~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/oprofile/init.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * S390 Version
  3  *   Copyright IBM Corp. 2002, 2011
  4  *   Author(s): Thomas Spatzier (tspat@de.ibm.com)
  5  *   Author(s): Mahesh Salgaonkar (mahesh@linux.vnet.ibm.com)
  6  *   Author(s): Heinz Graalfs (graalfs@linux.vnet.ibm.com)
  7  *   Author(s): Andreas Krebbel (krebbel@linux.vnet.ibm.com)
  8  *
  9  * @remark Copyright 2002-2011 OProfile authors
 10  */
 11 
 12 #include <linux/oprofile.h>
 13 #include <linux/perf_event.h>
 14 #include <linux/init.h>
 15 #include <linux/errno.h>
 16 #include <linux/fs.h>
 17 #include <linux/module.h>
 18 #include <asm/processor.h>
 19 
 20 #include "../../../drivers/oprofile/oprof.h"
 21 
 22 extern void s390_backtrace(struct pt_regs * const regs, unsigned int depth);
 23 
 24 #include "hwsampler.h"
 25 #include "op_counter.h"
 26 
 27 #define DEFAULT_INTERVAL        4127518
 28 
 29 #define DEFAULT_SDBT_BLOCKS     1
 30 #define DEFAULT_SDB_BLOCKS      511
 31 
 32 static unsigned long oprofile_hw_interval = DEFAULT_INTERVAL;
 33 static unsigned long oprofile_min_interval;
 34 static unsigned long oprofile_max_interval;
 35 
 36 static unsigned long oprofile_sdbt_blocks = DEFAULT_SDBT_BLOCKS;
 37 static unsigned long oprofile_sdb_blocks = DEFAULT_SDB_BLOCKS;
 38 
 39 static int hwsampler_enabled;
 40 static int hwsampler_running;   /* start_mutex must be held to change */
 41 static int hwsampler_available;
 42 
 43 static struct oprofile_operations timer_ops;
 44 
 45 struct op_counter_config counter_config;
 46 
 47 enum __force_cpu_type {
 48         reserved = 0,           /* do not force */
 49         timer,
 50 };
 51 static int force_cpu_type;
 52 
 53 static int set_cpu_type(const char *str, struct kernel_param *kp)
 54 {
 55         if (!strcmp(str, "timer")) {
 56                 force_cpu_type = timer;
 57                 printk(KERN_INFO "oprofile: forcing timer to be returned "
 58                                  "as cpu type\n");
 59         } else {
 60                 force_cpu_type = 0;
 61         }
 62 
 63         return 0;
 64 }
 65 module_param_call(cpu_type, set_cpu_type, NULL, NULL, 0);
 66 MODULE_PARM_DESC(cpu_type, "Force legacy basic mode sampling"
 67                            "(report cpu_type \"timer\"");
 68 
 69 static int __oprofile_hwsampler_start(void)
 70 {
 71         int retval;
 72 
 73         retval = hwsampler_allocate(oprofile_sdbt_blocks, oprofile_sdb_blocks);
 74         if (retval)
 75                 return retval;
 76 
 77         retval = hwsampler_start_all(oprofile_hw_interval);
 78         if (retval)
 79                 hwsampler_deallocate();
 80 
 81         return retval;
 82 }
 83 
 84 static int oprofile_hwsampler_start(void)
 85 {
 86         int retval;
 87 
 88         hwsampler_running = hwsampler_enabled;
 89 
 90         if (!hwsampler_running)
 91                 return timer_ops.start();
 92 
 93         retval = perf_reserve_sampling();
 94         if (retval)
 95                 return retval;
 96 
 97         retval = __oprofile_hwsampler_start();
 98         if (retval)
 99                 perf_release_sampling();
100 
101         return retval;
102 }
103 
104 static void oprofile_hwsampler_stop(void)
105 {
106         if (!hwsampler_running) {
107                 timer_ops.stop();
108                 return;
109         }
110 
111         hwsampler_stop_all();
112         hwsampler_deallocate();
113         perf_release_sampling();
114         return;
115 }
116 
117 /*
118  * File ops used for:
119  * /dev/oprofile/0/enabled
120  * /dev/oprofile/hwsampling/hwsampler  (cpu_type = timer)
121  */
122 
123 static ssize_t hwsampler_read(struct file *file, char __user *buf,
124                 size_t count, loff_t *offset)
125 {
126         return oprofilefs_ulong_to_user(hwsampler_enabled, buf, count, offset);
127 }
128 
129 static ssize_t hwsampler_write(struct file *file, char const __user *buf,
130                 size_t count, loff_t *offset)
131 {
132         unsigned long val;
133         int retval;
134 
135         if (*offset)
136                 return -EINVAL;
137 
138         retval = oprofilefs_ulong_from_user(&val, buf, count);
139         if (retval <= 0)
140                 return retval;
141 
142         if (val != 0 && val != 1)
143                 return -EINVAL;
144 
145         if (oprofile_started)
146                 /*
147                  * save to do without locking as we set
148                  * hwsampler_running in start() when start_mutex is
149                  * held
150                  */
151                 return -EBUSY;
152 
153         hwsampler_enabled = val;
154 
155         return count;
156 }
157 
158 static const struct file_operations hwsampler_fops = {
159         .read           = hwsampler_read,
160         .write          = hwsampler_write,
161 };
162 
163 /*
164  * File ops used for:
165  * /dev/oprofile/0/count
166  * /dev/oprofile/hwsampling/hw_interval  (cpu_type = timer)
167  *
168  * Make sure that the value is within the hardware range.
169  */
170 
171 static ssize_t hw_interval_read(struct file *file, char __user *buf,
172                                 size_t count, loff_t *offset)
173 {
174         return oprofilefs_ulong_to_user(oprofile_hw_interval, buf,
175                                         count, offset);
176 }
177 
178 static ssize_t hw_interval_write(struct file *file, char const __user *buf,
179                                  size_t count, loff_t *offset)
180 {
181         unsigned long val;
182         int retval;
183 
184         if (*offset)
185                 return -EINVAL;
186         retval = oprofilefs_ulong_from_user(&val, buf, count);
187         if (retval <= 0)
188                 return retval;
189         if (val < oprofile_min_interval)
190                 oprofile_hw_interval = oprofile_min_interval;
191         else if (val > oprofile_max_interval)
192                 oprofile_hw_interval = oprofile_max_interval;
193         else
194                 oprofile_hw_interval = val;
195 
196         return count;
197 }
198 
199 static const struct file_operations hw_interval_fops = {
200         .read           = hw_interval_read,
201         .write          = hw_interval_write,
202 };
203 
204 /*
205  * File ops used for:
206  * /dev/oprofile/0/event
207  * Only a single event with number 0 is supported with this counter.
208  *
209  * /dev/oprofile/0/unit_mask
210  * This is a dummy file needed by the user space tools.
211  * No value other than 0 is accepted or returned.
212  */
213 
214 static ssize_t hwsampler_zero_read(struct file *file, char __user *buf,
215                                     size_t count, loff_t *offset)
216 {
217         return oprofilefs_ulong_to_user(0, buf, count, offset);
218 }
219 
220 static ssize_t hwsampler_zero_write(struct file *file, char const __user *buf,
221                                      size_t count, loff_t *offset)
222 {
223         unsigned long val;
224         int retval;
225 
226         if (*offset)
227                 return -EINVAL;
228 
229         retval = oprofilefs_ulong_from_user(&val, buf, count);
230         if (retval <= 0)
231                 return retval;
232         if (val != 0)
233                 return -EINVAL;
234         return count;
235 }
236 
237 static const struct file_operations zero_fops = {
238         .read           = hwsampler_zero_read,
239         .write          = hwsampler_zero_write,
240 };
241 
242 /* /dev/oprofile/0/kernel file ops.  */
243 
244 static ssize_t hwsampler_kernel_read(struct file *file, char __user *buf,
245                                      size_t count, loff_t *offset)
246 {
247         return oprofilefs_ulong_to_user(counter_config.kernel,
248                                         buf, count, offset);
249 }
250 
251 static ssize_t hwsampler_kernel_write(struct file *file, char const __user *buf,
252                                       size_t count, loff_t *offset)
253 {
254         unsigned long val;
255         int retval;
256 
257         if (*offset)
258                 return -EINVAL;
259 
260         retval = oprofilefs_ulong_from_user(&val, buf, count);
261         if (retval <= 0)
262                 return retval;
263 
264         if (val != 0 && val != 1)
265                 return -EINVAL;
266 
267         counter_config.kernel = val;
268 
269         return count;
270 }
271 
272 static const struct file_operations kernel_fops = {
273         .read           = hwsampler_kernel_read,
274         .write          = hwsampler_kernel_write,
275 };
276 
277 /* /dev/oprofile/0/user file ops. */
278 
279 static ssize_t hwsampler_user_read(struct file *file, char __user *buf,
280                                    size_t count, loff_t *offset)
281 {
282         return oprofilefs_ulong_to_user(counter_config.user,
283                                         buf, count, offset);
284 }
285 
286 static ssize_t hwsampler_user_write(struct file *file, char const __user *buf,
287                                     size_t count, loff_t *offset)
288 {
289         unsigned long val;
290         int retval;
291 
292         if (*offset)
293                 return -EINVAL;
294 
295         retval = oprofilefs_ulong_from_user(&val, buf, count);
296         if (retval <= 0)
297                 return retval;
298 
299         if (val != 0 && val != 1)
300                 return -EINVAL;
301 
302         counter_config.user = val;
303 
304         return count;
305 }
306 
307 static const struct file_operations user_fops = {
308         .read           = hwsampler_user_read,
309         .write          = hwsampler_user_write,
310 };
311 
312 
313 /*
314  * File ops used for: /dev/oprofile/timer/enabled
315  * The value always has to be the inverted value of hwsampler_enabled. So
316  * no separate variable is created. That way we do not need locking.
317  */
318 
319 static ssize_t timer_enabled_read(struct file *file, char __user *buf,
320                                   size_t count, loff_t *offset)
321 {
322         return oprofilefs_ulong_to_user(!hwsampler_enabled, buf, count, offset);
323 }
324 
325 static ssize_t timer_enabled_write(struct file *file, char const __user *buf,
326                                    size_t count, loff_t *offset)
327 {
328         unsigned long val;
329         int retval;
330 
331         if (*offset)
332                 return -EINVAL;
333 
334         retval = oprofilefs_ulong_from_user(&val, buf, count);
335         if (retval <= 0)
336                 return retval;
337 
338         if (val != 0 && val != 1)
339                 return -EINVAL;
340 
341         /* Timer cannot be disabled without having hardware sampling.  */
342         if (val == 0 && !hwsampler_available)
343                 return -EINVAL;
344 
345         if (oprofile_started)
346                 /*
347                  * save to do without locking as we set
348                  * hwsampler_running in start() when start_mutex is
349                  * held
350                  */
351                 return -EBUSY;
352 
353         hwsampler_enabled = !val;
354 
355         return count;
356 }
357 
358 static const struct file_operations timer_enabled_fops = {
359         .read           = timer_enabled_read,
360         .write          = timer_enabled_write,
361 };
362 
363 
364 static int oprofile_create_hwsampling_files(struct dentry *root)
365 {
366         struct dentry *dir;
367 
368         dir = oprofilefs_mkdir(root, "timer");
369         if (!dir)
370                 return -EINVAL;
371 
372         oprofilefs_create_file(dir, "enabled", &timer_enabled_fops);
373 
374         if (!hwsampler_available)
375                 return 0;
376 
377         /* reinitialize default values */
378         hwsampler_enabled = 1;
379         counter_config.kernel = 1;
380         counter_config.user = 1;
381 
382         if (!force_cpu_type) {
383                 /*
384                  * Create the counter file system.  A single virtual
385                  * counter is created which can be used to
386                  * enable/disable hardware sampling dynamically from
387                  * user space.  The user space will configure a single
388                  * counter with a single event.  The value of 'event'
389                  * and 'unit_mask' are not evaluated by the kernel code
390                  * and can only be set to 0.
391                  */
392 
393                 dir = oprofilefs_mkdir(root, "");
394                 if (!dir)
395                         return -EINVAL;
396 
397                 oprofilefs_create_file(dir, "enabled", &hwsampler_fops);
398                 oprofilefs_create_file(dir, "event", &zero_fops);
399                 oprofilefs_create_file(dir, "count", &hw_interval_fops);
400                 oprofilefs_create_file(dir, "unit_mask", &zero_fops);
401                 oprofilefs_create_file(dir, "kernel", &kernel_fops);
402                 oprofilefs_create_file(dir, "user", &user_fops);
403                 oprofilefs_create_ulong(dir, "hw_sdbt_blocks",
404                                         &oprofile_sdbt_blocks);
405 
406         } else {
407                 /*
408                  * Hardware sampling can be used but the cpu_type is
409                  * forced to timer in order to deal with legacy user
410                  * space tools.  The /dev/oprofile/hwsampling fs is
411                  * provided in that case.
412                  */
413                 dir = oprofilefs_mkdir(root, "hwsampling");
414                 if (!dir)
415                         return -EINVAL;
416 
417                 oprofilefs_create_file(dir, "hwsampler",
418                                        &hwsampler_fops);
419                 oprofilefs_create_file(dir, "hw_interval",
420                                        &hw_interval_fops);
421                 oprofilefs_create_ro_ulong(dir, "hw_min_interval",
422                                            &oprofile_min_interval);
423                 oprofilefs_create_ro_ulong(dir, "hw_max_interval",
424                                            &oprofile_max_interval);
425                 oprofilefs_create_ulong(dir, "hw_sdbt_blocks",
426                                         &oprofile_sdbt_blocks);
427         }
428         return 0;
429 }
430 
431 static int oprofile_hwsampler_init(struct oprofile_operations *ops)
432 {
433         /*
434          * Initialize the timer mode infrastructure as well in order
435          * to be able to switch back dynamically.  oprofile_timer_init
436          * is not supposed to fail.
437          */
438         if (oprofile_timer_init(ops))
439                 BUG();
440 
441         memcpy(&timer_ops, ops, sizeof(timer_ops));
442         ops->create_files = oprofile_create_hwsampling_files;
443 
444         /*
445          * If the user space tools do not support newer cpu types,
446          * the force_cpu_type module parameter
447          * can be used to always return \"timer\" as cpu type.
448          */
449         if (force_cpu_type != timer) {
450                 struct cpuid id;
451 
452                 get_cpu_id (&id);
453 
454                 switch (id.machine) {
455                 case 0x2097: case 0x2098: ops->cpu_type = "s390/z10"; break;
456                 case 0x2817: case 0x2818: ops->cpu_type = "s390/z196"; break;
457                 case 0x2827: case 0x2828: ops->cpu_type = "s390/zEC12"; break;
458                 default: return -ENODEV;
459                 }
460         }
461 
462         if (hwsampler_setup())
463                 return -ENODEV;
464 
465         /*
466          * Query the range for the sampling interval from the
467          * hardware.
468          */
469         oprofile_min_interval = hwsampler_query_min_interval();
470         if (oprofile_min_interval == 0)
471                 return -ENODEV;
472         oprofile_max_interval = hwsampler_query_max_interval();
473         if (oprofile_max_interval == 0)
474                 return -ENODEV;
475 
476         /* The initial value should be sane */
477         if (oprofile_hw_interval < oprofile_min_interval)
478                 oprofile_hw_interval = oprofile_min_interval;
479         if (oprofile_hw_interval > oprofile_max_interval)
480                 oprofile_hw_interval = oprofile_max_interval;
481 
482         printk(KERN_INFO "oprofile: System z hardware sampling "
483                "facility found.\n");
484 
485         ops->start = oprofile_hwsampler_start;
486         ops->stop = oprofile_hwsampler_stop;
487 
488         return 0;
489 }
490 
491 static void oprofile_hwsampler_exit(void)
492 {
493         hwsampler_shutdown();
494 }
495 
496 int __init oprofile_arch_init(struct oprofile_operations *ops)
497 {
498         ops->backtrace = s390_backtrace;
499 
500         /*
501          * -ENODEV is not reported to the caller.  The module itself
502          * will use the timer mode sampling as fallback and this is
503          * always available.
504          */
505         hwsampler_available = oprofile_hwsampler_init(ops) == 0;
506 
507         return 0;
508 }
509 
510 void oprofile_arch_exit(void)
511 {
512         oprofile_hwsampler_exit();
513 }
514 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp