pax_global_header00006660000000000000000000000064136145035750014523gustar00rootroot0000000000000052 comment=49b8cdf64f4b8b64e726f25d641e368dfae678a8 perf-tools-unstable-1.0.1~20200130+git49b8cdf/000077500000000000000000000000001361450357500203005ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/LICENSE000066400000000000000000000431511361450357500213110ustar00rootroot00000000000000GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. {description} Copyright (C) {year} {fullname} This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. {signature of Ty Coon}, 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License.perf-tools-unstable-1.0.1~20200130+git49b8cdf/README.md000066400000000000000000000276401361450357500215700ustar00rootroot00000000000000perf-tools ========== A miscellaneous collection of in-development and unsupported performance analysis tools for Linux ftrace and perf_events (aka the "perf" command). Both ftrace and perf are core Linux tracing tools, included in the kernel source. Your system probably has ftrace already, and perf is often just a package add (see Prerequisites). These tools are designed to be easy to install (fewest dependencies), provide advanced performance observability, and be simple to use: do one thing and do it well. This collection was created by Brendan Gregg (author of the DTraceToolkit). Many of these tools employ workarounds so that functionality is possible on existing Linux kernels. Because of this, many tools have caveats (see man pages), and their implementation should be considered a placeholder until future kernel features, or new tracing subsystems, are added. These are intended for Linux 3.2 and newer kernels. For Linux 2.6.x, see Warnings. ## Presentation These tools were introduced in the USENIX LISA 2014 presentation: Linux Performance Analysis: New Tools and Old Secrets - slides: http://www.slideshare.net/brendangregg/linux-performance-analysis-new-tools-and-old-secrets - video: https://www.usenix.org/conference/lisa14/conference-program/presentation/gregg ## Contents
Using ftrace: - [iosnoop](iosnoop): trace disk I/O with details including latency. [Examples](examples/iosnoop_example.txt). - [iolatency](iolatency): summarize disk I/O latency as a histogram. [Examples](examples/iolatency_example.txt). - [execsnoop](execsnoop): trace process exec() with command line argument details. [Examples](examples/execsnoop_example.txt). - [opensnoop](opensnoop): trace open() syscalls showing filenames. [Examples](examples/opensnoop_example.txt). - [killsnoop](killsnoop): trace kill() signals showing process and signal details. [Examples](examples/killsnoop_example.txt). - fs/[cachestat](fs/cachestat): basic cache hit/miss statistics for the Linux page cache. [Examples](examples/cachestat_example.txt). - net/[tcpretrans](net/tcpretrans): show TCP retransmits, with address and other details. [Examples](examples/tcpretrans_example.txt). - system/[tpoint](system/tpoint): trace a given tracepoint. [Examples](examples/tpoint_example.txt). - kernel/[funccount](kernel/funccount): count kernel function calls, matching a string with wildcards. [Examples](examples/funccount_example.txt). - kernel/[functrace](kernel/functrace): trace kernel function calls, matching a string with wildcards. [Examples](examples/functrace_example.txt). - kernel/[funcslower](kernel/funcslower): trace kernel functions slower than a threshold. [Examples](examples/funcslower_example.txt). - kernel/[funcgraph](kernel/funcgraph): trace a graph of kernel function calls, showing children and times. [Examples](examples/funcgraph_example.txt). - kernel/[kprobe](kernel/kprobe): dynamically trace a kernel function call or its return, with variables. [Examples](examples/kprobe_example.txt). - user/[uprobe](user/uprobe): dynamically trace a user-level function call or its return, with variables. [Examples](examples/uprobe_example.txt). - tools/[reset-ftrace](tools/reset-ftrace): reset ftrace state if needed. [Examples](examples/reset-ftrace_example.txt). Using perf_events: - misc/[perf-stat-hist](misc/perf-stat-hist): power-of aggregations for tracepoint variables. [Examples](examples/perf-stat-hist_example.txt). - [syscount](syscount): count syscalls by syscall or process. [Examples](examples/syscount_example.txt). - disk/[bitesize](disk/bitesize): histogram summary of disk I/O size. [Examples](examples/bitesize_example.txt). Using eBPF: - As a preview of things to come, see the bcc tracing [Tools section](https://github.com/iovisor/bcc/blob/master/README.md#tracing). These use [bcc](https://github.com/iovisor/bcc), a front end for using [eBPF](http://www.brendangregg.com/blog/2015-05-15/ebpf-one-small-step.html). bcc+eBPF will allow some of these tools to be rewritten and improved, and additional tools to be created. ## Screenshots Showing new processes and arguments: 
# ./execsnoop 
Tracing exec()s. Ctrl-C to end.
   PID   PPID ARGS
 22898  22004 man ls
 22905  22898 preconv -e UTF-8
 22908  22898 pager -s
 22907  22898 nroff -mandoc -rLL=164n -rLT=164n -Tutf8
 22906  22898 tbl
 22911  22910 locale charmap
 22912  22907 groff -mtty-char -Tutf8 -mandoc -rLL=164n -rLT=164n
 22913  22912 troff -mtty-char -mandoc -rLL=164n -rLT=164n -Tutf8
 22914  22912 grotty
Measuring block device I/O latency from queue insert to completion: 
# ./iolatency -Q
Tracing block I/O. Output every 1 seconds. Ctrl-C to end.

  >=(ms) .. <(ms)   : I/O      |Distribution                          |
       0 -> 1       : 1913     |######################################|
       1 -> 2       : 438      |#########                             |
       2 -> 4       : 100      |##                                    |
       4 -> 8       : 145      |###                                   |
       8 -> 16      : 43       |#                                     |
      16 -> 32      : 43       |#                                     |
      32 -> 64      : 1        |#                                     |

[...]
Tracing the block:block_rq_insert tracepoint, with kernel stack traces, and only for reads: 
# ./tpoint -s block:block_rq_insert 'rwbs ~ "*R*"'
   cksum-11908 [000] d... 7269839.919098: block_rq_insert: 202,1 R 0 () 736560 + 136 [cksum]
   cksum-11908 [000] d... 7269839.919107: 
 => __elv_add_request
 => blk_flush_plug_list
 => blk_finish_plug
 => __do_page_cache_readahead
 => ondemand_readahead
 => page_cache_async_readahead
 => generic_file_read_iter
 => new_sync_read
 => vfs_read
 => SyS_read
 => system_call_fastpath

[...]
Count kernel function calls beginning with "bio_", summarize every second: 
# ./funccount -i 1 'bio_*'
Tracing "bio_*"... Ctrl-C to end.

FUNC                              COUNT
bio_attempt_back_merge               26
bio_get_nr_vecs                     361
bio_alloc                           536
bio_alloc_bioset                    536
bio_endio                           536
bio_free                            536
bio_fs_destructor                   536
bio_init                            536
bio_integrity_enabled               536
bio_put                             729
bio_add_page                       1004

[...]
There are many more examples in the [examples](examples) directory. Also see the [man pages](man/man8). ## Prerequisites The intent is as few as possible. Eg, a Linux 3.2 server without debuginfo. See the tool man page for specifics. ### ftrace FTRACE configured in the kernel. You may already have this configured and available in your kernel version, as FTRACE was first added in 2.6.27. This requires CONFIG_FTRACE and other FTRACE options depending on the tool. Some tools (eg, funccount) require CONFIG_FUNCTION_PROFILER. ### perf_events Requires the "perf" command to be installed. This is in the linux-tools-common package. After installing that, perf may tell you to install an additional linux-tools package (linux-tools-_kernel_version_). perf can also be built under tools/perf in the kernel source. See [perf_events Prerequisites](http://www.brendangregg.com/perf.html#Prerequisites) for more details about getting perf_events to work fully. ### debugfs Requires a kernel with CONFIG_DEBUG_FS option enabled. As with FTRACE, this may already be enabled (debugfs was added in 2.6.10-rc3). The debugfs also needs to be mounted: ``` # mount -t debugfs none /sys/kernel/debug ``` ### awk Many of there scripts use awk, and will try to use either mawk or gawk depending on the desired behavior: mawk for buffered output (because of its speed), and gawk for synchronous output (as fflush() works, allowing more efficient grouping of writes). ## Install These are just scripts. Either grab everything: ``` git clone --depth 1 https://github.com/brendangregg/perf-tools ``` Or use the raw links on github to download individual scripts. Eg: ``` wget https://raw.githubusercontent.com/brendangregg/perf-tools/master/iosnoop ``` This preserves tabs (which copy-n-paste can mess up). ## Warnings Ftrace was first added to Linux 2.6.27, and perf_events to Linux 2.6.31. These early versions had kernel bugs, and lockups and panics have been reported on 2.6.32 series kernels. This includes CentOS 6.x. If you must analyze older kernels, these tools may only be useful in a fault-tolerant environment, such as a lab with simulated issues. These tools have been primarily developed on Linux 3.2 and later kernels. Depending on the tool, there may also be overhead incurred. See the next section. ## Internals and Overhead perf_events is evolving. This collection began development circa Linux 3.16, with Linux 3.2 servers as the main target, at a time when perf_events lacks certain programmatic capabilities (eg, custom in-kernel aggregations). It's possible these will be added in a forthcoming kernel release. Until then, many of these tools employ workarounds, tricks, and hacks in order to work. Some of these tools pass event data to user space for post-processing, which costs much higher overhead than in-kernel aggregations. The overhead of each tool is described in its man page. __WARNING__: In _extreme_ cases, your target application may run 5x slower when using these tools. Depending on the tool and kernel version, there may also be the risk of kernel panics. Read the program header for warnings, and test before use. If the overhead is a problem, these tools can be improved. If a tool doesn't already, it could be rewritten in C to use perf_events_open() and mmap() for the trace buffer. It could also implement frequency counts in C, and operate on mmap() directly, rather than using awk/Perl/Python. Additional improvements are possible for ftrace-based tools, such as use of snapshots and per-instance buffers. Some of these tools are intended as short-term workarounds until more kernel capabilities exist, at which point they can be substantially rewritten. Older versions of these tools will be kept in this repository, for older kernel versions. As my main target is a fleet of Linux 3.2 servers that do not have debuginfo, these tools try not to require it. At times, this makes the tool more brittle than it needs to be, as I'm employing workarounds (that may be kernel version and platform specific) instead of using debuginfo information (which can be generic). See the man page for detailed prerequisites for each tool. I've tried to use perf_events ("perf") where possible, since that interface has been developed for multi-user use. For various reasons I've often needed to use ftrace instead. ftrace is surprisingly powerful (thanks Steven Rostedt!), and not all of its features are exposed via perf, or in common usage. This tool collection is in some ways a demonstration of hidden Linux features using ftrace. Since things are changing, it's very possible you may find some tools don't work on your Linux kernel version. Some expertise and assembly will be required to fix them. ## Links A case study and summary: - 13 Aug 2014: http://lwn.net/Articles/608497 Ftrace: The hidden light switch Related articles: - 28 Jun 2015: http://www.brendangregg.com/blog/2015-06-28/linux-ftrace-uprobe.html - 31 Dec 2014: http://www.brendangregg.com/blog/2014-12-31/linux-page-cache-hit-ratio.html - 06 Sep 2014: http://www.brendangregg.com/blog/2014-09-06/linux-ftrace-tcp-retransmit-tracing.html - 28 Jul 2014: http://www.brendangregg.com/blog/2014-07-28/execsnoop-for-linux.html - 25 Jul 2014: http://www.brendangregg.com/blog/2014-07-25/opensnoop-for-linux.html - 23 Jul 2014: http://www.brendangregg.com/blog/2014-07-23/linux-iosnoop-latency-heat-maps.html - 16 Jul 2014: http://www.brendangregg.com/blog/2014-07-16/iosnoop-for-linux.html - 10 Jul 2014: http://www.brendangregg.com/blog/2014-07-10/perf-hacktogram.html perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/000077500000000000000000000000001361450357500210505ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/bitesize000077700000000000000000000000001361450357500255122../disk/bitesizeustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/cachestat000077700000000000000000000000001361450357500254322../fs/cachestatustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/execsnoop000077700000000000000000000000001361450357500251322../execsnoopustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/funccount000077700000000000000000000000001361450357500264142../kernel/funccountustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/funcgraph000077700000000000000000000000001361450357500263362../kernel/funcgraphustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/funcslower000077700000000000000000000000001361450357500267622../kernel/funcslowerustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/functrace000077700000000000000000000000001361450357500263302../kernel/functraceustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/iolatency000077700000000000000000000000001361450357500251022../iolatencyustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/iosnoop000077700000000000000000000000001361450357500243002../iosnoopustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/killsnoop000077700000000000000000000000001361450357500251502../killsnoopustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/kprobe000077700000000000000000000000001361450357500251502../kernel/kprobeustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/opensnoop000077700000000000000000000000001361450357500251642../opensnoopustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/perf-stat-hist000077700000000000000000000000001361450357500276032../misc/perf-stat-histustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/reset-ftrace000077700000000000000000000000001361450357500272342../tools/reset-ftraceustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/syscount000077700000000000000000000000001361450357500247022../syscountustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/tcpretrans000077700000000000000000000000001361450357500262642../net/tcpretransustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/tpoint000077700000000000000000000000001361450357500253022../system/tpointustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/bin/uprobe000077700000000000000000000000001361450357500246722../user/uprobeustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/deprecated/000077500000000000000000000000001361450357500224005ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/deprecated/README.md000066400000000000000000000000361361450357500236560ustar00rootroot00000000000000Deprecated versions of tools. perf-tools-unstable-1.0.1~20200130+git49b8cdf/deprecated/execsnoop-proc000066400000000000000000000110211361450357500252620ustar00rootroot00000000000000#!/usr/bin/perl # # execsnoop - trace process exec() with arguments. /proc version. # Written using Linux ftrace. # # This shows the execution of new processes, especially short-lived ones that # can be missed by sampling tools such as top(1). # # USAGE: ./execsnoop [-h] [-n name] # # REQUIREMENTS: FTRACE CONFIG, sched:sched_process_exec tracepoint (you may # already have these on recent kernels), and Perl. # # This traces exec() from the fork()->exec() sequence, which means it won't # catch new processes that only fork(), and, it will catch processes that # re-exec. This instruments sched:sched_process_exec without buffering, and then # in user-space (this program) reads PPID and process arguments asynchronously # from /proc. # # If the process traced is very short-lived, this program may miss reading # arguments and PPID details. In that case, "" and "?" will be printed # respectively. This program is best-effort, and should be improved in the # future when other kernel capabilities are made available. If you need a # more reliable tool now, then consider other tracing alternatives (eg, # SystemTap). This tool is really a proof of concept to see what ftrace can # currently do. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the execsnoop(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 07-Jul-2014 Brendan Gregg Created this. use strict; use warnings; use POSIX qw(strftime); use Getopt::Long; my $tracing = "/sys/kernel/debug/tracing"; my $flock = "/var/tmp/.ftrace-lock"; my $tpdir = "sched/sched_process_exec"; my $tptext = $tpdir; $tptext =~ s/\//:/; local $SIG{INT} = \&cleanup; local $SIG{QUIT} = \&cleanup; local $SIG{TERM} = \&cleanup; local $SIG{PIPE} = \&cleanup; local $SIG{HUP} = \&cleanup; $| = 1; ### options my ($name, $help); GetOptions("name=s" => \$name, "help" => \$help) or usage(); usage() if $help; sub usage { print STDERR "USAGE: execsnoop [-h] [-n name]\n"; print STDERR " eg,\n"; print STDERR " execsnoop -n ls # show \"ls\" cmds only.\n"; exit; } sub ldie { unlink $flock; die @_; } sub writeto { my ($string, $file) = @_; open FILE, ">$file" or return 0; print FILE $string or return 0; close FILE or return 0; } ### check permissions chdir "$tracing" or ldie "ERROR: accessing tracing. Root? Kernel has FTRACE?" . "\ndebugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)"; ### ftrace lock if (-e $flock) { open FLOCK, $flock; my $fpid = ; chomp $fpid; close FLOCK; die "ERROR: ftrace may be in use by PID $fpid ($flock)"; } writeto "$$", $flock or die "ERROR: unable to write $flock."; ### setup and begin tracing writeto "nop", "current_tracer" or ldie "ERROR: disabling current_tracer."; writeto "1", "events/$tpdir/enable" or ldie "ERROR: enabling tracepoint " . "\"$tptext\" (tracepoint missing in this kernel version?)"; open TPIPE, "trace_pipe" or warn "ERROR: opening trace_pipe."; printf "%-8s %6s %6s %s\n", "TIME", "PID", "PPID", "ARGS"; while () { my ($taskpid, $rest) = split; my ($task, $pid) = $taskpid =~ /(.*)-(\d+)/; next if (defined $name and $name ne $task); my $args = "$task "; if (open CMDLINE, "/proc/$pid/cmdline") { my $arglist = ; if (defined $arglist) { $arglist =~ s/\000/ /g; $args = $arglist; } close CMDLINE; } my $ppid = "?"; if (open STAT, "/proc/$pid/stat") { my $fields = ; if (defined $fields) { $ppid = (split ' ', $fields)[3]; } close STAT; } my $now = strftime "%H:%M:%S", localtime; printf "%-8s %6s %6s %s\n", $now, $pid, $ppid, $args; } ### end tracing cleanup(); sub cleanup { print "\nEnding tracing...\n"; close TPIPE; writeto "0", "events/$tpdir/enable" or ldie "ERROR: disabling \"$tptext\""; writeto "", "trace"; unlink $flock; exit; } perf-tools-unstable-1.0.1~20200130+git49b8cdf/deprecated/execsnoop-proc.8000066400000000000000000000050721361450357500254410ustar00rootroot00000000000000.TH execsnoop\-proc 8 "2014-07-07" "USER COMMANDS" .SH NAME execsnoop\-proc \- trace process exec() with arguments. Uses Linux ftrace. /proc version. .SH SYNOPSIS .B execsnoop\-proc [\-h] [\-n name] .SH DESCRIPTION execsnoop\-proc traces process execution, showing PID, PPID, and argument details if possible. This traces exec() from the fork()->exec() sequence, which means it won't catch new processes that only fork(), and, it will catch processes that re-exec. This instruments sched:sched_process_exec without buffering, and then in user-space (this program) reads PPID and process arguments asynchronously from /proc. If the process traced is very short-lived, this program may miss reading arguments and PPID details. In that case, "" and "?" will be printed respectively. This program is best-effort (a hack), and should be improved in the future when other kernel capabilities are made available. It may be useful in the meantime. If you need a more reliable tool now, consider other tracing alternates (eg, SystemTap). This tool is really a proof of concept to see what ftrace can currently do. See execsnoop(8) for another version that reads arguments from registers instead of /proc. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE CONFIG and the sched:sched_process_exec tracepoint, which you may already have enabled and available on recent kernels, and Perl. .SH OPTIONS \-n name Only show processes that match this name. This is filtered in user space. .TP \-h Print usage message. .SH EXAMPLES .TP Trace all new processes and arguments (if possible): .B execsnoop\-proc .TP Trace all new processes with process name "sed": .B execsnoop\-proc -n sed .SH FIELDS .TP TIME Time of process exec(): HH:MM:SS. .TP PID Process ID. .TP PPID Parent process ID, if this was able to be read (may be missed for short-lived processes). If it is unable to be read, "?" is printed. .TP ARGS Command line arguments, if these were able to be read in time (may be missed for short-lived processes). If they are unable to be read, "" is printed. .SH OVERHEAD This reads and processes exec() events in user space as they occur. Since the rate of exec() is expected to be low (< 500/s), the overhead is expected to be small or negligible. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO execsnoop(8), top(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/deprecated/execsnoop-proc_example.txt000066400000000000000000000030341361450357500276200ustar00rootroot00000000000000Demonstrations of execsnoop-proc, the Linux ftrace version. Here's execsnoop showing what's really executed by "man ls": # ./execsnoop TIME PID PPID ARGS 17:52:37 22406 25781 man ls 17:52:37 22413 22406 preconv -e UTF-8 17:52:37 22416 22406 pager -s 17:52:37 22415 22406 /bin/sh /usr/bin/nroff -mandoc -rLL=162n -rLT=162n -Tutf8 17:52:37 22414 22406 tbl 17:52:37 22419 22418 locale charmap 17:52:37 22420 22415 groff -mtty-char -Tutf8 -mandoc -rLL=162n -rLT=162n 17:52:37 22421 22420 troff -mtty-char -mandoc -rLL=162n -rLT=162n -Tutf8 17:52:37 22422 22420 grotty These are short-lived processes, where the argument and PPID details are often missed by execsnoop: # ./execsnoop TIME PID PPID ARGS 18:00:33 26750 1961 multilog 18:00:33 26749 1972 multilog 18:00:33 26749 1972 multilog 18:00:33 26751 ? mkdir 18:00:33 26749 1972 multilog 18:00:33 26752 ? chown 18:00:33 26750 1961 multilog 18:00:33 26750 1961 multilog 18:00:34 26753 1961 multilog 18:00:34 26754 1972 multilog [...] This will be fixed in a later version, but likely requires some kernel or tracer changes first (fetching cmdline as the probe fires). The previous examples were on Linux 3.14 and 3.16 kernels. Here's a 3.2 system I'm running: # ./execsnoop ERROR: enabling tracepoint "sched:sched_process_exec" (tracepoint missing in this kernel version?) at ./execsnoop line 78. This kernel version is missing the sched_process_exec probe, which is pretty annoying. perf-tools-unstable-1.0.1~20200130+git49b8cdf/disk/000077500000000000000000000000001361450357500212325ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/disk/bitesize000077500000000000000000000115561361450357500230060ustar00rootroot00000000000000#!/bin/bash # # bitesize - show disk I/O size as a histogram. # Written using Linux perf_events (aka "perf"). # # This can be used to characterize the distribution of block device I/O # sizes. To study I/O in more detail, see iosnoop(8). # # USAGE: bitesize [-h] [-b buckets] [seconds] # eg, # ./bitesize 10 # # Run "bitesize -h" for full usage. # # REQUIREMENTS: perf_events and block:block_rq_issue tracepoint, which you may # already have on recent kernels. # # This uses multiple counting tracepoints with different filters, one for each # histogram bucket. While this is summarized in-kernel, the use of multiple # tracepoints does add addiitonal overhead, which is more evident if you add # more buckets. In the future this functionality will be available in an # efficient way in the kernel, and this tool can be rewritten. # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 22-Jul-2014 Brendan Gregg Created this. duration=0 buckets=(1 8 64 128) secsz=512 trap ':' INT QUIT TERM PIPE HUP function usage { cat <<-END >&2 USAGE: bitesize [-h] [-b buckets] [seconds] -b buckets # specify histogram buckets (Kbytes) -h # this usage message eg, bitesize # trace I/O size until Ctrl-C bitesize 10 # trace I/O size for 10 seconds bitesize -b "8 16 32" # specify custom bucket points END exit } function die { echo >&2 "$@" exit 1 } ### process options while getopts b:h opt do case $opt in b) buckets=($OPTARG) ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) tpoint=block:block_rq_issue var=nr_sector duration=$1 ### convert buckets (Kbytes) to disk sectors i=0 sectors=(${buckets[*]}) ((max_i = ${#buckets[*]} - 1)) while (( i <= max_i )); do (( sectors[$i] = ${sectors[$i]} * 1024 / $secsz )) # avoid negative array index errors for old version bash if (( i > 0 ));then if (( ${sectors[$i]} <= ${sectors[$i - 1]} )); then die "ERROR: bucket list must increase in size." fi fi (( i++ )) done ### build list of tracepoints and filters for each histogram bucket max_b=${buckets[$max_i]} max_s=${sectors[$max_i]} tpoints="-e $tpoint --filter \"$var < ${sectors[0]}\"" awkarray= i=0 while (( i < max_i )); do tpoints="$tpoints -e $tpoint --filter \"$var >= ${sectors[$i]} && " tpoints="$tpoints $var < ${sectors[$i + 1]}\"" awkarray="$awkarray buckets[$i]=${buckets[$i]};" (( i++ )) done awkarray="$awkarray buckets[$max_i]=${buckets[$max_i]};" tpoints="$tpoints -e $tpoint --filter \"$var >= ${sectors[$max_i]}\"" ### prepare to run if (( duration )); then etext="for $duration seconds" cmd="sleep $duration" else etext="until Ctrl-C" cmd="sleep 999999" fi echo "Tracing block I/O size (bytes), $etext..." ### run perf out="-o /dev/stdout" # a workaround needed in linux 3.2; not by 3.4.15 stat=$(eval perf stat $tpoints -a $out $cmd 2>&1) if (( $? != 0 )); then echo >&2 "ERROR running perf:" echo >&2 "$stat" exit fi ### find max value for ASCII histogram most=$(echo "$stat" | awk -v tpoint=$tpoint ' $2 == tpoint { gsub(/,/, ""); if ($1 > m) { m = $1 } } END { print m }' ) ### process output echo echo "$stat" | awk -v tpoint=$tpoint -v max_i=$max_i -v most=$most ' function star(sval, smax, swidth) { stars = "" # using int could avoid error on gawk if (int(smax) == 0) return "" for (si = 0; si < (swidth * sval / smax); si++) { stars = stars "#" } return stars } BEGIN { '"$awkarray"' printf(" %-15s: %-8s %s\n", "Kbytes", "I/O", "Distribution") } /Performance counter stats/ { i = -1 } # reverse order of rule set is important { ok = 0 } $2 == tpoint { num = $1; gsub(/,/, "", num); ok = 1 } ok && i >= max_i { printf(" %10.1f -> %-10s: %-8s |%-38s|\n", buckets[i], "", num, star(num, most, 38)) next } ok && i >= 0 && i < max_i { printf(" %10.1f -> %-10.1f: %-8s |%-38s|\n", buckets[i], buckets[i+1] - 0.1, num, star(num, most, 38)) i++ next } ok && i == -1 { printf(" %10s -> %-10.1f: %-8s |%-38s|\n", "", buckets[0] - 0.1, num, star(num, most, 38)) i++ } ' perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/000077500000000000000000000000001361450357500221165ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/bitesize_example.txt000066400000000000000000000046771361450357500262260ustar00rootroot00000000000000Demonstrations of bitesize, the Linux perf_events version. bitesize traces block I/O issued, and reports a histogram of I/O size. By default five buckets are used to gather statistics on common I/O sizes: # ./bitesize Tracing block I/O size (bytes), until Ctrl-C... ^C Kbytes : I/O Distribution -> 0.9 : 0 | | 1.0 -> 7.9 : 38 |# | 8.0 -> 63.9 : 10108 |######################################| 64.0 -> 127.9 : 13 |# | 128.0 -> : 1 |# | In this case, most of the I/O was between 8 and 63.9 Kbytes. The "63.9" really means "less than 64". Specifying custom buckets to examine the I/O size in more detail: # ./bitesize -b "8 16 24 32" Tracing block I/O size (bytes), until Ctrl-C... ^C Kbytes : I/O Distribution -> 7.9 : 89 |# | 8.0 -> 15.9 : 14665 |######################################| 16.0 -> 23.9 : 657 |## | 24.0 -> 31.9 : 661 |## | 32.0 -> : 376 |# | The I/O is mostly between 8 and 15.9 Kbytes It's probably 8 Kbytes. Checking: # ./bitesize -b "8 9" Tracing block I/O size (bytes), until Ctrl-C... ^C Kbytes : I/O Distribution -> 7.9 : 62 |# | 8.0 -> 8.9 : 11719 |######################################| 9.0 -> : 1358 |##### | It is. The overhead of this tool is relative to the number of buckets used, hence only using what is necessary. To study this I/O in more detail, I can use iosnoop(8) and capture it to a file for post-processing. Use -h to print the USAGE message: # ./bitesize -h USAGE: bitesize [-h] [-b buckets] [seconds] -b buckets # specify histogram buckets (Kbytes) -h # this usage message eg, bitesize # trace I/O size until Ctrl-C bitesize 10 # trace I/O size for 10 seconds bitesize -b "8 16 32" # specify custom bucket points perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/cachestat_example.txt000066400000000000000000000050421361450357500263320ustar00rootroot00000000000000Demonstrations of cachestat, the Linux ftrace version. Here is some sample output showing file system cache statistics, followed by the workload that caused it: # ./cachestat -t Counting cache functions... Output every 1 seconds. TIME HITS MISSES DIRTIES RATIO BUFFERS_MB CACHE_MB 08:28:57 415 0 0 100.0% 1 191 08:28:58 411 0 0 100.0% 1 191 08:28:59 362 97 0 78.9% 0 8 08:29:00 411 0 0 100.0% 0 9 08:29:01 775 20489 0 3.6% 0 89 08:29:02 411 0 0 100.0% 0 89 08:29:03 6069 0 0 100.0% 0 89 08:29:04 15249 0 0 100.0% 0 89 08:29:05 411 0 0 100.0% 0 89 08:29:06 411 0 0 100.0% 0 89 08:29:07 411 0 3 100.0% 0 89 [...] I used the -t option to include the TIME column, to make describing the output easier. The workload was: # echo 1 > /proc/sys/vm/drop_caches; sleep 2; cksum 80m; sleep 2; cksum 80m At 8:28:58, the page cache was dropped by the first command, which can be seen by the drop in size for "CACHE_MB" (page cache size) from 191 Mbytes to 8. After a 2 second sleep, a cksum command was issued at 8:29:01, for an 80 Mbyte file (called "80m"), which caused a total of ~20,400 misses ("MISSES" column), and the page cache size to grow by 80 Mbytes. The hit ratio during this dropped to 3.6%. Finally, after another 2 second sleep, at 8:29:03 the cksum command was run a second time, this time hitting entirely from cache. Instrumenting all file system cache accesses does cost some overhead, and this tool might slow your target system by 2% or so. Test before use if this is a concern. This tool also uses dynamic tracing, and is tied to Linux kernel implementation details. If it doesn't work for you, it probably needs fixing. Use -h to print the USAGE message: # ./cachestat -h USAGE: cachestat [-Dht] [interval] -D # print debug counters -h # this usage message -t # include timestamp interval # output interval in secs (default 1) eg, cachestat # show stats every second cachestat 5 # show stats every 5 seconds See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/execsnoop_example.txt000066400000000000000000000153141361450357500264010ustar00rootroot00000000000000Demonstrations of execsnoop, the Linux ftrace version. Here's execsnoop showing what's really executed by "man ls": # ./execsnoop Tracing exec()s. Ctrl-C to end. PID PPID ARGS 22898 22004 man ls 22905 22898 preconv -e UTF-8 22908 22898 pager -s 22907 22898 nroff -mandoc -rLL=164n -rLT=164n -Tutf8 22906 22898 tbl 22911 22910 locale charmap 22912 22907 groff -mtty-char -Tutf8 -mandoc -rLL=164n -rLT=164n 22913 22912 troff -mtty-char -mandoc -rLL=164n -rLT=164n -Tutf8 22914 22912 grotty Many commands. This is particularly useful for understanding application startup. Another use for execsnoop is identifying short-lived processes. Eg, with the -t option to see timestamps: # ./execsnoop -t Tracing exec()s. Ctrl-C to end. TIMEs PID PPID ARGS 7419756.154031 8185 8181 mawk -W interactive -v o=1 -v opt_name=0 -v name= [...] 7419756.154131 8186 8184 cat -v trace_pipe 7419756.245264 8188 1698 ./run 7419756.245691 8189 1696 ./run 7419756.246212 8187 1689 ./run 7419756.278993 8190 1693 ./run 7419756.278996 8191 1692 ./run 7419756.288430 8192 1695 ./run 7419756.290115 8193 1691 ./run 7419756.292406 8194 1699 ./run 7419756.293986 8195 1690 ./run 7419756.294149 8196 1686 ./run 7419756.296527 8197 1687 ./run 7419756.296973 8198 1697 ./run 7419756.298356 8200 1685 ./run 7419756.298683 8199 1688 ./run 7419757.269883 8201 1696 ./run [...] So we're running many "run" commands every second. The PPID is included, so I can debug this further (they are "supervise" processes). Short-lived processes can consume CPU and not be visible from top(1), and can be the source of hidden performance issues. Here's another example: I noticed CPU usage was high in top(1), but couldn't see the responsible process: $ top top - 00:04:32 up 78 days, 15:41, 3 users, load average: 0.85, 0.29, 0.14 Tasks: 123 total, 1 running, 121 sleeping, 0 stopped, 1 zombie Cpu(s): 15.7%us, 34.9%sy, 0.0%ni, 49.2%id, 0.0%wa, 0.0%hi, 0.0%si, 0.2%st Mem: 7629464k total, 7537216k used, 92248k free, 1376492k buffers Swap: 0k total, 0k used, 0k free, 5432356k cached PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 7225 bgregg-t 20 0 29480 6196 2128 S 3 0.1 0:02.64 ec2rotatelogs 1 root 20 0 24320 2256 1340 S 0 0.0 0:01.23 init 2 root 20 0 0 0 0 S 0 0.0 0:00.00 kthreadd 3 root 20 0 0 0 0 S 0 0.0 1:19.61 ksoftirqd/0 4 root 20 0 0 0 0 S 0 0.0 0:00.00 kworker/0:0 5 root 20 0 0 0 0 S 0 0.0 0:00.01 kworker/u:0 6 root RT 0 0 0 0 S 0 0.0 0:16.00 migration/0 7 root RT 0 0 0 0 S 0 0.0 0:17.29 watchdog/0 8 root RT 0 0 0 0 S 0 0.0 0:15.85 migration/1 9 root 20 0 0 0 0 S 0 0.0 0:00.00 kworker/1:0 [...] See the line starting with "Cpu(s):". So there's about 50% CPU utilized (this is a two CPU server, so that's equivalent to one full CPU), but this CPU usage isn't visible from the process listing. vmstat agreed, showing the same average CPU usage statistics: # vmstat 1 procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu---- r b swpd free buff cache si so bi bo in cs us sy id wa 2 0 0 92816 1376476 5432188 0 0 0 3 2 1 0 1 99 0 1 0 0 92676 1376484 5432264 0 0 0 24 6573 6130 12 38 49 0 1 0 0 91964 1376484 5432272 0 0 0 0 6529 6097 16 35 49 0 1 0 0 92692 1376484 5432272 0 0 0 0 6192 5775 17 35 49 0 1 0 0 92692 1376484 5432272 0 0 0 0 6554 6121 14 36 50 0 1 0 0 91940 1376484 5432272 0 0 0 12 6546 6101 13 38 49 0 1 0 0 92560 1376484 5432272 0 0 0 0 6201 5769 15 35 49 0 1 0 0 92676 1376484 5432272 0 0 0 0 6524 6123 17 34 49 0 1 0 0 91932 1376484 5432272 0 0 0 0 6546 6107 10 40 49 0 1 0 0 92832 1376484 5432272 0 0 0 0 6057 5710 13 38 49 0 1 0 0 92248 1376484 5432272 0 0 84 28 6592 6183 16 36 48 1 1 0 0 91504 1376492 5432348 0 0 0 12 6540 6098 18 33 49 1 [...] So this could be caused by short-lived processes, who vanish before they are seen by top(1). Do I have my execsnoop handy? Yes: # ~/perf-tools/bin/execsnoop Tracing exec()s. Ctrl-C to end. PID PPID ARGS 10239 10229 gawk -v o=0 -v opt_name=0 -v name= -v opt_duration=0 [...] 10240 10238 cat -v trace_pipe 10242 7225 sh [?] 10243 10242 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.201201.3122.txt 10245 7225 sh [?] 10246 10245 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.202201.3122.txt 10248 7225 sh [?] 10249 10248 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.203201.3122.txt 10251 7225 sh [?] 10252 10251 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.204201.3122.txt 10254 7225 sh [?] 10255 10254 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.205201.3122.txt 10257 7225 sh [?] 10258 10257 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.210201.3122.txt 10260 7225 sh [?] 10261 10260 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.211201.3122.txt 10263 7225 sh [?] 10264 10263 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.212201.3122.txt 10266 7225 sh [?] 10267 10266 /usr/sbin/lsof -X /logs/tomcat/cores/threaddump.20141215.213201.3122.txt [...] The output scrolled quickly, showing that many shell and lsof processes were being launched. If you check the PID and PPID columns carefully, you can see that these are ultimately all from PID 7225. We saw that earlier in the top output: ec2rotatelogs, at 3% CPU. I now know the culprit. I should have used "-t" to show the timestamps with this example. Run -h to print the USAGE message: # ./execsnoop -h USAGE: execsnoop [-hrt] [-a argc] [-d secs] [name] -d seconds # trace duration, and use buffers -a argc # max args to show (default 8) -r # include re-execs -t # include time (seconds) -h # this usage message name # process name to match (REs allowed) eg, execsnoop # watch exec()s live (unbuffered) execsnoop -d 1 # trace 1 sec (buffered) execsnoop grep # trace process names containing grep execsnoop 'log$' # filenames ending in "log" See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/funccount_example.txt000066400000000000000000000105441361450357500264020ustar00rootroot00000000000000Demonstrations of funccount, the Linux ftrace version. Tracing all kernel functions that start with "bio_" (which would be block interface functions), and counting how many times they were executed until Ctrl-C is hit: # ./funccount 'bio_*' Tracing "bio_*"... Ctrl-C to end. ^C FUNC COUNT bio_attempt_back_merge 26 bio_get_nr_vecs 361 bio_alloc 536 bio_alloc_bioset 536 bio_endio 536 bio_free 536 bio_fs_destructor 536 bio_init 536 bio_integrity_enabled 536 bio_put 729 bio_add_page 1004 Note that these counts are performed in-kernel context, using the ftrace function profiler, which means this is a (relatively) low overhead technique. Test yourself to quantify overhead. As was demonstrated here, wildcards can be used. Individual functions can also be specified. For example, all of the following are valid arguments: bio_init bio_* *init *bio* A "*" within a string (eg, "bio*init") is not supported. The full list of what can be traced is in: /sys/kernel/debug/tracing/available_filter_functions, which can be grep'd to check what is there. Note that grep uses regular expressions, whereas funccount uses globbing for wildcards. Counting all "tcp_" kernel functions, and printing a summary every one second: # ./funccount -i 1 -t 5 'tcp_*' Tracing "tcp_*". Top 5 only... Ctrl-C to end. FUNC COUNT tcp_cleanup_rbuf 386 tcp_service_net_dma 386 tcp_established_options 549 tcp_v4_md5_lookup 560 tcp_v4_md5_do_lookup 890 FUNC COUNT tcp_service_net_dma 498 tcp_cleanup_rbuf 499 tcp_established_options 664 tcp_v4_md5_lookup 672 tcp_v4_md5_do_lookup 1071 [...] Neat. Tracing all "ext4*" kernel functions for 10 seconds, and printing the top 25: # ./funccount -t 25 -d 10 'ext4*' Tracing "ext4*" for 10 seconds. Top 25 only... FUNC COUNT ext4_inode_bitmap 840 ext4_meta_trans_blocks 840 ext4_ext_drop_refs 843 ext4_find_entry 845 ext4_discard_preallocations 1008 ext4_free_inodes_count 1120 ext4_group_desc_csum 1120 ext4_group_desc_csum_set 1120 ext4_getblk 1128 ext4_es_free_extent 1328 ext4_map_blocks 1471 ext4_es_lookup_extent 1751 ext4_mb_check_limits 1873 ext4_es_lru_add 2031 ext4_data_block_valid 2312 ext4_journal_check_start 3080 ext4_mark_inode_dirty 5320 ext4_get_inode_flags 5955 ext4_get_inode_loc 5955 ext4_mark_iloc_dirty 5955 ext4_reserve_inode_write 5955 ext4_inode_table 7076 ext4_get_group_desc 8476 ext4_has_inline_data 9492 ext4_inode_touch_time_cmp 38980 Ending tracing... So ext4_inode_touch_time_cmp() was called the most frequently, at 38,980 times. This may be normal, this may not. The purpose of this tool is to give you one view of how one or many kernel functions are executed. Previously I had little idea what ext4 was doing internally. Now I know the top 25 functions, and their rate, and can begin researching them from the source code. Use -h to print the USAGE message: # ./funccount -h USAGE: funccount [-hT] [-i secs] [-d secs] [-t top] funcstring -d seconds # total duration of trace -h # this usage message -i seconds # interval summary -t top # show top num entries only -T # include timestamp (for -i) eg, funccount 'vfs*' # trace all funcs that match "vfs*" funccount -d 5 'tcp*' # trace "tcp*" funcs for 5 seconds funccount -t 10 'ext3*' # show top 10 "ext3*" funcs funccount -i 1 'ext3*' # summary every 1 second funccount -i 1 -d 5 'ext3*' # 5 x 1 second summaries See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/funcgraph_example.txt000066400000000000000000004607171361450357500263660ustar00rootroot00000000000000Demonstrations of funcgraph, the Linux ftrace version. I'll start by showing do_nanosleep(), since it's usually a low frequency function that can be easily triggered (run "vmstat 1"): # ./funcgraph do_nanosleep Tracing "do_nanosleep"... Ctrl-C to end. 0) | do_nanosleep() { 0) | hrtimer_start_range_ns() { 0) | __hrtimer_start_range_ns() { 0) | lock_hrtimer_base.isra.24() { 0) 0.198 us | _raw_spin_lock_irqsave(); 0) 0.908 us | } 0) 0.061 us | idle_cpu(); 0) 0.117 us | ktime_get(); 0) 0.371 us | enqueue_hrtimer(); 0) 0.075 us | _raw_spin_unlock_irqrestore(); 0) 3.447 us | } 0) 3.998 us | } 0) | schedule() { 0) | __schedule() { 0) 0.050 us | rcu_note_context_switch(); 0) 0.055 us | _raw_spin_lock_irq(); 0) | deactivate_task() { 0) | dequeue_task() { 0) 0.142 us | update_rq_clock(); 0) | dequeue_task_fair() { 0) | dequeue_entity() { 0) | update_curr() { 0) 0.086 us | cpuacct_charge(); 0) 0.757 us | } 0) 0.052 us | clear_buddies(); 0) 0.103 us | update_cfs_load(); 0) | update_cfs_shares() { 0) | reweight_entity() { 0) 0.077 us | update_curr(); 0) 0.438 us | } 0) 0.794 us | } 0) 3.067 us | } 0) 0.064 us | set_next_buddy(); 0) 0.066 us | update_cfs_load(); 0) 0.085 us | update_cfs_shares(); 0) | hrtick_update() { 0) 0.063 us | hrtick_start_fair(); 0) 0.367 us | } 0) 5.188 us | } 0) 5.923 us | } 0) 6.228 us | } 0) | put_prev_task_fair() { 0) 0.078 us | put_prev_entity(); 0) | put_prev_entity() { 0) 0.070 us | update_curr(); 0) 0.074 us | __enqueue_entity(); 0) 0.737 us | } 0) 1.367 us | } 0) | pick_next_task_fair() { 0) | pick_next_entity() { 0) 0.052 us | wakeup_preempt_entity.isra.95(); 0) 0.070 us | clear_buddies(); 0) 0.676 us | } 0) | set_next_entity() { 0) 0.052 us | update_stats_wait_end(); 0) 0.435 us | } 0) | pick_next_entity() { 0) 0.065 us | clear_buddies(); 0) 0.376 us | } 0) | set_next_entity() { 0) 0.067 us | update_stats_wait_end(); 0) 0.374 us | } 0) 0.051 us | hrtick_start_fair(); 0) 3.879 us | } 0) 0.057 us | paravirt_start_context_switch(); 0) | xen_load_sp0() { 0) 0.050 us | paravirt_get_lazy_mode(); 0) 0.057 us | __xen_mc_entry(); 0) 0.056 us | paravirt_get_lazy_mode(); 0) 1.441 us | } 0) | xen_load_tls() { 0) 0.049 us | paravirt_get_lazy_mode(); 0) 0.051 us | paravirt_get_lazy_mode(); 0) | load_TLS_descriptor() { 0) | arbitrary_virt_to_machine() { 0) 0.081 us | __virt_addr_valid(); 0) 0.052 us | __phys_addr(); 0) 0.084 us | get_phys_to_machine(); 0) 1.115 us | } 0) 0.053 us | __xen_mc_entry(); 0) 1.744 us | } 0) | load_TLS_descriptor() { 0) | arbitrary_virt_to_machine() { 0) 0.053 us | __virt_addr_valid(); 0) 0.056 us | __phys_addr(); 0) 0.057 us | get_phys_to_machine(); 0) 0.990 us | } 0) 0.053 us | __xen_mc_entry(); 0) 1.583 us | } /* load_TLS_descriptor */ 0) | load_TLS_descriptor() { 0) | arbitrary_virt_to_machine() { 0) 0.057 us | __virt_addr_valid(); 0) 0.051 us | __phys_addr(); 0) 0.053 us | get_phys_to_machine(); 0) 0.978 us | } 0) 0.052 us | __xen_mc_entry(); 0) 1.586 us | } 0) 0.052 us | paravirt_get_lazy_mode(); 0) 6.630 us | } 0) | xen_end_context_switch() { 0) 0.666 us | xen_mc_flush(); 0) 0.050 us | paravirt_end_context_switch(); 0) 1.286 us | } 0) 0.172 us | xen_write_msr_safe(); ------------------------------------------ 0) platfor-3210 => vmstat-2854 ------------------------------------------ 0) | do_nanosleep() { 0) | hrtimer_start_range_ns() { 0) | __hrtimer_start_range_ns() { 0) | lock_hrtimer_base.isra.24() { 0) 0.217 us | _raw_spin_lock_irqsave(); 0) 0.831 us | } 0) 0.066 us | idle_cpu(); 0) 0.123 us | ktime_get(); 0) 1.172 us | enqueue_hrtimer(); 0) 0.089 us | _raw_spin_unlock_irqrestore(); 0) 4.050 us | } 0) 4.523 us | } [...] The default output shows the function call graph, including all child kernel functions, along with the function duration times. These times are printed on either the return line for the function ("}"), or for leaf functions, on the same line. The format of this output is documented in the function graph section of the kernel source file Documentation/trace/ftrace.txt. This particular example shows the workings of do_nanosleep, in the first dozen lines, and then schedule() is called to sleep this thread and run another. The inner workings of schedule() is included in the output. This output is great for determining the behavior of a certain kernel function, and to identify functions that can be studied in more details using other, lower overhead, tools (eg, funccount(8), functrace(8), kprobe(8)). The overheads of funcgraph are moderate, since all kernel functions are traced in case they are executed, then included in the output if they are. Now, if you want to start understanding the general behavior of the kernel, without a certain kernel function in mind, you may be better to begin with CPU stack profiling using perf and generating a flame graph. Such an approach has low overhead, as you are in control of the frequency of event collection (eg, gathering CPU stacks at 99 Hertz). For instructions, see: http://www.brendangregg.com/perf.html#FlameGraphs On newer Linux kernels, you can use the -m option to limit the function depth. Eg, 3 levels only: # ./funcgraph -m 3 do_nanosleep Tracing "do_nanosleep"... Ctrl-C to end. 1) | do_nanosleep() { 1) | hrtimer_start_range_ns() { 1) 1.115 us | __hrtimer_start_range_ns(); 1) 1.919 us | } 1) | schedule() { 1) | __schedule() { 1) 1000131 us | } 1) 11.006 us | xen_evtchn_do_upcall(); 1) 1000149 us | } 1) | hrtimer_cancel() { 1) 0.212 us | hrtimer_try_to_cancel(); 1) 0.699 us | } 1) 1000154 us | } Neat. Now do_sys_open() to 3 levels: 0) | do_sys_open() { 0) | getname() { 0) 0.296 us | getname_flags(); 0) 0.768 us | } 0) | get_unused_fd_flags() { 0) 0.397 us | __alloc_fd(); 0) 0.827 us | } 0) | do_filp_open() { 0) 4.166 us | path_openat(); 0) 4.617 us | } 0) | __fsnotify_parent() { 0) 0.083 us | dget_parent(); 0) 0.063 us | dput(); 0) 0.883 us | } 0) 0.058 us | fsnotify(); 0) | fd_install() { 0) 0.133 us | __fd_install(); 0) 0.525 us | } 0) | putname() { 0) 0.198 us | final_putname(); 0) 0.512 us | } 0) 10.777 us | } [...] I can then pick the highest latency child function, then run funcgraph again using it as the target. Without timestamps (-D to elide duration): # ./funcgraph -Dm 3 do_sys_open Tracing "do_sys_open"... Ctrl-C to end. 1) do_sys_open() { 1) getname() { 1) getname_flags(); 1) } 1) get_unused_fd_flags() { 1) __alloc_fd(); 1) } 1) do_filp_open() { 1) path_openat(); 1) } 1) __fsnotify_parent(); 1) fsnotify(); 1) fd_install() { 1) __fd_install(); 1) } 1) putname() { 1) final_putname(); 1) } 1) } Beautiful. I could elide the CPU column as well, but I want to leave it: if it changes half-way through some output, you know the CPU buffer has switched, and the output may be shuffled. For this example, I trace vfs_read() calls by process ID 5363: which is a bash shell. I also include headers (-H) and absolute timestamps (-t). While tracing, in that bash shell, I typed the word "hello": # ./funcgraph -Htp 5363 vfs_read Tracing "vfs_read" for PID 5363... Ctrl-C to end. # tracer: function_graph # # TIME CPU DURATION FUNCTION CALLS # | | | | | | | | 7238523.638008 | 0) | finish_task_switch() { 7238523.638012 | 0) | xen_evtchn_do_upcall() { 7238523.638012 | 0) | irq_enter() { 7238523.638013 | 0) 0.153 us | rcu_irq_enter(); 7238523.638014 | 0) 1.144 us | } 7238523.638014 | 0) 0.056 us | exit_idle(); 7238523.638014 | 0) | __xen_evtchn_do_upcall() { 7238523.638015 | 0) | evtchn_2l_handle_events() { 7238523.638015 | 0) 0.057 us | irq_from_virq(); 7238523.638015 | 0) | evtchn_from_irq() { 7238523.638015 | 0) | irq_get_irq_data() { 7238523.638016 | 0) 0.058 us | irq_to_desc(); 7238523.638016 | 0) 0.565 us | } 7238523.638016 | 0) 0.966 us | } 7238523.638016 | 0) | get_evtchn_to_irq() { 7238523.638017 | 0) 0.050 us | evtchn_2l_max_channels(); 7238523.638017 | 0) 0.386 us | } 7238523.638017 | 0) | generic_handle_irq() { 7238523.638017 | 0) 0.058 us | irq_to_desc(); 7238523.638018 | 0) | handle_percpu_irq() { 7238523.638018 | 0) | ack_dynirq() { 7238523.638018 | 0) | evtchn_from_irq() { 7238523.638018 | 0) | irq_get_irq_data() { 7238523.638019 | 0) 0.049 us | irq_to_desc(); 7238523.638019 | 0) 0.441 us | } 7238523.638019 | 0) 0.772 us | } 7238523.638019 | 0) 0.049 us | irq_move_irq(); 7238523.638020 | 0) 0.060 us | evtchn_2l_clear_pending(); 7238523.638020 | 0) 1.810 us | } 7238523.638020 | 0) | handle_irq_event_percpu() { 7238523.638020 | 0) | xen_irq_work_interrupt() { 7238523.638021 | 0) | irq_enter() { 7238523.638021 | 0) 0.056 us | rcu_irq_enter(); 7238523.638021 | 0) 0.384 us | } 7238523.638021 | 0) | __wake_up() { 7238523.638022 | 0) 0.059 us | _raw_spin_lock_irqsave(); 7238523.638022 | 0) | __wake_up_common() { 7238523.638022 | 0) | autoremove_wake_function() { 7238523.638023 | 0) | default_wake_function() { 7238523.638023 | 0) | try_to_wake_up() { 7238523.638023 | 0) 0.220 us | _raw_spin_lock_irqsave(); 7238523.638024 | 0) 0.270 us | task_waking_fair(); 7238523.638024 | 0) | select_task_rq_fair() { 7238523.638025 | 0) 0.055 us | source_load(); 7238523.638025 | 0) 0.056 us | target_load(); 7238523.638025 | 0) 0.060 us | idle_cpu(); 7238523.638026 | 0) 0.054 us | cpus_share_cache(); 7238523.638026 | 0) 0.083 us | idle_cpu(); 7238523.638026 | 0) 2.060 us | } 7238523.638027 | 0) 0.051 us | _raw_spin_lock(); 7238523.638027 | 0) | ttwu_do_activate.constprop.124() { 7238523.638027 | 0) | activate_task() { 7238523.638027 | 0) | enqueue_task() { 7238523.638028 | 0) 0.120 us | update_rq_clock(); 7238523.638028 | 0) | enqueue_task_fair() { 7238523.638028 | 0) | enqueue_entity() { 7238523.638028 | 0) 0.147 us | update_curr(); 7238523.638029 | 0) 0.055 us | __compute_runnable_contrib.part.51(); 7238523.638029 | 0) 0.066 us | __update_entity_load_avg_contrib(); 7238523.638029 | 0) 0.141 us | update_cfs_rq_blocked_load(); 7238523.638030 | 0) 0.068 us | account_entity_enqueue(); 7238523.638030 | 0) 0.351 us | update_cfs_shares(); 7238523.638031 | 0) 0.053 us | place_entity(); 7238523.638031 | 0) 0.082 us | __enqueue_entity(); 7238523.638032 | 0) 0.050 us | update_cfs_rq_blocked_load(); 7238523.638032 | 0) 3.922 us | } 7238523.638032 | 0) | enqueue_entity() { 7238523.638033 | 0) 0.058 us | update_curr(); 7238523.638033 | 0) 0.056 us | __compute_runnable_contrib.part.51(); 7238523.638033 | 0) 0.078 us | __update_entity_load_avg_contrib(); 7238523.638034 | 0) 0.055 us | update_cfs_rq_blocked_load(); 7238523.638034 | 0) 0.064 us | account_entity_enqueue(); 7238523.638034 | 0) 0.059 us | update_cfs_shares(); 7238523.638035 | 0) 0.050 us | place_entity(); 7238523.638036 | 0) 0.057 us | __enqueue_entity(); 7238523.638036 | 0) 3.829 us | } 7238523.638037 | 0) 0.057 us | hrtick_update(); 7238523.638037 | 0) 8.876 us | } 7238523.638037 | 0) 9.698 us | } 7238523.638037 | 0) 10.113 us | } 7238523.638038 | 0) | ttwu_do_wakeup() { 7238523.638038 | 0) | check_preempt_curr() { 7238523.638038 | 0) | resched_task() { 7238523.638038 | 0) | xen_smp_send_reschedule() { 7238523.638038 | 0) | xen_send_IPI_one() { 7238523.638039 | 0) | notify_remote_via_irq() { 7238523.638039 | 0) | evtchn_from_irq() { 7238523.638039 | 0) | irq_get_irq_data() { 7238523.638039 | 0) 0.051 us | irq_to_desc(); 7238523.638039 | 0) 0.518 us | } 7238523.638040 | 0) 0.955 us | } 7238523.638041 | 0) 2.001 us | } 7238523.638041 | 0) 2.391 us | } 7238523.638041 | 0) 2.745 us | } 7238523.638041 | 0) 3.183 us | } 7238523.638042 | 0) 3.663 us | } 7238523.638042 | 0) 4.621 us | } 7238523.638043 | 0) 15.443 us | } 7238523.638043 | 0) 0.067 us | _raw_spin_unlock(); 7238523.638043 | 0) 0.167 us | ttwu_stat(); 7238523.638044 | 0) 0.087 us | _raw_spin_unlock_irqrestore(); 7238523.638044 | 0) 21.447 us | } 7238523.638045 | 0) 21.940 us | } 7238523.638045 | 0) 22.406 us | } 7238523.638045 | 0) 23.071 us | } 7238523.638045 | 0) 0.073 us | _raw_spin_unlock_irqrestore(); 7238523.638046 | 0) 24.382 us | } 7238523.638046 | 0) | irq_exit() { 7238523.638047 | 0) 0.085 us | idle_cpu(); 7238523.638047 | 0) 0.093 us | rcu_irq_exit(); 7238523.638048 | 0) 1.242 us | } 7238523.638048 | 0) 27.410 us | } 7238523.638049 | 0) 0.139 us | add_interrupt_randomness(); 7238523.638049 | 0) 0.089 us | note_interrupt(); 7238523.638050 | 0) 29.582 us | } 7238523.638050 | 0) 32.112 us | } 7238523.638050 | 0) 32.951 us | } 7238523.638051 | 0) 35.765 us | } 7238523.638051 | 0) 36.170 us | } 7238523.638051 | 0) | irq_exit() { 7238523.638051 | 0) 0.082 us | idle_cpu(); 7238523.638052 | 0) 0.071 us | rcu_irq_exit(); 7238523.638053 | 0) 1.328 us | } 7238523.638053 | 0) 40.563 us | } 7238523.638054 | 0) | __mmdrop() { 7238523.638054 | 0) | pgd_free() { 7238523.638055 | 0) 0.151 us | _raw_spin_lock(); 7238523.638055 | 0) 0.069 us | _raw_spin_unlock(); 7238523.638056 | 0) | xen_pgd_free() { 7238523.638056 | 0) 0.067 us | xen_get_user_pgd(); 7238523.638057 | 0) | free_pages() { 7238523.638057 | 0) | __free_pages() { 7238523.638057 | 0) | free_hot_cold_page() { 7238523.638058 | 0) 0.080 us | free_pages_prepare(); 7238523.638058 | 0) 0.363 us | get_pfnblock_flags_mask(); 7238523.638059 | 0) 1.626 us | } 7238523.638059 | 0) 2.317 us | } 7238523.638060 | 0) 2.847 us | } 7238523.638060 | 0) 3.908 us | } 7238523.638060 | 0) | free_pages() { 7238523.638060 | 0) | __free_pages() { 7238523.638061 | 0) | free_hot_cold_page() { 7238523.638061 | 0) 0.083 us | free_pages_prepare(); 7238523.638061 | 0) 0.139 us | get_pfnblock_flags_mask(); 7238523.638062 | 0) 1.062 us | } 7238523.638062 | 0) 1.534 us | } 7238523.638062 | 0) 2.038 us | } 7238523.638063 | 0) 8.268 us | } 7238523.638064 | 0) 0.160 us | destroy_context(); 7238523.638065 | 0) 0.384 us | kmem_cache_free(); 7238523.638066 | 0) 11.433 us | } 7238523.638066 | 0) 54.448 us | } 7238523.638066 | 0) 19354026 us | } /* __schedule */ 7238523.638067 | 0) 19354026 us | } /* schedule */ 7238523.638067 | 0) 19354027 us | } /* schedule_timeout */ 7238523.638067 | 0) 0.121 us | down_read(); 7238523.638068 | 0) | copy_from_read_buf() { 7238523.638069 | 0) | tty_audit_add_data() { 7238523.638070 | 0) 0.220 us | _raw_spin_lock_irqsave(); 7238523.638071 | 0) 0.097 us | _raw_spin_unlock_irqrestore(); 7238523.638071 | 0) 0.078 us | _raw_spin_lock_irqsave(); 7238523.638072 | 0) 0.077 us | _raw_spin_unlock_irqrestore(); 7238523.638072 | 0) 2.795 us | } 7238523.638073 | 0) 4.183 us | } 7238523.638073 | 0) 0.084 us | copy_from_read_buf(); 7238523.638074 | 0) 0.078 us | n_tty_set_room(); 7238523.638074 | 0) 0.082 us | n_tty_write_wakeup(); 7238523.638075 | 0) | __wake_up() { 7238523.638075 | 0) 0.084 us | _raw_spin_lock_irqsave(); 7238523.638076 | 0) | __wake_up_common() { 7238523.638076 | 0) 0.095 us | pollwake(); 7238523.638077 | 0) 0.819 us | } 7238523.638077 | 0) 0.074 us | _raw_spin_unlock_irqrestore(); 7238523.638078 | 0) 2.463 us | } 7238523.638078 | 0) 0.071 us | n_tty_set_room(); 7238523.638078 | 0) 0.082 us | up_read(); 7238523.638079 | 0) | remove_wait_queue() { 7238523.638079 | 0) 0.082 us | _raw_spin_lock_irqsave(); 7238523.638080 | 0) 0.086 us | _raw_spin_unlock_irqrestore(); 7238523.638080 | 0) 1.239 us | } 7238523.638081 | 0) 0.142 us | mutex_unlock(); 7238523.638081 | 0) 19354047 us | } /* n_tty_read */ 7238523.638082 | 0) | tty_ldisc_deref() { 7238523.638082 | 0) 0.064 us | ldsem_up_read(); 7238523.638082 | 0) 0.554 us | } 7238523.638083 | 0) 0.074 us | get_seconds(); 7238523.638083 | 0) 19354052 us | } /* tty_read */ 7238523.638084 | 0) 0.352 us | __fsnotify_parent(); 7238523.638085 | 0) 0.178 us | fsnotify(); 7238523.638085 | 0) 19354058 us | } /* vfs_read */ 7238523.638156 | 0) | vfs_read() { 7238523.638157 | 0) | rw_verify_area() { 7238523.638157 | 0) | security_file_permission() { 7238523.638158 | 0) | apparmor_file_permission() { 7238523.638158 | 0) 0.183 us | common_file_perm(); 7238523.638159 | 0) 0.778 us | } 7238523.638159 | 0) 0.081 us | __fsnotify_parent(); 7238523.638160 | 0) 0.104 us | fsnotify(); 7238523.638160 | 0) 2.662 us | } 7238523.638161 | 0) 3.337 us | } 7238523.638161 | 0) | tty_read() { 7238523.638161 | 0) 0.067 us | tty_paranoia_check(); 7238523.638162 | 0) | tty_ldisc_ref_wait() { 7238523.638162 | 0) 0.080 us | } /* ldsem_down_read */ 7238523.638163 | 0) 0.637 us | } 7238523.638163 | 0) | n_tty_read() { 7238523.638164 | 0) 0.078 us | _raw_spin_lock_irq(); 7238523.638164 | 0) 0.090 us | mutex_lock_interruptible(); 7238523.638165 | 0) 0.078 us | down_read(); 7238523.638165 | 0) | add_wait_queue() { 7238523.638166 | 0) 0.070 us | _raw_spin_lock_irqsave(); 7238523.638166 | 0) 0.084 us | _raw_spin_unlock_irqrestore(); 7238523.638167 | 0) 1.111 us | } 7238523.638167 | 0) 0.083 us | tty_hung_up_p(); 7238523.638168 | 0) 0.080 us | n_tty_set_room(); 7238523.638169 | 0) 0.068 us | up_read(); 7238523.638169 | 0) | schedule_timeout() { 7238523.638170 | 0) | schedule() { 7238523.638170 | 0) | __schedule() { 7238523.638171 | 0) 0.078 us | rcu_note_context_switch(); 7238523.638171 | 0) 0.081 us | _raw_spin_lock_irq(); 7238523.638172 | 0) | deactivate_task() { 7238523.638172 | 0) | dequeue_task() { 7238523.638172 | 0) 0.181 us | update_rq_clock(); 7238523.638173 | 0) | dequeue_task_fair() { 7238523.638174 | 0) | dequeue_entity() { 7238523.638174 | 0) | update_curr() { 7238523.638174 | 0) 0.257 us | cpuacct_charge(); 7238523.638175 | 0) 0.982 us | } 7238523.638175 | 0) 0.079 us | update_cfs_rq_blocked_load(); 7238523.638176 | 0) 0.080 us | clear_buddies(); 7238523.638177 | 0) 0.096 us | account_entity_dequeue(); 7238523.638177 | 0) | update_cfs_shares() { 7238523.638178 | 0) 0.113 us | update_curr(); 7238523.638178 | 0) 0.087 us | account_entity_dequeue(); 7238523.638179 | 0) 0.073 us | account_entity_enqueue(); 7238523.638179 | 0) 1.948 us | } 7238523.638180 | 0) 5.913 us | } 7238523.638180 | 0) | dequeue_entity() { 7238523.638180 | 0) 0.086 us | update_curr(); 7238523.638181 | 0) 0.079 us | update_cfs_rq_blocked_load(); 7238523.638182 | 0) 0.076 us | clear_buddies(); 7238523.638182 | 0) 0.076 us | account_entity_dequeue(); 7238523.638183 | 0) 0.104 us | update_cfs_shares(); 7238523.638183 | 0) 3.171 us | } 7238523.638184 | 0) 0.076 us | hrtick_update(); 7238523.638184 | 0) 10.785 us | } 7238523.638184 | 0) 12.057 us | } 7238523.638185 | 0) 12.704 us | } 7238523.638185 | 0) | pick_next_task_fair() { 7238523.638185 | 0) 0.074 us | check_cfs_rq_runtime(); 7238523.638186 | 0) | pick_next_entity() { 7238523.638186 | 0) 0.067 us | clear_buddies(); 7238523.638187 | 0) 0.544 us | } 7238523.638187 | 0) | put_prev_entity() { 7238523.638187 | 0) 0.079 us | check_cfs_rq_runtime(); 7238523.638188 | 0) 0.612 us | } 7238523.638188 | 0) | put_prev_entity() { 7238523.638188 | 0) 0.076 us | check_cfs_rq_runtime(); 7238523.638189 | 0) 0.618 us | } 7238523.638189 | 0) | set_next_entity() { 7238523.638190 | 0) 0.078 us | update_stats_wait_end(); 7238523.638190 | 0) 0.712 us | } 7238523.638190 | 0) 5.023 us | } 7238523.638191 | 0) 0.086 us | paravirt_start_context_switch(); 7238523.638192 | 0) 0.070 us | xen_read_cr0(); 7238523.638193 | 0) | xen_write_cr0() { 7238523.638193 | 0) 0.085 us | paravirt_get_lazy_mode(); 7238523.638194 | 0) 0.085 us | __xen_mc_entry(); 7238523.638194 | 0) 0.077 us | paravirt_get_lazy_mode(); 7238523.638195 | 0) 1.822 us | } 7238523.638195 | 0) | xen_load_sp0() { 7238523.638195 | 0) 0.074 us | paravirt_get_lazy_mode(); 7238523.638196 | 0) 0.085 us | __xen_mc_entry(); 7238523.638196 | 0) 0.078 us | paravirt_get_lazy_mode(); 7238523.638197 | 0) 1.754 us | } 7238523.638197 | 0) | xen_load_tls() { 7238523.638198 | 0) 0.069 us | paravirt_get_lazy_mode(); 7238523.638198 | 0) 0.082 us | paravirt_get_lazy_mode(); 7238523.638199 | 0) 0.127 us | load_TLS_descriptor(); 7238523.638199 | 0) 0.080 us | load_TLS_descriptor(); 7238523.638200 | 0) 0.094 us | load_TLS_descriptor(); 7238523.638201 | 0) 0.081 us | paravirt_get_lazy_mode(); 7238523.638202 | 0) 4.155 us | } 7238523.638202 | 0) | xen_end_context_switch() { 7238523.638202 | 0) 0.699 us | xen_mc_flush(); 7238523.638204 | 0) 0.089 us | paravirt_end_context_switch(); 7238523.638204 | 0) 1.915 us | } 7238523.797630 | 0) | finish_task_switch() { 7238523.797634 | 0) | xen_evtchn_do_upcall() { 7238523.797634 | 0) | irq_enter() { 7238523.797634 | 0) 0.134 us | rcu_irq_enter(); 7238523.797635 | 0) 0.688 us | } 7238523.797635 | 0) 0.055 us | exit_idle(); 7238523.797635 | 0) | __xen_evtchn_do_upcall() { 7238523.797636 | 0) | evtchn_2l_handle_events() { 7238523.797636 | 0) 0.048 us | irq_from_virq(); 7238523.797636 | 0) | evtchn_from_irq() { 7238523.797636 | 0) | irq_get_irq_data() { 7238523.797637 | 0) 0.061 us | irq_to_desc(); 7238523.797637 | 0) 0.564 us | } 7238523.797637 | 0) 0.954 us | } 7238523.797638 | 0) | get_evtchn_to_irq() { 7238523.797638 | 0) 0.057 us | evtchn_2l_max_channels(); 7238523.797638 | 0) 0.409 us | } 7238523.797638 | 0) | generic_handle_irq() { 7238523.797638 | 0) 0.052 us | irq_to_desc(); 7238523.797639 | 0) | handle_percpu_irq() { 7238523.797639 | 0) | ack_dynirq() { 7238523.797639 | 0) | evtchn_from_irq() { 7238523.797639 | 0) | irq_get_irq_data() { 7238523.797640 | 0) 0.057 us | irq_to_desc(); 7238523.797640 | 0) 0.440 us | } 7238523.797640 | 0) 0.746 us | } 7238523.797640 | 0) 0.056 us | irq_move_irq(); 7238523.797641 | 0) 0.058 us | evtchn_2l_clear_pending(); 7238523.797641 | 0) 1.729 us | } 7238523.797641 | 0) | handle_irq_event_percpu() { 7238523.797641 | 0) | xen_irq_work_interrupt() { 7238523.797642 | 0) | irq_enter() { 7238523.797642 | 0) 0.053 us | rcu_irq_enter(); 7238523.797642 | 0) 0.396 us | } 7238523.797642 | 0) | __wake_up() { 7238523.797643 | 0) 0.053 us | _raw_spin_lock_irqsave(); 7238523.797643 | 0) | __wake_up_common() { 7238523.797643 | 0) | autoremove_wake_function() { 7238523.797644 | 0) | default_wake_function() { 7238523.797644 | 0) | try_to_wake_up() { 7238523.797644 | 0) 0.228 us | _raw_spin_lock_irqsave(); 7238523.797645 | 0) 0.194 us | task_waking_fair(); 7238523.797645 | 0) | select_task_rq_fair() { 7238523.797645 | 0) 0.051 us | source_load(); 7238523.797646 | 0) 0.050 us | target_load(); 7238523.797646 | 0) 0.067 us | idle_cpu(); 7238523.797647 | 0) 0.050 us | cpus_share_cache(); 7238523.797647 | 0) 0.068 us | idle_cpu(); 7238523.797647 | 0) 1.983 us | } 7238523.797648 | 0) 0.051 us | _raw_spin_lock(); 7238523.797648 | 0) | ttwu_do_activate.constprop.124() { 7238523.797648 | 0) | activate_task() { 7238523.797648 | 0) | enqueue_task() { 7238523.797648 | 0) 0.135 us | update_rq_clock(); 7238523.797649 | 0) | enqueue_task_fair() { 7238523.797649 | 0) | enqueue_entity() { 7238523.797649 | 0) 0.059 us | update_curr(); 7238523.797650 | 0) 0.073 us | __compute_runnable_contrib.part.51(); 7238523.797650 | 0) 0.066 us | __update_entity_load_avg_contrib(); 7238523.797650 | 0) 0.059 us | update_cfs_rq_blocked_load(); 7238523.797651 | 0) 0.064 us | account_entity_enqueue(); 7238523.797651 | 0) 0.137 us | update_cfs_shares(); 7238523.797651 | 0) 0.054 us | place_entity(); 7238523.797652 | 0) 0.074 us | __enqueue_entity(); 7238523.797652 | 0) 3.085 us | } 7238523.797652 | 0) | enqueue_entity() { 7238523.797653 | 0) 0.058 us | update_curr(); 7238523.797654 | 0) 0.049 us | update_cfs_rq_blocked_load(); 7238523.797654 | 0) 0.057 us | account_entity_enqueue(); 7238523.797655 | 0) 0.066 us | update_cfs_shares(); 7238523.797655 | 0) 0.049 us | place_entity(); 7238523.797655 | 0) 0.051 us | __enqueue_entity(); 7238523.797656 | 0) 3.432 us | } 7238523.797656 | 0) 0.049 us | hrtick_update(); 7238523.797657 | 0) 7.552 us | } 7238523.797657 | 0) 8.414 us | } 7238523.797657 | 0) 8.753 us | } 7238523.797657 | 0) | ttwu_do_wakeup() { 7238523.797657 | 0) | check_preempt_curr() { 7238523.797657 | 0) | resched_task() { 7238523.797658 | 0) | xen_smp_send_reschedule() { 7238523.797658 | 0) | xen_send_IPI_one() { 7238523.797658 | 0) | notify_remote_via_irq() { 7238523.797658 | 0) | evtchn_from_irq() { 7238523.797658 | 0) | irq_get_irq_data() { 7238523.797659 | 0) 0.069 us | irq_to_desc(); 7238523.797659 | 0) 0.504 us | } 7238523.797659 | 0) 0.869 us | } 7238523.797660 | 0) 1.940 us | } /* notify_remote_via_irq */ 7238523.797660 | 0) 2.319 us | } 7238523.797660 | 0) 2.712 us | } 7238523.797661 | 0) 3.147 us | } 7238523.797661 | 0) 3.625 us | } 7238523.797662 | 0) 4.525 us | } 7238523.797662 | 0) 13.961 us | } 7238523.797662 | 0) 0.069 us | _raw_spin_unlock(); 7238523.797663 | 0) 0.168 us | ttwu_stat(); 7238523.797663 | 0) 0.076 us | _raw_spin_unlock_irqrestore(); 7238523.797664 | 0) 19.821 us | } 7238523.797664 | 0) 20.301 us | } 7238523.797664 | 0) 20.796 us | } 7238523.797664 | 0) 21.367 us | } 7238523.797665 | 0) 0.071 us | _raw_spin_unlock_irqrestore(); 7238523.797665 | 0) 22.621 us | } 7238523.797666 | 0) | irq_exit() { 7238523.797666 | 0) 0.085 us | idle_cpu(); 7238523.797666 | 0) 0.106 us | rcu_irq_exit(); 7238523.797667 | 0) 1.220 us | } 7238523.797667 | 0) 25.712 us | } 7238523.797668 | 0) 0.138 us | add_interrupt_randomness(); 7238523.797668 | 0) 0.092 us | note_interrupt(); 7238523.797669 | 0) 27.713 us | } 7238523.797669 | 0) 30.163 us | } 7238523.797669 | 0) 31.017 us | } 7238523.797670 | 0) 33.953 us | } 7238523.797670 | 0) 34.384 us | } 7238523.797670 | 0) | irq_exit() { 7238523.797671 | 0) 0.079 us | idle_cpu(); 7238523.797671 | 0) 0.072 us | rcu_irq_exit(); 7238523.797672 | 0) 1.023 us | } 7238523.797672 | 0) 37.789 us | } 7238523.797672 | 0) 39.298 us | } 7238523.797673 | 0) 159502.1 us | } 7238523.797673 | 0) 159502.8 us | } 7238523.797673 | 0) 159503.5 us | } 7238523.797674 | 0) 0.112 us | down_read(); 7238523.797675 | 0) | copy_from_read_buf() { 7238523.797676 | 0) | tty_audit_add_data() { 7238523.797676 | 0) 0.226 us | _raw_spin_lock_irqsave(); 7238523.797677 | 0) 0.075 us | _raw_spin_unlock_irqrestore(); 7238523.797677 | 0) 0.101 us | _raw_spin_lock_irqsave(); 7238523.797678 | 0) 0.068 us | _raw_spin_unlock_irqrestore(); 7238523.797679 | 0) 2.656 us | } 7238523.797679 | 0) 3.762 us | } 7238523.797679 | 0) 0.145 us | copy_from_read_buf(); 7238523.797680 | 0) 0.068 us | n_tty_set_room(); 7238523.797680 | 0) 0.058 us | n_tty_write_wakeup(); 7238523.797681 | 0) | __wake_up() { 7238523.797682 | 0) 0.060 us | _raw_spin_lock_irqsave(); 7238523.797682 | 0) | __wake_up_common() { 7238523.797683 | 0) 0.083 us | pollwake(); 7238523.797683 | 0) 0.739 us | } 7238523.797683 | 0) 0.069 us | _raw_spin_unlock_irqrestore(); 7238523.797684 | 0) 2.745 us | } 7238523.797684 | 0) 0.061 us | n_tty_set_room(); 7238523.797685 | 0) 0.074 us | up_read(); 7238523.797685 | 0) | remove_wait_queue() { 7238523.797685 | 0) 0.075 us | _raw_spin_lock_irqsave(); 7238523.797686 | 0) 0.070 us | _raw_spin_unlock_irqrestore(); 7238523.797686 | 0) 1.110 us | } 7238523.797687 | 0) 0.146 us | mutex_unlock(); 7238523.797687 | 0) 159524.0 us | } 7238523.797688 | 0) | tty_ldisc_deref() { 7238523.797688 | 0) 0.070 us | ldsem_up_read(); 7238523.797689 | 0) 0.739 us | } 7238523.797689 | 0) 0.066 us | get_seconds(); 7238523.797690 | 0) 159528.3 us | } 7238523.797690 | 0) 0.298 us | __fsnotify_parent(); 7238523.797691 | 0) 0.179 us | fsnotify(); 7238523.797692 | 0) 159534.6 us | } 7238523.797762 | 0) | vfs_read() { 7238523.797763 | 0) | rw_verify_area() { 7238523.797763 | 0) | security_file_permission() { 7238523.797764 | 0) | apparmor_file_permission() { 7238523.797764 | 0) 0.165 us | common_file_perm(); 7238523.797765 | 0) 0.732 us | } 7238523.797765 | 0) 0.081 us | __fsnotify_parent(); 7238523.797766 | 0) 0.094 us | fsnotify(); 7238523.797766 | 0) 2.711 us | } 7238523.797767 | 0) 3.386 us | } 7238523.797767 | 0) | tty_read() { 7238523.797767 | 0) 0.077 us | tty_paranoia_check(); 7238523.797768 | 0) | tty_ldisc_ref_wait() { 7238523.797768 | 0) 0.083 us | ldsem_down_read(); 7238523.797769 | 0) 0.686 us | } 7238523.797769 | 0) | n_tty_read() { 7238523.797770 | 0) 0.071 us | _raw_spin_lock_irq(); 7238523.797770 | 0) 0.111 us | mutex_lock_interruptible(); 7238523.797771 | 0) 0.072 us | down_read(); 7238523.797771 | 0) | add_wait_queue() { 7238523.797772 | 0) 0.083 us | _raw_spin_lock_irqsave(); 7238523.797772 | 0) 0.085 us | _raw_spin_unlock_irqrestore(); 7238523.797773 | 0) 1.124 us | } 7238523.797773 | 0) 0.066 us | tty_hung_up_p(); 7238523.797774 | 0) 0.090 us | n_tty_set_room(); 7238523.797774 | 0) 0.064 us | up_read(); 7238523.797775 | 0) | schedule_timeout() { 7238523.797775 | 0) | schedule() { 7238523.797775 | 0) | __schedule() { 7238523.797776 | 0) 0.083 us | rcu_note_context_switch(); 7238523.797776 | 0) 0.078 us | _raw_spin_lock_irq(); 7238523.797777 | 0) | deactivate_task() { 7238523.797777 | 0) | dequeue_task() { 7238523.797777 | 0) 0.191 us | update_rq_clock(); 7238523.797778 | 0) | dequeue_task_fair() { 7238523.797778 | 0) | dequeue_entity() { 7238523.797779 | 0) | update_curr() { 7238523.797779 | 0) 0.179 us | cpuacct_charge(); 7238523.797780 | 0) 0.902 us | } 7238523.797780 | 0) 0.070 us | __update_entity_load_avg_contrib(); 7238523.797781 | 0) 0.152 us | update_cfs_rq_blocked_load(); 7238523.797781 | 0) 0.073 us | clear_buddies(); 7238523.797782 | 0) 0.074 us | account_entity_dequeue(); 7238523.797783 | 0) | update_cfs_shares() { 7238523.797783 | 0) 0.111 us | update_curr(); 7238523.797783 | 0) 0.082 us | account_entity_dequeue(); 7238523.797784 | 0) 0.081 us | account_entity_enqueue(); 7238523.797785 | 0) 2.330 us | } 7238523.797785 | 0) 6.633 us | } /* dequeue_entity */ 7238523.797786 | 0) | dequeue_entity() { 7238523.797786 | 0) 0.078 us | update_curr(); 7238523.797787 | 0) 0.086 us | update_cfs_rq_blocked_load(); 7238523.797787 | 0) 0.076 us | clear_buddies(); 7238523.797788 | 0) 0.079 us | account_entity_dequeue(); 7238523.797789 | 0) 0.074 us | update_cfs_shares(); 7238523.797789 | 0) 3.287 us | } 7238523.797789 | 0) 0.074 us | hrtick_update(); 7238523.797790 | 0) 11.606 us | } 7238523.797790 | 0) 12.879 us | } 7238523.797790 | 0) 13.406 us | } 7238523.797791 | 0) | pick_next_task_fair() { 7238523.797791 | 0) 0.073 us | check_cfs_rq_runtime(); 7238523.797792 | 0) | pick_next_entity() { 7238523.797792 | 0) 0.076 us | clear_buddies(); 7238523.797793 | 0) 0.663 us | } 7238523.797793 | 0) | put_prev_entity() { 7238523.797793 | 0) 0.076 us | check_cfs_rq_runtime(); 7238523.797794 | 0) 0.598 us | } 7238523.797794 | 0) | put_prev_entity() { 7238523.797794 | 0) 0.078 us | check_cfs_rq_runtime(); 7238523.797795 | 0) 0.618 us | } 7238523.797795 | 0) | set_next_entity() { 7238523.797795 | 0) 0.096 us | update_stats_wait_end(); 7238523.797796 | 0) 0.738 us | } 7238523.797796 | 0) 5.222 us | } 7238523.797797 | 0) 0.078 us | paravirt_start_context_switch(); 7238523.797798 | 0) 0.071 us | xen_read_cr0(); 7238523.797799 | 0) | xen_write_cr0() { 7238523.797799 | 0) 0.078 us | paravirt_get_lazy_mode(); 7238523.797800 | 0) 0.084 us | __xen_mc_entry(); 7238523.797800 | 0) 0.076 us | paravirt_get_lazy_mode(); 7238523.797801 | 0) 1.798 us | } 7238523.797801 | 0) | xen_load_sp0() { 7238523.797801 | 0) 0.080 us | paravirt_get_lazy_mode(); 7238523.797802 | 0) 0.076 us | __xen_mc_entry(); 7238523.797802 | 0) 0.073 us | paravirt_get_lazy_mode(); 7238523.797803 | 0) 1.623 us | } 7238523.797803 | 0) | xen_load_tls() { 7238523.797803 | 0) 0.082 us | paravirt_get_lazy_mode(); 7238523.797804 | 0) 0.084 us | paravirt_get_lazy_mode(); 7238523.797804 | 0) 0.136 us | load_TLS_descriptor(); 7238523.797805 | 0) 0.072 us | load_TLS_descriptor(); 7238523.797806 | 0) 0.080 us | load_TLS_descriptor(); 7238523.797806 | 0) 0.088 us | paravirt_get_lazy_mode(); 7238523.797807 | 0) 3.360 us | } 7238523.797807 | 0) | xen_end_context_switch() { 7238523.797807 | 0) 0.601 us | xen_mc_flush(); 7238523.797808 | 0) 0.098 us | paravirt_end_context_switch(); 7238523.797809 | 0) 1.902 us | } 7238524.005649 | 0) | finish_task_switch() { 7238524.005653 | 0) | xen_evtchn_do_upcall() { 7238524.005653 | 0) | irq_enter() { 7238524.005653 | 0) 0.138 us | rcu_irq_enter(); 7238524.005654 | 0) 0.753 us | } 7238524.005654 | 0) 0.056 us | exit_idle(); 7238524.005655 | 0) | __xen_evtchn_do_upcall() { 7238524.005655 | 0) | evtchn_2l_handle_events() { 7238524.005655 | 0) 0.057 us | irq_from_virq(); 7238524.005656 | 0) | evtchn_from_irq() { 7238524.005656 | 0) | irq_get_irq_data() { 7238524.005656 | 0) 0.050 us | irq_to_desc(); 7238524.005656 | 0) 0.499 us | } 7238524.005657 | 0) 0.958 us | } 7238524.005657 | 0) | get_evtchn_to_irq() { 7238524.005657 | 0) 0.057 us | evtchn_2l_max_channels(); 7238524.005658 | 0) 0.400 us | } 7238524.005659 | 0) | generic_handle_irq() { 7238524.005659 | 0) 0.052 us | irq_to_desc(); 7238524.005659 | 0) | handle_percpu_irq() { 7238524.005659 | 0) | ack_dynirq() { 7238524.005659 | 0) | evtchn_from_irq() { 7238524.005660 | 0) | irq_get_irq_data() { 7238524.005660 | 0) 0.056 us | irq_to_desc(); 7238524.005660 | 0) 0.439 us | } 7238524.005660 | 0) 0.739 us | } 7238524.005661 | 0) 0.051 us | irq_move_irq(); 7238524.005661 | 0) 0.051 us | evtchn_2l_clear_pending(); 7238524.005661 | 0) 1.963 us | } 7238524.005662 | 0) | handle_irq_event_percpu() { 7238524.005662 | 0) | xen_irq_work_interrupt() { 7238524.005662 | 0) | irq_enter() { 7238524.005662 | 0) 0.053 us | rcu_irq_enter(); 7238524.005663 | 0) 0.392 us | } 7238524.005663 | 0) | __wake_up() { 7238524.005663 | 0) 0.058 us | _raw_spin_lock_irqsave(); 7238524.005664 | 0) | __wake_up_common() { 7238524.005664 | 0) | autoremove_wake_function() { 7238524.005664 | 0) | default_wake_function() { 7238524.005665 | 0) | try_to_wake_up() { 7238524.005665 | 0) 0.226 us | _raw_spin_lock_irqsave(); 7238524.005665 | 0) 0.392 us | task_waking_fair(); 7238524.005666 | 0) | select_task_rq_fair() { 7238524.005666 | 0) 0.067 us | source_load(); 7238524.005667 | 0) 0.057 us | target_load(); 7238524.005667 | 0) 0.065 us | idle_cpu(); 7238524.005668 | 0) 0.050 us | cpus_share_cache(); 7238524.005668 | 0) 0.080 us | idle_cpu(); 7238524.005668 | 0) 2.053 us | } 7238524.005669 | 0) 0.051 us | _raw_spin_lock(); 7238524.005669 | 0) | ttwu_do_activate.constprop.124() { 7238524.005669 | 0) | activate_task() { 7238524.005669 | 0) | enqueue_task() { 7238524.005669 | 0) 0.165 us | update_rq_clock(); 7238524.005670 | 0) | enqueue_task_fair() { 7238524.005670 | 0) | enqueue_entity() { 7238524.005670 | 0) 0.065 us | update_curr(); 7238524.005671 | 0) 0.078 us | __compute_runnable_contrib.part.51(); 7238524.005671 | 0) 0.070 us | __update_entity_load_avg_contrib(); 7238524.005671 | 0) 0.051 us | update_cfs_rq_blocked_load(); 7238524.005672 | 0) 0.069 us | account_entity_enqueue(); 7238524.005672 | 0) 0.132 us | update_cfs_shares(); 7238524.005673 | 0) 0.054 us | place_entity(); 7238524.005673 | 0) 0.081 us | __enqueue_entity(); 7238524.005673 | 0) 3.111 us | } 7238524.005673 | 0) | enqueue_entity() { 7238524.005674 | 0) 0.059 us | update_curr(); 7238524.005674 | 0) 0.057 us | update_cfs_rq_blocked_load(); 7238524.005674 | 0) 0.067 us | account_entity_enqueue(); 7238524.005675 | 0) 0.082 us | update_cfs_shares(); 7238524.005675 | 0) 0.120 us | place_entity(); 7238524.005675 | 0) 0.051 us | __enqueue_entity(); 7238524.005676 | 0) 2.075 us | } 7238524.005676 | 0) 0.049 us | hrtick_update(); 7238524.005676 | 0) 6.167 us | } 7238524.005676 | 0) 6.979 us | } 7238524.005676 | 0) 7.317 us | } 7238524.005677 | 0) | ttwu_do_wakeup() { 7238524.005677 | 0) | check_preempt_curr() { 7238524.005677 | 0) | resched_task() { 7238524.005677 | 0) | xen_smp_send_reschedule() { 7238524.005677 | 0) | xen_send_IPI_one() { 7238524.005678 | 0) | notify_remote_via_irq() { 7238524.005678 | 0) | evtchn_from_irq() { 7238524.005678 | 0) | irq_get_irq_data() { 7238524.005678 | 0) 0.051 us | irq_to_desc(); 7238524.005679 | 0) 0.545 us | } 7238524.005679 | 0) 0.910 us | } 7238524.005680 | 0) 1.962 us | } /* notify_remote_via_irq */ 7238524.005680 | 0) 2.332 us | } 7238524.005680 | 0) 2.684 us | } 7238524.005681 | 0) 3.606 us | } 7238524.005681 | 0) 4.064 us | } 7238524.005682 | 0) 5.129 us | } 7238524.005682 | 0) 13.194 us | } 7238524.005683 | 0) 0.066 us | _raw_spin_unlock(); 7238524.005683 | 0) 0.165 us | ttwu_stat(); 7238524.005684 | 0) 0.070 us | _raw_spin_unlock_irqrestore(); 7238524.005684 | 0) 19.634 us | } 7238524.005685 | 0) 20.080 us | } 7238524.005685 | 0) 20.608 us | } 7238524.005685 | 0) 21.348 us | } 7238524.005685 | 0) 0.084 us | _raw_spin_unlock_irqrestore(); 7238524.005686 | 0) 22.728 us | } 7238524.005686 | 0) | irq_exit() { 7238524.005687 | 0) 0.077 us | idle_cpu(); 7238524.005687 | 0) 0.093 us | rcu_irq_exit(); 7238524.005688 | 0) 1.101 us | } 7238524.005688 | 0) 25.644 us | } 7238524.005688 | 0) 0.138 us | add_interrupt_randomness(); 7238524.005689 | 0) 0.083 us | note_interrupt(); 7238524.005689 | 0) 27.672 us | } 7238524.005690 | 0) 30.410 us | } 7238524.005690 | 0) 31.458 us | } 7238524.005690 | 0) 35.276 us | } 7238524.005691 | 0) 35.797 us | } 7238524.005691 | 0) | irq_exit() { 7238524.005691 | 0) 0.066 us | idle_cpu(); 7238524.005692 | 0) 0.080 us | rcu_irq_exit(); 7238524.005692 | 0) 1.110 us | } 7238524.005693 | 0) 39.440 us | } 7238524.005693 | 0) 41.142 us | } 7238524.005694 | 0) 207918.1 us | } 7238524.005694 | 0) 207918.7 us | } 7238524.005694 | 0) 207919.4 us | } 7238524.005695 | 0) 0.068 us | down_read(); 7238524.005696 | 0) | copy_from_read_buf() { 7238524.005697 | 0) | tty_audit_add_data() { 7238524.005697 | 0) 0.233 us | _raw_spin_lock_irqsave(); 7238524.005698 | 0) 0.076 us | _raw_spin_unlock_irqrestore(); 7238524.005699 | 0) 0.076 us | _raw_spin_lock_irqsave(); 7238524.005699 | 0) 0.078 us | _raw_spin_unlock_irqrestore(); 7238524.005700 | 0) 2.696 us | } 7238524.005700 | 0) 4.335 us | } 7238524.005701 | 0) 0.086 us | copy_from_read_buf(); 7238524.005701 | 0) 0.074 us | n_tty_set_room(); 7238524.005702 | 0) 0.085 us | n_tty_write_wakeup(); 7238524.005702 | 0) | __wake_up() { 7238524.005703 | 0) 0.061 us | _raw_spin_lock_irqsave(); 7238524.005703 | 0) | __wake_up_common() { 7238524.005703 | 0) 0.080 us | pollwake(); 7238524.005704 | 0) 0.687 us | } 7238524.005704 | 0) 0.063 us | _raw_spin_unlock_irqrestore(); 7238524.005705 | 0) 2.040 us | } 7238524.005705 | 0) 0.071 us | n_tty_set_room(); 7238524.005706 | 0) 0.074 us | up_read(); 7238524.005706 | 0) | remove_wait_queue() { 7238524.005706 | 0) 0.074 us | _raw_spin_lock_irqsave(); 7238524.005707 | 0) 0.069 us | _raw_spin_unlock_irqrestore(); 7238524.005707 | 0) 1.076 us | } 7238524.005708 | 0) 0.139 us | mutex_unlock(); 7238524.005708 | 0) 207939.0 us | } 7238524.005709 | 0) | tty_ldisc_deref() { 7238524.005709 | 0) 0.077 us | ldsem_up_read(); 7238524.005710 | 0) 0.702 us | } 7238524.005710 | 0) 0.068 us | get_seconds(); 7238524.005711 | 0) 207943.4 us | } 7238524.005712 | 0) 0.301 us | __fsnotify_parent(); 7238524.005713 | 0) 0.157 us | fsnotify(); 7238524.005713 | 0) 207950.3 us | } 7238524.005783 | 0) | vfs_read() { 7238524.005784 | 0) | rw_verify_area() { 7238524.005784 | 0) | security_file_permission() { 7238524.005785 | 0) | apparmor_file_permission() { 7238524.005785 | 0) 0.164 us | common_file_perm(); 7238524.005786 | 0) 0.790 us | } 7238524.005786 | 0) 0.080 us | __fsnotify_parent(); 7238524.005787 | 0) 0.094 us | fsnotify(); 7238524.005787 | 0) 2.683 us | } 7238524.005788 | 0) 3.313 us | } 7238524.005788 | 0) | tty_read() { 7238524.005788 | 0) 0.087 us | tty_paranoia_check(); 7238524.005789 | 0) | tty_ldisc_ref_wait() { 7238524.005789 | 0) 0.080 us | ldsem_down_read(); 7238524.005790 | 0) 0.683 us | } 7238524.005790 | 0) | n_tty_read() { 7238524.005791 | 0) 0.080 us | _raw_spin_lock_irq(); 7238524.005791 | 0) 0.104 us | mutex_lock_interruptible(); 7238524.005792 | 0) 0.070 us | down_read(); 7238524.005792 | 0) | add_wait_queue() { 7238524.005793 | 0) 0.079 us | _raw_spin_lock_irqsave(); 7238524.005793 | 0) 0.087 us | _raw_spin_unlock_irqrestore(); 7238524.005794 | 0) 1.147 us | } 7238524.005794 | 0) 0.078 us | tty_hung_up_p(); 7238524.005795 | 0) 0.071 us | n_tty_set_room(); 7238524.005795 | 0) 0.077 us | up_read(); 7238524.005796 | 0) | schedule_timeout() { 7238524.005796 | 0) | schedule() { 7238524.005796 | 0) | __schedule() { 7238524.005797 | 0) 0.087 us | rcu_note_context_switch(); 7238524.005797 | 0) 0.075 us | _raw_spin_lock_irq(); 7238524.005798 | 0) | deactivate_task() { 7238524.005798 | 0) | dequeue_task() { 7238524.005798 | 0) 0.177 us | update_rq_clock(); 7238524.005799 | 0) | dequeue_task_fair() { 7238524.005799 | 0) | dequeue_entity() { 7238524.005800 | 0) | update_curr() { 7238524.005800 | 0) 0.334 us | cpuacct_charge(); 7238524.005801 | 0) 1.199 us | } 7238524.005802 | 0) 0.081 us | __update_entity_load_avg_contrib(); 7238524.005802 | 0) 0.064 us | update_cfs_rq_blocked_load(); 7238524.005803 | 0) 0.076 us | clear_buddies(); 7238524.005803 | 0) 0.079 us | account_entity_dequeue(); 7238524.005804 | 0) | update_cfs_shares() { 7238524.005804 | 0) 0.108 us | update_curr(); 7238524.005805 | 0) 0.083 us | account_entity_dequeue(); 7238524.005805 | 0) 0.084 us | account_entity_enqueue(); 7238524.005806 | 0) 1.869 us | } 7238524.005806 | 0) 6.530 us | } /* dequeue_entity */ 7238524.005807 | 0) | dequeue_entity() { 7238524.005807 | 0) 0.104 us | update_curr(); 7238524.005808 | 0) 0.115 us | __update_entity_load_avg_contrib(); 7238524.005808 | 0) 0.069 us | update_cfs_rq_blocked_load(); 7238524.005809 | 0) 0.066 us | clear_buddies(); 7238524.005809 | 0) 0.086 us | account_entity_dequeue(); 7238524.005810 | 0) 0.102 us | update_cfs_shares(); 7238524.005811 | 0) 3.907 us | } 7238524.005811 | 0) 0.071 us | hrtick_update(); 7238524.005812 | 0) 12.301 us | } 7238524.005812 | 0) 13.546 us | } 7238524.005812 | 0) 14.105 us | } 7238524.005812 | 0) | pick_next_task_fair() { 7238524.005813 | 0) 0.078 us | check_cfs_rq_runtime(); 7238524.005813 | 0) | pick_next_entity() { 7238524.005814 | 0) 0.071 us | clear_buddies(); 7238524.005815 | 0) 0.585 us | } 7238524.005815 | 0) | put_prev_entity() { 7238524.005815 | 0) 0.073 us | check_cfs_rq_runtime(); 7238524.005816 | 0) 0.717 us | } 7238524.005816 | 0) | put_prev_entity() { 7238524.005817 | 0) 0.080 us | check_cfs_rq_runtime(); 7238524.005817 | 0) 0.687 us | } 7238524.005817 | 0) | set_next_entity() { 7238524.005818 | 0) 0.091 us | update_stats_wait_end(); 7238524.005818 | 0) 0.786 us | } 7238524.005819 | 0) 6.135 us | } 7238524.005820 | 0) 0.091 us | paravirt_start_context_switch(); 7238524.005821 | 0) 0.089 us | xen_read_cr0(); 7238524.005821 | 0) | xen_write_cr0() { 7238524.005821 | 0) 0.078 us | paravirt_get_lazy_mode(); 7238524.005822 | 0) 0.083 us | __xen_mc_entry(); 7238524.005823 | 0) 0.074 us | paravirt_get_lazy_mode(); 7238524.005823 | 0) 1.657 us | } 7238524.005823 | 0) | xen_load_sp0() { 7238524.005824 | 0) 0.074 us | paravirt_get_lazy_mode(); 7238524.005824 | 0) 0.083 us | __xen_mc_entry(); 7238524.005825 | 0) 0.087 us | paravirt_get_lazy_mode(); 7238524.005825 | 0) 1.764 us | } 7238524.005826 | 0) | xen_load_tls() { 7238524.005826 | 0) 0.077 us | paravirt_get_lazy_mode(); 7238524.005826 | 0) 0.084 us | paravirt_get_lazy_mode(); 7238524.005827 | 0) 0.150 us | load_TLS_descriptor(); 7238524.005828 | 0) 0.082 us | load_TLS_descriptor(); 7238524.005828 | 0) 0.084 us | load_TLS_descriptor(); 7238524.005829 | 0) 0.076 us | paravirt_get_lazy_mode(); 7238524.005829 | 0) 3.388 us | } 7238524.005829 | 0) | xen_end_context_switch() { 7238524.005830 | 0) 0.731 us | xen_mc_flush(); 7238524.005831 | 0) 0.093 us | paravirt_end_context_switch(); 7238524.005831 | 0) 1.836 us | } 7238524.141853 | 0) | finish_task_switch() { 7238524.141857 | 0) | xen_evtchn_do_upcall() { 7238524.141858 | 0) | irq_enter() { 7238524.141858 | 0) 0.133 us | rcu_irq_enter(); 7238524.141859 | 0) 0.766 us | } 7238524.141859 | 0) 0.056 us | exit_idle(); 7238524.141859 | 0) | __xen_evtchn_do_upcall() { 7238524.141859 | 0) | evtchn_2l_handle_events() { 7238524.141860 | 0) 0.049 us | irq_from_virq(); 7238524.141860 | 0) | evtchn_from_irq() { 7238524.141860 | 0) | irq_get_irq_data() { 7238524.141860 | 0) 0.058 us | irq_to_desc(); 7238524.141861 | 0) 0.498 us | } 7238524.141861 | 0) 0.897 us | } 7238524.141861 | 0) | get_evtchn_to_irq() { 7238524.141861 | 0) 0.049 us | evtchn_2l_max_channels(); 7238524.141862 | 0) 0.392 us | } 7238524.141862 | 0) | generic_handle_irq() { 7238524.141862 | 0) 0.061 us | irq_to_desc(); 7238524.141862 | 0) | handle_percpu_irq() { 7238524.141863 | 0) | ack_dynirq() { 7238524.141863 | 0) | evtchn_from_irq() { 7238524.141863 | 0) | irq_get_irq_data() { 7238524.141863 | 0) 0.051 us | irq_to_desc(); 7238524.141863 | 0) 0.439 us | } 7238524.141864 | 0) 0.745 us | } 7238524.141864 | 0) 0.049 us | irq_move_irq(); 7238524.141864 | 0) 0.060 us | evtchn_2l_clear_pending(); 7238524.141864 | 0) 1.714 us | } 7238524.141865 | 0) | handle_irq_event_percpu() { 7238524.141865 | 0) | xen_irq_work_interrupt() { 7238524.141865 | 0) | irq_enter() { 7238524.141865 | 0) 0.053 us | rcu_irq_enter(); 7238524.141866 | 0) 0.371 us | } 7238524.141866 | 0) | __wake_up() { 7238524.141866 | 0) 0.051 us | _raw_spin_lock_irqsave(); 7238524.141867 | 0) | __wake_up_common() { 7238524.141867 | 0) | autoremove_wake_function() { 7238524.141867 | 0) | default_wake_function() { 7238524.141867 | 0) | try_to_wake_up() { 7238524.141868 | 0) 0.213 us | _raw_spin_lock_irqsave(); 7238524.141869 | 0) 0.196 us | task_waking_fair(); 7238524.141870 | 0) | select_task_rq_fair() { 7238524.141870 | 0) 0.051 us | source_load(); 7238524.141870 | 0) 0.049 us | target_load(); 7238524.141871 | 0) 0.065 us | idle_cpu(); 7238524.141871 | 0) 0.051 us | cpus_share_cache(); 7238524.141872 | 0) 0.078 us | idle_cpu(); 7238524.141872 | 0) 2.427 us | } 7238524.141873 | 0) 0.050 us | _raw_spin_lock(); 7238524.141873 | 0) | ttwu_do_activate.constprop.124() { 7238524.141873 | 0) | activate_task() { 7238524.141873 | 0) | enqueue_task() { 7238524.141873 | 0) 0.170 us | update_rq_clock(); 7238524.141874 | 0) | enqueue_task_fair() { 7238524.141874 | 0) | enqueue_entity() { 7238524.141874 | 0) 0.058 us | update_curr(); 7238524.141875 | 0) 0.076 us | __compute_runnable_contrib.part.51(); 7238524.141875 | 0) 0.059 us | __update_entity_load_avg_contrib(); 7238524.141875 | 0) 0.060 us | update_cfs_rq_blocked_load(); 7238524.141876 | 0) 0.064 us | account_entity_enqueue(); 7238524.141876 | 0) 0.123 us | update_cfs_shares(); 7238524.141876 | 0) 0.055 us | place_entity(); 7238524.141877 | 0) 0.078 us | __enqueue_entity(); 7238524.141877 | 0) 3.039 us | } 7238524.141877 | 0) | enqueue_entity() { 7238524.141877 | 0) 0.065 us | update_curr(); 7238524.141878 | 0) 0.050 us | update_cfs_rq_blocked_load(); 7238524.141878 | 0) 0.049 us | account_entity_enqueue(); 7238524.141878 | 0) 0.081 us | update_cfs_shares(); 7238524.141879 | 0) 0.049 us | place_entity(); 7238524.141879 | 0) 0.051 us | __enqueue_entity(); 7238524.141879 | 0) 2.021 us | } 7238524.141880 | 0) 0.049 us | hrtick_update(); 7238524.141880 | 0) 6.040 us | } 7238524.141880 | 0) 6.874 us | } 7238524.141880 | 0) 7.212 us | } 7238524.141880 | 0) | ttwu_do_wakeup() { 7238524.141881 | 0) | check_preempt_curr() { 7238524.141881 | 0) | resched_task() { 7238524.141881 | 0) | xen_smp_send_reschedule() { 7238524.141881 | 0) | xen_send_IPI_one() { 7238524.141881 | 0) | notify_remote_via_irq() { 7238524.141881 | 0) | evtchn_from_irq() { 7238524.141882 | 0) | irq_get_irq_data() { 7238524.141882 | 0) 0.049 us | irq_to_desc(); 7238524.141882 | 0) 0.497 us | } 7238524.141882 | 0) 0.860 us | } 7238524.141883 | 0) 1.882 us | } /* notify_remote_via_irq */ 7238524.141884 | 0) 2.257 us | } 7238524.141884 | 0) 2.619 us | } 7238524.141884 | 0) 3.079 us | } 7238524.141884 | 0) 3.526 us | } 7238524.141885 | 0) 4.485 us | } 7238524.141885 | 0) 12.333 us | } 7238524.141885 | 0) 0.062 us | _raw_spin_unlock(); 7238524.141886 | 0) 0.169 us | ttwu_stat(); 7238524.141887 | 0) 0.076 us | _raw_spin_unlock_irqrestore(); 7238524.141887 | 0) 19.434 us | } 7238524.141887 | 0) 19.909 us | } 7238524.141888 | 0) 20.377 us | } 7238524.141888 | 0) 21.020 us | } 7238524.141888 | 0) 0.075 us | _raw_spin_unlock_irqrestore(); 7238524.141888 | 0) 22.268 us | } 7238524.141889 | 0) | irq_exit() { 7238524.141889 | 0) 0.087 us | idle_cpu(); 7238524.141889 | 0) 0.101 us | rcu_irq_exit(); 7238524.141890 | 0) 1.127 us | } 7238524.141890 | 0) 25.163 us | } 7238524.141891 | 0) 0.133 us | add_interrupt_randomness(); 7238524.141892 | 0) 0.083 us | note_interrupt(); 7238524.141892 | 0) 27.453 us | } 7238524.141893 | 0) 30.024 us | } 7238524.141893 | 0) 30.898 us | } 7238524.141893 | 0) 33.683 us | } 7238524.141893 | 0) 34.097 us | } 7238524.141894 | 0) | irq_exit() { 7238524.141894 | 0) 0.065 us | idle_cpu(); 7238524.141895 | 0) 0.076 us | rcu_irq_exit(); 7238524.141895 | 0) 1.135 us | } 7238524.141895 | 0) 37.746 us | } 7238524.141896 | 0) 39.634 us | } 7238524.141897 | 0) 136100.0 us | } 7238524.141897 | 0) 136100.6 us | } 7238524.141897 | 0) 136101.4 us | } 7238524.141898 | 0) 0.093 us | down_read(); 7238524.141899 | 0) | copy_from_read_buf() { 7238524.141900 | 0) | tty_audit_add_data() { 7238524.141900 | 0) 0.238 us | _raw_spin_lock_irqsave(); 7238524.141901 | 0) 0.069 us | _raw_spin_unlock_irqrestore(); 7238524.141901 | 0) 0.090 us | _raw_spin_lock_irqsave(); 7238524.141902 | 0) 0.077 us | _raw_spin_unlock_irqrestore(); 7238524.141902 | 0) 2.513 us | } 7238524.141903 | 0) 3.632 us | } 7238524.141903 | 0) 0.085 us | copy_from_read_buf(); 7238524.141904 | 0) 0.066 us | n_tty_set_room(); 7238524.141905 | 0) 0.067 us | n_tty_write_wakeup(); 7238524.141905 | 0) | __wake_up() { 7238524.141906 | 0) 0.070 us | _raw_spin_lock_irqsave(); 7238524.141906 | 0) | __wake_up_common() { 7238524.141906 | 0) 0.086 us | pollwake(); 7238524.141907 | 0) 0.620 us | } 7238524.141907 | 0) 0.064 us | _raw_spin_unlock_irqrestore(); 7238524.141907 | 0) 1.980 us | } 7238524.141908 | 0) 0.059 us | n_tty_set_room(); 7238524.141909 | 0) 0.071 us | up_read(); 7238524.141909 | 0) | remove_wait_queue() { 7238524.141909 | 0) 0.079 us | _raw_spin_lock_irqsave(); 7238524.141910 | 0) 0.082 us | _raw_spin_unlock_irqrestore(); 7238524.141910 | 0) 1.164 us | } 7238524.141910 | 0) 0.142 us | mutex_unlock(); 7238524.141911 | 0) 136120.9 us | } 7238524.141911 | 0) | tty_ldisc_deref() { 7238524.141912 | 0) 0.062 us | ldsem_up_read(); 7238524.141912 | 0) 0.593 us | } 7238524.141912 | 0) 0.079 us | get_seconds(); 7238524.141913 | 0) 136125.1 us | } 7238524.141914 | 0) 0.280 us | __fsnotify_parent(); 7238524.141915 | 0) 0.187 us | fsnotify(); 7238524.141915 | 0) 136131.2 us | } 7238524.141988 | 0) | vfs_read() { 7238524.141989 | 0) | rw_verify_area() { 7238524.141989 | 0) | security_file_permission() { 7238524.141989 | 0) | apparmor_file_permission() { 7238524.141990 | 0) 0.149 us | common_file_perm(); 7238524.141990 | 0) 0.774 us | } 7238524.141991 | 0) 0.079 us | __fsnotify_parent(); 7238524.141991 | 0) 0.095 us | fsnotify(); 7238524.141992 | 0) 2.558 us | } 7238524.141992 | 0) 3.300 us | } 7238524.141993 | 0) | tty_read() { 7238524.141993 | 0) 0.076 us | tty_paranoia_check(); 7238524.141994 | 0) | tty_ldisc_ref_wait() { 7238524.141994 | 0) 0.081 us | ldsem_down_read(); 7238524.141995 | 0) 0.689 us | } 7238524.141995 | 0) | n_tty_read() { 7238524.141995 | 0) 0.073 us | _raw_spin_lock_irq(); 7238524.141996 | 0) 0.110 us | mutex_lock_interruptible(); 7238524.141997 | 0) 0.069 us | down_read(); 7238524.141998 | 0) | add_wait_queue() { 7238524.141998 | 0) 0.079 us | _raw_spin_lock_irqsave(); 7238524.141999 | 0) 0.078 us | _raw_spin_unlock_irqrestore(); 7238524.141999 | 0) 1.201 us | } 7238524.142000 | 0) 0.067 us | tty_hung_up_p(); 7238524.142000 | 0) 0.078 us | n_tty_set_room(); 7238524.142001 | 0) 0.079 us | up_read(); 7238524.142001 | 0) | schedule_timeout() { 7238524.142002 | 0) | schedule() { 7238524.142002 | 0) | __schedule() { 7238524.142002 | 0) 0.076 us | rcu_note_context_switch(); 7238524.142003 | 0) 0.080 us | _raw_spin_lock_irq(); 7238524.142004 | 0) | deactivate_task() { 7238524.142004 | 0) | dequeue_task() { 7238524.142004 | 0) 0.178 us | update_rq_clock(); 7238524.142005 | 0) | dequeue_task_fair() { 7238524.142005 | 0) | dequeue_entity() { 7238524.142005 | 0) | update_curr() { 7238524.142006 | 0) 0.263 us | cpuacct_charge(); 7238524.142007 | 0) 0.965 us | } 7238524.142007 | 0) 0.075 us | update_cfs_rq_blocked_load(); 7238524.142008 | 0) 0.065 us | clear_buddies(); 7238524.142008 | 0) 0.084 us | account_entity_dequeue(); 7238524.142009 | 0) | update_cfs_shares() { 7238524.142009 | 0) 0.115 us | update_curr(); 7238524.142010 | 0) 0.084 us | account_entity_dequeue(); 7238524.142010 | 0) 0.068 us | account_entity_enqueue(); 7238524.142011 | 0) 1.754 us | } 7238524.142011 | 0) 5.580 us | } 7238524.142012 | 0) | dequeue_entity() { 7238524.142012 | 0) 0.089 us | update_curr(); 7238524.142012 | 0) 0.101 us | update_cfs_rq_blocked_load(); 7238524.142013 | 0) 0.076 us | clear_buddies(); 7238524.142013 | 0) 0.078 us | account_entity_dequeue(); 7238524.142014 | 0) 0.076 us | update_cfs_shares(); 7238524.142015 | 0) 3.071 us | } 7238524.142015 | 0) 0.078 us | hrtick_update(); 7238524.142016 | 0) 10.525 us | } 7238524.142016 | 0) 11.803 us | } 7238524.142016 | 0) 12.447 us | } 7238524.142017 | 0) | pick_next_task_fair() { 7238524.142017 | 0) 0.069 us | check_cfs_rq_runtime(); 7238524.142017 | 0) | pick_next_entity() { 7238524.142018 | 0) 0.061 us | clear_buddies(); 7238524.142018 | 0) 0.601 us | } 7238524.142019 | 0) | put_prev_entity() { 7238524.142019 | 0) 0.069 us | check_cfs_rq_runtime(); 7238524.142019 | 0) 0.605 us | } 7238524.142020 | 0) | put_prev_entity() { 7238524.142020 | 0) 0.076 us | check_cfs_rq_runtime(); 7238524.142020 | 0) 0.609 us | } 7238524.142021 | 0) | set_next_entity() { 7238524.142021 | 0) 0.088 us | update_stats_wait_end(); 7238524.142022 | 0) 0.768 us | } 7238524.142022 | 0) 5.183 us | } 7238524.142023 | 0) 0.080 us | paravirt_start_context_switch(); 7238524.142024 | 0) 0.076 us | xen_read_cr0(); 7238524.142024 | 0) | xen_write_cr0() { 7238524.142025 | 0) 0.088 us | paravirt_get_lazy_mode(); 7238524.142025 | 0) 0.096 us | __xen_mc_entry(); 7238524.142026 | 0) 0.083 us | paravirt_get_lazy_mode(); 7238524.142026 | 0) 1.802 us | } 7238524.142026 | 0) | xen_load_sp0() { 7238524.142027 | 0) 0.074 us | paravirt_get_lazy_mode(); 7238524.142027 | 0) 0.098 us | __xen_mc_entry(); 7238524.142028 | 0) 0.073 us | paravirt_get_lazy_mode(); 7238524.142029 | 0) 2.289 us | } 7238524.142029 | 0) | xen_load_tls() { 7238524.142029 | 0) 0.073 us | paravirt_get_lazy_mode(); 7238524.142030 | 0) 0.079 us | paravirt_get_lazy_mode(); 7238524.142031 | 0) 0.135 us | load_TLS_descriptor(); 7238524.142031 | 0) 0.082 us | load_TLS_descriptor(); 7238524.142032 | 0) 0.091 us | load_TLS_descriptor(); 7238524.142032 | 0) 0.081 us | paravirt_get_lazy_mode(); 7238524.142033 | 0) 3.306 us | } 7238524.142033 | 0) | xen_end_context_switch() { 7238524.142033 | 0) 0.697 us | xen_mc_flush(); 7238524.142034 | 0) 0.083 us | paravirt_end_context_switch(); 7238524.142035 | 0) 1.876 us | } 7238524.269404 | 0) | finish_task_switch() { 7238524.269408 | 0) | xen_evtchn_do_upcall() { 7238524.269408 | 0) | irq_enter() { 7238524.269408 | 0) 0.132 us | rcu_irq_enter(); 7238524.269409 | 0) 0.948 us | } 7238524.269409 | 0) 0.063 us | exit_idle(); 7238524.269410 | 0) | __xen_evtchn_do_upcall() { 7238524.269410 | 0) | evtchn_2l_handle_events() { 7238524.269410 | 0) 0.057 us | irq_from_virq(); 7238524.269411 | 0) | evtchn_from_irq() { 7238524.269411 | 0) | irq_get_irq_data() { 7238524.269411 | 0) 0.058 us | irq_to_desc(); 7238524.269412 | 0) 0.579 us | } 7238524.269412 | 0) 0.898 us | } 7238524.269412 | 0) | get_evtchn_to_irq() { 7238524.269412 | 0) 0.049 us | evtchn_2l_max_channels(); 7238524.269412 | 0) 0.390 us | } 7238524.269413 | 0) | generic_handle_irq() { 7238524.269413 | 0) 0.051 us | irq_to_desc(); 7238524.269413 | 0) | handle_percpu_irq() { 7238524.269413 | 0) | ack_dynirq() { 7238524.269413 | 0) | evtchn_from_irq() { 7238524.269414 | 0) | irq_get_irq_data() { 7238524.269414 | 0) 0.057 us | irq_to_desc(); 7238524.269414 | 0) 0.446 us | } 7238524.269414 | 0) 0.754 us | } 7238524.269414 | 0) 0.057 us | irq_move_irq(); 7238524.269415 | 0) 0.057 us | evtchn_2l_clear_pending(); 7238524.269415 | 0) 1.718 us | } 7238524.269415 | 0) | handle_irq_event_percpu() { 7238524.269416 | 0) | xen_irq_work_interrupt() { 7238524.269416 | 0) | irq_enter() { 7238524.269416 | 0) 0.059 us | rcu_irq_enter(); 7238524.269416 | 0) 0.380 us | } 7238524.269417 | 0) | __wake_up() { 7238524.269417 | 0) 0.051 us | _raw_spin_lock_irqsave(); 7238524.269417 | 0) | __wake_up_common() { 7238524.269417 | 0) | autoremove_wake_function() { 7238524.269418 | 0) | default_wake_function() { 7238524.269418 | 0) | try_to_wake_up() { 7238524.269418 | 0) 0.230 us | _raw_spin_lock_irqsave(); 7238524.269419 | 0) 0.197 us | task_waking_fair(); 7238524.269419 | 0) | select_task_rq_fair() { 7238524.269419 | 0) 0.050 us | source_load(); 7238524.269420 | 0) 0.057 us | target_load(); 7238524.269420 | 0) 0.065 us | idle_cpu(); 7238524.269421 | 0) 0.055 us | cpus_share_cache(); 7238524.269421 | 0) 0.076 us | idle_cpu(); 7238524.269421 | 0) 2.041 us | } 7238524.269422 | 0) 0.050 us | _raw_spin_lock(); 7238524.269422 | 0) | ttwu_do_activate.constprop.124() { 7238524.269422 | 0) | activate_task() { 7238524.269422 | 0) | enqueue_task() { 7238524.269422 | 0) 0.175 us | update_rq_clock(); 7238524.269423 | 0) | enqueue_task_fair() { 7238524.269423 | 0) | enqueue_entity() { 7238524.269423 | 0) 0.065 us | update_curr(); 7238524.269424 | 0) 0.070 us | __compute_runnable_contrib.part.51(); 7238524.269424 | 0) 0.052 us | __update_entity_load_avg_contrib(); 7238524.269424 | 0) 0.050 us | update_cfs_rq_blocked_load(); 7238524.269425 | 0) 0.059 us | account_entity_enqueue(); 7238524.269426 | 0) 0.134 us | update_cfs_shares(); 7238524.269426 | 0) 0.055 us | place_entity(); 7238524.269427 | 0) 0.083 us | __enqueue_entity(); 7238524.269427 | 0) 4.026 us | } 7238524.269427 | 0) | enqueue_entity() { 7238524.269428 | 0) 0.065 us | update_curr(); 7238524.269428 | 0) 0.051 us | update_cfs_rq_blocked_load(); 7238524.269428 | 0) 0.058 us | account_entity_enqueue(); 7238524.269429 | 0) 0.082 us | update_cfs_shares(); 7238524.269429 | 0) 0.105 us | place_entity(); 7238524.269429 | 0) 0.049 us | __enqueue_entity(); 7238524.269430 | 0) 2.247 us | } 7238524.269430 | 0) 0.050 us | hrtick_update(); 7238524.269430 | 0) 7.310 us | } 7238524.269430 | 0) 8.101 us | } 7238524.269431 | 0) 8.449 us | } 7238524.269431 | 0) | ttwu_do_wakeup() { 7238524.269431 | 0) | check_preempt_curr() { 7238524.269431 | 0) | resched_task() { 7238524.269431 | 0) | xen_smp_send_reschedule() { 7238524.269432 | 0) | xen_send_IPI_one() { 7238524.269432 | 0) | notify_remote_via_irq() { 7238524.269432 | 0) | evtchn_from_irq() { 7238524.269432 | 0) | irq_get_irq_data() { 7238524.269432 | 0) 0.051 us | irq_to_desc(); 7238524.269433 | 0) 0.493 us | } 7238524.269433 | 0) 0.857 us | } 7238524.269434 | 0) 1.909 us | } /* notify_remote_via_irq */ 7238524.269434 | 0) 2.288 us | } 7238524.269434 | 0) 2.655 us | } 7238524.269434 | 0) 3.127 us | } 7238524.269435 | 0) 3.590 us | } 7238524.269435 | 0) 4.506 us | } 7238524.269436 | 0) 13.594 us | } 7238524.269436 | 0) 0.070 us | _raw_spin_unlock(); 7238524.269436 | 0) 0.163 us | ttwu_stat(); 7238524.269437 | 0) 0.080 us | _raw_spin_unlock_irqrestore(); 7238524.269438 | 0) 19.508 us | } 7238524.269438 | 0) 19.991 us | } 7238524.269438 | 0) 20.486 us | } 7238524.269438 | 0) 21.024 us | } 7238524.269438 | 0) 0.076 us | _raw_spin_unlock_irqrestore(); 7238524.269439 | 0) 22.247 us | } 7238524.269439 | 0) | irq_exit() { 7238524.269439 | 0) 0.101 us | idle_cpu(); 7238524.269440 | 0) 0.099 us | rcu_irq_exit(); 7238524.269441 | 0) 1.207 us | } 7238524.269441 | 0) 25.035 us | } 7238524.269441 | 0) 0.131 us | add_interrupt_randomness(); 7238524.269442 | 0) 0.076 us | note_interrupt(); 7238524.269442 | 0) 26.909 us | } 7238524.269443 | 0) 29.377 us | } 7238524.269443 | 0) 30.139 us | } 7238524.269443 | 0) 32.759 us | } 7238524.269443 | 0) 33.204 us | } 7238524.269444 | 0) | irq_exit() { 7238524.269444 | 0) | __do_softirq() { 7238524.269444 | 0) 0.068 us | msecs_to_jiffies(); 7238524.269445 | 0) | rcu_process_callbacks() { 7238524.269445 | 0) 0.070 us | note_gp_changes(); 7238524.269445 | 0) 0.064 us | _raw_spin_lock_irqsave(); 7238524.269446 | 0) 0.135 us | rcu_accelerate_cbs(); 7238524.269447 | 0) | rcu_report_qs_rnp() { 7238524.269447 | 0) 0.061 us | _raw_spin_unlock_irqrestore(); 7238524.269448 | 0) 0.779 us | } 7238524.269448 | 0) 0.081 us | cpu_needs_another_gp(); 7238524.269449 | 0) | file_free_rcu() { 7238524.269449 | 0) 0.291 us | kmem_cache_free(); 7238524.269450 | 0) 1.139 us | } 7238524.269451 | 0) | put_cred_rcu() { 7238524.269451 | 0) | security_cred_free() { 7238524.269452 | 0) | apparmor_cred_free() { 7238524.269453 | 0) | aa_free_task_context() { 7238524.269453 | 0) | kzfree() { 7238524.269454 | 0) 0.380 us | ksize(); 7238524.269455 | 0) 0.147 us | kfree(); 7238524.269455 | 0) 1.602 us | } 7238524.269455 | 0) 2.631 us | } 7238524.269456 | 0) 3.611 us | } /* apparmor_cred_free */ 7238524.269456 | 0) 4.927 us | } 7238524.269457 | 0) 0.071 us | key_put(); 7238524.269457 | 0) 0.071 us | key_put(); 7238524.269458 | 0) 0.065 us | key_put(); 7238524.269458 | 0) 0.066 us | key_put(); 7238524.269459 | 0) 0.390 us | free_uid(); 7238524.269460 | 0) 0.178 us | kmem_cache_free(); 7238524.269460 | 0) 9.429 us | } 7238524.269461 | 0) 0.099 us | note_gp_changes(); 7238524.269461 | 0) 0.080 us | cpu_needs_another_gp(); 7238524.269462 | 0) 16.796 us | } 7238524.269462 | 0) 0.068 us | rcu_bh_qs(); 7238524.269462 | 0) 0.066 us | __local_bh_enable(); 7238524.269463 | 0) 18.770 us | } 7238524.269463 | 0) 0.073 us | idle_cpu(); 7238524.269464 | 0) 0.088 us | rcu_irq_exit(); 7238524.269464 | 0) 20.487 us | } 7238524.269465 | 0) 56.365 us | } 7238524.269465 | 0) 58.028 us | } 7238524.269466 | 0) 127463.5 us | } 7238524.269466 | 0) 127464.2 us | } 7238524.269467 | 0) 127465.0 us | } 7238524.269467 | 0) 0.095 us | down_read(); 7238524.269468 | 0) | copy_from_read_buf() { 7238524.269469 | 0) | tty_audit_add_data() { 7238524.269469 | 0) 0.228 us | _raw_spin_lock_irqsave(); 7238524.269470 | 0) 0.070 us | _raw_spin_unlock_irqrestore(); 7238524.269471 | 0) 0.074 us | _raw_spin_lock_irqsave(); 7238524.269471 | 0) 0.079 us | _raw_spin_unlock_irqrestore(); 7238524.269472 | 0) 2.616 us | } 7238524.269472 | 0) 3.878 us | } 7238524.269473 | 0) 0.104 us | copy_from_read_buf(); 7238524.269473 | 0) 0.074 us | n_tty_set_room(); 7238524.269474 | 0) 0.067 us | n_tty_write_wakeup(); 7238524.269474 | 0) | __wake_up() { 7238524.269475 | 0) 0.077 us | _raw_spin_lock_irqsave(); 7238524.269475 | 0) | __wake_up_common() { 7238524.269476 | 0) 0.095 us | pollwake(); 7238524.269476 | 0) 0.694 us | } 7238524.269476 | 0) 0.064 us | _raw_spin_unlock_irqrestore(); 7238524.269477 | 0) 2.128 us | } 7238524.269477 | 0) 0.062 us | n_tty_set_room(); 7238524.269477 | 0) 0.066 us | up_read(); 7238524.269478 | 0) | remove_wait_queue() { 7238524.269478 | 0) 0.080 us | _raw_spin_lock_irqsave(); 7238524.269479 | 0) 0.081 us | _raw_spin_unlock_irqrestore(); 7238524.269480 | 0) 1.225 us | } 7238524.269480 | 0) 0.152 us | mutex_unlock(); 7238524.269480 | 0) 127485.3 us | } 7238524.269481 | 0) | tty_ldisc_deref() { 7238524.269481 | 0) 0.081 us | ldsem_up_read(); 7238524.269482 | 0) 0.655 us | } 7238524.269482 | 0) 0.089 us | get_seconds(); 7238524.269483 | 0) 127490.1 us | } 7238524.269484 | 0) 0.287 us | __fsnotify_parent(); 7238524.269484 | 0) 0.183 us | fsnotify(); 7238524.269485 | 0) 127496.2 us | } 7238524.269559 | 0) | vfs_read() { 7238524.269559 | 0) | rw_verify_area() { 7238524.269560 | 0) | security_file_permission() { 7238524.269560 | 0) | apparmor_file_permission() { 7238524.269561 | 0) 0.164 us | common_file_perm(); 7238524.269561 | 0) 0.831 us | } 7238524.269562 | 0) 0.078 us | __fsnotify_parent(); 7238524.269562 | 0) 0.080 us | fsnotify(); 7238524.269563 | 0) 2.765 us | } 7238524.269563 | 0) 3.490 us | } 7238524.269564 | 0) | tty_read() { 7238524.269564 | 0) 0.066 us | tty_paranoia_check(); 7238524.269564 | 0) | tty_ldisc_ref_wait() { 7238524.269565 | 0) 0.085 us | ldsem_down_read(); 7238524.269565 | 0) 0.656 us | } 7238524.269566 | 0) | n_tty_read() { 7238524.269566 | 0) 0.078 us | _raw_spin_lock_irq(); 7238524.269567 | 0) 0.118 us | mutex_lock_interruptible(); 7238524.269567 | 0) 0.078 us | down_read(); 7238524.269568 | 0) | add_wait_queue() { 7238524.269568 | 0) 0.089 us | _raw_spin_lock_irqsave(); 7238524.269569 | 0) 0.082 us | _raw_spin_unlock_irqrestore(); 7238524.269569 | 0) 1.164 us | } 7238524.269570 | 0) 0.073 us | tty_hung_up_p(); 7238524.269570 | 0) 0.076 us | n_tty_set_room(); 7238524.269571 | 0) 0.078 us | up_read(); 7238524.269571 | 0) | schedule_timeout() { 7238524.269572 | 0) | schedule() { 7238524.269572 | 0) | __schedule() { 7238524.269572 | 0) 0.078 us | rcu_note_context_switch(); 7238524.269573 | 0) 0.085 us | _raw_spin_lock_irq(); 7238524.269574 | 0) | deactivate_task() { 7238524.269574 | 0) | dequeue_task() { 7238524.269574 | 0) 0.185 us | update_rq_clock(); 7238524.269575 | 0) | dequeue_task_fair() { 7238524.269575 | 0) | dequeue_entity() { 7238524.269575 | 0) | update_curr() { 7238524.269576 | 0) 0.206 us | cpuacct_charge(); 7238524.269577 | 0) 0.937 us | } 7238524.269577 | 0) 0.084 us | __update_entity_load_avg_contrib(); 7238524.269577 | 0) 0.077 us | update_cfs_rq_blocked_load(); 7238524.269578 | 0) 0.075 us | clear_buddies(); 7238524.269579 | 0) 0.096 us | account_entity_dequeue(); 7238524.269579 | 0) | update_cfs_shares() { 7238524.269580 | 0) 0.095 us | update_curr(); 7238524.269580 | 0) 0.104 us | account_entity_dequeue(); 7238524.269581 | 0) 0.076 us | account_entity_enqueue(); 7238524.269581 | 0) 1.898 us | } 7238524.269582 | 0) 6.120 us | } 7238524.269582 | 0) | dequeue_entity() { 7238524.269582 | 0) 0.093 us | update_curr(); 7238524.269583 | 0) 0.116 us | __update_entity_load_avg_contrib(); 7238524.269583 | 0) 0.085 us | update_cfs_rq_blocked_load(); 7238524.269584 | 0) 0.067 us | clear_buddies(); 7238524.269585 | 0) 0.082 us | account_entity_dequeue(); 7238524.269585 | 0) 0.097 us | update_cfs_shares(); 7238524.269586 | 0) 3.833 us | } 7238524.269586 | 0) 0.070 us | hrtick_update(); 7238524.269587 | 0) 11.677 us | } 7238524.269587 | 0) 13.001 us | } 7238524.269587 | 0) 13.516 us | } 7238524.269588 | 0) | pick_next_task_fair() { 7238524.269588 | 0) 0.072 us | check_cfs_rq_runtime(); 7238524.269588 | 0) | pick_next_entity() { 7238524.269589 | 0) 0.080 us | clear_buddies(); 7238524.269589 | 0) 0.675 us | } 7238524.269590 | 0) | put_prev_entity() { 7238524.269590 | 0) 0.071 us | check_cfs_rq_runtime(); 7238524.269591 | 0) 0.543 us | } 7238524.269591 | 0) | put_prev_entity() { 7238524.269591 | 0) 0.066 us | check_cfs_rq_runtime(); 7238524.269592 | 0) 0.658 us | } 7238524.269592 | 0) | set_next_entity() { 7238524.269593 | 0) 0.082 us | update_stats_wait_end(); 7238524.269593 | 0) 0.844 us | } 7238524.269594 | 0) 5.970 us | } 7238524.269594 | 0) 0.076 us | paravirt_start_context_switch(); 7238524.269595 | 0) 0.074 us | xen_read_cr0(); 7238524.269596 | 0) | xen_write_cr0() { 7238524.269597 | 0) 0.081 us | paravirt_get_lazy_mode(); 7238524.269597 | 0) 0.086 us | __xen_mc_entry(); 7238524.269598 | 0) 0.070 us | paravirt_get_lazy_mode(); 7238524.269598 | 0) 1.739 us | } 7238524.269598 | 0) | xen_load_sp0() { 7238524.269599 | 0) 0.078 us | paravirt_get_lazy_mode(); 7238524.269599 | 0) 0.078 us | __xen_mc_entry(); 7238524.269600 | 0) 0.069 us | paravirt_get_lazy_mode(); 7238524.269600 | 0) 1.568 us | } 7238524.269601 | 0) | xen_load_tls() { 7238524.269601 | 0) 0.068 us | paravirt_get_lazy_mode(); 7238524.269601 | 0) 0.068 us | paravirt_get_lazy_mode(); 7238524.269602 | 0) 0.078 us | load_TLS_descriptor(); 7238524.269602 | 0) 0.071 us | load_TLS_descriptor(); 7238524.269603 | 0) 0.073 us | load_TLS_descriptor(); 7238524.269603 | 0) 0.063 us | paravirt_get_lazy_mode(); 7238524.269604 | 0) 3.025 us | } 7238524.269604 | 0) | xen_end_context_switch() { 7238524.269604 | 0) 0.646 us | xen_mc_flush(); 7238524.269605 | 0) 0.087 us | paravirt_end_context_switch(); 7238524.269606 | 0) 1.604 us | } ^C Ending tracing... If you read through the durations carefully, you can see that the shell begins by completing a 19 second read (time between commands), then has a series of 100 to 200 ms reads (inter-keystroke latency). The function times printed are inclusive of their children. The -C option will print on-CPU times only, excluding sleeping or blocking events from the function duration times. Eg: # ./funcgraph -Ctp 25285 vfs_read Tracing "vfs_read" for PID 25285... Ctrl-C to end. 7338520.591816 | 0) | finish_task_switch() { 7338520.591820 | 0) | xen_evtchn_do_upcall() { 7338520.591821 | 0) | irq_enter() { 7338520.591821 | 0) 0.134 us | rcu_irq_enter(); 7338520.591822 | 0) 0.823 us | } 7338520.591822 | 0) 0.055 us | exit_idle(); 7338520.591822 | 0) | __xen_evtchn_do_upcall() { 7338520.591823 | 0) | evtchn_2l_handle_events() { 7338520.591823 | 0) 0.051 us | irq_from_virq(); 7338520.591823 | 0) | evtchn_from_irq() { 7338520.591823 | 0) | irq_get_irq_data() { 7338520.591824 | 0) 0.064 us | irq_to_desc(); 7338520.591824 | 0) 0.572 us | } 7338520.591824 | 0) 0.973 us | } 7338520.591825 | 0) | get_evtchn_to_irq() { 7338520.591825 | 0) 0.049 us | evtchn_2l_max_channels(); 7338520.591825 | 0) 0.386 us | } 7338520.591825 | 0) | generic_handle_irq() { 7338520.591825 | 0) 0.061 us | irq_to_desc(); 7338520.591826 | 0) | handle_percpu_irq() { 7338520.591826 | 0) | ack_dynirq() { 7338520.591826 | 0) | evtchn_from_irq() { 7338520.591826 | 0) | irq_get_irq_data() { 7338520.591827 | 0) 0.050 us | irq_to_desc(); 7338520.591827 | 0) 0.441 us | } 7338520.591827 | 0) 0.748 us | } 7338520.591827 | 0) 0.048 us | irq_move_irq(); 7338520.591828 | 0) 0.053 us | evtchn_2l_clear_pending(); 7338520.591828 | 0) 1.810 us | } 7338520.591828 | 0) | handle_irq_event_percpu() { 7338520.591828 | 0) | xen_irq_work_interrupt() { 7338520.591829 | 0) | irq_enter() { 7338520.591829 | 0) 0.069 us | rcu_irq_enter(); 7338520.591829 | 0) 0.386 us | } 7338520.591830 | 0) | __wake_up() { 7338520.591830 | 0) 0.060 us | _raw_spin_lock_irqsave(); 7338520.591830 | 0) | __wake_up_common() { 7338520.591830 | 0) | autoremove_wake_function() { 7338520.591831 | 0) | default_wake_function() { 7338520.591831 | 0) | try_to_wake_up() { 7338520.591831 | 0) 0.223 us | _raw_spin_lock_irqsave(); 7338520.591832 | 0) 0.243 us | task_waking_fair(); 7338520.591832 | 0) | select_task_rq_fair() { 7338520.591833 | 0) 0.063 us | source_load(); 7338520.591833 | 0) 0.059 us | target_load(); 7338520.591834 | 0) 0.060 us | idle_cpu(); 7338520.591834 | 0) 0.059 us | cpus_share_cache(); 7338520.591834 | 0) 0.085 us | idle_cpu(); 7338520.591835 | 0) 2.176 us | } 7338520.591835 | 0) 0.050 us | _raw_spin_lock(); 7338520.591835 | 0) | ttwu_do_activate.constprop.124() { 7338520.591835 | 0) | activate_task() { 7338520.591836 | 0) | enqueue_task() { 7338520.591836 | 0) 0.197 us | update_rq_clock(); 7338520.591836 | 0) | enqueue_task_fair() { 7338520.591836 | 0) | enqueue_entity() { 7338520.591837 | 0) 0.118 us | update_curr(); 7338520.591837 | 0) 0.060 us | __compute_runnable_contrib.part.51(); 7338520.591838 | 0) 0.052 us | __update_entity_load_avg_contrib(); 7338520.591838 | 0) 0.132 us | update_cfs_rq_blocked_load(); 7338520.591838 | 0) 0.068 us | account_entity_enqueue(); 7338520.591839 | 0) 0.327 us | update_cfs_shares(); 7338520.591839 | 0) 0.055 us | place_entity(); 7338520.591840 | 0) 0.086 us | __enqueue_entity(); 7338520.591840 | 0) 0.069 us | update_cfs_rq_blocked_load(); 7338520.591840 | 0) 3.870 us | } 7338520.591841 | 0) | enqueue_entity() { 7338520.591841 | 0) 0.050 us | update_curr(); 7338520.591841 | 0) 0.048 us | __compute_runnable_contrib.part.51(); 7338520.591842 | 0) 0.079 us | __update_entity_load_avg_contrib(); 7338520.591842 | 0) 0.068 us | update_cfs_rq_blocked_load(); 7338520.591842 | 0) 0.072 us | account_entity_enqueue(); 7338520.591843 | 0) 0.068 us | update_cfs_shares(); 7338520.591844 | 0) 0.123 us | place_entity(); 7338520.591844 | 0) 0.051 us | __enqueue_entity(); 7338520.591845 | 0) 3.919 us | } 7338520.591845 | 0) 0.059 us | hrtick_update(); 7338520.591845 | 0) 8.895 us | } 7338520.591846 | 0) 9.770 us | } 7338520.591846 | 0) 10.197 us | } 7338520.591846 | 0) | ttwu_do_wakeup() { 7338520.591846 | 0) | check_preempt_curr() { 7338520.591846 | 0) | resched_task() { 7338520.591847 | 0) | xen_smp_send_reschedule() { 7338520.591847 | 0) | xen_send_IPI_one() { 7338520.591847 | 0) | notify_remote_via_irq() { 7338520.591847 | 0) | evtchn_from_irq() { 7338520.591848 | 0) | irq_get_irq_data() { 7338520.591848 | 0) 0.051 us | irq_to_desc(); 7338520.591848 | 0) 0.503 us | } 7338520.591848 | 0) 1.031 us | } 7338520.591849 | 0) 2.112 us | } 7338520.591849 | 0) 2.484 us | } 7338520.591850 | 0) 2.851 us | } 7338520.591850 | 0) 3.311 us | } 7338520.591850 | 0) 3.828 us | } 7338520.591851 | 0) 4.788 us | } 7338520.591851 | 0) 15.731 us | } 7338520.591851 | 0) 0.074 us | _raw_spin_unlock(); 7338520.591852 | 0) 0.156 us | ttwu_stat(); 7338520.591852 | 0) 0.080 us | _raw_spin_unlock_irqrestore(); 7338520.591853 | 0) 21.807 us | } 7338520.591853 | 0) 22.286 us | } 7338520.591853 | 0) 22.738 us | } 7338520.591854 | 0) 23.387 us | } 7338520.591854 | 0) 0.105 us | _raw_spin_unlock_irqrestore(); 7338520.591854 | 0) 24.698 us | } 7338520.591855 | 0) | irq_exit() { 7338520.591855 | 0) 0.086 us | idle_cpu(); 7338520.591856 | 0) 0.105 us | rcu_irq_exit(); 7338520.591856 | 0) 1.272 us | } 7338520.591856 | 0) 27.818 us | } 7338520.591857 | 0) 0.140 us | add_interrupt_randomness(); 7338520.591857 | 0) 0.084 us | note_interrupt(); 7338520.591858 | 0) 29.866 us | } 7338520.591858 | 0) 32.390 us | } 7338520.591859 | 0) 33.204 us | } 7338520.591859 | 0) 36.137 us | } 7338520.591859 | 0) 36.574 us | } 7338520.591859 | 0) | irq_exit() { 7338520.591860 | 0) 0.073 us | idle_cpu(); 7338520.591860 | 0) 0.076 us | rcu_irq_exit(); 7338520.591861 | 0) 1.091 us | } 7338520.591861 | 0) 40.156 us | } 7338520.591862 | 0) 41.874 us | } 7338520.591862 | 0) 75.633 us | } /* __schedule */ 7338520.591862 | 0) 76.182 us | } /* schedule */ 7338520.591863 | 0) 76.965 us | } /* schedule_timeout */ 7338520.591863 | 0) 0.070 us | down_read(); 7338520.591864 | 0) | copy_from_read_buf() { 7338520.591865 | 0) | tty_audit_add_data() { 7338520.591865 | 0) 0.232 us | _raw_spin_lock_irqsave(); 7338520.591866 | 0) 0.079 us | _raw_spin_unlock_irqrestore(); 7338520.591867 | 0) 0.122 us | _raw_spin_lock_irqsave(); 7338520.591867 | 0) 0.066 us | _raw_spin_unlock_irqrestore(); 7338520.591868 | 0) 2.642 us | } 7338520.591868 | 0) 3.886 us | } 7338520.591868 | 0) 0.149 us | copy_from_read_buf(); 7338520.591869 | 0) 0.072 us | n_tty_set_room(); 7338520.591870 | 0) 0.071 us | n_tty_write_wakeup(); 7338520.591870 | 0) | __wake_up() { 7338520.591871 | 0) 0.071 us | _raw_spin_lock_irqsave(); 7338520.591872 | 0) | __wake_up_common() { 7338520.591872 | 0) 0.097 us | pollwake(); 7338520.591873 | 0) 0.739 us | } 7338520.591873 | 0) 0.066 us | _raw_spin_unlock_irqrestore(); 7338520.591874 | 0) 3.043 us | } 7338520.591874 | 0) 0.075 us | n_tty_set_room(); 7338520.591875 | 0) 0.106 us | up_read(); 7338520.591875 | 0) | remove_wait_queue() { 7338520.591875 | 0) 0.078 us | _raw_spin_lock_irqsave(); 7338520.591876 | 0) 0.075 us | _raw_spin_unlock_irqrestore(); 7338520.591877 | 0) 1.165 us | } 7338520.591877 | 0) 0.137 us | mutex_unlock(); 7338520.591877 | 0) 98.321 us | } /* n_tty_read */ 7338520.591878 | 0) | tty_ldisc_deref() { 7338520.591878 | 0) 0.072 us | ldsem_up_read(); 7338520.591879 | 0) 0.561 us | } 7338520.591879 | 0) 0.090 us | get_seconds(); 7338520.591880 | 0) 102.599 us | } /* tty_read */ 7338520.591880 | 0) 0.362 us | __fsnotify_parent(); 7338520.591881 | 0) 0.171 us | fsnotify(); 7338520.591882 | 0) 109.640 us | } /* vfs_read */ 7338520.591951 | 0) | vfs_read() { 7338520.591951 | 0) | rw_verify_area() { 7338520.591952 | 0) | security_file_permission() { 7338520.591952 | 0) | apparmor_file_permission() { 7338520.591952 | 0) 0.174 us | common_file_perm(); 7338520.591953 | 0) 0.762 us | } 7338520.591953 | 0) 0.126 us | __fsnotify_parent(); 7338520.591954 | 0) 0.088 us | fsnotify(); 7338520.591954 | 0) 2.609 us | } 7338520.591955 | 0) 3.351 us | } 7338520.591955 | 0) | tty_read() { 7338520.591956 | 0) 0.081 us | tty_paranoia_check(); 7338520.591956 | 0) | tty_ldisc_ref_wait() { 7338520.591956 | 0) 0.090 us | ldsem_down_read(); 7338520.591957 | 0) 0.633 us | } 7338520.591957 | 0) | n_tty_read() { 7338520.591958 | 0) 0.073 us | _raw_spin_lock_irq(); 7338520.591958 | 0) 0.089 us | mutex_lock_interruptible(); 7338520.591959 | 0) 0.080 us | down_read(); 7338520.591960 | 0) | add_wait_queue() { 7338520.591960 | 0) 0.084 us | _raw_spin_lock_irqsave(); 7338520.591960 | 0) 0.087 us | _raw_spin_unlock_irqrestore(); 7338520.591961 | 0) 1.215 us | } 7338520.591961 | 0) 0.078 us | tty_hung_up_p(); 7338520.591962 | 0) 0.084 us | n_tty_set_room(); 7338520.591962 | 0) 0.072 us | up_read(); 7338520.591963 | 0) | schedule_timeout() { 7338520.591963 | 0) | schedule() { 7338520.591964 | 0) | __schedule() { 7338520.591964 | 0) 0.084 us | rcu_note_context_switch(); 7338520.591965 | 0) 0.086 us | _raw_spin_lock_irq(); 7338520.591965 | 0) | deactivate_task() { 7338520.591966 | 0) | dequeue_task() { 7338520.591966 | 0) 0.171 us | update_rq_clock(); 7338520.591966 | 0) | dequeue_task_fair() { 7338520.591967 | 0) | dequeue_entity() { 7338520.591967 | 0) | update_curr() { 7338520.591967 | 0) 0.248 us | cpuacct_charge(); 7338520.591968 | 0) 0.974 us | } 7338520.591969 | 0) 0.074 us | update_cfs_rq_blocked_load(); 7338520.591969 | 0) 0.081 us | clear_buddies(); 7338520.591970 | 0) 0.094 us | account_entity_dequeue(); 7338520.591971 | 0) | update_cfs_shares() { 7338520.591971 | 0) 0.096 us | update_curr(); 7338520.591971 | 0) 0.093 us | account_entity_dequeue(); 7338520.591972 | 0) 0.079 us | account_entity_enqueue(); 7338520.591972 | 0) 1.743 us | } 7338520.591972 | 0) 5.515 us | } 7338520.591973 | 0) | dequeue_entity() { 7338520.591973 | 0) 0.088 us | update_curr(); 7338520.591974 | 0) 0.106 us | update_cfs_rq_blocked_load(); 7338520.591975 | 0) 0.078 us | clear_buddies(); 7338520.591975 | 0) 0.088 us | account_entity_dequeue(); 7338520.591976 | 0) 0.091 us | update_cfs_shares(); 7338520.591977 | 0) 3.639 us | } 7338520.591977 | 0) 0.078 us | hrtick_update(); 7338520.591978 | 0) 10.851 us | } 7338520.591978 | 0) 11.992 us | } 7338520.591978 | 0) 12.496 us | } 7338520.591978 | 0) | pick_next_task_fair() { 7338520.591979 | 0) 0.079 us | check_cfs_rq_runtime(); 7338520.591979 | 0) | pick_next_entity() { 7338520.591979 | 0) 0.080 us | clear_buddies(); 7338520.591980 | 0) 0.594 us | } 7338520.591980 | 0) | put_prev_entity() { 7338520.591980 | 0) 0.078 us | check_cfs_rq_runtime(); 7338520.591981 | 0) 0.641 us | } 7338520.591981 | 0) | put_prev_entity() { 7338520.591982 | 0) 0.076 us | check_cfs_rq_runtime(); 7338520.591982 | 0) 0.610 us | } 7338520.591982 | 0) | set_next_entity() { 7338520.591983 | 0) 0.097 us | update_stats_wait_end(); 7338520.591983 | 0) 0.744 us | } 7338520.591984 | 0) 5.115 us | } 7338520.591984 | 0) 0.076 us | paravirt_start_context_switch(); 7338520.591985 | 0) 0.086 us | xen_read_cr0(); 7338520.591986 | 0) | xen_write_cr0() { 7338520.591986 | 0) 0.078 us | paravirt_get_lazy_mode(); 7338520.591987 | 0) 0.086 us | __xen_mc_entry(); 7338520.591987 | 0) 0.078 us | paravirt_get_lazy_mode(); 7338520.591988 | 0) 1.698 us | } 7338520.591988 | 0) | xen_load_sp0() { 7338520.591988 | 0) 0.074 us | paravirt_get_lazy_mode(); 7338520.591989 | 0) 0.084 us | __xen_mc_entry(); 7338520.591989 | 0) 0.084 us | paravirt_get_lazy_mode(); 7338520.591990 | 0) 1.724 us | } 7338520.591990 | 0) | xen_load_tls() { 7338520.591991 | 0) 0.080 us | paravirt_get_lazy_mode(); 7338520.591991 | 0) 0.088 us | paravirt_get_lazy_mode(); 7338520.591992 | 0) 0.140 us | load_TLS_descriptor(); 7338520.591992 | 0) 0.079 us | load_TLS_descriptor(); 7338520.591993 | 0) 0.087 us | load_TLS_descriptor(); 7338520.591994 | 0) 0.078 us | paravirt_get_lazy_mode(); 7338520.591994 | 0) 3.666 us | } 7338520.591995 | 0) | xen_end_context_switch() { 7338520.591995 | 0) 0.644 us | xen_mc_flush(); 7338520.591996 | 0) 0.080 us | paravirt_end_context_switch(); 7338520.591997 | 0) 1.813 us | } 7338520.855105 | 0) | finish_task_switch() { 7338520.855110 | 0) | xen_evtchn_do_upcall() { 7338520.855110 | 0) | irq_enter() { 7338520.855110 | 0) 0.137 us | rcu_irq_enter(); 7338520.855111 | 0) 0.673 us | } 7338520.855111 | 0) 0.063 us | exit_idle(); 7338520.855111 | 0) | __xen_evtchn_do_upcall() { 7338520.855112 | 0) | evtchn_2l_handle_events() { 7338520.855112 | 0) 0.050 us | irq_from_virq(); 7338520.855112 | 0) | evtchn_from_irq() { 7338520.855112 | 0) | irq_get_irq_data() { 7338520.855113 | 0) 0.050 us | irq_to_desc(); 7338520.855113 | 0) 0.568 us | } 7338520.855113 | 0) 0.895 us | } 7338520.855114 | 0) | get_evtchn_to_irq() { 7338520.855114 | 0) 0.048 us | evtchn_2l_max_channels(); 7338520.855114 | 0) 0.386 us | } 7338520.855114 | 0) | generic_handle_irq() { 7338520.855114 | 0) 0.051 us | irq_to_desc(); 7338520.855115 | 0) | handle_percpu_irq() { 7338520.855115 | 0) | ack_dynirq() { 7338520.855115 | 0) | evtchn_from_irq() { 7338520.855115 | 0) | irq_get_irq_data() { 7338520.855116 | 0) 0.058 us | irq_to_desc(); 7338520.855117 | 0) 1.264 us | } 7338520.855117 | 0) 1.644 us | } 7338520.855117 | 0) 0.048 us | irq_move_irq(); 7338520.855118 | 0) 0.050 us | evtchn_2l_clear_pending(); 7338520.855118 | 0) 2.876 us | } 7338520.855118 | 0) | handle_irq_event_percpu() { 7338520.855119 | 0) | xen_irq_work_interrupt() { 7338520.855119 | 0) | irq_enter() { 7338520.855119 | 0) 0.055 us | rcu_irq_enter(); 7338520.855119 | 0) 0.460 us | } 7338520.855120 | 0) | __wake_up() { 7338520.855120 | 0) 0.057 us | _raw_spin_lock_irqsave(); 7338520.855120 | 0) | __wake_up_common() { 7338520.855121 | 0) | autoremove_wake_function() { 7338520.855121 | 0) | default_wake_function() { 7338520.855121 | 0) | try_to_wake_up() { 7338520.855121 | 0) 0.203 us | _raw_spin_lock_irqsave(); 7338520.855122 | 0) 0.179 us | task_waking_fair(); 7338520.855123 | 0) | select_task_rq_fair() { 7338520.855123 | 0) 0.048 us | source_load(); 7338520.855123 | 0) 0.059 us | target_load(); 7338520.855124 | 0) 0.059 us | idle_cpu(); 7338520.855124 | 0) 0.058 us | cpus_share_cache(); 7338520.855124 | 0) 0.058 us | idle_cpu(); 7338520.855125 | 0) 1.940 us | } 7338520.855125 | 0) 0.057 us | _raw_spin_lock(); 7338520.855125 | 0) | ttwu_do_activate.constprop.124() { 7338520.855125 | 0) | activate_task() { 7338520.855126 | 0) | enqueue_task() { 7338520.855126 | 0) 0.171 us | update_rq_clock(); 7338520.855126 | 0) | enqueue_task_fair() { 7338520.855126 | 0) | enqueue_entity() { 7338520.855127 | 0) 0.063 us | update_curr(); 7338520.855127 | 0) 0.078 us | __compute_runnable_contrib.part.51(); 7338520.855127 | 0) 0.066 us | __update_entity_load_avg_contrib(); 7338520.855128 | 0) 0.061 us | update_cfs_rq_blocked_load(); 7338520.855128 | 0) 0.072 us | account_entity_enqueue(); 7338520.855128 | 0) 0.116 us | update_cfs_shares(); 7338520.855129 | 0) 0.062 us | place_entity(); 7338520.855129 | 0) 0.087 us | __enqueue_entity(); 7338520.855129 | 0) 2.950 us | } 7338520.855130 | 0) | enqueue_entity() { 7338520.855130 | 0) 0.065 us | update_curr(); 7338520.855130 | 0) 0.065 us | update_cfs_rq_blocked_load(); 7338520.855130 | 0) 0.067 us | account_entity_enqueue(); 7338520.855131 | 0) 0.084 us | update_cfs_shares(); 7338520.855131 | 0) 0.112 us | place_entity(); 7338520.855131 | 0) 0.051 us | __enqueue_entity(); 7338520.855132 | 0) 2.074 us | } 7338520.855132 | 0) 0.055 us | hrtick_update(); 7338520.855132 | 0) 5.983 us | } 7338520.855133 | 0) 6.790 us | } 7338520.855133 | 0) 7.138 us | } 7338520.855133 | 0) | ttwu_do_wakeup() { 7338520.855133 | 0) | check_preempt_curr() { 7338520.855133 | 0) | resched_task() { 7338520.855133 | 0) | xen_smp_send_reschedule() { 7338520.855134 | 0) | xen_send_IPI_one() { 7338520.855134 | 0) | notify_remote_via_irq() { 7338520.855134 | 0) | evtchn_from_irq() { 7338520.855134 | 0) | irq_get_irq_data() { 7338520.855134 | 0) 0.057 us | irq_to_desc(); 7338520.855135 | 0) 0.502 us | } 7338520.855135 | 0) 0.865 us | } 7338520.855136 | 0) 1.975 us | } /* notify_remote_via_irq */ 7338520.855136 | 0) 2.350 us | } 7338520.855136 | 0) 2.723 us | } 7338520.855136 | 0) 3.175 us | } 7338520.855137 | 0) 3.620 us | } 7338520.855138 | 0) 4.642 us | } 7338520.855138 | 0) 12.409 us | } 7338520.855138 | 0) 0.059 us | _raw_spin_unlock(); 7338520.855139 | 0) 0.108 us | ttwu_stat(); 7338520.855140 | 0) 0.073 us | _raw_spin_unlock_irqrestore(); 7338520.855140 | 0) 18.857 us | } 7338520.855141 | 0) 19.415 us | } 7338520.855141 | 0) 19.993 us | } 7338520.855141 | 0) 20.587 us | } 7338520.855141 | 0) 0.070 us | _raw_spin_unlock_irqrestore(); 7338520.855142 | 0) 21.858 us | } 7338520.855142 | 0) | irq_exit() { 7338520.855143 | 0) 0.084 us | idle_cpu(); 7338520.855143 | 0) 0.082 us | rcu_irq_exit(); 7338520.855144 | 0) 1.235 us | } 7338520.855144 | 0) 25.109 us | } 7338520.855144 | 0) 0.126 us | add_interrupt_randomness(); 7338520.855145 | 0) 0.091 us | note_interrupt(); 7338520.855145 | 0) 26.935 us | } 7338520.855146 | 0) 30.693 us | } 7338520.855146 | 0) 31.575 us | } 7338520.855146 | 0) 34.424 us | } 7338520.855147 | 0) 34.841 us | } 7338520.855147 | 0) | irq_exit() { 7338520.855147 | 0) 0.083 us | idle_cpu(); 7338520.855148 | 0) 0.069 us | rcu_irq_exit(); 7338520.855148 | 0) 1.056 us | } 7338520.855148 | 0) 38.284 us | } 7338520.855149 | 0) 39.892 us | } 7338520.855150 | 0) 72.181 us | } 7338520.855150 | 0) 72.925 us | } 7338520.855150 | 0) 73.638 us | } 7338520.855151 | 0) 0.078 us | down_read(); 7338520.855152 | 0) | copy_from_read_buf() { 7338520.855153 | 0) | tty_audit_add_data() { 7338520.855153 | 0) 0.272 us | _raw_spin_lock_irqsave(); 7338520.855154 | 0) 0.063 us | _raw_spin_unlock_irqrestore(); 7338520.855155 | 0) 0.086 us | _raw_spin_lock_irqsave(); 7338520.855155 | 0) 0.067 us | _raw_spin_unlock_irqrestore(); 7338520.855156 | 0) 2.808 us | } 7338520.855156 | 0) 4.330 us | } 7338520.855156 | 0) 0.083 us | copy_from_read_buf(); 7338520.855157 | 0) 0.062 us | n_tty_set_room(); 7338520.855158 | 0) 0.079 us | n_tty_write_wakeup(); 7338520.855158 | 0) | __wake_up() { 7338520.855158 | 0) 0.068 us | _raw_spin_lock_irqsave(); 7338520.855159 | 0) | __wake_up_common() { 7338520.855159 | 0) 0.092 us | pollwake(); 7338520.855160 | 0) 0.643 us | } 7338520.855160 | 0) 0.074 us | _raw_spin_unlock_irqrestore(); 7338520.855160 | 0) 2.040 us | } 7338520.855161 | 0) 0.074 us | n_tty_set_room(); 7338520.855162 | 0) 0.073 us | up_read(); 7338520.855162 | 0) | remove_wait_queue() { 7338520.855162 | 0) 0.084 us | _raw_spin_lock_irqsave(); 7338520.855163 | 0) 0.078 us | _raw_spin_unlock_irqrestore(); 7338520.855163 | 0) 1.166 us | } 7338520.855164 | 0) 0.140 us | mutex_unlock(); 7338520.855164 | 0) 93.360 us | } 7338520.855165 | 0) | tty_ldisc_deref() { 7338520.855165 | 0) 0.070 us | ldsem_up_read(); 7338520.855166 | 0) 0.746 us | } 7338520.855166 | 0) 0.071 us | get_seconds(); 7338520.855167 | 0) 97.713 us | } 7338520.855167 | 0) 0.283 us | __fsnotify_parent(); 7338520.855168 | 0) 0.172 us | fsnotify(); 7338520.855168 | 0) 103.847 us | } 7338520.855238 | 0) | vfs_read() { 7338520.855239 | 0) | rw_verify_area() { 7338520.855240 | 0) | security_file_permission() { 7338520.855240 | 0) | apparmor_file_permission() { 7338520.855240 | 0) 0.160 us | common_file_perm(); 7338520.855241 | 0) 0.770 us | } 7338520.855241 | 0) 0.078 us | __fsnotify_parent(); 7338520.855242 | 0) 0.087 us | fsnotify(); 7338520.855243 | 0) 2.595 us | } 7338520.855243 | 0) 4.148 us | } 7338520.855243 | 0) | tty_read() { 7338520.855244 | 0) 0.078 us | tty_paranoia_check(); 7338520.855244 | 0) | tty_ldisc_ref_wait() { 7338520.855244 | 0) 0.084 us | ldsem_down_read(); 7338520.855245 | 0) 0.643 us | } 7338520.855245 | 0) | n_tty_read() { 7338520.855246 | 0) 0.079 us | _raw_spin_lock_irq(); 7338520.855247 | 0) 0.171 us | mutex_lock_interruptible(); 7338520.855247 | 0) 0.064 us | down_read(); 7338520.855248 | 0) | add_wait_queue() { 7338520.855248 | 0) 0.078 us | _raw_spin_lock_irqsave(); 7338520.855249 | 0) 0.082 us | _raw_spin_unlock_irqrestore(); 7338520.855249 | 0) 1.076 us | } 7338520.855250 | 0) 0.075 us | tty_hung_up_p(); 7338520.855250 | 0) 0.079 us | n_tty_set_room(); 7338520.855251 | 0) 0.075 us | up_read(); 7338520.855251 | 0) | schedule_timeout() { 7338520.855252 | 0) | schedule() { 7338520.855252 | 0) | __schedule() { 7338520.855252 | 0) 0.084 us | rcu_note_context_switch(); 7338520.855253 | 0) 0.079 us | _raw_spin_lock_irq(); 7338520.855254 | 0) | deactivate_task() { 7338520.855254 | 0) | dequeue_task() { 7338520.855254 | 0) 0.219 us | update_rq_clock(); 7338520.855255 | 0) | dequeue_task_fair() { 7338520.855255 | 0) | dequeue_entity() { 7338520.855255 | 0) | update_curr() { 7338520.855256 | 0) 0.186 us | cpuacct_charge(); 7338520.855257 | 0) 0.924 us | } 7338520.855257 | 0) 0.078 us | update_cfs_rq_blocked_load(); 7338520.855258 | 0) 0.078 us | clear_buddies(); 7338520.855258 | 0) 0.083 us | account_entity_dequeue(); 7338520.855259 | 0) | update_cfs_shares() { 7338520.855259 | 0) 0.105 us | update_curr(); 7338520.855260 | 0) 0.093 us | account_entity_dequeue(); 7338520.855260 | 0) 0.098 us | account_entity_enqueue(); 7338520.855261 | 0) 1.825 us | } 7338520.855261 | 0) 5.574 us | } 7338520.855261 | 0) | dequeue_entity() { 7338520.855261 | 0) 0.086 us | update_curr(); 7338520.855262 | 0) 0.127 us | __update_entity_load_avg_contrib(); 7338520.855263 | 0) 0.070 us | update_cfs_rq_blocked_load(); 7338520.855263 | 0) 0.066 us | clear_buddies(); 7338520.855264 | 0) 0.082 us | account_entity_dequeue(); 7338520.855264 | 0) 0.104 us | update_cfs_shares(); 7338520.855265 | 0) 3.439 us | } 7338520.855265 | 0) 0.078 us | hrtick_update(); 7338520.855266 | 0) 10.741 us | } 7338520.855266 | 0) 11.990 us | } 7338520.855266 | 0) 12.580 us | } 7338520.855267 | 0) | pick_next_task_fair() { 7338520.855267 | 0) 0.074 us | check_cfs_rq_runtime(); 7338520.855268 | 0) | pick_next_entity() { 7338520.855268 | 0) 0.078 us | clear_buddies(); 7338520.855269 | 0) 0.696 us | } 7338520.855269 | 0) | put_prev_entity() { 7338520.855269 | 0) 0.084 us | check_cfs_rq_runtime(); 7338520.855270 | 0) 0.628 us | } 7338520.855270 | 0) | put_prev_entity() { 7338520.855270 | 0) 0.074 us | check_cfs_rq_runtime(); 7338520.855271 | 0) 0.575 us | } 7338520.855271 | 0) | set_next_entity() { 7338520.855272 | 0) 0.104 us | update_stats_wait_end(); 7338520.855273 | 0) 0.834 us | } 7338520.855273 | 0) 5.872 us | } 7338520.855274 | 0) 0.079 us | paravirt_start_context_switch(); 7338520.855275 | 0) 0.080 us | xen_read_cr0(); 7338520.855276 | 0) | xen_write_cr0() { 7338520.855276 | 0) 0.091 us | paravirt_get_lazy_mode(); 7338520.855277 | 0) 0.087 us | __xen_mc_entry(); 7338520.855277 | 0) 0.076 us | paravirt_get_lazy_mode(); 7338520.855278 | 0) 1.986 us | } 7338520.855278 | 0) | xen_load_sp0() { 7338520.855278 | 0) 0.066 us | paravirt_get_lazy_mode(); 7338520.855279 | 0) 0.083 us | __xen_mc_entry(); 7338520.855280 | 0) 0.082 us | paravirt_get_lazy_mode(); 7338520.855280 | 0) 1.925 us | } 7338520.855281 | 0) | xen_load_tls() { 7338520.855281 | 0) 0.082 us | paravirt_get_lazy_mode(); 7338520.855281 | 0) 0.080 us | paravirt_get_lazy_mode(); 7338520.855282 | 0) 0.137 us | load_TLS_descriptor(); 7338520.855283 | 0) 0.090 us | load_TLS_descriptor(); 7338520.855283 | 0) 0.081 us | load_TLS_descriptor(); 7338520.855284 | 0) 0.081 us | paravirt_get_lazy_mode(); 7338520.855284 | 0) 3.397 us | } 7338520.855284 | 0) | xen_end_context_switch() { 7338520.855285 | 0) 0.618 us | xen_mc_flush(); 7338520.855286 | 0) 0.086 us | paravirt_end_context_switch(); 7338520.855286 | 0) 1.708 us | } ^C Ending tracing... Understanding whether the time is on-CPU or blocked off-CPU directs the performance investigation. Use -h to print the USAGE message: # ./funcgraph -h USAGE: funcgraph [-aCDhHPtT] [-m maxdepth] [-p PID] [-L TID] [-d secs] funcstring -a # all info (same as -HPt) -C # measure on-CPU time only -d seconds # trace duration, and use buffers -D # do not show function duration -h # this usage message -H # include column headers -m maxdepth # max stack depth to show -p PID # trace when this pid is on-CPU -L TID # trace when this thread is on-CPU -P # show process names & PIDs -t # show timestamps -T # comment function tails eg, funcgraph do_nanosleep # trace do_nanosleep() and children funcgraph -m 3 do_sys_open # trace do_sys_open() to 3 levels only funcgraph -a do_sys_open # include timestamps and process name funcgraph -p 198 do_sys_open # trace vfs_read() for PID 198 only funcgraph -d 1 do_sys_open >out # trace 1 sec, then write to file See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/funcslower_example.txt000066400000000000000000000104161361450357500265630ustar00rootroot00000000000000Demonstrations of funcslower, the Linux ftrace version. Show me ext3_readpages() calls slower than 1000 microseconds (1 ms): # ./funcslower ext3_readpages 1000 Tracing "ext3_readpages" slower than 1000 us... Ctrl-C to end. 0) ! 8147.120 us | } /* ext3_readpages */ 0) ! 8135.067 us | } /* ext3_readpages */ 0) ! 12202.93 us | } /* ext3_readpages */ 0) ! 12201.84 us | } /* ext3_readpages */ 0) ! 8142.667 us | } /* ext3_readpages */ 0) ! 12194.14 us | } /* ext3_readpages */ ^C Ending tracing... Neat. So this confirms that there are ext3_readpages() calls that are taking over 8000 us (8 ms). funcslower uses the ftrace function graph profiler to dynamically instrument the given kernel function, time it in-kernel, and only emit events slower than the given latency threshold in-kernel. Since this all operates in kernel context, the overheads are relatively low (compared to post-processing in user space). Now include the process name and PID (-P) of the process who is on-CPU, and the absolute timestamp (-t) of the event: # ./funcslower -Pt ext3_readpages 1000 Tracing "ext3_readpages" slower than 1000 us... Ctrl-C to end. 2678112.003180 | 0) cksum-26695 | ! 8145.268 us | } /* ext3_readpages */ 2678113.538763 | 0) cksum-26695 | ! 8139.086 us | } /* ext3_readpages */ 2678113.704901 | 0) cksum-26695 | ! 8147.549 us | } /* ext3_readpages */ 2678113.721102 | 0) cksum-26695 | ! 8142.530 us | } /* ext3_readpages */ 2678113.810269 | 0) cksum-26695 | ! 12234.70 us | } /* ext3_readpages */ 2678113.996625 | 0) cksum-26695 | ! 8146.129 us | } /* ext3_readpages */ 2678114.012832 | 0) cksum-26695 | ! 8148.153 us | } /* ext3_readpages */ ^C Ending tracing... Great! Now I can see the process name, which in this case is the responsible process. The timestamps also let me determine the rate of these slow events. Now measure time differently: excluding time spent sleeping, so that we only see on-CPU time: # ./funcslower -Pct ext3_readpages 1000 Tracing "ext3_readpages" slower than 1000 us... Ctrl-C to end. ^C Ending tracing... I believe the workload hasn't changed, so these ext3_readpages() calls are still happening, however, their CPU time doesn't exceed 1 ms. Compared to the earlier output, this tells me that the latency in this function is due to time spent blocked off-CPU, and not on-CPU. This makes sense: this function is ultimately being blocked on disk I/O. Were the function duration times to be similar with and without -C, that would tell us that the high latency is due to time spent on-CPU executing code. This traces the sys_nanosleep() kernel function, and shows calls taking over 100 us: # ./funcslower sys_nanosleep 100 Tracing "sys_nanosleep" slower than 100 us... Ctrl-C to end. 0) ! 2000147 us | } /* sys_nanosleep */ ------------------------------------------ 0) registe-27414 => vmstat-27419 ------------------------------------------ 0) ! 1000143 us | } /* sys_nanosleep */ 0) ! 1000154 us | } /* sys_nanosleep */ ------------------------------------------ 0) vmstat-27419 => registe-27414 ------------------------------------------ 0) ! 2000183 us | } /* sys_nanosleep */ ------------------------------------------ 0) registe-27414 => vmstat-27419 ------------------------------------------ 0) ! 1000141 us | } /* sys_nanosleep */ ^C Ending tracing... This is an example where I did not use -P, but ftrace has included process information anyway. Look for the lines containing "=>", which indicate a process switch on the given CPU. Use -h to print the USAGE message: # ./funcslower -h USAGE: funcslower [-aChHPt] [-p PID] [-d secs] funcstring latency_us -a # all info (same as -HPt) -C # measure on-CPU time only -d seconds # trace duration, and use buffers -h # this usage message -H # include column headers -p PID # trace when this pid is on-CPU -L TID # trace when this thread is on-CPU -P # show process names & PIDs -t # show timestamps eg, funcslower vfs_read 10000 # trace vfs_read() slower than 10 ms See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/functrace_example.txt000066400000000000000000000335041361450357500263510ustar00rootroot00000000000000Demonstrations of functrace, the Linux ftrace version. A (usually) good example to start with is do_nanosleep(), since it is not called frequently, and easily triggered. Here's tracing it using functrace: # ./functrace 'do_nanosleep' Tracing "do_nanosleep"... Ctrl-C to end. svscan-1678 [000] .... 6412438.703521: do_nanosleep <-hrtimer_nanosleep svscan-1678 [000] .... 6412443.703678: do_nanosleep <-hrtimer_nanosleep svscan-1678 [000] .... 6412448.703865: do_nanosleep <-hrtimer_nanosleep vmstat-28371 [000] .... 6412453.216241: do_nanosleep <-hrtimer_nanosleep svscan-1678 [000] .... 6412453.704049: do_nanosleep <-hrtimer_nanosleep vmstat-28371 [000] .... 6412454.216524: do_nanosleep <-hrtimer_nanosleep vmstat-28371 [000] .... 6412455.216816: do_nanosleep <-hrtimer_nanosleep vmstat-28371 [000] .... 6412456.217093: do_nanosleep <-hrtimer_nanosleep vmstat-28371 [000] .... 6412457.217378: do_nanosleep <-hrtimer_nanosleep vmstat-28371 [000] .... 6412458.217660: do_nanosleep <-hrtimer_nanosleep ^C Ending tracing... While tracing, I ran a "vmstat 1" in another window. vmstat and its process ID can be seen as the 1st column, and the timestamp and one second intervals can be seen as the 4th column. This is basic details: who was on-CPU (process name and PID), flags, timestamp, and calling function. Treat this as the next step, after funccount, for getting a little more information on kernel function execution, before using more capabilities to dig further. This is Linux 3.16, and the output is the ftrace text buffer format, which has changed slightly between kernel versions. To see the column headers, use -H. This is Linux 3.16: # ./functrace -H do_nanosleep Tracing "do_nanosleep"... Ctrl-C to end. # tracer: function # # entries-in-buffer/entries-written: 0/0 #P:2 # # _-----=> irqs-off # / _----=> need-resched # | / _---=> hardirq/softirq # || / _--=> preempt-depth # ||| / delay # TASK-PID CPU# |||| TIMESTAMP FUNCTION # | | | |||| | | svscan-1678 [001] .... 6413283.729520: do_nanosleep <-hrtimer_nanosleep svscan-1678 [001] .... 6413288.729679: do_nanosleep <-hrtimer_nanosleep For comparison, here's Linux 3.2: # ./functrace -H do_nanosleep Tracing "do_nanosleep"... Ctrl-C to end. # tracer: function # # TASK-PID CPU# TIMESTAMP FUNCTION # | | | | | vmstat-11789 [000] 1763207.021204: do_nanosleep <-hrtimer_nanosleep vmstat-11789 [000] 1763208.022970: do_nanosleep <-hrtimer_nanosleep vmstat-11789 [000] 1763209.023267: do_nanosleep <-hrtimer_nanosleep For documentation on the exact format, see the Linux kernel source under Documentation/trace/ftrace.txt. This error: # ./functrace 'ext4_z*' Tracing "ext4_z*"... Ctrl-C to end. ./functrace: line 136: echo: write error: Invalid argument ERROR: enabling "ext4_z*". Exiting. Is because there were no functions beginning with "ext4_z". You can check available functions in the /sys/kernel/debug/tracing/available_filter_functions file. You might want to use funccount to check the frequency of events before using functrace. For example, counting ext3 events on a system: # ./funccount -d 10 'ext3*' Tracing "ext3*" for 10 seconds... FUNC COUNT ext3_journal_dirty_data 1 ext3_ordered_write_end 1 ext3_write_begin 1 ext3_writepage_trans_blocks 1 ext3_dirty_inode 2 ext3_do_update_inode 2 ext3_get_group_desc 2 ext3_get_inode_block.isra.20 2 ext3_get_inode_flags 2 ext3_get_inode_loc 2 ext3_mark_iloc_dirty 2 ext3_mark_inode_dirty 2 ext3_reserve_inode_write 2 ext3_journal_start_sb 3 ext3_block_to_path.isra.22 6 ext3_bmap 6 ext3_get_block 6 ext3_get_blocks_handle 6 ext3_get_branch 6 ext3_discard_reservation 11 ext3_ioctl 11 ext3_release_file 11 Ending tracing... During 10 seconds, there weren't many ext3 calls. I might consider tracing them all (warnings about dynamic tracing many kernel functions apply: test before use, as in the past there have been bugs causing panics). # ./functrace 'ext3_*' Tracing "ext3_*"... Ctrl-C to end. register_start.-17008 [000] 1763557.577985: ext3_release_file <-__fput register_start.-17008 [000] 1763557.577987: ext3_discard_reservation <-ext3_release_file register_start.-17026 [000] 1763558.163620: ext3_ioctl <-file_ioctl register_start.-17026 [000] 1763558.481081: ext3_release_file <-__fput register_start.-17026 [000] 1763558.481083: ext3_discard_reservation <-ext3_release_file register_start.-17041 [000] 1763559.186984: ext3_ioctl <-file_ioctl register_start.-17041 [000] 1763559.511267: ext3_release_file <-__fput [...] For comparison, here's a different system and ext4: # ./funccount -d 10 'ext4*' Tracing "ext4*" for 10 seconds... FUNC COUNT ext4_journal_commit_callback 2 ext4_htree_fill_tree 6 ext4_htree_free_dir_info 6 ext4_release_dir 6 ext4_readdir 12 ext4fs_dirhash 29 ext4_htree_store_dirent 29 ext4_follow_link 36 ext4_file_mmap 42 ext4_free_data_callback 44 ext4_getattr 45 ext4_bmap 62 ext4_get_block 62 ext4_add_entry 280 ext4_add_nondir 280 ext4_alloc_da_blocks 280 ext4_alloc_inode 280 ext4_bio_write_page 280 ext4_can_truncate 280 ext4_claim_free_clusters 280 ext4_clear_inode 280 ext4_create 280 ext4_da_get_block_prep 280 ext4_da_invalidatepage 280 ext4_da_update_reserve_space 280 ext4_da_write_begin 280 ext4_da_write_end 280 ext4_dec_count.isra.22 280 ext4_delete_entry 280 ext4_destroy_inode 280 ext4_drop_inode 280 ext4_end_bio 280 ext4_es_init_tree 280 ext4_es_lru_del 280 ext4_evict_inode 280 ext4_ext_calc_metadata_amount 280 ext4_ext_correct_indexes 280 ext4_ext_find_goal 280 ext4_ext_insert_extent 280 ext4_ext_remove_space 280 ext4_ext_tree_init 280 ext4_ext_truncate 280 ext4_ext_truncate_extend_resta 280 ext4_ext_try_to_merge 280 ext4_ext_try_to_merge_right 280 ext4_file_write_iter 280 ext4_find_dest_de 280 ext4_finish_bio 280 ext4_free_blocks 280 ext4_free_inode 280 ext4_generic_delete_entry 280 ext4_has_free_clusters 280 ext4_i_callback 280 ext4_init_acl 280 ext4_init_security 280 ext4_inode_attach_jinode 280 ext4_inode_to_goal_block 280 ext4_insert_dentry 280 ext4_invalidatepage 280 ext4_io_submit_init 280 ext4_itable_unused_count 280 ext4_lookup 280 ext4_mb_complex_scan_group 280 ext4_mb_find_by_goal 280 ext4_mb_free_metadata 280 ext4_mb_initialize_context 280 ext4_mb_mark_diskspace_used 280 ext4_mb_new_blocks 280 ext4_mb_normalize_request 280 ext4_mb_regular_allocator 280 ext4_mb_release_context 280 ext4_mb_use_best_found 280 ext4_mb_use_preallocated 280 ext4_nonda_switch 280 ext4_orphan_del 280 ext4_put_io_end_defer 280 ext4_releasepage 280 ext4_rename 280 ext4_set_aops 280 ext4_setent 280 ext4_set_inode_flags 280 ext4_truncate 280 ext4_writepages 280 ext4_writepage_trans_blocks 280 ext4_xattr_delete_inode 280 ext4_xattr_get 285 ext4_xattr_ibody_get 285 ext4_xattr_security_get 285 ext4_bread 286 ext4_release_file 288 ext4_file_open 305 ext4_superblock_csum_set 494 ext4_block_bitmap_csum_set 560 ext4_es_free_extent 560 ext4_es_insert_extent 560 ext4_es_remove_extent 560 ext4_ext_find_extent 560 ext4_ext_map_blocks 560 ext4_free_group_clusters_set 560 ext4_free_inodes_set 560 ext4_get_group_no_and_offset 560 ext4_get_reserved_space 560 ext4_init_io_end 560 ext4_inode_bitmap_csum_set 560 ext4_io_submit 560 ext4_mb_good_group 560 ext4_orphan_add 560 ext4_put_io_end 560 ext4_read_block_bitmap 560 ext4_read_block_bitmap_nowait 560 ext4_read_inode_bitmap 560 ext4_release_io_end 560 ext4_set_bits 560 ext4_validate_block_bitmap 560 ext4_wait_block_bitmap 560 ext4_mb_load_buddy 604 ext4_mb_unload_buddy.isra.24 604 ext4_block_bitmap 840 ext4_discard_preallocations 840 ext4_ext_drop_refs 840 ext4_ext_get_access.isra.30 840 ext4_ext_index_trans_blocks 840 ext4_find_entry 840 ext4_free_group_clusters 840 ext4_handle_dirty_dirent_node 840 ext4_inode_bitmap 840 ext4_meta_trans_blocks 840 ext4_dirty_inode 845 ext4_free_inodes_count 1120 ext4_group_desc_csum 1120 ext4_group_desc_csum_set 1120 ext4_getblk 1126 ext4_map_blocks 1468 ext4_es_lookup_extent 1748 ext4_mb_check_limits 1875 ext4_es_lru_add 2028 ext4_data_block_valid 2308 ext4_journal_check_start 3085 ext4_mark_inode_dirty 5325 ext4_get_inode_flags 5951 ext4_get_inode_loc 5951 ext4_mark_iloc_dirty 5951 ext4_reserve_inode_write 5951 ext4_inode_table 7071 ext4_get_group_desc 8471 ext4_has_inline_data 9486 Ending tracing... There are many functions called frequently. Tracing them all may cost significant performance overhead. I may read through this list and look for the most interesting functions to trace, reducing overheads by only selecting a few. For example, ext4_create() looks interesting: # ./functrace ext4_create Tracing "ext4_create"... Ctrl-C to end. supervise-1681 [000] .... 6414396.700163: ext4_create <-vfs_create supervise-1684 [001] .... 6414396.700287: ext4_create <-vfs_create supervise-1681 [000] .... 6414396.700598: ext4_create <-vfs_create supervise-1684 [001] .... 6414396.700636: ext4_create <-vfs_create supervise-1687 [001] .... 6414396.701577: ext4_create <-vfs_create supervise-1688 [000] .... 6414396.702590: ext4_create <-vfs_create supervise-1693 [001] .... 6414396.702829: ext4_create <-vfs_create supervise-1693 [001] .... 6414396.703592: ext4_create <-vfs_create supervise-1688 [000] .... 6414396.703598: ext4_create <-vfs_create supervise-1687 [001] .... 6414396.703988: ext4_create <-vfs_create supervise-1685 [001] .... 6414396.704126: ext4_create <-vfs_create supervise-1685 [001] .... 6414396.704458: ext4_create <-vfs_create supervise-1682 [001] .... 6414396.704577: ext4_create <-vfs_create supervise-1683 [000] .... 6414396.704984: ext4_create <-vfs_create supervise-1682 [001] .... 6414396.704985: ext4_create <-vfs_create [...] Now I know that different PIDs of the supervise program are calling ext4_create, of around the same time, and from vfs_create(). The duration mode uses buffering, instead of printing events as they occur. This greatly reduces overheads. For example: # ./functrace -d 10 ext4_create > out.ext4_create # wc out.ext4_create 283 1687 21059 out.ext4_create Note that the buffer has a limited size. Check the timestamps to see if the range does not match your duration, as one clue that the buffer was exhausted and events were missed. Use -h to print the USAGE message: # ./functrace -h USAGE: functrace [-hH] [-p PID] [-L TID] [-d secs] funcstring -d seconds # trace duration, and use buffers -h # this usage message -H # include column headers -p PID # trace when this pid is on-CPU -L TID # trace when this thread is on-CPU eg, functrace do_nanosleep # trace the do_nanosleep() function functrace '*sleep' # trace functions ending in "sleep" functrace -p 198 'vfs*' # trace "vfs*" funcs for PID 198 functrace 'tcp*' > out # trace all "tcp*" funcs to out file functrace -d 1 'tcp*' > out # trace 1 sec, then write out file See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/iolatency_example.txt000066400000000000000000000436161361450357500263730ustar00rootroot00000000000000Demonstrations of iolatency, the Linux ftrace version. Here's a busy system doing over 4k disk IOPS: # ./iolatency Tracing block I/O. Output every 1 seconds. Ctrl-C to end. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 4381 |######################################| 1 -> 2 : 9 |# | 2 -> 4 : 5 |# | 4 -> 8 : 0 | | 8 -> 16 : 1 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 4053 |######################################| 1 -> 2 : 18 |# | 2 -> 4 : 9 |# | 4 -> 8 : 2 |# | 8 -> 16 : 1 |# | 16 -> 32 : 1 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 4658 |######################################| 1 -> 2 : 9 |# | 2 -> 4 : 2 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 4298 |######################################| 1 -> 2 : 17 |# | 2 -> 4 : 10 |# | 4 -> 8 : 1 |# | 8 -> 16 : 1 |# | ^C Ending tracing... Disk I/O latency is usually between 0 and 1 milliseconds, as this system uses SSDs. There are occasional outliers, up to the 16->32 ms range. Identifying outliers like these is difficult from iostat(1) alone, which at the same time reported: # iostat 1 [...] avg-cpu: %user %nice %system %iowait %steal %idle 0.53 0.00 1.05 46.84 0.53 51.05 Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s avgrq-sz avgqu-sz await r_await w_await svctm %util xvdap1 0.00 0.00 0.00 28.00 0.00 112.00 8.00 0.02 0.71 0.00 0.71 0.29 0.80 xvdb 0.00 0.00 2134.00 0.00 18768.00 0.00 17.59 0.51 0.24 0.24 0.00 0.23 50.00 xvdc 0.00 0.00 2088.00 0.00 18504.00 0.00 17.72 0.47 0.22 0.22 0.00 0.22 46.40 md0 0.00 0.00 4222.00 0.00 37256.00 0.00 17.65 0.00 0.00 0.00 0.00 0.00 0.00 I/O latency ("await") averages 0.24 and 0.22 ms for our busy disks, but this output doesn't show that occasionally is much higher. To get more information on these I/O, try the iosnoop(8) tool. The -Q option includes the block I/O queued time, by tracing based on block_rq_insert instead of block_rq_issue: # ./iolatency -Q Tracing block I/O. Output every 1 seconds. Ctrl-C to end. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1913 |######################################| 1 -> 2 : 438 |######### | 2 -> 4 : 100 |## | 4 -> 8 : 145 |### | 8 -> 16 : 43 |# | 16 -> 32 : 43 |# | 32 -> 64 : 1 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 2360 |######################################| 1 -> 2 : 132 |### | 2 -> 4 : 72 |## | 4 -> 8 : 14 |# | 8 -> 16 : 1 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 2138 |######################################| 1 -> 2 : 496 |######### | 2 -> 4 : 81 |## | 4 -> 8 : 40 |# | 8 -> 16 : 1 |# | 16 -> 32 : 2 |# | ^C Ending tracing... I use this along with the default mode to identify problems of load (queueing) vs problems of the device, which is shown by default. Here's a more interesting system. This is doing a mixed read/write workload, and has a pretty awful latency distribution: # ./iolatency 5 3 Tracing block I/O. Output every 5 seconds. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 2809 |######################################| 1 -> 2 : 32 |# | 2 -> 4 : 14 |# | 4 -> 8 : 6 |# | 8 -> 16 : 7 |# | 16 -> 32 : 14 |# | 32 -> 64 : 39 |# | 64 -> 128 : 1556 |###################### | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 3027 |######################################| 1 -> 2 : 19 |# | 2 -> 4 : 6 |# | 4 -> 8 : 5 |# | 8 -> 16 : 3 |# | 16 -> 32 : 7 |# | 32 -> 64 : 14 |# | 64 -> 128 : 540 |####### | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 2939 |######################################| 1 -> 2 : 25 |# | 2 -> 4 : 15 |# | 4 -> 8 : 2 |# | 8 -> 16 : 3 |# | 16 -> 32 : 7 |# | 32 -> 64 : 17 |# | 64 -> 128 : 936 |############# | Ending tracing... It's multi-modal, with most I/O taking 0 to 1 milliseconds, then many between 64 and 128 milliseconds. This is how it looks in iostat: # iostat -x 1 avg-cpu: %user %nice %system %iowait %steal %idle 0.52 0.00 12.37 32.99 0.00 54.12 Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s avgrq-sz avgqu-sz await r_await w_await svctm %util xvdap1 0.00 12.00 0.00 156.00 0.00 19968.00 256.00 52.17 184.38 0.00 184.38 2.33 36.40 xvdb 0.00 0.00 298.00 0.00 2732.00 0.00 18.34 0.04 0.12 0.12 0.00 0.11 3.20 xvdc 0.00 0.00 297.00 0.00 2712.00 0.00 18.26 0.08 0.27 0.27 0.00 0.24 7.20 md0 0.00 0.00 595.00 0.00 5444.00 0.00 18.30 0.00 0.00 0.00 0.00 0.00 0.00 Fortunately, it turns out that the high latency is to xvdap1, which is for files from a low priority application (processing and writing log files). A high priority application is reading from the other disks, xvdb and xvdc. Examining xvdap1 only: # ./iolatency -d 202,1 5 Tracing block I/O. Output every 5 seconds. Ctrl-C to end. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 38 |## | 1 -> 2 : 18 |# | 2 -> 4 : 0 | | 4 -> 8 : 0 | | 8 -> 16 : 5 |# | 16 -> 32 : 11 |# | 32 -> 64 : 26 |## | 64 -> 128 : 894 |######################################| >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 75 |### | 1 -> 2 : 11 |# | 2 -> 4 : 0 | | 4 -> 8 : 4 |# | 8 -> 16 : 4 |# | 16 -> 32 : 7 |# | 32 -> 64 : 13 |# | 64 -> 128 : 1141 |######################################| >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 61 |######## | 1 -> 2 : 21 |### | 2 -> 4 : 5 |# | 4 -> 8 : 1 |# | 8 -> 16 : 5 |# | 16 -> 32 : 7 |# | 32 -> 64 : 19 |### | 64 -> 128 : 324 |######################################| 128 -> 256 : 7 |# | 256 -> 512 : 26 |#### | ^C Ending tracing... And now xvdb: # ./iolatency -d 202,16 5 Tracing block I/O. Output every 5 seconds. Ctrl-C to end. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1427 |######################################| 1 -> 2 : 5 |# | 2 -> 4 : 3 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1409 |######################################| 1 -> 2 : 6 |# | 2 -> 4 : 1 |# | 4 -> 8 : 1 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1478 |######################################| 1 -> 2 : 6 |# | 2 -> 4 : 5 |# | 4 -> 8 : 0 | | 8 -> 16 : 2 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1437 |######################################| 1 -> 2 : 5 |# | 2 -> 4 : 7 |# | 4 -> 8 : 0 | | 8 -> 16 : 1 |# | [...] While that's much better, it is reaching the 8 - 16 millisecond range, and these are SSDs with a light workload (~1500 IOPS). I already know from iosnoop(8) analysis the reason for these high latency outliers: they are queued behind writes. However, these writes are to a different disk -- somewhere in this virtualized guest (Xen) there may be a shared I/O queue. One way to explore this is to reduce the queue length for the low priority disk, so that it is less likely to pollute any shared queue. (There are other ways to investigate and fix this too.) Here I reduce the disk queue length from its default of 128 to 4: # echo 4 > /sys/block/xvda1/queue/nr_requests The overall distribution looks much better: # ./iolatency 5 Tracing block I/O. Output every 5 seconds. Ctrl-C to end. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 3005 |######################################| 1 -> 2 : 19 |# | 2 -> 4 : 9 |# | 4 -> 8 : 45 |# | 8 -> 16 : 859 |########### | 16 -> 32 : 16 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 2959 |######################################| 1 -> 2 : 43 |# | 2 -> 4 : 16 |# | 4 -> 8 : 39 |# | 8 -> 16 : 1009 |############# | 16 -> 32 : 76 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 3031 |######################################| 1 -> 2 : 27 |# | 2 -> 4 : 9 |# | 4 -> 8 : 24 |# | 8 -> 16 : 422 |###### | 16 -> 32 : 5 |# | ^C Ending tracing... Latency only reaching 32 ms. Our important disk didn't appear to change much -- maybe a slight improvement to the outliers: # ./iolatency -d 202,16 5 Tracing block I/O. Output every 5 seconds. Ctrl-C to end. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1449 |######################################| 1 -> 2 : 6 |# | 2 -> 4 : 5 |# | 4 -> 8 : 1 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1519 |######################################| 1 -> 2 : 12 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1466 |######################################| 1 -> 2 : 2 |# | 2 -> 4 : 3 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 1460 |######################################| 1 -> 2 : 4 |# | 2 -> 4 : 7 |# | [...] And here's the other disk after the queue length change: # ./iolatency -d 202,1 5 Tracing block I/O. Output every 5 seconds. Ctrl-C to end. >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 85 |### | 1 -> 2 : 12 |# | 2 -> 4 : 21 |# | 4 -> 8 : 76 |## | 8 -> 16 : 1539 |######################################| 16 -> 32 : 10 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 123 |################## | 1 -> 2 : 8 |## | 2 -> 4 : 6 |# | 4 -> 8 : 17 |### | 8 -> 16 : 270 |######################################| 16 -> 32 : 2 |# | >=(ms) .. <(ms) : I/O |Distribution | 0 -> 1 : 91 |### | 1 -> 2 : 23 |# | 2 -> 4 : 8 |# | 4 -> 8 : 71 |### | 8 -> 16 : 1223 |######################################| 16 -> 32 : 12 |# | ^C Ending tracing... Much better looking distribution. Use -h to print the USAGE message: # ./iolatency -h USAGE: iolatency [-hQT] [-d device] [-i iotype] [interval [count]] -d device # device string (eg, "202,1) -i iotype # match type (eg, '*R*' for all reads) -Q # use queue insert as start time -T # timestamp on output -h # this usage message interval # summary interval, seconds (default 1) count # number of summaries eg, iolatency # summarize latency every second iolatency -Q # include block I/O queue time iolatency 5 2 # 2 x 5 second summaries iolatency -i '*R*' # trace reads iolatency -d 202,1 # trace device 202,1 only See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/iosnoop_example.txt000066400000000000000000000357451361450357500260760ustar00rootroot00000000000000Demonstrations of iosnoop, the Linux ftrace version. Here's Linux 3.16, tracing tar archiving a filesystem: # ./iosnoop Tracing block I/O... Ctrl-C to end. COMM PID TYPE DEV BLOCK BYTES LATms supervise 1809 W 202,1 17039968 4096 1.32 supervise 1809 W 202,1 17039976 4096 1.30 tar 14794 RM 202,1 8457608 4096 7.53 tar 14794 RM 202,1 8470336 4096 14.90 tar 14794 RM 202,1 8470368 4096 0.27 tar 14794 RM 202,1 8470784 4096 7.74 tar 14794 RM 202,1 8470360 4096 0.25 tar 14794 RM 202,1 8469968 4096 0.24 tar 14794 RM 202,1 8470240 4096 0.24 tar 14794 RM 202,1 8470392 4096 0.23 tar 14794 RM 202,1 8470544 4096 5.96 tar 14794 RM 202,1 8470552 4096 0.27 tar 14794 RM 202,1 8470384 4096 0.24 [...] The "tar" I/O looks like it is slightly random (based on BLOCK) and 4 Kbytes in size (BYTES). One returned in 14.9 milliseconds, but the rest were fast, so fast (0.24 ms) some may be returning from some level of cache (disk or controller). The "RM" TYPE means Read of Metadata. The start of the trace shows a couple of Writes by supervise PID 1809. Here's a deliberate random I/O workload: # ./iosnoop Tracing block I/O. Ctrl-C to end. COMM PID TYPE DEV BLOCK BYTES LATms randread 9182 R 202,32 30835224 8192 0.18 randread 9182 R 202,32 21466088 8192 0.15 randread 9182 R 202,32 13529496 8192 0.16 randread 9182 R 202,16 21250648 8192 0.18 randread 9182 R 202,16 1536776 32768 0.30 randread 9182 R 202,32 17157560 24576 0.23 randread 9182 R 202,32 21313320 8192 0.16 randread 9182 R 202,32 862184 8192 0.18 randread 9182 R 202,16 25496872 8192 0.21 randread 9182 R 202,32 31471768 8192 0.18 randread 9182 R 202,16 27571336 8192 0.20 randread 9182 R 202,16 30783448 8192 0.16 randread 9182 R 202,16 21435224 8192 1.28 randread 9182 R 202,16 970616 8192 0.15 randread 9182 R 202,32 13855608 8192 0.16 randread 9182 R 202,32 17549960 8192 0.15 randread 9182 R 202,32 30938232 8192 0.14 [...] Note the changing offsets. The resulting latencies are very good in this case, because the storage devices are flash memory-based solid state disks (SSDs). For rotational disks, I'd expect these latencies to be roughly 10 ms. Here's an idle Linux 3.2 system: # ./iosnoop Tracing block I/O. Ctrl-C to end. COMM PID TYPE DEV BLOCK BYTES LATms supervise 3055 W 202,1 12852496 4096 0.64 supervise 3055 W 202,1 12852504 4096 1.32 supervise 3055 W 202,1 12852800 4096 0.55 supervise 3055 W 202,1 12852808 4096 0.52 jbd2/xvda1-212 212 WS 202,1 1066720 45056 41.52 jbd2/xvda1-212 212 WS 202,1 1066808 12288 41.52 jbd2/xvda1-212 212 WS 202,1 1066832 4096 32.37 supervise 3055 W 202,1 12852800 4096 14.28 supervise 3055 W 202,1 12855920 4096 14.07 supervise 3055 W 202,1 12855960 4096 0.67 supervise 3055 W 202,1 12858208 4096 1.00 flush:1-409 409 W 202,1 12939640 12288 18.00 [...] This shows supervise doing various writes from PID 3055. The highest latency was from jbd2/xvda1-212, the journaling block device driver, doing synchronous writes (TYPE = WS). Options can be added to show the start time (-s) and end time (-t): # ./iosnoop -ts Tracing block I/O. Ctrl-C to end. STARTs ENDs COMM PID TYPE DEV BLOCK BYTES LATms 5982800.302061 5982800.302679 supervise 1809 W 202,1 17039600 4096 0.62 5982800.302423 5982800.302842 supervise 1809 W 202,1 17039608 4096 0.42 5982800.304962 5982800.305446 supervise 1801 W 202,1 17039616 4096 0.48 5982800.305250 5982800.305676 supervise 1801 W 202,1 17039624 4096 0.43 5982800.308849 5982800.309452 supervise 1810 W 202,1 12862464 4096 0.60 5982800.308856 5982800.309470 supervise 1806 W 202,1 17039632 4096 0.61 5982800.309206 5982800.309740 supervise 1806 W 202,1 17039640 4096 0.53 5982800.309211 5982800.309805 supervise 1810 W 202,1 12862472 4096 0.59 5982800.309332 5982800.309953 supervise 1812 W 202,1 17039648 4096 0.62 5982800.309676 5982800.310283 supervise 1812 W 202,1 17039656 4096 0.61 [...] This is useful when gathering I/O event data for post-processing. Now for matching on a single PID: # ./iosnoop -p 1805 Tracing block I/O issued by PID 1805. Ctrl-C to end. COMM PID TYPE DEV BLOCK BYTES LATms supervise 1805 W 202,1 17039648 4096 0.68 supervise 1805 W 202,1 17039672 4096 0.60 supervise 1805 W 202,1 17040040 4096 0.62 supervise 1805 W 202,1 17040056 4096 0.47 supervise 1805 W 202,1 17040624 4096 0.49 supervise 1805 W 202,1 17040632 4096 0.44 ^C Ending tracing... This option works by using an in-kernel filter for that PID on I/O issue. There is also a "-n" option to match on process names, however, that currently does so in user space, so is less efficient. I would say that this will generally identify the origin process, but there will be an error margin. Depending on the file system, block I/O queueing, and I/O subsystem, this could miss events that aren't issued in this PID context but are related to this PID (eg, triggering a read readahead on the completion of previous I/O. Again, whether this happens is up to the file system and storage subsystem). You can try the -Q option for more reliable process identification. The -Q option begins tracing on block I/O queue insert, instead of issue. Here's before and after, while dd(1) writes a large file: # ./iosnoop Tracing block I/O. Ctrl-C to end. COMM PID TYPE DEV BLOCK BYTES LATms dd 26983 WS 202,16 4064416 45056 16.70 dd 26983 WS 202,16 4064504 45056 16.72 dd 26983 WS 202,16 4064592 45056 16.74 dd 26983 WS 202,16 4064680 45056 16.75 cat 27031 WS 202,16 4064768 45056 16.56 cat 27031 WS 202,16 4064856 45056 16.46 cat 27031 WS 202,16 4064944 45056 16.40 gawk 27030 WS 202,16 4065032 45056 0.88 gawk 27030 WS 202,16 4065120 45056 1.01 gawk 27030 WS 202,16 4065208 45056 16.15 gawk 27030 WS 202,16 4065296 45056 16.16 gawk 27030 WS 202,16 4065384 45056 16.16 [...] The output here shows the block I/O time from issue to completion (LATms), which is largely representative of the device. The process names and PIDs identify dd, cat, and gawk. By default iosnoop shows who is on-CPU at time of block I/O issue, but these may not be the processes that originated the I/O. In this case (having debugged it), the reason is that processes such as cat and gawk are making hypervisor calls (this is a Xen guest instance), eg, for memory operations, and during hypervisor processing a queue of pending work is checked and dispatched. So cat and gawk were on-CPU when the block device I/O was issued, but they didn't originate it. Now the -Q option is used: # ./iosnoop -Q Tracing block I/O. Ctrl-C to end. COMM PID TYPE DEV BLOCK BYTES LATms kjournald 1217 WS 202,16 6132200 45056 141.12 kjournald 1217 WS 202,16 6132288 45056 141.10 kjournald 1217 WS 202,16 6132376 45056 141.10 kjournald 1217 WS 202,16 6132464 45056 141.11 kjournald 1217 WS 202,16 6132552 40960 141.11 dd 27718 WS 202,16 6132624 4096 0.18 flush:16-1279 1279 W 202,16 6132632 20480 0.52 flush:16-1279 1279 W 202,16 5940856 4096 0.50 flush:16-1279 1279 W 202,16 5949056 4096 0.52 flush:16-1279 1279 W 202,16 5957256 4096 0.54 flush:16-1279 1279 W 202,16 5965456 4096 0.56 flush:16-1279 1279 W 202,16 5973656 4096 0.58 flush:16-1279 1279 W 202,16 5981856 4096 0.60 flush:16-1279 1279 W 202,16 5990056 4096 0.63 [...] This uses the block_rq_insert tracepoint as the starting point of I/O, instead of block_rq_issue. This makes the following differences to columns and options: - COMM: more likely to show the originating process. - PID: more likely to show the originating process. - LATms: shows the I/O time, including time spent on the block I/O queue. - STARTs (not shown above): shows the time of queue insert, not I/O issue. - -p PID: more likely to match the originating process. - -n name: more likely to match the originating process. The reason that this ftrace-based iosnoop does not just instrument both insert and issue tracepoints is one of overhead. Even with buffering, iosnoop can have difficulty under high load. If I want to capture events for post-processing, I use the duration mode, which not only lets me set the duration, but also uses buffering, which reduces the overheads of tracing. Capturing 5 seconds, with both start timestamps (-s) and end timestamps (-t): # time ./iosnoop -ts 5 > out real 0m5.566s user 0m0.336s sys 0m0.140s # wc out 27010 243072 2619744 out This server is doing over 5,000 disk IOPS. Even with buffering, this did consume a measurable amount of CPU to capture: 0.48 seconds of CPU time in total. Note that the run took 5.57 seconds: this is 5 seconds for the capture, followed by the CPU time for iosnoop to fetch and process the buffer. Now tracing for 30 seconds: # time ./iosnoop -ts 30 > out real 0m31.207s user 0m0.884s sys 0m0.472s # wc out 64259 578313 6232898 out Since it's the same server and workload, this should have over 150k events, but only has 64k. The tracing buffer has overflowed, and events have been dropped. If I really must capture this many events, I can either increase the trace buffer size (it's the bufsize_kb setting in the script), or, use a different tracer (perf_evets, SystemTap, ktap, etc.) If the IOPS rate is low (eg, less than 5k), then unbuffered (no duration), despite the higher overheads, may be sufficient, and will keep capturing events until Ctrl-C. Here's an example of digging into the sequence of I/O to explain an outlier. My randread program on an SSD server (which is an AWS EC2 instance) usually experiences about 0.15 ms I/O latency, but there are some outliers as high as 20 milliseconds. Here's an excerpt: # ./iosnoop -ts > out # more out Tracing block I/O. Ctrl-C to end. STARTs ENDs COMM PID TYPE DEV BLOCK BYTES LATms 6037559.121523 6037559.121685 randread 22341 R 202,32 29295416 8192 0.16 6037559.121719 6037559.121874 randread 22341 R 202,16 27515304 8192 0.16 [...] 6037595.999508 6037596.000051 supervise 1692 W 202,1 12862968 4096 0.54 6037595.999513 6037596.000144 supervise 1687 W 202,1 17040160 4096 0.63 6037595.999634 6037596.000309 supervise 1693 W 202,1 17040168 4096 0.68 6037595.999937 6037596.000440 supervise 1693 W 202,1 17040176 4096 0.50 6037596.000579 6037596.001192 supervise 1689 W 202,1 17040184 4096 0.61 6037596.000826 6037596.001360 supervise 1689 W 202,1 17040192 4096 0.53 6037595.998302 6037596.018133 randread 22341 R 202,32 954168 8192 20.03 6037595.998303 6037596.018150 randread 22341 R 202,32 954200 8192 20.05 6037596.018182 6037596.018347 randread 22341 R 202,32 18836600 8192 0.16 [...] It's important to sort on the I/O completion time (ENDs). In this case it's already in the correct order. So my 20 ms reads happened after a large group of supervise writes were completed (I truncated dozens of supervise write lines to keep this example short). Other latency outliers in this output file showed the same sequence: slow reads after a batch of writes. Note the I/O request timestamp (STARTs), which shows that these 20 ms reads were issued before the supervise writes – so they had been sitting on a queue. I've debugged this type of issue many times before, but this one is different: those writes were to a different device (202,1), so I would have assumed they would be on different queues, and wouldn't interfere with each other. Somewhere in this system (Xen guest) it looks like there is a shared queue. (Having just discovered this using iosnoop, I can't yet tell you which queue, but I'd hope that after identifying it there would be a way to tune its queueing behavior, so that we can eliminate or reduce the severity of these outliers.) Use -h to print the USAGE message: # ./iosnoop -h USAGE: iosnoop [-hQst] [-d device] [-i iotype] [-p PID] [-n name] [duration] -d device # device string (eg, "202,1) -i iotype # match type (eg, '*R*' for all reads) -n name # process name to match on I/O issue -p PID # PID to match on I/O issue -Q # use queue insert as start time -s # include start time of I/O (s) -t # include completion time of I/O (s) -h # this usage message duration # duration seconds, and use buffers eg, iosnoop # watch block I/O live (unbuffered) iosnoop 1 # trace 1 sec (buffered) iosnoop -Q # include queueing time in LATms iosnoop -ts # include start and end timestamps iosnoop -i '*R*' # trace reads iosnoop -p 91 # show I/O issued when PID 91 is on-CPU iosnoop -Qp 91 # show I/O queued by PID 91, queue time See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/killsnoop_example.txt000066400000000000000000000046621361450357500264140ustar00rootroot00000000000000Demonstrations of killsnoop, the Linux ftrace version. What signals are happening on my system? # ./killsnoop Tracing kill()s. Ctrl-C to end. COMM PID TPID SIGNAL RETURN postgres 2209 2148 10 0 postgres 5416 2209 12 0 postgres 5416 2209 12 0 supervise 2135 5465 15 0 supervise 2135 5465 18 0 ^C Ending tracing... The first line of output shows that PID 2209, process name "postgres", has sent a signal 10 (SIGUSR1) to target PID 2148. This signal returned success (0). kilsnoop traces the kill() syscall, which is used to send signals to other processes. These signals can include SIGKILL and SIGTERM, both of which ultimately kill the target process (in different fashions), but the signals may also include other operations, including checking if a process still exists (signal 0). To read more about signals, see "man -s7 signal". killsnoop can be useful to identify why some processes are abruptly and unexpectedly ending (also check for the OOM killer in dmesg). The -s option can be used to print signal names instead of numbers: # ./killsnoop -s Tracing kill()s. Ctrl-C to end. COMM PID KILLED SIGNAL RETURN postgres 2209 2148 SIGUSR1 0 postgres 5665 2209 SIGUSR2 0 postgres 5665 2209 SIGUSR2 0 supervise 2135 5711 SIGTERM 0 supervise 2135 5711 SIGCONT 0 bash 27450 27450 0 0 [...] On the last line: there wasn't a nice signal name for signal 0, so just numeric 0 is printed. You'll see signal 0's used to check if processes still exist. Use -h to print the USAGE message: # ./opensnoop -h USAGE: killsnoop [-ht] [-d secs] [-p PID] [-n name] [filename] -d seconds # trace duration, and use buffers -n name # process name to match -p PID # PID to match on kill issue -t # include time (seconds) -s # human readable signal names -h # this usage message eg, killsnoop # watch kill()s live (unbuffered) killsnoop -d 1 # trace 1 sec (buffered) killsnoop -p 181 # trace kill()s issued to PID 181 only See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/kprobe_example.txt000066400000000000000000000526251361450357500256660ustar00rootroot00000000000000Demonstrations of kprobe, the Linux ftrace version. This traces the kernel do_sys_open() function, when it is called: # ./kprobe p:do_sys_open Tracing kprobe do_sys_open. Ctrl-C to end. kprobe-26042 [001] d... 6910441.001452: do_sys_open: (do_sys_open+0x0/0x220) kprobe-26042 [001] d... 6910441.001475: do_sys_open: (do_sys_open+0x0/0x220) kprobe-26042 [001] d... 6910441.001866: do_sys_open: (do_sys_open+0x0/0x220) kprobe-26042 [001] d... 6910441.001966: do_sys_open: (do_sys_open+0x0/0x220) supervise-1689 [000] d... 6910441.083302: do_sys_open: (do_sys_open+0x0/0x220) supervise-1693 [001] d... 6910441.083530: do_sys_open: (do_sys_open+0x0/0x220) supervise-1689 [000] d... 6910441.083759: do_sys_open: (do_sys_open+0x0/0x220) supervise-1693 [001] d... 6910441.083877: do_sys_open: (do_sys_open+0x0/0x220) [...] The "p:" is for creating a probe. Use "r:" to probe the return of the function: # ./kprobe r:do_sys_open Tracing kprobe do_sys_open. Ctrl-C to end. kprobe-29475 [001] d... 6910688.229777: do_sys_open: (SyS_open+0x1e/0x20 <- do_sys_open) <...>-29476 [001] d... 6910688.231101: do_sys_open: (SyS_open+0x1e/0x20 <- do_sys_open) <...>-29476 [001] d... 6910688.231123: do_sys_open: (SyS_open+0x1e/0x20 <- do_sys_open) <...>-29476 [001] d... 6910688.231530: do_sys_open: (SyS_open+0x1e/0x20 <- do_sys_open) <...>-29476 [001] d... 6910688.231624: do_sys_open: (SyS_open+0x1e/0x20 <- do_sys_open) supervise-1685 [001] d... 6910688.328776: do_sys_open: (SyS_open+0x1e/0x20 <- do_sys_open) supervise-1689 [000] d... 6910688.328780: do_sys_open: (SyS_open+0x1e/0x20 <- do_sys_open) [...] This output includes the function that the traced function is returning to. The trace output can be a little different between kernel versions. Use -H to print the header: # ./kprobe -H p:do_sys_open Tracing kprobe do_sys_open. Ctrl-C to end. # tracer: nop # # entries-in-buffer/entries-written: 4/4 #P:2 # # _-----=> irqs-off # / _----=> need-resched # | / _---=> hardirq/softirq # || / _--=> preempt-depth # ||| / delay # TASK-PID CPU# |||| TIMESTAMP FUNCTION # | | | |||| | | kprobe-27952 [001] d... 6910580.008086: do_sys_open: (do_sys_open+0x0/0x220) kprobe-27952 [001] d... 6910580.008109: do_sys_open: (do_sys_open+0x0/0x220) kprobe-27952 [001] d... 6910580.008483: do_sys_open: (do_sys_open+0x0/0x220) [...] These columns are explained in the kernel source under Documentation/trace/ftrace.txt. This traces do_sys_open() returns, using a probe alias "myopen", and showing the return value ($retval): # ./kprobe 'r:myopen do_sys_open $retval' Tracing kprobe myopen. Ctrl-C to end. kprobe-26386 [001] d... 6593278.858754: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x3 <...>-26387 [001] d... 6593278.860043: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x3 <...>-26387 [001] d... 6593278.860064: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x3 <...>-26387 [001] d... 6593278.860433: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x3 <...>-26387 [001] d... 6593278.860521: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x3 supervise-1685 [001] d... 6593279.178806: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1689 [001] d... 6593279.228756: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1689 [001] d... 6593279.229106: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1688 [000] d... 6593279.229501: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1695 [000] d... 6593279.229944: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1685 [001] d... 6593279.230104: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1687 [001] d... 6593279.230293: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1699 [000] d... 6593279.230381: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1692 [000] d... 6593279.230825: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1698 [000] d... 6593279.230915: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1698 [000] d... 6593279.231277: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 supervise-1690 [000] d... 6593279.231703: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) arg1=0x9 ^C Ending tracing... The string specified, 'r:myopen do_sys_open $retval', is a kprobe definition, and is the same as those documented in the Linux kernel source under Documentation/trace/kprobetrace.txt, which can be written to the /sys/kernel/debug/tracing/kprobe_events file. Apart from probe name aliases, you can also provide arbitrary names for arguments. Eg, instead of the "arg1" default, calling it "rval": # ./kprobe 'r:myopen do_sys_open rval=$retval' Tracing kprobe myopen. Ctrl-C to end. kprobe-27454 [001] d... 6593356.250019: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x3 <...>-27455 [001] d... 6593356.251280: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x3 <...>-27455 [001] d... 6593356.251301: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x3 <...>-27455 [001] d... 6593356.251672: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x3 <...>-27455 [001] d... 6593356.251769: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x3 supervise-1689 [000] d... 6593356.859758: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x9 supervise-1689 [000] d... 6593356.860143: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x9 supervise-1696 [000] d... 6593356.862682: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x9 supervise-1685 [001] d... 6593356.862684: myopen: (SyS_open+0x1e/0x20 <- do_sys_open) rval=0x9 [...] That's a bit better. Tracing the open() mode: # ./kprobe 'p:myopen do_sys_open mode=%cx:u16' Tracing kprobe myopen. Ctrl-C to end. kprobe-29572 [001] d... 6593503.353923: myopen: (do_sys_open+0x0/0x220) mode=0x1 kprobe-29572 [001] d... 6593503.353945: myopen: (do_sys_open+0x0/0x220) mode=0x0 kprobe-29572 [001] d... 6593503.354307: myopen: (do_sys_open+0x0/0x220) mode=0x5c00 kprobe-29572 [001] d... 6593503.354401: myopen: (do_sys_open+0x0/0x220) mode=0x0 supervise-1689 [000] d... 6593503.944125: myopen: (do_sys_open+0x0/0x220) mode=0x1a4 supervise-1688 [001] d... 6593503.944125: myopen: (do_sys_open+0x0/0x220) mode=0x1a4 supervise-1688 [001] d... 6593503.944606: myopen: (do_sys_open+0x0/0x220) mode=0x1a4 supervise-1689 [000] d... 6593503.944606: myopen: (do_sys_open+0x0/0x220) mode=0x1a4 supervise-1698 [000] d... 6593503.944728: myopen: (do_sys_open+0x0/0x220) mode=0x1a4 supervise-1698 [000] d... 6593503.945077: myopen: (do_sys_open+0x0/0x220) mode=0x1a4 [...] Here I guessed that the mode was in register %cx, and cast it as a 16-bit unsigned integer (":u16"). Your platform and kernel may be different, and the mode may be in a different register. If fiddling with such registers becomes too painful or unreliable for you, consider installing kernel debuginfo and using the named variables with perf_events "perf probe". Tracing the open() filename: # ./kprobe 'p:myopen do_sys_open filename=+0(%si):string' Tracing kprobe myopen. Ctrl-C to end. kprobe-32369 [001] d... 6593706.999728: myopen: (do_sys_open+0x0/0x220) filename="/etc/ld.so.cache" kprobe-32369 [001] d... 6593706.999748: myopen: (do_sys_open+0x0/0x220) filename="/lib/x86_64-linux-gnu/libc.so.6" kprobe-32369 [001] d... 6593707.000092: myopen: (do_sys_open+0x0/0x220) filename="/usr/lib/locale/locale-archive" kprobe-32369 [001] d... 6593707.000176: myopen: (do_sys_open+0x0/0x220) filename="trace_pipe" supervise-1699 [000] d... 6593707.254970: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1689 [001] d... 6593707.254970: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1689 [001] d... 6593707.255432: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1699 [000] d... 6593707.255432: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1695 [001] d... 6593707.258805: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" [...] As mentioned previously, the %si register may be different on your platform. In this example, I cast it as a string. Specifying a duration will buffer in-kernel (reducing overhead), and write at the end. Here's tracing for 10 seconds, and writing to the "out" file: # ./kprobe -d 10 'p:myopen do_sys_open filename=+0(%si):string' > out You can match on a single PID only: # ./kprobe -p 1696 'p:myopen do_sys_open filename=+0(%si):string' Tracing kprobe myopen. Ctrl-C to end. supervise-1696 [001] d... 6593773.677033: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1696 [001] d... 6593773.677332: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1696 [001] d... 6593774.697144: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1696 [001] d... 6593774.697675: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1696 [001] d... 6593775.717986: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" supervise-1696 [001] d... 6593775.718499: myopen: (do_sys_open+0x0/0x220) filename="supervise/status.new" ^C Ending tracing... This will only show events when that PID is on-CPU. The -v option will show you the available variables you can use in custom filters: # ./kprobe -v 'p:myopen do_sys_open filename=+0(%si):string' name: myopen ID: 1443 format: field:unsigned short common_type; offset:0; size:2; signed:0; field:unsigned char common_flags; offset:2; size:1; signed:0; field:unsigned char common_preempt_count; offset:3; size:1; signed:0; field:int common_pid; offset:4; size:4; signed:1; field:unsigned long __probe_ip; offset:8; size:8; signed:0; field:__data_loc char[] filename; offset:16; size:4; signed:1; print fmt: "(%lx) filename=\"%s\"", REC->__probe_ip, __get_str(filename) Tracing filenames that end in "stat", by adding a filter: # ./kprobe 'p:myopen do_sys_open filename=+0(%si):string' 'filename ~ "*stat"' Tracing kprobe myopen. Ctrl-C to end. postgres-1172 [000] d... 6594028.787166: myopen: (do_sys_open+0x0/0x220) filename="pg_stat_tmp/pgstat.stat" postgres-1172 [001] d... 6594028.797410: myopen: (do_sys_open+0x0/0x220) filename="pg_stat_tmp/pgstat.stat" postgres-1172 [001] d... 6594028.797467: myopen: (do_sys_open+0x0/0x220) filename="pg_stat_tmp/pgstat.stat" postgres-4443 [001] d... 6594028.800908: myopen: (do_sys_open+0x0/0x220) filename="pg_stat_tmp/pgstat.stat" postgres-4443 [000] d... 6594028.811237: myopen: (do_sys_open+0x0/0x220) filename="pg_stat_tmp/pgstat.stat" postgres-4443 [000] d... 6594028.811290: myopen: (do_sys_open+0x0/0x220) filename="pg_stat_tmp/pgstat.stat" ^C Ending tracing... This filtering is done in-kernel context. As an example of tracing a deeper kernel function, lets trace bio_alloc() and entry registers: # ./kprobe 'p:myprobe bio_alloc %ax %bx %cx %dx' Tracing kprobe myprobe. Ctrl-C to end. supervise-3055 [000] 2172148.728250: myprobe: (bio_alloc+0x0/0x30) arg1=ffff880064acc8d0 arg2=ffff8800e56a7990 arg3=0 arg4=ffff880064acc910 supervise-3055 [000] 2172148.728527: myprobe: (bio_alloc+0x0/0x30) arg1=ffff880064acf948 arg2=ffff8800e56a7990 arg3=0 arg4=ffff880064acf988 jbd2/xvda1-8-212 [000] 2172149.749474: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800ad1f87b8 arg3=ffff8800ba22c06c arg4=8 jbd2/xvda1-8-212 [000] 2172149.749485: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff880089d053a8 arg3=10f16c5bb arg4=0 jbd2/xvda1-8-212 [000] 2172149.749487: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff880089d05958 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749488: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff880089d05b60 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749489: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff880089d05820 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749489: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff880089d055b0 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749490: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff88006ff22ea0 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749491: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff880089d1f000 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749492: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff880089d1f138 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749493: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff88005d267138 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749494: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff88005d267680 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.749495: myprobe: (bio_alloc+0x0/0x30) arg1=0 arg2=ffff88005d2675b0 arg3=5 arg4=0 jbd2/xvda1-8-212 [000] 2172149.751044: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800cc241ea0 arg3=445f0300 arg4=ffff8800effba000 supervise-3055 [000] 2172149.751095: myprobe: (bio_alloc+0x0/0x30) arg1=ffff880064acf948 arg2=ffff8800e56a7990 arg3=0 arg4=ffff880064acf988 supervise-3055 [000] 2172149.751341: myprobe: (bio_alloc+0x0/0x30) arg1=ffff880064acc8d0 arg2=ffff8800e56a7990 arg3=0 arg4=ffff880064acc910 supervise-3055 [000] 2172150.772033: myprobe: (bio_alloc+0x0/0x30) arg1=ffff880064acc8d0 arg2=ffff8800e56a7990 arg3=0 arg4=ffff880064acc910 supervise-3055 [000] 2172150.772305: myprobe: (bio_alloc+0x0/0x30) arg1=ffff880064acf948 arg2=ffff8800e56a7990 arg3=0 arg4=ffff880064acf988 flush-202:1-409 [000] 2172151.087815: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800da51d6e8 arg3=16afd arg4=1 flush-202:1-409 [000] 2172151.087829: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800e7537f08 arg3=16afd arg4=2 flush-202:1-409 [000] 2172151.087844: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800e7519af8 arg3=16afd arg4=3 flush-202:1-409 [000] 2172151.087846: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800e7511478 arg3=16afd arg4=4 flush-202:1-409 [000] 2172151.087849: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800e75e6a90 arg3=16afd arg4=5 flush-202:1-409 [000] 2172151.087851: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800e7512bc8 arg3=16afd arg4=6 flush-202:1-409 [000] 2172151.087853: myprobe: (bio_alloc+0x0/0x30) arg1=ffffffff arg2=ffff8800eb3bf410 arg3=16afd arg4=7 ^C The output includes who is on-CPU, high resolution timestamps, and the arguments we requested (registers %ax to %dx). These registers are platform dependent, and are mapped by the compiler to the entry arguments of the function. How are these useful? If you are debugging this kernel function, you'll know. :) Note that you can add qualifiers, eg, if I knew %ax was a uint32: # ./kprobe 'p:myprobe bio_alloc %ax:u32' Tracing kprobe myprobe. Ctrl-C to end. supervise-3055 [000] 2172389.734606: myprobe: (bio_alloc+0x0/0x30) arg1=64acf948 supervise-3055 [000] 2172389.734865: myprobe: (bio_alloc+0x0/0x30) arg1=64acc8d0 supervise-3055 [000] 2172390.772391: myprobe: (bio_alloc+0x0/0x30) arg1=64acf948 supervise-3055 [000] 2172390.772676: myprobe: (bio_alloc+0x0/0x30) arg1=64acc8d0 ^C Ending tracing... You can give them aliases too, instead of the default arg1..N: # ./kprobe 'p:myprobe bio_alloc ax=%ax' Tracing kprobe myprobe. Ctrl-C to end. supervise-3055 [000] 2172420.451663: myprobe: (bio_alloc+0x0/0x30) ax=ffff880064acc8d0 supervise-3055 [000] 2172420.451938: myprobe: (bio_alloc+0x0/0x30) ax=ffff880064acf948 flush-202:1-409 [000] 2172421.163462: myprobe: (bio_alloc+0x0/0x30) ax=ffff880064acc8d0 supervise-3055 [000] 2172421.500994: myprobe: (bio_alloc+0x0/0x30) ax=ffff880064acc8d0 supervise-3055 [000] 2172421.501307: myprobe: (bio_alloc+0x0/0x30) ax=ffff880064acf948 ^C Ending tracing... Now for the return of bio_alloc(): # ./kprobe 'r:myprobe bio_alloc $retval' Tracing kprobe myprobe. Ctrl-C to end. supervise-3055 [000] 2172164.145533: myprobe: (io_submit_init.isra.6+0x74/0x100 <- bio_alloc) arg1=ffff8800e55843c0 supervise-3055 [000] 2172164.145829: myprobe: (io_submit_init.isra.6+0x74/0x100 <- bio_alloc) arg1=ffff8800e5584840 jbd2/xvda1-8-212 [000] 2172165.166453: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e57596c0 jbd2/xvda1-8-212 [000] 2172165.166493: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759c00 jbd2/xvda1-8-212 [000] 2172165.166496: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759600 jbd2/xvda1-8-212 [000] 2172165.166497: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759e40 jbd2/xvda1-8-212 [000] 2172165.166498: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e57590c0 jbd2/xvda1-8-212 [000] 2172165.166500: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e57599c0 jbd2/xvda1-8-212 [000] 2172165.166500: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759a80 jbd2/xvda1-8-212 [000] 2172165.166502: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759f00 jbd2/xvda1-8-212 [000] 2172165.166503: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759540 jbd2/xvda1-8-212 [000] 2172165.166504: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759180 jbd2/xvda1-8-212 [000] 2172165.166504: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759900 jbd2/xvda1-8-212 [000] 2172165.166505: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759000 jbd2/xvda1-8-212 [000] 2172165.166506: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759480 <...>-212 [000] 2172165.176261: myprobe: (submit_bh+0x76/0x120 <- bio_alloc) arg1=ffff8800e5759480 supervise-3055 [000] 2172165.176317: myprobe: (io_submit_init.isra.6+0x74/0x100 <- bio_alloc) arg1=ffff8800e57596c0 supervise-3055 [000] 2172165.176586: myprobe: (io_submit_init.isra.6+0x74/0x100 <- bio_alloc) arg1=ffff8800e5759900 ^C Ending tracing... Great. This output includes the function we are returning to, in most cases, submit_bh(). Note that this mode (without a duration) prints events as they happen, so the overheads can be high for frequent events. You could try the -d mode, which buffers in-kernel. The -s option will print the kernel stack trace after the event: # ./kprobe -s 'p:mytcp tcp_init_cwnd' Tracing kprobe mytcp. Ctrl-C to end. sshd-5121 [000] d... 6897275.911301: mytcp: (tcp_init_cwnd+0x0/0x40) sshd-5121 [000] d... 6897275.911309: => tcp_write_xmit => __tcp_push_pending_frames => tcp_push => tcp_sendmsg => inet_sendmsg => sock_aio_write => do_sync_write => vfs_write => SyS_write => system_call_fastpath sshd-32219 [000] d... 6897275.911467: mytcp: (tcp_init_cwnd+0x0/0x40) sshd-32219 [000] d... 6897275.911471: => tcp_write_xmit => __tcp_push_pending_frames => tcp_push => tcp_sendmsg => inet_sendmsg => sock_aio_write => do_sync_write => vfs_write => SyS_write => system_call_fastpath sshd-5121 [000] d... 6897277.878794: mytcp: (tcp_init_cwnd+0x0/0x40) sshd-5121 [000] d... 6897277.878801: => tcp_write_xmit => __tcp_push_pending_frames => tcp_push => tcp_sendmsg => inet_sendmsg => sock_aio_write => do_sync_write => vfs_write => SyS_write => system_call_fastpath This makes use of the kernel options/stacktrace feature. Use -h to print the USAGE message: # ./kprobe -h USAGE: kprobe [-FhHsv] [-d secs] [-p PID] [-L TID] kprobe_definition [filter] -F # force. trace despite warnings. -d seconds # trace duration, and use buffers -p PID # PID to match on events -L TID # thread id to match on events -v # view format file (don't trace) -H # include column headers -s # show kernel stack traces -h # this usage message Note that these examples may need modification to match your kernel version's function names and platform's register usage. eg, kprobe p:do_sys_open # trace open() entry kprobe r:do_sys_open # trace open() return kprobe 'r:do_sys_open $retval' # trace open() return value kprobe 'r:myopen do_sys_open $retval' # use a custom probe name kprobe 'p:myopen do_sys_open mode=%cx:u16' # trace open() file mode kprobe 'p:myopen do_sys_open filename=+0(%si):string' # trace open() with filename kprobe -s 'p:myprobe tcp_retransmit_skb' # show kernel stacks kprobe 'p:do_sys_open file=+0(%si):string' 'file ~ "*stat"' # opened files ending in "stat" See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/opensnoop_example.txt000066400000000000000000000037371361450357500264240ustar00rootroot00000000000000Demonstrations of opensnoop, the Linux ftrace version. # ./opensnoop Tracing open()s. Ctrl-C to end. COMM PID FD FILE opensnoop 5334 0x3 <...> 5343 0x3 /etc/ld.so.cache opensnoop 5342 0x3 /etc/ld.so.cache <...> 5343 0x3 /lib/x86_64-linux-gnu/libc.so.6 opensnoop 5342 0x3 /lib/x86_64-linux-gnu/libm.so.6 opensnoop 5342 0x3 /lib/x86_64-linux-gnu/libc.so.6 <...> 5343 0x3 /usr/lib/locale/locale-archive <...> 5343 0x3 trace_pipe supervise 1684 0x9 supervise/status.new supervise 1684 0x9 supervise/status.new supervise 1688 0x9 supervise/status.new supervise 1688 0x9 supervise/status.new supervise 1686 0x9 supervise/status.new supervise 1685 0x9 supervise/status.new supervise 1685 0x9 supervise/status.new supervise 1686 0x9 supervise/status.new [...] The first several lines show opensnoop catching itself initializing. Use -h to print the USAGE message: # ./opensnoop -h USAGE: opensnoop [-htx] [-d secs] [-p PID] [-L TID] [-n name] [filename] -d seconds # trace duration, and use buffers -n name # process name to match on open -p PID # PID to match on open -L TID # thread id to match on open -t # include time (seconds) -x # only show failed opens -h # this usage message filename # match filename (partials, REs, ok) eg, opensnoop # watch open()s live (unbuffered) opensnoop -d 1 # trace 1 sec (buffered) opensnoop -p 181 # trace I/O issued by PID 181 only opensnoop conf # trace filenames containing "conf" opensnoop 'log$' # filenames ending in "log" See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/perf-stat-hist_example.txt000066400000000000000000000163641361450357500272560ustar00rootroot00000000000000Demonstrations of perf-stat-hist, the Linux perf_events version. Tracing the net:net_dev_xmit tracepoint, and building a power-of-4 histogram for the "len" variable, for 10 seconds: # ./perf-stat-hist net:net_dev_xmit len 10 Tracing net:net_dev_xmit, power-of-4, max 1048576, for 10 seconds... Range : Count Distribution 0 : 0 | | 1 -> 3 : 0 | | 4 -> 15 : 0 | | 16 -> 63 : 2 |# | 64 -> 255 : 30 |### | 256 -> 1023 : 3 |# | 1024 -> 4095 : 446 |######################################| 4096 -> 16383 : 0 | | 16384 -> 65535 : 0 | | 65536 -> 262143 : 0 | | 262144 -> 1048575 : 0 | | 1048576 -> : 0 | | This showed that most of the network transmits were between 1024 and 4095 bytes, with a handful between 64 and 255 bytes. Cat the format file for the tracepoint to see what other variables are available to trace. Eg: # cat /sys/kernel/debug/tracing/events/net/net_dev_xmit/format name: net_dev_xmit ID: 1078 format: field:unsigned short common_type; offset:0; size:2; signed:0; field:unsigned char common_flags; offset:2; size:1; signed:0; field:unsigned char common_preempt_count; offset:3; size:1; signed:0; field:int common_pid; offset:4; size:4; signed:1; field:void * skbaddr; offset:8; size:8; signed:0; field:unsigned int len; offset:16; size:4; signed:0; field:int rc; offset:20; size:4; signed:1; field:__data_loc char[] name; offset:24; size:4; signed:1; print fmt: "dev=%s skbaddr=%p len=%u rc=%d", __get_str(name), REC->skbaddr, REC->len, REC->rc That's where "len" came from. This works by creating a series of tracepoint and filter pairs for each histogram bucket, and doing in-kernel counts. The overhead should in many cases be better than user space post-processing, however, this approach is still not ideal. I've called it a "perf hacktogram". The overhead is relative to the frequency of events, multiplied by the number of buckets. You can modify the script to use power-of-2 instead, or whatever you like, but the overhead for more buckets will be higher. Histogram of the returned read() syscall sizes: # ./perf-stat-hist syscalls:sys_exit_read ret 10 Tracing syscalls:sys_exit_read, power-of-4, max 1048576, for 10 seconds... Range : Count Distribution 0 : 90 |# | 1 -> 3 : 9587 |######################################| 4 -> 15 : 69 |# | 16 -> 63 : 590 |### | 64 -> 255 : 250 |# | 256 -> 1023 : 389 |## | 1024 -> 4095 : 296 |## | 4096 -> 16383 : 183 |# | 16384 -> 65535 : 12 |# | 65536 -> 262143 : 0 | | 262144 -> 1048575 : 0 | | 1048576 -> : 0 | | Most of our read()s were tiny, between 1 and 3 bytes. Using power-of-2, and a max of 1024: # ./perf-stat-hist -P 2 -m 1024 syscalls:sys_exit_read ret Tracing syscalls:sys_exit_read, power-of-2, max 1024, until Ctrl-C... ^C Range : Count Distribution -> -1 : 29 |## | 0 -> 0 : 1 |# | 1 -> 1 : 959 |######################################| 2 -> 3 : 1 |# | 4 -> 7 : 0 | | 8 -> 15 : 2 |# | 16 -> 31 : 14 |# | 32 -> 63 : 1 |# | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 1 |# | 1024 -> : 1 |# | Specifying custom bucket sizes: # ./perf-stat-hist -b "10 50 100 5000" syscalls:sys_exit_read ret Tracing syscalls:sys_exit_read, specified buckets, until Ctrl-C... ^C Range : Count Distribution -> 9 : 989 |######################################| 10 -> 49 : 5 |# | 50 -> 99 : 0 | | 100 -> 4999 : 2 |# | 5000 -> : 0 | | Specifying a single value to bifurcate statistics: # ./perf-stat-hist -b 10 syscalls:sys_exit_read ret Tracing syscalls:sys_exit_read, specified buckets, until Ctrl-C... ^C Range : Count Distribution -> 9 : 2959 |######################################| 10 -> : 7 |# | This has the lowest overhead for collection, since only two tracepoint filter pairs are used. Use -h to print the USAGE message: # ./perf-stat-hist -h USAGE: perf-stat-hist [-h] [-b buckets|-P power] [-m max] tracepoint variable [seconds] -b buckets # specify histogram bucket points -P power # power-of (default is 4) -m max # max value for power-of -h # this usage message eg, perf-stat-hist syscalls:sys_enter_read count 5 # read() request histogram, 5 seconds perf-stat-hist syscalls:sys_exit_read ret 5 # read() return histogram, 5 seconds perf-stat-hist -P 10 syscalls:sys_exit_read ret 5 # ... use power-of-10 perf-stat-hist -P 2 -m 1024 syscalls:sys_exit_read ret 5 # ... use power-of-2, max 1024 perf-stat-hist -b "10 50 100 500" syscalls:sys_exit_read ret 5 # ... histogram based on these bucket ranges perf-stat-hist -b 10 syscalls:sys_exit_read ret 5 # ... bifurcate by the value 10 (lowest overhead) See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/reset-ftrace_example.txt000066400000000000000000000051071361450357500267610ustar00rootroot00000000000000Demonstrations of reset-ftrace, the Linux ftrace tool. You will probably never need this tool. If you kill -9 an ftrace-based tool, leaving the kernel in a tracing enabled state, you could try using this tool to reset ftrace and disable tracing. Make sure no other ftrace sessions are in use on your system, or it will kill those. Here's an example: # ./opensnoop Tracing open()s. Ctrl-C to end. ERROR: ftrace may be in use by PID 2197 /var/tmp/.ftrace-lock I tried to run opensnoop, but there's a lock file for PID 2197. Checking if it exists: # ps -fp 2197 UID PID PPID C STIME TTY TIME CMD # No. I also know that no one is using ftrace on this system. So I'll use reset-ftrace to clean up this lock file and ftrace state: # ./reset-ftrace ERROR: ftrace lock (/var/tmp/.ftrace-lock) exists. It shows ftrace may be in use by PID 2197. Double check to see if that PID is still active. If not, consider using -f to force a reset. Exiting. ... except it's complaining about the lock file too. I'm already sure that this PID doesn't exist, so I'll add the -f option: # ./reset-ftrace -f Reseting ftrace state... current_tracer, before: 1 nop current_tracer, after: 1 nop set_ftrace_filter, before: 1 #### all functions enabled #### set_ftrace_filter, after: 1 #### all functions enabled #### set_ftrace_pid, before: 1 no pid set_ftrace_pid, after: 1 no pid kprobe_events, before: kprobe_events, after: Done. The output shows what has been reset, including the before and after state of these files. Now I can try iosnoop again: # ./iosnoop Tracing block I/O. Ctrl-C to end. COMM PID TYPE DEV BLOCK BYTES LATms supervise 1689 W 202,1 17039664 4096 0.58 supervise 1689 W 202,1 17039672 4096 0.47 supervise 1694 W 202,1 17039744 4096 0.98 supervise 1694 W 202,1 17039752 4096 0.74 supervise 1684 W 202,1 17039760 4096 0.63 [...] Fixed. Note that reset-ftrace currently only resets a few methods of enabling tracing, such as set_ftrace_filter and kprobe_events. Static tracepoints could be enabled individually, and this script currently doesn't find and disable those. Use -h to print the USAGE message: # ./reset-ftrace -h USAGE: reset-ftrace [-fhq] -f # force: delete ftrace lock file -q # quiet: reset, but say nothing -h # this usage message eg, reset-ftrace # disable active ftrace session perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/syscount_example.txt000066400000000000000000000220531361450357500262630ustar00rootroot00000000000000Demonstrations of syscount, the Linux perf_events version. The first mode I use is "-c", where it behaves like "strace -c", but for the entire system (all procesess) and with much lower overhead: # ./syscount -c Tracing... Ctrl-C to end. ^Csleep: Interrupt SYSCALL COUNT accept 1 getsockopt 1 setsid 1 chdir 2 getcwd 2 getpeername 2 getsockname 2 setgid 2 setgroups 2 setpgid 2 setuid 2 getpgrp 4 getpid 4 rename 4 setitimer 4 setrlimit 4 setsockopt 4 statfs 4 set_tid_address 5 readlink 6 set_robust_list 6 nanosleep 7 newuname 7 faccessat 8 futex 10 clock_gettime 16 newlstat 20 pipe 20 epoll_wait 24 getrlimit 25 socket 27 connect 29 exit_group 30 getppid 31 dup2 34 wait4 51 fcntl 58 getegid 72 getgid 72 getuid 72 geteuid 75 perf_event_open 100 munmap 121 gettimeofday 216 access 266 ioctl 340 poll 348 sendto 374 mprotect 414 brk 597 rt_sigaction 632 recvfrom 664 lseek 749 newfstatat 2922 openat 2925 newfstat 3229 newstat 4334 open 4534 fchdir 5845 getdents 5854 read 7673 close 7728 select 9633 rt_sigprocmask 19886 write 34581 While tracing, the write() syscall was executed 34,581 times. This mode uses "perf stat" to count the syscalls:* tracepoints in-kernel. You can add a duration (-d) and limit the number shown (-t): # ./syscount -cd 5 -t 10 Tracing for 5 seconds. Top 10 only... SYSCALL COUNT gettimeofday 1009 write 3583 read 8174 openat 21550 newfstat 21558 open 21824 fchdir 43098 getdents 43106 close 43694 newfstatat 110936 While tracing for 5 seconds, the newfstatat() syscall was executed 110,936 times. Without the -c, syscount shows syscalls by process name: # ./syscount -d 5 -t 10 Tracing for 5 seconds. Top 10 only... [ perf record: Woken up 66 times to write data ] [ perf record: Captured and wrote 16.513 MB perf.data (~721455 samples) ] COMM COUNT stat 450 perl 537 catalina.sh 1700 postgres 2094 run 2362 :6946 4764 ps 5961 sshd 45796 find 61039 So processes named "find" called 61,039 syscalls during the 5 seconds of tracing. Note that this mode writes a perf.data file. This is higher overhead for a few reasons: - all data is passed from kernel to user space, which eats CPU for the memory copy. Note that it is buffered in an efficient way by perf_events, which wakes up and context switches only a small number of times: 66 in this case, to hand 16 Mbytes of trace data to user space. - data is post-processed in user space, eating more CPU. - data is stored on the file system in the perf.data file, consuming available storage. This will be improved in future kernels, but it is difficult to improve this much further in existing kernels. For example, using a pipe to "perf script" instead of writing perf.data can have issues with feedback loops, where perf traces itself. This syscount version goes to lengths to avoid tracing its own perf, but right now with existing functionality in older kernels. The trip via perf.data is necessary Running without options shows syscalls by process name until Ctrl-C: # ./syscount Tracing... Ctrl-C to end. ^C[ perf record: Woken up 39 times to write data ] [ perf record: Captured and wrote 9.644 MB perf.data (~421335 samples) ] COMM COUNT apache2 8 apacheLogParser 13 platformservice 16 snmpd 16 ntpd 21 multilog 66 supervise 84 dirname 102 echo 102 svstat 108 cut 111 bash 113 grep 132 xargs 132 redis-server 190 sed 192 setuidgid 294 stat 450 perl 537 catalina.sh 1275 postgres 1736 run 2352 :7396 4527 ps 5925 sshd 20154 find 28700 Note again it is writing a perf.data file to do this. The -v option adds process IDs: # ./syscount -v Tracing... Ctrl-C to end. ^C[ perf record: Woken up 48 times to write data ] [ perf record: Captured and wrote 12.114 MB perf.data (~529276 samples) ] PID COMM COUNT 3599 apacheLogParser 3 7977 xargs 3 7982 supervise 3 7993 xargs 3 3575 apache2 4 1311 ntpd 6 3135 postgres 6 3600 apacheLogParser 6 3210 platformservice 8 6503 sshd 9 7978 :7978 9 7994 run 9 7968 :7968 11 7984 run 11 1451 snmpd 16 3040 svscan 17 3066 postgres 17 3133 postgres 24 3134 postgres 24 3136 postgres 24 3061 multilog 29 3055 supervise 30 7979 bash 31 7977 echo 34 7981 dirname 34 7993 echo 34 7968 svstat 36 7984 svstat 36 7975 cut 37 7991 cut 37 9857 bash 37 7967 :7967 40 7983 run 40 7972 :7972 41 7976 xargs 41 7988 run 41 7992 xargs 41 7969 :7969 42 7976 :7976 42 7985 run 42 7992 run 42 7973 :7973 43 7974 :7974 43 7989 run 43 7990 run 43 7973 grep 44 7989 grep 44 7975 :7975 45 7991 run 45 7970 :7970 51 7986 run 51 7981 catalina.sh 52 7974 sed 64 7990 sed 64 3455 postgres 66 7971 :7971 66 7987 run 66 7966 :7966 96 7966 setuidgid 98 3064 redis-server 110 7970 stat 150 7986 stat 150 7969 perl 179 7985 perl 179 7982 run 341 7966 catalina.sh 373 7980 postgres 432 7972 ps 1971 7988 ps 1983 9832 sshd 37511 7979 find 51040 Once you've found a process ID of interest, you can use "-c" and "-p PID" to show syscall names. This also switches to "perf stat" mode for in-kernel counts, and lower overhead: # ./syscount -cp 7979 Tracing PID 7979... Ctrl-C to end. ^CSYSCALL COUNT brk 10 newfstat 2171 open 2171 newfstatat 2175 openat 2175 close 4346 fchdir 4346 getdents 4351 write 25482 So the most frequent syscall by PID 7979 was write(). Use -h to print the USAGE message: # ./syscount -h USAGE: syscount [-chv] [-t top] {-p PID|-d seconds|command} syscount # count by process name -c # show counts by syscall name -h # this usage message -v # verbose: shows PID -p PID # trace this PID only -d seconds # duration of trace -t num # show top number only command # run and trace this command eg, syscount # syscalls by process name syscount -c # syscalls by syscall name syscount -d 5 # trace for 5 seconds syscount -cp 923 # syscall names for PID 923 syscount -c ls # syscall names for "ls" See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/tcpretrans_example.txt000066400000000000000000000066771361450357500265770ustar00rootroot00000000000000Demonstrations of tcpretrans, the Linux ftrace version. Tracing TCP retransmits on a busy server: # ./tcpretrans TIME PID LADDR:LPORT -- RADDR:RPORT STATE 05:16:44 3375 10.150.18.225:53874 R> 10.105.152.3:6001 ESTABLISHED 05:16:44 3375 10.150.18.225:53874 R> 10.105.152.3:6001 ESTABLISHED 05:16:54 4028 10.150.18.225:6002 R> 10.150.30.249:1710 ESTABLISHED 05:16:54 4028 10.150.18.225:6002 R> 10.150.30.249:1710 ESTABLISHED 05:16:54 4028 10.150.18.225:6002 R> 10.150.30.249:1710 ESTABLISHED 05:16:54 4028 10.150.18.225:6002 R> 10.150.30.249:1710 ESTABLISHED 05:16:54 4028 10.150.18.225:6002 R> 10.150.30.249:1710 ESTABLISHED 05:16:54 4028 10.150.18.225:6002 R> 10.150.30.249:1710 ESTABLISHED 05:16:54 4028 10.150.18.225:6002 R> 10.150.30.249:1710 ESTABLISHED 05:16:55 0 10.150.18.225:47115 R> 10.71.171.158:6001 ESTABLISHED 05:16:58 0 10.150.18.225:44388 R> 10.103.130.120:6001 ESTABLISHED 05:16:58 0 10.150.18.225:44388 R> 10.103.130.120:6001 ESTABLISHED 05:16:58 0 10.150.18.225:44388 R> 10.103.130.120:6001 ESTABLISHED 05:16:59 0 10.150.18.225:56086 R> 10.150.32.107:6001 ESTABLISHED 05:16:59 0 10.150.18.225:56086 R> 10.150.32.107:6001 ESTABLISHED ^C Ending tracing... This shows TCP retransmits by dynamically tracing the kernel function that does the retransmit. This is a low overhead approach. The PID may or may not make sense: it's showing the PID that was on-CPU, however, retransmits are often timer-based, where it's the kernel that is on-CPU. The STATE column shows the TCP state for the socket performing the retransmit. The "--" column is the packet type. "R>" for retransmit. Kernel stack traces can be included with -s, which may show the type of retransmit: # ./tcpretrans -s TIME PID LADDR:LPORT -- RADDR:RPORT STATE 06:21:10 19516 10.144.107.151:22 R> 10.13.106.251:32167 ESTABLISHED => tcp_fastretrans_alert => tcp_ack => tcp_rcv_established => tcp_v4_do_rcv => tcp_v4_rcv => ip_local_deliver_finish => ip_local_deliver => ip_rcv_finish => ip_rcv => __netif_receive_skb => netif_receive_skb => handle_incoming_queue => xennet_poll => net_rx_action => __do_softirq => call_softirq => do_softirq => irq_exit => xen_evtchn_do_upcall => xen_do_hypervisor_callback This looks like a fast retransmit (inclusion of tcp_fastretrans_alert(), and being based on receiving an ACK, rather than a timer). The -l option will include TCP tail loss probe events (TLP; see http://lwn.net/Articles/542642/). Eg: # ./tcpretrans -l TIME PID LADDR:LPORT -- RADDR:RPORT STATE 21:56:06 0 10.100.155.200:22 R> 10.10.237.72:18554 LAST_ACK 21:56:08 0 10.100.155.200:22 R> 10.10.237.72:18554 LAST_ACK 21:56:10 16452 10.100.155.200:22 R> 10.10.237.72:18554 LAST_ACK 21:56:10 0 10.100.155.200:22 L> 10.10.237.72:46408 LAST_ACK 21:56:10 0 10.100.155.200:22 R> 10.10.237.72:46408 LAST_ACK 21:56:12 0 10.100.155.200:22 R> 10.10.237.72:46408 LAST_ACK 21:56:13 0 10.100.155.200:22 R> 10.10.237.72:46408 LAST_ACK ^C Ending tracing... Look for "L>" in the type column ("--") for TLP events. Use -h to print the USAGE message: # ./tcpretrans -h USAGE: tcpretrans [-hs] -h # help message -s # print stack traces eg, tcpretrans # trace TCP retransmits perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/tpoint_example.txt000066400000000000000000000174151361450357500257170ustar00rootroot00000000000000Demonstrations of tpoint, the Linux ftrace version. Let's trace block:block_rq_issue, to see block device (disk) I/O requests: # ./tpoint block:block_rq_issue Tracing block:block_rq_issue. Ctrl-C to end. supervise-1692 [001] d... 7269912.982162: block_rq_issue: 202,1 W 0 () 17039656 + 8 [supervise] supervise-1696 [000] d... 7269912.982243: block_rq_issue: 202,1 W 0 () 12862264 + 8 [supervise] cksum-12994 [000] d... 7269913.317924: block_rq_issue: 202,1 R 0 () 9357056 + 72 [cksum] cksum-12994 [000] d... 7269913.319013: block_rq_issue: 202,1 R 0 () 2977536 + 144 [cksum] cksum-12994 [000] d... 7269913.320217: block_rq_issue: 202,1 R 0 () 2986240 + 216 [cksum] cksum-12994 [000] d... 7269913.321677: block_rq_issue: 202,1 R 0 () 620344 + 56 [cksum] cksum-12994 [001] d... 7269913.329309: block_rq_issue: 202,1 R 0 () 9107912 + 88 [cksum] cksum-12994 [001] d... 7269913.340133: block_rq_issue: 202,1 R 0 () 3147008 + 248 [cksum] cksum-12994 [001] d... 7269913.354551: block_rq_issue: 202,1 R 0 () 11583488 + 256 [cksum] cksum-12994 [001] d... 7269913.379904: block_rq_issue: 202,1 R 0 () 11583744 + 256 [cksum] [...] ^C Ending tracing... Great, that was easy! perf_events can do this as well, and is better in many ways, including a more efficient buffering strategy, and multi-user access. It's not that easy to do this one-liner in perf_events, however. An equivalent for recent kernels is: perf record --no-buffer -e block:block_rq_issue -a -o - | PAGER=cat stdbuf -oL perf script -i - Older kernels, use -D instead of --no-buffer. Even better is to set the buffer page size to a sufficient grouping (using -m), to minimize overheads, at the expense of liveliness of updates. Note that stack traces (-g) don't work on my systems with this perf one-liner, however, they do work with tpoint -s. Column headings can be printed using -H: # ./tpoint -H block:block_rq_issue Tracing block:block_rq_issue. Ctrl-C to end. # tracer: nop # # entries-in-buffer/entries-written: 0/0 #P:2 # # _-----=> irqs-off # / _----=> need-resched # | / _---=> hardirq/softirq # || / _--=> preempt-depth # ||| / delay # TASK-PID CPU# |||| TIMESTAMP FUNCTION # | | | |||| | | supervise-1697 [000] d... 7270545.340856: block_rq_issue: 202,1 W 0 () 12862464 + 8 [supervise] supervise-1697 [000] d... 7270545.341256: block_rq_issue: 202,1 W 0 () 12862472 + 8 [supervise] supervise-1690 [000] d... 7270545.342363: block_rq_issue: 202,1 W 0 () 17040368 + 8 [supervise] [...] They are also documented in the Linux kernel source under: Documentation/trace/ftrace.txt. How about stacks traces for those block_rq_issue events? Adding -s: # ./tpoint -s block:block_rq_issue Tracing block:block_rq_issue. Ctrl-C to end. supervise-1691 [000] d... 7269511.079179: block_rq_issue: 202,1 W 0 () 17040232 + 8 [supervise] supervise-1691 [000] d... 7269511.079188: => blk_peek_request => do_blkif_request => __blk_run_queue => queue_unplugged => blk_flush_plug_list => blk_finish_plug => ext4_writepages => do_writepages => __filemap_fdatawrite_range => filemap_flush => ext4_alloc_da_blocks => ext4_rename => vfs_rename => SYSC_renameat2 => SyS_renameat2 => SyS_rename => system_call_fastpath cksum-7428 [000] d... 7269511.331778: block_rq_issue: 202,1 R 0 () 9006848 + 208 [cksum] cksum-7428 [000] d... 7269511.331784: => blk_peek_request => do_blkif_request => __blk_run_queue => queue_unplugged => blk_flush_plug_list => blk_finish_plug => __do_page_cache_readahead => ondemand_readahead => page_cache_async_readahead => generic_file_read_iter => new_sync_read => vfs_read => SyS_read => system_call_fastpath cksum-7428 [000] d... 7269511.332631: block_rq_issue: 202,1 R 0 () 620992 + 200 [cksum] cksum-7428 [000] d... 7269511.332639: => blk_peek_request => do_blkif_request => __blk_run_queue => queue_unplugged => blk_flush_plug_list => blk_finish_plug => __do_page_cache_readahead => ondemand_readahead => page_cache_sync_readahead => generic_file_read_iter => new_sync_read => vfs_read => SyS_read => system_call_fastpath ^C Ending tracing... Easy. Now I can read the ancestry to understand what actually lead to issuing a block device (disk) I/O. Here's insertion onto the block I/O queue (better matches processes): # ./tpoint -s block:block_rq_insert Tracing block:block_rq_insert. Ctrl-C to end. cksum-11908 [000] d... 7269834.882517: block_rq_insert: 202,1 R 0 () 736304 + 256 [cksum] cksum-11908 [000] d... 7269834.882528: => __elv_add_request => blk_flush_plug_list => blk_finish_plug => __do_page_cache_readahead => ondemand_readahead => page_cache_sync_readahead => generic_file_read_iter => new_sync_read => vfs_read => SyS_read => system_call_fastpath [...] You can also add tracepoint filters. To see what variables you can use, use -v: # ./tpoint -v block:block_rq_issue name: block_rq_issue ID: 942 format: field:unsigned short common_type; offset:0; size:2; signed:0; field:unsigned char common_flags; offset:2; size:1; signed:0; field:unsigned char common_preempt_count; offset:3; size:1; signed:0; field:int common_pid; offset:4; size:4; signed:1; field:dev_t dev; offset:8; size:4; signed:0; field:sector_t sector; offset:16; size:8; signed:0; field:unsigned int nr_sector; offset:24; size:4; signed:0; field:unsigned int bytes; offset:28; size:4; signed:0; field:char rwbs[8]; offset:32; size:8; signed:1; field:char comm[16]; offset:40; size:16; signed:1; field:__data_loc char[] cmd; offset:56; size:4; signed:1; print fmt: "%d,%d %s %u (%s) %llu + %u [%s]", ((unsigned int) ((REC->dev) >> 20)), ((unsigned int) ((REC->dev) & ((1U << 20) - 1))), REC->rwbs, REC->bytes, __get_str(cmd), (unsigned long long)REC->sector, REC->nr_sector, REC->comm Now I'll add a filter to check that the rwbs field (I/O type) includes an "R", making it a read: # ./tpoint -s block:block_rq_insert 'rwbs ~ "*R*"' cksum-11908 [000] d... 7269839.919098: block_rq_insert: 202,1 R 0 () 736560 + 136 [cksum] cksum-11908 [000] d... 7269839.919107: => __elv_add_request => blk_flush_plug_list => blk_finish_plug => __do_page_cache_readahead => ondemand_readahead => page_cache_async_readahead => generic_file_read_iter => new_sync_read => vfs_read => SyS_read => system_call_fastpath [...] Use -h to print the USAGE message: # ./tpoint -h USAGE: tpoint [-hHsv] [-d secs] [-p PID] [-L TID] tracepoint [filter] tpoint -l -d seconds # trace duration, and use buffers -p PID # PID to match on events -L TID # thread id to match on events -v # view format file (don't trace) -H # include column headers -l # list all tracepoints -s # show kernel stack traces -h # this usage message Note that these examples may need modification to match your kernel version's function names and platform's register usage. eg, tpoint -l | grep open # find tracepoints containing "open" tpoint syscalls:sys_enter_open # trace open() syscall entry tpoint block:block_rq_issue # trace block I/O issue tpoint -s block:black_rq_issue # show kernel stacks See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/examples/uprobe_example.txt000066400000000000000000000347661361450357500257060ustar00rootroot00000000000000Demonstrations of uprobe, the Linux ftrace version. Trace the readline() function from all processes named "bash": # ./uprobe p:bash:readline Tracing uprobe readline (p:readline /bin/bash:0x8db60). Ctrl-C to end. bash-11886 [003] d... 19601233.618462: readline: (0x48db60) bash-11886 [003] d... 19601235.152067: readline: (0x48db60) bash-11915 [003] d... 19601238.976244: readline: (0x48db60) ^C Ending tracing... readline() is the bash shell's function for reading interactive input, and a line is printed each time I entered commands in separate bash shells. The line contains default ftrace columns: the process name, "-", and PID; the CPU, flags, a timestamp (in units of seconds), the probe name, then other arguments. These columns are documented in the kernel source, under Documentation/trace/ftrace.txt. The first line of output is informational, and shows what uprobe is really doing: it turned "bash" into "/bin/bash", using a $PATH lookup (via which(1)). It then turned the "readline" symbol into 0x8db60, using objdump(1) for symbol lookups. Note that this traces _all_ bash processes simultaneously. Tracing PID 11886 only: # ./uprobe -p 11886 p:bash:readline Tracing uprobe readline (p:readline /bin/bash:0x8db60). Ctrl-C to end. bash-11886 [002] d... 19601657.753893: readline: (0x48db60) bash-11886 [002] d... 19601658.246613: readline: (0x48db60) bash-11886 [002] d... 19601658.386666: readline: (0x48db60) bash-11886 [002] d... 19601661.415952: readline: (0x48db60) ^C Ending tracing... This may be important if you are tracing shared library functions, and only care about one target process. You can specify the full path to a binary to trace: # ./uprobe p:/bin/bash:readline Tracing uprobe readline (p:readline /bin/bash:0x8db60). Ctrl-C to end. bash-11886 [002] d... 19601746.902461: readline: (0x48db60) bash-11886 [002] d... 19601749.543485: readline: (0x48db60) bash-11886 [001] d... 19601749.702369: readline: (0x48db60) ^C Ending tracing... This might be useful if uprobe picked the wrong binary to trace, as shown by the informational line, and you wanted to specify it directly. It is also useful for tracing binaries not in the $PATH, which uprobe can't otherwise find. Use -l to list symbols available to trace; eg, searching for functions containing "readline" in bash: # ./uprobe -l bash | grep readline initialize_readline pcomp_set_readline_variables posix_readline_initialize readline readline_internal_char readline_internal_setup readline_internal_teardown Tracing the return of readline() with return value as a string: # ./uprobe 'r:bash:readline +0($retval):string' Tracing uprobe readline (r:readline /bin/bash:0x8db60 +0($retval):string). Ctrl-C to end. bash-11886 [003] d... 19601837.001935: readline: (0x41e876 <- 0x48db60) arg1="ls -l" bash-11886 [002] d... 19601851.008409: readline: (0x41e876 <- 0x48db60) arg1="echo "hello world"" bash-11886 [002] d... 19601854.099730: readline: (0x41e876 <- 0x48db60) arg1="df -h" bash-11886 [002] d... 19601858.805740: readline: (0x41e876 <- 0x48db60) arg1="cd .." bash-11886 [003] d... 19601898.378753: readline: (0x41e876 <- 0x48db60) arg1="foo bar" ^C Ending tracing... Now I can see the commands entered. Note that this traces what bash reads in, even if the command eventually fails. Eg, the last command "foo bar" didn't work (No command 'foo' found). Note that this invocation now uses "r:" at the start of the probe description, instead of "p:". r is for return probes, p for entry probes. Tracing sleep() calls in all running libc shared libraries: # ./uprobe p:libc:sleep Tracing uprobe sleep (p:sleep /lib/x86_64-linux-gnu/libc-2.15.so:0xbf130). Ctrl-C to end. svscan-2134 [000] d... 19602402.959904: sleep: (0x7f2dba562130) cron-923 [000] d... 19602404.640507: sleep: (0x7f3e26d9e130) cron-923 [002] d... 19602404.655232: sleep: (0x7f3e26d9e130) cron-923 [002] d... 19602405.189271: sleep: (0x7f3e26d9e130) svscan-2134 [000] d... 19602407.959947: sleep: (0x7f2dba562130) [...] This shows different programs calling sleep -- likely threads waiting for work. I ran a "sleep 1" command in a bash shell, which wasn't seen above: probably using a different sleep library call, which I'd need to trace separately. Including headers (-H): # ./uprobe -H p:libc:sleep Tracing uprobe sleep (p:sleep /lib/x86_64-linux-gnu/libc-2.15.so:0xbf130). Ctrl-C to end. # tracer: nop # # entries-in-buffer/entries-written: 0/0 #P:4 # # _-----=> irqs-off # / _----=> need-resched # | / _---=> hardirq/softirq # || / _--=> preempt-depth # ||| / delay # TASK-PID CPU# |||| TIMESTAMP FUNCTION # | | | |||| | | svscan-2134 [000] d... 19603052.976770: sleep: (0x7f2dba562130) svscan-2134 [002] d... 19603057.976927: sleep: (0x7f2dba562130) [...] These are documented in Documentation/trace/ftrace.txt. Tracing sleep() with its argument (seconds): # ./uprobe 'p:libc:sleep %di' Tracing uprobe sleep (p:sleep /lib/x86_64-linux-gnu/libc-2.15.so:0xbf130 %di). Ctrl-C to end. svscan-2134 [002] d... 19602517.962925: sleep: (0x7f2dba562130) arg1=0x5 svscan-2134 [002] d... 19602522.963082: sleep: (0x7f2dba562130) arg1=0x5 cron-923 [002] d... 19602524.187733: sleep: (0x7f3e26d9e130) arg1=0x3c svscan-2134 [002] d... 19602527.963267: sleep: (0x7f2dba562130) arg1=0x5 [...] So svcan was sleeping for 5 seconds, and cron for 60 seconds (0x3c = 60). The argument is specified by its register, %di. This is platform dependent: %di may only be meaningful on x86. If you're on a different architecture (eg, ARM), you will probably need to use something else. If working with registers is not for you, then consider tracing this using perf_events with debuginfo installed: in which case you can use the variable names. Or consider a different tracer. Here is an example of the optional filter expression, to only trace the return of fopen() when it failed and returned NULL (0): # ./uprobe 'r:libc:fopen file=$retval' 'file == 0' Tracing uprobe fopen (r:fopen /lib/x86_64-linux-gnu/libc-2.15.so:0x6e540 file=$retval). Ctrl-C to end. prog1-23982 [000] d... 19602894.346872: fopen: (0x40051e <- 0x7f637867f540) file=0x0 ^C Ending tracing... The argument $retval was given a vanity name "file", which was then tested in the filter expression "file == 0". Here's an example of tracing the MySQL server dispatch_command() function, along with the query string (note: the %dx register is only valid for this architecture and this software build): # ./uprobe 'p:dispatch_command /opt/mysql/bin/mysqld:_Z16dispatch_command19enum_server_commandP3THDPcj +0(%dx):string' Tracing uprobe dispatch_command (p:dispatch_command /opt/mysql/bin/mysqld:0x2dbd40 +0(%dx):string). Ctrl-C to end. mysqld-2855 [001] d... 19956674.509085: dispatch_command: (0x6dbd40) arg1="show tables" mysqld-2855 [001] d... 19956675.541155: dispatch_command: (0x6dbd40) arg1="SELECT * FROM numbers where number > 32000" ^C Ending tracing... The function name, "_Z16dispatch_command19enum_server_commandP3THDPcj", is the C++ mangled symbol. I can name the query string argument "cmd" then test it in a filter; eg, to only match queries that begin with "SELECT": # ./uprobe 'p:dispatch_command /opt/mysql/bin/mysqld:_Z16dispatch_command19enum_server_commandP3THDPcj cmd=+0(%dx):string' 'cmd ~ "SELECT*"' Tracing uprobe dispatch_command (p:dispatch_command /opt/mysql/bin/mysqld:0x2dbd40 cmd=+0(%dx):string). Ctrl-C to end. mysqld-2855 [001] d... 19956754.619958: dispatch_command: (0x6dbd40) cmd="SELECT * FROM numbers where number > 32000" mysqld-2855 [001] d... 19956755.060125: dispatch_command: (0x6dbd40) cmd="SELECT * FROM numbers where number > 32000" ^C Ending tracing... Overhead is relative to the rate of events: a higher rate of traced events, means uprobe costs higher overhead. If you are unsure of the rate of events, you can capture a set number only, or trace for a limited duration only (covered in the next example). To trace a set number only, you can pipe into head, eg: # ./uprobe -p 11982 p:bash:sh_malloc | head -15 Tracing uprobe sh_malloc (p:sh_malloc /bin/bash:0xaafa0). Ctrl-C to end. bash-11982 [001] d... 19643121.529484: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529493: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529506: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529510: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529519: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529521: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529523: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529525: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529531: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529533: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529536: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529541: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529546: sh_malloc: (0x4aafa0) bash-11982 [001] d... 19643121.529549: sh_malloc: (0x4aafa0) uprobe traps SIGPIPE, so that it properly exits and cleans up probes when used in this fashion. Note the timestamps: by examining the rate they are increasing, you can have some estimation for the rate of events. In this case, the 15 events all happened within the same millisecond (the timestamp column is in units of seconds), which suggests these are frequent events. The -d option can be used to specify a duration for tracing, which also causes uprobe to perform in-kernel buffering, which reduces the overhead of tracing: # ./uprobe -d 5 p:libc:gettimeofday Tracing uprobe gettimeofday for 5 seconds (buffered)... sleep-12743 [001] d... 19642858.943440: gettimeofday: (0x7f400138ac10) rotatelog-12744 [000] d... 19642858.955665: gettimeofday: (0x7f0ba34ebc10) rotatelog-12745 [003] d... 19642858.956425: gettimeofday: (0x7f1e6db20c10) rotatelog-12744 [000] d... 19642858.956924: gettimeofday: (0x7f0ba34ebc10) rotatelog-12745 [003] d... 19642858.957608: gettimeofday: (0x7f1e6db20c10) rotatelog-12744 [001] d... 19642858.958005: gettimeofday: (0x7fd8a1d64c10) rotatelog-12744 [003] d... 19642858.959496: gettimeofday: (0x7f9531acdc10) mkdir-12746 [002] d... 19642858.959542: gettimeofday: (0x7fd539474c10) chown-12747 [001] d... 19642858.961455: gettimeofday: (0x7ff5646afc10) rotatelog-12745 [000] d... 19642858.963065: gettimeofday: (0x7f406aca7c10) rotatelog-12745 [001] d... 19642858.964280: gettimeofday: (0x7f6548debc10) rotatelog-12749 [000] d... 19642859.977462: gettimeofday: (0x7fecaf7e1c10) rotatelog-12750 [003] d... 19642859.977697: gettimeofday: (0x7f821eb3cc10) rotatelog-12749 [000] d... 19642859.978707: gettimeofday: (0x7fecaf7e1c10) [...] You will not see live output during the -d mode, as it is being buffered in-kernel. Tracing func_abc() in my test program, and including user-level stacks: # ./uprobe -s p:/root/func_abc:func_c Tracing uprobe func_c (p:func_c /root/func_abc:0x4f4). Ctrl-C to end. func_abc-25394 [000] d... 19603250.054040: func_c: (0x4004f4) func_abc-25394 [000] d... 19603250.054056: => <00000000004004f4> => <0000000000400527> => <0000000000400537> => <00007fca9f0e376d> func_abc-25394 [000] d... 19603251.054250: func_c: (0x4004f4) func_abc-25394 [000] d... 19603251.054266: => <00000000004004f4> => <0000000000400527> => <0000000000400537> => <00007fca9f0e376d> ^C Ending tracing... The output has the raw hex addresses. If this is too much of a nuisance, then try tracing this using perf_events which should automate the translation. It can get worse, eg: l# ./uprobe -s p:bash:readline Tracing uprobe readline (p:readline /bin/bash:0x8db60). Ctrl-C to end. bash-11886 [002] d... 19603434.397818: readline: (0x48db60) bash-11886 [002] d... 19603434.397832: => <000000000048db60> bash-11886 [002] d... 19603434.592500: readline: (0x48db60) bash-11886 [002] d... 19603434.592510: => <000000000048db60> ^C Ending tracing... Here the stack trace is missing (0x48db60 is the traced function, transposed from the base load address). This is due to compiler optimizations. It can be fixed by recompiling with -fno-omit-frame-pointer, or, using perf_events and a different method of stack walking. Use -h to print the USAGE message: # ./uprobe -h USAGE: uprobe [-FhHsv] [-d secs] [-p PID] [-L TID] {-l target | uprobe_definition [filter]} -F # force. trace despite warnings. -d seconds # trace duration, and use buffers -l target # list functions from this executable -p PID # PID to match on events -L TID # thread id to match on events -v # view format file (don't trace) -H # include column headers -s # show user stack traces -h # this usage message Note that these examples may need modification to match your kernel version's function names and platform's register usage. eg, # trace readline() calls in all running "bash" executables: uprobe p:bash:readline # trace readline() with explicit executable path: uprobe p:/bin/bash:readline # trace the return of readline() with return value as a string: uprobe 'r:bash:readline +0($retval):string' # trace sleep() calls in all running libc shared libraries: uprobe p:libc:sleep # trace sleep() with register %di (x86): uprobe 'p:libc:sleep %di' # trace this address (use caution: must be instruction aligned): uprobe p:libc:0xbf130 # trace gettimeofday() for PID 1182 only: uprobe -p 1182 p:libc:gettimeofday # trace the return of fopen() only when it returns NULL: uprobe 'r:libc:fopen file=$retval' 'file == 0' See the man page and example file for more info. perf-tools-unstable-1.0.1~20200130+git49b8cdf/execsnoop000077500000000000000000000207611361450357500222370ustar00rootroot00000000000000#!/bin/bash # # execsnoop - trace process exec() with arguments. # Written using Linux ftrace. # # This shows the execution of new processes, especially short-lived ones that # can be missed by sampling tools such as top(1). # # USAGE: ./execsnoop [-hrt] [-n name] # # REQUIREMENTS: FTRACE and KPROBE CONFIG, sched:sched_process_fork tracepoint, # and either the sys_execve, stub_execve or do_execve kernel function. You may # already have these on recent kernels. And awk. # # This traces exec() from the fork()->exec() sequence, which means it won't # catch new processes that only fork(). With the -r option, it will also catch # processes that re-exec. It makes a best-effort attempt to retrieve the program # arguments and PPID; if these are unavailable, 0 and "[?]" are printed # respectively. There is also a limit to the number of arguments printed (by # default, 8), which can be increased using -a. # # This implementation is designed to work on older kernel versions, and without # kernel debuginfo. It works by dynamic tracing an execve kernel function to # read the arguments from the %si register. The sys_execve function is tried # first, then stub_execve and do_execve. The sched:sched_process_fork # tracepoint is used to get the PPID. This program is a workaround that should be # improved in the future when other kernel capabilities are made available. If # you need a more reliable tool now, then consider other tracing alternatives # (eg, SystemTap). This tool is really a proof of concept to see what ftrace can # currently do. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the execsnoop(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 07-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock; wroteflock=0 opt_duration=0; duration=; opt_name=0; name=; opt_time=0; opt_reexec=0 opt_argc=0; argc=8; max_argc=16; ftext= trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: execsnoop [-hrt] [-a argc] [-d secs] [name] -d seconds # trace duration, and use buffers -a argc # max args to show (default 8) -r # include re-execs -t # include time (seconds) -h # this usage message name # process name to match (REs allowed) eg, execsnoop # watch exec()s live (unbuffered) execsnoop -d 1 # trace 1 sec (buffered) execsnoop grep # trace process names containing grep execsnoop 'udevd$' # process names ending in "udevd" See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > events/kprobes/$kname/enable" warn "echo 0 > events/sched/sched_process_fork/enable" warn "echo -:$kname >> kprobe_events" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts a:d:hrt opt do case $opt in a) opt_argc=1; argc=$OPTARG ;; d) opt_duration=1; duration=$OPTARG ;; r) opt_reexec=1 ;; t) opt_time=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) if (( $# )); then opt_name=1 name=$1 shift fi (( $# )) && usage ### option logic (( opt_pid && opt_name )) && die "ERROR: use either -p or -n." (( opt_pid )) && ftext=" issued by PID $pid" (( opt_name )) && ftext=" issued by process name \"$name\"" (( opt_file )) && ftext="$ftext for filenames containing \"$file\"" (( opt_argc && argc > max_argc )) && die "ERROR: max -a argc is $max_argc." if (( opt_duration )); then echo "Tracing exec()s$ftext for $duration seconds (buffered)..." else echo "Tracing exec()s$ftext. Ctrl-C to end." fi ### select awk if (( opt_duration )); then [[ -x /usr/bin/mawk ]] && awk=mawk || awk=awk else # workarounds for mawk/gawk fflush behavior if [[ -x /usr/bin/gawk ]]; then awk=gawk elif [[ -x /usr/bin/mawk ]]; then awk="mawk -W interactive" else awk=awk fi fi ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### build probe if [[ -x /usr/bin/getconf ]]; then bits=$(getconf LONG_BIT) else bits=64 [[ $(uname -m) == i* ]] && bits=32 fi (( offset = bits / 8 )) function makeprobe { func=$1 kname=execsnoop_$func kprobe="p:$kname $func" i=0 while (( i < argc + 1 )); do # p:kname do_execve +0(+0(%si)):string +0(+8(%si)):string ... kprobe="$kprobe +0(+$(( i * offset ))(%si)):string" (( i++ )) done } # try in this order: sys_execve, stub_execve, do_execve makeprobe sys_execve ### setup and begin tracing echo nop > current_tracer if ! echo $kprobe >> kprobe_events 2>/dev/null; then makeprobe stub_execve if ! echo $kprobe >> kprobe_events 2>/dev/null; then makeprobe do_execve if ! echo $kprobe >> kprobe_events 2>/dev/null; then edie "ERROR: adding a kprobe for execve. Exiting." fi fi fi if ! echo 1 > events/kprobes/$kname/enable; then edie "ERROR: enabling kprobe for execve. Exiting." fi if ! echo 1 > events/sched/sched_process_fork/enable; then edie "ERROR: enabling sched:sched_process_fork tracepoint. Exiting." fi echo "Instrumenting $func" (( opt_time )) && printf "%-16s " "TIMEs" printf "%6s %6s %s\n" "PID" "PPID" "ARGS" # # Determine output format. It may be one of the following (newest first): # TASK-PID CPU# |||| TIMESTAMP FUNCTION # TASK-PID CPU# TIMESTAMP FUNCTION # To differentiate between them, the number of header fields is counted, # and an offset set, to skip the extra column when needed. # offset=$($awk 'BEGIN { o = 0; } $1 == "#" && $2 ~ /TASK/ && NF == 6 { o = 1; } $2 ~ /TASK/ { print o; exit }' trace) ### print trace buffer warn "echo > trace" ( if (( opt_duration )); then # wait then dump buffer sleep $duration cat -v trace else # print buffer live cat -v trace_pipe fi ) | $awk -v o=$offset -v opt_name=$opt_name -v name=$name \ -v opt_duration=$opt_duration -v opt_time=$opt_time -v kname=$kname \ -v opt_reexec=$opt_reexec ' # common fields $1 != "#" { # task name can contain dashes comm = pid = $1 sub(/-[0-9][0-9]*/, "", comm) sub(/.*-/, "", pid) } $1 != "#" && $(4+o) ~ /sched_process_fork/ { cpid=$0 sub(/.* child_pid=/, "", cpid) sub(/ .*/, "", cpid) getppid[cpid] = pid delete seen[pid] } $1 != "#" && $(4+o) ~ kname { if (seen[pid]) next if (opt_name && comm !~ name) next # # examples: # ... arg1="/bin/echo" arg2="1" arg3="2" arg4="3" ... # ... arg1="sleep" arg2="2" arg3=(fault) arg4="" ... # ... arg1="" arg2=(fault) arg3="" arg4="" ... # the last example is uncommon, and may be a race. # if ($0 ~ /arg1=""/) { args = comm " [?]" } else { args=$0 sub(/ arg[0-9]*=\(fault\).*/, "", args) sub(/.*arg1="/, "", args) gsub(/" arg[0-9]*="/, " ", args) sub(/"$/, "", args) if ($0 !~ /\(fault\)/) args = args " [...]" } if (opt_time) { time = $(3+o); sub(":", "", time) printf "%-16s ", time } printf "%6s %6d %s\n", pid, getppid[pid], args if (!opt_duration) fflush() if (!opt_reexec) { seen[pid] = 1 delete getppid[pid] } } $0 ~ /LOST.*EVENT[S]/ { print "WARNING: " $0 > "/dev/stderr" } ' ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/fs/000077500000000000000000000000001361450357500207105ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/fs/cachestat000077500000000000000000000124731361450357500226040ustar00rootroot00000000000000#!/bin/bash # # cachestat - show Linux page cache hit/miss statistics. # Uses Linux ftrace. # # This is a proof of concept using Linux ftrace capabilities on older kernels, # and works by using function profiling for in-kernel counters. Specifically, # four kernel functions are traced: # # mark_page_accessed() for measuring cache accesses # mark_buffer_dirty() for measuring cache writes # add_to_page_cache_lru() for measuring page additions # account_page_dirtied() for measuring page dirties # # It is possible that these functions have been renamed (or are different # logically) for your kernel version, and this script will not work as-is. # This script was written on Linux 3.13. This script is a sandcastle: the # kernel may wash some away, and you'll need to rebuild. # # USAGE: cachestat [-Dht] [interval] # eg, # cachestat 5 # show stats every 5 seconds # # Run "cachestat -h" for full usage. # # WARNING: This uses dynamic tracing of kernel functions, and could cause # kernel panics or freezes. Test, and know what you are doing, before use. # It also traces cache activity, which can be frequent, and cost some overhead. # The statistics should be treated as best-effort: there may be some error # margin depending on unusual workload types. # # REQUIREMENTS: CONFIG_FUNCTION_PROFILER, awk. # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 28-Dec-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing interval=1; opt_timestamp=0; opt_debug=0 trap 'quit=1' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: cachestat [-Dht] [interval] -D # print debug counters -h # this usage message -t # include timestamp interval # output interval in secs (default 1) eg, cachestat # show stats every second cachestat 5 # show stats every 5 seconds See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function die { echo >&2 "$@" exit 1 } ### process options while getopts Dht opt do case $opt in D) opt_debug=1 ;; t) opt_timestamp=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) ### option logic if (( $# )); then interval=$1 fi echo "Counting cache functions... Output every $interval seconds." ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### enable tracing sysctl -q kernel.ftrace_enabled=1 # doesn't set exit status printf "mark_page_accessed\nmark_buffer_dirty\nadd_to_page_cache_lru\naccount_page_dirtied\n" > set_ftrace_filter || \ die "ERROR: tracing these four kernel functions: mark_page_accessed,"\ "mark_buffer_dirty, add_to_page_cache_lru and account_page_dirtied (unknown kernel version?). Exiting." warn "echo nop > current_tracer" if ! echo 1 > function_profile_enabled; then echo > set_ftrace_filter die "ERROR: enabling function profiling. Have CONFIG_FUNCTION_PROFILER? Exiting." fi (( opt_timestamp )) && printf "%-8s " TIME printf "%8s %8s %8s %8s %12s %10s" HITS MISSES DIRTIES RATIO "BUFFERS_MB" "CACHE_MB" (( opt_debug )) && printf " DEBUG" echo ### summarize quit=0; secs=0 while (( !quit && (!opt_duration || secs < duration) )); do (( secs += interval )) echo 0 > function_profile_enabled echo 1 > function_profile_enabled sleep $interval (( opt_timestamp )) && printf "%(%H:%M:%S)T " -1 # cat both meminfo and trace stats, and let awk pick them apart cat /proc/meminfo trace_stat/function* | awk -v debug=$opt_debug ' # match meminfo stats: $1 == "Buffers:" && $3 == "kB" { buffers_mb = $2 / 1024 } $1 == "Cached:" && $3 == "kB" { cached_mb = $2 / 1024 } # identify and save trace counts: $2 ~ /[0-9]/ && $3 != "kB" { a[$1] += $2 } END { mpa = a["mark_page_accessed"] mbd = a["mark_buffer_dirty"] apcl = a["add_to_page_cache_lru"] apd = a["account_page_dirtied"] total = mpa - mbd misses = apcl - apd if (misses < 0) misses = 0 hits = total - misses ratio = 100 * hits / total printf "%8d %8d %8d %7.1f%% %12.0f %10.0f", hits, misses, mbd, ratio, buffers_mb, cached_mb if (debug) printf " (%d %d %d %d)", mpa, mbd, apcl, apd printf "\n" }' done ### end tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null warn "echo 0 > function_profile_enabled" warn "echo > set_ftrace_filter" perf-tools-unstable-1.0.1~20200130+git49b8cdf/images/000077500000000000000000000000001361450357500215455ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/images/perf-tools_2016.png000066400000000000000000006576651361450357500250460ustar00rootroot00000000000000‰PNG  IHDRÜYóºysRGB®Îé pHYsgŸÒRÕiTXtXML:com.adobe.xmp 5 1 2 ‹O²@IDATxì˜%Åõ·k°8‹;Áa±@X,8,.ÁÝ݃[pw—àÜÝ‚.®‚-‡?žMHçW_ª§oO_é¾Ý³wfÞzž™îÛåoUK:uj@dÎá @€ @€ @(Jànj󫢱‰@€ @€ @€@î],8ƒ @€ @€ &€À½0:"B€ @€ @€º pïbÁ @€ @€ @ 0î…Ñ€ @€ @€ ÐE{ Î @€ @€ @… p/ŒŽˆ€ @€ @€ .Ü»Xp@€ @€ @(L{atD„ @€ @€ t@àÞÅ‚3@€ @€ @€@aÜ £#" @€ @€ @ ‹÷.œA€ @€ @€ @à^!@€ @€ @]¸w±à € @€ @€ P˜÷Âèˆ@€ @€ @è"€À½‹g€ @€ @€ ¸FGD@€ @€ @€@î],8ƒ @€ @€ &€À½0:"B€ @€ @€º pïbÁ @€ @€ @ 0î…Ñ€ @€ @€ ÐE{ Î @€ @€ @… p/ŒŽˆ€ @€ @€ .Ü»Xp@€ @€ @(L{atD„ @€ @€ t@àÞÅ‚3@€ @€ @€@aÜ £#" @€ @€ @ ‹÷.œA€ @€ @€ @à^!@€ @€ @]¸w±à € @€ @€ P˜÷Âèˆ@€ @€ @è"€À½‹g€ @€ @€ ¸FGD@€ @€ @€@î],8ƒ @€ @€ &€À½0:"B€ @€ @€º pïbÁ @€ @€ @ 0î…Ñ€ @€ @€ ÐE{ Î @€ @€ @… p/ŒŽˆ€ @€ @€ .Ü»Xp@€ @€ @(L{atD„ @€ @€ t@àÞÅ‚3@€ @€ @€@aÜ £#" @€ @€ @ ‹÷.œA€ @€ @€ @à^!@€ @€ @]¸w±à € @€ @€ P˜÷Âèˆ@€ @€ @è"€À½‹g€ @€ @€ ¸FGD@€ @€ @€@î],8ƒ @€ @€ &€À½0:"B€ @€ @€º pïbÁ @€ @€ @ 0î…Ñ€ @€ @€ ÐE{ Î @€ @€ @… Œ^8&!~IàÛo¿u/¿ü²›xâ‰Ýì³Ï^ƒŸ~úÉ=÷ÜsnÚi§õ¥%Ü m•Á¸ãŽë¦šj*7É$“¸äÞ1á?ÿüswÛm·¹wÞyÇý÷¿ÿu3Í4“Ûzë­;¦|exæ™gÜ7Þè^xá÷É'Ÿ¸#F¸üÑ 4ÈM1Åþ¹ºòÊ+»UW]Õ 80WÖ<Ÿsáêµ{¢åQÔ¯7뭷ܧŸ~ZYQõ=¦ï²Þâµuo©å¬%À7W-¼¿¸'ò#< ^@ ÂAÈAà‘G‰ìÑ­¹æš9b5úÆoøt9äæ ÑÐVj¯"¿þõ¯£¡C‡FwÞygdë–òì”@'žxb4Î8ãøzÿæ7¿‰&tÒh‚ &è”âQ”B`äÈ‘ÑI'M3Í4ñ=®þ>óÌ3GK,±D´ÒJ+EƒŽ&›l²È&Ï|Ý×k¯½vdÀ–ËÀó¹eT½:`O´s£<Šúõè[mµU|y7‹c“m½C\ÆFmâ¤×à›«ý¦âžhŸ!)@è ?Ø·›CÃ]p€ú0yæ™Çm³Í6-×ð»ï¾óšxÒ˜5a»»ãŽ;¼v¸´ÅË\ÕÐrr¼å–[ÜÞ{ïíV[m5·ûî»»!C†82:NæL‰àè\=ôÛi§Ü믿î5Öµzcýõ×wK-µ”m´Ñºü£>r×\s»òÊ+Ý 7Üàn¿ýv·×^{9›ätcŽ9f·ð\€@o$pÎ9çøþ¿í¶ÛvTñ7ÜpCg“_-•éòË/wO?ý´Û~ûíÝœsÎÙRœyç·¥p‚@ÙzꛫSïí²y’ ôÜûN[R@™dJeçwÎôkvñí·ßv묳Ž{饗œÌQ 6Ì™¶l³h£ÔÿüóÏwM4‘»úê«iûÆe‘о@à/ù‹ŸDûå—_ÜlàN9åo:¦Qݦžzj?¥É¨K.¹ÄŸ}ôÑžr˜È”½À駟î'X;Mà¾ôÒK;ýµâ4Ù-û*«¬âl•Y+QQF §¾¹:õÞeàÉ€:ž›¦v|Q@@£Ž€™¦p=ö˜ô>ÜkËÎd';Ù°žcŽ9j„í\^Ê<N;í4gæ)¼ïõ×_﮺ꪦÂötú›o¾¹×Œ_h¡…܃>è–Yf÷Í7ߤƒñ€ Ðß\ ñà @ý˜÷~ÜøTDÀl»ûî»Ïm¶ÙfT,Êb¤ùzóÍ7»é§ŸÞk¸K»¶“Ý—_~é7|íä2R6!`û2¸=÷ÜÓ5ÖX^+Ýl±IÆDZ} Üý÷ßï]tÑØ|EáĈ }××b±$À7WApDƒ >O{Ÿob*ÞA@¦?–]vY7ãŒ3öŽ÷³RŽ>úèÞºª-;Ð8@ g üßÿýŸÛtÓMm`ìd fÅWl»ô‚{¯½öZoß½íDI }×× (xA€ @ 2Ü+CK€ú™±øÕ¯~åµaûVͨ :ŸÀGá>øà7à 3¸wܱ´O2É$nß}÷õéí¶ÛnîÇ,-m‚ @€ Ð pï­N! Ó2SL1…û׿þ…½çüˆ¢¾ÿþ{wá…úèGu”ß²hZYñöØc7ÕTS9™¸ì²Ë²‚p € @€Z$0z‹á@ RôœsÎ9nñÅwK.¹d·¼dkø©§žr»îº«“ùƒàÞzë-wæ™gºgžyƽóÎ;îÛo¿õfif™e7Ï<ó¸]vÙÅÉVq=W/ÝzáÓןþywçwºM6ÙÄM7ÝtÞûÉ'Ÿt<ð€›h¢‰ i¢¾ôÒKî¶ÛnsÓN;­7!‘ÎsTþžl²ÉÜ?ÿùO'óL0A·¢üýï÷f)î½÷^îóÏ?wã?¾›rÊ)ÝÒK/í6Ø`·ð w‹—¼Ð¨M´qëã?î>úè#7räHwðÁ»#<2ÝýòË/îÍ7ßìv}µÕVó}¢&ðÿ~¼ûî»ÞTÎwÜᵈ?ùäo»^å^pÁÝzë­ç–_~y'Ó:Í\ÞòË.÷£>êvØa7ñÄûä5©qþùç;•GLÅQæ–~ûÛߺ5ÖXÃ÷7­6H;ñ9å”SÜO<áÞÿ}÷Ýwß¹YgÕÍ>ûìž½äq?üðƒ;÷ÜsýýõÞ{ï9ý©í%œ•MeÙõ×ʇ%–X¢n²õx´{ïÖËPÏ™G mù駟ú¾:ÓL3y†*«6 sÌ1ë%Q÷zý»nâ <´o‚¸/°Ànýõ×o²˜×Øcí?üp·õÖ[;mʺÝvÛ¹4ML÷Úí·ß⠧öTŸ“†ü AƒÎsÏ=çîºë.oFHÏ£´+ã>M§™ü]f;7{×'óMž×‹—~þñÅ~Cáôu½»>ûì37ùä“û~žL;Ïù믿în¸á·È"‹x3xyâöDØ2ßeYå­:ýtže?”Þ 'œà³Ñs®Ñ÷aº,Í~×ë£ÿùÏüD¦¾]^yåÿN×3A óÎ;¯F®¼òÊ…&RËxž©^­>ÓôÝ•~7ùæjÆRþé{¸Þ½­w»¾-ë¹*ûl•i׫OÙ÷D½|¸@%ˆp€r0á`džhÍ5×Ì«yÐ7Þxç{È!‡dÞk¯½¼ÿ‡~èýMø­»îº‘ #Û@02!n´óÎ;GÇ{ldf"ªùð&ìN<ñÄÌ4u1nÝ€uŸ_|±&›¬çó­·Þêïs•KÏYõÛÐÕ÷õ9õ™à§°­¸ë¯¿>Ò3FñlR'²M´ýsåøãL ß¿wBŸ4Ás¤g\«®Ì6Ìs¯¾úê¾>&lkµ¨ÝÂÙÄ…O#}•yŸ*Óžhç¬ÏTù<Ï´ô½%–y¾¹Z…Χѽ]/Í2ûl:²ÓÎê?é<«¸'Òyð€J!ðƒ½í ‰ƒ ƒ@B\eßìC39ÐÓ´‚ü€úÒK/­+¼}õÕW½ðZº“O>9³–Ét34¹˜%pW”×^{Í—O“/¼ðB“Tº¼ƒ`åôÓOïºXð¬ì¶’ V,50L:M0¡’dõ„Ò¦¥™f±OCáz‚ßd›hPyàú8šˆPù¡‡òÂfÓ&K#>×d…„+Íœi…Fm´‘O{•UV‰ÂdN:ž„²_|±ŸØ1´è±ÇK©ù·üI»­ ðùˆiRÖ¤«¦=Ol˜vydÚÛ>Œ’j›7Þ8’@!í~úé§èÐCõa4èoæ4Ù ôæŸþÈ4këבš°€ULÓ.É£Ì{7™­lñ<*órË-™&~Ò»æ\÷…mÐìë'ÁV3Wvÿn–_Ú_m®>m&ºMt¥Ã¶ûÛ´°=—ôó'ý|Ö—šèÔsV÷i–³•^p.A‰ú_½pŠ{ÑEy¡­äˆ$¤2­É¬$#õå³Ï>;2Me?ác«Y2Ã%/–݆É>Ýìe+ i}'ëÜsÏí‚bÑŠ3@^€$-n \Ò.Ù&A›PšÊ­j#·2øS¾š8ïÝwß½®p/Y6­8v­4Ïͤ@Ò«æê­fÎ)+H·kfF̯¶‘öhÖs$D¨¢ CŸVÝš=£$PÓäØo~ó›è›o¾ Åjù¨•&b'dÒ•}Ÿ*íªÛ9G²>íø%Ói$”“°UWš¬iõ}’L[ÏMµ…VnUéòÜ«|—©ŽU¥Ÿìki–U>zJà®ûSïeµe+ï$}ÏjU¾_nºé¦4’øwÏ3%žç™æ'­|s¥ãùÝèÞN¦WUŸUU¦=ªî‰$;Î!@ 4ÜKCIBèGÊât>4& Ìö¦JJë¯U÷ðÃûA²Ls¤]H· »ò’PJt H9³¹íNf£»%á|£´‚_™mev۽ƾê’4k4,  Cy’G³Oî¹ØÉËþ<´Éu×]çÃhÙn×ÊàOºªËI'”'i¿ä[SO=µ×´ÍŠœ·üAஹÙnIøo›hzMK™ß V+ Zq2©ìRÖs2Õ!-N³MZ/Hæu³­íËŸö <ʾwC>fçÕ·¥LÝäq„ÊÄŽúA=ÓUôï÷ì³Ïú²™ õ¸Hfߙ֥3Ás|­ÕÛ`Ë™F²3m3gšÏ™Ñl°ê’ùe*pQišig‚L§¾‘×™Ig¶:Òúò׋Ÿ·üf£Ù™V\½äº]·Õþš Žœ™-êæ_ï‚â™pÚ™{· fvÉû-ºè¢Ýüš]°ý œ  ò3ƒVqïšigæÜa‡æÔ§ò:õmÓØvfg»[Ôªûw· ë\P?’³ së„(ï² Ùv_ýµöøé–°­¬p6ð÷aºy6¹`«0œi¹;³kìL˽&´ž“réë52~˜pÕ©_ÙÄI†¯sU·a«÷¸íýàTÛŒÖ?K3 ›qñ²Ë.óWÍþ{o•÷©2ªªk*1Š~˜0ÔÙæØÎL~8›¨l¹j › u6aÔrœªVý.«:ýz|ªz„ülòËé¯*gçÎöSqM4Qî,Ïl¹;[ýçl´&~ÕÏ3eÖê3­¦`ô£Ê>[eÚÍV}O4Ë@(F{1nÄ‚FÓ\v¦e™;wÛpÓÇ1;Ò¹ã¶aši¦qf÷Ø "M Ø ©Cš¶Ù¥»ãŽ;Ü[láÿÂõ2ò›VsK;í´“[a…¼rÒI'u¶üÞ™µ|?ýôÓ^¸¥²Ið`+:3âÌÖw¡âJ%ážÙ¨ÎŒ¯¶.[È(!¢m¸è'L‹;3ßf5P·eÝ~`zÍ5×Ô ž·üy'[4‰#ïu ’òñÞzë­”óía&LœÙðîæ×ìB × WŽ+á­mÖêt_uª¯mV\½'úwM† ~Hø)gfE„*ÏKÏW z4y’åÌLVÖå¦×4¹µÏ>ûø 3óU>ôa3%Qs½ÙM²Øª /XO‡í‰6Ìso·Ýv¾ˆf6']ÔÌßj³îL‹Þ-¹ä’5aôܬê> UÑÎ!íQ}TÝô.8ï¼óZ.Šž5z'®ºêª-Ç©2`ÕﲪÓoĦŠçA£üªð³}g %;æ˜c:}‡½óÎ;Î6ŽÓè‰ç™2ËóL‹ ×!'UöÙ*Ón__¸'Z©'a ô5ÕMï÷5RÔèy4y“6"þç?þ˜¼ÜcçfgÛÙ2Qw˜iâJðbªºÇ{Ì n¥õ)íöªœ4™ÍEËÉ‹•„<‹-¶˜Lkð—ÖÔú裼fñB -ÔrºY%,5³Y^n¹å–˼ÞÎE³Eï'ýôÓ–þ$Ô“Àí¹çžsýë_Êœ¶«Œ>ȵ+p×dƒò“ùš´³ÍÃÒ—Úþ­¬\^!u:ãAƒ9³îBziýÎ[þ9çœ3+™¦×ê ›F,!€íQàn¼ñF?HÏà'³(ûÞ ìguÖd6¥œ÷Dÿnµ aEB³­¦×(œÙ5öRõ„ꆷãl3@'³5i»„Ïz.Ú^^»3<'ƒv‘<{¢ óÜãšo»í¶Þ\K£•1¡®Ò¨VM(µëòܧʫªvn·eÅ×d¥mhéÌ&³7ùÖ,] æå¶ÜrKì„áùWÕ»¬êô1¬âyÐ(¿²ý´ª±§ç¤œ´Üƒë‰ç™òÊóL eë”c•}¶Ê´[á×Ûï‰VêH@}‘î}±U©ú0¢B»N@"A“LÌ?ÿüî€ðE’P»ê:i‰²l‚–éÂàoØ°a^óªhÚÇ÷QeK7CZ¾•í‚ÍÞ2˜+^V9ó–¿™ÆkVº&ÖU9-£VI“_NiÜ~öÙgÎ6ôu—‰&-u—IµŸmÔ[·(e0O&ÀU Ü«ìßɺ4:÷®öy¨Ú…<¤áœå´wA;NÏ"i'I!=™MÑj—ýöÛÏïqÏ=÷8iÛ¦ÓnÈ!Nû èOæTZqøŒ’é0MbʬÌÖ[o]·ÚÛâ–[nqK-µTK°2ïSªÊv®[éöØf›mœm¶ëûšöå¨ç´*Nïiõâ“¢õÒnçzx÷”ñ\Íz—U~³º—ýN@ƒÞì¤9*»•°ÊzotA`&¸isyë£%úÚ|5í$œ+Û…AkZáJC«4€ fZ’å­¢üÉô«<×æ•_|±ßà2aÕ_§vZ? × \«$¨ÓòÔS›[kU#×ÎJ®*ûl•i7â‘öë­÷Dºü† Ð_ pï/-M=!JH»7;÷ÜsÝÍ7ßì…•2Û²Þzë9 ”²¶yÒíé°Á~øk¯½V¹†~™u ö°eÆfª©¦j+i™ß‘º·µ]³JËÜÅÆoìÍióT ¥$ŒšrÊ)›EíQ™õ‘ûüóÏ](ÉÂwRÿ–PVP +¤m›e[=YövÎ}ôQ]í,&_²üZ½&[¸Í4¨%T×ß{ìá4Ï>û¬{â‰'œ&t<çœsüß2Ë,ã7ožcŽ9ºeßIm˜,œ& ¤1}ÁÔÝ[Cæd$XY{íµ“QkΫ¼O{ªk*4 ~h Üõ^ÖfÚYNæd´a±LÀu’«ú]VuúyX–ñ<È“_»aëm8'Ý~ø¡fÕ_§>ÏòÔI¦ «tUöÙ*Ó.¤·ÝEêH@}6ÜûB+R@`”È#˜xñŽIö9ï½÷^·ï¾ûº'Ÿ|Òí¿ÿþ£¬üE3³ uU4žŽìݾõÖ[mg­%Æ!½¶ë´™¯„í2Ÿ ¾--wÙÓî4a»p;Ó2yS¶ë¤þ-STÚÀXšjŸªÜ·ß~ënºé&Ÿ|={XUP´ š0cÚ|T£ô´ÿÆïÿ{·×^{ùýdÖHÂfÝ{Ú¨W›üe•«“Ú0Y¿?üá~’R‚Þ,Áœž©Ú¤S]õ&Wª¾O³x&ëÐì¼H;7K³ ­0[`¼Ð=k¿­D{ðÁݺë®ë'@ª(CÑ4û§ªwYÕé­wÑçAÑüŠÄ“ɵvÜ/¿üâß¿Á–»ÒêÔçY;õ,;n•}¶Ê´ÛåÐî‰vëH|@½•÷ÞÚr”(…@0!¸E\«ƒ]-I—Eñ×^{­“¶ŒìÇjÀÒI'¹Ûn»­Hö£,Nv†e¶£¬ 93ö¾ƒ=ÎœÑãà#GŽôB¾0‹=zñ‰ú¦4>¥Í.ûÙyÍJ4³ÍZ6š Œ¨BàÞiý;˜9ôÐC½–{Ù,•ÞñÇï7/–@¸ž™ Ûq}ô‘žGàžÎOÏl­ úûßÿîµÛ%ÜZc5ÒÁâ ™N{F©üÚj“e¹•W^9Ž+³*t7_ÌqÒzúé§kbuZ& ' ÿµÖZËÛ¤—¦~p²¡¯7Ûl³p©Û±§îÓ²Û¹[E:äÂXcå5Ø5i3lØ°¸T2ë£É¼-·Ü2¾ÖI'U¿ËªN¿˪žõò«âº&®e6°¨ÓDÜ\sÍ'ÑÉϳ¸£ø¤Ê>[eÚÍ°õ…{¢Yñ‡ ÐW ôŒ„£¯Ò£^€@¯'´†‚æež p ™6x“iHq·Ývó&þò—¿$½âsÙ‡Ýf›mÜSO=åöÛo¿øz'ŸH@. 4±ŠÚ•– TKù5ÑГîˆ#Žp?ÿü³;öØc e«:Ëìƒ6l\j©¥ ¥Ñ‰‘´™¥ÜSL‘»xšTÓžvx ¶k¥D§ ³7Þxí¶Új5Ñ;±ï¸ãŽ^ÓV}‡rHMyÛù¡g”žMZq£ "›M~)ŒÊ×IKOÏ8 ‘’š›ƒvZiôðÃçMÒ‡›Ù½ûî»5ñ;± “Ôª'¹¤–»m*÷¦›nš ZsÞS÷iÙí\S‰ŠäÝÌ\«¬Ä=©å®úëžhÔW£iòU¿ËªN?«‚U=²òªòZ²/åÉGæœôM¥}+]tÑ8j§?Ïâ‚V|ÒìÞ®²ÏV™v#l}åžhTGü ôUÜûjËR/@ %Z¶¯AuØ,°¥HèÓO?õ& \µ ›ì¶k,iÑJ#¼ž“™i—ž|òÉîÖ[o­¬£®ïºë®~)¾ÌA¨Žyœ´Û¥©+³ Yö—ó¤•7ìJ+­ä5£%$«86wU/]MŠsa’žmrÒ¦O: Ûç›o>¯íÝÊŠ¡d\ßwß}þÒTSM•öòí«ULøŒÒÆ´³Í6›7!ó¯ýËOÞ^wÝunÙe—­Ym‘®TOܧU´sºUý–ÆzžÍÌU­4ÓÊí¯¢Õnz?ɾþСCÝä“O^UQÛN·êwYÕég¨òy üt¯é¤¿Ï>û,«m_›wÞyýê¿"ß'žx¢ÿ¾8ì°Ãº•£ÓÞIÝ Xñ…Vîí*ûl•i7BWõ=Ñ(oü @ =ÜÛãGl@ —íf œž|òIwÿý÷·TiòJÛT›K6ÒÎÞ~ûíÝ›o¾é³Úµ‘“y å5 }ß`»QœQí'ÁßÞ{ïíÍêh³Í<¦e¶Þzk÷Úk¯9™fÉ»9gõ–v»ÞØÊ„C+N6Y%””êÚk¯ÝT8ÙJšfî¹çöÅÉ3á#SHJÀ°ÜrËùøyúAõ—–»L¬è^Ì£y}ä‘GúÍaeÎdþùçïV”Nìß Þ~ûí~ßi¹ï±Ç…WH£\†Ÿ|ò‰ßÄSš¹ÙgŸÝI3[¦ .ºè¢fÁc•UÃ2W”5¹!á—îG™YÉ3q¢8·Ür‹ßs@›½¦]'¶a²ŒÚ­ªÕ«,? Èeƒ^“âyœÞa2Ý çû7ÞèÛ¢7KMשêwYÕé§ë£ßU=”¶žÚ°^U Üe>PÚé:æÉCJšLU\}›¤]§?ÏÒå-ûw«÷v•}¶Ê´ñªòžh”/~€ Ð& à ´Là‘G‰ì±­¹æš-Çi% ™uðéš`&3¸™/ñþ¦¹–éßì¢idúø>ø`· fR!2·ÿ3ºÝü“lÃÀÈ–wF&$ŽÌfuT/]3àó3­¹È4i“I4<7Maoá…ŽFŽÙ0l3ϪÚ*™¯iF&@óe^zé¥#³åôîvnÂ¥Èv>¼ Ý»ùëB»mmÚ@‘iÍg¦¼hÃÈ&8"›t‰üñ¤W·sÄD¶ZÁ—Û‘ x»… ò–_}^÷”î<Į̂øxjç<δh}<“NýTuSY®¸âŠ¤Wæ¹iïE¦m™fqdæ<"3äã>ûì³5áóò¨‰l?êÝcÉpguVd+U"ÓŽLK:éÕíÜ„ò‘ ª#ÓÌþwd«3º… ªèß!ívŽzö¨ßª­l3·Èì·œœm.™]êÈ4û}ü}÷Ý·iÜäóYÏ%œû¸&|h×45}Ø馛.RŸ©çLàïéª?5s6Q™Ù_Ý õ\mØnŸeÕóRÏ ›øð÷ž™Ç‰ô¬i䪺O•gO´s2t=‹ú%Ó1¥ïG¦¥Ÿ¼Üô\\m³Zÿ Ñ»ÌLkE¶§JÓxU036¾6¹ÖRòU½ËBæU¤ß¨­•oUÏ›Œñlõì´Õ\¡Š¥“u²=%"[ÁÍ4ÓL‘¾9½ƒÂ3EáM¡nð*žgÊ,ä_ä»Õo®º•jÑ#Ͻ]EŸ Ŭ*ídÿ y%UÝÉ<8‡ Òü`ßöµƒ ƒ@âJÈ&d»¦Uîsoö¡ÙÎ`@4Ú™ÍL/°3 ¢È´˜#ÓLLÊ—møðá‘„“ûì³O4pàÀhÊ)§Œ^zé%ï—•®øc=vd›\5@ûDRÿ4™¡Ç³m°šòÉ÷3´UÙ“#Y¥0ó0‘mì™ndZï‘mJ…›ixy¶Ù¼&šh"/è4-ÎÈV d%ÕÖÀO æüI8,A ƶ"!²ò" dåLS;RÛÛæ^°,¥iö6Ð*^Þ¾Ú)w•]m¥þ­þgæ"3×Ùæ²ñ¤‘„$H¸®¶4{Ü‘ÙœUÔÈ´t}<3~øá‘iëùëyyøH‰Y÷XÂ;>}à|™$´Ô¤Î…^èïSµ£„,j[3=ã'Ô–o¼qd›ÛÅñ”Ù¿å“ÇOgÝGAp>묳F¦çÛgĈq?5­iÿ<»úê«#Ó¸ô÷‡ÚWÂÅ;ï¼³¥,ÓÏgMœm¸á†¾½% 7ó‘Ê&%Ô¿í¶Û"[=äèŸ4›‘ÐÉö²ðÏÝê7=ôï*¤ÒVÿSŸÜyç£É&›Ì?³/»ì²–êPf¶Û§“Þd“M<#µ£žA­¸*îSåÛíœÎ#Yߢ~É4ÔOBßT×ûHC¶r',óÜV\ù¶Ðýaû©d†é‰‹yî*Sï²d]ËN¿Q[+ߪž=%pWôα ’#3kí¿ÿþÑ /¼™ 6yùúéÝj+"3mèûžÏ£êÔÎ3-Ï7—¯|Áyïí²ûl²ØU¤=ªî‰d½8‡ Ò p/ % A B\ HËø;ï¼ó<½fší ”A+B;•Aé¡^€Œ3Î8ño Í|EdKÕãO§«Á”´l¥mÛLk:N$u"a–„õ*‡™Hù¶þ3´UOÜU*Mž˜iŽ˜—ʯ‰‡ÀSG ç^|ñņ•h·­óþ¤­.G²­Çw\?Ê®z™éŠ†åžyËßIwÕAÂR 4ùê/¨þÂoiUk5†´í‚“€DÚÌòS»o°ÁÞ+/^8¦ï±p=ë(MB -’eÕyJ«ün 6,+zÃkeõðT]ÄZ“¡}tÔ3Hý8yMçfóÞO<„ ÅV²¬÷|–À^ÂôÀwŒ1ƨ¹ç§žzêÈL7Ô\ËÊ[Z§«®ºjM¹uoª>¡.šT‘p^“?y\YmØnŸN–YB¹P/ÛT6éÕð¼ìûT™õD;×Ë£QþÍüäŸtêÛ't’_‰¡÷V³˜°dÌs ;µÚMíÑl‚(3’.¸+ë²ßeéê”™~£~Ì·ìçAO ÜU÷Þ{/2sE‘žYá>×s9ù<Ó÷žÙn',“õot^ÖóLy´óLËûÍÕ¨NÍüòÞÛeöÙtÙÊN{TÝézñ€J!àî””}à @àdÓX›÷½ýöÛ~SMmÆgË|½ÍnÙZÇ5&ðÎ;ï8„yÛвÇ<à 38º™gžÙÙ¤EãÈ£ÐWö{e×Zî©Ø ØoºÀ øò¢’¬eýÕW_õû hOTû¶Ô½`BV§M<;Õ™PÅ™y(g„Þ–³iC;m6©‰ÛíƒÚ¿Má÷¡° -ßMËÝoþ8hÐ gæ1Ü´ÓNëÌ„Ž?–ÝnÚ8W›íÚÊo?[÷»þÄÛV¾ÊδÙý3XÏaZ9={eÃ×V`xÇêE]§¶a‘úôä}ZE;©sUqôÜ·I"§ÍÔmºªl*O·êwYÕégªòy•_‘kÚ³G!Û$º³U^5Iˆ™ö ²aî£>òÆëÙ¬÷’ö±IËšðy~ô¥çYžzç [eŸ­2íFuì ÷D£òã@ øÑÞíã pïã­Lõ @€ ÆN>ùdgš¾~ãTÓ2o_¤4¸§‚ò€ ¾MÀ Ü;W=­oçv€ @€@‡0{Ún 't¶x‡”ˆb@€ ôVÜ{kËQn@€ @ mO<ñ„7‹d×zóEm'H€ @ýš÷~ÝüT€ @ý›€lnk_€]vÙ¥ƒ ö€ @¥@à^ F @€zÏ>ûÌm´ÑFîÞ{ïu»îº«ß`¸7•Ÿ²B€ t&Ñ;³X” € @€@¹.½ôR÷ú믻?þØÝ~ûíî믿v /¼°;úè£ËÍˆÔ @€ú-îý¶é©8 @€ú#<Ò >Ü;î¸nÆgtGu”Ûd“MÜcŒÑ¿@P[@€ Ê ˆÌU–: C€ @è#GŽôöÚ;¤8£Ðú‡~ð}Kûà @è·~0`À8ÜûmûSq@€ @€ @(‰€¸³ijI4I€ @€ @€ú7îý»ý©= @€ @€ ”D{I I€ @€ @€ú7îý»ý©= @€ @€ ”D{I I€ @€ @€ú7îý»ý©= @€ @€ ”D{I I€ @€ @€ú7îý»ý©= @€ @€ ”D{I I€ @€ @€ú7Ñ¿ÿþ{÷òË/÷o Ô€ @€ @€ PÀÿû_)·/:ú#<â:è EQÁ¤ˆ@€ @€ @è¿Làþk«ýÙLÐŽ¤½ÿöj@€ @€ @íøqÀ€ã`ý}¤@€ @€ @pÜé€ @€ @€  p/"I@€ @€ @€¸Ó @€ @€ @%@à^D’€ @€ @€  p§@€ @€ @€J €À½ˆ$@€ @€ @@àN€ @€ @€ ”@{ I€ @€ @€ €À>@€ @€ @(÷ ’ @€ @€ @;}€ @€ @€ Pî%@$ @€ @€ @€wú @€ @€ @ ÜK€H€ @€ @€ îô@€ @€ @€@ ¸—‘$ @€ @€ @Üé€ @€ @€  p/"I@€ @€ @€¸Ó @€ @€ @%@à^D’€ @€ @€  p§@€ @€ @€J €À½ˆ$@€ @€ @@àN€ @€ @€ ”@{ I€ @€ @€ €À>@€ @€ @(÷ ’ @€ @€ @;}€ @€ @€ Pî%@$ @€ @€ @€wú @€ @€ @ £—I@€ Ð |óÍ7îæ›ov<òˆ1b„ûþûïÝd“MæfœqF·Æk¸!C†¸ôšU[ä~øÁÝqÇ>“W\Ñ 8°Ú KNý»ï¾sW\q…{å•WÜ{ï½ç~þùg7ýôÓûv_ýõÝ,³ÌRrŽ$@€ @ ÿ™ë?Õ¥¦€ ˆÀ¥—^êvØa÷ÓO?Õ²à‚ ºë¯¿ÞM7ÝtuÃôUW_}ÕýˆŽLë@IDATë_ÿrÓL3Ÿ„HÖSBjMJÈ)ÜœsΙôîØs}òvØaîôÓOwšlÉr£6šÛ`ƒ ÜÉ'Ÿì&tÒ¬ =víË/¿tÇw£>º›wÞy{,_2‚ Î$pûí·»üÑM5ÕT^) Y)“äƒv¿ýío›EéQÿ_|ÑýãÿðßK-µTæMf€ PMimî•ñ%a@€@çy·Ývsçwž/ܯýk·À ¸E]Ô —Ÿyæ÷øã{A§L4ÑDîÊ+¯tÒäîOn†fð $œÞe—]jªÞ[î{챇;õÔS}]4‰²îºëzÍö_~ùŽûî»îºë®sü±÷_b‰%Ü<à…Ý5•ïÁšÚ|óÍ}”ð@ý›€&Á?úè#¿ 鍊nj #ù¾ÖD²ÞƒäöÜsOwÊ)§¸?üáîÁ줢Q@(NÀ Ü1)S 1!@½ŽÀj«­æî½÷^_î•W^Ù]sÍ5n¼ñÆëV™™YsÍ5ÝW_}å†ên¸á?Àí°^˜p ÝQGåk.<½ÁÝrË-±°}Ûm·uçœsŽûÕ¯j·ò9î¸ãÜ>ûìãÎ8ã ÷·¿ýÍkÃy䑽¡z”€ @€@ǨiuL±( @eÝñ lßf›mÜ­·Þš)lW¾K.¹¤{â‰'¼9™ÿþ÷¿^ûïÿ»ì"õÊô&˜`wÀø¿Qmv¥U€÷ÝwŸª²g Ûå9æ˜cz¡üb‹-æÃʾ?€ @€ò@àž¡!@½’€„æûí·Ÿ/»6È”ÐUöº¹Ùf›ÍÛûV˜·ß~Ûþù‚{¿‘#Gºçž{ÎoĪMXó8™»yúé§Ý°aÃÜþóŸù¤Ÿdxøá‡Ýûï¿ßRúYiµ1èÓO?õ¯¿þºË3i!*óóÏ?ïdö¥'3AróÍ7_7ÍödºÒz_o½õü%ñü¿ÿû¿¤w[çêƒo¼ñ†o£ûï¿ßoÚªþR–k·ÿÈœŽ&&Ô^YNýYKþŲ^˜¬x\ƒ @€úîý«½©- ôS7Þx£ßàSÕßk¯½š Û¦UW]ÕÍ1ÇþçGQ#Ì–ÉÛÆmµÕVÞôÌòË/ïÆw\§ÍVµù×øãïæšk.'s&œÑÒ¨—i›…^Ø-²È"Nf[d7^¦MÒîꫯöù†4% ×fhÚ¼Tq’ÂiiñË>ýÔSOí«¯¾º·•ªI‡ùçŸß ´Cú=ôOWun›uÊÉÞ½~ë逸žò×d6\{íµ×ü5ý“YקœrJí²Ë.ó´M>ùän…VðUÇO<±†cœÀÿNn»í6_VñSÙec_¶ôwÝuW'¡µ6}S>y4Ð¥Ù.'áýÏ?ÿü¿œ²믿¾7!¤ sÄÃN;íäóTûjúzîî»ïöá$¸—]øàd ¦™fr³Ï>»o£å–[ÎÍ3Ï<~ã»?ýéO.)xW_Pýd¿]Nf﬽òöŸt;]|ñÅnzëÚ„O}Xí5묳Æå׆vC† ñ}r™e–qZ 6þãÿè>ûì3_FþA€@ï%  äõ>פý]wÝå'ÿ5‰›Ç5šôÿî»ï¼"‚Þ?ðÞ(ª„xhãu­‚Ô$z–“}M`òÉ'YÞ\ƒ Ð?Ø@ @€@'`BÍȾl"3™À4Wmͦ·«ø&ˆŽã®±ÆþºÙ‚æž{nn›°F¿ûÝgž9ŽcÂÒèÐCã%OL(ýæ7¿ñaÇ{l×±Ñè£î¯ÉÏ6ïLF‰®ºê*ï§p¦3Î8q^*£i‘û𠧼uM&t–]vÙÈ&âk&@ŽlìÛör|=ÄIMÛ܇3ArîÕW_ËfƒK}Š)¦ˆ®¸âŠÈ„ÎÑcŒÙ¤Cd“q¥i“q¼äÉ™gžéã)Œâ+®M&Ä׶ÜrËÈ×>-Û0.µáùÁçovü#l7 Ÿö|ñÅãø¶‰nÚ;þ½Ùf›ùp6á_Û{ï½ã¸OŽmØ_Oò×¹M\Äéê¤HÿI¶Ó 'œàóR¿µ‰ß7BŸ{Óf ÙjÈV|ør›Ýþ¸|&€Ë]S0~@€@éô×»@ß­¸äûÚ6MíåóÏ?vß}÷hàÀñs=¼wtÍ6M¿)Bää7ˆ®Ùd|d qüð "?›÷ï½ÏCºzǬ´ÒJ‘ «#ÛÄÕ_·MSÜ;ÛÔÜ_Ûpà åšãÎ;ï§e“è5~úa+#›°÷al5c¿)@D¿ÿýïãø¡L:Ú ¸È„è5áõÃ&ù}xSÜð,l£×ø»íÀŒÃ›²Cdû¾D6i]“¾ÞŠcëqXN ôq?ØsÕž¬8@€ú<Óìö |ò: ¼õÉ ?ÓþŠ£{ð³D#Ó‹ý%ÔM O͆|짓7ß|3’ SñMƒºf"À´¢" †å'A¼i1ÇqÃ`Wu ‚þM6Ù$’ 8 >Íü‡Ÿ\Pü 6Ø úàƒâø:1möxÀh›…z? |MûÛÿ…ïI'_ áä>Kà.!»´o¼qd&Yâ|%´^h¡…|Lƒ?úá‡b?˜V÷S™Õ^_ýuìoÚd^À ¿ð—GànæR¢Yf™%Ž;ÖXcEš(ÑdÊ /¼àèqfuNlõ¯xYNì ÿòË/÷A¾üòËx²@B ‚3íÁÈláÇeÒ䉜åJë‚ .ð~bÚ%9`/Ú‚À=Ö%PIö[ c5YòòË/‡b{æ›n‡yë­·b?N @ :e ÜMë<²dñ³I{ÂË?|w$óß=JCß(i§‰bù)ï#FÄÞy•BĤÀ]“ãJ;üû_|©áú´ÓNë¿ÿT‡pMßtzïã ôÜûA#SE@€€' ž=ÒªÊëÌ„J<`2Ó qô¤Àý°Ã‹¯'O4¸’Ö”ò6.I/¯­¬ë묳NÍõðCZbŠ£0fN%\Ž5Üu]Zc¦mëãIøl‡°f.LJÉÊßLŒx¿d}C¼fw•kñÅÁkŽš¿þ^z饿0X532‘4ÅÒNÂê °Wü<w¥eK¼}û'¡,Z% Aºê› 'ËpÑEùrkõ-‰Ozùs•GéIèVQÜyçq}m¹~·8º0à 3ø0aâ#ºä’KüuiÂg9i»+¿¬öSøzý'ÜWƒ,&4qòÊ+¯t "–]Vÿë € Ð6 p—ðV°Íþ41žÕi ÷ƒ:ÈûI¸.…Mì§IصÖZËûk%\r²8ÜMú'ß}ZYgû~„¤ýï±Ç[#ŒO® {ôÑGã2Ûž8q:ÅO´«L27#…½“““ LÆ(ýàÚQBwå»ôÒKG¶¯JHÖe†FïyMÆkÅ\– +ÇTæääCVX®Aè¼À}t{pâ @èã´a¥6Ÿ4Aeîš&ãÌ8ãŒÝâ›6·ß µ›Çÿ.˜ætìeÚfδ´ýædºh4®/³œiOùË&üõ›¾jCÖ¤ÛqÇ“?ãsÓª aµù¨Ùé÷zxµÛ´‰k–S;É™¶^–·¿&.É6¬@è8Ú]ßze¹o¿ý6¾lBóøûìnþé Y“þá;Ga“ 鸚ØUÙ¤vk¯½¶gêÛÅV—9}ÈûRK-夨 ÷´&´Ã{Wç¦!ïlW—T(C ÁÌÞ¹¬Iê0nÚëîÚk¯MW%þm+-ý¹™œAàSáè˸÷åÖ¥n€ ÿÀ]Î62uÇwf2ÅÿnåŸtÁ…tÂo[þJ°.ŽA©Z£©ô¿i­,Å4hP2H|n¶ãÙ6u¶á«¿&¿°¶q¨ò2ÄüñîüóÏãŒÊ“ÀPå–¦˜&²œÞ!l–Ö5 §¥m'æÒPoä¤ý®þTSMålÃSg›ËÖ"C€zÛ¸Ë ¥‰|ñÅ»<ÐICª™“@4˜]9î¸ã2ƒk°'Í«zÚ`ÆîÒ¤–Óàñå—_v¶ÁXRs´M7ã%ÊôÊŽx+. :µd\ê,'Áv§¸äÊ›o¾Ùm¿ýö™E“yœ¼.,5W¼‡~¸¥q˜ ‘ɘ¤°]iˆçž{îéþñxÁ»çÌk€Ÿ6 £ü¤ý&¡Ez%ƒ„ægu–œvÚiÞ­LëÌ0à ʦ¡«ºÿ4ÌO@èÕôma›®{aû +¬àÛimt™@käêMú‡ tíñ¡4}k5šdÖ;5ÜUŽ`N&ܵˆ&Ñ¥?lØ0¿âO‚Ï0a,{Ja?—dº:×Ä„LðÈî¼4îq½“€¾õ¥œ"·Ï>ûøU ­ÔD+'µªcþùçwYfšZI£Õ0úfÔ=±Î:ë poáF)Ɔ+GiÑÈ€ 2 uÔQ^¸©AàK,á?¥/3|°"íªÅ[,3¸ÌœœtÒI™~Ò`?å”S¼Ÿ„ÊA#ExÉ«œLÔs{챇îjÉw«Âv¥4Áëi[ip &rÒú¯çùÕ‹SäºÈÚ|VNÜÃæeÉ´$Œ–¶~^'-¥ ÄÖFeIû²YiɆ­l¬Êɶ{Úi)°»/³2ÁœÌV[m•ê—¿ï´ÓN^+¾K-.Ø© ¿uÌŠWuÿIæÏ9 ô-Ò×fßrZÅ—¶ëzÑIùäúwÜ¡¤2Vÿ…﬚Ðw¾WôMîÉwf°O/¡{P4Hn–Ò ~A !K³¾h}Ãø‹/¾²Ë<Þxãþ{0˜úË ÄÅQF`Át¿ýío}þ7ÜpCKåP›JÍL¶” ÐÇ pïc Ju @õHø| 'xe} K3êòË/wÚT,8-K–¹ IwÝuW¯®x'Ÿ|r’y<òÈ#ÝA`諯¾òfB}ôQç°Ã«Yj*y ú4 •9Ù NvKe÷;ØÝf›m‚WKÇ9çœÓ‡“&Œ4Ù’î¾ûîs+®¸¢ßäS×¥ŸvÁtΓO>éë¡q–à7¯ßG}´.ð•VZÉ·ƒ&,´éÝwßí'I$ ÐF§yÝUW]åd*FŒ5X×Ê… liɾ¾V#Hð//èo±ÅÁ»æ¨ÕrW\q…Ï)§œÒI8vA {í›o¾¹g™ £teK_Nm–Ôm ­+õI•Wý3¸*ûOȃ# ô=aR^ïÅz¦3´ÁwpyÞÿZ-t½ßÒïڦҫɵäQåaeØõ×_ï73—p;99òI ÜÓæd”f¨o»JÉò…ó`&NßrzWg¹W^yÅkOku\£:gÅåZÏЪ9õ—矾iÆá]+!ë­&mšHŽÒl—òP(gŽ¨…À¨!`/ @ýˆ€iTE&Ø”Zwügö#Ó>Æ{ìøšüM³=2áw&5ÖXÇ]n¹å"ÅWx³]™ùšÈ…‘ Óã´vß}÷ÈÌÇtKçÔSOÌð¶:2(‘Ù€Œãš0¾&® ½Ÿ „»¥.˜ÆZß–}ûº™MÊh¢‰&ò×mÐÙ’Ù8ŒiöD|ðAˆ™p8ö œLøîým û½úê«q<Ç×m€_OŸ„úÚ:í]pÁ‘ âtLã;æ£z˜@||3ëÙx¸ì¦ý™ù¸¸,úVJ:›@ð~âTÏ­¶Új>Œ¾±nºé¦¸ úî3Ámd Þß& ¢FßGõÒçzÏ°ìã~`ñ6ÍTýI÷‡¾#q€@ ìÞ°»@€@¿#`fC"ÛÜÈ ]õ9þ›nºé"Û\54e wÓnòƒIÓ<ñ÷–“¦µ]{íµYÑãk¶ ’ŒiÀâêhvO#³í™}ð8¬NZì*œ™²‰ T“æÀ#ÛØ32­öÈ4§£‰'ž8ö×À<8 HÍ©÷ƒâž¸+ñËi§Ö—Me6÷èöÛo÷Å“pZ|ByB™[9š½ØhÇw¬Ûîã?~d+"³ÏÞ4¹ä¤F³ð¶o@4Ï<óĬC;kòÁ–¿Gf63?3%i°&‚ÒwEÊÛ¸g¢æ" Ž'P–ÀÝ̶ùwKxÙ>#^h¨Ih)躙´‹‚@Q߶JÏóiõDß/!-¥§æ?ûì³FÉŒ2?}À'9¨œa@ÛÎ ÂÌÔxÖÒòS»K#í¹çž‹t½Uwì±Çú²Ø~­FñšupKèýÒK/ùI–#7 XEÿi’%Þ€ ЃÊ¸«È¶Ÿ‰ŸÌïTµÒNf½åÌ\^üÎÝtÓMýµVî ¬ï­Ú“;ä£s3™Ít/Ô×uý®ç†êãªlŸþy·`á]¬tô=WÏUBhEà®<õ½eûÄÄ+C}uÔ÷¢ ¸Î'`{2Å}µÑxà€ðá¤,£oÿ¤“€=¬jHöku£„ðiú™Æ!úž3óCQP09ðÀ}p݃JCJ)YÎLEú&M+ð˜ÙCß7õÍŸv­(a(N½Õ©o¾ù¦Ÿ8KN®…:/¹ä’‘퉔ÎÒO>„0y¾¡»%Ä…N&àîTBkl @ÈE@s™Y'ûE6óÌ•Y?|öÙg{[¯fnÅÍ;ï¼™5Öæ´{ï½·Ó梲³>ªœ>MûÉÙ$†»ä’KÜf›m6ªŠB¾€ ´Y¨lVËÍ=÷ÜþýšLÌÌÁ8í%2×\s9ª%½Z>7AŸßDÜ„íNvØMx×rÜ2ªÚÃGû§˜Æ½ßPÝùq&èôvØõ~Oî©hñDûŘ…³UsÎÌÕÚ{¦Å¬V2í¹c+,ýN&èvÚ£)Ë™€ÜÙ¤•“]õë®».bfœ6P bF›$s³Í6›ßOI{ÉéÖV'ºÙgŸ=Ž§Í†mµ¤Óæº×\sM¼‡“„rè[S{3¥óT[évÛm7§=—ä´_­”õ÷)ùkf>Ñi?Õ/8m\¬ïn9í·`+1‚WÍQ÷®îÅ·•)ÞO÷’ Ì݈#üžT¶’Óï± ûKûÈi?$3™èlâÍÿÖ?›ˆ‹÷yPü°!r€“¾@àG{¶ŽÃ¦©}¡)© @½ž€iÙ8³+ïÿ´iÚ™mMgf~üåvØ!íÝ£¿¯¼òJ/l·åâ~#´ÍœÌ @%Ð{L›ÈëO‚À´›a†ÜàÁƒ Û•ž„uöi2}T ÛC9$ð׆æH&…íòWÙÌL[Âv¥cæúœi÷znE6zW¸QC@›«íä$\Îr¦ùî…íò“p=8[%é¶Øb /l×ƦfjÈ}øá‡Nß·¶ÚÔ™YgZëNp3½¢Õ%°×f¬ÔÛ¾ îž{îq¶TM˜ô3oãô],a»„ÞÊK !¶âÖO–éÛY}[›ún½õÖéè…ŸuÖY^Ø®gˆòÛÁÙj/pפ–˜~øá…ó bï&PlŠ¶w×™ÒC€ Ž#°ÝvÛ9³Óî&øÛÆÎlà;³aé ¶Éš8ئdΖòöxùï¼óN÷ì³ÏúÁÅå—_î󗶽-Ýíñ²! @€@ù6ÜpC/7s)~¥‚Vw$]Ðh·ÍãÝÊ+¯{™©g¦…¼pû /ôÂõØÓNl¯g¬za»„ßYNikBHÂ~¥ßŠÓ·¨™Œt“O>¹²''yl&·×^{ù²ØFþû®»îr¶7R+I7 £úÊIK=©­¯kbfû>¸Í7ßÜ=úè£NŠ4a…Œ8¨¼réI/‘}†î}¦)© @½™ÀŠ+®èZÆ-Á¶îC† q«¬²Š×ŽÑ’v B̺›`‚ z¼ªÒ:ôÐCÙ|÷;*¯ÙØìñr! @€@5d2E«2ä‚p=™S¸&Ó.!œü§™fg{BùoYi²g9Û;Ê_¦_Òa$ ?óÌ3[¶Ë¬L¶ÈIÀ¶'ÓÖ7µÌÖÈÙ&ÂI¯ÂçóÏ?¿{÷Ýw»§žzª[:o¼±ûæ›o¼–ÿh£Vã/A;Âö$}òî}²Y© ÞK@¶Ï8ã ·ýöÛ³¯Ã›QæO¤£åÖ¸r¬¾úê^[Hšî¶‰©“-M ×e+SËÀÃ2ßrrË—Š4r¤%$»œ .¸ 7%£€ @ of¹4ÀmóS/WÚÁ-»ì²á´ÛQo¥­ðÉ8Ý渰þúë{ÛñÚSI¦˜”¾4þ[l1'a¼ÌØh\ÿ%€À½ÿ¶=5‡ Ðq´Üîøã÷›AÊÞžÌfŒ9æ˜WN ôÿ èãW>} kCZýu’ÓfrÁ†|'•‹²@€ ”G@ 5¸k£Ó×_=‚ívi³Ë”J–“ÝuÙb—Ém,6P•F·ÐZ±YÏÍ<óÌõ¼2¯k£U9iÚËfz#'å9­ØLšxi§‘Ÿ”`xào6æý÷ß÷šöAÛ^›¥J/ÛòI³;Òïï@-©ïµ)5‚ Ðk ¼ûî»^Ø® H#BËq€ @€ Ð3dÎ0l"„ìÊ9œkSÔ´IÙo—–¹L^zé¥~L'ó4ûï¿¿ÿ­qÝzë­×°Ú,5 ÂüVâ¤ËÛJœfa´úS|Ùißo¿ýÜ"‹,â…ÿÚ,U«U‡êÄ*Ølo–þ}‹÷¾ÕžÔ€@¯&þÉóÕ«+Ná!@€ tÙ`_c5|I´©œÌÉò6ÚÈ_KþÛwß}½Æ·âJÃýã?öú£>Úmºé¦n¦™fJÏ<k¬±2¯×»ì²9ÒI˼‘ eŸqÆã L…~²Ãþïÿ;üìv”¹™‘9æ˜cÜ“O>éí¶_vÙeN+C容æ?áÐ-"ú<>#pצ ºÞxã ÷ÓO?•Òpºiµ|fĈm§§ò½öÚk —ÏäÍD‚)iƒê¯]¡”ê*~Z2ôõ×_ç-Jfø2ËWvû–ž”Ù_2ö‹Uô³2±TQ>-™ÓÇÉG}ä—®µSÞ*úm;åÉŠ[æ}Ÿ•>× @E hð/ »ôänÑôÊŽWvùTOÕWã™FKø[­ÇçŸî^|ñE÷ÁøïÞVã5 'Û·²í«c»î³Ï>óß\Ÿ|òIÛc#•¥ìôBšJ@ “ ȬŒœžÑ’ív ’ç™gžnE¿÷Þ{ýµ?þñNöͳ4Ê?ýôÓnñÚ¹îJCæ]ê¹_~ùÅ=üðÃÞ;gì±ÇŽ£Ô{½úê«q˜p" ö³Ï>ÛÿéݘtJs“M6q2­&BÞÉpœ÷}½Ú†»>5stÑE¹—_~9þ°Ò=ûì³»­¶ÚÊm¶Ùfnâ‰'îÖ’×^{­»ùæ›ÝðáÃc?-_ÑÒíZ¬?Ù›Ò)7餓ºyç×oâ§e1­¸÷Þ{Ïoø§‹CZ*›6—›o¾ùœ–Ÿ¨ŒÉ›<™î‡~èÎ=÷\÷øãÇeZ’¢ Õ´QÝßþö·xrA6¢´1ƒl«þîw¿K&S÷\‘Ç{¬»á†¼009ø˜rÊ)ê©zë{àúú'«º|í´o²œá¼ôz¢¿„röµc»ý쪫®òöã4¸ n–Yfqë®»®[uÕUÃ%¼óÎ;Ú*Ì^ëâ Aƒü²6mÀ™åÚ-_Všú¹ð ý$›6< N› .´ÐBNSL1…»õÖ[vL׌x=×N¿ÕLü駟îíÉ}õÕWqzŽtÐAñï/¿üÒuÖYþ™¢‡¤Smœ\÷½òÔ&©=ôK„iw÷¬]îeÿOvñvÙe—LÿP^Ž€ Ð èÛöâ‹/öã ˜ƒR‰–Éë»^ßΛo¾¹?Ö£t÷Ýw{í´ä&kú¶X~ùåÝŽ;îG»à‚ Ü]wÝU£¨£A½–Ïkó¹,WFùÒéê»æ°ÃsHЮÉúà&šh"ÿ}¿ÖZkùo½_¥‘Xo,¢xZ¯ñ‚ÆZIa„4úd¿vµÕVóKéÅRû®¤¾Ënºé¦ÍC]ÓŸÞýú®Óiºé¦óB•¿Õý[d#Xì¥ùý÷ßÇÙkl$íÌm¶Ù&×fÓEÓËú>RaT—I&™ÄuÔQþ;Gš’r£>ºß\pñÅwþóŸ}ïÁ?@B`¹å–óò ”5¾ ÷,ívYŠ rÒ Ïr’‰ÝÿýÞ«]…Ѿäjy衇zó-ÁN££d†z'Êm·Ývþ¨I6’‹ÉæzÚé˜vz|ðÁNclí½¤wMÚi¼¯ï)ß7Þx5ÞÉúëý‡ë£¬¡{¥»ï¾û"ëÀ‘5KÃ?¶G&X¯©£-5‰ì#±[<û0‹&›l²n×Óy˜ :2͉š4“?Ìîpd7{d³YMÓš|òÉ#û8OFÏMß-¾Ê—UöPFùyä‘qõNÎ9çœHõ ñšUç´«²|í´oºœúÝNzU÷—¬òö•kíö3³‡Ù (³ŸÚà0²\ŒÊÓ û´M\ÅaÃI»å é„£ ¶"xf–·Þ=fÚ!z·c;ýV‰ÙòµÌ²˜p¡&/ûXÈ §2§ŸuUÜ÷gžyfÝüëq ×mR²¦.ü€ ˆÀ°aÃ"›änéýb“»‘ “»Ó5$×MÃø>Î3ϲeÕÝ—U¾°žÉ2jRîä“OŽlÙ\¤:H€nKÍ¢ð1‘ +-²¤+«ß*MÝ׶T9š~úéãò¥î˜9ÏUZ`ɲ¥îU<—4°×óY+ƒ6Ûl³šüõ,Úc=ºý)¬Ù‹@ôÞJ¯‚5SŽÑŸþô§ÈÌ£DŽkpm6fk¾õî3S•!™øhæ'ý;(­ì#ío äåtL«(¼„ÙŠŸte—Oikü“^k¶w½Ö´Ù\|ðAÿ-°Â +t€k ‘vŠ“üü4Anû=ù÷ï)§œÙRþšpf¾'TdKø=¿dz:—¶ Þï·ÜrKô /øo¦´F½&&²œÆVÉô$Ô×·ám·Ýæ5µºY«÷&˜`‚špÒlÌún(#=})ÿýöÛ/S±IJf^&2S}~L(~+¯¼rM»IÉ$ë›5‹× ô)”&å`é‰ÕtôlK ›õ¬8p —9I‘QŠfI%5ß幈†{(ƒ4Û%KÊÅ”¿Ê/Azò;ÄÓQBõôŠ6iê‡úf ÜOå×?)ìï'M0qÄÝòÕ¸7„Aà.Š}ÒõN»n Ð9u” X,'zRhœeºÁìéÕ¤'móãŽ;.+9¿QKT’ù'?,µœ4¹lR7z½¦ÿüç?QX‚Ò“fD–“ÆM££–µ„üdøvÚ)g¶“^5çsÌ1GN³mõœ„ùáãÝ6½¨,*³|e·oÙé•Ù_êí#eö3i§'ï- Ðê¹ÝvÛ-îßìjИåÊ,ßå—_ç©{T÷v–ֺʡ{7½Ä=½Ì¹ì~«|“÷iZà.ÿà$ÄN>o´Ê Ë%Ó+ã¹òÐÀ<™¿ÙŒ ^!@M H!&ù‘05KȪ„¤¹—ÔÀ–^½÷žÙï¦ô³ì²Ëzm¹´¢ÞÉåãÉB—]>}WA€ê­¼µt¿ž“0:ÉGßMi÷׿þµ&Œ&)²œÆ`k®¹¦+M@)îd9M$óÔ8%+Í#FÄc…× ¼´“>™–LM:ì{ï½I£1>½2®ìôT†äøSyÛƒuË(¥±ädŽ4'â ôVÒæ–ðÛ61õJriyßR K+•U_½ó¥0©ç{Òm³ôOï Äó–Mæg4Ž•²ê¦tÒõn–?þ}Š@ï¸ë¦M~0Ië¼™“=ód}X']Z€šµ¬2^ᶱBœ¦>2ƒK¦¥N™¬ø駟êþi†Ï6ŠÓ²MCR5Ǥ`Kšõn\iL$ëZOà—ÖâЇꮻîêgïôPJšÊÑ„>ºë TTвÊWvû–žêšlc±n§¿(½¾ìÊîgl°AÜ¿µÊ%mN,µ¬+¹&kïÀ¼Ìò%µåµ¤Þ½òÖ€4Ü«$']ýVé'ïÓ²îe<—îG@ÈK@‚ʤ–™ÞOß~ûmÝoq}§Û†ž5æg´:­ž{òÉ'½½íð×1(§„kÒìk¤pSvùÒÚèR8jæ’J?Úï%íÒïbi'jœÆUXË?(ÿè›ç/ùK7Mþdši{z<– ›g)XheB`­rÕ¶‡4%l ¶‡O“$IWvzJ;)p—VÖ7k² éñE½‰‹dÎ!@èX½Oà~öÙgÇXÒvÕt3§Ù5mb>ÌÒŠ&?p¤]ðå—_6K2Úwß}ãô´ÁBpAÃ#äUä˜^vª´[”i6-™g½ºH£$lú Ÿ<—9 Û}:ÒÀ¢™+«|e·oÙé‰C™ý¥×Þî_v?{ã7jµYK Ã¦.êËzF¤7ïJ2-³|É ±Ž9æ˜d6uÏe§S‚-oOº*ú­Òoõ>-¢áÞH€ßês)0HòÑpd8B€@3É íäwmžóFï4å/¯LAf¥© פU]ÏUQ>mÊÊ"mýFJ2¡\2 £U®únª§$D‡ô“G)É6¯¾5qÑÈ¥îYã?iš'K¹j²É&‹ë+3­¸ã?>Ž£1P’QÙé©.«™ƒpfc)þ]ïÄ>^œÙK½í#9>OŸ˜-)gKIÓ—»ýþì|TÇLJâZ ¸{‘P X!ÁÛ@‘+Ü‹´8¥B©-…ýŠ[pw‚“àîP\‹‡ÍgÛݼw¹‹Þ%'¿ý|.ovß¾•ï»Ü½›þu™ØúHâ!SæÅC´.® ”Kѽ4Ò× ‹vÛIIü(°y°Ä €€½ôå—_’Øöc³®½NØûþÚ»=ËyÆôýbÙž»åíý>ÁKH,iL“&M"!]çEÀâ2•„%yyy©l˜£½Æ'þHüpÔí?ot¡A,Ü‘ØòMµjÕ2uôûÖÔ2   àFbãY\,²“ðk•šðÑM"fŠÕs\èˆñ;×%$ lö¯Nˆù[@ă"a%®ŠMG~¦êܹ3ño)k‰ˆmó$|§?S ך֪ٵL7%±Í_·Y¶lY-‡'ë c,âß9œìÝžµ1¿ÄÖŠMe|øž¨d|Te8‚€€¸ˆŸÈœh>ÂjC†•\‘MÂÒ[Wî&´l)W*$|=Y‡É «o]ÆGbk¨ÌgÊ”I—GW0Ž5ºmDæ:ák’„õ/ ëZ¾ãI|$U9̥„„%.‰`IJ#“½ï¯½Û³œ{Lß/–í¹cÞÞï³o¿ý–D@)‰Šè‰ $›Ø½¢†øÇæÀõ9[‚=ÆÇ}‰Ý1º áòIËÑý¾Î˜p €€¸ØxÔHXÁ[Å!ÜßÑĉ­žãBGŒÏ¨`é3ˆqàlØ$vÝÑÙ³gI™¥öíÛ“ˆA£÷ëŠÝiT¾|yPÅv—…u: >º]a®åðËßWê÷ ½Û³6á>ÇZ±©Œç!vè²’%Kj€€€€køWså"c7Z°5ëŽ;äÃ]xÃç‡V,«dlC•­Zµ"áRÔƒ˜ñËÂ'#‰@­º˜-ÀUâ‡#' H>p U½ðŽ‘µŽ ¯ðÎñƒ¸ð½(žÙj…­k¶"؃<·gÏ[T¥å ·'¶‚’ðñh²0¯Ÿèœ3Þ{Ü_{·gmN1y¿XkÏ]Êõ>Ë›7¯ü‘«,Ùù=Ú¿ùãkÚ´iÿà5Z éÿ öŸðÍ)w‹¨Ïþß©Y³¦e—‘ÎÇÆû6ÒƒAEp!limLÂe ñâzT’2¤±v [s2ÄtJ¸‡£õë×Ë2áCž:vì(Ÿ¥Ù`Ÿ Ï1>ãÎ[~á·áÍÁ4xÞA8cÆ .cHr§nݺéšbs7‰˜9ÄJvÞ©7~üxâß<÷>}úpU£ëÚ[®Zäe.âLQ›6mÂp¶ì—è$\’ðé.³önOõa<Š`»Ä».…ß|c±–™gk±€#|âë2ãïK]@@@Àµ¸’G2Êgaùb?ã$ÑVâàŸùóç×õÙŸže}£OnÕ®x㻜q"lªê ‹’ñ€­»Ÿ9s¦>Çu„…­>!²¾—#ã+9((HQ<<‡;,öohôMݵkW«õí5>{ß_{·Ç“·çûÅ*L7)tÄûL¡a¿ŸF?—Í›7?Tôûšƒ—qTòð’½ÇסCÝ?F±òˆÿÍž=[úO=s挮îˆ÷-7.Öô«T©¢û3 XÌèŸ?Ç8P´µd¯ÿ{˶ÙW¿úŒå£ñ3Ö².çÙW®°¾³v e  H@,ÎëïdÎÏ 1MbW]H‹-t»üýÄÏ"b±_6ÍGþaüþjØ°aÈÓ§OÃtmïñq@Nc¿íÚµ Ó§µæÂþÅ­ù ¯V­šlSìº F0Ö.×e0ÕØÿíÛ·õ9%ØÓ‡û€Lý 7>ª«Ga(eª/ ŽLõìÝ7nù^`¿ñbGqˆX˜0õ;ô9ˆ«‘_… Lup9®4•spãCIêÔ©CÆŽk ø#üñ…Lž<Ù‘ž¯aî’5ªjŸúüÀ)¶O†ˆm•¦~¹Îo¿ýfjOXv„”+WÎT¯Aƒ!¿¡©g8àëÆ¥WX<È…–-[†°b_%V¼­^½:¤D‰ºÍÊ•+‡¬[·.Ìÿ°| Ü´iSˆ°äUÍÉ£pÁ¡Ûâ9ðCž°Êáà²ÆÄ×ü`¨XðQXô«„8b|ö¾¿önÏžïL7ËØó}f ÿXRïM^øb%»Ê‹]Ö.1•Ù{|ÂÂKiUcà\üÿbíG'—ñâX©R¥ô˜ùÿИìý¾å¶ûõë§ûc^Âתî’ÀñNáCT×Qsá¹?Gñ¯"þ1j¼Ÿ~~~aׯ_=ztH™2eäxù=°hÑ"c3A@<”#Wßa|ÖÌò·/*·ñ"/e£á%¤X±bò9ÛXÅ•ÚØ®°®6V“‹èÆó, ßáa¸Û{|<c QîWì´ Ùºukÿ61&~Þçù}!b7¯æ$Üžèjü[„Äj.Â"Tª‡áƒ<$gÎœ!–/|^ yôèQ˜;žUµkíسgÏ0mq+®¬)çÙB„-Zø!Rfµ:F[*‰-°¦‡0ã8Ú¶m«ª…ðÿ˜0žW²Ø ªë± 5Z­Ç +¶n8BD0Ð0ãã‡òcÇŽ™ÚrÄøì}íÝž½ß/& n”±çûÌ–+W®˜~ ª÷»ðï)kgGŒoøðáVÿ·Øâ]|•ÿûüCTÕx´´8·÷û– ¿ªaúæÏLkJvãØXÛÕõmpÄÿ½nü?A)ÒÕ8øóS¸Ú‘/–U¹ñøÙgŸY6ƒ<€€€‡`ºñ;‚e~Ö͘1£Tó3¯Q©l¬ËŠw•FŒ¦U—¿ßÕ+VÚwÁª:ê(‚¬ª&åÑ^ãS²2ܸ+UõË ØY²d‘J^>ZûÄuY9¯’pIcsÎü§H‘"ò÷–Qa¯úã]Æ$â^Ùl‹w(~|¥R^µÉsX»v­±Ù+V˜ T]Vh,X0ÄÖó/®XKönÏ–Â]ÓÚ‘5þøãkÃC€€€€kpM…;3fKäÓæœåCŒð=Æ•ŒºWF*+ŸXiÆá–m¨<[»³ujx‰-ËÛEÕµùÁ]¹o`+RVÚº†•dÊjÅr›¦ñ~˜5.4†6Û4^g”ùÉ‚ LSvÔø¸{Þ_{·çˆ÷‹ ¬›dìõ> oƒ6¾OY6.D…w­£Æ÷駟†“å-óü¹cÍÊËÞÿlõe¹Þr,¶òüY$zÉ]-Žø\²¼Wl¥Æ?šmDzN¼E’]¹ðC |Ò£GȪkՎ呤 îÖ¬?Œãd« ÞnÊ[;Ù:Ƙ~úé'iÑi¬Ï2oÝô÷÷7V aìÇX—–yÁ˜x;-o3åºMš4 ÷Áœílcé÷^µçˆñ©¶ùhûkïöõ~1ŽÓd{¾Ïlñàÿ£uÿ¸¹ üyG&9r|ìò‰ùŒÿ‹ÖdÞM–s–[Ü-ÇoÏÿVº³oW£Ë56^œcÅ—_~i;[çóVr•ý¯úaWW¶v3ñ˜ù³•]ñˆºa\Ψ6pðl"¹t ©¾ëlÙº˜]˜-]ºÔŒ¿‹Ø#G¯åú¼ˆ­\Aòo þ~Íœ9³©/R³Å¼¥…¶ê$¦ãSí¨#»­ãß¼›Ö8^K™¿C9Ç´±–Øœ ØU‹å®3˶øw æXû½ÅÛ¬H·ÜƆCì.†]Ä©ÄVö+V4¹caE9Ç áÄÖû¯oß¾½ÍÝzléÎ.;m]oÙ¦½Ú3*ÜgÍš%»e߇Z@IDAT^C¦L™"Ÿ³Ø@dРAÒÞ7,‡<€€€€k ÷x<ñàäÒIø_¤ýû÷“ð;Nâa„[Êvnd"œ—ð³L_ýµ¬'î$üFxMT*ˆqÛ%‰ÇÈ/aÝ@¢•²eË&BñMâ!>*MÚµ.Oø˜'8‰Äq^lI%a1JBaOâÝ®ýE§±˜Ü_kýŤ=G¿_¬×Êñ>;zô¨ü?WabqŒ~ÿý÷hárÄøÄ+ù¿ÏŸK‰_$~ˆË—ø©Ï'ãdbò¾5¶Ã²Øõ"ÿï÷íÛGÂ…”ü?¨IXÆYVó¼ðýJâ; ¿®$¶Â“X¨/þŒâÏS$ˆˆ€PDëgq¡T%áZF>‡ó39¿âúy×ÞãÁZéÈ‘#ò·?‡ˆÅ}‹ò$S¦LôÎ;ïDé;ŸÛ‹ò·5]ºtòÙAý^àïç¸LÂЉ¶lÙBÂð‚Äna9×\¹rQ¥J•H(í£<´˜¶Ç¿íøÙ’“P¸S³fÍ¢<\   ಞŠg£än¡pÉ-€5&ô<ïZ¼_œçž‹í¹´xñb9 þaËe¬ÈF¸"…{\‘G¿   à¤ÂæNq/0¨>¾iÉ’%ú±ÊvM€€€€€€€€@\HWÇu¿¼ÍOøe¤ƒê¡<|øf̘!óÂ!•(QBº0Ð x,¼_âîÖ?þ\º?a·,*M›6”+.ã-Íìv¤@ª Ž     kDÜ+ùÌÊ.NU~òIÄÐ!á·ž„ú8w_¤Æ…#€€€€c x¤KVూŽ}8†—ªU«F6l¯ Îy¼_âî&ÿóÏ?2&í[·"û_e¿é©S§Ž°.*€€€€€€½øûûS×®]ÃmŽcÏlÞ¼Y*Þ툓   ®LÀs]Êp@ˆ”í|g98 xãÊwc¼_bÆ/&W³_öÈ(Û¹¶mÛ¶˜t‡kA@@@@ ÊØ’=¢Ä–ï;w΃€€¸ø߉äóˆÒÒ¥KG/_¾¤Û·oÓãÇ)A‚¦W„ ©xñâôÍ7ßP©R¥¢Ô6*»¼_âîžf̘‘ØÊÿWŸ˜0€€xßÿýt)ãA7Sp<Ïu)ãx¶è@@@@@@@@@@ÀÓ$ð´ c¾  àéîß¿/ãX)RÄÓQ`þ      nFàÙ³gÒ5­šVÒ¤Ié­·ÞRYAÀáÞpxèDàرcÔ¾}{9r$…„„8¨4 îEàÔ©SÄ~F½¼¼¨M›6î59Ì@@@Ài \¹r…|||¨pá´qãF§'  àú¶mÛFÙ³g×/üöuý{êj3€ÂÝÕîÆ« pà¡É“'SÏž=e"}€€M+W®¤{÷îÉóÓ¦M£ãÇÛ¬‹    `/  íÛ·ÓÉ“'©wïÞöj퀀D@àܹsTªT)*^¼8>}:‚Ú8íh¸Ž&ìíCáî÷£ˆ諆N:@À:Ò¥K›Nøûû›òÈ€€€€€#¬Y³F7›6mZ-Cp,… Òþýûéðáô`ÁÇv†Ö#$€û!"·¨…»[ÜFϜİaÃôÄ_¿~M-[¶¤›7oê2 a TªT‰ *¤OÌš5‹?~¬ó@@@@ÀÞöíÛG·nÝÒÍV¯^]Ë@@K€í*:tH‰n},X° ;V¿:uêä4óõÄûá4ðcq P¸Ç"lte_쿽AƒºQV¶7oÞœXùŽ `›@×®]õɇÒÌ™3u€€€Ø›€åNT___{wö@@l0êH<%þûoçß½êU«V-tb¿ØïGìSŽû¡pû{€Ä€ûpÏ;·naÆ 4pà@‡ –@‹-(yòäúĸqã´ @@@ìMÀ¨pgw2ÅŠ³wh@@ Žð&Ž öìÙ³€Ûb ð7n³.£2eÊHå<»MY¿~=­[·Ž^½z%Û`espp0•-[ÖÔ'ï°f-*%K–ŒzöìIï½÷ž´?sæ íß¿_ºpQ.k¸î|@k×®¥7Þk?lœ3×e¥?»ÕQ)2î\—ë±5ýˆ#Ô¥òÈ.cسBåÊ•¥kve<þ|Úµk—®gËU«qlѽºÎN.eœýa|Q'°sçNbc¼e‡¸ó^¹rå¢Þ®7'ðüùsÊ–-›|ᩲ?»óçÏk‹7Ÿ>¦   à`¼ë”Ÿ5TêÝ»7 >\eqˆFåvýúõiÑ¢EQî5Q¢D:n_ÌÊùeË–I÷+–M™2…Ú·o¯ý¨³›^xe75œ‚‚‚¤ÞF]÷î»ïJÿíìªÆ2]¼x‘7nL{öìѧxwv½zõtÞ–À ¼Æ Ý‘U¸s{ÜŸq‘€w ðBÕ˜ØmÏ©†±cÇR×®]UÂÈö¸aE3€Kgº‹}°bÝøÏŠwþ0»wïž}:@+ àFø¡‰ýò©Ä»CV®\©²8‚€€€@Œ¬^½Út½¯¯¯) €€€ëH‘"…´2·¦ çÙ´mÛ–x÷´JlÔÅ.WTb¥´JìÂ…ƒ¥Új+W®\²/ö ¯’¿¿¿cí¸téÒ0ÊvîœÝî°«•Î;§D=œ@Ø=Ów}tƒ·A©ÄJÄÖ­[«,Ž ìgθ/.^ à   àFØP%^è÷ööVYA@\”+Ô9ˆhx©[·nÄŸû*íÞ½[‰´eË-wêÔɦ²]UJ“& õíÛWe¥…¼¥{}ÒA‚q·–eÆy*o –u÷<P¸{Þ=wûÇ‹fÎœiúàhѶ‚u¸=LÂ!3gNª]»¶®Á>÷Ξ=«ó@@@@ :BBBˆýùªÄ>o“'O®²8‚€¸( D8r¶\/T¨®§,¿?~L·nÝÒåF·-ºÐŠ`¬÷ìÙ3b—eH àÌ pw滃±E›û×â€ÊG7ÄÁS÷íÛí6q!¸+ü¢ÿ8†•»¢#€€€@t °5ã;wôåp'£Q@—&ÀAP#J< 'NèjÊí 5êi¸^dÒ_ýeª–$ISp6P¸;ÛÁxìF€ƒ§þôÓOº½/^P£F(²èúB àæøpÞ¼yõ,§OŸN‘ @@@¢K 00Ðt)î&È€€€Ë˜7oqàR[‰¸Ø­/ë`Tòññ‘b„ ‰ý²«4þ|\U•Y;Î;W³‹£Ow}8(Üèf`(ö'лwoªV­šnøÂ… 2Z¶.€ @솩sçΚÄÝ»wå]@@@¢HÀ¨pgň——W[@u{àß{*ݼyS‰VÏŸ?§]»v™”å–Y¡îçç'½<}úÔtúäÉ“Ä ¬dT¥ *PæÌ™UV^«2ëã‡~PY«ÇÑ£G+æUjÒ¤‰]òhïûá’<`ÐP¸{ÀMöä)r0È€€Ê˜1£ÆÀ°GŒ¡ó@ˆÚ´iCÆmyãƈöÑ»gÏ}í‡~(øuX#;wnÝ+Ó8 ó,°%ú¶mÛ¨C‡RwR®\9*]º´©Že†ý¨4ˆØo‰%¨zõê”'O*R¤mØ°AWÏ—/-Z´HçY`—¦)S¦Ôeß}÷Õ¨QƒŽ9B**+õO:EõëקîÝ»ëºì’¦G:¯^(à¸!¬˜W/càn®·fÍ}ŽëY]X8xð ) _Ë‹ÈF9\ÆéòåËÄk*qÞÒý:§ŽŽ¸ªm‡@<ñ&qžá`$ à7n”«¬êÛ?¤ù‹¦xñâŽé­‚€ `¥û´iÓôÈÙ÷j™2et€€€D†À’%K¤’DÕe¶†Dˆ}¬h®Y³¦©ã,Y²PÚ´ie¬ ¶z·T ²ñâ7´ë–D‰YUN›µÈdÈØß{þüù-έ\¹’>þøc­`W’&MJ9sæ¤+W®Ð“'OT±>²ûÓ–-[ê< <~îãÑ£G¦òÈdR§NMЕYpb=/8XKÌ€•îÊë°aè_¿~aª²úU«VÉEˆ0'E=vQæ4žŠ] Éaáî4÷q$v+cܦī±ìÏ=:ÈŽ'Ú¸$`t+Ãã@ðÔ¸¼è@@\—€Ñ Ï¢J•*®;Œ@\œï2jÖ¬™iׯ_§cÇŽI¥º¥²]žôïß_+ÛMŠL¯^½¨AƒÄJyk)Y²dòúÓ§O[U¶ó5µk×–ÞXámLKŒ-Û-•í)R¤  &„Q¶óµ{÷î¶nçþýû&‹Kk|ãØØŠž”UÚ¼y³MÇW¯^ɦBCÆÞ÷ÃÐ4D'" w'ºŠc ð‡+Þy›‘JM›6¥Ù³g«,Ž àñØ¢X8±uÁÕ«Wõj¿ÇÃH(X° ±¢…»°t_©FP @@ÀnX‘ýóÏ?K÷º¶ Ù²¼^½z2ài±bÅL}-ÜgÍš%øçÏŸ—ú•3gÎH+sv)S¨P!òöö6¹õ55d‘aÅÿÀ¥«—‡Zœ%Jž<¹Tî³Û£+cEv‰Ó®];b2·nÝ2ž WΔ)“te3iÒ$b«tN<vaÃz#£úT©RÉÅcv½ªüѳžÐÎ;µõ?/ TªT‰ÆŒcs¼ÜOLï·ä´¤…;îN{00Gàsþâ¸sçŽn~ìرԵkW‡žL€]Ê°k•x›\Ÿ>}TG—oÍgŸ½*}ñÅRÉ£ò8‚€Äö7Î16.]ºDþù'åÈ‘ƒ .,åo¾ù¦ÍYS¸Û¬¬€Þ²e ]¸pA*ïÙM®\¹¤òš•Ø{?Ü•‡›Ì w7¹‘˜F ¬]»Vú/Sۦ؊—¿p¼¼¼¢Øªƒ€ûà¬Y³Ò½{÷ääøóü@gîw«1#p¶þã€x*q,¥ªU«ª,Ž  .HÀÑ wD‚!ƒ€-ðán‹ ÊÝ›G¿æm?*±‚‘ý¹· ©s8‚€§à¨¶mÛêiŸ={VnÍÓ@@@@ ¼¥_¥$I’PùòåUGðÖ#xÄÔ1IO&À wãÃÿÉ“'M–8žÌsN:™,Ú<ï Èxýúµ)P[¶³Ò @@À5 pL¯yó澫D3fÌ ¥K—»DAK>ÜÃ2A‰‡¸rå /^ÜôÁQ¯;tèà!0M°M€w‚( 5 ÃqØ¿€€€Ø"L*TЧGŽ)ƒÏé  .C€ ¯"Šw÷ÆoÐæÍ›©bÅŠ.3/ L.e Í;9ìÙ³ˆ4¦ž={Ò©S§ŒEAÀ# }¯¾zõŠÆï‘0iÈ 4Uöõõ5å‘plÉQbË÷;wFT çAÀãÀ¥ŒÇÝrLØH N:Ô¿]ôäÉéÏýº#€'¨U«ñ¢”J“'O¦çÏŸ«,Ž    †€Qáž)S&*T¨P˜:(p }ûö¥š5kÒ›o¾)݃±‹0ã+C† Ô¸qcjÕª•kL£X$—2±]9'/^··7íÝ»WÝÊ°{$’Ády!Éóð6ð!C†è‰7Ž4h ó@@@@@xôè(P€xg§¦M›Ò¨Q£Ôi·=²"*Q¢Dn;?L @@@ J¤K(Ü£Ä •Ý•À… ¨D‰ôàÁ=Ev7ãé+µ»wï¦*Uª,þõÛ€€€€ho½õ£³gÏšÊ<-³ÿ~(Û=í¦c¾    ‘&ð×_ÑñãÇ#]A@@ÜŸ@÷Ÿ"f‘#P¿~}êÕ«ýöÛoòÞÛ¨Q#$qâÄ‘kÄMk5¬Qƒævÿ-Ánzûb4­à}û¨¢_3ÝF‡Æè÷Ôy    ÀòV«F®\•0J-J{-t{0^µëЉ?þpûyb‚   Q#€ ©Qã…ÚnN€ýU³k•š0a‚©n»v툫"€'hþÑG”"yr=õñsæh€€€¬ Ò’&IBï/¦ó@@@@ÀÓ@áîiwó&Mš˜\É©´wï^êÑ£‡ÊâE ³_SÓ|ýf›òÈ€€€x&àýûéÑ“'zòðß®Q@ðPP¸{èÇ´#&Dl‡eîÉ ®4üýýiùòå_Œ àfŠäÏO•Ê”ѳZºaýyë–ÎCðLÁÁ¦‰ûúÀ» 2   G w»å˜pT,XXÉnLmÚ´¡Ë—/‹ ƒ€G0O}õêM˜7Ï#æI‚€€Ø&` ˜š5cFÊŸ+—íÊ8   @ w¸É˜bÌ´lÙ’:v쨹{÷.5mÚ”Ø_%xºï¿OÓ¥ÓSž(v€àÿ@〠 GàžˆstðÄ =ïš•+i€€€x*(Ü=õÎcÞQ"0bÄ*T¨¾fÇŽÔ·o_‡ž@ a„ÔQVéúÍ[´lãF•Å@@@ÀìÝD!!!zÖÕ}*h€€€x*(Ü=õÎcÞQ",Y2éÏ=iÒ¤úºQ£FÑÚµkuxÑo„~u xª'ÜuÌ@@¬Üê¿=^¼xT¹lh¼ëW @@@ÜŸ@¨ÖÄý犂@ŒxyyÑèÑ£ulÍÓ¢E º~ýº.ƒîN [¦LôñûÕô47ïÚE§ÏŸ×y   žC`ÓÎ]z²e‹£´©Së<ðTP¸{êǼ£E }ûöÔºuk}í;w¤?w ‰žB ‹ŸŸiªþ³g›òÈ€€€¸?ãgÎЕ?ÿÔõõñÑ2ðdP¸{òÝÇÜ£E`̘1”?~}í¶mÛ諯¾Òy à+GùsåÒÓœ¾x =ýûo‡   àþÖ™&éëãmÊ#   žJ wO½ó˜w´ ¤H‘BúsOœ8±ncøðá´Á#5îM€}´vijåþðñc X¾Â½'Ù€€˜o×ùÉ“Sé¢Eu€€€x2(Ü=ùîcîÑ&P¼xq;v¬¾þõë×Ô¬Y3ºyó¦.ƒîL U½z”4I=EÿÙZ†   àÞž?NÁû÷ëI~à]ž&L¨ó@@@@À“ @áîÉwsöçÞ°aCÝ+ÛYéÎÊw$pw©S¥"¿:uô4Ÿ,çóüÅ š´`õïÔÉm應Ä>«7n˜Ü•ò*JyrdýD±Ç?oÝ¢ }ûäUißLMï Æ*mؾƒî>¸/³ÄwFæ Ô)§=†7§4 +n‹Åõ#§N뾪W¨ e    DP¸ã]v Ð¥K ¤eË–ÉÖ®_¿N-[¶¤Õ«WS¼xñìКç$ШfMê9ä'º{ÿ_eâïsçQ¿è7°Ê9ï˜ój°ÿ8ú}î\=P~Í9BçU8pü5éÑS¯¤——Iáþ寿ÒþcÇ乿ÿNµœ@á~óÎâÅ No¥NM¹²e“²úÞ|TA<“ÀÚmÛL÷õñ6å‘O'ˆ§¿0»˜:u*å[jUZ+Ük 4Heq·$X¸SjÿÉ'zn—®]£Õp©¤y@ˆ¿ÿù‡æ¬\iºhéúõzAÇt™˜¹t•®ß@¾¾5:FmábÏ"¼]O˜Ø+•)£ó@@@@ˆ pÇ»ìD Mš44WXe&Hºqä‡~ ;vØ©4ÎI S“Ʀžêœ÷ÉFµXìzøø±i¨ìª(`ù S™«eÖ¨NŸ6m*_9³fq‰áó8Õ˜yüH   lÚµK‰TþÝôfÊ”:@@@@.eð»(W® 6Œzöü×­ÀË—/©I“&ÒŸ{Ú´iíÚg!;{vú°REZ½åß`Áë‚‚è•+ÄåH “,ÔÕ?n¹FϘ!óS-¤ÏZ¶Ðç\Mø¢cGW2y(@þßçrãÆ€AKàðÉSÄ1TòõöQ"Ž    ÿ€…;Þ `gÝ»w§šÂç°JW„â±uëÖ*‹#¸%.~Íô¼BBBhÜœ9:"Càüå+´e÷nY5Ø1ôsß>”þ¿…JVð8~<2͘êÜ{ð€ÖoßNìo˜ƒüE5½~ýšNœ=K …‹°#§N/¢::]1@–mØ@«6o¡SçÎEºOæ·Q쨚³b%­Ü¼™˜?6ÒóçÏéЉ“´`ÍÚwô(ýóìY´º½xõªlcûþýÄ÷.¢ôøÉ j¹ßEëÖÑîC‡ééßGt΃Ä€Àºà ÓÕ¾>P¸›€    ‚@¨ï à° ’:}út*^¼8]þ¬9­X±‚†J_|ñ…]ú@# àljT¬@9³f%öáÎiê¢ÅôcÄ>Þ‘@ 2¦-^¬«}òᇔ$qbâ£@€,gë÷w‹ÑuŒ+§ëtê$‹ZÔý˜F|õÕÁ¬ƒ÷í7V£Y²Ð°/úÉvM'D†ý™«À¦ç6n ­{öÒç"+uUâ1ñnŽ‰¢<­4Ùdl[M­RÙté á6ç«ß~£) …Q4g͘‘ú¶oOš6±úÿ4wå*úuÊ=vcÃü?Ù½UKêaXô}OÄ\Øsøˆ±Í¿ùÅiô€Ô­Es©ðWL9ìÞÅ‹L×pæÌÅ‹ôé·)H(½‹ìÓ¹tÑ¢4^¸U+V¨`˜ërW©ª?+<@[öì¡î‚é…+WuÝD RÏ6mhàgÝä{AŸÂÛ·E°æ!´|ã&b¿ÿÆÄ®-Ú4h@ƒ{õ¤¤I’OA°£ÿvþ+éeýsÙ]¡ pY°pwÙ[‡;3téÒÑaá?~|=ÌB‰±wï^‡îD€lýšê)ýuïÍ[µZç!€@xØÛ¨p÷«S[VoZ»–¾Œƒ©FÆrúÖ_w©J‹–a”íÜ[7îÞƒúüü³nךÀ;4Ú~ù¥IÙÎõ¸ÿ%ë©”PÎ=}ÚÚ¥Q.»zãùÿî¿NžFÙÎ]»y“z LÍzõc±>J,îúõêeUÙÎ×òX¯!?Q_±àkï4M,ªÿècÚ,|9•íÜßÏ݇S™† é7±^Z¾i5èö™IÙÎõÙwÿÐ èëßF˜.g+ø÷>i$?_,•í\ñÁ£G4rÚ4±ói¤Þ/¦Æ‘—î8p@×aëvã³®>@@@<œîþÀôG B… 4DXà©ÄŒ7¦‘Ø&¯®Á\‰@[aUÊV©*ùÏþ×2Yåq[6W(¬xæÄVÙåß}WÊ|Ìž9³”ï?|HT5¢Ä1X^]|¯2™.oÛJk&O¢ß__úÛ”©Â:z£Î[ Ã'M¦dI“Ò¨o¾¡Ã+–ÓɵkhìÀo)UŠ²*+}[ÑŸØ}RLSga!¾÷ÈQÙ [³Ïö ]ܲ™6Ïš)-ÓÕÿÏ}脉º»k7nRÏÁ¡ß1õ|? …cÆÐÕ mt:pÜa¢a#¦N“Šh¾x¸Øiµü÷ñÔº~}ÝVå²ee—׶°¾×• Âɳ稣XDV ï¼½i‰ÿÿä¸WMœ@õ}}emþÞëóóPb1¶R‹>}©`ž<Ä×]ؼ‰&D¥„u¼J¬<繪Ļxá„[Þo™5‹nîÚ)-ðÙ^¥M;wŠ`»ËUG;`·_Æ…O_o;´Š&@@@@Àý@áî~÷3r"}úô¡÷ Jž .P»víœh„ Ø@:áo»‘!~»­ˆŽßmû-¹ c°Ô&µj»æâÄGΫÄÊÖȤº¼O+'üNl}™-S&©|_4v ±»•¾5ʦœûÝ"Þ¨µèÛoÓÛB!Ü¥Y3Ú&‘XÏéà‰ÒÚ]µã6á¶fÕ–-òÒäÉ’ÑŽùó¨ùÇK×7•Ê”¡ß¾ú’º6o®›f+•Öˆ…•ØUNÀ¯¿Rýê¾”E(íóçÊE_wéLU«*«°ÅùöýÿZ¥ú”*%”êU¨p¾|êrɈËø•+[6]nKø|ÐÚª½AõêRYÎ <Ž+U¢cFS'0\¥nµ̫W¯TÖtäû³SÌ›¯ãÅ–vÂåÍ:±PÂ<8ñ¢Æ±3èk6 …ŸJ½„Ë™ŠeJK_ÿ¬|øÙgÔª~=éî‡]þ¬ß¾CUÅ@ÀŒîd¸¹jåÊÙ¡U4   îG w÷»§˜‘`7Âÿp&¡PPiÑ¢E4b„y‹¼:‡#¸:.ÍüLSð˜mÊ#–îÞ¿/ƒ„ªråN&4_G‰ÄVËl]QÔ³g7üy<´o_½ ãÈ©Ó2À§µ¶Ö¨a²²VuÞ)XP(„ª,M^¸@ËÑÆÍ ýÿèÓ®­¶æ7¶õÕ§ˆ­×y!_ÎÚÍ÷»%¥?[ñNÆÏ9·ñèq¨ÿùû›¶Ìü7îØ)¯g¦ÃûA $0µÇ Cz÷Ò‹Àuÿ1ëAo{¶i­ë©FÒ¼ù&¬Uº`¸çÙ3‡~ŸŽž1C¸¢¹¢ªÉãTá.èΞÝò5w$¾kMpàD*ñBddèT}A@@@À“@áîIws2dJwVL¨ô¥ð |ðàA•Å܆À{"X°1H"[ä²+$°E `ù 鯛Ï{( -ÊuùýT0o]ÄyÃK¬2ZoëfJŸžØ}ŠJg.]R¢éX«reSÞ˜iZû_ÿò\væ¢õëõÓO?¯O—+QBËFá­4ihÑر´øÿ“¯É“ËÓ…òå•ülÅ_ wnYv]ø{g—ãfϦÚ;»ê±w:yîœn²ü»%¤Uº.0¬4¯!Üú¨d¼N•ññ±ƒÀZÊ,î•JFëø†Õk¨bé'>ÿ¾Â§û'ÔØpZ¼.8~€€ý p°bãÿquñÙƒ    `€Ù$Éz”‚Ä@ÕªUéûï¿'œÊé™:Õ¨Q#: O¥L™2†­ãrp.]…ëŽßüû^gÏSÅ®ŽžÂõX#0eÑB]üèÉúøÓÎ:¯„'OÿV¢ ®Ê¾º‹˜ú¤r ·&᥼9rèÓgm(ÜsfµÝ†ñú‹"()+ƒ•¯tÝp$£Â>Îœ‘¼*´+—§/YB ×®nWÎhë÷Ðö—Œ 7# k=ϯ3ÖM‘ìßcËÊ­e9»Ía«úoFŒ”¾¤Ù]»¯â—º®‚p›Ã.uØ·<€€}¬Ù¶ÍÔ/ö!€€€X'jrký½-Ï_ºv]åÉž]ËF!¼6Œ×sÀÏD‰/´ÌVñF ðˆEËF¶îÙC›wí’¯Ä)N¼‹„•îœjV®DWƒ¶Ññ5«¥Û™!½{Sùwßµ¹ @^Í?¬ÔWéÜå+J´z%KRÊ)t€€€€€™îfÈ€C dʤ™3gš¶Ê÷éÓ‡Ž=êÐ~Ñ8Ä6Î~MM]"xª 2‚+Žg¯X¡YüÚ¿?]ÚºÅækPÏºî² lúêf ø}6>Sù¼;%–¥ìFe‡!Èä!C(KÆŒa.瀴öNF…ûN1Ë ¥ª?î{í¶ •%ãuº0Š»¨úAø³ç×b±úå;Øz¾¨ðߧ};:¼|©Å>¿ïè±(ö‚ê –?N·ïÞÕž>pפa@+ p·E àHÕ«W§o¾ùFwñP °?÷'Âw1¸ ·…5kÕråôtX™xõÆ ‡K×oÐu&LHŸ| Ó&µjéÅJvÅÂÁVm¥~¿ £gÏŸ‡9=pÔhzòô©,gëvúi-­Ú²…ŒîTöù>nv¨›’¬NEëØì£:ú:n×è:G:a¢©–°dgËx^8xüßw+›­¹k9zú4:yR_k)ÄúøðñcËÓ6ó9³f¥jåÿýßfÅŸ¡Cµâ[]ÄÖ°ý‡'VsâÀ·%½Š¨ÓÑ>²"]T}7z ñ½Ü$¬þ-Sº´ié­Ô©uq–Œ¡ïº€@”¬ u'ÃV7DŽRC¨    B ô×–‡LÓg ðí·ß’·!˜Û©S§¨K—.Î04ŒìF ‹ŸŸn‹s¿ JH  LY,õÊ)Í›oªSVì*¤j¹÷ô9c°U]øŸ°e÷nªÜ¬9±%<»]Y¿};µèÓ—FϘ¡«öëÐ!Ü`§µ;v¢Aÿó'¶ì<}þTÍ>ñÇ̘IKׯ§“gÏ©*6£…;öáÌiIàzªÙ¾ƒf½zËVjøÙg4iþ}ýX1è–Õü'|à]^5ï݇~þýwÚ}è°œ;[Ü·neÔâ/Ät‚î x0ãdZ± U¬`A¦©ƒ€€€@Äþýµq=Ô°#VTÌÁÜŠ/NwÿÛ¢;C(‚|Dð·B „î@à£jU…›‹ týæ-9VÀ}Ûµ+±53’gàà¨F×.~ujG äݸã_—0GN¦ýÇŽ Ëi/Óµrç¦$‰ÑîÇ©^—®¦s*Ó¸VMjÓ 4΀*WÇO>ü¬YCߎ%_ª\S§JE3‡ ³Ë{yÒàÁT·s:yîœ\hÕï ÕéøÛW_R‰Â…uÙ—:Q§d~Çô~«ÖúœrdÉ¢ý¼œ6ÖlÛF'×®‘§+”*%•ø¼[€ýœw4H–mÊê§]µe<òù ?þHÝ~øA^Ë {klùý§Þ½È[ø{¶Wùõ×´çÈQ¹rçÞ=úê×߬6Jø—ž5|˜Õs(ˆ<þ|àÀÌ*UϪ— @@@@À6<-Ùfƒ3 àPÙ…;ƒé јzôèA'Ãq`¬ œ/,ujÒDóæ;´8жol]‚Û˜¾d ±e6§É“SªU#5çÂ%WbCRkÁSSŠöÖ årsáîÅÒªš-ÿ»‰fÿö[¸Êò–uëÒ‚1£‰ÖÆÄ®[J-J;æÍ¥ŠeJOE[Ο+í[²˜º4k&YX6T$~ œ:Už7žëиùv¥.T,Ó;ߦM3gÐÁeK)]š4–§e>k¦Œ’ƒeàX1ÅH¥ÖbÁâð—ή£”µ»º¹¿'”÷ˆ] ½Ú¶UÅv9ò=Ü,æÖ½U+âÍ–‰wð‚JÐœÙvUô[öƒ<x vÝÄ s*ù …;€€€€@ø≼ÿþâ ¿΂8ˆ@(p¨ð«’—°Öܳg%µ¢HPubëèïïO]…E2»=˜?zTlu‹~܈ÀŸ·nQŽJ•éÕ«WrVì>ck@€ÍSq«6o¡:Ââ›[¼ï]¼HÊ÷<–îìJ…] plkþιréú ¤Å<Ë+„›’ZU*ËEöƒ~îòez3eJ*[¬±å´£?’q_l½ÏýÈ‹Øu­1ó88ø,׿xí*eL—Nbå£JìŸ-àŸþýX,𠳈 Úà€ˆ)’%‹Ðµj×x|!”q'„+š3—.Rnáê† ’$Nl¬â™ýñŸ¹x‰.]¿F/D€Ôl™2Éùó$ûø\ìf;s–nìò¶­òMx¸àU»øãÚ¼y3U®\ÙÃi`ú   ‚ÀSñû-9\Êà½qLàGñC†ÒYÉÎé˜p‘йsgš&,4‘@ÀÕ °ßíú¾¾Ò=Ï%hï>:~æŒTȹúÜ0~ç'ÀÖÐ5„øè&Vt³£+—趙ë¸?ö9¿ã¬Ø.Sìù²Ö+î#bÀm°b?º‰]Çp`T~ÅfJ.Š.$_±Ù/úO"` ˜Ê‹i¼°…    >¸” Ÿ΂€Ã °¢bÞ¼y”Z¡R‰]ÍÌž=[eq—&Ð¥YhðTžˆÞÛ.}C1x Àˆ9³JÕ+ÀŒb#€€€„G ÷ðèàÄ\‡ï”)SL½uîÎK`$pu•Ê”¡ByCƒ0Î\¶Œ?yâêÓÂøA@@À­ ¬ÙºÍ4?øo7á@@@@l€ÂÝ&œØ%P¯^=êÙ³§îô±ð»Û¨Q#z&üó"€«0Z¹³²•îH   ÎK 08XŽwdú”,©ó@@@@l€ÂÝ6œX'ðóÏ?ӻﾫû=tè}öÙg:\•@‹ºu‰ý-«4nö%â1&P©Li:²r…|Í9"Zíñuª n @<™ÀëׯióîÝA¥Ò¥)YÒ¤:@@@@À6(Üm³Áˆu‰%¢ùóçSªT©tß'N¤… ê<pE¸±ùGé¡ûã@U@H‘<9y( _ysäˆVK|jƒÛCO&°çȺ{ÿ¾Fw2ˆî"Bˆ]y…¯ë &˜:mß¾=?ÞT† ¸Î~MMCöŸ`Ê#   àŒîdxD˜ê÷£p P¸»Æ}Â(=Œ@ãÆ©k×®zÖ< .{þü¹.ƒ®Fà‚ÉÛàÿuѺ@ºy玫Mã·'¼]Ï1}Ú´r.€    .(ÜÃŃ“ w†Nï¼óŽÀ¾}û¨W¯^:\‘@??=ì—/_ÒÄyóu€€€@ÜààæìRF¥+P¼xñTG@á œ¸"$IéÏ=¹Á—ðÿþ÷?Z¶lY\ ý‚@Œ 4¨îKl)§Ò„yóèÕ«W*‹#€€€@Ø°cñ¢¸Jðß®Hà   ‘#…{ä8¡Ä ·ß~›Ægê»M›6tùòeS2 à*80pûFŸèá^½qƒVlÚ¤ó@@@â–€Ñ ¤Z¹rq; ô   .F w»a®çhÑ¢uèÐAOüÞ½{Ô¤I“å‘> \€@'ñþ}ãЯÿ€Ù.0j @@<ƒ[¸«T¼P!Ê”>½Êâ     ¡HTF¸!0räH*\¸°î|çÎÔ¯_?‡®D G–,T«re=dþaæâE‡   7Ή]”g/]ÒÃŒF@@@"M ÷H£BEˆ;É’%“þÜ“&MªÁJøÕ«Wë<p%]›73 wÜì9¦<2   ±O 08ØÔ©¯·) €€€€@Ä p˜j€€S(R¤;V%$$„ZµjE×®]Óe@ÀU|àíMysäÐöx1ýýÏ?:@@@ ö ý·'Iœ˜Ê¿ûnì=‚€€€€‹€ÂÝÅo †ïYÚ¶m+•ìjÖwîÜ¡¦M›Ò«W¯TŽ àâÅ‹Gýšê±Þøæ¬\©ó@@@b—?OnÙ½[wZ¹lYb¥;€€€€@Ô@á5^¨ qN€­Ü ( ÇD_ýµÎCW!к~}Jœ(‘.ÜÊh@@@ Ö ìS¦L¡œ9sê­[·Ž¬ó@À™ äï]_=ÄÕ[·Ò¥k×t€€€€co75ìëú}l: €€€€@¤@á)L¨ÎO Mš44wî\J˜0¡ì÷ßOÛE,$p]š…OeîãçÌu…acŒ   àÒƒCý·'Kš”Þ+^Ì¥çƒÁƒ€€€@\€Â=®ïú;xï½÷è—_~Ñ-¾|ù’š WwïÞÕe@ÀY Ôª\™²gά‡7eáBzþü¹ÎC°/~Vܺw¯n´ªx–L”(‘ÎCˆ:(ܣΠW€€SèÞ½;ÕªUKñŠ@ÙªU+‡ÎJ ~üøÔ©I=¼Ûb¡hÁÚµ:@@@À¾‚÷ï§ÇOžèF«W€; €€€D“îчË@ÀY Ä‹¦OŸNÙ²eÓC\¹r¥Éò]Ÿ€NF }£OLn‘üf;Ù1pFw2<+c<÷™%f   ±K ÷ØåÞ@ V¼õÖ[4gÎb‹a•¾ùæÚ³gÊâNI ƒxï6¬^]mçÁƒtøä)‡   `?Æ€©ìÖ-®\ök-€€€€‡€ÂÝCo<¦íþ|||hÈ!z¢/^¼ ÆÓýû÷·iô@IDATupFÆà©<>ÿÙÎ8LŒ @@\šÀ]ñLxðÄ =‡+h€€€€@ô @á}v¸œž@ß¾}É××WóâÅ‹Ô¶m[‡ÎHÀ»dIò*P@-`ù zøø±ÎCˆ9¶n Ñ ÁŒF@@@bD ÷áÃÅ àÜØŸûÌ™3)³Ø"¬Ò’%KhäÈ‘*‹#8%®Íšéq=ýûoš¾x‰ÎCˆ9uÁAº~f¬R¶¬ÎCˆ>(Ü£ÏW‚€KÈ!Ðo„þ»ñÅtàÀ—?陚}T‡R&O®'?n‚§j@@@À6îØ©[)[¬¥MZç!€€€€DŸ@¨.úmàJ''P¥Júþûïõ(Ÿ?N5¢‡ê2 àLRe{ËzuõN;O›wíÒy   Ñ'pü̺zã†nîd4     cP¸Ç!× ðÕW_+ÞU:wîuìØQeq§#ÐÙÏÏ4&ÿX¹›€   Ñ$lºÒ×ÇÛ”G@@@@ ú p>;\ .E€]Ê°kv1£Ò¼yóÈßß_eq§"P8_>ªT¦ŒÓÒ èúÍ›:@@@ z8`ªJì­Ì;ï¨,Ž    1$…{ ârp%<•ƒ¨r`,•z÷îMGŽQYAÀ©tijåþêÕ+š8¾SƒW#À®·íÝ«‡]­|9J ÎCˆ(ÜcÆWƒ€Ëðõõ¥o¾ùFûŸþ‘þÜŸ}Í´¡?SŽ,Yt€€€@Äî=xH ºuÓ?ªVz´n¥ó¢F q÷tûî]zýúßgœ¨]Ú   îJ ww½³˜D‚@­Zµ¨_¿~4tèPYûéÓ§ÒŸû^H+iÒ¤‘hU@ ê²dÈ@•Ë–Ò…ßvëJ´n£¯Ùw쵬WOç!€€€DL`Ö²e¦JmÔòw²©Ï$IœØà `ú   Ö hª5*("ðã?RYƒòóøñãÒŸ»!ÀT]€@5±ó¢@îÜz¤3–,¥'b @@@ òÖëÊìb0ª àúb    6 @án N€€gH˜0!Í›7R§N­'Ì®ft8Î~Mõ0>~LËWè<ˆ lܹSW*W¢8½™2¥ÎC°(Üí퀀KÈ™3'M:Õ4‡O?ý”n"0¥‰ 2qK •p!“4I=ˆqsfk€€€@øŸ|8eÍšUÏãÀñãÔ맟uÄÄÂõQ»† u÷—D¬Õ[·ê<3cÀÔ·óä¡œ†gh0­³Phç÷õˆÔ¿cGêÖ¢¹ig†±NlʇNœ¤W¯_É.‹(@‰„›&wH«¶l¡Þÿ¹>K™Í=Š’ ¿î*œ6VmÞ¢²8‚@¬xã7èÓ¦Mt¿wïߧy«Vë<p4¿Þ½èÊŸÊnØ¢ú÷¤›»vÒóÇiçüùôcä%,ÈUì?Ž¯ TYŒ@ÃÕÅgJSùÊ™5‹“Î>Ãñ„9Ú‡”û´ÂAïïÜ»§'ÿíp¸”qZ4 îE€-ÜÇü–Ú î*µúâ :´|eË”Iá±J mƒôíÈQôüÅ Ù¯¿puÔª~½X:óL?¦íûèÉÏö }üþû:_¶x1⻑)Ó !¹xQž›¶x1Õ¯î«ëAp_·?îž}þ¼Œ³ñ—øLÎðÖ[”7{²gá¿ÿù‡ž8!­dË•(AéÅÿ]TÒƒGhÏ‘#Ä1@J-jr¥Ú¹s÷.m?p@—};wn«uT]g9^¾~]ø|?.v%–¾Ý£Ê…¹²‹6Þ%Qõ½r”5“9PùùËWÄ}½B·þºK)S$§ì™2SÑ· ïî‰l:wù²üLL‘,™4])²—Éz—®]מ Y2SqáZ.2ßóŸ<‘kÿ¼}[Ž3[ÆLrÌÉ’&Rߨl?Fÿío¥I#ï¥ýZGK    Ö@án Ê@lûí·´ëÐaâ@œ¶ïßO_ÿ6‚~îÛÇæ58Ž$Ð¥™ŸV¸s?ÿ›@“âÈ.Ñ6ЫW¡ÊvƱdýzêìçg•L‹ºSÖŒ¡ÊÔçÏŸÓ~±0äÝ8Ô%Òë)_Îœa®!vod*ïM÷<ç6LŸFUË•“ò´E‹iؤItòܹ0×±bü‡îŸSµòåå¹µÛ¶QÍöÂÔË÷ŸU~ÚÔ©éΞݦó¬Èoÿõ7â3ÿ˜ï¿AV¹Bþ\¹¨{«–Ô¥Y3S}Îä®R•XQËéþý4fÆL2~<±rY%Ž½°zâ*˜7/>yŠš÷éCÇÏœQ§å‘w ø72ÿ¸ÔtÒAöko šZ¥²ÕžnÞ¹C]¾ûŽ–®7Ï‘% û¢}òᇦrι<;~ŒÖˆûÑyàwÒ¿?Ÿg·m kÔ`‘æ®\E¿N™¢Ç" ÿû“3kVɾGëÖÆbš¾x µéß_–}ùi'¤·“ø¾æ¶8ñ.5V¸G4Gö÷ýÓøßiÔôét[,‚¨”\(ì9Ðæï?üfa€ëÜ öžC†Ðò›L÷šÏñ¢/ØîÕÓ䚎Ï!9–À“§O‰UòõöŽÒ‚ºG¨ˆ¼‰LÔÚEm7%À¶æI‰%Ò3üeâD2ZPé@ ¼W¼¸ÉboÎÊ•Z9 Ý£ %P¼PA“Å//<Ÿ4Ùjà^VĶnP_¿‰ÏOVˆ–Ü*Í^±B‰¦ãÆ;õû™ÝwU.[Vžÿnôjûå—V•í\a§P²ÕìÐ1Ú±6¬YC¥„šUÊvn›Ýãtûþê"Æ/_¾ä"«‰Ý=±e¿QÙÎ/^½J å?+¬+7oFÙÎu–mØ@í¾úšE§J„wµ–­Â(ÛylñÞ¸{êóóÏáŽymP5èö™V¶+³¢Û¯W/«Êv®Ç‹½†üD}‡5^f’_¿¡Ú:ie»éd8^ÔáE™oFŒ0)ÛùVܮ޲•Ê4lHûŽ5µÂ÷ó½OÉ–÷š+òŽûR§Ó§Vÿ?L!cW›wï&^´S îd A@@@À± pw,_´nIà‚iô€¦¹µèÓתòÀT p®Í›é–ÿyöŒØO68’@a±Þº v—Òï—_(}Ù÷¨¶ðΊÓcü¡Ï[Ú%¼Jsþ³DVyuœ·:4pó?’Ö©Oÿþ›†N˜ ªÐ/ýúÑY¡ ¾¼m+-ç/\x¼-ϱ¢­óÀÄVË%½¼hùïãå˸`:aвlöo¿êöØ Isñ™ÎJVv_Ò¿SGÚ¿t ß´‘¦ e²r2~Ρœý×UŽ¾Ø Œž1ƒª¼÷mŸ7—®m£yb±–­9±â¸A·nrÑbÖ¯Ãéâ–Ít`éRjY¯®n­ò#b¨+Ç’À»»Nœ=KÕ+T µS&Kæk&O2ùïÿmÊTaé½Ñæˆúý2L.bdɘšÔ®%w °»˜k7nRÏÁ¡»sêù~@ ÇŒ‘ìN®“Ax•[—S§IE¶µN–Š÷BÐÞ}/^<ªPºñçcÝÞ·VÕTÖwè/´N,p*’?¿|/]Úº…‚çÎ!¿:udùŸ·nQ•-‰]©4eá"¹ØÀy~Ÿm™5KÞ»x ü¬›ªF›ÄâQÀòå:Áñ,!ÞÿoÇ‹ã{F    àÙàRƳï?fÑ&Сq#bËËùÿ)ƒxëy³Þ}ˆÝDÅ¿l´€ AÀ@ iíÚªt¨V@Ÿ3—Øå+œ@ÀQƈ…ǧÿcri¤,Ù˜SÆt鈕\š4&ŸR¥LCaßîlϾàÙ} ûI/Q¸°®Ã®gŒnK¸>'¶^&ÎqÊ/Ü»ôißNÊü‡­àódÏ.­°_‰vŸ W.‡Nž”íÖ®REÖSJ[ΰïpKïü¿¤¬b§üô“I Îî`*ˆyxÕª%­•ÿ@ý:´'vIc™ —1ë„R:A‚7ÙÕÊê­[¥ûUwâ AÄŠeN¼€úk· ¿åɲ3/‘WRv–?¬¼^0z´ÞáÀÌ?®:Ø¥ËÌ¥ÿÆ“øvÔ(ªSµªÕÏ ¾×{bòÁÄ®ZTš4¾%‹€_•>íUá×]:ÓÇå{‚ß3´·få°~Ù¹}^Øà1¾ï]^]î‘ß{S-’u æÍC¬,O’8±ÌgÏœ™Ê¿û.¥HžŒ&Ì'bF‹õÁŸ[Q«Ô«Mª(\Ïpâ…VÀ_‹++6m–eë·ï UŸHOÀ0•Q,ã8~è@@@<“,Ü=ó¾cÖ `lÉŠ•¶ˆÝìæ b›äk]?ÔZ˜]^lر#¶‡þ<Œ@„ iÆ°_hׂÔª~=m½mÄÀþ¾Ùª·¢_3úøÓÎ&÷*쟼FÅ º:»C2¦uÁÁôðñcYTú¢Òç9gXª¿× LÆ®¬ ¾¹k§ôÉÎ~ÙJ|u­#»aw.œ¸£Å¹º†ô7–Y^``¥»µÔ­Es­lWçYY¯[Úü~5••G^$+UÔK—]½qCËÎ" êÙS+ÛÕ˜x¡yhß¾”H¼'89u:ŒëU—-Û§þü“IÙÎç¼ß-)­æÙr>pê­ðV×ññÑã':{ÿÑC-[ ßþy¤•í|-ïFàœ~ìÑÃj߃żÕ"&ÇÊà©œ²gÎ$ü‡Û¹påŠÎ³À‹(ü>ä×Ü‘#LçqÆ«âíp/p'ã8Öh@@@, @ánIyHH•"… ôÆJ'•G›wíRYA Ö|Ú44%wê0;ÖúFGžM L±w¤Rñ¯½{h÷Â4¤w/éJEYv+:+6m¢&=zª¬)¢O¥ Ð_"    € )€p14„Ù3d I}ûPÇaÃårÙXÄÒ2n[·P¼Ø±C¬ÑN89:R‰üùhÿ‰“rFlÜd?½7°LÓ¦Øxœ+sfùê#‚Vr°ÈíJÃãa8åÄŸËc®®J^¦’y‰3¦4J²7÷1×sRw›clm9ñ¦f!á¢%ö2Þ.4ÜÛ¶£óW®Èb–õbƒ=¿8ñ˜-kդ͛›”{‘LüwEgpgYMÇDSUôNè×›J‘"D4U¬ÊL¹2thûõÑo¨…è2)ÔÕm3wSZ'6N/Ù´‰ÖïÚM¼ù¡y‘kõ–¼ó80¯¥‰n_»sG5¯Ñ±£Ê{—y÷Áã¹W+Sš&ôé-õüùsË›=gÜ/Ê÷çÏ+Ÿl`I–ÞA zývÞ„)œ+WàÜw Üñ!ð7ö H=÷Í{=dž¿zED•ÅkÇÏý} h'd;4ƒ;}æ®Y#å,èŠ& `1ÖVŸ!Cj©r‰”*Y2íR½³ŽvýÊ•)¶l”²DIUî"‚jzîl­/R²§•Û¶Iƒ;º5ck¡ÓÍt}bOc×M…Þù ó€ÔÑfín-±ávÌœ¹Ä4¯^M1£Gת¼}ÿóÇÓ£œ7M5fï:%Ò8H„ ­Püúý[åõs›€Ÿ>•ÒCü®%6Î;9¦ ´bC‘5ø9H-{¼{—Ìo®Üÿüù£ª³¦Kgòäj`"Ó­Y3XuÅÖm´÷øqgàÓ’3<þ‘³géHÓ³4sèá}_×Ä(²&þùw@wÚíæ6¸¬y_Œ    àAw|@¬B€ë]¸züwÄœÿà9s hßÎ*ãc°„@åʼne*4oâùk×Ñ öí¥‡°%ýÑ,!ÀFò o.rbÃjïV­ÌvM!b]pÀBÍ{üµ‘ÄËÊh÷õ»wÓôAiÍ©yÐÆU«š»láÂB¾°¬/<ÍŸ9#4ã· é]²ìú»b® T€K³ýW‘&ErÕ„½‘—M¯®‘!ºk¤OnÌäÁOc¹>Ɖ¾]¨L{ð·04c;C;|8%ßÏôÉ”¾žó–´Ñ÷áö¼atõömY¼nú4Ò{êëÛz—gIîÍ›ÉÙ/ß¼I»#°úìåKÙµÓðÄòHw)àœ½x‰Þ}ø nýv…¦ã”[ã& Á‰@ŒhÑhõäÉò†LŸ.¥‚Ó:±û&:thjUÇ#˜#Ï”VnܳǾ'ÙIy³fQóÞyø°öºªÐe´à§\”+S&] Q–tiU`SöLg¯t–¢áÄžíå‹1hï"î7lÆ ù:pÒCB‰ð÷á*%KÊØ=Z4W}N^pSyŸ2N)R¨&g.^4«ÏÆÙ"X,¿N»¹«>Á=Ã2U®—.™\&Kí×=T^O=˜ì( Ù#ùÄ… ªzÁ¨Q^Œí\ùöý{ÕÆšö¢×Ò)7óŸ¬=÷_¿~É ÀÚgqø¿ÿÒïÿ¼úùt[&''âÏ¡»˜Ó¼«¹ÞõÒeíVx {Ž3úí8p   N÷GŒ€@È!G Æöì¡Ì„º]»!`š"‚L`hY«–ÁÆÏLl ¬M Xž¼jÈ£g]©çرÊب*þËŒzël¨ÕëY'}ðTŽ‰ñíûwÙ¤N…ò^Nh뫃}¾×¸ñôCÈ §ÁâY|ùúU³w{þìÙŒ›˜½fc½&!ÄÆjSrl—nÜ ·k×̎៊†Uª¨î#Äé4m.ªPd8p+ËÅñs_¸~ƒü\²!}öªÕò³Èëעh}ãÄŠE±cÄÐ.ÅF$ˆŒÊðÉ-±4o~ €€€Ï¿¸€@0&Ð¥IªP´¨Z!K{4îÝÛ¤AH5B¬H€e ª–*¥Fdc(K €5 ´«_Šç˧†œ´p¥*YJhlOÆÈõ´jÛv)«•¯f-ê;a¢jW­ti¡Éíi ×*êUªHØŸÌÐ’)9™byó(ÙçÏSµöhÍŽÄAWï É“%7I­om ã@• ušë¦L¦u..´q·ÇI–™Ü¿ŸÖ•Xæ¤Ïø Ä^Ïw>¢Å6RÅV­Å}Ë6lÈ+™?¿jo/Ö“;¯rÍ[øzʬ¡^´~Ú"N"° K¨±!Z“â{µl)‚¿zê¹ûtÖØOž$‰lÆr,üLùôÂË7oäÆÇÔ%K¨XÃFð§8ê­‘œÅ÷Ì¢yòÈ¡8@ž5iƒ7ºÿø19s–N™BÝGQ·ê.4ÛµTª€çóo ‚¦™3Gžz๟^û{õ’ŸMnŸ,qb“ñ´±ðîŸ>¦ÓNÊ*hrÇÿw    æ„1Wrð öÊ[Z9ÉÓø®oKx³ŒþsË3sÉÏpŸÔÉ“K÷öC†Ê!ØðË/S©¶ð¯_¹’AHµ9ó÷g~ñý«•)-ÛÉ›†vîDC§ÏR'ãæÍ#~'6ï˜7×ny–ȯøÖ`Í›—oÝ’ͪíÚ#‘×̼iõj&ë¼+ì+N ´8P6á”’›xiî(‘ÒyŸ"´Ñ9ïµ]žßë¼tðEÁœáÃȹm;ºvçŽ|ÕìØÉdï]»ªÏ 7˜Ò¿?šál¨çøý&N2Ù/Z”(´1L²±f!ËéƒàB¿Ýšt1€€€XFî–qB+_`ÍáÕÂ¥÷î0yJˆÒùõ.4 l0LŸ*•y¹Ðf¯?$°&þ^wiû6š;b8¥Hêálj|ÖhçÀÒ;„´ \5—Œ´ =e>Œû´­W6÷3WÉë4B‹}BŸÞ´bâD‰%®Ú©“0ÂW¦ðº¹K˜ Á†¯XNÓ¤ñ2~„ðá©c£†tbÍjJ’ —úà\ nÚ»xÈ‘ÃË2ÙK}@»vbSe’ /M´¬]Kn¤Ä,Æ)sZ':°l)]ز™âˆÏ]@$ÞÈ9·y“|¶Q"Gör þóg®_Û6u¼îƒbn76 •Onð&ÄÑU+Mr3 þ&°çØqƒ1ìñŠÁq   ÁÀ?âØêÿ‚Ằ$+˜9s&µF—eËÊ |¾’u‹õR ì™ç&‚§q`?¤G€5§9¸ ÿ28Àü»|9±¶–f Díê××.ñV%À¥÷Ÿ<‘R+w…¬ °“%ND)„82-Iìi^±U+Ù”û?8|È"ƒ6Ë~<ÞõO_¼AVcC„”VxÇ[’^½}Kü’¸æ6x³ê¢Ðúò%%’ ¬Ux+‡ôÄ'.\½*ôöÝû´R*ÈxãÂ/Œ¾ÿøA¯ßŸ§Ç?NɛߵĺûìÿõÛwq"#ñÏVk'þó€?Ç4L‚*žº\ÝõzîÝG!÷k׃ê’0ï @ \¸pÔ¢VM5ÓÇÏŸÓ¶Ô52   Ô ì>æ05Qüx”>Uª ¾$Ì@@@‚,܃ì£ÃÄA hà@€ýÚ¶Q“ÿñó'ÕêÜ™>ù¢ÊkhU»6ñ) -Í\à© ¼ƒ€mï?~$×KžÁèË,´„Ùƒ€€€@'ài}â ÁôA‚!;²¼uÿ>µ48è,3 r%¢ŠÅŠ©yï;q‚øs‡  AÿLûû÷¯ZôÛ d@@@@À&`p· vÜB6ÖÎ^5i2ÅŽSX¹mÍ_‹`– 2V'Ю~=ƒ1g­\ep Šö;f0íùò\ã@@@@ p À฼q7ÿ$NŸ–ŒkÀ£óˆ‘tåÖ-ƒ2\€€µ°œQJ5ÜâéÛ÷ïêŠö?¡¦#cFŠ+–ºF@@@@ ð üó?‘ÿ¶¸#€@P п5jTP˜*æ    6!À¿/÷íÛ×&÷ÆMA@@ìŠÀ×þù'2<Üíê™`2 `_~ýúe_Âl@@@@@ÀÎ$NœØÎf„退€Ø’@[Þ÷°oÉ“'—¬T±ÍŸ;&À&ûèñ3*Qª>}øðIÝcÆô¡T³zyuLð ðåë7úöͶ2.N M›÷( «VL¥Ì™Ó©kd@@@ ¨h×~ >rZN7RÄtâøF âÖó«X¹%Ý»÷€t’uuoÜ@@@À~ à·1û}6˜Ø ðáÃSܸ±l><öâ…¨jõÖê½ûŒ¥Å ““£*C&èˆkKèÛ»Á}§Ë!ª]«’Ì SË ðID×s—T‡âÅ PæLiÕ52O b„ðÜ@@@ È€¤L{d˜0OU*—¢ÎšªÅ}ùò•jÕí@ß¿ÿPeÈ€€5äÌ™™ø¥¥µëvЛ7ï´K¼ƒ€€@ pâÄyâß—´TºTA-‹w€Á݆ðqkCcG÷¦92©ÂK—®Sç®CÕ52 `-íÚ4PCýøñ“.Z§®‘ @`Ͼ£Ó,]ªÁ5.@@@@lCwÛpÇ]AL.­Y9¢E‹ªjçÍ_MkÖnW×È€€5Ô©]‰bÆŒ®†š=wýïÿS×È€€€€½ؽ爚¢ƒC"J“ÆQ]#    `;0¸ÛŽ=î  `‚€££Í›3Ú ¦U›~tç΃2\€€Dš«M›ÔTCÜ»÷ˆví>¬®‘{&ÀRh.\QS,Sº°Ê#    `[0¸Û–?î `‚@Íå©­NòãÓ§ÏRÏýçÏŸ&Z£üF mëúgÎZnpÍÏŸ¿¢á#¦Ó•+7½Ô¡@@lE`ï¾c'³ 'c«'û‚€€€€W0¸{e‚; 0iBÊ’%š {quï9J]#þ%2e2Ò{ît9H÷ï?–Ã>|šj‹ ½) Ðà¡“éÅË×þ½úƒ€€€ÕìÙë©ß*T(*^,¿ÕÆÆ@    þ#ƒ»ÿø¡7€@>¼Ôs9’ºÃ¿3—ҦͻÕ52 à_íÚzOe ÷ÖmûQÆ,e¨Xɺ´nýNúýû·¼Å·oßý{+ô«`w-åÊ•Ù .‰VŽwÛ€ÁÝ6ÜqW pð¯9³F´lÖ¢—òB6¨Àø@…òÅ)A‚¸ª'0®^½¥®µ î ¼ƒ€ؚ˜=yò\Mr2 2    ``p·‹Ç€I€˜#P¯njÞ¬¶ªþðáÕ©ß‘~ýú¥Êßàx«×l£¢%êJvŸúÿþç&¨@! —“á–)…€©7 „±°š€€ÍL›2˜N¾ Wž9ãN}ú£‰ãûÛlN¸qÐ$ðèÑSš3oÍ_°†^úB—ýÛ7܃æǬA@ øÐÜ£FB¹sg ~‹ÄŠ@ øöí]¸pÎ;G®®®âTî}Jž<9¥J•ŠŠ/N 0»ª{÷îÑÙ³gÍÖsEŒ1(uêÔäàà@¡C‡6ÙvíÚµ²œÛeË–Íd}áß¿iýúõ²ÈÉÉIÄÐÂ÷=äA@À¯`p÷+9ô4#F µ«fPÎ<•I“ö˜~Ÿ9[9âS¾MÚçηýÐ@@¬IàÇtäè5d‰âù)LüI§€ 6"°nÝ:jÞ¼9}údø{æ‘#GäŒ DÅŠ£#FPþü^ƒ8p€Z´haÑì£FJƒ¦Î;{ùú¯S§q\¢:ÐôéÓ}ïÏŸ?T»¶ÇiâîÝ»Ãàî#14Ëà·3Ë8¡€€ ¤K—ŠfÎNM›÷T3iÒ¬'¹ÛAI’$TeÈ€€9‰' MæP¹ MèÇŸæš™,·IžÇªÕ[éü…+tïÞ#úüå 9¦p ”Žró)K–t&ç€%ðùóÚ¶}?íÛ\ê*ûþ]>—4©SP¾|Ù©h‘¼2}ûÑÛ·äØ… 梄 ã©ûxW§™Èܼy—Üܯɚ°aÃPUç2&Z¢¯_¿ ÄKôúÍ[Š!žf `ƪӃ'hÙòM²õÛ·ï…ž{':´•ï †C“H€ ŸkWÏ j5Ú{ôXšìÁÃ}Òäù4vüzõêÁ´ñðt8x9W)M£Gö"''Gƒ6¶¸xñâ•øÃÐ#¨_ìØ1Å‘ê$¶˜F€ßsë¶}Ô¤Yzÿþ£Á½Žõ<^PÇéFEŠä1hãß‹¾ýÇ‹cë—ä0۶̧ ‹«!½«SLdvì|ôblì9à~ àWzýö”)“ Z¿…~ þ$Àšël`çÄr0Û¶m3ilçú’%KJ9o4üø‘&MòýïFÿüóôŒß¾};E‹‡¥E‹Éwü  `_`p·¯çÙ€ø@ räHRÏ=|xO¯È±ãf“±Ç—à:„¨_Ï™¦Ob1[JÊð©½Áºr¥’têøFúþå:=r†V,›BM›ÔTÁ³ž?EU„Ø7üƒ@CE Q“îħ´T¼X~š?w ]¿²~|½!ßÇé+þ öôrkÖ¢7Õi/k}ñ¸./{ͳ ;¶-¤{·Rïž­w"¸ø’Ÿºxñºêïv…° Þ½{K½ôxñâÑ´iÓÔïbæ&“;wnª\¹²¬Þ´iñæ½_R’$IÄ©¹"²ëõëžßü2ú€€ HÊ WŒ  €2eJKÓ¦ ¡Ömû©»4lÜÜÏï4Ð0V•È€€ íÛ5’žÉ–œ°¥¤Ì®Ý‡Õì³eË@×ϦP¡<öËãÅ‹CuëT–¯œ92QûŽƒdÛ BãÝ]èpgÏžQõEÆzØh¾fív5`ófµiöÌh§IãH=º;R¥Š%(w>g¡·úYþaÝ¥ûp:wf›ê‹Là¸yóžºi™Ò…¨\Ù¢ê°g{÷3˜ î8pJ@Ódç›rðRÖn·$ 0@Éżyó†$H`I7/m%òˆ9òü¹‡|Ÿ—(°)ÜmŠ7ð+–-êH=wÍèõúõ[ª× 3íß»B#ý:6ú…ýûu wB{[ï©ljõ¶4¸r$ZÊ•3³ÙÏw‹æµ¥ö¶æòÔy«Ü90(ëo?ô¡BýCI'$ÖàŽɲ?0µ5x÷þàÁö29ˆÀ•Y³¦70`{×O«»xñݼuâƉMyòd•0µ:~g¯Þˆ¸s÷!%O–˜2dHãëù³~j×#Ô°åË£ysF«kã K`Ý›Úu(«x3äÉ“çÄA|ñ¼té=^¬œO”0¾ÐwMEqãÆ6njW×?~ü ãBÞëË—¯”:U J“&…ÙÏ©o'Î_{ÌìµÐZÏ—7›¯YpÿÓgÜèÑ£gT¼X>ÉýãÇÏjÑ£{ž@P…ºŒŸ ߟ=’ï?xLIE€ïÔ©“[¼ÿ®]· dƒ ½œLèС©XѼÁdeX=nnnjÒM›6UyŸ2Y²dQwŸÚzWëÖ-YÍY‘@@ì îö÷L0# Ì=Š\EÀÀ;wȇœ¦¡Ã§ÒÐÁ]-Í@€h¸~ÒÓ}ᢵfq|ûöÃl]@WüùóWÝbÛöý2¨#ZŒSØ°aiõÊéÄÁ„9¥K›J¾—)׈4¯Èzu«Ðò¥“e¹ñ¼éÀšäœ8È瑃š¤,QÓUxespP6ê+YÎfäð³+‚¬Ê[ *9ã®oFËWl–/.œ6e0uhßXÕ³{ô˜™4uúbz–*R8Í™5Ò‹qzÉÒ Ô´yO9F·®-¨•Ø€«×° ?YË<:´oDÇ÷—ǽym󬑞æZ#>!0fT/jÒ¸†Väã;?ý}zvoåcŸúõªÐñùúýû·lË› zƒ;ËDðI‹5kwÌó³®X¡8ÓGkSøx¯€l`Ì}øÐnò9lÙº—~üø©nÍ'1fLJùòe—e|J£|E¯ÆˆTNEe}¬X1èõ‹óª?gnܸK-Z÷¡S§.È#1ƒÎ›P»¶ ÚóEŠT…ˆ7m8±¬Ë®ÃÔ¶ýzöì¥,K—6%]»~GæµÿôŸÍ}{– £|~Yåßgâêz‘Úˆ{ó&Õß¿ž_ì¿Ëhöï( .é´i¼ûeíà"Øо—óóŠ (½dU°]4vJàæÍ›rf‘#G'lê,O:E‡–÷Ì!C Þ7°Œ î–qB+;$5j©çž¯`uúùÓÃØÃÁ%ÙH§MìpÚ˜’àÍ›>ц.&g§y›¬ àBöjgã'6²árôÈ^&½×YßÝ8±A\3Ò°a”=vMy¥¯]¿CumÔ ªÌß¿ÿ˜Š–¨C>Uuú 3›2u¡ôàݾur}[Sùwï>È“)¦b0°·ôN—ƒRŽeËƹ”Sp0•8@l‘âuèÅ‹×Õ¬‹:yÊŠ3º4²®\µÅ ž/^¾|MÍ[ö&'!ÿ¢‡½42*p=çñ,¸8}úÔBC5Q ¯—ü½êì)¯÷ç–¼¡Q¼T=ºndÖFa¯|~nì¥Í› ©R%תlúÎϧbåætðÐI/ó`ô²šÐ•‹»)‰ðêömZ·~'5kÑKzÌ÷½%N0tè4˜._¹)7o„1ý«,ù«×lk`¬7ËܵŸÉŒ—ˆÓ&£LjóòÓÆM»ägûÀÞ•ÒhªŸ‡5Ö®ùàC€Oçè¿Ï•)U8ø,+ H@3¸§HaýÍð÷ïß‹X#o ¨|ÿþ?~L{÷î¥ &ÈŸo,1È:òH  öGASíï™`F ¾ Àž”Ç÷S=ؘQ_xº²! ,%À°¬X6™Ìéá{v[:®5ÚõèÖÒÀÍÆóœy*SúL¥¨S—!´mû>úøñ“Ù[9W)MšlIÙCÛ8±a]óJ!<Õ¬Q^6Y¸x­2¶çñ‡ö¯¦OÏJãñàÕ0ØuÅÊÍòzÂØ~´uó<¯ñ¢EòÊ2.¯X¡„ê׳÷hð˜å]6 Ãúƒ»ÇèØáuÄÞøœx“¡XÉzIJQ¦ÒÚuìþE_9ðå%·]T£ºÇü¹={Ž³±½v­ŠrÞï§ ëf{UsâïuÁOe¡7ÿ]½z[ÕfÍ’^åýšá€¸š±=vì˜4~l_r=½UÄekM‡ŸÀsæ­ôëm¬Þoî¼UħŠôï ãgœ9¹™:vh¬N:°fýð‘Óå}sˆXüìù¥xÍ]\¶rùT5?>±Ô QWilç¯Ë>½ÛJÍû»·ŽÐ¢ã•Ëì9+hÀ ‰ªŸq¦WŸ1Ò‘(Q|ªS»’ôˆïÒ¹¹¼ŸþDƒþ³™%³‡Ç¹ž oŽuê2TÛŠÍ+ÞláùÏž9’råÊ"§Ê›x«478Ñ`­µ³Àuð  —“á•.U0x, « JàÙ³græQ¢D±ú Š-JqâÄ1xq Ô¼yóÒÀ…“ÈâS¬ÏX‘@@ì€i· û›'f f pðËOҦͻeökШíÚ¹Øj:ÂfoŽŠ`C \¸p2 ii!ÁrBèQëÓ7áUd«”"ERÚ·{9U®ÚRÉÅð\ØH˯ÿ.•²#¹re¦*•JQÛ6õ dØ€ÎÆëY³—Ë%hÆgýzØh­¥*•K }4yyðÐ)­˜ºuiN… {üQÇšâl€g]jÍ€Ï<”åh8]¿~WõM’$¡+Ø zÑâu²MZ!õÁFIž+§¤BÃ=þ%J$bÃ.oLžô,]c*±†:Õ­×oØ©] ­ù´´jÅ4uÍ^×lÀÖ‚ÌÞº}_Õù”¹vÝÓàž‰äèè`°–þáÓ œŠµ7jXMÕ3ïBâó•1Kbƒõ¿3—Q¯­Õæ‰j(2,ËR«fZ0o,±<‘>ùôÙôÏ3éÝw¬ºo@Lß½u˜¦OB|ªÃ8±ìk]÷í?Ž’§,D;v0hÒT§Q¾k÷b)}Z³n»ºÔ89È£–¦ÍXL÷î=Ò.å;{³ö6¿X?Þ7‰Çc£-'64kÆvýl`ç?.9±q•·'6æêí\ŸLDÕK™ÔÞíƉ¥z´Ä²4–&½¤ËÕø'±a™Ê»v.‘/mœØ{_KïE€_{I1ÅÚÛ¶iàe:ú Ž÷î=öRï]Ÿ´`ùN3:Ûµ~l gÃ5'ÞˆáÏ…©Äžíüù46¶›j«/óÏ3a#¿&±Ã2Bü¹6N Ä•q#øä ¿´gj͵ß×AŸŸ²:vÜ3€vÉáPô+VÄ ¤J•J®€=Ý5iKK–ôíÛ7rqq‘¯˜ì²ÿ~áðÜËëË—/"ðúÚ³gŒí&É¡@ì‡@û™ f ~'ÀÞ^«…kÁ"µT`ÂÁC§PáB¹©x!€¥ø³´Çe©ü,ÝþÏóÙ–’2Ú¼98Ÿæà׫Wo„aïí?p\†ÔŒÙ€W­F[:|`µÒ‡fÏc–l¹"t¯Ù ÈZõ-š{wyìmÎ)~ü8²:5ª—£Õk¶ÉºÓ§Ý(uÚb«2± Gn!ÁñXÅ/éÒåªÕwU×ú Î=z*esØ(ɆX}J—.¥þRåÙè®qIšÔsã@k 7ÄêƒZjõæÞS¥J&äw<Ó>ò…¡ÞÔxØÕXƈ?küLn ­r7÷«4gî*S]m^ÆŸ'½·º6¡„ âiY_ë§_¾âù™p§Ì}&bÆðÜèp¿xMÝOŸiÕ¢®’·Ñ—û”÷Ï3¹~Ã3 k† © NšèïËÆ›Ö\»þ^ÈGŽž1L 9™àñ\±Š M eJß?ØyàÂ… ”'Ï1]xÅGr_@IDAT¥òå=N®±áœ=åSìرÅïdñ‹-ºæ¾¯_¿ö¢o®óÛ·ž’}Ü @@À:`p·GŒ `rçÎJcG÷ÁêFÊÙ°­nƒÎävn‡Ð@Œe3Ä‚ xBÊcßîeÒèÎF[{0¸ëÙ±W7Ëeð‹“›ÛUš.5j-lTg}kÖ×R3th¿òKŸ.µZ?oXšXkÿýûO²yÖ,é¤ÌÖ÷ÐáS´pÑZáÁêJ)¤k8 &'þÙ|DèŠókæŒáúãÆã诹ߟ?UÏŸd…”.­§!— ä¼cÊ ¯_ o€Ô©×Imܬ_;S܇›JC‡OUÍù„K¥tLFùòf“'ª×l«êƒs†¥‘´Ä›^¬ýïSbéSI/‡dªÞ»2¿>ýÆKÊø&Ysí¾¹/ÚÚÞÔ¬ìÜRžz)SºúÁ3Ôë·;99ÿ|B°-L™2QµjÕhÆ ´nÝ:5j¥H‘ÂÛI}üø‘æÎ+Ûp°ÓH‘ cŒxÛÙÂJÍà~õêUzúô)%J”ÈÛž‡Rõ0¸+È€€€¿  ƒ;ÿ¡Z³fMÚ²e‹øÃ3¶Ô;Ë•+—¿@‚'Å ÇSÖ”œ„Ë®C4aâ<êÙ£•Zð-!×P«nrw¿FNi©SÇ&ªÐ°ac׎ÅTµF­(PßoܼKH‘ëËׯWÅÀÝx2Q3¸³QûíÛÒ¨Îí<W§Í[öHC9{¶—)]˜.ÿ'í’Ex]gÎœÎxHyͺÓÝ»µ”/—ûìÞsT2] ÷ܨS—¡rC€çéSbã:K³\½êáѼnõ¿”2¥×#Õ>c‹úR% Š ;¿yóŽ–¯ØL¦´×õsc}}½1¶`œ²šË5c{øðáhéâIT½ZYƒÍ‡cÇ"˜­–Ø(ËÞÛœØC^KMD`Ûš5ÊÛ¹î­Q€[­}p|×&Îœu—F¦ÖÉÆGí3Á±¬™üóLÒ:yÆàS$ÚIãùÕmЉJ”ª/_šTˆ=¬Ýxž¸|ld×Òóç¯hé²Ô±ó­H¾s¬ ßh4èŒ «HŸ>=uíÚUŽyëÖ-;'/­X±Bz–ëoÄò.Å‹§ ÈâöíÛSÙ²eõM¬–¯]»6U©REŽÇÞ÷¼pýúu/ãïܹSÎ÷Ó'ßÙóžen@@¬CÀî îÝ»w—?´ôË}õê•üÁÁ;²H  `Š@þü9hİë³G{ã¦Ý©~Ã.ôùóUwHÈv°1 ÌÈ+¤=l‘80¥>þ@ý†]ÅMwLN…3ÃGNWu… z= V®lQ•¹º^¤YsVÈö¼9U¯neÕ—3,“2{î 2l :™”ZÿünœXÒ§}ÇAtòäyU5~ìîñ¢äÑcO/hý¡Ö˜õìAœ’~ÆŸ þ¼ó†'>…¤Å$ЯŸ¿wWrn!?ü¹øøŸ¡@ßÆ?yÿ<“L™œ” ÏsôØY^¦rT¿d/z-ñ©Nö°vmNx·6¦û” œH1ãd¥ •šÑÔi‹ âaøÔõ Ö'0aÂiH(bÊpÒ Pâĉ…ô“.\Xü®GœdJKštKõêÕiüøñÖŸˆnD6žkÞê˜5]ºtb³?žÔŒg¥–èe'ƇJÉÍÞ½{S‰%t#   à_v-)3nÜ8š¥½ûÒÄIóåØü_w¡%o/‰¹Oš0@Ó9ì;(KöòT@lô,‹’'OL—„ìζíû 6HZ4¯mð}†×ª¥ù ÖëŽW«Z†¢E‹BWEPÙ)SÊ1´6“âÞ½GâôB<¥Í¯Õ•÷„ ã*ÏoìÛ¸Qu!“J¬ÛCJgò„T¬d]¹œVmúÑ­Û÷ɹria(ˆMG„±zñÒõ’7à“%K´êÒýûL¦L(=×yRc„ÁƒºÖ«SY|&’Ð)áß³·‡D×ר^^|-%å¬<Ù`ëµË‰à?›H`âû°© ñ $–Ëã'>‰uòػٔ”“ ‚4kÖŒræÌIl¸vuu¥×¯_Ó£GäKÃÀFo®Zºti­(ÀÞÙ¸Îñï.\H,{óäÉb§E~é~:u*A®WOy°»5¸/]º”úôéc°Ê!C†ÈÝcþáÅéâÅ‹ò¸ÔîÝ»ƒìž Ä€€U °ôÅÒÅ)Mºâ¤—Ú0u“.‡ a¦Ú  lA DñÒ¸Ûµûp©½ÎÞ ]äËÔ|ب¾qýlÊ£“£Ñ·kÒ¨†Œi /3ŒuʤAÄÒlýú-±4“©-ZTZ¾Äpƒœ=ìÃ… '¥øIç®Ce×iS O«T2?gÖHr®ÞZzh^æšµÛ›^žVaƒ¬=¥Ö­êKˆÔkØYêØùòU6Ô7ÔÏ—ƒÖNž8P_$6JKÌ0_Þøë+¤gø¥O,?óñã'¸—9¦LSDlÂL£Úµ*ê›™|©’…„,à=9_–óâË€iÏ·H‘<4tpW©mÏŸõqãçÈ—ñÙ€½ÃD0lãv¾½öï3á ©!ƒºÈùó …9sWÊ—ñ<8fÁü¹£ Šm½vƒÉàÂ&,ñp75±áC»ÁØn Ê@  dÎœYÆšã[²çøùóçÅÏïÒÓœƒ‘ÆŒÓÛÙ4oÞœøe­Ä¿¶jÕŠZ¶l)%nîÞ½KübÙÖ™O•*•s²Ö\0€„Dv))ãââ"Øð*Z4h <˜Ø¸+V,­˜>LõêÕ3«ó©" â°¬gïÑ>Û tÜCÜÇ#H-˜ƒú^¹¸GMuö¢ñ­-„½ÚÙ̺êì±n.¥OŸšrç΢ª£GJš¬…*ü/3ft:¸ouîÔTm5®gƒ:~Z#Ž)ç4¨f/ð•Ë§££ƒA9o„i)uêtîÌ6êØ¡1E‰Y+VïÈuúYÔ¯¯iC¼jh£ HÝÎí 6¦'Þé¦Ôw»,‘Q#GŽdЄ7*vn[DÊ7(ç fË:ù7¯í§~}ìsý^&mAÁÐÁ]ä瘃ÄjIÿ™à²:Òá«)cF'­‰zçÀ’üy9qtƒY檱2Öx&ƒv¢CûWI™ã)°¤«8)röÔq’!ªqµM×îe2(tñÿ‹ïà›ó÷g– C°,'ãììL5’:é>Ûræü3–%n *D7–¶öh·åœr½@ì…À?¨íiÕ¶ƒY>}Zùúõ«š ïʲ™–Nže&OžL/_¾”ò3ÜöÇT¥J:räeΜ٧8 à°!ݨV Ô¼U:{ÖÝ¢Uît9DUËXÔ@ ¨¨[»2%sHLŸ>¡´N)©€Ø”rtt*ÓÇ n‰1A@@@¬LÀ&÷™3gÒˆ#ÔRØC}áÂ…Ò#]ú!%Jrqq¡Ô©S«Þ7oÞ¤òåËÓ—/¦=ETCd@‚=äɓО]KiÑ‚ñ3ft³ëÝérÐl*@@@@  ÄçUÇ=FŒhBJf2…: n‹qA@@@¬H Ð îìÅÞ±cGƒ%Œ7Ž6lhPæ׋¸qãJ ø ¨!Ξ=KÕ«W§_¿~©2d@B.ƪӵË{©fò&!섬ŒI.(X¦<ÜçÏCI“Zß*`gˆÑAÀzž?Nk×®•/>Ž  Á…@ ÜݸqC]²¶¼¹Äs¾7·×÷Ñ·7ÇŒµäyNþü!sÌ|Û×?,ýÊJ¿VäA@À^ XÅàÎLjjÕªE¿ÿVëdí1Ö[³çÄ;Ã;vì;æZ´ó-[¶ë´Í›7Ïž§Ž¹€€€€€€@°&/^<«¯ïêÕ«rLÖ`ç—OÉ”¤LªT©LvcÍuN¬íŸY÷=yòäÞvÕ¤tø^lƒai}ò3ßöõK¿²Ò¯yÿ`Y¤~}z‹xŸü?F"„§AƒSþö!Õ ‹ †ƒ~göÃùlÅŠ vHãÇOäÃ'£5ëoñ1sǸü0Õ…õÐؘ®ÒU…‰L…  ~Ðò±(ÖM>|¸‰Ö(Š4Y–Œqttôq l0N¦ ê,SóõëWÙ”uã}“¸¯¥IÓ§·´}@¶ó+Kÿ° Èõ„ı9^Á—]!qéAjͱbD‡Á=H=1"Ü9 G5Y›#ƒëÓ‹/dtm}™¹<iâ€Å‹7×Ä×åüÍ›¥bX—ݯiĈ2x ?AúÒ¦MK§N"ÖR÷«“]„¼€`CxÊ”)‰>|è¥^_À²¶lœ)’ ¶ªé²ÿüù“M£F’õyóæ¥|ù<%<&NœH,¹Ëö–ÈÕ’rcV˜4iuìØQö-Uª”2ÖËýç–þaÅËõîÛn  Š€¿$e´Q8ˆˆ©@"Z½­ßãÆK¼cŒ  àw×._ ÷nÉ„ K%ËUõq°—ÏŸÒù³ÇT»"%+RĈ‘hŸË&ñGŒ‡^ ªô!“>SrHžÒK«›×.Ñžèñƒ»ôôÉŠ36%M–’R;e r•ëPx›^A„ׯޤ[÷ÐÃûèÉ£§3V J–ÜÒ¤KE•ª•§|ä-0°½|þŠÎœ:'oCŒ*XÔÓ8÷Ç=@@‚,Y²HÃùêÕ«‰_œØøÎFnN3fÌNv®®®TµjUŠ-š”y¹sçŽò>1"mÛ¶MüîQö±ä?v,ä ”<æýû÷¥N<†9@+Òoß¾- ð±bÅ’ób»–ØP?{ölêܹ3¹»»S† (EŠ”0aBºxñ¢òzÏ;7ÍŸ?_ëfów¿²ô+^´OÏØæ`0MÀ*÷M‹BàÎÍ«Ô§s#µÚ퇯QrÇ4êÚTfÅ¢´`æXY?Ab*S±¦Ì÷ïÖ”¾|þdª‹Ù²#gƒ{[UÿîM=¸ ?´[•g¦Ž@-Úõ¦zM;P`ž¬2ž®AÀÖîÞ¾OCûŽ¦Ã<7ÀŒç4~äTj×¹5nYß®¾^._¼Jšw—ÓÍ”5C ܯ\ºFÿü•÷vJŸšÂ… gŒ ×  vH€uÑß½{GÇŽ“ïì!®OI“&¥ãÇÓÀå©}ŽwâÄ ÕÄÙÙ™† & åªÐÂLÖ¬Y¥Á¼K—.´eËéaäÈÙ;tèÐÔ¨Q#éånÊi±eË–Ä^ãìÉ~æ̺wïž|qçdÉ’{…ó þ°aÃZ8›€oæ–þaåÓ3ø•ã  `ž îæÙ @@@G XéÊV›~ýü)K÷ïÚDÍ…1Û»´Wxžk©L¥ZV3â½xö„ZÔ-MÏŸ>Ò†—ïlT׎ sÁ«ϤQþí›WÔ±ç0ƒ¶¸BàùÓÔ Z qä™Á’¿^Ø“|ˆ0Ê¿~ý–zôëdÐ6¤^Ô(ß¾}ý&—äÜ.±é—4¤¢ÀºA@ÀêÊ”)cð{›þl(÷)qÀQ~™JoŽ¥b¼K¼‰:vìXùzóæ ]¾|™¢GN)S¦¤¨Q£šìzãÆ “åÆ…ì1ÏžîœØ˜Ï²µ<'GGG刔§ò&{ÄspU²ªI¨ß‹¯K–,i–¥¾ýÏÿ~×—ù§¯6Ž_Xj}ýÊÊ’g¬Ýï  Ø`pl⸀Q‘£Dž¥eéàž­rû\6{kpg©—‡÷o«Õ–wS)kŽ|ä”>‹©*ƒ²ÔNÕu¯Žõ•±çÕsàx*^Æ™¢ÇˆEW.ºÒÉ£ûh׶µtëúeÙgδ‘”6cV*U®š):µê©ŒíQ¢F¦þÃzRéò%„üRtºxá ;|’¶or¡×<$£fLœC2¥£r•J…DX'€€@';vl*R¤H€PH’$ ñË·‰åfÒ¤I#_¾íkËöþaéWV¶\/î  ¦ÀànŠ Ê@@L(S¡†2¸_r;Cìi?ab“m÷¹lTåIRP¦l¹Õµ>SºBujÔ²«¾ÈÛ…Ö®ØDÞ0èŸ Q|jÝ¡™8R‹Â‡·üëôòÅkTϹ}üðQŽW½N7m8q`:-±1¼wçAÄ þx~I‘25mÝ5¯«5•Fó&µÚ¨k-S8GY™åuºÝö ¬·nå&š3cݾqGkªÞ³çÊJÝûv¤Eòª2d‡À÷ï?hÕºtÞý*Ý{ð˜>þJŽ)’RJñªX¶(eÉ”Öê¹ÿà 9wQŽ›0A\*”?§Õïáß>E¯ß¼“ÃÈ›‹¯;k¤g"ÄÑ®r¨Xâk¤d±üÖc€€€€@$`ú¯¡ ¹L@@ 0èee\OF³wB;=¦Á­õr2ÉÓPÚ Y êýs‘6}ViHÓŒfÓÆ A ¿H ™ð" 0±9×jbP† I2dLkðõ2~ÄT” ã"„7@‘8I"ªY¯ªA™þ‚ ìšw§SÇÏê‹Uþý»4mü,é±>kñJêà¹ÙÅØ ¾M“.ä~þ’ê£ÏppסýFÓé“®4sá$bíZŸÒµ+7D@ØæÊØ^_ëGLd yÇ–ÝÔ³ãúúå«—áXBgP¯tSè×ÓÏìF—ŽÿLû/M7Ó\5?ëFMj·¡9K§RñÒ£ löæ!¸bÒôÅ4vò|zitŠáðqƒðÀáÓȹb =¤9¥Ia5R‡¥&m=8–+UÈ. îGL£§Ýäš7­œf5ƒûy·«T»Iw9nÎl`p·Ú§ €€E0¸[ñ©}ùò…~üø!£‡ÿóÏ?VC€€ýÐdeØ[œÞ‡öm£*5LpïNOýö²•kÔ_\½tvn^e\lp]@kÕŒúñ$¢jušÓºse›ÞÓÄ‘½iæäa”+oÊW¸$å-P‚R§õ ²j0.@ ˆ/<Ök7¨N+—¬•«f/ðQƒ'Ða$Î#¼o Í/½¯Ò¥ö‘Êðã”±=b¤ˆÔµO{*P8/… –N;CGÏ^ë—…Gqß®ƒiù†ùcöï1LÛÙ›½÷À®”;z$¼‚YâeÙ‚Uôóç/ðx/Íš:ŸÚwmeÐßø‚ƒ¼²g;ú9µhÛ˜ŒèeÐìÁ½‡Ô¥uobÏz6à·éÔœÊW)#¾ŸD£Óbã`ô‰RZfù¢5%jê3¸eÊ’¬üWŽÓ®iWñ»ÝO™3e(ҊõrúöõÍóÔR¿¡=¨lÅ’²þòÅ«4qÔtº~õ¦¼wÿîÃèÄÅ}Z?¼[—Àˆq³hàˆéƒj¿•ÿï¿R~ß´}?:ëNg­¥$‰´Ç€€€€ø‡ îþ¡'ú®_¿ž¦NJ7oÞ¤—/_ÊÑøs¬X±ÈÁÁòäÉC;v¤´i­lÕŸSGwðcY™ýBVFopúø]¹xN]΃ûöM+ˆ_Þ¥u.®ÊàÎíú ïÄïß¾Ò¶ËU7ör?r`§|qaì¸ñ)_Á’T«A+Êž» j‡ „4CÇö£o߾ѦµÛÔÒÙÛûàÞ#òÅ…lHfÙöÏ•7‡j§eΞ:G[Öo——áÂ…¥•›Ê`«Z}ê´©(_¡¾ŸNÙGçϥ߿«¦‡ön£íëÒŒ…›U2 ÒdÍ‘™øõW½äv…Ž9EG…·ïÙ“ç ¾^öí:HZô ù+f(DläÖR•ê嵬—÷ÊÕ+п“çÉr}Zª%$j*ÅŒƒf/™jªJ•½~ùFÛ›ª€­ì-_£Ž³ª×gX—]K‰’$$×ÓçµKƒ÷èÑ£©ë«BÞÒÄ^íé28ëÈsbÙ˜IBV‡ev²çÊB9rg£ £Ý-zKï‰vÞЂvr«\Ù3™eߢq êÞo}'8<ãFÙ³¦—ySÿ=|ô”.ˆà¼aB‡¡”ŽI)•Ø2ØTÿobëÄé ôõëwJ*¥I•ÜìÜôý¹ß±!ÀANóåÉJqÅé K<¾zý]¿y¢G‹B¹Å×}ìØ1,é(müº.mrÜÿ´ëEzôø's¬øUï  Oàó—o´íà9Úwò"=yñVüLþIŽIãSšä )_V'*š'ƒÙIܼ÷”Ü®ß7[ϱcD¥Li(^l¯ŽYZÇSn7éá³×ò2AœT8—ù߸ÑG€}×Q7­;•Ì—‰b‰û €)0¸›¢âCÙû÷ïiþ|OÍÎtéÒQ÷îÝ)yòäÄžï?¦GÉ÷ÏŸ?S‡`l÷)ªMpwwWnnžßØU!2 `#¦deØàþêÅ3ºàzBͪl%ïõÛ¹a¶\ù©nãvª_2lÐÊ”5—|µh߇>}ü@‡÷m§É£ûÒ‹çOält?æäeü}‚þzÉ"Œ‘üj×¥¥”€9°û6™8p)'6º³ŒŒ&/sç–§ÁÝ!…ƒYÉ’¨ºÇÂHÉ:ç¬÷~ïîUΆj¿¦gOŸte¯ô¾Ý†ÐÂU3 Êùâ¦Ñ’^>G+3õþáýGSÅ&ËØ‘‚ïÛ²aGbÝzNìu¿uãNùâkÞD¨Û¨¦›iB1bÚÁ“çÓŸ?Õ²¶¹¤' ”AƒUá>õ±zÑDzûŸþ:'Gã&RŠ¨ßÐ)´pÙFÕNk”DÄ èÙ¹µnV›Â‡§{yÿôé 5n݇vì>B?E-±÷ýŒ ¥]+ӿ߆òJy–¾ÑRa¬ïܶµkYW+2xgŸi³–Ïû«î”Jhñ5_«ZYš<¦A{ã‹KÒý‡Oeñé«åéã6µu¥u›wËâPûVõŒ›˜½ö˺ôsúùÆ\ö¥¶]‡ÒÓç¯ä}Ö-L5œË˜½'*@@ìÀÖý"ÈxßéýGÃÓŒG]¯©ÉÌ‘–†w®CEr{5¼ï8|žºY¢Úz—aƒ{ aŸ> ™ãø”%;h­‹Çß®%óg¦=>Ü>}MuºNV·;µvå†Á]ñ@Æ î†<,ºruu5h·dÉÊ•+—A.@ÀþþõüÑÿˆB{"À²2÷l•S:¼»ôÝ¿{³šb†Ì9„†qJum j]¹ØÓë¶X©Êä"•—¡Yb¦bµú”5g~*[À³þèÁ]0¸{¡…‚àJ€½\—Ì_©–Wªl1!ÕâÕØÍ3Î5+IìBÙ= W‡öUw5ˆÈx÷óȸŽÒ,µ÷KCÕRä(‘µ¬ŸÞYk›5Û§O˜-%\X~ãš­T­veƒñôÆ×8BN„µú”â'ˆëSƒz–•Ù~`Ú”ö /Õ{ó³ÆüÌ)ó„´Í~Úà²\Ä¢0ïee00.üD WöŒtöüeÙ— ²å«·q»™ô^¯\¡¸Ù{<~òœª7èLgÎ]2Ùæ±Ø˜êÜ{49îJk…Á×Ô)6æ¯ØäÿìXYÇÏîØ‚ **v¢(*¶®Ý¶®½k÷®ÝÝkwvw·(6ˆØbçî÷Ýÿ}w†y‹FAÎyžqîÜžß¼à˹gþ—Î^ð5ê26•ë´%ßÓ[Œ6l]»q'µê8ÞŠÅ$Có»uŸ:õFW®Þ”²8†Qö5v¤­;6£Ä÷ɕ붓Ï¿P~FcFTîK™ÆÎ=GåsÑ.B(e|fL€ 0ØOàË—¯Ôoâ š¸0d_!s³>zî:•i6˜–ŽíBMk”2W-Ìü'Ï_ÑÊ­G Îü ÓzQá<Ñû÷i˜à ñ–;Ü#ñè?ÖE¡)"db«³ÎÚ{÷îÉ;trrŠR”=ú‚ž8$2fÌH©REíÆW¯^ɹ¥I#þ¶±‰Ðk¹ò†4ÿ`³Ú   ²¶¶–Gl“ƒ£x"E ~ÝHóè8Ç hee^¿ ²I+'S¹zƒh¿Ã„‰Ñ¿'г'º(ׯ_¿PëŽ}ÌŽcgïDY³ç¢[7t—/t¯ šmÀLà"Hü¼Ì™¾P¼y¢ûÜätø½Ù;Ì$¢Ó³‰ÍO•ÈðσպY³e¦‹ÿ9ýï65eþ÷¨Ùv™2’E yíà”IuD?2Vi,ÕzÚÄÉcgTtHÏXX$ÖËï Óæ—›±¾¯õιH–î7ŠÜK»QzÃ<³&’ÞÝÃ&Ï£×Wt^x”+I8`¯^½¦S»Il2»Ý[ y<‹^ÿˆÎa¹/=Ŧ· —mT¥bvï?N8\Äç·|7ªP¦8•v/"ö1HnÐRÿÔŠ³Ñì£w£R% ÓÝûä½mÍœ»’>‰E¤õ›÷ИIó¨_vúˆ+Hž ²üÏ>dö§OŸiéªÍ4oñ:}þZD¿;›fO¬¶½}ÇŸ<Ûô‘ÑðhÛûÖT¿v%² 5‡Žž¡ÞƒÆÓñŬù«(eŠdâ­”jÛe¢o­³½n ÔÊ«åÍ]HËÜ¡ Ó‘Vã^mø Q¹/íôpÿp¶ÛfH/Ÿ‡•e*ʤÙKA[—ÓL€ 0&û4ë3Vo?¦N¬l±ÜÔ¤ZIB4»“]zºûà mÞ–†ÏZ/å[P±Õ€YdŸ1•,lz_°Ä‰Ò¸Þ^jŸJâÕ›÷tÊç&m²5°žSë3é¢÷ø(ùÆ”þùÌÂ"À÷°ýW¾m›xÕdÍòóó£gÏB6p@»¹¹õbkkKU«V¥–-[ªe§OŸ&DÃCD¹¼qãFétV*nß¾V¯^-ÇRòp®S§õêÕKÍ‚lÍìÙ³éرcôéÓ'™1kÖ¬)ëAcþÛ&K–Œ ,HãÇ'WWWµÐpd<˜NžoŠ3xA `á|´K8aUißµu?/!ÿçåÑŠeÍ–Eu¸{¯ßJ%„n²)ó^·M͆“^±,ÎNªÃr5¹ókdÞŒšÕ×9.S G654á<¬R½‚ÌîÖ·mß¼‹…ÿµpr÷ï1DOw>³S±Kç/Ëï^¦"‘o é™ógtnÙÄF§Ä&›á±â Ñ/¬H±‚T\h·Ã  _ñײòù×xéhG¾2Òl1CÀÉÑŽön^@5u¤ç/^©ƒ\gÓþ^.tØ¡"…rSM±9o±É¯¡óý°XôQ×ÉÅÇ÷® Lb˜½XD‚Ãß½&N_,óV®ÝfÒáŽÂÉcúQçßšÊzø§°ø™BŸ#'Ì‘y—®\WËè9`œ*=³`æjÖ¤¦Zîè`K%‹¢ÜEkÈ…Â釼•-ÂÛ,½ŽWë¶ô¬-7‡U‚Pì„SZçƒÁ"Á·¶ÈÞ—á<¯‹½ Ö©"îm%Ù˜`L î@„¹ÖÙÞº^9š=¤­žô[6§ŒÔ³u ª^¦¹ÖïGo„Î;¢âÿ¹Îmkòf%L@=«˜,CæÜ5{é·?ÿ–å—ýüiÛÁóTMôÏÆbš;ÜÃAøõë×Ô°aC2t¼¢)^†CÚ”­_¿ž .Lyòä‘ÅÍ›7§ë×õ¿X£@q–#±4h`r¬üùó£ŠjC† ¡ùóç«×HܹsG:sñú¶Ö0÷#GŽPñâÅ í  -6Jca {÷îzNim%8«áðÆ¡X¾|ù¨víÚÊ¥z†¦}§N¤#]ÍÔ$°øpêÔ)y(ÙÐ.×ê—+ùp®wíÚ•.\¨déqŸË—/—GýúõiÎœ9”:ujµÎ† ¨gÏžêµ’È‘#‡’”ç)S¦Ð°aÃôò” üQ£˜¿¿?5iÒDoeX„yøð¡RMžñYA¤ûèÑ£iË–-’GæÌ!ÎTÂòé¢wµ€¹¹ÏÚ‰'äBœþxÕž |+ZY™][תÃæ/äFlíÕëèL¸ºy¨÷s§ŽÐøὩ›ˆn5|µcΟ9FhR¨Ã*ZRMs‚ ÄnÃý´ØuäŸã©Ï_ÝLþ¼Ìš2©Xývd4ô¬CëVêº6­ÝJ ½êQ!ƒÍO¿lÁ*µ=ê(V«^5!«²_^.[¸šˆþ2ÚꜘJYSC¾Ó”­X:ÌÿÏ°aê°ñR«FdpäoZ»EÊã Ñú¹òä ßË×éîíû´vùF1ïºÊpòüîí;jÕ¤ü™¿t]È÷Tøå—ŸÕúoÞ„,ð#3H°š4f†,Ç©n%‹-fdqù>½Mzµ/NÄâŠП=2š|ÁÒõrÓQ­("¤Oœ¾$D§/3†ªV.­NhÖ¼ÏpÏ®-Ug»ZA$ú I£{"Ú]‘Pz+>GÉ ¤’}Ý¡M#m3™.SÊUu¸ß½€‚þ6ý·8–'§³ž³]é$³xŽ>Ù@IDATS¤]Ë4Eè´CrN÷A"‚R3žè‚&H #òg»Ò‹MˆÔß´uŸ”˜Qòcú•û2œ"ÛÎ!|, ‹øš 0&Àb1üÙmÔ"u†¿–.Hs‡·W¯ Ù3ÛÒ˜žžÔqˆî{Ù…«wÅƪÏÉÖ:aÕ0¯Û6(Oƒ¦¬"HËÀN^òc‡{˜Ô¸Bt`‡{8("j;eÊ”&à¡5‡óG ÉSwm ý¢ÒC38âÉ]²dI³ÑÐpÆ92´nL–=zÔÈá©, b<"æãã#À]18ÓK”(A( !¢þܹsÒ‘Ÿ6mZÙÄ3S}…·ægaaAïß¿×ëÆÐÙ®W(.å(þ½{÷êá3ƒ¹šr¸ëU4qyv¶›ÃY1JÀ£Bu‚Ì ´ÕµV¹Fíe´¦‰ V÷ íøSÇtλÅs&Òîmë¨zO‚„Œ…E ð¿#6MÝF>N©cW¨R‡œ²dW¯9Áâ¯Öi÷Žýtü°îg,ˆ ¯Ý :erÈ$$_“ÿ½âgê Øð8äÿ×Ê"ŠQéŠÁù^S8ͽ…LÊg!¥Ñ´vkêÞ·³Œt‡¼ÞI¡]>~ä4RœÒpQ"ÑÑǯ5+‘«[!‚ÓÿÙÓçTÿW/êÑ¿«Œ G›e VÓ‰#º9&¯·jßL:ÔsÙ ¥¨Z­Ê´uÓNYﯾ£ÄœÜ(]ú´ò ºA#úR£-dYßnÉÍ[+þZŽÒ¦³¢SÇÏÊEÅÙž#g6¼µ–Þ:½Ò°ñ#¦R½Æµd¿¸77÷¢2Às§/ÐoͺŠßC¿Raá|Ç:ú?rŠÚ]Iƒ¾ÕND;D­c3OO…Ëñùßwð$íØs„„>»b/Å&¹ušv¥C;–P1×|2ûºØ°T17Wý`%?MšÔ´~ùTåÒä9—Xð1õ½,ƒFöH ]vÅì3e c'Ï+—zgËÔ!ß/‰Å$$có(Y„¬Åçß”9gu$8íoŠ¨oeQ¹/Ã9b±í†Tøš 0&û l21ç}Cþ¯ê%¢Øò¦ÕKÒüõûÄwªeÕó¾w#åpGcg‡ ªÃŸ²1oA€îá Œ?$!a²cǺyó¦”WÙ¹S÷‡¢E~ÿýw£^ s^¹re²³³SËàF;+V¬Póµ Œ…heŒ9´A„¸)ƒãô™¾ºÖ ÑÒ¢E *Z´¨Œ´Æ˜K–,QåWå¾oß>m™†ì͘1côòÁ]½zurqq‘ïp¬CÆóZGóÇõÚáNe­³R;=zô ¼yóJ½u8ÄÑdT´ò)h«üÇuëÖ­õœí±éÖ­+VŒ)Žgƒþ ãŒ&2âóÇýãYyxxÈñpï ,ç²¢Á?˜·³³³””QžƒAy‰èyŒ‰HúI“&éUdLÇŽå˜ööötàÀ)K¤D©c`ˆÅ­íÞ½[>ÿ+W®¤Œ.Y³f•ÏA[WIã- |ÞؘÀ·&üŽÍ»E €îMí÷¯Vd4ýŒIsèòE_Ãæ”YD7n^ŸZ‹ˆ}SúñF 8#Ò°©è¹ ºgVlÊ«Õ?×vš_,æÌŸ1\~÷\²r³,B<žo‚¿È78”ú)ÄƤßÊ”ï†Ï:]²³5~“Õp.…Ä LùÎ4Þ ÍþýW+°ZÍè)‹Ê}Î “ •a9_3&À˜@ì$põvHi~—η˜í†Ý§èá“êPpø³1oA€îß‚ò7Îql¤ªýcPª*wlü ½x­ó2'ZÉ›Q£F9Û•¾pÆæ¬p¢Cf¸y,4ìC„·¡³])Ã(`CUèÀÃàÄÖj¯OŸ>]æãÌÙÐÙ®ŠG° ‚…§OŸÊ¢™3gÉÝhÛDwzÓ¦MzÎv¥Âˆ² ](Qêð™ Ä5Õê4%±S×to¡D¤a],ŒÕkÒ†j7lI÷ÄqW8ÞïÈßl¤¼Œƒ“³a3¾fñ’~^ MõúMj‹Ÿ“@át$ÿûòçÅÖ.£—±“ÛaÁÁ÷‹6›Ëã©ÐŒ¾*6}üçë?g½MÆ°„B{yØØ4TD†ß¿ëO×|ý(EŠää”ÕAjº›úþ=÷{ÏÙÚ¹6iÞ€p˜³ÂE ÊEÈÃ\¿zƒ?zJv"ëÉCqª¦¶LM“g‘Çs!MòUlÜe)äD´V¹Zy ¸<}?’‚©)£ØhS»q¬¶ §£ŸÀ›w©Ç€±²ãdI“PÓ†ÕLJº(#×Û*÷…¶ì‹—¯r/Y„ä 6ç„ùœ÷¦ ~È Á =c!o¢bÙÄâŒbʧ¥sÃÕ—5³½Ò”íÐìν}MB«gÎ1íøˆXTîËpœŸþÉ0‹¯™`L ¸v;äÿ&G[㇨ÜÂ?âÿbŸ÷õº€füÓ¯iû¡ó4kånµ,­eJj\Õ]½æˆIìpIºß¡oH¶˜úcS1ŒVCT¹Ö´›”B®¥K—.Úb“éáÇˈxŒ[¥J½:Úþðv€Ö¹¯Wñ¿ DpcCQH­Êôú|͘@Ø𦑽cy„]›k0øM?/NöònÂ(Á€Nz鲑û£ßU3;È#J“ˆ`c8×á|Œ!Â?4Ë$dip°}ÅŠè‚60ú»÷èà‘ÓT.ÝüW¯Þ¨ÅfœŠ¶zŽl™U‡û–¨`þœj=%±{ß1ªT»­¼Lc•Šß>ªEúœ]³gÂés>f¿·^Ò3'N_”ãävq¦¢â¾µw,<LЙ7´ÓbŸ†;bÏs†Å…{þeñ£'º ú·ÅBYD,*÷‘q¸.`L€ Ä^ÅÿKŠY¥J®$£åüþÃ'Ê_³g˜}Á4¶—'%Kjf]®À¢ƒÀÏÑÑ ÷ñcÐÊÌ@<<Îièº#š‘óZ‡:¢çµr-S õéÓ‡ aŽh|ÅÞ¾}KÚÍ`¡KÓÖƒ|``ȪjxÚs&À˜`L€ 0¸A —KVJ§‰FoÚº·ž¶¹ö.=~*Þ´˜¥f•,^HM#2^±YóVQ€ØóÀÐÆLš§fU­T:ÔHzµb Ì¿À{øݺO —éÞ Õ6{ûöUoБÚtþS¯ÿÛÐ7_žT0Ÿ‹¬ú^ì¯0høTm3™þøñõý+tLGÍ‚ÑþC§ŒúØ{à8an±¨ÜWDÆáºL€ 0&{ dµ·Q'¤/I¨Ä`ÂÎ& \:˜ZÔ)ƒ£p×L@ŸG¸ëóˆ×WZ»òŠld /D¯áUXTúÃ棈ÈS4 _½z®ii7kE ^É 8®Ä˜`L€ 08FßW.O•jµ%¼^þXì1ÛµÕ®^žŠ-@¶ÓÓóÁtåêMZ¼Bì! ¢àaI…ÌÑ›©w[¯V%*U¼0>~VöQ²’ Ø…ÜÝ Ñë7o NøýBó–Xè¥kÛªD"ïΓF÷%_›ËÖíºüE7…s»–+JŸÎŠ;K‹–oT#ÔóæÊFåËèÞRÁwRµdÛYóWÑK±p+¯º”ÝÙ‘Îœ¿B“g,¡£'χ:³ÅÄIÞºWïÿ^°†¾ ¥–žµ)Y²$â3Ôopè{SGå¾LõÇyL€ 0&÷äÌš‰NûÜ’¿ø$Ü7°eÿY þoq9GÊ“ÝÁ¨m„ ¨mýrFùiR§ ÜÙì)·s&rvÈ ÷i1ª¤Éøôù‹æÊt26NŒ%OžœråÊEèÍò_Õm^Ñþ ;ëèè¨n »fÍjÙ²¥Yé¥ÿU«V)I¡¥jIØ´– 0&À˜`LàÇ$ ™‰£úP·¾£ ºìp¼Ã¬8‘ ï:¡ØChÃò©R–E[6oúPªÕ¸ ]½q›î ]þf¿õӫ鉣úR|Æ’3j…&J»Žó.4dÔ 9÷1“çCsr°¥mëô÷lªZ¹4õú½›²@V_µ~áÐZ.±1±£CFÚ¶ë°6[M·oÝ&N_Dèó—/4{Ájy(ò‹Hz±÷÷öýJV¸ÎQ¹¯p À•˜`L VpÉ"¹wôÜuú ÞºJÆÞ'XômÔ}’¨«Û´~ÝÔž&îbñ{úŸm"uÿé¬RªíÞ¾ÿ¨¦Í% ëhÛ›kÃùñ—KÊ|‡g¯$Çð÷ï›~5sÿþýtóæÍo6C­ÃýãÇáÒpWæÍõ¹sçêÍUÛß„ ô6dÕ«¨¹@$üÊ•+©S§Ntë–nÅMš4QkíÚµ‹†ª^›JL:•à˜W¬Q£FJR=kŸƒ¹gðòåK½~ÔÆß(¡Õãüøq¨£~þü™Nž<)¢‘Â^™ µ#.dL€ 0&À˜@%еƒùžÙBž «Ó/"jÜ”!ª½}«†téÄFªTÞx笎töðZêÔ¶1¥HžÔ¨‹ÜBþe÷<ê(Ê£Ûõé@‡v.¡<9é'ƒÎáœèÚÞ“Žï]Av¶!¯ç+ÕÆëIë—M!8ä ­„ˆò?¸c1Ù¤7€‚_l[DåJ‡á ŸŸE=òömY`vYÃñ ¯£r_†}ñ5`L€ Ä-JäU'ü<ø -Û|D½6—8yé¦êlG÷B9ÌUt>¢ßÃÆ®XÍÎùÞQ‹¡ïh›^½æ0$Àî†DÌ\CGüرc985ƒƒXëØE>^i-X° Ù=säÈ¡'‘2gÎ*P ¥H‘‚Þ½{GG¥#F6úÔZ@@€Øé¹Ø)ÌÆ\Ž?N=R«A7èîîî„OƒÖ××W¹”gljêáá¡FŠg̘Q¶Ãø°ùóçSPPAW½D‰zú”pîúûûÓÒ¥Kiìر=,gÎœ².Òõë×—}€ø•.]šþøãjÛ¶-¥M›UT{öìa>}ûö¥³gÏÊ|???Ú³gLwìØ‘&OžLoÞè6¸Sµà¿„“““š…ÏÝùóçågKÉÄs<‡uëÖQpp0åË—.^¼¨Tá3`L€ 0&Àâl|ºtîš6nݺãOwï? GŸ‘uZ²·Ë@.Ù³ˆ½‡Bß´-‰pÊOŸ0ˆ¦H·E>¾~”Rlº›M8ã3‰>´A ÜæMkŽÐ,§ˆ2ÿßë«¡U!H»øœôß{߉qoÐà'}uÜW 1‡Ð¬N „§ž½pEγHÁÜâmÏT²Ù¼Ã‡9Ë’Ùžö Çúå~óö})£SRÈéXY¥µ="ìcâ¾î^ÙknªœÏ˜`q„@~'òªYš–zëü&cæn¢e “uZÝÿ-†·ßNß ËÔììN)}Ýÿcjf4$òd ‘¨ùøé3m=xžêWÖɵv9­ßâ Ì•ÕÎäwÃv| °Ã=ÏþÔ©ST²dI“‘ÃÐoØ°¡É^¥=}út£2È­äÍ›—ਅ-_¾\:Kmmm sszç[·n%kkkÚ¼y³”gAÔöÎ;õú?xð áhÕª•tv£N|8nŸ>}ªW·lÙ²Ò9®8ØQ¸aÃÂf£p8öoß.,"`ìôéÓË LáˆWôÙeÅÿþQtÖqY¡BéïÙS·c46>…3à~Ñ/¢Ë1GCÓöeccC+V¬ š5kª|鎲7„ Sý`A#[¶l†Ý« (ÀXEŠ¡L™2ÉEC'»¶qÅŠ Ñûptà îæfü ¹]»v”(Q"ºzõ*eÉ’E67nõîÝ[Ûy{{ž+ÿ•*UÒ+Ã>w£F’ù˜c¡B… #VVV„E D½>ÈøàY³„ŽNÎ`L€ 0&ÀâÔ©SRaálÆYƒc=kyD¶È¶ƒsÎ÷ÈXš4©MF/DЛŠ¢oûÐêEå¾Bë—˘`L öÙ½1­ÛuBF­ß xLîMÑ®ù)s&k½IC'½ÛÈEtâ‚Ÿš?®wÈ^+jf4$ ä‹èÒR@Ð3Ù[ë3)CºÔ"šÞE¯wøèÚ œ­7§šåŠèÕá &`HÀô{–†µâù5"Í##Ó±oß>³äàN:d5ïÓ§OtçÎÕ™l®!œ®p¨#º}ï^óˆvVÖˆl7t¶+ýŸ9sFFŸ+×pÒÂÉÍs­¡¯‡ÊÈiœ ¼¨ Ç:ÄZëÑ£µoß^›%ÓˆxG4:Ò¦œäp|.VT«VM.Nh¹¡3hÍ_¿~ݨ8õÁ¹Y3Ó¿œÑŸ———ÞÜà´ÍÙ®TF>ê­_¿^É2:ã-m¤ýŒê laoʪT©BM›6Õ+ÿ+W®È7 Ÿþ(Ä[ìl×CÆL€ 0&À˜`L€ 0&À˜Àw"`k†&öm.Õ 0…Ûþ(_ÍžT¹Íp>s™9L}Æ-£µzÑìUº ¼Q¯ØµZ™BHF»AªmѨNj¿oß}$¯Á”·FjÕ&õŸ¸‚ª¶IÜÛÒ¢ !þ×¼Y©Wëšj;N0SØánŠŠAž§§§Œ¬N™2dCƒ*z—ÐG´ô°aæ_ׄt ¤_2dÈ ×V¹Èš5+ýùçŸ2^ÉK–,™ŒlGôtªT©dÿ¦"·!±2zôhUÆÕÕ•:tè #Ê•¾p†´ÍÈ‘#e´¹a>ä\0>"©C3 ,J ‚ÛÔëµ³fÍ’‘舨Ë\\\hÒ¤IR^ÆPŽmÕ„6mÚˆWM?p‚“ÝÇÇGÊטÏiÑ¢EÔºuk••¶."Ôk×®MýúõÓfSöìÙ¥äÆdz€S\+߃Ê(C4¾ÖYGx©R¥›À*†EªU«ÊûQò ÏÐÆdz€ä9C„?dsðÖäˆØ˜`L€ 0&À˜`L€ 0&[üÖ¨"í[ô'eH¯ ð|'6*Ý}ôý9u55ë=ÆÍ÷¦ëwÕézÖ(E“úµP¯c"Q¦XnþGcu!ÑìWüü¥ƒ}ôœ´ãðzú"DfØÁ6-Û•$ø%&¦Ã}þ@XR&r&›6m G͈USÑÊ×®]“ÎÐö†ô áùóç— 2Äl§pàâÍœ9“p„× ±Ž±¡ßÇ5´ÆýqÈÊ`¡\ c oj È°à¸}û¶Ü }!šÎgô…ÃÞÞžòäÉcª¹^$Uà„Æƨˆö‡ü ¤U0/GGG©Gvx N÷yóæI'?4ú¹üÌ™3*”{Ä)svv–o˜*3̃³ÝPëÝ°Ž©kHæàY`cÚÓ§OK Hú€%°H6&À˜`L€ 0&À˜`L€ ÄV¥]sÑÅMã¨Çè%tð´/=xôÜhªÐlŸ:°U(‘Ϩ,&2ú·¯CµÊ¡Þ"Â~û¡ó&‡H)6Q êumö+%NDi²2g2A€î±àc‡)ŽØhˆÜ†^9Žè0è™+šæQíŽhD—G‡!z¼råÊòˆŽþb¢¼m€9~»wÇ–Ì›ü=†æ1™`1Nàë×/rŒíÞ»éêåë1>À~Dwoéöÿùïï‰ „EàâÅ‹aUár&À˜@¬$Qþ­&˜Î*-ÛE÷øY0¹|[:Þ]²ØRžlöd•ÚüÛýhÔ­E5yDç|sfÍD[ÿîG/_½¥[BîæÖýGôòõ[r²³¦¬ö6ä("Û&djt2ÿÑûâOËþ„ùþ˜@àí ˜ß5;¤Gzâ¦L€ 0ØO`é‚•±’q.Ò÷¯`Êdok²ý»·ïhﮃtìÐ zôð }üøQüNÊDNY¨`‘üäæîj²2ïܺGW¯\7[ŽKËÔ”=§3¥M—&Ôz†…k–o %óWÊìæmšP•êéà>ÝïHd–(UŒ,­R6Ó»>wú=|,óÒ[§#W·BjyXsO øý–Erøùç°ãUvnÝ+~ÿUû7LüòË/²¯,ÎN”0aBÃb¾fL€ 0&À˜ˆ7o?ЀÉ+éÃÇϲ՗¯ÿD 5WeÑO€îQdºnÝ:š2e ùùùÑ“'Odoø#ÊÊÊŠìíí©hÑ¢Ô¥KÊ‘#GGâæL€ Ä5º·¤woßDhÚGLέÂiužzvl,ÛæÊ[HÏá>ytòõÑ9Ûf,ÚL¥­«FhŒ¨T¾wÇFýõ;¸Ël7SƤ6ûP“–cÅâãuß‹ôÏ?º/\Ùrä¡„‰™;0¸@Níέ{DzªfŒ4épß³c?õè4€^¿z­×·Ö¹_¤XAêÑ¿++QD¯.öï>DÃ5Ê7•‡;œäCÆô v¡;ÊÑ~þ¬%tãÚMÙUÑâ…éQÐc=ëw,£B®L ¥æ͹˜vnÙ#¯=ʹ ‡ûßjYxçž4YRÊ•'•­Xš~ëÒŠÌ9ß{vîOoß¼Sû7—€#?k¶ÌÔ¥g{ªZ³’¹jœÏ˜`L€ 0&`‚À+ñ}kËs4tÆZºuÿ‘‰œÅ¾°Ct¾Ï¼bý¨ˆø*]º4Õ¯_ŸŽ=ª:Û1q8vž>}JçΣ™3gÊ:±þ†¾Á‡NÖÖÖô×_}ƒÑx&À¢›Àã @jÓ¸¢‘³ÝðDçÃ)?}|ìøY÷ª]’Vu•Ç£ Ñ…ûcqžÀ—/_hÄ qÔÖ³‹‘³ÝðæÎœMˆ†¿xñ¢^¤èÆÉÆÆF­·}ûvZ½zµK͉:uêP¯^½Ô,ÈÖÌž=›Ž;FŸ>}’ù³fÍš²4æáx†%K–Œ ,(õÓ]]]e^XÿOeL8µá°ïÚµ+µiÓ†,,ÂUUnÊøpÖã~—,YBW®\¡—/uÈäÉ“S¾|ùäólÑ¢…<+møÌ@`×Öµ4°GkúðþH½ŒØE:|û "FŒ*™ÈÈ‘3¿”˜Pœ÷SÇ”ýCB&±ÁÏF[{án¡× ⎙³Ñ½;~2Û¦Ô¡›±$Æ©£ûTg;¢¸‹¸yÈú3&¡Y“ÌGÞ^[´hõë×O)Ö;ûøøè]k/víÚE©S§¦ß~ûM›MíÚµ£3gÎèåáâãÇ„þÀNy­ÁéŽy ÏãÇK}¥¼Y³f´jÕ*åÒè ‡7´æáüÇž³¥eèG7L‹3Ðþ7u¿Ø‹,80/,^`‘Žx¶ØKàêå ´}ÓÊP'X£²Ø€4ôÏX¨ˆBÿ{·©ˆ þ*”°hÔªCoªT­¥LeIgO¢ #úЋçOiõÒÙ”,yJê.4˜Ãcém2RF­iíò9²úëWÁ²¯™Â ^¤Xir+U^8ëÊ ™“Üf»«Ý°MÕ_–o÷^eÒá¾ClºªXµ:žò>|xOógŽQ²©Ç€1T^lÄš0Q"ºvù¼”¯ñ».ÌÄ=ëבJºG9Å[ÓzË6ÝÛ7Îl\ ó7¥Mo#Þ^ ‘kˆ.fp¶»/C]{#lz{áì1Üç7é`GüíêÉ fÇL]J]ÝéUð Z2o m^·DÎóèÁrÃY…á†Õ Ug;Þrè5h~x/éxÆ8Ã&̧šõš©CBÚ¤ kIªU>} U+Ï ÖzQ*K+µNh‰þæ ù„÷´eÃ2µ¢èïß.d¦IgMnîå©g;éTV+ŠDºÍhʘò È·\»r\rP«@zfŸªQ Zð°K"zÑß0Hâ´lßS¦ñ¢àíì3SëFååB#œóÐ:G¿å«Éz¿üü‹Zò4†zïÑÅ Îð9Ëwªo TªV_pÙAÞk«ã;G,Ô–×x`ÄÄtL8ÚŸ?ÓýîÆŠÃýôñj»æbÃÝÂÅt¿³¡Ã| pâܳEÖ9qd/;ÜUZœ/[~wÔª™ì3ªéèHüóÏ¿bÿˆz]!Háų—t`ïañ6HÈ‚7¢Ûk}v­aÑ{Ý Ãߧj7¨®-ŽéôéÓªó x(i7›U ?zbÄâ³Ðiÿ³—É­`ŒV¿é~ï)mù̘`L€ 0&À˜@Ü#À÷p<3èx#:ò#pîB^2$0DþþûïF½@ç¼råÊR\)\»v­l‡¶+V¬P²õÎëĉr,8yÑæÁƒzu” 8Îáh†Ì ôÕµ†M\!7R´hQ‚ö7Æ„4 ¢£aˆrß·oŸ¶‰L#²z̘HRd6iÒ„ªW¯N...2âŽuDWÃ1üþý{µDšk 8“9xð Ô’Gô·bˆÊN—.r©ž±°I,Ú#Rýܹs¹%úÛp!20`“5kVš0ay{{ËçT¾|y½.‡*Ùác¼…–¹rå"8ö±0ý{Ô9uJ÷:;ž?ÛiÒ¤ÑëÑÅ Ò;x›‘ùŠ(P€*T¨ H2dÈ ?‹`ç¿ò<1·¥K—’—ÿ¡®p‹gH@š§­ÖÙ®ð€³¹~“vRúÎr8ÝÛÿ1H)õŒßO£¦,¦&-:Ñ*!¿×&#y”çOË…,.xT¨Nãg¬TõÅ¡Oî.¢øá ‡!Ê]ëp?zh½}óZ–åÎ_DjžãÂ&c&™‡à^³ìoª×¤­ü¹FîõðÅGHFØ¢“¸À1¨µB"’]q¸'JœXjµkËúé'á ™ S†…,þÔ¯__:9¡«ënݺ™ªÎyß™@"Å©qóŽ1:‹Û~¾jÿZ™5ÓDâÕ«‡‘‰âP³à<Î#"Ñq´éÔWF»C[|Ò¨~ôøQ l §ûùÓGUy™2å«œÄÁ/ŸÓ#ͲBEKJ‰›»7Ë6 D$}•š!Qžr±pñêÚº6]ší0èÐí8¤Ñ'¢Þ[þÖ#Ü9è':™%±ÐÐEÿZKl‘D{©¦ ·¦ ‹4½£©ãI>ظ|ñ´{ò°<œA ½toFEuLnh7ý0ìºî›6…ÈE–‹k8û#êl‡Ãò+ИªE7­ã>²sÒÎ%²}p»¸KÀ1sH”©[É 4zê’h¹8Éþ=ž=ÑIN|ýú…Zwìc¶oèŒgÍž‹nÝÐEÜ¿|¢F•Y¶`ªl¿{Û:Âf¬;7¯Qû3¥=¯º—©L8`¯_ gó!áŒ^AèvçÖuZ$æú{Ÿáò:¬bŠYXãF¤w7õ&_¾¦k·PãfõÕkÊ|Õ­fjXð=d¢š“ÅÙ‰Ò¦K£^GGâŠÏ5á¿.»‚3²3æ,{Ngµh×Ö½ê4j¦&qôÐ ±H÷ZÍÉæòŽšÎÄã 'Ô¿û`µvFÛ T¯q-õšL€ 0&À˜`L€ Äoá¿Ÿ¿ÞÝ+âP»|ù²”7ÁÆ©?š]»v-Z¤Þ6±3f Õ¨Qäêp2˜³èâ†ÍPµÖ±cG“šôÚ:†éñyÞ#_›'€¨ò¹òÓuß‹tÿîMÚ¸z!ÕmÜZ¯d[:µ¬AüïÊü9Ëwê•›»puîÛ©{›åÜ©#4~xoêÖo”Iýåù3ÇУ‡jWŒ1´Ú Zе+döˆA]éãGœ´Û 7`F_3&‘u ˆ R]‹—1úYuʲØÎF_&G«‘þîmˆÃ Æ$39áHþc!~÷®^ö·úVAžE©Diý ›-­ÒÊ háÃÂ#Éép³˜@ïÐöÍ»eÔºÿ½ª÷«-]7‡ì3éÝ54Ò‡ -6c¾¨æ÷²Ð¥fF1‘ÍR+V)KGêØ®_õ£®m{Ñ”9c~/]¾è+Êz«3ƒMÂùÔëð$ð=àAÀC:wê< ›=ãÅ:vkk$Û§”ñ™ 0&À˜`L€ 0øG€îßá™k#¢1üýû÷ÉÁÁ8‚kÿþýtóæÍo6C­ãøãÇRÃ}Þ¼yaŽùOœ8‘rçÎMmÛ¶5Yßp×ÇdkÌÙ½{÷d¤Z–,YÌU‰tþ¾}ºØÐ{4ÚeøãzëÖ­¡:ÛQ/º¸¥I“†p¿Ø¸†±{÷îmò³!+ð?LÀ€~·ôùk"µlPV– îó›p¼ß¢r•k’UšôÂQt˜6­]¬:Û³åÈCn%Ëôbú²‘Øðu¿ØÔT‰0_angoKpfïÛunùÝQÁ4òªGå*y¨×Ñ‘€Súí°dÉ“RÕš•BíÖ«ucÚ!"ÛOѽ©³Í{;|’òæÏM¹òºÐóç/èÊÅ«tãÚM½è÷1S†RªT)Íöýþݹð Tøðþ=ݹ}Ÿ>¼ÙgE)ƒäMCÏ:Ê%Ÿ™`L€ 0&À˜`Ä÷p~Þ¾}KÇŽ£W¯^ÑÉ“'ÕVp­Y¢=Œlî…heH’˜²9rÈ:Êf}sæÌ¡ PŠ)èÝ»wtôèQ1b9rD¯y@@€øãñ9Á1 Ã\°Yè£G:]eäÁQ½{÷nrww'l|ª4˱)§Ö îáá¡FŠBRí0>lþüùD}úô¡%JèmZöY8ÉüýýiéÒ¥4vìXúQ¶É™3§¬+/4ÿdÊ”Iïž.\(ëi#²1ÖºuëhÙ²etúôié[»v-Õ©£ûC÷Žg€±¥®Xpp°Ñ3Hœ81¹¹¹Qúôé•jêYëüðª]»¶äJ¸¯C‡Ѹqã‘þZóÇ=bqAé':¹M™2…ªU«&‡Ä<Š)Býõ5iÒ„,--Õ©`1ÀÏÏN:%Y]¸pA~vð,*VÔ‚Uq"^(âVš:÷L3… ~?-˜5V†7o›É‘f.Ùª~Ž Ë ¯ñ{m¬UäYËîÝñ“ÅAþ4gÚHêêu1÷r4vúrõZ›HeiEe+Ö¤][תٙ]ŒägPèàä,uÞ‡è,ëîßå-dh¼ÕvÚñUŦ¬Zs+UAóáýÛ GªÔVÒáŽz1ÅL;‡È¤ûY¬M”@IDAT žDÂæ°ÐÁŸ&SMk7¨NŽècª(Jy»·ï£WÁ¯dUkU¦¤ÉB¾Ç˜êÿO˜1‚šÖn-~NîË*Á/_™;ê·ïÚ:T­wt‚ßgE${h–(QB<º?5iÞ ´j\Ƙ`L€ 0&ðûFâa˜@ØØá6#éÔ„¦7œ³†§yÆ ³åu§NhúôéFeÉ“'§¼y󜤰åË—KG36ÿ„Ãè™2D<[[[ÓæÍ›é×_¥FÑÎúrˆÖÆѪU+é0G?pâÃùÿôéS½nË–-+ÞŠƒ…6l ¢E‹ÒÝ»:¹‰íÛ·8Û06ØOž<‘ŽxS2+Ê"‚Þ@âÎÿB… Iç0ÊV¬X!7[µ³³“U‡V‹¢‹[ÕªU Ÿ›3fȾñÌ:wîL]»v¥téÒÉóß>}RÇWC† a‡»#ŸÛÿ1ˆ\K”¥aý;Ê 6µ([X­á¶Ô¶s_Âfœ1è«oÜëCÞ"J~ÞŒÑj¤¼aÙ…F»W뮄(vl¸jÎ +£u¸×¨ëi®*5jÖAhEÛÐÜé£È×çœQ=l~Z¿i[òjó‡\¬ÓVèÜ}0½¬îÞ¾Ž>ÿ÷s£,˜)õbŠ™ÒdΩR[ÒÂ5ûiþ̱´nÅ\!ó¥ÿ;lËW®-že?©ë™1¸ P+Q„vÚ@Ã¥“GÏPÐÃÅ|¥4ÛêO%ËW²¢õ¬•“ièY7\}C?}÷1oZ¾p5M;“àp7eÅK¥C{të#cøäœ= åÉŸ‹r‹èù¥Ý(k¶Ì‘éŠÛ0&À˜`L€ 0&ðƒ`‡{80"ÍM9ÛÃjª•.1¬‹¨ö *¢³apžÞ¹òª¶a}åm8¡q¾wï^%ÛèŒHqŒ?ÙnèlWœ9s†½Eœºp°/^œ^¾|©T“¯b?|øp˜³ž={JG´¹ò¹sçJù•b3@ìˆÒ6g™3g–²6(ǧ¦üæÚ"õ!ËcèpÏš5«tÄ·oß^m®Ú¨yµÀL‘åXÈH–,™¬ÜÆ/yãù)‹/8ÃÉŽ#4à l±‡À©k!¿UérUéJÀ?&›­ÞvÚd¾6³ [ٸ璔R¹q͇ž>~(dG)sÖBª!…¶j„Òaª×¤ ÕnØ’î‰ã®p¼ß‘‘òl¤¼ "ÒÃcÿþ/dqðjBž&4+_¥6áÀ¸Ü—÷”J,d°µ—÷e®-¢éGO]"ÏŸJèŸZd˜í>úïmDù›{ŽÊøãÄ[8LEú žH]z#¡Ëûþúõ Yg°R=9Dz1…Â÷žë¿Í¦”…ç móI³F˪OŸ<òPW„ãý±t,甦¶ ýóÖ¦csÂÃÿÃpä» Gv"±˜T¨HþpwƒßK-Úy’g«Fâ÷ÃCº'dqüï=o®%oÈ8cf{²´Š¹¹›šè•{aÿž6ÕŽó˜`L€ 0&À˜ˆûØáŽgèéé)eVàô -úYé šÀˆæ†þ¶9+\¸°”2©Y³¦Œ7¬§0dD6mÚD>>>²ÎÝÒ¥KS»ví„öh*6lAšÅÐi ¹8™ál‡¹ººR‡dd<"¸ƒ´M›6mTg»6}N›6M:¦_¼x¡--[¯ýöÛoRŽÆ¨‚&QýX„mT½¦ŠÐ¶ý z÷¯HÎüþûï„(x´Säk´í Óøc‹X0e˜/¤y —cj¡Î?,jxyyÉ{Óö¡pSœíJò£ƒÌš5KFÝ#Ú‹"¡Þ:(_¾<5hЀðybcZp®Ã‘݆ß/öŽYäÙ¾·oZ¥6-UöW²NäðäppDƬҤ ³YL1 sàP*$MšLnˆ‹MqÙ˜À· .}Úh×hmÞøÒ®SËЪ„Y†·×œìåfe®À˜`L€ 0&À˜ˆ!ìpXéøGÕU>7"ÆY y8¶!ýÇmþü:§ $BÌYß¾} GxlæÌ™„#¼–6mZÂØpHÃá=q˜#¼2d‰®Õ«èªãóçÏKç46\…sÛÅÅEˆjÇ‚…¡Çž={ ³£t…‚5jH'>åpèãÞ°-ÆS6²ÅGx-:¹áó-{¼pýúuy`ÁÒ>ÐÄW++«ðNë1ïJàëׯôôIˆ:M%uÔ·{¯TçÓ´U5Í &À˜`L€ 0&À˜`L€ ÄUìpONq6Ç‚©MÚëÅŠ“‡Qa2°©,Žïmˆ„‡–=Žè´èä¦h·C7ž ÄeÁ/ŸS…¢ŽF·P£›²1&À˜`L€ 0&À˜`L ®0%ŽëwÄógL€ 08C _Áb4b‚83_ž(`L ¦Dt¯š˜š÷˘`L€ 0&À˜@Ôp„{Ôøqk&À˜'äÉSÊ @ƒ_¾ h’çÌS -E Å›&lL€ 0øN`Ö”ybh'ª\­||GÁ÷Ϙ`L€ 0&Àâ4v¸ÇéÇÇ“gL€ ÄI’Wëßã΄y¦L€ 0oH wޜԬ~;¹Yí1È.SÆo8:Ř`L€ 0&À˜@t`I™è"Éý0&À˜`L€ 0H(æ^„’§HFûv¤ònÕéïi ›M³1&À˜`L€ 0&·°Ã=n=/ž-`L€ 0&À˜ÀH¹{”ÓmþñÃG5xUõ¨GçN_øï–o‰ 0&À˜`L€ ü¸Øáþã>[¾3&À˜`L€ 08D bÕrz³½qí&Õ­âI}ÿø‹‚_ë•ñ`L€ 0&À˜`±“;ÜcçsáY1&À˜`L€ Ä3åKR‚Æ[,­ZºŽÊ­FëWyÇ3"|»L€ 0&À˜`L î`‡{Ü{f³Ó'üM‹ç.§â¥Š‘]¦Œa¶‰é ¾>Wå/_£îýFÇôpÜ?ˆ=y+æÁ“`L€ D•ÀÕÛhíÎQí†ÛG3ó¾w£¹Gîî[`‡û·"Íã08HÀ××WÎÚÿÞ-Z2or¼ž2`L ü¶oÞþÊ\“ Äo^¿¥][÷Æ‚™„Láæmš4cIH§˜@< ðèÑ£xp—|‹L€ üˆ&L(okp¶ã`‹X$ãY™%Àw³h¸€ 0{{{ ÁÒ*-eÉ–“0&À~HçN!¼Ñã’+;¥L•â‡¼G¾©¸EàAÀC GDì—_~!;{[²¶IG?ýôSDšFKÝ×nRðËW”.%åÌ‘%ZúäN˜@l'pòŒ}úü™Ò¦MÛ§ÊócL€ ˜$ЪU+ºuë½}ûÖdy\Ì|ب^Ù}úô©<Î;'ë\¾|Ù¨g„Àׯ_iܸqôþýûð5àZL€ 0&À˜øÁ T÷Ås—‡ë.=ʹÓä¿ÇPjËÔáªÏ•˜`L€ 0&ð£`‡ûúdãÖ}q„»™çÕ¥K“ÎvSÕß¼ycRÅT]Î3&ÍC///Âf_lL€ 0&À˜`DEK¦”)ÃÞÄ·k~Z¸z6;ÛùCØ`L€ 0A€îü1ˆ 8ÂÝÄS¦yóæ©%...Ô£Grtt$D¾?xð€ä;9c·`åZmĉ˜={6=š®]»&/îÞ½Kžžžêƒ+3&À˜`LàG!€€„2J‘÷úm¡ÞÒ¹Ói׶}T¹ZùPëq!`L€ 0&ÀâÅ?ÇîñáiÇÞ{d‡»‰gsöìY½ÜÅ‹S‘"Eôòø"ú ¤NšÜÜÜdÇH³1&À˜`L >¨ðkY“÷LvpÿŠ¦w—ä’+98Ù«yœ`L€ 0&À˜@|$À÷øøÔcß=³¤Œ‰gòøñc5¤ÆFgû¿ÿþKwîÜ‘GTWí^½zE—.]’ûÐSŠAÛþâÅ‹äïïOŸ?ŽJWÑÚöÉ“'ò=z«ä>|H7oÞ$<Ϙ°>ÐÕ«WéÓ§O1Ñ=÷ɘ`L€ Ä r% ßEµæÕªí;¹…ê4¬¡f¿~ý†:´è&ÞÄäÿïU(œ`L€ 0&Àâ%v¸ÇËÇënš#Üÿ{$Û¶m£5kÖŸŸ={öL}Pp@+Q×j¦HØÚÚRÕªU©eË–2ûË—/4uêTÚ¿?½xñB­Š:T¯Ÿ?N3fÌúðïÞ½Só‘ؾ};YZZÊuê”<”á0‡#Þаbªì/§óæÍ¥£]ÛN÷E‹É9á^°`L€ 0&û @V&ÀÿÍ^<…²»8«†~öâÉT½lð  ,X»b#å+˜‡<[6Tëq‚ 0&À˜`ñ‰;ÜãÓÓŽ½÷Ê’2âÙ$I’„R¦Lᧄ¨a%"ÝÚÚ:\í£R²(ÚˆfÃQ†húÇÉë   ©¨õˆœ¸X”Ðóˆ7çl×ÖÕ¦áìIƒ3½D‰fí†c#Ò¿P¡Bê[ iÓ¦5¬¢^ã­S–+W.SÙ2Où|`Aó2å(7ÕŽÿ ˜*"sŸ!HÓ`ðæ Ÿ8ÞÙ˜`L€ 0¸A zíÊ´eßZ=g»2sÇÌ4~ÆHåRž‡ MW.]ÕËã &À˜`L€ Äìp/O:vß'G¸‹çmL8‚wìØ!õ´¯]»F;wî”Or"¿ÿþ»ÑS̘1#U®\™ìììd™‡‡‡ŒNÞ·oŸ”û¸wïžQd :ÙÙÙY:Å!_‡¯)ƒãÎSÈÇFOCS²#E‹%h€c®(QdSåŽyƆ¤bp ÷èуòæÍ+¸çΓ÷€HnÌMk†à—/ÿŸ½«"Ùº÷½ÝE,.ACРÁÝÝ‚ ÜÝÝÝÝÝ%¸»[ðàwwg—Ý÷ÿu*TOÏdf2‘‰qï÷uºº¼NOFNÝ>÷²ÄLÕÉ‘#•)SFJ®€€Ææ€Íœ9Sbªê™êªü:7kÖLzy«þ çÒ¥KÊŸ??9;;˹`ð"ÿþ½¬†'êÕ«'qÄ&ÂÞ½{¥Œ¯¯¯,O‘"µiÓFzc½,ÎðáÃiúôéò^-[¶L[kªT©¤ç<0ALâõˆ>4h –#Ï‹÷<ÖÍEâ›>¡‘&M¹“6mZš0amÞ¼YÊã”.]Ú¨¿_é⇈+°÷&mÉ3»’“szíÚRâøá=ôé£ßë%YŠÔ”Õ5èA”_½xFçN•CÅŽ ùuï‡Â{×Ö5*)Ï1cŦÂÅËåYº8ú½|ñÔ¨¸T¹jôG”(Fy|Á0á]ÛöiŸ™²d$ç´NÚ$ïÞ¾OH±fqãÆ¡ ™ÒQ‚„ñ­U‹ðeqÄ:­Y¹J¥¨]—4cÒ}d25 ë•as¡U«V4`À¹é¡ò¡µû ƒV<<Ë•|_¹r¥$¿UæÚ¾}{¹áv_¿~•E;w¦råÊQ¢D‰TU)Sƒùáù¯¿O¨„×B×®]iĈ5jTÙüž ‰š”)Sj}ýj °SÇ ‡÷oË¥W¨êA㦯° ÃçO©]7úGÄi€ 3;X„ûµ+ç©{Ûº²¯ÌÙr1á.PxHPļï<÷„âÅO¨²ÌžñTO§îôî­!î*¿ôŠbG‰g¶ g2Œ@øA {û¾ôù“_<›þÃzîö¦áÆÚ4Yî…Šæ§!cúR@ä´MFÀJ]ût ³§|èÔ‰³rö>¡Î­{ÓÂU3å÷‚¸$ž2#À0Œ#À0AB@qkˆfc –” +äƒ0.¼¥HU‘íú.PU‚¾šJÀ@?]WÇz²]•áŒþA +ƒ½Ò8WyЭׄB$/Èux‡ƒ¸ÇÝb!a‚ñ@ÒÛÞ^OseX›)Ù®Êpv,ØTI˜Ð@èÁ_<Ï•A«^y»#X©ÞÔ5ž4¸}ÛÄEy‘"Ed5‚ûöíÓšà"+ôúAä›ØÀ†ºÇÀ‹k[ ÷ ^ò «ÈvÕ› ¿2Ù®p(W¹–JÒ‘ýÛ ^ïÖìð¾mÙŽûR¦‚»µê\àÿf·‰×»¹nO?àl7WóF r#ðúÕÚ¼~;U(êN—|®DîÅZX6*§/˜@ ¤ñî=B“ǾÛXhÊÙŒ#À0Œ#ÀD*˜pT·3Â.†=Ü#ЭƒŒzã06¼Çõ¦—/A¾>è)<ù-‘íªã£G–Ò4æ$u@ƒ`_³ÆO ?¼õõû˜äo*V¬(=®£E‹¦º·ËùСCZ¿ð:×{¶kºôÕ!ÙÓ³gO™ yhÓCF4 ¬•”Êðcöرcºü¡^¹r… ±£7E¸_½z•¾}û¦Á“> ìµÊ?æžX0­ƒkl@š2l–(W¹&Í›>JVøòù´-\¢¼Å{wlÐÊò.M±ã²ç´ˆÛ7­¢ºÛYaçÃ-V+r!#ÀDh¢FB}‡t÷·†?Ó…s—„TØ!YöìésêÙqí<²Áâ÷%D¢Œ„‰ÐÌ…Éí‰ógê¸Y”'_N!ÓU ­”—Â0Œ#À0Œ€eoÆî–1âû#À„»ý1ó@†ë%n\]]mšS¯^½‡%ƒ|üøñiÁ‚ÒcÛ´¼¸?.HÚ@{¼= ºçÐW}{[L_äú“'OšíØÈ›7¯ÔUG?ÐJ¿wïžÙ.áå®$`Pý*°©~£Ãlc2m%ܱ!Ãd{À€B·=¥SZMVfïÎ ÷oß¾Ò±C~ñÐs…ªu€k„ÎyÓ“G÷)Y '³ýáÉ„}; ›!f+q&#ÀD þˆò5jQßâZV-]K}º –å¾×nähJ•+n±~d.È“?AžgH_¿eüÐìТ;í8´ž“%‰ÌKçµ1Œ#À0Œ# `Â_á–” wÁÎs€Ç¶zÃÁPðâ ‹+– Š )èš7oÞ\êП75¢….¨¤Õ³>ˆ,*ê½ðõ²2ÐÛG`ZeÀT6ôAjõí’$ þ[Ó9ªqùtô²2‡ön±ø?²ýûw¿' ÿ^²lU³ƒ¾~ù\ó»é°¨yþì±Ù:a•yãú%Ú³}ñ>L #Sƒ|˵Ëçi÷¶µtùÂñDÆWÓ*f¯¿‹'7|Ξ ƒ{¶ÐÛ7¯ÌÖ J&tí•íؼJ%ýÞ-ÙúýŸëÛø«h’ñèÁ]:yl?íô‡„\﵋ï¿IS£Kl³ógŽÓ‡÷ïŒÊ,]gll0\ö9Mûwm¢—ÏŸZÂjþÓÇÄ&ÅFºzéœæýjµIáÃûwäšÜiR—Œ@Ø"P·a-£À©>g/†í„Âxô&­<©‚›_LåÝÛ÷Ô¶iúñ3IO‡gF€`FÀ®(þ‹=Üí 3wìá@‘¡2ÜSÉž P(d^‚c<t¡B…¨dÉ’2à§êoj?&ì{ö쑺ó_¾|‘šîÝ»w—AKUÝ:#¨+tÙU€YHÝ4iÒÄh£ÁÜX«W¯Ö²!1£×t/V¬˜Ô¤G…Giõ@@UTï8”)9\#ªÞÚ¶mKåË[–/Ñ×UisªŒÏAC@/+óæõKº ˆãœy ûëL/'S¸xyŠõgl­^çKçM¢…³ÆúÐ[ì8ñ¤JëNý5=~}¹¥tÙÎR¶j‹7eÍ‘×_Õ®­ëHý†MÕdW6¯]Býº6•õµìJµê· žíëK2]uò»ø?©×¸=õ8ž0ÿqÃzÐúUó Ò:Êâ'HD]úŒ¢jµ«,£ó½;7h`téüI#Ò6UêtäÙ¬#ÕmÔÖ¨~`/ª¸{JBí +Ó¢½_ÀbÓ~ôr2ú6¦õÔõŽÍ«iÉ܉Zß*ç¤ÉSɹ7lÞYŸ-Óú{rÚ÷ö>D£u¦Ç O¼`3¦aó.Ô¶Ë@ŠjF:+¨ccÞ½¥=[È͸ùNÎéiæâ­´IÜ÷¹ÓF"‹ê5iO}‡N‘iõ÷JËL5Ú‰îƒòä/FƒFϦĎÉTuyÖ¿–€óv½hpïÖ´S`K“>)QA¦ù#^prNEÐr‡=yü,¼L+Ìæ1nêpº!¼ýïÞ¾/çàsö’ø?I#& ³9ñÀŒ#À0Œ#À„L¸‡ÊaÂòðð è°[3xÂ{yyIÝò.]ºÉ•4kÖLzu;88È€¢aQ†77\ã([¶,eÉ’E’ß(‡7<‚º&H`ê¥Ú÷\¯^=6l˜ìf÷îÝ4tèP7×÷Ô©Sî0Ñ<ò$ÓTÒ-ýúõ#¢5'÷¢'Ü!¹“&Mm#`Û¶mR3>UªTú¡8Ê@V&…Sz$”²;3fÌ lºè s»qã†|r }ûö„§ ·{®7HÌlÙ²E⧔½ÿÞ#à ½¶½ªËg¢ò•kk0ؽIK«„÷±}šçw´hÑ©x™*ªˆÆí¦‘íÑ£;HÚu»ÎÑæý—¥×ùŸ‚ІAªep¯VZ»ÐJìÚº†¾ ¯ux;ïñ¾K›ö]¢²•jjÃO7P’íØDðÚ~šö~@“ç®D|QQª\5­œŒ@x@`çÖ½âÏð¤Qº iÂôÂ|é3¦¥Q“Í£wçAtË÷¶Q_XG ŠxŠ©¿x¢¬NãnòÝÿ—n¥ÊÐBáí L-¼Áá‰îíí-=ÐMIçC‡Ž¦M›Ê@¥èR-©S§öGvCæóPÄx™2e$)IHؾ}ûÊ’3ðÚ†:<òѧ©aÊ@¤#À¨2Ç*À*ï”)SJRÿÅ‹BÿÚX3D·Þóä>}¤¹®æ­ÆÄùÏ?ÿ”žãÊ[zé+W®”’5Š`Ç& ȲÀ«Ò0æÖ7wî\JŸ>½¾{™ÆÆ^zkܸ±¼¬_¿>õèÑCh^ûyŽ!SïÝ.+‰?•*U"¼V@²Ã ?B½cÇŽRÂ26x]/=®²²ø3dÈù¤®¡#ñAÆ™6d̽Vñaƒ×)6$Ø èee -²kôr2ÅJW&!Á;ú˜æ)‘^û([Ž|Z;Èmä-T’<«’ä­÷Ñ}´W÷,S¡†V'4 ƒ+V«« …Mh¹+KŸ1+›±R]RÇäBŽá9 ï×^æÁc]oã‡÷Ð<»‡MX@Uk6ÔŠØ4gÞ"T­tV©¿jÉ j֦ŎëGàkmLTªV¦÷“=عeµ¸i$µs³—Ö“žœ×2u ½Þ¸c²”4fÚr#Ù—VûÑõË>â)‡rcÎçìq*Z²¢®C2±ÀhÅ–âýÄAfº×mF¥Å}-/•ÜÀÿå­W4‰–àŒ½uÃrº~ÅGŽ“ QZ¼öÖoò”©)Gî‚”PäOÑË0A] m7z-’9Îi3’׶ÓÚº“¦íbÒÚsåܗΛLz ×õà—„„¤”&Î^CŠ”öWÎŒ@h ðï¿ÿ£ëWo …ÿ··¯ßÑÁ}GhùB?¹#T€w»[ óÿÃFü"ÕjV¦‹ç/Ó¢9ËåŠáíÞªQ'Ú²o Á žÍ6jU+G#'Ì••·ï>,>@Ä[²m»Ñß?5óÿ›Âîne,U tþ²U[¨Ç€ñ²]7Z:wt ûàŒ#À0Œ@dF€ ÷È|w#ÎÚØÃ]Ü«£Gš%Ûºú@™úº•+W&xAë D¯5²]Õ…7<êîÛ·Oeù;¯[·NÓN†g»^?\_ùÌ™3’øVyݺu£Ö­[«Kí wxV_»vÍ,ÍýÆ‹Z’£ùôé“ô¶qoJ¶ƒŒž={¶6.çÎ l7j »žX£Þ€ýŠ+üyу‡g»)ÙŽÍí ÈC}ú¨ÈdžH† dxê×®mð’F¦9ÂùãÇ—Øë冰)’ýÊ•+Ïwsd;Ú.lÐ?xð Y²õ,H‰X*þe󕬌Á(•aSII– ¯¼›á>¯[µ@U#7÷Fd»*H“Î…<68Ö¯4´Quìy†·¹žlÇXÐ)©®¬BUÿ‰Y²çQÅâéšÇZBìÞ,¯ÓeÌbD¶«JðÀ®U¯¥¼„\ H÷ úRr6Ïž<$˜Tôæ wtÌ-I¡¨ú9ò¢9ËwÊcÞÊÝé¬ÊqþòÅ aÿéÃ{}‘Qºa‹ÎÙ® ϣߨyòèž*¢àŒ­ßT¨]¿¥F¶k‹Dý&¤¤Ž>O¥—/œ¦½W´^üæ´åA°«/£¸__¿|VÍÎíº f²Ý¾m@W(ZÃè¨XÌ<ݛӂYKÅç§ßoøŒí3¸9ÄðÛ íy†×ñ€‰«3Q]÷ž¨K>Û€@­êå´Z?}¡‡1´ÂŸ‰õ› O'–.Q€âÅ‹#KR¥LJmšyÈ£¦ ñÙF€`F äP¿qÌ9*†ühÜ##`&Ü.žžžÒ+Ó¶~ÐÁk]é…›¶AùâÅ‹ :çð75xÄT¯^úôécT"wĈÒ}›ó¸†úèÑ£µ~óæÍ+å^à¡®7â#GŽ$Êz›5k–ôø†|@æââB“&M"ÈÓdʔɨ:æOöråÊæ`Í0çµk×ÒáÇ…—°ñàÒ¥KS£F(qâÄÖºðW†ú Éá¹ojÐbÇFDóæÍ¥¼i9®!ƒö›iÑ¢…¹*2d·ž$WÞíªi[K„;6)€=äŠðÚ È%J$å|6mÚDcƌѪC˜¡?[ ¯µâÅ‹“¹'liÙëèeeöïܨ-÷ŒŒ v˜CŒ˜T´DE­ìîíëZºbU-mšÐ—éֳۘǵ³ üÍ™£ Ý•%^Φ†@šÊþOl)ƒ×¶2Ǥ)é¼ ÀÍÆö#P÷ƵKªIÎzÏuOUv`Ïf‚¾>L_G•›ž±ùQ¨XYy€ ‡½|þT?]½tµmT…ð‚-fª%¯Ú$H䨒ô?ÝÓ@Á[ÿšÑËi‰D!…•+_Q}––¾å{YKã §¹ûxíÃ>úHØX15<ÅQÇÓÿF­i=¾fÂǤIÈkëb±ñW=¬§îÆÇw™‹&QÜŸ¤/&¸cónš3ma¸›kxk6J—ÆðºaË^‹Sý*6ˆví;¦•{¸¾CdÉ”ŽfN(^]šku8Á0Œ#ö<~üØH¢Õ’c£¥™B©@ÉàBÚ•-ì`Â=ì°ç‘ ünHþº)H‘€Ø II;þ|IX?~\ê¸#€&ô½APÇë§ñ RÜœõîÝ›pØbÐX7Õƒ·ÖÒ58îܹ#ƒ˜Â»^õüñ9::ÊdzÖ¬o(Óþ@Vë½ÂÑÇéÓ§¥æ<>˜ ó‚µâù¯ÞðLûÁ†6'BÚ ¥>oÞÀMËþCÿQÍ"ÜYÃ!~‚DšW´µ…$JœÔZq€eqâƧÂ%*С½[%i}âÈrÍY€p†AÃZæ$iº#œ•á €Ôi2ˆ##+]‰¦‰ ¯§ÅS !mA¤aŒ˜±´ ½?LDëçùùÓý¥Lãµ÷ïÿþÕòñ:×?©£Ø€Þ;#ÖD…†íÖÓˆðã)Qº÷ëHã†O‘kÁ{{Û¦]iûÁu"&D‚¿>{/²2JÇýÅ«7tâ”.Ëß°z9™ò¥‹Pìر´:Ûw¦ÊµÛÈëÜ92Ó™Ãkµ²ÔYJÓý‡Oåõßo.ÒÎ=G©M—!ôôù+™—Ö9%ݾkø,Cæ²Õ[äô´qý¨}«ú´dÅ&jܦ/²¨B™"´cý™Öÿ¹&çfÎë&³ˆ«W÷Oè‹ Yˆ@±^v$tôö»p–©\¾8ÖÒ¥uÒqš`H…â§tWä­µÅ!nœ"Û­Õã²ÐA@Ý3Óßä¡3:Âø!À„;¿Fà—F²2ó¦’@ÇPß¼z!¯!‘R°ˆ±l‘sZº|á´,ôà!`¨9{,¼å•A?=šØü Œýïÿþg¶zP½³Ívfc¦’bAõÑS—ÚØ2xÕªÔ¨/ wôY™W/žIw\Wª^§mp¯VÙŽ`¨ƒÇÌ¡DIŒ7þ#žH²‡gl¼fnùúIùÜ¿{ì†;æ¬âB­äzJ§´âÉ„k2 OS:msõ?ÿ±6j®|fÐE mçtöäylö¨ø¥ s;4ïN+6.Ðä CwFg4ÈÊèIï[÷ù#ÜOS•yÔ4Èɨ<[λö#wÏNôN¦Ì–v!Qçù‹WT²Rº~Óð=Fß/æ´iû~áy‘ŽìZFiuR;úzœfF "#ÂöÞ½{R·xñâ.E=µvLò—Ý+0ánwˆyà_Ò6€ÄUF ò"YeÎy‹`Ÿ3Õ%•*_ÝŸœ†^]¯-®5ú™Ð—¤·ÅâÆ3x¾~ùÜlü¡mNδ!±Ù€€¿æ ïzTÇ%ŸSæª*¯xé*3–_lƒ"hëF¯E²ýïB^’3æésÖàµ7tü|d;úPzýõ˜òàŽ.£AÒkýê…f‡¾wç†Ñúô•RëîÙ¥ó'õEFémVh÷ìÇFe|Á0‘ü+DÒÁ»A³NÚ¼{K}:54ÊÓ_Tq÷Ô.çL¡á eŠ‚Æö}àžážB'›`"?±ãĦY‹'S¡/®lÞÌÅ´gÇuÉg @VFÙÝûéâeC\ä¯ß²GKÓù–*_ò(.³á ïQ%¿ ÓÖË`¬gOZ¿iÜ°îZ³F­ºjiN0Œ@äG «kf2¦ŸÑB»µíC÷ï>0Êã c”¬ŒÊ…¬Œ2¼Þ¢Û´¨ã^Aú ÏöE³FPP û@ø³™…3GÐîóäÑ¢±ÿïGŸtšîï?| êPÜŽ`p@Ñ¢EÉÙÙ™¾|ùB Ý­Ù¢E~Oá*’ÞZ]|¯1b9::RŠ)¨lÙ²2íââBݺu3Kp.\X:Í;—@†W¬XQĉMùóç—?Ò}ûöÕ†2dˆì3cÆŒ2ž]Ö¬Yeì¾+VhuLˆë‚vˆË—0aB*]º4¹ººb,XΞ=kÚD^gÈAÎmãÆ’øÇ’%KF… ¢Y³fI‡ßèÛša-¨×¨Q#kÕl.cÂÝf¨¸¢` w;‚Ë]3Œ@Ä@ |•Z4Æh£É–­TÓ¢ž-Èç—ϞЙ“‡éû÷o4aD/£¶ê"s¶\4dì\u๎gkZ:w=ö˜þ?zAºãP–!Sv‚¶÷Á=~,ªüÐ8ç)PŒÚwL3' •’2 g%¦Mû™K·™õ&7­kËužüÅ(q’dôâùY3š±ÕZ´ïMƒ{µ–Õ!/ÒÚÔ“¥ÔtÞ—ÍŸLÇ‡üôÏMëæ:¸cOœåE½:6Ðtì±Y€CYûîCèoáM3wšÁÛP•á}¦Ö:Ó¦=«DÜ‘h{qvœ=deTðTîƒû¶—£:zšÞ¼õÛ°Ó*–-äY´lR›¢‡Á=À“NeK2š÷·oße°Ö›·ïÓ…K¾4g¡áI@£Š|Á0Œ@$B@‘¿š YKd:¼ÇÏ;'7zzzÒÌ™yRS8Þ¼yCµjÕ¢ƒýžd¹íääDׯ_—Þ྾¾tûömZ»v­x -Šis‚G<6P?yòä”:ujé½þîÝ;5j¥K—Nã˜C¼xñDýÇéÚµkôèÑ#jØ°¡$ÃM5éìµvíÚtìØ19fŒ1({öìôòåKºsçy{{KÒ}ܸqÔ©“á)\Ó Ö¯_ŸÖ¬1H¬¯\¹2mÚ´‰V®\)К¶Á5´òá­kÚ´©<÷îÁEÛ‡ìá(rŒ#¡ÐËʨ…XÓ?!-\³ŸzOñ$RM´sì8ñ¨uç´bó Ik$ ¡²pÍžõøÂoû…«÷‘^ç=€îB¼kZ¼î¥Ë˜Å_ߘ{ý&hŦã”Ä1¹¿ò fÀ»^ 3ËV«Y¯õ6•pÏL-ƒK6y×í:o\ƒ;vŒ˜±hÚ‚4hô,ªX­.¥JNίͱÓWPëNýôô£Ga´DÔ_»ã¬¼/1b•á8“箣– 1þ*q#ÀDj†ŒîK.™ q:|¯Ý¤~݇Fê5wqzY™KWoÒÝ{d—¶¼Ý«V*EÑ¢E òP.œƒÜ6$bó aËÞ䜵 ÅL’‹²¨F5t¦áãfÓ«7ïBbîƒ`pjü;räˆ$…ÍMd<¬\¹rÒ«\^Xøïoí©R¥’}>xð@e± B:Nœ8R ¾uk?g!Ón†. ô“'OJóB Öa «A¶:TÊÔ=zTÊ >Èox×ÏŸ?ß´[j×®$Ûûí76l}øðŽ?N·nÝ¢›7oRîܹ¥ç}çÎe¾¿Ddu@¶c#`âĉ´{÷nBýV­ZÉêèò7æÌËËo#7mÚ´rCÁ\Àæ1áXĸ¾=`w{ Ê}2Œ@„C`çÑ›š3>Ķè"ׯ^HI™ÿý‡2fr¥ÄŽÉ,öU¬T%ºòè_‹å)ÒЂÕBËOx¹C/ý‹ÐBÏ•·ÅŽO¶:ná0µªµk¶lÃkÅääœÞêÜÐ8gžB´qïEúòùݸ~‰^½x*6œÈ9mFA³†úëÚw´<,õмë6nG5<šÑM1ß'ï‹M’Ä”ZÌ7AÂÄZ—;Ý¢ ÂþÛ÷¯”%[n-÷]-m)1q¶eo¿àŒñð:«U¿¥<ÌÿB¼N”9§5f*›}†N¦ÞC&ä€A´è’¼O‘Ê<¡cËkIõÏgF 8\¹Úbóæm6û"OöÙK&Såµî°õ«7“k®lÔ ©‡} ½+Y™ÛwÊÀ˽KûF¤——ñp¯¬Õ¥Hæ¬öÁi‡78Hò%K–ÐàÁƒÖ )±åË—Ë}|OÞ¥ÿ-GŽ"¾àœ´X>¢j‡©p—Œ#ð‹ Ð¥w{:'Ècïc~R?=¥Î­zÑ"¯Ùš§Ø/E€ËÔËÊüOx,®^¿Sk\9­# ½gàÇ~2@úªN©’j—¾7ïÒÓg/)©£A–Þ~3ç­Òêèž<×.ûÍ¿_Ú.÷ÚªÕá#À0‘E Sëð:/^¼¸\òëׯiÛ¶m2 /ø€ KaÐ9×µÔºî¦fºjZŽk[êèÛA[¦÷’×—«tâĉéÏ?ÿ”òæwHÏX²¤I“Êà©›7o–²2лW¦ädš5k¦²BäÌ„{ˆÀÈ&܃ 7gF€`ìdd%IJ‹f§wo_ ½ügòÐU¼LêÒ{$¥IŸIŸÍiF€`ˆÜióÇSÅâîôòù+ÙþÐþc4iÌ ê*Èx6cjU+G£&ÇTI(¼ËKËg\1„¯“‚€ï;äMÓf/§É“P†t©É%CJ뜊'ŒO/^½¡¿Ä“ j´¤v-ëQ¹R…žíã§.¢c'Ï›U.„Ðü%ëD¿ŽTCxìÿùgLºæ{‡&Ï\J[vÔÚ‚Ì¿wÿ±$ô£ 6F€`"# ÔA¸¯[·NʦÀãANüøA™3g6«KnŠƒÚ,…dŒ³³³i±¿ë$I’ø˳g†"¨­¡ê˜“iA°TkÖ²eKá¾iÓ&úúõ+988H)xØ'H@JíXkØ2ks l_\Ÿ*L¸9nÇ0Œ#ÀئmzPƒæéÔ±ýtÿÞMzóê%ÅŸ’¥HMÎé\(uš vžwÏ0¿ Q;sáDòpkB›6~6åΛƒŠ–Œ8q;BãžÕ®QÞá^SðŠT±×ŠÌEQ£ü!Éô/_¿QÇž#åPÓÆõ“„;ˆï½ÚPûîÃeþ¥«7©U§ÁÚt ?P”3KËS‰j•KQFAÜûÞº'ûï=h"áÐÈü"Àî·ïÆwÎV–V/Ou‚(V?§F€O@n$ùÝ»w%é®xÌi[ AGl´jÕª4lØ0[š„Jx¶Ÿ;wŽ”§»¥AáqÿáÃYœ!ƒÿß–$kTПO™2%=|øP’îõêÕÓäd<==­ÊÙ¨>sfÂ=0hq]{!àÿYA{Äý2Œ#À0Œ@ €Ö#ºBb¦S¯áÔ°E*U¾“íF’0Œ€-äΗ“ 7jƒ'[§V=éé“g¶4ÿeê(Yý‚ë¸WÐ_Ú%,ibZ¹p<¥I¨E. ³Msš>¾?ÅŠé`Tøó§£kå« x²ïX?‡*—/¦²´3HþšÒMŸÔ·»Aï_«À F€`")xU=!+ƒ ŸŠ VŶX¦L~O£¢5Û°aMš4‰öïßo­Zˆ•)òüèÑ£ÒcßRÇúù¨6–êšË‡Ô’Y±b…¬¢äd ñÒ¦>Íyã‡ôXÜ#` öp·„ ç3Œ#À0Œ#À0¿ ZÔ§SÞçhÇæÝrõïÞ¾AT»ÐÚíKCÜ -"Ã{ë®@M¿’ ²ÿŽ¯iÃ{WŒÉ™–ë¯k¸•!ß…—ù«×o)f Š7¶VÄddšxV§[wH)§”É(GvMßÒˆR¤H¡?~ ¨)—3Œ#À0Œ#¢Ĉƒf/žLÑi«lå’5´iíVuÉgF€`Fà—A@O°Ç‹/Ð>§OŸ.9"8iV¯^âĉ#‰xGGGÊ™3'y{{SôèÑiëÖ­òZÀÎœ9SrZˆÝÒ¿(ûO*X° ¥K—NðÈ% M™2EÎ78ó‚G=ìùóçruëÖ NwÛ2án.E˜p"Øx¬»µjÕ¢cÇŽ‚H(ÃŽà«W¯dð ¼y¡#` ¼fÆGoÞ¼±VËF€`F€5ÒeLKc¦ 5¯w—Átãú-£<¾`F€`";5jÔ X±bÉe‚(Ž5j – §ºãÇSÏž=¥·7ëNœ8A/^¼ýÀÓüÔ©SÙ–Ð4þ”Á\öëׯ’ü‡w»ƒƒƒ$ã±бcÇ`O«B… ríèxÆŽmC v纘p×ÁÉ0C€5܃}‡¤~—-Í?}ú$Rÿô¶´á:¿*àÊüùóáúµPàÕ2Œ#À0Œ@xCÀ­FEºpî-œ½LNí»ÐônݨmÝ¿–bÆŠÞ¦ËóaF€`‚„%•Ì‹¹bĈA=}>lØ0I\›kôä¡Þ>}zÖÒø7nÜ°Td6ÿÇ)f˜ ¢j¶b03÷.Á†›3V`ÂÝ*<æ ß¿O F•¹¸¸P·nÝÈÉÉI/ú.µ·=z$ÏŸ?¦öíÛkRª ŸSfÏžM£G&D>ïÒ¥‹iq˜\ãvÚû5®U"LæÀƒ2Œ#`oþþû/9Äо£éÏØ~žKö“ûg"ˆ1SHÌ|þì÷#ùžÄY$gYJ/<à•ÝºqG%ùÌ0Œ#À0 Bª áÍàu^¸pa»LkÍš5ôîÝ;‚'}ñâÅí2:eÂÝnÐrÇ@€ ÷@€¥ªž={V%åyÉ’%f£LUâ FÀ ã–)S&j†N•k×®ÉÞ¿}MgO AyF€`ÂëWç¥FÓäapÀ»·ïéÔ ãïÄább< F€`F€wÀ92º0(F(RÜU}³‡»=Ðå>mE€ w[‘ÒÕS[ÈB€Ô‡þO|Ε­X’'IiÖÅ aBgOžÓ¾Ý‡´nñƒ¶L…òÿæÈÁãôàÞ#­ŒŒ#À0Œ#ÀtíÚ•dvÛ¶mRB'qâÄÔ¼ys»Ä»]áåÎmD€ wÚ¾};áñ—›7oÒëׯµVˆä\ @íZ%’%KF•*U¢&Mš¨,:}ú4ÁþÂ… [ÙÆ)I’$ê’vìØA^^^r,-S$T¢GZdk C‚Àýå÷8<ƬZµª¬wäÈIl£ôÆùzüøñ6áQ€+È|œgÍš%ëâÞüþûïäééI£F2Âý`ß¹s'íÚµK®:eh£ì¿ÿý¯$ì¡u†„hÑ¢©"y6‡? €Y‚ hĈ2øræ’1cFtdèС²Ž,àÖ½hÑ"Z·n¦wí·,Y²›› 0€0W{˜Z³K–œÔÄt{ Á}2Œ#ælX½ +Ó¤U*P8tU…ùâyŒ@ ˜9y6Y¶Âw<¡ï¾ýà:z+<Þ™p$˜\`F€ˆä€£yûö­\%ø…+V™º˜v]5îv…—;·&Üm 1êÔ©£‘ú&ø¡BÚœ­_¿žrçÎMY³f•Å5"___UYŽŒU»vm³c¹ººµ2d-X°À(ïîÝ»’ðù¬7¦8zô(ÄF»~ýúé‹ý¥ñ¦ˆHõÆhZù Ðq(Ëž=;U¯^]]Ê3¼ÌAVƒ”7gØÀhÚ´©ÜPÁ3T=luêTòððPÅÏæ´Íþþûo¹ñ€ÍD2_µjUŸ:°800Œ#À0Œ#`‚@›NÍéì):°ç°,yõâ5uhÞâ'ŒoR“/F€`FàWG‚àUà” þúíö6&Üí0÷o öq‹µeäT'zôèRb$°S†G³ž Å£3Y`Æ2×¼ÒMÉvý˜(CäiÙ– d|ãÆ-’í–Ú™FÏF0 Û°D¶ëû1%ÛUY¢D†GûÍ­õðæ S²]õ3¤X@¼ë ê¶6êׯoT]ÿT‚¾› $fêÖ­+£“T7 rxéã©6F€`F€`ì~ÄNš5Š’§L¦ -÷ëW8‚'F€`F@"йsgš1cõíÛ7TÈv Ê„;¿øÂìánÃ]€Vö‰'¤üÈ]È«@†)N:ùë:çåË——R)ªpíÚµ²Ú®\¹Re1–··· $/Ú<~üبŽºq¢23ÐW×tåAšçË—ž>}*Ç…§øçÏŸe5x¹ïß¿_ßD¦!{3fÌ£üzõêQ•*UÈÅÅE’ð Ö!cù¯_¿juõR1Èlß¾½[U€w9dcòæÍK¿ýö!øìðáÃ¥¦»ª£Î={ö”ÞøeÊ”QYR.žêçΓÊÛÝ”¬‡n;°fú„ hóæÍò>•.]Zë x¨;ÌO!ËÌ™3ˆ}lL@ÿuàA±ýæÍB4q>0€/°;v¬‘LÊQÁ@°^󇦽{÷Jo{µ)‚yƒýX3èÐOÔutt”÷¯!Ô}ãÞa,6F€`F€`ì‰@ì8±iö’)ä^¾ž5ü[uïÎ}{É}3Œ#À0Œ#`L¸ÛW²3L¸Û0ÈbH…À 9¥wµ'N´©—„ Rƒ (-îè(UªTÔºukÙ§F¸«7 5¼á!áY=áéì ÂÖ+W.I˜£=òa`15Hž@–E‘ÁèdµžôF›%JȦ(«V­šÖ>ˆ'ˆeýAvoØ°ôAR¡gxxŽCÇ^oÐ\7Õ%‡n<¼Âq€ìV„»j‡õAÚé*P*<ìAJC#,eÊ”ªª<—,YR’÷F™º‹L™2É{­te ûË–-+/OåÊ•åb_¯Ëø X­²9rvw¡C™Èslh`s¯%s†G¯ ëŸ-[6­÷´bÅŠR—_ebnL¸+4øÌ0Œ#À0öD K6:¦?õêlˆÁƒñ>}þbÏa¹oF€`F€`¬" ¸3p.lŒ@X!À„{X!o§qAŽ#ªzƒÑƒ€ªŠpGàWèÅÿùçŸZ•«W¯ĩô6%ÛµÊ"r‘ÓÕËÈ€(‡w½žl— ÄÖ  á ½ö Zœ8q¤Ž9ž*05çÖìÛ·o´gϹi ÌR@ðt7•LN@r2xÊÁœA³þùó皎>t÷½žP׷Óؤ15øÉ“'×6dð$#À0Œ#À0¡…@î2hêêeë´!½O_O@~#‡èZ^xM\ó½MW®Ý2š^Á|âûU²$Fyæ.Þ½û@{ž0*J—&åÈný{§Q¾`F€`G@ñaL¸‡8´Üa `Â=`E„ªð†Vo.¦ó%ŠQ¼«õvñâEíÒÁÁAÊ¡h„G<Æ­P¡‚VK¯§/pÈ X2å5kÖ¤)S¦Xªb5O@ò21¬d?dc‚Cö›Ž BÝÙ®êB²>~ ƒl%ÂÝ”ôW}à ì”äz2A_ÎiF€`F€`ì‰ÀàÑ}é’ϺvÅWóáãgjÝy-;ڞÆHßë6í¡A#§õÕ©Mš<¦Qž¹‹å^[©cÏ‘FEZÕgÂݾ`F€`Bʼn1áúØóˆ˜p7`ñ˧ô23D1•t1tÝ7mÚä¯:÷Ê ‹ÙRÇR ûK¶ÿøñƒÊ•+G´ÔmóÓ§O`[¸FÈ^õ»^<(‹I‘"=xð@6UgkýØRÇZûÀ–AçÞ”l‡W:¤[ðÁÉxŽC¦å¯¿þ T÷*Û®];«m>|ø ÑÞ'híÆ]tÿÁ³í_¿yG›·ï§ÝûŽY¬c®áó¯d›í»Óã'ÏÍU 0ë;tô4-[µ™ž<}`}®À0ŒÀ¯ŽÀúõëéÊ•+F8¿è«:õéÓ:™­§Ï¼qó)ëI&ÍC…ÊÖ§ªuÛS"ç”!gš9o•¾ª–N¥4ýçÏLòø(ÑŽ7›’¦/Fe«5§ÚºRê¬eÈY¾7ïÊ6/ûRÖ|n”0u!ªV·•¯ÑRÖ©.ÒÏž›÷ŠÄ÷Ù‰ÓS’4Âù#]1Ù¦rí6”Â¥$%p*@ƒFL£þñÓå×&ö3¡Ÿ¾Oc!mörT¢RcjتU¬ÙZ›¿góž¦ÍµkŒ¯ÖY´\-ŸŒ#Àüê@¦wÑ¢ERÇXìÝ»÷W‡Äæõ+Î' ÞÆæ¹"#XÃÝÐN:EðBÖK€¨f ¢ëÔ©£.ÎÐñž>}ºQ.bÆŒIÙ²e#Y¶bÅ Z·n!ø'sK^@ X'N,IçŠ+’‡‡íڵ˨xkãhÚ´)0‡ÄO:µ¿GJ–,I… "hŽ+Û°aåË—OÛ0Ù‹;Q¢D’È~öì™YÒYó¿ÿþ;-Y²„ræÌ©ÉÉÀ[†ÂËD¹­ͲÆB†ÅÜ&03wð& üÛ¶mk4 ‚¥b~êD£F$^HòäÉúøñ£Q}ýÅäÉ“ ^ È ËcÉ{XÛ„ Ênð ïwSƒ·<^3 Ý“$I"1ÀÔëGÕǽÃÏú¡C‡ªìpq¾÷&ù^ Xë4vœx”,¹%Má$É{ÝGÞûy…åÊ[„&v4W-Ôóì5¯€°ûý÷?(MúL”*u:›‡60¯^<£s§Êaq )ÚSôxzÌoé ÕÝGDiðíÛWºzñ,½{÷š¢FFé2f%Ǥ)"ÊôyžV¸+HÁkW|­Ô0_”Á%¥ËÆ|¡™ÜGŸÐÅó—eI¢Ä )o\fjqÖ¯„@Ô¨QhíÒÉT¬BCúñ“¬1nÊŸSÚá[BϳŽ› Úý¾ß­ðÚJîUý/[-äd”yÖ©B'Nù}ŸWy¦gx£7mÛŸ>1~êõnÞ~@íº £+×nÑÔq}-~÷(ˆï)³–™vM÷„—{A¬OÕ[ŒÑÞ xSÛ$¼ÝÿŽ2;ÖÏ1*zùê ÕÄý¡cgŒòÕÅ›·hè˜Yrãaݲ)ä”*™*òwÞµ÷¹{v¢Äï"e%Šæ¥KWnÈËÍ‚Œÿúõ98DWÅÚyÀGYÃzUU’ÏŒ#À0ð&P"¸yó¦?Êüú‡G½â} »%J”"ÔûaÂ=Ô!çÍ À„»PL³Ž=j–l7­gz­—.1-ƒW{™2e4ÒÑðøÈ@hƒPQ®÷”6mcà ží–ô¾Îœ9CðÞ¡ ù ¸`Á‚‚€y§u‹qñXKÖ½{wID«rZ»v­ òâ…á±Rk„¶jkzF€Ssd»i=ý5êC–Ç”p‡W9ˆøÖ­[kÕ±>½×¼V`!MldĈÃ_®]»Ê«7šÝ©ÍÉô‚àþ#Œ¾Ì9°ƒúvnLïßžœòh؆úð¿QVÿWÿ) '^J‘Ò˜t;uü uoßOŽS¼TaA¸“zž@$k~‘l¹Úr äs¥I£{SûîÃeÞÿÄw²úÍ{Ðù£ë)eŠ¤Z½ð–p«X‚bÅt OŸ¿ÒŽ=GÄ“„Ÿ(vìXFÓ„~; ò3uÜ+X%ÜïÜ}HžÍ{ÑßÂü7AšôìÜŒjU/GqãĦÂèî9`<½Ò2³¬¦?cÅ ÑC»¥.@¶—,šOüOw¢T)“Òñ“ç©eÇA’`¿ÿð)ըߑâÇ‹M+æ¥ÂrÒÛwhòÌ¥´dåfÙÅνG%©Ÿ%S:Õ%uí3F#Ûc"|HßöTªx~A°üAœ&üèçÜ…kb¬´g³Ÿ#Ö.u€lÇ“ E å¦xqcS*¥iÉŠMrŽØlغó À«¢®IÉ›Sg/ɼèÑ¢R­jåŒÊù‚`F€4F½ÂyPèÙ³'3FeGŽIýúõ£,Y²È§õõ…P"˜4i’tüÔçãIý&MšÈ§ö#"ñ΄»þnr:¬`I÷ôô”ßð̶Ű 9h“[²Ü¹sK)GGG³U@ 8Pz« wáÙé–رcËþá•mjx#=z´&[=õ6mÚHz}]HÁàÍW‘íª ùØáÄøñât8U¹þ-Z4>Ø”7nœœBÕ©\¹²$üᥭÞôTÎð4‡.äW¬4âK—.MÏÇBñâÅ ›æ¬U«Vr32/æ sŇל9þ‰…›9²}Á«ðH_¸p!õéÓGzÐcÁÆʨQ£HO¶£]ûöíÍ®1nܸäîîN5kÖD5ÂkëJ•*•¼VðºË•+—Í=ª]x<¿yõ‚ÆïIƒz¶ Ó —súöõ ?}Œ&êK­T4"QÃå„áI5¨^„êTÊ+çχ Ÿ>~ðG¶‡ÉDxÐpÀÆ5[©J©Úò˜8jZ¸Ÿox›à¯Œ_»–õ¨N Ú-ÇtÍ)G+Öl“×QÁ¾ëBêÖ± ¡]¦Œi ÷îØžåççfÃÞƒÞ]{Kæ{ëž¼×7Îï • ÇÓô ñž‡êÕ28E¬\»Ý_ó5 O T­TÒß憿œÁ0ŒÀ/†drá|ÃSî!i=zô±ø ?~|ÉŸ+VLr@¯_¿–üNƒ íø’s j_Š{ ¬ÓfPÇãvŒ€9ØÃÝ*&yñØ´i“Inð/AÊÃcžÕ'yûö­”~¡ëêê*°¦oÞ»woÂa‹Íœ9“pØjØÑÄØvzéÒ%©kmsÌR(Ø(.Æ!lÍðæ ÙxÜCÿýAj›Ð7G?zïnÇê Rõ ¢y3FS¿aSÍbZ™é2f¡#g„Öp<Ž<q”*VŽŠ”0x¡ª|>G¢EJÃÇŒ< â•DbÆŒAëWL¡¼Åëhæóq[¤`.jN Ö’Åò‘câôìÅk!­rJuLâogõz?²3Ÿ±fð†W–2…£”Q×úsÜ8†'høÔœü65HË(K–4±Y)¹â{¼2}Œ¨ë7 2–uu^誮:£Lî×oÜQÙþÎØ40%ÛQ)wÎ,”Å%-]¹~[zú¯^òÍù=±y[xÜ«à³I% ²¥ ùë—3F€ˆìØBdC²v„ ! $rÕçB‹-4²ƒ€#1b­ZµJÆöƒ‡½-ó Ñ ³3&܃ 7˜p¹“à }w}pÙ¢E‹§;nÁH锆\2ç  ç¼åJ@Õ~ˆÝyx?¸w‹’¥H-t‰³PTe‰0æwñ$ÆMßKôäÑ}J’4… L/¾ßî ÎÉ^íbljKSæ­§qÃzÐ’¹~Þ ëVΣíz[õrúø]»|ž“¥¤Œ™]¾lÙk®–ú Þh+½¶ß¾¦ì¹ Phߧ¿EŸ³ÇEP¸/òuâäœÞ,ùaiíÖòƒ»6´¿tá”Ðá~Dù –¤ÄŽÉèó'CpèX± Þ†ææ§Onù^¦×/Ÿ‹ÿ‰¯"PqR¨×VŒ#ò}5‡çÙ†À÷oßEÀä ò‰6'çTäœÖɦÿ ´»zù:½}óŽræq¥øHv˜Îí}Î]¢gOžSÁ"ùÄ{wbÓ*Ú5¾^ò¹B‰™Š@±±…®¶-öøÑSºrñšòíH™²f Ó÷M[æÖu@ÃÓÝ£‰Aæ¯uç!R¾$kfÿÒˆa=_Ä?ÑuÉà¬Õ3M4O×tí;Ff¯O (ÂÝkƒAN¦~Êüd _3Œ#ðè¬ß»wæÍ›'¥_B<ÑRàÐ~Ÿ={¶Ø8nÔõ•+W¤÷=k¸ÁÂŒ€Í0án3T\18 è'ds ¦ *AÊ:çoÞ‚ö•*UJU ÷gÈÐ H‰ÚÆ„¡g€ˆÐüÇæA@:øá~‘a0ÁÿY!e9óÞã ûÞm„¦ùQúçŸTW’ìÉ’= =‹2fÊ®å›&®\{h›xi[4¼îõ¦<õyH§Hæhš¥]{zT¡^'Ðñ}ìÐÑÓÚ,'£AÄ F€ø…زe‹Yµƒ/_¾Ð£Gdl¸åË—ÓÆ¥±Íqí¬Á ‰à%JÐhéÒ¥RÚ¶jÕª.¦`Á‚”4iR±±lxJÊZ_á±L}^™~Ž…ǹòœ"/V+ò®‘Wƨ •*U¢Fi]‚¹žl‡&=Þè#‚A?EŠäááaD Ð*ÖY½zuJ˜0¡Ühˆë /s„¤ÌµËç´é¤ÔŦ5‹É½l:}â ÙŽAž_ò9E•ói^àÚ@? –=«–^ßz²ÅøÀÞ»sÕ¯Z. ‚×C›Á½Zkd{Üx hášv!Û1ŸØqãQÅjbêú£iBzÄïÔ±ŒÈvT‚ü‘;È£J>I‚«†Ujxª¤ ÃN2ËàÒ2&ö l”Uª^O%­žƒƒ÷îmk©vÅ<äsæ¸Ñÿ ĦˈþhXßvþ^V'ˆBàÕ¶qAH¯1"ÛÑpoåY‚5$ÖvìÐ.êܲ¦F¶biÒ›½ií’´~Õ|d;ú‘t`÷fjT³8=¼gScDäûªÖÀçÀ#ðþýª[­ íºÕ¦z¤W/]§FµZJÏsÓž·oÞ-ƒ²ž=uÞßÿò=!;1°çpê/ˆtýªi‡÷£Ö:kd»i¹ºÞ»ë ¬§'ÛQö·9kÊ|°{Šªª?ˆu5®ÝšÆ˜bD¶£ÂW¡»}pïr+SGzËk8á1C»QAôS‚x6nÝG]†«3›"P)ì¬ÏUºqó­Ù°K^'OD”,°ÔbzñT‡²2% ÒÙ#ë<–ÍóóWíìuÖKÔܹ÷Ðâ0wï6¥ acN6ÿû_Ëñ?X¶rùbr <1¢ò4—J§D²eÉ`q\À0Œ@dF eÊ””6mZâ»U®\™/^Là`¾¾¾Z:$0Ùºu+µnÝZzºC3^îµjÕ¢dÉ’ÉM€~ýúIýø+´û`Â=´çñÌ!À„»9T8/D8sæŒø!ûw€}öíÛ—F`½ðRžì[ooýRåÿ §s§Žú;ŽÂ·O[ªçV@ê·Gî@ãf¬$G!åb«Ý¹u]Û­¤w7Ú,ZFƒÜ{òÍZºÊT¨!»úG§ôÊyAÔê ¹ðæF9 ^ÚðÈÞ}âŽðúžEY~z¤#¨kÛFUÌ‘úþá Ò–0±#-^w(PÞñ²a ÿ8§Í¨µxüÐ ÓŠÌ #zÒñC»eyÚ ™iÚ‚´÷Ô}éµ®HrxC7dë;!σ'>$R”íݱ^%µóÍë—…·¨ßXñ&¦ü…~R%8xcc¦WÇr“–› 霵;ÏÊ{5bâBMRÆkÙl¹¹ M4kWÌ•A~[uêOö\ ÕÛNQý&„׉ßã˜ð Ÿ=y¸1“ðh³<üVÙà1sdÞØé+T–Œck›(ž81ŽÀ¹ªz‡ðöoØ¢“¯ZíÆÚxy ×æ–áç“ÓÆžð~ZÂqâƧîýÇÒšgè°Ï3éŸ)kNÙ23kz‹è÷U¿–È’þñãÚ¼~{€ÇioÃfg¿¡=hÁÊT«^u †…óÊ<ä—,W\ËW xăXïØ£ í:º‘¶ìó¢Æ-ëS´Ÿrð~Ÿ6ÁïG£jó@}[õ’Ä5þ—ÛvnAÛ®££>{hüôš¤ÌòE^‚𞪚ù;œ ™"˜GÍŠ6É#e¯3e§…Ì‘é&¾*»æ{›,]'Sg.ªl»žõ0 kÉV®Ù¦éIz-ÓÆ‚§*Ãjóy,U!ÃgF€`Ì#дiSí©ùýûý‚q›¯¸\x°Ïš5‹ž>}J , :uêH²½€ÜGÐÔ4iÒÈà­ë9ìk3áö÷€g@ô;ƒÀØ777jÒ¤ íÛ·Ïh‡ô÷ߧäÉ“ôÃÚ¶mKEŠ±÷TB´ÿ=zÐÇ¥¤Ì_:) 5$eð˜¼ÝÙ @ê^±Ù!GR¶¢{@ÕŒÊG,ÿ)!SF´a× å…‹——øšå~„< A"B6qdoyƧ}†NÖ®kÕoI%ʸQùBi%¡ÿáý[:qt¯Fâku‰:’ ã/X½ QooK0‰6äE@ºbðºV²6 彶Ö4í±±¹‡˜"ÞÛKçM¦N½üã*îžR^ï„{ý¦´1Ø¿k£v]ÑÍCÃTË4“Þã‡÷Ð6F†ý?{gÅÕ…á¯-ÅÝÝÝ ÅŠ»kpww)îR Å‚»ZÜwwww‡¿ÿœf²»ÙÛî~çy–¹6wî}' É™3ßï¦9½\+$J’9óF•’YÔÛ¥ó§jR=Tô¿1( òöBŸß&™%Îœ-7"FŠ¬${ä—/œVW½ó¢š‹ØO?z|½IYä[’$K)EÃko"IS¦b- 7[»¯‘Œù¥pã»3]Êñ$6Ö&u±½»<J¹C!¨Ý°µ•ÅŠ]ÃÆÏAµR‘ªGîÖ»ÔÑÞï«Ùf¤òéã'tjÙÓÇÝ”,S yóçRãò¸xEêE7ÑC/aÅÑ®÷ËqösÔTjFœÙ‘4Ù‘c»pÎãAŽªhÿ 8Öˆ†;eª×ñ|Ë-IÒDj=¿¬¬}/·¥hݱ)¢Çˆ®Ÿneª”Á˜ß‡j߃¶_N0>ÖlY‚=ŒÕÖô¥ËT,‰üYK*§¿|__ºxŇ9«=@X¹Øãç[ê´)ñÏŽ†äLBÍ¡Ÿ+oµ¿%óW¨óÝþœý;kò\þãglÈA ’ÜséÜq(U¹9¾iA bý‡LFþ¼ÙP¤`žPµëzšŽ{?íg¼ˆªlw÷ žðœŒl$“–,4‡&¥tBûº|õæ.ú Í\=†ê}ûö*Öj =’|ëÚàyøÐ̵:æ-^«–±xù:4×Ö•ßäíé8wá þt[¦/ÕÐ^7üP([ª0$1êÃÇOqDÓ¿}ç:;Œö»I½Z^åÖü05‡’ €Ãç±DÁ>|z<üõ˦?~ìíðøñãCœúò»pá‚ʱ7{öl¼yóFE½ßºå!YéíD¡¨“÷Pt3œx)Œpwâ›\[§EsŠNûíÛ·Uò´Z?ùÈoùa.Ù¯íÍÙ.ìræ̉ 6àåË—fûÒ÷'É`—-[ùŒæw][ÕBû¦UTJßœ-‰MþëñÄ_¢${ k8Ûõóå?ÞN½†k¯D{8c.?…ó§=":Å9)24b‘"GQNFý<ý;n|t×æ-Q¦Šú¼yõRïòr5¨ –ΛªÚ“hNö«w‹³].(ë×Mœíz‚ÌEs¦(Yék¯9Q­%»þ Š8ªß¿{«¦2••9~ø_%9¢_CŽÛ7{üá.å Õ¼ê:K»©„·Ük‘3K“>³™³]¿†8±kÖk©ªòð@öØUKT[Ûµ—ió(j´Ý»ãé¬4½)æÞ$²]ã–Îvo.¯ºD dè87-ÏÀ&õ©Q¯…—SÞ½{c´½6ù>p„ûjlŒ?¤£ šÖñr^þBùŒ¶;·îy–µ¤¥[7îTõtÒ˜9ÛõAI“'A½F5UUä[Ì^ªw™%²]"â½s¶Ë ÍÚ¸Îv}Yw†Léôªö¶ŽççÍ\düÜìÖGÞ` gŒÓ =úw2~nÊúÞiNTšm"Ç2bpgcÀWíÿ©Úºáá#ó<Æ€*$ÓøÖôùM-“ö†ƒÈÍøÆäw‘‰£zC[v„Þš–ùÁçp]K¾:oÑT¨ÙÆp¶gÕÈ–,–ß”…BÚƒµúµ<Òä”JVjŠq“çà¤öp@íSg.AáÒ ñêµÇï¿jë’D±þ5 ~hX×#Ÿ‹ÌñèÉ35Ué’OsÄÓH€H€l7¤®^½ª¤KçùûŠ4è‰NÅ·bË$ù©¥¹»»C$r7nô ²ÑÇdÈS§NE›6çˆG’¶Ú“éÏJ BŠ€GègH]×%p:â잯9Ÿ­™8À·mü þÝ®~ºo[‡žíê)¹ kãMÛLAf×"µ&NfÚm”£iNR‰t-v19/KŽ¼f¿©ÓfBä(QsL u4«|¼³?' ÅÙ“GŒ!EKVTöFC,¡ÊžÅ®\Éýß#$¶=Œ³z•Ü92aÖ”!VûüÒظ~ŒÕœú¦F9S,“ €uS¦LÁóçÏU§e ¢(ˆ­]»2Îòo‘÷•Ä¨–vêÔ)tîÜYIÈHrVÝAm:®hÑ¢˜ñ|Õ0IÒ”êRòˆ)£.-="F}ZÇëW/Œ!å.úûb[ׯ2î¦r2º¼q’B@x_»|ΘU’¼ÊÇ'{e²ŸÆú¶_äw¬™þ žµ>ŸÚso)ÓdðérÞö>àŽ5Ëæj4þ…HùæVG¸¯ÞB±ÓΟÃþ WMÓ<¨M¤c¬ÙÖµ¶Ëšvµn’xT>>Ù«—¯­Iý=Á¥ÕN“F[ðÖ¾oåkþêåëÆÙm{FeV ¶Öhe¨Ó6 ï3F!W‘F„÷^-‡@þcµ¨ð>¡†KÊ¥ÐAÓo—(pù:Ö£Âý²À½ÚhIVó¡MçßpVKjkA{c¢EãšèÓ­âÇó|0å—ùý;V’™îÜ0“¦.P:úzÔ¹>_¬˜ÑЮE=Èúuy>½Ï?ÇŒÚÛùrgÅ¡£À£G‹‚JåŠûg*žC$@CàÚµk`K“‘qGº¨ˆ‰¯.û¢Ï›7/æÍ›Iz:zôh´k×Ñ¢ESÝÅÞ°aCíí¼ðê|ý9/îñó÷Þ½{hܸ1&NœhèÄK¿H׌3FŠÈ”)âÄ Þÿ£Ô…ðþ{oþ~ Àex* xK€woñ°“H $ˆdK”¨Ñðæõ+uy‘0ñÉá®ÿ§*'øô«i¿~Þ'M[^·ˆ&’,z›_ÙsåG´è1±{Ç•(­_·¦XµéLfúuNߎ?¼ßÝšø»>¸ìùÛÿ<£­…§¼îî+]¡¦–T¶#>k9 ŽÞ‹gOk ãšËÉTõYNF®Þ¦²r}‰È÷ÉâÆKèÓPј{‹Ÿ0‰¿÷4mÂo˜6qˆq¾¼-6CVMo>²åtÑ4´c¡sËF¿^à}ÕIðèß¾ýÏ;N,C7Ýh´Rˆg-oÚ-æmòsÓ4Ú=S–ôøÁ?7{MŽ4_ôèQ±z‘¦ß^¢.>~ú¬¶6iÚB%ãù¿0Ø»-äcËbĈ†O=Þà²5f}ë<è@IDATÉœqwVÐ%'Nü[{âNkoiÜðÉ5ÉšôZ^€(QÌslèóÜ8»]/Z=–(šÿ½>oµOoôimò;P—öÔç‘ö–ÁÉÓµ\8ß=kzˆÞ¾wæÓú¬kš8¶VÕ2V%š¬Ç6 pTÕ«{™ù´¿¬Y³*¹ZË ’+oøðáÇy¿~ý0tèPäÊ• âȧy–,Yлwo´oßÞìÒ>dÈ 8 ,ÀòåËÕØ1bàéÓ§8}ú´Ê&‰U%rÞÞLÿßôï~{Û×kÿèp·ÿ{È€Cˆ9ªápüè{L™Ú3š÷έkÞŽ¿sÓ³?ej¼äšŠnïÝÖ‹^Žé{ç¶GÄ£H‡HòQKËíRÓæ­S’,‹eÔô|ߨèò©š³KŸ–õ~IKÒyhßNcÎÂÅʨ²8ד&Ok—=þ8Ÿ0}…Ÿ5åå!ˆÈãlÝ°J=DØ®ÉÊ”(S'îWׇ ‰“¦0®í]! ¼“§ô”„È_øWŒú}w—²«¾ÀÜÛ?øíŠêÔñƒ†³]œ4’„Øô<³f¼¯Ö¨°Í”©<¥¿ iÎÃIÓGÛêcû?ÚŠ£÷ñT›äk>YŠ¤¸rÉãÿŒis'ªºÍØágÙµ¤¢Ó& DÓvýs›´é‹Ìš$OÚ4É6G)ˆs]œï¡ÑDK½tÉBA¶´«×n©„©úZ6©¥y$ °B a„Ȗ-Š+†N:!lØ°^FIôúþýû!Žw‘Žùøñ#öíÛ§%t„²eËbþüùV%ed¢@$i&Mš¤ìG5æ—¨ûJ•*)g½DÑÛ›ÑánowÌ1×K‡»cÞWîŠìšÀM?\4ÄuKœ4¹^´y4•Ï8uìDWÜšó÷Õ‹çø×}³1î¨Oaâ8) q’›&ÕOè¡iÊ‹CR¬×à VîMZw×÷EVŸÎZ’Öá:ªñs§EɲU‘%{Uì?¼ßzµ6¦•ç*5õ)Ó÷ÓÚ’šH냴Âú¿ãÓ§ª©R W³×+Vo îÒ¹uÃjå„Õ#|“,UMªýÞɵ}èvæäaåü7uë}òpá¤öµ &:ôYsx&nÔÇ„¶chØ›©3]¾~äÍK{õÒCGÒ²÷Õ’ëÞH™ÆóÝ©ãgl~/_ѤgŽñˆ2N«9bsh²Áe©´5ê÷GOÙt¸¯]¹N{sÇ#J»ZJf?7ƒk­öz& «á vgÎ[©¶ðZ‹¯Þ #íZ®%}ö{ {åàˆë–D¸µ\"Ïž¿DkMRG·ù²#—¦ O# g$ЬY3È'°,iҤرc‡öÕ\¼xQ鸋£^×s¯]»6äcÍÄQ/Ÿû÷ïãîÝ»xýú5âÆ‹äÉ“#jÔ¨ÖN±‹6:Üíâ69ü"ýþæðX¸A ðåËìݵ ÝÛÔ1»|æì>?U—¤ž.…J¨óä•åqC{h¯E5›GÃFöÑžü{ÈǤ˘ ¿'øL›> ä#öþÝ[Ìúc”Ù¹RýrÝÙ.õb¿V’ƒ·V[K°ª;ze]ý5i™/Ÿ=œ2ÞžèËNÙ“$6'yµRÙqúÄ!ãÌí{ãg“Hq–ë6ã÷ájŸz]?.[ð'zwrÅ ž-±fù\/N#I8+r"bG´«—º©²¼ÞX¦b-UöÍ?á:]&CbèÖ+j–×”{Ø®I%µÙËÛ7ÖuŸ-Ï Žºä1ÐíÝ[óu…†½=¼W_Lת7Ê×Ü:íëÍš9ó}µÆÃÚLf½Õ‚¦¥Õ4E¦Eì†ýºrñ/Ó¿{ûMëµC¯ÎÕ'°×àå‚ UkyþœŸ2~†ö0öÅ`áœeèܺ·ZßòÅ™ýÜ J~^bÇ “ÇôEÎlžoª½p­: ¶ãqéBà·‘Ó-q^¤ÌZ ;v{+ü µÞ‹€H€H€™@”(Q'OäÌ™Óp¶ûöM/‘ì%K–„È×س³]öL‡»oï<Ç%F¸%]ÎM$à…À‡÷ïаZ/íÒ #_¿ziÖW»ak¤×ã¾±>C&£ºætGûöÍkÐƵ¼Jì™!s-Bñ,þZ:Gµësõæ™É]œ"½~›ˆfµKªîÙSGikyòUê"a’äˆðqÃzꧢTùV#èß 2ïàÑ3P³l.¥ƒ'Qעݩ×0Ë¡>Ö-ÙIý––ìõÇ÷^έR«1ªÕ1œmü¼ù‹B"øo\»„:]оûošÃ+Ü»{·cÞÌñÆ\Zu5ÊzA^/,[¹–Λª¢QÏžòxõÐÔ¯õîÞêÜAФVqu‰Á½ZáÖ«š¼MeÄŒW{0²kWÎWo9Èqç/ìq_½[Spõ‰‘¼A!öû˜¨\ÓU9¶-[M½1Ð+„÷–1«§ÜÁꥳ‘ abíÍŒjÚQqíÊy,œ=îÛÖ¸ž<Ò"b´7JD'_$hüû}dï÷Õ oµˆáì© øje¿–-Ž±S<>Å5ÑLÿWs˜Í›¹ ‰œVr¤ñe¢R[–{>`xoÔ©ÔX éÝen\¿…RåJ vœ˜8´ÿ(V-]‹;·îªþôÓB¤g‚ÓJ—/ü…òâÀ¿‡µ¯ÿ¨\ª.ºõnÌÙ3iÉ„`¯û~Ìš:ÏXR‹v²‚’ŸÙ…ì¼^Kºjád•DõÅ÷ĸ‹–¯SI6Û·ò]n;GàË«ý1u¸äõÝïuN…›$ tt¸:RNèaüqO &=‚Düê&™¡ÃiÎ šu¢W& >t3yŠºH”÷‰#û|\”ü'YAKÀ)ÎGßZª4”s{xÿÊ -dùXZí¾.½G gž‚f]ù C»®ƒ”C\¢xW,š¡>fƒ´JMŠeÈØY–Í6ëi3dAãVÝá6ÍCŸxΟc”´L¦ïÑõ6O´èð ;‰hï«=x¨Y¿¥ÅÙÕA£§£C³ªJSþú• èÚÊzTzÇžC!`kV©zCåp7í󋜌~^@xçÉÿ Úw¬î•p¦ò±´DÚÃ’i ÖQ–ý!QÏ_äWÜÔ”ˆíÙ¹Q}$Á®Î;¤÷V¢tÌN5J=”‘·1&Žì«>¦¬$Yí[-:ÿ“ösWø”)˜c§.AÙJµá¬÷Õ”Oh,¿|á‘„Ú§µ½µˆàÎë’KÓ ýŸ?Á‡÷0¸ÏH5Åo£úØá.¹̃®š{Ò˜iê!ÞôßÝ KK¬%˜œ»ìÏù^1a0Z4쀫š–»|Ú4éb¹eŠ$¡j\ €ã ÃÝñî©=2¡ð®I†èdÉ’!~üøH’$‰ñ‘ä4¯¾}û† * zôè+áV¾|y¯ƒÙj ˆ$I’d)•,LFm±vÇŒœ<_EÌúeÑÙ½zË ä+X–YÜEÇ.[N,[ZzÞ–ë´é2óVî‚H{XšÌçÚ¢ –¯?ŒÈQü¦iצ³–”æ{BQùš ,iÙ“Dp˾ÅÑ.{·ål—ý$K‘+7Eý&”ƼåEfgÒÌUhÙ¡¯e—Q zÓ䞢u/ÉTýcáÝZc:o•»Òg·¼v8-ìqñÚ}ˆŸ ±ewˆÖÛw¬&I4¸nú/…z=$÷&_Û.Ø€_Jxý*t$GÁ†=—Т}}¹^ŽÎx_½@p†ø ãaò̱ZÎs'™å×l@¶Û±G¬X?é4}vK §E>7nYm^¬EÖÇ·ì–z -¹ëú+Õ:"EŽèåš3§Çôù“Ѿ«×ÁÁÏ˂측|™_0 WcŸµÀ“š®]ðì™ùÛoÆB5"ÚµÞ][`ø ÎhX·2èlÕ·‹‹# ‡! ÿž*At4)?h_€!ò(¯ë—îÖ­Æh nÞ¼‰)RóM:mÛ¶5꡽P¨P!•YÚr’£xq Ë>g®Ëƒafi¹sçÆ‘#G,›Y÷iÓ¦¡]»vJ>eÂôå~83t •7DD㶦ó(I ¤N› âˆõ­‰ìÇ¥ó§ðôÉCía@*嬖d¨Žbò3øέë¸|á4ÂGˆ¨ö'=BÊÂ[«íCäM&N®’ÙZKzR{³uÝçÏžà«öu#fl3½}Óñ!¹·ûwo©·!>||Iº+lLó\ÓÞ’¸tî$âi5$WiŸ¾{¸¯9SEÔ"¸?aéßs•|ˆ¾vÍ |üø ÏŸ=G¤H-z4óÎ@ª‰üÍÅó—ðèá$N’©Ò¤ÔpF ¤Ù>üܼ}ó.œ»ŒÃkßɼ<Œ°u•ààgëÚÁÑÞ®Y7lX»5«”ÆŠý}Iyk©t•Øî~À˜£TñØô×L%»e4²@¡€@¦¼•qþâìÚµ E‹ +âH€H€jÖ¬‰U«VAümÚx>È'&﵇>‘()L´ýr™ºuëâøñãÚkú‰ýr®3Ž•Ä Y²dÁ™3gœqûܳ7Do\ôß}«o9•8lsæõú0Çrœ½ÖåÉRMG>¡ÁÂ[k!öäÓbÆŠãÓM;]û: ¡½I2bùØ2‘q’wæŒ÷Õ;öÜ':Û 5ýö 4q®çÎç™G (¯åŸ¹åçf²IÕǯç?¿®)4Ž— œ%sÆ"g¡ê¸{ÿ‘ZâÖû1hø: ch\2×D$@$@$Š0Â=Ý '^ %eBáÍ—ˆâçÏŸcëÖ­¡pu¡oI¢Õ~úôiܺu õêÕ } äŠH€H€H€H€|M Nì˜X¹`~Ö¤Üt>v:6mÝ£Wy$   «èp·Š…ÁL€÷`îÛË…×d/ræ ½^¾ÝGpŽKš4)%Jœ—äµH€H€H€H€‚€€K^-§ÈhÏ\¢Ù E/ܺ}/®Æ)I€H€H€…îŽr'í{t¸Û÷ý ”Õ?~üçÎçOŸe>ËIDSÿþýû–Í>Öe]§NÂÇ ½OòfÀçÏŸqáÂ}js…âdþý÷ßQ©R%ãÚúü{÷îUç]½z7FüøñU[‰}0bij¾·oßBœÖsçÎ5k×+â8_¼x±úHÆé™3g"zôèz·Õãµk× Ý‘"EòvYqãÆUý]nͬ9Û-Ç=yòuëÖU‰H{õêeÖ-ñ¶¬eË–xñâ…­nÕ>nÜ8‰/ÉNÅÄ™^°`A•øT5øðDÉK„þ¡C‡;vl›£}Z‡~â‚ TdýñãÇU$½Þ.G‰Ø/^¼¸zaÚn«¼hÑ"<{ö 7n´5„íþ$ðáÃ{œ>~G¿;ØO?€OÚÛ¶¬X©J¨Q¯…­n¶“ Ø ôiSbδa¨Õ¨«±âÖ#{ÖôÈš9ÑÆ ÐáίÐ@€÷Ðpü°qN¯X±ÂËU«VU²)… Vbзo_äË—OE_3Æ‹Þx¬X±Ð¡CäÍ›Wɬˆ\˶mÛ ’3ß¾}S×èß¿¿’¤‘ytË•+—rvoß¾]E´K$¼n¦NîŸ~úIÉÊ4oÞ\—¨û¨õéÎv9¯Y³ffÎv‘~éÒ¥ \\\2eJ¥•.v‰ ùò¥º”DË׫WOE¨ÿø£ÏÊH"#ÑçY²dQñ£GB˜Èƒ1‘ÀéÚµ+fÍš¥êòDë×®]ÛÌÙž#Güúë¯JZFdiDGœòâ`—hw±M›6aáÂ…hØ°¡ªóÿxýê%Nݧ¢×܃ógŽ™Ý ïf7>†Œõ¼—Þe @è'P³jt=r þ˜¯ûáã'ToÐ Gw¯Ô$þ¢„þ p…$@$@$@ÁB€÷`ÁÌ‹ø@€w…¦n‰LGôéÓ§eýüóÏJú¥uëÖF›^ˆ!*T¨ >ãÇ7s¸‹ãùï¿ÿVúêúxq&wîÜsæÌ8Éÿûï?åàÇöåË—!tÝÄI/IDjêp×ûÓ¤I‰ö–1bâ<—5JTºD³ë&Îj‘ÈÑ-gÎœ9›)RèMJw½råÊhÚ´©r€‹Ä‹˜<=ÈÃïlÆŒÈ{S+Z´(5j‘§ÑuáE£½zõê(S¦ŒÚ¢E õ€@?OœïK–,©ƒ_Ö+r3"+SªT)¼ïñª³p,]º4ô· ô9x´M@¾Þ¶m\íÁ®9Ø/_<ãïd¹Ã'ÌEŒ˜¶ß~°½ ö „V£‡tá#§±ïÐ µÄ«×o£që¾X³tJh]2×E$@$@$Ìèpf༜U>‡[=!A U«VfÎö8qâ@¢Ì­9Û½[Ÿ$GírS§¶éxql‹»nM~îÜ9½êã±F*¨îl×O.œŠ 7uÜÿñÇz7¢FêÅÙntjÑc—u˾u›6mš^´z½zKg»>PæYºt©J‚ª·‰N¼˜Dø [Ý$ª]¢ßåƒ$­µüHÔ¿œ&ŒÇ3¬çÏŸ«º~>>ÿÿuß‚%sÿÀ¥ §ýíloج þRÊç r €]ß³V,˜ˆ¸±cë^»aFMà[mH€H€HÀÉ Ðáîä_¡dût¸‡’á›eè2/26cÆŒY”"EŠøæT³1âPO˜0¡Y›eE¢¶Me_$2Ý7&ø¢±.N}ߘ»»»1L(Øz Š#zôè¡W•œËÿþ÷?£nY|ø 7«hzy o ØúH¤½$žÕÍôM½Gï ô4 %õ~7½iÒgF—>#½Á.   {&0A\,›7?™H ö2î{=Þ€´ç½qí$@$@$@'@‡{Àr†€ Ã=à Cd†Û·oû)êÜt‘iÓ¦5­Z-‹s9C† Fßµk׌²w…_~ùÅ»n³>Ñ<üø±Ñfªo4Z)˜ŽûôéîÝ»ge(Q"_Iºˆ”Žn/^TŽöS§NéMþ>Òáîwt‘"GÁ°ñn~?Q;ãg- ï˜)‹V{“‚F$@$@$ชɇ‘ƒ»ü¦_ÔiÜ zäæ1:X   p:t¸;Ý-•¦†{¨¼->/JœÕ•*UÂôéÓUÒQŸÏðñï¿ÿ¢]»vž VJ¯^½Âùóç‘L l‰‘—Ñ#÷åš¾±gÏž™ >¼Yݯ]FÎ}vYSüøñý:—ñ–ëô2ÀD:GìÖí«h^ÿ×`[q¼„‰ðè¾õ)¶‘0I2ŒêùÇ·­ql' K “%ÇZãèáÓ>‚GBFË1¬“ xOàÅ‹H–&N]¹‡B•Úz?8z%÷KÌX±ðüûï…ž4 ð/[þ=‘ç‘ ˜¸lV ¾Ê-xcÿž=ÁwA^‰¾¸ÿ>Y „ºO‰CCÉ qÒeÐánG7^œÓ¢¿ž8qb¥;®ë…ÿöÛoʱ6lÆtéÒ)­ó+W®àæÍ›0} ˜:uj¬^½ZN1L’”?~ׯ_7K*öíÛ§æ6kqRçÎ[Iµ˜¶KY"Ç'Mš„7oÞ¨.‰Ô?pàÆŒƒÌ™3+‰YDZ÷íÛkÖ¬1¦IšÎ;«º<|8|ø0DƒÝÔ6mÚ„bÅŠ©ùd "#öîÝ;Ìš5K9ø……˜D¤wïÞ]•åŸÉ“'£B… ª.šùyòäQä!DÖë&ë»|ù2$±¬¬A¯Êü²‡R¥JéÃìò(o!ˆ¥Ì -ûx¼Y”¹xò8µn„ë=åŒ|ºÞðÙ‹ñKùÊ> c? €ƒÈœ;†´kfìîÀŽÍhÝ’k74J»þ^©îAy ÎM$@$à7t¸ûG :܃†k€fõ)Ê[&/S¦ DþDœ¼ºmÞ¼òËŸ??L¥Rô1–Ç>àäIër!qãÆÅÆÍ$[Do]¢žÅÁlÍÆŽk­Yɺ\½zUɵ˜­ô%K– råÊG¾˜DºËGàâ¬Yq`[ÚÌ™3! `¥/eÊ”f XMÇîÞ½’hUôò–ÀëׯñàÁÓ!ª,rÓD±åË—WZ÷S§NUýOž¼÷zÿ¥¿jãt¶ë x$  '%P±~cœ9rkæÍTÞk)½ÖÀ¼!R$'¥Âm“ €s ÃÝ9ï{hÛµG¸oh[•“¯gÇŽ>Èv‰2·eGŽQÎ`ký]»vEõêÕhoË1"1Ó»woUž&M³nq~Ûr¶› ´¨xwžD‘/^¼Ñ£G7;KHĺ¥³=räÈg»«««æÌ›ÎvÓ %’]"å-í’$µGÊ™n:^ÊãÆCëÖ­ÍXɃq²Ÿ={ù®GÈ[žº÷–×p„úÕógѸ„ fŽüÍÌÙQ»Ï}'MÇô ;­¾‘4Ut1Áp$@$@$@$Ð}ô$¤ÏGÞ–Þ©Ugåé$@$@$@öF€w{»cŽ¹^:ÜCá}íׯ ,è­»8GŽ©äc,· 1ÇGÔ¨Q-»T]tÊW­Z‘)Ñq™‘˜ù‘Š‘¹-àr²Dˆ‹´KŠ)¬Îm­1iÒ¤JúE$bl™h±Ÿ;wN%µµîHZ„’8ÙOŸ>-ZS¹¸¸(MûD‰mRiÙ“hÞÛ2yàرcJþÅÚ˜ðáÃãÏ?ÿÄÁƒ•¤Œµ1¦mòV€Hά]»£G6íbÙ‚€¼-±`Ò¸̓K§N˜õæ.R ËöŸVìsäF£.½Íú Cg/Bx“üfX!  p*aµ7GÏ_‰(&[V-…hlÓH€H€H€œ‡îÎs¯CóN)) ïŽÈøFŠ¤[·nMdXäãWg¾|Û&L¨tÕ%1ª»»;nܸ¡"Éʼn-Žþ_~ùò ÁšMŸ>ÝZ³jëÕ«—’Þ¹vínjõ’U¤cäãÛd°¢ß.úì"+#Q÷òýxñâ)¹œ$I’¨c̘1m®ƒžn]½ŒÁ­ãìQOI$镨í@íVÌr´è5{7¯Ã•³§Õ$­ú†8âi$@$@$@$ H˜,9†Î\ˆÎµ*êM˜Ô¿2åÊ Ñy§‘ 8>:ÜÿÛÃép·‡»ädkíö²eËÚ®ÃhÑÐòÆ€|jºv{áÂ…:•Sž/ f%ÒìÁ}ðéãG3YóÀà?ç"IÊÔfíR £%oýmú|¸Ë‹,y\Шs//cØ@$@$@$@K•C‹^1kôãë—/èݨí9†è±b €ƒ ÃÝÁo°l’2vr£¸L°w÷nÞ@ë Å1¾w3g»¼ÞaðHÌÚ´Ûª³]ßwšÌYÑyØX ™±ÀLS_ïç‘H€H€H€„@sí͸¼EK0Ý»‹~ÍêCòðÐH€H€H€›îŽ}íewŽp)É“'ÛLÐi „Dº—‰æ¸_$Pä›StÁEßÜ–žxp­= ×¹{÷.öíÛgöÆÞ½{UrJÙ[‘"E@”€Ræù>X3o&öë†ïÞ™ Í=~›1)Òe0k·U© xGàÇÄp·ÅhP$ÄÙ.vØ};¦ˆ¶‡yw*ûH€H€H€ìœîv~dùr¸¿xñmÛ¶E@çú7CP1}õêäã“ä¡9rä€$0µW›6mÚµkçeù3fÌ€|Ää’]»v)Ç»—l ?r‡¶oŽC»¶™Í$IO›õè‡&Ýúz›Øì$VH€H€H€HÀ—D>fÔühQöˆ¬ŒØÜ #‘Í¥Dv†F$@$@$à˜tc@}•ŽI‡» .’” 6,¢GàµfÊ”)Às˜N É7cĈaÚ䯲$ë´g“HvŸL^­=pà€OÃØO~&°aÙBÔΟŋ³=u¦,X°ë°ÒW}} I”ÚmÔD³©´lˆû·nšµ±B$@$@$à8èpwœ{iÏ; ·+R¤H˜={6jÖ¬i&Y"%eÊ”ñ‘‹|äÍ›®®®>ŽõËy°eËÌš5 ï,$,¬ÍsýúulYµT]êÍË—èÕ¨&ܶü É#C#  p,t¸;Öý´×ÝÈá.›®V­DǽeË–ƒçÏŸ£@VåLŒAA\È“'äã“ݹs 4&k_µj•ÝK]äÌ™6l0Û+$”¶¯]‰Q]ÚâÕ‹çf—I–&~›>™rå5kg…HÀ±ìZ·_¿zH7XÛYÌØq‘.kDŽÍZwˆ·Ò4ž_ÿù•#aÄŽŸ Ä×äÓ‚›ùÓ‡pâ€ÇtQcÄD>“Ä”>­•ý$RúMž+gOáúÅój OÇèîí1`ʬZ¯K$@$@$Dèp"°œÖOìp—«µhÑOŸ>…$'Õ­cÇŽˆ+êÔ©£7…ºã³gÏPªT)ˆÓ]·Ì™3cýúõˆ1¢ÞÄ# €^>†Ñ]ÛAî¦&ÿÑÕiÓ íG¸ðáM»X&p@¿µm‚woÞø¸³Ä)RA’&7ëÙ©2®¬œ÷fÀÔÁ}qáä15bâòP(~yoF‡Ž®àf~ñÔqômRWm^îa>÷’¡WAÞˆ ½•;zá*4*–ïß¾U#ÿY8Ù] ¢býÆÞœÉ.   {#@‡»½Ý1Ç\o€4ÜM‘ôéÓ]ºt1šD\¤bDÚ%4Ú[í—m‘¹xñ¢±¼äÉ“«õ†þ»1) $ààvoøµóeöâlO”<%fntG×ãélwð¯nüJàîkضf—pÁ–ÕËüz:Çûƒ™ûOq(ɵ·íþáf¶§ÑÝÚáò™Sfm¬ Ø7:Üíûþ9Êê%Â]‡1~üxHÔø‚ TÓ—/_P½zulß¾...ú°?~þüU«VÅ‘#GŒµH‚ÔmÛ¶A®ÒH€|& ¨ãûtÁ†¥ßï¦gToÚ†ŽD”ÑH€œ“@Ñ U§H1µùÿþûïÞÁK´Ïy#aáÇ÷ïÑ¿Y}ܽ~ÍzôqP%ªTGÆœrtñ“$ ñõøuÁÁ\¸ÈÏx±I“úu‰O!J D•hСM¯ÖñéãGôlX‹v µRW! Œ'  ;$@‡»Þ4\r :Üå‹ÚÍÍ /^¼Àºu %iiùòå±gÏdÊò¯Kä}ƒ ÔCý~JòÐÍ›7#uêÔz$@Þ8°c †¶oŽ'—8‰ŠË[´„Y;+$@ÎG GþB¨Õ²½Õ‹îøÐÍ!îÄÜÆ×dš nÂDVÇWc£Î½‚ëRArà`ž:cfôž05HÖÏII 8´4gŽÄ©ƒûÔåîݼŽA­aÜ’5Ðÿ@Žuð$@$@$@AC@ÿÿ\‚~h$RMRFß@˜0a°|ùr.\Xo‚$Q-]º4nݺe´…T¡mÛ¶X¹r¥qùðš®ô?ÿüƒ9rm, X' º§#:·AÇêå¼8ÛEuÙþÓ ³Ý:;¶’ x(V±*ï9Ž(Ñ£«Æ/Ú›gó'ñ`¥ôñÃœ:´»7þƒOŸX¼Mï܆Hjý»en^¾¨%‹ýêë<¸} òÐAôâ¿}ûæëó2Ð?ÌåzÂýØ^wlX¶ïß È|}n@ïµwk–ÿÇNøWÉ íø{5Î=yÓ‚æ<äo•Qó–#fœ¸Æ¦÷lZ‡¹FuH€H€H€ì—îö{ïiåîp8"DPîÙ²e3XÝ»wO%(}ò$äþHîß¿?f̘a¬é§Ÿ~²eËðË/¿m, X' —:²bͼ™fbÅ‹I.8pª"ko‹ÐH€HÀ7$M†j[C×Ο…×/_u½póÊ%4/SEGCó҅ѽ^U”JÕs¥ÇÊÙÓôaêøüÉc¸Ä ‹<ÑRŸCîÛÍúõŠDÖ»ÄgŒ»«E¸Š¹Ík´‰#ÝÒ¾jRy“ôD‰ä±Q1K t¯_ ]jWBͼ™P9kJ,›þ;>údyšªK„Íœñ#ÔÚ+icEÆB®W,i t®U1XœÙ>1—uéìd¯òp£jŽ4h]±·nŒ3‡¨ úY¿X@¹«I´ür¯õs|³fûôÑCôkZ¥ÒÄG‹²¿ Oã:èݨš”,€²cBßnêá‚>/ŽM vü1w~üÑóO¡Ãáèž]Ž½qîŽH€H€œ€îNp“í`‹*)cºßhÑ¢)™–B… áÚµkªëòåË(S¦ ÜÝÝ%JÓáA^ž1×/¶ûfôÒ ø&?0¸ûõ^ëë4=ÚZóý[7ѪB1È[ Öìí«WX:m®ž;­=@^ÇDßÖ 9`[®B¿ ýà‘ø} ‡””ÈNömZ‹÷GœÌé䀷œ[" ‡&бcGœ>}Ú¡÷èÛÍ]¿îL³téR>|Ø·§qœ  Pnݺ5jÖ¬iÒÊ¢_™Ã]?~|lݺ ÄÇÕºŽ?®œÜ›6mB¸páü²V]´hºtébvþرcѤI³6VH€Ì èÿQݹvÕ¬#z¬Øè3ñO¯Tͬ ð x‰«äʺC]´”u‡ûÝ×0 ECH¤µ8¯];i‘åZÂCyÀw|ßnå$i™Õs¦#’övMÍq&V®NÃá.²-½ÆO…üÂhjîë×Õ²µëeï £º¶…îl­yÑÎY îݺ¡"ÁWiÑö"³óŸ¿ÔC„&]ûÓIT¼îlO•!Ú †tYsàѽ;X5ûOl^¹O>@ë ÅñÏé럱AeÞ17½¦8!ÅÙ.ŽÇÚ>£Åˆ ÉÓñòÙSÓaF9 Üý{¯‹/ØZó?‹æÎö Ùs¡óðqH‘.ƒ–È÷6ön^Y£†¨ŽìÞ‰Í+£²k3Ë©YwP ;v÷ªÒä¡ÄägJïƵ1cýN„ùùgÝ5·E$@$àh$¸uÊ”)Ž¶­ïçîݻ͞={F‡»ÿЩ³‚Ôá.WH™2%¶lÙ¢d[^~OŽ¶k×.Ô­[Wi©[þ€½X=uÆ ʱnš,¡W¯^èÞ½»Õñl$>i‘¦ƒÆ„ ¼à`q¶ÇˆÇKH€HÀ¯bÅq¸Š‰Ã]·Iý{(g»ÔE²ª|]W½ “%Gö…QÇ% >}üˆ•³¦jùÊ)üK¹Êˆ92D«[œÃ'öíAî"ÅŒsEß["¡Å~Ò¢â­ZËè³U8®Í¡KÌDˆ n[÷!¾æ|‹Ÿ$)$RV^]]2u¢jÛ²jt‡ûÅS'°NsøŠ%O›ów6"¨eyÀ!Rd%×%–L„¶‡©ñAõ-æ¦×»¥Iù›ÌVEô>ƒ^×áîß{­_[?ÚZ³Ì¯[ýö]³`U•ÿÇÄ/šú{5 o±C»¶Óá®H8Ï?ƒ§ÍEâyŒŸC§µ\ò5Ó}ô$çÀ’ Ø5=—P”H0{x»Þ òÎ]¹ƒ!SWâ‹øDó? w¸ËÒ²fͪ4ÝK•*…ÚºbkÖ¬A«V­0{ölUŠöíÛ§žÆè?|äM›6ŨQ£‚ârœ“‚€¼…âêêŠsçΙíG’v=åj70kg…H€B ’‰ÄÜ+-ɺ˜H€HBR±T3›9ÛU£öÈÀTmÜR馋£ZœîÍ{@x-L‰Ê5°nñ<5t»&+cêp?´s+>}ÿ]$‰Ò¾Š&_í6]Í%ÿ4èÐÍp¶Z¡I·>šãö&ôüâðÇÿòSŒ¶Öý†ÎvÓsÅÁ.örîŠÙSѸkou®é˜À,[cn9¿D¶œ6Gñ´ì³V÷/÷€ÜkËuØZs¼DGdü²éS9· %Oaœ>HÛ'Íy DÖd0Ç,\¥éùçWð„„|ßfs)à«rÎKŽ;' mÂ…ý5ËämËâzìŒ@œQ•ÃÝΖê–,wÙµh¹¯\¹UªTîwssC¬X±0z´‡~k`Òíª *~™»jÕª˜9Ó<ác`^“s‘€=§—#FŒÀ°aÃŒïQ}?’u¡ûjšê@x$4"á ›5~íÂY½Isn'Å©ƒûŒºiAêv嬧f¥<Ôî»Öý…žã¦šê;5™Ý|+'sóÊEýdÍký˜è1c)§1ð{áêù3F“DÁÛÚK\M^çÑÝ;x÷ú5îkŽûÔÚƒ† 2kÌ-¯Uµq _;ÛõsýÃ= ÷Z¿¶m­¹Dåêغz™zöè!TË™4­ü\…‹"SÎ<È©½¡ ÷æ¼ÒdΪÞÞÜÆSnrhûæH“)«z3ÅyÉpç$@$@$@$@þ!lwY\ùòå1wî\=«G€3qâÄ T‰і䬺„\»hÑ¢„ A-a#×¢‘€½8{ö¬ú¾r¾<É¡I5íÞùŠýj:%ËND@d«Î9¤òBȶåÍ™žZâàù;™É*9n•H€H€H€HÀŸ‚Õá.klРž>}j–Ä´gÏžˆ;67nìÏmxžöèÑ#ˆt̓ŒÆœ9sâŸþ ¶$­Æ…Y PN@â7Äg-ÙŸ©•(QB=¨0`€i3Ë$@$h$Úû›æ×Mw¸ËÏ&ÝbƉ ‰þöÉâÄOh j™šõUòRiÜñ÷j¥³~üßÝÐóÅ*VóU·¬E’¡êf*Ç¢·Ù:Šsû&{I—5;~ÐÀ†¤Ùbn¹&SË>[uÿpè½6]‹wk®ß¾+J׬§’¢ŠNû™#ðîÍuºÜ'Ñé—Oï SQ½ikÓiYv"]GNPÉ‘/œ<¦v-̆uhás–8n•H€H€H€H  ‚Ýá. îܹ³rº>\­_þÐiÞ¼9bĈʕ+û{O¯^½BéÒ¥qíÚ5cŽ4iÒ`óæ͈b¢kt²@NLàÒ¥Kê!×ÁƒÍ(DÒJžƒvíÚáÏ?ÿ4ëc…H€“À’ižI ãi DS¦Ï¨¦O–*­q‰82sQ÷m¡\†Ã}ç?«UD÷õkÓËÖªg”½+È›q‰S¤‚$ä{xç¶MÝ÷cšCÿ?-zZ,‹&=N{K(IÊÔ¸~ñ¼j5…šKUBè[Ì-—ó£? ø•{`Ük}í>­9¶&&üò‘ß=¯?‹;¶@˜<}è¨1¶g'”¯ãŠð#êÓòèD† ‡Ñ V¢A‘\Æù­-×¾Ÿ]P§uG'"Á­’ „@ˆ…Y‰N´$MÕM"œêÔ©ƒÝ»wëM~:ŠìEÅŠqêÔ)ã¼D‰aÛ¶mJ²Æhdœœ€8&OžŒ9rÀÒÙ.¹ä{¨}ûöê{'GÅí“ !µógÃÔÞTK:æçŸÕ“¥Ig\Y¤?DÄš‰#ûïnê#Úܦ&ÎûtÙr¨¦g*ít÷ wÉK‘»HqÓáÞ–“§MoôïÙ¼Î(›jÉX[W(Ž6•J¢w£ZV÷ræˆùNÓó7­Xlìå«–S#(Ì;æu=¿rŒ{íÝÚ?j rg¢>³Ç 5r”H4~êLYаcw,Ýwá´d»bòÆÅùG½›’}N AÒd:{‘Ù.'õaûû×l0+$@$@$@$@NO ÄîB~Ú´i¨Q£†qÄi^©R%XêHlD“µV­ZØ»w¯1"f̘زe ’%Kf´±@ÎNàÆJ&FÞ2ù 9!t­ö±cǪ^©R¥Ò›y$ @%ðþí[åÌì׬>†wj¥¢Œå¢·^±¾g²Â”2AäWÄD?}Ý¢¹ªlúÌÕµN% ëØR}Þ½ymÚ­Ê’ÄS·)ƒzãɃûªZªz?åt)«I‘è¶Úm:Þ½£WãüIcŒrÁÒåùM×à6v8dÝ–¶ÊíO léªöñ¶WýÁƒå8ÿÔ}ËÜ?sÛ:ÇtÏ>q¬{mk-á5Gúê930säo˜1b0ŽîÙéehôX±Í’¦ÆIà)Oäe0œ‚@’eТ÷@c¯ò F¤™&6:Y      !")£¯A^ý]¼x±Jnº}ûvÕüúõk•ðtß¾}H:µ>ÔæQ¢u›5k†uë<#ÎDcÆ È”)“ÍóØAÎF`ÆŒ*9ñ[ gOžy{Eìñý{è׬þX³>É‘ €sÒÛ«ýaºfÍ/^GŽQËyüø1~ýõWˆÓ=aBºwïŽ ÛøY{}õêÕpqq1ÚX g&p÷î]4mÚTÉ+™rïI–Ú§O#Ó´Ÿe û·nB>ÞYÖ|0jÞrX‹(ÎUèÍ1=³F Q’2 ´rùXZÂdÉ1iÅz«2X±âÆC¾â¥°Û&ã4‘‡IŸ=§Q÷m¡ÿ”Yè^¯*$‰¢è¸nÝØê©]FŒGúïR6ú€¾“¦çÊù)kÍÚ Šâ•ªYëòU[@™ûê"¾äWîq¯½[V·Q!ÒD¢ÃÿòÙSLý­ŸÕá‘¢FÅЙŽy«ØèTÄ©.Ò2¢ç®?,<²{'þ:íyä¡r* Ü, €¯ „¨¤Œ¾ÊÈ‘#cÓ¦MHŸÞS#õæÍ›*ê‹/ôa^Ž#GŽÄ„ ŒvùÅXœï’8•F$¹ž9sf/ÎölÙ²©\ýû÷§³_($@ÁF@¤;\4x“®}TbÂëwZu¶ë ’әݑ*cf½É8JBÒÚ­:Àmë>%IctX$‰§©ù6Yªé9RNš* ¸AÍæmQû½ÅÒRi28¬Ý¢ú-ûäÜ…»ªõZ;7m–l³pšvëkyj€ë~eà ~ŸÀ¯Üã^ÛZ{Ôè10]ûZ“7¬%C•·JU«Ù›ö ›KA[Ó°Ý D £µdǦ2Oó&ŽÂÞÍë·L$@$@$@$à[?h¯yÿçÛÁA=îÎ;(X° ä¨[”³0bĈz“:Κ5 -[¶4kûã?Ю];³6VHÀ <|øP}˜J- ‡0a gÏž|†ý'.͹3§BÊ$ñŒºµÂù«wpöŠ§2‡Œ)#º¶µñ¦m/^½Å¶ý§M›&YäÈÈ·æÌ 8@%Ô9Ü…©DàJ"ÕòåËãóçÏ ó’%KðõëW¥õþéÓ'}ݺu1eʣΠ8#y¤U«Vxôè‘ÙöS§Nyóæ)©&³VH€H€H€H€|M@$ Fk¹Ë ‘=ûgádÍã‚Ê®Í|=’ €#Ø°û8ºšïã#E ’£|Ñ\èѬ’Mç»oçÓ/(óvlXV›³2¢G¤7Û<Ÿ¾3–m3úk•-€e»uk…U[bð”f]]ËaRß&fmÖ*‹þÙƒNÃçšuµoP–w3"ŽQ IS­¡,Y²$/^löM·bÅ ¼ùþ ®œS¦L%‘!O³h$àŒ^j¯47jÔUªT1s¶Ë÷„D»Ÿ:uŠÎvgüÂàžI€H€H€@²Ôi1é¨)h@IDATpê³y%Ê]¢Ýi$@$@$@¾'ðîýGü{ì"úŒ_Œ²-†ãÙ ‡Ù¾ŸÁúH™wäŒ5È]½Þ¼ý`}Ð÷Ö?aéú}fcÖn?Œç/ý¾–å÷›)q˜MjRY¶Ñüz&],:Pá®3®Q£$icëÖ­õ&ãèââÑr÷MâGã$HÀl޼͛7ǽ{÷Ìv•4iRÌ;WÉ2™u°B$@$@$@$ Å+UCÎݱð÷qjžÏÚ›·¢ç.IT™|7@hy2 €ƒögŒíÙÐØÕ»Ÿpñú=œ¿zç¯Ý…8ÇŶí;œÕzâÀ²áH/¦1Þ²`9ŸÞÿõÛ7^?þµõ^¿}¯WÕñó—¯X¼n/:4,gÖîSåÑÓ—Øyð,~-˜ÍæÐÛ÷ŸàÀ‰Ë6ûÙáXBµÃ]P‹L†hS÷ïßß Ÿ)S&lØ°µW;i$àlä-îÝ»cæÌ™^¶Þ´iSLœ8Q£FõÒÇ    €h;p8Î=„û÷ªÉîݼA­aüÒµJG6àWà $@$@$`ÿÂþ"—bÍD˼Y¿?!åbw<ÅÈ™k0e€m™6ïæ“9†t¬S‘óR—¹½s¸»­Þ)Ô‰$Ìï 6ªòœÕ»üìp——¬ÿ×[‡»DÁÓœ‡@¨•”1½ýúõÃàÁƒ.\8äÍ›[·nE̘¶Ÿz™žË2 8]»v!kÖ¬^œí &T¡ÜÜÜèlw¤ν „:a„Áˆ¹Ë+®gRµ½›×cîø¡n­\ „F1¢EÆ_ô@×&åÍZ±÷=7ê~-ü¬9ø[ÕþÕ8íåëw¤¨ÖL"àÝy$B­%\Õ­>âÄô\<¥%}=~Ӽ´eM— ?ýäáZ•ˆùŸ<òPz¨5˜ÊÉäÌ”ÒÚ¶9»p¸ ïAƒáÇ8tèĹH#g"ðþý{têÔ %J”ÀÍ›7Ͷ^¯^=œ={åÊùí•'³IX!   ð5Øñâ+§ûO?ýdœ3cÄ`Ùí-gt°@$@$@$`•@ßVU!|XÕ'r.“¿G™[ì‹Æ$ b›ŠÎcn³F­2ï¯]FSÍ2ù^'GÝÜVùîÿ󸱢¡t¡ìê´7ï>`ƒûq} ³£HÝœ8CµåÍši“'0ëgÅñØÃ]Ð39ªã}rG>Ø¿?²gÏŽßÿÿý÷ŸqBœ8qTI.#F £     '³`´<Ò¸Ðÿþ÷?ômZï›ç×1°@$@$@$`F fô(¨[¾Ñv₇SÚhðcáòÍûÆñãDG¬QŒº^ÿ¯ç­q׫¨WÑãúu+x®c醽V7NÖ *6ª¢ÿnÍL£ÛT*bmÛŒ€]9ÜŒ=·CÞø$I¸zõBáÂ…qåʳ±Õ«WǹsçP­Z5³vVH€H€H€H€‚@ƒÝP¬bUã‚/Ÿ=EïFµðõË£   Û2¤JdtŠÔ‹í‚–ˆuÄô5ÆéµÊ0ʦ…íûÏR3ÉÅAéT·õy‘£‰ßX¥ây9Rx5tãîãxõæ—Ó–oܧÚD~¦v9ëëòrìš@¨Ošj×t¹xð'cÇŽ¡Q£FÊ©n:…ä.H÷úõë›6³L$@$@$@$BNƒ«çÎàÎõ«jgŽÄÄ~ÝÑcÌäZ/K$@$@öC ~ìèÆboÝ‚oß¾iºèž’mzçÇÏ_Ðkì"½jßü„­ûNAd[t˘:1†uª£WÍŽn«võ:å j¢ª!õ±n«þ9ZRÕz=£×“, #„Cµ_óaÁÚÝYœÕ[¡iâƨ³—oãüÕ»ª.ò3qbF3úXp\t¸;î½åÎìÀ-jØ°a1b¾~ýj¶ƒòåËcÖ¬YH øµ¾ŽíuG«òÅÌÖà €ÈQ£á‡ÄÚkêb+fþÃîÛ3N\ü×! ܽuÓ!÷ÅM‘ @pˆ)‚q¹oßþ‡×o?@’ªZÚÍ™­;Ã-ûLë-µÄ©ã{¹"RD¨sÓ¾ç/ßàïGŒ¦z&22Ò(ò2ú5v<‹›w#ybŸÿ/¯¯9æÅá.¶dý^3‡»¹œŒÏ|5 ÿ±{t¸Ûý-ä…À™3gàêꊓ'Ošm)jÔ¨˜0aš5kfÖ=A±¼}|ßžà¸$¯A$@$@$@Aàæå‹Íñ $Jä)‡àø»åI€H p |Ò‹*¹ê ö5ñ£ö›w&8’üuâ¼õøï¿ÿ Qí]WÀÑ3× ëÒ‹ìŒÈÏÐœƒîÎqŸ¹ËPJàÒ¥KJ«ýÐ!ód‘"EÂèѣѶm[CO,$¶ fE‹ ‰Kóš$@$@$ ¦‹kÖ¬ ¹x2 ø–€+*TGŽx¼®~ïÞ=lØ°Ë–-óíG$@$@NE`ס³Æ~S&‰g”- ?àDïÕa-’/ò)š7Ò•éˆ{ž«Sç¯u7s¸Ÿ8§.Þ4¦½uï äãÝyð’dµT¡lÞ S} *Qw©ˆ¬Œ8ÜÍådŠø88ïÑ8Î>¹Uþ§é{Nš4 Ù³g‡¥³½páÂ8uêÚµk¢ÎöPŒ‹!   ; 6lX¬Zµ ±bÅ2V»|ùrõ{ŸÑÀ €"púÒ-ˆVºne‹äЋ~>Jô¸8½u»l’DUÚL“¥ŠtM’±m~"„«OcvžÑh¥#c dH•Xõ;{—4Yš›ö«ºÈˈì Íy0ÂÝyî5wJ\¿~Mš4Áž=æšèòª±$LíÒ¥‹¯+…’­p$@$@$@$@D pñâÅ(W®$ÈB¬gϞț7/ (`1šU  pN÷µHôVg›xãªEº ÙÒ{j²ß}ø̘âã§ÏZÔù¿F]’ªJrU[&Ò0ÝFÍWÝ’dõÙ‹7ˆ#Š­áF{ƒJ…•œ4´ê} uʤŸÇ äF¸;Ç}æ.C éÓ§#kÖ¬^œíò؉'Э[7þ%÷ŠË    ÿ(]º´ÊÏ£ŸÿåËÔªU ?Ö›x$  §# úæ7ï>Æâö [åî8têŠÁ O˪ög£îŸBÌhžNñ§š“\®'¶vûa¼|ýN•þ9 j–ɯʶþ¹HìŠI’UI¶ê«W¡°1lÇ3FÙ4òÞhdÁ¡ 0ÂÝ¡o/7ZܹsÍš5ömÛÌ–$¯8½{÷†$Ù ‘ 8þýûãÀؼy³Úè¹×­[W%Uåï}Žq¹   Û$ùházŒï>|„ȼ¼7IJªw6®V Íj׫þ>FÑ8WÞ2{þò­ŠL7M–ZVK¤#Zdcœµ‚.£;Íç¬Þ‰Ž®å¬ 5kK–( ç΀½G/íS'†ÈÍÐœ‹#Üë~s·!@`Þ¼yÈ’%‹g»è·KB­~ýúÑÙ÷…—$    $ðã?*i™dÉ<_oß¹s'ÄO#  G' ï}Ç/Ÿ“nzq¶‡Õ¢Í§ÿÖsF´…DžÔbD5w¤ï=vA%FÕç2½ŠžQèÞ]¯^…BF·hÍ;{ͨ{W°Œf¯ïËëy7'ûìîöwϸb;!ððáCT¬XQ鵿zõÊXu˜0aÔZ‡Vò2F $@$@$@$@E f̘*‰j¸páŒ}=ëÖ­3ê, €³ø駑%mRHDûïý›âäßã¼ÕR÷+—4É@¢Ìu›±læ¯u7¤e"G ŠÅréÝÞ«—vA8‰·U;½¯wÖÐΓ ºÑᮓp®ãšž‘‡ ‘sí›»% %°lÙ2´k×ÏŸ?7»NÆŒ1þ|äÎÛ¬   À%ðäÉÄWMÊ_w—-gó;™3g¢U«VƉѣGDZcÇ2eJ£  ðóçÏ#S¦Lˆ#*póÏ<‡ î‡Î¡x£ÁÿÕ¹sçŒv|Mསÿ‰î¾æÅ$à3§OŸ¢fÍšJŸÓÔÙ.¯wïÞǧ³ÝgŒA$@$@$@E eË–puu5öôòåKT¯^?~4ÚX    p t¸;Æ}ä.Bµkת§Ê«V­2[MêÔ©±gÏŒ;¦¯› b…H€H€H€HÀ¡ LŸ>ÝLNðäÉ“hÛ¶­Cï™›#   g$@‡»3Þuî9P H„’D,U­Z?6æÖ^!AûöíqêÔ),XÐhgH€H€H€HÀùDˆ«W¯FÔ¨QÍÏ;³fÍ2ê, Ø?:Üíÿr!H`Ó¦M*ª}áÂ…f«H–,¶oߎ)S¦ bĈf}¬ 8'yóQòù˜ZÇŽ•ì iË$@$@$@$@öK€wû½w\yxóæ D‹³\¹r¸ÿ¾ÙJš5k†3gΠxñâfí¬ @•*UгgO„è¸×¨Q/^¼0ÚX    °_aìwé\9 „ ]»v¡I“&¸uë–Ù&LˆÙ³g£lÙ²fí¬ Ø'‡ª<,²úÂ… #A‚ÞnäÞ½{¨\¹2äM7‘±fGŽÁ_ý…+W®àÑ£G™™·@¨V­âĉcí4_µÝ¸q2¿-“$îr½Ø±c#mÚ´ˆ#†­¡lb#FŒÀ¡C‡°{÷nu%¹w 6ĺuë ²„4    û%@‡»ýÞ;®<˜ ¼ÿ½{÷ÆüÿþûÏìêõë×Wò1üÃÕ +$@$@$`×$KíÚµÕÖ¯_òåË{»Ñã>vì˜rº[”|8ú÷ïxâL$@$@$@$@ÁN€÷`GÎ Ú#ýû÷£Q£F¸zõªÙòãÆ‹éÓ§«„©f¬ 8ÿýïpssƒ8R›6mj¶wù=¢fÍš† ]¢D‰TBõ|ùòáÉ“'~‰Lÿðá:w·æ"GŽl6_*©R¥BøðáÍNùöí^½z‰Ü—à7¢X±bرcG€"ëÍ.Š¯ Ä‹O9ÝE†ðëׯê¼AƒÁÅÅ%K–ôõ<H$@$@$@$ºPÃ=tÝ®&”øôé“ÒØ”×È-í¢µyîÜ9:ÛCÙ=ãrH€H€H $H²ô›7oª¨qq¨ë¶gÏ-ZT9Û#EŠ„¿ÿþwïÞUŽÖ®]»bäÈ‘JVäùóç¨W¯ž:M"ŸÅ.N|ÿšHÚœ={ÖìsᵑÅsuuUSKÞIòN ò;æ˜1cŒ‹Ë=—¯ù¡‘ Ø':Üíó¾qÕÁ@àèѣș3§zµÛôÞ˜1cbÉ’%X¹r¥Ò@ †¥ð$@$@$@¡œÀ¬Y³Ô %©ºnEÞ½{w|ùòòVœ»»;*Uª¤w›%}Ñ¢Eø?{çæDõµñCQšôÞ»T© ÒA¥#ˆ(‚tæ^üE)‚Š HéˆÒ¥#M:Ò{ïU`)¢~y/Þa2;É&Ùd7»ûžç 3sçÎ{“ ɹ羧gÏžªßC ÷Ëœ9³@þ:î°_ý5·a›èÒ¥‹Ô«WϨUX÷ H€H€H€H ê Ã=ê=3ö8Àðãæ£>’R¥JÉœîV«V-)Ö°aC§r Ä\ÐgGä:"ÛkÔ¨a€˜;w®‘ÄI2_|ñEãœÝtÕ‡ ¢&üqßG«ê@¾ÆlGŽHïA£ ¯¿þºÚbBò:6l0W羃@âĉeþüùÙ!mß~û­üøãú[    (B€IS£Èƒb7KIĆ*øaüèÑ#§›!iœíX~M#   +ñãÇ "Æ[¶liœ 1VʵjÕJàœöÔ / DÎ#™j m¯Y³F5]µjU¿Ý9oàT¿xñ¢rÆ.\X‰Z¡¿nÝ:¥s¿zõjäà·Gƒ† ( ßÿ½4nÜØMëÖ­ óçÏo”q‡H€H€ìܼ}W ¾ÞÍîËHÀc÷B\[xÜ+ î|Äx‡’¦M›Êï¿ÿîÄFÇ—÷ß_ý`t:É   p€ÝÕªU“¬Y³LP w˜·ÎRDÉçÉ“G9Ü>l´éÍ$ò¬à*€#ßy q­p8÷ÍÞÜî.¢²qD·Ã¡Ÿ/_>£’¸"ÚÉeä°xñbãwžx÷ÝweóæÍŽ°{÷î©g„g†(x X `>rÁ`åÚ£§­§yL>È‘#‡O×ñ¢'èpç;!Æ@"Ô/¿üRúöíJµ\¹r2iÒ$áLŒ}{pà$@$@$à,‘Èfľ¶ìÙ³ë]·øé_î/½ôR˜÷êÚµ«Œ1"ÌzÞTØ´i“ª^¾|y'g; ,( fÍš©±=~üXâÆåÏ+ß‘#G ’ænݺUÂ{ “"³g϶Vå1 HòäÉ+ÌŽ=J$àþð令_nMá7Ühú`9,÷Ž?.Í›7¥!ŠYáÁƒKçÎÕÒp÷­ð, @L&€¤ Ð/G4wíÚµP z\[Ê”)õ®ÇÛ)R¨º7oÞTyeá˜5j”œÏ­(ù¡9sæ¨ä¹×®]SHpüÅ_0‘*ß $@$@¶'/ @p`ÒÔàxìEÀÒîÑ£G+-Lk®’%KÊ®]»Ñ^Ða¥‘ €;Ó¦MS«ä0‰ouˆç̙ӸôÌ™3ƾ§;úš,Y²„jÛ“6~þùgé†h7ók÷îÝ* <äôð½hÁ‚‚¤©:ª'm»«óÎ;ï¨ïQwîÜ‘Ò¥KË«¯¾ª¢è­ ‰8Ù“&Mª^HÊJ³'€ÜA3fÌpúNÚ£GÙ¸q£ý,%   ô*Í£`GM?\«T©":tPz˜ú~Hb†¨vü€É›7¯.æ–H€H€H€Ü@d8œÆHŠj5h°k;qâ„Þõx‹Ès˜¯ßMà¨Ï•+W¨pÖªUKIç!A' ’%z_„㟠*ȪU«”ž=úHŽÚ­[7A¤;–¼CÃ}É’%á¸C̹´råÊJë^<õë×—Ë—/ë"nI€H€H€H€‚îAøPØ%ÿ˜8q¢¼ð ²råJ§Æ‹)¢42ûôé£"®œNò€H€H€H€\زe‹ è+¯¼"æhv]=[¶lJÇ¿ýö›.öh{ýúu9xð ªkvÜ{t±•Z´h!ZºNrYÅŠò}XMØ«W/ålG€€.Z´HjÖ¬) 6äÓ¡¹'€\C5jÔ0*]¸pA±ûûï¿2î :܃ëy°7~&pñâEÅ…”þù§Ñ:–}÷ïß_iŒÂO#   o¸J–ªÛ€tJõêÕÕ!¤Aà(õÔ¾ùæ¹ÿ¾ªŽhô@¢ó»té’W·¹uë–’ˆquÆ©šÏ>ûL6oÞ,¨?eÊkfÎœ)“'Ovu9Ëÿ#€g4uêTÁŽ¶5kÖñ4    à$@‡{p>öÊ~üñG)X° ,^¼Ø©µüùó«$^ƒ ’gžyÆéH€H€H€H ,˜ÄŸ5k–¤J•JêÖ­ë²ú§Ÿ~ªVÐ=zôH†ùÚ†ÃýsÈŠÊa~ìØ1Õ¼9’>A‚Æ-¡Ångˆî·"Ø‘+/sÒXÔC›Mš4‘åË— ’ÔÃÖ®]«¶üÇ=¬B˜;w®Ä‹Ϩ8lØ0Y¸p¡qÌ    à!@‡{ð< öÄOðï­·Þ’FÉ7ŒV‘µ{÷î²sçN)^¼¸QÎ   ð†"Öá\FâQH¥¸2Lò7kÖLþòË/eÀ€®ªªrDÁ—/_^®]»¦´á‡ê¶~xO~ýõ×Æw¥råÊÍeÊ”ÉØŸ7ož±oÞ2dˆùPí'L˜P­ D¾œŸ~ú)Ôy¤OŸ^´s?qâĶuXš¾»âyiƒ>>Þî¡‘ :܃ëy°7á$°`ÁÕnýq˜;wn¥#Šh stP8oÇËI€H€H€b °ädÌH>þøcõÝeTQÞ›6m’‡Õ ç2gÎ¥u¾gÏUÞ¯_¿pÀ{àÀP¯?þøCé¨#Ñk—.]Ô½Óò{Ú2fÌ(2dP‡ß~û­lÛ¶MŸ’iÛ¶­J|jýNùè·Ãzöì*wœÄ•Ù»w¯ª£ëªþ&Ö­[+'»®xûöm©W¯ž!?¤Ë¹%   ˆ\q#÷ö¼; ø‡ÀÍ›7¥S§N2}út§ñïcÇŽ‚(,D]ÑH€H€H€H <°R/D¢ëHmwí!¢{ëÖ­ÊI=mÚ4Ñ/8«áè¾r劜,-Z´0Ž¹C$@$@$@$81ZÃýìÙ³òóÏ?t³eË&5kÖ4Ž¹C$@$@$@$5 PÃ=j>7öÚÎ;'ÅŠsÊY5bÄéÚµ«ÿn–H€H€H€H€Ì”†{Œv¸›ipŸH€H€H€H ú Ã=ú¡šÃ8,X §OŸ6Ρ ¯¯¿þZ §‹+–dÍšUÞyç0`€Ä‹ϨïnÇßãõµ=Œã»ï¾“7:9Ó1–T©RÉàÁƒUÏ­[·ÔpÕ“7o^)W®œúñ:4   èG€îÑï™rD¾Àož×_]/^l4€ß%«V­ü¶ ‘ ø@Ì“”ù믿$sæÌn#::$yòäñ˜2œë|ðLœ81ÌkÞ~ûm;v¬$K–Ìe]ü8„3}Ë–-.ëXO R½`Á‚F1"á³gÏn,Õ'2dÈ .\Ї¡¶ Pšö9räuNø{¼ámãÇ×Ý3¶ÿÉ“'c»Ô©S˨Q£ÔdƒÝy–‘ €¯&Mš$S.–¿ÐÍ×.Äøëþþûo#ðÀÝw›ÊR&Œ/ý{v“Â… û±U6å7oÞ”âÅ‹;}?îÞ½» 6Ìͳ     'bžÃã†cÒ"®Ì‡û½{÷¤téÒ* ÝU{ÖrüàÛºu«Š¾¶žƒ¶""¯íí}ÿý÷Ò¦MãDsg̘QBBBŒ2Ow^}õUÖ£ù{¼þh¯ÿþòÉ'ŸØu×ã2¬$èÙ³§ÇõY‘H€H€Â"?~|§•WaÕçyˆ.7n,S§N.ÉVãعs§”)SFI€H€H€H€H *ÀïóªZ y’**Ž•}&   È @‡»Ô×®]k\Ù¶m[Û(j£‚c'yòä‚ÄDÚám•?É›7¯S„ûŸþ©¢Þûõë'o¾ù¦äË—O%J$eË–8¬!É’5kVÝd˜[D±»2D‡kƒSßjþ¯¿Û³öu$‰ug;vTQñº´õi$@$@$@$@$ Çļyó$Y²dÆ0­R—Æ î xM€w¯‘‰Ü½{Wé©ëKͲ-ºÌnk®÷ðáC9þ|¨jÐUl×®“#Ø\éÑ£G½ò¾}ûªhuÈÉÚü=^·g7þçŸޮة +0‰¡Í.²_Ÿã–H€H€H€H€¢ È)Bj—={öTR‹Ñel D6:Ü}xH<'NãÊÛ·oûîv®_¿îtÑ%VKœ8±JŠzìØ1•l:ãHšj§©xðàA)]º´Ò)·¶ãÏc×ßíÙIPÃ2<·Õ̲:F!wH€H€H€H€H (Q¢„ ¯Ô!C$nܸÑp„ D:Ü}àþÌ3Ï(]v}éìٳ䛺Ìn;sæL£3fMwœ8}ú´|üñDzzõjÉœ9³@òdܸq*ùé½{÷äÌ™3*åÃ?TÒ2¸ò/ݺuÃnÀÌßãõw{vŸ5k–úaweH<Û¬Y3§$«ê¡‘ €¯èp÷‘\£FŒ+±sРAƱÝΨQ£ŽymÐ_·ZË–-å£>’×_]Ξ=ët:V¬XÊ _¥JùüóÏ•†»®€høk×®éÀlý=^·g4ê¸Gÿþý%$$Äé4V€#’Èj+W®œ¤OŸ^rK$@$@$@$@$@$@$@$@$@^ˆQw蟯[·N9¾áüÆ Îr³-]ºÔé<’›þõ×_æ*j¿}ûöùm jÕªÉÞ½{d¨pú:tH%<ýßÿþ§« $U:wîlc‘êZâÂ… Ë°aÃäêÕ«¡ê-[¶LFŒa”#‘ª9éNìÚµKÕ¨äØY±b…“„Š>‡Èù7nèCIo•¿ñ÷xýÝžÑyÓtò?ùäI•*•-ZTªV­*Ы,P €¬\¹Ò¨™+W.•8Ê(à ø@ –Ã)ü¯×E¹K._¾,¹sç–;wîxÝw8³‘P3EŠN×.Z´HêÔ©c8ØõIè­gÍšUE©C Æj“'O–÷Þ{Ï©øÁƒ¶:í¨Ç~–,YT²VŒuÍÖ¤I™2eŠQ´eË)Uª”qlÞyöÙg•Ó=gÎœªxøðáÒ£GsµúÅ‹+'µ>éÏñ¢M·‡±ÙMŽèþÛmÓ¤I£&:ðÞ ‘ €¿`elØî‹’8ej5ËvH h ¬›ûì³P“%úznI€H€H€H€b8ÚµíÞ½[ïrIø<" wp¯ìZ2_.9(^½$ÏÄO ÉÒ¦—çKU”BUjK¢dÉuU¯·æ>»»8¡ã)3e“”™³ Ææ«Ý¾|QŽýþ›ºmæ+÷š×Mýyõ²ÝòdE`‚$I%…*^·Á ‚‡À?ÿüct&†¨nã Æ>`|*ì €'|ÿ•âIë1¬´ÛYî/ƒn;^Ájþ¯¿Û Vnì šÀ¾UKdî nê6ñŸK¦Ã}ïÊ_ çsÉzC9Ûïÿy[¦|ØJv/{*KgÖ¹SåÙ ¥ág£åeÇõ¾˜¹Ïž\Ÿ$uZy­í‡R±YyÆ‘Þ[;³o§ŒoßP]–¥PqŸî續ù ÑáîíCˆAõá<†&ùãÇÁ&I“& ÷è¯\¹¢‚rråÊ%ñ|ø«ÉD r?yÛþ… òš¸Ö•ÄcX÷èó¾Ž÷öíÛ‚g"™3g•÷Ë×q@VôÔ©S*€ 9½ÂcW¯^•óçÏ«¾a7r_ÑH€H€H€G€÷À±eË$@$@$@$%lš9ÉègéÍ}ìœÞ»CÆ·{G®9éTn=@tüäÎÍßë¤Á Q|k¿#º|þ'=äü=Òì«É~m›ÅXé9mÚ4%yäÈcàXµZªT)ãXï`…)¤7n¬du¹ÝNØÈ–-[äàÁƒbÎÅ”"E •oèÍ7ߔիW+)Èž={ PΞ=«r4mܸQ>|h4¶°âuðàÁ‚}Ú(F^_ýµzàÞsY³fURœxx:ù±hÑ"2dˆ’5…ó^[œ8qÔ ìÚµkˆ Ô3éÓ§>Í- €Är,—ü×í° ˆ4çÎS_x¡M¯8´mÛVJ—.­tõ!›ƒ54  ˆ(ZömØî‹’8eꈺ­qŸUã¾tŠpÿâàç—QÁ´sëÒéS2›üëp˜¥Î–S®?dÈÖABfHÍ’ÉX<‡ÜÌ«mºH®e%{±—åîõ«rlÛFÙµxžìýõ£Õ&¬›½lÚ´IE\›ÏC³cÇŽ¶íšëaŽ{8óíä6ñ<ü=Þ?þøCŠ/.ý÷™hŸùÿ@rl¬éPc¨:® n_¹äHB»[ܽ#©²æ,/sš˜pu¹üÖÅóyží’$M:Õwo¹ ÿg÷ï’»7®IŽâ¥"eå„y<ÑeÅŠ²téR%ƒ²xñbѲ2ÐEýõ×m‡ù /HµjÕlÏ!Ú{èСNç5j¤ÚÊ—/ŸŠx‡cr$ø ÝomZrò%K–Tu† * ÎþN: ¢·áœ‡ ˯¿þ*Ë—/7V{öë×O*V¬¨ÚÑíc‹È{ÔÛ±c‡¬_¿ÞˆJ‡ÞºÙ ½Ž6ÀaĈ²páBÄòÚk¯Õà|nР“³ÎåÊ•+«ïÝ:"ã\²d‰Ü½{W] ÞS§N•&Mšmé?Ž}ÄäBË–-sÈð@*ïÈ»]~Hé¬ZµJz÷î­îˆÚ‡DŒÕáž,Y2õ ÆŽ+_|ñ…¾ÚB2¦}ûöêù¡]aÕˆŽXGû` !«!RÎsmúy¼ôÒK‚èxÈíÚµK´„ImÏØ$ÉÖç¸%  ðžîÞ3ãAD {÷îò矪$fKÝEDTªTI°<–F$@$@$àLàèÖ Žhñcª0ù*NNèÅ#•s¿\A²yÉ8vµSåýn†ÃýÚé‚dªeµtU=\å˜ Ð–Ó!qc¶¾¥rÊsOt‘¿9q_ö­Y*?öé ·/_TÕZ7Sž‰Ÿ@F7«£Ž‘4µ÷â­æ&Ôþ•“Çdj·VFBY]!yúLòf¿a’(Yr]är»ã—9JÞçÖ¥óFHæ¼Öº‹Ôúp€tÌß(ÿ|ïI”ÜYïÒñÃ2­{9¹s‹ücÒÜN“=·¼Òò©Ð´q=w¼'§p‹-Ô…ˆ.Ö÷B… ÉÈ‘#½jÎU|çÔ‡Ðc‡£h³á») ç¬M;=q]­ZµÔ În³ìœý¸r$ÚàTíܹ³ÒPoÕª•áè…£ã1GâCfðxÁ±o•— ¤p ¯µÂË–-+P20pkkݺµ ê]œï3fÌpJ’ ‡4$U0ÁP¥Jc‚ý­Zµª¤I“F_®¶þ|hПãE{X9k'÷ƒsÚ°R`ûöí2wî\U„};ƒî>¤Ìw¬¸À„¸iƒÜžW¦L™Œ÷ÖÞ½{mîúý«¯E_ÍmaÒ§B… ò¿ÿýO倆<¨bÒ€F$@$@$à?t¸û%[Šø‰h$ €÷6Íšh\TúfÆþãGäü¡?ŒãŠÍ¿À9Ä©°3ìpüë‡;$ež´­n#*ÙGãìþµËdl›·œÕO®rÿïÑ-ëåë&5²5÷CU¼yñœüС‘«õV¨sæ‚9ºÊêF™‹ÔþcG"Ìeß q8χ:g.رh®Lý°¥< qŽ>F+'*Íô ‡÷IýA_I‡< -r @îãСCF'dÔêl7N:vêÔ©#Hš ív˜]’Vuâ¿ {¾lÙ2¥óm.×û˜8€<$m`'NœP$˜<ðÄuýã?ÚFïçÏŸß© L*˜eM0ÎqãÆÉ#Çg‡Á¡;}út¥ñ‰ hÛã’+‘eތ׮H‹ p>~ü¸’šÁŠÈØÜw¬HѦÈêcwÛŸ~úÉÉA®ë¢]0Ä îgg˜1&w0±Äµx†p¸cÕä{ ­wÔARV €ÿð›¹ÿX²%   ˆ2 ²ÓáÐ…%JžR U®môýò‰#NêLù‹çÂÚÉ\ °áp¿xô`XÕmÏÿípÈ!úÞjCîÊÞ¿ÈNG’Vè·?› ¡4ù|¼¤ÈÙZÕ8†´ "Ó¦Ë ¹K–sD¥§äŽúfqeH;£w{ÃÙžÐÉþú‡åùR””ÌákdÁg½ ~víìY¾ÐÉÙMúâµÞ–dé2:¤m¶ÉÏÃ?24ïí®Ç¤ÂÄš( }DóWi×]9ø%M.G“ ÷”;Ž¤µë§~/ñŸK"uû|f× Ë"Àž={Œ»%L˜Pɾ.v>ù䵌$¬Õ«WwQëI1êHªéÎM>pà@Ãñ½uëVñÄáŽd«"3ÖÃä‚Ù© I¬,õÆ¥YæíxÍýD9ävÁv¢Ø]"ѵaÒÂÎ5_¿~}#q1VÏ™3G½t}´‰™5j¨Õ Ð’§‘ ø—îþåÉÖH€H€H€H JØþólytÿ‰~tÉ7ßuÒZ¿tìi”.“"ãS‰°—2s6£ÊÅ#Œ}ovU>ò­'²î®kúåD)V£ž»*rÙ!ÉRüõ·•c>^ÂDFÝ?V¹^!·nêw¢Äs$†í2{•dÊ÷4J‘ü9^,%Cj½l$œ5vì`ÂŽ~m5þ×W^ï6PªD³y˾"ŸÕ(!7Ο1ÊÍ;ó>éa$¬}oÄòò[Oõ®K9çrÈè|üZ!5ñ°nòhå·ÊјÛã~à ˜Ȉ4†üHX†ˆcD5{bÐ ËàôF›Úùï*ÚÚþž:Ûq­nßÚŽ7Çf^Þ\çºÞŽWß+  íïÊá­ëEæ22Ðùÿᇌ‰s° ?x!‰-tîဧ‘ ø@Øßýw/¶D$@$@$@$$œäd4wêÕ«—c8©½Ið™ÐA®-äÖ å|ÖÇþÞŽkÛ@Æ´¨k+¹¢ï…Èö÷FL³³]Ÿsµ=¶åit}éúÍœœíú$N-ñFC}è´=»o—’|A!ö•ÑéV{.E*yµugk±:¾~ö” B–!oA'g»*tü“Ú‘¼µl£Öê’3kNwZä0;Øͺëþê’­†e·oßVzëº^ ´¹!q^»~ýzx›ˆÐë‘Ñãfg;¢Å¡¡_·n]1éè°G¦%NœX%E=vì˜|ýõ×]8Ô‘Àj”Ò¥K«¼Ös<&  ð#Ü}gÇ+I€H`Ñ¢EFb-Ooƒ%ÓXJK³'€ˆZ'zXN ½Ùõë׫®”+WN0F$XzG @IDATAN†fÌç¬û›:[N£pæÞÿó¶$H’Ô(s·sóÂYã4¢Ý}чṪóÖí˜wÎØ+»–Ì—C¿­hÍïýõ‡žú»Ò~¢}”p9‡SúYG“¹Mëþ¥ãO#ü‹×®o=mç¯XM¶ÎŸnëãçKU”ø§»å+÷š]±œwè²kK‘!‹߶Q:m:äe´wp¡E.—_~Ù蜳\±sr•¼Ü™5k–Ò@‡î»AÞ¤Y³fJK\ŸGÂÓ@˜9'Úoß¾½­ö»»{û“»ûøëäîܹc4‡Ä£=zô°•ù¬Ï€Œºµsúôi™2eŠ”)SF^yå•°VßïsçÎ œì+V¬ï¾ûNîÝ»§&ºuë¦r èºÜ’ „îáãÇ«I€D ]»vêG7Í:”w7ÀBBB¤AƒªÆºuë‚ÆáŽeéº_˜h©Y³¦›Qxw Í:’fÎœYÒ¤IãÝŬôyêÔ)•ü Q…4Ï lž=ɨ\ÚÝŽL1Ûõs§$S~Ï#:[[úÜÎíèò°¶±ãÄDÛÊK7h&»—ý$ß·~’´ô•‹äìþÝ’¹@h­ùt¹óÙ5ã² zïHHª-eF×ÉSeɦ«9m¯ž:f'ÏÉØ·î@KÞÎÌR<ûV/¼Â²Û7êÂóaˆ+–Qãò姫<ŒBÓd9vîÜ©Y>óÌ3êŒÙáþÀ‘c S§Ny° NÒ‘#GJÁ‚¥uë'«ì®Ã´Q£FÒ½{wéÝ»·@'^œ¨|ðS"Ó@NbC²$gÎœFòNüÿ ç³?“o†÷yh6þØ‚ýêÕ«¦ðl¿üòKãؼƒ@ÜÔ\û-[¶”U«V©÷øâû6ðÄ1^UªTQï·æÍŸ¬nB4üµk×"=:_÷•[  ˆêèpêOý'hNËb³dñL;8²—ðFóG%‡U8dGåQòº(9ÈÜi8xÍ™"E ‰jÒ‘ùØ /¾eîTÕ…gÉò^ªóN¨îÀŒ(s­ñ~pýJîÑ8¼iÑ^ºÜ[uT¤Ú*êÑ÷°ã¿o´u¸»sx5í A)þHœ ‹cJThª¦vÿuŒ×ÎÌ‘çÿõÈ®Š*»çIß­àô×–8UIžÞµÓ^×Kš–«ƒ4 _·Ù³g7.ݲe‹r¨›#¹ÿr¼'6oÞ,S§NU 3oݺ%˜ìÛ½{·º MQ®¥_ ¡}ñâEéÙ³§Š8Žãx_iƒÃþÌ™3ª­aÆ ô°üù󫺺žu‹IdDZ1BòäÉ£&“=ªþ¯ƒSXôØçÍ›§->+¡ÝûÁI¯ c™={¶>TÛxñâI©R¥\NXõÕWR«V-UclÉÿýßÿ©IäÉŸ®¾@¿h \áˆÞµk—Š¬Æ¸áøueá}hןã5O Xü —CPÉNœ8Q½ôóÄ9$.]²d‰z®I“&E‘2p@„ÙyŽèt¼Ì¾7nÜ0ŠpŒ±aâCV2ê÷úƒ÷f¯^½NuóªFÔ[¹r¥zék%J$É’%Ӈܒ „“îáÈËI€KàÕW_• ö&lH€bDKß¹vE¸Hõº’0ih' KùÊW6tÄ×LüFéÃíÎþpÈ»\;}¨‚6iñŸK¢änp[—/ØÞ*v,ïRa쩲äe~ýÌIIœÒ^‚ëªãœ¥Èôt¢øòñ#vUT™YzÆ\)mŽÜÆ!dgššbs'pþÙgŸ©üí˜ô€þ9œè˜ÔCô/¢ÞÍNmT„tÌÕ«W ‡&¤ÛJ–,)'O>yoÀÑŠœíiÓ¦UÎë+W®(G¼µ-´‡ûzb«ÑŽ~k}¬èÂ=ÍNVÔÔH3Ç$¥Ý}19­W›™ÛÃßÃ7ß|£$cÌåØÇŠ´:È·ß~«NCÇŽU¤=îœÍà†‰«AvÅÃ=¼Ïßã‡5j¨£¤ðàÇáD?qℸÒí¿pá‚b7n\Y¼x±3&t0™aµ6mÚtá8 VàüðáÃÕêsÝ…  &Ñ^ÕªUÕ)8ÒÍœoÞ¼©&{0á£XîÞ½«ž‡yBC¦ý£‘ ø‡€w¿@üsOŸ[ÁèÎéW°D³áËÕùóç~éþa‹/>4   ›fN4ºb''£OÖíó™ÄþÏ]öUã¿Ò§l·ˆ4_üÅÇƹ}sWåF¥pìÜpôɬŸ*ËÓèäp4«.M-—ÑÄÎ¥ó}ëÎöŸfZ‹Ôq†<òc¿ÿ&—Ž6ŽÍ;æĵæò´9ò‡§voséÈäÀÆ'¨×É][k¸ãêÕ«Ë»ï¾ët1œ¥'ƒLˆÕQ ',"ˆÍŽmìÃÙmŽðFƒp¤£-8ɱµ¶…:Ðц“Ù•uíÚUêÕ«'æä¬æº˜A>,¹s?´ÑuÖ¬Yc{_}Þn‹~š¥T¬u>ÿüsyÿý÷ú„ßFp²ƒ"±ÍN`óõaéˇ÷yø{¼ˆè·æ Â$äX\9ÛÍãÅïBÑn·ú@×Åês° ÆagxOé88ß±bÉÚ?}´çù"«³ï9è¹ÓH€H€H€üG J9Üñ…BëÎa«5çü‡Ãû– _¬3eÊäÔ7ÝO|ᥑ Dmøá³cÇõ# ‘Až¢Ïðãfùòå²téRµŒÚÕNWmâ+–cÙ2–²{bøqŒååˆzB¿=ùhm†¿þú«r0XÏ…uŒeé›6mh‡ÂðƒuÛ¶mêG&"=1;džÝu7Ú^¶l™ê»§ýF1^DPbù7Þ¾˜/ï#}_¯õ•%þFð|ñþÃûØÓ÷½î/·î ܾrÉÐGBÓ<¥+¹¼ mŽç¥Â{íŒóó?éáäP7N8vÐ*)u”#¾ÞGÃÍUü¶©—}k–Êøv ÚÌVä%§ãð@#^Û†icåò‰ÐQêèÃþµËt5§-بTÝ(›Ò¥…ܻ嬱¾yÎÙñË£Žy'}ž†<ôä7Ïšd>­öÜ»+£›×‘i=ڨ׃;†ªÃï Œ7N>úè#ìêjè”wîÜYI£ <8T58=!¡‚vïÎà$mܸ±lØ°AE2ÉïÊ o3wî\õÙ8aÂ¥ãÞ¢E %1.¢¬¡ïJI>_{í5å˜uus9"­+V¬¨&Ìåæ}ô̘1‚ˆmHÊ„eˆ¾‡ýO?ý$Ƚ–…çyø{¼ˆd‡óÌ]Mz@âQÿ :>=÷Üs*ʽU«VjȈdÇ„‚Y‡'’$I¢’—š'~0‰R¾|yѹPÏÚÊ`Ðö‡#¢ÞK”(ñ¤ÐÅ¿È0gÎõýÖÚ—°˜H€H€HÀC\7æ!(»jp‚`‰4ò‚ÝŽ?®–‰¢Ï³fÍRšÁÞgö|%€¸ü$ÊË ñÃÇjÐôÆ1¢ˆÞxã µ_·n]õ#?¦ð÷ýÎ;ïÈÚµk §~`A¯?°ëÔ©£®±þg*ÎãÇ0–R› ?¤š6mª’£™—î™Z¹reIŸ>½Š|Ã2hh´ÂᨠZª(ûðÃÅîùíÛ·ÕRn,1†Ó[&ûöí«î«Ëì¶pÌã‡:˜!’OXF=dȧ{8ýX8°„zéX¶Œ()|.âžèox ÑoКýþûïåí·ßVc@¤Ý½{÷ŒfñƒrÚ´iF4~ ¿òÊ+ÆyìàYëç ý]sb»@ŽÎc$·ƒ.®ÕY^­Z5匱[RŽ>#2ï]èÝš£Ñ oç Øš|ãšð¼Âs-î ó…å“+Eéεwï^ãï çðþE9ž4fa*TpŠêƒ®­þ›€“4{[çM­^êí¦7ûÚɈ.)Mö ‡ö©*‹F”m gJ®e%GñRrçú¥~ô÷ bvøÖúp€¤÷2Y©¹CîÉçoV0ûì—ÛO?ãp¢|“¶iÌ„±S¸JmÉZøE9½g»×ð7ÊIžŸHî’å};°v¹,þòi4¿]s5þ×ÇQo™Š(FôùÇ• KŠU%Iêtrbûf9²y­`ÒÃœdV·ƒÿkÞú¿òEýWUÑôžmU"×ÂÕê8ämÒȱ­dóœÉrí?I›Œy_¼éZø $H@ u‚Ï|þ"":ìpbBBßÌ:ܮ2hÿ/âs ‘ÞZ‡NgüŸ.]:)T¨P¨hxWmêò9r^ÞZ‘"EÔd¦·×yRÎvðBÄ7&Üñ `Èèè@$lÚ€°Þ+<Ï#ãÅ3ƒ6Ÿ>}”Æ?¾áÿ>LÂ@sß/ôÿÍ3fÌ°Ç8Æ ¬„ðÄàlבñaÕï½÷/mxÏá¹à{ž Þ—úýƒïwúÿN]Ÿ[   ÿ Ã=á,kÒ¤‰Œ?Þc½ÅpÜ.\—"‘®0D2ôë×/\íñbfHØ'9¢Åzôè¡´2ÍK«-ŒÀ0ü ÖÎvó˜ðÃQ]¨‹/8uáÔòaD­Ã1Ç>V¹˜ ðp¤ê¿7\‹ˆ4l‘ ø¯¿þZ9ŒñƒÍΦOŸ®Vð@ïÑGˆÎÆ=µóÎWëß0"à1 ôˆ|ÂML¶ÁQ ™v÷C$ºàÐÖË–áXÈ–-›Š¬×?œ1v|~`,v†h,kÂ5»z¾”a2ŽTD>ÃQQ´hQ#é~Hâ.ôr1¡árÜø‘ MTý^€Ó ÌÀ“2p ¯ZµJm­cÇŽUïMíhÇc8g¤ RH4‡g…ÏvWI…}yiv¾\–_~ù¥š˜À¤0 Ž 8ÚÁLÞ`•&“ÌUº¿ÜzN@K˜ÀÉRª~Ó0/L”,¹ôüy³Ìþ¿ÿ)Ù\pÙ!‚×ÆC†%tÔo:r‚ªüz˜m»«€d¤Ç·mtWEÃ8JÔmäpN ³®·š|>^¾kYW9µïݼ.3z=ö×mUn×M~ó¹>tÚbBâý dBÇÆòÐ~ûÒ1ËùÀÙÞyæ¯Ò¿Lhé4ô|© ‚‰‹Å_ ðX1f¸z9ÝÄq€v:Lù…Ž3+˜pÃ1ŒÿÏÃkˆÆÿQæ‰Þð¶Ì×ã³/wÒ8¾ôß_Ï×{Û]“3gNCcÝî|°”á;‚«ï ÁÒGöƒH€H€¢#ØQiP˜…Gä¥~µmÛ6Ò»HN8N Ÿ€(LDY£ÁI£ÍU‚%}ž[&ˆ‚¤DX/í¨Cßá¨FT~œ!Òå: ˜XÊŒí‹/¾¨—vãEÔœíˆT‡³wëÖ­Ê™h-DÁ ŽÈ5kt–GÃIˆäTtƒÕˆLB’48`apLë>™ïÏô}Ä>ú€HgüÝê¥Ú#GŽ µ²IÐàlGÂõ¾^ë+K0éÒ¥‹’ÎÁߤh¼ãÃûWO.á=…U0DããùBj­dýÌùåUÆB8±c³r”ã ¢¡Sd|šØ3tí§%Ï:&‹+Í¿š"ÙŠ”¸ŽÏ«%IVŠÖ¨'}—í·³ÝÚ¶ùšò©²æ¼e_• MÛIÿU{¥ÙW“å›>™¯óe?cÞ‚Ò{É6)Vë-y&~§&â%L$ïý^*5ïèTn=(ôZ-éùËfy­mWÉýrI$©d)T\ªvè)]笖dé2:]òl‚„NÇ5;÷“箑 Ž¾X퇔îßý§ß$yúLÖÓ<&    ˆ$±N—#éÞÑò¶Ú±¥G]‘mÅ€玻D=‘ÝWÞŸ@ËŽáxóÔ I Íg³ÁA¬e_>ýôS¥k‰ˆv8i±ŽM,ÿ5›–”A¢×-o5hº#R ×#z]G0£^™2eÔ–ÛéºîܹSŠ/®š4>h9œ@T˜9 –ªìøŽo­é‰I48cap0Ö®][íÑHu«aÒŸE˜0€Áá Yžè7&*àäDd¼Õ »ƒÏ8zñ\eÓ’2ØG”6"®­‰âpÎÁ‘ª£Á\³fM£º–”A¢Á­‘à(×}À³ƒ´Ùð|á¼Å3ïÔ©“ùT@Ç 8axnV-W”/\¸ÐX]Ïd=óꫯªuX¶Ž¥ê˜¼±ôrÛ·o¯Š1 XXxÞGá¹6<ï!üíâÙâýŒ‰-è› _S09†¿^xAI3èó˜ÈÀd&ׂ%‘ºî›^¦?l÷E‡Hj]©[DŒwH™Àò”®¨$S|é4ÔÏv$CÜ»SžK‘R²~I’¥wvûÒn0_$(½|òˆ¤Ë™WÒ9är\i8{3Ž«§OÈGeŸW—¤È”Uo>îòòwïÈùƒ{åÖå‹’ÒQ7]®¼ÿ¹ÐŸ.ð‰u“ÇÈÌ~ÔÿAZíà!Uóø¿Á<ø_OÐ#بtéÒj5þÁgH€H€H€H ¨„8~ &ŠRS8¯ulóp’!jýCg0"ÑGD"ûËîܹ£"{± ¯¡_è$7À“sÀ ýÁ¨ÃyȹÀ çbu¶«ÿýIWÚˆX†C' œÔÚàÐÇJW‘ÇfMwDäÚ™–»±žƒCNq˜y2bÒ¤Iª 0õêÕSûÖ0Á€¾Ùd±ðÙ v;g;®Á½áìDD¶¾Ÿ¹-8ž°úÈ[g»¹ wûp¸Ú9Ûq³™‰»¶ô¹@Ž«Ÿ`ˆ°oР¾¥Ó“AX €•Ú©ŽÏ*hÔÃðžÕåN:=‰ôííÌÛ÷‘¹ o¯õ•%Æ g; «Vg;Êá¸F$;8½õÖ[‚ /šor¾TFª8$Pð‚>¹¯Ç1ñ–¥`Q)Û¨¥©öF´w¶ƒ’ÀfÌ÷‚sDñgp$4 ËÙŽÏÔ/ê¿&ƒ«W¯‹GÚâ>°n…Qž>W>cßnÎu<Ã⎈{$ˆ &g»]Yæ;¬ØBàf´³­áó«àð2d[ì&ç}¿+¯$   ð¸þj(Pí Z²XRoç GÔ¶/ºt€ÁxDcš—ò#!ôœ[·nmDjlví"cBD "ý0`68É=[h»3ÈAÀñvˆ’Ô¦vIúàÔ€^4’ñéÈL}y 6’A"©#"toÞ¼©N£oè"~qˆ­+Ã1 Ù m(à ѳgϪbô +üà€ó rž¸¡þ–-[”£ÝìØD4tˆ&…c Úšp.A_†>á Þ#Ð̆¡¢ŽQª#{Qéü(k<úÂþÀ{‰µhá#€èWDó†eúùYëÁÉŽhcD£k'bÇŽ '­µ¾>Æóv— IDµ>|Ø{©_¿¾.6¶pãïïG-{bœ´ÙÁß¡aŒpòàÇ÷ýû÷*pZÂ%îÎ T«V-¥io\øßúCô:þ]™Ž¤Ã|hã›­R¥J}¿»b‚>à³ff¢ Âø'ãÖŸ¹ø¼v÷L ¥b6¼—´á½ïÊ0ñæ¨o¾Æ\ß3Wï£ð\ë+KÍ ÷ÆûÓ•áÿwÿ§¸ºŽå$Yðý%U–l²iÖZÕ…ût”6ßÏr¬Hetißê%òóðþÆq¹Æ­}îÄløÞ–áû8V¹ûÎVùÄ8Ö;ÐZÆdÄŠO#×ô9n½#€÷O®\¹¼»ÈT“4ˆ¾Õ2.p*c2&,ÓÚß®êa’øÓo]IñÙ÷ þVÌ+5<ù<1Oêè6Ým¡ï C4œ;s5&HaÁ à‰ €u"׆çáú°Ì[&aµ‡ó·~&д÷Æ´«(²9V,¸³çŸ"C{á3ßšL4<̼½ÖW–šþ.½½§;6‡¨z8ì 9mvÌ„»áp6`vfûÚ”'w_ÛÆuæöáðÖ‘éîÚ„CŽEhzcÁÎ>úè#ÙŠ÷°fƒ³å0ÜÎWš @Vž¼! ƒã ÑÁ0èë›™(ƒL‘^á0hÐ åŒE¹ÙàÈÄ$ž1r(@R}€ôÑ‚ TUH™uà+V¬¨¢éqNBÈ@÷JX1ƒs8 µMãÆeàÀæÛú¼9*¬Aô=ò Ïˆ¼‡d¢¦ñwŒü® “¬‚SNOHéÀ‰ i*ŒkLZ@–FO^¸j+˜Ê .¬º3sæLABhôŽ]m7V»L˜0A°b úä˜ÜÃý1ñxOBÞ«-Ð7ógdª°}ÅsÃûï%<4ßñ¼‘T;X,<,±"«·à@Ç{ÿ'"¯þ¿Æß&¢õ„šy¼8‡÷6&1¢ÒDy Ü'     ˆ^b9"©ÿJCB$³ŽXD¿¡ÛíIÂ8D”jío$ðDÂC«ÃÉÊÔÙ³g«b,[GägX‡œqÚ Ån>ÖåÖ­ù^8‡h?8¾2dÈ`­ª"bu$5"g<ªŽµ’:("{çÍ›g­âòÎr³£,ðÆàA¤¯Ù”Ö¼ŠÎI;Ç®A’T8—`R5j”Ú×ÿ ™£ÖLÆÄž•¿œ/ptá=¦e à,…Nv«V­ ‡;&tà8ó佨ûÌmpÀV>@ÒIO¨Àù  >3ðùƒ(Ú°ÌìLǪ «î4ÞWp&ÂÁ¨ó„Õ¦7ç‘(ùèÑ£*º>mÚ´Þ\ªêâïŸ_ˆ¨Î™3§`2!&X Ç Y<|®ÃQìiâOL"Bï)¼_´ŒJ°?_YBöŸ§X=„IOs>•`³¹ú;Æ°Ý%qʧ9aÌu¸OщÀºÉcdf¿NJvMŽNããXH€H€H€H€HÀ!Žß‚‰âzP1ZT÷ǬƲ|ùrõª%'쇮ùÇÖ2Ìy¬^½ÚheDûÙÙ¥K—ŽjoMÿðÇufk»v U°sçN%O‡dàpÓHˆÉWÎq»6] dmpÖ€¡'R §OŸVÇpb!¢ÔΠ÷HT­Õ>uêTõcròäÉFu¼¿èl7pD»HAÎÓۣ;¬<ÞÜË®.œºvvvuíÊ´ü‰Ý¹è\ÈqC¢È]® W\ n¼¢’ùÊ“¦æDÙQiÌv}ñf‰å˜”¥‘@t'r+ìÀ”è΀ã#    j‡;¿D0;ˆá 5"ÕÍãN€óÕ9ˆ¨l8±‘€†q´=lØ01‡߇VKõµF3êB’ZÍVCÿ°äNpm:±›>†.;"õ´Ažý3'Å9³CãAÔ:ä0`H‡6UÊÚy»dÉCÛW—[·fçú ‡:t™µ!z<àLž;w® ™#"ywïÞ­ª@C·V­Zj/½ô’ÒȆ£Ùm †Ï€ô& ÉpÖIÑÊ‘ÐÒl+V¬Pã°Ê²à~æÕ8Fä$œ9ÚàXDrAÈd$ìÙ³§jÓ,)„ç†60VôKóÄ}]9U‘8‰7q-$H­å ­w hø+Y.Ÿ8¢‹¸%A+xh$@$@$@$@$“ ­¤ œìXJ®äÞ<$$ûC46’Ñ™ ‘ÙÐòµj|CzÑÚH`ç°ÕÉlÖñÆùk×®©Ä‡žêÁ›ÛD´,úg–iL‰9bõ±ŒrÐx¶öÙÜöáô…þ­Ù©m®ƒ‰ k²98©Áco«º&!0™ —ówìØQ%5·‹:8œÿhG'5×CòFèCÃàð·&±Ôu1YDÔÆ®¢éõy½…ã…<¶«W¯*‰88̆ºˆ4N“&Jž G¼u¬¨ €òåË›/uÚ·?* úÚî´èAÀNR&zŒŒ£ ˆH˜¸ÆºÝÿ7Ù˜|/<|¦ÃÖ¬Y“QDØرB¹>ðýF$@$@$@$@1@pKÊlÛ¶Í'g;$~`!‚ÛªŽíéÓ§K»víTýБ\ZðVƒæ2Zí¨·cÇ“¯ZÛ…cãÓ‰qäˆ 7÷d¼<1D[ÃaìÊáŽ{!1$Ư ÏxÙ"î‘`Q;ÛQ ëÝ i=€-œìx¹3DŸks§r¬.èÖ­›ªîê2úäƒf‡;úŠh8÷‘œPêº+êá~ЉwgHRˆÈyºXIèw ˜ `ò¿B… æ"îG0ów¨Š+FðÝy;     ˜J hÃOàHmÒ¤‰ŠJöæá@²Ñâ•*U²½ ZìgAÂKDšÛ"ÂÉŽ­®t½áÌoÚ´©[f»¶i¶+W®ìt‘ìp.#Q£«¨ H¨tèÐA6lèt-&jÖ¬©ÆätÂr0nÜ8%}â.ù!"ý!ŸÉ—Áƒ;µ€¨¥1cƨuHÊ„eˆ(‡ä P:Ô¨Þ¦M5Ù0aB£ ;xX€‰mpú#êÜ,än¼H" IH¼XW8è6õãiܸ±lØ°AEÒ›e}tó+Ú¶mk.Rï.vBåºwï®ò7`bŽF$@$@$@$@$@$@$@$@ÞZIoák]D¶¯]»ö‰Æª#BâlÙ²©ˆ48u#Ë 7ƒ}8ŽA'8´`í´é}é#ôС¯=|È«dÉ’E _Íx8þ=5DŽ!"¯óçϫɇ̙3‹~…åðöô>¾Öƒö=&M ×®uàñŒ¡ó‰™B… 9éÏ{rŸ·ÞzKt„>äoðŒ‚)y¬'c`  ˆ ð=ÿïÃ(íž8ÇH$@$@$@$@‘N@IÊÄh‡{¤?v J€ó¾H‘"Æö÷ß_EüG©A°³$@$@$CÐáC4‡I$@$@$@$@ÁC@9܃VR&x8±'$ð„À€ g{¼xñ¤oß¾DC$@$@$@$@$@$@$@$@$@¸ÆwH€  Ù´i“ ‰+ ‰x¡E¯­páÂòǨ¤²p¾ÓH€H€H€H€H€H€H€H€H€H€’2|€…ÀÈ‘#åÃ?´”Ú8P%hµ?ËR   È"@I™È"Ïû’ @Œ%@I™ûè9p·6nÜèö¼ù¤9êÝ\Î}         ˜G€’21ï™sÄaèÕ«—Ü¿_IÊ<|øжvœ8qäÅ_”=zØžg! @Ì#@I™˜÷Ì9b   ˆö()í1H$@$@$@$@ÁF€’2ÁöDØ          ¨K vÔí:{N$@$@$@$@$@$@$@$@$@$@ÁC€÷àyì @&@‡{~xì: @ð Ã=xž{B$@$@$@$@$@$@$@$@$@$… Ðá…»N$@$@$@$@$@$@$@$@$@$<èpžgÁž Dat¸Gá‡Ç®“ ¸ÁÓßzrùòeù믿Œ‹S¥J%ñãÇ7Žý±óðáC¹zõªÑT‚ $eÊ”Æ1wÜ ?÷|xÖ{ëÖ­“:uêÈíÛ·½¿˜W Ä8±bÅŠqcæ€I€H &H”(‘̘1Cj×®“†Í±’ )(á¾`ÁÉ‘#‡¤K—N2gÎl¼V­ZåwÔëׯ7Úǽš7oî÷{DçÉ/:?ÝÈ[HHˆàE#     ÈÝ»w ‚H€H€‚‚@”p=z´œ,åÊ•S«À<˜›„Ñ*V¹'Nœ8ŒZ ÔóæÍ+ß|óqlÙ²ûÞîìٳǸd÷îÝÆ~tÞñ'¿è̉c#        ˆÚ¢¬ÃØãÅ‹'Å‹ø€n{‡ürŸþùÇhçßÿ5ö£óŽ?ùEgN @Ô&e“¦zŠýÊ•+ràÀù믿<½$ÊÖ»pá‚=zTÌNýð K…æÌyôèQxšŠ×ú›_”4;I$@$@$@$@$@$@$@$@$à7Q:ÂÝ…íÛ·ËgŸ}&kÖ¬‘›7oªjÏ>û¬äÏŸ_ÉÏ 0@’'OîêrU¾víZ™>}ºìß¿_ì"Ñ‘ð4K–,nÛÐ'×­['Ó¦MSm9rD îQªT)ãXïÄŠK ,¨$sÜÉåÀ±>a™2eŠìÛ·Ï+t­ .,ÅŠ“fÍš©­n;¬í¢E‹dÈ!²wï^¹sçŽQ=Nœ8R¡B©]»¶lØ°AµÙ§Oã¼uÇŸü¶nÝ*;w¶Þ"Ìã¦M›Êûï¿ï²^ ø¹¼O D{±Îä(­k":i!žVîܹU”·»'—!C;v¬Ô¬YÓ¶¢á!ƒrùòeÛó(½r„é¼dɹ{÷®ª†±L:Uš4i¢/3¶ˆT7;Ïu{/½ô’ŠT@”®]»dôèÑN«àXweþägu¸#’ sµa•Ãøñãåï¿ÿÖE¶íÚµ3ŽõN ø鶹%        ˆÙ¢¤ 'Å ,H²XmæÌ™J];g¡¡¾qãFnº;ƒ¦9tѵy*)£ëëí;ï¼#Ї½ùæ›2oÞ<}Ê£-d_~ùå£.œï3fÌرC/VÀ¸ªT©"pHÃR¤H!”4iÒ×cæø;vØê¾Ãñ]¯^=Åšø³)T¨S[®ÂÃïÔ©S’={vÕt¦L™äìÙ³Æm06¬V€^¿6È áØîù‚Ÿ¾/·1“%ebæsç¨I€H€H€H€ž ¤ ß $@$@$`ˆž’2H §º³C‡Ã‘ïÚ6oÞ,'NœÐ‡A½Å$ÁÊ•+>"ª}ܸqòèÑ#yðàA¨WñâÅUâWÈÚÀnܸ¡ŽþÛA4½Ù*Uª¤ðƒVÎuL. ¢““&M’‰'ª(}Oíæ¶}ÙÏ–-›šœH tèÐÁhâÞ½{R£F 'g;tõ‘°ÕîùŠŸÑ!î ÄhÑNR’)9räpûPû÷ï/Ç7$H —’3gN·×ÃÉýû÷Ëýû÷®@¶%I’$Ʊ';ˆ4·ZÞ¼y•ƒ}öìÙêÔŸþ©¢Þù® íX9w×®]%~üøúT„l±ÉXµŒ ¤rÐHçhË—/Ÿ¬^½ZÒ¥K§‹œ¶âçt ÄX¡uH¢8ŠbÅŠ…9‚„  "¡µÁálÏž=áî¦ÃBšçp¬Û¢è!QÓ·o_%79™ˆ6íl¿sçŽT­ZÕÉÙ^ @éîÊÙŽ¾’_D³àýH€H€H€H€H€H€H€H€H€‚@´s¸{ŠXˬ ¾väzzmdÕsçLö´Oׯ_·­š8qb•õرcòõ×_K«V­TD;d\¬øÒ¥KËÂ… ­§~Œè{èÒ›“¼BšíHŽëÎÉÏÝ}yŽH€H€H€H€H€H€H€H€H fˆv’2[¶lQÎbwïöíÛ‚Ä.ÚŠ-ªwƒzkÞoß¾½T«VÍ«>Û9ÐOŸ>-S¦L‘2eÊÈ+¯¼";v4ÚD¢ÔsçΩd«+V¬ï¾ûN M÷nݺI:uŒºÞ¹uë–Šlÿý÷ß[!‘-tíS¥Je”A«uS¦Li”a'Püœn         K Ú9Ü‘Ô³yóæÊyìꩾÿþûÊa¬Ï[±º<[$Õvùòe½k»…ŒËÎ;ÉO…2´æ?®ê/Z´Hzôè!Y³fµ½ÞÓ–-[ʪU«R;Hš9sfãRôÇx!²¼`Á‚Š/* þÚµkNÎnãB?ïܼySÝûöíF˘(Ž½Ù±mwÈË\¼xQ¾ýö[iݺµQ?PüŒp‡H€H€H€H€H€H€H€H€H FˆÒw8U×­[çôÝŒdš½{÷D€ë¤¢ˆÔ††w¯^½dùòåÆ5M›6ur0ãÝ›7o³CQàf[ºt©“&xúôéåå—_Sž&{öìF3ˆÆ‡CÝìðGbPÜ{êÔ©2wî\©(îÝ»w«ë¾úê+©U«–Ú?s挒}ù¿ÿû?iÔ¨‘$OžÜhã=räˆlݺUzD¦6L9®uEDªÿöÛoê0$$Dp/0¤EêÔ©u55AHò#Fe‰%’dÉ’ÇzÇßünܸ!•+WV¬ô=pï6mÚ¨‰]†-´åÁ6}út'‡;ÊüÍmÒH€H€H€H€H€H€H€H€H€Hb9³ÿFEÇWÑÝaõºÞpDŸ:uJ#úëßeŒƒÁ“ Ä8kÅ*cü½råJŒ?L$@$@&!µDQ6Â(žÀxY-_¾|2cÆ 'g;êü?{gÕх჻w‚Kp¡¸–¢-Å)îÅÝÝŠÉ—âE‹»'xpw×ýçL:7w7»É&Ù$»›ï<ÏÍ—÷Þ$»gÎœa éà(Û¹.û g‹õòåËsÔ¬TªT‰6l(­¯UV ›S s>»ta‹s½µù„ ˆ-ùçÎKß¿—ÍðÝÒ\U?|/^¼¸>J1cƤìÙ³KW2F"Â.\¸`š,ã%J”0« ~æÌÊÊD[ò³²K›ã¼Sb?žì”¯{÷î»ÑQò= 7æ:aè<.vcÃm'I’„2fÌ(/¶†×üj®¾£¥Ùš_hÍ¿m»ôÇœYÂPlŠ-|ØCìƒÀ‡裸øï ž‹}<ŒÂñˆU\zþü™¸øåxÀˆA@ÀðN/^¼p c¨öNàòåËÄ; 'NL—.]²÷áb|vH€w8Eb‡SÀ@@@.eœVá®f‰;8 zMÚÓª¥³©öo©NËÁÎ2-Ì@èõ‹'ÔªrJI w¼  zÄN[Ê–-±q@ì‰À¸‰c¨g·Þö4$Œ@‚C@*Ü#§&ꀀ€€€€8(Ûë‘a´ aì?°/ÂÌp~{hªó?Ì@@@@@lO I’Ĵ휧íF‹  D«þÜHcûÍ b-û& wû~>€€€€€€€€€€€ƒ€ÂÝA†           `ß p·ïçƒÑÉ¥"@IDAT€€€€€€€€€8(ÜäAa˜          öM wû~>€€€€€€€€€€€ƒ€ÂÝA†           `ß p·ïçƒÑ€€€€€€€€€8(ÜäAa˜          öM wû~>rtÞÞÞ4iÒ$ºtéR„œ?&          à˜ pwÌçæ´£~úô)yxxP÷îÝ©páÂtþüy§+&         à\¢:×t0G'àããC¯_¿–Óxûö-Õ©S‡Ž?NqãÆuô©aüaDàØž¿éÛׯ²·ôYóRªtYìy÷¦E´mÍ,Yæ§:¨t•¦þÊ|ÿ–NØDgï¤OîÓÇo)KrJ™. .õ ev+ì¯NHn];KGw¯¥»7/ÑËg)nüD”2mfÑgV*R¦ÅM(¤]8uý³ÇvÒ»×/ä³ç+N.IRÊð‹§ÈûôŽß…ò.ïÔ09°%…{ØòFo(X° +VŒ<(K²{™Ö­[Ó²eË©‰lð%0kx úðþŒ4éWNÓ÷ïßd÷é2妨Ѣ‡ùP–ÏîO7¼OÊ~{OX/îUdøæåS4e`Θ½ îaþdÐ!€€@D&à}îݾy_CPêÇ"#¦åÏ Þ¤ý;iåKV𠘱bhqÌxòè9yõý|› a<ò(™ß|A¤¾÷öm?JG÷yÑ“‡OéãÇÏ”&] J—) å)”ƒ Ícƒ^œ» f÷ê¥ï÷—ü¹(ir_Ú°|ŽÎM³°'…{Ø3Gˆ)-_¾œòçÏOÏž=“%9^¢D j×®]5‘A'pýÒ MÙž3)Jž:£ÖÈׯ_hù¬~´iùd-ÍRàÜñ]Ô«Iê2씳@)KÅMgñäþõéñý›–å…¿Ž û7Ò°9{)flûÚ2¨MIúôñ½œÃ´5WŒ¸81d‚€€85õË·Óª?7jslÑ¥>uèãw¡*ðòùkêÛf´ŠÒV/O›*Ü/Ÿ¿Nß¿}—ígÎáJÑ¢GÓúrä/l(n9òf 5…ûÞmGhp—‰ôæÕ[#\^GüÜ‚æ÷p£v½šPA;T¼?{òB|î~*Çž Q|J•6¹Ñ<Â*2}ÔŸtéÌUÙÝ”¥C…ÂÝw÷lX=Ç°š'úˆD>Ü#ÒÓv¹¦M›––.]J¬|Wòûï¿“———Šâ6!°{ãŸZ;e«·Ð˜9´©‘²=W¡²Ô¶ß<š¼ò"-Ýý†ÏÜEõÚ “®^¸<»}Ö©]8µ‡£Av!3 UqMÙ#VªÕbõŸº•ïzI ¶>¦A3wCÉ­«gh꠆⋢¯5¹JÇ@@@À’Ykèæ•Ûá6ÔÕ»S£Ÿ:ËëÑ_Åk¸ Æ:þòå+M:º5êOÙn: ¯£¨u­Þ´å¯M³Â=¾yõ.íùÏ·$Üǃ€€8ÈÎ3ÌÄ™TªT‰úõë§MéÓ§OÒŸû«W¯´4@ $>ü@¶/—MÄŠŸÛÝ ”¦Ó·Sù_Zi-ž:¸™NÚ¢ÅG!ðU(nGõ™á(ÃÅ8ÿ#0¨Óòœ³Vãá^< šÔ•Ö˜GGno”÷.£¸ñbke†þ>™Né,ßµ @@@À @áî„ÕY¦4tèP*UÊÏ=ÇõëשE‹Î2=Ì#œ ‡«~xç{@o± õˆ•è,ƒA*ÍÕðò­LmúÎ¥ÈQ¢¨$£{j×ì4hÆNŠÙ÷Ï)[ï±EØOü…“»µ*}&n¤L9 iqÓ@ónS)q²4Z2è°õýé#Ûˆ•óÏß ¨¨Å¼/Ÿ?ÑùÿJ76÷|¼ƒµ¨`±q‘Á ¼;`ß?žôüñ=E¿~ùLìþð®5Ä®€>ú诌­xL—ÏsÞ@¯_< róÍ)È ¢€€8!S‡Ïц•;œpfÎ9%Všo_¿W›Ü/¿V¤™+FÐÏ *Rzá·=Z´¨òÞ¤}mZ¼e*ʼnë«tçÅ•‰ƒæhõg&îÎüt|nQ„‚Sùsôè‘œÍÚµkiòäÉÄ.f »7ù¹“)Sµ¹ÖÔɉÖTR½aw´xO‘&y”©IG„2˜eÕü!dê¢Æbe‘±zþ0-›}ÉgÎé®ÅÍøÒ*âÀÔ½[–ÈìOüSåyငݰt<½zñX%Ë{Üø‰¨bíöT«ùŠÕøßÀÞÍKhÖß…->”µ^ëa2ÎJgVº+É-?µè>²æþA&>¼•Fw«ª²µ{çÚYe˜û\°Íwkd‡jÝ’éÿÛÿNþ‡æë@/ž>i¿\AEÊÖ–áw®Ò¼±íÉ[ì:øöí«Lã¼À‘9‡;µì=‹\³äÕÒm¸ë2ÍÕš®^8bä®'eÚ,T©^gªXËÿyA™“-ƈ6@@@ÀÑ DM, ûîî›:l>ñ¨ …íȃ;è’ð_ž2u2Êš+#ñ÷ {—/Ÿ¿Ð áV‡“M-|ˆgÊîàA²ææóñƒ0ŒðºLî=!÷â¶ý\¤ï?_Nü‡–T¼œ; œØU‹›\3§¡ÎZÐèÿv1xŸ»N…ëžd)“˜•q[°à†î‹÷àÂé+òðÑŒYÓQ|qp¬-åŽÏ}â¹ÄŽ“Š ¦b«y˜¶Pœß>“€Ï=ÈS0;¹$IPqy¦ï¥gä¯"@@Ì0Ö´˜-‚D?)S¦¤eË–Q… 4‹ÚÞ½{SÑ¢EÉÃÃ#ü†žšJª,ÊÓft£Ìn¾ñ¤®_:©Í-M†œV‚Z±V{MáÎ ð—ω/¼Ä–Û·¯ŸÓú¬XÛ¿2WËÔªÔïB|™“WÏÓ” 袗Ÿõ‘¾ÜÛ×Ïå¡«§n¡n£W‰/=®úl-üñã;Ó£ºÆJË›—½hT×Ê4qù9#k{}k¬¨ŸØ·Ž‘b[ÕÛ³y1-ßQ|ÿ ’´;»ï¹zá(õkQ„~m?ŠxqÀÂô³GþFŸ>¼ó×+ÿNè$Úå]¦‹ªB@sRepˆN ÔEèÖ{tå ©$œ:| žôÿç¬^8m%-Ÿ·Ž^<{¥a%”¡ÈMýÇw6Rðú÷uj8P+§?ñ58Hàþ9åIesÖ%VB²Ì^=š ·)zÛw&­Zä»Ë0Wþlš{Š>[<¼¡rnõäîÉÈÂP`ǹåF ·ÅÜGõšN^GÏÓׯ~çñpY·|Y©ß¸N”Õ-£Q›©êÞ”Üõ5b`÷-<ŸQ½§ÓÓGÏeÙ±sûQŒX1üÕÓ'ðaœmëôÕü¯W­[^º„ lbßö£téì5­)¶bL*Õ*Cë–o®}çÈ}›*smÁbÿµµtâÐYš0`Ý»ýP„Û°u jݽ¡¶Ñ´rW¹@¡-kþ•§õَ굨NÅ΋!]'Éb-:×£fêÒÈžÓhÛ:ßÏجÌ×+܃;ÙA0ø\»KûO¡s'/ ã?·–é2¦¦-¦ºÍ«ùkÙšw¨|µþê!@@Àz‘­/Š’ >Ê–-Kì^FÉ—/_¨nݺôü¹ï‡J•Ž;XK€¹JôÖíœvïæ%•E®Y­·2µ²¾{ó¢ÖN@û·¯)›]³™ ¨®¥¼%ÓºkÊö1cS£Nãhìâ4qÙYi•'¾‹¬Ê–üsG·µÔ íZ7O¶S³y¿T(Ø¡Ÿêt¤è1bÉ:Þ¿‘Š{ŽdÌ^z_'¯hÑý¾äµîó‡Lë<ÌÓl?ÿ›ÙGÎß%i***\ûü(¬ÇÙ'þ]ŸKblm4e{žÂ¨ÇØ¿hæß7¨Ï¤šÏ}ö{¿tZOò>sÐlûAI|x÷:MÒX*ÛÙ‚þ—&½iÌ¢ã4}í5j?`!ÅwI*›Ûñ÷´âÿ_ÔU_–æ¤òq ±pE*•#EŠ$qlX±=È>¾_¿|#•ç³Æ,6R¶sƒÞ¤»ŽSãJ]袰vŠÄˆ~(]P«r|ÿi-¬Ç…rW +‘¹?½?pZ*Û9-¿‡›‘²]è4(ߎtîø.Ù,[š7ú¦î[øËNƒ¶#ÅÖàزV{ÃÛ÷ wpÆÃ}ß·^VM›)—‘²]µÇ ån%£ìr†•îæÄܜ̕C€€€QG¡$OôŸ¿iV\.ý—UXتœ­âY\³¤¥¥ÂŠš•ä)„Â9¯{N1³Õl\Iæ³õù²¹Ë0û¶fñ|ñw %ìûœÓ”e{ ]þÅ3W¥‚V•=)ze‰%²ø 㻳ÕËa½ÌO?hYãÌÖ”í媧©žÃ¨´ÈO™&™tO2n^¹¡*°•ò·oßTÔèÎ à ÕKÒßçÓ¨Ù}¨÷èÄ‹æ„•ùmk÷Ñ”ñ¿u­$e;·yóªïgh§þæC*¶d‘kVÌ+I&ê«÷"•™¹1kV°Ï\1’æÿ=žzjOú4•Õm95žÀîS†Î—Êv.Ç®˜:ökNÙsg&{µzhÑæÉš Un”.ŽÌµ”wÈ\}¤€˜'à÷ Ã|>RAÀn$Mš”V®\IQu‡<8öíÛg7cÄ@ìŸÀîºÃR«5ó7ài2kiJ1¯%àñÏŸÜÓJð›Ö¸ª„•¸ÊB^¥õ®·˜/V¡¾Åêú¼{:«~}…´ÜÌZŒ»$I©ûþÝü@­@ V`G˨”~<Ùr¥¤)Óå«H\± À–îJôsWiÖÞï\÷û’œ$y:领ÝÔ˜^qâùºãávo]õÛJ®ïÇÜœôùƒ€€øˆ— .uêge=ò2nAüJû…VÌ_¯¹liß«‰¦\ô+AB!ÚLÛ ËJÇ÷ï>è³ ó®y ç”ex‡ä©ÿ”ìœÀÄ,¬à, üijxéîìÎãá~ÖÙ\)§ù0O¶–gaeÿïƒZŠï6Qd\ý`£^„PŠ|öq¯÷›®Êñ-ÛÙŒR*ëóôaV”·Êvåãžw´ïí«,Ö— ,üüÉ ­[Ó‡DlÍâWá§Ý”[{ëýàß×ùvÎØÛölL%ýv1p¶ž‡5ãâ>÷l=,‹²5>ûà7•4éSRÍF~ Nüþ›kß!su‘  `™€u{õ,×G„)bÅŠÑèÑ£©gÏž²_¶öhРyyyQ²dÉÂt,èÌñ¼}õ\³bf¥±^Y«f“&Cºvñ˜Œ>yàk£òº¿xú@X™|ÖŠp;Ö»xÑ [Z›úƒ×ç«ðÓ‡·…ußŦH‘" ×8¿Ê¬û:5ÉSû)óU=u×»yyòð}úø^³WebÆŠ«‚Fw[ºqJ-¬íME¯8×Ó´Ç“§É¨%ëÝi‰Vô>÷½m!¾“·oü¾têËš›“>ac•j–‘Öꬌþôñ3’NÿßpãB&1v¢„?›°ks–Ïï=¡·oÞKå¨9w!æêq[¦+Eú1ᢄ-èYØ÷: û0gÅ<\Ê~×Ù_8Ò©·ngëu%lÁ¯$¯{M¯ÒÔÅEË’.O8ëñÁ¬¦Â U¥˜7ÍSqV’·­Ý›Ø  +¥«™QЪòÝÓº¦–Ò—evÛ±5‹,93˜N’ä~;P¿‰…“à ?×ÚÂý‘©Øz¦í›‹ëß}ÞÑaéÝçÅ,%W„ï~sbÍ;d®Ò@@&…{À|k‡ºwï.­ÚÙ;Ëýû÷©aÆ´mÛ6£m¡v8t )œ ؾ\SŠ—ªÜĬõ¶^YÊþÐ?üàÏÛÜ4ÎÛi”œ*½ùí¼F…D„e·(¬ðfáv¬Q¸ïÛêI+ÿ$ë° ¥p— ÿý0A5 ³E¾^"Q$}4̉“§ñ×—~,Í+êç’…€ïº­Ú \’Q¢dþÇe:P½¥¿>ÏÜœôùƒ€€ø'ÐwLGª[¦TZ³›„4§dæšüÿ_ïÞ¤gËþ4“òúå[3©–“J û¤!óde™þL(°}þs­RPX·'~áYx¡€]Ï°;›#{NÊ4þQ¦’Ná®sÉÂȉ>_?W} :—(út}øÑý§ú¨<ÜudÏi4eéP£tk"Üßy/_…;[Y[+û¶‡´¾“ųæÊHìÿ\?'ý\͵©Ï××Ó—'–>ª…CòùPkDÒ¸¦”‹)ú4ëÇ£§i9ŽëóõõÌ• (Ý)áƒù LÞXx÷­y‡kù  þ @áîŸ RìœhZ¼x1(P€|||ähwîÜIC‡•—à Gÿn\¨õ^ºj3-¬ä)\žþ7Ó7åÍ«g´Ûÿ¨ÜÏ-õĔ7¯œª¥gËSÔÈ'¹–a&ÀïsžÂ4ËûVÏ *õ»š] ÐW?b·Íž§˜æe¡ÿèîuq0”«–§<¾çgå’4Ez«ôõmŽ,¬óM%µ«ßbÅ£»~ã4-Çq}~j+9̵“2Ÿ  Üâè4d‰¹bV¥™›“UQ@@"0tSS‹Îõè ž’„s¤¿lsHXá·…*a·-‘#ÛÞx€-ºù0ÖëBÁɆ>}üœ”¯vv Çg²Å8+{Ù]×Ñóä&,ÑOôu9“:] Ê’Óo7žøا‰±éƒ–ìÐGXR³õ¾5¾æëÚ€æO^NìgÿÎc´yõ.ªR§œ5Õµ2zå,[Uüð)P û/âð×¾mÇȲÜÐøù¤ÂÝÖ,´A†R …Öá1ý»ÏçXó$î‡Ì‰5uÍÕC€€@À p˜r픀‹‹ ­ZµŠŠ/NŸ?ûºñ1b•(Q‚Ê—/o§£Æ°Â“ÀÍË^Âç¶ïößìy‹‹-¼~ Vý¸\³æ#>ltß?¾_öÖ/GKTÛ…- ÅeUÛÜVãÎãõMþµÃh:up³øâøUèÊÊûj¿v³Xïô‘mt᤟Â=gRZYVV+…;[ôçv7ÿEŠó”è­úUZxÞõã¹rþ0ñÁ¬ÉReð7$vtúÈV-]¯¨×­ ¤Jç·MûúÅãò˨þ 5Õ »ž¹r¦ÍäföPZUw hÖ±ý³v7±ô§žÓÌÑ‹Ì6Àÿ£Ó ‹cV‚³Œ×OÄS™-ÒÄRÂ% +ÜYŽ8#•êΖ;ŇƒRñÎVù¬Œg wå+žëê%C–tZô®Ï-l.pç–_¾kfó;ïÌ}V1m‹}ÄžÓ—ÊV)&Çå9g­,2^,hþÈ“ê\®˜Ö5å§ý—øòùkÚò׿šŸpÓ²*~¦lç4^¤`±5 Ùh(þˆ$Þ9sóH/§”x”*@#føº[UiA¹[ó¥=”ð%`þ¿耀pww§‰'j#ek v-Ã.f `J`÷¦?µ¤2ÕškasmGRô¾ÛR KðAmJßÍɶ5³hÖp¿öŠýX?ÈJØTé²ÒµÚiÍ{NïEk˜÷[zåÜaš3ª•V6‹›)SK‹—­ÞB ضL(‡kq¸sãm_;GE©ìÏ~u´Ä"GŽ¢Õþð6À‡¤ª…ƒø½^:­}ûúÕ¨:[¶ýoV_úüÉ÷ð³ôYòRÆìÊ%’&£ñb ˃;WiϦE2¬ÿññý[Ûãgúctkygnúö0&=Ftê;¶£–¸oûQ-lH¯SB³R×’°Rxݲ­òbkë Jéÿü¶s=v+£Lew2J _î,g„Õ÷¡Ýzw2EUyÏ%­?{â’ÅÃa_½xC‡uíè-˵¬ dqË(•í\œýL‘Æ÷Ü«7¯ÞÒ¨^J}n]c¼“@o¿xÆjb;–„?¯M¹PËæ…¶Èf Ú@lyèßý ÂÅ6'ìzF½û|Æ@@ ì@áv¬ÑS(èر#Õ®][kùñãÇT¿~}a)üMKC¾|þDÊ¢;fì¸T¤¬ß;cŽN¢d©©I—‰¤,YØ5KÏÆùiT×Êôן#iï–¥´`|GêÙ(?-œØYó#ÎVØ ;Œ1×d iµDì‹]ÉêùCé÷únB±Û†v åïæSiÚàF4¸]izñÄwQ‰}¿w¼ÈÈý [ï¯Ø@6Ǹïô#müßDò¹ršXÑÎ ƒÛ–"¥,Îí^ž×îÊbz…;žÊ³þµd³ ³ow>U/)Ó&§Â%|øYI:yè<úúÕø{‹RR³»–¬Baž#Of}3Á³û›¾£;hõyAƒ$‚"û6ÓÜÈÜVø-ªw'¾›ÊçO¾‡ßò‚’.ƒZª <06“6’%ª¦ånCZÑágœ­°-I™JE‰-ËO:+•àM*w¥v‚;GÞ,ôðîc:²ï)÷)ÜFã¶~;U›I’»Ð»·¾ŠöYcSÕz(ŠX„g÷+Jøÿ})aå¾fñfbËsNËïág(Á qåÇ]•)YÁC(týúª½^#ÚQýrí¥¢}÷–CÔ¹á@ªÛ¼šT ^÷ö¡uË·§+é=ª½ÙvT~PïÅ˦ ÕKÒŽ ûdÕñf“‡p“8©‹UM%K™„º iMcúΔ–Õì§~Ùö”¯pNqå¢Ti“ÑÕK>´oÇQípYn¸F߈™è%¼Y$ѹÓ9ºÏ‹V,X/ü¡'%×Li((» Âzl(Ò}hkj]Ë÷3þˆÓ„âý>•ôòvm´qåmEfqH-?c€€@Ø€Â=ìX£§P"?~|Z³f )R„>~ü({?~<•,Y’ªT©J½¢YG"°{£Ÿ;™²ÕZX=tVÀŽ[rŠ–LëAOí¥gïÕe ìt™sSÙê¿Ñ5Ûå'=f,¡ŸK9ó—¦­âðÔ[×Î[çë%ZôT¦jsj ”̱ãÄ×giáø.IiÐÌ´EXųúW/ky`åwÅÚí©Vó%ªíÿ Ôm9DXѼ¤£»ÿÒÆåté*M‰„7®=]òÚ'}Ü«‰D_`3åp§–½f’«p'c+©Õb¹,CóÇw ;×Ï5-FL*W½%ÕhÚ‡&Na”‡€€€€í°Ò°sÿæ4²×ôí?¾3uk>Œn _î|õj5Òlùö}š)ÑU!’èÖõ{2z`×qâ+K<eKUüA*ÜU=¶:— ®ŠJ…8û&g?îJÊå§9aEnÿ ]h¬PX³;+zù2•¨Â¿S¿æB‰íëóÜ4?$ñÃÛÐá='éíëwôúå[Ý{MX8Ðê&k5©Lì¦_û±Ò×þ‡÷E{§äe®‘ʵËR÷amüe…7 ^4‰=šø¼úE>‹ñæÈ1öÙ.H ÷ð˜ïª`As'þO.|,ž¹šø2•TbWÅ4Ï¡01ƒ8€„2ÛkZByÀhÌÈ›7/MŸ>ZµòõmÍ[1›4iB^^^”.]:sUæ¤íòµdWÓû.Ü åñ¨ }‚³²:knó_~TyÓ;+¯;^,“_>D| &[¼³’—ý†s›¶–?ýJ|}ýúE*}oxŸ’–óé„Ë>ì••Í +¸«4è*/7»”ù.euÍ’ØeŽ%)U¥ ñ¤É“V¶ì5n‚DÔiÈy½~ñDÎ#~Â$Z“3þ¾®… ¤H›™Nß.ÛàK ÿêìº'M7ág?¦Åê£ÿ4ïóµ@±*Ždkù ž§…Û7bÑã¬|ÞìW>uúì+N<³}eNf@"€€€€*Ña¥ötâðÈÿm›NÓF,n5vøs+ÊñVÝ~¥²•ý,Öõ°ÂòP:ïÚ´_ì ü"³Ì ¸Ë£Y°s!½;Õ[Û+…{ÌX1„Eq•åï^]XÒçŠt^Pð:rNZ»«Bìæ„ÝØôÛIº“Q鶼'I–ˆº h¡-hìþçm[·‡*þRÚênXá»bçLš$Üâ°_ûG÷Ÿú«ËJùžÂ¢¿ˆ8ØÓ’„' ¶Ö5«7M¾ÀØ-ŽøT yð»í^<¯\0¹&vGè%FÌèrWAóÎõˆŸ7@@ l DŠICØv‰Þ@ ô4nܘ<==µ<<<ˆ]ÌD‹MKsÔ@½&íiÕÒÙTû·T§å`GÆ  þðÂL«Ê)e:>–øð‹/’››%I’˜¶óûÌl³±!þÿÁ¾Ä¯^¼)ÜƤtSQšô¾ÿ[¬Ö‹§/¥â;a¢øÒêÙš:¶(ù²u>ûâN.eþ¹YYêh‡§^8}EœwóTˆÊnLx·@P$È•-ñùrdað¦>Úƒ:ŸðdÁ‹)R' êÍ–y°r=4Ü™ A@%àw,w EQìŸ@œ8qhõêÕÄw%Ó¦M£µkת(î          * p¬h4< äÌ™“fÏžm4„-ZÐõëÖû6ªŒ€€€€€€€€€XA w+ ¡ˆã`_îêUý«W¯¨N:ôéÓ'Ç› F          à pwˆÇ„A‡»’É›7¯VÕËË‹:wî¬Å[€ÂÝ–4Ñ–]ˆ3¦ôç?~|m\sçÎ¥eË–iq@@@@@@@@@@ÀV p·I´c—²dÉBóçÏ7[›6mÈÛÛÛ( )(ÜCJõížûnïÔ©“6ηoßRíÚµéýû÷Z          RP¸‡” ê; &»»»6Ö .Pûöíµ8          RP¸‡” ê;èÑ£ÓªU«ÈÅÅEïâÅ‹iÁ‚Z ¨!©Œº àH\]]iÑ¢EôË/¿Á`CgW3… ¦Ü¹s;ÌT?ð¡ §ö8Ìx1PŒÀ»7/+‚|øüù 8tÖ†-¢)Û7î¯"j€€€ÂÝŽ†f{Õ«W§=zÐøñãeã>|þÜOœ8Añâų}‡6l1ftß )û¶,%¾  àl"EÂÆ;g{¦˜€€}ˆÙ÷ïìëׯ©M­Þö58Œ@ BPŸ"4L@Ài@áî4±–À¨Q£èСCtðàAYåÊ•+ÔªU+Z±b…µM„K¹v-Ñ¥³ÇèÝ»waÖÿóçÏéáÇ?~|J“&M˜õ‹ŽÂžyø±··ž?}úDׯ_§(Q¢P¶lÙÂdx?ÿüs˜ôƒN@@ ¢Èš5+Õ¯_ŸÎœ9Cß ßœãGéËׯ”4IRŠ#†SÏ“slwïÝ•H™2%E‰ű'ÌÑLjƒZþÖ*˜µQ @ì@$áZÃ×·†ý #P#pïÞ=Ê—/=}úTëcƌԡC-ŽÑ¬Y³$“:uêHø`âüðÌÿ[;Ë/’››%Mš”?~lm5”» ÀÿÃøÙîÝ»©téÒv1& ̈)’LæÏ[ü¹   àÐÞ‹¿ëq°wÛ¡Ÿ!\©S§&OOOÒo[ëÞ½;}:ØÃáÝxÊßo°AEP#…{¨¡EÃŽB yòäRéÎ þ‚ÏÒ·o_*Z´(ýðÃŽ2 Œ@@ 0`9r„ *ds…ûùóç‰Ý¬¥M›–’%KæT_½zEÅ‹'‡³(Ü7mÚ¢Eýš5kRÔ¨ø¯Þ°¸‡÷ïDXÌ}€€€€ØŽ>­ÛŽ%Zr`¥K—¦aÆi>Ý¿|ùBõêÕ#///Jœ8±Ï C `krš6muêÔ)h•mPzäÈ‘RÙÎJeV.çÈ‘ƒråÊeƒ–í£‰$I’›››ÙÁ\¸pA¦óÎ…”)Sš-ƒÄ°'Þ¿a?cô    P¸‡„ê:¶jß¿?mݺUÎëÎ;Ô¨Q#Ú²e ¶n;Õ“Æd@@ì™À±cÇäðªV­J+W®´ç¡klMš4!¾Ì‰rÓ°aC¹àa® Ò@@@@@ì›MµïçƒÑ…!þ’ëééIiÒ¤Ñzeåû¨Q£´8   ¡KàÅ‹²v—G# wG{bo¨`÷1«V­¢R¥J»•a€4gÎœÄnMƒÁX™÷î]ºtéåΛR¤HaUUèåË—ò`Tv¡’={v•,ïõÏs¹qãqÿß¿—.àòæÍK1bÄ0jÇR„ë±onþߟ!C«˜p[ìOþÌ™3Äã+X°`¸ûSˆaHñ|=z$çË>ý3gÎLÑ¢Eãd‹ÂÏ‚†½uëE‰…ø¬œlÙ²QôèÑ-Ö1͸ÿ>±{WWWÙ§²ü7-g.þôéS9^~Çù]l¼¦mÄ3°wòùóçrî<î?]ºt”*U*Ó.pvâƒ#@À„ÀĉYË ]B`xøð¡I)çÎœ9S2¨S§ŽóO3”ðÌñ"(BÙ%ÿ“&Mª’p·#EŠ‘ÏGXû•X$–yüñ‡A( Âÿ´!Nœ82Mýo+\¸°A(Eµºÿþû¯Q¾*§î‡ÖÊr@2n1b„ÿ?ª2|JsC·nÝ Ÿ?6*Ï‘¬Y³Ê²k×®5ˆEmY.vìØ2­U«VFíèÛäð©S§´öžÀîq„•½¬Û¹sg}VÃjŒ)ܹœ%†Áe¤îÜv‰%ÌŽ]XškŒ„{­ /ꨱëæZPF cÇŽÕ’õ wv;£ ´ÿÄn­}±ûPËfW>ª_vucNx!F)Ì=<<ŒŠXûNô;Áî™x –Üïñ‚çó"¿+°#…{رFO!# þŽAá2Ž¨  vB@*ÜáCüwƒ€€%|š°¾Ó²……ñ–ã{÷îii€€€€=–½]œÓrÈ|phPdþüùÒå‡ð Oùòå3[U(ñ¥;>|\(ý•a×lì>DXIûË ,]‚xzzRË–-Íe—2J„u¼ Òœ9sdX(^©^½zZº>ðóÏ?ËÿùC‡%¡•YwîÜ!vÃ2pà@y7ý!üv“ðŸ.“ÙõŒ¾_Ó²¶ŠÄ0¸ŒôcëÝ»·>ª…ùÙòA¨,úw‡ßu°©P¨Öj*|@-H*L³dœ]öðA£æD,v»¶aghEæÎ+Ãü\Åb‡–®ˆ$odÒÑ£G‰ÝÔ˜J@±â_¸!’så¶x¬Å‹—ç ðïŠpSd©:ÒA@@@œ´…NøP1%Û˜7ožªe“|à©5‡žòÁ•¦’9sfÓ¤ ÅY¹Í NVîò°¬èT"üÇ« ÑÏd~ãÒ‹¨ù _âòðôÀÊs¾¹9[S/(ecFúþƒóîð¡±Ý»w—è|€(ï*P; ²gÏ.¬þÎ)iÒ¤ú®´0[©$3f”Ù>>>Ä»'X‘­>— ×0U%á_]Ì; ô {U)0žªœ¹{©R¥äa»Íš5“‡Âò{É àÊ øvíÚI%¼¹úHp>P¸;ß3ÅŒBo-_½z5 Ÿ¹šE—8LŽJ–,I–,²x zùòå±}8žšÊ%†8Ø””4 ‘¤H‘Â_vP•Þú6lØ@lQÌ–ùlu.ügK÷5Y²d‘.GX±+ümë«H8â S™#F £¼À"Êž•»lµlfÉmM• ˆapÖŸ5ù<ïÙ³gÓàÁƒIøt§íÛ·“8¤TºácKôQ£FÑôéÓiçÎò¹™¶Énû^ô`¾9É´¬rgP}U†ë›J@ðÜaa®m¤€€€8(Üï™aÄáD@â&}ÎþöÛorü…­iÓ¦Ä_¨ô_îù á€hܸq$ó’ÛœÃiÈè@@lJ€Ú캅݅ >ûÙÿ?ïF‡‹JKpÓ>oݺEìšÆ’(Ÿñ¬W 'lÙ.ÊÕ,Ý-Õå]¯^½’ÙÙ²eóWÌOHàÅ(v#à / ­Y³Fî†8ÓTÙÎm?zôÈlÊåˆrõa®vʾËÙµ EÍ—-ªÏž=k®šLãÿÿ\‡/¶j/ £Œ™ÏµaÿùlÙn*¼h1sæLéV…óxÑãæÍ›¦Åý̤ÚÖ»QÊóýû÷K73þý/a×®]Z–ª£%„ ÀÏšçÍ—ò㯚c÷7–‡î*…>s‚€€€€8?(Üÿc†6&À_ªÜÜÜ´VÙ,û,å-Òùóç'þÒ§„ý™B@@@À ˜s½Á Ï,ì6ƒÿÿ™¶æåÃÅ»uëFl1n+¹qã†lŠ­›S§Nm¶Yå3œ3õã¯U«–,ÏŸZZ _´h‘¦°WîcÒ¦M+ÝÃqev•bIø°Už/û–g¿Ýá%!a’1Ÿ9s†:tè@­[·6â®o“Ý®(Q‡öª8ßÙ©ÒZå³{µà¡·çþXد;»«1'¼Ò¿™Å.ˆLL5WÇRšþâ2¼bàÀrîëÖ­3[­ö•’Ÿ]B@@@@œŸîÎÿŒ1Cà/W¼EXÿe‘·Jó6aÓƒÒxµúòkãa 9...²]öGýüùsb…¥R4+VŒªW¯.ã?ýô±’QåñÝËË‹Ú´iCì^-й¬­D-vúô‰¦L™¢õËí¿|ù’:wî,ìTýqš’† ÊEqŽ³/mös®ÆÍiG•>Æ9ÌçµüðÔ»ÖØ- /2°;”gÏž©,ân¬(VȶjÕJË @H…d¼¼»åÞ½{ć‡ò{£—‡JW{œÆc4wp*×aîúݼ³€-ÛÕ‚ [Ëÿúë¯ZÓ|`é/¿ü"ã½{÷¦‘#G»ÿQríÚ5yÞŽ²¨Ÿ4i’|–*ßÚ»¥ß ~/ÔB÷ÏÆzáwlÉ’%Úb*«/ƒ0€€€€€ó€ÂÝùž)f؇-og׋þ‹»>Ý’%¾    `/òæÍ+‡Â>§'NLìƒÒJx‘¹P¡BR©Z£F J˜0!±"ž-y ( Žä:¼Ë‹ï¶VV*×0={ö”‡¶òáäü?™¸láÌ–æÊåH£FhèС²{VŒ.\¸\Ūì„}ÐóÜXaËm²¢÷Î;”(Q"ék[–Ê•yNì*†ý·ó‚;÷Åu<<¤Þœ;æÏíò!¾3f”~þY¹ÏÖíü9•ñçÁ•€~'ؽÑÞ½{‰w7ð/Ü°¯v¾øä1ñØøÐ]VüC@@@@œŸ@$aqapþib† `;ü+ÃÛËÙŠJ¿mÙRüåŠ}Ø:¢ßN¶cŸ¬lµ§¶Ë[š'Òƒž¹sL•sX¼½½e}~.|Eø¹ó9¼ƒw"D‰%(ÕCT–õåy°kV¾óbÏwX@ž»/âÿe¼ û? `¯Ôßþ¼eÎå–½Žã0Kà½ø»Çü7³å‘ ÀþE›4i"-쬥ñùógâþ”ÿQkë¡€€8åš%,ÇÊ.Gø²$¬Lx§_AVà+_éA­–åmÁ(¸ãåE ¾‚+ì&ˆ¯à/ü/^<8UC\‡-êC2ö €€€€Ø¸”±‹Ç€A8Þ:Î~Ey;{Pne‚J åA@@@@@@@@Àñ@áîxÏ #'죓þ ŽlÙ²…¾ÿœª¨         à  pw…a†?V¸ÿý÷ß´víZâpPäÉ“'òpµ ÔAYÇ"…»c=/ŒÖÔ¨QCÀć‰å4¸•±ƒ‡‡!€€€Ø >P”eç‹Ï€€€€€€€3€ÂÝž"ææâÇO3fÌ ƒRîܹ­êÓ¦MV•C!ˆø€Ó:uêÈ‹…€€€€€€3€ÂÝž"ænŠ)B'Ož¤Q£FQ̘1ÇÙ³géöíÛ–A&€€€€€€€€€€ã€ÂÝqŸFn'¢E‹F}ûö¥sçÎQ¹rå¬ÜăLphP¸;ôãÃàí‰@æÌ™içδhÑ"‹~H¡p·§'†±€€€€€€€€€€m @án[žh ¨iÓ¦äííM7öGc÷îÝôþý{éHp|P¸;þ3Ä ì@’$IhÉ’%´cÇÊ”)“6Â?Ê4-§!…»Ó}J“'O¦—/_ÚÅxÂc½{÷&Þ%f̘Ԯ];Êœ9sDœ>æ  à„"‰_ðmá„6"M)UZWzp÷VDš2æúJŸ>}¨ðÈ!qûˆKàøñãT¨P!›À{eSœÙXh¼W ƒS'Nœ ww÷0íÙWWWºyó¦} J7š &PÏž=u)F4Íš5£?ÿü3¢Móp>ïÅBwX¸;߃p3úøþœó5ÛR|—¤nþqÂ<'ÐçOèÝ;ßg TÛx¯Bƒ®}·¹{ýzöô ½}ûÖæUïU•ºí(ÿ½úöí«°2{E‘#G"—D6gÑܼj½zñ4TÞ«ˆÆó:õ?-aâT·YÕ 7€KàÕó·´òÏõ¡ú¹ÙpÔ;š'¿/ïn‹&¦gϞɱº¸¸ˆÏ]Ïëï9/oÚ¿óˆÝ¿£óBa  vA w»x „-T¬ÝžÒdÈi‹¦Ð†Øö×l©p‹aâ½ ÊöÕÇÙƒI…{hŽªì/íð÷*4ÛaÛû¶¯– w;† ¸…{›"ÐŒ1Õ;×J…»£È•?;ýÖ­ž£ ã´Un” w4…&@@ÀnD¼åS»A€€€€€€€€€€8(Üéib.          áF ÷pCŽA@@@@@@@@@œ‰îÎô41p#…{¸¡GÇ          ÎD wgzš˜ €€€€€€€€€€@¸€Â=ÜУcg"…»3=MÌ@@@@@@@@@@ Ü@ánèÑ1€€€€€€€€€€€3€ÂÝ™ž&æ          n¢†[Ï蜘À±=Ó·¯_-Î0~¢¤”!k~Š7Å2*ãì±ôîõ Íž¯8¹$I©²‚uñôyŸ> ëƉïBy —V;¨         `L wcˆ€MÌÞ‚>¼h[ÉÓd¢ŒÙ P­(mF7³å—ÏîO7¼OʼÞÖ …{³å¬M¼yùMØ@Ϙ½ îÖ‚³ƒr÷o_¡[WÎXI”¨Q)M†œ”"mŠ9à L¡±ðbëÅ!‹EFˆ|þô‘îXAü·àñ}úøá-%O•øïQbUÈ5KÞµÊ   ÿn9H_¿~³X%j”(âsr*rÍœ–¢EÃ×W‹ jn]¿K—/Ü°ý„.ñ(sŽ ”(IÂË!@@ bÀ'–ˆñœ1K;%ðèîuâëÔÁÍÔ¦ß<*V¡žŽò^·Ð’i=JŒXqäŠÅ*Sµ†=Ì*ßCcáÅÖ‹CN‚L`ÓòÉ´~é8zýâ‰QÝK^ûd|åƒÈ½Ô/ôk»‘”*}6£2ˆ€€€@hÒe½{û>Ц£F"…ÓQËßP…j%-Zž=y!¬ŸÊæ$ŠO©Ò&­®Ð®8°óM2ϪѰ½p‰|Ôkd{J ”ðá%—Ï_§ïß¾Ëî3çp¥hÑ£…×PÐ/€DHP¸GÈÇŽI‡%V^å*XFvi0èé£ÛtÏÇ›îÞ¼HOøÈôOßÓ´A éáÝkT«y™¦~)[‹2å($£IR¤Wɸƒ€EŸ>¼#ï3äuþÄnê<Ì“â%Hl±<2"¿þI«æt²Ç÷®£«çШ…G(q²4–G líÒMêÓzhZ…úŒî@‘"E ‹®úؼzM¾@¦U®]–†Oïi”HÄ&ðüéKÚú÷ò:zž&,H9óe  -ªw»?ɾ×YHiÒ‡Ì-i¸L‚€€€Â݆îrä-N?Õé`v°ìë}ΨVôîÍK™¿V(ÄÊTiF‰’¥ÖÊÿܸ—FhÑcP£ŽãT”>}|ç»ãsI.æ°Òåì±Ô»i!1ï %JšJ+Ï‹7j´‘ñ¤)±£qÒÀùÿ)Û •¨N5šö!׬ùäßÎ?{|'íûg©°†úF/Ÿ=¤ñ½jШG(²ØÊ° P¦RQr/nìÚŒí<¥­kwÓÓǾç­Y¼™UÏŒ!€³`ëâò¿´Ö¦µký|b…©’¾Í=¨ÞQåžÞõÂV¨SþJ­*§¤ÁmKÓ”õir¿z4 e1j[---žÚ>ü ¯h˜•l-~L¢õ9sxsiñhE°qã»P¡P­ÚàwmLü^=r_‹[¸ë2>¼•öo]&­åÝ øÀ(kÛE¹°%à}ú€Ö!+Õ-ª[¶úo-FL­,»– Ká÷ëÜñ]tpû :y`“TøÿîëÔÚqðßOÞÙÁï­©¯zkÛ@9û#;N,úµU m`Þç®ÓçOŸµ¸iàËç/Ä~¬wlÜOO_»-—5­«âì’ãÄ¡³ÄndØʨ٨’ÑÁ©çNz[¬b‹w”¿ãs_¾çw·Ø2@@–,ÜÖ7z³*Ön/2äÌ/Ÿ? × —([ž¢f˪ÄÇ|hhû²ôôám•dtÿömY1•n_;G½'l è:%šQA]äÖµ³4¢sEÍÅMù­©eOlƒÔ!r¨`¦}iûÚ9âËèâÝÿ¬šF ;Œ‘sàÅ›±=~–áŒÙ Òè?}·¿ª îÙ¼˜6xNï¢JS÷¬¹ º­†Pn÷r*)Ð;Ÿ_ÀV÷{6-’eãÄKHý¦üC™sºZBNàû÷oZ#¬Èþ­Ç ³®b¢FÛ¤‡/ÓýR»f—õþZ8‚VÍ"ÃÙ…›¬¡söÈ°úÁŠm^øSÒwÒ&Ê÷ÃO**t£-+}-¾*×ëLM»NÒòîXI›–M¢Þ'µ4H*ÜUå«Ôä]ÿ—¬ÔˆšŠC÷Æ÷®)Ï.ÐL’"t¿ôC¹Úúd„A@@ºŒ~îñø³Åã‡Ïüù¦¾}ãê5]úÐfw4Jx±ÙMøÓî7®eu˨’µ{U÷¦ôàîc?r{#ú÷ê=]œ¿ô\¦¥ÍŠîÜ46^زæ_â‹¥×ÈvZ>ËBø!¤Ë˜šØ—;ËÃ{¾ï”~âÁ}G7®ÜACþûüÔ¢s=jÖ©®´¦ß¶n¯l>Eꤢ¿'ú®døç"-äqý÷â*ùH°=X¸Ûž)Z àƒ cÄŠ£Õ{|ÿ¦¶ؽñOMÙÎ ÓÁ³þ¥y[HÅiíßiÕØ7ómË´¸¥ÀíëçixÇ BÑæû¥¢Jý®Ôª×,ø´ÌÒã&H$Ý„¨¡Þ¼|Z¼¯ž?”føͬ²+^9w˜Fw«J¦;.,5Ê_ˆçŽi«)Ûã%LBƒfÝ°PHW/sÓ/žŠ¿âùÝð>e¶'öï^ºJSyeqóÝ]¨du­,[½üxá”ï=¿$í5•³ÇvjIî%}{8•ð|h´9e;ç?yx‹–ˆÝ:K§[>Ïâ•PøíPΟ²ëó¢$ïþY:­'G!  LàÞíGF£O˜(¾Q|ƒPH6(ߎE+ÿL·¯Ÿ£o_¿ÐüqhæºÊ.ÊÌßþÝ°@vé’$% ˜¾ÒèÆei,H·j »ÓîÍ‹è˧²Qþ›ÀWêôÙ)wárb·ByÊY ÅŽc¬¸P#HŸ9±¥9+¿¿}ûJÞ§÷Y°_<µG•÷K^ûâÏß“‡ùrb¼‰‰­äY8-ß•.UƒŠÿÔ€²¸‘Þµšxˆrݼb ÕjÞŸbÇ5þâÊuÏüç£>o‘ŠÒ>M†œtçÆÚù÷\:¾o½l~ÓòÉ”#  €ã`—0ì[IÒ‰)n¶ÿY5CúÙf¨ÉqȦ²†æ²lÕ e{`ÔB?Ÿ]Æð!Íc— ']‡/— *l ®—wo^Ò„>µéŠP¾+É‘·Åùo±†w6¨8ÿóßI|±¬T·ÅŒí»ÈsI¸aá¿oÊ{ô±({Õ¤t-”×ãGâ+Uº¬2ýù“ûtA¸¨áÇt¯NçtÖñZE“+ëÙŒ9aw]nJkYï\Ó€€8ZM*Ó’-S4E&Ï€]u(ÉëžC|žI®¢F÷øÂ5 [º+Ñ×Si|¯Ù¨”íz ‰@r±óaîÚ±T½žßgý»f‹w4ZôhT[ü.@@@ì“,Üíó¹`TŒÀeá&ý"+I–:£ xgßíÅl@ûÅ¡¨çÄ„ìDYƒ²’ë’×>)®–=g m̶Å¡ì¶á¯?GJ— |&»_(Y©‘ÙòHt,/Ÿû-¨$î`¶þê=qïUSúlçò¼û‚wS¨샛­Þ«ýÚø`Vsrýâq£dV¾+_2»6JG$üðy?”¯#/+ÑÿY=C;Ü–ýô¯ücp´]2JÔ¨ÒËþ­ÿ“ñ 'wS‘²µ¥rœ2f+ t²ç)N§l„½¹o»o^ú.ü°õè1cÉúê+î÷nYBGþýKø]?Oß¿UYVßÙ¿|@’\÷7õá](Üb…<OyÝsR67ãÏ+ì—:mÆÔ”9[z±›Ó•LJåñ²Ë%iÒ§TA³w}¾¾ž¾pßm}: UøAÿ{woWUz|1†‚ „90)ˆ¥¶j«UëÐ꣨TZ‹ÅéùÄ uzjµƒZµ¶Jm}•ÚÁ¶R+ †IÆ@B˜ Æê;¿þ';;ûÌçÜ}ÅçrÎÙÓZë»ÖÞ7÷¿×Yû¯{á&;7àKÿ¤ŸÒ_c:£Ø0ß×ò}0Öç_óëóûm´Íì=Aw“ ( Àx pÏv±TSLà_¾ñéf™Ò£ÕHÍæF¹7ŒÞ|Ékßžýd¿ã–kÓ/ý샫¸'ÛòËŸ<=øâSÒ´m¶Ëí™sVn™NÿÈ×£å rñPAÒW>õ¶ÆCON<àÒ4¹ò×ÍÛÕŠÑÎç|åGéªÆüÚ—ýÏw²€êÝ·ßØÜ…é·ÿúÜ´ôç§ýåÿ´5?ïÐcëvMÜÄáŸÿÈo§s¿zYã¿žÝÄœ€7Œ@¿µñÀ[ÒŽ;ÏhLuJi®³çžÞò¾/6æùº9ç9Auæô6cZ™¸3;÷á¾à™7óðUî7]{qãáºO7G·“éÑ'n˜N†ÏÜ»2}à-'e¯|&ñ ß=÷›ßx ëülJ‚þŒx$mÞ¸ÖEâF‚IP`<Nþ•ç¦×½iýCH{)ac¼@35¦ÓnŸÿ^ŽÄ@ƒ²Äe“eÓ¦mÞõǧ”)î›ïjz`q«g>wÑGgÙG[à¹X ŽGy,…SNà‚ó¿”–^øíf½_~ê{#"ÚVxríéŸþöãÙ>ü¡ð²ßzwã©ô[fÜwŸçýÊ©é÷_6§ñàÂ'²ÑóÌ[¼ð™€Xd¶ß‡eÁv>¿êwÏJ—|ÿ[Yà‹é$¾pîiéÌýclêë$`¾êü\Ûù‡\vS¶}è×_ùƒ´ä߿щüÙîÚÍ¿z,¢›+ € Q ó_±CÌÌC) ÀzF“g^ì¿<çMÙǬadñóõõë7jó¦døÏü‹,xùÍ/œ•®½|à c·v™±ÑCSw±q+¶‹×mó{ÿö;ÿ4>¦Ë—|§1’õëÍϾ™\̃ý…s6ÌÇÏ7'NjÜ„é”®¼øß½üpö“Öo¿ã.Ùèä?:û¼ô’×Ñ<Ìòk.i¾Ï¿yicæò&xú›o9»¹ŠE7¦›i®ôÍH<äÙÍã®[»¦ãhñ'{¤¹ýôFûå¿éB›zÔÉÙz¦f¹ð_¿–½çÆßA‡Ÿ½ßÿ #›ó¸óm›e?^’-_pø‰MAijn¼æ¢lÿ{óû¾°I°åü;¥ï»#»¦–m·æ±‡Ó5—]Ð\5«ñ_“ ( @½æ¸á¡ïW_vCºkå†)õò5}xõ£éâï_Þ\äÔ1M ߌXÀ>:b`¯€ Œ™€÷1k‹S?æDþ?ozÞ3?'¦Ó£ÎO=y—ôÞ7>§9'6µÞyúné?ô·ÙèÑnó‹ÍÍ>{ÖoeS|,¿îÒÆÃWïÏærÿ܇^Ÿx(*‰ùgí3·¹}«7G4F˜{ò«š«¿ü©Ó³¬Í¾kF#ßÏŠìFÉ™§,Nô‡H/o| ‚‘ÉÒƒ÷Ý™ÝÈa$:7s8f1íµßAÍEÓgvžvè¯xs:ðàõA_¦–ù³ÆÔ2O?õdó¾­À>sN;6nÀEúìNIw­X?*=–Å+QþVã·‘<Dϼ2­L¤ó¿ö'Ù[¦£Ùn‡³÷ŒdgwÒ¿ž÷éf[§“!óµ°ç¿bZyó5ÙÜòÅåeŸÿöOßMS\G?f´=‰i•æz\q?+ € Lr’zÌ ‡gµà†î§>ø…ôôÓ?ݨVü›æ³gÿUZûĺlù¼Æ\ñ uþ÷ñFi|Øb‹ B?þèšâj?+P*0‘}”lÑø÷X$ûiHøª€ LœÀ–—•9)05Vݳ"ñÓ.Í_t\zÛGÎ+ÝÙj¿Sßö©l¤0skó@ÂoüÙûJ7ÝvûÒœõ×¥ëʾþ>•ÍO0ìñGV§/þÉï§wœ³~ ‘²í]VÀÚµg7q"÷uÏ÷4¦as11²ýù/}cqqéçƒ<)ñUã7^}QúÄ»_™Ž{Ák}”¹¯yæyñþ澋Ž~Aó}«7|-›©BÞõú£óƒÿ4ÝyÛõéï¿ô¡Ò©hZÃåý ?½q3ïì·½(kׇWߟÎxÝ¢tÌó^Þ>Û¸îì•}äÁìù<¼4úÐÖÓ¶M/þÓ7Éø¨Æ”3_8wý·'bôùÂÅÏÛh»˜Ç=Ö³òè\ žÏ;ì4=ÍÜcvv}$ò‰÷¼2½º1µÕ>ûÒ˜ŠèátåEÿ¶QðŸ}nYvYc^÷7ƒû,‹Ä<ï<íÒ¯ýÖ™iμÅéî•76ÆúµÆ4H¾©óÒÿõζÓéı|U@˜|g~ä-é7N>- ´ÿ_/Jøº÷§W¿á%iþ!4~¬HßþÆ¿'–Gz×GOÛ((Ë;½ÎØ}Ãã/½ðÊtÞ—ÎO»ï93Í>`ïÆïŸ SÛt:Žë§žÀDõQdgì>==þØú¿ >ÎWÓ¯¾æi‹Æ¿É¡ñœ“ ( Àè ¸ÞØØD€Ñ¦ûÏ?"Í9舴ãçÈã_ÒqÞöâAV}às$F˜^pþ›A²ØŽÑÌÇ<ïe‰9á™Ó½ÛÄCX_÷ûç4jKðíôÃÿü»ôÜFÐÕ4>ëâ?l[ úÀÞþéô‹/ûݶÛåWî±Ïég|&}éc-^záùg œŸß¤ùþ¸_|u:¾1x7‰>ø’מ‘õW¶ÿ§¿ùXãù/oôÿ#»ÙÝmà!ȧžþ‰ôÕÿûöì[ ôŸKÏlà§,ñ@å37Úâ› ùm¸F°<ÿ Š…Gœ˜ß¤9Ÿ{,œ3qš1kÓ ÄËO}w6;ÛqƒçÃoý¥Ø¥ùÊ~1;#æy˜ï§Î»®¹ž7{ì;/m½õ6Y™>þ®_ßh]| ¿žÔÅ”]±½¯ ( €“K€`÷û>~z:÷=ŸËF± 秘¶ÜjËôÖ÷¾!~ÌÁÅU]}^üìCߪñ­ª§²|>ö¿ÿ<Ûï̳ßbÀ½+Á©»ÑDõQ„Ÿ}âéö[îÊ°—\°4ñ³óô ¸OÝîgÍP`‚ ¸O0¸ÙM ¯\°zhýã/o˜¤xP_§¾í“é5oúpº÷ŽåiÕ½·g£wmÌÏ´Ì»]LG4Zøw?]\¼Ñg´½i7ÚÙ• 0’yïÙ ³›8s7t²î5{Ãô/Ýì—SÀì²ëîé¿zNºuÙ†yNc‚›ô¿æôÔËCÅ^ùÆ÷§‹/øûtÿÝ·e#Ý?ߘZæœ/ÿ¨«©n"o_ûxÑ«ßšó‚ôÿ¾òÑÆM´ó²ÑîÅ£1ªýÄŸ’ØvïÙ Š«›Ÿ™V&îëço?¡¹Ž71{LSœN&6>ù×~'›ræþêÃé‘Õ«bqöºßÜEéÔ?údÚoîaém¯Y}“g£ r¶ÝnÇôžOþsúëϼ#«ߤˆ´}ãæä/ÿúiÙèyÊjR@¨¯ÀK£x7égŸùÙtå%×l4­ SÁ,<|^zï¹oML'ÓoÚm食Wúô‡¿”îÌ=€5ù;¦_Ò)µßDôQ@ßüÎSß`|<]ðÏÿ“ž\÷Tf쿃¦TW³² (P±Àf¯qo:AoÅ…2{zØõY3ÓêŸ<>ñõ«ÓÞsö²«ÛNRßyѬ,øvÝu×¥… GÓæ»í¶[ZµjÕ”ïWÌ ÿÀ=·§ÕÜ“=ðrÆîûöÄŸL]íýoX”nZv}úþ÷¿ŸN:餡}\úÕã>”xèéýw¯HÌÛÎÍ»³öi´í‚´]cª‰NO®[›VÞ|ucz™ÛÓλî–ölÜ(â¦O¤5?’njŒ€_·nM:à £²ÑòWüð_Ò¹ïøµlüqsò±ÆTX77ž_À>í÷Üo~#R} ýŒ×Ú˜N醑ô«pòUh%ðßÿýßéùÏ~6û~ð­6«Õò§žz:ÝvÓÊ´òÖ»Ò^ûÎj|»t¿4m›­‡ZÇukŸL«|¸ñ»s›´Ó.;õØÃ:Ø7ß›^vÂÒÌ™3Óý÷ß?¬Ãý8guVúà?˜^ûÆ_Ogœý;C?þ8p"ú(õ^ýÀCÙͧ]vÝ)ûvƸY|óËßIç¾÷óéU¯zUúæ7¿9nų< ( @¯knï÷^ÙÜ^˜B»5æØæÇT/¾ýrÀ‚£²Ÿq¨ÙÖÓ¶Is>&û)+7?ö…e«6YÆt[Ýn»ÉÎ.P@¨ÀV©cÉ>ÈhöNðgí5³Óf®W T`"ú(OŸ±é·žK äBP@¡ l>´#y P@P@P@P@P@¦°€÷)ÜøV]P@P@P@P@P`x܇gé‘P@P@P@P@P@¦°€s¸OáÆ·ê ( € LV…‹Ÿ—>ö7WeÅßzÚ¶“µ–[P@P@P fÜkÖ VGP@© °Ív;¤}8d*TÕ:* € ( € ( € L"§”™DeQP@P@P@P@P@ÆWÀ€ûø¶%S@P@P@P@P@˜DÜ'QcYTP@P@P@P@P@ñ0à>¾mcÉP@P@P@P@P@&‘€MDeQÛ |þÃoL[o³]û\[ 5>4aõ°_MõØdtÇí+Ʀ,DP@a ÜsÇ}éw_qæ0é±Æ\`ÝOŽy -ž ( €õ0à^¿6r5Úc½Ò꟱.]qñ5]ìá&uˆ>P·zYP@ÆQÀ€û8¶ŠeêIà‚ï}7-Y²$ýüç?ïi?7žÜ ,iÀý»ßýnú·ÿ\’~ú3ûÕäî)½—~ûmRš7wÿtàö¾s—{|í3ïHÛn¿S—[»Y¼ÿÎ:TÃ:( À$˜7o^úÑÒKÓ Ë¯›¤5°Øý l–6KÛnµC:þøãû=Ä„î·ä¿.I«~oÕ„æifÕ ¬¼í®j `î ( À ¸ÕCN¬À¬Y³Ò+_ùʉÍÔÜj/@¿zÃ)ö«Ú7ôWpÆŒÙ7'®ºä?&8g³Q~3g\êh9P`<Ž>ê˜ÄIqˆß+WÜ•ø1M=èS¯æÖXê(°YcT°Ã7ëزÖIP`ì–/_ž¾÷½ïùœ±k™‰)ÐþûïŸ^øÂNLf梀 ( À$X»vmúÖ·¾•~øáITj‹:,iÓ¦¥W¼âiúôéÃ:¤ÇQ@ªX³Ùf›moÀ½*~óU@P@P@P@P@¨‹@pß¼.µ± ( € ( € ( € ( € ( € T)`À½J}óV@P@P@P@P@¨€÷Ú4¥Q@P@P@P@P@¨RÀ€{•úæ­€ ( € ( € ( € ( € (PîµiJ+¢€ ( € ( € ( € ( € (P¥€÷*õÍ[P@P@P@P@P 6ÜkÓ”VDP@P@P@P@P JîUê›· ( € ( € ( € ( € ( @m ¸×¦)­ˆ ( € ( € ( € ( € ( @•Ü«Ô7oP@P@P@P@P@Úp¯MSZP@P@P@P@P@* ¸W©oÞ ( € ( € ( € ( € ( €µ0à^›¦´" ( € ( € ( € ( € ( €U p¯Rß¼P@P@P@P@P@j#`À½6MiEP@P@P@P@P@ª0à^¥¾y+ € ( € ( € ( € ( € ÔFÀ€{mšÒŠ( € ( € ( € ( € ( € T)`À½J}óV@P@P@P@P@¨€÷Ú4¥Q@P@P@P@P@¨RÀ€{•úæ­€ ( € ( € ( € ( € (PîµiJ+¢€ ( € ( € ( € ( € (P¥€÷*õÍ[P@P@P@P@P 6ÜkÓ”VDP@P@P@P@P JîUê›· ( € ( € ( € ( € ( @m ¸×¦)­ˆ ( € ( € ( € ( € ( @•Ü«Ô7oP@P@P@P@P@Úp¯MSZP@P@P@P@P@* ¸W©oÞ ( € ( € ( € ( € ( €µ0à^›¦´" ( € ( € ( € ( € ( €U p¯Rß¼P@P@P@P@P@j#`À½6MiEP@P@P@P@P@ª0à^¥¾y+ € ( € ( € ( € ( € ÔFÀ€{mšÒŠ( € ( € ( € ( € ( € T)`À½J}óV@P@P@P@P@¨€÷Ú4¥Q@P@P@P@P@¨RÀ€{•úæ­€ ( € ( € ( € ( € (PîµiJ+¢€ ( € ( € ( € ( € (P¥€÷*õÍ[P@P@P@P@P 6ÜkÓ”VDP@P@P@P@P JîUê›· ( € ( € ( € ( € ( @m ¸×¦)­ˆ ( € ( € ( € ( € ( @•Ü«Ô7oP@P@P@P@P@Úp¯MSZP@P@P@P@P@* ¸W©oÞ ( € ( € ( € ( € ( €µ0à^›¦´" ( € ( € ( € ( € ( €U p¯Rß¼P@P@P@P@P@j#`À½6MiEP@P@P@P@P@ª0à^¥¾y+ € ( € ( € ( € ( € ÔFÀ€{mšÒŠ( € ( € ( € ( € ( € T)`À½J}óV@P@P@P@P@¨€÷Ú4¥Q@P@P@P@P@¨RÀ€{•úæ­€ ( € ( € ( € ( € (PîµiJ+¢€ ( € ( € ( € ( € (P¥€÷*õÍ[P@P@P@P@P 6ÜkÓ”VDP@P@P@P@P JîUê›· ( € ( € ( € ( € ( @m ¸×¦)­ˆ ( € ( € ( € ( € ( @•Ü«Ô7oP@P@P@P@P@Úp¯MSZP@P@P@P@P@* ¸W©oÞ ( € ( € ( € ( € ( €µ0à^›¦´" ( € ( € ( € ( € ( €U p¯Rß¼P@P@P@P@P@j#`À½6MiEP@P@P@P@P@ª0à^¥¾y+ € ( € ( € ( € ( € ÔFÀ€{mšÒŠ( € ( € ( € ( € ( € T)`À½J}óV@P@P@P@P@¨€÷Ú4¥Q@P@P@P@P@¨RÀ€{•úæ­€ ( € ( € ( € ( € (PîµiJ+¢€ ( € ( € ( € ( € (P¥€÷*õÍ[P@P@P@P@P 6ÜkÓ”VDP@P@P@P@P JîUê›· ( € ( € ( € ( € ( @m ¸×¦)­ˆ ( € ( € ( € ( € ( @•Ü«Ô7oP@P@P@P@P@Úp¯MSZP@P@P@P@P@* ¸W©oÞ ( € ( € ( € ( € ( €µ0à^›¦´" ( € ( € ( € ( € ( €U p¯Rß¼P@P@P@P@P@j#`À½6MiEP@P@P@P@P@ª0à^¥¾y+ € ( € ( € ( € ( € ÔFÀ€{mšÒŠ( € ( € ( € ( € ( € T)`À½J}óV@P@P@P@P@¨€÷Ú4¥Q@P@P@P@P@¨RÀ€{•úæ­€ ( € ( € ( € ( € (PîµiJ+¢€ ( € ( € ( € ( € (P¥€÷*õÍ[P@P@P@P@P 6ÜkÓ”VDP@P@P@P@P JîUê›· ( € ( € ( € ( € ( @m ¸×¦)­ˆ ( € ( € ( € ( € ( @•Ü«Ô7oP@P@P@P@P@Úp¯MSZP@P@P@P@P@* ¸W©oÞ ( € ( € ( € ( € ( €µ0à^›¦´" ( € ( € ( € ( € ( €U p¯Rß¼P@P@P@P@P@j#`À½6MiEP@P@P@P@P@ª0à^¥¾y+ € ( € ( € ( € ( € ÔFÀ€{mšÒŠ( € ( € ( € ( € ( € T)`À½J}óV@P@P@P@P@¨€÷Ú4¥Q@P@P@P@P@¨RÀ€{•úæ­€ ( € ( € ( € ( € (PîµiJ+¢€ ( € ( € ( € ( € (P¥€÷*õÍ[P@P@P@P@P 6ÜkÓ”VDP@P@¨¿ÀÏþó´zõêôØcµ¬ìš5k²m~úÓŸ¶ÜÆSSÀ¾15Û}\kÝÍõlÜÊN™M (Ð^`Ëö«]«€ ( € ( € (P¥ÀUW]•ž|òÉ´pá´Ã;TY”±È{ÕªUéúë¯Op@Kk¯½6=õÔSéØcí»Ì<òHZ¶lYÚf›mÒ¢E‹º>ÎD·u%ˆ˜=0”‡´zè¡éÆoLL+1¶áx`bê•bzøᇳrò ½|¢¬ûî»o6%L~9#=o½õÖlu™1cF~uöžyq .Ì™3g“u±€ºRžÝvÛ-5_ ÂsêFP3Ž·õÖ['ÜÈ!‡dû0uÍu×]—ø8âˆlY'Ûâô3Ý´WpéÒ¥Y¹x@+NÅ”o“V#ïi£[n¹¥Ø%ÐCËÌ‹Ç/ûLЂù‡iÏh{¶£ígÏžÝrº"ÈœÍù›B¡x`çþûï¿É(Y‚á7ß|s6/?íA¥.´}œ):è Ì…v¤L´#7tH¬ç!º¿Uj×7اW»‹/¾8 XwÜqYà—2Óg8g8Ï"ñ‹Ûo¿½y„þÉÃù–F±Ÿ¨'å¢Hì»÷Þ{§ýöÛ/s‰<â•|8F˱£OcÞ.aʾ”5®lO~LßÄyžÙ×Ζ¾C£Op=ãØ$¦–i5­W¾ž½\3iO®œGÑçi3Î)® í Ýë5'_Æü{ÌW4~Çò;)úëéü^¡ùzs®aDŠ9îi¿¾óž}¹~“Š×(²J^lA}Ž¿×^{eý}‹©§øýB»qC:r3¶-ûwDüþËç}É%—dqàšO½ô¹Q•¥×¶Ë—ï7m¹Qäâ1P@P@P@àr~øcœtó3ä_qÅé9ÏyN¶Ž? ùÃ3þxÏ¿§Ö³ ûp|‚W_}u!(M°€‘œº‘7¨üœµü¡N…`(èóG>?×_}Z°`ÁFAqÊD~$Þ—%êN` ÕèuÊBЂ@E>8ȱ"x@pÜPÇ(ÁOÖåGS‡A>¸Ò]”½ÛöŠíÉ›2oYŠòä˘ߎmÂv¨(7&Ô‘Ý;^óÇ#hI[Q&?éÔþH¹1Â~ÅÇ(ëlÛ.”›ÀÚ•W^Ùì¿ù¼ Â觜ÜøÀ‚è8p‡ûF ŽM}ØŽs‹:áNÛ¯hÊØ.ß–œk±=Çb4-ùámÕ*XÉ6Q~ÊI^´ ç9¶ôcÊ7¢8~¿ådß~ÎÅÈW²e‚¦¬ôú×*æ¸p$¨Éznfå˜ô#êkIÔoöa×|ÞÙFÏü¯Ÿzä÷ou=‹ëù÷s>÷ÛçZÙbÄO¤x¯±¼Õ+ÇÍ#ÿ>¿ý›ë íÇõ†ó›¶¢ÝXÇuM³7úò‰ãõsÍÉ#ÿž>Dpœ2pþD?à¹Lß8üðÛ¿ch#ÎÉ|â\,&~'’N8á„ì:ŠË²eËš}|¸Þq| 8&ç>/öï×)úÇÄ‹k9õãÜ&Oê—ÿwyۊϱ<{óÌÿzís£*K¯m—¯Ã(Þp…ªÇT@P@P@†,@€†€áܹs³‡'xLjHþh&¨D0"F?G`Š}ý©ÓúØŽW‚qé™t³œëÄpö!F ‹@"õHü±N™('£Uó£Ð ¬DО@@1ü#@IÀŸÀDY‡”/'Ÿ) ˆóG>y䌀<˨GY}‹©»nÛ«˜G¿ŸÉ€ 7@òFnøa/AW‘Á ‘ô+¶?øàƒ³ û±ŒQ·Õi{nþD“€Ëñ¥ÏÑ÷"Ô! FŸe¿Å‹Ǫæ+AF‚žG}t³?ßå—_ž€i+ÊÃèßÈ3¿žýËî­úFd<ˆÁ&úçºI8àA}(/m‰ü‰ë‹#§ âœÇ(ÖÑ&|Cƒ¾Ê9Dð1ÎÚ–@Ÿi«|ãŽ[Œ°2Ä+ÇÄ'œqLÖSúûRÇüºXßK9= 6òƒ%õçš×ÊI rŸ}öÉnFpó€Ä2úû± çG$®Côú7ò7%¨;IÜ‹iÐzt{=ëõ|¤Ïµ²Åñ¶ÛnˮٳfÍÊnz=Ú}îæš×ÚŠ 0ç ýŠDÛ’?}œëë9Ï" z͉ãðʹÁö#<²y.³ŽëVÜ d›¸ÑÈ·+¢¬\ è“|ƒsÊ¿ïâwç0}sŠß“ñ- ö£-¸ÑMœ:Ç͵Aœ8.‰k7˜‹ÿŽà¦¿ãßœ Ç|¶lÉ’%Ù¾Ç{ì&×€AúÜ0ËÒOÛe•áÿœÃ}„¸ZP@P@–7¾Æ$ŽKp/þðçÎQ$‰Å 6A) äƒyQ#ùD¹ù:>QÞ´ŠDpž¯ºóSüÊ=Û $ðR,Gìϱ^ *\ ÈHÀŠ@N<Ø—@¸b 1Ž;ÈëD·ua4d>ØNùóíGછDP—QŒ”.ú0rž`:ùáN —Ä{˜$FÓçƒí,£]jÒö”bj ÖEbã¸ùÂrò‹Qàœ"ïHùõÜ*¦v}#¶ÄŽºàŽ3}>\dS‚iù`;yÒ Ó§éŸÅÄrFóG°õô[ö‰s'¦¬ XNŒD-lgîù 3Ëò‰‘Ú$ÎÍây€;õ¡7̲D¹{i»VõÖrîÃ’ô8 ( € ( € ( Àøƒ½,Åh¿ü|³eÛõ³Œ £áÊÁØ䃧Q‚¯ù@<Çàaæ·æ§Ü+Ë#–1ŠŽüÊ‚ñlÃhTþø/++ëHeëXN™"ØÀça¥‰n/òkeC¦g °Õ)E³|ð2ö#0ÆPŸT"ðL¤ ÜËÒ°Ž<òÛÔ"€UL€cò.¦X_6¹]߈ã bÇ ¯|`œcr Ê[\yFäÜ¡ïæõ)ÎYÏrŽIŠówn(Ñ#(™mû¦q^ægo¹ÉÅ<ôqÜüzú Ç&L,¦^Êɾƒž‹|-öÉèK­Î9ú ×*êÀµ„Dð›Ü Š›–ÙŠÜÿ¢r‹²·ƒÖ£ÓõŒLz퓃ö¹V¶Åºâs´7éèÇeivㆉÀj¼‡qÍÉúÌÿâáÜâÛ qŽÅ6\×øÝUv}‹2ñ‹HeËXånwÎò ®¯|ë$R¿N±?¯­Î‘|ÝóÛ·{?hŸfYòåïµíÚÕquå=y#º¯ ( € ( € ( ÀÐòÈçÁ§²€X~»~Þä. pƱ&2²< ,'hB0‹¯Ó3•û3z”À,GƱZ½´çXp)ÛŽ£z#˜›ß&ÊÖ.ßvëòÇêåýD·Wqu¾¬S î<Ńvm—¬Ý1©_¾Ž1š¼òß"(æCð—€eä‘__뢷ꋱ>¶Ï¿¶ë±]»zv²‹›Nq,^Ão¦3j•(7Ávn‚äû`Þµ¸oÔ5Î÷pdÿvLËTLaÎñ°Фü¼l—z)'ÇÉ—µÕqóÅmȯìÆ@x3b=‚áÅ}#ïØ6>s¼0-îà …8oòëbßvemµ®›ëyõÚ'£^ƒô¹2Û|½‹ïé\ã˦Ï}îsËVm²,Êޮδ=×xÎüùûQîv}¿Ý5'_Ú›ß_ô#®Üa_~wñ;Œß_­njFŸÈŸeËÈ/–·;g©Oñf]Ô·W§|óåË/s ®+ùu­ÞGyéseÇî§,ƒ´]Y†±Ì€û0=† ( € ( € (0bv…QeÁ¸VÇõÄ# `îáÎåŒâQð¬gÚ‡‘ûµz%ðÁà­FÃ$PÈhÔb0„@@Œn¬%ßV£*[•©›åÝ^Ñ­ÊÆz<òmU¶-^Œü%u:f~ÿ8.v)‚ýÝŒ´owœnÖµëùý;Õ³]Y}£n˜„K>¿â{FÒæ´½ô8~7u(æËgòfª!Õñ Î7sYý¡¸/åƹXfï¯1=N±œùÏ1j9ÜÚ]دp´®gQÖnÚ3>ÚçÊl£,­^ ÎR†²Ômß ýâÊÀµƒ¹Ôóu%ïnöc»Ø÷­Ó­ðí¦ ¢?ñ»…¦sá÷ ¿‡˜â†úq<æZ'E˜ò&¦îŠ¾ÆM Î)~ïñ-­(G§6Ηq§üqºm—ü>­ÞG=&â:ת ùå½´]~¿Q½7à>*Y«€ ( € ( € Lr´ªF¬/R\à‡?Ê ɨw‚îA @0ïuq_1ŽÏˆP ­‚*1vY@žrĨÈVACòŒà[1ÿqúÁÐVeŠ¶è´¾ØVÅíñ"(C~D*nSö9ŽÛ©aݪ=ËŽÝï²v}#ÌNeŽõQÇü¾eË¢nŒŠ%Ô)ÅMˆNÛ•­¼Úõoö+[OAÄ$àϼьæ%Ø£LãFYYÞ½,ƹXfM xqþÿ²òEÀ1ŽUæ’ß/Ú>– RŽÕézùóåñë£Ñúísqœ8~7¯äu 't³iËmh¿¸FGZm\¼vD™{ݯÕñc9Aq~¸2m ¿¿¸ñÄÍã˜Gçäç)úïYÆç8—XFŠ›<½\_qZŸëðÿ?hŸ~‰RÖn½¶Ý(ÊÁ1 ¸JÖã* € ( € ( €“\€`9A‚Le‰à9)†ŒxŒÀCìÃ:~˜_š‘K—.ÍŽI£SÀÑ ³,˜N¾D˜Ò†Qó­¾fOðr8!@T–º[¶ß0—ƒ2ÅcÇ4Ååñ™:–M©ÃúhGÞG[ñ¾UÂŒ ,?1G{qÛ+Vd¦ÌMûÄt¥h³VõᘤؾxÜa}î¦oD^ôã˜1Zs'ÞG^ù×Lë7…#®íÜ¥[LÙ óE—•Ça¥Q‹¥ÏµòæºÄOÔ1Üh{ꘔF}9fYýû­G§ëYäËk¯}2ê=}._ÎðÌ/ëõ=mAÿ¤ÎeÏ.àxÛ#@m¯ÃºæÐ?8‡¨}‰>Áï ~˜SÑë<씹ԹQõ”g .»ì²ìÛ"ñ™e^xa¶ï¢E‹øØLôån•¸Þ/_¾<+7’(K¿N­òtyU}®¬Ü½¶]Üô(;Ö°–ùÐÔaIzP@P@P f›b”p±j?bôkIX¶dÉ’ôÃþ°ÉïLj¸ wYÊ~¨Ø‡ke‰`;y¶z¸!ûDÙ˜—`J1p‡€{Z•…º¶KX•Ù‡u$=ìÉ´ø_ÜiÕö¿V®\™}k!F9²OŒ4fä²DàŸ-¤h—²í†±¬›¾ù ÓŽcró ˆÜè)Kœ;]tQºüòËËVw½Œ"äÅù-îLðŽo˜å#ÑveS‚ Ýœ§Åã¶úm>ìs1¦§jÕ_)Ï•W^™yGÿ 7®­Î-F3—¥~ëÑéz–Ï«×>9‘}._Îa¼O®NËS”‘:Ç5lØל[o½5ûýÅkYŠ‡O³®x^pŽE¹XϵŽëq~ËI´t®£ñ Ôõk6üŸÀ~<Ø7nõë´á¨Ã}7N}n¶®Ê†£pß`á;P@P@P 6ñGz| ¿X±Nëc{F2RE˜†W Œ^'4fÔmFÜ)" œ9Mð‘€?ñ`G^ ZÌš5«åhi‚R #ÿ(sþuß}÷Í’Œ&¼îºë6 èpdÞV£±óÇÉ¿ïÖ.¿O§÷1Z`d>˜ƒ!#cdx«ã°u!€˜O´Á£4óu-sg»Ù³gg®øÜtÓM,j&ÊÃÅ“áß í±&±¾ØgHáÏ~jÚµY3³ÞtÓ7âðýØže¯ÀÃâ†nÈFïæ·cd;çiPòb*ÒÍ7ßœMY’}xæœCœ«Ås‘Õq³¤,°NÛSöH­¡±¾›×Qœ‹äK ”éEP–]w¸9D}¸VÄ ?úk¸q~åoHÐG±äüˆs=_¿~êÑÍõ,ŸG¯}r"û\¾œÝ¾DzßGxÒ~¬»þúë7ºþq|®_œÏ$¾%iØל¸–q .ûFýD¾1ºžÏœÏñ»Ï$®w¤²€;×ÍøÖ××b^ôÕ¸yÆï¿Hý:Åþý¼F»±o±í&ºÏµ+K¿m×I·û”/°Û½ÝNP@P@P`," @à“ 7¬.^¼¸dë´žJE°€ ATF\ @@`—ÀÃüùó7 âÎ;7 ð aÊ þæsö£ìGp9_äÃ:¦o E°™Ñª‡#0‘­Ìý4û(›’÷‚ ²à!£ Ï4äI #ólßxãÕ#ö/{íÆ®l¿vËþÅ<Á_|qöPYêÖ¸l•ýHÐ} hS/öi ðÎo8N™;ËÙ—ù÷Év i{ÊÈm‚¸ô§… n¤¬Ç™>C kœYNPŠ`}f”©Û¾eèÇ.ömõŠý6áF}žÊF@8¦³77Mœñ%¯k¯½6 ÒúÑh+¾%B;æõŽsóG?úQö­Ú˜>Ã~´eäØŒ %Ÿüy›?V7ïGq.’/çÿ¼yó²sœà,çõ§Þ´×êE¿£ ‘`ÒôWnVô¥²Œ ;ë©;Ç`ÿHýÔ£Óõ,Ž¯ýôɉìsQÎn_Û]3i¿ƒ:(k?ú襗^šMe…3þ¼æ!¾3fÌØ(Ëa^s8v¸_qÅÍç!}‚s‚4»pÎFùâ÷%Û”-cy$ŽÁï/ŽËõsë×Vú×ÎÙü··qŠ|{}å✠\L›Ã9Â4bü~ MdŸkW–~Û®W^¶ßp¥ée/·U@P@P@kFÎò= NüŸåÚi=•#àÁÃábälLÇÀþ&rñÇx>1½Ã¡‡š˜€ÀA~¤3Ç#€0gÎœ,XŸß/ÿžòRnŽU<~l#ó‰XW|%pqä‘Gf7 à8áf¤3b2F³¬›Ô]7ÇÉoCÀ7ÿ¨©?A>U£:•`ÁÐo$à‰ ëŒô’p¥L1º>Fwr n¢p€õùD@„þBp‘Àg—Ù&¼¹¹A?eê¥oPŽaÛqL,˜»™›xÐç"`Çùƒ/ß8`»AÇ#/Úž‘±¸óCÿ¡ý¹áÄkúT>±Žù¡9¿Ù>ÎoÚ ‚j´{ŒÒ'88HÀ¼‡}.F}8—:ê¨ìœãùº|çšÃ5+Ÿ¢¿2u õŒ *ýš "wž9A*ž½Ô£›ëY¾\¼ï§ONdŸ+–·ÓçN×LÚ&Ú/~oqLú0hÚ6.¦hÃa\sÈ‹óß]\C¸Žæ¯¥Ü|â:Z<Ê‚ëeËòe§?ñ;‰YœwôY~H\é{ù)lbß~bÿ~^¹QÅ7G¨wús¤‰îs­ÊÒoÛE=FñºYã\›Nb7Šœ<¦ ( € ( € ( À¤`Ä'#e T 1:™ Á= Ý$þ0'x̾1z”?Œ;%þ¨'@H€£U^È8nqÔv§c³žQöù /AQ9òSts¬QlÃÈs ¶çËÙm^ŒPÆžý‹Ân‘ߎ°mO"HKè&EŸaĆb‘P@P@P@*xàà²e˲iD;ì°*‹2”¼™>‚‡xò <æ¼ÓlÅüÔ‘¯ (°^`ÜÎE‚ë<$“kó·Gâ/<¸”ÑíŒh/¦QÕ㪫®Ên.\¸0{ht1_?+ ÀØ ds¸pûv²€ ( € ( € ( €Ãˆ¹2·|ñáÃÊÃã( @gq: ¶ó€L^™»—o»ŒS=:«»… ŒXÀ€ûˆ=¼ ( € ( € ( € ( € ( ÀÔÈî›OºZKP@P@P@P@P@F+`À}´¾]P@P@P@P@P`ŠpŸ" m5P@P@P@P@P@F+`À}´¾]P@P@P@P@P`ŠpŸ" m5P@P@P@P@P@F+`À}´¾]P@P@P@P@P`ŠpŸ" m5P@P@P@P@P@F+`À}´¾]P@P@P@P@P`ŠlÙ¨çš)RW«©€ ( € ( € ( € ( € ( À(Œ³BÕc* € ( € ( € ( € ( € LMÿUš1%«PìIEND®B`‚perf-tools-unstable-1.0.1~20200130+git49b8cdf/iolatency000077500000000000000000000170031361450357500222160ustar00rootroot00000000000000#!/bin/bash # # iolatency - summarize block device I/O latency as a histogram. # Written using Linux ftrace. # # This shows the distribution of latency, allowing modes and latency outliers # to be identified and studied. # # USAGE: ./iolatency [-hQT] [-d device] [-i iotype] [interval [count]] # # REQUIREMENTS: FTRACE CONFIG and block:block_rq_* tracepoints, which you may # already have on recent kernels. # # OVERHEAD: block device I/O issue and completion events are traced and buffered # in-kernel, then processed and summarized in user space. There may be # measurable overhead with this approach, relative to the block device IOPS. # # This was written as a proof of concept for ftrace. # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 20-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock bufsize_kb=4096 opt_device=0; device=; opt_iotype=0; iotype=; opt_timestamp=0 opt_interval=0; interval=1; opt_count=0; count=0; opt_queue=0 trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: iolatency [-hQT] [-d device] [-i iotype] [interval [count]] -d device # device string (eg, "202,1) -i iotype # match type (eg, '*R*' for all reads) -Q # use queue insert as start time -T # timestamp on output -h # this usage message interval # summary interval, seconds (default 1) count # number of summaries eg, iolatency # summarize latency every second iolatency -Q # include block I/O queue time iolatency 5 2 # 2 x 5 second summaries iolatency -i '*R*' # trace reads iolatency -d 202,1 # trace device 202,1 only See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > events/block/$b_start/enable" warn "echo 0 > events/block/block_rq_complete/enable" if (( opt_device || opt_iotype )); then warn "echo 0 > events/block/$b_start/filter" warn "echo 0 > events/block/block_rq_complete/filter" fi warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts d:hi:QT opt do case $opt in d) opt_device=1; device=$OPTARG ;; i) opt_iotype=1; iotype=$OPTARG ;; Q) opt_queue=1 ;; T) opt_timestamp=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) if (( $# )); then opt_interval=1 interval=$1 shift fi if (( $# )); then opt_count=1 count=$1 fi if (( opt_device )); then major=${device%,*} minor=${device#*,} dev=$(( (major << 20) + minor )) fi if (( opt_queue )); then b_start=block_rq_insert else b_start=block_rq_issue fi ### select awk [[ -x /usr/bin/mawk ]] && awk='mawk -W interactive' || awk=awk ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and begin tracing warn "echo nop > current_tracer" warn "echo $bufsize_kb > buffer_size_kb" filter= if (( opt_iotype )); then filter="rwbs ~ \"$iotype\"" fi if (( opt_device )); then [[ "$filter" != "" ]] && filter="$filter && " filter="${filter}dev == $dev" fi if (( opt_iotype || opt_device )); then if ! echo "$filter" > events/block/$b_start/filter || \ ! echo "$filter" > events/block/block_rq_complete/filter then edie "ERROR: setting -d or -t filter. Exiting." fi fi if ! echo 1 > events/block/$b_start/enable || \ ! echo 1 > events/block/block_rq_complete/enable; then edie "ERROR: enabling block I/O tracepoints. Exiting." fi etext= (( !opt_count )) && etext=" Ctrl-C to end." echo "Tracing block I/O. Output every $interval seconds.$etext" # # Determine output format. It may be one of the following (newest first): # TASK-PID CPU# |||| TIMESTAMP FUNCTION # TASK-PID CPU# TIMESTAMP FUNCTION # To differentiate between them, the number of header fields is counted, # and an offset set, to skip the extra column when needed. # offset=$($awk 'BEGIN { o = 0; } $1 == "#" && $2 ~ /TASK/ && NF == 6 { o = 1; } $2 ~ /TASK/ { print o; exit }' trace) ### print trace buffer warn "echo > trace" i=0 while (( !opt_count || (i < count) )); do (( i++ )) sleep $interval # snapshots were added in 3.10 if [[ -x snapshot ]]; then echo 1 > snapshot echo > trace cat snapshot else cat trace echo > trace fi (( opt_timestamp )) && printf "time %(%H:%M:%S)T:\n" -1 echo "tick" done | \ $awk -v o=$offset -v opt_timestamp=$opt_timestamp -v b_start=$b_start ' function star(sval, smax, swidth) { stars = "" if (smax == 0) return "" for (si = 0; si < (swidth * sval / smax); si++) { stars = stars "#" } return stars } BEGIN { max_i = 0 } # common fields $1 != "#" { time = $(3+o); sub(":", "", time) dev = $(5+o) } # block I/O request $1 != "#" && $0 ~ b_start { # # example: (fields1..4+o) 202,1 W 0 () 12862264 + 8 [tar] # The cmd field "()" might contain multiple words (hex), # hence stepping from the right (NF-3). # loc = $(NF-3) starts[dev, loc] = time next } # block I/O completion $1 != "#" && $0 ~ /rq_complete/ { # # example: (fields1..4+o) 202,1 W () 12862256 + 8 [0] # dir = $(6+o) loc = $(NF-3) if (starts[dev, loc] > 0) { latency_ms = 1000 * (time - starts[dev, loc]) i = 0 for (ms = 1; latency_ms > ms; ms *= 2) { i++ } hist[i]++ if (i > max_i) max_i = i delete starts[dev, loc] } next } # timestamp $1 == "time" { lasttime = $2 } # print summary $1 == "tick" { print "" if (opt_timestamp) print lasttime # find max value max_v = 0 for (i = 0; i <= max_i; i++) { if (hist[i] > max_v) max_v = hist[i] } # print histogram printf "%8s .. %-8s: %-8s |%-38s|\n", ">=(ms)", "<(ms)", "I/O", "Distribution" ms = 1 from = 0 for (i = 0; i <= max_i; i++) { printf "%8d -> %-8d: %-8d |%-38s|\n", from, ms, hist[i], star(hist[i], max_v, 38) from = ms ms *= 2 } fflush() delete hist delete starts # invalid if events missed between snapshots max_i = 0 } $0 ~ /LOST.*EVENTS/ { print "WARNING: " $0 > "/dev/stderr" } ' ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/iosnoop000077500000000000000000000216301361450357500217160ustar00rootroot00000000000000#!/bin/bash # # iosnoop - trace block device I/O. # Written using Linux ftrace. # # This traces disk I/O at the block device interface, using the block: # tracepoints. This can help characterize the I/O requested for the storage # devices and their resulting performance. I/O completions can also be studied # event-by-event for debugging disk and controller I/O scheduling issues. # # USAGE: ./iosnoop [-hQst] [-d device] [-i iotype] [-p pid] [-n name] [duration] # # Run "iosnoop -h" for full usage. # # REQUIREMENTS: FTRACE CONFIG, block:block_rq_* tracepoints (you may # already have these on recent kernels). # # OVERHEAD: By default, iosnoop works without buffering, printing I/O events # as they happen (uses trace_pipe), context switching and consuming CPU to do # so. This has a limit of about 10,000 IOPS (depending on your platform), at # which point iosnoop will be consuming 1 CPU. The duration mode uses buffering, # and can handle much higher IOPS rates, however, the buffer has a limit of # about 50,000 I/O, after which events will be dropped. You can tune this with # bufsize_kb, which is per-CPU. Also note that the "-n" option is currently # post-filtered, so all events are traced. # # This was written as a proof of concept for ftrace. It would be better written # using perf_events (after some capabilities are added), which has a better # buffering policy, or a tracer such as SystemTap or ktap. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the iosnoop(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 12-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock bufsize_kb=4096 opt_duration=0; duration=; opt_name=0; name=; opt_pid=0; pid=; ftext= opt_start=0; opt_end=0; opt_device=0; device=; opt_iotype=0; iotype= opt_queue=0 trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: iosnoop [-hQst] [-d device] [-i iotype] [-p PID] [-n name] [duration] -d device # device string (eg, "202,1) -i iotype # match type (eg, '*R*' for all reads) -n name # process name to match on I/O issue -p PID # PID to match on I/O issue -Q # use queue insert as start time -s # include start time of I/O (s) -t # include completion time of I/O (s) -h # this usage message duration # duration seconds, and use buffers eg, iosnoop # watch block I/O live (unbuffered) iosnoop 1 # trace 1 sec (buffered) iosnoop -Q # include queueing time in LATms iosnoop -ts # include start and end timestamps iosnoop -i '*R*' # trace reads iosnoop -p 91 # show I/O issued when PID 91 is on-CPU iosnoop -Qp 91 # show I/O queued by PID 91, queue time See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > events/block/$b_start/enable" warn "echo 0 > events/block/block_rq_complete/enable" if (( opt_device || opt_iotype || opt_pid )); then warn "echo 0 > events/block/$b_start/filter" warn "echo 0 > events/block/block_rq_complete/filter" fi warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts d:hi:n:p:Qst opt do case $opt in d) opt_device=1; device=$OPTARG ;; i) opt_iotype=1; iotype=$OPTARG ;; n) opt_name=1; name=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; Q) opt_queue=1 ;; s) opt_start=1 ;; t) opt_end=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) if (( $# )); then opt_duration=1 duration=$1 shift fi if (( opt_device )); then major=${device%,*} minor=${device#*,} dev=$(( (major << 20) + minor )) fi ### option logic (( opt_pid && opt_name )) && die "ERROR: use either -p or -n." (( opt_pid )) && ftext=" issued by PID $pid" (( opt_name )) && ftext=" issued by process name \"$name\"" if (( opt_duration )); then echo "Tracing block I/O$ftext for $duration seconds (buffered)..." else echo "Tracing block I/O$ftext. Ctrl-C to end." fi if (( opt_queue )); then b_start=block_rq_insert else b_start=block_rq_issue fi ### select awk (( opt_duration )) && use=mawk || use=gawk # workaround for mawk fflush() [[ -x /usr/bin/$use ]] && awk=$use || awk=awk wroteflock=1 ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." ### setup and begin tracing echo nop > current_tracer warn "echo $bufsize_kb > buffer_size_kb" filter= if (( opt_iotype )); then filter="rwbs ~ \"$iotype\"" fi if (( opt_device )); then [[ "$filter" != "" ]] && filter="$filter && " filter="${filter}dev == $dev" fi filter_i=$filter if (( opt_pid )); then [[ "$filter_i" != "" ]] && filter_i="$filter_i && " filter_i="${filter_i}common_pid == $pid" [[ "$filter" == "" ]] && filter=0 fi if (( opt_iotype || opt_device || opt_pid )); then if ! echo "$filter_i" > events/block/$b_start/filter || \ ! echo "$filter" > events/block/block_rq_complete/filter then edie "ERROR: setting -d or -t filter. Exiting." fi fi if ! echo 1 > events/block/$b_start/enable || \ ! echo 1 > events/block/block_rq_complete/enable; then edie "ERROR: enabling block I/O tracepoints. Exiting." fi (( opt_start )) && printf "%-15s " "STARTs" (( opt_end )) && printf "%-15s " "ENDs" printf "%-12.12s %-6s %-4s %-8s %-12s %-6s %8s\n" \ "COMM" "PID" "TYPE" "DEV" "BLOCK" "BYTES" "LATms" # # Determine output format. It may be one of the following (newest first): # TASK-PID CPU# |||| TIMESTAMP FUNCTION # TASK-PID CPU# TIMESTAMP FUNCTION # To differentiate between them, the number of header fields is counted, # and an offset set, to skip the extra column when needed. # offset=$($awk 'BEGIN { o = 0; } $1 == "#" && $2 ~ /TASK/ && NF == 6 { o = 1; } $2 ~ /TASK/ { print o; exit }' trace) ### print trace buffer warn "echo > trace" ( if (( opt_duration )); then # wait then dump buffer sleep $duration cat trace else # print buffer live cat trace_pipe fi ) | $awk -v o=$offset -v opt_name=$opt_name -v name=$name \ -v opt_duration=$opt_duration -v opt_start=$opt_start -v opt_end=$opt_end \ -v b_start=$b_start ' # common fields $1 != "#" { # task name can contain dashes comm = pid = $1 sub(/-[0-9][0-9]*/, "", comm) sub(/.*-/, "", pid) time = $(3+o); sub(":", "", time) dev = $(5+o) } # block I/O request $1 != "#" && $0 ~ b_start { if (opt_name && match(comm, name) == 0) next # # example: (fields1..4+o) 202,1 W 0 () 12862264 + 8 [tar] # The cmd field "()" might contain multiple words (hex), # hence stepping from the right (NF-3). # loc = $(NF-3) starts[dev, loc] = time comms[dev, loc] = comm pids[dev, loc] = pid next } # block I/O completion $1 != "#" && $0 ~ /rq_complete/ { # # example: (fields1..4+o) 202,1 W () 12862256 + 8 [0] # dir = $(6+o) loc = $(NF-3) nsec = $(NF-1) if (starts[dev, loc] > 0) { latency = sprintf("%.2f", 1000 * (time - starts[dev, loc])) comm = comms[dev, loc] pid = pids[dev, loc] if (opt_start) printf "%-15s ", starts[dev, loc] if (opt_end) printf "%-15s ", time printf "%-12.12s %-6s %-4s %-8s %-12s %-6s %8s\n", comm, pid, dir, dev, loc, nsec * 512, latency if (!opt_duration) fflush() delete starts[dev, loc] delete comms[dev, loc] delete pids[dev, loc] } next } $0 ~ /LOST.*EVENTS/ { print "WARNING: " $0 > "/dev/stderr" } ' ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/kernel/000077500000000000000000000000001361450357500215605ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/kernel/funccount000077500000000000000000000105341361450357500235150ustar00rootroot00000000000000#!/bin/bash # # funccount - count kernel function calls matching specified wildcards. # Uses Linux ftrace. # # This is a proof of concept using Linux ftrace capabilities on older kernels, # and works by using function profiling: in-kernel counters. # # USAGE: funccount [-hT] [-i secs] [-d secs] [-t top] funcstring # eg, # funccount 'ext3*' # count all ext3* kernel function calls # # Run "funccount -h" for full usage. # # WARNING: This uses dynamic tracing of kernel functions, and could cause # kernel panics or freezes. Test, and know what you are doing, before use. # # REQUIREMENTS: CONFIG_FUNCTION_PROFILER, awk. # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 12-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing opt_duration=0; duration=; opt_interval=0; interval=999999; opt_timestamp=0 opt_tail=0; tcmd=cat; ttext= trap 'quit=1' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: funccount [-hT] [-i secs] [-d secs] [-t top] funcstring -d seconds # total duration of trace -h # this usage message -i seconds # interval summary -t top # show top num entries only -T # include timestamp (for -i) eg, funccount 'vfs*' # trace all funcs that match "vfs*" funccount -d 5 'tcp*' # trace "tcp*" funcs for 5 seconds funccount -t 10 'ext3*' # show top 10 "ext3*" funcs funccount -i 1 'ext3*' # summary every 1 second funccount -i 1 -d 5 'ext3*' # 5 x 1 second summaries See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function die { echo >&2 "$@" exit 1 } ### process options while getopts d:hi:t:T opt do case $opt in d) opt_duration=1; duration=$OPTARG ;; i) opt_interval=1; interval=$OPTARG ;; t) opt_tail=1; tnum=$OPTARG ;; T) opt_timestamp=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) ### option logic (( $# == 0 )) && usage funcs="$1" if (( opt_tail )); then tcmd="tail -$tnum" ttext=" Top $tnum only." fi if (( opt_duration )); then echo "Tracing \"$funcs\" for $duration seconds.$ttext.." else echo "Tracing \"$funcs\".$ttext.. Ctrl-C to end." fi (( opt_duration && !opt_interval )) && interval=$duration ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### enable tracing sysctl -q kernel.ftrace_enabled=1 # doesn't set exit status echo "$funcs" > set_ftrace_filter || die "ERROR: enabling \"$funcs\". Exiting." warn "echo nop > current_tracer" if ! echo 1 > function_profile_enabled; then echo > set_ftrace_filter die "ERROR: enabling function profiling."\ "Have CONFIG_FUNCTION_PROFILER? Exiting." fi ### summarize quit=0; secs=0 while (( !quit && (!opt_duration || secs < duration) )); do (( secs += interval )) echo 0 > function_profile_enabled echo 1 > function_profile_enabled sleep $interval echo (( opt_timestamp )) && date printf "%-30s %8s\n" "FUNC" "COUNT" cat trace_stat/function* | awk ' # skip headers by matching on the numeric hit column $2 ~ /[0-9]/ { a[$1] += $2 } END { for (k in a) { printf "%-30s %8d\n", k, a[k] } }' | sort -n -k2 | $tcmd done ### end tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null warn "echo 0 > function_profile_enabled" warn "echo > set_ftrace_filter" perf-tools-unstable-1.0.1~20200130+git49b8cdf/kernel/funcgraph000077500000000000000000000215531361450357500234710ustar00rootroot00000000000000#!/bin/bash # # funcgraph - trace kernel function graph, showing child function calls. # Uses Linux ftrace. # # This is an exploratory tool that shows the graph of child function calls # for a given kernel function. This can cost moderate overhead to execute, and # should only be used to understand kernel behavior for a given function before # using other, lower overhead tools. This is a proof of concept using Linux # ftrace capabilities on older kernels. # # USAGE: funcgraph [-aCDhHPtT] [-m maxdepth] [-p PID] [-L TID] [-d secs] funcstring # # Run "funcgraph -h" for full usage. # # The output format is the same as the ftrace function graph trace format, # described in the kernel source under Documentation/trace/ftrace.txt. # Note that the output may be shuffled when different CPU buffers are read; # check the CPU column for changes, or include timestamps (-t) and post sort. # # The "-d duration" mode leaves the trace data in the kernel buffer, and # only reads it at the end. If the trace data is large, beware of exhausting # buffer space (/sys/kernel/debug/tracing/buffer_size_kb) and losing data. # # Also beware of feedback loops: tracing tcp* functions over an ssh session, # or writing ext4* functions to an ext4 file system. For the former, tcp # trace data could be redirected to a file (as in the usage message). For # the latter, trace to the screen or a different file system. # # WARNING: This uses dynamic tracing of kernel functions, and could cause # kernel panics or freezes. Test, and know what you are doing, before use. # # OVERHEADS: This tool causes moderate to high overheads. Use with caution for # exploratory purposes, then switch to lower overhead techniques based on # findings. It's expected that the kernel will run at least 50% slower while # this tool is running -- even while no output is being generated. This is # because ALL kernel functions are traced, and filtered based on the function # of interest. When output is generated, it can generate many lines quickly # depending on the traced event. Such data will cause performance overheads. # This also works without buffering by default, printing function events # as they happen (uses trace_pipe), context switching and consuming CPU to do # so. If needed, you can try the "-d secs" option, which buffers events # instead, reducing overhead. If you think the buffer option is losing events, # try increasing the buffer size (buffer_size_kb). # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 12-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock opt_duration=0; duration=; opt_pid=0; pid=; opt_tid=0; tid=; pidtext= opt_headers=0; opt_proc=0; opt_time=0; opt_tail=0; opt_nodur=0; opt_cpu=0 opt_max=0; max=0 trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: funcgraph [-aCDhHPtT] [-m maxdepth] [-p PID] [-L TID] [-d secs] funcstring -a # all info (same as -HPt) -C # measure on-CPU time only -d seconds # trace duration, and use buffers -D # do not show function duration -h # this usage message -H # include column headers -m maxdepth # max stack depth to show -p PID # trace when this pid is on-CPU -L TID # trace when this thread is on-CPU -P # show process names & PIDs -t # show timestamps -T # comment function tails eg, funcgraph do_nanosleep # trace do_nanosleep() and children funcgraph -m 3 do_sys_open # trace do_sys_open() to 3 levels only funcgraph -a do_sys_open # include timestamps and process name funcgraph -p 198 do_sys_open # trace vfs_read() for PID 198 only funcgraph -d 1 do_sys_open >out # trace 1 sec, then write to file See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing (( opt_time )) && warn "echo nofuncgraph-abstime > trace_options" (( opt_proc )) && warn "echo nofuncgraph-proc > trace_options" (( opt_tail )) && warn "echo nofuncgraph-tail > trace_options" (( opt_nodur )) && warn "echo funcgraph-duration > trace_options" (( opt_cpu )) && warn "echo sleep-time > trace_options" warn "echo nop > current_tracer" (( opt_pid || opt_tid )) && warn "echo > set_ftrace_pid" (( opt_max )) && warn "echo 0 > max_graph_depth" warn "echo > set_graph_function" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts aCd:DhHm:p:L:PtT opt do case $opt in a) opt_headers=1; opt_proc=1; opt_time=1 ;; C) opt_cpu=1; ;; d) opt_duration=1; duration=$OPTARG ;; D) opt_nodur=1; ;; m) opt_max=1; max=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; L) opt_tid=1; tid=$OPTARG ;; H) opt_headers=1; ;; P) opt_proc=1; ;; t) opt_time=1; ;; T) opt_tail=1; ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) ### option logic (( $# == 0 )) && usage (( opt_pid && opt_tid )) && edie "ERROR: You can use -p or -L but not both." funcs="$1" (( opt_pid )) && pidtext=" for PID $pid" (( opt_tid )) && pidtext=" for TID $tid" if (( opt_duration )); then echo "Tracing \"$funcs\"$pidtext for $duration seconds..." else echo "Tracing \"$funcs\"$pidtext... Ctrl-C to end." fi ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and commence tracing sysctl -q kernel.ftrace_enabled=1 # doesn't set exit status read mode < current_tracer [[ "$mode" != "nop" ]] && edie "ERROR: ftrace active (current_tracer=$mode)" if (( opt_max )); then if ! echo $max > max_graph_depth; then edie "ERROR: setting -m $max. Older kernel version? Exiting." fi fi if (( opt_pid )); then echo > set_ftrace_pid # ftrace expects kernel pids, which are thread ids for tid in /proc/$pid/task/*; do if ! echo ${tid##*/} >> set_ftrace_pid; then edie "ERROR: setting -p $pid (PID exist?). Exiting." fi done fi if (( opt_tid )); then if ! echo $tid > set_ftrace_pid; then edie "ERROR: setting -L $tid (TID exist?). Exiting." fi fi if ! echo > set_ftrace_filter; then edie "ERROR: writing to set_ftrace_filter. Exiting." fi if ! echo "$funcs" > set_graph_function; then edie "ERROR: enabling \"$funcs\". Exiting." fi if ! echo function_graph > current_tracer; then edie "ERROR: setting current_tracer to \"function\". Exiting." fi if (( opt_cpu )); then if ! echo nosleep-time > trace_options; then edie "ERROR: setting -C (nosleep-time). Exiting." fi fi # the following must be done after setting current_tracer if (( opt_time )); then if ! echo funcgraph-abstime > trace_options; then edie "ERROR: setting -t (funcgraph-abstime). Exiting." fi fi if (( opt_proc )); then if ! echo funcgraph-proc > trace_options; then edie "ERROR: setting -P (funcgraph-proc). Exiting." fi fi if (( opt_tail )); then if ! echo funcgraph-tail > trace_options; then edie "ERROR: setting -T (funcgraph-tail). Old kernel? Exiting." fi fi if (( opt_nodur )); then if ! echo nofuncgraph-duration > trace_options; then edie "ERROR: setting -D (nofuncgraph-duration). Exiting." fi fi ### print trace buffer warn "echo > trace" if (( opt_duration )); then sleep $duration if (( opt_headers )); then cat trace else grep -v '^#' trace fi else # trace_pipe lack headers, so fetch them from trace (( opt_headers )) && cat trace cat trace_pipe fi ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/kernel/funcslower000077500000000000000000000166331361450357500237060ustar00rootroot00000000000000#!/bin/bash # # funcslower - trace kernel functions slower than a threshold (microseconds). # Uses Linux ftrace. # # This uses the Linux ftrace function graph profiler to time kernel functions # and filter them based on a latency threshold. This is a proof of concept using # Linux ftrace capabilities on older kernels. # # USAGE: funcslower [-aChHPt] [-p PID] [-d secs] funcstring latency_us # # Run "funcslower -h" for full usage. # # REQUIREMENTS: FTRACE function graph, which you may already have available # and enabled in recent kernels. And awk. # # The output format is the same as the ftrace function graph trace format, # described in the kernel source under Documentation/trace/ftrace.txt. # Note that the output may be shuffled when different CPU buffers are read; # check the CPU column for changes, or include timestamps (-t) and post sort. # # WARNING: This uses dynamic tracing of kernel functions, and could cause # kernel panics or freezes. Test, and know what you are doing, before use. # # OVERHEADS: Timing and filtering is performed in-kernel context, costing # lower overheads than post-processing in user space. If you trace frequent # events (eg, pick a common function and a low threshold), you might want to # try the "-d secs" option, which buffers events in-kernel instead of printing # them live. # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 12-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock opt_duration=0; duration=; opt_pid=0; pid=; opt_tid=0; tid= pidtext=; opt_headers=0; opt_proc=0; opt_time=0; opt_cpu=0 trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: funcslower [-aChHPt] [-p PID] [-L TID] [-d secs] funcstring latency_us -a # all info (same as -HPt) -C # measure on-CPU time only -d seconds # trace duration, and use buffers -h # this usage message -H # include column headers -p PID # trace when this pid is on-CPU -L TID # trace when this thread is on-CPU -P # show process names & PIDs -t # show timestamps eg, funcslower vfs_read 10000 # trace vfs_read() slower than 10 ms See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing (( opt_time )) && warn "echo nofuncgraph-abstime > trace_options" (( opt_proc )) && warn "echo nofuncgraph-proc > trace_options" (( opt_cpu )) && warn "echo sleep-time > trace_options" warn "echo nop > current_tracer" (( opt_pid )) && warn "echo > set_ftrace_pid" warn "echo > set_ftrace_filter" warn "echo > set_graph_function" warn "echo 0 > tracing_thresh" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts aCd:hHp:L:Pt opt do case $opt in a) opt_headers=1; opt_proc=1; opt_time=1 ;; C) opt_cpu=1; ;; d) opt_duration=1; duration=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; L) opt_tid=1; tid=$OPTARG ;; H) opt_headers=1; ;; P) opt_proc=1; ;; t) opt_time=1; ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) ### option logic (( $# < 2 )) && usage (( opt_pid && opt_tid )) && edie "ERROR: You can use -p or -L but not both." funcs="$1" shift thresh=$1 (( opt_pid )) && pidtext=" for PID $pid" (( opt_tid )) && pidtext=" for TID $tid" printf "Tracing \"$funcs\"$pidtext slower than $thresh us" if (( opt_duration )); then echo " for $duration seconds..." else echo "... Ctrl-C to end." fi ## select awk if (( opt_duration )); then [[ -x /usr/bin/mawk ]] && awk=mawk || awk=awk else # workarounds for mawk/gawk fflush behavior if [[ -x /usr/bin/gawk ]]; then awk=gawk elif [[ -x /usr/bin/mawk ]]; then awk="mawk -W interactive" else awk=awk fi fi ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and commence tracing sysctl -q kernel.ftrace_enabled=1 # doesn't set exit status read mode < current_tracer [[ "$mode" != "nop" ]] && edie "ERROR: ftrace active (current_tracer=$mode)" if ! echo $thresh > tracing_thresh; then edie "ERROR: setting tracing_thresh to $thresh. Exiting." fi if (( opt_pid )); then echo '' > set_ftrace_pid # ftrace expects kernel pids, which are thread ids for tid in /proc/$pid/task/*; do if ! echo ${tid##*/} >> set_ftrace_pid; then edie "ERROR: setting -p $pid (PID exist?). Exiting." fi done fi if (( opt_tid )); then if ! echo $tid > set_ftrace_pid; then edie "ERROR: setting -L $tid (TID exist?). Exiting." fi fi if ! echo "$funcs" > set_ftrace_filter; then edie "ERROR: enabling \"$funcs\" filter. Function exist? Exiting." fi if ! echo "$funcs" > set_graph_function; then edie "ERROR: enabling \"$funcs\" graph. Exiting." fi if ! echo function_graph > current_tracer; then edie "ERROR: setting current_tracer to \"function_graph\". Exiting." fi if (( opt_cpu )); then if ! echo nosleep-time > trace_options; then edie "ERROR: setting -C (nosleep-time). Exiting." fi fi # the following must be done after setting current_tracer if (( opt_time )); then if ! echo funcgraph-abstime > trace_options; then edie "ERROR: setting -t (funcgraph-abstime). Exiting." fi fi if (( opt_proc )); then if ! echo funcgraph-proc > trace_options; then edie "ERROR: setting -P (funcgraph-proc). Exiting." fi fi ### setup output filter cat=cat if (( opt_proc )); then # remove proc change entries, since PID is included. example: # ------------------------------------------ # 0) supervi-1699 => supervi-1693 # ------------------------------------------ # cat=$awk' "/(^ ---|^$)/ || \$3 == \"=>\" { next } { print \$0 }"' fi ### print trace buffer warn "echo > trace" if (( opt_duration )); then sleep $duration if (( opt_headers )); then $cat trace else $cat trace | grep -v '^#' fi else # trace_pipe lack headers, so fetch them from trace (( opt_headers )) && cat trace eval $cat trace_pipe fi ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/kernel/functrace000077500000000000000000000141451361450357500234650ustar00rootroot00000000000000#!/bin/bash # # functrace - trace kernel function calls matching specified wildcards. # Uses Linux ftrace. # # This is a proof of concept using Linux ftrace capabilities on older kernels. # # USAGE: functrace [-hH] [-p PID] [-L TID] [-d secs] funcstring # eg, # functrace '*sleep' # trace all functions ending in "sleep" # # Run "functrace -h" for full usage. # # The output format is the same as the ftrace function trace format, described # in the kernel source under Documentation/trace/ftrace.txt. # # The "-d duration" mode leaves the trace data in the kernel buffer, and # only reads it at the end. If the trace data is large, beware of exhausting # buffer space (/sys/kernel/debug/tracing/buffer_size_kb) and losing data. # # Also beware of feedback loops: tracing tcp* functions over an ssh session, # or writing ext4* functions to an ext4 file system. For the former, tcp # trace data could be redirected to a file (as in the usage message). For # the latter, trace to the screen or a different file system. # # WARNING: This uses dynamic tracing of kernel functions, and could cause # kernel panics or freezes. Test, and know what you are doing, before use. # # OVERHEADS: This can generate a lot of trace data quickly, depending on the # frequency of the traced events. Such data will cause performance overheads. # This also works without buffering by default, printing function events # as they happen (uses trace_pipe), context switching and consuming CPU to do # so. If needed, you can try the "-d secs" option, which buffers events # instead, reducing overhead. If you think the buffer option is losing events, # try increasing the buffer size (buffer_size_kb). # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 12-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock opt_duration=0; duration=; opt_pid=0; pid=; opt_tid=0; tid=; pidtext= opt_headers=0 trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: functrace [-hH] [-p PID] [-L TID] [-d secs] funcstring -d seconds # trace duration, and use buffers -h # this usage message -H # include column headers -p PID # trace when this pid is on-CPU -L TID # trace when this thread is on-CPU eg, functrace do_nanosleep # trace the do_nanosleep() function functrace '*sleep' # trace functions ending in "sleep" functrace -p 198 'vfs*' # trace "vfs*" funcs for PID 198 functrace 'tcp*' > out # trace all "tcp*" funcs to out file functrace -d 1 'tcp*' > out # trace 1 sec, then write out file See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo nop > current_tracer" (( opt_pid || opt_tid )) && warn "echo > set_ftrace_pid" warn "echo > set_ftrace_filter" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts d:hHp:L: opt do case $opt in d) opt_duration=1; duration=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; L) opt_tid=1; tid=$OPTARG ;; H) opt_headers=1; ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) ### option logic (( $# == 0 )) && usage (( opt_pid && opt_tid )) && edie "ERROR: You can use -p or -L but not both." funcs="$1" (( opt_pid )) && pidtext=" for PID $pid" (( opt_tid )) && pidtext=" for TID $pid" if (( opt_duration )); then echo "Tracing \"$funcs\"$pidtext for $duration seconds..." else echo "Tracing \"$funcs\"$pidtext... Ctrl-C to end." fi ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and commence tracing sysctl -q kernel.ftrace_enabled=1 # doesn't set exit status read mode < current_tracer [[ "$mode" != "nop" ]] && edie "ERROR: ftrace active (current_tracer=$mode)" if (( opt_pid )); then echo > set_ftrace_pid # ftrace expects kernel pids, which are thread ids for tid in /proc/$pid/task/*; do if ! echo ${tid##*/} >> set_ftrace_pid; then edie "ERROR: setting -p $pid (PID exist?). Exiting." fi done fi if (( opt_tid )); then if ! echo $tid > set_ftrace_pid; then edie "ERROR: setting -L $tid (TID exist?). Exiting." fi fi if ! echo "$funcs" > set_ftrace_filter; then edie "ERROR: enabling \"$funcs\". Exiting." fi if ! echo function > current_tracer; then edie "ERROR: setting current_tracer to \"function\". Exiting." fi ### print trace buffer warn "echo > trace" if (( opt_duration )); then sleep $duration if (( opt_headers )); then cat trace else grep -v '^#' trace fi else # trace_pipe lack headers, so fetch them from trace (( opt_headers )) && cat trace cat trace_pipe fi ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/kernel/kprobe000077500000000000000000000175511361450357500230010ustar00rootroot00000000000000#!/bin/bash # # kprobe - trace a given kprobe definition. Kernel dynamic tracing. # Written using Linux ftrace. # # This will create, trace, then destroy a given kprobe definition. See # Documentation/trace/kprobetrace.txt in the Linux kernel source for the # syntax of a kprobe definition, and "kprobe -h" for examples. With this tool, # the probe alias is optional (it will become to kprobe: if not # specified). # # USAGE: ./kprobe [-FhHsv] [-d secs] [-p pid] [-L tid] kprobe_definition [filter] # # Run "kprobe -h" for full usage. # # I wrote this because I kept testing different custom kprobes at the command # line, and wanted a way to automate the steps. # # WARNING: This uses dynamic tracing of kernel functions, and could cause # kernel panics or freezes, depending on the function traced. Test in a lab # environment, and know what you are doing, before use. # # REQUIREMENTS: FTRACE and KPROBE CONFIG, which you may already have on recent # kernel versions. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the kprobe(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 22-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock; wroteflock=0 opt_duration=0; duration=; opt_pid=0; pid=; opt_tid=0; tid= opt_filter=0; filter=; opt_view=0; opt_headers=0; opt_stack=0; dmesg=2 debug=0; opt_force=0 trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: kprobe [-FhHsv] [-d secs] [-p PID] [-L TID] kprobe_definition [filter] -F # force. trace despite warnings. -d seconds # trace duration, and use buffers -p PID # PID to match on events -L TID # thread id to match on events -v # view format file (don't trace) -H # include column headers -s # show kernel stack traces -h # this usage message Note that these examples may need modification to match your kernel version's function names and platform's register usage. eg, kprobe p:do_sys_open # trace open() entry kprobe r:do_sys_open # trace open() return kprobe 'r:do_sys_open \$retval' # trace open() return value kprobe 'r:myopen do_sys_open \$retval' # use a custom probe name kprobe 'p:myopen do_sys_open mode=%cx:u16' # trace open() file mode kprobe 'p:myopen do_sys_open filename=+0(%si):string' # trace open() with filename kprobe -s 'p:myprobe tcp_retransmit_skb' # show kernel stacks kprobe 'p:do_sys_open file=+0(%si):string' 'file ~ "*stat"' # opened files ending in "stat" See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > events/kprobes/$kname/enable" if (( opt_filter )); then warn "echo 0 > events/kprobes/$kname/filter" fi warn "echo -:$kname >> kprobe_events" (( opt_stack )) && warn "echo 0 > options/stacktrace" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts Fd:hHp:L:sv opt do case $opt in F) opt_force=1 ;; d) opt_duration=1; duration=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; L) opt_tid=1; tid=$OPTARG ;; H) opt_headers=1 ;; s) opt_stack=1 ;; v) opt_view=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) (( $# )) || usage kprobe=$1 shift if (( $# )); then opt_filter=1 filter=$1 fi ### option logic (( opt_pid + opt_filter + opt_tid > 1 )) && \ die "ERROR: use at most one of -p, -L, or filter." (( opt_duration && opt_view )) && die "ERROR: use either -d or -v." if (( opt_pid )); then # convert to filter opt_filter=1 # ftrace common_pid is thread id from user's perspective for tid in /proc/$pid/task/*; do filter="$filter || common_pid == ${tid##*/}" done filter=${filter:3} # trim leading ' || ' (four characters) fi if (( opt_tid )); then opt_filter=1 filter="common_pid == $tid" fi if [[ "$kprobe" != p:* && "$kprobe" != r:* ]]; then echo >&2 "ERROR: invalid kprobe definition (should start with p: or r:)" usage fi # # parse the following: # r:do_sys_open # r:my_sys_open do_sys_open # r:do_sys_open %ax # r:do_sys_open $retval %ax # r:my_sys_open do_sys_open $retval %ax # r:do_sys_open rval=$retval # r:my_sys_open do_sys_open rval=$retval # r:my_sys_open do_sys_open rval=$retval %ax # ... and examples from USAGE message # krest=${kprobe#*:} kname=${krest%% *} set -- $krest if [[ $2 == "" || $2 == *[=%\$]* ]]; then # if probe name unspecified, default to function name ktype=${kprobe%%:*} kprobe="$ktype:$kname $krest" fi if (( debug )); then echo "kname: $kname, kprobe: $kprobe" fi ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ## check function set -- $kprobe fname=$2 if (( !opt_force )) && ! grep -w $fname available_filter_functions >/dev/null \ 2>&1 then echo >&2 "ERROR: func $fname not in $PWD/available_filter_functions." printf >&2 "Either it doesn't exist, or, it might be unsafe to kprobe. " echo >&2 "Exiting. Use -F to override." exit 1 fi if (( !opt_view )); then if (( opt_duration )); then echo "Tracing kprobe $kname for $duration seconds (buffered)..." else echo "Tracing kprobe $kname. Ctrl-C to end." fi fi ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and begin tracing echo nop > current_tracer if ! echo "$kprobe" >> kprobe_events; then echo >&2 "ERROR: adding kprobe \"$kprobe\"." if (( dmesg )); then echo >&2 "Last $dmesg dmesg entries (might contain reason):" dmesg | tail -$dmesg | sed 's/^/ /' fi edie "Exiting." fi if (( opt_view )); then cat events/kprobes/$kname/format edie "" fi if (( opt_filter )); then if ! echo "$filter" > events/kprobes/$kname/filter; then edie "ERROR: setting filter or -p. Exiting." fi fi if (( opt_stack )); then if ! echo 1 > options/stacktrace; then edie "ERROR: enabling stack traces (-s). Exiting" fi fi if ! echo 1 > events/kprobes/$kname/enable; then edie "ERROR: enabling kprobe $kname. Exiting." fi ### print trace buffer warn "echo > trace" if (( opt_duration )); then sleep $duration if (( opt_headers )); then cat trace else grep -v '^#' trace fi else # trace_pipe lack headers, so fetch them from trace (( opt_headers )) && cat trace cat trace_pipe fi ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/killsnoop000077500000000000000000000175631361450357500222540ustar00rootroot00000000000000#!/bin/bash # # killsnoop - trace kill() syscalls with signal/process details. # Written using Linux ftrace. # # This traces kill() syscalls, showing which process killed which pid and # returns the returncode (0 for success, -1 for error). # # This implementation is designed to work on older kernel versions, and without # kernel debuginfo. It works by dynamic tracing of the return value of kill() # and associating it with the previous kill() syscall return. # This approach is kernel version specific, and may not work on your version. # It is a workaround, and proof of concept for ftrace, until more kernel tracing # functionality is available. # # USAGE: ./killsnoop [-hst] [-d secs] [-p pid] [-n name] # # Run "killsnoop -h" for full usage. # # REQUIREMENTS: FTRACE and KPROBE CONFIG, syscalls:sys_enter_kill and # syscalls:sys_exit_kill kernel tracepoints (you may already have these # on recent kernels) and awk. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the killsnoop(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # COPYRIGHT: Copyright (c) 2014 Martin Probst. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 20-Jul-2014 Brendan Gregg Templated this. # 13-Sep-2014 Martin Probst Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock; wroteflock=0 opt_duration=0; duration=; opt_name=0; name=; opt_pid=0; pid=; ftext= opt_time=0; opt_fail=0; opt_file=0; file= kevent_entry=events/syscalls/sys_enter_kill kevent_return=events/syscalls/sys_exit_kill trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: killsnoop [-hst] [-d secs] [-p PID] [-n name] [filename] -d seconds # trace duration, and use buffers -n name # process name to match -p PID # PID to match on kill issue -t # include time (seconds) -s # human readable signal names -h # this usage message eg, killsnoop # watch kill()s live (unbuffered) killsnoop -d 1 # trace 1 sec (buffered) killsnoop -p 181 # trace kill()s issued to PID 181 only See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > $kevent_entry/enable" warn "echo 0 > $kevent_return/enable" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts d:hn:p:st opt do case $opt in d) opt_duration=1; duration=$OPTARG ;; n) opt_name=1; name=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; t) opt_time=1 ;; s) opt_fancy=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) (( $# )) && usage ### option logic (( opt_pid && opt_name )) && die "ERROR: use either -p or -n." (( opt_pid )) && ftext=" issued to PID $pid" (( opt_name )) && ftext=" issued by process name \"$name\"" if (( opt_duration )); then echo "Tracing kill()s$ftext for $duration seconds (buffered)..." else echo "Tracing kill()s$ftext. Ctrl-C to end." fi ### select awk # workaround for mawk fflush() [[ -x /usr/bin/mawk ]] && awk="mawk" && mawk -W interactive && \ [ $? -eq 0 ] && awk="mawk -W interactive" # workaround for gawk strtonum() [[ -x /usr/bin/gawk ]] && awk="gawk --non-decimal-data" ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and begin tracing echo nop > current_tracer if ! echo 1 > $kevent_entry/enable; then edie "ERROR: enabling kill() entry tracepoint Exiting." fi if ! echo 1 > $kevent_return/enable; then edie "ERROR: enabling kill() return tracepoint. Exiting." fi (( opt_time )) && printf "%-16s " "TIMEs" printf "%-16.16s %-6s %-8s %-10s %4s\n" "COMM" "PID" "TPID" "SIGNAL" "RETURN" # # Determine output format. It may be one of the following (newest first): # TASK-PID CPU# |||| TIMESTAMP FUNCTION # TASK-PID CPU# TIMESTAMP FUNCTION # To differentiate between them, the number of header fields is counted, # and an offset set, to skip the extra column when needed. # offset=$($awk 'BEGIN { o = 0; } $1 == "#" && $2 ~ /TASK/ && NF == 6 { o = 1; } $2 ~ /TASK/ { print o; exit }' trace) ### print trace buffer warn "echo > trace" ( if (( opt_duration )); then # wait then dump buffer sleep $duration cat trace else # print buffer live cat trace_pipe fi ) | $awk -v o=$offset -v opt_name=$opt_name -v name=$name \ -v opt_duration=$opt_duration -v opt_time=$opt_time \ -v opt_pid=$pid -v opt_fancy=$opt_fancy ' # fancy signal names BEGIN { signals[1] = "SIGHUP" signals[2] = "SIGINT" signals[3] = "SIGQUIT" signals[4] = "SIGILL" signals[6] = "SIGABRT" signals[8] = "SIGFPE" signals[9] = "SIGKILL" signals[11] = "SIGSEGV" signals[13] = "SIGPIPE" signals[14] = "SIGALRM" signals[15] = "SIGTERM" signals[10] = "SIGUSR1" signals[12] = "SIGUSR2" signals[17] = "SIGCHLD" signals[18] = "SIGCONT" signals[19] = "SIGSTOP" signals[20] = "SIGTSTP" signals[21] = "SIGTTIN" signals[22] = "SIGTTOU" } # common fields $1 != "#" { # task name can contain dashes comm = pid = $1 sub(/-[0-9][0-9]*/, "", comm) if (opt_name && match(comm, name) == 0) next sub(/.*-/, "", pid) } # sys_kill() entry $1 != "#" && $(4+o) ~ /sys_kill/ && $(5+o) !~ /->/ { # # eg: ... sys_kill(pid:... # kpid = $(5+o) signal = $(7+o) sub(/,$/, "", kpid) sub(/\)$/, "", signal) kpid = int("0x"kpid) signal = int("0x"signal) current[pid,"kpid"] = kpid current[pid,"signal"] = signal } # sys_kill exit $1 != "#" && $(5+o) ~ /->/ { rv = int($NF) killed_pid = current[pid,"kpid"] signal = current[pid,"signal"] delete current[pid,"kpid"] delete current[pid,"signal"] if(opt_pid && killed_pid != opt_pid) { next } if (opt_time) { time = $(3+o); sub(":", "", time) printf "%-16s ", time } if (opt_fancy) { if (signals[signal] != "") { signal = signals[signal] } } printf "%-16.16s %-6s %-8s %-10s %-4s\n", comm, pid, killed_pid, signal, rv } $0 ~ /LOST.*EVENTS/ { print "WARNING: " $0 > "/dev/stderr" } ' ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/000077500000000000000000000000001361450357500210535ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/000077500000000000000000000000001361450357500217165ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/bitesize.8000066400000000000000000000046311361450357500236310ustar00rootroot00000000000000.TH bitesize 8 "2014-07-07" "USER COMMANDS" .SH NAME bitesize \- show disk I/O size as a histogram. Uses Linux perf_events. .SH SYNOPSIS .B bitesize [-h] [-b buckets] [seconds] .SH DESCRIPTION This can be used to characterize the distribution of block device (disk) I/O sizes. To study block device I/O in more detail, see iosnoop(8). This uses multiple counting tracepoints with different filters, one for each histogram bucket. While this is summarized in-kernel, the use of multiple tracepoints does add addiitonal overhead, which is more evident if you add more buckets. In the future this functionality will be available in an efficient way in the kernel, and this tool can be rewritten. .SH REQUIREMENTS Linux perf_events: add linux-tools-common, run "perf", then add any additional packages it requests. This also requires the block:block_rq_issue tracepoint, which should already be available in recent kernels. .SH OPTIONS .TP \-h Usage message. .TP \-b buckets Specify a list of bucket points for the histogram as a string (eg, "10 500 1000"). The histogram will include buckets for less-than the minimum, and greater-than-or-equal-to the maximum. If a single value is specified, two statistics only are gathered: for less-than and for greater-than-or-equal-to. The overhead is relative to the number of buckets, so only specifying a single value costs the lowest overhead. .TP seconds Number of seconds to trace. If not specified, this runs until Ctrl-C. .SH EXAMPLES .TP Trace read() syscalls until Ctrl-C, and show histogram of requested size: # .B bitesize syscalls:sys_enter_read count .SH FIELDS .TP Kbytes Kbyte range of the histogram bucket. .TP I/O Number of I/O that occurred in this range while tracing. .TP Distribution ASCII histogram representation of the I/O column. .SH OVERHEAD While the counts are performed in-kernel, there is one tracepoint used per histogram bucket, so the overheads are higher than usual (relative to the number of buckets) than function counting using perf stat. The lowest overhead is when \-b is used to specify one bucket only, bifurcating statistics. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO iosnoop(8), iolatency(8), iostat(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/cachestat.8000066400000000000000000000073771361450357500237640ustar00rootroot00000000000000.TH cachestat 8 "2014-12-28" "USER COMMANDS" .SH NAME cachestat \- Measure page cache hits/misses. Uses Linux ftrace. .SH SYNOPSIS .B cachestat [\-Dht] [interval] .SH DESCRIPTION This tool provides basic cache hit/miss statistics for the Linux page cache. Its current implementation uses Linux ftrace dynamic function profiling to create custom in-kernel counters, which is a workaround until such counters can be built-in to the kernel. Specifically, four kernel functions are counted: .IP mark_page_accessed() for measuring cache accesses .IP mark_buffer_dirty() for measuring cache writes .IP add_to_page_cache_lru() for measuring page additions .IP account_page_dirtied() for measuring page dirties .PP It is possible that these functions have been renamed (or are different logically) for your kernel version, and this script will not work as-is. This was written for a Linux 3.13 kernel, and tested on a few others versions. This script is a sandcastle: the kernel may wash some away, and you'll need to rebuild. This program's implementation can be improved in the future when other kernel capabilities are made available. If you need a more reliable tool now, then consider other tracing alternatives (eg, SystemTap). This tool is really a proof of concept to see what ftrace can currently do. WARNING: This uses dynamic tracing of kernel functions, and could cause kernel panics or freezes. Test, and know what you are doing, before use. It also traces cache activity, which can be frequent, and cost some overhead. The statistics should be treated as best-effort: there may be some error margin depending on unusual workload types. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS CONFIG_FUNCTION_PROFILER, which you may already have enabled and available on recent kernels, and awk. .SH OPTIONS .TP \-D Include extra fields for debug purposes (see script). .TP \-h Print usage message. .TP \-t Include timestamps in units of seconds. .TP interval Output interval in seconds. Default is 1. .SH EXAMPLES .TP Show per-second page cache statistics: # .B cachestat .SH FIELDS .TP TIME Time, in HH:MM:SS. .TP HITS Number of page cache hits (reads). Each hit is for one memory page (the size depends on your processor architecture; commonly 4 Kbytes). Since this tool outputs at a timed interval, this field indicates the cache hit rate. .TP MISSES Number of page cache misses (reads from storage I/O). Each miss is for one memory page. Cache misses should be causing disk I/O. Run iostat(1) for correlation (although the miss count and size by the time disk I/O is issued can differ due to I/O subsystem merging). .TP DIRTIES Number of times a page in the page cache was written to and thus "dirtied". The same page may be counted multiple times per interval, if it is written to multiple times. This field gives an indication of how much cache churn there is, caused by applications writing data. .TP RATIO The ratio of cache hits to total cache accesses (hits + misses), as a percentage. .TP BUFFERS_MB Size of the buffer cache, for disk I/O. From /proc/meminfo. .TP CACHED_MB Size of the page cache, for file system I/O. From /proc/meminfo. .SH OVERHEAD This tool currently uses ftrace function profiling, which provides efficient in-kernel counters. However, the functions profiled are executed frequently, so the overheads can add up. Test and measure before use. My own testing showed around a 2% loss in application performance while this tool was running. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO iostat(1), iosnoop(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/execsnoop.8000066400000000000000000000066511361450357500240220ustar00rootroot00000000000000.TH execsnoop 8 "2014-07-07" "USER COMMANDS" .SH NAME execsnoop \- trace process exec() with arguments. Uses Linux ftrace. .SH SYNOPSIS .B execsnoop [\-hrt] [\-a argc] [\-d secs] [name] .SH DESCRIPTION execsnoop traces process execution, showing PID, PPID, and argument details if possible. This traces exec() from the fork()->exec() sequence, which means it won't catch new processes that only fork(). With the -r option, it will also catch processes that re-exec. It makes a best-effort attempt to retrieve the program arguments and PPID; if these are unavailable, 0 and "[?]" are printed respectively. There is also a limit to the number of arguments printed (by default, 8), which can be increased using -a. This implementation is designed to work on older kernel versions, and without kernel debuginfo. It works by dynamic tracing an execve kernel function to read the arguments from the %si register. The stub_execve() function is tried first, and then the do_execve() function. The sched:sched_process_fork tracepoint, is used for the PPID. Tracing registers and kernel functions is an unstable technique, and this tool may not work for some kernels or platforms. This program is a workaround that should be improved in the future when other kernel capabilities are made available. If you need a more reliable tool now, then consider other tracing alternatives (eg, SystemTap). This tool is really a proof of concept to see what ftrace can currently do. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE and KPROBE CONFIG, sched:sched_process_fork tracepoint, and either the stub_execve() or do_execve() kernel function. You may already have these on recent kernels. And awk. .SH OPTIONS .TP \-a argc Maximum number of arguments to show. The default is 8, and the maximum allowed is 16. If execsnoop thinks it has truncated the argument list, an ellipsis "[...]" will be shown. .TP \-d seconds Duration to trace, in seconds. This also uses in-kernel buffering. .TP \-h Print usage message. .TP \-r Include re-exec()s. .TP \-t Include timestamps in units of seconds. .TP name Only show processes that match this name. Partials and regular expressions are allowed, as this is filtered in user space by awk. .SH EXAMPLES .TP Trace all new processes and arguments (if possible): # .B execsnoop .TP Trace all new process names containing the text "http": # .B execsnoop http .SH FIELDS .TP TIMEs Time of the exec(), in seconds. .TP PID Process ID. .TP PPID Parent process ID, if this was able to be read. If it wasn't, 0 is printed. .TP ARGS Command line arguments, if these were able to be read. If they aren't able to be read, "[?]" is printed (which would be due to a limitation in this tools implementation, since this is workaround for older kernels; if you need reliable argument tracing, use a different tracer). They will be truncated to the argc limit, and an ellipsis "[...]" may be printed if execsnoop is aware of the truncation. .SH OVERHEAD This reads and processes exec() events in user space as they occur. Since the rate of exec() is expected to be low (< 500/s), the overhead is expected to be small or negligible. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO top(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/funccount.8000066400000000000000000000040561361450357500240200ustar00rootroot00000000000000.TH funccount 8 "2014-07-19" "USER COMMANDS" .SH NAME funccount \- count kernel function calls matching specified wildcards. Uses Linux ftrace. .SH SYNOPSIS .B funccount [\-hT] [\-i secs] [\-d secs] [\-t top] funcstring .SH DESCRIPTION This tool is a quick way to determine which kernel functions are being called, and at what rate. It uses ftrace function profiling capabilities. WARNING: This uses dynamic tracing of (what can be many) kernel functions, and could cause kernel panics or freezes. Test, and know what you are doing, before use. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS CONFIG_FUNCTION_PROFILER, which you may already have enabled and available on recent kernels, and awk. .SH OPTIONS \-d seconds Total duration of the trace. .TP \-h Print usage message. .TP \-i seconds Print an interval summary every so many seconds. .TP \-t top Print top number of entries only. .TP \-T Include timestamp on each summary. .TP funcstring A function name to trace, which may include file glob style wildcards ("*") at the beginning or ending of a string only. Eg, "vfs*" means match "vfs" followed by anything. .SH EXAMPLES .TP Count every kernel function beginning with "bio_", until Ctrl-C is hit: # .B funccount 'bio_*' .TP Count every "tcp_*" kernel function, and print a summary every one second, five in total: # .B funccount \-i 1 \-d 5 'tcp_*' .TP Count every "ext4*" kernel function, and print the top 20 when Ctrl-C is hit: # .B funccount \-t 20 'ext4*' .SH FIELDS .TP FUNC Kernel function name. .TP COUNT Number of times this function was called during the tracing interval. .SH OVERHEAD This uses the ftrace profiling framework, which does in-kernel counts, lowering the overhead (compared to tracing each event). .SH SOURCE This is from the perf-tools collection: .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO functrace(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/funcgraph.8000066400000000000000000000135721361450357500237740ustar00rootroot00000000000000.TH funcgraph 8 "2014-07-29" "USER COMMANDS" .SH NAME funcgraph \- trace kernel function graph, showing child function calls and times. Uses Linux ftrace. .SH SYNOPSIS .B funcgraph [\-aCDhHPtT] [\-m maxdepth] [\-p PID] [\-L TID] [\-d secs] funcstring .SH DESCRIPTION This is an exploratory tool that shows the graph of child function calls for a given kernel function. This can cost moderate overhead to execute, and should only be used to understand kernel behavior before using other, lower overhead tools. This is a proof of concept using Linux ftrace capabilities on older kernels. The output format is the same as the ftrace function graph trace format, described in the kernel source under Documentation/trace/ftrace.txt. Note that the output may be shuffled when different CPU buffers are read; check the CPU column for changes, or include timestamps (-t) and post sort. The "-d duration" mode leaves the trace data in the kernel buffer, and only reads it at the end. If the trace data is large, beware of exhausting buffer space (/sys/kernel/debug/tracing/buffer_size_kb) and losing data. Also beware of feedback loops: tracing tcp* functions over an ssh session, or writing ext4* functions to an ext4 file system. For the former, tcp trace data could be redirected to a file (as in the usage message). For the latter, trace to the screen or a different file system. WARNING: This uses dynamic tracing of kernel functions, and could cause kernel panics or freezes. Test, and know what you are doing, before use. Also see the OVERHEAD section. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE CONFIG, which you may already have enabled and available on recent kernels. .SH OPTIONS .TP \-a All info. Same as \-HPt. (But no -T, which isn't available in older kernels.) .TP \-C Function durations measure on-CPU time only (exclude sleep time). .TP \-d seconds Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-D Do not show function duration times. .TP \-h Print usage message. .TP \-H Print column headers. .TP \-m Max depth to trace functions. By default, unlimited (0). This feature is only available for newer Linux kernel versions. .TP \-p PID Only trace kernel functions when this process ID is on-CPU. .TP \-L TID Only trace kernel functions when this thread ID is on-CPU. .TP \-P Show process names and process IDs with every line of output. .TP \-t Show timestamps on every line of output. .TP \-T Tail mode: decorate function return lines with the name of the function. This option may not be available for older kernels. .TP funcstring A function name to trace, which may include file glob style wildcards ("*") at the beginning or ending of a string only. Eg, "vfs*" means match "vfs" followed by anything. Since the output is verbose, you probably only want to trace single functions, and not use wildcards. .SH EXAMPLES .TP Trace calls to do_nanosleep(), showing child functions and durations: # .B funcgraph do_nanosleep .TP Same as above, but include column headers: # .B funcgraph -H do_nanosleep .TP Same as above, but include timestamps and process names as well: # .B funcgraph -HtP do_nanosleep .TP Trace all vfs_read() kernel function calls, and child functions, for PID 198 only: # .B funcgraph \-p 198 vfs_read .TP Trace all vfs_read() kernel function calls, and child functions, for 1 second then write to a file. # .B funcgraph \-d 1 vfs_read > out .SH FIELDS The output format depends on the kernel version, and headings can be printed using \-H. The format is the same as the ftrace function trace format, described in the kernel source under Documentation/trace/ftrace.txt. Typical fields are: .TP TIME (Shown with \-t.) Time of event, in seconds. .TP CPU The CPU this event occurred on. .TP TASK/PID (Shown with \-P.) The process name (which could include dashes), a dash, and the process ID. .TP DURATION Elapsed time during the function call, inclusive of children. This is also inclusive of sleep time, unless -C is used. The time is either displayed on the return of a function ("}"), or for a leaf function (no children), on the same line. If the trace output begins with some returns that lack entries, their durations may not be trusted. This is usually only the case for the first dozen or so lines. .TP FUNCTION CALLS Entries and returns from kernel functions. .SH OVERHEAD This tool causes moderate to high overheads. Use with caution for exploratory purposes, then switch to lower overhead techniques based on findings. It's expected that the kernel will run at least 50% slower while this tool is running -- even while no output is being generated. This is because ALL kernel functions are traced, and filtered based on the function of interest. When output is generated, it can generate many lines quickly depending on the traced event. Such data will cause performance overheads. This also works without buffering by default, printing function events as they happen (uses trace_pipe), context switching and consuming CPU to do so. If needed, you can try the "-d secs" option, which buffers events instead, reducing overhead. If you think the buffer option is losing events, try increasing the buffer size (buffer_size_kb). It's a good idea to use funccount(8) first, which is lower overhead, to help you select which functions you may want to trace using funcgraph(8). .SH SOURCE This is from the perf-tools collection: .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO funccount(8), functrace(8), kprobe(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/funcslower.8000066400000000000000000000101361361450357500241770ustar00rootroot00000000000000.TH funcslower 8 "2014-07-30" "USER COMMANDS" .SH NAME funcslower \- trace kernel functions slower than a threshold (microseconds). Uses Linux ftrace. .SH SYNOPSIS .B funcslower [\-aChHPt] [\-p PID] [\-L TID] [\-d secs] funcstring latency_us .SH DESCRIPTION This uses the Linux ftrace function graph profiler to time kernel functions and filter them based on a latency threshold. Latency outliers can be studied this way, confirming their presence, duration, and rate. This tool is a proof of concept using Linux ftrace capabilities on older kernels. The output format is based on the ftrace function graph trace format, described in the kernel source under Documentation/trace/ftrace.txt. Use the \-H option to print column headings. Note that the output may be shuffled when different CPU buffers are read; check the CPU column for changes, or include timestamps (-t) and post sort. WARNING: This uses dynamic tracing of kernel functions, and could cause kernel panics or freezes. Test, and know what you are doing, before use. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE function graph, which you may already have enabled and available on recent kernels. And awk. .SH OPTIONS .TP \-a All info. Same as \-HPt. .TP \-C Function durations measure on-CPU time only (exclude sleep time). .TP \-d seconds Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-h Print usage message. .TP \-H Print column headers. .TP \-p PID Only trace kernel functions when this process ID is on-CPU. .TP \-L TID Only trace kernel functions when this thread ID is on-CPU. .TP \-P Show process names and process IDs with every line of output. .TP \-t Show timestamps on every line of output. .TP funcstring A function name to trace, which may include file glob style wildcards ("*") at the beginning or ending of a string only. Eg, "vfs*" means match "vfs" followed by anything. Since the output is verbose, you probably only want to trace single functions, and not use wildcards. .TP latency_us Minimum function duration to trace, in units of microseconds. This is filtered in-kernel. .SH EXAMPLES .TP Trace calls to vfs_read(), showing events slower than 10 ms: # .B funcslower vfs_read 10000 .TP Same as above, but include column headers, event timestamps, and process names: # .B funcslower -HPt vfs_read 10000 .TP Trace slow vfs_read()s for PID 198 only: # .B funcslower \-p 198 vfs_read 10000 .SH FIELDS The output format depends on the kernel version, and headings can be printed using \-H. The format is the same as the ftrace function trace format, described in the kernel source under Documentation/trace/ftrace.txt. Typical fields are: .TP TIME (Shown with \-t.) Time of event, in seconds. .TP CPU The CPU this event occurred on. .TP TASK/PID (Shown with \-P.) The process name (which could include dashes), a dash, and the process ID. .TP DURATION Elapsed time during the function call, inclusive of children. This is also inclusive of sleep time, unless -C is used. .TP FUNCTION CALLS Kernel function returns. .SH OVERHEAD OVERHEADS: Timing and filtering is performed in-kernel context, costing lower overheads than post-processing in user space. If you trace frequent events (eg, pick a common function and a low threshold), you might want to try the "-d secs" option, which buffers events in-kernel instead of printing them live. It's a good idea to start with a high threshold (eg, "100000" for 100 ms) then to decrease it. If you start low instead, you may start printing too many events. .SH SOURCE This is from the perf-tools collection: .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO funccount(8), functrace(8), funcgraph(8), kprobe(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/functrace.8000066400000000000000000000075221361450357500237670ustar00rootroot00000000000000.TH functrace 8 "2014-07-20" "USER COMMANDS" .SH NAME functrace \- trace kernel function calls matching specified wildcards. Uses Linux ftrace. .SH SYNOPSIS .B functrace [\-hH] [\-p PID] [\-L TID] [\-d secs] funcstring .SH DESCRIPTION This tool provides a quick way to capture the execution of kernel functions, showing basic details including as the process ID, timestamp, and calling function. WARNING: This uses dynamic tracing of (what can be many) kernel functions, and could cause kernel panics or freezes. Test, and know what you are doing, before use. Also beware of feedback loops: tracing tcp* functions over an ssh session, or writing ext4* functions to an ext4 file system. For the former, tcp trace data could be redirected to a file (as in the usage message). For the latter, trace to the screen or a different file system. SEE ALSO: kprobe(8), which can dynamically trace a single function call or return, and examine CPU registers and return values. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE CONFIG, which you may already have enabled and available on recent kernels. .SH OPTIONS .TP \-d seconds Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-h Print usage message. .TP \-H Print column headers. .TP \-p PID Only trace kernel functions when this process ID is on-CPU. .TP \-L TID Only trace kernel functions when this thread ID is on-CPU. .TP funcstring A function name to trace, which may include file glob style wildcards ("*") at the beginning or ending of a string only. Eg, "vfs*" means match "vfs" followed by anything. .SH EXAMPLES .TP Trace calls to do_nanosleep(): # .B functrace do_nanosleep .TP Trace calls to all kernel functions ending in "*sleep": # .B functrace '*sleep' .TP Trace all "vfs*" kernel function calls for PID 198: # .B functrace \-p 198 'vfs*' .TP Trace all "tcp*" kernel function calls, and output to a file until Ctrl-C: # .B functrace 'tcp*' > out .TP Trace all "tcp*" kernel function calls, output to a file, for 1 second (buffered): # .B functrace \-d 1 'tcp*' > out .SH FIELDS The output format depends on the kernel version, and headings can be printed using \-H. The format is the same as the ftrace function trace format, described in the kernel source under Documentation/trace/ftrace.txt. Typical fields are: .TP TASK-PID The process name (which could include dashes), a dash, and the process ID. .TP CPU# The CPU ID, in brackets. .TP |||| Kernel state flags. For example, on Linux 3.16 these are for irqs-off, need-resched, hardirq/softirq, and preempt-depth. .TP TIMESTAMP Time of event, in seconds. .TP FUNCTION Kernel function name. .SH OVERHEAD This can generate a lot of trace data quickly, depending on the frequency of the traced events. Such data will cause performance overheads. This also works without buffering by default, printing function events as they happen (uses trace_pipe), context switching and consuming CPU to do so. If needed, you can try the "\-d secs" option, which buffers events instead, reducing overhead. If you think the buffer option is losing events, try increasing the buffer size (buffer_size_kb). It's a good idea to use funccount(8) first, which is lower overhead, to help you select which functions you may want to trace using functrace(8). .SH SOURCE This is from the perf-tools collection: .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO funccount(8), kprobe(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/iolatency.8000066400000000000000000000071101361450357500237750ustar00rootroot00000000000000.TH iolatency 8 "2014-07-12" "USER COMMANDS" .SH NAME iolatency \- summarize block device I/O latency as a histogram. Uses Linux ftrace. .SH SYNOPSIS .B iolatency [\-hQT] [\-d device] [\-i iotype] [interval [count]] .SH DESCRIPTION This shows the distribution of latency, allowing modes and latency outliers to be identified and studied. For more details of block device I/O, use iosnoop(8). This is a proof of concept tool using ftrace, and involves user space processing and related overheads. See the OVERHEAD section. NOTE: Due to the way trace buffers are switched per interval, there is the possibility of losing a small number of I/O (usually less than 1%). The summary therefore shows the general distribution, but may be slightly incomplete. If 100% of I/O must be studied, use iosnoop(8) and post-process. Also note that I/O may be missed when the trace buffer is full: see the interval section in OPTIONS. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE CONFIG, and the tracepoints block:block_rq_issue and block:block_rq_complete, which you may already have enabled and available on recent Linux kernels. And awk. .SH OPTIONS .TP \-d device Only show I/O issued by this device. (eg, "202,1"). This matches the DEV column in the iolatency output, and is filtered in-kernel. .TP \-i iotype Only show I/O issued that matches this I/O type. This matches the TYPE column in the iolatency output, and wildcards ("*") can be used at the beginning or end (only). Eg, "*R*" matches all reads. This is filtered in-kernel. .TP \-h Print usage message. .TP \-Q Include block I/O queueing time. This uses block I/O queue insertion as the start tracepoint (block:block_rq_insert), instead of block I/O issue (block:block_rq_issue). .TP \-T Include timestamps with each summary output. .TP interval Interval between summary histograms, in seconds. During the interval, trace output will be buffered in-kernel, which is then read and processed for the summary. This buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size (the bufsize_kb setting in iolatency). With the default setting (4 Mbytes), I'd expect this to happen around 50k I/O per summary. .TP count Number of summaries to print. .SH EXAMPLES .TP Default output, print a summary of block I/O latency every 1 second: # .B iolatency .TP Include block I/O queue time: .B iolatency \-Q .TP Print 5 x 1 second summaries: # .B iolatency 1 5 .TP Trace reads only: # .B iolatency \-i '*R*' .TP Trace I/O issued to device 202,1 only: # .B iolatency \-d 202,1 .SH FIELDS .TP >=(ms) Latency was greater than or equal-to this value, in milliseconds. .TP <(ms) Latency was less than this value, in milliseconds. .TP I/O Number of block device I/O in this latency range, during the interval. .TP Distribution ASCII histogram representation of the I/O column. .SH OVERHEAD Block device I/O issue and completion events are traced and buffered in-kernel, then processed and summarized in user space. There may be measurable overhead with this approach, relative to the block device IOPS. The overhead may be acceptable in many situations. If it isn't, this tool can be reimplemented in C, or using a different tracer (eg, perf_events, SystemTap, ktap.) .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO iosnoop(8), iostat(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/iosnoop.8000066400000000000000000000133401361450357500234760ustar00rootroot00000000000000.TH iosnoop 8 "2014-07-12" "USER COMMANDS" .SH NAME iosnoop \- trace block I/O events as they occur. Uses Linux ftrace. .SH SYNOPSIS .B iosnoop [\-hQst] [\-d device] [\-i iotype] [\-p pid] [\-n name] [duration] .SH DESCRIPTION iosnoop prints block device I/O events as they happen, with useful details such as PID, device, I/O type, block number, I/O size, and latency. This traces disk I/O at the block device interface, using the block: tracepoints. This can help characterize the I/O requested for the storage devices and their resulting performance. I/O completions can also be studied event-by-event for debugging disk and controller I/O scheduling issues. NOTE: Use of a duration buffers I/O, which reduces overheads, but this also introduces a limit to the number of I/O that will be captured. See the duration section in OPTIONS. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE CONFIG, and the tracepoints block:block_rq_insert, block:block_rq_issue, and block:block_rq_complete, which you may already have enabled and available on recent Linux kernels. And awk. .SH OPTIONS .TP \-d device Only show I/O issued by this device. (eg, "202,1"). This matches the DEV column in the iosnoop output, and is filtered in-kernel. .TP \-i iotype Only show I/O issued that matches this I/O type. This matches the TYPE column in the iosnoop output, and wildcards ("*") can be used at the beginning or end (only). Eg, "*R*" matches all reads. This is filtered in-kernel. .TP \-p PID Only show I/O issued by this PID. This filters in-kernel. Note that I/O may be issued indirectly; for example, as the result of a memory allocation, causing dirty buffers (maybe from another PID) to be written to storage. With the \-Q option, the identified PID is more accurate, however, LATms now includes queueing time (see the \-Q option). .TP \-n name Only show I/O issued by processes with this name. Partial strings and regular expressions are allowed. This is a post-filter, so all I/O is traced and then filtered in user space. As with PID, this includes indirectly issued I/O, and \-Q can be used to improve accuracy (see the \-Q option). .TP \-h Print usage message. .TP \-Q Use block I/O queue insertion as the start tracepoint (block:block_rq_insert), instead of block I/O issue (block:block_rq_issue). This makes the following changes: COMM and PID are more likely to identify the origin process, as are \-p PID and \-n name; STARTs shows queue insert; and LATms shows I/O time including time spent on the block I/O queue. .TP \-s Include a column for the start time (issue time) of the I/O, in seconds. If the \-Q option is used, this is the time the I/O is inserted on the block I/O queue. .TP \-t Include a column for the completion time of the I/O, in seconds. .TP duration Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size (the bufsize_kb setting in iosnoop). With the default setting (4 Mbytes), I'd expect this to happen around 50k I/O. .SH EXAMPLES .TP Default output, print I/O activity as it occurs: # .B iosnoop .TP Buffer for 5 seconds (lower overhead) and write to a file: # .B iosnoop 5 > outfile .TP Trace based on block I/O queue insertion, showing queueing time: # .B iosnoop -Q .TP Trace reads only: # .B iosnoop \-i '*R*' .TP Trace I/O issued to device 202,1 only: # .B iosnoop \-d 202,1 .TP Include I/O start and completion timestamps: # .B iosnoop \-ts .TP Include I/O queueing and completion timestamps: # .B iosnop \-Qts .TP Trace I/O issued when PID 181 was on-CPU only: # .B iosnoop \-p 181 .TP Trace I/O queued when PID 181 was on-CPU (more accurate), and include queue time: # .B iosnoop \-Qp 181 .SH FIELDS .TP COMM Process name (command) for the PID that was on-CPU when the I/O was issued, or inserted if \-Q is used. See PID. This column is truncated to 12 characters. .TP PID Process ID which was on-CPU when the I/O was issued, or inserted if \-Q is used. This will usually be the process directly requesting I/O, however, it may also include indirect I/O. For example, a memory allocation by this PID which causes dirty memory from another PID to be flushed to disk. .TP TYPE Type of I/O. R=read, W=write, M=metadata, S=sync, A=readahead, F=flush or FUA (force unit access), D=discard, E=secure, N=null (not RWFD). .TP DEV Storage device ID. .TP BLOCK Disk block for the operation (location, relative to this device). .TP BYTES Size of the I/O, in bytes. .TP LATms Latency (time) for the I/O, in milliseconds. .SH OVERHEAD By default, iosnoop works without buffering, printing I/O events as they happen (uses trace_pipe), context switching and consuming CPU to do so. This has a limit of about 10,000 IOPS (depending on your platform), at which point iosnoop will be consuming 1 CPU. The duration mode uses buffering, and can handle much higher IOPS rates, however, the buffer has a limit of about 50,000 I/O, after which events will be dropped. You can tune this with bufsize_kb, which is per-CPU. Also note that the "-n" option is currently post-filtered, so all events are traced. The overhead may be acceptable in many situations. If it isn't, this tool can be reimplemented in C, or using a different tracer (eg, perf_events, SystemTap, ktap.) .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO iolatency(8), iostat(1), lsblk(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/killsnoop.8000066400000000000000000000056001361450357500240220ustar00rootroot00000000000000.TH killsnoop 8 "2014-09-15" "USER COMMANDS" .SH NAME killsnoop \- trace kill() syscalls with process and signal details. Uses Linux ftrace. .SH SYNOPSIS .B killsnoop [\-hst] [\-d secs] [\-p pid] [\-n name] .SH DESCRIPTION This traces kill() syscalls, showing which process killed which pid and returns the returncode (0 for success, -1 for error). This implementation is designed to work on older kernel versions, and without kernel debuginfo. It works by dynamic tracing of the return value of kill() and associating it with the previous kill() syscall return. This approach is kernel version specific, and may not work on your version. It is a workaround, and proof of concept for ftrace, until more kernel tracing functionality is available. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE and KPROBE CONFIG, syscalls:sys_enter_kill and syscalls:sys_exit_kill kernel tracepoints (you may already have these on recent kernels) and awk. .SH OPTIONS .TP \-d secs Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-h Print usage message. .TP \-n name Only show processes matching this process name. Partial strings and regular expressions are allowed. This is post-filtered using awk. .TP \-p PID Only trace this process ID. This is filtered in-kernel. .TP \-s Use human readable signal names, instead of signal numbers. .TP \-t Include timestamps, in seconds. .SH EXAMPLES .TP Trace all kill() syscalls with details: # .B killsnoop .TP Trace kill() syscalls with readable signal names, and times: # .B killsnoop -st .TP Track kill() syscalls for processes named "httpd": # .B killsnoop -n httpd .SH FIELDS .TP TIMEs Time of open() completion, in units of seconds. .TP COMM Process name (if known) of the process that issued the signal. .TP PID Process ID that issued the signal. .TP TPID Target PID for the signal. .TP SIGNAL Signal number sent to the target process, or name if -s is used. .TP RETURN Return status: 0 for success, -1 for failure. .SH OVERHEAD This reads and kill() syscalls as they occur. For high rates of kills (> 500/s), the overhead may begin to be measurable, however, the rate is unlikely to get this high. And if it is: you should investigate why. Test yourself. You can also use the \-d mode to buffer output, reducing overheads. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Martin Probst .SH SEE ALSO tpoint(8), execsnoop(8), opensnoop(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/kprobe.8000066400000000000000000000124221361450357500232720ustar00rootroot00000000000000.TH kprobe 8 "2014-07-20" "USER COMMANDS" .SH NAME kprobe \- trace a given kprobe definition. Kernel dynamic tracing. Uses Linux ftrace. .SH SYNOPSIS .B kprobe [\-FhHsv] [\-d secs] [\-p PID] [\-L TID] kprobe_definition [filter] .SH DESCRIPTION This will create, trace, then destroy a given kprobe definition. See Documentation/trace/kprobetrace.txt in the Linux kernel source for the syntax of a kprobe definition, and "kprobe -h" for examples. With this tool, the probe alias is optional (it will become to kprobe: if not specified). WARNING: This uses dynamic tracing of kernel functions, and could cause kernel panics or freezes, depending on the function traced. Test in a lab environment, and know what you are doing, before use. Also beware of feedback loops: tracing tcp functions over an ssh session, or writing ext4 functions to an ext4 file system. For the former, tcp trace data could be redirected to a file (as in the usage message). For the latter, trace to the screen or a different file system. SEE ALSO: functrace(8), which can perform basic tracing (event only) of multiple kernel functions using wildcards. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE and KPROBES CONFIG, which you may already have enabled and available on recent kernels. .SH OPTIONS .TP \-F Force. Trace despite warnings. By default the specified kernel function must exist in the available_filter_functions file. This option overrides this check. This might expose you to more unsafe functions, which could cause kernel panics or freezes when traced. .TP \-d seconds Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-h Print usage message. .TP \-H Print column headers. .TP \-s Print kernel stack traces after each event. .TP \-v Show the kprobe format file only (do not trace), identifying possible variables for use in a custom filter. .TP \-p PID Only trace kernel functions when this process ID is on-CPU. .TP \-L TID Only trace kernel functions when this thread ID is on-CPU. .TP kprobe_definition A full kprobe definition, as documented by Documentation/trace/kprobetrace.txt in the Linux kernel source. Note that the probe alias name is optional with kprobe(8), and if not specified, the tracepoint will become kprobe:. See the EXAMPLES section. .TP filter An ftrace filter definition. .SH EXAMPLES These examples may need modification to match your kernel version's function names and platform's register usage. If using platform specific registers becomes too painful in practice, consider a kernel debuginfo-based tracer, which can trace variables names instead. For example, perf_events. .TP Trace do_sys_open() entry: # .B kprobe p:do_sys_open .TP Trace do_sys_open() return: # .B kprobe r:do_sys_open .TP Trace do_sys_open() return value: # .B kprobe 'r:do_sys_open $retval' .TP Trace do_sys_open() return value, with a custom probe alias "myopen": # .B kprobe 'r:myopen do_sys_open $retval' .TP Trace do_sys_open() file mode: # .B kprobe 'p:myopen do_sys_open mode=%cx:u16' .TP Trace do_sys_open() file mode for PID 81: # .B kprobe -p 81 'p:myopen do_sys_open mode=%cx:u16' .TP Trace do_sys_open() with filename string: # .B kprobe 'p:myopen do_sys_open filename=+0(%si):string' .TP Trace do_sys_open() for filenames ending in "stat": # .B kprobe 'p:myopen do_sys_open fn=+0(%si):string' 'fn ~ """*stat"""' .TP Trace tcp_retransmit_skb() and show kernel stack traces, showing the path that led to it (can help explain why): # .B kprobe \-s 'p:myprobe tcp_retransmit_skb' .SH FIELDS The output format depends on the kernel version, and headings can be printed using \-H. The format is the same as the ftrace function trace format, described in the kernel source under Documentation/trace/ftrace.txt. Typical fields are: .TP TASK-PID The process name (which could include dashes), a dash, and the process ID. .TP CPU# The CPU ID, in brackets. .TP |||| Kernel state flags. For example, on Linux 3.16 these are for irqs-off, need-resched, hardirq/softirq, and preempt-depth. .TP TIMESTAMP Time of event, in seconds. .TP FUNCTION Kernel function name. .SH OVERHEAD This can generate a lot of trace data quickly, depending on the frequency of the traced events. Such data will cause performance overheads. This also works without buffering by default, printing function events as they happen (uses trace_pipe), context switching and consuming CPU to do so. If needed, you can try the "\-d secs" option, which buffers events instead, reducing overhead. If you think the buffer option is losing events, try increasing the buffer size (buffer_size_kb). It's a good idea to use funccount(8) first, which is lower overhead, to help you select which functions you may want to trace using kprobe(8). .SH SOURCE This is from the perf-tools collection: .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO functrace(8), funccount(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/opensnoop.8000066400000000000000000000061721361450357500240350ustar00rootroot00000000000000.TH opensnoop 8 "2014-07-20" "USER COMMANDS" .SH NAME opensnoop \- trace open() syscalls with file details. Uses Linux ftrace. .SH SYNOPSIS .B opensnoop [\-htx] [\-d secs] [\-p pid] [\-L tid] [\-n name] [filename] .SH DESCRIPTION This traces open() syscalls, showing the file name (pathname) and returned file descriptor number (or \-1, for error). This implementation is designed to work on older kernel versions, and without kernel debuginfo. It works by dynamic tracing of the return value of getname() as a string, and associating it with the following open() syscall return. This approach is kernel version specific, and may not work on your version. It is a workaround, and proof of concept for ftrace, until more kernel tracing functionality is available. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE and KPROBE CONFIG, the syscalls:sys_exit_open tracepoint, and the getname() kernel function. You may already have these enabled and available on recent Linux kernels. And awk. .SH OPTIONS .TP \-d secs Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-h Print usage message. .TP \-n name Only show processes matching this process name. Partial strings and regular expressions are allowed. This is post-filtered using awk. .TP \-p PID Only trace this process ID. This is filtered in-kernel. .TP \-L TID Only trace this thread ID. This is filtered in-kernel. .TP \-t Include timestamps, in seconds. .TP \-x Only print failed open()s. .TP filename Only show open()s which match this filename. Partial strings and regular expressions are allowed. This is post-filtered using awk. .SH EXAMPLES .TP Trace all open() syscalls with details: # .B opensnoop .TP Only trace open()s for PID 81: # .B opensnoop -p 81 .TP Trace failed open() syscalls: # .B opensnoop -x .TP Trace open() syscalls for filenames containing "conf": # .B opensnoop conf .TP Trace open() syscalls for filenames ending in "log": # .B opensnoop 'log$' .SH FIELDS .TP TIMEs Time of open() completion, in units of seconds. .TP COMM Process name (if known). .TP PID Process ID. .TP FD File descriptor. If this is a successful open, the file descriptor number is shown. If this is unsuccessful, -1 is shown. Numbers beginning with 0x are hexadecimal. .TP FILE Filename (pathname) used by the open() syscall. .SH OVERHEAD This reads and open() syscalls and getname() kernel functions as they occur. For high rates of opens (> 500/s), the overhead may begin to be measurable. Test yourself. You can use the \-d mode to buffer output, reducing overheads. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO execsnoop(8), strace(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/perf-stat-hist.8000066400000000000000000000075201361450357500246650ustar00rootroot00000000000000.TH perf-stat-hist 8 "2014-07-07" "USER COMMANDS" .SH NAME perf-stat-hist \- histogram summary of tracepoint values. Uses Linux perf_events. .SH SYNOPSIS .B perf-stat-hist [-h] [-b buckets|-P power] [-m max] tracepoint variable [seconds] .SH DESCRIPTION This is a proof-of-concept showing in-kernel histograms using Linux perf_events (aka the "perf" command), on older kernels where perf_events does not have this native capability. These histograms show the distribution of variable, allowing details including multiple modes and outliers to be studied. This uses multiple counting tracepoints with different filters, one for each histogram bucket. While this is summarized in-kernel, the use of multiple tracepoints does add addiitonal overhead. Hopefully, in the future this this functionality will be provided in an efficient way from perf_events itself, at which point this tool can be deleted or rewritten. .SH REQUIREMENTS Linux perf_events: add linux-tools-common, run "perf", then add any additional packages it requests. Also uses awk. .SH OPTIONS .TP \-h Usage message. .TP \-b buckets Specify a list of bucket points for the histogram as a string (eg, "10 500 1000"). The histogram will include buckets for less-than the minimum, and greater-than-or-equal-to the maximum. If a single value is specified, two statistics only are gathered: for less-than and for greater-than-or-equal-to. The overhead is relative to the number of buckets, so only specifying a single value costs the lowest overhead. .TP \-P power Power for power-of histogram. By default, a power-of-4 histogram is created. This and the \-b option are exclusive. .TP \-m max Max value for power-of histograms. .TP tracepoint Tracepoint specification. Eg, syscalls:sys_enter_read. .TP variable The tracepoint variable name to summarize. To see what are available, cat the format file under /sys/kernel/debug/tracing/events/*/*/format. .TP seconds Number of seconds to trace. If not specified, this runs until Ctrl-C. .SH EXAMPLES .TP Trace read() syscalls until Ctrl-C, and show histogram of requested size: # .B perf\-stat\-hist syscalls:sys_enter_read count .TP Trace read() syscall completions until Ctrl-C, and show histogram of successful returned size: # .B perf\-stat\-hist syscalls:sys_exit_read ret .TP Trace read() return sizes for 10 seconds, showing histogram: # .B perf\-stat\-hist syscalls:sys_exit_read ret 10 .TP Trace network transmits until Ctrl-C, and show histogram of packet size: # .B perf\-stat\-hist net:net_dev_xmit len .TP Trace read() return sizes, using a power-of-10 histogram: .B perf\-stat\-hist \-P 10 syscalls:sys_exit_read ret .TP Trace read() return sizes, using a power-of-2 histogram, and a max of 1024: .B perf\-stat\-hist \-P 2 \-m 1024 syscalls:sys_exit_read ret .TP Trace read() return sizes, using the specified bucket points: .B perf\-stat\-hist \-b """10 50 100 5000""" syscalls:sys_exit_read ret .TP Trace read() return sizes, and bifurcate statistics by the value 10: .B perf-stat-hist \-b 10 syscalls:sys_exit_read ret .SH FIELDS .TP Range Range of the histogram bucket, in units of the variable specified. .TP Count Number of occurrences (tracepoint events) of the variable in this range. .TP Distribution ASCII histogram representation of the Count column. .SH OVERHEAD While the counts are performed in-kernel, there is one tracepoint used per histogram bucket, so the overheads are higher than usual (relative to the number of buckets) than function counting using perf stat. The lowest overhead is when \-b is used to specify one bucket only, bifurcating statistics. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO perf(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/reset-ftrace.8000066400000000000000000000024141361450357500243740ustar00rootroot00000000000000.TH reset-ftrace 8 "2014-07-07" "USER COMMANDS" .SH NAME reset-ftrace \- reset state of ftrace, disabling all tracing. Written for Linux ftrace. .SH SYNOPSIS .B reset-ftrace [\-fhq] .SH DESCRIPTION This resets the state of various ftrace files, and shows the before and after state. This may only be of use to ftrace hackers who, in the process of developing ftrace software, often get the subsystem into a partially active state, and would like a quick way to reset state. Check the end of this script for the actually files reset, and add more if you need. WARNING: Only use this if and when you are sure that there are no other active ftrace sessions on your system, as otherwise it will kill them. .SH REQUIREMENTS FTRACE CONFIG. .SH OPTIONS .TP \-f Force. If the ftrace lock file exists (/var/tmp/.ftrace-lock), delete it. .TP \-h Print usage message. .TP \-q Quiet. Run, but don't print any output. .SH EXAMPLES .TP Reset various ftrace files: # .B reset-ftrace .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO perf(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/syscount.8000066400000000000000000000050471361450357500237040ustar00rootroot00000000000000.TH syscount 8 "2014-07-07" "USER COMMANDS" .SH NAME syscount \- count system calls. Uses Linux perf_events. .SH SYNOPSIS .B syscount [\-chv] [\-t top] {\-p PID|\-d seconds|command} .SH DESCRIPTION This is a proof-of-concept using perf_events capabilities for older kernel versions, that lack custom in-kernel aggregations. Once they exist, this script can be substantially rewritten and improved (lower overhead). .SH REQUIREMENTS Linux perf_events: add linux-tools-common, run "perf", then add any additional packages it requests. Also needs awk. .SH OPTIONS .TP \-c Show counts by syscall name. This mode (without -v) uses in-kernel counts, which have lower overhead than the default mode. .TP \-h Usage message. .TP \-v Verbose: include PID. .TP \-p PID Trace this process ID only. .TP \-d seconds Duration of trace in seconds. .TP command Run and trace this command. .SH EXAMPLES .TP Trace and summarize syscalls by process name: # .B syscount .TP Trace and summarize syscalls by syscall name (lower overhead): # .B syscount \-c .TP Trace for 5 seconds, showing by process name: # .B syscount \-d 5 .TP Trace PID 932 only, and show by syscall name (lower overhead): # .B syscount \-cp 923 .TP Execute the """ls""" command, and show by syscall name: # .B syscount -c ls .SH FIELDS .TP PID Process ID. .TP COMM Process command name. .TP SYSCALL Syscall name. .TP COUNT Number of syscalls during tracing. .SH OVERHEAD Modes that report syscall names only (\-c, \-cp PID, \-cd secs) have lower overhead, since they use in-kernel counts. Other modes which report process IDs (\-cv) or process names (default) create a perf.data file for post processing, and you will see messages about it doing this. Beware of the file size (test for short durations, or use \-c to see counts based on in-kernel counters), and gauge overheads based on the perf.data size. Note that this script delibrately does not pipe perf record into perf script, which would avoid perf.data, because it can create a feedback loop where the perf script syscalls are recorded. Hopefully there will be a fix for this in a later perf version, so perf.data can be skipped, or other kernel features to aggregate by process name in-kernel directly (eg, via eBPF, ktap, or SystemTap). .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO iosnoop(8), iolatency(8), iostat(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/tcpretrans.8000066400000000000000000000053251361450357500242010ustar00rootroot00000000000000.TH tcpretrans 8 "2014-07-31" "USER COMMANDS" .SH NAME tcpretrans \- show TCP retransmits, with address and other details. Uses Linux ftrace. .SH SYNOPSIS .B tcpretrans [\-hsp] .SH DESCRIPTION This traces TCP retransmits that are sent by the system tcpretrans is executed from, showing address, port, and TCP state information, and sometimes the PID (although usually not, since retransmits are usually sent by the kernel on timeout events). To keep overhead low, only tcp_retransmit_skb() kernel calls are traced (this does not trace every packet). This was written as a proof of concept for ftrace, for older Linux systems, and without kernel debuginfo. It uses dynamic tracing of tcp_retransmit_skb(), and reads /proc/net/tcp for socket details. Its use of dynamic tracing and CPU registers is an unstable platform-specific workaround, and may require modifications to work on different kernels and platforms. This would be better written using a tracer such as SystemTap, and will likely be rewritten in the future when certain tracing features are added to the Linux kernel. When \-l is used, this also uses dynamic tracing of tcp_send_loss_probe() and a register. Currently only IPv4 is supported, on x86_64. If you try this on a different architecture, you'll likely need to adjust the register locations (search for %di). Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE and KPROBE CONFIG, tcp_retransmit_skb() kernel function. You may have these already have these on recent kernels. And Perl. TCP tail loss probes were added in Linux 3.10. .SH OPTIONS .TP \-h Print usage message. .TP \-s Include kernel stack traces. .TP \-l Include TCP tail loss probes. .SH EXAMPLES .TP Trace TCP retransmits # .B tcpretrans .TP TIME Time of retransmit (may be rounded up to the nearest second). .TP PID Process ID that was on-CPU. This is less useful than it might sound, as it may usually be 0, for the kernel, for timer-based retransmits. .TP LADDR Local address. .TP LPORT Local port. .TP \-\- Packet type: "R>" for retransmit, and "L>" for tail loss probe. .TP RADDR Remote address. .TP RPORT Remote port. .TP STATE TCP session state. .SH OVERHEAD The CPU overhead is relative to the rate of TCP retransmits, and is designed to be low as this does not examine every packet. Once per second the /proc/net/tcp file is read, and a buffer of retransmit trace events is retrieved from the kernel and processed. .SH SOURCE This is from the perf-tools collection. .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO tcpdump(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/tpoint.8000066400000000000000000000100501361450357500233200ustar00rootroot00000000000000.TH tpoint 8 "2014-07-20" "USER COMMANDS" .SH NAME tpoint \- trace a given tracepoint. Static tracing. Uses Linux ftrace. .SH SYNOPSIS .B tpoint [\-hHsv] [\-d secs] [\-p PID] [\-L TID] tracepoint [filter] .B tpoint \-l .SH DESCRIPTION This will enable a given tracepoint, print events, then disable the tracepoint when the program ends. This is like a simple version of the "perf" command for printing live tracepoint events only. Wildcards are currently not supported. If for any reason tpoint(8) is insufficient, use the more powerful perf command for tracing tracepoints instead. Beware of feedback loops: tracing tcp functions over an ssh session, or writing ext4 events to an ext4 file system. For the former, tcp trace data could be redirected to a file (as in the usage message). For the latter, trace to the screen or a different file system. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS FTRACE CONFIG and tracepoints, which you may already have enabled and available on recent kernels. .SH OPTIONS .TP \-d seconds Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-h Print usage message. .TP \-H Print column headers. .TP \-l List tracepoints only. .TP \-s Print kernel stack traces after each event. .TP \-v Show the tpoint format file only (do not trace), identifying possible variables for use in a custom filter. .TP \-p PID Only trace kernel functions when this process ID is on-CPU. .TP \-L TID Only trace kernel functions when this thread ID is on-CPU. .TP tracepoint A tracepoint name. Eg, block:block_rq_issue. See the EXAMPLES section. .TP filter An ftrace filter definition. .SH EXAMPLES .TP List tracepoints containing "open": # .B tpoint -l | grep open .TP Trace open() syscall entry: # .B tpoint syscalls:sys_enter_open .TP Trace open() syscall entry, showing column headers: # .B tpoint -H syscalls:sys_enter_open .TP Trace block I/O issue: # .B tpoint block:block_rq_issue .TP Trace block I/O issue with stack traces: # .B tpoint \-s block:block_rq_issue .SH FIELDS The output format depends on the kernel version, and headings can be printed using \-H. The format is the same as the ftrace function trace format, described in the kernel source under Documentation/trace/ftrace.txt. Typical fields are: .TP TASK-PID The process name (which could include dashes), a dash, and the process ID. .TP CPU# The CPU ID, in brackets. .TP |||| Kernel state flags. For example, on Linux 3.16 these are for irqs-off, need-resched, hardirq/softirq, and preempt-depth. .TP TIMESTAMP Time of event, in seconds. .TP FUNCTION Kernel function name. .SH OVERHEAD This can generate a lot of trace data quickly, depending on the frequency of the traced events. Such data will cause performance overheads. This also works without buffering by default, printing function events as they happen (uses trace_pipe), context switching and consuming CPU to do so. If needed, you can try the "\-d secs" option, which buffers events instead, reducing overhead. If you think the buffer option is losing events, try increasing the buffer size (buffer_size_kb). Before using tpoint(8), you can use perf_events to count the rate of events for the tracepoint of interest, to gauge overhead. For example: .B perf stat \-e block:block_rq_issue \-a sleep 5 That counts the occurrences of the block:block_rq_issue tracepoint for 5 seconds. Also consider using perf_events, which manages buffers differently and more efficiently, for higher frequency applications. .SH SOURCE This is from the perf-tools collection: .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO functrace(8), funccount(8), perf(1) perf-tools-unstable-1.0.1~20200130+git49b8cdf/man/man8/uprobe.8000066400000000000000000000136401361450357500233070ustar00rootroot00000000000000.TH uprobe 8 "2014-07-20" "USER COMMANDS" .SH NAME uprobe \- trace a given uprobe definition. User-level dynamic tracing. Uses Linux ftrace. EXPERIMENTAL. .SH SYNOPSIS .B uprobe [\-FhHsv] [\-d secs] [\-p PID] [\-L TID] {\-l target | uprobe_definition [filter]} .SH DESCRIPTION This will create, trace, then destroy a given uprobe definition. See Documentation/trace/uprobetracer.txt in the Linux kernel source for the syntax of a uprobe definition, and "uprobe -h" for examples. With this tool, the probe alias is optional (it will default to something meaningful). WARNING: This uses dynamic tracing of user-level functions, using some relatively new kernel code. I have seen this cause target processes to fail, either entering endless spin loops or crashing on illegal instructions. I believe newer kernels (post 4.0) are relatively safer, but use caution. Test in a lab environment, and know what you are doing, before use. Also consider other (more developed) user-level tracers (perf_events, LTTng, etc.). Use extreme caution with the raw address mode: eg, "p:libc:0xbf130". uprobe does not check for instruction alignment, so tracing the wrong address (eg, mid-way through a multi-byte instruction) will corrupt the target's memory. Other tracers (eg, perf_events with debuginfo) check alignment. Also beware of widespread tracing that interferes with the operation of the system, eg, tracing libc:malloc, which by-default will trace _all_ processes. I wrote this because I kept testing different custom uprobes at the command line, and wanted a way to automate the steps. For generic user-level tracing, use perf_events directly. Since this uses ftrace, only the root user can use this tool. .SH REQUIREMENTS REQUIREMENTS: FTRACE and UPROBE CONFIG, which you may already have on recent kernel versions, file(1), ldconfig(8), objdump(1), and some version of awk. Also, currently only executes on Linux 4.0+ (see WARNING) unless -F is used. .SH OPTIONS .TP \-F Force. Trace despite kernel version warnings. Use on older kernels may expose you to (since fixed) bugs, which can lock up or crash target processes, which could also lock up the entire system. Test in a lab environment before use, and consider other more developed user-level tracers (perf_events, LTTng, etc.). .TP \-d seconds Set the duration of tracing, in seconds. Trace output will be buffered and printed at the end. This also reduces overheads by buffering in-kernel, instead of printing events as they occur. The ftrace buffer has a fixed size per-CPU (see /sys/kernel/debug/tracing/buffer_size_kb). If you think events are missing, try increasing that size. .TP \-h Print usage message. .TP \-H Print column headers. .TP \-s Print user-level stack traces after each event. These are currently printed in hex, and need post-processing to see user-level symbols (eg, addr2line; I should automate that). .TP \-v Show the uprobe format file only (do not trace), identifying possible variables for use in a custom filter. .TP \-p PID Only trace user-level functions when this process ID is on-CPU. .TP \-L TID Only trace user-level functions when this thread ID is on-CPU. .TP uprobe_definition A full uprobe definition, as documented by Documentation/trace/uprobetracer.txt in the Linux kernel source. Note that the probe alias name is optional with uprobe(8), and if not specified, it will default to something meaningful. See the EXAMPLES section. .TP filter An ftrace filter definition. .SH EXAMPLES These examples may need modification to match your target software function names and platform's register usage. If using platform specific registers becomes too painful in practice, consider a debuginfo-based tracer, which can trace variables names instead (eg, perf_events). .TP trace readline() calls in all running "bash" executables: # .B uprobe p:bash:readline .TP trace readline() with explicit executable path: # .B uprobe p:/bin/bash:readline .TP trace the return of readline() with return value as a string: # .B uprobe 'r:bash:readline +0($retval):string' .TP trace sleep() calls in all running libc shared libraries: # .B uprobe p:libc:sleep .TP trace sleep() with register %di (x86): # .B uprobe 'p:libc:sleep %di' .TP trace this address (use caution: must be instruction aligned): # .B uprobe p:libc:0xbf130 .TP trace gettimeofday() for PID 1182 only: # .B uprobe -p 1182 p:libc:gettimeofday .TP trace the return of fopen() only when it returns NULL: # .B uprobe 'r:libc:fopen file=$retval' 'file == 0' .SH FIELDS The output format depends on the kernel version, and headings can be printed using \-H. The format is the same as the ftrace function trace format, described in the kernel source under Documentation/trace/ftrace.txt. Typical fields are: .TP TASK-PID The process name (which could include dashes), a dash, and the process ID. .TP CPU# The CPU ID, in brackets. .TP |||| Kernel state flags. For example, on Linux 3.16 these are for irqs-off, need-resched, hardirq/softirq, and preempt-depth. .TP TIMESTAMP Time of event, in seconds. .TP FUNCTION User-level function name. .SH OVERHEAD This can generate a lot of trace data quickly, depending on the frequency of the traced events. Such data will cause performance overheads. This also works without buffering by default, printing function events as they happen (uses trace_pipe), context switching and consuming CPU to do so. If needed, you can try the "\-d secs" option, which buffers events instead, reducing overhead. If you think the buffer option is losing events, try increasing the buffer size (buffer_size_kb). If you find a use for uprobe(8) where the overhead is prohibitive, consider the same enabling using perf_events where overhead should be reduced. .SH SOURCE This is from the perf-tools collection: .IP https://github.com/brendangregg/perf-tools .PP Also look under the examples directory for a text file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH SEE ALSO kprobe(8) perf-tools-unstable-1.0.1~20200130+git49b8cdf/misc/000077500000000000000000000000001361450357500212335ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/misc/perf-stat-hist000077500000000000000000000151751361450357500240440ustar00rootroot00000000000000#!/bin/bash # # perf-stat-hist - perf_events stat histogram hack. # Written using Linux perf_events (aka "perf"). # # This is a proof-of-concept showing in-kernel histogram summaries of a # tracepoint variable. # # USAGE: perf-stat-hist [-h] [-b buckets|-P power] [-m max] tracepoint # variable [seconds] # # Run "perf-stat-hist -h" for full usage. # # This uses multiple counting tracepoints with different filters, one for each # histogram bucket. While this is summarized in-kernel, the use of multiple # tracepoints does add addiitonal overhead, which is more evident if you change # the power-of size from 4 to 2 (which creates more buckets). Hopefully, in the # future this this functionality will be provided in an efficient way from # perf_events itself, at which point this tool can be rewritten. # # From perf-tools: https://github.com/brendangregg/perf-tools # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 30-Jun-2014 Brendan Gregg Created this. opt_buckets=0; buckets=; opt_power=0; power=4; opt_max=0; max=$((1024 * 1024)) opt_filter=0; filter=; duration=0; debug=0 trap ':' INT QUIT TERM PIPE HUP function usage { cat <<-END >&2 USAGE: perf-stat-hist [-h] [-b buckets|-P power] [-m max] [-f filter] tracepoint variable [seconds] -b buckets # specify histogram bucket points -P power # power-of (default is 4) -m max # max value for power-of -f filter # specify a filter -h # this usage message eg, perf-stat-hist syscalls:sys_enter_read count 5 # read() request histogram, 5 seconds perf-stat-hist syscalls:sys_exit_read ret 5 # read() return histogram, 5 seconds perf-stat-hist -P 10 syscalls:sys_exit_read ret 5 # ... use power-of-10 perf-stat-hist -P 2 -m 1024 syscalls:sys_exit_read ret 5 # ... use power-of-2, max 1024 perf-stat-hist -b "10 50 100 500" syscalls:sys_exit_read ret 5 # ... histogram based on these bucket ranges perf-stat-hist -b 10 syscalls:sys_exit_read ret 5 # ... bifurcate by the value 10 (lowest overhead) perf-stat-hist -f 'rwbs == "WS"' block:block_rq_complete nr_sector 5 # ... synchronous writes histogram, 5 seconds See the man page and example file for more info. END exit } function die { echo >&2 "$@" exit 1 } ### process options while getopts b:hm:P:f: opt do case $opt in b) opt_buckets=1; buckets=($OPTARG) ;; P) opt_power=1; power=$OPTARG ;; m) opt_max=1; max=$OPTARG ;; f) opt_filter=1; filter="$OPTARG && " ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) (( $# < 2 )) && usage tpoint=$1 # tracepoint var=$2 # variable for histogram duration=${3} ### option logic (( opt_buckets && opt_power )) && die "ERROR: use either -b or -P" (( opt_power && power < 2 )) && die "ERROR: -P power must be 2 or higher" ### check that tracepoint exists if ! grep "^$tpoint\$" /sys/kernel/debug/tracing/available_events > /dev/null then echo >&2 "ERROR: tracepoint \"$tpoint\" not found. Exiting..." [[ "$USER" != "root" ]] && echo >&2 "Not root user?" exit 1 fi ### auto build power-of buckets if (( !opt_buckets )); then b=0 s=1 while (( s <= max )); do b="$b $s" (( s *= power )) done buckets=($b) fi ### build list of tracepoints and filters for each histogram bucket max=${buckets[${#buckets[@]} - 1]} # last element ((max_i = ${#buckets[*]} - 1)) tpoints="-e $tpoint --filter \"$filter $var < ${buckets[0]}\"" awkarray= i=0 while (( i < max_i )); do if (( i && ${buckets[$i]} <= ${buckets[$i - 1]} )); then die "ERROR: bucket list must increase in size." fi tpoints="$tpoints -e $tpoint --filter \"$filter $var >= ${buckets[$i]} && " tpoints="$tpoints $var < ${buckets[$i + 1]}\"" awkarray="$awkarray buckets[$i]=${buckets[$i]};" (( i++ )) done awkarray="$awkarray buckets[$max_i]=${buckets[$max_i]};" tpoints="$tpoints -e $tpoint --filter \"$filter $var >= ${buckets[$max_i]}\"" if (( debug )); then echo buckets: ${buckets[*]} echo tracepoints: $tpoints echo awkarray: ${awkarray[*]} fi ### prepare to run if (( duration )); then etext="for $duration seconds" cmd="sleep $duration" else etext="until Ctrl-C" cmd="sleep 999999" fi p_tpoint=$tpoint if [ -n "$filter" ]; then p_tpoint="$tpoint (Filter: ${filter%????})" fi if (( opt_buckets )); then echo "Tracing $p_tpoint, specified buckets, $etext..." else echo "Tracing $p_tpoint, power-of-$power, max $max, $etext..." fi ### run perf out="-o /dev/stdout" # a workaround needed in linux 3.2; not by 3.4.15 stat=$(eval perf stat $tpoints -a $out $cmd 2>&1) if (( $? != 0 )); then echo >&2 "ERROR running perf:" echo >&2 "$stat" exit fi if (( debug )); then echo raw output: echo "$stat" echo fi ### find max value for ASCII histogram most=$(echo "$stat" | awk -v tpoint=$tpoint ' $2 == tpoint { gsub(/,/, ""); if ($1 > m) { m = $1 } } END { print m }' ) ### process output echo echo "$stat" | awk -v tpoint=$tpoint -v max_i=$max_i -v most=$most ' function star(sval, smax, swidth) { stars = "" if (smax == 0) return "" for (si = 0; si < (swidth * sval / smax); si++) { stars = stars "#" } return stars } BEGIN { '"$awkarray"' printf(" %-15s: %-8s %s\n", "Range", "Count", "Distribution") } /Performance counter stats/ { i = -1 } # reverse order of rule set is important { ok = 0 } $2 == tpoint { num = $1; gsub(/,/, "", num); ok = 1 } ok && i >= max_i { printf(" %10d -> %-10s: %-8s |%-38s|\n", buckets[i], "", num, star(num, most, 38)) next } ok && i >= 0 && i < max_i { printf(" %10d -> %-10d: %-8s |%-38s|\n", buckets[i], buckets[i+1] - 1, num, star(num, most, 38)) i++ next } ok && i == -1 { printf(" %10s -> %-10d: %-8s |%-38s|\n", "", buckets[0] - 1, num, star(num, most, 38)) i++ } ' perf-tools-unstable-1.0.1~20200130+git49b8cdf/net/000077500000000000000000000000001361450357500210665ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/net/tcpretrans000077500000000000000000000214341361450357500232050ustar00rootroot00000000000000#!/usr/bin/perl # # tcpretrans - show TCP retransmts, with address and other details. # Written using Linux ftrace. # # This traces TCP retransmits, showing address, port, and TCP state information, # and sometimes the PID (although usually not, since retransmits are usually # sent by the kernel on timeouts). To keep overhead low, only # tcp_retransmit_skb() calls are traced (this does not trace every packet). # # USAGE: ./tcpretrans [-hls] # # REQUIREMENTS: FTRACE and KPROBE CONFIG, tcp_retransmit_skb() kernel function, # and tcp_send_loss_probe() when -l is used. You may have these already have # these on recent kernels. And Perl. # # This was written as a proof of concept for ftrace, for older Linux systems, # and without kernel debuginfo. It uses dynamic tracing of tcp_retransmit_skb(), # and reads /proc/net/tcp for socket details. Its use of dynamic tracing and # CPU registers is an unstable platform-specific workaround, and may require # modifications to work on different kernels and platforms. This would be better # written using a tracer such as SystemTap, and will likely be rewritten in the # future when certain tracing features are added to the Linux kernel. # # When -l is used, this also uses dynamic tracing of tcp_send_loss_probe() and # a register. # # Currently only IPv4 is supported, on x86_64. If you try this on a different # architecture, you'll likely need to adjust the register locations (search # for %di). # # OVERHEAD: The CPU overhead is relative to the rate of TCP retransmits, and is # designed to be low as this does not examine every packet. Once per second the # /proc/net/tcp file is read, and a buffer of retransmit trace events is # retrieved from the kernel and processed. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the tcpretrans(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 28-Jul-2014 Brendan Gregg Created this. use strict; use warnings; use POSIX qw(strftime); use Getopt::Long; my $tracing = "/sys/kernel/debug/tracing"; my $flock = "/var/tmp/.ftrace-lock"; my $interval = 1; local $SIG{INT} = \&cleanup; local $SIG{QUIT} = \&cleanup; local $SIG{TERM} = \&cleanup; local $SIG{PIPE} = \&cleanup; local $SIG{HUP} = \&cleanup; $| = 1; ### options my ($help, $stacks, $tlp); GetOptions("help|h" => \$help, "stacks|s" => \$stacks, "tlp|l" => \$tlp) or usage(); usage() if $help; sub usage { print STDERR "USAGE: tcpretrans [-hls]\n"; print STDERR " -h # help message\n"; print STDERR " -l # trace TCP tail loss probes\n"; print STDERR " -s # print stack traces\n"; print STDERR " eg,\n"; print STDERR " tcpretrans # trace TCP retransmits\n"; exit; } # delete lock and die sub ldie { unlink $flock; die @_; } # end tracing (silently) and die sub edie { print STDERR "@_\n"; close STDOUT; close STDERR; cleanup(); } sub writeto { my ($string, $file) = @_; open FILE, ">$file" or return 0; print FILE $string or return 0; close FILE or return 0; } sub appendto { my ($string, $file) = @_; open FILE, ">>$file" or return 0; print FILE $string or return 0; close FILE or return 0; } # kprobe functions sub create_kprobe { my ($kname, $kval) = @_; appendto "p:$kname $kval", "kprobe_events" or return 0; } sub enable_kprobe { my ($kname) = @_; writeto "1", "events/kprobes/$kname/enable" or return 0; } sub remove_kprobe { my ($kname) = @_; writeto "0", "events/kprobes/$kname/enable" or return 0; appendto "-:$kname", "kprobe_events" or return 0; } # tcp socket cache my %tcp; sub cache_tcp { undef %tcp; open(TCP, "/proc/net/tcp") or ldie "ERROR: reading /proc/net/tcp."; while () { next if /^ *sl/; my ($sl, $local_address, $rem_address, $st, $tx_rx, $tr_tm, $retrnsmt, $uid, $timeout, $inode, $jf, $sk) = split; $sk =~ s/^0x//; $tcp{$sk}{laddr} = $local_address; $tcp{$sk}{raddr} = $rem_address; $tcp{$sk}{state} = $st; } close TCP; } my @tcpstate; sub map_tcp_states { push @tcpstate, "NULL"; for () { chomp; s/.*TCP_//; s/[, ].*$//; push @tcpstate, $_; } } # /proc/net/tcp hex addr to dotted quad decimal sub inet_h2a { my ($haddr) = @_; my @addr = (); for my $num ($haddr =~ /(..)(..)(..)(..)/) { unshift @addr, hex($num); } return join(".", @addr); } ### check permissions chdir "$tracing" or die "ERROR: accessing tracing. Root? Kernel has FTRACE?" . "\ndebugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)"; ### ftrace lock if (-e $flock) { open FLOCK, $flock; my $fpid = ; chomp $fpid; close FLOCK; die "ERROR: ftrace may be in use by PID $fpid ($flock)"; } writeto "$$", $flock or die "ERROR: unable to write $flock."; # # Setup and begin tracing. # Use of ldie() and edie() ensures that if an error is encountered, the # kernel is not left in a partially configured state. # writeto "nop", "current_tracer" or ldie "ERROR: disabling current_tracer."; my $kname_rtr = "tcpretrans_tcp_retransmit_skb"; my $kname_tlp = "tcpretrans_tcp_send_loss_probe"; create_kprobe $kname_rtr, "tcp_retransmit_skb sk=%di" or ldie "ERROR: creating kprobe for tcp_retransmit_skb().";; if ($tlp) { create_kprobe $kname_tlp, "tcp_send_loss_probe sk=%di" or edie "ERROR: creating kprobe for tcp_send_loss_probe(). " . "Older kernel version?"; } if ($stacks) { writeto "1", "options/stacktrace" or print STDERR "WARNING: " . "unable to enable stacktraces.\n"; } enable_kprobe $kname_rtr or edie "ERROR: enabling $kname_rtr probe."; if ($tlp) { enable_kprobe $kname_tlp or edie "ERROR: enabling $kname_tlp probe."; } map_tcp_states(); printf "%-8s %-6s %-20s -- %-20s %-12s\n", "TIME", "PID", "LADDR:LPORT", "RADDR:RPORT", "STATE"; # # Read and print event data. This loop waits one second then reads the buffered # trace data, then caches /proc/net/tcp, then iterates over the buffered trace # data using the cached state. While this minimizes CPU overheads, it only # works because sockets that are retransmitting are usually long lived, and # remain in /proc/net/tcp for at least our sleep interval. # while (1) { sleep $interval; # buffer trace data open TPIPE, "trace" or edie "ERROR: opening trace_pipe."; my @trace = (); while () { next if /^#/; push @trace, $_; } close TPIPE; writeto "0", "trace" or edie "ERROR: clearing trace"; # cache /proc/net/tcp state if (scalar @trace) { cache_tcp(); } # process and print events for (@trace) { if ($stacks && /^ *=>/) { print $_; next; } my ($taskpid, $rest) = split ' ', $_, 2; my ($task, $pid) = $taskpid =~ /(.*)-(\d+)/; my ($skp) = $rest =~ /sk=([0-9a-fx]*)/; next unless defined $skp and $skp ne ""; $skp =~ s/^0x//; my ($laddr, $lport, $raddr, $rport, $state); if (defined $tcp{$skp}) { # convert /proc/net/tcp hex to dotted quads my ($hladdr, $hlport) = split /:/, $tcp{$skp}{laddr}; my ($hraddr, $hrport) = split /:/, $tcp{$skp}{raddr}; $laddr = inet_h2a($hladdr); $raddr = inet_h2a($hraddr); $lport = hex($hlport); $rport = hex($hrport); $state = $tcpstate[hex($tcp{$skp}{state})]; } else { # socket closed too quickly ($laddr, $raddr) = ("-", "-"); ($lport, $rport) = ("-", "-"); $state = "-"; } my $now = strftime "%H:%M:%S", localtime; printf "%-8s %-6s %-20s %s> %-20s %-12s\n", $now, $pid, "$laddr:$lport", $rest =~ /$kname_tlp/ ? "L" : "R", "$raddr:$rport", $state, } } ### end tracing cleanup(); sub cleanup { print "\nEnding tracing...\n"; close TPIPE; if ($stacks) { writeto "0", "options/stacktrace" or print STDERR "WARNING: " . "unable to disable stacktraces.\n"; } remove_kprobe $kname_rtr or print STDERR "ERROR: removing kprobe $kname_rtr\n"; if ($tlp) { remove_kprobe $kname_tlp or print STDERR "ERROR: removing kprobe $kname_tlp\n"; } writeto "", "trace"; unlink $flock; exit; } # from /usr/include/netinet/tcp.h: __DATA__ TCP_ESTABLISHED = 1, TCP_SYN_SENT, TCP_SYN_RECV, TCP_FIN_WAIT1, TCP_FIN_WAIT2, TCP_TIME_WAIT, TCP_CLOSE, TCP_CLOSE_WAIT, TCP_LAST_ACK, TCP_LISTEN, TCP_CLOSING /* now a valid state */ perf-tools-unstable-1.0.1~20200130+git49b8cdf/opensnoop000077500000000000000000000210041361450357500222430ustar00rootroot00000000000000#!/bin/bash # # opensnoop - trace open() syscalls with file details. # Written using Linux ftrace. # # This traces open() syscalls, showing the file name and returned file # descriptor number (or -1, for error). # # This implementation is designed to work on older kernel versions, and without # kernel debuginfo. It works by dynamic tracing of the return value of getname() # as a string, and associating it with the following open() syscall return. # This approach is kernel version specific, and may not work on your version. # It is a workaround, and proof of concept for ftrace, until more kernel tracing # functionality is available. # # USAGE: ./opensnoop [-htx] [-d secs] [-p pid] [-L tid] [-n name] [filename] # # Run "opensnoop -h" for full usage. # # REQUIREMENTS: FTRACE and KPROBE CONFIG, syscalls:sys_exit_open tracepoint, # getname() kernel function (you may already have these on recent kernels), # and awk. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the opensnoop(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 20-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock; wroteflock=0 opt_duration=0; duration=; opt_name=0; name=; opt_pid=0; pid=; opt_tid=0; tid= ftext=; opt_time=0; opt_fail=0; opt_file=0; file= trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: opensnoop [-htx] [-d secs] [-p PID] [-L TID] [-n name] [filename] -d seconds # trace duration, and use buffers -n name # process name to match on open -p PID # PID to match on open -L TID # PID to match on open -t # include time (seconds) -x # only show failed opens -h # this usage message filename # match filename (partials, REs, ok) eg, opensnoop # watch open()s live (unbuffered) opensnoop -d 1 # trace 1 sec (buffered) opensnoop -p 181 # trace I/O issued by PID 181 only opensnoop conf # trace filenames containing "conf" opensnoop 'log$' # filenames ending in "log" See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > events/kprobes/getnameprobe/enable" warn "echo 0 > events/syscalls/sys_exit_open/enable" warn "echo 0 > events/syscalls/sys_exit_openat/enable" if (( opt_pid || opt_tid )); then warn "echo 0 > events/kprobes/getnameprobe/filter" warn "echo 0 > events/syscalls/sys_exit_open/filter" warn "echo 0 > events/syscalls/sys_exit_openat/filter" fi warn "echo -:getnameprobe >> kprobe_events" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts d:hn:p:L:tx opt do case $opt in d) opt_duration=1; duration=$OPTARG ;; n) opt_name=1; name=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; L) opt_tid=1; tid=$OPTARG ;; t) opt_time=1 ;; x) opt_fail=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) if (( $# )); then opt_file=1 file=$1 shift fi (( $# )) && usage ### option logic (( opt_pid + opt_name + opt_tid > 1 )) && \ die "ERROR: use at most one of -p, -n, -L." (( opt_pid )) && ftext=" issued by PID $pid" (( opt_tid )) && ftext=" issued by TID $tid" (( opt_name )) && ftext=" issued by process name \"$name\"" (( opt_file )) && ftext="$ftext for filenames containing \"$file\"" if (( opt_duration )); then echo "Tracing open()s$ftext for $duration seconds (buffered)..." else echo "Tracing open()s$ftext. Ctrl-C to end." fi ### select awk (( opt_duration )) && use=mawk || use=gawk # workaround for mawk fflush() [[ -x /usr/bin/$use ]] && awk=$use || awk=awk ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and begin tracing echo nop > current_tracer ver=$(uname -r) if [[ "$ver" == 2.* || "$ver" == 3.[1-6].* ]]; then # rval is char * kprobe='r:getnameprobe getname +0($retval):string' else # rval is struct filename * kprobe='r:getnameprobe getname +0(+0($retval)):string' fi if ! echo $kprobe >> kprobe_events; then edie "ERROR: adding a kprobe for getname(). Exiting." fi if (( opt_pid )); then filter= for tid in /proc/$pid/task/*; do filter="$filter || common_pid == ${tid##*/}" done filter=${filter:3} # trim leading ' || ' (four characters) if ! echo $filter > events/kprobes/getnameprobe/filter || \ ! echo $filter > events/syscalls/sys_exit_open/filter || \ ! echo $filter > events/syscalls/sys_exit_openat/filter then edie "ERROR: setting -p $pid. Exiting." fi fi if (( opt_tid )); then if ! echo "common_pid == $tid" > events/kprobes/getnameprobe/filter || \ ! echo "common_pid == $tid" > events/syscalls/sys_exit_open/filter || \ ! echo "common_pid == $tid" > events/syscalls/sys_exit_openat/filter then edie "ERROR: setting -L $tid. Exiting." fi fi if ! echo 1 > events/kprobes/getnameprobe/enable; then edie "ERROR: enabling kprobe for getname(). Exiting." fi if ! echo 1 > events/syscalls/sys_exit_open/enable; then edie "ERROR: enabling open() exit tracepoint. Exiting." fi if ! echo 1 > events/syscalls/sys_exit_openat/enable; then edie "ERROR: enabling openat() exit tracepoint. Exiting." fi (( opt_time )) && printf "%-16s " "TIMEs" printf "%-16.16s %-6s %4s %s\n" "COMM" "PID" "FD" "FILE" # # Determine output format. It may be one of the following (newest first): # TASK-PID CPU# |||| TIMESTAMP FUNCTION # TASK-PID CPU# TIMESTAMP FUNCTION # To differentiate between them, the number of header fields is counted, # and an offset set, to skip the extra column when needed. # offset=$($awk 'BEGIN { o = 0; } $1 == "#" && $2 ~ /TASK/ && NF == 6 { o = 1; } $2 ~ /TASK/ { print o; exit }' trace) ### print trace buffer warn "echo > trace" ( if (( opt_duration )); then # wait then dump buffer sleep $duration cat trace else # print buffer live cat trace_pipe fi ) | $awk -v o=$offset -v opt_name=$opt_name -v name=$name \ -v opt_duration=$opt_duration -v opt_time=$opt_time -v opt_fail=$opt_fail \ -v opt_file=$opt_file -v file=$file ' # common fields $1 != "#" { # task name can contain dashes and space split($0, line, "-") sub(/^[ \t\r\n]+/, "", line[1]) comm = line[1] if (opt_name && match(comm, name) == 0) next sub(/ .*$/, "", line[2]) pid = line[2] } # do_sys_open() $1 != "#" && $(5+o) ~ /do_sys_open/ { # # eg: ... (do_sys_open+0xc3/0x220 <- getname) arg1="file1" # match($0, /arg1=\"(.+)\"/, m) lastfile[pid] = m[1] } # sys_open() / sys_openat() $1 != "#" && ($(4+o) == "sys_open" || $(4+o) == "sys_openat") { filename = lastfile[pid] if (!filename) next delete lastfile[pid] if (opt_file && filename !~ file) next rval = $NF # matched failed as beginning with 0xfffff if (opt_fail && rval !~ /0xfffff/) next if (rval ~ /0xfffff/) rval = -1 if (opt_time) { time = $(3+o); sub(":", "", time) printf "%-16s ", time } printf "%-16.16s %-6s %4s %s\n", comm, pid, rval, filename } $0 ~ /LOST.*EVENTS/ { delete lastfile print "WARNING: " $0 > "/dev/stderr" } ' ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/syscount000077500000000000000000000145271361450357500221260ustar00rootroot00000000000000#!/bin/bash # # syscount - count system calls. # Written using Linux perf_events (aka "perf"). # # This is a proof-of-concept using perf_events capabilities for older kernel # versions, that lack custom in-kernel aggregations. Once they exist, this # script can be substantially rewritten and improved (lower overhead). # # USAGE: syscount [-chv] [-t top] {-p PID|-d seconds|command} # # Run "syscount -h" for full usage. # # REQUIREMENTS: Linux perf_events: add linux-tools-common, run "perf", then # add any additional packages it requests. Also needs awk. # # OVERHEADS: Modes that report syscall names only (-c, -cp PID, -cd secs) have # lower overhead, since they use in-kernel counts. Other modes which report # process IDs (-cv) or process names (default) create a perf.data file for # post processing, and you will see messages about it doing this. Beware of # the file size (test for short durations, or use -c to see counts based on # in-kernel counters), and gauge overheads based on the perf.data size. # # Note that this script delibrately does not pipe perf record into # perf script, which would avoid perf.data, because it can create a feedback # loop where the perf script syscalls are recorded. Hopefully there will be a # fix for this in a later perf version, so perf.data can be skipped, or other # kernel features to aggregate by process name in-kernel directly (eg, via # eBPF, ktap, or SystemTap). # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the syscount(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 07-Jul-2014 Brendan Gregg Created this. # default variables opt_count=0; opt_pid=0; opt_verbose=0; opt_cmd=0; opt_duration=0; opt_tail=0 tnum=; pid=; duration=; cmd=; cpus=-a; opts=; tcmd=cat; ttext= trap '' INT QUIT TERM PIPE HUP stdout_workaround=1 # needed for older perf versions write_workaround=1 # needed for perf versions that trace their own writes ### parse options while getopts cd:hp:t:v opt do case $opt in c) opt_count=1 ;; d) opt_duration=1; duration=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; t) opt_tail=1; tnum=$OPTARG ;; v) opt_verbose=1 ;; h|?) cat <<-END >&2 USAGE: syscount [-chv] [-t top] {-p PID|-d seconds|command} syscount # count by process name -c # show counts by syscall name -h # this usage message -v # verbose: shows PID -p PID # trace this PID only -d seconds # duration of trace -t num # show top number only command # run and trace this command eg, syscount # syscalls by process name syscount -c # syscalls by syscall name syscount -d 5 # trace for 5 seconds syscount -cp 923 # syscall names for PID 923 syscount -c ls # syscall names for "ls" See the man page and example file for more info. END exit 1 esac done shift $(( $OPTIND - 1 )) ### option logic if (( $# > 0 )); then opt_cmd=1 cmd="$@" cpus= fi if (( opt_pid + opt_duration + opt_cmd > 1 )); then echo >&2 "ERROR: Pick one of {-p PID|-n name|-d seconds|command}" exit 1 fi if (( opt_tail )); then tcmd="tail -$tnum" ttext=" Top $tnum only." fi if (( opt_duration )); then cmd="sleep $duration" echo "Tracing for $duration seconds.$ttext.." fi if (( opt_pid )); then cpus= cmd="-p $pid" echo "Tracing PID $pid.$ttext.. Ctrl-C to end." fi (( opt_cmd )) && echo "Tracing while running: \"$cmd\".$ttext.." (( opt_pid + opt_duration + opt_cmd == 0 )) && \ echo "Tracing.$ttext.. Ctrl-C to end." (( stdout_workaround )) && opts="-o /dev/stdout" ulimit -n 32768 # often needed ### execute syscall name mode if (( opt_count && ! opt_verbose )); then : ${cmd:=sleep 999999} out=$(perf stat $opts -e 'syscalls:sys_enter_*' $cpus $cmd) printf "%-17s %8s\n" "SYSCALL" "COUNT" echo "$out" | awk ' $1 && $2 ~ /syscalls:/ { sub("syscalls:sys_enter_", ""); sub(":", "") gsub(",", "") printf "%-17s %8s\n", $2, $1 }' | sort -n -k2 | $tcmd exit fi ### execute syscall name with pid mode if (( opt_count && opt_verbose )); then if (( write_workaround )); then # this list must end in write to associate the filter tp=$(perf list syscalls:sys_enter_* | awk ' $1 != "syscalls:sys_enter_write" && $1 ~ /syscalls:/ { printf "-e %s ", $1 }') tp="$tp -e syscalls:sys_enter_write" sh -c "perf record $tp --filter 'common_pid != '\$\$ $cpus $cmd" else perf record 'syscalls:sys_enter_*' $cpus $cmd # could also pipe direct to perf script fi printf "%-6s %-16s %-17s %8s\n" "PID" "COMM" "SYSCALL" "COUNT" perf script --fields pid,comm,event | awk '$1 != "#" { sub("syscalls:sys_enter_", ""); sub(":", "") a[$1 ";" $2 ";" $3]++ } END { for (k in a) { split(k, b, ";"); printf "%-6s %-16s %-17s %8d\n", b[2], b[1], b[3], a[k] } }' | sort -n -k4 | $tcmd exit fi ### execute process name mode tp="-e raw_syscalls:sys_enter" if (( write_workaround )); then sh -c "perf record $tp --filter 'common_pid != '\$\$ $cpus $cmd" else perf record $tp $cpus $cmd fi if (( opt_verbose )); then printf "%-6s %-16s %8s\n" "PID" "COMM" "COUNT" perf script --fields pid,comm | awk '$1 != "#" { a[$1 ";" $2]++ } END { for (k in a) { split(k, b, ";"); printf "%-6s %-16s %8d\n", b[2], b[1], a[k] } }' | sort -n -k3 | $tcmd else printf "%-16s %8s\n" "COMM" "COUNT" perf script --fields comm | awk '$1 != "#" { a[$1]++ } END { for (k in a) { printf "%-16s %8d\n", k, a[k] } }' | sort -n -k2 | $tcmd fi perf-tools-unstable-1.0.1~20200130+git49b8cdf/system/000077500000000000000000000000001361450357500216245ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/system/tpoint000077500000000000000000000143331361450357500230730ustar00rootroot00000000000000#!/bin/bash # # tpoint - trace a given tracepoint. Static tracing. # Written using Linux ftrace. # # This will enable a given tracepoint, print events, then disable the tracepoint # when the program ends. This is like a simple version of the "perf" command for # printing live tracepoint events only. Wildcards are currently not supported. # If this is insufficient for any reason, use the perf command instead. # # USAGE: ./tpoint [-hHsv] [-d secs] [-p pid] [-L tid] tracepoint [filter] # ./tpoint -l # # Run "tpoint -h" for full usage. # # I wrote this because I often needed a quick way to dump stack traces for a # given tracepoint. # # OVERHEADS: Relative to the frequency of traced events. You might want to # check their frequency beforehand, using perf_events. Eg: # # perf stat -e block:block_rq_issue -a sleep 5 # # To count occurrences of that tracepoint for 5 seconds. # # REQUIREMENTS: FTRACE and tracepoints, which you may already have on recent # kernel versions. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the tpoint(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 22-Jul-2014 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock; wroteflock=0 opt_duration=0; duration=; opt_pid=0; pid=; opt_tid=0; tid= opt_filter=0; filter=; opt_view=0; opt_headers=0; opt_stack=0; dmesg=2 trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: tpoint [-hHsv] [-d secs] [-p PID] [-L TID] tracepoint [filter] tpoint -l -d seconds # trace duration, and use buffers -p PID # PID to match on event -L TID # thread id to match on event -v # view format file (don't trace) -H # include column headers -l # list all tracepoints -s # show kernel stack traces -h # this usage message eg, tpoint -l | grep open # find tracepoints containing "open" tpoint syscalls:sys_enter_open # trace open() syscall entry tpoint block:block_rq_issue # trace block I/O issue tpoint -s block:block_rq_issue # show kernel stacks See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > $tdir/enable" if (( opt_filter )); then warn "echo 0 > $tdir/filter" fi (( opt_stack )) && warn "echo 0 > options/stacktrace" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } ### process options while getopts d:hHlp:L:sv opt do case $opt in d) opt_duration=1; duration=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; L) opt_tid=1; tid=$OPTARG ;; H) opt_headers=1 ;; l) opt_list=1 ;; s) opt_stack=1 ;; v) opt_view=1 ;; h|?) usage ;; esac done if (( !opt_list )); then shift $(( $OPTIND - 1 )) (( $# )) || usage tpoint=$1 shift if (( $# )); then opt_filter=1 filter=$1 fi fi ### option logic (( opt_pid + opt_filter + opt_tid > 1 )) && \ die "ERROR: use at most one of -p, -L, or filter." (( opt_duration && opt_view )) && die "ERROR: use either -d or -v." if (( opt_pid )); then # convert to filter opt_filter=1 # ftrace common_pid is thread id from user's perspective for tid in /proc/$pid/task/*; do filter="$filter || common_pid == ${tid##*/}" done filter=${filter:3} # trim leading ' || ' (four characters) fi if (( opt_tid )); then opt_filter=1 filter="common_pid == $tid" fi if (( !opt_view && !opt_list )); then if (( opt_duration )); then echo "Tracing $tpoint for $duration seconds (buffered)..." else echo "Tracing $tpoint. Ctrl-C to end." fi fi ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" ### do list tracepoints if (( opt_list )); then cd events for tp in */*; do # skip filter/enable files [[ -f $tp ]] && continue echo ${tp/\//:} done exit fi ### check tracepoints tdir=events/${tpoint/:/\/} [[ -e $tdir ]] || die "ERROR: tracepoint $tpoint not found. Exiting" ### view if (( opt_view )); then cat $tdir/format exit fi ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and begin tracing echo nop > current_tracer if (( opt_filter )); then if ! echo "$filter" > $tdir/filter; then edie "ERROR: setting filter or -p. Exiting." fi fi if (( opt_stack )); then if ! echo 1 > options/stacktrace; then edie "ERROR: enabling stack traces (-s). Exiting" fi fi if ! echo 1 >> $tdir/enable; then edie "ERROR: enabling tracepoint $tprobe. Exiting." fi ### print trace buffer warn "echo > trace" if (( opt_duration )); then sleep $duration if (( opt_headers )); then cat trace else grep -v '^#' trace fi else # trace_pipe lack headers, so fetch them from trace (( opt_headers )) && cat trace cat trace_pipe fi ### end tracing end perf-tools-unstable-1.0.1~20200130+git49b8cdf/tools/000077500000000000000000000000001361450357500214405ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/tools/reset-ftrace000077500000000000000000000062651361450357500237630ustar00rootroot00000000000000#!/bin/bash # # reset-ftrace - reset state of ftrace, disabling all tracing. # Written for Linux ftrace. # # This may only be of use to ftrace hackers who, in the process of developing # ftrace software, often get the subsystem into a partially active state, and # would like a quick way to reset state. Check the end of this script for the # actually files reset, and add more if you need. # # USAGE: ./reset-ftrace [-fhq] # # REQUIREMENTS: FTRACE CONFIG. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the reset-ftrace(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2014 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 20-Jul-2014 Brendan Gregg Created this. tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock opt_force=0; opt_quiet=0 function usage { cat <<-END >&2 USAGE: reset-ftrace [-fhq] -f # force: delete ftrace lock file -q # quiet: reset, but say nothing -h # this usage message eg, reset-ftrace # disable active ftrace session END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function die { echo >&2 "$@" exit 1 } function vecho { (( opt_quiet )) && return echo "$@" } # write to file function writefile { file=$1 string=$2 # optional if [[ ! -w $file ]]; then echo >&2 "WARNING: file $file not writable/exists. Skipping." return fi vecho "$file, before:" (( ! opt_quiet )) && cat -n $file warn "echo $string > $file" vecho "$file, after:" (( ! opt_quiet )) && cat -n $file vecho } ### process options while getopts fhq opt do case $opt in f) opt_force=1 ;; q) opt_quiet=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) ### ftrace lock if [[ -e $flock ]]; then if (( opt_force )); then warn rm $flock else echo -e >&2 "ERROR: ftrace lock ($flock) exists. It shows" \ "ftrace may be in use by PID $(cat $flock).\nDouble check" \ "to see if that PID is still active. If not, consider" \ "using -f to force a reset. Exiting." exit 1 fi fi ### reset ftrace state vecho "Reseting ftrace state..." vecho cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE?" writefile current_tracer nop writefile set_ftrace_filter writefile set_graph_function writefile set_ftrace_pid writefile events/enable 0 writefile tracing_thresh 0 writefile kprobe_events writefile tracing_on 1 vecho "Done." perf-tools-unstable-1.0.1~20200130+git49b8cdf/user/000077500000000000000000000000001361450357500212565ustar00rootroot00000000000000perf-tools-unstable-1.0.1~20200130+git49b8cdf/user/uprobe000077500000000000000000000276371361450357500225170ustar00rootroot00000000000000#!/bin/bash # # uprobe - trace a given uprobe definition. User-level dynamic tracing. # Written using Linux ftrace. Experimental. # # This will create, trace, then destroy a given uprobe definition. See # Documentation/trace/uprobetrace.txt in the Linux kernel source for the # syntax of a uprobe definition, and "uprobe -h" for examples. With this tool, # the probe alias is optional (it will default to something meaningful). # # USAGE: ./uprobe [-FhHsv] [-d secs] [-p pid] [-L tid] {-l target | # uprobe_definition [filter]} # # Run "uprobe -h" for full usage. # # WARNING: This uses dynamic tracing of user-level functions, using some # relatively new kernel code. I have seen this cause target processes to fail, # either entering endless spin loops or crashing on illegal instructions. I # believe newer kernels (post 4.0) are relatively safer, but use caution. Test # in a lab environment, and know what you are doing, before use. # # Use extreme caution with the raw address mode: eg, "p:libc:0xbf130". uprobe # does not check for instruction alignment, so tracing the wrong address (eg, # mid-way through a multi-byte instruction) will corrupt the target's memory. # Other tracers (eg, perf_events with debuginfo) check alignment. # # Also beware of widespread tracing that interferes with the operation of the # system, eg, tracing libc:malloc, which by-default will trace _all_ processes. # Test in a lab environment before use. # # I wrote this because I kept testing different custom uprobes at the command # line, and wanted a way to automate the steps. For generic user-level # tracing, use perf_events directly. # # REQUIREMENTS: FTRACE and UPROBE CONFIG, which you may already have on recent # kernel versions, file(1), ldconfig(8), objdump(1), and some version of awk. # Also, currently only executes on Linux 4.0+ (see WARNING) unless -F is used. # # From perf-tools: https://github.com/brendangregg/perf-tools # # See the uprobe(8) man page (in perf-tools) for more info. # # COPYRIGHT: Copyright (c) 2015 Brendan Gregg. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software Foundation, # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # # (http://www.gnu.org/copyleft/gpl.html) # # 27-Jul-2015 Brendan Gregg Created this. ### default variables tracing=/sys/kernel/debug/tracing flock=/var/tmp/.ftrace-lock; wroteflock=0 opt_duration=0; duration=; opt_pid=0; pid=; opt_tid=0; tid= opt_filter=0; filter=; opt_view=0; opt_headers=0; opt_stack=0; dmesg=2 debug=0; opt_force=0; opt_list=0; target= PATH=$PATH:/usr/bin:/sbin # ensure we find objdump, ldconfig trap ':' INT QUIT TERM PIPE HUP # sends execution to end tracing section function usage { cat <<-END >&2 USAGE: uprobe [-FhHsv] [-d secs] [-p PID] [-L TID] {-l target | uprobe_definition [filter]} -F # force. trace despite warnings. -d seconds # trace duration, and use buffers -l target # list functions from this executable -p PID # PID to match on events -L TID # thread id to match on events -v # view format file (don't trace) -H # include column headers -s # show user stack traces -h # this usage message Note that these examples may need modification to match your kernel version's function names and platform's register usage. eg, # trace readline() calls in all running "bash" executables: uprobe p:bash:readline # trace readline() with explicit executable path: uprobe p:/bin/bash:readline # trace the return of readline() with return value as a string: uprobe 'r:bash:readline +0(\$retval):string' # trace sleep() calls in all running libc shared libraries: uprobe p:libc:sleep # trace sleep() with register %di (x86): uprobe 'p:libc:sleep %di' # trace this address (use caution: must be instruction aligned): uprobe p:libc:0xbf130 # trace gettimeofday() for PID 1182 only: uprobe -p 1182 p:libc:gettimeofday # trace the return of fopen() only when it returns NULL: uprobe 'r:libc:fopen file=\$retval' 'file == 0' See the man page and example file for more info. END exit } function warn { if ! eval "$@"; then echo >&2 "WARNING: command failed \"$@\"" fi } function end { # disable tracing echo 2>/dev/null echo "Ending tracing..." 2>/dev/null cd $tracing warn "echo 0 > events/uprobes/$uname/enable" if (( opt_filter )); then warn "echo 0 > events/uprobes/$uname/filter" fi warn "echo -:$uname >> uprobe_events" (( opt_stack )) && warn "echo 0 > options/userstacktrace" warn "echo > trace" (( wroteflock )) && warn "rm $flock" } function die { echo >&2 "$@" exit 1 } function edie { # die with a quiet end() echo >&2 "$@" exec >/dev/null 2>&1 end exit 1 } function set_path { name=$1 path=$(which $name) if [[ "$path" == "" ]]; then path=$(ldconfig -v 2>/dev/null | awk -v lib=$name ' $1 ~ /:/ { sub(/:/, "", $1); path = $1 } { sub(/\..*/, "", $1); } $1 == lib { print path "/" $3 }') if [[ "$path" == "" ]]; then die "ERROR: segment \"$name\" ambiguous." \ "Program or library? Try a full path." fi fi if [[ ! -x $path ]]; then die "ERROR: resolved \"$name\" to \"$path\", but file missing" fi } function set_addr { path=$1 name=$2 sym=$3 [[ "$path" == "" ]] && die "ERROR: missing symbol path." [[ "$sym" == "" ]] && die "ERROR: missing symbol for $path" addr=$(objdump -tT $path | awk -v sym=$sym ' $NF == sym && $4 == ".text" { print $1; exit }') [[ "$addr" == "" ]] && die "ERROR: missing symbol \"$sym\" in $path" (( 0x$addr == 0 )) && die "ERROR: failed resolving \"$sym\" in $path." \ "Maybe it exists in a different target (eg, library)?" addr=0x$( printf "%x" 0x$addr ) # strip leading zeros type=$(file $path) if [[ "$type" != *shared?object* ]]; then # subtract the base mapping address. see Documentation/trace/ # uprobetracer.txt for background. base=$(objdump -x $path | awk ' $1 == "LOAD" && $3 ~ /^[0x]*$/ { print $5 }') [[ "$base" != 0x* ]] && die "ERROR: finding base load addr"\ "for $path." addr=$(( addr - base )) (( addr < 0 )) && die "ERROR: transposed address for $sym"\ "became negative: $addr" addr=0x$( printf "%x" $addr) fi } ### process options while getopts Fd:hHl:p:L:sv opt do case $opt in F) opt_force=1 ;; d) opt_duration=1; duration=$OPTARG ;; p) opt_pid=1; pid=$OPTARG ;; L) opt_tid=1; tid=$OPTARG ;; l) opt_list=1; target=$OPTARG ;; H) opt_headers=1 ;; s) opt_stack=1 ;; v) opt_view=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) uprobe=$1 shift if (( $# )); then opt_filter=1 filter=$1 fi ### handle listing [[ "$opt_list" == 1 && "$uprobe" != "" ]] && die "ERROR: -l takes a target only" if (( opt_list )); then if [[ "$target" != */* ]]; then set_path $target target=$path fi objdump -tT $target | awk '$4 == ".text" { print $NF }' | sort | uniq exit fi ### check kernel version ver=$(uname -r) maj=${ver%%.*} if (( opt_force == 0 && $maj < 4 )); then cat <<-END >&2 ERROR: Kernel version >= 4.0 preferred (you have $ver). Aborting. Background: uprobes were first added in 3.5. I've tested them on 3.13, and found them unsafe, as they can crash or lock up processes, which can effectively lock up the system. On 4.0, uprobes seem much safer. You can use -F to force tracing, but you've been warned. END exit fi ### check command dependencies for cmd in file objdump ldconfig awk; do which $cmd > /dev/null (( $? != 0 )) && die "ERROR: missing $cmd in \$PATH. $0 needs" \ "to use this command. Exiting." done ### option logic [[ "$uprobe" == "" ]] && usage (( opt_pid + opt_filter + opt_tid > 1 )) && \ die "ERROR: use at most one of -p, -L, or filter." (( opt_duration && opt_view )) && die "ERROR: use either -d or -v." if (( opt_pid )); then # convert to filter opt_filter=1 # ftrace common_pid is thread id from user's perspective for tid in /proc/$pid/task/*; do filter="$filter || common_pid == ${tid##*/}" done filter=${filter:3} # trim leading ' || ' (four characters) fi if (( opt_tid )); then opt_filter=1 filter="common_pid == $tid" fi if [[ "$uprobe" != p:* && "$uprobe" != r:* ]]; then echo >&2 "ERROR: invalid uprobe definition (should start with p: or r:)" usage fi # # Parse the following: # p:bash:readline # p:my bash:readline # p:bash:readline %si # r:bash:readline $ret # p:my bash:readline %si # p:bash:readline si=%si # p:my bash:readline si=%si # r:bash:readline cmd=+0($retval):string # ... and all of the above with /bin/bash instead of bash # ... and all of the above with libc:sleep instead of ... # ... and all of the above with /lib/x86_64-linux-gnu/libc.so.6:sleep ... # ... and all of the above with symbol addresses # ... and examples from USAGE message # The following code is not as complicated as it looks. # utype=${uprobe%%:*} urest="${uprobe#*:} " set -- $urest if [[ $1 == *:* ]]; then uname=; probe=$1; shift; uargs="$@" else [[ $2 != *:* ]] && die "ERROR: invalid probe. See usage (-h)." uname=$1; probe=$2; shift 2; uargs="$@" fi path=$probe; path=${path%%:*} addr=$probe; addr=${addr##*:} # set seg and fix path (eg, seg=bash, path=/bin/bash) if [[ $path == */* ]]; then seg=${path##*/} seg=${seg%%.*} else seg=$path # determine path, eg, given "zsh" or "libc" set_path $path fi # fix uname and addr (eg, uname=readline, addr=0x8db60) if [[ "$addr" == 0x* ]]; then # symbol unknown; default to seg+addr [[ "$uname" == "" ]] && uname=${seg}_$addr else [[ "$uname" == "" ]] && uname=$addr set_addr $path $seg $addr fi # construct uprobe uprobe="$utype:$uname $path:$addr" [[ "$uargs" != "" ]] && uprobe="$uprobe $uargs" if (( debug )); then echo "uname: \"$uname\", uprobe: \"$uprobe\"" fi ### check permissions cd $tracing || die "ERROR: accessing tracing. Root user? Kernel has FTRACE? debugfs mounted? (mount -t debugfs debugfs /sys/kernel/debug)" if (( !opt_view )); then if (( opt_duration )); then echo "Tracing uprobe $uname for $duration seconds (buffered)..." else echo "Tracing uprobe $uname ($uprobe). Ctrl-C to end." fi fi ### ftrace lock [[ -e $flock ]] && die "ERROR: ftrace may be in use by PID $(cat $flock) $flock" echo $$ > $flock || die "ERROR: unable to write $flock." wroteflock=1 ### setup and begin tracing echo nop > current_tracer if ! echo "$uprobe" >> uprobe_events; then echo >&2 "ERROR: adding uprobe \"$uprobe\"." if (( dmesg )); then echo >&2 "Last $dmesg dmesg entries (might contain reason):" dmesg | tail -$dmesg | sed 's/^/ /' fi edie "Exiting." fi if (( opt_view )); then cat events/uprobes/$uname/format edie "" fi if (( opt_filter )); then if ! echo "$filter" > events/uprobes/$uname/filter; then edie "ERROR: setting filter or -p. Exiting." fi fi if (( opt_stack )); then if ! echo 1 > options/userstacktrace; then edie "ERROR: enabling stack traces (-s). Exiting" fi fi if ! echo 1 > events/uprobes/$uname/enable; then edie "ERROR: enabling uprobe $uname. Exiting." fi ### print trace buffer warn "echo > trace" if (( opt_duration )); then sleep $duration if (( opt_headers )); then cat trace else grep -v '^#' trace fi else # trace_pipe lack headers, so fetch them from trace (( opt_headers )) && cat trace cat trace_pipe fi ### end tracing end