arch/ia64/kernel/perfmon.c

   1 /*
   2  * This file implements the perfmon-2 subsystem which is used
   3  * to program the IA-64 Performance Monitoring Unit (PMU).
   4  *
   5  * The initial version of perfmon.c was written by
   6  * Ganesh Venkitachalam, IBM Corp.
   7  *
   8  * Then it was modified for perfmon-1.x by Stephane Eranian and
   9  * David Mosberger, Hewlett Packard Co.
  10  *
  11  * Version Perfmon-2.x is a rewrite of perfmon-1.x
  12  * by Stephane Eranian, Hewlett Packard Co.
  13  *
  14  * Copyright (C) 1999-2005  Hewlett Packard Co
  15  *               Stephane Eranian <eranian@hpl.hp.com>
  16  *               David Mosberger-Tang <davidm@hpl.hp.com>
  17  *
  18  * More information about perfmon available at:
  19  *      http://www.hpl.hp.com/research/linux/perfmon
  20  */
  21
  22 #include <linux/config.h>
  23 #include <linux/module.h>
  24 #include <linux/kernel.h>
  25 #include <linux/sched.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/smp_lock.h>
  28 #include <linux/proc_fs.h>
  29 #include <linux/seq_file.h>
  30 #include <linux/init.h>
  31 #include <linux/vmalloc.h>
  32 #include <linux/mm.h>
  33 #include <linux/sysctl.h>
  34 #include <linux/list.h>
  35 #include <linux/file.h>
  36 #include <linux/poll.h>
  37 #include <linux/vfs.h>
  38 #include <linux/pagemap.h>
  39 #include <linux/mount.h>
  40 #include <linux/bitops.h>
  41 #include <linux/capability.h>
  42 #include <linux/rcupdate.h>
  43 #include <linux/completion.h>
  44
  45 #include <asm/errno.h>
  46 #include <asm/intrinsics.h>
  47 #include <asm/page.h>
  48 #include <asm/perfmon.h>
  49 #include <asm/processor.h>
  50 #include <asm/signal.h>
  51 #include <asm/system.h>
  52 #include <asm/uaccess.h>
  53 #include <asm/delay.h>
  54
  55 #ifdef CONFIG_PERFMON
  56 /*
  57  * perfmon context state
  58  */
  59 #define PFM_CTX_UNLOADED        1       /* context is not loaded onto any task */
  60 #define PFM_CTX_LOADED          2       /* context is loaded onto a task */
  61 #define PFM_CTX_MASKED          3       /* context is loaded but monitoring is masked due to overflow */
  62 #define PFM_CTX_ZOMBIE          4       /* owner of the context is closing it */
  63
  64 #define PFM_INVALID_ACTIVATION  (~0UL)
  65
  66 /*
  67  * depth of message queue
  68  */
  69 #define PFM_MAX_MSGS            32
  70 #define PFM_CTXQ_EMPTY(g)       ((g)->ctx_msgq_head == (g)->ctx_msgq_tail)
  71
  72 /*
  73  * type of a PMU register (bitmask).
  74  * bitmask structure:
  75  *      bit0   : register implemented
  76  *      bit1   : end marker
  77  *      bit2-3 : reserved
  78  *      bit4   : pmc has pmc.pm
  79  *      bit5   : pmc controls a counter (has pmc.oi), pmd is used as counter
  80  *      bit6-7 : register type
  81  *      bit8-31: reserved
  82  */
  83 #define PFM_REG_NOTIMPL         0x0 /* not implemented at all */
  84 #define PFM_REG_IMPL            0x1 /* register implemented */
  85 #define PFM_REG_END             0x2 /* end marker */
  86 #define PFM_REG_MONITOR         (0x1<<4|PFM_REG_IMPL) /* a PMC with a pmc.pm field only */
  87 #define PFM_REG_COUNTING        (0x2<<4|PFM_REG_MONITOR) /* a monitor + pmc.oi+ PMD used as a counter */
  88 #define PFM_REG_CONTROL         (0x4<<4|PFM_REG_IMPL) /* PMU control register */
  89 #define PFM_REG_CONFIG          (0x8<<4|PFM_REG_IMPL) /* configuration register */
  90 #define PFM_REG_BUFFER          (0xc<<4|PFM_REG_IMPL) /* PMD used as buffer */
  91
  92 #define PMC_IS_LAST(i)  (pmu_conf->pmc_desc[i].type & PFM_REG_END)
  93 #define PMD_IS_LAST(i)  (pmu_conf->pmd_desc[i].type & PFM_REG_END)
  94
  95 #define PMC_OVFL_NOTIFY(ctx, i) ((ctx)->ctx_pmds[i].flags &  PFM_REGFL_OVFL_NOTIFY)
  96
  97 /* i assumed unsigned */
  98 #define PMC_IS_IMPL(i)    (i< PMU_MAX_PMCS && (pmu_conf->pmc_desc[i].type & PFM_REG_IMPL))
  99 #define PMD_IS_IMPL(i)    (i< PMU_MAX_PMDS && (pmu_conf->pmd_desc[i].type & PFM_REG_IMPL))
 100
 101 /* XXX: these assume that register i is implemented */
 102 #define PMD_IS_COUNTING(i) ((pmu_conf->pmd_desc[i].type & PFM_REG_COUNTING) == PFM_REG_COUNTING)
 103 #define PMC_IS_COUNTING(i) ((pmu_conf->pmc_desc[i].type & PFM_REG_COUNTING) == PFM_REG_COUNTING)
 104 #define PMC_IS_MONITOR(i)  ((pmu_conf->pmc_desc[i].type & PFM_REG_MONITOR)  == PFM_REG_MONITOR)
 105 #define PMC_IS_CONTROL(i)  ((pmu_conf->pmc_desc[i].type & PFM_REG_CONTROL)  == PFM_REG_CONTROL)
 106
 107 #define PMC_DFL_VAL(i)     pmu_conf->pmc_desc[i].default_value
 108 #define PMC_RSVD_MASK(i)   pmu_conf->pmc_desc[i].reserved_mask
 109 #define PMD_PMD_DEP(i)     pmu_conf->pmd_desc[i].dep_pmd[0]
 110 #define PMC_PMD_DEP(i)     pmu_conf->pmc_desc[i].dep_pmd[0]
 111
 112 #define PFM_NUM_IBRS      IA64_NUM_DBG_REGS
 113 #define PFM_NUM_DBRS      IA64_NUM_DBG_REGS
 114
 115 #define CTX_OVFL_NOBLOCK(c)     ((c)->ctx_fl_block == 0)
 116 #define CTX_HAS_SMPL(c)         ((c)->ctx_fl_is_sampling)
 117 #define PFM_CTX_TASK(h)         (h)->ctx_task
 118
 119 #define PMU_PMC_OI              5 /* position of pmc.oi bit */
 120
 121 /* XXX: does not support more than 64 PMDs */
 122 #define CTX_USED_PMD(ctx, mask) (ctx)->ctx_used_pmds[0] |= (mask)
 123 #define CTX_IS_USED_PMD(ctx, c) (((ctx)->ctx_used_pmds[0] & (1UL << (c))) != 0UL)
 124
 125 #define CTX_USED_MONITOR(ctx, mask) (ctx)->ctx_used_monitors[0] |= (mask)
 126
 127 #define CTX_USED_IBR(ctx,n)     (ctx)->ctx_used_ibrs[(n)>>6] |= 1UL<< ((n) % 64)
 128 #define CTX_USED_DBR(ctx,n)     (ctx)->ctx_used_dbrs[(n)>>6] |= 1UL<< ((n) % 64)
 129 #define CTX_USES_DBREGS(ctx)    (((pfm_context_t *)(ctx))->ctx_fl_using_dbreg==1)
 130 #define PFM_CODE_RR     0       /* requesting code range restriction */
 131 #define PFM_DATA_RR     1       /* requestion data range restriction */
 132
 133 #define PFM_CPUINFO_CLEAR(v)    pfm_get_cpu_var(pfm_syst_info) &= ~(v)
 134 #define PFM_CPUINFO_SET(v)      pfm_get_cpu_var(pfm_syst_info) |= (v)
 135 #define PFM_CPUINFO_GET()       pfm_get_cpu_var(pfm_syst_info)
 136
 137 #define RDEP(x) (1UL<<(x))
 138
 139 /*
 140  * context protection macros
 141  * in SMP:
 142  *      - we need to protect against CPU concurrency (spin_lock)
 143  *      - we need to protect against PMU overflow interrupts (local_irq_disable)
 144  * in UP:
 145  *      - we need to protect against PMU overflow interrupts (local_irq_disable)
 146  *
 147  * spin_lock_irqsave()/spin_lock_irqrestore():
 148  *      in SMP: local_irq_disable + spin_lock
 149  *      in UP : local_irq_disable
 150  *
 151  * spin_lock()/spin_lock():
 152  *      in UP : removed automatically
 153  *      in SMP: protect against context accesses from other CPU. interrupts
 154  *              are not masked. This is useful for the PMU interrupt handler
 155  *              because we know we will not get PMU concurrency in that code.
 156  */
 157 #define PROTECT_CTX(c, f) \
 158         do {  \
 159                 DPRINT(("spinlock_irq_save ctx %p by [%d]\n", c, current->pid)); \
 160                 spin_lock_irqsave(&(c)->ctx_lock, f); \
 161                 DPRINT(("spinlocked ctx %p  by [%d]\n", c, current->pid)); \
 162         } while(0)
 163
 164 #define UNPROTECT_CTX(c, f) \
 165         do { \
 166                 DPRINT(("spinlock_irq_restore ctx %p by [%d]\n", c, current->pid)); \
 167                 spin_unlock_irqrestore(&(c)->ctx_lock, f); \
 168         } while(0)
 169
 170 #define PROTECT_CTX_NOPRINT(c, f) \
 171         do {  \
 172                 spin_lock_irqsave(&(c)->ctx_lock, f); \
 173         } while(0)
 174
 175
 176 #define UNPROTECT_CTX_NOPRINT(c, f) \
 177         do { \
 178                 spin_unlock_irqrestore(&(c)->ctx_lock, f); \
 179         } while(0)
 180
 181
 182 #define PROTECT_CTX_NOIRQ(c) \
 183         do {  \
 184                 spin_lock(&(c)->ctx_lock); \
 185         } while(0)
 186
 187 #define UNPROTECT_CTX_NOIRQ(c) \
 188         do { \
 189                 spin_unlock(&(c)->ctx_lock); \
 190         } while(0)
 191
 192
 193 #ifdef CONFIG_SMP
 194
 195 #define GET_ACTIVATION()        pfm_get_cpu_var(pmu_activation_number)
 196 #define INC_ACTIVATION()        pfm_get_cpu_var(pmu_activation_number)++
 197 #define SET_ACTIVATION(c)       (c)->ctx_last_activation = GET_ACTIVATION()
 198
 199 #else /* !CONFIG_SMP */
 200 #define SET_ACTIVATION(t)       do {} while(0)
 201 #define GET_ACTIVATION(t)       do {} while(0)
 202 #define INC_ACTIVATION(t)       do {} while(0)
 203 #endif /* CONFIG_SMP */
 204
 205 #define SET_PMU_OWNER(t, c)     do { pfm_get_cpu_var(pmu_owner) = (t); pfm_get_cpu_var(pmu_ctx) = (c); } while(0)
 206 #define GET_PMU_OWNER()         pfm_get_cpu_var(pmu_owner)
 207 #define GET_PMU_CTX()           pfm_get_cpu_var(pmu_ctx)
 208
 209 #define LOCK_PFS(g)             spin_lock_irqsave(&pfm_sessions.pfs_lock, g)
 210 #define UNLOCK_PFS(g)           spin_unlock_irqrestore(&pfm_sessions.pfs_lock, g)
 211
 212 #define PFM_REG_RETFLAG_SET(flags, val) do { flags &= ~PFM_REG_RETFL_MASK; flags |= (val); } while(0)
 213
 214 /*
 215  * cmp0 must be the value of pmc0
 216  */
 217 #define PMC0_HAS_OVFL(cmp0)  (cmp0 & ~0x1UL)
 218
 219 #define PFMFS_MAGIC 0xa0b4d889
 220
 221 /*
 222  * debugging
 223  */
 224 #define PFM_DEBUGGING 1
 225 #ifdef PFM_DEBUGGING
 226 #define DPRINT(a) \
 227         do { \
 228                 if (unlikely(pfm_sysctl.debug >0)) { printk("%s.%d: CPU%d [%d] ", __FUNCTION__, __LINE__, smp_processor_id(), current->pid); printk a; } \
 229         } while (0)
 230
 231 #define DPRINT_ovfl(a) \
 232         do { \
 233                 if (unlikely(pfm_sysctl.debug > 0 && pfm_sysctl.debug_ovfl >0)) { printk("%s.%d: CPU%d [%d] ", __FUNCTION__, __LINE__, smp_processor_id(), current->pid); printk a; } \
 234         } while (0)
 235 #endif
 236
 237 /*
 238  * 64-bit software counter structure
 239  *
 240  * the next_reset_type is applied to the next call to pfm_reset_regs()
 241  */
 242 typedef struct {
 243         unsigned long   val;            /* virtual 64bit counter value */
 244         unsigned long   lval;           /* last reset value */
 245         unsigned long   long_reset;     /* reset value on sampling overflow */
 246         unsigned long   short_reset;    /* reset value on overflow */
 247         unsigned long   reset_pmds[4];  /* which other pmds to reset when this counter overflows */
 248         unsigned long   smpl_pmds[4];   /* which pmds are accessed when counter overflow */
 249         unsigned long   seed;           /* seed for random-number generator */
 250         unsigned long   mask;           /* mask for random-number generator */
 251         unsigned int    flags;          /* notify/do not notify */
 252         unsigned long   eventid;        /* overflow event identifier */
 253 } pfm_counter_t;
 254
 255 /*
 256  * context flags
 257  */
 258 typedef struct {
 259         unsigned int block:1;           /* when 1, task will blocked on user notifications */
 260         unsigned int system:1;          /* do system wide monitoring */
 261         unsigned int using_dbreg:1;     /* using range restrictions (debug registers) */
 262         unsigned int is_sampling:1;     /* true if using a custom format */
 263         unsigned int excl_idle:1;       /* exclude idle task in system wide session */
 264         unsigned int going_zombie:1;    /* context is zombie (MASKED+blocking) */
 265         unsigned int trap_reason:2;     /* reason for going into pfm_handle_work() */
 266         unsigned int no_msg:1;          /* no message sent on overflow */
 267         unsigned int can_restart:1;     /* allowed to issue a PFM_RESTART */
 268         unsigned int reserved:22;
 269 } pfm_context_flags_t;
 270
 271 #define PFM_TRAP_REASON_NONE            0x0     /* default value */
 272 #define PFM_TRAP_REASON_BLOCK           0x1     /* we need to block on overflow */
 273 #define PFM_TRAP_REASON_RESET           0x2     /* we need to reset PMDs */
 274
 275
 276 /*
 277  * perfmon context: encapsulates all the state of a monitoring session
 278  */
 279
 280 typedef struct pfm_context {
 281         spinlock_t              ctx_lock;               /* context protection */
 282
 283         pfm_context_flags_t     ctx_flags;              /* bitmask of flags  (block reason incl.) */
 284         unsigned int            ctx_state;              /* state: active/inactive (no bitfield) */
 285
 286         struct task_struct      *ctx_task;              /* task to which context is attached */
 287
 288         unsigned long           ctx_ovfl_regs[4];       /* which registers overflowed (notification) */
 289
 290         struct completion       ctx_restart_done;       /* use for blocking notification mode */
 291
 292         unsigned long           ctx_used_pmds[4];       /* bitmask of PMD used            */
 293         unsigned long           ctx_all_pmds[4];        /* bitmask of all accessible PMDs */
 294         unsigned long           ctx_reload_pmds[4];     /* bitmask of force reload PMD on ctxsw in */
 295
 296         unsigned long           ctx_all_pmcs[4];        /* bitmask of all accessible PMCs */
 297         unsigned long           ctx_reload_pmcs[4];     /* bitmask of force reload PMC on ctxsw in */
 298         unsigned long           ctx_used_monitors[4];   /* bitmask of monitor PMC being used */
 299
 300         unsigned long           ctx_pmcs[IA64_NUM_PMC_REGS];    /*  saved copies of PMC values */
 301
 302         unsigned int            ctx_used_ibrs[1];               /* bitmask of used IBR (speedup ctxsw in) */
 303         unsigned int            ctx_used_dbrs[1];               /* bitmask of used DBR (speedup ctxsw in) */
 304         unsigned long           ctx_dbrs[IA64_NUM_DBG_REGS];    /* DBR values (cache) when not loaded */
 305         unsigned long           ctx_ibrs[IA64_NUM_DBG_REGS];    /* IBR values (cache) when not loaded */
 306
 307         pfm_counter_t           ctx_pmds[IA64_NUM_PMD_REGS]; /* software state for PMDS */
 308
 309         u64                     ctx_saved_psr_up;       /* only contains psr.up value */
 310
 311         unsigned long           ctx_last_activation;    /* context last activation number for last_cpu */
 312         unsigned int            ctx_last_cpu;           /* CPU id of current or last CPU used (SMP only) */
 313         unsigned int            ctx_cpu;                /* cpu to which perfmon is applied (system wide) */
 314
 315         int                     ctx_fd;                 /* file descriptor used my this context */
 316         pfm_ovfl_arg_t          ctx_ovfl_arg;           /* argument to custom buffer format handler */
 317
 318         pfm_buffer_fmt_t        *ctx_buf_fmt;           /* buffer format callbacks */
 319         void                    *ctx_smpl_hdr;          /* points to sampling buffer header kernel vaddr */
 320         unsigned long           ctx_smpl_size;          /* size of sampling buffer */
 321         void                    *ctx_smpl_vaddr;        /* user level virtual address of smpl buffer */
 322
 323         wait_queue_head_t       ctx_msgq_wait;
 324         pfm_msg_t               ctx_msgq[PFM_MAX_MSGS];
 325         int                     ctx_msgq_head;
 326         int                     ctx_msgq_tail;
 327         struct fasync_struct    *ctx_async_queue;
 328
 329         wait_queue_head_t       ctx_zombieq;            /* termination cleanup wait queue */
 330 } pfm_context_t;
 331
 332 /*
 333  * magic number used to verify that structure is really
 334  * a perfmon context
 335  */
 336 #define PFM_IS_FILE(f)          ((f)->f_op == &pfm_file_ops)
 337
 338 #define PFM_GET_CTX(t)          ((pfm_context_t *)(t)->thread.pfm_context)
 339
 340 #ifdef CONFIG_SMP
 341 #define SET_LAST_CPU(ctx, v)    (ctx)->ctx_last_cpu = (v)
 342 #define GET_LAST_CPU(ctx)       (ctx)->ctx_last_cpu
 343 #else
 344 #define SET_LAST_CPU(ctx, v)    do {} while(0)
 345 #define GET_LAST_CPU(ctx)       do {} while(0)
 346 #endif
 347
 348
 349 #define ctx_fl_block            ctx_flags.block
 350 #define ctx_fl_system           ctx_flags.system
 351 #define ctx_fl_using_dbreg      ctx_flags.using_dbreg
 352 #define ctx_fl_is_sampling      ctx_flags.is_sampling
 353 #define ctx_fl_excl_idle        ctx_flags.excl_idle
 354 #define ctx_fl_going_zombie     ctx_flags.going_zombie
 355 #define ctx_fl_trap_reason      ctx_flags.trap_reason
 356 #define ctx_fl_no_msg           ctx_flags.no_msg
 357 #define ctx_fl_can_restart      ctx_flags.can_restart
 358
 359 #define PFM_SET_WORK_PENDING(t, v)      do { (t)->thread.pfm_needs_checking = v; } while(0);
 360 #define PFM_GET_WORK_PENDING(t)         (t)->thread.pfm_needs_checking
 361
 362 /*
 363  * global information about all sessions
 364  * mostly used to synchronize between system wide and per-process
 365  */
 366 typedef struct {
 367         spinlock_t              pfs_lock;                  /* lock the structure */
 368
 369         unsigned int            pfs_task_sessions;         /* number of per task sessions */
 370         unsigned int            pfs_sys_sessions;          /* number of per system wide sessions */
 371         unsigned int            pfs_sys_use_dbregs;        /* incremented when a system wide session uses debug regs */
 372         unsigned int            pfs_ptrace_use_dbregs;     /* incremented when a process uses debug regs */
 373         struct task_struct      *pfs_sys_session[NR_CPUS]; /* point to task owning a system-wide session */
 374 } pfm_session_t;
 375
 376 /*
 377  * information about a PMC or PMD.
 378  * dep_pmd[]: a bitmask of dependent PMD registers
 379  * dep_pmc[]: a bitmask of dependent PMC registers
 380  */
 381 typedef int (*pfm_reg_check_t)(struct task_struct *task, pfm_context_t *ctx, unsigned int cnum, unsigned long *val, struct pt_regs *regs);
 382 typedef struct {
 383         unsigned int            type;
 384         int                     pm_pos;
 385         unsigned long           default_value;  /* power-on default value */
 386         unsigned long           reserved_mask;  /* bitmask of reserved bits */
 387         pfm_reg_check_t         read_check;
 388         pfm_reg_check_t         write_check;
 389         unsigned long           dep_pmd[4];
 390         unsigned long           dep_pmc[4];
 391 } pfm_reg_desc_t;
 392
 393 /* assume cnum is a valid monitor */
 394 #define PMC_PM(cnum, val)       (((val) >> (pmu_conf->pmc_desc[cnum].pm_pos)) & 0x1)
 395
 396 /*
 397  * This structure is initialized at boot time and contains
 398  * a description of the PMU main characteristics.
 399  *
 400  * If the probe function is defined, detection is based
 401  * on its return value:
 402  *      - 0 means recognized PMU
 403  *      - anything else means not supported
 404  * When the probe function is not defined, then the pmu_family field
 405  * is used and it must match the host CPU family such that:
 406  *      - cpu->family & config->pmu_family != 0
 407  */
 408 typedef struct {
 409         unsigned long  ovfl_val;        /* overflow value for counters */
 410
 411         pfm_reg_desc_t *pmc_desc;       /* detailed PMC register dependencies descriptions */
 412         pfm_reg_desc_t *pmd_desc;       /* detailed PMD register dependencies descriptions */
 413
 414         unsigned int   num_pmcs;        /* number of PMCS: computed at init time */
 415         unsigned int   num_pmds;        /* number of PMDS: computed at init time */
 416         unsigned long  impl_pmcs[4];    /* bitmask of implemented PMCS */
 417         unsigned long  impl_pmds[4];    /* bitmask of implemented PMDS */
 418
 419         char          *pmu_name;        /* PMU family name */
 420         unsigned int  pmu_family;       /* cpuid family pattern used to identify pmu */
 421         unsigned int  flags;            /* pmu specific flags */
 422         unsigned int  num_ibrs;         /* number of IBRS: computed at init time */
 423         unsigned int  num_dbrs;         /* number of DBRS: computed at init time */
 424         unsigned int  num_counters;     /* PMC/PMD counting pairs : computed at init time */
 425         int           (*probe)(void);   /* customized probe routine */
 426         unsigned int  use_rr_dbregs:1;  /* set if debug registers used for range restriction */
 427 } pmu_config_t;
 428 /*
 429  * PMU specific flags
 430  */
 431 #define PFM_PMU_IRQ_RESEND      1       /* PMU needs explicit IRQ resend */
 432
 433 /*
 434  * debug register related type definitions
 435  */
 436 typedef struct {
 437         unsigned long ibr_mask:56;
 438         unsigned long ibr_plm:4;
 439         unsigned long ibr_ig:3;
 440         unsigned long ibr_x:1;
 441 } ibr_mask_reg_t;
 442
 443 typedef struct {
 444         unsigned long dbr_mask:56;
 445         unsigned long dbr_plm:4;
 446         unsigned long dbr_ig:2;
 447         unsigned long dbr_w:1;
 448         unsigned long dbr_r:1;
 449 } dbr_mask_reg_t;
 450
 451 typedef union {
 452         unsigned long  val;
 453         ibr_mask_reg_t ibr;
 454         dbr_mask_reg_t dbr;
 455 } dbreg_t;
 456
 457
 458 /*
 459  * perfmon command descriptions
 460  */
 461 typedef struct {
 462         int             (*cmd_func)(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs);
 463         char            *cmd_name;
 464         int             cmd_flags;
 465         unsigned int    cmd_narg;
 466         size_t          cmd_argsize;
 467         int             (*cmd_getsize)(void *arg, size_t *sz);
 468 } pfm_cmd_desc_t;
 469
 470 #define PFM_CMD_FD              0x01    /* command requires a file descriptor */
 471 #define PFM_CMD_ARG_READ        0x02    /* command must read argument(s) */
 472 #define PFM_CMD_ARG_RW          0x04    /* command must read/write argument(s) */
 473 #define PFM_CMD_STOP            0x08    /* command does not work on zombie context */
 474
 475
 476 #define PFM_CMD_NAME(cmd)       pfm_cmd_tab[(cmd)].cmd_name
 477 #define PFM_CMD_READ_ARG(cmd)   (pfm_cmd_tab[(cmd)].cmd_flags & PFM_CMD_ARG_READ)
 478 #define PFM_CMD_RW_ARG(cmd)     (pfm_cmd_tab[(cmd)].cmd_flags & PFM_CMD_ARG_RW)
 479 #define PFM_CMD_USE_FD(cmd)     (pfm_cmd_tab[(cmd)].cmd_flags & PFM_CMD_FD)
 480 #define PFM_CMD_STOPPED(cmd)    (pfm_cmd_tab[(cmd)].cmd_flags & PFM_CMD_STOP)
 481
 482 #define PFM_CMD_ARG_MANY        -1 /* cannot be zero */
 483
 484 typedef struct {
 485         unsigned long pfm_spurious_ovfl_intr_count;     /* keep track of spurious ovfl interrupts */
 486         unsigned long pfm_replay_ovfl_intr_count;       /* keep track of replayed ovfl interrupts */
 487         unsigned long pfm_ovfl_intr_count;              /* keep track of ovfl interrupts */
 488         unsigned long pfm_ovfl_intr_cycles;             /* cycles spent processing ovfl interrupts */
 489         unsigned long pfm_ovfl_intr_cycles_min;         /* min cycles spent processing ovfl interrupts */
 490         unsigned long pfm_ovfl_intr_cycles_max;         /* max cycles spent processing ovfl interrupts */
 491         unsigned long pfm_smpl_handler_calls;
 492         unsigned long pfm_smpl_handler_cycles;
 493         char pad[SMP_CACHE_BYTES] ____cacheline_aligned;
 494 } pfm_stats_t;
 495
 496 /*
 497  * perfmon internal variables
 498  */
 499 static pfm_stats_t              pfm_stats[NR_CPUS];
 500 static pfm_session_t            pfm_sessions;   /* global sessions information */
 501
 502 static DEFINE_SPINLOCK(pfm_alt_install_check);
 503 static pfm_intr_handler_desc_t  *pfm_alt_intr_handler;
 504
 505 static struct proc_dir_entry    *perfmon_dir;
 506 static pfm_uuid_t               pfm_null_uuid = {0,};
 507
 508 static spinlock_t               pfm_buffer_fmt_lock;
 509 static LIST_HEAD(pfm_buffer_fmt_list);
 510
 511 static pmu_config_t             *pmu_conf;
 512
 513 /* sysctl() controls */
 514 pfm_sysctl_t pfm_sysctl;
 515 EXPORT_SYMBOL(pfm_sysctl);
 516
 517 static ctl_table pfm_ctl_table[]={
 518         {1, "debug", &pfm_sysctl.debug, sizeof(int), 0666, NULL, &proc_dointvec, NULL,},
 519         {2, "debug_ovfl", &pfm_sysctl.debug_ovfl, sizeof(int), 0666, NULL, &proc_dointvec, NULL,},
 520         {3, "fastctxsw", &pfm_sysctl.fastctxsw, sizeof(int), 0600, NULL, &proc_dointvec, NULL,},
 521         {4, "expert_mode", &pfm_sysctl.expert_mode, sizeof(int), 0600, NULL, &proc_dointvec, NULL,},
 522         { 0, },
 523 };
 524 static ctl_table pfm_sysctl_dir[] = {
 525         {1, "perfmon", NULL, 0, 0755, pfm_ctl_table, },
 526         {0,},
 527 };
 528 static ctl_table pfm_sysctl_root[] = {
 529         {1, "kernel", NULL, 0, 0755, pfm_sysctl_dir, },
 530         {0,},
 531 };
 532 static struct ctl_table_header *pfm_sysctl_header;
 533
 534 static int pfm_context_unload(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs);
 535 static int pfm_flush(struct file *filp);
 536
 537 #define pfm_get_cpu_var(v)              __ia64_per_cpu_var(v)
 538 #define pfm_get_cpu_data(a,b)           per_cpu(a, b)
 539
 540 static inline void
 541 pfm_put_task(struct task_struct *task)
 542 {
 543         if (task != current) put_task_struct(task);
 544 }
 545
 546 static inline void
 547 pfm_set_task_notify(struct task_struct *task)
 548 {
 549         struct thread_info *info;
 550
 551         info = (struct thread_info *) ((char *) task + IA64_TASK_SIZE);
 552         set_bit(TIF_NOTIFY_RESUME, &info->flags);
 553 }
 554
 555 static inline void
 556 pfm_clear_task_notify(void)
 557 {
 558         clear_thread_flag(TIF_NOTIFY_RESUME);
 559 }
 560
 561 static inline void
 562 pfm_reserve_page(unsigned long a)
 563 {
 564         SetPageReserved(vmalloc_to_page((void *)a));
 565 }
 566 static inline void
 567 pfm_unreserve_page(unsigned long a)
 568 {
 569         ClearPageReserved(vmalloc_to_page((void*)a));
 570 }
 571
 572 static inline unsigned long
 573 pfm_protect_ctx_ctxsw(pfm_context_t *x)
 574 {
 575         spin_lock(&(x)->ctx_lock);
 576         return 0UL;
 577 }
 578
 579 static inline void
 580 pfm_unprotect_ctx_ctxsw(pfm_context_t *x, unsigned long f)
 581 {
 582         spin_unlock(&(x)->ctx_lock);
 583 }
 584
 585 static inline unsigned int
 586 pfm_do_munmap(struct mm_struct *mm, unsigned long addr, size_t len, int acct)
 587 {
 588         return do_munmap(mm, addr, len);
 589 }
 590
 591 static inline unsigned long
 592 pfm_get_unmapped_area(struct file *file, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags, unsigned long exec)
 593 {
 594         return get_unmapped_area(file, addr, len, pgoff, flags);
 595 }
 596
 597
 598 static struct super_block *
 599 pfmfs_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data)
 600 {
 601         return get_sb_pseudo(fs_type, "pfm:", NULL, PFMFS_MAGIC);
 602 }
 603
 604 static struct file_system_type pfm_fs_type = {
 605         .name     = "pfmfs",
 606         .get_sb   = pfmfs_get_sb,
 607         .kill_sb  = kill_anon_super,
 608 };
 609
 610 DEFINE_PER_CPU(unsigned long, pfm_syst_info);
 611 DEFINE_PER_CPU(struct task_struct *, pmu_owner);
 612 DEFINE_PER_CPU(pfm_context_t  *, pmu_ctx);
 613 DEFINE_PER_CPU(unsigned long, pmu_activation_number);
 614 EXPORT_PER_CPU_SYMBOL_GPL(pfm_syst_info);
 615
 616
 617 /* forward declaration */
 618 static struct file_operations pfm_file_ops;
 619
 620 /*
 621  * forward declarations
 622  */
 623 #ifndef CONFIG_SMP
 624 static void pfm_lazy_save_regs (struct task_struct *ta);
 625 #endif
 626
 627 void dump_pmu_state(const char *);
 628 static int pfm_write_ibr_dbr(int mode, pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs);
 629
 630 #include "perfmon_itanium.h"
 631 #include "perfmon_mckinley.h"
 632 #include "perfmon_montecito.h"
 633 #include "perfmon_generic.h"
 634
 635 static pmu_config_t *pmu_confs[]={
 636         &pmu_conf_mont,
 637         &pmu_conf_mck,
 638         &pmu_conf_ita,
 639         &pmu_conf_gen, /* must be last */
 640         NULL
 641 };
 642
 643
 644 static int pfm_end_notify_user(pfm_context_t *ctx);
 645
 646 static inline void
 647 pfm_clear_psr_pp(void)
 648 {
 649         ia64_rsm(IA64_PSR_PP);
 650         ia64_srlz_i();
 651 }
 652
 653 static inline void
 654 pfm_set_psr_pp(void)
 655 {
 656         ia64_ssm(IA64_PSR_PP);
 657         ia64_srlz_i();
 658 }
 659
 660 static inline void
 661 pfm_clear_psr_up(void)
 662 {
 663         ia64_rsm(IA64_PSR_UP);
 664         ia64_srlz_i();
 665 }
 666
 667 static inline void
 668 pfm_set_psr_up(void)
 669 {
 670         ia64_ssm(IA64_PSR_UP);
 671         ia64_srlz_i();
 672 }
 673
 674 static inline unsigned long
 675 pfm_get_psr(void)
 676 {
 677         unsigned long tmp;
 678         tmp = ia64_getreg(_IA64_REG_PSR);
 679         ia64_srlz_i();
 680         return tmp;
 681 }
 682
 683 static inline void
 684 pfm_set_psr_l(unsigned long val)
 685 {
 686         ia64_setreg(_IA64_REG_PSR_L, val);
 687         ia64_srlz_i();
 688 }
 689
 690 static inline void
 691 pfm_freeze_pmu(void)
 692 {
 693         ia64_set_pmc(0,1UL);
 694         ia64_srlz_d();
 695 }
 696
 697 static inline void
 698 pfm_unfreeze_pmu(void)
 699 {
 700         ia64_set_pmc(0,0UL);
 701         ia64_srlz_d();
 702 }
 703
 704 static inline void
 705 pfm_restore_ibrs(unsigned long *ibrs, unsigned int nibrs)
 706 {
 707         int i;
 708
 709         for (i=0; i < nibrs; i++) {
 710                 ia64_set_ibr(i, ibrs[i]);
 711                 ia64_dv_serialize_instruction();
 712         }
 713         ia64_srlz_i();
 714 }
 715
 716 static inline void
 717 pfm_restore_dbrs(unsigned long *dbrs, unsigned int ndbrs)
 718 {
 719         int i;
 720
 721         for (i=0; i < ndbrs; i++) {
 722                 ia64_set_dbr(i, dbrs[i]);
 723                 ia64_dv_serialize_data();
 724         }
 725         ia64_srlz_d();
 726 }
 727
 728 /*
 729  * PMD[i] must be a counter. no check is made
 730  */
 731 static inline unsigned long
 732 pfm_read_soft_counter(pfm_context_t *ctx, int i)
 733 {
 734         return ctx->ctx_pmds[i].val + (ia64_get_pmd(i) & pmu_conf->ovfl_val);
 735 }
 736
 737 /*
 738  * PMD[i] must be a counter. no check is made
 739  */
 740 static inline void
 741 pfm_write_soft_counter(pfm_context_t *ctx, int i, unsigned long val)
 742 {
 743         unsigned long ovfl_val = pmu_conf->ovfl_val;
 744
 745         ctx->ctx_pmds[i].val = val  & ~ovfl_val;
 746         /*
 747          * writing to unimplemented part is ignore, so we do not need to
 748          * mask off top part
 749          */
 750         ia64_set_pmd(i, val & ovfl_val);
 751 }
 752
 753 static pfm_msg_t *
 754 pfm_get_new_msg(pfm_context_t *ctx)
 755 {
 756         int idx, next;
 757
 758         next = (ctx->ctx_msgq_tail+1) % PFM_MAX_MSGS;
 759
 760         DPRINT(("ctx_fd=%p head=%d tail=%d\n", ctx, ctx->ctx_msgq_head, ctx->ctx_msgq_tail));
 761         if (next == ctx->ctx_msgq_head) return NULL;
 762
 763         idx =   ctx->ctx_msgq_tail;
 764         ctx->ctx_msgq_tail = next;
 765
 766         DPRINT(("ctx=%p head=%d tail=%d msg=%d\n", ctx, ctx->ctx_msgq_head, ctx->ctx_msgq_tail, idx));
 767
 768         return ctx->ctx_msgq+idx;
 769 }
 770
 771 static pfm_msg_t *
 772 pfm_get_next_msg(pfm_context_t *ctx)
 773 {
 774         pfm_msg_t *msg;
 775
 776         DPRINT(("ctx=%p head=%d tail=%d\n", ctx, ctx->ctx_msgq_head, ctx->ctx_msgq_tail));
 777
 778         if (PFM_CTXQ_EMPTY(ctx)) return NULL;
 779
 780         /*
 781          * get oldest message
 782          */
 783         msg = ctx->ctx_msgq+ctx->ctx_msgq_head;
 784
 785         /*
 786          * and move forward
 787          */
 788         ctx->ctx_msgq_head = (ctx->ctx_msgq_head+1) % PFM_MAX_MSGS;
 789
 790         DPRINT(("ctx=%p head=%d tail=%d type=%d\n", ctx, ctx->ctx_msgq_head, ctx->ctx_msgq_tail, msg->pfm_gen_msg.msg_type));
 791
 792         return msg;
 793 }
 794
 795 static void
 796 pfm_reset_msgq(pfm_context_t *ctx)
 797 {
 798         ctx->ctx_msgq_head = ctx->ctx_msgq_tail = 0;
 799         DPRINT(("ctx=%p msgq reset\n", ctx));
 800 }
 801
 802 static void *
 803 pfm_rvmalloc(unsigned long size)
 804 {
 805         void *mem;
 806         unsigned long addr;
 807
 808         size = PAGE_ALIGN(size);
 809         mem  = vmalloc(size);
 810         if (mem) {
 811                 //printk("perfmon: CPU%d pfm_rvmalloc(%ld)=%p\n", smp_processor_id(), size, mem);
 812                 memset(mem, 0, size);
 813                 addr = (unsigned long)mem;
 814                 while (size > 0) {
 815                         pfm_reserve_page(addr);
 816                         addr+=PAGE_SIZE;
 817                         size-=PAGE_SIZE;
 818                 }
 819         }
 820         return mem;
 821 }
 822
 823 static void
 824 pfm_rvfree(void *mem, unsigned long size)
 825 {
 826         unsigned long addr;
 827
 828         if (mem) {
 829                 DPRINT(("freeing physical buffer @%p size=%lu\n", mem, size));
 830                 addr = (unsigned long) mem;
 831                 while ((long) size > 0) {
 832                         pfm_unreserve_page(addr);
 833                         addr+=PAGE_SIZE;
 834                         size-=PAGE_SIZE;
 835                 }
 836                 vfree(mem);
 837         }
 838         return;
 839 }
 840
 841 static pfm_context_t *
 842 pfm_context_alloc(void)
 843 {
 844         pfm_context_t *ctx;
 845
 846         /*
 847          * allocate context descriptor
 848          * must be able to free with interrupts disabled
 849          */
 850         ctx = kmalloc(sizeof(pfm_context_t), GFP_KERNEL);
 851         if (ctx) {
 852                 memset(ctx, 0, sizeof(pfm_context_t));
 853                 DPRINT(("alloc ctx @%p\n", ctx));
 854         }
 855         return ctx;
 856 }
 857
 858 static void
 859 pfm_context_free(pfm_context_t *ctx)
 860 {
 861         if (ctx) {
 862                 DPRINT(("free ctx @%p\n", ctx));
 863                 kfree(ctx);
 864         }
 865 }
 866
 867 static void
 868 pfm_mask_monitoring(struct task_struct *task)
 869 {
 870         pfm_context_t *ctx = PFM_GET_CTX(task);
 871         struct thread_struct *th = &task->thread;
 872         unsigned long mask, val, ovfl_mask;
 873         int i;
 874
 875         DPRINT_ovfl(("masking monitoring for [%d]\n", task->pid));
 876
 877         ovfl_mask = pmu_conf->ovfl_val;
 878         /*
 879          * monitoring can only be masked as a result of a valid
 880          * counter overflow. In UP, it means that the PMU still
 881          * has an owner. Note that the owner can be different
 882          * from the current task. However the PMU state belongs
 883          * to the owner.
 884          * In SMP, a valid overflow only happens when task is
 885          * current. Therefore if we come here, we know that
 886          * the PMU state belongs to the current task, therefore
 887          * we can access the live registers.
 888          *
 889          * So in both cases, the live register contains the owner's
 890          * state. We can ONLY touch the PMU registers and NOT the PSR.
 891          *
 892          * As a consequence to this call, the thread->pmds[] array
 893          * contains stale information which must be ignored
 894          * when context is reloaded AND monitoring is active (see
 895          * pfm_restart).
 896          */
 897         mask = ctx->ctx_used_pmds[0];
 898         for (i = 0; mask; i++, mask>>=1) {
 899                 /* skip non used pmds */
 900                 if ((mask & 0x1) == 0) continue;
 901                 val = ia64_get_pmd(i);
 902
 903                 if (PMD_IS_COUNTING(i)) {
 904                         /*
 905                          * we rebuild the full 64 bit value of the counter
 906                          */
 907                         ctx->ctx_pmds[i].val += (val & ovfl_mask);
 908                 } else {
 909                         ctx->ctx_pmds[i].val = val;
 910                 }
 911                 DPRINT_ovfl(("pmd[%d]=0x%lx hw_pmd=0x%lx\n",
 912                         i,
 913                         ctx->ctx_pmds[i].val,
 914                         val & ovfl_mask));
 915         }
 916         /*
 917          * mask monitoring by setting the privilege level to 0
 918          * we cannot use psr.pp/psr.up for this, it is controlled by
 919          * the user
 920          *
 921          * if task is current, modify actual registers, otherwise modify
 922          * thread save state, i.e., what will be restored in pfm_load_regs()
 923          */
 924         mask = ctx->ctx_used_monitors[0] >> PMU_FIRST_COUNTER;
 925         for(i= PMU_FIRST_COUNTER; mask; i++, mask>>=1) {
 926                 if ((mask & 0x1) == 0UL) continue;
 927                 ia64_set_pmc(i, th->pmcs[i] & ~0xfUL);
 928                 th->pmcs[i] &= ~0xfUL;
 929                 DPRINT_ovfl(("pmc[%d]=0x%lx\n", i, th->pmcs[i]));
 930         }
 931         /*
 932          * make all of this visible
 933          */
 934         ia64_srlz_d();
 935 }
 936
 937 /*
 938  * must always be done with task == current
 939  *
 940  * context must be in MASKED state when calling
 941  */
 942 static void
 943 pfm_restore_monitoring(struct task_struct *task)
 944 {
 945         pfm_context_t *ctx = PFM_GET_CTX(task);
 946         struct thread_struct *th = &task->thread;
 947         unsigned long mask, ovfl_mask;
 948         unsigned long psr, val;
 949         int i, is_system;
 950
 951         is_system = ctx->ctx_fl_system;
 952         ovfl_mask = pmu_conf->ovfl_val;
 953
 954         if (task != current) {
 955                 printk(KERN_ERR "perfmon.%d: invalid task[%d] current[%d]\n", __LINE__, task->pid, current->pid);
 956                 return;
 957         }
 958         if (ctx->ctx_state != PFM_CTX_MASKED) {
 959                 printk(KERN_ERR "perfmon.%d: task[%d] current[%d] invalid state=%d\n", __LINE__,
 960                         task->pid, current->pid, ctx->ctx_state);
 961                 return;
 962         }
 963         psr = pfm_get_psr();
 964         /*
 965          * monitoring is masked via the PMC.
 966          * As we restore their value, we do not want each counter to
 967          * restart right away. We stop monitoring using the PSR,
 968          * restore the PMC (and PMD) and then re-establish the psr
 969          * as it was. Note that there can be no pending overflow at
 970          * this point, because monitoring was MASKED.
 971          *
 972          * system-wide session are pinned and self-monitoring
 973          */
 974         if (is_system && (PFM_CPUINFO_GET() & PFM_CPUINFO_DCR_PP)) {
 975                 /* disable dcr pp */
 976                 ia64_setreg(_IA64_REG_CR_DCR, ia64_getreg(_IA64_REG_CR_DCR) & ~IA64_DCR_PP);
 977                 pfm_clear_psr_pp();
 978         } else {
 979                 pfm_clear_psr_up();
 980         }
 981         /*
 982          * first, we restore the PMD
 983          */
 984         mask = ctx->ctx_used_pmds[0];
 985         for (i = 0; mask; i++, mask>>=1) {
 986                 /* skip non used pmds */
 987                 if ((mask & 0x1) == 0) continue;
 988
 989                 if (PMD_IS_COUNTING(i)) {
 990                         /*
 991                          * we split the 64bit value according to
 992                          * counter width
 993                          */
 994                         val = ctx->ctx_pmds[i].val & ovfl_mask;
 995                         ctx->ctx_pmds[i].val &= ~ovfl_mask;
 996                 } else {
 997                         val = ctx->ctx_pmds[i].val;
 998                 }
 999                 ia64_set_pmd(i, val);
1000
1001                 DPRINT(("pmd[%d]=0x%lx hw_pmd=0x%lx\n",
1002                         i,
1003                         ctx->ctx_pmds[i].val,
1004                         val));
1005         }
1006         /*
1007          * restore the PMCs
1008          */
1009         mask = ctx->ctx_used_monitors[0] >> PMU_FIRST_COUNTER;
1010         for(i= PMU_FIRST_COUNTER; mask; i++, mask>>=1) {
1011                 if ((mask & 0x1) == 0UL) continue;
1012                 th->pmcs[i] = ctx->ctx_pmcs[i];
1013                 ia64_set_pmc(i, th->pmcs[i]);
1014                 DPRINT(("[%d] pmc[%d]=0x%lx\n", task->pid, i, th->pmcs[i]));
1015         }
1016         ia64_srlz_d();
1017
1018         /*
1019          * must restore DBR/IBR because could be modified while masked
1020          * XXX: need to optimize
1021          */
1022         if (ctx->ctx_fl_using_dbreg) {
1023                 pfm_restore_ibrs(ctx->ctx_ibrs, pmu_conf->num_ibrs);
1024                 pfm_restore_dbrs(ctx->ctx_dbrs, pmu_conf->num_dbrs);
1025         }
1026
1027         /*
1028          * now restore PSR
1029          */
1030         if (is_system && (PFM_CPUINFO_GET() & PFM_CPUINFO_DCR_PP)) {
1031                 /* enable dcr pp */
1032                 ia64_setreg(_IA64_REG_CR_DCR, ia64_getreg(_IA64_REG_CR_DCR) | IA64_DCR_PP);
1033                 ia64_srlz_i();
1034         }
1035         pfm_set_psr_l(psr);
1036 }
1037
1038 static inline void
1039 pfm_save_pmds(unsigned long *pmds, unsigned long mask)
1040 {
1041         int i;
1042
1043         ia64_srlz_d();
1044
1045         for (i=0; mask; i++, mask>>=1) {
1046                 if (mask & 0x1) pmds[i] = ia64_get_pmd(i);
1047         }
1048 }
1049
1050 /*
1051  * reload from thread state (used for ctxw only)
1052  */
1053 static inline void
1054 pfm_restore_pmds(unsigned long *pmds, unsigned long mask)
1055 {
1056         int i;
1057         unsigned long val, ovfl_val = pmu_conf->ovfl_val;
1058
1059         for (i=0; mask; i++, mask>>=1) {
1060                 if ((mask & 0x1) == 0) continue;
1061                 val = PMD_IS_COUNTING(i) ? pmds[i] & ovfl_val : pmds[i];
1062                 ia64_set_pmd(i, val);
1063         }
1064         ia64_srlz_d();
1065 }
1066
1067 /*
1068  * propagate PMD from context to thread-state
1069  */
1070 static inline void
1071 pfm_copy_pmds(struct task_struct *task, pfm_context_t *ctx)
1072 {
1073         struct thread_struct *thread = &task->thread;
1074         unsigned long ovfl_val = pmu_conf->ovfl_val;
1075         unsigned long mask = ctx->ctx_all_pmds[0];
1076         unsigned long val;
1077         int i;
1078
1079         DPRINT(("mask=0x%lx\n", mask));
1080
1081         for (i=0; mask; i++, mask>>=1) {
1082
1083                 val = ctx->ctx_pmds[i].val;
1084
1085                 /*
1086                  * We break up the 64 bit value into 2 pieces
1087                  * the lower bits go to the machine state in the
1088                  * thread (will be reloaded on ctxsw in).
1089                  * The upper part stays in the soft-counter.
1090                  */
1091                 if (PMD_IS_COUNTING(i)) {
1092                         ctx->ctx_pmds[i].val = val & ~ovfl_val;
1093                          val &= ovfl_val;
1094                 }
1095                 thread->pmds[i] = val;
1096
1097                 DPRINT(("pmd[%d]=0x%lx soft_val=0x%lx\n",
1098                         i,
1099                         thread->pmds[i],
1100                         ctx->ctx_pmds[i].val));
1101         }
1102 }
1103
1104 /*
1105  * propagate PMC from context to thread-state
1106  */
1107 static inline void
1108 pfm_copy_pmcs(struct task_struct *task, pfm_context_t *ctx)
1109 {
1110         struct thread_struct *thread = &task->thread;
1111         unsigned long mask = ctx->ctx_all_pmcs[0];
1112         int i;
1113
1114         DPRINT(("mask=0x%lx\n", mask));
1115
1116         for (i=0; mask; i++, mask>>=1) {
1117                 /* masking 0 with ovfl_val yields 0 */
1118                 thread->pmcs[i] = ctx->ctx_pmcs[i];
1119                 DPRINT(("pmc[%d]=0x%lx\n", i, thread->pmcs[i]));
1120         }
1121 }
1122
1123
1124
1125 static inline void
1126 pfm_restore_pmcs(unsigned long *pmcs, unsigned long mask)
1127 {
1128         int i;
1129
1130         for (i=0; mask; i++, mask>>=1) {
1131                 if ((mask & 0x1) == 0) continue;
1132                 ia64_set_pmc(i, pmcs[i]);
1133         }
1134         ia64_srlz_d();
1135 }
1136
1137 static inline int
1138 pfm_uuid_cmp(pfm_uuid_t a, pfm_uuid_t b)
1139 {
1140         return memcmp(a, b, sizeof(pfm_uuid_t));
1141 }
1142
1143 static inline int
1144 pfm_buf_fmt_exit(pfm_buffer_fmt_t *fmt, struct task_struct *task, void *buf, struct pt_regs *regs)
1145 {
1146         int ret = 0;
1147         if (fmt->fmt_exit) ret = (*fmt->fmt_exit)(task, buf, regs);
1148         return ret;
1149 }
1150
1151 static inline int
1152 pfm_buf_fmt_getsize(pfm_buffer_fmt_t *fmt, struct task_struct *task, unsigned int flags, int cpu, void *arg, unsigned long *size)
1153 {
1154         int ret = 0;
1155         if (fmt->fmt_getsize) ret = (*fmt->fmt_getsize)(task, flags, cpu, arg, size);
1156         return ret;
1157 }
1158
1159
1160 static inline int
1161 pfm_buf_fmt_validate(pfm_buffer_fmt_t *fmt, struct task_struct *task, unsigned int flags,
1162                      int cpu, void *arg)
1163 {
1164         int ret = 0;
1165         if (fmt->fmt_validate) ret = (*fmt->fmt_validate)(task, flags, cpu, arg);
1166         return ret;
1167 }
1168
1169 static inline int
1170 pfm_buf_fmt_init(pfm_buffer_fmt_t *fmt, struct task_struct *task, void *buf, unsigned int flags,
1171                      int cpu, void *arg)
1172 {
1173         int ret = 0;
1174         if (fmt->fmt_init) ret = (*fmt->fmt_init)(task, buf, flags, cpu, arg);
1175         return ret;
1176 }
1177
1178 static inline int
1179 pfm_buf_fmt_restart(pfm_buffer_fmt_t *fmt, struct task_struct *task, pfm_ovfl_ctrl_t *ctrl, void *buf, struct pt_regs *regs)
1180 {
1181         int ret = 0;
1182         if (fmt->fmt_restart) ret = (*fmt->fmt_restart)(task, ctrl, buf, regs);
1183         return ret;
1184 }
1185
1186 static inline int
1187 pfm_buf_fmt_restart_active(pfm_buffer_fmt_t *fmt, struct task_struct *task, pfm_ovfl_ctrl_t *ctrl, void *buf, struct pt_regs *regs)
1188 {
1189         int ret = 0;
1190         if (fmt->fmt_restart_active) ret = (*fmt->fmt_restart_active)(task, ctrl, buf, regs);
1191         return ret;
1192 }
1193
1194 static pfm_buffer_fmt_t *
1195 __pfm_find_buffer_fmt(pfm_uuid_t uuid)
1196 {
1197         struct list_head * pos;
1198         pfm_buffer_fmt_t * entry;
1199
1200         list_for_each(pos, &pfm_buffer_fmt_list) {
1201                 entry = list_entry(pos, pfm_buffer_fmt_t, fmt_list);
1202                 if (pfm_uuid_cmp(uuid, entry->fmt_uuid) == 0)
1203                         return entry;
1204         }
1205         return NULL;
1206 }
1207
1208 /*
1209  * find a buffer format based on its uuid
1210  */
1211 static pfm_buffer_fmt_t *
1212 pfm_find_buffer_fmt(pfm_uuid_t uuid)
1213 {
1214         pfm_buffer_fmt_t * fmt;
1215         spin_lock(&pfm_buffer_fmt_lock);
1216         fmt = __pfm_find_buffer_fmt(uuid);
1217         spin_unlock(&pfm_buffer_fmt_lock);
1218         return fmt;
1219 }
1220
1221 int
1222 pfm_register_buffer_fmt(pfm_buffer_fmt_t *fmt)
1223 {
1224         int ret = 0;
1225
1226         /* some sanity checks */
1227         if (fmt == NULL || fmt->fmt_name == NULL) return -EINVAL;
1228
1229         /* we need at least a handler */
1230         if (fmt->fmt_handler == NULL) return -EINVAL;
1231
1232         /*
1233          * XXX: need check validity of fmt_arg_size
1234          */
1235
1236         spin_lock(&pfm_buffer_fmt_lock);
1237
1238         if (__pfm_find_buffer_fmt(fmt->fmt_uuid)) {
1239                 printk(KERN_ERR "perfmon: duplicate sampling format: %s\n", fmt->fmt_name);
1240                 ret = -EBUSY;
1241                 goto out;
1242         }
1243         list_add(&fmt->fmt_list, &pfm_buffer_fmt_list);
1244         printk(KERN_INFO "perfmon: added sampling format %s\n", fmt->fmt_name);
1245
1246 out:
1247         spin_unlock(&pfm_buffer_fmt_lock);
1248         return ret;
1249 }
1250 EXPORT_SYMBOL(pfm_register_buffer_fmt);
1251
1252 int
1253 pfm_unregister_buffer_fmt(pfm_uuid_t uuid)
1254 {
1255         pfm_buffer_fmt_t *fmt;
1256         int ret = 0;
1257
1258         spin_lock(&pfm_buffer_fmt_lock);
1259
1260         fmt = __pfm_find_buffer_fmt(uuid);
1261         if (!fmt) {
1262                 printk(KERN_ERR "perfmon: cannot unregister format, not found\n");
1263                 ret = -EINVAL;
1264                 goto out;
1265         }
1266         list_del_init(&fmt->fmt_list);
1267         printk(KERN_INFO "perfmon: removed sampling format: %s\n", fmt->fmt_name);
1268
1269 out:
1270         spin_unlock(&pfm_buffer_fmt_lock);
1271         return ret;
1272
1273 }
1274 EXPORT_SYMBOL(pfm_unregister_buffer_fmt);
1275
1276 extern void update_pal_halt_status(int);
1277
1278 static int
1279 pfm_reserve_session(struct task_struct *task, int is_syswide, unsigned int cpu)
1280 {
1281         unsigned long flags;
1282         /*
1283          * validy checks on cpu_mask have been done upstream
1284          */
1285         LOCK_PFS(flags);
1286
1287         DPRINT(("in sys_sessions=%u task_sessions=%u dbregs=%u syswide=%d cpu=%u\n",
1288                 pfm_sessions.pfs_sys_sessions,
1289                 pfm_sessions.pfs_task_sessions,
1290                 pfm_sessions.pfs_sys_use_dbregs,
1291                 is_syswide,
1292                 cpu));
1293
1294         if (is_syswide) {
1295                 /*
1296                  * cannot mix system wide and per-task sessions
1297                  */
1298                 if (pfm_sessions.pfs_task_sessions > 0UL) {
1299                         DPRINT(("system wide not possible, %u conflicting task_sessions\n",
1300                                 pfm_sessions.pfs_task_sessions));
1301                         goto abort;
1302                 }
1303
1304                 if (pfm_sessions.pfs_sys_session[cpu]) goto error_conflict;
1305
1306                 DPRINT(("reserving system wide session on CPU%u currently on CPU%u\n", cpu, smp_processor_id()));
1307
1308                 pfm_sessions.pfs_sys_session[cpu] = task;
1309
1310                 pfm_sessions.pfs_sys_sessions++ ;
1311
1312         } else {
1313                 if (pfm_sessions.pfs_sys_sessions) goto abort;
1314                 pfm_sessions.pfs_task_sessions++;
1315         }
1316
1317         DPRINT(("out sys_sessions=%u task_sessions=%u dbregs=%u syswide=%d cpu=%u\n",
1318                 pfm_sessions.pfs_sys_sessions,
1319                 pfm_sessions.pfs_task_sessions,
1320                 pfm_sessions.pfs_sys_use_dbregs,
1321                 is_syswide,
1322                 cpu));
1323
1324         /*
1325          * disable default_idle() to go to PAL_HALT
1326          */
1327         update_pal_halt_status(0);
1328
1329         UNLOCK_PFS(flags);
1330
1331         return 0;
1332
1333 error_conflict:
1334         DPRINT(("system wide not possible, conflicting session [%d] on CPU%d\n",
1335                 pfm_sessions.pfs_sys_session[cpu]->pid,
1336                 cpu));
1337 abort:
1338         UNLOCK_PFS(flags);
1339
1340         return -EBUSY;
1341
1342 }
1343
1344 static int
1345 pfm_unreserve_session(pfm_context_t *ctx, int is_syswide, unsigned int cpu)
1346 {
1347         unsigned long flags;
1348         /*
1349          * validy checks on cpu_mask have been done upstream
1350          */
1351         LOCK_PFS(flags);
1352
1353         DPRINT(("in sys_sessions=%u task_sessions=%u dbregs=%u syswide=%d cpu=%u\n",
1354                 pfm_sessions.pfs_sys_sessions,
1355                 pfm_sessions.pfs_task_sessions,
1356                 pfm_sessions.pfs_sys_use_dbregs,
1357                 is_syswide,
1358                 cpu));
1359
1360
1361         if (is_syswide) {
1362                 pfm_sessions.pfs_sys_session[cpu] = NULL;
1363                 /*
1364                  * would not work with perfmon+more than one bit in cpu_mask
1365                  */
1366                 if (ctx && ctx->ctx_fl_using_dbreg) {
1367                         if (pfm_sessions.pfs_sys_use_dbregs == 0) {
1368                                 printk(KERN_ERR "perfmon: invalid release for ctx %p sys_use_dbregs=0\n", ctx);
1369                         } else {
1370                                 pfm_sessions.pfs_sys_use_dbregs--;
1371                         }
1372                 }
1373                 pfm_sessions.pfs_sys_sessions--;
1374         } else {
1375                 pfm_sessions.pfs_task_sessions--;
1376         }
1377         DPRINT(("out sys_sessions=%u task_sessions=%u dbregs=%u syswide=%d cpu=%u\n",
1378                 pfm_sessions.pfs_sys_sessions,
1379                 pfm_sessions.pfs_task_sessions,
1380                 pfm_sessions.pfs_sys_use_dbregs,
1381                 is_syswide,
1382                 cpu));
1383
1384         /*
1385          * if possible, enable default_idle() to go into PAL_HALT
1386          */
1387         if (pfm_sessions.pfs_task_sessions == 0 && pfm_sessions.pfs_sys_sessions == 0)
1388                 update_pal_halt_status(1);
1389
1390         UNLOCK_PFS(flags);
1391
1392         return 0;
1393 }
1394
1395 /*
1396  * removes virtual mapping of the sampling buffer.
1397  * IMPORTANT: cannot be called with interrupts disable, e.g. inside
1398  * a PROTECT_CTX() section.
1399  */
1400 static int
1401 pfm_remove_smpl_mapping(struct task_struct *task, void *vaddr, unsigned long size)
1402 {
1403         int r;
1404
1405         /* sanity checks */
1406         if (task->mm == NULL || size == 0UL || vaddr == NULL) {
1407                 printk(KERN_ERR "perfmon: pfm_remove_smpl_mapping [%d] invalid context mm=%p\n", task->pid, task->mm);
1408                 return -EINVAL;
1409         }
1410
1411         DPRINT(("smpl_vaddr=%p size=%lu\n", vaddr, size));
1412
1413         /*
1414          * does the actual unmapping
1415          */
1416         down_write(&task->mm->mmap_sem);
1417
1418         DPRINT(("down_write done smpl_vaddr=%p size=%lu\n", vaddr, size));
1419
1420         r = pfm_do_munmap(task->mm, (unsigned long)vaddr, size, 0);
1421
1422         up_write(&task->mm->mmap_sem);
1423         if (r !=0) {
1424                 printk(KERN_ERR "perfmon: [%d] unable to unmap sampling buffer @%p size=%lu\n", task->pid, vaddr, size);
1425         }
1426
1427         DPRINT(("do_unmap(%p, %lu)=%d\n", vaddr, size, r));
1428
1429         return 0;
1430 }
1431
1432 /*
1433  * free actual physical storage used by sampling buffer
1434  */
1435 #if 0
1436 static int
1437 pfm_free_smpl_buffer(pfm_context_t *ctx)
1438 {
1439         pfm_buffer_fmt_t *fmt;
1440
1441         if (ctx->ctx_smpl_hdr == NULL) goto invalid_free;
1442
1443         /*
1444          * we won't use the buffer format anymore
1445          */
1446         fmt = ctx->ctx_buf_fmt;
1447
1448         DPRINT(("sampling buffer @%p size %lu vaddr=%p\n",
1449                 ctx->ctx_smpl_hdr,
1450                 ctx->ctx_smpl_size,
1451                 ctx->ctx_smpl_vaddr));
1452
1453         pfm_buf_fmt_exit(fmt, current, NULL, NULL);
1454
1455         /*
1456          * free the buffer
1457          */
1458         pfm_rvfree(ctx->ctx_smpl_hdr, ctx->ctx_smpl_size);
1459
1460         ctx->ctx_smpl_hdr  = NULL;
1461         ctx->ctx_smpl_size = 0UL;
1462
1463         return 0;
1464
1465 invalid_free:
1466         printk(KERN_ERR "perfmon: pfm_free_smpl_buffer [%d] no buffer\n", current->pid);
1467         return -EINVAL;
1468 }
1469 #endif
1470
1471 static inline void
1472 pfm_exit_smpl_buffer(pfm_buffer_fmt_t *fmt)
1473 {
1474         if (fmt == NULL) return;
1475
1476         pfm_buf_fmt_exit(fmt, current, NULL, NULL);
1477
1478 }
1479
1480 /*
1481  * pfmfs should _never_ be mounted by userland - too much of security hassle,
1482  * no real gain from having the whole whorehouse mounted. So we don't need
1483  * any operations on the root directory. However, we need a non-trivial
1484  * d_name - pfm: will go nicely and kill the special-casing in procfs.
1485  */
1486 static struct vfsmount *pfmfs_mnt;
1487
1488 static int __init
1489 init_pfm_fs(void)
1490 {
1491         int err = register_filesystem(&pfm_fs_type);
1492         if (!err) {
1493                 pfmfs_mnt = kern_mount(&pfm_fs_type);
1494                 err = PTR_ERR(pfmfs_mnt);
1495                 if (IS_ERR(pfmfs_mnt))
1496                         unregister_filesystem(&pfm_fs_type);
1497                 else
1498                         err = 0;
1499         }
1500         return err;
1501 }
1502
1503 static void __exit
1504 exit_pfm_fs(void)
1505 {
1506         unregister_filesystem(&pfm_fs_type);
1507         mntput(pfmfs_mnt);
1508 }
1509
1510 static ssize_t
1511 pfm_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
1512 {
1513         pfm_context_t *ctx;
1514         pfm_msg_t *msg;
1515         ssize_t ret;
1516         unsigned long flags;
1517         DECLARE_WAITQUEUE(wait, current);
1518         if (PFM_IS_FILE(filp) == 0) {
1519                 printk(KERN_ERR "perfmon: pfm_poll: bad magic [%d]\n", current->pid);
1520                 return -EINVAL;
1521         }
1522
1523         ctx = (pfm_context_t *)filp->private_data;
1524         if (ctx == NULL) {
1525                 printk(KERN_ERR "perfmon: pfm_read: NULL ctx [%d]\n", current->pid);
1526                 return -EINVAL;
1527         }
1528
1529         /*
1530          * check even when there is no message
1531          */
1532         if (size < sizeof(pfm_msg_t)) {
1533                 DPRINT(("message is too small ctx=%p (>=%ld)\n", ctx, sizeof(pfm_msg_t)));
1534                 return -EINVAL;
1535         }
1536
1537         PROTECT_CTX(ctx, flags);
1538
1539         /*
1540          * put ourselves on the wait queue
1541          */
1542         add_wait_queue(&ctx->ctx_msgq_wait, &wait);
1543
1544
1545         for(;;) {
1546                 /*
1547                  * check wait queue
1548                  */
1549
1550                 set_current_state(TASK_INTERRUPTIBLE);
1551
1552                 DPRINT(("head=%d tail=%d\n", ctx->ctx_msgq_head, ctx->ctx_msgq_tail));
1553
1554                 ret = 0;
1555                 if(PFM_CTXQ_EMPTY(ctx) == 0) break;
1556
1557                 UNPROTECT_CTX(ctx, flags);
1558
1559                 /*
1560                  * check non-blocking read
1561                  */
1562                 ret = -EAGAIN;
1563                 if(filp->f_flags & O_NONBLOCK) break;
1564
1565                 /*
1566                  * check pending signals
1567                  */
1568                 if(signal_pending(current)) {
1569                         ret = -EINTR;
1570                         break;
1571                 }
1572                 /*
1573                  * no message, so wait
1574                  */
1575                 schedule();
1576
1577                 PROTECT_CTX(ctx, flags);
1578         }
1579         DPRINT(("[%d] back to running ret=%ld\n", current->pid, ret));
1580         set_current_state(TASK_RUNNING);
1581         remove_wait_queue(&ctx->ctx_msgq_wait, &wait);
1582
1583         if (ret < 0) goto abort;
1584
1585         ret = -EINVAL;
1586         msg = pfm_get_next_msg(ctx);
1587         if (msg == NULL) {
1588                 printk(KERN_ERR "perfmon: pfm_read no msg for ctx=%p [%d]\n", ctx, current->pid);
1589                 goto abort_locked;
1590         }
1591
1592         DPRINT(("fd=%d type=%d\n", msg->pfm_gen_msg.msg_ctx_fd, msg->pfm_gen_msg.msg_type));
1593
1594         ret = -EFAULT;
1595         if(copy_to_user(buf, msg, sizeof(pfm_msg_t)) == 0) ret = sizeof(pfm_msg_t);
1596
1597 abort_locked:
1598         UNPROTECT_CTX(ctx, flags);
1599 abort:
1600         return ret;
1601 }
1602
1603 static ssize_t
1604 pfm_write(struct file *file, const char __user *ubuf,
1605                           size_t size, loff_t *ppos)
1606 {
1607         DPRINT(("pfm_write called\n"));
1608         return -EINVAL;
1609 }
1610
1611 static unsigned int
1612 pfm_poll(struct file *filp, poll_table * wait)
1613 {
1614         pfm_context_t *ctx;
1615         unsigned long flags;
1616         unsigned int mask = 0;
1617
1618         if (PFM_IS_FILE(filp) == 0) {
1619                 printk(KERN_ERR "perfmon: pfm_poll: bad magic [%d]\n", current->pid);
1620                 return 0;
1621         }
1622
1623         ctx = (pfm_context_t *)filp->private_data;
1624         if (ctx == NULL) {
1625                 printk(KERN_ERR "perfmon: pfm_poll: NULL ctx [%d]\n", current->pid);
1626                 return 0;
1627         }
1628
1629
1630         DPRINT(("pfm_poll ctx_fd=%d before poll_wait\n", ctx->ctx_fd));
1631
1632         poll_wait(filp, &ctx->ctx_msgq_wait, wait);
1633
1634         PROTECT_CTX(ctx, flags);
1635
1636         if (PFM_CTXQ_EMPTY(ctx) == 0)
1637                 mask =  POLLIN | POLLRDNORM;
1638
1639         UNPROTECT_CTX(ctx, flags);
1640
1641         DPRINT(("pfm_poll ctx_fd=%d mask=0x%x\n", ctx->ctx_fd, mask));
1642
1643         return mask;
1644 }
1645
1646 static int
1647 pfm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1648 {
1649         DPRINT(("pfm_ioctl called\n"));
1650         return -EINVAL;
1651 }
1652
1653 /*
1654  * interrupt cannot be masked when coming here
1655  */
1656 static inline int
1657 pfm_do_fasync(int fd, struct file *filp, pfm_context_t *ctx, int on)
1658 {
1659         int ret;
1660
1661         ret = fasync_helper (fd, filp, on, &ctx->ctx_async_queue);
1662
1663         DPRINT(("pfm_fasync called by [%d] on ctx_fd=%d on=%d async_queue=%p ret=%d\n",
1664                 current->pid,
1665                 fd,
1666                 on,
1667                 ctx->ctx_async_queue, ret));
1668
1669         return ret;
1670 }
1671
1672 static int
1673 pfm_fasync(int fd, struct file *filp, int on)
1674 {
1675         pfm_context_t *ctx;
1676         int ret;
1677
1678         if (PFM_IS_FILE(filp) == 0) {
1679                 printk(KERN_ERR "perfmon: pfm_fasync bad magic [%d]\n", current->pid);
1680                 return -EBADF;
1681         }
1682
1683         ctx = (pfm_context_t *)filp->private_data;
1684         if (ctx == NULL) {
1685                 printk(KERN_ERR "perfmon: pfm_fasync NULL ctx [%d]\n", current->pid);
1686                 return -EBADF;
1687         }
1688         /*
1689          * we cannot mask interrupts during this call because this may
1690          * may go to sleep if memory is not readily avalaible.
1691          *
1692          * We are protected from the conetxt disappearing by the get_fd()/put_fd()
1693          * done in caller. Serialization of this function is ensured by caller.
1694          */
1695         ret = pfm_do_fasync(fd, filp, ctx, on);
1696
1697
1698         DPRINT(("pfm_fasync called on ctx_fd=%d on=%d async_queue=%p ret=%d\n",
1699                 fd,
1700                 on,
1701                 ctx->ctx_async_queue, ret));
1702
1703         return ret;
1704 }
1705
1706 #ifdef CONFIG_SMP
1707 /*
1708  * this function is exclusively called from pfm_close().
1709  * The context is not protected at that time, nor are interrupts
1710  * on the remote CPU. That's necessary to avoid deadlocks.
1711  */
1712 static void
1713 pfm_syswide_force_stop(void *info)
1714 {
1715         pfm_context_t   *ctx = (pfm_context_t *)info;
1716         struct pt_regs *regs = task_pt_regs(current);
1717         struct task_struct *owner;
1718         unsigned long flags;
1719         int ret;
1720
1721         if (ctx->ctx_cpu != smp_processor_id()) {
1722                 printk(KERN_ERR "perfmon: pfm_syswide_force_stop for CPU%d  but on CPU%d\n",
1723                         ctx->ctx_cpu,
1724                         smp_processor_id());
1725                 return;
1726         }
1727         owner = GET_PMU_OWNER();
1728         if (owner != ctx->ctx_task) {
1729                 printk(KERN_ERR "perfmon: pfm_syswide_force_stop CPU%d unexpected owner [%d] instead of [%d]\n",
1730                         smp_processor_id(),
1731                         owner->pid, ctx->ctx_task->pid);
1732                 return;
1733         }
1734         if (GET_PMU_CTX() != ctx) {
1735                 printk(KERN_ERR "perfmon: pfm_syswide_force_stop CPU%d unexpected ctx %p instead of %p\n",
1736                         smp_processor_id(),
1737                         GET_PMU_CTX(), ctx);
1738                 return;
1739         }
1740
1741         DPRINT(("on CPU%d forcing system wide stop for [%d]\n", smp_processor_id(), ctx->ctx_task->pid));
1742         /*
1743          * the context is already protected in pfm_close(), we simply
1744          * need to mask interrupts to avoid a PMU interrupt race on
1745          * this CPU
1746          */
1747         local_irq_save(flags);
1748
1749         ret = pfm_context_unload(ctx, NULL, 0, regs);
1750         if (ret) {
1751                 DPRINT(("context_unload returned %d\n", ret));
1752         }
1753
1754         /*
1755          * unmask interrupts, PMU interrupts are now spurious here
1756          */
1757         local_irq_restore(flags);
1758 }
1759
1760 static void
1761 pfm_syswide_cleanup_other_cpu(pfm_context_t *ctx)
1762 {
1763         int ret;
1764
1765         DPRINT(("calling CPU%d for cleanup\n", ctx->ctx_cpu));
1766         ret = smp_call_function_single(ctx->ctx_cpu, pfm_syswide_force_stop, ctx, 0, 1);
1767         DPRINT(("called CPU%d for cleanup ret=%d\n", ctx->ctx_cpu, ret));
1768 }
1769 #endif /* CONFIG_SMP */
1770
1771 /*
1772  * called for each close(). Partially free resources.
1773  * When caller is self-monitoring, the context is unloaded.
1774  */
1775 static int
1776 pfm_flush(struct file *filp)
1777 {
1778         pfm_context_t *ctx;
1779         struct task_struct *task;
1780         struct pt_regs *regs;
1781         unsigned long flags;
1782         unsigned long smpl_buf_size = 0UL;
1783         void *smpl_buf_vaddr = NULL;
1784         int state, is_system;
1785
1786         if (PFM_IS_FILE(filp) == 0) {
1787                 DPRINT(("bad magic for\n"));
1788                 return -EBADF;
1789         }
1790
1791         ctx = (pfm_context_t *)filp->private_data;
1792         if (ctx == NULL) {
1793                 printk(KERN_ERR "perfmon: pfm_flush: NULL ctx [%d]\n", current->pid);
1794                 return -EBADF;
1795         }
1796
1797         /*
1798          * remove our file from the async queue, if we use this mode.
1799          * This can be done without the context being protected. We come
1800          * here when the context has become unreacheable by other tasks.
1801          *
1802          * We may still have active monitoring at this point and we may
1803          * end up in pfm_overflow_handler(). However, fasync_helper()
1804          * operates with interrupts disabled and it cleans up the
1805          * queue. If the PMU handler is called prior to entering
1806          * fasync_helper() then it will send a signal. If it is
1807          * invoked after, it will find an empty queue and no
1808          * signal will be sent. In both case, we are safe
1809          */
1810         if (filp->f_flags & FASYNC) {
1811                 DPRINT(("cleaning up async_queue=%p\n", ctx->ctx_async_queue));
1812                 pfm_do_fasync (-1, filp, ctx, 0);
1813         }
1814
1815         PROTECT_CTX(ctx, flags);
1816
1817         state     = ctx->ctx_state;
1818         is_system = ctx->ctx_fl_system;
1819
1820         task = PFM_CTX_TASK(ctx);
1821         regs = task_pt_regs(task);
1822
1823         DPRINT(("ctx_state=%d is_current=%d\n",
1824                 state,
1825                 task == current ? 1 : 0));
1826
1827         /*
1828          * if state == UNLOADED, then task is NULL
1829          */
1830
1831         /*
1832          * we must stop and unload because we are losing access to the context.
1833          */
1834         if (task == current) {
1835 #ifdef CONFIG_SMP
1836                 /*
1837                  * the task IS the owner but it migrated to another CPU: that's bad
1838                  * but we must handle this cleanly. Unfortunately, the kernel does
1839                  * not provide a mechanism to block migration (while the context is loaded).
1840                  *
1841                  * We need to release the resource on the ORIGINAL cpu.
1842                  */
1843                 if (is_system && ctx->ctx_cpu != smp_processor_id()) {
1844
1845                         DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
1846                         /*
1847                          * keep context protected but unmask interrupt for IPI
1848                          */
1849                         local_irq_restore(flags);
1850
1851                         pfm_syswide_cleanup_other_cpu(ctx);
1852
1853                         /*
1854                          * restore interrupt masking
1855                          */
1856                         local_irq_save(flags);
1857
1858                         /*
1859                          * context is unloaded at this point
1860                          */
1861                 } else
1862 #endif /* CONFIG_SMP */
1863                 {
1864
1865                         DPRINT(("forcing unload\n"));
1866                         /*
1867                         * stop and unload, returning with state UNLOADED
1868                         * and session unreserved.
1869                         */
1870                         pfm_context_unload(ctx, NULL, 0, regs);
1871
1872                         DPRINT(("ctx_state=%d\n", ctx->ctx_state));
1873                 }
1874         }
1875
1876         /*
1877          * remove virtual mapping, if any, for the calling task.
1878          * cannot reset ctx field until last user is calling close().
1879          *
1880          * ctx_smpl_vaddr must never be cleared because it is needed
1881          * by every task with access to the context
1882          *
1883          * When called from do_exit(), the mm context is gone already, therefore
1884          * mm is NULL, i.e., the VMA is already gone  and we do not have to
1885          * do anything here
1886          */
1887         if (ctx->ctx_smpl_vaddr && current->mm) {
1888                 smpl_buf_vaddr = ctx->ctx_smpl_vaddr;
1889                 smpl_buf_size  = ctx->ctx_smpl_size;
1890         }
1891
1892         UNPROTECT_CTX(ctx, flags);
1893
1894         /*
1895          * if there was a mapping, then we systematically remove it
1896          * at this point. Cannot be done inside critical section
1897          * because some VM function reenables interrupts.
1898          *
1899          */
1900         if (smpl_buf_vaddr) pfm_remove_smpl_mapping(current, smpl_buf_vaddr, smpl_buf_size);
1901
1902         return 0;
1903 }
1904 /*
1905  * called either on explicit close() or from exit_files().
1906  * Only the LAST user of the file gets to this point, i.e., it is
1907  * called only ONCE.
1908  *
1909  * IMPORTANT: we get called ONLY when the refcnt on the file gets to zero
1910  * (fput()),i.e, last task to access the file. Nobody else can access the
1911  * file at this point.
1912  *
1913  * When called from exit_files(), the VMA has been freed because exit_mm()
1914  * is executed before exit_files().
1915  *
1916  * When called from exit_files(), the current task is not yet ZOMBIE but we
1917  * flush the PMU state to the context.
1918  */
1919 static int
1920 pfm_close(struct inode *inode, struct file *filp)
1921 {
1922         pfm_context_t *ctx;
1923         struct task_struct *task;
1924         struct pt_regs *regs;
1925         DECLARE_WAITQUEUE(wait, current);
1926         unsigned long flags;
1927         unsigned long smpl_buf_size = 0UL;
1928         void *smpl_buf_addr = NULL;
1929         int free_possible = 1;
1930         int state, is_system;
1931
1932         DPRINT(("pfm_close called private=%p\n", filp->private_data));
1933
1934         if (PFM_IS_FILE(filp) == 0) {
1935                 DPRINT(("bad magic\n"));
1936                 return -EBADF;
1937         }
1938
1939         ctx = (pfm_context_t *)filp->private_data;
1940         if (ctx == NULL) {
1941                 printk(KERN_ERR "perfmon: pfm_close: NULL ctx [%d]\n", current->pid);
1942                 return -EBADF;
1943         }
1944
1945         PROTECT_CTX(ctx, flags);
1946
1947         state     = ctx->ctx_state;
1948         is_system = ctx->ctx_fl_system;
1949
1950         task = PFM_CTX_TASK(ctx);
1951         regs = task_pt_regs(task);
1952
1953         DPRINT(("ctx_state=%d is_current=%d\n",
1954                 state,
1955                 task == current ? 1 : 0));
1956
1957         /*
1958          * if task == current, then pfm_flush() unloaded the context
1959          */
1960         if (state == PFM_CTX_UNLOADED) goto doit;
1961
1962         /*
1963          * context is loaded/masked and task != current, we need to
1964          * either force an unload or go zombie
1965          */
1966
1967         /*
1968          * The task is currently blocked or will block after an overflow.
1969          * we must force it to wakeup to get out of the
1970          * MASKED state and transition to the unloaded state by itself.
1971          *
1972          * This situation is only possible for per-task mode
1973          */
1974         if (state == PFM_CTX_MASKED && CTX_OVFL_NOBLOCK(ctx) == 0) {
1975
1976                 /*
1977                  * set a "partial" zombie state to be checked
1978                  * upon return from down() in pfm_handle_work().
1979                  *
1980                  * We cannot use the ZOMBIE state, because it is checked
1981                  * by pfm_load_regs() which is called upon wakeup from down().
1982                  * In such case, it would free the context and then we would
1983                  * return to pfm_handle_work() which would access the
1984                  * stale context. Instead, we set a flag invisible to pfm_load_regs()
1985                  * but visible to pfm_handle_work().
1986                  *
1987                  * For some window of time, we have a zombie context with
1988                  * ctx_state = MASKED  and not ZOMBIE
1989                  */
1990                 ctx->ctx_fl_going_zombie = 1;
1991
1992                 /*
1993                  * force task to wake up from MASKED state
1994                  */
1995                 complete(&ctx->ctx_restart_done);
1996
1997                 DPRINT(("waking up ctx_state=%d\n", state));
1998
1999                 /*
2000                  * put ourself to sleep waiting for the other
2001                  * task to report completion
2002                  *
2003                  * the context is protected by mutex, therefore there
2004                  * is no risk of being notified of completion before
2005                  * begin actually on the waitq.
2006                  */
2007                 set_current_state(TASK_INTERRUPTIBLE);
2008                 add_wait_queue(&ctx->ctx_zombieq, &wait);
2009
2010                 UNPROTECT_CTX(ctx, flags);
2011
2012                 /*
2013                  * XXX: check for signals :
2014                  *      - ok for explicit close
2015                  *      - not ok when coming from exit_files()
2016                  */
2017                 schedule();
2018
2019
2020                 PROTECT_CTX(ctx, flags);
2021
2022
2023                 remove_wait_queue(&ctx->ctx_zombieq, &wait);
2024                 set_current_state(TASK_RUNNING);
2025
2026                 /*
2027                  * context is unloaded at this point
2028                  */
2029                 DPRINT(("after zombie wakeup ctx_state=%d for\n", state));
2030         }
2031         else if (task != current) {
2032 #ifdef CONFIG_SMP
2033                 /*
2034                  * switch context to zombie state
2035                  */
2036                 ctx->ctx_state = PFM_CTX_ZOMBIE;
2037
2038                 DPRINT(("zombie ctx for [%d]\n", task->pid));
2039                 /*
2040                  * cannot free the context on the spot. deferred until
2041                  * the task notices the ZOMBIE state
2042                  */
2043                 free_possible = 0;
2044 #else
2045                 pfm_context_unload(ctx, NULL, 0, regs);
2046 #endif
2047         }
2048
2049 doit:
2050         /* reload state, may have changed during  opening of critical section */
2051         state = ctx->ctx_state;
2052
2053         /*
2054          * the context is still attached to a task (possibly current)
2055          * we cannot destroy it right now
2056          */
2057
2058         /*
2059          * we must free the sampling buffer right here because
2060          * we cannot rely on it being cleaned up later by the
2061          * monitored task. It is not possible to free vmalloc'ed
2062          * memory in pfm_load_regs(). Instead, we remove the buffer
2063          * now. should there be subsequent PMU overflow originally
2064          * meant for sampling, the will be converted to spurious
2065          * and that's fine because the monitoring tools is gone anyway.
2066          */
2067         if (ctx->ctx_smpl_hdr) {
2068                 smpl_buf_addr = ctx->ctx_smpl_hdr;
2069                 smpl_buf_size = ctx->ctx_smpl_size;
2070                 /* no more sampling */
2071                 ctx->ctx_smpl_hdr = NULL;
2072                 ctx->ctx_fl_is_sampling = 0;
2073         }
2074
2075         DPRINT(("ctx_state=%d free_possible=%d addr=%p size=%lu\n",
2076                 state,
2077                 free_possible,
2078                 smpl_buf_addr,
2079                 smpl_buf_size));
2080
2081         if (smpl_buf_addr) pfm_exit_smpl_buffer(ctx->ctx_buf_fmt);
2082
2083         /*
2084          * UNLOADED that the session has already been unreserved.
2085          */
2086         if (state == PFM_CTX_ZOMBIE) {
2087                 pfm_unreserve_session(ctx, ctx->ctx_fl_system , ctx->ctx_cpu);
2088         }
2089
2090         /*
2091          * disconnect file descriptor from context must be done
2092          * before we unlock.
2093          */
2094         filp->private_data = NULL;
2095
2096         /*
2097          * if we free on the spot, the context is now completely unreacheable
2098          * from the callers side. The monitored task side is also cut, so we
2099          * can freely cut.
2100          *
2101          * If we have a deferred free, only the caller side is disconnected.
2102          */
2103         UNPROTECT_CTX(ctx, flags);
2104
2105         /*
2106          * All memory free operations (especially for vmalloc'ed memory)
2107          * MUST be done with interrupts ENABLED.
2108          */
2109         if (smpl_buf_addr)  pfm_rvfree(smpl_buf_addr, smpl_buf_size);
2110
2111         /*
2112          * return the memory used by the context
2113          */
2114         if (free_possible) pfm_context_free(ctx);
2115
2116         return 0;
2117 }
2118
2119 static int
2120 pfm_no_open(struct inode *irrelevant, struct file *dontcare)
2121 {
2122         DPRINT(("pfm_no_open called\n"));
2123         return -ENXIO;
2124 }
2125
2126
2127
2128 static struct file_operations pfm_file_ops = {
2129         .llseek   = no_llseek,
2130         .read     = pfm_read,
2131         .write    = pfm_write,
2132         .poll     = pfm_poll,
2133         .ioctl    = pfm_ioctl,
2134         .open     = pfm_no_open,        /* special open code to disallow open via /proc */
2135         .fasync   = pfm_fasync,
2136         .release  = pfm_close,
2137         .flush    = pfm_flush
2138 };
2139
2140 static int
2141 pfmfs_delete_dentry(struct dentry *dentry)
2142 {
2143         return 1;
2144 }
2145
2146 static struct dentry_operations pfmfs_dentry_operations = {
2147         .d_delete = pfmfs_delete_dentry,
2148 };
2149
2150
2151 static int
2152 pfm_alloc_fd(struct file **cfile)
2153 {
2154         int fd, ret = 0;
2155         struct file *file = NULL;
2156         struct inode * inode;
2157         char name[32];
2158         struct qstr this;
2159
2160         fd = get_unused_fd();
2161         if (fd < 0) return -ENFILE;
2162
2163         ret = -ENFILE;
2164
2165         file = get_empty_filp();
2166         if (!file) goto out;
2167
2168         /*
2169          * allocate a new inode
2170          */
2171         inode = new_inode(pfmfs_mnt->mnt_sb);
2172         if (!inode) goto out;
2173
2174         DPRINT(("new inode ino=%ld @%p\n", inode->i_ino, inode));
2175
2176         inode->i_mode = S_IFCHR|S_IRUGO;
2177         inode->i_uid  = current->fsuid;
2178         inode->i_gid  = current->fsgid;
2179
2180         sprintf(name, "[%lu]", inode->i_ino);
2181         this.name = name;
2182         this.len  = strlen(name);
2183         this.hash = inode->i_ino;
2184
2185         ret = -ENOMEM;
2186
2187         /*
2188          * allocate a new dcache entry
2189          */
2190         file->f_dentry = d_alloc(pfmfs_mnt->mnt_sb->s_root, &this);
2191         if (!file->f_dentry) goto out;
2192
2193         file->f_dentry->d_op = &pfmfs_dentry_operations;
2194
2195         d_add(file->f_dentry, inode);
2196         file->f_vfsmnt = mntget(pfmfs_mnt);
2197         file->f_mapping = inode->i_mapping;
2198
2199         file->f_op    = &pfm_file_ops;
2200         file->f_mode  = FMODE_READ;
2201         file->f_flags = O_RDONLY;
2202         file->f_pos   = 0;
2203
2204         /*
2205          * may have to delay until context is attached?
2206          */
2207         fd_install(fd, file);
2208
2209         /*
2210          * the file structure we will use
2211          */
2212         *cfile = file;
2213
2214         return fd;
2215 out:
2216         if (file) put_filp(file);
2217         put_unused_fd(fd);
2218         return ret;
2219 }
2220
2221 static void
2222 pfm_free_fd(int fd, struct file *file)
2223 {
2224         struct files_struct *files = current->files;
2225         struct fdtable *fdt;
2226
2227         /*
2228          * there ie no fd_uninstall(), so we do it here
2229          */
2230         spin_lock(&files->file_lock);
2231         fdt = files_fdtable(files);
2232         rcu_assign_pointer(fdt->fd[fd], NULL);
2233         spin_unlock(&files->file_lock);
2234
2235         if (file)
2236                 put_filp(file);
2237         put_unused_fd(fd);
2238 }
2239
2240 static int
2241 pfm_remap_buffer(struct vm_area_struct *vma, unsigned long buf, unsigned long addr, unsigned long size)
2242 {
2243         DPRINT(("CPU%d buf=0x%lx addr=0x%lx size=%ld\n", smp_processor_id(), buf, addr, size));
2244
2245         while (size > 0) {
2246                 unsigned long pfn = ia64_tpa(buf) >> PAGE_SHIFT;
2247
2248
2249                 if (remap_pfn_range(vma, addr, pfn, PAGE_SIZE, PAGE_READONLY))
2250                         return -ENOMEM;
2251
2252                 addr  += PAGE_SIZE;
2253                 buf   += PAGE_SIZE;
2254                 size  -= PAGE_SIZE;
2255         }
2256         return 0;
2257 }
2258
2259 /*
2260  * allocate a sampling buffer and remaps it into the user address space of the task
2261  */
2262 static int
2263 pfm_smpl_buffer_alloc(struct task_struct *task, pfm_context_t *ctx, unsigned long rsize, void **user_vaddr)
2264 {
2265         struct mm_struct *mm = task->mm;
2266         struct vm_area_struct *vma = NULL;
2267         unsigned long size;
2268         void *smpl_buf;
2269
2270
2271         /*
2272          * the fixed header + requested size and align to page boundary
2273          */
2274         size = PAGE_ALIGN(rsize);
2275
2276         DPRINT(("sampling buffer rsize=%lu size=%lu bytes\n", rsize, size));
2277
2278         /*
2279          * check requested size to avoid Denial-of-service attacks
2280          * XXX: may have to refine this test
2281          * Check against address space limit.
2282          *
2283          * if ((mm->total_vm << PAGE_SHIFT) + len> task->rlim[RLIMIT_AS].rlim_cur)
2284          *      return -ENOMEM;
2285          */
2286         if (size > task->signal->rlim[RLIMIT_MEMLOCK].rlim_cur)
2287                 return -ENOMEM;
2288
2289         /*
2290          * We do the easy to undo allocations first.
2291          *
2292          * pfm_rvmalloc(), clears the buffer, so there is no leak
2293          */
2294         smpl_buf = pfm_rvmalloc(size);
2295         if (smpl_buf == NULL) {
2296                 DPRINT(("Can't allocate sampling buffer\n"));
2297                 return -ENOMEM;
2298         }
2299
2300         DPRINT(("smpl_buf @%p\n", smpl_buf));
2301
2302         /* allocate vma */
2303         vma = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
2304         if (!vma) {
2305                 DPRINT(("Cannot allocate vma\n"));
2306                 goto error_kmem;
2307         }
2308         memset(vma, 0, sizeof(*vma));
2309
2310         /*
2311          * partially initialize the vma for the sampling buffer
2312          */
2313         vma->vm_mm           = mm;
2314         vma->vm_flags        = VM_READ| VM_MAYREAD |VM_RESERVED;
2315         vma->vm_page_prot    = PAGE_READONLY; /* XXX may need to change */
2316
2317         /*
2318          * Now we have everything we need and we can initialize
2319          * and connect all the data structures
2320          */
2321
2322         ctx->ctx_smpl_hdr   = smpl_buf;
2323         ctx->ctx_smpl_size  = size; /* aligned size */
2324
2325         /*
2326          * Let's do the difficult operations next.
2327          *
2328          * now we atomically find some area in the address space and
2329          * remap the buffer in it.
2330          */
2331         down_write(&task->mm->mmap_sem);
2332
2333         /* find some free area in address space, must have mmap sem held */
2334         vma->vm_start = pfm_get_unmapped_area(NULL, 0, size, 0, MAP_PRIVATE|MAP_ANONYMOUS, 0);
2335         if (vma->vm_start == 0UL) {
2336                 DPRINT(("Cannot find unmapped area for size %ld\n", size));
2337                 up_write(&task->mm->mmap_sem);
2338                 goto error;
2339         }
2340         vma->vm_end = vma->vm_start + size;
2341         vma->vm_pgoff = vma->vm_start >> PAGE_SHIFT;
2342
2343         DPRINT(("aligned size=%ld, hdr=%p mapped @0x%lx\n", size, ctx->ctx_smpl_hdr, vma->vm_start));
2344
2345         /* can only be applied to current task, need to have the mm semaphore held when called */
2346         if (pfm_remap_buffer(vma, (unsigned long)smpl_buf, vma->vm_start, size)) {
2347                 DPRINT(("Can't remap buffer\n"));
2348                 up_write(&task->mm->mmap_sem);
2349                 goto error;
2350         }
2351
2352         /*
2353          * now insert the vma in the vm list for the process, must be
2354          * done with mmap lock held
2355          */
2356         insert_vm_struct(mm, vma);
2357
2358         mm->total_vm  += size >> PAGE_SHIFT;
2359         vm_stat_account(vma->vm_mm, vma->vm_flags, vma->vm_file,
2360                                                         vma_pages(vma));
2361         up_write(&task->mm->mmap_sem);
2362
2363         /*
2364          * keep track of user level virtual address
2365          */
2366         ctx->ctx_smpl_vaddr = (void *)vma->vm_start;
2367         *(unsigned long *)user_vaddr = vma->vm_start;
2368
2369         return 0;
2370
2371 error:
2372         kmem_cache_free(vm_area_cachep, vma);
2373 error_kmem:
2374         pfm_rvfree(smpl_buf, size);
2375
2376         return -ENOMEM;
2377 }
2378
2379 /*
2380  * XXX: do something better here
2381  */
2382 static int
2383 pfm_bad_permissions(struct task_struct *task)
2384 {
2385         /* inspired by ptrace_attach() */
2386         DPRINT(("cur: uid=%d gid=%d task: euid=%d suid=%d uid=%d egid=%d sgid=%d\n",
2387                 current->uid,
2388                 current->gid,
2389                 task->euid,
2390                 task->suid,
2391                 task->uid,
2392                 task->egid,
2393                 task->sgid));
2394
2395         return ((current->uid != task->euid)
2396             || (current->uid != task->suid)
2397             || (current->uid != task->uid)
2398             || (current->gid != task->egid)
2399             || (current->gid != task->sgid)
2400             || (current->gid != task->gid)) && !capable(CAP_SYS_PTRACE);
2401 }
2402
2403 static int
2404 pfarg_is_sane(struct task_struct *task, pfarg_context_t *pfx)
2405 {
2406         int ctx_flags;
2407
2408         /* valid signal */
2409
2410         ctx_flags = pfx->ctx_flags;
2411
2412         if (ctx_flags & PFM_FL_SYSTEM_WIDE) {
2413
2414                 /*
2415                  * cannot block in this mode
2416                  */
2417                 if (ctx_flags & PFM_FL_NOTIFY_BLOCK) {
2418                         DPRINT(("cannot use blocking mode when in system wide monitoring\n"));
2419                         return -EINVAL;
2420                 }
2421         } else {
2422         }
2423         /* probably more to add here */
2424
2425         return 0;
2426 }
2427
2428 static int
2429 pfm_setup_buffer_fmt(struct task_struct *task, pfm_context_t *ctx, unsigned int ctx_flags,
2430                      unsigned int cpu, pfarg_context_t *arg)
2431 {
2432         pfm_buffer_fmt_t *fmt = NULL;
2433         unsigned long size = 0UL;
2434         void *uaddr = NULL;
2435         void *fmt_arg = NULL;
2436         int ret = 0;
2437 #define PFM_CTXARG_BUF_ARG(a)   (pfm_buffer_fmt_t *)(a+1)
2438
2439         /* invoke and lock buffer format, if found */
2440         fmt = pfm_find_buffer_fmt(arg->ctx_smpl_buf_id);
2441         if (fmt == NULL) {
2442                 DPRINT(("[%d] cannot find buffer format\n", task->pid));
2443                 return -EINVAL;
2444         }
2445
2446         /*
2447          * buffer argument MUST be contiguous to pfarg_context_t
2448          */
2449         if (fmt->fmt_arg_size) fmt_arg = PFM_CTXARG_BUF_ARG(arg);
2450
2451         ret = pfm_buf_fmt_validate(fmt, task, ctx_flags, cpu, fmt_arg);
2452
2453         DPRINT(("[%d] after validate(0x%x,%d,%p)=%d\n", task->pid, ctx_flags, cpu, fmt_arg, ret));
2454
2455         if (ret) goto error;
2456
2457         /* link buffer format and context */
2458         ctx->ctx_buf_fmt = fmt;
2459
2460         /*
2461          * check if buffer format wants to use perfmon buffer allocation/mapping service
2462          */
2463         ret = pfm_buf_fmt_getsize(fmt, task, ctx_flags, cpu, fmt_arg, &size);
2464         if (ret) goto error;
2465
2466         if (size) {
2467                 /*
2468                  * buffer is always remapped into the caller's address space
2469                  */
2470                 ret = pfm_smpl_buffer_alloc(current, ctx, size, &uaddr);
2471                 if (ret) goto error;
2472
2473                 /* keep track of user address of buffer */
2474                 arg->ctx_smpl_vaddr = uaddr;
2475         }
2476         ret = pfm_buf_fmt_init(fmt, task, ctx->ctx_smpl_hdr, ctx_flags, cpu, fmt_arg);
2477
2478 error:
2479         return ret;
2480 }
2481
2482 static void
2483 pfm_reset_pmu_state(pfm_context_t *ctx)
2484 {
2485         int i;
2486
2487         /*
2488          * install reset values for PMC.
2489          */
2490         for (i=1; PMC_IS_LAST(i) == 0; i++) {
2491                 if (PMC_IS_IMPL(i) == 0) continue;
2492                 ctx->ctx_pmcs[i] = PMC_DFL_VAL(i);
2493                 DPRINT(("pmc[%d]=0x%lx\n", i, ctx->ctx_pmcs[i]));
2494         }
2495         /*
2496          * PMD registers are set to 0UL when the context in memset()
2497          */
2498
2499         /*
2500          * On context switched restore, we must restore ALL pmc and ALL pmd even
2501          * when they are not actively used by the task. In UP, the incoming process
2502          * may otherwise pick up left over PMC, PMD state from the previous process.
2503          * As opposed to PMD, stale PMC can cause harm to the incoming
2504          * process because they may change what is being measured.
2505          * Therefore, we must systematically reinstall the entire
2506          * PMC state. In SMP, the same thing is possible on the
2507          * same CPU but also on between 2 CPUs.
2508          *
2509          * The problem with PMD is information leaking especially
2510          * to user level when psr.sp=0
2511          *
2512          * There is unfortunately no easy way to avoid this problem
2513          * on either UP or SMP. This definitively slows down the
2514          * pfm_load_regs() function.
2515          */
2516
2517          /*
2518           * bitmask of all PMCs accessible to this context
2519           *
2520           * PMC0 is treated differently.
2521           */
2522         ctx->ctx_all_pmcs[0] = pmu_conf->impl_pmcs[0] & ~0x1;
2523
2524         /*
2525          * bitmask of all PMDs that are accesible to this context
2526          */
2527         ctx->ctx_all_pmds[0] = pmu_conf->impl_pmds[0];
2528
2529         DPRINT(("<%d> all_pmcs=0x%lx all_pmds=0x%lx\n", ctx->ctx_fd, ctx->ctx_all_pmcs[0],ctx->ctx_all_pmds[0]));
2530
2531         /*
2532          * useful in case of re-enable after disable
2533          */
2534         ctx->ctx_used_ibrs[0] = 0UL;
2535         ctx->ctx_used_dbrs[0] = 0UL;
2536 }
2537
2538 static int
2539 pfm_ctx_getsize(void *arg, size_t *sz)
2540 {
2541         pfarg_context_t *req = (pfarg_context_t *)arg;
2542         pfm_buffer_fmt_t *fmt;
2543
2544         *sz = 0;
2545
2546         if (!pfm_uuid_cmp(req->ctx_smpl_buf_id, pfm_null_uuid)) return 0;
2547
2548         fmt = pfm_find_buffer_fmt(req->ctx_smpl_buf_id);
2549         if (fmt == NULL) {
2550                 DPRINT(("cannot find buffer format\n"));
2551                 return -EINVAL;
2552         }
2553         /* get just enough to copy in user parameters */
2554         *sz = fmt->fmt_arg_size;
2555         DPRINT(("arg_size=%lu\n", *sz));
2556
2557         return 0;
2558 }
2559
2560
2561
2562 /*
2563  * cannot attach if :
2564  *      - kernel task
2565  *      - task not owned by caller
2566  *      - task incompatible with context mode
2567  */
2568 static int
2569 pfm_task_incompatible(pfm_context_t *ctx, struct task_struct *task)
2570 {
2571         /*
2572          * no kernel task or task not owner by caller
2573          */
2574         if (task->mm == NULL) {
2575                 DPRINT(("task [%d] has not memory context (kernel thread)\n", task->pid));
2576                 return -EPERM;
2577         }
2578         if (pfm_bad_permissions(task)) {
2579                 DPRINT(("no permission to attach to  [%d]\n", task->pid));
2580                 return -EPERM;
2581         }
2582         /*
2583          * cannot block in self-monitoring mode
2584          */
2585         if (CTX_OVFL_NOBLOCK(ctx) == 0 && task == current) {
2586                 DPRINT(("cannot load a blocking context on self for [%d]\n", task->pid));
2587                 return -EINVAL;
2588         }
2589
2590         if (task->exit_state == EXIT_ZOMBIE) {
2591                 DPRINT(("cannot attach to  zombie task [%d]\n", task->pid));
2592                 return -EBUSY;
2593         }
2594
2595         /*
2596          * always ok for self
2597          */
2598         if (task == current) return 0;
2599
2600         if ((task->state != TASK_STOPPED) && (task->state != TASK_TRACED)) {
2601                 DPRINT(("cannot attach to non-stopped task [%d] state=%ld\n", task->pid, task->state));
2602                 return -EBUSY;
2603         }
2604         /*
2605          * make sure the task is off any CPU
2606          */
2607         wait_task_inactive(task);
2608
2609         /* more to come... */
2610
2611         return 0;
2612 }
2613
2614 static int
2615 pfm_get_task(pfm_context_t *ctx, pid_t pid, struct task_struct **task)
2616 {
2617         struct task_struct *p = current;
2618         int ret;
2619
2620         /* XXX: need to add more checks here */
2621         if (pid < 2) return -EPERM;
2622
2623         if (pid != current->pid) {
2624
2625                 read_lock(&tasklist_lock);
2626
2627                 p = find_task_by_pid(pid);
2628
2629                 /* make sure task cannot go away while we operate on it */
2630                 if (p) get_task_struct(p);
2631
2632                 read_unlock(&tasklist_lock);
2633
2634                 if (p == NULL) return -ESRCH;
2635         }
2636
2637         ret = pfm_task_incompatible(ctx, p);
2638         if (ret == 0) {
2639                 *task = p;
2640         } else if (p != current) {
2641                 pfm_put_task(p);
2642         }
2643         return ret;
2644 }
2645
2646
2647
2648 static int
2649 pfm_context_create(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
2650 {
2651         pfarg_context_t *req = (pfarg_context_t *)arg;
2652         struct file *filp;
2653         int ctx_flags;
2654         int ret;
2655
2656         /* let's check the arguments first */
2657         ret = pfarg_is_sane(current, req);
2658         if (ret < 0) return ret;
2659
2660         ctx_flags = req->ctx_flags;
2661
2662         ret = -ENOMEM;
2663
2664         ctx = pfm_context_alloc();
2665         if (!ctx) goto error;
2666
2667         ret = pfm_alloc_fd(&filp);
2668         if (ret < 0) goto error_file;
2669
2670         req->ctx_fd = ctx->ctx_fd = ret;
2671
2672         /*
2673          * attach context to file
2674          */
2675         filp->private_data = ctx;
2676
2677         /*
2678          * does the user want to sample?
2679          */
2680         if (pfm_uuid_cmp(req->ctx_smpl_buf_id, pfm_null_uuid)) {
2681                 ret = pfm_setup_buffer_fmt(current, ctx, ctx_flags, 0, req);
2682                 if (ret) goto buffer_error;
2683         }
2684
2685         /*
2686          * init context protection lock
2687          */
2688         spin_lock_init(&ctx->ctx_lock);
2689
2690         /*
2691          * context is unloaded
2692          */
2693         ctx->ctx_state = PFM_CTX_UNLOADED;
2694
2695         /*
2696          * initialization of context's flags
2697          */
2698         ctx->ctx_fl_block       = (ctx_flags & PFM_FL_NOTIFY_BLOCK) ? 1 : 0;
2699         ctx->ctx_fl_system      = (ctx_flags & PFM_FL_SYSTEM_WIDE) ? 1: 0;
2700         ctx->ctx_fl_is_sampling = ctx->ctx_buf_fmt ? 1 : 0; /* assume record() is defined */
2701         ctx->ctx_fl_no_msg      = (ctx_flags & PFM_FL_OVFL_NO_MSG) ? 1: 0;
2702         /*
2703          * will move to set properties
2704          * ctx->ctx_fl_excl_idle   = (ctx_flags & PFM_FL_EXCL_IDLE) ? 1: 0;
2705          */
2706
2707         /*
2708          * init restart semaphore to locked
2709          */
2710         init_completion(&ctx->ctx_restart_done);
2711
2712         /*
2713          * activation is used in SMP only
2714          */
2715         ctx->ctx_last_activation = PFM_INVALID_ACTIVATION;
2716         SET_LAST_CPU(ctx, -1);
2717
2718         /*
2719          * initialize notification message queue
2720          */
2721         ctx->ctx_msgq_head = ctx->ctx_msgq_tail = 0;
2722         init_waitqueue_head(&ctx->ctx_msgq_wait);
2723         init_waitqueue_head(&ctx->ctx_zombieq);
2724
2725         DPRINT(("ctx=%p flags=0x%x system=%d notify_block=%d excl_idle=%d no_msg=%d ctx_fd=%d \n",
2726                 ctx,
2727                 ctx_flags,
2728                 ctx->ctx_fl_system,
2729                 ctx->ctx_fl_block,
2730                 ctx->ctx_fl_excl_idle,
2731                 ctx->ctx_fl_no_msg,
2732                 ctx->ctx_fd));
2733
2734         /*
2735          * initialize soft PMU state
2736          */
2737         pfm_reset_pmu_state(ctx);
2738
2739         return 0;
2740
2741 buffer_error:
2742         pfm_free_fd(ctx->ctx_fd, filp);
2743
2744         if (ctx->ctx_buf_fmt) {
2745                 pfm_buf_fmt_exit(ctx->ctx_buf_fmt, current, NULL, regs);
2746         }
2747 error_file:
2748         pfm_context_free(ctx);
2749
2750 error:
2751         return ret;
2752 }
2753
2754 static inline unsigned long
2755 pfm_new_counter_value (pfm_counter_t *reg, int is_long_reset)
2756 {
2757         unsigned long val = is_long_reset ? reg->long_reset : reg->short_reset;
2758         unsigned long new_seed, old_seed = reg->seed, mask = reg->mask;
2759         extern unsigned long carta_random32 (unsigned long seed);
2760
2761         if (reg->flags & PFM_REGFL_RANDOM) {
2762                 new_seed = carta_random32(old_seed);
2763                 val -= (old_seed & mask);       /* counter values are negative numbers! */
2764                 if ((mask >> 32) != 0)
2765                         /* construct a full 64-bit random value: */
2766                         new_seed |= carta_random32(old_seed >> 32) << 32;
2767                 reg->seed = new_seed;
2768         }
2769         reg->lval = val;
2770         return val;
2771 }
2772
2773 static void
2774 pfm_reset_regs_masked(pfm_context_t *ctx, unsigned long *ovfl_regs, int is_long_reset)
2775 {
2776         unsigned long mask = ovfl_regs[0];
2777         unsigned long reset_others = 0UL;
2778         unsigned long val;
2779         int i;
2780
2781         /*
2782          * now restore reset value on sampling overflowed counters
2783          */
2784         mask >>= PMU_FIRST_COUNTER;
2785         for(i = PMU_FIRST_COUNTER; mask; i++, mask >>= 1) {
2786
2787                 if ((mask & 0x1UL) == 0UL) continue;
2788
2789                 ctx->ctx_pmds[i].val = val = pfm_new_counter_value(ctx->ctx_pmds+ i, is_long_reset);
2790                 reset_others        |= ctx->ctx_pmds[i].reset_pmds[0];
2791
2792                 DPRINT_ovfl((" %s reset ctx_pmds[%d]=%lx\n", is_long_reset ? "long" : "short", i, val));
2793         }
2794
2795         /*
2796          * Now take care of resetting the other registers
2797          */
2798         for(i = 0; reset_others; i++, reset_others >>= 1) {
2799
2800                 if ((reset_others & 0x1) == 0) continue;
2801
2802                 ctx->ctx_pmds[i].val = val = pfm_new_counter_value(ctx->ctx_pmds + i, is_long_reset);
2803
2804                 DPRINT_ovfl(("%s reset_others pmd[%d]=%lx\n",
2805                           is_long_reset ? "long" : "short", i, val));
2806         }
2807 }
2808
2809 static void
2810 pfm_reset_regs(pfm_context_t *ctx, unsigned long *ovfl_regs, int is_long_reset)
2811 {
2812         unsigned long mask = ovfl_regs[0];
2813         unsigned long reset_others = 0UL;
2814         unsigned long val;
2815         int i;
2816
2817         DPRINT_ovfl(("ovfl_regs=0x%lx is_long_reset=%d\n", ovfl_regs[0], is_long_reset));
2818
2819         if (ctx->ctx_state == PFM_CTX_MASKED) {
2820                 pfm_reset_regs_masked(ctx, ovfl_regs, is_long_reset);
2821                 return;
2822         }
2823
2824         /*
2825          * now restore reset value on sampling overflowed counters
2826          */
2827         mask >>= PMU_FIRST_COUNTER;
2828         for(i = PMU_FIRST_COUNTER; mask; i++, mask >>= 1) {
2829
2830                 if ((mask & 0x1UL) == 0UL) continue;
2831
2832                 val           = pfm_new_counter_value(ctx->ctx_pmds+ i, is_long_reset);
2833                 reset_others |= ctx->ctx_pmds[i].reset_pmds[0];
2834
2835                 DPRINT_ovfl((" %s reset ctx_pmds[%d]=%lx\n", is_long_reset ? "long" : "short", i, val));
2836
2837                 pfm_write_soft_counter(ctx, i, val);
2838         }
2839
2840         /*
2841          * Now take care of resetting the other registers
2842          */
2843         for(i = 0; reset_others; i++, reset_others >>= 1) {
2844
2845                 if ((reset_others & 0x1) == 0) continue;
2846
2847                 val = pfm_new_counter_value(ctx->ctx_pmds + i, is_long_reset);
2848
2849                 if (PMD_IS_COUNTING(i)) {
2850                         pfm_write_soft_counter(ctx, i, val);
2851                 } else {
2852                         ia64_set_pmd(i, val);
2853                 }
2854                 DPRINT_ovfl(("%s reset_others pmd[%d]=%lx\n",
2855                           is_long_reset ? "long" : "short", i, val));
2856         }
2857         ia64_srlz_d();
2858 }
2859
2860 static int
2861 pfm_write_pmcs(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
2862 {
2863         struct thread_struct *thread = NULL;
2864         struct task_struct *task;
2865         pfarg_reg_t *req = (pfarg_reg_t *)arg;
2866         unsigned long value, pmc_pm;
2867         unsigned long smpl_pmds, reset_pmds, impl_pmds;
2868         unsigned int cnum, reg_flags, flags, pmc_type;
2869         int i, can_access_pmu = 0, is_loaded, is_system, expert_mode;
2870         int is_monitor, is_counting, state;
2871         int ret = -EINVAL;
2872         pfm_reg_check_t wr_func;
2873 #define PFM_CHECK_PMC_PM(x, y, z) ((x)->ctx_fl_system ^ PMC_PM(y, z))
2874
2875         state     = ctx->ctx_state;
2876         is_loaded = state == PFM_CTX_LOADED ? 1 : 0;
2877         is_system = ctx->ctx_fl_system;
2878         task      = ctx->ctx_task;
2879         impl_pmds = pmu_conf->impl_pmds[0];
2880
2881         if (state == PFM_CTX_ZOMBIE) return -EINVAL;
2882
2883         if (is_loaded) {
2884                 thread = &task->thread;
2885                 /*
2886                  * In system wide and when the context is loaded, access can only happen
2887                  * when the caller is running on the CPU being monitored by the session.
2888                  * It does not have to be the owner (ctx_task) of the context per se.
2889                  */
2890                 if (is_system && ctx->ctx_cpu != smp_processor_id()) {
2891                         DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
2892                         return -EBUSY;
2893                 }
2894                 can_access_pmu = GET_PMU_OWNER() == task || is_system ? 1 : 0;
2895         }
2896         expert_mode = pfm_sysctl.expert_mode;
2897
2898         for (i = 0; i < count; i++, req++) {
2899
2900                 cnum       = req->reg_num;
2901                 reg_flags  = req->reg_flags;
2902                 value      = req->reg_value;
2903                 smpl_pmds  = req->reg_smpl_pmds[0];
2904                 reset_pmds = req->reg_reset_pmds[0];
2905                 flags      = 0;
2906
2907
2908                 if (cnum >= PMU_MAX_PMCS) {
2909                         DPRINT(("pmc%u is invalid\n", cnum));
2910                         goto error;
2911                 }
2912
2913                 pmc_type   = pmu_conf->pmc_desc[cnum].type;
2914                 pmc_pm     = (value >> pmu_conf->pmc_desc[cnum].pm_pos) & 0x1;
2915                 is_counting = (pmc_type & PFM_REG_COUNTING) == PFM_REG_COUNTING ? 1 : 0;
2916                 is_monitor  = (pmc_type & PFM_REG_MONITOR) == PFM_REG_MONITOR ? 1 : 0;
2917
2918                 /*
2919                  * we reject all non implemented PMC as well
2920                  * as attempts to modify PMC[0-3] which are used
2921                  * as status registers by the PMU
2922                  */
2923                 if ((pmc_type & PFM_REG_IMPL) == 0 || (pmc_type & PFM_REG_CONTROL) == PFM_REG_CONTROL) {
2924                         DPRINT(("pmc%u is unimplemented or no-access pmc_type=%x\n", cnum, pmc_type));
2925                         goto error;
2926                 }
2927                 wr_func = pmu_conf->pmc_desc[cnum].write_check;
2928                 /*
2929                  * If the PMC is a monitor, then if the value is not the default:
2930                  *      - system-wide session: PMCx.pm=1 (privileged monitor)
2931                  *      - per-task           : PMCx.pm=0 (user monitor)
2932                  */
2933                 if (is_monitor && value != PMC_DFL_VAL(cnum) && is_system ^ pmc_pm) {
2934                         DPRINT(("pmc%u pmc_pm=%lu is_system=%d\n",
2935                                 cnum,
2936                                 pmc_pm,
2937                                 is_system));
2938                         goto error;
2939                 }
2940
2941                 if (is_counting) {
2942                         /*
2943                          * enforce generation of overflow interrupt. Necessary on all
2944                          * CPUs.
2945                          */
2946                         value |= 1 << PMU_PMC_OI;
2947
2948                         if (reg_flags & PFM_REGFL_OVFL_NOTIFY) {
2949                                 flags |= PFM_REGFL_OVFL_NOTIFY;
2950                         }
2951
2952                         if (reg_flags & PFM_REGFL_RANDOM) flags |= PFM_REGFL_RANDOM;
2953
2954                         /* verify validity of smpl_pmds */
2955                         if ((smpl_pmds & impl_pmds) != smpl_pmds) {
2956                                 DPRINT(("invalid smpl_pmds 0x%lx for pmc%u\n", smpl_pmds, cnum));
2957                                 goto error;
2958                         }
2959
2960                         /* verify validity of reset_pmds */
2961                         if ((reset_pmds & impl_pmds) != reset_pmds) {
2962                                 DPRINT(("invalid reset_pmds 0x%lx for pmc%u\n", reset_pmds, cnum));
2963                                 goto error;
2964                         }
2965                 } else {
2966                         if (reg_flags & (PFM_REGFL_OVFL_NOTIFY|PFM_REGFL_RANDOM)) {
2967                                 DPRINT(("cannot set ovfl_notify or random on pmc%u\n", cnum));
2968                                 goto error;
2969                         }
2970                         /* eventid on non-counting monitors are ignored */
2971                 }
2972
2973                 /*
2974                  * execute write checker, if any
2975                  */
2976                 if (likely(expert_mode == 0 && wr_func)) {
2977                         ret = (*wr_func)(task, ctx, cnum, &value, regs);
2978                         if (ret) goto error;
2979                         ret = -EINVAL;
2980                 }
2981
2982                 /*
2983                  * no error on this register
2984                  */
2985                 PFM_REG_RETFLAG_SET(req->reg_flags, 0);
2986
2987                 /*
2988                  * Now we commit the changes to the software state
2989                  */
2990
2991                 /*
2992                  * update overflow information
2993                  */
2994                 if (is_counting) {
2995                         /*
2996                          * full flag update each time a register is programmed
2997                          */
2998                         ctx->ctx_pmds[cnum].flags = flags;
2999
3000                         ctx->ctx_pmds[cnum].reset_pmds[0] = reset_pmds;
3001                         ctx->ctx_pmds[cnum].smpl_pmds[0]  = smpl_pmds;
3002                         ctx->ctx_pmds[cnum].eventid       = req->reg_smpl_eventid;
3003
3004                         /*
3005                          * Mark all PMDS to be accessed as used.
3006                          *
3007                          * We do not keep track of PMC because we have to
3008                          * systematically restore ALL of them.
3009                          *
3010                          * We do not update the used_monitors mask, because
3011                          * if we have not programmed them, then will be in
3012                          * a quiescent state, therefore we will not need to
3013                          * mask/restore then when context is MASKED.
3014                          */
3015                         CTX_USED_PMD(ctx, reset_pmds);
3016                         CTX_USED_PMD(ctx, smpl_pmds);
3017                         /*
3018                          * make sure we do not try to reset on
3019                          * restart because we have established new values
3020                          */
3021                         if (state == PFM_CTX_MASKED) ctx->ctx_ovfl_regs[0] &= ~1UL << cnum;
3022                 }
3023                 /*
3024                  * Needed in case the user does not initialize the equivalent
3025                  * PMD. Clearing is done indirectly via pfm_reset_pmu_state() so there is no
3026                  * possible leak here.
3027                  */
3028                 CTX_USED_PMD(ctx, pmu_conf->pmc_desc[cnum].dep_pmd[0]);
3029
3030                 /*
3031                  * keep track of the monitor PMC that we are using.
3032                  * we save the value of the pmc in ctx_pmcs[] and if
3033                  * the monitoring is not stopped for the context we also
3034                  * place it in the saved state area so that it will be
3035                  * picked up later by the context switch code.
3036                  *
3037                  * The value in ctx_pmcs[] can only be changed in pfm_write_pmcs().
3038                  *
3039                  * The value in thread->pmcs[] may be modified on overflow, i.e.,  when
3040                  * monitoring needs to be stopped.
3041                  */
3042                 if (is_monitor) CTX_USED_MONITOR(ctx, 1UL << cnum);
3043
3044                 /*
3045                  * update context state
3046                  */
3047                 ctx->ctx_pmcs[cnum] = value;
3048
3049                 if (is_loaded) {
3050                         /*
3051                          * write thread state
3052                          */
3053                         if (is_system == 0) thread->pmcs[cnum] = value;
3054
3055                         /*
3056                          * write hardware register if we can
3057                          */
3058                         if (can_access_pmu) {
3059                                 ia64_set_pmc(cnum, value);
3060                         }
3061 #ifdef CONFIG_SMP
3062                         else {
3063                                 /*
3064                                  * per-task SMP only here
3065                                  *
3066                                  * we are guaranteed that the task is not running on the other CPU,
3067                                  * we indicate that this PMD will need to be reloaded if the task
3068                                  * is rescheduled on the CPU it ran last on.
3069                                  */
3070                                 ctx->ctx_reload_pmcs[0] |= 1UL << cnum;
3071                         }
3072 #endif
3073                 }
3074
3075                 DPRINT(("pmc[%u]=0x%lx ld=%d apmu=%d flags=0x%x all_pmcs=0x%lx used_pmds=0x%lx eventid=%ld smpl_pmds=0x%lx reset_pmds=0x%lx reloads_pmcs=0x%lx used_monitors=0x%lx ovfl_regs=0x%lx\n",
3076                           cnum,
3077                           value,
3078                           is_loaded,
3079                           can_access_pmu,
3080                           flags,
3081                           ctx->ctx_all_pmcs[0],
3082                           ctx->ctx_used_pmds[0],
3083                           ctx->ctx_pmds[cnum].eventid,
3084                           smpl_pmds,
3085                           reset_pmds,
3086                           ctx->ctx_reload_pmcs[0],
3087                           ctx->ctx_used_monitors[0],
3088                           ctx->ctx_ovfl_regs[0]));
3089         }
3090
3091         /*
3092          * make sure the changes are visible
3093          */
3094         if (can_access_pmu) ia64_srlz_d();
3095
3096         return 0;
3097 error:
3098         PFM_REG_RETFLAG_SET(req->reg_flags, PFM_REG_RETFL_EINVAL);
3099         return ret;
3100 }
3101
3102 static int
3103 pfm_write_pmds(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3104 {
3105         struct thread_struct *thread = NULL;
3106         struct task_struct *task;
3107         pfarg_reg_t *req = (pfarg_reg_t *)arg;
3108         unsigned long value, hw_value, ovfl_mask;
3109         unsigned int cnum;
3110         int i, can_access_pmu = 0, state;
3111         int is_counting, is_loaded, is_system, expert_mode;
3112         int ret = -EINVAL;
3113         pfm_reg_check_t wr_func;
3114
3115
3116         state     = ctx->ctx_state;
3117         is_loaded = state == PFM_CTX_LOADED ? 1 : 0;
3118         is_system = ctx->ctx_fl_system;
3119         ovfl_mask = pmu_conf->ovfl_val;
3120         task      = ctx->ctx_task;
3121
3122         if (unlikely(state == PFM_CTX_ZOMBIE)) return -EINVAL;
3123
3124         /*
3125          * on both UP and SMP, we can only write to the PMC when the task is
3126          * the owner of the local PMU.
3127          */
3128         if (likely(is_loaded)) {
3129                 thread = &task->thread;
3130                 /*
3131                  * In system wide and when the context is loaded, access can only happen
3132                  * when the caller is running on the CPU being monitored by the session.
3133                  * It does not have to be the owner (ctx_task) of the context per se.
3134                  */
3135                 if (unlikely(is_system && ctx->ctx_cpu != smp_processor_id())) {
3136                         DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
3137                         return -EBUSY;
3138                 }
3139                 can_access_pmu = GET_PMU_OWNER() == task || is_system ? 1 : 0;
3140         }
3141         expert_mode = pfm_sysctl.expert_mode;
3142
3143         for (i = 0; i < count; i++, req++) {
3144
3145                 cnum  = req->reg_num;
3146                 value = req->reg_value;
3147
3148                 if (!PMD_IS_IMPL(cnum)) {
3149                         DPRINT(("pmd[%u] is unimplemented or invalid\n", cnum));
3150                         goto abort_mission;
3151                 }
3152                 is_counting = PMD_IS_COUNTING(cnum);
3153                 wr_func     = pmu_conf->pmd_desc[cnum].write_check;
3154
3155                 /*
3156                  * execute write checker, if any
3157                  */
3158                 if (unlikely(expert_mode == 0 && wr_func)) {
3159                         unsigned long v = value;
3160
3161                         ret = (*wr_func)(task, ctx, cnum, &v, regs);
3162                         if (ret) goto abort_mission;
3163
3164                         value = v;
3165                         ret   = -EINVAL;
3166                 }
3167
3168                 /*
3169                  * no error on this register
3170                  */
3171                 PFM_REG_RETFLAG_SET(req->reg_flags, 0);
3172
3173                 /*
3174                  * now commit changes to software state
3175                  */
3176                 hw_value = value;
3177
3178                 /*
3179                  * update virtualized (64bits) counter
3180                  */
3181                 if (is_counting) {
3182                         /*
3183                          * write context state
3184                          */
3185                         ctx->ctx_pmds[cnum].lval = value;
3186
3187                         /*
3188                          * when context is load we use the split value
3189                          */
3190                         if (is_loaded) {
3191                                 hw_value = value &  ovfl_mask;
3192                                 value    = value & ~ovfl_mask;
3193                         }
3194                 }
3195                 /*
3196                  * update reset values (not just for counters)
3197                  */
3198                 ctx->ctx_pmds[cnum].long_reset  = req->reg_long_reset;
3199                 ctx->ctx_pmds[cnum].short_reset = req->reg_short_reset;
3200
3201                 /*
3202                  * update randomization parameters (not just for counters)
3203                  */
3204                 ctx->ctx_pmds[cnum].seed = req->reg_random_seed;
3205                 ctx->ctx_pmds[cnum].mask = req->reg_random_mask;
3206
3207                 /*
3208                  * update context value
3209                  */
3210                 ctx->ctx_pmds[cnum].val  = value;
3211
3212                 /*
3213                  * Keep track of what we use
3214                  *
3215                  * We do not keep track of PMC because we have to
3216                  * systematically restore ALL of them.
3217                  */
3218                 CTX_USED_PMD(ctx, PMD_PMD_DEP(cnum));
3219
3220                 /*
3221                  * mark this PMD register used as well
3222                  */
3223                 CTX_USED_PMD(ctx, RDEP(cnum));
3224
3225                 /*
3226                  * make sure we do not try to reset on
3227                  * restart because we have established new values
3228                  */
3229                 if (is_counting && state == PFM_CTX_MASKED) {
3230                         ctx->ctx_ovfl_regs[0] &= ~1UL << cnum;
3231                 }
3232
3233                 if (is_loaded) {
3234                         /*
3235                          * write thread state
3236                          */
3237                         if (is_system == 0) thread->pmds[cnum] = hw_value;
3238
3239                         /*
3240                          * write hardware register if we can
3241                          */
3242                         if (can_access_pmu) {
3243                                 ia64_set_pmd(cnum, hw_value);
3244                         } else {
3245 #ifdef CONFIG_SMP
3246                                 /*
3247                                  * we are guaranteed that the task is not running on the other CPU,
3248                                  * we indicate that this PMD will need to be reloaded if the task
3249                                  * is rescheduled on the CPU it ran last on.
3250                                  */
3251                                 ctx->ctx_reload_pmds[0] |= 1UL << cnum;
3252 #endif
3253                         }
3254                 }
3255
3256                 DPRINT(("pmd[%u]=0x%lx ld=%d apmu=%d, hw_value=0x%lx ctx_pmd=0x%lx  short_reset=0x%lx "
3257                           "long_reset=0x%lx notify=%c seed=0x%lx mask=0x%lx used_pmds=0x%lx reset_pmds=0x%lx reload_pmds=0x%lx all_pmds=0x%lx ovfl_regs=0x%lx\n",
3258                         cnum,
3259                         value,
3260                         is_loaded,
3261                         can_access_pmu,
3262                         hw_value,
3263                         ctx->ctx_pmds[cnum].val,
3264                         ctx->ctx_pmds[cnum].short_reset,
3265                         ctx->ctx_pmds[cnum].long_reset,
3266                         PMC_OVFL_NOTIFY(ctx, cnum) ? 'Y':'N',
3267                         ctx->ctx_pmds[cnum].seed,
3268                         ctx->ctx_pmds[cnum].mask,
3269                         ctx->ctx_used_pmds[0],
3270                         ctx->ctx_pmds[cnum].reset_pmds[0],
3271                         ctx->ctx_reload_pmds[0],
3272                         ctx->ctx_all_pmds[0],
3273                         ctx->ctx_ovfl_regs[0]));
3274         }
3275
3276         /*
3277          * make changes visible
3278          */
3279         if (can_access_pmu) ia64_srlz_d();
3280
3281         return 0;
3282
3283 abort_mission:
3284         /*
3285          * for now, we have only one possibility for error
3286          */
3287         PFM_REG_RETFLAG_SET(req->reg_flags, PFM_REG_RETFL_EINVAL);
3288         return ret;
3289 }
3290
3291 /*
3292  * By the way of PROTECT_CONTEXT(), interrupts are masked while we are in this function.
3293  * Therefore we know, we do not have to worry about the PMU overflow interrupt. If an
3294  * interrupt is delivered during the call, it will be kept pending until we leave, making
3295  * it appears as if it had been generated at the UNPROTECT_CONTEXT(). At least we are
3296  * guaranteed to return consistent data to the user, it may simply be old. It is not
3297  * trivial to treat the overflow while inside the call because you may end up in
3298  * some module sampling buffer code causing deadlocks.
3299  */
3300 static int
3301 pfm_read_pmds(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3302 {
3303         struct thread_struct *thread = NULL;
3304         struct task_struct *task;
3305         unsigned long val = 0UL, lval, ovfl_mask, sval;
3306         pfarg_reg_t *req = (pfarg_reg_t *)arg;
3307         unsigned int cnum, reg_flags = 0;
3308         int i, can_access_pmu = 0, state;
3309         int is_loaded, is_system, is_counting, expert_mode;
3310         int ret = -EINVAL;
3311         pfm_reg_check_t rd_func;
3312
3313         /*
3314          * access is possible when loaded only for
3315          * self-monitoring tasks or in UP mode
3316          */
3317
3318         state     = ctx->ctx_state;
3319         is_loaded = state == PFM_CTX_LOADED ? 1 : 0;
3320         is_system = ctx->ctx_fl_system;
3321         ovfl_mask = pmu_conf->ovfl_val;
3322         task      = ctx->ctx_task;
3323
3324         if (state == PFM_CTX_ZOMBIE) return -EINVAL;
3325
3326         if (likely(is_loaded)) {
3327                 thread = &task->thread;
3328                 /*
3329                  * In system wide and when the context is loaded, access can only happen
3330                  * when the caller is running on the CPU being monitored by the session.
3331                  * It does not have to be the owner (ctx_task) of the context per se.
3332                  */
3333                 if (unlikely(is_system && ctx->ctx_cpu != smp_processor_id())) {
3334                         DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
3335                         return -EBUSY;
3336                 }
3337                 /*
3338                  * this can be true when not self-monitoring only in UP
3339                  */
3340                 can_access_pmu = GET_PMU_OWNER() == task || is_system ? 1 : 0;
3341
3342                 if (can_access_pmu) ia64_srlz_d();
3343         }
3344         expert_mode = pfm_sysctl.expert_mode;
3345
3346         DPRINT(("ld=%d apmu=%d ctx_state=%d\n",
3347                 is_loaded,
3348                 can_access_pmu,
3349                 state));
3350
3351         /*
3352          * on both UP and SMP, we can only read the PMD from the hardware register when
3353          * the task is the owner of the local PMU.
3354          */
3355
3356         for (i = 0; i < count; i++, req++) {
3357
3358                 cnum        = req->reg_num;
3359                 reg_flags   = req->reg_flags;
3360
3361                 if (unlikely(!PMD_IS_IMPL(cnum))) goto error;
3362                 /*
3363                  * we can only read the register that we use. That includes
3364                  * the one we explicitely initialize AND the one we want included
3365                  * in the sampling buffer (smpl_regs).
3366                  *
3367                  * Having this restriction allows optimization in the ctxsw routine
3368                  * without compromising security (leaks)
3369                  */
3370                 if (unlikely(!CTX_IS_USED_PMD(ctx, cnum))) goto error;
3371
3372                 sval        = ctx->ctx_pmds[cnum].val;
3373                 lval        = ctx->ctx_pmds[cnum].lval;
3374                 is_counting = PMD_IS_COUNTING(cnum);
3375
3376                 /*
3377                  * If the task is not the current one, then we check if the
3378                  * PMU state is still in the local live register due to lazy ctxsw.
3379                  * If true, then we read directly from the registers.
3380                  */
3381                 if (can_access_pmu){
3382                         val = ia64_get_pmd(cnum);
3383                 } else {
3384                         /*
3385                          * context has been saved
3386                          * if context is zombie, then task does not exist anymore.
3387                          * In this case, we use the full value saved in the context (pfm_flush_regs()).
3388                          */
3389                         val = is_loaded ? thread->pmds[cnum] : 0UL;
3390                 }
3391                 rd_func = pmu_conf->pmd_desc[cnum].read_check;
3392
3393                 if (is_counting) {
3394                         /*
3395                          * XXX: need to check for overflow when loaded
3396                          */
3397                         val &= ovfl_mask;
3398                         val += sval;
3399                 }
3400
3401                 /*
3402                  * execute read checker, if any
3403                  */
3404                 if (unlikely(expert_mode == 0 && rd_func)) {
3405                         unsigned long v = val;
3406                         ret = (*rd_func)(ctx->ctx_task, ctx, cnum, &v, regs);
3407                         if (ret) goto error;
3408                         val = v;
3409                         ret = -EINVAL;
3410                 }
3411
3412                 PFM_REG_RETFLAG_SET(reg_flags, 0);
3413
3414                 DPRINT(("pmd[%u]=0x%lx\n", cnum, val));
3415
3416                 /*
3417                  * update register return value, abort all if problem during copy.
3418                  * we only modify the reg_flags field. no check mode is fine because
3419                  * access has been verified upfront in sys_perfmonctl().
3420                  */
3421                 req->reg_value            = val;
3422                 req->reg_flags            = reg_flags;
3423                 req->reg_last_reset_val   = lval;
3424         }
3425
3426         return 0;
3427
3428 error:
3429         PFM_REG_RETFLAG_SET(req->reg_flags, PFM_REG_RETFL_EINVAL);
3430         return ret;
3431 }
3432
3433 int
3434 pfm_mod_write_pmcs(struct task_struct *task, void *req, unsigned int nreq, struct pt_regs *regs)
3435 {
3436         pfm_context_t *ctx;
3437
3438         if (req == NULL) return -EINVAL;
3439
3440         ctx = GET_PMU_CTX();
3441
3442         if (ctx == NULL) return -EINVAL;
3443
3444         /*
3445          * for now limit to current task, which is enough when calling
3446          * from overflow handler
3447          */
3448         if (task != current && ctx->ctx_fl_system == 0) return -EBUSY;
3449
3450         return pfm_write_pmcs(ctx, req, nreq, regs);
3451 }
3452 EXPORT_SYMBOL(pfm_mod_write_pmcs);
3453
3454 int
3455 pfm_mod_read_pmds(struct task_struct *task, void *req, unsigned int nreq, struct pt_regs *regs)
3456 {
3457         pfm_context_t *ctx;
3458
3459         if (req == NULL) return -EINVAL;
3460
3461         ctx = GET_PMU_CTX();
3462
3463         if (ctx == NULL) return -EINVAL;
3464
3465         /*
3466          * for now limit to current task, which is enough when calling
3467          * from overflow handler
3468          */
3469         if (task != current && ctx->ctx_fl_system == 0) return -EBUSY;
3470
3471         return pfm_read_pmds(ctx, req, nreq, regs);
3472 }
3473 EXPORT_SYMBOL(pfm_mod_read_pmds);
3474
3475 /*
3476  * Only call this function when a process it trying to
3477  * write the debug registers (reading is always allowed)
3478  */
3479 int
3480 pfm_use_debug_registers(struct task_struct *task)
3481 {
3482         pfm_context_t *ctx = task->thread.pfm_context;
3483         unsigned long flags;
3484         int ret = 0;
3485
3486         if (pmu_conf->use_rr_dbregs == 0) return 0;
3487
3488         DPRINT(("called for [%d]\n", task->pid));
3489
3490         /*
3491          * do it only once
3492          */
3493         if (task->thread.flags & IA64_THREAD_DBG_VALID) return 0;
3494
3495         /*
3496          * Even on SMP, we do not need to use an atomic here because
3497          * the only way in is via ptrace() and this is possible only when the
3498          * process is stopped. Even in the case where the ctxsw out is not totally
3499          * completed by the time we come here, there is no way the 'stopped' process
3500          * could be in the middle of fiddling with the pfm_write_ibr_dbr() routine.
3501          * So this is always safe.
3502          */
3503         if (ctx && ctx->ctx_fl_using_dbreg == 1) return -1;
3504
3505         LOCK_PFS(flags);
3506
3507         /*
3508          * We cannot allow setting breakpoints when system wide monitoring
3509          * sessions are using the debug registers.
3510          */
3511         if (pfm_sessions.pfs_sys_use_dbregs> 0)
3512                 ret = -1;
3513         else
3514                 pfm_sessions.pfs_ptrace_use_dbregs++;
3515
3516         DPRINT(("ptrace_use_dbregs=%u  sys_use_dbregs=%u by [%d] ret = %d\n",
3517                   pfm_sessions.pfs_ptrace_use_dbregs,
3518                   pfm_sessions.pfs_sys_use_dbregs,
3519                   task->pid, ret));
3520
3521         UNLOCK_PFS(flags);
3522
3523         return ret;
3524 }
3525
3526 /*
3527  * This function is called for every task that exits with the
3528  * IA64_THREAD_DBG_VALID set. This indicates a task which was
3529  * able to use the debug registers for debugging purposes via
3530  * ptrace(). Therefore we know it was not using them for
3531  * perfmormance monitoring, so we only decrement the number
3532  * of "ptraced" debug register users to keep the count up to date
3533  */
3534 int
3535 pfm_release_debug_registers(struct task_struct *task)
3536 {
3537         unsigned long flags;
3538         int ret;
3539
3540         if (pmu_conf->use_rr_dbregs == 0) return 0;
3541
3542         LOCK_PFS(flags);
3543         if (pfm_sessions.pfs_ptrace_use_dbregs == 0) {
3544                 printk(KERN_ERR "perfmon: invalid release for [%d] ptrace_use_dbregs=0\n", task->pid);
3545                 ret = -1;
3546         }  else {
3547                 pfm_sessions.pfs_ptrace_use_dbregs--;
3548                 ret = 0;
3549         }
3550         UNLOCK_PFS(flags);
3551
3552         return ret;
3553 }
3554
3555 static int
3556 pfm_restart(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3557 {
3558         struct task_struct *task;
3559         pfm_buffer_fmt_t *fmt;
3560         pfm_ovfl_ctrl_t rst_ctrl;
3561         int state, is_system;
3562         int ret = 0;
3563
3564         state     = ctx->ctx_state;
3565         fmt       = ctx->ctx_buf_fmt;
3566         is_system = ctx->ctx_fl_system;
3567         task      = PFM_CTX_TASK(ctx);
3568
3569         switch(state) {
3570                 case PFM_CTX_MASKED:
3571                         break;
3572                 case PFM_CTX_LOADED:
3573                         if (CTX_HAS_SMPL(ctx) && fmt->fmt_restart_active) break;
3574                         /* fall through */
3575                 case PFM_CTX_UNLOADED:
3576                 case PFM_CTX_ZOMBIE:
3577                         DPRINT(("invalid state=%d\n", state));
3578                         return -EBUSY;
3579                 default:
3580                         DPRINT(("state=%d, cannot operate (no active_restart handler)\n", state));
3581                         return -EINVAL;
3582         }
3583
3584         /*
3585          * In system wide and when the context is loaded, access can only happen
3586          * when the caller is running on the CPU being monitored by the session.
3587          * It does not have to be the owner (ctx_task) of the context per se.
3588          */
3589         if (is_system && ctx->ctx_cpu != smp_processor_id()) {
3590                 DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
3591                 return -EBUSY;
3592         }
3593
3594         /* sanity check */
3595         if (unlikely(task == NULL)) {
3596                 printk(KERN_ERR "perfmon: [%d] pfm_restart no task\n", current->pid);
3597                 return -EINVAL;
3598         }
3599
3600         if (task == current || is_system) {
3601
3602                 fmt = ctx->ctx_buf_fmt;
3603
3604                 DPRINT(("restarting self %d ovfl=0x%lx\n",
3605                         task->pid,
3606                         ctx->ctx_ovfl_regs[0]));
3607
3608                 if (CTX_HAS_SMPL(ctx)) {
3609
3610                         prefetch(ctx->ctx_smpl_hdr);
3611
3612                         rst_ctrl.bits.mask_monitoring = 0;
3613                         rst_ctrl.bits.reset_ovfl_pmds = 0;
3614
3615                         if (state == PFM_CTX_LOADED)
3616                                 ret = pfm_buf_fmt_restart_active(fmt, task, &rst_ctrl, ctx->ctx_smpl_hdr, regs);
3617                         else
3618                                 ret = pfm_buf_fmt_restart(fmt, task, &rst_ctrl, ctx->ctx_smpl_hdr, regs);
3619                 } else {
3620                         rst_ctrl.bits.mask_monitoring = 0;
3621                         rst_ctrl.bits.reset_ovfl_pmds = 1;
3622                 }
3623
3624                 if (ret == 0) {
3625                         if (rst_ctrl.bits.reset_ovfl_pmds)
3626                                 pfm_reset_regs(ctx, ctx->ctx_ovfl_regs, PFM_PMD_LONG_RESET);
3627
3628                         if (rst_ctrl.bits.mask_monitoring == 0) {
3629                                 DPRINT(("resuming monitoring for [%d]\n", task->pid));
3630
3631                                 if (state == PFM_CTX_MASKED) pfm_restore_monitoring(task);
3632                         } else {
3633                                 DPRINT(("keeping monitoring stopped for [%d]\n", task->pid));
3634
3635                                 // cannot use pfm_stop_monitoring(task, regs);
3636                         }
3637                 }
3638                 /*
3639                  * clear overflowed PMD mask to remove any stale information
3640                  */
3641                 ctx->ctx_ovfl_regs[0] = 0UL;
3642
3643                 /*
3644                  * back to LOADED state
3645                  */
3646                 ctx->ctx_state = PFM_CTX_LOADED;
3647
3648                 /*
3649                  * XXX: not really useful for self monitoring
3650                  */
3651                 ctx->ctx_fl_can_restart = 0;
3652
3653                 return 0;
3654         }
3655
3656         /*
3657          * restart another task
3658          */
3659
3660         /*
3661          * When PFM_CTX_MASKED, we cannot issue a restart before the previous
3662          * one is seen by the task.
3663          */
3664         if (state == PFM_CTX_MASKED) {
3665                 if (ctx->ctx_fl_can_restart == 0) return -EINVAL;
3666                 /*
3667                  * will prevent subsequent restart before this one is
3668                  * seen by other task
3669                  */
3670                 ctx->ctx_fl_can_restart = 0;
3671         }
3672
3673         /*
3674          * if blocking, then post the semaphore is PFM_CTX_MASKED, i.e.
3675          * the task is blocked or on its way to block. That's the normal
3676          * restart path. If the monitoring is not masked, then the task
3677          * can be actively monitoring and we cannot directly intervene.
3678          * Therefore we use the trap mechanism to catch the task and
3679          * force it to reset the buffer/reset PMDs.
3680          *
3681          * if non-blocking, then we ensure that the task will go into
3682          * pfm_handle_work() before returning to user mode.
3683          *
3684          * We cannot explicitely reset another task, it MUST always
3685          * be done by the task itself. This works for system wide because
3686          * the tool that is controlling the session is logically doing
3687          * "self-monitoring".
3688          */
3689         if (CTX_OVFL_NOBLOCK(ctx) == 0 && state == PFM_CTX_MASKED) {
3690                 DPRINT(("unblocking [%d] \n", task->pid));
3691                 complete(&ctx->ctx_restart_done);
3692         } else {
3693                 DPRINT(("[%d] armed exit trap\n", task->pid));
3694
3695                 ctx->ctx_fl_trap_reason = PFM_TRAP_REASON_RESET;
3696
3697                 PFM_SET_WORK_PENDING(task, 1);
3698
3699                 pfm_set_task_notify(task);
3700
3701                 /*
3702                  * XXX: send reschedule if task runs on another CPU
3703                  */
3704         }
3705         return 0;
3706 }
3707
3708 static int
3709 pfm_debug(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3710 {
3711         unsigned int m = *(unsigned int *)arg;
3712
3713         pfm_sysctl.debug = m == 0 ? 0 : 1;
3714
3715         printk(KERN_INFO "perfmon debugging %s (timing reset)\n", pfm_sysctl.debug ? "on" : "off");
3716
3717         if (m == 0) {
3718                 memset(pfm_stats, 0, sizeof(pfm_stats));
3719                 for(m=0; m < NR_CPUS; m++) pfm_stats[m].pfm_ovfl_intr_cycles_min = ~0UL;
3720         }
3721         return 0;
3722 }
3723
3724 /*
3725  * arg can be NULL and count can be zero for this function
3726  */
3727 static int
3728 pfm_write_ibr_dbr(int mode, pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3729 {
3730         struct thread_struct *thread = NULL;
3731         struct task_struct *task;
3732         pfarg_dbreg_t *req = (pfarg_dbreg_t *)arg;
3733         unsigned long flags;
3734         dbreg_t dbreg;
3735         unsigned int rnum;
3736         int first_time;
3737         int ret = 0, state;
3738         int i, can_access_pmu = 0;
3739         int is_system, is_loaded;
3740
3741         if (pmu_conf->use_rr_dbregs == 0) return -EINVAL;
3742
3743         state     = ctx->ctx_state;
3744         is_loaded = state == PFM_CTX_LOADED ? 1 : 0;
3745         is_system = ctx->ctx_fl_system;
3746         task      = ctx->ctx_task;
3747
3748         if (state == PFM_CTX_ZOMBIE) return -EINVAL;
3749
3750         /*
3751          * on both UP and SMP, we can only write to the PMC when the task is
3752          * the owner of the local PMU.
3753          */
3754         if (is_loaded) {
3755                 thread = &task->thread;
3756                 /*
3757                  * In system wide and when the context is loaded, access can only happen
3758                  * when the caller is running on the CPU being monitored by the session.
3759                  * It does not have to be the owner (ctx_task) of the context per se.
3760                  */
3761                 if (unlikely(is_system && ctx->ctx_cpu != smp_processor_id())) {
3762                         DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
3763                         return -EBUSY;
3764                 }
3765                 can_access_pmu = GET_PMU_OWNER() == task || is_system ? 1 : 0;
3766         }
3767
3768         /*
3769          * we do not need to check for ipsr.db because we do clear ibr.x, dbr.r, and dbr.w
3770          * ensuring that no real breakpoint can be installed via this call.
3771          *
3772          * IMPORTANT: regs can be NULL in this function
3773          */
3774
3775         first_time = ctx->ctx_fl_using_dbreg == 0;
3776
3777         /*
3778          * don't bother if we are loaded and task is being debugged
3779          */
3780         if (is_loaded && (thread->flags & IA64_THREAD_DBG_VALID) != 0) {
3781                 DPRINT(("debug registers already in use for [%d]\n", task->pid));
3782                 return -EBUSY;
3783         }
3784
3785         /*
3786          * check for debug registers in system wide mode
3787          *
3788          * If though a check is done in pfm_context_load(),
3789          * we must repeat it here, in case the registers are
3790          * written after the context is loaded
3791          */
3792         if (is_loaded) {
3793                 LOCK_PFS(flags);
3794
3795                 if (first_time && is_system) {
3796                         if (pfm_sessions.pfs_ptrace_use_dbregs)
3797                                 ret = -EBUSY;
3798                         else
3799                                 pfm_sessions.pfs_sys_use_dbregs++;
3800                 }
3801                 UNLOCK_PFS(flags);
3802         }
3803
3804         if (ret != 0) return ret;
3805
3806         /*
3807          * mark ourself as user of the debug registers for
3808          * perfmon purposes.
3809          */
3810         ctx->ctx_fl_using_dbreg = 1;
3811
3812         /*
3813          * clear hardware registers to make sure we don't
3814          * pick up stale state.
3815          *
3816          * for a system wide session, we do not use
3817          * thread.dbr, thread.ibr because this process
3818          * never leaves the current CPU and the state
3819          * is shared by all processes running on it
3820          */
3821         if (first_time && can_access_pmu) {
3822                 DPRINT(("[%d] clearing ibrs, dbrs\n", task->pid));
3823                 for (i=0; i < pmu_conf->num_ibrs; i++) {
3824                         ia64_set_ibr(i, 0UL);
3825                         ia64_dv_serialize_instruction();
3826                 }
3827                 ia64_srlz_i();
3828                 for (i=0; i < pmu_conf->num_dbrs; i++) {
3829                         ia64_set_dbr(i, 0UL);
3830                         ia64_dv_serialize_data();
3831                 }
3832                 ia64_srlz_d();
3833         }
3834
3835         /*
3836          * Now install the values into the registers
3837          */
3838         for (i = 0; i < count; i++, req++) {
3839
3840                 rnum      = req->dbreg_num;
3841                 dbreg.val = req->dbreg_value;
3842
3843                 ret = -EINVAL;
3844
3845                 if ((mode == PFM_CODE_RR && rnum >= PFM_NUM_IBRS) || ((mode == PFM_DATA_RR) && rnum >= PFM_NUM_DBRS)) {
3846                         DPRINT(("invalid register %u val=0x%lx mode=%d i=%d count=%d\n",
3847                                   rnum, dbreg.val, mode, i, count));
3848
3849                         goto abort_mission;
3850                 }
3851
3852                 /*
3853                  * make sure we do not install enabled breakpoint
3854                  */
3855                 if (rnum & 0x1) {
3856                         if (mode == PFM_CODE_RR)
3857                                 dbreg.ibr.ibr_x = 0;
3858                         else
3859                                 dbreg.dbr.dbr_r = dbreg.dbr.dbr_w = 0;
3860                 }
3861
3862                 PFM_REG_RETFLAG_SET(req->dbreg_flags, 0);
3863
3864                 /*
3865                  * Debug registers, just like PMC, can only be modified
3866                  * by a kernel call. Moreover, perfmon() access to those
3867                  * registers are centralized in this routine. The hardware
3868                  * does not modify the value of these registers, therefore,
3869                  * if we save them as they are written, we can avoid having
3870                  * to save them on context switch out. This is made possible
3871                  * by the fact that when perfmon uses debug registers, ptrace()
3872                  * won't be able to modify them concurrently.
3873                  */
3874                 if (mode == PFM_CODE_RR) {
3875                         CTX_USED_IBR(ctx, rnum);
3876
3877                         if (can_access_pmu) {
3878                                 ia64_set_ibr(rnum, dbreg.val);
3879                                 ia64_dv_serialize_instruction();
3880                         }
3881
3882                         ctx->ctx_ibrs[rnum] = dbreg.val;
3883
3884                         DPRINT(("write ibr%u=0x%lx used_ibrs=0x%x ld=%d apmu=%d\n",
3885                                 rnum, dbreg.val, ctx->ctx_used_ibrs[0], is_loaded, can_access_pmu));
3886                 } else {
3887                         CTX_USED_DBR(ctx, rnum);
3888
3889                         if (can_access_pmu) {
3890                                 ia64_set_dbr(rnum, dbreg.val);
3891                                 ia64_dv_serialize_data();
3892                         }
3893                         ctx->ctx_dbrs[rnum] = dbreg.val;
3894
3895                         DPRINT(("write dbr%u=0x%lx used_dbrs=0x%x ld=%d apmu=%d\n",
3896                                 rnum, dbreg.val, ctx->ctx_used_dbrs[0], is_loaded, can_access_pmu));
3897                 }
3898         }
3899
3900         return 0;
3901
3902 abort_mission:
3903         /*
3904          * in case it was our first attempt, we undo the global modifications
3905          */
3906         if (first_time) {
3907                 LOCK_PFS(flags);
3908                 if (ctx->ctx_fl_system) {
3909                         pfm_sessions.pfs_sys_use_dbregs--;
3910                 }
3911                 UNLOCK_PFS(flags);
3912                 ctx->ctx_fl_using_dbreg = 0;
3913         }
3914         /*
3915          * install error return flag
3916          */
3917         PFM_REG_RETFLAG_SET(req->dbreg_flags, PFM_REG_RETFL_EINVAL);
3918
3919         return ret;
3920 }
3921
3922 static int
3923 pfm_write_ibrs(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3924 {
3925         return pfm_write_ibr_dbr(PFM_CODE_RR, ctx, arg, count, regs);
3926 }
3927
3928 static int
3929 pfm_write_dbrs(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3930 {
3931         return pfm_write_ibr_dbr(PFM_DATA_RR, ctx, arg, count, regs);
3932 }
3933
3934 int
3935 pfm_mod_write_ibrs(struct task_struct *task, void *req, unsigned int nreq, struct pt_regs *regs)
3936 {
3937         pfm_context_t *ctx;
3938
3939         if (req == NULL) return -EINVAL;
3940
3941         ctx = GET_PMU_CTX();
3942
3943         if (ctx == NULL) return -EINVAL;
3944
3945         /*
3946          * for now limit to current task, which is enough when calling
3947          * from overflow handler
3948          */
3949         if (task != current && ctx->ctx_fl_system == 0) return -EBUSY;
3950
3951         return pfm_write_ibrs(ctx, req, nreq, regs);
3952 }
3953 EXPORT_SYMBOL(pfm_mod_write_ibrs);
3954
3955 int
3956 pfm_mod_write_dbrs(struct task_struct *task, void *req, unsigned int nreq, struct pt_regs *regs)
3957 {
3958         pfm_context_t *ctx;
3959
3960         if (req == NULL) return -EINVAL;
3961
3962         ctx = GET_PMU_CTX();
3963
3964         if (ctx == NULL) return -EINVAL;
3965
3966         /*
3967          * for now limit to current task, which is enough when calling
3968          * from overflow handler
3969          */
3970         if (task != current && ctx->ctx_fl_system == 0) return -EBUSY;
3971
3972         return pfm_write_dbrs(ctx, req, nreq, regs);
3973 }
3974 EXPORT_SYMBOL(pfm_mod_write_dbrs);
3975
3976
3977 static int
3978 pfm_get_features(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3979 {
3980         pfarg_features_t *req = (pfarg_features_t *)arg;
3981
3982         req->ft_version = PFM_VERSION;
3983         return 0;
3984 }
3985
3986 static int
3987 pfm_stop(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
3988 {
3989         struct pt_regs *tregs;
3990         struct task_struct *task = PFM_CTX_TASK(ctx);
3991         int state, is_system;
3992
3993         state     = ctx->ctx_state;
3994         is_system = ctx->ctx_fl_system;
3995
3996         /*
3997          * context must be attached to issue the stop command (includes LOADED,MASKED,ZOMBIE)
3998          */
3999         if (state == PFM_CTX_UNLOADED) return -EINVAL;
4000
4001         /*
4002          * In system wide and when the context is loaded, access can only happen
4003          * when the caller is running on the CPU being monitored by the session.
4004          * It does not have to be the owner (ctx_task) of the context per se.
4005          */
4006         if (is_system && ctx->ctx_cpu != smp_processor_id()) {
4007                 DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
4008                 return -EBUSY;
4009         }
4010         DPRINT(("task [%d] ctx_state=%d is_system=%d\n",
4011                 PFM_CTX_TASK(ctx)->pid,
4012                 state,
4013                 is_system));
4014         /*
4015          * in system mode, we need to update the PMU directly
4016          * and the user level state of the caller, which may not
4017          * necessarily be the creator of the context.
4018          */
4019         if (is_system) {
4020                 /*
4021                  * Update local PMU first
4022                  *
4023                  * disable dcr pp
4024                  */
4025                 ia64_setreg(_IA64_REG_CR_DCR, ia64_getreg(_IA64_REG_CR_DCR) & ~IA64_DCR_PP);
4026                 ia64_srlz_i();
4027
4028                 /*
4029                  * update local cpuinfo
4030                  */
4031                 PFM_CPUINFO_CLEAR(PFM_CPUINFO_DCR_PP);
4032
4033                 /*
4034                  * stop monitoring, does srlz.i
4035                  */
4036                 pfm_clear_psr_pp();
4037
4038                 /*
4039                  * stop monitoring in the caller
4040                  */
4041                 ia64_psr(regs)->pp = 0;
4042
4043                 return 0;
4044         }
4045         /*
4046          * per-task mode
4047          */
4048
4049         if (task == current) {
4050                 /* stop monitoring  at kernel level */
4051                 pfm_clear_psr_up();
4052
4053                 /*
4054                  * stop monitoring at the user level
4055                  */
4056                 ia64_psr(regs)->up = 0;
4057         } else {
4058                 tregs = task_pt_regs(task);
4059
4060                 /*
4061                  * stop monitoring at the user level
4062                  */
4063                 ia64_psr(tregs)->up = 0;
4064
4065                 /*
4066                  * monitoring disabled in kernel at next reschedule
4067                  */
4068                 ctx->ctx_saved_psr_up = 0;
4069                 DPRINT(("task=[%d]\n", task->pid));
4070         }
4071         return 0;
4072 }
4073
4074
4075 static int
4076 pfm_start(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
4077 {
4078         struct pt_regs *tregs;
4079         int state, is_system;
4080
4081         state     = ctx->ctx_state;
4082         is_system = ctx->ctx_fl_system;
4083
4084         if (state != PFM_CTX_LOADED) return -EINVAL;
4085
4086         /*
4087          * In system wide and when the context is loaded, access can only happen
4088          * when the caller is running on the CPU being monitored by the session.
4089          * It does not have to be the owner (ctx_task) of the context per se.
4090          */
4091         if (is_system && ctx->ctx_cpu != smp_processor_id()) {
4092                 DPRINT(("should be running on CPU%d\n", ctx->ctx_cpu));
4093                 return -EBUSY;
4094         }
4095
4096         /*
4097          * in system mode, we need to update the PMU directly
4098          * and the user level state of the caller, which may not
4099          * necessarily be the creator of the context.
4100          */
4101         if (is_system) {
4102
4103                 /*
4104                  * set user level psr.pp for the caller
4105                  */
4106                 ia64_psr(regs)->pp = 1;
4107
4108                 /*
4109                  * now update the local PMU and cpuinfo
4110                  */
4111                 PFM_CPUINFO_SET(PFM_CPUINFO_DCR_PP);
4112
4113                 /*
4114                  * start monitoring at kernel level
4115                  */
4116                 pfm_set_psr_pp();
4117
4118                 /* enable dcr pp */
4119                 ia64_setreg(_IA64_REG_CR_DCR, ia64_getreg(_IA64_REG_CR_DCR) | IA64_DCR_PP);
4120                 ia64_srlz_i();
4121
4122                 return 0;
4123         }
4124
4125         /*
4126          * per-process mode
4127          */
4128
4129         if (ctx->ctx_task == current) {
4130
4131                 /* start monitoring at kernel level */
4132                 pfm_set_psr_up();
4133
4134                 /*
4135                  * activate monitoring at user level
4136                  */
4137                 ia64_psr(regs)->up = 1;
4138
4139         } else {
4140                 tregs = task_pt_regs(ctx->ctx_task);
4141
4142                 /*
4143                  * start monitoring at the kernel level the next
4144                  * time the task is scheduled
4145                  */
4146                 ctx->ctx_saved_psr_up = IA64_PSR_UP;
4147
4148                 /*
4149                  * activate monitoring at user level
4150                  */
4151                 ia64_psr(tregs)->up = 1;
4152         }
4153         return 0;
4154 }
4155
4156 static int
4157 pfm_get_pmc_reset(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
4158 {
4159         pfarg_reg_t *req = (pfarg_reg_t *)arg;
4160         unsigned int cnum;
4161         int i;
4162         int ret = -EINVAL;
4163
4164         for (i = 0; i < count; i++, req++) {
4165
4166                 cnum = req->reg_num;
4167
4168                 if (!PMC_IS_IMPL(cnum)) goto abort_mission;
4169
4170                 req->reg_value = PMC_DFL_VAL(cnum);
4171
4172                 PFM_REG_RETFLAG_SET(req->reg_flags, 0);
4173
4174                 DPRINT(("pmc_reset_val pmc[%u]=0x%lx\n", cnum, req->reg_value));
4175         }
4176         return 0;
4177
4178 abort_mission:
4179         PFM_REG_RETFLAG_SET(req->reg_flags, PFM_REG_RETFL_EINVAL);
4180         return ret;
4181 }
4182
4183 static int
4184 pfm_check_task_exist(pfm_context_t *ctx)
4185 {
4186         struct task_struct *g, *t;
4187         int ret = -ESRCH;
4188
4189         read_lock(&tasklist_lock);
4190
4191         do_each_thread (g, t) {
4192                 if (t->thread.pfm_context == ctx) {
4193                         ret = 0;
4194                         break;
4195                 }
4196         } while_each_thread (g, t);
4197
4198         read_unlock(&tasklist_lock);
4199
4200         DPRINT(("pfm_check_task_exist: ret=%d ctx=%p\n", ret, ctx));
4201
4202         return ret;
4203 }
4204
4205 static int
4206 pfm_context_load(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
4207 {
4208         struct task_struct *task;
4209         struct thread_struct *thread;
4210         struct pfm_context_t *old;
4211         unsigned long flags;
4212 #ifndef CONFIG_SMP
4213         struct task_struct *owner_task = NULL;
4214 #endif
4215         pfarg_load_t *req = (pfarg_load_t *)arg;
4216         unsigned long *pmcs_source, *pmds_source;
4217         int the_cpu;
4218         int ret = 0;
4219         int state, is_system, set_dbregs = 0;
4220
4221         state     = ctx->ctx_state;
4222         is_system = ctx->ctx_fl_system;
4223         /*
4224          * can only load from unloaded or terminated state
4225          */
4226         if (state != PFM_CTX_UNLOADED) {
4227                 DPRINT(("cannot load to [%d], invalid ctx_state=%d\n",
4228                         req->load_pid,
4229                         ctx->ctx_state));
4230                 return -EBUSY;
4231         }
4232
4233         DPRINT(("load_pid [%d] using_dbreg=%d\n", req->load_pid, ctx->ctx_fl_using_dbreg));
4234
4235         if (CTX_OVFL_NOBLOCK(ctx) == 0 && req->load_pid == current->pid) {
4236                 DPRINT(("cannot use blocking mode on self\n"));
4237                 return -EINVAL;
4238         }
4239
4240         ret = pfm_get_task(ctx, req->load_pid, &task);
4241         if (ret) {
4242                 DPRINT(("load_pid [%d] get_task=%d\n", req->load_pid, ret));
4243                 return ret;
4244         }
4245
4246         ret = -EINVAL;
4247
4248         /*
4249          * system wide is self monitoring only
4250          */
4251         if (is_system && task != current) {
4252                 DPRINT(("system wide is self monitoring only load_pid=%d\n",
4253                         req->load_pid));
4254                 goto error;
4255         }
4256
4257         thread = &task->thread;
4258
4259         ret = 0;
4260         /*
4261          * cannot load a context which is using range restrictions,
4262          * into a task that is being debugged.
4263          */
4264         if (ctx->ctx_fl_using_dbreg) {
4265                 if (thread->flags & IA64_THREAD_DBG_VALID) {
4266                         ret = -EBUSY;
4267                         DPRINT(("load_pid [%d] task is debugged, cannot load range restrictions\n", req->load_pid));
4268                         goto error;
4269                 }
4270                 LOCK_PFS(flags);
4271
4272                 if (is_system) {
4273                         if (pfm_sessions.pfs_ptrace_use_dbregs) {
4274                                 DPRINT(("cannot load [%d] dbregs in use\n", task->pid));
4275                                 ret = -EBUSY;
4276                         } else {
4277                                 pfm_sessions.pfs_sys_use_dbregs++;
4278                                 DPRINT(("load [%d] increased sys_use_dbreg=%u\n", task->pid, pfm_sessions.pfs_sys_use_dbregs));
4279                                 set_dbregs = 1;
4280                         }
4281                 }
4282
4283                 UNLOCK_PFS(flags);
4284
4285                 if (ret) goto error;
4286         }
4287
4288         /*
4289          * SMP system-wide monitoring implies self-monitoring.
4290          *
4291          * The programming model expects the task to
4292          * be pinned on a CPU throughout the session.
4293          * Here we take note of the current CPU at the
4294          * time the context is loaded. No call from
4295          * another CPU will be allowed.
4296          *
4297          * The pinning via shed_setaffinity()
4298          * must be done by the calling task prior
4299          * to this call.
4300          *
4301          * systemwide: keep track of CPU this session is supposed to run on
4302          */
4303         the_cpu = ctx->ctx_cpu = smp_processor_id();
4304
4305         ret = -EBUSY;
4306         /*
4307          * now reserve the session
4308          */
4309         ret = pfm_reserve_session(current, is_system, the_cpu);
4310         if (ret) goto error;
4311
4312         /*
4313          * task is necessarily stopped at this point.
4314          *
4315          * If the previous context was zombie, then it got removed in
4316          * pfm_save_regs(). Therefore we should not see it here.
4317          * If we see a context, then this is an active context
4318          *
4319          * XXX: needs to be atomic
4320          */
4321         DPRINT(("before cmpxchg() old_ctx=%p new_ctx=%p\n",
4322                 thread->pfm_context, ctx));
4323
4324         ret = -EBUSY;
4325         old = ia64_cmpxchg(acq, &thread->pfm_context, NULL, ctx, sizeof(pfm_context_t *));
4326         if (old != NULL) {
4327                 DPRINT(("load_pid [%d] already has a context\n", req->load_pid));
4328                 goto error_unres;
4329         }
4330
4331         pfm_reset_msgq(ctx);
4332
4333         ctx->ctx_state = PFM_CTX_LOADED;
4334
4335         /*
4336          * link context to task
4337          */
4338         ctx->ctx_task = task;
4339
4340         if (is_system) {
4341                 /*
4342                  * we load as stopped
4343                  */
4344                 PFM_CPUINFO_SET(PFM_CPUINFO_SYST_WIDE);
4345                 PFM_CPUINFO_CLEAR(PFM_CPUINFO_DCR_PP);
4346
4347                 if (ctx->ctx_fl_excl_idle) PFM_CPUINFO_SET(PFM_CPUINFO_EXCL_IDLE);
4348         } else {
4349                 thread->flags |= IA64_THREAD_PM_VALID;
4350         }
4351
4352         /*
4353          * propagate into thread-state
4354          */
4355         pfm_copy_pmds(task, ctx);
4356         pfm_copy_pmcs(task, ctx);
4357
4358         pmcs_source = thread->pmcs;
4359         pmds_source = thread->pmds;
4360
4361         /*
4362          * always the case for system-wide
4363          */
4364         if (task == current) {
4365
4366                 if (is_system == 0) {
4367
4368                         /* allow user level control */
4369                         ia64_psr(regs)->sp = 0;
4370                         DPRINT(("clearing psr.sp for [%d]\n", task->pid));
4371
4372                         SET_LAST_CPU(ctx, smp_processor_id());
4373                         INC_ACTIVATION();
4374                         SET_ACTIVATION(ctx);
4375 #ifndef CONFIG_SMP
4376                         /*
4377                          * push the other task out, if any
4378                          */
4379                         owner_task = GET_PMU_OWNER();
4380                         if (owner_task) pfm_lazy_save_regs(owner_task);
4381 #endif
4382                 }
4383                 /*
4384                  * load all PMD from ctx to PMU (as opposed to thread state)
4385                  * restore all PMC from ctx to PMU
4386                  */
4387                 pfm_restore_pmds(pmds_source, ctx->ctx_all_pmds[0]);
4388                 pfm_restore_pmcs(pmcs_source, ctx->ctx_all_pmcs[0]);
4389
4390                 ctx->ctx_reload_pmcs[0] = 0UL;
4391                 ctx->ctx_reload_pmds[0] = 0UL;
4392
4393                 /*
4394                  * guaranteed safe by earlier check against DBG_VALID
4395                  */
4396                 if (ctx->ctx_fl_using_dbreg) {
4397                         pfm_restore_ibrs(ctx->ctx_ibrs, pmu_conf->num_ibrs);
4398                         pfm_restore_dbrs(ctx->ctx_dbrs, pmu_conf->num_dbrs);
4399                 }
4400                 /*
4401                  * set new ownership
4402                  */
4403                 SET_PMU_OWNER(task, ctx);
4404
4405                 DPRINT(("context loaded on PMU for [%d]\n", task->pid));
4406         } else {
4407                 /*
4408                  * when not current, task MUST be stopped, so this is safe
4409                  */
4410                 regs = task_pt_regs(task);
4411
4412                 /* force a full reload */
4413                 ctx->ctx_last_activation = PFM_INVALID_ACTIVATION;
4414                 SET_LAST_CPU(ctx, -1);
4415
4416                 /* initial saved psr (stopped) */
4417                 ctx->ctx_saved_psr_up = 0UL;
4418                 ia64_psr(regs)->up = ia64_psr(regs)->pp = 0;
4419         }
4420
4421         ret = 0;
4422
4423 error_unres:
4424         if (ret) pfm_unreserve_session(ctx, ctx->ctx_fl_system, the_cpu);
4425 error:
4426         /*
4427          * we must undo the dbregs setting (for system-wide)
4428          */
4429         if (ret && set_dbregs) {
4430                 LOCK_PFS(flags);
4431                 pfm_sessions.pfs_sys_use_dbregs--;
4432                 UNLOCK_PFS(flags);
4433         }
4434         /*
4435          * release task, there is now a link with the context
4436          */
4437         if (is_system == 0 && task != current) {
4438                 pfm_put_task(task);
4439
4440                 if (ret == 0) {
4441                         ret = pfm_check_task_exist(ctx);
4442                         if (ret) {
4443                                 ctx->ctx_state = PFM_CTX_UNLOADED;
4444                                 ctx->ctx_task  = NULL;
4445                         }
4446                 }
4447         }
4448         return ret;
4449 }
4450
4451 /*
4452  * in this function, we do not need to increase the use count
4453  * for the task via get_task_struct(), because we hold the
4454  * context lock. If the task were to disappear while having
4455  * a context attached, it would go through pfm_exit_thread()
4456  * which also grabs the context lock  and would therefore be blocked
4457  * until we are here.
4458  */
4459 static void pfm_flush_pmds(struct task_struct *, pfm_context_t *ctx);
4460
4461 static int
4462 pfm_context_unload(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
4463 {
4464         struct task_struct *task = PFM_CTX_TASK(ctx);
4465         struct pt_regs *tregs;
4466         int prev_state, is_system;
4467         int ret;
4468
4469         DPRINT(("ctx_state=%d task [%d]\n", ctx->ctx_state, task ? task->pid : -1));
4470
4471         prev_state = ctx->ctx_state;
4472         is_system  = ctx->ctx_fl_system;
4473
4474         /*
4475          * unload only when necessary
4476          */
4477         if (prev_state == PFM_CTX_UNLOADED) {
4478                 DPRINT(("ctx_state=%d, nothing to do\n", prev_state));
4479                 return 0;
4480         }
4481
4482         /*
4483          * clear psr and dcr bits
4484          */
4485         ret = pfm_stop(ctx, NULL, 0, regs);
4486         if (ret) return ret;
4487
4488         ctx->ctx_state = PFM_CTX_UNLOADED;
4489
4490         /*
4491          * in system mode, we need to update the PMU directly
4492          * and the user level state of the caller, which may not
4493          * necessarily be the creator of the context.
4494          */
4495         if (is_system) {
4496
4497                 /*
4498                  * Update cpuinfo
4499                  *
4500                  * local PMU is taken care of in pfm_stop()
4501                  */
4502                 PFM_CPUINFO_CLEAR(PFM_CPUINFO_SYST_WIDE);
4503                 PFM_CPUINFO_CLEAR(PFM_CPUINFO_EXCL_IDLE);
4504
4505                 /*
4506                  * save PMDs in context
4507                  * release ownership
4508                  */
4509                 pfm_flush_pmds(current, ctx);
4510
4511                 /*
4512                  * at this point we are done with the PMU
4513                  * so we can unreserve the resource.
4514                  */
4515                 if (prev_state != PFM_CTX_ZOMBIE)
4516                         pfm_unreserve_session(ctx, 1 , ctx->ctx_cpu);
4517
4518                 /*
4519                  * disconnect context from task
4520                  */
4521                 task->thread.pfm_context = NULL;
4522                 /*
4523                  * disconnect task from context
4524                  */
4525                 ctx->ctx_task = NULL;
4526
4527                 /*
4528                  * There is nothing more to cleanup here.
4529                  */
4530                 return 0;
4531         }
4532
4533         /*
4534          * per-task mode
4535          */
4536         tregs = task == current ? regs : task_pt_regs(task);
4537
4538         if (task == current) {
4539                 /*
4540                  * cancel user level control
4541                  */
4542                 ia64_psr(regs)->sp = 1;
4543
4544                 DPRINT(("setting psr.sp for [%d]\n", task->pid));
4545         }
4546         /*
4547          * save PMDs to context
4548          * release ownership
4549          */
4550         pfm_flush_pmds(task, ctx);
4551
4552         /*
4553          * at this point we are done with the PMU
4554          * so we can unreserve the resource.
4555          *
4556          * when state was ZOMBIE, we have already unreserved.
4557          */
4558         if (prev_state != PFM_CTX_ZOMBIE)
4559                 pfm_unreserve_session(ctx, 0 , ctx->ctx_cpu);
4560
4561         /*
4562          * reset activation counter and psr
4563          */
4564         ctx->ctx_last_activation = PFM_INVALID_ACTIVATION;
4565         SET_LAST_CPU(ctx, -1);
4566
4567         /*
4568          * PMU state will not be restored
4569          */
4570         task->thread.flags &= ~IA64_THREAD_PM_VALID;
4571
4572         /*
4573          * break links between context and task
4574          */
4575         task->thread.pfm_context  = NULL;
4576         ctx->ctx_task             = NULL;
4577
4578         PFM_SET_WORK_PENDING(task, 0);
4579
4580         ctx->ctx_fl_trap_reason  = PFM_TRAP_REASON_NONE;
4581         ctx->ctx_fl_can_restart  = 0;
4582         ctx->ctx_fl_going_zombie = 0;
4583
4584         DPRINT(("disconnected [%d] from context\n", task->pid));
4585
4586         return 0;
4587 }
4588
4589
4590 /*
4591  * called only from exit_thread(): task == current
4592  * we come here only if current has a context attached (loaded or masked)
4593  */
4594 void
4595 pfm_exit_thread(struct task_struct *task)
4596 {
4597         pfm_context_t *ctx;
4598         unsigned long flags;
4599         struct pt_regs *regs = task_pt_regs(task);
4600         int ret, state;
4601         int free_ok = 0;
4602
4603         ctx = PFM_GET_CTX(task);
4604
4605         PROTECT_CTX(ctx, flags);
4606
4607         DPRINT(("state=%d task [%d]\n", ctx->ctx_state, task->pid));
4608
4609         state = ctx->ctx_state;
4610         switch(state) {
4611                 case PFM_CTX_UNLOADED:
4612                         /*
4613                          * only comes to thios function if pfm_context is not NULL, i.e., cannot
4614                          * be in unloaded state
4615                          */
4616                         printk(KERN_ERR "perfmon: pfm_exit_thread [%d] ctx unloaded\n", task->pid);
4617                         break;
4618                 case PFM_CTX_LOADED:
4619                 case PFM_CTX_MASKED:
4620                         ret = pfm_context_unload(ctx, NULL, 0, regs);
4621                         if (ret) {
4622                                 printk(KERN_ERR "perfmon: pfm_exit_thread [%d] state=%d unload failed %d\n", task->pid, state, ret);
4623                         }
4624                         DPRINT(("ctx unloaded for current state was %d\n", state));
4625
4626                         pfm_end_notify_user(ctx);
4627                         break;
4628                 case PFM_CTX_ZOMBIE:
4629                         ret = pfm_context_unload(ctx, NULL, 0, regs);
4630                         if (ret) {
4631                                 printk(KERN_ERR "perfmon: pfm_exit_thread [%d] state=%d unload failed %d\n", task->pid, state, ret);
4632                         }
4633                         free_ok = 1;
4634                         break;
4635                 default:
4636                         printk(KERN_ERR "perfmon: pfm_exit_thread [%d] unexpected state=%d\n", task->pid, state);
4637                         break;
4638         }
4639         UNPROTECT_CTX(ctx, flags);
4640
4641         { u64 psr = pfm_get_psr();
4642           BUG_ON(psr & (IA64_PSR_UP|IA64_PSR_PP));
4643           BUG_ON(GET_PMU_OWNER());
4644           BUG_ON(ia64_psr(regs)->up);
4645           BUG_ON(ia64_psr(regs)->pp);
4646         }
4647
4648         /*
4649          * All memory free operations (especially for vmalloc'ed memory)
4650          * MUST be done with interrupts ENABLED.
4651          */
4652         if (free_ok) pfm_context_free(ctx);
4653 }
4654
4655 /*
4656  * functions MUST be listed in the increasing order of their index (see permfon.h)
4657  */
4658 #define PFM_CMD(name, flags, arg_count, arg_type, getsz) { name, #name, flags, arg_count, sizeof(arg_type), getsz }
4659 #define PFM_CMD_S(name, flags) { name, #name, flags, 0, 0, NULL }
4660 #define PFM_CMD_PCLRWS  (PFM_CMD_FD|PFM_CMD_ARG_RW|PFM_CMD_STOP)
4661 #define PFM_CMD_PCLRW   (PFM_CMD_FD|PFM_CMD_ARG_RW)
4662 #define PFM_CMD_NONE    { NULL, "no-cmd", 0, 0, 0, NULL}
4663
4664 static pfm_cmd_desc_t pfm_cmd_tab[]={
4665 /* 0  */PFM_CMD_NONE,
4666 /* 1  */PFM_CMD(pfm_write_pmcs, PFM_CMD_PCLRWS, PFM_CMD_ARG_MANY, pfarg_reg_t, NULL),
4667 /* 2  */PFM_CMD(pfm_write_pmds, PFM_CMD_PCLRWS, PFM_CMD_ARG_MANY, pfarg_reg_t, NULL),
4668 /* 3  */PFM_CMD(pfm_read_pmds, PFM_CMD_PCLRWS, PFM_CMD_ARG_MANY, pfarg_reg_t, NULL),
4669 /* 4  */PFM_CMD_S(pfm_stop, PFM_CMD_PCLRWS),
4670 /* 5  */PFM_CMD_S(pfm_start, PFM_CMD_PCLRWS),
4671 /* 6  */PFM_CMD_NONE,
4672 /* 7  */PFM_CMD_NONE,
4673 /* 8  */PFM_CMD(pfm_context_create, PFM_CMD_ARG_RW, 1, pfarg_context_t, pfm_ctx_getsize),
4674 /* 9  */PFM_CMD_NONE,
4675 /* 10 */PFM_CMD_S(pfm_restart, PFM_CMD_PCLRW),
4676 /* 11 */PFM_CMD_NONE,
4677 /* 12 */PFM_CMD(pfm_get_features, PFM_CMD_ARG_RW, 1, pfarg_features_t, NULL),
4678 /* 13 */PFM_CMD(pfm_debug, 0, 1, unsigned int, NULL),
4679 /* 14 */PFM_CMD_NONE,
4680 /* 15 */PFM_CMD(pfm_get_pmc_reset, PFM_CMD_ARG_RW, PFM_CMD_ARG_MANY, pfarg_reg_t, NULL),
4681 /* 16 */PFM_CMD(pfm_context_load, PFM_CMD_PCLRWS, 1, pfarg_load_t, NULL),
4682 /* 17 */PFM_CMD_S(pfm_context_unload, PFM_CMD_PCLRWS),
4683 /* 18 */PFM_CMD_NONE,
4684 /* 19 */PFM_CMD_NONE,
4685 /* 20 */PFM_CMD_NONE,
4686 /* 21 */PFM_CMD_NONE,
4687 /* 22 */PFM_CMD_NONE,
4688 /* 23 */PFM_CMD_NONE,
4689 /* 24 */PFM_CMD_NONE,
4690 /* 25 */PFM_CMD_NONE,
4691 /* 26 */PFM_CMD_NONE,
4692 /* 27 */PFM_CMD_NONE,
4693 /* 28 */PFM_CMD_NONE,
4694 /* 29 */PFM_CMD_NONE,
4695 /* 30 */PFM_CMD_NONE,
4696 /* 31 */PFM_CMD_NONE,
4697 /* 32 */PFM_CMD(pfm_write_ibrs, PFM_CMD_PCLRWS, PFM_CMD_ARG_MANY, pfarg_dbreg_t, NULL),
4698 /* 33 */PFM_CMD(pfm_write_dbrs, PFM_CMD_PCLRWS, PFM_CMD_ARG_MANY, pfarg_dbreg_t, NULL)
4699 };
4700 #define PFM_CMD_COUNT   (sizeof(pfm_cmd_tab)/sizeof(pfm_cmd_desc_t))
4701
4702 static int
4703 pfm_check_task_state(pfm_context_t *ctx, int cmd, unsigned long flags)
4704 {
4705         struct task_struct *task;
4706         int state, old_state;
4707
4708 recheck:
4709         state = ctx->ctx_state;
4710         task  = ctx->ctx_task;
4711
4712         if (task == NULL) {
4713                 DPRINT(("context %d no task, state=%d\n", ctx->ctx_fd, state));
4714                 return 0;
4715         }
4716
4717         DPRINT(("context %d state=%d [%d] task_state=%ld must_stop=%d\n",
4718                 ctx->ctx_fd,
4719                 state,
4720                 task->pid,
4721                 task->state, PFM_CMD_STOPPED(cmd)));
4722
4723         /*
4724          * self-monitoring always ok.
4725          *
4726          * for system-wide the caller can either be the creator of the
4727          * context (to one to which the context is attached to) OR
4728          * a task running on the same CPU as the session.
4729          */
4730         if (task == current || ctx->ctx_fl_system) return 0;
4731
4732         /*
4733          * we are monitoring another thread
4734          */
4735         switch(state) {
4736                 case PFM_CTX_UNLOADED:
4737                         /*
4738                          * if context is UNLOADED we are safe to go
4739                          */
4740                         return 0;
4741                 case PFM_CTX_ZOMBIE:
4742                         /*
4743                          * no command can operate on a zombie context
4744                          */
4745                         DPRINT(("cmd %d state zombie cannot operate on context\n", cmd));
4746                         return -EINVAL;
4747                 case PFM_CTX_MASKED:
4748                         /*
4749                          * PMU state has been saved to software even though
4750                          * the thread may still be running.
4751                          */
4752                         if (cmd != PFM_UNLOAD_CONTEXT) return 0;
4753         }
4754
4755         /*
4756          * context is LOADED or MASKED. Some commands may need to have
4757          * the task stopped.
4758          *
4759          * We could lift this restriction for UP but it would mean that
4760          * the user has no guarantee the task would not run between
4761          * two successive calls to perfmonctl(). That's probably OK.
4762          * If this user wants to ensure the task does not run, then
4763          * the task must be stopped.
4764          */
4765         if (PFM_CMD_STOPPED(cmd)) {
4766                 if ((task->state != TASK_STOPPED) && (task->state != TASK_TRACED)) {
4767                         DPRINT(("[%d] task not in stopped state\n", task->pid));
4768                         return -EBUSY;
4769                 }
4770                 /*
4771                  * task is now stopped, wait for ctxsw out
4772                  *
4773                  * This is an interesting point in the code.
4774                  * We need to unprotect the context because
4775                  * the pfm_save_regs() routines needs to grab
4776                  * the same lock. There are danger in doing
4777                  * this because it leaves a window open for
4778                  * another task to get access to the context
4779                  * and possibly change its state. The one thing
4780                  * that is not possible is for the context to disappear
4781                  * because we are protected by the VFS layer, i.e.,
4782                  * get_fd()/put_fd().
4783                  */
4784                 old_state = state;
4785
4786                 UNPROTECT_CTX(ctx, flags);
4787
4788                 wait_task_inactive(task);
4789
4790                 PROTECT_CTX(ctx, flags);
4791
4792                 /*
4793                  * we must recheck to verify if state has changed
4794                  */
4795                 if (ctx->ctx_state != old_state) {
4796                         DPRINT(("old_state=%d new_state=%d\n", old_state, ctx->ctx_state));
4797                         goto recheck;
4798                 }
4799         }
4800         return 0;
4801 }
4802
4803 /*
4804  * system-call entry point (must return long)
4805  */
4806 asmlinkage long
4807 sys_perfmonctl (int fd, int cmd, void __user *arg, int count)
4808 {
4809         struct file *file = NULL;
4810         pfm_context_t *ctx = NULL;
4811         unsigned long flags = 0UL;
4812         void *args_k = NULL;
4813         long ret; /* will expand int return types */
4814         size_t base_sz, sz, xtra_sz = 0;
4815         int narg, completed_args = 0, call_made = 0, cmd_flags;
4816         int (*func)(pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs);
4817         int (*getsize)(void *arg, size_t *sz);
4818 #define PFM_MAX_ARGSIZE 4096
4819
4820         /*
4821          * reject any call if perfmon was disabled at initialization
4822          */
4823         if (unlikely(pmu_conf == NULL)) return -ENOSYS;
4824
4825         if (unlikely(cmd < 0 || cmd >= PFM_CMD_COUNT)) {
4826                 DPRINT(("invalid cmd=%d\n", cmd));
4827                 return -EINVAL;
4828         }
4829
4830         func      = pfm_cmd_tab[cmd].cmd_func;
4831         narg      = pfm_cmd_tab[cmd].cmd_narg;
4832         base_sz   = pfm_cmd_tab[cmd].cmd_argsize;
4833         getsize   = pfm_cmd_tab[cmd].cmd_getsize;
4834         cmd_flags = pfm_cmd_tab[cmd].cmd_flags;
4835
4836         if (unlikely(func == NULL)) {
4837                 DPRINT(("invalid cmd=%d\n", cmd));
4838                 return -EINVAL;
4839         }
4840
4841         DPRINT(("cmd=%s idx=%d narg=0x%x argsz=%lu count=%d\n",
4842                 PFM_CMD_NAME(cmd),
4843                 cmd,
4844                 narg,
4845                 base_sz,
4846                 count));
4847
4848         /*
4849          * check if number of arguments matches what the command expects
4850          */
4851         if (unlikely((narg == PFM_CMD_ARG_MANY && count <= 0) || (narg > 0 && narg != count)))
4852                 return -EINVAL;
4853
4854 restart_args:
4855         sz = xtra_sz + base_sz*count;
4856         /*
4857          * limit abuse to min page size
4858          */
4859         if (unlikely(sz > PFM_MAX_ARGSIZE)) {
4860                 printk(KERN_ERR "perfmon: [%d] argument too big %lu\n", current->pid, sz);
4861                 return -E2BIG;
4862         }
4863
4864         /*
4865          * allocate default-sized argument buffer
4866          */
4867         if (likely(count && args_k == NULL)) {
4868                 args_k = kmalloc(PFM_MAX_ARGSIZE, GFP_KERNEL);
4869                 if (args_k == NULL) return -ENOMEM;
4870         }
4871
4872         ret = -EFAULT;
4873
4874         /*
4875          * copy arguments
4876          *
4877          * assume sz = 0 for command without parameters
4878          */
4879         if (sz && copy_from_user(args_k, arg, sz)) {
4880                 DPRINT(("cannot copy_from_user %lu bytes @%p\n", sz, arg));
4881                 goto error_args;
4882         }
4883
4884         /*
4885          * check if command supports extra parameters
4886          */
4887         if (completed_args == 0 && getsize) {
4888                 /*
4889                  * get extra parameters size (based on main argument)
4890                  */
4891                 ret = (*getsize)(args_k, &xtra_sz);
4892                 if (ret) goto error_args;
4893
4894                 completed_args = 1;
4895
4896                 DPRINT(("restart_args sz=%lu xtra_sz=%lu\n", sz, xtra_sz));
4897
4898                 /* retry if necessary */
4899                 if (likely(xtra_sz)) goto restart_args;
4900         }
4901
4902         if (unlikely((cmd_flags & PFM_CMD_FD) == 0)) goto skip_fd;
4903
4904         ret = -EBADF;
4905
4906         file = fget(fd);
4907         if (unlikely(file == NULL)) {
4908                 DPRINT(("invalid fd %d\n", fd));
4909                 goto error_args;
4910         }
4911         if (unlikely(PFM_IS_FILE(file) == 0)) {
4912                 DPRINT(("fd %d not related to perfmon\n", fd));
4913                 goto error_args;
4914         }
4915
4916         ctx = (pfm_context_t *)file->private_data;
4917         if (unlikely(ctx == NULL)) {
4918                 DPRINT(("no context for fd %d\n", fd));
4919                 goto error_args;
4920         }
4921         prefetch(&ctx->ctx_state);
4922
4923         PROTECT_CTX(ctx, flags);
4924
4925         /*
4926          * check task is stopped
4927          */
4928         ret = pfm_check_task_state(ctx, cmd, flags);
4929         if (unlikely(ret)) goto abort_locked;
4930
4931 skip_fd:
4932         ret = (*func)(ctx, args_k, count, task_pt_regs(current));
4933
4934         call_made = 1;
4935
4936 abort_locked:
4937         if (likely(ctx)) {
4938                 DPRINT(("context unlocked\n"));
4939                 UNPROTECT_CTX(ctx, flags);
4940                 fput(file);
4941         }
4942
4943         /* copy argument back to user, if needed */
4944         if (call_made && PFM_CMD_RW_ARG(cmd) && copy_to_user(arg, args_k, base_sz*count)) ret = -EFAULT;
4945
4946 error_args:
4947         kfree(args_k);
4948
4949         DPRINT(("cmd=%s ret=%ld\n", PFM_CMD_NAME(cmd), ret));
4950
4951         return ret;
4952 }
4953
4954 static void
4955 pfm_resume_after_ovfl(pfm_context_t *ctx, unsigned long ovfl_regs, struct pt_regs *regs)
4956 {
4957         pfm_buffer_fmt_t *fmt = ctx->ctx_buf_fmt;
4958         pfm_ovfl_ctrl_t rst_ctrl;
4959         int state;
4960         int ret = 0;
4961
4962         state = ctx->ctx_state;
4963         /*
4964          * Unlock sampling buffer and reset index atomically
4965          * XXX: not really needed when blocking
4966          */
4967         if (CTX_HAS_SMPL(ctx)) {
4968
4969                 rst_ctrl.bits.mask_monitoring = 0;
4970                 rst_ctrl.bits.reset_ovfl_pmds = 0;
4971
4972                 if (state == PFM_CTX_LOADED)
4973                         ret = pfm_buf_fmt_restart_active(fmt, current, &rst_ctrl, ctx->ctx_smpl_hdr, regs);
4974                 else
4975                         ret = pfm_buf_fmt_restart(fmt, current, &rst_ctrl, ctx->ctx_smpl_hdr, regs);
4976         } else {
4977                 rst_ctrl.bits.mask_monitoring = 0;
4978                 rst_ctrl.bits.reset_ovfl_pmds = 1;
4979         }
4980
4981         if (ret == 0) {
4982                 if (rst_ctrl.bits.reset_ovfl_pmds) {
4983                         pfm_reset_regs(ctx, &ovfl_regs, PFM_PMD_LONG_RESET);
4984                 }
4985                 if (rst_ctrl.bits.mask_monitoring == 0) {
4986                         DPRINT(("resuming monitoring\n"));
4987                         if (ctx->ctx_state == PFM_CTX_MASKED) pfm_restore_monitoring(current);
4988                 } else {
4989                         DPRINT(("stopping monitoring\n"));
4990                         //pfm_stop_monitoring(current, regs);
4991                 }
4992                 ctx->ctx_state = PFM_CTX_LOADED;
4993         }
4994 }
4995
4996 /*
4997  * context MUST BE LOCKED when calling
4998  * can only be called for current
4999  */
5000 static void
5001 pfm_context_force_terminate(pfm_context_t *ctx, struct pt_regs *regs)
5002 {
5003         int ret;
5004
5005         DPRINT(("entering for [%d]\n", current->pid));
5006
5007         ret = pfm_context_unload(ctx, NULL, 0, regs);
5008         if (ret) {
5009                 printk(KERN_ERR "pfm_context_force_terminate: [%d] unloaded failed with %d\n", current->pid, ret);
5010         }
5011
5012         /*
5013          * and wakeup controlling task, indicating we are now disconnected
5014          */
5015         wake_up_interruptible(&ctx->ctx_zombieq);
5016
5017         /*
5018          * given that context is still locked, the controlling
5019          * task will only get access when we return from
5020          * pfm_handle_work().
5021          */
5022 }
5023
5024 static int pfm_ovfl_notify_user(pfm_context_t *ctx, unsigned long ovfl_pmds);
5025  /*
5026   * pfm_handle_work() can be called with interrupts enabled
5027   * (TIF_NEED_RESCHED) or disabled. The down_interruptible
5028   * call may sleep, therefore we must re-enable interrupts
5029   * to avoid deadlocks. It is safe to do so because this function
5030   * is called ONLY when returning to user level (PUStk=1), in which case
5031   * there is no risk of kernel stack overflow due to deep
5032   * interrupt nesting.
5033   */
5034 void
5035 pfm_handle_work(void)
5036 {
5037         pfm_context_t *ctx;
5038         struct pt_regs *regs;
5039         unsigned long flags, dummy_flags;
5040         unsigned long ovfl_regs;
5041         unsigned int reason;
5042         int ret;
5043
5044         ctx = PFM_GET_CTX(current);
5045         if (ctx == NULL) {
5046                 printk(KERN_ERR "perfmon: [%d] has no PFM context\n", current->pid);
5047                 return;
5048         }
5049
5050         PROTECT_CTX(ctx, flags);
5051
5052         PFM_SET_WORK_PENDING(current, 0);
5053
5054         pfm_clear_task_notify();
5055
5056         regs = task_pt_regs(current);
5057
5058         /*
5059          * extract reason for being here and clear
5060          */
5061         reason = ctx->ctx_fl_trap_reason;
5062         ctx->ctx_fl_trap_reason = PFM_TRAP_REASON_NONE;
5063         ovfl_regs = ctx->ctx_ovfl_regs[0];
5064
5065         DPRINT(("reason=%d state=%d\n", reason, ctx->ctx_state));
5066
5067         /*
5068          * must be done before we check for simple-reset mode
5069          */
5070         if (ctx->ctx_fl_going_zombie || ctx->ctx_state == PFM_CTX_ZOMBIE) goto do_zombie;
5071
5072
5073         //if (CTX_OVFL_NOBLOCK(ctx)) goto skip_blocking;
5074         if (reason == PFM_TRAP_REASON_RESET) goto skip_blocking;
5075
5076         /*
5077          * restore interrupt mask to what it was on entry.
5078          * Could be enabled/diasbled.
5079          */
5080         UNPROTECT_CTX(ctx, flags);
5081
5082         /*
5083          * force interrupt enable because of down_interruptible()
5084          */
5085         local_irq_enable();
5086
5087         DPRINT(("before block sleeping\n"));
5088
5089         /*
5090          * may go through without blocking on SMP systems
5091          * if restart has been received already by the time we call down()
5092          */
5093         ret = wait_for_completion_interruptible(&ctx->ctx_restart_done);
5094
5095         DPRINT(("after block sleeping ret=%d\n", ret));
5096
5097         /*
5098          * lock context and mask interrupts again
5099          * We save flags into a dummy because we may have
5100          * altered interrupts mask compared to entry in this
5101          * function.
5102          */
5103         PROTECT_CTX(ctx, dummy_flags);
5104
5105         /*
5106          * we need to read the ovfl_regs only after wake-up
5107          * because we may have had pfm_write_pmds() in between
5108          * and that can changed PMD values and therefore
5109          * ovfl_regs is reset for these new PMD values.
5110          */
5111         ovfl_regs = ctx->ctx_ovfl_regs[0];
5112
5113         if (ctx->ctx_fl_going_zombie) {
5114 do_zombie:
5115                 DPRINT(("context is zombie, bailing out\n"));
5116                 pfm_context_force_terminate(ctx, regs);
5117                 goto nothing_to_do;
5118         }
5119         /*
5120          * in case of interruption of down() we don't restart anything
5121          */
5122         if (ret < 0) goto nothing_to_do;
5123
5124 skip_blocking:
5125         pfm_resume_after_ovfl(ctx, ovfl_regs, regs);
5126         ctx->ctx_ovfl_regs[0] = 0UL;
5127
5128 nothing_to_do:
5129         /*
5130          * restore flags as they were upon entry
5131          */
5132         UNPROTECT_CTX(ctx, flags);
5133 }
5134
5135 static int
5136 pfm_notify_user(pfm_context_t *ctx, pfm_msg_t *msg)
5137 {
5138         if (ctx->ctx_state == PFM_CTX_ZOMBIE) {
5139                 DPRINT(("ignoring overflow notification, owner is zombie\n"));
5140                 return 0;
5141         }
5142
5143         DPRINT(("waking up somebody\n"));
5144
5145         if (msg) wake_up_interruptible(&ctx->ctx_msgq_wait);
5146
5147         /*
5148          * safe, we are not in intr handler, nor in ctxsw when
5149          * we come here
5150          */
5151         kill_fasync (&ctx->ctx_async_queue, SIGIO, POLL_IN);
5152
5153         return 0;
5154 }
5155
5156 static int
5157 pfm_ovfl_notify_user(pfm_context_t *ctx, unsigned long ovfl_pmds)
5158 {
5159         pfm_msg_t *msg = NULL;
5160
5161         if (ctx->ctx_fl_no_msg == 0) {
5162                 msg = pfm_get_new_msg(ctx);
5163                 if (msg == NULL) {
5164                         printk(KERN_ERR "perfmon: pfm_ovfl_notify_user no more notification msgs\n");
5165                         return -1;
5166                 }
5167
5168                 msg->pfm_ovfl_msg.msg_type         = PFM_MSG_OVFL;
5169                 msg->pfm_ovfl_msg.msg_ctx_fd       = ctx->ctx_fd;
5170                 msg->pfm_ovfl_msg.msg_active_set   = 0;
5171                 msg->pfm_ovfl_msg.msg_ovfl_pmds[0] = ovfl_pmds;
5172                 msg->pfm_ovfl_msg.msg_ovfl_pmds[1] = 0UL;
5173                 msg->pfm_ovfl_msg.msg_ovfl_pmds[2] = 0UL;
5174                 msg->pfm_ovfl_msg.msg_ovfl_pmds[3] = 0UL;
5175                 msg->pfm_ovfl_msg.msg_tstamp       = 0UL;
5176         }
5177
5178         DPRINT(("ovfl msg: msg=%p no_msg=%d fd=%d ovfl_pmds=0x%lx\n",
5179                 msg,
5180                 ctx->ctx_fl_no_msg,
5181                 ctx->ctx_fd,
5182                 ovfl_pmds));
5183
5184         return pfm_notify_user(ctx, msg);
5185 }
5186
5187 static int
5188 pfm_end_notify_user(pfm_context_t *ctx)
5189 {
5190         pfm_msg_t *msg;
5191
5192         msg = pfm_get_new_msg(ctx);
5193         if (msg == NULL) {
5194                 printk(KERN_ERR "perfmon: pfm_end_notify_user no more notification msgs\n");
5195                 return -1;
5196         }
5197         /* no leak */
5198         memset(msg, 0, sizeof(*msg));
5199
5200         msg->pfm_end_msg.msg_type    = PFM_MSG_END;
5201         msg->pfm_end_msg.msg_ctx_fd  = ctx->ctx_fd;
5202         msg->pfm_ovfl_msg.msg_tstamp = 0UL;
5203
5204         DPRINT(("end msg: msg=%p no_msg=%d ctx_fd=%d\n",
5205                 msg,
5206                 ctx->ctx_fl_no_msg,
5207                 ctx->ctx_fd));
5208
5209         return pfm_notify_user(ctx, msg);
5210 }
5211
5212 /*
5213  * main overflow processing routine.
5214  * it can be called from the interrupt path or explicitely during the context switch code
5215  */
5216 static void
5217 pfm_overflow_handler(struct task_struct *task, pfm_context_t *ctx, u64 pmc0, struct pt_regs *regs)
5218 {
5219         pfm_ovfl_arg_t *ovfl_arg;
5220         unsigned long mask;
5221         unsigned long old_val, ovfl_val, new_val;
5222         unsigned long ovfl_notify = 0UL, ovfl_pmds = 0UL, smpl_pmds = 0UL, reset_pmds;
5223         unsigned long tstamp;
5224         pfm_ovfl_ctrl_t ovfl_ctrl;
5225         unsigned int i, has_smpl;
5226         int must_notify = 0;
5227
5228         if (unlikely(ctx->ctx_state == PFM_CTX_ZOMBIE)) goto stop_monitoring;
5229
5230         /*
5231          * sanity test. Should never happen
5232          */
5233         if (unlikely((pmc0 & 0x1) == 0)) goto sanity_check;
5234
5235         tstamp   = ia64_get_itc();
5236         mask     = pmc0 >> PMU_FIRST_COUNTER;
5237         ovfl_val = pmu_conf->ovfl_val;
5238         has_smpl = CTX_HAS_SMPL(ctx);
5239
5240         DPRINT_ovfl(("pmc0=0x%lx pid=%d iip=0x%lx, %s "
5241                      "used_pmds=0x%lx\n",
5242                         pmc0,
5243                         task ? task->pid: -1,
5244                         (regs ? regs->cr_iip : 0),
5245                         CTX_OVFL_NOBLOCK(ctx) ? "nonblocking" : "blocking",
5246                         ctx->ctx_used_pmds[0]));
5247
5248
5249         /*
5250          * first we update the virtual counters
5251          * assume there was a prior ia64_srlz_d() issued
5252          */
5253         for (i = PMU_FIRST_COUNTER; mask ; i++, mask >>= 1) {
5254
5255                 /* skip pmd which did not overflow */
5256                 if ((mask & 0x1) == 0) continue;
5257
5258                 /*
5259                  * Note that the pmd is not necessarily 0 at this point as qualified events
5260                  * may have happened before the PMU was frozen. The residual count is not
5261                  * taken into consideration here but will be with any read of the pmd via
5262                  * pfm_read_pmds().
5263                  */
5264                 old_val              = new_val = ctx->ctx_pmds[i].val;
5265                 new_val             += 1 + ovfl_val;
5266                 ctx->ctx_pmds[i].val = new_val;
5267
5268                 /*
5269                  * check for overflow condition
5270                  */
5271                 if (likely(old_val > new_val)) {
5272                         ovfl_pmds |= 1UL << i;
5273                         if (PMC_OVFL_NOTIFY(ctx, i)) ovfl_notify |= 1UL << i;
5274                 }
5275
5276                 DPRINT_ovfl(("ctx_pmd[%d].val=0x%lx old_val=0x%lx pmd=0x%lx ovfl_pmds=0x%lx ovfl_notify=0x%lx\n",
5277                         i,
5278                         new_val,
5279                         old_val,
5280                         ia64_get_pmd(i) & ovfl_val,
5281                         ovfl_pmds,
5282                         ovfl_notify));
5283         }
5284
5285         /*
5286          * there was no 64-bit overflow, nothing else to do
5287          */
5288         if (ovfl_pmds == 0UL) return;
5289
5290         /*
5291          * reset all control bits
5292          */
5293         ovfl_ctrl.val = 0;
5294         reset_pmds    = 0UL;
5295
5296         /*
5297          * if a sampling format module exists, then we "cache" the overflow by
5298          * calling the module's handler() routine.
5299          */
5300         if (has_smpl) {
5301                 unsigned long start_cycles, end_cycles;
5302                 unsigned long pmd_mask;
5303                 int j, k, ret = 0;
5304                 int this_cpu = smp_processor_id();
5305
5306                 pmd_mask = ovfl_pmds >> PMU_FIRST_COUNTER;
5307                 ovfl_arg = &ctx->ctx_ovfl_arg;
5308
5309                 prefetch(ctx->ctx_smpl_hdr);
5310
5311                 for(i=PMU_FIRST_COUNTER; pmd_mask && ret == 0; i++, pmd_mask >>=1) {
5312
5313                         mask = 1UL << i;
5314
5315                         if ((pmd_mask & 0x1) == 0) continue;
5316
5317                         ovfl_arg->ovfl_pmd      = (unsigned char )i;
5318                         ovfl_arg->ovfl_notify   = ovfl_notify & mask ? 1 : 0;
5319                         ovfl_arg->active_set    = 0;
5320                         ovfl_arg->ovfl_ctrl.val = 0; /* module must fill in all fields */
5321                         ovfl_arg->smpl_pmds[0]  = smpl_pmds = ctx->ctx_pmds[i].smpl_pmds[0];
5322
5323                         ovfl_arg->pmd_value      = ctx->ctx_pmds[i].val;
5324                         ovfl_arg->pmd_last_reset = ctx->ctx_pmds[i].lval;
5325                         ovfl_arg->pmd_eventid    = ctx->ctx_pmds[i].eventid;
5326
5327                         /*
5328                          * copy values of pmds of interest. Sampling format may copy them
5329                          * into sampling buffer.
5330                          */
5331                         if (smpl_pmds) {
5332                                 for(j=0, k=0; smpl_pmds; j++, smpl_pmds >>=1) {
5333                                         if ((smpl_pmds & 0x1) == 0) continue;
5334                                         ovfl_arg->smpl_pmds_values[k++] = PMD_IS_COUNTING(j) ?  pfm_read_soft_counter(ctx, j) : ia64_get_pmd(j);
5335                                         DPRINT_ovfl(("smpl_pmd[%d]=pmd%u=0x%lx\n", k-1, j, ovfl_arg->smpl_pmds_values[k-1]));
5336                                 }
5337                         }
5338
5339                         pfm_stats[this_cpu].pfm_smpl_handler_calls++;
5340
5341                         start_cycles = ia64_get_itc();
5342
5343                         /*
5344                          * call custom buffer format record (handler) routine
5345                          */
5346                         ret = (*ctx->ctx_buf_fmt->fmt_handler)(task, ctx->ctx_smpl_hdr, ovfl_arg, regs, tstamp);
5347
5348                         end_cycles = ia64_get_itc();
5349
5350                         /*
5351                          * For those controls, we take the union because they have
5352                          * an all or nothing behavior.
5353                          */
5354                         ovfl_ctrl.bits.notify_user     |= ovfl_arg->ovfl_ctrl.bits.notify_user;
5355                         ovfl_ctrl.bits.block_task      |= ovfl_arg->ovfl_ctrl.bits.block_task;
5356                         ovfl_ctrl.bits.mask_monitoring |= ovfl_arg->ovfl_ctrl.bits.mask_monitoring;
5357                         /*
5358                          * build the bitmask of pmds to reset now
5359                          */
5360                         if (ovfl_arg->ovfl_ctrl.bits.reset_ovfl_pmds) reset_pmds |= mask;
5361
5362                         pfm_stats[this_cpu].pfm_smpl_handler_cycles += end_cycles - start_cycles;
5363                 }
5364                 /*
5365                  * when the module cannot handle the rest of the overflows, we abort right here
5366                  */
5367                 if (ret && pmd_mask) {
5368                         DPRINT(("handler aborts leftover ovfl_pmds=0x%lx\n",
5369                                 pmd_mask<<PMU_FIRST_COUNTER));
5370                 }
5371                 /*
5372                  * remove the pmds we reset now from the set of pmds to reset in pfm_restart()
5373                  */
5374                 ovfl_pmds &= ~reset_pmds;
5375         } else {
5376                 /*
5377                  * when no sampling module is used, then the default
5378                  * is to notify on overflow if requested by user
5379                  */
5380                 ovfl_ctrl.bits.notify_user     = ovfl_notify ? 1 : 0;
5381                 ovfl_ctrl.bits.block_task      = ovfl_notify ? 1 : 0;
5382                 ovfl_ctrl.bits.mask_monitoring = ovfl_notify ? 1 : 0; /* XXX: change for saturation */
5383                 ovfl_ctrl.bits.reset_ovfl_pmds = ovfl_notify ? 0 : 1;
5384                 /*
5385                  * if needed, we reset all overflowed pmds
5386                  */
5387                 if (ovfl_notify == 0) reset_pmds = ovfl_pmds;
5388         }
5389
5390         DPRINT_ovfl(("ovfl_pmds=0x%lx reset_pmds=0x%lx\n", ovfl_pmds, reset_pmds));
5391
5392         /*
5393          * reset the requested PMD registers using the short reset values
5394          */
5395         if (reset_pmds) {
5396                 unsigned long bm = reset_pmds;
5397                 pfm_reset_regs(ctx, &bm, PFM_PMD_SHORT_RESET);
5398         }
5399
5400         if (ovfl_notify && ovfl_ctrl.bits.notify_user) {
5401                 /*
5402                  * keep track of what to reset when unblocking
5403                  */
5404                 ctx->ctx_ovfl_regs[0] = ovfl_pmds;
5405
5406                 /*
5407                  * check for blocking context
5408                  */
5409                 if (CTX_OVFL_NOBLOCK(ctx) == 0 && ovfl_ctrl.bits.block_task) {
5410
5411                         ctx->ctx_fl_trap_reason = PFM_TRAP_REASON_BLOCK;
5412
5413                         /*
5414                          * set the perfmon specific checking pending work for the task
5415                          */
5416                         PFM_SET_WORK_PENDING(task, 1);
5417
5418                         /*
5419                          * when coming from ctxsw, current still points to the
5420                          * previous task, therefore we must work with task and not current.
5421                          */
5422                         pfm_set_task_notify(task);
5423                 }
5424                 /*
5425                  * defer until state is changed (shorten spin window). the context is locked
5426                  * anyway, so the signal receiver would come spin for nothing.
5427                  */
5428                 must_notify = 1;
5429         }
5430
5431         DPRINT_ovfl(("owner [%d] pending=%ld reason=%u ovfl_pmds=0x%lx ovfl_notify=0x%lx masked=%d\n",
5432                         GET_PMU_OWNER() ? GET_PMU_OWNER()->pid : -1,
5433                         PFM_GET_WORK_PENDING(task),
5434                         ctx->ctx_fl_trap_reason,
5435                         ovfl_pmds,
5436                         ovfl_notify,
5437                         ovfl_ctrl.bits.mask_monitoring ? 1 : 0));
5438         /*
5439          * in case monitoring must be stopped, we toggle the psr bits
5440          */
5441         if (ovfl_ctrl.bits.mask_monitoring) {
5442                 pfm_mask_monitoring(task);
5443                 ctx->ctx_state = PFM_CTX_MASKED;
5444                 ctx->ctx_fl_can_restart = 1;
5445         }
5446
5447         /*
5448          * send notification now
5449          */
5450         if (must_notify) pfm_ovfl_notify_user(ctx, ovfl_notify);
5451
5452         return;
5453
5454 sanity_check:
5455         printk(KERN_ERR "perfmon: CPU%d overflow handler [%d] pmc0=0x%lx\n",
5456                         smp_processor_id(),
5457                         task ? task->pid : -1,
5458                         pmc0);
5459         return;
5460
5461 stop_monitoring:
5462         /*
5463          * in SMP, zombie context is never restored but reclaimed in pfm_load_regs().
5464          * Moreover, zombies are also reclaimed in pfm_save_regs(). Therefore we can
5465          * come here as zombie only if the task is the current task. In which case, we
5466          * can access the PMU  hardware directly.
5467          *
5468          * Note that zombies do have PM_VALID set. So here we do the minimal.
5469          *
5470          * In case the context was zombified it could not be reclaimed at the time
5471          * the monitoring program exited. At this point, the PMU reservation has been
5472          * returned, the sampiing buffer has been freed. We must convert this call
5473          * into a spurious interrupt. However, we must also avoid infinite overflows
5474          * by stopping monitoring for this task. We can only come here for a per-task
5475          * context. All we need to do is to stop monitoring using the psr bits which
5476          * are always task private. By re-enabling secure montioring, we ensure that
5477          * the monitored task will not be able to re-activate monitoring.
5478          * The task will eventually be context switched out, at which point the context
5479          * will be reclaimed (that includes releasing ownership of the PMU).
5480          *
5481          * So there might be a window of time where the number of per-task session is zero
5482          * yet one PMU might have a owner and get at most one overflow interrupt for a zombie
5483          * context. This is safe because if a per-task session comes in, it will push this one
5484          * out and by the virtue on pfm_save_regs(), this one will disappear. If a system wide
5485          * session is force on that CPU, given that we use task pinning, pfm_save_regs() will
5486          * also push our zombie context out.
5487          *
5488          * Overall pretty hairy stuff....
5489          */
5490         DPRINT(("ctx is zombie for [%d], converted to spurious\n", task ? task->pid: -1));
5491         pfm_clear_psr_up();
5492         ia64_psr(regs)->up = 0;
5493         ia64_psr(regs)->sp = 1;
5494         return;
5495 }
5496
5497 static int
5498 pfm_do_interrupt_handler(int irq, void *arg, struct pt_regs *regs)
5499 {
5500         struct task_struct *task;
5501         pfm_context_t *ctx;
5502         unsigned long flags;
5503         u64 pmc0;
5504         int this_cpu = smp_processor_id();
5505         int retval = 0;
5506
5507         pfm_stats[this_cpu].pfm_ovfl_intr_count++;
5508
5509         /*
5510          * srlz.d done before arriving here
5511          */
5512         pmc0 = ia64_get_pmc(0);
5513
5514         task = GET_PMU_OWNER();
5515         ctx  = GET_PMU_CTX();
5516
5517         /*
5518          * if we have some pending bits set
5519          * assumes : if any PMC0.bit[63-1] is set, then PMC0.fr = 1
5520          */
5521         if (PMC0_HAS_OVFL(pmc0) && task) {
5522                 /*
5523                  * we assume that pmc0.fr is always set here
5524                  */
5525
5526                 /* sanity check */
5527                 if (!ctx) goto report_spurious1;
5528
5529                 if (ctx->ctx_fl_system == 0 && (task->thread.flags & IA64_THREAD_PM_VALID) == 0)
5530                         goto report_spurious2;
5531
5532                 PROTECT_CTX_NOPRINT(ctx, flags);
5533
5534                 pfm_overflow_handler(task, ctx, pmc0, regs);
5535
5536                 UNPROTECT_CTX_NOPRINT(ctx, flags);
5537
5538         } else {
5539                 pfm_stats[this_cpu].pfm_spurious_ovfl_intr_count++;
5540                 retval = -1;
5541         }
5542         /*
5543          * keep it unfrozen at all times
5544          */
5545         pfm_unfreeze_pmu();
5546
5547         return retval;
5548
5549 report_spurious1:
5550         printk(KERN_INFO "perfmon: spurious overflow interrupt on CPU%d: process %d has no PFM context\n",
5551                 this_cpu, task->pid);
5552         pfm_unfreeze_pmu();
5553         return -1;
5554 report_spurious2:
5555         printk(KERN_INFO "perfmon: spurious overflow interrupt on CPU%d: process %d, invalid flag\n",
5556                 this_cpu,
5557                 task->pid);
5558         pfm_unfreeze_pmu();
5559         return -1;
5560 }
5561
5562 static irqreturn_t
5563 pfm_interrupt_handler(int irq, void *arg, struct pt_regs *regs)
5564 {
5565         unsigned long start_cycles, total_cycles;
5566         unsigned long min, max;
5567         int this_cpu;
5568         int ret;
5569
5570         this_cpu = get_cpu();
5571         if (likely(!pfm_alt_intr_handler)) {
5572                 min = pfm_stats[this_cpu].pfm_ovfl_intr_cycles_min;
5573                 max = pfm_stats[this_cpu].pfm_ovfl_intr_cycles_max;
5574
5575                 start_cycles = ia64_get_itc();
5576
5577                 ret = pfm_do_interrupt_handler(irq, arg, regs);
5578
5579                 total_cycles = ia64_get_itc();
5580
5581                 /*
5582                  * don't measure spurious interrupts
5583                  */
5584                 if (likely(ret == 0)) {
5585                         total_cycles -= start_cycles;
5586
5587                         if (total_cycles < min) pfm_stats[this_cpu].pfm_ovfl_intr_cycles_min = total_cycles;
5588                         if (total_cycles > max) pfm_stats[this_cpu].pfm_ovfl_intr_cycles_max = total_cycles;
5589
5590                         pfm_stats[this_cpu].pfm_ovfl_intr_cycles += total_cycles;
5591                 }
5592         }
5593         else {
5594                 (*pfm_alt_intr_handler->handler)(irq, arg, regs);
5595         }
5596
5597         put_cpu_no_resched();
5598         return IRQ_HANDLED;
5599 }
5600
5601 /*
5602  * /proc/perfmon interface, for debug only
5603  */
5604
5605 #define PFM_PROC_SHOW_HEADER    ((void *)NR_CPUS+1)
5606
5607 static void *
5608 pfm_proc_start(struct seq_file *m, loff_t *pos)
5609 {
5610         if (*pos == 0) {
5611                 return PFM_PROC_SHOW_HEADER;
5612         }
5613
5614         while (*pos <= NR_CPUS) {
5615                 if (cpu_online(*pos - 1)) {
5616                         return (void *)*pos;
5617                 }
5618                 ++*pos;
5619         }
5620         return NULL;
5621 }
5622
5623 static void *
5624 pfm_proc_next(struct seq_file *m, void *v, loff_t *pos)
5625 {
5626         ++*pos;
5627         return pfm_proc_start(m, pos);
5628 }
5629
5630 static void
5631 pfm_proc_stop(struct seq_file *m, void *v)
5632 {
5633 }
5634
5635 static void
5636 pfm_proc_show_header(struct seq_file *m)
5637 {
5638         struct list_head * pos;
5639         pfm_buffer_fmt_t * entry;
5640         unsigned long flags;
5641
5642         seq_printf(m,
5643                 "perfmon version           : %u.%u\n"
5644                 "model                     : %s\n"
5645                 "fastctxsw                 : %s\n"
5646                 "expert mode               : %s\n"
5647                 "ovfl_mask                 : 0x%lx\n"
5648                 "PMU flags                 : 0x%x\n",
5649                 PFM_VERSION_MAJ, PFM_VERSION_MIN,
5650                 pmu_conf->pmu_name,
5651                 pfm_sysctl.fastctxsw > 0 ? "Yes": "No",
5652                 pfm_sysctl.expert_mode > 0 ? "Yes": "No",
5653                 pmu_conf->ovfl_val,
5654                 pmu_conf->flags);
5655
5656         LOCK_PFS(flags);
5657
5658         seq_printf(m,
5659                 "proc_sessions             : %u\n"
5660                 "sys_sessions              : %u\n"
5661                 "sys_use_dbregs            : %u\n"
5662                 "ptrace_use_dbregs         : %u\n",
5663                 pfm_sessions.pfs_task_sessions,
5664                 pfm_sessions.pfs_sys_sessions,
5665                 pfm_sessions.pfs_sys_use_dbregs,
5666                 pfm_sessions.pfs_ptrace_use_dbregs);
5667
5668         UNLOCK_PFS(flags);
5669
5670         spin_lock(&pfm_buffer_fmt_lock);
5671
5672         list_for_each(pos, &pfm_buffer_fmt_list) {
5673                 entry = list_entry(pos, pfm_buffer_fmt_t, fmt_list);
5674                 seq_printf(m, "format                    : %02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x %s\n",
5675                         entry->fmt_uuid[0],
5676                         entry->fmt_uuid[1],
5677                         entry->fmt_uuid[2],
5678                         entry->fmt_uuid[3],
5679                         entry->fmt_uuid[4],
5680                         entry->fmt_uuid[5],
5681                         entry->fmt_uuid[6],
5682                         entry->fmt_uuid[7],
5683                         entry->fmt_uuid[8],
5684                         entry->fmt_uuid[9],
5685                         entry->fmt_uuid[10],
5686                         entry->fmt_uuid[11],
5687                         entry->fmt_uuid[12],
5688                         entry->fmt_uuid[13],
5689                         entry->fmt_uuid[14],
5690                         entry->fmt_uuid[15],
5691                         entry->fmt_name);
5692         }
5693         spin_unlock(&pfm_buffer_fmt_lock);
5694
5695 }
5696
5697 static int
5698 pfm_proc_show(struct seq_file *m, void *v)
5699 {
5700         unsigned long psr;
5701         unsigned int i;
5702         int cpu;
5703
5704         if (v == PFM_PROC_SHOW_HEADER) {
5705                 pfm_proc_show_header(m);
5706                 return 0;
5707         }
5708
5709         /* show info for CPU (v - 1) */
5710
5711         cpu = (long)v - 1;
5712         seq_printf(m,
5713                 "CPU%-2d overflow intrs      : %lu\n"
5714                 "CPU%-2d overflow cycles     : %lu\n"
5715                 "CPU%-2d overflow min        : %lu\n"
5716                 "CPU%-2d overflow max        : %lu\n"
5717                 "CPU%-2d smpl handler calls  : %lu\n"
5718                 "CPU%-2d smpl handler cycles : %lu\n"
5719                 "CPU%-2d spurious intrs      : %lu\n"
5720                 "CPU%-2d replay   intrs      : %lu\n"
5721                 "CPU%-2d syst_wide           : %d\n"
5722                 "CPU%-2d dcr_pp              : %d\n"
5723                 "CPU%-2d exclude idle        : %d\n"
5724                 "CPU%-2d owner               : %d\n"
5725                 "CPU%-2d context             : %p\n"
5726                 "CPU%-2d activations         : %lu\n",
5727                 cpu, pfm_stats[cpu].pfm_ovfl_intr_count,
5728                 cpu, pfm_stats[cpu].pfm_ovfl_intr_cycles,
5729                 cpu, pfm_stats[cpu].pfm_ovfl_intr_cycles_min,
5730                 cpu, pfm_stats[cpu].pfm_ovfl_intr_cycles_max,
5731                 cpu, pfm_stats[cpu].pfm_smpl_handler_calls,
5732                 cpu, pfm_stats[cpu].pfm_smpl_handler_cycles,
5733                 cpu, pfm_stats[cpu].pfm_spurious_ovfl_intr_count,
5734                 cpu, pfm_stats[cpu].pfm_replay_ovfl_intr_count,
5735                 cpu, pfm_get_cpu_data(pfm_syst_info, cpu) & PFM_CPUINFO_SYST_WIDE ? 1 : 0,
5736                 cpu, pfm_get_cpu_data(pfm_syst_info, cpu) & PFM_CPUINFO_DCR_PP ? 1 : 0,
5737                 cpu, pfm_get_cpu_data(pfm_syst_info, cpu) & PFM_CPUINFO_EXCL_IDLE ? 1 : 0,
5738                 cpu, pfm_get_cpu_data(pmu_owner, cpu) ? pfm_get_cpu_data(pmu_owner, cpu)->pid: -1,
5739                 cpu, pfm_get_cpu_data(pmu_ctx, cpu),
5740                 cpu, pfm_get_cpu_data(pmu_activation_number, cpu));
5741
5742         if (num_online_cpus() == 1 && pfm_sysctl.debug > 0) {
5743
5744                 psr = pfm_get_psr();
5745
5746                 ia64_srlz_d();
5747
5748                 seq_printf(m,
5749                         "CPU%-2d psr                 : 0x%lx\n"
5750                         "CPU%-2d pmc0                : 0x%lx\n",
5751                         cpu, psr,
5752                         cpu, ia64_get_pmc(0));
5753
5754                 for (i=0; PMC_IS_LAST(i) == 0;  i++) {
5755                         if (PMC_IS_COUNTING(i) == 0) continue;
5756                         seq_printf(m,
5757                                 "CPU%-2d pmc%u                : 0x%lx\n"
5758                                 "CPU%-2d pmd%u                : 0x%lx\n",
5759                                 cpu, i, ia64_get_pmc(i),
5760                                 cpu, i, ia64_get_pmd(i));
5761                 }
5762         }
5763         return 0;
5764 }
5765
5766 struct seq_operations pfm_seq_ops = {
5767         .start =        pfm_proc_start,
5768         .next =         pfm_proc_next,
5769         .stop =         pfm_proc_stop,
5770         .show =         pfm_proc_show
5771 };
5772
5773 static int
5774 pfm_proc_open(struct inode *inode, struct file *file)
5775 {
5776         return seq_open(file, &pfm_seq_ops);
5777 }
5778
5779
5780 /*
5781  * we come here as soon as local_cpu_data->pfm_syst_wide is set. this happens
5782  * during pfm_enable() hence before pfm_start(). We cannot assume monitoring
5783  * is active or inactive based on mode. We must rely on the value in
5784  * local_cpu_data->pfm_syst_info
5785  */
5786 void
5787 pfm_syst_wide_update_task(struct task_struct *task, unsigned long info, int is_ctxswin)
5788 {
5789         struct pt_regs *regs;
5790         unsigned long dcr;
5791         unsigned long dcr_pp;
5792
5793         dcr_pp = info & PFM_CPUINFO_DCR_PP ? 1 : 0;
5794
5795         /*
5796          * pid 0 is guaranteed to be the idle task. There is one such task with pid 0
5797          * on every CPU, so we can rely on the pid to identify the idle task.
5798          */
5799         if ((info & PFM_CPUINFO_EXCL_IDLE) == 0 || task->pid) {
5800                 regs = task_pt_regs(task);
5801                 ia64_psr(regs)->pp = is_ctxswin ? dcr_pp : 0;
5802                 return;
5803         }
5804         /*
5805          * if monitoring has started
5806          */
5807         if (dcr_pp) {
5808                 dcr = ia64_getreg(_IA64_REG_CR_DCR);
5809                 /*
5810                  * context switching in?
5811                  */
5812                 if (is_ctxswin) {
5813                         /* mask monitoring for the idle task */
5814                         ia64_setreg(_IA64_REG_CR_DCR, dcr & ~IA64_DCR_PP);
5815                         pfm_clear_psr_pp();
5816                         ia64_srlz_i();
5817                         return;
5818                 }
5819                 /*
5820                  * context switching out
5821                  * restore monitoring for next task
5822                  *
5823                  * Due to inlining this odd if-then-else construction generates
5824                  * better code.
5825                  */
5826                 ia64_setreg(_IA64_REG_CR_DCR, dcr |IA64_DCR_PP);
5827                 pfm_set_psr_pp();
5828                 ia64_srlz_i();
5829         }
5830 }
5831
5832 #ifdef CONFIG_SMP
5833
5834 static void
5835 pfm_force_cleanup(pfm_context_t *ctx, struct pt_regs *regs)
5836 {
5837         struct task_struct *task = ctx->ctx_task;
5838
5839         ia64_psr(regs)->up = 0;
5840         ia64_psr(regs)->sp = 1;
5841
5842         if (GET_PMU_OWNER() == task) {
5843                 DPRINT(("cleared ownership for [%d]\n", ctx->ctx_task->pid));
5844                 SET_PMU_OWNER(NULL, NULL);
5845         }
5846
5847         /*
5848          * disconnect the task from the context and vice-versa
5849          */
5850         PFM_SET_WORK_PENDING(task, 0);
5851
5852         task->thread.pfm_context  = NULL;
5853         task->thread.flags       &= ~IA64_THREAD_PM_VALID;
5854
5855         DPRINT(("force cleanup for [%d]\n",  task->pid));
5856 }
5857
5858
5859 /*
5860  * in 2.6, interrupts are masked when we come here and the runqueue lock is held
5861  */
5862 void
5863 pfm_save_regs(struct task_struct *task)
5864 {
5865         pfm_context_t *ctx;
5866         struct thread_struct *t;
5867         unsigned long flags;
5868         u64 psr;
5869
5870
5871         ctx = PFM_GET_CTX(task);
5872         if (ctx == NULL) return;
5873         t = &task->thread;
5874
5875         /*
5876          * we always come here with interrupts ALREADY disabled by
5877          * the scheduler. So we simply need to protect against concurrent
5878          * access, not CPU concurrency.
5879          */
5880         flags = pfm_protect_ctx_ctxsw(ctx);
5881
5882         if (ctx->ctx_state == PFM_CTX_ZOMBIE) {
5883                 struct pt_regs *regs = task_pt_regs(task);
5884
5885                 pfm_clear_psr_up();
5886
5887                 pfm_force_cleanup(ctx, regs);
5888
5889                 BUG_ON(ctx->ctx_smpl_hdr);
5890
5891                 pfm_unprotect_ctx_ctxsw(ctx, flags);
5892
5893                 pfm_context_free(ctx);
5894                 return;
5895         }
5896
5897         /*
5898          * save current PSR: needed because we modify it
5899          */
5900         ia64_srlz_d();
5901         psr = pfm_get_psr();
5902
5903         BUG_ON(psr & (IA64_PSR_I));
5904
5905         /*
5906          * stop monitoring:
5907          * This is the last instruction which may generate an overflow
5908          *
5909          * We do not need to set psr.sp because, it is irrelevant in kernel.
5910          * It will be restored from ipsr when going back to user level
5911          */
5912         pfm_clear_psr_up();
5913
5914         /*
5915          * keep a copy of psr.up (for reload)
5916          */
5917         ctx->ctx_saved_psr_up = psr & IA64_PSR_UP;
5918
5919         /*
5920          * release ownership of this PMU.
5921          * PM interrupts are masked, so nothing
5922          * can happen.
5923          */
5924         SET_PMU_OWNER(NULL, NULL);
5925
5926         /*
5927          * we systematically save the PMD as we have no
5928          * guarantee we will be schedule at that same
5929          * CPU again.
5930          */
5931         pfm_save_pmds(t->pmds, ctx->ctx_used_pmds[0]);
5932
5933         /*
5934          * save pmc0 ia64_srlz_d() done in pfm_save_pmds()
5935          * we will need it on the restore path to check
5936          * for pending overflow.
5937          */
5938         t->pmcs[0] = ia64_get_pmc(0);
5939
5940         /*
5941          * unfreeze PMU if had pending overflows
5942          */
5943         if (t->pmcs[0] & ~0x1UL) pfm_unfreeze_pmu();
5944
5945         /*
5946          * finally, allow context access.
5947          * interrupts will still be masked after this call.
5948          */
5949         pfm_unprotect_ctx_ctxsw(ctx, flags);
5950 }
5951
5952 #else /* !CONFIG_SMP */
5953 void
5954 pfm_save_regs(struct task_struct *task)
5955 {
5956         pfm_context_t *ctx;
5957         u64 psr;
5958
5959         ctx = PFM_GET_CTX(task);
5960         if (ctx == NULL) return;
5961
5962         /*
5963          * save current PSR: needed because we modify it
5964          */
5965         psr = pfm_get_psr();
5966
5967         BUG_ON(psr & (IA64_PSR_I));
5968
5969         /*
5970          * stop monitoring:
5971          * This is the last instruction which may generate an overflow
5972          *
5973          * We do not need to set psr.sp because, it is irrelevant in kernel.
5974          * It will be restored from ipsr when going back to user level
5975          */
5976         pfm_clear_psr_up();
5977
5978         /*
5979          * keep a copy of psr.up (for reload)
5980          */
5981         ctx->ctx_saved_psr_up = psr & IA64_PSR_UP;
5982 }
5983
5984 static void
5985 pfm_lazy_save_regs (struct task_struct *task)
5986 {
5987         pfm_context_t *ctx;
5988         struct thread_struct *t;
5989         unsigned long flags;
5990
5991         { u64 psr  = pfm_get_psr();
5992           BUG_ON(psr & IA64_PSR_UP);
5993         }
5994
5995         ctx = PFM_GET_CTX(task);
5996         t   = &task->thread;
5997
5998         /*
5999          * we need to mask PMU overflow here to
6000          * make sure that we maintain pmc0 until
6001          * we save it. overflow interrupts are
6002          * treated as spurious if there is no
6003          * owner.
6004          *
6005          * XXX: I don't think this is necessary
6006          */
6007         PROTECT_CTX(ctx,flags);
6008
6009         /*
6010          * release ownership of this PMU.
6011          * must be done before we save the registers.
6012          *
6013          * after this call any PMU interrupt is treated
6014          * as spurious.
6015          */
6016         SET_PMU_OWNER(NULL, NULL);
6017
6018         /*
6019          * save all the pmds we use
6020          */
6021         pfm_save_pmds(t->pmds, ctx->ctx_used_pmds[0]);
6022
6023         /*
6024          * save pmc0 ia64_srlz_d() done in pfm_save_pmds()
6025          * it is needed to check for pended overflow
6026          * on the restore path
6027          */
6028         t->pmcs[0] = ia64_get_pmc(0);
6029
6030         /*
6031          * unfreeze PMU if had pending overflows
6032          */
6033         if (t->pmcs[0] & ~0x1UL) pfm_unfreeze_pmu();
6034
6035         /*
6036          * now get can unmask PMU interrupts, they will
6037          * be treated as purely spurious and we will not
6038          * lose any information
6039          */
6040         UNPROTECT_CTX(ctx,flags);
6041 }
6042 #endif /* CONFIG_SMP */
6043
6044 #ifdef CONFIG_SMP
6045 /*
6046  * in 2.6, interrupts are masked when we come here and the runqueue lock is held
6047  */
6048 void
6049 pfm_load_regs (struct task_struct *task)
6050 {
6051         pfm_context_t *ctx;
6052         struct thread_struct *t;
6053         unsigned long pmc_mask = 0UL, pmd_mask = 0UL;
6054         unsigned long flags;
6055         u64 psr, psr_up;
6056         int need_irq_resend;
6057
6058         ctx = PFM_GET_CTX(task);
6059         if (unlikely(ctx == NULL)) return;
6060
6061         BUG_ON(GET_PMU_OWNER());
6062
6063         t     = &task->thread;
6064         /*
6065          * possible on unload
6066          */
6067         if (unlikely((t->flags & IA64_THREAD_PM_VALID) == 0)) return;
6068
6069         /*
6070          * we always come here with interrupts ALREADY disabled by
6071          * the scheduler. So we simply need to protect against concurrent
6072          * access, not CPU concurrency.
6073          */
6074         flags = pfm_protect_ctx_ctxsw(ctx);
6075         psr   = pfm_get_psr();
6076
6077         need_irq_resend = pmu_conf->flags & PFM_PMU_IRQ_RESEND;
6078
6079         BUG_ON(psr & (IA64_PSR_UP|IA64_PSR_PP));
6080         BUG_ON(psr & IA64_PSR_I);
6081
6082         if (unlikely(ctx->ctx_state == PFM_CTX_ZOMBIE)) {
6083                 struct pt_regs *regs = task_pt_regs(task);
6084
6085                 BUG_ON(ctx->ctx_smpl_hdr);
6086
6087                 pfm_force_cleanup(ctx, regs);
6088
6089                 pfm_unprotect_ctx_ctxsw(ctx, flags);
6090
6091                 /*
6092                  * this one (kmalloc'ed) is fine with interrupts disabled
6093                  */
6094                 pfm_context_free(ctx);
6095
6096                 return;
6097         }
6098
6099         /*
6100          * we restore ALL the debug registers to avoid picking up
6101          * stale state.
6102          */
6103         if (ctx->ctx_fl_using_dbreg) {
6104                 pfm_restore_ibrs(ctx->ctx_ibrs, pmu_conf->num_ibrs);
6105                 pfm_restore_dbrs(ctx->ctx_dbrs, pmu_conf->num_dbrs);
6106         }
6107         /*
6108          * retrieve saved psr.up
6109          */
6110         psr_up = ctx->ctx_saved_psr_up;
6111
6112         /*
6113          * if we were the last user of the PMU on that CPU,
6114          * then nothing to do except restore psr
6115          */
6116         if (GET_LAST_CPU(ctx) == smp_processor_id() && ctx->ctx_last_activation == GET_ACTIVATION()) {
6117
6118                 /*
6119                  * retrieve partial reload masks (due to user modifications)
6120                  */
6121                 pmc_mask = ctx->ctx_reload_pmcs[0];
6122                 pmd_mask = ctx->ctx_reload_pmds[0];
6123
6124         } else {
6125                 /*
6126                  * To avoid leaking information to the user level when psr.sp=0,
6127                  * we must reload ALL implemented pmds (even the ones we don't use).
6128                  * In the kernel we only allow PFM_READ_PMDS on registers which
6129                  * we initialized or requested (sampling) so there is no risk there.
6130                  */
6131                 pmd_mask = pfm_sysctl.fastctxsw ?  ctx->ctx_used_pmds[0] : ctx->ctx_all_pmds[0];
6132
6133                 /*
6134                  * ALL accessible PMCs are systematically reloaded, unused registers
6135                  * get their default (from pfm_reset_pmu_state()) values to avoid picking
6136                  * up stale configuration.
6137                  *
6138                  * PMC0 is never in the mask. It is always restored separately.
6139                  */
6140                 pmc_mask = ctx->ctx_all_pmcs[0];
6141         }
6142         /*
6143          * when context is MASKED, we will restore PMC with plm=0
6144          * and PMD with stale information, but that's ok, nothing
6145          * will be captured.
6146          *
6147          * XXX: optimize here
6148          */
6149         if (pmd_mask) pfm_restore_pmds(t->pmds, pmd_mask);
6150         if (pmc_mask) pfm_restore_pmcs(t->pmcs, pmc_mask);
6151
6152         /*
6153          * check for pending overflow at the time the state
6154          * was saved.
6155          */
6156         if (unlikely(PMC0_HAS_OVFL(t->pmcs[0]))) {
6157                 /*
6158                  * reload pmc0 with the overflow information
6159                  * On McKinley PMU, this will trigger a PMU interrupt
6160                  */
6161                 ia64_set_pmc(0, t->pmcs[0]);
6162                 ia64_srlz_d();
6163                 t->pmcs[0] = 0UL;
6164
6165                 /*
6166                  * will replay the PMU interrupt
6167                  */
6168                 if (need_irq_resend) hw_resend_irq(NULL, IA64_PERFMON_VECTOR);
6169
6170                 pfm_stats[smp_processor_id()].pfm_replay_ovfl_intr_count++;
6171         }
6172
6173         /*
6174          * we just did a reload, so we reset the partial reload fields
6175          */
6176         ctx->ctx_reload_pmcs[0] = 0UL;
6177         ctx->ctx_reload_pmds[0] = 0UL;
6178
6179         SET_LAST_CPU(ctx, smp_processor_id());
6180
6181         /*
6182          * dump activation value for this PMU
6183          */
6184         INC_ACTIVATION();
6185         /*
6186          * record current activation for this context
6187          */
6188         SET_ACTIVATION(ctx);
6189
6190         /*
6191          * establish new ownership.
6192          */
6193         SET_PMU_OWNER(task, ctx);
6194
6195         /*
6196          * restore the psr.up bit. measurement
6197          * is active again.
6198          * no PMU interrupt can happen at this point
6199          * because we still have interrupts disabled.
6200          */
6201         if (likely(psr_up)) pfm_set_psr_up();
6202
6203         /*
6204          * allow concurrent access to context
6205          */
6206         pfm_unprotect_ctx_ctxsw(ctx, flags);
6207 }
6208 #else /*  !CONFIG_SMP */
6209 /*
6210  * reload PMU state for UP kernels
6211  * in 2.5 we come here with interrupts disabled
6212  */
6213 void
6214 pfm_load_regs (struct task_struct *task)
6215 {
6216         struct thread_struct *t;
6217         pfm_context_t *ctx;
6218         struct task_struct *owner;
6219         unsigned long pmd_mask, pmc_mask;
6220         u64 psr, psr_up;
6221         int need_irq_resend;
6222
6223         owner = GET_PMU_OWNER();
6224         ctx   = PFM_GET_CTX(task);
6225         t     = &task->thread;
6226         psr   = pfm_get_psr();
6227
6228         BUG_ON(psr & (IA64_PSR_UP|IA64_PSR_PP));
6229         BUG_ON(psr & IA64_PSR_I);
6230
6231         /*
6232          * we restore ALL the debug registers to avoid picking up
6233          * stale state.
6234          *
6235          * This must be done even when the task is still the owner
6236          * as the registers may have been modified via ptrace()
6237          * (not perfmon) by the previous task.
6238          */
6239         if (ctx->ctx_fl_using_dbreg) {
6240                 pfm_restore_ibrs(ctx->ctx_ibrs, pmu_conf->num_ibrs);
6241                 pfm_restore_dbrs(ctx->ctx_dbrs, pmu_conf->num_dbrs);
6242         }
6243
6244         /*
6245          * retrieved saved psr.up
6246          */
6247         psr_up = ctx->ctx_saved_psr_up;
6248         need_irq_resend = pmu_conf->flags & PFM_PMU_IRQ_RESEND;
6249
6250         /*
6251          * short path, our state is still there, just
6252          * need to restore psr and we go
6253          *
6254          * we do not touch either PMC nor PMD. the psr is not touched
6255          * by the overflow_handler. So we are safe w.r.t. to interrupt
6256          * concurrency even without interrupt masking.
6257          */
6258         if (likely(owner == task)) {
6259                 if (likely(psr_up)) pfm_set_psr_up();
6260                 return;
6261         }
6262
6263         /*
6264          * someone else is still using the PMU, first push it out and
6265          * then we'll be able to install our stuff !
6266          *
6267          * Upon return, there will be no owner for the current PMU
6268          */
6269         if (owner) pfm_lazy_save_regs(owner);
6270
6271         /*
6272          * To avoid leaking information to the user level when psr.sp=0,
6273          * we must reload ALL implemented pmds (even the ones we don't use).
6274          * In the kernel we only allow PFM_READ_PMDS on registers which
6275          * we initialized or requested (sampling) so there is no risk there.
6276          */
6277         pmd_mask = pfm_sysctl.fastctxsw ?  ctx->ctx_used_pmds[0] : ctx->ctx_all_pmds[0];
6278
6279         /*
6280          * ALL accessible PMCs are systematically reloaded, unused registers
6281          * get their default (from pfm_reset_pmu_state()) values to avoid picking
6282          * up stale configuration.
6283          *
6284          * PMC0 is never in the mask. It is always restored separately
6285          */
6286         pmc_mask = ctx->ctx_all_pmcs[0];
6287
6288         pfm_restore_pmds(t->pmds, pmd_mask);
6289         pfm_restore_pmcs(t->pmcs, pmc_mask);
6290
6291         /*
6292          * check for pending overflow at the time the state
6293          * was saved.
6294          */
6295         if (unlikely(PMC0_HAS_OVFL(t->pmcs[0]))) {
6296                 /*
6297                  * reload pmc0 with the overflow information
6298                  * On McKinley PMU, this will trigger a PMU interrupt
6299                  */
6300                 ia64_set_pmc(0, t->pmcs[0]);
6301                 ia64_srlz_d();
6302
6303                 t->pmcs[0] = 0UL;
6304
6305                 /*
6306                  * will replay the PMU interrupt
6307                  */
6308                 if (need_irq_resend) hw_resend_irq(NULL, IA64_PERFMON_VECTOR);
6309
6310                 pfm_stats[smp_processor_id()].pfm_replay_ovfl_intr_count++;
6311         }
6312
6313         /*
6314          * establish new ownership.
6315          */
6316         SET_PMU_OWNER(task, ctx);
6317
6318         /*
6319          * restore the psr.up bit. measurement
6320          * is active again.
6321          * no PMU interrupt can happen at this point
6322          * because we still have interrupts disabled.
6323          */
6324         if (likely(psr_up)) pfm_set_psr_up();
6325 }
6326 #endif /* CONFIG_SMP */
6327
6328 /*
6329  * this function assumes monitoring is stopped
6330  */
6331 static void
6332 pfm_flush_pmds(struct task_struct *task, pfm_context_t *ctx)
6333 {
6334         u64 pmc0;
6335         unsigned long mask2, val, pmd_val, ovfl_val;
6336         int i, can_access_pmu = 0;
6337         int is_self;
6338
6339         /*
6340          * is the caller the task being monitored (or which initiated the
6341          * session for system wide measurements)
6342          */
6343         is_self = ctx->ctx_task == task ? 1 : 0;
6344
6345         /*
6346          * can access PMU is task is the owner of the PMU state on the current CPU
6347          * or if we are running on the CPU bound to the context in system-wide mode
6348          * (that is not necessarily the task the context is attached to in this mode).
6349          * In system-wide we always have can_access_pmu true because a task running on an
6350          * invalid processor is flagged earlier in the call stack (see pfm_stop).
6351          */
6352         can_access_pmu = (GET_PMU_OWNER() == task) || (ctx->ctx_fl_system && ctx->ctx_cpu == smp_processor_id());
6353         if (can_access_pmu) {
6354                 /*
6355                  * Mark the PMU as not owned
6356                  * This will cause the interrupt handler to do nothing in case an overflow
6357                  * interrupt was in-flight
6358                  * This also guarantees that pmc0 will contain the final state
6359                  * It virtually gives us full control on overflow processing from that point
6360                  * on.
6361                  */
6362                 SET_PMU_OWNER(NULL, NULL);
6363                 DPRINT(("releasing ownership\n"));
6364
6365                 /*
6366                  * read current overflow status:
6367                  *
6368                  * we are guaranteed to read the final stable state
6369                  */
6370                 ia64_srlz_d();
6371                 pmc0 = ia64_get_pmc(0); /* slow */
6372
6373                 /*
6374                  * reset freeze bit, overflow status information destroyed
6375                  */
6376                 pfm_unfreeze_pmu();
6377         } else {
6378                 pmc0 = task->thread.pmcs[0];
6379                 /*
6380                  * clear whatever overflow status bits there were
6381                  */
6382                 task->thread.pmcs[0] = 0;
6383         }
6384         ovfl_val = pmu_conf->ovfl_val;
6385         /*
6386          * we save all the used pmds
6387          * we take care of overflows for counting PMDs
6388          *
6389          * XXX: sampling situation is not taken into account here
6390          */
6391         mask2 = ctx->ctx_used_pmds[0];
6392
6393         DPRINT(("is_self=%d ovfl_val=0x%lx mask2=0x%lx\n", is_self, ovfl_val, mask2));
6394
6395         for (i = 0; mask2; i++, mask2>>=1) {
6396
6397                 /* skip non used pmds */
6398                 if ((mask2 & 0x1) == 0) continue;
6399
6400                 /*
6401                  * can access PMU always true in system wide mode
6402                  */
6403                 val = pmd_val = can_access_pmu ? ia64_get_pmd(i) : task->thread.pmds[i];
6404
6405                 if (PMD_IS_COUNTING(i)) {
6406                         DPRINT(("[%d] pmd[%d] ctx_pmd=0x%lx hw_pmd=0x%lx\n",
6407                                 task->pid,
6408                                 i,
6409                                 ctx->ctx_pmds[i].val,
6410                                 val & ovfl_val));
6411
6412                         /*
6413                          * we rebuild the full 64 bit value of the counter
6414                          */
6415                         val = ctx->ctx_pmds[i].val + (val & ovfl_val);
6416
6417                         /*
6418                          * now everything is in ctx_pmds[] and we need
6419                          * to clear the saved context from save_regs() such that
6420                          * pfm_read_pmds() gets the correct value
6421                          */
6422                         pmd_val = 0UL;
6423
6424                         /*
6425                          * take care of overflow inline
6426                          */
6427                         if (pmc0 & (1UL << i)) {
6428                                 val += 1 + ovfl_val;
6429                                 DPRINT(("[%d] pmd[%d] overflowed\n", task->pid, i));
6430                         }
6431                 }
6432
6433                 DPRINT(("[%d] ctx_pmd[%d]=0x%lx  pmd_val=0x%lx\n", task->pid, i, val, pmd_val));
6434
6435                 if (is_self) task->thread.pmds[i] = pmd_val;
6436
6437                 ctx->ctx_pmds[i].val = val;
6438         }
6439 }
6440
6441 static struct irqaction perfmon_irqaction = {
6442         .handler = pfm_interrupt_handler,
6443         .flags   = SA_INTERRUPT,
6444         .name    = "perfmon"
6445 };
6446
6447 static void
6448 pfm_alt_save_pmu_state(void *data)
6449 {
6450         struct pt_regs *regs;
6451
6452         regs = task_pt_regs(current);
6453
6454         DPRINT(("called\n"));
6455
6456         /*
6457          * should not be necessary but
6458          * let's take not risk
6459          */
6460         pfm_clear_psr_up();
6461         pfm_clear_psr_pp();
6462         ia64_psr(regs)->pp = 0;
6463
6464         /*
6465          * This call is required
6466          * May cause a spurious interrupt on some processors
6467          */
6468         pfm_freeze_pmu();
6469
6470         ia64_srlz_d();
6471 }
6472
6473 void
6474 pfm_alt_restore_pmu_state(void *data)
6475 {
6476         struct pt_regs *regs;
6477
6478         regs = task_pt_regs(current);
6479
6480         DPRINT(("called\n"));
6481
6482         /*
6483          * put PMU back in state expected
6484          * by perfmon
6485          */
6486         pfm_clear_psr_up();
6487         pfm_clear_psr_pp();
6488         ia64_psr(regs)->pp = 0;
6489
6490         /*
6491          * perfmon runs with PMU unfrozen at all times
6492          */
6493         pfm_unfreeze_pmu();
6494
6495         ia64_srlz_d();
6496 }
6497
6498 int
6499 pfm_install_alt_pmu_interrupt(pfm_intr_handler_desc_t *hdl)
6500 {
6501         int ret, i;
6502         int reserve_cpu;
6503
6504         /* some sanity checks */
6505         if (hdl == NULL || hdl->handler == NULL) return -EINVAL;
6506
6507         /* do the easy test first */
6508         if (pfm_alt_intr_handler) return -EBUSY;
6509
6510         /* one at a time in the install or remove, just fail the others */
6511         if (!spin_trylock(&pfm_alt_install_check)) {
6512                 return -EBUSY;
6513         }
6514
6515         /* reserve our session */
6516         for_each_online_cpu(reserve_cpu) {
6517                 ret = pfm_reserve_session(NULL, 1, reserve_cpu);
6518                 if (ret) goto cleanup_reserve;
6519         }
6520
6521         /* save the current system wide pmu states */
6522         ret = on_each_cpu(pfm_alt_save_pmu_state, NULL, 0, 1);
6523         if (ret) {
6524                 DPRINT(("on_each_cpu() failed: %d\n", ret));
6525                 goto cleanup_reserve;
6526         }
6527
6528         /* officially change to the alternate interrupt handler */
6529         pfm_alt_intr_handler = hdl;
6530
6531         spin_unlock(&pfm_alt_install_check);
6532
6533         return 0;
6534
6535 cleanup_reserve:
6536         for_each_online_cpu(i) {
6537                 /* don't unreserve more than we reserved */
6538                 if (i >= reserve_cpu) break;
6539
6540                 pfm_unreserve_session(NULL, 1, i);
6541         }
6542
6543         spin_unlock(&pfm_alt_install_check);
6544
6545         return ret;
6546 }
6547 EXPORT_SYMBOL_GPL(pfm_install_alt_pmu_interrupt);
6548
6549 int
6550 pfm_remove_alt_pmu_interrupt(pfm_intr_handler_desc_t *hdl)
6551 {
6552         int i;
6553         int ret;
6554
6555         if (hdl == NULL) return -EINVAL;
6556
6557         /* cannot remove someone else's handler! */
6558         if (pfm_alt_intr_handler != hdl) return -EINVAL;
6559
6560         /* one at a time in the install or remove, just fail the others */
6561         if (!spin_trylock(&pfm_alt_install_check)) {
6562                 return -EBUSY;
6563         }
6564
6565         pfm_alt_intr_handler = NULL;
6566
6567         ret = on_each_cpu(pfm_alt_restore_pmu_state, NULL, 0, 1);
6568         if (ret) {
6569                 DPRINT(("on_each_cpu() failed: %d\n", ret));
6570         }
6571
6572         for_each_online_cpu(i) {
6573                 pfm_unreserve_session(NULL, 1, i);
6574         }
6575
6576         spin_unlock(&pfm_alt_install_check);
6577
6578         return 0;
6579 }
6580 EXPORT_SYMBOL_GPL(pfm_remove_alt_pmu_interrupt);
6581
6582 /*
6583  * perfmon initialization routine, called from the initcall() table
6584  */
6585 static int init_pfm_fs(void);
6586
6587 static int __init
6588 pfm_probe_pmu(void)
6589 {
6590         pmu_config_t **p;
6591         int family;
6592
6593         family = local_cpu_data->family;
6594         p      = pmu_confs;
6595
6596         while(*p) {
6597                 if ((*p)->probe) {
6598                         if ((*p)->probe() == 0) goto found;
6599                 } else if ((*p)->pmu_family == family || (*p)->pmu_family == 0xff) {
6600                         goto found;
6601                 }
6602                 p++;
6603         }
6604         return -1;
6605 found:
6606         pmu_conf = *p;
6607         return 0;
6608 }
6609
6610 static struct file_operations pfm_proc_fops = {
6611         .open           = pfm_proc_open,
6612         .read           = seq_read,
6613         .llseek         = seq_lseek,
6614         .release        = seq_release,
6615 };
6616
6617 int __init
6618 pfm_init(void)
6619 {
6620         unsigned int n, n_counters, i;
6621
6622         printk("perfmon: version %u.%u IRQ %u\n",
6623                 PFM_VERSION_MAJ,
6624                 PFM_VERSION_MIN,
6625                 IA64_PERFMON_VECTOR);
6626
6627         if (pfm_probe_pmu()) {
6628                 printk(KERN_INFO "perfmon: disabled, there is no support for processor family %d\n",
6629                                 local_cpu_data->family);
6630                 return -ENODEV;
6631         }
6632
6633         /*
6634          * compute the number of implemented PMD/PMC from the
6635          * description tables
6636          */
6637         n = 0;
6638         for (i=0; PMC_IS_LAST(i) == 0;  i++) {
6639                 if (PMC_IS_IMPL(i) == 0) continue;
6640                 pmu_conf->impl_pmcs[i>>6] |= 1UL << (i&63);
6641                 n++;
6642         }
6643         pmu_conf->num_pmcs = n;
6644
6645         n = 0; n_counters = 0;
6646         for (i=0; PMD_IS_LAST(i) == 0;  i++) {
6647                 if (PMD_IS_IMPL(i) == 0) continue;
6648                 pmu_conf->impl_pmds[i>>6] |= 1UL << (i&63);
6649                 n++;
6650                 if (PMD_IS_COUNTING(i)) n_counters++;
6651         }
6652         pmu_conf->num_pmds      = n;
6653         pmu_conf->num_counters  = n_counters;
6654
6655         /*
6656          * sanity checks on the number of debug registers
6657          */
6658         if (pmu_conf->use_rr_dbregs) {
6659                 if (pmu_conf->num_ibrs > IA64_NUM_DBG_REGS) {
6660                         printk(KERN_INFO "perfmon: unsupported number of code debug registers (%u)\n", pmu_conf->num_ibrs);
6661                         pmu_conf = NULL;
6662                         return -1;
6663                 }
6664                 if (pmu_conf->num_dbrs > IA64_NUM_DBG_REGS) {
6665                         printk(KERN_INFO "perfmon: unsupported number of data debug registers (%u)\n", pmu_conf->num_ibrs);
6666                         pmu_conf = NULL;
6667                         return -1;
6668                 }
6669         }
6670
6671         printk("perfmon: %s PMU detected, %u PMCs, %u PMDs, %u counters (%lu bits)\n",
6672                pmu_conf->pmu_name,
6673                pmu_conf->num_pmcs,
6674                pmu_conf->num_pmds,
6675                pmu_conf->num_counters,
6676                ffz(pmu_conf->ovfl_val));
6677
6678         /* sanity check */
6679         if (pmu_conf->num_pmds >= IA64_NUM_PMD_REGS || pmu_conf->num_pmcs >= IA64_NUM_PMC_REGS) {
6680                 printk(KERN_ERR "perfmon: not enough pmc/pmd, perfmon disabled\n");
6681                 pmu_conf = NULL;
6682                 return -1;
6683         }
6684
6685         /*
6686          * create /proc/perfmon (mostly for debugging purposes)
6687          */
6688         perfmon_dir = create_proc_entry("perfmon", S_IRUGO, NULL);
6689         if (perfmon_dir == NULL) {
6690                 printk(KERN_ERR "perfmon: cannot create /proc entry, perfmon disabled\n");
6691                 pmu_conf = NULL;
6692                 return -1;
6693         }
6694         /*
6695          * install customized file operations for /proc/perfmon entry
6696          */
6697         perfmon_dir->proc_fops = &pfm_proc_fops;
6698
6699         /*
6700          * create /proc/sys/kernel/perfmon (for debugging purposes)
6701          */
6702         pfm_sysctl_header = register_sysctl_table(pfm_sysctl_root, 0);
6703
6704         /*
6705          * initialize all our spinlocks
6706          */
6707         spin_lock_init(&pfm_sessions.pfs_lock);
6708         spin_lock_init(&pfm_buffer_fmt_lock);
6709
6710         init_pfm_fs();
6711
6712         for(i=0; i < NR_CPUS; i++) pfm_stats[i].pfm_ovfl_intr_cycles_min = ~0UL;
6713
6714         return 0;
6715 }
6716
6717 __initcall(pfm_init);
6718
6719 /*
6720  * this function is called before pfm_init()
6721  */
6722 void
6723 pfm_init_percpu (void)
6724 {
6725         static int first_time=1;
6726         /*
6727          * make sure no measurement is active
6728          * (may inherit programmed PMCs from EFI).
6729          */
6730         pfm_clear_psr_pp();
6731         pfm_clear_psr_up();
6732
6733         /*
6734          * we run with the PMU not frozen at all times
6735          */
6736         pfm_unfreeze_pmu();
6737
6738         if (first_time) {
6739                 register_percpu_irq(IA64_PERFMON_VECTOR, &perfmon_irqaction);
6740                 first_time=0;
6741         }
6742
6743         ia64_setreg(_IA64_REG_CR_PMV, IA64_PERFMON_VECTOR);
6744         ia64_srlz_d();
6745 }
6746
6747 /*
6748  * used for debug purposes only
6749  */
6750 void
6751 dump_pmu_state(const char *from)
6752 {
6753         struct task_struct *task;
6754         struct thread_struct *t;
6755         struct pt_regs *regs;
6756         pfm_context_t *ctx;
6757         unsigned long psr, dcr, info, flags;
6758         int i, this_cpu;
6759
6760         local_irq_save(flags);
6761
6762         this_cpu = smp_processor_id();
6763         regs     = task_pt_regs(current);
6764         info     = PFM_CPUINFO_GET();
6765         dcr      = ia64_getreg(_IA64_REG_CR_DCR);
6766
6767         if (info == 0 && ia64_psr(regs)->pp == 0 && (dcr & IA64_DCR_PP) == 0) {
6768                 local_irq_restore(flags);
6769                 return;
6770         }
6771
6772         printk("CPU%d from %s() current [%d] iip=0x%lx %s\n",
6773                 this_cpu,
6774                 from,
6775                 current->pid,
6776                 regs->cr_iip,
6777                 current->comm);
6778
6779         task = GET_PMU_OWNER();
6780         ctx  = GET_PMU_CTX();
6781
6782         printk("->CPU%d owner [%d] ctx=%p\n", this_cpu, task ? task->pid : -1, ctx);
6783
6784         psr = pfm_get_psr();
6785
6786         printk("->CPU%d pmc0=0x%lx psr.pp=%d psr.up=%d dcr.pp=%d syst_info=0x%lx user_psr.up=%d user_psr.pp=%d\n",
6787                 this_cpu,
6788                 ia64_get_pmc(0),
6789                 psr & IA64_PSR_PP ? 1 : 0,
6790                 psr & IA64_PSR_UP ? 1 : 0,
6791                 dcr & IA64_DCR_PP ? 1 : 0,
6792                 info,
6793                 ia64_psr(regs)->up,
6794                 ia64_psr(regs)->pp);
6795
6796         ia64_psr(regs)->up = 0;
6797         ia64_psr(regs)->pp = 0;
6798
6799         t = &current->thread;
6800
6801         for (i=1; PMC_IS_LAST(i) == 0; i++) {
6802                 if (PMC_IS_IMPL(i) == 0) continue;
6803                 printk("->CPU%d pmc[%d]=0x%lx thread_pmc[%d]=0x%lx\n", this_cpu, i, ia64_get_pmc(i), i, t->pmcs[i]);
6804         }
6805
6806         for (i=1; PMD_IS_LAST(i) == 0; i++) {
6807                 if (PMD_IS_IMPL(i) == 0) continue;
6808                 printk("->CPU%d pmd[%d]=0x%lx thread_pmd[%d]=0x%lx\n", this_cpu, i, ia64_get_pmd(i), i, t->pmds[i]);
6809         }
6810
6811         if (ctx) {
6812                 printk("->CPU%d ctx_state=%d vaddr=%p addr=%p fd=%d ctx_task=[%d] saved_psr_up=0x%lx\n",
6813                                 this_cpu,
6814                                 ctx->ctx_state,
6815                                 ctx->ctx_smpl_vaddr,
6816                                 ctx->ctx_smpl_hdr,
6817                                 ctx->ctx_msgq_head,
6818                                 ctx->ctx_msgq_tail,
6819                                 ctx->ctx_saved_psr_up);
6820         }
6821         local_irq_restore(flags);
6822 }
6823
6824 /*
6825  * called from process.c:copy_thread(). task is new child.
6826  */
6827 void
6828 pfm_inherit(struct task_struct *task, struct pt_regs *regs)
6829 {
6830         struct thread_struct *thread;
6831
6832         DPRINT(("perfmon: pfm_inherit clearing state for [%d]\n", task->pid));
6833
6834         thread = &task->thread;
6835
6836         /*
6837          * cut links inherited from parent (current)
6838          */
6839         thread->pfm_context = NULL;
6840
6841         PFM_SET_WORK_PENDING(task, 0);
6842
6843         /*
6844          * the psr bits are already set properly in copy_threads()
6845          */
6846 }
6847 #else  /* !CONFIG_PERFMON */
6848 asmlinkage long
6849 sys_perfmonctl (int fd, int cmd, void *arg, int count)
6850 {
6851         return -ENOSYS;
6852 }
6853 #endif /* CONFIG_PERFMON */