Fixup bad merge.
[opensuse:kernel.git] / arch / ia64 / kernel / perfmon.c
1 /*
2  * This file implements the perfmon subsystem which is used
3  * to program the IA-64 Performance Monitoring Unit (PMU).
4  *
5  * Originaly Written by Ganesh Venkitachalam, IBM Corp.
6  * Copyright (C) 1999 Ganesh Venkitachalam <venkitac@us.ibm.com>
7  *
8  * Modifications by Stephane Eranian, Hewlett-Packard Co.
9  * Modifications by David Mosberger-Tang, Hewlett-Packard Co.
10  *
11  * Copyright (C) 1999-2002  Hewlett Packard Co
12  *               Stephane Eranian <eranian@hpl.hp.com>
13  *               David Mosberger-Tang <davidm@hpl.hp.com>
14  */
15
16 #include <linux/config.h>
17 #include <linux/kernel.h>
18 #include <linux/sched.h>
19 #include <linux/interrupt.h>
20 #include <linux/smp_lock.h>
21 #include <linux/proc_fs.h>
22 #include <linux/init.h>
23 #include <linux/vmalloc.h>
24 #include <linux/wrapper.h>
25 #include <linux/mm.h>
26
27 #include <asm/bitops.h>
28 #include <asm/errno.h>
29 #include <asm/page.h>
30 #include <asm/pal.h>
31 #include <asm/perfmon.h>
32 #include <asm/processor.h>
33 #include <asm/signal.h>
34 #include <asm/system.h>
35 #include <asm/uaccess.h>
36 #include <asm/delay.h> /* for ia64_get_itc() */
37
38 #ifdef CONFIG_PERFMON
39
40 /*
41  * For PMU which rely on the debug registers for some features, you must
42  * you must enable the following flag to activate the support for
43  * accessing the registers via the perfmonctl() interface.
44  */
45 #ifdef CONFIG_ITANIUM
46 #define PFM_PMU_USES_DBR        1
47 #endif
48
49 /*
50  * perfmon context states
51  */
52 #define PFM_CTX_DISABLED        0
53 #define PFM_CTX_ENABLED         1
54
55 /*
56  * Reset register flags
57  */
58 #define PFM_RELOAD_LONG_RESET   1
59 #define PFM_RELOAD_SHORT_RESET  2
60
61 /*
62  * Misc macros and definitions
63  */
64 #define PMU_FIRST_COUNTER       4
65
66 #define PFM_IS_DISABLED() pmu_conf.pfm_is_disabled
67
68 #define PMC_OVFL_NOTIFY(ctx, i) ((ctx)->ctx_soft_pmds[i].flags &  PFM_REGFL_OVFL_NOTIFY)
69 #define PFM_FL_INHERIT_MASK     (PFM_FL_INHERIT_NONE|PFM_FL_INHERIT_ONCE|PFM_FL_INHERIT_ALL)
70
71 #define PMC_IS_IMPL(i)    (i<pmu_conf.num_pmcs && pmu_conf.impl_regs[i>>6] & (1UL<< (i) %64))
72 #define PMD_IS_IMPL(i)    (i<pmu_conf.num_pmds &&  pmu_conf.impl_regs[4+(i>>6)] & (1UL<<(i) % 64))
73
74 #define PMD_IS_COUNTING(i) (i >=0  && i < 256 && pmu_conf.counter_pmds[i>>6] & (1UL <<(i) % 64))
75 #define PMC_IS_COUNTING(i) PMD_IS_COUNTING(i)
76
77 #define IBR_IS_IMPL(k)    (k<pmu_conf.num_ibrs)
78 #define DBR_IS_IMPL(k)    (k<pmu_conf.num_dbrs)
79
80 #define PMC_IS_BTB(a)     (((pfm_monitor_t *)(a))->pmc_es == PMU_BTB_EVENT)
81
82 #define LSHIFT(x)               (1UL<<(x))
83 #define PMM(x)                  LSHIFT(x)
84 #define PMC_IS_MONITOR(c)       ((pmu_conf.monitor_pmcs[0] & PMM((c))) != 0)
85
86 #define CTX_IS_ENABLED(c)       ((c)->ctx_flags.state == PFM_CTX_ENABLED)
87 #define CTX_OVFL_NOBLOCK(c)     ((c)->ctx_fl_block == 0)
88 #define CTX_INHERIT_MODE(c)     ((c)->ctx_fl_inherit)
89 #define CTX_HAS_SMPL(c)         ((c)->ctx_psb != NULL)
90 #define CTX_USED_PMD(ctx,n)     (ctx)->ctx_used_pmds[(n)>>6] |= 1UL<< ((n) % 64)
91
92 #define CTX_USED_IBR(ctx,n)     (ctx)->ctx_used_ibrs[(n)>>6] |= 1UL<< ((n) % 64)
93 #define CTX_USED_DBR(ctx,n)     (ctx)->ctx_used_dbrs[(n)>>6] |= 1UL<< ((n) % 64)
94 #define CTX_USES_DBREGS(ctx)    (((pfm_context_t *)(ctx))->ctx_fl_using_dbreg==1)
95
96 #define LOCK_CTX(ctx)   spin_lock(&(ctx)->ctx_lock)
97 #define UNLOCK_CTX(ctx) spin_unlock(&(ctx)->ctx_lock)
98
99 #define SET_PMU_OWNER(t)    do { pmu_owners[smp_processor_id()].owner = (t); } while(0)
100 #define PMU_OWNER()         pmu_owners[smp_processor_id()].owner
101
102 #define LOCK_PFS()          spin_lock(&pfm_sessions.pfs_lock)
103 #define UNLOCK_PFS()        spin_unlock(&pfm_sessions.pfs_lock)
104
105 #define PFM_REG_RETFLAG_SET(flags, val) do { flags &= ~PFM_REG_RETFL_MASK; flags |= (val); } while(0)
106
107 /*
108  * debugging
109  */
110 #define DBprintk(a) \
111         do { \
112                 if (pfm_debug_mode >0) { printk("%s.%d: CPU%d ", __FUNCTION__, __LINE__, smp_processor_id()); printk a; } \
113         } while (0)
114
115
116 /* 
117  * These are some helpful architected PMC and IBR/DBR register layouts
118  */
119 typedef struct {
120         unsigned long pmc_plm:4;        /* privilege level mask */
121         unsigned long pmc_ev:1;         /* external visibility */
122         unsigned long pmc_oi:1;         /* overflow interrupt */
123         unsigned long pmc_pm:1;         /* privileged monitor */
124         unsigned long pmc_ig1:1;        /* reserved */
125         unsigned long pmc_es:8;         /* event select */
126         unsigned long pmc_ig2:48;       /* reserved */
127 } pfm_monitor_t;
128
129 /*
130  * There is one such data structure per perfmon context. It is used to describe the
131  * sampling buffer. It is to be shared among siblings whereas the pfm_context 
132  * is not.
133  * Therefore we maintain a refcnt which is incremented on fork().
134  * This buffer is private to the kernel only the actual sampling buffer 
135  * including its header are exposed to the user. This construct allows us to 
136  * export the buffer read-write, if needed, without worrying about security 
137  * problems.
138  */
139 typedef struct _pfm_smpl_buffer_desc {
140         spinlock_t              psb_lock;       /* protection lock */
141         unsigned long           psb_refcnt;     /* how many users for the buffer */
142         int                     psb_flags;      /* bitvector of flags */
143
144         void                    *psb_addr;      /* points to location of first entry */
145         unsigned long           psb_entries;    /* maximum number of entries */
146         unsigned long           psb_size;       /* aligned size of buffer */
147         unsigned long           psb_index;      /* next free entry slot XXX: must use the one in buffer */
148         unsigned long           psb_entry_size; /* size of each entry including entry header */
149         perfmon_smpl_hdr_t      *psb_hdr;       /* points to sampling buffer header */
150
151         struct _pfm_smpl_buffer_desc *psb_next; /* next psb, used for rvfreeing of psb_hdr */
152
153 } pfm_smpl_buffer_desc_t;
154
155 #define LOCK_PSB(p)     spin_lock(&(p)->psb_lock)
156 #define UNLOCK_PSB(p)   spin_unlock(&(p)->psb_lock)
157
158 #define PFM_PSB_VMA     0x1                     /* a VMA is describing the buffer */
159
160 /*
161  * This structure is initialized at boot time and contains
162  * a description of the PMU main characteristic as indicated
163  * by PAL
164  */
165 typedef struct {
166         unsigned long pfm_is_disabled;  /* indicates if perfmon is working properly */
167         unsigned long perf_ovfl_val;    /* overflow value for generic counters   */
168         unsigned long max_counters;     /* upper limit on counter pair (PMC/PMD) */
169         unsigned long num_pmcs ;        /* highest PMC implemented (may have holes) */
170         unsigned long num_pmds;         /* highest PMD implemented (may have holes) */
171         unsigned long impl_regs[16];    /* buffer used to hold implememted PMC/PMD mask */
172         unsigned long num_ibrs;         /* number of instruction debug registers */
173         unsigned long num_dbrs;         /* number of data debug registers */
174         unsigned long monitor_pmcs[4];  /* which pmc are controlling monitors */
175         unsigned long counter_pmds[4];  /* which pmd are used as counters */
176 } pmu_config_t;
177
178 /*
179  * 64-bit software counter structure
180  */
181 typedef struct {
182         u64 val;        /* virtual 64bit counter value */
183         u64 ival;       /* initial value from user */
184         u64 long_reset; /* reset value on sampling overflow */
185         u64 short_reset;/* reset value on overflow */
186         u64 reset_pmds[4]; /* which other pmds to reset when this counter overflows */
187         int flags;      /* notify/do not notify */
188 } pfm_counter_t;
189
190 /*
191  * perfmon context. One per process, is cloned on fork() depending on 
192  * inheritance flags
193  */
194 typedef struct {
195         unsigned int state:1;           /* 0=disabled, 1=enabled */
196         unsigned int inherit:2;         /* inherit mode */
197         unsigned int block:1;           /* when 1, task will blocked on user notifications */
198         unsigned int system:1;          /* do system wide monitoring */
199         unsigned int frozen:1;          /* pmu must be kept frozen on ctxsw in */
200         unsigned int protected:1;       /* allow access to creator of context only */
201         unsigned int using_dbreg:1;     /* using range restrictions (debug registers) */
202         unsigned int reserved:24;
203 } pfm_context_flags_t;
204
205 /*
206  * perfmon context: encapsulates all the state of a monitoring session
207  * XXX: probably need to change layout
208  */
209 typedef struct pfm_context {
210         pfm_smpl_buffer_desc_t  *ctx_psb;               /* sampling buffer, if any */
211         unsigned long           ctx_smpl_vaddr;         /* user level virtual address of smpl buffer */
212
213         spinlock_t              ctx_lock;
214         pfm_context_flags_t     ctx_flags;              /* block/noblock */
215
216         struct task_struct      *ctx_notify_task;       /* who to notify on overflow */
217         struct task_struct      *ctx_owner;             /* pid of creator (debug) */
218
219         unsigned long           ctx_ovfl_regs[4];       /* which registers overflowed (notification) */
220         unsigned long           ctx_smpl_regs[4];       /* which registers to record on overflow */
221
222         struct semaphore        ctx_restart_sem;        /* use for blocking notification mode */
223
224         unsigned long           ctx_used_pmds[4];       /* bitmask of used PMD (speedup ctxsw) */
225         unsigned long           ctx_saved_pmcs[4];      /* bitmask of PMC to save on ctxsw */
226         unsigned long           ctx_reload_pmcs[4];     /* bitmask of PMC to reload on ctxsw (SMP) */
227
228         unsigned long           ctx_used_ibrs[4];       /* bitmask of used IBR (speedup ctxsw) */
229         unsigned long           ctx_used_dbrs[4];       /* bitmask of used DBR (speedup ctxsw) */
230
231         pfm_counter_t           ctx_soft_pmds[IA64_NUM_PMD_REGS]; /* XXX: size should be dynamic */
232
233         u64                     ctx_saved_psr;          /* copy of psr used for lazy ctxsw */
234         unsigned long           ctx_saved_cpus_allowed; /* copy of the task cpus_allowed (system wide) */
235         unsigned long           ctx_cpu;                /* cpu to which perfmon is applied (system wide) */
236
237         atomic_t                ctx_saving_in_progress; /* flag indicating actual save in progress */
238         atomic_t                ctx_last_cpu;           /* CPU id of current or last CPU used */
239 } pfm_context_t;
240
241 #define ctx_fl_inherit          ctx_flags.inherit
242 #define ctx_fl_block            ctx_flags.block
243 #define ctx_fl_system           ctx_flags.system
244 #define ctx_fl_frozen           ctx_flags.frozen
245 #define ctx_fl_protected        ctx_flags.protected
246 #define ctx_fl_using_dbreg      ctx_flags.using_dbreg
247
248 /*
249  * global information about all sessions
250  * mostly used to synchronize between system wide and per-process
251  */
252 typedef struct {
253         spinlock_t              pfs_lock;               /* lock the structure */
254
255         unsigned long           pfs_task_sessions;      /* number of per task sessions */
256         unsigned long           pfs_sys_sessions;       /* number of per system wide sessions */
257         unsigned long           pfs_sys_use_dbregs;             /* incremented when a system wide session uses debug regs */
258         unsigned long           pfs_ptrace_use_dbregs;    /* incremented when a process uses debug regs */
259         struct task_struct      *pfs_sys_session[NR_CPUS];  /* point to task owning a system-wide session */
260 } pfm_session_t;
261
262 /*
263  * structure used to pass argument to/from remote CPU 
264  * using IPI to check and possibly save the PMU context on SMP systems.
265  *
266  * not used in UP kernels
267  */
268 typedef struct {
269         struct task_struct *task;       /* which task we are interested in */
270         int retval;                     /* return value of the call: 0=you can proceed, 1=need to wait for completion */
271 } pfm_smp_ipi_arg_t;
272
273 /*
274  * perfmon command descriptions
275  */
276 typedef struct {
277         int             (*cmd_func)(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs);
278         int             cmd_flags;
279         unsigned int    cmd_narg;
280         size_t          cmd_argsize;
281 } pfm_cmd_desc_t;
282
283 #define PFM_CMD_PID             0x1     /* command requires pid argument */
284 #define PFM_CMD_ARG_READ        0x2     /* command must read argument(s) */
285 #define PFM_CMD_ARG_WRITE       0x4     /* command must write argument(s) */
286 #define PFM_CMD_CTX             0x8     /* command needs a perfmon context */
287 #define PFM_CMD_NOCHK           0x10    /* command does not need to check task's state */
288
289 #define PFM_CMD_IDX(cmd)        (cmd)
290
291 #define PFM_CMD_IS_VALID(cmd)   ((PFM_CMD_IDX(cmd) >= 0) && (PFM_CMD_IDX(cmd) < PFM_CMD_COUNT) \
292                                   && pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_func != NULL)
293
294 #define PFM_CMD_USE_PID(cmd)    ((pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_flags & PFM_CMD_PID) != 0)
295 #define PFM_CMD_READ_ARG(cmd)   ((pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_flags & PFM_CMD_ARG_READ) != 0)
296 #define PFM_CMD_WRITE_ARG(cmd)  ((pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_flags & PFM_CMD_ARG_WRITE) != 0)
297 #define PFM_CMD_USE_CTX(cmd)    ((pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_flags & PFM_CMD_CTX) != 0)
298 #define PFM_CMD_CHK(cmd)        ((pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_flags & PFM_CMD_NOCHK) == 0)
299
300 #define PFM_CMD_ARG_MANY        -1 /* cannot be zero */
301 #define PFM_CMD_NARG(cmd)       (pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_narg)
302 #define PFM_CMD_ARG_SIZE(cmd)   (pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_argsize)
303
304
305 /*
306  * perfmon internal variables
307  */
308 static pmu_config_t     pmu_conf;       /* PMU configuration */
309 static int              pfm_debug_mode; /* 0= nodebug, >0= debug output on */
310 static pfm_session_t    pfm_sessions;   /* global sessions information */
311 static struct proc_dir_entry *perfmon_dir; /* for debug only */
312 static unsigned long pfm_spurious_ovfl_intr_count; /* keep track of spurious ovfl interrupts */
313 static unsigned long pfm_ovfl_intr_count; /* keep track of spurious ovfl interrupts */
314 static unsigned long pfm_recorded_samples_count;
315
316 static void pfm_vm_close(struct vm_area_struct * area);
317 static struct vm_operations_struct pfm_vm_ops={
318         close: pfm_vm_close
319 };
320
321 /*
322  * keep track of task owning the PMU per CPU.
323  */
324 static struct {
325         struct task_struct *owner;
326 } ____cacheline_aligned pmu_owners[NR_CPUS];
327
328
329
330 /*
331  * forward declarations
332  */
333 static void ia64_reset_pmu(struct task_struct *);
334 static void pfm_fetch_regs(int cpu, struct task_struct *task, pfm_context_t *ctx);
335 static void pfm_lazy_save_regs (struct task_struct *ta);
336
337 static inline unsigned long
338 pfm_read_soft_counter(pfm_context_t *ctx, int i)
339 {
340         return ctx->ctx_soft_pmds[i].val + (ia64_get_pmd(i) & pmu_conf.perf_ovfl_val);
341 }
342
343 static inline void
344 pfm_write_soft_counter(pfm_context_t *ctx, int i, unsigned long val)
345 {
346         ctx->ctx_soft_pmds[i].val = val  & ~pmu_conf.perf_ovfl_val;
347         /*
348          * writing to unimplemented part is ignore, so we do not need to
349          * mask off top part
350          */
351         ia64_set_pmd(i, val);
352 }
353
354 /*
355  * finds the number of PM(C|D) registers given
356  * the bitvector returned by PAL
357  */
358 static unsigned long __init
359 find_num_pm_regs(long *buffer)
360 {
361         int i=3; /* 4 words/per bitvector */
362
363         /* start from the most significant word */
364         while (i>=0 && buffer[i] == 0 ) i--;
365         if (i< 0) {
366                 printk(KERN_ERR "perfmon: No bit set in pm_buffer\n");
367                 return 0;
368         }
369         return 1+ ia64_fls(buffer[i]) + 64 * i;
370 }
371
372
373 /*
374  * Generates a unique (per CPU) timestamp
375  */
376 static inline unsigned long
377 pfm_get_stamp(void)
378 {
379         /*
380          * XXX: must find something more efficient
381          */
382         return ia64_get_itc();
383 }
384
385 /* Here we want the physical address of the memory.
386  * This is used when initializing the contents of the area.
387  */
388 static inline unsigned long
389 pfm_kvirt_to_pa(unsigned long adr)
390 {
391         __u64 pa = ia64_tpa(adr);
392         //DBprintk(("kv2pa(%lx-->%lx)\n", adr, pa));
393         return pa;
394 }
395
396
397 static void *
398 pfm_rvmalloc(unsigned long size)
399 {
400         void *mem;
401         unsigned long adr;
402
403         size=PAGE_ALIGN(size);
404         mem=vmalloc(size);
405         if (mem) {
406                 //printk("perfmon: CPU%d pfm_rvmalloc(%ld)=%p\n", smp_processor_id(), size, mem);
407                 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
408                 adr=(unsigned long) mem;
409                 while (size > 0) {
410                         mem_map_reserve(vmalloc_to_page((void *)adr));
411                         adr+=PAGE_SIZE;
412                         size-=PAGE_SIZE;
413                 }
414         }
415         return mem;
416 }
417
418 static void
419 pfm_rvfree(void *mem, unsigned long size)
420 {
421         unsigned long adr;
422
423         if (mem) {
424                 adr=(unsigned long) mem;
425                 while ((long) size > 0)
426                         mem_map_unreserve(vmalloc_to_page((void*)adr));
427                         adr+=PAGE_SIZE;
428                         size-=PAGE_SIZE;
429                 }
430                 vfree(mem);
431         }
432         return;
433 }
434
435 /*
436  * This function gets called from mm/mmap.c:exit_mmap() only when there is a sampling buffer
437  * attached to the context AND the current task has a mapping for it, i.e., it is the original
438  * creator of the context.
439  *
440  * This function is used to remember the fact that the vma describing the sampling buffer
441  * has now been removed. It can only be called when no other tasks share the same mm context.
442  *
443  */
444 static void 
445 pfm_vm_close(struct vm_area_struct *vma)
446 {
447         pfm_smpl_buffer_desc_t *psb = (pfm_smpl_buffer_desc_t *)vma->vm_private_data;
448
449         if (psb == NULL) {
450                 printk("perfmon: psb is null in [%d]\n", current->pid);
451                 return;
452         }
453         /*
454          * Add PSB to list of buffers to free on release_thread() when no more users
455          *
456          * This call is safe because, once the count is zero is cannot be modified anymore.
457          * This is not because there is no more user of the mm context, that the sampling
458          * buffer is not being used anymore outside of this task. In fact, it can still
459          * be accessed from within the kernel by another task (such as the monitored task).
460          *
461          * Therefore, we only move the psb into the list of buffers to free when we know
462          * nobody else is using it.
463          * The linked list if independent of the perfmon context, because in the case of
464          * multi-threaded processes, the last thread may not have been involved with
465          * monitoring however it will be the one removing the vma and it should therefore
466          * also remove the sampling buffer. This buffer cannot be removed until the vma
467          * is removed.
468          *
469          * This function cannot remove the buffer from here, because exit_mmap() must first
470          * complete. Given that there is no other vma related callback in the generic code,
471          * we have created on own with the linked list of sampling buffer to free which
472          * is part of the thread structure. In release_thread() we check if the list is
473          * empty. If not we call into perfmon to free the buffer and psb. That is the only
474          * way to ensure a safe deallocation of the sampling buffer which works when
475          * the buffer is shared between distinct processes or with multi-threaded programs.
476          *
477          * We need to lock the psb because the refcnt test and flag manipulation must
478          * looked like an atomic operation vis a vis pfm_context_exit()
479          */
480         LOCK_PSB(psb);
481
482         if (psb->psb_refcnt == 0) {
483
484                 psb->psb_next = current->thread.pfm_smpl_buf_list;
485                 current->thread.pfm_smpl_buf_list = psb;
486
487                 DBprintk(("psb for [%d] smpl @%p size %ld inserted into list\n", 
488                         current->pid, psb->psb_hdr, psb->psb_size));
489         }
490         DBprintk(("psb vma flag cleared for [%d] smpl @%p size %ld inserted into list\n", 
491                         current->pid, psb->psb_hdr, psb->psb_size));
492
493         /*
494          * indicate to pfm_context_exit() that the vma has been removed. 
495          */
496         psb->psb_flags &= ~PFM_PSB_VMA;
497
498         UNLOCK_PSB(psb);
499 }
500
501 /*
502  * This function is called from pfm_destroy_context() and also from pfm_inherit()
503  * to explicitely remove the sampling buffer mapping from the user level address space.
504  */
505 static int
506 pfm_remove_smpl_mapping(struct task_struct *task)
507 {
508         pfm_context_t *ctx = task->thread.pfm_context;
509         pfm_smpl_buffer_desc_t *psb;
510         int r;
511
512         /*
513          * some sanity checks first
514          */
515         if (ctx == NULL || task->mm == NULL || ctx->ctx_smpl_vaddr == 0 || ctx->ctx_psb == NULL) {
516                 printk("perfmon: invalid context mm=%p\n", task->mm);
517                 return -1;
518         }
519         psb = ctx->ctx_psb;     
520
521         down_write(&task->mm->mmap_sem);
522
523         r = do_munmap(task->mm, ctx->ctx_smpl_vaddr, psb->psb_size);
524
525         up_write(&task->mm->mmap_sem);
526         if (r !=0) {
527                 printk("perfmon: pid %d unable to unmap sampling buffer @0x%lx size=%ld\n", 
528                                 task->pid, ctx->ctx_smpl_vaddr, psb->psb_size);
529         }
530         DBprintk(("[%d] do_unmap(0x%lx, %ld)=%d\n", 
531                 task->pid, ctx->ctx_smpl_vaddr, psb->psb_size, r));
532
533         /* 
534          * make sure we suppress all traces of this buffer
535          * (important for pfm_inherit)
536          */
537         ctx->ctx_smpl_vaddr = 0;
538
539         return 0;
540 }
541
542 static pfm_context_t *
543 pfm_context_alloc(void)
544 {
545         pfm_context_t *ctx;
546
547         /* allocate context descriptor */
548         ctx = kmalloc(sizeof(pfm_context_t), GFP_KERNEL);
549         if (ctx) memset(ctx, 0, sizeof(pfm_context_t));
550         
551         return ctx;
552 }
553
554 static void
555 pfm_context_free(pfm_context_t *ctx)
556 {
557         if (ctx) kfree(ctx);
558 }
559
560 static int
561 pfm_remap_buffer(struct vm_area_struct *vma, unsigned long buf, unsigned long addr, unsigned long size)
562 {
563         unsigned long page;
564
565         DBprintk(("CPU%d buf=0x%lx addr=0x%lx size=%ld\n", smp_processor_id(), buf, addr, size));
566
567         while (size > 0) {
568                 page = pfm_kvirt_to_pa(buf);
569
570                 if (remap_page_range(vma, addr, page, PAGE_SIZE, PAGE_SHARED)) return -ENOMEM;
571                 
572                 addr  += PAGE_SIZE;
573                 buf   += PAGE_SIZE;
574                 size  -= PAGE_SIZE;
575         }
576         return 0;
577 }
578
579 /*
580  * counts the number of PMDS to save per entry.
581  * This code is generic enough to accomodate more than 64 PMDS when they become available
582  */
583 static unsigned long
584 pfm_smpl_entry_size(unsigned long *which, unsigned long size)
585 {
586         unsigned long res = 0;
587         int i;
588
589         for (i=0; i < size; i++, which++) res += hweight64(*which);
590
591         DBprintk(("weight=%ld\n", res));
592
593         return res;
594 }
595
596 /*
597  * Allocates the sampling buffer and remaps it into caller's address space
598  */
599 static int
600 pfm_smpl_buffer_alloc(pfm_context_t *ctx, unsigned long *which_pmds, unsigned long entries, 
601                       void **user_vaddr)
602 {
603         struct mm_struct *mm = current->mm;
604         struct vm_area_struct *vma = NULL;
605         unsigned long size, regcount;
606         void *smpl_buf;
607         pfm_smpl_buffer_desc_t *psb;
608
609         regcount = pfm_smpl_entry_size(which_pmds, 1);
610
611         /* note that regcount might be 0, in this case only the header for each
612          * entry will be recorded.
613          */
614
615         /*
616          * 1 buffer hdr and for each entry a header + regcount PMDs to save
617          */
618         size = PAGE_ALIGN(  sizeof(perfmon_smpl_hdr_t)
619                           + entries * (sizeof(perfmon_smpl_entry_t) + regcount*sizeof(u64)));
620         /*
621          * check requested size to avoid Denial-of-service attacks
622          * XXX: may have to refine this test    
623          * Check against address space limit.
624          *
625          * if ((mm->total_vm << PAGE_SHIFT) + len> current->rlim[RLIMIT_AS].rlim_cur) 
626          *      return -ENOMEM;
627          */
628         if (size > current->rlim[RLIMIT_MEMLOCK].rlim_cur) return -EAGAIN;
629
630         /*
631          * We do the easy to undo allocations first.
632          *
633          * pfm_rvmalloc(), clears the buffer, so there is no leak
634          */
635         smpl_buf = pfm_rvmalloc(size);
636         if (smpl_buf == NULL) {
637                 DBprintk(("Can't allocate sampling buffer\n"));
638                 return -ENOMEM;
639         }
640
641         DBprintk(("smpl_buf @%p\n", smpl_buf));
642
643         /* allocate sampling buffer descriptor now */
644         psb = kmalloc(sizeof(*psb), GFP_KERNEL);
645         if (psb == NULL) {
646                 DBprintk(("Can't allocate sampling buffer descriptor\n"));
647                 pfm_rvfree(smpl_buf, size);
648                 return -ENOMEM;
649         }
650
651         /* allocate vma */
652         vma = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
653         if (!vma) {
654                 DBprintk(("Cannot allocate vma\n"));
655                 goto error;
656         }
657         /*
658          * partially initialize the vma for the sampling buffer
659          */
660         vma->vm_flags        = VM_READ| VM_MAYREAD |VM_RESERVED;
661         vma->vm_page_prot    = PAGE_READONLY; /* XXX may need to change */
662         vma->vm_ops          = &pfm_vm_ops; /* necesarry to get the close() callback */
663         vma->vm_pgoff        = 0;
664         vma->vm_file         = NULL;
665         vma->vm_raend        = 0;
666         vma->vm_private_data = psb;     /* information needed by the pfm_vm_close() function */
667
668         /*
669          * Now we have everything we need and we can initialize
670          * and connect all the data structures
671          */
672
673         psb->psb_hdr     = smpl_buf;
674         psb->psb_addr    = ((char *)smpl_buf)+sizeof(perfmon_smpl_hdr_t); /* first entry */
675         psb->psb_size    = size; /* aligned size */
676         psb->psb_index   = 0;
677         psb->psb_entries = entries;
678         psb->psb_flags   = PFM_PSB_VMA; /* remember that there is a vma describing the buffer */
679         psb->psb_refcnt  = 1;
680
681         spin_lock_init(&psb->psb_lock);
682
683         /*
684          * XXX: will need to do cacheline alignment to avoid false sharing in SMP mode and
685          * multitask monitoring.
686          */
687         psb->psb_entry_size = sizeof(perfmon_smpl_entry_t) + regcount*sizeof(u64);
688
689         DBprintk(("psb @%p entry_size=%ld hdr=%p addr=%p\n", 
690                   (void *)psb,psb->psb_entry_size, (void *)psb->psb_hdr, 
691                   (void *)psb->psb_addr));
692
693         /* initialize some of the fields of user visible buffer header */
694         psb->psb_hdr->hdr_version    = PFM_SMPL_VERSION;
695         psb->psb_hdr->hdr_entry_size = psb->psb_entry_size;
696         psb->psb_hdr->hdr_pmds[0]    = which_pmds[0];
697
698         /*
699          * Let's do the difficult operations next.
700          *
701          * now we atomically find some area in the address space and
702          * remap the buffer in it.
703          */
704         down_write(&current->mm->mmap_sem);
705
706
707         /* find some free area in address space, must have mmap sem held */
708         vma->vm_start = get_unmapped_area(NULL, 0, size, 0, MAP_PRIVATE|MAP_ANONYMOUS);
709         if (vma->vm_start == 0UL) {
710                 DBprintk(("Cannot find unmapped area for size %ld\n", size));
711                 up_write(&current->mm->mmap_sem);
712                 goto error;
713         }
714         vma->vm_end = vma->vm_start + size;
715
716         DBprintk(("entries=%ld aligned size=%ld, unmapped @0x%lx\n", entries, size, vma->vm_start));
717                 
718         /* can only be applied to current, need to have the mm semaphore held when called */
719         if (pfm_remap_buffer(vma, (unsigned long)smpl_buf, vma->vm_start, size)) {
720                 DBprintk(("Can't remap buffer\n"));
721                 up_write(&current->mm->mmap_sem);
722                 goto error;
723         }
724
725         /*
726          * now insert the vma in the vm list for the process, must be
727          * done with mmap lock held
728          */
729         insert_vm_struct(mm, vma);
730
731         mm->total_vm  += size >> PAGE_SHIFT;
732
733         up_write(&current->mm->mmap_sem);
734
735         /* store which PMDS to record */
736         ctx->ctx_smpl_regs[0] = which_pmds[0];
737
738
739         /* link to perfmon context */
740         ctx->ctx_psb        = psb;
741
742         /*
743          * keep track of user level virtual address 
744          */
745         ctx->ctx_smpl_vaddr = *(unsigned long *)user_vaddr = vma->vm_start;
746
747         return 0;
748
749 error:
750         pfm_rvfree(smpl_buf, size);
751         kfree(psb);
752         return -ENOMEM;
753 }
754
755 /*
756  * XXX: do something better here
757  */
758 static int
759 pfm_bad_permissions(struct task_struct *task)
760 {
761         /* stolen from bad_signal() */
762         return (current->session != task->session)
763             && (current->euid ^ task->suid) && (current->euid ^ task->uid)
764             && (current->uid ^ task->suid) && (current->uid ^ task->uid);
765 }
766
767
768 static int
769 pfx_is_sane(struct task_struct *task, pfarg_context_t *pfx)
770 {
771         int ctx_flags;
772         int cpu;
773
774         /* valid signal */
775
776         /* cannot send to process 1, 0 means do not notify */
777         if (pfx->ctx_notify_pid == 1) {
778                 DBprintk(("invalid notify_pid %d\n", pfx->ctx_notify_pid));
779                 return -EINVAL;
780         }
781         ctx_flags = pfx->ctx_flags;
782
783         if (ctx_flags & PFM_FL_SYSTEM_WIDE) {
784                 DBprintk(("cpu_mask=0x%lx\n", pfx->ctx_cpu_mask));
785                 /*
786                  * cannot block in this mode 
787                  */
788                 if (ctx_flags & PFM_FL_NOTIFY_BLOCK) {
789                         DBprintk(("cannot use blocking mode when in system wide monitoring\n"));
790                         return -EINVAL;
791                 }
792                 /*
793                  * must only have one bit set in the CPU mask
794                  */
795                 if (hweight64(pfx->ctx_cpu_mask) != 1UL) {
796                         DBprintk(("invalid CPU mask specified\n"));
797                         return -EINVAL;
798                 }
799                 /*
800                  * and it must be a valid CPU
801                  */
802                 cpu = ffs(pfx->ctx_cpu_mask);
803                 if (cpu > smp_num_cpus) {
804                         DBprintk(("CPU%d is not online\n", cpu));
805                         return -EINVAL;
806                 }
807                 /*
808                  * check for pre-existing pinning, if conflicting reject
809                  */
810                 if (task->cpus_allowed != ~0UL && (task->cpus_allowed & (1UL<<cpu)) == 0) {
811                         DBprintk(("[%d] pinned on 0x%lx, mask for CPU%d \n", task->pid, 
812                                 task->cpus_allowed, cpu));
813                         return -EINVAL;
814                 }
815
816         } else {
817                 /*
818                  * must provide a target for the signal in blocking mode even when
819                  * no counter is configured with PFM_FL_REG_OVFL_NOTIFY
820                  */
821                 if ((ctx_flags & PFM_FL_NOTIFY_BLOCK) && pfx->ctx_notify_pid == 0) return -EINVAL;
822         }
823         /* probably more to add here */
824
825         return 0;
826 }
827
828 static int
829 pfm_create_context(struct task_struct *task, pfm_context_t *ctx, void *req, int count, 
830                    struct pt_regs *regs)
831 {
832         pfarg_context_t tmp;
833         void *uaddr = NULL;
834         int ret, cpu = 0;
835         int ctx_flags;
836         pid_t notify_pid;
837
838         /* a context has already been defined */
839         if (ctx) return -EBUSY;
840
841         /*
842          * not yet supported
843          */
844         if (task != current) return -EINVAL;
845
846         if (copy_from_user(&tmp, req, sizeof(tmp))) return -EFAULT;
847
848         ret = pfx_is_sane(task, &tmp);
849         if (ret < 0) return ret;
850
851         ctx_flags = tmp.ctx_flags;
852
853         ret =  -EBUSY;
854
855         LOCK_PFS();
856
857         if (ctx_flags & PFM_FL_SYSTEM_WIDE) {
858
859                 /* at this point, we know there is at least one bit set */
860                 cpu = ffs(tmp.ctx_cpu_mask) - 1;
861
862                 DBprintk(("requesting CPU%d currently on CPU%d\n",cpu, smp_processor_id()));
863
864                 if (pfm_sessions.pfs_task_sessions > 0) {
865                         DBprintk(("system wide not possible, task_sessions=%ld\n", pfm_sessions.pfs_task_sessions));
866                         goto abort;
867                 }
868
869                 if (pfm_sessions.pfs_sys_session[cpu]) {
870                         DBprintk(("system wide not possible, conflicting session [%d] on CPU%d\n",pfm_sessions.pfs_sys_session[cpu]->pid, cpu));
871                         goto abort;
872                 }
873                 pfm_sessions.pfs_sys_session[cpu] = task;
874                 /*
875                  * count the number of system wide sessions
876                  */
877                 pfm_sessions.pfs_sys_sessions++;
878
879         } else if (pfm_sessions.pfs_sys_sessions == 0) {
880                 pfm_sessions.pfs_task_sessions++;
881         } else {
882                 /* no per-process monitoring while there is a system wide session */
883                 goto abort;
884         }
885
886         UNLOCK_PFS();
887
888         ret = -ENOMEM;
889
890         ctx = pfm_context_alloc();
891         if (!ctx) goto error;
892
893         /* record the creator (important for inheritance) */
894         ctx->ctx_owner = current;
895
896         notify_pid = tmp.ctx_notify_pid;
897
898         spin_lock_init(&ctx->ctx_lock);
899
900         if (notify_pid == current->pid) {
901
902                 ctx->ctx_notify_task = task = current;
903                 current->thread.pfm_context = ctx;
904
905         } else if (notify_pid!=0) {
906                 struct task_struct *notify_task;
907
908                 read_lock(&tasklist_lock);
909
910                 notify_task = find_task_by_pid(notify_pid);
911
912                 if (notify_task) {
913
914                         ret = -EPERM;
915
916                         /*
917                          * check if we can send this task a signal
918                          */
919                         if (pfm_bad_permissions(notify_task)) goto buffer_error;
920
921                         /* 
922                          * make visible
923                          * must be done inside critical section
924                          *
925                          * if the initialization does not go through it is still
926                          * okay because child will do the scan for nothing which
927                          * won't hurt.
928                          */
929                         current->thread.pfm_context = ctx;
930
931                         /*
932                          * will cause task to check on exit for monitored
933                          * processes that would notify it. see release_thread()
934                          * Note: the scan MUST be done in release thread, once the
935                          * task has been detached from the tasklist otherwise you are
936                          * exposed to race conditions.
937                          */
938                         atomic_add(1, &ctx->ctx_notify_task->thread.pfm_notifiers_check);
939
940                         ctx->ctx_notify_task = notify_task;
941                 }
942                 read_unlock(&tasklist_lock);
943         }
944
945         /*
946          * notification process does not exist
947          */
948         if (notify_pid != 0 && ctx->ctx_notify_task == NULL) {
949                 ret = -EINVAL;
950                 goto buffer_error;
951         }
952
953         if (tmp.ctx_smpl_entries) {
954                 DBprintk(("sampling entries=%ld\n",tmp.ctx_smpl_entries));
955
956                 ret = pfm_smpl_buffer_alloc(ctx, tmp.ctx_smpl_regs, 
957                                                  tmp.ctx_smpl_entries, &uaddr);
958                 if (ret<0) goto buffer_error;
959
960                 tmp.ctx_smpl_vaddr = uaddr;
961         }
962         /* initialization of context's flags */
963         ctx->ctx_fl_inherit   = ctx_flags & PFM_FL_INHERIT_MASK;
964         ctx->ctx_fl_block     = (ctx_flags & PFM_FL_NOTIFY_BLOCK) ? 1 : 0;
965         ctx->ctx_fl_system    = (ctx_flags & PFM_FL_SYSTEM_WIDE) ? 1: 0;
966         ctx->ctx_fl_frozen    = 0;
967         /*
968          * setting this flag to 0 here means, that the creator or the task that the
969          * context is being attached are granted access. Given that a context can only
970          * be created for the calling process this, in effect only allows the creator
971          * to access the context. See pfm_protect() for more.
972          */
973         ctx->ctx_fl_protected = 0;
974
975         /* for system wide mode only (only 1 bit set) */
976         ctx->ctx_cpu         = cpu;
977
978         atomic_set(&ctx->ctx_last_cpu,-1); /* SMP only, means no CPU */
979
980         /* 
981          * Keep track of the pmds we want to sample
982          * XXX: may be we don't need to save/restore the DEAR/IEAR pmds
983          * but we do need the BTB for sure. This is because of a hardware
984          * buffer of 1 only for non-BTB pmds.
985          *
986          * We ignore the unimplemented pmds specified by the user
987          */
988         ctx->ctx_used_pmds[0]  = tmp.ctx_smpl_regs[0] & pmu_conf.impl_regs[4];
989         ctx->ctx_saved_pmcs[0] = 1; /* always save/restore PMC[0] */
990
991         sema_init(&ctx->ctx_restart_sem, 0); /* init this semaphore to locked */
992
993
994         if (copy_to_user(req, &tmp, sizeof(tmp))) {
995                 ret = -EFAULT;
996                 goto buffer_error;
997         }
998
999         DBprintk(("context=%p, pid=%d notify_task=%p\n",
1000                         (void *)ctx, task->pid, ctx->ctx_notify_task));
1001
1002         DBprintk(("context=%p, pid=%d flags=0x%x inherit=%d block=%d system=%d\n", 
1003                         (void *)ctx, task->pid, ctx_flags, ctx->ctx_fl_inherit, 
1004                         ctx->ctx_fl_block, ctx->ctx_fl_system));
1005
1006         /*
1007          * when no notification is required, we can make this visible at the last moment
1008          */
1009         if (notify_pid == 0) task->thread.pfm_context = ctx;
1010         /*
1011          * pin task to CPU and force reschedule on exit to ensure
1012          * that when back to user level the task runs on the designated
1013          * CPU.
1014          */
1015         if (ctx->ctx_fl_system) {
1016                 ctx->ctx_saved_cpus_allowed = task->cpus_allowed;
1017                 set_cpus_allowed(task, 1UL << cpu);
1018                 DBprintk(("[%d] rescheduled allowed=0x%lx\n", task->pid,task->cpus_allowed));
1019         }
1020
1021         return 0;
1022
1023 buffer_error:
1024         pfm_context_free(ctx);
1025 error:
1026         /*
1027          * undo session reservation
1028          */
1029         LOCK_PFS();
1030
1031         if (ctx_flags & PFM_FL_SYSTEM_WIDE) {
1032                 pfm_sessions.pfs_sys_session[cpu] = NULL;
1033                 pfm_sessions.pfs_sys_sessions--;
1034         } else {
1035                 pfm_sessions.pfs_task_sessions--;
1036         }
1037 abort:
1038         UNLOCK_PFS();
1039
1040         return ret;
1041 }
1042
1043 static void
1044 pfm_reset_regs(pfm_context_t *ctx, unsigned long *ovfl_regs, int flag)
1045 {
1046         unsigned long mask = ovfl_regs[0];
1047         unsigned long reset_others = 0UL;
1048         unsigned long val;
1049         int i;
1050
1051         DBprintk(("masks=0x%lx\n", mask));
1052
1053         /*
1054          * now restore reset value on sampling overflowed counters
1055          */
1056         mask >>= PMU_FIRST_COUNTER;
1057         for(i = PMU_FIRST_COUNTER; mask; i++, mask >>= 1) {
1058                 if (mask & 0x1) {
1059                         val  = flag == PFM_RELOAD_LONG_RESET ? 
1060                                         ctx->ctx_soft_pmds[i].long_reset:
1061                                         ctx->ctx_soft_pmds[i].short_reset;
1062
1063                         reset_others |= ctx->ctx_soft_pmds[i].reset_pmds[0];
1064
1065                         DBprintk(("[%d] %s reset soft_pmd[%d]=%lx\n", 
1066                                 current->pid, 
1067                                 flag == PFM_RELOAD_LONG_RESET ? "long" : "short", i, val));
1068
1069                         /* upper part is ignored on rval */
1070                         pfm_write_soft_counter(ctx, i, val);
1071                 }
1072         }
1073
1074         /*
1075          * Now take care of resetting the other registers
1076          */
1077         for(i = 0; reset_others; i++, reset_others >>= 1) {
1078
1079                 if ((reset_others & 0x1) == 0) continue;
1080
1081                 val  = flag == PFM_RELOAD_LONG_RESET ? 
1082                                         ctx->ctx_soft_pmds[i].long_reset:
1083                                         ctx->ctx_soft_pmds[i].short_reset;
1084
1085                 if (PMD_IS_COUNTING(i)) {
1086                         pfm_write_soft_counter(ctx, i, val);
1087                 } else {
1088                         ia64_set_pmd(i, val);
1089                 }
1090
1091                 DBprintk(("[%d] %s reset_others pmd[%d]=%lx\n", 
1092                                 current->pid, 
1093                                 flag == PFM_RELOAD_LONG_RESET ? "long" : "short", i, val));
1094         }
1095         /* just in case ! */
1096         ctx->ctx_ovfl_regs[0] = 0UL;
1097 }
1098
1099 static int
1100 pfm_write_pmcs(struct task_struct *ta, pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
1101 {
1102         struct thread_struct *th = &ta->thread;
1103         pfarg_reg_t tmp, *req = (pfarg_reg_t *)arg;
1104         unsigned int cnum;
1105         int i;
1106         int ret = 0, reg_retval = 0;
1107
1108         /* we don't quite support this right now */
1109         if (ta != current) return -EINVAL;
1110
1111         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1112
1113         /* XXX: ctx locking may be required here */
1114
1115         for (i = 0; i < count; i++, req++) {
1116
1117
1118                 if (copy_from_user(&tmp, req, sizeof(tmp))) return -EFAULT;
1119
1120                 cnum = tmp.reg_num;
1121
1122                 /* 
1123                  * we reject all non implemented PMC as well
1124                  * as attempts to modify PMC[0-3] which are used
1125                  * as status registers by the PMU
1126                  */
1127                 if (!PMC_IS_IMPL(cnum) || cnum < 4) {
1128                         DBprintk(("pmc[%u] is unimplemented or invalid\n", cnum));
1129                         ret = -EINVAL;
1130                         goto abort_mission;
1131                 }
1132                 /*
1133                  * A PMC used to configure monitors must be:
1134                  *      - system-wide session: privileged monitor
1135                  *      - per-task : user monitor
1136                  * any other configuration is rejected.
1137                  */
1138                 if (PMC_IS_MONITOR(cnum)) {
1139                         pfm_monitor_t *p = (pfm_monitor_t *)&tmp.reg_value;
1140
1141                         DBprintk(("pmc[%u].pm = %d\n", cnum, p->pmc_pm));
1142
1143                         if (ctx->ctx_fl_system ^ p->pmc_pm) {
1144                         //if ((ctx->ctx_fl_system == 1 && p->pmc_pm == 0)
1145                          //  ||(ctx->ctx_fl_system == 0 && p->pmc_pm == 1)) {
1146                                 ret = -EINVAL;
1147                                 goto abort_mission;
1148                         }
1149                         /*
1150                          * enforce generation of overflow interrupt. Necessary on all
1151                          * CPUs which do not implement 64-bit hardware counters.
1152                          */
1153                         p->pmc_oi = 1;
1154                 }
1155
1156                 if (PMC_IS_COUNTING(cnum)) {
1157                         if (tmp.reg_flags & PFM_REGFL_OVFL_NOTIFY) {
1158                                 /*
1159                                  * must have a target for the signal
1160                                  */
1161                                 if (ctx->ctx_notify_task == NULL) {
1162                                         ret = -EINVAL;
1163                                         goto abort_mission;
1164                                 }
1165
1166                                 ctx->ctx_soft_pmds[cnum].flags |= PFM_REGFL_OVFL_NOTIFY;
1167                         }
1168                         /*
1169                          * copy reset vector
1170                          */
1171                         ctx->ctx_soft_pmds[cnum].reset_pmds[0] = tmp.reg_reset_pmds[0];
1172                         ctx->ctx_soft_pmds[cnum].reset_pmds[1] = tmp.reg_reset_pmds[1];
1173                         ctx->ctx_soft_pmds[cnum].reset_pmds[2] = tmp.reg_reset_pmds[2];
1174                         ctx->ctx_soft_pmds[cnum].reset_pmds[3] = tmp.reg_reset_pmds[3];
1175
1176                         /*
1177                          * needed in case the user does not initialize the equivalent
1178                          * PMD. Clearing is done in reset_pmu() so there is no possible
1179                          * leak here.
1180                          */
1181                         CTX_USED_PMD(ctx, cnum);
1182                 }
1183 abort_mission:
1184                 if (ret == -EINVAL) reg_retval = PFM_REG_RETFL_EINVAL;
1185
1186                 PFM_REG_RETFLAG_SET(tmp.reg_flags, reg_retval);
1187
1188                 /*
1189                  * update register return value, abort all if problem during copy.
1190                  */
1191                 if (copy_to_user(req, &tmp, sizeof(tmp))) return -EFAULT;
1192
1193                 /*
1194                  * if there was something wrong on this register, don't touch
1195                  * the hardware at all and abort write request for others.
1196                  *
1197                  * On error, the user mut sequentially scan the table and the first
1198                  * entry which has a return flag set is the one that caused the error.
1199                  */
1200                 if (ret != 0) {
1201                         DBprintk(("[%d] pmc[%u]=0x%lx error %d\n",
1202                                   ta->pid, cnum, tmp.reg_value, reg_retval));
1203                         break;
1204                 }
1205
1206                 /* 
1207                  * We can proceed with this register!
1208                  */
1209                 
1210                 /* 
1211                  * keep copy the pmc, used for register reload
1212                  */
1213                 th->pmc[cnum] = tmp.reg_value;
1214
1215                 ia64_set_pmc(cnum, tmp.reg_value);
1216
1217                 DBprintk(("[%d] pmc[%u]=0x%lx flags=0x%x save_pmcs=0%lx reload_pmcs=0x%lx\n", 
1218                           ta->pid, cnum, tmp.reg_value, 
1219                           ctx->ctx_soft_pmds[cnum].flags, 
1220                           ctx->ctx_saved_pmcs[0], ctx->ctx_reload_pmcs[0]));
1221
1222         }
1223         return ret;
1224 }
1225
1226 static int
1227 pfm_write_pmds(struct task_struct *ta, pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
1228 {
1229         pfarg_reg_t tmp, *req = (pfarg_reg_t *)arg;
1230         unsigned int cnum;
1231         int i;
1232         int ret = 0, reg_retval = 0;
1233
1234         /* we don't quite support this right now */
1235         if (ta != current) return -EINVAL;
1236
1237         /* 
1238          * Cannot do anything before PMU is enabled 
1239          */
1240         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1241
1242
1243         /* XXX: ctx locking may be required here */
1244
1245         for (i = 0; i < count; i++, req++) {
1246
1247                 if (copy_from_user(&tmp, req, sizeof(tmp))) return -EFAULT;
1248
1249                 cnum = tmp.reg_num;
1250
1251                 if (!PMD_IS_IMPL(cnum)) {
1252                         ret = -EINVAL;
1253                         goto abort_mission;
1254                 }
1255
1256                 /* update virtualized (64bits) counter */
1257                 if (PMD_IS_COUNTING(cnum)) {
1258                         ctx->ctx_soft_pmds[cnum].ival = tmp.reg_value;
1259                         ctx->ctx_soft_pmds[cnum].val  = tmp.reg_value & ~pmu_conf.perf_ovfl_val;
1260                         ctx->ctx_soft_pmds[cnum].long_reset = tmp.reg_long_reset;
1261                         ctx->ctx_soft_pmds[cnum].short_reset = tmp.reg_short_reset;
1262
1263                 }
1264 abort_mission:
1265                 if (ret == -EINVAL) reg_retval = PFM_REG_RETFL_EINVAL;
1266
1267                 PFM_REG_RETFLAG_SET(tmp.reg_flags, reg_retval);
1268
1269                 if (copy_to_user(req, &tmp, sizeof(tmp))) return -EFAULT;
1270
1271                 /*
1272                  * if there was something wrong on this register, don't touch
1273                  * the hardware at all and abort write request for others.
1274                  *
1275                  * On error, the user mut sequentially scan the table and the first
1276                  * entry which has a return flag set is the one that caused the error.
1277                  */
1278                 if (ret != 0) {
1279                         DBprintk(("[%d] pmc[%u]=0x%lx error %d\n",
1280                                   ta->pid, cnum, tmp.reg_value, reg_retval));
1281                         break;
1282                 }
1283
1284                 /* keep track of what we use */
1285                 CTX_USED_PMD(ctx, cnum);
1286
1287                 /* writes to unimplemented part is ignored, so this is safe */
1288                 ia64_set_pmd(cnum, tmp.reg_value);
1289
1290                 /* to go away */
1291                 ia64_srlz_d();
1292                 DBprintk(("[%d] pmd[%u]: soft_pmd=0x%lx  short_reset=0x%lx "
1293                           "long_reset=0x%lx hw_pmd=%lx notify=%c used_pmds=0x%lx reset_pmds=0x%lx\n",
1294                                 ta->pid, cnum,
1295                                 ctx->ctx_soft_pmds[cnum].val,
1296                                 ctx->ctx_soft_pmds[cnum].short_reset,
1297                                 ctx->ctx_soft_pmds[cnum].long_reset,
1298                                 ia64_get_pmd(cnum) & pmu_conf.perf_ovfl_val,
1299                                 PMC_OVFL_NOTIFY(ctx, cnum) ? 'Y':'N',
1300                                 ctx->ctx_used_pmds[0],
1301                                 ctx->ctx_soft_pmds[cnum].reset_pmds[0]));
1302         }
1303         return ret;
1304 }
1305
1306 static int
1307 pfm_read_pmds(struct task_struct *ta, pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
1308 {
1309         struct thread_struct *th = &ta->thread;
1310         unsigned long val=0;
1311         pfarg_reg_t tmp, *req = (pfarg_reg_t *)arg;
1312         int i;
1313
1314         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1315
1316         /*
1317          * XXX: MUST MAKE SURE WE DON"T HAVE ANY PENDING OVERFLOW BEFORE READING
1318          * This is required when the monitoring has been stoppped by user or kernel.
1319          * If it is still going on, then that's fine because we a re not guaranteed
1320          * to return an accurate value in this case.
1321          */
1322
1323         /* XXX: ctx locking may be required here */
1324
1325         DBprintk(("ctx_last_cpu=%d for [%d]\n", atomic_read(&ctx->ctx_last_cpu), ta->pid));
1326
1327         for (i = 0; i < count; i++, req++) {
1328                 unsigned long reg_val = ~0UL, ctx_val = ~0UL;
1329
1330                 if (copy_from_user(&tmp, req, sizeof(tmp))) return -EFAULT;
1331
1332                 if (!PMD_IS_IMPL(tmp.reg_num)) goto abort_mission;
1333
1334                 /*
1335                  * If the task is not the current one, then we check if the
1336                  * PMU state is still in the local live register due to lazy ctxsw.
1337                  * If true, then we read directly from the registers.
1338                  */
1339                 if (atomic_read(&ctx->ctx_last_cpu) == smp_processor_id()){
1340                         ia64_srlz_d();
1341                         val = reg_val = ia64_get_pmd(tmp.reg_num);
1342                         DBprintk(("reading pmd[%u]=0x%lx from hw\n", tmp.reg_num, val));
1343                 } else {
1344 #ifdef CONFIG_SMP
1345                         int cpu;
1346                         /*
1347                          * for SMP system, the context may still be live on another
1348                          * CPU so we need to fetch it before proceeding with the read
1349                          * This call we only be made once for the whole loop because
1350                          * of ctx_last_cpu becoming == -1.
1351                          *
1352                          * We cannot reuse ctx_last_cpu as it may change before we get to the
1353                          * actual IPI call. In this case, we will do the call for nothing but
1354                          * there is no way around it. The receiving side will simply do nothing.
1355                          */
1356                         cpu = atomic_read(&ctx->ctx_last_cpu);
1357                         if (cpu != -1) {
1358                                 DBprintk(("must fetch on CPU%d for [%d]\n", cpu, ta->pid));
1359                                 pfm_fetch_regs(cpu, ta, ctx);
1360                         }
1361 #endif
1362                         /* context has been saved */
1363                         val = reg_val = th->pmd[tmp.reg_num];
1364                 }
1365                 if (PMD_IS_COUNTING(tmp.reg_num)) {
1366                         /*
1367                          * XXX: need to check for overflow
1368                          */
1369
1370                         val &= pmu_conf.perf_ovfl_val;
1371                         val += ctx_val = ctx->ctx_soft_pmds[tmp.reg_num].val;
1372                 } else {
1373
1374                         val = reg_val = ia64_get_pmd(tmp.reg_num);
1375                 }
1376                 PFM_REG_RETFLAG_SET(tmp.reg_flags, 0);
1377                 tmp.reg_value = val;
1378
1379                 DBprintk(("read pmd[%u] soft_pmd=0x%lx reg=0x%lx pmc=0x%lx\n", 
1380                                         tmp.reg_num, ctx_val, reg_val, 
1381                                         ia64_get_pmc(tmp.reg_num)));
1382
1383                 if (copy_to_user(req, &tmp, sizeof(tmp))) return -EFAULT;
1384         }
1385         return 0;
1386 abort_mission:
1387         PFM_REG_RETFLAG_SET(tmp.reg_flags, PFM_REG_RETFL_EINVAL);
1388         /* 
1389          * XXX: if this fails, we stick we the original failure, flag not updated!
1390          */
1391         copy_to_user(req, &tmp, sizeof(tmp));
1392         return -EINVAL;
1393
1394 }
1395
1396 #ifdef PFM_PMU_USES_DBR
1397 /*
1398  * Only call this function when a process it trying to
1399  * write the debug registers (reading is always allowed)
1400  */
1401 int
1402 pfm_use_debug_registers(struct task_struct *task)
1403 {
1404         pfm_context_t *ctx = task->thread.pfm_context;
1405         int ret = 0;
1406
1407         DBprintk(("called for [%d]\n", task->pid));
1408
1409         /*
1410          * do it only once
1411          */
1412         if (task->thread.flags & IA64_THREAD_DBG_VALID) return 0;
1413
1414         /*
1415          * Even on SMP, we do not need to use an atomic here because
1416          * the only way in is via ptrace() and this is possible only when the
1417          * process is stopped. Even in the case where the ctxsw out is not totally
1418          * completed by the time we come here, there is no way the 'stopped' process
1419          * could be in the middle of fiddling with the pfm_write_ibr_dbr() routine.
1420          * So this is always safe.
1421          */
1422         if (ctx && ctx->ctx_fl_using_dbreg == 1) return -1;
1423
1424         /*
1425          * XXX: not pretty
1426          */
1427         LOCK_PFS();
1428
1429         /*
1430          * We only allow the use of debug registers when there is no system
1431          * wide monitoring 
1432          * XXX: we could relax this by 
1433          */
1434         if (pfm_sessions.pfs_sys_use_dbregs> 0)
1435                 ret = -1;
1436         else
1437                 pfm_sessions.pfs_ptrace_use_dbregs++;
1438
1439         DBprintk(("ptrace_use_dbregs=%lu  sys_use_dbregs=%lu by [%d] ret = %d\n", 
1440                   pfm_sessions.pfs_ptrace_use_dbregs, 
1441                   pfm_sessions.pfs_sys_use_dbregs, 
1442                   task->pid, ret));
1443
1444         UNLOCK_PFS();
1445
1446         return ret;
1447 }
1448
1449 /*
1450  * This function is called for every task that exits with the
1451  * IA64_THREAD_DBG_VALID set. This indicates a task which was
1452  * able to use the debug registers for debugging purposes via
1453  * ptrace(). Therefore we know it was not using them for
1454  * perfmormance monitoring, so we only decrement the number
1455  * of "ptraced" debug register users to keep the count up to date
1456  */
1457 int
1458 pfm_release_debug_registers(struct task_struct *task)
1459 {
1460         int ret;
1461
1462         LOCK_PFS();
1463         if (pfm_sessions.pfs_ptrace_use_dbregs == 0) {
1464                 printk("perfmon: invalid release for [%d] ptrace_use_dbregs=0\n", task->pid);
1465                 ret = -1;
1466         }  else {
1467                 pfm_sessions.pfs_ptrace_use_dbregs--;
1468                 ret = 0;
1469         }
1470         UNLOCK_PFS();
1471
1472         return ret;
1473 }
1474 #else /* PFM_PMU_USES_DBR is true */
1475 /*
1476  * in case, the PMU does not use the debug registers, these two functions are nops.
1477  * The first function is called from arch/ia64/kernel/ptrace.c.
1478  * The second function is called from arch/ia64/kernel/process.c.
1479  */
1480 int
1481 pfm_use_debug_registers(struct task_struct *task)
1482 {
1483         return 0;
1484 }
1485 int
1486 pfm_release_debug_registers(struct task_struct *task)
1487 {
1488         return 0;
1489 }
1490 #endif /* PFM_PMU_USES_DBR */
1491
1492 static int
1493 pfm_restart(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1494          struct pt_regs *regs)
1495 {
1496         void *sem = &ctx->ctx_restart_sem;
1497
1498         /* 
1499          * Cannot do anything before PMU is enabled 
1500          */
1501         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1502
1503
1504         if (ctx->ctx_fl_frozen==0) {
1505                 printk("task %d without pmu_frozen set\n", task->pid);
1506                 return -EINVAL;
1507         }
1508
1509         if (task == current) {
1510                 DBprintk(("restarting self %d frozen=%d \n", current->pid, ctx->ctx_fl_frozen));
1511
1512                 pfm_reset_regs(ctx, ctx->ctx_ovfl_regs, PFM_RELOAD_LONG_RESET);
1513
1514                 ctx->ctx_ovfl_regs[0] = 0UL;
1515
1516                 /*
1517                  * We ignore block/don't block because we never block
1518                  * for a self-monitoring process.
1519                  */
1520                 ctx->ctx_fl_frozen = 0;
1521
1522                 if (CTX_HAS_SMPL(ctx)) {
1523                         ctx->ctx_psb->psb_hdr->hdr_count = 0;
1524                         ctx->ctx_psb->psb_index = 0;
1525                 }
1526
1527                 /* simply unfreeze */
1528                 ia64_set_pmc(0, 0);
1529                 ia64_srlz_d();
1530
1531                 return 0;
1532         } 
1533         /* restart on another task */
1534
1535         /*
1536          * if blocking, then post the semaphore.
1537          * if non-blocking, then we ensure that the task will go into
1538          * pfm_overflow_must_block() before returning to user mode. 
1539          * We cannot explicitely reset another task, it MUST always
1540          * be done by the task itself. This works for system wide because
1541          * the tool that is controlling the session is doing "self-monitoring".
1542          *
1543          * XXX: what if the task never goes back to user?
1544          *
1545          */
1546         if (CTX_OVFL_NOBLOCK(ctx) == 0) {
1547                 DBprintk(("unblocking %d \n", task->pid));
1548                 up(sem);
1549         } else {
1550                 task->thread.pfm_ovfl_block_reset = 1;
1551                 set_tsk_thread_flag(current, TIF_NOTIFY_RESUME);
1552         }
1553 #if 0
1554         /*
1555          * in case of non blocking mode, then it's just a matter of
1556          * of reseting the sampling buffer (if any) index. The PMU
1557          * is already active.
1558          */
1559
1560         /*
1561          * must reset the header count first
1562          */
1563         if (CTX_HAS_SMPL(ctx)) {
1564                 DBprintk(("resetting sampling indexes for %d \n", task->pid));
1565                 ctx->ctx_psb->psb_hdr->hdr_count = 0;
1566                 ctx->ctx_psb->psb_index = 0;
1567         }
1568 #endif
1569         return 0;
1570 }
1571
1572 static int
1573 pfm_destroy_context(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1574          struct pt_regs *regs)
1575 {
1576         /* we don't quite support this right now */
1577         if (task != current) return -EINVAL;
1578
1579                 if (ctx->ctx_fl_system) {
1580                 ia64_psr(regs)->pp = 0;
1581                 __asm__ __volatile__ ("rsm psr.pp;;"::: "memory");
1582         } else {
1583                 ia64_psr(regs)->up = 0;
1584                 __asm__ __volatile__ ("rum psr.up;;"::: "memory");
1585
1586                 task->thread.flags &= ~IA64_THREAD_PM_VALID;
1587         }
1588
1589         SET_PMU_OWNER(NULL);
1590
1591         /* freeze PMU */
1592         ia64_set_pmc(0, 1);
1593         ia64_srlz_d();
1594
1595         /* restore security level */
1596         ia64_psr(regs)->sp = 1;
1597
1598         /*
1599          * remove sampling buffer mapping, if any
1600          */
1601         if (ctx->ctx_smpl_vaddr) pfm_remove_smpl_mapping(task);
1602
1603         /* now free context and related state */
1604         pfm_context_exit(task);
1605
1606         return 0;
1607 }
1608
1609 /*
1610  * does nothing at the moment
1611  */
1612 static int
1613 pfm_unprotect_context(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1614          struct pt_regs *regs)
1615 {
1616         return 0;
1617 }
1618
1619 static int
1620 pfm_protect_context(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1621          struct pt_regs *regs)
1622 {
1623         DBprintk(("context from [%d] is protected\n", task->pid));
1624         /*
1625          * from now on, only the creator of the context has access to it
1626          */
1627         ctx->ctx_fl_protected = 1;
1628
1629         /*
1630          * reinforce secure monitoring: cannot toggle psr.up
1631          */
1632         ia64_psr(regs)->sp = 1;
1633
1634         return 0;
1635 }
1636
1637 static int
1638 pfm_debug(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1639          struct pt_regs *regs)
1640 {
1641         unsigned int mode = *(unsigned int *)arg;
1642
1643         pfm_debug_mode = mode == 0 ? 0 : 1;
1644
1645         printk("perfmon debugging %s\n", pfm_debug_mode ? "on" : "off");
1646
1647         return 0;
1648 }
1649
1650 #ifdef PFM_PMU_USES_DBR
1651
1652 typedef struct {
1653         unsigned long ibr_mask:56;
1654         unsigned long ibr_plm:4;
1655         unsigned long ibr_ig:3;
1656         unsigned long ibr_x:1;
1657 } ibr_mask_reg_t;
1658
1659 typedef struct {
1660         unsigned long dbr_mask:56;
1661         unsigned long dbr_plm:4;
1662         unsigned long dbr_ig:2;
1663         unsigned long dbr_w:1;
1664         unsigned long dbr_r:1;
1665 } dbr_mask_reg_t;
1666
1667 typedef union {
1668         unsigned long  val;
1669         ibr_mask_reg_t ibr;
1670         dbr_mask_reg_t dbr;
1671 } dbreg_t;
1672
1673
1674 static int
1675 pfm_write_ibr_dbr(int mode, struct task_struct *task, void *arg, int count, struct pt_regs *regs)
1676 {
1677         struct thread_struct *thread = &task->thread;
1678         pfm_context_t *ctx = task->thread.pfm_context;
1679         pfarg_dbreg_t tmp, *req = (pfarg_dbreg_t *)arg;
1680         dbreg_t dbreg;
1681         unsigned int rnum;
1682         int first_time;
1683         int i, ret = 0;
1684
1685         /*
1686          * for range restriction: psr.db must be cleared or the
1687          * the PMU will ignore the debug registers.
1688          *
1689          * XXX: may need more in system wide mode,
1690          * no task can have this bit set?
1691          */
1692         if (ia64_psr(regs)->db == 1) return -EINVAL;
1693
1694
1695         first_time = ctx->ctx_fl_using_dbreg == 0;
1696
1697         /*
1698          * check for debug registers in system wide mode
1699          *
1700          */
1701         LOCK_PFS();
1702         if (ctx->ctx_fl_system && first_time) {
1703                 if (pfm_sessions.pfs_ptrace_use_dbregs) 
1704                         ret = -EBUSY;
1705                 else
1706                         pfm_sessions.pfs_sys_use_dbregs++;
1707         }
1708         UNLOCK_PFS();
1709
1710         if (ret != 0) return ret;
1711
1712         if (ctx->ctx_fl_system) {
1713                 /* we mark ourselves as owner  of the debug registers */
1714                 ctx->ctx_fl_using_dbreg = 1;
1715         } else {
1716                 if (ctx->ctx_fl_using_dbreg == 0) {
1717                         ret= -EBUSY;
1718                         if ((thread->flags & IA64_THREAD_DBG_VALID) != 0) {
1719                                 DBprintk(("debug registers already in use for [%d]\n", task->pid));
1720                                 goto abort_mission;
1721                         }
1722                         /* we mark ourselves as owner  of the debug registers */
1723                         ctx->ctx_fl_using_dbreg = 1;
1724
1725                         /* 
1726                          * Given debug registers cannot be used for both debugging 
1727                          * and performance monitoring at the same time, we reuse
1728                          * the storage area to save and restore the registers on ctxsw.
1729                          */
1730                         memset(task->thread.dbr, 0, sizeof(task->thread.dbr));
1731                         memset(task->thread.ibr, 0, sizeof(task->thread.ibr));
1732
1733                         /*
1734                          * clear hardware registers to make sure we don't leak
1735                          * information and pick up stale state
1736                          */
1737                         for (i=0; i < pmu_conf.num_ibrs; i++) {
1738                                 ia64_set_ibr(i, 0UL);
1739                         }
1740                         for (i=0; i < pmu_conf.num_dbrs; i++) {
1741                                 ia64_set_dbr(i, 0UL);
1742                         }
1743                 }
1744         }
1745
1746         ret = -EFAULT;
1747
1748         /*
1749          * Now install the values into the registers
1750          */
1751         for (i = 0; i < count; i++, req++) {
1752
1753                 
1754                 if (copy_from_user(&tmp, req, sizeof(tmp))) goto abort_mission;
1755                 
1756                 rnum      = tmp.dbreg_num;
1757                 dbreg.val = tmp.dbreg_value;
1758                 
1759                 ret = -EINVAL;
1760
1761                 if ((mode == 0 && !IBR_IS_IMPL(rnum)) || ((mode == 1) && !DBR_IS_IMPL(rnum))) {
1762                         DBprintk(("invalid register %u val=0x%lx mode=%d i=%d count=%d\n", 
1763                                   rnum, dbreg.val, mode, i, count));
1764
1765                         goto abort_mission;
1766                 }
1767
1768                 /*
1769                  * make sure we do not install enabled breakpoint
1770                  */
1771                 if (rnum & 0x1) {
1772                         if (mode == 0) 
1773                                 dbreg.ibr.ibr_x = 0;
1774                         else
1775                                 dbreg.dbr.dbr_r = dbreg.dbr.dbr_w = 0;
1776                 }
1777
1778                 /*
1779                  * clear return flags and copy back to user
1780                  *
1781                  * XXX: fix once EAGAIN is implemented
1782                  */
1783                 ret = -EFAULT;
1784
1785                 PFM_REG_RETFLAG_SET(tmp.dbreg_flags, 0);
1786
1787                 if (copy_to_user(req, &tmp, sizeof(tmp))) goto abort_mission;
1788
1789                 /*
1790                  * Debug registers, just like PMC, can only be modified
1791                  * by a kernel call. Moreover, perfmon() access to those
1792                  * registers are centralized in this routine. The hardware
1793                  * does not modify the value of these registers, therefore,
1794                  * if we save them as they are written, we can avoid having
1795                  * to save them on context switch out. This is made possible
1796                  * by the fact that when perfmon uses debug registers, ptrace()
1797                  * won't be able to modify them concurrently.
1798                  */
1799                 if (mode == 0) {
1800                         CTX_USED_IBR(ctx, rnum);
1801
1802                         ia64_set_ibr(rnum, dbreg.val);
1803
1804                         thread->ibr[rnum] = dbreg.val;
1805
1806                         DBprintk(("write ibr%u=0x%lx used_ibrs=0x%lx\n", rnum, dbreg.val, ctx->ctx_used_ibrs[0]));
1807                 } else {
1808                         CTX_USED_DBR(ctx, rnum);
1809
1810                         ia64_set_dbr(rnum, dbreg.val);
1811
1812                         thread->dbr[rnum] = dbreg.val;
1813
1814                         DBprintk(("write dbr%u=0x%lx used_dbrs=0x%lx\n", rnum, dbreg.val, ctx->ctx_used_dbrs[0]));
1815                 }
1816         }
1817
1818         return 0;
1819
1820 abort_mission:
1821         /*
1822          * in case it was our first attempt, we undo the global modifications
1823          */
1824         if (first_time) {
1825                 LOCK_PFS();
1826                 if (ctx->ctx_fl_system) {
1827                         pfm_sessions.pfs_sys_use_dbregs--;
1828                 }
1829                 UNLOCK_PFS();
1830                 ctx->ctx_fl_using_dbreg = 0;
1831         }
1832         /*
1833          * install error return flag
1834          */
1835         if (ret != -EFAULT) {
1836                 /*
1837                  * XXX: for now we can only come here on EINVAL
1838                  */
1839                 PFM_REG_RETFLAG_SET(tmp.dbreg_flags, PFM_REG_RETFL_EINVAL);
1840                 copy_to_user(req, &tmp, sizeof(tmp));
1841         }
1842         return ret;
1843 }
1844
1845 static int
1846 pfm_write_ibrs(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1847          struct pt_regs *regs)
1848 {       
1849         /* we don't quite support this right now */
1850         if (task != current) return -EINVAL;
1851
1852         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1853
1854         return pfm_write_ibr_dbr(0, task, arg, count, regs);
1855 }
1856
1857 static int
1858 pfm_write_dbrs(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1859          struct pt_regs *regs)
1860 {       
1861         /* we don't quite support this right now */
1862         if (task != current) return -EINVAL;
1863
1864         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1865
1866         return pfm_write_ibr_dbr(1, task, arg, count, regs);
1867 }
1868
1869 #endif /* PFM_PMU_USES_DBR */
1870
1871 static int
1872 pfm_get_features(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, struct pt_regs *regs)
1873 {
1874         pfarg_features_t tmp;
1875
1876         memset(&tmp, 0, sizeof(tmp));
1877
1878         tmp.ft_version      = PFM_VERSION;
1879         tmp.ft_smpl_version = PFM_SMPL_VERSION;
1880
1881         if (copy_to_user(arg, &tmp, sizeof(tmp))) return -EFAULT;
1882
1883         return 0;
1884 }
1885
1886 static int
1887 pfm_start(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1888           struct pt_regs *regs)
1889 {
1890         /* we don't quite support this right now */
1891         if (task != current) return -EINVAL;
1892
1893         /* 
1894          * Cannot do anything before PMU is enabled 
1895          */
1896         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1897
1898         DBprintk(("[%d] fl_system=%d owner=%p current=%p\n",
1899                                 current->pid,
1900                                 ctx->ctx_fl_system, PMU_OWNER(),
1901                                 current));
1902
1903         if (PMU_OWNER() != task) {
1904                 printk("perfmon: pfm_start task [%d] not pmu owner\n", task->pid);
1905                 return -EINVAL;
1906         }
1907
1908         if (ctx->ctx_fl_system) {
1909                 
1910                 /* enable dcr pp */
1911                 ia64_set_dcr(ia64_get_dcr()|IA64_DCR_PP);
1912
1913                 local_cpu_data->pfm_dcr_pp  = 1;
1914                 ia64_psr(regs)->pp = 1;
1915                 __asm__ __volatile__ ("ssm psr.pp;;"::: "memory");
1916
1917         } else {
1918                 if ((task->thread.flags & IA64_THREAD_PM_VALID) == 0) {
1919                         printk("perfmon: pfm_start task flag not set for [%d]\n", task->pid);
1920                         return -EINVAL;
1921                 }
1922                 ia64_psr(regs)->up = 1;
1923                 __asm__ __volatile__ ("sum psr.up;;"::: "memory");
1924         }
1925         ia64_srlz_d();
1926
1927         return 0;
1928 }
1929
1930 static int
1931 pfm_enable(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1932            struct pt_regs *regs)
1933 {
1934         /* we don't quite support this right now */
1935         if (task != current) return -EINVAL;
1936
1937         if (ctx->ctx_fl_system == 0 && PMU_OWNER()  && PMU_OWNER() != current) 
1938                 pfm_lazy_save_regs(PMU_OWNER());
1939
1940         /* reset all registers to stable quiet state */
1941         ia64_reset_pmu(task);
1942
1943         /* make sure nothing starts */
1944         if (ctx->ctx_fl_system) {
1945                 ia64_psr(regs)->pp = 0;
1946                 ia64_psr(regs)->up = 0; /* just to make sure! */
1947
1948                 __asm__ __volatile__ ("rsm psr.pp;;"::: "memory");
1949
1950 #ifdef CONFIG_SMP
1951                 local_cpu_data->pfm_syst_wide = 1;
1952                 local_cpu_data->pfm_dcr_pp    = 0;
1953 #endif
1954         } else {
1955                 /*
1956                  * needed in case the task was a passive task during
1957                  * a system wide session and now wants to have its own
1958                  * session
1959                  */
1960                 ia64_psr(regs)->pp = 0; /* just to make sure! */
1961                 ia64_psr(regs)->up = 0;
1962
1963                 __asm__ __volatile__ ("rum psr.up;;"::: "memory");
1964                 /*
1965                  * allow user control (user monitors only)
1966                 if (task  == ctx->ctx_owner) {
1967                  */
1968                 {
1969                         DBprintk(("clearing psr.sp for [%d]\n", current->pid));
1970                         ia64_psr(regs)->sp = 0;
1971                 }
1972                 task->thread.flags |= IA64_THREAD_PM_VALID;
1973         }
1974
1975         SET_PMU_OWNER(task);
1976
1977
1978         ctx->ctx_flags.state = PFM_CTX_ENABLED;
1979         atomic_set(&ctx->ctx_last_cpu, smp_processor_id());
1980
1981         /* simply unfreeze */
1982         ia64_set_pmc(0, 0);
1983         ia64_srlz_d();
1984
1985         return 0;
1986 }
1987
1988 static int
1989 pfm_disable(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
1990            struct pt_regs *regs)
1991 {       
1992         /* we don't quite support this right now */
1993         if (task != current) return -EINVAL;
1994
1995         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
1996
1997         /*
1998          * stop monitoring, freeze PMU, and save state in context
1999          */
2000         pfm_flush_regs(task);
2001         
2002         /*
2003          * just to make sure nothing starts again when back in user mode.
2004          * pfm_flush_regs() freezes the PMU anyway.
2005          */ 
2006         if (ctx->ctx_fl_system) {
2007                 ia64_psr(regs)->pp = 0;
2008         } else {
2009                 ia64_psr(regs)->up = 0;
2010         }
2011
2012         /* 
2013          * goes back to default behavior 
2014          * no need to change live psr.sp because useless at the kernel level
2015          */
2016         ia64_psr(regs)->sp = 1;
2017
2018         DBprintk(("enabling psr.sp for [%d]\n", current->pid));
2019
2020         ctx->ctx_flags.state = PFM_CTX_DISABLED;
2021
2022         return 0;
2023 }
2024
2025 static int
2026 pfm_stop(struct task_struct *task, pfm_context_t *ctx, void *arg, int count, 
2027          struct pt_regs *regs)
2028 {
2029         /* we don't quite support this right now */
2030         if (task != current) return -EINVAL;
2031
2032         /* 
2033          * Cannot do anything before PMU is enabled 
2034          */
2035         if (!CTX_IS_ENABLED(ctx)) return -EINVAL;
2036
2037         DBprintk(("[%d] fl_system=%d owner=%p current=%p\n",
2038                                 current->pid,
2039                                 ctx->ctx_fl_system, PMU_OWNER(),
2040                                 current));
2041         /* simply stop monitoring but not the PMU */
2042         if (ctx->ctx_fl_system) {
2043
2044                 __asm__ __volatile__ ("rsm psr.pp;;"::: "memory");
2045
2046                 /* disable dcr pp */
2047                 ia64_set_dcr(ia64_get_dcr() & ~IA64_DCR_PP);
2048
2049                 local_cpu_data->pfm_dcr_pp  = 0;
2050
2051                 ia64_psr(regs)->pp = 0;
2052
2053                 __asm__ __volatile__ ("rsm psr.pp;;"::: "memory");
2054
2055         } else {
2056                 ia64_psr(regs)->up = 0;
2057                 __asm__ __volatile__ ("rum psr.up;;"::: "memory");
2058         }
2059         return 0;
2060 }
2061
2062 /*
2063  * functions MUST be listed in the increasing order of their index (see permfon.h)
2064  */
2065 static pfm_cmd_desc_t pfm_cmd_tab[]={
2066 /* 0  */{ NULL, 0, 0, 0}, /* not used */
2067 /* 1  */{ pfm_write_pmcs, PFM_CMD_PID|PFM_CMD_CTX|PFM_CMD_ARG_READ|PFM_CMD_ARG_WRITE, PFM_CMD_ARG_MANY, sizeof(pfarg_reg_t)}, 
2068 /* 2  */{ pfm_write_pmds, PFM_CMD_PID|PFM_CMD_CTX|PFM_CMD_ARG_READ, PFM_CMD_ARG_MANY, sizeof(pfarg_reg_t)},
2069 /* 3  */{ pfm_read_pmds, PFM_CMD_PID|PFM_CMD_CTX|PFM_CMD_ARG_READ|PFM_CMD_ARG_WRITE, PFM_CMD_ARG_MANY, sizeof(pfarg_reg_t)},
2070 /* 4  */{ pfm_stop, PFM_CMD_PID|PFM_CMD_CTX, 0, 0},
2071 /* 5  */{ pfm_start, PFM_CMD_PID|PFM_CMD_CTX, 0, 0},
2072 /* 6  */{ pfm_enable, PFM_CMD_PID|PFM_CMD_CTX, 0, 0},
2073 /* 7  */{ pfm_disable, PFM_CMD_PID|PFM_CMD_CTX, 0, 0},
2074 /* 8  */{ pfm_create_context, PFM_CMD_ARG_READ, 1, sizeof(pfarg_context_t)},
2075 /* 9  */{ pfm_destroy_context, PFM_CMD_PID|PFM_CMD_CTX, 0, 0},
2076 /* 10 */{ pfm_restart, PFM_CMD_PID|PFM_CMD_CTX|PFM_CMD_NOCHK, 0, 0},
2077 /* 11 */{ pfm_protect_context, PFM_CMD_PID|PFM_CMD_CTX, 0, 0},
2078 /* 12 */{ pfm_get_features, PFM_CMD_ARG_WRITE, 0, 0},
2079 /* 13 */{ pfm_debug, 0, 1, sizeof(unsigned int)},
2080 /* 14 */{ pfm_unprotect_context, PFM_CMD_PID|PFM_CMD_CTX, 0, 0},
2081 /* 15 */{ NULL, 0, 0, 0}, /* not used */
2082 /* 16 */{ NULL, 0, 0, 0}, /* not used */
2083 /* 17 */{ NULL, 0, 0, 0}, /* not used */
2084 /* 18 */{ NULL, 0, 0, 0}, /* not used */
2085 /* 19 */{ NULL, 0, 0, 0}, /* not used */
2086 /* 20 */{ NULL, 0, 0, 0}, /* not used */
2087 /* 21 */{ NULL, 0, 0, 0}, /* not used */
2088 /* 22 */{ NULL, 0, 0, 0}, /* not used */
2089 /* 23 */{ NULL, 0, 0, 0}, /* not used */
2090 /* 24 */{ NULL, 0, 0, 0}, /* not used */
2091 /* 25 */{ NULL, 0, 0, 0}, /* not used */
2092 /* 26 */{ NULL, 0, 0, 0}, /* not used */
2093 /* 27 */{ NULL, 0, 0, 0}, /* not used */
2094 /* 28 */{ NULL, 0, 0, 0}, /* not used */
2095 /* 29 */{ NULL, 0, 0, 0}, /* not used */
2096 /* 30 */{ NULL, 0, 0, 0}, /* not used */
2097 /* 31 */{ NULL, 0, 0, 0}, /* not used */
2098 #ifdef PFM_PMU_USES_DBR
2099 /* 32 */{ pfm_write_ibrs, PFM_CMD_PID|PFM_CMD_CTX|PFM_CMD_ARG_READ|PFM_CMD_ARG_WRITE, PFM_CMD_ARG_MANY, sizeof(pfarg_dbreg_t)},
2100 /* 33 */{ pfm_write_dbrs, PFM_CMD_PID|PFM_CMD_CTX|PFM_CMD_ARG_READ|PFM_CMD_ARG_WRITE, PFM_CMD_ARG_MANY, sizeof(pfarg_dbreg_t)}
2101 #endif
2102 };
2103 #define PFM_CMD_COUNT   (sizeof(pfm_cmd_tab)/sizeof(pfm_cmd_desc_t))
2104
2105 static int
2106 check_task_state(struct task_struct *task)
2107 {
2108         int ret = 0;
2109 #ifdef CONFIG_SMP
2110         /* We must wait until the state has been completely
2111          * saved. There can be situations where the reader arrives before
2112          * after the task is marked as STOPPED but before pfm_save_regs()
2113          * is completed.
2114          */
2115         for (;;) {
2116
2117                 task_lock(task);
2118                 if (1 /*XXX !task_has_cpu(task)*/) break;
2119                 task_unlock(task);
2120
2121                 do {
2122                         if (task->state != TASK_ZOMBIE && task->state != TASK_STOPPED) return -EBUSY;
2123                         barrier();
2124                         cpu_relax();
2125                 } while (0 /*task_has_cpu(task)*/);
2126         }
2127         task_unlock(task);
2128 #else
2129         if (task->state != TASK_ZOMBIE && task->state != TASK_STOPPED) {
2130                 DBprintk(("warning [%d] not in stable state %ld\n", task->pid, task->state));
2131                 ret = -EBUSY;
2132         }
2133 #endif
2134         return ret;
2135 }
2136
2137 asmlinkage int
2138 sys_perfmonctl (pid_t pid, int cmd, void *arg, int count, long arg5, long arg6, long arg7, 
2139                 long arg8, long stack)
2140 {
2141         struct pt_regs *regs = (struct pt_regs *)&stack;
2142         struct task_struct *task = current;
2143         pfm_context_t *ctx = task->thread.pfm_context;
2144         size_t sz;
2145         int ret = -ESRCH, narg;
2146
2147         /* 
2148          * reject any call if perfmon was disabled at initialization time
2149          */
2150         if (PFM_IS_DISABLED()) return -ENOSYS;
2151
2152         DBprintk(("cmd=%d idx=%d valid=%d narg=0x%x\n", cmd, PFM_CMD_IDX(cmd), 
2153                   PFM_CMD_IS_VALID(cmd), PFM_CMD_NARG(cmd)));
2154
2155         if (PFM_CMD_IS_VALID(cmd) == 0) return -EINVAL;
2156
2157         /* ingore arguments when command has none */
2158         narg = PFM_CMD_NARG(cmd);
2159         if ((narg == PFM_CMD_ARG_MANY  && count == 0) || (narg > 0 && narg != count)) return -EINVAL;
2160
2161         sz = PFM_CMD_ARG_SIZE(cmd);
2162
2163         if (PFM_CMD_READ_ARG(cmd) && !access_ok(VERIFY_READ, arg, sz*count)) return -EFAULT;
2164
2165         if (PFM_CMD_WRITE_ARG(cmd) && !access_ok(VERIFY_WRITE, arg, sz*count)) return -EFAULT;
2166
2167         if (PFM_CMD_USE_PID(cmd))  {
2168                 /* 
2169                  * XXX: may need to fine tune this one
2170                  */
2171                 if (pid < 2) return -EPERM;
2172
2173                 if (pid != current->pid) {
2174
2175                         read_lock(&tasklist_lock);
2176
2177                         task = find_task_by_pid(pid);
2178
2179                         if (!task) goto abort_call;
2180
2181                         ret = -EPERM;
2182
2183                         if (pfm_bad_permissions(task)) goto abort_call;
2184
2185                         if (PFM_CMD_CHK(cmd)) {
2186                                 ret = check_task_state(task);
2187                                 if (ret != 0) goto abort_call;
2188                         }
2189                         ctx = task->thread.pfm_context;
2190                 }
2191         } 
2192
2193         if (PFM_CMD_USE_CTX(cmd)) {
2194                 ret = -EINVAL;
2195                if (ctx == NULL) {
2196                         DBprintk(("no context for task %d\n", task->pid));
2197                         goto abort_call;
2198                }
2199                ret = -EPERM;
2200                /*
2201                 * we only grant access to the context if:
2202                 *       - the caller is the creator of the context (ctx_owner)
2203                 *  OR   - the context is attached to the caller AND The context IS NOT 
2204                 *         in protected mode
2205                 */
2206                if (ctx->ctx_owner != current && (ctx->ctx_fl_protected || task != current)) {
2207                                 DBprintk(("context protected, no access for [%d]\n", task->pid));
2208                                 goto abort_call;
2209                }
2210         }
2211
2212         ret = (*pfm_cmd_tab[PFM_CMD_IDX(cmd)].cmd_func)(task, ctx, arg, count, regs);
2213
2214 abort_call:
2215         if (task != current) read_unlock(&tasklist_lock);
2216
2217         return ret;
2218 }
2219
2220 void
2221 pfm_ovfl_block_reset (void)
2222 {
2223         struct thread_struct *th = &current->thread;
2224         pfm_context_t *ctx = current->thread.pfm_context;
2225         int ret;
2226
2227         /*
2228          * clear the flag, to make sure we won't get here
2229          * again
2230          */
2231         th->pfm_ovfl_block_reset = 0;
2232
2233         /*
2234          * do some sanity checks first
2235          */
2236         if (!ctx) {
2237                 printk("perfmon: [%d] has no PFM context\n", current->pid);
2238                 return;
2239         }
2240
2241         if (CTX_OVFL_NOBLOCK(ctx)) goto non_blocking;
2242
2243         DBprintk(("[%d] before sleeping\n", current->pid));
2244
2245         /*
2246          * may go through without blocking on SMP systems
2247          * if restart has been received already by the time we call down()
2248          */
2249         ret = down_interruptible(&ctx->ctx_restart_sem);
2250
2251         DBprintk(("[%d] after sleeping ret=%d\n", current->pid, ret));
2252
2253         /*
2254          * in case of interruption of down() we don't restart anything
2255          */
2256         if (ret >= 0) {
2257
2258 non_blocking:
2259                 /* we reactivate on context switch */
2260                 ctx->ctx_fl_frozen = 0;
2261                 /*
2262                  * the ovfl_sem is cleared by the restart task and this is safe because we always
2263                  * use the local reference
2264                  */
2265
2266                 pfm_reset_regs(ctx, ctx->ctx_ovfl_regs, PFM_RELOAD_LONG_RESET);
2267
2268                 ctx->ctx_ovfl_regs[0] = 0UL;
2269
2270                 /*
2271                  * Unlock sampling buffer and reset index atomically
2272                  * XXX: not really needed when blocking
2273                  */
2274                 if (CTX_HAS_SMPL(ctx)) {
2275                         ctx->ctx_psb->psb_hdr->hdr_count = 0;
2276                         ctx->ctx_psb->psb_index = 0;
2277                 }
2278
2279                 ia64_set_pmc(0, 0);
2280                 ia64_srlz_d();
2281
2282                 /* state restored, can go back to work (user mode) */
2283         }
2284 }
2285
2286 /*
2287  * This function will record an entry in the sampling if it is not full already.
2288  * Return:
2289  *      0 : buffer is not full (did not BECOME full: still space or was already full)
2290  *      1 : buffer is full (recorded the last entry)
2291  */
2292 static int
2293 pfm_record_sample(struct task_struct *task, pfm_context_t *ctx, unsigned long ovfl_mask, struct pt_regs *regs)
2294 {
2295         pfm_smpl_buffer_desc_t *psb = ctx->ctx_psb;
2296         unsigned long *e, m, idx;
2297         perfmon_smpl_entry_t *h;
2298         int j;
2299
2300
2301 pfm_recorded_samples_count++;
2302         idx = ia64_fetch_and_add(1, &psb->psb_index);
2303         DBprintk(("recording index=%ld entries=%ld\n", idx-1, psb->psb_entries));
2304
2305         /*
2306         * XXX: there is a small chance that we could run out on index before resetting
2307         * but index is unsigned long, so it will take some time.....
2308         * We use > instead of == because fetch_and_add() is off by one (see below)
2309         *
2310         * This case can happen in non-blocking mode or with multiple processes.
2311         * For non-blocking, we need to reload and continue.
2312          */
2313         if (idx > psb->psb_entries) return 0;
2314
2315         /* first entry is really entry 0, not 1 caused by fetch_and_add */
2316         idx--;
2317
2318         h = (perfmon_smpl_entry_t *)(((char *)psb->psb_addr) + idx*(psb->psb_entry_size));
2319
2320         /*
2321          * initialize entry header
2322          */
2323         h->pid  = task->pid;
2324         h->cpu  = smp_processor_id();
2325         h->rate = 0; /* XXX: add the sampling rate used here */
2326         h->ip   = regs ? regs->cr_iip : 0x0;    /* where did the fault happened */
2327         h->regs = ovfl_mask;                    /* which registers overflowed */
2328
2329         /* guaranteed to monotonically increase on each cpu */
2330         h->stamp  = pfm_get_stamp();
2331         h->period = 0UL; /* not yet used */
2332
2333         /* position for first pmd */
2334         e = (unsigned long *)(h+1);
2335
2336         /*
2337          * selectively store PMDs in increasing index number
2338          */
2339         m = ctx->ctx_smpl_regs[0];
2340         for (j=0; m; m >>=1, j++) {
2341
2342                 if ((m & 0x1) == 0) continue;
2343
2344                 if (PMD_IS_COUNTING(j)) {
2345                         *e  =  pfm_read_soft_counter(ctx, j);
2346                         /* check if this pmd overflowed as well */
2347                         *e +=  ovfl_mask & (1UL<<j) ? 1 + pmu_conf.perf_ovfl_val : 0;
2348                 } else {
2349                         *e = ia64_get_pmd(j); /* slow */
2350                 }
2351                 DBprintk(("e=%p pmd%d =0x%lx\n", (void *)e, j, *e));
2352                 e++;
2353         }
2354         /*
2355          * make the new entry visible to user, needs to be atomic
2356          */
2357         ia64_fetch_and_add(1, &psb->psb_hdr->hdr_count);
2358
2359         DBprintk(("index=%ld entries=%ld hdr_count=%ld\n", 
2360                                 idx, psb->psb_entries, psb->psb_hdr->hdr_count));
2361         /* 
2362          * sampling buffer full ? 
2363          */
2364         if (idx == (psb->psb_entries-1)) {
2365                 DBprintk(("sampling buffer full\n"));
2366                 /*
2367                  * XXX: must reset buffer in blocking mode and lost notified
2368                  */
2369                 return 1;
2370         }
2371         return 0;
2372 }
2373
2374 /*
2375  * main overflow processing routine.
2376  * it can be called from the interrupt path or explicitely during the context switch code
2377  * Return:
2378  *      new value of pmc[0]. if 0x0 then unfreeze, else keep frozen
2379  */
2380 static unsigned long
2381 pfm_overflow_handler(struct task_struct *task, u64 pmc0, struct pt_regs *regs)
2382 {
2383         unsigned long mask;
2384         struct thread_struct *t;
2385         pfm_context_t *ctx;
2386         unsigned long old_val;
2387         unsigned long ovfl_notify = 0UL, ovfl_pmds = 0UL;
2388         int i;
2389         int my_cpu = smp_processor_id();
2390         int ret = 1;
2391         struct siginfo si;
2392         /*
2393          * It is never safe to access the task for which the overflow interrupt is destinated
2394          * using the current variable as the interrupt may occur in the middle of a context switch
2395          * where current does not hold the task that is running yet.
2396          *
2397          * For monitoring, however, we do need to get access to the task which caused the overflow
2398          * to account for overflow on the counters.
2399          *
2400          * We accomplish this by maintaining a current owner of the PMU per CPU. During context
2401          * switch the ownership is changed in a way such that the reflected owner is always the
2402          * valid one, i.e. the one that caused the interrupt.
2403          */
2404
2405         if (task == NULL) {
2406                 DBprintk(("owners[%d]=NULL\n", my_cpu));
2407                 return 0x1;
2408         }
2409         t   = &task->thread;
2410         ctx = task->thread.pfm_context;
2411
2412         if (!ctx) {
2413                 printk("perfmon: Spurious overflow interrupt: process %d has no PFM context\n", 
2414                         task->pid);
2415                 return 0;
2416         }
2417
2418         /*
2419          * XXX: debug test
2420          * Don't think this could happen given upfront tests
2421          */
2422         if ((t->flags & IA64_THREAD_PM_VALID) == 0 && ctx->ctx_fl_system == 0) {
2423                 printk("perfmon: Spurious overflow interrupt: process %d not using perfmon\n", 
2424                         task->pid);
2425                 return 0x1;
2426         }
2427         /*
2428          * sanity test. Should never happen
2429          */
2430         if ((pmc0 & 0x1) == 0) {
2431                 printk("perfmon: pid %d pmc0=0x%lx assumption error for freeze bit\n", 
2432                         task->pid, pmc0);
2433                 return 0x0;
2434         }
2435
2436         mask = pmc0 >> PMU_FIRST_COUNTER;
2437
2438         DBprintk(("pmc0=0x%lx pid=%d iip=0x%lx, %s"
2439                   " mode used_pmds=0x%lx save_pmcs=0x%lx reload_pmcs=0x%lx\n", 
2440                         pmc0, task->pid, (regs ? regs->cr_iip : 0), 
2441                         CTX_OVFL_NOBLOCK(ctx) ? "nonblocking" : "blocking",
2442                         ctx->ctx_used_pmds[0],
2443                         ctx->ctx_saved_pmcs[0],
2444                         ctx->ctx_reload_pmcs[0]));
2445
2446         /*
2447          * First we update the virtual counters
2448          */
2449         for (i = PMU_FIRST_COUNTER; mask ; i++, mask >>= 1) {
2450
2451                 /* skip pmd which did not overflow */
2452                 if ((mask & 0x1) == 0) continue;
2453
2454                 DBprintk(("PMD[%d] overflowed hw_pmd=0x%lx soft_pmd=0x%lx\n", 
2455                           i, ia64_get_pmd(i), ctx->ctx_soft_pmds[i].val));
2456
2457                 /*
2458                  * Because we sometimes (EARS/BTB) reset to a specific value, we cannot simply use
2459                  * val to count the number of times we overflowed. Otherwise we would loose the 
2460                  * current value in the PMD (which can be >0). So to make sure we don't loose
2461                  * the residual counts we set val to contain full 64bits value of the counter.
2462                  */
2463                 old_val = ctx->ctx_soft_pmds[i].val;
2464                 ctx->ctx_soft_pmds[i].val = 1 + pmu_conf.perf_ovfl_val + pfm_read_soft_counter(ctx, i);
2465
2466
2467                 DBprintk(("soft_pmd[%d].val=0x%lx old_val=0x%lx pmd=0x%lx\n", 
2468                           i, ctx->ctx_soft_pmds[i].val, old_val, 
2469                           ia64_get_pmd(i) & pmu_conf.perf_ovfl_val));
2470
2471                 /*
2472                  * now that we have extracted the hardware counter, we can clear it to ensure
2473                  * that a subsequent PFM_READ_PMDS will not include it again.
2474                  */
2475                 ia64_set_pmd(i, 0UL);
2476
2477                 /*
2478                  * check for overflow condition
2479                  */
2480                 if (old_val > ctx->ctx_soft_pmds[i].val) {
2481
2482                         ovfl_pmds |= 1UL << i;
2483
2484                         DBprintk(("soft_pmd[%d] overflowed flags=0x%x, ovfl=0x%lx\n", i, ctx->ctx_soft_pmds[i].flags, ovfl_pmds));
2485
2486                         if (PMC_OVFL_NOTIFY(ctx, i)) {
2487                                 ovfl_notify |= 1UL << i;
2488                         }
2489                 }
2490         }
2491
2492         /*
2493          * check for sampling buffer
2494          *
2495          * if present, record sample. We propagate notification ONLY when buffer
2496          * becomes full.
2497          */
2498         if(CTX_HAS_SMPL(ctx)) {
2499                 ret = pfm_record_sample(task, ctx, ovfl_pmds, regs);
2500                 if (ret == 1) {
2501                         /*
2502                          * Sampling buffer became full
2503                          * If no notication was requested, then we reset buffer index
2504                          * and reset registers (done below) and resume.
2505                          * If notification requested, then defer reset until pfm_restart()
2506                          */
2507                         if (ovfl_notify == 0UL) {
2508                                 ctx->ctx_psb->psb_hdr->hdr_count = 0UL;
2509                                 ctx->ctx_psb->psb_index          = 0UL;
2510                         }
2511                 } else {
2512                         /*
2513                          * sample recorded in buffer, no need to notify user
2514                          */
2515                         ovfl_notify = 0UL;
2516                 }
2517         }
2518
2519         /*
2520          * No overflow requiring a user level notification
2521          */
2522         if (ovfl_notify == 0UL) {
2523                 pfm_reset_regs(ctx, &ovfl_pmds, PFM_RELOAD_SHORT_RESET);
2524                 return 0x0;
2525         }
2526
2527         /* 
2528          * keep track of what to reset when unblocking 
2529          */
2530         ctx->ctx_ovfl_regs[0]  = ovfl_pmds; 
2531
2532         /*
2533          * we have come to this point because there was an overflow and that notification
2534          * was requested. The notify_task may have disappeared, in which case notify_task
2535          * is NULL.
2536          */
2537         if (ctx->ctx_notify_task) {
2538
2539                 si.si_errno    = 0;
2540                 si.si_addr     = NULL;
2541                 si.si_pid      = task->pid; /* who is sending */
2542
2543                 si.si_signo    = SIGPROF;
2544                 si.si_code     = PROF_OVFL; /* indicates a perfmon SIGPROF signal */
2545                 /*
2546                  * Shift the bitvector such that the user sees bit 4 for PMD4 and so on.
2547                  * We only use smpl_ovfl[0] for now. It should be fine for quite a while
2548                  * until we have more than 61 PMD available.
2549                  */
2550                 si.si_pfm_ovfl[0] = ovfl_notify;
2551         
2552                 /*
2553                  * when the target of the signal is not ourself, we have to be more
2554                  * careful. The notify_task may being cleared by the target task itself
2555                  * in release_thread(). We must ensure mutual exclusion here such that
2556                  * the signal is delivered (even to a dying task) safely.
2557                  */
2558
2559                 if (ctx->ctx_notify_task != current) {
2560                         /*
2561                          * grab the notification lock for this task
2562                          * This guarantees that the sequence: test + send_signal
2563                          * is atomic with regards to the ctx_notify_task field.
2564                          *
2565                          * We need a spinlock and not just an atomic variable for this.
2566                          *
2567                          */
2568                         spin_lock(&ctx->ctx_lock);
2569
2570                         /*
2571                          * now notify_task cannot be modified until we're done
2572                          * if NULL, they it got modified while we were in the handler
2573                          */
2574                         if (ctx->ctx_notify_task == NULL) {
2575
2576                                 spin_unlock(&ctx->ctx_lock);
2577
2578                                 /*
2579                                  * If we've lost the notified task, then we will run
2580                                  * to completion wbut keep the PMU frozen. Results
2581                                  * will be incorrect anyway. We do not kill task
2582                                  * to leave it possible to attach perfmon context
2583                                  * to already running task.
2584                                  */
2585                                 goto lost_notify;
2586                         }
2587                         /*
2588                          * required by send_sig_info() to make sure the target
2589                          * task does not disappear on us.
2590                          */
2591                         read_lock(&tasklist_lock);
2592                 }
2593                 /*
2594                  * in this case, we don't stop the task, we let it go on. It will
2595                  * necessarily go to the signal handler (if any) when it goes back to
2596                  * user mode.
2597                  */
2598                 DBprintk(("[%d] sending notification to [%d]\n", 
2599                           task->pid, ctx->ctx_notify_task->pid));
2600
2601
2602                 /* 
2603                  * this call is safe in an interrupt handler, so does read_lock() on tasklist_lock
2604                  */
2605                 ret = send_sig_info(SIGPROF, &si, ctx->ctx_notify_task);
2606                 if (ret != 0) 
2607                         printk("send_sig_info(process %d, SIGPROF)=%d\n",  
2608                                ctx->ctx_notify_task->pid, ret);
2609                 /*
2610                  * now undo the protections in order
2611                  */
2612                 if (ctx->ctx_notify_task != current) {
2613                         read_unlock(&tasklist_lock);
2614                         spin_unlock(&ctx->ctx_lock);
2615                 }
2616
2617                 /*
2618                  * if we block set the pfm_must_block bit
2619                  * when in block mode, we can effectively block only when the notified
2620                  * task is not self, otherwise we would deadlock. 
2621                  * in this configuration, the notification is sent, the task will not 
2622                  * block on the way back to user mode, but the PMU will be kept frozen
2623                  * until PFM_RESTART.
2624                  * Note that here there is still a race condition with notify_task
2625                  * possibly being nullified behind our back, but this is fine because
2626                  * it can only be changed to NULL which by construction, can only be
2627                  * done when notify_task != current. So if it was already different
2628                  * before, changing it to NULL will still maintain this invariant.
2629                  * Of course, when it is equal to current it cannot change at this point.
2630                  */
2631                 DBprintk(("block=%d notify [%d] current [%d]\n", 
2632                         ctx->ctx_fl_block,
2633                         ctx->ctx_notify_task ? ctx->ctx_notify_task->pid: -1, 
2634                         current->pid ));
2635
2636                 if (!CTX_OVFL_NOBLOCK(ctx) && ctx->ctx_notify_task != task) {
2637                         t->pfm_ovfl_block_reset = 1; /* will cause blocking */
2638                 }
2639         } else {
2640 lost_notify: /* XXX: more to do here, to convert to non-blocking (reset values) */
2641
2642                 DBprintk(("notification task has disappeared !\n"));
2643                 /*
2644                  * for a non-blocking context, we make sure we do not fall into the 
2645                  * pfm_overflow_notify() trap. Also in the case of a blocking context with lost 
2646                  * notify process, then we do not want to block either (even though it is 
2647                  * interruptible). In this case, the PMU will be kept frozen and the process will 
2648                  * run to completion without monitoring enabled.
2649                  *
2650                  * Of course, we cannot loose notify process when self-monitoring.
2651                  */
2652                 t->pfm_ovfl_block_reset = 0; 
2653
2654         }
2655         /*
2656          * If notification was successful, then we rely on the pfm_restart()
2657          * call to unfreeze and reset (in both blocking or non-blocking mode).
2658          *
2659          * If notification failed, then we will keep the PMU frozen and run
2660          * the task to completion
2661          */
2662         ctx->ctx_fl_frozen = 1;
2663
2664         DBprintk(("reload pmc0=0x%x must_block=%ld\n",
2665                                 ctx->ctx_fl_frozen ? 0x1 : 0x0, t->pfm_ovfl_block_reset));
2666
2667         return ctx->ctx_fl_frozen ? 0x1 : 0x0;
2668 }
2669
2670 static void
2671 perfmon_interrupt (int irq, void *arg, struct pt_regs *regs)
2672 {
2673         u64 pmc0;
2674         struct task_struct *task;
2675
2676         pfm_ovfl_intr_count++;
2677
2678         /* 
2679          * srlz.d done before arriving here
2680          *
2681          * This is slow
2682          */
2683         pmc0 = ia64_get_pmc(0); 
2684
2685         /*
2686          * if we have some pending bits set
2687          * assumes : if any PM[0].bit[63-1] is set, then PMC[0].fr = 1
2688          */
2689         if ((pmc0 & ~0x1UL)!=0UL && (task=PMU_OWNER())!= NULL) {
2690
2691                 /* 
2692                  * assumes, PMC[0].fr = 1 at this point 
2693                  *
2694                  * XXX: change protype to pass &pmc0
2695                  */
2696                 pmc0 = pfm_overflow_handler(task, pmc0, regs);
2697
2698                 /* we never explicitely freeze PMU here */
2699                 if (pmc0 == 0) {
2700                         ia64_set_pmc(0, 0);
2701                         ia64_srlz_d();
2702                 }
2703         } else {
2704                 pfm_spurious_ovfl_intr_count++;
2705
2706                 DBprintk(("perfmon: Spurious PMU overflow interrupt on CPU%d: pmc0=0x%lx owner=%p\n", 
2707                         smp_processor_id(), pm