pax_global_header00006660000000000000000000000064130531411440014506gustar00rootroot0000000000000052 comment=02884a026578fec59a575942d46ea50b081adcb0 bpfcc-0.2.0+git0.02884a026/000077500000000000000000000000001305314114400144765ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/.clang-format000066400000000000000000000002311305314114400170450ustar00rootroot00000000000000--- BasedOnStyle: Google AllowShortIfStatementsOnASingleLine: false AllowShortLoopsOnASingleLine: false IndentCaseLabels: false AccessModifierOffset: -2 bpfcc-0.2.0+git0.02884a026/.dockerignore000066400000000000000000000000311305314114400171440ustar00rootroot00000000000000Dockerfile* build .*.swp bpfcc-0.2.0+git0.02884a026/.gitignore000066400000000000000000000001731305314114400164670ustar00rootroot00000000000000# Editor's files *.swp *.swo *.pyc .idea # Build artifacts /build/ cmake-build-debug debian/**/*.log obj-x86_64-linux-gnu bpfcc-0.2.0+git0.02884a026/CMakeLists.txt000066400000000000000000000053421305314114400172420ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") cmake_minimum_required(VERSION 2.8.7) project(bcc) set(CMAKE_BUILD_TYPE Release) enable_testing() include(cmake/GetGitRevisionDescription.cmake) include(cmake/version.cmake) include(GNUInstallDirs) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) if(NOT PYTHON_ONLY) find_package(BISON) find_package(FLEX) find_package(LLVM REQUIRED CONFIG) message(STATUS "Found LLVM: ${LLVM_INCLUDE_DIRS}") # clang is linked as a library, but the library path searching is # primitively supported, unlike libLLVM set(CLANG_SEARCH "/opt/local/llvm/lib;/usr/lib/llvm-3.7/lib;${LLVM_LIBRARY_DIRS}") find_library(libclangAnalysis NAMES clangAnalysis HINTS ${CLANG_SEARCH}) find_library(libclangAST NAMES clangAST HINTS ${CLANG_SEARCH}) find_library(libclangBasic NAMES clangBasic HINTS ${CLANG_SEARCH}) find_library(libclangCodeGen NAMES clangCodeGen HINTS ${CLANG_SEARCH}) find_library(libclangDriver NAMES clangDriver HINTS ${CLANG_SEARCH}) find_library(libclangEdit NAMES clangEdit HINTS ${CLANG_SEARCH}) find_library(libclangFrontend NAMES clangFrontend HINTS ${CLANG_SEARCH}) find_library(libclangLex NAMES clangLex HINTS ${CLANG_SEARCH}) find_library(libclangParse NAMES clangParse HINTS ${CLANG_SEARCH}) find_library(libclangRewrite NAMES clangRewrite HINTS ${CLANG_SEARCH}) find_library(libclangSema NAMES clangSema HINTS ${CLANG_SEARCH}) find_library(libclangSerialization NAMES clangSerialization HINTS ${CLANG_SEARCH}) if(libclangBasic STREQUAL "libclangBasic-NOTFOUND") message(FATAL_ERROR "Unable to find clang libraries") endif() FOREACH(DIR ${LLVM_INCLUDE_DIRS}) include_directories("${DIR}/../tools/clang/include") ENDFOREACH() # Set to a string path if system places kernel lib directory in # non-default location. if(NOT DEFINED BCC_KERNEL_MODULES_DIR) set(BCC_KERNEL_MODULES_DIR "/lib/modules") endif() find_package(LibElf REQUIRED) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall") # As reported in issue #735, GCC 6 has some behavioral problems when # dealing with -isystem. Hence, skip the warning optimization # altogether on that compiler. execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION) if (GCC_VERSION VERSION_LESS 6.0) # iterate over all available directories in LLVM_INCLUDE_DIRS to # generate a correctly tokenized list of parameters foreach(ONE_LLVM_INCLUDE_DIR ${LLVM_INCLUDE_DIRS}) set(CXX_ISYSTEM_DIRS "${CXX_ISYSTEM_DIRS} -isystem ${ONE_LLVM_INCLUDE_DIR}") endforeach() endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall ${CXX_ISYSTEM_DIRS}") endif() add_subdirectory(examples) add_subdirectory(man) add_subdirectory(src) add_subdirectory(tests) add_subdirectory(tools) bpfcc-0.2.0+git0.02884a026/CONTRIBUTING-SCRIPTS.md000066400000000000000000000153451305314114400200640ustar00rootroot00000000000000# Contributing bcc/eBPF scripts If you want to contribute scripts to bcc, or improve your own bcc programs, great! Please read this first. _(Written by Brendan Gregg.)_ ## Type of script bcc has 2 types of scripts, in different directories: - **/examples**: intended as short examples of bcc & eBPF code. You should focus on keeping it short, neat, and documented (code comments). A submission can just be the example code. - **/tools**: intended as production safe performance and troubleshooting tools. You should focus on it being useful, tested, low overhead, documented (incl. all caveats), and easy to use. A submission should involve 4 changes: the tool, a man page, an example file, and an addition to README.md. Follow [my lead](https://github.com/brendangregg/bcc/commit/9fa156273b395cfc5505f0fff5d6b7b1396f7daa), and see the checklist below. These will be run in mission critical environments as root, so if spending hours testing isn't for you, please submit your idea as an issue instead, or chat with us on irc. More detail for each below. ## Examples These are grouped into subdirectories (networking, tracing). Your example can either be a Python program with embedded C (eg, tracing/strlen_count.py), or separate Python and C files (eg, tracing/vfsreadlat.*). As said earlier: keep it short, neat, and documented (code comments). ## Tools A checklist for bcc tool development: 1. **Research the topic landscape**. Learn the existing tools and metrics (incl. from /proc). Determine what real world problems exist and need solving. We have too many tools and metrics as it is, we don't need more "I guess that's useful" tools, we need more "ah-hah! I couldn't do this before!" tools. Consider asking other developers about your idea. Many of us can be found in IRC, in the #iovisor channel on irc.oftc.net. There's also the mailing list (see the README.md), and github for issues. 1. **Create a known workload for testing**. This might involving writing a 10 line C program, using a micro-benchmark, or just improvising at the shell. If you don't know how to create a workload, learn! Figuring this out will provide invaluable context and details that you may have otherwise overlooked. Sometimes it's easy, and I'm able to just use dd(1) from /dev/urandom or a disk device to /dev/null. It lets me set the I/O size, count, and provides throughput statistics for cross-checking my tool output. But other times I need a micro-benchmark, or some C. 1. **Write the tool to solve the problem and no more**. Unix philosophy: do one thing and do it well. netstat doesn't have an option to dump packets, tcpdump-style. They are two different tools. 1. **Check your tool correctly measures your known workload**. If possible, run a prime number of events (eg, 23) and check that the numbers match. Try other workload variations. 1. **Use other observability tools to perform a cross-check or sanity check**. Eg, imagine you write a PCI bus tool that shows current throughput is 28 Gbytes/sec. How could you sanity test that? Well, what PCI devices are there? Disks and network cards? Measure their throughput (iostat, nicstat, sar), and check if is in the ballpark of 28 Gbytes/sec (which would include PCI frame overheads). Ideally, your numbers match. 1. **Measure the overhead of the tool**. If you are running a micro-benchmark, how much slower is it with the tool running. Is more CPU consumed? Try to determine the worst case: run the micro-benchmark so that CPU headroom is exhausted, and then run the bcc tool. Can overhead be lowered? 1. **Test again, and stress test**. You want to discover and fix all the bad things before others hit them. 1. **Consider command line options**. Should it have -p for filtering on a PID? -T for timestamps? -i for interval? See other tools for examples, and copy the style: the usage message should list example usage at the end. Remember to keep the tool doing one thing and doing it well. Also, if there's one option that seems to be the common case, perhaps it should just be the first argument and not need a switch (no -X). A special case of this is *stat tools, like iostat/vmstat/etc, where the convention is [interval [count]]. 1. **Concise, intuitive, self-explanatory output**. The default output should meet the common need concisely. Leave much less useful fields and data to be shown with options: -v for verbose, etc. Consider including a startup message that's self-explanatory, eg "Tracing block I/O. Output every 1 seconds. Ctrl-C to end.". Also, try hard to keep the output less than 80 characters wide, especially the default output of the tool. That way, the output not only fits on the smallest reasonable terminal, it also fits well in slide decks, blog posts, articles, and printed material, all of which help education and adoption. Publishers of technical books often have templates they require books to conform to: it may not be an option to shrink or narrow the font to fit your output. 1. **Use pep8 to check Python style**: pep8 --show-source --ignore=E123,E125,E126,E127,E128,E302 filename . Note that it misses some things, like consistent usage, so you'll still need to double check your script. 1. **Write an _example.txt file**. Copy the style in tools/biolatency_example.txt: start with an intro sentence, then have examples, and finish with the USAGE message. Explain everything: the first example should explain what we are seeing, even if this seems obvious. For some people it won't be obvious. Also explain why we are running the tool: what problems it's solving. It can take a long time (hours) to come up with good examples, but it's worth it. These will get copied around (eg, presentations, articles). 1. **Read your example.txt file**. Does this sound too niche or convoluted? Are you spending too much time explaining caveats? These can be hints that perhaps you should fix your tool, or abandon it! Perhaps it better belongs as an /example, and not a tool. I've abandoned many tools at this stage. 1. **Write a man page**. Either ROFF (.8), markdown (.md), or plain text (.txt): so long as it documents the important sections, particularly columns (fields) and caveats. These go under man/man8. See the other examples. Include a section on overhead, and pull no punches. It's better for end users to know about high overhead beforehand, than to discover it the hard way. Also explain caveats. Don't assume those will be obvious to tool users. 1. **Read your man page**. For ROFF: nroff -man filename. Like before, this exercise is like saying something out loud. Does it sound too niche or convoluted? Again, hints that you might need to go back and fix things, or abandon it. 1. **Spell check your documentation**. Use a spell checker like aspell to check your document quality before committing. 1. **Add an entry to README.md**. 1. If you made it this far, pull request! bpfcc-0.2.0+git0.02884a026/COPYRIGHT.txt000066400000000000000000000010411305314114400166030ustar00rootroot00000000000000Copyright 2015 PLUMgrid Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. bpfcc-0.2.0+git0.02884a026/Dockerfile.debian000066400000000000000000000012041305314114400177060ustar00rootroot00000000000000FROM debian:jessie RUN apt-key adv --keyserver ha.pool.sks-keyservers.net --recv 15CF4D18AF4F7421 && \ echo "deb http://llvm.org/apt/jessie/ llvm-toolchain-jessie-3.8 main" > /etc/apt/sources.list.d/llvm.list && \ apt-get update && \ apt-get install -y --no-install-recommends build-essential fakeroot bison cmake debhelper devscripts flex git libedit-dev python zlib1g-dev libllvm3.8 llvm-3.8-dev libclang-3.8-dev libelf-dev luajit libluajit-5.1-dev && \ mkdir -p /usr/share/llvm-3.8 && \ ln -s /usr/lib/llvm-3.8/share/llvm/cmake /usr/share/llvm-3.8/cmake COPY ./ /root/bcc WORKDIR /root/bcc RUN ./scripts/build-deb.sh bpfcc-0.2.0+git0.02884a026/Dockerfile.ubuntu000066400000000000000000000014031305314114400200070ustar00rootroot00000000000000# File to be used for building an Ubuntu .deb FROM ubuntu:trusty MAINTAINER Brenden Blanco RUN apt-get -y install wget RUN printf "deb http://llvm.org/apt/trusty/ llvm-toolchain-trusty main\ndeb-src http://llvm.org/apt/trusty/ llvm-toolchain-trusty main\n" > /etc/apt/sources.list.d/llvm.list RUN wget -q -O - http://llvm.org/apt/llvm-snapshot.gpg.key | apt-key add - RUN apt-get -y update RUN apt-get -y install bison build-essential cmake debhelper devscripts flex git libedit-dev python zlib1g-dev RUN apt-get -y install libllvm3.8 llvm-3.8-dev libclang-3.8-dev RUN mkdir -p /root/bcc/build COPY ./ /root/bcc/ WORKDIR /root RUN tar zcf bcc_0.1.1.orig.tar.gz bcc/ WORKDIR /root/bcc RUN DEB_BUILD_OPTIONS="nocheck parallel=4" debuild -us -uc bpfcc-0.2.0+git0.02884a026/FAQ.txt000066400000000000000000000031331305314114400156460ustar00rootroot00000000000000Q: while running 'make test' I'm seeing: 'ImportError: No module named pyroute2' A: Install pyroute2: git clone https://github.com/svinota/pyroute2.git cd pyroute2; sudo make install Q: hello_world.py fails with: OSError: libbcc.so: cannot open shared object file: No such file or directory A: make sure to 'make install' and add the directory where libbcc.so was installed into your LD_LIBRARY_PATH export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH Q: hello_world.py fails with: ImportError: No module named bpf A: checkout "sudo make install" output to find out bpf package installation site, add it to the PYTHONPATH env variable before running the program. sudo bash -c 'PYTHONPATH=/usr/lib/python2.7/site-packages python examples/hello_world.py' Q: hello_world.py still fails with: bpf: Operation not permitted Exception: Failed to load BPF program hello A: sudo Q: How do I fulfill the Linux kernel version requirement? A: You need to obtain a recent version of the Linux source code (please look at the README for the exact version), enable the configuration options listed in the README file, install the image, modules and headers, update your bootloader and reboot into the new kernel. If you want to compile your own kernel, you can fetch the sources from kernel.org or through your Linux distribution. To install, you need all of the following: make install make modules_install make headers_install INSTALL_HDR_PATH=/usr/local/ Q: hello_world.py fails with: ImportError: No module named past.builtins A: sudo pip install future bpfcc-0.2.0+git0.02884a026/INSTALL.md000066400000000000000000000231011305314114400161230ustar00rootroot00000000000000# Installing BCC * [Kernel Configuration](#kernel-configuration) * [Packages](#packages) - [Ubuntu](#ubuntu-xenial---binary) - [Fedora](#fedora---binary) - [Arch](#arch---aur) - [Gentoo](#gentoo---portage) * [Source](#source) - [Debian](#debian---source) - [Ubuntu](#ubuntu---source) - [Fedora](#fedora---source) * [Older Instructions](#older-instructions) ## Kernel Configuration In general, to use these features, a Linux kernel version 4.1 or newer is required. In addition, the kernel should have been compiled with the following flags set: ``` CONFIG_BPF=y CONFIG_BPF_SYSCALL=y # [optional, for tc filters] CONFIG_NET_CLS_BPF=m # [optional, for tc actions] CONFIG_NET_ACT_BPF=m CONFIG_BPF_JIT=y CONFIG_HAVE_BPF_JIT=y # [optional, for kprobes] CONFIG_BPF_EVENTS=y ``` There are a few optional kernel flags needed for running bcc networking examples on vanilla kernel: ``` CONFIG_NET_SCH_SFQ=m CONFIG_NET_ACT_POLICE=m CONFIG_NET_ACT_GACT=m CONFIG_DUMMY=m CONFIG_VXLAN=m ``` Kernel compile flags can usually be checked by looking at `/proc/config.gz` or `/boot/config-`. # Packages ## Ubuntu Xenial - Binary Only the nightly packages are built for Ubuntu 16.04, but the steps are very straightforward. No need to upgrade the kernel or compile from source! ```bash echo "deb [trusted=yes] https://repo.iovisor.org/apt/xenial xenial-nightly main" | sudo tee /etc/apt/sources.list.d/iovisor.list sudo apt-get update sudo apt-get install bcc-tools ``` ## Ubuntu Trusty - Binary **Kernel** Install a 4.3+ kernel from http://kernel.ubuntu.com/~kernel-ppa/mainline, for example: ```bash VER=4.5.1-040501 PREFIX=http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.5.1-wily/ REL=201604121331 wget ${PREFIX}/linux-headers-${VER}-generic_${VER}.${REL}_amd64.deb wget ${PREFIX}/linux-headers-${VER}_${VER}.${REL}_all.deb wget ${PREFIX}/linux-image-${VER}-generic_${VER}.${REL}_amd64.deb sudo dpkg -i linux-*${VER}.${REL}*.deb # reboot ``` Update PREFIX to the latest date, and you can browse the files in the PREFIX url to find the REL number. **Signed Packages** Tagged and signed bcc binary packages are built for Ubuntu Trusty (14.04) and hosted at https://repo.iovisor.org/apt/. To install: ```bash sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys D4284CDD echo "deb https://repo.iovisor.org/apt trusty main" | sudo tee /etc/apt/sources.list.d/iovisor.list sudo apt-get update sudo apt-get install binutils bcc bcc-tools libbcc-examples python-bcc ``` **Nightly Packages** ```bash echo "deb [trusted=yes] https://repo.iovisor.org/apt/trusty trusty-nightly main" | sudo tee /etc/apt/sources.list.d/iovisor.list sudo apt-get update sudo apt-get install bcc-tools libbcc-examples ``` Test it: ``` sudo python /usr/share/bcc/examples/hello_world.py sudo python /usr/share/bcc/examples/tracing/task_switch.py ``` (Optional) Install pyroute2 for additional networking features ```bash git clone https://github.com/svinota/pyroute2 cd pyroute2; sudo make install sudo python /usr/share/bcc/examples/networking/simple_tc.py ``` ## Fedora - Binary Install a 4.2+ kernel from http://alt.fedoraproject.org/pub/alt/rawhide-kernel-nodebug, for example: ```bash sudo dnf config-manager --add-repo=http://alt.fedoraproject.org/pub/alt/rawhide-kernel-nodebug/fedora-rawhide-kernel-nodebug.repo sudo dnf update # reboot ``` Nightly bcc binary packages are built for Fedora 23 and 24, hosted at `https://repo.iovisor.org/yum/nightly/f{23,24}`. To install (change 'f23' to 'f24' for rawhide): ```bash echo -e '[iovisor]\nbaseurl=https://repo.iovisor.org/yum/nightly/f23/$basearch\nenabled=1\ngpgcheck=0' | sudo tee /etc/yum.repos.d/iovisor.repo sudo dnf install bcc-tools ``` ## Arch - AUR Upgrade the kernel to minimum 4.3.1-1 first; the ```CONFIG_BPF_SYSCALL=y``` configuration was not added until [this kernel release](https://bugs.archlinux.org/task/47008). Install these packages using any AUR helper such as [pacaur](https://aur.archlinux.org/packages/pacaur), [yaourt](https://aur.archlinux.org/packages/yaourt), [cower](https://aur.archlinux.org/packages/cower), etc.: ``` bcc bcc-tools python-bcc python2-bcc ``` All build and install dependencies are listed [in the PKGBUILD](https://aur.archlinux.org/cgit/aur.git/tree/PKGBUILD?h=bcc) and should install automatically. ## Gentoo - Portage First of all, upgrade the kernel of your choice to a recent version. For example: ``` emerge sys-kernel/gentoo-sources ``` Then, configure the kernel enabling the features you need. Please consider the following as a starting point: ``` CONFIG_BPF=y CONFIG_BPF_SYSCALL=y CONFIG_NET_CLS_BPF=m CONFIG_NET_ACT_BPF=m CONFIG_BPF_JIT=y CONFIG_BPF_EVENTS=y ``` Finally, you can install bcc with: ``` emerge dev-util/bcc ``` The appropriate dependencies (e.g., ```clang```, ```llvm``` with BPF backend) will be pulled automatically. # Source ## Debian - Source ### Jessie #### Repositories The automated tests that run as part of the build process require `netperf`. Since netperf's license is not "certified" as an open-source license, it is in Debian's `non-free` repository. `/etc/apt/sources.list` should include the `non-free` repository and look something like this: ``` deb http://httpredir.debian.org/debian/ jessie main non-free deb-src http://httpredir.debian.org/debian/ jessie main non-free deb http://security.debian.org/ jessie/updates main non-free deb-src http://security.debian.org/ jessie/updates main non-free # wheezy-updates, previously known as 'volatile' deb http://ftp.us.debian.org/debian/ jessie-updates main non-free deb-src http://ftp.us.debian.org/debian/ jessie-updates main non-free ``` BCC also requires kernel version 4.1 or above. Those kernels are available in the `jessie-backports` repository. To add the `jessie-backports` repository to your system create the file `/etc/apt/sources.list.d/jessie-backports.list` with the following contents: ``` deb http://httpredir.debian.org/debian jessie-backports main deb-src http://httpredir.debian.org/debian jessie-backports main ``` #### Install Build Dependencies Note, check for the latest `linux-image-4.x` version in `jessie-backports` before proceeding. Also, have a look at the `Build-Depends:` section in `debian/control` file. ``` # Before you begin apt-get update # Update kernel and linux-base package apt-get -t jessie-backports install linux-base linux-image-4.8.0-0.bpo.2-amd64 # BCC build dependencies: apt-get install debhelper cmake libllvm3.8 llvm-3.8-dev libclang-3.8-dev \ libelf-dev bison flex libedit-dev clang-format-3.8 python python-netaddr \ python-pyroute2 luajit libluajit-5.1-dev arping iperf netperf ethtool \ devscripts zlib1g-dev ``` #### Sudo Adding eBPF probes to the kernel and removing probes from it requires root privileges. For the build to complete successfully, you must build from an account with `sudo` access. (You may also build as root, but it is bad style.) `/etc/sudoers` or `/etc/sudoers.d/build-user` should contain ``` build-user ALL = (ALL) NOPASSWD: ALL ``` or ``` build-user ALL = (ALL) ALL ``` If using the latter sudoers configuration, please keep an eye out for sudo's password prompt while the build is running. #### Build ``` cd git clone https://github.com/iovisor/bcc.git cd bcc debuild -b -uc -us ``` #### Install ``` cd .. sudo dpkg -i *bcc*.deb ``` ## Ubuntu - Source To build the toolchain from source, one needs: * LLVM 3.7.1 or newer, compiled with BPF support (default=on) * Clang, built from the same tree as LLVM * cmake, gcc (>=4.7), flex, bison * LuaJIT, if you want Lua support ### Install build dependencies ``` # Trusty and older VER=trusty echo "deb http://llvm.org/apt/$VER/ llvm-toolchain-$VER-3.7 main deb-src http://llvm.org/apt/$VER/ llvm-toolchain-$VER-3.7 main" | \ sudo tee /etc/apt/sources.list.d/llvm.list wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key | sudo apt-key add - sudo apt-get update # All versions sudo apt-get -y install bison build-essential cmake flex git libedit-dev \ libllvm3.7 llvm-3.7-dev libclang-3.7-dev python zlib1g-dev libelf-dev # For Lua support sudo apt-get -y install luajit luajit-5.1-dev ``` ### Install and compile BCC ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build cmake .. -DCMAKE_INSTALL_PREFIX=/usr make sudo make install ``` ## Fedora - Source ### Install build dependencies ``` sudo dnf install -y bison cmake ethtool flex git iperf libstdc++-static \ python-netaddr python-pip gcc gcc-c++ make zlib-devel \ elfutils-libelf-devel sudo dnf install -y luajit luajit-devel # for Lua support sudo dnf install -y \ http://pkgs.repoforge.org/netperf/netperf-2.6.0-1.el6.rf.x86_64.rpm sudo pip install pyroute2 ``` ### Install binary clang ``` # FC22 wget http://llvm.org/releases/3.7.1/clang+llvm-3.7.1-x86_64-fedora22.tar.xz sudo tar xf clang+llvm-3.7.1-x86_64-fedora22.tar.xz -C /usr/local --strip 1 # FC23 wget http://llvm.org/releases/3.9.0/clang+llvm-3.9.0-x86_64-fedora23.tar.xz sudo tar xf clang+llvm-3.9.0-x86_64-fedora23.tar.xz -C /usr/local --strip 1 # FC24 and FC25 sudo dnf install -y clang clang-devel llvm llvm-devel llvm-static ncurses-devel ``` ### Install and compile BCC ``` git clone https://github.com/iovisor/bcc.git mkdir bcc/build; cd bcc/build cmake .. -DCMAKE_INSTALL_PREFIX=/usr make sudo make install ``` # Older Instructions ## Build LLVM and Clang development libs ``` git clone http://llvm.org/git/llvm.git cd llvm/tools; git clone http://llvm.org/git/clang.git cd ..; mkdir -p build/install; cd build cmake -G "Unix Makefiles" -DLLVM_TARGETS_TO_BUILD="BPF;X86" \ -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$PWD/install .. make make install export PATH=$PWD/install/bin:$PATH ``` bpfcc-0.2.0+git0.02884a026/LICENSE.txt000066400000000000000000000261351305314114400163300ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {yyyy} {name of copyright owner} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. bpfcc-0.2.0+git0.02884a026/QUICKSTART.md000066400000000000000000000011131305314114400165060ustar00rootroot00000000000000# Quick Start Guide A Docker container is provided for user to try out [bcc](https://github.com/iovisor/bcc). From your host shell: ```bash docker run -it --rm \ --privileged \ -v /lib/modules:/lib/modules:ro \ -v /usr/src:/usr/src:ro \ -v /etc/localtime:/etc/localtime:ro \ --workdir /usr/share/bcc/tools \ zlim/bcc ``` Now, from the container shell, you can try the various pre-installed bcc tools. For examples, please refer to the [tutorial](docs/tutorial.md#1-general-performance). If you wish to install bcc on your host, please refer to [INSTALL.md](INSTALL.md). bpfcc-0.2.0+git0.02884a026/README.md000066400000000000000000000430461305314114400157640ustar00rootroot00000000000000![BCC Logo](images/logo2.png) # BPF Compiler Collection (BCC) BCC is a toolkit for creating efficient kernel tracing and manipulation programs, and includes several useful tools and examples. It makes use of extended BPF (Berkeley Packet Filters), formally known as eBPF, a new feature that was first added to Linux 3.15. Much of what BCC uses requires Linux 4.1 and above. eBPF was [described by](https://lkml.org/lkml/2015/4/14/232) Ingo Molnár as: > One of the more interesting features in this cycle is the ability to attach eBPF programs (user-defined, sandboxed bytecode executed by the kernel) to kprobes. This allows user-defined instrumentation on a live kernel image that can never crash, hang or interfere with the kernel negatively. BCC makes BPF programs easier to write, with kernel instrumentation in C (and includes a C wrapper around LLVM), and front-ends in Python and lua. It is suited for many tasks, including performance analysis and network traffic control. ## Screenshot This example traces a disk I/O kernel function, and populates an in-kernel power-of-2 histogram of the I/O size. For efficiency, only the histogram summary is returned to user-level. ```Shell # ./bitehist.py Tracing... Hit Ctrl-C to end. ^C kbytes : count distribution 0 -> 1 : 3 | | 2 -> 3 : 0 | | 4 -> 7 : 211 |********** | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 800 |**************************************| ``` The above output shows a bimodal distribution, where the largest mode of 800 I/O was between 128 and 255 Kbytes in size. See the source: [bitehist.py](examples/tracing/bitehist.py). What this traces, what this stores, and how the data is presented, can be entirely customized. This shows only some of many possible capabilities. ## Installing See [INSTALL.md](INSTALL.md) for installation steps on your platform. ## FAQ See [FAQ.txt](FAQ.txt) for the most common troubleshoot questions. ## Contents Some of these are single files that contain both C and Python, others have a pair of .c and .py files, and some are directories of files. ### Tracing #### Examples: - examples/tracing/[bitehist.py](examples/tracing/bitehist.py): Block I/O size histogram. [Examples](examples/tracing/bitehist_example.txt). - examples/tracing/[disksnoop.py](examples/tracing/disksnoop.py): Trace block device I/O latency. [Examples](examples/tracing/disksnoop_example.txt). - examples/[hello_world.py](examples/hello_world.py): Prints "Hello, World!" for new processes. - examples/tracing/[mysqld_query.py](examples/tracing/mysqld_query.py): Trace MySQL server queries using USDT probes. [Examples](examples/tracing/mysqld_query_example.txt). - examples/tracing/[nodejs_http_server.py](examples/tracing/nodejs_http_server.py): Trace Node.js HTTP server requests using USDT probes. [Examples](examples/tracing/nodejs_http_server_example.txt). - examples/tracing/[task_switch.py](examples/tracing/task_switch.py): Count task switches with from and to PIDs. - examples/tracing/[tcpv4connect.py](examples/tracing/tcpv4connect.py): Trace TCP IPv4 active connections. [Examples](examples/tracing/tcpv4connect_example.txt). - examples/tracing/[trace_fields.py](examples/tracing/trace_fields.py): Simple example of printing fields from traced events. - examples/tracing/[urandomread.py](examples/tracing/urandomread.py): A kernel tracepoint example, which traces random:urandom_read. [Examples](examples/tracing/urandomread_example.txt). - examples/tracing/[vfsreadlat.py](examples/tracing/vfsreadlat.py) examples/tracing/[vfsreadlat.c](examples/tracing/vfsreadlat.c): VFS read latency distribution. [Examples](examples/tracing/vfsreadlat_example.txt). #### Tools:
- tools/[argdist](tools/argdist.py): Display function parameter values as a histogram or frequency count. [Examples](tools/argdist_example.txt). - tools/[bashreadline](tools/bashreadline.py): Print entered bash commands system wide. [Examples](tools/bashreadline_example.txt). - tools/[biolatency](tools/biolatency.py): Summarize block device I/O latency as a histogram. [Examples](tools/biolatency_example.txt). - tools/[biotop](tools/biotop.py): Top for disks: Summarize block device I/O by process. [Examples](tools/biotop_example.txt). - tools/[biosnoop](tools/biosnoop.py): Trace block device I/O with PID and latency. [Examples](tools/biosnoop_example.txt). - tools/[bitesize](tools/bitesize.py): Show per process I/O size histogram. [Examples](tools/bitesize_example.txt). - tools/[btrfsdist](tools/btrfsdist.py): Summarize btrfs operation latency distribution as a histogram. [Examples](tools/btrfsdist_example.txt). - tools/[btrfsslower](tools/btrfsslower.py): Trace slow btrfs operations. [Examples](tools/btrfsslower_example.txt). - tools/[capable](tools/capable.py): Trace security capability checks. [Examples](tools/capable_example.txt). - tools/[cachestat](tools/cachestat.py): Trace page cache hit/miss ratio. [Examples](tools/cachestat_example.txt). - tools/[cachetop](tools/cachetop.py): Trace page cache hit/miss ratio by processes. [Examples](tools/cachetop_example.txt). - tools/[cpudist](tools/cpudist.py): Summarize on- and off-CPU time per task as a histogram. [Examples](tools/cpudist_example.txt) - tools/[cpuunclaimed](tools/cpuunclaimed.py): Sample CPU run queues and calculate unclaimed idle CPU. [Examples](tools/cpuunclaimed_example.txt) - tools/[dbslower](tools/dbslower.py): Trace MySQL/PostgreSQL queries slower than a threshold. [Examples](tools/dbslower_example.txt). - tools/[dbstat](tools/dbstat.py): Summarize MySQL/PostgreSQL query latency as a histogram. [Examples](tools/dbstat_example.txt). - tools/[dcsnoop](tools/dcsnoop.py): Trace directory entry cache (dcache) lookups. [Examples](tools/dcsnoop_example.txt). - tools/[dcstat](tools/dcstat.py): Directory entry cache (dcache) stats. [Examples](tools/dcstat_example.txt). - tools/[deadlock_detector](tools/deadlock_detector.py): Detect potential deadlocks on a running process. [Examples](tools/deadlock_detector_example.txt). - tools/[execsnoop](tools/execsnoop.py): Trace new processes via exec() syscalls. [Examples](tools/execsnoop_example.txt). - tools/[ext4dist](tools/ext4dist.py): Summarize ext4 operation latency distribution as a histogram. [Examples](tools/ext4dist_example.txt). - tools/[ext4slower](tools/ext4slower.py): Trace slow ext4 operations. [Examples](tools/ext4slower_example.txt). - tools/[filelife](tools/filelife.py): Trace the lifespan of short-lived files. [Examples](tools/filelife_example.txt). - tools/[fileslower](tools/fileslower.py): Trace slow synchronous file reads and writes. [Examples](tools/fileslower_example.txt). - tools/[filetop](tools/filetop.py): File reads and writes by filename and process. Top for files. [Examples](tools/filetop_example.txt). - tools/[funccount](tools/funccount.py): Count kernel function calls. [Examples](tools/funccount_example.txt). - tools/[funclatency](tools/funclatency.py): Time functions and show their latency distribution. [Examples](tools/funclatency_example.txt). - tools/[gethostlatency](tools/gethostlatency.py): Show latency for getaddrinfo/gethostbyname[2] calls. [Examples](tools/gethostlatency_example.txt). - tools/[hardirqs](tools/hardirqs.py): Measure hard IRQ (hard interrupt) event time. [Examples](tools/hardirqs_example.txt). - tools/[killsnoop](tools/killsnoop.py): Trace signals issued by the kill() syscall. [Examples](tools/killsnoop_example.txt). - tools/[llcstat](tools/llcstat.py): Summarize CPU cache references and misses by process. [Examples](tools/llcstat_example.txt). - tools/[mdflush](tools/mdflush.py): Trace md flush events. [Examples](tools/mdflush_example.txt). - tools/[mysqld_qslower](tools/mysqld_qslower.py): Trace MySQL server queries slower than a threshold. [Examples](tools/mysqld_qslower_example.txt). - tools/[memleak](tools/memleak.py): Display outstanding memory allocations to find memory leaks. [Examples](tools/memleak_example.txt). - tools/[offcputime](tools/offcputime.py): Summarize off-CPU time by kernel stack trace. [Examples](tools/offcputime_example.txt). - tools/[offwaketime](tools/offwaketime.py): Summarize blocked time by kernel off-CPU stack and waker stack. [Examples](tools/offwaketime_example.txt). - tools/[oomkill](tools/oomkill.py): Trace the out-of-memory (OOM) killer. [Examples](tools/oomkill_example.txt). - tools/[opensnoop](tools/opensnoop.py): Trace open() syscalls. [Examples](tools/opensnoop_example.txt). - tools/[pidpersec](tools/pidpersec.py): Count new processes (via fork). [Examples](tools/pidpersec_example.txt). - tools/[profile](tools/profile.py): Profile CPU usage by sampling stack traces at a timed interval. [Examples](tools/profile_example.txt). - tools/[reset-trace](tools/reset-trace.sh): Reset the state of tracing. Maintenance tool only. [Examples](tools/reset-trace_example.txt). - tools/[runqlat](tools/runqlat.py): Run queue (scheduler) latency as a histogram. [Examples](tools/runqlat_example.txt). - tools/[runqlen](tools/runqlen.py): Run queue length as a histogram. [Examples](tools/runqlen_example.txt). - tools/[slabratetop](tools/slabratetop.py): Kernel SLAB/SLUB memory cache allocation rate top. [Examples](tools/slabratetop_example.txt). - tools/[softirqs](tools/softirqs.py): Measure soft IRQ (soft interrupt) event time. [Examples](tools/softirqs_example.txt). - tools/[solisten](tools/solisten.py): Trace TCP socket listen. [Examples](tools/solisten_example.txt). - tools/[sslsniff](tools/sslsniff.py): Sniff OpenSSL written and readed data. [Examples](tools/sslsniff_example.txt). - tools/[stackcount](tools/stackcount.py): Count kernel function calls and their stack traces. [Examples](tools/stackcount_example.txt). - tools/[stacksnoop](tools/stacksnoop.py): Trace a kernel function and print all kernel stack traces. [Examples](tools/stacksnoop_example.txt). - tools/[statsnoop](tools/statsnoop.py): Trace stat() syscalls. [Examples](tools/statsnoop_example.txt). - tools/[syncsnoop](tools/syncsnoop.py): Trace sync() syscall. [Examples](tools/syncsnoop_example.txt). - tools/[syscount](tools/syscount.py): Summarize syscall counts and latencies. [Examples](tools/syscount_example.txt). - tools/[tcpaccept](tools/tcpaccept.py): Trace TCP passive connections (accept()). [Examples](tools/tcpaccept_example.txt). - tools/[tcpconnect](tools/tcpconnect.py): Trace TCP active connections (connect()). [Examples](tools/tcpconnect_example.txt). - tools/[tcpconnlat](tools/tcpconnlat.py): Trace TCP active connection latency (connect()). [Examples](tools/tcpconnlat_example.txt). - tools/[tcplife](tools/tcplife.py): Trace TCP sessions and summarize lifespan. [Examples](tools/tcplife_example.txt). - tools/[tcpretrans](tools/tcpretrans.py): Trace TCP retransmits and TLPs. [Examples](tools/tcpretrans_example.txt). - tools/[tcptop](tools/tcptop.py): Summarize TCP send/recv throughput by host. Top for TCP. [Examples](tools/tcptop_example.txt). - tools/[tplist](tools/tplist.py): Display kernel tracepoints or USDT probes and their formats. [Examples](tools/tplist_example.txt). - tools/[trace](tools/trace.py): Trace arbitrary functions, with filters. [Examples](tools/trace_example.txt). - tools/[ttysnoop](tools/ttysnoop.py): Watch live output from a tty or pts device. [Examples](tools/ttysnoop_example.txt). - tools/[ucalls](tools/ucalls.py): Summarize method calls or Linux syscalls in high-level languages. [Examples](tools/ucalls_example.txt). - tools/[uflow](tools/uflow.py): Print a method flow graph in high-level languages. [Examples](tools/uflow_example.txt). - tools/[ugc](tools/ugc.py): Trace garbage collection events in high-level languages. [Examples](tools/ugc_example.txt). - tools/[uobjnew](tools/uobjnew.py): Summarize object allocation events by object type and number of bytes allocated. [Examples](tools/uobjnew_example.txt). - tools/[ustat](tools/ustat.py): Collect events such as GCs, thread creations, object allocations, exceptions and more in high-level languages. [Examples](tools/ustat_example.txt). - tools/[uthreads](tools/uthreads.py): Trace thread creation events in Java and raw pthreads. [Examples](tools/uthreads_example.txt). - tools/[vfscount](tools/vfscount.py) tools/[vfscount.c](tools/vfscount.c): Count VFS calls. [Examples](tools/vfscount_example.txt). - tools/[vfsstat](tools/vfsstat.py) tools/[vfsstat.c](tools/vfsstat.c): Count some VFS calls, with column output. [Examples](tools/vfsstat_example.txt). - tools/[wakeuptime](tools/wakeuptime.py): Summarize sleep to wakeup time by waker kernel stack. [Examples](tools/wakeuptime_example.txt). - tools/[xfsdist](tools/xfsdist.py): Summarize XFS operation latency distribution as a histogram. [Examples](tools/xfsdist_example.txt). - tools/[xfsslower](tools/xfsslower.py): Trace slow XFS operations. [Examples](tools/xfsslower_example.txt). - tools/[zfsdist](tools/zfsdist.py): Summarize ZFS operation latency distribution as a histogram. [Examples](tools/zfsdist_example.txt). - tools/[zfsslower](tools/zfsslower.py): Trace slow ZFS operations. [Examples](tools/zfsslower_example.txt). ### Networking Examples: - examples/networking/[distributed_bridge/](examples/networking/distributed_bridge): Distributed bridge example. - examples/networking/[http_filter/](examples/networking/http_filter): Simple HTTP filter example. - examples/networking/[simple_tc.py](examples/networking/simple_tc.py): Simple traffic control example. - examples/networking/[simulation.py](examples/networking/simulation.py): Simulation helper. - examples/networking/neighbor_sharing/[tc_neighbor_sharing.py](examples/networking/neighbor_sharing/tc_neighbor_sharing.py) examples/networking/neighbor_sharing/[tc_neighbor_sharing.c](examples/networking/neighbor_sharing/tc_neighbor_sharing.c): Per-IP classification and rate limiting. - examples/networking/[tunnel_monitor/](examples/networking/tunnel_monitor): Efficiently monitor traffic flows. [Example video](https://www.youtube.com/watch?v=yYy3Cwce02k). - examples/networking/vlan_learning/[vlan_learning.py](examples/networking/vlan_learning/vlan_learning.py) examples/[vlan_learning.c](examples/networking/vlan_learning/vlan_learning.c): Demux Ethernet traffic into worker veth+namespaces. ## Motivation BPF guarantees that the programs loaded into the kernel cannot crash, and cannot run forever, but yet BPF is general purpose enough to perform many arbitrary types of computation. Currently, it is possible to write a program in C that will compile into a valid BPF program, yet it is vastly easier to write a C program that will compile into invalid BPF (C is like that). The user won't know until trying to run the program whether it was valid or not. With a BPF-specific frontend, one should be able to write in a language and receive feedback from the compiler on the validity as it pertains to a BPF backend. This toolkit aims to provide a frontend that can only create valid BPF programs while still harnessing its full flexibility. Furthermore, current integrations with BPF have a kludgy workflow, sometimes involving compiling directly in a linux kernel source tree. This toolchain aims to minimize the time that a developer spends getting BPF compiled, and instead focus on the applications that can be written and the problems that can be solved with BPF. The features of this toolkit include: * End-to-end BPF workflow in a shared library * A modified C language for BPF backends * Integration with llvm-bpf backend for JIT * Dynamic (un)loading of JITed programs * Support for BPF kernel hooks: socket filters, tc classifiers, tc actions, and kprobes * Bindings for Python * Examples for socket filters, tc classifiers, and kprobes * Self-contained tools for tracing a running system In the future, more bindings besides python will likely be supported. Feel free to add support for the language of your choice and send a pull request! ## Tutorials - [docs/tutorial.md](docs/tutorial.md): Using bcc tools to solve performance, troubleshooting, and networking issues. - [docs/tutorial_bcc_python_developer.md](docs/tutorial_bcc_python_developer.md): Developing new bcc programs using the Python interface. - [docs/reference_guide.md](docs/reference_guide.md): Reference guide to the bcc and bcc/BPF APIs. ### Networking At Red Hat Summit 2015, BCC was presented as part of a [session on BPF](http://www.devnation.org/#7784f1f7513e8542e4db519e79ff5eec). A multi-host vxlan environment is simulated and a BPF program used to monitor one of the physical interfaces. The BPF program keeps statistics on the inner and outer IP addresses traversing the interface, and the userspace component turns those statistics into a graph showing the traffic distribution at multiple granularities. See the code [here](examples/networking/tunnel_monitor). [![Screenshot](http://img.youtube.com/vi/yYy3Cwce02k/0.jpg)](https://youtu.be/yYy3Cwce02k) ## Contributing Already pumped up to commit some code? Here are some resources to join the discussions in the [IOVisor](https://www.iovisor.org/) community and see what you want to work on. * _Mailing List:_ http://lists.iovisor.org/mailman/listinfo/iovisor-dev * _IRC:_ #iovisor at irc.oftc.net * _IRC Logs:_ https://scrollback.io/iovisor/all * _BCC Issue Tracker:_ [Github Issues](https://github.com/iovisor/bcc/issues) * _A guide for contributing scripts:_ [CONTRIBUTING-SCRIPTS.md](CONTRIBUTING-SCRIPTS.md) bpfcc-0.2.0+git0.02884a026/SPECS/000077500000000000000000000000001305314114400153535ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/SPECS/Dockerfile.fedora000066400000000000000000000014441305314114400206070ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") FROM fedora:rawhide MAINTAINER Brenden Blanco RUN dnf -y install bison cmake flex gcc gcc-c++ git libxml2-devel make python2-devel rpm-build wget zlib-devel WORKDIR /root RUN wget http://llvm.org/releases/3.7.1/{cfe,llvm}-3.7.1.src.tar.xz RUN tar -xf llvm-3.7.1.src.tar.xz && mkdir llvm-3.7.1.src/tools/clang && tar -xf cfe-3.7.1.src.tar.xz -C llvm-3.7.1.src/tools/clang --strip 1 && mkdir llvm-3.7.1.src/build RUN cd llvm-3.7.1.src/build && cmake .. -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD="X86;BPF" -DCMAKE_INSTALL_PREFIX=/usr RUN cd llvm-3.7.1.src/build && make -j8 COPY . bcc WORKDIR /root/bcc RUN PATH=/root/llvm-3.7.1.src/build/bin:$PATH ./scripts/build-rpm.sh bpfcc-0.2.0+git0.02884a026/SPECS/bcc+clang.spec000066400000000000000000000052411305314114400200400ustar00rootroot00000000000000%define debug_package %{nil} %define llvmver 3.7.1 Name: bcc Version: @REVISION@ Release: @GIT_REV_COUNT@ Summary: BPF Compiler Collection (BCC) Group: Development/Languages License: ASL 2.0 URL: https://github.com/iovisor/bcc Source0: https://github.com/iovisor/bcc/archive/v%{version}.tar.gz Source1: http://llvm.org/releases/%{llvmver}/llvm-%{llvmver}.src.tar.xz Source2: http://llvm.org/releases/%{llvmver}/cfe-%{llvmver}.src.tar.xz BuildArch: x86_64 BuildRequires: bison, cmake >= 2.8.7, flex, gcc, gcc-c++, libxml2-devel, python2-devel, elfutils-libelf-devel-static %description Python bindings for BPF Compiler Collection (BCC). Control a BPF program from userspace. %prep %setup -T -b 1 -n llvm-%{llvmver}.src mkdir tools/clang tar -xvvJf %{_sourcedir}/cfe-%{llvmver}.src.tar.xz -C tools/clang --strip 1 %setup -D -n bcc %build export LD_LIBRARY_PATH="%{_builddir}/usr/lib64" export PATH="%{_builddir}/usr/bin":$PATH # build llvm pushd %{_builddir}/llvm-%{llvmver}.src mkdir build cd build cmake .. -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD="X86;BPF" -DCMAKE_INSTALL_PREFIX=/usr make %{?_smp_mflags} make install DESTDIR="%{_builddir}" popd mkdir build pushd build cmake .. -DREVISION_LAST=%{version} -DREVISION=%{version} -DCMAKE_INSTALL_PREFIX=/usr make %{?_smp_mflags} popd %install pushd build make install/strip DESTDIR=%{buildroot} %changelog * Fri Jul 03 2015 Brenden Blanco - 0.1.1-2 - Initial RPM Release %package -n libbcc Summary: Shared Library for BPF Compiler Collection (BCC) Requires: elfutils-libelf %description -n libbcc Shared Library for BPF Compiler Collection (BCC) %package -n libbcc-examples Summary: Examples for BPF Compiler Collection (BCC) Requires: libbcc %description -n libbcc-examples Examples for BPF Compiler Collection (BCC) %package -n python-bcc Summary: Python bindings for BPF Compiler Collection (BCC) Requires: libbcc %description -n python-bcc Python bindings for BPF Compiler Collection (BCC) %package -n bcc-tools Summary: Command line tools for BPF Compiler Collection (BCC) Requires: python-bcc %description -n bcc-tools Command line tools for BPF Compiler Collection (BCC) %files -n python-bcc %{python_sitelib}/bcc* %files -n libbcc /usr/lib64/* /usr/include/bcc/* %files -n libbcc-examples /usr/share/bcc/examples/* %exclude /usr/share/bcc/examples/*.pyc %exclude /usr/share/bcc/examples/*.pyo %exclude /usr/share/bcc/examples/*/*.pyc %exclude /usr/share/bcc/examples/*/*.pyo %exclude /usr/share/bcc/examples/*/*/*.pyc %exclude /usr/share/bcc/examples/*/*/*.pyo %files -n bcc-tools /usr/share/bcc/tools/* /usr/share/bcc/man/* bpfcc-0.2.0+git0.02884a026/SPECS/bcc.spec000066400000000000000000000071271305314114400167650ustar00rootroot00000000000000%bcond_with local_clang_static #lua jit not available for some architectures %ifarch ppc64 aarch64 ppc64le %{!?with_lua: %global with_lua 0} %else %{!?with_lua: %global with_lua 1} %endif %define debug_package %{nil} Name: bcc Version: @REVISION@ Release: @GIT_REV_COUNT@ Summary: BPF Compiler Collection (BCC) Group: Development/Languages License: ASL 2.0 URL: https://github.com/iovisor/bcc Source0: bcc.tar.gz ExclusiveArch: x86_64 ppc64 aarch64 ppc64le BuildRequires: bison cmake >= 2.8.7 flex make BuildRequires: gcc gcc-c++ python2-devel elfutils-libelf-devel-static %if %{with_lua} BuildRequires: luajit luajit-devel %endif %if %{without local_clang_static} BuildRequires: llvm-devel llvm-static BuildRequires: clang-devel %endif BuildRequires: pkgconfig ncurses-devel %description Python bindings for BPF Compiler Collection (BCC). Control a BPF program from userspace. %if %{with_lua} %global lua_include `pkg-config --variable=includedir luajit` %global lua_libs `pkg-config --variable=libdir luajit`/lib`pkg-config --variable=libname luajit`.so %global lua_config -DLUAJIT_INCLUDE_DIR=%{lua_include} -DLUAJIT_LIBRARIES=%{lua_libs} %endif %prep %setup -q -n bcc %build mkdir build pushd build cmake .. -DREVISION_LAST=%{version} -DREVISION=%{version} \ -DCMAKE_INSTALL_PREFIX=/usr \ %{?lua_config} make %{?_smp_mflags} popd %install pushd build make install/strip DESTDIR=%{buildroot} %package -n libbcc Summary: Shared Library for BPF Compiler Collection (BCC) Requires: elfutils-libelf %description -n libbcc Shared Library for BPF Compiler Collection (BCC) %package -n python-bcc Summary: Python bindings for BPF Compiler Collection (BCC) Requires: libbcc = %{version}-%{release} %description -n python-bcc Python bindings for BPF Compiler Collection (BCC) %if %{with_lua} %package -n bcc-lua Summary: Standalone tool to run BCC tracers written in Lua Requires: libbcc = %{version}-%{release} %description -n bcc-lua Standalone tool to run BCC tracers written in Lua %endif %package -n libbcc-examples Summary: Examples for BPF Compiler Collection (BCC) Requires: python-bcc = %{version}-%{release} %if %{with_lua} Requires: bcc-lua = %{version}-%{release} %endif %description -n libbcc-examples Examples for BPF Compiler Collection (BCC) %package -n bcc-tools Summary: Command line tools for BPF Compiler Collection (BCC) Requires: python-bcc = %{version}-%{release} %description -n bcc-tools Command line tools for BPF Compiler Collection (BCC) %files -n libbcc /usr/lib64/* /usr/include/bcc/* %files -n python-bcc %{python_sitelib}/bcc* %if %{with_lua} %files -n bcc-lua /usr/bin/bcc-lua %endif %files -n libbcc-examples /usr/share/bcc/examples/* %exclude /usr/share/bcc/examples/*.pyc %exclude /usr/share/bcc/examples/*.pyo %exclude /usr/share/bcc/examples/*/*.pyc %exclude /usr/share/bcc/examples/*/*.pyo %exclude /usr/share/bcc/examples/*/*/*.pyc %exclude /usr/share/bcc/examples/*/*/*.pyo %files -n bcc-tools /usr/share/bcc/tools/* /usr/share/bcc/man/* %post -n libbcc -p /sbin/ldconfig %postun -n libbcc -p /sbin/ldconfig %changelog * Mon Nov 21 2016 William Cohen - 0.2.0-1 - Revise bcc.spec to address rpmlint issues and build properly in Fedora koji. * Mon Apr 04 2016 Vicent Marti - 0.1.4-1 - Add bcc-lua package * Sun Nov 29 2015 Brenden Blanco - 0.1.3-1 - Add bcc-tools package * Mon Oct 12 2015 Brenden Blanco - 0.1.2-1 - Add better version numbering into libbcc.so * Fri Jul 03 2015 Brenden Blanco - 0.1.1-2 - Initial RPM Release bpfcc-0.2.0+git0.02884a026/cmake/000077500000000000000000000000001305314114400155565ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/cmake/FindLibElf.cmake000066400000000000000000000030471305314114400205220ustar00rootroot00000000000000# - Try to find libelf # Once done this will define # # LIBELF_FOUND - system has libelf # LIBELF_INCLUDE_DIRS - the libelf include directory # LIBELF_LIBRARIES - Link these to use libelf # LIBELF_DEFINITIONS - Compiler switches required for using libelf # # Copyright (c) 2008 Bernhard Walle # # Redistribution and use is allowed according to the terms of the New # BSD license. # For details see the accompanying COPYING-CMAKE-SCRIPTS file. # if (LIBELF_LIBRARIES AND LIBELF_INCLUDE_DIRS) set (LibElf_FIND_QUIETLY TRUE) endif (LIBELF_LIBRARIES AND LIBELF_INCLUDE_DIRS) find_path (LIBELF_INCLUDE_DIRS NAMES libelf.h PATHS /usr/include /usr/include/libelf /usr/local/include /usr/local/include/libelf /opt/local/include /opt/local/include/libelf /sw/include /sw/include/libelf ENV CPATH) find_library (LIBELF_LIBRARIES NAMES elf PATHS /usr/lib /usr/local/lib /opt/local/lib /sw/lib ENV LIBRARY_PATH ENV LD_LIBRARY_PATH) include (FindPackageHandleStandardArgs) # handle the QUIETLY and REQUIRED arguments and set LIBELF_FOUND to TRUE if all listed variables are TRUE FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibElf DEFAULT_MSG LIBELF_LIBRARIES LIBELF_INCLUDE_DIRS) SET(CMAKE_REQUIRED_LIBRARIES elf) INCLUDE(CheckCXXSourceCompiles) CHECK_CXX_SOURCE_COMPILES("#include int main() { Elf *e = (Elf*)0; size_t sz; elf_getshdrstrndx(e, &sz); return 0; }" ELF_GETSHDRSTRNDX) mark_as_advanced(LIBELF_INCLUDE_DIRS LIBELF_LIBRARIES ELF_GETSHDRSTRNDX) bpfcc-0.2.0+git0.02884a026/cmake/FindLuaJIT.cmake000066400000000000000000000044251305314114400204560ustar00rootroot00000000000000# Locate Lua library # This module defines # LUAJIT_FOUND, if false, do not try to link to Lua # LUAJIT_LIBRARIES # LUAJIT_INCLUDE_DIR, where to find lua.h # # Note that the expected include convention is # #include "lua.h" # and not # #include # This is because, the lua location is not standardized and may exist # in locations other than lua/ #============================================================================= # Copyright 2007-2009 Kitware, Inc. # # Distributed under the OSI-approved BSD License (the "License"); # see accompanying file Copyright.txt for details. # # This software is distributed WITHOUT ANY WARRANTY; without even the # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. # See the License for more information. #============================================================================= # (To distributed this file outside of CMake, substitute the full # License text for the above reference.) # # ################ # 2010 - modified for cronkite to find luajit instead of lua, as it was before. # FIND_PATH(LUAJIT_INCLUDE_DIR lua.h HINTS $ENV{LUAJIT_DIR} PATH_SUFFIXES include/luajit-2.0 include/luajit2.0 include/luajit include PATHS ~/Library/Frameworks /Library/Frameworks /usr/local /usr /sw # Fink /opt/local # DarwinPorts /opt/csw # Blastwave /opt ) FIND_LIBRARY(LUAJIT_LIBRARY NAMES libluajit-51.a libluajit-5.1.a libluajit.a HINTS $ENV{LUAJIT_DIR} PATH_SUFFIXES lib64 lib PATHS ~/Library/Frameworks /Library/Frameworks /usr/local /usr /sw /opt/local /opt/csw /opt ) IF(LUAJIT_LIBRARY) IF(UNIX AND NOT APPLE) FIND_LIBRARY(LUAJIT_MATH_LIBRARY m) FIND_LIBRARY(LUAJIT_DL_LIBRARY dl) SET( LUAJIT_LIBRARIES "${LUAJIT_LIBRARY};${LUAJIT_DL_LIBRARY};${LUAJIT_MATH_LIBRARY}" CACHE STRING "Lua Libraries") ELSE(UNIX AND NOT APPLE) SET( LUAJIT_LIBRARIES "${LUAJIT_LIBRARY}" CACHE STRING "Lua Libraries") ENDIF(UNIX AND NOT APPLE) ENDIF(LUAJIT_LIBRARY) INCLUDE(FindPackageHandleStandardArgs) # handle the QUIETLY and REQUIRED arguments and set LUAJIT_FOUND to TRUE if # all listed variables are TRUE FIND_PACKAGE_HANDLE_STANDARD_ARGS(LuaJIT DEFAULT_MSG LUAJIT_LIBRARIES LUAJIT_INCLUDE_DIR) MARK_AS_ADVANCED(LUAJIT_INCLUDE_DIR LUAJIT_LIBRARIES LUAJIT_LIBRARY LUAJIT_MATH_LIBRARY) bpfcc-0.2.0+git0.02884a026/cmake/GetGitRevisionDescription.cmake000066400000000000000000000073141305314114400236730ustar00rootroot00000000000000# - Returns a version string from Git # # These functions force a re-configure on each git commit so that you can # trust the values of the variables in your build system. # # get_git_head_revision( [ ...]) # # Returns the refspec and sha hash of the current head revision # # git_describe( [ ...]) # # Returns the results of git describe on the source tree, and adjusting # the output so that it tests false if an error occurs. # # git_get_exact_tag( [ ...]) # # Returns the results of git describe --exact-match on the source tree, # and adjusting the output so that it tests false if there was no exact # matching tag. # # Requires CMake 2.6 or newer (uses the 'function' command) # # Original Author: # 2009-2010 Ryan Pavlik # http://academic.cleardefinition.com # Iowa State University HCI Graduate Program/VRAC # # Copyright Iowa State University 2009-2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) if(__get_git_revision_description) return() endif() set(__get_git_revision_description YES) # We must run the following at "include" time, not at function call time, # to find the path to this module rather than the path to a calling list file get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH) function(get_git_head_revision _refspecvar _hashvar) set(GIT_PARENT_DIR "${CMAKE_SOURCE_DIR}") set(GIT_DIR "${GIT_PARENT_DIR}/.git") while(NOT EXISTS "${GIT_DIR}") # .git dir not found, search parent directories set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}") get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH) if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT) # We have reached the root directory, we are not in git set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE) set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE) return() endif() set(GIT_DIR "${GIT_PARENT_DIR}/.git") endwhile() set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data") if(NOT EXISTS "${GIT_DATA}") file(MAKE_DIRECTORY "${GIT_DATA}") endif() if(NOT EXISTS "${GIT_DIR}/HEAD") return() endif() set(HEAD_FILE "${GIT_DATA}/HEAD") configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY) configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" "${GIT_DATA}/grabRef.cmake" @ONLY) include("${GIT_DATA}/grabRef.cmake") set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE) set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE) endfunction() function(git_describe _var) if(NOT GIT_FOUND) find_package(Git QUIET) endif() get_git_head_revision(refspec hash) if(NOT GIT_FOUND) set(${_var} "GIT-NOTFOUND" PARENT_SCOPE) return() endif() if(NOT hash) set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE) return() endif() # TODO sanitize #if((${ARGN}" MATCHES "&&") OR # (ARGN MATCHES "||") OR # (ARGN MATCHES "\\;")) # message("Please report the following error to the project!") # message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}") #endif() #message(STATUS "Arguments to execute_process: ${ARGN}") execute_process(COMMAND "${GIT_EXECUTABLE}" describe ${hash} ${ARGN} WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) if(NOT res EQUAL 0) set(out "${out}-${res}-NOTFOUND") endif() set(${_var} "${out}" PARENT_SCOPE) endfunction() function(git_get_exact_tag _var) git_describe(out --exact-match ${ARGN}) set(${_var} "${out}" PARENT_SCOPE) endfunction() bpfcc-0.2.0+git0.02884a026/cmake/GetGitRevisionDescription.cmake.in000066400000000000000000000022611305314114400242740ustar00rootroot00000000000000# # Internal file for GetGitRevisionDescription.cmake # # Requires CMake 2.6 or newer (uses the 'function' command) # # Original Author: # 2009-2010 Ryan Pavlik # http://academic.cleardefinition.com # Iowa State University HCI Graduate Program/VRAC # # Copyright Iowa State University 2009-2010. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) set(HEAD_HASH) file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024) string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS) if(HEAD_CONTENTS MATCHES "ref") # named branch string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}") if(EXISTS "@GIT_DIR@/${HEAD_REF}") configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}") configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) set(HEAD_HASH "${HEAD_REF}") endif() else() # detached HEAD configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY) endif() if(NOT HEAD_HASH) file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024) string(STRIP "${HEAD_HASH}" HEAD_HASH) endif() bpfcc-0.2.0+git0.02884a026/cmake/bump_version.cmake000066400000000000000000000010521305314114400212660ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") configure_file(SPECS/Dockerfile.el6.in SPECS/Dockerfile.el6 @ONLY) configure_file(SPECS/Dockerfile.el7.in SPECS/Dockerfile.el7 @ONLY) configure_file(SPECS/Dockerfile.f22.in SPECS/Dockerfile.f22 @ONLY) configure_file(SPECS/bcc.el6.spec.in SPECS/bcc.el6.spec @ONLY) configure_file(SPECS/bcc.el7.spec.in SPECS/bcc.el7.spec @ONLY) configure_file(SPECS/bcc.f22.spec.in SPECS/bcc.f22.spec @ONLY) configure_file(scripts/build-deb.sh.in scripts/build-deb.sh @ONLY) bpfcc-0.2.0+git0.02884a026/cmake/version.cmake000066400000000000000000000017271305314114400202540ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") if(NOT REVISION) get_git_head_revision(GIT_REFSPEC GIT_SHA1) string(SUBSTRING "${GIT_SHA1}" 0 8 GIT_SHA1_SHORT) git_describe(GIT_DESCRIPTION) git_describe(GIT_TAG_LAST "--abbrev=0") git_get_exact_tag(GIT_TAG_EXACT) string(SUBSTRING "${GIT_TAG_LAST}-${GIT_SHA1_SHORT}" 1 -1 REVISION) if(GIT_TAG_EXACT) string(SUBSTRING "${GIT_TAG_EXACT}" 1 -1 REVISION) message(STATUS "Currently on Git tag ${GIT_TAG_EXACT}") else () message(STATUS "Latest recognized Git tag is ${GIT_TAG_LAST}") set(GIT_TAG_EXACT "") endif() message(STATUS "Git HEAD is ${GIT_SHA1}") # rpm/deb packaging uses this, only works on whole tag numbers if(NOT REVISION_LAST) string(SUBSTRING "${GIT_TAG_LAST}" 1 -1 REVISION_LAST) endif() else() set(REVISION_LAST "${REVISION}") endif() # strip leading 'v', and make unique for the tag message(STATUS "Revision is ${REVISION}") bpfcc-0.2.0+git0.02884a026/debian/000077500000000000000000000000001305314114400157205ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/debian/bcc-lua.install000066400000000000000000000000201305314114400206060ustar00rootroot00000000000000usr/bin/bcc-lua bpfcc-0.2.0+git0.02884a026/debian/bcc-tools.install000066400000000000000000000000521305314114400211720ustar00rootroot00000000000000usr/share/bcc/tools/* usr/share/bcc/man/* bpfcc-0.2.0+git0.02884a026/debian/changelog000066400000000000000000000022651305314114400175770ustar00rootroot00000000000000bcc (0.2.0-1) unstable; urgency=low * Add many new utilities in tools/ * Support for USDT * Support for lua * Many utilities converted to perf ring buffer * Support for tracepoints -- Brenden Blanco Thu, 08 Sep 2016 17:05:28 -0700 bcc (0.1.8-1) unstable; urgency=low * Add many new utilities in tools/ * wakeuptime, offwaketime, argdist, {xfs,zfs,ext4}{slower,dist}, others * Support for bpf_perf_event() * Support for public tables shared between programs * Support for up to 4.4 features * Remove external file dependencies from clang lib -- Brenden Blanco Mon, 23 Feb 2016 00:41:00 +0000 bcc (0.1.7-1) unstable; urgency=low * Tracing features and bugfixes * Built against LLVM 3.8 HEAD -- Brenden Blanco Mon, 12 Oct 2015 16:47:09 +0000 bcc (0.1.6-1) unstable; urgency=low * Stability fixes * Improvements to python API * Tracing features * Support for kernel 4.2 features -- Brenden Blanco Wed, 02 Sep 2015 16:23:19 +0000 bcc (0.1.5-1) unstable; urgency=low * Initial release -- Brenden Blanco Mon, 06 Jul 2015 18:04:28 +0000 bpfcc-0.2.0+git0.02884a026/debian/compat000066400000000000000000000000021305314114400171160ustar00rootroot000000000000009 bpfcc-0.2.0+git0.02884a026/debian/control000066400000000000000000000023671305314114400173330ustar00rootroot00000000000000Source: bcc Maintainer: Brenden Blanco Section: misc Priority: optional Standards-Version: 3.9.5 Build-Depends: debhelper (>= 9), cmake, libllvm3.7 | libllvm3.8, llvm-3.7-dev | llvm-3.8-dev, libclang-3.7-dev | libclang-3.8-dev, libelf-dev, bison, flex, libedit-dev, clang-format | clang-format-3.7 | clang-format-3.8, python (>= 2.7), python-netaddr, python-pyroute2, luajit, libluajit-5.1-dev, arping, inetutils-ping | iputils-ping, iperf, netperf, ethtool, devscripts Homepage: https://github.com/iovisor/bcc Package: libbcc Architecture: amd64 Depends: libc6, libstdc++6, libelf1 Description: Shared Library for BPF Compiler Collection (BCC) Shared Library for BPF Compiler Collection to control BPF programs from userspace. Package: libbcc-examples Architecture: any Depends: libbcc Description: Shared Library for BPF Compiler Collection (BCC) Package: python-bcc Architecture: all Depends: libbcc, python, binutils Description: Python wrappers for BPF Compiler Collection (BCC) Package: bcc-tools Architecture: all Depends: python-bcc Description: Command line tools for BPF Compiler Collection (BCC) Package: bcc-lua Architecture: all Depends: libbcc Description: Standalone tool to run BCC tracers written in Lua bpfcc-0.2.0+git0.02884a026/debian/copyright000066400000000000000000000003011305314114400176450ustar00rootroot00000000000000Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: bcc Source: https://github.com/iovisor/bcc Files: * Copyright: 2015 PLUMgrid, Inc. License: Apache-2.0 bpfcc-0.2.0+git0.02884a026/debian/docs000066400000000000000000000000361305314114400165720ustar00rootroot00000000000000FAQ.txt LICENSE.txt README.md bpfcc-0.2.0+git0.02884a026/debian/libbcc-examples.install000066400000000000000000000000311305314114400223340ustar00rootroot00000000000000usr/share/bcc/examples/* bpfcc-0.2.0+git0.02884a026/debian/libbcc.install000066400000000000000000000001021305314114400205170ustar00rootroot00000000000000usr/include/bcc/* usr/lib/*/libbcc* usr/lib/*/pkgconfig/libbcc.pc bpfcc-0.2.0+git0.02884a026/debian/python-bcc.install000066400000000000000000000000201305314114400213460ustar00rootroot00000000000000usr/lib/python* bpfcc-0.2.0+git0.02884a026/debian/rules000077500000000000000000000013101305314114400167730ustar00rootroot00000000000000#!/usr/bin/make -f # -*- makefile -*- # Uncomment this to turn on verbose mode. #export DH_VERBOSE=1 DEBIAN_VERSION := $(shell dpkg-parsechangelog | sed -rne "s,^Version: (.*),\1,p") DEBIAN_REVISION := $(shell dpkg-parsechangelog | sed -rne "s,^Version: ([0-9.]+)(~|-)(.*),\3,p") UPSTREAM_VERSION := $(shell dpkg-parsechangelog | sed -rne "s,^Version: ([0-9.]+)(~|-)(.*),\1,p") %: dh $@ --buildsystem=cmake --parallel # FIXME: LLVM_DEFINITIONS is broken somehow in LLVM cmake upstream override_dh_auto_configure: dh_auto_configure -- -DREVISION_LAST=$(UPSTREAM_VERSION) -DREVISION=$(UPSTREAM_VERSION) -DLLVM_DEFINITIONS="-D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS" bpfcc-0.2.0+git0.02884a026/debian/source/000077500000000000000000000000001305314114400172205ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/debian/source/format000066400000000000000000000000141305314114400204260ustar00rootroot000000000000003.0 (quilt) bpfcc-0.2.0+git0.02884a026/docs/000077500000000000000000000000001305314114400154265ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/docs/kernel-versions.md000066400000000000000000000377411305314114400211120ustar00rootroot00000000000000# BPF Features by Linux Kernel Version ## eBPF support Kernel version | Commit ---------------|------- 3.15 | [bd4cf0ed331a](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=bd4cf0ed331a275e9bf5a49e6d0fd55dffc551b8) ## JIT compiling Feature / Architecture | Kernel version | Commit -----------------------|----------------|------- x86\_64 | 3.16 | [622582786c9e](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=622582786c9e041d0bd52bde201787adeab249f8) ARM64 | 3.18 | [e54bcde3d69d](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=e54bcde3d69d40023ae77727213d14f920eb264a) s390 | 4.1 | [054623105728](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=054623105728b06852f077299e2bf1bf3d5f2b0b) Constant blinding for JIT machines | 4.7 | [4f3446bb809f](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4f3446bb809f20ad56cadf712e6006815ae7a8f9) PowerPC64 | 4.8 | [156d0e290e96](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=156d0e290e969caba25f1851c52417c14d141b24) Constant blinding - PowerPC64 | 4.9 | [b7b7013cac55](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=b7b7013cac55d794940bd9cb7b7c55c9dececac4) ## Main features Feature | Kernel version | Commit --------|----------------|------- `AF_PACKET` (libpcap/tcpdump, `cls_bpf` classifier, netfilter's `xt_bpf`, team driver's load-balancing mode…) | 3.15 | [bd4cf0ed331a](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=bd4cf0ed331a275e9bf5a49e6d0fd55dffc551b8) Kernel helpers | 3.15 | [bd4cf0ed331a](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=bd4cf0ed331a275e9bf5a49e6d0fd55dffc551b8) `bpf()` syscall | 3.18 | [99c55f7d47c0](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=99c55f7d47c0dc6fc64729f37bf435abf43f4c60) Tables (_a.k.a._ Maps; details below) | 3.18 | [99c55f7d47c0](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=99c55f7d47c0dc6fc64729f37bf435abf43f4c60) BPF attached to sockets | 3.19 | [89aa075832b0](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=89aa075832b0da4402acebd698d0411dcc82d03e) BPF attached to `kprobes` | 4.1 | [2541517c32be](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=2541517c32be2531e0da59dfd7efc1ce844644f5) `cls_bpf` / `act_bpf` for `tc` | 4.1 | [e2e9b6541dd4](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=e2e9b6541dd4b31848079da80fe2253daaafb549) Tail calls | 4.2 | [04fd61ab36ec](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=04fd61ab36ec065e194ab5e74ae34a5240d992bb) Non-root programs on sockets | 4.4 | [1be7f75d1668](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=1be7f75d1668d6296b80bf35dcf6762393530afc) Persistent maps and programs (virtual FS) | 4.4 | [b2197755b263](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=b2197755b2633e164a439682fb05a9b5ea48f706) `tc`'s `direct_action` (`da`) mode | 4.4 | [045efa82ff56](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=045efa82ff563cd4e656ca1c2e354fa5bf6bbda4) `tc`'s `clsact` qdisc | 4.5 | [1f211a1b929c](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=1f211a1b929c804100e138c5d3d656992cfd5622) BPF attached to tracepoints | 4.7 | [98b5c2c65c29](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=98b5c2c65c2951772a8fc661f50d675e450e8bce) Direct packet access | 4.7 | [969bf05eb3ce](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=969bf05eb3cedd5a8d4b7c346a85c2ede87a6d6d) XDP (see below) | 4.8 | [6a773a15a1e8](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6a773a15a1e8874e5eccd2f29190c31085912c95) BPF attached to perf events | 4.9 | [0515e5999a46](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=0515e5999a466dfe6e1924f460da599bb6821487) Hardware offload for `tc`'s `cls_bpf` | 4.9 | [332ae8e2f6ec](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=332ae8e2f6ecda5e50c5c62ed62894963e3a83f5) Verifier exposure and internal hooks | 4.9 | [13a27dfc6697](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=13a27dfc669724564aafa2699976ee756029fed2) BPF attached to cgroups for socket filtering | [4.10](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=0e33661de493db325435d565a4a722120ae4cbf3) | [](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=0e33661de493db325435d565a4a722120ae4cbf3) Lightweight tunnel encapsulation | [4.10](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=3a0af8fd61f90920f6fa04e4f1e9a6a73c1b4fd2) | []() **e**BPF support for `xt_bpf` module (iptables) | [4.10](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=2c16d60332643e90d4fa244f4a706c454b8c7569) | []() ## Tables (_a.k.a._ Maps) Table type | Kernel version | Commit -----------|----------------|------- Hash | 3.19 | [0f8e4bd8a1fc](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=0f8e4bd8a1fc8c4185f1630061d0a1f2d197a475) Array | 3.19 | [28fbcfa08d8e](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=28fbcfa08d8ed7c5a50d41a0433aad222835e8e3) Tail call (`PROG_ARRAY`) | 4.2 | [04fd61ab36ec](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=04fd61ab36ec065e194ab5e74ae34a5240d992bb) Perf events | 4.3 | [ea317b267e9d](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ea317b267e9d03a8241893aa176fba7661d07579) Per-CPU hash | 4.6 | [824bd0ce6c7c](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=824bd0ce6c7c43a9e1e210abf124958e54d88342) Per-CPU array | 4.6 | [a10423b87a7e](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=a10423b87a7eae75da79ce80a8d9475047a674ee) Stack trace | 4.6 | [d5a3b1f69186](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d5a3b1f691865be576c2bffa708549b8cdccda19) Pre-alloc maps memory | 4.6 | [6c9059817432](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6c90598174322b8888029e40dd84a4eb01f56afe) cgroup array | 4.8 | [4ed8ec521ed5](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4ed8ec521ed57c4e207ad464ca0388776de74d4b) LRU hash | 4.10 | [29ba732acbee](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=29ba732acbeece1e34c68483d1ec1f3720fa1bb3) LRU per-CPU hash | 4.10 | [8f8449384ec3](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=8f8449384ec364ba2a654f11f94e754e4ff719e0) LPM trie | 4.11 | [b95a5c4db09b](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=b95a5c4db09bc7c253636cb84dc9b12c577fd5a0) Text string | _To be done?_ | Variable-length maps | _To be done?_ | ## XDP Feature / Driver | Kernel version | Commit -----------------|----------------|------- XDP core architecture | 4.8 | [6a773a15a1e8](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6a773a15a1e8874e5eccd2f29190c31085912c95) Action: drop | 4.8 | [6a773a15a1e8](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6a773a15a1e8874e5eccd2f29190c31085912c95) Action: pass on to stack | 4.8 | [6a773a15a1e8](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6a773a15a1e8874e5eccd2f29190c31085912c95) Action: direct forwarding (on same port) | 4.8 | [6ce96ca348a9](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6ce96ca348a9e949f8c43f4d3e98db367d93cffd) Direct packet data write | 4.8 | [4acf6c0b84c9](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4acf6c0b84c91243c705303cd9ff16421914150d) Mellanox `mlx4` driver | 4.8 | [47a38e155037](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=47a38e155037f417c5740e24ccae6482aedf4b68) Mellanox `mlx5` driver | 4.9 | [86994156c736](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=86994156c736978d113e7927455d4eeeb2128b9f) QLogic (Cavium) `qed*` drivers | [4.10](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=496e051709588f832d7a6a420f44f8642b308a87) | [](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=496e051709588f832d7a6a420f44f8642b308a87) `virtio_net` driver | ? | []() Intel `i40e` driver | ? | []() ## Helpers Alphabetical order Helper | Kernel version | Commit -------|----------------|------- `BPF_FUNC_clone_redirect()` | 4.2 | [3896d655f4d4](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=3896d655f4d491c67d669a15f275a39f713410f8) `BPF_FUNC_csum_diff()` | 4.6 | [7d672345ed29](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7d672345ed295b1356a5d9f7111da1d1d7d65867) `BPF_FUNC_csum_update()` | 4.9 | [36bbef52c7eb](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=36bbef52c7eb646ed6247055a2acd3851e317857) `BPF_FUNC_current_task_under_cgroup()` | 4.9 | [60d20f9195b2](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=60d20f9195b260bdf0ac10c275ae9f6016f9c069) `BPF_FUNC_get_cgroup_classid()` | 4.3 | [8d20aabe1c76](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=8d20aabe1c76cccac544d9fcc3ad7823d9e98a2d) `BPF_FUNC_get_current_comm()` | 4.2 | [ffeedafbf023](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ffeedafbf0236f03aeb2e8db273b3e5ae5f5bc89) `BPF_FUNC_get_current_pid_tgid()` | 4.2 | [ffeedafbf023](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ffeedafbf0236f03aeb2e8db273b3e5ae5f5bc89) `BPF_FUNC_get_current_task()` | 4.8 | [606274c5abd8](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=606274c5abd8e245add01bc7145a8cbb92b69ba8) `BPF_FUNC_get_current_uid_gid()` | 4.2 | [ffeedafbf023](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=ffeedafbf0236f03aeb2e8db273b3e5ae5f5bc89) `BPF_FUNC_get_hash_recalc()` | 4.8 | [13c5c240f789](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=13c5c240f789bbd2bcacb14a23771491485ae61f) `BPF_FUNC_get_numa_node_id()` | [4.10](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=2d0e30c30f84d08dc16f0f2af41f1b8a85f0755e) | [](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=2d0e30c30f84d08dc16f0f2af41f1b8a85f0755e) `BPF_FUNC_get_prandom_u32()` | 4.1 | [03e69b508b6f](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=03e69b508b6f7c51743055c9f61d1dfeadf4b635) `BPF_FUNC_get_route_realm()` | 4.4 | [c46646d0484f](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=c46646d0484f5d08e2bede9b45034ba5b8b489cc) `BPF_FUNC_get_smp_processor_id()` | 4.1 | [c04167ce2ca0](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=c04167ce2ca0ecaeaafef006cb0d65cf01b68e42) `BPF_FUNC_get_stackid()` | 4.6 | [d5a3b1f69186](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d5a3b1f691865be576c2bffa708549b8cdccda19) `BPF_FUNC_ktime_get_ns()` | 4.1 | [d9847d310ab4](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d9847d310ab4003725e6ed1822682e24bd406908) `BPF_FUNC_l3_csum_replace()` | 4.1 | [91bc4822c3d6](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=91bc4822c3d61b9bb7ef66d3b77948a4f9177954) `BPF_FUNC_l4_csum_replace()` | 4.1 | [91bc4822c3d6](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=91bc4822c3d61b9bb7ef66d3b77948a4f9177954) `BPF_FUNC_map_delete_elem()` | 3.19 | [d0003ec01c66](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d0003ec01c667b731c139e23de3306a8b328ccf5) `BPF_FUNC_map_lookup_elem()` | 3.19 | [d0003ec01c66](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d0003ec01c667b731c139e23de3306a8b328ccf5) `BPF_FUNC_map_update_elem()` | 3.19 | [d0003ec01c66](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d0003ec01c667b731c139e23de3306a8b328ccf5) `BPF_FUNC_perf_event_output()` | 4.4 | [a43eec304259](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=a43eec304259a6c637f4014a6d4767159b6a3aa3) `BPF_FUNC_perf_event_read()` | 4.3 | [35578d798400](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=35578d7984003097af2b1e34502bc943d40c1804) `BPF_FUNC_probe_read()` | 4.1 | [2541517c32be](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=2541517c32be2531e0da59dfd7efc1ce844644f5) `BPF_FUNC_probe_write_user()` | 4.8 | [96ae52279594](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=96ae52279594470622ff0585621a13e96b700600) `BPF_FUNC_redirect()` | 4.4 | [27b29f63058d](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=27b29f63058d26c6c1742f1993338280d5a41dc6) `BPF_FUNC_set_hash_invalid()` | 4.9 | [7a4b28c6cc9f](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=7a4b28c6cc9ffac50f791b99cc7e46106436e5d8) `BPF_FUNC_skb_change_head()` | [4.10](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=3a0af8fd61f90920f6fa04e4f1e9a6a73c1b4fd2) | []() `BPF_FUNC_skb_change_proto()` | 4.8 | [6578171a7ff0](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=6578171a7ff0c31dc73258f93da7407510abf085) `BPF_FUNC_skb_change_tail()` | 4.9 | [5293efe62df8](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=5293efe62df81908f2e90c9820c7edcc8e61f5e9) `BPF_FUNC_skb_change_type()` | 4.8 | [d2485c4242a82](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d2485c4242a826fdf493fd3a27b8b792965b9b9e) `BPF_FUNC_skb_get_tunnel_key()` | 4.3 | [d3aa45ce6b94](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d3aa45ce6b94c65b83971257317867db13e5f492) `BPF_FUNC_skb_get_tunnel_opt()` | 4.6 | [14ca0751c96f](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=14ca0751c96f8d3d0f52e8ed3b3236f8b34d3460) `BPF_FUNC_skb_load_bytes()` | 4.5 | [05c74e5e53f6](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=05c74e5e53f6cb07502c3e6a820f33e2777b6605) `BPF_FUNC_skb_pull_data()` | 4.9 | [36bbef52c7eb](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=36bbef52c7eb646ed6247055a2acd3851e317857) `BPF_FUNC_skb_set_tunnel_key()` | 4.3 | [d3aa45ce6b94](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=d3aa45ce6b94c65b83971257317867db13e5f492) `BPF_FUNC_skb_set_tunnel_opt()` | 4.6 | [14ca0751c96f](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=14ca0751c96f8d3d0f52e8ed3b3236f8b34d3460) `BPF_FUNC_skb_store_bytes()` | 4.1 | [91bc4822c3d6](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=91bc4822c3d61b9bb7ef66d3b77948a4f9177954) `BPF_FUNC_skb_under_cgroup()` | 4.8 | [4a482f34afcc](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4a482f34afcc162d8456f449b137ec2a95be60d8) `BPF_FUNC_skb_vlan_pop()` | 4.3 | [4e10df9a60d9](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4e10df9a60d96ced321dd2af71da558c6b750078) `BPF_FUNC_skb_vlan_push()` | 4.3 | [4e10df9a60d9](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=4e10df9a60d96ced321dd2af71da558c6b750078) `BPF_FUNC_tail_call()` | 4.2 | [04fd61ab36ec](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=04fd61ab36ec065e194ab5e74ae34a5240d992bb) `BPF_FUNC_trace_printk()` | 4.1 | [9c959c863f82](https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=9c959c863f8217a2ff3d7c296e8223654d240569) `BPF_FUNC_xdp_adjust_head()` | [4.10](https://git.kernel.org/cgit/linux/kernel/git/davem/net-next.git/commit/?id=17bedab2723145d17b14084430743549e6943d03) | []() bpfcc-0.2.0+git0.02884a026/docs/reference_guide.md000066400000000000000000001257551305314114400211020ustar00rootroot00000000000000# bcc Reference Guide Intended for search (Ctrl-F) and reference. For tutorials, start with [tutorial.md](tutorial.md). This guide is incomplete. If something feels missing, check the bcc and kernel source. And if you confirm we're missing something, please send a pull request to fix it, and help out everyone. ## Contents - [BPF C](#bpf-c) - [Events & Arguments](#events--arguments) - [1. kprobes](#1-kprobes) - [2. kretprobes](#2-kretprobes) - [3. Tracepoints](#3-tracepoints) - [4. uprobes](#4-uprobes) - [5. uretprobes](#5-uretprobes) - [6. USDT probes](#6-usdt-probes) - [Data](#data) - [1. bpf_probe_read()](#1-bpf_probe_read) - [2. bpf_ktime_get_ns()](#2-bpf_ktime_get_ns) - [3. bpf_get_current_pid_tgid()](#3-bpf_get_current_pid_tgid) - [4. bpf_get_current_uid_gid()](#4-bpf_get_current_uid_gid) - [5. bpf_get_current_comm()](#5-bpf_get_current_comm) - [6. bpf_log2l()](#6-bpflog2l) - [Output](#output) - [1. bpf_trace_printk()](#1-bpf_trace_printk) - [2. BPF_PERF_OUTPUT](#2-bpf_perf_output) - [3. perf_submit()](#3-perf_submit) - [Maps](#maps) - [1. BPF_TABLE](#1-bpf_table) - [2. BPF_HASH](#2-bpf_hash) - [3. BPF_HISTOGRAM](#3-bpf_histogram) - [4. BPF_STACK_TRACE](#4-bpf_stack_trace) - [5. BPF_PERF_ARRAY](#5-bpf_perf_array) - [6. map.lookup()](#6-maplookup) - [7. map.lookup_or_init()](#7-maplookup_or_init) - [8. map.delete()](#8-mapdelete) - [9. map.update()](#9-mapupdate) - [10. map.increment()](#10-mapincrement) - [11. map.get_stackid()](#11-mapget_stackid) - [12. map.perf_read()](#12-mapperf_read) - [bcc Python](#bcc-python) - [Initialization](#initialization) - [1. BPF](#1-bpf) - [2. USDT](#2-usdt) - [Events](#events) - [1. attach_kprobe()](#1-attach_kprobe) - [2. attach_kretprobe()](#2-attach_kretprobe) - [3. attach_tracepoint()](#3-attach_tracepoint) - [4. attach_uprobe()](#4-attach_uprobe) - [5. attach_uretprobe()](#5-attach_uretprobe) - [6. USDT.enable_probe()](#6-usdtenable_probe) - [Debug Output](#debug-output) - [1. trace_print()](#1-trace_print) - [2. trace_fields()](#2-trace_fields) - [Output](#output) - [1. kprobe_poll()](#1-kprobe_poll) - [Maps](#maps) - [1. get_table()](#1-get_table) - [2. open_perf_buffer()](#2-open_perf_buffer) - [3. items()](#3-items) - [4. values()](#4-values) - [5. clear()](#5-clear) - [6. print_log2_hist()](#6-print_log2_hist) - [7. print_linear_hist()](#6-print_linear_hist) - [Helpers](#helpers) - [1. ksym()](#1-ksym) - [2. ksymname()](#2-ksymname) - [3. sym()](#3-sym) - [4. num_open_kprobes()](#4-num_open_kprobes) - [BPF Errors](#bpf-errors) - [1. Invalid mem access](#1-invalid-mem-access) # BPF C This section describes the C part of a bcc program. ## Events & Arguments ### 1. kprobes Syntax: kprobe__*kernel_function_name* ```kprobe__``` is a special prefix that creates a kprobe (dynamic tracing of a kernel function call) for the kernel function name provided as the remainder. You can also use kprobes by declaring a normal C function, then using the Python ```BPF.attach_kprobe()``` (covered later) to associate it with a kernel function. Arguments are specified on the function declaration: kprobe__*kernel_function_name*(struct pt_regs *ctx [, *argument1* ...]) For example: ```C int kprobe__tcp_v4_connect(struct pt_regs *ctx, struct sock *sk) [...] } ``` This instruments the tcp_v4_connect() kernel function using a kprobe, with the following arguments: - ```struct pt_regs *ctx```: Registers and BPF context. - ```struct sock *sk```: First argument to tcp_v4_connect(). The first argument is always ```struct pt_regs *```, the remainder are the arguments to the function (they don't need to be specified, if you don't intend to use them). Examples in situ: [code](https://github.com/iovisor/bcc/blob/4afa96a71c5dbfc4c507c3355e20baa6c184a3a8/examples/tracing/tcpv4connect.py#L28) ([output](https://github.com/iovisor/bcc/blob/5bd0eb21fd148927b078deb8ac29fff2fb044b66/examples/tracing/tcpv4connect_example.txt#L8)), [code](https://github.com/iovisor/bcc/commit/310ab53710cfd46095c1f6b3e44f1dbc8d1a41d8#diff-8cd1822359ffee26e7469f991ce0ef00R26) ([output](https://github.com/iovisor/bcc/blob/3b9679a3bd9b922c736f6061dc65cb56de7e0250/examples/tracing/bitehist_example.txt#L6)) ### 2. kretprobes Syntax: kretprobe__*kernel_function_name* ```kretprobe__``` is a special prefix that creates a kretprobe (dynamic tracing of a kernel function return) for the kernel function name provided as the remainder. You can also use kretprobes by declaring a normal C function, then using the Python ```BPF.attach_kretprobe()``` (covered later) to associate it with a kernel function. Return value is available as ```PT_REGS_RC(ctx)```, given a function declaration of: kretprobe__*kernel_function_name*(struct pt_regs *ctx) For example: ```C int kretprobe__tcp_v4_connect(struct pt_regs *ctx) { int ret = PT_REGS_RC(ctx); [...] } ``` This instruments the return of the tcp_v4_connect() kernel function using a kretprobe, and stores the return value in ```ret```. Examples in situ: [code](https://github.com/iovisor/bcc/blob/4afa96a71c5dbfc4c507c3355e20baa6c184a3a8/examples/tracing/tcpv4connect.py#L38) ([output](https://github.com/iovisor/bcc/blob/5bd0eb21fd148927b078deb8ac29fff2fb044b66/examples/tracing/tcpv4connect_example.txt#L8)) ### 3. Tracepoints Syntax: TRACEPOINT_PROBE(*category*, *event*) This is a macro that instruments the tracepoint defined by *category*:*event*. Arguments are available in an ```args``` struct, which are the tracepoint arguments. One way to list these is to cat the relevant format file under /sys/kernel/debug/tracing/events/*category*/*event*/format. For example: ```C TRACEPOINT_PROBE(random, urandom_read) { // args is from /sys/kernel/debug/tracing/events/random/urandom_read/format bpf_trace_printk("%d\\n", args->got_bits); return 0; } ``` This instruments the random:urandom_read tracepoint, and prints the tracepoint argument ```got_bits```. Examples in situ: [code](https://github.com/iovisor/bcc/blob/a4159da8c4ea8a05a3c6e402451f530d6e5a8b41/examples/tracing/urandomread.py#L19) ([output](https://github.com/iovisor/bcc/commit/e422f5e50ecefb96579b6391a2ada7f6367b83c4#diff-41e5ecfae4a3b38de5f4e0887ed160e5R10)), [search /examples](https://github.com/iovisor/bcc/search?q=TRACEPOINT_PROBE+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=TRACEPOINT_PROBE+path%3Atools&type=Code) ### 4. uprobes These are instrumented by declaring a normal function in C, then associating it as a uprobe probe in Python via ```BPF.attach_uprobe()``` (covered later). Arguments can be examined using ```PT_REGS_PARM``` macros. For example: ```C int count(struct pt_regs *ctx) { char buf[64]; bpf_probe_read(&buf, sizeof(buf), (void *)PT_REGS_PARM1(ctx)); bpf_trace_printk("%s %d", buf, PT_REGS_PARM2(ctx)); return(0); } ``` This reads the first argument as a string, and then prints it with the second argument as an integer. Examples in situ: [code](https://github.com/iovisor/bcc/blob/4afa96a71c5dbfc4c507c3355e20baa6c184a3a8/examples/tracing/strlen_count.py#L26) ### 5. uretprobes These are instrumented by declaring a normal function in C, then associating it as a uretprobe probe in Python via ```BPF.attach_uretprobe()``` (covered later). Return value is available as ```PT_REGS_RC(ctx)```, given a function declaration of: *function_name*(struct pt_regs *ctx) For example: ```C BPF_HISTOGRAM(dist); int count(struct pt_regs *ctx) { dist.increment(PT_REGS_RC(ctx)); return 0; } ``` This increments the bucket in the ```dist``` histogram that is indexed by the return value. Examples in situ: [code](https://github.com/iovisor/bcc/blob/4afa96a71c5dbfc4c507c3355e20baa6c184a3a8/examples/tracing/strlen_hist.py#L39) ([output](https://github.com/iovisor/bcc/blob/4afa96a71c5dbfc4c507c3355e20baa6c184a3a8/examples/tracing/strlen_hist.py#L15)), [code](https://github.com/iovisor/bcc/blob/4afa96a71c5dbfc4c507c3355e20baa6c184a3a8/tools/bashreadline.py) ([output](https://github.com/iovisor/bcc/commit/aa87997d21e5c1a6a20e2c96dd25eb92adc8e85d#diff-2fd162f9e594206f789246ce97d62cf0R7)) ### 6. USDT probes These are User Statically-Defined Tracing (USDT) probes, which may be placed in some applications or libraries to provide a user-level equivalent of tracepoints. The primary BPF method provided for USDT support method is ```enable_probe()```. USDT probes are instrumented by declaring a normal function in C, then associating it as a USDT probe in Python via ```USDT.enable_probe()```. Arguments can be read via: bpf_usdt_readarg(*index*, ctx, &addr) For example: ```C int do_trace(struct pt_regs *ctx) { uint64_t addr; char path[128]; bpf_usdt_readarg(6, ctx, &addr); bpf_probe_read(&path, sizeof(path), (void *)addr); bpf_trace_printk("path:%s\\n", path); return 0; }; ``` This reads the sixth USDT argument, and then pulls it in as a string to ```path```. Examples in situ: [code](https://github.com/iovisor/bcc/commit/4f88a9401357d7b75e917abd994aa6ea97dda4d3#diff-04a7cad583be5646080970344c48c1f4R24), [search /examples](https://github.com/iovisor/bcc/search?q=bpf_usdt_readarg+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_usdt_readarg+path%3Atools&type=Code) ## Data ### 1. bpf_probe_read() Syntax: ```int bpf_probe_read(void *dst, int size, void *src)``` Return: 0 on success This copies a memory location to the BPF stack, so that BPF can later operate on it. For safety, all memory reads must pass through bpf_probe_read(). This happens automatically in some cases, such as dereferencing kernel variables, as bcc will rewrite the BPF program to include the necessary bpf_probe_reads(). Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_probe_read+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_probe_read+path%3Atools&type=Code) ### 2. bpf_ktime_get_ns() Syntax: ```u64 bpf_ktime_get_ns(void)``` Return: current time in nanoseconds Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_ktime_get_ns+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_ktime_get_ns+path%3Atools&type=Code) ### 3. bpf_get_current_pid_tgid() Syntax: ```u64 bpf_get_current_pid_tgid(void)``` Return: ```current->tgid << 32 | current->pid``` Returns the process ID in the lower 32 bits (kernel's view of the PID, which in user space is usually presented as the thread ID), and the thread group ID in the upper 32 bits (what user space often thinks of as the PID). By directly setting this to a u32, we discard the upper 32 bits. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_get_current_pid_tgid+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_get_current_pid_tgid+path%3Atools&type=Code) ### 4. bpf_get_current_uid_gid() Syntax: ```u64 bpf_get_current_uid_gid(void)``` Return: ```current_gid << 32 | current_uid``` Returns the user ID and group IDs. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_get_current_uid_gid+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_get_current_uid_gid+path%3Atools&type=Code) ### 5. bpf_get_current_comm() Syntax: ```bpf_get_current_comm(char *buf, int size_of_buf)``` Return: 0 on success Populates the first argument address with the current process name. It should be a pointer to a char array of at least size TASK_COMM_LEN, which is defined in linux/sched.h. For example: ```C #include int do_trace(struct pt_regs *ctx) { char comm[TASK_COMM_LEN]; bpf_get_current_comm(&comm, sizeof(comm)); [...] ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_get_current_comm+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_get_current_comm+path%3Atools&type=Code) ### 6. bpf_log2l() Syntax: ```unsigned int bpf_log2l(unsigned long v)``` Returns the log-2 of the provided value. This is often used to create indexes for histograms, to construct power-of-2 histograms. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_log2l+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_log2l+path%3Atools&type=Code) ## Output ### 1. bpf_trace_printk() Syntax: ```int bpf_trace_printk(const char *fmt, int fmt_size, ...)``` Return: 0 on success A simple kernel facility for printf() to the common trace_pipe (/sys/kernel/debug/tracing/trace_pipe). This is ok for some quick examples, but has limitations: 3 args max, 1 %s only, and trace_pipe is globally shared, so concurrent programs will have clashing output. A better interface is via BPF_PERF_OUTPUT(). Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=bpf_trace_printk+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=bpf_trace_printk+path%3Atools&type=Code) ### 2. BPF_PERF_OUTPUT Syntax: ```BPF_PERF_OUTPUT(name)``` Creates a BPF table for pushing out custom event data to user space via a perf ring buffer. This is the preferred method for pushing per-event data to user space. For example: ```C struct data_t { u32 pid; u64 ts; char comm[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(events); int hello(struct pt_regs *ctx) { struct data_t data = {}; data.pid = bpf_get_current_pid_tgid(); data.ts = bpf_ktime_get_ns(); bpf_get_current_comm(&data.comm, sizeof(data.comm)); events.perf_submit(ctx, &data, sizeof(data)); return 0; } ``` The output table is named ```events```, and data is pushed to it via ```events.perf_submit()```. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=BPF_PERF_OUTPUT+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=BPF_PERF_OUTPUT+path%3Atools&type=Code) ### 3. perf_submit() Syntax: ```int perf_submit((void *)ctx, (void *)data, u32 data_size)``` Return: 0 on success A method of a BPF_PERF_OUTPUT table, for submitting custom event data to user space. See the BPF_PERF_OUTPUT entry. (This ultimately calls bpf_perf_event_output().) Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=perf_submit+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=perf_submit+path%3Atools&type=Code) ## Maps Maps are BPF data stores, and are the basis for higher level object types including tables, hashes, and histograms. ### 1. BPF_TABLE Syntax: ```BPF_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries)``` Creates a map named ```_name```. Most of the time this will be used via higher-level macros, like BPF_HASH, BPF_HIST, etc. Methods (covered later): map.lookup(), map.lookup_or_init(), map.delete(), map.update(), map.increment(). Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=BPF_TABLE+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=BPF_TABLE+path%3Atools&type=Code) ### 2. BPF_HASH Syntax: ```BPF_HASH(name [, key_type [, leaf_type [, size]]])``` Creates a hash map (associative array) named ```name```, with optional parameters. Defaults: ```BPF_HASH(name, key_type=u64, leaf_type=u64, size=10240)``` For example: ```C BPF_HASH(start, struct request *); ``` This creates a hash named ```start``` where the key is a ```struct request *```, and the value defaults to u64. This hash is used by the disksnoop.py example for saving timestamps for each I/O request, where the key is the pointer to struct request, and the value is the timestamp. Methods (covered later): map.lookup(), map.lookup_or_init(), map.delete(), map.update(), map.increment(). Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=BPF_HASH+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=BPF_HASH+path%3Atools&type=Code) ### 3. BPF_HISTOGRAM Syntax: ```BPF_HISTOGRAM(name [, key_type [, size ]])``` Creates a histogram map named ```name```, with optional parameters. Defaults: ```BPF_HISTOGRAM(name, key_type=int, size=64)``` For example: ```C BPF_HISTOGRAM(dist); ``` This creates a histogram named ```dist```, which defaults to 64 buckets indexed by keys of type int. Methods (covered later): map.increment(). Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=BPF_HISTOGRAM+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=BPF_HISTOGRAM+path%3Atools&type=Code) ### 4. BPF_STACK_TRACE Syntax: ```BPF_STACK_TRACE(name, max_entries)``` Creates stack trace map named ```name```, with a maximum entry count provided. These maps are used to store stack traces. For example: ```C BPF_STACK_TRACE(stack_traces, 1024); ``` This creates stack trace map named ```stack_traces```, with a maximum number of stack trace entries of 1024. Methods (covered later): map.get_stackid(). Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=BPF_STACK_TRACE+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=BPF_STACK_TRACE+path%3Atools&type=Code) ### 5. BPF_PERF_ARRAY Syntax: ```BPF_PERF_ARRAY(name, max_entries)``` Creates perf array named ```name```, with a maximum entry count provided, which must be equal to the number of system cpus. These maps are used to fetch hardware performance counters. For example: ```C text=""" BPF_PERF_ARRAY(cpu_cycles, NUM_CPUS); """ b = bcc.BPF(text=text, cflags=["-DNUM_CPUS=%d" % multiprocessing.cpu_count()]) b["cpu_cycles"].open_perf_event(b["cpu_cycles"].HW_CPU_CYCLES) ``` This creates a perf array named ```cpu_cycles```, with number of entries equal to the number of cpus/cores. The array is configured so that later calling map.perf_read() will return a hardware-calculated counter of the number of cycles elapsed from some point in the past. Only one type of hardware counter may be configured per table at a time. Methods (covered later): map.perf_read(). Examples in situ: [search /tests](https://github.com/iovisor/bcc/search?q=BPF_PERF_ARRAY+path%3Atests&type=Code) ### 6. map.lookup() Syntax: ```*val map.lookup(&key)``` Lookup the key in the map, and return a pointer to its value if it exists, else NULL. We pass the key in as an address to a pointer. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=lookup+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=lookup+path%3Atools&type=Code) ### 7. map.lookup_or_init() Syntax: ```*val map.lookup_or_init(&key, &zero)``` Lookup the key in the map, and return a pointer to its value if it exists, else initialize the key's value to the second argument. This is often used to initialize values to zero. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=lookup_or_init+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=lookup_or_init+path%3Atools&type=Code) ### 8. map.delete() Syntax: ```map.delete(&key)``` Delete the key from the hash. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=delete+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=delete+path%3Atools&type=Code) ### 9. map.update() Syntax: ```map.update(&key, &val)``` Associate the value in the second argument to the key, overwriting any previous value. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=update+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=update+path%3Atools&type=Code) ### 10. map.increment() Syntax: ```map.increment(key)``` Increments the key's value by one. Used for histograms. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=increment+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=increment+path%3Atools&type=Code) ### 11. map.get_stackid() Syntax: ```int map.get_stackid(void *ctx, u64 flags)``` This walks the stack found via the struct pt_regs in ```ctx```, saves it in the stack trace map, and returns a unique ID for the stack trace. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=get_stackid+path%3Aexamples&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=get_stackid+path%3Atools&type=Code) ### 12. map.perf_read() Syntax: ```u64 map.perf_read(u32 cpu)``` This returns the hardware performance counter as configured in [5. BPF_PERF_ARRAY](#5-bpf_perf_array) Examples in situ: [search /tests](https://github.com/iovisor/bcc/search?q=perf_read+path%3Atests&type=Code) # bcc Python ## Initialization Constructors. ### 1. BPF Syntax: ```BPF({text=BPF_program | src_file=filename} [, usdt_contexts=[USDT_object, ...]])``` Creates a BPF object. This is the main object for defining a BPF program, and interacting with its output. Examples: ```Python # define entire BPF program in one line: BPF(text='int do_trace(void *ctx) { bpf_trace_printk("hit!\\n"); return 0; }'); # define program as a variable: prog = """ int hello(void *ctx) { bpf_trace_printk("Hello, World!\\n"); return 0; } """ b = BPF(text=prog) # source a file: b = BPF(src_file = "vfsreadlat.c") # include a USDT object: u = USDT(pid=int(pid)) [...] b = BPF(text=bpf_text, usdt_contexts=[u]) ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=BPF+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=BPF+path%3Atools+language%3Apython&type=Code) ### 2. USDT Syntax: ```USDT({pid=pid | path=path})``` Creates an object to instrument User Statically-Defined Tracing (USDT) probes. Its primary method is ```enable_probe()```. Arguments: - pid: attach to this process ID. - path: instrument USDT probes from this binary path. Examples: ```Python # include a USDT object: u = USDT(pid=int(pid)) [...] b = BPF(text=bpf_text, usdt_contexts=[u]) ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=USDT+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=USDT+path%3Atools+language%3Apython&type=Code) ## Events ### 1. attach_kprobe() Syntax: ```BPF.attach_kprobe(event="event", fn_name="name")``` Instruments the kernel function ```event()``` using kernel dynamic tracing of the function entry, and attaches our C defined function ```name()``` to be called when the kernel function is called. For example: ```Python b.attach_kprobe(event="sys_clone", fn_name="do_trace") ``` This will instrument the kernel ```sys_clone()``` function, which will then run our BPF defined ```do_trace()``` function each time it is called. You can call attach_kprobe() more than once, and attach your BPF function to multiple kernel functions. See the previous kprobes section for how to instrument arguments from BPF. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=attach_kprobe+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=attach_kprobe+path%3Atools+language%3Apython&type=Code) ### 2. attach_kretprobe() Syntax: ```BPF.attach_kretprobe(event="event", fn_name="name")``` Instruments the return of the kernel function ```event()``` using kernel dynamic tracing of the function return, and attaches our C defined function ```name()``` to be called when the kernel function returns. For example: ```Python b.attach_kretprobe(event="vfs_read", fn_name="do_return") ``` This will instrument the kernel ```vfs_read()``` function, which will then run our BPF defined ```do_return()``` function each time it is called. You can call attach_kretprobe() more than once, and attach your BPF function to multiple kernel function returns. See the previous kretprobes section for how to instrument the return value from BPF. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=attach_kretprobe+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=attach_kretprobe+path%3Atools+language%3Apython&type=Code) ### 3. attach_tracepoint() Syntax: ```BPF.attach_tracepoint(tp="tracepoint", fn_name="name")``` Instruments the kernel tracepoint described by ```tracepoint```, and when hit, runs the BPF function ```name()```. This is an explicit way to instrument tracepoints. The ```TRACEPOINT_PROBE``` syntax, covered in the earlier tracepoints section, is an alternate method with the advantage of auto-declaring an ```args``` struct containing the tracepoint arguments. With ```attach_tracepoint()```, the tracepoint arguments need to be declared in the BPF program. For example: ```Python # define BPF program bpf_text = """ #include struct urandom_read_args { // from /sys/kernel/debug/tracing/events/random/urandom_read/format u64 __unused__; u32 got_bits; u32 pool_left; u32 input_left; }; int printarg(struct urandom_read_args *args) { bpf_trace_printk("%d\\n", args->got_bits); return 0; }; """ # load BPF program b = BPF(text=bpf_text) b.attach_tracepoint("random:urandom_read", "printarg") ``` Notice how the first argument to ```printarg()``` is now our defined struct. Examples in situ: [code](https://github.com/iovisor/bcc/blob/a4159da8c4ea8a05a3c6e402451f530d6e5a8b41/examples/tracing/urandomread-explicit.py#L41) ### 4. attach_uprobe() Syntax: ```BPF.attach_uprobe(name="location", sym="symbol", fn_name="name")``` Instruments the user-level function ```symbol()``` from either the library or binary named by ```location``` using user-level dynamic tracing of the function entry, and attach our C defined function ```name()``` to be called whenever the user-level function is called. Libraries can be given in the name argument without the lib prefix, or with the full path (/usr/lib/...). Binaries can be given only with the full path (/bin/sh). For example: ```Python b.attach_uprobe(name="c", sym="strlen", fn_name="count") ``` This will instrument ```strlen()``` function from libc, and call our BPF function ```count()``` when it is called. Note how the "lib" in "libc" is not necessary to specify. Other examples: ```Python b.attach_uprobe(name="c", sym="getaddrinfo", fn_name="do_entry") b.attach_uprobe(name="/usr/bin/python", sym="main", fn_name="do_main") ``` You can call attach_uprobe() more than once, and attach your BPF function to multiple user-level functions. See the previous uprobes section for how to instrument arguments from BPF. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=attach_uprobe+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=attach_uprobe+path%3Atools+language%3Apython&type=Code) ### 5. attach_uretprobe() Syntax: ```BPF.attach_uretprobe(name="location", sym="symbol", fn_name="name")``` Instruments the return of the user-level function ```symbol()``` from either the library or binary named by ```location``` using user-level dynamic tracing of the function return, and attach our C defined function ```name()``` to be called whenever the user-level function returns. For example: ```Python b.attach_uretprobe(name="c", sym="strlen", fn_name="count") ``` This will instrument ```strlen()``` function from libc, and call our BPF function ```count()``` when it returns. Other examples: ```Python b.attach_uprobe(name="c", sym="getaddrinfo", fn_name="do_entry") b.attach_uprobe(name="/usr/bin/python", sym="main", fn_name="do_main") ``` You can call attach_uretprobe() more than once, and attach your BPF function to multiple user-level functions. See the previous uretprobes section for how to instrument the return value from BPF. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=attach_uretprobe+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=attach_uretprobe+path%3Atools+language%3Apython&type=Code) ### 6. USDT.enable_probe() Syntax: ```USDT.enable_probe(probe=probe, fn_name=name)``` Attaches a BPF C function ```name``` to the USDT probe ```probe```. Example: ```Python # enable USDT probe from given PID u = USDT(pid=int(pid)) u.enable_probe(probe="http__server__request", fn_name="do_trace") ``` To check if your binary has USDT probes, and what they are, you can run ```readelf -n binary``` and check the stap debug section. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=enable_probe+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=enable_probe+path%3Atools+language%3Apython&type=Code) ## Debug Output ### 1. trace_print() Syntax: ```BPF.trace_print(fmt="fields")``` This method continually reads the globally shared /sys/kernel/debug/tracing/trace_pipe file and prints its contents. This file can be written to via BPF and the bpf_trace_printk() function, however, that method has limitations, including a lack of concurrent tracing support. The BPF_PERF_OUTPUT mechanism, covered earlier, is preferred. Arguments: - ```fmt```: optional, and can contain a field formatting string. It defaults to ```None```. Examples: ```Python # print trace_pipe output as-is: b.trace_print() # print PID and message: b.trace_print(fmt="{1} {5}") ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=trace_print+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=trace_print+path%3Atools+language%3Apython&type=Code) ### 2. trace_fields() Syntax: ```BPF.trace_fields(nonblocking=False)``` This method reads one line from the globally shared /sys/kernel/debug/tracing/trace_pipe file and returns it as fields. This file can be written to via BPF and the bpf_trace_printk() function, however, that method has limitations, including a lack of concurrent tracing support. The BPF_PERF_OUTPUT mechanism, covered earlier, is preferred. Arguments: - ```nonblocking```: optional, defaults to ```False```. When set to ```True```, the program will not block waiting for input. Examples: ```Python while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue [...] ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=trace_print+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=trace_print+path%3Atools+language%3Apython&type=Code) ## Output Normal output from a BPF program is either: - per-event: using PERF_EVENT_OUTPUT, open_perf_buffer(), and kprobe_poll(). - map summary: using items(), or print_log2_hist(), covered in the Maps section. ### 1. kprobe_poll() Syntax: ```BPF.kprobe_poll()``` This polls from the ring buffers for all of the open kprobes, calling the callback function that was given in the BPF constructor for each entry, usually via ```open_perf_buffer()```. Example: ```Python # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() ``` Examples in situ: [code](https://github.com/iovisor/bcc/blob/08fbceb7e828f0e3e77688497727c5b2405905fd/examples/tracing/hello_perf_output.py#L61), [search /examples](https://github.com/iovisor/bcc/search?q=kprobe_poll+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=kprobe_poll+path%3Atools+language%3Apython&type=Code) ## Maps Maps are BPF data stores, and are used in bcc to implement a table, and then higher level objects on top of tables, including hashes and histograms. ### 1. get_table() Syntax: ```BPF.get_table(name)``` Returns a table object. This is no longer used, as tables can now be read as items from BPF. Eg: ```BPF[name]```. Examples: ```Python counts = b.get_table("counts") counts = b["counts"] ``` These are equivalent. ### 2. open_perf_buffer() Syntax: ```table.open_perf_buffers(callback)``` This operates on a table as defined in BPF as BPF_PERF_OUTPUT(), and associates the callback Python function ```callback``` to be called when data is available in the perf ring buffer. This is part of the recommended mechanism for transferring per-event data from kernel to user space. Example: ```Python # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents [...] # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() ``` Note that the data structure transferred will need to be declared in C in the BPF program, and in Python. For example: ```C // define output data structure in C struct data_t { u32 pid; u64 ts; char comm[TASK_COMM_LEN]; }; ``` ```Python # define output data structure in Python TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [("pid", ct.c_ulonglong), ("ts", ct.c_ulonglong), ("comm", ct.c_char * TASK_COMM_LEN)] ``` Perhaps in a future bcc version, the Python data structure will be automatically generated from the C declaration. Examples in situ: [code](https://github.com/iovisor/bcc/blob/08fbceb7e828f0e3e77688497727c5b2405905fd/examples/tracing/hello_perf_output.py#L59), [search /examples](https://github.com/iovisor/bcc/search?q=open_perf_buffer+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=open_perf_buffer+path%3Atools+language%3Apython&type=Code) ### 3. items() Syntax: ```table.items()``` Returns an array of the keys in a table. This can be used with BPF_HASH maps to fetch, and iterate, over the keys. Example: ```Python # print output print("%10s %s" % ("COUNT", "STRING")) counts = b.get_table("counts") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): print("%10d \"%s\"" % (v.value, k.c.encode('string-escape'))) ``` This example also uses the ```sorted()``` method to sort by value. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=clear+items%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=clear+items%3Atools+language%3Apython&type=Code) ### 4. values() Syntax: ```table.values()``` Returns an array of the values in a table. ### 5. clear() Syntax: ```table.clear()``` Clears the table: deletes all entries. Example: ```Python # print map summary every second: while True: time.sleep(1) print("%-8s\n" % time.strftime("%H:%M:%S"), end="") dist.print_log2_hist(sym + " return:") dist.clear() ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=clear+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=clear+path%3Atools+language%3Apython&type=Code) ### 6. print_log2_hist() Syntax: ```table.print_log2_hist(val_type="value", section_header="Bucket ptr", section_print_fn=None)``` Prints a table as a log2 histogram in ASCII. The table must be stored as log2, which can be done using the BPF function ```bpf_log2l()```. Arguments: - val_type: optional, column header. - section_header: if the histogram has a secondary key, multiple tables will print and section_header can be used as a header description for each. - section_print_fn: if section_print_fn is not None, it will be passed the bucket value. Example: ```Python b = BPF(text=""" BPF_HISTOGRAM(dist); int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) { dist.increment(bpf_log2l(req->__data_len / 1024)); return 0; } """) [...] b["dist"].print_log2_hist("kbytes") ``` Output: ``` kbytes : count distribution 0 -> 1 : 3 | | 2 -> 3 : 0 | | 4 -> 7 : 211 |********** | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 800 |**************************************| ``` This output shows a multi-modal distribution, with the largest mode of 128->255 kbytes and a count of 800. This is an efficient way to summarize data, as the summarization is performed in-kernel, and only the count column is passed to user space. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=print_log2_hist+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=print_log2_hist+path%3Atools+language%3Apython&type=Code) ### 6. print_linear_hist() Syntax: ```table.print_linear_hist(val_type="value", section_header="Bucket ptr", section_print_fn=None)``` Prints a table as a linear histogram in ASCII. This is intended to visualize small integer ranges, eg, 0 to 100. Arguments: - val_type: optional, column header. - section_header: if the histogram has a secondary key, multiple tables will print and section_header can be used as a header description for each. - section_print_fn: if section_print_fn is not None, it will be passed the bucket value. Example: ```Python b = BPF(text=""" BPF_HISTOGRAM(dist); int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) { dist.increment(req->__data_len / 1024); return 0; } """) [...] b["dist"].print_linear_hist("kbytes") ``` Output: ``` kbytes : count distribution 0 : 3 |****** | 1 : 0 | | 2 : 0 | | 3 : 0 | | 4 : 19 |****************************************| 5 : 0 | | 6 : 0 | | 7 : 0 | | 8 : 4 |******** | 9 : 0 | | 10 : 0 | | 11 : 0 | | 12 : 0 | | 13 : 0 | | 14 : 0 | | 15 : 0 | | 16 : 2 |**** | [...] ``` This is an efficient way to summarize data, as the summarization is performed in-kernel, and only the values in the count column are passed to user space. Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=print_linear_hist+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=print_linear_hist+path%3Atools+language%3Apython&type=Code) ## Helpers Some helper methods provided by bcc. Note that since we're in Python, we can import any Python library and their methods, including, for example, the libraries: argparse, collections, ctypes, datetime, re, socket, struct, subprocess, sys, and time. ### 1. ksym() Syntax: ```BPF.ksym(addr)``` Translate a kernel memory address into a kernel function name, which is returned. Example: ```Python print("kernel function: " + b.ksym(addr)) ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=ksym+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=ksym+path%3Atools+language%3Apython&type=Code) ### 2. ksymname() Syntax: ```BPF.ksymname(name)``` Translate a kernel name into an address. This is the reverse of ksym. Returns -1 when the function name is unknown. Example: ```Python print("kernel address: %x" % b.ksymname("vfs_read")) ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=ksymname+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=ksymname+path%3Atools+language%3Apython&type=Code) ### 3. sym() Syntax: ```BPF.sym(addr, pid, show_module=False, show_offset=False)``` Translate a memory address into a function name for a pid, which is returned. A pid of less than zero will access the kernel symbol cache. The `show_module` and `show_offset` parameters control whether the module in which the symbol lies should be displayed, and whether the instruction offset from the beginning of the symbol should be displayed. These extra parameters default to `False`. Example: ```Python print("function: " + b.sym(addr, pid)) ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=sym+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=sym+path%3Atools+language%3Apython&type=Code) ### 4. num_open_kprobes() Syntax: ```BPF.num_open_kprobes()``` Returns the number of open k[ret]probes. Can be useful for scenarios where event_re is used while attaching and detaching probes. Excludes perf_events readers. Example: ```Python b.attach_kprobe(event_re=pattern, fn_name="trace_count") matched = b.num_open_kprobes() if matched == 0: print("0 functions matched by \"%s\". Exiting." % args.pattern) exit() ``` Examples in situ: [search /examples](https://github.com/iovisor/bcc/search?q=num_open_kprobes+path%3Aexamples+language%3Apython&type=Code), [search /tools](https://github.com/iovisor/bcc/search?q=num_open_kprobes+path%3Atools+language%3Apython&type=Code) # BPF Errors See the "Understanding eBPF verifier messages" section in the kernel source under Documentation/networking/filter.txt. ## 1. Invalid mem access This can be due to trying to read memory directly, instead of operating on memory on the BPF stack. All memory reads must be passed via bpf_probe_read() to copy memory into the BPF stack, which can be automatic by the bcc rewriter in some cases of simple dereferencing. bpf_probe_read() does all the required checks. Example: ``` bpf: Permission denied 0: (bf) r6 = r1 1: (79) r7 = *(u64 *)(r6 +80) 2: (85) call 14 3: (bf) r8 = r0 [...] 23: (69) r1 = *(u16 *)(r7 +16) R7 invalid mem access 'inv' Traceback (most recent call last): File "./tcpaccept", line 179, in b = BPF(text=bpf_text) File "/usr/lib/python2.7/dist-packages/bcc/__init__.py", line 172, in __init__ self._trace_autoload() File "/usr/lib/python2.7/dist-packages/bcc/__init__.py", line 612, in _trace_autoload fn = self.load_func(func_name, BPF.KPROBE) File "/usr/lib/python2.7/dist-packages/bcc/__init__.py", line 212, in load_func raise Exception("Failed to load BPF program %s" % func_name) Exception: Failed to load BPF program kretprobe__inet_csk_accept ``` bpfcc-0.2.0+git0.02884a026/docs/tutorial.md000066400000000000000000000317421305314114400176220ustar00rootroot00000000000000# bcc Tutorial This tutorial covers how to use [bcc](https://github.com/iovisor/bcc) tools to quickly solve performance, troubleshooting, and networking issues. If you want to develop new bcc tools, see [tutorial_bcc_python_developer.md](tutorial_bcc_python_developer.md) for that tutorial. It is assumed for this tutorial that bcc is already installed, and you can run tools like execsnoop successfully. See [INSTALL.md](../INSTALL.md). This uses enhancements added to the Linux 4.x series. ## Observability Some quick wins. ### 0. Before bcc Before using bcc, you should start with the Linux basics. One reference is the [Linux Performance Analysis in 60s](http://techblog.netflix.com/2015/11/linux-performance-analysis-in-60s.html) post, which covers these commands: 1. uptime 1. dmesg | tail 1. vmstat 1 1. mpstat -P ALL 1 1. pidstat 1 1. iostat -xz 1 1. free -m 1. sar -n DEV 1 1. sar -n TCP,ETCP 1 1. top ### 1. General Performance Here is a generic checklist for performance investigations with bcc, first as a list, then in detail: 1. execsnoop 1. opensnoop 1. ext4slower (or btrfs\*, xfs\*, zfs\*) 1. biolatency 1. biosnoop 1. cachestat 1. tcpconnect 1. tcpaccept 1. tcpretrans 1. runqlat 1. profile These tools may be installed on your system under /usr/share/bcc/tools, or you can run them from the bcc github repo under /tools where they have a .py extension. Browse the 50+ tools available for more analysis options. #### 1. execsnoop ``` # ./execsnoop PCOMM PID RET ARGS supervise 9660 0 ./run supervise 9661 0 ./run mkdir 9662 0 /bin/mkdir -p ./main run 9663 0 ./run [...] ``` execsnoop prints one line of output for each new process. Check for short-lived processes. These can consume CPU resources, but not show up in most monitoring tools that periodically take snapshots of which processes are running. It works by tracing exec(), not the fork(), so it will catch many types of new processes but not all (eg, it won't see an application launching working processes, that doesn't exec() anything else). More [examples](../tools/execsnoop_example.txt). #### 2. opensnoop ``` # ./opensnoop PID COMM FD ERR PATH 1565 redis-server 5 0 /proc/1565/stat 1565 redis-server 5 0 /proc/1565/stat 1565 redis-server 5 0 /proc/1565/stat 1603 snmpd 9 0 /proc/net/dev 1603 snmpd 11 0 /proc/net/if_inet6 1603 snmpd -1 2 /sys/class/net/eth0/device/vendor 1603 snmpd 11 0 /proc/sys/net/ipv4/neigh/eth0/retrans_time_ms 1603 snmpd 11 0 /proc/sys/net/ipv6/neigh/eth0/retrans_time_ms 1603 snmpd 11 0 /proc/sys/net/ipv6/conf/eth0/forwarding [...] ``` opensnoop prints one line of output for each open() syscall, including details. Files that are opened can tell you a lot about how applications work: identifying their data files, config files, and log files. Sometimes applications can misbehave, and perform poorly, when they are constantly attempting to read files that do not exist. opensnoop gives you a quick look. More [examples](../tools/opensnoop_example.txt). #### 3. ext4slower (or btrfs\*, xfs\*, zfs\*) ``` # ./ext4slower Tracing ext4 operations slower than 10 ms TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME 06:35:01 cron 16464 R 1249 0 16.05 common-auth 06:35:01 cron 16463 R 1249 0 16.04 common-auth 06:35:01 cron 16465 R 1249 0 16.03 common-auth 06:35:01 cron 16465 R 4096 0 10.62 login.defs 06:35:01 cron 16464 R 4096 0 10.61 login.defs ``` ext4slower traces the ext4 file system and times common operations, and then only prints those that exceed a threshold. This is great for identifying or exonerating one type of performance issue: slow individually slow disk i/O via the file system. Disks process I/O asynchronously, and it can be difficult to associate latency at that layer with the latency applications experience. Tracing higher up in the kernel stack, at the VFS -> file system interface, will more closely match what an application suffers. Use this tool to identify if file system latency exceeds a given threshold. Similar tools exist in bcc for other file systems: btrfsslower, xfsslower, and zfsslower. There is also fileslower, which works at the VFS layer and traces everything (although at some higher overhead). More [examples](../tools/ext4slower_example.txt). #### 4. biolatency ``` # ./biolatency Tracing block device I/O... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 12 |******** | 256 -> 511 : 15 |********** | 512 -> 1023 : 43 |******************************* | 1024 -> 2047 : 52 |**************************************| 2048 -> 4095 : 47 |********************************** | 4096 -> 8191 : 52 |**************************************| 8192 -> 16383 : 36 |************************** | 16384 -> 32767 : 15 |********** | 32768 -> 65535 : 2 |* | 65536 -> 131071 : 2 |* | ``` biolatency traces disk I/O latency (time from device issue to completion), and when the tool ends (Ctrl-C, or a given interval), it prints a histogram summary of the latency. This is great for understanding disk I/O latency beyond the average times given by tools like iostat. I/O latency outliers will be visible at the end of the distribution, as well as multi-mode distributions. More [examples](../tools/biolatency_example.txt). #### 5. biosnoop ``` # ./biosnoop TIME(s) COMM PID DISK T SECTOR BYTES LAT(ms) 0.000004001 supervise 1950 xvda1 W 13092560 4096 0.74 0.000178002 supervise 1950 xvda1 W 13092432 4096 0.61 0.001469001 supervise 1956 xvda1 W 13092440 4096 1.24 0.001588002 supervise 1956 xvda1 W 13115128 4096 1.09 1.022346001 supervise 1950 xvda1 W 13115272 4096 0.98 1.022568002 supervise 1950 xvda1 W 13188496 4096 0.93 [...] ``` biosnoop prints a line of output for each disk I/O, with details including latency (time from device issue to completion). This allows you to examine disk I/O in more detail, and look for time-ordered patterns (eg, reads queueing behind writes). Note that the output will be verbose if your system performance a high rate of disk I/O. More [examples](../tools/biosnoop_example.txt). #### 6. cachestat ``` # ./cachestat HITS MISSES DIRTIES READ_HIT% WRITE_HIT% BUFFERS_MB CACHED_MB 1074 44 13 94.9% 2.9% 1 223 2195 170 8 92.5% 6.8% 1 143 182 53 56 53.6% 1.3% 1 143 62480 40960 20480 40.6% 19.8% 1 223 7 2 5 22.2% 22.2% 1 223 348 0 0 100.0% 0.0% 1 223 [...] ``` cachestat prints a one line summary every second (or every custom interval) showing statistics from the file system cache. Use this to identify a low cache hit ratio, and a high rate of misses: which gives one lead for performance tuning. More [examples](../tools/cachestat_example.txt). #### 7. tcpconnect ``` # ./tcpconnect PID COMM IP SADDR DADDR DPORT 1479 telnet 4 127.0.0.1 127.0.0.1 23 1469 curl 4 10.201.219.236 54.245.105.25 80 1469 curl 4 10.201.219.236 54.67.101.145 80 1991 telnet 6 ::1 ::1 23 2015 ssh 6 fe80::2000:bff:fe82:3ac fe80::2000:bff:fe82:3ac 22 [...] ``` tcpconnect prints one line of output for every active TCP connection (eg, via connect()), with details including source and destination addresses. Look for unexpected connections that may point to inefficiencies in application configuration, or an intruder. More [examples](../tools/tcpconnect_example.txt). #### 8. tcpaccept ``` # ./tcpaccept PID COMM IP RADDR LADDR LPORT 907 sshd 4 192.168.56.1 192.168.56.102 22 907 sshd 4 127.0.0.1 127.0.0.1 22 5389 perl 6 1234:ab12:2040:5020:2299:0:5:0 1234:ab12:2040:5020:2299:0:5:0 7001 [...] ``` tcpaccept prints one line of output for every passive TCP connection (eg, via accept()), with details including source and destination addresses. Look for unexpected connections that may point to inefficiencies in application configuration, or an intruder. More [examples](../tools/tcpaccept_example.txt). #### 9. tcpretrans ``` # ./tcpretrans TIME PID IP LADDR:LPORT T> RADDR:RPORT STATE 01:55:05 0 4 10.153.223.157:22 R> 69.53.245.40:34619 ESTABLISHED 01:55:05 0 4 10.153.223.157:22 R> 69.53.245.40:34619 ESTABLISHED 01:55:17 0 4 10.153.223.157:22 R> 69.53.245.40:22957 ESTABLISHED [...] ``` tcprerans prints one line of output for every TCP retransmit packet, with details including source and destination addresses, and kernel state of the TCP connection. TCP retransmissions cause latency and throughput issues. For ESTABLESHID retransmits, look for patterns with networks. For SYN_SENT, this may point to target kernel CPU saturation and kernel packet drops. More [examples](../tools/tcpretrans_example.txt). #### 10. runqlat ``` # ./runqlat Tracing run queue latency... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 233 |*********** | 2 -> 3 : 742 |************************************ | 4 -> 7 : 203 |********** | 8 -> 15 : 173 |******** | 16 -> 31 : 24 |* | 32 -> 63 : 0 | | 64 -> 127 : 30 |* | 128 -> 255 : 6 | | 256 -> 511 : 3 | | 512 -> 1023 : 5 | | 1024 -> 2047 : 27 |* | 2048 -> 4095 : 30 |* | 4096 -> 8191 : 20 | | 8192 -> 16383 : 29 |* | 16384 -> 32767 : 809 |****************************************| 32768 -> 65535 : 64 |*** | ``` runqlat times how long threads were waiting on the CPU run queues, and prints this as a histogram. This can help quantify time lost waiting for a turn on CPU, during periods of CPU saturation. More [examples](../tools/runqlat_example.txt). #### 11. profile ``` # ./profile Sampling at 49 Hertz of all threads by user + kernel stack... Hit Ctrl-C to end. ^C 00007f31d76c3251 [unknown] 47a2c1e752bf47f7 [unknown] - sign-file (8877) 1 ffffffff813d0af8 __clear_user ffffffff813d5277 iov_iter_zero ffffffff814ec5f2 read_iter_zero ffffffff8120be9d __vfs_read ffffffff8120c385 vfs_read ffffffff8120d786 sys_read ffffffff817cc076 entry_SYSCALL_64_fastpath 00007fc5652ad9b0 read - dd (25036) 4 0000000000400542 func_a 0000000000400598 main 00007f12a133e830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (13549) 5 [...] ffffffff8105eb66 native_safe_halt ffffffff8103659e default_idle ffffffff81036d1f arch_cpu_idle ffffffff810bba5a default_idle_call ffffffff810bbd07 cpu_startup_entry ffffffff8104df55 start_secondary - swapper/1 (0) 75 ``` profile is a CPU profiler, which takes samples of stack traces at timed intervals, and prints a summary of unique stack traces and a count of their occurrence. Use this tool to understand the code paths that are consuming CPU resources. More [examples](../tools/profile_example.txt). ## Networking To do. bpfcc-0.2.0+git0.02884a026/docs/tutorial_bcc_python_developer.md000066400000000000000000000722751305314114400241050ustar00rootroot00000000000000# bcc Python Developer Tutorial This tutorial is about developing [bcc](https://github.com/iovisor/bcc) tools and programs using the Python interface. There are two parts: observability then networking. Snippets are taken from various programs in bcc: see their files for licences. Also see the bcc developer's [reference_guide.md](reference_guide.md), and a tutorial for end-users of tools: [tutorial.md](tutorial.md). There is also a lua interface for bcc. ## Observability This observability tutorial contains 17 lessons, and 46 enumerated things to learn. ### Lesson 1. Hello World Start by running [examples/hello_world.py](../examples/hello_world.py), while running some commands (eg, "ls") in another session. It should print "Hello, World!" for new processes. If not, start by fixing bcc: see [INSTALL.md](../INSTALL.md). ``` # ./examples/hello_world.py bash-13364 [002] d... 24573433.052937: : Hello, World! bash-13364 [003] d... 24573436.642808: : Hello, World! [...] ``` Here's the code for hello_world.py: ```Python from bcc import BPF BPF(text='int kprobe__sys_clone(void *ctx) { bpf_trace_printk("Hello, World!\\n"); return 0; }').trace_print() ``` There are six things to learn from this: 1. ```text='...'```: This defines a BPF program inline. The program is written in C. 1. ```kprobe__sys_clone()```: This is a short-cut for kernel dynamic tracing via kprobes. If the C function begins with ``kprobe__``, the rest is treated as a kernel function name to instrument, in this case, ```sys_clone()```. 1. ```void *ctx```: ctx has arguments, but since we aren't using them here, we'll just cast it to ```void *```. 1. ```bpf_trace_printk()```: A simple kernel facility for printf() to the common trace_pipe (/sys/kernel/debug/tracing/trace_pipe). This is ok for some quick examples, but has limitations: 3 args max, 1 %s only, and trace_pipe is globally shared, so concurrent programs will have clashing output. A better interface is via BPF_PERF_OUTPUT(), covered later. 1. ```return 0;```: Necessary formality (if you want to know why, see [#139](https://github.com/iovisor/bcc/issues/139)). 1. ```.trace_print()```: A bcc routine that reads trace_pipe and prints the output. ### Lesson 2. sys_sync() Write a program that traces the sys_sync() kernel function. Print "sys_sync() called" when it runs. Test by running ```sync``` in another session while tracing. The hello_world.py program has everything you need for this. Improve it by printing "Tracing sys_sync()... Ctrl-C to end." when the program first starts. Hint: it's just Python. ### Lesson 3. hello_fields.py This program is in [examples/tracing/hello_fields.py](../examples/tracing/trace_fields.py). Sample output (run commands in another session): ``` # ./examples/tracing/hello_fields.py TIME(s) COMM PID MESSAGE 24585001.174885999 sshd 1432 Hello, World! 24585001.195710000 sshd 15780 Hello, World! 24585001.991976000 systemd-udevd 484 Hello, World! 24585002.276147000 bash 15787 Hello, World! ``` Code: ```Python from bcc import BPF # define BPF program prog = """ int hello(void *ctx) { bpf_trace_printk("Hello, World!\\n"); return 0; } """ # load BPF program b = BPF(text=prog) b.attach_kprobe(event="sys_clone", fn_name="hello") # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "MESSAGE")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) ``` This is similar to hello_world.py, and traces new processes via sys_clone() again, but has a few more things to learn: 1. ```prog =```: This time we declare the C program as a variable, and later refer to it. This is useful if you want to add some string substitutions based on command line arguments. 1. ```hello()```: Now we're just declaring a C function, instead of the ```kprobe__``` shortcut. We'll refer to this later. All C functions declared in the BPF program are expected to be executed on a probe, hence they all need to take a ```pt_reg* ctx``` as first argument. If you need to define some helper function that will not be executed on a probe, they need to be defined as ```static inline``` in order to be inlined by the compiler. Sometimes you would also need to add ```_always_inline``` function attribute to it. 1. ```b.attach_kprobe(event="sys_clone", fn_name="hello")```: Creates a kprobe for the sys_clone() kernel function, which will execute our defined hello() function. You can call attach_kprobe() more than once, and attach your C function to multiple kernel functions. 1. ```b.trace_fields()```: Returns a fixed set of fields from trace_pipe. Simalar to trace_print(), this is handy for hacking, but for real tooling we should switch to BPF_PERF_OUTPUT(). ### Lesson 4. sync_timing.py Remember the days of sysadmins typing ```sync``` three times on a slow console before ```reboot```, to give the first asynchronous sync time to complete? Then someone thought ```sync;sync;sync``` was clever, to run them all on one line, which became industry practice despite defeating the original purpose! And then sync became synchronous, so more reasons it was silly. Anyway. The following example times how quickly the ```do_sync``` function is called, and prints output if it has been called more recently than one second ago. A ```sync;sync;sync``` will print output for the 2nd and 3rd sync's: ``` # ./examples/tracing/sync_timing.py Tracing for quick sync's... Ctrl-C to end At time 0.00 s: multiple syncs detected, last 95 ms ago At time 0.10 s: multiple syncs detected, last 96 ms ago ``` This program is [examples/tracing/sync_timing.py](../examples/tracing/sync_timing.py): ```Python from bcc import BPF # load BPF program b = BPF(text=""" #include #include BPF_HASH(last); void do_trace(struct pt_regs *ctx) { u64 ts, *tsp, delta, key = 0; // attempt to read stored timestamp tsp = last.lookup(&key); if (tsp != 0) { delta = bpf_ktime_get_ns() - *tsp; if (delta < 1000000000) { // output if time is less than 1 second bpf_trace_printk("%d\\n", delta / 1000000); } last.delete(&key); } // update stored timestamp ts = bpf_ktime_get_ns(); last.update(&key, &ts); } """) b.attach_kprobe(event="sys_sync", fn_name="do_trace") print("Tracing for quick sync's... Ctrl-C to end") # format output start = 0 while 1: (task, pid, cpu, flags, ts, ms) = b.trace_fields() if start == 0: start = ts ts = ts - start print("At time %.2f s: multiple syncs detected, last %s ms ago" % (ts, ms)) ``` Things to learn: 1. ```bpf_ktime_get_ns()```: Returns the time as nanoseconds. 1. ```BPF_HASH(last)```: Creates a BPF map object that is a hash (associative array), called "last". We didn't specify any further arguments, so it defaults to key and value types of u64. 1. ```key = 0```: We'll only store one key/value pair in this hash, where the key is hardwired to zero. 1. ```last.lookup(&key)```: Lookup the key in the hash, and return a pointer to its value if it exists, else NULL. We pass the key in as an address to a pointer. 1. ```last.delete(&key)```: Delete the key from the hash. This is currently required because of [a kernel bug in `.update()`](https://git.kernel.org/cgit/linux/kernel/git/davem/net.git/commit/?id=a6ed3ea65d9868fdf9eff84e6fe4f666b8d14b02). 1. ```last.update(&key, &ts)```: Associate the value in the 2nd argument to the key, overwriting any previous value. This records the timestamp. ### Lesson 5. sync_count.py Modify the sync_timing.py program (prior lesson) to store the count of all sys_sync() calls (both fast and slow), and print it with the output. This count can be recorded in the BPF program by adding a new key index to the existing hash. ### Lesson 6. disksnoop.py Browse the [examples/tracing/disksnoop.py](../examples/tracing/disksnoop.py) program to see what is new. Here is some sample output: ``` # ./disksnoop.py TIME(s) T BYTES LAT(ms) 16458043.436012 W 4096 3.13 16458043.437326 W 4096 4.44 16458044.126545 R 4096 42.82 16458044.129872 R 4096 3.24 [...] ``` And a code snippet: ```Python [...] REQ_WRITE = 1 # from include/linux/blk_types.h # load BPF program b = BPF(text=""" #include #include BPF_HASH(start, struct request *); void trace_start(struct pt_regs *ctx, struct request *req) { // stash start timestamp by request ptr u64 ts = bpf_ktime_get_ns(); start.update(&req, &ts); } void trace_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp, delta; tsp = start.lookup(&req); if (tsp != 0) { delta = bpf_ktime_get_ns() - *tsp; bpf_trace_printk("%d %x %d\\n", req->__data_len, req->cmd_flags, delta / 1000); start.delete(&req); } } """) b.attach_kprobe(event="blk_start_request", fn_name="trace_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_start") b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_completion") [...] ``` Things to learn: 1. ```REQ_WRITE```: We're defining a kernel constant in the Python program because we'll use it there later. If we were using REQ_WRITE in the BPF program, it should just work (without needing to be defined) with the appropriate #includes. 1. ```trace_start(struct pt_regs *ctx, struct request *req)```: This function will later be attached to kprobes. The arguments to kprobe functions are ```struct pt_regs *ctx```, for registers and BPF context, and then the actual arguments to the function. We'll attach this to blk_start_request(), where the first argument is ```struct request *```. 1. ```start.update(&req, &ts)```: We're using the pointer to the request struct as a key in our hash. What? This is commonplace in tracing. Pointers to structs turn out to be great keys, as they are unique: two structs can't have the same pointer address. (Just be careful about when it gets free'd and reused.) So what we're really doing is tagging the request struct, which describes the disk I/O, with our own timestamp, so that we can time it. There's two common keys used for storing timestamps: pointers to structs, and, thread IDs (for timing function entry to return). 1. ```req->__data_len```: We're dereferencing members of ```struct request```. See its definition in the kernel source for what members are there. bcc actually rewrites these expressions to be a series of ```bpf_probe_read()``` calls. Sometimes bcc can't handle a complex dereference, and you need to call ```bpf_probe_read()``` directly. This is a pretty interesting program, and if you can understand all the code, you'll understand many important basics. We're still using the bpf_trace_printk() hack, so let's fix that next. ### Lesson 7. hello_perf_output.py Let's finally stop using bpf_trace_printk() and use the proper BPF_PERF_OUTPUT() interface. This will also mean we stop getting the free trace_field() members like PID and timestamp, and will need to fetch them directly. Sample output while commands are run in another session: ``` # ./hello_perf_output.py TIME(s) COMM PID MESSAGE 0.000000000 bash 22986 Hello, perf_output! 0.021080275 systemd-udevd 484 Hello, perf_output! 0.021359520 systemd-udevd 484 Hello, perf_output! 0.021590610 systemd-udevd 484 Hello, perf_output! [...] ``` Code is [examples/tracing/hello_perf_output.py](../examples/tracing/hello_perf_output.py): ```Python from bcc import BPF import ctypes as ct # define BPF program prog = """ #include // define output data structure in C struct data_t { u32 pid; u64 ts; char comm[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(events); int hello(struct pt_regs *ctx) { struct data_t data = {}; data.pid = bpf_get_current_pid_tgid(); data.ts = bpf_ktime_get_ns(); bpf_get_current_comm(&data.comm, sizeof(data.comm)); events.perf_submit(ctx, &data, sizeof(data)); return 0; } """ # load BPF program b = BPF(text=prog) b.attach_kprobe(event="sys_clone", fn_name="hello") # define output data structure in Python TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [("pid", ct.c_ulonglong), ("ts", ct.c_ulonglong), ("comm", ct.c_char * TASK_COMM_LEN)] # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "MESSAGE")) # process event start = 0 def print_event(cpu, data, size): global start event = ct.cast(data, ct.POINTER(Data)).contents if start == 0: start = event.ts time_s = (float(event.ts - start)) / 1000000000 print("%-18.9f %-16s %-6d %s" % (time_s, event.comm, event.pid, "Hello, perf_output!")) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() ``` Things to learn: 1. ```struct data_t```: This defines the C struct we'll use to pass data from kernel to user space. 1. ```BPF_PERF_OUTPUT(events)```: This names our output channel "events". 1. ```struct data_t data = {};```: Create an empty data_t struct that we'll then populate. 1. ```bpf_get_current_pid_tgid()```: Returns the process ID in the lower 32 bits (kernel's view of the PID, which in user space is usually presented as the thread ID), and the thread group ID in the upper 32 bits (what user space often thinks of as the PID). By directly setting this to a u32, we discard the upper 32 bits. Should you be presenting the PID or the TGID? For a multi-threaded app, the TGID will be the same, so you need the PID to differentiate them, if that's what you want. It's also a question of expectations for the end user. 1. ```bpf_get_current_comm()```: Populates the first argument address with the current process name. 1. ```events.perf_submit()```: Submit the event for user space to read via a perf ring buffer. 1. ```class Data(ct.Structure)```: Now define the Python version of the C data structure. 1. ```def print_event()```: Define a Python function that will handle reading events from the ```events``` stream. 1. ```b["events"].open_perf_buffer(print_event)```: Associate the Python ```print_event``` function with the ```events``` stream. 1. ```while 1: b.kprobe_poll()```: Block waiting for events. This may be improved in future bcc versions. Eg, the Python data struct could be auto-generated from the C code. ### Lesson 8. sync_perf_output.py Rewrite sync_timing.py, from a prior lesson, to use ```BPF_PERF_OUTPUT```. ### Lesson 9. bitesize.py The following tool records a histogram of disk I/O sizes. Sample output: ``` # ./bitehist.py Tracing... Hit Ctrl-C to end. ^C kbytes : count distribution 0 -> 1 : 3 | | 2 -> 3 : 0 | | 4 -> 7 : 211 |********** | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 800 |**************************************| ``` Code is [examples/tracing/bitesize.py](../examples/tracing/bitesize.py): ```Python from bcc import BPF from time import sleep # load BPF program b = BPF(text=""" #include #include BPF_HISTOGRAM(dist); int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) { dist.increment(bpf_log2l(req->__data_len / 1024)); return 0; } """) # header print("Tracing... Hit Ctrl-C to end.") # trace until Ctrl-C try: sleep(99999999) except KeyboardInterrupt: print # output b["dist"].print_log2_hist("kbytes") ``` A recap from earlier lessons: - ```kprobe__```: This prefix means the rest will be treated as a kernel function name that will be instrumented using kprobe. - ```struct pt_regs *ctx, struct request *req```: Arguments to kprobe. The ```ctx``` is registers and BPF context, the ```req``` is the first argument to the instrumented function: ```blk_account_io_completion()```. - ```req->__data_len```: Dereferencing that member. New things to learn: 1. ```BPF_HISTOGRAM(dist)```: Defines a BPF map object that is a histogram, and names it "dist". 1. ```dist.increment()```: Increments the histogram bucket index provided as an argument by one. 1. ```bpf_log2l()```: Returns the log-2 of the provided value. This becomes the index of our histogram, so that we're constructing a power-of-2 histogram. 1. ```b["dist"].print_log2_hist("kbytes")```: Prints the "dist" histogram as power-of-2, with a column header of "kbytes". The only data transferred from kernel to user space is the bucket counts, making this efficient. ### Lesson 10. disklatency.py Write a program that times disk I/O, and prints a histogram of their latency. Disk I/O instrumentation and timing can be found in the disksnoop.py program from a prior lesson, and histogram code can be found in bitesize.py from a prior lesson. ### Lesson 11. vfsreadlat.py This example is split into separate Python and C files. Example output: ``` # ./vfsreadlat.py 1 Tracing... Hit Ctrl-C to end. usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 2 |*********** | 4 -> 7 : 7 |****************************************| 8 -> 15 : 4 |********************** | usecs : count distribution 0 -> 1 : 29 |****************************************| 2 -> 3 : 28 |************************************** | 4 -> 7 : 4 |***** | 8 -> 15 : 8 |*********** | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 2 |** | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 4 |***** | 8192 -> 16383 : 6 |******** | 16384 -> 32767 : 9 |************ | 32768 -> 65535 : 6 |******** | 65536 -> 131071 : 2 |** | usecs : count distribution 0 -> 1 : 11 |****************************************| 2 -> 3 : 2 |******* | 4 -> 7 : 10 |************************************ | 8 -> 15 : 8 |***************************** | 16 -> 31 : 1 |*** | 32 -> 63 : 2 |******* | [...] ``` Browse the code in [examples/tracing/vfsreadlat.py](../examples/tracing/vfsreadlat.py) and [examples/tracing/vfsreadlat.c](../examples/tracing/vfsreadlat.c). Things to learn: 1. ```b = BPF(src_file = "vfsreadlat.c")```: Read the BPF C program from a separate source file. 1. ```b.attach_kretprobe(event="vfs_read", fn_name="do_return")```: Attaches the BPF C function ```do_return()``` to the return of the kernel function ```vfs_read()```. This is a kretprobe: instrumenting the return from a function, rather than its entry. 1. ```b["dist"].clear()```: Clears the histogram. ### Lesson 12. urandomread.py Tracing while a ```dd if=/dev/urandom of=/dev/null bs=8k count=5``` is run: ``` # ./urandomread.py TIME(s) COMM PID GOTBITS 24652832.956994001 smtp 24690 384 24652837.726500999 dd 24692 65536 24652837.727111001 dd 24692 65536 24652837.727703001 dd 24692 65536 24652837.728294998 dd 24692 65536 24652837.728888001 dd 24692 65536 ``` Hah! I caught smtp by accident. Code is [examples/tracing/urandomread.py](../examples/tracing/urandomread.py): ```Python from bcc import BPF # load BPF program b = BPF(text=""" TRACEPOINT_PROBE(random, urandom_read) { // args is from /sys/kernel/debug/tracing/events/random/urandom_read/format bpf_trace_printk("%d\\n", args->got_bits); return 0; }; """) # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "GOTBITS")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) ``` Things to learn: 1. ```TRACEPOINT_PROBE(random, urandom_read)```: Instrument the kernel tracepoint ```random:urandom_read```. These have a stable API, and thus are recommend to use instead of kprobes, wherever possible. You can run ```perf list``` for a list of tracepoints. Linux >= 4.7 is required to attach BPF programs to tracepoints. 1. ```args->got_bits```: ```args``` is auto-populated to be a structure of the tracepoint arguments. The comment above says where you can see that structure. Eg: ``` # cat /sys/kernel/debug/tracing/events/random/urandom_read/format name: urandom_read ID: 972 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:int got_bits; offset:8; size:4; signed:1; field:int pool_left; offset:12; size:4; signed:1; field:int input_left; offset:16; size:4; signed:1; print fmt: "got_bits %d nonblocking_pool_entropy_left %d input_entropy_left %d", REC->got_bits, REC->pool_left, REC->input_left ``` In this case, we were printing the ```got_bits``` member. ### Lesson 13. disksnoop.py fixed Convert disksnoop.py from a previous lesson to use the ```block:block_rq_issue``` and ```block:block_rq_complete``` tracepoints. ### Lesson 14. strlen_count.py This program instruments a user-level function, the ```strlen()``` library function, and frequency counts its string argument. Example output: ``` # ./strlen_count.py Tracing strlen()... Hit Ctrl-C to end. ^C COUNT STRING 1 " " 1 "/bin/ls" 1 "." 1 "cpudist.py.1" 1 ".bashrc" 1 "ls --color=auto" 1 "key_t" [...] 10 "a7:~# " 10 "/root" 12 "LC_ALL" 12 "en_US.UTF-8" 13 "en_US.UTF-8" 20 "~" 70 "#%^,~:-=?+/}" 340 "\x01\x1b]0;root@bgregg-test: ~\x07\x02root@bgregg-test:~# " ``` These are various strings that are being processed by this library function while tracing, along with their frequency counts. ```strlen()``` was called on "LC_ALL" 12 times, for example. Code is [examples/tracing/strlen_count.py](../examples/tracing/strlen_count.py): ```Python from bcc import BPF from time import sleep # load BPF program b = BPF(text=""" #include struct key_t { char c[80]; }; BPF_HASH(counts, struct key_t); int count(struct pt_regs *ctx) { if (!PT_REGS_PARM1(ctx)) return 0; struct key_t key = {}; u64 zero = 0, *val; bpf_probe_read(&key.c, sizeof(key.c), (void *)PT_REGS_PARM1(ctx)); val = counts.lookup_or_init(&key, &zero); (*val)++; return 0; }; """) b.attach_uprobe(name="c", sym="strlen", fn_name="count") # header print("Tracing strlen()... Hit Ctrl-C to end.") # sleep until Ctrl-C try: sleep(99999999) except KeyboardInterrupt: pass # print output print("%10s %s" % ("COUNT", "STRING")) counts = b.get_table("counts") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): print("%10d \"%s\"" % (v.value, k.c.encode('string-escape'))) ``` Things to learn: 1. ```PT_REGS_PARM1(ctx)```: This fetches the first argument to ```strlen()```, which is the string. 1. ```b.attach_uprobe(name="c", sym="strlen", fn_name="count")```: Attach to library "c" (if this is the main program, use its pathname), instrument the user-level function ```strlen()```, and on execution call our C function ```count()```. ### Lesson 15. nodejs_http_server.py This program instruments a user-defined static tracing (USDT) probe, which is the user-level version of a kernel tracepoint. Sample output: ``` # ./nodejs_http_server.py 24728 TIME(s) COMM PID ARGS 24653324.561322998 node 24728 path:/index.html 24653335.343401998 node 24728 path:/images/welcome.png 24653340.510164998 node 24728 path:/images/favicon.png ``` Relevant code from [examples/tracing/nodejs_http_server.py](../examples/tracing/nodejs_http_server.py): ```Python if len(sys.argv) < 2: print("USAGE: nodejs_http_server PID") exit() pid = sys.argv[1] # load BPF program bpf_text = """ #include int do_trace(struct pt_regs *ctx) { uint64_t addr; char path[128]; bpf_usdt_readarg(6, ctx, &addr); bpf_probe_read(&path, sizeof(path), (void *)addr); bpf_trace_printk("path:%s\\n", path); return 0; }; """ # enable USDT probe from given PID u = USDT(pid=int(pid)) u.enable_probe(probe="http__server__request", fn_name="do_trace") # initialize BPF b = BPF(text=bpf_text, usdt_contexts=[u]) ``` Things to learn: 1. ```bpf_usdt_readarg(6, ctx, &addr)```: Read the address of argument 6 from the USDT probe into ```addr```. 1. ```bpf_probe_read(&path, sizeof(path), (void *)addr)```: Now the string ```addr``` points to into our ```path``` variable. 1. ```u = USDT(pid=int(pid))```: Initialize USDT tracing for the given PID. 1. ```u.enable_probe(probe="http__server__request", fn_name="do_trace")```: Attach our ```do_trace()``` BPF C function to the Node.js ```http__server__request``` USDT probe. 1. ```b = BPF(text=bpf_text, usdt_contexts=[u])```: Need to pass in our USDT object, ```u```, to BPF object creation. ### Lesson 16. task_switch.c This is an older tutorial included as a bonus lesson. Use this for recap and to reinforce what you've already learned. This is a slightly more complex tracing example than Hello World. This program will be invoked for every task change in the kernel, and record in a BPF map the new and old pids. The C program below introduces two new concepts. The first is the macro `BPF_TABLE`. This defines a table (type="hash"), with key type `key_t` and leaf type `u64` (a single counter). The table name is `stats`, containing 1024 entries maximum. One can `lookup`, `lookup_or_init`, `update`, and `delete` entries from the table. The second concept is the prev argument. This argument is treated specially by the BCC frontend, such that accesses to this variable are read from the saved context that is passed by the kprobe infrastructure. The prototype of the args starting from position 1 should match the prototype of the kernel function being kprobed. If done so, the program will have seamless access to the function parameters. ```c #include #include struct key_t { u32 prev_pid; u32 curr_pid; }; // map_type, key_type, leaf_type, table_name, num_entry BPF_TABLE("hash", struct key_t, u64, stats, 1024); // attach to finish_task_switch in kernel/sched/core.c, which has the following // prototype: // struct rq *finish_task_switch(struct task_struct *prev) int count_sched(struct pt_regs *ctx, struct task_struct *prev) { struct key_t key = {}; u64 zero = 0, *val; key.curr_pid = bpf_get_current_pid_tgid(); key.prev_pid = prev->pid; val = stats.lookup_or_init(&key, &zero); (*val)++; return 0; } ``` The userspace component loads the file shown above, and attaches it to the `finish_task_switch` kernel function. The [] operator of the BPF object gives access to each BPF_TABLE in the program, allowing pass-through access to the values residing in the kernel. Use the object as you would any other python dict object: read, update, and deletes are all allowed. ```python from bcc import BPF from time import sleep b = BPF(src_file="task_switch.c") b.attach_kprobe(event="finish_task_switch", fn_name="count_sched") # generate many schedule events for i in range(0, 100): sleep(0.01) for k, v in b["stats"].items(): print("task_switch[%5d->%5d]=%u" % (k.prev_pid, k.curr_pid, v.value)) ``` These programs have now been merged, and are both in [examples/tracing/task_switch.py](examples/tracing/task_switch.py). ### Lesson 17. Further Study For further study, see Sasha Goldshtein's [linux-tracing-workshop](https://github.com/goldshtn/linux-tracing-workshop), which contains additional labs. There are also many tools in bcc /tools to study. Please read [CONTRIBUTING-SCRIPTS.md](../CONTRIBUTING-SCRIPTS.md) if you wish to contrubite tools to bcc. At the bottom of the main [README.md](../README.md), you'll also find methods for contacting us. Good luck, and happy tracing! ## Networking To do. bpfcc-0.2.0+git0.02884a026/examples/000077500000000000000000000000001305314114400163145ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/CMakeLists.txt000066400000000000000000000003161305314114400210540ustar00rootroot00000000000000set(EXAMPLE_PROGRAMS hello_world.py) install(PROGRAMS ${EXAMPLE_PROGRAMS} DESTINATION share/bcc/examples) add_subdirectory(cpp) add_subdirectory(lua) add_subdirectory(networking) add_subdirectory(tracing) bpfcc-0.2.0+git0.02884a026/examples/cpp/000077500000000000000000000000001305314114400170765ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/cpp/CMakeLists.txt000066400000000000000000000024261305314114400216420ustar00rootroot00000000000000# Copyright (c) Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") include_directories(${CMAKE_SOURCE_DIR}/src/cc) add_executable(HelloWorld HelloWorld.cc) target_link_libraries(HelloWorld bcc-static) install (TARGETS HelloWorld DESTINATION share/bcc/examples/cpp) add_executable(CPUDistribution CPUDistribution.cc) target_link_libraries(CPUDistribution bcc-static) install (TARGETS CPUDistribution DESTINATION share/bcc/examples/cpp) add_executable(RecordMySQLQuery RecordMySQLQuery.cc) target_link_libraries(RecordMySQLQuery bcc-static) install (TARGETS RecordMySQLQuery DESTINATION share/bcc/examples/cpp) add_executable(TCPSendStack TCPSendStack.cc) target_link_libraries(TCPSendStack bcc-static) install (TARGETS TCPSendStack DESTINATION share/bcc/examples/cpp) add_executable(RandomRead RandomRead.cc) target_link_libraries(RandomRead bcc-static) install (TARGETS RandomRead DESTINATION share/bcc/examples/cpp) add_executable(LLCStat LLCStat.cc) target_link_libraries(LLCStat bcc-static) install (TARGETS LLCStat DESTINATION share/bcc/examples/cpp) add_executable(FollyRequestContextSwitch FollyRequestContextSwitch.cc) target_link_libraries(FollyRequestContextSwitch bcc-static) install (TARGETS FollyRequestContextSwitch DESTINATION share/bcc/examples/cpp) bpfcc-0.2.0+git0.02884a026/examples/cpp/CPUDistribution.cc000066400000000000000000000047071305314114400224440ustar00rootroot00000000000000/* * CPUDistribution Show load distribution across CPU cores during a period of * time. For Linux, uses BCC, eBPF. Embedded C. * * Basic example of BCC and kprobes. * * USAGE: CPUDistribution [duration] * * Copyright (c) Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") */ #include #include #include #include #include #include "BPF.h" const std::string BPF_PROGRAM = R"( #include #include BPF_HASH(pid_to_cpu, pid_t, int); BPF_HASH(pid_to_ts, pid_t, uint64_t); BPF_HASH(cpu_time, int, uint64_t); int task_switch_event(struct pt_regs *ctx, struct task_struct *prev) { pid_t prev_pid = prev->pid; int* prev_cpu = pid_to_cpu.lookup(&prev_pid); uint64_t* prev_ts = pid_to_ts.lookup(&prev_pid); pid_t cur_pid = bpf_get_current_pid_tgid(); int cur_cpu = bpf_get_smp_processor_id(); uint64_t cur_ts = bpf_ktime_get_ns(); uint64_t this_cpu_time = 0; if (prev_ts) { pid_to_ts.delete(&prev_pid); this_cpu_time = (cur_ts - *prev_ts); } if (prev_cpu) { pid_to_cpu.delete(&prev_pid); if (this_cpu_time > 0) { int cpu_key = *prev_cpu; uint64_t* history_time = cpu_time.lookup(&cpu_key); if (history_time) this_cpu_time += *history_time; cpu_time.update(&cpu_key, &this_cpu_time); } } pid_to_cpu.update(&cur_pid, &cur_cpu); pid_to_ts.update(&cur_pid, &cur_ts); return 0; } )"; int main(int argc, char** argv) { ebpf::BPF bpf; auto init_res = bpf.init(BPF_PROGRAM); if (init_res.code() != 0) { std::cerr << init_res.msg() << std::endl; return 1; } auto attach_res = bpf.attach_kprobe("finish_task_switch", "task_switch_event"); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; } int probe_time = 10; if (argc == 2) { probe_time = atoi(argv[1]); } std::cout << "Probing for " << probe_time << " seconds" << std::endl; sleep(probe_time); auto table = bpf.get_hash_table("cpu_time"); auto num_cores = sysconf(_SC_NPROCESSORS_ONLN); for (int i = 0; i < num_cores; i++) { std::cout << "CPU " << std::setw(2) << i << " worked for "; std::cout << (table[i] / 1000000.0) << " ms." << std::endl; } auto detach_res = bpf.detach_kprobe("finish_task_switch"); if (detach_res.code() != 0) { std::cerr << detach_res.msg() << std::endl; return 1; } return 0; } bpfcc-0.2.0+git0.02884a026/examples/cpp/FollyRequestContextSwitch.cc000066400000000000000000000050521305314114400245740ustar00rootroot00000000000000/* * FollyRequestContextSwitch Monitor RequestContext switch events for any binary * uses the class from [folly](http://bit.ly/2h6S1yx). * For Linux, uses BCC, eBPF. Embedded C. * * Basic example of using USDT with BCC. * * USAGE: FollyRequestContextSwitch PATH_TO_BINARY * * Copyright (c) Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") */ #include #include #include #include "BPF.h" const std::string BPF_PROGRAM = R"( #include #include struct event_t { int pid; char name[16]; uint64_t old_addr; uint64_t new_addr; }; BPF_PERF_OUTPUT(events); int on_context_switch(struct pt_regs *ctx) { struct event_t event = {}; event.pid = bpf_get_current_pid_tgid(); bpf_get_current_comm(&event.name, sizeof(event.name)); bpf_usdt_readarg(1, ctx, &event.old_addr); bpf_usdt_readarg(2, ctx, &event.new_addr); events.perf_submit(ctx, &event, sizeof(event)); return 0; } )"; // Define the same struct to use in user space. struct event_t { int pid; char name[16]; uint64_t old_addr; uint64_t new_addr; }; void handle_output(void* cb_cookie, void* data, int data_size) { auto event = static_cast(data); std::cout << "PID " << event->pid << " (" << event->name << ") "; std::cout << "folly::RequestContext switch from " << event->old_addr << " to " << event->new_addr << std::endl; } ebpf::BPF* bpf; void signal_handler(int s) { std::cerr << "Terminating..." << std::endl; delete bpf; exit(0); } int main(int argc, char** argv) { if (argc != 2) { std::cout << "USAGE: FollyRequestContextSwitch PATH_TO_BINARY" << std::endl; exit(1); } std::string binary_path(argv[1]); bpf = new ebpf::BPF(); std::vector u; u.emplace_back(binary_path, "folly", "request_context_switch_before", "on_context_switch"); auto init_res = bpf->init(BPF_PROGRAM, {}, u); if (init_res.code() != 0) { std::cerr << init_res.msg() << std::endl; return 1; } auto attach_res = bpf->attach_usdt(u[0]); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; } auto open_res = bpf->open_perf_buffer("events", &handle_output); if (open_res.code() != 0) { std::cerr << open_res.msg() << std::endl; return 1; } signal(SIGINT, signal_handler); std::cout << "Started tracing, hit Ctrl-C to terminate." << std::endl; while (true) bpf->poll_perf_buffer("events"); return 0; } bpfcc-0.2.0+git0.02884a026/examples/cpp/HelloWorld.cc000066400000000000000000000023031305314114400214560ustar00rootroot00000000000000/* * Copyright (c) Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") */ #include #include #include #include #include "BPF.h" const std::string BPF_PROGRAM = R"( int on_sys_clone(void *ctx) { bpf_trace_printk("Hello, World! Here I did a sys_clone call!\n"); return 0; } )"; int main() { ebpf::BPF bpf; auto init_res = bpf.init(BPF_PROGRAM); if (init_res.code() != 0) { std::cerr << init_res.msg() << std::endl; return 1; } std::ifstream pipe("/sys/kernel/debug/tracing/trace_pipe"); std::string line; auto attach_res = bpf.attach_kprobe("sys_clone", "on_sys_clone"); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; } while (true) { if (std::getline(pipe, line)) { std::cout << line << std::endl; // Detach the probe if we got at least one line. auto detach_res = bpf.detach_kprobe("sys_clone"); if (detach_res.code() != 0) { std::cerr << detach_res.msg() << std::endl; return 1; } break; } else { std::cout << "Waiting for a sys_clone event" << std::endl; sleep(1); } } return 0; } bpfcc-0.2.0+git0.02884a026/examples/cpp/LLCStat.cc000066400000000000000000000063451305314114400206630ustar00rootroot00000000000000/* * LLCStat Show LLC hit ratio for each process on each CPU core. * For Linux, uses BCC, eBPF. Embedded C. * * Basic example of BCC timed sampling perf event. * * USAGE: LLCStat [duration] * * Copyright (c) Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") */ #include #include #include #include #include #include "BPF.h" const std::string BPF_PROGRAM = R"( #include #include struct event_t { int cpu; int pid; char name[16]; }; BPF_HASH(ref_count, struct event_t); BPF_HASH(miss_count, struct event_t); static inline __attribute__((always_inline)) void get_key(struct event_t* key) { key->cpu = bpf_get_smp_processor_id(); key->pid = bpf_get_current_pid_tgid(); bpf_get_current_comm(&(key->name), sizeof(key->name)); } int on_cache_miss(struct bpf_perf_event_data *ctx) { struct event_t key = {}; get_key(&key); u64 zero = 0, *val; val = miss_count.lookup_or_init(&key, &zero); (*val) += ctx->sample_period; return 0; } int on_cache_ref(struct bpf_perf_event_data *ctx) { struct event_t key = {}; get_key(&key); u64 zero = 0, *val; val = ref_count.lookup_or_init(&key, &zero); (*val) += ctx->sample_period; return 0; } )"; struct event_t { int cpu; int pid; char name[16]; }; int main(int argc, char** argv) { ebpf::BPF bpf; auto init_res = bpf.init(BPF_PROGRAM); if (init_res.code() != 0) { std::cerr << init_res.msg() << std::endl; return 1; } auto attach_ref_res = bpf.attach_perf_event(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES, "on_cache_ref", 100, 0); if (attach_ref_res.code() != 0) { std::cerr << attach_ref_res.msg() << std::endl; return 1; } auto attach_miss_res = bpf.attach_perf_event( PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES, "on_cache_miss", 100, 0); if (attach_miss_res.code() != 0) { std::cerr << attach_miss_res.msg() << std::endl; return 1; } int probe_time = 10; if (argc == 2) { probe_time = atoi(argv[1]); } std::cout << "Probing for " << probe_time << " seconds" << std::endl; sleep(probe_time); bpf.detach_perf_event(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); bpf.detach_perf_event(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); auto refs = bpf.get_hash_table("ref_count"); auto misses = bpf.get_hash_table("miss_count"); for (auto it : refs.get_table_offline()) { uint64_t hit; try { auto miss = misses[it.first]; hit = miss <= it.second ? it.second - miss : 0; } catch (...) { hit = it.second; } double ratio = (double(hit) / double(it.second)) * 100.0; std::cout << "PID " << std::setw(8) << std::setfill(' ') << it.first.pid; std::cout << std::setw(20) << std::setfill(' ') << std::left << " (" + std::string(it.first.name) + ") " << std::right; std::cout << "on CPU " << std::setw(2) << std::setfill(' ') << it.first.cpu; std::cout << " Hit Rate " << std::setprecision(4) << ratio << "% "; std::cout << "(" << hit << "/" << it.second << ")" << std::endl; } return 0; } bpfcc-0.2.0+git0.02884a026/examples/cpp/RandomRead.cc000066400000000000000000000043741305314114400214310ustar00rootroot00000000000000/* * RandomRead Monitor random number read events. * For Linux, uses BCC, eBPF. Embedded C. * * Basic example of BCC Tracepoint and perf buffer. * * USAGE: RandomRead * * Copyright (c) Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") */ #include #include #include "BPF.h" const std::string BPF_PROGRAM = R"( #include #include struct urandom_read_args { // See /sys/kernel/debug/tracing/events/random/urandom_read/format uint64_t common__unused; int got_bits; int pool_left; int input_left; }; struct event_t { int pid; char comm[16]; int cpu; int got_bits; }; BPF_PERF_OUTPUT(events); int on_urandom_read(struct urandom_read_args* attr) { struct event_t event = {}; event.pid = bpf_get_current_pid_tgid(); bpf_get_current_comm(&event.comm, sizeof(event.comm)); event.cpu = bpf_get_smp_processor_id(); event.got_bits = attr->got_bits; events.perf_submit(attr, &event, sizeof(event)); return 0; } )"; // Define the same struct to use in user space. struct event_t { int pid; char comm[16]; int cpu; int got_bits; }; void handle_output(void* cb_cookie, void* data, int data_size) { auto event = static_cast(data); std::cout << "PID: " << event->pid << " (" << event->comm << ") on CPU " << event->cpu << " read " << event->got_bits << " bits" << std::endl; } ebpf::BPF* bpf; void signal_handler(int s) { std::cerr << "Terminating..." << std::endl; delete bpf; exit(0); } int main(int argc, char** argv) { bpf = new ebpf::BPF(); auto init_res = bpf->init(BPF_PROGRAM); if (init_res.code() != 0) { std::cerr << init_res.msg() << std::endl; return 1; } auto attach_res = bpf->attach_tracepoint("random:urandom_read", "on_urandom_read"); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; } auto open_res = bpf->open_perf_buffer("events", &handle_output); if (open_res.code() != 0) { std::cerr << open_res.msg() << std::endl; return 1; } signal(SIGINT, signal_handler); std::cout << "Started tracing, hit Ctrl-C to terminate." << std::endl; while (true) bpf->poll_perf_buffer("events"); return 0; } bpfcc-0.2.0+git0.02884a026/examples/cpp/RecordMySQLQuery.cc000066400000000000000000000051111305314114400225350ustar00rootroot00000000000000/* * RecordMySQLQuery Record MySQL queries by probing the alloc_query() function * in mysqld. For Linux, uses BCC, eBPF. Embedded C. * * Basic example of BCC and uprobes. * * Copyright (c) Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") */ #include #include #include #include #include #include "BPF.h" const std::string BPF_PROGRAM = R"( #include struct query_probe_t { uint64_t ts; pid_t pid; char query[100]; }; BPF_HASH(queries, struct query_probe_t, int); int probe_mysql_query(struct pt_regs *ctx, void* thd, char* query, size_t len) { if (query) { struct query_probe_t key = {}; key.ts = bpf_ktime_get_ns(); key.pid = bpf_get_current_pid_tgid(); bpf_probe_read(&key.query, sizeof(key.query), query); int one = 1; queries.update(&key, &one); } return 0; } )"; const std::string ALLOC_QUERY_FUNC = "_Z11alloc_queryP3THDPKcj"; // Define the same struct to use in user space. struct query_probe_t { uint64_t ts; pid_t pid; char query[100]; }; int main(int argc, char** argv) { if (argc < 2) { std::cout << "USAGE: RecordMySQLQuery PATH_TO_MYSQLD [duration]" << std::endl; exit(1); } std::string mysql_path(argv[1]); std::cout << "Using mysqld path: " << mysql_path << std::endl; ebpf::BPF bpf; auto init_res = bpf.init(BPF_PROGRAM); if (init_res.code() != 0) { std::cerr << init_res.msg() << std::endl; return 1; } auto attach_res = bpf.attach_uprobe(mysql_path, ALLOC_QUERY_FUNC, "probe_mysql_query"); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; } int probe_time = 10; if (argc >= 3) probe_time = atoi(argv[2]); std::cout << "Probing for " << probe_time << " seconds" << std::endl; sleep(probe_time); auto table_handle = bpf.get_hash_table("queries"); auto table = table_handle.get_table_offline(); std::sort(table.begin(), table.end(), [](std::pair a, std::pair b) { return a.first.ts < b.first.ts; }); std::cout << table.size() << " queries recorded:" << std::endl; for (auto it : table) { std::cout << "Time: " << it.first.ts << " PID: " << it.first.pid << " Query: " << it.first.query << std::endl; } auto detach_res = bpf.detach_uprobe(mysql_path, ALLOC_QUERY_FUNC); if (detach_res.code() != 0) { std::cerr << detach_res.msg() << std::endl; return 1; } return 0; } bpfcc-0.2.0+git0.02884a026/examples/cpp/TCPSendStack.cc000066400000000000000000000060471305314114400216420ustar00rootroot00000000000000/* * TCPSendStack Summarize tcp_sendmsg() calling stack traces. * For Linux, uses BCC, eBPF. Embedded C. * * Basic example of BCC in-kernel stack trace dedup. * * USAGE: TCPSendStack [duration] * * Copyright (c) Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") */ #include #include #include #include "BPF.h" const std::string BPF_PROGRAM = R"( #include #include struct stack_key_t { int pid; char name[16]; int user_stack; int kernel_stack; }; BPF_STACK_TRACE(stack_traces, 10240) BPF_HASH(counts, struct stack_key_t, uint64_t); int on_tcp_send(struct pt_regs *ctx) { struct stack_key_t key = {}; key.pid = bpf_get_current_pid_tgid(); bpf_get_current_comm(&key.name, sizeof(key.name)); key.kernel_stack = stack_traces.get_stackid(ctx, BPF_F_REUSE_STACKID); key.user_stack = stack_traces.get_stackid( ctx, BPF_F_REUSE_STACKID | BPF_F_USER_STACK ); u64 zero = 0, *val; val = counts.lookup_or_init(&key, &zero); (*val)++; return 0; } )"; // Define the same struct to use in user space. struct stack_key_t { int pid; char name[16]; int user_stack; int kernel_stack; }; int main(int argc, char** argv) { ebpf::BPF bpf; auto init_res = bpf.init(BPF_PROGRAM); if (init_res.code() != 0) { std::cerr << init_res.msg() << std::endl; return 1; } auto attach_res = bpf.attach_kprobe("tcp_sendmsg", "on_tcp_send"); if (attach_res.code() != 0) { std::cerr << attach_res.msg() << std::endl; return 1; } int probe_time = 10; if (argc == 2) { probe_time = atoi(argv[1]); } std::cout << "Probing for " << probe_time << " seconds" << std::endl; sleep(probe_time); auto table = bpf.get_hash_table("counts").get_table_offline(); std::sort(table.begin(), table.end(), [](std::pair a, std::pair b) { return a.second < b.second; }); auto stacks = bpf.get_stack_table("stack_traces"); for (auto it : table) { std::cout << "PID: " << it.first.pid << " (" << it.first.name << ") " << "made " << it.second << " TCP sends on following stack: " << std::endl; std::cout << " Kernel Stack:" << std::endl; if (it.first.kernel_stack >= 0) { auto syms = stacks.get_stack_symbol(it.first.kernel_stack, -1); for (auto sym : syms) std::cout << " " << sym << std::endl; } else std::cout << " " << it.first.kernel_stack << std::endl; std::cout << " User Stack:" << std::endl; if (it.first.user_stack >= 0) { auto syms = stacks.get_stack_symbol(it.first.user_stack, it.first.pid); for (auto sym : syms) std::cout << " " << sym << std::endl; } else std::cout << " " << it.first.user_stack << std::endl; } auto detach_res = bpf.detach_kprobe("tcp_sendmsg"); if (detach_res.code() != 0) { std::cerr << detach_res.msg() << std::endl; return 1; } return 0; } bpfcc-0.2.0+git0.02884a026/examples/hello_world.py000077500000000000000000000005521305314114400212050ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # run in project examples directory with: # sudo ./hello_world.py" # see trace_fields.py for a longer example from bcc import BPF BPF(text='int kprobe__sys_clone(void *ctx) { bpf_trace_printk("Hello, World!\\n"); return 0; }').trace_print() bpfcc-0.2.0+git0.02884a026/examples/lua/000077500000000000000000000000001305314114400170755ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/lua/CMakeLists.txt000066400000000000000000000002601305314114400216330ustar00rootroot00000000000000file(GLOB C_FILES *.c) file(GLOB LUA_FILES *.lua) install(FILES ${C_FILES} DESTINATION share/bcc/examples/lua) install(PROGRAMS ${LUA_FILES} DESTINATION share/bcc/examples/lua)bpfcc-0.2.0+git0.02884a026/examples/lua/bashreadline.c000066400000000000000000000006731305314114400216700ustar00rootroot00000000000000#include struct str_t { u64 pid; char str[80]; }; BPF_PERF_OUTPUT(events); int printret(struct pt_regs *ctx) { struct str_t data = {}; u32 pid; if (!PT_REGS_RC(ctx)) return 0; pid = bpf_get_current_pid_tgid(); data.pid = pid; bpf_probe_read(&data.str, sizeof(data.str), (void *)PT_REGS_RC(ctx)); events.perf_submit(ctx, &data, sizeof(data)); return 0; }; bpfcc-0.2.0+git0.02884a026/examples/lua/bashreadline.lua000077500000000000000000000021111305314114400222170ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require("ffi") return function(BPF) local b = BPF:new{src_file="bashreadline.c", debug=0} b:attach_uprobe{name="/bin/bash", sym="readline", fn_name="printret", retprobe=true} local function print_readline(cpu, event) print("%-9s %-6d %s" % {os.date("%H:%M:%S"), tonumber(event.pid), ffi.string(event.str)}) end b:get_table("events"):open_perf_buffer(print_readline, "struct { uint64_t pid; char str[80]; }") print("%-9s %-6s %s" % {"TIME", "PID", "COMMAND"}) b:kprobe_poll_loop() end bpfcc-0.2.0+git0.02884a026/examples/lua/kprobe-latency.lua000066400000000000000000000047341305314114400225270ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- This example program measures latency of block device operations and plots it -- in a histogram. It is similar to BPF example: -- https://github.com/torvalds/linux/blob/master/samples/bpf/tracex3_kern.c local ffi = require('ffi') local bpf = require('bpf') local S = require('syscall') -- Shared part of the program local bins = 100 local map = bpf.map('hash', 512, ffi.typeof('uint64_t'), ffi.typeof('uint64_t')) local lat_map = bpf.map('array', bins) -- Kernel-space part of the program local trace_start = bpf.kprobe('myprobe:blk_start_request', function (ptregs) map[ptregs.parm1] = time() end, false, -1, 0) local trace_end = bpf.kprobe('myprobe2:blk_account_io_completion', function (ptregs) -- The lines below are computing index -- using log10(x)*10 = log2(x)*10/log2(10) = log2(x)*3 -- index = 29 ~ 1 usec -- index = 59 ~ 1 msec -- index = 89 ~ 1 sec -- index = 99 ~ 10sec or more local delta = time() - map[ptregs.parm1] local index = 3 * math.log2(delta) if index >= bins then index = bins-1 end xadd(lat_map[index], 1) return true end, false, -1, 0) -- User-space part of the program pcall(function() local counter = 0 local sym = {' ',' ','.','.','*','*','o','o','O','O','#','#'} while true do -- Print header once in a while if counter % 50 == 0 then print('|1us |10us |100us |1ms |10ms |100ms |1s |10s') counter = 0 end counter = counter + 1 -- Collect all events local hist, events = {}, 0 for i=29,bins-1 do local v = tonumber(lat_map[i] or 0) if v > 0 then hist[i] = hist[i] or 0 + v events = events + v end end -- Print histogram symbols based on relative frequency local s = '' for i=29,bins-1 do if hist[i] then local c = math.ceil((hist[i] / (events + 1)) * #sym) s = s .. sym[c] else s = s .. ' ' end end print(s .. string.format(' ; %d events', events)) S.sleep(1) end end)bpfcc-0.2.0+git0.02884a026/examples/lua/kprobe-write.lua000066400000000000000000000021451305314114400222140ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- Simple tracing example that executes a program on -- return from sys_write() and tracks the number of hits local ffi = require('ffi') local bpf = require('bpf') local S = require('syscall') -- Shared part of the program local map = bpf.map('array', 1) -- Kernel-space part of the program local probe = bpf.kprobe('myprobe:sys_write', function (ptregs) xadd(map[0], 1) end, true) -- User-space part of the program pcall(function() for _ = 1, 10 do print('hits: ', tonumber(map[0])) S.sleep(1) end end) bpfcc-0.2.0+git0.02884a026/examples/lua/memleak.lua000077500000000000000000000141051305314114400212170ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local bpf_source = [[ #include struct alloc_info_t { u64 size; u64 timestamp_ns; int stack_id; }; BPF_HASH(sizes, u64); BPF_HASH(allocs, u64, struct alloc_info_t); BPF_STACK_TRACE(stack_traces, 10240) int alloc_enter(struct pt_regs *ctx, size_t size) { SIZE_FILTER if (SAMPLE_EVERY_N > 1) { u64 ts = bpf_ktime_get_ns(); if (ts % SAMPLE_EVERY_N != 0) return 0; } u64 pid = bpf_get_current_pid_tgid(); u64 size64 = size; sizes.update(&pid, &size64); if (SHOULD_PRINT) bpf_trace_printk("alloc entered, size = %u\n", size); return 0; } int alloc_exit(struct pt_regs *ctx) { u64 address = PT_REGS_RC(ctx); u64 pid = bpf_get_current_pid_tgid(); u64* size64 = sizes.lookup(&pid); struct alloc_info_t info = {0}; if (size64 == 0) return 0; // missed alloc entry info.size = *size64; sizes.delete(&pid); info.timestamp_ns = bpf_ktime_get_ns(); info.stack_id = stack_traces.get_stackid(ctx, STACK_FLAGS); allocs.update(&address, &info); if (SHOULD_PRINT) { bpf_trace_printk("alloc exited, size = %lu, result = %lx\n", info.size, address); } return 0; } int free_enter(struct pt_regs *ctx, void *address) { u64 addr = (u64)address; struct alloc_info_t *info = allocs.lookup(&addr); if (info == 0) return 0; allocs.delete(&addr); if (SHOULD_PRINT) { bpf_trace_printk("free entered, address = %lx, size = %lu\n", address, info->size); } return 0; } ]] return function(BPF, utils) local parser = utils.argparse("memleak", "Catch memory leaks") parser:flag("-t --trace") parser:flag("-a --show-allocs") parser:option("-p --pid"):convert(tonumber) parser:option("-i --interval", "", 5):convert(tonumber) parser:option("-o --older", "", 500):convert(tonumber) parser:option("-s --sample-rate", "", 1):convert(tonumber) parser:option("-z --min-size", ""):convert(tonumber) parser:option("-Z --max-size", ""):convert(tonumber) parser:option("-T --top", "", 10):convert(tonumber) local args = parser:parse() local size_filter = "" if args.min_size and args.max_size then size_filter = "if (size < %d || size > %d) return 0;" % {args.min_size, args.max_size} elseif args.min_size then size_filter = "if (size < %d) return 0;" % args.min_size elseif args.max_size then size_filter = "if (size > %d) return 0;" % args.max_size end local stack_flags = "BPF_F_REUSE_STACKID" if args.pid then stack_flags = stack_flags .. "|BPF_F_USER_STACK" end local text = bpf_source text = text:gsub("SIZE_FILTER", size_filter) text = text:gsub("STACK_FLAGS", stack_flags) text = text:gsub("SHOULD_PRINT", args.trace and "1" or "0") text = text:gsub("SAMPLE_EVERY_N", tostring(args.sample_rate)) local bpf = BPF:new{text=text, debug=0} local syms = nil local min_age_ns = args.older * 1e6 if args.pid then print("Attaching to malloc and free in pid %d, Ctrl+C to quit." % args.pid) bpf:attach_uprobe{name="c", sym="malloc", fn_name="alloc_enter", pid=args.pid} bpf:attach_uprobe{name="c", sym="malloc", fn_name="alloc_exit", pid=args.pid, retprobe=true} bpf:attach_uprobe{name="c", sym="free", fn_name="free_enter", pid=args.pid} else print("Attaching to kmalloc and kfree, Ctrl+C to quit.") bpf:attach_kprobe{event="__kmalloc", fn_name="alloc_enter"} bpf:attach_kprobe{event="__kmalloc", fn_name="alloc_exit", retprobe=true} -- TODO bpf:attach_kprobe{event="kfree", fn_name="free_enter"} end local syms = BPF.SymbolCache(args.pid) local allocs = bpf:get_table("allocs") local stack_traces = bpf:get_table("stack_traces") local function resolve(addr) local sym = syms:resolve(addr) if args.pid == nil then sym = sym .. " [kernel]" end return string.format("%s (%p)", sym, addr) end local function print_outstanding() local alloc_info = {} local now = utils.posix.time_ns() print("[%s] Top %d stacks with outstanding allocations:" % {os.date("%H:%M:%S"), args.top}) for address, info in allocs:items() do if now - min_age_ns >= tonumber(info.timestamp_ns) then local stack_id = tonumber(info.stack_id) if stack_id >= 0 then if alloc_info[stack_id] then local s = alloc_info[stack_id] s.count = s.count + 1 s.size = s.size + tonumber(info.size) else local stack = stack_traces:get(stack_id, resolve) alloc_info[stack_id] = { stack=stack, count=1, size=tonumber(info.size) } end end if args.show_allocs then print("\taddr = %p size = %s" % {address, tonumber(info.size)}) end end end local top = table.values(alloc_info) table.sort(top, function(a, b) return a.size > b.size end) for n, alloc in ipairs(top) do print("\t%d bytes in %d allocations from stack\n\t\t%s" % {alloc.size, alloc.count, table.concat(alloc.stack, "\n\t\t")}) if n == args.top then break end end end if args.trace then local pipe = bpf:pipe() while true do print(pipe:trace_fields()) end else while true do utils.posix.sleep(args.interval) syms:refresh() print_outstanding() end end end bpfcc-0.2.0+git0.02884a026/examples/lua/offcputime.lua000077500000000000000000000060361305314114400217510ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local program = [[ #include #include #define MINBLOCK_US 1 struct key_t { char name[TASK_COMM_LEN]; int stack_id; }; BPF_HASH(counts, struct key_t); BPF_HASH(start, u32); BPF_STACK_TRACE(stack_traces, 10240) int oncpu(struct pt_regs *ctx, struct task_struct *prev) { u32 pid; u64 ts, *tsp; // record previous thread sleep time if (FILTER) { pid = prev->pid; ts = bpf_ktime_get_ns(); start.update(&pid, &ts); } // calculate current thread's delta time pid = bpf_get_current_pid_tgid(); tsp = start.lookup(&pid); if (tsp == 0) return 0; // missed start or filtered u64 delta = bpf_ktime_get_ns() - *tsp; start.delete(&pid); delta = delta / 1000; if (delta < MINBLOCK_US) return 0; // create map key u64 zero = 0, *val; struct key_t key = {}; int stack_flags = BPF_F_REUSE_STACKID; /* if (!(prev->flags & PF_KTHREAD)) stack_flags |= BPF_F_USER_STACK; */ bpf_get_current_comm(&key.name, sizeof(key.name)); key.stack_id = stack_traces.get_stackid(ctx, stack_flags); val = counts.lookup_or_init(&key, &zero); (*val) += delta; return 0; } ]] return function(BPF, utils) local ffi = require("ffi") local parser = utils.argparse("offcputime", "Summarize off-cpu time") parser:flag("-u --user-only") parser:option("-p --pid"):convert(tonumber) parser:flag("-f --folded") parser:option("-d --duration", "duration to trace for", 9999999):convert(tonumber) local args = parser:parse() local ksym = BPF.SymbolCache() local filter = "1" local MAXDEPTH = 20 if args.pid then filter = "pid == %d" % args.pid elseif args.user_only then filter = "!(prev->flags & PF_KTHREAD)" end local text = program:gsub("FILTER", filter) local b = BPF:new{text=text} b:attach_kprobe{event="finish_task_switch", fn_name="oncpu"} if BPF.num_open_kprobes() == 0 then print("no functions matched. quitting...") return end print("Sleeping for %d seconds..." % args.duration) pcall(utils.posix.sleep, args.duration) print("Tracing...") local counts = b:get_table("counts") local stack_traces = b:get_table("stack_traces") for k, v in counts:items() do for addr in stack_traces:walk(tonumber(k.stack_id)) do print(" %-16p %s" % {addr, ksym:resolve(addr)}) end print(" %-16s %s" % {"-", ffi.string(k.name)}) print(" %d\n" % tonumber(v)) end end bpfcc-0.2.0+git0.02884a026/examples/lua/sock-parse-dns.lua000066400000000000000000000032361305314114400224350ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- Simple parsing example of UDP/DNS that counts frequency of QTYPEs. -- It shows how to parse packet variable-length packet structures. local ffi = require("ffi") local bpf = require("bpf") local S = require("syscall") -- Shared part of the program local map = assert(bpf.map('array', 256)) -- Kernel-space part of the program local prog = bpf.socket('lo', function (skb) local ip = pkt.ip -- Accept only UDP messages if ip.proto ~= c.ip.proto_udp then return false end local udp = ip.udp -- Only messages >12 octets (DNS header) if udp.length < 12 then return false end -- Unroll QNAME (up to 2 labels) udp = udp.data + 12 local label = udp[0] if label > 0 then udp = udp + label + 1 label = udp[0] if label > 0 then udp = udp + label + 1 end end -- Track QTYPE (low types) if udp[0] == 0 then local qtype = udp[2] -- Low octet from QTYPE xadd(map[qtype], 1) end end) -- User-space part of the program for _ = 1, 10 do for k,v in map.pairs,map,0 do v = tonumber(v) if v > 0 then print(string.format('TYPE%d: %d', k, v)) end end S.sleep(1) endbpfcc-0.2.0+git0.02884a026/examples/lua/sock-parse-http.lua000066400000000000000000000037531305314114400226340ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- Simple parsing example of TCP/HTTP that counts frequency of types of requests -- and shows more complicated pattern matching constructions and slices. -- Rewrite of a BCC example: -- https://github.com/iovisor/bcc/blob/master/examples/networking/http_filter/http-parse-simple.c local ffi = require("ffi") local bpf = require("bpf") local S = require("syscall") -- Shared part of the program local map = bpf.map('hash', 64) -- Kernel-space part of the program local prog = bpf.socket('lo', function (skb) -- Only ingress so we don't count twice on loopback if skb.ingress_ifindex == 0 then return end local data = pkt.ip.tcp.data -- Get TCP protocol dissector -- Continue only if we have 7 bytes of TCP data if data + 7 > skb.len then return end -- Fetch 4 bytes of TCP data and compare local h = data(0, 4) if h == 'HTTP' or h == 'GET ' or h == 'POST' or h == 'PUT ' or h == 'HEAD' or h == 'DELE' then -- If hash key doesn't exist, create it -- otherwise increment counter local v = map[h] if not v then map[h] = 1 else xadd(map[h], 1) end end end) -- User-space part of the program for _ = 1, 10 do local strkey = ffi.new('uint32_t [1]') local s = '' for k,v in map.pairs,map,0 do strkey[0] = bpf.ntoh(k) s = s..string.format('%s %d ', ffi.string(strkey, 4):match '^%s*(.-)%s*$', tonumber(v)) end if #s > 0 then print(s..'messages') end S.sleep(1) endbpfcc-0.2.0+git0.02884a026/examples/lua/sock-proto.lua000066400000000000000000000026341305314114400217050ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- This program looks at IP, UDP and ICMP packets and -- increments counter for each packet of given type seen -- Rewrite of https://github.com/torvalds/linux/blob/master/samples/bpf/sock_example.c local ffi = require("ffi") local bpf = require("bpf") local S = require("syscall") -- Shared part of the program local map = bpf.map('hash', 256) map[1], map[6], map[17] = 0, 0, 0 -- Kernel-space part of the program bpf.socket('lo', function (skb) local proto = pkt.ip.proto -- Get byte (ip.proto) from frame at [23] xadd(map[proto], 1) -- Atomic `map[proto] += 1` end) -- User-space part of the program for _ = 1, 10 do local icmp, udp, tcp = map[1], map[17], map[6] print(string.format('TCP %d UDP %d ICMP %d packets', tonumber(tcp or 0), tonumber(udp or 0), tonumber(icmp or 0))) S.sleep(1) endbpfcc-0.2.0+git0.02884a026/examples/lua/sock-protolen.lua000066400000000000000000000030011305314114400223710ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- This program counts total bytes received per-protocol in 64-bit counters. -- The map backend is array in this case to avoid key allocations. -- increments counter for each packet of given type seen -- Rewrite of https://github.com/torvalds/linux/blob/master/samples/bpf/sock_example.c local ffi = require("ffi") local bpf = require("bpf") local S = require("syscall") -- Shared part of the program local map = bpf.map('array', 256, ffi.typeof('uint32_t'), ffi.typeof('uint64_t')) -- Kernel-space part of the program bpf.socket('lo', function (skb) local proto = pkt.ip.proto -- Get byte (ip.proto) from frame at [23] xadd(map[proto], skb.len) -- Atomic `map[proto] += ` end) -- User-space part of the program for _ = 1, 10 do local icmp, udp, tcp = map[1], map[17], map[6] print(string.format('TCP %d UDP %d ICMP %d bytes', tonumber(tcp or 0), tonumber(udp or 0), tonumber(icmp or 0))) S.sleep(1) endbpfcc-0.2.0+git0.02884a026/examples/lua/strlen_count.lua000077500000000000000000000024241305314114400223240ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] assert(arg[1], "usage: strlen_count PID") local program = string.gsub([[ #include int printarg(struct pt_regs *ctx) { if (!PT_REGS_PARM1(ctx)) return 0; u32 pid = bpf_get_current_pid_tgid(); if (pid != PID) return 0; char str[128] = {}; bpf_probe_read(&str, sizeof(str), (void *)PT_REGS_PARM1(ctx)); bpf_trace_printk("strlen(\"%s\")\n", &str); return 0; }; ]], "PID", arg[1]) return function(BPF) local b = BPF:new{text=program, debug=0} b:attach_uprobe{name="c", sym="strlen", fn_name="printarg"} local pipe = b:pipe() while true do local task, pid, cpu, flags, ts, msg = pipe:trace_fields() print("%-18.9f %-16s %-6d %s" % {ts, task, pid, msg}) end end bpfcc-0.2.0+git0.02884a026/examples/lua/task_switch.lua000077500000000000000000000025661305314114400221370ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local program = [[ #include #include struct key_t { u32 prev_pid; u32 curr_pid; }; // map_type, key_type, leaf_type, table_name, num_entry BPF_TABLE("hash", struct key_t, u64, stats, 1024); int count_sched(struct pt_regs *ctx, struct task_struct *prev) { struct key_t key = {}; u64 zero = 0, *val; key.curr_pid = bpf_get_current_pid_tgid(); key.prev_pid = prev->pid; val = stats.lookup_or_init(&key, &zero); (*val)++; return 0; } ]] return function(BPF) local b = BPF:new{text=program, debug=0} b:attach_kprobe{event="finish_task_switch", fn_name="count_sched"} print("Press any key...") io.read() local t = b:get_table("stats") for k, v in t:items() do print("task_switch[%d -> %d] = %d" % {k.prev_pid, k.curr_pid, tonumber(v)}) end end bpfcc-0.2.0+git0.02884a026/examples/lua/tracepoint-offcputime.lua000066400000000000000000000051321305314114400241100ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- Summarize off-CPU time by stack trace -- Related tool: https://github.com/iovisor/bcc/blob/master/tools/offcputime.py local ffi = require('ffi') local bpf = require('bpf') local S = require('syscall') -- Create BPF maps -- TODO: made smaller to fit default memory limits local key_t = 'struct { char name[16]; int32_t stack_id; }' local starts = assert(bpf.map('hash', 128, ffi.typeof('uint32_t'), ffi.typeof('uint64_t'))) local counts = assert(bpf.map('hash', 128, ffi.typeof(key_t), ffi.typeof('uint64_t'))) local stack_traces = assert(bpf.map('stack_trace', 16)) -- Open tracepoint and attach BPF program -- The 'arg' parses tracepoint format automatically local tp = bpf.tracepoint('sched/sched_switch', function (arg) -- Update previous thread sleep time local pid = arg.prev_pid local now = time() starts[pid] = now -- Calculate current thread's delta time pid = arg.next_pid local from = starts[pid] if not from then return 0 end local delta = (now - from) / 1000 starts[pid] = nil -- Check if the delta is below 1us if delta < 1 then return end -- Create key for this thread local key = ffi.new(key_t) comm(key.name) key.stack_id = stack_id(stack_traces, BPF.F_FAST_STACK_CMP) -- Update current thread off cpu time with delta local val = counts[key] if not val then counts[key] = 0 end xadd(counts[key], delta) end, 0, -1) -- Helper: load kernel symbols ffi.cdef 'unsigned long long strtoull(const char *, char **, int);' local ksyms = {} for l in io.lines('/proc/kallsyms') do local addr, sym = l:match '(%w+) %w (%S+)' if addr then ksyms[ffi.C.strtoull(addr, nil, 16)] = sym end end -- User-space part of the program while true do for k,v in counts.pairs,counts,nil do local s = '' local traces = stack_traces[k.stack_id] if traces then for i, ip in ipairs(traces) do s = s .. string.format(" %-16p %s", ip, ksyms[ip]) end end s = s .. string.format(" %-16s %s", "-", ffi.string(k.name)) s = s .. string.format(" %d", tonumber(v)) print(s) end S.sleep(1) end bpfcc-0.2.0+git0.02884a026/examples/lua/uprobe-readline-perf.lua000066400000000000000000000036071305314114400236150ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- Trace readline() call from all bash instances (print bash commands from all running shells). -- This is rough equivallent to `bashreadline` with output through perf event API. -- Source: http://www.brendangregg.com/blog/2016-02-08/linux-ebpf-bcc-uprobes.html local ffi = require('ffi') local bpf = require('bpf') local S = require('syscall') -- Perf event map local sample_t = 'struct { uint64_t pid; char str[80]; }' local events = bpf.map('perf_event_array') -- Kernel-space part of the program local probe = bpf.uprobe('/bin/bash:readline', function (ptregs) local sample = ffi.new(sample_t) sample.pid = pid_tgid() ffi.copy(sample.str, ffi.cast('char *', ptregs.ax)) -- Cast `ax` to string pointer and copy to buffer perf_submit(events, sample) -- Write buffer to perf event map end, true, -1, 0) -- User-space part of the program local log = events:reader(nil, 0, sample_t) -- Must specify PID or CPU_ID to observe print(' TASK-PID TIMESTAMP FUNCTION') print(' | | | |') while true do log:block() -- Wait until event reader is readable for _,e in log:read() do -- Collect available reader events print(string.format('%12s%-16s %-10s %s', '', tonumber(e.pid), os.date("%H:%M:%S"), ffi.string(e.str))) end end bpfcc-0.2.0+git0.02884a026/examples/lua/uprobe-readline.lua000066400000000000000000000030241305314114400226540ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- Trace readline() call from all bash instances (print bash commands from all running shells). -- This is rough equivallent to `bashreadline` -- Source: http://www.brendangregg.com/blog/2016-02-08/linux-ebpf-bcc-uprobes.html local ffi = require('ffi') local bpf = require('bpf') local S = require('syscall') -- Kernel-space part of the program local probe = bpf.uprobe('/bin/bash:readline', function (ptregs) local line = ffi.new('char [40]') -- Create a 40 byte buffer on stack ffi.copy(line, ffi.cast('char *', ptregs.ax)) -- Cast `ax` to string pointer and copy to buffer print('%s\n', line) -- Print to trace_pipe end, true, -1, 0) -- User-space part of the program local ok, err = pcall(function() local log = bpf.tracelog() print(' TASK-PID CPU# TIMESTAMP FUNCTION') print(' | | | | |') while true do print(log:read()) end end) bpfcc-0.2.0+git0.02884a026/examples/lua/uprobe-tailkt.lua000066400000000000000000000047731305314114400223750ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- Trace operations on keys matching given pattern in KyotoTycoon daemon. -- This can show you if certain keys were modified or read during the lifetime -- even if KT doesn't support this. It also shows how to attach to C++ mangled symbols. local ffi = require('ffi') local bpf = require('bpf') local S = require('syscall') local function help(err) print(string.format('%s [get|set] [key]', arg[0])) if err then print('error: '..err) end os.exit(1) end -- Accept the same format as ktremotemgr for clarity: local writeable, watch_key, klen = 'any', arg[2] or '*', 80 if arg[1] == 'get' then writeable = 0 elseif arg[1] == 'set' then writeable = 1 elseif arg[1] == '-h' or arg[1] == '--help' then help() elseif arg[1] and arg[1] ~= 'any' then help(string.format('bad cmd: "%s"', arg[1])) end if watch_key ~= '*' then klen = #watch_key end -- Find a good entrypoint that has both key and differentiates read/write in KT -- That is going to serve as an attachment point for BPF program -- ABI: bool accept(void *this, const char* kbuf, size_t ksiz, Visitor* visitor, bool writable) local key_type = string.format('char [%d]', klen) local probe = bpf.uprobe('/usr/local/bin/ktserver:kyotocabinet::StashDB::accept', function (ptregs) -- Watch either get/set or both if writeable ~= 'any' then if ptregs.parm5 ~= writeable then return end end local line = ffi.new(key_type) ffi.copy(line, ffi.cast('char *', ptregs.parm2)) -- Check if we're looking for specific key if watch_key ~= '*' then if ptregs.parm3 ~= klen then return false end if line ~= watch_key then return false end end print('%s write:%d\n', line, ptregs.parm5) end, false, -1, 0) -- User-space part of the program local ok, err = pcall(function() local log = bpf.tracelog() print(' TASK-PID CPU# TIMESTAMP FUNCTION') print(' | | | | |') while true do print(log:read()) end end) bpfcc-0.2.0+git0.02884a026/examples/lua/usdt_ruby.lua000077500000000000000000000022711305314114400216250ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local program = [[ #include int trace_method(struct pt_regs *ctx) { uint64_t addr; bpf_usdt_readarg(2, ctx, &addr); char fn_name[128] = {}; bpf_probe_read(&fn_name, sizeof(fn_name), (void *)addr); bpf_trace_printk("%s(...)\n", fn_name); return 0; }; ]] return function(BPF, util) if not arg[1] then print("usage: rubysyms.lua PID") return end local u = util.USDT:new{pid=tonumber(arg[1])} u:enable_probe{probe="method__entry", fn_name="trace_method"} local b = BPF:new{text=program, usdt=u} local pipe = b:pipe() while true do print(pipe:trace_fields()) end end bpfcc-0.2.0+git0.02884a026/examples/networking/000077500000000000000000000000001305314114400205035ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/CMakeLists.txt000066400000000000000000000006551305314114400232510ustar00rootroot00000000000000set(EXAMPLE_FILES simulation.py) set(EXAMPLE_PROGRAMS simple_tc.py tc_perf_event.py) install(FILES ${EXAMPLE_FILES} DESTINATION share/bcc/examples/networking) install(PROGRAMS ${EXAMPLE_PROGRAMS} DESTINATION share/bcc/examples/networking) add_subdirectory(distributed_bridge) add_subdirectory(neighbor_sharing) add_subdirectory(vlan_learning) add_subdirectory(tunnel_monitor) add_subdirectory(http_filter) add_subdirectory(xdp) bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/000077500000000000000000000000001305314114400243415ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/CMakeLists.txt000066400000000000000000000004571305314114400271070ustar00rootroot00000000000000set(EXAMPLE_FILES simulation.py tunnel.c tunnel_mesh.c) set(EXAMPLE_PROGRAMS main.py tunnel_mesh.py tunnel.py) install(FILES ${EXAMPLE_FILES} DESTINATION share/bcc/examples/networking/distributed_bridge) install(PROGRAMS ${EXAMPLE_PROGRAMS} DESTINATION share/bcc/examples/networking/distributed_bridge) bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/main.py000077500000000000000000000056531305314114400256530ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from sys import argv from builtins import input from pyroute2 import IPRoute, NetNS, IPDB, NSPopen from simulation import Simulation from subprocess import PIPE, call, Popen import re multicast = 1 dhcp = 0 gretap = 0 if "mesh" in argv: multicast = 0 if "dhcp" in argv: dhcp = 1 multicast = 0 if "gretap" in argv: gretap = 1 multicast = 0 print("multicast %d dhcp %d gretap %d" % (multicast, dhcp, gretap)) ipr = IPRoute() ipdb = IPDB(nl=ipr) num_hosts = 3 null = open("/dev/null", "w") class TunnelSimulation(Simulation): def __init__(self, ipdb): super(TunnelSimulation, self).__init__(ipdb) def start(self): # each entry is tuple of ns_ipdb, out_ifc, in_ifc host_info = [] for i in range(0, num_hosts): print("Launching host %i of %i" % (i + 1, num_hosts)) ipaddr = "172.16.1.%d/24" % (100 + i) host_info.append(self._create_ns("host%d" % i, ipaddr=ipaddr, disable_ipv6=True)) if multicast: cmd = ["python", "tunnel.py", str(i)] else: cmd = ["python", "tunnel_mesh.py", str(num_hosts), str(i), str(dhcp), str(gretap)] p = NSPopen(host_info[i][0].nl.netns, cmd, stdin=PIPE) self.processes.append(p) with self.ipdb.create(ifname="br-fabric", kind="bridge") as br: for host in host_info: br.add_port(host[1]) br.up() # get host0 bridge ip's host0_br_ips = [] if dhcp == 1: print("Waiting for host0 br1/br2 ip addresses available") for j in range(0, 2): interface = host_info[0][0].interfaces["br%d" % j] interface.wait_ip("99.1.0.0", 16, timeout=60) host0_br_ips = [x[0] for x in interface.ipaddr if x[0].startswith("99.1")] else: host0_br_ips.append("99.1.0.1") host0_br_ips.append("99.1.1.1") # traffic test print("Validating connectivity") for i in range(1, num_hosts): for j in range(0, 2): interface = host_info[i][0].interfaces["br%d" % j] interface.wait_ip("99.1.0.0", 16, timeout=60) print("VNI%d between host0 and host%d" % (10000 + j, i)) call(["ip", "netns", "exec", "host%d" % i, "ping", host0_br_ips[j], "-c", "3", "-i", "0.2", "-q"]) try: sim = TunnelSimulation(ipdb) sim.start() input("Press enter to quit:") for p in sim.processes: p.communicate(b"\n") except: if "sim" in locals(): for p in sim.processes: p.kill(); p.wait(); p.release() finally: if "br-fabric" in ipdb.interfaces: ipdb.interfaces["br-fabric"].remove().commit() if "sim" in locals(): sim.release() ipdb.release() null.close() bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/simulation.py000077700000000000000000000000001305314114400320432../simulation.pyustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/tunnel.c000066400000000000000000000045671305314114400260260ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include BPF_TABLE("hash", u32, int, vni2if, 1024); struct vni_key { u64 mac; int ifindex; int pad; }; struct host { u32 tunnel_id; u32 remote_ipv4; u64 rx_pkts; u64 tx_pkts; }; BPF_TABLE("hash", struct vni_key, struct host, mac2host, 10240); struct config { int tunnel_ifindex; }; BPF_TABLE("hash", int, struct config, conf, 1); // Handle packets from the encap device, demux into the dest tenant int handle_ingress(struct __sk_buff *skb) { u8 *cursor = 0; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); struct bpf_tunnel_key tkey = {}; bpf_skb_get_tunnel_key(skb, &tkey, offsetof(struct bpf_tunnel_key, remote_ipv6[1]), 0); int *ifindex = vni2if.lookup(&tkey.tunnel_id); if (ifindex) { //bpf_trace_printk("ingress tunnel_id=%d ifindex=%d\n", tkey.tunnel_id, *ifindex); struct vni_key vk = {ethernet->src, *ifindex, 0}; struct host *src_host = mac2host.lookup_or_init(&vk, &(struct host){tkey.tunnel_id, tkey.remote_ipv4, 0, 0}); lock_xadd(&src_host->rx_pkts, 1); bpf_clone_redirect(skb, *ifindex, 1/*ingress*/); } else { bpf_trace_printk("ingress invalid tunnel_id=%d\n", tkey.tunnel_id); } return 1; } // Handle packets from the tenant, mux into the encap device int handle_egress(struct __sk_buff *skb) { u8 *cursor = 0; int one = 1; struct config *cfg = conf.lookup(&one); if (!cfg) return 1; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); struct vni_key vk = {ethernet->dst, skb->ifindex, 0}; struct host *dst_host = mac2host.lookup(&vk); struct bpf_tunnel_key tkey = {}; if (dst_host) { u32 zero = 0; tkey.tunnel_id = dst_host->tunnel_id; tkey.remote_ipv4 = dst_host->remote_ipv4; bpf_skb_set_tunnel_key(skb, &tkey, offsetof(struct bpf_tunnel_key, remote_ipv6[1]), 0); lock_xadd(&dst_host->tx_pkts, 1); } else { struct bpf_tunnel_key tkey = {}; vk.mac = 0xFFFFFFFFFFFFull; dst_host = mac2host.lookup(&vk); if (!dst_host) return 1; tkey.tunnel_id = dst_host->tunnel_id; tkey.remote_ipv4 = dst_host->remote_ipv4; bpf_skb_set_tunnel_key(skb, &tkey, offsetof(struct bpf_tunnel_key, remote_ipv6[1]), 0); } bpf_clone_redirect(skb, cfg->tunnel_ifindex, 0/*egress*/); return 1; } bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/tunnel.py000077500000000000000000000050621305314114400262260ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from sys import argv from bcc import BPF from builtins import input from ctypes import c_int, c_uint from http.server import HTTPServer, SimpleHTTPRequestHandler import json from netaddr import EUI, IPAddress from pyroute2 import IPRoute, NetNS, IPDB, NSPopen from socket import htons, AF_INET from threading import Thread from subprocess import call host_id = int(argv[1]) b = BPF(src_file="tunnel.c") ingress_fn = b.load_func("handle_ingress", BPF.SCHED_CLS) egress_fn = b.load_func("handle_egress", BPF.SCHED_CLS) mac2host = b.get_table("mac2host") vni2if = b.get_table("vni2if") conf = b.get_table("conf") ipr = IPRoute() ipdb = IPDB(nl=ipr) ifc = ipdb.interfaces.eth0 mcast = IPAddress("239.1.1.1") # ifcs to cleanup at the end ifc_gc = [] def run(): ipdb.routes.add({"dst": "224.0.0.0/4", "oif": ifc.index}).commit() with ipdb.create(ifname="vxlan0", kind="vxlan", vxlan_id=0, vxlan_link=ifc, vxlan_port=4789, vxlan_group=str(mcast), vxlan_flowbased=True, vxlan_collect_metadata=True, vxlan_learning=False) as vx: vx.up() ifc_gc.append(vx.ifname) conf[c_int(1)] = c_int(vx.index) ipr.tc("add", "ingress", vx.index, "ffff:") ipr.tc("add-filter", "bpf", vx.index, ":1", fd=ingress_fn.fd, name=ingress_fn.name, parent="ffff:", action="drop", classid=1) for i in range(0, 2): vni = 10000 + i with ipdb.create(ifname="br%d" % i, kind="bridge") as br: v = ipdb.create(ifname="dummy%d" % i, kind="dummy").up().commit() mcast_key = mac2host.Key(0xFFFFFFFFFFFF, v.index, 0) mcast_leaf = mac2host.Leaf(vni, mcast.value, 0, 0) mac2host[mcast_key] = mcast_leaf ipr.tc("add", "sfq", v.index, "1:") ipr.tc("add-filter", "bpf", v.index, ":1", fd=egress_fn.fd, name=egress_fn.name, parent="1:", action="drop", classid=1) br.add_port(v) br.up() ifc_gc.append(v.ifname) ifc_gc.append(br.ifname) vni2if[c_uint(vni)] = c_int(v.index) ipaddr = "99.1.%d.%d/24" % (i, host_id + 1) br.add_ip(ipaddr) try: run() ipdb.release() input("") print("---") for k, v in mac2host.items(): print(EUI(k.mac), k.ifindex, IPAddress(v.remote_ipv4), v.tunnel_id, v.rx_pkts, v.tx_pkts) finally: for v in ifc_gc: call(["ip", "link", "del", v]) bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/tunnel_mesh.c000066400000000000000000000035061305314114400270320ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include struct config { int tunnel_ifindex; }; BPF_TABLE("hash", int, struct config, conf, 1); struct tunnel_key { u32 tunnel_id; u32 remote_ipv4; }; BPF_TABLE("hash", struct tunnel_key, int, tunkey2if, 1024); BPF_TABLE("hash", int, struct tunnel_key, if2tunkey, 1024); // Handle packets from the encap device, demux into the dest tenant int handle_ingress(struct __sk_buff *skb) { struct bpf_tunnel_key tkey = {}; struct tunnel_key key; bpf_skb_get_tunnel_key(skb, &tkey, offsetof(struct bpf_tunnel_key, remote_ipv6[1]), 0); key.tunnel_id = tkey.tunnel_id; key.remote_ipv4 = tkey.remote_ipv4; int *ifindex = tunkey2if.lookup(&key); if (ifindex) { //bpf_trace_printk("ingress tunnel_id=%d remote_ip=%08x ifindex=%d\n", // key.tunnel_id, key.remote_ipv4, *ifindex); // mark from external skb->tc_index = 1; bpf_clone_redirect(skb, *ifindex, 1/*ingress*/); } else { bpf_trace_printk("ingress invalid tunnel_id=%d\n", key.tunnel_id); } return 1; } // Handle packets from the tenant, mux into the encap device int handle_egress(struct __sk_buff *skb) { int ifindex = skb->ifindex; struct bpf_tunnel_key tkey = {}; struct tunnel_key *key_p; int one = 1; struct config *cfg = conf.lookup(&one); if (!cfg) return 1; if (skb->tc_index) { //bpf_trace_printk("from external\n"); // don't send it back out to encap device return 1; } key_p = if2tunkey.lookup(&ifindex); if (key_p) { tkey.tunnel_id = key_p->tunnel_id; tkey.remote_ipv4 = key_p->remote_ipv4; bpf_skb_set_tunnel_key(skb, &tkey, offsetof(struct bpf_tunnel_key, remote_ipv6[1]), 0); bpf_clone_redirect(skb, cfg->tunnel_ifindex, 0/*egress*/); } return 1; } bpfcc-0.2.0+git0.02884a026/examples/networking/distributed_bridge/tunnel_mesh.py000066400000000000000000000122651305314114400272420ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from sys import argv from bcc import BPF from builtins import input from ctypes import c_int, c_uint from http.server import HTTPServer, SimpleHTTPRequestHandler import json from netaddr import EUI, IPAddress from pyroute2 import IPRoute, NetNS, IPDB, NSPopen from socket import htons, AF_INET from threading import Thread from subprocess import call, Popen, PIPE num_hosts = int(argv[1]) host_id = int(argv[2]) dhcp = int(argv[3]) gretap = int(argv[4]) b = BPF(src_file="tunnel_mesh.c") ingress_fn = b.load_func("handle_ingress", BPF.SCHED_CLS) egress_fn = b.load_func("handle_egress", BPF.SCHED_CLS) tunkey2if = b.get_table("tunkey2if") if2tunkey = b.get_table("if2tunkey") conf = b.get_table("conf") ipr = IPRoute() ipdb = IPDB(nl=ipr) ifc = ipdb.interfaces.eth0 # ifcs to cleanup at the end ifc_gc = [] # dhcp server and client processes d_serv = [] d_client = [] def run(): if gretap: with ipdb.create(ifname="gretap1", kind="gretap", gre_ikey=0, gre_okey=0, gre_local='172.16.1.%d' % (100 + host_id), gre_ttl=16, gre_collect_metadata=1) as vx: vx.up() ifc_gc.append(vx.ifname) else: with ipdb.create(ifname="vxlan0", kind="vxlan", vxlan_id=0, vxlan_link=ifc, vxlan_port=4789, vxlan_collect_metadata=True, vxlan_learning=False) as vx: vx.up() ifc_gc.append(vx.ifname) conf[c_int(1)] = c_int(vx.index) ipr.tc("add", "ingress", vx.index, "ffff:") ipr.tc("add-filter", "bpf", vx.index, ":1", fd=ingress_fn.fd, name=ingress_fn.name, parent="ffff:", action="drop", classid=1) for j in range(0, 2): vni = 10000 + j with ipdb.create(ifname="br%d" % j, kind="bridge") as br: for i in range(0, num_hosts): if i != host_id: v = ipdb.create(ifname="dummy%d%d" % (j , i), kind="dummy").up().commit() ipaddr = "172.16.1.%d" % (100 + i) tunkey2if_key = tunkey2if.Key(vni) tunkey2if_key.remote_ipv4 = IPAddress(ipaddr) tunkey2if_leaf = tunkey2if.Leaf(v.index) tunkey2if[tunkey2if_key] = tunkey2if_leaf if2tunkey_key = if2tunkey.Key(v.index) if2tunkey_leaf = if2tunkey.Leaf(vni) if2tunkey_leaf.remote_ipv4 = IPAddress(ipaddr) if2tunkey[if2tunkey_key] = if2tunkey_leaf ipr.tc("add", "sfq", v.index, "1:") ipr.tc("add-filter", "bpf", v.index, ":1", fd=egress_fn.fd, name=egress_fn.name, parent="1:", action="drop", classid=1) br.add_port(v) br.up() ifc_gc.append(v.ifname) if dhcp == 0: ipaddr = "99.1.%d.%d/24" % (j, host_id + 1) br.add_ip(ipaddr) ifc_gc.append(br.ifname) # dhcp server only runs on host 0 if dhcp == 1 and host_id == 0: for j in range(0, 2): v1 = "dhcp%d_v1" % j v2 = "dhcp%d_v2" % j br = ipdb.interfaces["br%d" % j] with ipdb.create(ifname=v1, kind="veth", peer=v2) as v: v.up() br.add_port(ipdb.interfaces[v1]).commit() dhcp_v2 = ipdb.interfaces[v2] dhcp_v2.add_ip("99.1.%d.1/24" % j).up().commit() call(["/bin/rm", "-f", "/tmp/dnsmasq.%d.leases" % j]) cmd = ["dnsmasq", "-d", "--bind-interfaces", "--strict-order", "--conf-file=", "--dhcp-range", "99.1.%d.2,99.1.%d.254,255.255.255.0,12h" % (j, j), "--dhcp-no-override", "--except-interface=lo", "--interface=dhcp%d_v2" % j, "--dhcp-authoritative", "--dhcp-leasefile=/tmp/dnsmasq.%d.leases" % j] d_serv.append(Popen(cmd, stdout=PIPE, stderr=PIPE)) # dhcp client to assign ip address for each bridge if dhcp == 1: for j in range(0, 2): call(["/bin/rm", "-rf", "/tmp/dhcp_%d_%d" % (host_id, j)]) call(["mkdir", "/tmp/dhcp_%d_%d" % (host_id, j)]) call(["touch", "/tmp/dhcp_%d_%d/dhclient.conf" % (host_id, j)]) call(["touch", "/tmp/dhcp_%d_%d/dhclient.lease" % (host_id, j)]) cmd = ["dhclient", "-d", "br%d" % j, "-cf", "/tmp/dhcp_%d_%d/dhclient.conf" % (host_id, j), "-lf", "/tmp/dhcp_%d_%d/dhclient.lease" % (host_id, j)] d_client.append(Popen(cmd, stdout=PIPE, stderr=PIPE)) # make sure we get address for eth0 retry = -1 while retry < 0: check = Popen(["ip", "addr", "show", "br%d" % j], stdout=PIPE, stderr=PIPE) out = check.stdout.read() checkip = b"99.1.%d" % j retry = out.find(checkip) try: run() input("") finally: for v in ifc_gc: call(["ip", "link", "del", v]) ipdb.release() for p in d_client: p.kill() for p in d_serv: p.kill() bpfcc-0.2.0+git0.02884a026/examples/networking/dns_matching/000077500000000000000000000000001305314114400231415ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/dns_matching/dns_matching.c000066400000000000000000000047701305314114400257530ustar00rootroot00000000000000/* * dns_matching.c Drop DNS packets requesting DNS name contained in hash map * For Linux, uses BCC, eBPF. See .py file. * * Copyright (c) 2016 Rudi Floren. * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public * License as published by the Free Software Foundation. * * 11-May-2016 Rudi Floren Created this. */ #include #include #include #include #include #include #include #define ETH_LEN 14 struct dns_hdr_t { uint16_t id; uint16_t flags; uint16_t qdcount; uint16_t ancount; uint16_t nscount; uint16_t arcount; } BPF_PACKET_HEADER; struct dns_query_flags_t { uint16_t qtype; uint16_t qclass; } BPF_PACKET_HEADER; struct dns_char_t { char c; } BPF_PACKET_HEADER; struct Key { unsigned char p[32]; }; struct Leaf { // Not really needed in this example unsigned char p[4]; }; BPF_TABLE("hash", struct Key, struct Leaf, cache, 128); int dns_matching(struct __sk_buff *skb) { u8 *cursor = 0; struct Key key = {}; // Check of ethernet/IP frame. struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); if(ethernet->type == ETH_P_IP) { // Check for UDP. struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); u16 hlen_bytes = ip->hlen << 2; if(ip->nextp == IPPROTO_UDP) { // Check for Port 53, DNS packet. struct udp_t *udp = cursor_advance(cursor, sizeof(*udp)); if(udp->dport == 53){ // Our Cursor + the length of our udp packet - size of the udp header // - the two 16bit values for QTYPE and QCLASS. u8 *sentinel = cursor + udp->length - sizeof(*udp) - 4; struct dns_hdr_t *dns_hdr = cursor_advance(cursor, sizeof(*dns_hdr)); // Do nothing if packet is not a request. if((dns_hdr->flags >>15) != 0) { // Exit if this packet is not a request. return -1; } u16 i = 0; struct dns_char_t *c; // This unroll worked not in latest BCC version. for(u8 j = 0; i<255;i++){ if (cursor == sentinel) goto end; c = cursor_advance(cursor, 1); key.p[i++] = c->c; } end: {} struct Leaf * lookup_leaf = cache.lookup(&key); // If DNS name is contained in our map, drop packet. if(lookup_leaf) { return 0; } } } } return -1; } bpfcc-0.2.0+git0.02884a026/examples/networking/dns_matching/dns_matching.py000066400000000000000000000023501305314114400261510ustar00rootroot00000000000000#!/usr/bin/python from __future__ import print_function from bcc import BPF from ctypes import * import sys import socket import os import struct def encode_dns(name): size = 32 if len(name) > 253: raise Exception("DNS Name too long.") b = bytearray(size) i = 0; elements = name.split(".") for element in elements: b[i] = struct.pack("!B", len(element)) i += 1 for j in range(0, len(element)): b[i] = element[j] i += 1 return (c_ubyte * size).from_buffer(b) # initialize BPF - load source code from http-parse-simple.c bpf = BPF(src_file = "dns_matching.c", debug=0) # print(bpf.dump_func("dns_test")) #load eBPF program http_filter of type SOCKET_FILTER into the kernel eBPF vm #more info about eBPF program types #http://man7.org/linux/man-pages/man2/bpf.2.html function_dns_matching = bpf.load_func("dns_matching", BPF.SOCKET_FILTER) #create raw socket, bind it to eth0 #attach bpf program to socket created BPF.attach_raw_socket(function_dns_matching, "eth1") # Get the table. cache = bpf.get_table("cache") # Create first entry for foo.bar key = cache.Key() key.p = encode_dns("foo.bar") leaf = cache.Leaf() leaf.p = (c_ubyte * 4).from_buffer(bytearray(4)) cache[key] = leaf bpf.trace_print() bpfcc-0.2.0+git0.02884a026/examples/networking/http_filter/000077500000000000000000000000001305314114400230275ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/http_filter/CMakeLists.txt000066400000000000000000000004331305314114400255670ustar00rootroot00000000000000set(FILES http-parse-complete.c http-parse-simple.c README.md) set(PROGRAMS http-parse-complete.py http-parse-simple.py) install(FILES ${FILES} DESTINATION share/bcc/examples/networking/http_filter) install(PROGRAMS ${PROGRAMS} DESTINATION share/bcc/examples/networking/http_filter) bpfcc-0.2.0+git0.02884a026/examples/networking/http_filter/README.md000066400000000000000000000040671305314114400243150ustar00rootroot00000000000000# HTTP Filter eBPF application that parses HTTP packets and extracts (and prints on screen) the URL contained in the GET/POST request. [eBPF HTTP Filter - Short Presentation](https://github.com/iovisor/bpf-docs/blob/master/ebpf_http_filter.pdf) ## Usage Example $ sudo python http-parse-complete.py GET /pipermail/iovisor-dev/ HTTP/1.1 HTTP/1.1 200 OK GET /favicon.ico HTTP/1.1 HTTP/1.1 404 Not Found GET /pipermail/iovisor-dev/2016-January/thread.html HTTP/1.1 HTTP/1.1 200 OK GET /pipermail/iovisor-dev/2016-January/000046.html HTTP/1.1 HTTP/1.1 200 OK ## Implementation overview The implementation is split in two portions: the former that exploits eBPF code, the latter that performs some additional processing in user space (the python wrapper). ### First part: eBPF filter This component filters IP and TCP packets containing the "HTTP", "GET", "POST" strings in their payload and all subsequent packets belonging to the same session, having the same (ip.src,ip.dst,port.src,port.dst) tuple. The program is loaded as PROG_TYPE_SOCKET_FILTER and attached to a socket, bind to eth0. Matching packets are forwarded to user space, the others are dropped by the filter. ### Second part: python code in user space The Python script reads filtered raw packets from the socket, if necessary reassembles packets belonging to the same session, and prints on stdout the first line of the HTTP GET/POST request. ## Simple vs. complete Two versions of this code are available in this repository: * simple version: it does not handle URLs that span across multiple packets. For instance, if the URL is too long it shows only the portion contained in the first packet. * complete version: it is able to cope with URLs spanning across multiple packets; if such a situation is detected, the code reassembles packets belonging to the same session and prints the complete URL. ## How to execute this sample This sample can be executed by typing either one the two commands below: $ sudo python http-parse-simple.py $ sudo python http-parse-complete.py bpfcc-0.2.0+git0.02884a026/examples/networking/http_filter/http-parse-complete.c000066400000000000000000000100741305314114400270720ustar00rootroot00000000000000#include #include #include #define IP_TCP 6 #define ETH_HLEN 14 struct Key { u32 src_ip; //source ip u32 dst_ip; //destination ip unsigned short src_port; //source port unsigned short dst_port; //destination port }; struct Leaf { int timestamp; //timestamp in ns }; //BPF_TABLE(map_type, key_type, leaf_type, table_name, num_entry) //map //tracing sessions having same Key(dst_ip, src_ip, dst_port,src_port) BPF_TABLE("hash", struct Key, struct Leaf, sessions, 1024); /*eBPF program. Filter IP and TCP packets, having payload not empty and containing "HTTP", "GET", "POST" as first bytes of payload. AND ALL the other packets having same (src_ip,dst_ip,src_port,dst_port) this means belonging to the same "session" this additional check avoids url truncation, if url is too long userspace script, if necessary, reassembles urls splitted in 2 or more packets. if the program is loaded as PROG_TYPE_SOCKET_FILTER and attached to a socket return 0 -> DROP the packet return -1 -> KEEP the packet and return it to user space (userspace can read it from the socket_fd ) */ int http_filter(struct __sk_buff *skb) { u8 *cursor = 0; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); //filter IP packets (ethernet type = 0x0800) if (!(ethernet->type == 0x0800)) { goto DROP; } struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); //filter TCP packets (ip next protocol = 0x06) if (ip->nextp != IP_TCP) { goto DROP; } u32 tcp_header_length = 0; u32 ip_header_length = 0; u32 payload_offset = 0; u32 payload_length = 0; struct Key key; struct Leaf zero = {0}; struct tcp_t *tcp = cursor_advance(cursor, sizeof(*tcp)); //retrieve ip src/dest and port src/dest of current packet //and save it into struct Key key.dst_ip = ip->dst; key.src_ip = ip->src; key.dst_port = tcp->dst_port; key.src_port = tcp->src_port; //calculate ip header length //value to multiply * 4 //e.g. ip->hlen = 5 ; IP Header Length = 5 x 4 byte = 20 byte ip_header_length = ip->hlen << 2; //SHL 2 -> *4 multiply //calculate tcp header length //value to multiply *4 //e.g. tcp->offset = 5 ; TCP Header Length = 5 x 4 byte = 20 byte tcp_header_length = tcp->offset << 2; //SHL 2 -> *4 multiply //calculate patload offset and length payload_offset = ETH_HLEN + ip_header_length + tcp_header_length; payload_length = ip->tlen - ip_header_length - tcp_header_length; //http://stackoverflow.com/questions/25047905/http-request-minimum-size-in-bytes //minimum length of http request is always geater than 7 bytes //avoid invalid access memory //include empty payload if(payload_length < 7) { goto DROP; } //load first 7 byte of payload into p (payload_array) //direct access to skb not allowed unsigned long p[7]; int i = 0; int j = 0; for (i = payload_offset ; i < (payload_offset + 7) ; i++) { p[j] = load_byte(skb , i); j++; } //find a match with an HTTP message //HTTP if ((p[0] == 'H') && (p[1] == 'T') && (p[2] == 'T') && (p[3] == 'P')) { goto HTTP_MATCH; } //GET if ((p[0] == 'G') && (p[1] == 'E') && (p[2] == 'T')) { goto HTTP_MATCH; } //POST if ((p[0] == 'P') && (p[1] == 'O') && (p[2] == 'S') && (p[3] == 'T')) { goto HTTP_MATCH; } //PUT if ((p[0] == 'P') && (p[1] == 'U') && (p[2] == 'T')) { goto HTTP_MATCH; } //DELETE if ((p[0] == 'D') && (p[1] == 'E') && (p[2] == 'L') && (p[3] == 'E') && (p[4] == 'T') && (p[5] == 'E')) { goto HTTP_MATCH; } //HEAD if ((p[0] == 'H') && (p[1] == 'E') && (p[2] == 'A') && (p[3] == 'D')) { goto HTTP_MATCH; } //no HTTP match //check if packet belong to an HTTP session struct Leaf * lookup_leaf = sessions.lookup(&key); if(lookup_leaf) { //send packet to userspace goto KEEP; } goto DROP; //keep the packet and send it to userspace retruning -1 HTTP_MATCH: //if not already present, insert into map sessions.lookup_or_init(&key,&zero); //send packet to userspace returning -1 KEEP: return -1; //drop the packet returning 0 DROP: return 0; } bpfcc-0.2.0+git0.02884a026/examples/networking/http_filter/http-parse-complete.py000066400000000000000000000252711305314114400273050ustar00rootroot00000000000000#!/usr/bin/python # #Bertrone Matteo - Polytechnic of Turin #November 2015 # #eBPF application that parses HTTP packets #and extracts (and prints on screen) the URL contained in the GET/POST request. # #eBPF program http_filter is used as SOCKET_FILTER attached to eth0 interface. #only packet of type ip and tcp containing HTTP GET/POST are returned to userspace, others dropped # #python script uses bcc BPF Compiler Collection by iovisor (https://github.com/iovisor/bcc) #and prints on stdout the first line of the HTTP GET/POST request containing the url from __future__ import print_function from bcc import BPF from ctypes import * from struct import * from sys import argv import sys import socket import os import struct import binascii import time CLEANUP_N_PACKETS = 50 #run cleanup every CLEANUP_N_PACKETS packets received MAX_URL_STRING_LEN = 8192 #max url string len (usually 8K) MAX_AGE_SECONDS = 30 #max age entry in bpf_sessions map #convert a bin string into a string of hex char #helper function to print raw packet in hex def toHex(s): lst = [] for ch in s: hv = hex(ord(ch)).replace('0x', '') if len(hv) == 1: hv = '0'+hv lst.append(hv) return reduce(lambda x,y:x+y, lst) #print str until CR+LF def printUntilCRLF(str): for k in range (0,len(str)-1): if (str[k] == '\n'): if (str[k-1] == '\r'): print ("") return print ("%c" % (str[k]), end = "") print("") return #cleanup function def cleanup(): #get current time in seconds current_time = int(time.time()) #looking for leaf having: #timestap == 0 --> update with current timestamp #AGE > MAX_AGE_SECONDS --> delete item for key,leaf in bpf_sessions.items(): try: current_leaf = bpf_sessions[key] #set timestamp if timestamp == 0 if (current_leaf.timestamp == 0): bpf_sessions[key] = bpf_sessions.Leaf(current_time) else: #delete older entries if (current_time - current_leaf.timestamp > MAX_AGE_SECONDS): del bpf_sessions[key] except: print("cleanup exception.") return #args def usage(): print("USAGE: %s [-i ]" % argv[0]) print("") print("Try '%s -h' for more options." % argv[0]) exit() #help def help(): print("USAGE: %s [-i ]" % argv[0]) print("") print("optional arguments:") print(" -h print this help") print(" -i if_name select interface if_name. Default is eth0") print("") print("examples:") print(" http-parse # bind socket to eth0") print(" http-parse -i wlan0 # bind socket to wlan0") exit() #arguments interface="eth0" if len(argv) == 2: if str(argv[1]) == '-h': help() else: usage() if len(argv) == 3: if str(argv[1]) == '-i': interface = argv[2] else: usage() if len(argv) > 3: usage() print ("binding socket to '%s'" % interface) # initialize BPF - load source code from http-parse-complete.c bpf = BPF(src_file = "http-parse-complete.c",debug = 0) #load eBPF program http_filter of type SOCKET_FILTER into the kernel eBPF vm #more info about eBPF program types #http://man7.org/linux/man-pages/man2/bpf.2.html function_http_filter = bpf.load_func("http_filter", BPF.SOCKET_FILTER) #create raw socket, bind it to interface #attach bpf program to socket created BPF.attach_raw_socket(function_http_filter, interface) #get file descriptor of the socket previously created inside BPF.attach_raw_socket socket_fd = function_http_filter.sock #create python socket object, from the file descriptor sock = socket.fromfd(socket_fd,socket.PF_PACKET,socket.SOCK_RAW,socket.IPPROTO_IP) #set it as blocking socket sock.setblocking(True) #get pointer to bpf map of type hash bpf_sessions = bpf.get_table("sessions") #packets counter packet_count = 0 #dictionary containing association #if url is not entirely contained in only one packet, save the firt part of it in this local dict #when I find \r\n in a next pkt, append and print all the url local_dictionary = {} while 1: #retrieve raw packet from socket packet_str = os.read(socket_fd,4096) #set packet length to max packet length on the interface packet_count += 1 #DEBUG - print raw packet in hex format #packet_hex = toHex(packet_str) #print ("%s" % packet_hex) #convert packet into bytearray packet_bytearray = bytearray(packet_str) #ethernet header length ETH_HLEN = 14 #IP HEADER #https://tools.ietf.org/html/rfc791 # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # |Version| IHL |Type of Service| Total Length | # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # #IHL : Internet Header Length is the length of the internet header #value to multiply * 4 byte #e.g. IHL = 5 ; IP Header Length = 5 * 4 byte = 20 byte # #Total length: This 16-bit field defines the entire packet size, #including header and data, in bytes. #calculate packet total length total_length = packet_bytearray[ETH_HLEN + 2] #load MSB total_length = total_length << 8 #shift MSB total_length = total_length + packet_bytearray[ETH_HLEN+3] #add LSB #calculate ip header length ip_header_length = packet_bytearray[ETH_HLEN] #load Byte ip_header_length = ip_header_length & 0x0F #mask bits 0..3 ip_header_length = ip_header_length << 2 #shift to obtain length #retrieve ip source/dest ip_src_str = packet_str[ETH_HLEN+12:ETH_HLEN+16] #ip source offset 12..15 ip_dst_str = packet_str[ETH_HLEN+16:ETH_HLEN+20] #ip dest offset 16..19 ip_src = int(toHex(ip_src_str),16) ip_dst = int(toHex(ip_dst_str),16) #TCP HEADER #https://www.rfc-editor.org/rfc/rfc793.txt # 12 13 14 15 # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # | Data | |U|A|P|R|S|F| | # | Offset| Reserved |R|C|S|S|Y|I| Window | # | | |G|K|H|T|N|N| | # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # #Data Offset: This indicates where the data begins. #The TCP header is an integral number of 32 bits long. #value to multiply * 4 byte #e.g. DataOffset = 5 ; TCP Header Length = 5 * 4 byte = 20 byte #calculate tcp header length tcp_header_length = packet_bytearray[ETH_HLEN + ip_header_length + 12] #load Byte tcp_header_length = tcp_header_length & 0xF0 #mask bit 4..7 tcp_header_length = tcp_header_length >> 2 #SHR 4 ; SHL 2 -> SHR 2 #retrieve port source/dest port_src_str = packet_str[ETH_HLEN+ip_header_length:ETH_HLEN+ip_header_length+2] port_dst_str = packet_str[ETH_HLEN+ip_header_length+2:ETH_HLEN+ip_header_length+4] port_src = int(toHex(port_src_str),16) port_dst = int(toHex(port_dst_str),16) #calculate payload offset payload_offset = ETH_HLEN + ip_header_length + tcp_header_length #payload_string contains only packet payload payload_string = packet_str[(payload_offset):(len(packet_bytearray))] #CR + LF (substring to find) crlf = "\r\n" #current_Key contains ip source/dest and port source/map #useful for direct bpf_sessions map access current_Key = bpf_sessions.Key(ip_src,ip_dst,port_src,port_dst) #looking for HTTP GET/POST request if ((payload_string[:3] == "GET") or (payload_string[:4] == "POST") or (payload_string[:4] == "HTTP") \ or ( payload_string[:3] == "PUT") or (payload_string[:6] == "DELETE") or (payload_string[:4] == "HEAD") ): #match: HTTP GET/POST packet found if (crlf in payload_string): #url entirely contained in first packet -> print it all printUntilCRLF(payload_string) #delete current_Key from bpf_sessions, url already printed. current session not useful anymore try: del bpf_sessions[current_Key] except: print ("error during delete from bpf map ") else: #url NOT entirely contained in first packet #not found \r\n in payload. #save current part of the payload_string in dictionary local_dictionary[binascii.hexlify(current_Key)] = payload_string else: #NO match: HTTP GET/POST NOT found #check if the packet belong to a session saved in bpf_sessions if (current_Key in bpf_sessions): #check id the packet belong to a session saved in local_dictionary #(local_dictionary mantains HTTP GET/POST url not printed yet because splitted in N packets) if (binascii.hexlify(current_Key) in local_dictionary): #first part of the HTTP GET/POST url is already present in local dictionary (prev_payload_string) prev_payload_string = local_dictionary[binascii.hexlify(current_Key)] #looking for CR+LF in current packet. if (crlf in payload_string): #last packet. containing last part of HTTP GET/POST url splitted in N packets. #append current payload prev_payload_string += payload_string #print HTTP GET/POST url printUntilCRLF(prev_payload_string) #clean bpf_sessions & local_dictionary try: del bpf_sessions[current_Key] del local_dictionary[binascii.hexlify(current_Key)] except: print ("error deleting from map or dictionary") else: #NOT last packet. containing part of HTTP GET/POST url splitted in N packets. #append current payload prev_payload_string += payload_string #check if not size exceeding (usually HTTP GET/POST url < 8K ) if (len(prev_payload_string) > MAX_URL_STRING_LEN): print("url too long") try: del bpf_sessions[current_Key] del local_dictionary[binascii.hexlify(current_Key)] except: print ("error deleting from map or dict") #update dictionary local_dictionary[binascii.hexlify(current_Key)] = prev_payload_string else: #first part of the HTTP GET/POST url is NOT present in local dictionary #bpf_sessions contains invalid entry -> delete it try: del bpf_sessions[current_Key] except: print ("error del bpf_session") #check if dirty entry are present in bpf_sessions if (((packet_count) % CLEANUP_N_PACKETS) == 0): cleanup() bpfcc-0.2.0+git0.02884a026/examples/networking/http_filter/http-parse-simple.c000066400000000000000000000054241305314114400265560ustar00rootroot00000000000000#include #include #include #define IP_TCP 6 #define ETH_HLEN 14 /*eBPF program. Filter IP and TCP packets, having payload not empty and containing "HTTP", "GET", "POST" ... as first bytes of payload if the program is loaded as PROG_TYPE_SOCKET_FILTER and attached to a socket return 0 -> DROP the packet return -1 -> KEEP the packet and return it to user space (userspace can read it from the socket_fd ) */ int http_filter(struct __sk_buff *skb) { u8 *cursor = 0; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); //filter IP packets (ethernet type = 0x0800) if (!(ethernet->type == 0x0800)) { goto DROP; } struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); //filter TCP packets (ip next protocol = 0x06) if (ip->nextp != IP_TCP) { goto DROP; } u32 tcp_header_length = 0; u32 ip_header_length = 0; u32 payload_offset = 0; u32 payload_length = 0; struct tcp_t *tcp = cursor_advance(cursor, sizeof(*tcp)); //calculate ip header length //value to multiply * 4 //e.g. ip->hlen = 5 ; IP Header Length = 5 x 4 byte = 20 byte ip_header_length = ip->hlen << 2; //SHL 2 -> *4 multiply //calculate tcp header length //value to multiply *4 //e.g. tcp->offset = 5 ; TCP Header Length = 5 x 4 byte = 20 byte tcp_header_length = tcp->offset << 2; //SHL 2 -> *4 multiply //calculate patload offset and length payload_offset = ETH_HLEN + ip_header_length + tcp_header_length; payload_length = ip->tlen - ip_header_length - tcp_header_length; //http://stackoverflow.com/questions/25047905/http-request-minimum-size-in-bytes //minimum length of http request is always geater than 7 bytes //avoid invalid access memory //include empty payload if(payload_length < 7) { goto DROP; } //load first 7 byte of payload into p (payload_array) //direct access to skb not allowed unsigned long p[7]; int i = 0; int j = 0; for (i = payload_offset ; i < (payload_offset + 7) ; i++) { p[j] = load_byte(skb , i); j++; } //find a match with an HTTP message //HTTP if ((p[0] == 'H') && (p[1] == 'T') && (p[2] == 'T') && (p[3] == 'P')) { goto KEEP; } //GET if ((p[0] == 'G') && (p[1] == 'E') && (p[2] == 'T')) { goto KEEP; } //POST if ((p[0] == 'P') && (p[1] == 'O') && (p[2] == 'S') && (p[3] == 'T')) { goto KEEP; } //PUT if ((p[0] == 'P') && (p[1] == 'U') && (p[2] == 'T')) { goto KEEP; } //DELETE if ((p[0] == 'D') && (p[1] == 'E') && (p[2] == 'L') && (p[3] == 'E') && (p[4] == 'T') && (p[5] == 'E')) { goto KEEP; } //HEAD if ((p[0] == 'H') && (p[1] == 'E') && (p[2] == 'A') && (p[3] == 'D')) { goto KEEP; } //no HTTP match goto DROP; //keep the packet and send it to userspace retruning -1 KEEP: return -1; //drop the packet returning 0 DROP: return 0; } bpfcc-0.2.0+git0.02884a026/examples/networking/http_filter/http-parse-simple.py000066400000000000000000000122401305314114400267560ustar00rootroot00000000000000#!/usr/bin/python # #Bertrone Matteo - Polytechnic of Turin #November 2015 # #eBPF application that parses HTTP packets #and extracts (and prints on screen) the URL contained in the GET/POST request. # #eBPF program http_filter is used as SOCKET_FILTER attached to eth0 interface. #only packet of type ip and tcp containing HTTP GET/POST are returned to userspace, others dropped # #python script uses bcc BPF Compiler Collection by iovisor (https://github.com/iovisor/bcc) #and prints on stdout the first line of the HTTP GET/POST request containing the url from __future__ import print_function from bcc import BPF from sys import argv import sys import socket import os #args def usage(): print("USAGE: %s [-i ]" % argv[0]) print("") print("Try '%s -h' for more options." % argv[0]) exit() #help def help(): print("USAGE: %s [-i ]" % argv[0]) print("") print("optional arguments:") print(" -h print this help") print(" -i if_name select interface if_name. Default is eth0") print("") print("examples:") print(" http-parse # bind socket to eth0") print(" http-parse -i wlan0 # bind socket to wlan0") exit() #arguments interface="eth0" if len(argv) == 2: if str(argv[1]) == '-h': help() else: usage() if len(argv) == 3: if str(argv[1]) == '-i': interface = argv[2] else: usage() if len(argv) > 3: usage() print ("binding socket to '%s'" % interface) # initialize BPF - load source code from http-parse-simple.c bpf = BPF(src_file = "http-parse-simple.c",debug = 0) #load eBPF program http_filter of type SOCKET_FILTER into the kernel eBPF vm #more info about eBPF program types #http://man7.org/linux/man-pages/man2/bpf.2.html function_http_filter = bpf.load_func("http_filter", BPF.SOCKET_FILTER) #create raw socket, bind it to interface #attach bpf program to socket created BPF.attach_raw_socket(function_http_filter, interface) #get file descriptor of the socket previously created inside BPF.attach_raw_socket socket_fd = function_http_filter.sock #create python socket object, from the file descriptor sock = socket.fromfd(socket_fd,socket.PF_PACKET,socket.SOCK_RAW,socket.IPPROTO_IP) #set it as blocking socket sock.setblocking(True) while 1: #retrieve raw packet from socket packet_str = os.read(socket_fd,2048) #DEBUG - print raw packet in hex format #packet_hex = toHex(packet_str) #print ("%s" % packet_hex) #convert packet into bytearray packet_bytearray = bytearray(packet_str) #ethernet header length ETH_HLEN = 14 #IP HEADER #https://tools.ietf.org/html/rfc791 # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # |Version| IHL |Type of Service| Total Length | # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # #IHL : Internet Header Length is the length of the internet header #value to multiply * 4 byte #e.g. IHL = 5 ; IP Header Length = 5 * 4 byte = 20 byte # #Total length: This 16-bit field defines the entire packet size, #including header and data, in bytes. #calculate packet total length total_length = packet_bytearray[ETH_HLEN + 2] #load MSB total_length = total_length << 8 #shift MSB total_length = total_length + packet_bytearray[ETH_HLEN+3] #add LSB #calculate ip header length ip_header_length = packet_bytearray[ETH_HLEN] #load Byte ip_header_length = ip_header_length & 0x0F #mask bits 0..3 ip_header_length = ip_header_length << 2 #shift to obtain length #TCP HEADER #https://www.rfc-editor.org/rfc/rfc793.txt # 12 13 14 15 # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # | Data | |U|A|P|R|S|F| | # | Offset| Reserved |R|C|S|S|Y|I| Window | # | | |G|K|H|T|N|N| | # +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # #Data Offset: This indicates where the data begins. #The TCP header is an integral number of 32 bits long. #value to multiply * 4 byte #e.g. DataOffset = 5 ; TCP Header Length = 5 * 4 byte = 20 byte #calculate tcp header length tcp_header_length = packet_bytearray[ETH_HLEN + ip_header_length + 12] #load Byte tcp_header_length = tcp_header_length & 0xF0 #mask bit 4..7 tcp_header_length = tcp_header_length >> 2 #SHR 4 ; SHL 2 -> SHR 2 #calculate payload offset payload_offset = ETH_HLEN + ip_header_length + tcp_header_length #print first line of the HTTP GET/POST request #line ends with 0xOD 0xOA (\r\n) #(if we want to print all the header print until \r\n\r\n) for i in range (payload_offset-1,len(packet_bytearray)-1): if (packet_bytearray[i]== 0x0A): if (packet_bytearray[i-1] == 0x0D): break print ("%c" % chr(packet_bytearray[i]), end = "") print("") bpfcc-0.2.0+git0.02884a026/examples/networking/neighbor_sharing/000077500000000000000000000000001305314114400240135ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/neighbor_sharing/CMakeLists.txt000066400000000000000000000004531305314114400265550ustar00rootroot00000000000000set(EXAMPLE_FILES README.txt simulation.py tc_neighbor_sharing.c) set(EXAMPLE_PROGRAMS tc_neighbor_sharing.py) install(FILES ${EXAMPLE_FILES} DESTINATION share/bcc/examples/networking/neighbor_sharing) install(PROGRAMS ${EXAMPLE_PROGRAMS} DESTINATION share/bcc/examples/networking/neighbor_sharing) bpfcc-0.2.0+git0.02884a026/examples/networking/neighbor_sharing/README.txt000066400000000000000000000052231305314114400255130ustar00rootroot00000000000000This example shows how a combination of BPF programs can be used to perform per-IP classification and rate limiting. The simulation in this example shows an example where N+M devices are combined and use 1 WAN. Traffic sent from/to the "neighbor" devices have their combined bandwidth capped at 128kbit, and the rest of the traffic can use an additional 1Mbit. This works by sharing a map between various tc ingress filters, each with a related set of bpf functions attached. The map stores a list of dynamically learned ip addresses that were seen on the neighbor devices and should be throttled. /------------\ | neigh1 --|->->->->->->->-| | | neigh2 --|->->->->->->->-| <-128kb-| /------\ | neigh3 --|->->->->->->->-| | wan0 | wan | | | ^ | br100 |-<-<-<--| sim | | | clsfy_neigh() | | ^ \------/ | lan1 ----|->->->->->->->-| <--1Mb--| | | lan2 ----|->->->->->->->-| | classify_wan() | ^ \------------/ | pass() | To run the example: $ sudo /path/to/neighbor_sharing/neighbor_sharing.py Starting netserver with host 'IN(6)ADDR_ANY' port '12865' and family AF_UNSPEC Starting netserver with host 'IN(6)ADDR_ANY' port '12865' and family AF_UNSPEC Starting netserver with host 'IN(6)ADDR_ANY' port '12865' and family AF_UNSPEC Starting netserver with host 'IN(6)ADDR_ANY' port '12865' and family AF_UNSPEC Starting netserver with host 'IN(6)ADDR_ANY' port '12865' and family AF_UNSPEC Network ready. Create a shell in the wan0 namespace and test with netperf (Neighbors are 172.16.1.100-102, and LAN clients are 172.16.1.150-151) e.g.: ip netns exec wan0 netperf -H 172.16.1.100 -l 2 Press enter when finished: In another shell: $ sudo ip netns exec wan0 netperf -H 172.16.1.100 -l 2 MIGRATED TCP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 172.16.1.100 () port 0 AF_INET : demo Recv Send Send Socket Socket Message Elapsed Size Size Size Time Throughput bytes bytes bytes secs. 10^6bits/sec 87380 16384 16384 4.30 0.18 $ sudo ip netns exec wan0 netperf -H 172.16.1.150 -l 2 MIGRATED TCP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 172.16.1.150 () port 0 AF_INET : demo Recv Send Send Socket Socket Message Elapsed Size Size Size Time Throughput bytes bytes bytes secs. 10^6bits/sec 87380 16384 16384 4.10 1.01 The bandwidth is throttled according to the IP. bpfcc-0.2.0+git0.02884a026/examples/networking/neighbor_sharing/simulation.py000077700000000000000000000000001305314114400315152../simulation.pyustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/neighbor_sharing/tc_neighbor_sharing.c000066400000000000000000000031621305314114400301570ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include struct ipkey { u32 client_ip; }; BPF_TABLE("hash", struct ipkey, int, learned_ips, 1024); // trivial action int pass(struct __sk_buff *skb) { return 1; } // Process each wan packet, and determine if the packet is in the IP // table or not. Learned IPs are rate-limited and unclassified are not. // returns: > 0 when an IP is known // = 0 when an IP is not known, or non-IP traffic int classify_wan(struct __sk_buff *skb) { u8 *cursor = 0; ethernet: { struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); switch (ethernet->type) { case ETH_P_IP: goto ip; default: goto EOP; } } ip: { struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); u32 dip = ip->dst; struct ipkey key = {.client_ip=dip}; int *val = learned_ips.lookup(&key); if (val) return *val; goto EOP; } EOP: return 0; } // Process each neighbor packet, and store the source IP in the learned table. // Mark the inserted entry with a non-zero value to be used by the classify_wan // lookup. int classify_neighbor(struct __sk_buff *skb) { u8 *cursor = 0; ethernet: { struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); switch (ethernet->type) { case ETH_P_IP: goto ip; default: goto EOP; } } ip: { struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); u32 sip = ip->src; struct ipkey key = {.client_ip=sip}; int val = 1; learned_ips.update(&key, &val); goto EOP; } EOP: return 1; } bpfcc-0.2.0+git0.02884a026/examples/networking/neighbor_sharing/tc_neighbor_sharing.py000077500000000000000000000056621305314114400303770ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF from pyroute2 import IPRoute, NetNS, IPDB, NSPopen from simulation import Simulation import sys from time import sleep from builtins import input ipr = IPRoute() ipdb = IPDB(nl=ipr) b = BPF(src_file="tc_neighbor_sharing.c", debug=0) wan_fn = b.load_func("classify_wan", BPF.SCHED_CLS) pass_fn = b.load_func("pass", BPF.SCHED_CLS) neighbor_fn = b.load_func("classify_neighbor", BPF.SCHED_CLS) num_neighbors = 3 num_locals = 2 # class to build the simulation network class SharedNetSimulation(Simulation): def __init__(self, ipdb): super(SharedNetSimulation, self).__init__(ipdb) # Create the wan namespace, and attach an ingress filter for throttling # inbound (download) traffic wan_if = self._create_ns("wan0", ipaddr="172.16.1.5/24")[1] ipr.tc("add", "ingress", wan_if["index"], "ffff:") ipr.tc("add-filter", "bpf", wan_if["index"], ":1", fd=wan_fn.fd, prio=1, name=wan_fn.name, parent="ffff:", action="drop", classid=1, rate="128kbit", burst=1024 * 32, mtu=16 * 1024) ipr.tc("add-filter", "bpf", wan_if["index"], ":2", fd=pass_fn.fd, prio=2, name=pass_fn.name, parent="ffff:", action="drop", classid=2, rate="1024kbit", burst=1024 * 32, mtu=16 * 1024) self.wan_if = wan_if # start the namespaces that compose the network, interconnect them with the # bridge, and attach the tc filters def start(self): neighbor_list = [] local_list = [] cmd = ["netserver", "-D"] for i in range(0, num_neighbors): ipaddr = "172.16.1.%d/24" % (i + 100) ret = self._create_ns("neighbor%d" % i, ipaddr=ipaddr, fn=neighbor_fn, cmd=cmd) neighbor_list.append(ret) for i in range(0, num_locals): ipaddr = "172.16.1.%d/24" % (i + 150) ret = self._create_ns("local%d" % i, ipaddr=ipaddr, fn=pass_fn, cmd=cmd) local_list.append(ret) with ipdb.create(ifname="br100", kind="bridge") as br100: for x in neighbor_list: br100.add_port(x[1]) for x in local_list: br100.add_port(x[1]) br100.add_port(self.wan_if) br100.up() try: sim = SharedNetSimulation(ipdb) sim.start() print("Network ready. Create a shell in the wan0 namespace and test with netperf") print(" (Neighbors are 172.16.1.100-%d, and LAN clients are 172.16.1.150-%d)" % (100 + num_neighbors - 1, 150 + num_locals - 1)) print(" e.g.: ip netns exec wan0 netperf -H 172.16.1.100 -l 2") input("Press enter when finished: ") finally: if "sim" in locals(): sim.release() if "br100" in ipdb.interfaces: ipdb.interfaces.br100.remove().commit() ipdb.release() bpfcc-0.2.0+git0.02884a026/examples/networking/simple_tc.py000077500000000000000000000015161305314114400230420ustar00rootroot00000000000000#!/usr/bin/python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF from pyroute2 import IPRoute ipr = IPRoute() text = """ int hello(struct __sk_buff *skb) { return 1; } """ try: b = BPF(text=text, debug=0) fn = b.load_func("hello", BPF.SCHED_CLS) ipr.link_create(ifname="t1a", kind="veth", peer="t1b") idx = ipr.link_lookup(ifname="t1a")[0] ipr.tc("add", "ingress", idx, "ffff:") ipr.tc("add-filter", "bpf", idx, ":1", fd=fn.fd, name=fn.name, parent="ffff:", action="ok", classid=1) ipr.tc("add", "sfq", idx, "1:") ipr.tc("add-filter", "bpf", idx, ":1", fd=fn.fd, name=fn.name, parent="1:", action="ok", classid=1) finally: if "idx" in locals(): ipr.link_remove(idx) print("BPF tc functionality - SCHED_CLS: OK") bpfcc-0.2.0+git0.02884a026/examples/networking/simulation.py000066400000000000000000000105211305314114400232400ustar00rootroot00000000000000import os import subprocess import pyroute2 from pyroute2 import IPRoute, NetNS, IPDB, NSPopen class Simulation(object): """ Helper class for controlling multiple namespaces. Inherit from this class and setup your namespaces. """ def __init__(self, ipdb): self.ipdb = ipdb self.ipdbs = {} self.namespaces = [] self.processes = [] self.released = False # helper function to add additional ifc to namespace # if called directly outside Simulation class, "ifc_base_name" should be # different from "name", the "ifc_base_name" and "name" are the same for # the first ifc created by namespace def _ns_add_ifc(self, name, ns_ifc, ifc_base_name=None, in_ifc=None, out_ifc=None, ipaddr=None, macaddr=None, fn=None, cmd=None, action="ok", disable_ipv6=False): if name in self.ipdbs: ns_ipdb = self.ipdbs[name] else: try: nl=NetNS(name) self.namespaces.append(nl) except KeyboardInterrupt: # remove the namespace if it has been created pyroute2.netns.remove(name) raise ns_ipdb = IPDB(nl) self.ipdbs[nl.netns] = ns_ipdb if disable_ipv6: cmd1 = ["sysctl", "-q", "-w", "net.ipv6.conf.default.disable_ipv6=1"] nsp = NSPopen(ns_ipdb.nl.netns, cmd1) nsp.wait(); nsp.release() ns_ipdb.interfaces.lo.up().commit() if in_ifc: in_ifname = in_ifc.ifname with in_ifc as v: # move half of veth into namespace v.net_ns_fd = ns_ipdb.nl.netns else: # delete the potentially leaf-over veth interfaces ipr = IPRoute() for i in ipr.link_lookup(ifname='%sa' % ifc_base_name): ipr.link_remove(i) ipr.close() try: out_ifc = self.ipdb.create(ifname="%sa" % ifc_base_name, kind="veth", peer="%sb" % ifc_base_name).commit() in_ifc = self.ipdb.interfaces[out_ifc.peer] in_ifname = in_ifc.ifname with in_ifc as v: v.net_ns_fd = ns_ipdb.nl.netns except KeyboardInterrupt: # explicitly remove the interface out_ifname = "%sa" % ifc_base_name if out_ifname in self.ipdb.interfaces: self.ipdb.interfaces[out_ifname].remove().commit() raise if out_ifc: out_ifc.up().commit() ns_ipdb.interfaces.lo.up().commit() in_ifc = ns_ipdb.interfaces[in_ifname] with in_ifc as v: v.ifname = ns_ifc if ipaddr: v.add_ip("%s" % ipaddr) if macaddr: v.address = macaddr v.up() if disable_ipv6: cmd1 = ["sysctl", "-q", "-w", "net.ipv6.conf.%s.disable_ipv6=1" % out_ifc.ifname] subprocess.call(cmd1) if fn and out_ifc: self.ipdb.nl.tc("add", "ingress", out_ifc["index"], "ffff:") self.ipdb.nl.tc("add-filter", "bpf", out_ifc["index"], ":1", fd=fn.fd, name=fn.name, parent="ffff:", action=action, classid=1) if cmd: self.processes.append(NSPopen(ns_ipdb.nl.netns, cmd)) return (ns_ipdb, out_ifc, in_ifc) # helper function to create a namespace and a veth connecting it def _create_ns(self, name, in_ifc=None, out_ifc=None, ipaddr=None, macaddr=None, fn=None, cmd=None, action="ok", disable_ipv6=False): (ns_ipdb, out_ifc, in_ifc) = self._ns_add_ifc(name, "eth0", name, in_ifc, out_ifc, ipaddr, macaddr, fn, cmd, action, disable_ipv6) return (ns_ipdb, out_ifc, in_ifc) def release(self): if self.released: return self.released = True for p in self.processes: if p.released: continue try: p.kill() p.wait() except: pass finally: p.release() for name, db in self.ipdbs.items(): db.release() for ns in self.namespaces: ns.remove() bpfcc-0.2.0+git0.02884a026/examples/networking/tc_perf_event.py000077500000000000000000000047061305314114400237120ustar00rootroot00000000000000#!/usr/bin/env python # # tc_perf_event.py Output skb and meta data through perf event # # Copyright (c) 2016-present, Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF import ctypes as ct import pyroute2 import socket bpf_txt = """ #include #include #include #include #include BPF_PERF_OUTPUT(skb_events); struct eth_hdr { unsigned char h_dest[ETH_ALEN]; unsigned char h_source[ETH_ALEN]; unsigned short h_proto; }; int handle_egress(struct __sk_buff *skb) { void *data = (void *)(long)skb->data; void *data_end = (void *)(long)skb->data_end; struct eth_hdr *eth = data; struct ipv6hdr *ip6h = data + sizeof(*eth); u32 magic = 0xfaceb00c; /* single length check */ if (data + sizeof(*eth) + sizeof(*ip6h) > data_end) return TC_ACT_OK; if (eth->h_proto == htons(ETH_P_IPV6) && ip6h->nexthdr == IPPROTO_ICMPV6) skb_events.perf_submit_skb(skb, skb->len, &magic, sizeof(magic)); return TC_ACT_OK; }""" def print_skb_event(cpu, data, size): class SkbEvent(ct.Structure): _fields_ = [ ("magic", ct.c_uint32), ("raw", ct.c_ubyte * (size - ct.sizeof(ct.c_uint32))) ] skb_event = ct.cast(data, ct.POINTER(SkbEvent)).contents icmp_type = int(skb_event.raw[54]) # Only print for echo request if icmp_type == 128: src_ip = bytes(skb_event.raw[22:38]) dst_ip = bytes(skb_event.raw[38:54]) print("%-3s %-32s %-12s 0x%08x" % (cpu, socket.inet_ntop(socket.AF_INET6, src_ip), socket.inet_ntop(socket.AF_INET6, dst_ip), skb_event.magic)) try: b = BPF(text=bpf_txt) fn = b.load_func("handle_egress", BPF.SCHED_CLS) ipr = pyroute2.IPRoute() ipr.link("add", ifname="me", kind="veth", peer="you") me = ipr.link_lookup(ifname="me")[0] you = ipr.link_lookup(ifname="you")[0] for idx in (me, you): ipr.link('set', index=idx, state='up') ipr.tc("add", "clsact", me) ipr.tc("add-filter", "bpf", me, ":1", fd=fn.fd, name=fn.name, parent="ffff:fff3", classid=1, direct_action=True) b["skb_events"].open_perf_buffer(print_skb_event) print('Try: "ping -6 ff02::1%me"\n') print("%-3s %-32s %-12s %-10s" % ("CPU", "SRC IP", "DST IP", "Magic")) while True: b.kprobe_poll() finally: if "me" in locals(): ipr.link("del", index=me) bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/000077500000000000000000000000001305314114400235575ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/CMakeLists.txt000066400000000000000000000004351305314114400263210ustar00rootroot00000000000000set(FILES README.md chord.png monitor.c simulation.py vxlan.jpg) set(PROGRAMS main.py monitor.py setup.sh traffic.sh) install(FILES ${FILES} DESTINATION share/bcc/examples/networking/tunnel_monitor) install(PROGRAMS ${PROGRAMS} DESTINATION share/bcc/examples/networking/tunnel_monitor)bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/README.md000066400000000000000000000050631305314114400250420ustar00rootroot00000000000000## Tunnel Monitor Example This example shows how to use a BPF program to parse packets across an encapsulation boundary. It uses this ability to record inner+outer ip addresses as well as vxlan id into a hash table. The entries in that table store bytes and packets received/transmitted. One novel part of this program is its use of `bpf_tail_call` to parse two different IP headers (inner/outer) using the same state machine logic. Also part of this example is a simulation of a multi-host environment with an overlay network (using vxlan in this case), and each host contains multiple clients in different segments of the overlay network. The script `traffic.sh` can be used to simulate a subset of clients on host0 talking to various other clients+hosts at different traffic rates. ![Overlay Diagram](vxlan.jpg) Once the simulation is running, the statistics kept by the BPF program can be displayed to give a visual clue as to the nature of the traffic flowing over the physical interface, post-encapsulation. ![Chord Diagram](chord.png) To get the example running, change into the examples/tunnel_monitor directory. If this is the first time, run `setup.sh` to pull in the UI component and dependencies. You will need nodejs+npm installed on the system to run this, but the setup script will only install packages in the local directory. ``` [user@localhost tunnel_monitor]$ ./setup.sh Cloning into 'chord-transitions'... remote: Counting objects: 294, done. ... jquery#2.1.4 bower_components/jquery modernizr#2.8.3 bower_components/modernizr fastclick#1.0.6 bower_components/fastclick [user@localhost tunnel_monitor]$ ``` Then, start the simulation by running main.py: ``` [root@bcc-dev tunnel_monitor]# python main.py Launching host 1 of 9 Launching host 2 of 9 ... Starting tunnel 8 of 9 Starting tunnel 9 of 9 HTTPServer listening on 0.0.0.0:8080 Press enter to quit: ``` The prompt will remain until you choose to exit. In the background, the script has started a python SimpleHTTPServer on port 8080, which you may now try to connect to from your browser. There will likely be a blank canvas until traffic is sent through the tunnels. To simulate traffic, use the traffic.sh script to generate a distribution of pings between various clients and hosts. Check back on the chord diagram to see a visualization. Try clicking on a host IP address to see a breakdown of the inner IP addresses sent to/from that host. As an exercise, try modifying the traffic.sh script to cause one of the clients to send much more traffic than the others, and use the chord diagram to identify the culprit. bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/chord.png000066400000000000000000003017121305314114400253700ustar00rootroot00000000000000PNG  IHDR8gVsBITOtEXtSoftwaregnome-screenshot> IDATx{XeET`LX V2Ht)D۷[b]jY+VWb[ &]Ѵ@[C:嘧!Oc*y`"h 8{1sյ/n޷_ee-4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 74ޫZVVv룣o~BJDDDHHӄNfsѣW^@h4c˖-| {ܭJݬeeeeddW>Ç7S۷|]ȑ#G-)ڵ/{'|7)=zO>o:x7'z@dA 4@F3g/_{w6lhM4KT~wЂ h, Ȃ _o@=v{qqqˮ]}Ç׮]cǎ={ n۷!C C^ܞ={\RO>J}~~]v9rܹs۷޽{xxaƎݻwGq8/_nӦMzywFFF^S Q\\}...>|``Rٳw=dȐo{lzZ{9srBԩS5w=\@ keddW>Ç{K/'WX7|s͚5/y䑿U_۷o[lLtnׯOMM5jԳ>{=x/gΜ~o7뜜 3^>`PP7{h4Koĉ=gO6m7+++ .L>L%ʖ-[6v܆>˩111uBϝ;766vƍ }}7O=TgǍu:J*6mr?#/]k.o^z5//Ͻ2jԨO?4&&7߬7}B߿ȑ#74TTT̚5kѢE^N|wRRR89eʔkz?䩧r?]/{?_^{5VVV6?ބ>?7ި-m۶ul޼kJyw;w:Nرc%c***%%%^nJIIIJJSO=ޣԍh~|獘'lذAS\裏l>299 ޷oɓ8ЧTx^ڸ˗}>+,^g^),,}BBB ťKN;;{ĉÆ {3@@͎{:|Qӎ;oB 888<<GGGKzr/޽{wwɒ%UY5{={g=s ?PT*3[.]:`ɓ'KV=z/^ټyiXm=ͯ\cǎ#F1رccƌ2y䔔[nŽtw>k֬5kS;x@s5jԨUVIgw~OF,Y"I=#$<:㏿=ܓ=|pI}[#Gb.]?v:]v&?q¼y<{#""½_VVVT6ОG0??߽2bĈTI,q}ےbq8uN@Thh[wp&;z˽XGW &̜9a'O^b%?~|㋋322<y}BxFݻgΜYd3>^@?~Mo]v$U~I}ر'/^tVPݛ*|&) En\d25I]XX#)&''{>W4hГO>ӽsυG-iӦ:͛7;vlnnn˽{… x7 %ݻ׶ @{vh4?zkll{}뭷W***Ο?zJrVTOY***,Kmsl"9@{^o6 z͛۷gr.4 >߿*\tQQQr.W2k׮… Ngmkk߾}rrrBB{U[l A 4?sOKN@ !$gEqN=oTWtt۶m ](++$ &4b)ǎPxկ;\.WKN׶mAO"// !  >|شiSG 4?(x=Nڞ={$U{^9qĹsT?J~R$7yO>ϗ/_>tdؐ!C$]kK{%7.^>h߾N5jȑ#ju@͏lrk߾L+~ݜJKKe]7m]=(((22ҽ"!<"iyĈo8qرcu?N7|o:t_|O1?O4#LTkTYY)xbb@@@#GjJbKN@Ѓ,+9-ͯ7n\paü&:uW_/,,r =[IO!D۶mZooZπѫyέ;ޛRb֭f;}twqG׮]_<=t޶m۔)StbqV7L0a„ gΜY~ lRcO2?ouB@hhLB}#SiTlq…F9++w.KpӦMtǟ1=vz˖-eee/FՀ s<qDqq{% G޽{ݻ/]T]j;v:t{ ?p̙b6mbbbIӶmѣGg=w!,00PR9wӋ tGҠA$-5o޼ |'6lGuرF׮]ۈ֬Y#hZ޴iBrg*#Fp}WJo <[oGYn]zzY:v+ѡC? N\B4 7nl4W#GC?nݺuذa Z̔7o,9o*zfW/_>iҤ䐲ѣGG/KKK % .z̘1uyp=x?։h.]W*++Ν{պ'͝;Wέ53111ZVR\pavv7ٖ744n3gΔTǴiӼie?'&&z՞kHrHjFVTTF(kwd…7#/&&FRܶmO?]RRR㔋/=XYYlN͛'^xW=;[n?~~ʬY8E !NV)Sv]o%zJ5?CiSɂ'M^)))yG$}=zѣǽ[ChƘ:uo޽… gΜٺu뫯^}fsРAU?{l~/^,9zů:11d2]pA2h47N)))d8sm޼ʕ+ 6DRɱ+99y֬Yʫ9rd޽ǎ-}3fG} 6[^z-_<""w\RXXo߾C?ѣGX&mL~gy뭷 ٭[7#[!22/\bEffT*{1N7Z``9sFcFFի$s?ԩSJe+PVw޽މ7nt/4UէXn7WvB~X֯?rzjǎ{u]wDEEI+۵k{7;ＳC7|7/Ͷyfzqҥ={w4hȑ#ož/+ '~WRRaÆof?~ܹseee:t 뮻F?ǥor%%%yyy{7RRRRRRR^^޾}Ν;u]Æ 2d??@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Y@d ta_o۷4_eehh4@Y@dA 4@Y@dA 4li IDAT@Y@dA 4@Y@dA 4@Y@dA 4@Y@dA 4@Yzh | |ѽ{w_o]aaKȂ h, Ȃ h, Ȃ h,}J-&1oꄞB3-;-$~in@ٸnZf?z5"aRX| 8oymR6N'hs>Qaఞ|1pԨEul>L>G @K5ByIЂ hZ}s""+W !Dɚ¦mt{ʲtδaaaaaa v|+N߹0x4i6E&yJ hַ8~tB,{񵳦MۄӇ?{=%.J694'#L!DɉCkV?3~ƚ˴[b%<4tݦB۴iW !y˜˨Yoά,@صT+> B}$he%M"'̥̕;tǃ"ַ5eeT!=FhBQf\aٷoߡB3$(˟;>ᵵ\Jxy '^y{{N2E!Mxf/ wq˒3֕ !zLJ44G\BCXOus^'Dy%c^_ZYNgLq͔wYuҢ75s^37",џ#N@X!m!ʁa7mpC"z2466^:MkϺ?/BE_lZ:LUVVzhu w]+,, .|Y@9>):::::V9;e!DuΘ1I9-;cX~^Rj .han0BRO}v{.!пWvZG +hi:jb:!ı?5б>{Bt<_+eIkuIyN_oM-N@ !DѪ:gB5kDMM4EƤ"h5!F o^BQ}eWe !Ā*{"": !/gAP&)kadG 2h}@wori !f ! Or̀?u"9C>\ inbN9*qE-hNYt:NGWMC5օ$iE Ft누?9+d+{Q+M/X(dHvaz2ic+ġw^ޞ673WNTWtCSj{70[PRXhL$톋d[/h\2_fo"f\h!-;K@ hN4|n8<'=N})K8 RJNXh*BL'!ĕ ׾uv{Wa h/Ňz !ġKa:SQGcL˻ M\bbg0:VQTE*݄W~ ǖA />K!r&4&t,yd1NӨ~~10zZFU %lsxZ'ZpCbW1_i}!QR&ǖh~+k Vh4FQ].Pp*;h` %goq&Tw>SLJS맾sH[6罘;ajVQذك+p8ی4-4j@Kv됄8B[S$fHAޓ_|*L!Vyo87!9-5)hk}> !B"5 !FQAq,{OB}닅a~C/>!E+^~o߅psq9V@;RM&SRjZ9ji-R!9i5 hOMQ*秲 -b~C/%4q%jו 挌EgN?`J5[;PB8I\-] { !foT~/jZlCe+.>yd /Y8cJҞ1;~`'֘j B@S$D!r{+BtAu&€vM9Ҫ_oRRkĤ)عxJ)J_NAAA} @vY8-qυlkޑBnZVK^N9w9!DHԔ8kb|+GA}C$ 7h4Z hr̴6 !DȔ ,׻r9,9i !ߖQNSRth |4n^z @cz̓Ӟc2% 0vh3hnU%,IIv%S9NЙRR kqYSt9'ff&8 7N9#Zh:9˜e6-BSFAU݌.1bLu QV(\g[98[*C GVC #5>qU !ã`4 $vP(dRB3uxsŜ-!)͐lħZu;@m|B2N^vRMqNћ-UP듲lYGT 2[v.r3PBno_ Rl}ٖj̴ߠ=eIT+)tSEYf{EP)p:] mRe~sy.QA+u]17 P++RsӇtI9lDOʳY2ֵ29xXTr mrN G?R?ݜb>ժhaBh&3s|@4@2q©E4ϠYmL1ͱ4zJZԥl[%rgG߮>型LI47ש*ޘ F-9TL3L Rs:P8٠JnqZ٪N2[bP+iI7jm$Ъ9ԙ2L׹y-4@=8u|niFFAܒiq|@+Pjw B iDôkЩ-gƢnS3 Ь6&6 PSZR)rNfZVK΢+ !˴ z_4AVujnq# MbMgLINN[|"$eYiI])5]x>J)Y'-cW.%'+3-;! XN5dVhRq.ӥP*;5,8GmF4CI%})}A̙"|B6nDVg#h ڸDЧf|79s~~~*m\jgp٭y9y66RK8qڱr8)M,qT O]K7@xǞl2%%Չfsžq#Ôn'f$& %e\W;4w.KFƢޮ'epXIL1doPӒ7jSE%foK`ׯfĞ-4wTH!Bf̘,zhJlKRhJjGreg՞t:q3ϭ3Y8 4TzqΡ2eNQn\GcH6ؙuT7 FiN6ΐl`ܑgtZFV) ?????[:uOĸEBܙCu>iAf 4j1|{r.)f2^ 4rNtrVLLE:3 zW6rb RT4jBT*JRR~{ԨrM}Hά{M{/J}gr?_93MuLHמiѽnj))ǾT_]lƅ١->w?p"&..|{I-jCr-1/3%%-s|!DH%q*_Sp( ISӗ/VMMKOK6dqQ M,9unqU<}_q6H 3{j!t<)*eV<{ZTM>q]WonzShn22k9+mlфf}nFժ5FQ<VF2R(=3hj ǩAڬ;e)./gLVW_oq999weK5DuFNZ@U\UYY]+fG+P6{K$ 6(y#;V`˿jo<~u:mXOM6>A8eɍB`!@8 @.Kvhs玜nYVt PzC\^ݸKN6+[s 8NcL4sڸdNmP?eKR7nEd,|[݀9D'阉CG̅>S(GX/U(O^:es)B:'ߟ4@)BԾH\6sJRrZn>G fD7 ];$.%B£n1otťd4 Úb26a*Jp9%Go|مBO nF,KO[1k<!^XcX^극kWp-z@4!J˘>To2}#ږ`WeG̬Ͳm~=#Ɛgs?Is B&kKIPKp4ž\K͜ JZ-x!ݤž<;9=PMiڄZMELy7$* XPR/b 1)ҐiݹdDfXȉ/,oI)jS#NK*3jhN{^9++˼2H!DȀSFc\Pi5LkJ353-_L(˖7}FKML3'yPt6\vٜe2 !DHةFѠת|YOI @'J=Ϝ{TD.N+i8L]f-@/9-i,15ŤW^ 3BGMyh4|;QhSr->qafI-PlNEc7鲥ƴti6 e#^RZU biZѨm ڤz>Π bk iyTjsZuY!ʕ uJQdMɯ{@SPPн{w_]aaaxxw4953)nGG" ta9.Tk47[<}\ݥPUMÅf-=p|.[7-+ŔQ!BꤍYi5%uj-8pЁߢԙ2m)ê ZC k^q)D/dh} ݜhZH!DHZ)i:–cTݠu}G-+3ٻ4_-֌,k(bwKyx^B!zjP7~-}MVCO R8yH)\XrB.̗O+MV-HJ aˮ)F&WW!B!aB؍UJɦ_N~d7V+%OfvCR]kU>SKbzzYm_XK IDAT)ӨFj-n*tYU!Bg!eVI2^z;VV%n0|uJAWri)(u|UmdhbV'єb]jJ-A#B!~=B!4lH[IXUk7*蕫xm)DRɓAv; @^i8<{ݠ~^ct1}Thj)(bv BI3_B!Z_0Fn``(v%%%%''{i!r)X{O嬦FW=2`ȕ2VU] V{5U |P9i:xV$M5gĴRÎYrtIvRK!BX`0k@NsssffJ_%n$|>v)߼ysTvA+ ܫ@huЦr-::islYkJBL-}}Y1Mk!}~T+gj?Vi Q2k4A$I$ Bo L^_ Z QC@.333;;{===?#s6x<1} B'2M3Fd7|MByZmXo2"I3B!Bh~E˵i&>;}KOOt:xQK m6[8B !JrB&!5JŨ{UHiWbrp( g; Tp/!B! hj[^mg;t萬d# ~/_׆BK,W+d2`8--0 3eP}5d7j+ռ&B!BM44|>0ߧsc\.S '..n5?k;wT ]aZZ)r@ώT ;*XVYLg?|_k^ 4/B!Bhi&/O3K`I"3&t(&cK!,ڪ/WeRLTW2GnIi[br*boi E4XyuUB!z6`hiRSS۳?Ok4}C)ڼyZp)mlhmjp=Zk;+\πRR2nҕ;Tg2 ^Xl{+jXe~R{LeT!şJOOe@NEo?ik-"ƛ:=9Nہ""!ԝ>?ǘ@ ^|y<)#\.Ib8///** p:</::z!!0Fb%$$~?11ќ-eR/᳏/^h`'5?>ʫ6sGg)ҝh%@=BUƒ'm+HT"H$D,Billyf x<+++112Leeesl6j=t]wޭ70Fa"rfͳkfQCqST{z#"Z"܋@s $bB*W&l)l)R,JebF!4uuue$\lkkkjjtґ#Gf+INN<sVVVhnnnX,6w||֭[K:B(`B%JhUNR&]PiTJR*M*07**W=I[YQmN;-8VVqBBsZL\VVe˖{.33knn|v)=:b\.wXL>|\RR,*!"!Z*NVB?}#;l^|lŁR&Œȯ%b^OXhE$ǶjS\с'e2T,$I)bў;{b3WGcG!&&&nܸyyy3YYY(,>|xNgBBBz`Buffz `UUUUξ)}c s]#dզvXѝt4 +j*9#Zf%$$+mg܄p455\.Z\\<~CMLi hK[P1}BV5YiŋX,V|||ll}7oAGȍ7FFFZWW8Iccc%L&cofdd$::Z (_<O$vכNt2̿哒6n 6l $߷LݻwriP!B+՚;@Pvs]JX7-1Ӗ+R|8EQJ\&JB!Im5+oQV,nAqXjB= FGG ))it\W^/,,ܾ};fʕ+oƔ4 ^z;>>ȑ# %$$>|s`SSӍ7zzzRSS^fڽ{w\\\0sNCCCkkkqq13 KKKl6<|ڵkE 0HZZZFFF<<"sҥ{})|srr~޽{C߿fy&ns$$$,RBk;"B-Xd={^v;vS5ϏjS{eųG7E^YU.‘XM R.  LyC3oD)W,3,5JEoF)^GB(|>vq~VV֮]bm۶---mbbjN_WW>ϖ]B,011Sw˜f@}}}0ٱc~y瘳022"(x;vdgg?Q,'q\===.]bصkWؙf?sb8e\i'VZ[cTUW*W! X]Q_g>^vJR*UgI\V*j4S{PVA<{9l$9uVuuQ|F!FsIMM ma7q&JOmNjﯫ;rSn߾*vNKKs\M6wm/>GEE͸~̙C+`Z=flnȐdٳ'//ofc7L<@#BhY:)ȤSgʬДJLVץ-5*sEʠh;RJ$,eS[ĺc $hn[-fss@p*"~ ^.|8pZRboB󖝝m6GGG].l0ǟ'P(0'ČeB?6 %._lbbb$IJJ I **ŋ L;=fZfk׮]v ln.]T*v_O?51117B"!BL(>y2Ug/:ҏWa+5҃AQІ 4Xԛ/**>:M/QJJ9# /Ъ}}Ȼ:m"B-88 \nJJS'dXN(|[2GJᒒ;wܼysÆ LW l6WWS&x)z&ʸ!Pd())g;;;`֭ܘ.++ ڦokklLEEE]~}瘘)xg"2ԃ~LLLjj* /vuuM4*4^ ,kRRR<2bP(T@#BhkԪs͂#ԍPb\N|ɜ) 4ը+WɄMyٳgϞy Jo]StkL5z}M`0M&lXB#H(&j^Zy0CҚ<Bu'???;;; ^vn|@ 022b2._ BeOUXXfܹ`d#::z`ZD1^o{{{`˗C$**w MhZoܸLaa޽{i.˄ceW2z{{pƍf۷>|m۶U^$Bh` BkMW麚r٣B`R^Y}B{PWe˭U_y5uѶs׽ *;~ZPeRJ7UrI#^ JՇVUU+#hN湾'GNu4$4:JըOjOhujiVA!9edee8p`W[[[__Ԕt:^oTT޽{| mmm&)==} SRRkkkx|iBQTkk˗|~ll狊ڽ{w(:GE B!bh "ɀZ)Iy{BB 'UmgCw++UO d8X]cՔWhV׹'d$!-:nxF^M hϜX(ͣ%m7-v,V fmEE P4EQMQ!ooo3O!"l\n"U1FՆ/H=4B!VXY~ҔXi&Z~\UV2CiUl3Pj}3峝_:e*cT)v VB(B:be7y@trX0 4E٭R` IDATVl20}F!Bh!ZAB^oOCޭYVkA\rt3; NU~%I)ɑ0e{  L `5[i{reӤT$b,B!Bh&@#BhE zKZ1iR"WT+XV2zEEL|ihuOk;e^pB UzϿ:N(T&:JzB!B{@0dh]IZEWT*!i` Jk***TRhlez^)y+\*fW@psKͣkbr|v!D!v ."D. QChBOtzNP,rB& ʹI#}NQB,솪n*mr#P\E$|]@0: $ڢ/TQFrx2验JÔOQ%?...)))999KCKObZ iJ8hlZv HR,%RELeTq9Dl4_^saqi)4B!E@ vIvnwGG͛C!6vCZsbNRI"(~}̪m:U?9ABR(Ageҵx1>{f8&۲mg<9~>+ JB%'?/eI0B!Bh@]]]fffNN\.7))iÆ ?4BXQe'?Vd<ʪ( )J$I@El6?3_RRRZZZ$ɲ]]?POg1O %k9\_j!L rӓ7&m̍(( B!p@H?22RTTH鍍iiipm_7S49%-o/3Puv)[dR`tN6 K~QQ˷ B ֚S֋}Ӗ˅O|~j]N_ 6_kJo5~d/-Q@SmlҔIcDs9Wڮtv::82);J.u^msN6;2d[&AC[BKz!Ρ>&w{v޾M"6nךEH Ȣg{v1ǔEJ0!BaВd)*|Om <Ƥ08G %2dAu nf ƒ6GǀD0 -CFeF i:2gjv?u4?>qu9( ~PPwkIiXB"_^˂9@q644t͡`0H/ f<A;wZ;w,**ZK#"(|r9-. R <@MIg zGNBqxƐp{_7"DAJ!?kUYebf\1KOTVVϘwhl==t;y!ݥI˵h6pOLh&Id!VvZrrrYYrz[;`CCC}}=㉉&bKi:1q^n_~?p8)91L܉gGC|]!B,4PB[B WT*Hd*yd'у}PO煚@?.ZL p h~<檳F JDy)sý.Br;v숊 B?99yzGP$%%MLLj{@rrrzzܳ!d@Hޞ5Em޼yEę9eBc&/O91Mi{4$3 !D*;c+ UBv&e4[%L3S8V)%:;w6-S!'$"q;'ߌ!bu=x_rHG$݃I4B5(@tt`~ Bhi8Nnncccjy988߿k׮ %6' t0 @m1t: 5WC `o SD]!)vcF}\Wyreهp|rl.Ћ=Kv{Dchzp8޽k=6m*((:{ne˖F~j:NE͛n1}˗/wtt=zf񄄄Æ %%%SO{lll qJ "hdddtt4>>>)))%%%trݹsip8펮]\$IZA"txR@ff&Ùtgg+W9Nbba~FD }B hX,@ ؾ}{{{{cc@ x[v;۷ ї_W7vnax;^-ajɒWK84\ҡ:0p/; &衔>חhJ/>kЫ1B}IQ: ܂5g>{^9d>.3.x˹yqu>o˖-=SV<88l.Ѱ鬭dΝL[[[{Ĝ/_v:BpϞ=0::Z[[k~ݻw/ty YYY2,>>~bbl6߽{xrdܜP(̘~;..n޽0w\|^\ԔUXXzcnApc6vlvWWWkk+>x`4v1[r^:>>^XX}v6 fs}}+Wx) hlvRRn|>JOO]VVvrEVijso; ;y~ߒfBoi8[>E+nV:vx[:=rB!Ѧ ^(8\6I?m5jLf;MHdJJ.\/jzt޾غ}j>0?>i4Lُ_Gc#XXtp/ !VEQ_SRRJKKc]v]zl63tGGS{PSԴ-hyqqq/ $::zǎLs)5ˇ D999mmmLv[ZZ`iiḭ={ PeZG ]w /VOO*((͛7[,ñ 455]v1GX,ֶml6[jH$KB(X,VBBBlļ9?ZdON=\iz #ظJ'g+ KM;'5|Ͽ?n];ӷv!ZB**++Sgj./ p><}X![{shlwβ4<еy\aAn؋ rD#"X||2L;vHKKcb[NS+򗿌:@ ۸q<00ۛeggOI|$)y4|x  >3D"ݻw'ЙN >>~r 2cyK3 B hV9k)ݿr*s[~kλT5h;u;saB5k*>cVThT21Z);PXk'nuw[ma?9[>S$INjdYByx74Rf4+Be&J CLLLFFFVVƍC~?1ֆP[ N@ `)FGG`uLɘ1qhs鱱ki:)qB͸Qttnw8Nstttxxr`zOIgГ0F!ZF30!4)T*m؋Խo޺60eBb!t atZsI%,FEW_}utttttL͛7PȬz2c. UR<!OIl'ogV8d9ui&߿wsb%&&ζgjnzV!ZhV!;S eVL@i): 9hVW1aظh6gbܿiDg@ /F$ݳlIgz%&&8p`bbnwuu}2_}`fL&[톙@Y,,Ν;,+777==$I$9N}}P\!<:B5jf 3k}\Jg,JLO *r;ޱ'A;Forc3.1{~S_?'[ Afxܾ}c=p\z{{S~Ӈ 1ezb̸61004X!@^RVVw޼TGe z)X,V||^g/ { tHҧb؏X/_E}c? e<`=f.+pkYj3}}d c_3|,7x Nmmmߴi oeZKJJ&x<|ÇW=bFGG;;;7n: \244u{nf<OL4$==}q9*++bl6۔B!ZhJ̔IQ: '!^1kȣh{܌B5}Kmpl& 9QVƟ,k'ZV,.O1bx>S W`s /h7hϸ׳k 3p?w?D=_y+>%#+B6իc2hwmdz; ]vm׮]111w5cJsrrNgmm}ce4'&&H #MHHyf333߸qchh(::zqmC*All- |eeeLlr]x`9Zguww߹s4*** ޽{/q~Pd!BkX*B-jVTTGzݤ- Whhւ-XB5zgn,a t`|qw=Cqk&f#lep'@;]ky4ӗ%If4+Byy?l ,tڵC}\NPsNfXttC? |$IӠ WL&svoQQQriaPIII088SSS_~EEE[ xޡ!STTt=&^}755%$$8Nw^>?<B !Z$i7uB#Vk+Ki)}9L c랝k-O)H¤981{GYB;D\@AG MH; ^{PgKx::y%^y ch+ܿgttbegg~lM6I$x@䫯t:߰aCqqqllp8/_ob IDATR[[ۃFFFn7AEEEɋ3;;[*4=w֭[߿OQn+,,,**nll(rM["^w^oopLLX,...^CE; P'l^B:ʤ-v R(5j‘w*˕2sG!6&ÏGko'=~nEN.:$f<\YhςfHH*=rzGv)14B! !B=3HFg|yBhnf=cMuu'}w&YŽ6~Ec6%oc񞘨{JOZ~S&[p;PC7[`:0ᏊNް?[z].pgýB!~a4B!4 n5u@+2՚OPp]uL9ζE\.ܐ1HƺۋjX"t` ]7yd".4%>%,b`Es`5Egl.1yET Cc54B!  BG:  h{sCpU''~WE_Vѱt ³5ܘp oa_gL{A4;˄0s$Sz_Ln<Zy4"5ս4&Y;7YWZ(qJmoB! BGiyRj*L(ڢh>u@trxKCz[B7tqv{NH$1_]ONѥ,/Z{6_dSЮQHH&e*}>9\+-+ps,+[p/!B @#B Ty :"9F[k*՚k :]r3m3/0y9{ѲlnH$bl000\&|@S@<0w1֊δťnںc[eֆo>0d{kIB$ʡSNt2oݢ2[q:۩kݝu[k:]-i-N_Q;AI$O?1 <9߯?<ܹsSLbOB஫FkKVTT.˾gL~^[W]w|y٩Iq<"i]qW/]&I }N- [, 򃫍e9LfnMTWlrXh_Cc+T@{Kv~d^Ӻ2ڪgש߫=:z[8AEѣe~cW:GG@6k]wV5IL :|<6y&q^O4\9rĚMDLZnޯliEͭN'ƿûX3&muyKM-9]g7>[[S9#Y5>e٫}ؐd+ow3X^:J&JJEEY "c1'^ r*Wm@GS3-d?o]h~z;iЂXYkj*~XUz)8x~F]7st랿~h4ЫuH^eʵ v 3Nt{#cQsa ?b9V %l2yr;GZκPȓ?K DDڊ}_#GK3 WԴ׿䗡%t]i8__ N ~\?~gyiGƧDS$c։#>*jW>mloFl3|5v{t|o=b ݛg chڏI^MƺvʗiN,=-X_`5re)mL^-M7cڦ\㺙d02PHiL/;@K 8Ь&,N_u_ u_܏x3r6> J/!bP(d2 hnܸtR>oiڏ#}ʃGjN^C]QUfR($DTRRZf_=YAe7z#w"诙lU@ǥf #C^:mOfsh<1~;>a/{_Ym K嬹sW]Wmahw 7Lv^$^:===>>^,իW aq6]{c)kOorDD$/ȣ:m0DD4gꐧ|+j׿4]ne024>&-{Mv7G*K=UB9y8nvU*ŋgxbJ_ u]U􅞉sа,eŖж҄_ҬP_E K "izCK@f|f y{hmG{VwCX(Ђ"ХKcbbX2,666>>ٜmhݞC͹JX.|lsITlctM^]ܭgg䖔ږ7Ң9[mf9E?ܱ}c,o=s6gr # z9΅Cg `7 [Ʈ[gpvɌ8*yJT:$F{cRs,rz1<^+-DqiZpt]|B78K57>O1!,! tj)-55ehh()!Oâyglߧ{eRs lCߴu'׹f]Kϼ`Ĝ 4ܦn8ynLr_s4#wC\Q7>\;MMξ|vO Lƺ:u{WWD&dڮvuLYcD BzM+q=\6hÍAC8>bYLhSX!;;w`1{[&FCY ]w?Y~o"T*^N* ? ]xӷCm`᧋DDz[stA.~HoI凟z_}S~q"OFD~sSt/5U9A_|G[b\(ʬJ+ʋ?YH|eט+ylC,&/??B>E6kwkVw7CR ͚Ǟbs FKRϤR^ߚ{9Oi>W_IV(d)N9t 4$ƴI(mˮDb߿0DDd=O*+˻U,[}G.Cg׸~6t|O8A'+W2ŤjlQ?~=ǭƺ ρò֎v|҄Ȭ>b(y^4>ʺ5B e:7& C\f!G9x΄nk톜BG.~ !H3>>.q:T*_F_oϜ:yy(HyVc!"^CĨ '2'ɉuhIOZZژIdlSL-}O5 sJ~v~v5?/-5A_X-fD[{/ 4DLf4}o4fʼ̩tF"Rxe3 D㰑 ! u F=K=)"2o{V,[ eIe][dWyOMGKIkw~\QFe[Jnتgх#yI'acͮkheoZkl,a$Q!\_ Xq߃V #W/ @C76 2,KD̔3"%ZX""瓜CX 1"C,8p X$YeU_}Hrf_Ee8MgƑV=[SUf>/ qj+qݬjNH!#JY<?λXM~(8$KZ˂x/:d6h4III~*;9;n);gh E s ]3""b=,7p $5m*%DꙂh2$_RWsQSY g˿6YLهrJ30WL׿[9~Iϣ:5{ ρ{&دZ-51 )ShA#GYYa%fݨ`OةT4DR)J{{}:7&&FTtK2Fty%"iH$MkT!#3D$dѱD$"6Evt?qaI =M{K_?.  e;5A^WH4tjHkWLc_IHM^|ދ hAc61}@ );rd}3n 4DaT*VqÃ*jjw N$"uN>y2q*(%"yZCLҭ'$HPɉؾa#<GǶ8Z6+YښMMT0u[^ZRRZ ]h\?/;X1gnc' 7\0G=kFW+geb<{!2蘻nrchW;`. 4D \n:Fgڵ4 UA"pSM%ReHYIdlkwOۚD2"Jɑ;ݣ*CY *H {lӔڏHy"q$rQӪ,RChmOAnqݳ~uN \mu/NX}PGx`ilEBI=T/Vl^B`۩Կ>>6E  rڵkYmmm1fyddڵk---Vuڵr tӊfzVdԾ~H҂[sҟ~t߭ߙξ~j(g[Qhw6'UtX%C멷YoܪB vtu{J~y n<(,=x~SWZݮm{`IEA_if ڊ7{nݳW[fm马CY|_OwӣmkfB4px;4|8K̎#WKA[0P0V5 D$ɤRERRRHsϜlxy?-\j.;$-ص+Ovsbݮ]o~g ҨI6LL7J2.pܡ'4ˤƎn#%n޽}gpUUVr\#5M%9~)U:vH(>6iG,۬n4fخu}A[ѥbZF|5DBү`AhL%17sgqt0JBϫVD6ㅀB=!èֈgȚyf*VmapVC FEE,˲f#"@͈Ҷ?tw6;M3 ږ6>{X^Vf6"ijnIٮΆ-3On}ùn"&Qa;,MYBJS#goVl""]MYB_RqrOIL:D&;*׏5}g `]5ٝbkw!#J^ݬfv+y #DePhcRMDC8&!o oc{l*EpB .YhU'fPZюgvx}zR^yeF27]>%s+'a6R|v=o8ڣ{}'rt=+i=_] r|+ƮmiyA6Onhtpƃ<RE"ۚX;@W4ԅ[!ZGsS+{ŲܒdWvuՖgݾ9彠VW)-..)U^j$Z]sT:uv3}FIn uLDVzCFde6cutim9i9[F"!;p$Zb$1qYqwwg9ܓLjKSW!CogF6{ Ĕ`"<>u=_N*y- NH7㺖,㷓 ߟ8/ ?z:;s[dAhn_`{k2_>_ $@IG,vﲡ6j$;ﳓ"!n٪^E C;+CI94:p GtFp@G7-̄/w&YBF*OX1~,1gx/~u ! řUVS8wP 74̌t?OSZ#b}|G' Y\L#fch4;-Ʒ:vPp C (uF IDATp{n)/klT-+,%#U0i0N8qsE^NlļQ2;ø ߓ_wšo+G>0".5؈#2y@w2]b+6|OOş cAX 4@)K,YSNv=vO NWUSdeegggg)xQun+'Nxꩧm65^YZ-j!}ay&}fj'z.~EQ|}ϸy<^@w2-Ha+Y:ki;B a@$Q?XU?sM$#ϖf+4zJ^UYqx:xSO=EDcccw& ì 8iD3 f8Q?pmPZ"h:֟n;сݼGv{v2/$iYB^=@/A?.28{=ǎV(zjJ`'xСM][ZZmAGc.We-C_nJ'Aq?=8dѾ[],`VN&m6D`cN&dM?sd4@Hj˳˪glUUVr\#菵{K'xfKK=n*▭Z1Ud5==A Eo02dӻ&/7]RE"ۚL d|li1/eby ə @/A tKN4ȼ⧵Ue YmܸqjT]]o>A<Ӳׄd׵B,]zۭVGb5Er@ $Zk2ËȠ"hPPmM}t򒃗ě^=ZZ?tm۶xk8q押8?Z CV EikBR=օC9۹L/EHFY\"AsSۑ$d,AD!"VNSBhj,I}55YA|477oڴ{SO͕Yws!ݘʽGZv<ŏ):3泑@HlJH_vbW hp(?R{dA?777o۶ڵk%"ݻw777afEn_HvC8AG]Q2#zbц!GDyF0bB'Ś CD+޳98Z?{Lա@XB 6LJKԤlfOB:̙>>m۶i4 1w)Lje}Aݘ*@G@uÁَ'n|0@Ś fD[$1qRd hpSW8c{tփ5ťe{*J Ji!}v۱cNsH[jH}_kaɣ:e߃{XpX- }?pLc# |jyDv-3(>}YDȠ-XpUP~vRPN7?d|S9}vjiiٱc|~Sp>o1GJۍzTǥf8%1%+sm)F:mOf^`64hAފ!#\#q|; Ut|bwS} vԩ6"pKP F?)KV5vז VDN3}v:O/@[-,bYgIBUPO˽:poc~ ىq>;>|ĉwYF( TVB^}ή@U@2G#PLvo$O|A, T޺ ښ}MMGj+\wM]5 /SW5yq>;=SΝs#NǮAM^&nj`Q|yB/hb'"Hap8N)j©A,–,{~́{n\[SQxKW#B \SbN;vhnnv@nLί\\mǮ<1&!6u@K} >niagi Lt|rZv>ӺC X`tu{J~vƜBmUA]mEǛRz螊Uuuf6S>2LjUFnaV +}['X-f׵q'"ӸOO:G1׶[t$0J60I@4@C t-yOk\Ϧ?¼YzRd+8/Mر#pm02'x X~_I<Ge ҆!Ҋ!o}1+w/͇9gv-G(*:_@>_*|@ ፝OM"PGGŋ??ŋׯ_&Gޫ=Zxc/#5&VhRWh%Y^Um۶e3Mo珶>t_Хz [G">Z}]ӲZ?p$FKh~klOY,k9bv{p Iӏ{NW[=2hF`!ݬ6<.E7znj!`Ffc 3 B!Ƹnk톘dj?  !dE"իbX,OOO_zP(<<2hXjh񳶦UJ"=zQYT2?N&ܿ^8Gj;rj#w@]f~6Юx67m5s+IC9B!GYӖ4`n@CϟWTŋU*_| 4I#"KvO[,""RU7kkUkqɊZʠxl/۽4E}XGS3 6bKcjkHM㣮f@ q221Sj|<>GdBh髿 0Po{.]JNNaYoo|rvv6gk~Ps?=Ö '_>o$bU%w}gl]W6wYb%e)&Ϣ9[mf9E?ܱ}cYޯ>usHDDU"$P~\}NW\ ")-mx9$Q"TVj4{_>-eqI1 );J*@-L\(s^ekF{_jgY߸ICKc ߙkl@dx|6DQAk<-g=~ݧ_LPq>9*! t:RiAjjG-[4:}zHmn5# ZѷN r/"= #r6kV `<ሎON)xfC,h! HRgRt```ygcsϽ9mЧhcOVT'_}يg_͉4\)͞:;YF/<]kWų/Ķqޯ3`Qմ׿Z*iUk^[{MEWWW/Sy8'_PfYEĉ!}&"<5^Stw3kjXEo\š'׾u]+>uad xP?xлe#WB @CR3T71]S={TtZ}D[ˊn5e %cé6gk%G7,mUHl,gTeeyZnVnߑ t'|㣛\5h0Dm5  ( +5vif+U%첪/>ZFIvU^]esss9NVli}%ɋ8]1 pYYW?p(„wB,eIgtĔ?AAj f H3>>.n\T:66_oϜګRO$sEE*γ Y4"FUĂ<9QN 5R sܻ9T3m~ 1[wn^9s[ CDl k>)\Őd\OjhiLIN۶m|8N/?y#^YM4݅zF#k;1~3*fWV"P<]2N'gbfhyϿg);)ɢ""J>WdQR3o%C2D Ytz"&)M>iribHbHn˶m'f#QbYL&"eYT4:}v2 ydЌ8j j1w7]+¢ׯ]q]R=:xb:*Z}$@z # xhP0c97͠/ #id2Gh^%tF"Rxe3 D㰑 ! u F=K=)"2=Mdh}sF)/[OڮisW:"eKwQ̠83hH᦯uLBJ^[-f׊ɳ6̔%1о|l扑؉H`%['u .>.5bfh4A& lm0xVG3"X%" KD$|sk!"FFc!hCN4wi@*?l^Ӿc5uuu{K w1:P=SW]]NM #C2GiEA4:/R3f]Ղ8<)Q(V6|K}'QA/Aꯆ;13 4D$tٝ34v"9uˮCDSs';Y&gV#ɯ?R;h`W˔?qk.>; ^mȠcR"5\p^Kbikz"^׵XxY:/lj`$2?~P(2B ?(fMƳo6/B FTJه(31)DdD$MR"b Ct"*d"brjâcH&@[4|Pm7 w喴JQ}'ګ+oSOb x:Lt θ}Ӳ:g7 nP:58:>=g;]P ڣc>V›@e_BiGz}0@CaFRi7nx9<<<88RvHJ""]ۖ!TA)Ӓ"}en=%D"JNM6I?]=FQmɢ< |&Qff+gjhm_ܷ[ʷbfi3eEtѐ0_t^3⨻ 6zEQ g?Յd2[e0 +,_;8h@<O.]eޑl6GFF]bZ׮]+yYZLr hkQoM$-ؚ̈[sҟ~t߭z맆r9E˾9[%aSo5$߸U̟u/9=LŸ=dQoAK j1_0ПkW\M?g)6:/9gZ$ǃX#h@ pmF@B`z! jd2T*]hQJJJTTPI~ /+XuvݪQV۵+o?LCa^5ۆ[fn]r@COh I FJܼ{2fXͻ;y b"7'N|ڝ?ij$:63^ju4ČeD՗#\q~/7Hbl|!nY& g^pdu7mӲ&~c ^ bccXeYf@ `n fDiN:ֻgϝ&bvms6>{X^Vf6"ijnIٮa-[g|sDLjGwlYv3nh3{Xݔ[p'knn޿?և|Z_t7ŲXg`tGŌ82r Z- R3" #Lzi{2f_5$^A@pg"I]x呑>;1(-_|mm1xpN /ҥKiii@X"ԻN۴iӵk׸6˲3h"v~atʒ+q^+8edwoLB 5}trtp3b=4M绛3 c-fyy¹1nնp˟ŲXa4ԻfTs<l{i~H.޽`u qLDk;rTJY2T #7TM^\q^Ħr+T(翮Q I<s 4=o}9< TVV~ι4cs~ njˠ;N\8p Y!tb翮sD濊,&’@.?~Χw Ν;|0s*b{GNg` IDAT5߉ 4>:yaq3fQKu'ؚ 6>A="+qjlH`XKZNs&79h;N۱c>?D'\KX8ȺcBU0nyeȚ__(-̳):>9&yn0v47&sudǎccci ςV zQe$*qT>]8{a]Lm6K d 65aJҖJb⸝͠ 4W^9N"_ss??s;o\n Πq,5~ftһ 漈Orۭ|*񬖅| >;9춌Յɚ; ޽ V[3p";"@. hIu񣃽.'xdZ3}'Ba$QYSr;'ho߾'TFaֽϺvAF50 9묽w0iᥪyA 鳓H"M)vοsl94@$;wk??/?y'"3#5҅4>F{k=+C|sz€0"N1 )1ɋ웇@D,Ncn|KSx@\3 MAur0 8njKF5//oX-f/-y|>#ZͦPo$\8U@‘ޫ  b޽{ll |s=97 2gmӻ(UVmydgVu qG;h.s܅d2i? bĜalօtk2z#5V|;.5r;' 4@d:qć~ᄊt~)&!%2=ί}@,v=7Ӳ4Fq^(s[ne3g,6ꆝ^c$i[-f#g 0ϳ2dj'4 d"7Eԏ U2LD1 )Jw99 VcgL[}G,Y9MfvvnNnjGqtIL~VF$N8qy'2p,;g\A3~dAgІ83M^W[3Az(&!e#DdL}haOP Ͼs8q;'qp4@Dt6(X{s90t|/ Cijkoߜ+qWuabƲj #7K}l,_8Mhmz g96nA'@DΛolGiĴ~ֺ[I#f2 \Pjq+3\Y=S'h5Et|&p꿱o }!##4?ܹs~!F^\wXo}%L_}N A߸vyQiFΡjL@sc4@<Y+" <R t:ݻ9p7GdF|Y8TZV-,j1ym3聫-D$4z4?M 8mY6ۂh!Gx}yJRjՖGhv?s^,6Sf_t8/ʙ@$usLWlO[8;0p(bBa/tpB; hHpܹ^{ htbwz\wbR|9󆃾ίGlIn/G@K~M =nl\ynm|C$AH ӫpGA  l;5Mo g.P#_G8bLwwQLB W]4PjPOQ7<휬Ĉ=[Z&l|P ÍXk1!}PR2Ak;/}L"PGGŋ??ŋׯ_TYYlK3\f[rKȈܞ&3-YW< :yIδU^@[-itحS[m8l6`~¿Xk6zn/Y *N#p/3a0 EZZL&#"`04͍7.]5X4ͱc8p8o3 ]y}ՖGbRw~~Y\ gshg_5}T#_pcpjjRJv情Z-3#8j}%#CLhv~T-@߸ve7gQ$>cn9pq狤1q}7i/D|r@m{u~{L[lbŊPo6DovU*ŋMsѢE*JV`>Ν;r5[{Qzֹ$]pFo?2|&"IY CgKKC+cRVmyd>ujӘ^#-J%f,,:h)vlB ]rxQʚVv֑BF>_Źifl"h4{kD'H* 8ȗl N:LԴn lh>2Lٝ-gvBf;)N;xN/dNI68icql sK" !ӍVdn~?Ѕɓ駏l[>_.4 Lܓ{\ibie GߞQ`4vs*-;^"Zw9B]X)o< "呯?[;;@DyZA#$?d'nhbZ3Cjy"f7/NDSZ{}lrY?Q3qiv3Hv\5\He"dp䄜W[{CR 4`ʂOw/>*FܣD޵,PW% =;$V\R%"Q5&R ssӉk UI5@ ?cJ4_bU;PB?7zK'}uVJ(benUV۽y9zM0F$V,Db'&3ku52©2l|g >0АjjϷ| ߯*{eGD}ي\|D߂uk/) (sڵm;J L\F7o.~0G3ǒHkcbHa!4zjvDP.ITQ0$@HA%)kdKwJɯs=OMw+/dt?^RO}_6zS#g'YqCϢOwA?wL/;e1s/bj87$R*Su )BdYyrXX/yAeXG.9n#V5TRM^^ގ \܍6'&EŇ|T^ɮJ" w_}rMt:{gi/odC imwwٳBGg_OB#A(\ōn&4T8_^oгhW0iwPm{-U߉ pL5CN"^D")v3; >U+Œ/+EIW#^wq^$Аj Czz̽/%4 {z$.|BsӉD tZIt(\A"Ro=LwiC,W <裯Zwwwa.#oWLW&G7Uڪ'ϗ勇)BM\^-9^O}h&hLs/2u?G:ԆXnBdtJ|NG'ZΫɔ*QJycQJ*Аj EEEf[ZZʅQQQ~:ڊ<"r'D-SGw_2& -RW% I[XiKD~yMoНtD 4@ zGzK m*DХXK?Ḧ́#Uuesnh7<3tPq"z>M|ݞs-HBHp렜ISeY,Yer&57)n Xc4Al4 VLLLl=33355uiF5bU%Z &.*Ζ*HYz7\lH0&:tTMDG͙G]1WxGߞ RT9$"?~z Uh g/?3kwI2s?diU,Fͯ(,9y{h ?H`;W9z{%Ri(JXezf$W}Ti%Ιq;TirD)d}hB} D"jO7nܘq:qt:CӧZDLϖ{|yI~gO*W~9{'`/<""O}"h{]}?@}BIDT'JD4r]~啁 )|nQSn_6^Noog?^?6n\hWϽHr|.ws$ 9L#5T <!\Ȳ]5JD{M_ѳ0'V5#kmmY\\ӧJiiiron<|"}w/߸2:1z7?}=cğ駋<^ ~~f&46]2NOa```zzzj897xl#iҵ9DĤghA"9S\:+57tuiz]q<:NPH˘\BUfs$D2\*M^&3K*p+>H*.8,IݶP'[]1iޥ_)1zDR)F33<<\PP?#L&SܱO?_|}lM|{?z{`GЖkUiJ^ Q5x~tyhGȭ엿đ3(W|=={sqۮiEϜ;&'..:B}L*WID\R|\d{xtXKxs@*}0?$YG>oFڨɓ_VWW_,嫰H8윝pۧuLzedv?λl]qW;è3ppg+];h5rF )&$RifZgrK*jp|&=c93]#5dU.]@C 4^lq͂E9y>#.\`=;)lK4 erLb IDAT)z; g뜟\#Z՗;t4M.bd Uz$Zms6["!c7Rg&L$'GDI!8@ hk,xcH$O[CTGyD_v, :s6a$(-S/':m2|R_(!J`ip0m2=S&W+p($79Ty*`~uv ` 8@ ā Ykﯭ*aӉİ3l0_ojdfi~ZΨrJ*|%3pmvr2D3/x޼A)4.9YLːHeAַHQLSD h37J&M|A12ʃLd U1Z~ϛ.0.L R Mk` !qЖގ.Z^㤈77:*e>|f&;*S˿zܓ7{Qgiy`]v̸lS'0LT&P(l?.̬0òAeqY6xOuޮD)@C l_gK{Wov"":Oކa1U#6xW? CBdj?^|x &GƯ\JV+Xɳ:y_!PehF/W*HecveѦT+|w7ziȿ$=M~c|0?tRw|s_@ @ q@zLZ\om0<~MDk7i^!jّ]`>9`F x .Lx>HcԚ5wyrҔ@C\ Q|lΜs}i#"\}CCccc I^" ͗P24%'nC9ڬF ĝ\NN)4BoLZFw/7@q.wۉ9sc=4A8`[&,=-_u[}\ Nz+:y$+蛈b}&W2:z/\ɚ²]Yvf~szLx4ADI}H l_g댛]R=$J (:! āfMƳ/ul.yO{]Jϝ3lWUϾ^uk:̊„"gҴ"=YfD$jݎ+Iʒcvu }uhp@k6zQ!Kc.sKO~ZEDĚLg_}󚹅\eph.5\^':yk MEd*^ %Peuzܓ)UNJìgQh KN%[\:}T/RGD)@C l_ m]Z:꪿vIKŃҙ [l5.Xf> okhE N Z}xu=C3CW1z;4R[qY8uV32\JƁ/;>4 c8rWވ 9'}8>$?kO>`\wRK\wD2 w]jq=KVWo[sۧnC LC'}mқ_vtJ-Yxh?,N-N`~*a4lf@@42M}پK}iv~=73/4M=C-FQl:u}ޖj9nmZ, N%}V>SL7tֻX̏PgˏU9harm^K;3?01㤎hcZD'(J=bh8@^P~bUKYKgc݅jmi33+V DuvOPL={_Nw{IG_ov%c}c*J0+JXɁ%'nC;&'.c ^:ǯ\rIItD/L$K{yeFD43 tǒHei:%گTI#8 04cl]/g~QAΖgYګvi[g;֞;\u{ru&$߼)ȴ8%TcS &m <95==\hZ}aNQ*SKDAO{.TњŒ|D,MbΆ4%'w&Gn}p"F#!NɳGUxm&h?ͥ.e.M C7444lsl{JfZ/qlo u O~jP:[`W'̳kS|+3G񺒓gンkk2Kt]nnɑ*""ܤϵM-;'W2hO]RSvQy=;&>4qϛHe2*e\f!QN\ qh8 )jH[TKWWKes NϰW~ekGjB[1:6^d}]]?!upϭD}eJO]C1>43t5QgiE _YʒZطHZdhH"J()S氞XɝȬ=1pفb "P 0/9xAx@4l:`X\AJ""WOS=3]h'Wϝv"2[ m?7/XݰhKZܹ[FIdg"rp)8TY7NR0iGO=mnL!M(c7柈.)"W2Sa7XCa}7:QND@@0wot=ҞoV飬YUX}f7聶Y.cݳ u_t%N8ɢU#>P)9yV_~|x\\$1y+UF!"s>qIC:+tPq3g-0} Eeh" lyqmg4.KSm+:zꈈñ<ۧ5]\}ֈ(uJ‰+7}}rrT~12I+zɑˑb3'(}ٱcџQ@MruH`" 4$>C][?3~Pe5EK$z{9zzQ֞~n/vu67xImTjE_+V+W.Mcܒ#%GX{rR0OЗ. ESCh"{^ $3vS/44:j[q w&]Ulik46ޣi^T"^9XT(U9ج6zZSr&:mg.QeJU8 3#4$']]gKT|ҧQu󽍆y24<_|Uok\eSMCskcOy6qOh= 3Z}LZB4D\N!z޵P+^韉]Whɯ]vva=6Vtuڗ?i}zJEDdnĄh zYtm(uF.tzS]7mm/JZz;ngyhK{Wه5lRQkG55wjGHϹC4q9X*#G(GH0soeo:=}j-מ ]d\1L{tu'RqݘgwEGgWwKK?U}NK=U6sg{{FSm}SS+GX?&-/ \uV^Ee.*Tej?x_Xs$Z ):,<>_O="ʑt2j97t=~rKn7Ι;@bC Ggk0e\Sez:߻+u1O6ƔVTD.?k%N[dŗ[;lڸ; n9vmjPx:o\/4p.-9! vA&W2e M7yp7Y~59Ơh8(\.ƻgkOX[kZߧlDSK[;.,Vt:z~Iw;Fl]/>Yon2ntSVQ/ו)f-Wg-Ws+UVo6C=]x4?cqjb- B}qCʼn ]\CGBN_~|vu&/3'Y3Om5 r";:\<ﭦZ97拜}g ZQrkыU~a\H\XR;Cþ NȔO>|xNZF{ч 5"0&ﭦjo+-% :"g_}x'Y9d~)mgrX㱂lQ2jm~kluDD?_a:iJZ3VF-ه/o,NSQo{s9~$ǎߩuQe6Ŕm3ݍ \>>16t-=13knk|n׺]5]{B֨bښk/}vLDZ붬NDD7fߩ$Z?}S?}l0xk~4ǃNZj5@X2w9nѹz:&wVstjJUָoe#´`naWE'n6 #KSccXW)Qkrˎ.e̮GCc}R`Lဤ)fhia"[+R&oeu5@D.>:=T2UM6YFߴۉ{j[}V]͛ìec\^O3DO .ˇ N72%/m<;{oe%{,<-LDsO>P+G-Bu9.3uig򢏈Hkq裯Su?\ ݒHj: Q KekjsM%Ӭj'}I*7=TgpwM9Ъvvw644lcYQŊ35ol&EZ}C I4$΄9N !HV-?4_龵=lygu195*{6} rkОι¾`){;{w_&bVյ*vIdG"[veFANK}!)##"b=lq)S;nGuyH^_ t12) WnC翩i=jyan3|F!" $?IkƵ Uff[w۫surDZKIeimlxuS_[E i}zJovQy֩hHRr%STWvl _G//S8 I(;WGZ6$ػe*%pDJ%#B!6ѝl8BrF.Y2v֕g鯿oi$Lq흛m4 ]ȝ 'p{ftDСНh C:|+T9qmN;q#:NDD,IjSU[-6UL3Tҥ^+UrJm7#:̭]hصhC*CS`:_vLmq=D9>$;g/l!g-f-GpPy6|M`R}_P\ X"#'ʔ&(ΝYS)qV "&ԇc֕0iU^Q7L0$>]OxКDٻBakeGUݫ@}Eo>=|9oH~63ljn}5P{S5us148~}h\Gˏ^^go|u뉢-f~0Lfֿ͍t>lhd>uu9H6ZQQܦqL ׄxbm?:ZϡZc'O6^O[6]]֪v#hT§^&"b*ϿչAL/*)h^tT4qSi}Ӣav r~Y5vuN^ĻX-^ a!Z]*Ѱg""ca6^ US\JF_3k w:sSiLP /,e^ 1!?3K"{9BnrurU.(4( Θ3SE}N_O09e5cf?hHa۷q ,"_HB@'<}+\qǽt+K4G'/uVV_m,Mase p}׉r`L~ /yBI42Lmt̴snZ.9V^GQg ŚC% 1m#H#y]$*D9A4N-h?#sn.{+Kkq/LЪuyb9b=n>Щ*dy^Zܒ NP@1:~VѓhޚZ~^94uc~މ68F{rM -N@":T"0& T`?8@8$Hr(ۣ$f^i+K)һ#W2ܽnp^/'.c^df" 4~cF.?Ul݋.Ӈeif4D3&65=1p  /@)1od=‹p^9?khrc[E`6KA_l` 342JF'S0׼ ᾂjQP@Y"R[x̮pߐ+87ZSX(3:Hdubm~FxqHy&ty2su(D`o, NWCBx@8 ~Ct`V_`}z܋ӣ^?T)R,FBAzn#V>G@!6Bg+dNhuV^NqV_EkX-BA\PF( *D8)j@E"ژ,s'2:+O1;09l_(JT&$,ՠKDRڗ#H6^t C.E~@C,>tDux-8&7ZvHe2ЪT&H$Y] t^C_$0~( 4Z:^VMʱRRC"YM-Na lS^9&#K:<}_a&GsK*HЂ,)ai}htt]nf>G #Scw{  LX*:+OxYG 4^qV"(]YfWnD'u"uV^FV~*M .Na3l! AW*Bg,;j> (UOxP㛣7y*CѬǽ8=85}bqH(dP{ijeZP3 )8=.yhx`?@8/fptgxtFv^ўEԘ)t:p8⸀B6ıRLR+iZ~CR@д:`;`"nEk$Hz,؅Hļ[ Nh Gؕeve9vjP/W*bZn>OaV"p(H( /JeGP9w$Ԉ s7: @!~" А,^lho!W4J{˷7* )eYsTα^YB4{Bx&Hvgw\d}ou5"W(rL+8CGD~/m'kJ9]rrD`OL- #r7rp0e2B&WJ BTJϣ6Xj$Oj;#pcwW-BX4"}h=܂.|~;H*ɕ*ij"B<8 38v5;¥XKW1h=aT@C |sԅ }I@ 5=MD|5F&SrAD!Dh5 q;¡sUR85fEH W>ob͝Z3xs$ԛ+WIdRA'Dp5cO2MLP0:*<,0^YuB e 2 % 9ϝwk.m6q4T&RRv$qon ͤ l Hp7'&…ܒ u 4BghiU?A^BPeh W;[ths t(xt:$g{  J/B! q- tQX+4Y_\08Bϻ-+2e)n dž<yh FTX0q@|,"*_s۷-~/'2TitPH !!ΏA$,t?~;@j@ Ņ."bAMлB`  `B}$ T %.]a(}SsD&"m|P9a9j$𯄃p0 {*@AG4@B:TwiG{s-|("Nj`  9j$ B!/p_Ae:q@d6`$"ZdfųdN0+nλyez81Gpe!Ø !t@d[ &-@Di2MT~3 gD7Ԫ2orp:Cneyqb2kJeQk:'ADXO+tTl%IۥsKti?ܾؔ:x!::[$q ~U~4guV\V{EV_LD2!D4^?fxL2W)33+hZRc !gn\x5!otP>}6s ֨24wn7cXwtF"t{Y<Ω!VX$){kk ioi4[\dkjmk@R̮l7S:+_T}]od6f:C(DeHdSO$"tGbdF,Zkk;{ZLm{;|t/[wc顯65ގvrF6ErǴT@lDY; =."//-e *2]Rk:jem+M5QgeUZ㽢^kg1gn4JWossKkXNYWwc yO{Xwku-ՖknmPoIETTMM}ͦ- h1l+WE9QS[dred뉈zRwm u ij +,M6e],kXt靖5Ԝli&v>B?SP{w_ޖ3hWOs݅KU( "bcv?Vg "]ucggS==:N5ն4W\G 4@H}`ԙ*uff>3GS\S\n8rcf!uvRQҥ2Y {RQk2T*(Ur>=m59[WSCs룷kM&`T^ZZV%ccݡ? .<,c}e˿XKG}݋+6v4տwAqw M- Dk- ;q[NJM8lf OVPNLNj9Fu*WǸvnpe2Fs 36r|AcnFEMsyƨM*AIxF~~?;k`Ϗ[ǽIwk/^BgzZ|U^8.nz7$ -7:n҄ƅ.Ow44ŁA; hٚ'~ آ !`R$E¡P0 FmLX '`ji}\]}h\]!p*ukޖ3'1R@gKON5u46ڛ[^B10<}zJ]kwOx6^ړ/6t?t^Q_w8[:E@)ݞp4>Zu68kAhT^!G*z!&A LGp~Vu@8\^Z HH[\^^b aR:#*u;ܹS*极wiΆd_wCOـdOʘ GcGOgz\4޾O-:/۽mOycbDQsh(uUQyQ!TEUV@<ƫŵTpX*}*۳@\Q@ S$h2b|/bQ#PHӢŴ`4ƒkr5/ ݌]~t497^ٳg ֟\(z]+Z^š x(lz]-u}7xnp)Ώ !)gs{[4RQBU^~|7JjU}tEY (H.}";;',BRi~!tv,/-LH}}.1j*>I},8敹>/6m+[q\k^MOoKK4^/}]?yzp::*"sy˷:!}fEEBNUxb5M[1(H.0A;KKP@[#R$b9T(q&.u=*܊Ux7xWtgsvN>٬nϟBxnnV!\=- JCtjptlYe^j[89+jxWiT'^s x\! 0YF Q6 le;KUTSpV축T9J^ba\[~iEK**Ne:oZ@QWlXjC]]DukG&岻9q}jQ p:jC{]nAQjꚧ6[w0vKXƖZ1ZwEQظlO܀@&mf# .E! U,J~gAOC\=â:/*u IDAT ex56ۼcV>vWkޣ8qym};Ojc{W:::!t-z Χ^lnlqj-]: hx)atڲ>}+{?.[FjjxڷY*jMt]s+nQ_9k-6x{o^:[klV;OwbEQtΩO<`EQD@Q+ G^y֎F\=mmghPBloC]7Wn5 !<~rQgKSRUqSYhzwV~;aCmhyܚ⨫wb57 hL9m0ZL0(H9-QW.p Q״vu6:8򳁕YӼ^it(Bl==hj^wymo\KWSge+>Qtg] +OTEl*G7Cs4x{Z;{[7 \{ 9G\K`a#+t1R$-Bp( As,V[3J1vqƵ Bw>wӏ@*<}uu-zs5?ƍjs۹с:|Non hp]1bz%';bq¡@nO׀^'(**ա+B8lhuMuMr~* >c3vd0p[2y!3MP[p{NO=^נKso3@pi_3ŴH΀Z`6C 4G6ZLo0ZFCJg UP@dh%lb:+;;G)@  --y6K-ǚ+=@Q@-VźbZCJg P@@bzŴy!3(_ciZXQc/GBN|f)4b*,޵gUzU!Ăw*'Am;yTQ@ (7}i UP@@QPjӚ߷8 gss?0?+р!R4+V\^d]JARPt83<G~#B KR:oft(87= g&) U{eRWmX&kntGٞBىQ!3"̈3fX +*KntՇo̵bp`#Ϊb76+w*'AbS`0 hKVvR$b) +vŠhيEVt`nvqg8# c6 (pҪ}mVLk~/0?N{Y d:! e+./WFɱ}Lm8D;0 LH(8?3Q@ 90MF$/PWTtN6|l1->8;!n42YU h$h\hTU޽E2[SL?vU1;1*(Wi> 4%OgX +*UGUi>Jt-^_LGMOڂw* tLb7P@=^Аˣ)z-/魤r*݀[L_Ӊ4=r#^W_G8ZZ[ܽͭ/]X-i~n:P]$ZanQUXQpbE-Y1 f|y`iBiV&5C]MϝUתދ/za`ABh%/T[<ֹۤWй%ы Sيˋ%(f5oqG1m;j>. u8:Zxw.Q@k-ϝSOirkmx'-;3l};:{m(RD~(Btc=N)(px(87= g&D$L RP@58G]CCz7v?޶ . !І_(xgiGCo  {sLǬ65=CZscs`I=Qe1jګ6 $͊i!̵BىQ!3"2^X{ q ^:qoY{Z[Μsvv;V#: moT=[Ϝj>0YAnk9#=/x=Ͽsز :(u k- t+zuD86m0BXu -ŠJQUX{Hh7+3 sۧZm?o*|^/PBtՇo|~}12WL¼Kn]x<7=Z]{W{"w'g?wё:7oc=}Ϟ u{}]~QB8:{\}'=1G:nl׵Ợ6Eys(jCאGw5WwKK4olaMdQ@gŠe{S: ,L~y=VÉjshXmڊ+KulcfŴx8XNd8b1m? yzz> 46w+榟s|Ζz;왦:@siӭ-gi/\FֆzEMm7ag[@&T;9zT!\[:՛@U/VUU7Jii8uVyMζHһ 9VVU [>m~?{9 ` __oV\nԲ"me=b/|JvE |k  h:rNRF:Cqu4|ggW*\zEox蕮~wks<}g~jWcjct t{&պU{k9T!1:T*λ<7׊r5Rk m1ZeZ֟db+./W+LWWkN90K0~`uj[Eo^ ߷8 gssd(u&`8 h4WwKs!MmM1lo|e:EM:keG*׽PfGsǭuІ15&pu7; G+?9Jo v6l9Bu:Vj(lZi "EgO[C}ohdܼGBA!Dtlmޓ3EdMIm/,g(BlsN846 dF ii|'ގeGrV;׼> hY]2 #6V_:}uwwC u55=Woy-d-/rj+T핅J^si[2ˁYm'f^&LUFNIa2JjK84L&S8esPP,i <G As OM17m㜨}yA֎ ӍcPpV:B\;;>o:[;آVMN|3ESica][3ںZۻFOx'Zx}ڑ_\lߎ1@0 ZZ/Jؖyu>V G*+m%g,-/-EBA=OҪ}: G AiR!ס vo8R;;.tnR{ښNG~w*j[jq8⥘z$U mp *Z{ߴróݣv}Bx]"{á:Tg]PUPΆ uK~ЦeF@';ZXQ: +v0Zf@,T7R!DVvNN8hVr'[g[dZpXJ!nL >8ִ_@{C/]۷XշJu"pcrRPtաAhpfzB8ԭT*^o̵fm'9IqBx1j4xe]5u6o$ҹxrk^H8LF2o=EBbHs&$C ʘd~!njXWj/T|}{ћNpnjnVO>?pSu'[P+k5JGkuޜl~As~նo},O99= &'gp*Nc58>m_L72;љ`9($Ƣl(Z u \'׎ІN7?w^<@Jy=WSuE>wgn|Mksӆ}./;ڛ?V7ǡ8Ic91eg}bVK9:@7>v @>@Rlh!^[G]:ϸ/nPTgZŹsOޮV8;z;69 [KbP V+ 핪J)03`_ ~a)'04`cּnMձt+E:u p8p)Bwhj}cS~ F1˸hjXPv&ͪVzLeY) +vfW [,j 4`cMvc9: e/3*ح: +*wIsǣ-3 e2ϰ04`3glWncv؊ˣO6盟|l%Ye{j,z7%fEEa2At`Iվ"{e[__Nis>(lhqާ3l͓rQ@ Za9[0[ 핪*~WWMOLrv Upȗ[KEQV駤r_\w j~Dt|¬Wg% MP@ ٚk2[A=!YbIyR]\w F'8MOL-t&Vr h"1?qUO9$0huܱёE 1są%Xg:L,WVU:L % /uHą=&'[/y-ŠҪ}v Ѯ!3CHEnk Še{K%;U {栔$ h"drZ!V퓲Kd32{$ hZP?$;+ hYS^3df2S:CJ4bأsaRXaiuΚ=!ĉBV(ܒ]: "Ty*KPuTVq7>@(8? hEls!,ح:J*lbi(r@XML[mR (){svxusٞ;l 9HK1 zy T(R tH=cK` 5dɴ軮3dׁR$(#{suf $eaAN&$- hHiÝ~;l ,<(#{VE hCΫĨ67@JXL0[P@B @IC1;L 3j$ hHsΡ'l5- a!H?ė=ˋ^S'bwٞoksto33`k] P@_: ll÷Uѱ%wWQ:NzQ[? P@_t䘳?G:T+Wn33tRNT(/9{7\ZOWXggJgdb4(/5תVzB֏Xg>gG<Xy! -Q@w: lŪx+ܬc64;1?% h.rך {;=Y>>=z7>٣ۤj+rB @;nolY-BMz=#ӣWm#& ?tE @ms bOcoў;Jooo!@߫?dW-4HO$fcjEcoéVY'Ibڈ!IDp: !^f $EO-me{(@z { +kmuBxƯ_xy;FAH",@lD0[slZUϥW=_.B[|! | 7뿢? 9Q@D^W^A Il_n@4F .^z嫱74] 1B(i :C564Ƹe M#Xa-~l̄oF @B _vիə%,4oo4sK~t\5˕rEBp@me{j 9e}2H]Cf"o!BE!\iQՂrUN0P@IE! i_?d|`$SVn@G @B8 vOZb9hHf$^ZP?)` ol4V+?[`,yRo8(H=!caaVn3!Żҟ(HNESԥ?dG$? h p`)6`nOvv΢wJ7@GsYE ~M7@栀pLrd2s24Ɛ2czX`Rr24ܒ IDAT}w]\l'Cea/-(ӟ3HH?1? P@`p\Dq-x'T@ a/%g!Kħ:tjct FC[X^oLC XE)azlXJ7@H%"x2[9 i(0Ta!O`a^JB(0X=RrXJ d~slwH-˟L-e2IY?xr(0ޡ..sJb]`PJ΁HH-OJ-%h* .a Xa/-/WL͛"9 ̵a)9/%%gl1WJ ЦG? Q@=fE 0?+% Q@rI3TJd2SVJb d$ YS8.}6/%\LHa p$ U-ҟXd,4ɟD~d8 h5Rr> q v,8hsX?@ @=,(ӟ%h1:~E{xFJ@ꢀ |>9? E")QQSsloҟ(H.X$LFL\d(ӟ(H2_s !maw]ٚwԟ(H:3) 鼔?bHHi$U-}R  5)Q\ {)9\m2L.I9rl(TG @2RՂJ(.Av9ןz[Rr4IAyR ]LL,S#% P@ջd]h,$R -I|HH$/Y_Kcr{NJTwKH$/grUJHX)QfSYQw?MYQ/%+jҟd4?lՇdEi4,ͲF?u-ФDq` gJ`4*Iantfs/+[ e<(q'6B$3E1Hg×dEU:g-P@2ջKl\+# m-/EJ+~(D @*9&t8 $)n@#NL&ӧ^VZ͑ed% hRH24 L hṞXl#D2[FiȔ5۲.ןn_]F$ڍ>eYQ44F @ﾻ d}8aa!W8{'Q@zr#'J]\^.hHdʺzdkIV@z %pVUJQrMV$ဴ݃ (G @KBt4@?Qe&ߨ9rlO4G @rKk)ğ].+ #7Hroy\-8bH84f67+H w݃X| @α}<7l_IYiv侻UYiSbYiEFM !ıKL'?&1k"_0 h"wFաwJxKbOy"2FLWe% !AY^}@oD @PՂGbt؟].1ئI!٢}H~/1x^oD @Z9rUvC#HN@`2 ?8$f;citJ!xg4aܢoZg!Dc-S#1 3Q@n`4_lK`an{24iH u@`ksӓBkA XD>r3$}.,@` $_jIL&_xz$}!̊L`k!rG?{鿓(H[GJb`0bx&)+kw$yNXb (HgqL##  %ƞI+bƯf3e{jfd8 hYbo.r35 f@cCoͬ:to4iYK_SnHH Xd2]@A5( h#'%L`=bO]r !ژ/ 4Ǐ>PXH>d}z #8>pť+r3Us>!D~ qRd/,޽8)7(GJntx|Bn&+ǚk,"Koi}?@, h2?(}k܃F-V㙲d2ɍ=]r3 XB|tMsJfP =0LK 45GNIn&֠ 8_}!p3FIlN\ˍ-޽? (8}c96@n~Gf'Ǯ_lȍzd8"}t0bz{4G5#0s3-=?GF?$4(Wo> :1}'=NKO='=ŃG @F;rXHA20,/E.cY<` h2]< ! P0B) ` ` A(tyLBB!ĥk!:h̤G@x$x(`G24}ĝ)+ۿ1LғY<` h {_J<頡_v# s8IOf (Ç?̏<d. hU-wV h'&)_xMHP@9cq t-tE+q)~XBN"89q鿋S8vla/}k_StcJȱ}x>p 4CAO#{UaV┏T77=lxHaɵŵ}~p4xw?SslqGJ olS < ,}Sx} vЁ`h4"o) Q@m׏ŵð%S|"0L^8>$9 h]q燗k;ښ_hI3#q7[13@2!rEZG-E"W6;|5lOM 4=/] ]E9~@**4 K k8;B *m1!ćp0֕,Bqzf^>n@=)ќ[0sjb5$473I U`A#? [XKRG-.iwgC v.`-!*L+o?1'>" hK:KBXK"k` p%~+3@ʢz%GΏ3:L < 6d2|ׯm\B ( 蠣#rg*c4q}JS+ǑKDs}iR4 +~ʧ SEf VH[x/C3WR4 g0l A0o٢xDF|x? =P@:߰X>%282HZf2o^jh4a/wK@}ZTQ$ /473y=vCQsgS .ty..9lYOSs B0[+oȇV:z?0v sP@p׿&扳Ko쪰E$A7LO{cw=CGD>c0Rt$tMMB7]:?rT]}_dI҃)+71vl{>d n@*oxo^HC ȑ| 3L`ۿIsw=ve{j\$ h=x=&a#SȔ߼Ra-aϔu߆}^sD÷geZ^^6 +?ߎ'{r  +v~6?3iyR4~Ͼ?l;7%H*܀I$W~oK8!Kv=Uٖ`Bײf'>0;bIR)+5 ns {߿#/#9Ao" e(<X~_2b(1; 4&/yAL&Spq~,0[h$'n@$Xx? Ʀc;JʩA(c5YQ{WOcA.CD ڑ_?o&' 쪰̊1sӓŻD_-IBf5XsFUBǾo4HZ ٩jۧ LuZ=:eF!,/-}SF}4H ̈́ ->()`(G,x.>`k e8o FІϮ/2$ :szB؊ˏzG qΩ⍏h8W߿m:b h s hSV67G4psjXm/x:νjc-Gl8wm~É8Ʀo/̔-"#ɋoz7mm_{>>`;LFd2pOǿ3ݽM-3~б,_m)l)=߿{g& HZ)}ѧW?pى R٪L%à(5'9x[F)PChӦzϋ"g˯~“_}SU{_Œ_w/W|Kܸ-#gX~პWU:M c0Ttk퓭MOkϿ5ٰzz3 -xw?o%f.Da+.[p›W?4Z}ɲAoLCخ@dlǕ*HD- : ɽW5qʖ"%RH$Č1)8[V fzv64CCx`LI`x>|~;_}~_ H"HOO!d6Ԇ]yG!Ld, o^kyWwmE!-ύЉkȍYS=r.,zo9uyfsWz ;6\[h 7ܰ(=좼0PSu7Vv-3l@7xj~?7&VL- 9 ݘ|?O=Ҝ[-QfUwԔCOscO aig%k?u",xwY;z:ճ\ok(K C40nI?Zu~Fy_uգ/ >XOt5.s˗|7/J_ޗ><{rƻ0rj~E|7Ft t9~[I D,USi@!3E-~N6666UV奲>O7zT-0qx'lf?~w>o[?;qj)v=0@ԆVmdQx",dScmIp6o_:>ng2oX| $EG[hfL w-=0@FKnM|2T[YLpgcc]8|E浶w =)Ubz?q͢ם;>x"BqsڣߟHNĻ!3#:1\+ߺowIYN@K77īʦnvWW>75\z_o?oC_^N^}ñ#ۧ_ե\2R= |HDcMyՁcɕPrm50CMvCzl oC I XFz^e}WIy]]5vz ¯_x7^MD[y?5v)fݴtſVrk PvYTE^zU & |ߕ雩>*p z-%_)rʷAi44@o~TO4 _q}Ƽ<0o1\ߚ]UOO sԁ_ X%!B|k(K p5-:w\g恡ƒU[M5PPju~`bTrצ^D~p *oݷz7<]y h.* G;^zGʲ/qhsḿ=E%Uy=aM!xk'+qo4pud ]wV58Ը`9笲-<ݺy%894嵸ziέ}y;tgJҳCV[77=T_hGzAyuA&cJt~j_ݖ~g{6Xh* YY5M=e MMO65Ԗ\jLnECo|Np⋺>vc^omfgB*mWPDSmedpgcc]yނ{w6|CtLy࿛NH湤9o\C :4ֺG_IkCПcGOy?_T 3eiέn%0@Kj{ꫫ >r>.{ B'O>prHNX LnNO7\k:ݒ?'ܺ,7պnXj־]45iz~sx78hjTSwBHH+Vݸ\`^.1?=Vp\1rp虷xs~؍n_vuۭ_ |&M5U;΄VxD{!~o 5uZ_7o2yYu3X.r%;{ǓeyCC5EωDIys炼իBM$'Kt211pr(L^CnɿyY[pY @WϿ3Jˋ.z{OXdwOmArnH8"B~38yo%s[MМvrCm ! )!@WjXהCM%;p§xzu;{Kk U:0::>zd29>9->0YfѹsR=pmH4g}g_<= 5mml)mo|џ,POse*ɅS/R '>\鱴o.Yr%mZrsVp-+6XPOSezcҪC֚;ˮ`AYkGv6ֲD࣭!6֦"@W.'?Xyl%=}$gj8$C]iod7vlĉpꆞ &zk:IzJ&W?T5t'; /=zg^QMS"0 |vCuU4ֆO  '.l*J0UN@ ' @$h *򲳲*zCyi(;/Ht<НʦK5Fm+&@7XUӬ?oonm{ ?_X{buʿ΢}ܹsH}[YSYִwW4d5T\.򲧥ak涍F+&@M/Xۇvmw^rhXFGC%j>Iώg3hsuh>DWmɭ%!d7꼏>˚ CMUٸ$ҿ .I(^[Ա<BH/()ʞyVv^, %PcUOϬ{`m"VxQ+ҳya'|VΝ;4Z~S7Tv냣t},/'Z+|L,dᏻk R2*6'`am<0a֏?\0regg>'`!j,Y;^/ !6W}G:>~z*/0<8Z}SOc?C{M^*G``AI fdO;認ozM\u4,xOX/f.C`J\ǚ;TYy}/HrӪxUCrzAuS#ϼ`}tV``.)YNMy.Z_ydcjwhXFJ~a`8,Hcc]Y%/Ll{* =+;U6glGN^۞ghYyeul]_PYe3`!.)ZWBYE5M=_7 ZR=@$!}zDSmedpgcc]y\eN@>#0kɻ:/'`K ,h"a @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$O N4+>ڲ=7򁾈h 9Vً.'ۏTw ?9vէ]3V08 @$m :w&?z#y-?|tX+_9Ec78|W eƦHfο˜v p1+8 0o?/y#aݽeOwz"#'gyC_~VV! 6HGK_!LtwN87vhY&gyxq+{?#]'^h>d0>7o; @+}uK3B}^t 8񶆖d={UC-O:D|f3Gwwu;Ze=\B(O]mm]v<BXQ\&=T#kG԰#!0rdr>OBČ?E<4B}~8#е)h8OW?~poņenxax#Wo΍B,wǷ.! vtO"kzwi{LnspqZOڽgs?{Hv !x~ /\y-aes!Ҝ#z'{tN5kBl:}Hn !y7t[ъ _i;K KׄLiBܰmwuNt mŹ_g_<0vzf.ʹ!/ !d!${Vx?x鶖8=v:~ >,ޞB;v*xymtPT])pSm-!,/ݒ !bCntϵ^8˯k}OD[o񶽛3g|Bɤ ]V\Ncp;fnXqq iӯ!L(q];BݧBi~p%n,v_ !, iapbs$=7_Qqm†pe0[ քΖSb#GB(2s+vw/ / kKKKl)ݼy̙Ouwv 0 HZlf..url2N ]7}23?SOB,Rˈ0$KQ -}-]##}!lH/};:F†]!U\8LY?[oaб΃v=2o|}anoGg=hkڛv>-չvq2b!K&g$Br<gBZںtƎtQXb0ž#]#/tVtb=ɑ#-G'ZضsE-9 {p !mMqEEik7f[vuGWksZl~7 ]$sMnZǿex{ޑY3[>'ps:>BݴBB5sg/zڎ4c-C!mSiTn !SZ|QUm>|ه[&#m|otXxOȹ[Q~yx_WWWHf}=RkkQZm{BΝ; 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@ HDB 4 @$h"!@sy@,IENDB`bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/main.py000077500000000000000000000065301305314114400250640ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from builtins import input from http.server import HTTPServer, SimpleHTTPRequestHandler from netaddr import IPNetwork from os import chdir from pyroute2 import IPRoute, NetNS, IPDB, NSPopen from random import choice, randint from simulation import Simulation from socket import htons from threading import Thread import sys ipr = IPRoute() ipdb = IPDB(nl=ipr) num_hosts = 9 num_vnis = 4 null = open("/dev/null", "w") class TunnelSimulation(Simulation): def __init__(self, ipdb): super(TunnelSimulation, self).__init__(ipdb) self.available_ips = [list(IPNetwork("192.168.%d.0/24" % i)[1:-1]) for i in range(0, num_vnis)] def start(self): # each entry is tuple of ns_ipdb, out_ifc, in_ifc host_info = [] for i in range(0, num_hosts): print("Launching host %i of %i" % (i + 1, num_hosts)) ipaddr = "172.16.1.%d/24" % (100 + i) host_info.append(self._create_ns("host%d" % i, ipaddr=ipaddr)) with self.ipdb.create(ifname="br100", kind="bridge") as br100: for host in host_info: br100.add_port(host[1]) br100.up() # create a vxlan device inside each namespace for host in host_info: print("Starting tunnel %i of %i" % (len(self.processes) + 1, num_hosts)) cmd = ["netserver", "-D"] self.processes.append(NSPopen(host[0].nl.netns, cmd, stdout=null)) for i in range(0, num_vnis): with host[0].create(ifname="vxlan%d" % i, kind="vxlan", vxlan_id=10000 + i, vxlan_link=host[0].interfaces.eth0, vxlan_port=4789, vxlan_group="239.1.1.%d" % (1 + i)) as vx: vx.up() with host[0].create(ifname="br%d" % i, kind="bridge") as br: br.add_port(host[0].interfaces["vxlan%d" % i]) br.up() with host[0].create(ifname="c%da" % i, kind="veth", peer="c%db" % i) as c: c.up() c.add_ip("%s/24" % self.available_ips[i].pop(0)) c.mtu = 1450 br.add_port(host[0].interfaces["c%db" % i]) host[0].interfaces["c%db" % i].up().commit() # pick one host to start the monitor in host = host_info[0] cmd = ["python", "monitor.py"] p = NSPopen(host[0].nl.netns, cmd) self.processes.append(p) def serve_http(self): chdir("chord-transitions") # comment below line to see http server log messages SimpleHTTPRequestHandler.log_message = lambda self, format, *args: None self.srv = HTTPServer(("", 8080), SimpleHTTPRequestHandler) self.t = Thread(target=self.srv.serve_forever) self.t.setDaemon(True) self.t.start() print("HTTPServer listening on 0.0.0.0:8080") try: sim = TunnelSimulation(ipdb) sim.start() sim.serve_http() input("Press enter to quit:") finally: if "br100" in ipdb.interfaces: ipdb.interfaces.br100.remove().commit() sim.release() ipdb.release() null.close() bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/monitor.c000066400000000000000000000062071305314114400254170ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include struct ipkey { u32 inner_sip; u32 inner_dip; u32 outer_sip; u32 outer_dip; u32 vni; }; struct counters { u64 tx_pkts; u64 rx_pkts; u64 tx_bytes; u64 rx_bytes; }; BPF_TABLE("hash", struct ipkey, struct counters, stats, 1024); BPF_TABLE("prog", int, int, parser, 10); enum cb_index { CB_FLAGS = 0, CB_SIP, CB_DIP, CB_VNI, CB_OFFSET, }; // helper func to swap two memory locations static inline void swap32(u32 *a, u32 *b) { u32 t = *a; *a = *b; *b = t; } // helper to swap the fields in an ipkey to give consistent ordering static inline void swap_ipkey(struct ipkey *key) { swap32(&key->outer_sip, &key->outer_dip); swap32(&key->inner_sip, &key->inner_dip); } #define IS_INGRESS 0x1 // initial handler for each packet on an ingress tc filter int handle_ingress(struct __sk_buff *skb) { skb->cb[CB_FLAGS] = IS_INGRESS; parser.call(skb, 1); // jump to generic packet parser return 1; } // initial handler for each packet on an egress tc filter int handle_egress(struct __sk_buff *skb) { skb->cb[CB_FLAGS] = 0; parser.call(skb, 1); // jump to generic packet parser return 1; } // parse the outer vxlan frame int handle_outer(struct __sk_buff *skb) { u8 *cursor = 0; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); // filter bcast/mcast from the stats if (ethernet->dst & (1ull << 40)) goto finish; switch (ethernet->type) { case 0x0800: goto ip; default: goto finish; } ip: ; struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); skb->cb[CB_SIP] = ip->src; skb->cb[CB_DIP] = ip->dst; switch (ip->nextp) { case 17: goto udp; default: goto finish; } udp: ; struct udp_t *udp = cursor_advance(cursor, sizeof(*udp)); switch (udp->dport) { case 4789: goto vxlan; default: goto finish; } vxlan: ; struct vxlan_t *vxlan = cursor_advance(cursor, sizeof(*vxlan)); skb->cb[CB_VNI] = vxlan->key; skb->cb[CB_OFFSET] = (u64)vxlan + sizeof(*vxlan); parser.call(skb, 2); finish: return 1; } // Parse the inner frame, whatever it may be. If it is ipv4, add the inner // source/dest ip to the key, for finer grained stats int handle_inner(struct __sk_buff *skb) { int is_ingress = skb->cb[CB_FLAGS] & IS_INGRESS; struct ipkey key = { .vni=skb->cb[CB_VNI], .outer_sip = skb->cb[CB_SIP], .outer_dip = skb->cb[CB_DIP] }; u8 *cursor = (u8 *)(u64)skb->cb[CB_OFFSET]; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); switch (ethernet->type) { case 0x0800: goto ip; default: goto finish; } ip: ; struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); key.inner_sip = ip->src; key.inner_dip = ip->dst; finish: // consistent ordering if (key.outer_dip < key.outer_sip) swap_ipkey(&key); struct counters zleaf = {0}; struct counters *leaf = stats.lookup_or_init(&key, &zleaf); if (is_ingress) { lock_xadd(&leaf->rx_pkts, 1); lock_xadd(&leaf->rx_bytes, skb->len); } else { lock_xadd(&leaf->tx_pkts, 1); lock_xadd(&leaf->tx_bytes, skb->len); } return 1; } bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/monitor.py000066400000000000000000000055201305314114400256220ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF from ctypes import c_uint, c_int, c_ulonglong, Structure import json from netaddr import IPAddress from os import rename from pyroute2 import IPRoute, NetNS, IPDB, NSPopen import sys from time import sleep ipr = IPRoute() ipdb = IPDB(nl=ipr) b = BPF(src_file="monitor.c", debug=0) ingress_fn = b.load_func("handle_ingress", BPF.SCHED_CLS) egress_fn = b.load_func("handle_egress", BPF.SCHED_CLS) outer_fn = b.load_func("handle_outer", BPF.SCHED_CLS) inner_fn = b.load_func("handle_inner", BPF.SCHED_CLS) stats = b.get_table("stats") # using jump table for inner and outer packet split parser = b.get_table("parser") parser[c_int(1)] = c_int(outer_fn.fd) parser[c_int(2)] = c_int(inner_fn.fd) ifc = ipdb.interfaces.eth0 ipr.tc("add", "ingress", ifc.index, "ffff:") ipr.tc("add-filter", "bpf", ifc.index, ":1", fd=ingress_fn.fd, name=ingress_fn.name, parent="ffff:", action="ok", classid=1) ipr.tc("add", "sfq", ifc.index, "1:") ipr.tc("add-filter", "bpf", ifc.index, ":1", fd=egress_fn.fd, name=egress_fn.name, parent="1:", action="ok", classid=1) def stats2json(k, v): return { "vni": int(k.vni), "outer_sip": str(IPAddress(k.outer_sip)), "outer_dip": str(IPAddress(k.outer_dip)), "inner_sip": str(IPAddress(k.inner_sip)), "inner_dip": str(IPAddress(k.inner_dip)), "tx_pkts": v.tx_pkts, "tx_bytes": v.tx_bytes, "rx_pkts": v.rx_pkts, "rx_bytes": v.rx_bytes, } def delta_stats(v, oldv): return stats.Leaf(v.tx_pkts - oldv.tx_pkts, v.rx_pkts - oldv.rx_pkts, v.tx_bytes - oldv.tx_bytes, v.rx_bytes - oldv.rx_bytes) def key2str(k): return "%s,%s,%d,%s,%s" % (IPAddress(k.outer_sip), IPAddress(k.outer_dip), k.vni, IPAddress(k.inner_sip), IPAddress(k.inner_dip)) prev = {} while True: result_total = [] result_delta = [] tmp = {} # compute both the total and last-N-seconds statistics for k, v in stats.items(): # subtract the previous totals from the current, or 0 if none exists v2 = delta_stats(v, prev.get(key2str(k), stats.Leaf(0, 0, 0, 0))) if v2.tx_pkts != 0 or v2.rx_pkts != 0: result_delta.append(stats2json(k, v2)) tmp[key2str(k)] = v result_total.append(stats2json(k, v)) prev = tmp with open("./chord-transitions/data/tunnel.json.new", "w") as f: json.dump(result_total, f) rename("./chord-transitions/data/tunnel.json.new", "./chord-transitions/data/tunnel.json") with open("./chord-transitions/data/tunnel-delta.json.new", "w") as f: json.dump(result_delta, f) rename("./chord-transitions/data/tunnel-delta.json.new", "./chord-transitions/data/tunnel-delta.json") sleep(5) ipdb.release() bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/setup.sh000077500000000000000000000013141305314114400252550ustar00rootroot00000000000000#!/bin/bash # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # this script: # 1. checks for bower to be installed # 2. clones the chord-transitions UI from github # 3. installs locally the packages required by the UI function which_() { hash "$1" &>/dev/null; } if [[ ! -d chord-transitions ]]; then git clone https://github.com/iovisor/chord-transitions.git fi cd chord-transitions export PATH=node_modules/.bin:$PATH if ! which_ bower; then if ! which_ npm; then echo "Error: required binary 'npm' not found, please install nodejs" exit 1 fi npm install bower fi if [[ "$(id -u)" = "0" ]]; then args="--allow-root" fi bower install $args bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/simulation.py000077700000000000000000000000001305314114400312612../simulation.pyustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/traffic.sh000077500000000000000000000024321305314114400255350ustar00rootroot00000000000000#!/bin/bash cmd="ip netns exec host0" if [[ "$(id -u)" != "0" ]]; then cmd="sudo $cmd" fi B=/usr/bin/byobu S=tunnel1 tmux has-session -t $S &> /dev/null if [[ $? != 0 ]]; then $B new-session -s $S -n "c1" -d tmux send -t $S "$cmd ping 192.168.0.1 -s512" C-m tmux new-window -t $S -n "c2" tmux send -t $S "$cmd ping 192.168.0.2 -s128" C-m tmux new-window -t $S -n "c3" tmux send -t $S "$cmd ping 192.168.0.3 -s1024" C-m tmux new-window -t $S -n "c3" tmux send -t $S "$cmd ping 192.168.0.4 -s128" C-m tmux new-window -t $S -n "c3" tmux send -t $S "$cmd ping 192.168.0.5 -s128" C-m tmux new-window -t $S -n "c3" tmux send -t $S "$cmd ping 192.168.0.6 -s128" C-m tmux new-window -t $S -n "c4" tmux send -t $S "$cmd ping 192.168.1.2 -s128" C-m tmux new-window -t $S -n "c5" tmux send -t $S "$cmd ping 192.168.1.4 -s768" C-m tmux new-window -t $S -n "c2" tmux send -t $S "$cmd ping 192.168.2.2 -s128" C-m tmux new-window -t $S -n "c3" tmux send -t $S "$cmd ping 192.168.2.7 -s1024" C-m tmux new-window -t $S -n "c4" tmux send -t $S "$cmd ping 192.168.2.2 -s128" C-m tmux new-window -t $S -n "c5" tmux send -t $S "$cmd ping 192.168.3.8 -s768" C-m tmux new-window -t $S -n "c5" tmux send -t $S "$cmd ping 192.168.3.9 -s768" C-m fi exec tmux attach -t $S bpfcc-0.2.0+git0.02884a026/examples/networking/tunnel_monitor/vxlan.jpg000066400000000000000000005605751305314114400254330ustar00rootroot00000000000000JFIF,,0ExifMM*  , ,(12GF GI idarktable 1.6.72015:06:27 23:22:092015:06:27 23:14:19  #2015:06:27 23:14:192015:06:27 23:14:19chttp://ns.adobe.com/xap/1.0/ 2 5 1 1 flip clipping ffffffff 0000000016512d3e6b6ba03edcb66d3f9c10523f0000000000000000cdcc4c3ecdcc4c3ecdcc4c3fcdcc4c3ecdcc4c3fcdcc4c3fcdcc4c3ecdcc4c3f000000000000000000000000010000000000000000000000 gz12eJxjYGBgkGAAgRNODESDBnsIHll8ANNSGQM= gz12eJxjYGBgkGAAgRNODESDBnsIHll8ANNSGQM= 7 7 0 0 ICC_PROFILE lcmsmntrRGB XYZ  acspAPPL-lcms cprtdesc,tdmnddmdd twtptbkptrXYZgXYZbXYZrTRC gTRC bTRC textPublic DomaindescsRGB sRGBdesc Darktable DarktabledescsRGB sRGBXYZ QXYZ XYZ o8XYZ bXYZ $curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmCC#   ~     !18Xw "7ATVW#25Qavx369BYq$4bst*HRZu%'Cr&FdDESUc  ] !1T"6AQSs257Raqr#34BUt$CDb8Ec%d ?;k5v{.Nz ѭ#- +=M2=żJN9i⨺{"&M~Gyk+OQOn dvGhX2<iʥ}RDžT记hXiʥ}QtWXui4y L,4R龨{DU:+: D: ߶m" m~10s0"6,I-¶jҙuzQ+;ɷCm[dIr4M4TuĒ5Vad'1һ;i$or{ʴT%VRQi]|{E$m'd(N6X*R.Q.k:MļlK,)88ɹ<j%!uQIQ&;-*qJw{7}%%uu(g{&ՄWsVvR^'RMx//qiů,ܻ*MrfZmlyw\kOtF#SٱiސhܮOrj%¼EJJ*RڳIOe5wf︺QԒڻbSn2]&ZW;*Jm C%ͨ:HDT>%H6IpIn_c}Q-m)_ge}{o-SjΛ[2NQj[\[RNM4ռj1,,T) Y:ślxr$-YeZhkۄ}te3YԌԥ(.pPm7k=^|D}.=F~CgT{2IӲi7wX[~eHVfqzU F ]]蛻r+kZTB%}LjVӥtzqqyɑr}GdlM;HIU|*&moḞHA(SfG]qkԞC: aT[2_(3s&ٷPتXڠBѽi&u SoƐ3$Өqq8qeS Vލj zFXˆ+亖.rEŹ%S *eӢo[&RFVgW=\0hVU*ƚJO#'[/yxҧ%%(1wrܬeݮ5ཹZr(w3 G6RIu->\A,fD%#2옩`iNRvnݹl.?NQRWW{f]-F#x`e+ k^@fTۏTdu-e u6ӿ/d3LiƤ!5ܥkZ*kzvouڼJ*T[N2dm/u|1ֻSvw7LǹR#deɣQ$4\֗%*ZB(1g*ܴ%daԩVOy}ɨi4Q.uU(ZUOa{^+}$ӌvqv|j]fYS.TBMr#߻W[w8V:q[M[zi٫qrfR-R6ߊIL[VbldYB[} KrTE<tx2SFr⨹sM7*i8ؓ(rRmFMrBNj8+x5(fY'$۸nQTX~߷V!\1`Y9)JTJXbFI()Idm'΍Z3j0K6ۓQI&&MV,ڽ|c Kb|'!GRݦ!q߃.LW+yJm[ĠԞ+^U,>өvZIJ1MfVn2:BPn/mij7M'i'k39k偔~CrMT.G)&qCCJJ&J.f\HGo}2vEe5fM_&`g]vK{Ju!M6Jqnf{]ڹ뽳߻- S>iz5Y ~q-x系itVx5u}E@tlE9/o|еj#Jvr-NyMQQLC+2%"1>j27WRT{m}+wR.D[Uob)6.˾\QN8]4(ݹ$\֕iShTݹF1In7eu}3A9|Ejw.ym!S=c/:˪@6@MNo twTXv _&}?귐 ;*sG;}/zPSu[9=c }n a~Kd݆=zRI\OLjZiJezq3$jݹNzdtFmn{`ۂԛX?S'])-/Jtۇ e[:&v2 .);Z2J0j9(%$Xž[(6TeVM96NnݖRVlg^7ڧLCZɵqH&q,6C>ez=옩MMW%*n%J &uB1lv5=Qj2vWՕ/.)osFUU,-qWF2Le-K-~;Pp4F3^Q[c%E'w-NcY1 sk(ɴ=i+9=n=6^!`cͱe>?jdLu,WU Dӭ(JXTkK7%-[Ci$+z\۷n[Jv'q'բjU0pmnSmޤ/-$i=UZǷn'1\VF2Eh8y9WwեhJД{^Xj(8u ӧFub>Ư 4I8q5<[J 8^8;E4&Ŵj3fz} >5re ԛ}vȌt82fd-4+`f u}jAPsْ(գ/}mɵkTnœՒrNRQoQ}/z~ܷy˱m˻!̇9jDuqTTԳ",>*/miBL]1)Rt\a;O)E줤y+=e.*X*x)EMr'4[eԝhk[7m+tFk ++p[`9|i>t,/=yO|~}ѝt46}^߿rWN.{Z[>r%xxۦ ?E䎃U<4~x][4x}ݵW鸱3{<yLл˶c06qok-?}%mhj">#uKV^S_wxQj0|6dϵ>53L$=8D_{sw"[ce~OűGg(^7dmxn:^~ B*JuJM~y+~6ڸ+ |{=|>{Zڿsό~7g$|޽=[Рp?~8b\i_ Dr?2 $E_o8*A.EݮoM9N5?DEOsZ!BU s.Sqd$)gm"F\ܻznӧTnINJR6dZwFfFD|dwXD&:96Q7ɀN_uM`co|dwXD&:96Q7ɀ/g.a6}ϩZw5 uۓ91R<(Afey3 1֒jRZRb8zDg '{RC d2_6̊Uq'IRM{q虍l3jr؁M-*K \WJ3?D;Zg_6zMՍ&Oө\*7D_CN\A|^dVvܭ83jfnOi!*{u6Î7VKtI뻊sxә/'q\Χ[mӓncIfK|yڻSQSєIm&댭Dmp \5[mMnn n7(Q6eXf䛻ڂ-})Ga890XL}޲j'_;˖2CqS|%*~1DOYCqFxiOs۩j{{0J)ٚZ\[>iвڊrSKm|AnϢShNq9adC!N:$>xԲ2FĬ2j- }IgxST~^&/V^ Ƹ b/U?o6_kdlq-&c}כ$-lɷ1LLfg!&\ۈ.2JۗoVKv|Kpz.J-ͻ=.~MՍ/4qr:Y-m)-)Rwq!DU›O`{6ˍ*m=q9E^.5bII]7g*Ŵ#4)e%*ڻGz_zҥm鷭Rĩvf"1UoSIITdpFiUTM6\RpjNZ8N=҂{.1^m}㻶tWK mktt_H4*z!T)^!q֢%+\u-DJ$\bNJ4ӾHI>5u-e]ZQZuRuJQv^2jy4S9vmK鋺-zU wE_0$I9D& \I{8$˲Gti? NW㳲x'.^n-5݌E"􈈈LE8%ci} .ũ[8[9KLT-G+(,$C\k5Ju&اFn7mF4'R *4jV#[J;MõmHaC|ŕ)R\mR sVa )K%{S_Ul+芩#!J9JTK9դTbߎMlXRo;{ʼ(kҳ-t=~IKKATdƌҔ|11w8GoEqn*[VkJ~ vIƒ[:Y"Vt{):qZ严)IgUu?6NM# w:]+TF9|ew2i,jFT©l'KE[uI%n"DJj+* ^A“TW*LDb7O,hO-I"/dwZt)91Woė!6kC#ڍ">uQKʭTd;j-ӎ5 MiJN=Qn3kkFq*Kh~}Y=Yz˪@)ۣB4za~K]VG|Nho%Xjw.ypۣB4z÷_u5;￁U8m!S=a/:˪@6>`&쿁sϫ ;*sG;}/za-.e]" -D&tgѫVHiD-YPd!IRFGF]+{7OsOimL.*.8{+ [4O*pbQ$JZƅ+wZӆњ[M_JFE,T_YtD6`u]XK6h5=`/M1~͋ Tر|E5Key+;APWǿxi>ϵmjṽJ=＿_tX}٧oo66~kXd|[3c򜧝/l[rEt&bvJv_._dUavk-vmXϚ8e㩞KNJoϪ:Cr[]Żvc &Ou4/ǵ;^>6\v>b=ﵫ~=v~{c0rU9=p'+x}N>C~֗-Z$_'c{gcy6n{;H_gYY'^A;;Z!֯rj/{ahONg|H5*ż;xsi?9Mx}H?)v!Qיj=Zhe.(eӹ)B_Q{DC-4wA?kVq<*-C5Pi\iжŮLDoZD9\*L4qڥN+uڻvo0Tu[_r+gnw ςjr_u\vۿ~_ujr_u\vۿ~_ujr_RS5_1w-d &K~]=uRˑ#4QmVjI"IzѼU`lTi{;OiYf9^R_Iڨu@RIDiQܤ(qi3m; a ha/sjw5`9L&:>tTn>6o n]I YrZfs aiҨq{[06ۼaڲ{7n2^I&q')ʤ^9NroEZ1_ZE'܏qf|r9<!i.e> tjBVԤl #J/9=-&{ZjMEKf6 0**-JOWm=ܦm& jnejdžqiSmSQ%oO!NR-km)A#d~tܔ[w{=ʿ[;/4qnME[)ݯn[[{*ROtt. 3UzMjTXY)D4LA!%m,JK2ݼ~;6uC FPۊunҔe,.+qn*ҭOcECmM%e%;75&㻻I].yn\IqrR DCt<ӨlȒ6NdVa*9qT!n7Wqvڜe%$V ΎiJ3M8&Yvqi&;ti9WSo E*_8Uk6b sKmӣQہ%\Ɲ⾤gdEGdԣ-{Q% FSR{=}g΋r$vq[|-]&.@’njW2NGRa[1('lgdKS59T-)ȜJRJkV *qiE2qVvڌ]rVQᚽyն_Z]͛n% DufeDk*ɡNAlRN&4Ŵe ݧQEېE<V5Voje=EnmݽVKjζ4,RSe(q;Qwd-p㽶wZx@5 NzTn4Z6Jҗ|&*O nSUZ؜dEuk߉;8J0m48ԓN2RVRM+Yэ ܻ)ёrVZ-dVlܓ:Qc>I'0!N! ]|FSK%dS:TO[m;'tc{Kf 1mEcoiƚ[4Uڳm6WKjVWm$FHeݶuA6eKa9[6J C/0NV:ҸRf$!Ice(ԣ(niSlQt(6J7M4rWO|e(qMjnƢܫ%VMl-0M6\(eidRj̧ Qi҅c9[jMNNRn1IQ9ׯ&Q\VSmE%༤mɶgL;^vHɸrcý$ci7ZaRX9 ͅ%--H)ɗ8SnB ,&dWB8եw%mnI6e-u{^ahɫk)6ҒNRwluG\m`ͪXT]PUj&|=r>ۯԧ Ƶ)K%X~#0znu%mhVM[QUkmRonMmی=k䵯ƧNr)ݐ{7m&)rEfšY(rp*ԧ)(+w;[b,RM)(l&u)ZiTO$k"N}bN'}owQ"-Z=yT- t.vnBwԯٯ"-j~_/R @c3(^Ĥm᫚}  ;t! RDX%rio#e{]EOWB۰(\q$Zy/;"C?!yRֵ)J>s33330}uBm&M:6cR Ka|+iJB~;Z[%h:È&UƒITe@p0vjo{V2mYFê>y۾[aLeLM%YulҦ"J[̭JgnS$('(T$jSexK*[Sj2վT]JSo~՛G.lLkDmbQhU*2j5##[y-H7)B̍ s ʤqota1I^ψBwR󜜪J+RnSi6-]$#Y"\xЯ1Ql*|;7-'"- t)4gKIn6LƦNrOe*-l'9ʡp F6Joٴbgru7Q1#÷\! #u u TtRd㭺ݽ49[.s*tcd7%j+|,'MU_kw4wjE;GZ&~5`aTo QUt Eeəb¶2gA $]h -اQM527[gW VI)mxl5P{iT]W*u&Zkgi;vwag]Ll嬍yZ$*vERU-yQJꔩ ̹"E_ mL;,':04Mٶ S[NJ _zQYJnkuem۳3U{{ө;W!L1!Q҂4'8Х7 'ƪT\doCm~uڵ՜o+/zVl6's=zmu0lrjMLRu7*XiL,꟧4)I;J5N_FGeݻziwum[SS1RZ0խ n΃wskٗUQrfý6v?VR\Kqsn:S첞Kew}new4; ۾};Ew5v V-CSW%eSI~(FF]FF'ñ*mӧJƝٽS5[up4Q񚊄)0M^6qihUSrnӅԣ&ޭ+it!Ė n͇uVo >~dK.ylj͖#FaR)f,&J %:vos')Io{1W{0Sm:R4j1IoQV{+ܧ'eyNVIY,^{&cN}tuyUeT[=jHyZ+v^[ i8{QΒ(B;Z1wNՅ,tPԤԜ%;vI(=+I&rxW,96c(.('~-g.Z3 OsReu ASi?cdE &O^w=[Wx;_hl3d72_ Sא4;حNB2Β$J6i%jҩG(8oӳنӔ#}ZFTpӖd\[Ӕ%+Skg, qj*vJjf_2Ҕ[5XH6MEpdn=ucRWIťmq{{Iܵn7{+*rڒneƬ՞C`XޕM]+y=ֳ%=*Gq=M9)RT RImܥ.⒥R1mʣj۠Gnm'7ĒJWSZJ4ԔU=7erܝhs.Bٕ_m;ꏽL̯B',?JhKwl *vG'}Fsyȋ[?y @ =X zs+|7[~4dD`E*"RUK-eQܽ,[z qq Z|S-'+A6}{XC}RH[lvn)x63h?#?ڽٯJ|kZ{\Խb0 @(˖7LgT\AXa8g*УYzΤHJaZteEVKR!s(J͖Ic0Q );KExj9?˱2ҩN)է%%7{Yw5{w_{4i33VR4H4F Q76j<&$m"#Y!23=^]f3j*I;wmݵiNQn}+F PJ;JrWrmMÕj}cVgMn<<ӗRuǘ | qǰSj0bc(J1J+i7w:RET{ܭ{+wm柘ؾ%?(튥Ety+}-5竜N޳=\3lYܩJ-1v IFIG_T6[ƻ}jFP}Օ'[ĵ+֍2T &JTU<Eȡ4|6սm{~v+|f*)bi乻nR-%iTr[ǿ}nVK}-ͦ{~RWNșR˴$ͭÏG> Vq $ށ>%+zԥ8NJPʹ+niJ;Mqնwݰk$ًxF)(gi%>6Χm[mtjoԩ<;{Оw\C[r|n]jөVNSmmnwܳJYlʃpͼ`kM V~2lc["D mDnT)-*{Me'r*,]"UsMJMNJ^u"Im6:!:8*tqRK{mEI&u֊K)|qoyyڬƨP. ~Bԩu(b\G=HZT-+B`u֤%uMI8-=J-Ҭkg5iE]5MI)&jI4GǸncүy^>٧ɾ2c4ƖkD8A+ r5e*q[,Ҟ^k*^NiSoiwR'dڊo-zuJ{ vׅld2Nky*'Q׃D-^ץڝMCkir/HYz ϛq$YC,NvږښZg8F}̱T冕.{Du[efBT1)5p޺ng%(̉@9H%Oq3ץ qQk'鷉"?^{o&"]ݞm O9KѨD:W+hKEݟ=H/³񬿋/BCf_-xW?ރ`54{'4>>z4M$Zk'՗ގAH~x< %|C̣WHBH뉷ޭ]-Kr"p՛ڟADOfHr- )kJK'^aVbIvFٱ#Q%ojCp2*7$ʸePq*9U8T7Pe4iRInQ)#L<(f=q9q[B)k'd]bY OLekbMSWҠvnBNir[Ȏ"B řg331!hc4o96K RUp)M(YA^VmCW"cMF6ēĵG}b4k!Y&cS jPw.tcip\8x3? X{A1.ʣXiͪ;5*SuJZ%s#".b!q j+RT].)I-wG(֩ɜq!sO"N}bN'}owQ"-Z=yT- t.vnBwԯٯ"-j~_/R @c3(fƋg7XaBz7]@--Daø?@aBz7]JJ>#%K!+/T>{_9IQ7ʜD\6"+& woѰх|Uy_VUD"/7\HQ$Em~xq[U.`{3Rt9X]WҨժJ Mj:RQ$0{)H􃟬{rNɹsOěLdM!GZͶn"\ Ofq֚timl%kM%L]zمJr}ʽ)M^źt#G^( ,vH[ Ip̽WO#qLF|$ D: ߶m"~hs?vQ G~sO3w_K{E>}Y};(׀OW;?U}čxt$@k/+f Q^WA qNƔ:#jf[{[n&ʳ:UU SgXF*6;ݷYt;b.zWj7^-1P3n6ˮPeI\'ɤ̷l-<µ:q%(;[ymBMIxnuםW JD*EF&eq2mĩ Z|+IsPl5)Tl` Ge g;q➢䪝vzz ڜ:,#ѣy<={e5U{j19}Wj(*n+%DBӍJFK+/7Wә}z:jaKDZݼ,[Zs^E wG(lui-pIJ i-5nO _hKyR7pӷޒIݟY mf Jv`:fYUbJxMgZ#tTtCbr:rS(pW2/fkKkK>OGiS\XXMRM\0NQ@\i_ Dr?2 $E_o8*A.EݮoM9N5?DEOsZ!Aݣw?~u lUR ?OX\ܦ Ȍ;w ?OX\ܦ {jfK6ch_WL?33O|? K/OcfHg;r8HS ޥ_`Z)B-N%-_Gr[O<.ZހF{*DgQv[M*~[{aP گ%.Z)K.ۙD!1Nm'|ۈ̷&lKQYJ'jq2f0=ƍ".ɭ]ݥV|+{<Avүwd~mwo9 - tڇ]Ǯo>2x9IG_y7FzPelO qjO4:]9~Vn}h4SMFo̵8K!c\|er/r+a8Ҿ1djv}W\DE:䃏Tx:)aS|)QK53.a4U0qqWa{u%F{Jq5 {J>nszŻFCA3?s͌BmS!ח+Ja2= uIפq{Z1t׸JKrKp]`$wU{ޔpiSxN||ZTmJ>ܪbΫIj#l%/ժn:i#R|(I$""t~<>kӂcrRrEG;^/o

D: ߶m"~hs?vQ G~sO3w_K{E>}Y};(׀OW;?U}čxt$@wO:,QA2~>ŐʿM?VODnϑ|Tr| ZTW:uG`4 'Fɗea&,ɷg{Ͼzs5?wўWݧx7̗V^n3# u%.*V*,gpe MNZ)`}KK 7˪qjQ(JM>̊JZ㴷=S{-MǺ+ʧeili1om4\ILŻHa=c9 9,ȹyBFيv2[R883-YlV4"I8ǒGI=,gwG3>ꚦreO&T{վ깇W-.ltwU:\L}3uWʾ7 ,QU/)Y=jGN:!x%PjL?KnpIR3)Cs kQ$fD.p<RF WY^?adrژf_GFw05*9TVzf,RzDLO1ę/&!(ѺE,, мO 9BRvݬ͆Ҽ҃~`nuWԥsIm3݀R5]qSRYW${d354!7y;'{qWx:*Yg.."钇ڽx˹*( S;(I۪$eK"RJޞiJ4X1j (xm5 ^%<\F 0"N}bN'}owQ"-Z=yT- t.vnBwԯٯ"-j~_/R @c3(fƋg7XaBz7]@--Daø?@aBz7]KW32_BJa xM|j_.=~?+5G?)'@@=UZuIH.M&N(uh.e(DgvݻyT8̸/4SNJuݏ3%{ k2V+ˆhL2xHޘm%J2.u9!J=y cipYγԎ)u9FW*?8픰*7tp؉:@ME/_Y:4d3Zi490ѵ^uU^^CeWT]. zmY'-Y#!8Qu,ZMoӬ놃NvmÀMĒ㒦j[eΖ/I+EiZE~з:ԦX-_dJH9&@ kfWwi~>32 C8*EA/Eݲ?h4@a"-lC D ]0`3qόECEl?WtMчf?[qGr\o3y~gS꿸Gh/GN_5;_Z?s6iv;f)dQ?3-s#RXaCg.7\?#닡Ot׿J`S-!ر R{>v_?$|!-W}"&>WT?51^+'3bɨ{?/5yv"ج+5 ‚x+L$DĜSdS([b5:f[l%\G4rP­NIxe0ImƒpCk~pw'Y+ eFG:G ]}~](S?f?VuCb}_MΟ'^g[ɾ*s9}+jvrj{Cv#d2v0][۳tL=9?dBӍJK+/7Wә}z:jYvi3QwX'<TW~.;)SҲ_&i2\D.I@FU6&{os8dؼ<0$D0ni4w<Ш&Vve6oZ^}(2W q79 mX^~ ɻףIRI?r.^z۬(bƥ/22D&oS-'zyN>iFgQUӗ)JkG_5faO\ݵmoUǶ'aʽō3nf ɥ2R-K)V&[i}P٭(0Xݪ oȰIJRS k-"56UoU;)] |g88=,\KyRg9VegapNs.k7YEx}V\5;;>ti%1M/[j1 JCRo/ũJZQz.7E:u)MזnVHזf{-~J>L9{'\!y;q*C q]ĞZ+;',VUumK*[=.~)q׀',Qݴgi)1*k̸RDamF}-P24T}p" HiS5j*8MYXc @\i_ Dr?2 $E_o8*A.EݮoM9N5?DEOsZ!Aݣw?~u lUR ?OX\ܦ ~vuǒLHQ]PR|F#ɞQ5ϼ-gLcGy8!oh^Ntk:d:2ζs+X"Q?f5["ỏRjRi~_B-Ih2Rw0/GW .m;XξPL>*ǜ.[a4n.L U߹aW/  [j P?I&>7ۋLk_يbNsdqN1yЦw}[l#*" es=@1rs ۳*kЮ?[pIij:\j+xl#[0~%3g̊6-#tjE0Mɪ>q\'[tk:d:2ζLcGy8 iڙou'QV葥KD1 Ң[q'y$}"\ vGm5IKߒe&Of&5u[S/M.tmU1M^mCr6Vg? I$mN'l5=7*j+O:JhADmU;V"Y񙒝'&ڍMy lxi&TjO3c(R9n2HqnN~d"]ESoLMh{45gqu(QFxL94u WVyTJU;+r*R_QI)řLJ08^^+Ը:dPj\5LM̆PfL: )R Q(zwp2ζLcGy8!oh^Ntk:d:2ζLcGy8!oh^NXvXM]5XڿVy蕲b駺_*#4!/AQ>`7vvMl/¶Gަ{WXuQHB%G{#h9lݥ> 5w|=e~^  =X zs+|7[~qt)# L֙jeD=9;_g_Ԕg䏚2ؽo_GjǕg@~sGy4YMDP~9?Cb|芛

%h]kΘrUsUʔs) DnKojQrHk4Eq~iMG%uֺsƋ/vI&yE6vkNzt:;,bOnܴEDMAe5JCij3J 5xRNz8NI;jM5{s14g*w-ʨ#cEݫ==@57.s旣PuW>{;H_gYY'^A;;Z!֯rj/{ahONI{gnRыڔ#Ww.&_{\ibM~ A?` s].\X%N!G[%pM ֵ($Dff}b!1䢕>۱U&r{3;BݼTi:{}E(dw.~ kBl4KK|/Zd 5_h$Mˁotmi\5!l;a\]6;.ɾqApX톉rIt&K֟_bö%%c|#'3"W bbV#'ZJWﺥ9燔jlF^Kk2ڗ1g=UM}{"zj#NLg qY?֐XZ4Bwn𳿃PS ڹu,(:lwSo܋Nx^Tzij3KwOe'K& aJ;0qVWg0N/ eblYYf:F>t*⋄FfB)tI)O\f׻R\bqY<ƃQNkkwS[a)O +;_iW+ j*ʹs][ԲUl3 |X\vԍm%yN4ڣSmv_Psg;åkO b톉rItٮv\|kO a p>M? /l4KKe7:_.k.I.93}|a[bYf]eٸi[Ѯ\L*l!N&MI߻y Kʳ|B_R{-]6Ӻ8z)7o5>f1nFjZWٶRƐ*f&S%p&FjZ F"n䘼neIOm ~e:UznAgV}nշSvӪ%ۗUp1z1-QM}qj'IRQы#%-Iޛ:F2/kį+ʽ QztowOc_tgXUaFO%*F%DP5^n7Jz:~Mދj;x.|)x2i6^!eWAj. g<}nNc.*z7IFY%:&%:8WWoe}giK{ROU'hqm!=۝i 0FtT%5%ʭЪN@jrloܦh\{~nRTdF\@MLl}AX!7u3d3s6z/=!J2mev(Zs*t*mrmU&[%!<- JBHRf{`Z(".ɭ]ݥV|+{<Avүwd~mwo9 - tڇ]Ǯo>2x9IG_yHJ}Ubե5G-*5pV#-ŨJRf;[Fpt%3z 4O?B1?ߚӟ̦1FTiVę,E3_;# U#f4[m9}O=&cJu=aa+F6NCUzQ7oF\1e|:uewvpgxv+K֟_bW p>M? /l4KKe7:_.k.I.8~ kBvD$lv\|7̘#j|,Cf\5v&7;^$8˄N^ԶI%ؙC)hJ*JNqn2'Z6ׄQڷl`j̴"ZNBu,VSKAGʘA1g-i4:kvf{Zݙ\,ʚY>uoF士"̼g?CsLLSQx祈^zOG$ψQ+*5tO+u.^]9RyEio>6k[#ZS,ejQ,(TeSԔ}fGɴIG}HZ>qM˸i콨qs T^ڻiޯlwu* x6'a'tBT#pļ\/`R'+ҧbRws[|*o6Kx ٽ6ܺ6ĵ/c1.赉Pk}/8[ĖI؜uU[7}medc*X$o/Zd 5_wl4KKˁotmi\5!l;a\]6;.ɾqApX톉rIt&ϣS[U\HR"U鎟4h㮺 (BRFfOժ(C7'%61TISwH#1V5٧\n;nEn[Ofݶ9*ť6iEKSQ!XM9KQΜ$zR7_LᨵPi;S`"޶f=o]WjX؏K?C jÜq(5<bs?G8 Ƅp9_fyn;8gNN{. x[Ns֊ [.ېܫz%NSW":nGS- P[;mY.aʭ,ړ㨩YNڷ^PՔ`fT~JĶzu!4FcIE+RL3NrsysqoIk4g:g:E*Zb \ZJD=DT$ՁMq*rS˵T`{;58qW9OC k=[.rJ A$Œڷ-r22޹s f5ib#(I]4Mnqѻ3^r,%`+c^661RȭSqLܕ[{d2JFъިNN+aw.Oi=eozv}g? /펼vD$l.ɾqApX톉rIt&K֟_bö%%c|/Zd 5_h$Mˁotmi\5!l;a\]6;.ɾqApX톉rIt&K֟_bö%%c|3>@dFiwn_D֞Mj~K(LTJȔRҜ3J\ۈYi_˳7PqRISQ֏o]ڹ뽳߻- S>iz5Y ~q-x系itVx5u}E@tlE9/b| k?X C%WMMpqGzZ34/Ȓi5vR8,} ҃TlO{xv u# ɭy,[\;~X\%ƑSr|ey#C%*ZT\IIDe3>Ya.8Ƽ+ʴiWѴT=|v^_khW$ygOՓ/p[u9և>{E95=bQ ; eC;gɭ?m:@^svtgwi %Dvi5@;r]淍ݘX4&&䙓\\Sjw^TVrIdu),ruﭛHm-4PXl5 H5(սg~z[)ζSO+َۛrW- {/sI74F{wRyp*:i>rb"s}o૪$T]&[0gty_%obu2R,+a8Ҿ l|sb>3&)lsed>n|'](~ͼAv}7wc!;WlI?/ΩhKܖ˟T[YvjE\] ꛏPemeRdb$9ϏOG?Z8N S)?b4R DFdJݼodޜmL{WE N6=ȢSUQ|HӍ}($Ǿ{_tjcj/pP%QݽzB[qSmZz Ķ+y\4\kםQ[vqGVM5QDu51;/Rimm+eVJBe.c##߼@aBz7]KW32_BJa xM|j_.=~?+5G?)'@DkPNZ*EYɍ"p}TuYi4(s16ojDy ,rZRd&9nhٴ{Pȹ[ߞ \%e֔[uح=3M1]a%-JK龯pL.jmoQQrڊT⻻qEG9s߼ G5++N ޵T$)r1C${z&sGζǯXկ|bWlu:e,xuue#[Ƃ23.d+L6ӫ֙ߵ6IT覾&i%DJ4}rf}hg[?B P&ewv[|NS=+ЬD:(ҤZ!]#Jݑ Qg"0^pB%_uS~cw\wl+.Лb)2[2Q/TR%Gg4ogaԓӻ~eJ+XXw 'EFi:MCQPi%䒟}D[֣?4 iRp3z피 0օrHq^;e//LhW$@R.օrH;WKZ#/X^;e//LhW$68/mq5ZYP>=yB <S|'Q2_|O(|;?"zO vUSOˉ>Lzc^LnLi*Fm*%XmI> U/Np [, p }?5BժuS5be0^ͻ-#5d2iRPFIRqs xTTU)T{jۼ)$-5hٿpv^~L n3:FItyb6o3=_w\D/\P E)7>d>&yJ7{406[:Ns\-vڬb{ΡN*+8)>g+#W(ӆP`Yb<*'ƧMsC޼ ts1VƨXwj~|'M "g|+B%"Ϟ}Yx_I!Noi@"61*+bTۇQW8 ([V+މJ)둓 ]5}OYbq) 9_7lr۟_qu¿YJ.+ʼ?*\Tjq\QJQVC B4FVIq$=(r) WƋn**ir+rUPqI"h̐RDJ"=ӭnBw2?ex7./r5,s#㛎vYwe92U[M!iQ) BIQȺc2dԋO[Ѧե:3qG6e0:<;ENڙ1C*o6K_çg n{ӴZk(:rȲSJZpߐf㫋i|$麱VMoI;,ivNN[[փjQ#p%++nRIS#4ަے%|U9GjV4{+0M٢+: B^4nMSPKo$d܅˛ȷudwNώuqӍٶWk^4(u@iJΌm:$hbqZt/m?ZFsv4%ЦQ)tj:7}qM(\"8 Q}e,8Ixi]i;;S^ʆ6qzU֦Zf4yusRW"oA2sʵO0V̰|*_nORE=z2Ԧ'вqB]^zEJML9Q6PT{Ƨ\^ZK?X\9a_fOi%{w-ɻ|ے#3cp؅ռЕR*4&F$!$C^KKBzܕk]i4iթj!s<`V)(7I3O KrR.kc|(F2inWwm>Liž7VE\5X=:]/Jj^>+a8Ҿ l|sb>3&)lsed>n|'](~ͼAv}7wc!;WlI?/ΩhKn*#UR:Ǽ((%Ke/ҟW9ԣ33=f|`'i'zv;uj_x膣J}n}tO[Md9 K-;TgImE+BI222220aBz7]MM8q% 4-Ң#}a< YuNfŏ^ٚvDӌ-:fn]}f pӕH6ORrEq=IhA4n_>r=˹wWwd~yG-'u?;8kW>K3Lr{Nｻpc3mQ{<fc AW[')oHiDJuIIq[Eq s13q5%R|W"֭jydi_.B&M6V^:_iVevx\ic1T}4>ا93q˙0ӥX70ʏKK}?7<.441P^>Ѳ3RVR_:5<e?bS@ ”2 PۉP.&s:DD\m8(^#au\_fЩtb_3Oa=Oekuy2q&$4KY KE cHʭ-v2rO#^6sڏD)U5!-+\&D{8[%} ZpNppq~y=:lg4, kspI)6;/Ƨ#xLצ? C/˯ljvzlixϚ^B!w¹_| D r^.G!~'e]dQz"6hKI-K-#۳13NuqSHRR[^+މSSƓ%3_ep>'jWb/sko[-eܽt޹.J_WUfpܗ IbZJ)ufjRfff;YЍ*QQU[H#6\G@R={CoJF]E lT=GrNM%%R.$o$>Tdm :\`hbxٗ|i^ن_ lȾEѯ]D<Í3]V$aY>PkiJZ\n,*ITFFdrSYMUSt'{[汙Тܾ;{>tڤ:5n?>tM^yԥ(ϜBb]69k=8J3N_Rѣ QWAukW:dU%\یdd~1mWN2ֆ kgDp͕^nqUNɔ~K왛?`ŶJلiIY#61\ILMםKwJ%UZ"q*JOGxŤҤ %s̈;Gh;IZMY5Lba*mAk9-Uݿյ7w} [)e2]x3`3GǓ_2T3qiuzsAo4]t4#Ǚ eD*;mE*Jddded`0稯Mَ$d$blQwq:y (XXթP-uo%#';GZfKuz(TR).Heq$d^i%-]Bub]B*&FGN'ց?u/ kfWwi~>32 C8*EA/Eݲ?h4@a"-lC D ],Ŏ&:S6m:GqlS8Cij3 *gXک.%_/ *ѣSQB %u܅H[Xؔ1:LhTvc%FjfDrU+uio4K|c }lEEtVnxd֧%rɼ#5Man+IaShgIJX=ov obvVI_鱗a?tKNme[`Y3ҷƠ~v KisO;}+PJf6i/>+@}+{jGhp٤F4دuﱨiݡf\bJ>ҷƠ~v KisO;}+PJf6i/>+@}+{jGhp٤F4دuﱨiݡf\bJ>ҷƠ~v KisO;}+PJf6i/>+*ޚtccSK-]n3R'"D}o2ǻl$:xcݶOBL1'!^mS/ {A@=d |ev?>Hu2ǻl$:xcݶOBL1'!^mS/ A@-mm[/"l"hG[l#Ao?d@ 1)iIeMa%hQnRL23 흳C ʛ2L["SHا6"2m*TsQ${f{S=ddwY'D/&{z1Fj[Pih91:Q!DIBn2##2[Cs1X@:}PP]څ5+ wz^b!O|YG~" "U͠N0?Ց!A.ZҎ;>*o亝Eź"V)[6y͎ۭӈR $Ҥ"2شcIq){kӋRM;?O/ uۏdﱨiݢBI|.i̗o_%X[cP? ?C%4|}co}@3H4\vW>5#8l_#K}qW_:V4I|.io_%X[cP? ?C%4|}co}@3H4\vW>5#8l_#K}qW_:V4I|.io_%X[cP? ?C%4|}co}@3H4\vW>5#8l_#K}qW_:V4I|.io_%YPI4VEᕮ dl{ʳ PL]s DiQܤo# F6iV溮~+Brֵ NTz]YCRɤ$$v/auϤ|4iʝ98Ԯv&n*1I9'w[Jqny |+PLm+C"}glߘ3E:ny |~J>cqib {fUb[ѩJsd($_Qk>u-JQs~+4Twoj'Z΅L%&~o Hy}cu"P"]ݞm O9KѨD:W+hKEݟ=H/³񬿋/BCf_-x5X=:]/Jj^>+a8Ҿ l|sb>3&)lsed>n|'](~ͼAv}7wc!;WlI?/ΩhK@:}PP]څ5+ wz^b!O|YG~" "U͠N0?Ց!A.JM1pE[`Eݫ==@57.s旣PuW>{;H_gYY'^A;;Z!6+l ξ#[)$BRnQm8Y ej&JiF(i3-C}E%u/kƟ_:r ĺ2V85oM})7(ci%n9ť+RUfG*U#MMgv6];Jͯ N]|;}{ۊm %F+[^ܣ7(QZ#"5JEFE(UFv%ton}-/+SV`vov]$%sCl"eK5uܥ)U30shd+o* n{[߈B2ftӳ[) /beXމ1^"O^7y.yg~>Ww.\W{V|G/JumpPn56tޭDD=zRnd)l(_mFeRLJіOw5uηN:ZjnfOՍΪ򶟠`]*ƿu9'yF&-N!6V*14u)Mdi߻q4S%RZ}*U+Օ)쭘-qooCG2\vWsYԎv$Iԭ>Jcwܚi(Kh;Uٓ6W5Egc7TzNiT76cfXShZ_Fi7R^R5̸<(`|Sx\C ;pBJ5ԣ(Jmvzk]aa&RUI)[jP'mtQw[7[Y %^=!-)r$zT)T֔F{p6BExd{ѭY7mtJ+ KrCC.6 Mo%$GIFPMY:S^Oc*möվte<jZiPLF&3o>%n6i 45{f)ʚSQjQ^([_a_37|i4OzirlR}mjXZaͬ^W%y4CZZmGƥw\1{5^Q߻mEG95i-,eI[iKionVr&^fC-Hoi[RRLy MJniQZ"jSdM;\iJk'TiC#-CEl?Wc݁C_6.tGחs~u?-.lM/w{9~"կٷ^Bш @"o&'}Jm""֧9- tvl}`;o1}_V}"1LX*O--"]ZMַJ[oFj"" J mEomGe~ Q0ա9x%7ݙ3SUl.vS:ӟ!*n#o8GoqoݿøUjܹx&x3&^`fCN"j nJM6^MReV*NUD A_00jQEzV]4կn[KSr6muq6ݒ{^~ ke,e|+lK¿im]4;ZPMpSfLʸq;D|HQu2Oi-wW[zWk)sku׌zr%6-zueJ--.m"D/a.S 5N4TnѦRr|Kkbvĭ]()q+v_X33j NQVa$m#|*JLXgJi]v5;+~YI+oe@,mMjUӥP(&?HMq&}9' +q ݹDgJ^x7$ޛْ$ԗ{DS;FV{̷V㴒n/qG#@:}PP]څ5+ wz^b!O|YG~" "U͠N0?Ց!A..܍m/ϳ$])UI奶bKIiKm(DD\TaM/9J2U#/ķ&s;&c{ }Jr eJbէ]\Zs7Ҥ%MmJu4֒Kz 7;qqN5aJS7-ɿ7vs5}YhjcjTU)PI|0J} <;IoDwJ )[~jKޓ[Uc*>/썏iw+T2a:bdru$JLB/iN/5N377d/z(;MXY ǗMn;$/r 9!<.#I[BR(-n-w PT?{}~&s:6+Y0{f%cJEzyZU9hI@hG.%^%+hބdYܻVqs*jtT{7R2V8Ǻ]mq94վL5Zΰ]Z)ƒR?Kn4鷰osNHZ\BV%!i#J#I'R\L2*^q xd/8nV&K_o' JzyϘ?r.1ޕ]_4˕m+_NJ G't:4zTDRnC fJn;IM,y (1 ըQrk')NЕ ]/oo6XVE/ tk%Be5qM%2ˊ[*mY!E#(h*n֒uun޷_aا{=uuW^3B,\e>)ܶt*i1q6&ִW/τq(׌u ldҖKeYOjFP9(vSr)nmnOsrQؿ3^)7.U]ڹ뽳߻- S>iz5Y ~q-x系itVx5u}E@tlE9/5'Žjw"X7 VD@\5}x-{65gin9O,EDf ^hZڟdR{JQ4{)vgJyN۷r 'fHܿ j.Ę#Y,אkWMca\v[3+i]`!K1֙Ӓ)T[K[V:xLMjVWۋzM:vQ9^pӣ EJN8CoC 5vub-Ҝ8*sZ{dOȹ+;W= ̨OrHT 1U*A*bXSK5h7,mYr9 ֚J>u*8B7W{#En;-Nr*i(q|wuye.?Bxؙo"UsDi *G48]~4&̿]SiB=2췌xxRke&^sS[ Ji_~c)(K$RSӶ3l9gcLmT{c 56"+*6T'YI}?qPp*tԮըniӭ-_bfK}w*vR9+bUf%*V\/S'.LwЂYBuy48nW &R}\aZqS]~JP¿5g$Sr]*Њ[8S]:vg0(ڝEKnO|'qiխAmlaR*#F3. U~9)9c1ʃMJXvM^)rZ\LY0RP$-NJuOf)]ŒaEEҽI.*6[uwZmRWԦ$lTi0R̶6`\|T]1Z qt9rݍPXhu:k9Y,} i׾B"<,;w"JqۄRߤ8-9&Yɚts1ȳ*΅ gaWSCj1%y)lg^KodkS⋉6y:~oսmҺMU|[fm{>),˴' exkWi4ں]WE,N#Blom%QFVi=ZJ6nLGɷDR)!Αn?%\I"DnJ+$э.mp*f(9*{sqqg:J׍GvqU f"fQԦ:aҒnINi^61X_ONṠ%Q&e veJϡ6tUL霛|*3[ [ ~I:mE VBqT`pKkB*1^8%e5.joiʵF+WRKII`{ijѲp!vl}n/[n%vlҊ5E_/AqFOljqXUHՊV^U"gyR}˖Ͳ'?fZs9F\bB}ˆ6h{b79\mr38}'rE/:w;םznrq{'gEx̸;Gp؜AYZ)-nRkskY5X=:]/Jj^>+a8Ҿ l|sb>3&)lsed>n|'](~ͼAv}7wc!;WlI?/ΩhKkNjGqmᔪB|}WCTXt\qu:Db–Եqo8ӛaEIVqݭ׼ʜ0|צTRZM'vW-n0լl7-oRm鴘0j$(w>ۊ52DRē;jOZ*ضoqT8N uG:]Ԕ f:x|UJ{S)K{q55)59ACj?=Q}RD OIBef˖MNj_ټ۱RuPJYZnQ7ם\zXⴍZTV Ӛe-NKQsV#jh ֌i=u-}lZ)2ó)X\n;r*ˑcmy" \'dpkϕRxѾփu5S!FOz'=A%.1ܦ&師50]8[2%-۳[J4bܯ-lQ{;KS؎JWc[ KdZen6$B50QBOk6(qp`Z"plm5-7{[.#F{ju,!;ۘR5*BƋ\UsUΤ{QJrWIE.'dR;Ǻ m6NҼr̶ҋvd]G6mSFļ#\0nj%6kf%KLҕnkrKff^Gg1b (vo} ۤ-ֵ%qN cNJq}Qo t>v_n)|Nҳk=1p*Շ_y4ɑэ32 C8*EA/Eݲ?h4@a"-lC D ]ZuPPT=o V%ZSæW͒㋩" D[~Ɯ3 -JMwemnT[F4ʥRi;tnq햭e3`ٹn},UTjhMQ$qCyQNѐ$.$UxԩU؍NŵS{Qp[9%>NU{7tqSڝ M7J]cۍtI P9ꏓ bzN8(s6\jvU&݌^#zRrDobƜ)lݪt]ʋFaU`0،GpeWn`x-SIsmegmNɖJĵqەyW^\tm͋t\R.Y;#8]|ƍa2{I9 -qv57-YRٔx )mݚQym[e6b܂ZuzV ߰n]{"+t$UdɩZ|YF[ԱdinٻUh/u!4OSei)e{ԃMzsNjfR/lu >r=E))}sۚIť ktd)P!S SR^]G-֫Rbçф/5c)Rn5]R8ꚍҥkvKF5Fu%Uzk fXz\WFk.F3VؐOHg$?UWqRnaN\mሴ`0Mϱׂ옵](llRu/4(nrqr+O~B4v흝v+&s7u|\vPavm-|Tlׄ'abnj߈_q4ѭ)*(_-U*w5Ej1iBҼmQ6kMEUq m-9mSܭ-ݙVЦ*NhSZ^bܪm.E"hs/t:ES.6a>w(pΌ%N5hӌm^ϰϱYJY2wMNJ 9RQNQ{n5v'W'%VE#km]9~-Mb2' P?2B哯kϕR8Ѿ'WU{FQުNSIEn[ Ma'(I&ake6`׽oFbK_mئ䫕N->EQNW MEoI)1iѿ-L+WY:r-pqi RnJ=N,BQw$9scKfH)z-jצM*}€8aof՚ަCŊڔ[8 q 6o:%rʵvmlT9F0*6K؝?k9ZTݾbA;SJHRTIB2IJ3Ӳ1F.,(i.Y\]mT[t$Z)TT%HDb0JJ~enYU:n|vMw%)IUQR>ce*Sig)>s[Mɻnj _|V]uݎ '-Ӭxun5U%oQK #,ZmZJWiaԪnVV"UjlsWnW{f+ulqcp)o*MxiƧcF-Pi8GjIɛ*S&ck!Њ5BW=w{v{崁ztGWFdL6k}+Q64ȋ~7\}X+jgBxܝRnKgqyn&,iYTHZ2߸{?DhA˲R_Ҥ\tHcqۖݭr\&GiGQSrVgJIqȌwed>n|'](~ͼAv}7wc!;WlI?/ΩhK@:}G4ѳJݩ,[rFTUwUR1=. >UTh+Q6DĦͶdDAtzĻr*kvA떌5=+\8tGiǣ^Ze m%M:ٰ8I:NuMR-CZxvؓQU%5Ʃ5&9ɺqd&j½&ZwXV-ZUeGL(!N7EMrTI796̌Sq[ǯf ضª鎈M ~ɗQi=++ W$i6c%[ mͻGXXU]C7L5L[j49$ :uN&\MWf,I᪻J«ٿM;xlFqX-M^4-᳝5{xVot~$G{#h91VƨXwj~|'M "g|+B%"Ϟ}Yx_I!Noi@ĝQ. OIG_yvsv~>Dع?^_y lm& S:Sf\w+̛_[g ^~5ɷhIMAP֥?;!V3[bA=-{4 0vlk.5fTm}M'U޷ UA--e%" mg) L\_<,jKQF0)jGISL$6rN4u!|;#2y3lz9#=k :dx%6-[xj>d4%DEM<ɻMKKxCN O \{0Ga?S찌qڊ|v;Irgh֘2u TjMr~V?= #g. 6u}iaʝٗvֳuUUdK%_) B%#."ZOeIQO.y2NQ:.&}FWPN:!In"JH1whnNZ=1E.h[S=oS-E%<힅%-(Z[fЧTT"1=x]5ҊPr x?Aglړ*t n>G'Ӑځ%_%D=>U@{sYNCj(V#drz=9mZUTCX5znq250w[:S]ҥ̏9,Ȉ7 tWB<eS6E$="ҜkPZ[)M+$ "o&'}Jm""֧9- tmm"8[1orvՌ-pjkd6&˸ulf8tTZF(*\$\It=k;A.+ IՓy;@:ӜNGZ:M'N7'wN߸r>q";Ӭ=LCB))eiJ6ZHĭjNM}rWlJ4nSj;ea̐Y{g"mKsiڬ>SԵHZ۔J{\H:GDeQă}{iiyGev3l)SUfĎf7vCL #1T -T V*xzyu';5'yYG5:9^x7coKs+ L7KJG$To Ӯn nk4ڋ$%IN"RffDEƃTL95rna'I8`̰Eݲ?h4@a"-lC D ]S&ck!Њ5BUjNz%×{U0 -\Rޙ-Df81J)J,0J•WThg]C\($iYN̷ GL6 |2LH4"yN8ӫl}l> [P˦ O1[g/VvfC![)#G& V7I\jiUK V25|F˕5Fօ I}&hmf>m{S.ݯbk{Nӡ*}8ה܄j#.IeLq'%jLp/PE=5xic3F$OiWv~5o1`ŹZ9 ֶO% ̫u>teA%D- ܴ-*B*ISy2@>{;H_gYY'^A;;Z!aFv=~WG_6-sok*f́pczCPӋXyD+A]统k} =F|NdR׏sM_MAzǕ \RZ:d7 \IG ۍ)#N2d%R+5w&{Yr^hjh]"ÚfyL,+L/mb*7!͢a jJij5n{4ŷ-a537Na[ *"KSM8<fr,'k㛞KlŽe尺LiaIBKq" luwM9`;c F#puWX*PRJQDdNpphvEMy)?%JOE3Iy)لBĤ:vw9PF&]Dݏ_ͳ_3$DZ_:A.-#S)} GQ[1ןbwUa=٧᨟\)0=wirʝsi ,r+92޵ykpKpܗ˲> 4ַ}$M[dJ:Qs(_Qy:j2N^*m2)gxVgNdP%8r򦆖ʒnѻSZV= \yFmڸ+Eq(iSJPQ(JTd%Re?ŸouTHC&6j&=:>5OB謙"њ2I~p-@P1Ej#Is:J #]릘!_SDD}TpZZLjXjrl}oVj:QȫaE^y[QRMChKm(m "BD]b"E6(>EgG;zHg_WYt e3~pQz4jG{#h91K5+fǖFyܕc0#D.u-81I,|kiaUznU:n.WJ[Z40f,ņaW1l99[ym2䷮ZBv;îg?y8Zu)uF4ɬw,īvnhJ}ŐqM0W^nQ5Ѫ=J[hٲO3~Y)lmN4X$Ci=D#1w,n#ݯv^ؼCrޕ+lWkhV'jcNUZXXѭK6X6uOr D: ߶m" j3;<ѵk~_S7Xd?lN רO|Ay۰0Bֻrtב%e)+DE Np;[ɽ%E.H䘲:kų^':mUNc_IIus%%o%Iܱp޷mJY1^'jkaʍf]>kqDi58{̒"@g;_Xb>j۾-'MznTz:Y2=2 rnû-;!wu:G_DkmPb% ׭__4̯Ht̯οD17"o&'}Jm""֧9- tioKeJ?ҍٍ=| 2; ? Dީ ̦TŨj1\bO/0$n62R24w:k̑l՝bSEknΌV~JVC"D1YIo>H&n|n Y.6|kwH3ոKNWb:q>K qUO q)_ Jk;aڽtZnkZ:2c sYΫKI.ʏKFi24q$%n&!IB15hKZ!?ָhɶ6N$ܤ2W7 Ja8GJPhVglZMn[t~NnP٩e6Cm JR%$DDDD'}QV"dŔyR- xgXܢ{3|=$c3Iz,:2ӏs?dwh?z8OI]#Jݑ Qg"0^pB% GtA7'WpI5D61NEĹ4KFqĭK%)*RτHy~s4] 56wmNFh;UMt{cxacv-Krj왥ifi᱘L& ZUԥk6rj\O+B6ne=Yhi_..u6Mɦ,i"HaC "7 $dzJf|魡ZEAwnմ)izLgy(C5: $HJT$Ȉp(C6F0%wI]ej{bGen6}5w{E^snI){rjGXɗZy9W SN%IKI\9ZVW}'lW9ΆmS7$kSW"Tv8nQBH҂R aevOaa S|{$^fexWӍj\[7`hwggv> '2_٩zk9͗ L(Z68ʵv!t=2vwTK q#>.Hȸ}`yXO.z|;Gfd[N3GВNm2ީ =_xǤ|IZ5sJ4tMF- "TiIq< E#6vlj:Y dȊ^=p]!iSYd2ۅM0>oPDDD!E͖ItNg#/ТDZ{6ҨZ1ևϯ_ I sWh:_W_QAwkwv?B6|kSꖈAW N2Fl?_^}WkW|foQp.Bٕ_m;ꏽL̯B',?JhKVZImHZ IRL 5+Lo- L5FHJ"v}Rj5#{{҄R?QgK{&-h*-ӫ.rK45h[OV\.ӊ`ȖmRBA**v"})6:q:|܃mBfM!&V44kڽ7QM]';_˘{:=vk GÛљ iW)ͻkRWVH=)C$ܣi[#s?o>ԠvcZ[enS=#)f;Dg%Пr :kc?Ww$j/^,5> Ŀzz( "Ϟ}Yx_I!Noi@kQy߸ƍ\Zʙj')`pv(i=F|NdR׏sM_M.%R+Ӳi7wX[~eHVfqzU F ]zK;A;|KJ(#~.vnBwԯٯ"-j~_/R @Ja)TX(-݃Gϱ;*McM:Eݨ][2K'}QV"dŔyR- xgXܢ{3|=$c3Iz,:2ӏs?dwh?z8OI]#Jݑ Qg"0^pB% _g ׌p<ϖFo,صN }B(Ur(<6R}MhE`ƉO0n4>PeVwu Ft|Yi/-Qiʫu=繵E%GYnQ2}$%v*^6lLKM:6櫋0J.u]ԗ"Gj$w4vbA m)Kq?AH8;ӓIal[<)QKmDrBy%2D^|S=/ Pů.{e%y2ߕIqךm#J[[]ɭ1Ɲ[ÐhoxҋvQI7\?r>ƫҩ-ۺ_+~ 60idF$[rVwG,ͨ;|H R 91ҵjܷ\uIA^3E٧&f{u[~-Eq:¯ WW~@.G!~'e]dQz"6hK] |hͿeƬ~2rh6 ѧb;PLgK5/Axqg?ٲU"-;!wu:G_DkmPb% ׭__4̯Ht̯οD17"o&'}Jm""֧9- tioKeJ?ҍٍ=| 2; ? DAأ]څ5+ wz^b!O|YG~" 1Fy./3:9CF3:ԗ3N-80aGX8FѤPEݲ?h4@a"-lC D ][<KZvrx >0pSP)󣭩'GKҋr(#222dѫe,Rv{mZYircW\׼Q?8} ltiSwp>ltiSwp>ltiSwp>ltiSwp>ltiSwp>lv{b[jAE>`Hpe Q?)xdl>G (T-ъevbQkGGcr|f+&ݑG@ _?/:ߒʔ+%{|?Py'|@e_v]qG] kfWwi~>32 C8*EA/b\^xfts/fu5/Eg@Zqa;qG I6d~iW?6;7VDZ AǞ_W5t^Z-@B32KZA{L>=.#dYWÑuOz˫:GeS#޲r?@Yu|9 Tڅ;- nHM\DX!9Jէ^vE] &BM4~ͧ[>t823[<KZvrx W=w{v{崁8Rqۏcpj2j;K&Y;qNlkQy߸ƍ\Zʙj')`pv(i=F|NdR׏sM_M.%R+Ӳi7wX[~eHVfqzU F ]zK;A;|KJ(#~.vnBwԯٯ"-j~_/R @9xܰFjIR֝:=(=leN bֆE1}No\FW"kK֜)rQ_ŝ2NqdKV릦h84w%).b"!ᾗi^uC[3*9֪~$F+tWvz 2QIx^9I lـ!IZ*#J{F>)+>#N|pf4Q*7dkȯ˷ՉߖQiqGΥXIQǧ9ꮕ\d*2岣(/bqM{";NQK&M%#{Ga}*F >S*m.j_VaZ$&gB+aZa&JL.# 1r6n/`m#U*1"U9S*r";":TdۋgɚJ߻yE,2qtj2u\7-]ۊ Ux«I*c{+9Jy~S]~xQӿa՜v?)9/?wI9H5$Pj.5'&̋][}^\ҷ_'{ݝFb惓lkO F]KO Hq$gi34$wsF/ҭXGz5v& 3Oi',+V9BV]iMf-#S)} GQ[1ןbwUa=٧ᨛ;uP&ewv[|NS=+ЬD:(ҤZ!(>EgG;zHg_WYt e3~pQz4jG{#h9yKvzlixϚ^B!w¹_| D r^{1w\PWWOGoQ;[;Q~ũPF&wggv> jv-z-RSGl5^7-$Cm4L2^.2#F0-ѽ f9>kNc58(4s̓ٵzM,.b'F~*qrQiI{7k"b{{ ,w܆*?g痻-/վ}aU.x!|ê=i.B_oawŇ T~QKuoXzb{{ ,=h"pvZ_˫}Ы]aCDT{][gX>'r'Ȩ:ݖk>/m;,lKYk\e.\!)ki[lEv!(!gK5!Pۧ{ӆQM5d{n֜JY%Pqw"8IDjm(O2Ld31R_kh] )v5S)r+٬^zjU-5=MGOM+]_{? 2mR 5pgl]26w^aB٭)W so"?#+Vi.'+%*yqqvm]'o"D-$iasZqjEJII]'fvlvrUɒp55Өg+eřTF:{s&df|$FdKA\nY.4Ҝ*JRvM_zM7i9޸O+L6xe*ӊi]ˏ3+ĕ>آX6PۛUreDܜI.7mVO^gV"rnOvtMf JP[YKbR6uC׃ j3;<ѵk~_S7Xd?lN i 1'h'{yϙ^Ù_~EboEݮoM9N5?DEOsZ!5V QX%%sIROW9jʑjYYO4?id-`:E咨t"} *kM;e>q4&}ׯJdz:lX+F1h~R #~-SޑJŘ :-Cś$~gg|ڼ&N 4pc$Cr<:iVW۫=}B_oawŋr'Ȩ:-/վ}aU.x!|ê=i.B_oawŇ T~QKuoXzb{{ ,=h"pvZ_˫}Ы]aCDT{][g>## #s0zM~cG LVYT0\4^AWQb&iibpiVg6-F.O{jVmfFzQ2"72J3O`ðf7Ưrs'n ,X'J0.L40z從1zJ:%gjˑ$jr:ɣ%tT?<]zN%CՋyϐIn%()拜^3*EnAII%䗩5sxOgڿl6V:xةACkj)3&ѣ(Щ 8gfMNPm&r׭j[ܤ;>Ŕx|2d%FfCN(rFh{evc:ĥ%7F2~{δ T٭Ix"ėR=`iԝB[WlSmSTZMR (q\ZδsVM)^qJ kmm){~~=ѽvdKLfR5NS{;e;Yo\k[;]qa58ՒJQ>ե%DDEc4SQ[sQsV/g;8X#@0n48v=O m DDDn6sصUڧMG$Фԑ)H[1}sr/#+lii2pTɶJUtQh6FCuV˝ 6$iFFD`2=&Uoʿ984Eyη뻢i-"VVm.D\EME.'?֩^0"]ݞm O9KѨD:W+hKf>.t9/U6` ?[}RMWT(#~系itVx5u}E@tlE9/m~?Pr+9t\ީW̭c#KnP{<[NحS-`y :L_6 wq"wҒ֑#?ILTg #8hUJ֣EKʋ*B[X}Qd񴥧q!*Ot)0:ъNM4g%kwń1ڞҚ8 iF M*mZ{N7Q~ 4w-CơNɫ\(J\:)S\;m-{BBJWES&>ի)NckqNޥkn# IO Q,$kMJ*{ dPbk#1J`Ϊ[QI˂MLȓ 3Li Z I%=v瞵jeuߙO: 78R$ gVNY +$%%xNs&);6'2_٩zk9͗\i_ Dr?2 $E_o8*A.Nhzaĝ>ezFe~u%v}7wc!;WlI?/ΩhK!&oCr9k+5oiPtVI-Y?*&*Pôeb[oku> OTJ:yU-LvQRcriqI"%(Ȉ"]l;$Βj{ݶkZY7n;$f>1`jNcҲojm+& BtaOυ#raR||Z)'uS)O1O%#QB+ &ue_ / QI}-smuDFMlcK~\KE6KloZniBcf fb1 tnb)I/Զߍ#ܣE6]c1ֲڒa;1m/rm~6db,lKzpZ݆w0[JФ4#O L?d֖k M)63p4&i;Z?{d'sDus?()£䢜ZZit5ȎioKeJ?ҍٍ=| 2; ? DAأ]څ5+ wz^b!O|YG~" 1Fy./3:9CF3:ԗ3N-80aGX8FѤPEݲ?h4@a"-lC D ]gS%@gOl@N^uh~혾'n֝ L2y 4 JR"". b8,vsSJodEKqJe56$3ē-͚\A#v:-'P ѳQ4tRxH1֢N3=qGk#h|Y˦u=NZ*i i[&L'qTn+D-LjI%ND5m^#3[W9p2"33E3x+2JmJ>R<'?֩^0"]ݞm O9KѨD:W+hKec2fGO}Rj*zL07>{;H_gYY'^A;;Z! u?'gnz! lh)*ds|jgY?ԭS-Pq0:Kd_RBǃ:I+OgF;y~;c{GQY}, 0G:ϬH؁mQ*?Ūw*bK/]e~5ڿuVaf%a?O?J=IAE^u+C VW6cdkR0|I7VE0Wmq/dvhYET`#6{Q[JhK5g/oD[u;2g|+[ |U9nDHmdY(nObsg'ld6߉Fܓf[ { dY>+9K6vQK{i:Sqmۖ3l—rA}4n}cZ'JCe^uӞΖQf)^ eNsPiɫ7ۙiƮ®qeZ|4Tl9);7iZTլW>Lw(P[*R&:Pn>zӜvTѪtrlcuˠx ^Ҋ(b[M8Kzk쫢|qiqSTW*u9ԥƎ&P∍|)m;ո̋ym\z<R3*ٻ\ܦ{$ەߓ eez5LNPqڲo4kZ-1 kQy߸ƍ\Zʙj')`pv(i=F|NdR׏sM_M.%R+Ӳi7wX[~eHVfqzU F ]zK;A;|KJ(#~.vnBwԯٯ"-j~_/R @ C/XL܆sJWk5H5cC:i?{Omϗ<{ƾOUDo]?9# S*(ly+u=({;ͼ?BFvɽK_h˦EΏL ;t_aè>W)٫.Dܗ̉Hgi,hO::y49?^sϴGDD=-e?bvx4Wπ~O+U*{%~?tGLJ6~оMPzGz5=T+=:%e?k>;7cϪukIj_ȤnH C=[seK5Fu&mIl"LKL#"ONIo>}ۏJZ*22:Vc)5}Įcx΁f 6 QJc)7m;%/흦,sQBp_çssaUN&n?$ Ct,)x6{mFe=rޕz5ETR]>R\(IJorȋq~mTfcK U;:R'-8+;q77[F,&qtdQjJR\v[WMYqY;NlN٣3OiБ_DyWak:Z9b[Gf?Orf){q%WIs.}wN[%#+jWݳN?z='4G!L7a2>[IJRSs|Q߱C7FgUqƔ\`h.j̟V+Zȹ3V7vz$i JnC-yE[Ʀn>;uoe©*Q~)A)q.48x{7̿@eT2̮X[xc5')*{T[:;~(7P)JT)F!0eQTH-#-Kz:9mF4U&([-&~51h5s[וJԢ F.1bJVvbl^PhV{MV65Q3&T ҍ-KH&ω\\D󙧴~}AiivI3 xuMRR,[]Vꏲ IvbEqq;Dڻ&++Zk;=<ioKeJ?ҍٍ=| 2; ? DAأ]څ5+ wz^b!O|YG~" 1Fy./3:9CF3:ԗ3N-80aGX8FѤPEݲ?h4@a"-lC D ]gS%@gOl@N^uh~혾'F*.è3:D p IQ=Ud}z-wskwzeKj>M嗲K}M=gMM~I}ȳZ;{ۨER_|7z9w)*eǷlV]%:Z5NSh_1ٗ]&vm[TQ$u,q$]FͣJ%whq$D-$٨B $Iq'FyY)pд(ƕ9 e]-\OضpԥV+m*symն-gΥp;|egkT@A@wj~|'M "g|+B% ײR/uk¯ ?[?7KFnߩ2߀.G!~'e]dQz"6hK3Cߏ<tܟ臰'E?_2^ρoGѨb? dRLC@-O}K  '|X9?IMk a荏aK,ȲnTY7Dd8ۉRTsy(Ijq<]%%R W}%ᄪͦN/u+i}=cܞr*g?POƾv7}|`{^[K!U9~5ñf_iX'\=l_4WHzǹ=*U~~5m/zs\-AEV:]a ^xB=) 2O2Ls{*|0NxN1e.6;K3lWZI ' J QoUxJf; (55V7FM>V'9}#}]b"RN[qOj+HGrlWQؖ[47CỶPxTiХ*ˑfC}.j%!i3%CClڥ9)BX4{[^(Vj'R.2i4VaK:FtΏv[O¢"LfšjE$%oyqndckuu#N5mҧm{+ gtM凚IPNVUJ2Ap[?@NRUqjHE2 -\+rM*#=G@]e=1GglRڽ;hv[JokËڻVf׻n;'_|;ؾ0z?Eym/;ܞr*g?POƾv7}|`{^[K!U9~5ñf_iX'\=l_4WHzǹ=*U~~Ӽ}q]ռeN:YfnƑ.!R1D#%yѼ8 p*84A^\nbܗ->;oL}SdyN=>&g+U٧I(}կW[F#J@+UP΋M8-ĢR[D#ݿy-C 6)J1m++q3*xD)Vnɻ"3- fԜ0(28gYwn\BHˌ(GuELGfu5z}`'ի:UcJ{/*kv՞zн]fك4qU:]6gU҂{n_7kmdWNǾiȦ,Ȅ&PN[sυŞcffgΦ4"q[+Q^ѕ);U)2$BQφהnWU&c̟55Q?<+N6K=f 2M\s 6ifkJ}ʥF^*)ueRWDQ' _djf*Nt6/ [ |nb!`a} "5 -Ţ[ƭ▽؋j>#ܥ)JEkQs+[ƦAa)0 BnFw{n&t; ]vKOu/)nrD䒿E Ԕܥ.s TR0qn"i>mF=uVҚ~ҫrӄ7kƟ} 6=MJIVs+xeur]ILhFja5PyT(2FF~泴Jzx:>-(5FMI4 |yΪ`18b(&)4sDkcw 崾OJ_z'_|;ؾ0=h-rzUȪC?Eym/{ҮEW/u+i}=cܞr*g?POƾv7}|`{^[K!U9AL%<%fJ+\ƍ茷qT)JIffDD\cI^hm\氆.WI*mJVI_{fmZ:ʧ<%UtJn۶䏝v(iu9KGxqg?ٲU"-;!wu:G_DkmPb% ׭__4̯Ht̯οD17"o&'}Jm""֧9- t:n_<4e|]fWTV?9O4?6'ݖ{CǽO|kPdOfC~_r;nO e?OKBǜ7S҉gC$f]}n<-f=bW@F.$j#2F[ edfa rxҔc6 ٵ903PH:M2OTtW}l_;Eym/釹=*U~~蟍}nbYC=W"sDkcw崾OJ_z'_|;ؾ0=h-rzUȪF.Dמe \ќuJPYfdDEb;h'U:xRՒJ[mӕIdL62z0ch69$܉-n;z>|oȯQJTZ#F-]8W{M74i{3\4EVu]䶟wC7~m53*̧RtU%y(W㕬ׇy\cJZ1kZe5(TOEG'P˜Odvicu=֌ pQm~"ޓ߻yOϕx-sMZeN\җ=ͫ= v'G٦kjmFfVLP4tI)"i Qd[G{?cg!U':U6SN_&*{#2mFU[Qe~rۓ6_օE\_4jNKhy(+;y{$.e.t$仚qvW_gxєiJm'cBx+NJi|̣֞bzӼѼ-SEӜmFrjM=GqJ5s=be[\uW)1>ueQKyaaa\$𨷚TeR@t򌪬գSrٵ6 {2{J+56{5^i=L7TavQ9T5wE7t4N־%fcX7yۗ}qM5*8ϩFۜ*N"Yw|jIr\.UOر4(ӋUR#lɽgຕۭ:[;fpݗ ^I)R{n;su᳍^_r}l_'u+i}=dOJ_z'_|;ؾ0=h-rzUȪC?Eym/{ҮEW/u+i}=cܞr*g?POƾv7}|`{^[K!U9~5ñf_iX'\x$k?c~:Y݉l!*R=)^?'?Q{1  2&Oewij&w".ɭ]ݥV|+{<A3ϬnfQqx=pr1aviǹ ;b4'Fލ$ڀ.A^s3Ykg/8Z!ug>/g;h˔}tzzʿtQ峳O@ sT/,k-OgFpm rڶ=u$֥(u6.gWIvSKB(ǖV٭djoyu#I0(%%9D #\*zBƭHS@CuW5C|V>夕ňwԲo5 [PĵtcIgj3ɐq1VȨ''֓분snWѸɸg®&]y5rt OKO\C*k3Rp.c3v;']ins5SjL!ب-&JބA#wXmKZdt[JاK[R4Q6 zԣ3Q}l-j((.\񩿁s4Cr8@;6Z#VH g)uk޴~OILEwggv> Ck'*e:Il} _(XgI;yLh{XO5OGkZ4s*W-{u:Pzuj!#ާ4:&:hq>ڔK֬wU:MPSb6D51;VZkarhү&F;Vmn3k/NA3Vij"9J׋u%IҖ)AqV#-޽ej!K>SKzuY}Y~KO/J[.jU~>z^'ŘU1xxӍNiAƋq]ͭK$&,h[nȵXt:LSQ+O-#3DD\c2܇Y MSJH+1Ri%}=Rfَ{^ rn۷d,it+iquT)bƍo+qj..FjV~tSGF6iJ6q%n'0զ+c*IQTeޞYup.m*jeK^ȶ7lƔBiTnHoyr?UQ֓&}iab߳:t%}Mmm:o6y\LT1컶Vb$k@4q g+~ ڎQO}c?]sC:@4q g+ݨ~[Tth6WQߪ)Ϭ?wǼ%lvTSX~oSSe2ĴKl|GdTtGn]]"Cl)Ȕi#2#"3"> 'MuOeܾO0a'l)ͩI)ktZ^ɽ5̢V'Nۄ5 +nkcC]zHԺq.zWQґ }ix˔'JDF{uZ%* qqcT%%~j&ܮI ,tIWxiRb{#57nf췜^8W9N[ u3]5yp(RuK&R#4oM͉_螹Q\at.jJpM9(ƒN27:M-u56,-8uW'&mSV:Oъuum[=wFГxdN4wKSz.inS*Jۓ9ZύJ+m^ҊlikXy:Ќt)Tͻju#{'=kOÝ. ~E4;|jU(gSZpx\ad 2/cNkRXlEjA?SKe +ۧ6wS)6i~^BYҍcv桇HU^enfdy9 8nw|?]sC:@4q g+ݨ~[TZe2EBR ĦRP>:ZeP[!%)""""> aF)$K$!^/ʵiԛmɻm}p[\i_ Dr?2 $E_o8*A.Nhzaĝ>ezFe~u%v}7wc!;WlI?/ΩhK!&oCr9k+5oiQ{=^S?T?ٽt+:wܞ6~pW 9}=e~n`{YH2tՂ3v(WЯJ#!J}BmE6M-jYbwgW 1Gb.ۚyc֞ M0X|:Ci;;&?KGwp'ݨ:GNhuGH=,ex<zꎐ {Y7j;E>y9 8nw|?]sCaEJvemZ=mV3 ؆u;2ޕ$0ѵ-OdzL+RVpse65 YYVT0^ͥTi>M i=kf^[&7'S跋sR`$%}I讯7`̳XJQj+jn)K;m8enYJ8 ӕ--Vw{|Z7c=7iJ,Mt_7 8nutΩNq,yEc})XbiԒIv׾m 2ҭli0J 5Iqv8-<:8#icVdn+ڵImrj'5H} ȷ\|8jKW,\NGJnTg$՚[ޙ^:1MRbjSU`i^i7-9Gky~߱t֩ \tu2upFO6[>b/!sмՔxl$a:ju}ְ7P.')h«7m*I[u)?ݽhL7K1 rݕEUs|}MT٫.fByΡu!,._f9l***S{WvR*[Kuj覸s.̧KMقٲ*rv[|~j@4q g+ nw|9 8nw|?]sC:@4q g+ݨ~[TM 薇MXa\HS"RQ~#׵_cgWN]j Uٵ-n߃gD+g}{043kBŕy S\êq&|\d3I-{"ts+?1MaQ78ݮ=Z{(5YG;ƼHYnޣFrQ}T'd岕 i%æ+K-+'JJK ("%e22CRRʉVcAnܳ">x2>iJLHq$Uj)(+o )4v+Q8ܯF5؈/JV\ĝ͗PGҪ=.  rҤ[rJdi :ҏ#70k鯰Z94V_' ʤb_Ѐjٙ<¥:)QH/J4%N11ч:v>t^Eo(~2YijSF-yk`i=`qѽ Z?*/޲}8ZoKJRkrW1 ZF_NJS2#ܤ8TF]cU`1^2x|M7NRM5ƚ{;o NJiJ2N2O4nNϼ5DZ[kZ,\8l\Le<pI%y"17/gQc5%Q;JM5nf@:hb08k':q[Owp}ۗ/H=,exݨ<#ާ4:Gwp~ ڎQO}aGNhuGH=,ex<zꎐ {Y7j;E>y9 8nw|?]sC:@4q g+ݨ~[Tth6WQߪ)Ϭ?wVmضд(-fނj-1mOX^ə33j333331.d6U],BQb_vۻwl34 Ү7UկUJRwm\IY+$r1]څ5+ wz^b!O|YG~" 1Fy./3:9CF3:ԗ3N-80aGX8FѤPEݲ?h4@a"-lC D ]gS%@gOl@N^uh~՝#&CVi4USE7E6{˟w8}]Ym^cl=ڽud{{cj` 鴚8NbrP'kfaTI *3ݼ˟<6ups2ig|*y(|^` ߭:nujd˦rR#OCVlb=#|d7uk\"GG5Lpy˟wX7]o/iLZkeSMQgqQ#>>-F]~]Ym^cl=ڽud{{cj` c3y;ۙ~IRU(He%wx Ԛ 5i1نƠեZ)qĶkuMTI3%jn/[uI֮h{`oZ^v%{ l=ɑ8Rz鴣Sbu')ebfzcrkXIK YJ-䤶lj"= ؒ#y%J*f^˪g~-$P\ޡ-#2߽@OM:Y._p&:MjQoSI'*5oH=uW} IA2r;vBY! q&5]c.`9XξjfPz}˅>J48V$(>- ud{{cj`Ց?#ݍ WVGW>v6|1}]Ym^cl;j4-PDR"S˿5[$I#m+tEwj~|'M "g|+B% ղhYS>yIbAէzt6QQEݟ=H/³񬿋/BCf_-x{hΏ3=߿_3}5JC8'7_g_'Vw%/|c$'3 a99U wʛ;ݕweEwפV!J򻥱Ysnsy9Pi> CտRj*8 -:]1d"`pttc(I|rj'RοYfL*Jܸg&TfOip$__DO(ۈIx^kScUedu( I{ߧM)qmQM6XڦE!(3ticO|[n<{FXoTED5yWSD[6w,?Ao"Ɣߠ<<* mx|#{:mEiި1Ʉq}ӗ-J'([o`̴(7WkJFxHyceU=Jcĭo}4̳Z~5UWkVw9nu}I}>@sed>n|'](~ͼA:vw9PF&]Dݏ_ͳ_3$DZ_:A.P^ 熕jʑj')`u?ҿd֞Z`x?\?`{A?LLGwޞ6~pW 9}=e~n`{YHK|8}ch=&W3A@O~_r$Kn俵PdH?RC<~He0tBg;ɧ?+}=# o7S);EC>½s|$S:|Di_S+>vgԗUijևr?KѬYYԭ(Ξ,)YٿcnWU}S^ORE#v@hӗ%ЮHm Г3ܦN_7soqWʴu%m-W,xླྀ~#FIֽYFr-7Q^ÔԣJ)l6sp=ah`x=0SMwx~sy4SjDv[rܯľc' @ kfWwi~>32 C8*EA/b\^xfts/fu5/Eg@Zqa;qG I6d~iW?6;7VDZ AYϮKYcNRL[Ѝ*I#.E B'>5$Qq*D49@_ i,~+1-F)>d:s};pv@SDvõ/*::'~yP?KʀK i{fؖmV'd8NUPH2qSM1o %02KFMm;**L37ӹO:~_Vi9!6O[y0M6B9Kp{ϜϮEas \IFf&MSUeQRi\#Yq^FҮ>(imcԦl(67Z^T>߇j^Tu8tOn;Râx;wڗNۿԼ4uCfhWd@f̑ߥ)qtwU˫*>qTlȸҵTFJޗddeDe@if>S%W~<|s\ ii0(A 6e6f[۷e  Uj &TZIHτ̈ȏxu8tOn;Râx;wڗNۿԼpv@SDvõ/*::'~yP?KʀFz,tSw<~f2y}fګKql/Gv 9xq#Vo.\񩿁s4Cr8@:Vsfv)}y,+/i.&N)}ir( "Ϟ}Yx_I!Noi@CSrqYvmLjʚiI2mf_:Qgn{a_}s= Ugt]\ Ufułj6d?*f&iKOKD [Fn#b7k(gSؕ 9FPڶԝ4pM39WTqXg>mپwkqVPE4pᅩߕ[:gCU({c"^8? -Ne0 u={/~Uo~:P_GUwJȽ旎 S*?s}ld^Kᅩߕ[T>Q]҇2/yʭ_\*k)oZwV]2.SOQ3'r+qF̝YᲚB\E\bmOktokq+lSNoJiaܖܣ7)(~vwW::FWq哳Do[^^b/eJW[1g,Vcr}JRճG `TWsNrWH G5Q[y${BG纼Jϲ*"~?_ˏxFoG>m#bŶ}E]vWUu?h6TWm'U[f٨RiޔݼMc},e(^ vw^Z46!:0^vZ;V}0[Ҳwi?;JuQ[` :Im3yNS徵uDɚ²##4o_6ekw3XlgR; ɸfuҵ[߱;3Neo =J)t${rEp\RSt;:ι*7#A@gRJI:)>3#YoҌ25pڍ u=lñҎ՛MEn~V7Jypl:GKĤ+xm{_y薱AQF]~7x཯m9[k^F3U| W0u'*$5xw6n<%.Jᦹ)a[q&GK2̷6úXQT3M~_fyF!UV)҄_:i|I7kWzyjuB*nYm)%NNڊvmъhTi2RLҤ'\Sii5fvمw5ʍ~MSM盄&7ꔔ$3N䤈j'gYwrՕISRrwj+ewwk+%$x\ucQJ䢬rܛnnm0vX6ZvC&u;{̿Bj/JhKZ>i 1'h'{yϙ^Ù_~EboEݮoM9N5?DEOsZ!w3K~LOqӽKZREL̈iťR8A^OY%nnN2+AJntf_Rnu^ ~kc: =;? 3W BT{;8}=UwJȽ旎?~Uo u={/~Uo~:P_GUwJȽ旎 S*?s}ld^Kᅩߕ[T>Q]҇2/yʭ_\*k(CajwV/c-'TR]):Uh[O4ZS$8D%I?RL%d0zx% -lCjMܤm+$E7f]9w Ԍu=bQSi7evݖ4nly)EDWT[f{qpvM ^jN^lMO7^K}o:Lڰaq\_"LԿKUD223)͡W"*4\} %o;:fII\2"뙑j _>(Wlt i/ bb`=]zЅ ݒor{ 615HB ]ADT+ŌMJ^II߲sEȜ[ڐ{:Ty=s,^A_^[ru%FѓۊRm֊i['cnWU}RR||Z)'W(TKQ:E6BSZ5b$Œʾ44' a3lتqJjҌd˳(C*uE-q4՚AhOH˫Y--B'I?@\륳GTeUK60-|Bk (`gB[i63uqu[EEtN\Ԛ $ޤ-*I[0A]2Xؕ1 [(A$ IJVF| nXl{F$bBJx/`4C3VMg[Fo^HhIc\5O*ѻP[/Z\ȵFm`<}U(O_A•FhR~4Є,̵uByˎk8ȷ+y-.rqjHݸ׽;jw|2ŻS*%- D: ߶m"8}ZxҮ_7jkې"UB .uJ2JP5)J$̈aH2mɪUKI^R~x[orJM5;ifuG.˩:ъ$ݒIGVgk&U"nbZcmw &֢Tj/yi$[Ik_׆m1],? |[skmx-څFQR.aY.S}pO ^юہ>m.t*6\t߁:#۬ډHq .t*"22#![F)8-4wM?Oz(bp|ftjJMI5tVi ksGe ڑ |,kBlNϟ 16[N4 Gu|F{O6beS{* {/ MnRcgR!ժfҕnǦLP|R 5:W H%&{``4GvMe{ x@E^Eq]ʝTN5z9W*n82#!<NCR٭MOf}-3Eh_ ʪʶ 8uBQ[NI4[q& _GJoF41ĺfTE6䒕ID9&2M.W UʼǙ iҏs1gIm<)tJqY-6ܚ1W̑ LAS aAE>-R<ܟTsY+H\.G1 6"*) [pvNfG !^GnјiNfywU8֎xRݨxVjI':q_cOE4+h*K(J;N>RjҔnkkz#2|YuJjۧ<|),q5ȓ5/C 8F&y| TdFW=%NL%-I1=Y^ƬGkWkZ!6ڤq&jMsOd]h'Ѧ94*l9m_c}Mk66&FBr׼#FI8gNI]yf,tfUWe iwU$djPN6)YDE/t](ߌ{+{mDb\WMT~w^̦7B%2z i!ZEysS:Fex]:iʌ-GiwMxW]]2fu<69U#Z{%)w)?nl,Q]EmUQ$! -D>4}WyfSF}2j\)۰ɽafաچtS\(Կg5[6T"l2Ÿ5 {#rr{)>>s_K>߮5>˻Vn 6irV$ѝ\-;͍TGG/֔ t(ҝf$.[mXcURۥ9R^Ȣ{.;*m6PBm\mJ}r2Hqc89FRNREzf}Z*E+taj=斒gb5!Ռy,:u6aR;*NM/ٟ< T+8N[N8Tof?h?i~c]PyVm;t6hJEk4MI#"R}[uyԩY)8Dzݛvn.}֮LTiEI-)IںV90cX6 Bgټ*{ժ@xd[CK&K\fUl?XSڧ:Hv5%Nt$&XS\M/Cq8=`!=.Ȥۊt׽w[{IqG?OJ6R*}:+Ι%Km2ٳ,qxQ)I(]܍_ PF.U&bvI|ҍiJ,RSp\QpkB>XZЅ))*VFaiGRb0ҭ~ Tً؜'*sٌs+mbXJ)bhם aNRrۼ# &)Jn]vݴ:BMJE":c6oyȔffd*R)Ies!hnpJeNshVe)JRcܤ0YC \Rqc)NЄޒI6Qri?]jqnJF2pZ7-*3R%ۗCQAtԖm:˭L(f[ZI*բN":*QSį Nd9+IһfOZMgj6n-NdN҂wƷmur^w, nYd]$-F%,Ү[s}-f~k4;6\Rt⶜e'9lɨ9-[4KZ<>Kcn;_f**NM+95/ %A] סÊUgF HBm*n-f#<H|~C(å''.caQMJ.4Oʹ2_iJS{../iMM' A|i3iKj-^M}Sl6yKab4SLԝκ"2Q{iԥ*J0e­HEATZ{mNIٴCFx&NWRR!VRi&of]څ5+ wz^b!O|YG~" 1Fy./3:9CF3:ԗ3N-80aGX8FѤPEݲ?h4@a"-lC D ]$^u{b?Uq[ޞÑ![%]~tz 6VUs˚xYi4ZA9 leRUFdd -RZt3h7}K-rbfeٙ%[ҥ@;Lc4ˮ.40u4Y4N:>K0qəʬ_ϼҩz>NK *k H`|[tυ;ԗ?9(5*v?hiVeBeS>KTqq3lY+r|;܉KIfʁ\*b&OD.L&M!sE)[tυ;ԗ>0|.u˳ٕOj.PjY$ӅvsڕjUZ!ȑiRfDzǻ` jJ)jQRfg" eM*QjqU&OKǶ@ѡV8|3B{2#l.\񩿁s4Cr8@:Q a>YŻBN%x?ucB?"߀.G!~'e]dQz"6hKq;\/;vַa)Vr $[kR$JQRFfD0A6s ª)?m+I6֎u,.*F+$M:;Y^n۸ݘof>3ܝ斒fkK^Z5lBOt-vJޠ۔u jw&-W2Sc} m](:B S`i*I.TKnE6B}Q)6T2N  fR 86i4ޚ-X\.; :NiQM4՚ii3^O8)ΉL̴ؼ4ڂ,r0wY2J"5q{maᡔfP໙nJKxD+wQu)=>N1S2x9s}xmeUviޘxϋN\%Ro}?q2|8DI#IΙ2#e~4XyFQeғM_en& [/+vQMNdڌZKF^{ãֺ?Twԇz|ꎐ^{=kMO:ԇz|ꎐ^{=kMO:ԇz|[ }yd{U- ڝ^K^}C0Pᚔٟ6BT{#5>YMJ7Kׂv3Y܂tSUw] W*mBf]9-3-m1QFIJzw#25$OM.=iUAQ۴JmAݢQ6X4k[J6*^RcR+{[i67FzШ°;E'o?L܉DS.(-I%6D_eȍil\ iW̩;=rBiF*[;=bJ?T&hэ.ȫ{(IlQ)$jW&5c"3C-&msSnyu"!R])M)EJJVi[KiOS R.e(U}Rʼ_dKSڵnƜ<tkSC[Tٴl]4Ȍmjµx29 %PJvG1-8ԥnpЦh-|i%4{KicO Rԗct(5M¤ܭV˼g4Ɖr<66&xK*;)STnR \bU`ߧUn\iޣ6l)nϭxM&"=0l>BZؙ3Z6[ aeRil(dfif5jTFt%44Bﲯ)]^M66baSO omG 0,*9I.?qa0%%kɨ||> ʭ*_o1ծF`,< ZZ3-岵% '.FDzK>eK J7S.n)ҫSf[=]FՊZ\eCnctJM9Z{{QiKrJy/ڀa`q>qM <%U.(M>}p&jkvrzlu 8[д(dc̳3󜾞/ QTQ)FQwROyeyIbuFJ-qr/ϏaKtƽ%.M2㭓^gw)IJzKXnRM\os=]|&eyaӨbJV~-^Sj E:63$(ˍąnGCȌW]\Lrm^..={%!¯ma>Hv=cxCzGꚟu?RO:Cyw5??RO|ux$ w-"X}^ǝtMNxu>ٛL8vX\iűmW 8L.D!_J]}Ē"?dzmhpMgzzۓsO”~y)1 ފjj=6 )ny!9V|Ϫ@ -3TQͶ\gPkigTrZ. fuu#֫Kmũ:rt =NPqnМ :PBMF*u{Rjjm6 Yxi%jUQt%SΆw5|26CJ2i+&Хmh߼ +9%\.*NR^jS*קJjt&7Fx*`3|s8(v:TdEI ZO}yFVL JUnr6c%fߪʛD(+|.XlUL<刌ͮqpcj=˜'qBզ'C6,Nz]*E;Ri[nWt5~<ǜ%Qw\+Vi>L>qdÉr"K<4Dih՝,OeVJՔܸԝuz?x=(Kԧ*Tk鸷N1ۋF&RuQ*=vwƋɋ~9xkg}l[ڵsř/a,jyq~-u/ׂ-^mv[_G~KЛHÇ'ҵмgW%;f<$|^lmo;%;;^ 4{ovkdzFS?f?z |?etM;qJ*m.r ^{};Zboc+=ts.pn' Km{lSv=wk[<mW6߳}{ bE52$Gq[+qTh$T=Ȕ^>KChaqO7FX'[Sm/}*EZrliQPm>&ix?jɪcK`2%w=gi+N-EXJ~8P(xi&X 6&=_$I]jtźNKAh\ig_wBѭSO|SUf$)-ĒEnr# kfWwi~>32 C8*EA/b\^xfts/fu5/Eg@Zqa;qG I6d~iW?6;7VDZ A$u/=p"W($d` *EiݗqRN.pQe5Z\F]e%Df%DiRL̀4[sP6aNT:&JE/m.nK-r4망M=iR :J&iFVd]m&)j20}FmhV0q)Tz5K)nE"Rm?E;J' Xnێ.j'Rgd$D^br^k<UͧVhlf+ rmx |23N̿lOwebyW6Cvl' -ĸHL8m둱5FkͰ)3fxuKJIC)RR#߹&~ҍEӻKҵ_5W^3RPrKr~+0ͷn..c u}tV1i"ݿ|Y+t{(JOtںOsz/u! 춷7~L깣К߭iGbeدUoQZmfB"7ZmqT3>˻-Kgmpui 붻;n'+&7h{$ MSpMYIBռe&}b1%Opm^3ow*\Mݷ_zkwwE͕ǒߐiIv}3Ϧ! ǑTMPKky$33. y(Tުv[5jUWw >-{On:Nֵ^z;-3|]s1T׆JljV[U;KRSg/UMI-"MD{ˇr&.To³XfNKr^v]4{DS.J5c:]ZyWU6?8)FU{}՜َ;x\eNoޫ& %3Z+_UJ*Zo:6кT%Cܮ6ˊS~spWqsj5Jcx7Gk޹l{V鍍)=苄SmMT$i afȶY9Lup1:-/j)ꋩ5V%j߻=4ԥ]hwjT[Ӥ^WOxs yݓv_uHvh'C 6ZH2q5jҦvI1%F 48j1YFRQRdoF$AUc#BIrm_fnɫ9 ]wSM.G :M['dgk+NьM?Af^S˖mb[dVlĠɤÚWjtWȕ%LʊQ> Ph2;."RMN{%%[fQm5'ңYTɴ6q[[/~8oy4{dFUٴZkū׭AVu0؃Te: %jY'Ըk"+z !UTCTS⊄%RdKsjgJKSKi+oy6ڲOky@m.IG}jR#J2i1$z5)j4qi8V½ﶖ{8IQm-j2%lZtqrQ2M/} +Z5(5wBVmY _6_(U<v $aOTJ\[,Jy%9㆔z."E84^nY9(Emvo*ԃQPR5նK{6 w(XS)T촔kwj~|'M "g|+B%?VM6Fd FE}JO-4h+*ТIw6/@b"@.G!~'e]dQz"6hK@]s`evHa@9fg&>tq-nIVM)DF)~r't鮛OC^YGeTpq[SiQIԬrح?AFaBi_iUujFRj0ME6wm)|(ul~NڎuC å7Sw;O QN]a~ޟXt1Nxw[?aS8i/Of?c>'*uG :uz}aқ;⃁l~NT?oO:Su?'sPp;4Jn_3wu:P>MkcA?S~§TpӪX_)|(8|OTuC å7Sw;O QN]a~ޟXt1Nxw[?aS8i/Of?c>'*uG :uz}cSEB Zu2L܊uFPemD8T2ڦ  rT*A*5SM;Ozk1iѭ'NiQu4Vi+4Iq[(y/3Zb}Z#ܛi(Rd[yNs65w4aL:sN2jWvi6Sbv4奔]Tu\%/F%:{pMW)T배[ ~9pٓi0l"YHIdy$b>*UiRU'_UIJ=aBc^U\{I; F Ҕx‡f;-է:[騷S•;=]b|?*r=ڊzĝQԢzJK',ִ)H|ƓRFC@hTj[1UJ#8B1_7R[PX y+S{=SlMϱ5#(SKbJ2z,cVX*RZ0dۏ94D]\\#"e1aTӬ65Paoxӝ\,/4k-6W˴G184J(na7_鬭;=ora3VtFLVlR䔵LJ%q/\fIS|{RpaT*,hpu]8KƋob;,`Ȣk1=' ӓg8ʋSԶoe)(ݭ~NbխksQ4[.\l8dyMkcA?S~§TpӪX_)|(8|OTuC å7Sw;O QN]a~ޟXt1Nxw[?aS8i/Of?c>'*uG :uz}aқ;⃁l~NT?oO:Su?'sPp;4Jn_3wu:P>W6baj9@pĪ Eo =>KGIJ[HGfDdf}(`â\1֥8J_RI{Q[L}XK^rmantﶢ߽ݳ'fVw wl: s7L uyk!M!ħ%IJA>U{EjZ9^qJRu_j۩SbYQaΘyOCV1Qk)TqFp؅l{1wkWee1Nr%B)kRg~#Rȏq(FGPh|s}$SUIv'J5*Rӏs9IyK q8XaiM׋K/bV +iũqOj=ȗ#"E]]2kÓ@)&o:D5$5+JQFO8**K*RIZ;V$(rSTۃQR9eҜ]HaN7[i$ԜS^uK#.d-+xQi4"b䕡$ٹKRԔդկϜcY,LlJ)tҎr_ J%ݷ$_e:o0R -lNR'jq[*)cI-+n}RnzVeԫ4m}di2ޕ%>}dC?Y@ӭ{>-ڌ$Bc(IE*)ZC<.yO ,թqe&t!NA[diqsHm&{e3YVcV,;RN 4=3W۠;CWOFje:0ӌѕ]9NK4rsTڪ R9ۗ [*TZ##sfnp̈I43\ Joی#ض$q9Oq{3]o4r|.Ө1nN%4V+t^JOI9'jXS¹tj-3HLhN+2Mh%RO;l5(=}fqMjfƼ١ Og %%oj|ݦwpueSa^N %YR-;v$AE0Ԏ 䶄7dg01V3gŮNppջե}I&%> bIKj*.VNe]ρ7{l|MN(7]tWyKN߹j݉NthC6CRIq'~2W8ײ ibq8ؙQbUeElBSqn;u)%.Wqs+SBuU8JOjri9Fik5m/-:eMfAО=t&O#2<DdRT)*%%FGϴ Ѧ9SJ[tA8J7ԢJ2(2jQi,=dV8I^㌖mɦi(g8F]\.뚩K f0qi%)J2m{j2--ujug[WgnG(_b6a;Rj0U)4&w%<-:0ܕ:{[;Rrns&WݒlcnurY$h nUf.E椰.$fA\*O'O1̽WqP8wpn*QN^˔d%+6y>U2VOrةhڌΜڲRْKi;+|ǴuV5*%y>S+y3j%LȈDEЩR)FKne')nJW)Iۓ|l[J#W ?مi&{{g V+4e:M<#"n622>M Zgƕ(aؘъQQpJ++c mV\V6NpX+8jrԱM54շZیܒJSJIlHݑwg>.Bٕ_m;ꏽL̯B',?JhK#In#Y̅e]EdE:碿 =βkIlZjZU%$غuQlՋRLԡ/fI;xl\akBd;EJ2V_(3S)S71qx;[~vᲝmVܔL}ԓ 9.uJJ8Q٣*ZP6.]Pj`r)jʒQxFT%ǎ&\ss}6ZY_=ikjBLz깙6jSMIV2v+IbJiuQ<7ByG7)-*6iK4),uQ__hZ\I:Q]z2ۨ4ooBy46ё2UlZ Fnio+]ݶw{5sf5aA8m4zw.XqkjLgn()q$̌3!kF: I])W n{?dO*J-?o^ϕhz-zU:7+HSܦC5MNEG  *S (/S#.xz'97w:U' +$3ZT䳌U%Ix6Wlr =~x|٧# q> M?j:TଥN~UU%4vS:L/"LP*:Щ71nBXSiURR߁8_f zVb-DldeirJH1;&̏q!xztEuIx)wnWٕb)+# ؚ[tjSIjua*Q\{JSTdrL>5}8KfgSwHbt:ϙ(Ta#}t[;աV~yJ~ 5-iEoh-:?REJOrgQqj{(7:F:ƷqKL<2(Җ9ی2*5Qp; sLJRԅ*EGdz+{oQojc%QNAF\ =f{Mo%EZ\ >/ieؚ (Ч}t*'oƫbFTЩRm}.5SfvXzJ\ڐɱ2"u4ˁ )M&4yQomwn8QO ƭGΥ]=Eᄣ.&TN'մ# $PEݟ=H/³񬿋/BCf_-x"N}bN'}owQ"-Z=yT- tuCg /$o9+4/s+(M! RfgH|uKD ] kfWwi~>32 C8*EA/b\^xfts/fu5/Eg@Zqa;qG I6d~iW?6;7VDZ AiFWzEnҮ[nm'Tp1O$4.: U̇P4rږ2ܮ~Q͈绋zߺ![F^ޒOeqSĸx@ug(:eS!Xmo)lGQn͸(e)e+ݭlx.kwaSxޕҲ|]kzkӝW<. ^Z߫Vx.\{8k3Ffc:Tf %[:*U{V\r}iX%Drڱ,Jʷ-+r=6pYRo=żU9)(T{QJ=&jvݼmT5&unOܹOx)?Srv=ĘҜTsF\{Mbkv^-8q]44ފRu%;՞=i#K~ߴ,EMmV2ęn2ƍ z.aʣu +&n~;n[e8MN[{}gq6+\? %gpٰ檕h4ڹ ܓ{> 9#x\m>6oST{.ų6Żq`ʎ4W6V U*rܑQTq-)qFqG5-jQ:TP%%KsRYMݾ60Ѩ{vNm H5 "Ċ re%I%$DETZ{SmQN($o{{-AŸָׅlKrqytPm3xĮ^KmoW9(8G=On\qίNKsU)t:m"NWԣ).#eEHqi22221¥*u4=:u*R]ΰl\wK]vErJrg[TfJMG´ԜT[m./(t7$7IXȴɴo;2Ii7n%OI%(tE6+~jTS׏9 6NSiT]:2iRvAnJm$IJHVRiMݿ QN(lYx!CN~V7}--w;UcZG1-y>.q‡X8Sii̐.\񩿁s4Cr8@(UVܔS_5"A7׏Ҋu#/ F0!(Ƹzy}b?\ 'V{ӑ@jo@v|wm# Ʋ.Ow}HB%$wN}|%=|~\RzoYRj5E(fQ%(/d̷o2t?tw+UX9[blԥ6wkuã>[f/ -+65)-r~8ooJv]rgw+#>K~z; v>mjmZW F: 쪖w}F~򷾷2ۍ(J%$IQo%$< ˋ!L1&;Ax/ˆ#ޓ4- |G25sN/s>.lM/w{9~"կٷ^Bш @'^=}~0@bNN2#A2:߀]蛻r+kZTB%))-2Io"ޣ>@Ē2IFd绯 ٙseڞ/c*KFE^U֙vD2(JK23pKqN5m-exXIRnq^0r{VnV-\y.ΰٌq;UcJQ$:ng&%z\Xˊ܉16G% $)xTW Ϲ&}b0[ݏ{-{KgEݨ][2K'}QV"dŔyR- xgXܢ{3|=$c3Iz,:2ӏs?dwh?z8OI]#Jݑ Qg"0^pB%>8FI3"R̓uRLDdfܢ#~qۺ.ص Yf($Ķ-йm-II""d[[jԡGjrwI%߁+ݽI>" pUFR^?\fc=R ]kGw>o&@Q1DHDFBUBeJJ$2Z0ŬDB1ٔRoikb+Kgq{ҋ񥲼{I;n+f\Ya1z Yx\4%dhVܢ>qZq{ݽ_5]ڹ뽳߻- S>iz5Y ~q-xMq&ޮFDEFff|\|/0WR } ݗdeFFGut{[H:}0\ 3Vazr7Fwggv> MHםOu\_ lpRbIRPE'M>('*RVfrٵT}I-%ܫ.тSۋ#%^ѼX"E@}&]E4")2 B!hҦDCUPd#zu5y%R=mYmFUfMڥ)*i-jPuvSik#N-錯J-ёk֬&4BD?;"b ^3T~RT_s8e'VU(FPxvt)[3دkmJ]>(ó{N`&X$Ҵ\NcTi_QVN8.dUɩVtv}f۱FEJ܏OE9$iqn,9f|&M(b)"F9mNZکҎ•8Fkb5VYvq]w؟g:ӫ5'n*uv:$)n !iQ3?^uTWӅ^rLf Jf۱7gZjC] K[2L 6MR%jlE)fcj;o9Em(]⚦r)w7M~ -Hk|g:hQbءٯ\i2PJJ_Z [JȍFF[pմ9z|=\St톇fw6F_BvXPjxe8.£=m+{u0NuXړ+I+6sKxYSqa7qLӸsoj buvjR67/|M]nL82aq|E *UcRkfbܣ$]ِ!k.,Q1vHeeR躱S UPN0-8\FX"Q8ū ɨ9%+I'i;-FufuBV&䝣$=)fNe XstLs|q_ZWմ,4|u+ja2tuN8aB8 322,u[-ӵJv#仪لTؽGiJvQ]w%OW<(O؉lU*TI-.MY+8BOe9^.Aș kͶJHwmUq$hm, Q: UZV4 *)4}ʜ:Ob$[NsRnpN.̣RQځ4EOfV엱JAz~:Zcoi:l(ICi܅oqn#O 沩0ssaMvmmZRN;l%c;TiN%+bX7Q\ZqvVfӋr\i_ Dr?2 $E_o8*A.Nhzaĝ>ezFe~u%v}7wc!;WlI?/ΩhKq8v:.p3-R0JR᧿2[%"pizR#>㇩  t}Otׁ=׍NRYpeUS_RvrޛWٱ$h7-J+y*cEyƙ {j=TCd6diF?Վj5Rkf:ITMb!:aNkF*.XxJnPd6*;vh8BU'98uKҸ+v<=rߏ㘫u FwD!'Wn^u[f& ?!K&FT_ Ni_sٞ)m;%M'jrPJN+jNn' OGEhQŵVFjjI8'&fiLam' ut^\'uӿsKO}I+BlOْa>*øv3TSdjI{bTɴtKK$%b:\M"0ڔ蓞m-Tc&v9-Qdw팹bVR/tM ^m[HYo`{'u6Qێ8FJS{g[mcEGPN-i9S'yb>C=&G8F/)G,48՜nWvV;7Ck{kǶ={ó۾~i+Y6D6+z5 o*0.?.צlةLJ!.A?;GcxoUS[(Fmr6`>PwM[yLCS{$,%=%a쩽n1fYV~P1D >+~ԯfIJIM_b!KLdMթӒP}IՄIkՔmN06 |v爄%J. sJٌ)ҩ=Q54B<뷋q#7&f&jne%bse:Η6eZN6j91vצÎXjsq2.xXE'}ߌ[bGf5:;kr}8 oYTj7P#lw\IjD8h~[}b`cW TQ[]&1\rj_\a)$?6myoqKsrk[=m)w6be`g*W),ܗ&̸2&>=j d$XD8RAFfKGuiS<)Yf"$[U*u&ڔ"̔)*TWϜj9úڏdҌRm9wu%Vqb)PP&ewv[|NS=+ЬD:(ҤZ!(>EgG;zHg_WYt e3~pQz4jG{#h9Í{؄rJ;\[qټ(#V07˳X$W62_f?W5N6itLjD{eQ)'5k[@C.j5 _sJ.1V_ߛS.a'YǺrqb5t6wޚf"ҝ{1T*zWpD Y).9 &t:PE>m8dsy=-d8zk ,;WBWrd+MJNsR97biia(O%8lΖˌJgݸJ;4ӥ /bҹl)9VUb܇"WԹ()ͦP[˨ z҉(r+)m ^S70\DkVۇceJRnMҕ^_8iG2N.;_`qSu#^)nQq%(2[?0En)qfU4JMA9qF% QHA$x~II,3c{Ȧq𤣵}Ķ]գR[ĩ*.2R6(}׽V2Aܸ**͡uv粲pfgEoT)nYyDw-QՍ VU5׌f{$,9QRq[3*`*WNWezjobwJi[eڱ4>~Grd>nʼnUvJb1@D(MN`PT^# E%Q: UZV4 *)4}ʜ:Ob$[NsRnpN.̣RQځ4EOfV엱JAz~:Zcoi:l(ICi܅oqn#O 沩0ssaMvmmZRN;l%c;TiN%+bX7Q\ZqvVfӋrvzlixϚ^B!w¹_| D r^ݿ[~oT.p_S(b6Ja `"ባ}3i+ Kӑ97p>{;H_gYY'^A;;Z!E͖ItNg#/ТDZ{6ҨZ1ևϯ_ I sWh:_W_QAwkwv?B6|kSꖈAwjd̮+oT}gezY=eqTD ^73w(|8_9IjR^0΁; wYc|1ގ#oFm@vүwd~mwo9 - t"]ݞm O9KѨD:W+hKqw~ O]/}Wu7gO߃/ Kƶ>0L}ґ;7P>{;H_gYY'^A;;Z!E͖ItNg#/ТDZ{6ҨZ1ևϯ_ I sWh:_W_QAwkwv?B6|kSꖈAwjd̮+oT}gezY=eqTD ^73w(|8_9IjR^0΁; wYc|1ގ#oFm@vүwd~mwo9 - t"]ݞm O9KѨD:W+hKqfVdfFVKq:Y/j}W3Qj43;(~01Yz5}^w_M1# \{@f Qo=SIx)si{={inO8 N5fۍ (432”ݮJ^$G-lODWNy$3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTuKt7mSPX<\3.iuGTC}v?% uC9RTeәvݔEQ.Mo[eHnTGir"2Dc{>#ɨV)5j4\棪9iVD*2'^=}~0@bNN2#A2:߀btw]дf~]ZrRv KZ"3{})׆gN $Cة 2N[2[&Kt7mSQpSG.xu= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CT&%u%/ٙϊ*e6S=UZ' kFWC?;p]\ES9ORnӽVM]siMENS}yS^&vh'p Q}cs7r ΎwÅξ% N= Xgu73>6i&Wl)*rl殈I5%PMKV Q0\n>t%x\wnTC}v?%G:rXCTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]Q-lOC`9sì8CTR T8)#<:Ä= K]RgS83QyC1pA-,ܗn&LVߛL䔮Yo%r.=gnӽRM鶑do,U7K JR1&ɪL( S40¯՗WٺDz$;FI/s߭=щjv~@7+EU+kqW/ˬUTnQ^qN:տj?14L0hѣaII+%btCFqV2mOC> ]|m::Ep#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$11~ 8U8[vU㢮ݻ )aNW?Y ︯0yyVMi׵칑r\'RXZJVo\aևϯ_ I sWh:_W_QA)`GbR`em/5Dw$Ao5f2 β X*ҦDz{q&F8JjHs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!{{EZPZύ*RE$:̈!\I֚Y} 1:{XW9FIM4M ь-U:xh)&ixSi3hFlHs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<äF}Äm::C>Hs}bTp#!:Agዻ/8FӮ]S=$0џk.|pNuN<ǵIvNfq*NĈ3 4.֖GmEG 5L4*c&M7jϝ;hna) %g{x6jʋSx#e"¬w҈I9[WfBQM<%=c?9oۭ}>o]WuƂn:vw9PF&(>EgG;zHg_WYt e3~pQz4j1^YDf;7FO$WpzH]}=&QddH55V/xNhzaĝ>ezFe~u%3ϬnfQqx=pr1aviǹ ;b4'Fލ$ڀ iXww'+߻~.B:ćvnKf':'~o 6Me7뿹=V /ܑhNhzaĝ>ezFe~u%3ϬnfQqx=pr1aviǹ ;b4'Fލ$ڀ [MaL̛ŷ<3<$=$cs=/E?g i&dfx"┳/d7 #!XNhzaĝ>ezFe~u%3ϬnfQqx=pr1aviǹ ;b4'Fލ$ڀ MViqG({Oxfm_Hpr1y۶KYt#FzpJ狩Fec73>6iFGMCK!S=Iouo^o&{ǘj1m< rR[3=]s0[䗅DI6/qG) oRɸr#Q [on{;}|ӏ\im*ZԔ! 3Z{f8Q[nRrv\gemm+aVJBТJI1!RQ$VhFQޏ[.BVPgV0rWA˨ܹAd6i#%8Ep[ׅE8%Jp|I+Jgjr%q$h{aևϯ_ I sWh:_W_QAG) oRɸr#Q [on{;}|ӏ\G) oRɸr#Q [on{;}|ӏ\dGo%}Q6%IFۄDfn+r{qq?S_Jhxmo<0*NEV36"¨ }qTjhْK"I->Ar8_J3JQ|RWOuT%N*ix\\+|(N)9BJ@3ϬnfQqx=pr1aviǹ ;b4'Fލ$ڀ ?epqRrScQ^w>32L'#nn~1^ҤMĢ23pC1]s1zDQh4i \;k635böN4Zw^U DGkȀK%3dDE%^w.TVS5o-{[gtC ae?ŵm\i6fm8=EGg?5*Ʈ=S9:bLPv3#%lEFfbᣍmBr9%~+ʕ6ڴIJYaPRm'(E^i)sNQkNtmR,OjRu-[puviބe-ў GbTGeV ۺ'=Ԋm=S҃xX7V1qw.3sJUQ[*TT.iS\ԓ x4pT;GXXKYc7X&}^G.'C0I"2ЕIĶޘu12Mz}jvP0I(n8*T !56 …U劧-rvwu*T{Mʊx^%R~kWͧ XSu=)֝WUBd 87RqL)%fqdzw]˫6 E=Kg%+m+BXYE>%'-qm[rMvĘֲ?9gk~ɨCC܇5/5D&QD7'иlvCjK!Eg*S,œjʫq#%KZ5vU*FRJH)< n/eMޮ'"Rjϰ5[ʣTԙtgF8p'JoJYfjT~5JpjHUY5SȞ.MlfC msXT&µJn*XŒSEQQ[1tjڤo9ӌܜ(N;3 FNIN2S`^ø;Űjɺaj9SRUJܲfKV_&gIFKd:9'8Xn5ŵ.۩I );VWnȶ?e羣67|{+Ex"۵(\=V휷b[yئP*5-œ&3 ios{O8DR*"JLbk6c%ጻ(+w2VEb9JZG~ui/x_{=ˡ <[ ѡUvtA{nr20NʔiH4jc\FޣIBK|]B*7IqeIԪ nZ"ն):nJ;=vNq݆ݝhť`X/ d ʥ*=m8Q%Ijt%E9)ADn6<jGC-C',D\M:q 2ۦۻTMʕrv8ui*"^+u*tK񝇳ͽe?-;q[ڶ.u5%T+mtouotJii*4HO0㣒x|.sQcQ\[RJ1RevlY^{8cwDz_hW*]jyYY:_#j ˢ೽x"_N[ڭ%˞j M91Q!ޞoFf/uIU#VgmjVR'YZjy|SP,ULJj7k+Wi…%:1Q>̍{\X&ȗ+ ٴ)EtVPMLxElO1SpkI(󹄪Vtk:*ңR{U)Btn-SŶ|GRt' #%zJQv[Q&d(Y7ekעmHXN0nyQ6;ң-Qo2(i8TWvw޼+ƞ;#F\5UR[]{a5Q`;6E:(vCfNh9Gi)BMn8d[ԵGM|Ve+诚1s)x#)$HJ*U7oam{۹B|Oa])̚]Q}Mj#tלvCnקL:3\)xHuטkN:tj񵛔f8F1fuF'z{S5{U1j ;>R{ӧ-kYK:c':yҥ3PWu*±eUU5S`q}R"vO Z_ל"q5)FC)ٝ<;uKAFUd QVRe5ȲȲLpؕJ؄uJ:r:Jmf8u$䉷mu]"uezV*}~"4J)[TzAo%BGT̲X % Hᬪ8Vm-tkVXzp`3_of7FNwŒcnkTN؝VԚxsNx PAStuU]3}Վ(RhWrt3 i*)= QDKm鋊]q3[[/^NZ %mקeJᰒ&cBSf(ҭGg,U9mT۔7NKԓRNnTU?JYu=ۮ }\Zƴ}pn'J.7Lĸ 2#S%lBiM %Vz)S0 0ihEU×N~اXI=u?9]XzT+' K*rB@ Q}cs7r ΎwÅξ% N= Xgu73>6i&aGsəayh|?;OF#H>,Z#-y~09/_zxO78jn\5NӔި (uFSmAlI5Zģ[ZK+C^gIB6"Jw}ӺI};Ӵ[J1t[N{]Rm949MFRn~~ꆰh:^Yϱzc7$Dza:>KԉGOEg[Ƹ~ؾunom|s۞deK w>֜wmaƧʊ[ي_KQz\jioTZk:V)%nrK1&fۨH7 lT\Qu *WjnɊb۲$miMl\ )$`>\۴徤on_knܷIr\b}W0}̪BiRM)F> J۾E$;~|v!`@NaEcڠɞǩEi*a5aA>e)eR;7a_;?cŭ튷ٽ8fte[(8eTM)$Ӳh庨ҝ.(\Yg>F&l&*ٕWJRͺmUiΈn*VIä8lwRhK}9m+=(R^qy{cÜwT{T2gn4k$a\˶T22n:֚ϊin2nEQV5mD(ԆR+elS ]R⬔5MŮ=kW-F4$\eܸJ|V{I|knH}b{o|wP,ESp(R]O(嬨EK֥޿V|,ޓcqO٧9:':]*qc)Z2N#FRU;g$&dQl)lUA*| ڏ ue%;NȐ}ş:uj>ssF}F)BN"Jo~8(A5:T[*ujIά-+nFcWNjkX1^Y5wUNOǏ](ulN*9&qKm e.pgxum)TڝI^ueԓn\ehgW_u%xqi1I);}m8YXYŐr "Y1%ܦҟ62yVJ$fBV]O4jI[M5M]i 1'h'{yϙ^Ù_~Ebo[?HwtPRC2‹@oA=RTÎk9EJ9D=|RʥUvn6Ov~}[o{S˱MTPqʩ)}RIefѱyC۹nFȣQz8(hKXCiRDĎMD"#=hC1[IͤŹRI6p읒 4VJU0uheV; =Ӝ|V4NsJͩ,E.D8͙ٛ0bf}웂oKT4S[#JLW7H`rRƚR(ҥ:$%$h5%**ygkww[_&=W̗l`.Ӝ8l8Q^+wt{1K]To|QUI]ߥl]U魫B)[SےM e=e +6<{^ъ`J]-Jqm**Io_RԠaM+^RmvG$'.WzbE&dZh/z ɒX;RR 6bٓS*IJH(;sۼ6%F~1Ww(ГrmN;woRt] )whӫ?A$* N[xѣ_x[-i/KXO鬻rN8m(Ȕfܢ4 ڄԔd5$ԩ"u(L,dS{2J\⦬եJ`-dYϹm'(ֶklCii, PmzsL!oi' 3#,\m\Ejk-ZtJwhb!4n1rizrݝ^k㹦—S-cK!3s@KytAe G'$k#s>.4Xa 1RJޭT'FɥhqS'&]ʫ%Vh%{lԥ {۽.Ďg1Fy./3:9CF3:ԗ3N-80aGX8FѤP55ݨ>g Dy~0G+ga~JYozO7a(Nhzaĝ>ezFe~u%3ϬnfQqx=pr1aviǹ ;b4'Fލ$ڀ >]E  lZ!f SatW/=4wBлv~-C\'huu=k[y5jm§өS$ɐ⒆Ym-kqfIJRffDF` (LُC*gBz^UuyjG}$ޕ$ys @hb!uե61=J9TZt5&ŽM)iJ;aGo/ś =4vŽ_6A>ԽDymo)V5D[x7+]Rꘂܒ\e!/r0\.q!f?3XU*m''ļo4(9]:pr*7&V~$mQf?GxnGl(dQf?GM͐~;aGo/ś =4vŽ_6A>zhl| ;y~,飶vYGl(dQf?GM͐~;aGo/ś =4vŽ_6A>zhl| ;y~,飶vYGl(dQf?GM͐~;aGo/ś =4vŽ_6A>zhl| ;y~,飶vYGl(dQf?GM͐~;aGo/ś =4vŽ_6A>zhl| ;y~,飶vYGl(dQf?GM͐~;aGo/ś =4vŽ_6A>zhl| ;y~,飶vYGl(dQf?GM͐~;aGo/ś =4vŽ_6A>zhl| ;y~,飶vYGl(dQf?GM͐~;aGo/ś =4vŽ_6A>zhl| ;y~,飶vYGl(dQf?G'75vu ƫS(Qfi˓%EqRАI5$n:${Ԥ-էC _d>^f-LDI6rZdJ!KhH>Q6Or]J]$W6g+$3H>7FSCf4986)3Ki5䑘iz:[Ԣf'&$Fɡ|/N&I=6H}3HcE9⾝=&Qn6\j~Fjk!5 h k.bMF)XjyJYۆrd)#3yTuˍ ,Ӌ=>οnoG]B7S~~W 8@\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_; ;F39\vv|frҸ(qQ5?HJ㰣k3~aGhg =+ŽѯA@zW_bؘ[V9[:Ցmy%99Ðפ8U,qn-DDk]UEMs\THk/T'mRmg)I1.^p#JZZOr|F͡jcԽ8)vьg3)FI-x=|l=8m?TDhCF XG~ϭ|O[>~Ҡ`e%f25o =PT+Әan1N"ki! !/4T7B J :e[S1mwZQ|͎= S !Tk4܅i!I!dqa[ϑ~BPAUе8`ZԺ]5jʓպiKJ[j\Y)%$p[I]{3k[ZEb2.Zͽ8hn1!6kR[%$l֐(>-f+/j ~c_ᦪ}tMRMqmrUߚ*mrPlA[؍n*DEo׮-Utn:qUZ),(\r .9†kZ7_ŲK4- Ԫ*Z>L\HaU {>c#/`>Ԏg ?_2AvN7^@op\lqPh=Z#&CLUև.K|ȥ0{AoslHzM&ӲQp¤qIq>=6Vm/{uwcdZqd'Z&VHh&EBs+vFK<$D&9fVQJ[Tt 0I^RXJRmPI(+ 69^rmEEY$Óokwϵ5cyiM[4=b媽CQpJCCJU5NE&ʥ"j;Jqg Ɔ8ͲFן`haTE(SKR0MmR۫+9MZe'RMGl77[0Hl,T@̹#+۔T" E~v5Sf^iTjP8(9׵JqY)7(6MNkSRxcUl՛[Wi 3N㴗zͻ6ڎET i䬯vz8]VGzE* Azit-ipF$ɏxY%pRսgwO J'vܻa ;tʌn>KH1e+{& VIxm95-rf Eᤚ̬xΨڐ>m :6D5SZNa eӆ}fV3JͦI֔dK'INXuexZzۡK0Q{*=]ьv-qK0c}PQSt jxtkΥkJTq]F8X^UUlf)Z^*ڎa,,)T)km7SN<p2lX=KӉҷmy?!!-;LINǧ1\t4Lz!/TlH / gۺT_E6}J:6hՉ꽵jrۣ"T!ˌyePj"R̢#ikA[0 VG`캕=1‡PQRۋu 'e['4ӄqۋJFڔKc͈WJgTDtE>1.GKqWj4$e\Q4>2כk\<(d{@\yk=oe_)NM*B tCmM6 6C73eeٺ`.+.\ Rq}k- 7ix0qơGȺh>{OؽVSr }sL9!Ph)#8Fgɵ_s(%G y[iڕ>۠Uk9A~|h<,Flqk)n:Z5mv2JQȝ[7PuN='wp ޸k~uڕűtj巪nBSKƐҒ^m!hqJJFFFD` ]vw=@V.j"Z\u""D'>uj$-+B($Wk1USnmBcHMpbZoP[Üm&DX2ܐouQ< _Cocj~r uNT~A DO>ɛm:rfKv^>K XFۡtWc6e\ThmT"ZZk/dNvmI-FelC[QEkZI[j56( ڑۜ{?<?\PC_h7'Rֳڹ8sKn-V[+Us*He)K0U jAd$Wx^Ծuonڷ99VXnX)w;NY6T]i6lVmw5c&}&J/ u9p*b&҄+rR%ps3Qn|`PۢWׁ4ڽ%;]:ۖYե:JI*˱T(ҝISk*%5f 6Cf?Uيbe[Eԗ6e6(Qelab aTd۝=6u#6zneyJ0|8bo lKnJ*w)5x<:FYy'|)CLgȴ6#6ץP|8 A6fEb%jr);I%hjIlM / >N)RQ[ۺka9JRsMdSZ^lqP*Y4iPq=rȒLlq2YQgt{Nj?jca>rm1e9c6U 7 [ QM'\v[ض|ݓQ#[{W4|imYE֋s%j.e^<0 f :-H5$>9 kڗ=[~V|wK9*K : e.iXk&ʋ&ԓkSSTZ}0⊅wl2Dv-r.uǔQML[je:XGŪilb ۼguRXqr%iwÎaI5,4%g*{̯5dAn|ynlnebظ\vdڟ#g MTj JPt$=xǕQeWGBچ:;MGiFS7$a&uL𽵕|/bZ';9Ke7RPus!kRt}: f Up_aTQlԆ>Qd1-"N2֔>fK;xK/شloz۲p]Ӷrn141Xq-PSޓڲ0~[YWi79vU _jBtzB\)9թF\II4u 09OngKt>7߽8ƾoKw,DqΫb`gJ鶜U,5*=)RN͔ۍ5`jۛ#B9 \UD:3fCtSJ/)Dp(ygr}kdVٽ{.smJڛ>ϵჇ;qIN[I-|REε++N9 ̨QB"LZTUv%"EM5 Mj#qPhSSQM3qISvږԮJ-Cf..˰EBJ}+j{n:r0a/i*ԗXbEr%Av =UAK󹃉XIS䞓5o;\/ӣ */n)ӧSr剕:TkF)>VHF&'0hs rԩZ6B*Ӻ:(WܯKʔl+uPO026,G'J։) Kq0aCm+Д3QQkfR3Ze4-kl98mEogm8L.QS Q׌5%6҅o$KUod|O [0е?XopCs&"Х0IRnCfZ3 Ko; cN6]99JRru)ͩNFc(eZmN;FRi(aBQ\ܦۖ[<ݏx߮3lz{"eЬD\R-z:ɪH(ᴮ2{ڐY^m66vtjьmS =6䶢+}ȱq]zn7Ƌ{Ž{P pdNE~U1A֚`vwKh/gҫ|џ,uRc}.?j2EOF{? _5/>w=lwOJ;֌Ţj"U*v46"k9Q.ga;09asbmapӸm nte3O5Io5]Q1%^)\<ΙAÈnq> SGm M3vQ^w~ JvʏeY^>Lu~yeMq+qŒ8'Rv6\BMZ9KN,'#+P PMvNyEoB>YɷI) FyMpJSA%.8eݺ@ut])"#YdQ+ٵrC(XbLb`1ꬡqȓ%7)˥ڍ :(ɷ2Jco|zg-çGN%k?W|mDjUF%M9i9>(ڑۜ{?<?k?|[+DFʺ#FHw;1e!oMRȔ\~ز| pMbǼc!q#MxI.;[%O,/ AjN%S7&^l+Ru/FDD9Fi#Q?"{g4T>{WsuA4]>_> tOP<3EDfGؐσ-=SQ>빴[DͫZm_LV4OzϏO9GGD-CYǿš`rZK>/Q^m6%j2MAGsZSnu^%>sj[2Jff[7B]' ګ'8_yiI&*qS8LY' ڣZ)N&C&hK.U7Gv#spANi/E>\+ڏU<Yhm,TZd׽^@l*h(ᪧ!=/?p^ =g2;5]GA&.9R_8HĪ?> iͷd948$ҏ b8G*8;Bջ x%O+Gb8F_5>yzk.Mk}>SM T822ެ8('8D_ fgm,k5r8;V3~t8)/ 8C?YJq–HcOĒ|;?cYWx2zY ]ta{ID4խ'ԣIkOo\×a~S b>[H-4̴u=y ZƷ>XNѺ JNनIӾ2XU؄}C/F)ΑZ0#joN2p=W\y>-?uDMŚ#hhcauw{W&$΅Q>WOjAIե/moCӺ _*_$BzRV_ V{ͰkոN$Z)#|0I/OWG(׭h5m=\GŦv:~Hqft3IS3-Kio07e+|]PԔM[(|_aO0'3?Y_zϕ0L֥t/??;>3ͿVVCk7?p:?Cݎs֞~ZIi#pR|-_iuZ\\h#S,dA4]q4z2ŕZÊ$6(/zsEi=Ωt$Ǻ"|Y]NOyK3'rM1 q:!Ωc^28XfQRX{T~J?UOQ3k6`Ù?,Zٖ!1-4ND<{x~ Ə: g18+v)v1qS[ GEVҼ;•+A kcmkϨ)QRq4*xIIL*`kiN*JsjOj{7o7M.Az{#ӶxgѭQ߫_|@1Sϟt s]6 lWC^WSidM%NUSmũ[nFgVԄ- KR D`uBݹy-۫ y_'̵k_RPɍ)l˨ZB(頑M& 5m s^/5T;7R\ʃLȡaMW\ qZRuWS& dۋs{I'T'S]"CTr,2Sęip舗Ye).$Y$Sͧ+ZƱy-kh+Ҙ nr{tnM.,iכ{ZcZF@ 7iJ2Iso.a3/b*B(Is&N2jn1o=3eW\w:M.5:rMytc>נ"CosQS/Y˵9WEz9blV$c%)+6cs})z]`IS*Rܔ:Hq 棿W_\egb?nP͘ΕX^BtaIEߑTJgR WGĵɖ'㎬Jd|^j7aOcY2/Jœ R*!q9InvCM%j"qȔ82G]Ekb4k!Hm.[zz!)u* V&Ha$?֥(BR'F[pNJLL5nRdRTtzuHq 55S~r]??6#5A8U.KQ B˼Q)DSuO!%\*[n6'v5=eBӴqOuaQc`#d+K6ܩ&@<ΗDօIoVw SKs!j[^Sb2Vm_ Ԗkt )"w]^4U.,)Dݏ92ZmHT7놓m$(RO1J z֦2Mf)_eO%Q< kpϔMo}_!Ҳh£wڨoP%ytKMe1\C+Q.2#-p8Nkk\_Q5Rߙݻ|n\RcW $$$dCnSv^ +[X$0ɮTAI(vC+V̋LK*J & $,ȗK-i+$(qIJ">n#_榿fu7?_F0 S_QH\:~jkj?˟P/M~G#ys٨o.s@555`榿fu7?_F0ߛ|,kNg&ݧȗp^7HA%ȤmqKZ)FdI3 'Za[Nex'hy>Z%o겸mT*DɎzgʸPN8{ۊHVP;)ymwO ]>أW3ռB'm6(Jg 37>\f(0%ٌ;cj-VvչwVf0T5Q\&0jK&ÿE'YU^6v28n^PiLTa6_Ar8.6J@_6hc:< okXwT£\%KFa7n!A{1.qspJ@ipT%Ky%Jm+)ǏrT㎫<ÅOk>ｘUo_^nRK&Vl7"9["hBCm`Ojk*ͽw+T`ɋjX95j#+Qa'W7^mW;4Vk¶&P| -S$RikAz6PŅdTmSpkVY3CjiJ%jmiH^{Jq~5,Z/ag"I<^&GӜ2jQ$La*vY{kh=%N/TeʝT;,5S~e*vPTN*zJ^?E@IS_;G*vY{kh=%N/TeʝT]wl:>:f+UFnӝ:tJ)CQ٨Nq8.'LamBd{ǫA2]}vWS]1njc>8q xRJ3 :jeXVFƻrzV>az2cy4QrdF9̸yJR-E%I5.FzTHCi晝o:8JZHrռOFk)EGylv-b*Շ'='(aA/-4:ܩ Ci*5JqjP^Ƕ*V/oby8 ٍG[r 7θRyjGgnsיqB o Q߫_|@1Sϟt=rXrugk&ȉpYJC+edDn2뭩 I$FF[6CNex};b\K'.NBL9Gxn6{P,y݊ݩQ,'-Jtxw}@Ta qn2ƧPe\ I64pIS_;G*vY{khT};d,-sGYoR rCIRaPJʠԒm9Y)Kڑۜ{?<?\PC_h7y3 evV$Hfk|uP2RC1Sl!n4YI?`/3ـs.v@i.WU[oZȼRretbpfcc-0.2.0+git0.02884a026/examples/networking/vlan_learning/000077500000000000000000000000001305314114400233225ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/vlan_learning/CMakeLists.txt000066400000000000000000000004311305314114400260600ustar00rootroot00000000000000set(EXAMPLE_FILES README.txt simulation.py vlan_learning.c) set(EXAMPLE_PROGRAMS vlan_learning.py) install(FILES ${EXAMPLE_FILES} DESTINATION share/bcc/examples/networking/vlan_learning) install(PROGRAMS ${EXAMPLE_PROGRAMS} DESTINATION share/bcc/examples/networking/vlan_learning) bpfcc-0.2.0+git0.02884a026/examples/networking/vlan_learning/README.txt000066400000000000000000000037561305314114400250330ustar00rootroot00000000000000This example shows a unique way to use a BPF program to demux any ethernet traffic into a pool of worker veth+namespaces (or any ifindex-based destination) depending on a configurable mapping of src-mac to ifindex. As part of the ingress processing, the program will dynamically learn the source ifindex of the matched source mac. Simulate a physical network with a vlan aware switch and clients that may connect to any vlan. The program will detect the known clients and pass the traffic through to a dedicated namespace for processing. Clients may have overlapping IP spaces and the traffic will still work. | bpf program | cli0 --| | /--|-- worker0 | cli1 --| trunk | +->--->-handle_p2v(pkt)-> /---|-- worker1 | cli2 --|=======|=+ /----|-- worker2 | ... --| | +-<---<-handle_v2p(pkt)-<-----|-- ... | cliN --| | \----|-- workerM | | | ^ | phys | veth | switch | | To run the example, simply: sudo /path/to/vlan_learning/vlan_learning.py Serving HTTP on 0.0.0.0 port 80 ... Serving HTTP on 0.0.0.0 port 80 ... Serving HTTP on 0.0.0.0 port 80 ... % Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0172.16.1.100 - - [04/Nov/2015 10:54:47] "GET / HTTP/1.1" 200 - 100 574 100 574 0 0 45580 0 --:--:-- --:--:-- --:--:-- 47833 ... Press enter to exit: mac 020000000000 rx pkts = 95, rx bytes = 7022 tx pkts = 0, tx bytes = 0 mac 020000000001 rx pkts = 95, rx bytes = 7022 tx pkts = 0, tx bytes = 0 mac 020000000002 rx pkts = 97, rx bytes = 7154 tx pkts = 0, tx bytes = 0 bpfcc-0.2.0+git0.02884a026/examples/networking/vlan_learning/simulation.py000077700000000000000000000000001305314114400310242../simulation.pyustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/vlan_learning/vlan_learning.c000066400000000000000000000037641305314114400263170ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include struct ifindex_leaf_t { int out_ifindex; int vlan_tci; // populated by phys2virt and used by virt2phys int vlan_proto; // populated by phys2virt and used by virt2phys u64 tx_pkts; u64 tx_bytes; }; // redirect based on mac -> out_ifindex (auto-learning) BPF_TABLE("hash", int, struct ifindex_leaf_t, egress, 4096); // redirect based on mac -> out_ifindex (config-driven) BPF_TABLE("hash", u64, struct ifindex_leaf_t, ingress, 4096); int handle_phys2virt(struct __sk_buff *skb) { // only handle vlan packets if (!skb->vlan_present) return 1; u8 *cursor = 0; ethernet: { struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); u64 src_mac = ethernet->src; struct ifindex_leaf_t *leaf = ingress.lookup(&src_mac); if (leaf) { lock_xadd(&leaf->tx_pkts, 1); lock_xadd(&leaf->tx_bytes, skb->len); // auto-program reverse direction table int out_ifindex = leaf->out_ifindex; struct ifindex_leaf_t zleaf = {0}; struct ifindex_leaf_t *out_leaf = egress.lookup_or_init(&out_ifindex, &zleaf); // to capture potential configuration changes out_leaf->out_ifindex = skb->ifindex; out_leaf->vlan_tci = skb->vlan_tci; out_leaf->vlan_proto = skb->vlan_proto; // pop the vlan header and send to the destination bpf_skb_vlan_pop(skb); bpf_clone_redirect(skb, leaf->out_ifindex, 0); } } return 1; } int handle_virt2phys(struct __sk_buff *skb) { u8 *cursor = 0; ethernet: { struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); int src_ifindex = skb->ifindex; struct ifindex_leaf_t *leaf = egress.lookup(&src_ifindex); if (leaf) { lock_xadd(&leaf->tx_pkts, 1); lock_xadd(&leaf->tx_bytes, skb->len); bpf_skb_vlan_push(skb, leaf->vlan_proto, leaf->vlan_tci); bpf_clone_redirect(skb, leaf->out_ifindex, 0); } } return 1; } bpfcc-0.2.0+git0.02884a026/examples/networking/vlan_learning/vlan_learning.py000077500000000000000000000072441305314114400265250ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF from builtins import input from pyroute2 import IPRoute, NetNS, IPDB, NSPopen from random import shuffle from time import sleep from simulation import Simulation import sys ipr = IPRoute() ipdb = IPDB(nl=ipr) num_clients = 3 num_vlans = 16 # load the bpf program b = BPF(src_file="vlan_learning.c", debug=0) phys_fn = b.load_func("handle_phys2virt", BPF.SCHED_CLS) virt_fn = b.load_func("handle_virt2phys", BPF.SCHED_CLS) ingress = b.get_table("ingress") egress = b.get_table("egress") class VlanSimulation(Simulation): def __init__(self, ipdb): super(VlanSimulation, self).__init__(ipdb) def start(self): # start identical workers each in a namespace for i in range(0, num_clients): httpmod = ("SimpleHTTPServer" if sys.version_info[0] < 3 else "http.server") cmd = ["python", "-m", httpmod, "80"] self._create_ns("worker%d" % i, cmd=cmd, fn=virt_fn, action="drop", ipaddr="172.16.1.5/24") # simulate a physical eth vlan trunk with self.ipdb.create(ifname="eth0a", kind="veth", peer="eth0b") as v: v.up() self.ipdb.interfaces.eth0b.up().commit() # eth0a will be hooked to clients with vlan interfaces # add the bpf program to eth0b for demuxing phys2virt packets v = self.ipdb.interfaces["eth0b"] ipr.tc("add", "ingress", v["index"], "ffff:") ipr.tc("add-filter", "bpf", v["index"], ":1", fd=phys_fn.fd, name=phys_fn.name, parent="ffff:", action="drop", classid=1) # allocate vlans randomly available_vlans = [i for i in range(2, 2 + num_vlans)] shuffle(available_vlans) available_ips = [[i for i in range(100, 105)] for i in range(0, num_clients)] # these are simulations of physical clients for i in range(0, num_clients): macaddr = ("02:00:00:%.2x:%.2x:%.2x" % ((i >> 16) & 0xff, (i >> 8) & 0xff, i & 0xff)) # assign this client to the given worker idx = self.ipdb.interfaces["worker%da" % i]["index"] mac = int(macaddr.replace(":", ""), 16) ingress[ingress.Key(mac)] = ingress.Leaf(idx, 0, 0, 0, 0) # test traffic with curl loop cmd = ["bash", "-c", "for i in {1..8}; do curl 172.16.1.5 -o /dev/null; sleep 1; done"] client_ifc = self.ipdb.create(ifname="eth0a.%d" % i, kind="vlan", link=self.ipdb.interfaces["eth0a"], vlan_id=available_vlans.pop(0)).commit() (out_ifc, in_ifc) = self._create_ns("client%d" % i, in_ifc=client_ifc, ipaddr="172.16.1.100/24", macaddr=macaddr, cmd=cmd)[1:3] try: sim = VlanSimulation(ipdb) sim.start() sleep(10) input("Press enter to exit: ") stats_collect = {} for key, leaf in ingress.items(): stats_collect[key.value] = [leaf.tx_pkts, leaf.tx_bytes, 0, 0] for key, leaf in egress.items(): x = stats_collect.get(key.value, [0, 0, 0, 0]) x[2] = leaf.tx_pkts x[3] = leaf.tx_bytes for k, v in stats_collect.items(): print("mac %.12x rx pkts = %u, rx bytes = %u" % (k, v[0], v[1])) print(" tx pkts = %u, tx bytes = %u" % (v[2], v[3])) finally: if "eth0a" in ipdb.interfaces: ipdb.interfaces.eth0a.remove().commit() if "sim" in locals(): sim.release() ipdb.release() bpfcc-0.2.0+git0.02884a026/examples/networking/xdp/000077500000000000000000000000001305314114400212765ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/networking/xdp/CMakeLists.txt000066400000000000000000000001221305314114400240310ustar00rootroot00000000000000install(PROGRAMS xdp_drop_count.py DESTINATION share/bcc/examples/networking/xdp) bpfcc-0.2.0+git0.02884a026/examples/networking/xdp/xdp_drop_count.py000077500000000000000000000071351305314114400247100ustar00rootroot00000000000000#!/usr/bin/env python # # xdp_drop_count.py Drop incoming packets on XDP layer and count for which # protocol type # # Copyright (c) 2016 PLUMgrid # Copyright (c) 2016 Jan Ruth # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF import pyroute2 import time import sys if len(sys.argv) != 2: print("Usage: {0} \n\ne.g.: {0} eth0".format(sys.argv[0])) exit(1) device = sys.argv[1] mode = BPF.XDP #mode = BPF.SCHED_CLS if mode == BPF.XDP: ret = "XDP_DROP" ctxtype = "xdp_md" else: ret = "TC_ACT_SHOT" ctxtype = "__sk_buff" # load BPF program b = BPF(text = """ #define KBUILD_MODNAME "foo" #include #include #include #include #include #include #include BPF_TABLE("percpu_array", uint32_t, long, dropcnt, 256); static inline int parse_ipv4(void *data, u64 nh_off, void *data_end) { struct iphdr *iph = data + nh_off; if ((void*)&iph[1] > data_end) return 0; return iph->protocol; } static inline int parse_ipv6(void *data, u64 nh_off, void *data_end) { struct ipv6hdr *ip6h = data + nh_off; if ((void*)&ip6h[1] > data_end) return 0; return ip6h->nexthdr; } int xdp_prog1(struct CTXTYPE *ctx) { void* data_end = (void*)(long)ctx->data_end; void* data = (void*)(long)ctx->data; struct ethhdr *eth = data; // drop packets int rc = RETURNCODE; // let pass XDP_PASS or redirect to tx via XDP_TX long *value; uint16_t h_proto; uint64_t nh_off = 0; uint32_t index; nh_off = sizeof(*eth); if (data + nh_off > data_end) return rc; h_proto = eth->h_proto; if (h_proto == htons(ETH_P_8021Q) || h_proto == htons(ETH_P_8021AD)) { struct vlan_hdr *vhdr; vhdr = data + nh_off; nh_off += sizeof(struct vlan_hdr); if (data + nh_off > data_end) return rc; h_proto = vhdr->h_vlan_encapsulated_proto; } if (h_proto == htons(ETH_P_8021Q) || h_proto == htons(ETH_P_8021AD)) { struct vlan_hdr *vhdr; vhdr = data + nh_off; nh_off += sizeof(struct vlan_hdr); if (data + nh_off > data_end) return rc; h_proto = vhdr->h_vlan_encapsulated_proto; } if (h_proto == htons(ETH_P_IP)) index = parse_ipv4(data, nh_off, data_end); else if (h_proto == htons(ETH_P_IPV6)) index = parse_ipv6(data, nh_off, data_end); else index = 0; value = dropcnt.lookup(&index); if (value) *value += 1; return rc; } """, cflags=["-w", "-DRETURNCODE=%s" % ret, "-DCTXTYPE=%s" % ctxtype]) fn = b.load_func("xdp_prog1", mode) if mode == BPF.XDP: b.attach_xdp(device, fn) else: ip = pyroute2.IPRoute() ipdb = pyroute2.IPDB(nl=ip) idx = ipdb.interfaces[device].index ip.tc("add", "clsact", idx) ip.tc("add-filter", "bpf", idx, ":1", fd=fn.fd, name=fn.name, parent="ffff:fff2", classid=1, direct_action=True) dropcnt = b.get_table("dropcnt") prev = [0] * 256 print("Printing drops per IP protocol-number, hit CTRL+C to stop") while 1: try: for k in dropcnt.keys(): val = dropcnt.sum(k).value i = k.value if val: delta = val - prev[i] prev[i] = val print("{}: {} pkt/s".format(i, delta)) time.sleep(1) except KeyboardInterrupt: print("Removing filter from device") break; if mode == BPF.XDP: b.remove_xdp(device) else: ip.tc("del", "clsact", idx) ipdb.release() bpfcc-0.2.0+git0.02884a026/examples/tracing/000077500000000000000000000000001305314114400177435ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/examples/tracing/CMakeLists.txt000066400000000000000000000004241305314114400225030ustar00rootroot00000000000000file(GLOB C_FILES *.c) file(GLOB PY_FILES *.py) file(GLOB TXT_FILES *.txt) install(PROGRAMS ${PY_FILES} DESTINATION share/bcc/examples/tracing) install(FILES ${C_FILES} DESTINATION share/bcc/examples/tracing) install(FILES ${TXT_FILES} DESTINATION share/bcc/examples/tracing) bpfcc-0.2.0+git0.02884a026/examples/tracing/bitehist.py000077500000000000000000000016231305314114400221350ustar00rootroot00000000000000#!/usr/bin/python # # bitehist.py Block I/O size histogram. # For Linux, uses BCC, eBPF. Embedded C. # # Written as a basic example of using a histogram to show a distribution. # # The default interval is 5 seconds. A Ctrl-C will print the partially # gathered histogram then exit. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 15-Aug-2015 Brendan Gregg Created this. from bcc import BPF from time import sleep # load BPF program b = BPF(text=""" #include #include BPF_HISTOGRAM(dist); int kprobe__blk_account_io_completion(struct pt_regs *ctx, struct request *req) { dist.increment(bpf_log2l(req->__data_len / 1024)); return 0; } """) # header print("Tracing... Hit Ctrl-C to end.") # trace until Ctrl-C try: sleep(99999999) except KeyboardInterrupt: print # output b["dist"].print_log2_hist("kbytes") bpfcc-0.2.0+git0.02884a026/examples/tracing/bitehist_example.txt000066400000000000000000000022701305314114400240330ustar00rootroot00000000000000Demonstrations of bitehist.py, the Linux eBPF/bcc version. This prints a power-of-2 histogram to show the block I/O size distribution. A summary is printed after Ctrl-C is hit. # ./bitehist.py Tracing... Hit Ctrl-C to end. ^C kbytes : count distribution 0 -> 1 : 3 | | 2 -> 3 : 0 | | 4 -> 7 : 211 |********** | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 800 |**************************************| This output shows a bimodal distribution. The largest mod of 800 I/O were between 128 and 255 Kbytes in size, and another mode of 211 I/O were between 4 and 7 Kbytes in size. Understanding this distribution is useful for characterizing workloads and understanding performance. The existence of this distribution is not visible from averages alone. bpfcc-0.2.0+git0.02884a026/examples/tracing/disksnoop.py000077500000000000000000000032001305314114400223240ustar00rootroot00000000000000#!/usr/bin/python # # disksnoop.py Trace block device I/O: basic version of iosnoop. # For Linux, uses BCC, eBPF. Embedded C. # # Written as a basic example of tracing latency. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 11-Aug-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF REQ_WRITE = 1 # from include/linux/blk_types.h # load BPF program b = BPF(text=""" #include #include BPF_HASH(start, struct request *); void trace_start(struct pt_regs *ctx, struct request *req) { // stash start timestamp by request ptr u64 ts = bpf_ktime_get_ns(); start.update(&req, &ts); } void trace_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp, delta; tsp = start.lookup(&req); if (tsp != 0) { delta = bpf_ktime_get_ns() - *tsp; bpf_trace_printk("%d %x %d\\n", req->__data_len, req->cmd_flags, delta / 1000); start.delete(&req); } } """) b.attach_kprobe(event="blk_start_request", fn_name="trace_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_start") b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_completion") # header print("%-18s %-2s %-7s %8s" % ("TIME(s)", "T", "BYTES", "LAT(ms)")) # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (bytes_s, bflags_s, us_s) = msg.split() if int(bflags_s, 16) & REQ_WRITE: type_s = "W" elif bytes_s == "0": # see blk_fill_rwbs() for logic type_s = "M" else: type_s = "R" ms = float(int(us_s, 10)) / 1000 print("%-18.9f %-2s %-7s %8.2f" % (ts, type_s, bytes_s, ms)) bpfcc-0.2.0+git0.02884a026/examples/tracing/disksnoop_example.txt000066400000000000000000000030631305314114400242320ustar00rootroot00000000000000Demonstrations of disksnoop.py, the Linux eBPF/bcc version. This traces block I/O, a prints a line to summarize each I/O completed: # ./disksnoop.py TIME(s) T BYTES LAT(ms) 16458043.435457 W 4096 2.73 16458043.435981 W 4096 3.24 16458043.436012 W 4096 3.13 16458043.437326 W 4096 4.44 16458044.126545 R 4096 42.82 16458044.129872 R 4096 3.24 16458044.130705 R 4096 0.73 16458044.142813 R 4096 12.01 16458044.147302 R 4096 4.33 16458044.148117 R 4096 0.71 16458044.148950 R 4096 0.70 16458044.164332 R 4096 15.29 16458044.168003 R 4096 3.58 16458044.171676 R 4096 3.59 16458044.172453 R 4096 0.72 16458044.173213 R 4096 0.71 16458044.173989 R 4096 0.72 16458044.174739 R 4096 0.70 16458044.190334 R 4096 15.52 16458044.196608 R 4096 6.17 16458044.203091 R 4096 6.35 The output includes a basic timestamp (in seconds), the type of I/O (W == write, R == read, M == metadata), the size of the I/O in bytes, and the latency (or duration) of the I/O in milliseconds. The latency is measured from I/O request to the device, to the device completion. This excludes latency spent queued in the OS. Most of the I/O in this example were 0.7 and 4 milliseconds in duration. There was an outlier of 42.82 milliseconds, a read which followed many writes (the high latency may have been caused by the writes still being serviced on the storage device). bpfcc-0.2.0+git0.02884a026/examples/tracing/hello_fields.py000077500000000000000000000011151305314114400227470ustar00rootroot00000000000000#!/usr/bin/env python # # This is a Hello World example that formats output as fields. from bcc import BPF # define BPF program prog = """ int hello(void *ctx) { bpf_trace_printk("Hello, World!\\n"); return 0; } """ # load BPF program b = BPF(text=prog) b.attach_kprobe(event="sys_clone", fn_name="hello") # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "MESSAGE")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) bpfcc-0.2.0+git0.02884a026/examples/tracing/hello_perf_output.py000077500000000000000000000026311305314114400240610ustar00rootroot00000000000000#!/usr/bin/env python # # This is a Hello World example that uses BPF_PERF_OUTPUT. from bcc import BPF import ctypes as ct # define BPF program prog = """ #include // define output data structure in C struct data_t { u32 pid; u64 ts; char comm[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(events); int hello(struct pt_regs *ctx) { struct data_t data = {}; data.pid = bpf_get_current_pid_tgid(); data.ts = bpf_ktime_get_ns(); bpf_get_current_comm(&data.comm, sizeof(data.comm)); events.perf_submit(ctx, &data, sizeof(data)); return 0; } """ # load BPF program b = BPF(text=prog) b.attach_kprobe(event="sys_clone", fn_name="hello") # define output data structure in Python TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [("pid", ct.c_uint), ("ts", ct.c_ulonglong), ("comm", ct.c_char * TASK_COMM_LEN)] # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "MESSAGE")) # process event start = 0 def print_event(cpu, data, size): global start event = ct.cast(data, ct.POINTER(Data)).contents if start == 0: start = event.ts time_s = (float(event.ts - start)) / 1000000000 print("%-18.9f %-16s %-6d %s" % (time_s, event.comm, event.pid, "Hello, perf_output!")) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/examples/tracing/mallocstacks.py000066400000000000000000000027221305314114400230000ustar00rootroot00000000000000#!/usr/bin/python # # mallocstacks Trace malloc() calls in a process and print the full # stack trace for all callsites. # For Linux, uses BCC, eBPF. Embedded C. # # This script is a basic example of the new Linux 4.6+ BPF_STACK_TRACE # table API. # # Copyright 2016 GitHub, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF from time import sleep import sys if len(sys.argv) < 2: print("USAGE: mallocstacks PID") exit() pid = int(sys.argv[1]) # load BPF program b = BPF(text=""" #include BPF_HASH(calls, int); BPF_STACK_TRACE(stack_traces, 1024) int alloc_enter(struct pt_regs *ctx, size_t size) { int key = stack_traces.get_stackid(ctx, BPF_F_USER_STACK|BPF_F_REUSE_STACKID); if (key < 0) return 0; u64 zero = 0, *val; val = calls.lookup_or_init(&key, &zero); (*val) += size; return 0; }; """) b.attach_uprobe(name="c", sym="malloc", fn_name="alloc_enter", pid=pid) print("Attaching to malloc in pid %d, Ctrl+C to quit." % pid) # sleep until Ctrl-C try: sleep(99999999) except KeyboardInterrupt: pass calls = b.get_table("calls") stack_traces = b.get_table("stack_traces") for k, v in reversed(sorted(calls.items(), key=lambda c: c[1].value)): print("%d bytes allocated at:" % v.value) for addr in stack_traces.walk(k.value): print("\t%s" % b.sym(addr, pid, show_offset=True)) bpfcc-0.2.0+git0.02884a026/examples/tracing/mysqld_query.py000077500000000000000000000030321305314114400230540ustar00rootroot00000000000000#!/usr/bin/python # # mysqld_query Trace MySQL server queries. Example of USDT tracing. # For Linux, uses BCC, BPF. Embedded C. # # USAGE: mysqld_query PID # # This uses USDT probes, and needs a MySQL server with -DENABLE_DTRACE=1. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF, USDT import sys if len(sys.argv) < 2: print("USAGE: mysqld_latency PID") exit() pid = sys.argv[1] debug = 0 # load BPF program bpf_text = """ #include int do_trace(struct pt_regs *ctx) { uint64_t addr; char query[128]; /* * Read the first argument from the query-start probe, which is the query. * The format of this probe is: * query-start(query, connectionid, database, user, host) * see: https://dev.mysql.com/doc/refman/5.7/en/dba-dtrace-ref-query.html */ bpf_usdt_readarg(1, ctx, &addr); bpf_trace_printk("%s\\n", addr); return 0; }; """ # enable USDT probe from given PID u = USDT(pid=int(pid)) u.enable_probe(probe="query__start", fn_name="do_trace") if debug: print(u.get_text()) print(bpf_text) # initialize BPF b = BPF(text=bpf_text, usdt_contexts=[u]) # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "QUERY")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: print("value error") continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) bpfcc-0.2.0+git0.02884a026/examples/tracing/mysqld_query_example.txt000066400000000000000000000007631305314114400247630ustar00rootroot00000000000000# ./mysqld_query.py `pgrep -n mysqld` TIME(s) COMM PID QUERY 17450459.549910001 mysqld 18608 select @@version_comment limit 1 17450463.822668001 mysqld 18608 SELECT DATABASE() 17450463.824042998 mysqld 18608 show databases 17450463.824570000 mysqld 18608 show tables 17450465.602717999 mysqld 18608 SELECT COUNT(*) FROM words 17450479.944897000 mysqld 18608 SELECT * FROM words WHERE word REGEXP '^bre.*n$' bpfcc-0.2.0+git0.02884a026/examples/tracing/nodejs_http_server.py000077500000000000000000000024171305314114400242330ustar00rootroot00000000000000#!/usr/bin/python # # nodejs_http_server Basic example of node.js USDT tracing. # For Linux, uses BCC, BPF. Embedded C. # # USAGE: nodejs_http_server PID # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF, USDT import sys if len(sys.argv) < 2: print("USAGE: nodejs_http_server PID") exit() pid = sys.argv[1] debug = 0 # load BPF program bpf_text = """ #include int do_trace(struct pt_regs *ctx) { uint64_t addr; char path[128]={0}; bpf_usdt_readarg(6, ctx, &addr); bpf_probe_read(&path, sizeof(path), (void *)addr); bpf_trace_printk("path:%s\\n", path); return 0; }; """ # enable USDT probe from given PID u = USDT(pid=int(pid)) u.enable_probe(probe="http__server__request", fn_name="do_trace") if debug: print(u.get_text()) print(bpf_text) # initialize BPF b = BPF(text=bpf_text, usdt_contexts=[u]) # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "ARGS")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: print("value error") continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) bpfcc-0.2.0+git0.02884a026/examples/tracing/nodejs_http_server_example.txt000066400000000000000000000004241305314114400261260ustar00rootroot00000000000000# ./nodejs_http_server.py 24728 TIME(s) COMM PID ARGS 24653324.561322998 node 24728 path:/index.html 24653335.343401998 node 24728 path:/images/welcome.png 24653340.510164998 node 24728 path:/images/favicon.png bpfcc-0.2.0+git0.02884a026/examples/tracing/strlen_count.py000077500000000000000000000023361305314114400230430ustar00rootroot00000000000000#!/usr/bin/python # # strlen_count Trace strlen() and print a frequency count of strings. # For Linux, uses BCC, eBPF. Embedded C. # # Written as a basic example of BCC and uprobes. # # Also see strlensnoop. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF from time import sleep # load BPF program b = BPF(text=""" #include struct key_t { char c[80]; }; BPF_HASH(counts, struct key_t); int count(struct pt_regs *ctx) { if (!PT_REGS_PARM1(ctx)) return 0; struct key_t key = {}; u64 zero = 0, *val; bpf_probe_read(&key.c, sizeof(key.c), (void *)PT_REGS_PARM1(ctx)); val = counts.lookup_or_init(&key, &zero); (*val)++; return 0; }; """) b.attach_uprobe(name="c", sym="strlen", fn_name="count") # header print("Tracing strlen()... Hit Ctrl-C to end.") # sleep until Ctrl-C try: sleep(99999999) except KeyboardInterrupt: pass # print output print("%10s %s" % ("COUNT", "STRING")) counts = b.get_table("counts") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): print("%10d \"%s\"" % (v.value, k.c.encode('string-escape'))) bpfcc-0.2.0+git0.02884a026/examples/tracing/strlen_hist.py000077500000000000000000000035011305314114400226550ustar00rootroot00000000000000#!/usr/bin/python # # strlen_hist.py Histogram of system-wide strlen return values # # A basic example of using uprobes along with a histogram to show # distributions. # # Runs until ctrl-c is pressed. # # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # Example output: # $ sudo ./strlen_hist.py # 22:12:52 # strlen return: : count distribution # 0 -> 1 : 2106 |**************** | # 2 -> 3 : 1172 |********* | # 4 -> 7 : 3892 |****************************** | # 8 -> 15 : 5096 |****************************************| # 16 -> 31 : 2201 |***************** | # 32 -> 63 : 547 |**** | # 64 -> 127 : 106 | | # 128 -> 255 : 13 | | # 256 -> 511 : 27 | | # 512 -> 1023 : 6 | | # 1024 -> 2047 : 10 | | # ^C$ # from __future__ import print_function import bcc import time text = """ #include BPF_HISTOGRAM(dist); int count(struct pt_regs *ctx) { dist.increment(bpf_log2l(PT_REGS_RC(ctx))); return 0; } """ b = bcc.BPF(text=text) sym="strlen" b.attach_uretprobe(name="c", sym=sym, fn_name="count") dist = b["dist"] try: while True: time.sleep(1) print("%-8s\n" % time.strftime("%H:%M:%S"), end="") dist.print_log2_hist(sym + " return:") dist.clear() except KeyboardInterrupt: pass bpfcc-0.2.0+git0.02884a026/examples/tracing/strlen_snoop.py000077500000000000000000000025431305314114400230510ustar00rootroot00000000000000#!/usr/bin/python # # strlen_snoop Trace strlen() library function for a given PID. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: strlensnoop PID # # Try running this on a separate bash shell. # # Written as a basic example of BCC and uprobes. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF from os import getpid import sys if len(sys.argv) < 2: print("USAGE: strlensnoop PID") exit() pid = sys.argv[1] # load BPF program bpf_text = """ #include int printarg(struct pt_regs *ctx) { if (!PT_REGS_PARM1(ctx)) return 0; u32 pid = bpf_get_current_pid_tgid(); if (pid != PID) return 0; char str[80] = {}; bpf_probe_read(&str, sizeof(str), (void *)PT_REGS_PARM1(ctx)); bpf_trace_printk("%s\\n", &str); return 0; }; """ bpf_text = bpf_text.replace('PID', pid) b = BPF(text=bpf_text) b.attach_uprobe(name="c", sym="strlen", fn_name="printarg") # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "STRLEN")) # format output me = getpid() while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue if pid == me or msg == "": continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) bpfcc-0.2.0+git0.02884a026/examples/tracing/sync_timing.py000077500000000000000000000023751305314114400226520ustar00rootroot00000000000000#!/usr/bin/python # # sync_timing.py Trace time between syncs. # For Linux, uses BCC, eBPF. Embedded C. # # Written as a basic example of tracing time between events. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF # load BPF program b = BPF(text=""" #include #include BPF_HASH(last); void do_trace(struct pt_regs *ctx) { u64 ts, *tsp, delta, key = 0; // attempt to read stored timestamp tsp = last.lookup(&key); if (tsp != 0) { delta = bpf_ktime_get_ns() - *tsp; if (delta < 1000000000) { // output if time is less than 1 second bpf_trace_printk("%d\\n", delta / 1000000); } last.delete(&key); } // update stored timestamp ts = bpf_ktime_get_ns(); last.update(&key, &ts); } """) b.attach_kprobe(event="sys_sync", fn_name="do_trace") print("Tracing for quick sync's... Ctrl-C to end") # format output start = 0 while 1: (task, pid, cpu, flags, ts, ms) = b.trace_fields() if start == 0: start = ts ts = ts - start print("At time %.2f s: multiple syncs detected, last %s ms ago" % (ts, ms)) bpfcc-0.2.0+git0.02884a026/examples/tracing/task_switch.py000077500000000000000000000015761305314114400226540ustar00rootroot00000000000000#!/usr/bin/python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF from time import sleep b = BPF(text=""" #include #include struct key_t { u32 prev_pid; u32 curr_pid; }; // map_type, key_type, leaf_type, table_name, num_entry BPF_TABLE("hash", struct key_t, u64, stats, 1024); int count_sched(struct pt_regs *ctx, struct task_struct *prev) { struct key_t key = {}; u64 zero = 0, *val; key.curr_pid = bpf_get_current_pid_tgid(); key.prev_pid = prev->pid; val = stats.lookup_or_init(&key, &zero); (*val)++; return 0; } """) b.attach_kprobe(event="finish_task_switch", fn_name="count_sched") # generate many schedule events for i in range(0, 100): sleep(0.01) for k, v in b["stats"].items(): print("task_switch[%5d->%5d]=%u" % (k.prev_pid, k.curr_pid, v.value)) bpfcc-0.2.0+git0.02884a026/examples/tracing/tcpv4connect.py000077500000000000000000000046211305314114400227350ustar00rootroot00000000000000#!/usr/bin/python # # tcpv4connect Trace TCP IPv4 connect()s. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: tcpv4connect [-h] [-t] [-p PID] # # This is provided as a basic example of TCP connection & socket tracing. # # All IPv4 connection attempts are traced, even if they ultimately fail. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 15-Oct-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF # define BPF program bpf_text = """ #include #include #include BPF_HASH(currsock, u32, struct sock *); int kprobe__tcp_v4_connect(struct pt_regs *ctx, struct sock *sk) { u32 pid = bpf_get_current_pid_tgid(); // stash the sock ptr for lookup on return currsock.update(&pid, &sk); return 0; }; int kretprobe__tcp_v4_connect(struct pt_regs *ctx) { int ret = PT_REGS_RC(ctx); u32 pid = bpf_get_current_pid_tgid(); struct sock **skpp; skpp = currsock.lookup(&pid); if (skpp == 0) { return 0; // missed entry } if (ret != 0) { // failed to send SYNC packet, may not have populated // socket __sk_common.{skc_rcv_saddr, ...} currsock.delete(&pid); return 0; } // pull in details struct sock *skp = *skpp; u32 saddr = 0, daddr = 0; u16 dport = 0; bpf_probe_read(&saddr, sizeof(saddr), &skp->__sk_common.skc_rcv_saddr); bpf_probe_read(&daddr, sizeof(daddr), &skp->__sk_common.skc_daddr); bpf_probe_read(&dport, sizeof(dport), &skp->__sk_common.skc_dport); // output bpf_trace_printk("trace_tcp4connect %x %x %d\\n", saddr, daddr, ntohs(dport)); currsock.delete(&pid); return 0; } """ # initialize BPF b = BPF(text=bpf_text) # header print("%-6s %-12s %-16s %-16s %-4s" % ("PID", "COMM", "SADDR", "DADDR", "DPORT")) def inet_ntoa(addr): dq = '' for i in range(0, 4): dq = dq + str(addr & 0xff) if (i != 3): dq = dq + '.' addr = addr >> 8 return dq # filter and format output while 1: # Read messages from kernel pipe try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (_tag, saddr_hs, daddr_hs, dport_s) = msg.split(" ") except ValueError: # Ignore messages from other tracers continue # Ignore messages from other tracers if _tag != "trace_tcp4connect": continue print("%-6d %-12.12s %-16s %-16s %-4s" % (pid, task, inet_ntoa(int(saddr_hs, 16)), inet_ntoa(int(daddr_hs, 16)), dport_s)) bpfcc-0.2.0+git0.02884a026/examples/tracing/tcpv4connect_example.txt000066400000000000000000000020471305314114400246340ustar00rootroot00000000000000Demonstrations of tcpv4connect.py, the Linux eBPF/bcc version. This example traces the kernel function performing active TCP IPv4 connections (eg, via a connect() syscall; accept() are passive connections). Some example output (IP addresses changed to protect the innocent): # ./tcpv4connect.py PID COMM SADDR DADDR DPORT 1479 telnet 127.0.0.1 127.0.0.1 23 1469 curl 10.201.219.236 54.245.105.25 80 1469 curl 10.201.219.236 54.67.101.145 80 This output shows three connections, one from a "telnet" process and two from "curl". The output details shows the source address, destination address, and destination port. This traces attempted connections: these may have failed. The overhead of this tool should be negligible, since it is only tracing the kernel function performing a connect. It is not tracing every packet and then filtering. This is provided as a basic example of TCP tracing. See tools/tcpconnect for a more featured version of this example (a tool). bpfcc-0.2.0+git0.02884a026/examples/tracing/trace_fields.py000077500000000000000000000007521305314114400227500ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # This is an example of tracing an event and printing custom fields. # run in project examples directory with: # sudo ./trace_fields.py" from bcc import BPF prog = """ int hello(void *ctx) { bpf_trace_printk("Hello, World!\\n"); return 0; } """ b = BPF(text=prog) b.attach_kprobe(event="sys_clone", fn_name="hello") print "PID MESSAGE" b.trace_print(fmt="{1} {5}") bpfcc-0.2.0+git0.02884a026/examples/tracing/trace_perf_output.py000077500000000000000000000026121305314114400240530ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # This is an example of tracing an event and printing custom fields. # run in project examples directory with: # sudo ./trace_fields.py" import atexit from bcc import BPF import ctypes as ct class Data(ct.Structure): _fields_ = [("ts", ct.c_ulonglong), ("magic", ct.c_ulonglong)] counter = 0 def cb(cpu, data, size): assert size >= ct.sizeof(Data) event = ct.cast(data, ct.POINTER(Data)).contents print("[%0d] %f: %x" % (cpu, float(event.ts) / 1000000, event.magic)) global counter counter += 1 prog = """ BPF_PERF_OUTPUT(events); BPF_TABLE("array", int, u64, counters, 10); int kprobe__sys_clone(void *ctx) { struct { u64 ts; u64 magic; } data = {bpf_ktime_get_ns(), 0x12345678}; int rc; if ((rc = events.perf_submit(ctx, &data, sizeof(data))) < 0) bpf_trace_printk("perf_output failed: %d\\n", rc); int zero = 0; u64 *val = counters.lookup(&zero); if (val) lock_xadd(val, 1); return 0; } """ b = BPF(text=prog) b["events"].open_perf_buffer(cb) @atexit.register def print_counter(): global counter global b print("counter = %d vs %d" % (counter, b["counters"][ct.c_int(0)].value)) print("Tracing sys_write, try `dd if=/dev/zero of=/dev/null`") print("Tracing... Hit Ctrl-C to end.") while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/examples/tracing/urandomread-explicit.py000077500000000000000000000026341305314114400244450ustar00rootroot00000000000000#!/usr/bin/python # # urandomread-explicit Example of instrumenting a kernel tracepoint. # For Linux, uses BCC, BPF. Embedded C. # # This is an older example of instrumenting a tracepoint, which defines # the argument struct and makes an explicit call to attach_tracepoint(). # See urandomread for a newer version that uses TRACEPOINT_PROBE(). # # REQUIRES: Linux 4.7+ (BPF_PROG_TYPE_TRACEPOINT support). # # Test by running this, then in another shell, run: # dd if=/dev/urandom of=/dev/null bs=1k count=5 # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF # define BPF program bpf_text = """ #include struct urandom_read_args { // from /sys/kernel/debug/tracing/events/random/urandom_read/format u64 __unused__; u32 got_bits; u32 pool_left; u32 input_left; }; int printarg(struct urandom_read_args *args) { bpf_trace_printk("%d\\n", args->got_bits); return 0; }; """ # load BPF program b = BPF(text=bpf_text) b.attach_tracepoint(tp="random:urandom_read", fn_name="printarg") # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "GOTBITS")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) bpfcc-0.2.0+git0.02884a026/examples/tracing/urandomread.py000077500000000000000000000016751305314114400226320ustar00rootroot00000000000000#!/usr/bin/python # # urandomread Example of instrumenting a kernel tracepoint. # For Linux, uses BCC, BPF. Embedded C. # # REQUIRES: Linux 4.7+ (BPF_PROG_TYPE_TRACEPOINT support). # # Test by running this, then in another shell, run: # dd if=/dev/urandom of=/dev/null bs=1k count=5 # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF # load BPF program b = BPF(text=""" TRACEPOINT_PROBE(random, urandom_read) { // args is from /sys/kernel/debug/tracing/events/random/urandom_read/format bpf_trace_printk("%d\\n", args->got_bits); return 0; }; """) # header print("%-18s %-16s %-6s %s" % ("TIME(s)", "COMM", "PID", "GOTBITS")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue print("%-18.9f %-16s %-6d %s" % (ts, task, pid, msg)) bpfcc-0.2.0+git0.02884a026/examples/tracing/urandomread_example.txt000077500000000000000000000012431305314114400245230ustar00rootroot00000000000000Examples of urandomread.py, the Linux eBPF/bcc version. To demonstrate this, the following workload was issued: # dd if=/dev/urandom of=/dev/null bs=1k count=5 While urandomread.py was tracing in another session: # ./urandomread.py TIME(s) COMM PID GOTBITS 22592556.392825000 dd 14228 8192 22592556.392949000 dd 14228 8192 22592556.393068999 dd 14228 8192 22592556.393183999 dd 14228 8192 22592556.393298000 dd 14228 8192 The GOTBITS of 8192 matches the workload of 1 Kbyte (8 Kbit) reads. This program was really written as a simple example of tracing a tracepoint. bpfcc-0.2.0+git0.02884a026/examples/tracing/vfsreadlat.c000066400000000000000000000016061305314114400222450ustar00rootroot00000000000000/* * vfsreadlat.c VFS read latency distribution. * For Linux, uses BCC, eBPF. See .py file. * * Copyright (c) 2013-2015 PLUMgrid, http://plumgrid.com * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public * License as published by the Free Software Foundation. * * 15-Aug-2015 Brendan Gregg Created this. */ #include BPF_HASH(start, u32); BPF_HISTOGRAM(dist); int do_entry(struct pt_regs *ctx) { u32 pid; u64 ts, *val; pid = bpf_get_current_pid_tgid(); ts = bpf_ktime_get_ns(); start.update(&pid, &ts); return 0; } int do_return(struct pt_regs *ctx) { u32 pid; u64 *tsp, delta; pid = bpf_get_current_pid_tgid(); tsp = start.lookup(&pid); if (tsp != 0) { delta = bpf_ktime_get_ns() - *tsp; dist.increment(bpf_log2l(delta / 1000)); start.delete(&pid); } return 0; } bpfcc-0.2.0+git0.02884a026/examples/tracing/vfsreadlat.py000077500000000000000000000025001305314114400224500ustar00rootroot00000000000000#!/usr/bin/python # # vfsreadlat.py VFS read latency distribution. # For Linux, uses BCC, eBPF. See .c file. # # Written as a basic example of a function latency distribution histogram. # # USAGE: vfsreadlat.py [interval [count]] # # The default interval is 5 seconds. A Ctrl-C will print the partially # gathered histogram then exit. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 15-Aug-2015 Brendan Gregg Created this. from bcc import BPF from ctypes import c_ushort, c_int, c_ulonglong from time import sleep from sys import argv def usage(): print("USAGE: %s [interval [count]]" % argv[0]) exit() # arguments interval = 5 count = -1 if len(argv) > 1: try: interval = int(argv[1]) if interval == 0: raise if len(argv) > 2: count = int(argv[2]) except: # also catches -h, --help usage() # load BPF program b = BPF(src_file = "vfsreadlat.c") b.attach_kprobe(event="vfs_read", fn_name="do_entry") b.attach_kretprobe(event="vfs_read", fn_name="do_return") # header print("Tracing... Hit Ctrl-C to end.") # output loop = 0 do_exit = 0 while (1): if count > 0: loop += 1 if loop > count: exit() try: sleep(interval) except KeyboardInterrupt: pass; do_exit = 1 print b["dist"].print_log2_hist("usecs") b["dist"].clear() if do_exit: exit() bpfcc-0.2.0+git0.02884a026/examples/tracing/vfsreadlat_example.txt000066400000000000000000000070431305314114400243560ustar00rootroot00000000000000Demonstrations of vfsreadlat.py, the Linux eBPF/bcc version. This example traces the latency of vfs_read (time from call to return), printing it as a histogram distribution. By default, output is every five seconds: # ./vfsreadlat.py Tracing... Hit Ctrl-C to end. usecs : count distribution 0 -> 1 : 4457 |*************************************+| 2 -> 3 : 447 |*** | 4 -> 7 : 2059 |***************** | 8 -> 15 : 1179 |********** | 16 -> 31 : 63 | | 32 -> 63 : 0 | | 64 -> 127 : 2 | | 128 -> 255 : 0 | | 256 -> 511 : 3 | | 512 -> 1023 : 1 | | 1024 -> 2047 : 3 | | 2048 -> 4095 : 2 | | 4096 -> 8191 : 0 | | 8192 -> 16383 : 0 | | 16384 -> 32767 : 0 | | 32768 -> 65535 : 0 | | 65536 -> 131071 : 4 | | 131072 -> 262143 : 2 | | 262144 -> 524287 : 0 | | 524288 -> 1048575 : 4 | | ^C usecs : count distribution 0 -> 1 : 241 |*************************************+| 2 -> 3 : 17 |** | 4 -> 7 : 2 | | 8 -> 15 : 4 | | 16 -> 31 : 2 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 0 | | 256 -> 511 : 1 | | 512 -> 1023 : 1 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 1 | | 4096 -> 8191 : 0 | | 8192 -> 16383 : 0 | | 16384 -> 32767 : 0 | | 32768 -> 65535 : 0 | | 65536 -> 131071 : 0 | | 131072 -> 262143 : 0 | | 262144 -> 524287 : 0 | | 524288 -> 1048575 : 1 | | These examples show outliers in the 524 - 1048 milliseconds range. Since vfs_read() will catch many types of events, this could be anything including keystroke latency on ssh sessions. Further drilling with bcc will be necessary to identify more details. Full usage: # ./vfsreadlat.py -h USAGE: ./vfsreadlat.py [interval [count]] bpfcc-0.2.0+git0.02884a026/images/000077500000000000000000000000001305314114400157435ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/images/bcc_tracing_tools_2016.png000066400000000000000000010176341305314114400226130ustar00rootroot00000000000000PNG  IHDRYysRGB pHYsgRiTXtXML:com.adobe.xmp 5 1 2 O@IDATx$Ն[eq.-E7\.-,$!wߚj@ BlezZ}ӻ^gFᮿzcYf믻6((\sM㏻:z-ʝ+_5A)^{mZkU4mFN(݁ @O hjdȐbXnUW]8]v٥g mٜRN_r뮻nEM6 @ V@*@}3Ff>G@AR/""e]) >|xs~w+)uBDnr ^xa<IJ^KO͆ @Ps!@ZD`wJ.6Z'/,6Zlq`IAF-w *=һ pC N{_? @}|O9n7ojZj)7c^z·~P|# @ "O @^7zh;qO4D;֥Zfiu?/^@ @#= @M 駟>=es=W_}Ur^s{[feo~7xy׭z )K2lT*;'igy&N?a_d_-+?|%ԒoZh!7dq4LnWt't{*+7p{l}.?c=zK/|}AWv3ˎ~n1lz0S?w}70jr?OB"9,dh(Qm܈#j~"e3$V?::tgy"r{!3| 6}PRhaAq(ܚYvf-eI/b&W+䭷 +:,yi)^{m7묳:)8w'4uiӟVvqXuU2Yhx_i믿jpw+}k=g'v~馛-ܒdRN=UN=T7svje 7tsL袋;íZa>.? )ڧfFGy$(bJznJsj_P6 @H# 0 toNwW^ ezYQ"؛_pLMaMiY^;^|E634ڙ.bNB=a%7whY/g}Xg d]>|7ެv-㡇O?ׯ?}t1 ~xmoJxlkㆴ[oufk=1]]w5ge3`f54kFnӒӿi]|pȧYo< 0%W+Kt ,z[S:_~9&83+t}6l3%aeg+5"6 =mQ| wUW $0?S+c;ɝxTrcBPk6ܩ)eN$mhֽ .l&Lp7-.r9@O2L`lK,xXDlbfW g&1b-ryޭ2H@"VW%p PCj.w]_+eZw0* '.R^wun&KVh߹̺2(k)@q͊HK+?RX"Rf_܃emfeَ38M:w>/3R'νj0Em3.v (&!C8"ϓZsIWlk±HI*E: Jߵbí hƽR{5+H ZHQ++w4%٥3Ad>KUa^eg+%R"Z\m)Ų?^zi`P F)-8rꩧ.+;tuYNzꩠLRү˖JEw~ dug5LJEA~P4Аp^q4_a2j62=]׈ŕVьd/,{/wL{wqQu<3qK@ PZA P[/~ _㚬kRgљukM6$(@GR6CJIhP 94OJx qE.n|Ͳ\,;[ v-{(w{ijß5YBgqtrЕhFՈ,-n?,Hj"})ү2[nݺO)6h@:iRWV^ymhR3;]+EDғDr 6ؠPOz=,;sRNO*YьɭZXPW+2` @:#½3: -T PY(#2ɕa,¥pYWK*+J[wR:vVGT r"KNY)Yv7.n! Bx%@_ܽ.P ,[˛jE,Q Eeݘ`РA].k^*̓V^yk_рbV e֛OŹX}뺗i0UbALKK*lhpW (`3)*o6lr I{@h$J,Q#SVD>ʠ ]A]S!R#jxZꫯ""̲m1bDp'Ry6-۲ՠ 2\3j /td8&d}}y%vgS3R4xV)Hf+JmmgE\h|*Zm*E,/U~'o9g[o5rK$lC @@w@] C)n%ŵ,YdwA6\s5QDەʒwfpoF$*z]^9ȴR Ѥ ^Yp<voza4LSs7_GʺeGI,TЖ[ eyJ3ٺ*m7^To${H_:*#KnVJVX3jZJ]v`e 1)*~@ hMm4Qʃ A =n*.RKdeRK5Mx>,igTEɁ4tHy=nqeֲ.߯Y'xb-YI[% VT+ ,(5+D3 `RK\pA+@^?;[?S.ΎyOʑc24XIcݝ-u-h6K/N:$+~{!I;op9 Y @E p/J| >BVrcrM79Y4˧nZi4w}"X%}?lfF/Q0.eRPC(Х,O=T*;ERRW}%f(t&;kCETiREHϔ)yb|?0Thv4Z| \+H@}G '`W:,B ѣk) @&(kEb@@#PB E}Qw6 \-Zo|5geǶ>Nm,%i=L31FZO@rK'-˂]4ni5\q3FT(e]`+f_{i= 1'n7XOKTXzC< $ <`Rvj#!@PsC @ !AwsV_;Y4"^LdxG2r),+gèG{ｐ=p׀ fmN?FfwmݞȧVk tDL]tQwuZ${-5Xv߻C9$f;z  @&½D) DW ђ/qRlt&s=o[w&xݎ;{1w䦩gE]48PJRmoX >ZD4P+u],{ʖ; )dkg }>FhA5Xa 53:jr>|@ZkՂVQG2jK݊+XVF/v(foy$ˊH@@$½Ov: @}.\x5u['|r%7K4l⡲)gwI'[nxRK9VĺTm~eկnsjw7^c=6ڨee+8vuW77rH'%wa2h>y7TZDVm62裏J+TE~DbUL=ԍlRCZc5Œ AZ B]y=IϫSjv߫-cԨQa! @Kѽ<@ȇj}Qw=!V)mlQn`*ݫ1K-Tda?beq sN3UqpvA?Kra9YEBR\d'X}!Hw,HnQ\o[gv*@[l,P5#:H ?Z>t +m5zJ5]NGnSI(z 6q+tfm*%nJz뭪#z݆nةkf` O: *7h` @&½D)  2QnX;m-{urү_w˃}'7Mv*?Fsu2,,+Q0SYm *z<̠<_r% *X|6lX]V@[);iPAuk JW_=5"%=vC [ vCjyk8VNwwyg{ljp/=O.&I1n6"3lZ7Cr{YW.4`ꛮR]~^נbEH^@fnIɮ${e^_@@{^ݡ7 P0άiv oMߌtRtK[EnNM55_O>SXp .]"r"Dz~.4__p[}c5VXTPw]CxPd.kU "[~e*Y5\Nkd5 )㩧 [t֥eK店Rw ׏,%7^PHvŶS.,+ AuN34w&R$OΙf跭ߏtu/_OK#tݽ.g}6P}B|R2cWI2$ e[=1Yf.Z}Wvm]x>?D9`˭F48սLmnvy\4)%4I?ůs9*+} >3q5ׄzni @M!`/! @)GMYU͊YDz!g,zT?x5ŕlL}4iIlmD̢@7?OU_MԪz/2Z?)UK<{>SzuL7<9]NW鷭4=]ֳJ?7e׿Jɼ LxsTx#T{dBy~d6\ ˛ەl֪Y~gB16YgzN6`mP1u@ Hڻ@ wR4SYg5Xmx;?w_~3aSVYC,U X-6+Z,Rv}ur@ aFfhv3~Qs^}Ety]Z_f虠M袋{ehvyOk=4C1] @h" kM$L @@ )fj^xඪPd @v@ @!=jPŻ0=!>DyI@ >posIO @ OdIb-FZ̚kB? @p@ @ ! #n2-e{MH @ڏwN @ Pѣݲ.S i);cGob)mZjBu  @-poH' @ x7ܙg._w\7>(kI'un;COg @O@'O; @"ߺ'x½s~})t ,@hs1*D @mO{۟b:@ @ @ c& @ @ ;~ @ @  `@ @ @hw( ?@ @ @h -L% @ @ P @ @ ([J @ @ @ po3L @ @ @%7^hIeT@ @ @h7ۗC9yۭ @ @ tp*k?Sio:n* @ @ 6&]~&{a@ @ @#½u  @ @ژ 6>t  @ @ZG{XS @ @ 1m|r @ @  ֱ&@ @ @hc(5@ @ @hcMM @ @ Pɥk @ @ :([ǚ @ @ @ poK @ @ @uP55A @ @@@'A @ @@pokj @ @ 6&½O.] @ @ @:@ @ @mL{\@ @ @#½u  @ @ژ 6>t  @ @ZG{XS @ @ 1m|r @ @  ֱ&@ @ @hc(5@ @ @hcMM @ @ Pɥk @ @ :([ǚ @ @ @ poK @ @ @uP55A @ @@@'A @ @@pokj @ @ 6&½O.] @ @ @:@ @ @mL{\@ @ @#½u  @ @ژ 6>t  @ @ZG{XS @ @ 1m|r @ @  ֱ&@ @ @hc(5@ @ @hcMM @ @ Pɥk @ @ :([ǚ @ @ @ o5@駟vl[l17c?Ct|)p_}{[ofqF ]uw/=zfi /i>O> N0nqq>{WB\M7t]UPo~楗^ׯߍNԒ(!@ @=}D# n!puYfò﷿KKt'8I7SSݐ!CCN:)7mNY>ɚg/oe}u|rNsLO;[q9SD}=gwn9Qo5o#Q~!@ @w˘|~/M Iso}P7q#Fp/Bp #e\h裰퍔ג%X}\}a s1j+/sf @ @d@ x*͟8p|̓Jb3B\D*se2wyߛ$Y'.YXc ?${9+ٷ+{c='pN.cҢ\/sYs7'Ͳ>՛?9{)þHL^{mo_~òhp']t A7t_iwۮ66k3R @Rv E~@ˊӔ3{̔C!ùɪ4+ & tMCyN$-F@n^Er':^` V_}ug_grmV: 7cgw/K.qrGl@/I০tO+ 7߄{i6h#7Swf!/u Sn=CIݲG'+38Ù|ٍZꭇs=yme q)86S)} @mP3֤J}e\:v(K6RU#__afxj5$‡nؐr)$RK-gWk=ʻW[^&}Ll)u}KF^z%'3 ȝPrG|7B\Otk=G鼬Cx@E]@iЮ'I3ۓG[ @ ЛpMgmŖ,%RP]?;)dI' y*+*l7W46||)K.Z62  ʔю_~9o." 7dE}'%\2,gm$r-odJ5i*/y?|_punùvzyY@=!p>`=kxf፤@@ >y?ro )եչ"wR BZkһ=zfirSL1EuiPA.&HC:haR?^ {c @Yu\_z+(X`.f v 8s=\;M2$%]]w53]I"07WYJ\^[s5,QռmH_9lU=pHGY$ZzͶsv;гN\, +f)\s ?A9JHK9gX7믿&U)Otmy~)<4 NP^ݴNܔ;=OuL4DemOQd]4Fm+lɊUSzXTQ&q-7Ju͈at"sU;]]'zOӵ뼳k+d @M^X>J Hٵnl㏗Q2ey,mg;̺>)e% 6̛i/}#G-CLW'K1e\wu~Yf)+.{SO5?}&blIYƒ؀@0V`f+h)_roc=JzC."^OÇ'yf$8\DxS6_o~V[m.2_!)(ŹH*XcOV;,9n$Ƿf䘂R?U}>n׽5JùEQ7ӟ-Arm随#3%0Xqw޹9op "jJ$ V78KSt zFRԛ"$O~OP^m7K$m/yZ3̐7l|keߧ*k[T)J*o-7zϳ q}--6M]PyENwxiyG{)}C͂@IDATkB -ͭXiC @5Pv& %Sc2Y=[|s?!PˇY9#tw߲- lbR4e .f%U }pviI}٧bXOzi_ަ'Y@8#,MZ2WnJuK:[X܂yK `O׺fI,;ꪫ&`p|֫r'o=(<+u0IU]wk{ u{"%g6ҿ߾,M6o)müa*o,w]^=>XuVeUYۨ[͈#΋c@bJYg>g׵gz5@ @EPt|{}jE $Yxƿ3<3X#k~ȢSJ;dȐY w}ksy'}ޣ߲VM>d~QG%elI_coFa. +-%sN= d%?44WBPJ5 7l@_!`V񲌍Z=*f,2W_}k{)?t2X,e-sR4Iea+eʒ^hOtR{u?ț-v|ͤN[o,z{b,#`.Ӽfk[F ϭOמq=X2|}o܃$ҺLʗEGJ[LYk&8nͥLWL"KF)-^CkfcZj$]D^ZX.o.eR񘖍T*"7z'=/͞77~ 6z7_zvf/)os p={llC\JYOV]D?vpGoC %Ult'r_W"xTK&FVܓ\j,DœZCrNt'Y@_!`hK$GtѠ3_ Lc=d]I B)ͧvEEa6o۵pUKFlخ%\<_@;３ tivZE5+REVyAr Eo1q)X.%*ueM?5R^U^o7z$=OGuכֿzuϗg? @ !M7tw0k eJd;Y jUNaMY>\}rO Adk8;u16tl2wA9[H;Ss hgYeiv&{6Ӧ]T?__+E(meI]p'oVHf|gwl+PnǷ\Yg51{g3SJk sg) f9s UO(ff_|ELZ2֫[@Y΢ V~8Vp9.ȍ>xu @@=ƨ'3y!J6=ܹ8}}I^z)Y/b㓬K-T]dW{N"N#TJbH0WL {̝E2kXgTv'QwoN9gNQ<Ȱ,KZJ {:=9mAҝw?PX\rɒcqf%͸ޥQ EXvg]s~oaUO;}1Bz/sl`+ @M >_5f-IkAN+TR޸_Q,32qdiKmޞ)hd)ە IbV G Hw'7 NJ$LI#}8GǾ5k@܆+"XwxAmvs,ȥ a晹qrz^OwaCQ~zWV~¦l=;EJnn:-F!EXӎzo]mI&Y 'vXh׃iAu].!ΙdelǩB^,0lLHH[ȦvF edvڙRZgݰaWzni;O.2V[gtz岰x+NuYw[PP̊+,{Yl{7r#%-ܲx>(_꩷ }L:ӛtIΟEODv}Ne! @PijҢ6-|MgNCkɇͲ`ʺBy뭷OVYJTF .cX)o0`@?}`z_y܎V>E%Rv+3GtMnРA΂:rU>e9㏻gy&(G,iwlTo>VSe1wUW7@T[ނѣG; d)Ls!r~uLʃY`wrq% A` ;."]Fe\%9j-jӳ&4JiѠL:&*O=TbTHݵ^6d4O-zXnwe7;k~8QԎ5X1[xJ x Tkܔs3ɔZQ]E3d?|p'nzV]bw9{@ܤDQ#Fvv ?橴,Jo7Ji/Qt'{_ĥPs:*U;G>(@q|by,!P v+~Sv}[g _m@$ J=СC]]qo&˔.ŲM1]^kVP%y7aoSK mJt<7EBG+f2Lam}I>6 @7>|;S_e ^'2fI$՛$ :{.IszHYތtH6X(e,f`hHv@'S? jo}Umyd @TSO=uaY|Uc5$+uYEߕ5e{j7ziy680kBmmuIc/=44ZANh]:`UVLY yޗI'x "YB&}jƘfE&YE.Ygb:kxvƴoyKY:\TfV0SLYp CMmZkviUprS4glsμ UUWV4Mge䐬 VW& UUQ3)sM6Yݙ*! W^9V hffjvOW"+oҽJ-}=PtSSLe67= N@;ܓ\?.g aFۉ'fKoiW1۩GrEwwZ![ Ӑ@om<\FF`<{>L39#%Q]sv'X>:5^JՇ@z+)wNYYjD?T+~ZJj+Qri7e\AfK3XUZo-txC(4+a*F2{%MRɨK.@TfK#6R>z͕E]4NH"WRH" )W_}'C=Ӝ r˅4Pyqe L;3ĝ D7wnZ`_NJ|FԪZ k Ha.eDܫU+isikh"e,d7xkAsT F A0Ťey"57 nts5W:_}ӀDF6Y&CB[ -mrgq^AM#ŗՈbL^ŽRL4)Vtծ>s8IL9Z C,='4˗s! Ȑvy<b|gabܬz@$Г6vЬwF{{h? 9[ kUVIGP ڴRKoJ)oʬ !0RǾcú67E?#KdAv)141F%aJi#KSh^^PˏyLwoJ_z \@146`oJYJ/ʔ^tYZ7e~+w|C6L*V[yJ#\0wk^KFT\l\ PY{哛/od$*Vk9J4n(F^*6A>ccS0(8\(ͤ J%~Hgt=#~2j9rdIZ3FFLpԨQf%AZG.>Òb%"*śo}Q;S҆XWoIko͊Ys,W:b!1^;z\PoVPr6lذpH]N:tkR%6tM7wGWGoL鞸k!SE1YdEBz {]'Y@":thbvKrQGeݛ'3HBM>Ǵm~K:j`M櫸#A |2ikYЗ6 k/`=)拼sLb]i rb݇\%dEN_wu$a{ i,``j[nR[d=݃=LZ,h`əg9蠃JXPpLʢX^s5SeIFZ,yeio mo-{kڲ[֮6{mE{ ʔ5y}Zk_J;-^5m)C>K][٣駟\צ`w_26-:Jyլ#ͰXI^s-u%]gO}ūH\Tɭ׽ޛԧ+"tr+GDx+c'5~@J`iuRWgӵhiS+p2_!PU+]P`sL 6@ m-E, M,e,dщ@,QF^YO7t lKVyAKBWY-2% Yg. o0s硇 SHjq\$dSPv)nen1Be1s3d 9~ Ҭ_f@QEr @4Zǥ݆nؒޖtJ h\E ?qH' 1R J:iFR.f"7RH̿zp>)kվ~A ))N+\&M̻[DF :(?)vF[b$owl螹&8Њ6t1lO_VlG%2yoC6+[ϙ}6+蔀͆ ǥpUdE w 4%1 ,iK YdKmNp%\rEt}7M^*wKguY?$A o_rLue.p!@gꫯQ3[]6O #0cV k% 2RJYFEeRHy5TKsUb֦*IVY``TV=:@aYVkTO1o|(r,?6, Y?{^Kd.cYk]JJYkZH6MMksd$;\@%t6_ >Lֲ(EGYчŧ~VK^ b>CG><ʺO> M7?BDӲFыďt*G/d u nz"Q6jBbk~l=lCD@Yu-d͞)ZL͊9gGRLu.Gθ>Z 4(TPs=eE*JbטH RD)Xy+w QG,8Sǒi& L9唱aj67ڨm41r)CINuM)`i"-r$A Kw) uMHd Z ~!-YTk)A80'EVzLJ6s@I\t!h*# 04?9 c$8dfM\.L2I6/4R~607pn$Oܨ^QFU4VCӛN)S^df%_uyPmʳɾx̦{_[';!@f<;4zS{7䘞+٠sOx>9fm؛B3<^xa.pN1ެß,qS} ا 6ٛ"ݛۆp\y9op.y?r-l<3%}R( dM6?製*EۛF YKWU+nh-R=t:?z[l:GK6PָQk6N)+` ^ĦxͧuhCt^ssc `3H̏9+#Io ItL\R1i+5,@-BZo5U ޝ'1hV[?QlvLRg~k4U?X$K4]*A!Ǯ^t\`iKY5Hg .,Y?y SOԫEk;mkf jz}Ӧţҋpygf>4@:thUϕ]ϛf[JL "e9zG0te[пzG1kyob1KXJqw4%yWꪾڂ֔WdzjCmV"׆ }RVJ4{|Gq3k`Pv%I!vەe7Of5ЀE]EGf%_Y w ~:[4& w&a (ܛ"!@ s=Q/Vk&Y{2Rq>|ŗCb-)EWK7I:7Uo\VYh,azWVR/Wm:^㲤1bud}>餓J\$oddSrU,XOk,T7l>( Izh Y3z؟pWY9u٥ՊTVpV.yQZYjDbs R z|p}?BgMW?| `| s)lqO=[iӼ[Om 3ʒgMtfǣa] C?dWGoCլÂP)tIyU@gk37=oh3kxg*a˦d;EK @S+ɬ JS+5,[kBMHt6Pl@-408 ,i|#EލJH@ + j PO:?+@>M)y碞sbŘQ3@3!\t^W# 쪺^wb;Xgޔd1uZ_ᑿ}jkg>+u9ڨԞ(+/{]Ӻ3;Ij+w%tc蒀޳%VнVbWrdžJC%O]LZ7dȐ;YJWf%&R+tV%n#Om:NN@qD;{^O/=^$#nC%ieW7T̓^)(ՔQ$M#-t[rNm.ª|zc[͈*ʪlajngTO½%4URE2(^VSAE-_K)Y?vYG5eh%=+'I]ebUgG5^Z9|2b5{/ˊ+XruJ#Eލ`$ Kx8蠃ZY5uA[ :ṠwYK@fE^ u%wq<iYtE} &Q[Zkt%qfD]f_5&v$Q4aRkD^SyYBj_6pl=BzHq5b;|G+j՛olw=c^"qZͨ7ՌXNgAܸ㎛4Bd5WNԹc,dJiueQŦaղIEKz&يέM1MJfY#' ;Xr6攨YqGROP@|WNN":>krl +8 n9ߑPj| ӵ_ 6gt[<(mΏ7{}યJ,ew4c=ouч|N랫vWs9P^$wJɚ2uB v$`AX^g33;;֎LS 80<˥|-PsO>)c1dmeNWt]mLZ-!}E}S;mcLM!`/=Nw'uR㫬4Og#e0 j|6lvIXF)zz5RkE[/F&1Mm.*zX)6 =y{xM*FM/+ޔ%ueA ҉͔݉M>',J~m._e[o!o3UJ/BެMcfY%xS0ySzs#v~ybdo ά)wO)o.;Hb-6Ȓ{qsZUEkJ; '$6|oA/6_6>9nsoS?~Z~ZJ=y>sД^IOÇF l馁 `h9yo¦UnB~򊯐>oq}Yg,_Qk;a3 ʞzKϕ<(xշw-Mu~|/nd Jp:i_laKK֋rN `O0׳^y>)f27O,%X\E^K>J|baeI7йo\ĦfmPv^7#[yfy ]Oj]K*h`O;/dlfDk*C!pCi )eH7 1C(꺗JB]}眽^߽w|}{}w-ժO9唔6Æ Kɓ\'~).u wL@c"=C.lB繓N:a7~cS2H]Zt>oXX^x_~)jɒ%i'cu|+ܣ<7#Ou[u rpNHHHHHx`%x[ovYxI0aե.PRrxߎ.ŷ@̰ f嬓T_k)}U1gQ8{ggWoVlFqY_iu]:Uݢ\;8qb.e}M]LIggT^F(a>1cDܷ-|s/_,W `?|&-e+Jqhn/Uaq,5e:ϟ_e'a BykQuw°Gu1I%_&rm7xRO^{rºuiX (e'af X ǔ!p+%ـQG $?[Aɝ#G'O |611=I8a?\bal3*+ԕ5 `Dv8xI"eSu "(ԯkor6XC}s]DϞ=vc@?!N W؉*P8fت?JZ2%X:@>u{gu\$_}Ҝϛk(Pxꩧ(Cs\ʺ8+b,'Pߋ-JtJ8aa;\7LzL\; G7L4teq\jza:;>9'gW'$@$@$@$@$P$L^AS!$Df}?0R~?@@)UZ R3|dҕ68&.+#DDwZފK@gc_'GZ-n,}yUX}Gz!*,+TkEvA_]\-cg-d+"S6R,T#tuOڠї_~źV?+G|b~o㩅|qwEWIKZ;Y'|p1A$@$@$@$@EH <\]:kQ++*1gQ媲Jo Vt^40hC@? h/AԢ4NW}Y( .܉Z%)5(;Q yMG+Y7{B(ipH hYtժU6!eZB1\ $U?i@٫E]HYFWdZ3-W ԟl~EeX۷o/ =p]޴J`\%2LvHHHH Pជ߶m[_ 3%ɓlWx+(94hpA[~E,՗h@2s=tz݉bu+v胓v%Mv` iذ..s&W @A >,]D6Ns[YHk\-cDvʕrG~p0i|mu,1 D ߰P9'a~#w}S p.$@$@$@$@$@{:dMGI\)m7^z25eGN(94&EVPc?믛<nd4 s w3nh=sc@HU #7nnIzSUb'>j()=k0g&Q5Wc2EN' &6eBeK6a{_~ ']/Y$x)ù> TT/_\q?o[ w= 5 |b4 =nٲO<񄸲w%m x㍭lVl[nҥK;?i$9 .7`$X%2sLS^>s&|vQ8xr;^tQUk/3Rcǎ3ϔ>^lE jVM$i<_9SD J{Nw3]vEʹVyh-ZfOp%b%7m}?~¥ KhVGq/駟& C 2xjڴ-_\\,\P޽h\+7O>'ZzBWw}7@6W,n7Aߡ84ȸ\}LקO{Vӟdp~G6ָEy~E}Q#&+`p衇!Ls L,{ή>nI ]=&X:e}>p@9yO]_yWLJ &`J.:uػt#lxHʖ@DpMF~^[ ⋄jUm9W*CPe:'%"8՗ng~qUkg=@MN ϨHުmN%nɗv4w9 _۪ek[ (k:ٙ*n=U:uʩ}Qi|6ѷE5P7)5`g/qek $e\ڤ۪XlRk)Տ7r0AEL@'S|Xz|v1:[twJg٘1cexL[ޥuhqʦIH< 5KDr3u/X Y`*4,$]YX*m8]~'YVcyc=1`_,u+- 3|6j߁<V WVXiSIRJ(uJ2:_6pwUE:XwK.Kq&} (wk`2Y[j-Fx~ŠWMWi1+C2z(_/PqVUYf/wvx<״aU}c$@$PSWYSW߰p?rIG P5!b87=TF\*c?ICpw|>f\%N%I)\|](Rcy晄jDo:S6]}YlYo>!T>E?*sssxŊ%d'&GL wp naSFk]mLvU,zrmwŊ++!9L~w1!6V1ӝÊ ݌[^GYwWxo@IDAT\| +X9b%Wlr]' ` wȢ @ h@WxӪ -W{[ K h@儼ȯJk"lW.]Xpϥv BW)e:A+t?T㜮 T9fΜ[v\_4`L[ sFQ=ý|p۷oJ m45UficP\r%Mر}rSS62  P>KB$@$@$@$@$@$Pa.\($ُ_H̞=[N>cFvMTp;ܾ;pWVY9 ℩]4tB5\ӧO Fp "dW;SNM[ɓS)RYk2c [0&~XtGc=|XEzU>…h)\IHwUI8V      1P冓s9\ HS5kv70E:vxV b64 ~Ќ7FLO?]((}7uH>}dr]wZJ;cJm:9|Ǿz3fMl8 w} \'x”͸zY)V,J,oZ'4 q9LA,r.zkB'NzHnf QÄ+ϻDnI ϗv\hs]$;wI'Z󓀮 @PŮP_߫SN9Ŏ5jȻ6=zw_X?vL}O>/j{챾?Nqٺ+PsU/bف*MX_~jFu#G}pAU%vJ|8s3QepGjiV%qWU!-]|$@UjD'_eʔ)RU֭\}9wNPf*Jyb P^'     "pYln~auYj|>s1#䭟PeNkY3hw}wS]|[w \l cS6w ndv8g5UTYͽ+K/v%P.f&     (V͛7u%c)4i"nm]z뭫S7X: 9eM7ŋ[NXg#RF+~M7YN^o)SD{XgAr,:Ν+=+!ۆ+S6\OBk?9s{a63-[vbI1]r4kbN{.:uvJtݱ\u]UMkDt06;], $@{y^WHJB5o<{91~IVXaKeyXb! d 6uZ`7>cI/^@ԴiSD\Ǜ>B4۶m+;s tcΥ,kx膕܂ B 8N!  |K7Gp{仙??p%O8,N@Iwq-,~է|pu6ʶa2v(۴icAEo6yD'<)ꏲ-TQ2$ xiWb@yF 7|\?OB K۠A;{iA]^$a QFq7vc`n喔UNݻ+\r{ aC޽] b P^C# b&nAF)+xhBbn12q] ,Ա}WM,a=W!_~{,0a2uT;LJ8SWk]!p>H,Zȶq>Ǥ>~qȄ û>tRý xXrm7\֥tǗ,Yb:s:w85EdUw)=M^`U@!  Z'ЧOQ7.}% W_2yUWk@_No9\r[n_ľpb̘1W[ZB.Do>O}g}I#n'ײ}؎cު{x9nIHH xS~KEL @]$SdJc]vQ:thOrKOrU? W<>ªʩ]7T9eBY5pO8ƢJx'jB^ivmj LqQv:8Xƥc1#Vv^ JR% 3DW}gJRm q`t*P#" }]LwxQÝ@c):dOuAΝ}s_npY4U:cA}%,QEyu]M]IcjAUҥKˋV%?Ao N6u2x<ovE|!sفZ]rȥݰcvV.lЕ.l[_3IU+ITǽlP裏t)tb~CF\+0tpK zSŌ!JV(N٬ȐPf@ L\Asg}ÇC~0Xcb=ۧ].,a~>}P;nXwL}XIQP?NM/|3U;%@{K%Mu_:S,(fd\v pK PO~`þ\z2=]qҽ`͓,a#O^T5x/n,><4.߃>hEa{exvxU$t;$@$@$@$@$@{Ƈ\+Qն*UW]iLz_TyHv w$x?q>쳙(v۔&` 5D z.xtb@P=(G}TtQxڽQ(΅jn2, ; +ч- ٱcG ΅Æ `P:ӥ [eV2"]R)C Ig)eq͹cn.)jb8e}eU2C>ChV ?(VRE}'tZ.Y!Xŀk4֭[".dY‰B] K$@$@$@  w(5h %{kڴ@gw3fSidk=C&+faa:tn[M6 8=C8)ڮ{7mXy "蟠Gk䭷޲| ;a @ %9Q_`Ajǻu\"FW6PN:_(k9뫗|,@-#-n r%Mr[>}pB?I[E%wsn_>rk[Ńcl2h@g*DLC_ 4/̈́2[\^K9Pe?<:a#`s7mDWa'?~׏V-EtR ({#}3"43khH.ْqM/s ԲA}(w/Dws\1={vnZ#ϫeBdbՃD/t%"]v?hbANJI5V|#(@m'8xyРA:y뮠e˖|r8e>oCgV2M&n LG (<HHHH 1^3‚*,u}+xD>.n^z)Jw |(eM2@N]!Pwvu;8TƏ!—C=};[o Hg `5Oؗfe=<R>}`=i$S@!W\oޟ |y(Lw}է.'2%7UW3VVSN/] +ܑV w6f_*hWV.}:Q$A\+QV}ny5,3 :RF*g}J?P(ܹN8&ו}|}]&XP3Rqw[(a厇$yg̮&*ԇ0aB~}_VK*u33L71FwqGwu w\c<̪o&ƕ!m.*k7[#   "7MAO^}F]Wu @4nܸԟ{q2Y^m4\ {;GԴ?s=6CVRjDa h5wjpS &T(S~{L? UBLD&ݻwkV*>E}`Eqxpń+,Xr}˥lX,[p]lHHHʑ@>ȅcpEsyv%,wW}( w(nsXêP% fD9A٤T,ե,,q;{&ml 3{ז3V$Jqǂ}J wjRp/k/pϕ @o4hcʘ)AE ic5kyubtԵhU!GzI7HrI~ \U_D[8ucك>"!9xdEwG{.9wL:jvuɦ]' .+ͣ 'u)M6 Lռys8$P*N ~E۵U1U0b[[:/.D}]Q,:tԿhоfeYBQ7 QK~ˢ.̪n@ZWNҽs-<#V: |"j.j .>HԲ5NEQ}3hE/vBDP$"&F7m4gϞ+s>O`ᢁ}bi=; &($@$@$@$@$@G@ʺ뮛v`UK[I )GS:T4:\}[]gulF꭪1 r mڴK.<ѠE]p]YAtFn&K}pJ{L` %DO 42vi"VW6^1ҭ[Յ)5?>: z0 >&0>yI۶mݡR70بU-g}`7n,c@6dpuY[nB#5D z4ЯY[nWG@VP7be,$@$@$@$@$@EOnݺCe)zԄ衰KbGwRWw@إH;⭷28N4@!E>PHV[5k&XzԩS t]( &s{'MWKʔ)SD>g̘ai +z&Mر^zAe-A9ː܄\߀;#a@eȑ){#}+g({ hBR}/uwIwAC~k`-%pϫ9ѣcwe˖t1~W^)x"))[&    7@Po} r*3ekey ,Y$mteUٛP;TTUJn_Zj^eYUse\Bg&uReOi#0,Dā*lS_׬ߪu~)ym" _&_R7WUuk|5Yrm7|m?V|u6e$@$P ZlHt}} ()PM ) @/ǒLR:;,Z.o hݺ8 (Ǐo1u:T?<l<`m"X|=,p~[o>ei%95 ckժs9iΝmuGYdo{Xd>$˸qꫯN>{+gl3f{~ p7וɵ]W6:" Npu]Wͳ-     /xo3m8L 4*IHH*Mqtb 3p%8PC9Y [O?dp(̤ W f275P; $@$@$@$@A|Gԩ#믿gHHHA |Pd$@eON8e?fHHHʍ@X޸qrC$@$@$Pp/. ?ZKZѧzJ^u @+N{H$@$@H Rj3 @AvaL ?*܋$@$@$Pp/+ *#F^}U4ig2e3gFHHH @{HHH *cca J#йsg޽!C>)$eO3ƶQa9   P^=#   G xXH \~k?C7n\RI`VݢEdu P$ @½FR r&ЩS'ݻ"?gr!ШQ#iܸ/4$@$@$@%@{~y6   TT2 e]&묳[pr-ՖaD`4$@$@$@%@{~y6   TT2 @VsF)gr!?gG yG IHHP$@$-AI-7|#W_}uE=wHHHP^chY1 p@$@ lQFW_}v% p3 @;_f7i&HHHH _pIC$P;S *HHHPS^ 0&  D HXHG^z2l0cܸq2o< dCe˖>O?$PSHHHK N57h 6   PT6  #[ZV^-Y#WL4one< &HHH o wXשS'ou"   ppw$% ^{턀>̜93bm,VǽRSR|+GB$@$P<p/k @9½.F$P>`9|^zO3A{uxHH=?&  Ȏqb. ȊW\;2a TE p_hUe9    P#0f'  D HXHu]c'*>$@˖- Wye$@$@$@P L TM`ذaZkY&=ztx+[,8գ`HHB `d%$@$@$@½@C@$@$@$P=*ܫg$@$3L]ܒ%K˹<a?XA!  *ǒ5 d&@{f63A/_~%9 IHH"XtiB &sHHHE |d=$@$g)͚53VC$?[nԩSv`G23HHH ?d6`W^~*f-$@$@$@$D $ % |Xo+U2w\ @rg0IHH :dsdI   P^=#  XN8i߾oIcM p{y_kHHP^{ T:*+IjZk%#G]&M G pKG[  G xXHHH {Tgϊ9IH Ν; ,ݝ 2DӝBaa2_}OL D @{h,B$@$@$ewm&LYS}U+5X:㋷YA4iD]w]k;׿U~Q  ('TXHHH P^7W_-̝;(Z{kNjʭTͭ+^ߩS'ݻ?1|p>$kw#A?$@$@$@]e7^K @5pPMdM{>&Ѻ/_.?~_zm+\y Xr_eC.2Ygu,… eԨQ3LE½"oHH p3PVG$@$@$Ή^zmV;@+ﾫWYv}khժs9>5\#E!GS nIHH ?pGB$@$@$P=:g)/9smIoٲ*IJL`stRWhBvi'Yk2I8]T?ʛo)-(n;iذaBvX~ឦqƲ;H%W\i͛'W-R?J:ut:Vk~A넮mFU29&t2NeEmu}k[u/m۶xE k皥~zG}dVrl?è&eРA]qnbB @ w$@$@$_alߑF$@$@$P1TUoo=LSv}`-z0vU\pA曧A=mڴ &MP&y'Jn*>~KnUn_r(۾}`ʔ)i/1"MmРAUHiȣ`݄ND܉r}u3Jq~u + 8,=.$=餓=#[0qĄu BvmW_}(+L#ݍ7XCH*e 5nVpIHHjJ}Ч21cjŚP&veʔw9PsW$aݰb4Vr_~ aGFj 2O)},P~YCYM(sv:a'3^t3j^;P+&nuUEe=__W_ nIO?aEDVwJ½\,E$'$%    p_5|O ܫŷ 8P: iԨ[Sz~vע<5ke 7|Ir)Vϖ[oׁDvne\uU͖Ydfn6;0yꩧ{-^VyWQ s }s࢖뮻*eZnIx ˮ}e̙2d;&,˾k=ǣrun\_uq-};VTl4aÆZ>,J/p rZA{x 袋lEp_^{m6m'-Ͻ+u_h;䬳βn?k/3/Ȍ3DW@3l"C&OlcU wU1nH =n&)n0˟GH$@$@$PK~TCѺeg~QG,_{3v` ̥JL|#Yj+ARX38VHU;; #ʑwܱbE@;c=J!  F@|AL(   !epWȢV*eL_~9)CQHvsi+>jU%̙;UVYQ(-7|uǩZU99F9:޸FE*Jۘp]2ev[gǁ/qԩ?x+L@L L:$9p(   P32   Aw \ƹp\]JmvuGa9F}PAV ꈲm۶/Y_$1,>I (}lƢ;suu87xE>(z V[ŽdvpɄ?,}u]78v~;ndvJ9_΁9{N`%^}8   hpƍHHH(+;V ejFF>\W (B.^zi8pie}}1߀+5\.q}YHXcl/\'&%<\$ t7!I|3pݹ.k:38:p=ruz Y?|y^bB"C0_L=ZZlC6yϵ >H\1xEpWJ{1\!l`u- @½/ O$@$@%F`' ]v|5#"}ӦM͏9p7)Pj[nr.5Oe7%s55wqt]5kfBWaQѰaêP?G.c~ J([L;s7ƱzbRttL-* s$@eL@W7]U#HHH L`${#]"+1cd cXO2[zdm=Z֝ᡇvm<\`I7phCY8GXׯԩ~,Dnv`5D{f{N:$,vo޽{ugA]aeQuel\|7JŒs7\9X?3iC꒑#G&Jqyv `>gyFO.ڵsYn VnHC@IDATS*@ح V} #@ xXHHH 7k@[ (pk3p0I&.-ry梖ҨQLSGm7Z\`xDpO_p@يZ/4n:t0%{q9zsmוz}7jQŹ\Q;Ǝ g61 T嬳β_rJuLw4{0&rB5E'OP .X/ *;!_46F$@$@$P)~TCep+q c!C2W wA6VvرIHH*)ҥLE\>HjCv dԩ1ܡ"s߾}}zo>C.e*Zs$@$@5C@bye;Zeo􈵒 ;* s|$Pv.:(?қoY46BR.ȻV#1 @LK.Ma 7L/{O4Bܮv-Ж-[w}쳏/>߮|V $@$@$Pl#lHXs5IU/cx+D x*҈@[E =0A$@$@L[nŁ<}3eH bA/_!Waę*dKuluu< 6IF/Ny?sBڵ6(X) x 7`C˽[JC`_c2Vp 7?=&S' ,a{99d׶x/x^#uԑΪtMo(믿_~9rl֍0# "*k6"x)qkֺzW\!'|/1 :Wl S?]v ,JQ7o\j3@c]/|scAlҥl63 6*k8# K裏~ȓO>C Z8YŵX+u? JRq&fĉ2Nj O<۵m˖-m(رceҥ yqO>Lѣe٦3fEL'\{dܳgO'yq)$@$@!@2VIH ';wX!C~?ʜ*e ЪU+=tiӦ$N @ T_~(d[}wxI6tS}3ZhgOKXFm$ڵgeXY N~w\Bg (:Ga׿9(ht̙U?=z07>s̑K/TN>dln3גhC~B0:J4ibJ~}]w9cHHv ½vy5 LI' d&k4uB2$@$@$P=JUZ+a;HUI_(;0VvՂ6nW]uYr-U1)(b Χ_z%+OPL9ȏ?(>㔵 B.^ɧO$@$PKp%lHngf-_^ז## YpS*|l?zDŽcǎƟ{?'Kۆ|gv8NYW/k{ws:t`/v% eTpZl6lcrJ-&r!k --$Czkd5jT!ök@XUKͳ  (Yp?Ovݠx{^(똩p?˖-~۔`[=^TENaKl;`8e]]b<'dvKHHjnvDC_xfϪc=|ՅH*3SMv)\>s2 g5FQʛ@8p*]ʔHHK`7ا=Q^=S8wE￿l~}YO?ݬwyg fzuY?Д0,!x矟n72gu: $NY ~n%ê yĤHH04Ï|-#R7|S -BWsnD]vuدQ>Xz~#F|TRʗ-rd$@$@5GV餜0x%o7f6mj"j^ܳ{|/X@|IqXwL M6#8=l xDŽ?|);m4wرz$@$@L@Z">zy}ݷZ̮uKaB4yvPVbFU*W\?\6Q!zשS'XzuìMGqty~m6ͶHHF0Z#CjNJ n>oyI<.oxJ|9$ve˪zʞqYRN <*ucYTIrtm;lذԟl5ү*>|ޓ>,Dpob:A=m۶,LwO$וKYXakYf ܓ)gd~5%r}هoѣGTsa|ws'H +6O$@$@MYkٷGwf~衇]09\!',{&͝;}P-u6a材|=c̲IxG?=N0 U`ǽWs='.),ìjm;x^;@;>,*9VxB7xþ}L .UQD@u-^EQ]25;]ޗ ס.a z[]hÛR M4 G? 6lR&.3a„@\p-ڂI&%q;quuDݖ5҇@_ <#_}UmdnvV]}!(YV_o]\`Nj-܋ڰg$@L2vDuJX$=O]>`~X;Z}T[u%r* rl eiBH7L(8TÁRF7|sG-(Ғ@:ZdPRVfl'Z|Aڶy0;l OuQd$~EgL&@{q_H w{s=s%HP^D]! L?j(1XF  دJ! M7 v!hV\yݮ7nrwEVqՇuqy?x[qOg]˃- tMַ#GZP AP?Yⴛ\W.vB\ -@(.}‚c:cF]tǖLwyzE\˪OqcƂD Ϋ4<"30w$O`4s*dNHHHja'tiX5+-nxϭV2=믿nsH*@f\gѢEᠿcu6nẪK5jw߀ip_z%ݹR'\BS8 t5^xQq&r'@LaWTr%m?7U}kٯ'@ F! @n.Ry'VIHTdU Z$]g7HH ]yg Q7 iqX{챒l#>#%Lq\O.]v74_a駟J޽*_}[{ž;u<ƍPrF:1c+ կU>w믷 Q 9*J8eQ>,\rs,^{MrgG@ V8:uR~ - nIHH 3Zgf3C@ce,VSHH]ᚨjE)M[#| wq~U #C \B_KZBˋ/(pѱcGsc;c СbJF qw]2ev9g8e ~4F /c:8@tK<ا(a2_|E{%GB$@$@#@{Xhg? PHHy&$NZ'zIÆ 8Q>[]ỻ_~ҭ[7[@&J)eV\)|oVz_$v`Dd_?;X:NY_&[G i t+;vm7_+L|ADyī[)vy   xpǏ@&M,> ߶nKe{\"HPក#ڎL/K[ З,Yr k;U*1 0a=kڴ~bD뮻X~ᇦtGC: ψC9N[q孷+ga>hAU cP8ǝRF9WԟV yf\]p#sYg.&~PU2-:GB}B&( {caV3Q- [j11 x4caHHH P={VZYMPvWO} L Z`=ږ(a-~M7 ZkPQ3g)J4@dڴiU;JKf͚%wu)aq{ۆ,<͛7 0GoX,?cr9H-dܹpwuk.,k.$я.Lq-4h l50õ2f/p}vl̙SN=b 5j$;2qـ @ΝM\nRwyg*Y{B$@$@$ @ p51fuhf+s9rj<gU9T9%'N#FH+wC NbRԇLdmQ(._ꪮ|Ƒ T,]ub9p$@$@$@Fiڿ|CCMNvuî4.r@[/̚ XBYf2]:uI'd3Սnvݻd={7\נ2묳Cڴiu|:.ȐKˆRFa긖\Ap~-4pOa5BXVdjY>PHX`uvmgo%~3)K0U  ( S)`4 @i@Ggվj*/X~ 7q ͟}嶄 `T:+($@$@$@05Ĩ>hΘ1\q *Kb$P.ڵgyƺ<}Mǎޫj!@0VnOZ> >gNݑHH PȣJN<B$@$@&@{'2!`$l)W\+-ނ?DNG $=GY(y%ЫW/i߾5@ʸF'`NhHpK$@$@pOQ{O=ZNy~   (:j &M(A`֒kF8Д)Sl2d=(=6" 0TW@uL @! ½6 @,WU w]v}w?A4I l>{M$@$@5L \g+{BG @ P^ I8Ӥnݺ2thTP#FN>]&O(=a7|# $=G9M6M~'ZLq @½t{J$;(ǎ+p>|=l йsg9|!Co(-l4hw:(dHH*|k9B  @{I\&vH L ۷̚5w`RM.A'YrPQ$ lE(IɈdD (AD$*Y@ݯ瘞{5_u6߿-\B'N~ S pj6:J$@$C ZlVZ H A0Β%>SIz)pB ',YR5kfگ_?|]g#8eeXޒ ^v){W^ݶ   `w $@Μ9e6km۶MеB$r-z> Tt,R$@$@$` 9sƶl h";{Wre   `w $@5<"?f̘_/O̟?v(z9FpfSR&p=%  SNիWmg [Ap׮];hŁ ܃>(4i"Etѐ~פRJB.]d۶mv Ozt(>;-83x$@$@$nfb-/#/^ƀE K0A7#)3gWZ<:/CϽQFs.C{vȑ#ĉv P@(f);v̮A$@$@Npۭas /_\o= 2ȃ>,C8HHAr#Cm0EDDa={6ԆF!=)S/SsoӦMjtQfͪWQh")S&{9ee[  % SN&yYNZjI)$  X /Shܿoϟ?͜9[N8 +W?lқs\"O֧+^Rw-Q#իW}1˗g!njڴi5'>a֭,X0ɭ +kٍ~ x|W`=~#-[f;HH\G@hHk׮*o۶ ~G(T-7ވqf͊PXsͼyF"KJ3ze9s:BMۮx\CJϞg*;2mdFiv^>D_vGȑ#Bh$gs1o8sқs'Nm}7Pr"_ Jݎ[oغuk+9 edx^3 <&/*4h` *8IСC>hC@j=#o9;\lvc3lrƌRxhyL 2eJ{aP/uiCpYdHHHpΆe{pV8d~Q S5@HH (0qܹꫯZ2eرv>ApH8ƍ-[ZlٲG}$h#`@o2uUưlٲE>cۏ͛'*ڹٶ?]G#_|%$ePR60g$C.\(o$>|?xK 40 ~O%eEr49! 9TVB={~O=ލ/$h_tyxڵK^z饀Or:mJ]zlo^; )cwCK  L0,^vڶ @0&Md}áC6hgϮnZo\UQzJk*q]w S4ͮ8%e*(o;%ey G4Q{{U%=*3~x}=bŊCuFo>BězP91VZ*mÈ˗/{ +:uǨ ~ٱ݈?0l+ LNK.Mx%^{$H~H 1()z<HM ?]MҗP3=dUU #IHH7()7t&tqUl+2dQ:<Ȓ%`LE O>d͚2wq]|= RUu}zA!J^ U/#twY#G3b7>'sb΍w޽= ךSQt7O>E$U_iI2TRa ծA$@$@L2yQ,U!҃˔)<9PHH PR&oanO,[mGm+Wnl;PֆO:**+WHs=ZLd#1sm5hÎ9b6蹛:Hl8k 0AٳPaڴiv P2WHHp-o_oSW>  C)A1h\f;v찻^ЙW8a\ҥnӅE_|Ed᜘sΣ-d( 2etH@ȍ)S ]oӦM@)9GM0oȕ+W*.&,,b $;ܓ_:@1%i\ 0[JJw֡CI22ڵ 馛LSj(I$InygϟwvoۧN6Q:ogE_ݶmȄO K Ĝ^&Lه~<" Zt)(klԩ2zhu(Dl),LH%©7HH\c,,,4 `[nyg| n37~ڣ|8iаdDlDԻo.8"|ZYlۼy>^G>_|zesUSA&|۶m>L#GU[zv xfU>|خ7/ TXWTXV;ɓ'07n~@30~"r}Lʔ)$pN̹ U`H\/Я\rӂfaVi-*a KxFs7f;  VLp=Hr2id#/^HHM7ZKRP{t9Bئ UaP[oPz 2QgֻuEBϞ=ox#H 4DYg534䣬T~D#  ЙpWOahKGFJ*Cɜ9ԯ_c Iz$M4z;?3-b$Oƌ#ZAV4.8E~i{8q?6y)tAOHsm,osxY͛[}n~dpCY̦ƍK\tK-3k4)|N Ĝ1`޽۷a(|aRK 4lʺ8HH @vSͮnC3f̚5K5jQ$@$@$*1^Ї~嗂 W׬YuzPI<2@jԨU y2!@%zsJPp 1&BsUVtU.QD,iϘ1GG/8xFs'Cٳlٲt^i}(9i7A$@@r-,30x:aPyv,Dg$@$~!_˗A4P"v \;t K,ѿSNҥK{;RJ8YxH6|CȚl#G{I$@$@$@$@A`ƍ4  N@g}R'ھxb;+W[:%\H୷ޒ7|3FX޹sg4˗/ן Fu> u駟*blOH2Λ׮CN=ʤrdI@M<R$Lx @iz *mAJ;aH|B>"Uʌ3܍}J!Q/hɒ%KJbtݷD20s֋C!S' 3M}mk }!-|7Y>N@w@l E$6$ ̆&RLK.]g~z-[5%N-77?s=^@.X27;wNLB*fѧNZ/px-q!_Ru߼yԮ][-[<aH elS؎ >O^u=/B.;߬Y3]0]T)om]]E`Ԥҡw->Uљ!аm;o=Z8H@w>n7m@F9jX;ÇkW>X<ٰ$_y=w͛ˀNCɓʕ+z3=Zy-تU+A(X)iӦ2anIH\y4h3gc9^ϲH})Ss׳gO#ءV.&M&Mח JרQtpß%ʋ饗4?vX9׆kzsZ֬Y8 L#@_u*>|U\YF^P$̼3۹$@%н{w9z? (Nk^J[n@ RT֪4(/rn%F$@$@Lva=vC`C>OlȂu;NomϞ=+ԇ߿۱A CYov`;#*X.XرC3BBfL4Z͛7ׯvlCz۱qG5BӦMv?gYQsq/ix5؎(N mڴq6 @< e}߾}RZ5=}pԡKLL]2w|7f;$r!ʕ[e2yG1f5j$HM)zir"V,pkqA$@$N^Ϝ)ؿgϟZ+{$&vY Yߋ/!= լ8^Zgk;)qZ۶m=ׅHe_~dfB X|Ȳ?~x"~uGޗSW^"P]۷ކ; CFSifm&*U'Nus!wD|Cf>|Fwܡ‹X xG ~;T0"+Se[J|=gK &={vAQY̅M 9Y|q,%9sZ}E {/g_$@$@$*'O_Sa"g6I:/KTv;aYȽŋ<xݺu +5kYXCh#ٳm9ճG}$#GϨO>@!hho,1"(=~x})H #kARpa!ާOn$Xd{dT6'O)[ 8P 8N˫\sǍX ݂vC|HorG&t%$@i?̜9ӣ &Ft6 @p>C;i"Jڰ|1A+Ȭ) ۭK̹X"6VbE&F, ?S ğ@O>edj o#Qſ\nu&K..IBܫVjGvvg7؉s0wCVfOAw:IHHHpdt!_Yđ>~ hC8 $UbqMK!4d~c{TKl,P 7vD3R)S駟YPUH*3,K0tst/%J9rĶ 17>G@g ӛ!`{ܹA]pAP)a‡ڊI$ \m<0iC /  .I =իkPە,ECGH/:׌p֗m   %TBgMLBiA5VLlFLd#1.:$kժe~ms$:.[LQ[o…6<,p| >\^{\ӉsՌ] q^, uH yPz6?ٟejtx)'ȋ/2.0SĜm޼YkCw?YHj?AIh$?-)O0[X{j꫺*sAbF$:m[op EnQY.픮wK9HI L$@$ON9dE6þA`5lX>k'$N0뷞ڱcG>}!ɉzҢ' 1dE#n_v1ݫCPH$_ lP-Z%aPAmH@q$ӑ]< 1YЭ.}d:V0̤cR_~^;;;v*\x`SNVuZ+L xAQc2s5rҥ%x(z CQX7 wnRtT;Gc**+c1ě >cnèG@IDATDQ|ÃڤI쇜% @@V2C%{޽cHH PS+4yJUz>nmN?N’Yʔ~7OJYqU}Nl 3f̐FߡdCҙ3g Q|4!;|ԨQҽ{w'11#YsĈz_T{Koqk׮P߯d XWT鞄 =vSAv\1⸘PhѨN$;mw #%&VT6[ opi$@A/ڐa .#ҘZʖEeUtWYFL$'Tz ʖMB04$  !p~{*HeS%1珻7oLF0.0d&(1-Hj*9\#!<葙ެY3CmDK`; ҢxiP@)V,;Æ |AGc9rʕ+UdcɈG3>GBi֬Ye q@b5%Ȟ={/K6l(=zoWs$@7&Ƈĉc)R>@,) SvF$Ѕs?~<`_wl\F)"HU #Gɘ5!m SKg  ^2QƢUuTlT[hܹS>F4$}VH]tԹw+|yۯz#^4dסCŋG1 O\ 8۸ Л ?hK믣m13A"yXO̹zxq9K \W^P&>|>Sy̦D/qM舡5`›>h[aZ H ލaݖ-[jH._TzfzHHrp۠o]B;HHB%eV=#wG{, |  $ĵLW ( { @; lc(ѦMmI9sX-\ܹsů]Z$@.%|s깣:|(cj从bTLo02܍ ?h\ @`=o5ۍ=3KgV$H$|ŬC5j H iD1:to!]vؖ+znG! c'OԺ3$b#n@w_ xhMԖwFb%]m6HHH TP=Ց픓 ϦJ*F H$'g̘[r3֩S'ׯYMe:V}źhرc4"\@p *>}`Mj] ZNM (?rN @(`{`mGu_7 +|rɛ7R'wRzu9HA.{z/_F3IՋR©ϞIHMda3%L*U< {2חےIFܹu֭[f͚!tm`w$7Qz,!O?c!W\1\SVS} %%`ތE+ycn}^Znƃ@K?2em6OkYGnQA$@$RYjժ%9g!-wL}q*THTQoQ@?DZ /Uj=>}ABϽ|ꫯ;Ȝe_*Gg J.S$W7. $#OH/ŋXfՕͿn:vҾh^CXM,ufز}\l=J[npǭ~{8px\r$led݁[4apٲ @l\k.-ro /=Ǎ՗%KHmϫV'xB28v'$@AE {姟~ 1w0E V#K=f9{LZ3^9mUCJǟ?Ջ :~;ƒ=- /VUzI6YHHk(©F+],X@ҤIc[x<3,jwA$4bsoܸ;99heI*>p?t§8$5gC $; fEc/Zɚ5 n'o [yү'ptdV:1ꬍ=$U+Wm6HHH  "~QyGÖaeҥ!C͍+ܹs=f/-[7}"H<G2̕=tlnxx9嘭dw mF 7yQ@{lR[/Tzn-?w+@@;PϤ'Q05 &=">ھvPRef#4ThgBEϟ?3A%Kzliz۷:Ĵ;۾[̸b7t'JXX Q4 %=K޽ QoRX/ TH +xo Gv{̒Yi֚{챬oّԫ'7t@6~,ijxcϞ۶YUϢxc٩OE⪆Or:tJhWen9Joə-1{y,f6spUJYLȞݹ;^#o$X qɟ_0,.ۥ)|̝G 8^|tYrʕK< УGYb,_\{ =w~{s1JӶt4H_tK[H9^*^ox 8^ZT kڵ }WkCCх+WI^6m@/ ۵6nV9epҨV-X&fV]fR2x_s^[MZT=tL5[iԳmV䥧TQ) yOꪗu& űvuO/30?Aﺑ2OOEM뼬grh/ &Ι+vǎjSCt7voH~6{ 7NvgKVWU̜Zphu >hCiӦG έHI ĝ6gɒ%ѽO#)-q{7 xGz^~YY- D-XCp@ h-\lɮ~ CmT~Tm,Z!{Iu8/3/^<8o7wRZٵ+kwK-؎k9qB:<۹Kb*ڴ13Zؕ}N]k]r2F7ns=#HB3Q`2}]/qHЬ_>Cl_>T,z%PI0/D$sYU*Hz!ث$ZDH̄!ي-{]ؙ2+ h! c{“6f% $5dw֕o֮ӫ8qR% fa >{~ݳG]! CQJ< uLF%M EyPnIRYNz@nѣl;Ggtnkƛa/pdEy˿S?*~βe2h'ҫ͵L~ƈs5I0WS 1l۽[7X6 0fcAZ竏?5j r~Ɂ:;@Q VGʕS5RJ|ƈo쳘 i>]3|MHhTgy%¥/u_4vu=5u#hrʪD#')P\? wp柴!R}Uy 1S߷XzL# `!;@FH"PJ=3gIq}6ˇ*3np-$|(/'$eh$v;ZMA쫃ΘƍPfwˆ#GjIt5U[2&Aͪ)=-P@RL<3}lkDjgEbM1Ҥ3[ .TVA' xܝ ow mTUӁdz$r`t7r 1pr>=||}~˔^&MJAꜥbdY#^{M^ii]u.^7ӵUK@HrU[l%ihA#Τ׬"؞:Iￗ-#?N5kV4 =GE$*.)*9N =GyQ"3PeiC@im10c7\KY,Rҥ6DʑYULԭV:Yu=YG+QlYfvBcܞֵ 6n7FoXj272L^lyn;5Q:lzlz (xg̪8ϱU#S f_2eMSE5+Κ x*ԍ.RDN_uE`!˓gNہedl!d}»}FCRa^p!.A$* v @'`s\/*r. zPddcǂyq\xQ?a r:oN9u똦\DP`56wJXAJk8O,ul 7+ٴS2SaPT>9JV?& z$X-?{R]?avItj;MN8ph/G?GOV7ŊU-|ysg5i.|  p +,Z* q >}ZԩcRRX~GH/IH\!)rFtH"=?\g29BQ}`Rw7W|fWypҫ"(6yz1$WlqÝ$/>>C&,bƠb1yK\|![!Ѽb#GtaҨq )b-_5u%shXCؾCL3Nl'F+;,S7 !*ANRB(k, .!)uֿڎzv#AA୷ޒOǀ6m*^D# `&{0]H>e e=w Wed^F(/RØWM=Ǻ*>C_d㋽7G!}t@S1a77m2nlzh\/ ڠMuTK~;ylLs2+{nL9xWLE'_}%~ɮƯ{(VUiըm'۱w(󆺟Qekpm狌纟SN'ҩz&4wXzuaƃFQj֬.T̝;7'I I4 $=jl텑1|p*g0(m]o;D6MoΏ79+k7o]W߶ck8(`E!*>'//ߴk79i=/hmp. ?Qd yqj?@i}< V|cy -#ٱE },m{܌2H%C~EEg-Yb9FN׆K\b.-Ի:6o!/[Rc1//רnNOԲj2 ~p>~\o✹z!ƪU`\9gvU8~NIZJ"\חK`6,s̲P}^@9 @Xs3 @ %_S*/w_KnFƫ ] (h;#y`zԦF@#4p gSȍ*~ ]+>/̩8xLyzd l+?NuX)5S[}1b1%3w,ǽP0y5m%/nhXQ)q{?DT# j *QGaCI:jj<,ZZY^'8>Oo9r@_Ksvm}|N g#ɨ7^WKdω})u͝wɸ9:r~AgլT4 Νu wz's̑"E8 fǏ" DIϽb64vl2Eetsꎘ8Igb&CW"i5GeH- 2}"ɖbitM*ݻx9z˼٘>KTL2kC,oְ5RuDGN&|+m7Ν#}V*ߣ] 2Uh^e,dԩRŹY _/mDo6{U/(j c3}I2WO؏z1]P05)15[i#={!C$u"p'UX5  s? pUiܸl۶hJ_ fXIJ?#P~%SЪU+9s_U睔 m 1oU!M¥C؝nKFooE㴟 4=Zb%Hi|OԨ!W.[v}ItLɒ@wLVjovɆ9cn6ޚ:|:s}mݹKS$>,61ke؏ d_c~)"c8Ȟ]ގ`eh;8n7ğ>\*Srefhc'>,̀'~AScj{Oed26x8q5EO>bsݲDF{D# Kr Rrxc +B?q^R$Ʋ~Ԩ{I|w!3-p0\˽քڪ 4-8ƌcL_ݮA$@D2t9V W{u9iGi&Mȕ+WA=^Y84J e]ˮ]~LKw?}ٺ`6CVYHB!}9x e=]Zmu6uܓc0^ckX9Ԕj*XD$@"puXL͆,^:TRef#tEP( nڬrI$@!O  I^[R%5l?oIqK#i} ܶ { 5lhnx0  ?p\V荅QݠpuV6-@k9Rnno  a$@$sw's =:`ޞpd ˀpNLy#6lH 8d0L.9dΪVyti tRܹuSy  q /O$T!ooܸ=&'E V+hx]g#q2HxvxnI2e*S+X0A$@n O657>8d-_^RZ3"MI@6nX^C L4ik H|@w@f$@$sS} G# 1sV +Fs:tE_|Q2^\=__t} Qy8Y8բ`:df ƣvr SR&,cFyFW +W/THep7$l4kL~TƆ :$@$@ 0 DsիWP#޻M}oǎu6NH=m ̀xVeE?uIHpwmpjH9U*{㊻ ;ɬY:uu6HHb&{\HJzSL\33:~u0:g%gʗ~Ç'C/w"u = D ȚUUpx 5pb˗eѵ+3;-w0a 2:UV-Fju;': c؇}']tvlGP[nax9QYCl~dyXB}po-؎N+W F~'o   Ds/ua3-mU!Gc>+HwoO@63g:$@$@$pw[\ʕl w2O$xft{$$H!3~zٴiΈ ɓ'{_V-Yn=Z>)XV~ӧ@B&3l0dGmljI3 B!|:駟Jڵuxкuk&x1QF wpAK.ղɑ#އ&LAR:ףGI6>6Mb|1_U_/}q1H ?O  ,TTDа &ӮLPS[pA,~ON4dK5ӹ+0N-dh$@$@$pw۩21\㡇hz,gݵk&Jj˕+pD aSO \0˗Df0F&?'8qBo6mjvsʖ-+M6M#{WoV܇1FVS+3ί\gϚ5K81"ܬY3ygd_k goܸ\J(*f%@nRJO `?o H$7x1zsMuz-SwQ7ݯt7EM*C'˽{$@$@$pcp1#]?\`@P$5h-Q:ǂscGfΝ;w/>qdq )22ȿ4j(C>dCF3l٢C}gdVҠ0|?Mty0t3|= $@ tzLՃAZVɡ͜)]Z FZVwc @8yBXL͆\xQZKeA#ouƍ*UhÙ:uކ3OcٳgC+=63vo|ƸÎ͐tʍ,~d?:~Ӛ< n߾]ؼ z@r&1>̙SsAIcB#[0;A?HH {-WݻRDtS_lXLT% #ԇ@H|}JXl 0f}2nQ@Xʚ1GB6aXI{ G}$'?^^{5y+EcٔLGՅV7o : QF97gd)2!cI~Q2.b[W^36`߱lQu^ nw75ktaCwpg$@${)U H=wJ'뾆 ;)9NHK5N=+a'k6l&ΝOlAE@5X zwq2LF =($t-jw!K*Ǚ=P}/7o^|O! @ޯ_x"3' C yZ#5Ǝ?nǴD#FxJϸ|)S;v1 .?e_LpW.nUoHH z#<B=X Ճ ߯5\A S rc HH%euYAJ1cU=-޽Q(I{!K,`;-Y w K ?81^P!I/'!xĨNϯ3!b T!YQ3ġ[=f+V,K`l} 6, Af* Y$dA`Ǚ516_H @@ 91Y`5X*iUvx|9уr0=c@?#lw@^ R2f4M.D`ѪնsolN Ub rvC@1H@ %[^';vҞJC3E2}h ;y)PfعsVAidϧOju$L<ߵkAaX1f v'g+ d  /^xxs .Ip%mE$@> ?hFs6a#˽MAz"-nu Yq/ u- OyzXeD%fLq6(2ׯ_o3Q͘@IDAToZ VLw7F$@ P|y=w<|#%X=E؞pdƌ`Zv7M.IHH 8ҥ 7 rkUS#BݘKP0v:DMԩS uf7tōPg 'O:ue xtv. xCzN>}?%\{lQزQJǏ;g~C$@$@.& S7jHZ*٤{:9rDի'lXc…ъ_ $ޠgL׾նkc?$@IGIǒW" Q{JdA1XxCVY %^,w}5@9Yp JʸF  HNs4h"{~Q2^/v1q@il*Kl%pE$@$@$lQ3Gٓl׏t"ϷCZnm  =f9{$ ԩXBk9WXQʖ-S{i#{O_r*ԱEsfn'X|qN]㏺+N-$3e$@$@AJС2nL=49 ڴ[λJlG|köd*Po5j >ܺѰaCyw:$@$@!W 9O4IJ*E}Aʔ)I_~Y>39zw?ƈIE\p|v,{mۗjoj" H#{v]4| b;}Fx-YDPc*7i$@$@%Obg$@$S(4}t]H :tH+ @[S:t@!{u6" ɟϮZRv $3gXŲucwիWu.d۶m&MXwqI&MHIHmpw?$@$ʕ+˱$sz=&E }xT'kz /j:M$@$pw}_jufJ̮4q S;wNw6mZY`ȑ#:IH"Wx0 L?[k&ׯ't/XRnlٸF@y!ؿW#v_   'Ϝކe li<;l,UjWl\&K.I,UtiӦIɒ%G^HH !pO5C$@N׉'Jn|!iN 5VM,YŽr07RJ%yr洛n`HH@iL OI,oc/gUH%y~"""iӦ?ڣ 6HN<)͚5{G.ӢE$@o$@$@IFWR\3e5o<dBu5=~q_B==pW敃3wL  }Mٱo:4¡מ)}zANcgƟ*i S :l2y 8dʖ*%w.g϶}tQڷoo XjL<9ڡYd-96|:ѫsҵk$W`+n  Sz3IkZ#}h" ɟ߮9nl @ m͆ 2w2#JG5eI;KHGK?׬cE, &kXONyѠ$ߝHƍ'_ 9sȱclkKF ]HH Ȏn:/C:mn<ΆH|y-dHHHVkvwTyW`-[Id$!BlӦV%n;i$-[oUz)ӧO3gjIoϞ=O7\璀 PR]|ӝQS+_SfffܔMҵ}zJ;q'j[giƑ`P@@g˖M@Ͻvt…P8{Ȝ"KtTR%Z*q`LQ_~ :YyP90#8S$ĉ,Q"Y`%d! ¸bQ _  7oޤjժxK( Aںu+E%c|UHLy}Qj~ϯ_~C{*v2_͟~bI,sc}Q bK_lvK.IFЅwށ%Fi_|m}"˟?D =xbׯF 'bMEal+ p#?˚ ϰF^֜w@?Ϟьe˜+vownG1390#8 5M{ |Ґ;yFB};@pĈi&}6k+WEƍ+ V&LrũN:*U*4i :&Rj-+VIAD%Ƚ 0n9$}1N3Rr!Yre~ҥKG}@=xxxǏ ȶcVZToK*%ۏ` #[bTēR50˗/U6#t0t0@ ѣG=^t%6XوYMv/j2K=za>3#8 *MW &pu䨮5vK|MD`4.]*X+3N>gkgϞ]pWݻm!WyU]jdȿv횥]2ɓ'9Q/}26ݻw d2=k,IL[:3Ph'|pmp` `n Gxd`"2ze]#|tB O͟?;~۶ -X> ObZ嘹sicX7LkE;>/)l#4ܺEkwgO)V2iʘ: /H<?ބEV1 :=v~ۋ,L <a_#gthѩx|2Y3=wn><#E_;4OF1[!pN|4 WQBxx 0J*= &gÞ;wN~h׮]rDݺux%Y̙S{1A8oڴitex?#AwAs@'4-6h )2(!ݩS'NH 8+&iKS31UY6mqƔ+W.5ba05iӦKҤIxVKIHzB*Fd&Ey :Ԥ-{B8!L;E&3#xzzsYʼn5kJL么:i40j݋u bzvaÅ58zlI  /D/d{c O`hc5ٓ>V޽E?@"¶̞M|׮SL[촃Ab&޶m)Hv[w4S/{6Κ O˗/uhтv9a_@CJ ܕ@Q/Y%%J}9᎝DL,۷oCc?c: f͚a4x؃nŎq e$XVK َsNZHC#30ďڶm+ wq <92kD%e\rF:zZpV=Mw iT_F3N|M0 #w; #K*ѸݜTtah֒(gjr0yC؂@"Llg~@~Wd !1L<3ARdƌjסWlKHs%GUeY lWeS @ 1)S$|3˿H"2+ܕ9j?{ =P:Fp1>fݫO"=X"GD ֬叜+vmsn;᮱#`+u=e(>3[L~yuCŴiϘIwۜp,.EE,%t٩5ǀ]H X*["26d[ܵ=zԄxM/֮]K a =Fw@ *(iѢE ){5kJvK>8;|v+gF F;N8!o$m>1٬e4aBzD;a"4ٺa]?}c^/;* /Def!,Uo\2Equs>&MPb]f2.%dKj#bdIm,4ڡ m(ZhN7*~M95K^)ao/։X0h*U WӧO=F&0#`޽{SŊ~L M)rL"Xj=Z)hќ3uîmg/_@tоec8.4UU Ν%ŃEB +W&'/^X.8ߧb0W|LRCZI& #_` n{yIy/`eDϗK f%JD WGzH;wl?O]$gI͓ŏgrGu},SNQ"G$Pi^ܶ<ErPyHnpѼp` `)#tق˕+GoD Xx>ɓr!DP2r7}%W^go+_$xjժRr:0xۗ-Zd1Kv@mK tbgswj[< @JJepJpwƍfF t""!^# r/Gr]7.ݸ)k8*mJ @!jf10#U {PuզɺAJ(/@g Vm]ݔJP37|ϗ]IE<׭“(5ٲѐN!Z1=&E B l|e9k6M]eS$AΕf$^~5`]6BϵnWI ~ˠ8GQiMFuFUU&AS#lAh=&m؞=F2&H^(}vpA})ܺ/X"3}K&#:5jH76fޭ[  u`AZpA!=.nQ⮸g͐>q@"]Y@2?#|j֭[ޯYy}֏=@޼y3A"Ot2hPkz(S;ߺu U ^=f,``Oq?дi x?fVPe ;t@NI>|Hg ( 8v@ ߰anZ]Dє1;wR ̳6ko A;Rz$QިQ#ub IA }5jE@boi1΀s7FF`A VTt\xF8*XPxf)ˬ C4to9p@$j~,!Mɝ -pd/TM +W%[%<ȔկTQʉ|T6Gw/=:|6 M1f$ƋKyVy*(d{%hԩa{ «|&.?D}ig俉]Qa?ʡb&vs=*SmNcel$T.p gF=ܝqFE8;r4g*߉4kWc:=Wx֩P^oCreS'Mo^SAޞw5S)DRJgFoyb<-yZ3p)ϣYeLx\*ܑ߷m:M7eݽu֨F[s̓{49iʬ;,lCXNFC9 $#d9؂1 P $5V&,"6 Сky̙h75!UgAA2ƒ% hB 1cJ9" lժU6U (a@K ? W0@( CL_%<ySz!;k*T[0aьS!)0#cIDQ*4?r*˄6lR628*@xʕ.TPm 1mhN 3s&J2LV+VjVgd/O7OH[OYX{لU!"/]F'!l~hVVGVmcM猣0wx ,b.߼EgbپpHgMzs~qM%U,J\=ҥ K$ UGT^p!$dxwhT[ <َT>$\y@рkp.>7nL+V$Ex?H 3&pFp0@VCQsWβ޵J j ¢qK N0B Ŵ@EoϜSkTDLV-˙Aj&b24F^ݎjϜ.:L$U /󩋗HB A+nCG,7"1(T(}yHtW$/"E& :;&'H-5!~8Zcy#lT>UJ*Y\{& /ș˗K" @S;b&sChPb0'(y4mgħN)Q=#o^ЯC/f :W/ *)j<\\ v9򝈱h+t ny0Kʄ|F`\N"H΁F-< BY,USLN "F,]K;\qzv+ 9nÂ*"ʭ]*9X1b[ ogI߾fQo/'8BCrt5Y Pg5[fZ]?idfï-SK?:?P2!⟥LTkE@`r]s],'@%kG+]ِ3A+#`"'cA(gp>x~癀K }xB/ɓ'$ŋyy&~  uϜ9#u]#(0(W0!z7o$tc@][/^IO| 9 rv9 WVtUE1}=Udz[%]Ox1ڪ)~#"AAH!CQ!Et ne nG͞CyLU$-1:e Ĭ_H%X!> Vr>mN CkI]Vȳ5ߣ6#\wO4hq/h`߮9B*)CJ(S:p;v*( ٰGu,6ŏG->v`cD*LÏ=!MI#)Tv!!9 @bg˖V{\(U^˰7RU]h'7R+VZ{/<' ]e:n|AM+w]kN!׶y}_Hg^k~ekP J lly=iFlmr'7?'qW,oސ;A%uH-bAM)%pN*U+v#Ō7n5H"9iϸٌs"`9Э~=oߦ:t[q#؂CG-:J-[PQes 2|,GiZn{=PI^3?,Af^ ~2ƠΒ>LW:h`l7$!7d47h^VIL_=e2ukLN\Ӷ$Q $5C0mK?~j0TH3\TIwxpA?b;!a!{,:݇9 #;MӬY  dӱ\2`r1 m$۳fJxdB)@yŠZrd׌@("{( 61w@(O0@!q)(0y } ZV6c2,Mr7]x1@ɝG:r,u=Zљf+ ͨCaPg:xre/hДr0y~4bjьƁUAJ*If6:S$ijAԢo?Zv6˺ZǘM @q->"ݞ/{6"VA+ !4Sʭ[z6Պ#8< 6 e slaY5j#Y N@A===-2#GRM٭Cb@:\ccF`IP [} 6,$<.qđ㴘6zOIL[} x_N^ȑ#S21MZfe~rh!4ĉRL')h !O&KYB]f\g\>}*_|kwBΤ޾A}x={J(4X8j\z:.q硗Ns`#ж^]ڴo) @+U$…'ȏSԥK%K Mn_2\[>=SVPau\3W EܯanbVM(|ɻ-!;wLSN5]F Zd $7F0/ޒڵ#W;XMhcYڵuvrhΝ  L"t-n6kc`CH*osl#T8/_>, {۶mlGDÆ iժU&k?bФ0o0# | n  C j4HgϞ]lG>>ݻw~#& ͗"%'>!o?Tj2'QA8o-nݪ6xhљ(Oy 90N@,i\Ϟ; 0jw0RUjSk{L9pܴ4So`FWn9ÆR$b6!-' kfN6+b~L1N&Y4ɓӸ^=ipÆ0z ߘ/LD=quhV3iZĦ= lb_۶[ US-9]Zڿd1]شb]HXpyp~!Ӿ`2*צdL p^v-e~8iYd{1#F _ȟgXh5nXW|UULu%JH? 1 A1 O>^+Փ,!6tnj=z$19˜93u֍ŋ'AxӂL+(/|xMV.;x 5`<-4 {w#@tRIc?<'N(ﰂ X@)esXohMJlc#8>gOk;k5<%<@b^6#]BhfW.[)[Nd[Sg*3'\ԥ1΅- %ޕ<~"d,QBJ.dB@dbH.߲,:HmТ CA@+V4AJ'ٶW1x?1"0dT<囷(bIX*02~FY,i\` ŋǏ2˟_ c{[pyp~|po+~G<{l$9C]L bS7*WL[lQY4{ljsי 8l 3gΤB`Dx'd‭t&!J4"܋-Io4iRj$޾}ۄpС7N{IzQ#qCIӕsٳRcx-otxQũS&w 1JO~ َa8 ȺҥK M6mЕ+W4#sVsӥG=G24leٴ^>{X g.{ߗ!+Vµ>O)۰Vf‹7XxwDHͿu qM,bɢL ny=ڭ\8~&!EU 'jXE d;fx3J"gXrUy\U׌#|oXR{_@/WMIF^^^v9G!H|0x,M#l7A])$^W.wi gs˗dGHdyvgcC zԨBx0x*R)g8CoG y.eGϞն+Ӹ% N0!"?NX^u 蹹rF`lA`a_9¹rQ$1:3f̐a A4C}ҕ}{AyH۷,X QTݻ 0io2eMHiܸ}̓'Om'NnϞ=AaPڸq#U7o^?tޮ.-Z4BUWW׌k"=Փ'Q:ug/_Q=hdW9btHw~$s3Ĕ.M8bSҦnnb)#DN fF`QNۭI8M0|^y [?#п6lI685kXp&;Chׯ 0[ x1F ߁/A@Wp0XPO̙ ]zw2ZyO#F n3$8/JtIMv]o@jnPQw<"E >˒3`ù WT LU @t6&SYc=7:Ќb@mۖ9E<ܰX31ҌΒ%K$RS3s1k#S܏I|^wDgsO$ S.^"/ALЀG+W_&]JsF`@PǎLk(tD'LHO8f;iժqYdshs=z&yA&cN۷oٳK3gΨ"X8*|>~;ƍKSN5kpl"ypQAW\ǦMJH>Xb,7dɒҡҸhѢIӘg)zlI)x/_pO 0>FtjiXӌ#7ЕF“8*)g Alj)B7JM 7ke˖UU5HDJO2΃ KӰaCe 87XS7AaƏA& rpq:4l@K׽ H9sVo;j'GI6"4v 2 #m&L08A1p>PYؽ{1|8u 0Bߚ s@~FBGwlK$AF uܨ^x!Z2d Ivc@p㾀 A I&֦"DTawz50#0a|ۋoSH`"`Zz"?S/3 m=39 |81u \/_D΢.)|F`FaA O'@IDATBޫaMлV/?SH)SL* y5jrX2?7,a„ԟl^hC$(VC2&\p~_l̃$Wc Yr??@Ōh6;b>}ZLNӦM-|#0W0@(!m@Xt)eҔg/SB5;Q9i6O%-G9 ݽsqP$q'Dy۸~(C 1#0@j/[P.PAgZwFѽi˶}"ii?-͛kl@Ν;Ir{9S&MDx2| lذA8 EҥK)J*ѬYMGpQo凔 gϞ<_x$f؏5@NQn:u0eAf!/vZP־}{hAશUȃ|TTD wlhF`92}c##S>cx5'-Doﾣq*Z$C7J:&b=@q#0"pMcaGÑ0h ޼Y-BNGmرcgϞzf+ IEݛ s8p Rڸqc'O4c :!KDrܸq}׮]N" h od3˗/79&]trPLM4ۺu+͝;WiExCvA]a}!ېpt L Y>|I@ŋ˺J,)b<Ռ ~4HZZlY=w}b0C'JHz;wNX@ ͎ͭQT;M%CQF ?e0Ydp###mcFyŴ2^uwׯ})9;g]ٹsWhj%֩S~Ý`F`wН-SNQ߬E/u+]=~}5(VH_e˖6VlȢ>|6lH?sCʥW^ͭGt:t(խ[*W,=!o޼R%K,s= 29r H(C;AÃkxzz22d h'Oܘ- ȑ# F৅3]-n+#0.@hQiiZWԠQWsϝ;+URo)DJ.&^.k0#05>|J7oӻ˖)a-qC\A;vLڶy@֠tE^Z5--*߿? 2Dm:D1Ǐ/sH$s $52^u5 xU| 5seΜ٪w:90 C7nX óf*MVZu1/A5Pv-)1 uZCCÇr00LpVuptpw+cF>|t1܇F7햺wʼuz.qR%իl _|'OCt2#ipӗ;0 0(=zwҁ^xM&/p ђ_~%Kk`Y 'F`E۷oqݿeu:,%ZKCwZ5ˇ%˗/S| jԨr˸}QC\ɓTR4iRZl5#ap?0]~Y c\Ξ=k DVe LFt1t^av$J:vhO?f=Xg:i8f3#0@ lH"R98v9<kP 򆺑8t rs#sdrog<1"^[4|iT 2۷-{^Z~۷o^7W0oe {֫G;xևiĨ@2>`Fpjv<_h>Œdkn~.,9aK?C@ǏKG=bH"ӧOeQո@b]0@ `=` - Ox,4{Bl q#kЏCBd{mg,&SY"`F@^#i~W8 )a!qEjCw5U*7ڰvvtؘ5kըQ G,Gt1!\eGepUXUK̘1]1FL0[]R~ ztEٳ'--9a]n|<#|?6D_;  xo'}?tԩtMw ә`F`D̙Ժm_JeZzEWl۾2 ;e߂R-Wo8Fhm|3zP 3 }"+S0 ,!x$ITÇҥKM)SRܹEpmiߗ9ҥ&[@[fW|Ki`OuLB2gL)R DTk22 ,F1Pz VJ}6O6XiԢUo٤KS-Ԏ@#Mj_ǏK%k: VL/\ӧϟ)E2ER*_Y>XAGnNw^|M1iZ-z2!Bx1Qbt;*JxOsq>owK7dT._q߇"8C/Na@G vl_kn^ݰ`,W)zFvߚlǽ2 ۶mKg6)Pn]nR7FCwx(yxxЊ+˗~Z|TR%?ʕ+'#{cО2e 4@.à7zhܹԢE ڵkC"VXRgm:m8z(! ,M6ȇDLbŐh:t_FC /\@zݻwٗ&Mŋڕ!wv 8lhSj׮5#8JϽCAJϽƍӸ s֭uchӆ4&YDc}(\ .L8Fga\$C4I-\/ yPX1-q*p6I6o߽Hܩ uLx}0jTK#޻X-{EVe<* `I@޶yt.% %`2n xW^-mٺOEKmp9%-uyNOl"TTa!HxԨN 0@P\z@::tۍo &?c6F8^7oɓ-{f͚[>vC:a َw.=ñ}5ʘ1 n$ۑ6:d;SSkv)jm7nP…-8ML@W#nӰ2h;#8sVnࡓ1fİ p?-LT7ޟlaçQ#ڸi7)^Gw)gJr0C7̎'=gvO4tTr/VGl8_U п 5 =z1v?dhmbǎa)/_IFϤEkS9sBp#}QU&tR#G'2no2#pAܸqiҤIc|(H7oJ ȳL0ܹsrjn0Wx{+AjPBR%AFta͚5gϊ8iڵ~@灴 }JƨQʇ'j,x"?۶m6mV@/-[H|N8A={;\^8СCիG8qپ}; 8P#8R0uw']ȕ+nN/f z玗3w۾q2+7Ӵl$jҸ~FxZ*/bA; H^A)RD;ӇwWr*Z$%!R^'wp"ؽ>gt.B0l6FwK}o׶KRŒs|g{׬Q j'4-Ci<0~…]gr`FLx#DرdGQDŋ"y~s'MT6JÀ7n[dI},x@ƨĉ›I>8_|y54ډ"ɓ')}z_-X A5q2+ٖ}ԩS.*9a uԄ#yly l麢EӖ&=9 j<\.  XdAei F׭IF[d&NgWH̙3?~ҧ3&ݻv'FֱxgȐAʿ!RF Kte~x" վ\oynË22YfՇիtRSY,#]ڶiGD#V*z-]Qm: Tp鞀FDCn`ۺT)Ra]ySUBE|cFIz/ki/-P%C] 3߾"k߁{E:F.O UFj|GWlfBDYU4J$*H1EB' u)nTZ+*S܏4 .[8QI 05Kryawr-ߩҺSR ^Tr ʖLS&M^Xx1pתxTJKʐlj>q}E~xtA פ12t+Wm)#i33) o@EץFML*U,NW< <աӘ9Fq~K"Ǐ^i|w>$w@17n,+P={X*&8ጀ+ 0(=wx*z1B^ʺ޶FBHM kX x+1\|1#se޸Qu= }we6*k͆4AZՄTW$A$~Meۼ~ٟ~^^ɕ޻oM'i#_|c5^*O=Y~e!ʕ[z7mΝ҅Mm ^(k{_&͂ii1མ#wE:v쬟;B}ǁԶ}(brr  `+8.P&077*]߄9yP*)ӽ[K*S]kÀlW8]=]|gz7;uB˖- *p mt,hW0K {^Ç "ț2d>}L\:|B:Şuջw'ONjOx0$8* v[u13fH%{FΡ+߻woڵkԮ];Yٳg~`2_d;}Ȗ bM|Xpֵɵس$#Iܱ )okVRIR I-ə>}׽F2s c7pJz 9Dr"˖{7m8Wt̑|b*[Bih9Q:zh խSI )"EKC{' >U` +8g|dݥ{]E'نΝBR8dYjY^uwnZ3vkҦ]:s)Q/a]AxQ7cft079A|nsx?[-OXRyQD䑌#[.(~_3*XBx3ftu^Cfr4hɯs59|4A?V8xFC_'N/ˬRB{i{M ?Fb3=*\6EO1AG jѼՋƌc ,y\FEKMre"M̌"A2C"Fhz5[uHp&12͓FP> ^܊l7}o9bV@@z aO0~BՒ#.`C"s[Dq{pM]*Q=&XbI]{ի -6Y~мf3f̠Fe0 xw9:8/ޑSG]kp!a$N" y Ⱥ @* c4Uʇ1$[`^~%fyi?^TDAz2:}EJtg4AIA+ @|߇%Ii|p7dVY8$[Ht!XTnJK4)dϞ' t1 'j_F߿k>IWAmLj;Xt Ul^'Hd;* 5ynO޼uژ+[3֯%5dϿ 8#`MVP惓:6:vuTH ,p>D;|"1KhwcF`#]@ 7$ HoxLj)@+j!v^|9͚5KzCZD<$bŎ(-[&MHMu ijf*=0OXbk֬чݺuKJ 8+p^=#E$Iy @_x!qΐ!]N05+S tp*ix T9dT>u\cTHʘ?|Dizy;2.^NS/-xnCzMET[y3) ۪UJӸ1}d] RZJ  椾QD7nxɡLޒʫ|K(/n*gl1ֶ3^^O)Ko k ѣB,3 x!Wv ő-ȴs6w]3i!a7aiVzMu:JVNٌD 17cG6v+BΪf:(1nl'b:eh7Yex4iaf9#0@`=x|tKTQmŊrA@[2ǹ5sK#/mڴ XCڹ0]!-ۯ4q|?jaܾF^ N2S\H(r8@&|޽]?YAM:w$6Ъƴ%K7Mzzgo2ƀIqiAa*XЀGPT负5 Ij,B׺U=V8}=~G$`HO LdIo(a9r)܀/T4Op\݌qƖ1(diyA&h_%Np濉s(Q"*1k*YSxӅ%EJ%n'wʇռGQRd3?[={Vpxcn Cpш#:la#؂tAFY];n-Ӫeq lFhiH!hBBAe ׇ6:On˃' A$a yխdn^y 5$˗+J7D9JZ9TZvC3knJ";`Tic"aAP-3&RL6'6U0y:͓]j;߄رM=qq{{XzD'5"wZ1y}[zU*]4=}TW%Jlbt'F`a ӽ,1I$h"8`gC`t^ćsxnŋvBÆxP]d;@rvhIH@!&[!`ЀG55f<|ԛ mn&KyWn֯j,J .Ǝ#@2F!)S:4nT( b@+2xIEV6.X%{Y9}6zdOڶQbgr0Zv>Lqp2{U0=wuWN7K^ni'qkZmǁ^tiSj}}eɮƌ]d3Mk@ 1 Ak,6~tF9HP I.UX uϡ˺' d"pQP\A۷Uv߂bF6?!q~ubǎMkצ[߀ n#06"ūWLӡ_|#HZjBXwoP}DŽyS]Ӯc sU@emG)Q@ w,SULiwAƖ %f^&̭[*&=5g 2h⡭ m,aB_}_1on 5FLf PZM <8َ!i6uSICN A7kSgVh1gmX ZĘ*f7]y!!]P\ss^*7 .>|42/^BQ/i=f,WCp sV&xK9EE#AXT ޭ[Yv A`|شi(Q„lp1&}a#0vCknUrE<0]tq +;1#J(=w'JD5—pǿwLxػ=0h,&k}WP,Fv4q|Z-A6 Ap;6sҟ~AZlz(,QgjŻܨ=y\I,qSM;FS-*XjJ%ɽpYEUu"h *+ y-yG;``"}B"$^AgKt,^8^1bD#7r3h# ) H&>{$ϙ6$u-H) ݁K>餈p#\Vh372iQoTDpIjeXнyB/]Aճ0w e )‡gp/LFe_ h*0 v6_͛GժU3ƾlٲI4$`F]t)S&j`D{B;dw $k,w\;wYNLf{5]^g&3nÔT߲iYvMi"悱 ߼yGGN5ndՊVaBǏ2 ,e<5l܅@B),_jʊ4OlKN8/;BJÆt.|8qVW-,k: ;L7huVݾ}_y^Y|+T(Aq3YP'dP{ǒp 3Y`;LtbE~|H" tV nf0arA ]h0D y4n8F4,޸zְP-hBP[c!5tni!r~uJ\G# Ps7.d"Nxn7I>ϝ!dl9n\e:G6J11( GOB ΋grD *k@߳gOd{fh޽LǚWO`" d"Bl۶S12Cp!Cz왬iccCWA+\`=TTIz.vAP-UŘ+W*- S"rNdme V]/QF  4W8~xw9غ#ݽ FE=i+^X V9y@=%3ٳQҤ_#H|S ,4!u`%izSRpz6"2S>le%H@IR`ki QXEܢEE4? ɴ A+"d(2-, ^א:q℔C|gWEy>&'L͋ c;5sU0|vZ1*Vi!%6l@M6 A WZnM7n4TA&0#_wL w3p2#*+ᎇ4_OˣGʒ%cF^^^l֦,Y2rsski|0#q0qXk=]tuFժU… SժU Y'OL^#0@(XКfLr8| /6tp7-$>&L1xBs"p![Ae4q ڝV,F7ZD HF`b%E iOϳA;vփ R^RFF# '-[6O0@E vBɉ, vZx"h޼|^'N)RDX~x>r6l 8ʗ+N+T&ML ݇,;ϕL瀻'ݹw5H ԧw;">>.>0Wod_~E(O3r {IK5Ԃ[z$IӨ ev8`F`8ܺI"O{R:%A:0و#wQ̿vyy^ <_FL=w"à'={vz׳RLi3$l?cu_N@F*^8ʼnGD9{)]vpN:5ɓGh=`r9uҤICEgS|Q.R ?Vϟ/teI$V>}_j>\.ܹsS| ʫz8cD=cYv,#UGQ#吔Q}#e6i3ܯ۠' 37<߭k+=wPvÄ{xm3#0XiBN&mT4nL?'mߡ;wKLM6xb>0#D8JѣG5kVItϜ9SN$4hRtљ3gd;dϔ)ϟMҤI6*V廻kokk+V Rb5VAWZEiԨQPBԪU+]\rr+W;}%rA5jԠSݺu%J̙3˶+c[cD:uv7nl@pcAJ*r| #lS" oݾ(Hv`\xA ǏWMjիWg`ʀ/\ó`ݺuF !Х 5oVW~ ŧO)u|?~naM?Hgii!GX#0#>{y]ǏG{ӝ2wl$,֨Q#dAhٲeLk`F j {8?ǏӃA 7gFW(eٞ<gggO@WApFkߗ -ZSv)z mڴILG9 5%E`=}S򽼼 aJBO߻wRժUp˗)(2( 6F,?A4"ϒV!>GoD9m"ʖ"mٺ/ж? LxhҸ|/D%K nmF`F`퀧AVFn߮$ڱ1Aͱ UF;wԦ];ef#DpgQL:{,0̙3G;ΝKG<Hnnn~ @IDATZpt7֭bCeڵR>U`Vl;{A%JжmBHvGGGBsezRΝ;6xј1cɓOWWW鱮K $͛Ӂξ}`X(_<|RR23fiذaYrϣ^zy={fΟ?/ǎL7 XPkh=Z3#D1q\!G z6hqHgᓩn&3b*We4dXp o%16^0ar#0#0F`媭Tzy䵇/$vYuѵ8a~5vZ]fF #ApK½Gf{F:V䳱Y[[3[A XΜ96y 7\J`{dmJ.djAࡵֱp~a'Ok,--"tHYfDuE+.&L(ec 3qD!CZ>b@_pA[|PXL 0ɐ؁#1

,Vv+o͛7SUF` LGCjҤFvL/eWdJ9[lһd5Vq>?,bZP $I"*={Lh ?'^09sIiчaY^_ V?AE߼y#SUCh2|U}A?]ܮ7eoʰ۷8`{iHn?~B;xDw^ZhS޿O#0#0@D1ڵkg}B tQ&ۣ# /]Dݺu1&x}6662.BS|1+<qTT)fMg{8?%=fgy\d;vvoRŶ3: tQ.<ׯe@Py#ö4|pCH"/_>r =Zdm۶-YXXdfi޼yFTȊ/{h!b:db5'9SNָ۷o(B;wiӆeѣGfZ7Pc:5vrxC~ل?0dL2I|0?B 7־>|ݻ'1.L_4i\]] |o޼I֭;շ׌#y?{(Z2or1*^bbetM3X C=ʝwg2#0#X9_0~w>h&\xQr) M]SE4'N)Rkڮ_.뀻cc&Mm9::Ҵi r@@k뷉&S Pӓ&L@{Պ:$Y6tPF!wޕe2ϟƍ5ftֲeKv h D9wxRd6||0":Ʊj*yE9x#hZhA&Mӝ;w$>` zEO+WJ-ʕ+k԰`53v^^^KTH!gF j!Sأ%]8{3#0#nv8@[׮]iܹ ؇끻b "8QӧÇҡ2kp$)c@ ;I9.;(( d͚5@V^]z 6mZ}Y&Ν[$9p |sm/oe yزfggGJ68>Q}+spp  AR -7A[W|K >.g,r` 8URE 3gN+Hߖ*6w.w 蟇3#D.o󧏂=wNP+ԪߜqILf};Mq9F`F`(vc'1َ...&gF){쑻 -4uM6}||4gI,Bג&M*Pl`cpK4M?JDvIXm5d^pEsYw9HmYiŊ3^X$ѿI27tAʪƞ8qb9n݊7I@$1<|~1!LC@2eR#i9F}&=yt2ZX;(G\=yhP 1#0#D EdCU߯pҥJs4F^ϟ;q hѢ. %.,4uU{zp\y,Y4j*ҡ~\ J"L2,K$I4HU yhO@X$qDžE/7x}h11O8oI?7mp!A 2AEV~F)CT8"AC/a GH J>%KF j0-ozl# ! 74jIw;7iri3HeCR2{.Z$uoS_Қ;#0#0@F$$Uܦ ,vA9sf׺uk}"hy U@n߾]WCSW8Pذ1ʖ-+%! i^0FxVm4kLSzxxhNO 2dJ`'÷lB5RMիGj۷/z ;b ,ľWȗ-[F vy={FL?=쬿}AvhꢡEI)]Sd;O:% M6Itَ7oĉ۰atƄ< 3} 1d2/_6 MAyؠz/vQd;|"vaƍ3(P3f?uu ,6 =fiƌR$7H|S伽,ҪU+ ƆI[nI|2[bg-[x/IV[(=Ƌ^6Hy'''_ӏLGg#fF'X=h4m?%ԱTZX\=Ʌg Ϳx2dNfF`F` @V*ˑ#$UDdQ@Bd0VA"aÆFȑ#]vpexz锠XH>\z\w3gNI#^Og%H>q^Z q~&Mx~ 1%KPϞ= L+ g#Aڣyj;*sÒx7@#U}Y ;v(o!JSqqWǢ@͚5u&c8 _E%e3#ibIUFj}z$;A~;v)v@XwkIsC=ܣ33#DҤ 7ҡqdOz+F~U?E[ʕ aG@`v)^ː)++Xxߦ.V ?n?Ri.t l_Kׯ^/(%elI֥\F "wڱy7]|?|B_>!,QFΛ+Ak:sWҤIlRQn< F`!Wh9 rxW>/zu5gJ{H+p ]yX…v1cF:r|xkܨ&OOOzJUg+|P ;Lp J].5`=j<#0@ErTt%1q_9_勧teʙ;e(;k==zpWV4uhWhpǂŔqkH}k}kHd:Paƍ+ ,@vG3^ŋ'h^H7e RrG#ukC=4+Sepdy~Pgm[ߔAHTv߁v@-f#{~<;F`0Dp2yZ(HG jm?}QJ5Bp`-d٪$Yr^]oܲ5{N0~d;f:g!_sZ=)\ fo^^JZ؄ j*Q~:_.𑎋GNu;7ԱuOᾞ^)xرϯ_h̘1ڌAWP|Kh(B0:uO.u>k,mLe;t@lٲ8Tل =%KeP8w bz%UdR]\-rJ!n:1}ڵk}V-]Dbnݺrs!UL."Pʕ+%vO<佞]Ǣ [E0Dg#gFD v5de>ClW70U,DiO{j(Z xA]:R]5p.P(K l_|MGCnGS?3rsHֿ{ۛ矠V qo_3CCܧ=iƝqB,L>m\` @vxn߾hbjq N1\#0 M2chScq\zu/~yxVVVc!{nllɓ'w<{%={$޻v i2l޼yԦMo( *U5"70 vpKzC'ŗzIOu  ,ę2<*UHy&M!L?5-#0#DzYo^s'pzɔX%NLH~Wz}'wdNs҇dUngF ~rw˜N9]VЂYKk߭تPdIȮ ɟ"aVGO> uٞl6džPƷi^Ȥ-ДYs>( !3,kԮ-u#@mUԔטŻ'k҂9{Z(\ ֋T(01x֩SGz遜lEɒWĦ3`;Tʔ)CI$Xh?8A"$9X/Hk̐j @"7kL_,@x?v`4_>_5k苛N \?mx[XXF+ذa)w#cD)na0HESmpZA HxVf–B7 +aX+P 0a.HE$ 5X]"Ƃ 4-,UccF@V&Sl/.?'LUVi93گ^:'~աC';#(P(/]pUBkjۼ+ gR.Zf޳:u2 gMu.gR& ߵm_OjA_ų4vD:}[:ݤKyIã:r=4Ib^LW|.>[A; ^GT#GDT{ƍWD}F 6F`C@/+}A*]\r2 < {6N6a'3ZdkPv 4T{SkJrܶMlB S挴f`C#1Xhܾ Oj+Sv-Ё߾wJ8R5re ]%qVQL>I{q^^5Y|;,~ejJ!ϐ1=,SO\ l=wnޕd=t{kGM7Ҧv$(~REZr1U]{)SeJYdɤn%4 6ːVł_ҵ+7)Z8Nq!{;筻) @bc߱+d{ٲeiΝ4iܹqyF 0ƍG r!Rbc+ AS#u2XA{!H ]\rR*q$𜓏cl#0ዀQ2miayQhi4^:E3&ꥲґF Px!rqGP//^B|T`5W[Y]Rf va3vhniM=jd(.z,=kԩBY,-.?y}9,D˃F1I?~TeEݜ vt6M-$g\F2HӬ^ 4<K|z8lWhБSd{/oo.ҋ{fTjoBoANA#_^57Uh bŋg.X{G~ΌL _ʔ) t#T$>_2J4K7o-H *#VX T8\~]nÅV [sҾC24؆mDƂ$ W56hx!-֞->}$g?~|3gcF ܻUe^.gOּ'HH+p(qߨANG)dL˶=k:sƒN;D<ҋ~?}>>ӊM@ᒦ4F #520Ayݓ?{G;WPb;W@r+k{~:4w"YT_AK!)K&7p6yVoҢ.ѹ^DX+.4jjϝ'ԑGL:nX傏>cZrӖ54SJA-֑$Owe.ݠKWnQW /p*h}$\X tQ: &Ƀedmmm!) `XݹB DCm5mڴ}vIhرC^I!HWRJIX&l^0wwwjٲF_2^[~{'" ztԗ@^G/Q >}4K ͙3_DoCJ:}%zK$ԢϞ=K={$DFDq_Ȉ lvJK.նCc</&"#SlJ݆59]rCJlXg){wwH2iBFٓϤ9{?T:_@J -];_2G G`O`E||Fl{ e:2vl#$`]S!7Ӗ&KA@D v:iBO(`! 7d֋k!U0yAۿTOL<JR""ibۗ ;-]hqp@TA ]t`L#i\,d_x!qxWqy_v8Y7nG-[_`mݺU.dɒEfGGv ^WkxA8|#P2ܓs;o+uG⬬V2gOW&OI ؙlspZLW2!UNW.~oLK[zn<#5ƍcc3<|w" Cl4_J@cy}ՅnF,MT1ȇ̮CAO!w 1?o"!ms6]%d5oct{Vvݲi9-Mq*u;Fݽ#^׍U%!ݨ@\*yv7?l2=䰲"Bmh±#&N[HV~M(vtT([85K2FX`y a dk7B7^Nњ`!v{/d(ڵJ/`\D/[-HzԤ mO0Ġ=ga?/j$ kSQs1c@cfe%NZA kc ƓtpC0-3#Ԩ_ K/=,ץ.Avnu.8'*kEϞZ)HrATh-BS`wYL ~?FF6hw]Զ%EJC¥V=?I jPR>Tc!AsM,<-#}k0qQZy-+GH_%n?~Vkhx41m\ڷ.ǀBsƭi|=4~1{w>-U3]oڹu/=צdY^9U:ޗ 3j'\Yf}G J@gQ"F6MZp?խ"fB=r;50͚JsOR x*d du}ɦJOi|Vdg_wBr 0,$t7el_2^0U&iSf.%+7˝ lNt>j8OZ"_0#0f`I3iYJn&,mxH`%Z G>Zl!!~H gcF Y)-;ɠujP!7>E4r81~XI%C{)|E2 e\)[A@8pp@ YF#b 9$YzjI|d ' `8^ ACeOQWcY߼GHֱ%5휔NW%Ls58g2*AH@=x "X(P/psVjYZn0O{[dJgvNɒ&t5~, XÎiRݴ߭X},ݲR w6F`F (0" h@#@[;,dɒ93gΤ#Gl֭[F|I,č7ʒkr L' S N(޻wLZp3fV_>ѣGt!qp5{6F`"%+=|=մphݾLN gM ךMU^*^8 d"v]ZS9_=gDx 7Om;&7Ev2Z*Ikx D]G=ɠ w@Qev!E_]J^L }X|A=e괔.YfM yͅ?Dg M'K"GOmO%҉(`ѱ{y@r0/YEiӧ H8LIgM(!e͞YA}7=o26msVDal}n^E/_ҋ8K?إj'i3VxJJ"ʖuTH|񊒉z60e| .H K:JIF׵ǂJܸq((@7BbJ3wb7ӷdٯ2 w1J@IDAT.9A,U L@w=RՏ^J@_#l#f'IJy GlƁ$I yJyse]Tse̥XbYʄG:u!1xd, A9`yުy׮LpGw HʢM-X`~Df^P.;}vP]gP6K sK̒I{_ cS~4$@c=8CPVriZh 9 5 "1Ku2\sr2@TA;v. bL.gpApq yķZ*]F(a 4҇zUfccC .4YR,n*X+@؛ڮ vW`ϓ'j^={ O!,l˖-D˖-ׁ_3#0#0b}{ pt0SsQ0e-uc1SE'Od;i&y@z]Go~lݵe/^V{bgJp,f9sI9+]3jN;ʆ԰ذl U?͚: Ņ"81Dx $zmw 1aò1n?rQr.sO-7Z窥~s8ٳKx߹s=zDZAz1buI@ȶ$O@+f $˗v^Xnd|^* $sEH GT gcF`F`b3pJƯ-aha0޻¤ !0E\"u<9(8. "i iV'3~8l[֧-;eSSS:4D]dZAkom{a )Uyv,ءq,ϡ#Jқ }>)k<\lm̪O^ڎmUVNK?.,iDԺyq>#e1qD);cƌ(3>|.&M*]+0A@ E$;48o+8cI#"-bQBm)o0#0#D6pDỶj4D y"oQTD!ʐ>5}^C+ֈ _N>vΜ|2lDTLQ+sq\ȴPo3eJM͂览YЮu#J 1p 9cPXҹh#w5ut9ZzFcjy7^+H~/v?utm؅m!H pX$_8x 8bAɞ9sfsO) ŐM`6vׅ%7. *dR@Qs= ǏgO˴$ID\9@_tI $/%a5!dE9'bp4'UT1 B X3;vL:^,8kӣ6LGãHvZjժ%W6J3#0#0#RM8 DeYx!E%tr4(S| ;'8W3_alqY<8/ PÖ{hbdS<~5S=$yF,. @ Ӂ8/'k];4scX ʌ]0_., +Ozb q#zI?TBI8iw.%λA@nt#\)1D 51a@ R嫷h}A*/te‚ӥ7eٲf"li+_sQi k,v2\J 'H~-EYҤio}V9g6slل׾ ֟/;OTT!+x0:5+.Cnѳ篤LWDZʚ;; PJ\=#v<1!бcG7u˖-e1݌u*֝"`N*Qpɒ%ԦgΜ) bx̙SqđA۷o/I_WWW*^x@Ñ+2N哞*俭 :4xwjՊʖ-+ nm_~}.^(=t-zjzC=x?N8e)SFzc 7oL֭1p6<{,)~rooo/ mtA[q֭[Abt6sLΝeQ`g?_tic48kEC hx n1#0#0#A/,JZ466 4`5c=˗'tGЕ+Wj@wGi֓HG<5k֘3 l;^َ>@d6ezyH6e~ix#hhXٮoxQT2qcK>qvUp3w0#0#0#0svO\Аoڨun,<͍ӣ?9Sͮ<13#h@ + M^jp>2mn*hP*zH2,HX[[ `]-*]f=:?=;#0#0#0# 0r,{Bn${fuq>3!A2xà7n\>j(m@Z#i $9)ȗ@f0 U!^ڂd )u(DHWiA)c4xc|M4WR%J]4N&c0#N|toNs#D_|\<Ap@4Gr D&O%Th~lgB y͛E4e)˂4ȧ"8WE:rHyEmg觃3gG .]*+u1n*U]cq@q9M LP]vC86=<<&:yATY8[cgƒ"E Z#bG#{c-2#cx왜Oi΍1f^<F`\pp1@^1#w4n/RZzlRGm c1L@ãڶm+Ixʊ+'E8Ç oAPOJjT]\\dPRbQc6<HVJϟ_͘1$+V({jդg=ӦMKϟ?K.ӧKz#hT๟wQ_NNݡ<B3yyl6BHo +g,=׭['" ٳge RUg鹏 }mR^(}ߠ:? >>;3azr}hs64ڷo=# 2e*CY`͂?ųeF \-XqHqAtuB<#0;ۿR9S(]1Qn}_?-ZY44"mA:u֋ō-b\}z7w;_XCİ"3gL a cAL5AƂ:d ;wL{n7n;lu͓@۷Oz#+'Ie=lSٳg׊5j$B%;wԯǸzD 4.W7n\}"'''0apr,0ȿqV w搯AМ9sZՃ… CjAAO2BsD\)&PlpK/҉'kSd6zh]DgZ7*?=zTsY>}2vF`F`F`F O)$Mj?fE$H`̳w͝;5jeC_~Ro44y9sYBƌCǏh1>rM.] .1Ӎ@Њ'OʣBFM6 rD?wɛ֭[k ^ylz 2a0􅠰RRk׮4c 1dҥTxqwDk=|PZ%yqiF`F`F`C34njӼկm "N 2z]VĹSe p ˭rk1_<7oNF )Qn7~`pSNh"#8iX ˈl7Xd9'A?~lxͯXBe:Gbʕ+F۷o'k;d1#b4>F w<̣RJҳ]t`w^J"y{{kdz6<փS}6/_^.]:Y ~i .ȓ@wF`F`F`.۶ 2NV)~{۔<7%l`:F]™MO["Xg888.6F 2#{[d,m۶ |ڴi)ÇҥKiСiӦ[?ee<<'NL3g={zM&wwwI~ؔ^zi3 ʕRf!bOnҊ˖-+7Ii3谆 Rvds͚528)K*%=`4qDIˆ(۱>xcCϜ9Cݺum۶l wB>^+샌G0Hkȑ#pBI#oԨQZ?H̓v#X`F`F`0GWA-7ky*r=Inpa5x$--dgYհz5_F(0Ư42fHRK d+5hЀҦM+/5UV9rh;6mڨ*$/R3ܹ$QsEV^ ӎ\\\$i\VЏ@xW oѤI.A*F퐽q$e wss9*T l԰kΝF;IFX MG|M=.G̋`F`F`F!'Zl#M<|bv"aEË'J)5;Pq%Bu΃8`&y ,YiC`OW42絏n!/ GM:U#Uӧ ի/V?v@3l*' /M0l!,d:~fF`F`FWohƼUZI/_ZWVU!L=M sEt8慇8V:N1# &CM{޼y;>}*/h#(H Rn9<1mkkʶdġd)ocx*$o@ R<iF`F`F`(4eRZt#}٦O[/wx?Z_*hѢߦNCX d"As}Jl7{<#0A {Fϟ ^ƍr( ! zپ}{ʚ5xɘ'OvhCbrCZ6Qr3qRL)?~(!bA+ ߗ~~~2Hk1w<|q73}y3#0ႀM~bƊ=XC<޾1xV/T&7z1;}T։ -Y>XcF.Ӟ=zx$LLiS٩JF=?4>F O 7HŊV,mi!:~ؓ +(d2}nUQ0aʜ-#%Ij=P׊th}K63z>w=~T%K ͯ5wɘ9*0Xh#؄5}U?*?{ n8nނĹDק[wcs;F`E WJ4o\zC@Rc 齸A̛W^hްavL՜#tr2djr͛7SX$oZq2)籱qFz92{ǃ;ҡO}:7+MzCiOB:&z3N/ehHN#0@!0q4x]vJep߻2޽}giO2 Gu" Á=i epI>b ag(GEsӍkdW'R׶7ZI YwX0{fR im{ر({,X?L Xh#XEԙK4nBr߱ B5%ϕ8Wi5mzF`'L1#nNd m;vL-Z@;A/_\w8߮_Nk׮%_d6.^( jܕA?~ʙ3$ &Bɉ 3OwٳT 4ARÓ ^=5b#I&xx;^Ϟ= :;t@G-[@իir: !,K,2 #FP֭庠^y'~ǎrt_n]rppyd90'N&nz;4'L퇪N3#<}5(^𹃍Ce)swnmV1u˾\x`F ""G #тKޙQV4m8U5*x7 O\ysXJ^5D?fҤIRe;<;vԊ@wM~4½{d\E4a0Ej`rB†.s6K̕q#p\D8:ե ^)SW_;N\;t"T ks,Agt뺷<1%GP2DZ #W@;r5l9LA*T' ֫@ڶyUTaYfwL{Hv ^nC)eF,Z"=/4hD>}^㐬}(:E/O(kجJt[w閐vT`]ͥmXM,ۃjwF@h.ThQ)Nx_3z[X/9wp@ DtIùJɥZK!΢_~F-8!™ws <8nݺUCkpyUd3`=_3xXo۶A]qP$;4 Wxc1eKi\\3KV+d4!h-39{%oeҤHv-;ҍV7~ofjԢz4רۜHa3sԬA; :*¥9л7e֢{p2eRZ.9V.r\b i4l\A ^mdՖzQ_צW$9Q}iӚSRTv`@21ޗ GQՒ׼ZӺ߯ov9]p(dT}kD@Cu^POs'Ӡ’ٳ^K}q~"`z؎ͽ3#0|[؍\d#{>l (7PlGz3Ez:Nl^nA~_M ^ Յ ĝPǖզc5=Cj*XEϚ2nklG<~py+~w0ԈlG??}#vR#‚ڠ- yXbڵiӆ Bn]ߥմ$걩)3fj{Ĉ/͛7G[(@؜A?˗O+ѣ6u֮]Q 8(eUVO WS iݎroAgQ ?h͛շwZ`@@e˙U%k^z6S۠#4x3dJMo恖ic,lʨچN;) `!xrWڹt^=e(9H.g0Xd$AeA#]eH{e~aӧOOb;CfŦasMg\W8>}$u { #G U^H֫{#s#2#0*ٮ(be*d ޯ[3㸈y/\j '+=QoET^ I*GgW$*SzY6v iu%r 4IU%N(O ucHȠF4}=$oy_9Hg eЂ]"Ӑik?O픎6*/s@R_rQƿ{V?#Qyl^DI! ~CJG[Ŋ6/׻|4hO}bĄTVc-ϐ gFgxc/?у:*,]6' }3ptJD7?Q#X5wD0 tw{ Ϯ7Go\mƱ }Z?-dɒh Y (2wdjݺ5A[4qi{.]T{pbQF;uD/_V D~ժU)G~ cAV@Eo6p*A$d&^)1C#0@ m4tf /ѣSߡv)@/jE nxk%)ڳ>/~WE6s-D}[(:NGO5҅?wҘf.VVK$"2xgΚn\3u)N*R+By:PL﷮|G(K;ɣrS .yIA+]Oʪ_QV="I 0?~h:LAn &ā7=ׯ2GQN󂷾2l#UyPwkX\nm_:w"/\ucF jɓepSnA֢ 0Dްa` va\T) ]vHXBzn?|̃lG&y(t?&/S+%H޼~)IhAF;8YxWi3HY˶Q^>'`^;Y" s+ a3[:/3Ѣrj Gm2fΠ~ gmAd{Y5[,%[@ רE@ %hE 6}yڴқoh2;N.].i]K63mC6֞N8ImjHةH/B wF}@<++RJK^΁*SU@?|Pz+j ٳga }r-<4-gW=v[ ' =#ZT[Y3|F`E1W}mm1Yx?Bs$qd,Yr-ձyL6zqŧuJʏܭ~n*%mp$ 2-J& tA|3tLuPO$+p8)sb1iPYpۿZ,)uZw(NTrf16$zlҙWum# #K5Om2Bcc>YrdF AR~7:q$BFsgé8qzΖ-< Htdn-?a)˂<B-T< UI7x/X@e1 ,@Ϝ9Sbŋe@T}C:7md 6 o8pI8 {h7'G0##`)(A=#9ˬ-29]syʺ!ϕR"JW:G6iڨ(ˑQ,rKk Bie?zpy_<#*AtE_RMyMӟ5h_omFXyH+pS ?=*xCTq@ {άTa sAiEms܈)ZQi)IuMㆣ !;c2g˨Q>Gc=&;LYLO?AkSrzki3wzի'NM͛78SO]\\xzP$!Փ"E z1]tN:%[GcŊw^jdr3FֳvZחpݻ}vz2a#z,8p@U ۷מ8x 6mZ-^p^CcZǜ7p7y F`F RB$2!rEwm^6nkDҺݿ+mTnPQp?w(MݏzkVy2 1VA+3YnJd#P)#dy^ P2F_Q6}fC29z7١ǵn3ڷcINJGsh2'@U;Dr A;^}Pib<B]|3$m/H|EgΜ|2e$: ACGUqY2wwwݻw6%9]͓ix۷On^ +G lrl D:& R^Yݺu*Oݗ.]rJ}ƍ% GO<=z,B]b38yD!{A1#6󧏃mGAߦrkRQtlX홲䤢%ۄ]#jz;c)RŵN3 ;BB*up5XZMh}ϟliFN;ֆΞץ*5RނГƺ&(f$GѪ3H΂O1aC! ȵu3O'OfZ-;arnwAP6hTT*P(I픊@f8dQzTKRqbQ߼mc%<=sv{#')W=WV}JJ7"}G#,g*|}ܣϟ *wH4lVG?rA\lZN]zvZ F`G^iҤ(.\>@Ν믿6HeÖ /tM-Cmٲ6< k)#F ڱcTعs ̆;wd<ʫU38<@L8SL8>^x+;_"dpzÆFڵwһexf$hIۚW<]f%J$=yНwuut#{c#0#8]0M՗V-a(e*F.9EKSiԑK9rt˷7aԬV )AFϟ^D90ӼKlŚ}. MgP&mF<xZ;}D|5Uo $Ѓf&4r$QwԭmmuM^:6wED c+<٭/DQ+ 2hڴ wsp#0Hk\;ޟ/NY%$m1*re@|t|UF|O0fTR%IBTj\=O4M)zV >bǎMLGX<1શC%\.sfsH☳X~9/`=찍=`6WEQbHF@diPqڧ >92jYGkTH蜏ԙn]6ZFtRq{ju%I¨,oEK~qiBy/vݖ 2z½vdZt'RЂc׹@0~Լ] !$=2v) š: \W1Q;En/HING UC}ATnNHz9whڄ".7m\Ta<8մȦg`Ϙ9=̓r⥋RLlj^nsB(:4QCӢ9)n󗬧.FWRQ *-~z_~r`F|oc{mzÆ x/i(PHڈ0F`IVv/2{r=:mszy-VlX0e2D Hf{Bn{vQɒF54ҡKkkU,$ +G zeo߼(oSe|g"Z7 g~-Ecs:ƌ#0Q܊Ë\Bx1$ys<6#0+.w[*j}ǏowSN;hSmڦ#0 Mjر/j\T,W]MN^GzesCF`{kGHȡhѢx׾|R!n<\{F%dR4~~~!̸ecׯ_żgUP!y2s5aXNq޻w@>kVt$Nh>Hx`$IBP XA7,gΜr6ixYѲOeFɗ/_dwm\̙3[|킚31ޗҤBE]hƢRgx{I'7_R΁,R(3F`Ff߽3|v@ x׬[- S@$D :up-6Lg/\ ԮLѣ[G#0@A pxAC|„ B;шeAddɒIXZtBz=z.ŏΝK5Ҳ_~t)G@C~̙f#d$3f ?o}SIΝ.]D;w… 0Ӎ@'O M͸Z .ЀhϞ=ZJdʔ|}}i{X5dVڵ+͘1C] h4("cǎi&6@'s:kqϜ9 J@l.zk7h@iF&o_"_?NZnhe͑֋`{{`U`0a@|Eha;w0@G)]{w 3F$Fu=w*##"yR:k95mۏ$o>},b V;0#0:uE D..xi 2"6 A wǏ7_WX!ܲeQ̣Xbtl}J 5kG2ݺum۶i1cƔ- CYڵ\׬YC˖-J"l@bƞv/_ӧ Dڷon4߼ys>'F6NEGh<.1$t(3=yo@`F`$?StNԭW>|DKWmcԬ+5o\Ö\`F #{VE3g*%EҦMK~]hҘ)D[p.#0#0#@TBI:gcݜ/-JOnK&QJgq*[oСqFRezfF0;o1bFW3ѣGKYykL@A8[hA>>>6"ؒk4JkR=Qyъˎ@qZ _A* s1m\rGt\gH1@`wF3Y6uV;#0#0#rdSQ܁hRS6#:5[oKoc߻M[~}TױcGԂ3#DpqȻ:!;vlc޾}P`OIܸqC( X޼yvXv@[t_ 15&OOӪ 90290#0#XA!ER:{ը-/ѨAʁZ%KztiAn+G/H(QB6Gl۷o3F`"?Lk Om8jwL tw!A ojzoߛW^˗/ezÆ 8 yʕ+qlڑ=rKzȭ޽lx#lܹe9 *hjЃO*ԗwtt; )COvzi`=c09Z6C`5k$-280t#XG;XUakפF\0#0#A vXy ѹ,uR$gf@V,(AtȐ!ty8q*N1B/^8͛7O:UF`HyqH_e@!bǎ#xâE&'ON*78<%vZ_~EzHܹS>ŋ%ь2l»:gΜte6lyyyIOsxwٳ%lL8zW૸co{xjy97oҹshϞ=[X 'OiJ̜9֭+"СCG=4WkRi(7#0#0@p@,RtiD@TjP93g 'I8qp ZJ58WfFOvvV&l2I*F@2ʫDn Νd3ȿ3ܜ~:a ^ !ҴiSkUa\xC?T4XL2e$Q:fSC 2h$isiti9?f͚ݣiӒ4 * ~~ x#2{A]ok>AjU8n̙͘3,3 lbUZMЉ)d[|}/]x>} ˕FӞ_)KFJ&ȂSwiCؙ墼kϜ`F^6^@+P8e͞n#Xb?r^jVDϜвef͚Q)[lZN0#/xh#0Nnc?YW笣DZhٌ#0#0@@ C 4bs=zڷoO $0Z7gN  777zQ~`F{p{yF`5e?Gw$[ F`F`F *Q͟?PuTzuΝ;GJ\]]iÆ _p`F `=nF`lG>6FkPJjڦ F`F`F0F zT~}ڶm :}tʟ?Q%H5n߾4h@)R:бcߨ?0#L#0<}um}wr@&/'n0#0#DM&MJݻwgիWih۷oiTdIJ>= 6nݺeTF`B!ǐ{`FzwjH_=D@qƳGn0#0#DmfJcǎ%___ڿ?lْƍkݻwiȑ)S&*V͝;^zeTF`CX˾>#0#`G}u91Wn~{> %?J> ϘEf3#駟lٲ={6m޼/_.IWӓpAz-Z*U/#00n;VQ/_h޼yR ;1$IrvvJ*Qja2fZzGz2^|I={ .зoT6,X.]=s`"'{vnKfjפ=nZ{D4mP{[v]f#8sa>G]Zנ6|WS΍e_sg] gFB\5kӝ2J;QY]p7B=i rrqD:>4CtԭϯTf sF`*bŢMǴj*I_|Yo+qԨQ#j޼9.\X F``=hdgϞQѢEg̘A׮],Yzqׯ_>:tVXaMОccȍhh">p49ק3Azoۮ u*Tk*"O"xZ][Y+2F ՛ԥM/lݐFMJy#؏G^.];)S>M-UT;wn(Q"bUJ]9~azQ~`ȇ_?Srqk:oA=RzO?@%T8ޝjeEJ i9"^>*_b*XFrD+r#TV4_z)mٴ?5Yd/]Z~0#ɓi„ w^Ij7oҐ!ChСTT)I4{xwIawF`0GiH޽[GBɿ@Hl1cn2e^l#=+ݼptu6C,N4Y6[$?DU0\ȃرe Y#ٻR@"efܣgr-׀ 5u> `!+Wiƍ|c w<ڵ+լYSJTXQJoD0@E 0|mqUɪڻwGёr%Mf/^s; J T'1@ذj>mYTkӦS_*_ ̡[ 볜dgVivz/=rRlm i0ȼq͋ܤR"@bݡ)C3s&9UfM[b_"4yJJ)%J<)|C(~ҫ(V"#eʒߞ_HϞ>1 Q)M 'S.p!UcrF <'6 3Rw}7EnY.,*V ׼/N&ZM'BH̘;JHFAթ&mF-tAZa3EԹf7vesZH: 5k]7߾~EkOEe2hxCVGA#n_]4rPg!X;e:XrPtI#MFO?=~F<WvS1i[پd"xA+<~򜎞8+g(a|*_w 899ѠA:@>}JSNW9 xHβ1# Q5Ë2|6%Q~zʖ-y{{AL}DvŋF,^rA=َ>u...FQPZO#ĉF7%ۍ*6'%ݔl0͛7Oz#؋gz(4{mi{6molGZ[J`J9m)َo߼FQEG"OQz.h$6BMgghvf߾yMFnXO%Iȵ6ضwFؼl7UW_foӠlU<%fVفlE CYh0G26X&MF VGߧlGE_Ԧa9zp|`s '=nEo6F !ྱGDt^y>Wߡz˫Nto˙1w֦ !NSُ )soQ Q8al JgGt֭+NE7Z,x~z8X>~hTF0F0u^~ť9lذ5j$g9q, ֥K|?W^^g.A"Ezo޼!H@FְaCΝ;R0|" v[NӧxU^]z3>,9{*UӓfϞ-O@dU ǏS^w& @vK,!b={:t #r# |ȮфB 9U@G`>:FRU?ado:s|J!hs:V卑 m o=>e72t^陙Gb1R)\yɡyȗS1e-x o,&Fu!:Zz椡BssZ,u!@̯G 2;%'EsSW,&jk롮+֢mgЮsJ !3{-ƒe=SB,@z^SF?TÑvr85#R|V/۠O4ؑ29PܯҖz+XˊoLJ:o9k0~AvCŋ4ooSjhĤ}`4&1A&C:<^-61@`+U/Nv]mٱvoe۫( T_[fʟ7N*#'-x8A] R48 3&MPlF{[=C Qs8qS%~EE ?.F … "˄ 3fLBvbŊc7+dB`aYd .Pڴi5 g /*Pէ5@C3|@>Dս7YeS:MLv ],AMڨ L@GOc(hT׬RZRʯ/^3\{aMJ:{7qVYkX2i}Xo|[AYRACgan|ǵ޺.B 2(~}ٍWPg7d^Μ8$&N*9oodzOPEK7]H=~t=C_+盔[Ȕŋ0Is^Okz{ݛtn#ӿfrF^]&;rk>/HUccB;գQԨQBTy~aMVϿb[wm3#`=bY17#7L1 ۷oMO(O<> MyE`E7.#xGl2yyP^=ʛ7 *ZȀDFN#,xNZL/+sGOH|׬L&iخ62k?/K 8vx MJk2f@7Ie`p@@IDATᎀWoxɲկSdB{x ۹~.UXRJ=Pmסf,ZIsY.Wy? ytRfG=>^k[ϩ;mغW^Κ4Z1K\v8R8];QNlN3@PU 8޼yCk֬3x8lll-ŋg7# (Aռys-СCԪU+鹍<-g@P\9 ,֭o?8,;^@və3'?^zc]0h'"!dt?fLL\. j(*@Bт: uzF+T-r7Y;^sg[ڍ$ +gA_lΔbU5MA &@x_ W x19)I8k:mLL%L>b"ED1bRA{S_l{@Yk?/#Rd|VH<#`h:G\ϊ#7I;fʐr:'Ι\,nYd~4q\H uYMUV^ߗ<<L-[=z͞={&#zkS3f ,p)LlJ:n޽\1~KhGbWŋ.^dݻwKmu-ڸÇR ,~Q}Lk0HǀL.zâv TVMn94vq8~5k&?@DE pCӧO[5宇^?pѩ!Y`"+#ts)Ho_S1[x9٦BW/yOSiLʵ _^ظ~%9ZW&gxH4>SIN^\[,jx_rs 2._8vHU#hm7(lX߶lG0aApXأ 5Qqks40@A@/+ 095a^NF,դ/u!.3c˖,$[:8u"h0l$Q'Oy?ЦדSըP\WZe 3pSg-A oXGP2gL@Ò|GLO#W )6#""D%"H7`DfbŢR߾}eֻw?!7xΞ=[eAvĉR 307ԃ;l߾=͙3GÖ/hÇ9;;SŊ ̍ ۹s'URʖ-KC a0?&-www)tR{#|yOS.MTvی4buzYKOҚemgيOFo 5^ׅ>'HzXx B@򇄥ͤ+ĶDܼ~Q |>} A}&1dzMfTy l/;1i!%HX]k KcgȜC.6\\~ OCyiF`F2zS Ǻ8ް|*ٗ.\6mJourL5M2Z4$.@A_t6/vGO]<TCN0D;K.- [l3...*-l=k,4V̟1<.K:>mh˺%&1` ոz"ɼx*%wEkۧ #4yUuMZvU{Vk$<޿kKR|8`de4w8}Mt(Ktڿ:ǿC{,Ǿ MvOv`D8*6lؐI&89@׮][v"h/_&8DB%~PxU@ bp@``wc\$[!ᢗq1?̷njT<OV; h i @MuZʔ)ܹBzڵkRƉ'&"E ;pvhH{Cǧ>}?nXw̡QLTNT`"H$obTVCڵe5ac9s.n/{IgIC_N_\voUׯO]N5hc~nNي5@RRoՎ Q^)[;)ŀMVc7mC]t1MY r3~9j,R`1bƦwoЊUg!%J APW !)HnHg.^tn7mIׄlNU(Vlʑ;?-U+etk&.ۅ^|0H\2_3#|8N L/'PvEôk}eAmX$0_(xݹn޾O!Cޝ z^DN@={Ǖ+W $r?s#C inx7,FkK.)NH_^~}Y'L7nf߿osDph8£%Kp1]vUSNCj^g(lV+ZDj UʸF;t zΞ:"I|ɣUl9h ˌ27nG*eS@tǡY}۵`=csZRS=3K~^d0,z½X𫕭P'߱@2uyOH6H?Dlo߾RŢidAηtNhXv_ZsK}*!c smذAj@:u̫zvhԺS@_mؚAx[,9kh ih-4t\\ks¬UԮ tGdz^& F`!zY{?C[w'4_l6US1!OsCc, 1 JOНW(j N->pX2ȳ\陋kTo qYTii2 -<}*ւ₼.Wꉓy ʮ|`ԥIޔyL uڎ-%NOĔ6}fήwǼ4D̡Qy/kIMID@_[ό@@hա)dT@"y#>vFɸ9ƻCi-vWM&HwX %#(YRSkO?6"3fLj֬<3?͇kF*xZ[ħ0@P#@0 6_{j:f2,ATLm[ӒGh5|bЃaeB8m s) _炼V{ZZ4g_\ʴ3$p kmzsK/>3#0Yt$1Qgzp?A'i' g>gIM/h(J(z+[GXƁXq ޡc'Dt~4jHƀT@N2&L p}{ē#mڴI?x`܁yFƍKsbفx ^Goо߶m(P@eZJf{w֍p yQ-1ʗ/2eЁKs*UhϞ=bH3fаa$鎆 !d>ӧOS˖-&cVZ4qD:Dizxٷo%@˗vA1F%eٳgRB(ի7=~1#T?~ *$=}cرZlؼRuY媩kN0@mWn߸,5fb${ԫ%xDf#^@^bu90#`}2y|.RLfu=O>J)oU߫WߡKWu@(@ l߾n-4AK^~677ȶ ˗Wy9dpիGd;깹I3g7#xvo~ex۸:'-E!n5&G:o޼2.<5r޽MH"vw َ&MJ8FN1lS.]h&P{ժ$qM P BG6F<oܢ \~'"GBc.5:p#0FTTD~ۤ8r2&YH$!})7htjڰ]38wByESOo ɄyZ6?KM19n\J:9=t{J ЈA){ D*ztr5!=SRHJ23DB!-wWWW5-1h yΐ!*7JPi9Aëdiɓ\e…ԦM)8qb>|$!Onx|c޽{wwBuV#2* r!pF /\@E Rti}LWTIGԩSʺ ȵ@6^qhGT]zEbrơa]X0dsٲe⾁fXĐٿxb=g"agvٳg8}3#pj܆`PYL_NmwZ7'GԽ" IIȕN~$hɼIz{pďgCޮe}2k)=y~ yCh)]+߳ AvE*[VhOwrN08qHd7< %<7n(ei<3p0A&M )S&IÃ& BFo߾lokf͚>7oNf q5;jϐ5\2eϞ]i{ܨ=vZ?*U*jڴ(ǜ5ܹ3M4IJ 5zxc,"Q5DJ615Cv 0< E'#0@ /}л `d; 퉸.Vݛ'd;|ɛ8{5%H_peF{s4o.٦>C&h4kV&}k0#$ee0@AmtQ(PBFFBv-%=1 ;c1AZ7sYQure$躉ZhiF "/!C`l׮ MoxHfUjUYرc:1cNPo%>'OlBkuLe_JR]+ /gm|ndy)Y"29sfa]7lP Sv׳# ulӐZ:ա+nOeӚPwy/!o)_l*K>0PVs+OH yUmժ4<ŵkY/fx,!"%îKw!w,hk15y`dg-ZDqX&ܭ(0@0"[鹮bhl3ܹs3 dd[ cN^OیѮd*Լ]/tuF`F`@BOt})'!5xȗSFmNFED s vq޺ukʒ%(^I^Y\E)id;8reip#0#0#ZE]#Uv${رCOR۶mMʵ޽{Ky5j @ *I&g4et~W\r^z9}- v ĉ#ᑎE ,ԩSGJ`Ƿ% $IPݺuG|gcEA'!U`K [M4 Z|#[k<`G ^ VK*eYx9rϟ?~_OD/Sl#^>wa'6E!b#+~OF'+Jܮq9kNJUr#3#.8 UjTE{`!ZQdI 36F`F odx/_,5Y=++R\``F.~M52< 6l@*ނ LO$5h$/FL?HKđ^fEʖ#*vcIkq?F`HvFXA:dff ny-D;&%-pCF`FL[BF<<}jۗ/_NХ ͈#P5k֤ݻkN0#0#8y=rfd6ow1D s? ,ϳxkڃf(Am:.-WdF`|C wrF`ҥKJ*'+/7nGgϞQ t0#0@DE _l'ٸ" {6+=~J[vafU|r6mܺ5w nІ-{7 pM܅k}ku-}Nkg/-U |x۶8OrT|#J<7[ rnj#0&#dЂѣy)ŌvA[)?H^cF6nl26v<#0#0@@OԮ^oYVF/'oci(3i>%-FiڍP'EAΐ^j+;|%R";ܔla1R";QJ'i-Fw=US$(O:]Rĵ.H2l6nu@4#rvq>} s̥^ M,kAȑi_hX>6)[$cƈnR#w:feSoL n> F`F/DK%0#p@rmۖ/^:I$ ڵͫ#ѧO:vj̙;wnuT[<,)ҟ$YJJʖl3s:s6qQ;֮@qJ8UužYY)u s =J _JcmW~DJ2砤=>سs_7 kTs'[򅫲~ @a;?劌@hC _R ݼG&ϙ=4Ž}!8a|/]ؤ{jز7j^D|]{RApo[;2ܟū7&?=e2'wtjOFRל4>⯛'_ /i8&>~zu(J-&&|AtM$f xಅ^ׯFG͔9kIcN4IٳCQ\Y p$ɟx-=^szgfg!RJΡ BZ6h yvSzuiAŧBu$'\B NԦPע\yA>wh݀BbâhЩYSx̟2Nug$I'OJ u,ԮfO҇\ v8u*kM:]hQCM/tdᢱI2)j؅މ͒%IHeKXh"tϞkJq`E?&, H(OUwq0#p cF@+D&d;?dYfIȑf ;ɩv s3',#pƕ@T6!Q-⒐@ITJyxSO=!24#eV<$!CCVn0/By:::TUWk79Zvnu r'x-YYVɒі@ի)RByh Զy=YRzVd fNmQj-K8t1>gfd:)'Z9&yc^FyڵqN2U*_6FZW;Uĭ~JtnZx͚z, Ւ:nD̈,^7q۷/mݿs@Nuh(I2zWCs'K:BC7_T2𰟱p3 [D oܔLN!)"WNDnOq!)RT'cLH h[V*PTmnxN8Lf/XM{1cT@G^{JA?yBօϛCe나³|ᓲ!G7itoo2)0fh7E\ZZ _Nէg)ZZ<7o\[xi@^M5['44\KPYFNXC5;4oca1}s_.K&ӡCڼy3999QZ(F p`F B!{z|#>|X~G4iҤ!Cŋj.ВϘ1]b԰y'Ӗ6Y(o^H?ĂA5۟FLJ4w+:gų'`8kyHbײCߐ6@M,niVd*^vp@U"uw)}ۮpͻm^ 9y|L?BzHoY2/U:Fw#cB]3hV`Ik3Ť oD^d;C2:g4 $jZ5"'8<<}&^I]...^n]jҤ .]Гާ`F 2Y0@(@`TBvlYtɓCld Vg?ʀ{wnk"0${o}]+4KC .}ZÛۗ/_nV{{{)ٿqy5fF{x|#<L8>GNk֬իFz*uY.\ƍCkB0qRJسޥ Mc&-ɐqs)s\Kr~DדNXvc{{HִeGl84ʑSfż~`tO%`acgm9+NFf-P4޾yEePk*;|v+7 ([ b(<8Irj޾kԖ cnvr _$ 7'5 hއmXF{MѹԳܷ@kEнve=QPMxt邎6n¶3Ё^$slg ZWآ.Thvo[K*d)R׊SnlKUM ys.E7mHڳc8HJeGLDvB ]ҦKM6! 5+}qI,=JY'B:iCw.K1Ӣ+N/o> B|OqEǑɽZQ!^cgx&AKKNFxiۓ4brww 61n哒30aBkOcF{(|(<%F[UvO>lǗC'W f hzpWsKN6qQ^$y *秋gŊу:~$"%ʫnܨđ;U\y iAC.NKOF/Ҹݩoޞdt@bϘ0؄lG;= (ȳaͪўMv6D gdtoЭM]E)oŢԧS#C@Oޓ&㭛\ g3AWnhZWnRS6޴3zeĐ>h dڑԮi7EV.d;7͝P{k wFO7!Qty(U/W_ %cVoIwWAFa?mjUmtF_b'M~*,O |Պ%e3ԃhwe^)KZ2gLϧϟUV}ܹsԥKJ,ըQCR[-`Fn=,'F`(ڵK} ٙҥK;ѲeKsS;?VZE)R\s|!?}pwn^!gA^^8*ˊ(G=VR7V2hԞm|uڼf$Gy R^3z&ԨEg7D6]L.4V}'PT}kM ׸YZ-6}f՗c|,҄^-!HĶKNɣJz݊yb ju1- ;g 3ΞSwW$ȇ7{c(_.^#s>:OfG QYcSiTG<>WnOЌ) n^/+6^>s|3ecֶ$Ѷ]+&Nl!t,IKQX1PץD$P"xc %5ޮes+ɐ) 9IWdy=GDGz_ʘ9=Uzc`mNI;hNQ<#W6Zzbǯ@ B:,,~jJMRW}ۮ׎q3~1V~랬zeJg%Ϣoj Cf!xhP>3#wCw»~>&ooiOݲ󀬆 T  DA_&LXΟ?f۷#N87)RD#0@@ R F`/_Xൢ0t`?O2Enk6l/塬yل') 7 \}fR6VduhՄ`WSQRe<>)c|iԼ3L@IDAT1M];4jCUEK1*Wc= icaEkS4A W4x!ҴQ'-vuETvi(oT>\TXlX-˔Acޜ7Q(B'0`^Z=Uf)qQՎrHv&Ԓ^ 6]M4D<뢏$m\$Na /~B*eԅ|dR@H4x#&-XЕaY)ܴTLe\M?[Ʌ7yh$U!HJisT/53Ov!dW y뵇C&*o3GQȖR5(lGI?F-"h:cUkV 3FI%-{W`tjT8VJ߰s!~`I&}y=]&n_xjXӦ.R?f)N(QF:5ote9劉x_FmҠG٨ F23܅kCyS]ZKb_ n o*`D˓M<:{=2,HѰ^v&ck׮]qMhxO'7&[[Z;>3# XR&l<'%#2n߾MDדkצ(~)ׯB DuXI@lT2_#u%{Dȇfi׾[~!l@NBνGȴ<{~V)OBܒAE[TH)H囎 َAk22dnBLC6D5HwXhѨl vVd795k޶"۵i#L ꕲ&}jcͲwo_9{ݽ}M'M. w#CPWn5de4?^[==@Qϯr2t^ֹ~E{AgK]ېl,4X:vL($[4Â,H?CrD4d̥^xFޡBt~s5pYZ9wo,yߪX,Ϙ9{"=q]-[|f'*Ck3od9}Yr[GdBpR $f 5?}lЙnrut3l>Zҫ]aYPdfJNz.NsaݩhEn֨&MؤMx11 doo/HRnڴIJ!}ԲAc ޱFv痶5xoa5i!:P-!m֬q-*V8/6\xܟSAa1ȽNs\b"A|99υ86z26̶#$!#SZr$߯_w]%JD 6mf'0@DB ^F PL6z衶G2\N@ki߷o qӓP ӽ$>\k E%O}ke6T9Kz- ق6:"VPۙ)Dfz M8\J&TH/E>;b7^hC~7\Qx~99[nioI3hd׉~19)I8k?mLL% Zk `} ٓpX|$ hrE;22KMi? p>ٱ}+}*&-e,n6u ʖ% riBpѬ^>ՋɓS߾}˗/kҫW#!8e&w8ڠ-#0@D \xV#xϜ9S AQARCڠ9zh5uRΝuXLČ%!?𑬶ME*mxȫ6noA$jBG2jyAH#pqvv^;vqrZA߿*[$kժ%8Pu80#0πg0o߾-[zKpƌ^fH݂5!CZxqHMj^:R0qRvTg\m?Ҫ>wzxv)sO>8.Hr# dæ*W&qF"/7Qxע񭙀TpL]ZTzdn 5yO1+eɞn^Ho^B^,ZƼ;\#0:~dm\IG/^4xt2Awn^E?~xH^׉@(f3 RյBs5B}UIw̅e6z!K\NQ#/lpߺakcPY\8/_ Oh)[Q`n˓MrgjTMn:~qUtAX5J 7;r`0_a&xʌ#BZLғ秓'ORh ^zy¢5+V#XhZE :6*VVI#{Kmq}CL_x }ٙ梬9d:cjƛَ2hV5$e%b>qO bvtiENȑuL+07eU%pW}F r?Mӏ@*Uw4 5?׭GEpSs[4g*Y_?3Fg*J]>uu{ -d»_/"Pެ}7飇ޘ쒾;7ҭY*Q %rE@PkZF CaX_> ;RnCa9v?UWUfN/ck-bZ֮ߺU}-Uec" !6gy:p䔼mE :ҥ3[gZlxO:~y+U&0# p\\`" ݣJ*Κѣ׹gϞƛ3gIkyj,rq6 V{U)K@/դTGjT4 =޾F,Zf*RSe}{Y A6l@R!xQOGkJ5W~%/8*=gvyU_}BMjPp&~UiQmǖڥ<{:Bl{Tb ?z DxȌ_*h@Ej7W5 WI[#(obYϣ3'~pФUWgي5 A\^ Q^yg'PNOK7mCC:)"저:5$|9og{<rӭumLمL ;oڕTB,Ċm#h;i 5e伊 KLwҿVRJCҠxݏ7UuJQeŮxt9ڸf+=qs噳f$HUR +@']FԳ_'ʞ;=sN)LD {Ǔ4zmPS+U+U3#!,v͞2 !7(nl +V>|Paq/_>H &Tu80#D !xF`N[85q̾C4c EІmܸDS/͚5 ii|y8|3x3RM[UYNu=zPgIBtanbIQ"cѸ~|yT)|Ɉ ̳-^g̒ϝ eЬ@J}  Шa59sG07s4nH!g ZYsU~M-kI{̰i!‰py탻7Gzbg$UF' (GB \w5(;b/y"˴tN &MJ鼯X8\arԈ\w4;(dG#I?M߾~a.h*z{ڄ9RRfތERJNK5L2k1SQ&rѾyw!z JF$zREG!#N\ús&#FhPRJFĂSihĆ[ i+Vp J!={Lvx;wpIDZ*E%D΃3#`_| dd4r cƌٳgݻԲrܹiY/-,U> !0l0ܹCoR[ebHz͛unݺZEZj:)鬅[CUmԃ/.^y\`ُ7o'I<T;:/1,'9$ޒ&Fq_eϛU[%oBį8/j,nN߫\y'FjrY=2榷4)ߣK/jLe$Du&PF?λQήp_-QK _6ݵ !܃wc'%gJ&L }eǶ_ԩ$_<1&#bkoeɐ)[`ݕ,?wt%u5Ixz'O|jbfo9:U~Z/_%]7۾}z23 Zzꩧr54  S}MzY D|~eРAӧRTbυm7n\9aI2(gcp<.W)>F=z:Iy8!䯄^%["ɼE{?)#LPU~y X*zc RhJ=! {ʻGf&d{֍9O(鶌 @+uܱRw…>c pႭ$a& p D{JŊeٲevp?,YDeK%A?wΝ;0,s2eL gu,F$@$@$@$@$ Im۶ڵk^owO~ +F$@$7:f$@QF*+T ;w#kժ̚5K%kLkυγ>+XaY_|!ٳg$@$@$@$@$@JL22tP3߇6l()St֭[rr咚5kʤI?t+Ãk*~Rxq*_9sSZ5Fʕ+L?֬YgQV X򙌲1ä  #BЙ07ߔ={cweW_پc @znݺuY--3aY| W25UVuӅ7$8b1ya[o5o\"۷o}/$4w`k8{MeIBL&7q,AO$1F)?C o1c8ݼkkyW1wHHHHHH ҧO/mڴ/8q~ٳ6$ǏבO=4owtt=%    ?ܩS'uDݻw}̙32bXqҧO!Gȧ~Nysq{opj#r… ͮZ.ȑ#1&g9{ѱ=w|Ou"iVLZDӧ=d-i?Ԯ][?Z(5ug>v~7:t?~ܜr"Wv; gW<޹, @] d۶mvFv0me _H6G-H"2zj&4EϱnQpHHHH /^\  ,БiҤqݻu48ژ1ce˖Z%K,yyfٴi5JgϮC!1fz|ꫯuC>ƃ!)yklbsnfy뭷믿?М۹s_|!=-Xތh_~E*L`FuZm7"}6mb +J>p@͎ILD;Vd@ɸuwpw# 'Foy"ebX-4$m͙yԮZ$)Qm_T96T5H |UӤUw It=! qO[CMJ! %]N򕮟PͰ^+.-56:D>|̘1C;h#S_\rݒB2ARZ5pyg}Vk^H@ԩSi$5 VZC8A;&'O4ݶw}Ɇ yvOMjgF}E;`9c<I <sU5ڲe~~B=}va&A{Xq-qb\ȡm,>dlZLtd3$@J3m۶I{unDCumȑ#XbIm|hJ?Ͼ\r1I7 r@{`e$@MIRd>M6M2u;ydm:t Hf>|dΞCn8t)q]6gVL*1 @ʥl;_&X $k){w $k>gΜ:Z=\4v[8H`5uzdo>Gٳ> @LFK.INdŊN`qddJ&9{>pB5\V6;Ƥߩ=x@3 l?L,Y"'NGiE"_Ϥ?+C{px7 @-2#3*Uh=ӛSam׮NNb}fQyՓ:"u'    p'%Kҥ_'D2̞={Jsu͚5[o٨{Nn&]I|ݻw,\vrd\@X$̗/-HXYP!5k\^?;ytRAz $w`hΜ9r)}g8D's:uܾC"y^êp2eʤu?{u#<"UVc.>'2 /5kV9zZJ'D B'NoSN}1V<x6 BU94r?\/>%Ǐ/-ZB 4 P5k{nC$CmM6ղ2Up-$Ç6ꫯJ߾}q YL]5\V@BjKbWǛHO> / @(T͝A./װIKQR&PY 8]M:u4jDEEDo^b[n2`7$n^hI봮]JΝVR-[Vǎ!Yyz:'ԛ7W.>,]Mjbu+W`Y6{iϳL(IP y1ZlvwmOk}N~W>=C2|_~>FCOPzJ DClG>F2K_}cݺul$0o8g"s5 $1D#BnpP#w1(F1D괌3a98֭+5jPp4;ǀT7裏 Gi}w^s^g{5PΈƪ⋒"wHaB>8CѮgs|SJs!xؠA+< WgIx7F`w`xIK()Æ 'ak̙3ĨX>R 6m`5%NiFyyҹѵDZ.V_x-$F$@$@`{0x/ Mq3J-W'D̽rIC@nxas#iz ۷o/@:!'-,w?a?vH',2ɓ's.ܷPzg18iGءҫ~w~bA    I[nR> r!{c€"x+R,}.ZE _t{Þ (F36! 4"0i6p]#pYx&r.DtG @p˓ $ .HƍomB_ I?0Yx4]K/d0yM LU*J%      KH#ldʕlX4i&L5Q6֢+R&6]:*s*B$@$@$@$@$@$@$@I$gٰaC8qmOF$ql ӦMG@E_e(5ӯ˗/˦˔_E?w>VF_|5Qd-ߓTHs;*V.Mܪ~WͅfB @p $<%KH ̙3Ν;{=z6l)SrRH!e*UￚfGS]e%rE9䍝?{6%h!fgq'gRdiu)Pxϛ֫ Mus_EpOl(C$@$@$@$@%e nI)Sf͚~СCߏHg;p5C$2pB G:o65kTPKʩڨQ#6mZ>}N:@`ٶt2lTj"FɁ@ qy*tJΟ=2}Yɜ=u`;/JvCNb0tFbzHHHHH 6Ipo߾|rv]n…Z"`kٲԮ];X?Utcfd̙v ywaENǎeݺucƌ"EcDeA_- >*EJ'+N[(Rꩋ%;7o~U9|N mȁ}%G.]cs`D_]%T+HI`}vU{S̒Cș7"<5lHHHH Hr~*={ kǎsÇѺ4 w'OuʪU tov{.v 3zhmD?;Gwuۺv`cC?rqlUauym}GKW{˭3ѷ;k~+Wkpp7i4jΠdWO]v|eȱq۹zNXtܷ}Zץy[u]'pjC]%Lqmcq9q1ww~9z`niɋ|<ߵv>IVx2:}[)_FcEÃD_m\ACݗٟ9< 8m_}SUy$@$@$@$@$0$Oj RH!Yf s -"/_V/HDvڥbˏ?m۶IvW>+WN ķ< ,7:2e8"0v;~=im <=MZV6:sMKQ9wHLټj<}EY3l7߲f%yz;oCu>`E٢&<->c#q17m~ܼu޶/@M{釯}oXg]eusOl}M|Ϙ+SzŜHHHHK #[h!cǎk׺!o޼.]:sܡCɔ)>Hx ؿOo|"- D*+WSN!<4#iذ\pAM&7tSsl*"]i$ ;Uwߑ6JQ7I#wKtء "Nʈ"vR;BҨ{/]V,$wRhQ$ǘ$+[%fD#z⛴(2d~NfN+ׯK/Jue=[tŴml̝/V E83JD F~$7p|m~I*>f%}V1ƛMeDߞJh~?{>wHH!g |KﾨoܸqRl`qŋ_~rA}-_|2gε)1n  %T5WTIvi>}z[՗%Kw}WK.(pkp,D!$0c y'rH0`t-$MU[Y7qM8QrΝ4aF5QݢNk޻} |x k 3eΪ!ƆM;@qOvӧ%ɞ'x4.6#劣(o㜯l]5o1l/:vzҀ!mAɂrIi;sZV@PN]X0cpsgσ67>'E5x*ԗ*џj:/{*WEt je*6*>z0H5%Ӵjʡ;ԫ!pcHR wHHH /[nq Ҋq!Fo'#`r7n+V<6'U"@XBrai^z1g/͛uq {r裏¬ $-CJFtʔ)/ g;'Olcu?l-]>b7 e*UrdJ`u-Eh5;}Z`Xml(3"AhƧ#$ g'vC[  ` >\ڶm}DUT XץK.+׵{U,Z(zT&PHw3}_GݻWjժ%ΝMV^]l(1`C! \/ 2̙3nWv4߀^zE? 8=UƐǠ@vl\'of;dae1k`Yss{Z ilfW߰b@[3lr/[6y(,H%_aӂP{cY-Z #O<%HL  ̌1L(3n1H.L/-%tw{u ][  oUZ5*}_hQyȑ#2e?N?[B9Mq%6w`(^̝;WjԨ!%Z3FˏǏkG.)SF+j6["Iyz̰@~H)RĜi}9{K{ľwH$Jj^ NI(y cǞzn ?u>=`{~f-+.` S_8anjE9=xԕK9oP%*당} <qj/_AopoڴI wgT%$qO>o]'qR~ {nە;C;o/AH˗/[/ Tz)9p >hM:U2gCc$OEB3X2ܒ@ r8ow`~aɚ+H?rQoaɆg*j\v{nEj4h7*;P@IDATGGZ%tſ4i&B' Xh"˾{V%GlSp_X̄HE·Ol}F؉h%̖Kt})V,|2ד IH'89>p@AӐsi|,r _|E-`OO+P5s W^yE kӐW p`; RtcId^:gDwB}Vspx#]t+W[9xv@{G… 275p籂7Q`CNdX0}FnD$dPN;&A=ڵkkX|gwZ0-[jԿ~ӄd60ϋ10ׯ9tw?I;"@X:܁@X>ҵkWK3|pj;gDANffEYJ&F$ fS^fxiFϬ[Çc>hOpxתx $pIIpnτMv˾?F^!)nQ7tpcsoTزzUＧ[!+; שe拫SG&/y&n"ĜG-l&[{f,`1^罘4)\ܴANdG8,J,{O%T[̓%ﭤۯ9Ԯ_|YMv e6LyTC  dHQ8UapllRK !CʕWo.MQ7@v…릛n{N˚nޮ+ʫ*x߷o|Z9'O%v0A%w` e/ޖ$4JlΘ16~&;ɜ~`Syע ib  aQ3H$NߛEalj 0oO]ؑ|]|V;G'_^5sF9.=StK{;kz*|>Wݮ\ȺQ_D )RHG(Dw ^m{<߫[qg;.Pŭe@qDa^G7|>(j!A=i]}Nǿ<IH8J)Shp[BNuH| ^4F ciH#!׮]㱵@3g8xy嗵D& &MNu8+WŦܹs_ n([`ŷŷߚqX,X |.I*>FH8kժ>;§e[e|ۅl G uL@44h߶mڗ |]V4lP!Tmk;;zf  lￏ1ۥ $8 Gmk^3)!ap'L9J=VmRHIx ӧOhђ͵p-Y&yhCJ`bpHX]2CY8+'|1]|.7%]};{vKUA߰||u^ju#bNi?_oX^kϋޗohjTII啭kotUoՄj,XvaK_zaS@$#cj'{)8L )s(\VV,߾MY o   piY>a@Ӳ+CΉln\;1ɘݦG/W3>_W@^Z·j, _`72gԔJ싔,mݶ 'w;۠dW#ϝ)xy=!L x+s$@$@Ƀĉ<R L:B;TO?Ҟ @?k֬too%F8tc5klEc뇷kg78L9DCz&Ă19gNIh{ C I=>υ9pA/:xࡇ˗'lyߐL3Q+f[E#N-ZOK+ڤ0%]ư ~GQ?-Zu>wH Pz]˦u_E{OLI8_+F[VߐJ_nER/( i--")mp_VtYS.\hrOA_wlsk25O(.ioB1q"P~TW$Ou:HYIBiزdʜU>}ظγy<ڢ4Й1 $opz{`u44\/Ϋ.[P@pԯ__.=!ԍp"(gZoff˖΅5 ,Xvt)c+uc;wԲ2ع3bTRfn1@EHxt3R>ex"TժUu6d8qm c:KΨ34!y+;gj]23 %={ъ Y?4NK6\51z8<&O*u|YPn=y䰖AWE Xh!Ľt6cG zK\^9Wڲsu[2yfݟ][7Ġ9TT;SMs2c1um(ڼTs#+lPV=_~S$̭ܚrܒ !}s$D:$4p#'t}ߦ=l)wܿt 6L't>MLD7GgCgL0D7CT2e^'d mN:i=vOY(stAw%+~$+'!sI2P,@8u8dLXYqL̛ߜJV[8 CJVX5)@/ EacƌH\Igٳ<2ظq:08o+A2)~Ak$RE.zi0TSn YfZ^رc2o<ֈFt1h/\Ў &"AN9GZ6qdO0Aʕ+ǎIcz8 G4r>B:GHXjNl "N:vO(a?}v-uݳgO?"ӡosӎN@[+v* #G'cySd٣·C0 '̜0, ;޽{˛oi1@VH&m~혌K./pQڇ2~olT^`Cq "0{'bg.U%H TlҒuRnI@֮&USJFV`1bD݀-7g1|m5o" "&=P~4 &コN纯gz! ޽{Cvl1LHxhh +66֭w眔$&qė9sfĉ!^l"Ns}u[u8:ݹd3Xꃙ`Zl}ʔ)tF…  lGvndXvPuGZTy #ƍ g|FNg;Ƃ(p82AYcSF076h@GB򈶮]`yΜ9id+WRَ2dȠD"x=$}oo0TFGcV:m jzޜ(hQ38K֫hbpӰJ`رcG=hw@NZ3t04c3m?[dt ftSː@X~h4Gq\T0#ܝ4DPzO(Z\k9 Mʕ+k&ٰr@'juvs/&_[^# M|H a 0=ac퐎Yn)g9S=# ϝ;?x =xDu#b\trW8Bg  {bŬWDQxu|}М_b 6h}pd$##ZrpB)0+.H^bM¬ĽdtBe F!i tۍS%9ۣ f\NJ]]~L}7y"%KW4S8J@x#woTxHHHdLJL+Zv&$K<#҃/{Cgug~\:"1)W|->-H F@DJʘc7#Gtpk|$-Dty+C=zSnMA駟֙M9,@h0㌦!C܇S\K,-g07n٧پM; N-d6.g>_$4$F52?}J2<@@VX"tb$+ޠ>}A-S6S[     "dԩSR՜` Ҋ44v p7czWK.P&!*f/0eLҥJ2 ^O]8َe%J~X/;B CӰbm۶ZfJ*KaI 'x6aIV HΟcATUgR[;$ýdcܙF-S1 @-!?"06Qn "|'NOaIƣ>*?c * `v飏>2kG+Vjq'2Aז-[tz$FҥRB/_HC2]`/gM%6m۸x;GDrI&y͎{M0A*QNƲNh; MHHHHH ,@e}ft?*;αc e|7A2TD//[L .l߰#FH^1vpzZ>27Ih{ "Ƒu,x0Q fP͛_"JݟlݐW=)RH BCe' CԩS۪={=Frޛn;wwg0& W:ZJ8 QL|oԐuԩ~V ֵcz}+_2C~'N8.͖n/rHHHHH " d˖ME?yÄ`\Y>Α#gyiժCH[nDHppBН:uR(GҦM+]v p݀N9x| Ǿs&YjIr9OhX$a _~Yׅc26cƌ>pCS|1Ɔ\pc МeXѳgODŽc?[޽8`̽R!?/?TEnMs%nϒ#d͕;*y? @=,6:lpΙ3G/0u =f8|Inu-9mOَZFOl98!,w1=uFY?CMqnvfhY5gڵ1i]~ݜܶo^k{HѣiӦXvNfL$wo߾tFNK϶?TsBAp6X @w "~w}~}z۶mZٔwDW_}%orGKXB3a-)ӦM8V' +I8 kݺٳGc‹/%av-Hԗ9Xfvـ,!۴mw:_`NY/uLD`駟Koٲ֩GT;C Ѳ<(DY8J,9`ǎgc5AB9|IT9ۿkZha9wp޼ժUs^rt9w;JjQ1_ٲJR&FY唷וu^S []jsW:u\*ۥz{ {qFe+-|{~lVƸ+s5)J2d~Ǹ?LȄ>| 3|nHڲeKlyHH > HFcp0D"rIx@y䈴'-ID}v VaH*:tPp=CbYPHjFgɒE+Wo@F'O<)iǏבa+$Ny/=ܯ$v ~ajbRLO._\J/@Hl@w|)ZhT# / xz;|=$Mի'*X;Ν+zE9;ZHC›u١9BE`ɶʕ+埱C$@p (P$@$@$@$ dp5j4ܕd{̚5K#K,_-bI21"X'gTűqƉJ3eʤ5םGy3e:$Mn ?ʕ+>1c۷;Coܿl2pAbpE{nݖ Vv  xʕ+gNE CǏGx9 ̟?VRn]=6+(j(e$@$@$@$@$@$@IG:$Mrr!$Vrn׮]sΒ;wn{lٲ:IUR17nkD)kHE4K/$nAL G5k0,ۣG- OիWhsqH* g< fR܋Cs%@̙СCn{solG%m۶޽ 0s< i_&11'%C`РAE0C*F$@ >}z9wjÆ RdPT:HHHHb'RH$eb IR>p CxժU͡f̘QG;OَR$X]އ3 Yd8aD׬YS|vgߝלz;#ڵ ̙S6mj:uƍ~<-EҢE 7vl.0DŽ8)ZjE_4;uj}CnI+ ~l' JƨnHpK$@$@$@$@$@M%#C!ՂŊp w8Wo)Xu]:j֟>C:ѶLr办XXX]eʔ?&bwbH\8 ` `H\/}K8F E=w NU   H :jIƒkDC+αaKɓz29`۶m{aav,l߾]/UZE>  :HHHH ` o (vtޢ=̙3ubyF$tR[]%l4C$@$@$@$@$@M$@>k٫W1wH 6N VH ^*UWHHHHHH ~ {D$$'NH&M˺ J`zZ$UT;$  HlBQ-      t. 7|#!ҽ};$b(BN;dBU @= vH xgh޼\.]YѢEeԨQW-[Ȟ={:A;BM SCM @=| H QFri]C4id6mxے+9sء+WRwBEٳuV[#- @T=*F7Ν;˚5k,D+Vs%oX.˗/+q2g,  v%     st N/?С4ks%Wp(BNJ*fVE$@$@$@$@$@$pw} ;vH6ms{;$\rEߒ-[6)QD , E~ab!     XtG[ǎ@&piذD dڴi2e 7~{ISi$J/^t~{(.     t^ Hm۶}v}&LyX U/_ X(B֭$y!sɒ%CX;"     tû> D`g{z!tZ܉ŋٳgRUƣBpVH"xHHHHHH ^Ľe0 $ok׮]ZpsC)'SF I&M|=$++ʨQd۶mҭ[X" @d=27%3gHFҥKzHl9yd%:t͛g+[ @֭C]%#     # 7]!MrO?-Ӆd=K,o?,;w%kժeC$@$@$@$@$@$@$@=Z,K$d'NW\9Æ*UΝ;zǑ $*:7#EIϞ=Փ^zs!t3n0$y/ |HšcǤiӦr| ~sA+VRݢ @<hH qO)S%}Ν+.eʔ1s$@$@$@$@$@$@$@ Gc˚I$УGYdeذaRti{SN_2$@$@$@$@$@$@$ г}˜Yd͛7֭[c@_l5o(C$@$@$@$@$@$@$Oto#H8{gyF\.n;#F$\9YX|oz7xT^=Q8]VM_xq݄l䯿VZI%0N_ַo_[2Q4      )e  @tt4lPΞ=t-hԩSG9!0{lۗx@nV{;&Lmݖ%JݫWO>ĭ?ypQپ}>u%{@7侙2ea0^3 "w_dxH ItQ֯_o3f.\sBENL9.]Hݥ@JSR%ywX9t4<"3f-ɲ &M&,Z( PC,L$@$@$@$@$@$Fn8x@$&N(G]xq;$*;v~a;!ÇOnAv*J &"EnΝ;{aQIHHHHH @{XH l۶Mڵkg(_[T{;$3gδ G@8D#y˖-r)Y,XP>hmȡC… qhcuc~=@ɓr}I\L-+ٳG"Ev 88u anIҥKg}n3*޷olڴIPB:76K|!믿?TPARH!]w]ρ4d^< dҤIٴ>OuLR6l ?VBdϞk[Γgݺuk.=Qߡ{'8@|rgx7w}gɴ- @P_0h$@$#ɥdc!Uu$n5j԰+$Сr\Tbc~;sN}S _]!R)y.Gyĥ>ԡ.% R9yw1]*Jߖ3UNQr/^vrVri [9o~rm+[nnR .v++Wl\{(mҤI.5 =lQ/pk:m֥63d/m_|\w4>.D?dyw\VҜ0ydJܾ}{}@*\r#GdKILR2ݻwۂ"o'μqk/9rą¼x.^h>;s2D_VP={͛WGJR0:*ʒ%kĈ͛7rԨQn{gkVXѭXqD4ibcuEln !jHHHH 0tƋIBM< 2J{8Ͱ>p#ТE JRq#|n݀sZ~Bb#6;}k͚5.HDlNog=;vt]tYmg]45ƽ*Ueqs͚5upBK>+m"J^]|9cp֩SGK]h0<1^:[j{N & 8\t}1-Zd#t]J^3;t2rBoRzR01}RI8'Ά f- $ :3!   O{66MF$@ AF]=<~~%KA@'*gO%#JVɭy $)5 yҥ^8lٲRZ5Q nu!yf\N*JrCԛ)Ghq}Iiiv<ˡmy:A3k5WwQ1d/rؚgdҥ&t"L%Uļhs3#HN.U:A鿊A*")]bհaCɜ9[JHz&A J.^3;Hk0dzCsCMy4hMVw8. @4=]”aO=( C+JA@BPr"r1݄G|0!Kɪ~ZTrϠ2z(]FE,57?}VɘE(eJF%}dH*-I@({3f;o}c}&;ul{vsGISk+S;x.M bŊ[     ~tG{@PnQvd9s젔F( w{);UZѺ*!4kLGd.B>DtSf7~q.N(MyA;L4p 9rD6mdG gXR$&:Çײ.E^he H`=Z;!_a(74Y^rz!}ٳ2k,-EMrq*UĐɀN?dt !ۼyWmۦccp֢6lw^ą:4}Zv@Ƹk.6}lːѾ}{;PeGnت5Lt'x;&>TrP=٢jMrhΨ`E~a2<晃ѝwu,e~X%mԮ][Mh;ƈ J+*9SGD VT JjփWW艘] [cP Z $*F$@ Nq)7Ro !SEs:ѷ .0ضkNOC*β*aWIuҞv)a 6*Y_;_zK9LOضq.4%;cϣN{}%R![C샒q)msJR5lʁRNme&l/R1j$q]MfVi(c2nݺ}8JIey-R1 H ҥϥL& ˥#NRMX(%rp)" єCb>DdըQC0@b `dq'|iMjժ*$/ݻww8,/x5H N9߂eʔ6u+UGI=nc#QF = ܈B60mϗ/ujDgΜ9JF)3fq מm#Y%Ƌu41n!⌢ӧD[N K=DMhI_xrȡc5F1$|nѢF{BV?<3gLe*?eIH)B(IhQʚJV[Y)J"$Ri%P ٗV"D"D-:tf̽3s;s}sM&Mc{*9G|nܸQBTR3;cmkhP "8!bodtdA* ɸ<7R-Bj7dFF7m^y4HG@IDATHHH 7>#<@֏Aڣpxu7H֣G=6~ ba/l{5 zpgp؈Hħ_$E2>O'+p!FYI>spf*Lm5kW%S)bXasَ c8K$@$@$@$@$ $+1\$؏޽ۍ.~-HCb:z9&rPZ>$@$@$@$@$@9@;ܡ i$3k{$o3f}nT-/XG'|RnMLukB:ukÆ ꄇ5D';T'K.t : N{!2* o#1W3>Oǎ+}I㐆7FXv;%q`]w6$WB6j?]6PLH/{i斦09 3'{$½J\!L"0eg\Y=(W<Ímȭyɸ!+j<ζ2㩾ҥK{Rv [N}2xj){ip$@$@$@$@$Hx)$={héHnhAݶm[I0?F#G. ^lYS=._bEt .0DuQڴiĆ*^z8ŋeĉ·b6۫(~7o6~WK׮]U*  !J̙*ɜAWg~Α;$$\mL {/%#F࠼픓I ̔|;LՔ)N$~N*n@E#     HBZ3`}c"ҌDuFf9fzvbFݙ?~zMKۛm PxF1ʬiK?m׮];[=`r`1c 똽9G~8nF27ӧ'8#et>p$@$@GHg}˖-K=1 d}pϾ bjD}Ό!׬YSUVZft}"={ԭ[W)"{SO=%AHHHHHHHH ͬ#g8IB̕+W]Ќ,L ˙motY Lt|ĭ2dH0? cHPY2PcdY5 S'=&$-M6͖1$@$@$@$@$@$@$@C H_=#6iN҄/ ˠ:4h #k;w7$`[nuBXN)e~ǶI`۶mҬY3ZdIARc9r*'0`X>Ed$       xHxC&OFWR% $(gu(۱c& /+F-ŋ:hE]S/Hjjt1!ZժUuPem;d:Gqs? )o/?~J"Wk$L. `4       L2XF$Ilۛ䨲rJiժro:`ֆ &;OVҥK6:f9zm0`@;pȀYđW˖sI$@$@$@$@$@J`޽mߞ]3h&ɕ+w{N'akk"~c4zvئM 2dqoHߩS44/=cM6;#jk:V hk$fyFhɀۙ3foGќ#o;g?O>115ddeP KL2in  ˖-Kys$@$@ݻyaE\F$ЬftbΪ ޸qnE-~9rD MR!POP~T @P{f 9\4Y@'mhȺMdB:HXBuG:v8tMRI'{"c,YGe˪ $y0O *nF@^&Ϙؒ1qk _|`9S ` ճgOp}HHH U*THvG<\pAL$ w߭2Ľi&9Ji 4yy OKz%M_pᡢ./Q 'kԨ1q&9cN% v0&tՐ7n81Q 8qB$@J`2h :tns$5!$@$@$@$@$@$@$@)B9ќ& ăI+۷wZ6WH  r\ŋKʕaX @ =N2H ~eϞ=AD4H$r2HJ#       @{VP1H 뮻4q1ȑ#5o9rDOΈ. d:ܳ2AN7ߔQF֭4i $ YfΝ;u8y:u$8        @{ dNXltf͚ү_?w+$Hr2Փ|%8       N~9=C7t:1uw~2{{@4{Qp4M: ۘdlg뮼X3s%:|p4$l"͛7#GXJ.-oq$]B{8R,'     $0uR ?_R4}tk$]WeϾvj*T\N=R^Z1m.:>#[Ǐ9eOwCxŀc=F6~SN9`@yѣG{arLa#AY44X0.7ߔO?C5H"~m塇qҴEI gyF4طo_2l>|$HǥK+L޸q<HHHHHHǛjw\FqF6}Rd޸~Rԓ+ջD\߬\/Xhyҿ3e2Է&;ep?@+eo͖onqMw?w&s?#rꩧ//Z;w\8K}Mc8yc{rK~7 %^Do߾]m&xʀzN*b Ob  $:ڳ_mq;q$\{84{Qu3ΐʕ+KBUWg7^;餓4[uDnq%_|O?ɒ%KXbRV;v5kh\rYg'O>dxIxrGsM%Ke]m>L~ںaesFzɓG (8g19C(TȊ+i&UTѺ!;{|E{~;>|Xnfu  &21>ȝt:uOq+qHHHHHH x ~S9p6r0/Xvk*Y7q!ٳ|W_#U)Ŋf uZ؏oyLM,L Le*rkb϶mJڵ5㭷: -ZhѢ/7nK{թ G9#rԭ[W.Bٴi~Æ RL=6aG _^fu$S-U\r%Q8.ǻwNj'u8g`5!,TVMʖ-+Gp[ ԄJpcڠ58sкuk73 BP7A[o s8 oLjsΒHH }]e\ @N pR& w*Vsף]/j/f.{Wޝ6W=yXjiSO.(CQ"j3]ٚV*<$?_hRzE]&w h`c航ڷ~޲P됙ċ-nǾcjD=db[Xv˪U^6 ټy7mljv}ҬY3Y;rVdРAn1"nn"@u쳆6?npxrJiذ& qm<؝JNF[Hp U.IHH e & 6vhS#o`UF;G,^.]*>!,^C6ǽvwKŊU]pr-;vTɓ'СCK/}skŋeĉnȢ`z8ἆ!}*ɂ@ytn?~>bY2D:t蠎q$E9G < pD< ~FlRĜhsګW/-{'?^Fe`no:@+PGW_}߿4iD9P4H&_l'k6$@$@$,^4  N3oڦ~3%\7>[9x谖oRqؕk6jrTl\njvwJ R~ΒrŅVZc/!t[$r26'pC"`ҤI8t޽@C>7)p.`xǹ?>̕9:u@gnԯ__&ݻWw}u;Jhx㍂% 5dOO1^v 󺓅nłdeӝe[ jUp+tb~AI3!yD%O˪-󖭒 KWweEϔU^R^}Uuox׬YS-[:կ8<0L>9˱SO+D~z:ù?ӭ) svomw :$f2<`Nz!6Io*{wV27ne8pvԨQ8@pS OXC6$@$@$@$@$@$@9?wL(g[!_7!]&NV?r䨼=ߟ'cȞdaSM&}HK3n$,wPvqǩ7A=ꫯ sΝ݈moٲE y'U2.OPeT k^Y[f^h[~ӛ۶mAk9 gs-^fjeVf6B?vKHs0xLQ̉$     W&la>-o׎#dg䱻ov}Y>HMTn5~4lk3ЅGHY+?2pm6noiI߬=^R?h+/&8-VXۆL 4yAd68;P{{O[o?#zO?2vۻQ(R:Qлwo-/X@N R{1.tڭA~t!ER'>r~ | $# d08HHHHHH z^ȳܹrI<6dZ:pyCŚWNe DovQpbپs|6삳u:ի2%eHx; $]tIC э6̵!a PYC%; HoC "ʡImD{~] 8kM22:uҢN8As=Wehp7o\5ޡb@Yk^&0a{24ܼ&;C'eh\,Mp=m4wowQpHHHHHR? X{Ѯ*m&Z'_Jhѐ#GjW V8mv Y8ac?#1!cctbH? p RmR)VZ m /ֈSO=u Cŋ K M2n8Sm?uϙ3gj3ΐMٹsL1B4Z0ܐ>M F4? K^Z5u/ZHf~-vکwkHNk QkqM8Q*k5ڼy>`M䊨ӧK|K?׎)pN↎=̝w}Wpi$Q! E#     H 쐎N O]_ݎv P87)񓡟Qf N?$Y)Vٱ@R$O߽MO:ʉ'3I_kujܹs $ghE ݺu8zvB7^aB:E4K.M}!RhwȔ נd^κMjpӧ%dgʞn w_@͚58Cȑ#[駟VIH@cǎ>k7%n`Ͳ^2d/A0؂{o#">C`G* 4H9PYF$@$@ICJ5N ?S[FU$==nIX CB/ NU+V٪Q yNj@sO v 1ZH{IH2d2*$!SU,d+*۠AA^#>k,ٶm[ӇdʕI'c+6HY:>@~ѢEnviw$f͚y%ccǎ2a믿PI&oJ"E=@ +oVdŊrWۻyfΜ-JޫW/0`{C m5VZ 䓂 =# . ؅Bm۶~ .$@$@$@$@೅qb-   0m4wqQpH {˗gPKqF}q}qގ;T K䙀 ^1b;۱ /7o.wy3rWʸq8I]F,cF?f9uݺu8pۧ'yuOj8x74_~ 5IHHH!tp @Xt똀dCgp @B@.d3+2d̟?_Pנ]fM)TXt"?Q s=W%?w\=zĠ޽{+q<3os D@˖A=V!  l%OH޽u nF$@dRdIٰaCᔮXkذL<9@;$=5:3={pCYfI5te[lQGW։v=t]C硇]^{Mnx1nXƬ'&9SISq(:3gD")c(v+O fҳիm>C55hC}/7x IHr|w43s8 Oɫ/<-/|v%|OIl<<4 @픓k #dMjX~     $($! hgqFm&P9, Fx:}>;"c1Hs@;O|̘1Zvjr4,8S4O?n+V*Uc9 E8V+U_RX1A*TȨ Ln $8ܭ5iĮrI$@QpyNP?EAzny AO> ޥHܴiS(ܳg&6lց$ "-1_uUd[6ڱ6h d?ca7QSjHk@?IQ5륗^1$@$@$@$g ?ΐhhƍz$<3DuI& BRǃڋE_|\ B F$SAo!۷o>bʸAH2c whqQpH xJc~e͐U9ssT}^x&M4q~+ڵD 9x֭ӄcgAM{X>S{ٲe%o޼j*9tVøƎ݇HءCw۶mt:7~<餓Yf!Xv$9w?Xpc0\ 0XCmVm.\(Ƒ5\^Ƀsl ItqC27֭[?qYvop N#   L4yԪټysY||RH&oJǎݶH5~xw;:uȗ_~V6`2$c0<^ ЬxʊqoY@?x/7 h"t2mbܕ+WWzۑk`Ë{oH&gsGZjףqGҜuH zgx8 '0uTL2?&W\uqxDW^iɝ;wvhꩧ:=zpen;5.q;}uZj\wuNv맷˘nh1O=XI1`瘃f;f92y1|d؏zׯwxD7l%ښD5\wɓqM{1&17¶{ y @ٳgς$n#9Fҿ7|L@?e.Zwvu=wFE= -Js2n£x$8=+TFW'*c1x]̳Fl֬Yj$DZ4 KH( 9i{ 8CvYgȑ#eb* D#%ڇkk;4NLyGfTXƌ!-[rF7D[gXdɒxv^,Yvz;p&N^ }G6 dn 愧2N< `  '… kb gma(:p̊+G 43xnaD*˪IsWmPZV1`ǿp`jN>Y#? ;w7lF8֌1I*fLLss饗:ƁH߀G7Qm=)X\!QD fiFsLԓn')cNNƇqQ_ پ{r~14OhX/i^Q[nme^{Nx%E$@3|_M4K1ajÊmIHH wAH\ w3j10YjEo+$RsxR/M4}۲eK1?p;"1{0A]G0aDWKʣ>pdžMįǷ1Dq`ϻ;w!&9SَYB?쳰mD̙3U  Ji~lI x8vU*2| 8P͛%tcf׆s C sH%d٧O1O^`C#Gnv}}3Iի|ϫ. *m۶վc}dX6-0.ax,$N&O4O>ILµf$@Ne5 e U?Wzj|>NzsJo_HHHHr \ٵ[n@tN8A@j%LiwjժIZn] >qһۭ^Ii׮ƻr;P޺3fpfhb/v#A5D#7jȹ{Uǖ{z]sdFn%cr.ܥqwyzt?t\ ZޢE -ҥ{Z编(P1{-EG5Jr?\LrB<} ua&$o g(Ax w[lLbM /\ģmK+7@IDAT]YV#HXKOv+믿&*;d d"}zdZx_hތzLWJ 7i$@$@$@$@$@$@$@$~Ygܠ۞7o^w;J:pRBvuQl뭷T9\#>#F侑vi6a&db2-n_bg| 4=3ivmX.Y}n 9 X:VJwaUV-{QvΕ%`d׮]:]2ׯ_ft^nsaJϞ=u'Qm5h#QFS$S9d/ƍp)뮻N_hWO:Uj˰6$~Z| {C7 a ^uբǘ cK]VaÆ̙3uP2.]o!Ctwu+WNǸxb3g0͝;λ +ohS?&#F{ ۸ikL2Ч1Q}RZ5h"۷^3hpmH(& Pfwk_| zٚ>o,ph 6mJ $AF9KK       'anl`%Jh`1åI#=5?hH;F1i-Z1N43mӦMc1ZH&1ksiӦ6su,NǴ9})iqΈjժ }ej׆sd_\S&< >}dؾ[n!?tۖ/_N:ny=r57sS۾OB-]M̀aÆ,GF$@$@$@$@$@$ s}PcŒf!޵kW7h@~Wʘ1c4o&u=ۤIEQD{ ( ͚5S}w.U EXb*^kYTLʕƘ1N~oU^ kÆ ʱ+WdD0HB"^I{:HdD4#=ePvm9G8V(K[>h#R/H8l 븾!uM5敡e… {1o.^n]oرr:\ @|2p8xj :õ[qFuCcTR}pNvB{^#/F:8m^dJ +pGⰵcjVvms I$hVf[v̞MbH h$@$@$@$@$@$@$]n{6g0x'O {IHAH#G;&֍1 $*ٳgk.]ȃ>串@v]ul@MI H^3uJI=1 @6mXg; gD#T!Sf#GL)sȮk#!VI'@6'   0p$@$@YOިQ94~T<" d <ˬ9* 5aY5f{<̪8YCW̚($@$@$@$ S IHrG|'Pp@ؽ{ o 2m0u$](w#͏?7LwM:tHH8xJ*I#ʕq&e60ŋ !^zv{޽rM}'˗/۷K bŊ:_[߻|wJʕsΉU< #]qo 'A;/|Hь9\W`<n KISi$@$@$+$֗q:CI _Njk߾&se9Fr)͘1 o۝tIN:u,ϟ>|عkΩ^z@1Nλﾛx 6vi"j-Z8s8n\n1 mUwٸqc4ѺOr̙㶱+~>.\'sرc[52V6 $x7뚜;wc;{Ӻuk]8f}iuV86 N:w 459N`.j~%HHH ܗ7:5aW$O%Khqg6l<i*yW~F/mmH:q;FW]Gq#=.C٫ٳg@ݻ>ܤ؇*Uڵkk[Ho̍4qwavbV6mG{\?sMQcn<9ƈJ#ϘYfT3f?m\Wb   H1pOtnxHHɓQ ]ٲem &d^|EMj3ϔ}jM7du֕5ja\rhnTիW뺟N0A[n> xn#,F]v4mf,[L۞p bnZѻx]qo`n^U7~Αa6SD[$ƓM1 /dxt{Ϙcm?V\'   ?\= @tr251k@ @ٕW^nTToq_~ cݾW 3o<_we6 1e4s1e5iYfboDϘcm/ZV޶\'   tgWJ$@$!JG (^n۷O>Bv,f$PT6f-:c /u?5OU~ >T6aF"&<7J*%FJFLV)VdB n?Nh%^0`l/R\s5R~}EM< Ϙcm#ZV޶\'   tgWJ$@$!O?T>!`GF؜H p#bn E:,-Hi 8Py[5`v~˗O;ҥKiӦKҥu={aÆ6"JW]u&yEȷzKw( IrdDpGbVHDj~XyaH o[?7^?~NNӤH.Cy79ֶ~+em: @:̏˗;wyS^=MetZl<3Ζ-[2ĉ#{BpDO^_ڥryvH؏=1x…4gȱڵk&<91Ȉ@>}vLf̘<ÎF\2R'NŊcqnfgԩ9 gΜ9ѴvlrF~&]4_>3_4X8 gwn"Vӧ;Fޙ9sctcpZC2Zj\r9 r6mdwkL|_yO[sθq$os3C[1avbV6mG{\?sM"9roM x/gnO\,~짭+wf%mu  H5LjgHйl21+ndRDkfcP|8p@gDhğ^C"%Jhov֣9nMi18& T)3261RdIey'f8Fb62Xb=n457O<rg{DnӏfvX6*cz: t&V^{51Oi^>_/fYiaҊFGT Me졌&6H2fZt7~̡]zv$23k"Tpأ ڛ(+{4Koնh1Rp4 y޽Ņ JC9g#1H91Qon/d D͸,9~I8Tk. y-b?& d"B::p]XBpTREP7=ϯ ntup&Tz%ԧ\};F\!T&縉W4hs9Wb1b6bM;_"YGb_IPuO[?UyDSK$@$@$@)E8/^GjXqz;x'QfNH1XCBҥKmqmgx,T!98ul{ eY1ЇqxcV; C6_xR$YcF"ς 9fQwhO+`0x|2TRR?x,ڶK$hCR<>1Xِ^hތyCj >=]G223`O>Hff"lS.Sp- A$H >S~駪EGH -^i+!pdXN$@$@K27pv ݻ8Dp3gN^ΞG>9ycb;/y\Ԏ1x똑x-BA5ss0hÆ Э >?pa^4Lc̙3U W5ϘMJz,]T}Q[nI8:40K뇳nC : b׭$ ,C~w}H һc'[Ho_͓% 9֬Y# fHi9&\n|?$r 7a FݮZjRƹzDSET=kLbSeltUmlk׮-X*[yƌn݌"cxc3PL[O laFJnpwyz>&ἶhB˺tg\0(OˌcZi{=ԭ[7 2^+?wN8P & UeEv޼yki$@YC}&cwf$< CdWYEΊ5IH sy\Ǚ(@+čp7駟.g(]$[|ݥcǎDnaVp<8WDI WQwK!G1cƈr9ū]2_9;8ǼFxJɸSN}':7oj֬)^˸"g͚eHgXp[W-wwCqQ8X>CS(H xzF$5-dx ["gŚ$@$@KoNȗW e0;@5#mAo}* 92b"qDI4 lDžS2o=y܊w u8q Gf[o:qoG4Ig]hXB_޳g@B fFC[[mJ@pfX,cΌqDg_;uk72v3`Z*U:F޽uŵc:-G䱑píDR'\[䬰h$@$@$@$@$X?B\Sm?m:ʆ { ymrB^Ij/?m܏y7tJ^mҤ:ڑx^ Hf\Gc:uaGHD#{ [4Cl~ZÆ muw&-[-C20)p#*k~pM Aَ% .# u~Op xU"_͛ Xv%Jhނ],>ѕW^LKpz]{#m}_$B֨nIpI$@$@$@$@{6rz5\O@'8o-[9*U>:mڴV3:Խ!߰}B uԼւݍ CM4]s\$=˻ϕk'j%#?-  (hqwwɒ%*=)4#hiÑgvlh>p1vNvw"-/hi |AA܄l;x>ub /܈q'0tP͑ ,4  {}7rM'ӌZrޢR@4YFgڕ iScȧxiMbZ4m3f{\ +V~':/c*UWVyny3Q]tQ;2IȗUApdǵ] d gc$E`ҹsguI}8O#>yCw>\A}d5~"o$b B|Xeo1.9L Y-x%ə9gE{Ÿ"Hr|ɇ1ƍ猉q$!q#G%V!6HU]Fv78dOH + Ss!ې'v֭Y(|>P<Տ'Q!y2eʤspl(}ݧ0 6fȍ9UH@=7?nL3)^$iݴ:˗|Ib]  Q޽{="f C#F`׮]:%iK9gH;Dek.sqj~<=7vϾ d&䘃I*{L$ ٹsvw'O$*ys1}WTmH[ƎH"'Te<5`oD/U⍿o+/%fݴu) @r2HZ $x$9/`=k>h|BsH1j<^>q<<9C4/)0D? Dsܠ:g<*6\*&P1*"Ĭ..0*u9q *f0"" @-\=3y}oŷ{{hUVY?'knC 7}t+8bǭ >|.'oXN3gmesa6 ϷOO%F)mD̍JIc믅!0ax_!L6c|^u_~P*ͥ+QȍT&NMY (\G" EG<ñpd+N4#aZ.̌3f;=={MLch )Guc;4rȐ!/yCs#J[@ĜtMC={2b?|/!*a+zh)и5tPRxơ˪6:*^ +>y?fCDN:-(NTu:sq~7no:|>xs)qz-o>f7Kߣ,jn{$77/ 9Z+y[tZ5FT*$wŒHGC;544_`߿#\7H-?e\dK/e|{lԨQK/sPlN، !` ّ#GΝ;$Ǜ͖grI{wrwxi7Y~)oFOfe;뮻2Ҕ;72 +E;7*1'Pnrzh̝#^wyiBlbrXRU% hui{%92|f5s\_覿5?wqGʌ7p{;b#~0;<1&l-|w3SN't|GN>dwZvj&ڒϊ7_y\ljbm߽IUL39Sotsa2Sq3gڳR:;D$WH%pW[mXO@jx+̹SN9%W_o2v~؎LŻ „#A}ŏj3~jY4 %ш@f4b|_~븑/;馛rP3x+|A[yx$>O)Oj< ã[n^,8#$@rFm.bF%$KƎ?w u|g.K.ڌ7;ㅠM#F!;oWw9i3 /e^UpW{ܸುHxr袋.5ɕ8Gz"82’`p17CŠO6"5+'{wukva]vg0/`|!ݰaƩX=zI-̈́%c@_;7?BPu=sB.K.!܊7MҌ>zOV>^wC_`Oujlgh p[m{9sgU(@T&" " MJ ?"/&K@K~yŗ.7 t|wC$"t_8oõ!kvn~t(jʩ7 qE]{FÇk9qq Z9yQ>K0u$6D7 p-5Zv5os#kAE^(rF9s2sgݤiD0IZkG"IC $/x_E72oFi8Q,byU{p(dCC$v5DqnVndt "PH?kϱȋ@S3o7zةᦨƇpx-vu]7/z4s駟ztP0k^_xfwe Oګ%6uÈɛ\c=cAL}_}3Ժ37¾;'üvd$z/L"ӌ+#Ljc;!&Mgg5JSY!m+1Jy/# ϲ.ڶm7,f 8Z[,"P㽞HCK9|W`OmKev~o>7Ym4>/+Uj&_H.Ê$/sV#KZI>j+?ڂ';{fY1׹K1{s8 g+u[oճ"2U5j>lhYyNG"P" 2K(0|L 6 y*~M(3czY Tٌ b}YdKR#hFrFXms2kDŽ4~e3_|\j18UBLe-9xoUqƒ0Vsꪫ\ZblT(K}OfcSnfwaCoo%i@&Fv{M>|#\ y9zl>n;;J?އ!\[U[o*]mPȘj qT'"7wгF~xbQ oפ*r3Xo/+~@c~_Wbn`ʙ!bdc)>}K[r^cU ث 3"|{韛*(GDn5+1t[VH9|&Wsz i(dɋvUT{^uND@Z#<7B{By|#j#EϞ=)%\w:7qs/`7kDXBnP4  AZBq/;7K}]l̍d_~{ɓ;0Ɔ׬6m$GĄ|qC`Wv|L|N/^qZHz]u\7`{/r^c?'VG-Dnz㹍X˸nޖ_~y3B~k2,cRFR-gnXS8o+0yj"J{TᇗSh,gps?*ýp[F{UWMz\m[('x W< tF x$7nEb M<1 ˄@C&2oMLh;W9SoZA&Lۈ1 AH6, ٠3ɡԹ,ץ[ܨ,az.1' *n }aǥZ` W9yլTayƼf{9 EH{H{ po>~/~ ,G(d:_?x`Ԋo#ؓk,[cǎ\qf$ֿD{QJY~gvd'm5.Ƿ2#?1sis1d<<%x9ݩSTyomIIǎm۶YqG?̳1ֵ zJkc @ǛG1wIb(%mrs-VJ=1fy9m-unS'yKܹQnKjr6,U)mԼ*n$mL)@CW+(}#Gtna0<@2Ó=L?>l}hx RVIAe %\3ϳdyg&^{CvՎ&K>O,GC~O`ر)XN;aL>nDs1'Fk?tP_T=ƼXguW<'D:mUi12m6&=㨓MdC=#bޮj Ӱyd庖^Drͻ\*Qj#P;"^zi#tzРAؾ[[o5\ך%,lpֽ{w9 RK-Vރ>,|\GFc=5\cY=/B *f0 le|Z_XÙa\pBpcvfj<ӏ=X?ψ\B|gsx;|[̋1D۹͡xg>p3Hr-K^ g~۟C7#>PJ{0: \|2^.gy&QMȍ6ڨv;@Ý~|g^y}ܽ^4Me8s駟=w&<fc({ӎΝ;U/dZRΕRtZ_wss{݌I3Y'p?$;ᒘ] 3fm'P>+$M2tu 07|c!tu 8JIx[  Bf`pΓou=@.N.4zsnOt .0dL.nAkFڌ;G>~D{Z[bQԍtIow>0m Su晗rSg|ơpG}.Q!.ZDF6Q 7XDp' @7ydOly'Z/bnc׎q裏ׄA\g3H|3ƍ=:.Ð6lPyi)SonIy6$%;Hw饗-uCfW_}cU \Jm&^wu^|]Enfa.uXNǵ60{7jǸ)/Ƹ)-ƏC,Φ>Ӏ{fl"̍xb/lV&x&Ӯ˯2xkX#V~\y9ҵmI QFN2 fFu<\5n$," " " " " "T;/vw}Od]Gy;t=6sov?"w7:<ѦO$vn%ݴ?w;vNeNukwN;8{uT/#2V68f%ahBq|9̿袋S:q|1摝ӳTqL8g\|gԍ'Vϑw||?Nۅ#\}MSK |"18." ╎ x#&ؐ#7tSK?#`rG9$/isXCM M Q6,׻=r83fI_΍BXH%sL8K.{}2fC`9} 8∬{&>b%ʍ7vuy晇Y f I@djsjEY{cc]yq#W{ݨkOt\>ޫu;qcpuw{f<;~sy.^qB٢ u":Kc  NFF 6B~S[9mLۉG߭[7٭m|.U9y1Ϊ h߾}E?k,7qD^lʃ1 )A&󩧞Zu9Fvf 7{݅2J`I=pݪ+,Z_N]~w}CaIm)vGS>e\7"L<иRf봃>+#W4}H/՝|\iR򹙑3l )Sr*]v..hbd59\L9Ŧ-VOKVй^!UPJTS^SåƊ@u <7nҗ t " " " " " " %1(gR [srmE,qzQ^ދ@E ͥn}i Yߝmzkt`?FȂ|m:ykM`:įu " " " " " " $f9ihݺ,,Ï?w^F9isTwW|7vn:Hp<( 26|X" " " " " " "Pi3>2.]y+i^#L7AzPH:puWD@]=ݰaÚ )" " " " " " @%;$9}w:oǍ#Ns2 =cnҤI%U&(@ߥHO\eeK{'^/>ln-KK%·i3d|%G7שR C I ].ܫk<bwn7|O sw?;fb(L6}Akv,oy wlq>i^PU RFImf7Z{Ř7<~uQύ/qz_tƾ19>N;ͯN}sVbjC@D@D@D@D@D@D@D@D@`kz=W3}CΑ3/=,QjWE$W`)" " " " " " " " "  ,TWAq#ϼޝ|шuxo$>F^n(lLSؖݐ#s?~In_ϋ.`{fe:]^c@8abE6v][keWt/>3> ߯; 7yM;y>г^w.g)_;B͌{MToZ&" X5K;>3 EY8٧/­:4idFoFwe:‹\s[m=k:$sS1):Wu"Uzu19'ߝo#_de?j-WM^% FNJ8묳QG{M7W^y46~?~?_&/>ݸqӶD}{%lvb=㧟~µ|m:αi%; !]9lu7lA?qSnʨvi xkέ>`?O ;찃}ݠAs󷬴]?J+ڴ-^@i>ߖZw}%؉%WV'5Fu2A1:ukG<)S%X­|j=?rv\۶x뭷رc].]G_G08 ҽSgϞ+6?M4'AT'^Zh"63\s7~7}8Ν;dܔmo6첋ߗ[nZ/-B@{`W" "/=1(OyPJ"HM?{<3 nkԁI \wu;!N> /t|MFx_p67"g(znmq￿lVrbx}ɓ'ݒK.({wߍ/qOCCꫯfӟ~ʌO*b֬Y3DЖ]vYm&iH࣏>rA!wi'ynE(=ܷ8@8ca=^*QNׯ۷o%["1M81@ތ55QV3E@D@D@D& Ŏ79Xb;oV==Y(^ڡN?>.z(sKڿo$)s<6ۓ5",7ۓi*o|~x.)Sׄ ܦno>Tz+o̘1++~{22$棫" "Ф>lkWȗ#GV|ゥ)6k cDj"89B5*;o6rp{Gwm^&4 /p!̚k+^{~W袋K/Խk> 5|;s|_|]r%>v7?w=.":^I7tOSu]cF" .蛁ѣIuQ?lfY#toF]]R(L)ԔGD@0{d (鹌/N,%#!l`F-֣ sa/=So%bc6j@'je{}mIlNGXA\d\Oż:s_~{ 9ɏ|V&*&o5͍d?ZD@D@Duwy};bx]wk.W^nb97bUW]t on¸֭_c5V[͝r)vًÇ:^z%7~r믿~=mASN.^ Blo$?^݅BJJꙀz}]D̜9/-Ay睽NjylǛ؉{ЫCul,i?!܌}#n9㓆(5h/=j7*{g$'d~8%$o9w[l\Wb'@@!eaG!@ E6I˻~QʉXjGb{FikbDldJy]KcD!Ƨ L8ӧ cr|vqb;9!FVZF/CL6x5GlsG~i㹔z2R]"$+= IZ-:5؞,s?Pz 3no9u{/,%cY)[Nj='YfyB$ 'b&&x;2iƦf|UٳguY`\'[Hwy'f[v}wz2gyw$F4w}wSᓥf$,7pCx7+%v"1ˉh*7v֬rdMRcc62F$a,x w^PaRK-Ľ4C禎%[noή3䭖a," " "Pψ?{o 9klGZ5>g^Dvg6QOU)_|qnߦ,L=!S_E ' 94?.(#]}>{(ʖXz+v2Fqj2: /w ꖎ/fahrƷ{naYD@D@D ?іK/_5ffWkBp5ʱѽ+Xُl%aKJK~Mt?Rڌ7(=aQ=0]Hd!@E6ai~agR/툷iq\zbc}1“h]wW\qƽģ,]S3Z9[Nd[bn$۠" " " K!/nӄG)9ɃrSwM7(r*6?^WJUy" "P< uܸqq:a2d/C|{ ZgYˍhSmrW_u}'7|f!qx+U/\s-ѣ>껊W; 7Nט1cѣ8ljFZ62{'0o?[0o9y-sҳT 4dmaU+MVI1u2f-o&U"" "Ј^,,E, tfhiy5ȈO>1YЛ=L' b{.#| 7,lHr97-6f2Mky/Ҽ]e˧e3*nFL.2~06 ef/KsgCq=_I(0ܤTD^nĝ ?dptfy/NTgCgFI;pQD@"%^fE~SczW^WNDf_|_C=9'N8Wnƴ\c[ ywMl'Fm1V V.uᙾfK\ʛkndtX/D@D@D@{b;>37x`eV:." uH@u8@}iӦ}:{LkԩS4apu!ܦ\13B2}رn_~q=zlVU.b7YW1yen$" " " >]1ܛ  >p (1g= mFZO%҇U-ao9y[SD@D@DճNh|YnE@DX=VCؘ>k,32jhnNE@D@D@*@0XV?n*$7[oNNj/XHvBO<(mڴ /\py:`0J(" " " " "@71{GքТ.d'0[$4TX(" G`„ O>7tqkQ Mՙ-䒾MUU]<[\޽sMU>=n֬YߙVڃvڹ 75\-ҭ6[;y{U*"P+z-㧟~x>{/2_.ϫC|;v{xϞ=ݪ|>e׏?7|^D_eUs̑5+a;7|=5x*/bos>~4O}|A{/h򱲠k׮aO6ͽEY8޽8o֗E=댹h۶mMa0&|ō *l%$Ϝsi/S[b|Æ08&MrXb Zk9ף/1p^Y9ٞs+v>gCE@D@D@D@D ;n7."P:LD@D "/ ]tiSyE`/(Sӧ‡4ѣQpקeit. <]ODjá.X_y^z0K|| 74D7Re&Z1糃Hl8/bXve?4~9rdB -fm_~5FBlC n̙3|Ƀh3نVZ)#y5yoHwرo(_n04lrHln>|xcmy"?<0'LMo'[b|!ڗ }  SO vg⸟q?WE$=mO^%2l0wG]Cĉt\jU)qa: ,^D@D@D@D@D@D@jb`" MK NM,;cog/wqq6YdMF!"s0"wcJz2O:$kה0g};Ҋ犍~{2*q‰NS>~ /0NrbĿK.XiC~ #}{fmxluYgG8mڄI^s #?40vE(=f>b|azBc 4E}-cP!.nԨQ%\cΆ?Ϸݵ^Ƕ'Kc1-;owuV>l# ! \aZb|i :{hWw{DDs=7;hFFJ/7rl3!C#c1wM(# Bp燢LD@D "!$3<ӈKeFHCT )C GBؐH0 DŽXn|yQ|úQ;qh|!e,ϑy7Dr!W2H0fGq}Ѧ^Dy6(YeőA"cavm1O?tx)>g}|8,P{mhظ]Q |Rz#0@IVu_s5hӢ8]$s4/!c. :Ta_/!;i拉n4q{- VP|(L/D@D@D@D@D@D@j)MS_2H:th#OmD1ڽG.ƃ>1-tƿ/(oT\'>KG',OZܘDO>ٟ#˜gݺuK-@ tLLS JoAteqgawJJ ":ux6rJ;ƿM_*[#Z'cH  x6 7ҥKdd vV&5o&>߿ԃo؎Pg 3|ڴi^ oZWgϞKbK=&_Qe$6_xXSlT{fm𝯜R#>˱yY9[q%Ɨ9~_@v?np$ 3_+iĺGlg/7pCJrd" " " " " " 1@ 7o & '\1W#2r!.0؆ǹ6 :fL'⊌si/Bӌ9Q6=oFo=5L3duȑ#X׿Q8 jdG\O!E lf;cuS O?FUyWfLXAs/י̗pp(a'|%wnZJi| -2իO9糯\D@D@D@D@D@D@5HD%+_P6eʔXE%&lĦ>ü7/u?8f> 1m朾=^g.f8F$F< i}0`﮻oOؔӧ{x/Hmb#Л馛Sywe_/-{wupċ} 79&NYC[fe.⮽Z7b:;찃oKc_B {hsTtȐ!> |A^nhZo3mnL<.e1bFOs/Fx 6̋ۼƌFv%/sg 6pC̘ 4fr法gVD}UE@D"!yC#>F K=H絃(w2"!-o7n7 Ѱ+2 vmD6D>[!vG D71PѮ|׋i;ܩ+I]UL´fJmcFǿH΍l\W̯Z?п:w+߇9昣f{]vwbq*}Dk~7UBx۶m3. ӧO8 %Xѣѵ D> k׼Fg̚kZ5@D@D@D@D@D@D@#`8i6mBN.]]]O͔$+ bMͺ9Ʒi7n7q 9眳VNb=|atL.V`57fܘx*.zuVUܨyixb$e7X,]K>g9kɖn/0PQR6U 51Nr E 9a[ZA2kl(V&1 5/gAʦйַrVfxŌ'\`_0:O 5YaeO]g[szs,/ʙ+Yr?wy_1RKEcYltVIUN0ϪG\|G|c#B~xS5wnؘ۵jx{5 " " " " " "P%0#& 6#os=$/^&j̟rUW]Շ fXa|_ -@(< 4DIXh+ Ckv}ɶ!m>f#Q}7fJ6\~9Gzk.2^_"I6hT`FӘ'V'[l1G?mVӕ< X7ӮyGLpcĉ^xcx.첞 }#F4pq=ƶis7lDž/9{"}s% W^9x*m(- O8RË1yG=~^{m/Jž 4UCYiX ʡ)y۽{vs;ӄX [B/WE6Q["?#}D&_Ҭ16~c"V&u!RP+iM=B7crV[0$|5"#`f_ 􏾦y/~/)Gifyf޷o߾l)sqaΆԹg̎2[ꘑ7i|&˰G67 ߣv͞Eo3v !>{"f|`1sm%~'؅`سgO/zaW^bޞi묳pGZ<EL Q!Pd<@C\D|#ºuN6 EIAny*,ls:6s6bY^Bǫz IC}W*"#B607Bq*Wb;8HLBU`6!1)"1*s9ӿ?SBjرcz,N4=܈+NyeMlg r-lH1ahbY##\‡;bf[y {R)}[8Yaf W9fJ+[1 gbG]KS3"/3>~5{kΗl;Xeap>ho5jID@D@D@D@D@DFqV5!V1F!kb"=53B(F&V5,[^d^>a4xQ_6PEҺ| tx ijDi*& Q-iv=M57~@&~dO3{1-&cfl(څ =vC<|VXyo ܌5^3m|a1K;gr=[[Jr,l͛J~s!|kxqs,7nd4Qyz7m ;ōVp!'iv'+T@(b[i#!f`y$Q @F Q(kezƻQd\׭mu-YW{r@FDBf摚LP5rʖ2ܤw]9m.uK>a:;.!4I2 7&[Baks9|$?nY;gDYas _öZ޳YrnZyie<َ{)s{1 V>[׬,`gPs#WXǹ޳63y632{nJ*9IpoNڪKD@D@D@D@D@D@RrNe@Bg8H nDX׼~b^xf#$Fu&r-Jb"[;p5/|e\6&YJ* Q`<1n;O(b<C{ a1ӷāOc+/b%bfU;\Ɨv>XۭZcfc!l7'O<:/ؑ>9+5fa[*ke3ϼa1g|5KkKysgeijGD@D@D@D@D@D@ Q٪I !ъbzGxDE"^t!DG,ؗ:@ ŽzL8KV-ryFlɱJKo7'LLK"j<> X ,ML|r[LKڞkm׭ڌHJgͰO&-x[_oii8d}ܥl>ٌ1b.Ekp潟lZr򥝃?{Z1J+){SV" " " " " " "PsaypZ\0!Xc Mcsutxo^w-Le6C mi'Y(lHUZ:;gL3k'a50 od>,Dž̍]1)7ƴ3x3z6iOûde9fgk[8lٜ1LgQY )7[ۀZ0H3Ipo)WD@D@D@D@D@D@J$jp4v-LiREóg*\D!FrRF 4AM %_~e@1CC=N: ##$ޥxylu\(0Ocƀ 127D? bb1cB#~څa:iymx%󇼌?<0bpjO8o/泂2w'Yh{h\JV.aE3ʑlI,gTrhG) 2s &5r1c<0.#D|BzCh#7>nZ1&[ ϊ^ 6@:ƌ9<X0NǞ1  /AD@ ޽{gq={b<e!;p՘̜CCtOZ떞 g 6N4f?]vY?y=>s&*LBDWkc10yM]5>عI>`mvf>GK+R>wg,}s%/g3O Vxs3gV;_0OV\qEdVؼMVm&FD liЄxeb6Y0FA<*ؘAt<Qq54F%t<ڥZʋay䆂n&0-*o Zr_\!VB L  Jچn"^G\`1F}0KqqDDÛpqxW5\1EbFZ;*7bIr`,DPd,V㪫=}yF bv>qMZ)3wJF0HMXD@D@*E@{Hf%@`bWM&DuM B+C4kU@^Cw)C1@Aq]6+Zh `u7JB/gw3?9KPfgP&x;̈Βsݕnw~N @.$[(\y!BG!@^N' @ @cT @ @ @H @ @F@>* @ @ P k: @ @ @`c"@ @ @H @ @F@>* @ @ P k: @ @ @`5* @ @ @`Q@ξ @ @ @)lIENDB`bpfcc-0.2.0+git0.02884a026/images/bcc_tracing_tools_2017.png000066400000000000000000010530171305314114400226070ustar00rootroot00000000000000PNG  IHDRYysRGB pHYsgRiTXtXML:com.adobe.xmp 5 1 2 O@IDATxDֆ.w],wg[⮋^`q-|oetO'yyfNJT*ɩS ,8 @ @ @E 0`QT45 @ @ @"{ @ @ FGB@ @ @@],؃ @ @ &0:B @ @ pb @ @ @0ё @ @ E{ @ @ @ p/ @ @ .ܻX@ @ @(L{at$ @ @ t@ł=@ @ @@a #! @ @ @.A @ @ @^ !@ @ @]w` @ @ PH@ @ @"{ @ @ FGB@ @ @@],؃ @ @ &0:B @ @ pb @ @ @0ё @ @ E{ @ @ @ p/ @ @ .ܻX@ @ @(L{at$ @ @ t@ł=@ @ @@a #! @ @ @.A @ @ @^ !@ @ @]w` @ @ PH@ @ @"{ @ @ FGB@ @ @@],؃ @ @ &0:B @ @ pb @ @ @0ё @ @ E{ @ @ @ p/ @ @ .ܻX@ @ @(L{at$ @ @ t@ł=@ @ @@a #! @ @ @.A @ @ @^ !@ @ @]w` @ @ PH@ @ @"{ @ @ FGB@ @ @@],؃ @ @ &0:B @ @ pb @ @ @0ё @ @ E``.{ 7| w\7 34 ʏ?z)7eO3g Eqw}|M'ycg7IgYFM2$ns 6y`馛.W[_{57{h4VuR6'PI_ %բ >[dEj殻;︅^xCiZ5#xwq{}~#<}\'xb~wv3Oلۈ5"0nrm[vek ˖.K/u뭷^pGu;j/{BcƪN ަT*I  D{_Z 4)$hj*r;ۖeZf&r?ꫯZ^@ @"= @- 矻; :*۟o*νknvr ,Fyd7L3UW]x1eEΈy駟uGO?=>g/<oѭnfsc=qO]tQwǻ>ґx wGx3=# &?fYgtneޡSN9 7p-wf~zFZ(dN'z^verzhwqnuq;?j*"x<@UF4XnnV駟ލ1Nn|UW~"7Ƕ_xooVe?+6۪ږ ?]M]{n㾞jӤN_ɧ vP @*wq?Jp !g$>-R/´/^xVa@:ĩvx _7 PBeYPosgyf8Vu_eU|վf rJ?!!o馞J+$m܌37O8 3'᫯oPG[o\*n[+m Vm^yC8ު4@$jGx뭷䊮G'{ZBW\M=NŽ]tE1MD|M^b-K{aJb_=NN3pO6~nLV;߭~馛_/5[I'䦛n:_OMos~0soݭ ~?݌V矮N8[c5?21Q=7%|5\fesN(7 @I "@ PA4#{pFZ?^~eiWeeB`4#ӾfuhQGL`в* SLәvfL]3R&PeDAE,h3`4$D :蠨V&?"ӖuɎȄTV}naV.k=̼!^n˳ PDŶ`ЗgZZNEM>[nsVo|:w}MxD6렼c #lR)y#ӈOG݊>&2lРA ;/2-p*ފ>>~ܱU&l9wqV4_B뭷MDzd,?Hciz衬hUZ تVhD&Tlb^:?F"+2|d+W^y%3!@@I{!|LH@8@Ad485 h'±ZBw-JZw˽4# ޺ {/vِi&4|o}dZ,LKߧ1=5Kd>ȵ&?.>B+N?D3υoԑ ,Or!L3QQ\˩ȼ?&i۽;FfMi2ʴ~)+JձN8kUV V*cذaluLdZؚ[10jLYEUzj2J.;sMt=XdᑭPLMfc s5e*˼[#y tG7r< @M# '<7_WoV´r(ihVt;@kq>zVB9gڕ^'9@@\v6dGZB\ٙ2O0K&JX+iWVdK{&YPl{y+j6&gջcX47hG#D2WNϋA+V>οcw&Q~p- @h*M͍ @(E`UWfb}kK;>o9O6d쨻[έZ^إ%~뭷zEMH$s4(t'!9ܑ7|*U+N:H~K=hРZ~Ofy.g 9u|CwA4Lo$HޙTDI .q]Yy,BY{Ƌqn4y>J+ՍuRZ}8+@S_)=..)hSf4ѹIofj|Z\PƎV(| Yhl"! @p f|P:*B雑H<<@.KZWi2GPlNX N e*E/p2Pnؾ!Pm$Hcizww=K/ԗi$[o]/ɛFTSM$Q Em=ati/oЄgVhg*_ǚ=Vj"G:'E9X[Y&xY6XveKeLU0'Uju~hrWM(iL0֩N34Or $$@CI)8K鈞 2+"C P TPv۵A2AZO _yL4;2t]piV杬K% ,SBrjH9rt) N:-ow.LJv7ɡ Bp:4\0M4-UJ"雝&/KgW_IBSiMqL"iv{]9>3l_|1Oą @ pυ G @gE׿k/#}٧em4) a4|C7is6;2POewlZO>~E ' 믿 `͉'peч W``\eǣկ,VjiDŽBUrnRa$8Z4jI>&z۵FC { p׆AB "QAʷ~,x3?oRF&EZ,se{'0PhyJۿSN9ś~á')Oh/݋2)4x`'y/%M$kގ>,a!H)Rk1+_3?zO.¹ 9 YeL_I+[y&z}QGus9kVwvK?nfb{"@ f@l@eɝzs`^N;䦘b wdF]s5[l}Q{g)s /t%:<̱ycv9-4Q/W^*y9 +VPHhwsyry&n~駚ZՇk؆&l2q/G4 +8C?/bˮ%\Xb 袋V r~[ngev[ @N!@?Xpi믿>Wy 'd XBF}{Mñ;ڞxngt馛= acEKU:^5\N+|wQ_c5ږ~nmuSϾzNBHioU 8z34/DKyO?cVy̸JkO>q-XC5( p` Yr;D 0y2@]yB*SjgwZ㮻dF@MgĚ @l/2Gqw}wlVeVz+17_h?ebeFs}躉89 38ُw}y@r:iDBP\gyy4;0R»9#N[uy6,]sYB 2,<\_|?묳Zʧ}*Kl˜&ܴVW_FՊǥ?;M[ G8wEouMC: kTm53)47xk @h6&J~ ^H@tC=TrB7{ɜʀ2{.Kvu8J\i]ڥ ,פJkSfp4 P+Ny睷[>V֮yVԬPx]}^Hz#ZznHj] ' f74݇h1w;/L3` X1O&d&I1n "+l6C2;ct]M}(UVU45#_72[& zbj @,;9 <rVOђrKo'Ann˱TKmO8YF4u<dB&SdXڏt68-{dslr*{Kx(4եIi`nLL,*;.;8-,5OPwG #<HvǶ.xN&~饗z{׺߇ N8un e[Latod {قx24'}i?3ށ KΛJ;t}鴭馛:\/6d8?;d7'^|E?2չgq䦄Lj'_1t*-}M>qUWyzni@ZB^B $ :4nLs7>O3e(wwm7΄U9`ڕ> FWL̈́BѨgq"L;G&8^E&=O8n-v[dHmu4a|dBญfS裆 孶j /]_2 }2ŧ~> U+n//n{?6UZwus靲}8_{[q=Y|߿Kdߎ~Z"̬S=VlD6a٤b2) @w7@9j@@!`BQhNcDO㦞zj-Q=믝 JChP^>w(JiKcXڄEl}yK#Unc'3 d^xHЪnr)h1g֔@ @ @L{_\@ @ @#})  @ @:4  @ @G{XS @ @ t0|qi @ @ $@ @ @`;4@ @ @hcMI @ @ wťi @ @ >ǚ @ @ @ pK @ @ @}5%A @ @@@A @ @@ pokJ @ @ &/.M @ @ @>֔@ @ @L{_\@ @ @#})  @ @:4  @ @G{XS @ @ t0|qi @ @ $@ @ @`;4@ @ @hcMI @ @ wťi @ @ >ǚ @ @ @ pK @ @ @}5%A @ @@@A @ @@ pokJ @ @ &/.M @ @ @>֔@ @ @L{_\@ @ @#})  @ @:4  @ @G{XS @ @ t0|qi @ @ $@ @ @`;4@ @ @hcMI @ @ vph @Er4Lk.?Uo/5q}7sol?^zɽn 't>{tg}uQ݈#y/t:x≻+}7x믾?8p0`@UUnFIk!@ @M>  haY7SD\rIE]tQ4coh}F}Xg֊> ڣ>8y䑫M?ѭۻ+Ry!W_=y:nhv~8]r_~F3NE:U&hȄ$Q3Uy8WT gf]t\z /8?xp b-&Ϋ7%l>H`}sxƳ~qi$ M>` @ ??2-*/Osu]k i[~8v>hi6=أ"I'mP[lQ6lW^ Ifs\Mیk,K =}Wҋ.h="{'V.&`VO?(aSO7lɺxVF.h7YfhV[mhv|?(]{'+#[\:/2@/#]@O8s?љg 6̿4}ّfoo4ǥ} k6zW:Zgu34Sq_>>'\ /D{z0i|qZ;hРhȐ!^i_u<0'zV~ m~\a-ZneҪEQEg]F׿).m*7@qqk(# ܋7 Y3n!GaLaGZ'xbzyep^߂~{¥ؤܓ40^T ؋37|33 ¼B\u?u„mUϙa7Wkӆuk3 nwoE {/m9Fj[[ve  h6TХc9ƙ3{Go̶tOOMN!w}L^i &N6x_;&ƊPi; tcݙty-ùLt\tھ>0ܷ~뫪&&|r$rZ-RnFhMrvl+3|?y|rY!3dJn挜7&|TPUdEV89+9{챋d+Mᜫ!Ѱsi tV{ڦgJ,_gw$[LHHLꝡ[`ꩧv;+f,PEMtԽak|WW{1;)ҏic9f$\;Y1YMץzFaM=|Q}#9iq3JkV]fXL &Hq$ۑ&҇1@!FZ:}4d"&+mt!^r+2E-ùLZտ5JH<:jD 9MG<0n4, iL#r"jB { p^"xCz+8p`\߲)Gn&hqC&hxhۄVB7lr,vHl 2-ù +Xc s!K.d v`>C&=u.B$PZhµ(mfLTQ7~oz'wV>YW7A|d"}VN@M(^w(7UKM TJ{Lug8,TgdF05zꙗֹHhzJXڙ7|)kxSx/y@jAeo-&Hif.N`R>O4d`R\4Q/Hz',K;|a[yo&2AjRZA]B;:WܔvwAiϴӇR` )"pGQ{w$9mСH-ZneҪEQE'lIafJ/LTp +7E*MZ:ze%+H@6TS5Tn3e[s#tA@IDATWVJqR&r4 P>?3|ΥN*_,9V Sc1OeWL;B:Z{o_^J2C2"N;wDz[[{h3u=TPyʴ7y3lM7>H6q2'pt(Z2}CcYQP-9~qk꫱ȑGٯt0s>Ch]{A!jI%72u|o}%w?4z7ֽX+h%m)eQ /AZ*hPV/bf>SuYbW>b㤀C/r<,GX`c:/+@o Џ5IuYgE>ld=h5(ɐ<[z}ԆcTi\iVҸVWarPc=6[ZN-S!lː `K^o,Mw!R!- 2i^ՇsvC Ұ $ !-2>heM$?e(IgK:ȱy{gOݨE|VH moQYkLPҡBA^V!ܧ2g&:?PfO:l!$gb/i eӻ&4CY}CΤ]ɐ|MefIEg!~IZgf^ֹlH*<~izRCW,AM_;y*ޗ ő sXE ف@U3Rؖ'H@u)-/Iէɕ:'yK:]פ@K˰"5M %;J4)% p/ Kz[Jidi]X&|.W2H4uk %גd sx [- 6*M;-,}$C9$~O=أB{] B"M1yHeEBId}iL(H<}itBR(I[7޺*} WRl*(2i\lwM($!Aw zy4Ë*CU!14$qR#>$6qLj a%p?|~ze}\F/hhF{pΪ_V 4kC?ׄ9S'8ɱ*O) d%0CR.8l!J}ScCrO&C_O ܛg sU=$4$C&*T*7B}GI*<VEeFRNYwOx?*ZAj?(e 2ZH@狀~ܥHMI]Mo<Åc:Bp G$WC0+ X SѪDVX_/}kj`Aஶ2,>Oh1 v@^[H*}&m0,S,d.4_K_t4R.'4knv?^pKe9$ߨl%p$$|ΔNf2.}@oXꭏb z@$5mV ղ&uQBE .B?锴q}i{zaI j%465h?oɞju%4KFy&VJ+ 奠%B /GWZzy VIWKl!"ˤ-{B}a ̀0IWDŽ4޲%ymgi$?^S˔ GLhoΡ=m)!M HҹLw!ΥC>I{2p-$TR I{l^aUT^VeǤ"Ux4z P6S^o7H(^P<@(馛w) ~I㡌 pW&z3W[mposnMle}_ӦɕA2.sޯcJq/ph*9V΄ VM0S\)3t:ZSi9VXa8tCPϙ@ٲW-cp?[.LWCmeδg}>& w+l@:{8[2a;Ý=8-wﾻ/ff/ՙ98= =X1[LLpgM,9ڙg/&^9Nk&vJ`t3! 3g8}R;ٲugBveZAj{ϟ635&Ɯ\qf~bU˖2,ùLZ_zٰ^i8{E鷂sf#2 9t})=3mgڕ޲el {K٢hB,gp;Oi3iLHU7[3Q|ޓhoy뙌o|OhcS| kM]gUA E'f+>|0g|& ߵvS+-! z*؊?.dޙǴl[n2=kL Y-יp?lЙ/gZ-#+]O gjUV$y/(Ri PIcSrB>w[']2nV8Ӧmef:}%/1EQ'Y)fV5eI/o82G^A@<󌯋^$_:,g|'rHp`Y@K/ԙV̺XŴP ML^L\ LEe\&m\vjPT9]zaﬠ&SmE3|^$T^Mf)/?wIe4|8dՔ&lŖUjf(ޢ˴Au u I p@;'(&. axKAf&șBk`+ N׻&h%s{މM8MXYcGlty9Aֱw3ƤvWNa̧83!TF6=ú yܬ]UOMJQKR2ӤhxRИ E ه@;EV..F HEsk)h2[=w%T~Rq!6Lj"ВOt>iV@ VFM0_S 4lK>zi66+鋬!H{{Fz׽+  $ kdKa6kbTp}9pr)?{'+Z$E]䮾>&I̚9=Sf?k7iUB0G^o6*`wI u7;3!磅~"gfqi;(HH3{^;-r%M 3tO,l{rV]RE+̡V$7GU%Pit%Б=s^;MPp LyMTBA!ZEcI Ҝ{"uP8I]m>l'.Պ YfNIiO5 % elSeI.3w$tъ;5t_K{Y!h8{FA+絊V$-{B}WZjw?)(K/b+aƇ??4ِ y\oA9JuЊ1=Jh  A}C'dMبqVo[_+ͼޝ9$ӳv02b.Ny!Ȳ@Pk2V^zR4„a2nrM8h@پd*9;g33lwlXʎs#4}|]vYO,B0?&6/&G"Y!8rMl$@/>J .nFy'{I:n:&[&jrj7qiq?: yGhr꛶$۷ɰPߚ&4IEEmoeX(˹Ҟxud?ߚt(\Z>|ېiw?''q߬wtɿAE2cR([3{XZ|tyߒ؉u(O[ 5Qd|-K8U ^.]fLJJnsh[z5Kt\[1ɡiܯ%d[gջHhzƳqے헀R^vY3y/ ' "zP_VֻdANmO T%k;e39ZUIc;-$TXTH.'3N6Vpx]pyRkɞ j_AVCZ-kײDe /bJ"j);kyjʐ/-RgZޖngI% r`2/ ?)mJ-־g:2% pl@K,CT+hX?ML]_KN@ 7dRFe/y"5*^LhQZ%ho#)|z6;Ⱦlg3Jv&]fio+8׫S 9Nw_Nшsy∓-л,ss L@}V46ɼ ؔttYpɃEfIl&3*b+c=vnzE܌@ߦC>-B6ͭ5b.{AED7%9MJ]>*ރ>͊%HCZa̐Y`ީiU;ʐ9(=S$أ ?{53e'\C fh/P&UJ*YNlf+ҚVU ZͶ|Q wd+%@  n[Nenuvi&!VywZ䖃Ĥ9ihvRW;lYޙM(̓C$Ky40.i?N?̄ 3Tm5k5|CEMʄLsޛF2={$䗂E ˬL4jRfEuCy '<9x2s$ * kĞ^I. d@O@._/NիSwך]v$Ⱥ'L83͟t=^,}# KaDJBdu]cAv8jSm*KQ@Ue1 XЪӭ޺nC|h4[A҈l҇D:eРAm-gw(P/jwiK 6RbMbwy~ys֪#!_Hb~bt67#4  {5hyQr-2~e>W&ddF~ͽ+>恥ߝQ;4/ЃKB:^zx @\veΜ%jG ʄ @ZK2K&G1ds 8@d?SlBr*VR=@ @O wzz3_QG;N~g/:n'N6-s_xؙzqVYep(ޖ)Wiw]wX{:/B\/MJ#t#-q(@hb %1x,И` k5J-;~s1U<KEƿˤ3aI{&eD@ \3<΄޼ڥs'GyğOf",~iw8뭷7CTSML<5ʘ~ 9 ٽM7/NڪW2)h{fvJqU 5g}vgjwQG'|ҝ{Nx AǶrKoB;C ,K#NmL.!/oZK?=q^ .3aeY<{i_q^KK+x≚q&#p]k-DX袋7~&W^ye%]駟)DꆼA&ɨ0MN|@fܣuo)h~᝞2_B_FkRf֊FSmzoFw_)YLڬ8@m$N+駟"i暑-fpdBȖGf&PfqFwW׌Nh 643iF(-6ܼM7(t>]yY5M_s;PVcLkh-ѽX?C+즇qw^ŹF~M;}Æ N'|rֱb Q[r8[.ùV8ޙLY%աgukZ{EC=W-RnF "Okf5+'[ e*}p׵BAA[)R +!Jk҄]'0nNB/+LNq+YVnE~l w$/?iUۻ9[5gzV(9+/u>w=пl=}'p}Fx`Y&+bq=YΡcRZ]+lb#Xd[M-yE*Ld=^"6c-2~zϔL"/6\sL$c!@x wAZfeڠ *v zܞ\d{:Yf; *.fo<3_$ ӈˬh^ff܏6ɔ>誫N8"]&B:}8 >hʤUAk^30"5{V~8VFE*]R^:9t^PYd/fviҧc=Bx[^̗BkJO :[.9N" ~ݱ{'T5ܸ#-RP^1IylEsJBk4E-;"7ZfUJ2iL؁@?# I#rSnnd$&w-mƅ>ß-5n& q_/Js7[9ABb)h{rV˶ @7ֹ(d\#/*yCMk)mFB:Q>FG}T8 J}Wk2LCů2q*#sI@9do;g=} h`6+XV[eEXnP3cX[衇V׵KK[BYblmJ#mIIB~! <:|HX&5{g_I0~M~Wܬ Ө0heGRக*뮻nZ+NzmV((6]F-8[dirgx@Wgz69~'P2iCl!ПH%Ծ4%2m U!Oe[Ҭ6Թ t\#-駟>& B- z]guui{rxᆋ*7tS8^{md6t8tPBJ>,T 2,.{[ou&2le)mF#&HCZ[0PN6~2,c*?O_'}Ϥ>/d8CG_65ɋty1(DNLRV$O+>WYjHjn/45wiۥСC2g~z> օ:>_Ҟ}:"8_&U5at<fpbı'|U1I&yCH 2$ s9WdL i=jLLX q-PʤMp)rWEПf] 1b&0'Č9fTքbsN{uj3=77=V*:++~-1'o5QΪ=In]75pOOzuuUaX6x0d=zcJ`{K/Ywd Q}Zoz)9D/5QhdV\.W"rlY[-m9j `U ˊR Z*d5֐^Z%]TMQcn=W,KLJ9Q*ywDjrW U"j%8k]EE Q%复[-8üV]uU9*ɂ*PD7ƧLWm eq ¿~|~-~7J"J'#JfJw wݫK%_Z)ֆR믋Z[NXd $ҋX:}B &Yg4uuޓ:]c+)/s#K,n~u@="̂w+lqdQ D5xE\~剴>}:Aa?/P+ŗoqP[J<61#bTX`!),3xf a{,8sm@#^wYƜ垔{wf(Wx›Ut幑nAUY̺D;"lW^i̵^k8ޢ=?ܿ` 0{M߸߇R=MENxPVon+7*VxzP?T9Ƈw[ZZמ#-ӚmYG-J4<>R 6!/ʷiYbܐݻUcl=E@1Ulj p (7-ǻ*]q{%>Y`X2AXtvX z#U||r LXȷ476 >f}OʅićRI9VG>D4("49V EsOk^T.XLŔOXx*|DA:B miPwҤIVp~ ?Ї_F>x)k ~XXb}{6VW4r+2M诲Rjǜ;s a{ζnkF)XP w@`Xc{%2 PX#x/;.g\{h[4wIq?PD(L3f֮>61pE? ,]T9c.TVc9G`B   ЪJ-To?Uz۽#LA ,я-w|]0u (vO~a NFeGaubBN?}tgeS_+vԛ캺a^J-Wsw\cֱBME~[窹joh5cܓX&.hIU'<ɴNr7}7REdyoM:Udk Bivb륕A:sJt!8g\jHyj`t)5qʩ>/'T/7ASCS/ޑ")]pjƦ,yeЮSNVyGioprimVDZ7m*sZ{`)eJy'ZF8T]'=|_"/1JsxH({n3v|uׅ2XE9BHZ3:>[]wD{VT4>C65'jc({aQ/ PrzTxb7Z^zΝ;<|>EBZi;KU&cXP ;_Ŷ0TPK.>`|\v(>4婅SvئH 咺[_pP 0o?f<'BVz:/_/w LO9?\*UP-n@N-xMD9VG T3R\}A؝Z&PPk+ܡlJZ7W:f?jIcǎMc;5SA9xhmm tnsTmY޿n sųX%Kݸ 1\yYk>W(5jT)z4X^l6^7V7UЯzXr$?y}z8(`Zm"` i0|= #>mpm {8?"-K!e.p+>Q;.\ލcʡW@IDAT/pGFm&O쫚r^pop s4Njn} 0;f .?ƤdCE1iUH{9\j} =Bo¡,XFI7yU*EE]S9eඥ<2˘VkMd9  D"@ DFF@cZT-zhjQW<쳢1Dd57Ψk]p }/,_~m=6j.CTnI1/ZW)4Q eec~x QuXT~HFߨBeV\8ۄJڏvQ4{:  D"@ D"@h;89J 9UݻE|w޹d3-h H)$D"@ D"@ -h`\pAS;=ztŁXSb"oh^燣#D"@ D"@ G/W3@½rX"@ D"@ D~Q/.J!M6I /oE_͕pViVfEC,?|w4\s#n34t1Twώ+^zIz-A[-?|yyG^ziYdE,}v*oƌvƏ/`K.+WR/_~Uo &ɓ.첖v|gmkv%"@ D"@p;"@@U/3tjuY]N*mn ecw뭷2~{nxo uzk׭[p1|N6swy'܎;[U3Z[nq-Xޘ^xaw55NW_p<裏v2KHyow~sݝ.^elՉ D"@ D^2@B U!^{Ɉ#J}k׮Vn7|3QOAYi&w\"擩S\ LO:{eyٗ_~_~83 3j;lذc+}?ME0tP9+ _9)G}TtPWs<8^{5󺨠:"@ D"@@!m={&D4>2C.2;ˍ7(V~Wz!Y%\"GuT8>#/묳>ΡʨO66[TcdhU DdϺ*|"@ DB(e^ *9眠H/p6n xiĆ¡Ѯ¹-Ui6۸_|, j[o=0+8DVrjrːwb5s z?&(c9vi89^۝|ɉtT;j|=tMy cǎ nKR 'xwتSJ&*(TD")΀"@ DdD J *(4Xe,첢V5ꫯ nikpn~ka.C2eʔF|jf-1Ϲz#<"&YfeM;m't/P`ߋ*- qϯv >ߪрcW&|+#A,B) swb]0,uqnse|>s|G>["@  q""@ @`Z46D ` cb (#e,h@(mikpn~=쳋Rpw}g֫Q.6ZnoZ +Jn/]r%@Q 뮻NzGǐ-:YgyfQao`Q2j?xVieR*R7䧟~nM#!N},|>߽{|&"@gbz*F D4q啸:tYg5q )B_|L8ђTҥ(߮R/qŔAEA}XXfe8GpV+dԩdƂ|*v^~i[4`h$P5oAl#^ 8x mM7jp"@@#K0xG"@ u*XZ^xשSݧ'uߩ؁VDy쪀q̅(E[dEm|ƍ/bT}`<_[UTW'u[~S<⍿[b-W<"*믟"O⋝*{mUdhB\Se\8F*m**\mݢ_[F6ଊRw!wyqΝߞz.`c|~ܪ<+n [ouC@+!(oU[I- 9AyB0ϻ;EN8!"ځ݋.Z 2ĩ۸B<|ljJuJSƼ .0#FH<: ?\fs{qU:O3H˃s Z=I(ĝϳBie D" /YV%Zj;|{O>Fny*{YV}Çwʡ[Z;eȑA6V( @ lpOS C&+Eyeׇ)4QugH,W5yS~k_;L\c=68Xڹi#)-/ SqtWoPr~طo߼ 70ֱWƷoqKŘ˾ 0+t\r>lge[0#@{ر& DR6<_Dm< D"@"pUu P .NyV"u]˘R(| /FY9(.wE,}l<(,Ž[otJ)R*(U3XQF\(CP²K/5TJ|u wy4i+]b;'<̡np^wuWC b曝QX>]P1c)y{'oq!nF6\WYq >ۮ[\7Xw` J{ƹVJsT{,5fs-r/%~ׅ#u}暶8:(W-^8D(qSʠP.7?={tR|k1f㪫{dȊ}XSL럋83 o-c^(*k'[#DB/L(meL'D"@@P#ew)\fe51Nyl㪉}o9 %P9;Q]NqA%h; K!HX}#kRYۇE9C]zspq](sPd7؂ǗBKK#^Y+gVӘvMcAjʔ)aAem` XL]F@: nPmOyQKW[la~Zfj w5 ౤0J;|KvPA4Â*J J`lP ?&DƯ |Xl("@ 0;F rᇋZȫ*3-[mU֩ |B]X^#ݚU,RdP--dnĴ$:0Ͷc2U^ tMgix(-Nh C mƢ gRt /`͇.Tr,UV(sDQpImNأGի0O>Y4@Yc1 k]Y|zI׮]jJdYk+,󭴯x7UnrYY "@h(>C D,%KV\6-- _n QuvgaТZ~#<"zŽho4HP`թ! Q/Tm&iߌ;tmSuV}gMFնݚ`N֥RJҏf/,(?-a1Oc.9+߹;mRɇ~hOv4T "@1ZC DP!83ˡj)/(߸(78`Q*͊ 2DE`:7tS%J #J:X܎D`7 YJq ~|jl喂~^eUPtMv+g5Mz_^S<{gPȾҽ{w ^vqG8p? W/.J[c+E5Xս F. D*k'[#D"@D ?=JJuX{v(2>JѣG(}G`ᮼA:q{NX/h?0sہc=(aMXB=P|wyaÆ QVo!,QƘ70H߾}e駷}\`o^p2a„PE jo֐nݺfmfiQԠ!Ѡˉyݑc u 0g뭷D6U5ƌ1,ו?+q+ERC=$#G4w%\"(SX`ߥm+V71=XtEP뀒 p.ءN:%[2ӧ?vE[O D9 }5|8V"@ Dy]VWh^-'|RpJ-x*ׯ`-w0O[V}U8 b%0Asd]?~ Bi9*X*:rye}~^ N-sf:nk#uAgq.lwVobC,q/8Cj#D$PpUzd& DfR⛊B D `VӤQ_9眲d궐zf [(<̓(ۛꫯJ0nV|X#cZgϞFOӻwDuk_uUf!,gjx駋*u`n6[#cn7!ȇ%`4ev3|淰],F6^WJp h{ WmЫW/ܹs !Jͭ[cX;!>c- D"@@"S½AO"M DN:[ 1Ǐ78[l1Su{I,@a)S h/x-Whk\O?Q 0^/"]tzi-]AZh!Yjjdo'˵S8㜀p^]c\J- ?,ĻK"BM( D$c ;8S DǞB#"@ D #?sG*3Dj4Lń]sD:T:&E~رTMM DS)r GΦ ,rf"@ DRƀ9"@ D @{;Dto{7.s"@ Dq7|Lw D @{ @dDuW=#>w D"@O?bW=~["@ DdF "@>;L[n%s"@ D1@n:i1w D"*ܳ"D4 뭷lVa'|r:*dpTG-6bĈ k8 D"P)1|Wiu'D"@@Qp/ 3 I $L3%2|d O3ϔw}W=P_*lʼn DJo9%D"@A rPb"@,r^{<8 1w@1aoI&U"@  +^p,J DeBD?8cd駷)S9g&@tAtj;a;D"@@9i^{|" DfG f8"@*F`E?<2d|;DR wD"@Z "@hfpoϹ"P5v:V/pS@P^-rGkV^{mYz?|I@-x0a_z)+lN;Yg%~ib͎Uvv@{;; D:C`:Ch` %tG#* 'V[-1Դnbpo'"D"Іk gD4>}=}r!2vƟgЪY\B~x[u4!~O6; RW_Cmdǹ;X,{y~Wa&O,o<̲ J+d>5ĉ8-B4LStΡV0VإK 1 kK-r¢~G߰O&302,bxL0W ETD"@@~1V!D4@2dH}'>l8(馛Nb+w(f(DPlÔP .^r%2sZ3fLȏw^xYa gmW6|sYtEM z޽*?Ce[ʣo/ݻw_\Dz8rEZh!?au]e3xG ZH-є)S<@)}۰`)ԩyJvX,^y啶2iҤ}BE|a\Hon?S-@ߎҳ>{J,A D ½X"P>;do! +i^b,CG`g4%e]<`a~G#Ӄ>hމ'(<[2j(taU?CN5@_ȑ#/bJm:X;(1o1Yh5֐^\.wE?煐eW\q0ʥ^*-F >܂B~A/K-(mp}>9餓8PLonpoٷ>|9Էb S?3p1ȏ?h\>(acy7|PB ٽ7,a\/q%Y(G=w0f \W z0}syR51p@B%be]Vze4@EXC E U(G?DRKe ,E 3 GyDN=TYfet*,XH~Bep{䣏>2ko/P+O)SZK"@ #@{X$ D$~>cnYei*ƣ"Prff |ZhlFG34ӘU;,a|M77ZQ@~/Ҹѡ\ wQ秞z*c-~}VX! w$ 4q3c"džn(my|oŌѣG[},1ckfJw )A:jQ~% o:)~śXq Eﾻw⾿-FQc]ve$D"@@0hj  D;0S|7f CV6)q B{^v"(Ar7ZRX(C . &|0!t^GݻRJQ ;xEH@~뭷pA쏇zHFi5\rpELڽ뮻?Ƕ*kWz4K]#x=Ĺ|VYN4i`x≶hVq[c<ڵpgZۥ^Z`k?S}ӷoc\P_¡ P ^sbj_ #tM D"@@yL;,E "v(! ~w+Km yPQ g=XľK7m0ۣ>Z-Gz!^wvi%B K޽{O?dW^yd=_`6c!}V_h +lP_z饅 P3 2ܩ'-5<@שSP, Vh &43`9묳BuEC9_|q i9ꨣb(#,"@#J1Pa,TX,nA݄Yg5QdxXӤ~ ؂ B;_2:qD `v#Ɯ[yXÜ7pZnlq=[>?~`K.؟_ֺ=6c1L$+ߐz8]pcum_|PO]w]HWΝPڞz@TV@! o^A}Bti"zJ|YAݯ~w^_|>@VLS^k]vIT;`Mg Bnu׷,F{S1:1=^{%#F(Vk׮ₘB}^+R7'DFQzeWZAwW;]D( fGE#IȈ,pPx}߷0jmc? [ h0"@"` iGK!DB@_^,8޸q㬇#<( Z;6CXQ;яO D>A 1^`N!D"@j@½6"ҥKrB;ies=Mٮzݻf"P^f"@jAEx `8~ժyӎxɥ"@ A@CCi !;DP~+LbcO?]=XkGw(wygb{v'I'/`ȵ^+GqDhԩmAѣO>f%,ʕ^4ͥ wxtA?ݬ~i[442 ދ Kݸ}78B`K~(䑦At-(ЕK"@2!}'qg7Ő" wZ D"P;b w*k+[j@nvٳ )]tY;g(!ԆW# [olVr#{v_41 UVYE?| (oƌc}T7˃>hW\qVGa PCbw(⁅X£/XӠ85^>48 >D#G_|7pgx0sJ+$:u2I&Y ,xܺ<&DE2"@j9`՚fm'|}t;}n?LJ"K%˳ DZ{l~ʯȒD Pp|7b8Pڵk^9vxvJ⦝vڼyǩ'կ_T~ڸ1& 95\NPC=ɫ!.v]OFqjT@N?,8׉> 9Z]Bh Zh!p"`s`B DdG p@CE~ᇋ*S':=z !]5쳇ʹ[*eYg5+]Wm *UۯSN1+ka zX w! cX`,h<>_i !oUs]7N(l K.>;`RsNywo4  o  8 DT_|!-Ape6lXZ{E|ǏO\@Q wY~c% D"S= :T:V]G<ވ-[od@Gbqg_xLb3Pc.hP/c.[W|AɎEf;\.> ~X {ӗ)cf% 幯zOT<x]A0 x≁y1rgA(',/; }2,#d.!Kr½2?kպefU=֬ DʮʟmqгKX+;C2 X{ﵧq.DC_z@?]J/8.|?R(C@!B,PY"Pp hZR .D?!O?@Z7@X`[Tۯo.<@@.]}~-Ƌz_~,r+7Hɓ-G}dL7t]s@)g%!*y ✵ 8V;_?j[9>O>D}VOE?%/ zJ}8 "luSO=em1Y_ wN`G@}#l>w饗Z˻+[c9a5hUN.O?4a9s4+7 M#F=ƆN&88"V )`sSźSDЭzg}61?Uh9증vD 075:A~L3YgUQ~s=t!!*A/"Q>>x݆nWsڵax 7U*]SxحjNu9kATqPv~U-~c;Ӆ5[oTqVYeDwݭ4\3SzPv)̉B<3nʔ)Uw[Ŷ_F`uZ;],Z)b[(zd=ԅ_-9kATx緽\WYϑrĹW^խ[7q uoZaQD&Q\ˏ3^d-!{ p`P gQ|W!zRqƹ+[Sxwcὐ/^{sC=8X+|1{q#GtcƌqVpi w^s'ѱ_jXXmqozN:}58 8Ս>ske0BSj?޹^x4V D"Dq{gxYJ=#SOuʋ91mC}uq#FpO>)R[e=W>蠃,a0x/DƇbrPʬJ馛={LGaG]uu&Mr<8pK^]`UW]PKw&;３ZZ7 f=GP.@;찃S*7qDA[n<|c!݂;XƏ4VSJPfԨQ-vۅq/E?v5yuxܚ`_w+yT)Keg'_~SDY! 5YnoF<|+`C3IvaiÔ;,}x{'U?zSGVȫGBx܏ ޸wyg[oۗAyԣdG^W1 [ D"@@>pWfZh& i??R`ϛ/Kc=_p,`/rḰhywСVB1M7d D)${챇 *R4ㆲUj?ۯdYmϷsV&]tQ(s1DŽ" y~ o'p\pu?f^p4Tya+߳p۷o7]hZ̷R6?XឆKvja L~xs=wzh R*>s߇r 0ϡ>%;Fm1&D"@@:pUrs9nE,4ۋp9%k^1ZH y~y/K>a{_LX`-`+cXõ |JU_-ث7_~[|VוǶs)2@ U MV+{4#*qBøxxD쾭5om=JPJ@- ~UA 3|pS#?W:޷5 7ߜuWbjY[pq̓ kY&㠨0vı? w`qV pYx,j=Pq w~k F7Oc\?~=DओN ^d"@ Dpe ^Z@6ۄ;w?Wឥ_(ZrUxσ//|1Tg'׭t?2,bmy]Jb _14Kp+O?t}衇µF04hP l!@UXt4Ty~ w?^zY~S΀2䣏>6(H,Y*ݯvYp4+Wrhr=s=W5\~ rAlH\hD_E-E+EKRDXUVYEԢJ]&L !'j+ *ʡ-mrYpղ,ouUmi|QNMǷnj9NZ 웗VyM2`9SlJ%|^q0T =FV qD^9hU+Ho&N}+kK&Ν;Bcȶnl߯Ճ͞eiQ#=zC^1"KW/9cE D-k~?zwh yJhHw6{QPԢ_NxvA\Gr[D[R}~7[~eYt|-+VH)ZԘdM݋Pc _|QrKQ+1JIu)ȑ#(>h&Vj/._}p v\[,P9֏־z=Q"HQ"P[cI8h`Ʊ(2(ssEzXa@<7;qz(!ݻwo=P4Mz.-W^yҾؘ~NQ1gPc.=f5״$}/xWIKʏ?(&M2KuXkXSDV C;OjPC& /%k0P{y%(ƪb|\:΄su+r~A :^g&٠45tuׅ&u>.}B1>H0.hkv5v#<m.om+pcmpe+D%3{(ƊָOṕ&"oδZ#Vl+$^|x~SFփ?3{$kRk `V@9h3GYe]>裡y7s"PW\ ЂΨVF68]:qz_p~Y0[rJmխ8SNk#7jhDw ijYq}WگW󋾲η~7C׏YtGqW.p׏Rz8V NF]Hs;6T8 뮻kᨣAl {}!p?39c7@ǨCjW}3|.z<˫CF\,O˺vA04хP&sy. V|JגW&-{!~T\F W2lذƨANi\n6E@cM|=Ep'|(^y啉6Pi^Jϯ'|++?ol9GjHAT'\PJpWov!h)Mnhw 78Z0ŹZ>éǃ'uscv 7w9 )C@F0"иى'{9r"Ў04ިV/FGT_ `t*\m() HTMqjAֻF)p#ԬZI V. Fhc1_ j-k2% Us~k1j-1\Wk#gUxM=EO\lk?]tq|tM98bzBi>!@#jAݾ'\=5(kyjDֶb/z+&riY CP1z:Cf ypV)Z-Ryl}N wP1\х Zw]54O?M#lc<@ ǠݻQ"l^ر_6Dl{B@:Eu.= /x>^VL/!小olĺ@8KH9GyUJ|,ăM㮘x쭪S=*gyf7x಩d<r'<΅/JxAc߁@Z*b-m5L_|qKK> pqq)D#pW;w#4` (ezBn D.ЮLX{ƬJkgF.Xݝ&v47~TM뮛 tt3< [ <@˓&ՎٷO[<@SD,ڇ(Dsl{XAu[rXok TuW`YO,/d1Z9WkQJuú.,P_U6T++={ Al ,s(׃͗[XykFY:"emc38Cjz)XMS/"Us\zai">8+{2rG \mX*$|;S[bCĬ 5c0`}жi40ҧO5jTH#qX+q2f4 < ,m Ŋ1!@ %X6E@]]lĪЦl(͇@lY NaJF )Lljjc9h#ss=z@E/,sXvd3Tg[-8 %ꫯ~7j ^7X=,:zwZ_ivOtڶ8`-ܳՠ+@ݗ^z{לRջ>[) xa|3swY_tE_<}ueY]v7xcق| T:fGoɏ-,cb۷o}+Y3w(@cM-:5f"n;anpU<Wr>.83ñW^5}#@{;UnAnZA?@ Co>aʉnxW߁^|5U;[œ["@G bI"@@ )XI ٠t?餓d,½1gDVNFIj_9()`Am+ ZN_,ӸVmi^ AA5)iXJ ,vvOr.bffA kbͶ`(EPeY&:\'H%u5TʝeY,$|QD)H盷޽{^~ Ȫ({Ѫ"ZZJܥK̚kYqSڂoh\C 2Ulmd|87Tǹ~@u5W#t(Q1F=زu]qK@qV s D^PnK >(́w;>)*̈h;Ԋ6(lk!"+>`VeQn=+<@#h\ܩyM7ަ J ٔP !J!1s$sDJL2fր2$ )%6{{߻wg=~sY{o-pVwB@]Z-PlkL$-j .{61ߴP2*fV^I^E]Cbk}8p9 ^Dfm`C ρUA{O`ƌ̕zg\0zT7@q%cujXGM jj` !O  艀' d̺{t㴏zfժUA m"(A@8@`ܹ |^pQ%mۖ&O& wOO.Չ@ϩx3y aB4 %- J Vi˗/('XN#J 0 oZM.h)0N}[~s9V*V[+UQtP<]Q}N)kt-L]О0ǾB>3f@65AN|'A-#A&j<ް ՘tn!yQ9s5-(i@a*$|7xc۔M~0c} JP\uU(P UP {)/ {qȐ!J,r(/aiҘ  CV*;kF$eʔQJ޽{+c Lɡ>gVS)5C1w(h!P{R䫋c9tR$N@M-j.AIoI_YO$ ȾO蟃ҽPWlf#"A ~C߭`]XbjݰTrB4e=zѺu̹$%LyeV A +rXnƒ XgWR5?TA ZX#&([ji_{-UOMXOC`!% >0wO”$*;S[[vZڼysQ[8f)ȩ $p̈́vwI{QDq%A{D .Vud<#1˹ #4{9Db"k-, N!GA@A u?n \wuZ;L4nXYXx %-z'N(/U4 TY38_W^T E(F ! ohU#PUt\i۶m#6|<ʢfHƌ0:|xTVne,Cq1se R&B5j(EEB,ŋ،3Gl}p,@j19 OnɵD,S&S $ >Լ}%('U-[Fp; ŴiӒm[ bpRj޼9ϟ_aԠAU/غ X#f$欭ޱ8bM@MM0Xxs,(c"?j"!Bѥ֨ƍCjhiٲM>~ /1K v96vފJ~ /e~5VH g3+T<D5.ʰ"?3g+] ؎Ɗ|\nDuǔ.޴0O A*uw1w K?|ś/17V=xA $@O}* ҈hv_։ X ]wݥva=<+X vhK/S:}D[%*O>U.Cl߾]q!j60_S`M=:s r |`u{zr۳-=3Gٳ+.@}j ?šg|w."ƗL`_ υ_~E%ƤV#w@/1?f :u|MbkKX_FBo0sgX3\W_ӧɶlRGJss^#|W lXk 7\O?.YzDhg`2x&T.Z@p:^_ wL9rPze=i.'x4k\*PzG a!9s *4 `A-xO8D׸:1E^L]=xWc|8`Oևc ye.Xޙwum wxW $bΊAd* UR۱cM` eqXAqXQɨGOVx^ R:-|`3g6ű 3fRK.u _Gc~=!8 ,3إ4ŌyXre݁-oM.ߺO'$yW=!S#^xB CZ`."VL2Qƌ]Up|C$o`+/4OX#M IԼ཈~yW8}aZP1XC5fX"v xa _WoumlGۧa{v8S͖-._0߹sN2텚k,YT|Sm0/?8ʐ ޶zHxS7 @#t NVbW@ѣ]`Wkn޺uks V笤v"k\ܹcT]Czrk)m\}gϞ.~9S5]}L2ULUBk,VTu1nvs ]]׽-_{V{O?B.^dٖ'OM\7+]32T3zu5rH. ||?̛.I2efΜiDx`j7Ebը"g~VE$1 w+oX~/o:fˬoD:.ԃ.x{2{l}t#p>GuV>c}>SkEG'멽Bs0c-ܱvOz tXkVJ‘_xqS6:`Ej:aNlOE{L7%;=N?O~=#Q8ƍKi  n,ybV#~b^>V&ΐ!C;t"dر),Xࠀ&/ekh֭[@dս`uo/xG4x戻C[iO2qDSO>H0um7IyM: DHx`M#"\<6<$ެoFϒ?f̖) l{6mp"t9OGl:O<`–cǎP9K0y(pf̶#gI1eR2Kž Q_v޽b_dԿ'{g3Lw`ӕ)E hOu" I(}^"fŷl`ʓ m˻"ϵk.ֽזx.)֬Yӌ` E9+܃>@e *"x ~Gppt+m  p0tQXh)g+aq+.Wz.?vJ*ƋFݺug xG*/I.]}dRS,}СMĻk?:I$`Ӊ ozT7@QDe`iPB%]V̺.X O PЛWI @u8"<ބ+YBծlv[YȘm;( v_{5s\w8B3̇(uyy0u7bsF#gO}{4f9w3Ǐwln޼qn,kt_Lﰈ !B@)C$ `Zc)η e_O+RRT`~Ad rT'dū V{\5j*PYZ5k-UO?񥩈I{{#~&A/-mԵkWJ> A7 /l%I7V ZѢE۱Q8-MU85Kg BjLFL=Bw}7 dj8͙3ܓSvf2b_d**R}9EIiɒ%)ڱ b}{yX۳;!=@/{SB^w8"k,uh~+BY-4U#!p %JGf`#Ib!MY1KiRhO/]Zi.$M[S:G,Ul5NcƌXBlAOQf(W\ĻŐݣjhƪ<[FÇu $]Ǯ&]TlvU {TJwt(oM% ЄOYp|Usɓ+L7dOm.S4‰m۶?LxԂDb˖EÈ@  {"I@ w-pHQ%Q[Lf▽l*n :Z)ϫ F!E[1q}`pO|O`M% 9uoﳷBTZ>,c#pqbz^lGoxV@zDG@,}pQY0'\[`!΁N[7((汨u/b K&gwPbwVdn/i?"S+a4.J.Pn:-l$SٰeVb?B]?](n/MX[R⨅*X<R6tʇr̩6lؠ6ZpSHUט*PG~۶mR){ 9ZGv S]Vʀc"A!ԦzȌHz 5" <0# K;v6qbpel0~f5zczmVXٛ)CPB=ܣ7&Kk H0W{l+ݻUr>-ΡT@b @oc0ZyxT ?lD|D_ #S d%Ouޑ#G|tQn\"f[=zPU5Ͳ ۯ{}}'1F \h;$j \sR]<{U1к6;+\A~AUL?oE_(# C( &+bAMmӦ]ͤ …((Ӯ];o''}ɤJRun#઻t6MslT 0 κ@ <4D.{ isׂ{)Η/_nڬ]W9#kIبnj͝=gO}sn󝔱 C%sҿѡEZ$F@{6i$[ ;xH3匋-M>e˖uE]KM9điQ\zJ ^z.cQp>}z/ǻ)`9^蘢ߞ<>WI1n=q9= ${K^)0jx9\u|SWulA Æ sה=N͇Sa bŊ⋮M6U@IDAT|.(nCrʹز]u=}YcȔ}l(q|%w(D9Λ7G#FXo]3DA@!J~䇍 Hj44/N{|'GA!\O  +hh|?*7f o5pk- Ѿۯ1QsF=pFp}@k]͝;jlKR&Bg/Qtmb@p_.8dΜ@+5"i#6E*UDl>ꫯY m:ٕ@:6A!&KV=/+lϘp@Qf:ۈAj} aƚ0-a=M8Q mrQtD|W_d$Qn]x=U$hC}Q^}-(MDXWVW˨Qk׮T ˄z" `D ݏ7J: 7t[lYHڔFbp^ 뼸5Zvq&`n:.L,=Q VJMΜ9bEk 5XaM XIjƥªV\qtU~8 g+ v^6 T@‹ޤT `q"Xp.䰆³7p\b%<#쾐W$mvB}ix3h ;>2B~j֬ix.&e?Җ XCVD@ٳĮ36Hl!СCc`a)˂d,Fid6bnɓĴ*;<Ҿ]«ӬQ^}huhx@=z8^LͲeᩂW/Z(eɒL95L2crd o@Qu^`z饗b|;VĔ\ < ^ZZ,e9bV%GA@BpJP) \rܧ<\rE>(~w5 %ۏ∤P {,':P+mDQGgEsDW@ԧOxΒ |M  >cub 6l{'K #WsA@H:`!Ȯ5$3"ߖؚƎ? I%64⁈ g%%5o]FC^Z@DjذQMX=J EL&IH0uΝ:|7 O^u*T`A`ٹsg?~Yf lp92A$08# 0T6m5;l;6*" )-EXٸq#q@e5~,DZrc|#Fz޿ M$A@pҮ GuVzh`׮]M@6m(_|2ݻw!Νx}*_L L! 'N0#"V2cR eȐKB-[WioܹsI4"rp# p#, [α`r p>^hm߾ݜK"m.}:tMPg4mԱx k _LشвvZtQ}Q  D@)!{,_ o sI"0rHZt3gNm7hHB"(#%~!pUWŋ)SLx8֭p$/\F {$G$~/ w2rA@Hl` pQ$ woHwkUA PnJ>M9su]g$!@{~A `2ydSw۶mSOsIALO?TY| I p[%$C CX>I6؛pػ?џI7n4v$D@_&{*Vh%!@${$іA 7nLݺu3uMF/9u]ԤISa?sIȑ#MF) 3gm+VvD],ܣwRyo"hS+.nݚ;srԳgOs. A@"(#3|]6AEx׮]>`@.]:U믿 &ЊT&r.L AphGA@`9Ϟ=+D]Qtj*s0k) AFhHu9rٳ 1DA@o3fHH|.RZ`eϞ]M.s mM%SE&S1^ t@a t1=^ ɀ@ZE$z=zuLQ1PH`իW/SkdwFsA DQGpw{M)a:EDZ0͘1x16lH"`ʈ=B:A@!E C%,E[.?vٷo)VjU 4h]}Ku)#@X8).`_ 2(w}eFr[ݻw/}TT)/!$=zTy^w~'\tE7,Y8nR}[o)ӧ '1bs0#X]uU>OW_я?HYfE 7@7Z]nu}.0ҖSW^yV?CoNެc 襗^;)+O>+mș35 dܸqԩS'R1vIpA@H֨:6^,%9@~pDGt2xO˛7o @6mo5БۜKB"ܯ"1*x/Ŋ0s?&.|hQ*.sV5jb%<+]uqʲe\6eYoRڅq~MNԪU> s k;E߅ rmڴɮҬ w.]ѾݗN&lٲ.~Iƶm\l! VP0y93fݐ8z8S7:\_-\ʕs뮻vW W/,a{xvEk'L2;oX@ꫯ67caH2A@{ T~ԔF Otʕn^ l7=/lM'cƌ12  &碁dTlъ洎˗wVꮒ%KV…?NC qQ@ѯ s{c@tD|󍮪b G"O<騿g[{YqƦ^cFCo]Qp񔟈Twr-^gΜ9Ic,GL8`M9I5Jظqw\I DQfy6o޼9yF|I H`Oh_nW|E~ե F@)܅Ý(pE駟/+f vڱc5mT}GԩS @6lHo6B֬YC͛7Wv{ｗ ֭!M*UԹ'OM:`pC\~91rCVԧ7aZ!Ke}8}\AD@,ӄH 1 s \bz<8ވ6C3%in۷74"|w }¿ku)'@$ w~@Ǎȑ#Xa oh"uoݻ{,ƋcQkP |ZnYmy))G(cƌ*Hkf͈i|^wL]{sX8{Aˌ3hT> P~}9ÿ><}.Eog>(@ q”y3rrk׮5ըQä%!؀aJE3g1ɓ  POZʜK"vieDIF&Ƀ(c^ w{GȊTWZU'(xE`#B(~q3֑ DQG0K{Ljx.RJNU)߇J-ZnMMD t9.\౳wy})aᇵ^paSUL2Vڌ}Q>+]l͛S/P$};x aPC)bA17RPlC%%|;wnU ?(R@>3^($)=zT ~NhM9 }x٣(6* ̙3{*+^O 1P@Ɉ~"GJ0<6&hG @ 1c2Q'GpC46%jiyw  /gYw\tAaypc[(] q ,Y{Jn(+@y|X{@+ 9dΝԮ];,yG"z~BcƌQ7r%\uU˷~lęLI}O?SNS9 @ /Q"bDotQr QK|wFَAC/K\!X@MЎ.סl'͖i  @RXCQV-LSKXIC:K@ Cɝ:u5j(ٳg\D!Rʕ lܸQRG%O>)T(_^, *'SXC_O?2OO79G5HG!EoO{{*"Q2F ^S}>ްM"E N}>]=9D8/*]L(QzVQԬY3j@;$u5"r8A@)/=ݻw+v[^B;iv}M@,"CLņ͛ǏM/Yo {!jԨ];ｖ%ަvҧrn̟ό}?qœKBA N-W$;h"=3Ǟ)U†HtG& Cy扲=VnCF !| URE|r*WZJihaÆd*("vٲeY53X{wn%lTkHT1 WFA@"(# ~>q^BeZb9j~t%S9  z[`%1c+YDxE ?UT9bIAG+RAI[oQ Le˖Q o A@H`ݤI3P]d9DJ,I*hFA @d{d'/(ܯ͚Sɋ0\KNc/Dt QI z|09Y @ P wpZ#8 7x#69s.DA 0yd*\9oѢ}W\tB1c0ID 7}?x%! YB)Yuo6sD_~I?XpU[DoߞݫO͹$A@WF~-@#c+K.ٓԬYf͚E4a<> $3fŋU A:u+D#pEW3,^XD],#t(AiɗD-E9ܽͥ똛[DSL3g0`$9|m7HB 8ůJժU;wYȑC)c<%W6ᥗ^Sq@/Ԃ ˏ?>.g =d 82 wp}A@p*%hj4pk^K$:{N:97 r"@ # wp}=J-[42 2y%ZjEc"ШQ,I @!Pvmׯܹsޠ9ѿѸ<܈#`[˱LDA@poQG. wC/cI>=s>|SEgR G-={$0 (ĵu҆ MĚ5kb*;%uFDxZzM7o֧rtCP|TӦ&w8?"%}nN=9zx%#A /pGwO`󏺔5sfӊ䩼%O=]K2ehРAT $qpI&zjs#ͼb *Y'vVmy'7ް$- %\BܹͣsaǎK~ڵ‚l諓B߉7xyjo !Apg#g3R<ڰѴ:;v B`ڴi4}t3,c^zɓ @\*].nݚ.\he]FK,˛@/!RZhAKJ@DBkUq4vpH!`󸋅{P~A@p" w'8;pϙ2E]D˕`#{ 4~͌'"@""w wp,ۊ1x#M:^˟IyDA hӦ 5kLlܸq/sAtWРΝ /4璈7o:w&- A@!pE S̩P("X}g隬Y͹$MڵLCsI hĕdP/ӣ>jg$ n9sPjL{g}f$!IhѢfBZ/ҜKեyq#F#.\TT .  @@,pDJɣEWǨH$qƌ4uT3{hn $"qp?~ s.#`swP =  (ܣ%d൜.JޱɎf+kҒH.GO?c`(or\A@PܩS'=+ .OZ~R }7:K ,Xfq PAAER"PfqmBG$" yNcCGsI D[8P.+2K/ O4Hdc+ڋ/]3DIy}$@<U{Mߘ1 R*{dA@pG].S m.[XCsY I@<<0he'@+"@2  l%Y^=GЛƍӫ={vzw(_|f _}UeZ'//E.X(͛Wn 4 x8ܥرKx9Dd1_~LZ A@[/6(ܽvc?:zRٲPZ9#i׮c\ӦM 8DDF &3-C=D3gΌ:_ȅ=Gfl;wjժ,@ p5… )}jRGJw(E. Pч6'N˜K"r{䰖‡Z>{/|#?d·-\EuWѽ"G`5?õ+qee.}A:/9sLsTNs. A@t6ͼz4h[~.]l PB^bŊ-[MU@" *Uƍg46mDX4N0!1&Y4c0lF8t͜EHs3 |'XAǣǨfv!Ynֱ,vF!Y0UnQ&у]gE3}^sA 0e;%\uTЕ9~p"CVmh WIK"9СA;ÇS9  4Ĕ}=˩S .]j,Lͅ(' Ԛ5k誫2#ٰaխ[Ac.JBm۪zق{T@AyG 'O_-sAaEp7>'J@k>[َ-Z)=LXN]9"Cr{p%](e|A,eN )7[7oM2 3oA ă%Om%S3eQWXA3f4[z55i҄@$A n{۴iC{1 ծ-e:gtc}_џ>uj|\/ʝ#}٧4W>3r#&ͽm}/LGM߂y [V LdpGo7حXGZNF#GMl1bDO\f( y-=֭['t`$C 9sK .O E!/ iӦ޽{SL<6{VF.]QFݲ.t1cP׮])W\T: ԨQHS[Æ ޽{h#?$XX⠲O<|{l8A ,OTgb̥@̇k֪dmZ3t:Tpt TwM>}v{bTzuG>Ne~;;Lg~͔͐>=Up/M3v*h}UoK4m"&-Xf7"[g+WѯXq;kw<05r䈡=Ԯ)7lPq5A@H>̩V)ƍy'Z֭C79ga%߉7("@< 0*W4!YiO=Bَzoة3u{Tye\jśaɺ$+`PȡG KGMBَҙv}"~aU~_f4e)(̠ĮQA]-$G(g0<`ÙA`LttSͶh[َr֪5#[7^Ovϩm 1-E"<`p lj;+ԧrLPMwnN< G =ܣ2~/Bɚ5Ou-](ay/[#(he6y\P|0gr~Z\qԼysT/ @oAw>Cm۶lAr饗Eenp}IMvh"2Xkb%nW@uhi^nH xSlmyctiBѪ@nΝϸҴR!IFNJhb3PweL{Ϩ4[Cܢg/t|??PÀ5nϨ&e;[[/^6z? coQ2f"lPeW_Q/ҶݻU,IuOE֤swhܯ 690W_aEVNRٲRZƎSm~n}m|a_H_Ϭe&64h%%~kTE_ƌU!x:XqC{ߎ2D"*@"m?}SO=M$A % 3{ioH{W>9$,u;0on#Ev(DA@`n‚[!֯_6l@P8' 4@̝cuk(M&'E;60P(_^Csi?dʹxv59OY) 1 nVCٮPAjߴ>%D~!|Ʌ}et  I`d&:G\Pclb"/5Y=+5"?t2A(WyKaPRJA @qM9Lc6H(Ϟ9٨-]a-%<^1y'AݭJ< 7孷RmySoWk0^+V4 ,իƿ- baO(u8֩S[Gl(:r[n挱`іʔ)0(Ƽa &dQ'ݗ @'0`#$M `gZP|9eֱZ]#!XD wmut2zk>5$?o8ړbsrA//D-%-x kY4a-]|4E,2`,_v Zmt޸wbceױ~c# 1`VEoY*ژ&v=~,eak+M'Daw ℿ=oOQIo@Vm8-&MoΒ q`u ALCA`OPd|ǎv>}:]{]T[eq>v3]Z2|p +sw^z%ls:4cBOw`il8lB,1A)7@.1ch֭g xv . rtՆ(f,YB- UqGHՄJ5-z pj<\ `ZmkIױ5ua>`X[ӻvn+o̗[T77A0MR5oƆ{w[Ș>5iOT?pC@#2oJ96)oPx(R7%l w&^PP L䰏tOP5_ 8ϵ4X6~HgVT16ހeiu JXW\YQǏ\l3Z:8&Ћ/Hoc{ryn j?l,X@M9 "2"CL#iY;X*ZiS-7{Zӥ[7[+,s(U(\@pge`(QeBu~Z_155oJtv]/{o}/'O ^!mMV {з9=r̤f@IDAT֎~IL0e60 a`nb E`m>uT5|@cXt.5Rq &BVc;(h2ȃB}(>[JzwS(Q~|V';hr)Ac[{lI0Vлk_mjcT{:j`3 &D@(eRb"9 @>Na߿?5ov:+;cf"N3 w-Γ  KvO''AjrV=ɷ?)I&aׇ7CX 9bF BZco7faCՆĵa?o^'SmE Tc˩7,Q]~Q3'T8MAInD!0XCreNoH7n9==?[01zP S:k=YڢukqPR(@]nIAaߣͨcͩ~Nt)[B6}z >\`npȭªe:h_(Gj dl|޳%fR6M}6Ϩ)„C_!lYJ QNi@PY"ĭB`EA ;|&dk X{J*yVy:`/$(!MR歎/NMqPFGP& 0d1%Q{E2A@ |רQT~HDvmMNѐ_IR$"3mZޥA7^_lāQ"'$+ %DZLjG7\;Tx=Qۀ9sMf?lҁ$>TTC,pM6Yrjͥ eu) й^"}^mmY.1wf˯WKKu2Gƫs|?ikиqT~Vv(V$2 wp =3o7P$LJ8VWfw:TՃ:W٘wSO+ѣj~3/ǘ>phSOӏGѷ'w8r p@jx.ڔS'ubXoݺ b cc\XGZc2yy *J˯! Z; AhԖüײg$@PUʻ 5Rpa|Gך5k <9s$zdSդ;痚4ӕ  ~?e˖U?Ǚ֌g(%ＨR\"G֕r6\q&P{nmEykLPC#U8{!eɎH{>XZ֭gƎUҠ/&6uΧ {jޣ/MBvtԦ޽GR}eSJo嗶*/QC&rw9i P5sf㣟C?r0ycՎ;n Tk=1~\?z*6U$nxj΃nFƟ}bʂ7ySMJrG).HF0~UXѯR8=ێ "@,!sl}Կ 8@81%.H΃'ڵk LW_}eu6{?nԲeKߊ+h2Sje:,WBCOsp{и:AVqfڪZ XaM,!'!EWxkORlhE8ܟy[<֝WܛX@NX^3k/ ,<0ݻ/D@{\ D+-.[!&d@,:wv)ܳ)paEG.%AގiR&0sìJV2N)WS?SGbjצ56r?3G [,s]/#O?]Ax&a+![ngV\VM~:L?F}۷qd@ǎt^[kk%O'ֆX{ e 6$q͵4?;jM (ri_eE,+>"CK" wDxƒHK I2;mr1qf*3IҧO٥K#Lo{ ߲g#oZ)s=4e`pJ*_[qȑǣK>A۲l2Qd*g ;`$PCoj6$v>|+ɓ'o߾vQGCt58 _x%~.]G_-:w,\83f(~!=v ~4#vw"jA }ĉfؙFx ȹW_P:~ЛZ8ő*|ZфYU(&>?r-F\NCűX~У6L-Smrq6~דf(jC"V`ALŖ̆C96Pws:A tX]gef`,89F"a&;x 6Z`Ee<6K2-,ߵk?ٻwoe)(񌁠>,a%ԩ,SSj %K9-<@5KB"zԌ`e}K1 ~Rmî@鳼~$ tGe* {5JBkC*J;y:|#=.0C3/lK/N73H ۴an19W2_m*>lj̳@ %ж| 1&TNW9VDZ 2>є<|/cݍHh۱1QhGڸL"+`#@Hxjacjغh#E1sʀذJɛ bf.a J|bSa׶m[: <<Aa @Zۧ;8BFAmS -j;=Ab!9x#|FjV%sV 's!ox%v29ߘn?/Dbφ-;v:(kJZG. @d3,Z9eEBO_Z+K_R&r[Y)!QD1"%P6Cae, T0vX#Db穜  k3gq5ܳRs bݻ![;SH~#nh-pH В)LZΚ-ZDA x" U{ĺ݆#di=<'C?*X@ L&"$"@U)"(܃EP  o6i>L"+3DX7 pkW@DA'C,b3o?ҢnKYA@e-Y5`F\|⤙Y I;X3(X$aFÆ A hjBWt2̓sQ"@{I=A@D|j2pGddӲ뫯hT!@}7cZw&-#v>l٨Z8}` fg3oFz ¤ԮQ41(_dʦ9+p 3k`kriGgϞK_0?>'&3 `$]T^O*'@۬Y`uX7iDs Cw1d[ou10~tTW<+PQЂ9*> kd*@}oI}F=݆KoOCQ48=(Cْm~Po9 ?CllZ:E&VX  o{Q/d?bmg?{WgEU@DJDXХ FiDJB ) )Qow߾}qvfۙk,e|w>## ="/@Uɝ(Q" تV=C:9b* ;Τ%-R^LSiV#brʩI$r=l4܅pwJ9t~O)[OV5dc&OLO[:'x'xɣ"H!d7= 9\>c 4sf?!iRM̐G~c==1 [`jjc>7/Ι9}+ 5 Z`AJ%/^J ^YUab<DbJoj,uf$ho AWWK&MPNAϚ5SWVn 6-ձfh;wΤ%;43D>09ޠr X!pBLu ;" Ŋźzd4tfJnA@p!PjA%FM 0e;vH}sקMk3 ?W}I򯿊FPzdVP W(Gd*,('A ^pٍoKVw!ܽw/rN+jҒ/6l@ƍ3+b # J SO=E+WTRݣD֭[.υ:{?3}O &&9O=3}D {%(G%)A@`ԤI<{ ;n#pWi]#۷J_ɐBCB̾$/RӦMmtۧLB9rAHOA@qp $F -k/]L v ƍ<6FiHWӏ? Cq_ suR>@J)O9xG /&vRQ ż'hQk ww4V,^ܤ%?ҠAqtFDݠ! A@<QjAeJ*E#G4sf?X G=G{uS4vWے]C ٳRe"~>eJ}HAhARޕ#5~S<諯6W(. ?J׏vmzO>KBA3A@Bޣ#'66oVV'=n߶ BM{Vwp^Ƒ'{U$*AKd*?jRU\bCߞ2Y2zǼX׼ $oh7mD!-!O._y}HV1@:(gΜꫯOh;pk$= A`F  %RlYZNs{eҒp !x(|.QpaJ6j^; Ц~Y5=7a*/]t.]DM8fbhnR^A@Jd?^U<{lʟ??nڳ pmCvy$ 9+WRK=/N :{^Ϟ-I #\U*{=i@z_]az^߿sJ"E(]{?ˆ!Fs=gß*yr!ݦ. 8N̖-X$mL)#Gc$W\]֭[(FL2jbuΝ;/^8K/{lݻ?j,Iݞ6WF"-cYVFecwHWS" .]݃^jDW<5^)dS<+,A)^ּӚ*#p# #w\OLŽӈq.ʄƍ+o@UT&MJs|/?иq\L% 0ahڵJE 5%JjժMeȐ M|){Ϟ=6;#Θ1#U^]1o޼۷i!!!tYkq{7|Sգ~ʕ+` x,XP[d:fxܑׅLoo,=QF>C6m(޾FOu|uel oouʃ*St}@9szXOiGѣmʜ?<uѢEIpo!+Hw{ޏɰd=2ѝ:M4IXao 9Owپ@=ЯOx]@sO/?<<[vpNt<{tj 7zl‰>Khs{$qڲI$& N^iք.?UI8D`c"q̉ I ax ,͛7S1T٘&M޽;Alٲ*C;GG<۶mΗ²MTgϞySVm_f 9`2k,鮏M<ԉ|tuELtM|t7nH?͝;Wy_}]S(D[*hƌC]vUߴi4l0 =^83,?x-G6m˅x  X=ERWzҶ K@$pBkc_~Y]d)Xu5ӧf͚)u:v޷[oO-lbs;ٳgW 6ѣG#| [NcD6x؃n"^ܺu($eU&*ovkHsTm8h2>/kL怤:A.eWN8r}Dt5;`JҦM + ay@#!/S)(yy46Oj:=I܁a"N|hcrEN} r`2VA@[tI ,s:X'̛Opt{N?am'-/lA@Cݎg9:bi۶mN!,; qdni;v!SL&qooO-[tAW_|]_@JK#G>x{ IG/#?<ԯ__@f5j ;=Gu3g=:,;Y;OrhR  X ,׀Iz1!qg~{=Wq񍠚ڴn;=1< '˗/<=m+WQ^ԩS ) {YZbzlsٴqW;c8.c.A@6ݷ@Nª:+( (WR!A4TaSz^Ȇ#{t|v{@Cb!A?\!% 0V]={ }~S(|.qU mƍ#{۷iڵtڵk:@8j$E|hт.^Hׯ'B2M JZDyߗ+WN2[؄ݼyGm.T;&T\_"gȑ#W;*UP&MPBݻ;~^i޼<\_-*=c&O_tBdž/L% :hXJE Ta Akvޭƍ.<8" x*@/I=1dGaɛv-Y!l}ǏMWkT*-3:`*A@VnDu;=+,8ā*lZJtc8 ,CH%5~nƧ8TVZJD˖{ 3aM| }(-M\@H Iϟ?qSr{U( HnӦ<&[f Ug|J*30q/^Xu-pV)_|7:ٳ'vF"'&\0qծ][zL{O\% 2 A@|r2?nz4CK>bٗDf1Ο3iI 5& l7a**[ J <؆lٳ}>8edy NLxcۋ/p_<Sl!샔x 6𢇡ҥKʂΒ%Nɒ%K* hc3&T?T+S:hY' VA@ v>@  B&52Ge(iҤ$!m*&rR*5cz8ֿo>M+lqy(wJŦށd#K.qtΙcZRqà )R(9@3'OÇG?j@ćS1!<&~X%ԩSiӒ}TRȽ #BuQ @ PhQ4sGKַo_1bD@~h._0{֕b%iЃwcppv%)kFLA@Wlu>0&N܅*[@+QFFd $<ļc%IJ(01O||݂ky-[jA@2:uYև3֭r[}N^fټfMӉ|ĢG {<8v.E  G\y6U&- ظc]ie AI+m+WL?jԨI4yNvȑ \BuQ@#FMh )]zϝ'zX+E=z #`.`VvhС6R$!qΜ9_*m 2eL 0@CFξB#" < Zh5<~6Leo53FϚE~K1VwpwA@l$e'{h "'cf@ =m pz ΋/r}\Ⱦ ~@֬YgK:uT=J[ hrw[ьK?ۿNCN}z;W8Hsf1#w$A@!=~ oUq+']Bڵk԰aCM1c6$FW^7o{'5Mlt1 {A!ܽT,@"Pvmի9R5pBʟ??u1n;G!gmѪũQEg4=p !`%D}r2ox˺Gjl$t/_lV!X!(Q"h .70.HuQ c ݻw}@KthҘ<hCxKT+  )ݹc49v4T,LiJ"^6l} 2ܹs;$A@| !}zHoA@p hAE8$4<߱5-Q„4k3O֬O6E ́~qKBA@'wJѰvOtESO9pvE 2Ѻe`" A@| !}HA@pԩSӊ+㰋/Rml§7^dʤQQ|ԙb}Ѩ=Zjh=Rymt9 ;w>NquG խGW~#cJA@ U[g"`x~A0ϧع M4K.&TB]D4'$! SO] C}#F8fZz mR믛1(9 @搌&vIEbߑ#B҆  x<03|pڴi?}4oPܴzhZA@f,]J<yvw.YϞgy~ܼP1۶#Cչŋ+@ *K崨U|D2TF&O=z?_JS= {  7MwKܤ%{N9k+WMm#0j(ڰai5]t4|PbNH &ͱԩS/%Og϶ҝ;w>ưpB|hɢEhڵkϚt|$b}W}ww^J2'Jv"tݻwJRXINA@+=Ӊ@;PRú|W?w^ ѭ$b'`|鸻5), X=ܟK!;7;M9rP3;\޿Ӡmet6Gs>~&ƎkNfbŊ`u֥ڵk/:u޽{LL0vu{mZb:ufRYRW\QtlGv!ܝIr   -MVTNzߏ:tiPgmYtlАC|鸛HBA@p7oRnp)aSNd q+6u۱2pqm,_|4ydʞ=Oc>NX;(Q"Ef/[L5Kϫe1)PreZLIA7[w.C@$eOJ  WK3Y˼|_~e@n+ 2WʛCTMnA@wޠ۾G ձB H_S5brt,sR"y=XxhI#2;\[B "  3ѣG駟~"DO^ܹs;%H@[/μKJ ̙3,YfU+9sA c(_y„o{%:qaS_Vː! :7nl=l Z[j&1%K؟6hdɒ?c a ߱cGs̝rU"8@KʿӧOWNlzl aÆ{rVȑ#*ĵ=MO}l1k w֭[!iUjU9sfI͛7{JY&k׎pӋ/6)B*@ ЦMqBd7S? zVHsk,p&  "HpkވwOSl--+X[d-u=ׯiD$ }]t8}'NjC 8!)sH= rРAdO#3+Uj ]lG> iӦM)TRvdYw/Oܹs=َvΟ?9iҤH~NJ#= }ʕƃQ>x[v =a0qSW?VPXƀ<\mA~ó|Ȑ!j5SoQmĒ}TN&׆0+َ _D `U"VgV7h W],#0c ЪhѢaWX"tڥ΢k8pP&& ")[=^I$6 p|Ov4}XIKܺuիgCtުb&z--$ež#3n&MTK/ʓJF1uVEkwVi"gϞ΃TG82`k֬1&Q6<ǏYH;1OH@ca6 bOm ;w&IZMB`<#D)xj"Ĝp1*\`lC[Fx0?6l, Iׁd9Vch?URJǎ#`E> 0e~l٢S6mR2W8Jbl}(LH{HuЁ߯b@VFK 2P -XW;403n,3aL}lר!% gًgV%D;pƺlm<˕+:`7onm2eR;͛-D0xG@ @)_<)S@`BrPEdb$ ;3v/be@j3óe˦ϸd䬎ׅXoc`(b " _H *<=I_ *iO{9Bdy܇]vmX,&z<&pMa'{x˝ @#`(t-[&{｀@2?ʝ5z4], GAǽTÔ;uJYA X8r\+7m3.˗8hcrJ~J0A`&N[??΄FnKy*Q^G1@+ _n"i2*SuZƨktԟїɮk"Q>kQ=2eT~{py iIz r}1A($QI8(}vmXqȃԭ[7VqО ,sQs̩;4qy O6Wjdu;s%;io$,o{M„ NZ)|tN`2VA@@@a)!  4;=g*ڠ7SB3o  2Xy0ڼkWuc/K4& <|*{]s<_Ś?8@llޱ"WAl'ɂC'@@3ՠ}ȀŊk)<X{=JEج"vMmQ$\ï< rj^mƇLHL#\{I3 &+ 0w0uww*BopM7gbKr  A 5n5<3с +`EX'z2zˣ 'PujGQ<ܵ]Lb_R-•+6A +N<;s_oޠ!|- eQT7 я/i_ x`D׭X2YTg0Cj8&ļg)ZW(]ĢG@{`Ɵ| 5n8RH\XU ݑTcݮXB׼TX =[ix]74'MwނN ޽{n22E<-R^Qyc< ѡ!n97}P͙3d]sSw$}N{zud&LV;j `rz+H{:!&ʖ-BJlo@={! {܂ ,xxZrzC<=Pl(3j+!34k jݠ~ /! O nlOگc0^ ;p8}/8PSZæNٲSro z>@(Μg^zetK>FQQYVFuJ!as=A9Lesܸq? e'к"1ŁE&MhDVHBUsS`}zB ҜYtgH &wHW7oND /9ǵuNdȡ iIr8}Wjb?lǵ J̝D!!!*ŋդ pT Ak֭_C<1+Yf1pHv]~X~/A@bj ر\%sܜ0,Ɛɢx_~dv2)${9> Ԕ_! +v6W"6˂|My֪E@Rhk 4r=V~/:&e; S늫}f`L O~eoQ=.!Odo_1dzZmG{>؋ n(c^soߏ#VsfRF zs%KhvMx+ ;8 .<í$8)S&}Hy~pg5t{=z'yk A(kGN8^Μ9noh D{̙UVH~w h h>cZm/xϛ7OViHL6FeqF2? Pqz+ 5W0t_xѵbEw=ӼiӦOZ` YqFٳǽ_'Νk&Lpc" +H ߱Z5َY +{$<=oן( `Vz$CVW?\(}ƌP {5lRp`ŊΡE-x!PBM4#1o̩U*A&ԋ: z%| xP r<*/yⴷB|pNTǵS9w#m?z}U"gD^Uj%2oK/vϨEq[лQn)2]g dEPS}HZn<ӑy&7FtNkŜںឿf-۠%K6=ϜA(nLՓTe,YJMZi#$8?HuXƲj+ܬ)uiziZm eg)1\llG].[y׈T ^_XpӦSbϲ3({ZƵ ^ڛ7ovH<HD mA4É YH@pԞuA- )s8ǡ"zĿn- E^1H@e [L+:nD,x~㾳Eڝpwsh3*2^s `B%r𚇴 Hv]lcD@y;ދdA@d%J AsO]ɺ|W$LRlՒf'x2Crwa6rG c-z1ƍUuBX{Wf~=ͺx:/Md{Z~*ˌa>D j5dUl.<‰cG 7pxLJui]d,p_]{L`kfɔQkBVi3kL@2kB?*ĘJLntaTEitVG0=,GuНkיx=a\n-Vζ|3Bbc'A\+^Ys=8艩}`y|bcqƦW$eIA@#ѯ_?Lk֌k3Jhȣ:#y$A z^ԩm2a'/NU|qLv%vYTU}q܊^sX4sf_o ^REz=vGU1Ll/Ϧ9gϲTZ5Z/~^ifkԈҽFXo&];iH.ryl5 V4>j߸ (vlWy;-˙*K19~VKw5f6$ @`# }}et uU:l &!fR ީ nj! !\s&- A@IL$߹{>EfϤ2,Һ~=zXY nLhB*#ū ZVu]*-1 /{KQnǟG Ws?}D&jt0>it{ߡ[:[7k&СԀ%tArZ09$\__>PYx)Yeh{j py&N*J9\k]Og8 ϣ :ڰ*bرw׮-'p9x2E *ݺs]P '+/FV2zjYn1+`oXX28HB۪>'AK:]dA@+ݯ.tVA 1KhAwl vjIc'O`I{\i7rG7+VP5iT̴XFTM[BLmi8XbKᗬ_Oݻv򿖓( RP3,5eWߧ>%>ZxëZMl&8|dOv{K:VAZ[}pgo-5Z>O|&u?:X{vǓt1}f #ېP$O^5/8#3nSuN&QΝk:.~75b#0yl=@˖- OiC]  8B   ;4S{ٚTa .2`3Y  oz t\|^7*Y`hn]"&f  . -|>EڻZG1؇lLڐ'-XmjU;yycOꃑ>?2s8w)'ނtז.M%N8t}܆n+:2k};d!(9d|KoӠ~Llλsͽ}?t4|r{9#X7fΈ 7,rJS5$d-Z$I}!ul?У o]1 -<ԫ$XЮ..]Xc\&.ǚ̔>l ?HӧXR L7%?aç7@c{m{%_,@>pȻTaiɓӍ[T*{Z 'ިgΤmѡ'TklUuNdvǎ:o#] Qy: 9&"P'}Ʋ;xXÕQO=ލq5]A'jYNt'<%C{& R`EP+'O#93R ! iiG?G o4yzj${4iY%X$o^彉A=ZCbL`pTSX XV'@z?Č_XnUpr20AA멃mAH!]B^˴T  ЭbO՝s+mc/hhwkq;bLB=KE;c _+]^ϖM<2.<O~*b=ݐ9%SFA̡n-g~|z[mb#I8+"Γ=lIIyTp6HXϲy8۷c@ĉ\rB9)W/!h//MjA@7ZKGi-;O$^ T9J+6n:*k(y֔v:),< ̞C\ b}De9髡t=a< + zҀijkVNFږ/V*Ekי:f(WOLL|:bG2 g̅ .^̱?&5َ`3 !ȹY '&s&O^sOߏ~ڧseJ!i#˾ct@gŤghժdY%TD .&;Y8H:>b@0!S[0űb&o:um߾݋-IՂ xDw[No5?aW1<]mΝI @4|=9aus’ι6kPPqStHnlkZLZDsߙ3 xTkE2϶>&~d/MeU#vjLSis٤{jկ?Yi>ZZﳬ kם;0!ᬁBDގn\q5Qx;rTTX; 'VLGPA^#9 g0ͱ40 b(i'>(bT,s8iBJʒ1ᷰzٲT@].)﫯ڲweImN 6=>% FLT`;hԘ㾫V&gf)hOpY[6xQO5ܹȜY*!Sj{qTGݹޏ6"qNSp)*s@.#[*&Ϙ1ÆC͛GL7T`e̶U^o؃ Y&NHW^U9s"=ؔ_U%/۷jҥ c7+UD6mR6>|裏hРAq#ٳJ׉{,Ybnx2`;v,Ux0s"˰aTx&rEGA/E:IYfUmVXQg 9jԩ#z˗ordXz aAo/N[=A{'cS&"b`0tBxXXHL 6̗35[@AԱ5,A#D|UlN)uPE £~{ ٳg=ѣs=XW?fԼysuHK]=e/]fO%XC~+KBPިQ#*TMuxyqɒ%)a„?͛q$^{5޽;a $I|r/yy/KVkٲ%͞=[z>}ԗҥKgEǫ+WV8^hQ,R6;AI}dAwo~iybykTKdի mt|t˜`6 0b2e'[;c:Uk n]/ܾo4!u & դw2"aB D3a*+ʟ߱Ҳ4_Lzd5gaE5~>{M\rxUDOVB U><G{uT#k]Hzj><ܽ+ r=m\swGOC@qhV%B}0⤤\B ?:q”#?+W ;X­˵: bDlݺ5OHD'(Q"J@҄{R ]'ӧOO͚5SV½cǎ4f%[N?/S 0VtYLZhkYR{=H`,zXFy矛LV|yBФo۶-;vL7+[A@sՇ S@ߩLFNԏ=67'A=8C-h!vDrwlˀٍkFrL&Hyܹ܏S׍8ڬ+19iBpT p<@h'V۟pe˖Q:ub9&Lxb^<׭?8!7n:ǭ4Év y;}A߶˰1a;^3a|/J߸  dFv| U& x)r z v+ީYStD8B~׳.Fцރֻ<8VﾋTgA}WA= , 8g`AejIZ] $'M{ Ixu# y^TzڴiJJZjԨVYT%ǡiР!k֬NT:%b=wb'Z!X+&2qdi/rLtܙ: nݺ|`S;AC&OP9}e@@,|>)goX?_>GZ RAQlѦ%fY.g ~D)+yA7hQ?rf,]:yrS(4(=*y&HZk,malAܸ}2/rb xMLhb%#͑9' :>^fDՁJQR7 rJ;wbd;#[|9}WJrX+ֿe l%ۭAZ `n>|{CΝ;4c[l۾g)*t] }E"Xq5َlG_k\/L];ł5kӱA5JV_?9s8vpUG11T-: PQz/=rdzQW^y*jVT$ A@Kwn qi@UW'sh~ wmᮑ |u;qFZ@@`#*@;y:j3H"#RޛW{S^:_uX1r^+VhbM41d;`O(V5il5d1#kk`M?qfGlQi|mJa߿Mkt_@G%I0,}Y]}ėVp˖cܺlA 8HSJ=Ot7lwgl߰<~ Dz_rEiZ ~}ƭL)OW9p>=T.5 @0 ͻ"Hqdm]V˘1uW>ipƍS"Hʜ9s`O#Էo_D HXI,Y(퀗߈f޽ *իͳ j׮M kACyq:t@6mJ[Hx $UV 2DFwʢߐ~ d4m x8>`r0Wb'vQO~`$~3pmV pxAV.0`tp0wb/" XC͛7W+*T'wޢE 7o>,[F@8 R=~#f1 %03GAK1%(0<0aI돯G۷oW_b̴iR~81+7o^ME< L!ԩS*~%Jcvc /@WA,R$A @RwZ"lڣ'6U |yi˽F}d3-K/<"BY\K8f $b͚w7}A@`So4@EJ;tf)My+W^U$5}پ[սz=>C$Y#m lRrGMbWZKpt=/6[pwˋI{ӪDZNE#0Kqd8h"YEh >&>ܘďHg+In-@cǎR}ޘ_6߈: 7;>QkN-}ٴiLbI;DeYY]p"Ac9^UY-&[<>KϞuԯ][( Sn=o6P]d 4L)mãve< ;̐3}I8l~'^pR$KF 1E+!q-N1З j`y䉲 wXSgٳ+K.}Oaʀ1JDWD8jmE8>쳺-ks2Hwq˰ތ=ɭ0KKJ,DQXaÏ*HsxHի/lNRJf?.RfIQw*~aDi#CK.&lw >mZS%6ghy>[)YmO~ mMt5A@ # Ŋ@O`ȑ${6T Oi+qH4hkȷ@|W , E}=p)b;~wb'ƶ-Ow'"+`Z:>YF';fF 8kb(ǚF^9 =%ȵ`f$@[p빘 A D|FpɓTE?GYZ24abuD0>4&cdGW nj|5j^ݺѡ՟Q:K|uCvլY/x~\5ju_!!ls&- A@A@?^N]Pk$>mlރ+,A9x!j5pм?CA2P,޽u\h|tw凷mۦtAYSA= ]NK`)k_hSX9&;16x2U=J p| 5n8Rנz p"R e˖q%'Ker1A@nҲO9zu ^YZء/W[f.]7d VQXpO$ ;M1J*gsB"n 3&V>K·X~iʔ)~CD9w秮]*_htc| & KL48ҥGwyPHSm~ JN8;AΡPA=O_|x¹jYmɑ#q@E5k*!`ͩ^nҲGg)ʕ+ Blc'>H,#)4aݨ q>⚠U-L&S2 NEL >\dk0bABӧx}gNmǏl%n6llA@4iy˔A]֯ ۷VL,r\z\WE (TdIiΞidz(_Μ4oxBA@AOxoڼk}=}C{?It/&$ɓ(ϫc{Ld)@ޣ}jI$3g*oqIߟ cwA^K倄+0 ao׏ze=}N@2K^ ͕ 7nܨP[0C!sj$ yfsUuLeQ$!buxBGʕ#Na*ɕ Ҿ}lc" M6L @*& Ƚܼy^Zyֽ{ _8kPBXƳM(0<:1u3Ѻ2A@l~ #Xr= r= @p_,0K,W~=f|CCC#7L=,[ 6،e˖*?;>|CTرcLJ)C)cAmڴQ[أ!/L??~CWʢ?Eo嘀|͇UսdɒEosL]Wb9n궎ךF!Cشy…L(G*˱rćHœeM]^׌3>\vC6NOVǙlXn]wʱgk[:+DC1et=urA@8A m4dDqjܴQtFڶiDҽJMkbC33iI  a6 K$G`U6d;B.l9Me:'A7ucY{Ã:ކ -B-Қ A@REhؐ:r5hL,]ߛ}O!>gҒA@@GيJ$F+ux&٣ك]dl@H3FyZ£/l۶Xcr*Uz8={TAU!!c;v>,BҦ %M,}|*%JTn[ϣ=b0gЛN;HOի?rK  /"_8hPN6 >Y͝œM4 -[,xJ4h *[,/^;|pڰaJ#_P!O9lDpХIA@G̙fNqqi{y mo>g( n-pRF,Q}VBBBh׮]Իwo! *_E@w_2/A@F SMhgYFf/?{WEtqÝKp`܃{p=qГn|MRoy}]JDѢյ :Ѡ+D~́S#2#Dyv:a]"29!M/Z^n^ݪ5'[J G}wj`ח(E I#&܃ZTlWj߾3gNqYP{NNh$d' bkyz 'xۺvv҂4ݹu)8?-q w@IDAT/0# zv߱YF{t Bi8݋Z'߿թS޾}@ӧOuQx|N0#`0nOFwiZ`yyyիW勯7~[Sun >ƍS֬Y͛750a׮)s-[,}G0xJi(az~9O`F<~@ ר^.LQ,Nشf _U۷oS%hҤIQeFN"C>_0#`="<%cRhĉ?KOxDϑ#g{Zv-x<#X)jޢA:#סk[_|M煬pnmpg=0#ط( 4>m۱CyjלEͻԩ Z8߅ҧOm㋰A`ʕT@:wa-Zy1#0&#ʓ y9:: z]pA{ ~H+x{{'CH#+[ƍ`4yvmɓcv&NO^E6}80#0ox7*W %JZ5qEMɱw!5u0FDU3 #;vf͚@cŊE˖-KR̘1|N0#9M8"޽{Rj˗?$iӦ jӧOte'IQ˫Wdɒ:ŋٳg!#!t Aݻ4G۹a@C."09/hgȐ/}@F/#\pO6Fv@'Nzj?GMbE-kqHV33s>uxd3r^~K>xSܸq=zD:tݻ}=P0aBZ*Tti}g?e{}ʍ?VXA jzP7nܸFM4QM06՛bs2No2rrΝzh+ 8~,YbQC3(\8ߊL;'\&{!&Q]*4vt_$C`/sY0a|J.j> RmP~cg6س].^yLMuC"؟p0h؞Imv=V)#U-CI$T=JZL>VO!5vF\8zB`еkW-Z /#DRXR4uTd;s5jHz맂`a i!z~"zGz+W(W\~v\O#sG9 } (i +C@;v5*[Y}yfC' F AֺQ߿ATk֥sss)> hS p^3-|%;n:MPJM̴(̯-Dcpc0]pmv 'Nr0VNTنB-Ȅ'C8ֹ xT2pk߾l?>mܸfΜIL #L[1$IL"=Ǐ/IׯK A&CLo`AŋKtpt[ R+h2eHɗɓ9Z"AkNuwTʡˎq m|РAR=N84ydITFy 3f̐՗, `#ܷn*9qOHxcLggRi޼sPǎ;hذa(fc@i<m0DvM TGD4qvqIRv%:yl}|?9M+M6j#?EvwԼmN"L !St);î!ў]K%z“s Kh7~QH4mރH%; ޸Q-ⵇ._M]Wk F v>RJN= JHS?}t!k԰A ug+#pʟ??Y0R%mݺu |0@d@ h#=t]Ç cǦJ*QB$!n_iҤ!K` J*]mذA zرZYT\rb on鎂ZjIy1OhENݧ %O? B4w,+VL.]zz@B:rK(غP|c Aqt:H1ؾyjתda+è}{wy3x4F $LO~^ഴj4Ē¹>7QY|9h*s"Xp߷o_o&F~5*ȋG;C`!zs菃8A t… ٳg%F 2aª04IiΠC9F b 0e]Hl#BvmK ӦӮ#J1ᮐ BWi߮{ái <*t]o)v]/_!ቔgTK`=ssiF [=-1Pe>:qBپe]+iSKꆫ|}(?3w$ J!c}tbH7:~W;8t-(}b oOZ_q!}&>9,| =q^C q℁G8 "Q5kۜAp,]!bu׫W/ٞ4iRL8n8&ۭ?06V~ϑ# lsӂwBÆ iywޕix[@327j~E3MWfZ7b +/_6m*!0Q,QҤ>P_{MQjYժ&/wxD$3JHLsX. j-ѐ[%-?^ x[WޒKyѲEhU+S7@9$j6NIS&7n@ SRS4ȱ(od?}[bKH1fLL~.R;^¼TN;Ioji"u1ZceNsFIz;Qe9Ϟw`z)ZeTN7ovy3iቱNG~`ԁ*KSS5չsu4p_sPL y|:tHްr+Wgs`HV|?&;;;)tx:TSҥ @zo@dZdɴ/-Juh~pxCr1curݻbBx@$OVt=zJ X_/wO2hYho2gN kM2'ծ pZmĎ4Q[5GѢ>wWn=q^nvz2 /q'U>J"Dbp{A z/EJ)^7-CO!&#_Vk5_bTv&:_ ,]tC+BK٣-?]ۅ 3x3x9caD= ӂQ5ءPh:v쬟&>t>LP"\MPST_!y&ReI qS}OǑbQa0# Ȓ%KLKOՍl}H,#hN ٬vd!ZŊłm 8 Ϟ=& F`"3L[>|y=rH:}41OutJh4aҧO?]?~&N'RH!l7_o5UeWmsΕ+LܹCS[ @-?S?]b1Co ([y#>)SƏ wQLrvmK…R5)PcD1,ܺu?L=ͳcT ^ #Iܽp)oKV׮,A31}EdiT ׈pFU:sr3 Cr"+7kWeW-YsJ")5i\ Dc農>.CSʔ$}+ /Jr]2p 0tD{_}ڈͩCz0<'WT#,APw;>x(#`lӊl6Hd]p~"ٳN:|~=mٲEhyޥ#GH@b<\ɘek֬IJ:Ge׹sg|)6l|6g$)\#*ˋF- pvҥ½{h۶mmP%JHʳoߖerwrrҥKK ,ܹsr%VH ~`O sWVj*m11@De8q<[ERń'ij;$=ks溓}+[^@Tb؆+>ӧ}SzJ1cRI.jW.S8z A^v[.Wn/eevu* :;ϕ+n|D&y. Ap@)ڸi>&kT/ M<𙆠bŤfiy].xhx KP idj$ #ҥ+oUbe2iTs IF k҂y.3_griV; ?N8F+[$&OY RBw|OH@@Bd;^z K&ZhD1Ygnݺ `Fip)WɓG+V  {׮]iʹk.;< 6O'/^,Ixxף?1xC/]$k`N:IIs1A~Bݻwris֭[7I؛Hoܸ$RpUK5#6 +74m-"(uZ8hGϐ^ :;븇3+Q=$?.$59aQX2-D5kTЪ23p يjnz3.V~2xH[! _%\ ͽv5pW5Bb~'[0~tTʗ+=S_vZ@kQA߱CS.@,1 .YvΡ:DE Q"ÐLϼH ƏC 28>4mRG]9&MH;})zjʟ?>ӌ#D9p#O*$ݯ]&I/_HmLĶ;IR2 !/vEz}GoǎM6RSƏ 2Hx?6d[vƍRbѰqAQ51cJQF9r0ɮӌ@$AFMyy]]ђEm̱W;%aUxFMUx+܆5k"2\؅ Wi%D nCzߞLڊN}F땫j;*kެ/E) w KAr%_^g G4PזPnYr軅r?y}$xWy>keJ oub!g[XfdZ0g&kWҚb}eIXzM.bioVp~qR`0K;v8!|d4mR%͟;FHR郊ΝMH_ P={\)k+V,C>_0#`=zمS0w8qPɒ%}3Djʕ_~$ʲe&s˚5 oP4>8p1@GAI{I˛]|0'shq(Nŋ=a {L=!a4jSO$ G Mu 'O_R 3q5w v7jH|l ;zl#00EJ߿oRNMK,1[ƙ#D sj )WRa{:wzP,sf4eBA /AC\i-Yk XѤ w@Bn˗\XQ@H[SY6HuWmT7:WA2E&EqnUf(EٳL"~,]['OHó >0xc^x~R[ })SKڽqʡ}D*[R'$֮U*xM(;}b^7'N+gP]` 3ɖ5Foݶ ȥnI;{h%$G/,Gvs3qxmwlw0ܞۜ3]."C6/&{{{닡HN:U,f F`1 ݯYDdp6cy+FR3jڼfp@l! "+ŏ^6[C++L#iDa+{h~3u Rewh߄On6D<>w:vAZO'(cİuJ ܍XeAn2x?RJCgS[P kHٵTN<'LC¦uG U 3!S [ݻĉӎ;Օv`K$gЖ󗈀[֦9^"Za0)S}t5kF+VF/܄`/_^zv]*\.} =ϓ6hZ}.R6˦fl=]p-!Gv {-lxޛn߾O tۓ%KLiRь~xu8go/b>=xD'N2Ξŋ`[=}$A3|l,YDI6FpŸqhС?hx#C uZeN0#;K!4#0@@z}zw[g\]wbso6 5ː8`^_0# &܃fF `+*i"ER96/_ U ׯߒy61/L"OԲ uC6B<.$#0Qx#u@UΟRjwZMB8q"mݺ&Ls`F xg^[nLb&ݦ7oP (I$rM62̮#0$"U3l&OMѾ=PU'&MLNyt k? ՠ4,y#^8PobŤ928m4m\ҦII?}lY3R#\@R0#`<`ѢJÆN4E  UTTHB@Q-ٓ'Oʕ+3<]t&gϞϟ T`Ay67Ǐ7Y#V zqy >}_ٳgty)w܆X42C=K]~X`cAJ7MڑG$7"lŌ36NԼEO94$oٝt"抬שc36cy_V;gF`8=s! p:9}$յb ,[tB?6Th׮M>0#`=,33JCJ>$L" Ց8qbᵘN>-˷lBSS0LHċO+/WV]x-ZH… t5yϞ=%5%lСz͛7UJ.-YB9SB cTZڶmKjՒ?mڴ/p2 qpI2%ahWfM n|XW|iP6{l-*߾}*:uhm1^cǴ6*b , ($juFdwacB Std6WoQHܿ,yqse 0nL_9^0bF`3CSM=LUVԲeK̟?@UF)L?z߿@-A dFW(Oo Nj6@+ox;;;kr~۶mѼyXbSPɓcZn晎" 5< W;}܇9Cx3yC]&M3۷RJt]C7^^^ӭ{` :ep-5kiԥMFo3eQVo;wXZ}go!_F`F`$;vys,ЁU6kpb^K.5TC~##@*#0@ q.Y$9su oXf̘3gΤÇk߽{={Pʕ.]sJOw 6uVC6\ yTY1F-Z6m$d5je˖M[OjߺuK[Çᱮ 7a})[$q {J]vycѠL2 ?_ŜM<6oL S 9<ڵkѣt99w7 ;;vаaT>3!<‘*/ͪw13v$g4AvX> ~ 13(cr7]h{GcN.x1&-=gF`A`ﾣ4p=].rzsa ~nް;3f̨4#0` w+Apwݻ%noooqdhl߿$M+ȑpԅǵް0.bHf*줇k״2 , iӞ9sfeU\rI27(%j[Y%|,  ZJo Ņ-@2dЍ^ MFG5&שS'5+V,)cj*| hcNвSϟT = "!_PPuD&޾}OS.L$>ӊ oPN;r՞ĉ%#Т%k"O<FRBO@?߉ci+o3>Kp>#(G!E/8͹ #@ƍ1bTB(a|"YǏY 6ŮpAtRUiF`A 9FiРFI@_]OAEٮp8AVoeC]Or w,`a~zyfz>}d]˥3Q ]0?IٱH} az6"i| _`F`"ؠ'N<0pwww-}q=F`E 3B~CPf.6BFpB f/ԩӕ3XRZ%N0 r[ҡcg9n!׊ozK<9Xʗ/4#0@8!AS <POm>}J;<0}a͛2żʱi5aYᏼi VY?AE_EVaZ _XOWwTcVrrr-`GX+0#0#D>-o޼~իŋl||(. Ԙ A‡2z{RТ>}ҡdSN-\`؂`ty)le&MJ.]*p^iժU[xc~~80isov\K3:rp'}_{?-a$hAcߌܭuBVODH9rDCttt47vϞ=WΨ>L>pĉ< E]^ҮзQϟxΝ;ULTLJX,YlTy~mI@ =ua׮]+3>1?XӦMʕ+2)r _x@IDAT qZ05ԃ;I&4n8Ij+oy}Jѭ[$>` ܻuFNe˖I- *H/~łBZ՜"bA{zzY,A0ecCvVzr_|S ;m8GAoz3Ͷ`wp&#0#0p͚5Ggpow6FV;OawgO8`™ɓ'E=Pdɒ`)S_ppTe XRjӧwUTdɒejժQe>zYMEز`(2xjPV2xlْbn=郱8;;ܹs-\юAꃠW!CIh< _}9:w'**V( u\ 5kV\ *Ϯ]]01DeY?>O9Oރǫ,Cp7#0#DRS>_|~v>pGڷo8XB Πpr@#9 I[srއ9s0`Llpss Ph5d^p͓'h,ϻ6,SLre ׯ_%saޡCj׮UA;=N8r o:>HiH  :ۀdG egϖX;ah OSx[2,2@'03fLZxƇiO|${`:@!R;w܇޾yx"6NQu''J*-Rب&ϟ>" `F`F b"ߴ}Sn~]t1#`M@C|/!E](5vlG?ĈC]!i:^ 2+ K(@qB4-Rx- zgS5Rn z3 ΰ4WrO*A%h hiuT}'ƅ/+{uyTt̙Ufة26.l'@&!㍋794|XKf||xtÛGP \kJPol#STHkWդ7_EϓP JY (qƎ>+ėS p'#0#0a^!] R5kc>ӌܩS'?@#) İ*yРARVĹceRIP[Hڢ...ѭ Ha8wرC۔,YΜ9Pk7(&@o^S;P[i @F+A޸TRRXAfT| T3@OfRHo8njS28ऊEE zUr7N>m@₡rՈ7˷0#7 ;7l9,l, @o9Nfк~t' F`F`.x a  @"Cjqd;Q \r5HX=nZ0%X =W~l%Am6G](b! r._*O1bg?~20A'=Q_o1%hd;ʰv\8p@#K.* 6%Q9sH&Q̄{}|#0 3Vlm&ʄ7'OP,j-_F`F`l߾=5oޜZXh#^Ƹ" D3dw!k.|eʔ/^RիWzI$ӛ1cv,[LHFr޴iV>j(§OHgWWW4 ɂ'OsIoyh2sݛ#: RGh#c>}5≭[W-[RA&ׯA\ݿW#1#D9'MNV(MLf߮f[4i*Y5F`F`5%u R&!~I ˙3$XT]vbA^&Myc'Ovx7h@_'Uދ憁u*g赛5gB0UA+Dz溊2ye5(#0@P(!Mh,7s}{]ԅFBv4e`7eS|ݛtʅ+DRG% W{'J&Խ/[eEOc`߾I[o^уZ>,{>yN/^\*UxX c0#`5ݡCZva xBΐ@X"/jKj, =zR0W ['f779[24 7>"r>^JZxz.ՋLG'0#b~J56CcscJz}:_z]$~xv?g릿 $Lp_2wXOo߼$:{ǛbTZ] ϘP/YmzOh8fԪH}eIN!waJ_t_9vĂf BVdI0M4lN3aV} V;3 ޖ"E 9ϟ?L $c߀ydH! MA]@' ˞={@U"u9KD70#I,Ig"H /fUk5n9Cid?Lzܦ } mFi_3QnbpwoOMZӳ'Mu-vFx.J70FA'NH\Гؽ8` &ۃ /7 EKyrJ@*Pيat_2eQ>3OOODyC~… $i+jhz{)җӪ,`۷}Ld?<܇."pC87iK㰇-= #0M#¹Tj4uy¹i뀃 qrUk5y3V?}S+qwcR(n~F_i{?1cѲ0.2Htt@5زn)?sֶ.vJzv|fckZzyՑrF>1Q~ Zj|z@['F>|nժ!xޒ&MJ˗/ f^zuر#AtÇN E>#iF .ce:mڴF{-i5 &Lϒi貃4ynQ?>{}y\]]csU9rDb ƍ5w !u]ECOT&YRF*4#0#H2eȚ^Vcͫ.AUfCB vm\y k䡖#he_3 ccǎ+K{B:4בF Ϩzܕ?0gϔ).]ZV:s[௼32=2?]7F`F ʼy.=N3^N2zR$NmYF"Xٯ*;e߬n[!-obG9dxCًkMu>cZjөlTeIҼuڵJ)XM&qnWٴ}#͙HzDi@7*Y3#D$Ic!i1d/9dV u2>AlxUS kwʼn*21<c73,T;s& , zԩ0ge˖˗/{k=XGT(N_)PsJoQ>A&` tj7)LWiARs̑[i/^L gq`F "Y2ң>>Ԕp.t0UY:dTyPj|l3Ҳ&?Ƭ\ @e 篨uoH/r1WvvNtk M-=g/BӤ4@[ AIG KNY 'iXڕ4 G57>ӗ_tqwݼvhqO]fMatSִoʵUd2OMQZ9+bXö:D*+.~ų0t{8^8Tb`oL|9w9XT>JBz,tޤrN3yfAt〾xX @z"Ea8#y\ M'lS1y.\V6 +u )r>XiYh]7nXbmM洸Bk`FZFZ7QߡXNG Mhl юM>3|}:iTThi-u''ڸf)+ Qҕ8 +Kbw', a;)Ky]J RhbJ,1r<^#ۣLjNS2W"0 ~Yz {FÛу'Reق_k^=u j ٮ/bQa;oNZWk^"Pw)#(qD/_MSgc%Y~*M3_)4{3,v|}&M_L.>CQZwYnWsvLȇ:u&5n$o-oF{^[((IcπhҤIЖ0au-8/)n0VDX EPe#e`&C^ (o.V [0J^Jzl}^В_~F`zY R"eˑWF/'SR-#Vfi޷نkz=U4^rhcŠGb֡-0n@/Ӧ" ]3{C7ǒy+RxWQh|v/P 2TZs(&8^sJxB#f ڰkH\^L,L?mY_ےlԉz.Fn0}AnF</HKňܽ-%L*V-'OZB_t?=\xH`aCYd],@ٯ\NDZ6"0jl2ja~\;oܶNgxc ϋ kS,Yի)_|!2@ @UPEc6F p"v  f߱cIMNN>>ܛ r 4*5'y?,9&0@TF@( Ye|xpuI4ҡ_>~ Oo/zcR~p#U(X$?C#]QN3//Bed*F+|V-[TQٮ 2gH-5Qz:-|*-ѾFk"aQzWYeH#v|ki,4D}0K?zDeEì3vfKH,ng MbjCiy/q0ٮвN, r_0ڶ~kkb≯ȌvXϟޢE d{d~|o|s_C=͡boҝ;wd$`A RSeXg+4bƌ)?Dx ,am^*u4zRA4`I2|%D,V(*UA#\jUݻwhY+ӧOrx~_+1b '$cjǾ#s Բ޺ ٹ[]}:kdU}-U@,p[2\A[AZ>]ve)R%<եWX+*4kjϞ3+AG٘IBV2; X0^ص֨@} iÚIWGgY5xȗCk F 0SL1To3fP֭ |0ޫP;|d f*c-k>3A 6Z40*&o޼Y[lSA~7iX2 +l߾}ԴiSp͛muݻwcRU76G&W AcGB V T\@6Vj}^tMJˬY1St %ӤO,F({)Az>P:_@J8˛BvF G@w@Ur|ƸZtA|,dlٰC"BӖ Lk?֖A@D vڷj@Nq N/7|Ch?B )sXbw=sPI( _ =cbQ X4ʗDzSi__ ^'(6?fmyqO߼EK?u֋=~F"&DXU)b5~CB&"4fp^-P@Te0D w+#niϟKbzWi}_r4[7nG 26tQ>w\-ϐg)Q10em۶ رcy x/[LzӦM#owwq# čxBqwwWqwwl%*;t'\fІǜkxVQCȻ>C"݌@AYdbVYmҁf~yj@ i~2>l~kU' 4<jxzI7K&1NLm ?i`ﶔ+Gfmx_yu; rXY4k4o{FCg,5 [(ᚏfOJ2F CL'՘=(4~xuq}(ER;o,֋ڵ~N@;v]sIK&RjXd=u9_om۶S,0#0ƿEznO2e62ȑCѣϟ_F3߽AQ5z?zвa ovhˡ-<1xJ>۾[nuDZϚ5 H =cIFmq2O_hEȵDa9W!~<] ӤYcTn.{!s/nl"&!3gB9';̟';$9 lŚiԐnU*ִ˥N++߲}QZz᲍4wZғ(Cl@8H.7IzyU8OU)XOs۴թ^^$k7XݼwFޢ)cɬ}j6Lz^_?S΃ifCAsɒ%TfM|~`F0|)k2eVKm@)lIctZW#AfUJڵkZϟ/VT mt'3d@nnnK<{2 A}Z "; sՏ 9+%KJʏ={J`n:Zq@~z{`<Q!IL[E "#w9~ S' a3Yc:_Y&k8]gp߳s?eϕUWV1@QK˒=$ۑߵO{ھŏ{ӼӴ&.bLe^!N]U3@ zU?~}Q _(0h—:q>>L[ό#0 r#PV-PW+ESezI=q;qDlWuqO. 6/NO&ƠoxkûYd!O9IA#dacǖZ_Z[ԃW-2۷GM3z8` %+)cjm U޿L$g&ti=ؐ޾=_>YkYy

Z=k8fƋ`xt\$ɒhiN Nhϖk65q`XR=%L[Gc~IߠީMCZ<{4VҦVM]>b~;{ڽ+BV iU6%H)neD,Lr$8up-?Hܴl)>qbՔf[EX',N옴w{&6Υ;GlǸ fCM Ib|֙>wV}g8┌g tvZ`M? ~ lLHqbMD7#GTVdel6kp>#0@B F-|'N׹5 3fhrRNU~CݍCPk7c /%iMT![n`ieC%r3#T; -(o;})KV*um]̝H;UKfkz6zԨEgGL`~2u87ThUj۴+͛mIKI>0*!) R0xi/H?Fͥ6h_2oժ؈) RM>P[ԅ#!Asu͛:!E[&a(YŃW/_˚89pDUi#Zb#5N2gHޒ$5y#o܈)+$bvl5s] j9yZ{uw31u[IU[ݱ{q7A_< 17xH;yAz{; rߝ}Ex[ɬŸ=zRzg%.tc )'!Xj.qRC= ӔY$ a;TB><ޡ!>w,BHYSAS7[V_'`K'w"G Uj\62`Hndl_8saaT'8yWo=hӼ\⿊g;gaTEl1#0`IkD)RUY@B4Fhb'vo_//9> i@bXIn}:$}beiU3qu+"Nܗ'\fЈ_nV®%+[^A[dc!JH:\v>$հ FNtpMlBŚL-˙9).8>+7LsYYH%dT)eDuQ ^֬|iWZjb=ӤNnuM}51,*0ߋνGj߽HuC~ˤ~ %' 0׬F`=Lш`i|ЂFR=S#PB;&Mvrcƍc#$ +ٙ0#kDZ"jPpB?V R?gΜR C т6tP#A^*0WhͪXq7tK9r7]dmҤ +R(z=1ca1eЭø[n7oL_  +WLY}?eXӯ_5lٲez[ҤI G <ʱׯӪU:,3f J ijԨ.\XZWB= SL.P IGv?5{fJ"i@f*<{HׄGo89}Z9F Lfo\pY|Mg~xRN!6\{D`xÌ_ST\p'B_K!t)[ l C Q#&NO̟>\J2.Yi<6TEE qb[@# ;)-T;6sdL5 d֊$_RAO1FZO9¶vv5viE_JX0ɧ4#8pPNֻwo)=a"ew#F:*b+ń{=|pl@[m~葔9Qu˔)#eV@b7N^L$:D#G;>@ G׮]} >H<: W`Az$u~<ƆtHSN";bWu;uD 4qRƍ1o\]W"Uٳgm\>XRhРA5'Ogy& ۵k]gRRZ`0@TF׸({|8{W!]^ԷV%JZ+b%lVtp!u!1x۲BAٽ| pgʔ)gNiu֍31ի"ӈpww׼Dpٲe+V s 8HĉkաYHLNZ+w8<Ε ^^^R\h06jժkAׯOs1l"|Uch7 ֊Fu x>[l@wxw t?{aXt6&իq`F`F*tIK 88Gũ#׬T^~{U v?~9:yAz^Gί߼jە[-e_RIq2%8)T3ڜ35ɫsdH9uQ}qFC#B@c'qx;իB] EU+1bu=sJjm+R7j.b5AE^셫E~MʘI>;vN8֚9;x $n~ 28v>.\AjgN;1k^1 6Nb'NQ!Mω[ƲI ޱ$ӴhFlfGiw"^稄%\v/6׋4||1m8AHE/J%f̘}|s`c#6p!ǏIp϶Ƅ*U 5`9~-,[A# ׺b iE]C' /SLVF;0E9X Π wz)H.ǍW_,cxK,) sQ)C fm-eۨ̄{Txy?,4]pA_Y 䛻ҦW|gF`F` ӄQk]qYȖx, ˧PA /H:鲟Y V.K˼i&os˲>Ϟy\V 2$GeFÙiӦ2 A=p>q  Ć_ThQ-6!ʛ4iB7o$_oI$S%q\]]%N'OIM=yo45Ho8niwܑ:,`9rG;ZXBkނmTJ'*-hǵg)i DfcF`F`NmѕS[62xiImr]Р>$Mv!bI֡1:FF ۇ43Cz':shujӐĎ$ףuY3uTzy鹯;VL3u(ul@m=]DJ2 {w뼛U a`tp!hg 1.{t J2Y=Sf. ~CԴ]F9۷od~-v䃜˗~@([.]T ,d;lVDjR܉%َrxrϞ=[zCX$F#C+W^ K/_Q۴i.=q (8W>^K]]:w M۟n}H9 VW޻,kL2{=٧{ԓ&u۲x~Ջ'H;B7бwkVpjA?^<?QyE-|üU*_lx|K)Ӄ+Nrhcg@5k7@TV'|ߝiӶ=4j<5OI6oL-WH vbH`x_#:ҥKy2%Sz wNoOaOmT/l8sPnݺI^b9995]o.ЪU+ڵ$գG)2vXڽ{N4G>geA֭[ }(fWti AW|FduHӠ7o' 3'Tx@2:P<8v$!)3qD5vR ~ZVi֭[Bbz}|| p )p0F$eA[acF`F`s@>Bc ] 8dWH amOa> yC2Ũl!\xXC;r%4̞pdž3}F)!Ҿ}{IR+իKB] a1@\Iv$2x"W\I={<;wL؅.]I'HZ@~@Tt1IcFyՖG"ٳgS;.h{RiHCu7r.KI|$L)T3Q;d{V2i}ðF9ArzĈ ue*HlW}PӧuUG6lXCW#(8-1Q_#0#0#0# yg͒&NH˸Jl"lpCBEO+\OXi3:pϒ% iK `N˧MsGUx; JK74!y'6$P2h;J*eKU;"j># 7"c=" <F`F`F`F5.̃$d E${\Y؋=Hs@+ i 6Hwِyr&qQ6~xl{r|R:@6Eͨ62,>I&IxCK\oЇ/dOgZF 6hѢ0xCG?ҫseF;!cޮweF lt${{e"9W/]+ Wf$u> 9M E‹$Sڭ:w!tE`JQ냜rLRJ4ꄕ"ܕt < F*"ϗ0@Hp"bc#h͐τ[FeJ^쮔+Šʿ HFWrD?Fzq[%Ju {QpWD14h9<͝;WU˖->}ZQWTI>LEPyؘ1cO!-ALZW%Ium/ׄWq _MM6)۶mV5APQ(]t"vn޼)ۢnڴiiŊFd ޾}K'O&l2p`޽sxD $ |]aݓC%@݁NmڴIbge^YU#@#.vWsSlcxTDSTB9w0}zt1cŦBEK i2#`ҿUL%}#!pMzx19ME.2+F "V9MЮ]vd]/_H\sE[ރim ȓ&M*tkdzT ?&$"gA駟ݻw+V,mzנAٞ4׳f*S6M0AE:lK*U)o| 6cq{5 9BJ'SL_zUjcsK MoرCVPY"H/U^Mmڴ4H"|2#bT`d)RӔC7dF ""P(k=ЂjS91aK 2HLx[xvxV^tʻx؍7.UVMN( oܸAs6#QΪE۷o ^M*ᥞ1cF=mD: 0WmїLG`wwwj߾=]bA6?8}QY ![ sG8-UuAZQ '=`9)/~U xwAz˱x{yyɢ\rIu`bˇZy+]{7~ٲe)~pxJQB6PI0E^ZzSݻ&Vcr#0#0#0##/jnyWd:HP%njSLWwKR(V]~([kٲ%խ[WjCz zj>ٚuؑpe~0Ohc3$uľ5vОDžzԡ  62@ "Cf}pԩSMϟOֺuked٨ȚDŽzzzJGc=ew>|?>{D5}ZNv޼y1`^a -uFfx=#>}$wv \v/s!q0zptdC0#0#0#n}Cq 1r |X#] I$W52I^[Upw 6{>aoߚ+V,O$2D6FteY.]1z֬Y2(ʇ;"$8q"3yD6m!Ј#h̘1@.\ѣ ,1>v #7R@d#dy*UhΜ9=$oYas@P eaWl@S͋-E.$5P z_P!λ}}N3#0#0#  ڇN'N_6Qlf pRwE~Z;9%`D%K& 5&DoŋNKo2eby0{۶mEUÂ8ƅ7oRƌՓu@# 2GQfwx/]Ti&2̣H"t|zq۶mdp'ڵkÀ"C:Q\9ٮ8t`{n?xhi)]Sw[[/`n߾MK 6 6mP0#0#0#XvD3XO;NZ+;ip4S..z2##Ugi$:v,{82J(AgϞrh@ xY l85\iҤMwN͛7K;qZnݺi3}Jts*ߚݻnݺ,YRn`FaHCYI-Zb̕+WxsJOcǎ$lGԩw;lt(ScǎuV-ܱ8㵂l x$ i޼yGްaô~@'f#0#0#0av=zv5蓧/Tҡw8vNy[#%8p-Itgȯ.#0@`=L442d@NNN pS9;;Ku "bŊ={vpqݬY3UcR3n׮$QsE?>eTȰ(v&Isj'~ٳ'ֹsg7n\cd!R1l k̇;66 ~ʔ)R"L2x[npm߾݌pGi21w\i&6/n)ṗ|رT[3#0#0#?;AOSgM\F3xQ<"_|py|TĹ ] F`&cW\ 0 oxEu <޽k[E*8qF<ӥK'=A>תUK_>H&Mg!0odT7>N@^0l!,w{$,3#0#0#0@ mI>g,œ/_ 3Oą'eU|wF2,$SאwQĹ52F`"Lkt߳gϖŋ&:AC(5hc^ơlky\A|HW6!H:@ =zӌ#0#0#0Q Kv|]4|(?~,Fݬ8w ,-,wܖE0@ pM~|Ɗ-:";޿{+y IC27^*\L珛.Ѯ?!N2dFԥh97 9x\ RcƌA%˖0lgw]lcR(S (qBkU ,@K比e[ԧ e^ 2/D3l2ϜI`~hWo^pbƌy+tuWd:q`F r"{6iԨ^7Rm袃'<$f1odo߾p ׮]+@A;Do֎#tr0`ƍ "@[Zzd Sccaݺussye!ZJ.:FAG~Ν2PDw}o*^05.^c৞Xȃ~UF  ח|}"H k3x-T"i%z,hWO;6F BGm3ZMv~gV1^'ʞ=ac ejpa#&3B4@4) ;Q{ }'އ0XBy{NTh@cu o$~b6Qg.nɮ Gϟͻk]߱d1wbڹǭ gk{X1)[Y:?L Xh#D`^5] >n(YD"y{1yN9tENj18`F r {{#n۶md m>|XdZQd^ׯӪUϏ~ٿ"sOׯ]6PK9r$eP诧I 3O{ь3T 4ARÓFARJ5b#~x!k׮B^Z"jܸ DX,X :2g,MuA_=`4Nz5k֔:z;p$ˑƜT;<+S| Bos&}_TU|gF x WVxKu67cϡ*ݷ_JG{hH&/ns|N39SR*MhҬTGUx m^K g/L9sgV. qEV;r@_:zM36H A# :I]l+-DiRdO$Un蠐Qծ]۞#"> vk;$ǚ> <)`{&///G}!n!0.k1|"<L1bh|W-N:YfK"SgϞ"E u }4hЀ@e qAw IR& IsnD ~]SJd_th hRA( xnݺ3r~^*=2Xc`18Z[n%x9;wN5S @4lP*rgzԽ{w/rHW...Rf͚525<3f(SN-=Ƈ &dig8Ǐ/vˉ5M ވ;ð\طo?ʰ&eqpOoG9`Ty0ד GN,?Ө6.靨Uwe<τψFu_~-V.YK}Yׯ$HKG8qb 2Ulk߽~B3>i. ܸzAx^N^#TEw1MMGN%ȩΝ`Hܶ[QLjnaR/nBg '|*yоKK^&c/V6qtܫEZg"=TPL\ɿHwx W'g A1Q)b+OM[5FX΢k^{9wp`=_JpctwH ;(!˞vkޞ@vd{ Wxc1uK>rP'3d$W J̃h9;z,sjؼkNeu߀>`΍T׫a*5Qd)2lf\tVsߠ4gl<;QvS%e5hqt5U]&6:Bz3[7,N]|;m-?EϛrbČ%5Jѳ.o^wk&6nՍj7hI:4djxAc+N (K(6E4QY=r\`:~ּTUV/[OmzO|jwV#ܟ<~FK^QKiP]KDn-iU?^J}q "}ǟ|jiQH#p}FGC VTL1yaoEB$Asn~`'bc@ @܇&T Sw[uȫ(xe2**҈XRoDZ :O ݹsG#e˖ %!=Mײ̄{Txy#0 QFJ_>"UJ_}JיB=wwF$WH}hw@Yt$0ITnsh+ kAKOւj,=h97!*\l ͟1FeSch[:#e̜Cַ"GN[k 𑇫DZG#3]iCTz}3jZ$.y cux:v6He+ҪBfw PœV4g :J_<{V?:#,k,*.[w : *WL˗0gvRr m!{q-~)yfB;c~]tGɔ)˗Խ{w:x _Fqځ2ȭ N"$1e(֭$!т9w'''kZjEvRM  i޼y> A"F5P;vL4qDCotր *U&:P֭aÆ2."+VMF>>>rc` z<ҝ jZFߵEJ<zK49e˙WæG>yf-?%2kͦZ[jXJL D66 Ach&`8`$" A.]Zz.\ qjɓ'fDtߘj^##0@@@EݻXöDʚWDXvs8CJl<[7L,mIEgumezo<$IDՅ:6/BiӫG׸TFq^h@;5_~HI4dA."DJ@GZl?EE_~2󦏖27K7U;>?Z~3@UDX;EPA?O?+b4}m^ZZuQqI{06VyhKת[MzYֵe@:  Qs m4NoC6@0kWl4m,6DGfXΙ#0Hq#T`ܹ* Gz+wo_Ebւ꺒IxqJOwn^f,}gG/'!pu+l8wFqBy>X,@NvS>Zꛗ WtywúĆW{?pw+m~ݠIdc}~{jJ0#y(S ]rEjϝ;Zlhq*߹s̯XbwE:xxÛ0K9'A&H%J$Տ?C%׫WOxcϟˀЧW3gN:spM"ETq :AӧpjReuwzk{&ܿ+3#kAQmu.zF&srɤ-V?\>t:9sYKZJjֶW*)ʧ/ް礴 Bib%?ڿ.7i))JuE_\Uyћ2i_6YɎ7E_<{*mr![a:6ZEl j&Uz7tdˑjxV ȵ͜<_ _F{OЊepDjώH\xMeW !;c2e͠~Pm cbU,!KmWɩVjLޱ>|0L!y#D.vJ ݪU+)Ҹqcrrr+V H@"CEo'O}i^(ۻwVҦMKUVUi[D }W2'HmC]%jho߾]E`6pWzԃ<Ӳ*ZБT>|-*06<< N P >ЦMZ ֫w&#+cF #TPTkKLJB$2!ryzpm\jknDhߴ =~xOYnj1dPF9q E]2_?c .dUӄ@F $>~ih[T:},-(wNِ8L^#ӧMv(~xlH{v$fO! bby_d& A[8fu;hM$G׀.}.#U-]7Gl<6[9<- |aì#,lti՛ԩeO<'ҥWDY/mzɝ/lO =3'dumIΊz%KTe`F "GJRD/Hf\zrO.'H_WWW3r//}m۶3fhYiNrAHaENc@?$AESNԠAIXcca4׳f*ƌ4h Yd<0*UrWזjբѣGK%Lm,lvwGo;vNUpr8Q3 uпހ/60/0z}G41#ҫ]n E8 Դ|HւxM ϓIQO.sPb킬O5=qdx)Q!ABzt\B 5jT>ޓ MU d@cm8w(unY*TB32vG5%J\+;~h-_0UMI+],j H]Coʖ#/={򐎉6hܺDhs# ^ =˿R5(_R.&U2{@uբR H}bŎIhl?vُel9Л7o阫t- :3y(ōz txP_|w/A;@IDAT$o<g}4<9>6֯LY F`~|\\\$tW777Fyʔ)UGԬ·xep[hڢ^'vܸqZ5 2Ù2eЛ+~Xy9}oʀYF^3f_Uz[wx+}eΜY )wwwj߾ t ggg9N>}tI"СP(!HM,ʕ+\ݚ)w/={V~&}ٲejJ/eQ ^5^d3_a^#08] ֓/jJF.9KPChġԂ>RvKrU԰+ݿ{Sf3u^ȵL 87~*Y*m3-Eߖ3OA+}~Ep( d +z[Aׯ_h.ɒp1ct5yukm~Vש0&BxXhs1" xԪ'|J0"#2Za:4H89vmK߽VVb *3 _ OA 7edw:woөMwtͽ“ݖ4dt?V۰*:Vnkp1#@PH Mrx#x'/!+ M[5Ɵ1[uJMKl^zas֬cǎ+(˗ӧǏSҤI)uԔ*U*I69$"Ac-OcSL2ϟOֺukedXQ- z,޽{kn<`(w$S( BED½L tH~fˈ&<jkI-;DI}{.f%?ohS޲]&ިy';nkY=^EHX^mʼnd4w(r1Kݠ%5jEzI<$'уZKOӄ}h㚅~aja"4iqבBEӎh@:~={j _*4ۇGCLߗQZ/'ٰQ@yOudp]M|f&޲bОJ"!S:[6.狖(L36*A{>@yfOupݸ|&͗Po[ZD<ц +[ 4O#lg,!e~R +}gЮ7<=q1#;\x15ʰ-[6;`w V~}M/*OOO\ :68U5A@{L0ޔ֐# pyD[q.ՊHofkw;֊#UOE!Rr"TCP_R~ Wl$OF+Ȇ"۷cl/a|,1S=FLa:'BnÅrDP{7u4ժo}dhH#xw`Ul]^v'v]-`+[l. k`#b+-6w9EagfϮy᜵|K8޽c9HP$ipC)K ?zLMǏw3z(dq?|J 3Qf4Y|"TZ`ɞMAU=d-,{י@Xlu5~-aڶiۺ9Tq#'K {{{\`і~##J]&89xZ֭,y0& ,]09Pg;DvGz!unnCWYھwo Qm &Bc Q`X-C{-,1]%"5): JאD-eFY9Untr;qEJ@"Юe9(zOa7Sn`QQD2G6kܸ1-X M@4$jLrۦqVX QU=?rDz={"?nvo[Ni10&@ M@H{w WfjKӉk(c!IQBڌ3& pdMy&yxxe%KʬÈCaZmez򥶊L c+hcC&;Y"^GR BhI5_HT3 ZTI~tdmmMHpN ">~(3Hk{yy+$@30e2… }`mp-PWtĐ<-YM=י%pyRJIGVP6h!Tg%nqe&`p;Ғ%KG.6Di) '3ի:vE!W\qY Mzʕr̭[SԩKr$ŋ<(M2&'ɭ=ZcY)sQԆ'7ӲCv& A"?b* $ŧ Q(fo$z@njԬBej޼Mcʓ/~>gцVϠC&.Q˩aj-eM``L `{8?Z8-[&G$K6mH"2ӧөSumɈ#3ŋ4tPyiӦ \bEmGzɥl K2fHpݛ9"ؐGI2ڶW^$DC|$H$ .t]rJu/]T:q}ᐼ&,̙3Gp3]v;v#ёƍ+-p#p_~]#bm۶r>ڵkE^/Wa UTjw59>}ȱ &.! |D7o\L ރ'Pe CuǾ\qty$&`L GSOY2R>cxc:8/-_UnҥfjQƵӔ0&@4&p~V"c}ٲe̙3Ky8kժ%%E,-- bpR޼yU;׭[Vcŋo߾ЍGvNa8Vh=Ptjc>pf+'5爤uޝ&O,u*pIF8(Q;P,SLrw[h\P*TH.&@FH(EDcA2>pϜ9SJ넶; {ٲN@̳^z X`DxGC4O8X699TNy`L 0&ttlۘ,3'=磯5C z! s7u&'# 0&> ܼ%KF5k֔"jNsDGFaDɒ%t-ZTF#~8@TiӦ =z4!aÆJu="=HD# ZE 8s)dɤp>H@Ƙao ´l!  ; k߾|jA͉3&@!x?&DCpCK1Ǘ:f2DCvDCƘ!!cA-[1h1ֿL}2; }hX S 6&&0elxZqШ+Y`L 0&@ ҤNIGڶ9bNJIjHztv 6эۍF#o$I˔)#6Gn{L 0& =1"ƫfpGTȠ@|׮]2Nw"MYy^~-]]]5Hp .YjԨ!U)Xܔ!r+{1ZQH?~yUoЃO.Ԙϐ!AVH@z갃ҳgs!+tߍb,#m:uH5d pڏ2DC;wЅ h߾}[8q0h>}ZCVbԠAt|CGϞ= uaѣԢE ,֬Y:YXhƚH{T41&8'^JYsAg|`L 0&BJԦHY2Bs6o<]AtБV=y$aCA Ε`L K83"t+U28~j8鏐lDOc QpCiӦU5qrh{yy/k8\JL:U:Qu8 fͪ:w֍f̘AgϞӿެY3vGҒPeѯα(w$U,4Ǯ$o3E$Jx19rPx",bډ7t ٖmn~kϓ紐rE?(H-O=g6lL 8uٳ@ q<g/^\*%M1@;'Lʨj~|G@1;ؘ`L #mX(P7p7}Gڷpo!'~JjcĈײeK?59ǏOO&_N<<"_ Џr/|Rݺu'! DJMgY}f,gggg 3&B^O5'$_M~W~cǎo_dL 0?1wȘ+]7c rD;C^XAI=?.#sMJROXnD Ƃfzp 24.V¹- n!)"1p" 5eиr劔AD"xipfdAי&p!T%Jl4-ӹ=uX;Gnk*XzL 0ظfAHB+Ov@#n&],ypߛw(poѤN3D`K) H 7޷mFo>Z|yDגoL 0&)wpg$ AD) WP!j&o)0HD'l!ж 8\ DBT 44dSZ%q 'MGXR%L -k{rl 0 KWܖ D*[]wN=)ODsOt naLf?&) ܸuO:lmmڸqEn1)r:wLh|Zj`L !͕_ `@ |C=5y"#$MNSgg{rM&`L 0HF[ua4g_vL޽{˷#٭t`LvL 4 DB^mH֊MvL י=+g4i3D#|L 0&`Q@LhӧOvi5Hʊ\iT@ɓ'1&@%lxf ؖbǎmt]3ڀ @4&p*k8P]=&`L 0&/^fϞ-[n|vۗ2d Ѕ\qlL 0&Op,r͙g"-#aիWׯ:F=ز1&8+OӴqJ%Vv|`L 0&*1cR:u[Z~{?uz˿~.M !ɪ@/6&{Q*T( ޾я?`҄Y8?{ 0&`L rH4)uAnݣ+WҪUD?~H...r{fͨy;wn0&@ψͣ1& ߵ=z*k`jʼ,yJ- 0&`L DYf#G;v)I$:7S?~<ɓ)B3gΤ/^&p<`L #đ}j;C'S"s>`L 0&`LL2pBBB 6P͚5 *ZpuޝҥKGj"WWW勶 3&@8`{8n`L Ns3Ǫ ԧ|`L 0&.رc=رC&[1c.\XwI:ujj׮?~t `L ;ǒ{bL 0P~]3fJ, EO܄ 0&`L DO)Snݺ͛4`ʐ!ӢElٲ%K>|8ݽ{W0&@ = &%߿SWqд aP͘`L 0&@&+W.7n=|8@-Z @y5gNJӛ7ot `L WVL 0&BE`>t)1)G.kܜ߿}{]S2[eWM@W;y9]KWA gz$e&Ws޾sv4uʌNۯs)e6ʕN0&ܿn^WN 5j>ܳӝ `eL%%ŌT5.gL Dk7UTInsΥ-[Њ+ϟ*SN6hCɉlll(VXj>`L 0`{YE_~ H}7P)(sTzu3`2vXZf,G Q ^~M={K.ѯ_b*Z(-_\=&&}7њe՛kę5j 0sPzڦ#M:a>|έj1a~7_>˾Xf oFB\5kݍ-2zs*7ε&]0I#4fD9 8tD}>9y|>͚݊@vuY+0&+xQӦMEWk׮H͛7-yH͛7ŋu 0&&E/^%KY֭[3gN 8۷ou>|V\_LОccL jx. FID9]=5iqv7eGwv8u40UHmz;l2!50s۾>| 0h@Q޼C[SIC鯿wη=4iP>}vxGN 7gAvQp# 0&'D۫H8^P!O'MGZҥKGɒ%ӿsnkk+u#G˗/u `Qϟg;{Gڧ-p%跇UPuc3'R5LfZ2U(q L^ϦT&|#Gd"_`L'Pݮ2*]Oz̛nI/ZJ/I6La 0&LߧLB'NKme;wА!ChСT\9|q%`Zpc|@xe 3d@ֲ4+\?>Aw vmpႌ2/_<s~"ϟ?/_ K*.\7emǫc`lFk(x\CĉW39"9XMPfw@^H[7,W۴ؗS#@++sxv{kߡpYN 31:W/ 9+ʑ;}( oߺJߡRuo Ym1'<(m̔5GLPyݼvҤHX0^H ݻsCIni?s Kpϝr(wbq2UZʒ=7%K2)3'sIR->y>y@o^x R({|FF@3CYN_%>/rQDҤ rL"@u'g[7۴\XD̋`L &LHZǏiժUR]>֭| M49yyL ;Ѡdڵt"dYiلb9884-,,{RftcƌSNt" (@v2/Jpoߞ6mDKk ]6-\?x`*7Nʾ(h?...JrNJ6ZC6hv|9~Y>I-Z9'MD10&&,Xu7&\4ֹVVp~^> +cPU+'SB J(` +M&Z$ɨqԡET+iEpn?E v+{uh$drosuZZEM_:N1cR]F'K.V}6y 9puhSC;hZ2޼/>-Q&Gl21~4r^Gjp%9?8gҹW5& =B^2R`|{dM){39{:{0IZ>~bS۞ԩ0#S j mLԬM7^7r743Ľ*;]p?:5Ci*}^t ?Fu^ߩS5;Iu&'L XZeRGϽx)ZL ,.]Iw=>Kժdwϼ^Sk֨ {پl"&u|7Vz|h摹;&BKޞsׅ!ڱ!;C,jry"ab6d`oPY:?}45]RD4?TSjѰ[,,9twg>mj:8̉CuϾܱVqe;7\~lĮ-kv&؊Wʴ{DvdA4$)CSv u%s'ЌC ڬ\2C.|s2X&M3h(Dϧَߡ֍*ӓ}+v"'u>&㠋׃-MѝYWmz(S3p4AceDžK7M ,Q8>٢&E`gϞt4h (sk׏G`ʕ+ӧO:u 0& =0u^~ҥe9Xpײ`;w&Ϝ9S㟛7ohuDV@/ g$.A%Jz޽#H@F֨Q#Cj#?Hvh֯_/3fDլYSF#2X=zTi"666t);w%K#KNN8Azљf0`e˖^xAڵ3È` 0DD_?y!믿hajtP8~긻 'N\PZty>C&=hہk2<"[ѿ.@"!,O[ݯD##l,"u> 7 YuY0`SrHZyH+#zMd9s94(X6ŋ@BH@m37q05Y QgM._N4|^v#hɺ9)"U4oNuą7ETz #zUjԣi ]'Ե(U !3ȷ2q3\hω{sOz.V @yM_J@Ʀ#9$ps&|ָçJc!Hڶ(vj[vǦ6m߯^r_\VZ3*R^nO=˙ |xs:ϟ?> 7$NNNR820&D1I sFBP8l٢F1uVm{Ȗ-!7xƍdL0D)ޭ[7JxDxðiN@xj!s3Aee*kNZ*FhC(^~DX4"XĨ"xm߸BF߽;V:y ,]zVݨyCo\ \7u#WD['PK+lZ{[tnL33֍%R /rݜ^,Ro1NiK:vʼn;OPde~N~b[wogӶ}jCqhԩ#~w(mx=pfABFߠl0E*FNpSL)Wo߾h[F  ^d98OeecLEn=2@ 2HlPD$2uiJp0bS'hhG'Klw|WR:: ( bHAtr8qelKoX5fXX@޿ z`1:ebW';tˑ ΊE-떉2Q) A2ǘk"⛤Lp6ٮeƮyZQ{& +(-*FU&ʞ+[d: 1Ycw$Tv3@Q ")lydWщztv10IIU+ZvQ| h?ȁ-qReF`7`F*jժ^~!j۶F3sZԂGrEeXX & {༶̒Cl9|;%`1@k1bĠ I{s01$ DZUm0L~9}=%MXRsdLC:}GɌ+ǀ&3M05٘/D{)R] 9zjz8ir˜9={hϏ0&`{>?R6mW^mgϞɌ*_?ٳR28ULVZ={coooY.]*D;D*1w-ՕlH6 e1^Sڡ> 1pPQhGhaQo ԪUKri ) D>A7lR0Jp#2~eX̚5kPL^?~h-E :;/wKo9%8fK3=峲#J!uQ8~zH%9~R'BZN{8cjҩ7sfRv+oA7^ $ܻcyeW.V`7݅6[H6{َd#&, k/֘gaa6k7.p3/seL DZY;Ԥ6YN N W*S0YNX\liԃEFQj"OXLyMuׯU6E%O|iÖ=496ۅ uXnM ̙AnÇK;rׁo@ wGG v)Rm&"h.Qz*qA+p4+0aB}*b/_.{Ǘǂ[_c߭Z*;H=lZYNZmg(xFkp+wD](SY{Y=&>84Y )w.7fpʡ:ܯ ')ͫW\:IQ3& ]Uՠ475֙^׾%UioP7ea-B'nFM^L)RRϕScg˙OuoZ c(}bv|jh{H86 8ۓ'iTb)>p'+ uB[4Sz$围yx8}l Xgزeٿ ]>}Zn2ow&<`L థz"&|5khSlt&M*#JJ #+pk pA; NyyHƄ[rE"G)#H"z|dFrf娯ֱ'O`oiiI]t .rbccC0dȐ9ہG:uPEԄqNePuY )dMF3hZ-۹e5Ionߠ+ Q;H>zHoH]9ՠ:΂cXh@w'ޯmY,v hW:V(r2ϟ=UH`n^eF޹uqtWl_O7Tq(XL͇˙`Qdew~VNivw8_l+G<#u1li?!_DAڻem]lWu3@b&Mz ng# ܘdIbeȮ^ڵe acU{,[EΝ:L&>]H+X߽IVݰjo9shIqŗN?(8݄K5R8"k.}FR|l /ݢ}/8,V)\,]8sL&KXnBjMkSe ݛr :Z3zYJK %NT !)=H^Ys?4 ٜr(aĔ@Q*]:8Wʮ R$_]A~zӑ8]K|j2']idBݎ~b ym q-  ϼ^Н{mڵ?dl'[nW^3Ry-[l2nt5,R;>|D/_V}E5!1H ߼yS6y]Hr]&e =>ڀ6hiӦ%llL ޽6mZ@a0 *D_9_DE"AZjv ec?|*s|iƪQ4rB׌6jցV,&eSlb9rzmW"tmIMuj`tnF{hzf:kZuiqR $ }"*r|K5JgIs֐7:v2F AXѷ42:+Oha/+S筗Lʂ bX+-R]Kg|b%Lwvww3r {>|8-[V:EĿk>.  퐟ʛ7xzz ECy@$wuu&РA*#TylL Z !ܹsGRHw^)Wؘ`I !;wՔ<D;"VVF"dS =N&8k-qdԡPZt_7u;NAzhe佩]2>OM[u5*H:ȬSjPGKf?AD4o.*/" :]Gos|ް3 =o9rY˟{.|$YKȶncy͉WSCԤ?n:3 >aL DAZY{ӏ?hNwRbICY23_4|.אzH^ Ҿ[D׫YrVSŲ4- D,8W.y{{Ӳeˤ̮VG%ggg)mvըnp#v1{nxk[5"NZ$IX>`,)n?F"*_nyeϞ]ʼvQ 0&Љɏ?s~g"{kH}I.\mɒ%e )#,@8Κ5J n:q˗)=U!'N)CNBmfϟ?Ź">f̘:e'W^ǧx۷oKiҤ! wpFT?.ބ07Aa\51,Hv0 o _cHop##(CrhF HwnMBppF'K2z->cq۟bЃfʲdEmpz+XLnF~ ђirMCFYe5=?y){&@d#/+hFt<C}=ɓN/msxXH5Y2g HaPېGtL8pܐ+wkH:c )6m*sk:pO:&N(~gNe8 n6m$ @1cPfÇ.͏qMm۶QbիW˷Q=z lZ,Q[L]v EaYS܋C"\$Eb o(h2b2eΛ XP@Г?{Ae.y E%e"HR3)!v5tĥ1& 8qJ(!# .7dԀ^Uӵ.siUjd9*V`#PpI}ֺ!HwoiH6Y|$c&0?̆-{_r P i?/+ݨRT˜1MGhZ:)>2(Gk[,cV߮ݸCD_s&@ucoNqƍR*UȄQڡ;~moF+W 8lGGYf7#Dk+xHFuj:9sٮ_9B:Q quХW z &|媳m~)9pV+-ؘ`IX? _uF-I,kKZB$y"MWD9BG6&NZwUKgJξoie"$X"jiˍ"pL 0&`@-;VLtf$M_oԢI])PvU٢tB">y` AqE$98bў&MLуGKH=oҍF Jysg9ڽ(8OժG'/]3ERʄFB&; sI iD?~\/Xv 2De˦^pEަM)v8O:~Y/^Lڵ2D9r$*UJéhn, ;={TsEd֭[e@H̜9S}":ŋ4tPy QњUXQ[$~F0D`8A}r &K,dʕH ƍsVO^&Ţ ,,HL b"cL 0O`Խ{w5"9+Wzꩉtp7ʫu!Q/Tm rwn]إ^& @SZl G+|Gw:]Da ip ̙3s!`24/ƁzAnݺ|, jJ+uՏӧN rǶpTnmX_)STefxNu|7\q3Jy-JGVFf &BCӧOm6) .yFjc>`! 2!U`Lhu5F:S9Z-;Sлӹ*WLw Y 0&`L 0&@>mڴR'>N8RSSf1l+[|9rq^!#өS'y ABs*Ec{NPaNNN"9AGƆ~Ct:&LLP\ 0&={Vj|R ^=g_CXhWJĸgL 0&`L 0?rg/^,%}Z!RL2:u\=6!Μ9"N=zӧO Z $LƜayF:& ,) H\ 0&YGzTg;>СCeZ `W 5l.cqL 0&`L 0?KN:]^وXG仾 6F>.8F-$v8qgŊR;s8ʑB\{2w\jѢזNz8^j;idc%MT:^R%U{.-Z:wLvvvRPhQvʅLՄ_VA ޘٳg&Mի51RΑ' 'ϟdee%p>Ǡ~I)GStiJ(QpƑ3fܹsNv @rfǎ䲈7fa}F2&_B%e 0& @KЫS ~vmօFo1&<(vS_x/D✍ 0&U1H7r[S 0&H&G-W\Q$LWai>}z l:`{rL 0p#[[.) p0Pݘ&ҵkWG/AԽL 0(A`>M,0թAK7@`IW c&mpc:v `LwW\!ooos|H@"*H<`L  邤0xO1D: =fAA`L \:v(٣I̘1 kNk+Wx?`L 0&gjڦ;x9BMi 0?accKDs`L &ϟGDh׮]3gڵk瀈zdz1&`L 0@ ^aTrlhKER߾?览hܱvd5`L D1(`߿WZN>]tikkk,Ν;G}UT 6L=&`L DE6VD z2:eN@ϼ^\[2ŊKOKo.3Ze#юYnEE 37&`;ǀ 0& ׯOTg7o^rssӫeuo߾!ҦM+#',٘`L 0& 8㰅G(ed6Fߤ|V'8;u*szja}96C5o!e`L xXR&x`L>}Jeʔq#leѣGbĈAׯ' +w`L 0Npoؼ'ird&ML]/B 0& D?&@Oe˖%OOOfiŊ]ʈ0H،5JnݺԳgO`L 0& :s> 2|/H s?徖ʗ.Y~Z4QKn`L EAL 03X|9ّZ .Ǜqz5nܘ? ˒% a^lL 0&#oOv.w?)mLVֻ'mN.P?U ۴q^:rl|x&nC.\#_ρ\"嫷dj:|,\P8ur^M Xbъi΁6\t'OOi?)[A*[-ZJ}Щ'L 0&C Fp*q&=8۷oOK.U;I:5ڵ *EA~رcPf͢ u~_h05F1)u !%Nh^t'IF%V1Z/ Osa +K)S1޿C޸l/0˒=7eF9ËI(aeUlꅱg_q<}bǎCr4 [ g#D7$u{5Y"UJ*VprE&)WɭЙ&>$RLNU*Թ{jҦ/q?>~]{R1޶n)נ zzSy'zo=u %ݷnߧF _6u?߹ho?WѸ=WזU=Sf gXmHx*S:aÅ=eqC ϶TR)9MъK,\(vEֵcWסUJSBQ 0&L&@ @:ޞݫ+W.rssL2equV6m:T֭m۶yx Պ>}:8TR:N.Hܼ~tj,c-"}At99˷STv =&dS|e[jաor y p"]8chaGA=Zһ:Ґs> 2>| MuIC$ID,̉sԧ`YVrp_sOn\E~(rFe5EC̒D}#Q m):wdٞ7WV;̟<}NsNg_SI Fz֤T˦丹*e`CFϔ{6ԧ[kJe YC҉Z5j`4{9UǍO#'̈́L i^nF,|(6uJ\<"@sH\V .}0-x>M[P=`L D-3.j1aL Vzrt8?qD;=<aTE{]7$oOM{V*IWL^܉ŧ2% co5; ғ:{Tjzj-5[95ެ$p%>vV@0Ք":YZ_LutBܫRerk;iKkF`S #0@x"-[ݻQ͝;WH7yAۻ'RHR_|/ +]r+⫩B>-tMyOƴt1_eCcF@U٧O֍t%ytڷD\TQkҌV.!_p "khco^Sο-k$LOݧR̃-gܶ-e EʨCއPV,IlBGbt-M9َФY Mx^鸱cRbe:@g4r,_&d lo<}-Z+Ӥ>`ӓիGEIW{|`F 2!^HFXh*Uَ%n5jT gϞWR}gO|*nݰ. ϟ>ѹGit!z=i(QѸ+Aӎӳ'~c1bls=~xvm]K{vW ]Bp^h+t F '~BG~ Gvcкㇲ;)4Kܿ{I,&=]tW3> E[vӍkl~^pci]+;Z.8F*A׍k҉Dk}gkU\ .ի\.ttsJ9: Zzkqٮ쵅gRQU^-?cR$;Pvd>R,F^ ^5-6ʀVM`uMذagY mDÛۇjŋKݻӥK̋1#0@(@=CM!2@ 0bڵ ><-^*V40kԦM7o^:t>vՄQW3Vx(e.k{:Bh7!lQ/M Ligv$to!z#⥫P޼bt܄V/%*M]2fY1/qi9L8,5:}o߼*t(ITTq[ՠϨhE[-*%|A$lrn$@dSdoo8qPP::l5o2a 9CPxAxԳoLncڶ@+C۞"^yeց[y}qDo/(Q:#nɼ ӷ>Ӂݛi@74IsD {Qv!mcn 咥HBգk#K  䌘 O=g@ 4k k,w1:">} O0?S ]e?]3qt=uD@DZ2ōG׷g~jX7W0{iY&>s. B FBǼ۴^zCv2=z_x'KN1N"I|&#&UukV}FI=c'ꇳIiZ|<Ɩ#G)9SfM+1# 70^7oN]td;~L޽;wIO?J0cƌI˖-ݼnRk͡j%ұC5*ysKQfEuxХ|ydtUTR>:+j[ \ѢǤYv َDV! cn^6'>~Є @9LV Նh36+XRWu 6&ܠɜ-M%Zj3u/u?}@]u? {&d;]fry6Ѳaڲ~ َv{e(AQGƆxzjRG]ZױH:wƝ﫯p*7BvCy/L z*{x#0+<͍%} ^H,ޝylXHdn(g$QhyRx<9x َEQ5* D(hZ~2 l )'ŖC'w+ &pی7oiEWKDB,?_t!ytAS2/KƴɆuiԩSv}>qmۖǏO*U&]e,F`!ÒkbP"ƍSJE7o)R輠N4nܘ]K… )aBݦGjsY,Az UZL2fo.Ҫų$aMxTؙ2fMrhBv>tգ:b@hYtq)MӲAvEIq?cv2NK2=ȼ'vm[Zt!HDNKwS" ! ~- ۹e5s;7{ǣL=_on"I9r%dn̛$=11s0j"<܅*S GS~æPLkeW}aS)fDXQjmʜ5!X/&&/7} 5kۓ"E"wz!,q%Z.!(s@g[C:eղx^\Z>u:SiGW^>aTst_}ǵ6^QF2MiHQ^0{)Ey.u%"rxQ(ͻQTiRôp2MϜ2O>HڻR)svcf.+6HfFt6.3f@3M]l٨}hqKUИPEQꪯݸn_F8.@rC`ՋWnȢG}Y/\^hYχp?| ݾ+ݿe3߿4ްSۿK3Xn$aJ|D)OyRd= 5 dk'0#.iԅ|dR@l4FXD0^B_Yx uT\1Ű 4~iϽZ<8} ,Zč{W9g gv{ b OY3ȴ σO.=!I|6jW/gounQ+]۵k'˗/K]w8@fF=3t@׭['@]{F`@%e>q/Fz*AHWZvd#G[n-={K\eM[e%ٹGC]Ŀ*?^6a '!Czdz,wBܚAEM*$${lG^ UL`Ti5!e׫vSy;,/PIŭl VP)ś^5v}6ݥn>0O4$`-Zܫ!@+Zδ"Pm r+!+u Gyl4j/ݼb~K~h,}نc{_9AtY !1I٘hp9Q+u-0a9zmyn"'Jy!{d.}#sMvnwXAJ WiSXL?._W;;pD(>Ǘ.^5I֮%wo>%S26ϒ>g^-& [2x?z޽{/b(䑓= f챩QZm-YUzU+x.02 IiS?I6sΐ~(l:nX27䚐$'c20+TxqArʕRrf׮]&qjOؠ^bE^T)_$VlF`A w Fp/_.=ST#x5joo*FuKU j7^J^b^҄>T(߲-8WvsˇTI1:F[8k3!}c~`_<NgYMc Ego߾EpoN_x&u!="`* 3ޱ܍CS/U c񳠍'!Ycɔs9z'w0V/imJ9Yc wF CR:>߸V 1 ޱwmkCQl7[,R5K[|ܸvKWۢmQW Aj{f>CbR3XIԵ(`{rH֒iuGlԼ}qBE? 34yL_,訥rDGOxOG*-hn{}$҂ $~o)t@IDAT?=;vl]&k֬n;n8#0 &C2C;:v쨗2\Z5ui߶m qGcxS_:I5#Y/3W}.կչ,cA*(zvVl>IaD@c& eF1cэ'\J&RG/E6;b5дW](3$psx!CIײ1#&L}^1 !xO0A AQAR۠9x` OOOjӦ>vDĈ>P?)a޿{S-%9e")-*Ϟg͏ޞZL»9IbIcR|؎&S$O,7ۯ X Ovgx[ A#`$ dϞqf}"Ng] ^ wNŊ{*UD 'F`&܃pF\¹fw&NP_с=[ԡ ̽d^ -y]wnUΞ:"oE½Q? U y򳧌U(c}g&ݿks]%<+{5IL*?sLzރP27 hSNO~J/ϞikgAes/j^c`=[:w5[Fց*V 5ӗޫv֬5Ax^z#ekrgY3C[@@P*۷tR~A]t AX5 1+`90"M ]fF 0@ҢElϙ3'>|\lGpի E SH 3&UK|& 2foǣ,;Kmqㅐ=$ӤL3ei36on'd;٢U^CXU5KHGJż {1&\d:wIns08e ]zl}N%0V*R.M`eF ae*ִ0Q5ΟBEpSs9i*T؇{ ~O,7/ǁ ?ݯl4g#cV oL%dtcNa {ԙZh:Cv[x._;VLJڭk>rsvOu X%ZBw[pyBPU6F $0%Tv="(w -8eQDMҁ͛Էo_J4niܹ=I$eFNW0#`n\\`B 7nܠ2eeM-SjߩS'I&MD3z* gE7[ V{y.K>IQ5A:#-ErTAK}ZxW4A CkA#fʵ(~/ꑃKd9OW}kxeO3@d^O?Pu9^?}TrTfcu(r}GS^ {+]Lj-5"H&V072j(ƣqB:badUa/֦ʖӃ "z)tnY&NYteBWF| yy]J޿L7hQ;)":蕼HBYȑ1Fg9iߤ6e_L[lwX¹TPLDE~6B}uvSmjjnXlfA͙%VRJecRky=լP֡/ݾuJ-&VUDNЊk| 3AictmTu֚~͒=xL.5iPU"vXMԏ<?~#0#GN9޷lْƏ ъ+L4ҰaMkϟ(qS j#Ih'ס۟or*w"Ԫc_Ih\`L DBdVSH gM.e2|z )!$\2=ăW!iNQ@Nw3E,Iwo֗A>}lplӸԸ{ -^ڥ(9qb}DUaɟ: {IRRf&N@Ld^GM굡B[F,6GvdD(nݸ#ٽ}a-Ų+LFMU$OĄS(lVĺ '+`[l1Yy '8Ar|6l`;70@h@gch-`| dd9?&N2dשqc,Yиq럎,K.ZVl9e5mhƍM!$$23kr΃[в s)g7RæuhՖ³> 9N&nص\#BLkZ2whycV"./gCńZMhpTV%&龀<"W};e3u %HyOOO7.5oޜ:H=jF`‹ h9/\@2&H: Xvڴp€V1 0aj߾Coa|`ɓΝ;']Ǔ'OrtVCEAIj\ܼ~ QُҋO(Q"X^*b99G?aRRؠ;~ܿs^9'ESBLkޢkb,~ /U$Ƀs&hc+ {gw(F8?#|^|E"(Qpb +W.]OSDMr1-8V{w(Y$&#jW3ň*cUsޚ[A{ Q211sVKE8q.S|RAX y:p\2eh߾}/^. ژx rرcҥK<(q1F`F`FLŋĉԶm[4Xgt֌30#?L`~T͛^GӺuDƈ:U5"h,°,t?~|W`F`F`ٳӸqd:އ<==)lذ&pA2QDTdIZ`}Ѥ  U*U 2-w>'L~ZSHF܂ T??\o!;ag2@M 4hbFpEG]BcS>}\4|pZz۠AhѢ#0#0#8VVPAno޼2ͣ?ھ}ZhAժU25 6хXL^(9JڽҥK:[lСIs3Sǎ\-{wʙdh wGFm:u*jՊ?ӌ3DWnz쩻ɛnݺcN0#0#0#lFJM6VΟ?_nnM^a;w|[.իWbaa=x\r%]~ݡ19sfY쏵'MD X_|Iϟ?{Z++ߑk}U3 +g>!:mxL; J`\޽{UXb.mh&۷o'K7/woo^E%TeF`F`\ )RP~ x/_ߧ!C-GҡVZ3fLMtn˗/4fǙ3g쪣@ +l5GRΝr3R_` Fg`Eׯo~Ց ҦM\ѰTvRG &Q=ztW.Ο>F};7a4#0#0k#A&L %S@oٲE; SNק҅HLuI9tʔ) $?b]g\gza۷oSB%Y0%JPpk^9` o>}DXI`4˹Kڙ8˗/K qR֬Y)Fpf1Ӟ>WrCpC,$Ib2E=".I#0.J.mBgʔ9d;իܹS=vXʕ+> kآ #~1#0#0zyyÇlٲ AXŋG|iA{Μ9R:uI'O.WU=vܙDBcǖ›ҥ=zPԩfŊ R/}yy< E-0M6&}P.RY8 }VxƍGO>UY&{\~1|k<|0ne7Fwy楋/Q3ێDוR?lD-,mڴ4}@j lfMA{vl0ᮡ#0#0@D C 4l0I*o߾]zGd7nܐ Am3fPƍ K8q$y9:{,M6Ǐ/ߡ\3= ׮^P2xc\xdjQkk-(ΘQr1E%LR(-}L,CBk 5p H"qb\mw, Ϥ_90a7E3͚5A{unxCodԩS)}mh|pF#$t c10#>~ `q^mO@zh}*"S^a,pd)Cs1F`B6Մ{"%(M,!k<F X>}$܃yx+z*AŒ]|Yg@GՕ9!J*IJ2;|x(RdrLPR3 Z?UZM $aFUL4ٌd;"/\P{2J_ɓll}%1wo^׌#0#0@0#vxhuoA oÇ"Qk pejѣKac *Pŭԅ;f@ʪTB?CWxΘvƺmM^UԩeHaBkgk^1[9 }F…|hnp<\sPsٖgҼ=>p{[`D`% Ï &P-W5kB`T,aӧ޾4{훩ϏcJϖ>,cF`A=AeG=(0K ?0޺# ~5 vaq#xzgՀ .]"/@:!&K =-OD# OX K,*PjР&Oc~K.L1@`7Fƒ;f;& F&VYhT wcF`F`F`F^p1.0Azi&&M]t޽{v"u{7C`„t}0޾!rTl]F`F`F`Fj+R\`Dylϟ??>|vf͚[ b`޼yLvFϧjR(Qldom*˅F`F`F`F=`wokF D# }=NOOO?̭3 I a|r5h (ѢSir=rN@ׯvE{'F|}wPkK36ɔI*Kufދ'3pl)u5SJF`F`;`(#>ʕ+ׯuc۷ѣGGx r2&L@ٳgWOݣX\&e-f,:up+ye<*@HAF;0Y J%;5ҋRo*p)l˽ 1 aF`F`,)=#;K.%Kj7ƌd;9RZn]jҤ>DBέz@ZIkӎ[iȜ%Tf==qT 'B1nߤQbyh%:ctXsK#0#0{30..]Ƞ/B ,UD۷Az<2dS[ wn\2S_T:1r\#0#0#NlBiϟ>s)W^#j 8ܸxݻCq$)RܧK@0GbB q|U6}NJM DLISM0#0#p={6ǥ~ a6nH>$x1)ϟ? *ѣGܹstcŊ-ӧn{F!E ԋ'y*Ӝ`(n"8k' },ftj֣E24 Ǐпρ٢-yR!1K;Z6/)w>uyu0OW?;b,2lHjTE4uϵ4C v?@ !:cfUdoXL.vW̔߻+[:3ܾvlI/fF`F`F ؃~^MO?Dqu&Lhrx- 5@FR.HWTvdŋyso_\rш#B߼^o1bDZJ1V@@عfmX<7 5^M|r70'BwYN 礳Gj2W 46ne[lͺ;z?"r׺U\uگ%=ʙS3CuV"c0Wmڱdʷx%)!;i&LwFm٠K*W8/?Ӹ>]$NgTruI~>}D+Mݤ}~.Oex:sZ9k E"ː-'%I޸&w[I5id9 vx+W|m(Jtd6Z;o]:up:T@kݢ"j˙{07|(+($L$%}TG< ]GMQ=25贳gU+)hèHŪaS4ep!t^>k_ F`GXp![29sPΜ9׵{!Cdɒц >). FTpE,M^]zU6jԨ/%*8,K,m6޿/wxTMBXjթS> BbrذaԹsg'iHLMcX}\aS*X"UΒ_۩ uaE7Ą5̍MR>%T͐"dw,Y(_QL>Cg}`]@(VneZIXAQ~BJ [V,NsW\PYuN0#0E`Сt_+'-_'Ș6mmݺU`әn3gСCNwkծ_}sKB_ $hVbEM.8wU"/׉'XO;@"0n8ҟaŋC%KhL2!Ƞb5Cv!w< E4{Pzi1߾z%[xtL;E_Mv"n%5k3fcWS)#cݥٳիYY#‰ЎV~ԫWON),2RiӦUYn%1ᵯ?Ǐ-Z/n{G︒H__X@ub3Кi;ϞqBvEwp&YC ok߽1,UDǜ1{5ͯK&y -X3vB2. ;eZ!6fzNmca%rq1J&Tm'-M|6F`F@!K.͛7cy楟T%=. FG CǨu~?㘁G? g˗/KƍKYfW3ru9a2eJʑ#E|}b?{,7+ "DjV3byUqؿd0UJԁ&DTj9L|39.umZO'6~%3l\C3y1cF`Љux>pe4!w@";˰JSNRΞ"E 5j|6?ڭ[7 k!dQA` Rx5 UR˖-Md^p:9gDjī}hQD)SP͚5Rᰁt7Uٲe2hdʕԥKuIvSټyM6`G uWN&L`~A{#܁!>gϦ$6/1hR}A@">/XŤ#DR^S5i 6p@9ɦƂ`WɔEXaHr\>sW+pihX=$l'O^'IZëyDDBVL)9z)W^,3MAzFٓޓظ|3np0#P-%( xM7F 48bX2xكݿ?ʕR$-Ѽk. G;H#+/U91B$2̑>#6-2(Op#I8١\Bʕ2xg7#IlUݻw% l0ϋ2`6duhwsN9믿@% w@Y ,رF3| 3Dd$SvmY=hQc0`cǏS7GӦM̺u?>PVJ` T}}!`o/PB5-X>{X߃7xld$bԝ~g94#}1cLu?vX^િm de@mX^\:&Y8HG=d <.ٸ6?~Dv2ڛp7E/x-&MdJWϞ"X-<5!(XXuM*5;8}3]:u\f!۽U>]i̹ϔY5|0# 9 RbqR*Nd OǎK{p.MQ7ڀv4i&LGoRd5]ݮ|Q=wܡɓ'KWL4h@2Ϙ1di۶r64cu$DR~ȑTbEyNUvq=dsqđѣG uCO8BFxG̷ӡCN {>=9,Y"%v0;c^Ee wۨQ#r3V_~=l|A`ҳg ib 0,S?B y "^ζ2oWHf$Oq)a|\B g}THw?y rsg~lT>X(-Z< mnȅ/E?RWyk)3d$l7.=ZlRzl S4fǁQE1?j] |>OӆxO#@jE֮?F\Xӌ#0 /lذΖb ^Bi,Y2LS7SxLC1~ I&֮]AX-Zv*%r0Y`I ,(bUwĉjܹrIXmn35p|~bb/۾};mڴIAyH܄ N#F$ҥKKދߎΟ? h(({ʕe/^^zI.'b?*]VxzzJ1cv֭Uw\p× رl,H@N>]fhͳ̔cc? |nkEJ`|ԨQC{+Zrl 6jizd]h[7hq~{U@l鴿hղx}_]/(o=kF>7r4Q}a\M U1we sk?ۀ74K{RRI‰#4w]]ʞZYcѕps?T)Z4^I}k>9 H u[M<5(sM>&`s, _0#"q RK>vo߾RL{[:'jXdY Hwx[3 -wF-k-رcYљX… Rߖa<޳g>lWF@IDAT΁s e p l71bAl<#&܍G w8uT>0<`f۠_BHDЎݻÁjk3C9p>~\!X [C`zЅVCV#`czt_E|{tammld$N:O:y{ݸYUkPi r#0@@`Rϟݻ:BYv.mԞƍKLd x3g,5¡c,Y&}A]P1G  ʌ:*O퍒8778AƒA:=>|h8nAA[xBP*U<(!yV4A|6l(? ,²&Y},Rmc }KȮmzJiN0Aϓ1:=pj1)mlrEׂ"m4߻B{Hǖt"a JManSh[ rRksI>oaZMLMfmν(b&pԆ {1J xp/c,ռdzq ;.5bPb<#U6Z-cF`B9 8tP! m~ꝈҤI >PJ1A NF-gXKƋigSL/n-:綔ѕZI{]իW:6(˚5J=&p s.=aJǼ 6nAB@{p22Ep#eO&eiBV6F #K&fAǏ[ѝBxďPM6xN> 51zlAC'*<"%£;׮g/\~ s{qzۙ%@7.OI2RVyٱt^y*G-+@K~ @xË:|ĈQK흉sTV`K )lX@ϪE*T!lX ]z!%HMXUx0#(o^0ol@z 3?<ӡ9V[iǠ-;v)RУGI?֭[t7>Ԍb{ f0s _`Xy6F #Я_?߿2eG0f8{l=,혌 -/,M:Zv[hqz@4u>7Tx%U͖މC7iekq.0‰1[$1gB$+BDe˖W 7 اLo7@#%xe $ʳ׼* /H(tki&q쇁Im$׭mdU>ád_ oߖ< b vV _ֹsg8)IL/v؄s#cϞ= *lnGq#ؿƙ5C59eA7߬#M~D[7o\hѢvb2kflGy6~ C{Fd!{`"=&FiL.]r3?I ӧ놻k,[`$@$#S (FGg\T˗k|vC (8C P`x)8bЃGT7@,VNH}C:ꂲ^Bdw٨axQv+j(E ``C֟wL.^I:=0+ 'D/L$/bM¬DYft$& &ag;`K93.~{, >M^y.̯'lN8!~ ,"_Mⱊ›Ц? ASVC#   ȘM+_v&$K#é/3@;b?vq+T ] Hk;7o bv6O/z`c;wְ2x]W^ݻwNB r g@ KxO7UT;D#m K>C>aP͚5ݗ2< /LgO 7iwS H#SNiySeM!%=G{ @!MycDa  n8|pA{ｧ/A*[n:0믛ъ kL8Zf6P _`\uU?~LG0фYɓ'{' oVĜ(gka* l=Dվ2C3jli7VLY;HHHHH 1*TH%>rq^8l-Z "Wz}^H =s1>^zɫ dϛ7OW 'tݵΝ;?_z)mpI1:4_xc^pc V2դ8bǀK2LpB;SjG_p3.]SN B "MZGlxsDMcUo{饗EL628y} w֩GT;/AhRJ VqTZUs@zڵ˰aM{;voVB9m۸^+]0q]OƾP{ DggL;2RU $#p?G Kk#*d(9\IȡҠ>3" @rP mׯw."G=/(, N93Pꮩr*i}]95ous'p7h+lMEČnVIl~߾}MLA] auϟ/G>'zZ)k3VV %!3,W\z+_~9ajŊӵ-VN$@$@$@$@$@$~Mc%KڌlgZW2a k.2"6b5v")+>bAuJ lMNBѐ@R' nMOT wܹH>^n֬ @P1: IHHHHH $M{=-[Dmi6ՑJ@"Z1yq2dA=p:XBn.@ZFNelk1ee&j[n3fڰTgŹw}W& /Ԛ%J|zt0&H b"i!TX1}/DZc]vK/To_p;b02z O0cC^r     `،i&lRxb!Sz!ŋk֬)K,lhvy'YjvX#J9XCD*{1>|xŠw}vݾ GҥKi#y%a^+0& R38,0LISmڴIGá@cǽ)(ѣGKΝpz-?=g `r Ӱs=WMXޔx N: 78YAK O}e=d ~;蠑 @8=%   wj̏3@u6"ͫC/"ׯJѤ/UӁ!ĉt'"u{{Eo7$xL1 S IHHHHH > PR&>{M$^xANjs4H5jdϙ M7(}{U44H/05Ȳ^     >:ܣϜ- D %מ3Ao@Yy&@{Y :cQ#$@"g|)]%\"^k#I,ga޼yvP͌E&H B~_mm(      $@{\>6vHl*۶m[ٹsΒ5kVCU*TȞ3AA:IHHHHH q2 @C.]jkCd{ 9$,~;d|dMlqݲ(      %@{>:vH&M$F0u&ڵL@Bbɒ%6;D`r)]{֬YL2%     :ܣE DڵkSN+B^|E{ dN>@JJ*i)μ$fn9rI̙\ :cy7$@A8vvmrQ]"o޼2ydɖ-[50 xptMMSi$+gSHHHHHH Jph6C$Y;w_~EW Dm% z|v(HGt#\VM$@$@$@$@$@D fIB'0rHym:H-&B 0|9x.={viذa i$@$@$@$@$@$p> X˖-={s8Fy{ B-'Ӹqcə3g(հ MM6*Ti&HHHHHHsH:o]ਂac>@2eʔt,8={E6 MzD2eҫ)K$@$@$@$@$@$EtG6"8rw֭[u%p^`+eIP֭['p~kҤIHF-'S\9NiVL$@$@$@$@$@%@{ty5  2Dܲ8_~ %~_UVM/~&S$N+S+HHHHHH p6qG$f| 0kٲQ'A BnM=W\Zy143f4jԈvK        P *9#H=X=vX)W=g"EN9HQe=$@$@$@$@$@$@$pOѓ@Lxd̘1O?nڞ3A"m6YviӦ6 JPɱ @D ҥK[gڵ=6M7 6m{.]ڞ3A$@$@$@$@$@$@$@=Tr,G$1GVZu^xL lyHHHHHH F{$@J`ҫW/Fƍe HrDgʔ)=[gɒ%H)9ox={jժɼyRz~/Z`qtCu7^UHHHHHH pO,f%?SZn-'NЕ"uĉr\x9ʬɛp7m9Ӯ#׬Y#OUJ2eR}l Fv!q dpCwE]GݻWjNyf6җ]vnfɚ5Ν۞KgԻuVYz{ٲeu=odmǟl BgӦMrI檫̙3 " 2g65ajY'cs3}ʑ#̙N++<}3[lrJYnVB.\/z/_.7n+RW=uT &8ڲe~o\~~K5     "`HH Q1/r.\>$rT:0ݺu}QKA_\rg;G9qoQ>6kQT[u($a\rK)ovSQQ=*gShQ{ߔS24|~Q)VYG~%8j2vCM :Cus#8 r0HQ)3y&Mte;w쨍mJnmSN`n# /QvoVRJcUN5ўDm*Uʣy{)i);n83@j sOM*;wN/@4 h46HHHH>HH ~iȋ/d%п޻k2q眯c”}KC^.(qƙ5k%#Jģ.l>H`S_-·Ut9S|ݾrHN⺹fc a*)V5; FMt椭Z]V *_}䊤z>Fm& [is5Ik.jI=D%{& qVot8euj"?qZ*$ @"9h$2_t!u]6nXڵk'?tLp*:o*F$/DE*ᤂsF"g٦ j3FEmijBĈ2`q%!4Hwy[(ȑ#pt?ϔ[:&60ɐ={v jE(]sQ2vX{/j 7ƞy} >f$mlW^yM{'􏽴}vL%5h3YۂQNDBF$,K,l>E[f49ruA'VƘ1cSƑ|fHi wNPC< ӧOR43NU}~٠A2Щ~18 ?zt?D_W\}޲euBpNMp>-[LOA^T)7n(Цd_~xKP… 1'N0с Pٮ^}NYp]wL*UYobch޼ncu vG1"HBy DAi6 fpꎹ~=zTOS變ϰNHHHHHrHǤ)8ʕSYG9(g[9u%e/eO}T4 y9ʁ`*QKuʩQ39K,q܌`;*JQN צ@sB9oկ__GiG'X)'G@'9g/;TԟrNؓ"s"3tW.]t==}W}.ڹڰQ}G*Va9i,3rٳmB9}ALcV>ZM.O*^n4ju0fʁ(w/Mxw:pn{s2M~#9s8hKmd6lzժUko۶)QG6qdŋr&7)əu`PB0=px%) *Qur㾊L&&8RP3JOz-IG`!&3TdSF }1#0!08N`Qz[wkʛvTǹ+USdI{ߔsUD'Ii8,|MTu.=񫢘]DrTTnMEWR)ުU+Gimɑ"E8jSLU!ݡCGm^k>M|NYTs+JjtTdmL֭( >᳠Lw^}]yw{yiF"B(e'O:jՊ$%ca\=F9b   #y$ v#)lXmL9^0Y2d̓MF%qLP9X&>(ZQb%rs&H f̘!n2+Vv^ PҤ݀DjFf#C`t!׽{wg$&e{ YrS{K-!5y$    HB)1Am0J}u Nf2ȴB6:5DEg_-jV-uPYFbi?R\P`OGp5@I3/\N276^Sl:hRc蝟$@$@$@$@$@I #8#ؗ!SݠyK/СCEhkMϟ/ zбG; ={裿^ϡrK@I0H֭*bŊUV(سD#<6N$D{V9Q2Ik#,4ȓͰ Dޗ\J~Bn F0M$@$@$@$@I JSoٳgO?^Z_ze vԮM0Aر3FoMSaX8;&*7ի,llmȏe#mݏxzF~3}$)/brl;uL%+yJ?#7qLV>nD#crYl D"z$(HHHHH ĜӦMuծ];-/ٳzp_tE:7Gg˖M?~b]pa}k@IDATA4.S XV6YdcW_}e#wq :&9xL>]6o,jQ]HXC4h u1QmܦA_v*^ze˴;C -[}'+V[nE)9rm x iٲΡ Rn ;,ZcjM8xxQmG.k׶L@F6c8 $aH$@$@$@$@$@BѣzcG%ː9t&-nS2Jҹة> WӯT]/|vF}ݩ֥"%(i[n)|G*)S&gΝtTYlذw}Hʛ5kLסV]N9Q= xsq})Y{@(Y}o Dr!  !;wn?pʕI3nHH mh_$7ƏN1rpޱczߊ(P@Gr)}_5J*T`.8"%UA۰QQ;G5򸆓kF>5Ꮂ۠PP,Fw6p\̀D9ܷt?,=̜9h6muM:1Nƿm6eQ;gwiyFrLg,۷k){U\97c{֓M4If; XE¥RH WwΨhl=0(l D q(؀r4ŋNz,sEt˵:6s+U Fg<'di*&# /NM>'ɓ ~A#ȑ#,^X3L8"\w :xHHH YɓG:#`U&9N  4x [oOCIf%ZxQ^^qt{o q s#"WT׋-*xŃի_k8}6gdG 1v0JlK#X!ooѢEt       Hp&8< @2gN,KF`֬YoѦ        h= ):͛u3e$&MB hD'~zٰaffl        :ܣAm@xdڴi D,1cVjդXb        BD2 8#`߿uͥo߾ EnvbHHHHHH? [vʪu[fȒ9T(]T.-QH=7OX,'O[ndϚE/%< +ѿeΒً<>?P5' {xܾښU[pސ@ؽ{iFN:RD ys$CdѢ\pGIHHHHH 6 ̜B:.̑]/!֐^|u9rC|4{)S g{L3b.}[@pc]j| é*e &{qRmC~)E7;/$6'|Rk;ȗ_~KKX&ooѢXF$@$@$@$@$@$p@6-c#6.C~ٴCt}ݏRp|6wƵTz%:~mKTי/\ʖ,"g}'=N2+雴w6 XYϛE O<,XPL"۷out.|j*Rlh^L2IJpˎ;9rHA){2%3g &_a%VgH ` {6WF:oHHHHHқ@,lr_Q2U9aw!?O3?.ֻp+y琔N9 Vu:oe\a!,MJW=- u)Qb'T>=^M1')S|yyN:a;|.;f5k@b[}hvo[Փ7xCON<~Fضm}XmB#x w鿫+d E#     HLys/Kz_ ;1});wiM4_MJq6NcXW6fykW6ZFR6ˤ m;rq}];c@ECs޲e\r%RJɓ' Ƕ1G˧אFT}9sJ9eRP!iРOق˦Mt̙3K2elx2jyr5[&qb䪫eP>Nᔵ!fqFcFfϞ]rE<3LL`̐i_%k׮ռ.bV.ǥ>@u'N.x?x|>3;k       'x[dԤ寿O %Y|BWBgYϑɔjӬW=2dtG=Pk߲,ikg _[}間qc@E{S9~f)R{ M.$t< ؤX=@/L},w^zI;uȹ;FI5dΝo&%KmCv)KYb LxRV-y%.ǻ{L*'4p׬YSo >kזRJɄ pxꩧ޶n:i޼ް^8׻D8{{ԨQv(ݺu=$7ƚ5kf< @2d.]Zz!KN$@$ʗ.bynNKgG},'I3Gvil.f1v%g}ǻZԳ&8hj.f %]YI}uMbtu-,pbcU8glN #r/+V'|R_C5dY܆lDʕ+k~X߂%Kֺܹ>}[rW{qWHe˖ԩS&~X^ꫯQ?)k8vXԩvc[Dc\p/^X?GD?#ұcG޶m[$6D9 /hG4Kwy(GD;{ｩSk5By裏T 4hrvapfpH:[lt$J%:ʕ-ZHrHpʺIK8n09c_~|zBO<ݿ;3h'|C>x0hܹs\ ̙3:080ҤIiѣG֬YGV hjJp}6yddO2nv $\9ϳaMU? ^XΐnJ߲-f I\g%\S괯&ޚ2/({bje䷝l9#Vdariٰ嬴1I %e@_v7E8DG*]~}YruG^w=pxaDÙ }rh#skS݇!conh ZO70% dV&I=Q"VO?diJDz5ᧈl72?~ތ8;@`R ZG      &a;@Hr $'o7Nug?u괼7v71ں$f&^0jy6r}⌅ȴyK'[zf`"f ļgDYj-o܃n{z_#ӫ~S/ݻw۸{ngR4qeU_j c-c[ $޽{- 9r7yd>1%Cw}Ȼ@2.r26wjsvƅysi9ɟVUU#ԩVNJ?6SC ^1b35D7v3dT18}dQC4hc3Pl*:f-xc(&=4vSԟ#p *ѢEz3Tw=֭tq^B-C #ަM]~HEs3lg!M}.'NT&M7.^q={lK[L @Rq6Y]vhj@ `%\6= T)_oѐSOˮ=tVmlZtQS2p&~Pv6!cctW?b,6HE޽{k)viyl Gˋ/制F䷷,X:Q m…%&8phhϛ7:QW_}M\rtM)df<(ӧO͛7[]al SO?۾K} }^zzSQD%/\;?hkƌqnwߕoV; G6-"/ K^vm_tTԇ k&CO%Сvn ӚMQq Q 6:u\wuҴiSt vڥW,^Xo䊨/Brȡ >ILY~ᇂH#x$q#3h$@$@$@$@$@$@A`yv- yZ"MIwqOzO/ؐV`>()T~L )6On]6ЏԐ ϡ6}=7^ݲcΞ%Kf -ĜýW^GN!D}mp>>p"j+Vpr C;dJ۠\uIO?mN3weO@7Nt~r8e[n-pqy\Gw!ChIH@s ?oN^\94MȜxÆ}ǎzr$l˖-zB X7yd9s&6fko2Aq@-'rCzMٳeV7mA& $ghE =Ԣ@Zކ4WZ#sly=es =o޼:QmqިQ#%D81Fmp|)RDO &Əp8p"R?9A^oCT;&H OFz2j(Aĺ[ Ș{/0ІGզ)Zy}#^ͽ 4gn;VHHHHHH1tI~K/Uj=kRJ#O3(wa]|ъ~N[՝-3h/z%0o{}zW)n@j|{+3pm۶ iBfŊ#3gNF9)^@Cܽ'ڃS2%ZP zDlài|r-RJi'?x8e/xcp|h#\pAjIop&auÆ Z" ) xoYo FW?^~`Sic5y$  "F0\RF6@6A+eĉ:;Vvmқoe*!1TD BN03 |KddYʫO+\([",[˹7K{%S/_~۹quS-נV-YˁAbR3#sw+_~눊vG{ߏsLҷpʦ_ysʥ?^װ/ׯj#QѣG Hr+XٲeT4  hIž={c=jӵxs8@i r}a$؁g6bKc>SlĈ:0.uHHH f` ]Ri^4s\VHwUdڰ YY|8{ݍum:Pn'CGٷp{ 2i:$f 5C?qp?1 @zLzPe$@'|Wb/xqc P4f͚ =2ϗ{yؐR./_/ޕc'lGT;d?WbX…=.s  G:(xE-Q#+RNK?tMq|/VdaIey=zpkD$@$&n&P'HAС3dc 1xc9FWkk$jB/Rt̜9sƋ~H̄gX?/̈gPm1톫/lڴu]{:+&;!KI V\B4{={Dbz&:u$sugHHHH@8G}rHHHb3<#݄v;@4 4{Wy)VoVtʕu͛=tqNJ*`<:?xAfR^=}n~kw֎zɓ> ҧO]8{6Uȑ#/ Tue!HxcMS1M7O`…iQF~gH:uh'?|駂۠%8aSLVZ0M$@$G>ZnHueʜHGn}M>WsRR& j  pSN&r\Y @x٨1D 7E5K.-~mG8Qp饗J߾g۷OG{ +J^|Э[7ꪫ=hW^g"+W*?|= ow=VHHHH< PRƓHHb";/_n{FE @0,rq݁t[>;_nOa'|8f!z b!i}vYgb<> lx_@vSkM- @2=6J$@qJ K.DGePm #Ppa=cǎi}vDbvvlRL2YSdHㅋ.Hoƺ~%׮]WVghg(ȡE4[ŵɓ'PBZ)ʗ/Z'   #@I{0 8܍l$y$ 0p>w#믿KA_׽(i9sxn}G^:$iImiu]cƌNcTf͚N}VŴ7QClش׬@SO=7Eƨ^J @,`{:?|FB;v-aСCif!_˻"|8"@_{gy{# *7ߔ?#+5kE'N/vr2$@@h`ן*_}*6S96Q4u͚5zcQ:t sl٢7$< wܩ?yw?轗*UJ;<ٰa?:5qD"G8ٲSN{GJ(džvg|I֭}oA܈gzfLL {8a*>}Z)k6EիWe,YD͛'82/׍#&ya]L@ZEҾ}{6/ټyn0~N#   8Km=eMM6j*Yh\x[AG-;wQɓy0kF˰ ð|:ѰHF?#F$F0\dLÆ yH C ²iӦ9sԓG$2lH a/rWhbA[]v*aիWk*>-ZT_.;pz)Ǝ+ʕC3ں<+ǤeC"grx3޼y󠇆\&ӵ3<³gϖ&Mx=ڵ r߇駟v_廍xHH xfrE2Qo &w/nM?j5fN, "ҧ#Kî?~]K}(MWK:ꏠK9ܽr=ET_7>{#S`݋xՑo NE9jG4h`ߏLq! 'o-ܒaH̙3%Kڿ=oP̙%;r{ظqsw;YdIQ ,Q+l9n*iG9A9ڵsnfO>rxyϞ=wU+>3+mwi9e~F*"Q+ y׼o۶mwTT>bzQVM9jBU\wg]{ qx}GlG  y?߿sx~ƯGsΛ1O兙ÇnC|HҀ0hMz!9e*co ˓''"*}J"1H7gz/ 4)44 HoPNP9B (tP|2edܸq2|pQ]- DcJWTO4C3VEBZn:yqh7:u">Vw7ϨXblٲ@{r/˗/{? hE9>j(}vUW|i&"@|tQp#];54+.) VPջ ~@o&TdPϾ؇|HȑI<8I_#foѻ{HL %Ojү -gh[}F?/2vi/f3 gQxHH'>c9 @{z:ճD#S1k( AGmbR`)(G9l~qJG9_4yQ؄ ܹsyL#2R6.e稨&}HRF9˝nݺyc9(lVTIKR՗}Hj6$tFDHQ^MVhH7d{oYbyyO+)I%y-gc{oe62gH eP/:e?쳎Hrijժҡ?Obs=gr|^# Dr HȐĪcal ˒ @xGwSh$d[з,[u/#^zyN`˺AZ-"<* $3FVoPwNW_}6ox/iƎ?PYB}(K/h{&n߾1JN:>31KvHFKxlY<96pX, $0pd.:pWc 6h;S֭+js'c|6aÆI˖-=m۶/0ҥKQѫ$q#sPQ A!Q"Ċ+'ж`+(g]oM6zQ3gZ_Zs[7T|WZ #FT_&DmOlZ9vTd8V^-/|NLrLF8(-l;VԄfO?-/^,x|ԩSޙ[5v|yej@+C)c*R"$@2K5Eh!R(eNyS\TRRol{{[Ϲgϴ{sY{=u%fi=L[tqɓW[l|ꩧSNv>AuhB ai&yv2~x~} k- d;HA0/^Vظ WRKw?Sa=G$@$@$@$;싯&jҤILtuƌ^ Vfx`hN~xr&A_8'\7Nzqz p7 :;w n%^[hb.v#6kFnٲwW$e嶑r]sd&n%gr&w;C1}&ׂno׮n 8u[ G]hIH;c^}XMlsHvQX. :FNenY/CEt1FEi;Zg}dԩ˂ .41 H쇨]lMkNW-^y䑸}ȑ4n8˲FDyH  4H^w[-߮ +sdB>`<}͛70r9PE6l(GkX#ۤ1>'SLm=bgO;V9q= {- $7 Yu88(xb]    g1s,YO> [OUz-c"Dӊ Qwp֧ oyfmv…zkڴ[xL"X1IJu9۱ߖ g(Aqk׮LbM}C\H~Q7߮ ˬ$`&J-}72Y'?y "˖-mp[KM8w3d\)-< @H{}nmiD I Mr8ۡߎ֭[U'T-Dَh É}#ՖObMɴg Qȿ@cv^cH|6,>G^FVƮƼ:V~}wb"r+@nw<(KB0rXO?wqGMN$@$@$@$@$@$@$2n}ﾻ+ߘw'i4*i;y˗/ׄCYkp83DB2RJ$Sg(ߺuc=;QN'矗 /@xxf͚ۣn@HRdx.D:|ٸq2L° ;|6%(YW-[tFїdv?!#c4tf5!fvuWT 0 zڶ&L)" @H駟.5H7N%XN;4|xF̙3e޼y8q:dۯ_[nEڴi$5oYNYxFBs5h#g}V&i:!{1j(լNiDy@7бmx6vI,)s@8&8CI֭[SfwHY%w       'inA{/2&2Su5k,P8h#R/H8l ˸!uWVȖqsd 24v[[bELMM4q7q9`Ǝ5HC; d mϔ$͛DW \`pLT?UVUTS'rG {d_H?8ŋ۠=w\ArW8dOakVҬH9*w2;$Xm}~~|Cfd E#      "pWܳp޽{0odRe=Yr$@$@ `T?搫M> @:u&;o,S(k#͑  $@{: jd`9*  < [ouCz rF4 %ꫯ̹#FdApBX x~    R @{)@g$@$@ -[C#~Mn%D8Ftk¾(le?%CW^2   %P&vk$@$@$P:;;ÝF$~gA.[.`H| >/pH ^tۣ-[h*T$F]NݺuVZIIߘ2+89sr Grv_~M:#`?HڵN:zr,\P֯_/Փ:()Nh# t\]NGoM6 'AnC9$O92JTtJ ?IHHH $M @i[_ƙΥ=$O$5h   &J=6O$E]/FhѢgr;_ 37z~]DnC*hq]u-g}(G/27|sL={><هF.|7agv<8/e1 ^n(˩x\cDy@Oy0H)SbGsQtJƀ B.#M*HH ?UV_ @@Qk?&JK99I&r'lJ50.˖-(+z?gn~WuId4od>T|?-_bc^'pF GcCs7 Q R&QɆ1׼Y &WL3)!kQnVn}. @i(S`$@$@$ɴlْ@HdW`*TPx" 7xN>DnݺիWk?Q/=ߘ(uu>#oJtD 똊rv99*LٟM4aRҶm[tReaFK[$@$@$@$ pτ1 @;@${o=ƍ7 ƌjX#;h#GMnq_T?`W1G%RJ1R2bJʕ$s-rkDa7E :T|wWTI5k&͛7\oxPȓϢ9lݨו{rrHHH2p8 cJSmr饗j_|QbMH/e$E?"Y!)Eaad nTMzM3FsҤH.ږ-[՘(c[7u@ܺ_.IHHH m xW\qw)h)3U;{k׮-vƍw }"rd%K&n95kV2Yr@Ν|^xa'@>}ϷL{=?gbu>WuWZ8oW]uU(\n09ިO<vZje{m\Œ֏R7u7Ü_>IHH :Q8 vAW_g"LA9V%_̶\1V1W1wDn%\Ni9~5l"H$5A e6#c#qzy!y睋cTVa"VDr&{zfƃ ωq'=Tr\W`=u2 L 2Dl.́2 86{r%ivzNv7xx`47%xÏO1?`IlF ]qaNu$2r-?|P0g;8n{A}d*}'ZL!.+V,P.?&טͻk10c6Qeb"V0vn iys:]p>`GZ~0~b8ϒugΎ fn(W\9Mne BYByZxkٲ "縉W*G{5l~: +[H ^a,*Fux1$ľ6H#DsQxǑʶ7>XHHH0N9shwN5NoSxA oQWUZoߍP50m=)H ə`ױA%gi&Іqx\ORSva>!ER3y. 7ʼE #|~rT[8YIH` gߑ \5Ni'v6mku8ڽ޽{5k@k߾}Uhَ_&V{ob$S @A#;E=!xM&OgŒ$@$@G2>z\ w8&?:~8mڴm[Ϟ.]$U?ZfM\hOsuQquvcFx㋷ Zl=8Ru>(K$I& $7h(c6*1o<۴ .mEB_97 (܆ &]vJ@WO>zݚ/9sB#k$U!qZrn;5/#FmԩetRnfN8A3'6ҪU+ݧhI& eb}$p >3e. @* KxVؾx幍A뮰};(Ga89^ W˗/-[odi9fd3 Cn@^~)EaZ'uA$6ΰgo:wl7Ǽcm;^[vnc3PwW-gtp0pfL|&w9=e˖֯_lkvt 7g\0TNP8uI&1Z1cW|y-x M>,\;}໖F$@a @v8Or¶z$䩑UXH ~.PH@FNm}Sj.-X҈^xA1ӰH܇зq6j,6=?hРOlo/l?FJʸLH\1b<.8M2;mpJB͛7k ^&:z!u.\&Īvs;c-3J1G2-ճڃ-iΐV L"JrApC 0d ӡ "˖-Mp[[d]LO?H$2,OTsjZ"H HHHHH 3*Py1ybW u(uUҭ}RKr16p:p ^[nU'|RuFui>J5r} /k׮f;Ֆo. 3GmfUҜn FVƮƼV~}wrw"ukocիW#H).䬰YE4    ֏<Ue 9f=JݘJaJ`ݤRJ%6 d%v}~GMrp#y#H H".{"o4eGıѫ Zavw}'h /Uw_fcvwBiWHH t#_~1z&iFnoYMH:u6|?^VX!&nC:_1. @^dԨQ ,n;,gqE f&L/֭aj!nJ`x{:_-$Gը |r]w9A/XZ8࡝n$U'<0qwrKFt\ƍMH`6a̙3:L8Q`  x`a72anݚ23g ϐpIHHHr~ (8*YR7>?vO?Gq,~IH! :XV-YtiX8pJ1sOAt9x㍚D2@hCr^8/0$J3O9?^;V@ +uƌz10CL<,p3O],KV&Q=z{W?n$t[}v$BENX^􁑮gժUg(ޓ1$N̄Su''9J<`lϞ=sHyX$@$@$@$@LuW*(u[xӪ="bi"ìhzAI i߄Hn _KEE;Ҿ}. DuGZ'&@6d 2.Ţ>ug2wYu^9lj/|_KMosQ [ZRG;"rՋPmw46n؏m͍$AT:">lA0QZhaDŽժU!zw)p#*ص(cvA>>GَFssW;3޽Q2nl{1MPd8֐xw}5oAg9:u$n`+VڍwDO/H>B֨nIHHHH}6rz\ftA 9~:s[UT(ӱcGo>8ޭCݭ u! u`ּkpc67'81cd`^{ͭ/Go YO`7?.'Uu<8R>_:돋22=SܹsU>OOONdF"/t@K(ccCD3ƎGu۶3= (u2>fS9m:F / N&(!?)QC oAC@IXi]oI0MwdnlJekUg;f!ߌ}Z59Ðy-[w?Ӻҏ]tљ͋].,l: hGT;/wŸ\үs̏ ^yєӜGE{Ɵ"Hrnmagƣ <&Dcƌ48>F:?Ⱥuђ%eumV%5U:i-(]7|撃Cې'vY(ea Ŭ~D-2/p@^8!{衇wȆY]s5Z c嫯!7T!mE7sPnҡuCuתVIG :SŲ$@$@ Qԯ1h @v@T O?eٖ4AIji]oI0MwdnlJr0ku#B^0HvXSD|ͳsATݯHq /h}fȉW'~M0k>^߰{U >KK(>9N_I F @{xJ$@$<WNIAC#^ikЃEk~ի5<1IYn"wD_^c;k0Tt@nȟ%+klr8WQxX:(>01k 9s:5/sB#  b'`h/c$@Gve3m?wyDym698vi#Fx&I_xfڹm{IOlL`#/gth {Y,M8Xڴii:'gtwM6ԏR7W߯q+o3XLt_<@oܸq~yw!׆^7k#os}m߾}=5j qRyAih!{oFLyU1Y0:ОiXd$dPqsАڵ&w `٭!b{1懺L4IB5eݝ֐PK.;;vVHZݎ.z4wy'HuFB.`̈f `"FTt\Jw'dq#1q^4y tR-Z|ߎ(9utS*#{1N@֬Y#Yf͘\!L'{k|Socma-b©;xY=<41C `  [8|ΜB;Sn֘*1e[T{ 'y@.짤L2d? wNwdHmϟnMV)KҮF׽@fF$ kQX;ug:_8=H.]ԙi<80`|G:/B ;\@0a/u3#Fԩ Ng|Zf6o^RjРJ!l^<ֹsgw*$NgIKMT<3Z"3[Dl٢6|\xNrYv6/8QO?Շw"{VZ>&L=C䟒!жM+3v tkøKѲ a Kuw=lz2F3M`qc6ZvN7D yg_ KnLCfmq{pwuLD)=m) 녹66Ž060(פ=,\8< Cr7 : B} c°:f[Ͼz]E,=fy82Yg8>= {C#( b?EԵ(u-ܒT4~W\qERCL"ہ< g3mYehT7s:CϱqL;Oݚ5tP}{_୚x%h()Sl>%e̗7HH 񐕇@W桑 /D;<GjHD!7a "v{hOǺ5Da_5rQ|8Ǯn!dzԵ;C%N4!f.Xk#x^X7Z2vXAD bv5܈l k3b+Ɍ6*H$ U>`@4.hi$@֭eŊ~{ᎲEv.3w/YX6e ||FH*| 7v}2dΪLPɟ:,1bM cgv 3>Ɋg nM-GE l9S' d)DۛnLH ? @D~ ! DH39N48LI-_8dvool\CR8%Nl<pNt˧zjq3X{2H%3f[~ze͊$W ڀ0QWRnfl'̌$; pC%h~[jnN;^U! y< (3& d o[p, u&]eܲ-oamq_dL\9:sL8HH C b- @~0]tDr0CDD Im2kaQuY`l~g ,lHh$$qIA=l|rmǛ5Muz~h#BQLڈ+\?_#ݎ,^x/pT֮];nB(κ$PpT kZbpj ;ZF3Ng5New5g5jd9¼"7wD1 :Tys=^zC i&!Fh.D\!v<3*0 ?i([ s LwI g@j#OΙcぐ j>:1]NYLg5j@zpj!ZNI8P?h7rوXG F.] 7 xn9餓j~1"2SMrTձŘD4=ts1n_kcI Ǟա'#Z+H J/J]ad;n ЦA&C.9D9HL4I_ {1iժ@25pKp]oi]b7hk41_ǃF7n4mTg!@hR)Ϝ9S͛J3ImU1G~{==aÆk׮*9sȴis(gD 8 dch$ANLX:M7ݤUEԋ/oWڶA ?Xa7 ɏeʦs{-X@#hKgQʄԩSXe@?h$n:L./@N4Iiaǎ)+Wo5ݯ_ª>8uH>ixJznC*TPܞ={u9lho$-z!{q[oSNzXԬYS0 {3 N זَ8qd]MxD(u6 @'g0S3vl#6ڰu鷤Ɋ+*c.A,<޽ຊgaexhَ:2(UB۶mu>{sЉxW J # ?f B?ޤҵ G+4 pOW_ 渡=S::U6o0F3=Yj,m\7ߤ@ɯ H[8!RJ p-}$fvyg&)ֳĐ/I6׭oSֳ$}%ځ3Ɲ H"`NT-̵jʇ7k#]d' ^g 8x>*0 k}麮 #>ϝ;Wewn*ժUC kaX+]Uq?ڰa0UYHHH&w8ۓMd$@rЈ v!=HTK\ǔdL 5D0F mA7,t0C5\[+Vi3+^x*9uRϊ5\i^_~ez#Zxi>"|SΡ=06mڨ+[G,Njd}=; 38#;&Q5p|3Nh$PxM4qG$@$@$@A c513Au'jSq4$ց{َr?NA E{,u`ڶ'Od3g,lOT6=:ۃu1˲r駟Oh :v( lF\(uh ˈZwUOݻwg; `24[ hhuc /vlǃ+|hEy!M$7pHR jsbf^UIe)4ˢ$XHHHr@Fz۷S8pxGl٢'N`74gϞ-s̑qi> E/~!ykhM"ߑ Sjy1b!zꩧj#H~ "}]Kh4iʻ@ru&dvD3 0o<۴ .=  .se9 aÆe]$&<95\#ql J [nɓ }G۠ߏwhCC%|p]p GT<>Op?ҪU+g&a'$Ck΀c9FOxz=ꨣrx$$@%N3Y$r; td;$@$@$@${2};&^n9Z @ql*<ƃc RrI5Y d'u'w,)iuYg%/,ԍi:,60Dh"! l>#]#<Av@ȅc]ڪeAgȯXi#̒pDA i&}tyn8Ƶ瞳ZDt)StۙfA~/`J8(a,cǎ-Lܞ]!Qݒ; @H2L9 dpJ*}IkH 'M7R8%Z?]V}MN |f{HUcqX18Ri3ί=F&g50 ի5}ݺuv:ȑo`ٲe qkg:ЂcoܸQ /P?5kMiYFavjBQfe(('Y['{ Ŀ:2x }VNF$Qu,$DbIk{?~XB>݌{Eԉ ;߆{O!:A™s̑iӦKW *YrtE[Bg)!%;СCUV{k=8 ح >\D'XHj-m}C:v}Yub\85jj1 .nNv~q\Q8ل ukx`_ _O1b*t$E"`,3aۻcA Np6)*!%"1q,N;M ]xpaG"W|>'N(e˖&?ydȃǔQd'G@IDAT9mVnIHHHHHHF!2v?9}9S ᢖKrҹ`eo7)6N[#6GVaʴqkzfLÌxŸ-dz?cRc߾}5[>}4Rzn.WVdhVk*ThD[$28Ḣ7ސ>ۗ ցC5DZϘ1v~ftD>jA- |:,/9 m F +G2rHu^Ŋv#=hpoҤIp3׳dr$@$@$@$@$@$E !srewLo>+1\&-M9?|)w [&9[/y=N&: k]zШz 6F˫#N`y=w\r8ٓqB3,46mQldžfzUTѱݎ-QXE-w@w9jE߼y,]TP[ƒ@ @N_:uv  жM+3v tk߼tm8Sy"mn;˛O,G90nWTRZzsy FR'_Rr1\Kxg%M&\Jʄ>4V,W4 lt:Ri#L(c!\(ԍE͚5LJ^n]}T+َ$ @q?ilGoJ%Se@NJy! @pۑd2q@$@$@$@$@$@$3zIG,Gթ[8đ0AUz%F~9Dio 9C9s*y $@$Pzpoh2;HHHHHHH $MD9Z2Iٚ:Ukcؽbu7Fѓ @Z̚5KH.ݼyielHHHHHH k ,rIz]_.[~7Zns:HHH"x6b]v׹@$@$@$@$@$@$@$INZʻGbځNgWɀoȂϾ]t $t:  L`ɒ%~gq      H77Y}tڃ'^EYU[fE<#@I<;<\ (={jժI&Mk׮$      %P}|7m~诗14p 0ݥe  P+9D#wnYd{{T9fӯ&(s+SR&H$@$@$@$@$@$@$@$@$1M[uV=]'~D{]~_1Єe?:ܳHHHHHHHHH {7k'FQ3u?IG\h;]؉3 }_nY/A'C!        (@n{9x.|4srcj9F68G.\gKrL:5ܳq$@$@$@$@$@$@$@$@$\L"؆8Z^|}xdm9ӯd2& ߟjvۿuc!ǼLP<@_YE˾DŽ*\t4M:܋ ,%       l#СC/~Avm7s=^zrEr֯_/'pnF?Xȑ#>ܝ<u?>.@@]w5}^?_5l_n{VuU+Ӻ }g_)\t,r_i+tIk9ɑ]\RtgIHHHHHHH x馛;⋲`{АqźyÆ q/m mw(N; OBMv$OE-Sen"to/;/8V, 127pdz&*(wZ=w%HHHHHHHBW^lơ*{ｷ^ZVZ%?yd2eh<:c=Ȑ!(wDѯ[NLT="D.hP?\7FeR i*RB槹&j:+#Ww8]Lv|wbZٹNR}R^RbPmRf=GG$@$@$@$@$@$@$@Nѓ+ԩSc?8ٮ%v' ^085jS0m۶ҹsgi֬Y\# #>@_ZHo2es/Z~MΣ$ R'{G zqN YT9ʓ$   ƽ8_TTI~gʕ+euD]\9)[/?\Ν++WN:I : h-[իWרt0eZNuC9 һ{B'o&+vmTfʸ8ǒm˂8^x|?C8~(t vvJ$@x'wq؈C aS"n;O#ZOs7r8n$   LgZh K/T $KL"8p`ģM'p۷iFu&>vaor/v_y__bYA[h?h_:K kp¾krG?b??z=BV6o,{tw|PN?tw3$w ?|Md,FyOGyHHx zrkK:zډՓ>8M"3F.]CȊYR Q0IHHH + 4,֠Gdv( /.lv$.ֺkO?J(W_Iǎ2fں~',6s`t#wz-Ag;ZdhB>|koΜ9rUW̊s=W Hpt·{IHX Ԯ][z!9ҏNMĉfQH),Q dD#v-7|S7iDt㎺qgSNF]v &ۼ۲e rbN(9,)gt籓 dM6!Czhċph(ډaG7nTu]'x.hԉqo:1ݾ.g91¹Yw`k;ＳN<ె*D0Y;CN}QR.,JL6u   %p7v/wAG};2vw82x-~|>8q/ x`FC5ܫp`$ܿOa )(,@rnAZjzWXّ@>L>e# @"{Ce˖8(ډa1MuPAKthcf=Q=?cК5kl(ꫯ8۱ Q0<\{X-`_TfʵIHH"26ի吏zjbWݕ 6p?}vk=^k׮R>=.~[R#J`6`$Xr#s<(HrnpDCS_VhNdԩ1QNND|IOe]S=GM$"o5Hj N:$zmfD7XZ5i=L4~Sut'QQNu#2zԨQQФLa-p^Î>htaDI=`n 8ogqvUZUׯr`,887Fi׆= '͛7k$d ܟ¬LLL*^gHj sjիW~ '$uo8p'盤_| G;wIK#|&@{>}; @F@"^{ԆS%YDp<ǻ0ډ|h*uo_l=J~N w@!6f9C$ςA&pcJmZԡ޶m[9eQ@CCTG]葶nZF)׆ew   &t?N\/\r!mjH<81ɐtt 22ݺuM˗V}5 &x!* }W:v쨿Mk֬Ox$P(: Ý$@$PfɑRp0,-tm0Ί̘̀0h M[DgY-kkP}/kw   &p8m1YH6i٢v'O$cm׀Wuڿ, ~=*;fa\a?~XB>lҀ f>ferV\e C1{R~Xx&LR͎<VR%R4jH#)mӦM5A-f^\"da@hlٲZ@Yg영Q}l2}~8: <#*U=j׫WOo\Wܛڒ{LWhcBz(mT9f9z?TT0hZ(+#*aQoKpe   %$+yǯ *-ܢ3M6ځ<\>ܫ"Mbw_{ f|HfHBj5Br>[ϟﯻ p3f7a70bĈMH2k¹[8WZ)0Ã5')߸qiA}G;g<"ٍwˈRkX,^]̴oӖ)?cFȑ#l/ r!3G.@o&! (^DL= ;#6=ҥ޴y]@0_SRژ1e9B$Q4z'`%"ʡˈLTr~ 4N$@$@$F7^E! 9ɡHu mѢƐrJ> kТ4B6K,Ѧ4/((gǜnt(#  b R-Z׺馛}*/ǷzK#bF0" NhG;6Q{}Ѳ{˺u8F%xXI8x/OUӎ9l>G*k׮8?̙#ӦMuB(")Scùuk Sr~Եc%qmؾN$@$@$@D5͚5ˤ!X0+nݺ*NaJɉam+ @d NW_}U:pt&Ne{ b;=fVэfw# %x8`eC p ژ~ic$CyyD5jвHF$H #_ȣ>S䧟~YOue͚5xb_q[eѢEٸqcműΓ ӥRJE޵O;֭[0 o 6D6(Ǜ&    HH`7d[%CߗNy+yry$@ ԨQC*oL0!q>R^=nP3\!CYn{YQC9,DňPbBEUP,FJQTBeh"eKX`QD%'yss!T,nOX/d/2]jּt:UW]Uzj|;ܱNv;R_~bWN"N;T,R-ⶃFxǓ}\s¿]C즛nJuɗ~;4yGRa+$F/ 6pü -bu]786mZ8'x"E=xO9ۉ/9jOsS)gqFQJb=Lה0}_׊?tW7xYZ'? Ni)}=Nr|ϛ7 N.?~W*1>7^xaJl .bo&b|i :3뮻y{K%\ viŰn(х~BNl&{a/ƕa $  H@$  ,.wh$ @R Fq)n.JwT|~N.ep}HpR y1wfJ4q1:<K1QZ7JQ˕rF;>U y}rqu`LR2o~S:\_CJ<:xXo}k^zyT}{_Jg\D('w57n7fv>= 2[ UC%@uiQ3])7;5N_ c.kY}鵿Pr,S.4vmf{ʯ[Wt>( H@$  H@K7M-gm$P%pG&M=Yc+.Ƃ> XU댯~E|TqX7(d] s~|-~/BmHV`Uuf6)6_R@aN> `[kƳ0y=\p,lM7-@,:[ 0Ʒ 8Q>ƈ}pT~i0_kV>_ )rbGix& H@$  H@9N~ H@C /V!ߴs 6h7 .-]4Ϟ=yɓO>6ElG(.ݳ$Xc~}%a3_跮<ӛfǗzMNe.j?vjNe`aOu`O}SkAN>/'0d^n_${ |K_J_8ໝ!,{0ًg}vN0K9 H@$  H@X<(/h/$ !`c=6mޘk,k l:cƌyDr6<3Fܫ@ZpS:aKpsyպI4:NN袋X~ 'rGuA-U?sl\rtN\U`~G?QUlXc1&`q|g^g1_9P׿`Ka ,ZJ=в/cK*69U/ H@$  H@X(/rCb$ p%կUKq)SO=x /LV/b*2wqGSEŝ~M}'k^4~S|H;,9S{R/7)%D:OU7|t ݆nX$gyf XN?o~sFǂ.V)r_$0m}Nɚx}M>q$K&)?}_t:/N;uQIpGPg|gڋxڇUXX`AȚ޺8Ë:8sz衩-yA >#&vXr/,h{BpˆJ8ӦMK_-7:Mճxs1I湚;wn1gΜ$j?H;yk믿>տjً\KcN4'GqDrMPE}Vo"xq˓W9Kr<VX+ r=LXnM y!"ugtp/q, \!RxEq5׌XdosxƗzR(:yQGuQ^~sN$  H@&%X6<͵Ə.,osU>BǗ;zUW*qgM7ݴ(-G{oquB9l2 ue<3u g uy[.f`LaS`׿uj#p53aS[81/YX0㋟*m[lnƃG]5= H@$  H@WOF|+)+s+$ Ł"pl;_&$  H@$  H@Szy H@ՈlIP6|}gˇӣ$  H@$  H@&-qU$(7-̙ӲEw\qi7B$  H@$ Ş@pw~$  JnμL, $  H@$  H@ w$  H l.el:mڴ$  H@$  L=n:K@$  H@$  H@Х@H H@$  H@$  H@>EnK@$  H@$  H@p (I@$  H@$  H@%>EnK@$  H@$  H@p (I@$  H@$  H@%>EnK@$  H@$  H@p (I@$  H@$  H@%>EnK@$  H@$  H@p (I@$  H@$  H@%>EnK@$  H@$  H@p (I@$  H@$  H@%>EnK@$  H@EO=T[ۼN񵙼9%87F'xb,ASSv[$  H@$0+fΜYޞE7pC{Gms:fy7[neZkդ}kNj""oꫯ>AA xNJoX~~/?v<lI[xNj|XnQ{77ڜQ$  H@$  t&e j@!~YET;fjq/ ]v)&+չj| K/]`NTt[ J,\:2,mE*} bq=ޣy]| B`Ye0q]wNErw&=unU 5w}wz[e +Nvu~`e_NeGA:$  H@$  H@hK^Hj\TwtV[uJb$!P77&z|~K_:Io3c{hߞaasmiɜR|ܹ\l)H!@( wqG˅z +nhR]~Q"?mѢF~sH@$  H@\"`׍(1L4ԋmDHA4|6Wb^ˆ~eӹ@="hyCt;76h?pe<~Fy~B(~^m[n=f a2ȘmsŜoa;!4uhy}e2sXΟ?+.%_εp_F6H@$  H@'؅(E}@dBp嗧u]7/D ,);'?f|$E BAL;?Wyjv…}i!m>Q#Q}fJX^^3GhS\cy9v3^{jg©1ieaJ_cj`e|r RBԍ?֪X'X!afڕn'8`$1Nq\l }G4pG ƶus#37oW^yeZh5?y.y>7l.U)1W:w.*XwVƔFcO{MVn{s s=Z:۹ ~3fYwGd.b0/"q[9j1w,xkUX٧B{rQu4/g4$  H@$  H@@| A+Dģy{SCp'BsD<=#X\wuIAxA0E`A A$n2B B&b(BGXBo^6EIB[і8RBoU%MxڄxFiy;ڃ{ r2~v#2^hW]~]#-"cB:R L#}Gtf(|ItX50;FpƟ0;69dE(鮽nQ_+n*h%bGDkUCQ;<7b|nGԅK]D=*W҆@ {ncsV->!y|W9u<ｾ+(@ifyFi3-9sqɸ0gPԉE!}w[ we5Mg4?X8U6P}&NgxVxZxl$  H@{EIDAT$ 6 OD/"b^s5I1 oJ9sR{Lj%,eop.qa8:2p9a:i'$`7muvZLOR:{Mnu;^MCD(̭ResM V"1y W(;|`v2[V̙ٳgGTH}|Ks> ^uUIch?,sǓNpo57WNԃ̼E!3ܖ)v6KłiBnJb;%|ªᲃ:v!RƢ[>+݌!:k֬{{X83/)37򾉍;Y`SGhO7~ ̢{w9~Z 5FBHqXG C^V.gw>.$  H@$  H@HU>GH(BXȍX!ڑ 1n\Q rq~]wM?z@ZTD:A]<("Cl<V"\xbW>~x,b;+V%5}.sqòG! _t!V6nn~`erF_<X;, y[a|a8"!F\#.ayFȰf9 äiY$  H@$ >F=Ubqw+u,IA|ͅx O/"7 Z]װK9N@tE[,yϻ"ͳY'p3X3BHen}RyZG[A,oW̛aw9g 5֮vqպjOx0B,,R鹟 a]N]P:"xԑ[ΏbGnn|~`Uk[X `ģ~L!ܦvD UV|XK$  H@$PC Č1J #1. >a ߰%WaZ2+تHvVb-qDP{b,Zxxc*mXw*3vB:2}nnk~7Dq,`F' Vu}\GCwH7$<|̀q%t+:"d"j;͕?Mh{ǵ:'{uR|E!ʒ?#Ҏs~Xce(y} sy]89޹y\G\Y%ZaWp6Q˓$  H@$  L!DjjW/lD+~p;#"(s Vu :Z}iN.Y]ܢr(mhވU]Xq.M^T:Xw)# vsUQqcS."zO_9>w};mo7f6`@zgͼO! bWK-'?aY^|Rk6e[ou9 ާjvsk1Ɓq䶩#>ǃuH@$  H@10sBXpbeH<q3f(vm$ !ov]&%֛u:Sv@lH':tFvXcU.~~=X x8V@A,!ҷJ7nF]Ѯ~u-*sAƘ|y|泱pǂ>,ģo<{ᦣՂWXˏѶ|<9s\0h!2736e&?By\sd\`n-y UCc6.-R6_\T7㭶Sa v/;=A _$  H@$0 Zpw*#,w7gΜK/m{y>s 9" eS֝… 3ı.N\g确=|B<4>QM$  H@$ 6"Ν9|W("8gϞ=GoPx_X" ""l6#ĸӧ'1we!䄥;m!Մ ؇^ #=u_XkcD@r rˈ~Dc7򵻷7}t_veiSYD` neX"1~7,MBpR=Cb7 Ek}g#v2'3c0h?KѪ>1+X琱ۦ93wW|}2wb&tîr4pCG7#>bj!"Y~B/#.0K>ڄq?9wo}7 )VpE$&o9eenԵc`bOYf~0x"H3}yy睓eq<ܧQG]A^)) n'M9?E{yF8bλw><F;2*M$  H@$  :}rqnVZY_yI’?| H@>L vR$  H@$ uޛ,z;XabZui'XR H@$  H@ YPύ<4( H@:4uꌵ=$  H@$  H@$ 1$%ǰ$  H@$  H@$  L Sf$  H@$  H@$  %k$  H@$  H@$0e(O$  H@$  H@$0ǒeK@$  H@$  H@!>eڎJ@$  H@$  H@XPpK- H@$  H@$  H@Sj;* H@$  H@$  H@cI`Ʋ˖$  H@$  H@$  ,{$  H@$  H@$0qu;\IENDB`bpfcc-0.2.0+git0.02884a026/images/logo1.png000066400000000000000000000246421305314114400175020ustar00rootroot00000000000000PNG  IHDR9t)UsBIT|d pHYs ~MEtEXtSoftwarewww.inkscape.org< IDATxwUߡCh @HI4V"  ETb$# RER 2Ti.HЖ8 *D$HNB~f;>zkݝ9>[r ?fl8p|ywp899dedp8ZG_Frq#98'p87]u8}9ƍG_FrqNp5np87s8}srqU׸kHp5n$p86V,-, |doS1OP`&v]q8'YMW?Pclǭi/ALVN|_kW*\2XcȰ/Ǡ9ޥ٩jљjҪsrGHwq#9#HwBǻQR^80 Xޖ>iq;zWFx9U)'xh`'uj+ҠLn.hz;NUF?3#9UFڶɽ쁁D'Ѭ6m61Ol'2K[Sooy1-G7jMF^ &оd~^pbd{LvziuǀUuɾﷺVpʰc&.q]S ̠j| '0~8r.4Ƽ݁QȈZ_ < lo1-Lϑ F%cnoGm'ѝO^9p> l}$j8Ҭ?xc-[Iw m6FRc >p!G[cJ/ ɍ'/ X$Z`8lDBFY 8i[k/m*p̚c>}MdmmzRt8$ "#^qp k'!; }"%0[ cd1?4O=2pQZs8 ')8M"AKdNx}ZDU}<$4PȂUCؘ{:=KN8f^÷bmɑP7N?3N5ܘw'zd K 6bƘѩc GO[Y,, \xau2c̿62y=ONnI[ʛ 5c&!qv83-N8ˑ.]uě e.2\w'fqNn^15N p O/YEcuy]O c jCu%z%&cλG^Baޝp8Z[#ǀ$zM'sn \L[!"Igv/r;pB7l{i9q= |1M-C:Sh+ՒtO>"ov醓,NǺN}Xּu^ n m:}ENn&pTmwYpc̰9Ng2n# m? |d؆1dzww@vwN9HތFq`'c̻v8,Y䞊hFb l98#trdh;Opr+pdCվprG6Gē)t8,NG!Nl4sht_cj8Mv*p>j efȧHȈq4Y873dZFvӦ0fx29|Z. u'7ͻG{=#iw 9p=Y9E26y;sn{rrKfd7mvrܾ u'y?X+cP21f6n,˱}e!ES:yqSw80GrƘ큥Mg#yX 8Km9CaLb3?N6Ċg<~OƘ-/c.NˮMҎ;5Nw/Ąd`8fubsVJ)ݑ\jNTF;4Gr0wFD>X`ےSAɽfiqp %trI4O{Do ӝ;Sl' CZ!8HU_Uq_SDd'nZcfϴxZSUHkM8]x}tG*$+FNQAZ#T($X)!zJm7CdZ_t#94Fr5{pD'^xp&oUĹ'kl>|u8 GD Hɷټ,N: 䞪|p u͞^\/]QXX X X&MGF0wInmOpHjeK |"#1gUg)'p8iD3G_㜜ks8}srqNp59W:JQH+Z+-ԏ^Z!ΰc&tRVn&.)2-N|/6N=}\DS^M/XmUPlU= Rk )|;#8-Q$EJRpGf*/!Zh΀QJ=Tk=sk8>ZSj5[%wǀk R?~|WkPcvifAYZS;kd>r|)tz@ xHZd80 _G@7wIEe_n#(6w*8dyi|$[u$c` `K }RjeuMԾ> `4aYɚRukKڿwBu:=Y=*1̞1;pR`uRbue H6Nɯl݋8 !`+'J Z9bYMWֶ78.'= m xEq=kJ́ˑ_~JoRMCծaUJõ'5/ l@vrJU'ZTJ-8ޟ#Rimpֺ]-i*F.$cRhg@')2kð&Q$h %VF~H^xp\;C Z_Hz8Z7pRRd;Zf^|Z8#I4jb(CW(Z IJӀ,0:$l+ ^8 X Bjn!rȔہdHU"S%"GD6f`~ [q=Z)k5+"+V@Qghݭ-iFoZ'J̀"pRZF p6tSSXD#7E'OΠAzRjwxRZ:I4Y|x xˆ }ũ p\Di hjr!\br G{"ӌr>xq6#NݦX,D./ f&E?I CkZ?:q\vmp-RZb;"'"TZϲ#M!֯uo"38nh2t eهv8.hk?*Y-5޹.P,Ń+s{bbfsR)vkrAk}OvA߮ca^إRn2{Ȃ"2?ؘjB$z psK=L"PY\yEdj܏μ8A͔bZswi.:|ޟ׉ldsl֚CvpU+m)V.og#Kg`t9).; YH/g\Х(+ -X YR*߫N*l`7i`k-Rkߘn{-m[uSzRg .^ ?Ha)Klű}r:56r}v4rEZS09Y:fȮќRjA2Ek=+7(ş> 9ڝ;+F]i [Ȋgks/W,9RG;ϥ70 Όlې}R 7qLe/Mi. k|sW/E"KHIwc{ vl| ;T3; hg(& z{U;wȏ$ WP(,   U(NkJj+VJ/v8R^Eۍ_j牙SJ9x>Gs\TJ}<\e\rE{TB[wn߫{TdHN͖Zw6RJ}3eظǃ /P,z0QkC D@T g#ߓm6A[Xo"ٕȔ0 {ֺR1Z;ֱTh"NF^DePj27J眖ݗu"r2~zj' V $u8,ppTPd]b/)QUݏԘ>^.?@vDVJ9m)bt- JXNxdP:r@k2$eNݗ9 "&=$ Y/\ X쩙 h_AR>WJcKvju$&`R7`ZP)u$2B$($pͯ͝}mVH!$ΏvQ,It_}H_W<5N4s*-JmӁAc;jZߥ K:Y; Qk=O-#(ֺ2-ե ՕRxFH,oi;i?RJ](u'xHu|Y(r8^J, pc$vL怣 Z{R -"WٓR o3W di,|iv'Z(޲v@vKC4N`'w{ddw'[MA)u=r۷}&[H1RqHݙqF^8qIv꠵~ RHֈ(2"/?xٝlXN]VJB6;JuXDnFq ̯֏JH?TwTjcX/98VIrw/FƴZ`{"Əe* Hhd,^#SI4 6 \Ǽq v^^ 8VGv^xmD̸pe B'-S.GU(uHJ'C6U7Xv5{8>)H#'QC̱m'd]hK<l'Qe~]!#!C' p$0!ޗFBG*A4$*X)¯y}~!GֲMm٤U4YpLW$zN p%$``/HULōb{tXD Go8^xY.sdG]` g R8ҭaPGU=8^ H>e/xCq FF4D0vGt]4j^%^xED+9۶cT>5+X uh8C!#*iRE:#͡H}co>DG'TPJ-/̚fhZ 7''Kü ${ҹsVTH*@;L-)r#>PZOR k+ ,vj{/ѲԓRj: ֺRj>`;} q %f۶n@W IDAT[XYV)IR)Z[[:TvCz|ֺnRȆNZbVJ= >=ϑHT[7$r"G*'#F͏aHYu\IH'g/B[BtCQEBv@)ֺgsw[eY/] H̝MlRk!k=zkȬhUQ9X$M/,ܙW|NT7~m$DJ]SjI]R)1'w9o'7ɗ+R[&䋶*MC$ZV|}~*FvQJmփuHZ ;Vk]?ȾRUi9 Qp~<l~7pRj}K)uQ?x4m$Y[OW8 V_&5:xX,D%,oVIoHFeUʎ#iȃgbݥ|7/xrMQ>ld_t A$ڥ$nݣ݉:OkvNUGkXٱ։;d /ȉb)qP_!a D:#H@F<6,k+=G"qp$ޤKkԱDUZtuק(h3=t&Y:wx }I#SzPRA/XX?x m$xX|jpM3X,.[(*USAnṷ H65Z[֮: Gx8: ;p}4^Wwd'*"<5 @ ~k͖~yw[$w^8,]Jw'}>d) "xŃoDv6;E"I;zBn  r%K)Um ;ɅW)Z*TJ WX]w+6͹K`BTTJv[^dG5hdFFs2'p8Jp O(M~}} X񯌈ֿb1&wTQx))??+uaR&;֗U image/svg+xml : BPF COMPILERCOLLECTION bpfcc-0.2.0+git0.02884a026/images/logo2.png000066400000000000000000000077331305314114400175050ustar00rootroot00000000000000PNG  IHDR|3ysBIT|d pHYs CtEXtSoftwarewww.inkscape.org<XIDATx{U}? !1JE<#-V"&%"cJbWCglxF7^J-19TRz* S)~T={@OS)^JCR|/@O!S)TRz*e\xCDcRvkcZ{2Da`?:jףΰ=f} "\|S,S\o}@= n(*țxR/ԂHQdK/wZ þNG}hh=`Db4k$_if5طT/Ķ{ + ![=aJ^|1{XUX7MV= 3KvL>я[IEɖ:U-V=se3"'("3TuElWuzcD : xN|8x* z[ImDD&ȑl3ty|X yB|Rc9GUIϻ! 9}Z /JҸJ'N,9==4U\eWzoI(I] hLTƞ}%i Tgzh`qCt3Www]qGT;8/I/=X`iSIm" Fd{0GU,V_`D7 ؾ[;d9pp~vt"u1zI/n>`E(0#Inzm1;ï\7x`yꜵ _R-~"2f)TumJw4>dcf86IuB@U-ڜi^oꊗ+Uu86WG~ vd`ID^; (.>_I" I=&BIۋ,b<0Iea#4^wS6{c%rAtpe[e30+5VOg3zķHUo.0pKDmUM<< ؄l6GӀ2XyZv1[0 6#6>s0mQb<PE';gFDG sy#.CňXyylL* f6`ށoX zO &ųz ^3U~v&%wcv|M„cȕvܽ/ nPAP\ TMRUl/74~4羧0vN.0=.sqQ= Tl &i iT욤qn/EɤdZE<쫪-_YV5 ߋ4pu+vwRr"g W=gaY G&i{gA4 裘ɿ(y=1-u6 Iu:051~< ڎjVRkh d)s:4 7U]vO5Iơ*9w{QqdT\ p-p#[u`Цq%%il3?JmqTM5_ԁi0f6jp4 ?mp#cvM^k}eg+"#PdC{6[j2\Ge6{w-ޤve26J'H.Z ęEq!9a0uyLd07\E)N"}Hٶjm p2ti(V-l $5_JzIU;` =`R^Z ƶ9b{ =uv^H`{$@v8./ry.gvU;Q6.oCe[FUWeEbJ6p29L:0qJV 6 rjyETa6BCmԂ,Gf9poBF-PM*+-hkp!lԆ,l]yX""}=!"2ˁ-kY  onE$7yz]q S{0"LiLoTmb1pe 1u~ ,Sڗs!ilq< p˶y/"2&+Y:ѓ4v_[1ly%IO"YFw)pP}-Vmm؏l+u-pvMUx#;Cm=gBvCGUjwѕ;:aMs`yULyy] 0rdK+RȻ2#P&apd.W"29E`DSٚ Nt/"bʐkLd֭..Tc h&mwADb^ɍWCJd30l_cF;slߋUF] p,A;10 .YɼH̯"r8&J oHyRE@D A4Rm4bqUDvC)ܺTU-s;{aiAtp n k_fzW'i :'IOzRDXؗ~I@UC֘'9a %iv]Ʒ?TıD$~dJUTn`D`CVY얤i粉1y:/[1ĺ;̉rc20L/2p86bv݇WF1ƃzW^|cL-ax.)l;PUO w^ 8י4E9jm?V7q; [X\D_}.pzvγ=ȅn۸XU_iMcmTᾐmJ0:Ѫ_'NMҸ:m"r50[?-∈L9 \-!Fto~9+Q `-aB`g ,ZD,lsyj/eo롉Tu^|h̺n q!dxfM'cۛY|@UOU|y{R:ڎPկa6mFCCv_NLn@#MSĦKr +xw^som i`ZӁX/$iSLlGV٪R9z(lTt`oU ^[J$iu$/+!U]eՆ^@Uo{lp=CJ&i)_,I㳪v p5=cC'1Tw.IV˲aC-Ñ4ސ)P|%ͬH8wRSS&i|o I_ɔXɶ{a)ph\#]{$c-וC6bR"ZߐY&hr*&'^G$i 83 +0/?Y?ylz,Iٴ#:xs&B$i8% ˁNIK6H'i)$ik`nDƔEJWf $i\Bp(:iSc vL$y=3]TLQL#9x1=GSqW"/IENDB`bpfcc-0.2.0+git0.02884a026/images/logo2.svg000066400000000000000000000122221305314114400175050ustar00rootroot00000000000000 image/svg+xml bpfcc-0.2.0+git0.02884a026/man/000077500000000000000000000000001305314114400152515ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/man/CMakeLists.txt000066400000000000000000000000271305314114400200100ustar00rootroot00000000000000add_subdirectory(man8) bpfcc-0.2.0+git0.02884a026/man/man8/000077500000000000000000000000001305314114400161145ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/man/man8/CMakeLists.txt000066400000000000000000000001141305314114400206500ustar00rootroot00000000000000file(GLOB FILES *.8) install(FILES ${FILES} DESTINATION share/bcc/man/man8) bpfcc-0.2.0+git0.02884a026/man/man8/argdist.8000066400000000000000000000176351305314114400176560ustar00rootroot00000000000000.TH argdist 8 "2016-02-11" "USER COMMANDS" .SH NAME argdist \- Trace a function and display a histogram or frequency count of its parameter values. Uses Linux eBPF/bcc. .SH SYNOPSIS .B argdist [-h] [-p PID] [-z STRING_SIZE] [-i INTERVAL] [-n COUNT] [-v] [-T TOP] [-H specifier] [-C specifier] [-I header] .SH DESCRIPTION argdist attaches to function entry and exit points, collects specified parameter values, and stores them in a histogram or a frequency collection that counts the number of times a parameter value occurred. It can also filter parameter values and instrument multiple entry points at once. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-p PID Trace only functions in the process PID. .TP \-z STRING_SIZE When collecting string arguments (of type char*), collect up to STRING_SIZE characters. Longer strings will be truncated. .TP \-i INTERVAL Print the collected data every INTERVAL seconds. The default is 1 second. .TP \-n NUMBER Print the collected data COUNT times and then exit. .TP \-v Display the generated BPF program, for debugging purposes. .TP \-T TOP When collecting frequency counts, display only the top TOP entries. .TP \-H specifiers, \-C specifiers One or more probe specifications that instruct argdist which functions to probe, which parameters to collect, how to aggregate them, and whether to perform any filtering. See SPECIFIER SYNTAX below. .TP \-I header One or more header files that should be included in the BPF program. This enables the use of structure definitions, enumerations, and constants that are available in these headers. You should provide the same path you would include in the BPF program, e.g. 'linux/blkdev.h' or 'linux/time.h'. Note: in many cases, argdist will deduce the necessary header files automatically. .SH SPECIFIER SYNTAX The general specifier syntax is as follows: .B {p,r,t,u}:{[library],category}:function(signature)[:type[,type...]:expr[,expr...][:filter]][#label] .TP .B {p,r,t,u} Probe type \- "p" for function entry, "r" for function return, "t" for kernel tracepoint, "u" for USDT probe; \-H for histogram collection, \-C for frequency count. Indicates where to place the probe and whether the probe should collect frequency count information, or aggregate the collected values into a histogram. Counting probes will collect the number of times every parameter value was observed, whereas histogram probes will collect the parameter values into a histogram. Only integral types can be used with histogram probes; there is no such limitation for counting probes. .TP .B [library] Library containing the probe. Specify the full path to the .so or executable file where the function to probe resides. Alternatively, you can specify just the lib name: for example, "c" refers to libc. If no library name is specified, the kernel is assumed. .TP .B category The category of the kernel tracepoint. For example: net, sched, block. .TP .B function(signature) The function to probe, and its signature. The function name must match exactly for the probe to be placed. The signature, on the other hand, is only required if you plan to collect parameter values based on that signature. For example, if you only want to collect the first parameter, you don't have to specify the rest of the parameters in the signature. When capturing kernel tracepoints, this should be the name of the event, e.g. net_dev_start_xmit. The signature for kernel tracepoints should be empty. When capturing USDT probes, this should be the name of the probe, e.g. reloc_complete. The signature for USDT probes should be empty. .TP .B [type[,type...]] The type(s) of the expression(s) to capture. This is the type of the keys in the histogram or raw event collection that are collected by the probes. .TP .B [expr[,expr...]] The expression(s) to capture. These are the values that are assigned to the histogram or raw event collection. You may use the parameters directly, or valid C expressions that involve the parameters, such as "size % 10". Tracepoints may access a special structure called "args" that is formatted according to the tracepoint format (which you can obtain using tplist). For example, the block:block_rq_complete tracepoint can access args->nr_sector. USDT probes may access the arguments defined by the tracing program in the special arg1, arg2, ... variables. To obtain their types, use the tplist tool. Return probes can use the argument values received by the function when it was entered, through the $entry(paramname) special variable. Return probes can also access the function's return value in $retval, and the function's execution time in nanoseconds in $latency. Note that adding the $latency or $entry(paramname) variables to the expression will introduce an additional probe at the function's entry to collect this data, and therefore introduce additional overhead. .TP .B [filter] The filter applied to the captured data. Only parameter values that pass the filter will be collected. This is any valid C expression that refers to the parameter values, such as "fd == 1 && length > 16". The $entry, $retval, and $latency variables can be used here as well, in return probes. The filter expression may also use the STRCMP pseudo-function to compare a predefined string to a string argument. For example: STRCMP("test.txt", file). The order of arguments is important: the first argument MUST be a quoted literal string, and the second argument can be a runtime string. .TP .B [label] The label that will be displayed when printing the probed values. By default, this is the probe specifier. .SH EXAMPLES .TP Print a histogram of allocation sizes passed to kmalloc: # .B argdist -H 'p::__kmalloc(u64 size):u64:size' .TP Print a count of how many times process 1005 called malloc with an allocation size of 16 bytes: # .B argdist -p 1005 -C 'p:c:malloc(size_t size):size_t:size:size==16' .TP Snoop on all strings returned by gets(): # .B argdist -C 'r:c:gets():char*:$retval' .TP Print a histogram of read sizes that were longer than 1ms: # .B argdist -H 'r::__vfs_read(void *file, void *buf, size_t count):size_t:$entry(count):$latency > 1000000' .TP Print frequency counts of how many times writes were issued to a particular file descriptor number, in process 1005: # .B argdist -p 1005 -C 'p:c:write(int fd):int:fd' .TP Print a histogram of error codes returned by read() in process 1005: # .B argdist -p 1005 -H 'r:c:read()' .TP Print a histogram of buffer sizes passed to write() across all processes, where the file descriptor was 1 (STDOUT): # .B argdist -H 'p:c:write(int fd, const void *buf, size_t count):size_t:count:fd==1' .TP Count fork() calls in libc across all processes, grouped by pid: # .B argdist -C 'p:c:fork():int:$PID;fork per process' .TP Print histogram of number of sectors in completing block I/O requests: # .B argdist -H 't:block:block_rq_complete():u32:nr_sector' .TP Aggregate interrupts by interrupt request (IRQ): # .B argdist -C 't:irq:irq_handler_entry():int:irq' .TP Print the functions used as thread entry points and how common they are: # .B argdist -C 'u:pthread:pthread_start():u64:arg2' -p 1337 .TP Print histograms of sleep() and nanosleep() parameter values: # .B argdist -H 'p:c:sleep(u32 seconds):u32:seconds' -H 'p:c:nanosleep(struct timespec *req):long:req->tv_nsec' .TP Spy on writes to STDOUT performed by process 2780, up to a string size of 120 characters: # .B argdist -p 2780 -z 120 -C 'p:c:write(int fd, char* buf, size_t len):char*:buf:fd==1' .TP Group files being read from and the read sizes from __vfs_read: # .B argdist -C 'p::__vfs_read(struct file *file, void *buf, size_t count):char*,size_t:file->f_path.dentry->d_iname,count:file->f_path.dentry->d_iname[0]!=0' .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein bpfcc-0.2.0+git0.02884a026/man/man8/bashreadline.8000066400000000000000000000025151305314114400206310ustar00rootroot00000000000000.TH bashreadline 8 "2016-01-28" "USER COMMANDS" .SH NAME bashreadline \- Print entered bash commands system wide. Uses Linux eBPF/bcc. .SH SYNOPSIS .B bashreadline .SH DESCRIPTION bashreadline traces the return of the readline() function using uprobes, to show the bash commands that were entered interactively, system wide. The entered command may fail: this is just showing what was entered. This program is also a basic example of eBPF/bcc and uprobes. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Trace bash commands system wide: # .B bashreadline .SH FIELDS .TP TIME Time of the command (HH:MM:SS). .TP PID Process ID of the bash shell. .TP COMMAND Entered command. .SH OVERHEAD As the rate of interactive bash commands is expected to be very low (<<100/s), the overhead of this program is expected to be negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 opensnoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/biolatency.8000066400000000000000000000045071305314114400203440ustar00rootroot00000000000000.TH biolatency 8 "2015-08-20" "USER COMMANDS" .SH NAME biolatency \- Summarize block device I/O latency as a histogram. .SH SYNOPSIS .B biolatency [\-h] [\-T] [\-Q] [\-m] [\-D] [interval [count]] .SH DESCRIPTION biolatency traces block device I/O (disk I/O), and records the distribution of I/O latency (time). This is printed as a histogram either on Ctrl-C, or after a given interval in seconds. The latency of the disk I/O is measured from the issue to the device to its completion. A \-Q option can be used to include time queued in the kernel. This tool uses in-kernel eBPF maps for storing timestamps and the histogram, for efficiency. This works by tracing various kernel blk_*() functions using dynamic tracing, and will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS \-h Print usage message. .TP \-T Include timestamps on output. .TP \-m Output histogram in milliseconds. .TP \-D Print a histogram per disk device. .TP interval Output interval, in seconds. .TP count Number of outputs. .SH EXAMPLES .TP Summarize block device I/O latency as a histogram: # .B biolatency .TP Print 1 second summaries, 10 times: # .B biolatency 1 10 .TP Print 1 second summaries, using milliseconds as units for the histogram, and include timestamps on output: # .B biolatency \-mT 1 .TP Include OS queued time in I/O time: # .B biolatency \-Q .TP Show a latency histogram for each disk device separately: # .B biolatency \-D .SH FIELDS .TP usecs Microsecond range .TP msecs Millisecond range .TP count How many I/O fell into this range .TP distribution An ASCII bar chart to visualize the distribution (count column) .SH OVERHEAD This traces kernel functions and maintains in-kernel timestamps and a histogram, which are asynchronously copied to user-space. This method is very efficient, and the overhead for most storage I/O rates (< 10k IOPS) should be negligible. If you have a higher IOPS storage environment, test and quantify the overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 biosnoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/biosnoop.8000066400000000000000000000043071305314114400200410ustar00rootroot00000000000000.TH biosnoop 8 "2015-09-16" "USER COMMANDS" .SH NAME biosnoop \- Trace block device I/O and print details incl. issuing PID. .SH SYNOPSIS .B biosnoop .SH DESCRIPTION This tools traces block device I/O (disk I/O), and prints a one-line summary for each I/O showing various details. These include the latency from the time of issue to the device to its completion, and the PID and process name from when the I/O was first created (which usually identifies the responsible process). This uses in-kernel eBPF maps to cache process details (PID and comm) by I/O request, as well as a starting timestamp for calculating I/O latency. This works by tracing various kernel blk_*() functions using dynamic tracing, and will need updating to match any changes to these functions. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Trace all block device I/O and print a summary line per I/O: # .B biosnoop .SH FIELDS .TP TIME(s) Time of the I/O, in seconds since the first I/O was seen. .TP COMM Cached process name, if present. This usually (but isn't guaranteed) to identify the responsible process for the I/O. .TP PID Cached process ID, if present. This usually (but isn't guaranteed) to identify the responsible process for the I/O. .TP DISK Disk device name. .TP T Type of I/O: R = read, W = write. This is a simplification. .TP SECTOR Device sector for the I/O. .TP BYTES Size of the I/O, in bytes. .TP LAT(ms) Time for the I/O (latency) from the issue to the device, to its completion, in milliseconds. .SH OVERHEAD Since block device I/O usually has a relatively low frequency (< 10,000/s), the overhead for this tool is expected to be negligible. For high IOPS storage systems, test and quantify before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 disksnoop(8), iostat(1) bpfcc-0.2.0+git0.02884a026/man/man8/biotop.8000066400000000000000000000051111305314114400174770ustar00rootroot00000000000000.TH biotop 8 "2016-02-06" "USER COMMANDS" .SH NAME biotop \- Block device (disk) I/O by process top. .SH SYNOPSIS .B biotop [\-h] [\-C] [\-r MAXROWS] [interval] [count] .SH DESCRIPTION This is top for disks. This traces block device I/O (disk I/O), and prints a per-process summary every interval (by default, 1 second). The summary is sorted on the top disk consumers by throughput (Kbytes). The PID and process name shown are measured from when the I/O was first created, which usually identifies the responsible process. For efficiency, this uses in-kernel eBPF maps to cache process details (PID and comm) by I/O request, as well as a starting timestamp for calculating I/O latency, and the final summary. This works by tracing various kernel blk_*() functions using dynamic tracing, and will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-C Don't clear the screen. .TP \-r MAXROWS Maximum number of rows to print. Default is 20. .TP \-p PID Trace this PID only. .TP interval Interval between updates, seconds. .TP count Number of interval summaries. .SH EXAMPLES .TP Summarize block device I/O by process, 1 second screen refresh: # .B biotop .TP Don't clear the screen: # .B biotop -C .TP 5 second summaries, 10 times only: # .B biotop 5 10 .SH FIELDS .TP loadavg: The contents of /proc/loadavg .TP PID Cached process ID, if present. This usually (but isn't guaranteed) to identify the responsible process for the I/O. .TP COMM Cached process name, if present. This usually (but isn't guaranteed) to identify the responsible process for the I/O. .TP D Direction: R == read, W == write. This is a simplification. .TP MAJ Major device number. .TP MIN Minor device number. .TP DISK Disk device name. .TP I/O Number of I/O during the interval. .TP Kbytes Total Kbytes for these I/O, during the interval. .TP AVGms Average time for the I/O (latency) from the issue to the device, to its completion, in milliseconds. .SH OVERHEAD Since block device I/O usually has a relatively low frequency (< 10,000/s), the overhead for this tool is expected to be low or negligible. For high IOPS storage systems, test and quantify before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH INSPIRATION top(1) by William LeFebvre .SH SEE ALSO biosnoop(8), biolatency(8), iostat(1) bpfcc-0.2.0+git0.02884a026/man/man8/bitesize.8000066400000000000000000000025711305314114400200300ustar00rootroot00000000000000.TH bitesize 8 "2016-02-05" "USER COMMANDS" .SH NAME bitesize \- Summarize block device I/O size as a histogram \- Linux eBPF/bcc. .SH SYNOPSIS .B bitesize .SH DESCRIPTION Show I/O distribution for requested block sizes, by process name. This works by tracing block I/O kernel functions using dynamic tracing and prints a historgram of I/O size. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Count I/O size per process until Ctrl-C is hit: # .B bitesize .SH FIELDS .TP Kbtes Size in kilobytes of range .TP count How many I/O fell into this range .TP distribution An ASCII bar chart to visualize the distribution (count column) .SH OVERHEAD This traces kernel block I/O functions to update a histgroam, which are asynchronously copied to user-space. This method is very efficient, and the overhead for most storage I/O rates (< 10k IOPS) should be negligible. If you have a higher IOPS storage environment, test and quantify the overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Allan McAleavy .SH SEE ALSO https://github.com/brendangregg/systemtap-lwtools/blob/master/disk/bitesize-nd.stp bpfcc-0.2.0+git0.02884a026/man/man8/btrfsdist.8000066400000000000000000000041021305314114400202060ustar00rootroot00000000000000.TH btrfsdist 8 "2016-02-15" "USER COMMANDS" .SH NAME btrfsdist \- Summarize btrfs operation latency. Uses Linux eBPF/bcc. .SH SYNOPSIS .B btrfsdist [\-h] [\-T] [\-N] [\-d] [interval] [count] .SH DESCRIPTION This tool summarizes time (latency) spent in common btrfs file operations: reads, writes, opens, and syncs, and presents it as a power-of-2 histogram. It uses an in-kernel eBPF map to store the histogram for efficiency. Since this works by tracing the btrfs_file_operations interface functions, it will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Don't include timestamps on interval output. .TP \-m Output in milliseconds. .TP \-p PID Trace this PID only. .SH EXAMPLES .TP Trace btrfs operation time, and print a summary on Ctrl-C: # .B btrfsdist .TP Trace PID 181 only: # .B btrfsdist -p 181 .TP Print 1 second summaries, 10 times: # .B btrfsdist 1 10 .TP 1 second summaries, printed in milliseconds # .B btrfsdist \-m 1 .SH FIELDS .TP msecs Range of milliseconds for this bucket. .TP usecs Range of microseconds for this bucket. .TP count Number of operations in this time range. .TP distribution ASCII representation of the distribution (the count column). .SH OVERHEAD This adds low-overhead instrumentation to btrfs writes and fsyncs, as well as all system reads and opens (due to the current implementation of the btrfs_file_operations interface). Particularly, all reads and writes from the file system cache will incur extra overhead while tracing. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool may become noticeable. Measure and quantify before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 btrfsslower(8) bpfcc-0.2.0+git0.02884a026/man/man8/btrfsslower.8000066400000000000000000000064611305314114400205700ustar00rootroot00000000000000.TH btrfsslower 8 "2016-02-15" "USER COMMANDS" .SH NAME btrfsslower \- Trace slow btrfs file operations, with per-event details. .SH SYNOPSIS .B btrfsslower [\-h] [\-j] [\-p PID] [min_ms] .SH DESCRIPTION This tool traces common btrfs file operations: reads, writes, opens, and syncs. It measures the time spent in these operations, and prints details for each that exceeded a threshold. WARNING: See the OVERHEAD section. By default, a minimum millisecond threshold of 10 is used. If a threshold of 0 is used, all events are printed (warning: verbose). Since this works by tracing the btrfs_file_operations interface functions, it will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS \-p PID Trace this PID only. .TP min_ms Minimum I/O latency (duration) to trace, in milliseconds. Default is 10 ms. .SH EXAMPLES .TP Trace synchronous file reads and writes slower than 10 ms: # .B btrfsslower .TP Trace slower than 1 ms: # .B btrfsslower 1 .TP Trace slower than 1 ms, and output just the fields in parsable format (csv): # .B btrfsslower \-j 1 .TP Trace all file reads and writes (warning: the output will be verbose): # .B btrfsslower 0 .TP Trace slower than 1 ms, for PID 181 only: # .B btrfsslower \-p 181 1 .SH FIELDS .TP TIME(s) Time of I/O completion since the first I/O seen, in seconds. .TP COMM Process name. .TP PID Process ID. .TP T Type of operation. R == read, W == write, O == open, S == fsync. .TP OFF_KB File offset for the I/O, in Kbytes. .TP BYTES Size of I/O, in bytes. .TP LAT(ms) Latency (duration) of I/O, measured from when it was issued by VFS to the filesystem, to when it completed. This time is inclusive of block device I/O, file system CPU cycles, file system locks, run queue latency, etc. It's a more accurate measure of the latency suffered by applications performing file system I/O, than to measure this down at the block device interface. .TP FILENAME A cached kernel file name (comes from dentry->d_iname). .TP ENDTIME_us Completion timestamp, microseconds (\-j only). .TP OFFSET_b File offset, bytes (\-j only). .TP LATENCY_us Latency (duration) of the I/O, in microseconds (\-j only). .SH OVERHEAD This adds low-overhead instrumentation to btrfs writes and fsyncs, as well as all system reads and opens (due to the current implementation of the btrfs_file_operations interface). Particularly, all reads and writes from the file system cache will incur extra overhead while tracing. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool may become noticeable. Measure and quantify before use. If this continues to be a problem, consider switching to a tool that prints in-kernel summaries only, such as btrfsdist(8). .PP Note that the overhead of this tool should be less than fileslower(8), as this tool targets btrfs functions only, and not all file read/write paths (which can include socket I/O). .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 btrfsdist(8), biosnoop(8), funccount(8), fileslower(8) bpfcc-0.2.0+git0.02884a026/man/man8/cachestat.8000066400000000000000000000042101305314114400201410ustar00rootroot00000000000000.TH cachestat 8 "2016-01-30" "USER COMMANDS" .SH NAME cachestat \- Statistics for linux page cache hit/miss ratios. Uses Linux eBPF/bcc. .SH SYNOPSIS .B cachestat [-T] [interval [count]] .SH DESCRIPTION This traces four kernel functions and prints per-second summaries. This can be useful for general workload characterization, and looking for patterns in operation usage over time. This works by tracing kernel page cache functions using dynamic tracing, and will need updating to match any changes to these functions. Edit the script to customize which functions are traced. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Print summaries every five second: # .B cachestat .TP Print summaries every five seconds with timestamp: # .B cachestat -T .TP Print summaries each second: # .B cachestat 1 .TP Print output every five seconds, three times: # .B cachestat 5 3 .TP Print output with timestamp every five seconds, three times: # .B cachestat -T 5 3 .SH FIELDS .TP TIME Timestamp. .TP HITS Number of page cache hits. .TP MISSES Number of page cache misses. .TP DIRTIES Number of dirty pages added to the page cache. .TP READ_HIT% Read hit percent of page cache usage. .TP WRITE_HIT% Write hit percent of page cache usage. .TP BUFFERS_MB Buffers size taken from /proc/meminfo. .TP CACHED_MB Cached amount of data in current page cache taken from /proc/meminfo. .SH OVERHEAD This traces various kernel page cache functions and maintains in-kernel counts, which are asynchronously copied to user-space. While the rate of operations can be very high (>1G/sec) we can have up to 34% overhead, this is still a relatively efficient way to trace these events, and so the overhead is expected to be small for normal workloads. Measure in a test environment. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Allan McAleavy .SH SEE ALSO https://github.com/brendangregg/perf-tools/blob/master/fs/cachestat bpfcc-0.2.0+git0.02884a026/man/man8/cachetop.8000066400000000000000000000045251305314114400200010ustar00rootroot00000000000000.TH cachetop 8 "2016-01-30" "USER COMMANDS" .SH NAME cachetop \- Statistics for linux page cache hit/miss ratios per processes. Uses Linux eBPF/bcc. .SH SYNOPSIS .B cachetop [interval] .SH DESCRIPTION This traces four kernel functions and prints per-processes summaries every \fBinterval\fR seconds. This can be useful for processes workload characterization, and looking for patterns in operation usage over time. It provides a \fBtop\fR-like interface which by default sorts by \fBHITS\fR in ascending order. This works by tracing kernel page cache functions using dynamic tracing, and will need updating to match any changes to these functions. Edit the script to customize which functions are traced. Since this uses BPF, only the root user can use this tool. .SH KEYBINDINGS The following keybindings can be used to control the output of \fBcachetop\fR. .TP .B < Use the previous column for sorting. .TP .B > Use the next column for sorting. .TP .B r Toggle sorting order (default ascending). .TP .B q Quit cachetop. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Update summaries every five second: # .B cachetop .TP Print summaries each second: # .B cachetop 1 .SH FIELDS .TP PID Process ID of the process causing the cache activity. .TP UID User ID of the process causing the cache activity. .TP HITS Number of page cache hits. .TP MISSES Number of page cache misses. .TP DIRTIES Number of dirty pages added to the page cache. .TP READ_HIT% Read hit percent of page cache usage. .TP WRITE_HIT% Write hit percent of page cache usage. .TP BUFFERS_MB Buffers size taken from /proc/meminfo. .TP CACHED_MB Cached amount of data in current page cache taken from /proc/meminfo. .SH OVERHEAD This traces various kernel page cache functions and maintains in-kernel counts, which are asynchronously copied to user-space. While the rate of operations can be very high (>1G/sec) we can have up to 34% overhead, this is still a relatively efficient way to trace these events, and so the overhead is expected to be small for normal workloads. Measure in a test environment. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Emmanuel Bretelle .SH SEE ALSO cachestat (8) bpfcc-0.2.0+git0.02884a026/man/man8/capable.8000066400000000000000000000031531305314114400175760ustar00rootroot00000000000000.TH capable 8 "2016-09-13" "USER COMMANDS" .SH NAME capable \- Trace security capability checks (cap_capable()). .SH SYNOPSIS .B capable [\-h] [\-v] [\-p PID] .SH DESCRIPTION This traces security capability checks in the kernel, and prints details for each call. This can be useful for general debugging, and also security enforcement: determining a white list of capabilities an application needs. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF, bcc. .SH OPTIONS \-h USAGE message. .TP \-v Include non-audit capability checks. These are those deemed not interesting and not necessary to audit, such as CAP_SYS_ADMIN checks on memory allocation to affect the behavior of overcommit. .SH EXAMPLES .TP Trace all capability checks system-wide: # .B capable .TP Trace capability checks for PID 181: # .B capable \-p 181 .SH FIELDS .TP TIME(s) Time of capability check: HH:MM:SS. .TP UID User ID. .TP PID Process ID. .TP COMM Process name. CAP Capability number. NAME Capability name. See capabilities(7) for descriptions. .TP AUDIT Whether this was an audit event. Use \-v to include non-audit events. .SH OVERHEAD This adds low-overhead instrumentation to capability checks, which are expected to be low frequency, however, that depends on the application. Test in a lab environment before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 capabilities(7) bpfcc-0.2.0+git0.02884a026/man/man8/cpudist.8000066400000000000000000000054631305314114400176700ustar00rootroot00000000000000.TH cpudist 8 "2016-06-28" "USER COMMANDS" .SH NAME cpudist \- On- and off-CPU task time as a histogram. .SH SYNOPSIS .B cpudist [\-h] [-O] [\-T] [\-m] [\-P] [\-L] [\-p PID] [interval] [count] .SH DESCRIPTION This measures the time a task spends on the CPU before being descheduled, and shows the times as a histogram. Tasks that spend a very short time on the CPU can be indicative of excessive context-switches and poor workload distribution, and possibly point to a shared source of contention that keeps tasks switching in and out as it becomes available (such as a mutex). Similarly, the tool can also measure the time a task spends off-CPU before it is scheduled again. This can be helpful in identifying long blocking and I/O operations, or alternatively very short descheduling times due to short-lived locks or timers. This tool uses in-kernel eBPF maps for storing timestamps and the histogram, for efficiency. Despite this, the overhead of this tool may become significant for some workloads: see the OVERHEAD section. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-O Measure off-CPU time instead of on-CPU time. .TP \-T Include timestamps on output. .TP \-m Output histogram in milliseconds. .TP \-P Print a histogram for each PID (tgid from the kernel's perspective). .TP \-L Print a histogram for each TID (pid from the kernel's perspective). .TP \-p PID Only show this PID (filtered in kernel for efficiency). .TP interval Output interval, in seconds. .TP count Number of outputs. .SH EXAMPLES .TP Summarize task on-CPU time as a histogram: # .B cpudist .TP Summarize task off-CPU time as a histogram: # .B cpudist -O .TP Print 1 second summaries, 10 times: # .B cpudist 1 10 .TP Print 1 second summaries, using milliseconds as units for the histogram, and include timestamps on output: # .B cpudist \-mT 1 .TP Trace PID 186 only, 1 second summaries: # .B cpudist -P 185 1 .SH FIELDS .TP usecs Microsecond range .TP msecs Millisecond range .TP count How many times a task event fell into this range .TP distribution An ASCII bar chart to visualize the distribution (count column) .SH OVERHEAD This traces scheduler tracepoints, which can become very frequent. While eBPF has very low overhead, and this tool uses in-kernel maps for efficiency, the frequency of scheduler events for some workloads may be high enough that the overhead of this tool becomes significant. Measure in a lab environment to quantify the overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _example.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO pidstat(1), runqlat(8) bpfcc-0.2.0+git0.02884a026/man/man8/cpuunclaimed.8000066400000000000000000000067361305314114400206720ustar00rootroot00000000000000.TH cpuunclaimed 8 "2016-12-21" "USER COMMANDS" .SH NAME cpuunclaimed \- Sample CPU run queues and calculate unclaimed idle CPU. Uses Linux eBPF/bcc. .SH SYNOPSIS .B cpuunclaimed [\-T] [\-j] [\-J] [interval [count]] .SH DESCRIPTION This tool samples the length of the run queues and determine when there are idle CPUs, yet queued threads waiting their turn. It reports the amount of idle (yet unclaimed by waiting threads) CPU as a system-wide percentage. This situation can happen for a number of reasons: .IP - An application has been bound to some, but not all, CPUs, and has runnable threads that cannot migrate to other CPUs due to this configuration. .IP - CPU affinity: an optimization that leaves threads on CPUs where the CPU caches are warm, even if this means short periods of waiting while other CPUs are idle. The wait period is tunale (see sysctl, kernel.sched*). .IP - Scheduler bugs. .P An unclaimed idle of < 1% is likely to be CPU affinity, and not usually a cause for concern. By leaving the CPU idle, overall throughput of the system may be improved. This tool is best for identifying larger issues, > 2%, due to the coarseness of its 99 Hertz samples. This is an experimental tool that currently works by use of sampling to keep overheads low. Tool assumptions: .IP - CPU samples consistently fire around the same offset. There will sometimes be a lag as a sample is delayed by higher-priority interrupts, but it is assumed the subsequent samples will catch up to the expected offsets (as is seen in practice). You can use -J to inspect sample offsets. Some systems can power down CPUs when idle, and when they wake up again they may begin firing at a skewed offset: this tool will detect the skew, print an error, and exit. .IP - All CPUs are online (see ncpu). .P If this identifies unclaimed CPU, you can double check it by dumping raw samples (-j), as well as using other tracing tools to instrument scheduler events (although this latter approach has much higher overhead). Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Sample and calculate unclaimed idle CPUs, output every 1 second (default: # .B cpuunclaimed .TP Print 5 second summaries, 10 times: # .B cpuunclaimed 5 10 .TP Print 1 second summaries with timestamps: # .B cpuunclaimed \-T 1 .TP Raw dump of all samples (verbose), as comma-separated values: # .B cpuunclaimed \-j .SH FIELDS .TP %CPU CPU utilization as a system-wide percentage. .TP unclaimed idle Percentage of CPU resources that were idle when work was queued on other CPUs, as a system-wide percentage. .TP TIME Time (HH:MM:SS) .TP TIMESTAMP_ns Timestamp, nanoseconds. .TP CPU# CPU ID. .TP OFFSET_ns_CPU# Time offset that a sample fired within a sample group for this CPU. .SH OVERHEAD The overhead is expected to be low/negligible as this tool uses sampling at 99 Hertz (on all CPUs), which has a fixed and low cost, rather than sampling every scheduler event as many other approaches use (which can involve instrumenting millions of events per second). Sampled CPUs, run queue lengths, and timestamps are written to ring buffers that are periodically read by user space for reporting. Measure overhead in a test environment. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 runqlen(8) bpfcc-0.2.0+git0.02884a026/man/man8/dbslower.8000066400000000000000000000042641305314114400200340ustar00rootroot00000000000000.TH dbslower 8 "2017-02-15" "USER COMMANDS" .SH NAME dbslower \- Trace MySQL/PostgreSQL server queries slower than a threshold. .SH SYNOPSIS .B dbslower [-v] [-p PID [PID ...]] [-m THRESHOLD] {mysql,postgres} .SH DESCRIPTION This traces queries served by a MySQL or PostgreSQL server, and prints those that exceed a latency (query time) threshold. By default a threshold of 1 ms is used. This uses User Statically-Defined Tracing (USDT) probes, a feature added to MySQL and PostgreSQL for DTrace support, but which may not be enabled on a given installation. See requirements. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF, bcc, and MySQL server with USDT probe support (when configuring the build: \-DENABLE_DTRACE=1) or PostgreSQL server with USDT probe support (when configuring the build: \-\-enable-dtrace). .SH OPTIONS \-h Print usage message. .TP \-p PID Trace this PID. If no PID is specified, the tool will attempt to automatically detect the MySQL or PostgreSQL processes running on the system. .TP \-m THRESHOLD Minimum query latency (duration) to trace, in milliseconds. Default is 1 ms. .TP {mysql,postgres} The database engine to trace. .SH EXAMPLES .TP Trace MySQL server queries slower than 1 ms: # .B dbslower mysql .TP Trace slower than 10 ms for PostgreSQL in process 408: # .B dbslower postgres -p 408 -m 10 .SH FIELDS .TP TIME(s) Time of query start, in seconds. .TP PID Process ID of the traced server. .TP MS Milliseconds for the query, from start to end. .TP QUERY Query string, truncated to 256 characters. .SH OVERHEAD This adds low-overhead instrumentation to queries, and only emits output data from kernel to user-level if they query exceeds the threshold. If the server query rate is less than 1,000/sec, the overhead is expected to be negligible. If the query rate is higher, test to gauge overhead. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein, Brendan Gregg .SH SEE ALSO biosnoop(8), mysqld_qslower(8), dbstat(8) bpfcc-0.2.0+git0.02884a026/man/man8/dbstat.8000066400000000000000000000043621305314114400174730ustar00rootroot00000000000000.TH dbstat 8 "2017-02-15" "USER COMMANDS" .SH NAME dbstat \- Collect histograms of MySQL/PostgreSQL query latencies. .SH SYNOPSIS . B dbstat [-v] [-p PID [PID ...]] [-m THRESHOLD] [-u] [-i INTERVAL] {mysql,postgres} .SH DESCRIPTION This traces queries served by a MySQL or PostgreSQL server, and collects a histogram of query latencies. The histogram is printed at the end of collection, or at specified intervals. This uses User Statically-Defined Tracing (USDT) probes, a feature added to MySQL and PostgreSQL for DTrace support, but which may not be enabled on a given installation. See requirements. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF, bcc, and MySQL server with USDT probe support (when configuring the build: \-DENABLE_DTRACE=1) or PostgreSQL server with USDT probe support (when configuring the build: \-\-enable-dtrace). .SH OPTIONS \-h Print usage message. .TP \-p PID Trace this PID. If no PID is specified, the tool will attempt to automatically detect the MySQL or PostgreSQL processes running on the system. .TP \-m THRESHOLD Minimum query latency (duration) to trace, in milliseconds. Default is all queries. .TP \-u Display query latencies in microseconds (default: milliseconds). .TP \-i INTERVAL Print summaries (histograms) at this interval, specified in seconds. .TP {mysql,postgres} The database engine to trace. .SH EXAMPLES .TP Display histogram of MySQL query latencies: # .B dbstat mysql .TP Display histogram of PostgreSQL query latencies slower than 10ms in pid 408: # .B dbstat postgres -p 408 -m 10 .TP Display histogram of PostgreSQL query latencies at 3-second intervals: # .B dbstat postgres -i 3 .SH OVERHEAD This adds low-overhead instrumentation to queries, and only emits output data from kernel to user-level if they query exceeds the threshold. If the server query rate is less than 1,000/sec, the overhead is expected to be negligible. If the query rate is higher, test to gauge overhead. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO dbslower(8) bpfcc-0.2.0+git0.02884a026/man/man8/dcsnoop.8000066400000000000000000000041371305314114400176570ustar00rootroot00000000000000.TH dcsnoop 8 "2016-02-10" "USER COMMANDS" .SH NAME dcsnoop \- Trace directory entry cache (dcache) lookups. Uses Linux eBPF/bcc. .SH SYNOPSIS .B dcsnoop [\-h] [\-a] .SH DESCRIPTION By default, this traces every failed dcache lookup (cache miss), and shows the process performing the lookup and the filename requested. A \-a option can be used to show all lookups, not just failed ones. The output of this tool can be verbose, and is intended for further investigations of dcache performance beyond dcstat(8), which prints per-second summaries. This uses kernel dynamic tracing of the d_lookup() function, and will need and will need updating to match any changes to this function. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-a Trace references, not just failed lookups. .SH EXAMPLES .TP Trace failed dcache lookups: # .B dcsnoop .TP Trace all dcache lookups: # .B dcsnoop \-a .SH FIELDS .TP TIME(s) Time of lookup, in seconds. .TP PID Process ID. .TP COMM Process name. .TP T Type: R == reference (only visible with \-a), M == miss. A miss will print two lines, one for the reference, and one for the miss. .TP FILE The file name component that was being looked up. This contains trailing pathname components (after '/'), which will be the subject of subsequent lookups. .SH OVERHEAD File name lookups can be frequent (depending on the workload), and this tool prints a line for each failed lookup, and with \-a, each reference as well. The output may be verbose, and the incurred overhead, while optimized to some extent, may still be from noticeable to significant. This is only really intended for deeper investigations beyond dcstat(8), when absolutely necessary. Measure and quantify the overhead in a test environment before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 dcstat(1) bpfcc-0.2.0+git0.02884a026/man/man8/dcstat.8000066400000000000000000000031661305314114400174750ustar00rootroot00000000000000.TH dcstat 8 "2016-02-09" "USER COMMANDS" .SH NAME dcstat \- Directory entry cache (dcache) stats. Uses Linux eBPF/bcc. .SH SYNOPSIS .B dcstat [interval [count]] .SH DESCRIPTION The Linux directory entry cache (dcache) improves the performance of file and directory name lookups. This tool provides per-second summary statistics of dcache performance. This uses kernel dynamic tracing of kernel functions, lookup_fast() and d_lookup(), which will need to be modified to match kernel changes. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Print summaries each second: # .B dcstat .TP Print output every five seconds, three times: # .B dcstat 5 3 .SH FIELDS .TP REFS/s Number dcache lookups (references) per second. .TP SLOW/s Number of dcache lookups that failed the lookup_fast() path and executed the lookup_slow() path instead. .TP MISS/s Number of dcache misses (failed both fast and slow lookups). .TP HIT% Percentage of dcache hits over total references. .SH OVERHEAD The overhead depends on the frequency of file and directory name lookups. While the per-event overhead is low, some applications may make over 100k lookups per second, and the low per-event overhead will begin to add up, and could begin to be measurable (over 10% CPU usage). Measure in a test environment. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 dcsnoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/deadlock_detector.8000066400000000000000000000116541305314114400216530ustar00rootroot00000000000000.TH deadlock_detector 8 "2017-02-01" "USER COMMANDS" .SH NAME deadlock_detector \- Find potential deadlocks (lock order inversions) in a running program. .SH SYNOPSIS .B deadlock_detector [\-h] [\--binary BINARY] [\--dump-graph DUMP_GRAPH] .B [\--verbose] [\--lock-symbols LOCK_SYMBOLS] .B [\--unlock-symbols UNLOCK_SYMBOLS] .B pid .SH DESCRIPTION deadlock_detector finds potential deadlocks in a running process. The program attaches uprobes on `pthread_mutex_lock` and `pthread_mutex_unlock` by default to build a mutex wait directed graph, and then looks for a cycle in this graph. This graph has the following properties: - Nodes in the graph represent mutexes. - Edge (A, B) exists if there exists some thread T where lock(A) was called and lock(B) was called before unlock(A) was called. If there is a cycle in this graph, this indicates that there is a lock order inversion (potential deadlock). If the program finds a lock order inversion, the program will dump the cycle of mutexes, dump the stack traces where each mutex was acquired, and then exit. This program can only find potential deadlocks that occur while the program is tracing the process. It cannot find deadlocks that may have occurred before the program was attached to the process. This tool does not work for shared mutexes or recursive mutexes. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc .SH OPTIONS .TP \-h, --help show this help message and exit .TP \--binary BINARY If set, trace the mutexes from the binary at this path. For statically-linked binaries, this argument is not required. For dynamically-linked binaries, this argument is required and should be the path of the pthread library the binary is using. Example: /lib/x86_64-linux-gnu/libpthread.so.0 .TP \--dump-graph DUMP_GRAPH If set, this will dump the mutex graph to the specified file. .TP \--verbose Print statistics about the mutex wait graph. .TP \--lock-symbols LOCK_SYMBOLS Comma-separated list of lock symbols to trace. Default is pthread_mutex_lock. These symbols cannot be inlined in the binary. .TP \--unlock-symbols UNLOCK_SYMBOLS Comma-separated list of unlock symbols to trace. Default is pthread_mutex_unlock. These symbols cannot be inlined in the binary. .TP pid Pid to trace .SH EXAMPLES .TP Find potential deadlocks in PID 181. The --binary argument is not needed for \ statically-linked binaries. # .B deadlock_detector 181 .TP Find potential deadlocks in PID 181. If the process was created from a \ dynamically-linked executable, the --binary argument is required and must be \ the path of the pthread library: # .B deadlock_detector 181 --binary /lib/x86_64-linux-gnu/libpthread.so.0 .TP Find potential deadlocks in PID 181. If the process was created from a \ statically-linked executable, optionally pass the location of the binary. \ On older kernels without https://lkml.org/lkml/2017/1/13/585, binaries that \ contain `:` in the path cannot be attached with uprobes. As a workaround, we \ can create a symlink to the binary, and provide the symlink name instead with \ the `--binary` option: # .B deadlock_detector 181 --binary /usr/local/bin/lockinversion .TP Find potential deadlocks in PID 181 and dump the mutex wait graph to a file: # .B deadlock_detector 181 --dump-graph graph.json .TP Find potential deadlocks in PID 181 and print mutex wait graph statistics: # .B deadlock_detector 181 --verbose .TP Find potential deadlocks in PID 181 with custom mutexes: # .B deadlock_detector 181 .B --lock-symbols custom_mutex1_lock,custom_mutex2_lock .B --unlock_symbols custom_mutex1_unlock,custom_mutex2_unlock .SH OUTPUT This program does not output any fields. Rather, it will keep running until it finds a potential deadlock, or the user hits Ctrl-C. If the program finds a potential deadlock, it will output the stack traces and lock order inversion in the following format and exit: .TP Potential Deadlock Detected! .TP Cycle in lock order graph: Mutex M0 => Mutex M1 => Mutex M0 .TP Mutex M1 acquired here while holding Mutex M0 in Thread T: .B [stack trace] .TP Mutex M0 previously acquired by the same Thread T here: .B [stack trace] .TP Mutex M0 acquired here while holding Mutex M1 in Thread S: .B [stack trace] .TP Mutex M1 previously acquired by the same Thread S here: .B [stack trace] .TP Thread T created by Thread R here: .B [stack trace] .TP Thread S created by Thread Q here: .B [stack trace] .SH OVERHEAD This traces all mutex lock and unlock events and all thread creation events on the traced process. The overhead of this can be high if the process has many threads and mutexes. You should only run this on a process where the slowdown is acceptable. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Kenny Yu bpfcc-0.2.0+git0.02884a026/man/man8/execsnoop.8000066400000000000000000000043331305314114400202130ustar00rootroot00000000000000.TH execsnoop 8 "2016-02-07" "USER COMMANDS" .SH NAME execsnoop \- Trace new processes via exec() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B execsnoop [\-h] [\-t] [\-x] [\-n NAME] .SH DESCRIPTION execsnoop traces new processes, showing the filename executed and argument list. It works by traces the execve() system call (commonly used exec() variant). This catches new processes that follow the fork->exec sequence, as well as processes that re-exec() themselves. Some applications fork() but do not exec(), eg, for worker processes, which won't be included in the execsnoop output. This works by tracing the kernel sys_execve() function using dynamic tracing, and will need updating to match any changes to this function. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-t Include a timestamp column. .TP \-x Include failed exec()s .TP \-n NAME Only print command lines matching this name (regex), matched anywhere .SH EXAMPLES .TP Trace all exec() syscalls: # .B execsnoop .TP Trace all exec() syscalls, and include timestamps: # .B execsnoop \-t .TP Include failed exec()s: # .B execsnoop \-x .TP Only trace exec()s where the filename or arguments contain "mount": # .B opensnoop \-n mount .SH FIELDS .TP TIME(s) Time of exec() return, in seconds. .TP PCOMM Parent process/command name. .TP PID Process ID .TP RET Return value of exec(). 0 == successs. Failures are only shown when using the \-x option. .TP ARGS Filename for the exec(), followed be up to 19 arguments. An ellipsis "..." is shown if the argument list is known to be truncated. .SH OVERHEAD This traces the kernel execve function and prints output for each event. As the rate of this is generally expected to be low (< 1000/s), the overhead is also expected to be negligible. If you have an application that is calling a high rate of exec()s, then test and understand overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 opensnoop(1) bpfcc-0.2.0+git0.02884a026/man/man8/ext4dist.8000066400000000000000000000036211305314114400177570ustar00rootroot00000000000000.TH ext4dist 8 "2016-02-12" "USER COMMANDS" .SH NAME ext4dist \- Summarize ext4 operation latency. Uses Linux eBPF/bcc. .SH SYNOPSIS .B ext4dist [\-h] [\-T] [\-N] [\-d] [interval] [count] .SH DESCRIPTION This tool summarizes time (latency) spent in common ext4 file operations: reads, writes, opens, and syncs, and presents it as a power-of-2 histogram. It uses an in-kernel eBPF map to store the histogram for efficiency. Since this works by tracing the ext4_file_operations interface functions, it will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Don't include timestamps on interval output. .TP \-m Output in milliseconds. .TP \-p PID Trace this PID only. .SH EXAMPLES .TP Trace ext4 operation time, and print a summary on Ctrl-C: # .B ext4dist .TP Trace PID 181 only: # .B ext4dist -p 181 .TP Print 1 second summaries, 10 times: # .B ext4dist 1 10 .TP 1 second summaries, printed in milliseconds # .B ext4dist \-m 1 .SH FIELDS .TP msecs Range of milliseconds for this bucket. .TP usecs Range of microseconds for this bucket. .TP count Number of operations in this time range. .TP distribution ASCII representation of the distribution (the count column). .SH OVERHEAD This adds low-overhead instrumentation to these ext4 operations, including reads and writes from the file system cache. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool may become noticeable. Measure and quantify before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 ext4snoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/ext4slower.8000066400000000000000000000062161305314114400203320ustar00rootroot00000000000000.TH ext4slower 8 "2016-02-11" "USER COMMANDS" .SH NAME ext4slower \- Trace slow ext4 file operations, with per-event details. .SH SYNOPSIS .B ext4slower [\-h] [\-j] [\-p PID] [min_ms] .SH DESCRIPTION This tool traces common ext4 file operations: reads, writes, opens, and syncs. It measures the time spent in these operations, and prints details for each that exceeded a threshold. WARNING: See the OVERHEAD section. By default, a minimum millisecond threshold of 10 is used. If a threshold of 0 is used, all events are printed (warning: verbose). Since this works by tracing the ext4_file_operations interface functions, it will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS \-p PID Trace this PID only. .TP min_ms Minimum I/O latency (duration) to trace, in milliseconds. Default is 10 ms. .SH EXAMPLES .TP Trace synchronous file reads and writes slower than 10 ms: # .B ext4slower .TP Trace slower than 1 ms: # .B ext4slower 1 .TP Trace slower than 1 ms, and output just the fields in parsable format (csv): # .B ext4slower \-j 1 .TP Trace all file reads and writes (warning: the output will be verbose): # .B ext4slower 0 .TP Trace slower than 1 ms, for PID 181 only: # .B ext4slower \-p 181 1 .SH FIELDS .TP TIME(s) Time of I/O completion since the first I/O seen, in seconds. .TP COMM Process name. .TP PID Process ID. .TP T Type of operation. R == read, W == write, O == open, S == fsync. .TP OFF_KB File offset for the I/O, in Kbytes. .TP BYTES Size of I/O, in bytes. .TP LAT(ms) Latency (duration) of I/O, measured from when it was issued by VFS to the filesystem, to when it completed. This time is inclusive of block device I/O, file system CPU cycles, file system locks, run queue latency, etc. It's a more accurate measure of the latency suffered by applications performing file system I/O, than to measure this down at the block device interface. .TP FILENAME A cached kernel file name (comes from dentry->d_iname). .TP ENDTIME_us Completion timestamp, microseconds (\-j only). .TP OFFSET_b File offset, bytes (\-j only). .TP LATENCY_us Latency (duration) of the I/O, in microseconds (\-j only). .SH OVERHEAD This adds low-overhead instrumentation to these ext4 operations, including reads and writes from the file system cache. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool (even if it prints no "slower" events) can begin to become significant. Measure and quantify before use. If this continues to be a problem, consider switching to a tool that prints in-kernel summaries only. .PP Note that the overhead of this tool should be less than fileslower(8), as this tool targets ext4 functions only, and not all file read/write paths (which can include socket I/O). .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 biosnoop(8), funccount(8), fileslower(8) bpfcc-0.2.0+git0.02884a026/man/man8/filelife.8000066400000000000000000000034671305314114400177760ustar00rootroot00000000000000.TH filelife 8 "2016-02-08" "USER COMMANDS" .SH NAME filelife \- Trace the lifespan of short-lived files. Uses Linux eBPF/bcc. .SH SYNOPSIS .B filelife [\-h] [\-p PID] .SH DESCRIPTION This traces the creation and deletion of files, providing information on who deleted the file, the file age, and the file name. The intent is to provide information on short-lived files, for debugging or performance analysis. This works by tracing the kernel vfs_create() and vfs_delete() functions (and maybe more, see the source) using dynamic tracing, and will need updating to match any changes to these functions. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-p PID Trace this process ID only (filtered in-kernel). .SH EXAMPLES .TP Trace all short-lived files, and print details: # .B filelife .TP Trace all short-lived files created AND deleted by PID 181: # .B filelife \-p 181 .SH FIELDS .TP TIME Time of the deletion. .TP PID Process ID that deleted the file. .TP COMM Process name for the PID. .TP AGE(s) Age of the file, from creation to deletion, in seconds. .TP FILE Filename. .SH OVERHEAD This traces the kernel VFS file create and delete functions and prints output for each delete. As the rate of this is generally expected to be low (< 1000/s), the overhead is also expected to be negligible. This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 opensnoop(1) bpfcc-0.2.0+git0.02884a026/man/man8/fileslower.8000066400000000000000000000075001305314114400203620ustar00rootroot00000000000000.TH fileslower 8 "2016-02-07" "USER COMMANDS" .SH NAME fileslower \- Trace slow synchronous file reads and writes. .SH SYNOPSIS .B fileslower [\-h] [\-p PID] [-a] [min_ms] .SH DESCRIPTION This script uses kernel dynamic tracing of synchronous reads and writes at the VFS interface, to identify slow file reads and writes for any file system. This version traces __vfs_read() and __vfs_write() and only showing synchronous I/O (the path to new_sync_read() and new_sync_write()), and I/O with filenames. This approach provides a view of just two file system request types: file reads and writes. There are typically many others: asynchronous I/O, directory operations, file handle operations, file open()s, fflush(), etc. WARNING: See the OVERHEAD section. By default, a minimum millisecond threshold of 10 is used. Since this works by tracing various kernel __vfs_*() functions using dynamic tracing, it will need updating to match any changes to these functions. A future version should switch to using FS tracepoints instead. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS \-p PID Trace this PID only. .TP \-a Include non-regular file types in output (sockets, FIFOs, etc). .TP min_ms Minimum I/O latency (duration) to trace, in milliseconds. Default is 10 ms. .SH EXAMPLES .TP Trace synchronous file reads and writes slower than 10 ms: # .B fileslower .TP Trace slower than 1 ms: # .B fileslower 1 .TP Trace slower than 1 ms, for PID 181 only: # .B fileslower \-p 181 1 .SH FIELDS .TP TIME(s) Time of I/O completion since the first I/O seen, in seconds. .TP COMM Process name. .TP PID Process ID. .TP D Direction of I/O. R == read, W == write. .TP BYTES Size of I/O, in bytes. .TP LAT(ms) Latency (duration) of I/O, measured from when the application issued it to VFS to when it completed. This time is inclusive of block device I/O, file system CPU cycles, file system locks, run queue latency, etc. It's a more accurate measure of the latency suffered by applications performing file system I/O, than to measure this down at the block device interface. .TP FILENAME A cached kernel file name (comes from dentry->d_iname). .SH OVERHEAD Depending on the frequency of application reads and writes, overhead can become severe, in the worst case slowing applications by 2x. In the best case, the overhead is negligible. Hopefully for real world workloads the overhead is often at the lower end of the spectrum -- test before use. The reason for high overhead is that this traces VFS reads and writes, which includes FS cache reads and writes, and can exceed one million events per second if the application is I/O heavy. While the instrumentation is extremely lightweight, and uses in-kernel eBPF maps for efficient timing and filtering, multiply that cost by one million events per second and that cost becomes a million times worse. You can get an idea of the possible cost by just counting the instrumented events using the bcc funccount tool, eg: .PP # ./funccount.py -i 1 -r '^__vfs_(read|write)$' .PP This also costs overhead, but is somewhat less than fileslower. .PP If the overhead is prohibitive for your workload, I'd recommend moving down-stack a little from VFS into the file system functions (ext4, xfs, etc). Look for updates to bcc for specific file system tools that do this. The advantage of a per-file system approach is that we can trace post-cache, greatly reducing events and overhead. The disadvantage is needing custom tracing approaches for each different file system (whereas VFS is generic). .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 biosnoop(8), funccount(8) bpfcc-0.2.0+git0.02884a026/man/man8/filetop.8000066400000000000000000000060561305314114400176560ustar00rootroot00000000000000.TH filetop 8 "2016-02-08" "USER COMMANDS" .SH NAME filetop \- File reads and writes by filename and process. Top for files. .SH SYNOPSIS .B filetop [\-h] [\-C] [\-r MAXROWS] [\-p PID] [interval] [count] .SH DESCRIPTION This is top for files. This traces file reads and writes, and prints a per-file summary every interval (by default, 1 second). The summary is sorted on the highest read throughput (Kbytes). By default only IO on regular files is shown. The -a option will list all file types (sokets, FIFOs, etc). This uses in-kernel eBPF maps to store per process summaries for efficiency. This script works by tracing the __vfs_read() and __vfs_write() functions using kernel dynamic tracing, which instruments explicit read and write calls. If files are read or written using another means (eg, via mmap()), then they will not be visible using this tool. Also, this tool will need updating to match any code changes to those vfs functions. This should be useful for file system workload characterization when analyzing the performance of applications. Note that tracing VFS level reads and writes can be a frequent activity, and this tool can begin to cost measurable overhead at high I/O rates. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-a Include non-regular file types (sockets, FIFOs, etc). .TP \-C Don't clear the screen. .TP \-r MAXROWS Maximum number of rows to print. Default is 20. .TP \-p PID Trace this PID only. .TP interval Interval between updates, seconds. .TP count Number of interval summaries. .SH EXAMPLES .TP Summarize block device I/O by process, 1 second screen refresh: # .B filetop .TP Don't clear the screen, and top 8 rows only: # .B filetop -Cr 8 .TP 5 second summaries, 10 times only: # .B filetop 5 10 .SH FIELDS .TP loadavg: The contents of /proc/loadavg .TP PID Process ID. .TP COMM Process name. .TP READS Count of reads during interval. .TP WRITES Count of writes during interval. .TP R_Kb Total read Kbytes during interval. .TP W_Kb Total write Kbytes during interval. .TP T Type of file: R == regular, S == socket, O == other (pipe, etc). .SH OVERHEAD Depending on the frequency of application reads and writes, overhead can become significant, in the worst case slowing applications by over 50%. Hopefully for real world workloads the overhead is much less -- test before use. The reason for the high overhead is that VFS reads and writes can be a frequent event, and despite the eBPF overhead being very small per event, if you multiply this small overhead by a million events per second, it becomes a million times worse. Literally. You can gauge the number of reads and writes using the vfsstat(8) tool, also from bcc. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH INSPIRATION top(1) by William LeFebvre .SH SEE ALSO vfsstat(8), vfscount(8), fileslower(8) bpfcc-0.2.0+git0.02884a026/man/man8/funccount.8000066400000000000000000000050511305314114400202120ustar00rootroot00000000000000.TH funccount 8 "2015-08-18" "USER COMMANDS" .SH NAME funccount \- Count function, tracepoint, and USDT probe calls matching a pattern. Uses Linux eBPF/bcc. .SH SYNOPSIS .B funccount [\-h] [\-p PID] [\-i INTERVAL] [\-T] [\-r] [\-d] pattern .SH DESCRIPTION This tool is a quick way to determine which functions are being called, and at what rate. It uses in-kernel eBPF maps to count function calls. WARNING: This uses dynamic tracing of (what can be many) functions, an activity that has had issues on some kernel versions (risk of panics or freezes). Test, and know what you are doing, before use. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS pattern Search pattern. Supports "*" wildcards. See EXAMPLES. You can also use \-r for regular expressions. .TP \-h Print usage message. .TP \-p PID Trace this process ID only. .TP \-i INTERVAL Print output every interval seconds. .TP \-T Include timestamps on output. .TP \-r Use regular expressions for the search pattern. .TP \-d Print the BPF program before starting (for debugging purposes). .SH EXAMPLES .TP Count kernel functions beginning with "vfs_", until Ctrl-C is hit: # .B funccount 'vfs_*' .TP Count kernel functions beginning with "tcp_send", until Ctrl-C is hit: # .B funccount 'tcp_send*' .TP Print kernel functions beginning with "vfs_", every second: # .B funccount \-i 1 'vfs_*' .TP Match kernel functions beginning with "vfs_", using regular expressions: # .B funccount \-r '^vfs_.*' .TP Count vfs calls for process ID 181 only: # .B funccount \-p 181 'vfs_*' .TP Count calls to the sched_fork tracepoint, indicating a fork() performed: # .B funccount t:sched:sched_fork .TP Count all GC USDT probes in the Node process: # .B funccount -p 185 u:node:gc* .TP Count all malloc() calls in libc: # .B funccount c:malloc .SH FIELDS .TP FUNC Function name .TP COUNT Number of calls while tracing .SH OVERHEAD This traces functions and maintains in-kernel counts, which are asynchronously copied to user-space. While the rate of calls be very high (>1M/sec), this is a relatively efficient way to trace these events, and so the overhead is expected to be small for normal workloads. Measure in a test environment before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg, Sasha Goldshtein .SH SEE ALSO stackcount(8) funclatency(8) vfscount(8) bpfcc-0.2.0+git0.02884a026/man/man8/funclatency.8000066400000000000000000000067441305314114400205330ustar00rootroot00000000000000.TH funclatency 8 "2015-08-18" "USER COMMANDS" .SH NAME funclatency \- Time functions and print latency as a histogram. .SH SYNOPSIS .B funclatency [\-h] [\-p PID] [\-i INTERVAL] [\-T] [\-u] [\-m] [\-F] [\-r] [\-v] pattern .SH DESCRIPTION This tool traces function calls and times their duration (latency), and shows the latency distribution as a histogram. The time is measured from when the function is called to when it returns, and is inclusive of both on-CPU time and time spent blocked. This tool uses in-kernel eBPF maps for storing timestamps and the histogram, for efficiency. Currently nested or recursive functions are not supported properly, and timestamps will be overwritten, creating dubious output. Try to match single functions, or groups of functions that run at the same stack layer, and don't ultimately call each other. WARNING: This uses dynamic tracing of (what can be many) functions, an activity that has had issues on some kernel versions (risk of panics or freezes). Test, and know what you are doing, before use. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS pattern Function name or search pattern. Supports "*" wildcards. See EXAMPLES. You can also use \-r for regular expressions. \-h Print usage message. .TP \-p PID Trace this process ID only. .TP \-i INTERVAL Print output every interval seconds. .TP \-T Include timestamps on output. .TP \-u Output histogram in microseconds. .TP \-m Output histogram in milliseconds. .TP \-F Print a separate histogram per function matched. .TP \-r Use regular expressions for the search pattern. .TP \-v Print the BPF program (for debugging purposes). .SH EXAMPLES .TP Time the do_sys_open() kernel function, and print the distribution as a histogram: # .B funclatency do_sys_open .TP Time the read() function in libc across all processes on the system: # .B funclatency c:read .TP Time vfs_read(), and print the histogram in units of microseconds: # .B funclatency \-u vfs_read .TP Time do_nanosleep(), and print the histogram in units of milliseconds: # .B funclatency \-m do_nanosleep .TP Time vfs_read(), and print output every 5 seconds, with timestamps: # .B funclatency \-mTi 5 vfs_read .TP Time vfs_read() for process ID 181 only: # .B funclatency \-p 181 vfs_read: .TP Time both vfs_fstat() and vfs_fstatat() calls, by use of a wildcard: # .B funclatency 'vfs_fstat*' .TP Time both vfs_fstat* calls, and print a separate histogram for each: # .B funclatency -F 'vfs_fstat*' .SH FIELDS .TP necs Nanosecond range .TP usecs Microsecond range .TP msecs Millisecond range .TP count How many calls fell into this range .TP distribution An ASCII bar chart to visualize the distribution (count column) .SH OVERHEAD This traces kernel functions and maintains in-kernel timestamps and a histogram, which are asynchronously copied to user-space. While this method is very efficient, the rate of kernel functions can also be very high (>1M/sec), at which point the overhead is expected to be measurable. Measure in a test environment and understand overheads before use. You can also use funccount to measure the rate of kernel functions over a short duration, to set some expectations before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg, Sasha Goldshtein .SH SEE ALSO funccount(8) bpfcc-0.2.0+git0.02884a026/man/man8/gethostlatency.8000066400000000000000000000033311305314114400212420ustar00rootroot00000000000000.TH gethostlatency 8 "2016-01-28" "USER COMMANDS" .SH NAME gethostlatency \- Show latency for getaddrinfo/gethostbyname[2] calls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B gethostlatency .SH DESCRIPTION This traces and prints when getaddrinfo(), gethostbyname(), and gethostbyname2() are called, system wide, and shows the responsible PID and command name, latency of the call (duration) in milliseconds, and the host string. This tool can be useful for identifying DNS latency, by identifying which remote host name lookups were slow, and by how much. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism This tool currently uses dynamic tracing of user-level functions and registers, and may need modifications to match your software and processor architecture. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-p PID Trace this process ID only. .SH EXAMPLES .TP Trace host lookups (getaddrinfo/gethostbyname[2]) system wide: # .B gethostlatency .SH FIELDS .TP TIME Time of the command (HH:MM:SS). .TP PID Process ID of the client performing the call. .TP COMM Process (command) name of the client performing the call. .TP HOST Host name string: the target of the lookup. .SH OVERHEAD The rate of lookups should be relatively low, so the overhead is not expected to be a problem. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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(8) bpfcc-0.2.0+git0.02884a026/man/man8/hardirqs.8000066400000000000000000000044321305314114400200250ustar00rootroot00000000000000.TH hardirqs 8 "2015-10-20" "USER COMMANDS" .SH NAME hardirqs \- Measure hard IRQ (hard interrupt) event time. Uses Linux eBPF/bcc. .SH SYNOPSIS .B hardirqs [\-h] [\-T] [\-N] [\-d] [interval] [count] .SH DESCRIPTION This summarizes the time spent servicing hard IRQs (hard interrupts), and can show this time as either totals or histogram distributions. A system-wide summary of this time is shown by the %irq column of mpstat(1), and event counts (but not times) are shown by /proc/interrupts. WARNING: This currently uses dynamic tracing of hard interrupts. You should understand what this means before use. Try in a test environment. Future versions should switch to tracepoints. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Include timestamps on output. .TP \-N Output in nanoseconds .TP \-d Show IRQ time distribution as histograms .SH EXAMPLES .TP Sum hard IRQ event time until Ctrl-C: # .B hardirqs .TP Show hard IRQ event time as histograms: # .B hardirqs \-d .TP Print 1 second summaries, 10 times: # .B hardirqs 1 10 .TP 1 second summaries, printed in nanoseconds, with timestamps: # .B hardirqs \-NT 1 .SH FIELDS .TP HARDIRQ The irq action name for this hard IRQ. .TP TOTAL_usecs Total time spent in this hard IRQ in microseconds. .TP TOTAL_nsecs Total time spent in this hard IRQ in nanoseconds. .TP usecs Range of microseconds for this bucket. .TP nsecs Range of nanoseconds for this bucket. .TP count Number of hard IRQs in this time range. .TP distribution ASCII representation of the distribution (the count column). .SH OVERHEAD This traces kernel functions and maintains in-kernel counts, which are asynchronously copied to user-space. While the rate of interrupts be very high (>1M/sec), this is a relatively efficient way to trace these events, and so the overhead is expected to be small for normal workloads, but could become noticeable for heavy workloads. Measure in a test environment before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 softirqs(8) bpfcc-0.2.0+git0.02884a026/man/man8/killsnoop.8000066400000000000000000000036671305314114400202330ustar00rootroot00000000000000.TH killsnoop 8 "2015-08-20" "USER COMMANDS" .SH NAME killsnoop \- Trace signals issued by the kill() syscall. Uses Linux eBPF/bcc. .SH SYNOPSIS .B killsnoop [\-h] [\-x] [-p PID] .SH DESCRIPTION killsnoop traces the kill() syscall, to show signals sent via this method. This may be useful to troubleshoot failing applications, where an unknown mechanism is sending signals. This works by tracing the kernel sys_kill() function using dynamic tracing, and will need updating to match any changes to this function. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-x Only print failed kill() syscalls. .TP \-p PID Trace this process ID only (filtered in-kernel). .SH EXAMPLES .TP Trace all kill() syscalls: # .B killsnoop .TP Trace only kill() syscalls that failed: # .B killsnoop \-x .TP Trace PID 181 only: # .B killsnoop \-p 181 .SH FIELDS .TP TIME Time of the kill call. .TP PID Source process ID .TP COMM Source process name .TP SIG Signal number. See signal(7). .TP TPID Target process ID .TP RES Result. 0 == success, a negative value (of the error code) for failure. .SH OVERHEAD This traces the kernel kill function and prints output for each event. As the rate of this is generally expected to be low (< 100/s), the overhead is also expected to be negligible. If you have an application that is calling a very high rate of kill()s for some reason, then test and understand overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 opensnoop(8), funccount(8) bpfcc-0.2.0+git0.02884a026/man/man8/llcstat.8000066400000000000000000000032531305314114400176560ustar00rootroot00000000000000.TH llcstat 8 "2015-08-18" "USER COMMANDS" .SH NAME llcstat \- Summarize CPU cache references and misses by process. Uses Linux eBPF/bcc. .SH SYNOPSIS .B llcstat [\-h] [\-c SAMPLE_PERIOD] [duration] .SH DESCRIPTION llcstat instruments CPU cache references and cache misses system-side, and summarizes them by PID and CPU. These events have different meanings on different architecture. For x86-64, they mean misses and references to LLC. This can be useful to locate and debug performance issues caused by cache hit rate. This works by sampling corresponding events defined in uapi/linux/perf_event.h, namely PERF_COUNT_HW_CACHE_REFERENCES and PERF_COUNT_HW_CACHE_MISSES, using BPF perf event tracing. Upon each sampled event, the attached BPF program records the PID and CPU ID on which the event happened, and stores it in table. This makes use of a Linux 4.9 feature (BPF_PROG_TYPE_PERF_EVENT). Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-c SAMPLE_PERIOD Sample one in this many cache reference and cache miss events. .TP duration Duration to trace, in seconds. .SH EXAMPLES .TP Sample one in 100 events, trace for 20 seconds: # .B llcstat -c 100 20 .SH FIELDS .TP PID Process ID .TP NAME Process name .TP CPU CPU ID .TP REFERENCE Number of cache reference events .TP MISS Number of cache miss events .TP HIT% Cache hit ratio .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Teng Qin bpfcc-0.2.0+git0.02884a026/man/man8/mdflush.8000066400000000000000000000027171305314114400176560ustar00rootroot00000000000000.TH pidpersec 8 "2016-02-13" "USER COMMANDS" .SH NAME mdflush \- Trace md flush events. Uses Linux eBPF/bcc. .SH SYNOPSIS .B mdflush .SH DESCRIPTION This tool traces flush events by md, the Linux multiple device driver (software RAID). The timestamp and md device for the flush are printed. Knowing when these flushes happen can be useful for correlation with unexplained spikes in disk latency. This works by tracing the kernel md_flush_request() function using dynamic tracing, and will need updating to match any changes to this function. Note that the flushes themselves are likely to originate from higher in the I/O stack, such as from the file systems. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Trace md flush events: # .B mdflush .SH FIELDS .TP TIME Time of the flush event (HH:MM:SS). .TP PID The process ID that was on-CPU when the event was issued. This may identify the cause of the flush (eg, the "sync" command), but will often identify a kernel worker thread that was managing I/O. .TP COMM The command name for the PID. .TP DEVICE The md device name. .SH OVERHEAD Expected to be negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 biosnoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/memleak.8000066400000000000000000000076351305314114400176330ustar00rootroot00000000000000.TH memleak 8 "2016-01-14" "USER COMMANDS" .SH NAME memleak \- Print a summary of outstanding allocations and their call stacks to detect memory leaks. Uses Linux eBPF/bcc. .SH SYNOPSIS .B memleak [-h] [-p PID] [-t] [-a] [-o OLDER] [-c COMMAND] [-s SAMPLE_RATE] [-T TOP] [-z MIN_SIZE] [-Z MAX_SIZE] [-O OBJ] [INTERVAL] [COUNT] .SH DESCRIPTION memleak traces and matches memory allocation and deallocation requests, and collects call stacks for each allocation. memleak can then print a summary of which call stacks performed allocations that weren't subsequently freed. When tracing a specific process, memleak instruments malloc and free from libc. When tracing all processes, memleak instruments kmalloc and kfree. memleak may introduce significant overhead when tracing processes that allocate and free many blocks very quickly. See the OVERHEAD section below. This tool only works on Linux 4.6+. Stack traces are obtained using the new BPF_STACK_TRACE` APIs. For kernels older than 4.6, see the version under tools/old. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-p PID Trace this process ID only (filtered in-kernel). This traces malloc and free from libc. .TP \-t Print a trace of all allocation and free requests and results. .TP \-a Print a list of allocations that weren't freed (and their sizes) in addition to their call stacks. .TP \-o OLDER Print only allocations older than OLDER milliseconds. Useful to remove false positives. The default value is 500 milliseconds. .TP \-c COMMAND Run the specified command and trace its allocations only. This traces malloc and free from libc. .TP \-s SAMPLE_RATE Record roughly every SAMPLE_RATE-th allocation to reduce overhead. .TP \-t TOP Print only the top TOP stacks (sorted by size). The default value is 10. .TP \-z MIN_SIZE Capture only allocations that are larger than or equal to MIN_SIZE bytes. .TP \-Z MAX_SIZE Capture only allocations that are smaller than or equal to MAX_SIZE bytes. .TP \-O OBJ Attach to malloc and free in specified object instead of resolving libc. Ignored when kernel allocations are profiled. .TP INTERVAL Print a summary of oustanding allocations and their call stacks every INTERVAL seconds. The default interval is 5 seconds. .TP COUNT Print the outstanding allocations summary COUNT times and then exit. .SH EXAMPLES .TP Print outstanding kernel allocation stacks every 3 seconds: # .B memleak 3 .TP Print user outstanding allocation stacks and allocation details for the process 1005: # .B memleak -p 1005 -a .TP Sample roughly every 5th allocation (~20%) of the call stacks and print the top 5 stacks 10 times before quitting. # .B memleak -s 5 --top=5 10 .TP Run ./allocs and print outstanding allocation stacks for that process: # .B memleak -c "./allocs" .TP Capture only allocations between 16 and 32 bytes in size: # .B memleak -z 16 -Z 32 .SH OVERHEAD memleak can have significant overhead if the target process or kernel performs allocations at a very high rate. Pathological cases may exhibit up to 100x degradation in running time. Most of the time, however, memleak shouldn't cause a significant slowdown. You can use the \-s switch to reduce the overhead further by capturing only every N-th allocation. The \-z and \-Z switches can also reduce overhead by capturing only allocations of specific sizes. To determine the rate at which your application is calling malloc/free, or the rate at which your kernel is calling kmalloc/kfree, place a probe with perf and collect statistics. For example, to determine how many calls to __kmalloc are placed in a typical period of 10 seconds: # .B perf probe '__kmalloc' # .B perf stat -a -e 'probe:__kmalloc' -- sleep 10 .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein bpfcc-0.2.0+git0.02884a026/man/man8/mountsnoop.8000066400000000000000000000027201305314114400204270ustar00rootroot00000000000000.TH mountsnoop 8 "2016-10-14" "USER COMMANDS" .SH NAME mountsnoop \- Trace mount() and umount() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B mountsnoop .SH DESCRIPTION mountsnoop traces the mount() and umount() syscalls, showing which processes are mounting and unmounting filesystems in what mount namespaces. This can be useful for troubleshooting system and container setup. This works by tracing the kernel sys_mount() and sys_umount() functions using dynamic tracing, and will need updating to match any changes to this function. This makes use of a Linux 4.4 feature (bpf_perf_event_output()). Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH FIELDS .TP COMM Process name .TP PID Process ID .TP TID Thread ID .TP MNT_NS Mount namespace inode number .TP CALL System call, arguments, and return value .SH OVERHEAD This traces the kernel mount and umount functions and prints output for each event. As the rate of these calls is generally expected to be very low, the overhead is also expected to be negligible. If your system calls mount() and umount() at a high rate, then test and understand overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Omar Sandoval .SH SEE ALSO mount(2) umount(2) bpfcc-0.2.0+git0.02884a026/man/man8/mysqld_qslower.8000066400000000000000000000035531305314114400213000ustar00rootroot00000000000000.TH mysqld_qslower 8 "2016-08-01" "USER COMMANDS" .SH NAME mysqld_qslower \- Trace MySQL server queries slower than a threshold. .SH SYNOPSIS .B mysqld_qslower PID [min_ms] .SH DESCRIPTION This traces queries served by a MySQL server, and prints those that exceed a custom latency (query duration) threshold. By default, a minimum threshold of 1 millisecond is used. If a threshold of 0 is used, all queries are printed. This uses User Statically-Defined Tracing (USDT) probes, a feature added to MySQL for DTrace support, but which may not be enabled on a given MySQL installation. See requirements. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF, bcc, and MySQL server with USDT probe support (when configuring the build: \-DENABLE_DTRACE=1). .SH OPTIONS PID Trace this mysqld PID. .TP min_ms Minimum query latency (duration) to trace, in milliseconds. Default is 1 ms. .SH EXAMPLES .TP Trace MySQL server queries slower than 1 ms for PID 1981: # .B mysqld_qslower 1981 .TP Trace slower than 10 ms for PID 1981: # .B mysqld_qslower 1981 10 .SH FIELDS .TP TIME(s) Time of query start, in seconds. .TP PID Process ID of the traced server. .TP MS Milliseconds for the query, from start to end. .TP QUERY Query string, truncated to 128 characters. .SH OVERHEAD This adds low-overhead instrumentation to MySQL queries, and only emits output data from kernel to user-level if they query exceeds the threshold. If the server query rate is less than 1,000/sec, the overhead is expected to be negligible. If the query rate is higher, test to gauge overhead. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 biosnoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/offcputime.8000066400000000000000000000067341305314114400203600ustar00rootroot00000000000000.TH offcputime 8 "2016-01-14" "USER COMMANDS" .SH NAME offcputime \- Summarize off-CPU time by kernel stack trace. Uses Linux eBPF/bcc. .SH SYNOPSIS .B offcputime [\-h] [\-u] [\-p PID] [\-v] [\-f] [duration] .SH DESCRIPTION This program shows stack traces and task names that were blocked and "off-CPU", and the total duration they were not running: their "off-CPU time". It works by tracing when threads block and when they return to CPU, measuring both the time they were off-CPU and the blocked stack trace and the task name. This data is summarized in the kernel using an eBPF map, and by summing the off-CPU time by unique stack trace and task name. The output summary will help you identify reasons why threads were blocking, and quantify the time they were off-CPU. This spans all types of blocking activity: disk I/O, network I/O, locks, page faults, involuntary context switches, etc. This is complementary to CPU profiling (e.g., CPU flame graphs) which shows the time spent on-CPU. This shows the time spent off-CPU, and the output, especially the -f format, can be used to generate an "off-CPU time flame graph". See http://www.brendangregg.com/FlameGraphs/offcpuflamegraphs.html This tool only works on Linux 4.6+. It uses the new `BPF_STACK_TRACE` table APIs to generate the in-kernel stack traces. For kernels older than 4.6, see the version under tools/old. Note: this tool only traces off-CPU times that began and ended while tracing. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-f Print output in folded stack format. .TP \-p PID Trace this process ID only (filtered in-kernel). .TP \-t TID Trace this thread ID only (filtered in-kernel). .TP \-u Only trace user threads (no kernel threads). .TP \-k Only trace kernel threads (no user threads). .TP \-U Show stacks from user space only (no kernel space stacks). .TP \-K Show stacks from kernel space only (no user space stacks). .TP \-d Insert delimiter between kernel/user stacks. .TP \-f Output folded format. .TP \-\-stack-storage-size STACK_STORAGE_SIZE Change the number of unique stack traces that can be stored and displayed. .TP duration Duration to trace, in seconds. .SH EXAMPLES .TP Trace all thread blocking events, and summarize (in-kernel) by kernel stack trace and total off-CPU time: # .B offcputime .TP Trace for 5 seconds only: # .B offcputime 5 .TP Trace for 5 seconds, and emit output in folded stack format (suitable for flame graphs): # .B offcputime -f 5 .TP Trace PID 185 only: # .B offcputime -p 185 .SH OVERHEAD This summarizes unique stack traces in-kernel for efficiency, allowing it to trace a higher rate of events than methods that post-process in user space. The stack trace and time data is only copied to user space once, when the output is printed. While these techniques greatly lower overhead, scheduler events are still a high frequency event, as they can exceed 1 million events per second, and so caution should still be used. Test before production use. If the overhead is still a problem, take a look at the MINBLOCK_US tunable in the code. If your aim is to chase down longer blocking events, then this could be increased to filter shorter blocking events, further lowering overhead. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 stackcount(8) bpfcc-0.2.0+git0.02884a026/man/man8/offwaketime.8000066400000000000000000000073631305314114400205170ustar00rootroot00000000000000.TH offwaketime 8 "2016-01-30" "USER COMMANDS" .SH NAME offwaketime \- Summarize blocked time by off-CPU stack + waker stack. Uses Linux eBPF/bcc. .SH SYNOPSIS .B offwaketime [\-h] [\-p PID | \-t TID | \-u | \-k] [\-U | \-K] [\-f] [\-\-stack-storage-size STACK_STORAGE_SIZE] [\-m MIN_BLOCK_TIME] [\-M MAX_BLOCK_TIME] [duration] .SH DESCRIPTION This program shows kernel stack traces and task names that were blocked and "off-CPU", along with the stack traces and task names for the threads that woke them, and the total elapsed time from when they blocked to when they were woken up. This combines the summaries from both the offcputime and wakeuptime tools. The time measurement will be very similar to off-CPU time, however, off-CPU time may include a little extra time spent waiting on a run queue to be scheduled. The combined stacks, task names, and total time is summarized in kernel context for efficiency, using an eBPF map. The output summary will further help you identify reasons why threads were blocking, and quantify the time from when they were blocked to woken up. This spans all types of blocking activity: disk I/O, network I/O, locks, page faults, swapping, sleeping, involuntary context switches, etc. This is complementary to CPU profiling (e.g., CPU flame graphs) which shows the time spent on-CPU. This shows the time spent blocked off-CPU, and the output, especially the -f format, can be used to generate an "off-wake time flame graph". See http://www.brendangregg.com/FlameGraphs/offcpuflamegraphs.html .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-f Print output in folded stack format. .TP \-p PID Trace this process ID only (filtered in-kernel). .TP \-t TID Trace this thread ID only (filtered in-kernel). .TP \-u Only trace user threads (no kernel threads). .TP \-k Only trace kernel threads (no user threads). .TP \-U Show stacks from user space only (no kernel space stacks). .TP \-K Show stacks from kernel space only (no user space stacks). .TP \-\-stack-storage-size STACK_STORAGE_SIZE Change the number of unique stack traces that can be stored and displayed. .TP duration Duration to trace, in seconds. .TP \-m MIN_BLOCK_TIME The amount of time in microseconds over which we store traces (default 1) .TP \-M MAX_BLOCK_TIME The amount of time in microseconds under which we store traces (default U64_MAX) .SH EXAMPLES .TP Trace all thread blocking events, and summarize (in-kernel) by user and kernel off-CPU stack trace, waker stack traces, task names, and total blocked time: # .B offwaketime .TP Trace for 5 seconds only: # .B offwaketime 5 .TP Trace for 5 seconds, and emit output in folded stack format (suitable for flame graphs), user-mode threads only: # .B offwaketime -fu 5 .TP Trace PID 185 only: # .B offwaketime -p 185 .SH OVERHEAD This summarizes unique stack trace pairs in-kernel for efficiency, allowing it to trace a higher rate of events than methods that post-process in user space. The stack trace and time data is only copied to user space once, when the output is printed. While these techniques greatly lower overhead, scheduler events are still a high frequency event, as they can exceed 1 million events per second, and so caution should still be used. Test before production use. If the overhead is still a problem, take a look at the min block option. If your aim is to chase down longer blocking events, then this could be increased to filter shorter blocking events, further lowering overhead. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 offcputime(8), wakeuptime(8) bpfcc-0.2.0+git0.02884a026/man/man8/oomkill.8000066400000000000000000000031411305314114400176520ustar00rootroot00000000000000.TH oomkill 8 "2016-02-09" "USER COMMANDS" .SH NAME oomkill \- Trace oom_kill_process(). Uses Linux eBPF/bcc. .SH SYNOPSIS .B oomkill .SH DESCRIPTION This traces the kernel out-of-memory killer, and prints basic details, including the system load averages at the time of the OOM kill. This can provide more context on the system state at the time: was it getting busier or steady, based on the load averages? This tool may also be useful to customize for investigations; for example, by adding other task_struct details at the time of OOM. This program is also a basic example of eBPF/bcc. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Trace OOM kill events: # .B oomkill .SH FIELDS .TP Triggered by ... The process ID and process name of the task that was running when another task was OOM killed. .TP OOM kill of ... The process ID and name of the target process that was OOM killed. .TP loadavg Contents of /proc/loadavg. The first three numbers are 1, 5, and 15 minute load averages (where the average is an exponentially damped moving sum, and those numbers are constants in the equation); then there is the number of running tasks, a slash, and the total number of tasks; and then the last number is the last PID to be created. .SH OVERHEAD Negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 memleak(8) bpfcc-0.2.0+git0.02884a026/man/man8/opensnoop.8000066400000000000000000000044521305314114400202320ustar00rootroot00000000000000.TH opensnoop 8 "2015-08-18" "USER COMMANDS" .SH NAME opensnoop \- Trace open() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B opensnoop [\-h] [\-T] [\-x] [\-p PID] [\-t TID] [\-n name] .SH DESCRIPTION opensnoop traces the open() syscall, showing which processes are attempting to open which files. This can be useful for determining the location of config and log files, or for troubleshooting applications that are failing, specially on startup. This works by tracing the kernel sys_open() function using dynamic tracing, and will need updating to match any changes to this function. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Include a timestamp column. .TP \-x Only print failed opens. .TP \-p PID Trace this process ID only (filtered in-kernel). .TP \-t TID Trace this thread ID only (filtered in-kernel). .TP \-n name Only print processes where its name partially matches 'name' .SH EXAMPLES .TP Trace all open() syscalls: # .B opensnoop .TP Trace all open() syscalls, and include timestamps: # .B opensnoop \-T .TP Trace only open() syscalls that failed: # .B opensnoop \-x .TP Trace PID 181 only: # .B opensnoop \-p 181 .TP Trace all open() syscalls from processes where its name partially matches 'ed': # .B opensnoop \-n ed .SH FIELDS .TP TIME(s) Time of the call, in seconds. .TP PID Process ID .TP TID Thread ID .TP COMM Process name .TP FD File descriptor (if success), or -1 (if failed) .TP ERR Error number (see the system's errno.h) .TP PATH Open path .SH OVERHEAD This traces the kernel open function and prints output for each event. As the rate of this is generally expected to be low (< 1000/s), the overhead is also expected to be negligible. If you have an application that is calling a high rate of open()s, then test and understand overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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(1) bpfcc-0.2.0+git0.02884a026/man/man8/pidpersec.8000066400000000000000000000023631305314114400201670ustar00rootroot00000000000000.TH pidpersec 8 "2015-08-18" "USER COMMANDS" .SH NAME pidpersec \- Count new processes (via fork()). Uses Linux eBPF/bcc. .SH SYNOPSIS .B pidpersec .SH DESCRIPTION pidpersec shows how many new processes were created each second. There can be performance issues caused by many short-lived processes, which may not be visible in sampling tools like top(1). pidpersec provides one way to investigate this behavior. This works by tracing the kernel sched_fork() function using dynamic tracing, and will need updating to match any changes to this function. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Count new processes created each second: # .B pidpersec .SH OVERHEAD This traces the kernel fork function, and maintains an in-kernel count which is read asynchronously from user-space. As the rate of this is generally expected to be low (<< 1000/s), the overhead is also expected to be negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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) bpfcc-0.2.0+git0.02884a026/man/man8/profile.8000066400000000000000000000107051305314114400176500ustar00rootroot00000000000000.TH profile 8 "2016-07-17" "USER COMMANDS" .SH NAME profile \- Profile CPU usage by sampling stack traces. Uses Linux eBPF/bcc. .SH SYNOPSIS .B profile [\-adfh] [\-p PID] [\-U | \-k] [\-F FREQUENCY] .B [\-\-stack\-storage\-size COUNT] [duration] .SH DESCRIPTION This is a CPU profiler. It works by taking samples of stack traces at timed intervals. It will help you understand and quantify CPU usage: which code is executing, and by how much, including both user-level and kernel code. By default this samples at 49 Hertz (samples per second), across all CPUs. This frequency can be tuned using a command line option. The reason for 49, and not 50, is to avoid lock-step sampling. This is also an efficient profiler, as stack traces are frequency counted in kernel context, rather than passing each stack to user space for frequency counting there. Only the unique stacks and counts are passed to user space at the end of the profile, greatly reducing the kernel<->user transfer. .SH REQUIREMENTS CONFIG_BPF and bcc. This also requires Linux 4.9+ (BPF_PROG_TYPE_PERF_EVENT support). See tools/old for an older version that may work on Linux 4.6 - 4.8. .SH OPTIONS .TP \-h Print usage message. .TP \-p PID Trace this process ID only (filtered in-kernel). Without this, all CPUs are profiled. .TP \-F frequency Frequency to sample stacks (default 49). .TP \-f Print output in folded stack format. .TP \-d Include an output delimiter between kernel and user stacks (either "--", or, in folded mode, "-"). .TP \-U Show stacks from user space only (no kernel space stacks). .TP \-K Show stacks from kernel space only (no user space stacks). .TP \-\-stack-storage-size COUNT The maximum number of unique stack traces that the kernel will count (default 10240). If the sampled count exceeds this, a warning will be printed. .TP duration Duration to trace, in seconds. .SH EXAMPLES .TP Profile (sample) stack traces system-wide at 49 Hertz (samples per second) until Ctrl-C: # .B profile .TP Profile for 5 seconds only: # .B profile 5 .TP Profile at 99 Hertz for 5 seconds only: # .B profile -F 99 5 .TP Profile PID 181 only: # .B profile -p 181 .TP Profile for 5 seconds and output in folded stack format (suitable as input for flame graphs), including a delimiter between kernel and user stacks: # .B profile -df 5 .TP Profile kernel stacks only: # .B profile -K .SH DEBUGGING See "[unknown]" frames with bogus addresses? This can happen for different reasons. Your best approach is to get Linux perf to work first, and then to try this tool. Eg, "perf record \-F 49 \-a \-g \-\- sleep 1; perf script", and to check for unknown frames there. The most common reason for "[unknown]" frames is that the target software has not been compiled with frame pointers, and so we can't use that simple method for walking the stack. The fix in that case is to use software that does have frame pointers, eg, gcc -fno-omit-frame-pointer, or Java's -XX:+PreserveFramePointer. Another reason for "[unknown]" frames is JIT compilers, which don't use a traditional symbol table. The fix in that case is to populate a /tmp/perf-PID.map file with the symbols, which this tool should read. How you do this depends on the runtime (Java, Node.js). If you seem to have unrelated samples in the output, check for other sampling or tracing tools that may be running. The current version of this tool can include their events if profiling happened concurrently. Those samples may be filtered in a future version. .SH OVERHEAD This is an efficient profiler, as stack traces are frequency counted in kernel context, and only the unique stacks and their counts are passed to user space. Contrast this with the current "perf record -F 99 -a" method of profiling, which writes each sample to user space (via a ring buffer), and then to the file system (perf.data), which must be post-processed. This uses perf_event_open to setup a timer which is instrumented by BPF, and for efficiency it does not initialize the perf ring buffer, so the redundant perf samples are not collected. It's expected that the overhead while sampling at 49 Hertz (the default), across all CPUs, should be negligible. If you increase the sample rate, the overhead might begin to be measurable. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 offcputime(8) bpfcc-0.2.0+git0.02884a026/man/man8/reset-trace.8000066400000000000000000000032551305314114400204300ustar00rootroot00000000000000.TH reset-trace 8 "2016-10-18" "USER COMMANDS" .SH NAME reset-trace \- reset the state of tracing. .SH SYNOPSIS .B reset-trace [\-F] [\-h] [\-q] [\-v] .SH DESCRIPTION You will probably never need this tool. If you kill \-9 a bcc tool (plus other signals, like SIGTERM), or if a bcc tool crashes, then kernel tracing can be left in a semi-enabled state. It's not as bad as it sounds: there may just be overhead for writing to ring buffers that are never read. This tool can be used to clean up the tracing state, and reset and disable active tracing. Make sure no other tracing sessions are active. This tool might stop them from functioning (perhaps ungracefully). This specifically clears the state in at least the following files in /sys/kernel/debug/tracing: kprobe_events, uprobe_events, trace_pipe. Other tracing facilities (ftrace) are checked, and if not in an expected state, a note is printed. All tracing files can be reset with \-F for force, but this will interfere with any other running tracing sessions (eg, ftrace). .SH REQUIREMENTS /sys/kernel/debug mounted as debugfs .SH OPTIONS .TP \-F Force. Will reset all tracing facilities, including those not used by bcc (ftrace). You shouldn't need to use this. .TP \-h USAGE message. .TP \-q Quiet. No output while working. .TP \-v Verbose: print what it is doing. .SH EXAMPLES .TP Reset the state of tracing: # .B reset-trace .TP Verbose: # .B reset-trace \-v .TP .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg bpfcc-0.2.0+git0.02884a026/man/man8/runqlat.8000066400000000000000000000055441305314114400177030ustar00rootroot00000000000000.TH runqlat 8 "2016-02-07" "USER COMMANDS" .SH NAME runqlat \- Run queue (scheduler) latency as a histogram. .SH SYNOPSIS .B runqlat [\-h] [\-T] [\-m] [\-P] [\-p PID] [interval] [count] .SH DESCRIPTION This measures the time a task spends waiting on a run queue (or equivalent scheduler data structure) for a turn on-CPU, and shows this time as a histogram. This time should be small, but a task may need to wait its turn due to CPU load. The higher the CPU load, the longer a task will generally need to wait its turn. This tool measures two types of run queue latency: 1. The time from a task being enqueued on a run queue to its context switch and execution. This traces enqueue_task_*() -> finish_task_switch(), and instruments the run queue latency after a voluntary context switch. 2. The time from when a task was involuntary context switched and still in the runnable state, to when it next executed. This is instrumented from finish_task_switch() alone. This tool uses in-kernel eBPF maps for storing timestamps and the histogram, for efficiency. Despite this, the overhead of this tool may become significant for some workloads: see the OVERHEAD section. This works by tracing various kernel scheduler functions using dynamic tracing, and will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Include timestamps on output. .TP \-m Output histogram in milliseconds. .TP \-P Print a histogram for each PID. .TP \-p PID Only show this PID (filtered in kernel for efficiency). .TP interval Output interval, in seconds. .TP count Number of outputs. .SH EXAMPLES .TP Summarize run queue latency as a histogram: # .B runqlat .TP Print 1 second summaries, 10 times: # .B runqlat 1 10 .TP Print 1 second summaries, using milliseconds as units for the histogram, and include timestamps on output: # .B runqlat \-mT 1 .TP Trace PID 186 only, 1 second summaries: # .B runqlat -P 185 1 .SH FIELDS .TP usecs Microsecond range .TP msecs Millisecond range .TP count How many times a task event fell into this range .TP distribution An ASCII bar chart to visualize the distribution (count column) .SH OVERHEAD This traces scheduler functions, which can become very frequent. While eBPF has very low overhead, and this tool uses in-kernel maps for efficiency, the frequency of scheduler events for some workloads may be high enough that the overhead of this tool becomes significant. Measure in a lab environment to quantify the overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 runqlen(8), pidstat(1) bpfcc-0.2.0+git0.02884a026/man/man8/runqlen.8000066400000000000000000000037251305314114400177000ustar00rootroot00000000000000.TH runqlen 8 "2016-12-12" "USER COMMANDS" .SH NAME runqlen \- Scheduler run queue length as a histogram. .SH SYNOPSIS .B runqlen [\-h] [\-T] [\-O] [\-C] [interval] [count] .SH DESCRIPTION This program summarizes scheduler queue length as a histogram, and can also show run queue occupancy. It works by sampling the run queue length on all CPUs at 99 Hertz. This tool can be used to identify imbalances, eg, when processes are bound to CPUs causing queueing, or interrupt mappings causing the same. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Include timestamps on output. .TP \-O Report run queue occupancy. .TP \-C Report for each CPU. .TP interval Output interval, in seconds. .TP count Number of outputs. .SH EXAMPLES .TP Summarize run queue length as a histogram: # .B runqlen .TP Print 1 second summaries, 10 times: # .B runqlen 1 10 .TP Print output every second, with timestamps, and show each CPU separately: # .B runqlen \-CT 1 .TP Print run queue occupancy every second: # .B runqlen \-O 1 .TP Print run queue occupancy, with timetamps, for each CPU: # .B runqlen \-COT 1 .SH FIELDS .TP runqlen Scheduler run queue length: the number of threads (tasks) waiting to run, (excluding including the currently running task). .TP count Number of samples at this queue length. .TP distribution An ASCII bar chart to visualize the distribution (count column) .SH OVERHEAD This uses sampling at 99 Hertz (on all CPUs), and in-kernel summaries, which should make overhead negligible. This does not trace scheduler events, like runqlen does, which comes at a much higher overhead cost. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 runqlat(8), pidstat(1) bpfcc-0.2.0+git0.02884a026/man/man8/slabratetop.8000066400000000000000000000035321305314114400205300ustar00rootroot00000000000000.TH slabratetop 8 "2016-10-17" "USER COMMANDS" .SH NAME slabratetop \- Kernel SLAB/SLUB memory cache allocation rate top. Uses Linux BPF/bcc. .SH SYNOPSIS .B slabratetop [\-h] [\-C] [\-r MAXROWS] [interval] [count] .SH DESCRIPTION This is top for the the rate of kernel SLAB/SLUB memory allocations. It works by tracing kmem_cache_alloc() calls, a commonly used interface for kernel memory allocation (SLAB or SLUB). It summarizes the rate and total bytes allocated of these calls per interval: the activity. Compare this to slabtop(1), which shows the current static volume of the caches. This tool uses kernel dynamic tracing of the kmem_cache_alloc() function. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-C Don't clear the screen. .TP \-r MAXROWS Maximum number of rows to print. Default is 20. .TP interval Interval between updates, seconds. .TP count Number of interval summaries. .SH EXAMPLES .TP Summarize active kernel SLAB/SLUB calls (kmem_cache_alloc()), showing the top 20 caches every second: # .B slabratetop .TP Don't clear the screen, and top 8 rows only: # .B slabratetop -Cr 8 .TP 5 second summaries, 10 times only: # .B slabratetop 5 10 .SH FIELDS .TP loadavg: The contents of /proc/loadavg .TP CACHE Kernel cache name. .TP ALLOCS Allocations (number of calls). .TP BYTES Total bytes allocated. .SH OVERHEAD If kmem_cache_alloc() is called at a high rate (eg, >100k/second) the overhead of this tool might begin to be measurable. The rate can be seen in the ALLOCS column of the output. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 slabtop(1) bpfcc-0.2.0+git0.02884a026/man/man8/softirqs.8000066400000000000000000000046711305314114400200670ustar00rootroot00000000000000.TH softirqs 8 "2015-10-20" "USER COMMANDS" .SH NAME softirqs \- Measure soft IRQ (soft interrupt) event time. Uses Linux eBPF/bcc. .SH SYNOPSIS .B softirqs [\-h] [\-T] [\-N] [\-d] [interval] [count] .SH DESCRIPTION This summarizes the time spent servicing soft IRQs (soft interrupts), and can show this time as either totals or histogram distributions. A system-wide summary of this time is shown by the %soft column of mpstat(1), and soft IRQ event counts (but not times) are available in /proc/softirqs. WARNING: This currently uses dynamic tracing of various soft interrupt functions, and can easily not work with different kernel versions. Check and adjust the code as necessary. Also try in a test environment and ensure this tool is safe before use. Future versions should switch to tracepoints. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Include timestamps on output. .TP \-N Output in nanoseconds .TP \-d Show IRQ time distribution as histograms .SH EXAMPLES .TP Sum soft IRQ event time until Ctrl-C: # .B softirqs .TP Show soft IRQ event time as histograms: # .B softirqs \-d .TP Print 1 second summaries, 10 times: # .B softirqs 1 10 .TP 1 second summaries, printed in nanoseconds, with timestamps: # .B softirqs \-NT 1 .SH FIELDS .TP SOFTIRQ The kernel function name that performs the soft IRQ action. .TP TOTAL_usecs Total time spent in this soft IRQ function in microseconds. .TP TOTAL_nsecs Total time spent in this soft IRQ function in nanoseconds. .TP usecs Range of microseconds for this bucket. .TP nsecs Range of nanoseconds for this bucket. .TP count Number of soft IRQs in this time range. .TP distribution ASCII representation of the distribution (the count column). .SH OVERHEAD This traces kernel functions and maintains in-kernel counts, which are asynchronously copied to user-space. While the rate of interrupts be very high (>1M/sec), this is a relatively efficient way to trace these events, and so the overhead is expected to be small for normal workloads, but could become noticeable for heavy workloads. Measure in a test environment before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 hardirqs(8) bpfcc-0.2.0+git0.02884a026/man/man8/sslsniff.8000066400000000000000000000021621305314114400200350ustar00rootroot00000000000000.TH sslsniff 8 "2016-08-16" "USER COMMANDS" .SH NAME sslsniff \- Print data passed to OpenSSL. Uses Linux eBPF/bcc. .SH SYNOPSIS .B sslsniff .SH DESCRIPTION sslsniff prints data sent to SSL_write and SSL_read OpenSSL functions, allowing us to read plain text content before encryption (when writing) and after decryption (when reading). This works reading the second parameter of both functions (*buf). Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Print all calls to SSL_write and SSL_read system-wide: # .B sslsniff .SH FIELDS .TP FUNC Which function is being called (SSL_write or SSL_read) .TP TIME Time of the command, in seconds. .TP COMM Entered command. .TP PID Process ID calling OpenSSL. .TP LEN Bytes written or read by OpenSSL functions. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHORS Adrian Lopez and Mark Drayton .SH SEE ALSO trace(8) bpfcc-0.2.0+git0.02884a026/man/man8/stackcount.8000066400000000000000000000067311305314114400203720ustar00rootroot00000000000000.TH stackcount 8 "2016-01-14" "USER COMMANDS" .SH NAME stackcount \- Count function calls and their stack traces. Uses Linux eBPF/bcc. .SH SYNOPSIS .B stackcount [\-h] [\-p PID] [\-i INTERVAL] [\-T] [\-r] [\-s] [\-P] [\-v] [\-d] pattern .SH DESCRIPTION stackcount traces functions and frequency counts them with their entire stack trace, summarized in-kernel for efficiency. This allows higher frequency events to be studied. The output consists of unique stack traces, and their occurrence counts. In addition to kernel and user functions, kernel tracepoints and USDT tracepoint are also supported. The pattern is a string with optional '*' wildcards, similar to file globbing. If you'd prefer to use regular expressions, use the \-r option. This tool only works on Linux 4.6+. Stack traces are obtained using the new `BPF_STACK_TRACE` APIs. For kernels older than 4.6, see the version under tools/old. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-r Allow regular expressions for the search pattern. The default allows "*" wildcards only. .TP \-s Show address offsets. .TP \-T Include a timestamp with interval output. .TP \-v Show raw addresses. .TP \-d Print the source of the BPF program when loading it (for debugging purposes). .TP \-i interval Summary interval, in seconds. .TP \-p PID Trace this process ID only (filtered in-kernel). .TP .TP pattern A function name, or a search pattern. Can include wildcards ("*"). If the \-r option is used, can include regular expressions. .SH EXAMPLES .TP Count kernel stack traces for submit_bio(): # .B stackcount submit_bio .TP Count kernel stack traces for ip_output(): # .B stackcount ip_output .TP Show symbol offsets: # .B stackcount -s ip_output .TP Show offsets and raw addresses (verbose): # .B stackcount -sv ip_output .TP Count kernel stacks for kernel functions matching tcp_send*: # .B stackcount 'tcp_send*' .TP Same as previous, but using regular expressions: # .B stackcount -r '^tcp_send.*' .TP Output every 5 seconds, with timestamps: # .B stackcount -Ti 5 ip_output .TP Only count stacks when PID 185 is on-CPU: # .B stackcount -p 185 ip_output .TP Count user stacks for dynamic heap allocations with malloc in PID 185: # .B stackcount -p 185 c:malloc .TP Count user stacks for thread creation (USDT tracepoint) in PID 185: # .B stackcount -p 185 u:pthread:pthread_create .TP Count kernel stacks for context switch events using a kernel tracepoint: # .B stackcount t:sched:sched_switch .SH OVERHEAD This summarizes unique stack traces in-kernel for efficiency, allowing it to trace a higher rate of function calls than methods that post-process in user space. The stack trace data is only copied to user space when the output is printed, which usually only happens once. The stack walking also happens in an optimized code path in the kernel thanks to the new BPF_STACK_TRACE table APIs, which should be more efficient than the manual walker in the eBPF tracer which older versions of this script used. With this in mind, call rates of < 10,000/sec would incur negligible overhead. Test before production use. You can also use funccount to get a handle on function call rates first. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg, Sasha Goldshtein .SH SEE ALSO stacksnoop(8), funccount(8) bpfcc-0.2.0+git0.02884a026/man/man8/stacksnoop.8000066400000000000000000000041331305314114400203720ustar00rootroot00000000000000.TH stacksnoop 8 "2016-01-14" "USER COMMANDS" .SH NAME stacksnoop \- Print kernel stack traces for kernel functions. Uses Linux eBPF/bcc. .SH SYNOPSIS .B stacksnoop [\-h] [\-p PID] [\-s] [\-v] function .SH DESCRIPTION stacksnoop traces a given kernel function and for each call, prints the kernel stack back trace for that call. This shows the ancestry of function calls, and is a quick way to investigate low frequency kernel functions and their cause. For high frequency kernel functions, see stackcount. This tool only works on Linux 4.6+. Stack traces are obtained using the new BPF_STACK_TRACE` APIs. For kernels older than 4.6, see the version under tools/old. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-s Show address offsets. .TP \-v Print more fields. .TP \-p PID Trace this process ID only (filtered in-kernel). .TP function Kernel function name. .SH EXAMPLES .TP Print kernel stack traces for each call to ext4_sync_fs: # .B stacksnoop ext4_sync_fs .TP Also show the symbol offsets: # .B stacksnoop -s ext4_sync_fs .TP Show extra columns: # .B stacksnoop -v ext4_sync_fs .TP Only trace when PID 185 is on-CPU: # .B stacksnoop -p 185 ext4_sync_fs .SH FIELDS .TP TIME(s) Time of the call, in seconds. .TP STACK Kernel stack trace. The first column shows "ip" for instruction pointer, and "r#" for each return pointer in the stack. The second column is the stack trace as hexadecimal. The third column is the translated kernel symbol names. .SH OVERHEAD This can have significant overhead if frequently called functions (> 1000/s) are traced, and is only intended for low frequency function calls. This is because details including the stack trace for every call is passed to user space and processed. See stackcount for higher frequency calls, which performs in-kernel summaries. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 stackcount(8) bpfcc-0.2.0+git0.02884a026/man/man8/statsnoop.8000066400000000000000000000041571305314114400202460ustar00rootroot00000000000000.TH statsnoop 8 "2016-02-08" "USER COMMANDS" .SH NAME statsnoop \- Trace stat() syscalls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B statsnoop [\-h] [\-t] [\-x] [\-p PID] .SH DESCRIPTION statsnoop traces the different stat() syscalls, showing which processes are attempting to read information about which files. This can be useful for determining the location of config and log files, or for troubleshooting applications that are failing, especially on startup. This works by tracing various kernel sys_stat() functions using dynamic tracing, and will need updating to match any changes to these functions. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-t Include a timestamp column: in seconds since the first event, with decimal places. .TP \-x Only print failed stats. .TP \-p PID Trace this process ID only (filtered in-kernel). .SH EXAMPLES .TP Trace all stat() syscalls: # .B statsnoop .TP Trace all stat() syscalls, and include timestamps: # .B statsnoop \-t .TP Trace only stat() syscalls that failed: # .B statsnoop \-x .TP Trace PID 181 only: # .B statsnoop \-p 181 .SH FIELDS .TP TIME(s) Time of the call, in seconds. .TP PID Process ID .TP COMM Process name .TP FD File descriptor (if success), or -1 (if failed) .TP ERR Error number (see the system's errno.h) .TP PATH Open path .SH OVERHEAD This traces the kernel stat function and prints output for each event. As the rate of this is generally expected to be low (< 1000/s), the overhead is also expected to be negligible. If you have an application that is calling a high rate of stat()s, then test and understand overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 opensnoop(1) bpfcc-0.2.0+git0.02884a026/man/man8/syncsnoop.8000066400000000000000000000026331305314114400202440ustar00rootroot00000000000000.TH syncsnoop 8 "2015-08-18" "USER COMMANDS" .SH NAME syncsnoop \- Trace sync() syscall. Uses Linux eBPF/bcc. .SH SYNOPSIS .B syncsnoop .SH DESCRIPTION syncsnoop traces calls to sync(), which flushes file system buffers to storage devices. These calls can cause performance perturbations, and it can be useful to know if they are happening and how frequently. This works by tracing the kernel sys_sync() function using dynamic tracing, and will need updating to match any changes to this function. This makes use of a Linux 4.5 feature (bpf_perf_event_output()); for kernels older than 4.5, see the version under tools/old, which uses an older mechanism. This program is also a basic example of eBPF/bcc. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Trace calls to sync(): # .B syncsnoop .SH FIELDS .TP TIME(s) Time of the call, in seconds. .TP CALL Call traced. .SH OVERHEAD This traces the kernel sync function and prints output for each event. As the rate of this is generally expected to be low (<< 100/s), the overhead is also expected to be negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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) bpfcc-0.2.0+git0.02884a026/man/man8/syscount.8000066400000000000000000000050071305314114400200760ustar00rootroot00000000000000.TH syscount 8 "2017-02-15" "USER COMMANDS" .SH NAME syscount \- Summarize syscall counts and latencies. .SH SYNOPSIS .B syscount [-h] [-p PID] [-i INTERVAL] [-T TOP] [-x] [-L] [-m] [-P] [-l] .SH DESCRIPTION This tool traces syscall entry and exit tracepoints and summarizes either the number of syscalls of each type, or the number of syscalls per process. It can also collect latency (invocation time) for each syscall or each process. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. Linux 4.7+ is required to attach a BPF program to the raw_syscalls:sys_{enter,exit} tracepoints, used by this tool. .SH OPTIONS .TP \-h Print usage message. .TP \-p PID Trace only this process. .TP \-i INTERVAL Print the summary at the specified interval (in seconds). .TP \-T TOP Print only this many entries. Default: 10. .TP \-x Trace only failed syscalls (i.e., the return value from the syscall was < 0). .TP \-m Display times in milliseconds. Default: microseconds. .TP \-P Summarize by process and not by syscall. .TP \-l List the syscalls recognized by the tool (hard-coded list). Syscalls beyond this list will still be displayed, as "[unknown: nnn]" where nnn is the syscall number. .SH EXAMPLES .TP Summarize all syscalls by syscall: # .B syscount .TP Summarize all syscalls by process: # .B syscount \-P .TP Summarize only failed syscalls: # .B syscount \-x .TP Trace PID 181 only: # .B syscount \-p 181 .TP Summarize syscalls counts and latencies: # .B syscount \-L .SH FIELDS .TP PID Process ID .TP COMM Process name .TP SYSCALL Syscall name, or "[unknown: nnn]" for syscalls that aren't recognized .TP COUNT The number of events .TP TIME The total elapsed time (in us or ms) .SH OVERHEAD For most applications, the overhead should be manageable if they perform 1000's or even 10,000's of syscalls per second. For higher rates, the overhead may become considerable. For example, tracing a loop of 4 million calls to geteuid(), slows it down by 1.85x when tracing only syscall counts, and slows it down by more than 5x when tracing syscall counts and latencies. However, this represents a rate of >3.5 million syscalls per second, which should not be typical. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO funccount(8), ucalls(8), argdist(8), trace(8), funclatency(8) bpfcc-0.2.0+git0.02884a026/man/man8/tcpaccept.8000066400000000000000000000041651305314114400201610ustar00rootroot00000000000000.TH tcpaccept 8 "2015-08-25" "USER COMMANDS" .SH NAME tcpaccept \- Trace TCP passive connections (accept()). Uses Linux eBPF/bcc. .SH SYNOPSIS .B tcpaccept [\-h] [\-t] [\-x] [\-p PID] .SH DESCRIPTION This tool traces passive TCP connections (eg, via an accept() syscall; connect() are active connections). This can be useful for general troubleshooting to see what new connections the local server is accepting. This uses dynamic tracing of the kernel inet_csk_accept() socket function (from tcp_prot.accept), and will need to be modified to match kernel changes. This tool only traces successful TCP accept()s. Connection attempts to closed ports will not be shown (those can be traced via other functions). Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-t Include a timestamp column. .TP \-p PID Trace this process ID only (filtered in-kernel). .SH EXAMPLES .TP Trace all passive TCP connections (accept()s): # .B tcpaccept .TP Trace all TCP accepts, and include timestamps: # .B tcpconnect \-t .TP Trace PID 181 only: # .B tcpconnect \-p 181 .SH FIELDS .TP TIME(s) Time of the event, in seconds. .TP PID Process ID .TP COMM Process name .TP IP IP address family (4 or 6) .TP RADDR Remote IP address. .TP LADDR Local IP address. .TP LPORT Local port .SH OVERHEAD This traces the kernel inet_csk_accept function and prints output for each event. The rate of this depends on your server application. If it is a web or proxy server accepting many tens of thousands of connections per second, then the overhead of this tool may be measurable (although, still a lot better than tracing every packet). If it is less than a thousand a second, then the overhead is expected to be negligible. Test and understand this overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 tcpconnect(8), funccount(8), tcpdump(8) bpfcc-0.2.0+git0.02884a026/man/man8/tcpconnect.8000066400000000000000000000041251305314114400203470ustar00rootroot00000000000000.TH tcpconnect 8 "2015-08-25" "USER COMMANDS" .SH NAME tcpconnect \- Trace TCP active connections (connect()). Uses Linux eBPF/bcc. .SH SYNOPSIS .B tcpconnect [\-h] [\-t] [\-x] [\-p PID] [-P PORT] .SH DESCRIPTION This tool traces active TCP connections (eg, via a connect() syscall; accept() are passive connections). This can be useful for general troubleshooting to see what connections are initiated by the local server. All connection attempts are traced, even if they ultimately fail. This works by tracing the kernel tcp_v4_connect() and tcp_v6_connect() functions using dynamic tracing, and will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-t Include a timestamp column. .TP \-p PID Trace this process ID only (filtered in-kernel). .TP \-P PORT Comma-separated list of destination ports to trace (filtered in-kernel). .SH EXAMPLES .TP Trace all active TCP connections: # .B tcpconnect .TP Trace all TCP connects, and include timestamps: # .B tcpconnect \-t .TP Trace PID 181 only: # .B tcpconnect \-p 181 .TP Trace ports 80 and 81 only: # .B tcpconnect \-P 80,81 .SH FIELDS .TP TIME(s) Time of the call, in seconds. .TP PID Process ID .TP COMM Process name .TP IP IP address family (4 or 6) .TP SADDR Source IP address. .TP DADDR Destination IP address. .TP DPORT Destination port .SH OVERHEAD This traces the kernel tcp_v[46]_connect functions and prints output for each event. As the rate of this is generally expected to be low (< 1000/s), the overhead is also expected to be negligible. If you have an application that is calling a high rate of connects()s, such as a proxy server, then test and understand this overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 tcpaccept(8), funccount(8), tcpdump(8) bpfcc-0.2.0+git0.02884a026/man/man8/tcpconnlat.8000066400000000000000000000051471305314114400203610ustar00rootroot00000000000000.TH tcpconnect 8 "2016-02-19" "USER COMMANDS" .SH NAME tcpconnect \- Trace TCP active connection latency. Uses Linux eBPF/bcc. .SH SYNOPSIS .B tcpconnect [\-h] [\-t] [\-p PID] .SH DESCRIPTION This tool traces active TCP connections (eg, via a connect() syscall), and shows the latency (time) for the connection as measured locally: the time from SYN sent to the response packet. This is a useful performance metric that typically spans kernel TCP/IP processing and the network round trip time (not application runtime). All connection attempts are traced, even if they ultimately fail (RST packet in response). This tool works by use of kernel dynamic tracing of TCP/IP functions, and will need updating to match any changes to these functions. This tool should be updated in the future to use static tracepoints, once they are available. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-t Include a timestamp column. .TP \-p PID Trace this process ID only (filtered in-kernel). .SH EXAMPLES .TP Trace all active TCP connections, and show connection latency (SYN->response round trip): # .B tcpconnect .TP Include timestamps: # .B tcpconnect \-t .TP Trace PID 181 only: # .B tcpconnect \-p 181 .SH FIELDS .TP TIME(s) Time of the response packet, in seconds. .TP PID Process ID that initiated the connection. .TP COMM Process name that initiated the connection. .TP IP IP address family (4 or 6). .TP SADDR Source IP address. .TP DADDR Destination IP address. .TP DPORT Destination port .TP LAT(ms) The time from when a TCP connect was issued (measured in-kernel) to when a response packet was received for this connection (can be SYN,ACK, or RST, etc). This time spans kernel to kernel latency, involving kernel TCP/IP processing and the network round trip in between. This typically does not include time spent by the application processing the new connection. .SH OVERHEAD This traces the kernel tcp_v[46]_connect functions and prints output for each event. As the rate of this is generally expected to be low (< 1000/s), the overhead is also expected to be negligible. If you have an application that is calling a high rate of connects()s, such as a proxy server, then test and understand this overhead before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 tcpconnect(8), tcpaccept(8), funccount(8), tcpdump(8) bpfcc-0.2.0+git0.02884a026/man/man8/tcplife.8000066400000000000000000000057471305314114400176500ustar00rootroot00000000000000.TH tcplife 8 "2016-10-19" "USER COMMANDS" .SH NAME tcplife \- Trace TCP sessions and summarize lifespan. Uses Linux eBPF/bcc. .SH SYNOPSIS .B tcplife [\-h] [\-T] [\-t] [\-w] [\-s] [\-p PID] [\-D PORTS] [\-L PORTS] .SH DESCRIPTION This tool traces TCP sessions that open and close while tracing, and prints a line of output to summarize each one. This includes the IP addresses, ports, duration, and throughput for the session. This is useful for workload characterisation and flow accounting: identifying what connections are happening, with the bytes transferred. This tool works by using kernel dynamic tracing, and will need to be updated if the kernel implementation changes. Only TCP state changes are traced, so it is expected that the overhead of this tool is much lower than typical send/receive tracing. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-s Comma separated values output (parseable). .TP \-t Include a timestamp column (seconds). .TP \-T Include a time column (HH:MM:SS). .TP \-w Wide column output (fits IPv6 addresses). .TP \-p PID Trace this process ID only (filtered in-kernel). .TP \-L PORTS Comma-separated list of local ports to trace (filtered in-kernel). .TP \-D PORTS Comma-separated list of destination ports to trace (filtered in-kernel). .SH EXAMPLES .TP Trace all TCP sessions, and summarize lifespan and throughput: # .B tcplife .TP Include a timestamp column, and wide column output: # .B tcplife \-tw .TP Trace PID 181 only: # .B tcplife \-p 181 .TP Trace connections to local ports 80 and 81 only: # .B tcplife \-L 80,81 .TP Trace connections to remote port 80 only: # .B tcplife \-D 80 .SH FIELDS .TP TIME Time of the call, in HH:MM:SS format. .TP TIME(s) Time of the call, in seconds. .TP PID Process ID .TP COMM Process name .TP IP IP address family (4 or 6) .TP LADDR Local IP address. .TP DADDR Remote IP address. .TP LPORT Local port. .TP DPORT Destination port. .TP TX_KB Total transmitted Kbytes. .TP RX_KB Total received Kbytes. .TP MS Lifespan of the session, in milliseconds. .SH OVERHEAD This traces the kernel TCP set state function, which should be called much less often than send/receive tracing, and therefore have lower overhead. The overhead of the tool is relative to the rate of new TCP sessions: if this is high, over 10,000 per second, then there may be noticable overhead just to print out 10k lines of formatted output per second. You can find out the rate of new TCP sessions using "sar \-n TCP 1", and adding the active/s and passive/s columns. As always, test and understand this tools overhead for your types of workloads before production use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 tcpaccept(8), tcpconnect(8), tcptop(8) bpfcc-0.2.0+git0.02884a026/man/man8/tcpretrans.8000066400000000000000000000036241305314114400203770ustar00rootroot00000000000000.TH tcpaccept 8 "2016-02-14" "USER COMMANDS" .SH NAME tcpaccept \- Trace TCP retransmits and TLPs. Uses Linux eBPF/bcc. .SH SYNOPSIS .B tcpaccept [\-h] [\-l] .SH DESCRIPTION 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 very low, only the TCP retransmit functions are traced. This does not trace every packet (like tcpdump(8) or a packet sniffer). This uses dynamic tracing of the kernel tcp_retransmit_skb() and tcp_send_loss_probe() functions, and will need to be updated to match kernel changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-l Include tail loss probe attempts (in some cases the kernel may not complete the TLP send). .SH EXAMPLES .TP Trace TCP retransmits: # .B tcpretrans .TP Trace TCP retransmits and TLP attempts: # .B tcpconnect \-l .SH FIELDS .TP TIME Time of the retransmit. .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 IP IP address family (4 or 6). .TP LADDR Local IP address. .TP LPORT Local port. .TP T> Type of event: R> == retransmit, L> == tail loss probe. .TP RADDR Remote IP address. .TP RPORT Remote port. .TP STATE TCP session state. .SH OVERHEAD Should be negligible: TCP retransmit events should be low (<1000/s), and the low overhead this tool adds to each event should make the cost negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 tcpconnect(8), tcpaccept(8) bpfcc-0.2.0+git0.02884a026/man/man8/tcptop.8000066400000000000000000000055521305314114400175250ustar00rootroot00000000000000.TH tcptop 8 "2016-09-13" "USER COMMANDS" .SH NAME tcptop \- Summarize TCP send/recv throughput by host. Top for TCP. .SH SYNOPSIS .B tcptop [\-h] [\-C] [\-S] [\-p PID] [interval] [count] .SH DESCRIPTION This is top for TCP sessions. This summarizes TCP send/receive Kbytes by host, and prints a summary that refreshes, along other system-wide metrics. This uses dynamic tracing of kernel TCP send/receive functions, and will need to be updated to match kernel changes. The traced TCP functions are usually called at a lower rate than per-packet functions, and therefore have lower overhead. The traced data is summarized in-kernel using a BPF map to further reduce overhead. At very high TCP event rates, the overhead may still be measurable. See the OVERHEAD section for more details. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print USAGE message. .TP \-C Don't clear the screen. .TP \-S Don't print the system summary line (load averages). .TP \-p PID Trace this PID only. .TP interval Interval between updates, seconds (default 1). .TP count Number of interval summaries (default is many). .SH EXAMPLES .TP Summarize TCP throughput by active sessions, 1 second refresh: # .B tcptop .TP Don't clear the screen (rolling output), and 5 second summaries: # .B tcptop \-C 5 .TP Trace PID 181 only, and don't clear the screen: # .B tcptop \-Cp 181 .SH FIELDS .TP loadavg: The contents of /proc/loadavg .TP PID Process ID. .TP COMM Process name. .TP LADDR Local address (IPv4), and TCP port .TP RADDR Remote address (IPv4), and TCP port .TP LADDR6 Source address (IPv6), and TCP port .TP RADDR6 Destination address (IPv6), and TCP port .TP RX_KB Received Kbytes .TP TX_KB Transmitted Kbytes .SH OVERHEAD This traces all send/receives in TCP, high in the TCP/IP stack (close to the application) which are usually called at a lower rate than per-packet functions, lowering overhead. It also summarizes data in-kernel to further reduce overhead. These techniques help, but there may still be measurable overhead at high send/receive rates, eg, ~13% of one CPU at 100k events/sec. use funccount to count the kprobes in the tool to find out this rate, as the overhead is relative to the rate. Some sample production servers tested found total TCP event rates of 4k to 15k per second, and the CPU overhead at these rates ranged from 0.5% to 2.0% of one CPU. If your send/receive rate is low (eg, <1000/sec) then the overhead is expected to be negligible; Test in a lab environment first. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Brendan Gregg .SH INSPIRATION top(1) by William LeFebvre .SH SEE ALSO tcpconnect(8), tcpaccept(8) bpfcc-0.2.0+git0.02884a026/man/man8/tplist.8000066400000000000000000000035021305314114400175240ustar00rootroot00000000000000.TH tplist 8 "2016-03-20" "USER COMMANDS" .SH NAME tplist \- Display kernel tracepoints or USDT probes and their formats. .SH SYNOPSIS .B tplist [-p PID] [-l LIB] [-v] [filter] .SH DESCRIPTION tplist lists all kernel tracepoints, and can optionally print out the tracepoint format; namely, the variables that you can trace when the tracepoint is hit. tplist can also list USDT probes embedded in a specific library or executable, and can list USDT probes for all the libraries loaded by a specific process. These features are usually used in conjunction with the argdist and/or trace tools. On a typical system, accessing the tracepoint list and format requires root. However, accessing USDT probes does not require root. .SH OPTIONS .TP \-p PID Display the USDT probes from all the libraries loaded by the specified process. .TP \-l LIB Display the USDT probes from the specified library or executable. If the librar or executable can be found in the standard paths, a full path is not required. .TP \-v Increase the verbosity level. Can be used to display the variables, locations, and arguments of tracepoints and USDT probes. .TP [filter] A wildcard expression that specifies which tracepoints or probes to print. For example, block:* will print all block tracepoints (block:block_rq_complete, etc.). Regular expressions are not supported. .SH EXAMPLES .TP Print all kernel tracepoints: # .B tplist .TP Print all net tracepoints with their format: # .B tplist -v 'net:*' .TP Print all USDT probes in libpthread: $ .B tplist -l pthread .TP Print all USDT probes in process 4717 from the libc provider: $ .B tplist -p 4717 'libc:*' .TP Print all the USDT probes in the node executable: $ .B tplist -l node .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein bpfcc-0.2.0+git0.02884a026/man/man8/trace.8000066400000000000000000000157231305314114400173130ustar00rootroot00000000000000.TH trace 8 "2016-02-18" "USER COMMANDS" .SH NAME trace \- Trace a function and print its arguments or return value, optionally evaluating a filter. Uses Linux eBPF/bcc. .SH SYNOPSIS .B trace [-h] [-p PID] [-L TID] [-v] [-Z STRING_SIZE] [-S] [-M MAX_EVENTS] [-t] [-T] [-K] [-U] [-I header] probe [probe ...] .SH DESCRIPTION trace probes functions you specify and displays trace messages if a particular condition is met. You can control the message format to display function arguments and return values. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-p PID Trace only functions in the process PID. .TP \-L TID Trace only functions in the thread TID. .TP \-v Display the generated BPF program, for debugging purposes. .TP \-z STRING_SIZE When collecting string arguments (of type char*), collect up to STRING_SIZE characters. Longer strings will be truncated. .TP \-S If set, trace messages from trace's own process. By default, this is off to avoid tracing storms -- for example, if you trace the write system call, and consider that trace is writing to the standard output. .TP \-M MAX_EVENTS Print up to MAX_EVENTS trace messages and then exit. .TP \-t Print times relative to the beginning of the trace (offsets), in seconds. .TP \-T Print the time column. .TP \-K Print the kernel stack for each event. .TP \-U Print the user stack for each event. .TP \-I header Additional header files to include in the BPF program. This is needed if your filter or print expressions use types or data structures that are not available in the standard headers. For example: 'linux/mm.h' .TP probe [probe ...] One or more probes that attach to functions, filter conditions, and print information. See PROBE SYNTAX below. .SH PROBE SYNTAX The general probe syntax is as follows: .B [{p,r}]:[library]:function[(signature)] [(predicate)] ["format string"[, arguments]] .B {t:category:event,u:library:probe} [(predicate)] ["format string"[, arguments]] .TP .B {[{p,r}],t,u} Probe type \- "p" for function entry, "r" for function return, "t" for kernel tracepoint, "u" for USDT probe. The default probe type is "p". .TP .B [library] Library containing the probe. Specify the full path to the .so or executable file where the function to probe resides. Alternatively, you can specify just the lib name: for example, "c" refers to libc. If no library name is specified, the kernel is assumed. Also, you can specify an executable name (without a full path) if it is in the PATH. For example, "bash". .TP .B category The tracepoint category. For example, "sched" or "irq". .TP .B function The function to probe. .TP .B signature The optional signature of the function to probe. This can make it easier to access the function's arguments, instead of using the "arg1", "arg2" etc. argument specifiers. For example, "(struct timespec *ts)" in the signature position lets you use "ts" in the filter or print expressions. .TP .B event The tracepoint event. For example, "block_rq_complete". .TP .B probe The USDT probe name. For example, "pthread_create". .TP .B [(predicate)] The filter applied to the captured data. Only if the filter evaluates as true, the trace message will be printed. The filter can use any valid C expression that refers to the argument values: arg1, arg2, etc., or to the return value retval in a return probe. If necessary, use C cast operators to coerce the arguments to the desired type. For example, if arg1 is of type int, use the expression ((int)arg1 < 0) to trace only invocations where arg1 is negative. Note that only arg1-arg6 are supported, and only if the function is using the standard x86_64 convention where the first six arguments are in the RDI, RSI, RDX, RCX, R8, R9 registers. If no predicate is specified, all function invocations are traced. The predicate expression may also use the STRCMP pseudo-function to compare a predefined string to a string argument. For example: STRCMP("test", arg1). The order of arguments is important: the first argument MUST be a quoted literal string, and the second argument can be a runtime string, most typically an argument. .TP .B ["format string"[, arguments]] A printf-style format string that will be used for the trace message. You can use the following format specifiers: %s, %d, %u, %lld, %llu, %hd, %hu, %c, %x, %llx -- with the same semantics as printf's. Make sure to pass the exact number of arguments as there are placeholders in the format string. The format specifier replacements may be any C expressions, and may refer to the same special keywords as in the predicate (arg1, arg2, etc.). In addition to the above format specifiers, you can also use %K and %U when the expression is an address that potentially points to executable code (i.e., a symbol). trace will resolve %K specifiers to a kernel symbol, such as vfs__read, and will resolve %U specifiers to a user-space symbol in that process, such as sprintf. In tracepoints, both the predicate and the arguments may refer to the tracepoint format structure, which is stored in the special "args" variable. For example, the block:block_rq_complete tracepoint can print or filter by args->nr_sector. To discover the format of your tracepoint, use the tplist tool. In USDT probes, the arg1, ..., argN variables refer to the probe's arguments. To determine which arguments your probe has, use the tplist tool. The predicate expression and the format specifier replacements for printing may also use the following special keywords: $pid, $tgid to refer to the current process' pid and tgid; $uid, $gid to refer to the current user's uid and gid; $cpu to refer to the current processor number. .SH EXAMPLES .TP Trace all invocations of the open system call with the name of the file being opened: # .B trace '::do_sys_open """%s"", arg2' .TP Trace all invocations of the read system call where the number of bytes requested is greater than 20,000: # .B trace '::sys_read (arg3 > 20000) """read %d bytes"", arg3' .TP Trace all malloc calls and print the size of the requested allocation: # .B trace ':c:malloc """size = %d"", arg1' .TP Trace returns from the readline function in bash and print the return value as a string: # .B trace 'r:bash:readline """%s"", retval' .TP Trace the block:block_rq_complete tracepoint and print the number of sectors completed: # .B trace 't:block:block_rq_complete """%d sectors"", args->nr_sector' .TP Trace the pthread_create USDT probe from the pthread library and print the address of the thread's start function: # .B trace 'u:pthread:pthread_create """start addr = %llx"", arg3' .TP Trace the nanosleep system call and print the sleep duration in nanoseconds: # .B trace 'p::SyS_nanosleep(struct timespec *ts) "sleep for %lld ns", ts->tv_nsec' .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein bpfcc-0.2.0+git0.02884a026/man/man8/ttysnoop.8000066400000000000000000000027011305314114400201040ustar00rootroot00000000000000.TH ttysnoop 8 "2016-02-08" "USER COMMANDS" .SH NAME ttysnoop \- Watch output from a tty or pts device. Uses Linux eBPF/bcc. .SH SYNOPSIS .B ttysnoop [\-h] [\-C] device .SH DESCRIPTION ttysnoop watches a tty or pts device, and prints the same output that is appearing on that device. It can be used to mirror the output from a shell session, or the system console. This works by use of kernel dynamic tracing of the tty_write() function. This tool will need updating in case that kernel function changes in a future kernel version. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-C Don't clear the screen. .TP device Either a path to a tty device (eg, /dev/tty0) or a pts number (eg, the "3" from /dev/pts/3). .SH EXAMPLES .TP Snoop output from /dev/pts/2 # .B ttysnoop /dev/pts/2 .TP Snoop output from /dev/pts/2 (shortcut) # .B ttysnoop 2 .TP Snoop output from the system console # .B ttysnoop /dev/console .TP Snoop output from /dev/tty0 # .B ttysnoop /dev/tty0 .SH OVERHEAD As the rate of tty_write() is expected to be very low (<100/s), the overhead of this tool is expected to be negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 opensnoop(1) bpfcc-0.2.0+git0.02884a026/man/man8/ucalls.8000066400000000000000000000053241305314114400174740ustar00rootroot00000000000000.TH ucalls 8 "2016-11-07" "USER COMMANDS" .SH NAME ucalls \- Summarize method calls from high-level languages and Linux syscalls. .SH SYNOPSIS .B ucalls [-l {java,python,ruby,php}] [-h] [-T TOP] [-L] [-S] [-v] [-m] pid [interval] .SH DESCRIPTION This tool summarizes method calls from high-level languages such as Python, Java, Ruby, and PHP. It can also trace Linux system calls. Whenever a method is invoked, ucalls records the call count and optionally the method's execution time (latency) and displays a summary. This uses in-kernel eBPF maps to store per process summaries for efficiency. This tool relies on USDT probes embedded in many high-level languages, such as Java, Python, Ruby, and PHP. It requires a runtime instrumented with these probes, which in some cases requires building from source with a USDT-specific flag, such as "--enable-dtrace" or "--with-dtrace". For Java, method probes are not enabled by default, and can be turned on by running the Java process with the "-XX:+ExtendedDTraceProbes" flag. For PHP processes, the environment variable USE_ZEND_DTRACE must be set to 1. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-l {java,python,ruby,php} The language to trace. If not provided, only syscalls are traced (when the \-S option is used). .TP \-T TOP Print only the top methods by frequency or latency. .TP \-L Collect method invocation latency (duration). .TP \-S Collect Linux syscalls frequency and timing. .TP \-v Print the resulting BPF program, for debugging purposes. .TP \-m Print times in milliseconds (the default is microseconds). .TP pid The process id to trace. .TP interval Print summary after this number of seconds and then exit. By default, wait for Ctrl+C to terminate. .SH EXAMPLES .TP Trace the top 10 Ruby method calls: # .B ucalls -T 10 -l ruby 1344 .TP Trace Python method calls and Linux syscalls including latency in milliseconds: # .B ucalls -l python -mL 2020 .TP Trace only syscalls and print a summary after 10 seconds: # .B ucalls -S 788 10 .SH OVERHEAD Tracing individual method calls will produce a considerable overhead in all high-level languages. For languages with just-in-time compilation, such as Java, the overhead can be more considerable than for interpreted languages. On the other hand, syscall tracing will typically be tolerable for most processes, unless they have a very unusual rate of system calls. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _example.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO ustat(8), argdist(8) bpfcc-0.2.0+git0.02884a026/man/man8/uflow.8000066400000000000000000000050671305314114400173510ustar00rootroot00000000000000.TH uflow 8 "2016-11-07" "USER COMMANDS" .SH NAME uflow \- Print a flow graph of method calls in high-level languages. .SH SYNOPSIS .B uflow [-h] [-M METHOD] [-C CLAZZ] [-v] {java,python,ruby,php} pid .SH DESCRIPTION uflow traces method calls and prints them in a flow graph that can facilitate debugging and diagnostics by following the program's execution (method flow). This tool relies on USDT probes embedded in many high-level languages, such as Java, Python, Ruby, and PHP. It requires a runtime instrumented with these probes, which in some cases requires building from source with a USDT-specific flag, such as "--enable-dtrace" or "--with-dtrace". For Java processes, the startup flag "-XX:+ExtendedDTraceProbes" is required. For PHP processes, the environment variable USE_ZEND_DTRACE must be set to 1. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-M METHOD Print only method calls where the method name begins with this string. .TP \-C CLAZZ Print only method calls where the class name begins with this string. The class name interpretation strongly depends on the language. For example, in Java use "package/subpackage/ClassName" to refer to classes. .TP \-v Print the resulting BPF program, for debugging purposes. .TP {java,python,ruby,php} The language to trace. .TP pid The process id to trace. .SH EXAMPLES .TP Follow method flow in a Ruby process: # .B uflow ruby 148 .TP Follow method flow in a Java process where the class name is java.lang.Thread: # .B uflow -C java/lang/Thread java 1802 .SH FIELDS .TP CPU The CPU number on which the method was invoked. This is useful to easily see where the output skips to a different CPU. .TP PID The process id. .TP TID The thread id. .TP TIME The duration of the method call. .TP METHOD The method name. .SH OVERHEAD This tool has extremely high overhead because it prints every method call. For some scenarios, you might see lost samples in the output as the tool is unable to keep up with the rate of data coming from the kernel. Filtering by class or method prefix can help reduce the amount of data printed, but there is still a very high overhead in the collection mechanism. Do not use for performance- sensitive production scenarios, and always test first. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _example.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO trace(8), ustat(8) bpfcc-0.2.0+git0.02884a026/man/man8/ugc.8000066400000000000000000000054331305314114400167700ustar00rootroot00000000000000.TH ugc 8 "2016-11-07" "USER COMMANDS" .SH NAME ugc \- Trace garbage collection events in high-level languages. .SH SYNOPSIS .B ugc [-h] [-v] [-m] [-M MINIMUM] [-F FILTER] {java,python,ruby,node} pid .SH DESCRIPTION This traces garbage collection events as they occur, including their duration and any additional information (such as generation collected or type of GC) provided by the respective language's runtime. This tool relies on USDT probes embedded in many high-level languages, such as Node, Java, Python, and Ruby. It requires a runtime instrumented with these probes, which in some cases requires building from source with a USDT-specific flag, such as "--enable-dtrace" or "--with-dtrace". Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-v Print the resulting BPF program, for debugging purposes. .TP \-m Print times in milliseconds. The default is microseconds. .TP \-M MINIMUM Display only collections that are longer than this threshold. The value is given in milliseconds. The default is to display all collections. .TP \-F FILTER Display only collections whose textual description matches (contains) this string. The default is to display all collections. Note that the filtering here is performed in user-space, and not as part of the BPF program. This means that if you have thousands of collection events, specifying this filter will not reduce the amount of data that has to be transferred from the BPF program to the user-space script. .TP {java,python,ruby,node} The language to trace. .TP pid The process id to trace. .SH EXAMPLES .TP Trace garbage collections in a specific Node process: # .B ugc node 148 .TP Trace garbage collections in a specific Java process, and print GC times in milliseconds: # .B ugc -m java 6004 .TP Trace garbage collections in a specific Java process, and display them only if they are longer than 10ms and have the string "Tenured" in their detailed description: # .B ugc -M 10 -F Tenured java 6004 .SH FIELDS .TP START The start time of the GC, in seconds from the beginning of the trace. .TP TIME The duration of the garbage collection event. .TP DESCRIPTION The runtime-provided description of this garbage collection event. .SH OVERHEAD Garbage collection events, even if frequent, should not produce a considerable overhead when traced because they are still not very common. Even hundreds of GCs per second (which is a very high rate) will still produce a fairly negligible overhead. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _example.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO trace(8), ustat(8), uobjnew(8) bpfcc-0.2.0+git0.02884a026/man/man8/uobjnew.8000066400000000000000000000043771305314114400176710ustar00rootroot00000000000000.TH uobjnew 8 "2016-11-07" "USER COMMANDS" .SH NAME uobjnew \- Summarize object allocations in high-level languages. .SH SYNOPSIS .B uobjnew [-h] [-C TOP_COUNT] [-S TOP_SIZE] [-v] {java,ruby,c} pid [interval] .SH DESCRIPTION uobjnew traces object allocations in high-level languages (including "malloc") and prints summaries of the most frequently allocated types by number of objects or number of bytes. This tool relies on USDT probes embedded in many high-level languages, such as Node, Java, Python, and Ruby. It requires a runtime instrumented with these probes, which in some cases requires building from source with a USDT-specific flag, such as "--enable-dtrace" or "--with-dtrace". For Java, the Java process must be started with the "-XX:+ExtendedDTraceProbes" flag. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-C TOP_COUNT Print the top object types sorted by number of instances. .TP \-S TOP_SIZE Print the top object types sorted by size. .TP \-v Print the resulting BPF program, for debugging purposes. .TP {java,ruby,c} The language to trace. .TP pid The process id to trace. .TP interval Wait this many seconds and then print the summary and exit. By default, wait for Ctrl+C to exit. .SH EXAMPLES .TP Trace object allocations in a Ruby process: # .B uobjnew ruby 148 .TP Trace object allocations from "malloc" and print the top 10 by total size: # .B uobjnew -S 10 c 1788 .SH FIELDS .TP TYPE The object type being allocated. For C (malloc), this is the block size. .TP ALLOCS The number of objects allocated. .TP BYTES The number of bytes allocated. .SH OVERHEAD Object allocation events are quite frequent, and therefore the overhead from running this tool can be considerable. Use with caution and make sure to test before using in a production environment. Nonetheless, even thousands of allocations per second will likely produce a reasonable overhead when investigating a problem. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _example.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO ustat(8), ugc(8), memleak(8) bpfcc-0.2.0+git0.02884a026/man/man8/ustat.8000066400000000000000000000070311305314114400173460ustar00rootroot00000000000000.TH ustat 8 "2016-11-07" "USER COMMANDS" .SH NAME ustat \- Activity stats from high-level languages. .SH SYNOPSIS .B ustat [-l {java,python,ruby,node,php}] [-C] [-S {cload,excp,gc,method,objnew,thread}] [-r MAXROWS] [-d] [interval [count]] .SH DESCRIPTION This is "top" for high-level language events, such as garbage collections, exceptions, thread creations, object allocations, method calls, and more. The events are aggregated for each process and printed in a top-like table, which can be sorted by various fields. This uses in-kernel eBPF maps to store per process summaries for efficiency. This tool relies on USDT probes embedded in many high-level languages, such as Node, Java, Python, Ruby, and PHP. It requires a runtime instrumented with these probes, which in some cases requires building from source with a USDT-specific flag, such as "--enable-dtrace" or "--with-dtrace". For Java, some probes are not enabled by default, and can be turned on by running the Java process with the "-XX:+ExtendedDTraceProbes" flag. For PHP processes, the environment variable USE_ZEND_DTRACE must be set to 1. Newly-created processes will only be traced at the next interval. If you run this tool with a short interval (say, 1-5 seconds), this should be virtually unnoticeable. For longer intervals, you might miss processes that were started and terminated during the interval window. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-l {java,python,ruby,node,php} The language to trace. By default, all languages are traced. .TP \-C Do not clear the screen between updates. .TP \-S {cload,excp,gc,method,objnew,thread} Sort the output by the specified field. .TP \-r MAXROWS Do not print more than this number of rows. .TP \-d Print the resulting BPF program, for debugging purposes. .TP interval Interval between updates, seconds. .TP count Number of interval summaries. .SH EXAMPLES .TP Summarize activity in high-level languages, 1 second refresh: # .B ustat .TP Don't clear the screen, and top 8 rows only: # .B ustat -Cr 8 .TP 5 second summaries, 10 times only: # .B ustat 5 10 .SH FIELDS .TP loadavg The contents of /proc/loadavg .TP PID Process ID. .TP CMDLINE Process command line (often the second and following arguments will give you a hint as to which application is being run. .TP METHOD/s Count of method invocations during interval. .TP GC/s Count of garbage collections during interval. .TP OBJNEW/s Count of objects allocated during interval. .TP CLOAD/s Count of classes loaded during interval. .TP EXC/s Count of exceptions thrown during interval. .TP THR/s Count of threads created during interval. .SH OVERHEAD When using this tool with high-frequency events, such as method calls, a very significant slow-down can be expected. However, many of the high-level languages covered by this tool already have a fairly high per-method invocation cost, especially when running in interpreted mode. For the lower-frequency events, such as garbage collections or thread creations, the overhead should not be significant. Specifically, when probing Java processes and not using the "-XX:+ExtendedDTraceProbes" flag, the most expensive probes are not emitted, and the overhead should be acceptable. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _example.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO trace(8), argdist(8), tplist(8) bpfcc-0.2.0+git0.02884a026/man/man8/uthreads.8000066400000000000000000000027711305314114400200330ustar00rootroot00000000000000.TH uthreads 8 "2016-11-07" "USER COMMANDS" .SH NAME uthreads \- Trace thread creation events in Java or pthreads. .SH SYNOPSIS .B uthreads [-h] [-l {java}] [-v] pid .SH DESCRIPTION This traces thread creation events in Java processes, or pthread creation events in any process. When a thread is created, its name or start address is printed. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-l {java} The language to trace (currently only Java is supported). When no language is specified, only pthread creations are traced. .TP \-v Print the resulting BPF program, for debugging purposes. .TP pid The process id to trace. .SH EXAMPLES .TP Trace Java thread creations: # .B uthreads -l java 148 .TP Trace pthread creations: # .B uthreads 1802 .SH FIELDS .TP TIME The event's time in seconds from the beginning of the trace. .TP ID The thread's ID. The information in this column depends on the runtime. .TP TYPE Event type -- thread start, stop, or pthread event. .TP DESCRIPTION The thread's name or start address function name. .SH OVERHEAD Thread start and stop events are usually not very frequent, which makes this tool's overhead negligible. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _example.txt file containing example usage, output, and commentary for this tool. .SH OS Linux .SH STABILITY Unstable - in development. .SH AUTHOR Sasha Goldshtein .SH SEE ALSO ustat(8), trace(8) bpfcc-0.2.0+git0.02884a026/man/man8/vfscount.8000066400000000000000000000031651305314114400200610ustar00rootroot00000000000000.TH vfscount 8 "2015-08-18" "USER COMMANDS" .SH NAME vfscount \- Count VFS calls ("vfs_*"). Uses Linux eBPF/bcc. .SH SYNOPSIS .B vfscount .SH DESCRIPTION This counts VFS calls. This can be useful for general workload characterization of these operations. This works by tracing all kernel functions beginning with "vfs_" using dynamic tracing. This may match more functions than you are interested in measuring: Edit the script to customize which functions to trace. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Count some VFS calls until Ctrl-C is hit: # .B vfscount .SH FIELDS .TP ADDR Address of the instruction pointer that was traced (only useful if the FUNC column is suspicious and you would like to double check the translation). .TP FUNC Kernel function name .TP COUNT Number of calls while tracing .SH OVERHEAD This traces kernel vfs functions and maintains in-kernel counts, which are asynchronously copied to user-space. While the rate of VFS operations can be very high (>1M/sec), this is a relatively efficient way to trace these events, and so the overhead is expected to be small for normal workloads. Measure in a test environment, and if overheads are an issue, edit the script to reduce the types of vfs functions traced (currently all beginning with "vfs_"). .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 vfsstat(8) bpfcc-0.2.0+git0.02884a026/man/man8/vfsstat.8000066400000000000000000000034661305314114400177100ustar00rootroot00000000000000.TH vfsstat 8 "2015-08-18" "USER COMMANDS" .SH NAME vfsstat \- Statistics for some common VFS calls. Uses Linux eBPF/bcc. .SH SYNOPSIS .B vfsstat [interval [count]] .SH DESCRIPTION This traces some common VFS calls and prints per-second summaries. This can be useful for general workload characterization, and looking for patterns in operation usage over time. This works by tracing some kernel vfs functions using dynamic tracing, and will need updating to match any changes to these functions. Edit the script to customize which functions are traced. Also see vfscount, which is more easily customized to trace multiple functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH EXAMPLES .TP Print summaries each second: # .B vfsstat .TP Print output every five seconds, three times: # .B vfsstat 5 3 .SH FIELDS .TP READ/s Number of vfs_read() calls as a per-second average. .TP WRITE/s Number of vfs_write() calls as a per-second average. .TP CREATE/s Number of vfs_create() calls as a per-second average. .TP OPEN/s Number of vfs_open() calls as a per-second average. .TP FSYNC/s Number of vfs_fsync() calls as a per-second average. .SH OVERHEAD This traces various kernel vfs functions and maintains in-kernel counts, which are asynchronously copied to user-space. While the rate of VFS operations can be very high (>1M/sec), this is a relatively efficient way to trace these events, and so the overhead is expected to be small for normal workloads. Measure in a test environment. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 vfscount(8) bpfcc-0.2.0+git0.02884a026/man/man8/wakeuptime.8000066400000000000000000000063461305314114400203710ustar00rootroot00000000000000.TH wakeuptime 8 "2016-01-27" "USER COMMANDS" .SH NAME wakeuptime \- Summarize sleep to wakeup time by waker kernel stack. Uses Linux eBPF/bcc. .SH SYNOPSIS .B wakeuptime [\-h] [\-u] [\-p PID] [\-v] [\-f] [duration] .SH DESCRIPTION This program shows the kernel stack traces for threads that woke up other blocked threads, along with the process names of the waker and target, along with a sum of the time that the target was blocked: the "blocked time". It works by tracing when threads block and when they were then woken up, and measuring the time delta. This time measurement will be very similar to off-CPU time, however, off-CPU time may include a little extra time spent waiting on a run queue to be scheduled. The stack traces, process names, and time spent blocked is summarized in the kernel using an eBPF map for efficiency. The output summary will help you identify reasons why threads were blocking by showing who woke them up, along with the time they were blocked. This spans all types of blocking activity: disk I/O, network I/O, locks, page faults, involuntary context switches, etc. This can be used in conjunction with offcputime, which shows the stack trace of the blocked thread. wakeuptime shows the stack trace of the waker thread. See http://www.brendangregg.com/FlameGraphs/offcpuflamegraphs.html The stack depth is currently limited to 20, and the stack traces are kernel mode only. Check for newer versions where either may be improved. This currently only works on x86_64. Check for future versions. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-f Print output in folded stack format. .TP \-u Only trace user threads (not kernel threads). .TP \-v Show raw addresses (for non-folded format). .TP \-p PID Trace this process ID only (filtered in-kernel). .TP duration Duration to trace, in seconds. .SH EXAMPLES .TP Trace all thread blocking events, and summarize (in-kernel) by kernel stack trace and total blocked time: # .B wakeuptime .TP Trace user-mode target threads only: # .B wakeuptime -u .TP Trace for 5 seconds only: # .B wakeuptime 5 .TP Trace for 5 seconds, and emit output in folded stack format (suitable for flame graphs): # .B wakeuptime -f 5 .TP Trace PID 185 only: # .B wakeuptime -p 185 .SH OVERHEAD This summarizes unique stack traces in-kernel for efficiency, allowing it to trace a higher rate of events than methods that post-process in user space. The stack trace and time data is only copied to user space once, when the output is printed. While these techniques greatly lower overhead, scheduler events are still a high frequency event, as they can exceed 1 million events per second, and so caution should still be used. Test before production use. If the overhead is still a problem, take a look at the MINBLOCK_US tunable in the code. If your aim is to chase down longer blocking events, then this could be increased to filter shorter blocking events, further lowering overhead. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 offcputime(8), stackcount(8) bpfcc-0.2.0+git0.02884a026/man/man8/xfsdist.8000066400000000000000000000036041305314114400176740ustar00rootroot00000000000000.TH xfsdist 8 "2016-02-12" "USER COMMANDS" .SH NAME xfsdist \- Summarize XFS operation latency. Uses Linux eBPF/bcc. .SH SYNOPSIS .B xfsdist [\-h] [\-T] [\-N] [\-d] [interval] [count] .SH DESCRIPTION This tool summarizes time (latency) spent in common XFS file operations: reads, writes, opens, and syncs, and presents it as a power-of-2 histogram. It uses an in-kernel eBPF map to store the histogram for efficiency. Since this works by tracing the xfs_file_operations interface functions, it will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Don't include timestamps on interval output. .TP \-m Output in milliseconds. .TP \-p PID Trace this PID only. .SH EXAMPLES .TP Trace XFS operation time, and print a summary on Ctrl-C: # .B xfsdist .TP Trace PID 181 only: # .B xfsdist -p 181 .TP Print 1 second summaries, 10 times: # .B xfsdist 1 10 .TP 1 second summaries, printed in milliseconds # .B xfsdist \-m 1 .SH FIELDS .TP msecs Range of milliseconds for this bucket. .TP usecs Range of microseconds for this bucket. .TP count Number of operations in this time range. .TP distribution ASCII representation of the distribution (the count column). .SH OVERHEAD This adds low-overhead instrumentation to these XFS operations, including reads and writes from the file system cache. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool may become noticeable. Measure and quantify before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 xfssnoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/xfsslower.8000066400000000000000000000062011305314114400202400ustar00rootroot00000000000000.TH xfsslower 8 "2016-02-11" "USER COMMANDS" .SH NAME xfsslower \- Trace slow xfs file operations, with per-event details. .SH SYNOPSIS .B xfsslower [\-h] [\-j] [\-p PID] [min_ms] .SH DESCRIPTION This tool traces common XFS file operations: reads, writes, opens, and syncs. It measures the time spent in these operations, and prints details for each that exceeded a threshold. WARNING: See the OVERHEAD section. By default, a minimum millisecond threshold of 10 is used. If a threshold of 0 is used, all events are printed (warning: verbose). Since this works by tracing the xfs_file_operations interface functions, it will need updating to match any changes to these functions. Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS \-p PID Trace this PID only. .TP min_ms Minimum I/O latency (duration) to trace, in milliseconds. Default is 10 ms. .SH EXAMPLES .TP Trace synchronous file reads and writes slower than 10 ms: # .B xfsslower .TP Trace slower than 1 ms: # .B xfsslower 1 .TP Trace slower than 1 ms, and output just the fields in parsable format (csv): # .B xfsslower \-j 1 .TP Trace all file reads and writes (warning: the output will be verbose): # .B xfsslower 0 .TP Trace slower than 1 ms, for PID 181 only: # .B xfsslower \-p 181 1 .SH FIELDS .TP TIME(s) Time of I/O completion since the first I/O seen, in seconds. .TP COMM Process name. .TP PID Process ID. .TP T Type of operation. R == read, W == write, O == open, S == fsync. .TP OFF_KB File offset for the I/O, in Kbytes. .TP BYTES Size of I/O, in bytes. .TP LAT(ms) Latency (duration) of I/O, measured from when it was issued by VFS to the filesystem, to when it completed. This time is inclusive of block device I/O, file system CPU cycles, file system locks, run queue latency, etc. It's a more accurate measure of the latency suffered by applications performing file system I/O, than to measure this down at the block device interface. .TP FILENAME A cached kernel file name (comes from dentry->d_iname). .TP ENDTIME_us Completion timestamp, microseconds (\-j only). .TP OFFSET_b File offset, bytes (\-j only). .TP LATENCY_us Latency (duration) of the I/O, in microseconds (\-j only). .SH OVERHEAD This adds low-overhead instrumentation to these XFS operations, including reads and writes from the file system cache. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool (even if it prints no "slower" events) can begin to become significant. Measure and quantify before use. If this continues to be a problem, consider switching to a tool that prints in-kernel summaries only. .PP Note that the overhead of this tool should be less than fileslower(8), as this tool targets xfs functions only, and not all file read/write paths (which can include socket I/O). .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 biosnoop(8), funccount(8), fileslower(8) bpfcc-0.2.0+git0.02884a026/man/man8/zfsdist.8000066400000000000000000000037301305314114400176760ustar00rootroot00000000000000.TH zfsdist 8 "2016-02-12" "USER COMMANDS" .SH NAME zfsdist \- Summarize ZFS operation latency. Uses Linux eBPF/bcc. .SH SYNOPSIS .B zfsdist [\-h] [\-T] [\-N] [\-d] [interval] [count] .SH DESCRIPTION This tool summarizes time (latency) spent in common ZFS file operations: reads, writes, opens, and syncs, and presents it as a power-of-2 histogram. It uses an in-kernel eBPF map to store the histogram for efficiency. This uses kernel dynamic tracing of the ZPL interface (ZFS POSIX Layer), and will need updates to match any changes to this interface. .TP This is intended to work with the ZFS on Linux project: http://zfsonlinux.org .PP Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS .TP \-h Print usage message. .TP \-T Don't include timestamps on interval output. .TP \-m Output in milliseconds. .TP \-p PID Trace this PID only. .SH EXAMPLES .TP Trace ZFS operation time, and print a summary on Ctrl-C: # .B zfsdist .TP Trace PID 181 only: # .B zfsdist -p 181 .TP Print 1 second summaries, 10 times: # .B zfsdist 1 10 .TP 1 second summaries, printed in milliseconds # .B zfsdist \-m 1 .SH FIELDS .TP msecs Range of milliseconds for this bucket. .TP usecs Range of microseconds for this bucket. .TP count Number of operations in this time range. .TP distribution ASCII representation of the distribution (the count column). .SH OVERHEAD This adds low-overhead instrumentation to these ZFS operations, including reads and writes from the file system cache. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool may become noticeable. Measure and quantify before use. .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 zfssnoop(8) bpfcc-0.2.0+git0.02884a026/man/man8/zfsslower.8000066400000000000000000000063251305314114400202510ustar00rootroot00000000000000.TH zfsslower 8 "2016-02-11" "USER COMMANDS" .SH NAME zfsslower \- Trace slow zfs file operations, with per-event details. .SH SYNOPSIS .B zfsslower [\-h] [\-j] [\-p PID] [min_ms] .SH DESCRIPTION This tool traces common ZFS file operations: reads, writes, opens, and syncs. It measures the time spent in these operations, and prints details for each that exceeded a threshold. WARNING: See the OVERHEAD section. By default, a minimum millisecond threshold of 10 is used. If a threshold of 0 is used, all events are printed (warning: verbose). This uses kernel dynamic tracing of the ZPL interface (ZFS POSIX Layer), and will need updates to match any changes to this interface. .TP This is intended to work with the ZFS on Linux project: http://zfsonlinux.org .PP Since this uses BPF, only the root user can use this tool. .SH REQUIREMENTS CONFIG_BPF and bcc. .SH OPTIONS \-p PID Trace this PID only. .TP min_ms Minimum I/O latency (duration) to trace, in milliseconds. Default is 10 ms. .SH EXAMPLES .TP Trace synchronous file reads and writes slower than 10 ms: # .B zfsslower .TP Trace slower than 1 ms: # .B zfsslower 1 .TP Trace slower than 1 ms, and output just the fields in parsable format (csv): # .B zfsslower \-j 1 .TP Trace all file reads and writes (warning: the output will be verbose): # .B zfsslower 0 .TP Trace slower than 1 ms, for PID 181 only: # .B zfsslower \-p 181 1 .SH FIELDS .TP TIME(s) Time of I/O completion since the first I/O seen, in seconds. .TP COMM Process name. .TP PID Process ID. .TP T Type of operation. R == read, W == write, O == open, S == fsync. .TP OFF_KB File offset for the I/O, in Kbytes. .TP BYTES Size of I/O, in bytes. .TP LAT(ms) Latency (duration) of I/O, measured from when it was issued by VFS to the filesystem, to when it completed. This time is inclusive of block device I/O, file system CPU cycles, file system locks, run queue latency, etc. It's a more accurate measure of the latency suffered by applications performing file system I/O, than to measure this down at the block device interface. .TP FILENAME A cached kernel file name (comes from dentry->d_iname). .TP ENDTIME_us Completion timestamp, microseconds (\-j only). .TP OFFSET_b File offset, bytes (\-j only). .TP LATENCY_us Latency (duration) of the I/O, in microseconds (\-j only). .SH OVERHEAD This adds low-overhead instrumentation to these ZFS operations, including reads and writes from the file system cache. Such reads and writes can be very frequent (depending on the workload; eg, 1M/sec), at which point the overhead of this tool (even if it prints no "slower" events) can begin to become significant. Measure and quantify before use. If this continues to be a problem, consider switching to a tool that prints in-kernel summaries only. .PP Note that the overhead of this tool should be less than fileslower(8), as this tool targets zfs functions only, and not all file read/write paths (which can include socket I/O). .SH SOURCE This is from bcc. .IP https://github.com/iovisor/bcc .PP Also look in the bcc distribution for a companion _examples.txt 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 biosnoop(8), funccount(8), fileslower(8) bpfcc-0.2.0+git0.02884a026/scripts/000077500000000000000000000000001305314114400161655ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/scripts/README.md000066400000000000000000000040521305314114400174450ustar00rootroot00000000000000 ## Fedora Demo VM Before running the script, ensure that virt-install is available on the system. `./build_bpf_demo.sh -n bpf-demo -k bpf_demo.ks.erb` After setting up the initial VM, log in (the default password is 'iovisor') and determine the DHCP IP. SSH to this IP as root. To set up a kernel with the right options, run `bpf-kernel-setup`. ``` [root@bpf-demo ~]# bpf-kernel-setup Cloning into 'net-next'... ``` After pulling the net-next branch, the kernel config menu should pop up. Ensure that the below settings are proper. ``` General setup ---> [*] Enable bpf() system call Networking support ---> Networking options ---> QoS and/or fair queueing ---> BPF-based classifier BPF based action [*] enable BPF Just In Time compiler ``` Once the .config is saved, the build will proceed and install the resulting kernel. This kernel has updated userspace headers (e.g. the bpf() syscall) which install into /usr/local/include...proper packaging for this will be distro-dependent. Next, run `bpf-llvm-setup` to pull and compile LLVM with BPF support enabled. ``` [root@bpf-demo ~]# bpf-llvm-setup Cloning into 'llvm'... ``` The resulting libraries will be installed into /opt/local/llvm. Next, reboot into the new kernel, either manually or by using the kexec helper. ``` [root@bpf-demo ~]# kexec-4.1.0-rc1+ Connection to 192.168.122.247 closed by remote host. Connection to 192.168.122.247 closed. ``` Reconnect and run the final step, building and testing bcc. ``` [root@bpf-demo ~]# bcc-setup Cloning into 'bcc'... ... Linking CXX shared library libcc.so [100%] Built target bcc ... Running tests... Test project /root/bcc/build Start 1: py_test1 1/4 Test #1: py_test1 ......................... Passed 0.24 sec Start 2: py_test2 2/4 Test #2: py_test2 ......................... Passed 0.53 sec Start 3: py_trace1 3/4 Test #3: py_trace1 ........................ Passed 0.09 sec Start 4: py_trace2 4/4 Test #4: py_trace2 ........................ Passed 1.06 sec 100% tests passed, 0 tests failed out of 4 ``` bpfcc-0.2.0+git0.02884a026/scripts/bpf_demo.ks.erb000066400000000000000000000056431305314114400210560ustar00rootroot00000000000000# Minimal Kickstart file install text reboot lang en_US.UTF-8 # repo to install the OS url --url=<%= @mirror %>/Everything/x86_64/os/ keyboard us network --bootproto dhcp rootpw <%= @password %> authconfig --enableshadow --passalgo=sha512 --enablefingerprint firewall --enabled --ssh selinux --enforcing timezone --utc America/Los_Angeles #firstboot --disable bootloader --location=mbr --append="console=tty0 console=ttyS0,115200 rd_NO_PLYMOUTH crashkernel=auto" zerombr clearpart --all --initlabel autopart --type=lvm repo --name=everything --baseurl=<%= @mirror %>/Everything/x86_64/os/ #Just core packages %packages --nobase @core ntp @c-development @development-tools @rpm-development-tools ncurses-devel vim bc kexec-tools cmake libstdc++-static python-netaddr python-futures %end %post --log=/root/anaconda-post.log echo Kickstart post chkconfig NetworkManager off chkconfig network on chkconfig ntpd on dnf config-manager --add-repo=http://alt.fedoraproject.org/pub/alt/rawhide-kernel-nodebug/fedora-rawhide-kernel-nodebug.repo yum -y clean metadata yum -y update hostname <%= @name %>.<%= @domain %> echo "<%= @name %>.<%= @domain %>" > /etc/hostname cat > /usr/local/bin/bpf-kernel-setup <<'DELIM__' #!/bin/bash set -e -x numcpu=$(grep -c ^processor /proc/cpuinfo) git clone https://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next.git cd net-next/ cp /boot/config-$(uname -r) ./ cp ./config-$(uname -r) .config make -j$numcpu mrproper make -j$numcpu nconfig make -j$numcpu bzImage make -j$numcpu modules sudo make modules_install sudo make install sudo make INSTALL_HDR_PATH=/usr/local headers_install release=$( /usr/local/bin/kexec-$release chmod +x /usr/local/bin/kexec-$release ln -fs kexec-$release /usr/local/bin/kexec-latest DELIM__ chmod +x /usr/local/bin/bpf-kernel-setup cat > /usr/local/bin/bpf-llvm-setup <<'DELIM__' #!/bin/bash set -e -x numcpu=$(grep -c ^processor /proc/cpuinfo) git clone https://github.com/llvm-mirror/llvm.git git clone https://github.com/llvm-mirror/clang.git llvm/tools/clang mkdir llvm/build/ cd llvm/build/ cmake .. \ -DBUILD_SHARED_LIBS=OFF \ -DCMAKE_BUILD_TYPE=Release \ -DLLVM_ENABLE_TERMINFO=OFF \ -DLLVM_TARGETS_TO_BUILD="ARM;CppBackend;X86;BPF" \ -DCMAKE_INSTALL_PREFIX=/opt/local/llvm make -j$numcpu sudo make install grep -q llvm $HOME/.bashrc || echo 'PATH=/opt/local/llvm/bin:$PATH' >> $HOME/.bashrc DELIM__ chmod +x /usr/local/bin/bpf-llvm-setup cat > /usr/local/bin/bcc-setup <<'DELIM__' #!/bin/bash set -e -x git clone https://github.com/svinota/pyroute2.git (cd pyroute2; make install) numcpu=$(grep -c ^processor /proc/cpuinfo) git clone https://github.com/iovisor/bcc.git mkdir bcc/build/ cd bcc/build/ export PATH=/opt/local/llvm/bin:$PATH cmake .. -DCMAKE_INSTALL_PREFIX=/usr make -j$numcpu DELIM__ chmod +x /usr/local/bin/bcc-setup %end bpfcc-0.2.0+git0.02884a026/scripts/build-deb.sh000077500000000000000000000016701305314114400203570ustar00rootroot00000000000000#!/bin/bash # helper script to be invoked by jenkins/buildbot # $1 [optional]: the build type - release | nightly | test buildtype=${1:-test} set -x set -e PARALLEL=${PARALLEL:-1} TMP=$(mktemp -d /tmp/debuild.XXXXXX) function cleanup() { [[ -d $TMP ]] && rm -rf $TMP } trap cleanup EXIT . scripts/git-tag.sh git archive HEAD --prefix=bcc/ --format=tar.gz -o $TMP/bcc_$revision.orig.tar.gz pushd $TMP tar xf bcc_$revision.orig.tar.gz cd bcc debuild=debuild if [[ "$buildtype" = "test" ]]; then # when testing, use faster compression options debuild+=" --preserve-envvar PATH" echo -e '#!/bin/bash\nexec /usr/bin/dpkg-deb -z1 "$@"' \ | sudo tee /usr/local/bin/dpkg-deb sudo chmod +x /usr/local/bin/dpkg-deb dch -b -v $revision-$release "$git_subject" fi if [[ "$buildtype" = "nightly" ]]; then dch -v $revision-$release "$git_subject" fi DEB_BUILD_OPTIONS="nocheck parallel=${PARALLEL}" $debuild -us -uc popd cp $TMP/*.deb . bpfcc-0.2.0+git0.02884a026/scripts/build-deb.sh.in000077500000000000000000000005311305314114400207570ustar00rootroot00000000000000#!/bin/bash set -x set -e PARALLEL=${PARALLEL:-1} TMP=$(mktemp -d /tmp/debuild.XXXXXX) function cleanup() { [[ -d $TMP ]] && rm -rf $TMP } trap cleanup EXIT mkdir $TMP/bcc cp -a * $TMP/bcc pushd $TMP tar zcf bcc_@REVISION_LAST@.orig.tar.gz bcc/ cd bcc DEB_BUILD_OPTIONS="nocheck parallel=${PARALLEL}" debuild -us -uc popd cp $TMP/*.deb . bpfcc-0.2.0+git0.02884a026/scripts/build-release-rpm.sh000077500000000000000000000012341305314114400220350ustar00rootroot00000000000000#!/bin/bash set -x set -e TMP=$(mktemp -d /tmp/rpmbuild.XXXXXX) function cleanup() { [[ -d $TMP ]] && rm -rf $TMP } trap cleanup EXIT mkdir $TMP/{BUILD,RPMS,SOURCES,SPECS,SRPMS} llvmver=3.7.1 . scripts/git-tag.sh git archive HEAD --prefix=bcc/ --format=tar.gz -o $TMP/SOURCES/$git_tag_latest.tar.gz wget -P $TMP/SOURCES http://llvm.org/releases/$llvmver/{cfe,llvm}-$llvmver.src.tar.xz sed \ -e "s/^\(Version:\s*\)@REVISION@/\1$revision/" \ -e "s/^\(Release:\s*\)@GIT_REV_COUNT@/\1$release/" \ SPECS/bcc+clang.spec > $TMP/SPECS/bcc.spec pushd $TMP rpmbuild --define "_topdir `pwd`" -ba SPECS/bcc.spec popd cp $TMP/RPMS/*/*.rpm . cp $TMP/SRPMS/*.rpm . bpfcc-0.2.0+git0.02884a026/scripts/build-rpm.sh000077500000000000000000000010641305314114400204200ustar00rootroot00000000000000#!/bin/bash set -x set -e TMP=$(mktemp -d /tmp/rpmbuild.XXXXXX) function cleanup() { [[ -d $TMP ]] && rm -rf $TMP } trap cleanup EXIT mkdir $TMP/{BUILD,RPMS,SOURCES,SPECS,SRPMS} llvmver=3.7.1 . scripts/git-tag.sh git archive HEAD --prefix=bcc/ --format=tar.gz -o $TMP/SOURCES/bcc.tar.gz sed \ -e "s/^\(Version:\s*\)@REVISION@/\1$revision/" \ -e "s/^\(Release:\s*\)@GIT_REV_COUNT@/\1$release/" \ SPECS/bcc.spec > $TMP/SPECS/bcc.spec pushd $TMP rpmbuild --define "_topdir `pwd`" -ba SPECS/bcc.spec popd cp $TMP/RPMS/*/*.rpm . cp $TMP/SRPMS/*.rpm . bpfcc-0.2.0+git0.02884a026/scripts/build_bpf_demo.sh000077500000000000000000000057471305314114400214730ustar00rootroot00000000000000#!/bin/bash #set -x set -e function usage() { cat < /dev/null; then echo "Error: virt-install is not installed" exit 1 fi libvirt_dir=/var/lib/libvirt/images img_name=$NAME tmpdir=$(mktemp -d /tmp/virt-install_XXXXX) tmp_ks_file=$tmpdir/$img_name.ks function cleanup() { set +e [[ -d "$tmpdir" ]] && rm -fr "$tmpdir" local destroy_kvm=n [[ -f "/etc/libvirt/qemu/$img_name.xml" ]] && read -p "Destroy libvirt VM (y/n)? " destroy_kvm if [[ "$destroy_kvm" != n* ]]; then virsh destroy $img_name virsh undefine $img_name virsh vol-delete $img_name.img --pool default $sudo rm -f $libvirt_dir/$img_name.img fi } trap cleanup EXIT ruby <, which defaults to HEAD. Changes are only applied to the working directory. The following git-config settings set the default of the corresponding option: clangFormat.binary clangFormat.commit clangFormat.extension clangFormat.style ''' # Name of the temporary index file in which save the output of clang-format. # This file is created within the .git directory. temp_index_basename = 'clang-format-index' Range = collections.namedtuple('Range', 'start, count') def main(): config = load_git_config() # In order to keep '--' yet allow options after positionals, we need to # check for '--' ourselves. (Setting nargs='*' throws away the '--', while # nargs=argparse.REMAINDER disallows options after positionals.) argv = sys.argv[1:] try: idx = argv.index('--') except ValueError: dash_dash = [] else: dash_dash = argv[idx:] argv = argv[:idx] default_extensions = ','.join([ # From clang/lib/Frontend/FrontendOptions.cpp, all lower case 'c', 'h', # C 'm', # ObjC 'mm', # ObjC++ 'cc', 'cp', 'cpp', 'c++', 'cxx', 'hpp', # C++ # Other languages that clang-format supports 'proto', 'protodevel', # Protocol Buffers 'js', # JavaScript 'ts', # TypeScript ]) p = argparse.ArgumentParser( usage=usage, formatter_class=argparse.RawDescriptionHelpFormatter, description=desc) p.add_argument('--binary', default=config.get('clangformat.binary', 'clang-format'), help='path to clang-format'), p.add_argument('--commit', default=config.get('clangformat.commit', 'HEAD'), help='default commit to use if none is specified'), p.add_argument('--diff', action='store_true', help='print a diff instead of applying the changes') p.add_argument('--extensions', default=config.get('clangformat.extensions', default_extensions), help=('comma-separated list of file extensions to format, ' 'excluding the period and case-insensitive')), p.add_argument('-f', '--force', action='store_true', help='allow changes to unstaged files') p.add_argument('-p', '--patch', action='store_true', help='select hunks interactively') p.add_argument('-q', '--quiet', action='count', default=0, help='print less information') p.add_argument('--style', default=config.get('clangformat.style', None), help='passed to clang-format'), p.add_argument('-v', '--verbose', action='count', default=0, help='print extra information') # We gather all the remaining positional arguments into 'args' since we need # to use some heuristics to determine whether or not was present. # However, to print pretty messages, we make use of metavar and help. p.add_argument('args', nargs='*', metavar='', help='revision from which to compute the diff') p.add_argument('ignored', nargs='*', metavar='...', help='if specified, only consider differences in these files') opts = p.parse_args(argv) opts.verbose -= opts.quiet del opts.quiet commit, files = interpret_args(opts.args, dash_dash, opts.commit) changed_lines = compute_diff_and_extract_lines(commit, files) if opts.verbose >= 1: ignored_files = set(changed_lines) filter_by_extension(changed_lines, opts.extensions.lower().split(',')) if opts.verbose >= 1: ignored_files.difference_update(changed_lines) if ignored_files: print 'Ignoring changes in the following files (wrong extension):' for filename in ignored_files: print ' ', filename if changed_lines: print 'Running clang-format on the following files:' for filename in changed_lines: print ' ', filename else: print 'no modified files to format' return # The computed diff outputs absolute paths, so we must cd before accessing # those files. cd_to_toplevel() old_tree = create_tree_from_workdir(changed_lines) new_tree = run_clang_format_and_save_to_tree(changed_lines, binary=opts.binary, style=opts.style) if opts.verbose >= 1: print 'old tree:', old_tree print 'new tree:', new_tree if old_tree == new_tree: if opts.verbose >= 0: print 'clang-format did not modify any files' elif opts.diff: print_diff(old_tree, new_tree) else: changed_files = apply_changes(old_tree, new_tree, force=opts.force, patch_mode=opts.patch) if (opts.verbose >= 0 and not opts.patch) or opts.verbose >= 1: print 'changed files:' for filename in changed_files: print ' ', filename def load_git_config(non_string_options=None): """Return the git configuration as a dictionary. All options are assumed to be strings unless in `non_string_options`, in which is a dictionary mapping option name (in lower case) to either "--bool" or "--int".""" if non_string_options is None: non_string_options = {} out = {} for entry in run('git', 'config', '--list', '--null').split('\0'): if entry: name, value = entry.split('\n', 1) if name in non_string_options: value = run('git', 'config', non_string_options[name], name) out[name] = value return out def interpret_args(args, dash_dash, default_commit): """Interpret `args` as "[commit] [--] [files...]" and return (commit, files). It is assumed that "--" and everything that follows has been removed from args and placed in `dash_dash`. If "--" is present (i.e., `dash_dash` is non-empty), the argument to its left (if present) is taken as commit. Otherwise, the first argument is checked if it is a commit or a file. If commit is not given, `default_commit` is used.""" if dash_dash: if len(args) == 0: commit = default_commit elif len(args) > 1: die('at most one commit allowed; %d given' % len(args)) else: commit = args[0] object_type = get_object_type(commit) if object_type not in ('commit', 'tag'): if object_type is None: die("'%s' is not a commit" % commit) else: die("'%s' is a %s, but a commit was expected" % (commit, object_type)) files = dash_dash[1:] elif args: if disambiguate_revision(args[0]): commit = args[0] files = args[1:] else: commit = default_commit files = args else: commit = default_commit files = [] return commit, files def disambiguate_revision(value): """Returns True if `value` is a revision, False if it is a file, or dies.""" # If `value` is ambiguous (neither a commit nor a file), the following # command will die with an appropriate error message. run('git', 'rev-parse', value, verbose=False) object_type = get_object_type(value) if object_type is None: return False if object_type in ('commit', 'tag'): return True die('`%s` is a %s, but a commit or filename was expected' % (value, object_type)) def get_object_type(value): """Returns a string description of an object's type, or None if it is not a valid git object.""" cmd = ['git', 'cat-file', '-t', value] p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = p.communicate() if p.returncode != 0: return None return stdout.strip() def compute_diff_and_extract_lines(commit, files): """Calls compute_diff() followed by extract_lines().""" diff_process = compute_diff(commit, files) changed_lines = extract_lines(diff_process.stdout) diff_process.stdout.close() diff_process.wait() if diff_process.returncode != 0: # Assume error was already printed to stderr. sys.exit(2) return changed_lines def compute_diff(commit, files): """Return a subprocess object producing the diff from `commit`. The return value's `stdin` file object will produce a patch with the differences between the working directory and `commit`, filtered on `files` (if non-empty). Zero context lines are used in the patch.""" cmd = ['git', 'diff-index', '-p', '-U0', commit, '--'] cmd.extend(files) p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE) p.stdin.close() return p def extract_lines(patch_file): """Extract the changed lines in `patch_file`. The return value is a dictionary mapping filename to a list of (start_line, line_count) pairs. The input must have been produced with ``-U0``, meaning unidiff format with zero lines of context. The return value is a dict mapping filename to a list of line `Range`s.""" matches = {} for line in patch_file: match = re.search(r'^\+\+\+\ [^/]+/(.*)', line) if match: filename = match.group(1).rstrip('\r\n') match = re.search(r'^@@ -[0-9,]+ \+(\d+)(,(\d+))?', line) if match: start_line = int(match.group(1)) line_count = 1 if match.group(3): line_count = int(match.group(3)) if line_count > 0: matches.setdefault(filename, []).append(Range(start_line, line_count)) return matches def filter_by_extension(dictionary, allowed_extensions): """Delete every key in `dictionary` that doesn't have an allowed extension. `allowed_extensions` must be a collection of lowercase file extensions, excluding the period.""" allowed_extensions = frozenset(allowed_extensions) for filename in dictionary.keys(): base_ext = filename.rsplit('.', 1) if len(base_ext) == 1 or base_ext[1].lower() not in allowed_extensions: del dictionary[filename] def cd_to_toplevel(): """Change to the top level of the git repository.""" toplevel = run('git', 'rev-parse', '--show-toplevel') os.chdir(toplevel) def create_tree_from_workdir(filenames): """Create a new git tree with the given files from the working directory. Returns the object ID (SHA-1) of the created tree.""" return create_tree(filenames, '--stdin') def run_clang_format_and_save_to_tree(changed_lines, binary='clang-format', style=None): """Run clang-format on each file and save the result to a git tree. Returns the object ID (SHA-1) of the created tree.""" def index_info_generator(): for filename, line_ranges in changed_lines.iteritems(): mode = oct(os.stat(filename).st_mode) blob_id = clang_format_to_blob(filename, line_ranges, binary=binary, style=style) yield '%s %s\t%s' % (mode, blob_id, filename) return create_tree(index_info_generator(), '--index-info') def create_tree(input_lines, mode): """Create a tree object from the given input. If mode is '--stdin', it must be a list of filenames. If mode is '--index-info' is must be a list of values suitable for "git update-index --index-info", such as " ". Any other mode is invalid.""" assert mode in ('--stdin', '--index-info') cmd = ['git', 'update-index', '--add', '-z', mode] with temporary_index_file(): p = subprocess.Popen(cmd, stdin=subprocess.PIPE) for line in input_lines: p.stdin.write('%s\0' % line) p.stdin.close() if p.wait() != 0: die('`%s` failed' % ' '.join(cmd)) tree_id = run('git', 'write-tree') return tree_id def clang_format_to_blob(filename, line_ranges, binary='clang-format', style=None): """Run clang-format on the given file and save the result to a git blob. Returns the object ID (SHA-1) of the created blob.""" clang_format_cmd = [binary, filename] if style: clang_format_cmd.extend(['-style='+style]) clang_format_cmd.extend([ '-lines=%s:%s' % (start_line, start_line+line_count-1) for start_line, line_count in line_ranges]) try: clang_format = subprocess.Popen(clang_format_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE) except OSError as e: if e.errno == errno.ENOENT: die('cannot find executable "%s"' % binary) else: raise clang_format.stdin.close() hash_object_cmd = ['git', 'hash-object', '-w', '--path='+filename, '--stdin'] hash_object = subprocess.Popen(hash_object_cmd, stdin=clang_format.stdout, stdout=subprocess.PIPE) clang_format.stdout.close() stdout = hash_object.communicate()[0] if hash_object.returncode != 0: die('`%s` failed' % ' '.join(hash_object_cmd)) if clang_format.wait() != 0: die('`%s` failed' % ' '.join(clang_format_cmd)) return stdout.rstrip('\r\n') @contextlib.contextmanager def temporary_index_file(tree=None): """Context manager for setting GIT_INDEX_FILE to a temporary file and deleting the file afterward.""" index_path = create_temporary_index(tree) old_index_path = os.environ.get('GIT_INDEX_FILE') os.environ['GIT_INDEX_FILE'] = index_path try: yield finally: if old_index_path is None: del os.environ['GIT_INDEX_FILE'] else: os.environ['GIT_INDEX_FILE'] = old_index_path os.remove(index_path) def create_temporary_index(tree=None): """Create a temporary index file and return the created file's path. If `tree` is not None, use that as the tree to read in. Otherwise, an empty index is created.""" gitdir = run('git', 'rev-parse', '--git-dir') path = os.path.join(gitdir, temp_index_basename) if tree is None: tree = '--empty' run('git', 'read-tree', '--index-output='+path, tree) return path def print_diff(old_tree, new_tree): """Print the diff between the two trees to stdout.""" # We use the porcelain 'diff' and not plumbing 'diff-tree' because the output # is expected to be viewed by the user, and only the former does nice things # like color and pagination. subprocess.check_call(['git', 'diff', old_tree, new_tree, '--']) def apply_changes(old_tree, new_tree, force=False, patch_mode=False): """Apply the changes in `new_tree` to the working directory. Bails if there are local changes in those files and not `force`. If `patch_mode`, runs `git checkout --patch` to select hunks interactively.""" changed_files = run('git', 'diff-tree', '-r', '-z', '--name-only', old_tree, new_tree).rstrip('\0').split('\0') if not force: unstaged_files = run('git', 'diff-files', '--name-status', *changed_files) if unstaged_files: print >>sys.stderr, ('The following files would be modified but ' 'have unstaged changes:') print >>sys.stderr, unstaged_files print >>sys.stderr, 'Please commit, stage, or stash them first.' sys.exit(2) if patch_mode: # In patch mode, we could just as well create an index from the new tree # and checkout from that, but then the user will be presented with a # message saying "Discard ... from worktree". Instead, we use the old # tree as the index and checkout from new_tree, which gives the slightly # better message, "Apply ... to index and worktree". This is not quite # right, since it won't be applied to the user's index, but oh well. with temporary_index_file(old_tree): subprocess.check_call(['git', 'checkout', '--patch', new_tree]) index_tree = old_tree else: with temporary_index_file(new_tree): run('git', 'checkout-index', '-a', '-f') return changed_files def run(*args, **kwargs): stdin = kwargs.pop('stdin', '') verbose = kwargs.pop('verbose', True) strip = kwargs.pop('strip', True) for name in kwargs: raise TypeError("run() got an unexpected keyword argument '%s'" % name) p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) stdout, stderr = p.communicate(input=stdin) if p.returncode == 0: if stderr: if verbose: print >>sys.stderr, '`%s` printed to stderr:' % ' '.join(args) print >>sys.stderr, stderr.rstrip() if strip: stdout = stdout.rstrip('\r\n') return stdout if verbose: print >>sys.stderr, '`%s` returned %s' % (' '.join(args), p.returncode) if stderr: print >>sys.stderr, stderr.rstrip() sys.exit(2) def die(message): print >>sys.stderr, 'error:', message sys.exit(2) if __name__ == '__main__': main() bpfcc-0.2.0+git0.02884a026/scripts/git-tag.sh000066400000000000000000000004771305314114400200650ustar00rootroot00000000000000git_tag_latest=$(git describe --abbrev=0) git_rev_count=$(git rev-list $git_tag_latest.. --count) git_rev_count=$[$git_rev_count+1] git_subject=$(git log --pretty="%s" -n 1) release=$git_rev_count if [[ "$release" != "1" ]]; then release="${release}.git.$(git log --pretty='%h' -n 1)" fi revision=${git_tag_latest:1} bpfcc-0.2.0+git0.02884a026/scripts/style-check.sh000077500000000000000000000010021305314114400207300ustar00rootroot00000000000000#!/bin/bash # Runs clang-format on the files changed between HEAD and $1, which defaults to # origin/master. # to pick up git-clang-format from scripts/ export PATH=$(dirname $0):$PATH CLANG_FORMAT=${CLANG_FORMAT:-clang-format} GITREF=${1:-origin/master} if ! hash $CLANG_FORMAT 2> /dev/null; then echo "Could not find clang-format tool" 1>&2 exit 1 fi cmd="git clang-format $GITREF --binary $CLANG_FORMAT --diff --extensions h,c,cc" n=$($cmd --quiet | wc -l) if [ $n -gt 0 ]; then $cmd -v exit 1 fi bpfcc-0.2.0+git0.02884a026/snapcraft/000077500000000000000000000000001305314114400164575ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/snapcraft/Makefile000066400000000000000000000027101305314114400201170ustar00rootroot00000000000000# # Copyright (C) 2016 Canonical # # 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. # # # Simple makefile to mangle version info in the yaml file # VERSION=$(shell git tag | tail -1 | cut -c2-) COMMITS=$(shell git log --oneline | wc -l) SHA=$(shell git log -1 --oneline | cut -d' ' -f1) DATE=$(shell date +'%Y%m%d') V=$(VERSION)-$(DATE)-$(COMMITS)-$(SHA) all: set_version snapcraft set_version: cat snapcraft.yaml | sed 's/version: .*/version: $(V)/' > snapcraft-tmp.yaml mv snapcraft-tmp.yaml snapcraft.yaml install: # # Install latest snap # sudo snap install --devmode bcc_*.snap # # Connect up interfaces # sudo snap connect bcc:mount-observe sudo snap connect bcc:system-observe sudo snap connect bcc:system-trace remove: sudo snap remove bcc clean: snapcraft clean rm -rf setup *.snap snapcraft bpfcc-0.2.0+git0.02884a026/snapcraft/README.md000066400000000000000000000024601305314114400177400ustar00rootroot00000000000000# bcc snap This is an unconfined snap of the BPF Compiler Collection (BCC), a toolkit for creating efficient kernel tracing and manipulation programs. First, install snapcraft, e.g. on Ubuntu: sudo apt install snapcraft Clone the bcc repo (if you haven't done so already) and create the snap: git clone https://github.com/iovisor/bcc.git cd snapcraft make Note: running `make` just gets the version from the current bcc gito repository and uses this in the snapcraft yaml file to version the bcc snap. The Makefile basically runs snapcraft to snap up bcc. Install the snap by running: sudo snap install --devmode bcc_*.snap One may need to ensure the snap plugins are enabled for the snap using: sudo snap connect bcc:mount-observe sudo snap connect bcc:system-observe sudo snap connect bcc:system-trace Now run a bcc tool, for example, to run opensnoop use: sudo bcc.opensnoop Note that this may fail to build and run if you do not have the kernel headers installed or perhaps the kernel config is not set up correctly. This snap has been tested using the mainly 4.8 and 4.9 kernels built with the Ubuntu Yakkety and Zesty kernel configs as well as the default Ubuntu 4.8 Yakkey and 4.9 Zesty kernels. Contact Colin Ian King for support on this bcc snap. Thu 15 Dec 17:08:29 GMT 2016 bpfcc-0.2.0+git0.02884a026/snapcraft/snapcraft.yaml000066400000000000000000000120761305314114400213320ustar00rootroot00000000000000# # Copyright (C) 2016 Canonical # # 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. # name: bcc version: 0.2.0-20170208-1555-3e77af5 summary: BPF Compiler Collection (BCC) description: A toolkit for creating efficient kernel tracing and manipulation programs confinement: strict grade: stable plugs: mount-observe: null system-observe: null system-trace: null apps: argdist: command: wrapper argdist bashreadline: command: wrapper bashreadline biolatency: command: wrapper biolatency biosnoop: command: wrapper biosnoop biotop: command: wrapper biotop bitesize: command: wrapper bitesize btrfsdist: command: wrapper btrfsdist btrfsslower: command: wrapper btrfsslower cachestat: command: wrapper cachestat cachetop: command: wrapper cachetop capable: command: wrapper capable cpudist: command: wrapper cpudist cpuunclaimed: command: wrapper cpuunclaimed dcsnoop: command: wrapper dcsnoop dcstat: command: wrapper dcstat deadlock-detector: command: wrapper deadlock_detector execsnoop: command: wrapper execsnoop ext4dist: command: wrapper ext4dist ext4slower: command: wrapper ext4slower filelife: command: wrapper filelife fileslower: command: wrapper fileslower filetop: command: wrapper filetop funccount: command: wrapper funccount funclatency: command: wrapper funclatency gethostlatency: command: wrapper gethostlatency hardirqs: command: wrapper hardirqs killsnoop: command: wrapper killsnoop llcstat: command: wrapper llcstat mdflush: command: wrapper mdflush memleak: command: wrapper memleak mountsnoop: command: wrapper mountsnoop offcputime: command: wrapper offcputime offwaketime: command: wrapper offwaketime oomkill: command: wrapper oomkill opensnoop: command: wrapper opensnoop pidpersec: command: wrapper pidpersec profile: command: wrapper profile runqlat: command: wrapper runqlat runqlen: command: wrapper runqlen slabratetop: command: wrapper slabratetop softirqs: command: wrapper softirqs solisten: command: wrapper solisten sslsniff: command: wrapper sslsniff stackcount: command: wrapper stackcount stacksnoop: command: wrapper stacksnoop statsnoop: command: wrapper statsnoop syncsnoop: command: wrapper syncsnoop tcpaccept: command: wrapper tcpaccept tcpconnect: command: wrapper tcpconnect tcpconnlat: command: wrapper tcpconnlat tcplife: command: wrapper tcplife tcpretrans: command: wrapper tcpretrans tcptop: command: wrapper tcptop tplist: command: wrapper tplist trace: command: wrapper trace ttysnoop: command: wrapper ttysnoop ucalls: command: wrapper ucalls uflow: command: wrapper uflow ugc: command: wrapper ugc uobjnew: command: wrapper uobjnew ustat: command: wrapper ustat uthreads: command: wrapper uthreads vfscount: command: wrapper vfscount vfsstat: command: wrapper vfsstat wakeuptime: command: wrapper wakeuptime xfsdist: command: wrapper xfsdist xfsslower: command: wrapper xfsslower zfsdist: command: wrapper zfsdist zfsslower: command: wrapper zfsslower parts: bcc: plugin: cmake configflags: - -DCMAKE_INSTALL_PREFIX=/usr source: .. build-packages: - bison - build-essential - cmake - flex - libedit-dev - libllvm3.7 - llvm-3.7-dev - libclang-3.7-dev - python - zlib1g-dev - libelf-dev stage-packages: - python snap: - usr/bin/python* - usr/share/bcc/tools - usr/lib/*/lib*.so* - usr/lib/python2.7 - -usr/share/bcc/tools/doc wrapper: source: . plugin: copy files: wrapper: bin/wrapper # vim: set ai et sts=4 tabstop=4 sw=4: bpfcc-0.2.0+git0.02884a026/snapcraft/wrapper000077500000000000000000000006251305314114400200700ustar00rootroot00000000000000#!/bin/sh -e # Snappy does not yet support CAP_SYS_ADMIN for unconfined snaps, thus sudo: # https://bugs.launchpad.net/snappy/+bug/1586581 # stdout isn't set to line buffered mode: # https://bugs.launchpad.net/snappy/+bug/1587675 cmd="$1" if [ `id -u` = 0 ] ; then shift stdbuf -oL $SNAP/usr/bin/python "$SNAP/usr/share/bcc/tools/$cmd" $@ else echo "Need to run $cmd as root (use sudo $@)" exit 1 fi bpfcc-0.2.0+git0.02884a026/src/000077500000000000000000000000001305314114400152655ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/CMakeLists.txt000066400000000000000000000005771305314114400200360ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti") include_directories(${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${CMAKE_CURRENT_BINARY_DIR}) if(NOT PYTHON_ONLY) add_subdirectory(cc) endif() add_subdirectory(python) add_subdirectory(lua) bpfcc-0.2.0+git0.02884a026/src/cc/000077500000000000000000000000001305314114400156525ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/BPF.cc000066400000000000000000000440321305314114400165730ustar00rootroot00000000000000/* * Copyright (c) 2016 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include "bcc_exception.h" #include "bcc_syms.h" #include "bpf_module.h" #include "libbpf.h" #include "perf_reader.h" #include "common.h" #include "usdt.h" #include "BPF.h" namespace ebpf { std::string uint_to_hex(uint64_t value) { std::stringstream ss; ss << std::hex << value; return ss.str(); } std::string sanitize_str(std::string str, bool (*validator)(char), char replacement = '_') { for (size_t i = 0; i < str.length(); i++) if (!validator(str[i])) str[i] = replacement; return str; } StatusTuple BPF::init(const std::string& bpf_program, std::vector cflags, std::vector usdt) { std::string all_bpf_program; for (auto u : usdt) { if (!u.initialized_) TRY2(u.init()); all_bpf_program += u.program_text_; usdt_.push_back(std::move(u)); } auto flags_len = cflags.size(); const char* flags[flags_len]; for (size_t i = 0; i < flags_len; i++) flags[i] = cflags[i].c_str(); all_bpf_program += bpf_program; if (bpf_module_->load_string(all_bpf_program, flags, flags_len) != 0) return StatusTuple(-1, "Unable to initialize BPF program"); return StatusTuple(0); }; BPF::~BPF() { auto res = detach_all(); if (res.code() != 0) std::cerr << "Failed to detach all probes on destruction: " << std::endl << res.msg() << std::endl; } StatusTuple BPF::detach_all() { bool has_error = false; std::string error_msg; for (auto it : kprobes_) { auto res = detach_kprobe_event(it.first, it.second); if (res.code() != 0) { error_msg += "Failed to detach kprobe event " + it.first + ": "; error_msg += res.msg() + "\n"; has_error = true; } } for (auto it : uprobes_) { auto res = detach_uprobe_event(it.first, it.second); if (res.code() != 0) { error_msg += "Failed to detach uprobe event " + it.first + ": "; error_msg += res.msg() + "\n"; has_error = true; } } for (auto it : tracepoints_) { auto res = detach_tracepoint_event(it.first, it.second); if (res.code() != 0) { error_msg += "Failed to detach Tracepoint " + it.first + ": "; error_msg += res.msg() + "\n"; has_error = true; } } for (auto it : perf_buffers_) { auto res = it.second->close_all_cpu(); if (res.code() != 0) { error_msg += "Failed to close perf buffer " + it.first + ": "; error_msg += res.msg() + "\n"; has_error = true; } delete it.second; } for (auto it : perf_events_) { auto res = detach_perf_event_all_cpu(it.second); if (res.code() != 0) { error_msg += res.msg() + "\n"; has_error = true; } } for (auto it : funcs_) { int res = close(it.second); if (res != 0) { error_msg += "Failed to unload BPF program for " + it.first + ": "; error_msg += std::string(std::strerror(errno)) + "\n"; has_error = true; } } if (has_error) return StatusTuple(-1, error_msg); else return StatusTuple(0); } StatusTuple BPF::attach_kprobe(const std::string& kernel_func, const std::string& probe_func, bpf_probe_attach_type attach_type, pid_t pid, int cpu, int group_fd, perf_reader_cb cb, void* cb_cookie) { std::string probe_event = get_kprobe_event(kernel_func, attach_type); if (kprobes_.find(probe_event) != kprobes_.end()) return StatusTuple(-1, "kprobe %s already attached", probe_event.c_str()); int probe_fd; TRY2(load_func(probe_func, BPF_PROG_TYPE_KPROBE, probe_fd)); void* res = bpf_attach_kprobe(probe_fd, attach_type, probe_event.c_str(), kernel_func.c_str(), pid, cpu, group_fd, cb, cb_cookie); if (!res) { TRY2(unload_func(probe_func)); return StatusTuple(-1, "Unable to attach %skprobe for %s using %s", attach_type_debug(attach_type).c_str(), kernel_func.c_str(), probe_func.c_str()); } open_probe_t p = {}; p.reader_ptr = res; p.func = probe_func; kprobes_[probe_event] = std::move(p); return StatusTuple(0); } StatusTuple BPF::attach_uprobe(const std::string& binary_path, const std::string& symbol, const std::string& probe_func, uint64_t symbol_addr, bpf_probe_attach_type attach_type, pid_t pid, int cpu, int group_fd, perf_reader_cb cb, void* cb_cookie) { bcc_symbol sym = bcc_symbol(); TRY2(check_binary_symbol(binary_path, symbol, symbol_addr, &sym)); std::string probe_event = get_uprobe_event(sym.module, sym.offset, attach_type); if (uprobes_.find(probe_event) != uprobes_.end()) return StatusTuple(-1, "uprobe %s already attached", probe_event.c_str()); int probe_fd; TRY2(load_func(probe_func, BPF_PROG_TYPE_KPROBE, probe_fd)); void* res = bpf_attach_uprobe(probe_fd, attach_type, probe_event.c_str(), binary_path.c_str(), sym.offset, pid, cpu, group_fd, cb, cb_cookie); if (!res) { TRY2(unload_func(probe_func)); return StatusTuple( -1, "Unable to attach %suprobe for binary %s symbol %s addr %lx using %s\n", attach_type_debug(attach_type).c_str(), binary_path.c_str(), symbol.c_str(), symbol_addr, probe_func.c_str()); } open_probe_t p = {}; p.reader_ptr = res; p.func = probe_func; uprobes_[probe_event] = std::move(p); return StatusTuple(0); } StatusTuple BPF::attach_usdt(const USDT& usdt, pid_t pid, int cpu, int group_fd) { for (auto& u : usdt_) if (u == usdt) { bool failed = false; std::string err_msg; int cnt = 0; for (auto addr : u.addresses_) { auto res = attach_uprobe(u.binary_path_, std::string(), u.probe_func_, addr); if (res.code() != 0) { failed = true; err_msg += "USDT " + u.print_name() + " at " + std::to_string(addr); err_msg += ": " + res.msg() + "\n"; break; } cnt++; } if (failed) { for (int i = 0; i < cnt; i++) { auto res = detach_uprobe(u.binary_path_, std::string(), u.addresses_[i]); err_msg += "During clean up: " + res.msg() + "\n"; } return StatusTuple(-1, err_msg); } else return StatusTuple(0); } return StatusTuple(-1, "USDT %s not found", usdt.print_name().c_str()); } StatusTuple BPF::attach_tracepoint(const std::string& tracepoint, const std::string& probe_func, pid_t pid, int cpu, int group_fd, perf_reader_cb cb, void* cb_cookie) { if (tracepoints_.find(tracepoint) != tracepoints_.end()) return StatusTuple(-1, "Tracepoint %s already attached", tracepoint.c_str()); auto pos = tracepoint.find(":"); if ((pos == std::string::npos) || (pos != tracepoint.rfind(":"))) return StatusTuple(-1, "Unable to parse Tracepoint %s", tracepoint.c_str()); std::string tp_category = tracepoint.substr(0, pos); std::string tp_name = tracepoint.substr(pos + 1); int probe_fd; TRY2(load_func(probe_func, BPF_PROG_TYPE_TRACEPOINT, probe_fd)); void* res = bpf_attach_tracepoint(probe_fd, tp_category.c_str(), tp_name.c_str(), pid, cpu, group_fd, cb, cb_cookie); if (!res) { TRY2(unload_func(probe_func)); return StatusTuple(-1, "Unable to attach Tracepoint %s using %s", tracepoint.c_str(), probe_func.c_str()); } open_probe_t p = {}; p.reader_ptr = res; p.func = probe_func; tracepoints_[tracepoint] = std::move(p); return StatusTuple(0); } StatusTuple BPF::attach_perf_event(uint32_t ev_type, uint32_t ev_config, const std::string& probe_func, uint64_t sample_period, uint64_t sample_freq, pid_t pid, int cpu, int group_fd) { auto ev_pair = std::make_pair(ev_type, ev_config); if (perf_events_.find(ev_pair) != perf_events_.end()) return StatusTuple(-1, "Perf event type %d config %d already attached", ev_type, ev_config); int probe_fd; TRY2(load_func(probe_func, BPF_PROG_TYPE_PERF_EVENT, probe_fd)); auto fds = new std::map(); std::vector cpus; if (cpu >= 0) cpus.push_back(cpu); else cpus = get_online_cpus(); for (int i: cpus) { int fd = bpf_attach_perf_event(probe_fd, ev_type, ev_config, sample_period, sample_freq, pid, i, group_fd); if (fd < 0) { for (auto it : *fds) close(it.second); delete fds; TRY2(unload_func(probe_func)); return StatusTuple(-1, "Failed to attach perf event type %d config %d", ev_type, ev_config); } fds->emplace(i, fd); } open_probe_t p = {}; p.func = probe_func; p.per_cpu_fd = fds; perf_events_[ev_pair] = std::move(p); return StatusTuple(0); } StatusTuple BPF::detach_kprobe(const std::string& kernel_func, bpf_probe_attach_type attach_type) { std::string event = get_kprobe_event(kernel_func, attach_type); auto it = kprobes_.find(event); if (it == kprobes_.end()) return StatusTuple(-1, "No open %skprobe for %s", attach_type_debug(attach_type).c_str(), kernel_func.c_str()); TRY2(detach_kprobe_event(it->first, it->second)); kprobes_.erase(it); return StatusTuple(0); } StatusTuple BPF::detach_uprobe(const std::string& binary_path, const std::string& symbol, uint64_t symbol_addr, bpf_probe_attach_type attach_type) { bcc_symbol sym = bcc_symbol(); TRY2(check_binary_symbol(binary_path, symbol, symbol_addr, &sym)); std::string event = get_uprobe_event(sym.module, sym.offset, attach_type); auto it = uprobes_.find(event); if (it == uprobes_.end()) return StatusTuple(-1, "No open %suprobe for binary %s symbol %s addr %lx", attach_type_debug(attach_type).c_str(), binary_path.c_str(), symbol.c_str(), symbol_addr); TRY2(detach_uprobe_event(it->first, it->second)); uprobes_.erase(it); return StatusTuple(0); } StatusTuple BPF::detach_usdt(const USDT& usdt) { for (auto& u : usdt_) if (u == usdt) { bool failed = false; std::string err_msg; for (auto addr : u.addresses_) { auto res = detach_uprobe(u.binary_path_, std::string(), addr); if (res.code() != 0) { failed = true; err_msg += "USDT " + u.print_name() + " at " + std::to_string(addr); err_msg += ": " + res.msg() + "\n"; } } if (failed) return StatusTuple(-1, err_msg); else return StatusTuple(0); } return StatusTuple(-1, "USDT %s not found", usdt.print_name().c_str()); } StatusTuple BPF::detach_tracepoint(const std::string& tracepoint) { auto it = tracepoints_.find(tracepoint); if (it == tracepoints_.end()) return StatusTuple(-1, "No open Tracepoint %s", tracepoint.c_str()); TRY2(detach_tracepoint_event(it->first, it->second)); tracepoints_.erase(it); return StatusTuple(0); } StatusTuple BPF::detach_perf_event(uint32_t ev_type, uint32_t ev_config) { auto it = perf_events_.find(std::make_pair(ev_type, ev_config)); if (it == perf_events_.end()) return StatusTuple(-1, "Perf Event type %d config %d not attached", ev_type, ev_config); TRY2(detach_perf_event_all_cpu(it->second)); perf_events_.erase(it); return StatusTuple(0); } StatusTuple BPF::open_perf_buffer(const std::string& name, perf_reader_raw_cb cb, void* cb_cookie) { if (perf_buffers_.find(name) == perf_buffers_.end()) perf_buffers_[name] = new BPFPerfBuffer(bpf_module_.get(), name); auto table = perf_buffers_[name]; TRY2(table->open_all_cpu(cb, cb_cookie)); return StatusTuple(0); } StatusTuple BPF::close_perf_buffer(const std::string& name) { auto it = perf_buffers_.find(name); if (it == perf_buffers_.end()) return StatusTuple(-1, "Perf buffer for %s not open", name.c_str()); TRY2(it->second->close_all_cpu()); return StatusTuple(0); } void BPF::poll_perf_buffer(const std::string& name, int timeout) { auto it = perf_buffers_.find(name); if (it == perf_buffers_.end()) return; it->second->poll(timeout); } StatusTuple BPF::load_func(const std::string& func_name, bpf_prog_type type, int& fd) { if (funcs_.find(func_name) != funcs_.end()) { fd = funcs_[func_name]; return StatusTuple(0); } uint8_t* func_start = bpf_module_->function_start(func_name); if (!func_start) return StatusTuple(-1, "Can't find start of function %s", func_name.c_str()); size_t func_size = bpf_module_->function_size(func_name); fd = bpf_prog_load(type, reinterpret_cast(func_start), func_size, bpf_module_->license(), bpf_module_->kern_version(), nullptr, 0 // BPFModule will handle error printing ); if (fd < 0) return StatusTuple(-1, "Failed to load %s: %d", func_name.c_str(), fd); funcs_[func_name] = fd; return StatusTuple(0); } StatusTuple BPF::unload_func(const std::string& func_name) { auto it = funcs_.find(func_name); if (it == funcs_.end()) return StatusTuple(0); int res = close(it->second); if (res != 0) return StatusTuple(-1, "Can't close FD for %s: %d", it->first.c_str(), res); funcs_.erase(it); return StatusTuple(0); } StatusTuple BPF::check_binary_symbol(const std::string& binary_path, const std::string& symbol, uint64_t symbol_addr, bcc_symbol* output) { int res = bcc_resolve_symname(binary_path.c_str(), symbol.c_str(), symbol_addr, 0, output); if (res < 0) return StatusTuple( -1, "Unable to find offset for binary %s symbol %s address %lx", binary_path.c_str(), symbol.c_str(), symbol_addr); return StatusTuple(0); } std::string BPF::get_kprobe_event(const std::string& kernel_func, bpf_probe_attach_type type) { std::string res = attach_type_prefix(type) + "_"; res += sanitize_str(kernel_func, &BPF::kprobe_event_validator); return res; } std::string BPF::get_uprobe_event(const std::string& binary_path, uint64_t offset, bpf_probe_attach_type type) { std::string res = attach_type_prefix(type) + "_"; res += sanitize_str(binary_path, &BPF::uprobe_path_validator); res += "_0x" + uint_to_hex(offset); return res; } StatusTuple BPF::detach_kprobe_event(const std::string& event, open_probe_t& attr) { if (attr.reader_ptr) { perf_reader_free(attr.reader_ptr); attr.reader_ptr = nullptr; } TRY2(unload_func(attr.func)); if (bpf_detach_kprobe(event.c_str()) < 0) return StatusTuple(-1, "Unable to detach kprobe %s", event.c_str()); return StatusTuple(0); } StatusTuple BPF::detach_uprobe_event(const std::string& event, open_probe_t& attr) { if (attr.reader_ptr) { perf_reader_free(attr.reader_ptr); attr.reader_ptr = nullptr; } TRY2(unload_func(attr.func)); if (bpf_detach_uprobe(event.c_str()) < 0) return StatusTuple(-1, "Unable to detach uprobe %s", event.c_str()); return StatusTuple(0); } StatusTuple BPF::detach_tracepoint_event(const std::string& tracepoint, open_probe_t& attr) { if (attr.reader_ptr) { perf_reader_free(attr.reader_ptr); attr.reader_ptr = nullptr; } TRY2(unload_func(attr.func)); // TODO: bpf_detach_tracepoint currently does nothing. return StatusTuple(0); } StatusTuple BPF::detach_perf_event_all_cpu(open_probe_t& attr) { bool has_error = false; std::string err_msg; for (auto it : *attr.per_cpu_fd) { int res = close(it.second); if (res < 0) { has_error = true; err_msg += "Failed to close perf event FD " + std::to_string(it.second) + " For CPU " + std::to_string(it.first) + ": "; err_msg += std::string(std::strerror(errno)) + "\n"; } } delete attr.per_cpu_fd; TRY2(unload_func(attr.func)); if (has_error) return StatusTuple(-1, err_msg); return StatusTuple(0); } StatusTuple USDT::init() { auto ctx = std::unique_ptr<::USDT::Context>(new ::USDT::Context(binary_path_)); if (!ctx->loaded()) return StatusTuple(-1, "Unable to load USDT " + print_name()); auto probe = ctx->get(name_); if (probe == nullptr) return StatusTuple(-1, "Unable to find USDT " + print_name()); if (!probe->enable(probe_func_)) return StatusTuple(-1, "Failed to enable USDT " + print_name()); std::ostringstream stream; if (!probe->usdt_getarg(stream)) return StatusTuple( -1, "Unable to generate program text for USDT " + print_name()); program_text_ = ::USDT::USDT_PROGRAM_HEADER + stream.str(); for (size_t i = 0; i < probe->num_locations(); i++) addresses_.push_back(probe->address(i)); initialized_ = true; return StatusTuple(0); } } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/BPF.h000066400000000000000000000147241305314114400164420ustar00rootroot00000000000000/* * Copyright (c) 2016 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include "BPFTable.h" #include "bcc_exception.h" #include "bcc_syms.h" #include "bpf_module.h" #include "compat/linux/bpf.h" #include "libbpf.h" namespace ebpf { struct open_probe_t { void* reader_ptr; std::string func; std::map* per_cpu_fd; }; class USDT; class BPF { public: static const int BPF_MAX_STACK_DEPTH = 127; explicit BPF(unsigned int flag = 0) : bpf_module_(new BPFModule(flag)) {} StatusTuple init(const std::string& bpf_program, std::vector cflags = {}, std::vector usdt = {}); ~BPF(); StatusTuple detach_all(); StatusTuple attach_kprobe( const std::string& kernel_func, const std::string& probe_func, bpf_probe_attach_type = BPF_PROBE_ENTRY, pid_t pid = -1, int cpu = 0, int group_fd = -1, perf_reader_cb cb = nullptr, void* cb_cookie = nullptr); StatusTuple detach_kprobe( const std::string& kernel_func, bpf_probe_attach_type attach_type = BPF_PROBE_ENTRY); StatusTuple attach_uprobe( const std::string& binary_path, const std::string& symbol, const std::string& probe_func, uint64_t symbol_addr = 0, bpf_probe_attach_type attach_type = BPF_PROBE_ENTRY, pid_t pid = -1, int cpu = 0, int group_fd = -1, perf_reader_cb cb = nullptr, void* cb_cookie = nullptr); StatusTuple detach_uprobe( const std::string& binary_path, const std::string& symbol, uint64_t symbol_addr = 0, bpf_probe_attach_type attach_type = BPF_PROBE_ENTRY); StatusTuple attach_usdt(const USDT& usdt, pid_t pid = -1, int cpu = 0, int group_fd = -1); StatusTuple detach_usdt(const USDT& usdt); StatusTuple attach_tracepoint(const std::string& tracepoint, const std::string& probe_func, pid_t pid = -1, int cpu = 0, int group_fd = -1, perf_reader_cb cb = nullptr, void* cb_cookie = nullptr); StatusTuple detach_tracepoint(const std::string& tracepoint); StatusTuple attach_perf_event(uint32_t ev_type, uint32_t ev_config, const std::string& probe_func, uint64_t sample_period, uint64_t sample_freq, pid_t pid = -1, int cpu = -1, int group_fd = -1); StatusTuple detach_perf_event(uint32_t ev_type, uint32_t ev_config); template BPFHashTable get_hash_table(const std::string& name) { return BPFHashTable(bpf_module_.get(), name); } BPFStackTable get_stack_table(const std::string& name) { return BPFStackTable(bpf_module_.get(), name); } StatusTuple open_perf_buffer(const std::string& name, perf_reader_raw_cb cb, void* cb_cookie = nullptr); StatusTuple close_perf_buffer(const std::string& name); void poll_perf_buffer(const std::string& name, int timeout = -1); private: StatusTuple load_func(const std::string& func_name, enum bpf_prog_type type, int& fd); StatusTuple unload_func(const std::string& func_name); std::string get_kprobe_event(const std::string& kernel_func, bpf_probe_attach_type type); std::string get_uprobe_event(const std::string& binary_path, uint64_t offset, bpf_probe_attach_type type); StatusTuple detach_kprobe_event(const std::string& event, open_probe_t& attr); StatusTuple detach_uprobe_event(const std::string& event, open_probe_t& attr); StatusTuple detach_tracepoint_event(const std::string& tracepoint, open_probe_t& attr); StatusTuple detach_perf_event_all_cpu(open_probe_t& attr); std::string attach_type_debug(bpf_probe_attach_type type) { switch (type) { case BPF_PROBE_ENTRY: return ""; case BPF_PROBE_RETURN: return "return "; } return "ERROR"; } std::string attach_type_prefix(bpf_probe_attach_type type) { switch (type) { case BPF_PROBE_ENTRY: return "p"; case BPF_PROBE_RETURN: return "r"; } return "ERROR"; } static bool kprobe_event_validator(char c) { return (c != '+') && (c != '.'); } static bool uprobe_path_validator(char c) { return std::isalpha(c) || std::isdigit(c) || (c == '_'); } StatusTuple check_binary_symbol(const std::string& binary_path, const std::string& symbol, uint64_t symbol_addr, bcc_symbol* output); std::unique_ptr bpf_module_; std::map funcs_; std::vector usdt_; std::map kprobes_; std::map uprobes_; std::map tracepoints_; std::map perf_buffers_; std::map, open_probe_t> perf_events_; }; class USDT { public: USDT(const std::string& binary_path, const std::string& provider, const std::string& name, const std::string& probe_func) : initialized_(false), binary_path_(binary_path), provider_(provider), name_(name), probe_func_(probe_func) {} bool operator==(const USDT& other) const { return (provider_ == other.provider_) && (name_ == other.name_) && (binary_path_ == other.binary_path_) && (probe_func_ == other.probe_func_); } std::string print_name() const { return provider_ + ":" + name_ + " from " + binary_path_; } private: StatusTuple init(); bool initialized_; std::string binary_path_; std::string provider_; std::string name_; std::string probe_func_; std::vector addresses_; std::string program_text_; friend class BPF; }; } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/BPFTable.cc000066400000000000000000000102111305314114400175330ustar00rootroot00000000000000/* * Copyright (c) 2016 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include "BPFTable.h" #include "bcc_exception.h" #include "bcc_syms.h" #include "libbpf.h" #include "perf_reader.h" #include "common.h" namespace ebpf { BPFStackTable::~BPFStackTable() { for (auto it : pid_sym_) bcc_free_symcache(it.second, it.first); } std::vector BPFStackTable::get_stack_addr(int stack_id) { std::vector res; stacktrace_t stack; if (!lookup(&stack_id, &stack)) return res; for (int i = 0; (i < BPF_MAX_STACK_DEPTH) && (stack.ip[i] != 0); i++) res.push_back(stack.ip[i]); return res; } std::vector BPFStackTable::get_stack_symbol(int stack_id, int pid) { auto addresses = get_stack_addr(stack_id); std::vector res; res.reserve(addresses.size()); if (pid < 0) pid = -1; if (pid_sym_.find(pid) == pid_sym_.end()) pid_sym_[pid] = bcc_symcache_new(pid); void* cache = pid_sym_[pid]; bcc_symbol symbol; for (auto addr : addresses) if (bcc_symcache_resolve(cache, addr, &symbol) != 0) res.push_back("[UNKNOWN]"); else res.push_back(symbol.demangle_name); return res; } StatusTuple BPFPerfBuffer::open_on_cpu(perf_reader_raw_cb cb, int cpu, void* cb_cookie) { if (cpu_readers_.find(cpu) != cpu_readers_.end()) return StatusTuple(-1, "Perf buffer already open on CPU %d", cpu); auto reader = static_cast(bpf_open_perf_buffer(cb, cb_cookie, -1, cpu)); if (reader == nullptr) return StatusTuple(-1, "Unable to construct perf reader"); int reader_fd = perf_reader_fd(reader); if (!update(&cpu, &reader_fd)) { perf_reader_free(static_cast(reader)); return StatusTuple(-1, "Unable to open perf buffer on CPU %d: %s", cpu, strerror(errno)); } cpu_readers_[cpu] = reader; readers_.push_back(reader); return StatusTuple(0); } StatusTuple BPFPerfBuffer::open_all_cpu(perf_reader_raw_cb cb, void* cb_cookie) { if (cpu_readers_.size() != 0 || readers_.size() != 0) return StatusTuple(-1, "Previously opened perf buffer not cleaned"); for (int i: get_online_cpus()) { auto res = open_on_cpu(cb, i, cb_cookie); if (res.code() != 0) { TRY2(close_all_cpu()); return res; } } return StatusTuple(0); } StatusTuple BPFPerfBuffer::close_on_cpu(int cpu) { auto it = cpu_readers_.find(cpu); if (it == cpu_readers_.end()) return StatusTuple(0); perf_reader_free(static_cast(it->second)); if (!remove(const_cast(&(it->first)))) return StatusTuple(-1, "Unable to close perf buffer on CPU %d", it->first); cpu_readers_.erase(it); return StatusTuple(0); } StatusTuple BPFPerfBuffer::close_all_cpu() { std::string errors; bool has_error = false; for (int i: get_online_cpus()) { auto res = close_on_cpu(i); if (res.code() != 0) { errors += "Failed to close CPU" + std::to_string(i) + " perf buffer: "; errors += res.msg() + "\n"; has_error = true; } } readers_.clear(); if (has_error) return StatusTuple(-1, errors); return StatusTuple(0); } void BPFPerfBuffer::poll(int timeout) { if (readers_.empty()) return; perf_reader_poll(readers_.size(), readers_.data(), timeout); } BPFPerfBuffer::~BPFPerfBuffer() { auto res = close_all_cpu(); if (res.code() != 0) std::cerr << "Failed to close all perf buffer on destruction: " << res.msg() << std::endl; } } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/BPFTable.h000066400000000000000000000075211305314114400174070ustar00rootroot00000000000000/* * Copyright (c) 2016 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include #include #include "bcc_exception.h" #include "bpf_module.h" #include "libbpf.h" #include "perf_reader.h" namespace ebpf { template class BPFTableBase { public: size_t capacity() { return capacity_; } protected: BPFTableBase(BPFModule* bpf_module, const std::string& name) { size_t id_ = bpf_module->table_id(name); if (id_ >= bpf_module->num_tables()) throw std::invalid_argument("Table " + name + " does not exist"); fd_ = bpf_module->table_fd(id_); capacity_ = bpf_module->table_max_entries(id_); }; bool lookup(KeyType* key, ValueType* value) { return bpf_lookup_elem(fd_, static_cast(key), static_cast(value)) >= 0; } bool next(KeyType* key, KeyType* next_key) { return bpf_get_next_key(fd_, static_cast(key), static_cast(next_key)) >= 0; } bool update(KeyType* key, ValueType* value) { return bpf_update_elem(fd_, static_cast(key), static_cast(value), 0) >= 0; } bool remove(KeyType* key) { return bpf_delete_elem(fd_, static_cast(key)) >= 0; } int fd_; size_t capacity_; }; template class BPFHashTable : protected BPFTableBase { public: BPFHashTable(BPFModule* bpf_module, const std::string& name) : BPFTableBase(bpf_module, name) {} ValueType get_value(const KeyType& key) { ValueType res; if (!this->lookup(const_cast(&key), &res)) throw std::invalid_argument("Key does not exist in the table"); return res; } ValueType operator[](const KeyType& key) { return get_value(key); } std::vector> get_table_offline() { std::vector> res; KeyType cur, nxt; ValueType value; while (true) { if (!this->next(&cur, &nxt)) break; if (!this->lookup(&nxt, &value)) break; res.emplace_back(nxt, value); std::swap(cur, nxt); } return res; } }; // From src/cc/export/helpers.h static const int BPF_MAX_STACK_DEPTH = 127; struct stacktrace_t { intptr_t ip[BPF_MAX_STACK_DEPTH]; }; class BPFStackTable : protected BPFTableBase { public: BPFStackTable(BPFModule* bpf_module, const std::string& name) : BPFTableBase(bpf_module, name) {} ~BPFStackTable(); std::vector get_stack_addr(int stack_id); std::vector get_stack_symbol(int stack_id, int pid); private: std::map pid_sym_; }; class BPFPerfBuffer : protected BPFTableBase { public: BPFPerfBuffer(BPFModule* bpf_module, const std::string& name) : BPFTableBase(bpf_module, name) {} ~BPFPerfBuffer(); StatusTuple open_all_cpu(perf_reader_raw_cb cb, void* cb_cookie); StatusTuple close_all_cpu(); void poll(int timeout); private: StatusTuple open_on_cpu(perf_reader_raw_cb cb, int cpu, void* cb_cookie); StatusTuple close_on_cpu(int cpu); std::map cpu_readers_; std::vector readers_; }; } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/CMakeLists.txt000066400000000000000000000076461305314114400204270ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) # to be removed include_directories(${CMAKE_CURRENT_BINARY_DIR}/frontends/b) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/frontends/b) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/frontends/clang) include_directories(${LLVM_INCLUDE_DIRS}) include_directories(${LIBELF_INCLUDE_DIRS}) # todo: if check for kernel version include_directories(${CMAKE_CURRENT_SOURCE_DIR}/compat) add_definitions(${LLVM_DEFINITIONS}) configure_file(libbcc.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libbcc.pc @ONLY) # prune unused llvm static library stuff when linking into the new .so set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--exclude-libs=ALL") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC") # only turn on static-libstdc++ if also linking statically against clang string(REGEX MATCH ".*[.]a$" LIBCLANG_ISSTATIC "${libclangBasic}") # if gcc 4.9 or higher is used, static libstdc++ is a good option if (CMAKE_COMPILER_IS_GNUCC AND LIBCLANG_ISSTATIC) execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION) if (GCC_VERSION VERSION_GREATER 4.9 OR GCC_VERSION VERSION_EQUAL 4.9) execute_process(COMMAND ${CMAKE_C_COMPILER} -print-libgcc-file-name OUTPUT_VARIABLE GCC_LIB) get_filename_component(GCC_DIR "${GCC_LIB}" DIRECTORY) find_library(GCC_LIBSTDCPP libstdc++.a PATHS "${GCC_DIR}" NO_DEFAULT_PATH) if (GCC_LIBSTDCPP) message(STATUS "Using static-libstdc++") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-libstdc++") endif() endif() endif() add_library(bcc-shared SHARED bpf_common.cc bpf_module.cc libbpf.c perf_reader.c shared_table.cc exported_files.cc bcc_elf.c bcc_perf_map.c bcc_proc.c bcc_syms.cc usdt_args.cc usdt.cc common.cc BPF.cc BPFTable.cc) set_target_properties(bcc-shared PROPERTIES VERSION ${REVISION_LAST} SOVERSION 0) set_target_properties(bcc-shared PROPERTIES OUTPUT_NAME bcc) add_library(bcc-loader-static libbpf.c perf_reader.c bcc_elf.c bcc_perf_map.c bcc_proc.c) add_library(bcc-static STATIC bpf_common.cc bpf_module.cc shared_table.cc exported_files.cc bcc_syms.cc usdt_args.cc usdt.cc common.cc BPF.cc BPFTable.cc) set_target_properties(bcc-static PROPERTIES OUTPUT_NAME bcc) set(llvm_raw_libs bitwriter bpfcodegen irreader linker mcjit objcarcopts option passes nativecodegen lto) list(FIND LLVM_AVAILABLE_LIBS "LLVMCoverage" _llvm_coverage) if (${_llvm_coverage} GREATER -1) list(APPEND llvm_raw_libs coverage) endif() list(FIND LLVM_AVAILABLE_LIBS "LLVMCoroutines" _llvm_coroutines) if (${_llvm_coroutines} GREATER -1) list(APPEND llvm_raw_libs coroutines) endif() llvm_map_components_to_libnames(llvm_libs ${llvm_raw_libs}) llvm_expand_dependencies(expanded_libs ${llvm_libs}) # order is important set(clang_libs ${libclangFrontend} ${libclangSerialization} ${libclangDriver} ${libclangParse} ${libclangSema} ${libclangCodeGen} ${libclangAnalysis} ${libclangRewrite} ${libclangEdit} ${libclangAST} ${libclangLex} ${libclangBasic}) # Link against LLVM libraries target_link_libraries(bcc-shared b_frontend clang_frontend ${clang_libs} ${expanded_libs} ${LIBELF_LIBRARIES}) target_link_libraries(bcc-static b_frontend clang_frontend bcc-loader-static ${clang_libs} ${expanded_libs} ${LIBELF_LIBRARIES}) install(TARGETS bcc-shared LIBRARY COMPONENT libbcc DESTINATION ${CMAKE_INSTALL_LIBDIR}) install(FILES bpf_common.h bpf_module.h bcc_syms.h bcc_exception.h libbpf.h perf_reader.h BPF.h BPFTable.h shared_table.h COMPONENT libbcc DESTINATION include/bcc) install(DIRECTORY compat/linux/ COMPONENT libbcc DESTINATION include/bcc/compat/linux FILES_MATCHING PATTERN "*.h") install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libbcc.pc COMPONENT libbcc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) add_subdirectory(frontends) bpfcc-0.2.0+git0.02884a026/src/cc/bcc_elf.c000066400000000000000000000337221305314114400174020ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include "bcc_elf.h" #define NT_STAPSDT 3 static int openelf(const char *path, Elf **elf_out, int *fd_out) { if (elf_version(EV_CURRENT) == EV_NONE) return -1; *fd_out = open(path, O_RDONLY); if (*fd_out < 0) return -1; *elf_out = elf_begin(*fd_out, ELF_C_READ, 0); if (*elf_out == 0) { close(*fd_out); return -1; } return 0; } static const char *parse_stapsdt_note(struct bcc_elf_usdt *probe, const char *desc, int elf_class) { if (elf_class == ELFCLASS32) { probe->pc = *((uint32_t *)(desc)); probe->base_addr = *((uint32_t *)(desc + 4)); probe->semaphore = *((uint32_t *)(desc + 8)); desc = desc + 12; } else { probe->pc = *((uint64_t *)(desc)); probe->base_addr = *((uint64_t *)(desc + 8)); probe->semaphore = *((uint64_t *)(desc + 16)); desc = desc + 24; } probe->provider = desc; desc += strlen(desc) + 1; probe->name = desc; desc += strlen(desc) + 1; probe->arg_fmt = desc; desc += strlen(desc) + 1; return desc; } static int do_note_segment(Elf_Scn *section, int elf_class, bcc_elf_probecb callback, const char *binpath, void *payload) { Elf_Data *data = NULL; while ((data = elf_getdata(section, data)) != 0) { size_t offset = 0; GElf_Nhdr hdr; size_t name_off, desc_off; while ((offset = gelf_getnote(data, offset, &hdr, &name_off, &desc_off)) != 0) { const char *desc, *desc_end; struct bcc_elf_usdt probe; if (hdr.n_type != NT_STAPSDT) continue; if (hdr.n_namesz != 8) continue; if (memcmp((const char *)data->d_buf + name_off, "stapsdt", 8) != 0) continue; desc = (const char *)data->d_buf + desc_off; desc_end = desc + hdr.n_descsz; if (parse_stapsdt_note(&probe, desc, elf_class) == desc_end) callback(binpath, &probe, payload); } } return 0; } static int listprobes(Elf *e, bcc_elf_probecb callback, const char *binpath, void *payload) { Elf_Scn *section = NULL; size_t stridx; int elf_class = gelf_getclass(e); if (elf_getshdrstrndx(e, &stridx) != 0) return -1; while ((section = elf_nextscn(e, section)) != 0) { GElf_Shdr header; char *name; if (!gelf_getshdr(section, &header)) continue; if (header.sh_type != SHT_NOTE) continue; name = elf_strptr(e, stridx, header.sh_name); if (name && !strcmp(name, ".note.stapsdt")) { if (do_note_segment(section, elf_class, callback, binpath, payload) < 0) return -1; } } return 0; } int bcc_elf_foreach_usdt(const char *path, bcc_elf_probecb callback, void *payload) { Elf *e; int fd, res; if (openelf(path, &e, &fd) < 0) return -1; res = listprobes(e, callback, path, payload); elf_end(e); close(fd); return res; } static int list_in_scn(Elf *e, Elf_Scn *section, size_t stridx, size_t symsize, bcc_elf_symcb callback, void *payload) { Elf_Data *data = NULL; while ((data = elf_getdata(section, data)) != 0) { size_t i, symcount = data->d_size / symsize; if (data->d_size % symsize) return -1; for (i = 0; i < symcount; ++i) { GElf_Sym sym; const char *name; if (!gelf_getsym(data, (int)i, &sym)) continue; if ((name = elf_strptr(e, stridx, sym.st_name)) == NULL) continue; if (callback(name, sym.st_value, sym.st_size, sym.st_info, payload) < 0) return 1; // signal termination to caller } } return 0; } static int listsymbols(Elf *e, bcc_elf_symcb callback, void *payload) { Elf_Scn *section = NULL; while ((section = elf_nextscn(e, section)) != 0) { GElf_Shdr header; if (!gelf_getshdr(section, &header)) continue; if (header.sh_type != SHT_SYMTAB && header.sh_type != SHT_DYNSYM) continue; int rc = list_in_scn(e, section, header.sh_link, header.sh_entsize, callback, payload); if (rc == 1) break; // callback signaled termination if (rc < 0) return rc; } return 0; } static Elf_Data * get_section_elf_data(Elf *e, const char *section_name) { Elf_Scn *section = NULL; GElf_Shdr header; char *name; size_t stridx; if (elf_getshdrstrndx(e, &stridx) != 0) return NULL; while ((section = elf_nextscn(e, section)) != 0) { if (!gelf_getshdr(section, &header)) continue; name = elf_strptr(e, stridx, header.sh_name); if (name && !strcmp(name, section_name)) { return elf_getdata(section, NULL); } } return NULL; } static int find_debuglink(Elf *e, char **debug_file, unsigned int *crc) { Elf_Data *data = NULL; *debug_file = NULL; *crc = 0; data = get_section_elf_data(e, ".gnu_debuglink"); if (!data || data->d_size <= 5) return 0; *debug_file = (char *)data->d_buf; *crc = *(unsigned int*)((char *)data->d_buf + data->d_size - 4); return *debug_file ? 1 : 0; } static int find_buildid(Elf *e, char *buildid) { Elf_Data *data = get_section_elf_data(e, ".note.gnu.build-id"); if (data->d_size <= 16 || strcmp((char *)data->d_buf + 12, "GNU")) return 0; char *buf = (char *)data->d_buf + 16; size_t length = data->d_size - 16; size_t i = 0; for (i = 0; i < length; ++i) { sprintf(buildid + (i * 2), "%02hhx", buf[i]); } return 1; } // The CRC algorithm used by GNU debuglink. Taken from: // https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html static unsigned int gnu_debuglink_crc32(unsigned int crc, char *buf, size_t len) { static const unsigned int crc32_table[256] = { 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d }; char *end; crc = ~crc & 0xffffffff; for (end = buf + len; buf < end; ++buf) crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); return ~crc & 0xffffffff; } static int verify_checksum(const char *file, unsigned int crc) { struct stat st; int fd; void *buf; unsigned int actual; fd = open(file, O_RDONLY); if (fd < 0) return 0; if (fstat(fd, &st) < 0) return 0; buf = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); if (!buf) { close(fd); return 0; } actual = gnu_debuglink_crc32(0, buf, st.st_size); munmap(buf, st.st_size); close(fd); return actual == crc; } static char *find_debug_via_debuglink(Elf *e, const char *binpath) { char fullpath[PATH_MAX]; char *bindir = NULL; char *res = NULL; unsigned int crc; char *name; // the name of the debuginfo file if (!find_debuglink(e, &name, &crc)) return NULL; bindir = strdup(binpath); bindir = dirname(bindir); // Search for the file in 'binpath' sprintf(fullpath, "%s/%s", bindir, name); if (access(fullpath, F_OK) != -1) { res = strdup(fullpath); goto DONE; } // Search for the file in 'binpath'/.debug sprintf(fullpath, "%s/.debug/%s", bindir, name); if (access(fullpath, F_OK) != -1) { res = strdup(fullpath); goto DONE; } // Search for the file in the global debug directory /usr/lib/debug/'binpath' sprintf(fullpath, "/usr/lib/debug%s/%s", bindir, name); if (access(fullpath, F_OK) != -1) { res = strdup(fullpath); goto DONE; } DONE: free(bindir); if (verify_checksum(res, crc)) return res; return NULL; } static char *find_debug_via_buildid(Elf *e) { char fullpath[PATH_MAX]; char buildid[128]; // currently 40 seems to be default, let's be safe if (!find_buildid(e, buildid)) return NULL; // Search for the file in the global debug directory with a sub-path: // mm/nnnnnn...nnnn.debug // Where mm are the first two characters of the buildid, and nnnn are the // rest of the build id, followed by .debug. sprintf(fullpath, "/usr/lib/debug/.build-id/%c%c/%s.debug", buildid[0], buildid[1], buildid + 2); if (access(fullpath, F_OK) != -1) { return strdup(fullpath); } return NULL; } static int foreach_sym_core(const char *path, bcc_elf_symcb callback, void *payload, int is_debug_file) { Elf *e; int fd, res; char *debug_file; if (openelf(path, &e, &fd) < 0) return -1; // If there is a separate debuginfo file, try to locate and read it, first // using the build-id section, then using the debuglink section. These are // also the rules that GDB folows. // See: https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html if (!is_debug_file) { // The is_debug_file argument helps avoid infinitely resolving debuginfo // files for debuginfo files and so on. debug_file = find_debug_via_buildid(e); if (!debug_file) debug_file = find_debug_via_debuglink(e, path); if (debug_file) { foreach_sym_core(debug_file, callback, payload, 1); free(debug_file); } } res = listsymbols(e, callback, payload); elf_end(e); close(fd); return res; } int bcc_elf_foreach_sym(const char *path, bcc_elf_symcb callback, void *payload) { return foreach_sym_core(path, callback, payload, 0); } static int loadaddr(Elf *e, uint64_t *addr) { size_t phnum, i; if (elf_getphdrnum(e, &phnum) != 0) return -1; for (i = 0; i < phnum; ++i) { GElf_Phdr header; if (!gelf_getphdr(e, (int)i, &header)) continue; if (header.p_type != PT_LOAD) continue; *addr = (uint64_t)header.p_vaddr; return 0; } return -1; } int bcc_elf_loadaddr(const char *path, uint64_t *address) { Elf *e; int fd, res; if (openelf(path, &e, &fd) < 0) return -1; res = loadaddr(e, address); elf_end(e); close(fd); return res; } int bcc_elf_is_shared_obj(const char *path) { Elf *e; GElf_Ehdr hdr; int fd, res = -1; if (openelf(path, &e, &fd) < 0) return -1; if (gelf_getehdr(e, &hdr)) res = (hdr.e_type == ET_DYN); elf_end(e); close(fd); return res; } #if 0 #include int main(int argc, char *argv[]) { uint64_t addr; if (bcc_elf_findsym(argv[1], argv[2], -1, STT_FUNC, &addr) < 0) return -1; printf("%s: %p\n", argv[2], (void *)addr); return 0; } #endif bpfcc-0.2.0+git0.02884a026/src/cc/bcc_elf.h000066400000000000000000000025731305314114400174070ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef LIBBCC_ELF_H #define LIBBCC_ELF_H #ifdef __cplusplus extern "C" { #endif #include struct bcc_elf_usdt { uint64_t pc; uint64_t base_addr; uint64_t semaphore; const char *provider; const char *name; const char *arg_fmt; }; typedef void (*bcc_elf_probecb)(const char *, const struct bcc_elf_usdt *, void *); typedef int (*bcc_elf_symcb)(const char *, uint64_t, uint64_t, int, void *); int bcc_elf_foreach_usdt(const char *path, bcc_elf_probecb callback, void *payload); int bcc_elf_loadaddr(const char *path, uint64_t *address); int bcc_elf_foreach_sym(const char *path, bcc_elf_symcb callback, void *payload); int bcc_elf_is_shared_obj(const char *path); #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/bcc_exception.h000066400000000000000000000027201305314114400206310ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include namespace ebpf { class StatusTuple { public: StatusTuple(int ret) : ret_(ret) {} StatusTuple(int ret, const char *msg) : ret_(ret), msg_(msg) {} StatusTuple(int ret, const std::string &msg) : ret_(ret), msg_(msg) {} template StatusTuple(int ret, const char *fmt, Args... args) : ret_(ret) { char buf[2048]; snprintf(buf, sizeof(buf), fmt, args...); msg_ = std::string(buf); } void append_msg(const std::string& msg) { msg_ += msg; } int code() { return ret_; } std::string msg() { return msg_; } private: int ret_; std::string msg_; }; #define TRY2(CMD) \ do { \ StatusTuple __stp = (CMD); \ if (__stp.code() != 0) { \ return __stp; \ } \ } while (0) } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/bcc_perf_map.c000066400000000000000000000054271305314114400204260ustar00rootroot00000000000000/* * Copyright (c) 2016 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include "bcc_perf_map.h" int bcc_perf_map_nstgid(int pid) { char status_path[64]; FILE *status; snprintf(status_path, sizeof(status_path), "/proc/%d/status", pid); status = fopen(status_path, "r"); if (!status) return -1; // return the original PID if we fail to work out the TGID int nstgid = pid; size_t size = 0; char *line = NULL; while (getline(&line, &size, status) != -1) { // check Tgid line first in case CONFIG_PID_NS is off if (strstr(line, "Tgid:") != NULL) nstgid = (int)strtol(strrchr(line, '\t'), NULL, 10); if (strstr(line, "NStgid:") != NULL) // PID namespaces can be nested -- last number is innermost PID nstgid = (int)strtol(strrchr(line, '\t'), NULL, 10); } free(line); fclose(status); return nstgid; } bool bcc_perf_map_path(char *map_path, size_t map_len, int pid) { char source[64]; snprintf(source, sizeof(source), "/proc/%d/root", pid); char target[4096]; ssize_t target_len = readlink(source, target, sizeof(target) - 1); if (target_len == -1) return false; target[target_len] = '\0'; if (strcmp(target, "/") == 0) target[0] = '\0'; int nstgid = bcc_perf_map_nstgid(pid); snprintf(map_path, map_len, "%s/tmp/perf-%d.map", target, nstgid); return true; } int bcc_perf_map_foreach_sym(const char *path, bcc_perf_map_symcb callback, void* payload) { FILE* file = fopen(path, "r"); if (!file) return -1; char *line = NULL; size_t size = 0; long long begin, len; while (getline(&line, &size, file) != -1) { char *cursor = line; char *newline, *sep; begin = strtoull(cursor, &sep, 16); if (*sep != ' ' || (sep == cursor && begin == 0)) continue; cursor = sep; while (*cursor && isspace(*cursor)) cursor++; len = strtoull(cursor, &sep, 16); if (*sep != ' ' || (sep == cursor && begin == 0)) continue; cursor = sep; while (*cursor && isspace(*cursor)) cursor++; newline = strchr(cursor, '\n'); if (newline) newline[0] = '\0'; callback(cursor, begin, len, 0, payload); } free(line); fclose(file); return 0; } bpfcc-0.2.0+git0.02884a026/src/cc/bcc_perf_map.h000066400000000000000000000021461305314114400204260ustar00rootroot00000000000000/* * Copyright (c) 2016 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef LIBBCC_PERF_MAP_H #define LIBBCC_PERF_MAP_H #ifdef __cplusplus extern "C" { #endif #include #include #include typedef int (*bcc_perf_map_symcb)(const char *, uint64_t, uint64_t, int, void *); int bcc_perf_map_nstgid(int pid); bool bcc_perf_map_path(char *map_path, size_t map_len, int pid); int bcc_perf_map_foreach_sym(const char *path, bcc_perf_map_symcb callback, void* payload); #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/bcc_proc.c000066400000000000000000000222561305314114400175770ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "bcc_perf_map.h" #include "bcc_proc.h" #include "bcc_elf.h" static bool is_exe(const char *path) { struct stat s; if (access(path, X_OK) < 0) return false; if (stat(path, &s) < 0) return false; return S_ISREG(s.st_mode); } char *bcc_procutils_which(const char *binpath) { char buffer[4096]; const char *PATH; if (strchr(binpath, '/')) return is_exe(binpath) ? strdup(binpath) : 0; if (!(PATH = getenv("PATH"))) return 0; while (PATH) { const char *next = strchr(PATH, ':') ?: strchr(PATH, '\0'); const size_t path_len = next - PATH; if (path_len) { memcpy(buffer, PATH, path_len); buffer[path_len] = '/'; strcpy(buffer + path_len + 1, binpath); if (is_exe(buffer)) return strdup(buffer); } PATH = *next ? (next + 1) : 0; } return 0; } int bcc_procutils_each_module(int pid, bcc_procutils_modulecb callback, void *payload) { char procmap_filename[128]; FILE *procmap; int ret; sprintf(procmap_filename, "/proc/%ld/maps", (long)pid); procmap = fopen(procmap_filename, "r"); if (!procmap) return -1; do { char endline[4096]; char perm[8], dev[8]; long long begin, end, size, inode; ret = fscanf(procmap, "%llx-%llx %s %llx %s %lld", &begin, &end, perm, &size, dev, &inode); if (!fgets(endline, sizeof(endline), procmap)) break; if (ret == 6) { char *mapname = endline; char *newline = strchr(endline, '\n'); if (newline) newline[0] = '\0'; while (isspace(mapname[0])) mapname++; if (strchr(perm, 'x') && mapname[0] && mapname[0] != '[') { if (callback(mapname, (uint64_t)begin, (uint64_t)end, payload) < 0) break; } } } while (ret && ret != EOF); fclose(procmap); // Add a mapping to /tmp/perf-pid.map for the entire address space. This will // be used if symbols aren't resolved in an earlier mapping. char map_path[4096]; if (bcc_perf_map_path(map_path, sizeof(map_path), pid)) callback(map_path, 0, -1, payload); return 0; } int bcc_procutils_each_ksym(bcc_procutils_ksymcb callback, void *payload) { char line[2048]; FILE *kallsyms; /* root is needed to list ksym addresses */ if (geteuid() != 0) return -1; kallsyms = fopen("/proc/kallsyms", "r"); if (!kallsyms) return -1; if (!fgets(line, sizeof(line), kallsyms)) { fclose(kallsyms); return -1; } while (fgets(line, sizeof(line), kallsyms)) { char *symname, *endsym; unsigned long long addr; addr = strtoull(line, &symname, 16); endsym = symname = symname + 3; while (*endsym && !isspace(*endsym)) endsym++; *endsym = '\0'; callback(symname, addr, payload); } fclose(kallsyms); return 0; } #define CACHE1_HEADER "ld.so-1.7.0" #define CACHE1_HEADER_LEN (sizeof(CACHE1_HEADER) - 1) #define CACHE2_HEADER "glibc-ld.so.cache" #define CACHE2_HEADER_LEN (sizeof(CACHE2_HEADER) - 1) #define CACHE2_VERSION "1.1" struct ld_cache1_entry { int32_t flags; uint32_t key; uint32_t value; }; struct ld_cache1 { char header[CACHE1_HEADER_LEN]; uint32_t entry_count; struct ld_cache1_entry entries[0]; }; struct ld_cache2_entry { int32_t flags; uint32_t key; uint32_t value; uint32_t pad1_; uint64_t pad2_; }; struct ld_cache2 { char header[CACHE2_HEADER_LEN]; char version[3]; uint32_t entry_count; uint32_t string_table_len; uint32_t pad_[5]; struct ld_cache2_entry entries[0]; }; static int lib_cache_count; static struct ld_lib { char *libname; char *path; int flags; } * lib_cache; static int read_cache1(const char *ld_map) { struct ld_cache1 *ldcache = (struct ld_cache1 *)ld_map; const char *ldstrings = (const char *)(ldcache->entries + ldcache->entry_count); uint32_t i; lib_cache = (struct ld_lib *)malloc(ldcache->entry_count * sizeof(struct ld_lib)); lib_cache_count = (int)ldcache->entry_count; for (i = 0; i < ldcache->entry_count; ++i) { const char *key = ldstrings + ldcache->entries[i].key; const char *val = ldstrings + ldcache->entries[i].value; const int flags = ldcache->entries[i].flags; lib_cache[i].libname = strdup(key); lib_cache[i].path = strdup(val); lib_cache[i].flags = flags; } return 0; } static int read_cache2(const char *ld_map) { struct ld_cache2 *ldcache = (struct ld_cache2 *)ld_map; uint32_t i; if (memcmp(ld_map, CACHE2_HEADER, CACHE2_HEADER_LEN)) return -1; lib_cache = (struct ld_lib *)malloc(ldcache->entry_count * sizeof(struct ld_lib)); lib_cache_count = (int)ldcache->entry_count; for (i = 0; i < ldcache->entry_count; ++i) { const char *key = ld_map + ldcache->entries[i].key; const char *val = ld_map + ldcache->entries[i].value; const int flags = ldcache->entries[i].flags; lib_cache[i].libname = strdup(key); lib_cache[i].path = strdup(val); lib_cache[i].flags = flags; } return 0; } static int load_ld_cache(const char *cache_path) { struct stat st; size_t ld_size; const char *ld_map; int ret, fd = open(cache_path, O_RDONLY); if (fd < 0) return -1; if (fstat(fd, &st) < 0 || st.st_size < sizeof(struct ld_cache1)) { close(fd); return -1; } ld_size = st.st_size; ld_map = (const char *)mmap(NULL, ld_size, PROT_READ, MAP_PRIVATE, fd, 0); if (ld_map == MAP_FAILED) { close(fd); return -1; } if (memcmp(ld_map, CACHE1_HEADER, CACHE1_HEADER_LEN) == 0) { const struct ld_cache1 *cache1 = (struct ld_cache1 *)ld_map; size_t cache1_len = sizeof(struct ld_cache1) + (cache1->entry_count * sizeof(struct ld_cache1_entry)); cache1_len = (cache1_len + 0x7) & ~0x7ULL; if (ld_size > (cache1_len + sizeof(struct ld_cache2))) ret = read_cache2(ld_map + cache1_len); else ret = read_cache1(ld_map); } else { ret = read_cache2(ld_map); } munmap((void *)ld_map, ld_size); close(fd); return ret; } #define LD_SO_CACHE "/etc/ld.so.cache" #define FLAG_TYPE_MASK 0x00ff #define TYPE_ELF_LIBC6 0x0003 #define FLAG_ABI_MASK 0xff00 #define ABI_SPARC_LIB64 0x0100 #define ABI_IA64_LIB64 0x0200 #define ABI_X8664_LIB64 0x0300 #define ABI_S390_LIB64 0x0400 #define ABI_POWERPC_LIB64 0x0500 static bool match_so_flags(int flags) { if ((flags & FLAG_TYPE_MASK) != TYPE_ELF_LIBC6) return false; switch (flags & FLAG_ABI_MASK) { case ABI_SPARC_LIB64: case ABI_IA64_LIB64: case ABI_X8664_LIB64: case ABI_S390_LIB64: case ABI_POWERPC_LIB64: return (sizeof(void *) == 8); } return true; } static bool which_so_in_process(const char* libname, int pid, char* libpath) { int ret, found = false; char endline[4096], *mapname = NULL, *newline; char mappings_file[128]; const size_t search_len = strlen(libname) + strlen("/lib."); char search1[search_len + 1]; char search2[search_len + 1]; sprintf(mappings_file, "/proc/%ld/maps", (long)pid); FILE *fp = fopen(mappings_file, "r"); if (!fp) return NULL; snprintf(search1, search_len + 1, "/lib%s.", libname); snprintf(search2, search_len + 1, "/lib%s-", libname); do { ret = fscanf(fp, "%*x-%*x %*s %*x %*s %*d"); if (!fgets(endline, sizeof(endline), fp)) break; mapname = endline; newline = strchr(endline, '\n'); if (newline) newline[0] = '\0'; while (isspace(mapname[0])) mapname++; if (strstr(mapname, ".so") && (strstr(mapname, search1) || strstr(mapname, search2))) { found = true; memcpy(libpath, mapname, strlen(mapname) + 1); break; } } while (ret != EOF); fclose(fp); return found; } char *bcc_procutils_which_so(const char *libname, int pid) { const size_t soname_len = strlen(libname) + strlen("lib.so"); char soname[soname_len + 1]; char libpath[4096]; int i; if (strchr(libname, '/')) return strdup(libname); if (pid && which_so_in_process(libname, pid, libpath)) return strdup(libpath); if (lib_cache_count < 0) return NULL; if (!lib_cache_count && load_ld_cache(LD_SO_CACHE) < 0) { lib_cache_count = -1; return NULL; } snprintf(soname, soname_len + 1, "lib%s.so", libname); for (i = 0; i < lib_cache_count; ++i) { if (!strncmp(lib_cache[i].libname, soname, soname_len) && match_so_flags(lib_cache[i].flags)) { return strdup(lib_cache[i].path); } } return NULL; } void bcc_procutils_free(const char *ptr) { free((void *)ptr); } bpfcc-0.2.0+git0.02884a026/src/cc/bcc_proc.h000066400000000000000000000023501305314114400175750ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef LIBBCC_PROC_H #define LIBBCC_PROC_H #include "bcc_syms.h" #ifdef __cplusplus extern "C" { #endif #include typedef int (*bcc_procutils_modulecb)(const char *, uint64_t, uint64_t, void *); typedef void (*bcc_procutils_ksymcb)(const char *, uint64_t, void *); char *bcc_procutils_which_so(const char *libname, int pid); char *bcc_procutils_which(const char *binpath); int bcc_procutils_each_module(int pid, bcc_procutils_modulecb callback, void *payload); int bcc_procutils_each_ksym(bcc_procutils_ksymcb callback, void *payload); void bcc_procutils_free(const char *ptr); #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/bcc_syms.cc000066400000000000000000000206141305314114400177660ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include "bcc_elf.h" #include "bcc_perf_map.h" #include "bcc_proc.h" #include "bcc_syms.h" #include "syms.h" #include "vendor/tinyformat.hpp" ino_t ProcStat::getinode_() { struct stat s; return (!stat(procfs_.c_str(), &s)) ? s.st_ino : -1; } ProcStat::ProcStat(int pid) : procfs_(tfm::format("/proc/%d/exe", pid)), inode_(getinode_()) {} void KSyms::_add_symbol(const char *symname, uint64_t addr, void *p) { KSyms *ks = static_cast(p); ks->syms_.emplace_back(symname, addr); } void KSyms::refresh() { if (syms_.empty()) { bcc_procutils_each_ksym(_add_symbol, this); std::sort(syms_.begin(), syms_.end()); } } bool KSyms::resolve_addr(uint64_t addr, struct bcc_symbol *sym) { refresh(); if (syms_.empty()) { sym->name = nullptr; sym->demangle_name = nullptr; sym->module = nullptr; sym->offset = 0x0; return false; } auto it = std::upper_bound(syms_.begin(), syms_.end(), Symbol("", addr)) - 1; sym->name = (*it).name.c_str(); sym->demangle_name = sym->name; sym->module = "kernel"; sym->offset = addr - (*it).addr; return true; } bool KSyms::resolve_name(const char *_unused, const char *name, uint64_t *addr) { refresh(); if (syms_.size() != symnames_.size()) { symnames_.clear(); for (Symbol &sym : syms_) { symnames_[sym.name] = sym.addr; } } auto it = symnames_.find(name); if (it == symnames_.end()) return false; *addr = it->second; return true; } ProcSyms::ProcSyms(int pid) : pid_(pid), procstat_(pid) { load_modules(); } bool ProcSyms::load_modules() { return bcc_procutils_each_module(pid_, _add_module, this) == 0; } void ProcSyms::refresh() { modules_.clear(); load_modules(); procstat_.reset(); } int ProcSyms::_add_module(const char *modname, uint64_t start, uint64_t end, void *payload) { ProcSyms *ps = static_cast(payload); ps->modules_.emplace_back(modname, start, end); return 0; } bool ProcSyms::resolve_addr(uint64_t addr, struct bcc_symbol *sym) { if (procstat_.is_stale()) refresh(); sym->module = nullptr; sym->name = nullptr; sym->demangle_name = nullptr; sym->offset = 0x0; for (Module &mod : modules_) { if (addr >= mod.start_ && addr < mod.end_) { bool res = mod.find_addr(addr, sym); if (sym->name) { sym->demangle_name = abi::__cxa_demangle(sym->name, nullptr, nullptr, nullptr); if (!sym->demangle_name) sym->demangle_name = sym->name; } return res; } } return false; } bool ProcSyms::resolve_name(const char *module, const char *name, uint64_t *addr) { if (procstat_.is_stale()) refresh(); for (Module &mod : modules_) { if (mod.name_ == module) return mod.find_name(name, addr); } return false; } ProcSyms::Module::Module(const char *name, uint64_t start, uint64_t end) : name_(name), start_(start), end_(end) { is_so_ = bcc_elf_is_shared_obj(name) == 1; } int ProcSyms::Module::_add_symbol(const char *symname, uint64_t start, uint64_t end, int flags, void *p) { Module *m = static_cast(p); auto res = m->symnames_.emplace(symname); m->syms_.emplace_back(&*(res.first), start, end, flags); return 0; } bool ProcSyms::Module::is_perf_map() const { return strstr(name_.c_str(), ".map") != nullptr; } void ProcSyms::Module::load_sym_table() { if (syms_.size()) return; if (is_perf_map()) bcc_perf_map_foreach_sym(name_.c_str(), _add_symbol, this); else bcc_elf_foreach_sym(name_.c_str(), _add_symbol, this); std::sort(syms_.begin(), syms_.end()); } bool ProcSyms::Module::find_name(const char *symname, uint64_t *addr) { load_sym_table(); for (Symbol &s : syms_) { if (*(s.name) == symname) { *addr = is_so() ? start_ + s.start : s.start; return true; } } return false; } bool ProcSyms::Module::find_addr(uint64_t addr, struct bcc_symbol *sym) { uint64_t offset = is_so() ? (addr - start_) : addr; load_sym_table(); sym->module = name_.c_str(); sym->offset = offset; auto it = std::upper_bound(syms_.begin(), syms_.end(), Symbol(nullptr, offset, 0)); if (it != syms_.begin()) --it; else it = syms_.end(); if (it != syms_.end() && offset >= it->start && offset < it->start + it->size) { sym->name = it->name->c_str(); sym->offset = (offset - it->start); return true; } return false; } extern "C" { void *bcc_symcache_new(int pid) { if (pid < 0) return static_cast(new KSyms()); return static_cast(new ProcSyms(pid)); } void bcc_free_symcache(void *symcache, int pid) { if (pid < 0) delete static_cast(symcache); else delete static_cast(symcache); } int bcc_symcache_resolve(void *resolver, uint64_t addr, struct bcc_symbol *sym) { SymbolCache *cache = static_cast(resolver); return cache->resolve_addr(addr, sym) ? 0 : -1; } int bcc_symcache_resolve_name(void *resolver, const char *module, const char *name, uint64_t *addr) { SymbolCache *cache = static_cast(resolver); return cache->resolve_name(module, name, addr) ? 0 : -1; } void bcc_symcache_refresh(void *resolver) { SymbolCache *cache = static_cast(resolver); cache->refresh(); } struct mod_st { const char *name; uint64_t start; }; static int _find_module(const char *modname, uint64_t start, uint64_t end, void *p) { struct mod_st *mod = (struct mod_st *)p; if (!strcmp(modname, mod->name)) { mod->start = start; return -1; } return 0; } int bcc_resolve_global_addr(int pid, const char *module, const uint64_t address, uint64_t *global) { struct mod_st mod = {module, 0x0}; if (bcc_procutils_each_module(pid, _find_module, &mod) < 0 || mod.start == 0x0) return -1; *global = mod.start + address; return 0; } static int _find_sym(const char *symname, uint64_t addr, uint64_t end, int flags, void *payload) { struct bcc_symbol *sym = (struct bcc_symbol *)payload; // TODO: check for actual function symbol in flags if (!strcmp(sym->name, symname)) { sym->offset = addr; return -1; } return 0; } int bcc_find_symbol_addr(struct bcc_symbol *sym) { return bcc_elf_foreach_sym(sym->module, _find_sym, sym); } struct sym_search_t { struct bcc_symbol *syms; int start; int requested; int *actual; }; // see #define ELF_TYPE_IS_FUNCTION(flags) (((flags) & 0xf) == 2) static int _list_sym(const char *symname, uint64_t addr, uint64_t end, int flags, void *payload) { if (!ELF_TYPE_IS_FUNCTION(flags) || addr == 0) return 0; SYM_CB cb = (SYM_CB) payload; return cb(symname, addr); } int bcc_foreach_symbol(const char *module, SYM_CB cb) { if (module == 0 || cb == 0) return -1; return bcc_elf_foreach_sym(module, _list_sym, (void *)cb); } int bcc_resolve_symname(const char *module, const char *symname, const uint64_t addr, int pid, struct bcc_symbol *sym) { uint64_t load_addr; sym->module = NULL; sym->name = NULL; sym->offset = 0x0; if (module == NULL) return -1; if (strchr(module, '/')) { sym->module = strdup(module); } else { sym->module = bcc_procutils_which_so(module, pid); } if (sym->module == NULL) return -1; if (bcc_elf_loadaddr(sym->module, &load_addr) < 0) { sym->module = NULL; return -1; } sym->name = symname; sym->offset = addr; if (sym->name && sym->offset == 0x0) { if (bcc_find_symbol_addr(sym) < 0) return -1; } if (sym->offset == 0x0) return -1; sym->offset = (sym->offset - load_addr); return 0; } } bpfcc-0.2.0+git0.02884a026/src/cc/bcc_syms.h000066400000000000000000000031331305314114400176250ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef LIBBCC_SYMS_H #define LIBBCC_SYMS_H #ifdef __cplusplus extern "C" { #endif #include struct bcc_symbol { const char *name; const char *demangle_name; const char *module; uint64_t offset; }; typedef int(* SYM_CB)(const char *symname, uint64_t addr); void *bcc_symcache_new(int pid); void bcc_free_symcache(void *symcache, int pid); int bcc_symcache_resolve(void *symcache, uint64_t addr, struct bcc_symbol *sym); int bcc_symcache_resolve_name(void *resolver, const char *module, const char *name, uint64_t *addr); void bcc_symcache_refresh(void *resolver); int bcc_resolve_global_addr(int pid, const char *module, const uint64_t address, uint64_t *global); int bcc_foreach_symbol(const char *module, SYM_CB cb); int bcc_find_symbol_addr(struct bcc_symbol *sym); int bcc_resolve_symname(const char *module, const char *symname, const uint64_t addr, int pid, struct bcc_symbol *sym); #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/bcc_usdt.h000066400000000000000000000045771305314114400176260ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef LIBBCC_USDT_H #define LIBBCC_USDT_H #ifdef __cplusplus extern "C" { #endif #include void *bcc_usdt_new_frompid(int pid); void *bcc_usdt_new_frompath(const char *path); void bcc_usdt_close(void *usdt); struct bcc_usdt { const char *provider; const char *name; const char *bin_path; uint64_t semaphore; int num_locations; int num_arguments; }; struct bcc_usdt_location { uint64_t address; }; #define BCC_USDT_ARGUMENT_NONE 0x0 #define BCC_USDT_ARGUMENT_CONSTANT 0x1 #define BCC_USDT_ARGUMENT_DEREF_OFFSET 0x2 #define BCC_USDT_ARGUMENT_DEREF_IDENT 0x4 #define BCC_USDT_ARGUMENT_BASE_REGISTER_NAME 0x8 #define BCC_USDT_ARGUMENT_INDEX_REGISTER_NAME 0x10 #define BCC_USDT_ARGUMENT_SCALE 0x20 struct bcc_usdt_argument { int size; int valid; int constant; int deref_offset; const char *deref_ident; const char *base_register_name; const char *index_register_name; int scale; }; typedef void (*bcc_usdt_cb)(struct bcc_usdt *); void bcc_usdt_foreach(void *usdt, bcc_usdt_cb callback); int bcc_usdt_get_location(void *usdt, const char *probe_name, int index, struct bcc_usdt_location *location); int bcc_usdt_get_argument(void *usdt, const char *probe_name, int location_index, int argument_index, struct bcc_usdt_argument *argument); int bcc_usdt_enable_probe(void *, const char *, const char *); const char *bcc_usdt_genargs(void *); const char *bcc_usdt_get_probe_argctype( void *ctx, const char* probe_name, const int arg_index ); typedef void (*bcc_usdt_uprobe_cb)(const char *, const char *, uint64_t, int); void bcc_usdt_foreach_uprobe(void *usdt, bcc_usdt_uprobe_cb callback); #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/bpf_common.cc000066400000000000000000000157471305314114400203160ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "bpf_common.h" #include "bpf_module.h" extern "C" { void * bpf_module_create_b(const char *filename, const char *proto_filename, unsigned flags) { auto mod = new ebpf::BPFModule(flags); if (mod->load_b(filename, proto_filename) != 0) { delete mod; return nullptr; } return mod; } void * bpf_module_create_c(const char *filename, unsigned flags, const char *cflags[], int ncflags) { auto mod = new ebpf::BPFModule(flags); if (mod->load_c(filename, cflags, ncflags) != 0) { delete mod; return nullptr; } return mod; } void * bpf_module_create_c_from_string(const char *text, unsigned flags, const char *cflags[], int ncflags) { auto mod = new ebpf::BPFModule(flags); if (mod->load_string(text, cflags, ncflags) != 0) { delete mod; return nullptr; } return mod; } void bpf_module_destroy(void *program) { auto mod = static_cast(program); if (!mod) return; delete mod; } size_t bpf_num_functions(void *program) { auto mod = static_cast(program); if (!mod) return 0; return mod->num_functions(); } const char * bpf_function_name(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->function_name(id); } void * bpf_function_start(void *program, const char *name) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->function_start(name); } void * bpf_function_start_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->function_start(id); } size_t bpf_function_size(void *program, const char *name) { auto mod = static_cast(program); if (!mod) return 0; return mod->function_size(name); } size_t bpf_function_size_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return 0; return mod->function_size(id); } char * bpf_module_license(void *program) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->license(); } unsigned bpf_module_kern_version(void *program) { auto mod = static_cast(program); if (!mod) return 0; return mod->kern_version(); } size_t bpf_num_tables(void *program) { auto mod = static_cast(program); if (!mod) return -1; return mod->num_tables(); } size_t bpf_table_id(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return ~0ull; return mod->table_id(table_name); } int bpf_table_fd(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_fd(table_name); } int bpf_table_fd_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_fd(id); } int bpf_table_type(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_type(table_name); } int bpf_table_type_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_type(id); } size_t bpf_table_max_entries(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return 0; return mod->table_max_entries(table_name); } size_t bpf_table_max_entries_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return 0; return mod->table_max_entries(id); } int bpf_table_flags(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_flags(table_name); } int bpf_table_flags_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_flags(id); } const char * bpf_table_name(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->table_name(id); } const char * bpf_table_key_desc(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->table_key_desc(table_name); } const char * bpf_table_key_desc_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->table_key_desc(id); } const char * bpf_table_leaf_desc(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->table_leaf_desc(table_name); } const char * bpf_table_leaf_desc_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return nullptr; return mod->table_leaf_desc(id); } size_t bpf_table_key_size(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return 0; return mod->table_key_size(table_name); } size_t bpf_table_key_size_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return 0; return mod->table_key_size(id); } size_t bpf_table_leaf_size(void *program, const char *table_name) { auto mod = static_cast(program); if (!mod) return 0; return mod->table_leaf_size(table_name); } size_t bpf_table_leaf_size_id(void *program, size_t id) { auto mod = static_cast(program); if (!mod) return 0; return mod->table_leaf_size(id); } int bpf_table_key_snprintf(void *program, size_t id, char *buf, size_t buflen, const void *key) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_key_printf(id, buf, buflen, key); } int bpf_table_leaf_snprintf(void *program, size_t id, char *buf, size_t buflen, const void *leaf) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_leaf_printf(id, buf, buflen, leaf); } int bpf_table_key_sscanf(void *program, size_t id, const char *buf, void *key) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_key_scanf(id, buf, key); } int bpf_table_leaf_sscanf(void *program, size_t id, const char *buf, void *leaf) { auto mod = static_cast(program); if (!mod) return -1; return mod->table_leaf_scanf(id, buf, leaf); } } bpfcc-0.2.0+git0.02884a026/src/cc/bpf_common.h000066400000000000000000000056711305314114400201530ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef BPF_COMMON_H #define BPF_COMMON_H #include #include #ifdef __cplusplus extern "C" { #endif void * bpf_module_create_b(const char *filename, const char *proto_filename, unsigned flags); void * bpf_module_create_c(const char *filename, unsigned flags, const char *cflags[], int ncflags); void * bpf_module_create_c_from_string(const char *text, unsigned flags, const char *cflags[], int ncflags); void bpf_module_destroy(void *program); char * bpf_module_license(void *program); unsigned bpf_module_kern_version(void *program); size_t bpf_num_functions(void *program); const char * bpf_function_name(void *program, size_t id); void * bpf_function_start_id(void *program, size_t id); void * bpf_function_start(void *program, const char *name); size_t bpf_function_size_id(void *program, size_t id); size_t bpf_function_size(void *program, const char *name); size_t bpf_num_tables(void *program); size_t bpf_table_id(void *program, const char *table_name); int bpf_table_fd(void *program, const char *table_name); int bpf_table_fd_id(void *program, size_t id); int bpf_table_type(void *program, const char *table_name); int bpf_table_type_id(void *program, size_t id); size_t bpf_table_max_entries(void *program, const char *table_name); size_t bpf_table_max_entries_id(void *program, size_t id); int bpf_table_flags(void *program, const char *table_name); int bpf_table_flags_id(void *program, size_t id); const char * bpf_table_name(void *program, size_t id); const char * bpf_table_key_desc(void *program, const char *table_name); const char * bpf_table_key_desc_id(void *program, size_t id); const char * bpf_table_leaf_desc(void *program, const char *table_name); const char * bpf_table_leaf_desc_id(void *program, size_t id); size_t bpf_table_key_size(void *program, const char *table_name); size_t bpf_table_key_size_id(void *program, size_t id); size_t bpf_table_leaf_size(void *program, const char *table_name); size_t bpf_table_leaf_size_id(void *program, size_t id); int bpf_table_key_snprintf(void *program, size_t id, char *buf, size_t buflen, const void *key); int bpf_table_leaf_snprintf(void *program, size_t id, char *buf, size_t buflen, const void *leaf); int bpf_table_key_sscanf(void *program, size_t id, const char *buf, void *key); int bpf_table_leaf_sscanf(void *program, size_t id, const char *buf, void *leaf); #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/bpf_module.cc000066400000000000000000000551731305314114400203100ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "bcc_exception.h" #include "frontends/b/loader.h" #include "frontends/clang/loader.h" #include "frontends/clang/b_frontend_action.h" #include "bpf_module.h" #include "exported_files.h" #include "kbuild_helper.h" #include "shared_table.h" #include "libbpf.h" namespace ebpf { using std::get; using std::make_tuple; using std::map; using std::move; using std::string; using std::tuple; using std::unique_ptr; using std::vector; using namespace llvm; typedef int (* sscanf_fn) (const char *, void *); typedef int (* snprintf_fn) (char *, size_t, const void *); const string BPFModule::FN_PREFIX = BPF_FN_PREFIX; // Snooping class to remember the sections as the JIT creates them class MyMemoryManager : public SectionMemoryManager { public: explicit MyMemoryManager(map> *sections) : sections_(sections) { } virtual ~MyMemoryManager() {} uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName) override { uint8_t *Addr = SectionMemoryManager::allocateCodeSection(Size, Alignment, SectionID, SectionName); //printf("allocateCodeSection: %s Addr %p Size %ld Alignment %d SectionID %d\n", // SectionName.str().c_str(), (void *)Addr, Size, Alignment, SectionID); (*sections_)[SectionName.str()] = make_tuple(Addr, Size); return Addr; } uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName, bool isReadOnly) override { uint8_t *Addr = SectionMemoryManager::allocateDataSection(Size, Alignment, SectionID, SectionName, isReadOnly); //printf("allocateDataSection: %s Addr %p Size %ld Alignment %d SectionID %d RO %d\n", // SectionName.str().c_str(), (void *)Addr, Size, Alignment, SectionID, isReadOnly); (*sections_)[SectionName.str()] = make_tuple(Addr, Size); return Addr; } map> *sections_; }; BPFModule::BPFModule(unsigned flags) : flags_(flags), ctx_(new LLVMContext) { InitializeNativeTarget(); InitializeNativeTargetAsmPrinter(); LLVMInitializeBPFTarget(); LLVMInitializeBPFTargetMC(); LLVMInitializeBPFTargetInfo(); LLVMInitializeBPFAsmPrinter(); LLVMLinkInMCJIT(); /* call empty function to force linking of MCJIT */ } BPFModule::~BPFModule() { engine_.reset(); rw_engine_.reset(); ctx_.reset(); if (tables_) { for (auto table : *tables_) { if (table.is_shared) { SharedTables::instance()->remove_fd(table.name); } else if (!table.is_extern) { close(table.fd); } } } } static void debug_printf(Module *mod, IRBuilder<> &B, const string &fmt, vector args) { GlobalVariable *fmt_gvar = B.CreateGlobalString(fmt, "fmt"); args.insert(args.begin(), B.CreateInBoundsGEP(fmt_gvar, vector({B.getInt64(0), B.getInt64(0)}))); args.insert(args.begin(), B.getInt64((uintptr_t)stderr)); Function *fprintf_fn = mod->getFunction("fprintf"); if (!fprintf_fn) { vector fprintf_fn_args({B.getInt64Ty(), B.getInt8PtrTy()}); FunctionType *fprintf_fn_type = FunctionType::get(B.getInt32Ty(), fprintf_fn_args, /*isvarArg=*/true); fprintf_fn = Function::Create(fprintf_fn_type, GlobalValue::ExternalLinkage, "fprintf", mod); fprintf_fn->setCallingConv(CallingConv::C); fprintf_fn->addFnAttr(Attribute::NoUnwind); } B.CreateCall(fprintf_fn, args); } // recursive helper to capture the arguments static void parse_type(IRBuilder<> &B, vector *args, string *fmt, Type *type, Value *out, bool is_writer) { if (StructType *st = dyn_cast(type)) { *fmt += "{ "; unsigned idx = 0; for (auto field : st->elements()) { parse_type(B, args, fmt, field, B.CreateStructGEP(type, out, idx++), is_writer); *fmt += " "; } *fmt += "}"; } else if (ArrayType *at = dyn_cast(type)) { *fmt += "[ "; for (size_t i = 0; i < at->getNumElements(); ++i) { parse_type(B, args, fmt, at->getElementType(), B.CreateStructGEP(type, out, i), is_writer); *fmt += " "; } *fmt += "]"; } else if (isa(type)) { *fmt += "0xl"; if (is_writer) *fmt += "x"; else *fmt += "i"; } else if (IntegerType *it = dyn_cast(type)) { if (is_writer) *fmt += "0x"; if (it->getBitWidth() <= 8) *fmt += "%hh"; else if (it->getBitWidth() <= 16) *fmt += "%h"; else if (it->getBitWidth() <= 32) *fmt += "%"; else *fmt += "%l"; if (is_writer) *fmt += "x"; else *fmt += "i"; args->push_back(is_writer ? B.CreateLoad(out) : out); } } Function * BPFModule::make_reader(Module *mod, Type *type) { auto fn_it = readers_.find(type); if (fn_it != readers_.end()) return fn_it->second; // int read(const char *in, Type *out) { // int n = sscanf(in, "{ %i ... }", &out->field1, ...); // if (n != num_fields) return -1; // return 0; // } IRBuilder<> B(*ctx_); vector fn_args({B.getInt8PtrTy(), PointerType::getUnqual(type)}); FunctionType *fn_type = FunctionType::get(B.getInt32Ty(), fn_args, /*isVarArg=*/false); Function *fn = Function::Create(fn_type, GlobalValue::ExternalLinkage, "reader" + std::to_string(readers_.size()), mod); auto arg_it = fn->arg_begin(); Argument *arg_in = &*arg_it; ++arg_it; arg_in->setName("in"); Argument *arg_out = &*arg_it; ++arg_it; arg_out->setName("out"); BasicBlock *label_entry = BasicBlock::Create(*ctx_, "entry", fn); BasicBlock *label_exit = BasicBlock::Create(*ctx_, "exit", fn); B.SetInsertPoint(label_entry); vector args({arg_in, nullptr}); string fmt; parse_type(B, &args, &fmt, type, arg_out, false); GlobalVariable *fmt_gvar = B.CreateGlobalString(fmt, "fmt"); args[1] = B.CreateInBoundsGEP(fmt_gvar, vector({B.getInt64(0), B.getInt64(0)})); if (0) debug_printf(mod, B, "%p %p\n", vector({arg_in, arg_out})); vector sscanf_fn_args({B.getInt8PtrTy(), B.getInt8PtrTy()}); FunctionType *sscanf_fn_type = FunctionType::get(B.getInt32Ty(), sscanf_fn_args, /*isVarArg=*/true); Function *sscanf_fn = mod->getFunction("sscanf"); if (!sscanf_fn) sscanf_fn = Function::Create(sscanf_fn_type, GlobalValue::ExternalLinkage, "sscanf", mod); sscanf_fn->setCallingConv(CallingConv::C); sscanf_fn->addFnAttr(Attribute::NoUnwind); CallInst *call = B.CreateCall(sscanf_fn, args); call->setTailCall(true); BasicBlock *label_then = BasicBlock::Create(*ctx_, "then", fn); Value *is_neq = B.CreateICmpNE(call, B.getInt32(args.size() - 2)); B.CreateCondBr(is_neq, label_then, label_exit); B.SetInsertPoint(label_then); B.CreateRet(B.getInt32(-1)); B.SetInsertPoint(label_exit); B.CreateRet(B.getInt32(0)); readers_[type] = fn; return fn; } Function * BPFModule::make_writer(Module *mod, Type *type) { auto fn_it = writers_.find(type); if (fn_it != writers_.end()) return fn_it->second; // int write(int len, char *out, Type *in) { // return snprintf(out, len, "{ %i ... }", out->field1, ...); // } IRBuilder<> B(*ctx_); vector fn_args({B.getInt8PtrTy(), B.getInt64Ty(), PointerType::getUnqual(type)}); FunctionType *fn_type = FunctionType::get(B.getInt32Ty(), fn_args, /*isVarArg=*/false); Function *fn = Function::Create(fn_type, GlobalValue::ExternalLinkage, "writer" + std::to_string(writers_.size()), mod); auto arg_it = fn->arg_begin(); Argument *arg_out = &*arg_it; ++arg_it; arg_out->setName("out"); Argument *arg_len = &*arg_it; ++arg_it; arg_len->setName("len"); Argument *arg_in = &*arg_it; ++arg_it; arg_in->setName("in"); BasicBlock *label_entry = BasicBlock::Create(*ctx_, "entry", fn); B.SetInsertPoint(label_entry); vector args({arg_out, B.CreateZExt(arg_len, B.getInt64Ty()), nullptr}); string fmt; parse_type(B, &args, &fmt, type, arg_in, true); GlobalVariable *fmt_gvar = B.CreateGlobalString(fmt, "fmt"); args[2] = B.CreateInBoundsGEP(fmt_gvar, vector({B.getInt64(0), B.getInt64(0)})); if (0) debug_printf(mod, B, "%d %p %p\n", vector({arg_len, arg_out, arg_in})); vector snprintf_fn_args({B.getInt8PtrTy(), B.getInt64Ty(), B.getInt8PtrTy()}); FunctionType *snprintf_fn_type = FunctionType::get(B.getInt32Ty(), snprintf_fn_args, /*isVarArg=*/true); Function *snprintf_fn = mod->getFunction("snprintf"); if (!snprintf_fn) snprintf_fn = Function::Create(snprintf_fn_type, GlobalValue::ExternalLinkage, "snprintf", mod); snprintf_fn->setCallingConv(CallingConv::C); snprintf_fn->addFnAttr(Attribute::NoUnwind); CallInst *call = B.CreateCall(snprintf_fn, args); call->setTailCall(true); B.CreateRet(call); writers_[type] = fn; return fn; } unique_ptr BPFModule::finalize_rw(unique_ptr m) { Module *mod = &*m; run_pass_manager(*mod); string err; EngineBuilder builder(move(m)); builder.setErrorStr(&err); builder.setUseOrcMCJITReplacement(true); auto engine = unique_ptr(builder.create()); if (!engine) fprintf(stderr, "Could not create ExecutionEngine: %s\n", err.c_str()); return engine; } // load an entire c file as a module int BPFModule::load_cfile(const string &file, bool in_memory, const char *cflags[], int ncflags) { clang_loader_ = make_unique(&*ctx_, flags_); if (clang_loader_->parse(&mod_, &tables_, file, in_memory, cflags, ncflags)) return -1; return 0; } // NOTE: this is a duplicate of the above, but planning to deprecate if we // settle on clang as the frontend // Load in a pre-built list of functions into the initial Module object, then // build an ExecutionEngine. int BPFModule::load_includes(const string &text) { clang_loader_ = make_unique(&*ctx_, flags_); if (clang_loader_->parse(&mod_, &tables_, text, true, nullptr, 0)) return -1; return 0; } int BPFModule::annotate() { for (auto fn = mod_->getFunctionList().begin(); fn != mod_->getFunctionList().end(); ++fn) if (!fn->hasFnAttribute(Attribute::NoInline)) fn->addFnAttr(Attribute::AlwaysInline); // separate module to hold the reader functions auto m = make_unique("sscanf", *ctx_); size_t id = 0; for (auto &table : *tables_) { table_names_[table.name] = id++; GlobalValue *gvar = mod_->getNamedValue(table.name); if (!gvar) continue; if (PointerType *pt = dyn_cast(gvar->getType())) { if (StructType *st = dyn_cast(pt->getElementType())) { if (st->getNumElements() < 2) continue; Type *key_type = st->elements()[0]; Type *leaf_type = st->elements()[1]; table.key_sscanf = make_reader(&*m, key_type); if (!table.key_sscanf) errs() << "Failed to compile sscanf for " << *key_type << "\n"; table.leaf_sscanf = make_reader(&*m, leaf_type); if (!table.leaf_sscanf) errs() << "Failed to compile sscanf for " << *leaf_type << "\n"; table.key_snprintf = make_writer(&*m, key_type); if (!table.key_snprintf) errs() << "Failed to compile snprintf for " << *key_type << "\n"; table.leaf_snprintf = make_writer(&*m, leaf_type); if (!table.leaf_snprintf) errs() << "Failed to compile snprintf for " << *leaf_type << "\n"; } } } rw_engine_ = finalize_rw(move(m)); if (rw_engine_) rw_engine_->finalizeObject(); return 0; } void BPFModule::dump_ir(Module &mod) { legacy::PassManager PM; PM.add(createPrintModulePass(errs())); PM.run(mod); } int BPFModule::run_pass_manager(Module &mod) { if (verifyModule(mod, &errs())) { if (flags_ & 1) dump_ir(mod); return -1; } legacy::PassManager PM; PassManagerBuilder PMB; PMB.OptLevel = 3; PM.add(createFunctionInliningPass()); /* * llvm < 4.0 needs * PM.add(createAlwaysInlinerPass()); * llvm >= 4.0 needs * PM.add(createAlwaysInlinerLegacyPass()); * use below 'stable' workaround */ LLVMAddAlwaysInlinerPass(reinterpret_cast(&PM)); PMB.populateModulePassManager(PM); if (flags_ & 1) PM.add(createPrintModulePass(outs())); PM.run(mod); return 0; } int BPFModule::finalize() { Module *mod = &*mod_; mod->setDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128"); mod->setTargetTriple("bpf-pc-linux"); string err; EngineBuilder builder(move(mod_)); builder.setErrorStr(&err); builder.setMCJITMemoryManager(make_unique(§ions_)); builder.setMArch("bpf"); builder.setUseOrcMCJITReplacement(true); engine_ = unique_ptr(builder.create()); if (!engine_) { fprintf(stderr, "Could not create ExecutionEngine: %s\n", err.c_str()); return -1; } if (int rc = run_pass_manager(*mod)) return rc; engine_->finalizeObject(); // give functions an id for (auto section : sections_) if (!strncmp(FN_PREFIX.c_str(), section.first.c_str(), FN_PREFIX.size())) function_names_.push_back(section.first); return 0; } size_t BPFModule::num_functions() const { return function_names_.size(); } const char * BPFModule::function_name(size_t id) const { if (id >= function_names_.size()) return nullptr; return function_names_[id].c_str() + FN_PREFIX.size(); } uint8_t * BPFModule::function_start(size_t id) const { if (id >= function_names_.size()) return nullptr; auto section = sections_.find(function_names_[id]); if (section == sections_.end()) return nullptr; return get<0>(section->second); } uint8_t * BPFModule::function_start(const string &name) const { auto section = sections_.find(FN_PREFIX + name); if (section == sections_.end()) return nullptr; return get<0>(section->second); } size_t BPFModule::function_size(size_t id) const { if (id >= function_names_.size()) return 0; auto section = sections_.find(function_names_[id]); if (section == sections_.end()) return 0; return get<1>(section->second); } size_t BPFModule::function_size(const string &name) const { auto section = sections_.find(FN_PREFIX + name); if (section == sections_.end()) return 0; return get<1>(section->second); } char * BPFModule::license() const { auto section = sections_.find("license"); if (section == sections_.end()) return nullptr; return (char *)get<0>(section->second); } unsigned BPFModule::kern_version() const { auto section = sections_.find("version"); if (section == sections_.end()) return 0; return *(unsigned *)get<0>(section->second); } size_t BPFModule::num_tables() const { return tables_->size(); } size_t BPFModule::table_id(const string &name) const { auto it = table_names_.find(name); if (it == table_names_.end()) return ~0ull; return it->second; } int BPFModule::table_fd(const string &name) const { return table_fd(table_id(name)); } int BPFModule::table_fd(size_t id) const { if (id >= tables_->size()) return -1; return (*tables_)[id].fd; } int BPFModule::table_type(const string &name) const { return table_type(table_id(name)); } int BPFModule::table_type(size_t id) const { if (id >= tables_->size()) return -1; return (*tables_)[id].type; } size_t BPFModule::table_max_entries(const string &name) const { return table_max_entries(table_id(name)); } size_t BPFModule::table_max_entries(size_t id) const { if (id >= tables_->size()) return 0; return (*tables_)[id].max_entries; } int BPFModule::table_flags(const string &name) const { return table_flags(table_id(name)); } int BPFModule::table_flags(size_t id) const { if (id >= tables_->size()) return -1; return (*tables_)[id].flags; } const char * BPFModule::table_name(size_t id) const { if (id >= tables_->size()) return nullptr; return (*tables_)[id].name.c_str(); } const char * BPFModule::table_key_desc(size_t id) const { if (b_loader_) return nullptr; if (id >= tables_->size()) return nullptr; return (*tables_)[id].key_desc.c_str(); } const char * BPFModule::table_key_desc(const string &name) const { return table_key_desc(table_id(name)); } const char * BPFModule::table_leaf_desc(size_t id) const { if (b_loader_) return nullptr; if (id >= tables_->size()) return nullptr; return (*tables_)[id].leaf_desc.c_str(); } const char * BPFModule::table_leaf_desc(const string &name) const { return table_leaf_desc(table_id(name)); } size_t BPFModule::table_key_size(size_t id) const { if (id >= tables_->size()) return 0; return (*tables_)[id].key_size; } size_t BPFModule::table_key_size(const string &name) const { return table_key_size(table_id(name)); } size_t BPFModule::table_leaf_size(size_t id) const { if (id >= tables_->size()) return 0; return (*tables_)[id].leaf_size; } size_t BPFModule::table_leaf_size(const string &name) const { return table_leaf_size(table_id(name)); } struct TableIterator { TableIterator(size_t key_size, size_t leaf_size) : key(new uint8_t[key_size]), leaf(new uint8_t[leaf_size]) { } unique_ptr key; unique_ptr leaf; uint8_t keyb[512]; }; int BPFModule::table_key_printf(size_t id, char *buf, size_t buflen, const void *key) { if (id >= tables_->size()) return -1; const TableDesc &desc = (*tables_)[id]; if (!desc.key_snprintf) { fprintf(stderr, "Key snprintf not available\n"); return -1; } snprintf_fn fn = (snprintf_fn)rw_engine_->getPointerToFunction(desc.key_snprintf); if (!fn) { fprintf(stderr, "Key snprintf not available in JIT Engine\n"); return -1; } int rc = (*fn)(buf, buflen, key); if (rc < 0) { perror("snprintf"); return -1; } if ((size_t)rc >= buflen) { fprintf(stderr, "snprintf ran out of buffer space\n"); return -1; } return 0; } int BPFModule::table_leaf_printf(size_t id, char *buf, size_t buflen, const void *leaf) { if (id >= tables_->size()) return -1; const TableDesc &desc = (*tables_)[id]; if (!desc.leaf_snprintf) { fprintf(stderr, "Key snprintf not available\n"); return -1; } snprintf_fn fn = (snprintf_fn)rw_engine_->getPointerToFunction(desc.leaf_snprintf); if (!fn) { fprintf(stderr, "Leaf snprintf not available in JIT Engine\n"); return -1; } int rc = (*fn)(buf, buflen, leaf); if (rc < 0) { perror("snprintf"); return -1; } if ((size_t)rc >= buflen) { fprintf(stderr, "snprintf ran out of buffer space\n"); return -1; } return 0; } int BPFModule::table_key_scanf(size_t id, const char *key_str, void *key) { if (id >= tables_->size()) return -1; const TableDesc &desc = (*tables_)[id]; if (!desc.key_sscanf) { fprintf(stderr, "Key sscanf not available\n"); return -1; } sscanf_fn fn = (sscanf_fn)rw_engine_->getPointerToFunction(desc.key_sscanf); if (!fn) { fprintf(stderr, "Key sscanf not available in JIT Engine\n"); return -1; } int rc = (*fn)(key_str, key); if (rc != 0) { perror("sscanf"); return -1; } return 0; } int BPFModule::table_leaf_scanf(size_t id, const char *leaf_str, void *leaf) { if (id >= tables_->size()) return -1; const TableDesc &desc = (*tables_)[id]; if (!desc.leaf_sscanf) { fprintf(stderr, "Key sscanf not available\n"); return -1; } sscanf_fn fn = (sscanf_fn)rw_engine_->getPointerToFunction(desc.leaf_sscanf); if (!fn) { fprintf(stderr, "Leaf sscanf not available in JIT Engine\n"); return -1; } int rc = (*fn)(leaf_str, leaf); if (rc != 0) { perror("sscanf"); return -1; } return 0; } // load a B file, which comes in two parts int BPFModule::load_b(const string &filename, const string &proto_filename) { if (!sections_.empty()) { fprintf(stderr, "Program already initialized\n"); return -1; } if (filename.empty() || proto_filename.empty()) { fprintf(stderr, "Invalid filenames\n"); return -1; } // Helpers are inlined in the following file (C). Load the definitions and // pass the partially compiled module to the B frontend to continue with. auto helpers_h = ExportedFiles::headers().find("/virtual/include/bcc/helpers.h"); if (helpers_h == ExportedFiles::headers().end()) { fprintf(stderr, "Internal error: missing bcc/helpers.h"); return -1; } if (int rc = load_includes(helpers_h->second)) return rc; b_loader_.reset(new BLoader(flags_)); if (int rc = b_loader_->parse(&*mod_, filename, proto_filename, &tables_)) return rc; if (int rc = annotate()) return rc; if (int rc = finalize()) return rc; return 0; } // load a C file int BPFModule::load_c(const string &filename, const char *cflags[], int ncflags) { if (!sections_.empty()) { fprintf(stderr, "Program already initialized\n"); return -1; } if (filename.empty()) { fprintf(stderr, "Invalid filename\n"); return -1; } if (int rc = load_cfile(filename, false, cflags, ncflags)) return rc; if (int rc = annotate()) return rc; if (int rc = finalize()) return rc; return 0; } // load a C text string int BPFModule::load_string(const string &text, const char *cflags[], int ncflags) { if (!sections_.empty()) { fprintf(stderr, "Program already initialized\n"); return -1; } if (int rc = load_cfile(text, true, cflags, ncflags)) return rc; if (int rc = annotate()) return rc; if (int rc = finalize()) return rc; return 0; } } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/bpf_module.h000066400000000000000000000101261305314114400201370ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include namespace llvm { class ExecutionEngine; class Function; class LLVMContext; class Module; class Type; } namespace ebpf { struct TableDesc; class BLoader; class ClangLoader; class BPFModule { private: static const std::string FN_PREFIX; int init_engine(); int parse(llvm::Module *mod); int finalize(); int annotate(); std::unique_ptr finalize_rw(std::unique_ptr mod); llvm::Function * make_reader(llvm::Module *mod, llvm::Type *type); llvm::Function * make_writer(llvm::Module *mod, llvm::Type *type); void dump_ir(llvm::Module &mod); int load_file_module(std::unique_ptr *mod, const std::string &file, bool in_memory); int load_includes(const std::string &text); int load_cfile(const std::string &file, bool in_memory, const char *cflags[], int ncflags); int kbuild_flags(const char *uname_release, std::vector *cflags); int run_pass_manager(llvm::Module &mod); public: BPFModule(unsigned flags); ~BPFModule(); int load_b(const std::string &filename, const std::string &proto_filename); int load_c(const std::string &filename, const char *cflags[], int ncflags); int load_string(const std::string &text, const char *cflags[], int ncflags); size_t num_functions() const; uint8_t * function_start(size_t id) const; uint8_t * function_start(const std::string &name) const; const char * function_name(size_t id) const; size_t function_size(size_t id) const; size_t function_size(const std::string &name) const; size_t num_tables() const; size_t table_id(const std::string &name) const; int table_fd(size_t id) const; int table_fd(const std::string &name) const; const char * table_name(size_t id) const; int table_type(const std::string &name) const; int table_type(size_t id) const; size_t table_max_entries(const std::string &name) const; size_t table_max_entries(size_t id) const; int table_flags(const std::string &name) const; int table_flags(size_t id) const; const char * table_key_desc(size_t id) const; const char * table_key_desc(const std::string &name) const; size_t table_key_size(size_t id) const; size_t table_key_size(const std::string &name) const; int table_key_printf(size_t id, char *buf, size_t buflen, const void *key); int table_key_scanf(size_t id, const char *buf, void *key); const char * table_leaf_desc(size_t id) const; const char * table_leaf_desc(const std::string &name) const; size_t table_leaf_size(size_t id) const; size_t table_leaf_size(const std::string &name) const; int table_leaf_printf(size_t id, char *buf, size_t buflen, const void *leaf); int table_leaf_scanf(size_t id, const char *buf, void *leaf); char * license() const; unsigned kern_version() const; private: unsigned flags_; // 0x1 for printing std::string filename_; std::string proto_filename_; std::unique_ptr ctx_; std::unique_ptr engine_; std::unique_ptr rw_engine_; std::unique_ptr mod_; std::unique_ptr b_loader_; std::unique_ptr clang_loader_; std::map> sections_; std::unique_ptr> tables_; std::map table_names_; std::vector function_names_; std::map readers_; std::map writers_; }; } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/clang/000077500000000000000000000000001305314114400167365ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/clang/include/000077500000000000000000000000001305314114400203615ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/clang/include/stdarg.h000066400000000000000000000041051305314114400220160ustar00rootroot00000000000000R"********( /*===---- stdarg.h - Variable argument handling ----------------------------=== * * Copyright (c) 2008 Eli Friedman * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. * *===-----------------------------------------------------------------------=== */ #ifndef __STDARG_H #define __STDARG_H #ifndef _VA_LIST typedef __builtin_va_list va_list; #define _VA_LIST #endif #define va_start(ap, param) __builtin_va_start(ap, param) #define va_end(ap) __builtin_va_end(ap) #define va_arg(ap, type) __builtin_va_arg(ap, type) /* GCC always defines __va_copy, but does not define va_copy unless in c99 mode * or -ansi is not specified, since it was not part of C90. */ #define __va_copy(d,s) __builtin_va_copy(d,s) #if __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L || !defined(__STRICT_ANSI__) #define va_copy(dest, src) __builtin_va_copy(dest, src) #endif /* Hack required to make standard headers work, at least on Ubuntu */ #ifndef __GNUC_VA_LIST #define __GNUC_VA_LIST 1 #endif typedef __builtin_va_list __gnuc_va_list; #endif /* __STDARG_H */ )********" bpfcc-0.2.0+git0.02884a026/src/cc/common.cc000066400000000000000000000026721305314114400174600ustar00rootroot00000000000000/* * Copyright (c) 2016 Catalysts GmbH * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "common.h" namespace ebpf { std::vector read_cpu_range(std::string path) { std::ifstream cpus_range_stream { path }; std::vector cpus; std::string cpu_range; while (std::getline(cpus_range_stream, cpu_range, ',')) { std::size_t rangeop = cpu_range.find('-'); if (rangeop == std::string::npos) { cpus.push_back(std::stoi(cpu_range)); } else { int start = std::stoi(cpu_range.substr(0, rangeop)); int end = std::stoi(cpu_range.substr(rangeop + 1)); for (int i = start; i <= end; i++) cpus.push_back(i); } } return cpus; } std::vector get_online_cpus() { return read_cpu_range("/sys/devices/system/cpu/online"); } std::vector get_possible_cpus() { return read_cpu_range("/sys/devices/system/cpu/possible"); } } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/common.h000066400000000000000000000017611305314114400173200ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include namespace ebpf { template typename std::enable_if::value, std::unique_ptr>::type make_unique(Args &&... args) { return std::unique_ptr(new T(std::forward(args)...)); } std::vector get_online_cpus(); std::vector get_possible_cpus(); } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/compat/000077500000000000000000000000001305314114400171355ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/compat/linux/000077500000000000000000000000001305314114400202745ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/compat/linux/bpf.h000066400000000000000000000437651305314114400212330ustar00rootroot00000000000000/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com * * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public * License as published by the Free Software Foundation. */ #ifndef _UAPI__LINUX_BPF_H__ #define _UAPI__LINUX_BPF_H__ #include #include "bpf_common.h" /* Extended instruction set based on top of classic BPF */ /* instruction classes */ #define BPF_ALU64 0x07 /* alu mode in double word width */ /* ld/ldx fields */ #define BPF_DW 0x18 /* double word */ #define BPF_XADD 0xc0 /* exclusive add */ /* alu/jmp fields */ #define BPF_MOV 0xb0 /* mov reg to reg */ #define BPF_ARSH 0xc0 /* sign extending arithmetic shift right */ /* change endianness of a register */ #define BPF_END 0xd0 /* flags for endianness conversion: */ #define BPF_TO_LE 0x00 /* convert to little-endian */ #define BPF_TO_BE 0x08 /* convert to big-endian */ #define BPF_FROM_LE BPF_TO_LE #define BPF_FROM_BE BPF_TO_BE #define BPF_JNE 0x50 /* jump != */ #define BPF_JSGT 0x60 /* SGT is signed '>', GT in x86 */ #define BPF_JSGE 0x70 /* SGE is signed '>=', GE in x86 */ #define BPF_CALL 0x80 /* function call */ #define BPF_EXIT 0x90 /* function return */ /* Register numbers */ enum { BPF_REG_0 = 0, BPF_REG_1, BPF_REG_2, BPF_REG_3, BPF_REG_4, BPF_REG_5, BPF_REG_6, BPF_REG_7, BPF_REG_8, BPF_REG_9, BPF_REG_10, __MAX_BPF_REG, }; /* BPF has 10 general purpose 64-bit registers and stack frame. */ #define MAX_BPF_REG __MAX_BPF_REG struct bpf_insn { __u8 code; /* opcode */ __u8 dst_reg:4; /* dest register */ __u8 src_reg:4; /* source register */ __s16 off; /* signed offset */ __s32 imm; /* signed immediate constant */ }; /* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */ struct bpf_lpm_trie_key { __u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */ __u8 data[0]; /* Arbitrary size */ }; /* BPF syscall commands, see bpf(2) man-page for details. */ enum bpf_cmd { BPF_MAP_CREATE, BPF_MAP_LOOKUP_ELEM, BPF_MAP_UPDATE_ELEM, BPF_MAP_DELETE_ELEM, BPF_MAP_GET_NEXT_KEY, BPF_PROG_LOAD, BPF_OBJ_PIN, BPF_OBJ_GET, BPF_PROG_ATTACH, BPF_PROG_DETACH, }; enum bpf_map_type { BPF_MAP_TYPE_UNSPEC, BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_PROG_ARRAY, BPF_MAP_TYPE_PERF_EVENT_ARRAY, BPF_MAP_TYPE_PERCPU_HASH, BPF_MAP_TYPE_PERCPU_ARRAY, BPF_MAP_TYPE_STACK_TRACE, BPF_MAP_TYPE_CGROUP_ARRAY, BPF_MAP_TYPE_LRU_HASH, BPF_MAP_TYPE_LRU_PERCPU_HASH, BPF_MAP_TYPE_LPM_TRIE, }; enum bpf_prog_type { BPF_PROG_TYPE_UNSPEC, BPF_PROG_TYPE_SOCKET_FILTER, BPF_PROG_TYPE_KPROBE, BPF_PROG_TYPE_SCHED_CLS, BPF_PROG_TYPE_SCHED_ACT, BPF_PROG_TYPE_TRACEPOINT, BPF_PROG_TYPE_XDP, BPF_PROG_TYPE_PERF_EVENT, BPF_PROG_TYPE_CGROUP_SKB, BPF_PROG_TYPE_CGROUP_SOCK, BPF_PROG_TYPE_LWT_IN, BPF_PROG_TYPE_LWT_OUT, BPF_PROG_TYPE_LWT_XMIT, }; enum bpf_attach_type { BPF_CGROUP_INET_INGRESS, BPF_CGROUP_INET_EGRESS, BPF_CGROUP_INET_SOCK_CREATE, __MAX_BPF_ATTACH_TYPE }; #define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE #define BPF_PSEUDO_MAP_FD 1 /* flags for BPF_MAP_UPDATE_ELEM command */ #define BPF_ANY 0 /* create new element or update existing */ #define BPF_NOEXIST 1 /* create new element if it didn't exist */ #define BPF_EXIST 2 /* update existing element */ #define BPF_F_NO_PREALLOC (1U << 0) /* Instead of having one common LRU list in the * BPF_MAP_TYPE_LRU_[PERCPU_]HASH map, use a percpu LRU list * which can scale and perform better. * Note, the LRU nodes (including free nodes) cannot be moved * across different LRU lists. */ #define BPF_F_NO_COMMON_LRU (1U << 1) union bpf_attr { struct { /* anonymous struct used by BPF_MAP_CREATE command */ __u32 map_type; /* one of enum bpf_map_type */ __u32 key_size; /* size of key in bytes */ __u32 value_size; /* size of value in bytes */ __u32 max_entries; /* max number of entries in a map */ __u32 map_flags; /* prealloc or not */ }; struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */ __u32 map_fd; __aligned_u64 key; union { __aligned_u64 value; __aligned_u64 next_key; }; __u64 flags; }; struct { /* anonymous struct used by BPF_PROG_LOAD command */ __u32 prog_type; /* one of enum bpf_prog_type */ __u32 insn_cnt; __aligned_u64 insns; __aligned_u64 license; __u32 log_level; /* verbosity level of verifier */ __u32 log_size; /* size of user buffer */ __aligned_u64 log_buf; /* user supplied buffer */ __u32 kern_version; /* checked when prog_type=kprobe */ }; struct { /* anonymous struct used by BPF_OBJ_* commands */ __aligned_u64 pathname; __u32 bpf_fd; }; struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ __u32 target_fd; /* container object to attach to */ __u32 attach_bpf_fd; /* eBPF program to attach */ __u32 attach_type; }; } __attribute__((aligned(8))); /* BPF helper function descriptions: * * void *bpf_map_lookup_elem(&map, &key) * Return: Map value or NULL * * int bpf_map_update_elem(&map, &key, &value, flags) * Return: 0 on success or negative error * * int bpf_map_delete_elem(&map, &key) * Return: 0 on success or negative error * * int bpf_probe_read(void *dst, int size, void *src) * Return: 0 on success or negative error * * u64 bpf_ktime_get_ns(void) * Return: current ktime * * int bpf_trace_printk(const char *fmt, int fmt_size, ...) * Return: length of buffer written or negative error * * u32 bpf_prandom_u32(void) * Return: random value * * u32 bpf_raw_smp_processor_id(void) * Return: SMP processor ID * * int bpf_skb_store_bytes(skb, offset, from, len, flags) * store bytes into packet * @skb: pointer to skb * @offset: offset within packet from skb->mac_header * @from: pointer where to copy bytes from * @len: number of bytes to store into packet * @flags: bit 0 - if true, recompute skb->csum * other bits - reserved * Return: 0 on success or negative error * * int bpf_l3_csum_replace(skb, offset, from, to, flags) * recompute IP checksum * @skb: pointer to skb * @offset: offset within packet where IP checksum is located * @from: old value of header field * @to: new value of header field * @flags: bits 0-3 - size of header field * other bits - reserved * Return: 0 on success or negative error * * int bpf_l4_csum_replace(skb, offset, from, to, flags) * recompute TCP/UDP checksum * @skb: pointer to skb * @offset: offset within packet where TCP/UDP checksum is located * @from: old value of header field * @to: new value of header field * @flags: bits 0-3 - size of header field * bit 4 - is pseudo header * other bits - reserved * Return: 0 on success or negative error * * int bpf_tail_call(ctx, prog_array_map, index) * jump into another BPF program * @ctx: context pointer passed to next program * @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY * @index: index inside array that selects specific program to run * Return: 0 on success or negative error * * int bpf_clone_redirect(skb, ifindex, flags) * redirect to another netdev * @skb: pointer to skb * @ifindex: ifindex of the net device * @flags: bit 0 - if set, redirect to ingress instead of egress * other bits - reserved * Return: 0 on success or negative error * * u64 bpf_get_current_pid_tgid(void) * Return: current->tgid << 32 | current->pid * * u64 bpf_get_current_uid_gid(void) * Return: current_gid << 32 | current_uid * * int bpf_get_current_comm(char *buf, int size_of_buf) * stores current->comm into buf * Return: 0 on success or negative error * * u32 bpf_get_cgroup_classid(skb) * retrieve a proc's classid * @skb: pointer to skb * Return: classid if != 0 * * int bpf_skb_vlan_push(skb, vlan_proto, vlan_tci) * Return: 0 on success or negative error * * int bpf_skb_vlan_pop(skb) * Return: 0 on success or negative error * * int bpf_skb_get_tunnel_key(skb, key, size, flags) * int bpf_skb_set_tunnel_key(skb, key, size, flags) * retrieve or populate tunnel metadata * @skb: pointer to skb * @key: pointer to 'struct bpf_tunnel_key' * @size: size of 'struct bpf_tunnel_key' * @flags: room for future extensions * Return: 0 on success or negative error * * u64 bpf_perf_event_read(&map, index) * Return: Number events read or error code * * int bpf_redirect(ifindex, flags) * redirect to another netdev * @ifindex: ifindex of the net device * @flags: bit 0 - if set, redirect to ingress instead of egress * other bits - reserved * Return: TC_ACT_REDIRECT * * u32 bpf_get_route_realm(skb) * retrieve a dst's tclassid * @skb: pointer to skb * Return: realm if != 0 * * int bpf_perf_event_output(ctx, map, index, data, size) * output perf raw sample * @ctx: struct pt_regs* * @map: pointer to perf_event_array map * @index: index of event in the map * @data: data on stack to be output as raw data * @size: size of data * Return: 0 on success or negative error * * int bpf_get_stackid(ctx, map, flags) * walk user or kernel stack and return id * @ctx: struct pt_regs* * @map: pointer to stack_trace map * @flags: bits 0-7 - numer of stack frames to skip * bit 8 - collect user stack instead of kernel * bit 9 - compare stacks by hash only * bit 10 - if two different stacks hash into the same stackid * discard old * other bits - reserved * Return: >= 0 stackid on success or negative error * * s64 bpf_csum_diff(from, from_size, to, to_size, seed) * calculate csum diff * @from: raw from buffer * @from_size: length of from buffer * @to: raw to buffer * @to_size: length of to buffer * @seed: optional seed * Return: csum result or negative error code * * int bpf_skb_get_tunnel_opt(skb, opt, size) * retrieve tunnel options metadata * @skb: pointer to skb * @opt: pointer to raw tunnel option data * @size: size of @opt * Return: option size * * int bpf_skb_set_tunnel_opt(skb, opt, size) * populate tunnel options metadata * @skb: pointer to skb * @opt: pointer to raw tunnel option data * @size: size of @opt * Return: 0 on success or negative error * * int bpf_skb_change_proto(skb, proto, flags) * Change protocol of the skb. Currently supported is v4 -> v6, * v6 -> v4 transitions. The helper will also resize the skb. eBPF * program is expected to fill the new headers via skb_store_bytes * and lX_csum_replace. * @skb: pointer to skb * @proto: new skb->protocol type * @flags: reserved * Return: 0 on success or negative error * * int bpf_skb_change_type(skb, type) * Change packet type of skb. * @skb: pointer to skb * @type: new skb->pkt_type type * Return: 0 on success or negative error * * int bpf_skb_under_cgroup(skb, map, index) * Check cgroup2 membership of skb * @skb: pointer to skb * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type * @index: index of the cgroup in the bpf_map * Return: * == 0 skb failed the cgroup2 descendant test * == 1 skb succeeded the cgroup2 descendant test * < 0 error * * u32 bpf_get_hash_recalc(skb) * Retrieve and possibly recalculate skb->hash. * @skb: pointer to skb * Return: hash * * u64 bpf_get_current_task(void) * Returns current task_struct * Return: current * * int bpf_probe_write_user(void *dst, void *src, int len) * safely attempt to write to a location * @dst: destination address in userspace * @src: source address on stack * @len: number of bytes to copy * Return: 0 on success or negative error * * int bpf_current_task_under_cgroup(map, index) * Check cgroup2 membership of current task * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type * @index: index of the cgroup in the bpf_map * Return: * == 0 current failed the cgroup2 descendant test * == 1 current succeeded the cgroup2 descendant test * < 0 error * * int bpf_skb_change_tail(skb, len, flags) * The helper will resize the skb to the given new size, to be used f.e. * with control messages. * @skb: pointer to skb * @len: new skb length * @flags: reserved * Return: 0 on success or negative error * * int bpf_skb_pull_data(skb, len) * The helper will pull in non-linear data in case the skb is non-linear * and not all of len are part of the linear section. Only needed for * read/write with direct packet access. * @skb: pointer to skb * @len: len to make read/writeable * Return: 0 on success or negative error * * s64 bpf_csum_update(skb, csum) * Adds csum into skb->csum in case of CHECKSUM_COMPLETE. * @skb: pointer to skb * @csum: csum to add * Return: csum on success or negative error * * void bpf_set_hash_invalid(skb) * Invalidate current skb->hash. * @skb: pointer to skb * * int bpf_get_numa_node_id() * Return: Id of current NUMA node. * * int bpf_skb_change_head() * Grows headroom of skb and adjusts MAC header offset accordingly. * Will extends/reallocae as required automatically. * May change skb data pointer and will thus invalidate any check * performed for direct packet access. * @skb: pointer to skb * @len: length of header to be pushed in front * @flags: Flags (unused for now) * Return: 0 on success or negative error * * int bpf_xdp_adjust_head(xdp_md, delta) * Adjust the xdp_md.data by delta * @xdp_md: pointer to xdp_md * @delta: An positive/negative integer to be added to xdp_md.data * Return: 0 on success or negative on error */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ FN(map_lookup_elem), \ FN(map_update_elem), \ FN(map_delete_elem), \ FN(probe_read), \ FN(ktime_get_ns), \ FN(trace_printk), \ FN(get_prandom_u32), \ FN(get_smp_processor_id), \ FN(skb_store_bytes), \ FN(l3_csum_replace), \ FN(l4_csum_replace), \ FN(tail_call), \ FN(clone_redirect), \ FN(get_current_pid_tgid), \ FN(get_current_uid_gid), \ FN(get_current_comm), \ FN(get_cgroup_classid), \ FN(skb_vlan_push), \ FN(skb_vlan_pop), \ FN(skb_get_tunnel_key), \ FN(skb_set_tunnel_key), \ FN(perf_event_read), \ FN(redirect), \ FN(get_route_realm), \ FN(perf_event_output), \ FN(skb_load_bytes), \ FN(get_stackid), \ FN(csum_diff), \ FN(skb_get_tunnel_opt), \ FN(skb_set_tunnel_opt), \ FN(skb_change_proto), \ FN(skb_change_type), \ FN(skb_under_cgroup), \ FN(get_hash_recalc), \ FN(get_current_task), \ FN(probe_write_user), \ FN(current_task_under_cgroup), \ FN(skb_change_tail), \ FN(skb_pull_data), \ FN(csum_update), \ FN(set_hash_invalid), \ FN(get_numa_node_id), \ FN(skb_change_head), \ FN(xdp_adjust_head), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call */ #define __BPF_ENUM_FN(x) BPF_FUNC_ ## x enum bpf_func_id { __BPF_FUNC_MAPPER(__BPF_ENUM_FN) __BPF_FUNC_MAX_ID, }; #undef __BPF_ENUM_FN /* All flags used by eBPF helper functions, placed here. */ /* BPF_FUNC_skb_store_bytes flags. */ #define BPF_F_RECOMPUTE_CSUM (1ULL << 0) #define BPF_F_INVALIDATE_HASH (1ULL << 1) /* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags. * First 4 bits are for passing the header field size. */ #define BPF_F_HDR_FIELD_MASK 0xfULL /* BPF_FUNC_l4_csum_replace flags. */ #define BPF_F_PSEUDO_HDR (1ULL << 4) #define BPF_F_MARK_MANGLED_0 (1ULL << 5) /* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */ #define BPF_F_INGRESS (1ULL << 0) /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */ #define BPF_F_TUNINFO_IPV6 (1ULL << 0) /* BPF_FUNC_get_stackid flags. */ #define BPF_F_SKIP_FIELD_MASK 0xffULL #define BPF_F_USER_STACK (1ULL << 8) #define BPF_F_FAST_STACK_CMP (1ULL << 9) #define BPF_F_REUSE_STACKID (1ULL << 10) /* BPF_FUNC_skb_set_tunnel_key flags. */ #define BPF_F_ZERO_CSUM_TX (1ULL << 1) #define BPF_F_DONT_FRAGMENT (1ULL << 2) /* BPF_FUNC_perf_event_output and BPF_FUNC_perf_event_read flags. */ #define BPF_F_INDEX_MASK 0xffffffffULL #define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK /* BPF_FUNC_perf_event_output for sk_buff input context. */ #define BPF_F_CTXLEN_MASK (0xfffffULL << 32) /* user accessible mirror of in-kernel sk_buff. * new fields can only be added to the end of this structure */ struct __sk_buff { __u32 len; __u32 pkt_type; __u32 mark; __u32 queue_mapping; __u32 protocol; __u32 vlan_present; __u32 vlan_tci; __u32 vlan_proto; __u32 priority; __u32 ingress_ifindex; __u32 ifindex; __u32 tc_index; __u32 cb[5]; __u32 hash; __u32 tc_classid; __u32 data; __u32 data_end; }; struct bpf_tunnel_key { __u32 tunnel_id; union { __u32 remote_ipv4; __u32 remote_ipv6[4]; }; __u8 tunnel_tos; __u8 tunnel_ttl; __u16 tunnel_ext; __u32 tunnel_label; }; /* Generic BPF return codes which all BPF program types may support. * The values are binary compatible with their TC_ACT_* counter-part to * provide backwards compatibility with existing SCHED_CLS and SCHED_ACT * programs. * * XDP is handled seprately, see XDP_*. */ enum bpf_ret_code { BPF_OK = 0, /* 1 reserved */ BPF_DROP = 2, /* 3-6 reserved */ BPF_REDIRECT = 7, /* >127 are reserved for prog type specific return codes */ }; struct bpf_sock { __u32 bound_dev_if; __u32 family; __u32 type; __u32 protocol; }; #define XDP_PACKET_HEADROOM 256 /* User return codes for XDP prog type. * A valid XDP program must return one of these defined values. All other * return codes are reserved for future use. Unknown return codes will result * in packet drop. */ enum xdp_action { XDP_ABORTED = 0, XDP_DROP, XDP_PASS, XDP_TX, }; /* user accessible metadata for XDP packet hook * new fields must be added to the end of this structure */ struct xdp_md { __u32 data; __u32 data_end; }; #endif /* _UAPI__LINUX_BPF_H__ */ bpfcc-0.2.0+git0.02884a026/src/cc/compat/linux/bpf_common.h000066400000000000000000000023351305314114400225670ustar00rootroot00000000000000#ifndef _UAPI__LINUX_BPF_COMMON_H__ #define _UAPI__LINUX_BPF_COMMON_H__ /* Instruction classes */ #define BPF_CLASS(code) ((code) & 0x07) #define BPF_LD 0x00 #define BPF_LDX 0x01 #define BPF_ST 0x02 #define BPF_STX 0x03 #define BPF_ALU 0x04 #define BPF_JMP 0x05 #define BPF_RET 0x06 #define BPF_MISC 0x07 /* ld/ldx fields */ #define BPF_SIZE(code) ((code) & 0x18) #define BPF_W 0x00 #define BPF_H 0x08 #define BPF_B 0x10 #define BPF_MODE(code) ((code) & 0xe0) #define BPF_IMM 0x00 #define BPF_ABS 0x20 #define BPF_IND 0x40 #define BPF_MEM 0x60 #define BPF_LEN 0x80 #define BPF_MSH 0xa0 /* alu/jmp fields */ #define BPF_OP(code) ((code) & 0xf0) #define BPF_ADD 0x00 #define BPF_SUB 0x10 #define BPF_MUL 0x20 #define BPF_DIV 0x30 #define BPF_OR 0x40 #define BPF_AND 0x50 #define BPF_LSH 0x60 #define BPF_RSH 0x70 #define BPF_NEG 0x80 #define BPF_MOD 0x90 #define BPF_XOR 0xa0 #define BPF_JA 0x00 #define BPF_JEQ 0x10 #define BPF_JGT 0x20 #define BPF_JGE 0x30 #define BPF_JSET 0x40 #define BPF_SRC(code) ((code) & 0x08) #define BPF_K 0x00 #define BPF_X 0x08 #ifndef BPF_MAXINSNS #define BPF_MAXINSNS 4096 #endif #endif /* _UAPI__LINUX_BPF_COMMON_H__ */ bpfcc-0.2.0+git0.02884a026/src/cc/compat/linux/virtual_bpf.h000066400000000000000000000440221305314114400227640ustar00rootroot00000000000000R"********( /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com * * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public * License as published by the Free Software Foundation. */ #ifndef _UAPI__LINUX_BPF_H__ #define _UAPI__LINUX_BPF_H__ #include #include /* Extended instruction set based on top of classic BPF */ /* instruction classes */ #define BPF_ALU64 0x07 /* alu mode in double word width */ /* ld/ldx fields */ #define BPF_DW 0x18 /* double word */ #define BPF_XADD 0xc0 /* exclusive add */ /* alu/jmp fields */ #define BPF_MOV 0xb0 /* mov reg to reg */ #define BPF_ARSH 0xc0 /* sign extending arithmetic shift right */ /* change endianness of a register */ #define BPF_END 0xd0 /* flags for endianness conversion: */ #define BPF_TO_LE 0x00 /* convert to little-endian */ #define BPF_TO_BE 0x08 /* convert to big-endian */ #define BPF_FROM_LE BPF_TO_LE #define BPF_FROM_BE BPF_TO_BE #define BPF_JNE 0x50 /* jump != */ #define BPF_JSGT 0x60 /* SGT is signed '>', GT in x86 */ #define BPF_JSGE 0x70 /* SGE is signed '>=', GE in x86 */ #define BPF_CALL 0x80 /* function call */ #define BPF_EXIT 0x90 /* function return */ /* Register numbers */ enum { BPF_REG_0 = 0, BPF_REG_1, BPF_REG_2, BPF_REG_3, BPF_REG_4, BPF_REG_5, BPF_REG_6, BPF_REG_7, BPF_REG_8, BPF_REG_9, BPF_REG_10, __MAX_BPF_REG, }; /* BPF has 10 general purpose 64-bit registers and stack frame. */ #define MAX_BPF_REG __MAX_BPF_REG struct bpf_insn { __u8 code; /* opcode */ __u8 dst_reg:4; /* dest register */ __u8 src_reg:4; /* source register */ __s16 off; /* signed offset */ __s32 imm; /* signed immediate constant */ }; /* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */ struct bpf_lpm_trie_key { __u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */ __u8 data[0]; /* Arbitrary size */ }; /* BPF syscall commands, see bpf(2) man-page for details. */ enum bpf_cmd { BPF_MAP_CREATE, BPF_MAP_LOOKUP_ELEM, BPF_MAP_UPDATE_ELEM, BPF_MAP_DELETE_ELEM, BPF_MAP_GET_NEXT_KEY, BPF_PROG_LOAD, BPF_OBJ_PIN, BPF_OBJ_GET, BPF_PROG_ATTACH, BPF_PROG_DETACH, }; enum bpf_map_type { BPF_MAP_TYPE_UNSPEC, BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_PROG_ARRAY, BPF_MAP_TYPE_PERF_EVENT_ARRAY, BPF_MAP_TYPE_PERCPU_HASH, BPF_MAP_TYPE_PERCPU_ARRAY, BPF_MAP_TYPE_STACK_TRACE, BPF_MAP_TYPE_CGROUP_ARRAY, BPF_MAP_TYPE_LRU_HASH, BPF_MAP_TYPE_LRU_PERCPU_HASH, BPF_MAP_TYPE_LPM_TRIE, }; enum bpf_prog_type { BPF_PROG_TYPE_UNSPEC, BPF_PROG_TYPE_SOCKET_FILTER, BPF_PROG_TYPE_KPROBE, BPF_PROG_TYPE_SCHED_CLS, BPF_PROG_TYPE_SCHED_ACT, BPF_PROG_TYPE_TRACEPOINT, BPF_PROG_TYPE_XDP, BPF_PROG_TYPE_PERF_EVENT, BPF_PROG_TYPE_CGROUP_SKB, BPF_PROG_TYPE_CGROUP_SOCK, BPF_PROG_TYPE_LWT_IN, BPF_PROG_TYPE_LWT_OUT, BPF_PROG_TYPE_LWT_XMIT, }; enum bpf_attach_type { BPF_CGROUP_INET_INGRESS, BPF_CGROUP_INET_EGRESS, BPF_CGROUP_INET_SOCK_CREATE, __MAX_BPF_ATTACH_TYPE }; #define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE #define BPF_PSEUDO_MAP_FD 1 /* flags for BPF_MAP_UPDATE_ELEM command */ #define BPF_ANY 0 /* create new element or update existing */ #define BPF_NOEXIST 1 /* create new element if it didn't exist */ #define BPF_EXIST 2 /* update existing element */ #define BPF_F_NO_PREALLOC (1U << 0) /* Instead of having one common LRU list in the * BPF_MAP_TYPE_LRU_[PERCPU_]HASH map, use a percpu LRU list * which can scale and perform better. * Note, the LRU nodes (including free nodes) cannot be moved * across different LRU lists. */ #define BPF_F_NO_COMMON_LRU (1U << 1) union bpf_attr { struct { /* anonymous struct used by BPF_MAP_CREATE command */ __u32 map_type; /* one of enum bpf_map_type */ __u32 key_size; /* size of key in bytes */ __u32 value_size; /* size of value in bytes */ __u32 max_entries; /* max number of entries in a map */ __u32 map_flags; /* prealloc or not */ }; struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */ __u32 map_fd; __aligned_u64 key; union { __aligned_u64 value; __aligned_u64 next_key; }; __u64 flags; }; struct { /* anonymous struct used by BPF_PROG_LOAD command */ __u32 prog_type; /* one of enum bpf_prog_type */ __u32 insn_cnt; __aligned_u64 insns; __aligned_u64 license; __u32 log_level; /* verbosity level of verifier */ __u32 log_size; /* size of user buffer */ __aligned_u64 log_buf; /* user supplied buffer */ __u32 kern_version; /* checked when prog_type=kprobe */ }; struct { /* anonymous struct used by BPF_OBJ_* commands */ __aligned_u64 pathname; __u32 bpf_fd; }; struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ __u32 target_fd; /* container object to attach to */ __u32 attach_bpf_fd; /* eBPF program to attach */ __u32 attach_type; }; } __attribute__((aligned(8))); /* BPF helper function descriptions: * * void *bpf_map_lookup_elem(&map, &key) * Return: Map value or NULL * * int bpf_map_update_elem(&map, &key, &value, flags) * Return: 0 on success or negative error * * int bpf_map_delete_elem(&map, &key) * Return: 0 on success or negative error * * int bpf_probe_read(void *dst, int size, void *src) * Return: 0 on success or negative error * * u64 bpf_ktime_get_ns(void) * Return: current ktime * * int bpf_trace_printk(const char *fmt, int fmt_size, ...) * Return: length of buffer written or negative error * * u32 bpf_prandom_u32(void) * Return: random value * * u32 bpf_raw_smp_processor_id(void) * Return: SMP processor ID * * int bpf_skb_store_bytes(skb, offset, from, len, flags) * store bytes into packet * @skb: pointer to skb * @offset: offset within packet from skb->mac_header * @from: pointer where to copy bytes from * @len: number of bytes to store into packet * @flags: bit 0 - if true, recompute skb->csum * other bits - reserved * Return: 0 on success or negative error * * int bpf_l3_csum_replace(skb, offset, from, to, flags) * recompute IP checksum * @skb: pointer to skb * @offset: offset within packet where IP checksum is located * @from: old value of header field * @to: new value of header field * @flags: bits 0-3 - size of header field * other bits - reserved * Return: 0 on success or negative error * * int bpf_l4_csum_replace(skb, offset, from, to, flags) * recompute TCP/UDP checksum * @skb: pointer to skb * @offset: offset within packet where TCP/UDP checksum is located * @from: old value of header field * @to: new value of header field * @flags: bits 0-3 - size of header field * bit 4 - is pseudo header * other bits - reserved * Return: 0 on success or negative error * * int bpf_tail_call(ctx, prog_array_map, index) * jump into another BPF program * @ctx: context pointer passed to next program * @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY * @index: index inside array that selects specific program to run * Return: 0 on success or negative error * * int bpf_clone_redirect(skb, ifindex, flags) * redirect to another netdev * @skb: pointer to skb * @ifindex: ifindex of the net device * @flags: bit 0 - if set, redirect to ingress instead of egress * other bits - reserved * Return: 0 on success or negative error * * u64 bpf_get_current_pid_tgid(void) * Return: current->tgid << 32 | current->pid * * u64 bpf_get_current_uid_gid(void) * Return: current_gid << 32 | current_uid * * int bpf_get_current_comm(char *buf, int size_of_buf) * stores current->comm into buf * Return: 0 on success or negative error * * u32 bpf_get_cgroup_classid(skb) * retrieve a proc's classid * @skb: pointer to skb * Return: classid if != 0 * * int bpf_skb_vlan_push(skb, vlan_proto, vlan_tci) * Return: 0 on success or negative error * * int bpf_skb_vlan_pop(skb) * Return: 0 on success or negative error * * int bpf_skb_get_tunnel_key(skb, key, size, flags) * int bpf_skb_set_tunnel_key(skb, key, size, flags) * retrieve or populate tunnel metadata * @skb: pointer to skb * @key: pointer to 'struct bpf_tunnel_key' * @size: size of 'struct bpf_tunnel_key' * @flags: room for future extensions * Return: 0 on success or negative error * * u64 bpf_perf_event_read(&map, index) * Return: Number events read or error code * * int bpf_redirect(ifindex, flags) * redirect to another netdev * @ifindex: ifindex of the net device * @flags: bit 0 - if set, redirect to ingress instead of egress * other bits - reserved * Return: TC_ACT_REDIRECT * * u32 bpf_get_route_realm(skb) * retrieve a dst's tclassid * @skb: pointer to skb * Return: realm if != 0 * * int bpf_perf_event_output(ctx, map, index, data, size) * output perf raw sample * @ctx: struct pt_regs* * @map: pointer to perf_event_array map * @index: index of event in the map * @data: data on stack to be output as raw data * @size: size of data * Return: 0 on success or negative error * * int bpf_get_stackid(ctx, map, flags) * walk user or kernel stack and return id * @ctx: struct pt_regs* * @map: pointer to stack_trace map * @flags: bits 0-7 - numer of stack frames to skip * bit 8 - collect user stack instead of kernel * bit 9 - compare stacks by hash only * bit 10 - if two different stacks hash into the same stackid * discard old * other bits - reserved * Return: >= 0 stackid on success or negative error * * s64 bpf_csum_diff(from, from_size, to, to_size, seed) * calculate csum diff * @from: raw from buffer * @from_size: length of from buffer * @to: raw to buffer * @to_size: length of to buffer * @seed: optional seed * Return: csum result or negative error code * * int bpf_skb_get_tunnel_opt(skb, opt, size) * retrieve tunnel options metadata * @skb: pointer to skb * @opt: pointer to raw tunnel option data * @size: size of @opt * Return: option size * * int bpf_skb_set_tunnel_opt(skb, opt, size) * populate tunnel options metadata * @skb: pointer to skb * @opt: pointer to raw tunnel option data * @size: size of @opt * Return: 0 on success or negative error * * int bpf_skb_change_proto(skb, proto, flags) * Change protocol of the skb. Currently supported is v4 -> v6, * v6 -> v4 transitions. The helper will also resize the skb. eBPF * program is expected to fill the new headers via skb_store_bytes * and lX_csum_replace. * @skb: pointer to skb * @proto: new skb->protocol type * @flags: reserved * Return: 0 on success or negative error * * int bpf_skb_change_type(skb, type) * Change packet type of skb. * @skb: pointer to skb * @type: new skb->pkt_type type * Return: 0 on success or negative error * * int bpf_skb_under_cgroup(skb, map, index) * Check cgroup2 membership of skb * @skb: pointer to skb * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type * @index: index of the cgroup in the bpf_map * Return: * == 0 skb failed the cgroup2 descendant test * == 1 skb succeeded the cgroup2 descendant test * < 0 error * * u32 bpf_get_hash_recalc(skb) * Retrieve and possibly recalculate skb->hash. * @skb: pointer to skb * Return: hash * * u64 bpf_get_current_task(void) * Returns current task_struct * Return: current * * int bpf_probe_write_user(void *dst, void *src, int len) * safely attempt to write to a location * @dst: destination address in userspace * @src: source address on stack * @len: number of bytes to copy * Return: 0 on success or negative error * * int bpf_current_task_under_cgroup(map, index) * Check cgroup2 membership of current task * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type * @index: index of the cgroup in the bpf_map * Return: * == 0 current failed the cgroup2 descendant test * == 1 current succeeded the cgroup2 descendant test * < 0 error * * int bpf_skb_change_tail(skb, len, flags) * The helper will resize the skb to the given new size, to be used f.e. * with control messages. * @skb: pointer to skb * @len: new skb length * @flags: reserved * Return: 0 on success or negative error * * int bpf_skb_pull_data(skb, len) * The helper will pull in non-linear data in case the skb is non-linear * and not all of len are part of the linear section. Only needed for * read/write with direct packet access. * @skb: pointer to skb * @len: len to make read/writeable * Return: 0 on success or negative error * * s64 bpf_csum_update(skb, csum) * Adds csum into skb->csum in case of CHECKSUM_COMPLETE. * @skb: pointer to skb * @csum: csum to add * Return: csum on success or negative error * * void bpf_set_hash_invalid(skb) * Invalidate current skb->hash. * @skb: pointer to skb * * int bpf_get_numa_node_id() * Return: Id of current NUMA node. * * int bpf_skb_change_head() * Grows headroom of skb and adjusts MAC header offset accordingly. * Will extends/reallocae as required automatically. * May change skb data pointer and will thus invalidate any check * performed for direct packet access. * @skb: pointer to skb * @len: length of header to be pushed in front * @flags: Flags (unused for now) * Return: 0 on success or negative error * * int bpf_xdp_adjust_head(xdp_md, delta) * Adjust the xdp_md.data by delta * @xdp_md: pointer to xdp_md * @delta: An positive/negative integer to be added to xdp_md.data * Return: 0 on success or negative on error */ #define __BPF_FUNC_MAPPER(FN) \ FN(unspec), \ FN(map_lookup_elem), \ FN(map_update_elem), \ FN(map_delete_elem), \ FN(probe_read), \ FN(ktime_get_ns), \ FN(trace_printk), \ FN(get_prandom_u32), \ FN(get_smp_processor_id), \ FN(skb_store_bytes), \ FN(l3_csum_replace), \ FN(l4_csum_replace), \ FN(tail_call), \ FN(clone_redirect), \ FN(get_current_pid_tgid), \ FN(get_current_uid_gid), \ FN(get_current_comm), \ FN(get_cgroup_classid), \ FN(skb_vlan_push), \ FN(skb_vlan_pop), \ FN(skb_get_tunnel_key), \ FN(skb_set_tunnel_key), \ FN(perf_event_read), \ FN(redirect), \ FN(get_route_realm), \ FN(perf_event_output), \ FN(skb_load_bytes), \ FN(get_stackid), \ FN(csum_diff), \ FN(skb_get_tunnel_opt), \ FN(skb_set_tunnel_opt), \ FN(skb_change_proto), \ FN(skb_change_type), \ FN(skb_under_cgroup), \ FN(get_hash_recalc), \ FN(get_current_task), \ FN(probe_write_user), \ FN(current_task_under_cgroup), \ FN(skb_change_tail), \ FN(skb_pull_data), \ FN(csum_update), \ FN(set_hash_invalid), \ FN(get_numa_node_id), \ FN(skb_change_head), \ FN(xdp_adjust_head), /* integer value in 'imm' field of BPF_CALL instruction selects which helper * function eBPF program intends to call */ #define __BPF_ENUM_FN(x) BPF_FUNC_ ## x enum bpf_func_id { __BPF_FUNC_MAPPER(__BPF_ENUM_FN) __BPF_FUNC_MAX_ID, }; #undef __BPF_ENUM_FN /* All flags used by eBPF helper functions, placed here. */ /* BPF_FUNC_skb_store_bytes flags. */ #define BPF_F_RECOMPUTE_CSUM (1ULL << 0) #define BPF_F_INVALIDATE_HASH (1ULL << 1) /* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags. * First 4 bits are for passing the header field size. */ #define BPF_F_HDR_FIELD_MASK 0xfULL /* BPF_FUNC_l4_csum_replace flags. */ #define BPF_F_PSEUDO_HDR (1ULL << 4) #define BPF_F_MARK_MANGLED_0 (1ULL << 5) /* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */ #define BPF_F_INGRESS (1ULL << 0) /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */ #define BPF_F_TUNINFO_IPV6 (1ULL << 0) /* BPF_FUNC_get_stackid flags. */ #define BPF_F_SKIP_FIELD_MASK 0xffULL #define BPF_F_USER_STACK (1ULL << 8) #define BPF_F_FAST_STACK_CMP (1ULL << 9) #define BPF_F_REUSE_STACKID (1ULL << 10) /* BPF_FUNC_skb_set_tunnel_key flags. */ #define BPF_F_ZERO_CSUM_TX (1ULL << 1) #define BPF_F_DONT_FRAGMENT (1ULL << 2) /* BPF_FUNC_perf_event_output and BPF_FUNC_perf_event_read flags. */ #define BPF_F_INDEX_MASK 0xffffffffULL #define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK /* BPF_FUNC_perf_event_output for sk_buff input context. */ #define BPF_F_CTXLEN_MASK (0xfffffULL << 32) /* user accessible mirror of in-kernel sk_buff. * new fields can only be added to the end of this structure */ struct __sk_buff { __u32 len; __u32 pkt_type; __u32 mark; __u32 queue_mapping; __u32 protocol; __u32 vlan_present; __u32 vlan_tci; __u32 vlan_proto; __u32 priority; __u32 ingress_ifindex; __u32 ifindex; __u32 tc_index; __u32 cb[5]; __u32 hash; __u32 tc_classid; __u32 data; __u32 data_end; }; struct bpf_tunnel_key { __u32 tunnel_id; union { __u32 remote_ipv4; __u32 remote_ipv6[4]; }; __u8 tunnel_tos; __u8 tunnel_ttl; __u16 tunnel_ext; __u32 tunnel_label; }; /* Generic BPF return codes which all BPF program types may support. * The values are binary compatible with their TC_ACT_* counter-part to * provide backwards compatibility with existing SCHED_CLS and SCHED_ACT * programs. * * XDP is handled seprately, see XDP_*. */ enum bpf_ret_code { BPF_OK = 0, /* 1 reserved */ BPF_DROP = 2, /* 3-6 reserved */ BPF_REDIRECT = 7, /* >127 are reserved for prog type specific return codes */ }; struct bpf_sock { __u32 bound_dev_if; __u32 family; __u32 type; __u32 protocol; }; #define XDP_PACKET_HEADROOM 256 /* User return codes for XDP prog type. * A valid XDP program must return one of these defined values. All other * return codes are reserved for future use. Unknown return codes will result * in packet drop. */ enum xdp_action { XDP_ABORTED = 0, XDP_DROP, XDP_PASS, XDP_TX, }; /* user accessible metadata for XDP packet hook * new fields must be added to the end of this structure */ struct xdp_md { __u32 data; __u32 data_end; }; #endif /* _UAPI__LINUX_BPF_H__ */ )********" bpfcc-0.2.0+git0.02884a026/src/cc/export/000077500000000000000000000000001305314114400171735ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/export/helpers.h000066400000000000000000000456321305314114400210200ustar00rootroot00000000000000R"********( /* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __BPF_HELPERS_H #define __BPF_HELPERS_H #include #include #include #ifndef CONFIG_BPF_SYSCALL #error "CONFIG_BPF_SYSCALL is undefined, please check your .config or ask your Linux distro to enable this feature" #endif #ifdef PERF_MAX_STACK_DEPTH #define BPF_MAX_STACK_DEPTH PERF_MAX_STACK_DEPTH #else #define BPF_MAX_STACK_DEPTH 127 #endif /* helper macro to place programs, maps, license in * different sections in elf_bpf file. Section names * are interpreted by elf_bpf loader */ #define SEC(NAME) __attribute__((section(NAME), used)) // Changes to the macro require changes in BFrontendAction classes #define BPF_F_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries, _flags) \ struct _name##_table_t { \ _key_type key; \ _leaf_type leaf; \ _leaf_type * (*lookup) (_key_type *); \ _leaf_type * (*lookup_or_init) (_key_type *, _leaf_type *); \ int (*update) (_key_type *, _leaf_type *); \ int (*delete) (_key_type *); \ void (*call) (void *, int index); \ void (*increment) (_key_type); \ int (*get_stackid) (void *, u64); \ _leaf_type data[_max_entries]; \ int flags; \ }; \ __attribute__((section("maps/" _table_type))) \ struct _name##_table_t _name = { .flags = (_flags) } #define BPF_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries) \ BPF_F_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries, 0); // define a table same as above but allow it to be referenced by other modules #define BPF_TABLE_PUBLIC(_table_type, _key_type, _leaf_type, _name, _max_entries) \ BPF_TABLE(_table_type, _key_type, _leaf_type, _name, _max_entries); \ __attribute__((section("maps/export"))) \ struct _name##_table_t __##_name // Table for pushing custom events to userspace via ring buffer #define BPF_PERF_OUTPUT(_name) \ struct _name##_table_t { \ int key; \ u32 leaf; \ /* map.perf_submit(ctx, data, data_size) */ \ int (*perf_submit) (void *, void *, u32); \ int (*perf_submit_skb) (void *, u32, void *, u32); \ u32 data[0]; \ }; \ __attribute__((section("maps/perf_output"))) \ struct _name##_table_t _name // Table for reading hw perf cpu counters #define BPF_PERF_ARRAY(_name, _max_entries) \ struct _name##_table_t { \ int key; \ u32 leaf; \ /* counter = map.perf_read(index) */ \ u64 (*perf_read) (int); \ u32 data[_max_entries]; \ }; \ __attribute__((section("maps/perf_array"))) \ struct _name##_table_t _name #define BPF_HASH1(_name) \ BPF_TABLE("hash", u64, u64, _name, 10240) #define BPF_HASH2(_name, _key_type) \ BPF_TABLE("hash", _key_type, u64, _name, 10240) #define BPF_HASH3(_name, _key_type, _leaf_type) \ BPF_TABLE("hash", _key_type, _leaf_type, _name, 10240) // helper for default-variable macro function #define BPF_HASHX(_1, _2, _3, NAME, ...) NAME // Define a hash function, some arguments optional // BPF_HASH(name, key_type=u64, leaf_type=u64, size=10240) #define BPF_HASH(...) \ BPF_HASHX(__VA_ARGS__, BPF_HASH3, BPF_HASH2, BPF_HASH1)(__VA_ARGS__) #define BPF_HIST1(_name) \ BPF_TABLE("histogram", int, u64, _name, 64) #define BPF_HIST2(_name, _key_type) \ BPF_TABLE("histogram", _key_type, u64, _name, 64) #define BPF_HIST3(_name, _key_type, _size) \ BPF_TABLE("histogram", _key_type, u64, _name, _size) #define BPF_HISTX(_1, _2, _3, NAME, ...) NAME // Define a histogram, some arguments optional // BPF_HISTOGRAM(name, key_type=int, size=64) #define BPF_HISTOGRAM(...) \ BPF_HISTX(__VA_ARGS__, BPF_HIST3, BPF_HIST2, BPF_HIST1)(__VA_ARGS__) struct bpf_stacktrace { u64 ip[BPF_MAX_STACK_DEPTH]; }; #define BPF_STACK_TRACE(_name, _max_entries) \ BPF_TABLE("stacktrace", int, struct bpf_stacktrace, _name, _max_entries); // packet parsing state machine helpers #define cursor_advance(_cursor, _len) \ ({ void *_tmp = _cursor; _cursor += _len; _tmp; }) char _license[4] SEC("license") = "GPL"; unsigned _version SEC("version") = LINUX_VERSION_CODE; /* helper functions called from eBPF programs written in C */ static void *(*bpf_map_lookup_elem)(void *map, void *key) = (void *) BPF_FUNC_map_lookup_elem; static int (*bpf_map_update_elem)(void *map, void *key, void *value, u64 flags) = (void *) BPF_FUNC_map_update_elem; static int (*bpf_map_delete_elem)(void *map, void *key) = (void *) BPF_FUNC_map_delete_elem; static int (*bpf_probe_read)(void *dst, u64 size, void *unsafe_ptr) = (void *) BPF_FUNC_probe_read; static u64 (*bpf_ktime_get_ns)(void) = (void *) BPF_FUNC_ktime_get_ns; static u32 (*bpf_get_prandom_u32)(void) = (void *) BPF_FUNC_get_prandom_u32; static int (*bpf_trace_printk_)(const char *fmt, u64 fmt_size, ...) = (void *) BPF_FUNC_trace_printk; int bpf_trace_printk(const char *fmt, ...) asm("llvm.bpf.extra"); static inline void bpf_tail_call_(u64 map_fd, void *ctx, int index) { ((void (*)(void *, u64, int))BPF_FUNC_tail_call)(ctx, map_fd, index); } static int (*bpf_clone_redirect)(void *ctx, int ifindex, u32 flags) = (void *) BPF_FUNC_clone_redirect; static u64 (*bpf_get_smp_processor_id)(void) = (void *) BPF_FUNC_get_smp_processor_id; static u64 (*bpf_get_current_pid_tgid)(void) = (void *) BPF_FUNC_get_current_pid_tgid; static u64 (*bpf_get_current_uid_gid)(void) = (void *) BPF_FUNC_get_current_uid_gid; static int (*bpf_get_current_comm)(void *buf, int buf_size) = (void *) BPF_FUNC_get_current_comm; static u64 (*bpf_get_cgroup_classid)(void *ctx) = (void *) BPF_FUNC_get_cgroup_classid; static u64 (*bpf_skb_vlan_push)(void *ctx, u16 proto, u16 vlan_tci) = (void *) BPF_FUNC_skb_vlan_push; static u64 (*bpf_skb_vlan_pop)(void *ctx) = (void *) BPF_FUNC_skb_vlan_pop; static int (*bpf_skb_get_tunnel_key)(void *ctx, void *to, u32 size, u64 flags) = (void *) BPF_FUNC_skb_get_tunnel_key; static int (*bpf_skb_set_tunnel_key)(void *ctx, void *from, u32 size, u64 flags) = (void *) BPF_FUNC_skb_set_tunnel_key; static int (*bpf_perf_event_read)(void *map, u32 index) = (void *) BPF_FUNC_perf_event_read; static int (*bpf_redirect)(int ifindex, u32 flags) = (void *) BPF_FUNC_redirect; static u32 (*bpf_get_route_realm)(void *ctx) = (void *) BPF_FUNC_get_route_realm; static int (*bpf_perf_event_output)(void *ctx, void *map, u64 index, void *data, u32 size) = (void *) BPF_FUNC_perf_event_output; static int (*bpf_skb_load_bytes)(void *ctx, int offset, void *to, u32 len) = (void *) BPF_FUNC_skb_load_bytes; /* bpf_get_stackid will return a negative value in the case of an error * * BPF_STACK_TRACE(_name, _size) will allocate space for _size stack traces. * -ENOMEM will be returned when this limit is reached. * * -EFAULT is typically returned when requesting user-space stack straces (using * BPF_F_USER_STACK) for kernel threads. However, a valid stackid may be * returned in some cases; consider a tracepoint or kprobe executing in the * kernel context. Given this you can typically ignore -EFAULT errors when * retrieving user-space stack traces. */ static int (*bpf_get_stackid_)(void *ctx, void *map, u64 flags) = (void *) BPF_FUNC_get_stackid; static inline __attribute__((always_inline)) int bpf_get_stackid(uintptr_t map, void *ctx, u64 flags) { return bpf_get_stackid_(ctx, (void *)map, flags); } static int (*bpf_csum_diff)(void *from, u64 from_size, void *to, u64 to_size, u64 seed) = (void *) BPF_FUNC_csum_diff; static int (*bpf_skb_get_tunnel_opt)(void *ctx, void *md, u32 size) = (void *) BPF_FUNC_skb_get_tunnel_opt; static int (*bpf_skb_set_tunnel_opt)(void *ctx, void *md, u32 size) = (void *) BPF_FUNC_skb_set_tunnel_opt; static int (*bpf_skb_change_proto)(void *ctx, u16 proto, u64 flags) = (void *) BPF_FUNC_skb_change_proto; static int (*bpf_skb_change_type)(void *ctx, u32 type) = (void *) BPF_FUNC_skb_change_type; static u32 (*bpf_get_hash_recalc)(void *ctx) = (void *) BPF_FUNC_get_hash_recalc; static u64 (*bpf_get_current_task)(void) = (void *) BPF_FUNC_get_current_task; static int (*bpf_probe_write_user)(void *dst, void *src, u32 size) = (void *) BPF_FUNC_probe_write_user; static int (*bpf_skb_change_tail)(void *ctx, u32 new_len, u64 flags) = (void *) BPF_FUNC_skb_change_tail; static int (*bpf_skb_pull_data)(void *ctx, u32 len) = (void *) BPF_FUNC_skb_pull_data; static int (*bpf_csum_update)(void *ctx, u16 csum) = (void *) BPF_FUNC_csum_update; static int (*bpf_set_hash_invalid)(void *ctx) = (void *) BPF_FUNC_set_hash_invalid; static int (*bpf_get_numa_node_id)(void) = (void *) BPF_FUNC_get_numa_node_id; static int (*bpf_skb_change_head)(void *ctx, u32 len, u64 flags) = (void *) BPF_FUNC_skb_change_head; static int (*bpf_xdp_adjust_head)(void *ctx, int offset) = (void *) BPF_FUNC_xdp_adjust_head; /* llvm builtin functions that eBPF C program may use to * emit BPF_LD_ABS and BPF_LD_IND instructions */ struct sk_buff; unsigned long long load_byte(void *skb, unsigned long long off) asm("llvm.bpf.load.byte"); unsigned long long load_half(void *skb, unsigned long long off) asm("llvm.bpf.load.half"); unsigned long long load_word(void *skb, unsigned long long off) asm("llvm.bpf.load.word"); /* a helper structure used by eBPF C program * to describe map attributes to elf_bpf loader */ struct bpf_map_def { unsigned int type; unsigned int key_size; unsigned int value_size; unsigned int max_entries; }; static int (*bpf_skb_store_bytes)(void *ctx, unsigned long long off, void *from, unsigned long long len, unsigned long long flags) = (void *) BPF_FUNC_skb_store_bytes; static int (*bpf_l3_csum_replace)(void *ctx, unsigned long long off, unsigned long long from, unsigned long long to, unsigned long long flags) = (void *) BPF_FUNC_l3_csum_replace; static int (*bpf_l4_csum_replace)(void *ctx, unsigned long long off, unsigned long long from, unsigned long long to, unsigned long long flags) = (void *) BPF_FUNC_l4_csum_replace; static inline u16 bpf_ntohs(u16 val) { /* will be recognized by gcc into rotate insn and eventually rolw 8 */ return (val << 8) | (val >> 8); } static inline u32 bpf_ntohl(u32 val) { /* gcc will use bswapsi2 insn */ return __builtin_bswap32(val); } static inline u64 bpf_ntohll(u64 val) { /* gcc will use bswapdi2 insn */ return __builtin_bswap64(val); } static inline unsigned __int128 bpf_ntoh128(unsigned __int128 val) { return (((unsigned __int128)bpf_ntohll(val) << 64) | (u64)bpf_ntohll(val >> 64)); } static inline u16 bpf_htons(u16 val) { return bpf_ntohs(val); } static inline u32 bpf_htonl(u32 val) { return bpf_ntohl(val); } static inline u64 bpf_htonll(u64 val) { return bpf_ntohll(val); } static inline unsigned __int128 bpf_hton128(unsigned __int128 val) { return bpf_ntoh128(val); } static inline u64 load_dword(void *skb, u64 off) { return ((u64)load_word(skb, off) << 32) | load_word(skb, off + 4); } void bpf_store_byte(void *skb, u64 off, u64 val) asm("llvm.bpf.store.byte"); void bpf_store_half(void *skb, u64 off, u64 val) asm("llvm.bpf.store.half"); void bpf_store_word(void *skb, u64 off, u64 val) asm("llvm.bpf.store.word"); u64 bpf_pseudo_fd(u64, u64) asm("llvm.bpf.pseudo"); static inline void bpf_store_dword(void *skb, u64 off, u64 val) { bpf_store_word(skb, off, (u32)val); bpf_store_word(skb, off + 4, val >> 32); } #define MASK(_n) ((_n) < 64 ? (1ull << (_n)) - 1 : ((u64)-1LL)) #define MASK128(_n) ((_n) < 128 ? ((unsigned __int128)1 << (_n)) - 1 : ((unsigned __int128)-1)) static inline unsigned int bpf_log2(unsigned int v) { unsigned int r; unsigned int shift; r = (v > 0xFFFF) << 4; v >>= r; shift = (v > 0xFF) << 3; v >>= shift; r |= shift; shift = (v > 0xF) << 2; v >>= shift; r |= shift; shift = (v > 0x3) << 1; v >>= shift; r |= shift; r |= (v >> 1); return r; } static inline unsigned int bpf_log2l(unsigned long v) { unsigned int hi = v >> 32; if (hi) return bpf_log2(hi) + 32 + 1; else return bpf_log2(v) + 1; } struct bpf_context; static inline __attribute__((always_inline)) SEC("helpers") u64 bpf_dext_pkt(void *pkt, u64 off, u64 bofs, u64 bsz) { if (bofs == 0 && bsz == 8) { return load_byte(pkt, off); } else if (bofs + bsz <= 8) { return load_byte(pkt, off) >> (8 - (bofs + bsz)) & MASK(bsz); } else if (bofs == 0 && bsz == 16) { return load_half(pkt, off); } else if (bofs + bsz <= 16) { return load_half(pkt, off) >> (16 - (bofs + bsz)) & MASK(bsz); } else if (bofs == 0 && bsz == 32) { return load_word(pkt, off); } else if (bofs + bsz <= 32) { return load_word(pkt, off) >> (32 - (bofs + bsz)) & MASK(bsz); } else if (bofs == 0 && bsz == 64) { return load_dword(pkt, off); } else if (bofs + bsz <= 64) { return load_dword(pkt, off) >> (64 - (bofs + bsz)) & MASK(bsz); } return 0; } static inline __attribute__((always_inline)) SEC("helpers") void bpf_dins_pkt(void *pkt, u64 off, u64 bofs, u64 bsz, u64 val) { // The load_xxx function does a bswap before returning the short/word/dword, // so the value in register will always be host endian. However, the bytes // written back need to be in network order. if (bofs == 0 && bsz == 8) { bpf_skb_store_bytes(pkt, off, &val, 1, 0); } else if (bofs + bsz <= 8) { u8 v = load_byte(pkt, off); v &= ~(MASK(bsz) << (8 - (bofs + bsz))); v |= ((val & MASK(bsz)) << (8 - (bofs + bsz))); bpf_skb_store_bytes(pkt, off, &v, 1, 0); } else if (bofs == 0 && bsz == 16) { u16 v = bpf_htons(val); bpf_skb_store_bytes(pkt, off, &v, 2, 0); } else if (bofs + bsz <= 16) { u16 v = load_half(pkt, off); v &= ~(MASK(bsz) << (16 - (bofs + bsz))); v |= ((val & MASK(bsz)) << (16 - (bofs + bsz))); v = bpf_htons(v); bpf_skb_store_bytes(pkt, off, &v, 2, 0); } else if (bofs == 0 && bsz == 32) { u32 v = bpf_htonl(val); bpf_skb_store_bytes(pkt, off, &v, 4, 0); } else if (bofs + bsz <= 32) { u32 v = load_word(pkt, off); v &= ~(MASK(bsz) << (32 - (bofs + bsz))); v |= ((val & MASK(bsz)) << (32 - (bofs + bsz))); v = bpf_htonl(v); bpf_skb_store_bytes(pkt, off, &v, 4, 0); } else if (bofs == 0 && bsz == 64) { u64 v = bpf_htonll(val); bpf_skb_store_bytes(pkt, off, &v, 8, 0); } else if (bofs + bsz <= 64) { u64 v = load_dword(pkt, off); v &= ~(MASK(bsz) << (64 - (bofs + bsz))); v |= ((val & MASK(bsz)) << (64 - (bofs + bsz))); v = bpf_htonll(v); bpf_skb_store_bytes(pkt, off, &v, 8, 0); } } static inline __attribute__((always_inline)) SEC("helpers") void * bpf_map_lookup_elem_(uintptr_t map, void *key) { return bpf_map_lookup_elem((void *)map, key); } static inline __attribute__((always_inline)) SEC("helpers") int bpf_map_update_elem_(uintptr_t map, void *key, void *value, u64 flags) { return bpf_map_update_elem((void *)map, key, value, flags); } static inline __attribute__((always_inline)) SEC("helpers") int bpf_map_delete_elem_(uintptr_t map, void *key) { return bpf_map_delete_elem((void *)map, key); } static inline __attribute__((always_inline)) SEC("helpers") int bpf_l3_csum_replace_(void *ctx, u64 off, u64 from, u64 to, u64 flags) { switch (flags & 0xf) { case 2: return bpf_l3_csum_replace(ctx, off, bpf_htons(from), bpf_htons(to), flags); case 4: return bpf_l3_csum_replace(ctx, off, bpf_htonl(from), bpf_htonl(to), flags); case 8: return bpf_l3_csum_replace(ctx, off, bpf_htonll(from), bpf_htonll(to), flags); default: {} } return bpf_l3_csum_replace(ctx, off, from, to, flags); } static inline __attribute__((always_inline)) SEC("helpers") int bpf_l4_csum_replace_(void *ctx, u64 off, u64 from, u64 to, u64 flags) { switch (flags & 0xf) { case 2: return bpf_l4_csum_replace(ctx, off, bpf_htons(from), bpf_htons(to), flags); case 4: return bpf_l4_csum_replace(ctx, off, bpf_htonl(from), bpf_htonl(to), flags); case 8: return bpf_l4_csum_replace(ctx, off, bpf_htonll(from), bpf_htonll(to), flags); default: {} } return bpf_l4_csum_replace(ctx, off, from, to, flags); } int incr_cksum_l3(void *off, u64 oldval, u64 newval) asm("llvm.bpf.extra"); int incr_cksum_l4(void *off, u64 oldval, u64 newval, u64 flags) asm("llvm.bpf.extra"); int bpf_num_cpus() asm("llvm.bpf.extra"); struct pt_regs; int bpf_usdt_readarg(int argc, struct pt_regs *ctx, void *arg) asm("llvm.bpf.extra"); int bpf_usdt_readarg_p(int argc, struct pt_regs *ctx, void *buf, u64 len) asm("llvm.bpf.extra"); #ifdef __powerpc__ #define PT_REGS_PARM1(ctx) ((ctx)->gpr[3]) #define PT_REGS_PARM2(ctx) ((ctx)->gpr[4]) #define PT_REGS_PARM3(ctx) ((ctx)->gpr[5]) #define PT_REGS_PARM4(ctx) ((ctx)->gpr[6]) #define PT_REGS_PARM5(ctx) ((ctx)->gpr[7]) #define PT_REGS_PARM6(ctx) ((ctx)->gpr[8]) #define PT_REGS_RC(ctx) ((ctx)->gpr[3]) #define PT_REGS_IP(ctx) ((ctx)->nip) #define PT_REGS_SP(ctx) ((ctx)->sp) #elif defined(__x86_64__) #define PT_REGS_PARM1(ctx) ((ctx)->di) #define PT_REGS_PARM2(ctx) ((ctx)->si) #define PT_REGS_PARM3(ctx) ((ctx)->dx) #define PT_REGS_PARM4(ctx) ((ctx)->cx) #define PT_REGS_PARM5(ctx) ((ctx)->r8) #define PT_REGS_PARM6(ctx) ((ctx)->r9) #define PT_REGS_RC(ctx) ((ctx)->ax) #define PT_REGS_IP(ctx) ((ctx)->ip) #define PT_REGS_SP(ctx) ((ctx)->sp) #elif defined(__aarch64__) #define PT_REGS_PARM1(x) ((x)->regs[0]) #define PT_REGS_PARM2(x) ((x)->regs[1]) #define PT_REGS_PARM3(x) ((x)->regs[2]) #define PT_REGS_PARM4(x) ((x)->regs[3]) #define PT_REGS_PARM5(x) ((x)->regs[4]) #define PT_REGS_PARM6(x) ((x)->regs[5]) #define PT_REGS_RET(x) ((x)->regs[30]) #define PT_REGS_FP(x) ((x)->regs[29]) /* Works only with CONFIG_FRAME_POINTER */ #define PT_REGS_RC(x) ((x)->regs[0]) #define PT_REGS_SP(x) ((x)->sp) #define PT_REGS_IP(x) ((x)->pc) #else #error "bcc does not support this platform yet" #endif #define lock_xadd(ptr, val) ((void)__sync_fetch_and_add(ptr, val)) #define TRACEPOINT_PROBE(category, event) \ int tracepoint__##category##__##event(struct tracepoint__##category##__##event *args) #define TP_DATA_LOC_READ_CONST(dst, field, length) \ do { \ short __offset = args->data_loc_##field & 0xFFFF; \ bpf_probe_read((void *)dst, length, (char *)args + __offset); \ } while (0); #define TP_DATA_LOC_READ(dst, field) \ do { \ short __offset = args->data_loc_##field & 0xFFFF; \ short __length = args->data_loc_##field >> 16; \ bpf_probe_read((void *)dst, __length, (char *)args + __offset); \ } while (0); #endif )********" bpfcc-0.2.0+git0.02884a026/src/cc/export/proto.h000066400000000000000000000073261305314114400205170ustar00rootroot00000000000000R"********( /* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __BCC_PROTO_H #define __BCC_PROTO_H #include #define BPF_PACKET_HEADER __attribute__((packed)) __attribute__((deprecated("packet"))) struct ethernet_t { unsigned long long dst:48; unsigned long long src:48; unsigned int type:16; } BPF_PACKET_HEADER; struct dot1q_t { unsigned short pri:3; unsigned short cfi:1; unsigned short vlanid:12; unsigned short type; } BPF_PACKET_HEADER; struct arp_t { unsigned short htype; unsigned short ptype; unsigned char hlen; unsigned char plen; unsigned short oper; unsigned long long sha:48; unsigned long long spa:32; unsigned long long tha:48; unsigned int tpa; } BPF_PACKET_HEADER; struct ip_t { unsigned char ver:4; // byte 0 unsigned char hlen:4; unsigned char tos; unsigned short tlen; unsigned short identification; // byte 4 unsigned short ffo_unused:1; unsigned short df:1; unsigned short mf:1; unsigned short foffset:13; unsigned char ttl; // byte 8 unsigned char nextp; unsigned short hchecksum; unsigned int src; // byte 12 unsigned int dst; // byte 16 } BPF_PACKET_HEADER; struct icmp_t { unsigned char type; unsigned char code; unsigned short checksum; } BPF_PACKET_HEADER; struct ip6_t { unsigned int ver:4; unsigned int priority:8; unsigned int flow_label:20; unsigned short payload_len; unsigned char next_header; unsigned char hop_limit; unsigned long long src_hi; unsigned long long src_lo; unsigned long long dst_hi; unsigned long long dst_lo; } BPF_PACKET_HEADER; struct ip6_opt_t { unsigned char next_header; unsigned char ext_len; unsigned char pad[6]; } BPF_PACKET_HEADER; struct icmp6_t { unsigned char type; unsigned char code; unsigned short checksum; } BPF_PACKET_HEADER; struct udp_t { unsigned short sport; unsigned short dport; unsigned short length; unsigned short crc; } BPF_PACKET_HEADER; struct tcp_t { unsigned short src_port; // byte 0 unsigned short dst_port; unsigned int seq_num; // byte 4 unsigned int ack_num; // byte 8 unsigned char offset:4; // byte 12 unsigned char reserved:4; unsigned char flag_cwr:1; unsigned char flag_ece:1; unsigned char flag_urg:1; unsigned char flag_ack:1; unsigned char flag_psh:1; unsigned char flag_rst:1; unsigned char flag_syn:1; unsigned char flag_fin:1; unsigned short rcv_wnd; unsigned short cksum; // byte 16 unsigned short urg_ptr; } BPF_PACKET_HEADER; struct vxlan_t { unsigned int rsv1:4; unsigned int iflag:1; unsigned int rsv2:3; unsigned int rsv3:24; unsigned int key:24; unsigned int rsv4:8; } BPF_PACKET_HEADER; struct vxlan_gbp_t { unsigned int gflag:1; unsigned int rsv1:3; unsigned int iflag:1; unsigned int rsv2:3; unsigned int rsv3:1; unsigned int dflag:1; unsigned int rsv4:1; unsigned int aflag:1; unsigned int rsv5:3; unsigned int tag:16; unsigned int key:24; unsigned int rsv6:8; } BPF_PACKET_HEADER; #endif )********" bpfcc-0.2.0+git0.02884a026/src/cc/exported_files.cc000066400000000000000000000022361305314114400212000ustar00rootroot00000000000000/* * Copyright (c) 2016 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "exported_files.h" using std::map; using std::string; namespace ebpf { // c++11 feature for including raw string literals // see http://www.stroustrup.com/C++11FAQ.html#raw-strings map ExportedFiles::headers_ = { { "/virtual/include/bcc/bpf.h", #include "compat/linux/virtual_bpf.h" }, { "/virtual/include/bcc/proto.h", #include "export/proto.h" }, { "/virtual/include/bcc/helpers.h", #include "export/helpers.h" }, { "/virtual/lib/clang/include/stdarg.h", #include "clang/include/stdarg.h" }, }; } bpfcc-0.2.0+git0.02884a026/src/cc/exported_files.h000066400000000000000000000015111305314114400210350ustar00rootroot00000000000000/* * Copyright (c) 2016 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include namespace ebpf { class ExportedFiles { static std::map headers_; public: static const std::map & headers() { return headers_; } }; } bpfcc-0.2.0+git0.02884a026/src/cc/frontends/000077500000000000000000000000001305314114400176545ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/CMakeLists.txt000066400000000000000000000002151305314114400224120ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") add_subdirectory(b) add_subdirectory(clang) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/000077500000000000000000000000001305314114400200755ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/CMakeLists.txt000066400000000000000000000014041305314114400226340ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") include_directories(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) BISON_TARGET(Parser parser.yy ${CMAKE_CURRENT_BINARY_DIR}/parser.yy.cc COMPILE_FLAGS "-o parser.yy.cc -v --debug") FLEX_TARGET(Lexer lexer.ll ${CMAKE_CURRENT_BINARY_DIR}/lexer.ll.cc COMPILE_FLAGS "--c++ --o lexer.ll.cc") ADD_FLEX_BISON_DEPENDENCY(Lexer Parser) if (CMAKE_C_COMPILER_ID STREQUAL "Clang") set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/lexer.ll.cc PROPERTIES COMPILE_FLAGS "-Wno-deprecated-register") endif() add_library(b_frontend loader.cc codegen_llvm.cc node.cc parser.cc printer.cc type_check.cc ${BISON_Parser_OUTPUTS} ${FLEX_Lexer_OUTPUTS}) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/codegen_llvm.cc000066400000000000000000001406171305314114400230530ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "bcc_exception.h" #include "codegen_llvm.h" #include "lexer.h" #include "table_desc.h" #include "type_helper.h" #include "linux/bpf.h" #include "libbpf.h" namespace ebpf { namespace cc { using namespace llvm; using std::for_each; using std::make_tuple; using std::map; using std::pair; using std::set; using std::string; using std::stringstream; using std::to_string; using std::vector; // can't forward declare IRBuilder in .h file (template with default // parameters), so cast it instead :( #define B (*((IRBuilder<> *)this->b_)) // Helper class to push/pop the insert block class BlockStack { public: explicit BlockStack(CodegenLLVM *cc, BasicBlock *bb) : old_bb_(cc->b_->GetInsertBlock()), cc_(cc) { cc_->b_->SetInsertPoint(bb); } ~BlockStack() { if (old_bb_) cc_->b_->SetInsertPoint(old_bb_); else cc_->b_->ClearInsertionPoint(); } private: BasicBlock *old_bb_; CodegenLLVM *cc_; }; // Helper class to push/pop switch statement insert block class SwitchStack { public: explicit SwitchStack(CodegenLLVM *cc, SwitchInst *sw) : old_sw_(cc->cur_switch_), cc_(cc) { cc_->cur_switch_ = sw; } ~SwitchStack() { cc_->cur_switch_ = old_sw_; } private: SwitchInst *old_sw_; CodegenLLVM *cc_; }; CodegenLLVM::CodegenLLVM(llvm::Module *mod, Scopes *scopes, Scopes *proto_scopes) : out_(stdout), mod_(mod), indent_(0), tmp_reg_index_(0), scopes_(scopes), proto_scopes_(proto_scopes), expr_(nullptr) { b_ = new IRBuilder<>(ctx()); } CodegenLLVM::~CodegenLLVM() { delete b_; } template void CodegenLLVM::emit(const char *fmt, Args&&... params) { //fprintf(out_, fmt, std::forward(params)...); //fflush(out_); } void CodegenLLVM::emit(const char *s) { //fprintf(out_, "%s", s); //fflush(out_); } StatusTuple CodegenLLVM::visit_block_stmt_node(BlockStmtNode *n) { // enter scope if (n->scope_) scopes_->push_var(n->scope_); if (!n->stmts_.empty()) { for (auto it = n->stmts_.begin(); it != n->stmts_.end(); ++it) TRY2((*it)->accept(this)); } // exit scope if (n->scope_) scopes_->pop_var(); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_if_stmt_node(IfStmtNode *n) { Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_then = BasicBlock::Create(ctx(), "if.then", parent); BasicBlock *label_else = n->false_block_ ? BasicBlock::Create(ctx(), "if.else", parent) : nullptr; BasicBlock *label_end = BasicBlock::Create(ctx(), "if.end", parent); TRY2(n->cond_->accept(this)); Value *is_not_null = B.CreateIsNotNull(pop_expr()); if (n->false_block_) B.CreateCondBr(is_not_null, label_then, label_else); else B.CreateCondBr(is_not_null, label_then, label_end); { BlockStack bstack(this, label_then); TRY2(n->true_block_->accept(this)); if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } if (n->false_block_) { BlockStack bstack(this, label_else); TRY2(n->false_block_->accept(this)); if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } B.SetInsertPoint(label_end); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_onvalid_stmt_node(OnValidStmtNode *n) { TRY2(n->cond_->accept(this)); Value *is_null = B.CreateIsNotNull(pop_expr()); Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_then = BasicBlock::Create(ctx(), "onvalid.then", parent); BasicBlock *label_else = n->else_block_ ? BasicBlock::Create(ctx(), "onvalid.else", parent) : nullptr; BasicBlock *label_end = BasicBlock::Create(ctx(), "onvalid.end", parent); if (n->else_block_) B.CreateCondBr(is_null, label_then, label_else); else B.CreateCondBr(is_null, label_then, label_end); { BlockStack bstack(this, label_then); TRY2(n->block_->accept(this)); if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } if (n->else_block_) { BlockStack bstack(this, label_else); TRY2(n->else_block_->accept(this)); if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } B.SetInsertPoint(label_end); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_switch_stmt_node(SwitchStmtNode *n) { Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_default = BasicBlock::Create(ctx(), "switch.default", parent); BasicBlock *label_end = BasicBlock::Create(ctx(), "switch.end", parent); // switch (cond) TRY2(n->cond_->accept(this)); SwitchInst *switch_inst = B.CreateSwitch(pop_expr(), label_default); B.SetInsertPoint(label_end); { // case 1..N SwitchStack sstack(this, switch_inst); TRY2(n->block_->accept(this)); } // if other cases are terminal, erase the end label if (pred_empty(label_end)) { B.SetInsertPoint(resolve_label("DONE")); label_end->eraseFromParent(); } return StatusTuple(0); } StatusTuple CodegenLLVM::visit_case_stmt_node(CaseStmtNode *n) { if (!cur_switch_) return mkstatus_(n, "no valid switch instruction"); Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_end = B.GetInsertBlock(); BasicBlock *dest; if (n->value_) { TRY2(n->value_->accept(this)); dest = BasicBlock::Create(ctx(), "switch.case", parent); Value *cond = B.CreateIntCast(pop_expr(), cur_switch_->getCondition()->getType(), false); cur_switch_->addCase(cast(cond), dest); } else { dest = cur_switch_->getDefaultDest(); } { BlockStack bstack(this, dest); TRY2(n->block_->accept(this)); // if no trailing goto, fall to end if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } return StatusTuple(0); } StatusTuple CodegenLLVM::visit_ident_expr_node(IdentExprNode *n) { if (!n->decl_) return mkstatus_(n, "variable lookup failed: %s", n->name_.c_str()); if (n->decl_->is_pointer()) { if (n->sub_name_.size()) { if (n->bitop_) { // ident is holding a host endian number, don't use dext if (n->is_lhs()) { emit("%s%s->%s", n->decl_->scope_id(), n->c_str(), n->sub_name_.c_str()); } else { emit("(((%s%s->%s) >> %d) & (((%s)1 << %d) - 1))", n->decl_->scope_id(), n->c_str(), n->sub_name_.c_str(), n->bitop_->bit_offset_, bits_to_uint(n->bitop_->bit_width_ + 1), n->bitop_->bit_width_); } return mkstatus_(n, "unsupported"); } else { if (n->struct_type_->id_->name_ == "_Packet" && n->sub_name_.substr(0, 3) == "arg") { // convert arg1~arg8 into args[0]~args[7] assuming type_check verified the range already auto arg_num = stoi(n->sub_name_.substr(3, 3)); if (arg_num < 5) { emit("%s%s->args_lo[%d]", n->decl_->scope_id(), n->c_str(), arg_num - 1); } else { emit("%s%s->args_hi[%d]", n->decl_->scope_id(), n->c_str(), arg_num - 5); } return mkstatus_(n, "unsupported"); } else { emit("%s%s->%s", n->decl_->scope_id(), n->c_str(), n->sub_name_.c_str()); auto it = vars_.find(n->decl_); if (it == vars_.end()) return mkstatus_(n, "Cannot locate variable %s in vars_ table", n->c_str()); LoadInst *load_1 = B.CreateLoad(it->second); vector indices({B.getInt32(0), B.getInt32(n->sub_decl_->slot_)}); expr_ = B.CreateInBoundsGEP(load_1, indices); if (!n->is_lhs()) expr_ = B.CreateLoad(pop_expr()); } } } else { auto it = vars_.find(n->decl_); if (it == vars_.end()) return mkstatus_(n, "Cannot locate variable %s in vars_ table", n->c_str()); expr_ = n->is_lhs() ? it->second : (Value *)B.CreateLoad(it->second); } } else { if (n->sub_name_.size()) { emit("%s%s.%s", n->decl_->scope_id(), n->c_str(), n->sub_name_.c_str()); auto it = vars_.find(n->decl_); if (it == vars_.end()) return mkstatus_(n, "Cannot locate variable %s in vars_ table", n->c_str()); vector indices({const_int(0), const_int(n->sub_decl_->slot_, 32)}); expr_ = B.CreateGEP(nullptr, it->second, indices); if (!n->is_lhs()) expr_ = B.CreateLoad(pop_expr()); } else { if (n->bitop_) { // ident is holding a host endian number, don't use dext if (n->is_lhs()) return mkstatus_(n, "illegal: ident %s is a left-hand-side type", n->name_.c_str()); if (n->decl_->is_struct()) return mkstatus_(n, "illegal: can only take bitop of a struct subfield"); emit("(((%s%s) >> %d) & (((%s)1 << %d) - 1))", n->decl_->scope_id(), n->c_str(), n->bitop_->bit_offset_, bits_to_uint(n->bitop_->bit_width_ + 1), n->bitop_->bit_width_); } else { emit("%s%s", n->decl_->scope_id(), n->c_str()); auto it = vars_.find(n->decl_); if (it == vars_.end()) return mkstatus_(n, "Cannot locate variable %s in vars_ table", n->c_str()); if (n->is_lhs() || n->decl_->is_struct()) expr_ = it->second; else expr_ = B.CreateLoad(it->second); } } } return StatusTuple(0); } StatusTuple CodegenLLVM::visit_assign_expr_node(AssignExprNode *n) { if (n->bitop_) { TRY2(n->lhs_->accept(this)); emit(" = ("); TRY2(n->lhs_->accept(this)); emit(" & ~((((%s)1 << %d) - 1) << %d)) | (", bits_to_uint(n->lhs_->bit_width_), n->bitop_->bit_width_, n->bitop_->bit_offset_); TRY2(n->rhs_->accept(this)); emit(" << %d)", n->bitop_->bit_offset_); return mkstatus_(n, "unsupported"); } else { if (n->lhs_->flags_[ExprNode::PROTO]) { // auto f = n->lhs_->struct_type_->field(n->id_->sub_name_); // emit("bpf_dins(%s%s + %zu, %zu, %zu, ", n->id_->decl_->scope_id(), n->id_->c_str(), // f->bit_offset_ >> 3, f->bit_offset_ & 0x7, f->bit_width_); // TRY2(n->rhs_->accept(this)); // emit(")"); return mkstatus_(n, "unsupported"); } else { TRY2(n->rhs_->accept(this)); if (n->lhs_->is_pkt()) { TRY2(n->lhs_->accept(this)); } else { Value *rhs = pop_expr(); TRY2(n->lhs_->accept(this)); Value *lhs = pop_expr(); if (!n->rhs_->is_ref()) rhs = B.CreateIntCast(rhs, cast(lhs->getType())->getElementType(), false); B.CreateStore(rhs, lhs); } } } return StatusTuple(0); } StatusTuple CodegenLLVM::lookup_var(Node *n, const string &name, Scopes::VarScope *scope, VariableDeclStmtNode **decl, Value **mem) const { *decl = scope->lookup(name, SCOPE_GLOBAL); if (!*decl) return mkstatus_(n, "cannot find %s variable", name.c_str()); auto it = vars_.find(*decl); if (it == vars_.end()) return mkstatus_(n, "unable to find %s memory location", name.c_str()); *mem = it->second; return StatusTuple(0); } StatusTuple CodegenLLVM::visit_packet_expr_node(PacketExprNode *n) { auto p = proto_scopes_->top_struct()->lookup(n->id_->name_, true); VariableDeclStmtNode *offset_decl, *skb_decl; Value *offset_mem, *skb_mem; TRY2(lookup_var(n, "skb", scopes_->current_var(), &skb_decl, &skb_mem)); TRY2(lookup_var(n, "$" + n->id_->name_, scopes_->current_var(), &offset_decl, &offset_mem)); if (p) { auto f = p->field(n->id_->sub_name_); if (f) { size_t bit_offset = f->bit_offset_; size_t bit_width = f->bit_width_; if (n->bitop_) { bit_offset += f->bit_width_ - (n->bitop_->bit_offset_ + n->bitop_->bit_width_); bit_width = std::min(bit_width - n->bitop_->bit_offset_, n->bitop_->bit_width_); } if (n->is_ref()) { // e.g.: @ip.hchecksum, return offset of the header within packet LoadInst *offset_ptr = B.CreateLoad(offset_mem); Value *skb_hdr_offset = B.CreateAdd(offset_ptr, B.getInt64(bit_offset >> 3)); expr_ = B.CreateIntCast(skb_hdr_offset, B.getInt64Ty(), false); } else if (n->is_lhs()) { emit("bpf_dins_pkt(pkt, %s + %zu, %zu, %zu, ", n->id_->c_str(), bit_offset >> 3, bit_offset & 0x7, bit_width); Function *store_fn = mod_->getFunction("bpf_dins_pkt"); if (!store_fn) return mkstatus_(n, "unable to find function bpf_dins_pkt"); LoadInst *skb_ptr = B.CreateLoad(skb_mem); Value *skb_ptr8 = B.CreateBitCast(skb_ptr, B.getInt8PtrTy()); LoadInst *offset_ptr = B.CreateLoad(offset_mem); Value *skb_hdr_offset = B.CreateAdd(offset_ptr, B.getInt64(bit_offset >> 3)); Value *rhs = B.CreateIntCast(pop_expr(), B.getInt64Ty(), false); B.CreateCall(store_fn, vector({skb_ptr8, skb_hdr_offset, B.getInt64(bit_offset & 0x7), B.getInt64(bit_width), rhs})); } else { emit("bpf_dext_pkt(pkt, %s + %zu, %zu, %zu)", n->id_->c_str(), bit_offset >> 3, bit_offset & 0x7, bit_width); Function *load_fn = mod_->getFunction("bpf_dext_pkt"); if (!load_fn) return mkstatus_(n, "unable to find function bpf_dext_pkt"); LoadInst *skb_ptr = B.CreateLoad(skb_mem); Value *skb_ptr8 = B.CreateBitCast(skb_ptr, B.getInt8PtrTy()); LoadInst *offset_ptr = B.CreateLoad(offset_mem); Value *skb_hdr_offset = B.CreateAdd(offset_ptr, B.getInt64(bit_offset >> 3)); expr_ = B.CreateCall(load_fn, vector({skb_ptr8, skb_hdr_offset, B.getInt64(bit_offset & 0x7), B.getInt64(bit_width)})); // this generates extra trunc insns whereas the bpf.load fns already // trunc the values internally in the bpf interpeter //expr_ = B.CreateTrunc(pop_expr(), B.getIntNTy(bit_width)); } } else { emit("pkt->start + pkt->offset + %s", n->id_->c_str()); return mkstatus_(n, "unsupported"); } } return StatusTuple(0); } StatusTuple CodegenLLVM::visit_integer_expr_node(IntegerExprNode *n) { APInt val; StringRef(n->val_).getAsInteger(0, val); expr_ = ConstantInt::get(mod_->getContext(), val); if (n->bits_) expr_ = B.CreateIntCast(expr_, B.getIntNTy(n->bits_), false); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_string_expr_node(StringExprNode *n) { if (n->is_lhs()) return mkstatus_(n, "cannot assign to a string"); Value *global = B.CreateGlobalString(n->val_); Value *ptr = new AllocaInst(B.getInt8Ty(), B.getInt64(n->val_.size() + 1), "", resolve_entry_stack()); B.CreateMemCpy(ptr, global, n->val_.size() + 1, 1); expr_ = ptr; return StatusTuple(0); } StatusTuple CodegenLLVM::emit_short_circuit_and(BinopExprNode *n) { Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_start = B.GetInsertBlock(); BasicBlock *label_then = BasicBlock::Create(ctx(), "and.then", parent); BasicBlock *label_end = BasicBlock::Create(ctx(), "and.end", parent); TRY2(n->lhs_->accept(this)); Value *neq_zero = B.CreateICmpNE(pop_expr(), B.getIntN(n->lhs_->bit_width_, 0)); B.CreateCondBr(neq_zero, label_then, label_end); { BlockStack bstack(this, label_then); TRY2(n->rhs_->accept(this)); expr_ = B.CreateICmpNE(pop_expr(), B.getIntN(n->rhs_->bit_width_, 0)); B.CreateBr(label_end); } B.SetInsertPoint(label_end); PHINode *phi = B.CreatePHI(B.getInt1Ty(), 2); phi->addIncoming(B.getFalse(), label_start); phi->addIncoming(pop_expr(), label_then); expr_ = phi; return StatusTuple(0); } StatusTuple CodegenLLVM::emit_short_circuit_or(BinopExprNode *n) { Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_start = B.GetInsertBlock(); BasicBlock *label_then = BasicBlock::Create(ctx(), "or.then", parent); BasicBlock *label_end = BasicBlock::Create(ctx(), "or.end", parent); TRY2(n->lhs_->accept(this)); Value *neq_zero = B.CreateICmpNE(pop_expr(), B.getIntN(n->lhs_->bit_width_, 0)); B.CreateCondBr(neq_zero, label_end, label_then); { BlockStack bstack(this, label_then); TRY2(n->rhs_->accept(this)); expr_ = B.CreateICmpNE(pop_expr(), B.getIntN(n->rhs_->bit_width_, 0)); B.CreateBr(label_end); } B.SetInsertPoint(label_end); PHINode *phi = B.CreatePHI(B.getInt1Ty(), 2); phi->addIncoming(B.getTrue(), label_start); phi->addIncoming(pop_expr(), label_then); expr_ = phi; return StatusTuple(0); } StatusTuple CodegenLLVM::visit_binop_expr_node(BinopExprNode *n) { if (n->op_ == Tok::TAND) return emit_short_circuit_and(n); if (n->op_ == Tok::TOR) return emit_short_circuit_or(n); TRY2(n->lhs_->accept(this)); Value *lhs = pop_expr(); TRY2(n->rhs_->accept(this)); Value *rhs = B.CreateIntCast(pop_expr(), lhs->getType(), false); switch (n->op_) { case Tok::TCEQ: expr_ = B.CreateICmpEQ(lhs, rhs); break; case Tok::TCNE: expr_ = B.CreateICmpNE(lhs, rhs); break; case Tok::TXOR: expr_ = B.CreateXor(lhs, rhs); break; case Tok::TMOD: expr_ = B.CreateURem(lhs, rhs); break; case Tok::TCLT: expr_ = B.CreateICmpULT(lhs, rhs); break; case Tok::TCLE: expr_ = B.CreateICmpULE(lhs, rhs); break; case Tok::TCGT: expr_ = B.CreateICmpUGT(lhs, rhs); break; case Tok::TCGE: expr_ = B.CreateICmpUGE(lhs, rhs); break; case Tok::TPLUS: expr_ = B.CreateAdd(lhs, rhs); break; case Tok::TMINUS: expr_ = B.CreateSub(lhs, rhs); break; case Tok::TLAND: expr_ = B.CreateAnd(lhs, rhs); break; case Tok::TLOR: expr_ = B.CreateOr(lhs, rhs); break; default: return mkstatus_(n, "unsupported binary operator"); } return StatusTuple(0); } StatusTuple CodegenLLVM::visit_unop_expr_node(UnopExprNode *n) { TRY2(n->expr_->accept(this)); switch (n->op_) { case Tok::TNOT: expr_ = B.CreateNot(pop_expr()); break; case Tok::TCMPL: expr_ = B.CreateNeg(pop_expr()); break; default: {} } return StatusTuple(0); } StatusTuple CodegenLLVM::visit_bitop_expr_node(BitopExprNode *n) { return StatusTuple(0); } StatusTuple CodegenLLVM::visit_goto_expr_node(GotoExprNode *n) { if (n->id_->name_ == "DONE") { return mkstatus_(n, "use return statement instead"); } string jump_label; // when dealing with multistates, goto statements may be overridden auto rewrite_it = proto_rewrites_.find(n->id_->full_name()); auto default_it = proto_rewrites_.find(""); if (rewrite_it != proto_rewrites_.end()) { jump_label = rewrite_it->second; } else if (default_it != proto_rewrites_.end()) { jump_label = default_it->second; } else { auto state = scopes_->current_state()->lookup(n->id_->full_name(), false); if (state) { jump_label = state->scoped_name(); if (n->is_continue_) { jump_label += "_continue"; } } else { state = scopes_->current_state()->lookup("EOP", false); if (state) { jump_label = state->scoped_name(); } } } B.CreateBr(resolve_label(jump_label)); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_return_expr_node(ReturnExprNode *n) { TRY2(n->expr_->accept(this)); Function *parent = B.GetInsertBlock()->getParent(); Value *cast_1 = B.CreateIntCast(pop_expr(), parent->getReturnType(), true); B.CreateStore(cast_1, retval_); B.CreateBr(resolve_label("DONE")); return StatusTuple(0); } StatusTuple CodegenLLVM::emit_table_lookup(MethodCallExprNode *n) { TableDeclStmtNode* table = scopes_->top_table()->lookup(n->id_->name_); IdentExprNode* arg0 = static_cast(n->args_.at(0).get()); IdentExprNode* arg1; StructVariableDeclStmtNode* arg1_type; auto table_fd_it = table_fds_.find(table); if (table_fd_it == table_fds_.end()) return mkstatus_(n, "unable to find table %s in table_fds_", n->id_->c_str()); Function *pseudo_fn = mod_->getFunction("llvm.bpf.pseudo"); if (!pseudo_fn) return mkstatus_(n, "pseudo fd loader doesn't exist"); Function *lookup_fn = mod_->getFunction("bpf_map_lookup_elem_"); if (!lookup_fn) return mkstatus_(n, "bpf_map_lookup_elem_ undefined"); CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; TRY2(arg0->accept(this)); Value *key_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); expr_ = B.CreateCall(lookup_fn, vector({pseudo_map_fd, key_ptr})); if (table->type_id()->name_ == "FIXED_MATCH" || table->type_id()->name_ == "INDEXED") { if (n->args_.size() == 2) { arg1 = static_cast(n->args_.at(1).get()); arg1_type = static_cast(arg1->decl_); if (table->leaf_id()->name_ != arg1_type->struct_id_->name_) { return mkstatus_(n, "lookup pointer type mismatch %s != %s", table->leaf_id()->c_str(), arg1_type->struct_id_->c_str()); } auto it = vars_.find(arg1_type); if (it == vars_.end()) return mkstatus_(n, "Cannot locate variable %s in vars_ table", n->id_->c_str()); expr_ = B.CreateBitCast(pop_expr(), cast(it->second->getType())->getElementType()); B.CreateStore(pop_expr(), it->second); } } else { return mkstatus_(n, "lookup in table type %s unsupported", table->type_id()->c_str()); } return StatusTuple(0); } StatusTuple CodegenLLVM::emit_table_update(MethodCallExprNode *n) { TableDeclStmtNode* table = scopes_->top_table()->lookup(n->id_->name_); IdentExprNode* arg0 = static_cast(n->args_.at(0).get()); IdentExprNode* arg1 = static_cast(n->args_.at(1).get()); auto table_fd_it = table_fds_.find(table); if (table_fd_it == table_fds_.end()) return mkstatus_(n, "unable to find table %s in table_fds_", n->id_->c_str()); Function *pseudo_fn = mod_->getFunction("llvm.bpf.pseudo"); if (!pseudo_fn) return mkstatus_(n, "pseudo fd loader doesn't exist"); Function *update_fn = mod_->getFunction("bpf_map_update_elem_"); if (!update_fn) return mkstatus_(n, "bpf_map_update_elem_ undefined"); CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; TRY2(arg0->accept(this)); Value *key_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); if (table->type_id()->name_ == "FIXED_MATCH" || table->type_id()->name_ == "INDEXED") { TRY2(arg1->accept(this)); Value *value_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); expr_ = B.CreateCall(update_fn, vector({pseudo_map_fd, key_ptr, value_ptr, B.getInt64(BPF_ANY)})); } else { return mkstatus_(n, "unsupported"); } return StatusTuple(0); } StatusTuple CodegenLLVM::emit_table_delete(MethodCallExprNode *n) { TableDeclStmtNode* table = scopes_->top_table()->lookup(n->id_->name_); IdentExprNode* arg0 = static_cast(n->args_.at(0).get()); auto table_fd_it = table_fds_.find(table); if (table_fd_it == table_fds_.end()) return mkstatus_(n, "unable to find table %s in table_fds_", n->id_->c_str()); Function *pseudo_fn = mod_->getFunction("llvm.bpf.pseudo"); if (!pseudo_fn) return mkstatus_(n, "pseudo fd loader doesn't exist"); Function *update_fn = mod_->getFunction("bpf_map_update_elem_"); if (!update_fn) return mkstatus_(n, "bpf_map_update_elem_ undefined"); CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; TRY2(arg0->accept(this)); Value *key_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); if (table->type_id()->name_ == "FIXED_MATCH" || table->type_id()->name_ == "INDEXED") { expr_ = B.CreateCall(update_fn, vector({pseudo_map_fd, key_ptr})); } else { return mkstatus_(n, "unsupported"); } return StatusTuple(0); } StatusTuple CodegenLLVM::emit_log(MethodCallExprNode *n) { vector args; auto arg = n->args_.begin(); TRY2((*arg)->accept(this)); args.push_back(pop_expr()); args.push_back(B.getInt64(((*arg)->bit_width_ >> 3) + 1)); ++arg; for (; arg != n->args_.end(); ++arg) { TRY2((*arg)->accept(this)); args.push_back(pop_expr()); } // int bpf_trace_printk(fmt, sizeof(fmt), ...) FunctionType *printk_fn_type = FunctionType::get(B.getInt32Ty(), vector({B.getInt8PtrTy(), B.getInt64Ty()}), true); Value *printk_fn = B.CreateIntToPtr(B.getInt64(BPF_FUNC_trace_printk), PointerType::getUnqual(printk_fn_type)); expr_ = B.CreateCall(printk_fn, args); return StatusTuple(0); } StatusTuple CodegenLLVM::emit_packet_rewrite_field(MethodCallExprNode *n) { TRY2(n->args_[1]->accept(this)); TRY2(n->args_[0]->accept(this)); return StatusTuple(0); } StatusTuple CodegenLLVM::emit_atomic_add(MethodCallExprNode *n) { TRY2(n->args_[0]->accept(this)); Value *lhs = B.CreateBitCast(pop_expr(), Type::getInt64PtrTy(ctx())); TRY2(n->args_[1]->accept(this)); Value *rhs = B.CreateSExt(pop_expr(), B.getInt64Ty()); AtomicRMWInst *atomic_inst = B.CreateAtomicRMW( AtomicRMWInst::Add, lhs, rhs, AtomicOrdering::SequentiallyConsistent); atomic_inst->setVolatile(false); return StatusTuple(0); } StatusTuple CodegenLLVM::emit_incr_cksum(MethodCallExprNode *n, size_t sz) { Value *is_pseudo; string csum_fn_str; if (n->args_.size() == 4) { TRY2(n->args_[3]->accept(this)); is_pseudo = B.CreateIntCast(B.CreateIsNotNull(pop_expr()), B.getInt64Ty(), false); csum_fn_str = "bpf_l4_csum_replace_"; } else { is_pseudo = B.getInt64(0); csum_fn_str = "bpf_l3_csum_replace_"; } TRY2(n->args_[2]->accept(this)); Value *new_val = B.CreateZExt(pop_expr(), B.getInt64Ty()); TRY2(n->args_[1]->accept(this)); Value *old_val = B.CreateZExt(pop_expr(), B.getInt64Ty()); TRY2(n->args_[0]->accept(this)); Value *offset = B.CreateZExt(pop_expr(), B.getInt64Ty()); Function *csum_fn = mod_->getFunction(csum_fn_str); if (!csum_fn) return mkstatus_(n, "Undefined built-in %s", csum_fn_str.c_str()); // flags = (is_pseudo << 4) | sizeof(old_val) Value *flags_lower = B.getInt64(sz ? sz : bits_to_size(n->args_[1]->bit_width_)); Value *flags_upper = B.CreateShl(is_pseudo, B.getInt64(4)); Value *flags = B.CreateOr(flags_upper, flags_lower); VariableDeclStmtNode *skb_decl; Value *skb_mem; TRY2(lookup_var(n, "skb", scopes_->current_var(), &skb_decl, &skb_mem)); LoadInst *skb_ptr = B.CreateLoad(skb_mem); Value *skb_ptr8 = B.CreateBitCast(skb_ptr, B.getInt8PtrTy()); expr_ = B.CreateCall(csum_fn, vector({skb_ptr8, offset, old_val, new_val, flags})); return StatusTuple(0); } StatusTuple CodegenLLVM::emit_get_usec_time(MethodCallExprNode *n) { return StatusTuple(0); } StatusTuple CodegenLLVM::visit_method_call_expr_node(MethodCallExprNode *n) { if (n->id_->sub_name_.size()) { if (n->id_->sub_name_ == "lookup") { TRY2(emit_table_lookup(n)); } else if (n->id_->sub_name_ == "update") { TRY2(emit_table_update(n)); } else if (n->id_->sub_name_ == "delete") { TRY2(emit_table_delete(n)); } else if (n->id_->sub_name_ == "rewrite_field" && n->id_->name_ == "pkt") { TRY2(emit_packet_rewrite_field(n)); } } else if (n->id_->name_ == "atomic_add") { TRY2(emit_atomic_add(n)); } else if (n->id_->name_ == "log") { TRY2(emit_log(n)); } else if (n->id_->name_ == "incr_cksum") { TRY2(emit_incr_cksum(n)); } else if (n->id_->name_ == "get_usec_time") { TRY2(emit_get_usec_time(n)); } else { return mkstatus_(n, "unsupported"); } TRY2(n->block_->accept(this)); return StatusTuple(0); } /* result = lookup(key) * if (!result) { * update(key, {0}, BPF_NOEXIST) * result = lookup(key) * } */ StatusTuple CodegenLLVM::visit_table_index_expr_node(TableIndexExprNode *n) { auto table_fd_it = table_fds_.find(n->table_); if (table_fd_it == table_fds_.end()) return mkstatus_(n, "unable to find table %s in table_fds_", n->id_->c_str()); Function *pseudo_fn = mod_->getFunction("llvm.bpf.pseudo"); if (!pseudo_fn) return mkstatus_(n, "pseudo fd loader doesn't exist"); Function *update_fn = mod_->getFunction("bpf_map_update_elem_"); if (!update_fn) return mkstatus_(n, "bpf_map_update_elem_ undefined"); Function *lookup_fn = mod_->getFunction("bpf_map_lookup_elem_"); if (!lookup_fn) return mkstatus_(n, "bpf_map_lookup_elem_ undefined"); StructType *leaf_type; TRY2(lookup_struct_type(n->table_->leaf_type_, &leaf_type)); PointerType *leaf_ptype = PointerType::getUnqual(leaf_type); CallInst *pseudo_call = B.CreateCall(pseudo_fn, vector({B.getInt64(BPF_PSEUDO_MAP_FD), B.getInt64(table_fd_it->second)})); Value *pseudo_map_fd = pseudo_call; TRY2(n->index_->accept(this)); Value *key_ptr = B.CreateBitCast(pop_expr(), B.getInt8PtrTy()); // result = lookup(key) Value *lookup1 = B.CreateBitCast(B.CreateCall(lookup_fn, vector({pseudo_map_fd, key_ptr})), leaf_ptype); Value *result = nullptr; if (n->table_->policy_id()->name_ == "AUTO") { Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_start = B.GetInsertBlock(); BasicBlock *label_then = BasicBlock::Create(ctx(), n->id_->name_ + "[].then", parent); BasicBlock *label_end = BasicBlock::Create(ctx(), n->id_->name_ + "[].end", parent); Value *eq_zero = B.CreateIsNull(lookup1); B.CreateCondBr(eq_zero, label_then, label_end); B.SetInsertPoint(label_then); // var Leaf leaf {0} Value *leaf_ptr = B.CreateBitCast(new AllocaInst(leaf_type, "", resolve_entry_stack()), B.getInt8PtrTy()); B.CreateMemSet(leaf_ptr, B.getInt8(0), B.getInt64(n->table_->leaf_id()->bit_width_ >> 3), 1); // update(key, leaf) B.CreateCall(update_fn, vector({pseudo_map_fd, key_ptr, leaf_ptr, B.getInt64(BPF_NOEXIST)})); // result = lookup(key) Value *lookup2 = B.CreateBitCast(B.CreateCall(lookup_fn, vector({pseudo_map_fd, key_ptr})), leaf_ptype); B.CreateBr(label_end); B.SetInsertPoint(label_end); PHINode *phi = B.CreatePHI(leaf_ptype, 2); phi->addIncoming(lookup1, label_start); phi->addIncoming(lookup2, label_then); result = phi; } else if (n->table_->policy_id()->name_ == "NONE") { result = lookup1; } if (n->is_lhs()) { if (n->sub_decl_) { Type *ptr_type = PointerType::getUnqual(B.getIntNTy(n->sub_decl_->bit_width_)); // u64 *errval -> uN *errval Value *err_cast = B.CreateBitCast(errval_, ptr_type); // if valid then &field, else &errval Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_start = B.GetInsertBlock(); BasicBlock *label_then = BasicBlock::Create(ctx(), n->id_->name_ + "[]field.then", parent); BasicBlock *label_end = BasicBlock::Create(ctx(), n->id_->name_ + "[]field.end", parent); if (1) { // the PHI implementation of this doesn't load, maybe eBPF limitation? B.CreateCondBr(B.CreateIsNull(result), label_then, label_end); B.SetInsertPoint(label_then); B.CreateStore(B.getInt32(2), retval_); B.CreateBr(resolve_label("DONE")); B.SetInsertPoint(label_end); vector indices({B.getInt32(0), B.getInt32(n->sub_decl_->slot_)}); expr_ = B.CreateInBoundsGEP(result, indices); } else { B.CreateCondBr(B.CreateIsNotNull(result), label_then, label_end); B.SetInsertPoint(label_then); vector indices({B.getInt32(0), B.getInt32(n->sub_decl_->slot_)}); Value *field = B.CreateInBoundsGEP(result, indices); B.CreateBr(label_end); B.SetInsertPoint(label_end); PHINode *phi = B.CreatePHI(ptr_type, 2); phi->addIncoming(err_cast, label_start); phi->addIncoming(field, label_then); expr_ = phi; } } else { return mkstatus_(n, "unsupported"); } } else { expr_ = result; } return StatusTuple(0); } /// on_match StatusTuple CodegenLLVM::visit_match_decl_stmt_node(MatchDeclStmtNode *n) { if (n->formals_.size() != 1) return mkstatus_(n, "on_match expected 1 arguments, %zu given", n->formals_.size()); StructVariableDeclStmtNode* leaf_n = static_cast(n->formals_.at(0).get()); if (!leaf_n) return mkstatus_(n, "invalid parameter type"); // lookup result variable auto result_decl = scopes_->current_var()->lookup("_result", false); if (!result_decl) return mkstatus_(n, "unable to find _result built-in"); auto result = vars_.find(result_decl); if (result == vars_.end()) return mkstatus_(n, "unable to find memory for _result built-in"); vars_[leaf_n] = result->second; Value *load_1 = B.CreateLoad(result->second); Value *is_null = B.CreateIsNotNull(load_1); Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_then = BasicBlock::Create(ctx(), "onvalid.then", parent); BasicBlock *label_end = BasicBlock::Create(ctx(), "onvalid.end", parent); B.CreateCondBr(is_null, label_then, label_end); { BlockStack bstack(this, label_then); TRY2(n->block_->accept(this)); if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } B.SetInsertPoint(label_end); return StatusTuple(0); } /// on_miss StatusTuple CodegenLLVM::visit_miss_decl_stmt_node(MissDeclStmtNode *n) { if (n->formals_.size() != 0) return mkstatus_(n, "on_match expected 0 arguments, %zu given", n->formals_.size()); auto result_decl = scopes_->current_var()->lookup("_result", false); if (!result_decl) return mkstatus_(n, "unable to find _result built-in"); auto result = vars_.find(result_decl); if (result == vars_.end()) return mkstatus_(n, "unable to find memory for _result built-in"); Value *load_1 = B.CreateLoad(result->second); Value *is_null = B.CreateIsNull(load_1); Function *parent = B.GetInsertBlock()->getParent(); BasicBlock *label_then = BasicBlock::Create(ctx(), "onvalid.then", parent); BasicBlock *label_end = BasicBlock::Create(ctx(), "onvalid.end", parent); B.CreateCondBr(is_null, label_then, label_end); { BlockStack bstack(this, label_then); TRY2(n->block_->accept(this)); if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(label_end); } B.SetInsertPoint(label_end); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_failure_decl_stmt_node(FailureDeclStmtNode *n) { return mkstatus_(n, "unsupported"); } StatusTuple CodegenLLVM::visit_expr_stmt_node(ExprStmtNode *n) { TRY2(n->expr_->accept(this)); expr_ = nullptr; return StatusTuple(0); } StatusTuple CodegenLLVM::visit_struct_variable_decl_stmt_node(StructVariableDeclStmtNode *n) { if (n->struct_id_->name_ == "" || n->struct_id_->name_[0] == '_') { return StatusTuple(0); } StructType *stype; StructDeclStmtNode *decl; TRY2(lookup_struct_type(n, &stype, &decl)); Type *ptr_stype = n->is_pointer() ? PointerType::getUnqual(stype) : (PointerType *)stype; AllocaInst *ptr_a = new AllocaInst(ptr_stype, "", resolve_entry_stack()); vars_[n] = ptr_a; if (n->struct_id_->scope_name_ == "proto") { if (n->is_pointer()) { ConstantPointerNull *const_null = ConstantPointerNull::get(cast(ptr_stype)); B.CreateStore(const_null, ptr_a); } else { return mkstatus_(n, "unsupported"); // string var = n->scope_id() + n->id_->name_; // /* zero initialize array to be filled in with packet header */ // emit("uint64_t __%s[%zu] = {}; uint8_t *%s = (uint8_t*)__%s;", // var.c_str(), ((decl->bit_width_ >> 3) + 7) >> 3, var.c_str(), var.c_str()); // for (auto it = n->init_.begin(); it != n->init_.end(); ++it) { // auto asn = static_cast(it->get()); // if (auto f = decl->field(asn->id_->sub_name_)) { // size_t bit_offset = f->bit_offset_; // size_t bit_width = f->bit_width_; // if (asn->bitop_) { // bit_offset += f->bit_width_ - (asn->bitop_->bit_offset_ + asn->bitop_->bit_width_); // bit_width = std::min(bit_width - asn->bitop_->bit_offset_, asn->bitop_->bit_width_); // } // emit(" bpf_dins(%s + %zu, %zu, %zu, ", var.c_str(), bit_offset >> 3, bit_offset & 0x7, bit_width); // TRY2(asn->rhs_->accept(this)); // emit(");"); // } // } } } else { if (n->is_pointer()) { if (n->id_->name_ == "_result") { // special case for capturing the return value of a previous method call Value *cast_1 = B.CreateBitCast(pop_expr(), ptr_stype); B.CreateStore(cast_1, ptr_a); } else { ConstantPointerNull *const_null = ConstantPointerNull::get(cast(ptr_stype)); B.CreateStore(const_null, ptr_a); } } else { B.CreateMemSet(ptr_a, B.getInt8(0), B.getInt64(decl->bit_width_ >> 3), 1); if (!n->init_.empty()) { for (auto it = n->init_.begin(); it != n->init_.end(); ++it) TRY2((*it)->accept(this)); } } } return StatusTuple(0); } StatusTuple CodegenLLVM::visit_integer_variable_decl_stmt_node(IntegerVariableDeclStmtNode *n) { if (!B.GetInsertBlock()) return StatusTuple(0); // uintX var = init AllocaInst *ptr_a = new AllocaInst(B.getIntNTy(n->bit_width_), n->id_->name_, resolve_entry_stack()); vars_[n] = ptr_a; // todo if (!n->init_.empty()) TRY2(n->init_[0]->accept(this)); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_struct_decl_stmt_node(StructDeclStmtNode *n) { ++indent_; StructType *struct_type = StructType::create(ctx(), "_struct." + n->id_->name_); vector fields; for (auto it = n->stmts_.begin(); it != n->stmts_.end(); ++it) fields.push_back(B.getIntNTy((*it)->bit_width_)); struct_type->setBody(fields, n->is_packed()); structs_[n] = struct_type; return StatusTuple(0); } StatusTuple CodegenLLVM::visit_parser_state_stmt_node(ParserStateStmtNode *n) { string jump_label = n->scoped_name() + "_continue"; BasicBlock *label_entry = resolve_label(jump_label); B.SetInsertPoint(label_entry); if (n->next_state_) TRY2(n->next_state_->accept(this)); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_state_decl_stmt_node(StateDeclStmtNode *n) { if (!n->id_) return StatusTuple(0); string jump_label = n->scoped_name(); BasicBlock *label_entry = resolve_label(jump_label); B.SetInsertPoint(label_entry); auto it = n->subs_.begin(); scopes_->push_state(it->scope_); for (auto in = n->init_.begin(); in != n->init_.end(); ++in) TRY2((*in)->accept(this)); if (n->subs_.size() == 1 && it->id_->name_ == "") { // this is not a multistate protocol, emit everything and finish TRY2(it->block_->accept(this)); if (n->parser_) { B.CreateBr(resolve_label(jump_label + "_continue")); TRY2(n->parser_->accept(this)); } } else { return mkstatus_(n, "unsupported"); } scopes_->pop_state(); return StatusTuple(0); } StatusTuple CodegenLLVM::visit_table_decl_stmt_node(TableDeclStmtNode *n) { if (n->table_type_->name_ == "Table" || n->table_type_->name_ == "SharedTable") { if (n->templates_.size() != 4) return mkstatus_(n, "%s expected 4 arguments, %zu given", n->table_type_->c_str(), n->templates_.size()); auto key = scopes_->top_struct()->lookup(n->key_id()->name_, /*search_local*/true); if (!key) return mkstatus_(n, "cannot find key %s", n->key_id()->name_.c_str()); auto leaf = scopes_->top_struct()->lookup(n->leaf_id()->name_, /*search_local*/true); if (!leaf) return mkstatus_(n, "cannot find leaf %s", n->leaf_id()->name_.c_str()); bpf_map_type map_type = BPF_MAP_TYPE_UNSPEC; if (n->type_id()->name_ == "FIXED_MATCH") map_type = BPF_MAP_TYPE_HASH; else if (n->type_id()->name_ == "INDEXED") map_type = BPF_MAP_TYPE_ARRAY; else return mkstatus_(n, "Table type %s not implemented", n->type_id()->name_.c_str()); StructType *key_stype, *leaf_stype; TRY2(lookup_struct_type(n->key_type_, &key_stype)); TRY2(lookup_struct_type(n->leaf_type_, &leaf_stype)); StructType *decl_struct = mod_->getTypeByName("_struct." + n->id_->name_); if (!decl_struct) decl_struct = StructType::create(ctx(), "_struct." + n->id_->name_); if (decl_struct->isOpaque()) decl_struct->setBody(vector({key_stype, leaf_stype}), /*isPacked=*/false); GlobalVariable *decl_gvar = new GlobalVariable(*mod_, decl_struct, false, GlobalValue::ExternalLinkage, 0, n->id_->name_); decl_gvar->setSection("maps"); tables_[n] = decl_gvar; int map_fd = bpf_create_map(map_type, key->bit_width_ / 8, leaf->bit_width_ / 8, n->size_, 0); if (map_fd >= 0) table_fds_[n] = map_fd; } else { return mkstatus_(n, "Table %s not implemented", n->table_type_->name_.c_str()); } return StatusTuple(0); } StatusTuple CodegenLLVM::lookup_struct_type(StructDeclStmtNode *decl, StructType **stype) const { auto struct_it = structs_.find(decl); if (struct_it == structs_.end()) return mkstatus_(decl, "could not find IR for type %s", decl->id_->c_str()); *stype = struct_it->second; return StatusTuple(0); } StatusTuple CodegenLLVM::lookup_struct_type(VariableDeclStmtNode *n, StructType **stype, StructDeclStmtNode **decl) const { if (!n->is_struct()) return mkstatus_(n, "attempt to search for struct with a non-struct type %s", n->id_->c_str()); auto var = (StructVariableDeclStmtNode *)n; StructDeclStmtNode *type; if (var->struct_id_->scope_name_ == "proto") type = proto_scopes_->top_struct()->lookup(var->struct_id_->name_, true); else type = scopes_->top_struct()->lookup(var->struct_id_->name_, true); if (!type) return mkstatus_(n, "could not find type %s", var->struct_id_->c_str()); TRY2(lookup_struct_type(type, stype)); if (decl) *decl = type; return StatusTuple(0); } StatusTuple CodegenLLVM::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { if (n->formals_.size() != 1) return mkstatus_(n, "Functions must have exactly 1 argument, %zd given", n->formals_.size()); vector formals; for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { VariableDeclStmtNode *formal = it->get(); if (formal->is_struct()) { StructType *stype; //TRY2(lookup_struct_type(formal, &stype)); auto var = (StructVariableDeclStmtNode *)formal; stype = mod_->getTypeByName("_struct." + var->struct_id_->name_); if (!stype) return mkstatus_(n, "could not find type %s", var->struct_id_->c_str()); formals.push_back(PointerType::getUnqual(stype)); } else { formals.push_back(B.getIntNTy(formal->bit_width_)); } } FunctionType *fn_type = FunctionType::get(B.getInt32Ty(), formals, /*isVarArg=*/false); Function *fn = mod_->getFunction(n->id_->name_); if (fn) return mkstatus_(n, "Function %s already defined", n->id_->c_str()); fn = Function::Create(fn_type, GlobalValue::ExternalLinkage, n->id_->name_, mod_); fn->setCallingConv(CallingConv::C); fn->addFnAttr(Attribute::NoUnwind); fn->setSection(BPF_FN_PREFIX + n->id_->name_); BasicBlock *label_entry = BasicBlock::Create(ctx(), "entry", fn); B.SetInsertPoint(label_entry); string scoped_entry_label = to_string((uintptr_t)fn) + "::entry"; labels_[scoped_entry_label] = label_entry; BasicBlock *label_return = resolve_label("DONE"); retval_ = new AllocaInst(fn->getReturnType(), "ret", label_entry); B.CreateStore(B.getInt32(0), retval_); errval_ = new AllocaInst(B.getInt64Ty(), "err", label_entry); B.CreateStore(B.getInt64(0), errval_); auto formal = n->formals_.begin(); for (auto arg = fn->arg_begin(); arg != fn->arg_end(); ++arg, ++formal) { TRY2((*formal)->accept(this)); Value *ptr = vars_[formal->get()]; if (!ptr) return mkstatus_(n, "cannot locate memory location for arg %s", (*formal)->id_->c_str()); B.CreateStore(&*arg, ptr); // Type *ptype; // if ((*formal)->is_struct()) { // StructType *type; // TRY2(lookup_struct_type(formal->get(), &type)); // ptype = PointerType::getUnqual(type); // } else { // ptype = PointerType::getUnqual(B.getIntNTy((*formal)->bit_width_)); // } // arg->setName((*formal)->id_->name_); // AllocaInst *ptr = new AllocaInst(ptype, nullptr, (*formal)->id_->name_, label_entry); // B.CreateStore(arg, ptr); // vars_[formal->get()] = ptr; } // visit function scoped variables { scopes_->push_state(n->scope_); for (auto it = scopes_->current_var()->obegin(); it != scopes_->current_var()->oend(); ++it) TRY2((*it)->accept(this)); TRY2(n->block_->accept(this)); scopes_->pop_state(); if (!B.GetInsertBlock()->getTerminator()) B.CreateBr(resolve_label("DONE")); // always return something B.SetInsertPoint(label_return); B.CreateRet(B.CreateLoad(retval_)); } return StatusTuple(0); } StatusTuple CodegenLLVM::visit(Node* root, vector &tables) { scopes_->set_current(scopes_->top_state()); scopes_->set_current(scopes_->top_var()); TRY2(print_header()); for (auto it = scopes_->top_table()->obegin(); it != scopes_->top_table()->oend(); ++it) TRY2((*it)->accept(this)); for (auto it = scopes_->top_func()->obegin(); it != scopes_->top_func()->oend(); ++it) TRY2((*it)->accept(this)); //TRY2(print_parser()); for (auto table : tables_) { bpf_map_type map_type = BPF_MAP_TYPE_UNSPEC; if (table.first->type_id()->name_ == "FIXED_MATCH") map_type = BPF_MAP_TYPE_HASH; else if (table.first->type_id()->name_ == "INDEXED") map_type = BPF_MAP_TYPE_ARRAY; tables.push_back({ table.first->id_->name_, table_fds_[table.first], map_type, table.first->key_type_->bit_width_ >> 3, table.first->leaf_type_->bit_width_ >> 3, table.first->size_, 0, "", "", }); } return StatusTuple(0); } StatusTuple CodegenLLVM::print_header() { GlobalVariable *gvar_license = new GlobalVariable(*mod_, ArrayType::get(Type::getInt8Ty(ctx()), 4), false, GlobalValue::ExternalLinkage, 0, "_license"); gvar_license->setSection("license"); gvar_license->setInitializer(ConstantDataArray::getString(ctx(), "GPL", true)); Function *pseudo_fn = mod_->getFunction("llvm.bpf.pseudo"); if (!pseudo_fn) { pseudo_fn = Function::Create( FunctionType::get(B.getInt64Ty(), vector({B.getInt64Ty(), B.getInt64Ty()}), false), GlobalValue::ExternalLinkage, "llvm.bpf.pseudo", mod_); } // declare structures for (auto it = scopes_->top_struct()->obegin(); it != scopes_->top_struct()->oend(); ++it) { if ((*it)->id_->name_ == "_Packet") continue; TRY2((*it)->accept(this)); } for (auto it = proto_scopes_->top_struct()->obegin(); it != proto_scopes_->top_struct()->oend(); ++it) { if ((*it)->id_->name_ == "_Packet") continue; TRY2((*it)->accept(this)); } return StatusTuple(0); } int CodegenLLVM::get_table_fd(const string &name) const { TableDeclStmtNode *table = scopes_->top_table()->lookup(name); if (!table) return -1; auto table_fd_it = table_fds_.find(table); if (table_fd_it == table_fds_.end()) return -1; return table_fd_it->second; } LLVMContext & CodegenLLVM::ctx() const { return mod_->getContext(); } Constant * CodegenLLVM::const_int(uint64_t val, unsigned bits, bool is_signed) { return ConstantInt::get(ctx(), APInt(bits, val, is_signed)); } Value * CodegenLLVM::pop_expr() { Value *ret = expr_; expr_ = nullptr; return ret; } BasicBlock * CodegenLLVM::resolve_label(const string &label) { Function *parent = B.GetInsertBlock()->getParent(); string scoped_label = to_string((uintptr_t)parent) + "::" + label; auto it = labels_.find(scoped_label); if (it != labels_.end()) return it->second; BasicBlock *label_new = BasicBlock::Create(ctx(), label, parent); labels_[scoped_label] = label_new; return label_new; } Instruction * CodegenLLVM::resolve_entry_stack() { BasicBlock *label_entry = resolve_label("entry"); return &label_entry->back(); } } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/codegen_llvm.h000066400000000000000000000074751305314114400227210ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include #include "node.h" #include "scope.h" namespace llvm { class AllocaInst; class BasicBlock; class BranchInst; class Constant; class Instruction; class IRBuilderBase; class LLVMContext; class Module; class StructType; class SwitchInst; class Value; class GlobalVariable; } namespace ebpf { struct TableDesc; namespace cc { class BlockStack; class SwitchStack; using std::vector; using std::string; using std::set; class CodegenLLVM : public Visitor { friend class BlockStack; friend class SwitchStack; public: CodegenLLVM(llvm::Module *mod, Scopes *scopes, Scopes *proto_scopes); virtual ~CodegenLLVM(); #define VISIT(type, func) virtual STATUS_RETURN visit_##func(type* n); EXPAND_NODES(VISIT) #undef VISIT STATUS_RETURN visit(Node* n, std::vector &tables); int get_table_fd(const std::string &name) const; private: STATUS_RETURN emit_short_circuit_and(BinopExprNode* n); STATUS_RETURN emit_short_circuit_or(BinopExprNode* n); STATUS_RETURN emit_table_lookup(MethodCallExprNode* n); STATUS_RETURN emit_table_update(MethodCallExprNode* n); STATUS_RETURN emit_table_delete(MethodCallExprNode* n); STATUS_RETURN emit_log(MethodCallExprNode* n); STATUS_RETURN emit_packet_rewrite_field(MethodCallExprNode* n); STATUS_RETURN emit_atomic_add(MethodCallExprNode* n); STATUS_RETURN emit_cksum(MethodCallExprNode* n); STATUS_RETURN emit_incr_cksum(MethodCallExprNode* n, size_t sz = 0); STATUS_RETURN emit_lb_hash(MethodCallExprNode* n); STATUS_RETURN emit_sizeof(MethodCallExprNode* n); STATUS_RETURN emit_get_usec_time(MethodCallExprNode* n); STATUS_RETURN emit_forward_to_vnf(MethodCallExprNode* n); STATUS_RETURN emit_forward_to_group(MethodCallExprNode* n); STATUS_RETURN print_header(); llvm::LLVMContext & ctx() const; llvm::Constant * const_int(uint64_t val, unsigned bits = 64, bool is_signed = false); llvm::Value * pop_expr(); llvm::BasicBlock * resolve_label(const string &label); llvm::Instruction * resolve_entry_stack(); StatusTuple lookup_var(Node *n, const std::string &name, Scopes::VarScope *scope, VariableDeclStmtNode **decl, llvm::Value **mem) const; StatusTuple lookup_struct_type(StructDeclStmtNode *decl, llvm::StructType **stype) const; StatusTuple lookup_struct_type(VariableDeclStmtNode *n, llvm::StructType **stype, StructDeclStmtNode **decl = nullptr) const; template void emit(const char *fmt, Args&&... params); void emit(const char *s); FILE* out_; llvm::Module* mod_; llvm::IRBuilderBase *b_; int indent_; int tmp_reg_index_; Scopes *scopes_; Scopes *proto_scopes_; vector > free_instructions_; vector table_inits_; map proto_rewrites_; map tables_; map table_fds_; map vars_; map structs_; map labels_; llvm::SwitchInst *cur_switch_; llvm::Value *expr_; llvm::AllocaInst *retval_; llvm::AllocaInst *errval_; }; } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/lexer.h000066400000000000000000000070251305314114400213710ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #ifndef yyFlexLexerOnce #undef yyFlexLexer #define yyFlexLexer ebpfccFlexLexer #include #endif #undef YY_DECL #define YY_DECL int ebpf::cc::Lexer::yylex() #include // NOLINT #include #include "parser.yy.hh" namespace ebpf { namespace cc { typedef BisonParser::token::yytokentype Tok; class Lexer : public yyFlexLexer { public: explicit Lexer(std::istream* in) : yyFlexLexer(in), prev_tok_(Tok::TSEMI), lines_({""}), yylval_(NULL), yylloc_(NULL) { if (!in || !*in) fprintf(stderr, "Unable to open input stream\n"); } int yylex(BisonParser::semantic_type *lval, BisonParser::location_type *lloc) { yylval_ = lval; yylloc_ = lloc; return yylex(); } std::string text(const BisonParser::location_type& loc) const { return text(loc.begin, loc.end); } std::string text(const position& begin, const position& end) const { std::string result; for (size_t i = begin.line; i <= end.line; ++i) { if (i == begin.line && i == end.line) { result += lines_.at(i - 1).substr(begin.column - 1, end.column - begin.column); } else if (i == begin.line && i < end.line) { result += lines_.at(i - 1).substr(begin.column - 1); } else if (i > begin.line && i == end.line) { result += lines_.at(i - 1).substr(0, end.column); } else if (i > begin.line && i == end.line) { result += lines_.at(i - 1); } } return result; } private: // true if a semicolon should be replaced here bool next_line() { lines_.push_back(""); yylloc_->lines(); yylloc_->step(); switch (prev_tok_) { case Tok::TIDENTIFIER: case Tok::TINTEGER: case Tok::THEXINTEGER: case Tok::TRBRACE: case Tok::TRPAREN: case Tok::TRBRACK: case Tok::TTRUE: case Tok::TFALSE: // uncomment to add implicit semicolons //return true; default: break; } return false; } Tok save(Tok tok, bool ignore_text = false) { if (!ignore_text) { save_text(); } switch (tok) { case Tok::TIDENTIFIER: case Tok::TINTEGER: case Tok::THEXINTEGER: yylval_->string = new std::string(yytext, yyleng); break; default: yylval_->token = tok; } prev_tok_ = tok; return tok; } /* std::string * alloc_string(const char *c, size_t len) { strings_.push_back(std::unique_ptr(new std::string(c, len))); return strings_.back().get(); } std::string * alloc_string(const std::string &s) { strings_.push_back(std::unique_ptr(new std::string(s))); return strings_.back().get(); } */ void save_text() { lines_.back().append(yytext, yyleng); yylloc_->columns(yyleng); } int yylex(); Tok prev_tok_; std::vector lines_; //std::list> strings_; BisonParser::semantic_type *yylval_; BisonParser::location_type *yylloc_; }; } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/lexer.ll000066400000000000000000000104331305314114400215460ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ %{ #include "lexer.h" %} %option yylineno nodefault yyclass="Lexer" noyywrap c++ prefix="ebpfcc" %option never-interactive %{ #include #include "parser.yy.hh" std::string tmp_str_cc; %} %x STRING_ %% \" {BEGIN STRING_;} \" { BEGIN 0; yylval_->string = new std::string(tmp_str_cc); tmp_str_cc = ""; return Tok::TSTRING; } \\n {tmp_str_cc += "\n"; } . {tmp_str_cc += *yytext; } [ \t]+ { save_text(); } \n { if (next_line()) { return save(Tok::TSEMI, true); } } "//".*\n { if (next_line()) { return save(Tok::TSEMI, true); } } ^"#" return save(Tok::TPRAGMA); "=" return save(Tok::TEQUAL); "==" return save(Tok::TCEQ); "!=" return save(Tok::TCNE); "<" return save(Tok::TCLT); "<=" return save(Tok::TCLE); ">" return save(Tok::TCGT); ">=" return save(Tok::TCGE); "(" return save(Tok::TLPAREN); ")" return save(Tok::TRPAREN); "{" return save(Tok::TLBRACE); "}" return save(Tok::TRBRACE); "[" return save(Tok::TLBRACK); "]" return save(Tok::TRBRACK); "->" return save(Tok::TARROW); "." return save(Tok::TDOT); "," return save(Tok::TCOMMA); "+" return save(Tok::TPLUS); "++" return save(Tok::TINCR); "-" return save(Tok::TMINUS); "--" return save(Tok::TDECR); "*" return save(Tok::TMUL); "/" return save(Tok::TDIV); "%" return save(Tok::TMOD); "^" return save(Tok::TXOR); "$" return save(Tok::TDOLLAR); "!" return save(Tok::TNOT); "~" return save(Tok::TCMPL); ":" return save(Tok::TCOLON); "::" return save(Tok::TSCOPE); ";" return save(Tok::TSEMI); "&&" return save(Tok::TAND); "||" return save(Tok::TOR); "&" return save(Tok::TLAND); "|" return save(Tok::TLOR); "@" return save(Tok::TAT); "case" return save(Tok::TCASE); "continue" return save(Tok::TCONTINUE); "else" return save(Tok::TELSE); "false" return save(Tok::TFALSE); "goto" return save(Tok::TGOTO); "if" return save(Tok::TIF); "next" return save(Tok::TNEXT); "on_match" return save(Tok::TMATCH); "on_miss" return save(Tok::TMISS); "on_failure" return save(Tok::TFAILURE); "on_valid" return save(Tok::TVALID); "return" return save(Tok::TRETURN); "state" return save(Tok::TSTATE); "struct" return save(Tok::TSTRUCT); "switch" return save(Tok::TSWITCH); "true" return save(Tok::TTRUE); "u8" return save(Tok::TU8); "u16" return save(Tok::TU16); "u32" return save(Tok::TU32); "u64" return save(Tok::TU64); [a-zA-Z_][a-zA-Z0-9_]* return save(Tok::TIDENTIFIER); [0-9]+ return save(Tok::TINTEGER); 0x[0-9a-fA-F]+ return save(Tok::THEXINTEGER); . printf("Unknown token \"%s\"\n", yytext); yyterminate(); %% bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/loader.cc000066400000000000000000000042021305314114400216500ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "parser.h" #include "type_check.h" #include "codegen_llvm.h" #include "loader.h" #include "table_desc.h" using std::string; using std::unique_ptr; using std::vector; namespace ebpf { BLoader::BLoader(unsigned flags) : flags_(flags) { (void)flags_; } BLoader::~BLoader() { } int BLoader::parse(llvm::Module *mod, const string &filename, const string &proto_filename, unique_ptr> *tables) { int rc; proto_parser_ = make_unique(proto_filename); rc = proto_parser_->parse(); if (rc) { fprintf(stderr, "In file: %s\n", filename.c_str()); return rc; } parser_ = make_unique(filename); rc = parser_->parse(); if (rc) { fprintf(stderr, "In file: %s\n", filename.c_str()); return rc; } //ebpf::cc::Printer printer(stderr); //printer.visit(parser_->root_node_); ebpf::cc::TypeCheck type_check(parser_->scopes_.get(), proto_parser_->scopes_.get()); auto ret = type_check.visit(parser_->root_node_); if (ret.code() != 0 || ret.msg().size()) { fprintf(stderr, "Type error @line=%d: %s\n", ret.code(), ret.msg().c_str()); return -1; } *tables = make_unique>(); codegen_ = ebpf::make_unique(mod, parser_->scopes_.get(), proto_parser_->scopes_.get()); ret = codegen_->visit(parser_->root_node_, **tables); if (ret.code() != 0 || ret.msg().size()) { fprintf(stderr, "Codegen error @line=%d: %s\n", ret.code(), ret.msg().c_str()); return ret.code(); } return 0; } } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/loader.h000066400000000000000000000022621305314114400215160ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include namespace llvm { class Module; } namespace ebpf { struct TableDesc; namespace cc { class Parser; class CodegenLLVM; } class BLoader { public: explicit BLoader(unsigned flags); ~BLoader(); int parse(llvm::Module *mod, const std::string &filename, const std::string &proto_filename, std::unique_ptr> *tables); private: unsigned flags_; std::unique_ptr parser_; std::unique_ptr proto_parser_; std::unique_ptr codegen_; }; } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/node.cc000066400000000000000000000024631305314114400213360ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include "node.h" namespace ebpf { namespace cc { #define ACCEPT(type, func) \ STATUS_RETURN type::accept(Visitor* v) { return v->visit_##func(this); } EXPAND_NODES(ACCEPT) #undef ACCEPT VariableDeclStmtNode* StructDeclStmtNode::field(const string& name) const { for (auto it = stmts_.begin(); it != stmts_.end(); ++it) { if ((*it)->id_->name_ == name) { return it->get(); } } return NULL; } int StructDeclStmtNode::indexof(const string& name) const { int i = 0; for (auto it = stmts_.begin(); it != stmts_.end(); ++it, ++i) { if ((*it)->id_->name_ == name) { return i; } } return -1; } } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/node.h000066400000000000000000000440301305314114400211740ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include #include #include "common.h" #include "bcc_exception.h" #include "scope.h" #define REVISION_MASK 0xfff #define MAJOR_VER_POS 22 #define MAJOR_VER_MASK ~((1 << MAJOR_VER_POS) - 1) #define MINOR_VER_POS 12 #define MINOR_VER_MASK (~((1 << MINOR_VER_POS) - 1) & (~(MAJOR_VER_MASK))) #define GET_MAJOR_VER(version) ((version & MAJOR_VER_MASK) >> MAJOR_VER_POS) #define GET_MINOR_VER(version) ((version & MINOR_VER_MASK) >> MINOR_VER_POS) #define GET_REVISION(version) (version & REVISION_MASK) #define MAKE_VERSION(major, minor, rev) \ ((major << MAJOR_VER_POS) | \ (minor << MINOR_VER_POS) | \ (rev & REVISION_MASK)) #define STATUS_RETURN __attribute((warn_unused_result)) StatusTuple namespace ebpf { namespace cc { using std::unique_ptr; using std::move; using std::string; using std::vector; using std::bitset; using std::find; typedef unique_ptr String; #define NODE_EXPRESSIONS(EXPAND) \ EXPAND(IdentExprNode, ident_expr_node) \ EXPAND(AssignExprNode, assign_expr_node) \ EXPAND(PacketExprNode, packet_expr_node) \ EXPAND(IntegerExprNode, integer_expr_node) \ EXPAND(StringExprNode, string_expr_node) \ EXPAND(BinopExprNode, binop_expr_node) \ EXPAND(UnopExprNode, unop_expr_node) \ EXPAND(BitopExprNode, bitop_expr_node) \ EXPAND(GotoExprNode, goto_expr_node) \ EXPAND(ReturnExprNode, return_expr_node) \ EXPAND(MethodCallExprNode, method_call_expr_node) \ EXPAND(TableIndexExprNode, table_index_expr_node) #define NODE_STATEMENTS(EXPAND) \ EXPAND(ExprStmtNode, expr_stmt_node) \ EXPAND(BlockStmtNode, block_stmt_node) \ EXPAND(IfStmtNode, if_stmt_node) \ EXPAND(OnValidStmtNode, onvalid_stmt_node) \ EXPAND(SwitchStmtNode, switch_stmt_node) \ EXPAND(CaseStmtNode, case_stmt_node) \ EXPAND(StructVariableDeclStmtNode, struct_variable_decl_stmt_node) \ EXPAND(IntegerVariableDeclStmtNode, integer_variable_decl_stmt_node) \ EXPAND(StructDeclStmtNode, struct_decl_stmt_node) \ EXPAND(StateDeclStmtNode, state_decl_stmt_node) \ EXPAND(ParserStateStmtNode, parser_state_stmt_node) \ EXPAND(MatchDeclStmtNode, match_decl_stmt_node) \ EXPAND(MissDeclStmtNode, miss_decl_stmt_node) \ EXPAND(FailureDeclStmtNode, failure_decl_stmt_node) \ EXPAND(TableDeclStmtNode, table_decl_stmt_node) \ EXPAND(FuncDeclStmtNode, func_decl_stmt_node) #define EXPAND_NODES(EXPAND) \ NODE_EXPRESSIONS(EXPAND) \ NODE_STATEMENTS(EXPAND) class Visitor; // forward declare all classes #define FORWARD(type, func) class type; EXPAND_NODES(FORWARD) #undef FORWARD #define DECLARE(type) \ typedef unique_ptr Ptr; \ virtual StatusTuple accept(Visitor* v); class Node { public: typedef unique_ptr Ptr; Node() : line_(-1), column_(-1) {} virtual ~Node() {} virtual StatusTuple accept(Visitor* v) = 0; int line_; int column_; string text_; }; template StatusTuple mkstatus_(Node *n, const char *fmt, Args... args) { StatusTuple status = StatusTuple(n->line_ ? n->line_ : -1, fmt, args...); if (n->line_ > 0) status.append_msg("\n" + n->text_); return status; } static inline StatusTuple mkstatus_(Node *n, const char *msg) { StatusTuple status = StatusTuple(n->line_ ? n->line_ : -1, msg); if (n->line_ > 0) status.append_msg("\n" + n->text_); return status; } class StmtNode : public Node { public: typedef unique_ptr Ptr; virtual StatusTuple accept(Visitor* v) = 0; }; typedef vector StmtNodeList; class ExprNode : public Node { public: typedef unique_ptr Ptr; virtual StatusTuple accept(Visitor* v) = 0; enum expr_type { STRUCT, INTEGER, STRING, VOID, UNKNOWN }; enum prop_flag { READ = 0, WRITE, PROTO, IS_LHS, IS_REF, IS_PKT, LAST }; expr_type typeof_; StructDeclStmtNode *struct_type_; size_t bit_width_; bitset flags_; unique_ptr bitop_; ExprNode() : typeof_(UNKNOWN), struct_type_(NULL), flags_(1 << READ) {} void copy_type(const ExprNode& other) { typeof_ = other.typeof_; struct_type_ = other.struct_type_; bit_width_ = other.bit_width_; flags_ = other.flags_; } bool is_lhs() const { return flags_[IS_LHS]; } bool is_ref() const { return flags_[IS_REF]; } bool is_pkt() const { return flags_[IS_PKT]; } }; typedef vector ExprNodeList; class IdentExprNode : public ExprNode { public: DECLARE(IdentExprNode) string name_; string sub_name_; string scope_name_; VariableDeclStmtNode *decl_; VariableDeclStmtNode *sub_decl_; IdentExprNode(const IdentExprNode& other) { name_ = other.name_; sub_name_ = other.sub_name_; scope_name_ = other.scope_name_; decl_ = other.decl_; sub_decl_ = other.sub_decl_; } IdentExprNode::Ptr copy() const { return IdentExprNode::Ptr(new IdentExprNode(*this)); } explicit IdentExprNode(const string& id) : name_(id) {} explicit IdentExprNode(const char* id) : name_(id) {} void prepend_scope(const string& id) { scope_name_ = id; } void append_scope(const string& id) { scope_name_ = move(name_); name_ = id; } void prepend_dot(const string& id) { sub_name_ = move(name_); name_ = id; } void append_dot(const string& id) { // we don't support nested struct so keep all subs as single variable if (!sub_name_.empty()) { sub_name_ += "." + id; } else { sub_name_ = id; } } const string& full_name() { if (full_name_.size()) { return full_name_; // lazy init } if (scope_name_.size()) { full_name_ += scope_name_ + "::"; } full_name_ += name_; if (sub_name_.size()) { full_name_ += "." + sub_name_; } return full_name_; } const char* c_str() const { return name_.c_str(); } private: string full_name_; }; class BitopExprNode : public ExprNode { public: DECLARE(BitopExprNode) ExprNode::Ptr expr_; size_t bit_offset_; size_t bit_width_; BitopExprNode(const string& bofs, const string& bsz) : bit_offset_(strtoul(bofs.c_str(), NULL, 0)), bit_width_(strtoul(bsz.c_str(), NULL, 0)) {} }; typedef vector IdentExprNodeList; class AssignExprNode : public ExprNode { public: DECLARE(AssignExprNode) //IdentExprNode *id_; ExprNode::Ptr lhs_; ExprNode::Ptr rhs_; AssignExprNode(IdentExprNode::Ptr id, ExprNode::Ptr rhs) : lhs_(move(id)), rhs_(move(rhs)) { //id_ = (IdentExprNode *)lhs_.get(); lhs_->flags_[ExprNode::IS_LHS] = true; } AssignExprNode(ExprNode::Ptr lhs, ExprNode::Ptr rhs) : lhs_(move(lhs)), rhs_(move(rhs)) { //id_ = nullptr; lhs_->flags_[ExprNode::IS_LHS] = true; } }; class PacketExprNode : public ExprNode { public: DECLARE(PacketExprNode) IdentExprNode::Ptr id_; explicit PacketExprNode(IdentExprNode::Ptr id) : id_(move(id)) {} }; class StringExprNode : public ExprNode { public: DECLARE(StringExprNode) string val_; explicit StringExprNode(string *val) : val_(move(*val)) { delete val; } explicit StringExprNode(const string &val) : val_(val) {} }; class IntegerExprNode : public ExprNode { public: DECLARE(IntegerExprNode) size_t bits_; string val_; IntegerExprNode(string* val, string* bits) : bits_(strtoul(bits->c_str(), NULL, 0)), val_(move(*val)) { delete val; delete bits; } explicit IntegerExprNode(string* val) : bits_(0), val_(move(*val)) { delete val; } explicit IntegerExprNode(const string& val) : bits_(0), val_(val) {} explicit IntegerExprNode(const string& val, size_t bits) : bits_(bits), val_(val) {} }; class BinopExprNode : public ExprNode { public: DECLARE(BinopExprNode) ExprNode::Ptr lhs_; int op_; ExprNode::Ptr rhs_; BinopExprNode(ExprNode::Ptr lhs, int op, ExprNode::Ptr rhs) : lhs_(move(lhs)), op_(op), rhs_(move(rhs)) {} }; class UnopExprNode : public ExprNode { public: DECLARE(UnopExprNode) ExprNode::Ptr expr_; int op_; UnopExprNode(int op, ExprNode::Ptr expr) : expr_(move(expr)), op_(op) {} }; class GotoExprNode : public ExprNode { public: DECLARE(GotoExprNode) bool is_continue_; IdentExprNode::Ptr id_; GotoExprNode(IdentExprNode::Ptr id, bool is_continue = false) : is_continue_(is_continue), id_(move(id)) {} }; class ReturnExprNode : public ExprNode { public: DECLARE(ReturnExprNode) ExprNode::Ptr expr_; ReturnExprNode(ExprNode::Ptr expr) : expr_(move(expr)) {} }; class BlockStmtNode : public StmtNode { public: DECLARE(BlockStmtNode) explicit BlockStmtNode(StmtNodeList stmts = StmtNodeList()) : stmts_(move(stmts)), scope_(NULL) {} ~BlockStmtNode() { delete scope_; } StmtNodeList stmts_; Scopes::VarScope* scope_; }; class MethodCallExprNode : public ExprNode { public: DECLARE(MethodCallExprNode) IdentExprNode::Ptr id_; ExprNodeList args_; BlockStmtNode::Ptr block_; MethodCallExprNode(IdentExprNode::Ptr id, ExprNodeList&& args, int lineno) : id_(move(id)), args_(move(args)), block_(make_unique()) { line_ = lineno; } }; class TableIndexExprNode : public ExprNode { public: DECLARE(TableIndexExprNode) IdentExprNode::Ptr id_; IdentExprNode::Ptr sub_; ExprNode::Ptr index_; TableDeclStmtNode *table_; VariableDeclStmtNode *sub_decl_; TableIndexExprNode(IdentExprNode::Ptr id, ExprNode::Ptr index) : id_(move(id)), index_(move(index)), table_(nullptr), sub_decl_(nullptr) {} }; class ExprStmtNode : public StmtNode { public: DECLARE(ExprStmtNode) ExprNode::Ptr expr_; explicit ExprStmtNode(ExprNode::Ptr expr) : expr_(move(expr)) {} }; class IfStmtNode : public StmtNode { public: DECLARE(IfStmtNode) ExprNode::Ptr cond_; StmtNode::Ptr true_block_; StmtNode::Ptr false_block_; // create an if () {} expression IfStmtNode(ExprNode::Ptr cond, StmtNode::Ptr true_block) : cond_(move(cond)), true_block_(move(true_block)) {} // create an if () {} else {} expression IfStmtNode(ExprNode::Ptr cond, StmtNode::Ptr true_block, StmtNode::Ptr false_block) : cond_(move(cond)), true_block_(move(true_block)), false_block_(move(false_block)) {} }; class OnValidStmtNode : public StmtNode { public: DECLARE(OnValidStmtNode) IdentExprNode::Ptr cond_; StmtNode::Ptr block_; StmtNode::Ptr else_block_; // create an onvalid () {} expression OnValidStmtNode(IdentExprNode::Ptr cond, StmtNode::Ptr block) : cond_(move(cond)), block_(move(block)) {} // create an onvalid () {} else {} expression OnValidStmtNode(IdentExprNode::Ptr cond, StmtNode::Ptr block, StmtNode::Ptr else_block) : cond_(move(cond)), block_(move(block)), else_block_(move(else_block)) {} }; class SwitchStmtNode : public StmtNode { public: DECLARE(SwitchStmtNode) ExprNode::Ptr cond_; BlockStmtNode::Ptr block_; SwitchStmtNode(ExprNode::Ptr cond, BlockStmtNode::Ptr block) : cond_(move(cond)), block_(move(block)) {} }; class CaseStmtNode : public StmtNode { public: DECLARE(CaseStmtNode) IntegerExprNode::Ptr value_; BlockStmtNode::Ptr block_; CaseStmtNode(IntegerExprNode::Ptr value, BlockStmtNode::Ptr block) : value_(move(value)), block_(move(block)) {} explicit CaseStmtNode(BlockStmtNode::Ptr block) : block_(move(block)) {} }; class VariableDeclStmtNode : public StmtNode { public: typedef unique_ptr Ptr; virtual StatusTuple accept(Visitor* v) = 0; enum storage_type { INTEGER, STRUCT, STRUCT_REFERENCE }; IdentExprNode::Ptr id_; ExprNodeList init_; enum storage_type storage_type_; size_t bit_width_; size_t bit_offset_; int slot_; string scope_id_; explicit VariableDeclStmtNode(IdentExprNode::Ptr id, storage_type t, size_t bit_width = 0, size_t bit_offset = 0) : id_(move(id)), storage_type_(t), bit_width_(bit_width), bit_offset_(bit_offset), slot_(0) {} const char* scope_id() const { return scope_id_.c_str(); } bool is_struct() { return (storage_type_ == STRUCT || storage_type_ == STRUCT_REFERENCE); } bool is_pointer() { return (storage_type_ == STRUCT_REFERENCE); } }; typedef vector FormalList; class StructVariableDeclStmtNode : public VariableDeclStmtNode { public: DECLARE(StructVariableDeclStmtNode) IdentExprNode::Ptr struct_id_; StructVariableDeclStmtNode(IdentExprNode::Ptr struct_id, IdentExprNode::Ptr id, VariableDeclStmtNode::storage_type t = VariableDeclStmtNode::STRUCT) : VariableDeclStmtNode(move(id), t), struct_id_(move(struct_id)) {} }; class IntegerVariableDeclStmtNode : public VariableDeclStmtNode { public: DECLARE(IntegerVariableDeclStmtNode) IntegerVariableDeclStmtNode(IdentExprNode::Ptr id, const string& bits) : VariableDeclStmtNode(move(id), VariableDeclStmtNode::INTEGER, strtoul(bits.c_str(), NULL, 0)) {} }; class StructDeclStmtNode : public StmtNode { public: DECLARE(StructDeclStmtNode) IdentExprNode::Ptr id_; FormalList stmts_; size_t bit_width_; bool packed_; StructDeclStmtNode(IdentExprNode::Ptr id, FormalList&& stmts = FormalList()) : id_(move(id)), stmts_(move(stmts)), bit_width_(0), packed_(false) {} VariableDeclStmtNode* field(const string& name) const; int indexof(const string& name) const; bool is_packed() const { return packed_; } }; class ParserStateStmtNode : public StmtNode { public: DECLARE(ParserStateStmtNode) IdentExprNode::Ptr id_; StmtNode* next_state_; string scope_id_; explicit ParserStateStmtNode(IdentExprNode::Ptr id) : id_(move(id)) {} static Ptr make(const IdentExprNode::Ptr& id) { return Ptr(new ParserStateStmtNode(id->copy())); } string scoped_name() const { return scope_id_ + id_->name_; } }; class StateDeclStmtNode : public StmtNode { public: DECLARE(StateDeclStmtNode) struct Sub { IdentExprNode::Ptr id_; BlockStmtNode::Ptr block_; ParserStateStmtNode::Ptr parser_; Scopes::StateScope* scope_; Sub(decltype(id_) id, decltype(block_) block, decltype(parser_) parser, decltype(scope_) scope) : id_(move(id)), block_(move(block)), parser_(move(parser)), scope_(scope) {} ~Sub() { delete scope_; } Sub(Sub&& other) : scope_(NULL) { *this = move(other); } Sub& operator=(Sub&& other) { if (this == &other) { return *this; } id_ = move(other.id_); block_ = move(other.block_); parser_ = move(other.parser_); std::swap(scope_, other.scope_); return *this; } }; IdentExprNode::Ptr id_; StmtNodeList init_; string scope_id_; ParserStateStmtNode::Ptr parser_; vector subs_; StateDeclStmtNode() {} StateDeclStmtNode(IdentExprNode::Ptr id, BlockStmtNode::Ptr block) : id_(move(id)) { subs_.push_back(Sub(make_unique(""), move(block), ParserStateStmtNode::Ptr(), NULL)); } StateDeclStmtNode(IdentExprNode::Ptr id1, IdentExprNode::Ptr id2, BlockStmtNode::Ptr block) : id_(move(id1)) { subs_.push_back(Sub(move(id2), move(block), ParserStateStmtNode::Ptr(), NULL)); } string scoped_name() const { return scope_id_ + id_->name_; } vector::iterator find_sub(const string& id) { return find_if(subs_.begin(), subs_.end(), [&id] (const Sub& sub) { if (sub.id_->name_ == id) return true; return false; }); } }; class MatchDeclStmtNode : public StmtNode { public: DECLARE(MatchDeclStmtNode) IdentExprNode::Ptr id_; FormalList formals_; BlockStmtNode::Ptr block_; MatchDeclStmtNode(IdentExprNode::Ptr id, FormalList&& formals, BlockStmtNode::Ptr block) : id_(move(id)), formals_(move(formals)), block_(move(block)) {} }; class MissDeclStmtNode : public StmtNode { public: DECLARE(MissDeclStmtNode) IdentExprNode::Ptr id_; FormalList formals_; BlockStmtNode::Ptr block_; MissDeclStmtNode(IdentExprNode::Ptr id, FormalList&& formals, BlockStmtNode::Ptr block) : id_(move(id)), formals_(move(formals)), block_(move(block)) {} }; class FailureDeclStmtNode : public StmtNode { public: DECLARE(FailureDeclStmtNode) IdentExprNode::Ptr id_; FormalList formals_; BlockStmtNode::Ptr block_; FailureDeclStmtNode(IdentExprNode::Ptr id, FormalList&& formals, BlockStmtNode::Ptr block) : id_(move(id)), formals_(move(formals)), block_(move(block)) {} }; class TableDeclStmtNode : public StmtNode { public: DECLARE(TableDeclStmtNode) IdentExprNode::Ptr table_type_; IdentExprNodeList templates_; IdentExprNode::Ptr id_; StructDeclStmtNode *key_type_; StructDeclStmtNode *leaf_type_; IdentExprNode * key_id() { return templates_.at(0).get(); } IdentExprNode * leaf_id() { return templates_.at(1).get(); } IdentExprNode * type_id() { return templates_.at(2).get(); } IdentExprNode * policy_id() { return templates_.at(3).get(); } size_t size_; TableDeclStmtNode(IdentExprNode::Ptr table_type, IdentExprNodeList&& templates, IdentExprNode::Ptr id, string* size) : table_type_(move(table_type)), templates_(move(templates)), id_(move(id)), key_type_(nullptr), leaf_type_(nullptr), size_(strtoul(size->c_str(), NULL, 0)) { delete size; } }; class FuncDeclStmtNode : public StmtNode { public: DECLARE(FuncDeclStmtNode) IdentExprNode::Ptr id_; FormalList formals_; BlockStmtNode::Ptr block_; Scopes::StateScope* scope_; FuncDeclStmtNode(IdentExprNode::Ptr id, FormalList&& formals, BlockStmtNode::Ptr block) : id_(move(id)), formals_(move(formals)), block_(move(block)), scope_(NULL) {} }; class Visitor { public: typedef StatusTuple Ret; virtual ~Visitor() {} #define VISIT(type, func) virtual STATUS_RETURN visit_##func(type* n) = 0; EXPAND_NODES(VISIT) #undef VISIT }; #undef DECLARE } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/parser.cc000066400000000000000000000175201305314114400217050ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "bcc_exception.h" #include "parser.h" #include "type_helper.h" namespace ebpf { namespace cc { using std::find; using std::move; using std::string; using std::unique_ptr; bool Parser::variable_exists(VariableDeclStmtNode *decl) const { if (scopes_->current_var()->lookup(decl->id_->name_, SCOPE_LOCAL) == NULL) { return false; } return true; } VariableDeclStmtNode *Parser::variable_add(vector *types, VariableDeclStmtNode *decl) { if (variable_exists(decl)) { fprintf(stderr, "redeclaration of variable %s", decl->id_->name_.c_str()); return nullptr; } decl->scope_id_ = string("v") + std::to_string(scopes_->current_var()->id_) + string("_"); scopes_->current_var()->add(decl->id_->name_, decl); return decl; } VariableDeclStmtNode *Parser::variable_add(vector *types, VariableDeclStmtNode *decl, ExprNode *init_expr) { AssignExprNode::Ptr assign(new AssignExprNode(decl->id_->copy(), ExprNode::Ptr(init_expr))); decl->init_.push_back(move(assign)); if (variable_exists(decl)) { fprintf(stderr, "redeclaration of variable %s", decl->id_->name_.c_str()); return nullptr; } decl->scope_id_ = string("v") + std::to_string(scopes_->current_var()->id_) + string("_"); scopes_->current_var()->add(decl->id_->name_, decl); return decl; } StructVariableDeclStmtNode *Parser::variable_add(StructVariableDeclStmtNode *decl, ExprNodeList *args, bool is_kv) { if (is_kv) { // annotate the init expressions with the declared id for (auto arg = args->begin(); arg != args->end(); ++arg) { // decorate with the name of this decl auto n = static_cast(arg->get()); auto id = static_cast(n->lhs_.get()); id->prepend_dot(decl->id_->name_); } } else { fprintf(stderr, "must use key = value syntax\n"); return NULL; } decl->init_ = move(*args); delete args; if (variable_exists(decl)) { fprintf(stderr, "ccpg: warning: redeclaration of variable '%s'\n", decl->id_->name_.c_str()); return nullptr; } decl->scope_id_ = string("v") + std::to_string(scopes_->current_var()->id_) + string("_"); scopes_->current_var()->add(decl->id_->name_, decl); return decl; } StmtNode *Parser::state_add(Scopes::StateScope *scope, IdentExprNode *id, BlockStmtNode *body) { if (scopes_->current_state()->lookup(id->full_name(), SCOPE_LOCAL)) { fprintf(stderr, "redeclaration of state %s\n", id->full_name().c_str()); // redeclaration return NULL; } auto state = new StateDeclStmtNode(IdentExprNode::Ptr(id), BlockStmtNode::Ptr(body)); // add a reference to the lower scope state->subs_[0].scope_ = scope; // add me to the upper scope scopes_->current_state()->add(state->id_->full_name(), state); state->scope_id_ = string("s") + std::to_string(scopes_->current_state()->id_) + string("_"); return state; } StmtNode *Parser::state_add(Scopes::StateScope *scope, IdentExprNode *id1, IdentExprNode *id2, BlockStmtNode *body) { auto state = scopes_->current_state()->lookup(id1->full_name(), SCOPE_LOCAL); if (!state) { state = new StateDeclStmtNode(IdentExprNode::Ptr(id1), IdentExprNode::Ptr(id2), BlockStmtNode::Ptr(body)); // add a reference to the lower scope state->subs_[0].scope_ = scope; // add me to the upper scope scopes_->current_state()->add(state->id_->full_name(), state); state->scope_id_ = string("s") + std::to_string(scopes_->current_state()->id_) + string("_"); return state; } else { if (state->find_sub(id2->name_) != state->subs_.end()) { fprintf(stderr, "redeclaration of state %s, %s\n", id1->full_name().c_str(), id2->full_name().c_str()); return NULL; } state->subs_.push_back(StateDeclStmtNode::Sub(IdentExprNode::Ptr(id2), BlockStmtNode::Ptr(body), ParserStateStmtNode::Ptr(), scope)); delete id1; return new StateDeclStmtNode(); // stub } } bool Parser::table_exists(TableDeclStmtNode *decl, bool search_local) { if (scopes_->top_table()->lookup(decl->id_->name_, search_local) == NULL) { return false; } return true; } StmtNode *Parser::table_add(IdentExprNode *type, IdentExprNodeList *templates, IdentExprNode *id, string *size) { auto table = new TableDeclStmtNode(IdentExprNode::Ptr(type), move(*templates), IdentExprNode::Ptr(id), size); if (table_exists(table, true)) { fprintf(stderr, "redeclaration of table %s\n", id->name_.c_str()); return table; } scopes_->top_table()->add(id->name_, table); return table; } StmtNode * Parser::struct_add(IdentExprNode *type, FormalList *formals) { auto struct_decl = new StructDeclStmtNode(IdentExprNode::Ptr(type), move(*formals)); if (scopes_->top_struct()->lookup(type->name_, SCOPE_LOCAL) != NULL) { fprintf(stderr, "redeclaration of struct %s\n", type->name_.c_str()); return struct_decl; } auto pr_it = pragmas_.find("packed"); if (pr_it != pragmas_.end() && pr_it->second == "true") struct_decl->packed_ = true; int i = 0; size_t offset = 0; for (auto it = struct_decl->stmts_.begin(); it != struct_decl->stmts_.end(); ++it, ++i) { FieldType ft = bits_to_enum((*it)->bit_width_); offset = struct_decl->is_packed() ? offset : align_offset(offset, ft); (*it)->slot_ = i; (*it)->bit_offset_ = offset; offset += (*it)->bit_width_; } struct_decl->bit_width_ = struct_decl->is_packed() ? offset : align_offset(offset, UINT32_T); scopes_->top_struct()->add(type->name_, struct_decl); return struct_decl; } StmtNode * Parser::result_add(int token, IdentExprNode *id, FormalList *formals, BlockStmtNode *body) { StmtNode *stmt = NULL; switch (token) { case Tok::TMATCH: stmt = new MatchDeclStmtNode(IdentExprNode::Ptr(id), move(*formals), BlockStmtNode::Ptr(body)); break; case Tok::TMISS: stmt = new MissDeclStmtNode(IdentExprNode::Ptr(id), move(*formals), BlockStmtNode::Ptr(body)); break; case Tok::TFAILURE: stmt = new FailureDeclStmtNode(IdentExprNode::Ptr(id), move(*formals), BlockStmtNode::Ptr(body)); break; default: {} } return stmt; } StmtNode * Parser::func_add(vector *types, Scopes::StateScope *scope, IdentExprNode *id, FormalList *formals, BlockStmtNode *body) { auto decl = new FuncDeclStmtNode(IdentExprNode::Ptr(id), move(*formals), BlockStmtNode::Ptr(body)); if (scopes_->top_func()->lookup(decl->id_->name_, SCOPE_LOCAL)) { fprintf(stderr, "redeclaration of func %s\n", id->name_.c_str()); return decl; } auto cur_scope = scopes_->current_var(); scopes_->set_current(scope); for (auto it = formals->begin(); it != formals->end(); ++it) if (!variable_add(nullptr, it->get())) return nullptr; scopes_->set_current(cur_scope); decl->scope_ = scope; scopes_->top_func()->add(id->name_, decl); return decl; } void Parser::set_loc(Node *n, const BisonParser::location_type &loc) const { n->line_ = loc.begin.line; n->column_ = loc.begin.column; n->text_ = lexer.text(loc); } string Parser::pragma(const string &name) const { auto it = pragmas_.find(name); if (it == pragmas_.end()) return "main"; return it->second; } } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/parser.h000066400000000000000000000047661305314114400215570ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include // NOLINT #include "node.h" #include "lexer.h" #include "scope.h" namespace ebpf { namespace cc { using std::pair; using std::string; using std::vector; class Parser { public: explicit Parser(const string& infile) : root_node_(NULL), scopes_(new Scopes), in_(infile), lexer(&in_), parser(lexer, *this) { // parser.set_debug_level(1); } ~Parser() { delete root_node_; } int parse() { return parser.parse(); } VariableDeclStmtNode * variable_add(vector *types, VariableDeclStmtNode *decl); VariableDeclStmtNode * variable_add(vector *types, VariableDeclStmtNode *decl, ExprNode *init_expr); StructVariableDeclStmtNode * variable_add(StructVariableDeclStmtNode *decl, ExprNodeList *args, bool is_kv); StmtNode * state_add(Scopes::StateScope *scope, IdentExprNode *id1, BlockStmtNode *body); StmtNode * state_add(Scopes::StateScope *scope, IdentExprNode *id1, IdentExprNode *id2, BlockStmtNode *body); StmtNode * func_add(std::vector *types, Scopes::StateScope *scope, IdentExprNode *id, FormalList *formals, BlockStmtNode *body); StmtNode * table_add(IdentExprNode *type, IdentExprNodeList *templates, IdentExprNode *id, string *size); StmtNode * struct_add(IdentExprNode *type, FormalList *formals); StmtNode * result_add(int token, IdentExprNode *id, FormalList *formals, BlockStmtNode *body); bool variable_exists(VariableDeclStmtNode *decl) const; bool table_exists(TableDeclStmtNode *decl, bool search_local = true); void add_pragma(const std::string& pr, const std::string& v) { pragmas_[pr] = v; } void set_loc(Node *n, const BisonParser::location_type &loc) const; std::string pragma(const std::string &name) const; Node *root_node_; Scopes::Ptr scopes_; std::map pragmas_; private: std::ifstream in_; Lexer lexer; BisonParser parser; }; } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/parser.yy000066400000000000000000000465511305314114400217670ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ %skeleton "lalr1.cc" %defines %define namespace "ebpf::cc" %define parser_class_name "BisonParser" %parse-param { ebpf::cc::Lexer &lexer } %parse-param { ebpf::cc::Parser &parser } %lex-param { ebpf::cc::Lexer &lexer } %locations %code requires { #include #include #include #include "node.h" // forward declaration namespace ebpf { namespace cc { class Lexer; class Parser; } } } %code { static int yylex(ebpf::cc::BisonParser::semantic_type *yylval, ebpf::cc::BisonParser::location_type *yylloc, ebpf::cc::Lexer &lexer); } %{ #include "node.h" #include "parser.h" using std::unique_ptr; using std::vector; using std::string; using std::move; %} %union { Scopes::StateScope *state_scope; Scopes::VarScope *var_scope; BlockStmtNode *block; ExprNode *expr; MethodCallExprNode *call; StmtNode *stmt; IdentExprNode *ident; IntegerExprNode *numeric; BitopExprNode *bitop; ExprNodeList *args; IdentExprNodeList *ident_args; StmtNodeList *stmts; FormalList *formals; VariableDeclStmtNode *decl; StructVariableDeclStmtNode *type_decl; TableIndexExprNode *table_index; std::vector *type_specifiers; std::string* string; int token; } /* Define the terminal symbols. */ %token TIDENTIFIER TINTEGER THEXINTEGER TPRAGMA TSTRING %token TU8 TU16 TU32 TU64 %token TEQUAL TCEQ TCNE TCLT TCLE TCGT TCGE TAND TOR %token TLPAREN TRPAREN TLBRACE TRBRACE TLBRACK TRBRACK %token TDOT TARROW TCOMMA TPLUS TMINUS TMUL TDIV TMOD TXOR TDOLLAR TCOLON TSCOPE TNOT TSEMI TCMPL TLAND TLOR %token TSTRUCT TSTATE TFUNC TGOTO TCONTINUE TNEXT TTRUE TFALSE TRETURN %token TIF TELSE TSWITCH TCASE %token TMATCH TMISS TFAILURE TVALID %token TAT /* Define non-terminal symbols as defined in the above union */ %type ident scoped_ident dotted_ident any_ident %type expr assign_expr return_expr init_arg_kv %type numeric %type bitop %type call_args /*init_args*/ init_args_kv %type table_decl_args %type struct_decl_stmts formals %type program block prog_decls %type decl_stmt int_decl ref_stmt %type type_decl ptr_decl %type stmt prog_decl var_decl struct_decl state_decl func_decl %type table_decl table_result_stmt if_stmt switch_stmt case_stmt onvalid_stmt %type enter_varscope exit_varscope %type enter_statescope exit_statescope %type stmts table_result_stmts case_stmts %type call_expr %type table_index_expr %type type_specifiers %type pragma_decl %type type_specifier /* taken from C++ operator precedence wiki page */ %nonassoc TSCOPE %left TDOT TLBRACK TLBRACE TLPAREN TINCR TDECR %right TNOT TCMPL %left TMUL %left TDIV %left TMOD %left TPLUS %left TMINUS %left TCLT TCLE TCGT TCGE %left TCEQ %left TCNE %left TXOR %left TAND %left TOR %left TLAND %left TLOR %right TEQUAL %start program %% program : enter_statescope enter_varscope prog_decls exit_varscope exit_statescope { parser.root_node_ = $3; $3->scope_ = $2; } ; /* program is a list of declarations */ prog_decls : prog_decl { $$ = new BlockStmtNode; $$->stmts_.push_back(StmtNode::Ptr($1)); } | prog_decls prog_decl { $1->stmts_.push_back(StmtNode::Ptr($2)); } ; /* possible program declarations are: "struct {}" "state|on_miss|on_match|on_valid {}" "var " "Table <...> (size)" */ prog_decl : var_decl TSEMI | struct_decl TSEMI | state_decl | table_decl TSEMI | pragma_decl | func_decl ; pragma_decl : TPRAGMA TIDENTIFIER TIDENTIFIER { $$ = new BlockStmtNode; parser.add_pragma(*$2, *$3); delete $2; delete $3; } | TPRAGMA TIDENTIFIER TSTRING { $$ = new BlockStmtNode; parser.add_pragma(*$2, *$3); delete $2; delete $3; } ; stmts : stmt { $$ = new StmtNodeList; $$->push_back(StmtNode::Ptr($1)); } | stmts stmt { $1->push_back(StmtNode::Ptr($2)); } ; stmt : expr TSEMI { $$ = new ExprStmtNode(ExprNode::Ptr($1)); parser.set_loc($$, @$); } | assign_expr TSEMI { $$ = new ExprStmtNode(ExprNode::Ptr($1)); parser.set_loc($$, @$); } | return_expr TSEMI { $$ = new ExprStmtNode(ExprNode::Ptr($1)); parser.set_loc($$, @$); } | call_expr TLBRACE enter_varscope table_result_stmts exit_varscope TRBRACE TSEMI { $$ = new ExprStmtNode(ExprNode::Ptr($1)); $1->block_->stmts_ = move(*$4); delete $4; $1->block_->scope_ = $3; parser.set_loc($$, @$); } | call_expr TLBRACE TRBRACE TSEMI // support empty curly braces { $$ = new ExprStmtNode(ExprNode::Ptr($1)); parser.set_loc($$, @$); } | if_stmt | switch_stmt | var_decl TSEMI { $$ = $1; } | state_decl | onvalid_stmt ; call_expr : any_ident TLPAREN call_args TRPAREN { $$ = new MethodCallExprNode(IdentExprNode::Ptr($1), move(*$3), lexer.lineno()); delete $3; parser.set_loc($$, @$); } ; block : TLBRACE stmts TRBRACE { $$ = new BlockStmtNode; $$->stmts_ = move(*$2); delete $2; parser.set_loc($$, @$); } | TLBRACE TRBRACE { $$ = new BlockStmtNode; parser.set_loc($$, @$); } ; enter_varscope : /* empty */ { $$ = parser.scopes_->enter_var_scope(); } ; exit_varscope : /* emtpy */ { $$ = parser.scopes_->exit_var_scope(); } ; enter_statescope : /* empty */ { $$ = parser.scopes_->enter_state_scope(); } ; exit_statescope : /* emtpy */ { $$ = parser.scopes_->exit_state_scope(); } ; struct_decl : TSTRUCT ident TLBRACE struct_decl_stmts TRBRACE { $$ = parser.struct_add($2, $4); delete $4; parser.set_loc($$, @$); } ; struct_decl_stmts : type_specifiers decl_stmt TSEMI { $$ = new FormalList; $$->push_back(VariableDeclStmtNode::Ptr($2)); } | struct_decl_stmts type_specifiers decl_stmt TSEMI { $1->push_back(VariableDeclStmtNode::Ptr($3)); } ; table_decl : ident TCLT table_decl_args TCGT ident TLPAREN TINTEGER TRPAREN { $$ = parser.table_add($1, $3, $5, $7); delete $3; parser.set_loc($$, @$); } ; table_decl_args : ident { $$ = new IdentExprNodeList; $$->push_back(IdentExprNode::Ptr($1)); } | table_decl_args TCOMMA ident { $$->push_back(IdentExprNode::Ptr($3)); } ; state_decl : TSTATE scoped_ident enter_statescope enter_varscope block exit_varscope exit_statescope { $$ = parser.state_add($3, $2, $5); $5->scope_ = $4; if (!$$) YYERROR; parser.set_loc($$, @$); } | TSTATE scoped_ident TCOMMA TMUL enter_statescope enter_varscope block exit_varscope exit_statescope { $$ = parser.state_add($5, $2, new IdentExprNode(""), $7); $7->scope_ = $6; if (!$$) YYERROR; parser.set_loc($$, @$); } | TSTATE scoped_ident TCOMMA scoped_ident enter_statescope enter_varscope block exit_varscope exit_statescope { $$ = parser.state_add($5, $2, $4, $7); $7->scope_ = $6; if (!$$) YYERROR; parser.set_loc($$, @$); } ; func_decl : type_specifiers ident enter_statescope enter_varscope TLPAREN formals TRPAREN block exit_varscope exit_statescope { $$ = parser.func_add($1, $3, $2, $6, $8); $8->scope_ = $4; if (!$$) YYERROR; parser.set_loc($$, @$); } ; table_result_stmts : table_result_stmt { $$ = new StmtNodeList; $$->push_back(StmtNode::Ptr($1)); } | table_result_stmts table_result_stmt { $$->push_back(StmtNode::Ptr($2)); } ; table_result_stmt : TMATCH ident enter_varscope TLPAREN formals TRPAREN block exit_varscope TSEMI { $$ = parser.result_add($1, $2, $5, $7); delete $5; $7->scope_ = $3; if (!$$) YYERROR; parser.set_loc($$, @$); } | TMISS ident enter_varscope TLPAREN TRPAREN block exit_varscope TSEMI { $$ = parser.result_add($1, $2, new FormalList, $6); $6->scope_ = $3; if (!$$) YYERROR; parser.set_loc($$, @$); } | TFAILURE ident enter_varscope TLPAREN formals TRPAREN block exit_varscope TSEMI { $$ = parser.result_add($1, $2, $5, $7); delete $5; $7->scope_ = $3; if (!$$) YYERROR; parser.set_loc($$, @$); } ; formals : TSTRUCT ptr_decl { $$ = new FormalList; $$->push_back(VariableDeclStmtNode::Ptr(parser.variable_add(nullptr, $2))); } | formals TCOMMA TSTRUCT ptr_decl { $1->push_back(VariableDeclStmtNode::Ptr(parser.variable_add(nullptr, $4))); } ; type_specifier : TU8 | TU16 | TU32 | TU64 ; type_specifiers : type_specifier { $$ = new std::vector; $$->push_back($1); } | type_specifiers type_specifier { $$->push_back($2); } ; var_decl : type_specifiers decl_stmt { $$ = parser.variable_add($1, $2); if (!$$) YYERROR; parser.set_loc($$, @$); } | type_specifiers int_decl TEQUAL expr { $$ = parser.variable_add($1, $2, $4); if (!$$) YYERROR; parser.set_loc($$, @$); } | TSTRUCT type_decl TEQUAL TLBRACE init_args_kv TRBRACE { $$ = parser.variable_add($2, $5, true); if (!$$) YYERROR; parser.set_loc($$, @$); } /*| TSTRUCT type_decl TEQUAL TLBRACE init_args TRBRACE { $$ = parser.variable_add($2, $5, false); parser.set_loc($$, @$); }*/ | TSTRUCT ref_stmt { $$ = parser.variable_add(nullptr, $2); if (!$$) YYERROR; parser.set_loc($$, @$); } ; /* "id":"bitsize" or "type" "id" */ decl_stmt : int_decl { $$ = $1; } | type_decl { $$ = $1; }; int_decl : ident TCOLON TINTEGER { $$ = new IntegerVariableDeclStmtNode(IdentExprNode::Ptr($1), *$3); delete $3; parser.set_loc($$, @$); } ; type_decl : scoped_ident ident { $$ = new StructVariableDeclStmtNode(IdentExprNode::Ptr($1), IdentExprNode::Ptr($2)); parser.set_loc($$, @$); } ; /* "type" "*" "id" */ ref_stmt : ptr_decl { $$ = $1; }; ptr_decl : scoped_ident TMUL ident { $$ = new StructVariableDeclStmtNode(IdentExprNode::Ptr($1), IdentExprNode::Ptr($3), VariableDeclStmtNode::STRUCT_REFERENCE); parser.set_loc($$, @$); } ; /* normal initializer */ /* init_args : expr { $$ = new ExprNodeList; $$->push_back(ExprNode::Ptr($1)); } | init_args TCOMMA expr { $$->push_back(ExprNode::Ptr($3)); } ;*/ /* one or more of "field" = "expr" */ init_args_kv : init_arg_kv { $$ = new ExprNodeList; $$->push_back(ExprNode::Ptr($1)); } | init_args_kv TCOMMA init_arg_kv { $$->push_back(ExprNode::Ptr($3)); } ; init_arg_kv : TDOT ident TEQUAL expr { $$ = new AssignExprNode(IdentExprNode::Ptr($2), ExprNode::Ptr($4)); parser.set_loc($$, @$); } | TDOT ident bitop TEQUAL expr { $$ = new AssignExprNode(IdentExprNode::Ptr($2), ExprNode::Ptr($5)); $$->bitop_ = BitopExprNode::Ptr($3); parser.set_loc($$, @$); } ; if_stmt : TIF expr enter_varscope block exit_varscope { $$ = new IfStmtNode(ExprNode::Ptr($2), StmtNode::Ptr($4)); $4->scope_ = $3; parser.set_loc($$, @$); } | TIF expr enter_varscope block exit_varscope TELSE enter_varscope block exit_varscope { $$ = new IfStmtNode(ExprNode::Ptr($2), StmtNode::Ptr($4), StmtNode::Ptr($8)); $4->scope_ = $3; $8->scope_ = $7; parser.set_loc($$, @$); } | TIF expr enter_varscope block exit_varscope TELSE if_stmt { $$ = new IfStmtNode(ExprNode::Ptr($2), StmtNode::Ptr($4), StmtNode::Ptr($7)); $4->scope_ = $3; parser.set_loc($$, @$); } ; onvalid_stmt : TVALID TLPAREN ident TRPAREN enter_varscope block exit_varscope { $$ = new OnValidStmtNode(IdentExprNode::Ptr($3), StmtNode::Ptr($6)); $6->scope_ = $5; parser.set_loc($$, @$); } | TVALID TLPAREN ident TRPAREN enter_varscope block exit_varscope TELSE enter_varscope block exit_varscope { $$ = new OnValidStmtNode(IdentExprNode::Ptr($3), StmtNode::Ptr($6), StmtNode::Ptr($10)); $6->scope_ = $5; $10->scope_ = $9; parser.set_loc($$, @$); } ; switch_stmt : TSWITCH expr TLBRACE case_stmts TRBRACE { $$ = new SwitchStmtNode(ExprNode::Ptr($2), make_unique(move(*$4))); delete $4; parser.set_loc($$, @$); } ; case_stmts : case_stmt { $$ = new StmtNodeList; $$->push_back(StmtNode::Ptr($1)); } | case_stmts case_stmt { $$->push_back(StmtNode::Ptr($2)); } ; case_stmt : TCASE numeric block TSEMI { $$ = new CaseStmtNode(IntegerExprNode::Ptr($2), BlockStmtNode::Ptr($3)); parser.set_loc($$, @$); } | TCASE TMUL block TSEMI { $$ = new CaseStmtNode(BlockStmtNode::Ptr($3)); parser.set_loc($$, @$); } ; numeric : TINTEGER { $$ = new IntegerExprNode($1); parser.set_loc($$, @$); } | THEXINTEGER { $$ = new IntegerExprNode($1); parser.set_loc($$, @$); } | TINTEGER TCOLON TINTEGER { $$ = new IntegerExprNode($1, $3); parser.set_loc($$, @$); } | THEXINTEGER TCOLON TINTEGER { $$ = new IntegerExprNode($1, $3); parser.set_loc($$, @$); } | TTRUE { $$ = new IntegerExprNode(new string("1"), new string("1")); parser.set_loc($$, @$); } | TFALSE { $$ = new IntegerExprNode(new string("0"), new string("1")); parser.set_loc($$, @$); } ; assign_expr : expr TEQUAL expr { $$ = new AssignExprNode(ExprNode::Ptr($1), ExprNode::Ptr($3)); parser.set_loc($$, @$); } /* The below has a reduce/reduce conflict. TODO: ensure the above is handled in the type check properly */ /*| dotted_ident TEQUAL expr { $$ = new AssignExprNode(IdentExprNode::Ptr($1), ExprNode::Ptr($3)); parser.set_loc($$, @$); } | dotted_ident bitop TEQUAL expr { $$ = new AssignExprNode(IdentExprNode::Ptr($1), ExprNode::Ptr($4)); $$->bitop_ = BitopExprNode::Ptr($2); parser.set_loc($$, @$); }*/ ; return_expr : TRETURN expr { $$ = new ReturnExprNode(ExprNode::Ptr($2)); parser.set_loc($$, @$); } ; expr : call_expr { $$ = $1; } | call_expr bitop { $$ = $1; $$->bitop_ = BitopExprNode::Ptr($2); } | table_index_expr { $$ = $1; } | table_index_expr TDOT ident { $$ = $1; $1->sub_ = IdentExprNode::Ptr($3); } | any_ident { $$ = $1; } | TAT dotted_ident { $$ = new PacketExprNode(IdentExprNode::Ptr($2)); $$->flags_[ExprNode::IS_REF] = true; parser.set_loc($$, @$); } | TDOLLAR dotted_ident { $$ = new PacketExprNode(IdentExprNode::Ptr($2)); $$->flags_[ExprNode::IS_PKT] = true; parser.set_loc($$, @$); } | TDOLLAR dotted_ident bitop { $$ = new PacketExprNode(IdentExprNode::Ptr($2)); $$->bitop_ = BitopExprNode::Ptr($3); $$->flags_[ExprNode::IS_PKT] = true; parser.set_loc($$, @$); } | TGOTO scoped_ident { $$ = new GotoExprNode(IdentExprNode::Ptr($2), false); parser.set_loc($$, @$); } | TNEXT scoped_ident { $$ = new GotoExprNode(IdentExprNode::Ptr($2), false); parser.set_loc($$, @$); } | TCONTINUE scoped_ident { $$ = new GotoExprNode(IdentExprNode::Ptr($2), true); parser.set_loc($$, @$); } | TLPAREN expr TRPAREN { $$ = $2; } | TLPAREN expr TRPAREN bitop { $$ = $2; $$->bitop_ = BitopExprNode::Ptr($4); } | TSTRING { $$ = new StringExprNode($1); parser.set_loc($$, @$); } | numeric { $$ = $1; } | numeric bitop { $$ = $1; $$->bitop_ = BitopExprNode::Ptr($2); } | expr TCLT expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TCGT expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TCGE expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TCLE expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TCNE expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TCEQ expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TPLUS expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TMINUS expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TMUL expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TDIV expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TMOD expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TXOR expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TAND expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TOR expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TLAND expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } | expr TLOR expr { $$ = new BinopExprNode(ExprNode::Ptr($1), $2, ExprNode::Ptr($3)); parser.set_loc($$, @$); } /*| expr bitop { $$ = $1; $$->bitop_ = BitopExprNode::Ptr($2); }*/ | TNOT expr { $$ = new UnopExprNode($1, ExprNode::Ptr($2)); parser.set_loc($$, @$); } | TCMPL expr { $$ = new UnopExprNode($1, ExprNode::Ptr($2)); parser.set_loc($$, @$); } ; call_args : /* empty */ { $$ = new ExprNodeList; } | expr { $$ = new ExprNodeList; $$->push_back(ExprNode::Ptr($1)); } | call_args TCOMMA expr { $$->push_back(ExprNode::Ptr($3)); } ; bitop : TLBRACK TCOLON TPLUS TINTEGER TRBRACK { $$ = new BitopExprNode(string("0"), *$4); delete $4; parser.set_loc($$, @$); } | TLBRACK TINTEGER TCOLON TPLUS TINTEGER TRBRACK { $$ = new BitopExprNode(*$2, *$5); delete $2; delete $5; parser.set_loc($$, @$); } ; table_index_expr : dotted_ident TLBRACK ident TRBRACK { $$ = new TableIndexExprNode(IdentExprNode::Ptr($1), IdentExprNode::Ptr($3)); parser.set_loc($$, @$); } ; scoped_ident : ident { $$ = $1; } | scoped_ident TSCOPE TIDENTIFIER { $$->append_scope(*$3); delete $3; } ; dotted_ident : ident { $$ = $1; } | dotted_ident TDOT TIDENTIFIER { $$->append_dot(*$3); delete $3; } ; any_ident : ident { $$ = $1; } | dotted_ident TARROW TIDENTIFIER { $$->append_dot(*$3); delete $3; } | dotted_ident TDOT TIDENTIFIER { $$->append_dot(*$3); delete $3; } | scoped_ident TSCOPE TIDENTIFIER { $$->append_scope(*$3); delete $3; } ; ident : TIDENTIFIER { $$ = new IdentExprNode(*$1); delete $1; parser.set_loc($$, @$); } ; %% void ebpf::cc::BisonParser::error(const ebpf::cc::BisonParser::location_type &loc, const string& msg) { std::cerr << "Error: " << loc << " " << msg << std::endl; } #include "lexer.h" static int yylex(ebpf::cc::BisonParser::semantic_type *yylval, ebpf::cc::BisonParser::location_type *yylloc, ebpf::cc::Lexer &lexer) { return lexer.yylex(yylval, yylloc); } bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/printer.cc000066400000000000000000000212161305314114400220710ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "printer.h" #include "lexer.h" #include "bcc_exception.h" namespace ebpf { namespace cc { void Printer::print_indent() { fprintf(out_, "%*s", indent_, ""); } StatusTuple Printer::visit_block_stmt_node(BlockStmtNode* n) { fprintf(out_, "{\n"); if (!n->stmts_.empty()) { ++indent_; for (auto it = n->stmts_.begin(); it != n->stmts_.end(); ++it) { print_indent(); TRY2((*it)->accept(this)); fprintf(out_, "\n"); } --indent_; } fprintf(out_, "%*s}", indent_, ""); return StatusTuple(0); } StatusTuple Printer::visit_if_stmt_node(IfStmtNode* n) { fprintf(out_, "if "); TRY2(n->cond_->accept(this)); fprintf(out_, " "); TRY2(n->true_block_->accept(this)); if (n->false_block_) { fprintf(out_, " else "); TRY2(n->false_block_->accept(this)); } return StatusTuple(0); } StatusTuple Printer::visit_onvalid_stmt_node(OnValidStmtNode* n) { fprintf(out_, "if "); TRY2(n->cond_->accept(this)); fprintf(out_, " "); TRY2(n->block_->accept(this)); if (n->else_block_) { fprintf(out_, " else "); TRY2(n->else_block_->accept(this)); } return StatusTuple(0); } StatusTuple Printer::visit_switch_stmt_node(SwitchStmtNode* n) { fprintf(out_, "switch ("); TRY2(n->cond_->accept(this)); fprintf(out_, ") "); TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_case_stmt_node(CaseStmtNode* n) { if (n->value_) { fprintf(out_, "case "); TRY2(n->value_->accept(this)); } else { fprintf(out_, "default"); } TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_ident_expr_node(IdentExprNode* n) { if (n->scope_name_.size()) { fprintf(out_, "%s::", n->scope_name_.c_str()); } fprintf(out_, "%s", n->name_.c_str()); if (n->sub_name_.size()) { fprintf(out_, ".%s", n->sub_name_.c_str()); } return StatusTuple(0); } StatusTuple Printer::visit_assign_expr_node(AssignExprNode* n) { TRY2(n->lhs_->accept(this)); fprintf(out_, " = "); TRY2(n->rhs_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_packet_expr_node(PacketExprNode* n) { fprintf(out_, "$"); TRY2(n->id_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_integer_expr_node(IntegerExprNode* n) { fprintf(out_, "%s:%zu", n->val_.c_str(), n->bits_); return StatusTuple(0); } StatusTuple Printer::visit_string_expr_node(StringExprNode *n) { fprintf(out_, "%s", n->val_.c_str()); return StatusTuple(0); } StatusTuple Printer::visit_binop_expr_node(BinopExprNode* n) { TRY2(n->lhs_->accept(this)); fprintf(out_, "%d", n->op_); TRY2(n->rhs_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_unop_expr_node(UnopExprNode* n) { const char* s = ""; switch (n->op_) { case Tok::TNOT: s = "!"; break; case Tok::TCMPL: s = "~"; break; case Tok::TMOD: s = "%"; break; default: {} } fprintf(out_, "%s", s); TRY2(n->expr_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_bitop_expr_node(BitopExprNode* n) { return StatusTuple(0); } StatusTuple Printer::visit_return_expr_node(ReturnExprNode* n) { fprintf(out_, "return "); TRY2(n->expr_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_goto_expr_node(GotoExprNode* n) { const char* s = n->is_continue_ ? "continue " : "goto "; fprintf(out_, "%s", s); TRY2(n->id_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_method_call_expr_node(MethodCallExprNode* n) { TRY2(n->id_->accept(this)); fprintf(out_, "("); for (auto it = n->args_.begin(); it != n->args_.end(); ++it) { TRY2((*it)->accept(this)); if (it + 1 != n->args_.end()) { fprintf(out_, ", "); } } fprintf(out_, ")"); if (!n->block_->stmts_.empty()) { fprintf(out_, " {\n"); ++indent_; for (auto it = n->block_->stmts_.begin(); it != n->block_->stmts_.end(); ++it) { print_indent(); TRY2((*it)->accept(this)); fprintf(out_, "\n"); } --indent_; fprintf(out_, "%*s}", indent_, ""); } return StatusTuple(0); } StatusTuple Printer::visit_table_index_expr_node(TableIndexExprNode *n) { fprintf(out_, "%s[", n->id_->c_str()); TRY2(n->index_->accept(this)); fprintf(out_, "]"); return StatusTuple(0); } StatusTuple Printer::visit_expr_stmt_node(ExprStmtNode* n) { TRY2(n->expr_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_struct_variable_decl_stmt_node(StructVariableDeclStmtNode* n) { fprintf(out_, "var "); TRY2(n->struct_id_->accept(this)); fprintf(out_, " "); TRY2(n->id_->accept(this)); if (!n->init_.empty()) { fprintf(out_, "{"); for (auto it = n->init_.begin(); it != n->init_.end(); ++it) { TRY2((*it)->accept(this)); if (it + 1 != n->init_.end()) { fprintf(out_, ", "); } } fprintf(out_, "}"); } return StatusTuple(0); } StatusTuple Printer::visit_integer_variable_decl_stmt_node(IntegerVariableDeclStmtNode* n) { fprintf(out_, "var "); TRY2(n->id_->accept(this)); fprintf(out_, ":%zu", n->bit_width_); if (!n->init_.empty()) { fprintf(out_, "; "); TRY2(n->init_[0]->accept(this)); } return StatusTuple(0); } StatusTuple Printer::visit_struct_decl_stmt_node(StructDeclStmtNode* n) { fprintf(out_, "struct "); TRY2(n->id_->accept(this)); fprintf(out_, " {\n"); ++indent_; for (auto it = n->stmts_.begin(); it != n->stmts_.end(); ++it) { print_indent(); TRY2((*it)->accept(this)); fprintf(out_, "\n"); } --indent_; fprintf(out_, "%*s}", indent_, ""); return StatusTuple(0); } StatusTuple Printer::visit_state_decl_stmt_node(StateDeclStmtNode* n) { if (!n->id_) { return StatusTuple(0); } fprintf(out_, "state "); TRY2(n->id_->accept(this)); //if (!n->id2_) { // fprintf(out_, ", * "); //} else { // fprintf(out_, ", "); // TRY2(n->id2_->accept(this)); //} //TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_parser_state_stmt_node(ParserStateStmtNode* n) { return StatusTuple(0); } StatusTuple Printer::visit_match_decl_stmt_node(MatchDeclStmtNode* n) { fprintf(out_, "on_match "); TRY2(n->id_->accept(this)); fprintf(out_, " ("); for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { TRY2((*it)->accept(this)); if (it + 1 != n->formals_.end()) { fprintf(out_, ", "); } } fprintf(out_, ") "); TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_miss_decl_stmt_node(MissDeclStmtNode* n) { fprintf(out_, "on_miss "); TRY2(n->id_->accept(this)); fprintf(out_, " ("); for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { TRY2((*it)->accept(this)); if (it + 1 != n->formals_.end()) { fprintf(out_, ", "); } } fprintf(out_, ") "); TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_failure_decl_stmt_node(FailureDeclStmtNode* n) { fprintf(out_, "on_failure "); TRY2(n->id_->accept(this)); fprintf(out_, " ("); for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { TRY2((*it)->accept(this)); if (it + 1 != n->formals_.end()) { fprintf(out_, ", "); } } fprintf(out_, ") "); TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple Printer::visit_table_decl_stmt_node(TableDeclStmtNode* n) { TRY2(n->table_type_->accept(this)); fprintf(out_, "<"); for (auto it = n->templates_.begin(); it != n->templates_.end(); ++it) { TRY2((*it)->accept(this)); if (it + 1 != n->templates_.end()) { fprintf(out_, ", "); } } fprintf(out_, "> "); TRY2(n->id_->accept(this)); fprintf(out_, "(%zu)", n->size_); return StatusTuple(0); } StatusTuple Printer::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { fprintf(out_, "func "); TRY2(n->id_->accept(this)); fprintf(out_, "("); for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { TRY2((*it)->accept(this)); if (it + 1 != n->formals_.end()) { fprintf(out_, ", "); } } fprintf(out_, ") "); TRY2(n->block_->accept(this)); return StatusTuple(0); } } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/printer.h000066400000000000000000000017471305314114400217420ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include "node.h" namespace ebpf { namespace cc { class Printer : public Visitor { public: explicit Printer(FILE* out) : out_(out), indent_(0) {} void print_indent(); #define VISIT(type, func) virtual STATUS_RETURN visit_##func(type* n); EXPAND_NODES(VISIT) #undef VISIT private: FILE* out_; int indent_; }; } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/scope.h000066400000000000000000000123241305314114400213610ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include namespace ebpf { namespace cc { using std::string; using std::vector; using std::map; using std::pair; using std::unique_ptr; class StateDeclStmtNode; class VariableDeclStmtNode; class TableDeclStmtNode; class StructDeclStmtNode; class FuncDeclStmtNode; enum search_type { SCOPE_LOCAL, SCOPE_GLOBAL }; template class Scope { public: Scope() {} Scope(Scope* scope, int id) : parent_(scope), id_(id) {} T* lookup(const string &name, bool search_local = true) { return lookup(name, search_local ? SCOPE_LOCAL : SCOPE_GLOBAL); } T * lookup(const string &name, search_type stype) { auto it = elems_.find(name); if (it != elems_.end()) return it->second; if (stype == SCOPE_LOCAL || !parent_) return nullptr; return parent_->lookup(name, stype); } void add(const string& name, T* n) { elems_[name] = n; elems_ordered_.push_back(n); } typename map::iterator begin() { return elems_.begin(); } typename map::iterator end() { return elems_.end(); } typename vector::iterator obegin() { return elems_ordered_.begin(); } typename vector::iterator oend() { return elems_ordered_.end(); } Scope *parent_; int id_; map elems_; vector elems_ordered_; }; /** * Hold the current stack of scope pointers. Lookups search upwards. * Actual scope pointers are kept in the AST. */ class Scopes { public: typedef unique_ptr Ptr; typedef Scope StructScope; typedef Scope StateScope; typedef Scope VarScope; typedef Scope TableScope; typedef Scope FuncScope; Scopes() : var_id__(0), state_id_(0), var_id_(0), current_var_scope_(nullptr), top_var_scope_(nullptr), current_state_scope_(nullptr), top_state_scope_(nullptr), top_struct_scope_(new StructScope(nullptr, 1)), top_table_scope_(new TableScope(nullptr, 1)), top_func_scope_(new FuncScope(nullptr, 1)) {} ~Scopes() { delete top_func_scope_; delete top_struct_scope_; delete top_table_scope_; delete top_state_scope_; } void push_var(VarScope *scope) { if (scope == top_var_scope_) return; scope->parent_ = current_var_scope_; current_var_scope_ = scope; } void pop_var() { if (current_var_scope_ == top_var_scope_) return; VarScope *old = current_var_scope_; current_var_scope_ = old->parent_; old->parent_ = nullptr; } void push_state(StateScope *scope) { if (scope == top_state_scope_) return; scope->parent_ = current_state_scope_; current_state_scope_ = scope; } void pop_state() { if (current_state_scope_ == top_state_scope_) return; StateScope *old = current_state_scope_; current_state_scope_ = old->parent_; old->parent_ = nullptr; } /// While building the AST, allocate a new scope VarScope* enter_var_scope() { current_var_scope_ = new VarScope(current_var_scope_, next_var_id()); if (!top_var_scope_) { top_var_scope_ = current_var_scope_; } return current_var_scope_; } VarScope* exit_var_scope() { current_var_scope_ = current_var_scope_->parent_; return current_var_scope_; } StateScope* enter_state_scope() { current_state_scope_ = new StateScope(current_state_scope_, next_state_id()); if (!top_state_scope_) { top_state_scope_ = current_state_scope_; } return current_state_scope_; } StateScope* exit_state_scope() { current_state_scope_ = current_state_scope_->parent_; return current_state_scope_; } void set_current(VarScope* s) { current_var_scope_ = s; } VarScope* current_var() const { return current_var_scope_; } VarScope* top_var() const { return top_var_scope_; } void set_current(StateScope* s) { current_state_scope_ = s; } StateScope* current_state() const { return current_state_scope_; } StateScope* top_state() const { return top_state_scope_; } StructScope* top_struct() const { return top_struct_scope_; } TableScope* top_table() const { return top_table_scope_; } FuncScope* top_func() const { return top_func_scope_; } int next_id() { return ++var_id__; } int next_state_id() { return ++state_id_; } int next_var_id() { return ++var_id_; } int var_id__; int state_id_; int var_id_; VarScope* current_var_scope_; VarScope* top_var_scope_; StateScope* current_state_scope_; StateScope* top_state_scope_; StructScope* top_struct_scope_; TableScope* top_table_scope_; FuncScope* top_func_scope_; }; } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/type_check.cc000066400000000000000000000526521305314114400225340ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "bcc_exception.h" #include "type_check.h" #include "lexer.h" namespace ebpf { namespace cc { using std::for_each; using std::set; StatusTuple TypeCheck::visit_block_stmt_node(BlockStmtNode *n) { // enter scope if (n->scope_) scopes_->push_var(n->scope_); if (!n->stmts_.empty()) { for (auto it = n->stmts_.begin(); it != n->stmts_.end(); ++it) TRY2((*it)->accept(this)); } if (n->scope_) scopes_->pop_var(); return StatusTuple(0); } StatusTuple TypeCheck::visit_if_stmt_node(IfStmtNode *n) { TRY2(n->cond_->accept(this)); //if (n->cond_->typeof_ != ExprNode::INTEGER) // return mkstatus_(n, "If condition must be a numeric type"); TRY2(n->true_block_->accept(this)); if (n->false_block_) { TRY2(n->false_block_->accept(this)); } return StatusTuple(0); } StatusTuple TypeCheck::visit_onvalid_stmt_node(OnValidStmtNode *n) { TRY2(n->cond_->accept(this)); auto sdecl = static_cast(n->cond_->decl_); if (sdecl->storage_type_ != StructVariableDeclStmtNode::STRUCT_REFERENCE) return mkstatus_(n, "on_valid condition must be a reference type"); TRY2(n->block_->accept(this)); if (n->else_block_) { TRY2(n->else_block_->accept(this)); } return StatusTuple(0); } StatusTuple TypeCheck::visit_switch_stmt_node(SwitchStmtNode *n) { TRY2(n->cond_->accept(this)); if (n->cond_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Switch condition must be a numeric type"); TRY2(n->block_->accept(this)); for (auto it = n->block_->stmts_.begin(); it != n->block_->stmts_.end(); ++it) { /// @todo check for duplicates } return StatusTuple(0); } StatusTuple TypeCheck::visit_case_stmt_node(CaseStmtNode *n) { if (n->value_) { TRY2(n->value_->accept(this)); if (n->value_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Switch condition must be a numeric type"); } TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple TypeCheck::visit_ident_expr_node(IdentExprNode *n) { n->decl_ = scopes_->current_var()->lookup(n->name_, SCOPE_GLOBAL); if (!n->decl_) return mkstatus_(n, "Variable %s lookup failed", n->c_str()); n->typeof_ = ExprNode::UNKNOWN; if (n->sub_name_.empty()) { if (n->decl_->storage_type_ == VariableDeclStmtNode::INTEGER) { n->typeof_ = ExprNode::INTEGER; n->bit_width_ = n->decl_->bit_width_; n->flags_[ExprNode::WRITE] = true; } else if (n->decl_->is_struct()) { n->typeof_ = ExprNode::STRUCT; auto sdecl = static_cast(n->decl_); if (sdecl->struct_id_->scope_name_ == "proto") { n->struct_type_ = proto_scopes_->top_struct()->lookup(sdecl->struct_id_->name_, true); n->flags_[ExprNode::PROTO] = true; } else { n->struct_type_ = scopes_->top_struct()->lookup(sdecl->struct_id_->name_, true); } if (!n->struct_type_) return mkstatus_(n, "Type %s has not been declared", sdecl->struct_id_->full_name().c_str()); n->bit_width_ = n->struct_type_->bit_width_; } } else { if (n->decl_->storage_type_ == VariableDeclStmtNode::INTEGER) return mkstatus_(n, "Subfield access not valid for numeric types"); auto sdecl = static_cast(n->decl_); if (sdecl->struct_id_->scope_name_ == "proto") { n->struct_type_ = proto_scopes_->top_struct()->lookup(sdecl->struct_id_->name_, true); n->flags_[ExprNode::PROTO] = true; } else { n->struct_type_ = scopes_->top_struct()->lookup(sdecl->struct_id_->name_, true); } if (!n->struct_type_) return mkstatus_(n, "Type %s has not been declared", sdecl->struct_id_->full_name().c_str()); n->sub_decl_ = n->struct_type_->field(n->sub_name_); if (!n->sub_decl_) return mkstatus_(n, "Access to invalid subfield %s.%s", n->c_str(), n->sub_name_.c_str()); if (n->sub_decl_->storage_type_ != VariableDeclStmtNode::INTEGER) return mkstatus_(n, "Accessing non-numeric subfield %s.%s", n->c_str(), n->sub_name_.c_str()); n->typeof_ = ExprNode::INTEGER; n->bit_width_ = n->sub_decl_->bit_width_; n->flags_[ExprNode::WRITE] = true; } return StatusTuple(0); } StatusTuple TypeCheck::visit_assign_expr_node(AssignExprNode *n) { /// @todo check lhs is assignable TRY2(n->lhs_->accept(this)); if (n->lhs_->typeof_ == ExprNode::STRUCT) { TRY2(n->rhs_->accept(this)); if (n->rhs_->typeof_ != ExprNode::STRUCT) return mkstatus_(n, "Right-hand side of assignment must be a struct"); } else { if (n->lhs_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Left-hand side of assignment must be a numeric type"); if (!n->lhs_->flags_[ExprNode::WRITE]) return mkstatus_(n, "Left-hand side of assignment is read-only"); TRY2(n->rhs_->accept(this)); if (n->rhs_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Right-hand side of assignment must be a numeric type"); } n->typeof_ = ExprNode::VOID; return StatusTuple(0); } StatusTuple TypeCheck::visit_packet_expr_node(PacketExprNode *n) { StructDeclStmtNode *struct_type = proto_scopes_->top_struct()->lookup(n->id_->name_, true); if (!struct_type) return mkstatus_(n, "Undefined packet header %s", n->id_->c_str()); if (n->id_->sub_name_.empty()) { n->typeof_ = ExprNode::STRUCT; n->struct_type_ = struct_type; } else { VariableDeclStmtNode *sub_decl = struct_type->field(n->id_->sub_name_); if (!sub_decl) return mkstatus_(n, "Access to invalid subfield %s.%s", n->id_->c_str(), n->id_->sub_name_.c_str()); n->typeof_ = ExprNode::INTEGER; if (n->is_ref()) n->bit_width_ = 64; else n->bit_width_ = sub_decl->bit_width_; } n->flags_[ExprNode::WRITE] = true; return StatusTuple(0); } StatusTuple TypeCheck::visit_integer_expr_node(IntegerExprNode *n) { n->typeof_ = ExprNode::INTEGER; n->bit_width_ = n->bits_; return StatusTuple(0); } StatusTuple TypeCheck::visit_string_expr_node(StringExprNode *n) { n->typeof_ = ExprNode::STRING; n->flags_[ExprNode::IS_REF] = true; n->bit_width_ = n->val_.size() << 3; return StatusTuple(0); } StatusTuple TypeCheck::visit_binop_expr_node(BinopExprNode *n) { TRY2(n->lhs_->accept(this)); if (n->lhs_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Left-hand side of binary expression must be a numeric type"); TRY2(n->rhs_->accept(this)); if (n->rhs_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Right-hand side of binary expression must be a numeric type"); n->typeof_ = ExprNode::INTEGER; switch(n->op_) { case Tok::TCEQ: case Tok::TCNE: case Tok::TCLT: case Tok::TCLE: case Tok::TCGT: case Tok::TCGE: n->bit_width_ = 1; default: n->bit_width_ = std::max(n->lhs_->bit_width_, n->rhs_->bit_width_); } return StatusTuple(0); } StatusTuple TypeCheck::visit_unop_expr_node(UnopExprNode *n) { TRY2(n->expr_->accept(this)); if (n->expr_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Unary operand must be a numeric type"); n->copy_type(*n->expr_); return StatusTuple(0); } StatusTuple TypeCheck::visit_bitop_expr_node(BitopExprNode *n) { if (n->expr_->typeof_ != ExprNode::INTEGER) return mkstatus_(n, "Bitop [] can only operate on numeric types"); n->typeof_ = ExprNode::INTEGER; return StatusTuple(0); } StatusTuple TypeCheck::visit_goto_expr_node(GotoExprNode *n) { //n->id_->accept(this); n->typeof_ = ExprNode::VOID; return StatusTuple(0); } StatusTuple TypeCheck::visit_return_expr_node(ReturnExprNode *n) { TRY2(n->expr_->accept(this)); n->typeof_ = ExprNode::VOID; return StatusTuple(0); } StatusTuple TypeCheck::expect_method_arg(MethodCallExprNode *n, size_t num, size_t num_def_args = 0) { if (num_def_args == 0) { if (n->args_.size() != num) return mkstatus_(n, "%s expected %d argument%s, %zu given", n->id_->sub_name_.c_str(), num, num == 1 ? "" : "s", n->args_.size()); } else { if (n->args_.size() < num - num_def_args || n->args_.size() > num) return mkstatus_(n, "%s expected %d argument%s (%d default), %zu given", n->id_->sub_name_.c_str(), num, num == 1 ? "" : "s", num_def_args, n->args_.size()); } return StatusTuple(0); } StatusTuple TypeCheck::check_lookup_method(MethodCallExprNode *n) { auto table = scopes_->top_table()->lookup(n->id_->name_); if (!table) return mkstatus_(n, "Unknown table name %s", n->id_->c_str()); TRY2(expect_method_arg(n, 2, 1)); if (table->type_id()->name_ == "LPM") return mkstatus_(n, "LPM unsupported"); if (n->block_->scope_) { auto result = make_unique(table->leaf_id()->copy(), make_unique("_result"), VariableDeclStmtNode::STRUCT_REFERENCE); n->block_->scope_->add("_result", result.get()); n->block_->stmts_.insert(n->block_->stmts_.begin(), move(result)); } return StatusTuple(0); } StatusTuple TypeCheck::check_update_method(MethodCallExprNode *n) { auto table = scopes_->top_table()->lookup(n->id_->name_); if (!table) return mkstatus_(n, "Unknown table name %s", n->id_->c_str()); if (table->type_id()->name_ == "FIXED_MATCH" || table->type_id()->name_ == "INDEXED") TRY2(expect_method_arg(n, 2)); else if (table->type_id()->name_ == "LPM") TRY2(expect_method_arg(n, 3)); return StatusTuple(0); } StatusTuple TypeCheck::check_delete_method(MethodCallExprNode *n) { auto table = scopes_->top_table()->lookup(n->id_->name_); if (!table) return mkstatus_(n, "Unknown table name %s", n->id_->c_str()); if (table->type_id()->name_ == "FIXED_MATCH" || table->type_id()->name_ == "INDEXED") TRY2(expect_method_arg(n, 1)); else if (table->type_id()->name_ == "LPM") {} return StatusTuple(0); } StatusTuple TypeCheck::visit_method_call_expr_node(MethodCallExprNode *n) { // be sure to visit those child nodes ASAP, so their properties can // be propagated up to this node and be ready to be used for (auto it = n->args_.begin(); it != n->args_.end(); ++it) { TRY2((*it)->accept(this)); } n->typeof_ = ExprNode::VOID; if (n->id_->sub_name_.size()) { if (n->id_->sub_name_ == "lookup") { TRY2(check_lookup_method(n)); } else if (n->id_->sub_name_ == "update") { TRY2(check_update_method(n)); } else if (n->id_->sub_name_ == "delete") { TRY2(check_delete_method(n)); } else if (n->id_->sub_name_ == "rewrite_field" && n->id_->name_ == "pkt") { TRY2(expect_method_arg(n, 2)); n->args_[0]->flags_[ExprNode::IS_LHS] = true; } } else if (n->id_->name_ == "log") { if (n->args_.size() < 1) return mkstatus_(n, "%s expected at least 1 argument", n->id_->c_str()); if (n->args_[0]->typeof_ != ExprNode::STRING) return mkstatus_(n, "%s expected a string for argument 1", n->id_->c_str()); n->typeof_ = ExprNode::INTEGER; n->bit_width_ = 32; } else if (n->id_->name_ == "atomic_add") { TRY2(expect_method_arg(n, 2)); n->typeof_ = ExprNode::INTEGER; n->bit_width_ = n->args_[0]->bit_width_; n->args_[0]->flags_[ExprNode::IS_LHS] = true; } else if (n->id_->name_ == "incr_cksum") { TRY2(expect_method_arg(n, 4, 1)); n->typeof_ = ExprNode::INTEGER; n->bit_width_ = 16; } else if (n->id_->name_ == "sizeof") { TRY2(expect_method_arg(n, 1)); n->typeof_ = ExprNode::INTEGER; n->bit_width_ = 32; } else if (n->id_->name_ == "get_usec_time") { TRY2(expect_method_arg(n, 0)); n->typeof_ = ExprNode::INTEGER; n->bit_width_ = 64; } if (!n->block_->stmts_.empty()) { if (n->id_->sub_name_ != "update" && n->id_->sub_name_ != "lookup") return mkstatus_(n, "%s does not allow trailing block statements", n->id_->full_name().c_str()); TRY2(n->block_->accept(this)); } return StatusTuple(0); } StatusTuple TypeCheck::visit_table_index_expr_node(TableIndexExprNode *n) { n->table_ = scopes_->top_table()->lookup(n->id_->name_); if (!n->table_) return mkstatus_(n, "Unknown table name %s", n->id_->c_str()); TRY2(n->index_->accept(this)); if (n->index_->struct_type_ != n->table_->key_type_) return mkstatus_(n, "Key to table %s lookup must be of type %s", n->id_->c_str(), n->table_->key_id()->c_str()); if (n->sub_) { n->sub_decl_ = n->table_->leaf_type_->field(n->sub_->name_); if (!n->sub_decl_) return mkstatus_(n, "Field %s is not a member of %s", n->sub_->c_str(), n->table_->leaf_id()->c_str()); n->typeof_ = ExprNode::INTEGER; } else { n->typeof_ = ExprNode::STRUCT; n->flags_[ExprNode::IS_REF] = true; n->struct_type_ = n->table_->leaf_type_; } return StatusTuple(0); } StatusTuple TypeCheck::visit_expr_stmt_node(ExprStmtNode *n) { TRY2(n->expr_->accept(this)); return StatusTuple(0); } StatusTuple TypeCheck::visit_struct_variable_decl_stmt_node(StructVariableDeclStmtNode *n) { //TRY2(n->struct_id_->accept(this)); //TRY2(n->id_->accept(this)); if (!n->init_.empty()) { StructDeclStmtNode *type; if (n->struct_id_->scope_name_ == "proto") type = proto_scopes_->top_struct()->lookup(n->struct_id_->name_, true); else type = scopes_->top_struct()->lookup(n->struct_id_->name_, true); if (!type) return mkstatus_(n, "type %s does not exist", n->struct_id_->full_name().c_str()); // init remaining fields to 0 set used; for (auto i = n->init_.begin(); i != n->init_.end(); ++i) { auto asn = static_cast(i->get()); auto id = static_cast(asn->lhs_.get()); used.insert(id->sub_name_); } for (auto f = type->stmts_.begin(); f != type->stmts_.end(); ++f) { if (used.find((*f)->id_->name_) == used.end()) { auto id = make_unique(n->id_->name_); id->append_dot((*f)->id_->name_); n->init_.push_back(make_unique(move(id), make_unique("0"))); } } for (auto it = n->init_.begin(); it != n->init_.end(); ++it) { TRY2((*it)->accept(this)); } } return StatusTuple(0); } StatusTuple TypeCheck::visit_integer_variable_decl_stmt_node(IntegerVariableDeclStmtNode *n) { //TRY2(n->id_->accept(this)); if (!n->init_.empty()) { TRY2(n->init_[0]->accept(this)); } return StatusTuple(0); } StatusTuple TypeCheck::visit_struct_decl_stmt_node(StructDeclStmtNode *n) { //TRY2(n->id_->accept(this)); for (auto it = n->stmts_.begin(); it != n->stmts_.end(); ++it) { TRY2((*it)->accept(this)); } return StatusTuple(0); } StatusTuple TypeCheck::visit_parser_state_stmt_node(ParserStateStmtNode *n) { return StatusTuple(0); } StatusTuple TypeCheck::visit_state_decl_stmt_node(StateDeclStmtNode *n) { if (!n->id_) { return StatusTuple(0); } auto s1 = proto_scopes_->top_state()->lookup(n->id_->name_, true); if (s1) { const string &name = n->id_->name_; auto offset_var = make_unique(make_unique("$" + name), "64"); offset_var->init_.push_back(make_unique(offset_var->id_->copy(), make_unique("0"))); scopes_->current_var()->add("$" + name, offset_var.get()); s1->subs_[0].block_->scope_->add("$" + name, offset_var.get()); n->init_.push_back(move(offset_var)); n->parser_ = ParserStateStmtNode::make(n->id_); n->parser_->next_state_ = s1->subs_[0].block_.get(); n->parser_->scope_id_ = n->scope_id_; auto p = proto_scopes_->top_struct()->lookup(n->id_->name_, true); if (!p) return mkstatus_(n, "unable to find struct decl for parser state %s", n->id_->full_name().c_str()); // $proto = parsed_bytes; parsed_bytes += sizeof($proto); auto asn1 = make_unique(make_unique("$" + n->id_->name_), make_unique("parsed_bytes")); n->init_.push_back(make_unique(move(asn1))); auto add_expr = make_unique(make_unique("parsed_bytes"), Tok::TPLUS, make_unique(std::to_string(p->bit_width_ >> 3), 64)); auto asn2 = make_unique(make_unique("parsed_bytes"), move(add_expr)); n->init_.push_back(make_unique(move(asn2))); } for (auto it = n->init_.begin(); it != n->init_.end(); ++it) { TRY2((*it)->accept(this)); } for (auto it = n->subs_.begin(); it != n->subs_.end(); ++it) { scopes_->push_state(it->scope_); TRY2(it->block_->accept(this)); if (s1) { if (it->id_->name_ == "") { it->parser_ = ParserStateStmtNode::make(it->id_); it->parser_->next_state_ = s1->subs_[0].block_.get(); it->parser_->scope_id_ = n->scope_id_ + n->id_->name_ + "_"; } else if (auto s2 = proto_scopes_->top_state()->lookup(it->id_->name_, true)) { it->parser_ = ParserStateStmtNode::make(it->id_); it->parser_->next_state_ = s2->subs_[0].block_.get(); it->parser_->scope_id_ = n->scope_id_ + n->id_->name_ + "_"; } if (it->parser_) { TRY2(it->parser_->accept(this)); } } scopes_->pop_state(); } return StatusTuple(0); } StatusTuple TypeCheck::visit_match_decl_stmt_node(MatchDeclStmtNode *n) { //TRY2(n->id_->accept(this)); for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { TRY2((*it)->accept(this)); } TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple TypeCheck::visit_miss_decl_stmt_node(MissDeclStmtNode *n) { //TRY2(n->id_->accept(this)); for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { TRY2((*it)->accept(this)); } TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple TypeCheck::visit_failure_decl_stmt_node(FailureDeclStmtNode *n) { //TRY2(n->id_->accept(this)); for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { TRY2((*it)->accept(this)); } TRY2(n->block_->accept(this)); return StatusTuple(0); } StatusTuple TypeCheck::visit_table_decl_stmt_node(TableDeclStmtNode *n) { n->key_type_ = scopes_->top_struct()->lookup(n->key_id()->name_, true); if (!n->key_type_) return mkstatus_(n, "Table key type %s undefined", n->key_id()->c_str()); n->key_id()->bit_width_ = n->key_type_->bit_width_; n->leaf_type_ = scopes_->top_struct()->lookup(n->leaf_id()->name_, true); if (!n->leaf_type_) return mkstatus_(n, "Table leaf type %s undefined", n->leaf_id()->c_str()); n->leaf_id()->bit_width_ = n->leaf_type_->bit_width_; if (n->type_id()->name_ == "INDEXED" && n->policy_id()->name_ != "AUTO") { fprintf(stderr, "Table %s is INDEXED, policy should be AUTO\n", n->id_->c_str()); n->policy_id()->name_ = "AUTO"; } if (n->policy_id()->name_ != "AUTO" && n->policy_id()->name_ != "NONE") return mkstatus_(n, "Unsupported policy type %s", n->policy_id()->c_str()); return StatusTuple(0); } StatusTuple TypeCheck::visit_func_decl_stmt_node(FuncDeclStmtNode *n) { for (auto it = n->formals_.begin(); it != n->formals_.end(); ++it) { VariableDeclStmtNode *var = it->get(); TRY2(var->accept(this)); if (var->is_struct()) { if (!var->is_pointer()) return mkstatus_(n, "Only struct references allowed in function definitions"); } } scopes_->push_state(n->scope_); TRY2(n->block_->accept(this)); scopes_->pop_state(); return StatusTuple(0); } StatusTuple TypeCheck::visit(Node *root) { BlockStmtNode *b = static_cast(root); scopes_->set_current(scopes_->top_state()); scopes_->set_current(scopes_->top_var()); // // packet data in bpf socket // if (scopes_->top_struct()->lookup("_skbuff", true)) { // return StatusTuple(-1, "_skbuff already defined"); // } // auto skb_type = make_unique(make_unique("_skbuff")); // scopes_->top_struct()->add("_skbuff", skb_type.get()); // b->stmts_.push_back(move(skb_type)); // if (scopes_->current_var()->lookup("skb", true)) { // return StatusTuple(-1, "skb already defined"); // } // auto skb = make_unique(make_unique("_skbuff"), // make_unique("skb")); // skb->storage_type_ = VariableDeclStmtNode::STRUCT_REFERENCE; // scopes_->current_var()->add("skb", skb.get()); // b->stmts_.push_back(move(skb)); // offset counter auto parsed_bytes = make_unique( make_unique("parsed_bytes"), "64"); parsed_bytes->init_.push_back(make_unique(parsed_bytes->id_->copy(), make_unique("0"))); scopes_->current_var()->add("parsed_bytes", parsed_bytes.get()); b->stmts_.push_back(move(parsed_bytes)); TRY2(b->accept(this)); if (!errors_.empty()) { for (auto it = errors_.begin(); it != errors_.end(); ++it) { fprintf(stderr, "%s\n", it->c_str()); } return StatusTuple(-1, errors_.begin()->c_str()); } return StatusTuple(0); } } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/type_check.h000066400000000000000000000026061305314114400223700ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include "node.h" #include "scope.h" namespace ebpf { namespace cc { class TypeCheck : public Visitor { public: TypeCheck(Scopes *scopes, Scopes *proto_scopes) : scopes_(scopes), proto_scopes_(proto_scopes) {} virtual STATUS_RETURN visit(Node* n); STATUS_RETURN expect_method_arg(MethodCallExprNode* n, size_t num, size_t num_def_args); STATUS_RETURN check_lookup_method(MethodCallExprNode* n); STATUS_RETURN check_update_method(MethodCallExprNode* n); STATUS_RETURN check_delete_method(MethodCallExprNode* n); #define VISIT(type, func) virtual STATUS_RETURN visit_##func(type* n); EXPAND_NODES(VISIT) #undef VISIT private: Scopes *scopes_; Scopes *proto_scopes_; vector errors_; }; } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/b/type_helper.h000066400000000000000000000052541305314114400225740ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once namespace ebpf { namespace cc { // Represent the numeric type of a protocol field enum FieldType { INVALID = 0, UINT8_T, UINT16_T, UINT32_T, UINT64_T, UINT128_T, VOID }; static inline size_t enum_to_size(const FieldType t) { switch (t) { case UINT8_T: return sizeof(uint8_t); case UINT16_T: return sizeof(uint16_t); case UINT32_T: return sizeof(uint32_t); case UINT64_T: return sizeof(uint64_t); case UINT128_T: return sizeof(__uint128_t); default: return 0; } } /// Convert a bit size to the next highest power of 2 static inline int next_base2(int v) { --v; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; ++v; return v; } static inline const char* bits_to_uint(int v) { v = next_base2(v); if (v <= 8) { return "uint8_t"; } else if (v == 16) { return "uint16_t"; } else if (v == 32) { return "uint32_t"; } else if (v == 64) { return "uint64_t"; } else if (v >= 128) { /* in plumlet 128-bit integers should be 8-byte aligned, * all other ints should have natural alignment */ return "unsigned __int128 __attribute__((packed, aligned(8)))"; } return "void"; } static inline FieldType bits_to_enum(int v) { v = next_base2(v); if (v <= 8) { return UINT8_T; } else if (v == 16) { return UINT16_T; } else if (v == 32) { return UINT32_T; } else if (v == 64) { return UINT64_T; } else if (v >= 128) { return UINT128_T; } return VOID; } static inline size_t bits_to_size(int v) { return enum_to_size(bits_to_enum(v)); } static inline size_t align_offset(size_t offset, FieldType ft) { switch (ft) { case UINT8_T: return offset % 8 > 0 ? offset + (8 - offset % 8) : offset; case UINT16_T: return offset % 16 > 0 ? offset + (16 - offset % 16) : offset; case UINT32_T: return offset % 32 > 0 ? offset + (32 - offset % 32) : offset; case UINT64_T: case UINT128_T: return offset % 64 > 0 ? offset + (64 - offset % 64) : offset; default: ; } return offset; } } // namespace cc } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/000077500000000000000000000000001305314114400207405ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/CMakeLists.txt000066400000000000000000000004621305314114400235020ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DKERNEL_MODULES_DIR='\"${BCC_KERNEL_MODULES_DIR}\"'") add_library(clang_frontend loader.cc b_frontend_action.cc tp_frontend_action.cc kbuild_helper.cc ../../common.cc) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/b_frontend_action.cc000066400000000000000000000737711305314114400247430ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include "b_frontend_action.h" #include "shared_table.h" #include "common.h" #include "libbpf.h" namespace ebpf { constexpr int MAX_CALLING_CONV_REGS = 6; const char *calling_conv_regs_x86[] = { "di", "si", "dx", "cx", "r8", "r9" }; const char *calling_conv_regs_ppc[] = {"gpr[3]", "gpr[4]", "gpr[5]", "gpr[6]", "gpr[7]", "gpr[8]"}; const char *calling_conv_regs_arm64[] = {"regs[0]", "regs[1]", "regs[2]", "regs[3]", "regs[4]", "regs[5]"}; // todo: support more archs #if defined(__powerpc__) const char **calling_conv_regs = calling_conv_regs_ppc; #elif defined(__aarch64__) const char **calling_conv_regs = calling_conv_regs_arm64; #else const char **calling_conv_regs = calling_conv_regs_x86; #endif using std::map; using std::set; using std::string; using std::to_string; using std::unique_ptr; using std::vector; using namespace clang; // Encode the struct layout as a json description BMapDeclVisitor::BMapDeclVisitor(ASTContext &C, string &result) : C(C), result_(result) {} bool BMapDeclVisitor::VisitFieldDecl(FieldDecl *D) { result_ += "\""; result_ += D->getName(); result_ += "\","; return true; } bool BMapDeclVisitor::TraverseRecordDecl(RecordDecl *D) { // skip children, handled in Visit... if (!WalkUpFromRecordDecl(D)) return false; return true; } bool BMapDeclVisitor::VisitRecordDecl(RecordDecl *D) { result_ += "[\""; result_ += D->getName(); result_ += "\", ["; for (auto F : D->getDefinition()->fields()) { if (F->isAnonymousStructOrUnion()) { if (const RecordType *R = dyn_cast(F->getType())) TraverseDecl(R->getDecl()); result_ += ", "; continue; } result_ += "["; TraverseDecl(F); if (const ConstantArrayType *T = dyn_cast(F->getType())) result_ += ", [" + T->getSize().toString(10, false) + "]"; if (F->isBitField()) result_ += ", " + to_string(F->getBitWidthValue(C)); result_ += "], "; } if (!D->getDefinition()->field_empty()) result_.erase(result_.end() - 2); result_ += "]"; if (D->isUnion()) result_ += ", \"union\""; else if (D->isStruct()) result_ += ", \"struct\""; result_ += "]"; return true; } // pointer to anything should be treated as terminal, don't recurse further bool BMapDeclVisitor::VisitPointerType(const PointerType *T) { result_ += "\"unsigned long long\""; return false; } bool BMapDeclVisitor::VisitTagType(const TagType *T) { return TraverseDecl(T->getDecl()->getDefinition()); } bool BMapDeclVisitor::VisitTypedefType(const TypedefType *T) { return TraverseDecl(T->getDecl()); } bool BMapDeclVisitor::VisitBuiltinType(const BuiltinType *T) { result_ += "\""; result_ += T->getName(C.getPrintingPolicy()); result_ += "\""; return true; } class ProbeChecker : public RecursiveASTVisitor { public: explicit ProbeChecker(Expr *arg, const set &ptregs) : needs_probe_(false), is_transitive_(false), ptregs_(ptregs) { if (arg) { TraverseStmt(arg); if (arg->getType()->isPointerType()) is_transitive_ = needs_probe_; } } bool VisitCallExpr(CallExpr *E) { needs_probe_ = false; return false; } bool VisitParenExpr(ParenExpr *E) { return false; } bool VisitDeclRefExpr(DeclRefExpr *E) { if (ptregs_.find(E->getDecl()) != ptregs_.end()) needs_probe_ = true; return true; } bool needs_probe() const { return needs_probe_; } bool is_transitive() const { return is_transitive_; } private: bool needs_probe_; bool is_transitive_; const set &ptregs_; }; // Visit a piece of the AST and mark it as needing probe reads class ProbeSetter : public RecursiveASTVisitor { public: explicit ProbeSetter(set *ptregs) : ptregs_(ptregs) {} bool VisitDeclRefExpr(DeclRefExpr *E) { ptregs_->insert(E->getDecl()); return true; } private: set *ptregs_; }; ProbeVisitor::ProbeVisitor(ASTContext &C, Rewriter &rewriter) : C(C), rewriter_(rewriter) {} bool ProbeVisitor::VisitVarDecl(VarDecl *Decl) { if (Expr *E = Decl->getInit()) { if (ProbeChecker(E, ptregs_).is_transitive()) set_ptreg(Decl); } return true; } bool ProbeVisitor::VisitCallExpr(CallExpr *Call) { if (FunctionDecl *F = dyn_cast(Call->getCalleeDecl())) { if (F->hasBody()) { unsigned i = 0; for (auto arg : Call->arguments()) { if (ProbeChecker(arg, ptregs_).needs_probe()) ptregs_.insert(F->getParamDecl(i)); ++i; } if (fn_visited_.find(F) == fn_visited_.end()) { fn_visited_.insert(F); TraverseDecl(F); } } } return true; } bool ProbeVisitor::VisitBinaryOperator(BinaryOperator *E) { if (!E->isAssignmentOp()) return true; // copy probe attribute from RHS to LHS if present if (ProbeChecker(E->getRHS(), ptregs_).is_transitive()) { ProbeSetter setter(&ptregs_); setter.TraverseStmt(E->getLHS()); } return true; } bool ProbeVisitor::VisitUnaryOperator(UnaryOperator *E) { if (E->getOpcode() == UO_AddrOf) return true; if (memb_visited_.find(E) != memb_visited_.end()) return true; if (!ProbeChecker(E, ptregs_).needs_probe()) return true; memb_visited_.insert(E); Expr *sub = E->getSubExpr(); string rhs = rewriter_.getRewrittenText(SourceRange(sub->getLocStart(), sub->getLocEnd())); string text; text = "({ typeof(" + E->getType().getAsString() + ") _val; memset(&_val, 0, sizeof(_val));"; text += " bpf_probe_read(&_val, sizeof(_val), (u64)"; text += rhs + "); _val; })"; rewriter_.ReplaceText(SourceRange(E->getLocStart(), E->getLocEnd()), text); return true; } bool ProbeVisitor::VisitMemberExpr(MemberExpr *E) { if (memb_visited_.find(E) != memb_visited_.end()) return true; // Checks to see if the expression references something that needs to be run // through bpf_probe_read. if (!ProbeChecker(E, ptregs_).needs_probe()) return true; Expr *base; SourceLocation rhs_start, op; bool found = false; for (MemberExpr *M = E; M; M = dyn_cast(M->getBase())) { memb_visited_.insert(M); rhs_start = M->getLocEnd(); base = M->getBase(); op = M->getOperatorLoc(); if (M->isArrow()) { found = true; break; } } if (!found) return true; if (op.isInvalid()) { error(base->getLocEnd(), "internal error: opLoc is invalid while preparing probe rewrite"); return false; } string rhs = rewriter_.getRewrittenText(SourceRange(rhs_start, E->getLocEnd())); string base_type = base->getType()->getPointeeType().getAsString(); string pre, post; pre = "({ typeof(" + E->getType().getAsString() + ") _val; memset(&_val, 0, sizeof(_val));"; pre += " bpf_probe_read(&_val, sizeof(_val), (u64)"; post = " + offsetof(" + base_type + ", " + rhs + ")"; post += "); _val; })"; rewriter_.InsertText(E->getLocStart(), pre); rewriter_.ReplaceText(SourceRange(op, E->getLocEnd()), post); return true; } template DiagnosticBuilder ProbeVisitor::error(SourceLocation loc, const char (&fmt)[N]) { unsigned int diag_id = C.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, fmt); return C.getDiagnostics().Report(loc, diag_id); } BTypeVisitor::BTypeVisitor(ASTContext &C, Rewriter &rewriter, vector &tables) : C(C), diag_(C.getDiagnostics()), rewriter_(rewriter), out_(llvm::errs()), tables_(tables) { } bool BTypeVisitor::VisitFunctionDecl(FunctionDecl *D) { // put each non-static non-inline function decl in its own section, to be // extracted by the MemoryManager auto real_start_loc = rewriter_.getSourceMgr().getFileLoc(D->getLocStart()); if (D->isExternallyVisible() && D->hasBody()) { current_fn_ = D->getName(); string attr = string("__attribute__((section(\"") + BPF_FN_PREFIX + D->getName().str() + "\")))\n"; rewriter_.InsertText(real_start_loc, attr); if (D->param_size() > MAX_CALLING_CONV_REGS + 1) { error(D->getParamDecl(MAX_CALLING_CONV_REGS + 1)->getLocStart(), "too many arguments, bcc only supports in-register parameters"); return false; } // remember the arg names of the current function...first one is the ctx fn_args_.clear(); string preamble = "{"; for (auto arg_it = D->param_begin(); arg_it != D->param_end(); arg_it++) { auto arg = *arg_it; if (arg->getName() == "") { error(arg->getLocEnd(), "arguments to BPF program definition must be named"); return false; } fn_args_.push_back(arg); if (fn_args_.size() > 1) { // Move the args into a preamble section where the same params are // declared and initialized from pt_regs. // Todo: this init should be done only when the program requests it. string text = rewriter_.getRewrittenText( SourceRange(arg->getLocStart(), arg->getLocEnd())); arg->addAttr(UnavailableAttr::CreateImplicit(C, "ptregs")); size_t d = fn_args_.size() - 2; const char *reg = calling_conv_regs[d]; preamble += " " + text + " = " + fn_args_[0]->getName().str() + "->" + string(reg) + ";"; } } if (D->param_size() > 1) { rewriter_.ReplaceText( SourceRange(D->getParamDecl(0)->getLocEnd(), D->getParamDecl(D->getNumParams() - 1)->getLocEnd()), fn_args_[0]->getName()); } // for each trace argument, convert the variable from ptregs to something on stack if (CompoundStmt *S = dyn_cast(D->getBody())) rewriter_.ReplaceText(S->getLBracLoc(), 1, preamble); } else if (D->hasBody() && rewriter_.getSourceMgr().getFileID(real_start_loc) == rewriter_.getSourceMgr().getMainFileID()) { // rewritable functions that are static should be always treated as helper rewriter_.InsertText(real_start_loc, "__attribute__((always_inline))\n"); } return true; } // Reverse the order of call traversal so that parameters inside of // function calls will get rewritten before the call itself, otherwise // text mangling will result. bool BTypeVisitor::TraverseCallExpr(CallExpr *Call) { for (auto child : Call->children()) if (!TraverseStmt(child)) return false; if (!WalkUpFromCallExpr(Call)) return false; return true; } // convert calls of the type: // table.foo(&key) // to: // bpf_table_foo_elem(bpf_pseudo_fd(table), &key [,&leaf]) bool BTypeVisitor::VisitCallExpr(CallExpr *Call) { // Get rewritten text given a source range, w/ expansion range applied auto getRewrittenText = [this] (SourceRange R) { auto r = rewriter_.getSourceMgr().getExpansionRange(R); return rewriter_.getRewrittenText(r); }; // make sure node is a reference to a bpf table, which is assured by the // presence of the section("maps/") GNU __attribute__ if (MemberExpr *Memb = dyn_cast(Call->getCallee()->IgnoreImplicit())) { StringRef memb_name = Memb->getMemberDecl()->getName(); if (DeclRefExpr *Ref = dyn_cast(Memb->getBase())) { if (SectionAttr *A = Ref->getDecl()->getAttr()) { if (!A->getName().startswith("maps")) return true; string args = getRewrittenText(SourceRange(Call->getArg(0)->getLocStart(), Call->getArg(Call->getNumArgs() - 1)->getLocEnd())); // find the table fd, which was opened at declaration time auto table_it = tables_.begin(); for (; table_it != tables_.end(); ++table_it) if (table_it->name == Ref->getDecl()->getName()) break; if (table_it == tables_.end()) { error(Ref->getLocEnd(), "bpf_table %0 failed to open") << Ref->getDecl()->getName(); return false; } string fd = to_string(table_it->fd); string prefix, suffix; string map_update_policy = "BPF_ANY"; string txt; auto rewrite_start = Call->getLocStart(); auto rewrite_end = Call->getLocEnd(); if (memb_name == "lookup_or_init") { map_update_policy = "BPF_NOEXIST"; string name = Ref->getDecl()->getName(); string arg0 = getRewrittenText(Call->getArg(0)->getSourceRange()); string arg1 = getRewrittenText(Call->getArg(1)->getSourceRange()); string lookup = "bpf_map_lookup_elem_(bpf_pseudo_fd(1, " + fd + ")"; string update = "bpf_map_update_elem_(bpf_pseudo_fd(1, " + fd + ")"; txt = "({typeof(" + name + ".leaf) *leaf = " + lookup + ", " + arg0 + "); "; txt += "if (!leaf) {"; txt += " " + update + ", " + arg0 + ", " + arg1 + ", " + map_update_policy + ");"; txt += " leaf = " + lookup + ", " + arg0 + ");"; txt += " if (!leaf) return 0;"; txt += "}"; txt += "leaf;})"; } else if (memb_name == "increment") { string name = Ref->getDecl()->getName(); string arg0 = getRewrittenText(Call->getArg(0)->getSourceRange()); string lookup = "bpf_map_lookup_elem_(bpf_pseudo_fd(1, " + fd + ")"; string update = "bpf_map_update_elem_(bpf_pseudo_fd(1, " + fd + ")"; txt = "({ typeof(" + name + ".key) _key = " + arg0 + "; "; if (table_it->type == BPF_MAP_TYPE_HASH) { txt += "typeof(" + name + ".leaf) _zleaf; memset(&_zleaf, 0, sizeof(_zleaf)); "; txt += update + ", &_key, &_zleaf, BPF_NOEXIST); "; } txt += "typeof(" + name + ".leaf) *_leaf = " + lookup + ", &_key); "; txt += "if (_leaf) (*_leaf)++; })"; } else if (memb_name == "perf_submit") { string name = Ref->getDecl()->getName(); string arg0 = getRewrittenText(Call->getArg(0)->getSourceRange()); string args_other = getRewrittenText(SourceRange(Call->getArg(1)->getLocStart(), Call->getArg(2)->getLocEnd())); txt = "bpf_perf_event_output(" + arg0 + ", bpf_pseudo_fd(1, " + fd + ")"; txt += ", bpf_get_smp_processor_id(), " + args_other + ")"; } else if (memb_name == "perf_submit_skb") { string skb = getRewrittenText(Call->getArg(0)->getSourceRange()); string skb_len = getRewrittenText(Call->getArg(1)->getSourceRange()); string meta = getRewrittenText(Call->getArg(2)->getSourceRange()); string meta_len = getRewrittenText(Call->getArg(3)->getSourceRange()); txt = "bpf_perf_event_output(" + skb + ", " + "bpf_pseudo_fd(1, " + fd + "), " + "((__u64)" + skb_len + " << 32) | BPF_F_CURRENT_CPU, " + meta + ", " + meta_len + ");"; } else if (memb_name == "get_stackid") { if (table_it->type == BPF_MAP_TYPE_STACK_TRACE) { string arg0 = getRewrittenText(Call->getArg(0)->getSourceRange()); txt = "bpf_get_stackid("; txt += "bpf_pseudo_fd(1, " + fd + "), " + arg0; rewrite_end = Call->getArg(0)->getLocEnd(); } else { error(Call->getLocStart(), "get_stackid only available on stacktrace maps"); return false; } } else { if (memb_name == "lookup") { prefix = "bpf_map_lookup_elem"; suffix = ")"; } else if (memb_name == "update") { prefix = "bpf_map_update_elem"; suffix = ", " + map_update_policy + ")"; } else if (memb_name == "delete") { prefix = "bpf_map_delete_elem"; suffix = ")"; } else if (memb_name == "call") { prefix = "bpf_tail_call_"; suffix = ")"; } else if (memb_name == "perf_read") { prefix = "bpf_perf_event_read"; suffix = ")"; } else { error(Call->getLocStart(), "invalid bpf_table operation %0") << memb_name; return false; } prefix += "((void *)bpf_pseudo_fd(1, " + fd + "), "; txt = prefix + args + suffix; } if (!rewriter_.isRewritable(rewrite_start) || !rewriter_.isRewritable(rewrite_end)) { error(Call->getLocStart(), "cannot use map function inside a macro"); return false; } rewriter_.ReplaceText(SourceRange(rewrite_start, rewrite_end), txt); return true; } } } else if (Call->getCalleeDecl()) { NamedDecl *Decl = dyn_cast(Call->getCalleeDecl()); if (!Decl) return true; if (AsmLabelAttr *A = Decl->getAttr()) { // Functions with the tag asm("llvm.bpf.extra") are implemented in the // rewriter rather than as a macro since they may also include nested // rewrites, and clang::Rewriter does not support rewrites in macros, // unless one preprocesses the entire source file. if (A->getLabel() == "llvm.bpf.extra") { if (!rewriter_.isRewritable(Call->getLocStart())) { error(Call->getLocStart(), "cannot use builtin inside a macro"); return false; } vector args; for (auto arg : Call->arguments()) args.push_back(getRewrittenText(arg->getSourceRange())); string text; if (Decl->getName() == "incr_cksum_l3") { text = "bpf_l3_csum_replace_(" + fn_args_[0]->getName().str() + ", (u64)"; text += args[0] + ", " + args[1] + ", " + args[2] + ", sizeof(" + args[2] + "))"; rewriter_.ReplaceText(SourceRange(Call->getLocStart(), Call->getLocEnd()), text); } else if (Decl->getName() == "incr_cksum_l4") { text = "bpf_l4_csum_replace_(" + fn_args_[0]->getName().str() + ", (u64)"; text += args[0] + ", " + args[1] + ", " + args[2]; text += ", ((" + args[3] + " & 0x1) << 4) | sizeof(" + args[2] + "))"; rewriter_.ReplaceText(SourceRange(Call->getLocStart(), Call->getLocEnd()), text); } else if (Decl->getName() == "bpf_trace_printk") { // #define bpf_trace_printk(fmt, args...) // ({ char _fmt[] = fmt; bpf_trace_printk_(_fmt, sizeof(_fmt), args...); }) text = "({ char _fmt[] = " + args[0] + "; bpf_trace_printk_(_fmt, sizeof(_fmt)"; if (args.size() <= 1) { text += "); })"; rewriter_.ReplaceText(SourceRange(Call->getLocStart(), Call->getLocEnd()), text); } else { rewriter_.ReplaceText(SourceRange(Call->getLocStart(), Call->getArg(0)->getLocEnd()), text); rewriter_.InsertTextAfter(Call->getLocEnd(), "); }"); } } else if (Decl->getName() == "bpf_num_cpus") { int numcpu = sysconf(_SC_NPROCESSORS_ONLN); if (numcpu <= 0) numcpu = 1; text = to_string(numcpu); rewriter_.ReplaceText(SourceRange(Call->getLocStart(), Call->getLocEnd()), text); } else if (Decl->getName() == "bpf_usdt_readarg_p") { text = "({ u64 __addr = 0x0; "; text += "_bpf_readarg_" + current_fn_ + "_" + args[0] + "(" + args[1] + ", &__addr, sizeof(__addr));"; text += "bpf_probe_read(" + args[2] + ", " + args[3] + ", (void *)__addr);"; text += "})"; rewriter_.ReplaceText( SourceRange(Call->getLocStart(), Call->getLocEnd()), text); } else if (Decl->getName() == "bpf_usdt_readarg") { text = "_bpf_readarg_" + current_fn_ + "_" + args[0] + "(" + args[1] + ", " + args[2] + ", sizeof(*(" + args[2] + ")))"; rewriter_.ReplaceText( SourceRange(Call->getLocStart(), Call->getLocEnd()), text); } } } } return true; } bool BTypeVisitor::VisitBinaryOperator(BinaryOperator *E) { if (!E->isAssignmentOp()) return true; Expr *LHS = E->getLHS()->IgnoreImplicit(); Expr *RHS = E->getRHS()->IgnoreImplicit(); if (MemberExpr *Memb = dyn_cast(LHS)) { if (DeclRefExpr *Base = dyn_cast(Memb->getBase()->IgnoreImplicit())) { if (DeprecatedAttr *A = Base->getDecl()->getAttr()) { if (A->getMessage() == "packet") { if (FieldDecl *F = dyn_cast(Memb->getMemberDecl())) { if (!rewriter_.isRewritable(E->getLocStart())) { error(E->getLocStart(), "cannot use \"packet\" header type inside a macro"); return false; } uint64_t ofs = C.getFieldOffset(F); uint64_t sz = F->isBitField() ? F->getBitWidthValue(C) : C.getTypeSize(F->getType()); string base = rewriter_.getRewrittenText(SourceRange(Base->getLocStart(), Base->getLocEnd())); string rhs = rewriter_.getRewrittenText(SourceRange(RHS->getLocStart(), RHS->getLocEnd())); string text = "bpf_dins_pkt(" + fn_args_[0]->getName().str() + ", (u64)" + base + "+" + to_string(ofs >> 3) + ", " + to_string(ofs & 0x7) + ", " + to_string(sz) + ", " + rhs + ")"; rewriter_.ReplaceText(SourceRange(E->getLocStart(), E->getLocEnd()), text); } } } } } return true; } bool BTypeVisitor::VisitImplicitCastExpr(ImplicitCastExpr *E) { // use dext only for RValues if (E->getCastKind() != CK_LValueToRValue) return true; MemberExpr *Memb = dyn_cast(E->IgnoreImplicit()); if (!Memb) return true; Expr *Base = Memb->getBase()->IgnoreImplicit(); if (DeclRefExpr *Ref = dyn_cast(Base)) { if (DeprecatedAttr *A = Ref->getDecl()->getAttr()) { if (A->getMessage() == "packet") { if (FieldDecl *F = dyn_cast(Memb->getMemberDecl())) { if (!rewriter_.isRewritable(E->getLocStart())) { error(E->getLocStart(), "cannot use \"packet\" header type inside a macro"); return false; } uint64_t ofs = C.getFieldOffset(F); uint64_t sz = F->isBitField() ? F->getBitWidthValue(C) : C.getTypeSize(F->getType()); string text = "bpf_dext_pkt(" + fn_args_[0]->getName().str() + ", (u64)" + Ref->getDecl()->getName().str() + "+" + to_string(ofs >> 3) + ", " + to_string(ofs & 0x7) + ", " + to_string(sz) + ")"; rewriter_.ReplaceText(SourceRange(E->getLocStart(), E->getLocEnd()), text); } } } } return true; } template DiagnosticBuilder BTypeVisitor::error(SourceLocation loc, const char (&fmt)[N]) { unsigned int diag_id = C.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, fmt); return C.getDiagnostics().Report(loc, diag_id); } // Open table FDs when bpf tables (as denoted by section("maps*") attribute) // are declared. bool BTypeVisitor::VisitVarDecl(VarDecl *Decl) { const RecordType *R = Decl->getType()->getAs(); if (SectionAttr *A = Decl->getAttr()) { if (!A->getName().startswith("maps")) return true; if (!R) { error(Decl->getLocEnd(), "invalid type for bpf_table, expect struct"); return false; } const RecordDecl *RD = R->getDecl()->getDefinition(); TableDesc table = {}; table.name = Decl->getName(); unsigned i = 0; for (auto F : RD->fields()) { size_t sz = C.getTypeSize(F->getType()) >> 3; if (F->getName() == "key") { if (sz == 0) { error(F->getLocStart(), "invalid zero-sized leaf"); return false; } table.key_size = sz; BMapDeclVisitor visitor(C, table.key_desc); visitor.TraverseType(F->getType()); } else if (F->getName() == "leaf") { if (sz == 0) { error(F->getLocStart(), "invalid zero-sized leaf"); return false; } table.leaf_size = sz; BMapDeclVisitor visitor(C, table.leaf_desc); visitor.TraverseType(F->getType()); } else if (F->getName() == "data") { table.max_entries = sz / table.leaf_size; } else if (F->getName() == "flags") { unsigned idx = F->getFieldIndex(); if (auto I = dyn_cast_or_null(Decl->getInit())) { llvm::APSInt res; if (I->getInit(idx)->EvaluateAsInt(res, C)) { table.flags = res.getExtValue(); } } } ++i; } bpf_map_type map_type = BPF_MAP_TYPE_UNSPEC; if (A->getName() == "maps/hash") { map_type = BPF_MAP_TYPE_HASH; } else if (A->getName() == "maps/array") { map_type = BPF_MAP_TYPE_ARRAY; } else if (A->getName() == "maps/percpu_hash") { map_type = BPF_MAP_TYPE_PERCPU_HASH; } else if (A->getName() == "maps/percpu_array") { map_type = BPF_MAP_TYPE_PERCPU_ARRAY; } else if (A->getName() == "maps/lru_hash") { map_type = BPF_MAP_TYPE_LRU_HASH; } else if (A->getName() == "maps/lru_percpu_hash") { map_type = BPF_MAP_TYPE_LRU_PERCPU_HASH; } else if (A->getName() == "maps/lpm_trie") { map_type = BPF_MAP_TYPE_LPM_TRIE; } else if (A->getName() == "maps/histogram") { if (table.key_desc == "\"int\"") map_type = BPF_MAP_TYPE_ARRAY; else map_type = BPF_MAP_TYPE_HASH; if (table.leaf_desc != "\"unsigned long long\"") { error(Decl->getLocStart(), "histogram leaf type must be u64, got %0") << table.leaf_desc; } } else if (A->getName() == "maps/prog") { map_type = BPF_MAP_TYPE_PROG_ARRAY; } else if (A->getName() == "maps/perf_output") { map_type = BPF_MAP_TYPE_PERF_EVENT_ARRAY; int numcpu = get_possible_cpus().size(); if (numcpu <= 0) numcpu = 1; table.max_entries = numcpu; } else if (A->getName() == "maps/perf_array") { map_type = BPF_MAP_TYPE_PERF_EVENT_ARRAY; } else if (A->getName() == "maps/stacktrace") { map_type = BPF_MAP_TYPE_STACK_TRACE; } else if (A->getName() == "maps/extern") { table.is_extern = true; table.fd = SharedTables::instance()->lookup_fd(table.name); table.type = SharedTables::instance()->lookup_type(table.name); } else if (A->getName() == "maps/export") { if (table.name.substr(0, 2) == "__") table.name = table.name.substr(2); auto table_it = tables_.begin(); for (; table_it != tables_.end(); ++table_it) if (table_it->name == table.name) break; if (table_it == tables_.end()) { error(Decl->getLocStart(), "reference to undefined table"); return false; } if (!SharedTables::instance()->insert_fd(table.name, table_it->fd, table_it->type)) { error(Decl->getLocStart(), "could not export bpf map %0: %1") << table.name << "already in use"; return false; } table_it->is_shared = true; return true; } if (!table.is_extern) { if (map_type == BPF_MAP_TYPE_UNSPEC) { error(Decl->getLocStart(), "unsupported map type: %0") << A->getName(); return false; } table.type = map_type; table.fd = bpf_create_map(map_type, table.key_size, table.leaf_size, table.max_entries, table.flags); } if (table.fd < 0) { error(Decl->getLocStart(), "could not open bpf map: %0\nis %1 map type enabled in your kernel?") << strerror(errno) << A->getName(); return false; } tables_.push_back(std::move(table)); } else if (const PointerType *P = Decl->getType()->getAs()) { // if var is a pointer to a packet type, clone the annotation into the var // decl so that the packet dext/dins rewriter can catch it if (const RecordType *RT = P->getPointeeType()->getAs()) { if (const RecordDecl *RD = RT->getDecl()->getDefinition()) { if (DeprecatedAttr *DA = RD->getAttr()) { if (DA->getMessage() == "packet") { Decl->addAttr(DA->clone(C)); } } } } } return true; } BTypeConsumer::BTypeConsumer(ASTContext &C, Rewriter &rewriter, vector &tables) : visitor_(C, rewriter, tables) { } bool BTypeConsumer::HandleTopLevelDecl(DeclGroupRef Group) { for (auto D : Group) visitor_.TraverseDecl(D); return true; } ProbeConsumer::ProbeConsumer(ASTContext &C, Rewriter &rewriter) : visitor_(C, rewriter) {} bool ProbeConsumer::HandleTopLevelDecl(DeclGroupRef Group) { for (auto D : Group) { if (FunctionDecl *F = dyn_cast(D)) { if (F->isExternallyVisible() && F->hasBody()) { for (auto arg : F->parameters()) { if (arg != F->getParamDecl(0) && !arg->getType()->isFundamentalType()) visitor_.set_ptreg(arg); } visitor_.TraverseDecl(D); } } } return true; } BFrontendAction::BFrontendAction(llvm::raw_ostream &os, unsigned flags) : os_(os), flags_(flags), rewriter_(new Rewriter), tables_(new vector) { } void BFrontendAction::EndSourceFileAction() { if (flags_ & DEBUG_PREPROCESSOR) rewriter_->getEditBuffer(rewriter_->getSourceMgr().getMainFileID()).write(llvm::errs()); rewriter_->getEditBuffer(rewriter_->getSourceMgr().getMainFileID()).write(os_); os_.flush(); } unique_ptr BFrontendAction::CreateASTConsumer(CompilerInstance &Compiler, llvm::StringRef InFile) { rewriter_->setSourceMgr(Compiler.getSourceManager(), Compiler.getLangOpts()); vector> consumers; consumers.push_back(unique_ptr(new ProbeConsumer(Compiler.getASTContext(), *rewriter_))); consumers.push_back(unique_ptr(new BTypeConsumer(Compiler.getASTContext(), *rewriter_, *tables_))); return unique_ptr(new MultiplexConsumer(move(consumers))); } } bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/b_frontend_action.h000066400000000000000000000123131305314114400245660ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include "table_desc.h" #define DEBUG_PREPROCESSOR 0x4 namespace clang { class ASTConsumer; class ASTContext; class CompilerInstance; } namespace llvm { class raw_ostream; class StringRef; } namespace ebpf { // Helper visitor for constructing a string representation of a key/leaf decl class BMapDeclVisitor : public clang::RecursiveASTVisitor { public: explicit BMapDeclVisitor(clang::ASTContext &C, std::string &result); bool TraverseRecordDecl(clang::RecordDecl *Decl); bool VisitRecordDecl(clang::RecordDecl *Decl); bool VisitFieldDecl(clang::FieldDecl *Decl); bool VisitBuiltinType(const clang::BuiltinType *T); bool VisitTypedefType(const clang::TypedefType *T); bool VisitTagType(const clang::TagType *T); bool VisitPointerType(const clang::PointerType *T); private: clang::ASTContext &C; std::string &result_; }; // Type visitor and rewriter for B programs. // It will look for B-specific features and rewrite them into a valid // C program. As part of the processing, open the necessary BPF tables // and store the open handles in a map of table-to-fd's. class BTypeVisitor : public clang::RecursiveASTVisitor { public: explicit BTypeVisitor(clang::ASTContext &C, clang::Rewriter &rewriter, std::vector &tables); bool TraverseCallExpr(clang::CallExpr *Call); bool VisitFunctionDecl(clang::FunctionDecl *D); bool VisitCallExpr(clang::CallExpr *Call); bool VisitVarDecl(clang::VarDecl *Decl); bool VisitBinaryOperator(clang::BinaryOperator *E); bool VisitImplicitCastExpr(clang::ImplicitCastExpr *E); private: template clang::DiagnosticBuilder error(clang::SourceLocation loc, const char (&fmt)[N]); clang::ASTContext &C; clang::DiagnosticsEngine &diag_; clang::Rewriter &rewriter_; /// modifications to the source go into this class llvm::raw_ostream &out_; /// for debugging std::vector &tables_; /// store the open FDs std::vector fn_args_; std::set visited_; std::string current_fn_; }; // Do a depth-first search to rewrite all pointers that need to be probed class ProbeVisitor : public clang::RecursiveASTVisitor { public: explicit ProbeVisitor(clang::ASTContext &C, clang::Rewriter &rewriter); bool VisitVarDecl(clang::VarDecl *Decl); bool VisitCallExpr(clang::CallExpr *Call); bool VisitBinaryOperator(clang::BinaryOperator *E); bool VisitUnaryOperator(clang::UnaryOperator *E); bool VisitMemberExpr(clang::MemberExpr *E); void set_ptreg(clang::Decl *D) { ptregs_.insert(D); } private: template clang::DiagnosticBuilder error(clang::SourceLocation loc, const char (&fmt)[N]); clang::ASTContext &C; clang::Rewriter &rewriter_; std::set fn_visited_; std::set memb_visited_; std::set ptregs_; }; // A helper class to the frontend action, walks the decls class BTypeConsumer : public clang::ASTConsumer { public: explicit BTypeConsumer(clang::ASTContext &C, clang::Rewriter &rewriter, std::vector &tables); bool HandleTopLevelDecl(clang::DeclGroupRef Group) override; private: BTypeVisitor visitor_; }; // A helper class to the frontend action, walks the decls class ProbeConsumer : public clang::ASTConsumer { public: ProbeConsumer(clang::ASTContext &C, clang::Rewriter &rewriter); bool HandleTopLevelDecl(clang::DeclGroupRef Group) override; private: ProbeVisitor visitor_; }; // Create a B program in 2 phases (everything else is normal C frontend): // 1. Catch the map declarations and open the fd's // 2. Capture the IR class BFrontendAction : public clang::ASTFrontendAction { public: // Initialize with the output stream where the new source file contents // should be written. BFrontendAction(llvm::raw_ostream &os, unsigned flags); // Called by clang when the AST has been completed, here the output stream // will be flushed. void EndSourceFileAction() override; std::unique_ptr CreateASTConsumer(clang::CompilerInstance &Compiler, llvm::StringRef InFile) override; // take ownership of the table-to-fd mapping data structure std::unique_ptr> take_tables() { return move(tables_); } private: llvm::raw_ostream &os_; unsigned flags_; std::unique_ptr rewriter_; std::unique_ptr> tables_; }; } // namespace visitor bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/kbuild_helper.cc000066400000000000000000000073421305314114400240660ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "kbuild_helper.h" namespace ebpf { using std::string; using std::vector; KBuildHelper::KBuildHelper(const std::string &kdir, bool has_source_dir) : kdir_(kdir), has_source_dir_(has_source_dir) { } // read the flags from cache or learn int KBuildHelper::get_flags(const char *uname_machine, vector *cflags) { //uname -m | sed -e s/i.86/x86/ -e s/x86_64/x86/ -e s/sun4u/sparc64/ -e s/arm.*/arm/ // -e s/sa110/arm/ -e s/s390x/s390/ -e s/parisc64/parisc/ // -e s/ppc.*/powerpc/ -e s/mips.*/mips/ -e s/sh[234].*/sh/ // -e s/aarch64.*/arm64/ string arch = uname_machine; if (!strncmp(uname_machine, "x86_64", 6)) { arch = "x86"; } else if (uname_machine[0] == 'i' && !strncmp(&uname_machine[2], "86", 2)) { arch = "x86"; } else if (!strncmp(uname_machine, "arm", 3)) { arch = "arm"; } else if (!strncmp(uname_machine, "sa110", 5)) { arch = "arm"; } else if (!strncmp(uname_machine, "s390x", 5)) { arch = "s390"; } else if (!strncmp(uname_machine, "parisc64", 8)) { arch = "parisc"; } else if (!strncmp(uname_machine, "ppc", 3)) { arch = "powerpc"; } else if (!strncmp(uname_machine, "mips", 4)) { arch = "mips"; } else if (!strncmp(uname_machine, "sh", 2)) { arch = "sh"; } else if (!strncmp(uname_machine, "aarch64", 7)) { arch = "arm64"; } cflags->push_back("-nostdinc"); cflags->push_back("-isystem"); cflags->push_back("/virtual/lib/clang/include"); // some module build directories split headers between source/ and build/ if (has_source_dir_) { cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include"); cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include/generated/uapi"); cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include/generated"); cflags->push_back("-I" + kdir_ + "/build/include"); cflags->push_back("-I" + kdir_ + "/build/./arch/"+arch+"/include/uapi"); cflags->push_back("-I" + kdir_ + "/build/arch/"+arch+"/include/generated/uapi"); cflags->push_back("-I" + kdir_ + "/build/include/uapi"); cflags->push_back("-I" + kdir_ + "/build/include/generated"); cflags->push_back("-I" + kdir_ + "/build/include/generated/uapi"); } cflags->push_back("-I./arch/"+arch+"/include"); cflags->push_back("-Iarch/"+arch+"/include/generated/uapi"); cflags->push_back("-Iarch/"+arch+"/include/generated"); cflags->push_back("-Iinclude"); cflags->push_back("-I./arch/"+arch+"/include/uapi"); cflags->push_back("-Iarch/"+arch+"/include/generated/uapi"); cflags->push_back("-I./include/uapi"); cflags->push_back("-Iinclude/generated/uapi"); cflags->push_back("-include"); cflags->push_back("./include/linux/kconfig.h"); cflags->push_back("-D__KERNEL__"); cflags->push_back("-D__HAVE_BUILTIN_BSWAP16__"); cflags->push_back("-D__HAVE_BUILTIN_BSWAP32__"); cflags->push_back("-D__HAVE_BUILTIN_BSWAP64__"); cflags->push_back("-Wno-unused-value"); cflags->push_back("-Wno-pointer-sign"); cflags->push_back("-fno-stack-protector"); return 0; } } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/kbuild_helper.h000066400000000000000000000054171305314114400237310ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include namespace ebpf { struct FileDeleter { void operator() (FILE *fp) { fclose(fp); } }; typedef std::unique_ptr FILEPtr; // Helper with pushd/popd semantics class DirStack { public: explicit DirStack(const std::string &dst) : ok_(false) { if (getcwd(cwd_, sizeof(cwd_)) == NULL) { ::perror("getcwd"); return; } if (::chdir(dst.c_str())) { fprintf(stderr, "chdir(%s): %s\n", dst.c_str(), strerror(errno)); return; } ok_ = true; } ~DirStack() { if (!ok_) return; if (::chdir(cwd_)) { fprintf(stderr, "chdir(%s): %s\n", cwd_, strerror(errno)); } } bool ok() const { return ok_; } const char * cwd() const { return cwd_; } private: bool ok_; char cwd_[256]; }; static int ftw_cb(const char *path, const struct stat *, int, struct FTW *) { return ::remove(path); } // Scoped class to manage the creation/deletion of tmpdirs class TmpDir { public: explicit TmpDir(const std::string &prefix = "/tmp/bcc-") : ok_(false), prefix_(prefix) { prefix_ += "XXXXXX"; if (::mkdtemp((char *)prefix_.data()) == NULL) ::perror("mkdtemp"); else ok_ = true; } ~TmpDir() { if (::nftw(prefix_.c_str(), ftw_cb, 20, FTW_DEPTH) < 0) ::perror("ftw"); else ::remove(prefix_.c_str()); } bool ok() const { return ok_; } const std::string & str() const { return prefix_; } private: bool ok_; std::string prefix_; }; // Compute the kbuild flags for the currently running kernel // Do this by: // 1. Create temp Makefile with stub dummy.c // 2. Run module build on that makefile, saving the computed flags to a file // 3. Cache the file for fast flag lookup in subsequent runs // Note: Depending on environment, different cache locations may be desired. In // case we eventually support non-root user programs, cache in $HOME. class KBuildHelper { public: explicit KBuildHelper(const std::string &kdir, bool has_source_dir); int get_flags(const char *uname_machine, std::vector *cflags); private: std::string kdir_; bool has_source_dir_; }; } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/loader.cc000066400000000000000000000237571305314114400225330ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "common.h" #include "bcc_exception.h" #include "exported_files.h" #include "kbuild_helper.h" #include "b_frontend_action.h" #include "tp_frontend_action.h" #include "loader.h" using std::map; using std::string; using std::unique_ptr; using std::vector; namespace ebpf { map> ClangLoader::remapped_files_; ClangLoader::ClangLoader(llvm::LLVMContext *ctx, unsigned flags) : ctx_(ctx), flags_(flags) { if (remapped_files_.empty()) { for (auto f : ExportedFiles::headers()) remapped_files_[f.first] = llvm::MemoryBuffer::getMemBuffer(f.second); } } ClangLoader::~ClangLoader() {} namespace { bool is_dir(const string& path) { struct stat buf; if (::stat (path.c_str (), &buf) < 0) return false; return S_ISDIR(buf.st_mode); } std::pair get_kernel_path_info(const string kdir) { if (is_dir(kdir + "/build") && is_dir(kdir + "/source")) return std::make_pair (true, "source"); const char* suffix_from_env = ::getenv("BCC_KERNEL_MODULES_SUFFIX"); if (suffix_from_env) return std::make_pair(false, string(suffix_from_env)); return std::make_pair(false, "build"); } } int ClangLoader::parse(unique_ptr *mod, unique_ptr> *tables, const string &file, bool in_memory, const char *cflags[], int ncflags) { using namespace clang; string main_path = "/virtual/main.c"; unique_ptr main_buf; struct utsname un; uname(&un); string kdir = string(KERNEL_MODULES_DIR) + "/" + un.release; auto kernel_path_info = get_kernel_path_info (kdir); // clang needs to run inside the kernel dir DirStack dstack(kdir + "/" + kernel_path_info.second); if (!dstack.ok()) return -1; string abs_file; if (in_memory) { abs_file = main_path; main_buf = llvm::MemoryBuffer::getMemBuffer(file); } else { if (file.substr(0, 1) == "/") abs_file = file; else abs_file = string(dstack.cwd()) + "/" + file; } // -fno-color-diagnostics: this is a workaround for a bug in llvm terminalHasColors() as of // 22 Jul 2016. Also see bcc #615. vector flags_cstr({"-O0", "-emit-llvm", "-I", dstack.cwd(), "-Wno-deprecated-declarations", "-Wno-gnu-variable-sized-type-not-at-end", "-fno-color-diagnostics", "-fno-unwind-tables", "-fno-asynchronous-unwind-tables", "-x", "c", "-c", abs_file.c_str()}); KBuildHelper kbuild_helper(kdir, kernel_path_info.first); vector kflags; if (kbuild_helper.get_flags(un.machine, &kflags)) return -1; kflags.push_back("-include"); kflags.push_back("/virtual/include/bcc/bpf.h"); kflags.push_back("-include"); kflags.push_back("/virtual/include/bcc/helpers.h"); kflags.push_back("-isystem"); kflags.push_back("/virtual/include"); for (auto it = kflags.begin(); it != kflags.end(); ++it) flags_cstr.push_back(it->c_str()); if (cflags) { for (auto i = 0; i < ncflags; ++i) flags_cstr.push_back(cflags[i]); } // set up the error reporting class IntrusiveRefCntPtr diag_opts(new DiagnosticOptions()); auto diag_client = new TextDiagnosticPrinter(llvm::errs(), &*diag_opts); IntrusiveRefCntPtr DiagID(new DiagnosticIDs()); DiagnosticsEngine diags(DiagID, &*diag_opts, diag_client); // set up the command line argument wrapper #if defined(__powerpc64__) #if defined(_CALL_ELF) && _CALL_ELF == 2 driver::Driver drv("", "powerpc64le-unknown-linux-gnu", diags); #else driver::Driver drv("", "powerpc64-unknown-linux-gnu", diags); #endif #elif defined(__aarch64__) driver::Driver drv("", "aarch64-unknown-linux-gnu", diags); #else driver::Driver drv("", "x86_64-unknown-linux-gnu", diags); #endif drv.setTitle("bcc-clang-driver"); drv.setCheckInputsExist(false); unique_ptr compilation(drv.BuildCompilation(flags_cstr)); if (!compilation) return -1; // expect exactly 1 job, otherwise error const driver::JobList &jobs = compilation->getJobs(); if (jobs.size() != 1 || !isa(*jobs.begin())) { SmallString<256> msg; llvm::raw_svector_ostream os(msg); jobs.Print(os, "; ", true); diags.Report(diag::err_fe_expected_compiler_job) << os.str(); return -1; } const driver::Command &cmd = cast(*jobs.begin()); if (llvm::StringRef(cmd.getCreator().getName()) != "clang") { diags.Report(diag::err_fe_expected_clang_command); return -1; } // Initialize a compiler invocation object from the clang (-cc1) arguments. const driver::ArgStringList &ccargs = cmd.getArguments(); if (flags_ & DEBUG_PREPROCESSOR) { llvm::errs() << "clang"; for (auto arg : ccargs) llvm::errs() << " " << arg; llvm::errs() << "\n"; } // pre-compilation pass for generating tracepoint structures CompilerInstance compiler0; CompilerInvocation &invocation0 = compiler0.getInvocation(); if (!CompilerInvocation::CreateFromArgs( invocation0, const_cast(ccargs.data()), const_cast(ccargs.data()) + ccargs.size(), diags)) return -1; invocation0.getPreprocessorOpts().RetainRemappedFileBuffers = true; for (const auto &f : remapped_files_) invocation0.getPreprocessorOpts().addRemappedFile(f.first, &*f.second); if (in_memory) { invocation0.getPreprocessorOpts().addRemappedFile(main_path, &*main_buf); invocation0.getFrontendOpts().Inputs.clear(); invocation0.getFrontendOpts().Inputs.push_back( FrontendInputFile(main_path, IK_C)); } invocation0.getFrontendOpts().DisableFree = false; compiler0.createDiagnostics(new IgnoringDiagConsumer()); // capture the rewritten c file string out_str; llvm::raw_string_ostream os(out_str); TracepointFrontendAction tpact(os); compiler0.ExecuteAction(tpact); // ignore errors, they will be reported later unique_ptr out_buf = llvm::MemoryBuffer::getMemBuffer(out_str); // first pass CompilerInstance compiler1; CompilerInvocation &invocation1 = compiler1.getInvocation(); if (!CompilerInvocation::CreateFromArgs( invocation1, const_cast(ccargs.data()), const_cast(ccargs.data()) + ccargs.size(), diags)) return -1; // This option instructs clang whether or not to free the file buffers that we // give to it. Since the embedded header files should be copied fewer times // and reused if possible, set this flag to true. invocation1.getPreprocessorOpts().RetainRemappedFileBuffers = true; for (const auto &f : remapped_files_) invocation1.getPreprocessorOpts().addRemappedFile(f.first, &*f.second); invocation1.getPreprocessorOpts().addRemappedFile(main_path, &*out_buf); invocation1.getFrontendOpts().Inputs.clear(); invocation1.getFrontendOpts().Inputs.push_back( FrontendInputFile(main_path, IK_C)); invocation1.getFrontendOpts().DisableFree = false; compiler1.createDiagnostics(); // capture the rewritten c file string out_str1; llvm::raw_string_ostream os1(out_str1); BFrontendAction bact(os1, flags_); if (!compiler1.ExecuteAction(bact)) return -1; unique_ptr out_buf1 = llvm::MemoryBuffer::getMemBuffer(out_str1); // this contains the open FDs *tables = bact.take_tables(); // second pass, clear input and take rewrite buffer CompilerInstance compiler2; CompilerInvocation &invocation2 = compiler2.getInvocation(); if (!CompilerInvocation::CreateFromArgs( invocation2, const_cast(ccargs.data()), const_cast(ccargs.data()) + ccargs.size(), diags)) return -1; invocation2.getPreprocessorOpts().RetainRemappedFileBuffers = true; for (const auto &f : remapped_files_) invocation2.getPreprocessorOpts().addRemappedFile(f.first, &*f.second); invocation2.getPreprocessorOpts().addRemappedFile(main_path, &*out_buf1); invocation2.getFrontendOpts().Inputs.clear(); invocation2.getFrontendOpts().Inputs.push_back( FrontendInputFile(main_path, IK_C)); invocation2.getFrontendOpts().DisableFree = false; // suppress warnings in the 2nd pass, but bail out on errors (our fault) invocation2.getDiagnosticOpts().IgnoreWarnings = true; compiler2.createDiagnostics(); EmitLLVMOnlyAction ir_act(&*ctx_); if (!compiler2.ExecuteAction(ir_act)) return -1; *mod = ir_act.takeModule(); return 0; } } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/loader.h000066400000000000000000000023261305314114400223620ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include namespace llvm { class Module; class LLVMContext; class MemoryBuffer; } namespace ebpf { struct TableDesc; class ClangLoader { public: explicit ClangLoader(llvm::LLVMContext *ctx, unsigned flags); ~ClangLoader(); int parse(std::unique_ptr *mod, std::unique_ptr> *tables, const std::string &file, bool in_memory, const char *cflags[], int ncflags); private: static std::map> remapped_files_; llvm::LLVMContext *ctx_; unsigned flags_; }; } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/tp_frontend_action.cc000066400000000000000000000153111305314114400251270ustar00rootroot00000000000000/* * Copyright (c) 2016 Sasha Goldshtein * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "tp_frontend_action.h" namespace ebpf { using std::map; using std::set; using std::string; using std::to_string; using std::unique_ptr; using std::vector; using std::regex; using std::smatch; using std::regex_search; using std::ifstream; using namespace clang; TracepointTypeVisitor::TracepointTypeVisitor(ASTContext &C, Rewriter &rewriter) : C(C), diag_(C.getDiagnostics()), rewriter_(rewriter), out_(llvm::errs()) { } enum class field_kind_t { common, data_loc, regular, invalid }; static inline field_kind_t _get_field_kind(string const& line, string& field_type, string& field_name) { auto field_pos = line.find("field:"); if (field_pos == string::npos) return field_kind_t::invalid; auto semi_pos = line.find(';', field_pos); if (semi_pos == string::npos) return field_kind_t::invalid; auto size_pos = line.find("size:", semi_pos); if (size_pos == string::npos) return field_kind_t::invalid; auto field = line.substr(field_pos + 6/*"field:"*/, semi_pos - field_pos - 6); auto pos = field.find_last_of("\t "); if (pos == string::npos) return field_kind_t::invalid; field_type = field.substr(0, pos); field_name = field.substr(pos + 1); if (field_type.find("__data_loc") != string::npos) return field_kind_t::data_loc; if (field_name.find("common_") == 0) return field_kind_t::common; return field_kind_t::regular; } string TracepointTypeVisitor::GenerateTracepointStruct( SourceLocation loc, string const& category, string const& event) { string format_file = "/sys/kernel/debug/tracing/events/" + category + "/" + event + "/format"; ifstream input(format_file.c_str()); if (!input) return ""; string tp_struct = "struct tracepoint__" + category + "__" + event + " {\n"; tp_struct += "\tu64 __do_not_use__;\n"; for (string line; getline(input, line); ) { string field_type, field_name; switch (_get_field_kind(line, field_type, field_name)) { case field_kind_t::invalid: case field_kind_t::common: continue; case field_kind_t::data_loc: tp_struct += "\tint data_loc_" + field_name + ";\n"; break; case field_kind_t::regular: tp_struct += "\t" + field_type + " " + field_name + ";\n"; break; } } tp_struct += "};\n"; return tp_struct; } static inline bool _is_tracepoint_struct_type(string const& type_name, string& tp_category, string& tp_event) { // We are looking to roughly match the regex: // (?:struct|class)\s+tracepoint__(\S+)__(\S+) // Not using std::regex because older versions of GCC don't support it yet. // E.g., the libstdc++ that ships with Ubuntu 14.04. auto first_space_pos = type_name.find_first_of("\t "); if (first_space_pos == string::npos) return false; auto first_tok = type_name.substr(0, first_space_pos); if (first_tok != "struct" && first_tok != "class") return false; auto non_space_pos = type_name.find_first_not_of("\t ", first_space_pos); auto second_space_pos = type_name.find_first_of("\t ", non_space_pos); auto second_tok = type_name.substr(non_space_pos, second_space_pos - non_space_pos); if (second_tok.find("tracepoint__") != 0) return false; auto tp_event_pos = second_tok.rfind("__"); if (tp_event_pos == string::npos) return false; tp_event = second_tok.substr(tp_event_pos + 2); auto tp_category_pos = second_tok.find("__"); if (tp_category_pos == tp_event_pos) return false; tp_category = second_tok.substr(tp_category_pos + 2, tp_event_pos - tp_category_pos - 2); return true; } bool TracepointTypeVisitor::VisitFunctionDecl(FunctionDecl *D) { if (D->isExternallyVisible() && D->hasBody()) { // If this function has a tracepoint structure as an argument, // add that structure declaration based on the structure name. for (auto it = D->param_begin(); it != D->param_end(); ++it) { auto arg = *it; auto type = arg->getType(); if (type->isPointerType() && type->getPointeeType()->isStructureOrClassType()) { auto type_name = QualType::getAsString(type.split()); string tp_cat, tp_evt; if (_is_tracepoint_struct_type(type_name, tp_cat, tp_evt)) { string tp_struct = GenerateTracepointStruct( D->getLocStart(), tp_cat, tp_evt); // Get the actual function declaration point (the macro instantiation // point if using the TRACEPOINT_PROBE macro instead of the macro // declaration point in bpf_helpers.h). auto insert_loc = D->getLocStart(); insert_loc = rewriter_.getSourceMgr().getFileLoc(insert_loc); rewriter_.InsertText(insert_loc, tp_struct); } } } } return true; } TracepointTypeConsumer::TracepointTypeConsumer(ASTContext &C, Rewriter &rewriter) : visitor_(C, rewriter) { } bool TracepointTypeConsumer::HandleTopLevelDecl(DeclGroupRef Group) { for (auto D : Group) visitor_.TraverseDecl(D); return true; } TracepointFrontendAction::TracepointFrontendAction(llvm::raw_ostream &os) : os_(os), rewriter_(new Rewriter) { } void TracepointFrontendAction::EndSourceFileAction() { rewriter_->getEditBuffer(rewriter_->getSourceMgr().getMainFileID()).write(os_); os_.flush(); } unique_ptr TracepointFrontendAction::CreateASTConsumer( CompilerInstance &Compiler, llvm::StringRef InFile) { rewriter_->setSourceMgr(Compiler.getSourceManager(), Compiler.getLangOpts()); return unique_ptr(new TracepointTypeConsumer( Compiler.getASTContext(), *rewriter_)); } } bpfcc-0.2.0+git0.02884a026/src/cc/frontends/clang/tp_frontend_action.h000066400000000000000000000044501305314114400247730ustar00rootroot00000000000000/* * Copyright (c) 2016 Sasha Goldshtein * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include namespace clang { class ASTConsumer; class ASTContext; class CompilerInstance; } namespace llvm { class raw_ostream; class StringRef; } namespace ebpf { // Visit functions that have a tracepoint argument structure in their signature // and automatically generate the structure on-the-fly. class TracepointTypeVisitor : public clang::RecursiveASTVisitor { public: explicit TracepointTypeVisitor(clang::ASTContext &C, clang::Rewriter &rewriter); bool VisitFunctionDecl(clang::FunctionDecl *D); private: std::string GenerateTracepointStruct(clang::SourceLocation loc, std::string const& category, std::string const& event); clang::ASTContext &C; clang::DiagnosticsEngine &diag_; clang::Rewriter &rewriter_; llvm::raw_ostream &out_; }; class TracepointTypeConsumer : public clang::ASTConsumer { public: explicit TracepointTypeConsumer(clang::ASTContext &C, clang::Rewriter &rewriter); bool HandleTopLevelDecl(clang::DeclGroupRef Group) override; private: TracepointTypeVisitor visitor_; }; class TracepointFrontendAction : public clang::ASTFrontendAction { public: TracepointFrontendAction(llvm::raw_ostream &os); void EndSourceFileAction() override; std::unique_ptr CreateASTConsumer(clang::CompilerInstance &Compiler, llvm::StringRef InFile) override; private: llvm::raw_ostream &os_; std::unique_ptr rewriter_; }; } // namespace visitor bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/000077500000000000000000000000001305314114400201775ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/README.md000066400000000000000000000337331305314114400214670ustar00rootroot00000000000000# Compiling P4 to EBPF Mihai Budiu - mbudiu@barefootnetworks.com September 22, 2015 ## Abstract This document describes a prototype compiler that translates programs written in the P4 programming languages to eBPF programs. The translation is performed by generating programs written in a subset of the C programming language, that are converted to EBPF using the BPF Compiler Collection tools. The compiler code is licensed under an [Apache v2.0 license] (http://www.apache.org/licenses/LICENSE-2.0.html). ## Preliminaries In this section we give a brief overview of P4 and EBPF. A detailed treatment of these topics is outside the scope of this text. ### P4 P4 (http://p4.org) is a domain-specific programming language for specifying the behavior of the dataplanes of network-forwarding elements. The name of the programming language comes from the title of a paper published in the proceedings of SIGCOMM Computer Communications Review in 2014: http://www.sigcomm.org/ccr/papers/2014/July/0000000.0000004: "Programming Protocol-Independent Packet Processors". P4 itself is protocol-independent but allows programmers to express a rich set of data plane behaviors and protocols. The core P4 abstractions are: * Header definitions describe the format (the set of fields and their sizes) of each header within a packet. * Parse graphs (finite-state machines) describe the permitted header sequences within received packets. * Tables associate keys to actions. P4 tables generalize traditional forwarding tables; they can be used to implement routing tables, flow lookup tables, access-control lists, etc. * Actions describe how packet header fields and metadata are manipulated. * Match-action units stitch together tables and actions, and perform the following sequence of operations: * Construct lookup keys from packet fields or computed metadata, * Use the constructed lookup key to index into tables, choosing an action to execute, * Finally, execute the selected action. * Control flow is expressed as an imperative program describing the data-dependent packet processing within a pipeline, including the data-dependent sequence of match-action unit invocations. P4 programs describe the behavior of network-processing dataplanes. A P4 program is designed to operate in concert with a separate *control plane* program. The control plane is responsible for managing at runtime the contents of the P4 tables. P4 cannot be used to specify control-planes; however, a P4 program implicitly specifies the interface between the data-plane and the control-plane. The P4 language is under active development; the current stable version is 1.0.2 (see http://p4.org/spec); a reference implementation of a compiler and associated tools is freely available using a Apache 2 open-source license (see http://p4.org/code). ### EBPF #### Safe code EBPF is a acronym that stands for Extended Berkeley Packet Filters. In essence EBPF is a low-level programming language (similar to machine code); EBPF programs are traditionally executed by a virtual machine that resides in the Linux kernel. EBPF programs can be inserted and removed from a live kernel using dynamic code instrumentation. The main feature of EBPF programs is their *static safety*: prior to execution all EBPF programs have to be validated as being safe, and unsafe programs cannot be executed. A safe program provably cannot compromise the machine it is running on: * it can only access a restricted memory region (on the local stack) * it can run only for a limited amount of time; during execution it cannot block, sleep or take any locks * it cannot use any kernel resources with the exception of a limited set of kernel services which have been specifically whitelisted, including operations to manipulate tables (described below) #### Kernel hooks EBPF programs are inserted into the kernel using *hooks*. There are several types of hooks available: * any function entry point in the kernel can act as a hook; attaching an EBPF program to a function `foo()` will cause the EBPF program to execute every time some kernel thread executes `foo()`. * EBPF programs can also be attached using the Linux Traffic Control (TC) subsystem, in the network packet processing datapath. Such programs can be used as TC classifiers and actions. * EBPF programs can also be attached to sockets or network interfaces. In this case they can be used for processing packets that flow through the socket/interface. EBPF programs can be used for many purposes; the main use cases are dynamic tracing and monitoring, and packet processing. We are mostly interested in the latter use case in this document. #### EBPF Tables The EBPF runtime exposes a bi-directional kernel-userspace data communication channel, called *tables* (also called maps in some EBPF documents and code samples). EBPF tables are essentially key-value stores, where keys and values are arbitrary fixed-size bitstrings. The key width, value width and table size (maximum number of entries that can be stored) are declared statically, at table creation time. In user-space tables handles are exposed as file descriptors. Both user- and kernel-space programs can manipulate tables, by inserting, deleting, looking up, modifying, and enumerating entries in a table. In kernel space the keys and values are exposed as pointers to the raw underlying data stored in the table, whereas in user-space the pointers point to copies of the data. #### Concurrency An important aspect to understand related to EBPF is the execution model. An EBPF program is triggered by a kernel hook; multiple instances of the same kernel hook can be running simultaneously on different cores. Each table however has a single instances across all the cores. A single table may be accessed simultaneously by multiple instances of the same EBPF program running as separate kernel threads on different cores. EBPF tables are native kernel objects, and access to the table contents is protected using the kernel RCU mechanism. This makes access to table entries safe under concurrent execution; for example, the memory associated to a value cannot be accidentally freed while an EBPF program holds a pointer to the respective value. However, accessing tables is prone to data races; since EBPF programs cannot use locks, some of these races often cannot be avoided. EBPF and the associated tools are also under active development, and new capabilities are added frequently. The P4 compiler generates code that can be compiled using the BPF Compiler Collection (BCC) (https://github.com/iovisor/bcc) ## Compiling P4 to EBPF From the above description it is apparent that the P4 and EBPF programming languages have different expressive powers. However, there is a significant overlap in their capabilities, in particular, in the domain of network packet processing. The following image illustrates the situation: ![P4 and EBPF overlap in capabilities](scope.png) We expect that the overlapping region will grow in size as both P4 and EBPF continue to mature. The current version of the P4 to EBPF compiler translates programs written in the version 1.1 of the P4 programming language to programs written in a restricted subset of C. The subset of C is chosen such that it should be compilable to EBPF using BCC. ``` -------------- ------- P4 ---> | P4-to-EBPF | ---> C ----> | BCC | --> EBPF -------------- ------- ``` The P4 program only describes the packet processing *data plane*, that runs in the Linux kernel. The *control plane* must be separately implemented by the user. The BCC tools simplify this task considerably, by generating C and/or Python APIs that expose the dataplane/control-plane APIs. ### Dependencies EBPF programs require a Linux kernel with version 4.2 or newer. In order to use the P4 to EBPF compiler the following software must be installed: * The compiler itself is written in the Python (v2.x) programming language. * the P4 compiler front-end: (https://github.com/p4lang/p4-hlir). This is required for parsing the P4 programs. * the BCC compiler collection tools: (https://github.com/iovisor/bcc). This is required for compiling the generated code. Also, BCC comes with a set of Python utilities which can be used to implement control-plane programs that operate in concert with the kernel EBPF datapath. The P4 to EBPF compiler generates code that is designed for being used as a classifier using the Linux TC subsystem. Furthermore, the test code provided is written using the Python (v3.x) programming language and requires several Python packages to be installed. ### Supported capabilities The current version of the P4 to EBPF compiler supports a relatively narrow subset of the P4 language, but still powerful enough to write very complex packet filters and simple packet forwarding engines. In the spirit of open-source "release early, release often", we expect that the compiler's capabilities will improve gradually. * Packet filtering is performed using the `drop()` action. Packets that are not dropped will be forwarded. * Packet forwarding is performed by setting the `standard_metadata.egress_port` to the index of the destination network interface Here are some limitations imposed on the P4 programs: * Currently both the ingress and the egress P4 pipelines are executed at the same hook (wherever the user chooses to insert the generated EBPF program). In the future the compiler should probably generate two separate EBPF programs. * arbitrary parsers can be compiled, but the BCC compiler will reject parsers that contain cycles * arithmetic on data wider than 32 bits is not supported * checksum computations are not implemented. In consequence, programs that IP/TCP/UDP headers will produce incorrect packet headers. * EBPF does not offer support for ternary or LPM tables * P4 cloning and recirculation and not supported * meters and registers are not supported; only direct counters are currently supported. EBPF can potentially support registers and arbitrary counters, so these may appear in the future. * learning (i.e. `generate_digest`) is not implemented ### Translating P4 to C To simplify the translation, the P4 programmer should refrain using identifiers whose name starts with `ebpf_`. The following table provides a brief summary of how each P4 construct is mapped to a corresponding C construct: #### Translating parsers P4 Construct | C Translation ----------|------------ `header_type` | `struct` type `header` | `struct` instance with an additional `valid` bit `metadata` | `struct` instance parser state | code block state transition | `goto` statement `extract` | load/shift/mask data from packet buffer #### Translating match-action pipelines P4 Construct | C Translation ----------|------------ table | 2 EBPF tables: second one used just for the default action table key | `struct` type table `actions` block | tagged `union` with all possible actions `action` arguments | `struct` table `reads` | EBPF table access `action` body | code block table `apply` | `switch` statement counters | additional EBPF table ### Code organization The compiler code is organized in two folders: * `compiler`: the complete compiler source code, in Python v2.x The compiler entry point is `p4toEbpf.py`. * `test`: testing code and data. There are two testing programs: * `testP4toEbpf.py`: which compiles all P4 files in the testprograms folder * `endToEndTest.py`: which compiles and executes the simple.p4 program, and includes a simple control plane Currently the compiler contains no installation capabilities. ### Invoking the compiler Invoking the compiler is just a matter of invoking the python program with a suitable input P4 file: ``` p4toEbpf.py file.p4 -o file.c ``` #### Compiler options The P4 compiler first runs the C preprocessor on the input P4 file. Some of the command-line options are passed directly to the preprocessor. The following compiler options are available: Option | Meaning -------|-------- `-D macro` | Option passed to C preprocessor `-I path` | Option passed to C preprocessor `-U macro` | Option passed to C preprocessor `-g [router|filter]` | Controls whether the generated code behaves like a router or a filter. `-o outoutFile` | writes the generated C code to the specified output file. The `-g` option controls the nature of the generated code: * `-g filter` generates a filter; the only P4 action that has an effect is the `drop()` action. Setting metadata in P4 (e.g., `egress_port`) has no effect. * `-g router` generates a simple router; both `drop()` and `egress_port` impact packet processing. #### Using the generated code The resulting file contains the complete data structures, tables, and a C function named `ebpf_filter` that implements the P4-specified data-plane. This C file can be manipulated using the BCC tools; please refer to the BCC project documentation and sample test files of the P4 to EBPF source code for an in-depth understanding. A minimal Python program that compiles and loads into the kernel the generated file into EBPF is: ``` #!/usr/bin/env python3 from bcc import BPF b = BPF(src_file="file.c", debug=0) fn = b.load_func("ebpf_filter", BPF.SCHED_CLS) ``` ##### Connecting the generated program with the TC The EBPF code that is generated is intended to be used as a classifier attached to the ingress packet path using the Linux TC subsystem. The same EBPF code should be attached to all interfaces. Note however that all EBPF code instances share a single set of tables, which are used to control the program behavior. The following code fragment illustrates how the EBPF code can be hooked up to the `eth0` interface using a Python program. (The `fn` variable is the one produced by the previous code fragment). ``` from pyroute2 import IPRoute ipr = IPRoute() interface_name="eth0" if_index = ipr.link_lookup(ifname=interface_name)[0] ipr.tc("add", "ingress", if_index, "ffff:") ipr.tc("add-filter", "bpf", if_index, ":1", fd=fn.fd, name=fn.name, parent="ffff:", action="ok", classid=1) ``` bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/000077500000000000000000000000001305314114400220115ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/README.txt000066400000000000000000000003001305314114400235000ustar00rootroot00000000000000This folder contains an implementation of a simple compiler that translates a programs written in a subset of P4 into C that can in turn be compiled into EBPF using the IOVisor bcc compiler. bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/compilationException.py000066400000000000000000000020751305314114400265640ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") class CompilationException(Exception): """Signals an error during compilation""" def __init__(self, isBug, format, *message): # isBug: indicates that this is a compiler bug super(CompilationException, self).__init__() assert isinstance(format, str) assert isinstance(isBug, bool) self.message = message self.format = format self.isBug = isBug def show(self): # TODO: format this message nicely return self.format.format(*self.message) class NotSupportedException(Exception): archError = " not supported by EBPF" def __init__(self, format, *message): super(NotSupportedException, self).__init__() assert isinstance(format, str) self.message = message self.format = format def show(self): # TODO: format this message nicely return (self.format + NotSupportedException.archError).format( *self.message) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfAction.py000066400000000000000000000365411305314114400244460ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import p4_action, p4_field from p4_hlir.hlir import p4_signature_ref, p4_header_instance import ebpfProgram from programSerializer import ProgramSerializer from compilationException import * import ebpfScalarType import ebpfCounter import ebpfType import ebpfInstance class EbpfActionData(object): def __init__(self, name, argtype): self.name = name self.argtype = argtype class EbpfActionBase(object): def __init__(self, p4action): self.name = p4action.name self.hliraction = p4action self.builtin = False self.arguments = [] def serializeArgumentsAsStruct(self, serializer): serializer.emitIndent() serializer.appendFormat("/* no arguments for {0} */", self.name) serializer.newline() def serializeBody(self, serializer, valueName, program): serializer.emitIndent() serializer.appendFormat("/* no body for {0} */", self.name) serializer.newline() def __str__(self): return "EbpfAction({0})".format(self.name) class EbpfAction(EbpfActionBase): unsupported = [ # The following cannot be done in EBPF "add_header", "remove_header", "execute_meter", "clone_ingress_pkt_to_egress", "clone_egress_pkt_to_egress", "generate_digest", "resubmit", "modify_field_with_hash_based_offset", "truncate", "push", "pop", # The following could be done, but are not yet implemented # The situation with copy_header is complicated, # because we don't do checksums "copy_header", "count", "register_read", "register_write"] # noinspection PyUnresolvedReferences def __init__(self, p4action, program): super(EbpfAction, self).__init__(p4action) assert isinstance(p4action, p4_action) assert isinstance(program, ebpfProgram.EbpfProgram) self.builtin = False self.invalid = False # a leaf action which is never # called from a table can be invalid. for i in range(0, len(p4action.signature)): param = p4action.signature[i] width = p4action.signature_widths[i] if width is None: self.invalid = True return argtype = ebpfScalarType.EbpfScalarType(p4action, width, False, program.config) actionData = EbpfActionData(param, argtype) self.arguments.append(actionData) def serializeArgumentsAsStruct(self, serializer): if self.invalid: raise CompilationException(True, "{0} Attempting to generate code for an invalid action", self.hliraction) # Build a struct containing all action arguments. serializer.emitIndent() serializer.append("struct ") serializer.blockStart() assert isinstance(serializer, ProgramSerializer) for arg in self.arguments: assert isinstance(arg, EbpfActionData) serializer.emitIndent() argtype = arg.argtype assert isinstance(argtype, ebpfType.EbpfType) argtype.declare(serializer, arg.name, False) serializer.endOfStatement(True) serializer.blockEnd(False) serializer.space() serializer.append(self.name) serializer.endOfStatement(True) def serializeBody(self, serializer, dataContainer, program): if self.invalid: raise CompilationException(True, "{0} Attempting to generate code for an invalid action", self.hliraction) # TODO: generate PARALLEL implementation # dataContainer is a string containing the variable name # containing the action data assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) assert isinstance(dataContainer, str) callee_list = self.hliraction.flat_call_sequence for e in callee_list: action = e[0] assert isinstance(action, p4_action) arguments = e[1] assert isinstance(arguments, list) self.serializeCallee(self, action, arguments, serializer, dataContainer, program) def checkSize(self, call, args, program): size = None for a in args: if a is None: continue if size is None: size = a elif a != size: program.emitWarning( "{0}: Arguments do not have the same size {1} and {2}", call, size, a) return size @staticmethod def translateActionToOperator(actionName): if actionName == "add" or actionName == "add_to_field": return "+" elif actionName == "bit_and": return "&" elif actionName == "bit_or": return "|" elif actionName == "bit_xor": return "^" elif actionName == "subtract" or actionName == "subtract_from_field": return "-" else: raise CompilationException(True, "Unexpected primitive action {0}", actionName) def serializeCount(self, caller, arguments, serializer, dataContainer, program): assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) assert isinstance(arguments, list) assert len(arguments) == 2 counter = arguments[0] index = ArgInfo(arguments[1], caller, dataContainer, program) ctr = program.getCounter(counter.name) assert isinstance(ctr, ebpfCounter.EbpfCounter) serializer.emitIndent() serializer.blockStart() # This is actually incorrect, since the key is not always an u32. # This code is currently disabled key = program.reservedPrefix + "index" serializer.emitIndent() serializer.appendFormat("u32 {0} = {1};", key, index.asString) serializer.newline() ctr.serializeCode(key, serializer, program) serializer.blockEnd(True) def serializeCallee(self, caller, callee, arguments, serializer, dataContainer, program): if self.invalid: raise CompilationException( True, "{0} Attempting to generate code for an invalid action", self.hliraction) assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) assert isinstance(callee, p4_action) assert isinstance(arguments, list) if callee.name in EbpfAction.unsupported: raise NotSupportedException("{0}", callee) # This is not yet ready #if callee.name == "count": # self.serializeCount(caller, arguments, # serializer, dataContainer, program) # return serializer.emitIndent() args = self.transformArguments(arguments, caller, dataContainer, program) if callee.name == "modify_field": dst = args[0] src = args[1] size = self.checkSize(callee, [a.widthInBits() for a in args], program) if size is None: raise CompilationException( True, "Cannot infer width for arguments {0}", callee) elif size <= 32: serializer.appendFormat("{0} = {1};", dst.asString, src.asString) else: if not dst.isLvalue: raise NotSupportedException( "Constants wider than 32-bit: {0}({1})", dst.caller, dst.asString) if not src.isLvalue: raise NotSupportedException( "Constants wider than 32-bit: {0}({1})", src.caller, src.asString) serializer.appendFormat("memcpy(&{0}, &{1}, {2});", dst.asString, src.asString, size / 8) elif (callee.name == "add" or callee.name == "bit_and" or callee.name == "bit_or" or callee.name == "bit_xor" or callee.name == "subtract"): size = self.checkSize(callee, [a.widthInBits() for a in args], program) if size is None: raise CompilationException( True, "Cannot infer width for arguments {0}", callee) if size > 32: raise NotSupportedException("{0}: Arithmetic on {1}-bits", callee, size) op = EbpfAction.translateActionToOperator(callee.name) serializer.appendFormat("{0} = {1} {2} {3};", args[0].asString, args[1].asString, op, args[2].asString) elif (callee.name == "add_to_field" or callee.name == "subtract_from_field"): size = self.checkSize(callee, [a.widthInBits() for a in args], program) if size is None: raise CompilationException( True, "Cannot infer width for arguments {0}", callee) if size > 32: raise NotSupportedException( "{0}: Arithmetic on {1}-bits", callee, size) op = EbpfAction.translateActionToOperator(callee.name) serializer.appendFormat("{0} = {0} {1} {2};", args[0].asString, op, args[1].asString) elif callee.name == "no_op": serializer.append("/* noop */") elif callee.name == "drop": serializer.appendFormat("{0} = 1;", program.dropBit) elif callee.name == "push" or callee.name == "pop": raise CompilationException( True, "{0} push/pop not yet implemented", callee) else: raise CompilationException( True, "Unexpected primitive action {0}", callee) serializer.newline() def transformArguments(self, arguments, caller, dataContainer, program): result = [] for a in arguments: t = ArgInfo(a, caller, dataContainer, program) result.append(t) return result class BuiltinAction(EbpfActionBase): def __init__(self, p4action): super(BuiltinAction, self).__init__(p4action) self.builtin = True def serializeBody(self, serializer, valueName, program): # This is ugly; there should be a better way if self.name == "drop": serializer.emitIndent() serializer.appendFormat("{0} = 1;", program.dropBit) serializer.newline() else: serializer.emitIndent() serializer.appendFormat("/* no body for {0} */", self.name) serializer.newline() class ArgInfo(object): # noinspection PyUnresolvedReferences # Represents an argument passed to an action def __init__(self, argument, caller, dataContainer, program): self.width = None self.asString = None self.isLvalue = True self.caller = caller assert isinstance(program, ebpfProgram.EbpfProgram) assert isinstance(caller, EbpfAction) if isinstance(argument, int): self.asString = str(argument) self.isLvalue = False # size is unknown elif isinstance(argument, p4_field): if ebpfProgram.EbpfProgram.isArrayElementInstance( argument.instance): if isinstance(argument.instance.index, int): index = "[" + str(argument.instance.index) + "]" else: raise CompilationException( True, "Unexpected index for array {0}", argument.instance.index) stackInstance = program.getStackInstance( argument.instance.base_name) assert isinstance(stackInstance, ebpfInstance.EbpfHeaderStack) fieldtype = stackInstance.basetype.getField(argument.name) self.width = fieldtype.widthInBits() self.asString = "{0}.{1}{3}.{2}".format( program.headerStructName, stackInstance.name, argument.name, index) else: instance = program.getInstance(argument.instance.base_name) if isinstance(instance, ebpfInstance.EbpfHeader): parent = program.headerStructName else: parent = program.metadataStructName fieldtype = instance.type.getField(argument.name) self.width = fieldtype.widthInBits() self.asString = "{0}.{1}.{2}".format( parent, instance.name, argument.name) elif isinstance(argument, p4_signature_ref): refarg = caller.arguments[argument.idx] self.asString = "{0}->u.{1}.{2}".format( dataContainer, caller.name, refarg.name) self.width = caller.arguments[argument.idx].argtype.widthInBits() elif isinstance(argument, p4_header_instance): # This could be a header array element # Unfortunately for push and pop, the user mean the whole array, # but the representation contains just the first element here. # This looks like a bug in the HLIR. if ebpfProgram.EbpfProgram.isArrayElementInstance(argument): if isinstance(argument.index, int): index = "[" + str(argument.index) + "]" else: raise CompilationException( True, "Unexpected index for array {0}", argument.index) stackInstance = program.getStackInstance(argument.base_name) assert isinstance(stackInstance, ebpfInstance.EbpfHeaderStack) fieldtype = stackInstance.basetype self.width = fieldtype.widthInBits() self.asString = "{0}.{1}{2}".format( program.headerStructName, stackInstance.name, index) else: instance = program.getInstance(argument.name) instancetype = instance.type self.width = instancetype.widthInBits() self.asString = "{0}.{1}".format( program.headerStructName, argument.name) else: raise CompilationException( True, "Unexpected action argument {0}", argument) def widthInBits(self): return self.width bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfConditional.py000066400000000000000000000101571305314114400254670ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import p4_conditional_node, p4_expression from p4_hlir.hlir import p4_header_instance, p4_field from programSerializer import ProgramSerializer from compilationException import CompilationException import ebpfProgram import ebpfInstance class EbpfConditional(object): @staticmethod def translate(op): if op == "not": return "!" elif op == "or": return "||" elif op == "and": return "&&" return op def __init__(self, p4conditional, program): assert isinstance(p4conditional, p4_conditional_node) assert isinstance(program, ebpfProgram.EbpfProgram) self.hlirconditional = p4conditional self.name = p4conditional.name def emitNode(self, node, serializer, program): if isinstance(node, p4_expression): self.emitExpression(node, serializer, program, False) elif node is None: pass elif isinstance(node, int): serializer.append(node) elif isinstance(node, p4_header_instance): header = program.getInstance(node.name) assert isinstance(header, ebpfInstance.EbpfHeader) # TODO: stacks? serializer.appendFormat( "{0}.{1}", program.headerStructName, header.name) elif isinstance(node, p4_field): instance = node.instance einstance = program.getInstance(instance.name) if isinstance(einstance, ebpfInstance.EbpfHeader): base = program.headerStructName else: base = program.metadataStructName serializer.appendFormat( "{0}.{1}.{2}", base, einstance.name, node.name) else: raise CompilationException(True, "{0} Unexpected expression ", node) def emitExpression(self, expression, serializer, program, toplevel): assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) assert isinstance(expression, p4_expression) assert isinstance(toplevel, bool) left = expression.left op = expression.op right = expression.right assert isinstance(op, str) if op == "valid": self.emitNode(right, serializer, program) serializer.append(".valid") return if not toplevel: serializer.append("(") self.emitNode(left, serializer, program) op = EbpfConditional.translate(op) serializer.append(op) self.emitNode(right, serializer, program) if not toplevel: serializer.append(")") def generateCode(self, serializer, program, nextNode): assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) serializer.emitIndent() serializer.blockStart() trueBranch = self.hlirconditional.next_[True] if trueBranch is None: trueBranch = nextNode falseBranch = self.hlirconditional.next_[False] if falseBranch is None: falseBranch = nextNode serializer.emitIndent() serializer.appendFormat("{0}:", program.getLabel(self.hlirconditional)) serializer.newline() serializer.emitIndent() serializer.append("if (") self.emitExpression( self.hlirconditional.condition, serializer, program, True) serializer.appendLine(")") serializer.increaseIndent() label = program.getLabel(trueBranch) serializer.emitIndent() serializer.appendFormat("goto {0};", label) serializer.newline() serializer.decreaseIndent() serializer.emitIndent() serializer.appendLine("else") serializer.increaseIndent() label = program.getLabel(falseBranch) serializer.emitIndent() serializer.appendFormat("goto {0};", label) serializer.newline() serializer.decreaseIndent() serializer.blockEnd(True) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfCounter.py000066400000000000000000000102101305314114400246310ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import p4_counter, P4_DIRECT, P4_COUNTER_BYTES from programSerializer import ProgramSerializer from compilationException import * import ebpfTable import ebpfProgram class EbpfCounter(object): # noinspection PyUnresolvedReferences def __init__(self, hlircounter, program): assert isinstance(hlircounter, p4_counter) assert isinstance(program, ebpfProgram.EbpfProgram) self.name = hlircounter.name self.hlircounter = hlircounter width = hlircounter.min_width # ebpf counters only work on 64-bits if width <= 64: self.valueTypeName = program.config.uprefix + "64" else: raise NotSupportedException( "{0}: Counters with {1} bits", hlircounter, width) self.dataMapName = self.name if ((hlircounter.binding is None) or (hlircounter.binding[0] != P4_DIRECT)): raise NotSupportedException( "{0}: counter which is not direct", hlircounter) self.autoIncrement = (hlircounter.binding != None and hlircounter.binding[0] == P4_DIRECT) if hlircounter.type is P4_COUNTER_BYTES: self.increment = "{0}->len".format(program.packetName) else: self.increment = "1" def getSize(self, program): if self.hlircounter.instance_count is not None: return self.hlircounter.instance_count if self.autoIncrement: return self.getTable(program).size program.emitWarning( "{0} does not specify a max_size; using 1024", self.hlircounter) return 1024 def getTable(self, program): table = program.getTable(self.hlircounter.binding[1].name) assert isinstance(table, ebpfTable.EbpfTable) return table def serialize(self, serializer, program): assert isinstance(serializer, ProgramSerializer) # Direct counters have the same key as the associated table # Static counters have integer keys if self.autoIncrement: keyTypeName = "struct " + self.getTable(program).keyTypeName else: keyTypeName = program.config.uprefix + "32" program.config.serializeTableDeclaration( serializer, self.dataMapName, True, keyTypeName, self.valueTypeName, self.getSize(program)) def serializeCode(self, keyname, serializer, program): assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) serializer.emitIndent() serializer.appendFormat("/* Update counter {0} */", self.name) serializer.newline() valueName = "ctrvalue" initValuename = "init_val" serializer.emitIndent() serializer.appendFormat("{0} *{1};", self.valueTypeName, valueName) serializer.newline() serializer.emitIndent() serializer.appendFormat("{0} {1};", self.valueTypeName, initValuename) serializer.newline() serializer.emitIndent() serializer.appendLine("/* perform lookup */") serializer.emitIndent() program.config.serializeLookup( serializer, self.dataMapName, keyname, valueName) serializer.newline() serializer.emitIndent() serializer.appendFormat("if ({0} != NULL) ", valueName) serializer.newline() serializer.increaseIndent() serializer.emitIndent() serializer.appendFormat("__sync_fetch_and_add({0}, {1});", valueName, self.increment) serializer.newline() serializer.decreaseIndent() serializer.emitIndent() serializer.append("else ") serializer.blockStart() serializer.emitIndent() serializer.appendFormat("{0} = {1};", initValuename, self.increment) serializer.newline() serializer.emitIndent() program.config.serializeUpdate( serializer, self.dataMapName, keyname, initValuename) serializer.newline() serializer.blockEnd(True) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfDeparser.py000066400000000000000000000147511305314114400247750ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from collections import defaultdict, OrderedDict from p4_hlir.hlir import parse_call, p4_field, p4_parse_value_set, \ P4_DEFAULT, p4_parse_state, p4_table, \ p4_conditional_node, p4_parser_exception, \ p4_header_instance, P4_NEXT import ebpfProgram import ebpfInstance import ebpfType import ebpfStructType from topoSorting import Graph from programSerializer import ProgramSerializer def produce_parser_topo_sorting(hlir): # This function is copied from the P4 behavioral model implementation header_graph = Graph() def walk_rec(hlir, parse_state, prev_hdr_node, tag_stacks_index): assert(isinstance(parse_state, p4_parse_state)) for call in parse_state.call_sequence: call_type = call[0] if call_type == parse_call.extract: hdr = call[1] if hdr.virtual: base_name = hdr.base_name current_index = tag_stacks_index[base_name] if current_index > hdr.max_index: return tag_stacks_index[base_name] += 1 name = base_name + "[%d]" % current_index hdr = hlir.p4_header_instances[name] if hdr not in header_graph: header_graph.add_node(hdr) hdr_node = header_graph.get_node(hdr) if prev_hdr_node: prev_hdr_node.add_edge_to(hdr_node) else: header_graph.root = hdr prev_hdr_node = hdr_node for branch_case, next_state in parse_state.branch_to.items(): if not next_state: continue if not isinstance(next_state, p4_parse_state): continue walk_rec(hlir, next_state, prev_hdr_node, tag_stacks_index.copy()) start_state = hlir.p4_parse_states["start"] walk_rec(hlir, start_state, None, defaultdict(int)) header_topo_sorting = header_graph.produce_topo_sorting() return header_topo_sorting class EbpfDeparser(object): def __init__(self, hlir): header_topo_sorting = produce_parser_topo_sorting(hlir) self.headerOrder = [hdr.name for hdr in header_topo_sorting] def serialize(self, serializer, program): assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) serializer.emitIndent() serializer.blockStart() serializer.emitIndent() serializer.appendLine("/* Deparser */") serializer.emitIndent() serializer.appendFormat("{0} = 0;", program.offsetVariableName) serializer.newline() for h in self.headerOrder: header = program.getHeaderInstance(h) self.serializeHeaderEmit(header, serializer, program) serializer.blockEnd(True) def serializeHeaderEmit(self, header, serializer, program): assert isinstance(header, ebpfInstance.EbpfHeader) assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) p4header = header.hlirInstance assert isinstance(p4header, p4_header_instance) serializer.emitIndent() serializer.appendFormat("if ({0}.{1}.valid) ", program.headerStructName, header.name) serializer.blockStart() if ebpfProgram.EbpfProgram.isArrayElementInstance(p4header): ebpfStack = program.getStackInstance(p4header.base_name) assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack) if isinstance(p4header.index, int): index = "[" + str(headerInstance.index) + "]" elif p4header.index is P4_NEXT: index = "[" + ebpfStack.indexVar + "]" else: raise CompilationException( True, "Unexpected index for array {0}", p4header.index) basetype = ebpfStack.basetype else: ebpfHeader = program.getHeaderInstance(p4header.name) basetype = ebpfHeader.type index = "" alignment = 0 for field in basetype.fields: assert isinstance(field, ebpfStructType.EbpfField) self.serializeFieldEmit(serializer, p4header.base_name, index, field, alignment, program) alignment += field.widthInBits() alignment = alignment % 8 serializer.blockEnd(True) def serializeFieldEmit(self, serializer, name, index, field, alignment, program): assert isinstance(index, str) assert isinstance(name, str) assert isinstance(field, ebpfStructType.EbpfField) assert isinstance(serializer, ProgramSerializer) assert isinstance(alignment, int) assert isinstance(program, ebpfProgram.EbpfProgram) if field.name == "valid": return fieldToEmit = (program.headerStructName + "." + name + index + "." + field.name) width = field.widthInBits() if width <= 32: store = self.generatePacketStore(fieldToEmit, 0, alignment, width, program) serializer.emitIndent() serializer.appendLine(store) else: # Destination is bigger than 4 bytes and # represented as a byte array. b = (width + 7) / 8 for i in range(0, b): serializer.emitIndent() store = self.generatePacketStore(fieldToEmit + "["+str(i)+"]", i, alignment, 8, program) serializer.appendLine(store) serializer.emitIndent() serializer.appendFormat("{0} += {1};", program.offsetVariableName, width) serializer.newline() def generatePacketStore(self, value, offset, alignment, width, program): assert width > 0 assert alignment < 8 assert isinstance(width, int) assert isinstance(alignment, int) return "bpf_dins_pkt({0}, {1} / 8 + {2}, {3}, {4}, {5});".format( program.packetName, program.offsetVariableName, offset, alignment, width, value ) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfInstance.py000066400000000000000000000066401305314114400247720ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import p4_header_instance from ebpfType import EbpfType from compilationException import CompilationException from programSerializer import ProgramSerializer import typeFactory class EbpfInstanceBase(object): def __init__(self): pass class SimpleInstance(EbpfInstanceBase): # A header or a metadata instance (but not array elements) def __init__(self, hlirInstance, factory, isMetadata): super(SimpleInstance, self).__init__() self.hlirInstance = hlirInstance self.name = hlirInstance.base_name self.type = factory.build(hlirInstance.header_type, isMetadata) def declare(self, serializer): assert isinstance(serializer, ProgramSerializer) self.type.declare(serializer, self.name, False) class EbpfHeader(SimpleInstance): """ Represents a header instance from a P4 program """ def __init__(self, hlirHeaderInstance, factory): super(EbpfHeader, self).__init__(hlirHeaderInstance, factory, False) if hlirHeaderInstance.metadata: raise CompilationException(True, "Metadata passed to EpbfHeader") if hlirHeaderInstance.index is not None: self.name += "_" + str(hlirHeaderInstance.index) class EbpfMetadata(SimpleInstance): """Represents a metadata instance from a P4 program""" def __init__(self, hlirMetadataInstance, factory): super(EbpfMetadata, self).__init__(hlirMetadataInstance, factory, True) if not hlirMetadataInstance.metadata: raise CompilationException( True, "Header instance passed to EpbfMetadata {0}", hlirMetadataInstance) if hlirMetadataInstance.index is not None: raise CompilationException( True, "Unexpected metadata array {0}", self.hlirInstance) if hasattr(hlirMetadataInstance, "initializer"): self.initializer = hlirMetadataInstance.initializer else: self.initializer = None def emitInitializer(self, serializer): assert isinstance(serializer, ProgramSerializer) if self.initializer is None: self.type.emitInitializer(serializer) else: for key in self.initializer.keys(): serializer.appendFormat( ".{0} = {1},", key, self.initializer[key]) class EbpfHeaderStack(EbpfInstanceBase): """Represents a header stack instance; there is one instance of this class for each STACK, and not for each element of the stack, as in the HLIR""" def __init__(self, hlirInstance, indexVar, factory): super(EbpfHeaderStack, self).__init__() # indexVar: name of the ebpf variable that # holds the current index for this stack assert isinstance(indexVar, str) assert isinstance(factory, typeFactory.EbpfTypeFactory) assert isinstance(hlirInstance, p4_header_instance) self.indexVar = indexVar self.name = hlirInstance.base_name self.basetype = factory.build(hlirInstance.header_type, False) assert isinstance(self.basetype, EbpfType) self.arraySize = hlirInstance.max_index + 1 self.hlirInstance = hlirInstance def declare(self, serializer): assert isinstance(serializer, ProgramSerializer) self.basetype.declareArray(serializer, self.name, self.arraySize) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfParser.py000066400000000000000000000427041305314114400244630ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import parse_call, p4_field, p4_parse_value_set, \ P4_DEFAULT, p4_parse_state, p4_table, \ p4_conditional_node, p4_parser_exception, \ p4_header_instance, P4_NEXT import ebpfProgram import ebpfStructType import ebpfInstance import programSerializer from compilationException import * class EbpfParser(object): def __init__(self, hlirParser): # hlirParser is a P4 parser self.parser = hlirParser self.name = hlirParser.name def serialize(self, serializer, program): assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) serializer.emitIndent() serializer.appendFormat("{0}: ", self.name) serializer.blockStart() for op in self.parser.call_sequence: self.serializeOperation(serializer, op, program) self.serializeBranch(serializer, self.parser.branch_on, self.parser.branch_to, program) serializer.blockEnd(True) def serializeSelect(self, selectVarName, serializer, branch_on, program): # selectVarName - name of temp variable to use for the select expression assert isinstance(selectVarName, str) assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) totalWidth = 0 switchValue = "" for e in branch_on: if isinstance(e, p4_field): instance = e.instance assert isinstance(instance, p4_header_instance) index = "" if ebpfProgram.EbpfProgram.isArrayElementInstance(instance): ebpfStack = program.getStackInstance(instance.base_name) assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack) if isinstance(instance.index, int): index = "[" + str(instance.index) + "]" elif instance.index is P4_NEXT: index = "[" + ebpfStack.indexVar + "]" else: raise CompilationException(True, "Unexpected index for array {0}", instance.index) basetype = ebpfStack.basetype name = ebpfStack.name else: ebpfHeader = program.getInstance(instance.name) assert isinstance(ebpfHeader, ebpfInstance.EbpfHeader) basetype = ebpfHeader.type name = ebpfHeader.name ebpfField = basetype.getField(e.name) assert isinstance(ebpfField, ebpfStructType.EbpfField) totalWidth += ebpfField.widthInBits() fieldReference = (program.headerStructName + "." + name + index + "." + ebpfField.name) if switchValue == "": switchValue = fieldReference else: switchValue = ("(" + switchValue + " << " + str(ebpfField.widthInBits()) + ")") switchValue = switchValue + " | " + fieldReference elif isinstance(e, tuple): switchValue = self.currentReferenceAsString(e, program) else: raise CompilationException( True, "Unexpected element in match {0}", e) if totalWidth > 32: raise NotSupportedException("{0}: Matching on {1}-bit value", branch_on, totalWidth) serializer.emitIndent() serializer.appendFormat("{0}32 {1} = {2};", program.config.uprefix, selectVarName, switchValue) serializer.newline() def generatePacketLoad(self, startBit, width, alignment, program): # Generates an expression that does a load_*, shift and mask # to load 'width' bits starting at startBit from the current # packet offset. # alignment is an integer <= 8 that holds the current alignment # of of the packet offset. assert width > 0 assert alignment < 8 assert isinstance(startBit, int) assert isinstance(width, int) assert isinstance(alignment, int) firstBitIndex = startBit + alignment lastBitIndex = startBit + width + alignment - 1 firstWordIndex = firstBitIndex / 8 lastWordIndex = lastBitIndex / 8 wordsToRead = lastWordIndex - firstWordIndex + 1 if wordsToRead == 1: load = "load_byte" loadSize = 8 elif wordsToRead == 2: load = "load_half" loadSize = 16 elif wordsToRead <= 4: load = "load_word" loadSize = 32 elif wordsToRead <= 8: load = "load_dword" loadSize = 64 else: raise CompilationException(True, "Attempt to load more than 1 word") readtype = program.config.uprefix + str(loadSize) loadInstruction = "{0}({1}, ({2} + {3}) / 8)".format( load, program.packetName, program.offsetVariableName, startBit) shift = loadSize - alignment - width load = "(({0}) >> ({1}))".format(loadInstruction, shift) if width != loadSize: mask = " & EBPF_MASK({0}, {1})".format(readtype, width) else: mask = "" return load + mask def currentReferenceAsString(self, tpl, program): # a string describing an expression of the form current(position, width) # The assumption is that at this point the packet cursor is ALWAYS # byte aligned. This should be true because headers are supposed # to have sizes an integral number of bytes. assert isinstance(tpl, tuple) if len(tpl) != 2: raise CompilationException( True, "{0} Expected a tuple with 2 elements", tpl) minIndex = tpl[0] totalWidth = tpl[1] result = self.generatePacketLoad( minIndex, totalWidth, 0, program) # alignment is 0 return result def serializeCases(self, selectVarName, serializer, branch_to, program): assert isinstance(selectVarName, str) assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) branches = 0 seenDefault = False for e in branch_to.keys(): serializer.emitIndent() value = branch_to[e] if isinstance(e, int): serializer.appendFormat("if ({0} == {1})", selectVarName, e) elif isinstance(e, tuple): serializer.appendFormat( "if (({0} & {1}) == {2})", selectVarName, e[0], e[1]) elif isinstance(e, p4_parse_value_set): raise NotSupportedException("{0}: Parser value sets", e) elif e is P4_DEFAULT: seenDefault = True if branches > 0: serializer.append("else") else: raise CompilationException( True, "Unexpected element in match case {0}", e) branches += 1 serializer.newline() serializer.increaseIndent() serializer.emitIndent() label = program.getLabel(value) if isinstance(value, p4_parse_state): serializer.appendFormat("goto {0};", label) elif isinstance(value, p4_table): serializer.appendFormat("goto {0};", label) elif isinstance(value, p4_conditional_node): serializer.appendFormat("goto {0};", label) elif isinstance(value, p4_parser_exception): raise CompilationException(True, "Not yet implemented") else: raise CompilationException( True, "Unexpected element in match case {0}", value) serializer.decreaseIndent() serializer.newline() # Must create default if it is missing if not seenDefault: serializer.emitIndent() serializer.appendFormat( "{0} = p4_pe_unhandled_select;", program.errorName) serializer.newline() serializer.emitIndent() serializer.appendFormat("default: goto end;") serializer.newline() def serializeBranch(self, serializer, branch_on, branch_to, program): assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) if branch_on == []: dest = branch_to.values()[0] serializer.emitIndent() name = program.getLabel(dest) serializer.appendFormat("goto {0};", name) serializer.newline() elif isinstance(branch_on, list): tmpvar = program.generateNewName("tmp") self.serializeSelect(tmpvar, serializer, branch_on, program) self.serializeCases(tmpvar, serializer, branch_to, program) else: raise CompilationException( True, "Unexpected branch_on {0}", branch_on) def serializeOperation(self, serializer, op, program): assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) operation = op[0] if operation is parse_call.extract: self.serializeExtract(serializer, op[1], program) elif operation is parse_call.set: self.serializeMetadataSet(serializer, op[1], op[2], program) else: raise CompilationException( True, "Unexpected operation in parser {0}", op) def serializeFieldExtract(self, serializer, headerInstanceName, index, field, alignment, program): assert isinstance(index, str) assert isinstance(headerInstanceName, str) assert isinstance(field, ebpfStructType.EbpfField) assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(alignment, int) assert isinstance(program, ebpfProgram.EbpfProgram) fieldToExtractTo = headerInstanceName + index + "." + field.name serializer.emitIndent() width = field.widthInBits() if field.name == "valid": serializer.appendFormat( "{0}.{1} = 1;", program.headerStructName, fieldToExtractTo) serializer.newline() return serializer.appendFormat("if ({0}->len < BYTES({1} + {2})) ", program.packetName, program.offsetVariableName, width) serializer.blockStart() serializer.emitIndent() serializer.appendFormat("{0} = p4_pe_header_too_short;", program.errorName) serializer.newline() serializer.emitIndent() serializer.appendLine("goto end;") # TODO: jump to correct exception handler serializer.blockEnd(True) if width <= 32: serializer.emitIndent() load = self.generatePacketLoad(0, width, alignment, program) serializer.appendFormat("{0}.{1} = {2};", program.headerStructName, fieldToExtractTo, load) serializer.newline() else: # Destination is bigger than 4 bytes and # represented as a byte array. if alignment == 0: shift = 0 else: shift = 8 - alignment assert shift >= 0 if shift == 0: method = "load_byte" else: method = "load_half" b = (width + 7) / 8 for i in range(0, b): serializer.emitIndent() serializer.appendFormat("{0}.{1}[{2}] = ({3}8)", program.headerStructName, fieldToExtractTo, i, program.config.uprefix) serializer.appendFormat("(({0}({1}, ({2} / 8) + {3}) >> {4})", method, program.packetName, program.offsetVariableName, i, shift) if (i == b - 1) and (width % 8 != 0): serializer.appendFormat(" & EBPF_MASK({0}8, {1})", program.config.uprefix, width % 8) serializer.append(")") serializer.endOfStatement(True) serializer.emitIndent() serializer.appendFormat("{0} += {1};", program.offsetVariableName, width) serializer.newline() def serializeExtract(self, serializer, headerInstance, program): assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(headerInstance, p4_header_instance) assert isinstance(program, ebpfProgram.EbpfProgram) if ebpfProgram.EbpfProgram.isArrayElementInstance(headerInstance): ebpfStack = program.getStackInstance(headerInstance.base_name) assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack) # write bounds check serializer.emitIndent() serializer.appendFormat("if ({0} >= {1}) ", ebpfStack.indexVar, ebpfStack.arraySize) serializer.blockStart() serializer.emitIndent() serializer.appendFormat("{0} = p4_pe_index_out_of_bounds;", program.errorName) serializer.newline() serializer.emitIndent() serializer.appendLine("goto end;") serializer.blockEnd(True) if isinstance(headerInstance.index, int): index = "[" + str(headerInstance.index) + "]" elif headerInstance.index is P4_NEXT: index = "[" + ebpfStack.indexVar + "]" else: raise CompilationException( True, "Unexpected index for array {0}", headerInstance.index) basetype = ebpfStack.basetype else: ebpfHeader = program.getHeaderInstance(headerInstance.name) basetype = ebpfHeader.type index = "" # extract all fields alignment = 0 for field in basetype.fields: assert isinstance(field, ebpfStructType.EbpfField) self.serializeFieldExtract(serializer, headerInstance.base_name, index, field, alignment, program) alignment += field.widthInBits() alignment = alignment % 8 if ebpfProgram.EbpfProgram.isArrayElementInstance(headerInstance): # increment stack index ebpfStack = program.getStackInstance(headerInstance.base_name) assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack) # write bounds check serializer.emitIndent() serializer.appendFormat("{0}++;", ebpfStack.indexVar) serializer.newline() def serializeMetadataSet(self, serializer, field, value, program): assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) assert isinstance(field, p4_field) dest = program.getInstance(field.instance.name) assert isinstance(dest, ebpfInstance.SimpleInstance) destType = dest.type assert isinstance(destType, ebpfStructType.EbpfStructType) destField = destType.getField(field.name) if destField.widthInBits() > 32: useMemcpy = True bytesToCopy = destField.widthInBits() / 8 if destField.widthInBits() % 8 != 0: raise CompilationException( True, "{0}: Not implemented: wide field w. sz not multiple of 8", field) else: useMemcpy = False bytesToCopy = None # not needed, but compiler is confused serializer.emitIndent() destination = "{0}.{1}.{2}".format( program.metadataStructName, dest.name, destField.name) if isinstance(value, int): source = str(value) if useMemcpy: raise CompilationException( True, "{0}: Not implemented: copying from wide constant", value) elif isinstance(value, tuple): source = self.currentReferenceAsString(value, program) elif isinstance(value, p4_field): source = program.getInstance(value.instance.name) if isinstance(source, ebpfInstance.EbpfMetadata): sourceStruct = program.metadataStructName else: sourceStruct = program.headerStructName source = "{0}.{1}.{2}".format(sourceStruct, source.name, value.name) else: raise CompilationException( True, "Unexpected type for parse_call.set {0}", value) if useMemcpy: serializer.appendFormat("memcpy(&{0}, &{1}, {2})", destination, source, bytesToCopy) else: serializer.appendFormat("{0} = {1}", destination, source) serializer.endOfStatement(True) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfProgram.py000066400000000000000000000436311305314114400246360ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import p4_header_instance, p4_table, \ p4_conditional_node, p4_action, p4_parse_state from p4_hlir.main import HLIR import typeFactory import ebpfTable import ebpfParser import ebpfAction import ebpfInstance import ebpfConditional import ebpfCounter import ebpfDeparser import programSerializer import target from compilationException import * class EbpfProgram(object): def __init__(self, name, hlir, isRouter, config): """Representation of an EbpfProgram (in fact, a C program that is converted to EBPF)""" assert isinstance(hlir, HLIR) assert isinstance(isRouter, bool) assert isinstance(config, target.TargetConfig) self.hlir = hlir self.name = name self.uniqueNameCounter = 0 self.config = config self.isRouter = isRouter self.reservedPrefix = "ebpf_" assert isinstance(config, target.TargetConfig) self.packetName = self.reservedPrefix + "packet" self.dropBit = self.reservedPrefix + "drop" self.license = "GPL" self.offsetVariableName = self.reservedPrefix + "packetOffsetInBits" self.zeroKeyName = self.reservedPrefix + "zero" self.arrayIndexType = self.config.uprefix + "32" # all array tables must be indexed with u32 values self.errorName = self.reservedPrefix + "error" self.functionName = self.reservedPrefix + "filter" self.egressPortName = "egress_port" # Hardwired in P4 definition self.typeFactory = typeFactory.EbpfTypeFactory(config) self.errorCodes = [ "p4_pe_no_error", "p4_pe_index_out_of_bounds", "p4_pe_out_of_packet", "p4_pe_header_too_long", "p4_pe_header_too_short", "p4_pe_unhandled_select", "p4_pe_checksum"] self.actions = [] self.conditionals = [] self.tables = [] self.headers = [] # header instances self.metadata = [] # metadata instances self.stacks = [] # header stack instances EbpfHeaderStack self.parsers = [] # all parsers self.deparser = None self.entryPoints = [] # control-flow entry points from parser self.counters = [] self.entryPointLabels = {} # maps p4_node from entryPoints # to labels in the C program self.egressEntry = None self.construct() self.headersStructTypeName = self.reservedPrefix + "headers_t" self.headerStructName = self.reservedPrefix + "headers" self.metadataStructTypeName = self.reservedPrefix + "metadata_t" self.metadataStructName = self.reservedPrefix + "metadata" def construct(self): if len(self.hlir.p4_field_list_calculations) > 0: raise NotSupportedException( "{0} calculated field", self.hlir.p4_field_list_calculations.values()[0].name) for h in self.hlir.p4_header_instances.values(): if h.max_index is not None: assert isinstance(h, p4_header_instance) if h.index == 0: # header stack; allocate only for zero-th index indexVarName = self.generateNewName(h.base_name + "_index") stack = ebpfInstance.EbpfHeaderStack( h, indexVarName, self.typeFactory) self.stacks.append(stack) elif h.metadata: metadata = ebpfInstance.EbpfMetadata(h, self.typeFactory) self.metadata.append(metadata) else: header = ebpfInstance.EbpfHeader(h, self.typeFactory) self.headers.append(header) for p in self.hlir.p4_parse_states.values(): parser = ebpfParser.EbpfParser(p) self.parsers.append(parser) for a in self.hlir.p4_actions.values(): if self.isInternalAction(a): continue action = ebpfAction.EbpfAction(a, self) self.actions.append(action) for c in self.hlir.p4_counters.values(): counter = ebpfCounter.EbpfCounter(c, self) self.counters.append(counter) for t in self.hlir.p4_tables.values(): table = ebpfTable.EbpfTable(t, self, self.config) self.tables.append(table) for n in self.hlir.p4_ingress_ptr.keys(): self.entryPoints.append(n) for n in self.hlir.p4_conditional_nodes.values(): conditional = ebpfConditional.EbpfConditional(n, self) self.conditionals.append(conditional) self.egressEntry = self.hlir.p4_egress_ptr self.deparser = ebpfDeparser.EbpfDeparser(self.hlir) def isInternalAction(self, action): # This is a heuristic really to guess which actions are built-in # Unfortunately there seems to be no other way to do this return action.lineno < 0 @staticmethod def isArrayElementInstance(headerInstance): assert isinstance(headerInstance, p4_header_instance) return headerInstance.max_index is not None def emitWarning(self, formatString, *message): assert isinstance(formatString, str) print("WARNING: ", formatString.format(*message)) def toC(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) self.generateIncludes(serializer) self.generatePreamble(serializer) self.generateTypes(serializer) self.generateTables(serializer) serializer.newline() serializer.emitIndent() self.config.serializeCodeSection(serializer) serializer.newline() serializer.emitIndent() serializer.appendFormat("int {0}(struct __sk_buff* {1}) ", self.functionName, self.packetName) serializer.blockStart() self.generateHeaderInstance(serializer) serializer.append(" = ") self.generateInitializeHeaders(serializer) serializer.endOfStatement(True) self.generateMetadataInstance(serializer) serializer.append(" = ") self.generateInitializeMetadata(serializer) serializer.endOfStatement(True) self.createLocalVariables(serializer) serializer.newline() serializer.emitIndent() serializer.appendLine("goto start;") self.generateParser(serializer) self.generatePipeline(serializer) self.generateDeparser(serializer) serializer.emitIndent() serializer.appendLine("end:") serializer.emitIndent() if isinstance(self.config, target.KernelSamplesConfig): serializer.appendFormat("return {0};", self.dropBit) serializer.newline() elif isinstance(self.config, target.BccConfig): if self.isRouter: serializer.appendFormat("if (!{0})", self.dropBit) serializer.newline() serializer.increaseIndent() serializer.emitIndent() serializer.appendFormat( "bpf_clone_redirect({0}, {1}.standard_metadata.{2}, 0);", self.packetName, self.metadataStructName, self.egressPortName) serializer.newline() serializer.decreaseIndent() serializer.emitIndent() serializer.appendLine( "return TC_ACT_SHOT /* drop packet; clone is forwarded */;") else: serializer.appendFormat( "return {1} ? TC_ACT_SHOT : TC_ACT_PIPE;", self.dropBit) serializer.newline() else: raise CompilationException( True, "Unexpected target configuration {0}", self.config.targetName) serializer.blockEnd(True) self.generateLicense(serializer) serializer.append(self.config.postamble) def generateLicense(self, serializer): self.config.serializeLicense(serializer, self.license) # noinspection PyMethodMayBeStatic def generateIncludes(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) serializer.append(self.config.getIncludes()) def getLabel(self, p4node): # C label that corresponds to this point in the control-flow if p4node is None: return "end" elif isinstance(p4node, p4_parse_state): label = p4node.name self.entryPointLabels[p4node.name] = label if p4node.name not in self.entryPointLabels: label = self.generateNewName(p4node.name) self.entryPointLabels[p4node.name] = label return self.entryPointLabels[p4node.name] # noinspection PyMethodMayBeStatic def generatePreamble(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) serializer.emitIndent() serializer.append("enum ErrorCode ") serializer.blockStart() for error in self.errorCodes: serializer.emitIndent() serializer.appendFormat("{0},", error) serializer.newline() serializer.blockEnd(False) serializer.endOfStatement(True) serializer.newline() serializer.appendLine( "#define EBPF_MASK(t, w) ((((t)(1)) << (w)) - (t)1)") serializer.appendLine("#define BYTES(w) ((w + 7) / 8)") self.config.generateDword(serializer) # noinspection PyMethodMayBeStatic def generateNewName(self, base): # base is a string """Generates a fresh name based on the specified base name""" # TODO: this should be made "safer" assert isinstance(base, str) base += "_" + str(self.uniqueNameCounter) self.uniqueNameCounter += 1 return base def generateTypes(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) for t in self.typeFactory.type_map.values(): t.serialize(serializer) # generate a new struct type for the packet itself serializer.appendFormat("struct {0} ", self.headersStructTypeName) serializer.blockStart() for h in self.headers: serializer.emitIndent() h.declare(serializer) serializer.endOfStatement(True) for h in self.stacks: assert isinstance(h, ebpfInstance.EbpfHeaderStack) serializer.emitIndent() h.declare(serializer) serializer.endOfStatement(True) serializer.blockEnd(False) serializer.endOfStatement(True) # generate a new struct type for the metadata serializer.appendFormat("struct {0} ", self.metadataStructTypeName) serializer.blockStart() for h in self.metadata: assert isinstance(h, ebpfInstance.EbpfMetadata) serializer.emitIndent() h.declare(serializer) serializer.endOfStatement(True) serializer.blockEnd(False) serializer.endOfStatement(True) def generateTables(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) for t in self.tables: t.serialize(serializer, self) for c in self.counters: c.serialize(serializer, self) def generateHeaderInstance(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) serializer.emitIndent() serializer.appendFormat( "struct {0} {1}", self.headersStructTypeName, self.headerStructName) def generateInitializeHeaders(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) serializer.blockStart() for h in self.headers: serializer.emitIndent() serializer.appendFormat(".{0} = ", h.name) h.type.emitInitializer(serializer) serializer.appendLine(",") serializer.blockEnd(False) def generateMetadataInstance(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) serializer.emitIndent() serializer.appendFormat( "struct {0} {1}", self.metadataStructTypeName, self.metadataStructName) def generateDeparser(self, serializer): self.deparser.serialize(serializer, self) def generateInitializeMetadata(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) serializer.blockStart() for h in self.metadata: serializer.emitIndent() serializer.appendFormat(".{0} = ", h.name) h.emitInitializer(serializer) serializer.appendLine(",") serializer.blockEnd(False) def createLocalVariables(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) serializer.emitIndent() serializer.appendFormat("unsigned {0} = 0;", self.offsetVariableName) serializer.newline() serializer.emitIndent() serializer.appendFormat( "enum ErrorCode {0} = p4_pe_no_error;", self.errorName) serializer.newline() serializer.emitIndent() serializer.appendFormat( "{0}8 {1} = 0;", self.config.uprefix, self.dropBit) serializer.newline() serializer.emitIndent() serializer.appendFormat( "{0} {1} = 0;", self.arrayIndexType, self.zeroKeyName) serializer.newline() for h in self.stacks: serializer.emitIndent() serializer.appendFormat( "{0}8 {0} = 0;", self.config.uprefix, h.indexVar) serializer.newline() def getStackInstance(self, name): assert isinstance(name, str) for h in self.stacks: if h.name == name: assert isinstance(h, ebpfInstance.EbpfHeaderStack) return h raise CompilationException( True, "Could not locate header stack named {0}", name) def getHeaderInstance(self, name): assert isinstance(name, str) for h in self.headers: if h.name == name: assert isinstance(h, ebpfInstance.EbpfHeader) return h raise CompilationException( True, "Could not locate header instance named {0}", name) def getInstance(self, name): assert isinstance(name, str) for h in self.headers: if h.name == name: return h for h in self.metadata: if h.name == name: return h raise CompilationException( True, "Could not locate instance named {0}", name) def getAction(self, p4action): assert isinstance(p4action, p4_action) for a in self.actions: if a.name == p4action.name: return a newAction = ebpfAction.BuiltinAction(p4action) self.actions.append(newAction) return newAction def getTable(self, name): assert isinstance(name, str) for t in self.tables: if t.name == name: return t raise CompilationException( True, "Could not locate table named {0}", name) def getCounter(self, name): assert isinstance(name, str) for t in self.counters: if t.name == name: return t raise CompilationException( True, "Could not locate counters named {0}", name) def getConditional(self, name): assert isinstance(name, str) for c in self.conditionals: if c.name == name: return c raise CompilationException( True, "Could not locate conditional named {0}", name) def generateParser(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) for p in self.parsers: p.serialize(serializer, self) def generateIngressPipeline(self, serializer): assert isinstance(serializer, programSerializer.ProgramSerializer) for t in self.tables: assert isinstance(t, ebpfTable.EbpfTable) serializer.emitIndent() serializer.appendFormat("{0}:", t.name) serializer.newline() def generateControlFlowNode(self, serializer, node, nextEntryPoint): # nextEntryPoint is used as a target whenever the target is None # nextEntryPoint may also be None if isinstance(node, p4_table): table = self.getTable(node.name) assert isinstance(table, ebpfTable.EbpfTable) table.serializeCode(serializer, self, nextEntryPoint) elif isinstance(node, p4_conditional_node): conditional = self.getConditional(node.name) assert isinstance(conditional, ebpfConditional.EbpfConditional) conditional.generateCode(serializer, self, nextEntryPoint) else: raise CompilationException( True, "{0} Unexpected control flow node ", node) def generatePipelineInternal(self, serializer, nodestoadd, nextEntryPoint): assert isinstance(serializer, programSerializer.ProgramSerializer) assert isinstance(nodestoadd, set) done = set() while len(nodestoadd) > 0: todo = nodestoadd.pop() if todo in done: continue if todo is None: continue print("Generating ", todo.name) done.add(todo) self.generateControlFlowNode(serializer, todo, nextEntryPoint) for n in todo.next_.values(): nodestoadd.add(n) def generatePipeline(self, serializer): todo = set() for e in self.entryPoints: todo.add(e) self.generatePipelineInternal(serializer, todo, self.egressEntry) todo = set() todo.add(self.egressEntry) self.generatePipelineInternal(serializer, todo, None) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfScalarType.py000066400000000000000000000050341305314114400252710ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import P4_AUTO_WIDTH from ebpfType import * from compilationException import * from programSerializer import ProgramSerializer class EbpfScalarType(EbpfType): __doc__ = "Represents a scalar type" def __init__(self, parent, widthInBits, isSigned, config): super(EbpfScalarType, self).__init__(None) assert isinstance(widthInBits, int) assert isinstance(isSigned, bool) self.width = widthInBits self.isSigned = isSigned self.config = config if widthInBits is P4_AUTO_WIDTH: raise NotSupportedException("{0} Variable-width field", parent) def widthInBits(self): return self.width @staticmethod def bytesRequired(width): return (width + 7) / 8 def asString(self): if self.isSigned: prefix = self.config.iprefix else: prefix = self.config.uprefix if self.width <= 8: name = prefix + "8" elif self.width <= 16: name = prefix + "16" elif self.width <= 32: name = prefix + "32" else: name = "char*" return name def alignment(self): if self.width <= 8: return 1 elif self.width <= 16: return 2 elif self.width <= 32: return 4 else: return 1 # Char array def serialize(self, serializer): assert isinstance(serializer, ProgramSerializer) serializer.append(self.asString()) def declareArray(self, serializer, identifier, size): raise CompilationException( True, "Arrays of base type not expected in P4") def declare(self, serializer, identifier, asPointer): assert isinstance(serializer, ProgramSerializer) assert isinstance(asPointer, bool) assert isinstance(identifier, str) if self.width <= 32: self.serialize(serializer) if asPointer: serializer.append("*") serializer.space() serializer.append(identifier) else: if asPointer: serializer.append("char*") else: serializer.appendFormat( "char {0}[{1}]", identifier, EbpfScalarType.bytesRequired(self.width)) def emitInitializer(self, serializer): assert isinstance(serializer, ProgramSerializer) serializer.append("0") bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfStructType.py000066400000000000000000000105121305314114400253450ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import P4_SIGNED, P4_SATURATING from ebpfScalarType import * class EbpfField(object): __doc__ = "represents a field in a struct type, not in an instance" def __init__(self, hlirParentType, name, widthInBits, attributes, config): self.name = name self.width = widthInBits self.hlirType = hlirParentType signed = False if P4_SIGNED in attributes: signed = True if P4_SATURATING in attributes: raise NotSupportedException( "{0}.{1}: Saturated types", self.hlirType, self.name) try: self.type = EbpfScalarType( self.hlirType, widthInBits, signed, config) except CompilationException, e: raise CompilationException( e.isBug, "{0}.{1}: {2}", hlirParentType, self.name, e.show()) def widthInBits(self): return self.width class EbpfStructType(EbpfType): # Abstract base class for HeaderType and MetadataType. # They are both represented by a p4 header_type def __init__(self, hlirHeader, config): super(EbpfStructType, self).__init__(hlirHeader) self.name = hlirHeader.name self.fields = [] for (fieldName, fieldSize) in self.hlirType.layout.items(): attributes = self.hlirType.attributes[fieldName] field = EbpfField( hlirHeader, fieldName, fieldSize, attributes, config) self.fields.append(field) def serialize(self, serializer): assert isinstance(serializer, ProgramSerializer) serializer.emitIndent() serializer.appendFormat("struct {0} ", self.name) serializer.blockStart() for field in self.fields: serializer.emitIndent() field.type.declare(serializer, field.name, False) serializer.appendFormat("; /* {0} bits */", field.widthInBits()) serializer.newline() serializer.blockEnd(False) serializer.endOfStatement(True) def declare(self, serializer, identifier, asPointer): assert isinstance(serializer, ProgramSerializer) assert isinstance(identifier, str) assert isinstance(asPointer, bool) serializer.appendFormat("struct {0} ", self.name) if asPointer: serializer.append("*") serializer.append(identifier) def widthInBits(self): return self.hlirType.length * 8 def getField(self, name): assert isinstance(name, str) for f in self.fields: assert isinstance(f, EbpfField) if f.name == name: return f raise CompilationException( True, "Could not locate field {0}.{1}", self, name) class EbpfHeaderType(EbpfStructType): def __init__(self, hlirHeader, config): super(EbpfHeaderType, self).__init__(hlirHeader, config) validField = EbpfField(hlirHeader, "valid", 1, set(), config) # check that no "valid" field exists already for f in self.fields: if f.name == "valid": raise CompilationException( True, "Header type contains a field named `valid': {0}", f) self.fields.append(validField) def emitInitializer(self, serializer): assert isinstance(serializer, ProgramSerializer) serializer.blockStart() serializer.emitIndent() serializer.appendLine(".valid = 0") serializer.blockEnd(False) def declareArray(self, serializer, identifier, size): assert isinstance(serializer, ProgramSerializer) serializer.appendFormat( "struct {0} {1}[{2}]", self.name, identifier, size) class EbpfMetadataType(EbpfStructType): def __init__(self, hlirHeader, config): super(EbpfMetadataType, self).__init__(hlirHeader, config) def emitInitializer(self, serializer): assert isinstance(serializer, ProgramSerializer) serializer.blockStart() for field in self.fields: serializer.emitIndent() serializer.appendFormat(".{0} = ", field.name) field.type.emitInitializer(serializer) serializer.append(",") serializer.newline() serializer.blockEnd(False) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfTable.py000066400000000000000000000352731305314114400242610ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import p4_match_type, p4_field, p4_table, p4_header_instance from programSerializer import ProgramSerializer from compilationException import * import ebpfProgram import ebpfInstance import ebpfCounter import ebpfStructType import ebpfAction class EbpfTableKeyField(object): def __init__(self, fieldname, instance, field, mask): assert isinstance(instance, ebpfInstance.EbpfInstanceBase) assert isinstance(field, ebpfStructType.EbpfField) self.keyFieldName = fieldname self.instance = instance self.field = field self.mask = mask def serializeType(self, serializer): assert isinstance(serializer, ProgramSerializer) ftype = self.field.type serializer.emitIndent() ftype.declare(serializer, self.keyFieldName, False) serializer.endOfStatement(True) def serializeConstruction(self, keyName, serializer, program): assert isinstance(serializer, ProgramSerializer) assert isinstance(keyName, str) assert isinstance(program, ebpfProgram.EbpfProgram) if self.mask is not None: maskExpression = " & {0}".format(self.mask) else: maskExpression = "" if isinstance(self.instance, ebpfInstance.EbpfMetadata): base = program.metadataStructName else: base = program.headerStructName if isinstance(self.instance, ebpfInstance.SimpleInstance): source = "{0}.{1}.{2}".format( base, self.instance.name, self.field.name) else: assert isinstance(self.instance, ebpfInstance.EbpfHeaderStack) source = "{0}.{1}[{2}].{3}".format( base, self.instance.name, self.instance.hlirInstance.index, self.field.name) destination = "{0}.{1}".format(keyName, self.keyFieldName) size = self.field.widthInBits() serializer.emitIndent() if size <= 32: serializer.appendFormat("{0} = ({1}){2};", destination, source, maskExpression) else: if maskExpression != "": raise NotSupportedException( "{0} Mask wider than 32 bits", self.field.hlirType) serializer.appendFormat( "memcpy(&{0}, &{1}, {2});", destination, source, size / 8) serializer.newline() class EbpfTableKey(object): def __init__(self, match_fields, program): assert isinstance(program, ebpfProgram.EbpfProgram) self.expressions = [] self.fields = [] self.masks = [] self.fieldNamePrefix = "key_field_" self.program = program fieldNumber = 0 for f in match_fields: field = f[0] matchType = f[1] mask = f[2] if ((matchType is p4_match_type.P4_MATCH_TERNARY) or (matchType is p4_match_type.P4_MATCH_LPM) or (matchType is p4_match_type.P4_MATCH_RANGE)): raise NotSupportedException( False, "Match type {0}", matchType) if matchType is p4_match_type.P4_MATCH_VALID: # we should be really checking the valid field; # p4_field is a header instance assert isinstance(field, p4_header_instance) instance = field fieldname = "valid" else: assert isinstance(field, p4_field) instance = field.instance fieldname = field.name if ebpfProgram.EbpfProgram.isArrayElementInstance(instance): ebpfStack = program.getStackInstance(instance.base_name) assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack) basetype = ebpfStack.basetype eInstance = program.getStackInstance(instance.base_name) else: ebpfHeader = program.getInstance(instance.name) assert isinstance(ebpfHeader, ebpfInstance.SimpleInstance) basetype = ebpfHeader.type eInstance = program.getInstance(instance.base_name) ebpfField = basetype.getField(fieldname) assert isinstance(ebpfField, ebpfStructType.EbpfField) fieldName = self.fieldNamePrefix + str(fieldNumber) fieldNumber += 1 keyField = EbpfTableKeyField(fieldName, eInstance, ebpfField, mask) self.fields.append(keyField) self.masks.append(mask) @staticmethod def fieldRank(field): assert isinstance(field, EbpfTableKeyField) return field.field.type.alignment() def serializeType(self, serializer, keyTypeName): assert isinstance(serializer, ProgramSerializer) serializer.emitIndent() serializer.appendFormat("struct {0} ", keyTypeName) serializer.blockStart() # Sort fields in decreasing size; this will ensure that # there is no padding. # Padding may cause the ebpf verification to fail, # since padding fields are not initalized fieldOrder = sorted( self.fields, key=EbpfTableKey.fieldRank, reverse=True) for f in fieldOrder: assert isinstance(f, EbpfTableKeyField) f.serializeType(serializer) serializer.blockEnd(False) serializer.endOfStatement(True) def serializeConstruction(self, serializer, keyName, program): serializer.emitIndent() serializer.appendLine("/* construct key */") for f in self.fields: f.serializeConstruction(keyName, serializer, program) class EbpfTable(object): # noinspection PyUnresolvedReferences def __init__(self, hlirtable, program, config): assert isinstance(hlirtable, p4_table) assert isinstance(program, ebpfProgram.EbpfProgram) self.name = hlirtable.name self.hlirtable = hlirtable self.config = config self.defaultActionMapName = (program.reservedPrefix + self.name + "_miss") self.key = EbpfTableKey(hlirtable.match_fields, program) self.size = hlirtable.max_size if self.size is None: program.emitWarning( "{0} does not specify a max_size; using 1024", hlirtable) self.size = 1024 self.isHash = True # TODO: try to guess arrays when possible self.dataMapName = self.name self.actionEnumName = program.generateNewName(self.name + "_actions") self.keyTypeName = program.generateNewName(self.name + "_key") self.valueTypeName = program.generateNewName(self.name + "_value") self.actions = [] if hlirtable.action_profile is not None: raise NotSupportedException("{0}: action_profile tables", hlirtable) if hlirtable.support_timeout: program.emitWarning("{0}: table timeout {1}; ignoring", hlirtable, NotSupportedException.archError) self.counters = [] if (hlirtable.attached_counters is not None): for c in hlirtable.attached_counters: ctr = program.getCounter(c.name) assert isinstance(ctr, ebpfCounter.EbpfCounter) self.counters.append(ctr) if (len(hlirtable.attached_meters) > 0 or len(hlirtable.attached_registers) > 0): program.emitWarning("{0}: meters/registers {1}; ignored", hlirtable, NotSupportedException.archError) for a in hlirtable.actions: action = program.getAction(a) self.actions.append(action) def serializeKeyType(self, serializer): assert isinstance(serializer, ProgramSerializer) self.key.serializeType(serializer, self.keyTypeName) def serializeActionArguments(self, serializer, action): assert isinstance(serializer, ProgramSerializer) assert isinstance(action, ebpfAction.EbpfActionBase) action.serializeArgumentsAsStruct(serializer) def serializeValueType(self, serializer): assert isinstance(serializer, ProgramSerializer) # create an enum with tags for all actions serializer.emitIndent() serializer.appendFormat("enum {0} ", self.actionEnumName) serializer.blockStart() for a in self.actions: name = a.name serializer.emitIndent() serializer.appendFormat("{0}_{1},", self.name, name) serializer.newline() serializer.blockEnd(False) serializer.endOfStatement(True) # a type-safe union: a struct with a tag and an union serializer.emitIndent() serializer.appendFormat("struct {0} ", self.valueTypeName) serializer.blockStart() serializer.emitIndent() #serializer.appendFormat("enum {0} action;", self.actionEnumName) # teporary workaround bcc bug serializer.appendFormat("{0}32 action;", self.config.uprefix) serializer.newline() serializer.emitIndent() serializer.append("union ") serializer.blockStart() for a in self.actions: self.serializeActionArguments(serializer, a) serializer.blockEnd(False) serializer.space() serializer.appendLine("u;") serializer.blockEnd(False) serializer.endOfStatement(True) def serialize(self, serializer, program): assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) self.serializeKeyType(serializer) self.serializeValueType(serializer) self.config.serializeTableDeclaration( serializer, self.dataMapName, self.isHash, "struct " + self.keyTypeName, "struct " + self.valueTypeName, self.size) self.config.serializeTableDeclaration( serializer, self.defaultActionMapName, False, program.arrayIndexType, "struct " + self.valueTypeName, 1) def serializeCode(self, serializer, program, nextNode): assert isinstance(serializer, ProgramSerializer) assert isinstance(program, ebpfProgram.EbpfProgram) hitVarName = program.reservedPrefix + "hit" keyname = "key" valueName = "value" serializer.newline() serializer.emitIndent() serializer.appendFormat("{0}:", program.getLabel(self)) serializer.newline() serializer.emitIndent() serializer.blockStart() serializer.emitIndent() serializer.appendFormat("{0}8 {1};", program.config.uprefix, hitVarName) serializer.newline() serializer.emitIndent() serializer.appendFormat("struct {0} {1} = {{}};", self.keyTypeName, keyname) serializer.newline() serializer.emitIndent() serializer.appendFormat( "struct {0} *{1};", self.valueTypeName, valueName) serializer.newline() self.key.serializeConstruction(serializer, keyname, program) serializer.emitIndent() serializer.appendFormat("{0} = 1;", hitVarName) serializer.newline() serializer.emitIndent() serializer.appendLine("/* perform lookup */") serializer.emitIndent() program.config.serializeLookup( serializer, self.dataMapName, keyname, valueName) serializer.newline() serializer.emitIndent() serializer.appendFormat("if ({0} == NULL) ", valueName) serializer.blockStart() serializer.emitIndent() serializer.appendFormat("{0} = 0;", hitVarName) serializer.newline() serializer.emitIndent() serializer.appendLine("/* miss; find default action */") serializer.emitIndent() program.config.serializeLookup( serializer, self.defaultActionMapName, program.zeroKeyName, valueName) serializer.newline() serializer.blockEnd(True) if len(self.counters) > 0: serializer.emitIndent() serializer.append("else ") serializer.blockStart() for c in self.counters: assert isinstance(c, ebpfCounter.EbpfCounter) if c.autoIncrement: serializer.emitIndent() serializer.blockStart() c.serializeCode(keyname, serializer, program) serializer.blockEnd(True) serializer.blockEnd(True) serializer.emitIndent() serializer.appendFormat("if ({0} != NULL) ", valueName) serializer.blockStart() serializer.emitIndent() serializer.appendLine("/* run action */") self.runAction(serializer, self.name, valueName, program, nextNode) nextNode = self.hlirtable.next_ if "hit" in nextNode: node = nextNode["hit"] if node is None: node = nextNode label = program.getLabel(node) serializer.emitIndent() serializer.appendFormat("if (hit) goto {0};", label) serializer.newline() node = nextNode["miss"] if node is None: node = nextNode label = program.getLabel(node) serializer.emitIndent() serializer.appendFormat("else goto {0};", label) serializer.newline() serializer.blockEnd(True) if not "hit" in nextNode: # Catch-all serializer.emitIndent() serializer.appendFormat("goto end;") serializer.newline() serializer.blockEnd(True) def runAction(self, serializer, tableName, valueName, program, nextNode): serializer.emitIndent() serializer.appendFormat("switch ({0}->action) ", valueName) serializer.blockStart() for a in self.actions: assert isinstance(a, ebpfAction.EbpfActionBase) serializer.emitIndent() serializer.appendFormat("case {0}_{1}: ", tableName, a.name) serializer.newline() serializer.emitIndent() serializer.blockStart() a.serializeBody(serializer, valueName, program) serializer.blockEnd(True) serializer.emitIndent() nextNodes = self.hlirtable.next_ if a.hliraction in nextNodes: node = nextNodes[a.hliraction] if node is None: node = nextNode label = program.getLabel(node) serializer.appendFormat("goto {0};", label) else: serializer.appendFormat("break;") serializer.newline() serializer.blockEnd(True) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/ebpfType.py000066400000000000000000000021351305314114400241420ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from compilationException import CompilationException class EbpfType(object): __doc__ = "Base class for representing a P4 type" def __init__(self, hlirType): self.hlirType = hlirType # Methods to override def serialize(self, serializer): # the type itself raise CompilationException(True, "Method must be overridden") def declare(self, serializer, identifier, asPointer): # declaration of an identifier with this type # asPointer is a boolean; # if true, the identifier is declared as a pointer raise CompilationException(True, "Method must be overridden") def emitInitializer(self, serializer): # A default initializer suitable for this type raise CompilationException(True, "Method must be overridden") def declareArray(self, serializer, identifier, size): # Declare an identifier with an array type with the specified size raise CompilationException(True, "Method must be overridden") bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/p4toEbpf.py000077500000000000000000000063261305314114400240600ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # Compiler from P4 to EBPF # (See http://www.slideshare.net/PLUMgrid/ebpf-and-linux-networking). # This compiler in fact generates a C source file # which can be compiled to EBPF using the LLVM compiler # with the ebpf target. # # Main entry point. import argparse import os import traceback import sys import target from p4_hlir.main import HLIR from ebpfProgram import EbpfProgram from compilationException import * from programSerializer import ProgramSerializer def get_parser(): parser = argparse.ArgumentParser(description='p4toEbpf arguments') parser.add_argument('source', metavar='source', type=str, help='a P4 source file to compile') parser.add_argument('-g', dest='generated', default="router", help="kind of output produced: filter or router") parser.add_argument('-o', dest='output_file', default="output.c", help="generated C file name") return parser def process(input_args): parser = get_parser() args, unparsed_args = parser.parse_known_args(input_args) has_remaining_args = False preprocessor_args = [] for a in unparsed_args: if a[:2] == "-D" or a[:2] == "-I" or a[:2] == "-U": input_args.remove(a) preprocessor_args.append(a) else: has_remaining_args = True # trigger error if has_remaining_args: parser.parse_args(input_args) if args.generated == "router": isRouter = True elif args.generated == "filter": isRouter = False else: print("-g should be one of 'filter' or 'router'") print("*** Compiling ", args.source) return compileP4(args.source, args.output_file, isRouter, preprocessor_args) class CompileResult(object): def __init__(self, kind, error): self.kind = kind self.error = error def __str__(self): if self.kind == "OK": return "Compilation successful" else: return "Compilation failed with error: " + self.error def compileP4(inputFile, gen_file, isRouter, preprocessor_args): h = HLIR(inputFile) for parg in preprocessor_args: h.add_preprocessor_args(parg) if not h.build(): return CompileResult("HLIR", "Error while building HLIR") try: basename = os.path.basename(inputFile) basename = os.path.splitext(basename)[0] config = target.BccConfig() e = EbpfProgram(basename, h, isRouter, config) serializer = ProgramSerializer() e.toC(serializer) f = open(gen_file, 'w') f.write(serializer.toString()) return CompileResult("OK", "") except CompilationException, e: prefix = "" if e.isBug: prefix = "### Compiler bug: " return CompileResult("bug", prefix + e.show()) except NotSupportedException, e: return CompileResult("not supported", e.show()) except: return CompileResult("exception", traceback.format_exc()) # main entry point if __name__ == "__main__": result = process(sys.argv[1:]) if result.kind != "OK": print(str(result)) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/programSerializer.py000066400000000000000000000027441305314114400260730ustar00rootroot00000000000000#!/usr/bin/env python # helper for building C program source text from compilationException import * class ProgramSerializer(object): def __init__(self): self.program = "" self.eol = "\n" self.currentIndent = 0 self.INDENT_AMOUNT = 4 # default indent amount def __str__(self): return self.program def increaseIndent(self): self.currentIndent += self.INDENT_AMOUNT def decreaseIndent(self): self.currentIndent -= self.INDENT_AMOUNT if self.currentIndent < 0: raise CompilationException(True, "Negative indentation level") def toString(self): return self.program def space(self): self.append(" ") def newline(self): self.program += self.eol def endOfStatement(self, addNewline): self.append(";") if addNewline: self.newline() def append(self, string): self.program += str(string) def appendFormat(self, format, *args): string = format.format(*args) self.append(string) def appendLine(self, string): self.append(string) self.newline() def emitIndent(self): self.program += " " * self.currentIndent def blockStart(self): self.append("{") self.newline() self.increaseIndent() def blockEnd(self, addNewline): self.decreaseIndent() self.emitIndent() self.append("}") if addNewline: self.newline() bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/target.py000066400000000000000000000132721305314114400236560ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from programSerializer import ProgramSerializer # abstraction for isolating target-specific features # Base class for representing target-specific configuration class TargetConfig(object): def __init__(self, target): self.targetName = target def getIncludes(self): return "" def serializeLookup(self, serializer, tableName, key, value): serializer.appendFormat("{0} = bpf_map_lookup_elem(&{1}, &{2});", value, tableName, key) def serializeUpdate(self, serializer, tableName, key, value): serializer.appendFormat( "bpf_map_update_elem(&{0}, &{1}, &{2}, BPF_ANY);", tableName, key, value) def serializeLicense(self, serializer, licenseString): assert isinstance(serializer, ProgramSerializer) serializer.emitIndent() serializer.appendFormat( "char _license[] {0}(\"license\") = \"{1}\";", self.config.section, licenseString) serializer.newline() def serializeCodeSection(self, serializer): assert isinstance(serializer, ProgramSerializer) serializer.appendFormat("{0}(\"{1}\")", self.section, self.entrySection) def serializeTableDeclaration(self, serializer, tableName, isHash, keyType, valueType, size): assert isinstance(serializer, ProgramSerializer) assert isinstance(tableName, str) assert isinstance(isHash, bool) assert isinstance(keyType, str) assert isinstance(valueType, str) assert isinstance(size, int) serializer.emitIndent() serializer.appendFormat("struct {0} {1}(\"maps\") {2} = ", self.tableName, self.section, tableName) serializer.blockStart() serializer.emitIndent() serializer.append(".type = ") if isHash: serializer.appendLine("BPF_MAP_TYPE_HASH,") else: serializer.appendLine("BPF_MAP_TYPE_ARRAY,") serializer.emitIndent() serializer.appendFormat(".{0} = sizeof(struct {1}), ", self.tableKeyAttribute, keyType) serializer.newline() serializer.emitIndent() serializer.appendFormat(".{0} = sizeof(struct {1}), ", self.tableValueAttribute, valueType) serializer.newline() serializer.emitIndent() serializer.appendFormat(".{0} = {1}, ", self.tableSizeAttribute, size) serializer.newline() serializer.blockEnd(False) serializer.endOfStatement(True) def generateDword(self, serializer): serializer.appendFormat( "static inline {0}64 load_dword(void *skb, {0}64 off)", self.uprefix) serializer.newline() serializer.blockStart() serializer.emitIndent() serializer.appendFormat( ("return (({0}64)load_word(skb, off) << 32) | " + "load_word(skb, off + 4);"), self.uprefix) serializer.newline() serializer.blockEnd(True) # Represents a target that is compiled within the kernel # source tree samples folder and which attaches to a socket class KernelSamplesConfig(TargetConfig): def __init__(self): super(SocketConfig, self).__init__("Socket") self.entrySection = "socket1" self.section = "SEC" self.uprefix = "u" self.iprefix = "i" self.tableKeyAttribute = "key_size" self.tableValueAttribute = "value_size" self.tableSizeAttribute = "max_entries" self.tableName = "bpf_map_def" self.postamble = "" def getIncludes(self): return """ #include #include #include #include #include #include #include "bpf_helpers.h" """ # Represents a target compiled by bcc that uses the TC class BccConfig(TargetConfig): def __init__(self): super(BccConfig, self).__init__("BCC") self.uprefix = "u" self.iprefix = "i" self.postamble = "" def serializeTableDeclaration(self, serializer, tableName, isHash, keyType, valueType, size): assert isinstance(serializer, ProgramSerializer) assert isinstance(tableName, str) assert isinstance(isHash, bool) assert isinstance(keyType, str) assert isinstance(valueType, str) assert isinstance(size, int) serializer.emitIndent() if isHash: kind = "hash" else: kind = "array" serializer.appendFormat( "BPF_TABLE(\"{0}\", {1}, {2}, {3}, {4});", kind, keyType, valueType, tableName, size) serializer.newline() def serializeLookup(self, serializer, tableName, key, value): serializer.appendFormat("{0} = {1}.lookup(&{2});", value, tableName, key) def serializeUpdate(self, serializer, tableName, key, value): serializer.appendFormat("{0}.update(&{1}, &{2});", tableName, key, value) def generateDword(self, serializer): pass def serializeCodeSection(self, serializer): pass def getIncludes(self): return """ #include #include #include #include #include #include #include """ def serializeLicense(self, serializer, licenseString): assert isinstance(serializer, ProgramSerializer) pass bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/topoSorting.py000066400000000000000000000051071305314114400247150ustar00rootroot00000000000000# Copyright 2013-present Barefoot Networks, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # # Antonin Bas (antonin@barefootnetworks.com) # # # -*- coding: utf-8 -*- class Node(object): def __init__(self, n): self.n = n self.edges = set() def add_edge_to(self, other): assert(isinstance(other, Node)) self.edges.add(other) def __str__(self): return str(self.n) class Graph(object): def __init__(self): self.nodes = {} self.root = None def add_node(self, node): assert(node not in self.nodes) self.nodes[node] = Node(node) def __contains__(self, node): return node in self.nodes def get_node(self, node): return self.nodes[node] def produce_topo_sorting(self): def visit(node, topo_sorting, sequence=None): if sequence is not None: sequence += [str(node)] if node._behavioral_topo_sorting_mark == 1: if sequence is not None: print "cycle", sequence return False if node._behavioral_topo_sorting_mark != 2: node._behavioral_topo_sorting_mark = 1 for next_node in node.edges: res = visit(next_node, topo_sorting, sequence) if not res: return False node._behavioral_topo_sorting_mark = 2 topo_sorting.insert(0, node.n) return True has_cycle = False topo_sorting = [] for node in self.nodes.values(): # 0 is unmarked, 1 is temp, 2 is permanent node._behavioral_topo_sorting_mark = 0 for node in self.nodes.values(): if node._behavioral_topo_sorting_mark == 0: if not visit(node, topo_sorting, sequence=[]): has_cycle = True break # removing mark for node in self.nodes.values(): del node._behavioral_topo_sorting_mark if has_cycle: return None return topo_sorting bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/compiler/typeFactory.py000066400000000000000000000022531305314114400246760ustar00rootroot00000000000000# Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from p4_hlir.hlir import p4_header from ebpfStructType import * class EbpfTypeFactory(object): def __init__(self, config): self.type_map = {} self.config = config def build(self, hlirType, asMetadata): name = hlirType.name if hlirType.name in self.type_map: retval = self.type_map[name] if ((not asMetadata and isinstance(retval, EbpfMetadataType)) or (asMetadata and isinstance(retval, EbpfHeaderType))): raise CompilationException( True, "Same type used both as a header and metadata {0}", hlirType) if isinstance(hlirType, p4_header): if asMetadata: type = EbpfMetadataType(hlirType, self.config) else: type = EbpfHeaderType(hlirType, self.config) else: raise CompilationException(True, "Unexpected type {0}", hlirType) self.registerType(name, type) return type def registerType(self, name, ebpfType): self.type_map[name] = ebpfType bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/docs/000077500000000000000000000000001305314114400211275ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/docs/README.md000066400000000000000000000001631305314114400224060ustar00rootroot00000000000000# External references See [p4toEbpf-bcc.pdf](https://github.com/iovisor/bpf-docs/blob/master/p4/p4toEbpf-bcc.pdf) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/scope.png000066400000000000000000003053201305314114400220210ustar00rootroot00000000000000PNG  IHDRgu$iCCPICC Profile8UoT>oR? XGůUS[IJ*$:7鶪O{7@Hkk?<kktq݋m6nƶد-mR;`zv x#=\% oYRڱ#&?>ҹЪn_;j;$}*}+(}'}/LtY"$].9｟%{_a݊]hk5'SN{<_ t jM{-4%TńtY۟R6#v\喊x:'HO3^&0::m,L%3:qVE t]~Iv6Wٯ) |ʸ2]G4(6w‹$"AEv m[D;Vh[}چN|3HS:KtxU'D;77;_"e?Yqxl+ pHYs  diTXtXML:com.adobe.xmp 2015-09-18T13:13:57 Rq965bVZS0WllMxPpRAZkg 2015-09-18T13:13:57 iPhoto 9.5.1 2015-09-18T13:13:57 1 2 72 72 933 775 `@IDATx}`V d{7 ޣOkjo_wkV;mmݳ &@#xssߛ72ܳsus"FWoե<ݿ u-7Wcu)3@7@]pi= i@.Zd]eadeġSBV. SZZ*;v:j#Hxiii 6]EŲs*׺ukIOO? 2?"p?!/۷9OLLWZՕkme5|iJ5W4СkNHl;*>߶m&߶mZhMe֭>.2224YB ` jK3ƾsNywU 516m.,yۼyw}2sLINNGWFL̟*=z,8q9Rii8O>)?٪U+ϞSvQz%{ GMGhQVo-_P[n|+귲'?Oyg$))}BxEpӧÆ+bq&(UڵK>yݻw1#/K.PY=CFF3Z_|!Gw\eݻo|P:wӟ2]VrΕ+WFm޽{U*ڱFnZiup ~V7<y0]zuYpx`A:Odm'U;a8 @\eaٲe:>|,8+\8z(ep_U ,>_b@d)߿B~ X1`htG}Dlfx3 JH#FPg$25k?X˸뮻drg}쁄hsfk֬?#,m\ނ #/y7Uh7Y}7~C"nec'?O;FػsA(oe#o 6_2eq?o<5GG`NFGAh"n>spBU86xXʚl35>m=Y|DZy[e$h8G9ڄ zme 8p 'EDH&PS]?۵]SY'Au!Ʃ8Dy1hg~&FR4"<4*B֨ா2#SC`q75͗)))[YA5WcC4 iHž={QlBiڵ?Y{: 0l pA^Bc r_lFYU|l:+VcHО;w@O@ 1ږ=H4pDg!-5nC4%T,Py3'ٝFy0b :TyB`Wj2|n \l!td gqIb=Xd^.z+ZzaȘ ~ 3>YLQmj!`xĥSN<^wys߭L?2hIkS%ŹX&M"!гмbDKr/[$V#ҒRd'_@^Y )|63R8z}10]umf^{ 3=;P9|8JqO?ե+)5ΤG}Ԓ_khP02O^4 B4pZ)n5ϚCC"״pa𩧞j*L֋fAKg.~뭷4])5Jxmd cw5_Wu-QҥK;h9ll;p#˚a5UG >Ls[5ZGWAzwGQ??^}Zl?ܼ^5`M CFM 0I׳>[Sѝ:>96vX^yV蚁)\h6淒y| 2w=~a>=w)Fœw^wG,7l!3r2_[Y*x&mor8Q`TglBքABt vGOb⨌?nP@sV6v'֭o9wܡzJJ%ЪʶQ!VT[Wpg0 }52->LQB*PX Rh(mTeymO p뭷h^+=FzJއy@ `M`4ep$DnlD!aA 'ɢ !y?}t{tKktz,`u9+X5U@Bb^c UeK.D:,_X[y-sG >0ȃ?_]v /Q=nN MzMHZb:;[E`O : Xøn_g 7B4ŭ,b1SXtM2gl𨣎RGh`/h3f(Z%HbDH[9JƎ&iMP^l{&M$i>61T # R÷k׮!7n\%5\2;pkFj@GEҭyNjZ"9:bubAb1 ^S)咈-9D-{=]rk*ļL<7,Q*w 1]m A' ṁ `8EtޞKС <8jtE8qߟbVXP&sKCeKWy:qmt <4(B֠=pᦵPVv`$@=9]bsd?Ms S``1I*2|f}0Ygu 2;f2JQ=>1pD? L%=x;%%5ED,_#CC `҃+T¥}z{u1VU8QV%T"`949@m!PYe‰OP-p_m=m){=?9ז#Ë@( u+8;rrVm`lR*_Yr0&@@p6îK+m<:q̒VC!GNv.t>w CA `FX$ #Ұ;-?ɡGۄћ !'Թ瞫33c!99-/_/l:z?%`M -hNi ش%sdW7}X91 *Hi©6,^yXߠpMa@(nuemg+;X gϙ)jvH)ց9)vz!mo~SZPxń'5;#0zrsp~4ZB}aOOW!Aq_eȵZ 6,HHwuzD+:[6h"^ ; C@8:{sg>ѺQr}'/ԑs(aeC `!4͌npDEegۯQa#,^sn>JS$wlgsap]nԿG'͹i-/w!-^M/aKM2E ZJxU; g:gix>몰SXRQUC@ `!T8q%FQUX\e›#;0zo](P^g0k~m(w̬r7(9 ***^r%~#Ml_35/\Pŀ aU1(%:P:-Է|~eqRqs9>g0Ӟ)MVMVXN63&;3>MU]P[PC?)@Ex .nvK\DqҊs}~}mm x ''6*<A?XC3{bWf[SQY^_-޻Ov=RXT$ť_X_)*RĕIq^)*'{(é#nm` <Պ ZEu+'ҮM$m+)IVRyN:IRZKJbMh-m,ٖW+u̬GT鞙$=:eHI1YUr -*| :|1.;" UX}ZmtJT`Ĝ<ضLrո}aSA8) JAJdi)# AZ2R mQ4#"'gxޙ&g g /"HޞB-(}}7`O@ (I ޡwt<ک&HvTe \-R|+<BvP`kLN6"2X&FMykndo#ٛrq-V "2I7V`B5 ]v3]2ZLC!PyaQaS"=Q~glˇrͼtg{$03D/q'WPX~h@QJG84zS!`nE%H:Ofť F$i53sK9Ƥ6`Zz G&ڥ?*a~f^i2 pO`OqfһwO]hP[Q|= ȃ@+5!Էnت^&g:HVw;Y &pI᨟cЪ[R! 4380-!)2@j|Uݲ"g,%!m$&JdaOajI&]ٛ ?:ZSkNjHQ4y{؊6˼5eWNeKE 8M¶b]Tu($Ov`T[ eņݲzKl/`Adua}ҥ_w̭ul/iO y+n!׉arUU^.ỡ|_ |Y2@dvJ6$M &zJ)i0/UncLqbݨ4z¢PghϦ:W,ўF[**|fus./k"QPo(rSO@ Agu=`hF@C;͐64X]'Y5̰ ʜhm~;e-X&bt5n4~7hiԨ+P s Dc=Ip,$ƿG6 ++OvRЩ#L ϡEpV`d\@ɕnS ޙ2 S $̳Y P]): Ch|'<7V|<-Gd;L+hA`-^mzfa8W{EG:l m Fvm'rX.]\@Z@"¿``| ,=-k/&wUy(pP 9$0?RwɆ\YSd2&Gb^&vhE^,2<7B`P\ǮId<2YWy.L`ɲue]2/s%>]dLhij ɫmvjr# Z/L& Ę.ig^ ;+ ~]^JY)VBU9q.+.ṶN/xFdizl|YeamlK.Lq2[{&6DN(?pcb~ )?R/,0@yq>F1Z~_+s `,+CF̂i.51ᐙmW<|d-^iU`NjjoM(<d? ^\WIZE:8,[avYCvLq( (81ZK(Pa\Xw,mk/;yy :u@V2 ʿ  ZC>RjdUDIAU`y-,[vUe%L:"G .w\ ]+y9 ""!`L{15)w#B@4Gf³sh44U%tA18Aҵ"33`dtb6|El+=jpW; f׌}9U/!8ZbSQY>W-CA҄蛉2djpVѡ?w+'7@Ю޳6W'؁a䥠̄gf wiP6 0V^ԌśdXVf[4#t,ƭRު*dV z?yVt-871הŶ !3ni/a2#:ݠxd`ѵvS 3'\QX rNdL_CVnˇhL:jXwh2bM>CD1ھa748$(Q{2|2lqu2kqh " $-Ƃ*0POE^l׼D>ujP LL)C L{ [։uKPWʗ6[d>:0yp'8 vi~kABV6}N+T# aFfknβ2cfY'rf}0_Y`A5_.#l/󵚉;Ȥ=ߦ"B&xE6ZQ={Wȃ[ a`V|XSЯ.&nj Ŵܥ t&uOX ZB7XASOEgt ?Of5nHwTbG4?NGYZ6/Lv UbQks 3FEl/('N`|lܵʎ sRZR&_˖ҝ2wFpHv\w@s 룭s$u f8:& yXjCFe䳅[d֞:GvIzԜ! 8w|OAR58bTƅ@؁ T9 t#yp؍dMެuвwK6r2ito֯dbsZ L5.< ֳ;*z,_xn@8‚yڳi_@q=ve=Og4-%[bM!Sɒmu̙Όe=FO8g׈zah` '$Vvb`7ɴ99LqtSgȁCГՙ2VP[TTkHLU6v70#LN"[o+=[San-k˒*s$S9Pp#k\^%'8EJm{Uq5nb};b<.-wڧaWŹ22T`m$ UHqckf^X~NzO/'\γy[r~2~hݷ P:hLx-c A x#,\ΐ@E$&)Vm%^'o}^bc]:tH]11ywJ0z'/ HD).P ^pxoQ+nUl7?_-˰8,>iLw;v/4/.܊Er,\ϞWy3fs(X2k4V{knpp\)h"(f@zqS\22wfffcPDN^2j`w5a=À\^AK>$^àuTnQ Vl-cne°ҳco"ά_Ȼs6 O)Mއ)mL!zėkkԼ᡹A;uMQ*I/l4CLnrCz }~Ex;}v@Xy`Ut>r e69zk |DCN;iXN£e̲y )j nĖCѝ!nԟ.ȑ>]%!Nڽ'1CzHW|g5@Z?fc?_nE،4=p邹7"ۿ)M-" 6<;E0 Fw%htix 6ߞԷfWnŴC\vud bx^B~@PV _ayAb{KE8Ѝi}g)>^^J;T)gBpU?-LǕ,8P?GD$ Omә6V>IYYsrj۠ ٹ@|t}L|u:Yy#ʹ=eZ~ĽbYc oG_.9t" +g6 ˷1}2(4aZxrE vpt%<ЧG`$E52.,˰#2]ZGl\{rDxFO,tevKpj UO d:ajQdR]QD&e8E9r:B&`}:FoA *4DK#4pǺ=řӞHAt^1 { 9.Ѹҙ#áUwGVkExln"a.ُQ?(=T?7bW}Ur{=91ض,i_.PsdGx8-uҠͥ9`Xyk&߯8yEDB`SAr%`\G8קP^ȆLbhU"L;Dɕ' S& 9.Ġ `#P G6Jgew/~AuvO7EQ5h^A]o=fQe`@xޒ \ M< ]Kx}LtKSǷX-?X&=E("gU9f.\;m0c$.;eD,pc̩>A1Mȡ=uy+ ύ  VVP*|Fd.HlR9A2nԀq,%CxH^^38Aɤ*<)@= @!Lsi.Eե' c0s{-=2Qϴ uyc"ޮf R^}xBE &􇷳sQ}|44D;!LTP#:]sI.eۊ䢣zʅ0 6?;z횢(Npi3A,89?Z.a2T|:ӆ8lkY?7 'Lw's_X\FdN&3^*:qEM4d?X.o݊ 䫧 檽աP"H#Vi> +@y!]đs^\A:KO O:24}5:UR|{)崣HNr,(ؖM'T?xJ\Waf?\/JGy'g]}Tfӣ; X,O^?Py1}$Y? fdFNyWlZZ7;s(&HFxB7JxCzbDC:'[Bv{|:._# LD=m5io&g!yT :ΤbRX,˷ʕN*:hj#|M~l U2P!c([g&ϾH]]UzH޻eV_*<<;4[g/9GLhlDwiLPx~ǏgZMEZ3ByM2eTga2$crvc"5d^r -ۄŢ/L{o &ל5XǎI0 Oc^߳]㽺C<inڳ5DhWIr$ߝ }]aM wDdYp'Y&k7"8DzKsK<$TvjYYԈ| /^_x@u vOVDSBThi!(1 Y3ưYA84p^zmu-Vlk#:Lâ nb0΀9<~k /Uq~% ۋe]0ɴ򰮃bX"<+,XhfP_xo<=c1| };iCu1_`g$OpSfRy轕26+M={3HgRҼ~') llhA5QV m:_ 5 Z(1 t'o=LNa'(%8/ӖֿP0d4۞ y2O{Qr4> hHG~`$ؽW "W~HgBdwI;s%Q׷. aG@ghnjч) \p0M n0{<"y_ǽW>L:ysHgDߢ{l<|se#hqO8vˣSv.E5R rZyZT 88h--Y'g)))gOšp!ڤ޻Г3I2f fOφQOVm)ngU;,_@F`J RO殗:_vo^0 $68cx^@:\pJ>_vZz>i?:34p xޗr?L%e GGv WU[G N,`tZfS 7B[b+%wI: c͘7-Ѽt(B  otcwx)AP2\4RNG gzl]"XtjlQ2 7]yìT;ڒ{P}QwKG|IiFnևgG8bUc"/z ɩʣzpbyOi5s_5&[GTw#|=\U\]z9Ci]T!OE^(.@niaL_'`N-L/c^ تk)/mg#DoME.W=3Kwʏ/+b ~)Rܱ'w"!@~ރerfs7mg/滨S/Pec, |"JܦCme{vL؜x>Kto 0H)dWa<]RKSzmF~w}6Y!`>ڏ;Kd֯lޜ'd d@Li <tO`JوO?\r;\2J'`aN0L*7W`r4ٝd |{ 巯-&t[.;ZzwLc>%a#غ>96xs-ҕSC?THn !E ˣ. |w`Ξy}`nhpڐ[,6oEp>m^P 7އA*rklCǝ\gPnxtIk>u6pˍ:h{Qb*;\ozp) gA}:9c!5ĘBJÈfVLɌ20CW:X1:pGɠ.bM$@~yw<,]Ë`#!nR2[=CM@\ܳ«^OPױFNXtIIOl#Cu"yÕKXF9ﭬk 0t&a/ϖWg1T(Q. +Mh 34סu'˳wm0.hçPɽ妋NU+;;D9!@-ؑ>:1}TҬ{jCA+]sjy@s䃑&&~pwA*;wyCE^߯^bÈpÆ R^^.Z!,/k{osF@ i8*3 ‹i+p?wL'xN Gy/8=j!MFµz M[Q/"{np UjV؝# Fouqoj*ö]֭iD(`M=zlmo6F7Sn͕?]#:3#`Vfk &`,تU+3.?Jn>% _%-+k߾2k/eeRVV*:uR0~ 118LvB)FǴp젗 K:7Ԏچhb+=0%`_dhܟ.X!L)⫡mZcU+77O~_ģ'c?,O>3VxxL֩|1[scCr9[~(|>:8J GopsUX=|V7:ipo'Ck* PTTBe[Ol;^ժt&$H*4=c3` dh41A@)CۡܲRqaD@TSt;./v$"Ec'>րތ K/$gu.>VA[>-~u5|1 ĭmT{TM3y瞗O?LRSSD[IclE8>g^+ZDsa}[҆@0M1̴baZY>^Ǧٴi*`޽{˛o)gO9[XÞL@|62rotQ-v=ْ ̻{ H 8(<7d~["C}޷o_2etUǒ)"Gu^! a-Z$}h:83cǎsN&ɶ5J۽tR/sϕ:srmۦuL8Q?xJt7nwyGx&?jb}d6`H Ҿ}{9餓GT .EdrʩszS4Hp=ɗ˓zK֮])2DψIoEv]˃^;N1ֆA4m(XNxݠv zdM_vo^Y,vn4熳 OϚr Sʍ7(4{zjgJwT0>Sm#i_O8QXQ[f$%%iaÆ)m*_0L:^Hww^Nc޽[iK.Q'ӳVҲƍ''xyP%?ۼypt?am#-҄J^oi&,ͭuҫW/1g$gh@ui bY{hS_b5'647Vȋ 6#0+xڹ w~l Ii M`_6r4]6,X ;w  &0lڙylha`Z" {Qk_Zx 7foD2>[?†ePZvikC=$?OUPxIR0C5k@s0:ʣJIa z(JA~kvRb ̟?_j3gAVo;/}\_a”U( $3H߬C}ޝ/wwʌyG#O:I,*5 񌮢c vO.72@jyӕjW2iݬtH? F+B|AKtD@zUXT.++Kdܹ~/rwJZj|+JkL@5eP$izx03o~‡t} / :&Qib`YK/T賓?^f̘i8r뭷BnTI&_dۦw3^rk1]‚0"ޅ#ds$ܙxeNh9 vj`k=[vFnȤ[_;wW7l_?kw "`Nv?12vQDl٢q?B1}ND"82%{ m {<"`=4Fuv6qW: h"`8Dr63g=`{ `4SY?]aw@ ^Ӹ>@ۂq? A8hʀLߓ FE Ãb |mNdFykaK_ ÛF{HD&|佹뼶j\I7pC T%C><"ioY\d? +Gˤw8fMe9Ҷm7TȈ#";2xM?"s/4HA]x*7}>y!݇\)q9J_eƆ3!B SVI7v//aS7o\>ZNiܰsd; i߶aEϠ\-.*֡_?{QM4T}Ow]GW5:cp4) ua*?OtX;0hbf;-4>~",qأga`y@rӄ|r4 MGmK/P@kiIj~W}ѼkjylA펣N&-gV)M_䮻R$owF\rPi83 >?]S /͓Lۏ wA^~A@15.i*98|r @'p@UW]KzYf|:^N~Chƃ0Rk _azcСF@h5&N SgϞj7㻐s9!|&N2n>Dq |#țnIO`mk}Fr"0$b&nQ$Lz`)GSdG`NqvQ[`Z`|rqiAFG%3>γpn; HȤ)X鑈@$ S[WZÑi#0|<Qx}A md41`87ZC`yeQry,.|]=,l'ߋf=g9Z<1wa]eGSӔCNs4O2fa_[$w9g4.+n\).sAN>aɣ3˝N< so5*QW}*5,,K>CC3Xy/[gw "ߩFe',鈿?fH\b4q0`FLC Q#:,ϡ)ri˼g[nϗƋFK 0?EvB4<ҳ0 E !][>3Wo]<^[Â|{n5TDZpLsg*Od0+瘞 T8!r#:>,*fyVu(P reX.y@>yڵ#?* 5)Y ,4Gtnv{ht@BAi:"Yء ȝM__ ?k7L&4$k)_0~WJF{{Њ:yWd#4_|"uBGy^ hqdֆgLgqDo:JdY.SS󡉂8,&N!hn`x7uD֭$6 /+Ag@2йDGS B CzZ^ZM,-,,wqBg}VGS8Bb!#HxpQҔI8P[q`>Dt<bnX|UN0:lUx]WДHOauLkkT<)Ju-KQpI Q7E3哴ot % #:-L9u*t=X&%sThmш$Γ6̂AHXli`,_njfgg |ǰNZ>8⤕*z*ȫl:p@HO,EZHG ,9L_KiD\Y^lRq=ehfN)nڐ ;ˏc0vI'HImdj+-MWRڒY,@&YN;ZE3͈ݝ^vD Kj4 4\x&Q袋sX`dߏ~#3FF/]99 hΏ})8j Զ8AB) G ]vi<GrHPH\7F%ptJޝZ,[ ;y\}N^ˢ) @6U]/8&*hU 5roo,0-N؉d;m&8I#ӼH=Thn7G/؞" #z+B?1†D+Hދ-#4kU]% p_t%.- ؤ= Y 'xBUz$_ves{ F*¤G‡|-x~W"8do̓?Z#z RTSSձ1x uAJM"\0(0uyS nEǪ)3UWFDзo_pɀL͐a[C|kʘƆP֮Y+Ww41P8ǎ+i=5(…N!V/H2"(8Za)ҕ^ v$GU(H&M >#`nڼIzu3;0-53jhe~j4UF nlm3+SdhF\n yY.ۨ7\.P@[Su?t߿~$ - ԯ16<;5u WSjv B YC~t1I~r1C?6g=&NE 0#2L#&-WK #7^`NܠsXܵ&2郼e~ HĶҫw m ;y-&͓W`>*| 8gq@zI:К3{$*:OWGTOxywtYP12aa|!2j8ldW cE9wN?GY>]ѪtH zg%P!ӑؼ@$#@#tU%ז>qvk m:YĆʮ* )qGPTr$gg}ñ2 `Y<ceٵ'ڿR֡mGxy[oEE^J~\~K;[0Zs ٭pM7:aas3p.}U2:rcY<,G~T)(h歮 ?k,!7N&?4qDUqpv&5ZlwUF'5T/<0w9/ÔB ư)tR viLk$MTzgY:Y6QQleeA3kYm3+HrGk WϞ}G׷Qرc N  .F~LaC ẀFi> kV_Mg3 ޵ԍ vP"tZ ƍP{=WN@azcq ~{:4C0RV)hYv }61L3.:V (ҧ1*ֹ 럭R.pᵀ7W:VnUsr"ʿ?\N; ^ժTs#v(-0ޞk>xeU?OSm]YV^ge9y^ՙzeX2ylbi@;i،z]R.dz_FLixh/?@>9˷;d.!]qҳU$ ߽Ċchc^WS|9/rgKgg{{+cY r5UZ>^;0(eX=|| p`e|.XP-{ih*ޘ(sY5R XE\Y/M8{g<w"<_zK \C?t-*и7F1s+.=Ɔ ѓY3σ3Cn uX>}ڪ>3>‘3KuSE҇˥p(=k={Vʙ|@kզ*Mv%rjzvv눤'O [;y%DC` ԥ@Z :\?'VL=2Iĺ9_4NաFNJ̡_.ȱQM{g1dr> {!̄4tN W)ttD>c 1NsCs10Izz2 9c']I|؞{\44ܧgN[[+gXkD!2;ԮuHeY¤y]|8Gl\68.KFF5xbGӁ% q+1JdnJ6. @d1=GEk HR tz/Pqt I١3G[B\o[q[.nXi6qmݭOƱ>.Rw)7>|J. FO^E8>tɢF"Gsqˠү3?JJgFkazlv){acUC1CM_}/=g<&m2 u&BBwETRl-XWQ\WVqwu׊Ww Cz/~}7o~$d҆I޻w9{JN/${!̣;TpVd[IR‘Pʭ3 Yw2zun6GBMGy3$0Gf 53`Tc +>aDl|v Ƈ33`[K:֬l ͸gǥ}z,ax@gOӳuvcO[%hRЮI3ٰ}EgdHfgil%>zUO`2TP%Tw"wѪuv gGo`nWK=YQA0O>:ɞsI: .kQkd8Qq urEbC9*E}x09aj]]xp LRC-o WCZJyy0fϰ[~ A2`8^a;mZ,Ywޒ=;"yOk8v߄yvS6ZfGwHzn2v7m΃ U q'F\-HOY`7>48vdB~-j$F1W1 EqފDjgXgP r-6gme]͇I&X>Gj|`l:("(6 a0Aa9 /O,xޝW(8zܾ] b#cdQn] +>{`g/p2iު#jgohhfÎwrJ" U6m =a=,է7Rž5 X#'Xn{U[n2a2ޕĖBzyp­Θ{ HKQwąaySF00Vi`Pef 4X&/K)f#!ⱁu뮿*+97 ϻi]܋وA3GؗozNtdIrG*%FWmHVwSF>ذ:: `بN|d{e?Bf}h# Rcg؟MOai@KT}48wK>l -6XkB*ᳺC3 żEiv_ljKN9SLq?|H_2 zRaÇtMlF?W$|H}Z1j\];vA}§lbXKl1؎=0+k_)Sl!%,]Ы6WG{ ΂< @=Br\ XaDGཛ'$ܙ*FQIsm^G9u!SH 0ֺY>C# T 0[΍+rCbĉ5[bQn=`e%_Nzai#vf7 J66k2D;P;zw̎sJgm<_v67;X̨k"a}wMy?z'sBG|bRx(ɧkMx8&vrD+kBԈ0.ʑ,S?颶 .8hoi+1 a8#<):Lo U$ip!# rG`^F8}!>^cܕyܫgg[ ;b>6@ώJ[)Ivo+u.z׽|TC{ӇlB3FP>3&}9sGq?y.9q'v)Wxu>|"XRk׽c=Hx]&&R+_yPG ۤOjSą:ziFxRW[Z(=/γ$D$c4RNXLfƓ{٩-)6ٵ J́brcd?yPKjKHtnB3{*iv6fWv]0Haj/dx 8IN?u*v$۬xׂG #P4fiAopq3!XLՇ[bo@|:{YNC WU#6Ql>q3lΔĚ}[ht+Al!eX(uo]6[%rIL_2XR0һ7;I͞4mV6<}}}fEKW)Ohu#} l-3CŴn"D~n͈HkοO0-ZSܹٛs݁jn 8ٗFqVjB}(b"~f=;wjkGH4b"I?T2?-fBQm8WGs66;03HW0[ ;hUigO`PqH́-2|~B7s*}:|S5yd; Ԥ5Ei\\T|1ؖb+o|tT\osm P W7*^Iq/G?mX6~nA" 9qE]3-yr@_oPKV*9G59^f Y>RA*8p98}To9I {#κ24/+c_eKVct ]vimHBV2܌Uf'ƾ:&HWuD fdֵC;;QѤ+d1;\Uؼ78/t$(1Ny8 UD}vĉ6n8;c{﵅ b_bf€m)_0(X.<<8kSz=*3¸>7ƨxFԩS)a;Q4eeA9o>xpw]W N٠lƪ{}gh@.1?&>h Khdʃ+?nhy"WM,ltkZŠǷ  qG$W1tsOоw]O|ž{9; )ͦMf_m~(yI&77o0x϶!Cxܔ)S}xuL7x݇>!?"̙3=<ǬGֵkWg#_לq\]D`^m$D NϞmTBPx_~1E:l@ 2m<2f"⠙_~u^vܜdSL1˲`1 ;vl&'뮻.鱙?__ى'-YÖ-[M:-Yb a~5!~B{~h$ko}[ $I$:*{#*Szʉoه?LRW79ψmznP3IR+{f3f~e]XnwTЂ7y9ivde[=iRa6(1+neE)SS`Qi:W_8;;86[ߥ_V%$L߰!yVg}C}w6YЙNqC)D~@Rp/Lgڰ.7CCZTZ?ǝ8>`7<cg$?|#! 6V\i'.N֭1^@I]6g,Sߥ /O:x8Rާ>)Ҟq%1mA yyO$@IDATٱk_ ~8L=L$($H>TӧOtb.1 ~mȑk^vꩧ0gN ,~͛;&W+Z`EGHg~ gԯ+Q(MM )cTݐ~=Lf{m!{po~x4G^}>`c ՔUU%}`D%7!p;ݷ+_n܈u`P%/^ oZg6n3꾷0FPﱮ:>C9T 3;N_'"1cw.'oW]u]tEΔ8u$cm bSa> M69@|~O~.mKl#Lq!~ӽ{w'?Os94p?#7@@`dGgmG<eO?O0Y:3 >gb?cW_}3Q0?XKK??LI ƴ~KR// I}#quDF׮};kFKpKW8IL]~|N# *{%bSw{(>?Q)ŕn8G26\o)rbٛs3uzLک^߳TE^ҙ=gXfp"8t#v'&,O]ku6ۧ=h;e58mPg=5/8 اŷ \ `)QAd_{s!oxLB.Qao{3N:UX=\7 p.LAk?jՑ> ۤW'GuuunYཞ7zhlGqKl}{ B;0@)"bQF0wƸ!u $TF5k]*#/(''Zl-8ʺvą39shqIm.:Vj]Ot)$t|y^%_?I HkVƵz^V8P{]d0YkU646WX[4T(WmkM H, gMRb/{U;'^I]ny6w*kD5ڮJb[UޯpٻsG;tӿO{>PWOϩ}9K#Ւ5tb,կƆ )Q-셸y5K/?:+!!aV!&QA#bH>?֛;y`|Ǚ_0#<ҭe̎42qF@^}U!Uwģq`NW;s~m!vaNi~#Py>꤮X򗿴/| %kIL򩗲Qz9m7(jZg&+ ]_̊,߆sMSȞO+eI5; ؿ-[.[n+W:YЖkKmٲNuߠ ̺ Zi9RuRSn~eԬJ ujmvۡ:(S֥>Vݫ:j):WQEoh,YE B}GZZ\CE^`ViBdXKm4FuR,2ډDa taY֥s~S6Rt IZCzk`Ѿ(e/]=f6\v@p9gI:l92ap1Ig5`? yT |5%oop{Q`bDg.V'Qn)_"|@z[#ybT2n ZpT9QuڐxW6mVL"*jڸ#otJUrfȉG9 @=ađb:'J|M-SgIO`)#>D^\m/Or-Ű#Šu?7⣜R&J_1úmlx-]󎗧sEIz/b6USl+llɶftk[-iILZnYuHо@%϶Ԯ]-MTƺzmGb[ؖ+VΘn N%xҖ D ni}dǐZHxPM`Z?dX?f셫j/sx_ٺsXnzlMah٣%8uXczxjpfs\ks>m^xڬ]m#:p:@L*W5.ݙIOL@~x,gH@B7g+VJҷW֚I%~kRCVuNí1f#\fBKxa%xTCAc;2*|0ހX_%5HֿK{u[sdU'xbUVJF51w0EW[j˴SNHJCtW!|!ΘĖ[o{;f>Ic ̸():,VI#6wEk Ѐ< a;n`l$L/,o)Sm?=lżWudC.zQOZ i 3"pjtFWc34:|hdB"E) IHIJy|8B"3:+Q K ioIcU%âjYd)yKݸq&%|s,^S!қ0UsT?G)MAYPcd`hidMfQhD[N:!'lk`lǟ/k#K~'hO>z$ _d`oYy SmSʏsQ:'gټ+ 8Q"t})n~pMj)(q,>vUC3:?;k<_%M+%UGoHO[D:g+U_)7 @Gjg}X1K%[ST'^\+RS:¾G͏#Ŵx9o*CШqm{iPFֱ@;[%n8ɱ6_^cmgYnnҡdSdHq kWN kL*^!]y[*hs 40OqOhsG-2HנȐx"> zTW.|6H2ʟ/Is[he 8b]Cl<1-zMqr*V^~<Ӵ=eyk[0&Ř,鳗ٰ}Znɐǹ@CmE0"H.q6<[,}6/2w)VX?}EJt_^pcVcA R CjrqTr}^ׯW7s9oA'}k6`#y|͌w &V^9חiСX#-th Np#qx0lw/I[Z٪իG^/ux㎷N9 .)'.үh˦cԳK RsS^Jg0&k_U@>S.>AsF; :D#O ~6gKuD^n15a,}](?9yRt6_[EhS􅫿h@/#ґ/G.&e&M5cfGxpmPm1g[*ھrQJߝPL`~~=ٴyjG~Z9E̫Ri4iɇmd[ZjpZNgueLC6E;?}8^O^}yJb8'C mk1KxGt׵S;^`-Yp= z.e|q{[:&q_;S\|ϕ4nQLϸHGơ@6yT7yaĊl61/Xʱ/bS;frӤ˭_ ֯gZR?5Ho?TN1q! WPx}+bPY b??矽㽴' C@:ÅZyfMzNpy ~ PO=z8r ͚9Or戔SKݸ=VhN7B!Ox]_|Pݯ<#Tw0K2i3R!ㅻ*ڲBkC*;hS8%=? d߈HA MAêl^z}Q2N6 th Gڴ{)7MhCzs ۨιR ci- x+n`#v<8 ŃageuK$ﶺN~4 &pKn&hHgݪ{^\hDJEaڷ+q&Gq(@!֜Cݡ3fp {QLjttɓ['#񮭭C_`:O-Ќ~T|H]8hL:h+]8*! C"4z n\QmrD]+G׌.I M ֮_khQjeJ-3+d1mzܧuS扚@;p ad4q/N(sp qm]]u4B~B%-O?tw v8p?(("urL^kIz~/8~upL9r_s@N/ЇK_uY^&/N?&C8QGϯ`R Wg0_W>s"~MCwѡ]:i.Iorj yuO+7d9,;3a:hx%VTm_^_J!߳c my?+i37&p6-o.[@ (/+Ϋ$ޝuF[}ZMS*BS͔*muqZ|c kG8yݓ뮳6HPx+twWW”jeQ:yQW}U<  HS?t &&pAÃ(9Kǖ= /~ ;|4̌8uL0h>+]Jr˿o>=;[7Q1w/p U$#5ZS.xw06;)I7[cŌ2qLxf"g&GʹXif I2L 3Lvmff zh_מ{Boxo}ʤ()g^IJgytB}{u⫙y'3M3 >v:}$?i.]]Ϳg_uRi{z~ڵj- EZߞݥ 4QK&;vK lҘ:TZb&SNQf2[֨QHY@{C#ۑ2Ǡ w9w?W+f#!^Gb6R]̠Ĭ|FD}DZ0 Nf<@xΏvGg3|: !$krWU锬7"E c.R80kR$NIYH9mj򉸌}>i◶DRwF=]>Y?] !4M64/*5rGJjE5$TTnZ-]se[?\9+.XA^ Р '<Ҡ 8 `>X!߰mVE44Qȍ)aH25W[sO}%Ԅ /pDxFIOTԟmrz3PTGL(D=cVHK  ̊q?T3nsficgy01Qg\Ѐe+xmSFmBͭU_=Lk#xB+?-3Mi,+YCcګb,HGV{~p'F!Mo~ I Դ;ڬ~儌_?83 zñF/11B脴$>YE?E*7!Co׶kKrB̋I!nd[a@A#J~NWX-oy xGqdINrh-X 4HeE蓏 alH\R r0~9Ni/ RɚT'Ɔ 8AP֊x1"س3D͸R1_ppu6Yz>&S::Ƶme%ՌVW4c`H,MfEF~텟ܞSQo@tvs3p2*ѷ6Pi5\m=:r@1(W3$|#@T9`]oS1`ge-2׬I>4(& KVvA |9 h?Bې0F= w(' o{FөrFA(oh'uZkh!QZ6і\e23Ո7Hy|ֽ|Pu. z E#K) `}kȹs{G(xA1&O}i}ȑa`|fHX |僇u f̌nr2lf0a"sOa\0L J,@f1)xf|Y,0 Ef^=*u!,i+^ D~VdΓ+Dr=6&9v$)1iA,^qvEy9-7?6/jJv3q !I> gى'ȟ &3^) #-c|3O̊?ӟ\#zEP~H[K=:pRJMw s)-ԇ4("F5#URfXIG@r^6$B/su^kG˒>+WVK}tإbbLJ?YמݤiXJ *fzM,@+d`WjgL0$7 aLXcy{w]>1Oh+|hYBf̺\SWWt Kaſ) @Dx<N<1a-h &c`0 c &4I4%n$}5'}*Yh.sj.ƛlѥ:Vwox@\[1+ׯOvJ̎JnȂ&اb`@RF@a0 οfsABamI+>Z>`,a$ |ʢf@+}D~f0YH !g )i/clˠ^ $貑0 y0U^zc^bmm`h]3H>_Nv#1Caic#:/C: szyˎ, >Q׾2/Ă"_x UR[j3dw\>@")͸*/e_>eηm#ہ_zǻ(%*?UkfXIG$gJý&"zf-hU={ۤk~h+ڣN;O*59vԾlA2Z ~ȵ 7aΕoDe#(:D _X:C53hL:szü֠AC b="C_M!,`Ea$AZ0t MnFAa`]>(h?$'W@`d0:؎=X10>.t:n ]Kf,ucFHoJd-ٷnx2[G9&)妿&R$}Eij2 kCn^,CR2qPw9#NUJRޗ_ӜqO%B07/UXa{:#̯>Vib+Ų벯oݓZqF4e1-ӟn9?ު"ӸnX/|qXfWfdB/K=dzwK/ݫYܝUֆx?ϣuZ_d77{ʯhD2߸1c򴏿 ;e74ұ\|nQm@>-TNiA'}вBM:rYGŋdb\4q,")$ٕz4[k*7Ju,@'DL VL~8kss%,jku,g $F Ey̨LeCMiu5f:j'>w\34~M7k6EZեtLcɠ4I7Ɯ "d﵋س> tG< 0kuѺʧQw.ao.&1xrG'gͽF?nnH6wz E궝4.ezm򷮲8CNr+)+ai E(;nAхjiw>j0Ɲ?\%YNv'riIE^D9L\F;/˟ CszgmI8 ־rMGIVӻj:c*RVuΝNٶA1X*0a ~Qfo ?JG"I1>^ʋG}kISCøFOQo5a56SDn'er_xTʨgPW!.;ydWE)LuHYPm)ia8Ja 'm;ځz\mX<@}p[ѣRUk |QTlK&e+oO|w1\#,߿^ʎtq_LyHõP^?ix.qky47Lj54lXsܮe%EI.b~Уk'ѯ֊5)g`+Oְq+":RGP>XA!Kiԡ,_y)By8T^sҖ)W|)^W7 Cy>8Q*몣tq'޴qdևL-|bjuaxp.y=Tb5vC(65Vtގqo Lo )Q[ϞƇdӱw۩}x{<0b}qq1VHR︱,{r,E(2 ضkڲYScX:8$ MgH`73;d-ۜ>x)OCE676ESo?Sfyiz&,p)?i˟s7 W3,պb`98Bf]:Yb76eV[jz[^^Uhn}=T6|wX${?GbEv陵.W%skW?q1\AA#쑅o@1]<=3dq3]_p%}L: ch XOhцr55ϑ.6WNSDڨeTU]]֮K{WUgi\2TSm+a6W`[p/šY`:\&Ŭ^,##3zq5̕;^iI+8$^fZ BuZoP\bi(ofj[n53i}uqbvP:/T DoMl}Q(R.b=R@cgq p.bo&|S2zya2 2gT'dKƯ9Pla p֏ϯ{̱ 3l!%fĥsr\ci;f_WJ҂՝.^`Sn 8ZfeuИt8M^].{D#5EthnhK`k5\*Y^#G]'&^ ņb K+6rc"0&sٱ?ʅi0/ֱDX83̆0|7%5@?}2 fm{IM]xTZ ^/]dS~m\<>/FnVI}(Ԋh!;b:vbVϕk@uA*{<}18ʥylz|~ᇬ CR9@"FV +H40q=1DL uScS9?PS^vev/⑼Ta f䂗wp-iH4s! __8MRr tsB <0~Gzx8[/tK1J:&Ne͑ͧѷbI%轋 YCwhmWwY1>Ӥ}*<)a`f{[TɷǎHP'j뼊6Zg`:޺j_a-3oF(MG;ҡ%"QTҫm6XL䢼.4_CՒPg^oOl02CG:Ab} .nW_q/!`^0 A '38`7dxCڨp=>&?#|L;"j;$M[ o~ƚ5><&b(zc)k"SkS=lx>gIDu *Ѓ xY) I*`MC# ll}P> w_m-aSsN6Nb fc F|&=Di_0 NU[HI( 5`zD? g4? VED Ƒ+@^ЖUΠh?u [pDu{q 鰮Pq"18# "=+A[djGkulMPFJ\ݷkT^)toki"F AWYF4i yVYNa|;%h˶bk6K4I%֕ʁPa~ĸ?tUZĄeΔX+C}qC ʄ)*Ha0CRA ,a,Qv' L&=Ǻ[0YX(Fr VL Xk+#j*W˭;}Y y@IDATFX#Μ1әGϬ`P.N?ԭ1 fP7P$`7O~JL\̼pSxmme*ЭYImg鎟![Ю _aTU-;00vF~*[*TIC]VeR㥕{^aB6DZ"JUK.d-%5\LK;am Q"dT6@X]uU.LˉG ӃS?-,W\U!u `E8t~R<y49Z#} N$+EP?c*`8~%<@XS_0CX@1?,7] f6D15hx=Bƌj7'^nVׯǮS_w&/<>gW?֎9'5%AWG/uyu}5&[@HHa)0yv$"&o` 1!X&$ID^CZa q`87TjSL +I&@`@  FʡH0!a& NJ#0*!AO fHH(im3 KOLPQba S PZ=?]JdMuK>C ;]uOε|Ѯio&eStrKG }[4JǩLv;sQsb9EhݐAmop(kl LMn@!aruE0lH*!sDR bO<@Y/ jpgJ^bar|&hS1mX6F<̥T/f c@0`8Fn9`3jQ$_*\.7LxΖIRy9C&j̠4Ɗn4Ӷ\+*%#^} Bc=LљuZ(YxHbU0RJ0Beh<=v⨰bX^k=ke:ޮTf"aa/$Vd!a0 M 5d0K0ezBuTلQn9#kRŴ://7!^ Pl5RLJ,jH_,[(bU[9QV^eGm˼MŜ-بJQ{! cB'*4=2*f (v=ZǪib޸3}!:s̊P-yK!l 6 Q^K_޾z˟-o)[kE^"*ɐavmg5@k'3^4 YG9-WQP1l w"$fACp8ˍ3U[4 6l֞Bhe$*zJ6Q#՗jָ3mm ծ5ڸڱ=kL\2+)I4$[x)Y:J-t r3U~o N0Ta*m~uJXa^Ʃu>53YQBĵGwJYmcAI@v67 6₠FmlĴb[-T-W3F1ѧFx۱k>d]NVkeyY#yVKB} -rC#B]!Q{[*5A\_|A +d7;Vw)WhL%"(kzZ'N@"Q[) _X#!`rX)awCzVoNOE9fH!h~U[sjI`Rԋp%NtljHk"?Ӭ|.>Öj_bhd_9}Q0?ٻ 6 ! ŕW^/h^#b!6ڍ7<_qhW?10|;v]ic5O&IE^KαI߾I3xJ֩څET)d[#v:J )uRV^&i$W[ 6u:VSO̤Z~EVdeV.% mޠ\$0- I6sC>p'v6c? a"OG\#,#61shjIA2# A_]b^FY{-qmtŶFX_G\&حZr]S> g-#_Rb|y@@_R9Ekӣj:$/[i=mxvq5UU 9Y}~ dMHDPTz/u6'lovxh:B$կӉ1ol"i>cS/RCBXx* ᙳ&Aģ=>92. r+X>q=yC3m( X*Xi!=aX&ƦktHy= ._D\\Ki\N,yr%fBh{Hag~ L" 07$UV2yx3fL#&gE4h:yBC8lٸ'm*-zm:X.,A(/ G 'V6eF/=]Wյ-\F[ʶLZᐽkKtYYɡ<Ş:mhIiUALq!5Sl7۬~lm:tLFee@)00!<ňK]xqǹO@ Os=kѣ?'?I;lk-"✖cK/ 6b Q ~[r4i]M&UD_/B7 엿xa06f & ce9# 5+ҝ $G ^=BD}p ,YlϴiiU&dr16>T6ŨGLںF 11[bѥ$2:5[.#/]Xv7ZL_+?sUCuw?f/LY!!{ݐ.җ_KeկʞUٟN;%;TV8UJ"|fr|f"J__,310?~YOǓ.0j}e_Ϯ2۲)Oh# K3S/-yw޽/$hjmlt@\KnѣKR-ZֻomT"dfR_۫n-v5QqIIA{Ͼ/?A{;Nz@g<,?Ve˖^%mlL5`B 5!K BrrPCB`{f}Hl6Z}>wvfgvvUVVZiR2D\Lƺ i`art GuE9GATF~8Bq`"?m~~\ a p88Nop7r饗%( R62 "E"L Dp88s9'k:9gH!ޤNpa/q߼lˣhU6xizx!.ƃcbўenvcX!bSc3duvkRl ',Nb>W<.O"P֦Dd-C( r$,n~-[]L #ψ%YkPDq#| a0.!uhD֧ `䁂駝v1"6"CDCZ{v z i Fa|Ѷk٢ڢ?[U FG=NQ?yד:|;igFԩ?fG?gzhzkWԊ}NAܼ`у6^H5LjR0Rɥ%Se-m&l:FGi D"#*ʊ4?cKVuM"p#3Dhp%b$)d'裏dK_{ιG+Ax 'ׂ!ͺeLMHNr("!HzA[BpT\b:QNmJe SO=E2y{q)UUUOȋv^Mea'^A)Ϝ*-MAJ$;g?6@R,9L>Voal˳ X2NY,wh0B'c_Z5/ KU1ˁ5V%m0)|X3Gw $Te6Fd%-Xw0҈1 j$WZe'X޾?lb6OZև M2=uŕ}hA88.bHX#ڋ9k֬+ua>37Mb)(SfӀ_oqAZĞ&xox9ZUB,8nǴ` BbR.JH}ӻsfxߚ]*Mq5>^_Hzƞs_Wjǫ^OKÿՊ~ sOj;%B(&b]0?sݕ`ḤȌ̎89m |̈/>?{yw HTKicO9{3*'I;Nܦ=B[bU)էHjw^bD'nW-@kUA7AydZ,csH;s]%&OMRSm8;ba.*barIQ; qlյ.GWS=/ϟk5ym{r~*kOcݽ3hkS}~^p;&STγe郗&MKw X\'ywBQq4A<1>4[e qʊ#TWY dtiWfhhhw?1#Ңȇ& l~| {_ Z]Yik3o%x/2C*AVXgMLu;&q*pGm;O ]^o!O,Fwaňt=w]8?.*n{.ˮtb|{RO,O|tÖLDL5"DjLZ޺i* TrыFw@ͬ.\)BkWT]q`dݶ7 WI^l4 Hy"T;~ Ǒc v]bn}DY8 &\k$uUQX:ԙj==c^(DH{ۗykl6J'c] WfB@RD U!2v[آ&Otq)#h ,kڇ+klە6e- |Obxu +wViOc;]Z]];n@mQh!Ӵ&Ὡ2i5Vjk>~rd⥋rU#r˖҂5B{QFa!??/:TYHvDL%IͦǘLE87qtOvТ(Z2ZbTwş<ٵ]YA*o0A?#>kYf\ 훶U}Yx ~Pj`lهئnOُ@.w?RCg?m c=y'ŕ@4 ).b $\|ܲ*5 > (4p4ޏv+Y1O%Xk =:Zӂ0 ks)̦/dKƺb-Ԁp@>q_jw}tbp9Aw6Z4{\؄j؏eᎪ1*ʑ4IIЪ7haaرNGN?.[L'i2x]۷ug0~wQkYqro[ky R,a]dcB&,\ =$]hk<;a'홭>hugykֽ[s/:yI|,j;nS-Nͤ1٪ȟ/Gg 1aLU>Gbd鵪W}N N$x!mݥ[,f,$o_C\U|85KjcRbD`Ca.!-DJA;T!G<6h7 %w#P c)$+|L?~yƸ{eN; w{צ}8ʠ-â={4(nuC6G߷1-=:pce+_&HUixxsQ#s Dđ ^8-o;tۜWe}'noUyi|הӉ@}?殴>m ,*pļ 莮 BŸdS答"IPBVÃ0C@RM@碼_馄u Wm7p.=qtZͨlōpP`>=Aa_EnpCq=Co H&8q|^#7#l<"*m7Jӳhfږkm}$GMاtvH]I\Po{dG~{_L{/TL|\ڢ~Z_'C-n֊ 썟qlvjCT{΀KW!z̯$J>e8yfӵhʔo!oiE-P{ FZRk毶 wNjB(@iS^b}YmfC)A fjDPYYiW]u|U6FT[!p6dh 1zgGaHpO#R*,oCX!*itH\\v!hOD3c O^81GXb2c9C"a4dYb5,H0:S`n6wVMSM/m?^_a]ťkC-"0 L&LF xC G8\?{Թo߶qP?6x]c @}_M.XiKؽS`ÉdOr|[lM2WZ3Χt瀢8Qܘl!sR+[kdLs}Ȭa\XÁAޟ'ǜGBR"h p' l^T͈ٞQA,Zp9zHXm G%MCĢK :xE" !'#Gt1!Oq=p@"Ĕu 0 >el+ܓM\"&+$<]^n٫ MvO~f[ٻWj3{Զ,Y2\($L ,N iΘ0arʟﳗoM_;Iґ&BnL8 ES ߲1aRk\"ELdڨli]j'@|zU/̶9 [.- D$T?R;qNT[8%$ ‚6p_ya' &nQ\:Sz3 3>>lY$t&/k|33abgUN8Q#/8,AV,ױ [s)& ^S n,˾! ʎe:ObU68Xu1.f~u`R_%[Oֲ7m˖m#γNÏB# ^"D@=]=If66lݛcqm~hh/tM]t]U u"NYߞڎ"Yq5mm-P Н \E8`VSuO>?0NBuD( hѬN{w";nTmGbF1+Ac1fsj!n{gv!hZP]&A7}&놝98!N8εi[]##{Wa3J"ħ|1A//<HH('Оd#uc 49Ǒh/r8 w(^ݙ+l;m]Z䰖,{}qY~5Ho>[i$bnr nz/Go|u:֬`@ ޴A,痦rْ^2']*$0,nFc@z暙3m& zO|J=~k"\'ZQpkaOWC/886q;{pOkYm ξO#(HnBo%ۤY9/i\zepcA:i0mrǡ(F+}"N#Uu W%yw ;)~']wu*_ePzw*O=}Ϳ6NN'je1M),V9${۪OqNҕRq>&Cz)>ƼCy[,|W淼5uJn~uoTΛeei?^5Azu>Tk;X+Hu!H6O[W%VKiu+t-&j 0??T[k7yR0U2gw4'W=w^bʋslܴ6l`'-*iphgF>.JrWG?Q':840j@8 D8Gt@~;!Ŀ5Q?m=zNBN‰(-]Զl {#‘EI:`mAÑh4&_l}jD|?q(kxCxip5!~{kiLQ"mj37R=rط"4M bGWsfUk]O>ɖ76Vh0Yڢ'ZaY2i-4s̀u*'CoA!Lw  TClRes$P@lrCt ~<[6i-Ԓ1-W붥n:aV!.k$^D`jZ".QaĤXE29S3$R8`T5@٪?tec+K)՛C~+ }YQTHh"c\~ \DQiɎEW^Qx1w$6/Z>϶[n5!5r{aϟM=ț:O~ ‰k^0@~򓟸XF{{qB=[ك}+l8q*ND!fDaHdVkm^dKj{*q xt6|?fe"neH"!Iͫ-N B}'?>(HE/P_,qwȩ3Q N>޼zZ-"oeoKXsػsmzqQ;mC 61GAiy['p6AHk˦6Gk) ) IȒd %HjdEj5l~ֲ$Y jBJ̿;d 6<7žлvǍI:V# !i@V]+-`!R n E" ~6(@xb1Eʄ" ?#bJ/Dq!"PFd$(gaO%OČ " F~Wx.EXF~N^`7z}lT& VB&SYu n[2e-(li&@V}[ĭMtf_"Ub46f"g"`A} I{U:v;EHGvrlY-ҡj$[6q8AO8*<* VSL'g[Aa6OI'gCC5mwl+׮oxu=(>{Ecø $oCw>>~ ŧOc <3dk HP@RZQef:N/wO]6gF:NN@vN`SE6zee ׯJ7`ujyz`_*H!զ~i/E]Mg5|,Βu%kk_IVѮhi˂/  ̮Ҋ7|L!뉶qjkڮgRk 5(Ԇ\ =Յe}@Cka.bmqXK#{uiʩl%ִUkٻdLJMZ9)RTZg *C 3rծީM>s?;g.EmDkq{Hqj;%4k7bdD3< ýRɇw&KWlF T p Drf C("b=srޥK/L]xǥӉGBTW\|Ue Ï|я; 1aH/1aΏouSiTN4:g7lo?SE p|,< hVpeMJ;Sl˚նj[3ko(v_ ˗XQִCҮ]@Mš5|WT3J C1T?j\G]*WV6-l UUk.Kl9A{7.oEċ۶R\bkֳjƤWtN<+(BZ[%!UcLco֔Euҳm ^"{ Ow6kt7\m Ɂ 1u*{mZ{YEڌXzBfkx:gxNػo$v,̰7D:$H=,ֽ:'Os$ {u/~+|u/cxS~1~ݽ_, l!N&8hH Pj O_(*sed1Y6KtV۲v]U3gYTY"3a[VPX+D Yl ZVoȔY^^1,WZT.dYa]jd~eKpk]JBݲfm&5l**z#{6o\ZDۭtת.jަ7eK9ƋF8&Cњ]ÓV_pYbPKh/ y 2#fGŰF;%͹05":ԲE|s|kcSx WOׄT|䀍F={lg/_l#WY1W3W0}G޵^4.8uM\DLT`Bp0Ujg; Ybur4ցp6Ź-:6k3w,YTXZf%VдI$'E_qn#J?*¢gM2$P[Ԗ5_fFۺam]Ԃ-[mv]DEִ‰Ri^V8JZԡJ3D?ֱ7N񷻶#Ca*A,:~֦ڋ0>~ G% ^b~\a09I:b(J}C@[ xw֫EHYT u0@l׶-D͸|{͐˔ݡ}{t{{,ˡwoS3:Z%N=}6a2'`0,' h%˦A%01=GE-{' MϦ m+WmD֮m]fuZ{9F ۶EIi++R3)mkĀ[I; -7_P̊Jt8)+j̚HkuDRߚ(ޮF;3ըj& E9TouZd; 0߆bh_q=Q4Ř7@Q!B(IynLΏ?Ű0.?U:5U6uꊛN;I.ovH2W\qqb,˳o1hN^Ab}p .ҮɠP,/Ͷ4S#0 @lons:!cCϱK$,5f2.GFLa&"B6~)LXM,Z?tf$zܨ%Y(Cת\Hw_X&EU^dl*dqFق5<)BϧPKdErD},0:.ۈkGAZ{Sԟňw=M09r6#?ͶCx [aϿ>zzX6- 2t<}o}`X7\b˽i؀;9@{|`1f hR|Y_@IDATCxI'ճ3c wuK!E 794\@.:ٟF8׎, J};&DH˂ hEJtx>qyq_j#!f ZqA{ :I}ݎIA#"{0鯇9'&ǖdύk۷c} tNCUϻI-w\9b#8mbQXa׿(0"cf)c/M7@V+=n[$/~RGD$xq  FXn pLӟ''(N`+Giրs\h8 }2W3kcxSsㆍv}U?p@כ- E|هc|;@;#ASqZTg8 w\6IF~;m:HOaSu%dgC䅬p_# kٕ_L3}GLPёiDW;=v<ҏ$$i[L{u*8Z~DԫW ٧ž\zUM &*-.eqFښ+kg!d~Υ 7̝nϑrm q6wک6T(]gI;{uDC{&Q5D;Y{7&w}HS7>,GdO~; =uS͉ m8hG?oYSo#!>H!Bxw&Vv0}wd Y WUU a!vw<&Ĉ:@hp'a`Gx7w{*ѣG۷-=׿_ F:by#?B;_ٹEienf]k̩7?yuB2nӐÌf-1Mu.i8dd>#^:̮#~=P;f%3SѾ8Uk]xۓo}/*8HfG[ʛzܻ.Ԏ9 Rw~Fy2\yEO}<3OͼϬ6ճܑ 0w*[חS|Ȭݺ=so_ɜ#"9|%csw-.O?͈k|_v?c6 32'23g87^}U#eCh3d$( BjH2q,=ql[C"pu/q|Qoȑ#3:P?ȌLzF23'*!ˈh1xb/sujw3~cߎV9*oi 5SuG^gϾ5/ KH{I3Iv3 f9dqĝdm03I&W^YSfeunVVPY4i"`(>}tg1KԺ;6 z]h'83!Yfy_t:Y|~XG~gC6e6j(qr{F:e ʌ$ig'_)bGRg%MWN78# !g[L׎mͼBwo;wa2&Z[Qx۞cS'ޝ^>x|2I$!alM?t<Ec(\arn`t-Jw:.p `ň803 Wux֭]<)V<^Qp:hb5:XXÞ*G5Zǰu=:;~}E?sԍseDw!h=vX _C-Z3Nñ<|.R==tTSߙo矰܎j,: 5BA>-#`oo]eUVV`YB!` uѯ5x@'2w\6cwu|?#=@2 EjofOoaw'X8!~'Xq4#nƍaGGyNȗWZ;2y:g #Y(k{h*k'%jy;6*KWNCp4Hg}']LWq6aGXA m}q{&`ٳVɞxkpAgr!|2RZa4r`dtx\'\̀^p,p Cȑ#}K_ݏR8YX0p ,by/Qx縒QϘ1ÉA/5X Eefc#1e͊9MNYH&?;ӣɋEJg[{0yyL@֯ 0>f׿*iC,]MM2D҂BI :wo؎EݪGdzαt)Gi4v Zb̸vJYިAiz=cIME t,Jznr?Gw֓"bSh#2*`xu^hlVD]Hp"+?Dm̪|AFfUUUN p${v$΃áS d0QDKwS!&I;UmhÏњ_gϩl;>{! q~ec&-)ZQ#N$8;#m9 O0}Id'mٲ1HGy>kh6aeLxt6k~nq*>*'"Vnf/> +f=/Q>s:{Ky DHaJ_^&x ҿׅ|b1y'Q6&3-',21!jWGQFP:݌DgGV}"w٘Y+m֩Lm_tM ""V"{rXi^ӹMxY})#DZPxtl< NYHxl&:" Y0bE G $bl T`q-3C\q0;^NџϠp)qtgڡ.7;q`g,{6OYJ}@=s<6`W^VQrm/( Hh2i {͹v֯[oQu܉Kh"DF >?ΝB#G] 8'导NGuՆI#O4(ryYzߦgm.U y %yx6Cf6j5cf.V1B8 D}LR#a-JXGMKCXw~s-8qar Rb8~Ij(eڎqKwy6l0_'츫%FY"81 (NF yUUU9LZJU:ϻCcvjFc>0]Ec\D8_y<8Nb<&D;pA8=H@W<O .?g"XH̢ Eϥn+?q h{h9FOVyf=񋀅M!OCPyR.ݠ Č85: iNzOAp tȎ<>4T{3)ʁ-ug@΍5~fI^ĉkzv3ݫ.Zn٢ȦI2ܼ8p*;)|CU3|,#ľNk[oXNGsFp%]bI ޚ~,1'uNY9P l3o=V.~Gw#s|X/vWv1t]+¸{~ sW,0ץ*+9' Lu &ڡvil ċw~qci~[]g;.yx(NW+֏Hb:4(ǁv"uC6.vsiU2{-ˑi;UgixѶGf+QP0Zkٟ^`> a4CGGӞƈ&#/϶ : Է)B-3zڣ,ߎk ALj#&(q J$$i+ie_Ʃg \2Pc9C$]\ 1?ҌzRgy  'w_5;2-Z~q!մe5\ik̵z&tz7%+6ϾgC43U3gE+D0.HyO2j}~[{i7~iEW8| 2McuJ;{险6}xҮ.~{jǫ~wv2.U'|:MO.?}H];Ni Vܑ8 .~y?]9>Y=q&:eĊɺeJYݵf`7L;^.ō1WU:ե馂fAI4LsE Ѧ|IvlY+"^y7#u$323{%k {ghTkŲ4ll# fD:U Nem}y/Y/sLt۹4ՀXXq:V͘i[w]<2G5Q"}v]2Uҁ+<:f'BzRdlMYV(Wˑeu#[ 'bޯ5q*G_J8ɾ3ًSScf:)bњ-!/zy~8j /6Jt~l\ý%|aU:u'k.Fd$T@47#4D"^ljzpgmx,2#_{ԋE Eh"A:߮<*hKs#T- b^8샧Ub;;dOGW@}|#СB߼u{+lVlm^[ ۪L*<3Xljٳ+{WN8 Ƽ-)x)Iv~}fg嘗`0Áz0 )OM6XG%\{vO{nb{|1/G8fl{}[ k/S=-Z}j-H1Gk>;2Bx@7#2>8ˢyQU364p%Aԁg篲mPx=@3zML ]YŘşō֮X0If;0T۱u4e}qv[i#2qa f6VQdXvvksWG衍B)(: [cWU C`]mvFQÕu %g$oFw i-o]KiiʝLjU[67\ -4hS sHb}G%Zq@^,4QdeyvX wmN`5^j -}32 Oe&dceEq0O.!{rJvʱUsbۈeg]DZO4e'H(VO~kE?' b{mߦإ;9'Hx[%:&Ept*i㞿b+bKĤ!Lw?0h,p ୵X<6gDʡ%&0!+BBÜ֬u[+f:JsP(r gh'5^ŕ}ZU{z[&8z_̇;ҌBgՃY8P_^~8XoW}|!ߪ?S:NvĄ~ٲ:|ݩ폣Rǡq avj~@$Jglp E텩+g&:X8kwJ]5-J0GoQc B8; YJZ|t5U.X\Y+*=4L7fvZޫ)WY&-ONw毷5Qf B(39 ?$=[/d !R٤I߇.yS,Vױ;kX7_7~u B^nl\Ua_t9w R h-:3aޛZCO%rұ 2|ÅX6.>4#"nufRңޫѣVGN Dk`mˊ5Z.usyD:3SnX<{~feAzq9KBgB++c[NֳppW~Hz!/OY^emu%:X6M7s9 !^!mģDHkU4gΌ0tHq9--/^8r}ꃃ_'D"> b*҅*.V@|};?13ͫ'Y* F?x}S0ODNLdãn&γAN89%m"z\ϚB^f֬mǚld?X6¡.7ӡM\{6.9z0[lqیvPIPBZKk=c뤴OcK| ) p=H8Cmkvc/ثq#Tz©{2E4江-ఛ`H:PڀHa^惧^ezf=”b hZեa?uEKZ&iFH|nkޡsmٶuZHZ وJaۜrgO[Avb^fWߩ8 w,=hdb&ۯ_i.:Ov{ͯj.3ke%;sVB4XAM# C5m|9 [~WCĶ[s܁v'SoUp6FCxuS;#`mZ[Nv:rm[+ȤӁqlJwNN]h[G\<tQ;- q)(Q )3~$Tɮ>+ĵacV9VW e7Of,]3P.X)& dFKx?[G ! !vCGR_+8+q'_UegδMK' j?~aSӻR(V9YpN]as:p-~{qϳ?֎RjvfZiBP0* C wrٸ9~SOo Yyzٻfo=54)a? {g(J껭h5ּKmkr>X/ ݦ1 ~wk֢PN^%!Z;[ /Ș %8O1 g津Z+i~ኡVպCNٿ^<Ğ~[DvY+Kkx J;b[1J0BPwjm_r8+I V ߢɩ#{[p\شY^=ömXH"PS;~k} 6[}cuں,a#8f *ɩv0[ަSj g']e? %tq֏M>0>69; H + SfJ7֯G;+#.ffq+}مH 0cץuz}̲9 VXfEİG_\#ul鄉Zbjh1n z [wa+ڿ}xqvXc1Pk)\e&ڧ{XYg^5LRN$9<"``-,4qޠm[wN D@ -s!okޅ\b_jw롲} ?Cgڒ%Ζ++=\[{7BM63mjpkھW`0KW,uk&q>Nf|R.45r'řz9/Gb }>"5]zKm+بaA )a C[-%mv>7SEa# .=SaZ'RlELĈ0Z`߯Nc1iAwm[n{AE:.5oqD4 f2g:7셉KR:oD/AITs7|+6 D\JtfTl k_cU#1[!8Ғ=oucϮ=~4[bjc-Jnv.<"e˺5tmnuRO6rJ'H6|Rv|MZfim[>2FCdÏ=B\T="4^߃R\͑!R \-IK+إѡɶ C <7lC4 V nJsFi~`s@5>ǻJ(Ё- 5CG7mBziEҦvKlƜ֣s kݢćR$smY–uloBY:ov( !A~k}7LbxpgؔOD1ɸ1N@;% |g L;}vּUX 1k*ycmz51STL͛'h " ?>nhxUsV#űʧ ԳSփڶmeZ+j|SfY)5x="m2%xb۲eK6Hp<||`0c`8 F4pvyw&{߲ujl$tv%VrUtlM+c|o$8țT:,=2NYnvgo1 b0ݟu;rZP#W]Սxegζ˘:[nx7q;K3N` $Nwn"uhwQewl}KE}a. :]ޮR\&۶kfoo}C)%OfܹJY_ n41Faț8 b8s scPWjxX[z}^'}wb7+T;h$_nvtnf,gg[g[<)D(k !J`"`g-v&گj kktu-G|)Pܶ, S \qGicV٪,nCTs7 *>^pREYmBAD$!zXi KWٙ!IF=઻!$~\Dc aj*_~N{9ۭSN?&L`pTvZ׮]iʕw̘1:V#9K"M{m/͝;hM>l&MoW\qx9⫯2Ys~zlĈH#nHNnxMMlڍvn;. D8X"m%12#6[S]U?hZM o۟_g;Ү;o" 0rqQ6] p@"R_9 0Wk-vӓb#ۧ/;Vye8s#pYAc0S1\V=.lmZWd殧'ښ,5>l.Jе'` yf纸ws=ΕMYgmo:gu0B\c-WK-ލǀ{Ii/$)KH? B HH{`z1nK%Yw}g= ,{Vl93;?<rgʼ1+++X:eZ,+Rn&Ȑc=Vj-tWŋ4ﲲ2Ƽ؟fv̼1/ gɝOn ;UIC Iv|G`-32H:ƶݿ-ao m؅}G]_)߽`|c G Dss6d_<1 rϣ6%ɍW.5 tMmːАPRz]w)Gdf#dTOO=Y*:kLNRՙ~8C?0? (}w;)%?WHAFCd]"Rb"c/KYE:3b-Ў;42:+7ȊV'xBZ!S|Gos9G7l YYY:_G}JH)]y<6%IxHΓYcǠ`mGK*RX8Y2_ѩi?`Z13<HFB[AFi^쎟m )uXƫ!_ ·aw܋cqQ+75C.9mFG<@F}4g` :|h֑i|MH/?NlׅR/_Xfc/=D|fT;<:A w}W%7j^5رC/_*B%-lӃMݎ'x,deĉUF ɼ<Np͒m+T:5fD/}<fמ;'ʯAvy|y(LDb=$iwGPX{뤩TgL`, &w}mIX}#:n,6X5^Pc6tӢΤR`qHE}|9ɺӍG KOF|"pC xCҁċ‵/]Pr3bwl[| 0OC^GuK*BJV̛7;W\8w7;.Lh4߷Пo o'Fo%@ %hsw@x@ m'KƘf̏~r ՊMF<#>Z܃pEX0^0㶝d_G>^8l̃*Gk%FF)˖xC?***Ԁ^8aя~y<۝=o]1/&ДN+cn,EM؆l6NMTxɭoC "``Q%QҊ5PG6bS_R{jl(mϚ*:[(a3z!U9aX!؃jQ,>Qn\8iv1Ҕ@o*qʸ@1$oC L3ܫͮZb!8xzΙ+3^ @BG먃>]fŃ+xDCɆ  $̚-O 6~aٲ:^d{v)*kjy,~D" ~0X`nGQe"D/bV&y2.2FqzH{i,iLp 7̋2G &=7!@ܤ*d_R5'?nBik^L ,(Z S2Cñ2o)Svl9i~BR\IYup]K˗nLa!2cpab9a1ʔBkU4ȸF!'O+W.4hiiJ;Q[x߀~II jvZ-]^~eS;%??o&Fo8&T!iXjqչseBNޔ5GCL1&TPz-1qGI <&o|AZwɘi8),(,&rΜ,JT4+eJ@d̏&E±c#iƳk;nڵK籦N*Afb71cƨzR e"[[dqjqmSO=V̷Lwݒ~|N;rl5TBA~asm\0G>w,rˈfpc'GMENЧY_|A{Le2KHHy V< Uiu|)rISp56:79iЎsN6@L붨OR,|X.W,'%ӡ S&wWqs)F豓)eYuI1+ϰR\2!E:s7+G}q2`oݦn R;/}_~e]FTyo+= ]|VPBƠ='P=^x@T gO2]>'dP|+ܷ]R 5poS% ߐʌҹyT)ѩ$L`b5w KG^zw<yW`tq$xMUM 9fjBR b7-HKieSd,& 1벩?N`IADeƷ93~ceiU{1YJ?dٲeZ: X;0g(Q%HuնZܒSqX30Jc>=Ki!8<l2a^nT#wRL^x<ߞ _\:A.^1U&g88'?Cs1yB^.Va4 k5R9cv|ٲGP1@aHd`הA'LU%lb9q|t9nX8(ݰ'nug555׀94w6{;CI,ÀQ1*;7)W:MVa 'R5CbN4hp.hHR?Hd&)|Er걓%~4* %.iw4jp@(mإ/uwv_^*\{Nx. z@ eYhO!xhWZُMP-̔ϟ1]qVo/?r-!̏]d`X(!:1ªyխJd v*Sd c 3u)MSjzsq#ndjFW+!̮QJ1yÈ,\H1MW ˭_^.(l89 F9>i .|F=dQ*PFxm<^ʌsz%e#:)_fv@tMkl/sC w 2.cva.;7Kd4pM30וu7: Ƥ B ,1Q5B:`rK[&9cV\|,BTj@&H$訲2(Gmt\̞V\`++e ,V]u*cPZۥ 9KX10tnEʦN,-{tcs`1 jE31D@0g@Ff^P<~T/ mr l.&i FƁ PAm'i!`obPcI,2ðkp<9cf|st dA>'Rߤ|;ߕ . ֙5%yס CI txރH`W]VmYy0i~M? 3 8D"as!4[J7 1!:Z.=ax䦘Ą>%2a& *ccЧz]VnuJ?;qDu{v@C`^t̋Gd2TGlxyqKɉKO,'. ꬧g4.y2f}jy0)ݔ]"%qh  ^ֈ'w`J#J.]:IN;n^[ Ёb0|˅3cWJPdkvQs;Ԋn.a:l/B;;f΋7!Zb W2$2V|8GBR%'LS.܇8.EtG"S"Y4Bf,{z|Zy lN-b!%I䘊#6bQ%q&$QpV 23S ]Y6 QznÚ]"`܅rv9~bPQ n;W8D@Q"?v _Wo,#%kw5)r 9~sk3RtkȈž*0I2xSbԇ*7wseJFOa~̬#4}6AP,~q9_W^V`=n H{Lź4cUܷQՕ`xq8ܲV݄CMgSL8%sC :N*oנyڟ҆N9}^ k,aB(>66JDR9l5tv ͯ$*H7>-O-*dŌ 9Vj fI*wVG ِ9y9mCH`Ƶ%4t-[% AÜ&aa䥘ɘɌڏGX؅Ɏ͑p)65WI=ˤ+/i_Q]~6)bүЏVCtiM+v4Ś]YN&ƕM͠K=4zHy\&w8zx2~h6N:Ίq V<05]8f,%9[$hE@՘=M`|g .GƇ#ag`RwZ\XQ/3s%yr\쀟,]8R|T`sgBJ2GF<@1wH?9 dߔ، 5H|4`7\o% ܙ L*H\bV&'OM q-+܀hc-cgRwg(=PEx$Qk*Yac0oqdF=w#xS)YO8謷yG R([a#΁k 22$IV`Ij(*mw [vqΞ-{QAcxԀ;ߧBpMͷn[JtV㌮+v9y&$%dLIK4(! 44@9EŢ&8ǨzɇiżLY'K*^|zyY]hA3_p 2 V5Ԋ՛xO$c_^Iׂ—ʒN(sRt*fE2.]ġ]Hna>'طuي`/%7$cO[!{Wf>IC@۳ߦ}à/ߪNٺHޛ gϝ1'[N?&_fM̔gM~{{Zj`3!~GUÉ%Ͻ+t.f¨S8bCQ.,[]&˦Z- sP/dzAD&zE p b߄QviU쮬v@|Fڻ}*e-0Oӹ>(u$K3d^;sX?^FuvHb<FZc=_7f@t>|8Q7kh2.>.hu+ U^rF%ǎe Ʃuih3`@CJXw:O;XH86ma{i6KfA ;*, ļ4Iv=B!#t> L'biv:Σ˒%?^ , Med`? d7x̃ `sW$Ѿ zSڶJf_BuOĊ|8Y|ullxqɘk@.m}>!G4t٢}`m5D[܈Q(=THMl\fĺFVE؁(!݋zpPP+E5BQRq*)9r,L꧂p%f _؁kM·fl5?/^217f22M[e24;U=]RWy{do[,-2f,YW!`6uEuU1!mZ>(o#uIe̙jJTC2ETa*# 1P l $'*NOCi쑢zYR%uت lY 钛Ւ?GdUv4 w#sn;`BŮK;ecAF6WtJh31Yx` "bV|k'ŕͲMvJia~gˌI2>3^#91sQ=#{0ԿR~V;TɶYlICG: $=_Дo>|T=8 oE*Yy6i{`t2 r,FC鼙QFoUEnaz$/q,* e˔񩒓+VWnRk4"HΏzh W-0\ ?meupkuj[: I^ . c$3sdvI$9 $B64}䌩Io3n)ޛm-HAuCr[ f@86#AL)- MR* k~M]qD` 5 DB@AO-({ ':~kAxl"XP?`ӹ釞bR%İC#dG?}P 'S3VǓ!uF2QjY<`Vϋ~w; <v@|@3> bZɳܬECwC,]0R'hp24ʒqX9_# 螣Ͼ;dxw>" E_2ɔbS: YP5lL::d'Va/#5%MbG)؁%Xҹ_M-eΙ ]|2+/f,03Sc\RHG{}G'8oHlEDк}}UtLi܁q(8xwJ%n_Z1}CMu[s }>fP77H}siy;dcyl^%ƥIvrtrߺw?i7@ZI7.3+ +>YJj$>'3pR\yVd$JBIKt4 O? \lWQa֑_z }rUBu?al6=<@BZ;6X~$H1sd0,i0<`:/a۽`UXQuCwl‚Vփ=eU(MMdX!2hl=P-'|$ΘuJ>F $邼'6߈|x hA0s"}n?i]PoY#vJQm'tlpBƢyc$ 'Sf`\c T,.IT N;O` |2#eS2k$P]j1,[*[Kr1o6V1g6 /j'] (/@vʩkUw#*ϴԛ<.0e(kj"8n0F4¤bls1>IO)LQc fu{~k#OfV>*e+ÒT$u0"IdSsJl3rv29Of(*yBX?^~YQW|3lSO+5-LJKGT7J+bWTn \sZ| }3@b - NkrsG;@%.OS U|xOeA"%5`f% āQ+ 9 #)%QnCYZ+~m·#T5`4wx4Qύ`-Uf4m#jf}z@;{:P`CXX$Ea~$$xl %$K^.s}{١NPZ|ݴHDTS l!PE5f̟i:9@Nk"- N+Ε cS )JR|DF#1j@uʴqSFV74P~:A-Uw-4Z殘ճ\3* \Jk:T*,.`c&l+3eִ3Fa~4HX(XIHŒ a x l0 v3/?kنx<4@9:jlE`h% ^z]i]JbLb+q7,c3cU ~Ғs~d +e(+0՛)N& 9~N] .&k\D_Nf-V7qU=U]ST;{T5a K-"/4A&fcN)URc"*"kT#zݟ e]Ju-FyGƽLǓHgBKK|X2c$5)A aDE"(pA+.9׬Gݵ);a4Oe8 1N0zHMR %ػI7ϭknX`xe$Y$K>6X,-3U` L֌@c{# (Oo^r#N];;A6cZHiU?QJq$03qHbvJ$Zdŀ0!QKMu;I.00du-uKUC/yyT7wx5+OOzuL L e&;5I@c*j1FnAЃ8+ MU]LARrLUSfb D*7nmZ:K=I0 vшMhy

5T&&p 30 ֪{`7?>ȏ7T,yDD&EȘG$P;4H aF"_^U$&kGH4HG48";hL~qݏїn< AmP3HEo1oz?:ڪ9dħphycƱё`@Azȴ 'b>#zcP *v HI&AID  t/Sv9@y y{1ޅ՟ ̀?1Ս=@|z$y&FHPCHƔ3S" nZΝC8d庒I zqp ,#G#b Q䍇ZE K'ғpLLzv,m4KC^كMU}`qJtö6iN8 x |yƁ <Q$%703Jn\HfF+U~0޽# E\RPX6نLp{{0@ڇ8vd HSY,&ŁBa]lj1jAGֵ#:ၗStۑ,|XJby3qd@#suJ5vvwK'F lciD ;aX*E>$T>2< sP6@:2h0C3@h1&Q)Ĉ#$F$$0H<P3U VCb.<>%:*F3ҸX!̌mc7 NND\G< LxWd0 iP[{Jt:nnCeA_GaL).ZNLGJTݕXNs>2^WapcV~CS: ='H&@gl"} Ёb7h,q|1Cυ/_;᜛yw%I?"8p} C?vAi5 )?AJvKsU5"`;Uݿp?@P`2a}^4@V' .! dL>Apu?\q @N3u33{ `>R;Y{ q8F`8**Frr%2.jBBïy >Zp;R#q>XLf&~ٺ3}[c92- 1n΃9}LrD獓6k/z־ nz- KM{}h}cIO[`=氄ЂB?ք=i/Q0䈈<];-`lPϛW}#ΰey @#Eʐ؊Й. D=!  A!E鋎r(KLq㤹R:QqNqqn̓leAc`èz8'$C'9}O^T\yndd//>jAB"#qA(\Z!]&7[A@ A Br`99vE=!_"9Q+E:`pA`BoU~ z AP!`zQȧnilh&4JgFMǼ^ ]{{80ҔJ``ϷW["FbqstD@*S!s-< <6P p!@Eѓ_n(W+ރ'><x p Y!-{z A'g% ppPc/fڱ_<7 Wvm9KPlc+w#7&9)W&Cc`Cw¬n$sN. ~Ҏy(s޽{ԠG"##`$wC ᯭMv)EEEd`1̙ _\qo20xue߇z-cjok7JuuVwߕRW[å=CރQ? 2%ڴq|K_rW+4=o߾o/UM G\Ӻmރݖg5>Ngf:n0׆[Vp[MgܴKv% 46oOl6AY.ۼa6.g|:u5R[XX6bN%66Vc,90#>OCĩ;vDǁ6?~ 1#[/C ׬YT"HMM+nTf%WJ{=$oPe}M վɧ>)e^d.=WiF㨜̐oWf =_R@Fpw',dowSE206}z%a$7|xr 7(<(xr(KbR22JnSbN2ye`o~zYdOkY{և—^zI?)83/ˋ/(7tSf [$;;[ U^^ROɔR3ϐ6MaG,ϗ9s΄pyRUxE)nd a_ڟ '|R,^2': "կ~Q^{L5ˑ9Gx\bO@$a/_Z_>} *嫮ay1:5O>0_gGK֮]q~i… } 2.q;$McaA"8*}f|+_TF>0$c|>HmZHc;\[q w߭~`8 /gRG`|Z>H>6.X&!N?t}ݧ`ԴTӂi4|P4R|i_AG0 $#T֖Vyǵpǝw U d}\կjz _W\ ``A`_z0d{|Yp#~̙3G`>0P6_}l>z/2͓8vO<7?pd~op,[LG f*0R |+_dU5qMu$=#]UL̋:UZ¦ vh"UG1SUgyVUG0+a `1ch'Tg1~nNe~sϺ3.N;M^,jPƧn=| K.U7**:Jr'pi>E*5J[?Յ^\Ŭ4>PRv8mƧ]Xɾζ†auUWI\|J~FJ.F*ɓ'kh h~gp$Ji8t>lUR"$yP/U{?ӹGIst)XKHK~(wx*AWGADTs;2H$<  *8HHHX1V"0n}%u3qDUW 0O "8 ?1窨bt?BbN?G1OQDg6qDDu\ դtLɜ97E8ѱ<n6 ~τ' i4u!# yntTcZxu.I|^'dfl915heZXяqX&gNc^L~gkm(pNy`x20IgOV[S7F`|KϦd])5XB|mYwo;㰮td1e:􋉎rȬ8F\21Hnc:+zNQz&hgkܟєh`aC0#KkH˲*c-gӑ̸@)EYg25:Z[̏j`% ȃɩjFk=`]hS7ںQ:&yTjb:JO#%(2)c RF+d<$|Tw>up=y#_W> #tm09._Svyꩧ4 UG@˕ّ<#r}+qeg?Yedr#oZ1 Gvq.Re$$7X+b ]T8t̋Ø@8vхi|)Բl\nˀ,D֗r\|J·zH9>3sގ&vNimb4`묳rg\b@FEEF8^z~(wNIENDB`bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/000077500000000000000000000000001305314114400211565ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/README.txt000066400000000000000000000012101305314114400226460ustar00rootroot00000000000000This folder contains tests for the P4->C->EBPF compiler - cleanup.sh should be run if for some reason endToEndTest.py crashes and leaves garbage namespaces or links - testP4toEbpf.py compiles all P4 files in the testprograms folder and deposits the corresponding C files in the testoutputs folder - endToEndTest.py runs a complete end-to-end test compiling the testprograms/simple.p4 program, creating a virtual network with 3 boxes (using network namespaces): client, server, switch, loading the EBPF into the kernel of the switch box using the TC, and implementing the forwarding in the switch solely using the P4 program. bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/cleanup.sh000077500000000000000000000003301305314114400231400ustar00rootroot00000000000000#!/bin/bash # Run this script if for some reason the endToEndTest.py crashed # and left some garbage state ip netns del sw ip netns del srv ip netns del clt ip link del dev veth-clt-sw ip link del dev veth-srv-sw bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/endToEndTest.py000077500000000000000000000307331305314114400241010ustar00rootroot00000000000000#!/usr/bin/env python3 # Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # Testing example for P4->EBPF compiler # # This program exercises the simple.c EBPF program # generated from the simple.p4 source file. import subprocess import ctypes import time import sys import os from bcc import BPF from pyroute2 import IPRoute, NSPopen, NetNS from netaddr import IPAddress ### This part is a simple generic network simulaton toolkit class Base(object): def __init__(self): self.verbose = True def message(self, *args): if self.verbose: print(*args) class Endpoint(Base): # a network interface really def __init__(self, ipaddress, ethaddress): Base.__init__(self) self.mac_addr = ethaddress self.ipaddress = ipaddress self.prefixlen = 24 self.parent = None def __str__(self): return "Endpoint " + str(self.ipaddress) def set_parent(self, parent): assert isinstance(parent, Node) self.parent = parent def get_ip_address(self): return IPAddress(self.ipaddress) class Node(Base): # Used to represent one of clt, sw, srv # Each lives in its own namespace def __init__(self, name): Base.__init__(self) self.name = name self.endpoints = [] self.get_ns() # as a side-effect creates namespace def add_endpoint(self, endpoint): assert isinstance(endpoint, Endpoint) self.endpoints.append(endpoint) endpoint.set_parent(self) def __str__(self): return "Node " + self.name def get_ns_name(self): return self.name def get_ns(self): nsname = self.get_ns_name() ns = NetNS(nsname) return ns def remove(self): ns = self.get_ns(); ns.close() ns.remove() def execute(self, command): # Run a command in the node's namespace # Return the command's exit code self.message(self.name, "Executing", command) nsn = self.get_ns_name() pipe = NSPopen(nsn, command) result = pipe.wait() pipe.release() return result def set_arp(self, destination): assert isinstance(destination, Endpoint) command = ["arp", "-s", str(destination.ipaddress), str(destination.mac_addr)] self.execute(command) class NetworkBase(Base): def __init__(self): Base.__init__(self) self.ipr = IPRoute() self.nodes = [] def add_node(self, node): assert isinstance(node, Node) self.nodes.append(node) def get_interface_name(self, source, dest): assert isinstance(source, Node) assert isinstance(dest, Node) interface_name = "veth-" + source.name + "-" + dest.name return interface_name def get_interface(self, ifname): interfaces = self.ipr.link_lookup(ifname=ifname) if len(interfaces) != 1: raise Exception("Could not identify interface " + ifname) ix = interfaces[0] assert isinstance(ix, int) return ix def set_interface_ipaddress(self, node, ifname, address, mask): # Ask a node to set the specified interface address if address is None: return assert isinstance(node, Node) command = ["ip", "addr", "add", str(address) + "/" + str(mask), "dev", str(ifname)] result = node.execute(command) assert(result == 0) def create_link(self, src, dest): assert isinstance(src, Endpoint) assert isinstance(dest, Endpoint) ifname = self.get_interface_name(src.parent, dest.parent) destname = self.get_interface_name(dest.parent, src.parent) self.ipr.link_create(ifname=ifname, kind="veth", peer=destname) self.message("Create", ifname, "link") # Set source endpoint information ix = self.get_interface(ifname) self.ipr.link("set", index=ix, address=src.mac_addr) # push source endpoint into source namespace self.ipr.link("set", index=ix, net_ns_fd=src.parent.get_ns_name(), state="up") # Set interface ip address; seems to be # lost of set prior to moving to namespace self.set_interface_ipaddress( src.parent, ifname, src.ipaddress , src.prefixlen) # Sef destination endpoint information ix = self.get_interface(destname) self.ipr.link("set", index=ix, address=dest.mac_addr) # push destination endpoint into the destination namespace self.ipr.link("set", index=ix, net_ns_fd=dest.parent.get_ns_name(), state="up") # Set interface ip address self.set_interface_ipaddress(dest.parent, destname, dest.ipaddress, dest.prefixlen) def show_interfaces(self, node): cmd = ["ip", "addr"] if node is None: # Run with no namespace subprocess.call(cmd) else: # Run in node's namespace assert isinstance(node, Node) self.message("Enumerating all interfaces in ", node.name) node.execute(cmd) def delete(self): self.message("Deleting virtual network") for n in self.nodes: n.remove() self.ipr.close() ### Here begins the concrete instantiation of the network # Network setup: # Each of these is a separate namespace. # # 62:ce:1b:48:3e:61 a2:59:94:cf:51:09 # 96:a4:85:fe:2a:11 62:ce:1b:48:3e:60 # /------------------\ /-----------------\ # ---------- -------- --------- # | clt | | sw | | srv | # ---------- -------- --------- # 10.0.0.11 10.0.0.10 # class SimulatedNetwork(NetworkBase): def __init__(self): NetworkBase.__init__(self) self.client = Node("clt") self.add_node(self.client) self.client_endpoint = Endpoint("10.0.0.11", "96:a4:85:fe:2a:11") self.client.add_endpoint(self.client_endpoint) self.server = Node("srv") self.add_node(self.server) self.server_endpoint = Endpoint("10.0.0.10", "a2:59:94:cf:51:09") self.server.add_endpoint(self.server_endpoint) self.switch = Node("sw") self.add_node(self.switch) self.sw_clt_endpoint = Endpoint(None, "62:ce:1b:48:3e:61") self.sw_srv_endpoint = Endpoint(None, "62:ce:1b:48:3e:60") self.switch.add_endpoint(self.sw_clt_endpoint) self.switch.add_endpoint(self.sw_srv_endpoint) def run_method_in_node(self, node, method, args): # run a method of the SimulatedNetwork class in a different namespace # return the exit code assert isinstance(node, Node) assert isinstance(args, list) torun = __file__ args.insert(0, torun) args.insert(1, method) return node.execute(args) # runs the command argv[0] method args def instantiate(self): # Creates the various namespaces self.message("Creating virtual network") self.message("Create client-switch link") self.create_link(self.client_endpoint, self.sw_clt_endpoint) self.message("Create server-switch link") self.create_link(self.server_endpoint, self.sw_srv_endpoint) self.show_interfaces(self.client) self.show_interfaces(self.server) self.show_interfaces(self.switch) self.message("Set ARP mappings") self.client.set_arp(self.server_endpoint) self.server.set_arp(self.client_endpoint) def setup_switch(self): # This method is run in the switch namespace. self.message("Compiling and loading BPF program") b = BPF(src_file="./simple.c", debug=0) fn = b.load_func("ebpf_filter", BPF.SCHED_CLS) self.message("BPF program loaded") self.message("Discovering tables") routing_tbl = b.get_table("routing") routing_miss_tbl = b.get_table("ebpf_routing_miss") cnt_tbl = b.get_table("cnt") self.message("Hooking up BPF classifiers using TC") interfname = self.get_interface_name(self.switch, self.server) sw_srv_idx = self.get_interface(interfname) self.ipr.tc("add", "ingress", sw_srv_idx, "ffff:") self.ipr.tc("add-filter", "bpf", sw_srv_idx, ":1", fd=fn.fd, name=fn.name, parent="ffff:", action="ok", classid=1) interfname = self.get_interface_name(self.switch, self.client) sw_clt_idx = self.get_interface(interfname) self.ipr.tc("add", "ingress", sw_clt_idx, "ffff:") self.ipr.tc("add-filter", "bpf", sw_clt_idx, ":1", fd=fn.fd, name=fn.name, parent="ffff:", action="ok", classid=1) self.message("Populating tables from the control plane") cltip = self.client_endpoint.get_ip_address() srvip = self.server_endpoint.get_ip_address() # BCC does not support tbl.Leaf when the type contains a union, # so we have to make up the value type manually. Unfortunately # these sizes are not portable... class Forward(ctypes.Structure): _fields_ = [("port", ctypes.c_ushort)] class Nop(ctypes.Structure): _fields_ = [] class Union(ctypes.Union): _fields_ = [("nop", Nop), ("forward", Forward)] class Value(ctypes.Structure): _fields_ = [("action", ctypes.c_uint), ("u", Union)] if False: # This is how it should ideally be done, but it does not work routing_tbl[routing_tbl.Key(int(cltip))] = routing_tbl.Leaf( 1, sw_clt_idx) routing_tbl[routing_tbl.Key(int(srvip))] = routing_tbl.Leaf( 1, sw_srv_idx) else: v1 = Value() v1.action = 1 v1.u.forward.port = sw_clt_idx v2 = Value() v2.action = 1; v2.u.forward.port = sw_srv_idx routing_tbl[routing_tbl.Key(int(cltip))] = v1 routing_tbl[routing_tbl.Key(int(srvip))] = v2 self.message("Dumping table contents") for key, leaf in routing_tbl.items(): self.message(str(IPAddress(key.key_field_0)), leaf.action, leaf.u.forward.port) def run(self): self.message("Pinging server from client") ping = ["ping", self.server_endpoint.ipaddress, "-c", "2"] result = self.client.execute(ping) if result != 0: raise Exception("Test failed") else: print("Test succeeded!") def prepare_switch(self): self.message("Configuring switch") # Re-invokes this script in the switch namespace; # this causes the setup_switch method to be run in that context. # This is the same as running self.setup_switch() # but in the switch namespace self.run_method_in_node(self.switch, "setup_switch", []) def compile(source, destination): try: status = subprocess.call( "../compiler/p4toEbpf.py " + source + " -o " + destination, shell=True) if status < 0: print("Child was terminated by signal", -status, file=sys.stderr) else: print("Child returned", status, file=sys.stderr) except OSError as e: print("Execution failed:", e, file=sys.stderr) raise e def start_simulation(): compile("testprograms/simple.p4", "simple.c") network = SimulatedNetwork() network.instantiate() network.prepare_switch() network.run() network.delete() os.remove("simple.c") def main(argv): print(str(argv)) if len(argv) == 1: # Main entry point: start simulation start_simulation() else: # We are invoked with some arguments (probably in a different namespace) # First argument is a method name, rest are method arguments. # Create a SimulatedNetwork and invoke the specified method with the # specified arguments. network = SimulatedNetwork() methodname = argv[1] arguments = argv[2:] method = getattr(network, methodname) method(*arguments) if __name__ == '__main__': main(sys.argv) bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testP4toEbpf.py000077500000000000000000000046471305314114400240710ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) Barefoot Networks, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # Runs the compiler on all files in the 'testprograms' folder # Writes outputs in the 'testoutputs' folder from bcc import BPF import os, sys sys.path.append("../compiler") # To get hold of p4toEbpf # We want to run it without installing it import p4toEbpf import os def drop_extension(filename): return os.path.splitext(os.path.basename(filename))[0] filesFailed = {} # map error kind -> list[ (file, error) ] def set_error(kind, file, error): if kind in filesFailed: filesFailed[kind].append((file, error)) else: filesFailed[kind] = [(file, error)] def is_root(): # Is this code portable? return os.getuid() == 0 def main(): testpath = "testprograms" destFolder = "testoutputs" files = os.listdir(testpath) files.sort() filesDone = 0 errors = 0 if not is_root(): print "Loading EBPF programs requires root priviledge." print "Will only test compilation, not loading." print "(Run with sudo to test program loading.)" for f in files: path = os.path.join(testpath, f) if not os.path.isfile(path): continue if not path.endswith(".p4"): continue destname = drop_extension(path) + ".c" destname = os.path.join(destFolder, destname) args = [path, "-o", destname] result = p4toEbpf.process(args) if result.kind != "OK": errors += 1 print path, result.error set_error(result.kind, path, result.error) else: # Try to load the compiled function if is_root(): try: print("Compiling and loading BPF program") b = BPF(src_file=destname, debug=0) fn = b.load_func("ebpf_filter", BPF.SCHED_CLS) except Exception as e: print(e) set_error("BPF error", path, str(e)) filesDone += 1 print "Compiled", filesDone, "files", errors, "errors" for key in sorted(filesFailed): print key, ":", len(filesFailed[key]), "programs" for v in filesFailed[key]: print "\t", v exit(len(filesFailed) != 0) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testoutputs/000077500000000000000000000000001305314114400236015ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testoutputs/.empty000066400000000000000000000000001305314114400247260ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/000077500000000000000000000000001305314114400237105ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/arrayKey.p4000066400000000000000000000006411305314114400257450ustar00rootroot00000000000000header_type ethernet_t { fields { dstAddr : 48; srcAddr : 48; etherType : 16; } } parser start { return parse_ethernet; } header ethernet_t ethernet; parser parse_ethernet { extract(ethernet); return ingress; } action nop() {} table routing { reads { ethernet.dstAddr: exact; } actions { nop; } size : 512; } control ingress { apply(routing); }bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/basic_routing.p4000066400000000000000000000114121305314114400270040ustar00rootroot00000000000000/* Copyright 2013-present Barefoot Networks, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ header_type ethernet_t { fields { dstAddr : 48; srcAddr : 48; etherType : 16; } } header_type ipv4_t { fields { version : 4; ihl : 4; diffserv : 8; totalLen : 16; identification : 16; flags : 3; fragOffset : 13; ttl : 8; protocol : 8; hdrChecksum : 16; srcAddr : 32; dstAddr: 32; } } parser start { return parse_ethernet; } #define ETHERTYPE_IPV4 0x0800 header ethernet_t ethernet; parser parse_ethernet { extract(ethernet); return select(latest.etherType) { ETHERTYPE_IPV4 : parse_ipv4; default: ingress; } } header ipv4_t ipv4; /* Not yet supported on EBPF target field_list ipv4_checksum_list { ipv4.version; ipv4.ihl; ipv4.diffserv; ipv4.totalLen; ipv4.identification; ipv4.flags; ipv4.fragOffset; ipv4.ttl; ipv4.protocol; ipv4.srcAddr; ipv4.dstAddr; } field_list_calculation ipv4_checksum { input { ipv4_checksum_list; } algorithm : csum16; output_width : 16; } calculated_field ipv4.hdrChecksum { verify ipv4_checksum; update ipv4_checksum; } */ parser parse_ipv4 { extract(ipv4); return ingress; } #define PORT_VLAN_TABLE_SIZE 32768 #define BD_TABLE_SIZE 65536 #define IPV4_LPM_TABLE_SIZE 16384 #define IPV4_HOST_TABLE_SIZE 131072 #define NEXTHOP_TABLE_SIZE 32768 #define REWRITE_MAC_TABLE_SIZE 32768 #define VRF_BIT_WIDTH 12 #define BD_BIT_WIDTH 16 #define IFINDEX_BIT_WIDTH 10 /* METADATA */ header_type ingress_metadata_t { fields { vrf : VRF_BIT_WIDTH; /* VRF */ bd : BD_BIT_WIDTH; /* ingress BD */ nexthop_index : 16; /* final next hop index */ } } metadata ingress_metadata_t ingress_metadata; action on_miss() { } action set_bd(bd) { modify_field(ingress_metadata.bd, bd); } table port_mapping { reads { standard_metadata.ingress_port : exact; } actions { set_bd; } size : PORT_VLAN_TABLE_SIZE; } action set_vrf(vrf) { modify_field(ingress_metadata.vrf, vrf); } table bd { reads { ingress_metadata.bd : exact; } actions { set_vrf; } size : BD_TABLE_SIZE; } action fib_hit_nexthop(nexthop_index) { modify_field(ingress_metadata.nexthop_index, nexthop_index); subtract_from_field(ipv4.ttl, 1); } table ipv4_fib { reads { ingress_metadata.vrf : exact; ipv4.dstAddr : exact; } actions { on_miss; fib_hit_nexthop; } size : IPV4_HOST_TABLE_SIZE; } table ipv4_fib_lpm { reads { ingress_metadata.vrf : exact; ipv4.dstAddr : exact; // lpm not supported } actions { on_miss; fib_hit_nexthop; } size : IPV4_LPM_TABLE_SIZE; } action set_egress_details(egress_spec) { modify_field(standard_metadata.egress_spec, egress_spec); } table nexthop { reads { ingress_metadata.nexthop_index : exact; } actions { on_miss; set_egress_details; } size : NEXTHOP_TABLE_SIZE; } control ingress { if (valid(ipv4)) { /* derive ingress_metadata.bd */ apply(port_mapping); /* derive ingress_metadata.vrf */ apply(bd); /* fib lookup, set ingress_metadata.nexthop_index */ apply(ipv4_fib) { on_miss { apply(ipv4_fib_lpm); } } /* derive standard_metadata.egress_spec from ingress_metadata.nexthop_index */ apply(nexthop); } } action rewrite_src_dst_mac(smac, dmac) { modify_field(ethernet.srcAddr, smac); modify_field(ethernet.dstAddr, dmac); } table rewrite_mac { reads { ingress_metadata.nexthop_index : exact; } actions { on_miss; rewrite_src_dst_mac; } size : REWRITE_MAC_TABLE_SIZE; } control egress { /* set smac and dmac from ingress_metadata.nexthop_index */ apply(rewrite_mac); }bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/bitfields.p4000066400000000000000000000013621305314114400261240ustar00rootroot00000000000000header_type ht { fields { f1 : 1; f2 : 2; f3 : 3; f4 : 4; f5 : 5; f6 : 6; f7 : 7; f8 : 8; f9 : 9; f10 : 10; f11 : 11; f12 : 12; f13 : 13; f14 : 14; f15 : 15; f16 : 16; f17 : 17; f18 : 18; f19 : 19; f20 : 20; f21 : 21; f22 : 22; f23 : 23; f24 : 24; f25 : 25; f26 : 26; f27 : 27; f28 : 28; f29 : 29; f30 : 30; f31 : 31; f32 : 32; } } header_type larget { fields { f48 : 48; f1: 1; f49 : 48; f2 : 1; f64 : 64; f3 : 1; f128 : 128; } } header ht h; header larget large; parser start { extract(h); extract(large); return ingress; } control ingress { } bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/compositeArray.p4000066400000000000000000000010451305314114400271560ustar00rootroot00000000000000header_type ethernet_t { fields { dstAddr : 48; } } header_type ipv4_t { fields { srcAddr : 32; } } parser start { return parse_ethernet; } header ethernet_t ethernet; parser parse_ethernet { extract(ethernet); return parse_ipv4; } action nop() {} header ipv4_t ipv4; parser parse_ipv4 { extract(ipv4); return ingress; } table routing { reads { ethernet.dstAddr: exact; ipv4.srcAddr: exact; } actions { nop; } size : 512; } control ingress { apply(routing); }bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/compositeKey.p4000066400000000000000000000020321305314114400266250ustar00rootroot00000000000000header_type ethernet_t { fields { dstAddr : 48; srcAddr : 48; etherType : 16; } } header_type ipv4_t { fields { version : 4; ihl : 4; diffserv : 8; totalLen : 16; identification : 16; flags : 3; fragOffset : 13; ttl : 8; protocol : 8; hdrChecksum : 16; srcAddr : 32; dstAddr: 32; } } parser start { return parse_ethernet; } header ethernet_t ethernet; parser parse_ethernet { extract(ethernet); return select(latest.etherType) { 0x800 : parse_ipv4; default: ingress; } } action nop() {} action forward(port) { modify_field(standard_metadata.egress_port, port); } header ipv4_t ipv4; parser parse_ipv4 { extract(ipv4); return ingress; } table routing { reads { ipv4.dstAddr: exact; ipv4.srcAddr: exact; } actions { nop; forward; } size : 512; } counter cnt { type: bytes; direct: routing; } control ingress { apply(routing); }bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/do_nothing.p4000066400000000000000000000007151305314114400263100ustar00rootroot00000000000000/* Sample P4 program */ header_type ethernet_t { fields { dstAddr : 48; srcAddr : 48; etherType : 16; } } parser start { return parse_ethernet; } header ethernet_t ethernet; parser parse_ethernet { extract(ethernet); return ingress; } action action_0(){ no_op(); } table table_0 { reads { ethernet.etherType : exact; } actions { action_0; } } control ingress { apply(table_0); } bpfcc-0.2.0+git0.02884a026/src/cc/frontends/p4/test/testprograms/simple.p4000066400000000000000000000021611305314114400254460ustar00rootroot00000000000000// Routes a packet to an interface based on its IPv4 address // Maintains a set of counters on the routing table header_type ethernet_t { fields { dstAddr : 48; srcAddr : 48; etherType : 16; } } header_type ipv4_t { fields { version : 4; ihl : 4; diffserv : 8; totalLen : 16; identification : 16; flags : 3; fragOffset : 13; ttl : 8; protocol : 8; hdrChecksum : 16; srcAddr : 32; dstAddr: 32; } } parser start { return parse_ethernet; } header ethernet_t ethernet; parser parse_ethernet { extract(ethernet); return select(latest.etherType) { 0x800 : parse_ipv4; default: ingress; } } action nop() {} action forward(port) { modify_field(standard_metadata.egress_port, port); } header ipv4_t ipv4; parser parse_ipv4 { extract(ipv4); return ingress; } table routing { reads { ipv4.dstAddr: exact; } actions { nop; forward; } size : 512; } counter cnt { type: bytes; direct: routing; } control ingress { apply(routing); }bpfcc-0.2.0+git0.02884a026/src/cc/libbcc.pc.in000066400000000000000000000004671305314114400200300ustar00rootroot00000000000000prefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=${prefix} libdir=${exec_prefix}/lib includedir=${prefix}/include datarootdir=${prefix}/share compatdir=${includedir}/bcc/compat Name: libbcc Version: @REVISION@ Description: BCC Program library Requires: Libs: -L${libdir} -lbcc Cflags: -I${includedir} -I${compatdir} bpfcc-0.2.0+git0.02884a026/src/cc/libbpf.c000066400000000000000000000521731305314114400172640ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "libbpf.h" #include "perf_reader.h" // TODO: remove these defines when linux-libc-dev exports them properly #ifndef __NR_bpf #if defined(__powerpc64__) #define __NR_bpf 361 #elif defined(__aarch64__) #define __NR_bpf 280 #else #define __NR_bpf 321 #endif #endif #ifndef SO_ATTACH_BPF #define SO_ATTACH_BPF 50 #endif #ifndef PERF_EVENT_IOC_SET_BPF #define PERF_EVENT_IOC_SET_BPF _IOW('$', 8, __u32) #endif #ifndef PERF_FLAG_FD_CLOEXEC #define PERF_FLAG_FD_CLOEXEC (1UL << 3) #endif static __u64 ptr_to_u64(void *ptr) { return (__u64) (unsigned long) ptr; } int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size, int max_entries, int map_flags) { union bpf_attr attr; memset(&attr, 0, sizeof(attr)); attr.map_type = map_type; attr.key_size = key_size; attr.value_size = value_size; attr.max_entries = max_entries; attr.map_flags = map_flags; int ret = syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr)); if (ret < 0 && errno == EPERM) { // see note below about the rationale for this retry struct rlimit rl = {}; if (getrlimit(RLIMIT_MEMLOCK, &rl) == 0) { rl.rlim_max = RLIM_INFINITY; rl.rlim_cur = rl.rlim_max; if (setrlimit(RLIMIT_MEMLOCK, &rl) == 0) ret = syscall(__NR_bpf, BPF_MAP_CREATE, &attr, sizeof(attr)); } } return ret; } int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags) { union bpf_attr attr; memset(&attr, 0, sizeof(attr)); attr.map_fd = fd; attr.key = ptr_to_u64(key); attr.value = ptr_to_u64(value); attr.flags = flags; return syscall(__NR_bpf, BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr)); } int bpf_lookup_elem(int fd, void *key, void *value) { union bpf_attr attr; memset(&attr, 0, sizeof(attr)); attr.map_fd = fd; attr.key = ptr_to_u64(key); attr.value = ptr_to_u64(value); return syscall(__NR_bpf, BPF_MAP_LOOKUP_ELEM, &attr, sizeof(attr)); } int bpf_delete_elem(int fd, void *key) { union bpf_attr attr; memset(&attr, 0, sizeof(attr)); attr.map_fd = fd; attr.key = ptr_to_u64(key); return syscall(__NR_bpf, BPF_MAP_DELETE_ELEM, &attr, sizeof(attr)); } int bpf_get_next_key(int fd, void *key, void *next_key) { union bpf_attr attr; memset(&attr, 0, sizeof(attr)); attr.map_fd = fd; attr.key = ptr_to_u64(key); attr.next_key = ptr_to_u64(next_key); return syscall(__NR_bpf, BPF_MAP_GET_NEXT_KEY, &attr, sizeof(attr)); } void bpf_print_hints(char *log) { if (log == NULL) return; // The following error strings will need maintenance to match LLVM. // stack busting if (strstr(log, "invalid stack off=-") != NULL) { fprintf(stderr, "HINT: Looks like you exceeded the BPF stack limit. " "This can happen if you allocate too much local variable storage. " "For example, if you allocated a 1 Kbyte struct (maybe for " "BPF_PERF_OUTPUT), busting a max stack of 512 bytes.\n\n"); } // didn't check NULL on map lookup if (strstr(log, "invalid mem access 'map_value_or_null'") != NULL) { fprintf(stderr, "HINT: The 'map_value_or_null' error can happen if " "you dereference a pointer value from a map lookup without first " "checking if that pointer is NULL.\n\n"); } // lacking a bpf_probe_read if (strstr(log, "invalid mem access 'inv'") != NULL) { fprintf(stderr, "HINT: The invalid mem access 'inv' error can happen " "if you try to dereference memory without first using " "bpf_probe_read() to copy it to the BPF stack. Sometimes the " "bpf_probe_read is automatic by the bcc rewriter, other times " "you'll need to be explicit.\n\n"); } } #define ROUND_UP(x, n) (((x) + (n) - 1u) & ~((n) - 1u)) int bpf_prog_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, int prog_len, const char *license, unsigned kern_version, char *log_buf, unsigned log_buf_size) { union bpf_attr attr; char *bpf_log_buffer = NULL; unsigned buffer_size = 0; int ret = 0; memset(&attr, 0, sizeof(attr)); attr.prog_type = prog_type; attr.insns = ptr_to_u64((void *) insns); attr.insn_cnt = prog_len / sizeof(struct bpf_insn); attr.license = ptr_to_u64((void *) license); attr.log_buf = ptr_to_u64(log_buf); attr.log_size = log_buf_size; attr.log_level = log_buf ? 1 : 0; attr.kern_version = kern_version; if (log_buf) log_buf[0] = 0; if (attr.insn_cnt > BPF_MAXINSNS) { ret = -1; errno = EINVAL; fprintf(stderr, "bpf: %s. Program too large (%d insns), at most %d insns\n\n", strerror(errno), attr.insn_cnt, BPF_MAXINSNS); return ret; } ret = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr)); if (ret < 0 && errno == EPERM) { // When EPERM is returned, two reasons are possible: // 1. user has no permissions for bpf() // 2. user has insufficent rlimit for locked memory // Unfortunately, there is no api to inspect the current usage of locked // mem for the user, so an accurate calculation of how much memory to lock // for this new program is difficult to calculate. As a hack, bump the limit // to unlimited. If program load fails again, return the error. struct rlimit rl = {}; if (getrlimit(RLIMIT_MEMLOCK, &rl) == 0) { rl.rlim_max = RLIM_INFINITY; rl.rlim_cur = rl.rlim_max; if (setrlimit(RLIMIT_MEMLOCK, &rl) == 0) ret = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr)); } } if (ret < 0 && !log_buf) { buffer_size = LOG_BUF_SIZE; // caller did not specify log_buf but failure should be printed, // so repeat the syscall and print the result to stderr for (;;) { bpf_log_buffer = malloc(buffer_size); if (!bpf_log_buffer) { fprintf(stderr, "bpf: buffer log memory allocation failed for error %s\n\n", strerror(errno)); return ret; } bpf_log_buffer[0] = 0; attr.log_buf = ptr_to_u64(bpf_log_buffer); attr.log_size = buffer_size; attr.log_level = bpf_log_buffer ? 1 : 0; ret = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr)); if (ret < 0 && errno == ENOSPC) { free(bpf_log_buffer); bpf_log_buffer = NULL; buffer_size <<= 1; } else { break; } } fprintf(stderr, "bpf: %s\n%s\n", strerror(errno), bpf_log_buffer); bpf_print_hints(bpf_log_buffer); free(bpf_log_buffer); } return ret; } int bpf_open_raw_sock(const char *name) { struct sockaddr_ll sll; int sock; sock = socket(PF_PACKET, SOCK_RAW | SOCK_NONBLOCK | SOCK_CLOEXEC, htons(ETH_P_ALL)); if (sock < 0) { printf("cannot create raw socket\n"); return -1; } memset(&sll, 0, sizeof(sll)); sll.sll_family = AF_PACKET; sll.sll_ifindex = if_nametoindex(name); sll.sll_protocol = htons(ETH_P_ALL); if (bind(sock, (struct sockaddr *)&sll, sizeof(sll)) < 0) { printf("bind to %s: %s\n", name, strerror(errno)); close(sock); return -1; } return sock; } int bpf_attach_socket(int sock, int prog) { return setsockopt(sock, SOL_SOCKET, SO_ATTACH_BPF, &prog, sizeof(prog)); } static int bpf_attach_tracing_event(int progfd, const char *event_path, struct perf_reader *reader, int pid, int cpu, int group_fd) { int efd, pfd; ssize_t bytes; char buf[256]; struct perf_event_attr attr = {}; snprintf(buf, sizeof(buf), "%s/id", event_path); efd = open(buf, O_RDONLY, 0); if (efd < 0) { fprintf(stderr, "open(%s): %s\n", buf, strerror(errno)); return -1; } bytes = read(efd, buf, sizeof(buf)); if (bytes <= 0 || bytes >= sizeof(buf)) { fprintf(stderr, "read(%s): %s\n", buf, strerror(errno)); close(efd); return -1; } close(efd); buf[bytes] = '\0'; attr.config = strtol(buf, NULL, 0); attr.type = PERF_TYPE_TRACEPOINT; attr.sample_type = PERF_SAMPLE_RAW | PERF_SAMPLE_CALLCHAIN; attr.sample_period = 1; attr.wakeup_events = 1; pfd = syscall(__NR_perf_event_open, &attr, pid, cpu, group_fd, PERF_FLAG_FD_CLOEXEC); if (pfd < 0) { fprintf(stderr, "perf_event_open(%s/id): %s\n", event_path, strerror(errno)); return -1; } perf_reader_set_fd(reader, pfd); if (perf_reader_mmap(reader, attr.type, attr.sample_type) < 0) return -1; if (ioctl(pfd, PERF_EVENT_IOC_SET_BPF, progfd) < 0) { perror("ioctl(PERF_EVENT_IOC_SET_BPF)"); return -1; } if (ioctl(pfd, PERF_EVENT_IOC_ENABLE, 0) < 0) { perror("ioctl(PERF_EVENT_IOC_ENABLE)"); return -1; } return 0; } void * bpf_attach_kprobe(int progfd, enum bpf_probe_attach_type attach_type, const char *ev_name, const char *fn_name, pid_t pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie) { int kfd; char buf[256]; char new_name[128]; struct perf_reader *reader = NULL; static char *event_type = "kprobe"; int n; snprintf(new_name, sizeof(new_name), "%s_bcc_%d", ev_name, getpid()); reader = perf_reader_new(cb, NULL, cb_cookie); if (!reader) goto error; snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/%s_events", event_type); kfd = open(buf, O_WRONLY | O_APPEND, 0); if (kfd < 0) { fprintf(stderr, "open(%s): %s\n", buf, strerror(errno)); goto error; } snprintf(buf, sizeof(buf), "%c:%ss/%s %s", attach_type==BPF_PROBE_ENTRY ? 'p' : 'r', event_type, new_name, fn_name); if (write(kfd, buf, strlen(buf)) < 0) { if (errno == EINVAL) fprintf(stderr, "check dmesg output for possible cause\n"); close(kfd); goto error; } close(kfd); if (access("/sys/kernel/debug/tracing/instances", F_OK) != -1) { snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/instances/bcc_%d", getpid()); if (access(buf, F_OK) == -1) { if (mkdir(buf, 0755) == -1) goto retry; } n = snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/instances/bcc_%d/events/%ss/%s", getpid(), event_type, new_name); if (n < sizeof(buf) && bpf_attach_tracing_event(progfd, buf, reader, pid, cpu, group_fd) == 0) goto out; snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/instances/bcc_%d", getpid()); rmdir(buf); } retry: snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/events/%ss/%s", event_type, new_name); if (bpf_attach_tracing_event(progfd, buf, reader, pid, cpu, group_fd) < 0) goto error; out: return reader; error: perf_reader_free(reader); return NULL; } void * bpf_attach_uprobe(int progfd, enum bpf_probe_attach_type attach_type, const char *ev_name, const char *binary_path, uint64_t offset, pid_t pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie) { int kfd; char buf[PATH_MAX]; char new_name[128]; struct perf_reader *reader = NULL; static char *event_type = "uprobe"; int n; snprintf(new_name, sizeof(new_name), "%s_bcc_%d", ev_name, getpid()); reader = perf_reader_new(cb, NULL, cb_cookie); if (!reader) goto error; snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/%s_events", event_type); kfd = open(buf, O_WRONLY | O_APPEND, 0); if (kfd < 0) { fprintf(stderr, "open(%s): %s\n", buf, strerror(errno)); goto error; } n = snprintf(buf, sizeof(buf), "%c:%ss/%s %s:0x%lx", attach_type==BPF_PROBE_ENTRY ? 'p' : 'r', event_type, new_name, binary_path, offset); if (n >= sizeof(buf)) { close(kfd); goto error; } if (write(kfd, buf, strlen(buf)) < 0) { if (errno == EINVAL) fprintf(stderr, "check dmesg output for possible cause\n"); close(kfd); goto error; } close(kfd); snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/events/%ss/%s", event_type, new_name); if (bpf_attach_tracing_event(progfd, buf, reader, pid, cpu, group_fd) < 0) goto error; return reader; error: perf_reader_free(reader); return NULL; } static int bpf_detach_probe(const char *ev_name, const char *event_type) { int kfd; char buf[256]; snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/%s_events", event_type); kfd = open(buf, O_WRONLY | O_APPEND, 0); if (kfd < 0) { fprintf(stderr, "open(%s): %s\n", buf, strerror(errno)); return -1; } snprintf(buf, sizeof(buf), "-:%ss/%s_bcc_%d", event_type, ev_name, getpid()); if (write(kfd, buf, strlen(buf)) < 0) { fprintf(stderr, "write(%s): %s\n", buf, strerror(errno)); close(kfd); return -1; } close(kfd); return 0; } int bpf_detach_kprobe(const char *ev_name) { char buf[256]; int ret = bpf_detach_probe(ev_name, "kprobe"); snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/instances/bcc_%d", getpid()); if (access(buf, F_OK) != -1) { rmdir(buf); } return ret; } int bpf_detach_uprobe(const char *ev_name) { return bpf_detach_probe(ev_name, "uprobe"); } void * bpf_attach_tracepoint(int progfd, const char *tp_category, const char *tp_name, int pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie) { char buf[256]; struct perf_reader *reader = NULL; reader = perf_reader_new(cb, NULL, cb_cookie); if (!reader) goto error; snprintf(buf, sizeof(buf), "/sys/kernel/debug/tracing/events/%s/%s", tp_category, tp_name); if (bpf_attach_tracing_event(progfd, buf, reader, pid, cpu, group_fd) < 0) goto error; return reader; error: perf_reader_free(reader); return NULL; } int bpf_detach_tracepoint(const char *tp_category, const char *tp_name) { // Right now, there is nothing to do, but it's a good idea to encourage // callers to detach anything they attach. return 0; } void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, void *cb_cookie, int pid, int cpu) { int pfd; struct perf_event_attr attr = {}; struct perf_reader *reader = NULL; reader = perf_reader_new(NULL, raw_cb, cb_cookie); if (!reader) goto error; attr.config = 10;//PERF_COUNT_SW_BPF_OUTPUT; attr.type = PERF_TYPE_SOFTWARE; attr.sample_type = PERF_SAMPLE_RAW; attr.sample_period = 1; attr.wakeup_events = 1; pfd = syscall(__NR_perf_event_open, &attr, pid, cpu, -1, PERF_FLAG_FD_CLOEXEC); if (pfd < 0) { fprintf(stderr, "perf_event_open: %s\n", strerror(errno)); fprintf(stderr, " (check your kernel for PERF_COUNT_SW_BPF_OUTPUT support, 4.4 or newer)\n"); goto error; } perf_reader_set_fd(reader, pfd); if (perf_reader_mmap(reader, attr.type, attr.sample_type) < 0) goto error; if (ioctl(pfd, PERF_EVENT_IOC_ENABLE, 0) < 0) { perror("ioctl(PERF_EVENT_IOC_ENABLE)"); goto error; } return reader; error: if (reader) perf_reader_free(reader); return NULL; } int bpf_open_perf_event(uint32_t type, uint64_t config, int pid, int cpu) { int fd; struct perf_event_attr attr = {}; attr.sample_period = LONG_MAX; attr.type = type; attr.config = config; fd = syscall(__NR_perf_event_open, &attr, pid, cpu, -1, PERF_FLAG_FD_CLOEXEC); if (fd < 0) { fprintf(stderr, "perf_event_open: %s\n", strerror(errno)); return -1; } if (ioctl(fd, PERF_EVENT_IOC_ENABLE, 0) < 0) { perror("ioctl(PERF_EVENT_IOC_ENABLE)"); close(fd); return -1; } return fd; } int bpf_attach_xdp(const char *dev_name, int progfd) { struct sockaddr_nl sa; int sock, seq = 0, len, ret = -1; char buf[4096]; struct nlattr *nla, *nla_xdp; struct { struct nlmsghdr nh; struct ifinfomsg ifinfo; char attrbuf[64]; } req; struct nlmsghdr *nh; struct nlmsgerr *err; memset(&sa, 0, sizeof(sa)); sa.nl_family = AF_NETLINK; sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (sock < 0) { fprintf(stderr, "bpf: opening a netlink socket: %s\n", strerror(errno)); return -1; } if (bind(sock, (struct sockaddr *)&sa, sizeof(sa)) < 0) { fprintf(stderr, "bpf: bind to netlink: %s\n", strerror(errno)); goto cleanup; } memset(&req, 0, sizeof(req)); req.nh.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)); req.nh.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; req.nh.nlmsg_type = RTM_SETLINK; req.nh.nlmsg_pid = 0; req.nh.nlmsg_seq = ++seq; req.ifinfo.ifi_family = AF_UNSPEC; req.ifinfo.ifi_index = if_nametoindex(dev_name); if (req.ifinfo.ifi_index == 0) { fprintf(stderr, "bpf: Resolving device name to index: %s\n", strerror(errno)); goto cleanup; } nla = (struct nlattr *)(((char *)&req) + NLMSG_ALIGN(req.nh.nlmsg_len)); nla->nla_type = NLA_F_NESTED | 43/*IFLA_XDP*/; nla_xdp = (struct nlattr *)((char *)nla + NLA_HDRLEN); // we specify the FD passed over by the user nla_xdp->nla_type = 1/*IFLA_XDP_FD*/; nla_xdp->nla_len = NLA_HDRLEN + sizeof(int); memcpy((char *)nla_xdp + NLA_HDRLEN, &progfd, sizeof(progfd)); nla->nla_len = NLA_HDRLEN + nla_xdp->nla_len; req.nh.nlmsg_len += NLA_ALIGN(nla->nla_len); if (send(sock, &req, req.nh.nlmsg_len, 0) < 0) { fprintf(stderr, "bpf: send to netlink: %s\n", strerror(errno)); goto cleanup; } len = recv(sock, buf, sizeof(buf), 0); if (len < 0) { fprintf(stderr, "bpf: recv from netlink: %s\n", strerror(errno)); goto cleanup; } for (nh = (struct nlmsghdr *)buf; NLMSG_OK(nh, len); nh = NLMSG_NEXT(nh, len)) { if (nh->nlmsg_pid != getpid()) { fprintf(stderr, "bpf: Wrong pid %d, expected %d\n", nh->nlmsg_pid, getpid()); errno = EBADMSG; goto cleanup; } if (nh->nlmsg_seq != seq) { fprintf(stderr, "bpf: Wrong seq %d, expected %d\n", nh->nlmsg_seq, seq); errno = EBADMSG; goto cleanup; } switch (nh->nlmsg_type) { case NLMSG_ERROR: err = (struct nlmsgerr *)NLMSG_DATA(nh); if (!err->error) continue; fprintf(stderr, "bpf: nlmsg error %s\n", strerror(-err->error)); errno = -err->error; goto cleanup; case NLMSG_DONE: break; } } ret = 0; cleanup: close(sock); return ret; } int bpf_attach_perf_event(int progfd, uint32_t ev_type, uint32_t ev_config, uint64_t sample_period, uint64_t sample_freq, pid_t pid, int cpu, int group_fd) { if (ev_type != PERF_TYPE_HARDWARE && ev_type != PERF_TYPE_SOFTWARE) { fprintf(stderr, "Unsupported perf event type\n"); return -1; } if ((ev_type == PERF_TYPE_HARDWARE && ev_config >= PERF_COUNT_HW_MAX) || (ev_type == PERF_TYPE_SOFTWARE && ev_config >= PERF_COUNT_SW_MAX)) { fprintf(stderr, "Invalid perf event config\n"); return -1; } if (!((sample_period > 0) ^ (sample_freq > 0))) { fprintf( stderr, "Exactly one of sample_period / sample_freq should be set\n" ); return -1; } struct perf_event_attr attr = {}; attr.type = ev_type; attr.config = ev_config; attr.inherit = 1; if (sample_freq > 0) { attr.freq = 1; attr.sample_freq = sample_freq; } else { attr.sample_period = sample_period; } int fd = syscall( __NR_perf_event_open, &attr, pid, cpu, group_fd, PERF_FLAG_FD_CLOEXEC ); if (fd < 0) { perror("perf_event_open failed"); return -1; } if (ioctl(fd, PERF_EVENT_IOC_SET_BPF, progfd) != 0) { perror("ioctl(PERF_EVENT_IOC_SET_BPF) failed"); close(fd); return -1; } if (ioctl(fd, PERF_EVENT_IOC_ENABLE, 0) != 0) { perror("ioctl(PERF_EVENT_IOC_ENABLE) failed"); close(fd); return -1; } return fd; } int bpf_detach_perf_event(uint32_t ev_type, uint32_t ev_config) { // Right now, there is nothing to do, but it's a good idea to encourage // callers to detach anything they attach. return 0; } int bpf_obj_pin(int fd, const char *pathname) { union bpf_attr attr = { .pathname = ptr_to_u64((void *)pathname), .bpf_fd = fd, }; return syscall(__NR_bpf, BPF_OBJ_PIN, &attr, sizeof(attr)); } int bpf_obj_get(const char *pathname) { union bpf_attr attr = { .pathname = ptr_to_u64((void *)pathname), }; return syscall(__NR_bpf, BPF_OBJ_GET, &attr, sizeof(attr)); } bpfcc-0.2.0+git0.02884a026/src/cc/libbpf.h000066400000000000000000000170341305314114400172660ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* eBPF mini library */ #ifndef LIBBPF_H #define LIBBPF_H #include "compat/linux/bpf.h" #ifdef __cplusplus extern "C" { #endif enum bpf_probe_attach_type { BPF_PROBE_ENTRY, BPF_PROBE_RETURN }; int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size, int max_entries, int map_flags); int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags); int bpf_lookup_elem(int fd, void *key, void *value); int bpf_delete_elem(int fd, void *key); int bpf_get_next_key(int fd, void *key, void *next_key); int bpf_prog_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, int insn_len, const char *license, unsigned kern_version, char *log_buf, unsigned log_buf_size); int bpf_attach_socket(int sockfd, int progfd); /* create RAW socket and bind to interface 'name' */ int bpf_open_raw_sock(const char *name); typedef void (*perf_reader_cb)(void *cb_cookie, int pid, uint64_t callchain_num, void *callchain); typedef void (*perf_reader_raw_cb)(void *cb_cookie, void *raw, int raw_size); void * bpf_attach_kprobe(int progfd, enum bpf_probe_attach_type attach_type, const char *ev_name, const char *fn_name, pid_t pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie); int bpf_detach_kprobe(const char *ev_name); void * bpf_attach_uprobe(int progfd, enum bpf_probe_attach_type attach_type, const char *ev_name, const char *binary_path, uint64_t offset, pid_t pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie); int bpf_detach_uprobe(const char *ev_name); void * bpf_attach_tracepoint(int progfd, const char *tp_category, const char *tp_name, int pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie); int bpf_detach_tracepoint(const char *tp_category, const char *tp_name); void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, void *cb_cookie, int pid, int cpu); /* attached a prog expressed by progfd to the device specified in dev_name */ int bpf_attach_xdp(const char *dev_name, int progfd); // attach a prog expressed by progfd to run on a specific perf event, with // certain sample period or sample frequency int bpf_attach_perf_event(int progfd, uint32_t ev_type, uint32_t ev_config, uint64_t sample_period, uint64_t sample_freq, pid_t pid, int cpu, int group_fd); int bpf_detach_perf_event(uint32_t ev_type, uint32_t ev_config); int bpf_obj_pin(int fd, const char *pathname); int bpf_obj_get(const char *pathname); #define LOG_BUF_SIZE 65536 // Put non-static/inline functions in their own section with this prefix + // fn_name to enable discovery by the bcc library. #define BPF_FN_PREFIX ".bpf.fn." /* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */ #define BPF_ALU64_REG(OP, DST, SRC) \ ((struct bpf_insn) { \ .code = BPF_ALU64 | BPF_OP(OP) | BPF_X, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = 0, \ .imm = 0 }) #define BPF_ALU32_REG(OP, DST, SRC) \ ((struct bpf_insn) { \ .code = BPF_ALU | BPF_OP(OP) | BPF_X, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = 0, \ .imm = 0 }) /* ALU ops on immediates, bpf_add|sub|...: dst_reg += imm32 */ #define BPF_ALU64_IMM(OP, DST, IMM) \ ((struct bpf_insn) { \ .code = BPF_ALU64 | BPF_OP(OP) | BPF_K, \ .dst_reg = DST, \ .src_reg = 0, \ .off = 0, \ .imm = IMM }) #define BPF_ALU32_IMM(OP, DST, IMM) \ ((struct bpf_insn) { \ .code = BPF_ALU | BPF_OP(OP) | BPF_K, \ .dst_reg = DST, \ .src_reg = 0, \ .off = 0, \ .imm = IMM }) /* Short form of mov, dst_reg = src_reg */ #define BPF_MOV64_REG(DST, SRC) \ ((struct bpf_insn) { \ .code = BPF_ALU64 | BPF_MOV | BPF_X, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = 0, \ .imm = 0 }) /* Short form of mov, dst_reg = imm32 */ #define BPF_MOV64_IMM(DST, IMM) \ ((struct bpf_insn) { \ .code = BPF_ALU64 | BPF_MOV | BPF_K, \ .dst_reg = DST, \ .src_reg = 0, \ .off = 0, \ .imm = IMM }) /* BPF_LD_IMM64 macro encodes single 'load 64-bit immediate' insn */ #define BPF_LD_IMM64(DST, IMM) \ BPF_LD_IMM64_RAW(DST, 0, IMM) #define BPF_LD_IMM64_RAW(DST, SRC, IMM) \ ((struct bpf_insn) { \ .code = BPF_LD | BPF_DW | BPF_IMM, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = 0, \ .imm = (__u32) (IMM) }), \ ((struct bpf_insn) { \ .code = 0, /* zero is reserved opcode */ \ .dst_reg = 0, \ .src_reg = 0, \ .off = 0, \ .imm = ((__u64) (IMM)) >> 32 }) #define BPF_PSEUDO_MAP_FD 1 /* pseudo BPF_LD_IMM64 insn used to refer to process-local map_fd */ #define BPF_LD_MAP_FD(DST, MAP_FD) \ BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD) /* Direct packet access, R0 = *(uint *) (skb->data + imm32) */ #define BPF_LD_ABS(SIZE, IMM) \ ((struct bpf_insn) { \ .code = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS, \ .dst_reg = 0, \ .src_reg = 0, \ .off = 0, \ .imm = IMM }) /* Memory load, dst_reg = *(uint *) (src_reg + off16) */ #define BPF_LDX_MEM(SIZE, DST, SRC, OFF) \ ((struct bpf_insn) { \ .code = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = OFF, \ .imm = 0 }) /* Memory store, *(uint *) (dst_reg + off16) = src_reg */ #define BPF_STX_MEM(SIZE, DST, SRC, OFF) \ ((struct bpf_insn) { \ .code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = OFF, \ .imm = 0 }) /* Memory store, *(uint *) (dst_reg + off16) = imm32 */ #define BPF_ST_MEM(SIZE, DST, OFF, IMM) \ ((struct bpf_insn) { \ .code = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM, \ .dst_reg = DST, \ .src_reg = 0, \ .off = OFF, \ .imm = IMM }) /* Conditional jumps against registers, if (dst_reg 'op' src_reg) goto pc + off16 */ #define BPF_JMP_REG(OP, DST, SRC, OFF) \ ((struct bpf_insn) { \ .code = BPF_JMP | BPF_OP(OP) | BPF_X, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = OFF, \ .imm = 0 }) /* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */ #define BPF_JMP_IMM(OP, DST, IMM, OFF) \ ((struct bpf_insn) { \ .code = BPF_JMP | BPF_OP(OP) | BPF_K, \ .dst_reg = DST, \ .src_reg = 0, \ .off = OFF, \ .imm = IMM }) /* Raw code statement block */ #define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM) \ ((struct bpf_insn) { \ .code = CODE, \ .dst_reg = DST, \ .src_reg = SRC, \ .off = OFF, \ .imm = IMM }) /* Program exit */ #define BPF_EXIT_INSN() \ ((struct bpf_insn) { \ .code = BPF_JMP | BPF_EXIT, \ .dst_reg = 0, \ .src_reg = 0, \ .off = 0, \ .imm = 0 }) #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/perf_reader.c000066400000000000000000000172521305314114400203030ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include "libbpf.h" #include "perf_reader.h" int perf_reader_page_cnt = 8; struct perf_reader { perf_reader_cb cb; perf_reader_raw_cb raw_cb; void *cb_cookie; // to be returned in the cb void *buf; // for keeping segmented data size_t buf_size; void *base; int page_size; int page_cnt; int fd; uint32_t type; uint64_t sample_type; }; struct perf_reader * perf_reader_new(perf_reader_cb cb, perf_reader_raw_cb raw_cb, void *cb_cookie) { struct perf_reader *reader = calloc(1, sizeof(struct perf_reader)); if (!reader) return NULL; reader->cb = cb; reader->raw_cb = raw_cb; reader->cb_cookie = cb_cookie; reader->fd = -1; reader->page_size = getpagesize(); reader->page_cnt = perf_reader_page_cnt; return reader; } void perf_reader_free(void *ptr) { if (ptr) { struct perf_reader *reader = ptr; munmap(reader->base, reader->page_size * (reader->page_cnt + 1)); if (reader->fd >= 0) close(reader->fd); free(reader->buf); free(ptr); } } int perf_reader_mmap(struct perf_reader *reader, unsigned type, unsigned long sample_type) { int mmap_size = reader->page_size * (reader->page_cnt + 1); if (reader->fd < 0) { fprintf(stderr, "%s: reader fd is not set\n", __FUNCTION__); return -1; } reader->base = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE , MAP_SHARED, reader->fd, 0); if (reader->base == MAP_FAILED) { perror("mmap"); return -1; } reader->type = type; reader->sample_type = sample_type; return 0; } struct perf_sample_trace_common { uint16_t id; uint8_t flags; uint8_t preempt_count; int pid; }; struct perf_sample_trace_kprobe { struct perf_sample_trace_common common; uint64_t ip; }; static void parse_tracepoint(struct perf_reader *reader, void *data, int size) { uint8_t *ptr = data; struct perf_event_header *header = (void *)data; struct perf_sample_trace_kprobe *tk = NULL; uint64_t *callchain = NULL; uint64_t num_callchain = 0; ptr += sizeof(*header); if (ptr > (uint8_t *)data + size) { fprintf(stderr, "%s: corrupt sample header\n", __FUNCTION__); return; } if (reader->sample_type & PERF_SAMPLE_CALLCHAIN) { struct { uint64_t nr; uint64_t ips[0]; } *cc = (void *)ptr; ptr += sizeof(cc->nr) + sizeof(*cc->ips) * cc->nr; // size sanity check if (ptr > (uint8_t *)data + size) { fprintf(stderr, "%s: corrupt callchain sample\n", __FUNCTION__); return; } int i; // don't include magic numbers in the call chain for (i = 0; i < cc->nr; ++i) { if (cc->ips[i] == PERF_CONTEXT_USER) break; if (cc->ips[i] >= PERF_CONTEXT_MAX) continue; if (!callchain) callchain = &cc->ips[i]; ++num_callchain; } } // for kprobes, raw samples just include the common data structure and the // instruction pointer if (reader->sample_type & PERF_SAMPLE_RAW) { struct { uint32_t size; char data[0]; } *raw = (void *)ptr; ptr += sizeof(raw->size) + raw->size; if (ptr > (uint8_t *)data + size) { fprintf(stderr, "%s: corrupt raw sample\n", __FUNCTION__); return; } tk = (void *)raw->data; } // sanity check if (ptr != (uint8_t *)data + size) { fprintf(stderr, "%s: extra data at end of sample\n", __FUNCTION__); return; } // call out to the user with the parsed data if (reader->cb) reader->cb(reader->cb_cookie, tk ? tk->common.pid : -1, num_callchain, callchain); } static void parse_sw(struct perf_reader *reader, void *data, int size) { uint8_t *ptr = data; struct perf_event_header *header = (void *)data; struct { uint32_t size; char data[0]; } *raw = NULL; ptr += sizeof(*header); if (ptr > (uint8_t *)data + size) { fprintf(stderr, "%s: corrupt sample header\n", __FUNCTION__); return; } if (reader->sample_type & PERF_SAMPLE_RAW) { raw = (void *)ptr; ptr += sizeof(raw->size) + raw->size; if (ptr > (uint8_t *)data + size) { fprintf(stderr, "%s: corrupt raw sample\n", __FUNCTION__); return; } } // sanity check if (ptr != (uint8_t *)data + size) { fprintf(stderr, "%s: extra data at end of sample\n", __FUNCTION__); return; } if (reader->raw_cb) reader->raw_cb(reader->cb_cookie, raw->data, raw->size); } static uint64_t read_data_head(struct perf_event_mmap_page *perf_header) { uint64_t data_head = *((volatile uint64_t *)&perf_header->data_head); asm volatile("" ::: "memory"); return data_head; } static void write_data_tail(struct perf_event_mmap_page *perf_header, uint64_t data_tail) { asm volatile("" ::: "memory"); perf_header->data_tail = data_tail; } static void event_read(struct perf_reader *reader) { struct perf_event_mmap_page *perf_header = reader->base; uint64_t buffer_size = (uint64_t)reader->page_size * reader->page_cnt; uint64_t data_head; uint8_t *base = (uint8_t *)reader->base + reader->page_size; uint8_t *sentinel = (uint8_t *)reader->base + buffer_size + reader->page_size; uint8_t *begin, *end; // Consume all the events on this ring, calling the cb function for each one. // The message may fall on the ring boundary, in which case copy the message // into a malloced buffer. for (data_head = read_data_head(perf_header); perf_header->data_tail != data_head; data_head = read_data_head(perf_header)) { uint64_t data_tail = perf_header->data_tail; uint8_t *ptr; begin = base + data_tail % buffer_size; // event header is u64, won't wrap struct perf_event_header *e = (void *)begin; ptr = begin; end = base + (data_tail + e->size) % buffer_size; if (end < begin) { // perf event wraps around the ring, make a contiguous copy reader->buf = realloc(reader->buf, e->size); size_t len = sentinel - begin; memcpy(reader->buf, begin, len); memcpy(reader->buf + len, base, e->size - len); ptr = reader->buf; } if (e->type == PERF_RECORD_LOST) { fprintf(stderr, "Lost %lu samples\n", *(uint64_t *)(ptr + sizeof(*e))); } else if (e->type == PERF_RECORD_SAMPLE) { if (reader->type == PERF_TYPE_TRACEPOINT) parse_tracepoint(reader, ptr, e->size); else if (reader->type == PERF_TYPE_SOFTWARE) parse_sw(reader, ptr, e->size); } else { fprintf(stderr, "%s: unknown sample type %d\n", __FUNCTION__, e->type); } write_data_tail(perf_header, perf_header->data_tail + e->size); } } int perf_reader_poll(int num_readers, struct perf_reader **readers, int timeout) { struct pollfd pfds[num_readers]; int i; for (i = 0; i fd; pfds[i].events = POLLIN; } if (poll(pfds, num_readers, timeout) > 0) { for (i = 0; i < num_readers; ++i) { if (pfds[i].revents & POLLIN) event_read(readers[i]); } } return 0; } void perf_reader_set_fd(struct perf_reader *reader, int fd) { reader->fd = fd; } int perf_reader_fd(struct perf_reader *reader) { return reader->fd; } bpfcc-0.2.0+git0.02884a026/src/cc/perf_reader.h000066400000000000000000000022351305314114400203030ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef PERF_READER_H #define PERF_READER_H #include "libbpf.h" #ifdef __cplusplus extern "C" { #endif struct perf_reader; struct perf_reader * perf_reader_new(perf_reader_cb cb, perf_reader_raw_cb raw_cb, void *cb_cookie); void perf_reader_free(void *ptr); int perf_reader_mmap(struct perf_reader *reader, unsigned type, unsigned long sample_type); int perf_reader_poll(int num_readers, struct perf_reader **readers, int timeout); int perf_reader_fd(struct perf_reader *reader); void perf_reader_set_fd(struct perf_reader *reader, int fd); #ifdef __cplusplus } #endif #endif bpfcc-0.2.0+git0.02884a026/src/cc/shared_table.cc000066400000000000000000000031451305314114400206010ustar00rootroot00000000000000/* * Copyright (c) 2016 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "shared_table.h" #include "compat/linux/bpf.h" namespace ebpf { using std::string; SharedTables * SharedTables::instance_; SharedTables * SharedTables::instance() { if (!instance_) { instance_ = new SharedTables; } return instance_; } int SharedTables::lookup_fd(const string &name) const { auto table = tables_.find(name); if (table == tables_.end()) return -1; return table->second.first; } int SharedTables::lookup_type(const string &name) const { auto table = tables_.find(name); if (table == tables_.end()) return BPF_MAP_TYPE_UNSPEC; return table->second.second; } bool SharedTables::insert_fd(const string &name, int fd, int type) { if (tables_.find(name) != tables_.end()) return false; tables_[name] = std::make_pair(fd, type); return true; } bool SharedTables::remove_fd(const string &name) { auto table = tables_.find(name); if (table == tables_.end()) return false; close(table->second.first); tables_.erase(table); return true; } } bpfcc-0.2.0+git0.02884a026/src/cc/shared_table.h000066400000000000000000000024721305314114400204450ustar00rootroot00000000000000/* * Copyright (c) 2016 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include namespace ebpf { struct TableDesc; class SharedTables { public: static SharedTables * instance(); // add an fd to the shared table, return true if successfully inserted bool insert_fd(const std::string &name, int fd, int type); // lookup an fd in the shared table, or -1 if not found int lookup_fd(const std::string &name) const; // lookup on map type in the shared table, or BPF_MAP_TYPE_UNSPEC if not found int lookup_type(const std::string &name) const; // close and remove a shared fd. return true if the value was found bool remove_fd(const std::string &name); private: static SharedTables *instance_; std::map> tables_; }; } bpfcc-0.2.0+git0.02884a026/src/cc/syms.h000066400000000000000000000061641305314114400170250ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include #include class ProcStat { std::string procfs_; ino_t inode_; ino_t getinode_(); public: ProcStat(int pid); bool is_stale() { return inode_ != getinode_(); } void reset() { inode_ = getinode_(); } }; class SymbolCache { public: virtual ~SymbolCache() = default; virtual void refresh() = 0; virtual bool resolve_addr(uint64_t addr, struct bcc_symbol *sym) = 0; virtual bool resolve_name(const char *module, const char *name, uint64_t *addr) = 0; }; class KSyms : SymbolCache { struct Symbol { Symbol(const char *name, uint64_t addr) : name(name), addr(addr) {} std::string name; uint64_t addr; bool operator<(const Symbol &rhs) const { return addr < rhs.addr; } }; std::vector syms_; std::unordered_map symnames_; static void _add_symbol(const char *, uint64_t, void *); public: virtual bool resolve_addr(uint64_t addr, struct bcc_symbol *sym); virtual bool resolve_name(const char *unused, const char *name, uint64_t *addr); virtual void refresh(); }; class ProcSyms : SymbolCache { struct Symbol { Symbol(const std::string *name, uint64_t start, uint64_t size, int flags = 0) : name(name), start(start), size(size), flags(flags) {} const std::string *name; uint64_t start; uint64_t size; int flags; bool operator<(const struct Symbol& rhs) const { return start < rhs.start; } }; struct Module { Module(const char *name, uint64_t start, uint64_t end); std::string name_; uint64_t start_; uint64_t end_; bool is_so_; std::unordered_set symnames_; std::vector syms_; void load_sym_table(); bool find_addr(uint64_t addr, struct bcc_symbol *sym); bool find_name(const char *symname, uint64_t *addr); bool is_so() const { return is_so_; } bool is_perf_map() const; static int _add_symbol(const char *symname, uint64_t start, uint64_t end, int flags, void *p); }; int pid_; std::vector modules_; ProcStat procstat_; static int _add_module(const char *, uint64_t, uint64_t, void *); bool load_modules(); public: ProcSyms(int pid); virtual void refresh(); virtual bool resolve_addr(uint64_t addr, struct bcc_symbol *sym); virtual bool resolve_name(const char *module, const char *name, uint64_t *addr); }; bpfcc-0.2.0+git0.02884a026/src/cc/table_desc.h000066400000000000000000000021131305314114400201050ustar00rootroot00000000000000/* * Copyright (c) 2015 PLUMgrid, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include namespace llvm { class Function; } namespace ebpf { struct TableDesc { std::string name; int fd; int type; size_t key_size; // sizes are in bytes size_t leaf_size; size_t max_entries; int flags; std::string key_desc; std::string leaf_desc; llvm::Function *key_sscanf; llvm::Function *leaf_sscanf; llvm::Function *key_snprintf; llvm::Function *leaf_snprintf; bool is_shared; bool is_extern; }; } // namespace ebpf bpfcc-0.2.0+git0.02884a026/src/cc/usdt.cc000066400000000000000000000263171305314114400171510ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include "bcc_elf.h" #include "bcc_proc.h" #include "usdt.h" #include "vendor/tinyformat.hpp" #include "bcc_usdt.h" namespace USDT { Location::Location(uint64_t addr, const char *arg_fmt) : address_(addr) { ArgumentParser_x64 parser(arg_fmt); while (!parser.done()) { Argument arg; if (!parser.parse(&arg)) continue; arguments_.push_back(std::move(arg)); } } Probe::Probe(const char *bin_path, const char *provider, const char *name, uint64_t semaphore, const optional &pid) : bin_path_(bin_path), provider_(provider), name_(name), semaphore_(semaphore), pid_(pid) {} bool Probe::in_shared_object() { if (!in_shared_object_) in_shared_object_ = (bcc_elf_is_shared_obj(bin_path_.c_str()) == 1); return in_shared_object_.value(); } bool Probe::resolve_global_address(uint64_t *global, const uint64_t addr) { if (in_shared_object()) { return (pid_ && !bcc_resolve_global_addr(*pid_, bin_path_.c_str(), addr, global)); } *global = addr; return true; } bool Probe::add_to_semaphore(int16_t val) { assert(pid_ && attached_semaphore_); if (!attached_semaphore_) { uint64_t addr; if (!resolve_global_address(&addr, semaphore_)) return false; attached_semaphore_ = addr; } off_t address = static_cast(attached_semaphore_.value()); std::string procmem = tfm::format("/proc/%d/mem", pid_.value()); int memfd = ::open(procmem.c_str(), O_RDWR); if (memfd < 0) return false; int16_t original; if (::lseek(memfd, address, SEEK_SET) < 0 || ::read(memfd, &original, 2) != 2) { ::close(memfd); return false; } original = original + val; if (::lseek(memfd, address, SEEK_SET) < 0 || ::write(memfd, &original, 2) != 2) { ::close(memfd); return false; } ::close(memfd); return true; } bool Probe::enable(const std::string &fn_name) { if (attached_to_) return false; if (need_enable()) { if (!pid_) return false; if (!add_to_semaphore(+1)) return false; } attached_to_ = fn_name; return true; } bool Probe::disable() { if (!attached_to_) return false; attached_to_ = nullopt; if (need_enable()) { assert(pid_); return add_to_semaphore(-1); } return true; } std::string Probe::largest_arg_type(size_t arg_n) { Argument *largest = nullptr; for (Location &location : locations_) { Argument *candidate = &location.arguments_[arg_n]; if (!largest || std::abs(candidate->arg_size()) > std::abs(largest->arg_size())) largest = candidate; } assert(largest); return largest->ctype(); } bool Probe::usdt_getarg(std::ostream &stream) { const size_t arg_count = locations_[0].arguments_.size(); if (!attached_to_) return false; if (arg_count == 0) return true; for (size_t arg_n = 0; arg_n < arg_count; ++arg_n) { std::string ctype = largest_arg_type(arg_n); std::string cptr = tfm::format("*((%s *)dest)", ctype); tfm::format(stream, "static inline int _bpf_readarg_%s_%d(" "struct pt_regs *ctx, void *dest, size_t len) {\n" " if (len != sizeof(%s)) return -1;\n", attached_to_.value(), arg_n + 1, ctype); if (locations_.size() == 1) { Location &location = locations_.front(); stream << " "; if (!location.arguments_[arg_n].assign_to_local(stream, cptr, bin_path_, pid_)) return false; stream << "\n return 0;\n}\n"; } else { stream << " switch(ctx->ip) {\n"; for (Location &location : locations_) { uint64_t global_address; if (!resolve_global_address(&global_address, location.address_)) return false; tfm::format(stream, " case 0x%xULL: ", global_address); if (!location.arguments_[arg_n].assign_to_local(stream, cptr, bin_path_, pid_)) return false; stream << " return 0;\n"; } stream << " }\n"; stream << " return -1;\n}\n"; } } return true; } void Probe::add_location(uint64_t addr, const char *fmt) { locations_.emplace_back(addr, fmt); } void Context::_each_probe(const char *binpath, const struct bcc_elf_usdt *probe, void *p) { Context *ctx = static_cast(p); ctx->add_probe(binpath, probe); } int Context::_each_module(const char *modpath, uint64_t, uint64_t, void *p) { bcc_elf_foreach_usdt(modpath, _each_probe, p); return 0; } void Context::add_probe(const char *binpath, const struct bcc_elf_usdt *probe) { for (auto &p : probes_) { if (p->provider_ == probe->provider && p->name_ == probe->name) { p->add_location(probe->pc, probe->arg_fmt); return; } } probes_.emplace_back( new Probe(binpath, probe->provider, probe->name, probe->semaphore, pid_)); probes_.back()->add_location(probe->pc, probe->arg_fmt); } std::string Context::resolve_bin_path(const std::string &bin_path) { std::string result; if (char *which = bcc_procutils_which(bin_path.c_str())) { result = which; ::free(which); } else if (char *which_so = bcc_procutils_which_so(bin_path.c_str(), 0)) { result = which_so; ::free(which_so); } return result; } Probe *Context::get(const std::string &probe_name) { for (auto &p : probes_) { if (p->name_ == probe_name) return p.get(); } return nullptr; } bool Context::generate_usdt_args(std::ostream &stream) { stream << USDT_PROGRAM_HEADER; for (auto &p : probes_) { if (p->enabled() && !p->usdt_getarg(stream)) return false; } return true; } bool Context::enable_probe(const std::string &probe_name, const std::string &fn_name) { if (pid_stat_ && pid_stat_->is_stale()) return false; auto p = get(probe_name); return p && p->enable(fn_name); } void Context::each(each_cb callback) { for (const auto &probe : probes_) { struct bcc_usdt info = {0}; info.provider = probe->provider().c_str(); info.bin_path = probe->bin_path().c_str(); info.name = probe->name().c_str(); info.semaphore = probe->semaphore(); info.num_locations = probe->num_locations(); info.num_arguments = probe->num_arguments(); callback(&info); } } void Context::each_uprobe(each_uprobe_cb callback) { for (auto &p : probes_) { if (!p->enabled()) continue; for (Location &loc : p->locations_) { callback(p->bin_path_.c_str(), p->attached_to_->c_str(), loc.address_, pid_.value_or(-1)); } } } Context::Context(const std::string &bin_path) : loaded_(false) { std::string full_path = resolve_bin_path(bin_path); if (!full_path.empty()) { if (bcc_elf_foreach_usdt(full_path.c_str(), _each_probe, this) == 0) loaded_ = true; } } Context::Context(int pid) : pid_(pid), pid_stat_(pid), loaded_(false) { if (bcc_procutils_each_module(pid, _each_module, this) == 0) loaded_ = true; } Context::~Context() { if (pid_stat_ && !pid_stat_->is_stale()) { for (auto &p : probes_) p->disable(); } } } extern "C" { void *bcc_usdt_new_frompid(int pid) { USDT::Context *ctx = new USDT::Context(pid); if (!ctx->loaded()) { delete ctx; return nullptr; } return static_cast(ctx); } void *bcc_usdt_new_frompath(const char *path) { USDT::Context *ctx = new USDT::Context(path); if (!ctx->loaded()) { delete ctx; return nullptr; } return static_cast(ctx); } void bcc_usdt_close(void *usdt) { USDT::Context *ctx = static_cast(usdt); delete ctx; } int bcc_usdt_enable_probe(void *usdt, const char *probe_name, const char *fn_name) { USDT::Context *ctx = static_cast(usdt); return ctx->enable_probe(probe_name, fn_name) ? 0 : -1; } const char *bcc_usdt_genargs(void *usdt) { static std::string storage_; USDT::Context *ctx = static_cast(usdt); std::ostringstream stream; if (!ctx->generate_usdt_args(stream)) return nullptr; storage_ = stream.str(); return storage_.c_str(); } const char *bcc_usdt_get_probe_argctype( void *ctx, const char* probe_name, const int arg_index ) { USDT::Probe *p = static_cast(ctx)->get(probe_name); std::string res = p ? p->get_arg_ctype(arg_index) : ""; return res.c_str(); } void bcc_usdt_foreach(void *usdt, bcc_usdt_cb callback) { USDT::Context *ctx = static_cast(usdt); ctx->each(callback); } int bcc_usdt_get_location(void *usdt, const char *probe_name, int index, struct bcc_usdt_location *location) { USDT::Context *ctx = static_cast(usdt); USDT::Probe *probe = ctx->get(probe_name); if (!probe) return -1; if (index < 0 || (size_t)index >= probe->num_locations()) return -1; location->address = probe->address(index); return 0; } int bcc_usdt_get_argument(void *usdt, const char *probe_name, int location_index, int argument_index, struct bcc_usdt_argument *argument) { USDT::Context *ctx = static_cast(usdt); USDT::Probe *probe = ctx->get(probe_name); if (!probe) return -1; if (argument_index < 0 || (size_t)argument_index >= probe->num_arguments()) return -1; if (location_index < 0 || (size_t)location_index >= probe->num_locations()) return -1; auto const &location = probe->location(location_index); auto const &arg = location.arguments_[argument_index]; argument->size = arg.arg_size(); argument->valid = BCC_USDT_ARGUMENT_NONE; if (arg.constant()) { argument->valid |= BCC_USDT_ARGUMENT_CONSTANT; argument->constant = *(arg.constant()); } if (arg.deref_offset()) { argument->valid |= BCC_USDT_ARGUMENT_DEREF_OFFSET; argument->deref_offset = *(arg.deref_offset()); } if (arg.deref_ident()) { argument->valid |= BCC_USDT_ARGUMENT_DEREF_IDENT; argument->deref_ident = arg.deref_ident()->c_str(); } if (arg.base_register_name()) { argument->valid |= BCC_USDT_ARGUMENT_BASE_REGISTER_NAME; argument->base_register_name = arg.base_register_name()->c_str(); } if (arg.index_register_name()) { argument->valid |= BCC_USDT_ARGUMENT_INDEX_REGISTER_NAME; argument->index_register_name = arg.index_register_name()->c_str(); } if (arg.scale()) { argument->valid |= BCC_USDT_ARGUMENT_SCALE; argument->scale = *(arg.scale()); } return 0; } void bcc_usdt_foreach_uprobe(void *usdt, bcc_usdt_uprobe_cb callback) { USDT::Context *ctx = static_cast(usdt); ctx->each_uprobe(callback); } } bpfcc-0.2.0+git0.02884a026/src/cc/usdt.h000066400000000000000000000144731305314114400170130ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #pragma once #include #include #include #include #include "syms.h" #include "vendor/optional.hpp" struct bcc_usdt; namespace USDT { using std::experimental::optional; using std::experimental::nullopt; class ArgumentParser; static const std::string USDT_PROGRAM_HEADER = "#include \n"; class Argument { private: optional arg_size_; optional constant_; optional deref_offset_; optional deref_ident_; optional base_register_name_; optional index_register_name_; optional scale_; bool get_global_address(uint64_t *address, const std::string &binpath, const optional &pid) const; public: Argument(); ~Argument(); bool assign_to_local(std::ostream &stream, const std::string &local_name, const std::string &binpath, const optional &pid = nullopt) const; int arg_size() const { return arg_size_.value_or(sizeof(void *)); } std::string ctype() const; const optional &deref_ident() const { return deref_ident_; } const optional &base_register_name() const { return base_register_name_; } const optional &index_register_name() const { return index_register_name_; } const optional scale() const { return scale_; } const optional constant() const { return constant_; } const optional deref_offset() const { return deref_offset_; } friend class ArgumentParser; }; class ArgumentParser { const char *arg_; ssize_t cur_pos_; void skip_whitespace_from(size_t pos); void skip_until_whitespace_from(size_t pos); protected: virtual bool normalize_register(std::string *reg, int *reg_size) = 0; ssize_t parse_register(ssize_t pos, std::string &name, int &size); ssize_t parse_number(ssize_t pos, optional *number); ssize_t parse_identifier(ssize_t pos, optional *ident); ssize_t parse_base_register(ssize_t pos, Argument *dest); ssize_t parse_index_register(ssize_t pos, Argument *dest); ssize_t parse_scale(ssize_t pos, Argument *dest); ssize_t parse_expr(ssize_t pos, Argument *dest); ssize_t parse_1(ssize_t pos, Argument *dest); void print_error(ssize_t pos); public: bool parse(Argument *dest); bool done() { return cur_pos_ < 0 || arg_[cur_pos_] == '\0'; } ArgumentParser(const char *arg) : arg_(arg), cur_pos_(0) {} }; class ArgumentParser_x64 : public ArgumentParser { enum Register { REG_A, REG_B, REG_C, REG_D, REG_SI, REG_DI, REG_BP, REG_SP, REG_8, REG_9, REG_10, REG_11, REG_12, REG_13, REG_14, REG_15, REG_RIP, }; struct RegInfo { Register reg; int size; }; static const std::unordered_map registers_; bool normalize_register(std::string *reg, int *reg_size); void reg_to_name(std::string *norm, Register reg); public: ArgumentParser_x64(const char *arg) : ArgumentParser(arg) {} }; struct Location { uint64_t address_; std::vector arguments_; Location(uint64_t addr, const char *arg_fmt); }; class Probe { std::string bin_path_; std::string provider_; std::string name_; uint64_t semaphore_; std::vector locations_; optional pid_; optional in_shared_object_; optional attached_to_; optional attached_semaphore_; std::string largest_arg_type(size_t arg_n); bool add_to_semaphore(int16_t val); bool resolve_global_address(uint64_t *global, const uint64_t addr); bool lookup_semaphore_addr(uint64_t *address); void add_location(uint64_t addr, const char *fmt); public: Probe(const char *bin_path, const char *provider, const char *name, uint64_t semaphore, const optional &pid); size_t num_locations() const { return locations_.size(); } size_t num_arguments() const { return locations_.front().arguments_.size(); } uint64_t semaphore() const { return semaphore_; } uint64_t address(size_t n = 0) const { return locations_[n].address_; } const Location &location(size_t n) const { return locations_[n]; } bool usdt_getarg(std::ostream &stream); std::string get_arg_ctype(int arg_index) { return largest_arg_type(arg_index); } bool need_enable() const { return semaphore_ != 0x0; } bool enable(const std::string &fn_name); bool disable(); bool enabled() const { return !!attached_to_; } bool in_shared_object(); const std::string &name() { return name_; } const std::string &bin_path() { return bin_path_; } const std::string &provider() { return provider_; } friend class Context; }; class Context { std::vector> probes_; optional pid_; optional pid_stat_; bool loaded_; static void _each_probe(const char *binpath, const struct bcc_elf_usdt *probe, void *p); static int _each_module(const char *modpath, uint64_t, uint64_t, void *p); void add_probe(const char *binpath, const struct bcc_elf_usdt *probe); std::string resolve_bin_path(const std::string &bin_path); public: Context(const std::string &bin_path); Context(int pid); ~Context(); optional pid() const { return pid_; } bool loaded() const { return loaded_; } size_t num_probes() const { return probes_.size(); } Probe *get(const std::string &probe_name); Probe *get(int pos) { return probes_[pos].get(); } bool enable_probe(const std::string &probe_name, const std::string &fn_name); bool generate_usdt_args(std::ostream &stream); typedef void (*each_cb)(struct bcc_usdt *); void each(each_cb callback); typedef void (*each_uprobe_cb)(const char *, const char *, uint64_t, int); void each_uprobe(each_uprobe_cb callback); }; } bpfcc-0.2.0+git0.02884a026/src/cc/usdt_args.cc000066400000000000000000000231521305314114400201570ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "syms.h" #include "usdt.h" #include "vendor/tinyformat.hpp" #include "bcc_elf.h" #include "bcc_syms.h" namespace USDT { Argument::Argument() {} Argument::~Argument() {} std::string Argument::ctype() const { const int s = arg_size() * 8; return (s < 0) ? tfm::format("int%d_t", -s) : tfm::format("uint%d_t", s); } bool Argument::get_global_address(uint64_t *address, const std::string &binpath, const optional &pid) const { if (pid) { return ProcSyms(*pid) .resolve_name(binpath.c_str(), deref_ident_->c_str(), address); } if (bcc_elf_is_shared_obj(binpath.c_str()) == 0) { struct bcc_symbol sym = {deref_ident_->c_str(), binpath.c_str(), 0x0}; if (!bcc_find_symbol_addr(&sym) && sym.offset) { *address = sym.offset; return true; } } return false; } bool Argument::assign_to_local(std::ostream &stream, const std::string &local_name, const std::string &binpath, const optional &pid) const { if (constant_) { tfm::format(stream, "%s = %d;", local_name, *constant_); return true; } if (!deref_offset_) { tfm::format(stream, "%s = (%s)ctx->%s;", local_name, ctype(), *base_register_name_); return true; } if (deref_offset_ && !deref_ident_) { tfm::format(stream, "{ u64 __addr = ctx->%s + (%d)", *base_register_name_, *deref_offset_); if (index_register_name_) { int scale = scale_.value_or(1); tfm::format(stream, " + (ctx->%s * %d);", *index_register_name_, scale); } else { tfm::format(stream, ";"); } tfm::format(stream, "%s __res = 0x0; " "bpf_probe_read(&__res, sizeof(__res), (void *)__addr); " "%s = __res; }", ctype(), local_name); return true; } if (deref_offset_ && deref_ident_ && *base_register_name_ == "ip") { uint64_t global_address; if (!get_global_address(&global_address, binpath, pid)) return false; tfm::format(stream, "{ u64 __addr = 0x%xull + %d; %s __res = 0x0; " "bpf_probe_read(&__res, sizeof(__res), (void *)__addr); " "%s = __res; }", global_address, *deref_offset_, ctype(), local_name); return true; } return false; } ssize_t ArgumentParser::parse_number(ssize_t pos, optional *result) { char *endp; int number = strtol(arg_ + pos, &endp, 0); if (endp > arg_ + pos) *result = number; return endp - arg_; } ssize_t ArgumentParser::parse_identifier(ssize_t pos, optional *result) { if (isalpha(arg_[pos]) || arg_[pos] == '_') { ssize_t start = pos++; while (isalnum(arg_[pos]) || arg_[pos] == '_') pos++; if (pos - start) result->emplace(arg_ + start, pos - start); } return pos; } ssize_t ArgumentParser::parse_register(ssize_t pos, std::string &name, int &size) { ssize_t start = ++pos; if (arg_[start - 1] != '%') return -start; while (isalnum(arg_[pos])) pos++; std::string regname(arg_ + start, pos - start); if (!normalize_register(®name, &size)) return -start; name = regname; return pos; } ssize_t ArgumentParser::parse_base_register(ssize_t pos, Argument *dest) { int size; std::string name; ssize_t res = parse_register(pos, name, size); if (res < 0) return res; dest->base_register_name_ = name; if (!dest->arg_size_) dest->arg_size_ = size; return res; } ssize_t ArgumentParser::parse_index_register(ssize_t pos, Argument *dest) { int size; std::string name; ssize_t res = parse_register(pos, name, size); if (res < 0) return res; dest->index_register_name_ = name; return res; } ssize_t ArgumentParser::parse_scale(ssize_t pos, Argument *dest) { return parse_number(pos, &dest->scale_); } ssize_t ArgumentParser::parse_expr(ssize_t pos, Argument *dest) { if (arg_[pos] == '$') return parse_number(pos + 1, &dest->constant_); if (arg_[pos] == '%') return parse_base_register(pos, dest); if (isdigit(arg_[pos]) || arg_[pos] == '-') { pos = parse_number(pos, &dest->deref_offset_); if (arg_[pos] == '+') { pos = parse_identifier(pos + 1, &dest->deref_ident_); if (!dest->deref_ident_) return -pos; } } else { dest->deref_offset_ = 0; pos = parse_identifier(pos, &dest->deref_ident_); if (arg_[pos] == '+' || arg_[pos] == '-') { pos = parse_number(pos, &dest->deref_offset_); } } if (arg_[pos] != '(') return -pos; pos = parse_base_register(pos + 1, dest); if (pos < 0) return pos; if (arg_[pos] == ',') { pos = parse_index_register(pos + 1, dest); if (pos < 0) return pos; if (arg_[pos] == ',') { pos = parse_scale(pos + 1, dest); if (pos < 0) return pos; } } return (arg_[pos] == ')') ? pos + 1 : -pos; } ssize_t ArgumentParser::parse_1(ssize_t pos, Argument *dest) { if (isdigit(arg_[pos]) || arg_[pos] == '-') { optional asize; ssize_t m = parse_number(pos, &asize); if (arg_[m] == '@' && asize) { dest->arg_size_ = asize; return parse_expr(m + 1, dest); } } return parse_expr(pos, dest); } void ArgumentParser::print_error(ssize_t pos) { fprintf(stderr, "Parse error:\n %s\n", arg_); for (ssize_t i = 0; i < pos + 4; ++i) fputc('-', stderr); fputc('^', stderr); fputc('\n', stderr); } void ArgumentParser::skip_whitespace_from(size_t pos) { while (isspace(arg_[pos])) pos++; cur_pos_ = pos; } void ArgumentParser::skip_until_whitespace_from(size_t pos) { while (arg_[pos] != '\0' && !isspace(arg_[pos])) pos++; cur_pos_ = pos; } bool ArgumentParser::parse(Argument *dest) { if (done()) return false; ssize_t res = parse_1(cur_pos_, dest); if (res < 0) { print_error(-res); skip_whitespace_from(-res + 1); return false; } if (!isspace(arg_[res]) && arg_[res] != '\0') { print_error(res); skip_until_whitespace_from(res); return false; } skip_whitespace_from(res); return true; } const std::unordered_map ArgumentParser_x64::registers_ = { {"rax", {REG_A, 8}}, {"eax", {REG_A, 4}}, {"ax", {REG_A, 2}}, {"al", {REG_A, 1}}, {"rbx", {REG_B, 8}}, {"ebx", {REG_B, 4}}, {"bx", {REG_B, 2}}, {"bl", {REG_B, 1}}, {"rcx", {REG_C, 8}}, {"ecx", {REG_C, 4}}, {"cx", {REG_C, 2}}, {"cl", {REG_C, 1}}, {"rdx", {REG_D, 8}}, {"edx", {REG_D, 4}}, {"dx", {REG_D, 2}}, {"dl", {REG_D, 1}}, {"rsi", {REG_SI, 8}}, {"esi", {REG_SI, 4}}, {"si", {REG_SI, 2}}, {"sil", {REG_SI, 1}}, {"rdi", {REG_DI, 8}}, {"edi", {REG_DI, 4}}, {"di", {REG_DI, 2}}, {"dil", {REG_DI, 1}}, {"rbp", {REG_BP, 8}}, {"ebp", {REG_BP, 4}}, {"bp", {REG_BP, 2}}, {"bpl", {REG_BP, 1}}, {"rsp", {REG_SP, 8}}, {"esp", {REG_SP, 4}}, {"sp", {REG_SP, 2}}, {"spl", {REG_SP, 1}}, {"r8", {REG_8, 8}}, {"r8d", {REG_8, 4}}, {"r8w", {REG_8, 2}}, {"r8b", {REG_8, 1}}, {"r9", {REG_9, 8}}, {"r9d", {REG_9, 4}}, {"r9w", {REG_9, 2}}, {"r9b", {REG_9, 1}}, {"r10", {REG_10, 8}}, {"r10d", {REG_10, 4}}, {"r10w", {REG_10, 2}}, {"r10b", {REG_10, 1}}, {"r11", {REG_11, 8}}, {"r11d", {REG_11, 4}}, {"r11w", {REG_11, 2}}, {"r11b", {REG_11, 1}}, {"r12", {REG_12, 8}}, {"r12d", {REG_12, 4}}, {"r12w", {REG_12, 2}}, {"r12b", {REG_12, 1}}, {"r13", {REG_13, 8}}, {"r13d", {REG_13, 4}}, {"r13w", {REG_13, 2}}, {"r13b", {REG_13, 1}}, {"r14", {REG_14, 8}}, {"r14d", {REG_14, 4}}, {"r14w", {REG_14, 2}}, {"r14b", {REG_14, 1}}, {"r15", {REG_15, 8}}, {"r15d", {REG_15, 4}}, {"r15w", {REG_15, 2}}, {"r15b", {REG_15, 1}}, {"rip", {REG_RIP, 8}}, }; void ArgumentParser_x64::reg_to_name(std::string *norm, Register reg) { switch (reg) { case REG_A: *norm = "ax"; break; case REG_B: *norm = "bx"; break; case REG_C: *norm = "cx"; break; case REG_D: *norm = "dx"; break; case REG_SI: *norm = "si"; break; case REG_DI: *norm = "di"; break; case REG_BP: *norm = "bp"; break; case REG_SP: *norm = "sp"; break; case REG_8: *norm = "r8"; break; case REG_9: *norm = "r9"; break; case REG_10: *norm = "r10"; break; case REG_11: *norm = "r11"; break; case REG_12: *norm = "r12"; break; case REG_13: *norm = "r13"; break; case REG_14: *norm = "r14"; break; case REG_15: *norm = "r15"; break; case REG_RIP: *norm = "ip"; break; } } bool ArgumentParser_x64::normalize_register(std::string *reg, int *reg_size) { auto it = registers_.find(*reg); if (it == registers_.end()) return false; *reg_size = it->second.size; reg_to_name(reg, it->second.reg); return true; } } bpfcc-0.2.0+git0.02884a026/src/cc/vendor/000077500000000000000000000000001305314114400171475ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/cc/vendor/optional.hpp000066400000000000000000000666731305314114400215270ustar00rootroot00000000000000// Copyright (C) 2011 - 2012 Andrzej Krzemienski. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // The idea and interface is based on Boost.Optional library // authored by Fernando Luis Cacciola Carballal # ifndef ___OPTIONAL_HPP___ # define ___OPTIONAL_HPP___ # include # include # include # include # include # include # include # define TR2_OPTIONAL_REQUIRES(...) typename enable_if<__VA_ARGS__::value, bool>::type = false # if defined __GNUC__ // NOTE: GNUC is also defined for Clang # if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8) # define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___ # elif (__GNUC__ > 4) # define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___ # endif # # if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7) # define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___ # elif (__GNUC__ > 4) # define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___ # endif # # if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1) # define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ # elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9) # define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ # elif (__GNUC__ > 4) # define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ # endif # endif # # if defined __clang_major__ # if (__clang_major__ == 3 && __clang_minor__ >= 5) # define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ # elif (__clang_major__ > 3) # define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ # endif # if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ # define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ # elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2) # define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ # endif # endif # # if defined _MSC_VER # if (_MSC_VER >= 1900) # define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ # endif # endif # if defined __clang__ # if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9) # define OPTIONAL_HAS_THIS_RVALUE_REFS 1 # else # define OPTIONAL_HAS_THIS_RVALUE_REFS 0 # endif # elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ # define OPTIONAL_HAS_THIS_RVALUE_REFS 1 # elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ # define OPTIONAL_HAS_THIS_RVALUE_REFS 1 # else # define OPTIONAL_HAS_THIS_RVALUE_REFS 0 # endif # if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___ # define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1 # define OPTIONAL_CONSTEXPR_INIT_LIST constexpr # else # define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0 # define OPTIONAL_CONSTEXPR_INIT_LIST # endif # if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L) # define OPTIONAL_HAS_MOVE_ACCESSORS 1 # else # define OPTIONAL_HAS_MOVE_ACCESSORS 0 # endif # // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr # if (defined __cplusplus) && (__cplusplus == 201103L) # define OPTIONAL_MUTABLE_CONSTEXPR # else # define OPTIONAL_MUTABLE_CONSTEXPR constexpr # endif namespace std{ namespace experimental{ // BEGIN workaround for missing is_trivially_destructible # if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___ // leave it: it is already there # elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ // leave it: it is already there # elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ // leave it: it is already there # elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS // leave it: the user doesn't want it # else template using is_trivially_destructible = std::has_trivial_destructor; # endif // END workaround for missing is_trivially_destructible # if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___) // leave it; our metafunctions are already defined. # elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_ // leave it; our metafunctions are already defined. # elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___ // leave it: it is already there # elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS // leave it: the user doesn't want it # else // workaround for missing traits in GCC and CLANG template struct is_nothrow_move_constructible { constexpr static bool value = std::is_nothrow_constructible::value; }; template struct is_assignable { template constexpr static bool has_assign(...) { return false; } template () = std::declval(), true)) > // the comma operator is necessary for the cases where operator= returns void constexpr static bool has_assign(bool) { return true; } constexpr static bool value = has_assign(true); }; template struct is_nothrow_move_assignable { template struct has_nothrow_move_assign { constexpr static bool value = false; }; template struct has_nothrow_move_assign { constexpr static bool value = noexcept( std::declval() = std::declval() ); }; constexpr static bool value = has_nothrow_move_assign::value>::value; }; // end workaround # endif // 20.5.4, optional for object types template class optional; // 20.5.5, optional for lvalue reference types template class optional; // workaround: std utility functions aren't constexpr yet template inline constexpr T&& constexpr_forward(typename std::remove_reference::type& t) noexcept { return static_cast(t); } template inline constexpr T&& constexpr_forward(typename std::remove_reference::type&& t) noexcept { static_assert(!std::is_lvalue_reference::value, "!!"); return static_cast(t); } template inline constexpr typename std::remove_reference::type&& constexpr_move(T&& t) noexcept { return static_cast::type&&>(t); } #if defined NDEBUG # define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR) #else # define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR))) #endif namespace detail_ { // static_addressof: a constexpr version of addressof template struct has_overloaded_addressof { template constexpr static bool has_overload(...) { return false; } template ().operator&()) > constexpr static bool has_overload(bool) { return true; } constexpr static bool value = has_overload(true); }; template )> constexpr T* static_addressof(T& ref) { return &ref; } template )> T* static_addressof(T& ref) { return std::addressof(ref); } // the call to convert(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A template U convert(U v) { return v; } } // namespace detail constexpr struct trivial_init_t{} trivial_init{}; // 20.5.6, In-place construction constexpr struct in_place_t{} in_place{}; // 20.5.7, Disengaged state indicator struct nullopt_t { struct init{}; constexpr explicit nullopt_t(init){} }; constexpr nullopt_t nullopt{nullopt_t::init()}; // 20.5.8, class bad_optional_access class bad_optional_access : public logic_error { public: explicit bad_optional_access(const string& what_arg) : logic_error{what_arg} {} explicit bad_optional_access(const char* what_arg) : logic_error{what_arg} {} }; template union storage_t { unsigned char dummy_; T value_; constexpr storage_t( trivial_init_t ) noexcept : dummy_() {}; template constexpr storage_t( Args&&... args ) : value_(constexpr_forward(args)...) {} ~storage_t(){} }; template union constexpr_storage_t { unsigned char dummy_; T value_; constexpr constexpr_storage_t( trivial_init_t ) noexcept : dummy_() {}; template constexpr constexpr_storage_t( Args&&... args ) : value_(constexpr_forward(args)...) {} ~constexpr_storage_t() = default; }; template struct optional_base { bool init_; storage_t storage_; constexpr optional_base() noexcept : init_(false), storage_(trivial_init) {}; explicit constexpr optional_base(const T& v) : init_(true), storage_(v) {} explicit constexpr optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {} template explicit optional_base(in_place_t, Args&&... args) : init_(true), storage_(constexpr_forward(args)...) {} template >)> explicit optional_base(in_place_t, std::initializer_list il, Args&&... args) : init_(true), storage_(il, std::forward(args)...) {} ~optional_base() { if (init_) storage_.value_.T::~T(); } }; template struct constexpr_optional_base { bool init_; constexpr_storage_t storage_; constexpr constexpr_optional_base() noexcept : init_(false), storage_(trivial_init) {}; explicit constexpr constexpr_optional_base(const T& v) : init_(true), storage_(v) {} explicit constexpr constexpr_optional_base(T&& v) : init_(true), storage_(constexpr_move(v)) {} template explicit constexpr constexpr_optional_base(in_place_t, Args&&... args) : init_(true), storage_(constexpr_forward(args)...) {} template >)> OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, std::initializer_list il, Args&&... args) : init_(true), storage_(il, std::forward(args)...) {} ~constexpr_optional_base() = default; }; template using OptionalBase = typename std::conditional< is_trivially_destructible::value, constexpr_optional_base, optional_base >::type; template class optional : private OptionalBase { static_assert( !std::is_same::type, nullopt_t>::value, "bad T" ); static_assert( !std::is_same::type, in_place_t>::value, "bad T" ); constexpr bool initialized() const noexcept { return OptionalBase::init_; } T* dataptr() { return std::addressof(OptionalBase::storage_.value_); } constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase::storage_.value_); } # if OPTIONAL_HAS_THIS_RVALUE_REFS == 1 constexpr const T& contained_val() const& { return OptionalBase::storage_.value_; } # if OPTIONAL_HAS_MOVE_ACCESSORS == 1 OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return std::move(OptionalBase::storage_.value_); } OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase::storage_.value_; } # else T& contained_val() & { return OptionalBase::storage_.value_; } T&& contained_val() && { return std::move(OptionalBase::storage_.value_); } # endif # else constexpr const T& contained_val() const { return OptionalBase::storage_.value_; } T& contained_val() { return OptionalBase::storage_.value_; } # endif void clear() noexcept { if (initialized()) dataptr()->T::~T(); OptionalBase::init_ = false; } template void initialize(Args&&... args) noexcept(noexcept(T(std::forward(args)...))) { assert(!OptionalBase::init_); ::new (static_cast(dataptr())) T(std::forward(args)...); OptionalBase::init_ = true; } template void initialize(std::initializer_list il, Args&&... args) noexcept(noexcept(T(il, std::forward(args)...))) { assert(!OptionalBase::init_); ::new (static_cast(dataptr())) T(il, std::forward(args)...); OptionalBase::init_ = true; } public: typedef T value_type; // 20.5.5.1, constructors constexpr optional() noexcept : OptionalBase() {}; constexpr optional(nullopt_t) noexcept : OptionalBase() {}; optional(const optional& rhs) : OptionalBase() { if (rhs.initialized()) { ::new (static_cast(dataptr())) T(*rhs); OptionalBase::init_ = true; } } optional(optional&& rhs) noexcept(is_nothrow_move_constructible::value) : OptionalBase() { if (rhs.initialized()) { ::new (static_cast(dataptr())) T(std::move(*rhs)); OptionalBase::init_ = true; } } constexpr optional(const T& v) : OptionalBase(v) {} constexpr optional(T&& v) : OptionalBase(constexpr_move(v)) {} template explicit constexpr optional(in_place_t, Args&&... args) : OptionalBase(in_place_t{}, constexpr_forward(args)...) {} template >)> OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, std::initializer_list il, Args&&... args) : OptionalBase(in_place_t{}, il, constexpr_forward(args)...) {} // 20.5.4.2, Destructor ~optional() = default; // 20.5.4.3, assignment optional& operator=(nullopt_t) noexcept { clear(); return *this; } optional& operator=(const optional& rhs) { if (initialized() == true && rhs.initialized() == false) clear(); else if (initialized() == false && rhs.initialized() == true) initialize(*rhs); else if (initialized() == true && rhs.initialized() == true) contained_val() = *rhs; return *this; } optional& operator=(optional&& rhs) noexcept(is_nothrow_move_assignable::value && is_nothrow_move_constructible::value) { if (initialized() == true && rhs.initialized() == false) clear(); else if (initialized() == false && rhs.initialized() == true) initialize(std::move(*rhs)); else if (initialized() == true && rhs.initialized() == true) contained_val() = std::move(*rhs); return *this; } template auto operator=(U&& v) -> typename enable_if < is_same::type, T>::value, optional& >::type { if (initialized()) { contained_val() = std::forward(v); } else { initialize(std::forward(v)); } return *this; } template void emplace(Args&&... args) { clear(); initialize(std::forward(args)...); } template void emplace(initializer_list il, Args&&... args) { clear(); initialize(il, std::forward(args)...); } // 20.5.4.4, Swap void swap(optional& rhs) noexcept(is_nothrow_move_constructible::value && noexcept(swap(declval(), declval()))) { if (initialized() == true && rhs.initialized() == false) { rhs.initialize(std::move(**this)); clear(); } else if (initialized() == false && rhs.initialized() == true) { initialize(std::move(*rhs)); rhs.clear(); } else if (initialized() == true && rhs.initialized() == true) { using std::swap; swap(**this, *rhs); } } // 20.5.4.5, Observers explicit constexpr operator bool() const noexcept { return initialized(); } constexpr T const* operator ->() const { return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr()); } # if OPTIONAL_HAS_MOVE_ACCESSORS == 1 OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() { assert (initialized()); return dataptr(); } constexpr T const& operator *() const& { return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val()); } OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & { assert (initialized()); return contained_val(); } OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && { assert (initialized()); return constexpr_move(contained_val()); } constexpr T const& value() const& { return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); } OPTIONAL_MUTABLE_CONSTEXPR T& value() & { return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); } OPTIONAL_MUTABLE_CONSTEXPR T&& value() && { if (!initialized()) throw bad_optional_access("bad optional access"); return std::move(contained_val()); } # else T* operator ->() { assert (initialized()); return dataptr(); } constexpr T const& operator *() const { return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val()); } T& operator *() { assert (initialized()); return contained_val(); } constexpr T const& value() const { return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); } T& value() { return initialized() ? contained_val() : (throw bad_optional_access("bad optional access"), contained_val()); } # endif # if OPTIONAL_HAS_THIS_RVALUE_REFS == 1 template constexpr T value_or(V&& v) const& { return *this ? **this : detail_::convert(constexpr_forward(v)); } # if OPTIONAL_HAS_MOVE_ACCESSORS == 1 template OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) && { return *this ? constexpr_move(const_cast&>(*this).contained_val()) : detail_::convert(constexpr_forward(v)); } # else template T value_or(V&& v) && { return *this ? constexpr_move(const_cast&>(*this).contained_val()) : detail_::convert(constexpr_forward(v)); } # endif # else template constexpr T value_or(V&& v) const { return *this ? **this : detail_::convert(constexpr_forward(v)); } # endif }; template class optional { static_assert( !std::is_same::value, "bad T" ); static_assert( !std::is_same::value, "bad T" ); T* ref; public: // 20.5.5.1, construction/destruction constexpr optional() noexcept : ref(nullptr) {} constexpr optional(nullopt_t) noexcept : ref(nullptr) {} constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {} optional(T&&) = delete; constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {} explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {} explicit optional(in_place_t, T&&) = delete; ~optional() = default; // 20.5.5.2, mutation optional& operator=(nullopt_t) noexcept { ref = nullptr; return *this; } // optional& operator=(const optional& rhs) noexcept { // ref = rhs.ref; // return *this; // } // optional& operator=(optional&& rhs) noexcept { // ref = rhs.ref; // return *this; // } template auto operator=(U&& rhs) noexcept -> typename enable_if < is_same::type, optional>::value, optional& >::type { ref = rhs.ref; return *this; } template auto operator=(U&& rhs) noexcept -> typename enable_if < !is_same::type, optional>::value, optional& >::type = delete; void emplace(T& v) noexcept { ref = detail_::static_addressof(v); } void emplace(T&&) = delete; void swap(optional& rhs) noexcept { std::swap(ref, rhs.ref); } // 20.5.5.3, observers constexpr T* operator->() const { return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref); } constexpr T& operator*() const { return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref); } constexpr T& value() const { return ref ? *ref : (throw bad_optional_access("bad optional access"), *ref); } explicit constexpr operator bool() const noexcept { return ref != nullptr; } template constexpr typename decay::type value_or(V&& v) const { return *this ? **this : detail_::convert::type>(constexpr_forward(v)); } }; template class optional { static_assert( sizeof(T) == 0, "optional rvalue references disallowed" ); }; // 20.5.8, Relational operators template constexpr bool operator==(const optional& x, const optional& y) { return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y; } template constexpr bool operator!=(const optional& x, const optional& y) { return !(x == y); } template constexpr bool operator<(const optional& x, const optional& y) { return (!y) ? false : (!x) ? true : *x < *y; } template constexpr bool operator>(const optional& x, const optional& y) { return (y < x); } template constexpr bool operator<=(const optional& x, const optional& y) { return !(y < x); } template constexpr bool operator>=(const optional& x, const optional& y) { return !(x < y); } // 20.5.9, Comparison with nullopt template constexpr bool operator==(const optional& x, nullopt_t) noexcept { return (!x); } template constexpr bool operator==(nullopt_t, const optional& x) noexcept { return (!x); } template constexpr bool operator!=(const optional& x, nullopt_t) noexcept { return bool(x); } template constexpr bool operator!=(nullopt_t, const optional& x) noexcept { return bool(x); } template constexpr bool operator<(const optional&, nullopt_t) noexcept { return false; } template constexpr bool operator<(nullopt_t, const optional& x) noexcept { return bool(x); } template constexpr bool operator<=(const optional& x, nullopt_t) noexcept { return (!x); } template constexpr bool operator<=(nullopt_t, const optional&) noexcept { return true; } template constexpr bool operator>(const optional& x, nullopt_t) noexcept { return bool(x); } template constexpr bool operator>(nullopt_t, const optional&) noexcept { return false; } template constexpr bool operator>=(const optional&, nullopt_t) noexcept { return true; } template constexpr bool operator>=(nullopt_t, const optional& x) noexcept { return (!x); } // 20.5.10, Comparison with T template constexpr bool operator==(const optional& x, const T& v) { return bool(x) ? *x == v : false; } template constexpr bool operator==(const T& v, const optional& x) { return bool(x) ? v == *x : false; } template constexpr bool operator!=(const optional& x, const T& v) { return bool(x) ? *x != v : true; } template constexpr bool operator!=(const T& v, const optional& x) { return bool(x) ? v != *x : true; } template constexpr bool operator<(const optional& x, const T& v) { return bool(x) ? *x < v : true; } template constexpr bool operator>(const T& v, const optional& x) { return bool(x) ? v > *x : true; } template constexpr bool operator>(const optional& x, const T& v) { return bool(x) ? *x > v : false; } template constexpr bool operator<(const T& v, const optional& x) { return bool(x) ? v < *x : false; } template constexpr bool operator>=(const optional& x, const T& v) { return bool(x) ? *x >= v : false; } template constexpr bool operator<=(const T& v, const optional& x) { return bool(x) ? v <= *x : false; } template constexpr bool operator<=(const optional& x, const T& v) { return bool(x) ? *x <= v : true; } template constexpr bool operator>=(const T& v, const optional& x) { return bool(x) ? v >= *x : true; } // Comparison of optional with T template constexpr bool operator==(const optional& x, const T& v) { return bool(x) ? *x == v : false; } template constexpr bool operator==(const T& v, const optional& x) { return bool(x) ? v == *x : false; } template constexpr bool operator!=(const optional& x, const T& v) { return bool(x) ? *x != v : true; } template constexpr bool operator!=(const T& v, const optional& x) { return bool(x) ? v != *x : true; } template constexpr bool operator<(const optional& x, const T& v) { return bool(x) ? *x < v : true; } template constexpr bool operator>(const T& v, const optional& x) { return bool(x) ? v > *x : true; } template constexpr bool operator>(const optional& x, const T& v) { return bool(x) ? *x > v : false; } template constexpr bool operator<(const T& v, const optional& x) { return bool(x) ? v < *x : false; } template constexpr bool operator>=(const optional& x, const T& v) { return bool(x) ? *x >= v : false; } template constexpr bool operator<=(const T& v, const optional& x) { return bool(x) ? v <= *x : false; } template constexpr bool operator<=(const optional& x, const T& v) { return bool(x) ? *x <= v : true; } template constexpr bool operator>=(const T& v, const optional& x) { return bool(x) ? v >= *x : true; } // Comparison of optional with T template constexpr bool operator==(const optional& x, const T& v) { return bool(x) ? *x == v : false; } template constexpr bool operator==(const T& v, const optional& x) { return bool(x) ? v == *x : false; } template constexpr bool operator!=(const optional& x, const T& v) { return bool(x) ? *x != v : true; } template constexpr bool operator!=(const T& v, const optional& x) { return bool(x) ? v != *x : true; } template constexpr bool operator<(const optional& x, const T& v) { return bool(x) ? *x < v : true; } template constexpr bool operator>(const T& v, const optional& x) { return bool(x) ? v > *x : true; } template constexpr bool operator>(const optional& x, const T& v) { return bool(x) ? *x > v : false; } template constexpr bool operator<(const T& v, const optional& x) { return bool(x) ? v < *x : false; } template constexpr bool operator>=(const optional& x, const T& v) { return bool(x) ? *x >= v : false; } template constexpr bool operator<=(const T& v, const optional& x) { return bool(x) ? v <= *x : false; } template constexpr bool operator<=(const optional& x, const T& v) { return bool(x) ? *x <= v : true; } template constexpr bool operator>=(const T& v, const optional& x) { return bool(x) ? v >= *x : true; } // 20.5.12, Specialized algorithms template void swap(optional& x, optional& y) noexcept(noexcept(x.swap(y))) { x.swap(y); } template constexpr optional::type> make_optional(T&& v) { return optional::type>(constexpr_forward(v)); } template constexpr optional make_optional(reference_wrapper v) { return optional(v.get()); } } // namespace experimental } // namespace std namespace std { template struct hash> { typedef typename hash::result_type result_type; typedef std::experimental::optional argument_type; constexpr result_type operator()(argument_type const& arg) const { return arg ? std::hash{}(*arg) : result_type{}; } }; template struct hash> { typedef typename hash::result_type result_type; typedef std::experimental::optional argument_type; constexpr result_type operator()(argument_type const& arg) const { return arg ? std::hash{}(*arg) : result_type{}; } }; } # undef TR2_OPTIONAL_REQUIRES # undef TR2_OPTIONAL_ASSERTED_EXPRESSION # endif //___OPTIONAL_HPP___ bpfcc-0.2.0+git0.02884a026/src/cc/vendor/tinyformat.hpp000066400000000000000000001234221305314114400220600ustar00rootroot00000000000000// tinyformat.h // Copyright (C) 2011, Chris Foster [chris42f (at) gmail (d0t) com] // // Boost Software License - Version 1.0 // // Permission is hereby granted, free of charge, to any person or organization // obtaining a copy of the software and accompanying documentation covered by // this license (the "Software") to use, reproduce, display, distribute, // execute, and transmit the Software, and to prepare derivative works of the // Software, and to permit third-parties to whom the Software is furnished to // do so, all subject to the following: // // The copyright notices in the Software and this entire statement, including // the above license grant, this restriction and the following disclaimer, // must be included in all copies of the Software, in whole or in part, and // all derivative works of the Software, unless such copies or derivative // works are solely in the form of machine-executable object code generated by // a source language processor. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT // SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE // FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. //------------------------------------------------------------------------------ // Tinyformat: A minimal type safe printf replacement // // tinyformat.h is a type safe printf replacement library in a single C++ // header file. Design goals include: // // * Type safety and extensibility for user defined types. // * C99 printf() compatibility, to the extent possible using std::ostream // * Simplicity and minimalism. A single header file to include and distribute // with your projects. // * Augment rather than replace the standard stream formatting mechanism // * C++98 support, with optional C++11 niceties // // // Main interface example usage // ---------------------------- // // To print a date to std::cout: // // std::string weekday = "Wednesday"; // const char* month = "July"; // size_t day = 27; // long hour = 14; // int min = 44; // // tfm::printf("%s, %s %d, %.2d:%.2d\n", weekday, month, day, hour, min); // // The strange types here emphasize the type safety of the interface; it is // possible to print a std::string using the "%s" conversion, and a // size_t using the "%d" conversion. A similar result could be achieved // using either of the tfm::format() functions. One prints on a user provided // stream: // // tfm::format(std::cerr, "%s, %s %d, %.2d:%.2d\n", // weekday, month, day, hour, min); // // The other returns a std::string: // // std::string date = tfm::format("%s, %s %d, %.2d:%.2d\n", // weekday, month, day, hour, min); // std::cout << date; // // These are the three primary interface functions. There is also a // convenience function printfln() which appends a newline to the usual result // of printf() for super simple logging. // // // User defined format functions // ----------------------------- // // Simulating variadic templates in C++98 is pretty painful since it requires // writing out the same function for each desired number of arguments. To make // this bearable tinyformat comes with a set of macros which are used // internally to generate the API, but which may also be used in user code. // // The three macros TINYFORMAT_ARGTYPES(n), TINYFORMAT_VARARGS(n) and // TINYFORMAT_PASSARGS(n) will generate a list of n argument types, // type/name pairs and argument names respectively when called with an integer // n between 1 and 16. We can use these to define a macro which generates the // desired user defined function with n arguments. To generate all 16 user // defined function bodies, use the macro TINYFORMAT_FOREACH_ARGNUM. For an // example, see the implementation of printf() at the end of the source file. // // Sometimes it's useful to be able to pass a list of format arguments through // to a non-template function. The FormatList class is provided as a way to do // this by storing the argument list in a type-opaque way. Continuing the // example from above, we construct a FormatList using makeFormatList(): // // FormatListRef formatList = tfm::makeFormatList(weekday, month, day, hour, min); // // The format list can now be passed into any non-template function and used // via a call to the vformat() function: // // tfm::vformat(std::cout, "%s, %s %d, %.2d:%.2d\n", formatList); // // // Additional API information // -------------------------- // // Error handling: Define TINYFORMAT_ERROR to customize the error handling for // format strings which are unsupported or have the wrong number of format // specifiers (calls assert() by default). // // User defined types: Uses operator<< for user defined types by default. // Overload formatValue() for more control. #ifndef TINYFORMAT_H_INCLUDED #define TINYFORMAT_H_INCLUDED namespace tinyformat {} //------------------------------------------------------------------------------ // Config section. Customize to your liking! // Namespace alias to encourage brevity namespace tfm = tinyformat; // Error handling; calls assert() by default. // #define TINYFORMAT_ERROR(reasonString) your_error_handler(reasonString) // Define for C++11 variadic templates which make the code shorter & more // general. If you don't define this, C++11 support is autodetected below. // #define TINYFORMAT_USE_VARIADIC_TEMPLATES //------------------------------------------------------------------------------ // Implementation details. #include #include #include #include #ifndef TINYFORMAT_ERROR # define TINYFORMAT_ERROR(reason) assert(0 && reason) #endif #if !defined(TINYFORMAT_USE_VARIADIC_TEMPLATES) && !defined(TINYFORMAT_NO_VARIADIC_TEMPLATES) # ifdef __GXX_EXPERIMENTAL_CXX0X__ # define TINYFORMAT_USE_VARIADIC_TEMPLATES # endif #endif #if defined(__GLIBCXX__) && __GLIBCXX__ < 20080201 // std::showpos is broken on old libstdc++ as provided with OSX. See // http://gcc.gnu.org/ml/libstdc++/2007-11/msg00075.html # define TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND #endif #ifdef __APPLE__ // Workaround OSX linker warning: xcode uses different default symbol // visibilities for static libs vs executables (see issue #25) # define TINYFORMAT_HIDDEN __attribute__((visibility("hidden"))) #else # define TINYFORMAT_HIDDEN #endif namespace tinyformat { //------------------------------------------------------------------------------ namespace detail { // Test whether type T1 is convertible to type T2 template struct is_convertible { private: // two types of different size struct fail { char dummy[2]; }; struct succeed { char dummy; }; // Try to convert a T1 to a T2 by plugging into tryConvert static fail tryConvert(...); static succeed tryConvert(const T2&); static const T1& makeT1(); public: # ifdef _MSC_VER // Disable spurious loss of precision warnings in tryConvert(makeT1()) # pragma warning(push) # pragma warning(disable:4244) # pragma warning(disable:4267) # endif // Standard trick: the (...) version of tryConvert will be chosen from // the overload set only if the version taking a T2 doesn't match. // Then we compare the sizes of the return types to check which // function matched. Very neat, in a disgusting kind of way :) static const bool value = sizeof(tryConvert(makeT1())) == sizeof(succeed); # ifdef _MSC_VER # pragma warning(pop) # endif }; // Detect when a type is not a wchar_t string template struct is_wchar { typedef int tinyformat_wchar_is_not_supported; }; template<> struct is_wchar {}; template<> struct is_wchar {}; template struct is_wchar {}; template struct is_wchar {}; // Format the value by casting to type fmtT. This default implementation // should never be called. template::value> struct formatValueAsType { static void invoke(std::ostream& /*out*/, const T& /*value*/) { assert(0); } }; // Specialized version for types that can actually be converted to fmtT, as // indicated by the "convertible" template parameter. template struct formatValueAsType { static void invoke(std::ostream& out, const T& value) { out << static_cast(value); } }; #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND template::value> struct formatZeroIntegerWorkaround { static bool invoke(std::ostream& /**/, const T& /**/) { return false; } }; template struct formatZeroIntegerWorkaround { static bool invoke(std::ostream& out, const T& value) { if (static_cast(value) == 0 && out.flags() & std::ios::showpos) { out << "+0"; return true; } return false; } }; #endif // TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND // Convert an arbitrary type to integer. The version with convertible=false // throws an error. template::value> struct convertToInt { static int invoke(const T& /*value*/) { TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to " "integer for use as variable width or precision"); return 0; } }; // Specialization for convertToInt when conversion is possible template struct convertToInt { static int invoke(const T& value) { return static_cast(value); } }; // Format at most ntrunc characters to the given stream. template inline void formatTruncated(std::ostream& out, const T& value, int ntrunc) { std::ostringstream tmp; tmp << value; std::string result = tmp.str(); out.write(result.c_str(), std::min(ntrunc, static_cast(result.size()))); } #define TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(type) \ inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \ { \ std::streamsize len = 0; \ while(len < ntrunc && value[len] != 0) \ ++len; \ out.write(value, len); \ } // Overload for const char* and char*. Could overload for signed & unsigned // char too, but these are technically unneeded for printf compatibility. TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(const char) TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR(char) #undef TINYFORMAT_DEFINE_FORMAT_TRUNCATED_CSTR } // namespace detail //------------------------------------------------------------------------------ // Variable formatting functions. May be overridden for user-defined types if // desired. /// Format a value into a stream, delegating to operator<< by default. /// /// Users may override this for their own types. When this function is called, /// the stream flags will have been modified according to the format string. /// The format specification is provided in the range [fmtBegin, fmtEnd). For /// truncating conversions, ntrunc is set to the desired maximum number of /// characters, for example "%.7s" calls formatValue with ntrunc = 7. /// /// By default, formatValue() uses the usual stream insertion operator /// operator<< to format the type T, with special cases for the %c and %p /// conversions. template inline void formatValue(std::ostream& out, const char* /*fmtBegin*/, const char* fmtEnd, int ntrunc, const T& value) { #ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS // Since we don't support printing of wchar_t using "%ls", make it fail at // compile time in preference to printing as a void* at runtime. typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; (void) DummyType(); // avoid unused type warning with gcc-4.8 #endif // The mess here is to support the %c and %p conversions: if these // conversions are active we try to convert the type to a char or const // void* respectively and format that instead of the value itself. For the // %p conversion it's important to avoid dereferencing the pointer, which // could otherwise lead to a crash when printing a dangling (const char*). bool canConvertToChar = detail::is_convertible::value; bool canConvertToVoidPtr = detail::is_convertible::value; if(canConvertToChar && *(fmtEnd-1) == 'c') detail::formatValueAsType::invoke(out, value); else if(canConvertToVoidPtr && *(fmtEnd-1) == 'p') detail::formatValueAsType::invoke(out, value); #ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND else if(detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; #endif else if(ntrunc >= 0) { // Take care not to overread C strings in truncating conversions like // "%.4s" where at most 4 characters may be read. detail::formatTruncated(out, value, ntrunc); } else out << value; } // Overloaded version for char types to support printing as an integer #define TINYFORMAT_DEFINE_FORMATVALUE_CHAR(charType) \ inline void formatValue(std::ostream& out, const char* /*fmtBegin*/, \ const char* fmtEnd, int /**/, charType value) \ { \ switch(*(fmtEnd-1)) \ { \ case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \ out << static_cast(value); break; \ default: \ out << value; break; \ } \ } // per 3.9.1: char, signed char and unsigned char are all distinct types TINYFORMAT_DEFINE_FORMATVALUE_CHAR(char) TINYFORMAT_DEFINE_FORMATVALUE_CHAR(signed char) TINYFORMAT_DEFINE_FORMATVALUE_CHAR(unsigned char) #undef TINYFORMAT_DEFINE_FORMATVALUE_CHAR //------------------------------------------------------------------------------ // Tools for emulating variadic templates in C++98. The basic idea here is // stolen from the boost preprocessor metaprogramming library and cut down to // be just general enough for what we need. #define TINYFORMAT_ARGTYPES(n) TINYFORMAT_ARGTYPES_ ## n #define TINYFORMAT_VARARGS(n) TINYFORMAT_VARARGS_ ## n #define TINYFORMAT_PASSARGS(n) TINYFORMAT_PASSARGS_ ## n #define TINYFORMAT_PASSARGS_TAIL(n) TINYFORMAT_PASSARGS_TAIL_ ## n // To keep it as transparent as possible, the macros below have been generated // using python via the excellent cog.py code generation script. This avoids // the need for a bunch of complex (but more general) preprocessor tricks as // used in boost.preprocessor. // // To rerun the code generation in place, use `cog.py -r tinyformat.h` // (see http://nedbatchelder.com/code/cog). Alternatively you can just create // extra versions by hand. /*[[[cog maxParams = 16 def makeCommaSepLists(lineTemplate, elemTemplate, startInd=1): for j in range(startInd,maxParams+1): list = ', '.join([elemTemplate % {'i':i} for i in range(startInd,j+1)]) cog.outl(lineTemplate % {'j':j, 'list':list}) makeCommaSepLists('#define TINYFORMAT_ARGTYPES_%(j)d %(list)s', 'class T%(i)d') cog.outl() makeCommaSepLists('#define TINYFORMAT_VARARGS_%(j)d %(list)s', 'const T%(i)d& v%(i)d') cog.outl() makeCommaSepLists('#define TINYFORMAT_PASSARGS_%(j)d %(list)s', 'v%(i)d') cog.outl() cog.outl('#define TINYFORMAT_PASSARGS_TAIL_1') makeCommaSepLists('#define TINYFORMAT_PASSARGS_TAIL_%(j)d , %(list)s', 'v%(i)d', startInd = 2) cog.outl() cog.outl('#define TINYFORMAT_FOREACH_ARGNUM(m) \\\n ' + ' '.join(['m(%d)' % (j,) for j in range(1,maxParams+1)])) ]]]*/ #define TINYFORMAT_ARGTYPES_1 class T1 #define TINYFORMAT_ARGTYPES_2 class T1, class T2 #define TINYFORMAT_ARGTYPES_3 class T1, class T2, class T3 #define TINYFORMAT_ARGTYPES_4 class T1, class T2, class T3, class T4 #define TINYFORMAT_ARGTYPES_5 class T1, class T2, class T3, class T4, class T5 #define TINYFORMAT_ARGTYPES_6 class T1, class T2, class T3, class T4, class T5, class T6 #define TINYFORMAT_ARGTYPES_7 class T1, class T2, class T3, class T4, class T5, class T6, class T7 #define TINYFORMAT_ARGTYPES_8 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8 #define TINYFORMAT_ARGTYPES_9 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9 #define TINYFORMAT_ARGTYPES_10 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10 #define TINYFORMAT_ARGTYPES_11 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11 #define TINYFORMAT_ARGTYPES_12 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12 #define TINYFORMAT_ARGTYPES_13 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13 #define TINYFORMAT_ARGTYPES_14 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14 #define TINYFORMAT_ARGTYPES_15 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15 #define TINYFORMAT_ARGTYPES_16 class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class T11, class T12, class T13, class T14, class T15, class T16 #define TINYFORMAT_VARARGS_1 const T1& v1 #define TINYFORMAT_VARARGS_2 const T1& v1, const T2& v2 #define TINYFORMAT_VARARGS_3 const T1& v1, const T2& v2, const T3& v3 #define TINYFORMAT_VARARGS_4 const T1& v1, const T2& v2, const T3& v3, const T4& v4 #define TINYFORMAT_VARARGS_5 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5 #define TINYFORMAT_VARARGS_6 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6 #define TINYFORMAT_VARARGS_7 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7 #define TINYFORMAT_VARARGS_8 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8 #define TINYFORMAT_VARARGS_9 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9 #define TINYFORMAT_VARARGS_10 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10 #define TINYFORMAT_VARARGS_11 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11 #define TINYFORMAT_VARARGS_12 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12 #define TINYFORMAT_VARARGS_13 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13 #define TINYFORMAT_VARARGS_14 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14 #define TINYFORMAT_VARARGS_15 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15 #define TINYFORMAT_VARARGS_16 const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5, const T6& v6, const T7& v7, const T8& v8, const T9& v9, const T10& v10, const T11& v11, const T12& v12, const T13& v13, const T14& v14, const T15& v15, const T16& v16 #define TINYFORMAT_PASSARGS_1 v1 #define TINYFORMAT_PASSARGS_2 v1, v2 #define TINYFORMAT_PASSARGS_3 v1, v2, v3 #define TINYFORMAT_PASSARGS_4 v1, v2, v3, v4 #define TINYFORMAT_PASSARGS_5 v1, v2, v3, v4, v5 #define TINYFORMAT_PASSARGS_6 v1, v2, v3, v4, v5, v6 #define TINYFORMAT_PASSARGS_7 v1, v2, v3, v4, v5, v6, v7 #define TINYFORMAT_PASSARGS_8 v1, v2, v3, v4, v5, v6, v7, v8 #define TINYFORMAT_PASSARGS_9 v1, v2, v3, v4, v5, v6, v7, v8, v9 #define TINYFORMAT_PASSARGS_10 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 #define TINYFORMAT_PASSARGS_11 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 #define TINYFORMAT_PASSARGS_12 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12 #define TINYFORMAT_PASSARGS_13 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13 #define TINYFORMAT_PASSARGS_14 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14 #define TINYFORMAT_PASSARGS_15 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 #define TINYFORMAT_PASSARGS_16 v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16 #define TINYFORMAT_PASSARGS_TAIL_1 #define TINYFORMAT_PASSARGS_TAIL_2 , v2 #define TINYFORMAT_PASSARGS_TAIL_3 , v2, v3 #define TINYFORMAT_PASSARGS_TAIL_4 , v2, v3, v4 #define TINYFORMAT_PASSARGS_TAIL_5 , v2, v3, v4, v5 #define TINYFORMAT_PASSARGS_TAIL_6 , v2, v3, v4, v5, v6 #define TINYFORMAT_PASSARGS_TAIL_7 , v2, v3, v4, v5, v6, v7 #define TINYFORMAT_PASSARGS_TAIL_8 , v2, v3, v4, v5, v6, v7, v8 #define TINYFORMAT_PASSARGS_TAIL_9 , v2, v3, v4, v5, v6, v7, v8, v9 #define TINYFORMAT_PASSARGS_TAIL_10 , v2, v3, v4, v5, v6, v7, v8, v9, v10 #define TINYFORMAT_PASSARGS_TAIL_11 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 #define TINYFORMAT_PASSARGS_TAIL_12 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12 #define TINYFORMAT_PASSARGS_TAIL_13 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13 #define TINYFORMAT_PASSARGS_TAIL_14 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14 #define TINYFORMAT_PASSARGS_TAIL_15 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 #define TINYFORMAT_PASSARGS_TAIL_16 , v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16 #define TINYFORMAT_FOREACH_ARGNUM(m) \ m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) m(9) m(10) m(11) m(12) m(13) m(14) m(15) m(16) //[[[end]]] namespace detail { // Type-opaque holder for an argument to format(), with associated actions on // the type held as explicit function pointers. This allows FormatArg's for // each argument to be allocated as a homogenous array inside FormatList // whereas a naive implementation based on inheritance does not. class FormatArg { public: FormatArg() {} template FormatArg(const T& value) : m_value(static_cast(&value)), m_formatImpl(&formatImpl), m_toIntImpl(&toIntImpl) { } void format(std::ostream& out, const char* fmtBegin, const char* fmtEnd, int ntrunc) const { m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value); } int toInt() const { return m_toIntImpl(m_value); } private: template TINYFORMAT_HIDDEN static void formatImpl(std::ostream& out, const char* fmtBegin, const char* fmtEnd, int ntrunc, const void* value) { formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); } template TINYFORMAT_HIDDEN static int toIntImpl(const void* value) { return convertToInt::invoke(*static_cast(value)); } const void* m_value; void (*m_formatImpl)(std::ostream& out, const char* fmtBegin, const char* fmtEnd, int ntrunc, const void* value); int (*m_toIntImpl)(const void* value); }; // Parse and return an integer from the string c, as atoi() // On return, c is set to one past the end of the integer. inline int parseIntAndAdvance(const char*& c) { int i = 0; for(;*c >= '0' && *c <= '9'; ++c) i = 10*i + (*c - '0'); return i; } // Print literal part of format string and return next format spec // position. // // Skips over any occurrences of '%%', printing a literal '%' to the // output. The position of the first % character of the next // nontrivial format spec is returned, or the end of string. inline const char* printFormatStringLiteral(std::ostream& out, const char* fmt) { const char* c = fmt; for(;; ++c) { switch(*c) { case '\0': out.write(fmt, c - fmt); return c; case '%': out.write(fmt, c - fmt); if(*(c+1) != '%') return c; // for "%%", tack trailing % onto next literal section. fmt = ++c; break; default: break; } } } // Parse a format string and set the stream state accordingly. // // The format mini-language recognized here is meant to be the one from C99, // with the form "%[flags][width][.precision][length]type". // // Formatting options which can't be natively represented using the ostream // state are returned in spacePadPositive (for space padded positive numbers) // and ntrunc (for truncating conversions). argIndex is incremented if // necessary to pull out variable width and precision . The function returns a // pointer to the character after the end of the current format spec. inline const char* streamStateFromFormat(std::ostream& out, bool& spacePadPositive, int& ntrunc, const char* fmtStart, const detail::FormatArg* formatters, int& argIndex, int numFormatters) { if(*fmtStart != '%') { TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string"); return fmtStart; } // Reset stream state to defaults. out.width(0); out.precision(6); out.fill(' '); // Reset most flags; ignore irrelevant unitbuf & skipws. out.unsetf(std::ios::adjustfield | std::ios::basefield | std::ios::floatfield | std::ios::showbase | std::ios::boolalpha | std::ios::showpoint | std::ios::showpos | std::ios::uppercase); bool precisionSet = false; bool widthSet = false; int widthExtra = 0; const char* c = fmtStart + 1; // 1) Parse flags for(;; ++c) { switch(*c) { case '#': out.setf(std::ios::showpoint | std::ios::showbase); continue; case '0': // overridden by left alignment ('-' flag) if(!(out.flags() & std::ios::left)) { // Use internal padding so that numeric values are // formatted correctly, eg -00010 rather than 000-10 out.fill('0'); out.setf(std::ios::internal, std::ios::adjustfield); } continue; case '-': out.fill(' '); out.setf(std::ios::left, std::ios::adjustfield); continue; case ' ': // overridden by show positive sign, '+' flag. if(!(out.flags() & std::ios::showpos)) spacePadPositive = true; continue; case '+': out.setf(std::ios::showpos); spacePadPositive = false; widthExtra = 1; continue; default: break; } break; } // 2) Parse width if(*c >= '0' && *c <= '9') { widthSet = true; out.width(parseIntAndAdvance(c)); } if(*c == '*') { widthSet = true; int width = 0; if(argIndex < numFormatters) width = formatters[argIndex++].toInt(); else TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width"); if(width < 0) { // negative widths correspond to '-' flag set out.fill(' '); out.setf(std::ios::left, std::ios::adjustfield); width = -width; } out.width(width); ++c; } // 3) Parse precision if(*c == '.') { ++c; int precision = 0; if(*c == '*') { ++c; if(argIndex < numFormatters) precision = formatters[argIndex++].toInt(); else TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable precision"); } else { if(*c >= '0' && *c <= '9') precision = parseIntAndAdvance(c); else if(*c == '-') // negative precisions ignored, treated as zero. parseIntAndAdvance(++c); } out.precision(precision); precisionSet = true; } // 4) Ignore any C99 length modifier while(*c == 'l' || *c == 'h' || *c == 'L' || *c == 'j' || *c == 'z' || *c == 't') ++c; // 5) We're up to the conversion specifier character. // Set stream flags based on conversion specifier (thanks to the // boost::format class for forging the way here). bool intConversion = false; switch(*c) { case 'u': case 'd': case 'i': out.setf(std::ios::dec, std::ios::basefield); intConversion = true; break; case 'o': out.setf(std::ios::oct, std::ios::basefield); intConversion = true; break; case 'X': out.setf(std::ios::uppercase); case 'x': case 'p': out.setf(std::ios::hex, std::ios::basefield); intConversion = true; break; case 'E': out.setf(std::ios::uppercase); case 'e': out.setf(std::ios::scientific, std::ios::floatfield); out.setf(std::ios::dec, std::ios::basefield); break; case 'F': out.setf(std::ios::uppercase); case 'f': out.setf(std::ios::fixed, std::ios::floatfield); break; case 'G': out.setf(std::ios::uppercase); case 'g': out.setf(std::ios::dec, std::ios::basefield); // As in boost::format, let stream decide float format. out.flags(out.flags() & ~std::ios::floatfield); break; case 'a': case 'A': TINYFORMAT_ERROR("tinyformat: the %a and %A conversion specs " "are not supported"); break; case 'c': // Handled as special case inside formatValue() break; case 's': if(precisionSet) ntrunc = static_cast(out.precision()); // Make %s print booleans as "true" and "false" out.setf(std::ios::boolalpha); break; case 'n': // Not supported - will cause problems! TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported"); break; case '\0': TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly " "terminated by end of string"); return c; default: break; } if(intConversion && precisionSet && !widthSet) { // "precision" for integers gives the minimum number of digits (to be // padded with zeros on the left). This isn't really supported by the // iostreams, but we can approximately simulate it with the width if // the width isn't otherwise used. out.width(out.precision() + widthExtra); out.setf(std::ios::internal, std::ios::adjustfield); out.fill('0'); } return c+1; } //------------------------------------------------------------------------------ inline void formatImpl(std::ostream& out, const char* fmt, const detail::FormatArg* formatters, int numFormatters) { // Saved stream state std::streamsize origWidth = out.width(); std::streamsize origPrecision = out.precision(); std::ios::fmtflags origFlags = out.flags(); char origFill = out.fill(); for (int argIndex = 0; argIndex < numFormatters; ++argIndex) { // Parse the format string fmt = printFormatStringLiteral(out, fmt); bool spacePadPositive = false; int ntrunc = -1; const char* fmtEnd = streamStateFromFormat(out, spacePadPositive, ntrunc, fmt, formatters, argIndex, numFormatters); if (argIndex >= numFormatters) { // Check args remain after reading any variable width/precision TINYFORMAT_ERROR("tinyformat: Not enough format arguments"); return; } const FormatArg& arg = formatters[argIndex]; // Format the arg into the stream. if(!spacePadPositive) arg.format(out, fmt, fmtEnd, ntrunc); else { // The following is a special case with no direct correspondence // between stream formatting and the printf() behaviour. Simulate // it crudely by formatting into a temporary string stream and // munging the resulting string. std::ostringstream tmpStream; tmpStream.copyfmt(out); tmpStream.setf(std::ios::showpos); arg.format(tmpStream, fmt, fmtEnd, ntrunc); std::string result = tmpStream.str(); // allocates... yuck. for(size_t i = 0, iend = result.size(); i < iend; ++i) if(result[i] == '+') result[i] = ' '; out << result; } fmt = fmtEnd; } // Print remaining part of format string. fmt = printFormatStringLiteral(out, fmt); if(*fmt != '\0') TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string"); // Restore stream state out.width(origWidth); out.precision(origPrecision); out.flags(origFlags); out.fill(origFill); } } // namespace detail /// List of template arguments format(), held in a type-opaque way. /// /// A const reference to FormatList (typedef'd as FormatListRef) may be /// conveniently used to pass arguments to non-template functions: All type /// information has been stripped from the arguments, leaving just enough of a /// common interface to perform formatting as required. class FormatList { public: FormatList(detail::FormatArg* formatters, int N) : m_formatters(formatters), m_N(N) { } friend void vformat(std::ostream& out, const char* fmt, const FormatList& list); private: const detail::FormatArg* m_formatters; int m_N; }; /// Reference to type-opaque format list for passing to vformat() typedef const FormatList& FormatListRef; namespace detail { // Format list subclass with fixed storage to avoid dynamic allocation template class FormatListN : public FormatList { public: #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES template FormatListN(const Args&... args) : FormatList(&m_formatterStore[0], N), m_formatterStore { FormatArg(args)... } { static_assert(sizeof...(args) == N, "Number of args must be N"); } #else // C++98 version void init(int) {} # define TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR(n) \ \ template \ FormatListN(TINYFORMAT_VARARGS(n)) \ : FormatList(&m_formatterStore[0], n) \ { assert(n == N); init(0, TINYFORMAT_PASSARGS(n)); } \ \ template \ void init(int i, TINYFORMAT_VARARGS(n)) \ { \ m_formatterStore[i] = FormatArg(v1); \ init(i+1 TINYFORMAT_PASSARGS_TAIL(n)); \ } TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR) # undef TINYFORMAT_MAKE_FORMATLIST_CONSTRUCTOR #endif private: FormatArg m_formatterStore[N]; }; // Special 0-arg version - MSVC says zero-sized C array in struct is nonstandard template<> class FormatListN<0> : public FormatList { public: FormatListN() : FormatList(0, 0) {} }; } // namespace detail //------------------------------------------------------------------------------ // Primary API functions #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES /// Make type-agnostic format list from list of template arguments. /// /// The exact return type of this function is an implementation detail and /// shouldn't be relied upon. Instead it should be stored as a FormatListRef: /// /// FormatListRef formatList = makeFormatList( /*...*/ ); template detail::FormatListN makeFormatList(const Args&... args) { return detail::FormatListN(args...); } #else // C++98 version inline detail::FormatListN<0> makeFormatList() { return detail::FormatListN<0>(); } #define TINYFORMAT_MAKE_MAKEFORMATLIST(n) \ template \ detail::FormatListN makeFormatList(TINYFORMAT_VARARGS(n)) \ { \ return detail::FormatListN(TINYFORMAT_PASSARGS(n)); \ } TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_MAKEFORMATLIST) #undef TINYFORMAT_MAKE_MAKEFORMATLIST #endif /// Format list of arguments to the stream according to the given format string. /// /// The name vformat() is chosen for the semantic similarity to vprintf(): the /// list of format arguments is held in a single function argument. inline void vformat(std::ostream& out, const char* fmt, FormatListRef list) { detail::formatImpl(out, fmt, list.m_formatters, list.m_N); } #ifdef TINYFORMAT_USE_VARIADIC_TEMPLATES /// Format list of arguments to the stream according to given format string. template void format(std::ostream& out, const char* fmt, const Args&... args) { vformat(out, fmt, makeFormatList(args...)); } /// Format list of arguments according to the given format string and return /// the result as a string. template std::string format(const char* fmt, const Args&... args) { std::ostringstream oss; format(oss, fmt, args...); return oss.str(); } /// Format list of arguments to std::cout, according to the given format string template void printf(const char* fmt, const Args&... args) { format(std::cout, fmt, args...); } template void printfln(const char* fmt, const Args&... args) { format(std::cout, fmt, args...); std::cout << '\n'; } #else // C++98 version inline void format(std::ostream& out, const char* fmt) { vformat(out, fmt, makeFormatList()); } inline std::string format(const char* fmt) { std::ostringstream oss; format(oss, fmt); return oss.str(); } inline void printf(const char* fmt) { format(std::cout, fmt); } inline void printfln(const char* fmt) { format(std::cout, fmt); std::cout << '\n'; } #define TINYFORMAT_MAKE_FORMAT_FUNCS(n) \ \ template \ void format(std::ostream& out, const char* fmt, TINYFORMAT_VARARGS(n)) \ { \ vformat(out, fmt, makeFormatList(TINYFORMAT_PASSARGS(n))); \ } \ \ template \ std::string format(const char* fmt, TINYFORMAT_VARARGS(n)) \ { \ std::ostringstream oss; \ format(oss, fmt, TINYFORMAT_PASSARGS(n)); \ return oss.str(); \ } \ \ template \ void printf(const char* fmt, TINYFORMAT_VARARGS(n)) \ { \ format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \ } \ \ template \ void printfln(const char* fmt, TINYFORMAT_VARARGS(n)) \ { \ format(std::cout, fmt, TINYFORMAT_PASSARGS(n)); \ std::cout << '\n'; \ } TINYFORMAT_FOREACH_ARGNUM(TINYFORMAT_MAKE_FORMAT_FUNCS) #undef TINYFORMAT_MAKE_FORMAT_FUNCS #endif } // namespace tinyformat #endif // TINYFORMAT_H_INCLUDED bpfcc-0.2.0+git0.02884a026/src/lua/000077500000000000000000000000001305314114400160465ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/lua/CMakeLists.txt000066400000000000000000000015451305314114400206130ustar00rootroot00000000000000find_package(LuaJIT) find_program(LUAJIT luajit) if (LUAJIT_LIBRARIES AND LUAJIT) FILE(GLOB_RECURSE SRC_LUA ${CMAKE_CURRENT_SOURCE_DIR}/bcc/*.lua ${CMAKE_CURRENT_SOURCE_DIR}/bcc/vendor/*.lua ${CMAKE_CURRENT_SOURCE_DIR}/bpf/*.lua) ADD_CUSTOM_COMMAND( OUTPUT bcc.lua COMMAND ${LUAJIT} ${CMAKE_CURRENT_SOURCE_DIR}/src/squish.lua ${CMAKE_CURRENT_SOURCE_DIR} DEPENDS ${SRC_LUA} ${CMAKE_CURRENT_SOURCE_DIR}/squishy ) ADD_CUSTOM_COMMAND( OUTPUT bcc.o COMMAND ${LUAJIT} -bg bcc.lua bcc.o DEPENDS bcc.lua ) include_directories(${LUAJIT_INCLUDE_DIR}) add_executable(bcc-lua src/main.c bcc.o) set_target_properties(bcc-lua PROPERTIES LINKER_LANGUAGE C) target_link_libraries(bcc-lua ${LUAJIT_LIBRARIES}) target_link_libraries(bcc-lua -Wl,--whole-archive bcc-static -Wl,--no-whole-archive) install(TARGETS bcc-lua RUNTIME DESTINATION bin) endif() bpfcc-0.2.0+git0.02884a026/src/lua/README.md000066400000000000000000000163751305314114400173410ustar00rootroot00000000000000Lua Tools for BCC ----------------- This directory contains Lua tooling for [BCC][bcc] (the BPF Compiler Collection). BCC is a toolkit for creating userspace and kernel tracing programs. By default, it comes with a library `libbcc`, some example tooling and a Python frontend for the library. Here we present an alternate frontend for `libbcc` implemented in LuaJIT. This lets you write the userspace part of your tracer in Lua instead of Python. Since LuaJIT is a JIT compiled language, tracers implemented in `bcc-lua` exhibit significantly reduced overhead compared to their Python equivalents. This is particularly noticeable in tracers that actively use the table APIs to get information from the kernel. If your tracer makes extensive use of `BPF_MAP_TYPE_PERF_EVENT_ARRAY` or `BPF_MAP_TYPE_HASH`, you may find the performance characteristics of this implementation very appealing, as LuaJIT can compile to native code a lot of the callchain to process the events, and this wrapper has been designed to benefit from such JIT compilation. ## Quickstart Guide The following instructions assume Ubuntu 14.04 LTS. 1. Install a **very new kernel**. It has to be new and shiny for this to work. 4.3+ ``` VER=4.4.2-040402 PREFIX=http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.4.2-wily/ REL=201602171633 wget ${PREFIX}/linux-headers-${VER}-generic_${VER}.${REL}_amd64.deb wget ${PREFIX}/linux-headers-${VER}_${VER}.${REL}_all.deb wget ${PREFIX}/linux-image-${VER}-generic_${VER}.${REL}_amd64.deb sudo dpkg -i linux-*${VER}.${REL}*.deb ``` 2. Install the `libbcc` binary packages and `luajit` ``` sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys D4284CDD echo "deb https://repo.iovisor.org/apt trusty main" | sudo tee /etc/apt/sources.list.d/iovisor.list sudo apt-get update sudo apt-get install libbcc luajit ``` 3. Test one of the examples to ensure `libbcc` is properly installed ``` sudo ./bcc-probe examples/lua/task_switch.lua ``` ## LuaJIT BPF compiler Now it is also possible to write Lua functions and compile them transparently to BPF bytecode, here is a simple socket filter example: ```lua local S = require('syscall') local bpf = require('bpf') local map = bpf.map('array', 256) -- Kernel-space part of the program local prog = assert(bpf(function () local proto = pkt.ip.proto -- Get byte (ip.proto) from frame at [23] xadd(map[proto], 1) -- Increment packet count end)) -- User-space part of the program local sock = assert(bpf.socket('lo', prog)) for i=1,10 do local icmp, udp, tcp = map[1], map[17], map[6] print('TCP', tcp, 'UDP', udp, 'ICMP', icmp, 'packets') S.sleep(1) end ``` The other application of BPF programs is attaching to probes for [perf event tracing][tracing]. That means you can trace events inside the kernel (or user-space), and then collect results - for example histogram of `sendto()` latency, off-cpu time stack traces, syscall latency, and so on. While kernel probes and perf events have unstable ABI, with a dynamic language we can create and use proper type based on the tracepoint ABI on runtime. Runtime automatically recognizes reads that needs a helper to be accessed. The type casts denote source of the objects, for example the [bashreadline][bashreadline] example that prints entered bash commands from all running shells: ```lua local ffi = require('ffi') local bpf = require('bpf') -- Perf event map local sample_t = 'struct { uint64_t pid; char str[80]; }' local events = bpf.map('perf_event_array') -- Kernel-space part of the program bpf.uprobe('/bin/bash:readline' function (ptregs) local sample = ffi.new(sample_t) sample.pid = pid_tgid() ffi.copy(sample.str, ffi.cast('char *', req.ax)) -- Cast `ax` to string pointer and copy to buffer perf_submit(events, sample) -- Write sample to perf event map end, true, -1, 0) -- User-space part of the program local log = events:reader(nil, 0, sample_t) -- Must specify PID or CPU_ID to observe while true do log:block() -- Wait until event reader is readable for _,e in log:read() do -- Collect available reader events print(tonumber(e.pid), ffi.string(e.str)) end end ``` Where cast to `struct pt_regs` flags the source of data as probe arguments, which means any pointer derived from this structure points to kernel and a helper is needed to access it. Casting `req.ax` to pointer is then required for `ffi.copy` semantics, otherwise it would be treated as `u64` and only it's value would be copied. The type detection is automatic most of the times (socket filters and `bpf.tracepoint`), but not with uprobes and kprobes. ### Installation ```bash $ luarocks install bpf ``` ### Examples See `examples/lua` directory. ### Helpers * `print(...)` is a wrapper for `bpf_trace_printk`, the output is captured in `cat /sys/kernel/debug/tracing/trace_pipe` * `bit.*` library **is** supported (`lshift, rshift, arshift, bnot, band, bor, bxor`) * `math.*` library *partially* supported (`log2, log, log10`) * `ffi.cast()` is implemented (including structures and arrays) * `ffi.new(...)` allocates memory on stack, initializers are NYI * `ffi.copy(...)` copies memory (possibly using helpers) between stack/kernel/registers * `ntoh(x[, width])` - convert from network to host byte order. * `hton(x[, width])` - convert from host to network byte order. * `xadd(dst, inc)` - exclusive add, a synchronous `*dst += b` if Lua had `+=` operator Below is a list of BPF-specific helpers: * `time()` - return current monotonic time in nanoseconds (uses `bpf_ktime_get_ns`) * `cpu()` - return current CPU number (uses `bpf_get_smp_processor_id`) * `pid_tgid()` - return caller `tgid << 32 | pid` (uses `bpf_get_current_pid_tgid`) * `uid_gid()` - return caller `gid << 32 | uid` (uses `bpf_get_current_uid_gid`) * `comm(var)` - write current process name (uses `bpf_get_current_comm`) * `perf_submit(map, var)` - submit variable to perf event array BPF map * `stack_id(map, flags)` - return stack trace identifier from stack trace BPF map ### Current state * Not all LuaJIT bytecode opcodes are supported *(notable mentions below)* * Closures `UCLO` will probably never be supported, although you can use upvalues inside compiled function. * Type narrowing is opportunistic. Numbers are 64-bit by default, but 64-bit immediate loads are not supported (e.g. `local x = map[ffi.cast('uint64_t', 1000)]`) * Tail calls `CALLT`, and iterators `ITERI` are NYI (as of now) * Arbitrary ctype **is** supported both for map keys and values * Basic optimisations like: constant propagation, partial DCE, liveness analysis and speculative register allocation are implement, but there's no control flow analysis yet. This means the compiler has the visibility when things are used and dead-stores occur, but there's no rewriter pass to eliminate them. * No register sub-allocations, no aggressive use of caller-saved `R1-5`, no aggressive narrowing (this would require variable range assertions and variable relationships) * Slices with not 1/2/4/8 length are NYI (requires allocating a memory on stack and using pointer type) [bcc]: https://github.com/iovisor/bcc [tracing]: http://www.brendangregg.com/blog/2016-03-05/linux-bpf-superpowers.html [bashreadline]: http://www.brendangregg.com/blog/2016-02-08/linux-ebpf-bcc-uprobes.htmlbpfcc-0.2.0+git0.02884a026/src/lua/bcc-probe000077500000000000000000000013551305314114400176340ustar00rootroot00000000000000#!/usr/bin/env luajit --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local str = require("debug").getinfo(1, "S").source:sub(2) local script_path = str:match("(.*/)").."/?.lua;" package.path = script_path..package.path require("bcc.run")() bpfcc-0.2.0+git0.02884a026/src/lua/bcc/000077500000000000000000000000001305314114400165755ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/lua/bcc/bpf.lua000066400000000000000000000171061305314114400200540ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require("ffi") local libbcc = require("bcc.libbcc") local TracerPipe = require("bcc.tracerpipe") local Table = require("bcc.table") local Sym = require("bcc.sym") local Bpf = class("BPF") Bpf.static.open_kprobes = {} Bpf.static.open_uprobes = {} Bpf.static.KPROBE_LIMIT = 1000 Bpf.static.tracer_pipe = nil Bpf.static.DEFAULT_CFLAGS = { '-D__HAVE_BUILTIN_BSWAP16__', '-D__HAVE_BUILTIN_BSWAP32__', '-D__HAVE_BUILTIN_BSWAP64__', } function Bpf.static.check_probe_quota(n) local cur = table.count(Bpf.static.open_kprobes) + table.count(Bpf.static.open_uprobes) assert(cur + n <= Bpf.static.KPROBE_LIMIT, "number of open probes would exceed quota") end function Bpf.static.cleanup() local function detach_all(probe_type, all_probes) for key, probe in pairs(all_probes) do libbcc.perf_reader_free(probe) -- skip bcc-specific kprobes if not key:starts("bcc:") then if probe_type == "kprobes" then libbcc.bpf_detach_kprobe(key) elseif probe_type == "uprobes" then libbcc.bpf_detach_uprobe(key) end end all_probes[key] = nil end end detach_all("kprobes", Bpf.static.open_kprobes) detach_all("uprobes", Bpf.static.open_uprobes) if Bpf.static.tracer_pipe ~= nil then Bpf.static.tracer_pipe:close() end end function Bpf.static.SymbolCache(pid) return Sym.create_cache(pid) end function Bpf.static.num_open_uprobes() return table.count(Bpf.static.open_uprobes) end function Bpf.static.num_open_kprobes() return table.count(Bpf.static.open_kprobes) end Bpf.static.SCRIPT_ROOT = "./" function Bpf.static.script_root(root) local dir, file = root:match'(.*/)(.*)' Bpf.static.SCRIPT_ROOT = dir or "./" return Bpf end local function _find_file(script_root, filename) if filename == nil then return nil end if os.exists(filename) then return filename end if not filename:starts("/") then filename = script_root .. filename if os.exists(filename) then return filename end end assert(nil, "failed to find file "..filename.." (root="..script_root..")") end function Bpf:initialize(args) self.funcs = {} self.tables = {} if args.usdt and args.text then args.text = args.usdt:_get_text() .. args.text end local cflags = table.join(Bpf.DEFAULT_CFLAGS, args.cflags) local cflags_ary = ffi.new("const char *[?]", #cflags, cflags) local llvm_debug = rawget(_G, "LIBBCC_LLVM_DEBUG") or args.debug or 0 assert(type(llvm_debug) == "number") if args.text then log.info("\n%s\n", args.text) self.module = libbcc.bpf_module_create_c_from_string(args.text, llvm_debug, cflags_ary, #cflags) elseif args.src_file then local src = _find_file(Bpf.SCRIPT_ROOT, args.src_file) if src:ends(".b") then local hdr = _find_file(Bpf.SCRIPT_ROOT, args.hdr_file) self.module = libbcc.bpf_module_create_b(src, hdr, llvm_debug) else self.module = libbcc.bpf_module_create_c(src, llvm_debug, cflags_ary, #cflags) end end assert(self.module ~= nil, "failed to compile BPF module") if args.usdt then args.usdt:_attach_uprobes(self) end end function Bpf:load_funcs(prog_type) prog_type = prog_type or "BPF_PROG_TYPE_KPROBE" local result = {} local fn_count = tonumber(libbcc.bpf_num_functions(self.module)) for i = 0,fn_count-1 do local name = ffi.string(libbcc.bpf_function_name(self.module, i)) table.insert(result, self:load_func(name, prog_type)) end return result end function Bpf:load_func(fn_name, prog_type) if self.funcs[fn_name] ~= nil then return self.funcs[fn_name] end assert(libbcc.bpf_function_start(self.module, fn_name) ~= nil, "unknown program: "..fn_name) local fd = libbcc.bpf_prog_load(prog_type, libbcc.bpf_function_start(self.module, fn_name), libbcc.bpf_function_size(self.module, fn_name), libbcc.bpf_module_license(self.module), libbcc.bpf_module_kern_version(self.module), nil, 0) assert(fd >= 0, "failed to load BPF program "..fn_name) log.info("loaded %s (%d)", fn_name, fd) local fn = {bpf=self, name=fn_name, fd=fd} self.funcs[fn_name] = fn return fn end function Bpf:dump_func(fn_name) local start = libbcc.bpf_function_start(self.module, fn_name) assert(start ~= nil, "unknown program") local len = libbcc.bpf_function_size(self.module, fn_name) return ffi.string(start, tonumber(len)) end function Bpf:attach_uprobe(args) Bpf.check_probe_quota(1) local path, addr = Sym.check_path_symbol(args.name, args.sym, args.addr, args.pid) local fn = self:load_func(args.fn_name, 'BPF_PROG_TYPE_KPROBE') local ptype = args.retprobe and "r" or "p" local ev_name = string.format("%s_%s_0x%p", ptype, path:gsub("[^%a%d]", "_"), addr) local retprobe = args.retprobe and 1 or 0 local res = libbcc.bpf_attach_uprobe(fn.fd, retprobe, ev_name, path, addr, args.pid or -1, args.cpu or 0, args.group_fd or -1, nil, nil) -- TODO; reader callback assert(res ~= nil, "failed to attach BPF to uprobe") self:probe_store("uprobe", ev_name, res) return self end function Bpf:attach_kprobe(args) -- TODO: allow the caller to glob multiple functions together Bpf.check_probe_quota(1) local fn = self:load_func(args.fn_name, 'BPF_PROG_TYPE_KPROBE') local event = args.event or "" local ptype = args.retprobe and "r" or "p" local ev_name = string.format("%s_%s", ptype, event:gsub("[%+%.]", "_")) local retprobe = args.retprobe and 1 or 0 local res = libbcc.bpf_attach_kprobe(fn.fd, retprobe, ev_name, event, args.pid or -1, args.cpu or 0, args.group_fd or -1, nil, nil) -- TODO; reader callback assert(res ~= nil, "failed to attach BPF to kprobe") self:probe_store("kprobe", ev_name, res) return self end function Bpf:pipe() if Bpf.tracer_pipe == nil then Bpf.tracer_pipe = TracerPipe:new() end return Bpf.tracer_pipe end function Bpf:get_table(name, key_type, leaf_type) if self.tables[name] == nil then self.tables[name] = Table(self, name, key_type, leaf_type) end return self.tables[name] end function Bpf:probe_store(t, id, reader) if t == "kprobe" then Bpf.open_kprobes[id] = reader elseif t == "uprobe" then Bpf.open_uprobes[id] = reader else error("unknown probe type '%s'" % t) end log.info("%s -> %s", id, reader) end function Bpf:probe_lookup(t, id) if t == "kprobe" then return Bpf.open_kprobes[id] elseif t == "uprobe" then return Bpf.open_uprobes[id] else return nil end end function Bpf:_kprobe_array() local kprobe_count = table.count(Bpf.open_kprobes) local readers = ffi.new("struct perf_reader*[?]", kprobe_count) local n = 0 for _, r in pairs(Bpf.open_kprobes) do readers[n] = r n = n + 1 end assert(n == kprobe_count) return readers, n end function Bpf:kprobe_poll_loop() local probes, probe_count = self:_kprobe_array() return pcall(function() while true do libbcc.perf_reader_poll(probe_count, probes, -1) end end) end function Bpf:kprobe_poll(timeout) local probes, probe_count = self:_kprobe_array() libbcc.perf_reader_poll(probe_count, probes, timeout or -1) end return Bpf bpfcc-0.2.0+git0.02884a026/src/lua/bcc/init.lua000066400000000000000000000011561305314114400202460ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] require("bcc.vendor.helpers") return { BPF = require("bcc.bpf") } bpfcc-0.2.0+git0.02884a026/src/lua/bcc/libbcc.lua000066400000000000000000000135221305314114400205210ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require("ffi") ffi.cdef[[ enum bpf_prog_type { BPF_PROG_TYPE_UNSPEC, BPF_PROG_TYPE_SOCKET_FILTER, BPF_PROG_TYPE_KPROBE, BPF_PROG_TYPE_SCHED_CLS, BPF_PROG_TYPE_SCHED_ACT, }; int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size, int max_entries, int map_flags); int bpf_update_elem(int fd, void *key, void *value, unsigned long long flags); int bpf_lookup_elem(int fd, void *key, void *value); int bpf_delete_elem(int fd, void *key); int bpf_get_next_key(int fd, void *key, void *next_key); int bpf_prog_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, int insn_len, const char *license, unsigned kern_version, char *log_buf, unsigned log_buf_size); int bpf_attach_socket(int sockfd, int progfd); /* create RAW socket and bind to interface 'name' */ int bpf_open_raw_sock(const char *name); typedef void (*perf_reader_cb)(void *cb_cookie, int pid, uint64_t callchain_num, void *callchain); typedef void (*perf_reader_raw_cb)(void *cb_cookie, void *raw, int raw_size); void * bpf_attach_kprobe(int progfd, int attach_type, const char *ev_name, const char *fn_name, int pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie); int bpf_detach_kprobe(const char *ev_name); void * bpf_attach_uprobe(int progfd, int attach_type, const char *ev_name, const char *binary_path, uint64_t offset, int pid, int cpu, int group_fd, perf_reader_cb cb, void *cb_cookie); int bpf_detach_uprobe(const char *ev_name); void * bpf_open_perf_buffer(perf_reader_raw_cb raw_cb, void *cb_cookie, int pid, int cpu); ]] ffi.cdef[[ void * bpf_module_create_b(const char *filename, const char *proto_filename, unsigned flags); void * bpf_module_create_c(const char *filename, unsigned flags, const char *cflags[], int ncflags); void * bpf_module_create_c_from_string(const char *text, unsigned flags, const char *cflags[], int ncflags); void bpf_module_destroy(void *program); char * bpf_module_license(void *program); unsigned bpf_module_kern_version(void *program); size_t bpf_num_functions(void *program); const char * bpf_function_name(void *program, size_t id); void * bpf_function_start_id(void *program, size_t id); void * bpf_function_start(void *program, const char *name); size_t bpf_function_size_id(void *program, size_t id); size_t bpf_function_size(void *program, const char *name); size_t bpf_num_tables(void *program); size_t bpf_table_id(void *program, const char *table_name); int bpf_table_fd(void *program, const char *table_name); int bpf_table_fd_id(void *program, size_t id); int bpf_table_type(void *program, const char *table_name); int bpf_table_type_id(void *program, size_t id); size_t bpf_table_max_entries(void *program, const char *table_name); size_t bpf_table_max_entries_id(void *program, size_t id); int bpf_table_flags(void *program, const char *table_name); int bpf_table_flags_id(void *program, size_t id); const char * bpf_table_name(void *program, size_t id); const char * bpf_table_key_desc(void *program, const char *table_name); const char * bpf_table_key_desc_id(void *program, size_t id); const char * bpf_table_leaf_desc(void *program, const char *table_name); const char * bpf_table_leaf_desc_id(void *program, size_t id); size_t bpf_table_key_size(void *program, const char *table_name); size_t bpf_table_key_size_id(void *program, size_t id); size_t bpf_table_leaf_size(void *program, const char *table_name); size_t bpf_table_leaf_size_id(void *program, size_t id); int bpf_table_key_snprintf(void *program, size_t id, char *buf, size_t buflen, const void *key); int bpf_table_leaf_snprintf(void *program, size_t id, char *buf, size_t buflen, const void *leaf); int bpf_table_key_sscanf(void *program, size_t id, const char *buf, void *key); int bpf_table_leaf_sscanf(void *program, size_t id, const char *buf, void *leaf); ]] ffi.cdef[[ struct perf_reader; struct perf_reader * perf_reader_new(perf_reader_cb cb, perf_reader_raw_cb raw_cb, void *cb_cookie); void perf_reader_free(void *ptr); int perf_reader_mmap(struct perf_reader *reader, unsigned type, unsigned long sample_type); int perf_reader_poll(int num_readers, struct perf_reader **readers, int timeout); int perf_reader_fd(struct perf_reader *reader); void perf_reader_set_fd(struct perf_reader *reader, int fd); ]] ffi.cdef[[ struct bcc_symbol { const char *name; const char *demangle_name; const char *module; uint64_t offset; }; int bcc_resolve_symname(const char *module, const char *symname, const uint64_t addr, int pid, struct bcc_symbol *sym); void bcc_procutils_free(const char *ptr); void *bcc_symcache_new(int pid); int bcc_symcache_resolve(void *symcache, uint64_t addr, struct bcc_symbol *sym); void bcc_symcache_refresh(void *resolver); ]] ffi.cdef[[ void *bcc_usdt_new_frompid(int pid); void *bcc_usdt_new_frompath(const char *path); void bcc_usdt_close(void *usdt); int bcc_usdt_enable_probe(void *, const char *, const char *); char *bcc_usdt_genargs(void *); typedef void (*bcc_usdt_uprobe_cb)(const char *, const char *, uint64_t, int); void bcc_usdt_foreach_uprobe(void *usdt, bcc_usdt_uprobe_cb callback); ]] if rawget(_G, "BCC_STANDALONE") then return ffi.C else return ffi.load( os.getenv("LIBBCC_SO_PATH") or rawget(_G, "LIBBCC_SO_PATH") or "bcc") end bpfcc-0.2.0+git0.02884a026/src/lua/bcc/run.lua000066400000000000000000000042161305314114400201070ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] return function() require("bcc.vendor.helpers") local standalone = rawget(_G, "BCC_STANDALONE") local progname = standalone or "bcc-probe" local function print_usage() io.stderr:write(string.format( "usage: %s [[--version|--verbose] --] path_to_script.lua [...]\n", progname)) os.exit(1) end local function print_version() local jit = require("jit") print(string.format("%s %s -- Running on %s (%s/%s)", progname, rawget(_G, "BCC_VERSION") or "HEAD", jit.version, jit.os, jit.arch)) os.exit(0) end while arg[1] and string.starts(arg[1], "-") do local k = table.remove(arg, 1) if k == "--" then break elseif standalone == nil and string.starts(k, "--so-path=") then rawset(_G, "LIBBCC_SO_PATH", string.lstrip(k, "--so-path=")) elseif k == "--llvm-debug" then rawset(_G, "LIBBCC_LLVM_DEBUG", 1) elseif k == "-V" or k == "--verbose" then log.enabled = true elseif k == "-v" or k == "--version" then print_version() else print_usage() end end local tracefile = table.remove(arg, 1) if not tracefile then print_usage() end local BPF = require("bcc.bpf") BPF.script_root(tracefile) local USDT = require("bcc.usdt") local utils = { argparse = require("bcc.vendor.argparse"), posix = require("bcc.vendor.posix"), USDT = USDT, } local command = dofile(tracefile) local res, err = xpcall(command, debug.traceback, BPF, utils) if not res and err ~= "interrupted!" then io.stderr:write("[ERROR] "..err.."\n") end BPF.cleanup() USDT.cleanup() return res, err end bpfcc-0.2.0+git0.02884a026/src/lua/bcc/sym.lua000066400000000000000000000032511305314114400201110ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require("ffi") local libbcc = require("bcc.libbcc") local SYM = ffi.typeof("struct bcc_symbol[1]") local function create_cache(pid) return { _CACHE = libbcc.bcc_symcache_new(pid or -1), resolve = function(self, addr) local sym = SYM() if libbcc.bcc_symcache_resolve(self._CACHE, addr, sym) < 0 then return "[unknown]", 0x0 end return ffi.string(sym[0].demangle_name), sym[0].offset end } end local function check_path_symbol(module, symname, addr, pid) local sym = SYM() local module_path if libbcc.bcc_resolve_symname(module, symname, addr or 0x0, pid or 0, sym) < 0 then if sym[0].module == nil then error("could not find library '%s' in the library path" % module) else module_path = ffi.string(sym[0].module) libbcc.bcc_procutils_free(sym[0].module) error("failed to resolve symbol '%s' in '%s'" % { symname, module_path}) end end module_path = ffi.string(sym[0].module) libbcc.bcc_procutils_free(sym[0].module) return module_path, sym[0].offset end return { create_cache=create_cache, check_path_symbol=check_path_symbol } bpfcc-0.2.0+git0.02884a026/src/lua/bcc/table.lua000066400000000000000000000242141305314114400203720ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require("ffi") local libbcc = require("bcc.libbcc") local Posix = require("bcc.vendor.posix") local BaseTable = class("BaseTable") BaseTable.static.BPF_MAP_TYPE_HASH = 1 BaseTable.static.BPF_MAP_TYPE_ARRAY = 2 BaseTable.static.BPF_MAP_TYPE_PROG_ARRAY = 3 BaseTable.static.BPF_MAP_TYPE_PERF_EVENT_ARRAY = 4 BaseTable.static.BPF_MAP_TYPE_PERCPU_HASH = 5 BaseTable.static.BPF_MAP_TYPE_PERCPU_ARRAY = 6 BaseTable.static.BPF_MAP_TYPE_STACK_TRACE = 7 BaseTable.static.BPF_MAP_TYPE_CGROUP_ARRAY = 8 BaseTable.static.BPF_MAP_TYPE_LRU_HASH = 9 BaseTable.static.BPF_MAP_TYPE_LRU_PERCPU_HASH = 10 BaseTable.static.BPF_MAP_TYPE_LPM_TRIE = 11 function BaseTable:initialize(t_type, bpf, map_id, map_fd, key_type, leaf_type) assert(t_type == libbcc.bpf_table_type_id(bpf.module, map_id)) self.t_type = t_type self.bpf = bpf self.map_id = map_id self.map_fd = map_fd self.c_key = ffi.typeof(key_type.."[1]") self.c_leaf = ffi.typeof(leaf_type.."[1]") end function BaseTable:key_sprintf(key) local pkey = self.c_key(key) local buf_len = ffi.sizeof(self.c_key) * 8 local pbuf = ffi.new("char[?]", buf_len) local res = libbcc.bpf_table_key_snprintf( self.bpf.module, self.map_id, pbuf, buf_len, pkey) assert(res == 0, "could not print key") return ffi.string(pbuf) end function BaseTable:leaf_sprintf(leaf) local pleaf = self.c_leaf(leaf) local buf_len = ffi.sizeof(self.c_leaf) * 8 local pbuf = ffi.new("char[?]", buf_len) local res = libbcc.bpf_table_leaf_snprintf( self.bpf.module, self.map_id, pbuf, buf_len, pleaf) assert(res == 0, "could not print leaf") return ffi.string(pbuf) end function BaseTable:key_scanf(key_str) local pkey = self.c_key() local res = libbcc.bpf_table_key_sscanf( self.bpf.module, self.map_id, key_str, pkey) assert(res == 0, "could not scanf key") return pkey[0] end function BaseTable:leaf_scanf(leaf_str) local pleaf = self.c_leaf() local res = libbcc.bpf_table_leaf_sscanf( self.bpf.module, self.map_id, leaf_str, pleaf) assert(res == 0, "could not scanf leaf") return pleaf[0] end function BaseTable:get(key) local pkey = self.c_key(key) local pvalue = self.c_leaf() if libbcc.bpf_lookup_elem(self.map_fd, pkey, pvalue) < 0 then return nil end return pvalue[0] end function BaseTable:set(key, value) local pkey = self.c_key(key) local pvalue = self.c_leaf(value) assert(libbcc.bpf_update_elem(self.map_fd, pkey, pvalue, 0) == 0, "could not update table") end function BaseTable:_empty_key() local pkey = self.c_key() local pvalue = self.c_leaf() for _, v in ipairs({0x0, 0x55, 0xff}) do ffi.fill(pkey, ffi.sizeof(pkey[0]), v) if libbcc.bpf_lookup_elem(self.map_fd, pkey, pvalue) < 0 then return pkey end end error("failed to find an empty key for table iteration") end function BaseTable:keys() local pkey = self:_empty_key() return function() local pkey_next = self.c_key() if libbcc.bpf_get_next_key(self.map_fd, pkey, pkey_next) < 0 then return nil end pkey = pkey_next return pkey[0] end end function BaseTable:items() local pkey = self:_empty_key() return function() local pkey_next = self.c_key() local pvalue = self.c_leaf() if libbcc.bpf_get_next_key(self.map_fd, pkey, pkey_next) < 0 then return nil end pkey = pkey_next assert(libbcc.bpf_lookup_elem(self.map_fd, pkey, pvalue) == 0) return pkey[0], pvalue[0] end end local HashTable = class("HashTable", BaseTable) function HashTable:initialize(bpf, map_id, map_fd, key_type, leaf_type) BaseTable.initialize(self, BaseTable.BPF_MAP_TYPE_HASH, bpf, map_id, map_fd, key_type, leaf_type) end function HashTable:delete(key) local pkey = self.c_key(key) return libbcc.bpf_delete_elem(self.map_fd, pkey) == 0 end function HashTable:size() local n = 0 self:each(function() n = n + 1 end) return n end local BaseArray = class("BaseArray", BaseTable) function BaseArray:initialize(t_type, bpf, map_id, map_fd, key_type, leaf_type) BaseTable.initialize(self, t_type, bpf, map_id, map_fd, key_type, leaf_type) self.max_entries = tonumber(libbcc.bpf_table_max_entries_id(self.bpf.module, self.map_id)) end function BaseArray:_normalize_key(key) assert(type(key) == "number", "invalid key (expected a number") if key < 0 then key = self.max_entries + key end assert(key < self.max_entries, string.format("out of range (%d >= %d)", key, self.max_entries)) return key end function BaseArray:get(key) return BaseTable.get(self, self:_normalize_key(key)) end function BaseArray:set(key, value) return BaseTable.set(self, self:_normalize_key(key), value) end function BaseArray:delete(key) assert(nil, "unsupported") end function BaseArray:items(with_index) local pkey = self.c_key() local max = self.max_entries local n = 0 -- TODO return function() local pvalue = self.c_leaf() if n == max then return nil end pkey[0] = n n = n + 1 if libbcc.bpf_lookup_elem(self.map_fd, pkey, pvalue) ~= 0 then return nil end if with_index then return n, pvalue[0] -- return 1-based index else return pvalue[0] end end end local Array = class("Array", BaseArray) function Array:initialize(bpf, map_id, map_fd, key_type, leaf_type) BaseArray.initialize(self, BaseTable.BPF_MAP_TYPE_ARRAY, bpf, map_id, map_fd, key_type, leaf_type) end local PerfEventArray = class("PerfEventArray", BaseArray) function PerfEventArray:initialize(bpf, map_id, map_fd, key_type, leaf_type) BaseArray.initialize(self, BaseTable.BPF_MAP_TYPE_PERF_EVENT_ARRAY, bpf, map_id, map_fd, key_type, leaf_type) self._callbacks = {} end local function _perf_id(id, cpu) return string.format("bcc:perf_event_array:%d:%d", tonumber(id), cpu or 0) end function PerfEventArray:_open_perf_buffer(cpu, callback, ctype) local _cb = ffi.cast("perf_reader_raw_cb", function (cookie, data, size) callback(cpu, ctype(data)[0]) end) local reader = libbcc.bpf_open_perf_buffer(_cb, nil, -1, cpu) assert(reader, "failed to open perf buffer") local fd = libbcc.perf_reader_fd(reader) self:set(cpu, fd) self.bpf:probe_store("kprobe", _perf_id(self.map_id, cpu), reader) self._callbacks[cpu] = _cb end function PerfEventArray:open_perf_buffer(callback, data_type, ...) assert(data_type, "a data type is needed for callback conversion") local ctype = ffi.typeof(data_type.."*", ...) for i = 0, Posix.cpu_count() - 1 do self:_open_perf_buffer(i, callback, ctype) end end local StackTrace = class("StackTrace", BaseTable) StackTrace.static.MAX_STACK = 127 function StackTrace:initialize(bpf, map_id, map_fd, key_type, leaf_type) BaseTable.initialize(self, BaseTable.BPF_MAP_TYPE_STACK_TRACE, bpf, map_id, map_fd, key_type, leaf_type) self._stackp = self.c_leaf() -- FIXME: not threadsafe end function StackTrace:walk(id) local pkey = self.c_key(id) local pstack = self._stackp local i = 0 if libbcc.bpf_lookup_elem(self.map_fd, pkey, pstack) < 0 then return nil end return function() if i >= StackTrace.MAX_STACK then return nil end local addr = pstack[0].ip[i] if addr == 0 then return nil end i = i + 1 return addr end end function StackTrace:get(id, resolver) local stack = {} for addr in self:walk(id) do table.insert(stack, resolver and resolver(addr) or addr) end return stack end local function _decode_table_type(desc) local json = require("bcc.vendor.json") local json_desc = ffi.string(desc) local function _dec(t) if type(t) == "string" then return t end local fields = {} local struct = t[3] or "struct" for _, value in ipairs(t[2]) do local f = nil if #value == 2 then f = string.format("%s %s;", _dec(value[2]), value[1]) elseif #value == 3 then if type(value[3]) == "table" then f = string.format("%s %s[%d];", _dec(value[2]), value[1], value[3][1]) elseif type(value[3]) == "number" then local t = _dec(value[2]) assert(t == "int" or t == "unsigned int", "bitfields can only appear in [unsigned] int types") f = string.format("%s %s:%d;", t, value[1], value[3]) end end assert(f ~= nil, "failed to decode type "..json_desc) table.insert(fields, f) end assert(struct == "struct" or struct == "union", "unknown complex type: "..struct) return string.format("%s { %s }", struct, table.concat(fields, " ")) end return _dec(json.parse(json_desc)) end local function NewTable(bpf, name, key_type, leaf_type) local id = libbcc.bpf_table_id(bpf.module, name) local fd = libbcc.bpf_table_fd(bpf.module, name) if fd < 0 then return nil end local t_type = libbcc.bpf_table_type_id(bpf.module, id) local table = nil if t_type == BaseTable.BPF_MAP_TYPE_HASH then table = HashTable elseif t_type == BaseTable.BPF_MAP_TYPE_ARRAY then table = Array elseif t_type == BaseTable.BPF_MAP_TYPE_PERF_EVENT_ARRAY then table = PerfEventArray elseif t_type == BaseTable.BPF_MAP_TYPE_STACK_TRACE then table = StackTrace end assert(table, "unsupported table type %d" % t_type) if key_type == nil then local desc = libbcc.bpf_table_key_desc(bpf.module, name) assert(desc, "Failed to load BPF table description for "..name) key_type = _decode_table_type(desc) end if leaf_type == nil then local desc = libbcc.bpf_table_leaf_desc(bpf.module, name) assert(desc, "Failed to load BPF table description for "..name) leaf_type = _decode_table_type(desc) end log.info("key = %s value = %s", key_type, leaf_type) return table:new(bpf, id, fd, key_type, leaf_type) end return NewTable bpfcc-0.2.0+git0.02884a026/src/lua/bcc/tracerpipe.lua000066400000000000000000000030041305314114400214330ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local TracerPipe = class("TracerPipe") TracerPipe.static.TRACEFS = "/sys/kernel/debug/tracing" TracerPipe.static.fields = "%s+(.-)%-(%d+)%s+%[(%d+)%]%s+(....)%s+([%d%.]+):.-:%s+(.+)" function TracerPipe:close() if self.pipe ~= nil then self.pipe:close() end end function TracerPipe:open() if self.pipe == nil then self.pipe = assert(io.open(TracerPipe.TRACEFS .. "/trace_pipe")) end return self.pipe end function TracerPipe:readline() return self:open():read() end function TracerPipe:trace_fields() while true do local line = self:readline() if not line and self.nonblocking then return nil end if not line:starts("CPU:") then local task, pid, cpu, flags, ts, msg = line:match(TracerPipe.fields) if task ~= nil then return task, tonumber(pid), tonumber(cpu), flags, tonumber(ts), msg end end end end function TracerPipe:initialize(nonblocking) self.nonblocking = nonblocking end return TracerPipe bpfcc-0.2.0+git0.02884a026/src/lua/bcc/usdt.lua000066400000000000000000000037111305314114400202610ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require("ffi") local libbcc = require("bcc.libbcc") local Usdt = class("USDT") Usdt.static.open_contexts = {} function Usdt.static.cleanup() for _, context in ipairs(Usdt.static.open_contexts) do context:_cleanup() end end function Usdt:initialize(args) assert(args.pid or args.path) if args.pid then self.pid = args.pid self.context = libbcc.bcc_usdt_new_frompid(args.pid) elseif args.path then self.path = args.path self.context = libbcc.bcc_usdt_new_frompath(args.path) end assert(self.context ~= nil, "failed to create USDT context") table.insert(Usdt.open_contexts, self) end function Usdt:enable_probe(args) assert(args.probe and args.fn_name) assert(libbcc.bcc_usdt_enable_probe( self.context, args.probe, args.fn_name) == 0) end function Usdt:_cleanup() libbcc.bcc_usdt_close(self.context) self.context = nil end function Usdt:_get_text() local argc = libbcc.bcc_usdt_genargs(self.context) assert(argc ~= nil) return ffi.string(argc) end function Usdt:_attach_uprobes(bpf) local uprobes = {} local cb = ffi.cast("bcc_usdt_uprobe_cb", function(binpath, fn_name, addr, pid) table.insert(uprobes, {name=ffi.string(binpath), addr=addr, fn_name=ffi.string(fn_name), pid=pid}) end) libbcc.bcc_usdt_foreach_uprobe(self.context, cb) cb:free() for _, args in ipairs(uprobes) do bpf:attach_uprobe(args) end end return Usdt bpfcc-0.2.0+git0.02884a026/src/lua/bcc/vendor/000077500000000000000000000000001305314114400200725ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/lua/bcc/vendor/argparse.lua000066400000000000000000000707501305314114400224120ustar00rootroot00000000000000-- The MIT License (MIT) -- Copyright (c) 2013 - 2015 Peter Melnichenko -- Permission is hereby granted, free of charge, to any person obtaining a copy of -- this software and associated documentation files (the "Software"), to deal in -- the Software without restriction, including without limitation the rights to -- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -- the Software, and to permit persons to whom the Software is furnished to do so, -- subject to the following conditions: -- The above copyright notice and this permission notice shall be included in all -- copies or substantial portions of the Software. -- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. local function deep_update(t1, t2) for k, v in pairs(t2) do if type(v) == "table" then v = deep_update({}, v) end t1[k] = v end return t1 end -- A property is a tuple {name, callback}. -- properties.args is number of properties that can be set as arguments -- when calling an object. local function class(prototype, properties, parent) -- Class is the metatable of its instances. local cl = {} cl.__index = cl if parent then cl.__prototype = deep_update(deep_update({}, parent.__prototype), prototype) else cl.__prototype = prototype end if properties then local names = {} -- Create setter methods and fill set of property names. for _, property in ipairs(properties) do local name, callback = property[1], property[2] cl[name] = function(self, value) if not callback(self, value) then self["_" .. name] = value end return self end names[name] = true end function cl.__call(self, ...) -- When calling an object, if the first argument is a table, -- interpret keys as property names, else delegate arguments -- to corresponding setters in order. if type((...)) == "table" then for name, value in pairs((...)) do if names[name] then self[name](self, value) end end else local nargs = select("#", ...) for i, property in ipairs(properties) do if i > nargs or i > properties.args then break end local arg = select(i, ...) if arg ~= nil then self[property[1]](self, arg) end end end return self end end -- If indexing class fails, fallback to its parent. local class_metatable = {} class_metatable.__index = parent function class_metatable.__call(self, ...) -- Calling a class returns its instance. -- Arguments are delegated to the instance. local object = deep_update({}, self.__prototype) setmetatable(object, self) return object(...) end return setmetatable(cl, class_metatable) end local function typecheck(name, types, value) for _, type_ in ipairs(types) do if type(value) == type_ then return true end end error(("bad property '%s' (%s expected, got %s)"):format(name, table.concat(types, " or "), type(value))) end local function typechecked(name, ...) local types = {...} return {name, function(_, value) typecheck(name, types, value) end} end local multiname = {"name", function(self, value) typecheck("name", {"string"}, value) for alias in value:gmatch("%S+") do self._name = self._name or alias table.insert(self._aliases, alias) end -- Do not set _name as with other properties. return true end} local function parse_boundaries(str) if tonumber(str) then return tonumber(str), tonumber(str) end if str == "*" then return 0, math.huge end if str == "+" then return 1, math.huge end if str == "?" then return 0, 1 end if str:match "^%d+%-%d+$" then local min, max = str:match "^(%d+)%-(%d+)$" return tonumber(min), tonumber(max) end if str:match "^%d+%+$" then local min = str:match "^(%d+)%+$" return tonumber(min), math.huge end end local function boundaries(name) return {name, function(self, value) typecheck(name, {"number", "string"}, value) local min, max = parse_boundaries(value) if not min then error(("bad property '%s'"):format(name)) end self["_min" .. name], self["_max" .. name] = min, max end} end local actions = {} local option_action = {"action", function(_, value) typecheck("action", {"function", "string"}, value) if type(value) == "string" and not actions[value] then error(("unknown action '%s'"):format(value)) end end} local option_init = {"init", function(self) self._has_init = true end} local option_default = {"default", function(self, value) if type(value) ~= "string" then self._init = value self._has_init = true return true end end} local add_help = {"add_help", function(self, value) typecheck("add_help", {"boolean", "string", "table"}, value) if self._has_help then table.remove(self._options) self._has_help = false end if value then local help = self:flag() :description "Show this help message and exit." :action(function() print(self:get_help()) os.exit(0) end) if value ~= true then help = help(value) end if not help._name then help "-h" "--help" end self._has_help = true end end} local Parser = class({ _arguments = {}, _options = {}, _commands = {}, _mutexes = {}, _require_command = true, _handle_options = true }, { args = 3, typechecked("name", "string"), typechecked("description", "string"), typechecked("epilog", "string"), typechecked("usage", "string"), typechecked("help", "string"), typechecked("require_command", "boolean"), typechecked("handle_options", "boolean"), typechecked("action", "function"), typechecked("command_target", "string"), add_help }) local Command = class({ _aliases = {} }, { args = 3, multiname, typechecked("description", "string"), typechecked("epilog", "string"), typechecked("target", "string"), typechecked("usage", "string"), typechecked("help", "string"), typechecked("require_command", "boolean"), typechecked("handle_options", "boolean"), typechecked("action", "function"), typechecked("command_target", "string"), add_help }, Parser) local Argument = class({ _minargs = 1, _maxargs = 1, _mincount = 1, _maxcount = 1, _defmode = "unused", _show_default = true }, { args = 5, typechecked("name", "string"), typechecked("description", "string"), option_default, typechecked("convert", "function", "table"), boundaries("args"), typechecked("target", "string"), typechecked("defmode", "string"), typechecked("show_default", "boolean"), typechecked("argname", "string", "table"), option_action, option_init }) local Option = class({ _aliases = {}, _mincount = 0, _overwrite = true }, { args = 6, multiname, typechecked("description", "string"), option_default, typechecked("convert", "function", "table"), boundaries("args"), boundaries("count"), typechecked("target", "string"), typechecked("defmode", "string"), typechecked("show_default", "boolean"), typechecked("overwrite", "boolean"), typechecked("argname", "string", "table"), option_action, option_init }, Argument) function Argument:_get_argument_list() local buf = {} local i = 1 while i <= math.min(self._minargs, 3) do local argname = self:_get_argname(i) if self._default and self._defmode:find "a" then argname = "[" .. argname .. "]" end table.insert(buf, argname) i = i+1 end while i <= math.min(self._maxargs, 3) do table.insert(buf, "[" .. self:_get_argname(i) .. "]") i = i+1 if self._maxargs == math.huge then break end end if i < self._maxargs then table.insert(buf, "...") end return buf end function Argument:_get_usage() local usage = table.concat(self:_get_argument_list(), " ") if self._default and self._defmode:find "u" then if self._maxargs > 1 or (self._minargs == 1 and not self._defmode:find "a") then usage = "[" .. usage .. "]" end end return usage end function actions.store_true(result, target) result[target] = true end function actions.store_false(result, target) result[target] = false end function actions.store(result, target, argument) result[target] = argument end function actions.count(result, target, _, overwrite) if not overwrite then result[target] = result[target] + 1 end end function actions.append(result, target, argument, overwrite) result[target] = result[target] or {} table.insert(result[target], argument) if overwrite then table.remove(result[target], 1) end end function actions.concat(result, target, arguments, overwrite) if overwrite then error("'concat' action can't handle too many invocations") end result[target] = result[target] or {} for _, argument in ipairs(arguments) do table.insert(result[target], argument) end end function Argument:_get_action() local action, init if self._maxcount == 1 then if self._maxargs == 0 then action, init = "store_true", nil else action, init = "store", nil end else if self._maxargs == 0 then action, init = "count", 0 else action, init = "append", {} end end if self._action then action = self._action end if self._has_init then init = self._init end if type(action) == "string" then action = actions[action] end return action, init end -- Returns placeholder for `narg`-th argument. function Argument:_get_argname(narg) local argname = self._argname or self:_get_default_argname() if type(argname) == "table" then return argname[narg] else return argname end end function Argument:_get_default_argname() return "<" .. self._name .. ">" end function Option:_get_default_argname() return "<" .. self:_get_default_target() .. ">" end -- Returns label to be shown in the help message. function Argument:_get_label() return self._name end function Option:_get_label() local variants = {} local argument_list = self:_get_argument_list() table.insert(argument_list, 1, nil) for _, alias in ipairs(self._aliases) do argument_list[1] = alias table.insert(variants, table.concat(argument_list, " ")) end return table.concat(variants, ", ") end function Command:_get_label() return table.concat(self._aliases, ", ") end function Argument:_get_description() if self._default and self._show_default then if self._description then return ("%s (default: %s)"):format(self._description, self._default) else return ("default: %s"):format(self._default) end else return self._description or "" end end function Command:_get_description() return self._description or "" end function Option:_get_usage() local usage = self:_get_argument_list() table.insert(usage, 1, self._name) usage = table.concat(usage, " ") if self._mincount == 0 or self._default then usage = "[" .. usage .. "]" end return usage end function Argument:_get_default_target() return self._name end function Option:_get_default_target() local res for _, alias in ipairs(self._aliases) do if alias:sub(1, 1) == alias:sub(2, 2) then res = alias:sub(3) break end end res = res or self._name:sub(2) return (res:gsub("-", "_")) end function Option:_is_vararg() return self._maxargs ~= self._minargs end function Parser:_get_fullname() local parent = self._parent local buf = {self._name} while parent do table.insert(buf, 1, parent._name) parent = parent._parent end return table.concat(buf, " ") end function Parser:_update_charset(charset) charset = charset or {} for _, command in ipairs(self._commands) do command:_update_charset(charset) end for _, option in ipairs(self._options) do for _, alias in ipairs(option._aliases) do charset[alias:sub(1, 1)] = true end end return charset end function Parser:argument(...) local argument = Argument(...) table.insert(self._arguments, argument) return argument end function Parser:option(...) local option = Option(...) if self._has_help then table.insert(self._options, #self._options, option) else table.insert(self._options, option) end return option end function Parser:flag(...) return self:option():args(0)(...) end function Parser:command(...) local command = Command():add_help(true)(...) command._parent = self table.insert(self._commands, command) return command end function Parser:mutex(...) local options = {...} for i, option in ipairs(options) do assert(getmetatable(option) == Option, ("bad argument #%d to 'mutex' (Option expected)"):format(i)) end table.insert(self._mutexes, options) return self end local max_usage_width = 70 local usage_welcome = "Usage: " function Parser:get_usage() if self._usage then return self._usage end local lines = {usage_welcome .. self:_get_fullname()} local function add(s) if #lines[#lines]+1+#s <= max_usage_width then lines[#lines] = lines[#lines] .. " " .. s else lines[#lines+1] = (" "):rep(#usage_welcome) .. s end end -- This can definitely be refactored into something cleaner local mutex_options = {} local vararg_mutexes = {} -- First, put mutexes which do not contain vararg options and remember those which do for _, mutex in ipairs(self._mutexes) do local buf = {} local is_vararg = false for _, option in ipairs(mutex) do if option:_is_vararg() then is_vararg = true end table.insert(buf, option:_get_usage()) mutex_options[option] = true end local repr = "(" .. table.concat(buf, " | ") .. ")" if is_vararg then table.insert(vararg_mutexes, repr) else add(repr) end end -- Second, put regular options for _, option in ipairs(self._options) do if not mutex_options[option] and not option:_is_vararg() then add(option:_get_usage()) end end -- Put positional arguments for _, argument in ipairs(self._arguments) do add(argument:_get_usage()) end -- Put mutexes containing vararg options for _, mutex_repr in ipairs(vararg_mutexes) do add(mutex_repr) end for _, option in ipairs(self._options) do if not mutex_options[option] and option:_is_vararg() then add(option:_get_usage()) end end if #self._commands > 0 then if self._require_command then add("") else add("[]") end add("...") end return table.concat(lines, "\n") end local margin_len = 3 local margin_len2 = 25 local margin = (" "):rep(margin_len) local margin2 = (" "):rep(margin_len2) local function make_two_columns(s1, s2) if s2 == "" then return margin .. s1 end s2 = s2:gsub("\n", "\n" .. margin2) if #s1 < (margin_len2-margin_len) then return margin .. s1 .. (" "):rep(margin_len2-margin_len-#s1) .. s2 else return margin .. s1 .. "\n" .. margin2 .. s2 end end function Parser:get_help() if self._help then return self._help end local blocks = {self:get_usage()} if self._description then table.insert(blocks, self._description) end local labels = {"Arguments:", "Options:", "Commands:"} for i, elements in ipairs{self._arguments, self._options, self._commands} do if #elements > 0 then local buf = {labels[i]} for _, element in ipairs(elements) do table.insert(buf, make_two_columns(element:_get_label(), element:_get_description())) end table.insert(blocks, table.concat(buf, "\n")) end end if self._epilog then table.insert(blocks, self._epilog) end return table.concat(blocks, "\n\n") end local function get_tip(context, wrong_name) local context_pool = {} local possible_name local possible_names = {} for name in pairs(context) do if type(name) == "string" then for i = 1, #name do possible_name = name:sub(1, i - 1) .. name:sub(i + 1) if not context_pool[possible_name] then context_pool[possible_name] = {} end table.insert(context_pool[possible_name], name) end end end for i = 1, #wrong_name + 1 do possible_name = wrong_name:sub(1, i - 1) .. wrong_name:sub(i + 1) if context[possible_name] then possible_names[possible_name] = true elseif context_pool[possible_name] then for _, name in ipairs(context_pool[possible_name]) do possible_names[name] = true end end end local first = next(possible_names) if first then if next(possible_names, first) then local possible_names_arr = {} for name in pairs(possible_names) do table.insert(possible_names_arr, "'" .. name .. "'") end table.sort(possible_names_arr) return "\nDid you mean one of these: " .. table.concat(possible_names_arr, " ") .. "?" else return "\nDid you mean '" .. first .. "'?" end else return "" end end local ElementState = class({ invocations = 0 }) function ElementState:__call(state, element) self.state = state self.result = state.result self.element = element self.target = element._target or element:_get_default_target() self.action, self.result[self.target] = element:_get_action() return self end function ElementState:error(fmt, ...) self.state:error(fmt, ...) end function ElementState:convert(argument) local converter = self.element._convert if converter then local ok, err if type(converter) == "function" then ok, err = converter(argument) else ok = converter[argument] end if ok == nil then self:error(err and "%s" or "malformed argument '%s'", err or argument) end argument = ok end return argument end function ElementState:default(mode) return self.element._defmode:find(mode) and self.element._default end local function bound(noun, min, max, is_max) local res = "" if min ~= max then res = "at " .. (is_max and "most" or "least") .. " " end local number = is_max and max or min return res .. tostring(number) .. " " .. noun .. (number == 1 and "" or "s") end function ElementState:invoke(alias) self.open = true self.name = ("%s '%s'"):format(alias and "option" or "argument", alias or self.element._name) self.overwrite = false if self.invocations >= self.element._maxcount then if self.element._overwrite then self.overwrite = true else self:error("%s must be used %s", self.name, bound("time", self.element._mincount, self.element._maxcount, true)) end else self.invocations = self.invocations + 1 end self.args = {} if self.element._maxargs <= 0 then self:close() end return self.open end function ElementState:pass(argument) argument = self:convert(argument) table.insert(self.args, argument) if #self.args >= self.element._maxargs then self:close() end return self.open end function ElementState:complete_invocation() while #self.args < self.element._minargs do self:pass(self.element._default) end end function ElementState:close() if self.open then self.open = false if #self.args < self.element._minargs then if self:default("a") then self:complete_invocation() else if #self.args == 0 then if getmetatable(self.element) == Argument then self:error("missing %s", self.name) elseif self.element._maxargs == 1 then self:error("%s requires an argument", self.name) end end self:error("%s requires %s", self.name, bound("argument", self.element._minargs, self.element._maxargs)) end end local args = self.args if self.element._maxargs <= 1 then args = args[1] end if self.element._maxargs == 1 and self.element._minargs == 0 and self.element._mincount ~= self.element._maxcount then args = self.args end self.action(self.result, self.target, args, self.overwrite) end end local ParseState = class({ result = {}, options = {}, arguments = {}, argument_i = 1, element_to_mutexes = {}, mutex_to_used_option = {}, command_actions = {} }) function ParseState:__call(parser, error_handler) self.parser = parser self.error_handler = error_handler self.charset = parser:_update_charset() self:switch(parser) return self end function ParseState:error(fmt, ...) self.error_handler(self.parser, fmt:format(...)) end function ParseState:switch(parser) self.parser = parser if parser._action then table.insert(self.command_actions, {action = parser._action, name = parser._name}) end for _, option in ipairs(parser._options) do option = ElementState(self, option) table.insert(self.options, option) for _, alias in ipairs(option.element._aliases) do self.options[alias] = option end end for _, mutex in ipairs(parser._mutexes) do for _, option in ipairs(mutex) do if not self.element_to_mutexes[option] then self.element_to_mutexes[option] = {} end table.insert(self.element_to_mutexes[option], mutex) end end for _, argument in ipairs(parser._arguments) do argument = ElementState(self, argument) table.insert(self.arguments, argument) argument:invoke() end self.handle_options = parser._handle_options self.argument = self.arguments[self.argument_i] self.commands = parser._commands for _, command in ipairs(self.commands) do for _, alias in ipairs(command._aliases) do self.commands[alias] = command end end end function ParseState:get_option(name) local option = self.options[name] if not option then self:error("unknown option '%s'%s", name, get_tip(self.options, name)) else return option end end function ParseState:get_command(name) local command = self.commands[name] if not command then if #self.commands > 0 then self:error("unknown command '%s'%s", name, get_tip(self.commands, name)) else self:error("too many arguments") end else return command end end function ParseState:invoke(option, name) self:close() if self.element_to_mutexes[option.element] then for _, mutex in ipairs(self.element_to_mutexes[option.element]) do local used_option = self.mutex_to_used_option[mutex] if used_option and used_option ~= option then self:error("option '%s' can not be used together with %s", name, used_option.name) else self.mutex_to_used_option[mutex] = option end end end if option:invoke(name) then self.option = option end end function ParseState:pass(arg) if self.option then if not self.option:pass(arg) then self.option = nil end elseif self.argument then if not self.argument:pass(arg) then self.argument_i = self.argument_i + 1 self.argument = self.arguments[self.argument_i] end else local command = self:get_command(arg) self.result[command._target or command._name] = true if self.parser._command_target then self.result[self.parser._command_target] = command._name end self:switch(command) end end function ParseState:close() if self.option then self.option:close() self.option = nil end end function ParseState:finalize() self:close() for i = self.argument_i, #self.arguments do local argument = self.arguments[i] if #argument.args == 0 and argument:default("u") then argument:complete_invocation() else argument:close() end end if self.parser._require_command and #self.commands > 0 then self:error("a command is required") end for _, option in ipairs(self.options) do local name = option.name or ("option '%s'"):format(option.element._name) if option.invocations == 0 then if option:default("u") then option:invoke(name) option:complete_invocation() option:close() end end local mincount = option.element._mincount if option.invocations < mincount then if option:default("a") then while option.invocations < mincount do option:invoke(name) option:close() end elseif option.invocations == 0 then self:error("missing %s", name) else self:error("%s must be used %s", name, bound("time", mincount, option.element._maxcount)) end end end for i = #self.command_actions, 1, -1 do self.command_actions[i].action(self.result, self.command_actions[i].name) end end function ParseState:parse(args) for _, arg in ipairs(args) do local plain = true if self.handle_options then local first = arg:sub(1, 1) if self.charset[first] then if #arg > 1 then plain = false if arg:sub(2, 2) == first then if #arg == 2 then self:close() self.handle_options = false else local equals = arg:find "=" if equals then local name = arg:sub(1, equals - 1) local option = self:get_option(name) if option.element._maxargs <= 0 then self:error("option '%s' does not take arguments", name) end self:invoke(option, name) self:pass(arg:sub(equals + 1)) else local option = self:get_option(arg) self:invoke(option, arg) end end else for i = 2, #arg do local name = first .. arg:sub(i, i) local option = self:get_option(name) self:invoke(option, name) if i ~= #arg and option.element._maxargs > 0 then self:pass(arg:sub(i + 1)) break end end end end end end if plain then self:pass(arg) end end self:finalize() return self.result end function Parser:error(msg) io.stderr:write(("%s\n\nError: %s\n"):format(self:get_usage(), msg)) os.exit(1) end -- Compatibility with strict.lua and other checkers: local default_cmdline = rawget(_G, "arg") or {} function Parser:_parse(args, error_handler) return ParseState(self, error_handler):parse(args or default_cmdline) end function Parser:parse(args) return self:_parse(args, self.error) end local function xpcall_error_handler(err) return tostring(err) .. "\noriginal " .. debug.traceback("", 2):sub(2) end function Parser:pparse(args) local parse_error local ok, result = xpcall(function() return self:_parse(args, function(_, err) parse_error = err error(err, 0) end) end, xpcall_error_handler) if ok then return true, result elseif not parse_error then error(result, 0) else return false, parse_error end end return function(...) return Parser(default_cmdline[0]):add_help(true)(...) end bpfcc-0.2.0+git0.02884a026/src/lua/bcc/vendor/helpers.lua000066400000000000000000000106461305314114400222460ustar00rootroot00000000000000do local ffi = require("ffi") local ptrtype = ffi.typeof("uint64_t") local strformat = string.format function string.format(format, ...) local args = {...} local match_no = 1 local newfmt, count = string.gsub(format, "()%%(.-)(%a)", function(_, mods, t) local n = match_no match_no = match_no + 1 if t == 'p' and ffi.istype(ptrtype, args[n]) then local lo = tonumber(args[n] % 4294967296ULL) local hi = tonumber(args[n] / 4294967296ULL) args[n] = (hi == 0) and strformat("%x", lo) or strformat("%x%08x", hi, lo) return "%"..mods.."s" end end) if count == 0 then return strformat(format, ...) else return strformat(newfmt, unpack(args,1,select('#',...))) end end end function string.starts(s, p) return string.sub(s, 1, string.len(p)) == p end function string.lstrip(s, p) return string.sub(s, string.len(p) + 1) end function string.ends(s, e) return e == '' or string.sub(s, -string.len(e))==e end function string.escape(s) return s:gsub('[%-%.%+%[%]%(%)%$%^%%%?%*]','%%%1') end --- split a string into a list of strings separated by a delimiter. -- @param s The input string -- @param re A Lua string pattern; defaults to '%s+' -- @param plain don't use Lua patterns -- @param n optional maximum number of splits -- @return a list-like table -- @raise error if s is not a string function string.split(s,re,plain,n) local find,sub,append = string.find, string.sub, table.insert local i1,ls = 1,{} if not re then re = '%s+' end if re == '' then return {s} end while true do local i2,i3 = find(s,re,i1,plain) if not i2 then local last = sub(s,i1) if last ~= '' then append(ls,last) end if #ls == 1 and ls[1] == '' then return {} else return ls end end append(ls,sub(s,i1,i2-1)) if n and #ls == n then ls[#ls] = sub(s,i1) return ls end i1 = i3+1 end end function table.count(T) local count = 0 for _ in pairs(T) do count = count + 1 end return count end function table.bsearch(list, value, mkval) local low = 1 local high = #list while low <= high do local mid = math.floor((low+high)/2) local this = mkval and mkval(list[mid]) or list[mid] if this > value then high = mid - 1 elseif this < value then low = mid + 1 else return mid end end return low - 1 end function table.join(a, b) assert(a) if b == nil or #b == 0 then return a end local res = {} for _, v in ipairs(a) do table.insert(res, v) end for _, v in ipairs(b) do table.insert(res, v) end return res end function table.build(iterator_fn, build_fn) build_fn = (build_fn or function(arg) return arg end) local res = {} while true do local vars = {iterator_fn()} if vars[1] == nil then break end table.insert(res, build_fn(vars)) end return res end function table.values(T) local V = {} for k, v in pairs(T) do table.insert(V, v) end return V end function table.tuples(T) local i = 0 local n = table.getn(t) return function () i = i + 1 if i <= n then return t[i][1], t[i][2] end end end getmetatable("").__mod = function(a, b) if not b then return a elseif type(b) == "table" then return string.format(a, unpack(b)) else return string.format(a, b) end end function os.exists(path) local f=io.open(path,"r") if f~=nil then io.close(f) return true else return false end end function os.spawn(...) local cmd = string.format(...) local proc = assert(io.popen(cmd)) local out = proc:read("*a") proc:close() return out end local function logline(...) if not log.enabled then return end local c_green = "\27[32m" local c_grey = "\27[1;30m" local c_clear = "\27[0m" local msg = string.format(...) local info = debug.getinfo(2, "Sln") local line = string.format("%s[%s:%s]%s %s", c_grey, info.short_src:match("^.+/(.+)$"), info.currentline, c_clear, info.name) io.stderr:write( string.format("%s[%s]%s %s: %s\n", c_green, os.date("%H:%M:%S"), c_clear, line, msg)) end setmetatable(_G, { __newindex = function (_, n) error("attempt to write to undeclared variable "..n, 2) end, __index = function (_, n) error("attempt to read undeclared variable "..n, 2) end, }) rawset(_G, "log", { info = logline, enabled = false }) rawset(_G, "class", require("bcc.vendor.middleclass")) bpfcc-0.2.0+git0.02884a026/src/lua/bcc/vendor/json.lua000066400000000000000000000161251305314114400215530ustar00rootroot00000000000000--[[ json.lua A compact pure-Lua JSON library. This code is in the public domain: https://gist.github.com/tylerneylon/59f4bcf316be525b30ab The main functions are: json.stringify, json.parse. ## json.stringify: This expects the following to be true of any tables being encoded: * They only have string or number keys. Number keys must be represented as strings in json; this is part of the json spec. * They are not recursive. Such a structure cannot be specified in json. A Lua table is considered to be an array if and only if its set of keys is a consecutive sequence of positive integers starting at 1. Arrays are encoded like so: `[2, 3, false, "hi"]`. Any other type of Lua table is encoded as a json object, encoded like so: `{"key1": 2, "key2": false}`. Because the Lua nil value cannot be a key, and as a table value is considerd equivalent to a missing key, there is no way to express the json "null" value in a Lua table. The only way this will output "null" is if your entire input obj is nil itself. An empty Lua table, {}, could be considered either a json object or array - it's an ambiguous edge case. We choose to treat this as an object as it is the more general type. To be clear, none of the above considerations is a limitation of this code. Rather, it is what we get when we completely observe the json specification for as arbitrary a Lua object as json is capable of expressing. ## json.parse: This function parses json, with the exception that it does not pay attention to \u-escaped unicode code points in strings. It is difficult for Lua to return null as a value. In order to prevent the loss of keys with a null value in a json string, this function uses the one-off table value json.null (which is just an empty table) to indicate null values. This way you can check if a value is null with the conditional `val == json.null`. If you have control over the data and are using Lua, I would recommend just avoiding null values in your data to begin with. --]] local json = {} -- Internal functions. local function kind_of(obj) if type(obj) ~= 'table' then return type(obj) end local i = 1 for _ in pairs(obj) do if obj[i] ~= nil then i = i + 1 else return 'table' end end if i == 1 then return 'table' else return 'array' end end local function escape_str(s) local in_char = {'\\', '"', '/', '\b', '\f', '\n', '\r', '\t'} local out_char = {'\\', '"', '/', 'b', 'f', 'n', 'r', 't'} for i, c in ipairs(in_char) do s = s:gsub(c, '\\' .. out_char[i]) end return s end -- Returns pos, did_find; there are two cases: -- 1. Delimiter found: pos = pos after leading space + delim; did_find = true. -- 2. Delimiter not found: pos = pos after leading space; did_find = false. -- This throws an error if err_if_missing is true and the delim is not found. local function skip_delim(str, pos, delim, err_if_missing) pos = pos + #str:match('^%s*', pos) if str:sub(pos, pos) ~= delim then if err_if_missing then error('Expected ' .. delim .. ' near position ' .. pos) end return pos, false end return pos + 1, true end -- Expects the given pos to be the first character after the opening quote. -- Returns val, pos; the returned pos is after the closing quote character. local function parse_str_val(str, pos, val) val = val or '' local early_end_error = 'End of input found while parsing string.' if pos > #str then error(early_end_error) end local c = str:sub(pos, pos) if c == '"' then return val, pos + 1 end if c ~= '\\' then return parse_str_val(str, pos + 1, val .. c) end -- We must have a \ character. local esc_map = {b = '\b', f = '\f', n = '\n', r = '\r', t = '\t'} local nextc = str:sub(pos + 1, pos + 1) if not nextc then error(early_end_error) end return parse_str_val(str, pos + 2, val .. (esc_map[nextc] or nextc)) end -- Returns val, pos; the returned pos is after the number's final character. local function parse_num_val(str, pos) local num_str = str:match('^-?%d+%.?%d*[eE]?[+-]?%d*', pos) local val = tonumber(num_str) if not val then error('Error parsing number at position ' .. pos .. '.') end return val, pos + #num_str end -- Public values and functions. function json.stringify(obj, as_key) local s = {} -- We'll build the string as an array of strings to be concatenated. local kind = kind_of(obj) -- This is 'array' if it's an array or type(obj) otherwise. if kind == 'array' then if as_key then error('Can\'t encode array as key.') end s[#s + 1] = '[' for i, val in ipairs(obj) do if i > 1 then s[#s + 1] = ', ' end s[#s + 1] = json.stringify(val) end s[#s + 1] = ']' elseif kind == 'table' then if as_key then error('Can\'t encode table as key.') end s[#s + 1] = '{' for k, v in pairs(obj) do if #s > 1 then s[#s + 1] = ', ' end s[#s + 1] = json.stringify(k, true) s[#s + 1] = ':' s[#s + 1] = json.stringify(v) end s[#s + 1] = '}' elseif kind == 'string' then return '"' .. escape_str(obj) .. '"' elseif kind == 'number' then if as_key then return '"' .. tostring(obj) .. '"' end return tostring(obj) elseif kind == 'boolean' then return tostring(obj) elseif kind == 'nil' then return 'null' else error('Unjsonifiable type: ' .. kind .. '.') end return table.concat(s) end json.null = {} -- This is a one-off table to represent the null value. function json.parse(str, pos, end_delim) pos = pos or 1 if pos > #str then error('Reached unexpected end of input.') end local pos = pos + #str:match('^%s*', pos) -- Skip whitespace. local first = str:sub(pos, pos) if first == '{' then -- Parse an object. local obj, key, delim_found = {}, true, true pos = pos + 1 while true do key, pos = json.parse(str, pos, '}') if key == nil then return obj, pos end if not delim_found then error('Comma missing between object items.') end pos = skip_delim(str, pos, ':', true) -- true -> error if missing. obj[key], pos = json.parse(str, pos) pos, delim_found = skip_delim(str, pos, ',') end elseif first == '[' then -- Parse an array. local arr, val, delim_found = {}, true, true pos = pos + 1 while true do val, pos = json.parse(str, pos, ']') if val == nil then return arr, pos end if not delim_found then error('Comma missing between array items.') end arr[#arr + 1] = val pos, delim_found = skip_delim(str, pos, ',') end elseif first == '"' then -- Parse a string. return parse_str_val(str, pos + 1) elseif first == '-' or first:match('%d') then -- Parse a number. return parse_num_val(str, pos) elseif first == end_delim then -- End of an object or array. return nil, pos + 1 else -- Parse true, false, or null. local literals = {['true'] = true, ['false'] = false, ['null'] = json.null} for lit_str, lit_val in pairs(literals) do local lit_end = pos + #lit_str - 1 if str:sub(pos, lit_end) == lit_str then return lit_val, lit_end + 1 end end local pos_info_str = 'position ' .. pos .. ': ' .. str:sub(pos, pos + 10) error('Invalid json syntax starting at ' .. pos_info_str) end end return json bpfcc-0.2.0+git0.02884a026/src/lua/bcc/vendor/middleclass.lua000066400000000000000000000135251305314114400230670ustar00rootroot00000000000000local middleclass = { _VERSION = 'middleclass v4.0.0', _DESCRIPTION = 'Object Orientation for Lua', _URL = 'https://github.com/kikito/middleclass', _LICENSE = [[ MIT LICENSE Copyright (c) 2011 Enrique García Cota Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ]] } local function _createIndexWrapper(aClass, f) if f == nil then return aClass.__instanceDict else return function(self, name) local value = aClass.__instanceDict[name] if value ~= nil then return value elseif type(f) == "function" then return (f(self, name)) else return f[name] end end end end local function _propagateInstanceMethod(aClass, name, f) f = name == "__index" and _createIndexWrapper(aClass, f) or f aClass.__instanceDict[name] = f for subclass in pairs(aClass.subclasses) do if rawget(subclass.__declaredMethods, name) == nil then _propagateInstanceMethod(subclass, name, f) end end end local function _declareInstanceMethod(aClass, name, f) aClass.__declaredMethods[name] = f if f == nil and aClass.super then f = aClass.super.__instanceDict[name] end _propagateInstanceMethod(aClass, name, f) end local function _tostring(self) return "class " .. self.name end local function _call(self, ...) return self:new(...) end local function _createClass(name, super) local dict = {} dict.__index = dict local aClass = { name = name, super = super, static = {}, __instanceDict = dict, __declaredMethods = {}, subclasses = setmetatable({}, {__mode='k'}) } if super then setmetatable(aClass.static, { __index = function(_,k) return rawget(dict,k) or super.static[k] end }) else setmetatable(aClass.static, { __index = function(_,k) return rawget(dict,k) end }) end setmetatable(aClass, { __index = aClass.static, __tostring = _tostring, __call = _call, __newindex = _declareInstanceMethod }) return aClass end local function _includeMixin(aClass, mixin) assert(type(mixin) == 'table', "mixin must be a table") for name,method in pairs(mixin) do if name ~= "included" and name ~= "static" then aClass[name] = method end end for name,method in pairs(mixin.static or {}) do aClass.static[name] = method end if type(mixin.included)=="function" then mixin:included(aClass) end return aClass end local DefaultMixin = { __tostring = function(self) return "instance of " .. tostring(self.class) end, initialize = function(self, ...) end, isInstanceOf = function(self, aClass) return type(self) == 'table' and type(self.class) == 'table' and type(aClass) == 'table' and ( aClass == self.class or type(aClass.isSubclassOf) == 'function' and self.class:isSubclassOf(aClass) ) end, static = { allocate = function(self) assert(type(self) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'") return setmetatable({ class = self }, self.__instanceDict) end, new = function(self, ...) assert(type(self) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'") local instance = self:allocate() instance:initialize(...) return instance end, subclass = function(self, name) assert(type(self) == 'table', "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'") assert(type(name) == "string", "You must provide a name(string) for your class") local subclass = _createClass(name, self) for methodName, f in pairs(self.__instanceDict) do _propagateInstanceMethod(subclass, methodName, f) end subclass.initialize = function(instance, ...) return self.initialize(instance, ...) end self.subclasses[subclass] = true self:subclassed(subclass) return subclass end, subclassed = function(self, other) end, isSubclassOf = function(self, other) return type(other) == 'table' and type(self) == 'table' and type(self.super) == 'table' and ( self.super == other or type(self.super.isSubclassOf) == 'function' and self.super:isSubclassOf(other) ) end, include = function(self, ...) assert(type(self) == 'table', "Make sure you that you are using 'Class:include' instead of 'Class.include'") for _,mixin in ipairs({...}) do _includeMixin(self, mixin) end return self end } } function middleclass.class(name, super) assert(type(name) == 'string', "A name (string) is needed for the new class") return super and super:subclass(name) or _includeMixin(_createClass(name), DefaultMixin) end setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end }) return middleclass bpfcc-0.2.0+git0.02884a026/src/lua/bcc/vendor/posix.lua000066400000000000000000000041431305314114400217410ustar00rootroot00000000000000--[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require("ffi") -- Avoid duplicate declarations if syscall library is present local has_syscall, _ = pcall(require, "syscall") if not has_syscall then ffi.cdef [[ typedef int clockid_t; typedef long time_t; struct timespec { time_t tv_sec; long tv_nsec; }; int clock_gettime(clockid_t clk_id, struct timespec *tp); int clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request, struct timespec *remain); ]] end ffi.cdef [[ int get_nprocs(void); uint64_t strtoull(const char *nptr, char **endptr, int base); ]] local CLOCK = { REALTIME = 0, MONOTONIC = 1, PROCESS_CPUTIME_ID = 2, THREAD_CPUTIME_ID = 3, MONOTONIC_RAW = 4, REALTIME_COARSE = 5, MONOTONIC_COARSE = 6, } local function time_ns(clock) local ts = ffi.new("struct timespec[1]") assert(ffi.C.clock_gettime(clock or CLOCK.MONOTONIC_RAW, ts) == 0, "clock_gettime() failed: "..ffi.errno()) return tonumber(ts[0].tv_sec * 1e9 + ts[0].tv_nsec) end local function sleep(seconds, clock) local s, ns = math.modf(seconds) local ts = ffi.new("struct timespec[1]") ts[0].tv_sec = s ts[0].tv_nsec = ns / 1e9 ffi.C.clock_nanosleep(clock or CLOCK.MONOTONIC, 0, ts, nil) end local function cpu_count() return tonumber(ffi.C.get_nprocs()) end local function tonumber64(n, base) assert(type(n) == "string") return ffi.C.strtoull(n, nil, base or 10) end return { time_ns=time_ns, sleep=sleep, CLOCK=CLOCK, cpu_count=cpu_count, tonumber64=tonumber64, } bpfcc-0.2.0+git0.02884a026/src/lua/bpf-scm-1.rockspec000066400000000000000000000014101305314114400212620ustar00rootroot00000000000000package = "bpf" version = "scm-1" source = { url = "git://github.com/iovisor/bcc.git" } description = { summary = "BCC - LuaJIT to BPF compiler.", detailed = [[ ]], homepage = "https://github.com/iovisor/bcc", license = "BSD" } dependencies = { "lua >= 5.1", "ljsyscall >= 0.12", } external_dependencies = { LIBELF = { library = "elf" } } build = { type = "builtin", install = { bin = { } }, modules = { bpf = "src/lua/bpf/bpf.lua", ["bpf.builtins"] = "src/lua/bpf/builtins.lua", ["bpf.cdef"] = "src/lua/bpf/cdef.lua", ["bpf.elf"] = "src/lua/bpf/elf.lua", ["bpf.init"] = "src/lua/bpf/init.lua", ["bpf.ljbytecode"] = "src/lua/bpf/ljbytecode.lua", ["bpf.proto"] = "src/lua/bpf/proto.lua", } } bpfcc-0.2.0+git0.02884a026/src/lua/bpf/000077500000000000000000000000001305314114400166155ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/lua/bpf/bpf.lua000066400000000000000000001375011305314114400200760ustar00rootroot00000000000000--[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- LuaJIT to BPF bytecode compiler. -- -- The code generation phase is currently one-pass and produces: -- * Compiled code in BPF bytecode format (https://www.kernel.org/doc/Documentation/networking/filter.txt) -- * Variables with liveness analysis and other meta (spill information, compile-time value) -- -- The code generator optimises as much as possible in single pass: -- * Fold compile-time expressions and constant propagation -- * Basic control flow analysis with dead code elimination (based on compile-time expressions) -- * Single-pass optimistic register allocation -- -- The first pass doesn't have variable lifetime visibility yet, so it relies on rewriter for further -- optimisations such as: -- * Dead store elimination (first-pass doesn't know if/when the variable is going to be used) -- * Common sub-expression elimination (relies on DCE and liveness analysis) -- * Orphan JMP elimination (removing this in first pass would break previous JMP targets) -- * Better register allocation (needs to be recomputed after optimisations) local ffi = require('ffi') local bit = require('bit') local S = require('syscall') local bytecode = require('bpf.ljbytecode') local cdef = require('bpf.cdef') local proto = require('bpf.proto') local builtins = require('bpf.builtins') -- Constants local ALWAYS, NEVER = -1, -2 local BPF = ffi.typeof('struct bpf') local HELPER = ffi.typeof('struct bpf_func_id') -- Symbolic table of constant expressions over numbers local const_expr = { ADD = function (a, b) return a + b end, SUB = function (a, b) return a - b end, DIV = function (a, b) return a / b end, MOD = function (a, b) return a % b end, JEQ = function (a, b) return a == b end, JNE = function (a, b) return a ~= b end, JGE = function (a, b) return a >= b end, JGT = function (a, b) return a > b end, } local const_width = { [1] = BPF.B, [2] = BPF.H, [4] = BPF.W, [8] = BPF.DW, } -- Built-ins that are strict only (never compile-time expandable) local builtins_strict = { [ffi.new] = true, [print] = true, } -- Return struct member size/type (requires LuaJIT 2.1+) -- I am ashamed that there's no easier way around it. local function sizeofattr(ct, name) if not ffi.typeinfo then error('LuaJIT 2.1+ is required for ffi.typeinfo') end local cinfo = ffi.typeinfo(ct) while true do cinfo = ffi.typeinfo(cinfo.sib) if not cinfo then return end if cinfo.name == name then break end end local size = math.max(1, ffi.typeinfo(cinfo.sib or ct).size - cinfo.size) -- Guess type name return size, builtins.width_type(size) end -- Return true if the constant part is a proxy local function is_proxy(x) return type(x) == 'table' and (x.__dissector or x.__map or x.__base) end -- Create compiler closure local function create_emitter(env, stackslots, params, param_types) local V = {} -- Variable tracking / register allocator local code = { -- Generated code pc = 0, bc_pc = 0, insn = ffi.new('struct bpf_insn[4096]'), fixup = {}, reachable = true, seen_cmp = nil, } local Vstate = {} -- Track variable layout at basic block exits -- Anything below this stack offset is free to use by caller -- @note: There is no tracking memory allocator, so the caller may -- lower it for persistent objects, but such memory will never -- be reclaimed and the caller is responsible for resetting stack -- top whenever the memory below is free to be reused local stack_top = (stackslots + 1) * ffi.sizeof('uint64_t') local function emit(op, dst, src, off, imm) local ins = code.insn[code.pc] ins.code = op ins.dst_reg = dst ins.src_reg = src ins.off = off ins.imm = imm code.pc = code.pc + 1 end local function reg_spill(var) local vinfo = V[var] vinfo.spill = (var + 1) * ffi.sizeof('uint64_t') -- Index by (variable number) * (register width) emit(BPF.MEM + BPF.STX + BPF.DW, 10, vinfo.reg, -vinfo.spill, 0) vinfo.reg = nil end local function reg_fill(var, reg) local vinfo = V[var] assert(vinfo.spill, 'attempt to fill register with a VAR that isn\'t spilled') emit(BPF.MEM + BPF.LDX + BPF.DW, reg, 10, -vinfo.spill, 0) vinfo.reg = reg vinfo.spill = nil end -- Allocate a register (lazy simple allocator) local function reg_alloc(var, reg) -- Specific register requested, must spill/move existing variable if reg then for k,v in pairs(V) do -- Spill any variable that has this register if v.reg == reg and not v.shadow then reg_spill(k) break end end return reg end -- Find free or least recently used slot local last, last_seen, used = nil, 0xffff, 0 for k,v in pairs(V) do if v.reg then if not v.live_to or v.live_to < last_seen then last, last_seen = k, v.live_to or last_seen end used = bit.bor(used, bit.lshift(1, v.reg)) end end -- Attempt to select a free register from R7-R9 (callee saved) local free = bit.bnot(used) if bit.band(free, 0x80) ~= 0 then reg = 7 elseif bit.band(free,0x100) ~= 0 then reg = 8 elseif bit.band(free,0x200) ~= 0 then reg = 9 end -- Select another variable to be spilled if not reg then assert(last) reg = V[last].reg reg_spill(last) end assert(reg, 'VAR '..var..'fill/spill failed') return reg end -- Set new variable local function vset(var, reg, const, vtype) -- Must materialise all variables shadowing this variable slot, as it will be overwritten if V[var] and V[var].reg then for _, vinfo in pairs(V) do -- Shadowing variable MUST share the same type and attributes, -- but the register assignment may have changed if vinfo.shadow == var then vinfo.reg = V[var].reg vinfo.shadow = nil end end end -- Get precise type for CDATA or attempt to narrow numeric constant if not vtype and type(const) == 'cdata' then vtype = ffi.typeof(const) end V[var] = {reg=reg, const=const, type=vtype} end -- Materialize (or register) a variable in a register -- If the register is nil, then the a new register is assigned (if not already assigned) local function vreg(var, reg, reserve, vtype) local vinfo = V[var] assert(vinfo, 'VAR '..var..' not registered') vinfo.live_to = code.pc-1 if (vinfo.reg and not reg) and not vinfo.shadow then return vinfo.reg end reg = reg_alloc(var, reg) -- Materialize variable shadow copy local src = vinfo while src.shadow do src = V[src.shadow] end if reserve then -- No load to register occurs elseif src.reg then emit(BPF.ALU64 + BPF.MOV + BPF.X, reg, src.reg, 0, 0) elseif src.spill then vinfo.spill = src.spill reg_fill(var, reg) elseif src.const then vtype = vtype or src.type if type(src.const) == 'table' and src.const.__base then -- Load pointer type emit(BPF.ALU64 + BPF.MOV + BPF.X, reg, 10, 0, 0) emit(BPF.ALU64 + BPF.ADD + BPF.K, reg, 0, 0, -src.const.__base) elseif type(src.const) == 'table' and src.const.__dissector then -- Load dissector offset (imm32), but keep the constant part (dissector proxy) emit(BPF.ALU64 + BPF.MOV + BPF.K, reg, 0, 0, src.const.off or 0) elseif vtype and ffi.sizeof(vtype) == 8 then -- IMM64 must be done in two instructions with imm64 = (lo(imm32), hi(imm32)) emit(BPF.LD + BPF.DW, reg, 0, 0, ffi.cast('uint32_t', src.const)) emit(0, 0, 0, 0, ffi.cast('uint32_t', bit.rshift(bit.rshift(src.const, 16), 16))) vinfo.const = nil -- The variable is live else emit(BPF.ALU64 + BPF.MOV + BPF.K, reg, 0, 0, src.const) vinfo.const = nil -- The variable is live end else assert(false, 'VAR '..var..' has neither register nor constant value') end vinfo.reg = reg vinfo.shadow = nil vinfo.live_from = code.pc-1 vinfo.type = vtype or vinfo.type return reg end -- Copy variable local function vcopy(dst, src) if dst == src then return end V[dst] = {reg=V[src].reg, const=V[src].const, shadow=src, source=V[src].source, type=V[src].type} end -- Dereference variable of pointer type local function vderef(dst_reg, src_reg, vtype) -- Dereference map pointers for primitive types -- BPF doesn't allow pointer arithmetics, so use the entry value local w = ffi.sizeof(vtype) assert(const_width[w], 'NYI: sizeof('..tostring(vtype)..') not 1/2/4/8 bytes') if dst_reg ~= src_reg then emit(BPF.ALU64 + BPF.MOV + BPF.X, dst_reg, src_reg, 0, 0) -- dst = src end emit(BPF.JMP + BPF.JEQ + BPF.K, src_reg, 0, 1, 0) -- if (src != NULL) emit(BPF.MEM + BPF.LDX + const_width[w], dst_reg, src_reg, 0, 0) -- dst = *src; end -- Allocate a space for variable local function valloc(size, blank) local base = stack_top assert(stack_top + size < 512 * 1024, 'exceeded maximum stack size of 512kB') stack_top = stack_top + size -- Align to 8 byte boundary stack_top = math.ceil(stack_top/8)*8 -- Current kernel version doesn't support ARG_PTR_TO_RAW_STACK -- so we always need to have memory initialized, remove this when supported if blank then if type(blank) == 'string' then local sp = 0 while sp < size do -- TODO: no BPF_ST + BPF_DW instruction yet local as_u32 = ffi.new('uint32_t [1]') local sub = blank:sub(sp+1, sp+ffi.sizeof(as_u32)) ffi.copy(as_u32, sub, #sub) emit(BPF.MEM + BPF.ST + BPF.W, 10, 0, -(stack_top-sp), as_u32[0]) sp = sp + ffi.sizeof(as_u32) end elseif type(blank) == 'boolean' then reg_alloc(stackslots, 0) emit(BPF.ALU64 + BPF.MOV + BPF.K, 0, 0, 0, 0) for sp = base+8,stack_top,8 do emit(BPF.MEM + BPF.STX + BPF.DW, 10, 0, -sp, 0) end else error('NYI: will with unknown type '..type(blank)) end end return stack_top end -- Emit compensation code at the end of basic block to unify variable set layout on all block exits -- 1. we need to free registers by spilling -- 2. fill registers to match other exits from this BB local function bb_end(Vcomp) for i,v in pairs(V) do if Vcomp[i] and Vcomp[i].spill and not v.spill then reg_spill(i) end end for i,v in pairs(V) do if Vcomp[i] and Vcomp[i].reg and not v.reg then vreg(i, Vcomp[i].reg) end end end local function LD_ABS(dst, off, w) local dst_reg = vreg(dst, 0, true, builtins.width_type(w)) -- Reserve R0 -- assert(w < 8, 'NYI: LD_ABS64 is not supported') -- IMM64 has two IMM32 insns fused together emit(BPF.LD + BPF.ABS + const_width[w], dst_reg, 0, 0, off) end local function LD_IND(dst, src, w, off) local src_reg = vreg(src) -- Must materialize first in case dst == src local dst_reg = vreg(dst, 0, true, builtins.width_type(w)) -- Reserve R0 emit(BPF.LD + BPF.IND + const_width[w], dst_reg, src_reg, 0, off or 0) end local function LD_FIELD(a, d, w, imm) if imm then LD_ABS(a, imm, w) else LD_IND(a, d, w) end end -- @note: This is specific now as it expects registers reserved local function LD_IMM_X(dst_reg, src_type, imm, w) if w == 8 then -- IMM64 must be done in two instructions with imm64 = (lo(imm32), hi(imm32)) emit(BPF.LD + const_width[w], dst_reg, src_type, 0, ffi.cast('uint32_t', imm)) -- Must shift in two steps as bit.lshift supports [0..31] emit(0, 0, 0, 0, ffi.cast('uint32_t', bit.lshift(bit.lshift(imm, 16), 16))) else emit(BPF.LD + const_width[w], dst_reg, src_type, 0, imm) end end local function LOAD(dst, src, off, vtype) local base = V[src].const assert(base.__dissector, 'NYI: load() on variable that doesnt have dissector') -- Cast to different type if requested vtype = vtype or base.__dissector local w = ffi.sizeof(vtype) assert(w <= 4, 'NYI: load() supports 1/2/4 bytes at a time only') if base.off then -- Absolute address to payload LD_ABS(dst, off + base.off, w) else -- Indirect address to payload LD_IND(dst, src, w, off) end V[dst].type = vtype V[dst].const = nil -- Dissected value is not constant anymore end local function CMP_STR(a, b, op) assert(op == 'JEQ' or op == 'JNE', 'NYI: only equivallence stack/string only supports == or ~=') -- I have no better idea how to implement it than unrolled XOR loop, as we can fixup only one JMP -- So: X(a,b) = a[0] ^ b[0] | a[1] ^ b[1] | ... -- EQ(a,b) <=> X == 0 -- This could be optimised by placing early exits by rewriter in second phase for long strings local base, size = V[a].const.__base, math.min(#b, ffi.sizeof(V[a].type)) local acc, tmp = reg_alloc(stackslots, 0), reg_alloc(stackslots+1, 1) local sp = 0 emit(BPF.ALU64 + BPF.MOV + BPF.K, acc, 0, 0, 0) while sp < size do -- Load string chunk as imm32 local as_u32 = ffi.new('uint32_t [1]') local sub = b:sub(sp+1, sp+ffi.sizeof(as_u32)) ffi.copy(as_u32, sub, #sub) -- TODO: make this faster by interleaved load/compare steps with DW length emit(BPF.MEM + BPF.LDX + BPF.W, tmp, 10, -(base-sp), 0) emit(BPF.ALU64 + BPF.XOR + BPF.K, tmp, 0, 0, as_u32[0]) emit(BPF.ALU64 + BPF.OR + BPF.X, acc, tmp, 0, 0) sp = sp + ffi.sizeof(as_u32) end emit(BPF.JMP + BPF[op] + BPF.K, acc, 0, 0xffff, 0) code.seen_cmp = code.pc-1 end local function CMP_REG(a, b, op) -- Fold compile-time expressions if V[a].const and V[b].const and not (is_proxy(V[a].const) or is_proxy(V[b].const)) then code.seen_cmp = const_expr[op](V[a].const, V[b].const) and ALWAYS or NEVER else -- Comparison against compile-time string or stack memory if V[b].const and type(V[b].const) == 'string' then return CMP_STR(a, V[b].const, op) end -- The 0xFFFF target here has no significance, it's just a placeholder for -- compiler to replace it's absolute offset to LJ bytecode insn with a relative -- offset in BPF program code, verifier will accept only programs with valid JMP targets local a_reg, b_reg = vreg(a), vreg(b) -- Migrate operands from R0-5 as it will be spilled in compensation code when JMP out of BB if a_reg == 0 then a_reg = vreg(a, 7) end emit(BPF.JMP + BPF[op] + BPF.X, a_reg, b_reg, 0xffff, 0) code.seen_cmp = code.pc-1 end end local function CMP_IMM(a, b, op) if V[a].const and not is_proxy(V[a].const) then -- Fold compile-time expressions code.seen_cmp = const_expr[op](V[a].const, b) and ALWAYS or NEVER else -- Convert imm32 to number if type(b) == 'string' then if #b == 1 then b = b:byte() elseif cdef.isptr(V[a].type) then -- String comparison between stack/constant string return CMP_STR(a, b, op) elseif #b <= 4 then -- Convert to u32 with network byte order local imm = ffi.new('uint32_t[1]') ffi.copy(imm, b, #b) b = builtins.hton(imm[0]) else error('NYI: compare register with string, where #string > sizeof(u32)') end end -- The 0xFFFF target here has no significance, it's just a placeholder for -- compiler to replace it's absolute offset to LJ bytecode insn with a relative -- offset in BPF program code, verifier will accept only programs with valid JMP targets local reg = vreg(a) -- Migrate operands from R0-5 as it will be spilled in compensation code when JMP out of BB if reg == 0 then reg = vreg(a, 7) end emit(BPF.JMP + BPF[op] + BPF.K, reg, 0, 0xffff, b) code.seen_cmp = code.pc-1 end end local function ALU_IMM(dst, a, b, op) -- Fold compile-time expressions if V[a].const and not is_proxy(V[a].const) then assert(type(V[a].const) == 'number', 'VAR '..a..' must be numeric') vset(dst, nil, const_expr[op](V[a].const, b)) -- Now we need to materialize dissected value at DST, and add it else vcopy(dst, a) local dst_reg = vreg(dst) if cdef.isptr(V[a].type) then vderef(dst_reg, dst_reg, V[a].const.__dissector) V[dst].type = V[a].const.__dissector else V[dst].type = V[a].type end emit(BPF.ALU64 + BPF[op] + BPF.K, dst_reg, 0, 0, b) end end local function ALU_REG(dst, a, b, op) -- Fold compile-time expressions if V[a].const and not (is_proxy(V[a].const) or is_proxy(V[b].const)) then assert(type(V[a].const) == 'number', 'VAR '..a..' must be numeric') assert(type(V[b].const) == 'number', 'VAR '..b..' must be numeric') if type(op) == 'string' then op = const_expr[op] end vcopy(dst, a) V[dst].const = op(V[a].const, V[b].const) else local src_reg = b and vreg(b) or 0 -- SRC is optional for unary operations if b and cdef.isptr(V[b].type) then -- We have to allocate a temporary register for dereferencing to preserve -- pointer in source variable that MUST NOT be altered reg_alloc(stackslots, 2) vderef(2, src_reg, V[b].const.__dissector) src_reg = 2 end vcopy(dst, a) -- DST may alias B, so copy must occur after we materialize B local dst_reg = vreg(dst) if cdef.isptr(V[a].type) then vderef(dst_reg, dst_reg, V[a].const.__dissector) V[dst].type = V[a].const.__dissector end emit(BPF.ALU64 + BPF[op] + BPF.X, dst_reg, src_reg, 0, 0) V[stackslots].reg = nil -- Free temporary registers end end local function ALU_IMM_NV(dst, a, b, op) -- Do DST = IMM(a) op VAR(b) where we can't invert because -- the registers are u64 but immediates are u32, so complement -- arithmetics wouldn't work vset(stackslots+1, nil, a) ALU_REG(dst, stackslots+1, b, op) end local function BUILTIN(func, ...) local builtin_export = { -- Compiler primitives (work with variable slots, emit instructions) V=V, vreg=vreg, vset=vset, vcopy=vcopy, vderef=vderef, valloc=valloc, emit=emit, reg_alloc=reg_alloc, reg_spill=reg_spill, tmpvar=stackslots, const_width=const_width, -- Extensions and helpers (use with care) LD_IMM_X = LD_IMM_X, } func(builtin_export, ...) end local function CALL(a, b, d) assert(b-1 <= 1, 'NYI: CALL with >1 return values') -- Perform either compile-time, helper, or builtin local func = V[a].const -- Gather all arguments and check if they're constant local args, const, nargs = {}, true, d - 1 for i = a+1, a+d-1 do table.insert(args, V[i].const) if not V[i].const or is_proxy(V[i].const) then const = false end end local builtin = builtins[func] if not const or nargs == 0 then if builtin and type(builtin) == 'function' then args = {a} for i = a+1, a+nargs do table.insert(args, i) end BUILTIN(builtin, unpack(args)) elseif V[a+2] and V[a+2].const then -- var OP imm ALU_IMM(a, a+1, V[a+2].const, builtin) elseif nargs <= 2 then -- var OP var ALU_REG(a, a+1, V[a+2] and a+2, builtin) else error('NYI: CALL non-builtin with 3 or more arguments') end -- Call on dissector implies slice retrieval elseif type(func) == 'table' and func.__dissector then assert(nargs >= 2, 'NYI: .slice(a, b) must have at least two arguments') assert(V[a+1].const and V[a+2].const, 'NYI: slice() arguments must be constant') local off = V[a+1].const local vtype = builtins.width_type(V[a+2].const - off) LOAD(a, a, off, vtype) -- Strict builtins cannot be expanded on compile-time elseif builtins_strict[func] and builtin then args = {a} for i = a+1, a+nargs do table.insert(args, i) end BUILTIN(builtin, unpack(args)) -- Attempt compile-time call expansion (expects all argument compile-time known) else V[a].const = func(unpack(args)) end end local function MAP_INIT(map_var, key, imm) local map = V[map_var].const vreg(map_var, 1, true, ffi.typeof('uint64_t')) -- Reserve R1 and load ptr for process-local map fd LD_IMM_X(1, BPF.PSEUDO_MAP_FD, map.fd, ffi.sizeof(V[map_var].type)) V[map_var].reg = nil -- R1 will be invalidated after CALL, forget register allocation -- Reserve R2 and load R2 = key pointer local key_size = ffi.sizeof(map.key_type) local w = const_width[key_size] or BPF.DW local pod_type = const_width[key_size] local sp = stack_top + key_size -- Must use stack below spill slots -- Store immediate value on stack reg_alloc(stackslots, 2) -- Spill anything in R2 (unnamed tmp variable) local key_base = key and V[key].const imm = imm or key_base if imm and (not key or not is_proxy(key_base)) then assert(pod_type, 'NYI: map[const K], K width must be 1/2/4/8') emit(BPF.MEM + BPF.ST + w, 10, 0, -sp, imm) -- Key is in register, spill it elseif V[key].reg and pod_type then if cdef.isptr(V[key].type) then -- There is already pointer in register, dereference before spilling emit(BPF.MEM + BPF.LDX + w, 2, V[key].reg, 0, 0) emit(BPF.MEM + BPF.STX + w, 10, 2, -sp, 0) else -- Variable in register is POD, spill it on the stack emit(BPF.MEM + BPF.STX + w, 10, V[key].reg, -sp, 0) end -- Key is spilled from register to stack elseif V[key].spill then sp = V[key].spill -- Key is already on stack, write to base-relative address elseif key_base.__base then assert(key_size == ffi.sizeof(V[key].type), 'VAR '..key..' type incompatible with BPF map key type') sp = key_base.__base else error('VAR '..key..' is neither const-expr/register/stack/spilled') end -- If [FP+K] addressing, emit it if sp then emit(BPF.ALU64 + BPF.MOV + BPF.X, 2, 10, 0, 0) emit(BPF.ALU64 + BPF.ADD + BPF.K, 2, 0, 0, -sp) end end local function MAP_GET(dst, map_var, key, imm) local map = V[map_var].const MAP_INIT(map_var, key, imm) -- Flag as pointer type and associate dissector for map value type vreg(dst, 0, true, ffi.typeof('uint8_t *')) V[dst].const = {__dissector=map.val_type} emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.map_lookup_elem) V[stackslots].reg = nil -- Free temporary registers end local function MAP_DEL(map_var, key, key_imm) -- Set R0, R1 (map fd, preempt R0) reg_alloc(stackslots, 0) -- Spill anything in R0 (unnamed tmp variable) MAP_INIT(map_var, key, key_imm) emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.map_delete_elem) V[stackslots].reg = nil -- Free temporary registers end local function MAP_SET(map_var, key, key_imm, src) local map = V[map_var].const -- Delete when setting nil if V[src].type == ffi.typeof('void') then return MAP_DEL(map_var, key, key_imm) end -- Set R0, R1 (map fd, preempt R0) reg_alloc(stackslots, 0) -- Spill anything in R0 (unnamed tmp variable) MAP_INIT(map_var, key, key_imm) reg_alloc(stackslots, 4) -- Spill anything in R4 (unnamed tmp variable) emit(BPF.ALU64 + BPF.MOV + BPF.K, 4, 0, 0, 0) -- BPF_ANY, create new element or update existing -- Reserve R3 for value pointer local val_size = ffi.sizeof(map.val_type) local w = const_width[val_size] or BPF.DW local pod_type = const_width[val_size] -- Stack pointer must be aligned to both key/value size and have enough headroom for (key, value) local sp = stack_top + ffi.sizeof(map.key_type) + val_size sp = sp + (sp % val_size) local base = V[src].const if base and not is_proxy(base) then assert(pod_type, 'NYI: MAP[K] = imm V; V width must be 1/2/4/8') emit(BPF.MEM + BPF.ST + w, 10, 0, -sp, base) -- Value is in register, spill it elseif V[src].reg and pod_type then emit(BPF.MEM + BPF.STX + w, 10, V[src].reg, -sp, 0) -- We get a pointer to spilled register on stack elseif V[src].spill then -- If variable is a pointer, we can load it to R3 directly (save "LEA") if cdef.isptr(V[src].type) then reg_fill(src, 3) emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.map_update_elem) return else sp = V[src].spill end -- Value is already on stack, write to base-relative address elseif base.__base then assert(val_size == ffi.sizeof(V[key].type), 'VAR '..key..' type incompatible with BPF map value type') sp = base.__base -- Value is constant, materialize it on stack else error('VAR '..key..' is neither const-expr/register/stack/spilled') end reg_alloc(stackslots, 3) -- Spill anything in R3 (unnamed tmp variable) emit(BPF.ALU64 + BPF.MOV + BPF.X, 3, 10, 0, 0) emit(BPF.ALU64 + BPF.ADD + BPF.K, 3, 0, 0, -sp) emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.map_update_elem) V[stackslots].reg = nil -- Free temporary registers end -- Finally - this table translates LuaJIT bytecode into code emitter actions. local BC = { -- Constants KNUM = function(a, _, c, _) -- KNUM vset(a, nil, c, ffi.typeof('int32_t')) -- TODO: only 32bit immediates are supported now end, KSHORT = function(a, _, _, d) -- KSHORT vset(a, nil, d, ffi.typeof('int16_t')) end, KPRI = function(a, _, _, d) -- KPRI -- KNIL is 0, must create a special type to identify it local vtype = (d < 1) and ffi.typeof('void') or ffi.typeof('uint8_t') vset(a, nil, (d < 2) and 0 or 1, vtype) end, KSTR = function(a, _, c, _) -- KSTR vset(a, nil, c, ffi.typeof('const char[?]')) end, MOV = function(a, _, _, d) -- MOV var, var vcopy(a, d) end, -- Comparison ops -- Note: comparisons are always followed by JMP opcode, that -- will fuse following JMP to JMP+CMP instruction in BPF -- Note: we're narrowed to integers, so operand/operator inversion is legit ISLT = function(a, _, _, d) return CMP_REG(d, a, 'JGE') end, -- (a < d) (inverted) ISGE = function(a, _, _, d) return CMP_REG(a, d, 'JGE') end, -- (a >= d) ISGT = function(a, _, _, d) return CMP_REG(a, d, 'JGT') end, -- (a > d) ISEQV = function(a, _, _, d) return CMP_REG(a, d, 'JEQ') end, -- (a == d) ISNEV = function(a, _, _, d) return CMP_REG(a, d, 'JNE') end, -- (a ~= d) ISEQS = function(a, _, c, _) return CMP_IMM(a, c, 'JEQ') end, -- (a == str(c)) ISNES = function(a, _, c, _) return CMP_IMM(a, c, 'JNE') end, -- (a ~= str(c)) ISEQN = function(a, _, c, _) return CMP_IMM(a, c, 'JEQ') end, -- (a == c) ISNEN = function(a, _, c, _) return CMP_IMM(a, c, 'JNE') end, -- (a ~= c) IST = function(_, _, _, d) return CMP_IMM(d, 0, 'JNE') end, -- (d) ISF = function(_, _, _, d) return CMP_IMM(d, 0, 'JEQ') end, -- (not d) ISEQP = function(a, _, c, _) return CMP_IMM(a, c, 'JEQ') end, -- ISEQP (a == c) -- Binary operations with RHS constants ADDVN = function(a, b, c, _) return ALU_IMM(a, b, c, 'ADD') end, SUBVN = function(a, b, c, _) return ALU_IMM(a, b, c, 'SUB') end, MULVN = function(a, b, c, _) return ALU_IMM(a, b, c, 'MUL') end, DIVVN = function(a, b, c, _) return ALU_IMM(a, b, c, 'DIV') end, MODVN = function(a, b, c, _) return ALU_IMM(a, b, c, 'MOD') end, -- Binary operations with LHS constants -- Cheat code: we're narrowed to integer arithmetic, so MUL+ADD are commutative ADDNV = function(a, b, c, _) return ALU_IMM(a, b, c, 'ADD') end, -- ADDNV MULNV = function(a, b, c, _) return ALU_IMM(a, b, c, 'MUL') end, -- MULNV SUBNV = function(a, b, c, _) return ALU_IMM_NV(a, c, b, 'SUB') end, -- SUBNV DIVNV = function(a, b, c, _) return ALU_IMM_NV(a, c, b, 'DIV') end, -- DIVNV -- Binary operations between registers ADDVV = function(a, b, _, d) return ALU_REG(a, b, d, 'ADD') end, SUBVV = function(a, b, _, d) return ALU_REG(a, b, d, 'SUB') end, MULVV = function(a, b, _, d) return ALU_REG(a, b, d, 'MUL') end, DIVVV = function(a, b, _, d) return ALU_REG(a, b, d, 'DIV') end, MODVV = function(a, b, _, d) return ALU_REG(a, b, d, 'MOD') end, -- Strings CAT = function(a, b, _, d) -- CAT A = B ~ D assert(V[b].const and V[d].const, 'NYI: CAT only works on compile-time expressions') assert(type(V[b].const) == 'string' and type(V[d].const) == 'string', 'NYI: CAT only works on compile-time strings') vset(a, nil, V[b].const .. V[d].const) end, -- Tables GGET = function (a, _, c, _) -- GGET (A = GLOBAL[c]) if env[c] ~= nil then vset(a, nil, env[c]) else error(string.format("undefined global '%s'", c)) end end, UGET = function (a, _, c, _) -- UGET (A = UPVALUE[c]) if env[c] ~= nil then vset(a, nil, env[c]) else error(string.format("undefined upvalue '%s'", c)) end end, TGETB = function (a, b, _, d) -- TGETB (A = B[D]) if a ~= b then vset(a) end local base = V[b].const if base.__map then -- BPF map read (constant) MAP_GET(a, b, nil, d) else LOAD(a, b, d, ffi.typeof('uint8_t')) end end, TSETB = function (a, b, _, d) -- TSETB (B[D] = A) if V[b].const.__map then -- BPF map read (constant) return MAP_SET(b, nil, d, a) -- D is literal elseif V[b].const and V[b].const and V[a].const then V[b].const[V[d].const] = V[a].const else error('NYI: B[D] = A, where B is not Lua table or BPF map') end end, TSETV = function (a, b, _, d) -- TSETV (B[D] = A) if V[b].const.__map then -- BPF map read (constant) return MAP_SET(b, d, nil, a) -- D is variable elseif V[b].const and V[d].const and V[a].const then V[b].const[V[d].const] = V[a].const else error('NYI: B[D] = A, where B is not Lua table or BPF map') end end, TSETS = function (a, b, c, _) -- TSETS (B[C] = A) assert(V[b] and V[b].const, 'NYI: B[D] where B is not Lua table or BPF map') local base = V[b].const if base.__dissector then local ofs,bpos = ffi.offsetof(base.__dissector, c) assert(not bpos, 'NYI: B[C] = A, where C is a bitfield') local w = sizeofattr(base.__dissector, c) -- TODO: support vectorized moves larger than register width assert(const_width[w], 'B[C] = A, sizeof(A) must be 1/2/4/8') local src_reg = vreg(a) -- If source is a pointer, we must dereference it first if cdef.isptr(V[a].type) then local tmp_reg = reg_alloc(stackslots, 1) -- Clone variable in tmp register emit(BPF.ALU64 + BPF.MOV + BPF.X, tmp_reg, src_reg, 0, 0) vderef(tmp_reg, tmp_reg, V[a].const.__dissector) src_reg = tmp_reg -- Materialize and dereference it -- Source is a value on stack, we must load it first elseif V[a].const and V[a].const.__base > 0 then emit(BPF.MEM + BPF.LDX + const_width[w], src_reg, 10, -V[a].const.__base, 0) V[a].type = V[a].const.__dissector V[a].const = nil -- Value is dereferenced end -- If the table is not on stack, it must be checked for NULL if not base.__base then emit(BPF.JMP + BPF.JEQ + BPF.K, V[b].reg, 0, 1, 0) -- if (map[x] != NULL) emit(BPF.MEM + BPF.STX + const_width[w], V[b].reg, src_reg, ofs, 0) else -- Table is already on stack, write to base-relative address emit(BPF.MEM + BPF.STX + const_width[w], 10, src_reg, -base.__base + ofs, 0) end elseif V[a].const then base[c] = V[a].const else error('NYI: B[C] = A, where B is not Lua table or BPF map') end end, TGETV = function (a, b, _, d) -- TGETV (A = B[D]) assert(V[b] and V[b].const, 'NYI: B[D] where B is not Lua table or BPF map') if a ~= b then vset(a) end if V[b].const.__map then -- BPF map read MAP_GET(a, b, d) elseif V[b].const == env.pkt then -- Raw packet, no offset LD_FIELD(a, d, 1, V[d].const) else V[a].const = V[b].const[V[d].const] end end, TGETS = function (a, b, c, _) -- TGETS (A = B[C]) assert(V[b] and V[b].const, 'NYI: B[C] where C is string and B not Lua table or BPF map') local base = V[b].const if type(base) == 'table' and base.__dissector then local ofs,bpos,bsize = ffi.offsetof(base.__dissector, c) -- Resolve table key using metatable if not ofs and type(base.__dissector[c]) == 'string' then c = base.__dissector[c] ofs,bpos,bsize = ffi.offsetof(base.__dissector, c) end if not ofs and proto[c] then -- Load new dissector on given offset BUILTIN(proto[c], a, b, c) else assert(ofs, tostring(base.__dissector)..'.'..c..' attribute not exists') if a ~= b then vset(a) end -- Dissected value is probably not constant anymore local new_const = nil -- Simple register load, get absolute offset or R-relative local w, atype = sizeofattr(base.__dissector, c) if base.__base == true then -- R-relative addressing local dst_reg = vreg(a, nil, true) assert(const_width[w], 'NYI: sizeof('..tostring(base.__dissector)..'.'..c..') not 1/2/4/8 bytes') emit(BPF.MEM + BPF.LDX + const_width[w], dst_reg, V[b].reg, ofs, 0) elseif not base.source and base.__base and base.__base > 0 then -- [FP+K] addressing if cdef.isptr(atype) then -- If the member is pointer type, update base pointer with offset new_const = {__base = base.__base-ofs} else local dst_reg = vreg(a, nil, true) emit(BPF.MEM + BPF.LDX + const_width[w], dst_reg, 10, -base.__base+ofs, 0) end elseif base.off then -- Absolute address to payload LD_ABS(a, ofs + base.off, w) elseif base.source == 'probe' then -- Indirect read using probe BUILTIN(builtins[builtins.probe_read], nil, a, b, atype, ofs) V[a].source = V[b].source -- Builtin handles everything return else -- Indirect address to payload LD_IND(a, b, w, ofs) end -- Bitfield, must be further narrowed with a bitmask/shift if bpos then local mask = 0 for i=bpos+1,bpos+bsize do mask = bit.bor(mask, bit.lshift(1, w*8-i)) end emit(BPF.ALU64 + BPF.AND + BPF.K, vreg(a), 0, 0, mask) -- Free optimization: single-bit values need just boolean result if bsize > 1 then local shift = w*8-bsize-bpos if shift > 0 then emit(BPF.ALU64 + BPF.RSH + BPF.K, vreg(a), 0, 0, shift) end end end V[a].type = atype V[a].const = new_const V[a].source = V[b].source end else V[a].const = base[c] end end, -- Loops and branches CALLM = function (a, b, _, d) -- A = A(A+1, ..., A+D+MULTRES) -- NYI: Support single result only CALL(a, b, d+2) end, CALL = function (a, b, _, d) -- A = A(A+1, ..., A+D-1) CALL(a, b, d) end, JMP = function (a, _, c, d) -- JMP -- Discard unused slots after jump for i, _ in pairs(V) do if i >= a then V[i] = {} end end local val = code.fixup[c] or {} if code.seen_cmp and code.seen_cmp ~= ALWAYS then if code.seen_cmp ~= NEVER then -- Do not emit the jump or fixup -- Store previous CMP insn for reemitting after compensation code local jmpi = ffi.new('struct bpf_insn', code.insn[code.pc-1]) code.pc = code.pc - 1 -- First branch point, emit compensation code local Vcomp = Vstate[c] if not Vcomp then for i,v in pairs(V) do if not v.reg and v.const and not is_proxy(v.const) then vreg(i, 0) -- Load to TMP register (not saved) end if v.reg and v.reg <= 5 then reg_spill(i) -- Spill caller-saved registers end end -- Record variable state Vstate[c] = V V = {} for i,v in pairs(Vstate[c]) do V[i] = {} for k,e in pairs(v) do V[i][k] = e end end -- Variable state already set, emit specific compensation code else bb_end(Vcomp) end -- Reemit CMP insn emit(jmpi.code, jmpi.dst_reg, jmpi.src_reg, jmpi.off, jmpi.imm) -- Fuse JMP into previous CMP opcode, mark JMP target for fixup -- as we don't knot the relative offset in generated code yet table.insert(val, code.pc-1) code.fixup[c] = val end code.seen_cmp = nil else emit(BPF.JMP + BPF.JEQ + BPF.X, 6, 6, 0xffff, 0) -- Always true table.insert(val, code.pc-1) -- Fixup JMP target code.reachable = false -- Code following the JMP is not reachable code.fixup[c] = val end end, RET1 = function (a, _, _, _) -- RET1 if V[a].reg ~= 0 then vreg(a, 0) end emit(BPF.JMP + BPF.EXIT, 0, 0, 0, 0) -- Free optimisation: spilled variable will not be filled again for _,v in pairs(V) do if v.reg == 0 then v.reg = nil end end code.reachable = false end, RET0 = function (_, _, _, _) -- RET0 emit(BPF.ALU64 + BPF.MOV + BPF.K, 0, 0, 0, 0) emit(BPF.JMP + BPF.EXIT, 0, 0, 0, 0) code.reachable = false end, compile = function () return code end } -- Always initialize R6 with R1 context emit(BPF.ALU64 + BPF.MOV + BPF.X, 6, 1, 0, 0) -- Register R6 as context variable (first argument) if params and params > 0 then vset(0, 6, param_types[1] or proto.skb) V[0].source = V[0].const.source -- Propagate source annotation from typeinfo end -- Register tmpvars vset(stackslots) vset(stackslots+1) return setmetatable(BC, { __index = function (t, k, v) if type(k) == 'number' then local op_str = string.sub(require('jit.vmdef').bcnames, 6*k+1, 6*k+6) error(string.format("NYI: opcode '0x%02x' (%-04s)", k, op_str)) end end, __call = function (t, op, a, b, c, d) code.bc_pc = code.bc_pc + 1 -- Exitting BB straight through, emit compensation code if Vstate[code.bc_pc] and code.reachable then bb_end(Vstate[code.bc_pc]) end -- Perform fixup of jump targets -- We need to do this because the number of consumed and emited -- bytecode instructions is different local fixup = code.fixup[code.bc_pc] if fixup ~= nil then -- Patch JMP source insn with relative offset for _,pc in ipairs(fixup) do code.insn[pc].off = code.pc - 1 - pc end code.fixup[code.bc_pc] = nil code.reachable = true end -- Execute if code.reachable then assert(t[op], string.format('NYI: instruction %s, parameters: %s,%s,%s,%s', op,a,b,c,d)) return t[op](a, b, c, d) end end, }) end -- Emitted code dump local function dump_mem(cls, ins) local mode = bit.band(ins.code, 0xe0) if mode == BPF.XADD then cls = 5 end -- The only mode local op_1 = {'LD', 'LDX', 'ST', 'STX', '', 'XADD'} local op_2 = {[0]='W', [8]='H', [16]='B', [24]='DW'} local name = op_1[cls+1] .. op_2[bit.band(ins.code, 0x18)] local off = tonumber(ffi.cast('int16_t', ins.off)) -- Reinterpret as signed local dst = cls < 2 and 'R'..ins.dst_reg or string.format('[R%d%+d]', ins.dst_reg, off) local src = cls % 2 == 0 and '#'..ins.imm or 'R'..ins.src_reg if cls == BPF.LDX then src = string.format('[R%d%+d]', ins.src_reg, off) end if mode == BPF.ABS then src = string.format('[%d]', ins.imm) end if mode == BPF.IND then src = string.format('[R%d%+d]', ins.src_reg, ins.imm) end return string.format('%s\t%s\t%s', name, dst, src) end local function dump_alu(cls, ins, pc) local alu = {'ADD', 'SUB', 'MUL', 'DIV', 'OR', 'AND', 'LSH', 'RSH', 'NEG', 'MOD', 'XOR', 'MOV', 'ARSH', 'END' } local jmp = {'JA', 'JEQ', 'JGT', 'JGE', 'JSET', 'JNE', 'JSGT', 'JSGE', 'CALL', 'EXIT'} local helper = {'unspec', 'map_lookup_elem', 'map_update_elem', 'map_delete_elem', 'probe_read', 'ktime_get_ns', 'trace_printk', 'get_prandom_u32', 'get_smp_processor_id', 'skb_store_bytes', 'l3_csum_replace', 'l4_csum_replace', 'tail_call', 'clone_redirect', 'get_current_pid_tgid', 'get_current_uid_gid', 'get_current_comm', 'get_cgroup_classid', 'skb_vlan_push', 'skb_vlan_pop', 'skb_get_tunnel_key', 'skb_set_tunnel_key', 'perf_event_read', 'redirect', 'get_route_realm', 'perf_event_output', 'skb_load_bytes'} local op = 0 for i = 0,13 do if 0x10 * i == bit.band(ins.code, 0xf0) then op = i + 1 break end end local name = (cls == 5) and jmp[op] or alu[op] local src = (bit.band(ins.code, 0x08) == BPF.X) and 'R'..ins.src_reg or '#'..ins.imm local target = (cls == 5 and op < 9) and string.format('\t=> %04d', pc + ins.off + 1) or '' if cls == 5 and op == 9 then target = string.format('\t; %s', helper[ins.imm + 1] or tostring(ins.imm)) end return string.format('%s\t%s\t%s%s', name, 'R'..ins.dst_reg, src, target) end local function dump(code) if not code then return end print(string.format('-- BPF %s:0-%u', code.insn, code.pc)) local cls_map = { [0] = dump_mem, [1] = dump_mem, [2] = dump_mem, [3] = dump_mem, [4] = dump_alu, [5] = dump_alu, [7] = dump_alu, } for i = 0, code.pc - 1 do local ins = code.insn[i] local cls = bit.band(ins.code, 0x07) print(string.format('%04u\t%s', i, cls_map[cls](cls, ins, i))) end end local function compile(prog, params) -- Create code emitter sandbox, include caller locals local env = { pkt=proto.pkt, BPF=BPF } -- Include upvalues up to 4 nested scopes back -- the narrower scope overrides broader scope for k = 5, 2, -1 do local i = 1 while true do local ok, n, v = pcall(debug.getlocal, k, i) if not ok or not n then break end env[n] = v i = i + 1 end end setmetatable(env, { __index = function (_, k) return proto[k] or builtins[k] or _G[k] end }) -- Create code emitter and compile LuaJIT bytecode if type(prog) == 'string' then prog = loadstring(prog) end -- Create error handler to print traceback local funci, pc = bytecode.funcinfo(prog), 0 local E = create_emitter(env, funci.stackslots, funci.params, params or {}) local on_err = function (e) funci = bytecode.funcinfo(prog, pc) local from, to = 0, 0 for _ = 1, funci.currentline do from = to to = string.find(funci.source, '\n', from+1, true) or 0 end print(funci.loc..':'..string.sub(funci.source, from+1, to-1)) print('error: '..e) print(debug.traceback()) end for _,op,a,b,c,d in bytecode.decoder(prog) do local ok, res, err = xpcall(E,on_err,op,a,b,c,d) if not ok then return nil, res, err end end return E:compile() end -- BPF map interface local bpf_map_mt = { __gc = function (map) S.close(map.fd) end, __len = function(map) return map.max_entries end, __index = function (map, k) if type(k) == 'string' then -- Return iterator if k == 'pairs' then return function(t, key) -- Get next key local next_key = ffi.new(ffi.typeof(t.key)) local cur_key if key then cur_key = t.key t.key[0] = key else cur_key = ffi.new(ffi.typeof(t.key)) end local ok, err = S.bpf_map_op(S.c.BPF_CMD.MAP_GET_NEXT_KEY, map.fd, cur_key, next_key) if not ok then return nil end -- Get next value assert(S.bpf_map_op(S.c.BPF_CMD.MAP_LOOKUP_ELEM, map.fd, next_key, map.val)) return next_key[0], map.val[0] end, map, nil -- Read for perf event map elseif k == 'reader' then return function (pmap, pid, cpu, event_type) -- Caller must either specify PID or CPU if not pid or pid < 0 then assert((cpu and cpu >= 0), 'NYI: creating composed reader for all CPUs') pid = -1 end -- Create BPF output reader local pe = S.t.perf_event_attr1() pe[0].type = 'software' pe[0].config = 'sw_bpf_output' pe[0].sample_type = 'raw' pe[0].sample_period = 1 pe[0].wakeup_events = 1 local reader, err = S.t.perf_reader(S.perf_event_open(pe, pid, cpu or -1)) if not reader then return nil, tostring(err) end -- Register event reader fd in BPF map assert(cpu < pmap.max_entries, string.format('BPF map smaller than read CPU %d', cpu)) pmap[cpu] = reader.fd -- Open memory map and start reading local ok, err = reader:start() assert(ok, tostring(err)) ok, err = reader:mmap() assert(ok, tostring(err)) return cdef.event_reader(reader, event_type) end -- Signalise this is a map type end return k == '__map' end -- Retrieve key map.key[0] = k local ok, err = S.bpf_map_op(S.c.BPF_CMD.MAP_LOOKUP_ELEM, map.fd, map.key, map.val) if not ok then return nil, err end return ffi.new(map.val_type, map.val[0]) end, __newindex = function (map, k, v) map.key[0] = k if v == nil then return S.bpf_map_op(map.fd, S.c.BPF_CMD.MAP_DELETE_ELEM, map.key, nil) end map.val[0] = v return S.bpf_map_op(S.c.BPF_CMD.MAP_UPDATE_ELEM, map.fd, map.key, map.val) end, } -- Linux tracing interface local function trace_check_enabled(path) path = path or '/sys/kernel/debug/tracing' if S.statfs(path) then return true end return nil, 'debugfs not accessible: "mount -t debugfs nodev /sys/kernel/debug"? missing sudo?' end -- Tracepoint interface local tracepoint_mt = { __index = { bpf = function (t, prog) if type(prog) ~= 'table' then -- Create protocol parser with source=probe prog = compile(prog, {proto.type(t.type, {source='probe'})}) end -- Load the BPF program local prog_fd, err, log = S.bpf_prog_load(S.c.BPF_PROG.TRACEPOINT, prog.insn, prog.pc) assert(prog_fd, tostring(err)..': '..tostring(log)) -- Open tracepoint and attach t.reader:setbpf(prog_fd:getfd()) table.insert(t.progs, prog_fd) return prog_fd end, } } -- Open tracepoint local function tracepoint_open(path, pid, cpu, group_fd) -- Open tracepoint and compile tracepoint type local tp = assert(S.perf_tracepoint('/sys/kernel/debug/tracing/events/'..path)) local tp_type = assert(cdef.tracepoint_type(path)) -- Open tracepoint reader and create interface local reader = assert(S.perf_attach_tracepoint(tp, pid, cpu, group_fd)) return setmetatable({tp=tp,type=tp_type,reader=reader,progs={}}, tracepoint_mt) end local function trace_bpf(ptype, pname, pdef, retprobe, prog, pid, cpu, group_fd) -- Load BPF program if type(prog) ~= 'table' then prog = compile(prog, {proto.pt_regs}) end local prog_fd, err, log = S.bpf_prog_load(S.c.BPF_PROG.KPROBE, prog.insn, prog.pc) assert(prog_fd, tostring(err)..': '..tostring(log)) -- Open tracepoint and attach local tp, err = S.perf_probe(ptype, pname, pdef, retprobe) if not tp then prog_fd:close() return nil, tostring(err) end local reader, err = S.perf_attach_tracepoint(tp, pid, cpu, group_fd, {sample_type='raw, callchain'}) if not reader then prog_fd:close() S.perf_probe(ptype, pname, false) return nil, tostring(err) end local ok, err = reader:setbpf(prog_fd:getfd()) if not ok then prog_fd:close() reader:close() S.perf_probe(ptype, pname, false) return nil, tostring(err)..' (kernel version should be at least 4.1)' end -- Create GC closure for reader to close BPF program -- and detach probe in correct order ffi.gc(reader, function () prog_fd:close() reader:close() S.perf_probe(ptype, pname, false) end) return {reader=reader, prog=prog_fd, probe=pname, probe_type=ptype} end -- Module interface return setmetatable({ new = create_emitter, dump = dump, maps = {}, map = function (type, max_entries, key_ctype, val_ctype) if not key_ctype then key_ctype = ffi.typeof('uint32_t') end if not val_ctype then val_ctype = ffi.typeof('uint32_t') end if not max_entries then max_entries = 4096 end -- Special case for BPF_MAP_STACK_TRACE if S.c.BPF_MAP[type] == S.c.BPF_MAP.STACK_TRACE then key_ctype = ffi.typeof('int32_t') val_ctype = ffi.typeof('struct bpf_stacktrace') end local fd, err = S.bpf_map_create(S.c.BPF_MAP[type], ffi.sizeof(key_ctype), ffi.sizeof(val_ctype), max_entries) if not fd then return nil, tostring(err) end local map = setmetatable({ max_entries = max_entries, key = ffi.new(ffi.typeof('$ [1]', key_ctype)), val = ffi.new(ffi.typeof('$ [1]', val_ctype)), map_type = S.c.BPF_MAP[type], key_type = key_ctype, val_type = val_ctype, fd = fd:nogc():getfd(), }, bpf_map_mt) return map end, socket = function (sock, prog) -- Expect socket type, if sock is string then assume it's -- an interface name (e.g. 'lo'), if it's a number then typecast it as a socket local ok, err if type(sock) == 'string' then local iface = assert(S.nl.getlink())[sock] assert(iface, sock..' is not interface name') sock, err = S.socket('packet', 'raw') assert(sock, tostring(err)) ok, err = sock:bind(S.t.sockaddr_ll({protocol='all', ifindex=iface.index})) assert(ok, tostring(err)) elseif type(sock) == 'number' then sock = assert(S.t.socket(sock)) end -- Load program and attach it to socket if type(prog) ~= 'table' then prog = compile(prog, {proto.skb}) end local prog_fd, err, log = S.bpf_prog_load(S.c.BPF_PROG.SOCKET_FILTER, prog.insn, prog.pc) assert(prog_fd, tostring(err)..': '..tostring(log)) assert(sock:setsockopt('socket', 'attach_bpf', prog_fd:getfd())) return prog_fd, err end, tracepoint = function(tp, prog, pid, cpu, group_fd) assert(trace_check_enabled()) -- Return tracepoint instance if no program specified -- this allows free specialisation of arg0 to tracepoint type local probe = tracepoint_open(tp, pid, cpu, group_fd) -- Load the BPF program if prog then probe:bpf(prog) end return probe end, kprobe = function(tp, prog, retprobe, pid, cpu, group_fd) assert(trace_check_enabled()) -- Open tracepoint and attach local pname, pdef = tp:match('([^:]+):(.+)') return trace_bpf('kprobe', pname, pdef, retprobe, prog, pid, cpu, group_fd) end, uprobe = function(tp, prog, retprobe, pid, cpu, group_fd) assert(trace_check_enabled()) -- Translate symbol to address local obj, sym_want = tp:match('([^:]+):(.+)') if not S.statfs(obj) then return nil, S.t.error(S.c.E.NOENT) end -- Resolve Elf object (no support for anything else) local elf = require('bpf.elf').open(obj) local sym = elf:resolve(sym_want) if not sym then return nil, 'no such symbol' end sym = sym.st_value - elf:loadaddr() local sym_addr = string.format('%x%04x', tonumber(bit.rshift(sym, 32)), tonumber(ffi.cast('uint32_t', sym))) -- Convert it to expected uprobe format local pname = string.format('%s_%s', obj:gsub('.*/', ''), sym_addr) local pdef = obj..':0x'..sym_addr return trace_bpf('uprobe', pname, pdef, retprobe, prog, pid, cpu, group_fd) end, tracelog = function(path) assert(trace_check_enabled()) path = path or '/sys/kernel/debug/tracing/trace_pipe' return io.open(path, 'r') end, ntoh = builtins.ntoh, hton = builtins.hton, }, { __call = function (t, prog) return compile(prog) end, }) bpfcc-0.2.0+git0.02884a026/src/lua/bpf/builtins.lua000066400000000000000000000372031305314114400211560ustar00rootroot00000000000000--[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require('ffi') local bit = require('bit') local cdef = require('bpf.cdef') local BPF, HELPER = ffi.typeof('struct bpf'), ffi.typeof('struct bpf_func_id') local const_width = { [1] = BPF.B, [2] = BPF.H, [4] = BPF.W, [8] = BPF.DW, } local const_width_type = { [1] = ffi.typeof('uint8_t'), [2] = ffi.typeof('uint16_t'), [4] = ffi.typeof('uint32_t'), [8] = ffi.typeof('uint64_t'), } -- Built-ins that will be translated into BPF instructions -- i.e. bit.bor(0xf0, 0x0f) becomes {'alu64, or, k', reg(0xf0), reg(0x0f), 0, 0} local builtins = { [bit.lshift] = 'LSH', [bit.rshift] = 'RSH', [bit.band] = 'AND', [bit.bnot] = 'NEG', [bit.bor] = 'OR', [bit.bxor] = 'XOR', [bit.arshift] = 'ARSH', -- Extensions and intrinsics } local function width_type(w) -- Note: ffi.typeof doesn't accept '?' as template return const_width_type[w] or ffi.typeof(string.format('uint8_t [%d]', w)) end builtins.width_type = width_type -- Byte-order conversions for little endian local function ntoh(x, w) if w then x = ffi.cast(const_width_type[w/8], x) end return bit.bswap(x) end local function hton(x, w) return ntoh(x, w) end builtins.ntoh = ntoh builtins.hton = hton builtins[ntoh] = function (e, dst, a, w) -- This is trickery, but TO_LE means cpu_to_le(), -- and we want exactly the opposite as network is always 'be' w = w or ffi.sizeof(e.V[a].type)*8 if w == 8 then return end -- NOOP assert(w <= 64, 'NYI: hton(a[, width]) - operand larger than register width') -- Allocate registers and execute e.vcopy(dst, a) e.emit(BPF.ALU + BPF.END + BPF.TO_BE, e.vreg(dst), 0, 0, w) end builtins[hton] = function (e, dst, a, w) w = w or ffi.sizeof(e.V[a].type)*8 if w == 8 then return end -- NOOP assert(w <= 64, 'NYI: hton(a[, width]) - operand larger than register width') -- Allocate registers and execute e.vcopy(dst, a) e.emit(BPF.ALU + BPF.END + BPF.TO_LE, e.vreg(dst), 0, 0, w) end -- Byte-order conversions for big endian are no-ops if ffi.abi('be') then ntoh = function (x, w) return w and ffi.cast(const_width_type[w/8], x) or x end hton = ntoh builtins[ntoh] = function(a, b, w) return end builtins[hton] = function(a, b, w) return end end -- Other built-ins local function xadd(a, b) error('NYI') end builtins.xadd = xadd builtins[xadd] = function (e, dst, a, b, off) assert(e.V[a].const.__dissector, 'xadd(a, b) called on non-pointer') local w = ffi.sizeof(e.V[a].const.__dissector) assert(w == 4 or w == 8, 'NYI: xadd() - 1 and 2 byte atomic increments are not supported') -- Allocate registers and execute e.vcopy(dst, a) local src_reg = e.vreg(b) local dst_reg = e.vreg(dst) e.emit(BPF.JMP + BPF.JEQ + BPF.K, dst_reg, 0, 1, 0) -- if (dst != NULL) e.emit(BPF.XADD + BPF.STX + const_width[w], dst_reg, src_reg, off or 0, 0) end local function probe_read() error('NYI') end builtins.probe_read = probe_read builtins[probe_read] = function (e, ret, dst, src, vtype, ofs) e.reg_alloc(e.tmpvar, 1) -- Load stack pointer to dst, since only load to stack memory is supported -- we have to use allocated stack memory or create a new allocation and convert -- to pointer type e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 1, 10, 0, 0) if not e.V[dst].const or not e.V[dst].const.__base > 0 then builtins[ffi.new](e, dst, vtype) -- Allocate stack memory end e.emit(BPF.ALU64 + BPF.ADD + BPF.K, 1, 0, 0, -e.V[dst].const.__base) -- Set stack memory maximum size bound e.reg_alloc(e.tmpvar, 2) if not vtype then vtype = cdef.typename(e.V[dst].type) -- Dereference pointer type to pointed type for size calculation if vtype:sub(-1) == '*' then vtype = vtype:sub(0, -2) end end local w = ffi.sizeof(vtype) e.emit(BPF.ALU64 + BPF.MOV + BPF.K, 2, 0, 0, w) -- Set source pointer if e.V[src].reg then e.reg_alloc(e.tmpvar, 3) -- Copy from original register e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 3, e.V[src].reg, 0, 0) else local src_reg = e.vreg(src, 3) e.reg_spill(src) -- Spill to avoid overwriting end if ofs and ofs > 0 then e.emit(BPF.ALU64 + BPF.ADD + BPF.K, 3, 0, 0, ofs) end -- Call probe read helper ret = ret or e.tmpvar e.vset(ret) e.vreg(ret, 0, true, ffi.typeof('int32_t')) e.emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.probe_read) e.V[e.tmpvar].reg = nil -- Free temporary registers end builtins[ffi.cast] = function (e, dst, ct, x) assert(e.V[ct].const, 'ffi.cast(ctype, x) called with bad ctype') e.vcopy(dst, x) if not e.V[x].const then e.V[dst].type = ffi.typeof(e.V[ct].const) else e.V[dst].const.__dissector = ffi.typeof(e.V[ct].const) end -- Specific types also encode source of the data -- This is because BPF has different helpers for reading -- different data sources, so variables must track origins. -- struct pt_regs - source of the data is probe -- struct skb - source of the data is socket buffer -- struct X - source of the data is probe/tracepoint if ffi.typeof(e.V[ct].const) == ffi.typeof('struct pt_regs') then e.V[dst].source = 'probe' end end builtins[ffi.new] = function (e, dst, ct, x) if type(ct) == 'number' then ct = ffi.typeof(e.V[ct].const) -- Get ctype from variable end assert(not x, 'NYI: ffi.new(ctype, ...) - initializer is not supported') assert(not cdef.isptr(ct, true), 'NYI: ffi.new(ctype, ...) - ctype MUST NOT be a pointer') e.vset(dst, nil, ct) e.V[dst].const = {__base = e.valloc(ffi.sizeof(ct), true), __dissector = ct} end builtins[ffi.copy] = function (e,ret, dst, src) assert(cdef.isptr(e.V[dst].type), 'ffi.copy(dst, src) - dst MUST be a pointer type') assert(cdef.isptr(e.V[src].type), 'ffi.copy(dst, src) - src MUST be a pointer type') -- Specific types also encode source of the data -- struct pt_regs - source of the data is probe -- struct skb - source of the data is socket buffer if e.V[src].source == 'probe' then e.reg_alloc(e.tmpvar, 1) -- Load stack pointer to dst, since only load to stack memory is supported -- we have to either use spilled variable or allocated stack memory offset e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 1, 10, 0, 0) if e.V[dst].spill then e.emit(BPF.ALU64 + BPF.ADD + BPF.K, 1, 0, 0, -e.V[dst].spill) elseif e.V[dst].const.__base then e.emit(BPF.ALU64 + BPF.ADD + BPF.K, 1, 0, 0, -e.V[dst].const.__base) else error('ffi.copy(dst, src) - can\'t get stack offset of dst') end -- Set stack memory maximum size bound local dst_tname = cdef.typename(e.V[dst].type) if dst_tname:sub(-1) == '*' then dst_tname = dst_tname:sub(0, -2) end e.reg_alloc(e.tmpvar, 2) e.emit(BPF.ALU64 + BPF.MOV + BPF.K, 2, 0, 0, ffi.sizeof(dst_tname)) -- Set source pointer if e.V[src].reg then e.reg_alloc(e.tmpvar, 3) -- Copy from original register e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 3, e.V[src].reg, 0, 0) else local src_reg = e.vreg(src, 3) e.reg_spill(src) -- Spill to avoid overwriting end -- Call probe read helper e.vset(ret) e.vreg(ret, 0, true, ffi.typeof('int32_t')) e.emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.probe_read) e.V[e.tmpvar].reg = nil -- Free temporary registers elseif e.V[src].const and e.V[src].const.__map then error('NYI: ffi.copy(dst, src) - src is backed by BPF map') elseif e.V[src].const and e.V[src].const.__dissector then error('NYI: ffi.copy(dst, src) - src is backed by socket buffer') else -- TODO: identify cheap register move -- TODO: identify copy to/from stack error('NYI: ffi.copy(dst, src) - src is neither BPF map/socket buffer or probe') end end -- print(format, ...) builtin changes semantics from Lua print(...) -- the first parameter has to be format and only reduced set of conversion specificers -- is allowed: %d %u %x %ld %lu %lx %lld %llu %llx %p %s builtins[print] = function (e, ret, fmt, a1, a2, a3) -- Load format string and length e.reg_alloc(e.V[e.tmpvar], 1) e.reg_alloc(e.V[e.tmpvar+1], 1) if type(e.V[fmt].const) == 'string' then local src = e.V[fmt].const local len = #src + 1 local dst = e.valloc(len, src) -- TODO: this is materialize step e.V[fmt].const = {__base=dst} e.V[fmt].type = ffi.typeof('char ['..len..']') elseif e.V[fmt].const.__base then -- NOP else error('NYI: print(fmt, ...) - format variable is not literal/stack memory') end -- Prepare helper call e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 1, 10, 0, 0) e.emit(BPF.ALU64 + BPF.ADD + BPF.K, 1, 0, 0, -e.V[fmt].const.__base) e.emit(BPF.ALU64 + BPF.MOV + BPF.K, 2, 0, 0, ffi.sizeof(e.V[fmt].type)) if a1 then local args = {a1, a2, a3} assert(#args <= 3, 'print(fmt, ...) - maximum of 3 arguments supported') for i, arg in ipairs(args) do e.vcopy(e.tmpvar, arg) -- Copy variable e.vreg(e.tmpvar, 3+i-1) -- Materialize it in arg register end end -- Call helper e.vset(ret) e.vreg(ret, 0, true, ffi.typeof('int32_t')) -- Return is integer e.emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.trace_printk) e.V[e.tmpvar].reg = nil -- Free temporary registers end -- Implements bpf_perf_event_output(ctx, map, flags, var, vlen) on perf event map local function perf_submit(e, dst, map_var, src) -- Set R2 = map fd (indirect load) local map = e.V[map_var].const e.vcopy(e.tmpvar, map_var) e.vreg(e.tmpvar, 2, true, ffi.typeof('uint64_t')) e.LD_IMM_X(2, BPF.PSEUDO_MAP_FD, map.fd, ffi.sizeof('uint64_t')) -- Set R1 = ctx e.reg_alloc(e.tmpvar, 1) -- Spill anything in R1 (unnamed tmp variable) e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 1, 6, 0, 0) -- CTX is always in R6, copy -- Set R3 = flags e.vset(e.tmpvar, nil, 0) -- BPF_F_CURRENT_CPU e.vreg(e.tmpvar, 3, false, ffi.typeof('uint64_t')) -- Set R4 = pointer to src on stack assert(e.V[src].const.__base, 'NYI: submit(map, var) - variable is not on stack') e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 4, 10, 0, 0) e.emit(BPF.ALU64 + BPF.ADD + BPF.K, 4, 0, 0, -e.V[src].const.__base) -- Set R5 = src length e.emit(BPF.ALU64 + BPF.MOV + BPF.K, 5, 0, 0, ffi.sizeof(e.V[src].type)) -- Set R0 = ret and call e.vset(dst) e.vreg(dst, 0, true, ffi.typeof('int32_t')) -- Return is integer e.emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.perf_event_output) e.V[e.tmpvar].reg = nil -- Free temporary registers end -- Implements bpf_get_stack_id() local function stack_id(e, ret, map_var, key) -- Set R2 = map fd (indirect load) local map = e.V[map_var].const e.vcopy(e.tmpvar, map_var) e.vreg(e.tmpvar, 2, true, ffi.typeof('uint64_t')) e.LD_IMM_X(2, BPF.PSEUDO_MAP_FD, map.fd, ffi.sizeof('uint64_t')) -- Set R1 = ctx e.reg_alloc(e.tmpvar, 1) -- Spill anything in R1 (unnamed tmp variable) e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 1, 6, 0, 0) -- CTX is always in R6, copy -- Load flags in R2 (immediate value or key) local imm = e.V[key].const assert(tonumber(imm), 'NYI: stack_id(map, var), var must be constant number') e.reg_alloc(e.tmpvar, 3) -- Spill anything in R2 (unnamed tmp variable) e.LD_IMM_X(3, 0, imm, 8) -- Return R0 as signed integer e.vset(ret) e.vreg(ret, 0, true, ffi.typeof('int32_t')) e.emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.get_stackid) e.V[e.tmpvar].reg = nil -- Free temporary registers end -- table.insert(table, value) keeps semantics with the exception of BPF maps -- map `perf_event` -> submit inserted value builtins[table.insert] = function (e, dst, map_var, value) assert(e.V[map_var].const.__map, 'NYI: table.insert() supported only on BPF maps') return perf_submit(e, dst, map_var, value) end -- bpf_get_current_comm(buffer) - write current process name to byte buffer local function comm() error('NYI') end builtins[comm] = function (e, ret, dst) -- Set R1 = buffer assert(e.V[dst].const.__base, 'NYI: comm(buffer) - buffer variable is not on stack') e.reg_alloc(e.tmpvar, 1) -- Spill e.emit(BPF.ALU64 + BPF.MOV + BPF.X, 1, 10, 0, 0) e.emit(BPF.ALU64 + BPF.ADD + BPF.K, 1, 0, 0, -e.V[dst].const.__base) -- Set R2 = length e.reg_alloc(e.tmpvar, 2) -- Spill e.emit(BPF.ALU64 + BPF.MOV + BPF.K, 2, 0, 0, ffi.sizeof(e.V[dst].type)) -- Return is integer e.vset(ret) e.vreg(ret, 0, true, ffi.typeof('int32_t')) e.emit(BPF.JMP + BPF.CALL, 0, 0, 0, HELPER.get_current_comm) e.V[e.tmpvar].reg = nil -- Free temporary registers end -- Math library built-ins math.log2 = function (x) error('NYI') end builtins[math.log2] = function (e, dst, x) -- Classic integer bits subdivison algorithm to find the position -- of the highest bit set, adapted for BPF bytecode-friendly operations. -- https://graphics.stanford.edu/~seander/bithacks.html -- r = 0 local r = e.vreg(dst, nil, true) e.emit(BPF.ALU64 + BPF.MOV + BPF.K, r, 0, 0, 0) -- v = x e.vcopy(e.tmpvar, x) local v = e.vreg(e.tmpvar, 2) if cdef.isptr(e.V[x].const) then -- No pointer arithmetics, dereference e.vderef(v, v, ffi.typeof('uint64_t')) end -- Invert value to invert all tests, otherwise we would need and+jnz e.emit(BPF.ALU64 + BPF.NEG + BPF.K, v, 0, 0, 0) -- v = ~v -- Unrolled test cases, converted masking to arithmetic as we don't have "if !(a & b)" -- As we're testing inverted value, we have to use arithmetic shift to copy MSB for i=4,0,-1 do local k = bit.lshift(1, i) e.emit(BPF.JMP + BPF.JGT + BPF.K, v, 0, 2, bit.bnot(bit.lshift(1, k))) -- if !upper_half(x) e.emit(BPF.ALU64 + BPF.ARSH + BPF.K, v, 0, 0, k) -- v >>= k e.emit(BPF.ALU64 + BPF.OR + BPF.K, r, 0, 0, k) -- r |= k end -- No longer constant, cleanup tmpvars e.V[dst].const = nil e.V[e.tmpvar].reg = nil end builtins[math.log10] = function (e, dst, x) -- Compute log2(x) and transform builtins[math.log2](e, dst, x) -- Relationship: log10(v) = log2(v) / log2(10) local r = e.V[dst].reg e.emit(BPF.ALU64 + BPF.ADD + BPF.K, r, 0, 0, 1) -- Compensate round-down e.emit(BPF.ALU64 + BPF.MUL + BPF.K, r, 0, 0, 1233) -- log2(10) ~ 1233>>12 e.emit(BPF.ALU64 + BPF.RSH + BPF.K, r, 0, 0, 12) end builtins[math.log] = function (e, dst, x) -- Compute log2(x) and transform builtins[math.log2](e, dst, x) -- Relationship: ln(v) = log2(v) / log2(e) local r = e.V[dst].reg e.emit(BPF.ALU64 + BPF.ADD + BPF.K, r, 0, 0, 1) -- Compensate round-down e.emit(BPF.ALU64 + BPF.MUL + BPF.K, r, 0, 0, 2839) -- log2(e) ~ 2839>>12 e.emit(BPF.ALU64 + BPF.RSH + BPF.K, r, 0, 0, 12) end -- Call-type helpers local function call_helper(e, dst, h) e.vset(dst) local dst_reg = e.vreg(dst, 0, true) e.emit(BPF.JMP + BPF.CALL, 0, 0, 0, h) e.V[dst].const = nil -- Target is not a function anymore end local function cpu() error('NYI') end local function rand() error('NYI') end local function time() error('NYI') end local function pid_tgid() error('NYI') end local function uid_gid() error('NYI') end -- Export helpers and builtin variants builtins.cpu = cpu builtins.time = time builtins.pid_tgid = pid_tgid builtins.uid_gid = uid_gid builtins.comm = comm builtins.perf_submit = perf_submit builtins.stack_id = stack_id builtins[cpu] = function (e, dst) return call_helper(e, dst, HELPER.get_smp_processor_id) end builtins[rand] = function (e, dst) return call_helper(e, dst, HELPER.get_prandom_u32) end builtins[time] = function (e, dst) return call_helper(e, dst, HELPER.ktime_get_ns) end builtins[pid_tgid] = function (e, dst) return call_helper(e, dst, HELPER.get_current_pid_tgid) end builtins[uid_gid] = function (e, dst) return call_helper(e, dst, HELPER.get_current_uid_gid) end builtins[perf_submit] = function (e, dst, map, value) return perf_submit(e, dst, map, value) end builtins[stack_id] = function (e, dst, map, key) return stack_id(e, dst, map, key) end return builtins bpfcc-0.2.0+git0.02884a026/src/lua/bpf/cdef.lua000066400000000000000000000176051305314114400202320ustar00rootroot00000000000000--[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require('ffi') local bit = require('bit') local S = require('syscall') local M = {} ffi.cdef [[ struct bpf { /* Instruction classes */ static const int LD = 0x00; static const int LDX = 0x01; static const int ST = 0x02; static const int STX = 0x03; static const int ALU = 0x04; static const int JMP = 0x05; static const int ALU64 = 0x07; /* ld/ldx fields */ static const int W = 0x00; static const int H = 0x08; static const int B = 0x10; static const int ABS = 0x20; static const int IND = 0x40; static const int MEM = 0x60; static const int LEN = 0x80; static const int MSH = 0xa0; /* alu/jmp fields */ static const int ADD = 0x00; static const int SUB = 0x10; static const int MUL = 0x20; static const int DIV = 0x30; static const int OR = 0x40; static const int AND = 0x50; static const int LSH = 0x60; static const int RSH = 0x70; static const int NEG = 0x80; static const int MOD = 0x90; static const int XOR = 0xa0; static const int JA = 0x00; static const int JEQ = 0x10; static const int JGT = 0x20; static const int JGE = 0x30; static const int JSET = 0x40; static const int K = 0x00; static const int X = 0x08; static const int JNE = 0x50; /* jump != */ static const int JSGT = 0x60; /* SGT is signed '>', GT in x86 */ static const int JSGE = 0x70; /* SGE is signed '>=', GE in x86 */ static const int CALL = 0x80; /* function call */ static const int EXIT = 0x90; /* function return */ /* ld/ldx fields */ static const int DW = 0x18; /* double word */ static const int XADD = 0xc0; /* exclusive add */ /* alu/jmp fields */ static const int MOV = 0xb0; /* mov reg to reg */ static const int ARSH = 0xc0; /* sign extending arithmetic shift right */ /* change endianness of a register */ static const int END = 0xd0; /* flags for endianness conversion: */ static const int TO_LE = 0x00; /* convert to little-endian */ static const int TO_BE = 0x08; /* convert to big-endian */ /* misc */ static const int PSEUDO_MAP_FD = 0x01; /* helper functions */ static const int F_CURRENT_CPU = 0xffffffff; static const int F_USER_STACK = 1 << 8; static const int F_FAST_STACK_CMP = 1 << 9; static const int F_REUSE_STACKID = 1 << 10; }; /* eBPF commands */ struct bpf_cmd { static const int MAP_CREATE = 0; static const int MAP_LOOKUP_ELEM = 1; static const int MAP_UPDATE_ELEM = 2; static const int MAP_DELETE_ELEM = 3; static const int MAP_GET_NEXT_KEY = 4; static const int PROG_LOAD = 5; static const int OBJ_PIN = 6; static const int OBJ_GET = 7; }; /* eBPF helpers */ struct bpf_func_id { static const int unspec = 0; static const int map_lookup_elem = 1; static const int map_update_elem = 2; static const int map_delete_elem = 3; static const int probe_read = 4; static const int ktime_get_ns = 5; static const int trace_printk = 6; static const int get_prandom_u32 = 7; static const int get_smp_processor_id = 8; static const int skb_store_bytes = 9; static const int l3_csum_replace = 10; static const int l4_csum_replace = 11; static const int tail_call = 12; static const int clone_redirect = 13; static const int get_current_pid_tgid = 14; static const int get_current_uid_gid = 15; static const int get_current_comm = 16; static const int get_cgroup_classid = 17; static const int skb_vlan_push = 18; static const int skb_vlan_pop = 19; static const int skb_get_tunnel_key = 20; static const int skb_set_tunnel_key = 21; static const int perf_event_read = 22; static const int redirect = 23; static const int get_route_realm = 24; static const int perf_event_output = 25; static const int skb_load_bytes = 26; static const int get_stackid = 27; }; /* BPF_MAP_STACK_TRACE structures and constants */ static const int BPF_MAX_STACK_DEPTH = 127; struct bpf_stacktrace { uint64_t ip[BPF_MAX_STACK_DEPTH]; }; ]] -- Compatibility: ljsyscall doesn't have support for BPF syscall if not S.bpf then error("ljsyscall doesn't support bpf(), must be updated") else -- Compatibility: ljsyscall<=0.12 if not S.c.BPF_MAP.PERCPU_HASH then S.c.BPF_MAP.PERCPU_HASH = 5 S.c.BPF_MAP.PERCPU_ARRAY = 6 S.c.BPF_MAP.STACK_TRACE = 7 S.c.BPF_MAP.CGROUP_ARRAY = 8 S.c.BPF_MAP.LRU_HASH = 9 S.c.BPF_MAP.LRU_PERCPU_HASH = 10 S.c.BPF_MAP.LPM_TRIE = 11 end if not S.c.BPF_PROG.TRACEPOINT then S.c.BPF_PROG.TRACEPOINT = 5 S.c.BPF_PROG.XDP = 6 S.c.BPF_PROG.PERF_EVENT = 7 end end -- Compatibility: metatype for stacktrace local function stacktrace_iter(t, i) i = i + 1 if i < #t and t.ip[i] > 0 then return i, t.ip[i] end end ffi.metatype('struct bpf_stacktrace', { __len = function (t) return ffi.sizeof(t.ip) / ffi.sizeof(t.ip[0]) end, __ipairs = function (t) return stacktrace_iter, t, -1 end, }) -- Reflect cdata type function M.typename(v) if not v or type(v) ~= 'cdata' then return nil end return string.match(tostring(ffi.typeof(v)), '<([^>]+)') end -- Reflect if cdata type can be pointer (accepts array or pointer) function M.isptr(v, noarray) local ctname = M.typename(v) if ctname then ctname = string.sub(ctname, -1) ctname = ctname == '*' or (not noarray and ctname == ']') end return ctname end function M.osversion() -- We have no better way to extract current kernel hex-string other -- than parsing headers, compiling a helper function or reading /proc local ver_str, count = S.sysctl('kernel.version'):match('%d+.%d+.%d+'), 2 if not ver_str then -- kernel.version is freeform, fallback to kernel.osrelease ver_str = S.sysctl('kernel.osrelease'):match('%d+.%d+.%d+') end local version = 0 for i in ver_str:gmatch('%d+') do -- Convert 'X.Y.Z' to 0xXXYYZZ version = bit.bor(version, bit.lshift(tonumber(i), 8*count)) count = count - 1 end return version end function M.event_reader(reader, event_type) -- Caller can specify event message binary format if event_type then assert(type(event_type) == 'string' and ffi.typeof(event_type), 'not a valid type for event reader') event_type = ffi.typeof(event_type .. '*') -- Convert type to pointer-to-type end -- Wrap reader in interface that can interpret read event messages return setmetatable({reader=reader,type=event_type}, {__index = { block = function(self) return S.select { readfds = {reader.fd} } end, next = function(self, k) local len, ev = reader:next(k) -- Filter out only sample frames while ev and ev.type ~= S.c.PERF_RECORD.SAMPLE do len, ev = reader:next(len) end if ev and event_type then -- The perf event reader returns framed data with header and variable length -- This is going skip the frame header and cast data to given type ev = ffi.cast(event_type, ffi.cast('char *', ev) + ffi.sizeof('struct perf_event_header') + ffi.sizeof('uint32_t')) end return len, ev end, read = function(self) return self.next, self, nil end, }}) end function M.tracepoint_type(tp) -- Read tracepoint format string local fp = assert(io.open('/sys/kernel/debug/tracing/events/'..tp..'/format', 'r')) local fmt = fp:read '*a' fp:close() -- Parse struct fields local fields = {} for f in fmt:gmatch 'field:([^;]+;)' do table.insert(fields, f) end return string.format('struct { %s }', table.concat(fields)) end return M bpfcc-0.2.0+git0.02884a026/src/lua/bpf/elf.lua000066400000000000000000000222011305314114400200630ustar00rootroot00000000000000--[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] -- This is a tiny wrapper over libelf to extract load address -- and offsets of dynamic symbols local S = require('syscall') local ffi = require('ffi') ffi.cdef [[ /* Type for a 16-bit quantity. */ typedef uint16_t Elf32_Half; typedef uint16_t Elf64_Half; /* Types for signed and unsigned 32-bit quantities. */ typedef uint32_t Elf32_Word; typedef int32_t Elf32_Sword; typedef uint32_t Elf64_Word; typedef int32_t Elf64_Sword; /* Types for signed and unsigned 64-bit quantities. */ typedef uint64_t Elf32_Xword; typedef int64_t Elf32_Sxword; typedef uint64_t Elf64_Xword; typedef int64_t Elf64_Sxword; /* Type of addresses. */ typedef uint32_t Elf32_Addr; typedef uint64_t Elf64_Addr; /* Type of file offsets. */ typedef uint32_t Elf32_Off; typedef uint64_t Elf64_Off; /* Type for section indices, which are 16-bit quantities. */ typedef uint16_t Elf32_Section; typedef uint16_t Elf64_Section; /* Constants */ struct Elf_Cmd { static const int READ = 1; static const int RDWR = 2; static const int WRITE = 3; static const int CLR = 4; static const int SET = 5; static const int FDDONE = 6; static const int FDREAD = 7; static const int READ_MMAP = 8; static const int RDWR_MMAP = 9; static const int WRITE_MMAP =10; static const int READ_MMAP_PRIVATE =11; static const int EMPTY =12; static const int NUM =13; }; /* Descriptor for the ELF file. */ typedef struct Elf Elf; /* Descriptor for ELF file section. */ typedef struct Elf_Scn Elf_Scn; /* Container type for metatable */ struct Elf_object { int fd; Elf *elf; }; /* Program segment header. */ typedef struct { Elf64_Word p_type; /* Segment type */ Elf64_Word p_flags; /* Segment flags */ Elf64_Off p_offset; /* Segment file offset */ Elf64_Addr p_vaddr; /* Segment virtual address */ Elf64_Addr p_paddr; /* Segment physical address */ Elf64_Xword p_filesz; /* Segment size in file */ Elf64_Xword p_memsz; /* Segment size in memory */ Elf64_Xword p_align; /* Segment alignment */ } Elf64_Phdr; typedef Elf64_Phdr GElf_Phdr; /* Section header. */ typedef struct { Elf64_Word sh_name; /* Section name (string tbl index) */ Elf64_Word sh_type; /* Section type */ Elf64_Xword sh_flags; /* Section flags */ Elf64_Addr sh_addr; /* Section virtual addr at execution */ Elf64_Off sh_offset; /* Section file offset */ Elf64_Xword sh_size; /* Section size in bytes */ Elf64_Word sh_link; /* Link to another section */ Elf64_Word sh_info; /* Additional section information */ Elf64_Xword sh_addralign; /* Section alignment */ Elf64_Xword sh_entsize; /* Entry size if section holds table */ } Elf64_Shdr; typedef Elf64_Shdr GElf_Shdr; /* Descriptor for data to be converted to or from memory format. */ typedef struct { void *d_buf; /* Pointer to the actual data. */ int d_type; /* Type of this piece of data. */ unsigned int d_version; /* ELF version. */ size_t d_size; /* Size in bytes. */ uint64_t d_off; /* Offset into section. */ size_t d_align; /* Alignment in section. */ } Elf_Data; /* Symbol table entry. */ typedef struct { Elf64_Word st_name; /* Symbol name (string tbl index) */ unsigned char st_info; /* Symbol type and binding */ unsigned char st_other; /* Symbol visibility */ Elf64_Section st_shndx; /* Section index */ Elf64_Addr st_value; /* Symbol value */ Elf64_Xword st_size; /* Symbol size */ } Elf64_Sym; typedef Elf64_Sym GElf_Sym; /* Coordinate ELF library and application versions. */ unsigned int elf_version (unsigned int __version); /* Return descriptor for ELF file to work according to CMD. */ Elf *elf_begin (int __fildes, int __cmd, Elf *__ref); /* Free resources allocated for ELF. */ int elf_end (Elf *__elf); /* Get the number of program headers in the ELF file. If the file uses more headers than can be represented in the e_phnum field of the ELF header the information from the sh_info field in the zeroth section header is used. */ int elf_getphdrnum (Elf *__elf, size_t *__dst); /* Retrieve program header table entry. */ GElf_Phdr *gelf_getphdr (Elf *__elf, int __ndx, GElf_Phdr *__dst); /* Retrieve section header. */ GElf_Shdr *gelf_getshdr (Elf_Scn *__scn, GElf_Shdr *__dst); /* Retrieve symbol information from the symbol table at the given index. */ GElf_Sym *gelf_getsym (Elf_Data *__data, int __ndx, GElf_Sym *__dst); /* Get section with next section index. */ Elf_Scn *elf_nextscn (Elf *__elf, Elf_Scn *__scn); /* Get data from section while translating from file representation to memory representation. */ Elf_Data *elf_getdata (Elf_Scn *__scn, Elf_Data *__data); /* Return pointer to string at OFFSET in section INDEX. */ char *elf_strptr (Elf *__elf, size_t __index, size_t __offset); ]] local elf = ffi.load('elf') local EV = { NONE=0, CURRENT=1, NUM=2 } local PT = { NULL=0, LOAD=1, DYNAMIC=2, INTERP=3, NOTE=4, SHLIB=5, PHDR=6, TLS=7, NUM=8 } local SHT = { NULL=0, PROGBITS=1, SYMTAB=2, STRTAB=3, RELA=4, HASH=5, DYNAMIC=6, NOTE=7, NOBITS=8, REL=9, SHLIB=10, DYNSYM=11, INIT_ARRAY=14, FINI_ARRAY=15, PREINIT_ARRAY=16, GROUP=17, SYMTAB_SHNDX=18, NUM=19 } local ELF_C = ffi.new('struct Elf_Cmd') local M = {} -- Optional poor man's C++ demangler local cpp_demangler = os.getenv('CPP_DEMANGLER') if not cpp_demangler then for prefix in string.gmatch(os.getenv('PATH'), '[^;:]+') do if S.statfs(prefix..'/c++filt') then cpp_demangler = prefix..'/c++filt' break end end end local cpp_demangle = function (name) return name end if cpp_demangler then cpp_demangle = function (name) local cmd = string.format('%s -p %s', cpp_demangler, name) local fp = assert(io.popen(cmd, 'r')) local output = fp:read('*all') fp:close() return output:match '^(.-)%s*$' end end -- Metatable for ELF object ffi.metatype('struct Elf_object', { __gc = function (t) t:close() end, __index = { close = function (t) if t.elf ~= nil then elf.elf_end(t.elf) S.close(t.fd) t.elf = nil end end, -- Load library load address loadaddr = function(t) local phnum = ffi.new('size_t [1]') if elf.elf_getphdrnum(t.elf, phnum) == nil then return nil, 'cannot get phdrnum' end local header = ffi.new('GElf_Phdr [1]') for i = 0, tonumber(phnum[0])-1 do if elf.gelf_getphdr(t.elf, i, header) ~= nil and header[0].p_type == PT.LOAD then return header[0].p_vaddr end end end, -- Resolve symbol address resolve = function (t, k, pattern) local section = elf.elf_nextscn(t.elf, nil) while section ~= nil do local header = ffi.new('GElf_Shdr [1]') if elf.gelf_getshdr(section, header) ~= nil then if header[0].sh_type == SHT.SYMTAB or header[0].sh_type == SHT.DYNSYM then local data = elf.elf_getdata(section, nil) while data ~= nil do if data.d_size % header[0].sh_entsize > 0 then return nil, 'bad section header entity size' end local symcount = tonumber(data.d_size / header[0].sh_entsize) local sym = ffi.new('GElf_Sym [1]') for i = 0, symcount - 1 do if elf.gelf_getsym(data, i, sym) ~= nil then local name = elf.elf_strptr(t.elf, header[0].sh_link, sym[0].st_name) if name ~= nil then -- Demangle C++ symbols if necessary name = ffi.string(name) if name:sub(1,2) == '_Z' then name = cpp_demangle(name) end -- Match symbol name against pattern if pattern and string.match(name, k) or k == name then return sym[0] end end end end data = elf.elf_getdata(section, data) end end end section = elf.elf_nextscn(t.elf, section) end end, } }) -- Open an ELF object function M.open(path) if elf.elf_version(EV.CURRENT) == EV.NONE then return nil, 'bad version' end local fd, err = S.open(path, 'rdonly') if not fd then return nil, err end local pt = ffi.new('Elf *') pt = elf.elf_begin(fd:getfd(), ELF_C.READ, pt) if not pt then fd:close() return nil, 'cannot open elf object' end return ffi.new('struct Elf_object', fd:nogc():getfd(), pt) end return Mbpfcc-0.2.0+git0.02884a026/src/lua/bpf/init.lua000066400000000000000000000011421305314114400202610ustar00rootroot00000000000000--[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] return require('bpf.bpf') bpfcc-0.2.0+git0.02884a026/src/lua/bpf/ljbytecode.lua000066400000000000000000000041671305314114400214540ustar00rootroot00000000000000--[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local jutil = require("jit.util") local vmdef = require("jit.vmdef") local bit = require('bit') local shr, band = bit.rshift, bit.band -- Decode LuaJIT 2.0 Byte Format -- Reference: http://wiki.luajit.org/Bytecode-2.0 -- Thanks to LJ, we get code in portable bytecode with constants folded, basic -- virtual registers allocated etc. -- No SSA IR, type inference or advanced optimizations because the code wasn't traced yet. local function decode_ins(func, pc) local ins, m = jutil.funcbc(func, pc) if not ins then return nil end local op, ma, mb, mc = band(ins, 0xff), band(m, 7), band(m, 15*8), band(m, 15*128) local a, b, c, d = band(shr(ins, 8), 0xff), nil, nil, shr(ins, 16) if mb ~= 0 then d = band(d, 0xff) b = shr(ins, 24) end if ma == 5 then -- BCMuv a = jutil.funcuvname(func, a) end if mc == 13*128 then -- BCMjump c = pc+d-0x7fff elseif mc == 9*128 then -- BCMint c = jutil.funck(func, d) elseif mc == 10*128 then -- BCMstr c = jutil.funck(func, -d-1) elseif mc == 5*128 then -- BCMuv c = jutil.funcuvname(func, d) end -- Convert version-specific opcode to string op = 6*op op = string.sub(vmdef.bcnames, op+1, op+6):match('[^%s]+') return pc, op, a, b, c, d end -- Decoder closure local function decoder(func) local pc = 0 return function () pc = pc + 1 return decode_ins(func, pc) end end -- Hexdump generated code local function dump(func) return require('jit.bc').dump(func) end return { decode = decode_ins, decoder = decoder, dump = dump, funcinfo = function (...) return jutil.funcinfo(...) end, }bpfcc-0.2.0+git0.02884a026/src/lua/bpf/proto.lua000066400000000000000000000365661305314114400205030ustar00rootroot00000000000000--[[ Copyright 2016 Marek Vavrusa Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ]] local ffi = require('ffi') local BPF = ffi.typeof('struct bpf') ffi.cdef [[ struct sk_buff { uint32_t len; uint32_t pkt_type; uint32_t mark; uint32_t queue_mapping; uint32_t protocol; uint32_t vlan_present; uint32_t vlan_tci; uint32_t vlan_proto; uint32_t priority; uint32_t ingress_ifindex; uint32_t ifindex; uint32_t tc_index; uint32_t cb[5]; uint32_t hash; uint32_t tc_classid; }; struct eth_t { uint8_t dst[6]; uint8_t src[6]; uint16_t type; } __attribute__((packed)); struct dot1q_t { uint16_t pri:3; uint16_t cfi:1; uint16_t vlanid:12; uint16_t type; } __attribute__((packed)); struct arp_t { uint16_t htype; uint16_t ptype; uint8_t hlen; uint8_t plen; uint16_t oper; uint8_t sha[6]; uint32_t spa; uint8_t tha[6]; uint32_t tpa; } __attribute__((packed)); struct ip_t { uint8_t ver:4; uint8_t hlen:4; uint8_t tos; uint16_t tlen; uint16_t identification; uint16_t ffo_unused:1; uint16_t df:1; uint16_t mf:1; uint16_t foffset:13; uint8_t ttl; uint8_t proto; uint16_t hchecksum; uint32_t src; uint32_t dst; } __attribute__((packed)); struct icmp_t { uint8_t type; uint8_t code; uint16_t checksum; } __attribute__((packed)); struct ip6_t { uint32_t ver:4; uint32_t priority:8; uint32_t flow_label:20; uint16_t payload_len; uint8_t next_header; uint8_t hop_limit; uint64_t src_hi; uint64_t src_lo; uint64_t dst_hi; uint64_t dst_lo; } __attribute__((packed)); struct ip6_opt_t { uint8_t next_header; uint8_t ext_len; uint8_t pad[6]; } __attribute__((packed)); struct icmp6_t { uint8_t type; uint8_t code; uint16_t checksum; } __attribute__((packed)); struct udp_t { uint16_t src_port; uint16_t dst_port; uint16_t length; uint16_t crc; } __attribute__((packed)); struct tcp_t { uint16_t src_port; uint16_t dst_port; uint32_t seq_num; uint32_t ack_num; uint8_t offset:4; uint8_t reserved:4; uint8_t flag_cwr:1; uint8_t flag_ece:1; uint8_t flag_urg:1; uint8_t flag_ack:1; uint8_t flag_psh:1; uint8_t flag_rst:1; uint8_t flag_syn:1; uint8_t flag_fin:1; uint16_t rcv_wnd; uint16_t cksum; uint16_t urg_ptr; } __attribute__((packed)); struct vxlan_t { uint32_t rsv1:4; uint32_t iflag:1; uint32_t rsv2:3; uint32_t rsv3:24; uint32_t key:24; uint32_t rsv4:8; } __attribute__((packed)); ]] -- Architecture-specific ptrace register layout local S = require('syscall') local arch = S.abi.arch local parm_to_reg = {} if arch == 'x64' then ffi.cdef [[ struct pt_regs { unsigned long r15; unsigned long r14; unsigned long r13; unsigned long r12; unsigned long bp; unsigned long bx; unsigned long r11; unsigned long r10; unsigned long r9; unsigned long r8; unsigned long ax; unsigned long cx; unsigned long dx; unsigned long si; unsigned long di; unsigned long orig_ax; unsigned long ip; unsigned long cs; unsigned long flags; unsigned long sp; unsigned long ss; };]] parm_to_reg = {parm1='di', parm2='si', parm3='dx', parm4='cx', parm5='r8', ret='sp', fp='bp'} else ffi.cdef 'struct pt_regs {};' end -- Map symbolic registers to architecture ABI ffi.metatype('struct pt_regs', { __index = function (t,k) return assert(parm_to_reg[k], 'no such register: '..k) end, }) local M = {} -- Dissector interface local function dissector(type, e, dst, src, field) local parent = e.V[src].const -- Create new dissector variable e.vcopy(dst, src) -- Compute and materialize new dissector offset from parent e.V[dst].const = {off=e.V[src].const.off, __dissector=e.V[src].const.__dissector} parent.__dissector[field](e, dst) e.V[dst].const.__dissector = type end M.dissector = dissector -- Get current effective offset, load field value at an offset relative to it and -- add its value to compute next effective offset (e.g. udp_off = ip_off + pkt[ip_off].hlen) local function next_offset(e, var, type, off, mask, shift) local d = e.V[var].const -- Materialize relative offset value in R0 local dst_reg, tmp_reg if d.off then dst_reg = e.vreg(var, 0, true) tmp_reg = dst_reg -- Use target register to avoid copy e.emit(BPF.LD + BPF.ABS + e.const_width[ffi.sizeof(type)], tmp_reg, 0, 0, d.off + off or 0) else tmp_reg = e.vreg(e.tmpvar, 0, true, type) -- Reserve R0 for temporary relative offset dst_reg = e.vreg(var) -- Must rematerialize (if it was spilled by tmp var) e.emit(BPF.LD + BPF.IND + e.const_width[ffi.sizeof(type)], tmp_reg, dst_reg, 0, off or 0) end -- Finalize relative offset if mask then e.emit(BPF.ALU + BPF.AND + BPF.K, tmp_reg, 0, 0, mask) end if shift then local op = BPF.LSH if shift < 0 then op = BPF.RSH shift = -shift end e.emit(BPF.ALU + op + BPF.K, tmp_reg, 0, 0, shift) end -- Add to base offset to turn it into effective address if dst_reg ~= tmp_reg then e.emit(BPF.ALU + BPF.ADD + BPF.X, dst_reg, tmp_reg, 0, 0) else e.emit(BPF.ALU + BPF.ADD + BPF.K, dst_reg, 0, 0, d.off) end -- Discard temporary allocations d.off = nil e.V[e.tmpvar].reg = nil end local function next_skip(e, var, off) local d = e.V[var].const if not d.off then local dst_reg = e.vreg(var) e.emit(BPF.ALU64 + BPF.ADD + BPF.K, dst_reg, 0, 0, off) else d.off = d.off + off end end local function skip_eth(e, dst) -- IP starts right after ETH header (fixed size) local d = e.V[dst].const d.off = d.off + ffi.sizeof('struct eth_t') end -- Export types M.type = function(typestr, t) t = t or {} t.__dissector=ffi.typeof(typestr) return t end M.skb = M.type('struct sk_buff', {__base=true}) M.pt_regs = M.type('struct pt_regs', {__base=true, source='probe'}) M.pkt = {off=0, __dissector=ffi.typeof('struct eth_t')} -- skb needs special accessors -- M.eth = function (...) return dissector(ffi.typeof('struct eth_t'), ...) end M.dot1q = function (...) return dissector(ffi.typeof('struct dot1q_t'), ...) end M.arp = function (...) return dissector(ffi.typeof('struct arp_t'), ...) end M.icmp = function (...) return dissector(ffi.typeof('struct icmp_t'), ...) end M.ip = function (...) return dissector(ffi.typeof('struct ip_t'), ...) end M.icmp6 = function (...) return dissector(ffi.typeof('struct icmp6_t'), ...) end M.ip6 = function (...) return dissector(ffi.typeof('struct ip6_t'), ...) end M.ip6_opt = function (...) return dissector(ffi.typeof('struct ip6_opt_t'), ...) end M.udp = function (...) return dissector(ffi.typeof('struct udp_t'), ...) end M.tcp = function (...) return dissector(ffi.typeof('struct tcp_t'), ...) end M.vxlan = function (...) return dissector(ffi.typeof('struct vxlan_t'), ...) end M.data = function (...) return dissector(ffi.typeof('uint8_t'), ...) end -- Metatables ffi.metatype(ffi.typeof('struct eth_t'), { __index = { ip = skip_eth, ip6 = skip_eth, } }) ffi.metatype(ffi.typeof('struct ip_t'), { __index = { -- Skip IP header length (stored as number of words) -- e.g. hlen = 5, Header Length = 5 x sizeof(u32) = 20 octets -- Mask first nibble and shift by 2 (multiplication by 4) icmp = function(e, dst) next_offset(e, dst, ffi.typeof('uint8_t'), 0, 0x0f, 2) end, udp = function(e, dst) next_offset(e, dst, ffi.typeof('uint8_t'), 0, 0x0f, 2) end, tcp = function(e, dst) next_offset(e, dst, ffi.typeof('uint8_t'), 0, 0x0f, 2) end, } }) ffi.metatype(ffi.typeof('struct tcp_t'), { __index = { -- Skip TCP header length (stored as number of words) -- e.g. hlen = 5, Header Length = 5 x sizeof(u32) = 20 octets data = function(e, dst) next_offset(e, dst, ffi.typeof('uint8_t'), ffi.offsetof('struct tcp_t', 'offset'), 0xf0, -2) end, } }) ffi.metatype(ffi.typeof('struct udp_t'), { __index = { -- Skip UDP header length (8 octets) data = function(e, dst) next_skip(e, dst, ffi.sizeof('struct udp_t')) end, } }) -- Constants M.c = { eth = { -- Constants http://standards.ieee.org/regauth/ethertype ip = 0x0800, -- IP (v4) protocol ip6 = 0x86dd, -- IP (v6) protocol arp = 0x0806, -- Address resolution protocol revarp = 0x8035, -- Reverse addr resolution protocol vlan = 0x8100, -- IEEE 802.1Q VLAN tagging }, ip = { -- Reserved Addresses addr_any = 0x00000000, -- 0.0.0.0 addr_broadcast = 0xffffffff, -- 255.255.255.255 addr_loopback = 0x7f000001, -- 127.0.0.1 addr_mcast_all = 0xe0000001, -- 224.0.0.1 addr_mcast_local = 0xe00000ff, -- 224.0.0.255 -- Type of service (ip_tos), RFC 1349 ("obsoleted by RFC 2474") tos_default = 0x00, -- default tos_lowdelay = 0x10, -- low delay tos_throughput = 0x08, -- high throughput tos_reliability = 0x04, -- high reliability tos_lowcost = 0x02, -- low monetary cost - XXX tos_ect = 0x02, -- ECN-capable transport tos_ce = 0x01, -- congestion experienced -- Fragmentation flags (ip_off) rf = 0x8000, -- reserved df = 0x4000, -- don't fragment mf = 0x2000, -- more fragments (not last frag) offmask = 0x1fff, -- mask for fragment offset -- Time-to-live (ip_ttl), seconds ttl_default = 64, -- default ttl, RFC 1122, RFC 1340 ttl_max = 255, -- maximum ttl -- Protocol (ip_p) - http://www.iana.org/assignments/protocol-numbers proto_ip = 0, -- dummy for IP proto_hopopts = 0, -- IPv6 hop-by-hop options proto_icmp = 1, -- ICMP proto_igmp = 2, -- IGMP proto_ggp = 3, -- gateway-gateway protocol proto_ipip = 4, -- IP in IP proto_st = 5, -- ST datagram mode proto_tcp = 6, -- TCP proto_cbt = 7, -- CBT proto_egp = 8, -- exterior gateway protocol proto_igp = 9, -- interior gateway protocol proto_bbnrcc = 10, -- BBN RCC monitoring proto_nvp = 11, -- Network Voice Protocol proto_pup = 12, -- PARC universal packet proto_argus = 13, -- ARGUS proto_emcon = 14, -- EMCON proto_xnet = 15, -- Cross Net Debugger proto_chaos = 16, -- Chaos proto_udp = 17, -- UDP proto_mux = 18, -- multiplexing proto_dcnmeas = 19, -- DCN measurement proto_hmp = 20, -- Host Monitoring Protocol proto_prm = 21, -- Packet Radio Measurement proto_idp = 22, -- Xerox NS IDP proto_trunk1 = 23, -- Trunk-1 proto_trunk2 = 24, -- Trunk-2 proto_leaf1 = 25, -- Leaf-1 proto_leaf2 = 26, -- Leaf-2 proto_rdp = 27, -- "Reliable Datagram" proto proto_irtp = 28, -- Inet Reliable Transaction proto_tp = 29, -- ISO TP class 4 proto_netblt = 30, -- Bulk Data Transfer proto_mfpnsp = 31, -- MFE Network Services proto_meritinp= 32, -- Merit Internodal Protocol proto_sep = 33, -- Sequential Exchange proto proto_3pc = 34, -- Third Party Connect proto proto_idpr = 35, -- Interdomain Policy Route proto_xtp = 36, -- Xpress Transfer Protocol proto_ddp = 37, -- Datagram Delivery Proto proto_cmtp = 38, -- IDPR Ctrl Message Trans proto_tppp = 39, -- TP++ Transport Protocol proto_il = 40, -- IL Transport Protocol proto_ip6 = 41, -- IPv6 proto_sdrp = 42, -- Source Demand Routing proto_routing = 43, -- IPv6 routing header proto_fragment= 44, -- IPv6 fragmentation header proto_rsvp = 46, -- Reservation protocol proto_gre = 47, -- General Routing Encap proto_mhrp = 48, -- Mobile Host Routing proto_ena = 49, -- ENA proto_esp = 50, -- Encap Security Payload proto_ah = 51, -- Authentication Header proto_inlsp = 52, -- Integated Net Layer Sec proto_swipe = 53, -- SWIPE proto_narp = 54, -- NBMA Address Resolution proto_mobile = 55, -- Mobile IP, RFC 2004 proto_tlsp = 56, -- Transport Layer Security proto_skip = 57, -- SKIP proto_icmp6 = 58, -- ICMP for IPv6 proto_none = 59, -- IPv6 no next header proto_dstopts = 60, -- IPv6 destination options proto_anyhost = 61, -- any host internal proto proto_cftp = 62, -- CFTP proto_anynet = 63, -- any local network proto_expak = 64, -- SATNET and Backroom EXPAK proto_kryptolan = 65, -- Kryptolan proto_rvd = 66, -- MIT Remote Virtual Disk proto_ippc = 67, -- Inet Pluribus Packet Core proto_distfs = 68, -- any distributed fs proto_satmon = 69, -- SATNET Monitoring proto_visa = 70, -- VISA Protocol proto_ipcv = 71, -- Inet Packet Core Utility proto_cpnx = 72, -- Comp Proto Net Executive proto_cphb = 73, -- Comp Protocol Heart Beat proto_wsn = 74, -- Wang Span Network proto_pvp = 75, -- Packet Video Protocol proto_brsatmon= 76, -- Backroom SATNET Monitor proto_sunnd = 77, -- SUN ND Protocol proto_wbmon = 78, -- WIDEBAND Monitoring proto_wbexpak = 79, -- WIDEBAND EXPAK proto_eon = 80, -- ISO CNLP proto_vmtp = 81, -- Versatile Msg Transport proto_svmtp = 82, -- Secure VMTP proto_vines = 83, -- VINES proto_ttp = 84, -- TTP proto_nsfigp = 85, -- NSFNET-IGP proto_dgp = 86, -- Dissimilar Gateway Proto proto_tcf = 87, -- TCF proto_eigrp = 88, -- EIGRP proto_ospf = 89, -- Open Shortest Path First proto_spriterpc= 90, -- Sprite RPC Protocol proto_larp = 91, -- Locus Address Resolution proto_mtp = 92, -- Multicast Transport Proto proto_ax25 = 93, -- AX.25 Frames proto_ipipencap= 94, -- yet-another IP encap proto_micp = 95, -- Mobile Internet Ctrl proto_sccsp = 96, -- Semaphore Comm Sec Proto proto_etherip = 97, -- Ethernet in IPv4 proto_encap = 98, -- encapsulation header proto_anyenc = 99, -- private encryption scheme proto_gmtp = 100, -- GMTP proto_ifmp = 101, -- Ipsilon Flow Mgmt Proto proto_pnni = 102, -- PNNI over IP proto_pim = 103, -- Protocol Indep Multicast proto_aris = 104, -- ARIS proto_scps = 105, -- SCPS proto_qnx = 106, -- QNX proto_an = 107, -- Active Networks proto_ipcomp = 108, -- IP Payload Compression proto_snp = 109, -- Sitara Networks Protocol proto_compaqpeer= 110, -- Compaq Peer Protocol proto_ipxip = 111, -- IPX in IP proto_vrrp = 112, -- Virtual Router Redundancy proto_pgm = 113, -- PGM Reliable Transport proto_any0hop = 114, -- 0-hop protocol proto_l2tp = 115, -- Layer 2 Tunneling Proto proto_ddx = 116, -- D-II Data Exchange (DDX) proto_iatp = 117, -- Interactive Agent Xfer proto_stp = 118, -- Schedule Transfer Proto proto_srp = 119, -- SpectraLink Radio Proto proto_uti = 120, -- UTI proto_smp = 121, -- Simple Message Protocol proto_sm = 122, -- SM proto_ptp = 123, -- Performance Transparency proto_isis = 124, -- ISIS over IPv4 proto_fire = 125, -- FIRE proto_crtp = 126, -- Combat Radio Transport proto_crudp = 127, -- Combat Radio UDP proto_sscopmce= 128, -- SSCOPMCE proto_iplt = 129, -- IPLT proto_sps = 130, -- Secure Packet Shield proto_pipe = 131, -- Private IP Encap in IP proto_sctp = 132, -- Stream Ctrl Transmission proto_fc = 133, -- Fibre Channel proto_rsvpign = 134, -- RSVP-E2E-IGNORE proto_raw = 255, -- Raw IP packets proto_reserved= 255, -- Reserved }, } return Mbpfcc-0.2.0+git0.02884a026/src/lua/squishy000066400000000000000000000014701305314114400175000ustar00rootroot00000000000000Module "bcc.vendor.argparse" "bcc/vendor/argparse.lua" Module "bcc.vendor.posix" "bcc/vendor/posix.lua" Module "bcc.vendor.middleclass" "bcc/vendor/middleclass.lua" Module "bcc.vendor.json" "bcc/vendor/json.lua" Module "bcc.vendor.helpers" "bcc/vendor/helpers.lua" Module "bcc.init" "bcc/init.lua" Module "bcc.run" "bcc/run.lua" Module "bcc.bpf" "bcc/bpf.lua" Module "bcc.sym" "bcc/sym.lua" Module "bcc.libbcc" "bcc/libbcc.lua" Module "bcc.tracerpipe" "bcc/tracerpipe.lua" Module "bcc.table" "bcc/table.lua" Module "bcc.usdt" "bcc/usdt.lua" Module "bpf" "bpf/init.lua" Module "bpf.bpf" "bpf/bpf.lua" Module "bpf.builtins" "bpf/builtins.lua" Module "bpf.cdef" "bpf/cdef.lua" Module "bpf.elf" "bpf/elf.lua" Module "bpf.ljbytecode" "bpf/ljbytecode.lua" Module "bpf.proto" "bpf/proto.lua" Main "bcc/run.lua" Output "bcc.lua" bpfcc-0.2.0+git0.02884a026/src/lua/src/000077500000000000000000000000001305314114400166355ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/lua/src/main.c000066400000000000000000000111631305314114400177270ustar00rootroot00000000000000/* * Copyright 2016 GitHub, Inc * * Based on lua.c, the Lua C Interpreter * Copyright (C) 1994-2012 Lua.org, PUC-Rio. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sublicense, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include #include #include #include "lauxlib.h" #include "lua.h" #include "lualib.h" static lua_State *globalL = NULL; static const char *progname = NULL; static void lstop(lua_State *L, lua_Debug *ar) { (void)ar; /* unused arg. */ lua_sethook(L, NULL, 0, 0); luaL_error(L, "interrupted!"); } static void laction(int i) { signal(i, SIG_DFL); lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1); } static void l_message(const char *pname, const char *msg) { if (pname) fprintf(stderr, "%s: ", pname); fprintf(stderr, "%s\n", msg); fflush(stderr); } static int report(lua_State *L, int status) { if (status && !lua_isnil(L, -1)) { const char *msg = lua_tostring(L, -1); if (msg == NULL) msg = "(error object is not a string)"; l_message(progname, msg); lua_pop(L, 1); } return status; } static int traceback(lua_State *L) { if (!lua_isstring(L, 1)) /* 'message' not a string? */ return 1; /* keep it intact */ lua_getfield(L, LUA_GLOBALSINDEX, "debug"); if (!lua_istable(L, -1)) { lua_pop(L, 1); return 1; } lua_getfield(L, -1, "traceback"); if (!lua_isfunction(L, -1)) { lua_pop(L, 2); return 1; } lua_pushvalue(L, 1); /* pass error message */ lua_pushinteger(L, 2); /* skip this function and traceback */ lua_call(L, 2, 1); /* call debug.traceback */ return 1; } static int docall(lua_State *L, int narg, int clear) { int status; int base = lua_gettop(L) - narg; /* function index */ lua_pushcfunction(L, traceback); /* push traceback function */ lua_insert(L, base); /* put it under chunk and args */ signal(SIGINT, laction); status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base); signal(SIGINT, SIG_DFL); lua_remove(L, base); /* remove traceback function */ /* force a complete garbage collection in case of errors */ if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0); return status; } static int dolibrary(lua_State *L, const char *name, int clear) { lua_getglobal(L, "require"); lua_pushstring(L, name); return report(L, docall(L, 1, clear)); } struct Smain { int argc; char **argv; int status; }; static void pushargv(lua_State *L, char **argv, int argc, int offset) { int i, j; lua_createtable(L, argc, 0); for (i = offset, j = 1; i < argc; i++, j++) { lua_pushstring(L, argv[i]); lua_rawseti(L, -2, j); } } static int pmain(lua_State *L) { struct Smain *s = (struct Smain *)lua_touserdata(L, 1); globalL = L; lua_gc(L, LUA_GCSTOP, 0); luaL_openlibs(L); lua_gc(L, LUA_GCRESTART, 0); s->status = dolibrary(L, "bcc", 0); if (s->status) return 0; lua_pushstring(L, progname); lua_setglobal(L, "BCC_STANDALONE"); pushargv(L, s->argv, s->argc, 1); lua_setglobal(L, "arg"); s->status = report(L, docall(L, 0, 1)); return 0; } int main(int argc, char **argv) { int status; struct Smain s; lua_State *L = lua_open(); /* create state */ if (L == NULL) { l_message(argv[0], "cannot create state: not enough memory"); return EXIT_FAILURE; } if (geteuid() != 0) { l_message(argv[0], "bcc-lua must be ran as root"); return EXIT_FAILURE; } progname = argv[0]; s.argc = argc; s.argv = argv; s.status = 0; status = lua_cpcall(L, &pmain, &s); report(L, status); lua_close(L); return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS; } bpfcc-0.2.0+git0.02884a026/src/lua/src/squish.lua000077500000000000000000000175351305314114400206720ustar00rootroot00000000000000#!/usr/bin/env lua local short_opts = { v = "verbose", vv = "very_verbose", o = "output", q = "quiet", qq = "very_quiet", g = "debug" } local opts = { use_http = false }; for _, opt in ipairs(arg) do if opt:match("^%-") then local name = opt:match("^%-%-?([^%s=]+)()") name = (short_opts[name] or name):gsub("%-+", "_"); if name:match("^no_") then name = name:sub(4, -1); opts[name] = false; else opts[name] = opt:match("=(.*)$") or true; end else base_path = opt; end end if opts.very_verbose then opts.verbose = true; end if opts.very_quiet then opts.quiet = true; end local noprint = function () end local print_err, print_info, print_verbose, print_debug = noprint, noprint, noprint, noprint; if not opts.very_quiet then print_err = print; end if not opts.quiet then print_info = print; end if opts.verbose or opts.very_verbose then print_verbose = print; end if opts.very_verbose then print_debug = print; end print = print_verbose; local modules, main_files, resources = {}, {}, {}; -- Functions to be called from squishy file -- function Module(name) if modules[name] then print_verbose("Ignoring duplicate module definition for "..name); return function () end end local i = #modules+1; modules[i] = { name = name, url = ___fetch_url }; modules[name] = modules[i]; return function (path) modules[i].path = path; end end function Resource(name, path) local i = #resources+1; resources[i] = { name = name, path = path or name }; return function (path) resources[i].path = path; end end function AutoFetchURL(url) ___fetch_url = url; end function Main(fn) table.insert(main_files, fn); end function Output(fn) if opts.output == nil then out_fn = fn; end end function Option(name) name = name:gsub("%-", "_"); if opts[name] == nil then opts[name] = true; return function (value) opts[name] = value; end else return function () end; end end function GetOption(name) return opts[name:gsub('%-', '_')]; end function Message(message) if not opts.quiet then print_info(message); end end function Error(message) if not opts.very_quiet then print_err(message); end end function Exit() os.exit(1); end -- -- -- -- -- -- -- --- -- -- -- -- -- -- -- -- base_path = (base_path or "."):gsub("/$", "").."/" squishy_file = base_path .. "squishy"; out_fn = opts.output; local ok, err = pcall(dofile, squishy_file); if not ok then print_err("Couldn't read squishy file: "..err); os.exit(1); end if not out_fn then print_err("No output file specified by user or squishy file"); os.exit(1); elseif #main_files == 0 and #modules == 0 and #resources == 0 then print_err("No files, modules or resources. Not going to generate an empty file."); os.exit(1); end local fetch = {}; function fetch.filesystem(path) local f, err = io.open(path); if not f then return false, err; end local data = f:read("*a"); f:close(); return data; end if opts.use_http then function fetch.http(url) local http = require "socket.http"; local body, status = http.request(url); if status == 200 then return body; end return false, "HTTP status code: "..tostring(status); end else function fetch.http(url) return false, "Module not found. Re-squish with --use-http option to fetch it from "..url; end end print_info("Writing "..out_fn.."..."); local f, err = io.open(out_fn, "w+"); if not f then print_err("Couldn't open output file: "..tostring(err)); os.exit(1); end if opts.executable then if opts.executable == true then f:write("#!/usr/bin/env lua\n"); else f:write(opts.executable, "\n"); end end if opts.debug then f:write(require_resource("squish.debug")); end print_verbose("Resolving modules..."); do local LUA_DIRSEP = package.config:sub(1,1); local LUA_PATH_MARK = package.config:sub(5,5); local package_path = package.path:gsub("[^;]+", function (path) if not path:match("^%"..LUA_DIRSEP) then return base_path..path; end end):gsub("/%./", "/"); local package_cpath = package.cpath:gsub("[^;]+", function (path) if not path:match("^%"..LUA_DIRSEP) then return base_path..path; end end):gsub("/%./", "/"); function resolve_module(name, path) name = name:gsub("%.", LUA_DIRSEP); for c in path:gmatch("[^;]+") do c = c:gsub("%"..LUA_PATH_MARK, name); print_debug("Looking for "..c) local f = io.open(c); if f then print_debug("Found!"); f:close(); return c; end end return nil; -- not found end for i, module in ipairs(modules) do if not module.path then module.path = resolve_module(module.name, package_path); if not module.path then print_err("Couldn't resolve module: "..module.name); else -- Strip base_path from resolved path module.path = module.path:gsub("^"..base_path:gsub("%p", "%%%1"), ""); end end end end print_verbose("Packing modules..."); for _, module in ipairs(modules) do local modulename, path = module.name, module.path; if module.path:sub(1,1) ~= "/" then path = base_path..module.path; end print_debug("Packing "..modulename.." ("..path..")..."); local data, err = fetch.filesystem(path); if (not data) and module.url then print_debug("Fetching: ".. module.url:gsub("%?", module.path)) data, err = fetch.http(module.url:gsub("%?", module.path)); end if data then f:write("package.preload['", modulename, "'] = (function (...)\n"); f:write(data); f:write(" end)\n"); if opts.debug then f:write(string.format("package.preload[%q] = ___adjust_chunk(package.preload[%q], %q);\n\n", modulename, modulename, "@"..path)); end else print_err("Couldn't pack module '"..modulename.."': "..(err or "unknown error... path to module file correct?")); os.exit(1); end end if #resources > 0 then print_verbose("Packing resources...") f:write("do local resources = {};\n"); for _, resource in ipairs(resources) do local name, path = resource.name, resource.path; local res_file, err = io.open(base_path..path, "rb"); if not res_file then print_err("Couldn't load resource: "..tostring(err)); os.exit(1); end local data = res_file:read("*a"); local maxequals = 0; data:gsub("(=+)", function (equals_string) maxequals = math.max(maxequals, #equals_string); end); f:write(("resources[%q] = %q"):format(name, data)); --[[ f:write(("resources[%q] = ["):format(name), string.rep("=", maxequals+1), "["); f:write(data); f:write("]", string.rep("=", maxequals+1), "];"); ]] end if opts.virtual_io then local vio = require_resource("vio"); if not vio then print_err("Virtual IO requested but is not enabled in this build of squish"); else -- Insert vio library f:write(vio, "\n") -- Override standard functions to use vio if opening a resource f:write[[local io_open, io_lines = io.open, io.lines; function io.open(fn, mode) if not resources[fn] then return io_open(fn, mode); else return vio.open(resources[fn]); end end function io.lines(fn) if not resources[fn] then return io_lines(fn); else return vio.open(resources[fn]):lines() end end local _dofile = dofile; function dofile(fn) if not resources[fn] then return _dofile(fn); else return assert(loadstring(resources[fn]))(); end end local _loadfile = loadfile; function loadfile(fn) if not resources[fn] then return _loadfile(fn); else return loadstring(resources[fn], "@"..fn); end end ]] end end f:write[[function require_resource(name) return resources[name] or error("resource '"..tostring(name).."' not found"); end end ]] end print_debug("Finalising...") for _, fn in pairs(main_files) do local fin, err = io.open(base_path..fn); if not fin then print_err("Failed to open "..fn..": "..err); os.exit(1); else f:write((fin:read("*a"):gsub("^#.-\n", ""))); fin:close(); end end f:close(); print_info("OK!"); bpfcc-0.2.0+git0.02884a026/src/python/000077500000000000000000000000001305314114400166065ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/python/CMakeLists.txt000066400000000000000000000021151305314114400213450ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") macro(symlink_file SRC DST) execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${SRC} ${DST}) endmacro() symlink_file(${CMAKE_CURRENT_SOURCE_DIR}/bcc ${CMAKE_CURRENT_BINARY_DIR}/bcc) if(NOT PYTHON_CMD) set(PYTHON_CMD "python") endif() set(PIP_INSTALLABLE "${CMAKE_CURRENT_BINARY_DIR}/dist/bcc-${REVISION}.tar.gz") configure_file(setup.py.in ${CMAKE_CURRENT_BINARY_DIR}/setup.py @ONLY) # build the pip installable add_custom_command(OUTPUT ${PIP_INSTALLABLE} COMMAND ${PYTHON_CMD} setup.py sdist WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/bcc/__init__.py ${CMAKE_CURRENT_BINARY_DIR}/setup.py ) add_custom_target(bcc_py ALL DEPENDS ${PIP_INSTALLABLE}) if(EXISTS "/etc/debian_version") set(PYTHON_FLAGS "${PYTHON_FLAGS} --install-layout deb") endif() install(CODE "execute_process(COMMAND ${PYTHON_CMD} setup.py install -f ${PYTHON_FLAGS} --prefix=${CMAKE_INSTALL_PREFIX} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})" COMPONENT python) bpfcc-0.2.0+git0.02884a026/src/python/MANIFEST000066400000000000000000000001371305314114400177400ustar00rootroot00000000000000# file GENERATED by distutils, do NOT edit setup.py bcc/__init__.py bcc/table.py bcc/libbcc.py bpfcc-0.2.0+git0.02884a026/src/python/bcc/000077500000000000000000000000001305314114400173355ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/src/python/bcc/__init__.py000066400000000000000000001226361305314114400214600ustar00rootroot00000000000000# Copyright 2015 PLUMgrid # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import print_function import atexit import ctypes as ct import fcntl import json import os import re import struct import errno import sys basestring = (unicode if sys.version_info[0] < 3 else str) from .libbcc import lib, _CB_TYPE, bcc_symbol, _SYM_CB_TYPE from .table import Table from .perf import Perf from .utils import get_online_cpus _kprobe_limit = 1000 _num_open_probes = 0 # for tests def _get_num_open_probes(): global _num_open_probes return _num_open_probes TRACEFS = "/sys/kernel/debug/tracing" DEBUG_LLVM_IR = 0x1 DEBUG_BPF = 0x2 DEBUG_PREPROCESSOR = 0x4 LOG_BUFFER_SIZE = 65536 class SymbolCache(object): def __init__(self, pid): self.cache = lib.bcc_symcache_new(pid) def resolve(self, addr): """ Return a tuple of the symbol (function), its offset from the beginning of the function, and the module in which it lies. For example: ("start_thread", 0x202, "/usr/lib/.../libpthread-2.24.so") If the symbol cannot be found but we know which module it is in, return the module name and the offset from the beginning of the module. If we don't even know the module, return the absolute address as the offset. """ sym = bcc_symbol() psym = ct.pointer(sym) if lib.bcc_symcache_resolve(self.cache, addr, psym) < 0: if sym.module and sym.offset: return (None, sym.offset, ct.cast(sym.module, ct.c_char_p).value.decode()) return (None, addr, None) return (sym.demangle_name.decode(), sym.offset, ct.cast(sym.module, ct.c_char_p).value.decode()) def resolve_name(self, module, name): addr = ct.c_ulonglong() if lib.bcc_symcache_resolve_name( self.cache, module, name, ct.pointer(addr)) < 0: return -1 return addr.value class PerfType: # From perf_type_id in uapi/linux/perf_event.h HARDWARE = 0 SOFTWARE = 1 class PerfHWConfig: # From perf_hw_id in uapi/linux/perf_event.h CPU_CYCLES = 0 INSTRUCTIONS = 1 CACHE_REFERENCES = 2 CACHE_MISSES = 3 BRANCH_INSTRUCTIONS = 4 BRANCH_MISSES = 5 BUS_CYCLES = 6 STALLED_CYCLES_FRONTEND = 7 STALLED_CYCLES_BACKEND = 8 REF_CPU_CYCLES = 9 class PerfSWConfig: # From perf_sw_id in uapi/linux/perf_event.h CPU_CLOCK = 0 TASK_CLOCK = 1 PAGE_FAULTS = 2 CONTEXT_SWITCHES = 3 CPU_MIGRATIONS = 4 PAGE_FAULTS_MIN = 5 PAGE_FAULTS_MAJ = 6 ALIGNMENT_FAULTS = 7 EMULATION_FAULTS = 8 DUMMY = 9 BPF_OUTPUT = 10 class BPF(object): # From bpf_prog_type in uapi/linux/bpf.h SOCKET_FILTER = 1 KPROBE = 2 SCHED_CLS = 3 SCHED_ACT = 4 TRACEPOINT = 5 XDP = 6 PERF_EVENT = 7 _probe_repl = re.compile("[^a-zA-Z0-9_]") _sym_caches = {} _auto_includes = { "linux/time.h": ["time"], "linux/fs.h": ["fs", "file"], "linux/blkdev.h": ["bio", "request"], "linux/slab.h": ["alloc"], "linux/netdevice.h": ["sk_buff", "net_device"] } # BPF timestamps come from the monotonic clock. To be able to filter # and compare them from Python, we need to invoke clock_gettime. # Adapted from http://stackoverflow.com/a/1205762 CLOCK_MONOTONIC = 1 # see class timespec(ct.Structure): _fields_ = [('tv_sec', ct.c_long), ('tv_nsec', ct.c_long)] _librt = ct.CDLL('librt.so.1', use_errno=True) _clock_gettime = _librt.clock_gettime _clock_gettime.argtypes = [ct.c_int, ct.POINTER(timespec)] @classmethod def monotonic_time(cls): """monotonic_time() Returns the system monotonic time from clock_gettime, using the CLOCK_MONOTONIC constant. The time returned is in nanoseconds. """ t = cls.timespec() if cls._clock_gettime(cls.CLOCK_MONOTONIC, ct.pointer(t)) != 0: errno = ct.get_errno() raise OSError(errno, os.strerror(errno)) return t.tv_sec * 1e9 + t.tv_nsec @classmethod def generate_auto_includes(cls, program_words): """ Generates #include statements automatically based on a set of recognized types such as sk_buff and bio. The input is all the words that appear in the BPF program, and the output is a (possibly empty) string of #include statements, such as "#include ". """ headers = "" for header, keywords in cls._auto_includes.items(): for keyword in keywords: for word in program_words: if keyword in word and header not in headers: headers += "#include <%s>\n" % header return headers # defined for compatibility reasons, to be removed Table = Table class Function(object): def __init__(self, bpf, name, fd): self.bpf = bpf self.name = name self.fd = fd @staticmethod def _find_file(filename): """ If filename is invalid, search in ./ of argv[0] """ if filename: if not os.path.isfile(filename): t = "/".join([os.path.abspath(os.path.dirname(sys.argv[0])), filename]) if os.path.isfile(t): filename = t else: raise Exception("Could not find file %s" % filename) return filename @staticmethod def find_exe(bin_path): """ find_exe(bin_path) Traverses the PATH environment variable, looking for the first directory that contains an executable file named bin_path, and returns the full path to that file, or None if no such file can be found. This is meant to replace invocations of the "which" shell utility, which doesn't have portable semantics for skipping aliases. """ # Source: http://stackoverflow.com/a/377028 def is_exe(fpath): return os.path.isfile(fpath) and \ os.access(fpath, os.X_OK) fpath, fname = os.path.split(bin_path) if fpath: if is_exe(bin_path): return bin_path else: for path in os.environ["PATH"].split(os.pathsep): path = path.strip('"') exe_file = os.path.join(path, bin_path) if is_exe(exe_file): return exe_file return None def __init__(self, src_file="", hdr_file="", text=None, cb=None, debug=0, cflags=[], usdt_contexts=[]): """Create a new BPF module with the given source code. Note: All fields are marked as optional, but either `src_file` or `text` must be supplied, and not both. Args: src_file (Optional[str]): Path to a source file for the module hdr_file (Optional[str]): Path to a helper header file for the `src_file` text (Optional[str]): Contents of a source file for the module debug (Optional[int]): Flags used for debug prints, can be |'d together DEBUG_LLVM_IR: print LLVM IR to stderr DEBUG_BPF: print BPF bytecode to stderr DEBUG_PREPROCESSOR: print Preprocessed C file to stderr """ self.open_kprobes = {} self.open_uprobes = {} self.open_tracepoints = {} self.open_perf_events = {} self.tracefile = None atexit.register(self.cleanup) self._reader_cb_impl = _CB_TYPE(BPF._reader_cb) self._user_cb = cb self.debug = debug self.funcs = {} self.tables = {} cflags_array = (ct.c_char_p * len(cflags))() for i, s in enumerate(cflags): cflags_array[i] = s.encode("ascii") if text: for usdt_context in usdt_contexts: usdt_text = usdt_context.get_text() if usdt_text is None: raise Exception("can't generate USDT probe arguments; " + "possible cause is missing pid when a " + "probe in a shared object has multiple " + "locations") text = usdt_text + text if text: self.module = lib.bpf_module_create_c_from_string(text.encode("ascii"), self.debug, cflags_array, len(cflags_array)) else: src_file = BPF._find_file(src_file) hdr_file = BPF._find_file(hdr_file) if src_file.endswith(".b"): self.module = lib.bpf_module_create_b(src_file.encode("ascii"), hdr_file.encode("ascii"), self.debug) else: self.module = lib.bpf_module_create_c(src_file.encode("ascii"), self.debug, cflags_array, len(cflags_array)) if not self.module: raise Exception("Failed to compile BPF module %s" % src_file) for usdt_context in usdt_contexts: usdt_context.attach_uprobes(self) # If any "kprobe__" or "tracepoint__" prefixed functions were defined, # they will be loaded and attached here. self._trace_autoload() def load_funcs(self, prog_type=KPROBE): """load_funcs(prog_type=KPROBE) Load all functions in this BPF module with the given type. Returns a list of the function handles.""" fns = [] for i in range(0, lib.bpf_num_functions(self.module)): func_name = lib.bpf_function_name(self.module, i).decode() fns.append(self.load_func(func_name, prog_type)) return fns def load_func(self, func_name, prog_type): if func_name in self.funcs: return self.funcs[func_name] if not lib.bpf_function_start(self.module, func_name.encode("ascii")): raise Exception("Unknown program %s" % func_name) buffer_len = LOG_BUFFER_SIZE while True: log_buf = ct.create_string_buffer(buffer_len) if self.debug else None fd = lib.bpf_prog_load(prog_type, lib.bpf_function_start(self.module, func_name.encode("ascii")), lib.bpf_function_size(self.module, func_name.encode("ascii")), lib.bpf_module_license(self.module), lib.bpf_module_kern_version(self.module), log_buf, ct.sizeof(log_buf) if log_buf else 0) if fd < 0 and ct.get_errno() == errno.ENOSPC and self.debug: buffer_len <<= 1 else: break if self.debug & DEBUG_BPF and log_buf.value: print(log_buf.value.decode(), file=sys.stderr) if fd < 0: atexit.register(self.donothing) if ct.get_errno() == errno.EPERM: raise Exception("Need super-user privilges to run") errstr = os.strerror(ct.get_errno()) raise Exception("Failed to load BPF program %s: %s" % (func_name, errstr)) fn = BPF.Function(self, func_name, fd) self.funcs[func_name] = fn return fn def dump_func(self, func_name): """ Return the eBPF bytecodes for the specified function as a string """ if not lib.bpf_function_start(self.module, func_name.encode("ascii")): raise Exception("Unknown program %s" % func_name) start, = lib.bpf_function_start(self.module, func_name.encode("ascii")), size, = lib.bpf_function_size(self.module, func_name.encode("ascii")), return ct.string_at(start, size) str2ctype = { u"_Bool": ct.c_bool, u"char": ct.c_char, u"wchar_t": ct.c_wchar, u"unsigned char": ct.c_ubyte, u"short": ct.c_short, u"unsigned short": ct.c_ushort, u"int": ct.c_int, u"unsigned int": ct.c_uint, u"long": ct.c_long, u"unsigned long": ct.c_ulong, u"long long": ct.c_longlong, u"unsigned long long": ct.c_ulonglong, u"float": ct.c_float, u"double": ct.c_double, u"long double": ct.c_longdouble } @staticmethod def _decode_table_type(desc): if isinstance(desc, basestring): return BPF.str2ctype[desc] anon = [] fields = [] for t in desc[1]: if len(t) == 2: fields.append((t[0], BPF._decode_table_type(t[1]))) elif len(t) == 3: if isinstance(t[2], list): fields.append((t[0], BPF._decode_table_type(t[1]) * t[2][0])) elif isinstance(t[2], int): fields.append((t[0], BPF._decode_table_type(t[1]), t[2])) elif isinstance(t[2], basestring) and ( t[2] == u"union" or t[2] == u"struct"): name = t[0] if name == "": name = "__anon%d" % len(anon) anon.append(name) fields.append((name, BPF._decode_table_type(t))) else: raise Exception("Failed to decode type %s" % str(t)) else: raise Exception("Failed to decode type %s" % str(t)) base = ct.Structure if len(desc) > 2: if desc[2] == u"union": base = ct.Union elif desc[2] == u"struct": base = ct.Structure cls = type(str(desc[0]), (base,), dict(_anonymous_=anon, _fields_=fields)) return cls def get_table(self, name, keytype=None, leaftype=None, reducer=None): map_id = lib.bpf_table_id(self.module, name.encode("ascii")) map_fd = lib.bpf_table_fd(self.module, name.encode("ascii")) if map_fd < 0: raise KeyError if not keytype: key_desc = lib.bpf_table_key_desc(self.module, name.encode("ascii")) if not key_desc: raise Exception("Failed to load BPF Table %s key desc" % name) keytype = BPF._decode_table_type(json.loads(key_desc.decode())) if not leaftype: leaf_desc = lib.bpf_table_leaf_desc(self.module, name.encode("ascii")) if not leaf_desc: raise Exception("Failed to load BPF Table %s leaf desc" % name) leaftype = BPF._decode_table_type(json.loads(leaf_desc.decode())) return Table(self, map_id, map_fd, keytype, leaftype, reducer=reducer) def __getitem__(self, key): if key not in self.tables: self.tables[key] = self.get_table(key) return self.tables[key] def __setitem__(self, key, leaf): self.tables[key] = leaf def __len__(self): return len(self.tables) def __delitem__(self, key): del self.tables[key] def __iter__(self): return self.tables.__iter__() def _reader_cb(self, pid, callchain_num, callchain): if self._user_cb: cc = tuple(callchain[i] for i in range(0, callchain_num)) self._user_cb(pid, cc) @staticmethod def attach_raw_socket(fn, dev): if not isinstance(fn, BPF.Function): raise Exception("arg 1 must be of type BPF.Function") sock = lib.bpf_open_raw_sock(dev.encode("ascii")) if sock < 0: errstr = os.strerror(ct.get_errno()) raise Exception("Failed to open raw device %s: %s" % (dev, errstr)) res = lib.bpf_attach_socket(sock, fn.fd) if res < 0: errstr = os.strerror(ct.get_errno()) raise Exception("Failed to attach BPF to device %s: %s" % (dev, errstr)) fn.sock = sock @staticmethod def get_kprobe_functions(event_re): with open("%s/../kprobes/blacklist" % TRACEFS) as blacklist_file: blacklist = set([line.rstrip().split()[1] for line in blacklist_file]) fns = [] with open("%s/available_filter_functions" % TRACEFS) as avail_file: for line in avail_file: fn = line.rstrip().split()[0] if re.match(event_re, fn) and fn not in blacklist: fns.append(fn) return set(fns) # Some functions may appear more than once def _check_probe_quota(self, num_new_probes): global _num_open_probes if _num_open_probes + num_new_probes > _kprobe_limit: raise Exception("Number of open probes would exceed global quota") def _add_kprobe(self, name, probe): global _num_open_probes self.open_kprobes[name] = probe _num_open_probes += 1 def _del_kprobe(self, name): global _num_open_probes del self.open_kprobes[name] _num_open_probes -= 1 def attach_kprobe(self, event="", fn_name="", event_re="", pid=-1, cpu=0, group_fd=-1): # allow the caller to glob multiple functions together if event_re: matches = BPF.get_kprobe_functions(event_re) self._check_probe_quota(len(matches)) for line in matches: try: self.attach_kprobe(event=line, fn_name=fn_name, pid=pid, cpu=cpu, group_fd=group_fd) except: pass return event = str(event) self._check_probe_quota(1) fn = self.load_func(fn_name, BPF.KPROBE) ev_name = "p_" + event.replace("+", "_").replace(".", "_") res = lib.bpf_attach_kprobe(fn.fd, 0, ev_name.encode("ascii"), event.encode("ascii"), pid, cpu, group_fd, self._reader_cb_impl, ct.cast(id(self), ct.py_object)) res = ct.cast(res, ct.c_void_p) if not res: raise Exception("Failed to attach BPF to kprobe") self._add_kprobe(ev_name, res) return self def detach_kprobe(self, event): event = str(event) ev_name = "p_" + event.replace("+", "_").replace(".", "_") if ev_name not in self.open_kprobes: raise Exception("Kprobe %s is not attached" % event) lib.perf_reader_free(self.open_kprobes[ev_name]) res = lib.bpf_detach_kprobe(ev_name.encode("ascii")) if res < 0: raise Exception("Failed to detach BPF from kprobe") self._del_kprobe(ev_name) def attach_kretprobe(self, event="", fn_name="", event_re="", pid=-1, cpu=0, group_fd=-1): # allow the caller to glob multiple functions together if event_re: for line in BPF.get_kprobe_functions(event_re): try: self.attach_kretprobe(event=line, fn_name=fn_name, pid=pid, cpu=cpu, group_fd=group_fd) except: pass return event = str(event) self._check_probe_quota(1) fn = self.load_func(fn_name, BPF.KPROBE) ev_name = "r_" + event.replace("+", "_").replace(".", "_") res = lib.bpf_attach_kprobe(fn.fd, 1, ev_name.encode("ascii"), event.encode("ascii"), pid, cpu, group_fd, self._reader_cb_impl, ct.cast(id(self), ct.py_object)) res = ct.cast(res, ct.c_void_p) if not res: raise Exception("Failed to attach BPF to kprobe") self._add_kprobe(ev_name, res) return self def detach_kretprobe(self, event): event = str(event) ev_name = "r_" + event.replace("+", "_").replace(".", "_") if ev_name not in self.open_kprobes: raise Exception("Kretprobe %s is not attached" % event) lib.perf_reader_free(self.open_kprobes[ev_name]) res = lib.bpf_detach_kprobe(ev_name.encode("ascii")) if res < 0: raise Exception("Failed to detach BPF from kprobe") self._del_kprobe(ev_name) @staticmethod def attach_xdp(dev, fn): ''' This function attaches a BPF function to a device on the device driver level (XDP) ''' if not isinstance(fn, BPF.Function): raise Exception("arg 1 must be of type BPF.Function") res = lib.bpf_attach_xdp(dev.encode("ascii"), fn.fd) if res < 0: err_no = ct.get_errno() if err_no == errno.EBADMSG: raise Exception("Internal error while attaching BPF to device,"+ " try increasing the debug level!") else: errstr = os.strerror(err_no) raise Exception("Failed to attach BPF to device %s: %s" % (dev, errstr)) @staticmethod def remove_xdp(dev): ''' This function removes any BPF function from a device on the device driver level (XDP) ''' res = lib.bpf_attach_xdp(dev.encode("ascii"), -1) if res < 0: errstr = os.strerror(ct.get_errno()) raise Exception("Failed to detach BPF from device %s: %s" % (dev, errstr)) @classmethod def _check_path_symbol(cls, module, symname, addr, pid): sym = bcc_symbol() psym = ct.pointer(sym) c_pid = 0 if pid == -1 else pid if lib.bcc_resolve_symname(module.encode("ascii"), symname.encode("ascii"), addr or 0x0, c_pid, psym) < 0: if not sym.module: raise Exception("could not find library %s" % module) lib.bcc_procutils_free(sym.module) raise Exception("could not determine address of symbol %s" % symname) module_path = ct.cast(sym.module, ct.c_char_p).value.decode() lib.bcc_procutils_free(sym.module) return module_path, sym.offset @staticmethod def find_library(libname): res = lib.bcc_procutils_which_so(libname.encode("ascii"), 0) if not res: return None libpath = ct.cast(res, ct.c_char_p).value.decode() lib.bcc_procutils_free(res) return libpath @staticmethod def get_tracepoints(tp_re): results = [] events_dir = os.path.join(TRACEFS, "events") for category in os.listdir(events_dir): cat_dir = os.path.join(events_dir, category) if not os.path.isdir(cat_dir): continue for event in os.listdir(cat_dir): evt_dir = os.path.join(cat_dir, event) if os.path.isdir(evt_dir): tp = ("%s:%s" % (category, event)) if re.match(tp_re, tp): results.append(tp) return results def attach_tracepoint(self, tp="", tp_re="", fn_name="", pid=-1, cpu=0, group_fd=-1): """attach_tracepoint(tp="", tp_re="", fn_name="", pid=-1, cpu=0, group_fd=-1) Run the bpf function denoted by fn_name every time the kernel tracepoint specified by 'tp' is hit. The optional parameters pid, cpu, and group_fd can be used to filter the probe. The tracepoint specification is simply the tracepoint category and the tracepoint name, separated by a colon. For example: sched:sched_switch, syscalls:sys_enter_bind, etc. Instead of a tracepoint name, a regular expression can be provided in tp_re. The program will then attach to tracepoints that match the provided regular expression. To obtain a list of kernel tracepoints, use the tplist tool or cat the file /sys/kernel/debug/tracing/available_events. Examples: BPF(text).attach_tracepoint(tp="sched:sched_switch", fn_name="on_switch") BPF(text).attach_tracepoint(tp_re="sched:.*", fn_name="on_switch") """ if tp_re: for tp in BPF.get_tracepoints(tp_re): self.attach_tracepoint(tp=tp, fn_name=fn_name, pid=pid, cpu=cpu, group_fd=group_fd) return fn = self.load_func(fn_name, BPF.TRACEPOINT) (tp_category, tp_name) = tp.split(':') res = lib.bpf_attach_tracepoint(fn.fd, tp_category.encode("ascii"), tp_name.encode("ascii"), pid, cpu, group_fd, self._reader_cb_impl, ct.cast(id(self), ct.py_object)) res = ct.cast(res, ct.c_void_p) if not res: raise Exception("Failed to attach BPF to tracepoint") self.open_tracepoints[tp] = res return self def detach_tracepoint(self, tp=""): """detach_tracepoint(tp="") Stop running a bpf function that is attached to the kernel tracepoint specified by 'tp'. Example: bpf.detach_tracepoint("sched:sched_switch") """ if tp not in self.open_tracepoints: raise Exception("Tracepoint %s is not attached" % tp) lib.perf_reader_free(self.open_tracepoints[tp]) (tp_category, tp_name) = tp.split(':') res = lib.bpf_detach_tracepoint(tp_category.encode("ascii"), tp_name.encode("ascii")) if res < 0: raise Exception("Failed to detach BPF from tracepoint") del self.open_tracepoints[tp] def _attach_perf_event(self, progfd, ev_type, ev_config, sample_period, sample_freq, pid, cpu, group_fd): res = lib.bpf_attach_perf_event(progfd, ev_type, ev_config, sample_period, sample_freq, pid, cpu, group_fd) if res < 0: raise Exception("Failed to attach BPF to perf event") return res def attach_perf_event(self, ev_type=-1, ev_config=-1, fn_name="", sample_period=0, sample_freq=0, pid=-1, cpu=-1, group_fd=-1): fn = self.load_func(fn_name, BPF.PERF_EVENT) res = {} if cpu >= 0: res[cpu] = self._attach_perf_event(fn.fd, ev_type, ev_config, sample_period, sample_freq, pid, cpu, group_fd) else: for i in get_online_cpus(): res[i] = self._attach_perf_event(fn.fd, ev_type, ev_config, sample_period, sample_freq, pid, i, group_fd) self.open_perf_events[(ev_type, ev_config)] = res def detach_perf_event(self, ev_type=-1, ev_config=-1): try: fds = self.open_perf_events[(ev_type, ev_config)] except KeyError: raise Exception("Perf event type {} config {} not attached".format( ev_type, ev_config)) for fd in fds.values(): os.close(fd) res = lib.bpf_detach_perf_event(ev_type, ev_config) if res < 0: raise Exception("Failed to detach BPF from perf event") del self.open_perf_events[(ev_type, ev_config)] return res def _add_uprobe(self, name, probe): global _num_open_probes self.open_uprobes[name] = probe _num_open_probes += 1 def _del_uprobe(self, name): global _num_open_probes del self.open_uprobes[name] _num_open_probes -= 1 @staticmethod def get_user_functions(name, sym_re): return set([name for (name, _) in BPF.get_user_functions_and_addresses(name, sym_re)]) @staticmethod def get_user_addresses(name, sym_re): """ We are returning addresses here instead of symbol names because it turns out that the same name may appear multiple times with different addresses, and the same address may appear multiple times with the same name. We can't attach a uprobe to the same address more than once, so it makes sense to return the unique set of addresses that are mapped to a symbol that matches the provided regular expression. """ return set([address for (_, address) in BPF.get_user_functions_and_addresses(name, sym_re)]) @staticmethod def get_user_functions_and_addresses(name, sym_re): addresses = [] def sym_cb(sym_name, addr): if re.match(sym_re, sym_name): addresses.append((sym_name, addr)) return 0 res = lib.bcc_foreach_symbol(name, _SYM_CB_TYPE(sym_cb)) if res < 0: raise Exception("Error %d enumerating symbols in %s" % (res, name)) return addresses def attach_uprobe(self, name="", sym="", sym_re="", addr=None, fn_name="", pid=-1, cpu=0, group_fd=-1): """attach_uprobe(name="", sym="", sym_re="", addr=None, fn_name="" pid=-1, cpu=0, group_fd=-1) Run the bpf function denoted by fn_name every time the symbol sym in the library or binary 'name' is encountered. The real address addr may be supplied in place of sym. Optional parameters pid, cpu, and group_fd can be used to filter the probe. Instead of a symbol name, a regular expression can be provided in sym_re. The uprobe will then attach to symbols that match the provided regular expression. Libraries can be given in the name argument without the lib prefix, or with the full path (/usr/lib/...). Binaries can be given only with the full path (/bin/sh). If a PID is given, the uprobe will attach to the version of the library used by the process. Example: BPF(text).attach_uprobe("c", "malloc") BPF(text).attach_uprobe("/usr/bin/python", "main") """ name = str(name) if sym_re: addresses = BPF.get_user_addresses(name, sym_re) self._check_probe_quota(len(addresses)) for sym_addr in addresses: self.attach_uprobe(name=name, addr=sym_addr, fn_name=fn_name, pid=pid, cpu=cpu, group_fd=group_fd) return (path, addr) = BPF._check_path_symbol(name, sym, addr, pid) self._check_probe_quota(1) fn = self.load_func(fn_name, BPF.KPROBE) ev_name = "p_%s_0x%x" % (self._probe_repl.sub("_", path), addr) res = lib.bpf_attach_uprobe(fn.fd, 0, ev_name.encode("ascii"), path.encode("ascii"), addr, pid, cpu, group_fd, self._reader_cb_impl, ct.cast(id(self), ct.py_object)) res = ct.cast(res, ct.c_void_p) if not res: raise Exception("Failed to attach BPF to uprobe") self._add_uprobe(ev_name, res) return self def detach_uprobe(self, name="", sym="", addr=None, pid=-1): """detach_uprobe(name="", sym="", addr=None, pid=-1) Stop running a bpf function that is attached to symbol 'sym' in library or binary 'name'. """ name = str(name) (path, addr) = BPF._check_path_symbol(name, sym, addr, pid) ev_name = "p_%s_0x%x" % (self._probe_repl.sub("_", path), addr) if ev_name not in self.open_uprobes: raise Exception("Uprobe %s is not attached" % ev_name) lib.perf_reader_free(self.open_uprobes[ev_name]) res = lib.bpf_detach_uprobe(ev_name.encode("ascii")) if res < 0: raise Exception("Failed to detach BPF from uprobe") self._del_uprobe(ev_name) def attach_uretprobe(self, name="", sym="", sym_re="", addr=None, fn_name="", pid=-1, cpu=0, group_fd=-1): """attach_uretprobe(name="", sym="", sym_re="", addr=None, fn_name="" pid=-1, cpu=0, group_fd=-1) Run the bpf function denoted by fn_name every time the symbol sym in the library or binary 'name' finishes execution. See attach_uprobe for meaning of additional parameters. """ if sym_re: for sym_addr in BPF.get_user_addresses(name, sym_re): self.attach_uretprobe(name=name, addr=sym_addr, fn_name=fn_name, pid=pid, cpu=cpu, group_fd=group_fd) return name = str(name) (path, addr) = BPF._check_path_symbol(name, sym, addr, pid) self._check_probe_quota(1) fn = self.load_func(fn_name, BPF.KPROBE) ev_name = "r_%s_0x%x" % (self._probe_repl.sub("_", path), addr) res = lib.bpf_attach_uprobe(fn.fd, 1, ev_name.encode("ascii"), path.encode("ascii"), addr, pid, cpu, group_fd, self._reader_cb_impl, ct.cast(id(self), ct.py_object)) res = ct.cast(res, ct.c_void_p) if not res: raise Exception("Failed to attach BPF to uprobe") self._add_uprobe(ev_name, res) return self def detach_uretprobe(self, name="", sym="", addr=None, pid=-1): """detach_uretprobe(name="", sym="", addr=None, pid=-1) Stop running a bpf function that is attached to symbol 'sym' in library or binary 'name'. """ name = str(name) (path, addr) = BPF._check_path_symbol(name, sym, addr, pid) ev_name = "r_%s_0x%x" % (self._probe_repl.sub("_", path), addr) if ev_name not in self.open_uprobes: raise Exception("Uretprobe %s is not attached" % ev_name) lib.perf_reader_free(self.open_uprobes[ev_name]) res = lib.bpf_detach_uprobe(ev_name.encode("ascii")) if res < 0: raise Exception("Failed to detach BPF from uprobe") self._del_uprobe(ev_name) def _trace_autoload(self): for i in range(0, lib.bpf_num_functions(self.module)): func_name = str(lib.bpf_function_name(self.module, i).decode()) if func_name.startswith("kprobe__"): fn = self.load_func(func_name, BPF.KPROBE) self.attach_kprobe(event=fn.name[8:], fn_name=fn.name) elif func_name.startswith("kretprobe__"): fn = self.load_func(func_name, BPF.KPROBE) self.attach_kretprobe(event=fn.name[11:], fn_name=fn.name) elif func_name.startswith("tracepoint__"): fn = self.load_func(func_name, BPF.TRACEPOINT) tp = fn.name[len("tracepoint__"):].replace("__", ":") self.attach_tracepoint(tp=tp, fn_name=fn.name) def trace_open(self, nonblocking=False): """trace_open(nonblocking=False) Open the trace_pipe if not already open """ if not self.tracefile: self.tracefile = open("%s/trace_pipe" % TRACEFS) if nonblocking: fd = self.tracefile.fileno() fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) return self.tracefile def trace_fields(self, nonblocking=False): """trace_fields(nonblocking=False) Read from the kernel debug trace pipe and return a tuple of the fields (task, pid, cpu, flags, timestamp, msg) or None if no line was read (nonblocking=True) """ try: while True: line = self.trace_readline(nonblocking) if not line and nonblocking: return (None,) * 6 # don't print messages related to lost events if line.startswith("CPU:"): continue task = line[:16].lstrip() line = line[17:] ts_end = line.find(":") pid, cpu, flags, ts = line[:ts_end].split() cpu = cpu[1:-1] msg = line[ts_end + 4:] return (task, int(pid), int(cpu), flags, float(ts), msg) except KeyboardInterrupt: exit() def trace_readline(self, nonblocking=False): """trace_readline(nonblocking=False) Read from the kernel debug trace pipe and return one line If nonblocking is False, this will block until ctrl-C is pressed. """ trace = self.trace_open(nonblocking) line = None try: line = trace.readline(1024).rstrip() except IOError: pass except KeyboardInterrupt: exit() return line def trace_print(self, fmt=None): """trace_print(self, fmt=None) Read from the kernel debug trace pipe and print on stdout. If fmt is specified, apply as a format string to the output. See trace_fields for the members of the tuple example: trace_print(fmt="pid {1}, msg = {5}") """ try: while True: if fmt: fields = self.trace_fields(nonblocking=False) if not fields: continue line = fmt.format(*fields) else: line = self.trace_readline(nonblocking=False) print(line) sys.stdout.flush() except KeyboardInterrupt: exit() @staticmethod def _sym_cache(pid): """_sym_cache(pid) Returns a symbol cache for the specified PID. The kernel symbol cache is accessed by providing any PID less than zero. """ if pid < 0 and pid != -1: pid = -1 if not pid in BPF._sym_caches: BPF._sym_caches[pid] = SymbolCache(pid) return BPF._sym_caches[pid] @staticmethod def sym(addr, pid, show_module=False, show_offset=False): """sym(addr, pid, show_module=False, show_offset=False) Translate a memory address into a function name for a pid, which is returned. When show_module is True, the module name is also included. When show_offset is True, the instruction offset as a hexadecimal number is also included in the string. A pid of less than zero will access the kernel symbol cache. Example output when both show_module and show_offset are True: "start_thread+0x202 [libpthread-2.24.so]" Example output when both show_module and show_offset are False: "start_thread" """ name, offset, module = BPF._sym_cache(pid).resolve(addr) offset = "+0x%x" % offset if show_offset and name is not None else "" name = name or "[unknown]" name = name + offset module = " [%s]" % os.path.basename(module) if show_module else "" return name + module @staticmethod def ksym(addr, show_module=False, show_offset=False): """ksym(addr) Translate a kernel memory address into a kernel function name, which is returned. When show_module is True, the module name ("kernel") is also included. When show_offset is true, the instruction offset as a hexadecimal number is also included in the string. Example output when both show_module and show_offset are True: "default_idle+0x0 [kernel]" """ return BPF.sym(addr, -1, show_module, show_offset) @staticmethod def ksymname(name): """ksymname(name) Translate a kernel name into an address. This is the reverse of ksym. Returns -1 when the function name is unknown.""" return BPF._sym_cache(-1).resolve_name(None, name) def num_open_kprobes(self): """num_open_kprobes() Get the number of open K[ret]probes. Can be useful for scenarios where event_re is used while attaching and detaching probes. Excludes perf_events readers. """ return len([k for k in self.open_kprobes.keys() if isinstance(k, str)]) def num_open_uprobes(self): """num_open_uprobes() Get the number of open U[ret]probes. """ return len(self.open_uprobes) def num_open_tracepoints(self): """num_open_tracepoints() Get the number of open tracepoints. """ return len(self.open_tracepoints) def kprobe_poll(self, timeout = -1): """kprobe_poll(self) Poll from the ring buffers for all of the open kprobes, calling the cb() that was given in the BPF constructor for each entry. """ try: readers = (ct.c_void_p * len(self.open_kprobes))() for i, v in enumerate(self.open_kprobes.values()): readers[i] = v lib.perf_reader_poll(len(self.open_kprobes), readers, timeout) except KeyboardInterrupt: exit() def donothing(self): """the do nothing exit handler""" def cleanup(self): for k, v in list(self.open_kprobes.items()): lib.perf_reader_free(v) # non-string keys here include the perf_events reader if isinstance(k, str): lib.bpf_detach_kprobe(str(k).encode("ascii")) self._del_kprobe(k) for k, v in list(self.open_uprobes.items()): lib.perf_reader_free(v) lib.bpf_detach_uprobe(str(k).encode("ascii")) self._del_uprobe(k) for k, v in self.open_tracepoints.items(): lib.perf_reader_free(v) (tp_category, tp_name) = k.split(':') lib.bpf_detach_tracepoint(tp_category.encode("ascii"), tp_name.encode("ascii")) self.open_tracepoints.clear() for (ev_type, ev_config) in list(self.open_perf_events.keys()): self.detach_perf_event(ev_type, ev_config) if self.tracefile: self.tracefile.close() self.tracefile = None if self.module: lib.bpf_module_destroy(self.module) self.module = None def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.cleanup() from .usdt import USDT, USDTException bpfcc-0.2.0+git0.02884a026/src/python/bcc/libbcc.py000066400000000000000000000226731305314114400211370ustar00rootroot00000000000000# Copyright 2015 PLUMgrid # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import ctypes as ct lib = ct.CDLL("libbcc.so.0", use_errno=True) # keep in sync with bpf_common.h lib.bpf_module_create_b.restype = ct.c_void_p lib.bpf_module_create_b.argtypes = [ct.c_char_p, ct.c_char_p, ct.c_uint] lib.bpf_module_create_c.restype = ct.c_void_p lib.bpf_module_create_c.argtypes = [ct.c_char_p, ct.c_uint, ct.POINTER(ct.c_char_p), ct.c_int] lib.bpf_module_create_c_from_string.restype = ct.c_void_p lib.bpf_module_create_c_from_string.argtypes = [ct.c_char_p, ct.c_uint, ct.POINTER(ct.c_char_p), ct.c_int] lib.bpf_module_destroy.restype = None lib.bpf_module_destroy.argtypes = [ct.c_void_p] lib.bpf_module_license.restype = ct.c_char_p lib.bpf_module_license.argtypes = [ct.c_void_p] lib.bpf_module_kern_version.restype = ct.c_uint lib.bpf_module_kern_version.argtypes = [ct.c_void_p] lib.bpf_num_functions.restype = ct.c_ulonglong lib.bpf_num_functions.argtypes = [ct.c_void_p] lib.bpf_function_name.restype = ct.c_char_p lib.bpf_function_name.argtypes = [ct.c_void_p, ct.c_ulonglong] lib.bpf_function_start.restype = ct.c_void_p lib.bpf_function_start.argtypes = [ct.c_void_p, ct.c_char_p] lib.bpf_function_size.restype = ct.c_size_t lib.bpf_function_size.argtypes = [ct.c_void_p, ct.c_char_p] lib.bpf_table_id.restype = ct.c_ulonglong lib.bpf_table_id.argtypes = [ct.c_void_p, ct.c_char_p] lib.bpf_table_fd.restype = ct.c_int lib.bpf_table_fd.argtypes = [ct.c_void_p, ct.c_char_p] lib.bpf_table_type_id.restype = ct.c_int lib.bpf_table_type_id.argtypes = [ct.c_void_p, ct.c_ulonglong] lib.bpf_table_max_entries_id.restype = ct.c_ulonglong lib.bpf_table_max_entries_id.argtypes = [ct.c_void_p, ct.c_ulonglong] lib.bpf_table_flags_id.restype = ct.c_int lib.bpf_table_flags_id.argtypes = [ct.c_void_p, ct.c_ulonglong] lib.bpf_table_key_desc.restype = ct.c_char_p lib.bpf_table_key_desc.argtypes = [ct.c_void_p, ct.c_char_p] lib.bpf_table_leaf_desc.restype = ct.c_char_p lib.bpf_table_leaf_desc.argtypes = [ct.c_void_p, ct.c_char_p] lib.bpf_table_key_snprintf.restype = ct.c_int lib.bpf_table_key_snprintf.argtypes = [ct.c_void_p, ct.c_ulonglong, ct.c_char_p, ct.c_ulonglong, ct.c_void_p] lib.bpf_table_leaf_snprintf.restype = ct.c_int lib.bpf_table_leaf_snprintf.argtypes = [ct.c_void_p, ct.c_ulonglong, ct.c_char_p, ct.c_ulonglong, ct.c_void_p] lib.bpf_table_key_sscanf.restype = ct.c_int lib.bpf_table_key_sscanf.argtypes = [ct.c_void_p, ct.c_ulonglong, ct.c_char_p, ct.c_void_p] lib.bpf_table_leaf_sscanf.restype = ct.c_int lib.bpf_table_leaf_sscanf.argtypes = [ct.c_void_p, ct.c_ulonglong, ct.c_char_p, ct.c_void_p] # keep in sync with libbpf.h lib.bpf_get_next_key.restype = ct.c_int lib.bpf_get_next_key.argtypes = [ct.c_int, ct.c_void_p, ct.c_void_p] lib.bpf_lookup_elem.restype = ct.c_int lib.bpf_lookup_elem.argtypes = [ct.c_int, ct.c_void_p, ct.c_void_p] lib.bpf_update_elem.restype = ct.c_int lib.bpf_update_elem.argtypes = [ct.c_int, ct.c_void_p, ct.c_void_p, ct.c_ulonglong] lib.bpf_delete_elem.restype = ct.c_int lib.bpf_delete_elem.argtypes = [ct.c_int, ct.c_void_p] lib.bpf_open_raw_sock.restype = ct.c_int lib.bpf_open_raw_sock.argtypes = [ct.c_char_p] lib.bpf_attach_socket.restype = ct.c_int lib.bpf_attach_socket.argtypes = [ct.c_int, ct.c_int] lib.bpf_prog_load.restype = ct.c_int lib.bpf_prog_load.argtypes = [ct.c_int, ct.c_void_p, ct.c_size_t, ct.c_char_p, ct.c_uint, ct.c_char_p, ct.c_uint] lib.bpf_attach_kprobe.restype = ct.c_void_p _CB_TYPE = ct.CFUNCTYPE(None, ct.py_object, ct.c_int, ct.c_ulonglong, ct.POINTER(ct.c_ulonglong)) _RAW_CB_TYPE = ct.CFUNCTYPE(None, ct.py_object, ct.c_void_p, ct.c_int) lib.bpf_attach_kprobe.argtypes = [ct.c_int, ct.c_int, ct.c_char_p, ct.c_char_p, ct.c_int, ct.c_int, ct.c_int, _CB_TYPE, ct.py_object] lib.bpf_detach_kprobe.restype = ct.c_int lib.bpf_detach_kprobe.argtypes = [ct.c_char_p] lib.bpf_attach_uprobe.restype = ct.c_void_p lib.bpf_attach_uprobe.argtypes = [ct.c_int, ct.c_int, ct.c_char_p, ct.c_char_p, ct.c_ulonglong, ct.c_int, ct.c_int, ct.c_int, _CB_TYPE, ct.py_object] lib.bpf_detach_uprobe.restype = ct.c_int lib.bpf_detach_uprobe.argtypes = [ct.c_char_p] lib.bpf_attach_tracepoint.restype = ct.c_void_p lib.bpf_attach_tracepoint.argtypes = [ct.c_int, ct.c_char_p, ct.c_char_p, ct.c_int, ct.c_int, ct.c_int, _CB_TYPE, ct.py_object] lib.bpf_detach_tracepoint.restype = ct.c_int lib.bpf_detach_tracepoint.argtypes = [ct.c_char_p, ct.c_char_p] lib.bpf_open_perf_buffer.restype = ct.c_void_p lib.bpf_open_perf_buffer.argtypes = [_RAW_CB_TYPE, ct.py_object, ct.c_int, ct.c_int] lib.bpf_open_perf_event.restype = ct.c_int lib.bpf_open_perf_event.argtypes = [ct.c_uint, ct.c_ulonglong, ct.c_int, ct.c_int] lib.perf_reader_poll.restype = ct.c_int lib.perf_reader_poll.argtypes = [ct.c_int, ct.POINTER(ct.c_void_p), ct.c_int] lib.perf_reader_free.restype = None lib.perf_reader_free.argtypes = [ct.c_void_p] lib.perf_reader_fd.restype = int lib.perf_reader_fd.argtypes = [ct.c_void_p] lib.bpf_attach_xdp.restype = ct.c_int; lib.bpf_attach_xdp.argtypes = [ct.c_char_p, ct.c_int] lib.bpf_attach_perf_event.restype = ct.c_int; lib.bpf_attach_perf_event.argtype = [ct.c_int, ct.c_uint, ct.c_uint, ct.c_ulonglong, ct.c_ulonglong, ct.c_int, ct.c_int, ct.c_int] lib.bpf_detach_perf_event.restype = ct.c_int; lib.bpf_detach_perf_event.argtype = [ct.c_uint, ct.c_uint] # bcc symbol helpers class bcc_symbol(ct.Structure): _fields_ = [ ('name', ct.c_char_p), ('demangle_name', ct.c_char_p), ('module', ct.POINTER(ct.c_char)), ('offset', ct.c_ulonglong), ] lib.bcc_procutils_which_so.restype = ct.POINTER(ct.c_char) lib.bcc_procutils_which_so.argtypes = [ct.c_char_p, ct.c_int] lib.bcc_procutils_free.restype = None lib.bcc_procutils_free.argtypes = [ct.c_void_p] lib.bcc_resolve_symname.restype = ct.c_int lib.bcc_resolve_symname.argtypes = [ ct.c_char_p, ct.c_char_p, ct.c_ulonglong, ct.c_int, ct.POINTER(bcc_symbol)] _SYM_CB_TYPE = ct.CFUNCTYPE(ct.c_int, ct.c_char_p, ct.c_ulonglong) lib.bcc_foreach_symbol.restype = ct.c_int lib.bcc_foreach_symbol.argtypes = [ct.c_char_p, _SYM_CB_TYPE] lib.bcc_symcache_new.restype = ct.c_void_p lib.bcc_symcache_new.argtypes = [ct.c_int] lib.bcc_free_symcache.restype = ct.c_void_p lib.bcc_free_symcache.argtypes = [ct.c_void_p, ct.c_int] lib.bcc_symcache_resolve.restype = ct.c_int lib.bcc_symcache_resolve.argtypes = [ct.c_void_p, ct.c_ulonglong, ct.POINTER(bcc_symbol)] lib.bcc_symcache_resolve_name.restype = ct.c_int lib.bcc_symcache_resolve_name.argtypes = [ ct.c_void_p, ct.c_char_p, ct.c_char_p, ct.POINTER(ct.c_ulonglong)] lib.bcc_symcache_refresh.restype = None lib.bcc_symcache_refresh.argtypes = [ct.c_void_p] lib.bcc_usdt_new_frompid.restype = ct.c_void_p lib.bcc_usdt_new_frompid.argtypes = [ct.c_int] lib.bcc_usdt_new_frompath.restype = ct.c_void_p lib.bcc_usdt_new_frompath.argtypes = [ct.c_char_p] lib.bcc_usdt_close.restype = None lib.bcc_usdt_close.argtypes = [ct.c_void_p] lib.bcc_usdt_enable_probe.restype = ct.c_int lib.bcc_usdt_enable_probe.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_char_p] lib.bcc_usdt_genargs.restype = ct.c_char_p lib.bcc_usdt_genargs.argtypes = [ct.c_void_p] lib.bcc_usdt_get_probe_argctype.restype = ct.c_char_p lib.bcc_usdt_get_probe_argctype.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_int] class bcc_usdt(ct.Structure): _fields_ = [ ('provider', ct.c_char_p), ('name', ct.c_char_p), ('bin_path', ct.c_char_p), ('semaphore', ct.c_ulonglong), ('num_locations', ct.c_int), ('num_arguments', ct.c_int), ] class bcc_usdt_location(ct.Structure): _fields_ = [ ('address', ct.c_ulonglong) ] class BCC_USDT_ARGUMENT_FLAGS(object): NONE = 0x0 CONSTANT = 0x1 DEREF_OFFSET = 0x2 DEREF_IDENT = 0x4 BASE_REGISTER_NAME = 0x8 INDEX_REGISTER_NAME = 0x10 SCALE = 0x20 class bcc_usdt_argument(ct.Structure): _fields_ = [ ('size', ct.c_int), ('valid', ct.c_int), ('constant', ct.c_int), ('deref_offset', ct.c_int), ('deref_ident', ct.c_char_p), ('base_register_name', ct.c_char_p), ('index_register_name', ct.c_char_p), ('scale', ct.c_int) ] _USDT_CB = ct.CFUNCTYPE(None, ct.POINTER(bcc_usdt)) lib.bcc_usdt_foreach.restype = None lib.bcc_usdt_foreach.argtypes = [ct.c_void_p, _USDT_CB] lib.bcc_usdt_get_location.restype = ct.c_int lib.bcc_usdt_get_location.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_int, ct.POINTER(bcc_usdt_location)] lib.bcc_usdt_get_argument.restype = ct.c_int lib.bcc_usdt_get_argument.argtypes = [ct.c_void_p, ct.c_char_p, ct.c_int, ct.c_int, ct.POINTER(bcc_usdt_argument)] _USDT_PROBE_CB = ct.CFUNCTYPE(None, ct.c_char_p, ct.c_char_p, ct.c_ulonglong, ct.c_int) lib.bcc_usdt_foreach_uprobe.restype = None lib.bcc_usdt_foreach_uprobe.argtypes = [ct.c_void_p, _USDT_PROBE_CB] bpfcc-0.2.0+git0.02884a026/src/python/bcc/perf.py000066400000000000000000000102651305314114400206470ustar00rootroot00000000000000# Copyright 2016 Sasha Goldshtein # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import ctypes as ct import os from .utils import get_online_cpus class Perf(object): class perf_event_attr(ct.Structure): _fields_ = [ ('type', ct.c_uint), ('size', ct.c_uint), ('config', ct.c_ulong), ('sample_period', ct.c_ulong), ('sample_type', ct.c_ulong), ('read_format', ct.c_ulong), ('flags', ct.c_ulong), ('wakeup_events', ct.c_uint), ('IGNORE3', ct.c_uint), ('IGNORE4', ct.c_ulong), ('IGNORE5', ct.c_ulong), ('IGNORE6', ct.c_ulong), ('IGNORE7', ct.c_uint), ('IGNORE8', ct.c_int), ('IGNORE9', ct.c_ulong), ('IGNORE10', ct.c_uint), ('IGNORE11', ct.c_uint) ] # x86 specific, from arch/x86/include/generated/uapi/asm/unistd_64.h NR_PERF_EVENT_OPEN = 298 # # Selected constants from include/uapi/linux/perf_event.h. # Values copied during Linux 4.7 series. # # perf_type_id PERF_TYPE_HARDWARE = 0 PERF_TYPE_SOFTWARE = 1 PERF_TYPE_TRACEPOINT = 2 PERF_TYPE_HW_CACHE = 3 # perf_event_sample_format PERF_SAMPLE_RAW = 1024 # it's a u32; could also try zero args # perf_event_attr PERF_ATTR_FLAG_FREQ = 1024 # perf_event.h PERF_FLAG_FD_CLOEXEC = 8 PERF_EVENT_IOC_SET_FILTER = 1074275334 PERF_EVENT_IOC_ENABLE = 9216 # fetch syscall routines libc = ct.CDLL('libc.so.6', use_errno=True) syscall = libc.syscall # not declaring vararg types ioctl = libc.ioctl # not declaring vararg types @staticmethod def _open_for_cpu(cpu, attr): pfd = Perf.syscall(Perf.NR_PERF_EVENT_OPEN, ct.byref(attr), attr.pid, cpu, -1, Perf.PERF_FLAG_FD_CLOEXEC) if pfd < 0: errno_ = ct.get_errno() raise OSError(errno_, os.strerror(errno_)) if attr.type == Perf.PERF_TYPE_TRACEPOINT: if Perf.ioctl(pfd, Perf.PERF_EVENT_IOC_SET_FILTER, "common_pid == -17") < 0: errno_ = ct.get_errno() raise OSError(errno_, os.strerror(errno_)) # we don't setup the perf ring buffers, as we won't read them if Perf.ioctl(pfd, Perf.PERF_EVENT_IOC_ENABLE, 0) < 0: errno_ = ct.get_errno() raise OSError(errno_, os.strerror(errno_)) @staticmethod def perf_event_open(tpoint_id, pid=-1, ptype=PERF_TYPE_TRACEPOINT, freq=0): attr = Perf.perf_event_attr() attr.config = tpoint_id attr.pid = pid attr.type = ptype attr.sample_type = Perf.PERF_SAMPLE_RAW if freq > 0: # setup sampling attr.flags = Perf.PERF_ATTR_FLAG_FREQ # no mmap or comm attr.sample_period = freq else: attr.sample_period = 1 attr.wakeup_events = 9999999 # don't wake up for cpu in get_online_cpus(): Perf._open_for_cpu(cpu, attr) bpfcc-0.2.0+git0.02884a026/src/python/bcc/table.py000066400000000000000000000633401305314114400210040ustar00rootroot00000000000000# Copyright 2015 PLUMgrid # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from collections import MutableMapping import ctypes as ct from functools import reduce import multiprocessing import os from .libbcc import lib, _RAW_CB_TYPE from .perf import Perf from .utils import get_online_cpus from .utils import get_possible_cpus from subprocess import check_output BPF_MAP_TYPE_HASH = 1 BPF_MAP_TYPE_ARRAY = 2 BPF_MAP_TYPE_PROG_ARRAY = 3 BPF_MAP_TYPE_PERF_EVENT_ARRAY = 4 BPF_MAP_TYPE_PERCPU_HASH = 5 BPF_MAP_TYPE_PERCPU_ARRAY = 6 BPF_MAP_TYPE_STACK_TRACE = 7 BPF_MAP_TYPE_CGROUP_ARRAY = 8 BPF_MAP_TYPE_LRU_HASH = 9 BPF_MAP_TYPE_LRU_PERCPU_HASH = 10 BPF_MAP_TYPE_LPM_TRIE = 11 stars_max = 40 log2_index_max = 65 linear_index_max = 1025 # helper functions, consider moving these to a utils module def _stars(val, val_max, width): i = 0 text = "" while (1): if (i > (width * val / val_max) - 1) or (i > width - 1): break text += "*" i += 1 if val > val_max: text = text[:-1] + "+" return text def _print_log2_hist(vals, val_type): global stars_max log2_dist_max = 64 idx_max = -1 val_max = 0 for i, v in enumerate(vals): if v > 0: idx_max = i if v > val_max: val_max = v if idx_max <= 32: header = " %-19s : count distribution" body = "%10d -> %-10d : %-8d |%-*s|" stars = stars_max else: header = " %-29s : count distribution" body = "%20d -> %-20d : %-8d |%-*s|" stars = int(stars_max / 2) if idx_max > 0: print(header % val_type); for i in range(1, idx_max + 1): low = (1 << i) >> 1 high = (1 << i) - 1 if (low == high): low -= 1 val = vals[i] print(body % (low, high, val, stars, _stars(val, val_max, stars))) def _print_linear_hist(vals, val_type): global stars_max log2_dist_max = 64 idx_max = -1 val_max = 0 for i, v in enumerate(vals): if v > 0: idx_max = i if v > val_max: val_max = v header = " %-13s : count distribution" body = " %-10d : %-8d |%-*s|" stars = stars_max if idx_max >= 0: print(header % val_type); for i in range(0, idx_max + 1): val = vals[i] print(body % (i, val, stars, _stars(val, val_max, stars))) def Table(bpf, map_id, map_fd, keytype, leaftype, **kwargs): """Table(bpf, map_id, map_fd, keytype, leaftype, **kwargs) Create a python object out of a reference to a bpf table handle""" ttype = lib.bpf_table_type_id(bpf.module, map_id) t = None if ttype == BPF_MAP_TYPE_HASH: t = HashTable(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_ARRAY: t = Array(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_PROG_ARRAY: t = ProgArray(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_PERF_EVENT_ARRAY: t = PerfEventArray(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_PERCPU_HASH: t = PerCpuHash(bpf, map_id, map_fd, keytype, leaftype, **kwargs) elif ttype == BPF_MAP_TYPE_PERCPU_ARRAY: t = PerCpuArray(bpf, map_id, map_fd, keytype, leaftype, **kwargs) elif ttype == BPF_MAP_TYPE_LPM_TRIE: t = LpmTrie(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_STACK_TRACE: t = StackTrace(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_LRU_HASH: t = LruHash(bpf, map_id, map_fd, keytype, leaftype) elif ttype == BPF_MAP_TYPE_LRU_PERCPU_HASH: t = LruPerCpuHash(bpf, map_id, map_fd, keytype, leaftype) if t == None: raise Exception("Unknown table type %d" % ttype) return t class TableBase(MutableMapping): def __init__(self, bpf, map_id, map_fd, keytype, leaftype): self.bpf = bpf self.map_id = map_id self.map_fd = map_fd self.Key = keytype self.Leaf = leaftype self.ttype = lib.bpf_table_type_id(self.bpf.module, self.map_id) self.flags = lib.bpf_table_flags_id(self.bpf.module, self.map_id) self._cbs = {} def key_sprintf(self, key): key_p = ct.pointer(key) buf = ct.create_string_buffer(ct.sizeof(self.Key) * 8) res = lib.bpf_table_key_snprintf(self.bpf.module, self.map_id, buf, len(buf), key_p) if res < 0: raise Exception("Could not printf key") return buf.value def leaf_sprintf(self, leaf): leaf_p = ct.pointer(leaf) buf = ct.create_string_buffer(ct.sizeof(self.Leaf) * 8) res = lib.bpf_table_leaf_snprintf(self.bpf.module, self.map_id, buf, len(buf), leaf_p) if res < 0: raise Exception("Could not printf leaf") return buf.value def key_scanf(self, key_str): key = self.Key() key_p = ct.pointer(key) res = lib.bpf_table_key_sscanf(self.bpf.module, self.map_id, key_str, key_p) if res < 0: raise Exception("Could not scanf key") return key def leaf_scanf(self, leaf_str): leaf = self.Leaf() leaf_p = ct.pointer(leaf) res = lib.bpf_table_leaf_sscanf(self.bpf.module, self.map_id, leaf_str, leaf_p) if res < 0: raise Exception("Could not scanf leaf") return leaf def __getitem__(self, key): key_p = ct.pointer(key) leaf = self.Leaf() leaf_p = ct.pointer(leaf) res = lib.bpf_lookup_elem(self.map_fd, ct.cast(key_p, ct.c_void_p), ct.cast(leaf_p, ct.c_void_p)) if res < 0: raise KeyError return leaf def __setitem__(self, key, leaf): key_p = ct.pointer(key) leaf_p = ct.pointer(leaf) res = lib.bpf_update_elem(self.map_fd, ct.cast(key_p, ct.c_void_p), ct.cast(leaf_p, ct.c_void_p), 0) if res < 0: errstr = os.strerror(ct.get_errno()) raise Exception("Could not update table: %s" % errstr) # override the MutableMapping's implementation of these since they # don't handle KeyError nicely def itervalues(self): for key in self: # a map entry may be deleted in between discovering the key and # fetching the value, suppress such errors try: yield self[key] except KeyError: pass def iteritems(self): for key in self: try: yield (key, self[key]) except KeyError: pass def items(self): return [item for item in self.iteritems()] def values(self): return [value for value in self.itervalues()] def clear(self): # default clear uses popitem, which can race with the bpf prog for k in self.keys(): self.__delitem__(k) def zero(self): # Even though this is not very efficient, we grab the entire list of # keys before enumerating it. This helps avoid a potential race where # the leaf assignment changes a hash table bucket that is being # enumerated by the same loop, and may lead to a hang. for k in list(self.keys()): self[k] = self.Leaf() def __iter__(self): return TableBase.Iter(self, self.Key) def iter(self): return self.__iter__() def keys(self): return self.__iter__() class Iter(object): def __init__(self, table, keytype): self.Key = keytype self.table = table k = self.Key() kp = ct.pointer(k) # if 0 is a valid key, try a few alternatives if k in table: ct.memset(kp, 0xff, ct.sizeof(k)) if k in table: ct.memset(kp, 0x55, ct.sizeof(k)) if k in table: raise Exception("Unable to allocate iterator") self.key = k def __iter__(self): return self def __next__(self): return self.next() def next(self): self.key = self.table.next(self.key) return self.key def next(self, key): next_key = self.Key() next_key_p = ct.pointer(next_key) key_p = ct.pointer(key) res = lib.bpf_get_next_key(self.map_fd, ct.cast(key_p, ct.c_void_p), ct.cast(next_key_p, ct.c_void_p)) if res < 0: raise StopIteration() return next_key def print_log2_hist(self, val_type="value", section_header="Bucket ptr", section_print_fn=None, bucket_fn=None): """print_log2_hist(val_type="value", section_header="Bucket ptr", section_print_fn=None, bucket_fn=None) Prints a table as a log2 histogram. The table must be stored as log2. The val_type argument is optional, and is a column header. If the histogram has a secondary key, multiple tables will print and section_header can be used as a header description for each. If section_print_fn is not None, it will be passed the bucket value to format into a string as it sees fit. If bucket_fn is not None, it will be used to produce a bucket value for the histogram keys. The maximum index allowed is log2_index_max (65), which will accomodate any 64-bit integer in the histogram. """ if isinstance(self.Key(), ct.Structure): tmp = {} f1 = self.Key._fields_[0][0] f2 = self.Key._fields_[1][0] for k, v in self.items(): bucket = getattr(k, f1) if bucket_fn: bucket = bucket_fn(bucket) vals = tmp[bucket] = tmp.get(bucket, [0] * log2_index_max) slot = getattr(k, f2) vals[slot] = v.value for bucket, vals in tmp.items(): if section_print_fn: print("\n%s = %s" % (section_header, section_print_fn(bucket))) else: print("\n%s = %r" % (section_header, bucket)) _print_log2_hist(vals, val_type) else: vals = [0] * log2_index_max for k, v in self.items(): vals[k.value] = v.value _print_log2_hist(vals, val_type) def print_linear_hist(self, val_type="value", section_header="Bucket ptr", section_print_fn=None, bucket_fn=None): """print_linear_hist(val_type="value", section_header="Bucket ptr", section_print_fn=None, bucket_fn=None) Prints a table as a linear histogram. This is intended to span integer ranges, eg, from 0 to 100. The val_type argument is optional, and is a column header. If the histogram has a secondary key, multiple tables will print and section_header can be used as a header description for each. If section_print_fn is not None, it will be passed the bucket value to format into a string as it sees fit. If bucket_fn is not None, it will be used to produce a bucket value for the histogram keys. The maximum index allowed is linear_index_max (1025), which is hoped to be sufficient for integer ranges spanned. """ if isinstance(self.Key(), ct.Structure): tmp = {} f1 = self.Key._fields_[0][0] f2 = self.Key._fields_[1][0] for k, v in self.items(): bucket = getattr(k, f1) if bucket_fn: bucket = bucket_fn(bucket) vals = tmp[bucket] = tmp.get(bucket, [0] * linear_index_max) slot = getattr(k, f2) vals[slot] = v.value for bucket, vals in tmp.items(): if section_print_fn: print("\n%s = %s" % (section_header, section_print_fn(bucket))) else: print("\n%s = %r" % (section_header, bucket)) _print_linear_hist(vals, val_type) else: vals = [0] * linear_index_max for k, v in self.items(): try: vals[k.value] = v.value except IndexError: # Improve error text. If the limit proves a nusiance, this # function be rewritten to avoid having one. raise IndexError(("Index in print_linear_hist() of %d " + "exceeds max of %d.") % (k.value, linear_index_max)) _print_linear_hist(vals, val_type) class HashTable(TableBase): def __init__(self, *args, **kwargs): super(HashTable, self).__init__(*args, **kwargs) def __len__(self): i = 0 for k in self: i += 1 return i def __delitem__(self, key): key_p = ct.pointer(key) res = lib.bpf_delete_elem(self.map_fd, ct.cast(key_p, ct.c_void_p)) if res < 0: raise KeyError class LruHash(HashTable): def __init__(self, *args, **kwargs): super(LruHash, self).__init__(*args, **kwargs) class ArrayBase(TableBase): def __init__(self, *args, **kwargs): super(ArrayBase, self).__init__(*args, **kwargs) self.max_entries = int(lib.bpf_table_max_entries_id(self.bpf.module, self.map_id)) def _normalize_key(self, key): if isinstance(key, int): if key < 0: key = len(self) + key key = self.Key(key) if not isinstance(key, ct._SimpleCData): raise IndexError("Array index must be an integer type") if key.value >= len(self): raise IndexError("Array index out of range") return key def __len__(self): return self.max_entries def __getitem__(self, key): key = self._normalize_key(key) return super(ArrayBase, self).__getitem__(key) def __setitem__(self, key, leaf): key = self._normalize_key(key) super(ArrayBase, self).__setitem__(key, leaf) def __delitem__(self, key): key = self._normalize_key(key) key_p = ct.pointer(key) # Deleting from array type maps does not have an effect, so # zero out the entry instead. leaf = self.Leaf() leaf_p = ct.pointer(leaf) res = lib.bpf_update_elem(self.map_fd, ct.cast(key_p, ct.c_void_p), ct.cast(leaf_p, ct.c_void_p), 0) if res < 0: raise Exception("Could not clear item") def __iter__(self): return ArrayBase.Iter(self, self.Key) class Iter(object): def __init__(self, table, keytype): self.Key = keytype self.table = table self.i = -1 def __iter__(self): return self def __next__(self): return self.next() def next(self): self.i += 1 if self.i == len(self.table): raise StopIteration() return self.Key(self.i) class Array(ArrayBase): def __init__(self, *args, **kwargs): super(Array, self).__init__(*args, **kwargs) class ProgArray(ArrayBase): def __init__(self, *args, **kwargs): super(ProgArray, self).__init__(*args, **kwargs) def __setitem__(self, key, leaf): if isinstance(leaf, int): leaf = self.Leaf(leaf) if isinstance(leaf, self.bpf.Function): leaf = self.Leaf(leaf.fd) super(ProgArray, self).__setitem__(key, leaf) class PerfEventArray(ArrayBase): class Event(object): def __init__(self, typ, config): self.typ = typ self.config = config HW_CPU_CYCLES = Event(Perf.PERF_TYPE_HARDWARE, 0) HW_INSTRUCTIONS = Event(Perf.PERF_TYPE_HARDWARE, 1) HW_CACHE_REFERENCES = Event(Perf.PERF_TYPE_HARDWARE, 2) HW_CACHE_MISSES = Event(Perf.PERF_TYPE_HARDWARE, 3) HW_BRANCH_INSTRUCTIONS = Event(Perf.PERF_TYPE_HARDWARE, 4) HW_BRANCH_MISSES = Event(Perf.PERF_TYPE_HARDWARE, 5) HW_BUS_CYCLES = Event(Perf.PERF_TYPE_HARDWARE, 6) HW_STALLED_CYCLES_FRONTEND = Event(Perf.PERF_TYPE_HARDWARE, 7) HW_STALLED_CYCLES_BACKEND = Event(Perf.PERF_TYPE_HARDWARE, 8) HW_REF_CPU_CYCLES = Event(Perf.PERF_TYPE_HARDWARE, 9) # not yet supported, wip #HW_CACHE_L1D_READ = Event(Perf.PERF_TYPE_HW_CACHE, 0<<0|0<<8|0<<16) #HW_CACHE_L1D_READ_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 0<<0|0<<8|1<<16) #HW_CACHE_L1D_WRITE = Event(Perf.PERF_TYPE_HW_CACHE, 0<<0|1<<8|0<<16) #HW_CACHE_L1D_WRITE_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 0<<0|1<<8|1<<16) #HW_CACHE_L1D_PREF = Event(Perf.PERF_TYPE_HW_CACHE, 0<<0|2<<8|0<<16) #HW_CACHE_L1D_PREF_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 0<<0|2<<8|1<<16) #HW_CACHE_L1I_READ = Event(Perf.PERF_TYPE_HW_CACHE, 1<<0|0<<8|0<<16) #HW_CACHE_L1I_READ_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 1<<0|0<<8|1<<16) #HW_CACHE_L1I_WRITE = Event(Perf.PERF_TYPE_HW_CACHE, 1<<0|1<<8|0<<16) #HW_CACHE_L1I_WRITE_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 1<<0|1<<8|1<<16) #HW_CACHE_L1I_PREF = Event(Perf.PERF_TYPE_HW_CACHE, 1<<0|2<<8|0<<16) #HW_CACHE_L1I_PREF_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 1<<0|2<<8|1<<16) #HW_CACHE_LL_READ = Event(Perf.PERF_TYPE_HW_CACHE, 2<<0|0<<8|0<<16) #HW_CACHE_LL_READ_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 2<<0|0<<8|1<<16) #HW_CACHE_LL_WRITE = Event(Perf.PERF_TYPE_HW_CACHE, 2<<0|1<<8|0<<16) #HW_CACHE_LL_WRITE_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 2<<0|1<<8|1<<16) #HW_CACHE_LL_PREF = Event(Perf.PERF_TYPE_HW_CACHE, 2<<0|2<<8|0<<16) #HW_CACHE_LL_PREF_MISS = Event(Perf.PERF_TYPE_HW_CACHE, 2<<0|2<<8|1<<16) def __init__(self, *args, **kwargs): super(PerfEventArray, self).__init__(*args, **kwargs) def __delitem__(self, key): super(PerfEventArray, self).__delitem__(key) self.close_perf_buffer(key) def open_perf_buffer(self, callback): """open_perf_buffers(callback) Opens a set of per-cpu ring buffer to receive custom perf event data from the bpf program. The callback will be invoked for each event submitted from the kernel, up to millions per second. """ for i in get_online_cpus(): self._open_perf_buffer(i, callback) def _open_perf_buffer(self, cpu, callback): fn = _RAW_CB_TYPE(lambda _, data, size: callback(cpu, data, size)) reader = lib.bpf_open_perf_buffer(fn, None, -1, cpu) if not reader: raise Exception("Could not open perf buffer") fd = lib.perf_reader_fd(reader) self[self.Key(cpu)] = self.Leaf(fd) self.bpf._add_kprobe((id(self), cpu), reader) # keep a refcnt self._cbs[cpu] = fn def close_perf_buffer(self, key): reader = self.bpf.open_kprobes.get((id(self), key)) if reader: lib.perf_reader_free(reader) self.bpf._del_kprobe((id(self), key)) del self._cbs[key] def _open_perf_event(self, cpu, typ, config): fd = lib.bpf_open_perf_event(typ, config, -1, cpu) if fd < 0: raise Exception("bpf_open_perf_event failed") try: self[self.Key(cpu)] = self.Leaf(fd) finally: # the fd is kept open in the map itself by the kernel os.close(fd) def open_perf_event(self, ev): """open_perf_event(ev) Configures the table such that calls from the bpf program to table.perf_read(bpf_get_smp_processor_id()) will return the hardware counter denoted by event ev on the local cpu. """ if not isinstance(ev, self.Event): raise Exception("argument must be an Event, got %s", type(ev)) for i in get_online_cpus(): self._open_perf_event(i, ev.typ, ev.config) class PerCpuHash(HashTable): def __init__(self, *args, **kwargs): self.reducer = kwargs.pop("reducer", None) super(PerCpuHash, self).__init__(*args, **kwargs) self.sLeaf = self.Leaf self.total_cpu = len(get_possible_cpus()) # This needs to be 8 as hard coded into the linux kernel. self.alignment = ct.sizeof(self.sLeaf) % 8 if self.alignment is 0: self.Leaf = self.sLeaf * self.total_cpu else: # Currently Float, Char, un-aligned structs are not supported if self.sLeaf == ct.c_uint: self.Leaf = ct.c_uint64 * self.total_cpu elif self.sLeaf == ct.c_int: self.Leaf = ct.c_int64 * self.total_cpu else: raise IndexError("Leaf must be aligned to 8 bytes") def getvalue(self, key): result = super(PerCpuHash, self).__getitem__(key) if self.alignment is 0: ret = result else: ret = (self.sLeaf * self.total_cpu)() for i in range(0, self.total_cpu): ret[i] = result[i] return ret def __getitem__(self, key): if self.reducer: return reduce(self.reducer, self.getvalue(key)) else: return self.getvalue(key) def __setitem__(self, key, leaf): super(PerCpuHash, self).__setitem__(key, leaf) def sum(self, key): if isinstance(self.Leaf(), ct.Structure): raise IndexError("Leaf must be an integer type for default sum functions") return self.sLeaf(sum(self.getvalue(key))) def max(self, key): if isinstance(self.Leaf(), ct.Structure): raise IndexError("Leaf must be an integer type for default max functions") return self.sLeaf(max(self.getvalue(key))) def average(self, key): result = self.sum(key) return result.value / self.total_cpu class LruPerCpuHash(PerCpuHash): def __init__(self, *args, **kwargs): super(LruPerCpuHash, self).__init__(*args, **kwargs) class PerCpuArray(ArrayBase): def __init__(self, *args, **kwargs): self.reducer = kwargs.pop("reducer", None) super(PerCpuArray, self).__init__(*args, **kwargs) self.sLeaf = self.Leaf self.total_cpu = len(get_possible_cpus()) # This needs to be 8 as hard coded into the linux kernel. self.alignment = ct.sizeof(self.sLeaf) % 8 if self.alignment is 0: self.Leaf = self.sLeaf * self.total_cpu else: # Currently Float, Char, un-aligned structs are not supported if self.sLeaf == ct.c_uint: self.Leaf = ct.c_uint64 * self.total_cpu elif self.sLeaf == ct.c_int: self.Leaf = ct.c_int64 * self.total_cpu else: raise IndexError("Leaf must be aligned to 8 bytes") def getvalue(self, key): result = super(PerCpuArray, self).__getitem__(key) if self.alignment is 0: ret = result else: ret = (self.sLeaf * self.total_cpu)() for i in range(0, self.total_cpu): ret[i] = result[i] return ret def __getitem__(self, key): if (self.reducer): return reduce(self.reducer, self.getvalue(key)) else: return self.getvalue(key) def __setitem__(self, key, leaf): super(PerCpuArray, self).__setitem__(key, leaf) def sum(self, key): if isinstance(self.Leaf(), ct.Structure): raise IndexError("Leaf must be an integer type for default sum functions") return self.sLeaf(sum(self.getvalue(key))) def max(self, key): if isinstance(self.Leaf(), ct.Structure): raise IndexError("Leaf must be an integer type for default max functions") return self.sLeaf(max(self.getvalue(key))) def average(self, key): result = self.sum(key) return result.value / self.total_cpu class LpmTrie(TableBase): def __init__(self, *args, **kwargs): super(LpmTrie, self).__init__(*args, **kwargs) def __len__(self): raise NotImplementedError def __delitem__(self, key): # Not implemented for lpm trie as of kernel commit # b95a5c4db09bc7c253636cb84dc9b12c577fd5a0 raise NotImplementedError class StackTrace(TableBase): MAX_DEPTH = 127 def __init__(self, *args, **kwargs): super(StackTrace, self).__init__(*args, **kwargs) class StackWalker(object): def __init__(self, stack, resolve=None): self.stack = stack self.n = -1 self.resolve = resolve def __iter__(self): return self def __next__(self): return self.next() def next(self): self.n += 1 if self.n == StackTrace.MAX_DEPTH: raise StopIteration() addr = self.stack.ip[self.n] if addr == 0 : raise StopIteration() return self.resolve(addr) if self.resolve else addr def walk(self, stack_id, resolve=None): return StackTrace.StackWalker(self[self.Key(stack_id)], resolve) def __len__(self): i = 0 for k in self: i += 1 return i def __delitem__(self, key): key_p = ct.pointer(key) res = lib.bpf_delete_elem(self.map_fd, ct.cast(key_p, ct.c_void_p)) if res < 0: raise KeyError def clear(self): pass bpfcc-0.2.0+git0.02884a026/src/python/bcc/usdt.py000066400000000000000000000174041305314114400206740ustar00rootroot00000000000000# Copyright 2016 Sasha Goldshtein # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import ctypes as ct import sys from .libbcc import lib, _USDT_CB, _USDT_PROBE_CB, \ bcc_usdt_location, bcc_usdt_argument, \ BCC_USDT_ARGUMENT_FLAGS class USDTException(Exception): pass class USDTProbeArgument(object): def __init__(self, argument): self.signed = argument.size < 0 self.size = abs(argument.size) self.valid = argument.valid if self.valid & BCC_USDT_ARGUMENT_FLAGS.CONSTANT != 0: self.constant = argument.constant if self.valid & BCC_USDT_ARGUMENT_FLAGS.DEREF_OFFSET != 0: self.deref_offset = argument.deref_offset if self.valid & BCC_USDT_ARGUMENT_FLAGS.DEREF_IDENT != 0: self.deref_ident = argument.deref_ident if self.valid & BCC_USDT_ARGUMENT_FLAGS.BASE_REGISTER_NAME != 0: self.base_register_name = argument.base_register_name if self.valid & BCC_USDT_ARGUMENT_FLAGS.INDEX_REGISTER_NAME != 0: self.index_register_name = argument.index_register_name if self.valid & BCC_USDT_ARGUMENT_FLAGS.SCALE != 0: self.scale = argument.scale def _size_prefix(self): return "%d %s bytes" % \ (self.size, "signed " if self.signed else "unsigned") def _format(self): # This mimics the logic in cc/usdt_args.cc that gives meaning to the # various argument settings. A change there will require a change here. if self.valid & BCC_USDT_ARGUMENT_FLAGS.CONSTANT != 0: return "%d" % self.constant if self.valid & BCC_USDT_ARGUMENT_FLAGS.DEREF_OFFSET == 0: return "%s" % self.base_register_name if self.valid & BCC_USDT_ARGUMENT_FLAGS.DEREF_OFFSET != 0 and \ self.valid & BCC_USDT_ARGUMENT_FLAGS.DEREF_IDENT == 0: if self.valid & BCC_USDT_ARGUMENT_FLAGS.INDEX_REGISTER_NAME != 0: index_offset = " + %s" % self.index_register_name if self.valid & BCC_USDT_ARGUMENT_FLAGS.SCALE != 0: index_offset += " * %d" % self.scale else: index_offset = "" sign = '+' if self.deref_offset >= 0 else '-' return "*(%s %s %d%s)" % (self.base_register_name, sign, abs(self.deref_offset), index_offset) if self.valid & BCC_USDT_ARGUMENT_FLAGS.DEREF_OFFSET != 0 and \ self.valid & BCC_USDT_ARGUMENT_FLAGS.DEREF_IDENT != 0 and \ self.valid & BCC_USDT_ARGUMENT_FLAGS.BASE_REGISTER_NAME != 0 and \ self.base_register_name == "ip": sign = '+' if self.deref_offset >= 0 else '-' return "*(&%s %s %d)" % (self.deref_ident, sign, abs(self.deref_offset)) # If we got here, this is an unrecognized case. Doesn't mean it's # necessarily bad, so just provide the raw data. It just means that # other tools won't be able to work with this argument. return "unrecognized argument format, flags %d" % self.valid def __str__(self): return "%s @ %s" % (self._size_prefix(), self._format()) class USDTProbeLocation(object): def __init__(self, probe, index, location): self.probe = probe self.index = index self.num_arguments = probe.num_arguments self.address = location.address def __str__(self): return "0x%x" % self.address def get_argument(self, index): arg = bcc_usdt_argument() res = lib.bcc_usdt_get_argument(self.probe.context, self.probe.name, self.index, index, ct.pointer(arg)) if res != 0: raise USDTException( "error retrieving probe argument %d location %d" % (index, self.index)) return USDTProbeArgument(arg) class USDTProbe(object): def __init__(self, context, probe): self.context = context self.provider = probe.provider self.name = probe.name self.bin_path = probe.bin_path self.semaphore = probe.semaphore self.num_locations = probe.num_locations self.num_arguments = probe.num_arguments def __str__(self): return "%s %s:%s [sema 0x%x]" % \ (self.bin_path, self.provider, self.name, self.semaphore) def short_name(self): return "%s:%s" % (self.provider, self.name) def get_location(self, index): loc = bcc_usdt_location() res = lib.bcc_usdt_get_location(self.context, self.name, index, ct.pointer(loc)) if res != 0: raise USDTException("error retrieving probe location %d" % index) return USDTProbeLocation(self, index, loc) class USDT(object): def __init__(self, pid=None, path=None): if pid and pid != -1: self.pid = pid self.context = lib.bcc_usdt_new_frompid(pid) if self.context == None: raise USDTException("USDT failed to instrument PID %d" % pid) elif path: self.path = path self.context = lib.bcc_usdt_new_frompath(path) if self.context == None: raise USDTException("USDT failed to instrument path %s" % path) else: raise USDTException( "either a pid or a binary path must be specified") def enable_probe(self, probe, fn_name): if lib.bcc_usdt_enable_probe(self.context, probe, fn_name) != 0: raise USDTException( ("failed to enable probe '%s'; a possible cause " + "can be that the probe requires a pid to enable") % probe ) def enable_probe_or_bail(self, probe, fn_name): if lib.bcc_usdt_enable_probe(self.context, probe, fn_name) != 0: print( """Error attaching USDT probes: the specified pid might not contain the given language's runtime, or the runtime was not built with the required USDT probes. Look for a configure flag similar to --with-dtrace or --enable-dtrace. To check which probes are present in the process, use the tplist tool.""") sys.exit(1) def get_text(self): return lib.bcc_usdt_genargs(self.context).decode() def get_probe_arg_ctype(self, probe_name, arg_index): return lib.bcc_usdt_get_probe_argctype( self.context, probe_name, arg_index) def enumerate_probes(self): probes = [] def _add_probe(probe): probes.append(USDTProbe(self.context, probe.contents)) lib.bcc_usdt_foreach(self.context, _USDT_CB(_add_probe)) return probes # This is called by the BPF module's __init__ when it realizes that there # is a USDT context and probes need to be attached. def attach_uprobes(self, bpf): probes = self.enumerate_active_probes() for (binpath, fn_name, addr, pid) in probes: bpf.attach_uprobe(name=binpath, fn_name=fn_name, addr=addr, pid=pid) def enumerate_active_probes(self): probes = [] def _add_probe(binpath, fn_name, addr, pid): probes.append((binpath, fn_name, addr, pid)) lib.bcc_usdt_foreach_uprobe(self.context, _USDT_PROBE_CB(_add_probe)) return probes bpfcc-0.2.0+git0.02884a026/src/python/bcc/utils.py000066400000000000000000000022641305314114400210530ustar00rootroot00000000000000# Copyright 2016 Catalysts GmbH # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. def _read_cpu_range(path): cpus = [] with open(path, 'r') as f: cpus_range_str = f.read() for cpu_range in cpus_range_str.split(','): rangeop = cpu_range.find('-') if rangeop == -1: cpus.append(int(cpu_range)) else: start = int(cpu_range[:rangeop]) end = int(cpu_range[rangeop+1:]) cpus.extend(range(start, end+1)) return cpus def get_online_cpus(): return _read_cpu_range('/sys/devices/system/cpu/online') def get_possible_cpus(): return _read_cpu_range('/sys/devices/system/cpu/possible') bpfcc-0.2.0+git0.02884a026/src/python/setup.py.in000066400000000000000000000007471305314114400207350ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from distutils.core import setup import os import sys if os.environ.get('DESTDIR'): sys.argv += ['--root', os.environ['DESTDIR']] setup(name='bcc', version='@REVISION@', description='BPF Loader Library', author='Brenden Blanco', author_email='bblanco@plumgrid.com', url='https://github.com/iovisor/bcc', packages=['bcc'], platforms=['Linux']) bpfcc-0.2.0+git0.02884a026/tests/000077500000000000000000000000001305314114400156405ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tests/CMakeLists.txt000066400000000000000000000007051305314114400204020ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") configure_file(wrapper.sh.in "${CMAKE_CURRENT_BINARY_DIR}/wrapper.sh" @ONLY) set(TEST_WRAPPER ${CMAKE_CURRENT_BINARY_DIR}/wrapper.sh) add_test(NAME style-check COMMAND ${CMAKE_SOURCE_DIR}/scripts/style-check.sh) set_tests_properties(style-check PROPERTIES PASS_REGULAR_EXPRESSION ".*") add_subdirectory(cc) add_subdirectory(python) add_subdirectory(lua) bpfcc-0.2.0+git0.02884a026/tests/cc/000077500000000000000000000000001305314114400162255ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tests/cc/CMakeLists.txt000066400000000000000000000013401305314114400207630ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") include_directories(${CMAKE_SOURCE_DIR}/src/cc) add_executable(test_static test_static.c) target_link_libraries(test_static bcc-static) add_test(NAME c_test_static COMMAND ${TEST_WRAPPER} c_test_static sudo ${CMAKE_CURRENT_BINARY_DIR}/test_static) add_executable(test_libbcc test_libbcc.cc test_c_api.cc test_usdt_args.cc test_usdt_probes.cc) target_link_libraries(test_libbcc bcc-shared dl) add_test(NAME test_libbcc COMMAND ${TEST_WRAPPER} c_test_all sudo ${CMAKE_CURRENT_BINARY_DIR}/test_libbcc) find_path(SDT_HEADER NAMES "sys/sdt.h") if (SDT_HEADER) target_compile_definitions(test_libbcc PRIVATE HAVE_SDT_HEADER=1) endif() bpfcc-0.2.0+git0.02884a026/tests/cc/catch.hpp000066400000000000000000013401201305314114400200210ustar00rootroot00000000000000/* * Catch v1.4.0 * Generated: 2016-03-15 07:23:12.623111 * ---------------------------------------------------------- * This file has been merged from multiple headers. Please don't edit it directly * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. * * Distributed under the Boost Software License, Version 1.0. (See accompanying * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED #define TWOBLUECUBES_CATCH_HPP_INCLUDED #ifdef __clang__ # pragma clang system_header #elif defined __GNUC__ # pragma GCC system_header #endif // #included from: internal/catch_suppress_warnings.h #ifdef __clang__ # ifdef __ICC // icpc defines the __clang__ macro # pragma warning(push) # pragma warning(disable: 161 1682) # else // __ICC # pragma clang diagnostic ignored "-Wglobal-constructors" # pragma clang diagnostic ignored "-Wvariadic-macros" # pragma clang diagnostic ignored "-Wc99-extensions" # pragma clang diagnostic ignored "-Wunused-variable" # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wpadded" # pragma clang diagnostic ignored "-Wc++98-compat" # pragma clang diagnostic ignored "-Wc++98-compat-pedantic" # pragma clang diagnostic ignored "-Wswitch-enum" # pragma clang diagnostic ignored "-Wcovered-switch-default" # endif #elif defined __GNUC__ # pragma GCC diagnostic ignored "-Wvariadic-macros" # pragma GCC diagnostic ignored "-Wunused-variable" # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpadded" #endif #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) # define CATCH_IMPL #endif #ifdef CATCH_IMPL # ifndef CLARA_CONFIG_MAIN # define CLARA_CONFIG_MAIN_NOT_DEFINED # define CLARA_CONFIG_MAIN # endif #endif // #included from: internal/catch_notimplemented_exception.h #define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED // #included from: catch_common.h #define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) #ifdef CATCH_CONFIG_COUNTER # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) #else # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) #endif #define INTERNAL_CATCH_STRINGIFY2( expr ) #expr #define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) #include #include #include // #included from: catch_compiler_capabilities.h #define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED // Detect a number of compiler features - mostly C++11/14 conformance - by compiler // The following features are defined: // // CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported? // CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported? // CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods // CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported? // CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported // CATCH_CONFIG_CPP11_LONG_LONG : is long long supported? // CATCH_CONFIG_CPP11_OVERRIDE : is override supported? // CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr) // CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported? // CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported? // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? // **************** // Note to maintainers: if new toggles are added please document them // in configuration.md, too // **************** // In general each macro has a _NO_ form // (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature. // Many features, at point of detection, define an _INTERNAL_ macro, so they // can be combined, en-mass, with the _NO_ forms later. // All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11 #if defined(__cplusplus) && __cplusplus >= 201103L # define CATCH_CPP11_OR_GREATER #endif #ifdef __clang__ # if __has_feature(cxx_nullptr) # define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR # endif # if __has_feature(cxx_noexcept) # define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT # endif # if defined(CATCH_CPP11_OR_GREATER) # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) # endif #endif // __clang__ //////////////////////////////////////////////////////////////////////////////// // Borland #ifdef __BORLANDC__ #endif // __BORLANDC__ //////////////////////////////////////////////////////////////////////////////// // EDG #ifdef __EDG_VERSION__ #endif // __EDG_VERSION__ //////////////////////////////////////////////////////////////////////////////// // Digital Mars #ifdef __DMC__ #endif // __DMC__ //////////////////////////////////////////////////////////////////////////////// // GCC #ifdef __GNUC__ # if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) # define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR # endif # if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) && defined(CATCH_CPP11_OR_GREATER) # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" ) # endif // - otherwise more recent versions define __cplusplus >= 201103L // and will get picked up below #endif // __GNUC__ //////////////////////////////////////////////////////////////////////////////// // Visual C++ #ifdef _MSC_VER #if (_MSC_VER >= 1600) # define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR # define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR #endif #if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) #define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT #define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS #endif #endif // _MSC_VER //////////////////////////////////////////////////////////////////////////////// // Use variadic macros if the compiler supports them #if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \ ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \ ( defined __GNUC__ && __GNUC__ >= 3 ) || \ ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L ) #define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS #endif // Use __COUNTER__ if the compiler supports it #if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \ ( defined __GNUC__ && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 ) || \ ( defined __clang__ && __clang_major__ >= 3 ) #define CATCH_INTERNAL_CONFIG_COUNTER #endif //////////////////////////////////////////////////////////////////////////////// // C++ language feature support // catch all support for C++11 #if defined(CATCH_CPP11_OR_GREATER) # if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) # define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR # endif # ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT # define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT # endif # ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS # define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS # endif # ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM # define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM # endif # ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE # define CATCH_INTERNAL_CONFIG_CPP11_TUPLE # endif # ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS # define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS # endif # if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) # define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG # endif # if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) # define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE # endif # if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) # define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR # endif #endif // __cplusplus >= 201103L // Now set the actual defines based on the above + anything the user has configured #if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_NULLPTR #endif #if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_NOEXCEPT #endif #if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_GENERATED_METHODS #endif #if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_IS_ENUM #endif #if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_TUPLE #endif #if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS) # define CATCH_CONFIG_VARIADIC_MACROS #endif #if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_LONG_LONG #endif #if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_OVERRIDE #endif #if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11) # define CATCH_CONFIG_CPP11_UNIQUE_PTR #endif #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) # define CATCH_CONFIG_COUNTER #endif #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) # define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS #endif // noexcept support: #if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT) # define CATCH_NOEXCEPT noexcept # define CATCH_NOEXCEPT_IS(x) noexcept(x) #else # define CATCH_NOEXCEPT throw() # define CATCH_NOEXCEPT_IS(x) #endif // nullptr support #ifdef CATCH_CONFIG_CPP11_NULLPTR # define CATCH_NULL nullptr #else # define CATCH_NULL NULL #endif // override support #ifdef CATCH_CONFIG_CPP11_OVERRIDE # define CATCH_OVERRIDE override #else # define CATCH_OVERRIDE #endif // unique_ptr support #ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR # define CATCH_AUTO_PTR( T ) std::unique_ptr #else # define CATCH_AUTO_PTR( T ) std::auto_ptr #endif namespace Catch { struct IConfig; struct CaseSensitive { enum Choice { Yes, No }; }; class NonCopyable { #ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS NonCopyable( NonCopyable const& ) = delete; NonCopyable( NonCopyable && ) = delete; NonCopyable& operator = ( NonCopyable const& ) = delete; NonCopyable& operator = ( NonCopyable && ) = delete; #else NonCopyable( NonCopyable const& info ); NonCopyable& operator = ( NonCopyable const& ); #endif protected: NonCopyable() {} virtual ~NonCopyable(); }; class SafeBool { public: typedef void (SafeBool::*type)() const; static type makeSafe( bool value ) { return value ? &SafeBool::trueValue : 0; } private: void trueValue() const {} }; template inline void deleteAll( ContainerT& container ) { typename ContainerT::const_iterator it = container.begin(); typename ContainerT::const_iterator itEnd = container.end(); for(; it != itEnd; ++it ) delete *it; } template inline void deleteAllValues( AssociativeContainerT& container ) { typename AssociativeContainerT::const_iterator it = container.begin(); typename AssociativeContainerT::const_iterator itEnd = container.end(); for(; it != itEnd; ++it ) delete it->second; } bool startsWith( std::string const& s, std::string const& prefix ); bool endsWith( std::string const& s, std::string const& suffix ); bool contains( std::string const& s, std::string const& infix ); void toLowerInPlace( std::string& s ); std::string toLower( std::string const& s ); std::string trim( std::string const& str ); bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ); struct pluralise { pluralise( std::size_t count, std::string const& label ); friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ); std::size_t m_count; std::string m_label; }; struct SourceLineInfo { SourceLineInfo(); SourceLineInfo( char const* _file, std::size_t _line ); SourceLineInfo( SourceLineInfo const& other ); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS SourceLineInfo( SourceLineInfo && ) = default; SourceLineInfo& operator = ( SourceLineInfo const& ) = default; SourceLineInfo& operator = ( SourceLineInfo && ) = default; # endif bool empty() const; bool operator == ( SourceLineInfo const& other ) const; bool operator < ( SourceLineInfo const& other ) const; std::string file; std::size_t line; }; std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); // This is just here to avoid compiler warnings with macro constants and boolean literals inline bool isTrue( bool value ){ return value; } inline bool alwaysTrue() { return true; } inline bool alwaysFalse() { return false; } void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ); void seedRng( IConfig const& config ); unsigned int rngSeed(); // Use this in variadic streaming macros to allow // >> +StreamEndStop // as well as // >> stuff +StreamEndStop struct StreamEndStop { std::string operator+() { return std::string(); } }; template T const& operator + ( T const& value, StreamEndStop ) { return value; } } #define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) #define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); #include namespace Catch { class NotImplementedException : public std::exception { public: NotImplementedException( SourceLineInfo const& lineInfo ); NotImplementedException( NotImplementedException const& ) {} virtual ~NotImplementedException() CATCH_NOEXCEPT {} virtual const char* what() const CATCH_NOEXCEPT; private: std::string m_what; SourceLineInfo m_lineInfo; }; } // end namespace Catch /////////////////////////////////////////////////////////////////////////////// #define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO ) // #included from: internal/catch_context.h #define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED // #included from: catch_interfaces_generators.h #define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED #include namespace Catch { struct IGeneratorInfo { virtual ~IGeneratorInfo(); virtual bool moveNext() = 0; virtual std::size_t getCurrentIndex() const = 0; }; struct IGeneratorsForTest { virtual ~IGeneratorsForTest(); virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0; virtual bool moveNext() = 0; }; IGeneratorsForTest* createGeneratorsForTest(); } // end namespace Catch // #included from: catch_ptr.hpp #define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif namespace Catch { // An intrusive reference counting smart pointer. // T must implement addRef() and release() methods // typically implementing the IShared interface template class Ptr { public: Ptr() : m_p( CATCH_NULL ){} Ptr( T* p ) : m_p( p ){ if( m_p ) m_p->addRef(); } Ptr( Ptr const& other ) : m_p( other.m_p ){ if( m_p ) m_p->addRef(); } ~Ptr(){ if( m_p ) m_p->release(); } void reset() { if( m_p ) m_p->release(); m_p = CATCH_NULL; } Ptr& operator = ( T* p ){ Ptr temp( p ); swap( temp ); return *this; } Ptr& operator = ( Ptr const& other ){ Ptr temp( other ); swap( temp ); return *this; } void swap( Ptr& other ) { std::swap( m_p, other.m_p ); } T* get() const{ return m_p; } T& operator*() const { return *m_p; } T* operator->() const { return m_p; } bool operator !() const { return m_p == CATCH_NULL; } operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); } private: T* m_p; }; struct IShared : NonCopyable { virtual ~IShared(); virtual void addRef() const = 0; virtual void release() const = 0; }; template struct SharedImpl : T { SharedImpl() : m_rc( 0 ){} virtual void addRef() const { ++m_rc; } virtual void release() const { if( --m_rc == 0 ) delete this; } mutable unsigned int m_rc; }; } // end namespace Catch #ifdef __clang__ #pragma clang diagnostic pop #endif #include #include #include namespace Catch { class TestCase; class Stream; struct IResultCapture; struct IRunner; struct IGeneratorsForTest; struct IConfig; struct IContext { virtual ~IContext(); virtual IResultCapture* getResultCapture() = 0; virtual IRunner* getRunner() = 0; virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0; virtual bool advanceGeneratorsForCurrentTest() = 0; virtual Ptr getConfig() const = 0; }; struct IMutableContext : IContext { virtual ~IMutableContext(); virtual void setResultCapture( IResultCapture* resultCapture ) = 0; virtual void setRunner( IRunner* runner ) = 0; virtual void setConfig( Ptr const& config ) = 0; }; IContext& getCurrentContext(); IMutableContext& getCurrentMutableContext(); void cleanUpContext(); Stream createStream( std::string const& streamName ); } // #included from: internal/catch_test_registry.hpp #define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED // #included from: catch_interfaces_testcase.h #define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED #include namespace Catch { class TestSpec; struct ITestCase : IShared { virtual void invoke () const = 0; protected: virtual ~ITestCase(); }; class TestCase; struct IConfig; struct ITestCaseRegistry { virtual ~ITestCaseRegistry(); virtual std::vector const& getAllTests() const = 0; virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; }; bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); std::vector const& getAllTestCasesSorted( IConfig const& config ); } namespace Catch { template class MethodTestCase : public SharedImpl { public: MethodTestCase( void (C::*method)() ) : m_method( method ) {} virtual void invoke() const { C obj; (obj.*m_method)(); } private: virtual ~MethodTestCase() {} void (C::*m_method)(); }; typedef void(*TestFunction)(); struct NameAndDesc { NameAndDesc( const char* _name = "", const char* _description= "" ) : name( _name ), description( _description ) {} const char* name; const char* description; }; void registerTestCase ( ITestCase* testCase, char const* className, NameAndDesc const& nameAndDesc, SourceLineInfo const& lineInfo ); struct AutoReg { AutoReg ( TestFunction function, SourceLineInfo const& lineInfo, NameAndDesc const& nameAndDesc ); template AutoReg ( void (C::*method)(), char const* className, NameAndDesc const& nameAndDesc, SourceLineInfo const& lineInfo ) { registerTestCase ( new MethodTestCase( method ), className, nameAndDesc, lineInfo ); } ~AutoReg(); private: AutoReg( AutoReg const& ); void operator= ( AutoReg const& ); }; void registerTestCaseFunction ( TestFunction function, SourceLineInfo const& lineInfo, NameAndDesc const& nameAndDesc ); } // end namespace Catch #ifdef CATCH_CONFIG_VARIADIC_MACROS /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \ static void TestName(); \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\ static void TestName() #define INTERNAL_CATCH_TESTCASE( ... ) \ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\ namespace{ \ struct TestName : ClassName{ \ void test(); \ }; \ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \ } \ void TestName::test() #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \ INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \ Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); #else /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \ static void TestName(); \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\ static void TestName() #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \ namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\ namespace{ \ struct TestCaseName : ClassName{ \ void test(); \ }; \ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \ } \ void TestCaseName::test() #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\ INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \ Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); #endif // #included from: internal/catch_capture.hpp #define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED // #included from: catch_result_builder.h #define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED // #included from: catch_result_type.h #define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED namespace Catch { // ResultWas::OfType enum struct ResultWas { enum OfType { Unknown = -1, Ok = 0, Info = 1, Warning = 2, FailureBit = 0x10, ExpressionFailed = FailureBit | 1, ExplicitFailure = FailureBit | 2, Exception = 0x100 | FailureBit, ThrewException = Exception | 1, DidntThrowException = Exception | 2, FatalErrorCondition = 0x200 | FailureBit }; }; inline bool isOk( ResultWas::OfType resultType ) { return ( resultType & ResultWas::FailureBit ) == 0; } inline bool isJustInfo( int flags ) { return flags == ResultWas::Info; } // ResultDisposition::Flags enum struct ResultDisposition { enum Flags { Normal = 0x01, ContinueOnFailure = 0x02, // Failures fail test, but execution continues FalseTest = 0x04, // Prefix expression with ! SuppressFail = 0x08 // Failures are reported but do not fail the test }; }; inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) { return static_cast( static_cast( lhs ) | static_cast( rhs ) ); } inline bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; } inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; } inline bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; } } // end namespace Catch // #included from: catch_assertionresult.h #define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED #include namespace Catch { struct AssertionInfo { AssertionInfo() {} AssertionInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, std::string const& _capturedExpression, ResultDisposition::Flags _resultDisposition ); std::string macroName; SourceLineInfo lineInfo; std::string capturedExpression; ResultDisposition::Flags resultDisposition; }; struct AssertionResultData { AssertionResultData() : resultType( ResultWas::Unknown ) {} std::string reconstructedExpression; std::string message; ResultWas::OfType resultType; }; class AssertionResult { public: AssertionResult(); AssertionResult( AssertionInfo const& info, AssertionResultData const& data ); ~AssertionResult(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS AssertionResult( AssertionResult const& ) = default; AssertionResult( AssertionResult && ) = default; AssertionResult& operator = ( AssertionResult const& ) = default; AssertionResult& operator = ( AssertionResult && ) = default; # endif bool isOk() const; bool succeeded() const; ResultWas::OfType getResultType() const; bool hasExpression() const; bool hasMessage() const; std::string getExpression() const; std::string getExpressionInMacro() const; bool hasExpandedExpression() const; std::string getExpandedExpression() const; std::string getMessage() const; SourceLineInfo getSourceInfo() const; std::string getTestMacroName() const; protected: AssertionInfo m_info; AssertionResultData m_resultData; }; } // end namespace Catch // #included from: catch_matchers.hpp #define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED namespace Catch { namespace Matchers { namespace Impl { namespace Generic { template class AllOf; template class AnyOf; template class Not; } template struct Matcher : SharedImpl { typedef ExpressionT ExpressionType; virtual ~Matcher() {} virtual Ptr clone() const = 0; virtual bool match( ExpressionT const& expr ) const = 0; virtual std::string toString() const = 0; Generic::AllOf operator && ( Matcher const& other ) const; Generic::AnyOf operator || ( Matcher const& other ) const; Generic::Not operator ! () const; }; template struct MatcherImpl : Matcher { virtual Ptr > clone() const { return Ptr >( new DerivedT( static_cast( *this ) ) ); } }; namespace Generic { template class Not : public MatcherImpl, ExpressionT> { public: explicit Not( Matcher const& matcher ) : m_matcher(matcher.clone()) {} Not( Not const& other ) : m_matcher( other.m_matcher ) {} virtual bool match( ExpressionT const& expr ) const CATCH_OVERRIDE { return !m_matcher->match( expr ); } virtual std::string toString() const CATCH_OVERRIDE { return "not " + m_matcher->toString(); } private: Ptr< Matcher > m_matcher; }; template class AllOf : public MatcherImpl, ExpressionT> { public: AllOf() {} AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {} AllOf& add( Matcher const& matcher ) { m_matchers.push_back( matcher.clone() ); return *this; } virtual bool match( ExpressionT const& expr ) const { for( std::size_t i = 0; i < m_matchers.size(); ++i ) if( !m_matchers[i]->match( expr ) ) return false; return true; } virtual std::string toString() const { std::ostringstream oss; oss << "( "; for( std::size_t i = 0; i < m_matchers.size(); ++i ) { if( i != 0 ) oss << " and "; oss << m_matchers[i]->toString(); } oss << " )"; return oss.str(); } AllOf operator && ( Matcher const& other ) const { AllOf allOfExpr( *this ); allOfExpr.add( other ); return allOfExpr; } private: std::vector > > m_matchers; }; template class AnyOf : public MatcherImpl, ExpressionT> { public: AnyOf() {} AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {} AnyOf& add( Matcher const& matcher ) { m_matchers.push_back( matcher.clone() ); return *this; } virtual bool match( ExpressionT const& expr ) const { for( std::size_t i = 0; i < m_matchers.size(); ++i ) if( m_matchers[i]->match( expr ) ) return true; return false; } virtual std::string toString() const { std::ostringstream oss; oss << "( "; for( std::size_t i = 0; i < m_matchers.size(); ++i ) { if( i != 0 ) oss << " or "; oss << m_matchers[i]->toString(); } oss << " )"; return oss.str(); } AnyOf operator || ( Matcher const& other ) const { AnyOf anyOfExpr( *this ); anyOfExpr.add( other ); return anyOfExpr; } private: std::vector > > m_matchers; }; } // namespace Generic template Generic::AllOf Matcher::operator && ( Matcher const& other ) const { Generic::AllOf allOfExpr; allOfExpr.add( *this ); allOfExpr.add( other ); return allOfExpr; } template Generic::AnyOf Matcher::operator || ( Matcher const& other ) const { Generic::AnyOf anyOfExpr; anyOfExpr.add( *this ); anyOfExpr.add( other ); return anyOfExpr; } template Generic::Not Matcher::operator ! () const { return Generic::Not( *this ); } namespace StdString { inline std::string makeString( std::string const& str ) { return str; } inline std::string makeString( const char* str ) { return str ? std::string( str ) : std::string(); } struct CasedString { CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity ) : m_caseSensitivity( caseSensitivity ), m_str( adjustString( str ) ) {} std::string adjustString( std::string const& str ) const { return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str; } std::string toStringSuffix() const { return m_caseSensitivity == CaseSensitive::No ? " (case insensitive)" : ""; } CaseSensitive::Choice m_caseSensitivity; std::string m_str; }; struct Equals : MatcherImpl { Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) : m_data( str, caseSensitivity ) {} Equals( Equals const& other ) : m_data( other.m_data ){} virtual ~Equals(); virtual bool match( std::string const& expr ) const { return m_data.m_str == m_data.adjustString( expr );; } virtual std::string toString() const { return "equals: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); } CasedString m_data; }; struct Contains : MatcherImpl { Contains( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) : m_data( substr, caseSensitivity ){} Contains( Contains const& other ) : m_data( other.m_data ){} virtual ~Contains(); virtual bool match( std::string const& expr ) const { return m_data.adjustString( expr ).find( m_data.m_str ) != std::string::npos; } virtual std::string toString() const { return "contains: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); } CasedString m_data; }; struct StartsWith : MatcherImpl { StartsWith( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) : m_data( substr, caseSensitivity ){} StartsWith( StartsWith const& other ) : m_data( other.m_data ){} virtual ~StartsWith(); virtual bool match( std::string const& expr ) const { return startsWith( m_data.adjustString( expr ), m_data.m_str ); } virtual std::string toString() const { return "starts with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); } CasedString m_data; }; struct EndsWith : MatcherImpl { EndsWith( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) : m_data( substr, caseSensitivity ){} EndsWith( EndsWith const& other ) : m_data( other.m_data ){} virtual ~EndsWith(); virtual bool match( std::string const& expr ) const { return endsWith( m_data.adjustString( expr ), m_data.m_str ); } virtual std::string toString() const { return "ends with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix(); } CasedString m_data; }; } // namespace StdString } // namespace Impl // The following functions create the actual matcher objects. // This allows the types to be inferred template inline Impl::Generic::Not Not( Impl::Matcher const& m ) { return Impl::Generic::Not( m ); } template inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, Impl::Matcher const& m2 ) { return Impl::Generic::AllOf().add( m1 ).add( m2 ); } template inline Impl::Generic::AllOf AllOf( Impl::Matcher const& m1, Impl::Matcher const& m2, Impl::Matcher const& m3 ) { return Impl::Generic::AllOf().add( m1 ).add( m2 ).add( m3 ); } template inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, Impl::Matcher const& m2 ) { return Impl::Generic::AnyOf().add( m1 ).add( m2 ); } template inline Impl::Generic::AnyOf AnyOf( Impl::Matcher const& m1, Impl::Matcher const& m2, Impl::Matcher const& m3 ) { return Impl::Generic::AnyOf().add( m1 ).add( m2 ).add( m3 ); } inline Impl::StdString::Equals Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { return Impl::StdString::Equals( str, caseSensitivity ); } inline Impl::StdString::Equals Equals( const char* str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { return Impl::StdString::Equals( Impl::StdString::makeString( str ), caseSensitivity ); } inline Impl::StdString::Contains Contains( std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { return Impl::StdString::Contains( substr, caseSensitivity ); } inline Impl::StdString::Contains Contains( const char* substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ) { return Impl::StdString::Contains( Impl::StdString::makeString( substr ), caseSensitivity ); } inline Impl::StdString::StartsWith StartsWith( std::string const& substr ) { return Impl::StdString::StartsWith( substr ); } inline Impl::StdString::StartsWith StartsWith( const char* substr ) { return Impl::StdString::StartsWith( Impl::StdString::makeString( substr ) ); } inline Impl::StdString::EndsWith EndsWith( std::string const& substr ) { return Impl::StdString::EndsWith( substr ); } inline Impl::StdString::EndsWith EndsWith( const char* substr ) { return Impl::StdString::EndsWith( Impl::StdString::makeString( substr ) ); } } // namespace Matchers using namespace Matchers; } // namespace Catch namespace Catch { struct TestFailureException{}; template class ExpressionLhs; struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; struct CopyableStream { CopyableStream() {} CopyableStream( CopyableStream const& other ) { oss << other.oss.str(); } CopyableStream& operator=( CopyableStream const& other ) { oss.str(""); oss << other.oss.str(); return *this; } std::ostringstream oss; }; class ResultBuilder { public: ResultBuilder( char const* macroName, SourceLineInfo const& lineInfo, char const* capturedExpression, ResultDisposition::Flags resultDisposition, char const* secondArg = "" ); template ExpressionLhs operator <= ( T const& operand ); ExpressionLhs operator <= ( bool value ); template ResultBuilder& operator << ( T const& value ) { m_stream.oss << value; return *this; } template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); ResultBuilder& setResultType( ResultWas::OfType result ); ResultBuilder& setResultType( bool result ); ResultBuilder& setLhs( std::string const& lhs ); ResultBuilder& setRhs( std::string const& rhs ); ResultBuilder& setOp( std::string const& op ); void endExpression(); std::string reconstructExpression() const; AssertionResult build() const; void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal ); void captureResult( ResultWas::OfType resultType ); void captureExpression(); void captureExpectedException( std::string const& expectedMessage ); void captureExpectedException( Matchers::Impl::Matcher const& matcher ); void handleResult( AssertionResult const& result ); void react(); bool shouldDebugBreak() const; bool allowThrows() const; private: AssertionInfo m_assertionInfo; AssertionResultData m_data; struct ExprComponents { ExprComponents() : testFalse( false ) {} bool testFalse; std::string lhs, rhs, op; } m_exprComponents; CopyableStream m_stream; bool m_shouldDebugBreak; bool m_shouldThrow; }; } // namespace Catch // Include after due to circular dependency: // #included from: catch_expression_lhs.hpp #define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED // #included from: catch_evaluate.hpp #define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable:4389) // '==' : signed/unsigned mismatch #endif #include namespace Catch { namespace Internal { enum Operator { IsEqualTo, IsNotEqualTo, IsLessThan, IsGreaterThan, IsLessThanOrEqualTo, IsGreaterThanOrEqualTo }; template struct OperatorTraits { static const char* getName(){ return "*error*"; } }; template<> struct OperatorTraits { static const char* getName(){ return "=="; } }; template<> struct OperatorTraits { static const char* getName(){ return "!="; } }; template<> struct OperatorTraits { static const char* getName(){ return "<"; } }; template<> struct OperatorTraits { static const char* getName(){ return ">"; } }; template<> struct OperatorTraits { static const char* getName(){ return "<="; } }; template<> struct OperatorTraits{ static const char* getName(){ return ">="; } }; template inline T& opCast(T const& t) { return const_cast(t); } // nullptr_t support based on pull request #154 from Konstantin Baumann #ifdef CATCH_CONFIG_CPP11_NULLPTR inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; } #endif // CATCH_CONFIG_CPP11_NULLPTR // So the compare overloads can be operator agnostic we convey the operator as a template // enum, which is used to specialise an Evaluator for doing the comparison. template class Evaluator{}; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs) { return bool( opCast( lhs ) == opCast( rhs ) ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return bool( opCast( lhs ) != opCast( rhs ) ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return bool( opCast( lhs ) < opCast( rhs ) ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return bool( opCast( lhs ) > opCast( rhs ) ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return bool( opCast( lhs ) >= opCast( rhs ) ); } }; template struct Evaluator { static bool evaluate( T1 const& lhs, T2 const& rhs ) { return bool( opCast( lhs ) <= opCast( rhs ) ); } }; template bool applyEvaluator( T1 const& lhs, T2 const& rhs ) { return Evaluator::evaluate( lhs, rhs ); } // This level of indirection allows us to specialise for integer types // to avoid signed/ unsigned warnings // "base" overload template bool compare( T1 const& lhs, T2 const& rhs ) { return Evaluator::evaluate( lhs, rhs ); } // unsigned X to int template bool compare( unsigned int lhs, int rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned long lhs, int rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned char lhs, int rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } // unsigned X to long template bool compare( unsigned int lhs, long rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned long lhs, long rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } template bool compare( unsigned char lhs, long rhs ) { return applyEvaluator( lhs, static_cast( rhs ) ); } // int to unsigned X template bool compare( int lhs, unsigned int rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( int lhs, unsigned long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( int lhs, unsigned char rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } // long to unsigned X template bool compare( long lhs, unsigned int rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( long lhs, unsigned long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( long lhs, unsigned char rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } // pointer to long (when comparing against NULL) template bool compare( long lhs, T* rhs ) { return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); } template bool compare( T* lhs, long rhs ) { return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); } // pointer to int (when comparing against NULL) template bool compare( int lhs, T* rhs ) { return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); } template bool compare( T* lhs, int rhs ) { return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); } #ifdef CATCH_CONFIG_CPP11_LONG_LONG // long long to unsigned X template bool compare( long long lhs, unsigned int rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( long long lhs, unsigned long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( long long lhs, unsigned long long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( long long lhs, unsigned char rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } // unsigned long long to X template bool compare( unsigned long long lhs, int rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( unsigned long long lhs, long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( unsigned long long lhs, long long rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } template bool compare( unsigned long long lhs, char rhs ) { return applyEvaluator( static_cast( lhs ), rhs ); } // pointer to long long (when comparing against NULL) template bool compare( long long lhs, T* rhs ) { return Evaluator::evaluate( reinterpret_cast( lhs ), rhs ); } template bool compare( T* lhs, long long rhs ) { return Evaluator::evaluate( lhs, reinterpret_cast( rhs ) ); } #endif // CATCH_CONFIG_CPP11_LONG_LONG #ifdef CATCH_CONFIG_CPP11_NULLPTR // pointer to nullptr_t (when comparing against nullptr) template bool compare( std::nullptr_t, T* rhs ) { return Evaluator::evaluate( nullptr, rhs ); } template bool compare( T* lhs, std::nullptr_t ) { return Evaluator::evaluate( lhs, nullptr ); } #endif // CATCH_CONFIG_CPP11_NULLPTR } // end of namespace Internal } // end of namespace Catch #ifdef _MSC_VER #pragma warning(pop) #endif // #included from: catch_tostring.h #define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED #include #include #include #include #include #ifdef __OBJC__ // #included from: catch_objc_arc.hpp #define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED #import #ifdef __has_feature #define CATCH_ARC_ENABLED __has_feature(objc_arc) #else #define CATCH_ARC_ENABLED 0 #endif void arcSafeRelease( NSObject* obj ); id performOptionalSelector( id obj, SEL sel ); #if !CATCH_ARC_ENABLED inline void arcSafeRelease( NSObject* obj ) { [obj release]; } inline id performOptionalSelector( id obj, SEL sel ) { if( [obj respondsToSelector: sel] ) return [obj performSelector: sel]; return nil; } #define CATCH_UNSAFE_UNRETAINED #define CATCH_ARC_STRONG #else inline void arcSafeRelease( NSObject* ){} inline id performOptionalSelector( id obj, SEL sel ) { #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Warc-performSelector-leaks" #endif if( [obj respondsToSelector: sel] ) return [obj performSelector: sel]; #ifdef __clang__ #pragma clang diagnostic pop #endif return nil; } #define CATCH_UNSAFE_UNRETAINED __unsafe_unretained #define CATCH_ARC_STRONG __strong #endif #endif #ifdef CATCH_CONFIG_CPP11_TUPLE #include #endif #ifdef CATCH_CONFIG_CPP11_IS_ENUM #include #endif namespace Catch { // Why we're here. template std::string toString( T const& value ); // Built in overloads std::string toString( std::string const& value ); std::string toString( std::wstring const& value ); std::string toString( const char* const value ); std::string toString( char* const value ); std::string toString( const wchar_t* const value ); std::string toString( wchar_t* const value ); std::string toString( int value ); std::string toString( unsigned long value ); std::string toString( unsigned int value ); std::string toString( const double value ); std::string toString( const float value ); std::string toString( bool value ); std::string toString( char value ); std::string toString( signed char value ); std::string toString( unsigned char value ); #ifdef CATCH_CONFIG_CPP11_LONG_LONG std::string toString( long long value ); std::string toString( unsigned long long value ); #endif #ifdef CATCH_CONFIG_CPP11_NULLPTR std::string toString( std::nullptr_t ); #endif #ifdef __OBJC__ std::string toString( NSString const * const& nsstring ); std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ); std::string toString( NSObject* const& nsObject ); #endif namespace Detail { extern const std::string unprintableString; struct BorgType { template BorgType( T const& ); }; struct TrueType { char sizer[1]; }; struct FalseType { char sizer[2]; }; TrueType& testStreamable( std::ostream& ); FalseType testStreamable( FalseType ); FalseType operator<<( std::ostream const&, BorgType const& ); template struct IsStreamInsertable { static std::ostream &s; static T const&t; enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) }; }; #if defined(CATCH_CONFIG_CPP11_IS_ENUM) template::value > struct EnumStringMaker { static std::string convert( T const& ) { return unprintableString; } }; template struct EnumStringMaker { static std::string convert( T const& v ) { return ::Catch::toString( static_cast::type>(v) ); } }; #endif template struct StringMakerBase { #if defined(CATCH_CONFIG_CPP11_IS_ENUM) template static std::string convert( T const& v ) { return EnumStringMaker::convert( v ); } #else template static std::string convert( T const& ) { return unprintableString; } #endif }; template<> struct StringMakerBase { template static std::string convert( T const& _value ) { std::ostringstream oss; oss << _value; return oss.str(); } }; std::string rawMemoryToString( const void *object, std::size_t size ); template inline std::string rawMemoryToString( const T& object ) { return rawMemoryToString( &object, sizeof(object) ); } } // end namespace Detail template struct StringMaker : Detail::StringMakerBase::value> {}; template struct StringMaker { template static std::string convert( U* p ) { if( !p ) return "NULL"; else return Detail::rawMemoryToString( p ); } }; template struct StringMaker { static std::string convert( R C::* p ) { if( !p ) return "NULL"; else return Detail::rawMemoryToString( p ); } }; namespace Detail { template std::string rangeToString( InputIterator first, InputIterator last ); } //template //struct StringMaker > { // static std::string convert( std::vector const& v ) { // return Detail::rangeToString( v.begin(), v.end() ); // } //}; template std::string toString( std::vector const& v ) { return Detail::rangeToString( v.begin(), v.end() ); } #ifdef CATCH_CONFIG_CPP11_TUPLE // toString for tuples namespace TupleDetail { template< typename Tuple, std::size_t N = 0, bool = (N < std::tuple_size::value) > struct ElementPrinter { static void print( const Tuple& tuple, std::ostream& os ) { os << ( N ? ", " : " " ) << Catch::toString(std::get(tuple)); ElementPrinter::print(tuple,os); } }; template< typename Tuple, std::size_t N > struct ElementPrinter { static void print( const Tuple&, std::ostream& ) {} }; } template struct StringMaker> { static std::string convert( const std::tuple& tuple ) { std::ostringstream os; os << '{'; TupleDetail::ElementPrinter>::print( tuple, os ); os << " }"; return os.str(); } }; #endif // CATCH_CONFIG_CPP11_TUPLE namespace Detail { template std::string makeString( T const& value ) { return StringMaker::convert( value ); } } // end namespace Detail /// \brief converts any type to a string /// /// The default template forwards on to ostringstream - except when an /// ostringstream overload does not exist - in which case it attempts to detect /// that and writes {?}. /// Overload (not specialise) this template for custom typs that you don't want /// to provide an ostream overload for. template std::string toString( T const& value ) { return StringMaker::convert( value ); } namespace Detail { template std::string rangeToString( InputIterator first, InputIterator last ) { std::ostringstream oss; oss << "{ "; if( first != last ) { oss << Catch::toString( *first ); for( ++first ; first != last ; ++first ) oss << ", " << Catch::toString( *first ); } oss << " }"; return oss.str(); } } } // end namespace Catch namespace Catch { // Wraps the LHS of an expression and captures the operator and RHS (if any) - // wrapping them all in a ResultBuilder object template class ExpressionLhs { ExpressionLhs& operator = ( ExpressionLhs const& ); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS ExpressionLhs& operator = ( ExpressionLhs && ) = delete; # endif public: ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ) {} # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS ExpressionLhs( ExpressionLhs const& ) = default; ExpressionLhs( ExpressionLhs && ) = default; # endif template ResultBuilder& operator == ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator != ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator < ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator > ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator <= ( RhsT const& rhs ) { return captureExpression( rhs ); } template ResultBuilder& operator >= ( RhsT const& rhs ) { return captureExpression( rhs ); } ResultBuilder& operator == ( bool rhs ) { return captureExpression( rhs ); } ResultBuilder& operator != ( bool rhs ) { return captureExpression( rhs ); } void endExpression() { bool value = m_lhs ? true : false; m_rb .setLhs( Catch::toString( value ) ) .setResultType( value ) .endExpression(); } // Only simple binary expressions are allowed on the LHS. // If more complex compositions are required then place the sub expression in parentheses template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( RhsT const& ); template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( RhsT const& ); private: template ResultBuilder& captureExpression( RhsT const& rhs ) { return m_rb .setResultType( Internal::compare( m_lhs, rhs ) ) .setLhs( Catch::toString( m_lhs ) ) .setRhs( Catch::toString( rhs ) ) .setOp( Internal::OperatorTraits::getName() ); } private: ResultBuilder& m_rb; T m_lhs; }; } // end namespace Catch namespace Catch { template inline ExpressionLhs ResultBuilder::operator <= ( T const& operand ) { return ExpressionLhs( *this, operand ); } inline ExpressionLhs ResultBuilder::operator <= ( bool value ) { return ExpressionLhs( *this, value ); } } // namespace Catch // #included from: catch_message.h #define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED #include namespace Catch { struct MessageInfo { MessageInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, ResultWas::OfType _type ); std::string macroName; SourceLineInfo lineInfo; ResultWas::OfType type; std::string message; unsigned int sequence; bool operator == ( MessageInfo const& other ) const { return sequence == other.sequence; } bool operator < ( MessageInfo const& other ) const { return sequence < other.sequence; } private: static unsigned int globalCount; }; struct MessageBuilder { MessageBuilder( std::string const& macroName, SourceLineInfo const& lineInfo, ResultWas::OfType type ) : m_info( macroName, lineInfo, type ) {} template MessageBuilder& operator << ( T const& value ) { m_stream << value; return *this; } MessageInfo m_info; std::ostringstream m_stream; }; class ScopedMessage { public: ScopedMessage( MessageBuilder const& builder ); ScopedMessage( ScopedMessage const& other ); ~ScopedMessage(); MessageInfo m_info; }; } // end namespace Catch // #included from: catch_interfaces_capture.h #define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED #include namespace Catch { class TestCase; class AssertionResult; struct AssertionInfo; struct SectionInfo; struct SectionEndInfo; struct MessageInfo; class ScopedMessageBuilder; struct Counts; struct IResultCapture { virtual ~IResultCapture(); virtual void assertionEnded( AssertionResult const& result ) = 0; virtual bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) = 0; virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0; virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0; virtual void pushScopedMessage( MessageInfo const& message ) = 0; virtual void popScopedMessage( MessageInfo const& message ) = 0; virtual std::string getCurrentTestName() const = 0; virtual const AssertionResult* getLastResult() const = 0; virtual void handleFatalErrorCondition( std::string const& message ) = 0; }; IResultCapture& getResultCapture(); } // #included from: catch_debugger.h #define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED // #included from: catch_platform.h #define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) #define CATCH_PLATFORM_MAC #elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) #define CATCH_PLATFORM_IPHONE #elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) #define CATCH_PLATFORM_WINDOWS #endif #include namespace Catch{ bool isDebuggerActive(); void writeToDebugConsole( std::string const& text ); } #ifdef CATCH_PLATFORM_MAC // The following code snippet based on: // http://cocoawithlove.com/2008/03/break-into-debugger.html #ifdef DEBUG #if defined(__ppc64__) || defined(__ppc__) #define CATCH_BREAK_INTO_DEBUGGER() \ if( Catch::isDebuggerActive() ) { \ __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \ : : : "memory","r0","r3","r4" ); \ } #else #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) {__asm__("int $3\n" : : );} #endif #endif #elif defined(_MSC_VER) #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { __debugbreak(); } #elif defined(__MINGW32__) extern "C" __declspec(dllimport) void __stdcall DebugBreak(); #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { DebugBreak(); } #endif #ifndef CATCH_BREAK_INTO_DEBUGGER #define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue(); #endif // #included from: catch_interfaces_runner.h #define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED namespace Catch { class TestCase; struct IRunner { virtual ~IRunner(); virtual bool aborting() const = 0; }; } /////////////////////////////////////////////////////////////////////////////// // In the event of a failure works out if the debugger needs to be invoked // and/or an exception thrown and takes appropriate action. // This needs to be done as a macro so the debugger will stop in the user // source code rather than in Catch library code #define INTERNAL_CATCH_REACT( resultBuilder ) \ if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \ resultBuilder.react(); /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ try { \ CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ ( __catchResult <= expr ).endExpression(); \ } \ catch( ... ) { \ __catchResult.useActiveException( Catch::ResultDisposition::Normal ); \ } \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::isTrue( false && static_cast(expr) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_IF( expr, resultDisposition, macroName ) \ INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ if( Catch::getResultCapture().getLastResult()->succeeded() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_ELSE( expr, resultDisposition, macroName ) \ INTERNAL_CATCH_TEST( expr, resultDisposition, macroName ); \ if( !Catch::getResultCapture().getLastResult()->succeeded() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_NO_THROW( expr, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ try { \ expr; \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ } \ catch( ... ) { \ __catchResult.useActiveException( resultDisposition ); \ } \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_THROWS( expr, resultDisposition, matcher, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition, #matcher ); \ if( __catchResult.allowThrows() ) \ try { \ expr; \ __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ } \ catch( ... ) { \ __catchResult.captureExpectedException( matcher ); \ } \ else \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_THROWS_AS( expr, exceptionType, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \ if( __catchResult.allowThrows() ) \ try { \ expr; \ __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ } \ catch( exceptionType ) { \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ } \ catch( ... ) { \ __catchResult.useActiveException( resultDisposition ); \ } \ else \ __catchResult.captureResult( Catch::ResultWas::Ok ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) /////////////////////////////////////////////////////////////////////////////// #ifdef CATCH_CONFIG_VARIADIC_MACROS #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, ... ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \ __catchResult.captureResult( messageType ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) #else #define INTERNAL_CATCH_MSG( messageType, resultDisposition, macroName, log ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ __catchResult << log + ::Catch::StreamEndStop(); \ __catchResult.captureResult( messageType ); \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) #endif /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_INFO( log, macroName ) \ Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log; /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CHECK_THAT( arg, matcher, resultDisposition, macroName ) \ do { \ Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \ try { \ std::string matcherAsString = (matcher).toString(); \ __catchResult \ .setLhs( Catch::toString( arg ) ) \ .setRhs( matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString ) \ .setOp( "matches" ) \ .setResultType( (matcher).match( arg ) ); \ __catchResult.captureExpression(); \ } catch( ... ) { \ __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \ } \ INTERNAL_CATCH_REACT( __catchResult ) \ } while( Catch::alwaysFalse() ) // #included from: internal/catch_section.h #define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED // #included from: catch_section_info.h #define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED // #included from: catch_totals.hpp #define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED #include namespace Catch { struct Counts { Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {} Counts operator - ( Counts const& other ) const { Counts diff; diff.passed = passed - other.passed; diff.failed = failed - other.failed; diff.failedButOk = failedButOk - other.failedButOk; return diff; } Counts& operator += ( Counts const& other ) { passed += other.passed; failed += other.failed; failedButOk += other.failedButOk; return *this; } std::size_t total() const { return passed + failed + failedButOk; } bool allPassed() const { return failed == 0 && failedButOk == 0; } bool allOk() const { return failed == 0; } std::size_t passed; std::size_t failed; std::size_t failedButOk; }; struct Totals { Totals operator - ( Totals const& other ) const { Totals diff; diff.assertions = assertions - other.assertions; diff.testCases = testCases - other.testCases; return diff; } Totals delta( Totals const& prevTotals ) const { Totals diff = *this - prevTotals; if( diff.assertions.failed > 0 ) ++diff.testCases.failed; else if( diff.assertions.failedButOk > 0 ) ++diff.testCases.failedButOk; else ++diff.testCases.passed; return diff; } Totals& operator += ( Totals const& other ) { assertions += other.assertions; testCases += other.testCases; return *this; } Counts assertions; Counts testCases; }; } namespace Catch { struct SectionInfo { SectionInfo ( SourceLineInfo const& _lineInfo, std::string const& _name, std::string const& _description = std::string() ); std::string name; std::string description; SourceLineInfo lineInfo; }; struct SectionEndInfo { SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds ) : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds ) {} SectionInfo sectionInfo; Counts prevAssertions; double durationInSeconds; }; } // end namespace Catch // #included from: catch_timer.h #define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED #ifdef CATCH_PLATFORM_WINDOWS typedef unsigned long long uint64_t; #else #include #endif namespace Catch { class Timer { public: Timer() : m_ticks( 0 ) {} void start(); unsigned int getElapsedMicroseconds() const; unsigned int getElapsedMilliseconds() const; double getElapsedSeconds() const; private: uint64_t m_ticks; }; } // namespace Catch #include namespace Catch { class Section : NonCopyable { public: Section( SectionInfo const& info ); ~Section(); // This indicates whether the section should be executed or not operator bool() const; private: SectionInfo m_info; std::string m_name; Counts m_assertions; bool m_sectionIncluded; Timer m_timer; }; } // end namespace Catch #ifdef CATCH_CONFIG_VARIADIC_MACROS #define INTERNAL_CATCH_SECTION( ... ) \ if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) #else #define INTERNAL_CATCH_SECTION( name, desc ) \ if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) ) #endif // #included from: internal/catch_generators.hpp #define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED #include #include #include #include namespace Catch { template struct IGenerator { virtual ~IGenerator() {} virtual T getValue( std::size_t index ) const = 0; virtual std::size_t size () const = 0; }; template class BetweenGenerator : public IGenerator { public: BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} virtual T getValue( std::size_t index ) const { return m_from+static_cast( index ); } virtual std::size_t size() const { return static_cast( 1+m_to-m_from ); } private: T m_from; T m_to; }; template class ValuesGenerator : public IGenerator { public: ValuesGenerator(){} void add( T value ) { m_values.push_back( value ); } virtual T getValue( std::size_t index ) const { return m_values[index]; } virtual std::size_t size() const { return m_values.size(); } private: std::vector m_values; }; template class CompositeGenerator { public: CompositeGenerator() : m_totalSize( 0 ) {} // *** Move semantics, similar to auto_ptr *** CompositeGenerator( CompositeGenerator& other ) : m_fileInfo( other.m_fileInfo ), m_totalSize( 0 ) { move( other ); } CompositeGenerator& setFileInfo( const char* fileInfo ) { m_fileInfo = fileInfo; return *this; } ~CompositeGenerator() { deleteAll( m_composed ); } operator T () const { size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); typename std::vector*>::const_iterator it = m_composed.begin(); typename std::vector*>::const_iterator itEnd = m_composed.end(); for( size_t index = 0; it != itEnd; ++it ) { const IGenerator* generator = *it; if( overallIndex >= index && overallIndex < index + generator->size() ) { return generator->getValue( overallIndex-index ); } index += generator->size(); } CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so } void add( const IGenerator* generator ) { m_totalSize += generator->size(); m_composed.push_back( generator ); } CompositeGenerator& then( CompositeGenerator& other ) { move( other ); return *this; } CompositeGenerator& then( T value ) { ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( value ); add( valuesGen ); return *this; } private: void move( CompositeGenerator& other ) { std::copy( other.m_composed.begin(), other.m_composed.end(), std::back_inserter( m_composed ) ); m_totalSize += other.m_totalSize; other.m_composed.clear(); } std::vector*> m_composed; std::string m_fileInfo; size_t m_totalSize; }; namespace Generators { template CompositeGenerator between( T from, T to ) { CompositeGenerator generators; generators.add( new BetweenGenerator( from, to ) ); return generators; } template CompositeGenerator values( T val1, T val2 ) { CompositeGenerator generators; ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( val1 ); valuesGen->add( val2 ); generators.add( valuesGen ); return generators; } template CompositeGenerator values( T val1, T val2, T val3 ){ CompositeGenerator generators; ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( val1 ); valuesGen->add( val2 ); valuesGen->add( val3 ); generators.add( valuesGen ); return generators; } template CompositeGenerator values( T val1, T val2, T val3, T val4 ) { CompositeGenerator generators; ValuesGenerator* valuesGen = new ValuesGenerator(); valuesGen->add( val1 ); valuesGen->add( val2 ); valuesGen->add( val3 ); valuesGen->add( val4 ); generators.add( valuesGen ); return generators; } } // end namespace Generators using namespace Generators; } // end namespace Catch #define INTERNAL_CATCH_LINESTR2( line ) #line #define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) #define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) // #included from: internal/catch_interfaces_exception.h #define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED #include #include // #included from: catch_interfaces_registry_hub.h #define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED #include namespace Catch { class TestCase; struct ITestCaseRegistry; struct IExceptionTranslatorRegistry; struct IExceptionTranslator; struct IReporterRegistry; struct IReporterFactory; struct IRegistryHub { virtual ~IRegistryHub(); virtual IReporterRegistry const& getReporterRegistry() const = 0; virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0; virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0; }; struct IMutableRegistryHub { virtual ~IMutableRegistryHub(); virtual void registerReporter( std::string const& name, Ptr const& factory ) = 0; virtual void registerListener( Ptr const& factory ) = 0; virtual void registerTest( TestCase const& testInfo ) = 0; virtual void registerTranslator( const IExceptionTranslator* translator ) = 0; }; IRegistryHub& getRegistryHub(); IMutableRegistryHub& getMutableRegistryHub(); void cleanUp(); std::string translateActiveException(); } namespace Catch { typedef std::string(*exceptionTranslateFunction)(); struct IExceptionTranslator; typedef std::vector ExceptionTranslators; struct IExceptionTranslator { virtual ~IExceptionTranslator(); virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0; }; struct IExceptionTranslatorRegistry { virtual ~IExceptionTranslatorRegistry(); virtual std::string translateActiveException() const = 0; }; class ExceptionTranslatorRegistrar { template class ExceptionTranslator : public IExceptionTranslator { public: ExceptionTranslator( std::string(*translateFunction)( T& ) ) : m_translateFunction( translateFunction ) {} virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const CATCH_OVERRIDE { try { if( it == itEnd ) throw; else return (*it)->translate( it+1, itEnd ); } catch( T& ex ) { return m_translateFunction( ex ); } } protected: std::string(*m_translateFunction)( T& ); }; public: template ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) { getMutableRegistryHub().registerTranslator ( new ExceptionTranslator( translateFunction ) ); } }; } /////////////////////////////////////////////////////////////////////////////// #define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \ static std::string translatorName( signature ); \ namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); }\ static std::string translatorName( signature ) #define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature ) // #included from: internal/catch_approx.hpp #define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED #include #include namespace Catch { namespace Detail { class Approx { public: explicit Approx ( double value ) : m_epsilon( std::numeric_limits::epsilon()*100 ), m_scale( 1.0 ), m_value( value ) {} Approx( Approx const& other ) : m_epsilon( other.m_epsilon ), m_scale( other.m_scale ), m_value( other.m_value ) {} static Approx custom() { return Approx( 0 ); } Approx operator()( double value ) { Approx approx( value ); approx.epsilon( m_epsilon ); approx.scale( m_scale ); return approx; } friend bool operator == ( double lhs, Approx const& rhs ) { // Thanks to Richard Harris for his help refining this formula return fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( fabs(lhs), fabs(rhs.m_value) ) ); } friend bool operator == ( Approx const& lhs, double rhs ) { return operator==( rhs, lhs ); } friend bool operator != ( double lhs, Approx const& rhs ) { return !operator==( lhs, rhs ); } friend bool operator != ( Approx const& lhs, double rhs ) { return !operator==( rhs, lhs ); } Approx& epsilon( double newEpsilon ) { m_epsilon = newEpsilon; return *this; } Approx& scale( double newScale ) { m_scale = newScale; return *this; } std::string toString() const { std::ostringstream oss; oss << "Approx( " << Catch::toString( m_value ) << " )"; return oss.str(); } private: double m_epsilon; double m_scale; double m_value; }; } template<> inline std::string toString( Detail::Approx const& value ) { return value.toString(); } } // end namespace Catch // #included from: internal/catch_interfaces_tag_alias_registry.h #define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED // #included from: catch_tag_alias.h #define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED #include namespace Catch { struct TagAlias { TagAlias( std::string _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {} std::string tag; SourceLineInfo lineInfo; }; struct RegistrarForTagAliases { RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); }; } // end namespace Catch #define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } // #included from: catch_option.hpp #define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED namespace Catch { // An optional type template class Option { public: Option() : nullableValue( CATCH_NULL ) {} Option( T const& _value ) : nullableValue( new( storage ) T( _value ) ) {} Option( Option const& _other ) : nullableValue( _other ? new( storage ) T( *_other ) : CATCH_NULL ) {} ~Option() { reset(); } Option& operator= ( Option const& _other ) { if( &_other != this ) { reset(); if( _other ) nullableValue = new( storage ) T( *_other ); } return *this; } Option& operator = ( T const& _value ) { reset(); nullableValue = new( storage ) T( _value ); return *this; } void reset() { if( nullableValue ) nullableValue->~T(); nullableValue = CATCH_NULL; } T& operator*() { return *nullableValue; } T const& operator*() const { return *nullableValue; } T* operator->() { return nullableValue; } const T* operator->() const { return nullableValue; } T valueOr( T const& defaultValue ) const { return nullableValue ? *nullableValue : defaultValue; } bool some() const { return nullableValue != CATCH_NULL; } bool none() const { return nullableValue == CATCH_NULL; } bool operator !() const { return nullableValue == CATCH_NULL; } operator SafeBool::type() const { return SafeBool::makeSafe( some() ); } private: T* nullableValue; char storage[sizeof(T)]; }; } // end namespace Catch namespace Catch { struct ITagAliasRegistry { virtual ~ITagAliasRegistry(); virtual Option find( std::string const& alias ) const = 0; virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0; static ITagAliasRegistry const& get(); }; } // end namespace Catch // These files are included here so the single_include script doesn't put them // in the conditionally compiled sections // #included from: internal/catch_test_case_info.h #define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED #include #include #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif namespace Catch { struct ITestCase; struct TestCaseInfo { enum SpecialProperties{ None = 0, IsHidden = 1 << 1, ShouldFail = 1 << 2, MayFail = 1 << 3, Throws = 1 << 4 }; TestCaseInfo( std::string const& _name, std::string const& _className, std::string const& _description, std::set const& _tags, SourceLineInfo const& _lineInfo ); TestCaseInfo( TestCaseInfo const& other ); friend void setTags( TestCaseInfo& testCaseInfo, std::set const& tags ); bool isHidden() const; bool throws() const; bool okToFail() const; bool expectedToFail() const; std::string name; std::string className; std::string description; std::set tags; std::set lcaseTags; std::string tagsAsString; SourceLineInfo lineInfo; SpecialProperties properties; }; class TestCase : public TestCaseInfo { public: TestCase( ITestCase* testCase, TestCaseInfo const& info ); TestCase( TestCase const& other ); TestCase withName( std::string const& _newName ) const; void invoke() const; TestCaseInfo const& getTestCaseInfo() const; void swap( TestCase& other ); bool operator == ( TestCase const& other ) const; bool operator < ( TestCase const& other ) const; TestCase& operator = ( TestCase const& other ); private: Ptr test; }; TestCase makeTestCase( ITestCase* testCase, std::string const& className, std::string const& name, std::string const& description, SourceLineInfo const& lineInfo ); } #ifdef __clang__ #pragma clang diagnostic pop #endif #ifdef __OBJC__ // #included from: internal/catch_objc.hpp #define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED #import #include // NB. Any general catch headers included here must be included // in catch.hpp first to make sure they are included by the single // header for non obj-usage /////////////////////////////////////////////////////////////////////////////// // This protocol is really only here for (self) documenting purposes, since // all its methods are optional. @protocol OcFixture @optional -(void) setUp; -(void) tearDown; @end namespace Catch { class OcMethod : public SharedImpl { public: OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {} virtual void invoke() const { id obj = [[m_cls alloc] init]; performOptionalSelector( obj, @selector(setUp) ); performOptionalSelector( obj, m_sel ); performOptionalSelector( obj, @selector(tearDown) ); arcSafeRelease( obj ); } private: virtual ~OcMethod() {} Class m_cls; SEL m_sel; }; namespace Detail{ inline std::string getAnnotation( Class cls, std::string const& annotationName, std::string const& testCaseName ) { NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()]; SEL sel = NSSelectorFromString( selStr ); arcSafeRelease( selStr ); id value = performOptionalSelector( cls, sel ); if( value ) return [(NSString*)value UTF8String]; return ""; } } inline size_t registerTestMethods() { size_t noTestMethods = 0; int noClasses = objc_getClassList( CATCH_NULL, 0 ); Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses); objc_getClassList( classes, noClasses ); for( int c = 0; c < noClasses; c++ ) { Class cls = classes[c]; { u_int count; Method* methods = class_copyMethodList( cls, &count ); for( u_int m = 0; m < count ; m++ ) { SEL selector = method_getName(methods[m]); std::string methodName = sel_getName(selector); if( startsWith( methodName, "Catch_TestCase_" ) ) { std::string testCaseName = methodName.substr( 15 ); std::string name = Detail::getAnnotation( cls, "Name", testCaseName ); std::string desc = Detail::getAnnotation( cls, "Description", testCaseName ); const char* className = class_getName( cls ); getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) ); noTestMethods++; } } free(methods); } } return noTestMethods; } namespace Matchers { namespace Impl { namespace NSStringMatchers { template struct StringHolder : MatcherImpl{ StringHolder( NSString* substr ) : m_substr( [substr copy] ){} StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){} StringHolder() { arcSafeRelease( m_substr ); } NSString* m_substr; }; struct Equals : StringHolder { Equals( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str isEqualToString:m_substr]; } virtual std::string toString() const { return "equals string: " + Catch::toString( m_substr ); } }; struct Contains : StringHolder { Contains( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str rangeOfString:m_substr].location != NSNotFound; } virtual std::string toString() const { return "contains string: " + Catch::toString( m_substr ); } }; struct StartsWith : StringHolder { StartsWith( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str rangeOfString:m_substr].location == 0; } virtual std::string toString() const { return "starts with: " + Catch::toString( m_substr ); } }; struct EndsWith : StringHolder { EndsWith( NSString* substr ) : StringHolder( substr ){} virtual bool match( ExpressionType const& str ) const { return (str != nil || m_substr == nil ) && [str rangeOfString:m_substr].location == [str length] - [m_substr length]; } virtual std::string toString() const { return "ends with: " + Catch::toString( m_substr ); } }; } // namespace NSStringMatchers } // namespace Impl inline Impl::NSStringMatchers::Equals Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); } inline Impl::NSStringMatchers::Contains Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); } inline Impl::NSStringMatchers::StartsWith StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); } inline Impl::NSStringMatchers::EndsWith EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); } } // namespace Matchers using namespace Matchers; } // namespace Catch /////////////////////////////////////////////////////////////////////////////// #define OC_TEST_CASE( name, desc )\ +(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \ {\ return @ name; \ }\ +(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \ { \ return @ desc; \ } \ -(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test ) #endif #ifdef CATCH_IMPL // #included from: internal/catch_impl.hpp #define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED // Collect all the implementation files together here // These are the equivalent of what would usually be cpp files #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wweak-vtables" #endif // #included from: ../catch_session.hpp #define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED // #included from: internal/catch_commandline.hpp #define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED // #included from: catch_config.hpp #define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED // #included from: catch_test_spec_parser.hpp #define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif // #included from: catch_test_spec.hpp #define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wpadded" #endif // #included from: catch_wildcard_pattern.hpp #define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED namespace Catch { class WildcardPattern { enum WildcardPosition { NoWildcard = 0, WildcardAtStart = 1, WildcardAtEnd = 2, WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd }; public: WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity ) : m_caseSensitivity( caseSensitivity ), m_wildcard( NoWildcard ), m_pattern( adjustCase( pattern ) ) { if( startsWith( m_pattern, "*" ) ) { m_pattern = m_pattern.substr( 1 ); m_wildcard = WildcardAtStart; } if( endsWith( m_pattern, "*" ) ) { m_pattern = m_pattern.substr( 0, m_pattern.size()-1 ); m_wildcard = static_cast( m_wildcard | WildcardAtEnd ); } } virtual ~WildcardPattern(); virtual bool matches( std::string const& str ) const { switch( m_wildcard ) { case NoWildcard: return m_pattern == adjustCase( str ); case WildcardAtStart: return endsWith( adjustCase( str ), m_pattern ); case WildcardAtEnd: return startsWith( adjustCase( str ), m_pattern ); case WildcardAtBothEnds: return contains( adjustCase( str ), m_pattern ); } #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunreachable-code" #endif throw std::logic_error( "Unknown enum" ); #ifdef __clang__ #pragma clang diagnostic pop #endif } private: std::string adjustCase( std::string const& str ) const { return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str; } CaseSensitive::Choice m_caseSensitivity; WildcardPosition m_wildcard; std::string m_pattern; }; } #include #include namespace Catch { class TestSpec { struct Pattern : SharedImpl<> { virtual ~Pattern(); virtual bool matches( TestCaseInfo const& testCase ) const = 0; }; class NamePattern : public Pattern { public: NamePattern( std::string const& name ) : m_wildcardPattern( toLower( name ), CaseSensitive::No ) {} virtual ~NamePattern(); virtual bool matches( TestCaseInfo const& testCase ) const { return m_wildcardPattern.matches( toLower( testCase.name ) ); } private: WildcardPattern m_wildcardPattern; }; class TagPattern : public Pattern { public: TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {} virtual ~TagPattern(); virtual bool matches( TestCaseInfo const& testCase ) const { return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end(); } private: std::string m_tag; }; class ExcludedPattern : public Pattern { public: ExcludedPattern( Ptr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {} virtual ~ExcludedPattern(); virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); } private: Ptr m_underlyingPattern; }; struct Filter { std::vector > m_patterns; bool matches( TestCaseInfo const& testCase ) const { // All patterns in a filter must match for the filter to be a match for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) if( !(*it)->matches( testCase ) ) return false; return true; } }; public: bool hasFilters() const { return !m_filters.empty(); } bool matches( TestCaseInfo const& testCase ) const { // A TestSpec matches if any filter matches for( std::vector::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it ) if( it->matches( testCase ) ) return true; return false; } private: std::vector m_filters; friend class TestSpecParser; }; } #ifdef __clang__ #pragma clang diagnostic pop #endif namespace Catch { class TestSpecParser { enum Mode{ None, Name, QuotedName, Tag }; Mode m_mode; bool m_exclusion; std::size_t m_start, m_pos; std::string m_arg; TestSpec::Filter m_currentFilter; TestSpec m_testSpec; ITagAliasRegistry const* m_tagAliases; public: TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {} TestSpecParser& parse( std::string const& arg ) { m_mode = None; m_exclusion = false; m_start = std::string::npos; m_arg = m_tagAliases->expandAliases( arg ); for( m_pos = 0; m_pos < m_arg.size(); ++m_pos ) visitChar( m_arg[m_pos] ); if( m_mode == Name ) addPattern(); return *this; } TestSpec testSpec() { addFilter(); return m_testSpec; } private: void visitChar( char c ) { if( m_mode == None ) { switch( c ) { case ' ': return; case '~': m_exclusion = true; return; case '[': return startNewMode( Tag, ++m_pos ); case '"': return startNewMode( QuotedName, ++m_pos ); default: startNewMode( Name, m_pos ); break; } } if( m_mode == Name ) { if( c == ',' ) { addPattern(); addFilter(); } else if( c == '[' ) { if( subString() == "exclude:" ) m_exclusion = true; else addPattern(); startNewMode( Tag, ++m_pos ); } } else if( m_mode == QuotedName && c == '"' ) addPattern(); else if( m_mode == Tag && c == ']' ) addPattern(); } void startNewMode( Mode mode, std::size_t start ) { m_mode = mode; m_start = start; } std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); } template void addPattern() { std::string token = subString(); if( startsWith( token, "exclude:" ) ) { m_exclusion = true; token = token.substr( 8 ); } if( !token.empty() ) { Ptr pattern = new T( token ); if( m_exclusion ) pattern = new TestSpec::ExcludedPattern( pattern ); m_currentFilter.m_patterns.push_back( pattern ); } m_exclusion = false; m_mode = None; } void addFilter() { if( !m_currentFilter.m_patterns.empty() ) { m_testSpec.m_filters.push_back( m_currentFilter ); m_currentFilter = TestSpec::Filter(); } } }; inline TestSpec parseTestSpec( std::string const& arg ) { return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec(); } } // namespace Catch #ifdef __clang__ #pragma clang diagnostic pop #endif // #included from: catch_interfaces_config.h #define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED #include #include #include namespace Catch { struct Verbosity { enum Level { NoOutput = 0, Quiet, Normal }; }; struct WarnAbout { enum What { Nothing = 0x00, NoAssertions = 0x01 }; }; struct ShowDurations { enum OrNot { DefaultForReporter, Always, Never }; }; struct RunTests { enum InWhatOrder { InDeclarationOrder, InLexicographicalOrder, InRandomOrder }; }; struct UseColour { enum YesOrNo { Auto, Yes, No }; }; class TestSpec; struct IConfig : IShared { virtual ~IConfig(); virtual bool allowThrows() const = 0; virtual std::ostream& stream() const = 0; virtual std::string name() const = 0; virtual bool includeSuccessfulResults() const = 0; virtual bool shouldDebugBreak() const = 0; virtual bool warnAboutMissingAssertions() const = 0; virtual int abortAfter() const = 0; virtual bool showInvisibles() const = 0; virtual ShowDurations::OrNot showDurations() const = 0; virtual TestSpec const& testSpec() const = 0; virtual RunTests::InWhatOrder runOrder() const = 0; virtual unsigned int rngSeed() const = 0; virtual UseColour::YesOrNo useColour() const = 0; }; } // #included from: catch_stream.h #define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED // #included from: catch_streambuf.h #define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED #include namespace Catch { class StreamBufBase : public std::streambuf { public: virtual ~StreamBufBase() CATCH_NOEXCEPT; }; } #include #include #include namespace Catch { std::ostream& cout(); std::ostream& cerr(); struct IStream { virtual ~IStream() CATCH_NOEXCEPT; virtual std::ostream& stream() const = 0; }; class FileStream : public IStream { mutable std::ofstream m_ofs; public: FileStream( std::string const& filename ); virtual ~FileStream() CATCH_NOEXCEPT; public: // IStream virtual std::ostream& stream() const CATCH_OVERRIDE; }; class CoutStream : public IStream { mutable std::ostream m_os; public: CoutStream(); virtual ~CoutStream() CATCH_NOEXCEPT; public: // IStream virtual std::ostream& stream() const CATCH_OVERRIDE; }; class DebugOutStream : public IStream { std::auto_ptr m_streamBuf; mutable std::ostream m_os; public: DebugOutStream(); virtual ~DebugOutStream() CATCH_NOEXCEPT; public: // IStream virtual std::ostream& stream() const CATCH_OVERRIDE; }; } #include #include #include #include #include #ifndef CATCH_CONFIG_CONSOLE_WIDTH #define CATCH_CONFIG_CONSOLE_WIDTH 80 #endif namespace Catch { struct ConfigData { ConfigData() : listTests( false ), listTags( false ), listReporters( false ), listTestNamesOnly( false ), showSuccessfulTests( false ), shouldDebugBreak( false ), noThrow( false ), showHelp( false ), showInvisibles( false ), filenamesAsTags( false ), abortAfter( -1 ), rngSeed( 0 ), verbosity( Verbosity::Normal ), warnings( WarnAbout::Nothing ), showDurations( ShowDurations::DefaultForReporter ), runOrder( RunTests::InDeclarationOrder ), useColour( UseColour::Auto ) {} bool listTests; bool listTags; bool listReporters; bool listTestNamesOnly; bool showSuccessfulTests; bool shouldDebugBreak; bool noThrow; bool showHelp; bool showInvisibles; bool filenamesAsTags; int abortAfter; unsigned int rngSeed; Verbosity::Level verbosity; WarnAbout::What warnings; ShowDurations::OrNot showDurations; RunTests::InWhatOrder runOrder; UseColour::YesOrNo useColour; std::string outputFilename; std::string name; std::string processName; std::vector reporterNames; std::vector testsOrTags; }; class Config : public SharedImpl { private: Config( Config const& other ); Config& operator = ( Config const& other ); virtual void dummy(); public: Config() {} Config( ConfigData const& data ) : m_data( data ), m_stream( openStream() ) { if( !data.testsOrTags.empty() ) { TestSpecParser parser( ITagAliasRegistry::get() ); for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) parser.parse( data.testsOrTags[i] ); m_testSpec = parser.testSpec(); } } virtual ~Config() { } std::string const& getFilename() const { return m_data.outputFilename ; } bool listTests() const { return m_data.listTests; } bool listTestNamesOnly() const { return m_data.listTestNamesOnly; } bool listTags() const { return m_data.listTags; } bool listReporters() const { return m_data.listReporters; } std::string getProcessName() const { return m_data.processName; } bool shouldDebugBreak() const { return m_data.shouldDebugBreak; } std::vector getReporterNames() const { return m_data.reporterNames; } int abortAfter() const { return m_data.abortAfter; } TestSpec const& testSpec() const { return m_testSpec; } bool showHelp() const { return m_data.showHelp; } bool showInvisibles() const { return m_data.showInvisibles; } // IConfig interface virtual bool allowThrows() const { return !m_data.noThrow; } virtual std::ostream& stream() const { return m_stream->stream(); } virtual std::string name() const { return m_data.name.empty() ? m_data.processName : m_data.name; } virtual bool includeSuccessfulResults() const { return m_data.showSuccessfulTests; } virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; } virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; } virtual RunTests::InWhatOrder runOrder() const { return m_data.runOrder; } virtual unsigned int rngSeed() const { return m_data.rngSeed; } virtual UseColour::YesOrNo useColour() const { return m_data.useColour; } private: IStream const* openStream() { if( m_data.outputFilename.empty() ) return new CoutStream(); else if( m_data.outputFilename[0] == '%' ) { if( m_data.outputFilename == "%debug" ) return new DebugOutStream(); else throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename ); } else return new FileStream( m_data.outputFilename ); } ConfigData m_data; std::auto_ptr m_stream; TestSpec m_testSpec; }; } // end namespace Catch // #included from: catch_clara.h #define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED // Use Catch's value for console width (store Clara's off to the side, if present) #ifdef CLARA_CONFIG_CONSOLE_WIDTH #define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH #undef CLARA_CONFIG_CONSOLE_WIDTH #endif #define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH // Declare Clara inside the Catch namespace #define STITCH_CLARA_OPEN_NAMESPACE namespace Catch { // #included from: ../external/clara.h // Version 0.0.1.1 // Only use header guard if we are not using an outer namespace #if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE) #ifndef STITCH_CLARA_OPEN_NAMESPACE #define TWOBLUECUBES_CLARA_H_INCLUDED #define STITCH_CLARA_OPEN_NAMESPACE #define STITCH_CLARA_CLOSE_NAMESPACE #else #define STITCH_CLARA_CLOSE_NAMESPACE } #endif #define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE // ----------- #included from tbc_text_format.h ----------- // Only use header guard if we are not using an outer namespace #if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE) #ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE #define TBC_TEXT_FORMAT_H_INCLUDED #endif #include #include #include #include // Use optional outer namespace #ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE { #endif namespace Tbc { #ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; #else const unsigned int consoleWidth = 80; #endif struct TextAttributes { TextAttributes() : initialIndent( std::string::npos ), indent( 0 ), width( consoleWidth-1 ), tabChar( '\t' ) {} TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } std::size_t initialIndent; // indent of first line, or npos std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos std::size_t width; // maximum width of text, including indent. Longer text will wrap char tabChar; // If this char is seen the indent is changed to current pos }; class Text { public: Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) : attr( _attr ) { std::string wrappableChars = " [({.,/|\\-"; std::size_t indent = _attr.initialIndent != std::string::npos ? _attr.initialIndent : _attr.indent; std::string remainder = _str; while( !remainder.empty() ) { if( lines.size() >= 1000 ) { lines.push_back( "... message truncated due to excessive size" ); return; } std::size_t tabPos = std::string::npos; std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); std::size_t pos = remainder.find_first_of( '\n' ); if( pos <= width ) { width = pos; } pos = remainder.find_last_of( _attr.tabChar, width ); if( pos != std::string::npos ) { tabPos = pos; if( remainder[width] == '\n' ) width--; remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); } if( width == remainder.size() ) { spliceLine( indent, remainder, width ); } else if( remainder[width] == '\n' ) { spliceLine( indent, remainder, width ); if( width <= 1 || remainder.size() != 1 ) remainder = remainder.substr( 1 ); indent = _attr.indent; } else { pos = remainder.find_last_of( wrappableChars, width ); if( pos != std::string::npos && pos > 0 ) { spliceLine( indent, remainder, pos ); if( remainder[0] == ' ' ) remainder = remainder.substr( 1 ); } else { spliceLine( indent, remainder, width-1 ); lines.back() += "-"; } if( lines.size() == 1 ) indent = _attr.indent; if( tabPos != std::string::npos ) indent += tabPos; } } } void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); _remainder = _remainder.substr( _pos ); } typedef std::vector::const_iterator const_iterator; const_iterator begin() const { return lines.begin(); } const_iterator end() const { return lines.end(); } std::string const& last() const { return lines.back(); } std::size_t size() const { return lines.size(); } std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } std::string toString() const { std::ostringstream oss; oss << *this; return oss.str(); } inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); it != itEnd; ++it ) { if( it != _text.begin() ) _stream << "\n"; _stream << *it; } return _stream; } private: std::string str; TextAttributes attr; std::vector lines; }; } // end namespace Tbc #ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE } // end outer namespace #endif #endif // TBC_TEXT_FORMAT_H_INCLUDED // ----------- end of #include from tbc_text_format.h ----------- // ........... back in clara.h #undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE // ----------- #included from clara_compilers.h ----------- #ifndef TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED #define TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED // Detect a number of compiler features - mostly C++11/14 conformance - by compiler // The following features are defined: // // CLARA_CONFIG_CPP11_NULLPTR : is nullptr supported? // CLARA_CONFIG_CPP11_NOEXCEPT : is noexcept supported? // CLARA_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods // CLARA_CONFIG_CPP11_OVERRIDE : is override supported? // CLARA_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr) // CLARA_CONFIG_CPP11_OR_GREATER : Is C++11 supported? // CLARA_CONFIG_VARIADIC_MACROS : are variadic macros supported? // In general each macro has a _NO_ form // (e.g. CLARA_CONFIG_CPP11_NO_NULLPTR) which disables the feature. // Many features, at point of detection, define an _INTERNAL_ macro, so they // can be combined, en-mass, with the _NO_ forms later. // All the C++11 features can be disabled with CLARA_CONFIG_NO_CPP11 #ifdef __clang__ #if __has_feature(cxx_nullptr) #define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR #endif #if __has_feature(cxx_noexcept) #define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT #endif #endif // __clang__ //////////////////////////////////////////////////////////////////////////////// // GCC #ifdef __GNUC__ #if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) #define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR #endif // - otherwise more recent versions define __cplusplus >= 201103L // and will get picked up below #endif // __GNUC__ //////////////////////////////////////////////////////////////////////////////// // Visual C++ #ifdef _MSC_VER #if (_MSC_VER >= 1600) #define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR #define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR #endif #if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) #define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT #define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS #endif #endif // _MSC_VER //////////////////////////////////////////////////////////////////////////////// // C++ language feature support // catch all support for C++11 #if defined(__cplusplus) && __cplusplus >= 201103L #define CLARA_CPP11_OR_GREATER #if !defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) #define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR #endif #ifndef CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT #define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT #endif #ifndef CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS #define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS #endif #if !defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) #define CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE #endif #if !defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) #define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR #endif #endif // __cplusplus >= 201103L // Now set the actual defines based on the above + anything the user has configured #if defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NO_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_NO_CPP11) #define CLARA_CONFIG_CPP11_NULLPTR #endif #if defined(CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_NO_CPP11) #define CLARA_CONFIG_CPP11_NOEXCEPT #endif #if defined(CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_NO_CPP11) #define CLARA_CONFIG_CPP11_GENERATED_METHODS #endif #if defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_OVERRIDE) && !defined(CLARA_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_CPP11) #define CLARA_CONFIG_CPP11_OVERRIDE #endif #if defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_UNIQUE_PTR) && !defined(CLARA_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_CPP11) #define CLARA_CONFIG_CPP11_UNIQUE_PTR #endif // noexcept support: #if defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_NOEXCEPT) #define CLARA_NOEXCEPT noexcept # define CLARA_NOEXCEPT_IS(x) noexcept(x) #else #define CLARA_NOEXCEPT throw() # define CLARA_NOEXCEPT_IS(x) #endif // nullptr support #ifdef CLARA_CONFIG_CPP11_NULLPTR #define CLARA_NULL nullptr #else #define CLARA_NULL NULL #endif // override support #ifdef CLARA_CONFIG_CPP11_OVERRIDE #define CLARA_OVERRIDE override #else #define CLARA_OVERRIDE #endif // unique_ptr support #ifdef CLARA_CONFIG_CPP11_UNIQUE_PTR # define CLARA_AUTO_PTR( T ) std::unique_ptr #else # define CLARA_AUTO_PTR( T ) std::auto_ptr #endif #endif // TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED // ----------- end of #include from clara_compilers.h ----------- // ........... back in clara.h #include #include #include // Use optional outer namespace #ifdef STITCH_CLARA_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE #endif namespace Clara { struct UnpositionalTag {}; extern UnpositionalTag _; #ifdef CLARA_CONFIG_MAIN UnpositionalTag _; #endif namespace Detail { #ifdef CLARA_CONSOLE_WIDTH const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH; #else const unsigned int consoleWidth = 80; #endif // Use this to try and stop compiler from warning about unreachable code inline bool isTrue( bool value ) { return value; } using namespace Tbc; inline bool startsWith( std::string const& str, std::string const& prefix ) { return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix; } template struct RemoveConstRef{ typedef T type; }; template struct RemoveConstRef{ typedef T type; }; template struct RemoveConstRef{ typedef T type; }; template struct RemoveConstRef{ typedef T type; }; template struct IsBool { static const bool value = false; }; template<> struct IsBool { static const bool value = true; }; template void convertInto( std::string const& _source, T& _dest ) { std::stringstream ss; ss << _source; ss >> _dest; if( ss.fail() ) throw std::runtime_error( "Unable to convert " + _source + " to destination type" ); } inline void convertInto( std::string const& _source, std::string& _dest ) { _dest = _source; } inline void convertInto( std::string const& _source, bool& _dest ) { std::string sourceLC = _source; std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower ); if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" ) _dest = true; else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" ) _dest = false; else throw std::runtime_error( "Expected a boolean value but did not recognise:\n '" + _source + "'" ); } inline void convertInto( bool _source, bool& _dest ) { _dest = _source; } template inline void convertInto( bool, T& ) { if( isTrue( true ) ) throw std::runtime_error( "Invalid conversion" ); } template struct IArgFunction { virtual ~IArgFunction() {} #ifdef CLARA_CONFIG_CPP11_GENERATED_METHODS IArgFunction() = default; IArgFunction( IArgFunction const& ) = default; #endif virtual void set( ConfigT& config, std::string const& value ) const = 0; virtual void setFlag( ConfigT& config ) const = 0; virtual bool takesArg() const = 0; virtual IArgFunction* clone() const = 0; }; template class BoundArgFunction { public: BoundArgFunction() : functionObj( CLARA_NULL ) {} BoundArgFunction( IArgFunction* _functionObj ) : functionObj( _functionObj ) {} BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : CLARA_NULL ) {} BoundArgFunction& operator = ( BoundArgFunction const& other ) { IArgFunction* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL; delete functionObj; functionObj = newFunctionObj; return *this; } ~BoundArgFunction() { delete functionObj; } void set( ConfigT& config, std::string const& value ) const { functionObj->set( config, value ); } void setFlag( ConfigT& config ) const { functionObj->setFlag( config ); } bool takesArg() const { return functionObj->takesArg(); } bool isSet() const { return functionObj != CLARA_NULL; } private: IArgFunction* functionObj; }; template struct NullBinder : IArgFunction{ virtual void set( C&, std::string const& ) const {} virtual void setFlag( C& ) const {} virtual bool takesArg() const { return true; } virtual IArgFunction* clone() const { return new NullBinder( *this ); } }; template struct BoundDataMember : IArgFunction{ BoundDataMember( M C::* _member ) : member( _member ) {} virtual void set( C& p, std::string const& stringValue ) const { convertInto( stringValue, p.*member ); } virtual void setFlag( C& p ) const { convertInto( true, p.*member ); } virtual bool takesArg() const { return !IsBool::value; } virtual IArgFunction* clone() const { return new BoundDataMember( *this ); } M C::* member; }; template struct BoundUnaryMethod : IArgFunction{ BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {} virtual void set( C& p, std::string const& stringValue ) const { typename RemoveConstRef::type value; convertInto( stringValue, value ); (p.*member)( value ); } virtual void setFlag( C& p ) const { typename RemoveConstRef::type value; convertInto( true, value ); (p.*member)( value ); } virtual bool takesArg() const { return !IsBool::value; } virtual IArgFunction* clone() const { return new BoundUnaryMethod( *this ); } void (C::*member)( M ); }; template struct BoundNullaryMethod : IArgFunction{ BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {} virtual void set( C& p, std::string const& stringValue ) const { bool value; convertInto( stringValue, value ); if( value ) (p.*member)(); } virtual void setFlag( C& p ) const { (p.*member)(); } virtual bool takesArg() const { return false; } virtual IArgFunction* clone() const { return new BoundNullaryMethod( *this ); } void (C::*member)(); }; template struct BoundUnaryFunction : IArgFunction{ BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {} virtual void set( C& obj, std::string const& stringValue ) const { bool value; convertInto( stringValue, value ); if( value ) function( obj ); } virtual void setFlag( C& p ) const { function( p ); } virtual bool takesArg() const { return false; } virtual IArgFunction* clone() const { return new BoundUnaryFunction( *this ); } void (*function)( C& ); }; template struct BoundBinaryFunction : IArgFunction{ BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {} virtual void set( C& obj, std::string const& stringValue ) const { typename RemoveConstRef::type value; convertInto( stringValue, value ); function( obj, value ); } virtual void setFlag( C& obj ) const { typename RemoveConstRef::type value; convertInto( true, value ); function( obj, value ); } virtual bool takesArg() const { return !IsBool::value; } virtual IArgFunction* clone() const { return new BoundBinaryFunction( *this ); } void (*function)( C&, T ); }; } // namespace Detail struct Parser { Parser() : separators( " \t=:" ) {} struct Token { enum Type { Positional, ShortOpt, LongOpt }; Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {} Type type; std::string data; }; void parseIntoTokens( int argc, char const* const argv[], std::vector& tokens ) const { const std::string doubleDash = "--"; for( int i = 1; i < argc && argv[i] != doubleDash; ++i ) parseIntoTokens( argv[i] , tokens); } void parseIntoTokens( std::string arg, std::vector& tokens ) const { while( !arg.empty() ) { Parser::Token token( Parser::Token::Positional, arg ); arg = ""; if( token.data[0] == '-' ) { if( token.data.size() > 1 && token.data[1] == '-' ) { token = Parser::Token( Parser::Token::LongOpt, token.data.substr( 2 ) ); } else { token = Parser::Token( Parser::Token::ShortOpt, token.data.substr( 1 ) ); if( token.data.size() > 1 && separators.find( token.data[1] ) == std::string::npos ) { arg = "-" + token.data.substr( 1 ); token.data = token.data.substr( 0, 1 ); } } } if( token.type != Parser::Token::Positional ) { std::size_t pos = token.data.find_first_of( separators ); if( pos != std::string::npos ) { arg = token.data.substr( pos+1 ); token.data = token.data.substr( 0, pos ); } } tokens.push_back( token ); } } std::string separators; }; template struct CommonArgProperties { CommonArgProperties() {} CommonArgProperties( Detail::BoundArgFunction const& _boundField ) : boundField( _boundField ) {} Detail::BoundArgFunction boundField; std::string description; std::string detail; std::string placeholder; // Only value if boundField takes an arg bool takesArg() const { return !placeholder.empty(); } void validate() const { if( !boundField.isSet() ) throw std::logic_error( "option not bound" ); } }; struct OptionArgProperties { std::vector shortNames; std::string longName; bool hasShortName( std::string const& shortName ) const { return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end(); } bool hasLongName( std::string const& _longName ) const { return _longName == longName; } }; struct PositionalArgProperties { PositionalArgProperties() : position( -1 ) {} int position; // -1 means non-positional (floating) bool isFixedPositional() const { return position != -1; } }; template class CommandLine { struct Arg : CommonArgProperties, OptionArgProperties, PositionalArgProperties { Arg() {} Arg( Detail::BoundArgFunction const& _boundField ) : CommonArgProperties( _boundField ) {} using CommonArgProperties::placeholder; // !TBD std::string dbgName() const { if( !longName.empty() ) return "--" + longName; if( !shortNames.empty() ) return "-" + shortNames[0]; return "positional args"; } std::string commands() const { std::ostringstream oss; bool first = true; std::vector::const_iterator it = shortNames.begin(), itEnd = shortNames.end(); for(; it != itEnd; ++it ) { if( first ) first = false; else oss << ", "; oss << "-" << *it; } if( !longName.empty() ) { if( !first ) oss << ", "; oss << "--" << longName; } if( !placeholder.empty() ) oss << " <" << placeholder << ">"; return oss.str(); } }; typedef CLARA_AUTO_PTR( Arg ) ArgAutoPtr; friend void addOptName( Arg& arg, std::string const& optName ) { if( optName.empty() ) return; if( Detail::startsWith( optName, "--" ) ) { if( !arg.longName.empty() ) throw std::logic_error( "Only one long opt may be specified. '" + arg.longName + "' already specified, now attempting to add '" + optName + "'" ); arg.longName = optName.substr( 2 ); } else if( Detail::startsWith( optName, "-" ) ) arg.shortNames.push_back( optName.substr( 1 ) ); else throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" ); } friend void setPositionalArg( Arg& arg, int position ) { arg.position = position; } class ArgBuilder { public: ArgBuilder( Arg* arg ) : m_arg( arg ) {} // Bind a non-boolean data member (requires placeholder string) template void bind( M C::* field, std::string const& placeholder ) { m_arg->boundField = new Detail::BoundDataMember( field ); m_arg->placeholder = placeholder; } // Bind a boolean data member (no placeholder required) template void bind( bool C::* field ) { m_arg->boundField = new Detail::BoundDataMember( field ); } // Bind a method taking a single, non-boolean argument (requires a placeholder string) template void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) { m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); m_arg->placeholder = placeholder; } // Bind a method taking a single, boolean argument (no placeholder string required) template void bind( void (C::* unaryMethod)( bool ) ) { m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); } // Bind a method that takes no arguments (will be called if opt is present) template void bind( void (C::* nullaryMethod)() ) { m_arg->boundField = new Detail::BoundNullaryMethod( nullaryMethod ); } // Bind a free function taking a single argument - the object to operate on (no placeholder string required) template void bind( void (* unaryFunction)( C& ) ) { m_arg->boundField = new Detail::BoundUnaryFunction( unaryFunction ); } // Bind a free function taking a single argument - the object to operate on (requires a placeholder string) template void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) { m_arg->boundField = new Detail::BoundBinaryFunction( binaryFunction ); m_arg->placeholder = placeholder; } ArgBuilder& describe( std::string const& description ) { m_arg->description = description; return *this; } ArgBuilder& detail( std::string const& detail ) { m_arg->detail = detail; return *this; } protected: Arg* m_arg; }; class OptBuilder : public ArgBuilder { public: OptBuilder( Arg* arg ) : ArgBuilder( arg ) {} OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {} OptBuilder& operator[]( std::string const& optName ) { addOptName( *ArgBuilder::m_arg, optName ); return *this; } }; public: CommandLine() : m_boundProcessName( new Detail::NullBinder() ), m_highestSpecifiedArgPosition( 0 ), m_throwOnUnrecognisedTokens( false ) {} CommandLine( CommandLine const& other ) : m_boundProcessName( other.m_boundProcessName ), m_options ( other.m_options ), m_positionalArgs( other.m_positionalArgs ), m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ), m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens ) { if( other.m_floatingArg.get() ) m_floatingArg.reset( new Arg( *other.m_floatingArg ) ); } CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) { m_throwOnUnrecognisedTokens = shouldThrow; return *this; } OptBuilder operator[]( std::string const& optName ) { m_options.push_back( Arg() ); addOptName( m_options.back(), optName ); OptBuilder builder( &m_options.back() ); return builder; } ArgBuilder operator[]( int position ) { m_positionalArgs.insert( std::make_pair( position, Arg() ) ); if( position > m_highestSpecifiedArgPosition ) m_highestSpecifiedArgPosition = position; setPositionalArg( m_positionalArgs[position], position ); ArgBuilder builder( &m_positionalArgs[position] ); return builder; } // Invoke this with the _ instance ArgBuilder operator[]( UnpositionalTag ) { if( m_floatingArg.get() ) throw std::logic_error( "Only one unpositional argument can be added" ); m_floatingArg.reset( new Arg() ); ArgBuilder builder( m_floatingArg.get() ); return builder; } template void bindProcessName( M C::* field ) { m_boundProcessName = new Detail::BoundDataMember( field ); } template void bindProcessName( void (C::*_unaryMethod)( M ) ) { m_boundProcessName = new Detail::BoundUnaryMethod( _unaryMethod ); } void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const { typename std::vector::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it; std::size_t maxWidth = 0; for( it = itBegin; it != itEnd; ++it ) maxWidth = (std::max)( maxWidth, it->commands().size() ); for( it = itBegin; it != itEnd; ++it ) { Detail::Text usage( it->commands(), Detail::TextAttributes() .setWidth( maxWidth+indent ) .setIndent( indent ) ); Detail::Text desc( it->description, Detail::TextAttributes() .setWidth( width - maxWidth - 3 ) ); for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) { std::string usageCol = i < usage.size() ? usage[i] : ""; os << usageCol; if( i < desc.size() && !desc[i].empty() ) os << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' ) << desc[i]; os << "\n"; } } } std::string optUsage() const { std::ostringstream oss; optUsage( oss ); return oss.str(); } void argSynopsis( std::ostream& os ) const { for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) { if( i > 1 ) os << " "; typename std::map::const_iterator it = m_positionalArgs.find( i ); if( it != m_positionalArgs.end() ) os << "<" << it->second.placeholder << ">"; else if( m_floatingArg.get() ) os << "<" << m_floatingArg->placeholder << ">"; else throw std::logic_error( "non consecutive positional arguments with no floating args" ); } // !TBD No indication of mandatory args if( m_floatingArg.get() ) { if( m_highestSpecifiedArgPosition > 1 ) os << " "; os << "[<" << m_floatingArg->placeholder << "> ...]"; } } std::string argSynopsis() const { std::ostringstream oss; argSynopsis( oss ); return oss.str(); } void usage( std::ostream& os, std::string const& procName ) const { validate(); os << "usage:\n " << procName << " "; argSynopsis( os ); if( !m_options.empty() ) { os << " [options]\n\nwhere options are: \n"; optUsage( os, 2 ); } os << "\n"; } std::string usage( std::string const& procName ) const { std::ostringstream oss; usage( oss, procName ); return oss.str(); } ConfigT parse( int argc, char const* const argv[] ) const { ConfigT config; parseInto( argc, argv, config ); return config; } std::vector parseInto( int argc, char const* argv[], ConfigT& config ) const { std::string processName = argv[0]; std::size_t lastSlash = processName.find_last_of( "/\\" ); if( lastSlash != std::string::npos ) processName = processName.substr( lastSlash+1 ); m_boundProcessName.set( config, processName ); std::vector tokens; Parser parser; parser.parseIntoTokens( argc, argv, tokens ); return populate( tokens, config ); } std::vector populate( std::vector const& tokens, ConfigT& config ) const { validate(); std::vector unusedTokens = populateOptions( tokens, config ); unusedTokens = populateFixedArgs( unusedTokens, config ); unusedTokens = populateFloatingArgs( unusedTokens, config ); return unusedTokens; } std::vector populateOptions( std::vector const& tokens, ConfigT& config ) const { std::vector unusedTokens; std::vector errors; for( std::size_t i = 0; i < tokens.size(); ++i ) { Parser::Token const& token = tokens[i]; typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); for(; it != itEnd; ++it ) { Arg const& arg = *it; try { if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) || ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) { if( arg.takesArg() ) { if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional ) errors.push_back( "Expected argument to option: " + token.data ); else arg.boundField.set( config, tokens[++i].data ); } else { arg.boundField.setFlag( config ); } break; } } catch( std::exception& ex ) { errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" ); } } if( it == itEnd ) { if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens ) unusedTokens.push_back( token ); else if( errors.empty() && m_throwOnUnrecognisedTokens ) errors.push_back( "unrecognised option: " + token.data ); } } if( !errors.empty() ) { std::ostringstream oss; for( std::vector::const_iterator it = errors.begin(), itEnd = errors.end(); it != itEnd; ++it ) { if( it != errors.begin() ) oss << "\n"; oss << *it; } throw std::runtime_error( oss.str() ); } return unusedTokens; } std::vector populateFixedArgs( std::vector const& tokens, ConfigT& config ) const { std::vector unusedTokens; int position = 1; for( std::size_t i = 0; i < tokens.size(); ++i ) { Parser::Token const& token = tokens[i]; typename std::map::const_iterator it = m_positionalArgs.find( position ); if( it != m_positionalArgs.end() ) it->second.boundField.set( config, token.data ); else unusedTokens.push_back( token ); if( token.type == Parser::Token::Positional ) position++; } return unusedTokens; } std::vector populateFloatingArgs( std::vector const& tokens, ConfigT& config ) const { if( !m_floatingArg.get() ) return tokens; std::vector unusedTokens; for( std::size_t i = 0; i < tokens.size(); ++i ) { Parser::Token const& token = tokens[i]; if( token.type == Parser::Token::Positional ) m_floatingArg->boundField.set( config, token.data ); else unusedTokens.push_back( token ); } return unusedTokens; } void validate() const { if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() ) throw std::logic_error( "No options or arguments specified" ); for( typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); it != itEnd; ++it ) it->validate(); } private: Detail::BoundArgFunction m_boundProcessName; std::vector m_options; std::map m_positionalArgs; ArgAutoPtr m_floatingArg; int m_highestSpecifiedArgPosition; bool m_throwOnUnrecognisedTokens; }; } // end namespace Clara STITCH_CLARA_CLOSE_NAMESPACE #undef STITCH_CLARA_OPEN_NAMESPACE #undef STITCH_CLARA_CLOSE_NAMESPACE #endif // TWOBLUECUBES_CLARA_H_INCLUDED #undef STITCH_CLARA_OPEN_NAMESPACE // Restore Clara's value for console width, if present #ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH #define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH #undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH #endif #include namespace Catch { inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; } inline void abortAfterX( ConfigData& config, int x ) { if( x < 1 ) throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" ); config.abortAfter = x; } inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); } inline void addReporterName( ConfigData& config, std::string const& _reporterName ) { config.reporterNames.push_back( _reporterName ); } inline void addWarning( ConfigData& config, std::string const& _warning ) { if( _warning == "NoAssertions" ) config.warnings = static_cast( config.warnings | WarnAbout::NoAssertions ); else throw std::runtime_error( "Unrecognised warning: '" + _warning + "'" ); } inline void setOrder( ConfigData& config, std::string const& order ) { if( startsWith( "declared", order ) ) config.runOrder = RunTests::InDeclarationOrder; else if( startsWith( "lexical", order ) ) config.runOrder = RunTests::InLexicographicalOrder; else if( startsWith( "random", order ) ) config.runOrder = RunTests::InRandomOrder; else throw std::runtime_error( "Unrecognised ordering: '" + order + "'" ); } inline void setRngSeed( ConfigData& config, std::string const& seed ) { if( seed == "time" ) { config.rngSeed = static_cast( std::time(0) ); } else { std::stringstream ss; ss << seed; ss >> config.rngSeed; if( ss.fail() ) throw std::runtime_error( "Argment to --rng-seed should be the word 'time' or a number" ); } } inline void setVerbosity( ConfigData& config, int level ) { // !TBD: accept strings? config.verbosity = static_cast( level ); } inline void setShowDurations( ConfigData& config, bool _showDurations ) { config.showDurations = _showDurations ? ShowDurations::Always : ShowDurations::Never; } inline void setUseColour( ConfigData& config, std::string const& value ) { std::string mode = toLower( value ); if( mode == "yes" ) config.useColour = UseColour::Yes; else if( mode == "no" ) config.useColour = UseColour::No; else if( mode == "auto" ) config.useColour = UseColour::Auto; else throw std::runtime_error( "colour mode must be one of: auto, yes or no" ); } inline void forceColour( ConfigData& config ) { config.useColour = UseColour::Yes; } inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) { std::ifstream f( _filename.c_str() ); if( !f.is_open() ) throw std::domain_error( "Unable to load input file: " + _filename ); std::string line; while( std::getline( f, line ) ) { line = trim(line); if( !line.empty() && !startsWith( line, "#" ) ) addTestOrTags( config, "\"" + line + "\"," ); } } inline Clara::CommandLine makeCommandLineParser() { using namespace Clara; CommandLine cli; cli.bindProcessName( &ConfigData::processName ); cli["-?"]["-h"]["--help"] .describe( "display usage information" ) .bind( &ConfigData::showHelp ); cli["-l"]["--list-tests"] .describe( "list all/matching test cases" ) .bind( &ConfigData::listTests ); cli["-t"]["--list-tags"] .describe( "list all/matching tags" ) .bind( &ConfigData::listTags ); cli["-s"]["--success"] .describe( "include successful tests in output" ) .bind( &ConfigData::showSuccessfulTests ); cli["-b"]["--break"] .describe( "break into debugger on failure" ) .bind( &ConfigData::shouldDebugBreak ); cli["-e"]["--nothrow"] .describe( "skip exception tests" ) .bind( &ConfigData::noThrow ); cli["-i"]["--invisibles"] .describe( "show invisibles (tabs, newlines)" ) .bind( &ConfigData::showInvisibles ); cli["-o"]["--out"] .describe( "output filename" ) .bind( &ConfigData::outputFilename, "filename" ); cli["-r"]["--reporter"] // .placeholder( "name[:filename]" ) .describe( "reporter to use (defaults to console)" ) .bind( &addReporterName, "name" ); cli["-n"]["--name"] .describe( "suite name" ) .bind( &ConfigData::name, "name" ); cli["-a"]["--abort"] .describe( "abort at first failure" ) .bind( &abortAfterFirst ); cli["-x"]["--abortx"] .describe( "abort after x failures" ) .bind( &abortAfterX, "no. failures" ); cli["-w"]["--warn"] .describe( "enable warnings" ) .bind( &addWarning, "warning name" ); // - needs updating if reinstated // cli.into( &setVerbosity ) // .describe( "level of verbosity (0=no output)" ) // .shortOpt( "v") // .longOpt( "verbosity" ) // .placeholder( "level" ); cli[_] .describe( "which test or tests to use" ) .bind( &addTestOrTags, "test name, pattern or tags" ); cli["-d"]["--durations"] .describe( "show test durations" ) .bind( &setShowDurations, "yes|no" ); cli["-f"]["--input-file"] .describe( "load test names to run from a file" ) .bind( &loadTestNamesFromFile, "filename" ); cli["-#"]["--filenames-as-tags"] .describe( "adds a tag for the filename" ) .bind( &ConfigData::filenamesAsTags ); // Less common commands which don't have a short form cli["--list-test-names-only"] .describe( "list all/matching test cases names only" ) .bind( &ConfigData::listTestNamesOnly ); cli["--list-reporters"] .describe( "list all reporters" ) .bind( &ConfigData::listReporters ); cli["--order"] .describe( "test case order (defaults to decl)" ) .bind( &setOrder, "decl|lex|rand" ); cli["--rng-seed"] .describe( "set a specific seed for random numbers" ) .bind( &setRngSeed, "'time'|number" ); cli["--force-colour"] .describe( "force colourised output (deprecated)" ) .bind( &forceColour ); cli["--use-colour"] .describe( "should output be colourised" ) .bind( &setUseColour, "yes|no" ); return cli; } } // end namespace Catch // #included from: internal/catch_list.hpp #define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED // #included from: catch_text.h #define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED #define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH #define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch // #included from: ../external/tbc_text_format.h // Only use header guard if we are not using an outer namespace #ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE # ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED # ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED # define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED # endif # else # define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED # endif #endif #ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED #include #include #include // Use optional outer namespace #ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE { #endif namespace Tbc { #ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; #else const unsigned int consoleWidth = 80; #endif struct TextAttributes { TextAttributes() : initialIndent( std::string::npos ), indent( 0 ), width( consoleWidth-1 ), tabChar( '\t' ) {} TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } std::size_t initialIndent; // indent of first line, or npos std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos std::size_t width; // maximum width of text, including indent. Longer text will wrap char tabChar; // If this char is seen the indent is changed to current pos }; class Text { public: Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) : attr( _attr ) { std::string wrappableChars = " [({.,/|\\-"; std::size_t indent = _attr.initialIndent != std::string::npos ? _attr.initialIndent : _attr.indent; std::string remainder = _str; while( !remainder.empty() ) { if( lines.size() >= 1000 ) { lines.push_back( "... message truncated due to excessive size" ); return; } std::size_t tabPos = std::string::npos; std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); std::size_t pos = remainder.find_first_of( '\n' ); if( pos <= width ) { width = pos; } pos = remainder.find_last_of( _attr.tabChar, width ); if( pos != std::string::npos ) { tabPos = pos; if( remainder[width] == '\n' ) width--; remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); } if( width == remainder.size() ) { spliceLine( indent, remainder, width ); } else if( remainder[width] == '\n' ) { spliceLine( indent, remainder, width ); if( width <= 1 || remainder.size() != 1 ) remainder = remainder.substr( 1 ); indent = _attr.indent; } else { pos = remainder.find_last_of( wrappableChars, width ); if( pos != std::string::npos && pos > 0 ) { spliceLine( indent, remainder, pos ); if( remainder[0] == ' ' ) remainder = remainder.substr( 1 ); } else { spliceLine( indent, remainder, width-1 ); lines.back() += "-"; } if( lines.size() == 1 ) indent = _attr.indent; if( tabPos != std::string::npos ) indent += tabPos; } } } void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); _remainder = _remainder.substr( _pos ); } typedef std::vector::const_iterator const_iterator; const_iterator begin() const { return lines.begin(); } const_iterator end() const { return lines.end(); } std::string const& last() const { return lines.back(); } std::size_t size() const { return lines.size(); } std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } std::string toString() const { std::ostringstream oss; oss << *this; return oss.str(); } inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); it != itEnd; ++it ) { if( it != _text.begin() ) _stream << "\n"; _stream << *it; } return _stream; } private: std::string str; TextAttributes attr; std::vector lines; }; } // end namespace Tbc #ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE } // end outer namespace #endif #endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED #undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE namespace Catch { using Tbc::Text; using Tbc::TextAttributes; } // #included from: catch_console_colour.hpp #define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED namespace Catch { struct Colour { enum Code { None = 0, White, Red, Green, Blue, Cyan, Yellow, Grey, Bright = 0x10, BrightRed = Bright | Red, BrightGreen = Bright | Green, LightGrey = Bright | Grey, BrightWhite = Bright | White, // By intention FileName = LightGrey, Warning = Yellow, ResultError = BrightRed, ResultSuccess = BrightGreen, ResultExpectedFailure = Warning, Error = BrightRed, Success = Green, OriginalExpression = Cyan, ReconstructedExpression = Yellow, SecondaryText = LightGrey, Headers = White }; // Use constructed object for RAII guard Colour( Code _colourCode ); Colour( Colour const& other ); ~Colour(); // Use static method for one-shot changes static void use( Code _colourCode ); private: bool m_moved; }; inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; } } // end namespace Catch // #included from: catch_interfaces_reporter.h #define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED #include #include #include #include namespace Catch { struct ReporterConfig { explicit ReporterConfig( Ptr const& _fullConfig ) : m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} ReporterConfig( Ptr const& _fullConfig, std::ostream& _stream ) : m_stream( &_stream ), m_fullConfig( _fullConfig ) {} std::ostream& stream() const { return *m_stream; } Ptr fullConfig() const { return m_fullConfig; } private: std::ostream* m_stream; Ptr m_fullConfig; }; struct ReporterPreferences { ReporterPreferences() : shouldRedirectStdOut( false ) {} bool shouldRedirectStdOut; }; template struct LazyStat : Option { LazyStat() : used( false ) {} LazyStat& operator=( T const& _value ) { Option::operator=( _value ); used = false; return *this; } void reset() { Option::reset(); used = false; } bool used; }; struct TestRunInfo { TestRunInfo( std::string const& _name ) : name( _name ) {} std::string name; }; struct GroupInfo { GroupInfo( std::string const& _name, std::size_t _groupIndex, std::size_t _groupsCount ) : name( _name ), groupIndex( _groupIndex ), groupsCounts( _groupsCount ) {} std::string name; std::size_t groupIndex; std::size_t groupsCounts; }; struct AssertionStats { AssertionStats( AssertionResult const& _assertionResult, std::vector const& _infoMessages, Totals const& _totals ) : assertionResult( _assertionResult ), infoMessages( _infoMessages ), totals( _totals ) { if( assertionResult.hasMessage() ) { // Copy message into messages list. // !TBD This should have been done earlier, somewhere MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); builder << assertionResult.getMessage(); builder.m_info.message = builder.m_stream.str(); infoMessages.push_back( builder.m_info ); } } virtual ~AssertionStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS AssertionStats( AssertionStats const& ) = default; AssertionStats( AssertionStats && ) = default; AssertionStats& operator = ( AssertionStats const& ) = default; AssertionStats& operator = ( AssertionStats && ) = default; # endif AssertionResult assertionResult; std::vector infoMessages; Totals totals; }; struct SectionStats { SectionStats( SectionInfo const& _sectionInfo, Counts const& _assertions, double _durationInSeconds, bool _missingAssertions ) : sectionInfo( _sectionInfo ), assertions( _assertions ), durationInSeconds( _durationInSeconds ), missingAssertions( _missingAssertions ) {} virtual ~SectionStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS SectionStats( SectionStats const& ) = default; SectionStats( SectionStats && ) = default; SectionStats& operator = ( SectionStats const& ) = default; SectionStats& operator = ( SectionStats && ) = default; # endif SectionInfo sectionInfo; Counts assertions; double durationInSeconds; bool missingAssertions; }; struct TestCaseStats { TestCaseStats( TestCaseInfo const& _testInfo, Totals const& _totals, std::string const& _stdOut, std::string const& _stdErr, bool _aborting ) : testInfo( _testInfo ), totals( _totals ), stdOut( _stdOut ), stdErr( _stdErr ), aborting( _aborting ) {} virtual ~TestCaseStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS TestCaseStats( TestCaseStats const& ) = default; TestCaseStats( TestCaseStats && ) = default; TestCaseStats& operator = ( TestCaseStats const& ) = default; TestCaseStats& operator = ( TestCaseStats && ) = default; # endif TestCaseInfo testInfo; Totals totals; std::string stdOut; std::string stdErr; bool aborting; }; struct TestGroupStats { TestGroupStats( GroupInfo const& _groupInfo, Totals const& _totals, bool _aborting ) : groupInfo( _groupInfo ), totals( _totals ), aborting( _aborting ) {} TestGroupStats( GroupInfo const& _groupInfo ) : groupInfo( _groupInfo ), aborting( false ) {} virtual ~TestGroupStats(); # ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS TestGroupStats( TestGroupStats const& ) = default; TestGroupStats( TestGroupStats && ) = default; TestGroupStats& operator = ( TestGroupStats const& ) = default; TestGroupStats& operator = ( TestGroupStats && ) = default; # endif GroupInfo groupInfo; Totals totals; bool aborting; }; struct TestRunStats { TestRunStats( TestRunInfo const& _runInfo, Totals const& _totals, bool _aborting ) : runInfo( _runInfo ), totals( _totals ), aborting( _aborting ) {} virtual ~TestRunStats(); # ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS TestRunStats( TestRunStats const& _other ) : runInfo( _other.runInfo ), totals( _other.totals ), aborting( _other.aborting ) {} # else TestRunStats( TestRunStats const& ) = default; TestRunStats( TestRunStats && ) = default; TestRunStats& operator = ( TestRunStats const& ) = default; TestRunStats& operator = ( TestRunStats && ) = default; # endif TestRunInfo runInfo; Totals totals; bool aborting; }; struct IStreamingReporter : IShared { virtual ~IStreamingReporter(); // Implementing class must also provide the following static method: // static std::string getDescription(); virtual ReporterPreferences getPreferences() const = 0; virtual void noMatchingTestCases( std::string const& spec ) = 0; virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0; virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0; virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0; virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0; virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0; // The return value indicates if the messages buffer should be cleared: virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0; virtual void sectionEnded( SectionStats const& sectionStats ) = 0; virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0; virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0; virtual void testRunEnded( TestRunStats const& testRunStats ) = 0; virtual void skipTest( TestCaseInfo const& testInfo ) = 0; }; struct IReporterFactory : IShared { virtual ~IReporterFactory(); virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0; virtual std::string getDescription() const = 0; }; struct IReporterRegistry { typedef std::map > FactoryMap; typedef std::vector > Listeners; virtual ~IReporterRegistry(); virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const = 0; virtual FactoryMap const& getFactories() const = 0; virtual Listeners const& getListeners() const = 0; }; Ptr addReporter( Ptr const& existingReporter, Ptr const& additionalReporter ); } #include #include namespace Catch { inline std::size_t listTests( Config const& config ) { TestSpec testSpec = config.testSpec(); if( config.testSpec().hasFilters() ) Catch::cout() << "Matching test cases:\n"; else { Catch::cout() << "All available test cases:\n"; testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); } std::size_t matchedTests = 0; TextAttributes nameAttr, tagsAttr; nameAttr.setInitialIndent( 2 ).setIndent( 4 ); tagsAttr.setIndent( 6 ); std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); it != itEnd; ++it ) { matchedTests++; TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); Colour::Code colour = testCaseInfo.isHidden() ? Colour::SecondaryText : Colour::None; Colour colourGuard( colour ); Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl; if( !testCaseInfo.tags.empty() ) Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl; } if( !config.testSpec().hasFilters() ) Catch::cout() << pluralise( matchedTests, "test case" ) << "\n" << std::endl; else Catch::cout() << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl; return matchedTests; } inline std::size_t listTestsNamesOnly( Config const& config ) { TestSpec testSpec = config.testSpec(); if( !config.testSpec().hasFilters() ) testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); std::size_t matchedTests = 0; std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); it != itEnd; ++it ) { matchedTests++; TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); Catch::cout() << testCaseInfo.name << std::endl; } return matchedTests; } struct TagInfo { TagInfo() : count ( 0 ) {} void add( std::string const& spelling ) { ++count; spellings.insert( spelling ); } std::string all() const { std::string out; for( std::set::const_iterator it = spellings.begin(), itEnd = spellings.end(); it != itEnd; ++it ) out += "[" + *it + "]"; return out; } std::set spellings; std::size_t count; }; inline std::size_t listTags( Config const& config ) { TestSpec testSpec = config.testSpec(); if( config.testSpec().hasFilters() ) Catch::cout() << "Tags for matching test cases:\n"; else { Catch::cout() << "All available tags:\n"; testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); } std::map tagCounts; std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); it != itEnd; ++it ) { for( std::set::const_iterator tagIt = it->getTestCaseInfo().tags.begin(), tagItEnd = it->getTestCaseInfo().tags.end(); tagIt != tagItEnd; ++tagIt ) { std::string tagName = *tagIt; std::string lcaseTagName = toLower( tagName ); std::map::iterator countIt = tagCounts.find( lcaseTagName ); if( countIt == tagCounts.end() ) countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first; countIt->second.add( tagName ); } } for( std::map::const_iterator countIt = tagCounts.begin(), countItEnd = tagCounts.end(); countIt != countItEnd; ++countIt ) { std::ostringstream oss; oss << " " << std::setw(2) << countIt->second.count << " "; Text wrapper( countIt->second.all(), TextAttributes() .setInitialIndent( 0 ) .setIndent( oss.str().size() ) .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) ); Catch::cout() << oss.str() << wrapper << "\n"; } Catch::cout() << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl; return tagCounts.size(); } inline std::size_t listReporters( Config const& /*config*/ ) { Catch::cout() << "Available reporters:\n"; IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories(); IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it; std::size_t maxNameLen = 0; for(it = itBegin; it != itEnd; ++it ) maxNameLen = (std::max)( maxNameLen, it->first.size() ); for(it = itBegin; it != itEnd; ++it ) { Text wrapper( it->second->getDescription(), TextAttributes() .setInitialIndent( 0 ) .setIndent( 7+maxNameLen ) .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) ); Catch::cout() << " " << it->first << ":" << std::string( maxNameLen - it->first.size() + 2, ' ' ) << wrapper << "\n"; } Catch::cout() << std::endl; return factories.size(); } inline Option list( Config const& config ) { Option listedCount; if( config.listTests() ) listedCount = listedCount.valueOr(0) + listTests( config ); if( config.listTestNamesOnly() ) listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config ); if( config.listTags() ) listedCount = listedCount.valueOr(0) + listTags( config ); if( config.listReporters() ) listedCount = listedCount.valueOr(0) + listReporters( config ); return listedCount; } } // end namespace Catch // #included from: internal/catch_run_context.hpp #define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED // #included from: catch_test_case_tracker.hpp #define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED #include #include #include #include namespace Catch { namespace TestCaseTracking { struct ITracker : SharedImpl<> { virtual ~ITracker(); // static queries virtual std::string name() const = 0; // dynamic queries virtual bool isComplete() const = 0; // Successfully completed or failed virtual bool isSuccessfullyCompleted() const = 0; virtual bool isOpen() const = 0; // Started but not complete virtual bool hasChildren() const = 0; virtual ITracker& parent() = 0; // actions virtual void close() = 0; // Successfully complete virtual void fail() = 0; virtual void markAsNeedingAnotherRun() = 0; virtual void addChild( Ptr const& child ) = 0; virtual ITracker* findChild( std::string const& name ) = 0; virtual void openChild() = 0; }; class TrackerContext { enum RunState { NotStarted, Executing, CompletedCycle }; Ptr m_rootTracker; ITracker* m_currentTracker; RunState m_runState; public: static TrackerContext& instance() { static TrackerContext s_instance; return s_instance; } TrackerContext() : m_currentTracker( CATCH_NULL ), m_runState( NotStarted ) {} ITracker& startRun(); void endRun() { m_rootTracker.reset(); m_currentTracker = CATCH_NULL; m_runState = NotStarted; } void startCycle() { m_currentTracker = m_rootTracker.get(); m_runState = Executing; } void completeCycle() { m_runState = CompletedCycle; } bool completedCycle() const { return m_runState == CompletedCycle; } ITracker& currentTracker() { return *m_currentTracker; } void setCurrentTracker( ITracker* tracker ) { m_currentTracker = tracker; } }; class TrackerBase : public ITracker { protected: enum CycleState { NotStarted, Executing, ExecutingChildren, NeedsAnotherRun, CompletedSuccessfully, Failed }; class TrackerHasName { std::string m_name; public: TrackerHasName( std::string const& name ) : m_name( name ) {} bool operator ()( Ptr const& tracker ) { return tracker->name() == m_name; } }; typedef std::vector > Children; std::string m_name; TrackerContext& m_ctx; ITracker* m_parent; Children m_children; CycleState m_runState; public: TrackerBase( std::string const& name, TrackerContext& ctx, ITracker* parent ) : m_name( name ), m_ctx( ctx ), m_parent( parent ), m_runState( NotStarted ) {} virtual ~TrackerBase(); virtual std::string name() const CATCH_OVERRIDE { return m_name; } virtual bool isComplete() const CATCH_OVERRIDE { return m_runState == CompletedSuccessfully || m_runState == Failed; } virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE { return m_runState == CompletedSuccessfully; } virtual bool isOpen() const CATCH_OVERRIDE { return m_runState != NotStarted && !isComplete(); } virtual bool hasChildren() const CATCH_OVERRIDE { return !m_children.empty(); } virtual void addChild( Ptr const& child ) CATCH_OVERRIDE { m_children.push_back( child ); } virtual ITracker* findChild( std::string const& name ) CATCH_OVERRIDE { Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( name ) ); return( it != m_children.end() ) ? it->get() : CATCH_NULL; } virtual ITracker& parent() CATCH_OVERRIDE { assert( m_parent ); // Should always be non-null except for root return *m_parent; } virtual void openChild() CATCH_OVERRIDE { if( m_runState != ExecutingChildren ) { m_runState = ExecutingChildren; if( m_parent ) m_parent->openChild(); } } void open() { m_runState = Executing; moveToThis(); if( m_parent ) m_parent->openChild(); } virtual void close() CATCH_OVERRIDE { // Close any still open children (e.g. generators) while( &m_ctx.currentTracker() != this ) m_ctx.currentTracker().close(); switch( m_runState ) { case NotStarted: case CompletedSuccessfully: case Failed: throw std::logic_error( "Illogical state" ); case NeedsAnotherRun: break;; case Executing: m_runState = CompletedSuccessfully; break; case ExecutingChildren: if( m_children.empty() || m_children.back()->isComplete() ) m_runState = CompletedSuccessfully; break; default: throw std::logic_error( "Unexpected state" ); } moveToParent(); m_ctx.completeCycle(); } virtual void fail() CATCH_OVERRIDE { m_runState = Failed; if( m_parent ) m_parent->markAsNeedingAnotherRun(); moveToParent(); m_ctx.completeCycle(); } virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE { m_runState = NeedsAnotherRun; } private: void moveToParent() { assert( m_parent ); m_ctx.setCurrentTracker( m_parent ); } void moveToThis() { m_ctx.setCurrentTracker( this ); } }; class SectionTracker : public TrackerBase { public: SectionTracker( std::string const& name, TrackerContext& ctx, ITracker* parent ) : TrackerBase( name, ctx, parent ) {} virtual ~SectionTracker(); static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) { SectionTracker* section = CATCH_NULL; ITracker& currentTracker = ctx.currentTracker(); if( ITracker* childTracker = currentTracker.findChild( name ) ) { section = dynamic_cast( childTracker ); assert( section ); } else { section = new SectionTracker( name, ctx, ¤tTracker ); currentTracker.addChild( section ); } if( !ctx.completedCycle() && !section->isComplete() ) { section->open(); } return *section; } }; class IndexTracker : public TrackerBase { int m_size; int m_index; public: IndexTracker( std::string const& name, TrackerContext& ctx, ITracker* parent, int size ) : TrackerBase( name, ctx, parent ), m_size( size ), m_index( -1 ) {} virtual ~IndexTracker(); static IndexTracker& acquire( TrackerContext& ctx, std::string const& name, int size ) { IndexTracker* tracker = CATCH_NULL; ITracker& currentTracker = ctx.currentTracker(); if( ITracker* childTracker = currentTracker.findChild( name ) ) { tracker = dynamic_cast( childTracker ); assert( tracker ); } else { tracker = new IndexTracker( name, ctx, ¤tTracker, size ); currentTracker.addChild( tracker ); } if( !ctx.completedCycle() && !tracker->isComplete() ) { if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun ) tracker->moveNext(); tracker->open(); } return *tracker; } int index() const { return m_index; } void moveNext() { m_index++; m_children.clear(); } virtual void close() CATCH_OVERRIDE { TrackerBase::close(); if( m_runState == CompletedSuccessfully && m_index < m_size-1 ) m_runState = Executing; } }; inline ITracker& TrackerContext::startRun() { m_rootTracker = new SectionTracker( "{root}", *this, CATCH_NULL ); m_currentTracker = CATCH_NULL; m_runState = Executing; return *m_rootTracker; } } // namespace TestCaseTracking using TestCaseTracking::ITracker; using TestCaseTracking::TrackerContext; using TestCaseTracking::SectionTracker; using TestCaseTracking::IndexTracker; } // namespace Catch // #included from: catch_fatal_condition.hpp #define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED namespace Catch { // Report the error condition then exit the process inline void fatal( std::string const& message, int exitCode ) { IContext& context = Catch::getCurrentContext(); IResultCapture* resultCapture = context.getResultCapture(); resultCapture->handleFatalErrorCondition( message ); if( Catch::alwaysTrue() ) // avoids "no return" warnings exit( exitCode ); } } // namespace Catch #if defined ( CATCH_PLATFORM_WINDOWS ) ///////////////////////////////////////// namespace Catch { struct FatalConditionHandler { void reset() {} }; } // namespace Catch #else // Not Windows - assumed to be POSIX compatible ////////////////////////// #include namespace Catch { struct SignalDefs { int id; const char* name; }; extern SignalDefs signalDefs[]; SignalDefs signalDefs[] = { { SIGINT, "SIGINT - Terminal interrupt signal" }, { SIGILL, "SIGILL - Illegal instruction signal" }, { SIGFPE, "SIGFPE - Floating point error signal" }, { SIGSEGV, "SIGSEGV - Segmentation violation signal" }, { SIGTERM, "SIGTERM - Termination request signal" }, { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" } }; struct FatalConditionHandler { static void handleSignal( int sig ) { for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) if( sig == signalDefs[i].id ) fatal( signalDefs[i].name, -sig ); fatal( "", -sig ); } FatalConditionHandler() : m_isSet( true ) { for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) signal( signalDefs[i].id, handleSignal ); } ~FatalConditionHandler() { reset(); } void reset() { if( m_isSet ) { for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) signal( signalDefs[i].id, SIG_DFL ); m_isSet = false; } } bool m_isSet; }; } // namespace Catch #endif // not Windows #include #include namespace Catch { class StreamRedirect { public: StreamRedirect( std::ostream& stream, std::string& targetString ) : m_stream( stream ), m_prevBuf( stream.rdbuf() ), m_targetString( targetString ) { stream.rdbuf( m_oss.rdbuf() ); } ~StreamRedirect() { m_targetString += m_oss.str(); m_stream.rdbuf( m_prevBuf ); } private: std::ostream& m_stream; std::streambuf* m_prevBuf; std::ostringstream m_oss; std::string& m_targetString; }; /////////////////////////////////////////////////////////////////////////// class RunContext : public IResultCapture, public IRunner { RunContext( RunContext const& ); void operator =( RunContext const& ); public: explicit RunContext( Ptr const& _config, Ptr const& reporter ) : m_runInfo( _config->name() ), m_context( getCurrentMutableContext() ), m_activeTestCase( CATCH_NULL ), m_config( _config ), m_reporter( reporter ) { m_context.setRunner( this ); m_context.setConfig( m_config ); m_context.setResultCapture( this ); m_reporter->testRunStarting( m_runInfo ); } virtual ~RunContext() { m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) ); } void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) { m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) ); } void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) { m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) ); } Totals runTest( TestCase const& testCase ) { Totals prevTotals = m_totals; std::string redirectedCout; std::string redirectedCerr; TestCaseInfo testInfo = testCase.getTestCaseInfo(); m_reporter->testCaseStarting( testInfo ); m_activeTestCase = &testCase; do { m_trackerContext.startRun(); do { m_trackerContext.startCycle(); m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, testInfo.name ); runCurrentTest( redirectedCout, redirectedCerr ); } while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() ); } // !TBD: deprecated - this will be replaced by indexed trackers while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() ); Totals deltaTotals = m_totals.delta( prevTotals ); if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) { deltaTotals.assertions.failed++; deltaTotals.testCases.passed--; deltaTotals.testCases.failed++; } m_totals.testCases += deltaTotals.testCases; m_reporter->testCaseEnded( TestCaseStats( testInfo, deltaTotals, redirectedCout, redirectedCerr, aborting() ) ); m_activeTestCase = CATCH_NULL; m_testCaseTracker = CATCH_NULL; return deltaTotals; } Ptr config() const { return m_config; } private: // IResultCapture virtual void assertionEnded( AssertionResult const& result ) { if( result.getResultType() == ResultWas::Ok ) { m_totals.assertions.passed++; } else if( !result.isOk() ) { m_totals.assertions.failed++; } if( m_reporter->assertionEnded( AssertionStats( result, m_messages, m_totals ) ) ) m_messages.clear(); // Reset working state m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition ); m_lastResult = result; } virtual bool sectionStarted ( SectionInfo const& sectionInfo, Counts& assertions ) { std::ostringstream oss; oss << sectionInfo.name << "@" << sectionInfo.lineInfo; ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, oss.str() ); if( !sectionTracker.isOpen() ) return false; m_activeSections.push_back( §ionTracker ); m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo; m_reporter->sectionStarting( sectionInfo ); assertions = m_totals.assertions; return true; } bool testForMissingAssertions( Counts& assertions ) { if( assertions.total() != 0 ) return false; if( !m_config->warnAboutMissingAssertions() ) return false; if( m_trackerContext.currentTracker().hasChildren() ) return false; m_totals.assertions.failed++; assertions.failed++; return true; } virtual void sectionEnded( SectionEndInfo const& endInfo ) { Counts assertions = m_totals.assertions - endInfo.prevAssertions; bool missingAssertions = testForMissingAssertions( assertions ); if( !m_activeSections.empty() ) { m_activeSections.back()->close(); m_activeSections.pop_back(); } m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) ); m_messages.clear(); } virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) { if( m_unfinishedSections.empty() ) m_activeSections.back()->fail(); else m_activeSections.back()->close(); m_activeSections.pop_back(); m_unfinishedSections.push_back( endInfo ); } virtual void pushScopedMessage( MessageInfo const& message ) { m_messages.push_back( message ); } virtual void popScopedMessage( MessageInfo const& message ) { m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() ); } virtual std::string getCurrentTestName() const { return m_activeTestCase ? m_activeTestCase->getTestCaseInfo().name : ""; } virtual const AssertionResult* getLastResult() const { return &m_lastResult; } virtual void handleFatalErrorCondition( std::string const& message ) { ResultBuilder resultBuilder = makeUnexpectedResultBuilder(); resultBuilder.setResultType( ResultWas::FatalErrorCondition ); resultBuilder << message; resultBuilder.captureExpression(); handleUnfinishedSections(); // Recreate section for test case (as we will lose the one that was in scope) TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); Counts assertions; assertions.failed = 1; SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false ); m_reporter->sectionEnded( testCaseSectionStats ); TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo(); Totals deltaTotals; deltaTotals.testCases.failed = 1; m_reporter->testCaseEnded( TestCaseStats( testInfo, deltaTotals, "", "", false ) ); m_totals.testCases.failed++; testGroupEnded( "", m_totals, 1, 1 ); m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) ); } public: // !TBD We need to do this another way! bool aborting() const { return m_totals.assertions.failed == static_cast( m_config->abortAfter() ); } private: void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) { TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); m_reporter->sectionStarting( testCaseSection ); Counts prevAssertions = m_totals.assertions; double duration = 0; try { m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal ); seedRng( *m_config ); Timer timer; timer.start(); if( m_reporter->getPreferences().shouldRedirectStdOut ) { StreamRedirect coutRedir( Catch::cout(), redirectedCout ); StreamRedirect cerrRedir( Catch::cerr(), redirectedCerr ); invokeActiveTestCase(); } else { invokeActiveTestCase(); } duration = timer.getElapsedSeconds(); } catch( TestFailureException& ) { // This just means the test was aborted due to failure } catch(...) { makeUnexpectedResultBuilder().useActiveException(); } m_testCaseTracker->close(); handleUnfinishedSections(); m_messages.clear(); Counts assertions = m_totals.assertions - prevAssertions; bool missingAssertions = testForMissingAssertions( assertions ); if( testCaseInfo.okToFail() ) { std::swap( assertions.failedButOk, assertions.failed ); m_totals.assertions.failed -= assertions.failedButOk; m_totals.assertions.failedButOk += assertions.failedButOk; } SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions ); m_reporter->sectionEnded( testCaseSectionStats ); } void invokeActiveTestCase() { FatalConditionHandler fatalConditionHandler; // Handle signals m_activeTestCase->invoke(); fatalConditionHandler.reset(); } private: ResultBuilder makeUnexpectedResultBuilder() const { return ResultBuilder( m_lastAssertionInfo.macroName.c_str(), m_lastAssertionInfo.lineInfo, m_lastAssertionInfo.capturedExpression.c_str(), m_lastAssertionInfo.resultDisposition ); } void handleUnfinishedSections() { // If sections ended prematurely due to an exception we stored their // infos here so we can tear them down outside the unwind process. for( std::vector::const_reverse_iterator it = m_unfinishedSections.rbegin(), itEnd = m_unfinishedSections.rend(); it != itEnd; ++it ) sectionEnded( *it ); m_unfinishedSections.clear(); } TestRunInfo m_runInfo; IMutableContext& m_context; TestCase const* m_activeTestCase; ITracker* m_testCaseTracker; ITracker* m_currentSectionTracker; AssertionResult m_lastResult; Ptr m_config; Totals m_totals; Ptr m_reporter; std::vector m_messages; AssertionInfo m_lastAssertionInfo; std::vector m_unfinishedSections; std::vector m_activeSections; TrackerContext m_trackerContext; }; IResultCapture& getResultCapture() { if( IResultCapture* capture = getCurrentContext().getResultCapture() ) return *capture; else throw std::logic_error( "No result capture instance" ); } } // end namespace Catch // #included from: internal/catch_version.h #define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED namespace Catch { // Versioning information struct Version { Version( unsigned int _majorVersion, unsigned int _minorVersion, unsigned int _patchNumber, std::string const& _branchName, unsigned int _buildNumber ); unsigned int const majorVersion; unsigned int const minorVersion; unsigned int const patchNumber; // buildNumber is only used if branchName is not null std::string const branchName; unsigned int const buildNumber; friend std::ostream& operator << ( std::ostream& os, Version const& version ); private: void operator=( Version const& ); }; extern Version libraryVersion; } #include #include #include namespace Catch { Ptr createReporter( std::string const& reporterName, Ptr const& config ) { Ptr reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() ); if( !reporter ) { std::ostringstream oss; oss << "No reporter registered with name: '" << reporterName << "'"; throw std::domain_error( oss.str() ); } return reporter; } Ptr makeReporter( Ptr const& config ) { std::vector reporters = config->getReporterNames(); if( reporters.empty() ) reporters.push_back( "console" ); Ptr reporter; for( std::vector::const_iterator it = reporters.begin(), itEnd = reporters.end(); it != itEnd; ++it ) reporter = addReporter( reporter, createReporter( *it, config ) ); return reporter; } Ptr addListeners( Ptr const& config, Ptr reporters ) { IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners(); for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end(); it != itEnd; ++it ) reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) ); return reporters; } Totals runTests( Ptr const& config ) { Ptr iconfig = config.get(); Ptr reporter = makeReporter( config ); reporter = addListeners( iconfig, reporter ); RunContext context( iconfig, reporter ); Totals totals; context.testGroupStarting( config->name(), 1, 1 ); TestSpec testSpec = config->testSpec(); if( !testSpec.hasFilters() ) testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests std::vector const& allTestCases = getAllTestCasesSorted( *iconfig ); for( std::vector::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end(); it != itEnd; ++it ) { if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) ) totals += context.runTest( *it ); else reporter->skipTest( *it ); } context.testGroupEnded( iconfig->name(), totals, 1, 1 ); return totals; } void applyFilenamesAsTags( IConfig const& config ) { std::vector const& tests = getAllTestCasesSorted( config ); for(std::size_t i = 0; i < tests.size(); ++i ) { TestCase& test = const_cast( tests[i] ); std::set tags = test.tags; std::string filename = test.lineInfo.file; std::string::size_type lastSlash = filename.find_last_of( "\\/" ); if( lastSlash != std::string::npos ) filename = filename.substr( lastSlash+1 ); std::string::size_type lastDot = filename.find_last_of( "." ); if( lastDot != std::string::npos ) filename = filename.substr( 0, lastDot ); tags.insert( "#" + filename ); setTags( test, tags ); } } class Session : NonCopyable { static bool alreadyInstantiated; public: struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; }; Session() : m_cli( makeCommandLineParser() ) { if( alreadyInstantiated ) { std::string msg = "Only one instance of Catch::Session can ever be used"; Catch::cerr() << msg << std::endl; throw std::logic_error( msg ); } alreadyInstantiated = true; } ~Session() { Catch::cleanUp(); } void showHelp( std::string const& processName ) { Catch::cout() << "\nCatch v" << libraryVersion << "\n"; m_cli.usage( Catch::cout(), processName ); Catch::cout() << "For more detail usage please see the project docs\n" << std::endl; } int applyCommandLine( int argc, char const* argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) { try { m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail ); m_unusedTokens = m_cli.parseInto( argc, argv, m_configData ); if( m_configData.showHelp ) showHelp( m_configData.processName ); m_config.reset(); } catch( std::exception& ex ) { { Colour colourGuard( Colour::Red ); Catch::cerr() << "\nError(s) in input:\n" << Text( ex.what(), TextAttributes().setIndent(2) ) << "\n\n"; } m_cli.usage( Catch::cout(), m_configData.processName ); return (std::numeric_limits::max)(); } return 0; } void useConfigData( ConfigData const& _configData ) { m_configData = _configData; m_config.reset(); } int run( int argc, char const* argv[] ) { int returnCode = applyCommandLine( argc, argv ); if( returnCode == 0 ) returnCode = run(); return returnCode; } int run( int argc, char* argv[] ) { return run( argc, const_cast( argv ) ); } int run() { if( m_configData.showHelp ) return 0; try { config(); // Force config to be constructed seedRng( *m_config ); if( m_configData.filenamesAsTags ) applyFilenamesAsTags( *m_config ); // Handle list request if( Option listed = list( config() ) ) return static_cast( *listed ); return static_cast( runTests( m_config ).assertions.failed ); } catch( std::exception& ex ) { Catch::cerr() << ex.what() << std::endl; return (std::numeric_limits::max)(); } } Clara::CommandLine const& cli() const { return m_cli; } std::vector const& unusedTokens() const { return m_unusedTokens; } ConfigData& configData() { return m_configData; } Config& config() { if( !m_config ) m_config = new Config( m_configData ); return *m_config; } private: Clara::CommandLine m_cli; std::vector m_unusedTokens; ConfigData m_configData; Ptr m_config; }; bool Session::alreadyInstantiated = false; } // end namespace Catch // #included from: catch_registry_hub.hpp #define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED // #included from: catch_test_case_registry_impl.hpp #define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED #include #include #include #include #include namespace Catch { struct LexSort { bool operator() (TestCase i,TestCase j) const { return (i sortTests( IConfig const& config, std::vector const& unsortedTestCases ) { std::vector sorted = unsortedTestCases; switch( config.runOrder() ) { case RunTests::InLexicographicalOrder: std::sort( sorted.begin(), sorted.end(), LexSort() ); break; case RunTests::InRandomOrder: { seedRng( config ); RandomNumberGenerator rng; std::random_shuffle( sorted.begin(), sorted.end(), rng ); } break; case RunTests::InDeclarationOrder: // already in declaration order break; } return sorted; } bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) { return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() ); } void enforceNoDuplicateTestCases( std::vector const& functions ) { std::set seenFunctions; for( std::vector::const_iterator it = functions.begin(), itEnd = functions.end(); it != itEnd; ++it ) { std::pair::const_iterator, bool> prev = seenFunctions.insert( *it ); if( !prev.second ){ Catch::cerr() << Colour( Colour::Red ) << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n" << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n" << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl; exit(1); } } } std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ) { std::vector filtered; filtered.reserve( testCases.size() ); for( std::vector::const_iterator it = testCases.begin(), itEnd = testCases.end(); it != itEnd; ++it ) if( matchTest( *it, testSpec, config ) ) filtered.push_back( *it ); return filtered; } std::vector const& getAllTestCasesSorted( IConfig const& config ) { return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config ); } class TestRegistry : public ITestCaseRegistry { public: TestRegistry() : m_currentSortOrder( RunTests::InDeclarationOrder ), m_unnamedCount( 0 ) {} virtual ~TestRegistry(); virtual void registerTest( TestCase const& testCase ) { std::string name = testCase.getTestCaseInfo().name; if( name == "" ) { std::ostringstream oss; oss << "Anonymous test case " << ++m_unnamedCount; return registerTest( testCase.withName( oss.str() ) ); } m_functions.push_back( testCase ); } virtual std::vector const& getAllTests() const { return m_functions; } virtual std::vector const& getAllTestsSorted( IConfig const& config ) const { if( m_sortedFunctions.empty() ) enforceNoDuplicateTestCases( m_functions ); if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) { m_sortedFunctions = sortTests( config, m_functions ); m_currentSortOrder = config.runOrder(); } return m_sortedFunctions; } private: std::vector m_functions; mutable RunTests::InWhatOrder m_currentSortOrder; mutable std::vector m_sortedFunctions; size_t m_unnamedCount; std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised }; /////////////////////////////////////////////////////////////////////////// class FreeFunctionTestCase : public SharedImpl { public: FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {} virtual void invoke() const { m_fun(); } private: virtual ~FreeFunctionTestCase(); TestFunction m_fun; }; inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) { std::string className = classOrQualifiedMethodName; if( startsWith( className, "&" ) ) { std::size_t lastColons = className.rfind( "::" ); std::size_t penultimateColons = className.rfind( "::", lastColons-1 ); if( penultimateColons == std::string::npos ) penultimateColons = 1; className = className.substr( penultimateColons, lastColons-penultimateColons ); } return className; } void registerTestCase ( ITestCase* testCase, char const* classOrQualifiedMethodName, NameAndDesc const& nameAndDesc, SourceLineInfo const& lineInfo ) { getMutableRegistryHub().registerTest ( makeTestCase ( testCase, extractClassName( classOrQualifiedMethodName ), nameAndDesc.name, nameAndDesc.description, lineInfo ) ); } void registerTestCaseFunction ( TestFunction function, SourceLineInfo const& lineInfo, NameAndDesc const& nameAndDesc ) { registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo ); } /////////////////////////////////////////////////////////////////////////// AutoReg::AutoReg ( TestFunction function, SourceLineInfo const& lineInfo, NameAndDesc const& nameAndDesc ) { registerTestCaseFunction( function, lineInfo, nameAndDesc ); } AutoReg::~AutoReg() {} } // end namespace Catch // #included from: catch_reporter_registry.hpp #define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED #include namespace Catch { class ReporterRegistry : public IReporterRegistry { public: virtual ~ReporterRegistry() CATCH_OVERRIDE {} virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const CATCH_OVERRIDE { FactoryMap::const_iterator it = m_factories.find( name ); if( it == m_factories.end() ) return CATCH_NULL; return it->second->create( ReporterConfig( config ) ); } void registerReporter( std::string const& name, Ptr const& factory ) { m_factories.insert( std::make_pair( name, factory ) ); } void registerListener( Ptr const& factory ) { m_listeners.push_back( factory ); } virtual FactoryMap const& getFactories() const CATCH_OVERRIDE { return m_factories; } virtual Listeners const& getListeners() const CATCH_OVERRIDE { return m_listeners; } private: FactoryMap m_factories; Listeners m_listeners; }; } // #included from: catch_exception_translator_registry.hpp #define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED #ifdef __OBJC__ #import "Foundation/Foundation.h" #endif namespace Catch { class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry { public: ~ExceptionTranslatorRegistry() { deleteAll( m_translators ); } virtual void registerTranslator( const IExceptionTranslator* translator ) { m_translators.push_back( translator ); } virtual std::string translateActiveException() const { try { #ifdef __OBJC__ // In Objective-C try objective-c exceptions first @try { return tryTranslators(); } @catch (NSException *exception) { return Catch::toString( [exception description] ); } #else return tryTranslators(); #endif } catch( TestFailureException& ) { throw; } catch( std::exception& ex ) { return ex.what(); } catch( std::string& msg ) { return msg; } catch( const char* msg ) { return msg; } catch(...) { return "Unknown exception"; } } std::string tryTranslators() const { if( m_translators.empty() ) throw; else return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() ); } private: std::vector m_translators; }; } namespace Catch { namespace { class RegistryHub : public IRegistryHub, public IMutableRegistryHub { RegistryHub( RegistryHub const& ); void operator=( RegistryHub const& ); public: // IRegistryHub RegistryHub() { } virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE { return m_reporterRegistry; } virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE { return m_testCaseRegistry; } virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE { return m_exceptionTranslatorRegistry; } public: // IMutableRegistryHub virtual void registerReporter( std::string const& name, Ptr const& factory ) CATCH_OVERRIDE { m_reporterRegistry.registerReporter( name, factory ); } virtual void registerListener( Ptr const& factory ) CATCH_OVERRIDE { m_reporterRegistry.registerListener( factory ); } virtual void registerTest( TestCase const& testInfo ) CATCH_OVERRIDE { m_testCaseRegistry.registerTest( testInfo ); } virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE { m_exceptionTranslatorRegistry.registerTranslator( translator ); } private: TestRegistry m_testCaseRegistry; ReporterRegistry m_reporterRegistry; ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; }; // Single, global, instance inline RegistryHub*& getTheRegistryHub() { static RegistryHub* theRegistryHub = CATCH_NULL; if( !theRegistryHub ) theRegistryHub = new RegistryHub(); return theRegistryHub; } } IRegistryHub& getRegistryHub() { return *getTheRegistryHub(); } IMutableRegistryHub& getMutableRegistryHub() { return *getTheRegistryHub(); } void cleanUp() { delete getTheRegistryHub(); getTheRegistryHub() = CATCH_NULL; cleanUpContext(); } std::string translateActiveException() { return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); } } // end namespace Catch // #included from: catch_notimplemented_exception.hpp #define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED #include namespace Catch { NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo ) : m_lineInfo( lineInfo ) { std::ostringstream oss; oss << lineInfo << ": function "; oss << "not implemented"; m_what = oss.str(); } const char* NotImplementedException::what() const CATCH_NOEXCEPT { return m_what.c_str(); } } // end namespace Catch // #included from: catch_context_impl.hpp #define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED // #included from: catch_stream.hpp #define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED #include #include #include namespace Catch { template class StreamBufImpl : public StreamBufBase { char data[bufferSize]; WriterF m_writer; public: StreamBufImpl() { setp( data, data + sizeof(data) ); } ~StreamBufImpl() CATCH_NOEXCEPT { sync(); } private: int overflow( int c ) { sync(); if( c != EOF ) { if( pbase() == epptr() ) m_writer( std::string( 1, static_cast( c ) ) ); else sputc( static_cast( c ) ); } return 0; } int sync() { if( pbase() != pptr() ) { m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) ); setp( pbase(), epptr() ); } return 0; } }; /////////////////////////////////////////////////////////////////////////// FileStream::FileStream( std::string const& filename ) { m_ofs.open( filename.c_str() ); if( m_ofs.fail() ) { std::ostringstream oss; oss << "Unable to open file: '" << filename << "'"; throw std::domain_error( oss.str() ); } } std::ostream& FileStream::stream() const { return m_ofs; } struct OutputDebugWriter { void operator()( std::string const&str ) { writeToDebugConsole( str ); } }; DebugOutStream::DebugOutStream() : m_streamBuf( new StreamBufImpl() ), m_os( m_streamBuf.get() ) {} std::ostream& DebugOutStream::stream() const { return m_os; } // Store the streambuf from cout up-front because // cout may get redirected when running tests CoutStream::CoutStream() : m_os( Catch::cout().rdbuf() ) {} std::ostream& CoutStream::stream() const { return m_os; } #ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions std::ostream& cout() { return std::cout; } std::ostream& cerr() { return std::cerr; } #endif } namespace Catch { class Context : public IMutableContext { Context() : m_config( CATCH_NULL ), m_runner( CATCH_NULL ), m_resultCapture( CATCH_NULL ) {} Context( Context const& ); void operator=( Context const& ); public: // IContext virtual IResultCapture* getResultCapture() { return m_resultCapture; } virtual IRunner* getRunner() { return m_runner; } virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) { return getGeneratorsForCurrentTest() .getGeneratorInfo( fileInfo, totalSize ) .getCurrentIndex(); } virtual bool advanceGeneratorsForCurrentTest() { IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); return generators && generators->moveNext(); } virtual Ptr getConfig() const { return m_config; } public: // IMutableContext virtual void setResultCapture( IResultCapture* resultCapture ) { m_resultCapture = resultCapture; } virtual void setRunner( IRunner* runner ) { m_runner = runner; } virtual void setConfig( Ptr const& config ) { m_config = config; } friend IMutableContext& getCurrentMutableContext(); private: IGeneratorsForTest* findGeneratorsForCurrentTest() { std::string testName = getResultCapture()->getCurrentTestName(); std::map::const_iterator it = m_generatorsByTestName.find( testName ); return it != m_generatorsByTestName.end() ? it->second : CATCH_NULL; } IGeneratorsForTest& getGeneratorsForCurrentTest() { IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); if( !generators ) { std::string testName = getResultCapture()->getCurrentTestName(); generators = createGeneratorsForTest(); m_generatorsByTestName.insert( std::make_pair( testName, generators ) ); } return *generators; } private: Ptr m_config; IRunner* m_runner; IResultCapture* m_resultCapture; std::map m_generatorsByTestName; }; namespace { Context* currentContext = CATCH_NULL; } IMutableContext& getCurrentMutableContext() { if( !currentContext ) currentContext = new Context(); return *currentContext; } IContext& getCurrentContext() { return getCurrentMutableContext(); } void cleanUpContext() { delete currentContext; currentContext = CATCH_NULL; } } // #included from: catch_console_colour_impl.hpp #define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED namespace Catch { namespace { struct IColourImpl { virtual ~IColourImpl() {} virtual void use( Colour::Code _colourCode ) = 0; }; struct NoColourImpl : IColourImpl { void use( Colour::Code ) {} static IColourImpl* instance() { static NoColourImpl s_instance; return &s_instance; } }; } // anon namespace } // namespace Catch #if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI ) # ifdef CATCH_PLATFORM_WINDOWS # define CATCH_CONFIG_COLOUR_WINDOWS # else # define CATCH_CONFIG_COLOUR_ANSI # endif #endif #if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) ///////////////////////////////////////// #ifndef NOMINMAX #define NOMINMAX #endif #ifdef __AFXDLL #include #else #include #endif namespace Catch { namespace { class Win32ColourImpl : public IColourImpl { public: Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) ) { CONSOLE_SCREEN_BUFFER_INFO csbiInfo; GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo ); originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY ); originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY ); } virtual void use( Colour::Code _colourCode ) { switch( _colourCode ) { case Colour::None: return setTextAttribute( originalForegroundAttributes ); case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); case Colour::Red: return setTextAttribute( FOREGROUND_RED ); case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); case Colour::Grey: return setTextAttribute( 0 ); case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); case Colour::Bright: throw std::logic_error( "not a colour" ); } } private: void setTextAttribute( WORD _textAttribute ) { SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes ); } HANDLE stdoutHandle; WORD originalForegroundAttributes; WORD originalBackgroundAttributes; }; IColourImpl* platformColourInstance() { static Win32ColourImpl s_instance; Ptr config = getCurrentContext().getConfig(); UseColour::YesOrNo colourMode = config ? config->useColour() : UseColour::Auto; if( colourMode == UseColour::Auto ) colourMode = !isDebuggerActive() ? UseColour::Yes : UseColour::No; return colourMode == UseColour::Yes ? &s_instance : NoColourImpl::instance(); } } // end anon namespace } // end namespace Catch #elif defined( CATCH_CONFIG_COLOUR_ANSI ) ////////////////////////////////////// #include namespace Catch { namespace { // use POSIX/ ANSI console terminal codes // Thanks to Adam Strzelecki for original contribution // (http://github.com/nanoant) // https://github.com/philsquared/Catch/pull/131 class PosixColourImpl : public IColourImpl { public: virtual void use( Colour::Code _colourCode ) { switch( _colourCode ) { case Colour::None: case Colour::White: return setColour( "[0m" ); case Colour::Red: return setColour( "[0;31m" ); case Colour::Green: return setColour( "[0;32m" ); case Colour::Blue: return setColour( "[0:34m" ); case Colour::Cyan: return setColour( "[0;36m" ); case Colour::Yellow: return setColour( "[0;33m" ); case Colour::Grey: return setColour( "[1;30m" ); case Colour::LightGrey: return setColour( "[0;37m" ); case Colour::BrightRed: return setColour( "[1;31m" ); case Colour::BrightGreen: return setColour( "[1;32m" ); case Colour::BrightWhite: return setColour( "[1;37m" ); case Colour::Bright: throw std::logic_error( "not a colour" ); } } static IColourImpl* instance() { static PosixColourImpl s_instance; return &s_instance; } private: void setColour( const char* _escapeCode ) { Catch::cout() << '\033' << _escapeCode; } }; IColourImpl* platformColourInstance() { Ptr config = getCurrentContext().getConfig(); UseColour::YesOrNo colourMode = config ? config->useColour() : UseColour::Auto; if( colourMode == UseColour::Auto ) colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) ) ? UseColour::Yes : UseColour::No; return colourMode == UseColour::Yes ? PosixColourImpl::instance() : NoColourImpl::instance(); } } // end anon namespace } // end namespace Catch #else // not Windows or ANSI /////////////////////////////////////////////// namespace Catch { static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); } } // end namespace Catch #endif // Windows/ ANSI/ None namespace Catch { Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); } Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast( _other ).m_moved = true; } Colour::~Colour(){ if( !m_moved ) use( None ); } void Colour::use( Code _colourCode ) { static IColourImpl* impl = platformColourInstance(); impl->use( _colourCode ); } } // end namespace Catch // #included from: catch_generators_impl.hpp #define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED #include #include #include namespace Catch { struct GeneratorInfo : IGeneratorInfo { GeneratorInfo( std::size_t size ) : m_size( size ), m_currentIndex( 0 ) {} bool moveNext() { if( ++m_currentIndex == m_size ) { m_currentIndex = 0; return false; } return true; } std::size_t getCurrentIndex() const { return m_currentIndex; } std::size_t m_size; std::size_t m_currentIndex; }; /////////////////////////////////////////////////////////////////////////// class GeneratorsForTest : public IGeneratorsForTest { public: ~GeneratorsForTest() { deleteAll( m_generatorsInOrder ); } IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) { std::map::const_iterator it = m_generatorsByName.find( fileInfo ); if( it == m_generatorsByName.end() ) { IGeneratorInfo* info = new GeneratorInfo( size ); m_generatorsByName.insert( std::make_pair( fileInfo, info ) ); m_generatorsInOrder.push_back( info ); return *info; } return *it->second; } bool moveNext() { std::vector::const_iterator it = m_generatorsInOrder.begin(); std::vector::const_iterator itEnd = m_generatorsInOrder.end(); for(; it != itEnd; ++it ) { if( (*it)->moveNext() ) return true; } return false; } private: std::map m_generatorsByName; std::vector m_generatorsInOrder; }; IGeneratorsForTest* createGeneratorsForTest() { return new GeneratorsForTest(); } } // end namespace Catch // #included from: catch_assertionresult.hpp #define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED namespace Catch { AssertionInfo::AssertionInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, std::string const& _capturedExpression, ResultDisposition::Flags _resultDisposition ) : macroName( _macroName ), lineInfo( _lineInfo ), capturedExpression( _capturedExpression ), resultDisposition( _resultDisposition ) {} AssertionResult::AssertionResult() {} AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data ) : m_info( info ), m_resultData( data ) {} AssertionResult::~AssertionResult() {} // Result was a success bool AssertionResult::succeeded() const { return Catch::isOk( m_resultData.resultType ); } // Result was a success, or failure is suppressed bool AssertionResult::isOk() const { return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); } ResultWas::OfType AssertionResult::getResultType() const { return m_resultData.resultType; } bool AssertionResult::hasExpression() const { return !m_info.capturedExpression.empty(); } bool AssertionResult::hasMessage() const { return !m_resultData.message.empty(); } std::string AssertionResult::getExpression() const { if( isFalseTest( m_info.resultDisposition ) ) return "!" + m_info.capturedExpression; else return m_info.capturedExpression; } std::string AssertionResult::getExpressionInMacro() const { if( m_info.macroName.empty() ) return m_info.capturedExpression; else return m_info.macroName + "( " + m_info.capturedExpression + " )"; } bool AssertionResult::hasExpandedExpression() const { return hasExpression() && getExpandedExpression() != getExpression(); } std::string AssertionResult::getExpandedExpression() const { return m_resultData.reconstructedExpression; } std::string AssertionResult::getMessage() const { return m_resultData.message; } SourceLineInfo AssertionResult::getSourceInfo() const { return m_info.lineInfo; } std::string AssertionResult::getTestMacroName() const { return m_info.macroName; } } // end namespace Catch // #included from: catch_test_case_info.hpp #define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED namespace Catch { inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) { if( startsWith( tag, "." ) || tag == "hide" || tag == "!hide" ) return TestCaseInfo::IsHidden; else if( tag == "!throws" ) return TestCaseInfo::Throws; else if( tag == "!shouldfail" ) return TestCaseInfo::ShouldFail; else if( tag == "!mayfail" ) return TestCaseInfo::MayFail; else return TestCaseInfo::None; } inline bool isReservedTag( std::string const& tag ) { return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !isalnum( tag[0] ); } inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) { if( isReservedTag( tag ) ) { { Colour colourGuard( Colour::Red ); Catch::cerr() << "Tag name [" << tag << "] not allowed.\n" << "Tag names starting with non alpha-numeric characters are reserved\n"; } { Colour colourGuard( Colour::FileName ); Catch::cerr() << _lineInfo << std::endl; } exit(1); } } TestCase makeTestCase( ITestCase* _testCase, std::string const& _className, std::string const& _name, std::string const& _descOrTags, SourceLineInfo const& _lineInfo ) { bool isHidden( startsWith( _name, "./" ) ); // Legacy support // Parse out tags std::set tags; std::string desc, tag; bool inTag = false; for( std::size_t i = 0; i < _descOrTags.size(); ++i ) { char c = _descOrTags[i]; if( !inTag ) { if( c == '[' ) inTag = true; else desc += c; } else { if( c == ']' ) { TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag ); if( prop == TestCaseInfo::IsHidden ) isHidden = true; else if( prop == TestCaseInfo::None ) enforceNotReservedTag( tag, _lineInfo ); tags.insert( tag ); tag.clear(); inTag = false; } else tag += c; } } if( isHidden ) { tags.insert( "hide" ); tags.insert( "." ); } TestCaseInfo info( _name, _className, desc, tags, _lineInfo ); return TestCase( _testCase, info ); } void setTags( TestCaseInfo& testCaseInfo, std::set const& tags ) { testCaseInfo.tags = tags; testCaseInfo.lcaseTags.clear(); std::ostringstream oss; for( std::set::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) { oss << "[" << *it << "]"; std::string lcaseTag = toLower( *it ); testCaseInfo.properties = static_cast( testCaseInfo.properties | parseSpecialTag( lcaseTag ) ); testCaseInfo.lcaseTags.insert( lcaseTag ); } testCaseInfo.tagsAsString = oss.str(); } TestCaseInfo::TestCaseInfo( std::string const& _name, std::string const& _className, std::string const& _description, std::set const& _tags, SourceLineInfo const& _lineInfo ) : name( _name ), className( _className ), description( _description ), lineInfo( _lineInfo ), properties( None ) { setTags( *this, _tags ); } TestCaseInfo::TestCaseInfo( TestCaseInfo const& other ) : name( other.name ), className( other.className ), description( other.description ), tags( other.tags ), lcaseTags( other.lcaseTags ), tagsAsString( other.tagsAsString ), lineInfo( other.lineInfo ), properties( other.properties ) {} bool TestCaseInfo::isHidden() const { return ( properties & IsHidden ) != 0; } bool TestCaseInfo::throws() const { return ( properties & Throws ) != 0; } bool TestCaseInfo::okToFail() const { return ( properties & (ShouldFail | MayFail ) ) != 0; } bool TestCaseInfo::expectedToFail() const { return ( properties & (ShouldFail ) ) != 0; } TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {} TestCase::TestCase( TestCase const& other ) : TestCaseInfo( other ), test( other.test ) {} TestCase TestCase::withName( std::string const& _newName ) const { TestCase other( *this ); other.name = _newName; return other; } void TestCase::swap( TestCase& other ) { test.swap( other.test ); name.swap( other.name ); className.swap( other.className ); description.swap( other.description ); tags.swap( other.tags ); lcaseTags.swap( other.lcaseTags ); tagsAsString.swap( other.tagsAsString ); std::swap( TestCaseInfo::properties, static_cast( other ).properties ); std::swap( lineInfo, other.lineInfo ); } void TestCase::invoke() const { test->invoke(); } bool TestCase::operator == ( TestCase const& other ) const { return test.get() == other.test.get() && name == other.name && className == other.className; } bool TestCase::operator < ( TestCase const& other ) const { return name < other.name; } TestCase& TestCase::operator = ( TestCase const& other ) { TestCase temp( other ); swap( temp ); return *this; } TestCaseInfo const& TestCase::getTestCaseInfo() const { return *this; } } // end namespace Catch // #included from: catch_version.hpp #define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED namespace Catch { Version::Version ( unsigned int _majorVersion, unsigned int _minorVersion, unsigned int _patchNumber, std::string const& _branchName, unsigned int _buildNumber ) : majorVersion( _majorVersion ), minorVersion( _minorVersion ), patchNumber( _patchNumber ), branchName( _branchName ), buildNumber( _buildNumber ) {} std::ostream& operator << ( std::ostream& os, Version const& version ) { os << version.majorVersion << "." << version.minorVersion << "." << version.patchNumber; if( !version.branchName.empty() ) { os << "-" << version.branchName << "." << version.buildNumber; } return os; } Version libraryVersion( 1, 4, 0, "", 0 ); } // #included from: catch_message.hpp #define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED namespace Catch { MessageInfo::MessageInfo( std::string const& _macroName, SourceLineInfo const& _lineInfo, ResultWas::OfType _type ) : macroName( _macroName ), lineInfo( _lineInfo ), type( _type ), sequence( ++globalCount ) {} // This may need protecting if threading support is added unsigned int MessageInfo::globalCount = 0; //////////////////////////////////////////////////////////////////////////// ScopedMessage::ScopedMessage( MessageBuilder const& builder ) : m_info( builder.m_info ) { m_info.message = builder.m_stream.str(); getResultCapture().pushScopedMessage( m_info ); } ScopedMessage::ScopedMessage( ScopedMessage const& other ) : m_info( other.m_info ) {} ScopedMessage::~ScopedMessage() { getResultCapture().popScopedMessage( m_info ); } } // end namespace Catch // #included from: catch_legacy_reporter_adapter.hpp #define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED // #included from: catch_legacy_reporter_adapter.h #define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED namespace Catch { // Deprecated struct IReporter : IShared { virtual ~IReporter(); virtual bool shouldRedirectStdout() const = 0; virtual void StartTesting() = 0; virtual void EndTesting( Totals const& totals ) = 0; virtual void StartGroup( std::string const& groupName ) = 0; virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0; virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0; virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0; virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0; virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0; virtual void NoAssertionsInSection( std::string const& sectionName ) = 0; virtual void NoAssertionsInTestCase( std::string const& testName ) = 0; virtual void Aborted() = 0; virtual void Result( AssertionResult const& result ) = 0; }; class LegacyReporterAdapter : public SharedImpl { public: LegacyReporterAdapter( Ptr const& legacyReporter ); virtual ~LegacyReporterAdapter(); virtual ReporterPreferences getPreferences() const; virtual void noMatchingTestCases( std::string const& ); virtual void testRunStarting( TestRunInfo const& ); virtual void testGroupStarting( GroupInfo const& groupInfo ); virtual void testCaseStarting( TestCaseInfo const& testInfo ); virtual void sectionStarting( SectionInfo const& sectionInfo ); virtual void assertionStarting( AssertionInfo const& ); virtual bool assertionEnded( AssertionStats const& assertionStats ); virtual void sectionEnded( SectionStats const& sectionStats ); virtual void testCaseEnded( TestCaseStats const& testCaseStats ); virtual void testGroupEnded( TestGroupStats const& testGroupStats ); virtual void testRunEnded( TestRunStats const& testRunStats ); virtual void skipTest( TestCaseInfo const& ); private: Ptr m_legacyReporter; }; } namespace Catch { LegacyReporterAdapter::LegacyReporterAdapter( Ptr const& legacyReporter ) : m_legacyReporter( legacyReporter ) {} LegacyReporterAdapter::~LegacyReporterAdapter() {} ReporterPreferences LegacyReporterAdapter::getPreferences() const { ReporterPreferences prefs; prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout(); return prefs; } void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {} void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) { m_legacyReporter->StartTesting(); } void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) { m_legacyReporter->StartGroup( groupInfo.name ); } void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) { m_legacyReporter->StartTestCase( testInfo ); } void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) { m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description ); } void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) { // Not on legacy interface } bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) { if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); it != itEnd; ++it ) { if( it->type == ResultWas::Info ) { ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal ); rb << it->message; rb.setResultType( ResultWas::Info ); AssertionResult result = rb.build(); m_legacyReporter->Result( result ); } } } m_legacyReporter->Result( assertionStats.assertionResult ); return true; } void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) { if( sectionStats.missingAssertions ) m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name ); m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions ); } void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) { m_legacyReporter->EndTestCase ( testCaseStats.testInfo, testCaseStats.totals, testCaseStats.stdOut, testCaseStats.stdErr ); } void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) { if( testGroupStats.aborting ) m_legacyReporter->Aborted(); m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals ); } void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) { m_legacyReporter->EndTesting( testRunStats.totals ); } void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) { } } // #included from: catch_timer.hpp #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wc++11-long-long" #endif #ifdef CATCH_PLATFORM_WINDOWS #include #else #include #endif namespace Catch { namespace { #ifdef CATCH_PLATFORM_WINDOWS uint64_t getCurrentTicks() { static uint64_t hz=0, hzo=0; if (!hz) { QueryPerformanceFrequency( reinterpret_cast( &hz ) ); QueryPerformanceCounter( reinterpret_cast( &hzo ) ); } uint64_t t; QueryPerformanceCounter( reinterpret_cast( &t ) ); return ((t-hzo)*1000000)/hz; } #else uint64_t getCurrentTicks() { timeval t; gettimeofday(&t,CATCH_NULL); return static_cast( t.tv_sec ) * 1000000ull + static_cast( t.tv_usec ); } #endif } void Timer::start() { m_ticks = getCurrentTicks(); } unsigned int Timer::getElapsedMicroseconds() const { return static_cast(getCurrentTicks() - m_ticks); } unsigned int Timer::getElapsedMilliseconds() const { return static_cast(getElapsedMicroseconds()/1000); } double Timer::getElapsedSeconds() const { return getElapsedMicroseconds()/1000000.0; } } // namespace Catch #ifdef __clang__ #pragma clang diagnostic pop #endif // #included from: catch_common.hpp #define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED namespace Catch { bool startsWith( std::string const& s, std::string const& prefix ) { return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix; } bool endsWith( std::string const& s, std::string const& suffix ) { return s.size() >= suffix.size() && s.substr( s.size()-suffix.size(), suffix.size() ) == suffix; } bool contains( std::string const& s, std::string const& infix ) { return s.find( infix ) != std::string::npos; } void toLowerInPlace( std::string& s ) { std::transform( s.begin(), s.end(), s.begin(), ::tolower ); } std::string toLower( std::string const& s ) { std::string lc = s; toLowerInPlace( lc ); return lc; } std::string trim( std::string const& str ) { static char const* whitespaceChars = "\n\r\t "; std::string::size_type start = str.find_first_not_of( whitespaceChars ); std::string::size_type end = str.find_last_not_of( whitespaceChars ); return start != std::string::npos ? str.substr( start, 1+end-start ) : ""; } bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) { bool replaced = false; std::size_t i = str.find( replaceThis ); while( i != std::string::npos ) { replaced = true; str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() ); if( i < str.size()-withThis.size() ) i = str.find( replaceThis, i+withThis.size() ); else i = std::string::npos; } return replaced; } pluralise::pluralise( std::size_t count, std::string const& label ) : m_count( count ), m_label( label ) {} std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { os << pluraliser.m_count << " " << pluraliser.m_label; if( pluraliser.m_count != 1 ) os << "s"; return os; } SourceLineInfo::SourceLineInfo() : line( 0 ){} SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line ) : file( _file ), line( _line ) {} SourceLineInfo::SourceLineInfo( SourceLineInfo const& other ) : file( other.file ), line( other.line ) {} bool SourceLineInfo::empty() const { return file.empty(); } bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const { return line == other.line && file == other.file; } bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const { return line < other.line || ( line == other.line && file < other.file ); } void seedRng( IConfig const& config ) { if( config.rngSeed() != 0 ) std::srand( config.rngSeed() ); } unsigned int rngSeed() { return getCurrentContext().getConfig()->rngSeed(); } std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) { #ifndef __GNUG__ os << info.file << "(" << info.line << ")"; #else os << info.file << ":" << info.line; #endif return os; } void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) { std::ostringstream oss; oss << locationInfo << ": Internal Catch error: '" << message << "'"; if( alwaysTrue() ) throw std::logic_error( oss.str() ); } } // #included from: catch_section.hpp #define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED namespace Catch { SectionInfo::SectionInfo ( SourceLineInfo const& _lineInfo, std::string const& _name, std::string const& _description ) : name( _name ), description( _description ), lineInfo( _lineInfo ) {} Section::Section( SectionInfo const& info ) : m_info( info ), m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) ) { m_timer.start(); } Section::~Section() { if( m_sectionIncluded ) { SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() ); if( std::uncaught_exception() ) getResultCapture().sectionEndedEarly( endInfo ); else getResultCapture().sectionEnded( endInfo ); } } // This indicates whether the section should be executed or not Section::operator bool() const { return m_sectionIncluded; } } // end namespace Catch // #included from: catch_debugger.hpp #define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED #include #ifdef CATCH_PLATFORM_MAC #include #include #include #include #include namespace Catch{ // The following function is taken directly from the following technical note: // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html // Returns true if the current process is being debugged (either // running under the debugger or has a debugger attached post facto). bool isDebuggerActive(){ int mib[4]; struct kinfo_proc info; size_t size; // Initialize the flags so that, if sysctl fails for some bizarre // reason, we get a predictable result. info.kp_proc.p_flag = 0; // Initialize mib, which tells sysctl the info we want, in this case // we're looking for information about a specific process ID. mib[0] = CTL_KERN; mib[1] = KERN_PROC; mib[2] = KERN_PROC_PID; mib[3] = getpid(); // Call sysctl. size = sizeof(info); if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0 ) { Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl; return false; } // We're being debugged if the P_TRACED flag is set. return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); } } // namespace Catch #elif defined(_MSC_VER) extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace Catch { bool isDebuggerActive() { return IsDebuggerPresent() != 0; } } #elif defined(__MINGW32__) extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); namespace Catch { bool isDebuggerActive() { return IsDebuggerPresent() != 0; } } #else namespace Catch { inline bool isDebuggerActive() { return false; } } #endif // Platform #ifdef CATCH_PLATFORM_WINDOWS extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* ); namespace Catch { void writeToDebugConsole( std::string const& text ) { ::OutputDebugStringA( text.c_str() ); } } #else namespace Catch { void writeToDebugConsole( std::string const& text ) { // !TBD: Need a version for Mac/ XCode and other IDEs Catch::cout() << text; } } #endif // Platform // #included from: catch_tostring.hpp #define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED namespace Catch { namespace Detail { const std::string unprintableString = "{?}"; namespace { const int hexThreshold = 255; struct Endianness { enum Arch { Big, Little }; static Arch which() { union _{ int asInt; char asChar[sizeof (int)]; } u; u.asInt = 1; return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little; } }; } std::string rawMemoryToString( const void *object, std::size_t size ) { // Reverse order for little endian architectures int i = 0, end = static_cast( size ), inc = 1; if( Endianness::which() == Endianness::Little ) { i = end-1; end = inc = -1; } unsigned char const *bytes = static_cast(object); std::ostringstream os; os << "0x" << std::setfill('0') << std::hex; for( ; i != end; i += inc ) os << std::setw(2) << static_cast(bytes[i]); return os.str(); } } std::string toString( std::string const& value ) { std::string s = value; if( getCurrentContext().getConfig()->showInvisibles() ) { for(size_t i = 0; i < s.size(); ++i ) { std::string subs; switch( s[i] ) { case '\n': subs = "\\n"; break; case '\t': subs = "\\t"; break; default: break; } if( !subs.empty() ) { s = s.substr( 0, i ) + subs + s.substr( i+1 ); ++i; } } } return "\"" + s + "\""; } std::string toString( std::wstring const& value ) { std::string s; s.reserve( value.size() ); for(size_t i = 0; i < value.size(); ++i ) s += value[i] <= 0xff ? static_cast( value[i] ) : '?'; return Catch::toString( s ); } std::string toString( const char* const value ) { return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" ); } std::string toString( char* const value ) { return Catch::toString( static_cast( value ) ); } std::string toString( const wchar_t* const value ) { return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" ); } std::string toString( wchar_t* const value ) { return Catch::toString( static_cast( value ) ); } std::string toString( int value ) { std::ostringstream oss; oss << value; if( value > Detail::hexThreshold ) oss << " (0x" << std::hex << value << ")"; return oss.str(); } std::string toString( unsigned long value ) { std::ostringstream oss; oss << value; if( value > Detail::hexThreshold ) oss << " (0x" << std::hex << value << ")"; return oss.str(); } std::string toString( unsigned int value ) { return Catch::toString( static_cast( value ) ); } template std::string fpToString( T value, int precision ) { std::ostringstream oss; oss << std::setprecision( precision ) << std::fixed << value; std::string d = oss.str(); std::size_t i = d.find_last_not_of( '0' ); if( i != std::string::npos && i != d.size()-1 ) { if( d[i] == '.' ) i++; d = d.substr( 0, i+1 ); } return d; } std::string toString( const double value ) { return fpToString( value, 10 ); } std::string toString( const float value ) { return fpToString( value, 5 ) + "f"; } std::string toString( bool value ) { return value ? "true" : "false"; } std::string toString( char value ) { return value < ' ' ? toString( static_cast( value ) ) : Detail::makeString( value ); } std::string toString( signed char value ) { return toString( static_cast( value ) ); } std::string toString( unsigned char value ) { return toString( static_cast( value ) ); } #ifdef CATCH_CONFIG_CPP11_LONG_LONG std::string toString( long long value ) { std::ostringstream oss; oss << value; if( value > Detail::hexThreshold ) oss << " (0x" << std::hex << value << ")"; return oss.str(); } std::string toString( unsigned long long value ) { std::ostringstream oss; oss << value; if( value > Detail::hexThreshold ) oss << " (0x" << std::hex << value << ")"; return oss.str(); } #endif #ifdef CATCH_CONFIG_CPP11_NULLPTR std::string toString( std::nullptr_t ) { return "nullptr"; } #endif #ifdef __OBJC__ std::string toString( NSString const * const& nsstring ) { if( !nsstring ) return "nil"; return "@" + toString([nsstring UTF8String]); } std::string toString( NSString * CATCH_ARC_STRONG const& nsstring ) { if( !nsstring ) return "nil"; return "@" + toString([nsstring UTF8String]); } std::string toString( NSObject* const& nsObject ) { return toString( [nsObject description] ); } #endif } // end namespace Catch // #included from: catch_result_builder.hpp #define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED namespace Catch { std::string capturedExpressionWithSecondArgument( std::string const& capturedExpression, std::string const& secondArg ) { return secondArg.empty() || secondArg == "\"\"" ? capturedExpression : capturedExpression + ", " + secondArg; } ResultBuilder::ResultBuilder( char const* macroName, SourceLineInfo const& lineInfo, char const* capturedExpression, ResultDisposition::Flags resultDisposition, char const* secondArg ) : m_assertionInfo( macroName, lineInfo, capturedExpressionWithSecondArgument( capturedExpression, secondArg ), resultDisposition ), m_shouldDebugBreak( false ), m_shouldThrow( false ) {} ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) { m_data.resultType = result; return *this; } ResultBuilder& ResultBuilder::setResultType( bool result ) { m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed; return *this; } ResultBuilder& ResultBuilder::setLhs( std::string const& lhs ) { m_exprComponents.lhs = lhs; return *this; } ResultBuilder& ResultBuilder::setRhs( std::string const& rhs ) { m_exprComponents.rhs = rhs; return *this; } ResultBuilder& ResultBuilder::setOp( std::string const& op ) { m_exprComponents.op = op; return *this; } void ResultBuilder::endExpression() { m_exprComponents.testFalse = isFalseTest( m_assertionInfo.resultDisposition ); captureExpression(); } void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) { m_assertionInfo.resultDisposition = resultDisposition; m_stream.oss << Catch::translateActiveException(); captureResult( ResultWas::ThrewException ); } void ResultBuilder::captureResult( ResultWas::OfType resultType ) { setResultType( resultType ); captureExpression(); } void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) { if( expectedMessage.empty() ) captureExpectedException( Matchers::Impl::Generic::AllOf() ); else captureExpectedException( Matchers::Equals( expectedMessage ) ); } void ResultBuilder::captureExpectedException( Matchers::Impl::Matcher const& matcher ) { assert( m_exprComponents.testFalse == false ); AssertionResultData data = m_data; data.resultType = ResultWas::Ok; data.reconstructedExpression = m_assertionInfo.capturedExpression; std::string actualMessage = Catch::translateActiveException(); if( !matcher.match( actualMessage ) ) { data.resultType = ResultWas::ExpressionFailed; data.reconstructedExpression = actualMessage; } AssertionResult result( m_assertionInfo, data ); handleResult( result ); } void ResultBuilder::captureExpression() { AssertionResult result = build(); handleResult( result ); } void ResultBuilder::handleResult( AssertionResult const& result ) { getResultCapture().assertionEnded( result ); if( !result.isOk() ) { if( getCurrentContext().getConfig()->shouldDebugBreak() ) m_shouldDebugBreak = true; if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) ) m_shouldThrow = true; } } void ResultBuilder::react() { if( m_shouldThrow ) throw Catch::TestFailureException(); } bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; } bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); } AssertionResult ResultBuilder::build() const { assert( m_data.resultType != ResultWas::Unknown ); AssertionResultData data = m_data; // Flip bool results if testFalse is set if( m_exprComponents.testFalse ) { if( data.resultType == ResultWas::Ok ) data.resultType = ResultWas::ExpressionFailed; else if( data.resultType == ResultWas::ExpressionFailed ) data.resultType = ResultWas::Ok; } data.message = m_stream.oss.str(); data.reconstructedExpression = reconstructExpression(); if( m_exprComponents.testFalse ) { if( m_exprComponents.op == "" ) data.reconstructedExpression = "!" + data.reconstructedExpression; else data.reconstructedExpression = "!(" + data.reconstructedExpression + ")"; } return AssertionResult( m_assertionInfo, data ); } std::string ResultBuilder::reconstructExpression() const { if( m_exprComponents.op == "" ) return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs; else if( m_exprComponents.op == "matches" ) return m_exprComponents.lhs + " " + m_exprComponents.rhs; else if( m_exprComponents.op != "!" ) { if( m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 && m_exprComponents.lhs.find("\n") == std::string::npos && m_exprComponents.rhs.find("\n") == std::string::npos ) return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs; else return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs; } else return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}"; } } // end namespace Catch // #included from: catch_tag_alias_registry.hpp #define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED // #included from: catch_tag_alias_registry.h #define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED #include namespace Catch { class TagAliasRegistry : public ITagAliasRegistry { public: virtual ~TagAliasRegistry(); virtual Option find( std::string const& alias ) const; virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const; void add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); static TagAliasRegistry& get(); private: std::map m_registry; }; } // end namespace Catch #include #include namespace Catch { TagAliasRegistry::~TagAliasRegistry() {} Option TagAliasRegistry::find( std::string const& alias ) const { std::map::const_iterator it = m_registry.find( alias ); if( it != m_registry.end() ) return it->second; else return Option(); } std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const { std::string expandedTestSpec = unexpandedTestSpec; for( std::map::const_iterator it = m_registry.begin(), itEnd = m_registry.end(); it != itEnd; ++it ) { std::size_t pos = expandedTestSpec.find( it->first ); if( pos != std::string::npos ) { expandedTestSpec = expandedTestSpec.substr( 0, pos ) + it->second.tag + expandedTestSpec.substr( pos + it->first.size() ); } } return expandedTestSpec; } void TagAliasRegistry::add( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { if( !startsWith( alias, "[@" ) || !endsWith( alias, "]" ) ) { std::ostringstream oss; oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" << lineInfo; throw std::domain_error( oss.str().c_str() ); } if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) { std::ostringstream oss; oss << "error: tag alias, \"" << alias << "\" already registered.\n" << "\tFirst seen at " << find(alias)->lineInfo << "\n" << "\tRedefined at " << lineInfo; throw std::domain_error( oss.str().c_str() ); } } TagAliasRegistry& TagAliasRegistry::get() { static TagAliasRegistry instance; return instance; } ITagAliasRegistry::~ITagAliasRegistry() {} ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); } RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { try { TagAliasRegistry::get().add( alias, tag, lineInfo ); } catch( std::exception& ex ) { Colour colourGuard( Colour::Red ); Catch::cerr() << ex.what() << std::endl; exit(1); } } } // end namespace Catch // #included from: ../reporters/catch_reporter_multi.hpp #define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED namespace Catch { class MultipleReporters : public SharedImpl { typedef std::vector > Reporters; Reporters m_reporters; public: void add( Ptr const& reporter ) { m_reporters.push_back( reporter ); } public: // IStreamingReporter virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { return m_reporters[0]->getPreferences(); } virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->noMatchingTestCases( spec ); } virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->testRunStarting( testRunInfo ); } virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->testGroupStarting( groupInfo ); } virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->testCaseStarting( testInfo ); } virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->sectionStarting( sectionInfo ); } virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->assertionStarting( assertionInfo ); } // The return value indicates if the messages buffer should be cleared: virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { bool clearBuffer = false; for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) clearBuffer |= (*it)->assertionEnded( assertionStats ); return clearBuffer; } virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->sectionEnded( sectionStats ); } virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->testCaseEnded( testCaseStats ); } virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->testGroupEnded( testGroupStats ); } virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->testRunEnded( testRunStats ); } virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); it != itEnd; ++it ) (*it)->skipTest( testInfo ); } }; Ptr addReporter( Ptr const& existingReporter, Ptr const& additionalReporter ) { Ptr resultingReporter; if( existingReporter ) { MultipleReporters* multi = dynamic_cast( existingReporter.get() ); if( !multi ) { multi = new MultipleReporters; resultingReporter = Ptr( multi ); if( existingReporter ) multi->add( existingReporter ); } else resultingReporter = existingReporter; multi->add( additionalReporter ); } else resultingReporter = additionalReporter; return resultingReporter; } } // end namespace Catch // #included from: ../reporters/catch_reporter_xml.hpp #define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED // #included from: catch_reporter_bases.hpp #define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED #include namespace Catch { struct StreamingReporterBase : SharedImpl { StreamingReporterBase( ReporterConfig const& _config ) : m_config( _config.fullConfig() ), stream( _config.stream() ) { m_reporterPrefs.shouldRedirectStdOut = false; } virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { return m_reporterPrefs; } virtual ~StreamingReporterBase() CATCH_OVERRIDE; virtual void noMatchingTestCases( std::string const& ) CATCH_OVERRIDE {} virtual void testRunStarting( TestRunInfo const& _testRunInfo ) CATCH_OVERRIDE { currentTestRunInfo = _testRunInfo; } virtual void testGroupStarting( GroupInfo const& _groupInfo ) CATCH_OVERRIDE { currentGroupInfo = _groupInfo; } virtual void testCaseStarting( TestCaseInfo const& _testInfo ) CATCH_OVERRIDE { currentTestCaseInfo = _testInfo; } virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE { m_sectionStack.push_back( _sectionInfo ); } virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) CATCH_OVERRIDE { m_sectionStack.pop_back(); } virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) CATCH_OVERRIDE { currentTestCaseInfo.reset(); } virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) CATCH_OVERRIDE { currentGroupInfo.reset(); } virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) CATCH_OVERRIDE { currentTestCaseInfo.reset(); currentGroupInfo.reset(); currentTestRunInfo.reset(); } virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE { // Don't do anything with this by default. // It can optionally be overridden in the derived class. } Ptr m_config; std::ostream& stream; LazyStat currentTestRunInfo; LazyStat currentGroupInfo; LazyStat currentTestCaseInfo; std::vector m_sectionStack; ReporterPreferences m_reporterPrefs; }; struct CumulativeReporterBase : SharedImpl { template struct Node : SharedImpl<> { explicit Node( T const& _value ) : value( _value ) {} virtual ~Node() {} typedef std::vector > ChildNodes; T value; ChildNodes children; }; struct SectionNode : SharedImpl<> { explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {} virtual ~SectionNode(); bool operator == ( SectionNode const& other ) const { return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo; } bool operator == ( Ptr const& other ) const { return operator==( *other ); } SectionStats stats; typedef std::vector > ChildSections; typedef std::vector Assertions; ChildSections childSections; Assertions assertions; std::string stdOut; std::string stdErr; }; struct BySectionInfo { BySectionInfo( SectionInfo const& other ) : m_other( other ) {} BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {} bool operator() ( Ptr const& node ) const { return node->stats.sectionInfo.lineInfo == m_other.lineInfo; } private: void operator=( BySectionInfo const& ); SectionInfo const& m_other; }; typedef Node TestCaseNode; typedef Node TestGroupNode; typedef Node TestRunNode; CumulativeReporterBase( ReporterConfig const& _config ) : m_config( _config.fullConfig() ), stream( _config.stream() ) { m_reporterPrefs.shouldRedirectStdOut = false; } ~CumulativeReporterBase(); virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { return m_reporterPrefs; } virtual void testRunStarting( TestRunInfo const& ) CATCH_OVERRIDE {} virtual void testGroupStarting( GroupInfo const& ) CATCH_OVERRIDE {} virtual void testCaseStarting( TestCaseInfo const& ) CATCH_OVERRIDE {} virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { SectionStats incompleteStats( sectionInfo, Counts(), 0, false ); Ptr node; if( m_sectionStack.empty() ) { if( !m_rootSection ) m_rootSection = new SectionNode( incompleteStats ); node = m_rootSection; } else { SectionNode& parentNode = *m_sectionStack.back(); SectionNode::ChildSections::const_iterator it = std::find_if( parentNode.childSections.begin(), parentNode.childSections.end(), BySectionInfo( sectionInfo ) ); if( it == parentNode.childSections.end() ) { node = new SectionNode( incompleteStats ); parentNode.childSections.push_back( node ); } else node = *it; } m_sectionStack.push_back( node ); m_deepestSection = node; } virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {} virtual bool assertionEnded( AssertionStats const& assertionStats ) { assert( !m_sectionStack.empty() ); SectionNode& sectionNode = *m_sectionStack.back(); sectionNode.assertions.push_back( assertionStats ); return true; } virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { assert( !m_sectionStack.empty() ); SectionNode& node = *m_sectionStack.back(); node.stats = sectionStats; m_sectionStack.pop_back(); } virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { Ptr node = new TestCaseNode( testCaseStats ); assert( m_sectionStack.size() == 0 ); node->children.push_back( m_rootSection ); m_testCases.push_back( node ); m_rootSection.reset(); assert( m_deepestSection ); m_deepestSection->stdOut = testCaseStats.stdOut; m_deepestSection->stdErr = testCaseStats.stdErr; } virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { Ptr node = new TestGroupNode( testGroupStats ); node->children.swap( m_testCases ); m_testGroups.push_back( node ); } virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { Ptr node = new TestRunNode( testRunStats ); node->children.swap( m_testGroups ); m_testRuns.push_back( node ); testRunEndedCumulative(); } virtual void testRunEndedCumulative() = 0; virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {} Ptr m_config; std::ostream& stream; std::vector m_assertions; std::vector > > m_sections; std::vector > m_testCases; std::vector > m_testGroups; std::vector > m_testRuns; Ptr m_rootSection; Ptr m_deepestSection; std::vector > m_sectionStack; ReporterPreferences m_reporterPrefs; }; template char const* getLineOfChars() { static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0}; if( !*line ) { memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 ); line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0; } return line; } struct TestEventListenerBase : StreamingReporterBase { TestEventListenerBase( ReporterConfig const& _config ) : StreamingReporterBase( _config ) {} virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {} virtual bool assertionEnded( AssertionStats const& ) CATCH_OVERRIDE { return false; } }; } // end namespace Catch // #included from: ../internal/catch_reporter_registrars.hpp #define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED namespace Catch { template class LegacyReporterRegistrar { class ReporterFactory : public IReporterFactory { virtual IStreamingReporter* create( ReporterConfig const& config ) const { return new LegacyReporterAdapter( new T( config ) ); } virtual std::string getDescription() const { return T::getDescription(); } }; public: LegacyReporterRegistrar( std::string const& name ) { getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); } }; template class ReporterRegistrar { class ReporterFactory : public SharedImpl { // *** Please Note ***: // - If you end up here looking at a compiler error because it's trying to register // your custom reporter class be aware that the native reporter interface has changed // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter. // However please consider updating to the new interface as the old one is now // deprecated and will probably be removed quite soon! // Please contact me via github if you have any questions at all about this. // In fact, ideally, please contact me anyway to let me know you've hit this - as I have // no idea who is actually using custom reporters at all (possibly no-one!). // The new interface is designed to minimise exposure to interface changes in the future. virtual IStreamingReporter* create( ReporterConfig const& config ) const { return new T( config ); } virtual std::string getDescription() const { return T::getDescription(); } }; public: ReporterRegistrar( std::string const& name ) { getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); } }; template class ListenerRegistrar { class ListenerFactory : public SharedImpl { virtual IStreamingReporter* create( ReporterConfig const& config ) const { return new T( config ); } virtual std::string getDescription() const { return ""; } }; public: ListenerRegistrar() { getMutableRegistryHub().registerListener( new ListenerFactory() ); } }; } #define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \ namespace{ Catch::LegacyReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } #define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \ namespace{ Catch::ReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } #define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \ namespace{ Catch::ListenerRegistrar catch_internal_RegistrarFor##listenerType; } // #included from: ../internal/catch_xmlwriter.hpp #define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED #include #include #include #include namespace Catch { class XmlEncode { public: enum ForWhat { ForTextNodes, ForAttributes }; XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes ) : m_str( str ), m_forWhat( forWhat ) {} void encodeTo( std::ostream& os ) const { // Apostrophe escaping not necessary if we always use " to write attributes // (see: http://www.w3.org/TR/xml/#syntax) for( std::size_t i = 0; i < m_str.size(); ++ i ) { char c = m_str[i]; switch( c ) { case '<': os << "<"; break; case '&': os << "&"; break; case '>': // See: http://www.w3.org/TR/xml/#syntax if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' ) os << ">"; else os << c; break; case '\"': if( m_forWhat == ForAttributes ) os << """; else os << c; break; default: // Escape control chars - based on contribution by @espenalb in PR #465 if ( ( c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) os << "&#x" << std::uppercase << std::hex << static_cast( c ); else os << c; } } } friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) { xmlEncode.encodeTo( os ); return os; } private: std::string m_str; ForWhat m_forWhat; }; class XmlWriter { public: class ScopedElement { public: ScopedElement( XmlWriter* writer ) : m_writer( writer ) {} ScopedElement( ScopedElement const& other ) : m_writer( other.m_writer ){ other.m_writer = CATCH_NULL; } ~ScopedElement() { if( m_writer ) m_writer->endElement(); } ScopedElement& writeText( std::string const& text, bool indent = true ) { m_writer->writeText( text, indent ); return *this; } template ScopedElement& writeAttribute( std::string const& name, T const& attribute ) { m_writer->writeAttribute( name, attribute ); return *this; } private: mutable XmlWriter* m_writer; }; XmlWriter() : m_tagIsOpen( false ), m_needsNewline( false ), m_os( &Catch::cout() ) {} XmlWriter( std::ostream& os ) : m_tagIsOpen( false ), m_needsNewline( false ), m_os( &os ) {} ~XmlWriter() { while( !m_tags.empty() ) endElement(); } XmlWriter& startElement( std::string const& name ) { ensureTagClosed(); newlineIfNecessary(); stream() << m_indent << "<" << name; m_tags.push_back( name ); m_indent += " "; m_tagIsOpen = true; return *this; } ScopedElement scopedElement( std::string const& name ) { ScopedElement scoped( this ); startElement( name ); return scoped; } XmlWriter& endElement() { newlineIfNecessary(); m_indent = m_indent.substr( 0, m_indent.size()-2 ); if( m_tagIsOpen ) { stream() << "/>\n"; m_tagIsOpen = false; } else { stream() << m_indent << "\n"; } m_tags.pop_back(); return *this; } XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) { if( !name.empty() && !attribute.empty() ) stream() << " " << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << "\""; return *this; } XmlWriter& writeAttribute( std::string const& name, bool attribute ) { stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\""; return *this; } template XmlWriter& writeAttribute( std::string const& name, T const& attribute ) { std::ostringstream oss; oss << attribute; return writeAttribute( name, oss.str() ); } XmlWriter& writeText( std::string const& text, bool indent = true ) { if( !text.empty() ){ bool tagWasOpen = m_tagIsOpen; ensureTagClosed(); if( tagWasOpen && indent ) stream() << m_indent; stream() << XmlEncode( text ); m_needsNewline = true; } return *this; } XmlWriter& writeComment( std::string const& text ) { ensureTagClosed(); stream() << m_indent << ""; m_needsNewline = true; return *this; } XmlWriter& writeBlankLine() { ensureTagClosed(); stream() << "\n"; return *this; } void setStream( std::ostream& os ) { m_os = &os; } private: XmlWriter( XmlWriter const& ); void operator=( XmlWriter const& ); std::ostream& stream() { return *m_os; } void ensureTagClosed() { if( m_tagIsOpen ) { stream() << ">\n"; m_tagIsOpen = false; } } void newlineIfNecessary() { if( m_needsNewline ) { stream() << "\n"; m_needsNewline = false; } } bool m_tagIsOpen; bool m_needsNewline; std::vector m_tags; std::string m_indent; std::ostream* m_os; }; } // #included from: catch_reenable_warnings.h #define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED #ifdef __clang__ # ifdef __ICC // icpc defines the __clang__ macro # pragma warning(pop) # else # pragma clang diagnostic pop # endif #elif defined __GNUC__ # pragma GCC diagnostic pop #endif namespace Catch { class XmlReporter : public StreamingReporterBase { public: XmlReporter( ReporterConfig const& _config ) : StreamingReporterBase( _config ), m_sectionDepth( 0 ) { m_reporterPrefs.shouldRedirectStdOut = true; } virtual ~XmlReporter() CATCH_OVERRIDE; static std::string getDescription() { return "Reports test results as an XML document"; } public: // StreamingReporterBase virtual void noMatchingTestCases( std::string const& s ) CATCH_OVERRIDE { StreamingReporterBase::noMatchingTestCases( s ); } virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE { StreamingReporterBase::testRunStarting( testInfo ); m_xml.setStream( stream ); m_xml.startElement( "Catch" ); if( !m_config->name().empty() ) m_xml.writeAttribute( "name", m_config->name() ); } virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { StreamingReporterBase::testGroupStarting( groupInfo ); m_xml.startElement( "Group" ) .writeAttribute( "name", groupInfo.name ); } virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { StreamingReporterBase::testCaseStarting(testInfo); m_xml.startElement( "TestCase" ).writeAttribute( "name", trim( testInfo.name ) ); if ( m_config->showDurations() == ShowDurations::Always ) m_testCaseTimer.start(); } virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { StreamingReporterBase::sectionStarting( sectionInfo ); if( m_sectionDepth++ > 0 ) { m_xml.startElement( "Section" ) .writeAttribute( "name", trim( sectionInfo.name ) ) .writeAttribute( "description", sectionInfo.description ); } } virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { } virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { const AssertionResult& assertionResult = assertionStats.assertionResult; // Print any info messages in tags. if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); it != itEnd; ++it ) { if( it->type == ResultWas::Info ) { m_xml.scopedElement( "Info" ) .writeText( it->message ); } else if ( it->type == ResultWas::Warning ) { m_xml.scopedElement( "Warning" ) .writeText( it->message ); } } } // Drop out if result was successful but we're not printing them. if( !m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()) ) return true; // Print the expression if there is one. if( assertionResult.hasExpression() ) { m_xml.startElement( "Expression" ) .writeAttribute( "success", assertionResult.succeeded() ) .writeAttribute( "type", assertionResult.getTestMacroName() ) .writeAttribute( "filename", assertionResult.getSourceInfo().file ) .writeAttribute( "line", assertionResult.getSourceInfo().line ); m_xml.scopedElement( "Original" ) .writeText( assertionResult.getExpression() ); m_xml.scopedElement( "Expanded" ) .writeText( assertionResult.getExpandedExpression() ); } // And... Print a result applicable to each result type. switch( assertionResult.getResultType() ) { case ResultWas::ThrewException: m_xml.scopedElement( "Exception" ) .writeAttribute( "filename", assertionResult.getSourceInfo().file ) .writeAttribute( "line", assertionResult.getSourceInfo().line ) .writeText( assertionResult.getMessage() ); break; case ResultWas::FatalErrorCondition: m_xml.scopedElement( "Fatal Error Condition" ) .writeAttribute( "filename", assertionResult.getSourceInfo().file ) .writeAttribute( "line", assertionResult.getSourceInfo().line ) .writeText( assertionResult.getMessage() ); break; case ResultWas::Info: m_xml.scopedElement( "Info" ) .writeText( assertionResult.getMessage() ); break; case ResultWas::Warning: // Warning will already have been written break; case ResultWas::ExplicitFailure: m_xml.scopedElement( "Failure" ) .writeText( assertionResult.getMessage() ); break; default: break; } if( assertionResult.hasExpression() ) m_xml.endElement(); return true; } virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { StreamingReporterBase::sectionEnded( sectionStats ); if( --m_sectionDepth > 0 ) { XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" ); e.writeAttribute( "successes", sectionStats.assertions.passed ); e.writeAttribute( "failures", sectionStats.assertions.failed ); e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk ); if ( m_config->showDurations() == ShowDurations::Always ) e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds ); m_xml.endElement(); } } virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { StreamingReporterBase::testCaseEnded( testCaseStats ); XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" ); e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() ); if ( m_config->showDurations() == ShowDurations::Always ) e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() ); m_xml.endElement(); } virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { StreamingReporterBase::testGroupEnded( testGroupStats ); // TODO: Check testGroupStats.aborting and act accordingly. m_xml.scopedElement( "OverallResults" ) .writeAttribute( "successes", testGroupStats.totals.assertions.passed ) .writeAttribute( "failures", testGroupStats.totals.assertions.failed ) .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk ); m_xml.endElement(); } virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { StreamingReporterBase::testRunEnded( testRunStats ); m_xml.scopedElement( "OverallResults" ) .writeAttribute( "successes", testRunStats.totals.assertions.passed ) .writeAttribute( "failures", testRunStats.totals.assertions.failed ) .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk ); m_xml.endElement(); } private: Timer m_testCaseTimer; XmlWriter m_xml; int m_sectionDepth; }; INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter ) } // end namespace Catch // #included from: ../reporters/catch_reporter_junit.hpp #define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED #include namespace Catch { class JunitReporter : public CumulativeReporterBase { public: JunitReporter( ReporterConfig const& _config ) : CumulativeReporterBase( _config ), xml( _config.stream() ) { m_reporterPrefs.shouldRedirectStdOut = true; } virtual ~JunitReporter() CATCH_OVERRIDE; static std::string getDescription() { return "Reports test results in an XML format that looks like Ant's junitreport target"; } virtual void noMatchingTestCases( std::string const& /*spec*/ ) CATCH_OVERRIDE {} virtual void testRunStarting( TestRunInfo const& runInfo ) CATCH_OVERRIDE { CumulativeReporterBase::testRunStarting( runInfo ); xml.startElement( "testsuites" ); } virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { suiteTimer.start(); stdOutForSuite.str(""); stdErrForSuite.str(""); unexpectedExceptions = 0; CumulativeReporterBase::testGroupStarting( groupInfo ); } virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException ) unexpectedExceptions++; return CumulativeReporterBase::assertionEnded( assertionStats ); } virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { stdOutForSuite << testCaseStats.stdOut; stdErrForSuite << testCaseStats.stdErr; CumulativeReporterBase::testCaseEnded( testCaseStats ); } virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { double suiteTime = suiteTimer.getElapsedSeconds(); CumulativeReporterBase::testGroupEnded( testGroupStats ); writeGroup( *m_testGroups.back(), suiteTime ); } virtual void testRunEndedCumulative() CATCH_OVERRIDE { xml.endElement(); } void writeGroup( TestGroupNode const& groupNode, double suiteTime ) { XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" ); TestGroupStats const& stats = groupNode.value; xml.writeAttribute( "name", stats.groupInfo.name ); xml.writeAttribute( "errors", unexpectedExceptions ); xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions ); xml.writeAttribute( "tests", stats.totals.assertions.total() ); xml.writeAttribute( "hostname", "tbd" ); // !TBD if( m_config->showDurations() == ShowDurations::Never ) xml.writeAttribute( "time", "" ); else xml.writeAttribute( "time", suiteTime ); xml.writeAttribute( "timestamp", "tbd" ); // !TBD // Write test cases for( TestGroupNode::ChildNodes::const_iterator it = groupNode.children.begin(), itEnd = groupNode.children.end(); it != itEnd; ++it ) writeTestCase( **it ); xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false ); xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false ); } void writeTestCase( TestCaseNode const& testCaseNode ) { TestCaseStats const& stats = testCaseNode.value; // All test cases have exactly one section - which represents the // test case itself. That section may have 0-n nested sections assert( testCaseNode.children.size() == 1 ); SectionNode const& rootSection = *testCaseNode.children.front(); std::string className = stats.testInfo.className; if( className.empty() ) { if( rootSection.childSections.empty() ) className = "global"; } writeSection( className, "", rootSection ); } void writeSection( std::string const& className, std::string const& rootName, SectionNode const& sectionNode ) { std::string name = trim( sectionNode.stats.sectionInfo.name ); if( !rootName.empty() ) name = rootName + "/" + name; if( !sectionNode.assertions.empty() || !sectionNode.stdOut.empty() || !sectionNode.stdErr.empty() ) { XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); if( className.empty() ) { xml.writeAttribute( "classname", name ); xml.writeAttribute( "name", "root" ); } else { xml.writeAttribute( "classname", className ); xml.writeAttribute( "name", name ); } xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) ); writeAssertions( sectionNode ); if( !sectionNode.stdOut.empty() ) xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false ); if( !sectionNode.stdErr.empty() ) xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false ); } for( SectionNode::ChildSections::const_iterator it = sectionNode.childSections.begin(), itEnd = sectionNode.childSections.end(); it != itEnd; ++it ) if( className.empty() ) writeSection( name, "", **it ); else writeSection( className, name, **it ); } void writeAssertions( SectionNode const& sectionNode ) { for( SectionNode::Assertions::const_iterator it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end(); it != itEnd; ++it ) writeAssertion( *it ); } void writeAssertion( AssertionStats const& stats ) { AssertionResult const& result = stats.assertionResult; if( !result.isOk() ) { std::string elementName; switch( result.getResultType() ) { case ResultWas::ThrewException: case ResultWas::FatalErrorCondition: elementName = "error"; break; case ResultWas::ExplicitFailure: elementName = "failure"; break; case ResultWas::ExpressionFailed: elementName = "failure"; break; case ResultWas::DidntThrowException: elementName = "failure"; break; // We should never see these here: case ResultWas::Info: case ResultWas::Warning: case ResultWas::Ok: case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: elementName = "internalError"; break; } XmlWriter::ScopedElement e = xml.scopedElement( elementName ); xml.writeAttribute( "message", result.getExpandedExpression() ); xml.writeAttribute( "type", result.getTestMacroName() ); std::ostringstream oss; if( !result.getMessage().empty() ) oss << result.getMessage() << "\n"; for( std::vector::const_iterator it = stats.infoMessages.begin(), itEnd = stats.infoMessages.end(); it != itEnd; ++it ) if( it->type == ResultWas::Info ) oss << it->message << "\n"; oss << "at " << result.getSourceInfo(); xml.writeText( oss.str(), false ); } } XmlWriter xml; Timer suiteTimer; std::ostringstream stdOutForSuite; std::ostringstream stdErrForSuite; unsigned int unexpectedExceptions; }; INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter ) } // end namespace Catch // #included from: ../reporters/catch_reporter_console.hpp #define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED namespace Catch { struct ConsoleReporter : StreamingReporterBase { ConsoleReporter( ReporterConfig const& _config ) : StreamingReporterBase( _config ), m_headerPrinted( false ) {} virtual ~ConsoleReporter() CATCH_OVERRIDE; static std::string getDescription() { return "Reports test results as plain lines of text"; } virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE { stream << "No test cases matched '" << spec << "'" << std::endl; } virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { } virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE { AssertionResult const& result = _assertionStats.assertionResult; bool printInfoMessages = true; // Drop out if result was successful and we're not printing those if( !m_config->includeSuccessfulResults() && result.isOk() ) { if( result.getResultType() != ResultWas::Warning ) return false; printInfoMessages = false; } lazyPrint(); AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); printer.print(); stream << std::endl; return true; } virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE { m_headerPrinted = false; StreamingReporterBase::sectionStarting( _sectionInfo ); } virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE { if( _sectionStats.missingAssertions ) { lazyPrint(); Colour colour( Colour::ResultError ); if( m_sectionStack.size() > 1 ) stream << "\nNo assertions in section"; else stream << "\nNo assertions in test case"; stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl; } if( m_headerPrinted ) { if( m_config->showDurations() == ShowDurations::Always ) stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl; m_headerPrinted = false; } else { if( m_config->showDurations() == ShowDurations::Always ) stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl; } StreamingReporterBase::sectionEnded( _sectionStats ); } virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) CATCH_OVERRIDE { StreamingReporterBase::testCaseEnded( _testCaseStats ); m_headerPrinted = false; } virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE { if( currentGroupInfo.used ) { printSummaryDivider(); stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n"; printTotals( _testGroupStats.totals ); stream << "\n" << std::endl; } StreamingReporterBase::testGroupEnded( _testGroupStats ); } virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE { printTotalsDivider( _testRunStats.totals ); printTotals( _testRunStats.totals ); stream << std::endl; StreamingReporterBase::testRunEnded( _testRunStats ); } private: class AssertionPrinter { void operator= ( AssertionPrinter const& ); public: AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) : stream( _stream ), stats( _stats ), result( _stats.assertionResult ), colour( Colour::None ), message( result.getMessage() ), messages( _stats.infoMessages ), printInfoMessages( _printInfoMessages ) { switch( result.getResultType() ) { case ResultWas::Ok: colour = Colour::Success; passOrFail = "PASSED"; //if( result.hasMessage() ) if( _stats.infoMessages.size() == 1 ) messageLabel = "with message"; if( _stats.infoMessages.size() > 1 ) messageLabel = "with messages"; break; case ResultWas::ExpressionFailed: if( result.isOk() ) { colour = Colour::Success; passOrFail = "FAILED - but was ok"; } else { colour = Colour::Error; passOrFail = "FAILED"; } if( _stats.infoMessages.size() == 1 ) messageLabel = "with message"; if( _stats.infoMessages.size() > 1 ) messageLabel = "with messages"; break; case ResultWas::ThrewException: colour = Colour::Error; passOrFail = "FAILED"; messageLabel = "due to unexpected exception with message"; break; case ResultWas::FatalErrorCondition: colour = Colour::Error; passOrFail = "FAILED"; messageLabel = "due to a fatal error condition"; break; case ResultWas::DidntThrowException: colour = Colour::Error; passOrFail = "FAILED"; messageLabel = "because no exception was thrown where one was expected"; break; case ResultWas::Info: messageLabel = "info"; break; case ResultWas::Warning: messageLabel = "warning"; break; case ResultWas::ExplicitFailure: passOrFail = "FAILED"; colour = Colour::Error; if( _stats.infoMessages.size() == 1 ) messageLabel = "explicitly with message"; if( _stats.infoMessages.size() > 1 ) messageLabel = "explicitly with messages"; break; // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: passOrFail = "** internal error **"; colour = Colour::Error; break; } } void print() const { printSourceInfo(); if( stats.totals.assertions.total() > 0 ) { if( result.isOk() ) stream << "\n"; printResultType(); printOriginalExpression(); printReconstructedExpression(); } else { stream << "\n"; } printMessage(); } private: void printResultType() const { if( !passOrFail.empty() ) { Colour colourGuard( colour ); stream << passOrFail << ":\n"; } } void printOriginalExpression() const { if( result.hasExpression() ) { Colour colourGuard( Colour::OriginalExpression ); stream << " "; stream << result.getExpressionInMacro(); stream << "\n"; } } void printReconstructedExpression() const { if( result.hasExpandedExpression() ) { stream << "with expansion:\n"; Colour colourGuard( Colour::ReconstructedExpression ); stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\n"; } } void printMessage() const { if( !messageLabel.empty() ) stream << messageLabel << ":" << "\n"; for( std::vector::const_iterator it = messages.begin(), itEnd = messages.end(); it != itEnd; ++it ) { // If this assertion is a warning ignore any INFO messages if( printInfoMessages || it->type != ResultWas::Info ) stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n"; } } void printSourceInfo() const { Colour colourGuard( Colour::FileName ); stream << result.getSourceInfo() << ": "; } std::ostream& stream; AssertionStats const& stats; AssertionResult const& result; Colour::Code colour; std::string passOrFail; std::string messageLabel; std::string message; std::vector messages; bool printInfoMessages; }; void lazyPrint() { if( !currentTestRunInfo.used ) lazyPrintRunInfo(); if( !currentGroupInfo.used ) lazyPrintGroupInfo(); if( !m_headerPrinted ) { printTestCaseAndSectionHeader(); m_headerPrinted = true; } } void lazyPrintRunInfo() { stream << "\n" << getLineOfChars<'~'>() << "\n"; Colour colour( Colour::SecondaryText ); stream << currentTestRunInfo->name << " is a Catch v" << libraryVersion << " host application.\n" << "Run with -? for options\n\n"; if( m_config->rngSeed() != 0 ) stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n"; currentTestRunInfo.used = true; } void lazyPrintGroupInfo() { if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) { printClosedHeader( "Group: " + currentGroupInfo->name ); currentGroupInfo.used = true; } } void printTestCaseAndSectionHeader() { assert( !m_sectionStack.empty() ); printOpenHeader( currentTestCaseInfo->name ); if( m_sectionStack.size() > 1 ) { Colour colourGuard( Colour::Headers ); std::vector::const_iterator it = m_sectionStack.begin()+1, // Skip first section (test case) itEnd = m_sectionStack.end(); for( ; it != itEnd; ++it ) printHeaderString( it->name, 2 ); } SourceLineInfo lineInfo = m_sectionStack.front().lineInfo; if( !lineInfo.empty() ){ stream << getLineOfChars<'-'>() << "\n"; Colour colourGuard( Colour::FileName ); stream << lineInfo << "\n"; } stream << getLineOfChars<'.'>() << "\n" << std::endl; } void printClosedHeader( std::string const& _name ) { printOpenHeader( _name ); stream << getLineOfChars<'.'>() << "\n"; } void printOpenHeader( std::string const& _name ) { stream << getLineOfChars<'-'>() << "\n"; { Colour colourGuard( Colour::Headers ); printHeaderString( _name ); } } // if string has a : in first line will set indent to follow it on // subsequent lines void printHeaderString( std::string const& _string, std::size_t indent = 0 ) { std::size_t i = _string.find( ": " ); if( i != std::string::npos ) i+=2; else i = 0; stream << Text( _string, TextAttributes() .setIndent( indent+i) .setInitialIndent( indent ) ) << "\n"; } struct SummaryColumn { SummaryColumn( std::string const& _label, Colour::Code _colour ) : label( _label ), colour( _colour ) {} SummaryColumn addRow( std::size_t count ) { std::ostringstream oss; oss << count; std::string row = oss.str(); for( std::vector::iterator it = rows.begin(); it != rows.end(); ++it ) { while( it->size() < row.size() ) *it = " " + *it; while( it->size() > row.size() ) row = " " + row; } rows.push_back( row ); return *this; } std::string label; Colour::Code colour; std::vector rows; }; void printTotals( Totals const& totals ) { if( totals.testCases.total() == 0 ) { stream << Colour( Colour::Warning ) << "No tests ran\n"; } else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) { stream << Colour( Colour::ResultSuccess ) << "All tests passed"; stream << " (" << pluralise( totals.assertions.passed, "assertion" ) << " in " << pluralise( totals.testCases.passed, "test case" ) << ")" << "\n"; } else { std::vector columns; columns.push_back( SummaryColumn( "", Colour::None ) .addRow( totals.testCases.total() ) .addRow( totals.assertions.total() ) ); columns.push_back( SummaryColumn( "passed", Colour::Success ) .addRow( totals.testCases.passed ) .addRow( totals.assertions.passed ) ); columns.push_back( SummaryColumn( "failed", Colour::ResultError ) .addRow( totals.testCases.failed ) .addRow( totals.assertions.failed ) ); columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure ) .addRow( totals.testCases.failedButOk ) .addRow( totals.assertions.failedButOk ) ); printSummaryRow( "test cases", columns, 0 ); printSummaryRow( "assertions", columns, 1 ); } } void printSummaryRow( std::string const& label, std::vector const& cols, std::size_t row ) { for( std::vector::const_iterator it = cols.begin(); it != cols.end(); ++it ) { std::string value = it->rows[row]; if( it->label.empty() ) { stream << label << ": "; if( value != "0" ) stream << value; else stream << Colour( Colour::Warning ) << "- none -"; } else if( value != "0" ) { stream << Colour( Colour::LightGrey ) << " | "; stream << Colour( it->colour ) << value << " " << it->label; } } stream << "\n"; } static std::size_t makeRatio( std::size_t number, std::size_t total ) { std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0; return ( ratio == 0 && number > 0 ) ? 1 : ratio; } static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) { if( i > j && i > k ) return i; else if( j > k ) return j; else return k; } void printTotalsDivider( Totals const& totals ) { if( totals.testCases.total() > 0 ) { std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() ); std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() ); std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() ); while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 ) findMax( failedRatio, failedButOkRatio, passedRatio )++; while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 ) findMax( failedRatio, failedButOkRatio, passedRatio )--; stream << Colour( Colour::Error ) << std::string( failedRatio, '=' ); stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' ); if( totals.testCases.allPassed() ) stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' ); else stream << Colour( Colour::Success ) << std::string( passedRatio, '=' ); } else { stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' ); } stream << "\n"; } void printSummaryDivider() { stream << getLineOfChars<'-'>() << "\n"; } private: bool m_headerPrinted; }; INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter ) } // end namespace Catch // #included from: ../reporters/catch_reporter_compact.hpp #define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED namespace Catch { struct CompactReporter : StreamingReporterBase { CompactReporter( ReporterConfig const& _config ) : StreamingReporterBase( _config ) {} virtual ~CompactReporter(); static std::string getDescription() { return "Reports test results on a single line, suitable for IDEs"; } virtual ReporterPreferences getPreferences() const { ReporterPreferences prefs; prefs.shouldRedirectStdOut = false; return prefs; } virtual void noMatchingTestCases( std::string const& spec ) { stream << "No test cases matched '" << spec << "'" << std::endl; } virtual void assertionStarting( AssertionInfo const& ) { } virtual bool assertionEnded( AssertionStats const& _assertionStats ) { AssertionResult const& result = _assertionStats.assertionResult; bool printInfoMessages = true; // Drop out if result was successful and we're not printing those if( !m_config->includeSuccessfulResults() && result.isOk() ) { if( result.getResultType() != ResultWas::Warning ) return false; printInfoMessages = false; } AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); printer.print(); stream << std::endl; return true; } virtual void testRunEnded( TestRunStats const& _testRunStats ) { printTotals( _testRunStats.totals ); stream << "\n" << std::endl; StreamingReporterBase::testRunEnded( _testRunStats ); } private: class AssertionPrinter { void operator= ( AssertionPrinter const& ); public: AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) : stream( _stream ) , stats( _stats ) , result( _stats.assertionResult ) , messages( _stats.infoMessages ) , itMessage( _stats.infoMessages.begin() ) , printInfoMessages( _printInfoMessages ) {} void print() { printSourceInfo(); itMessage = messages.begin(); switch( result.getResultType() ) { case ResultWas::Ok: printResultType( Colour::ResultSuccess, passedString() ); printOriginalExpression(); printReconstructedExpression(); if ( ! result.hasExpression() ) printRemainingMessages( Colour::None ); else printRemainingMessages(); break; case ResultWas::ExpressionFailed: if( result.isOk() ) printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) ); else printResultType( Colour::Error, failedString() ); printOriginalExpression(); printReconstructedExpression(); printRemainingMessages(); break; case ResultWas::ThrewException: printResultType( Colour::Error, failedString() ); printIssue( "unexpected exception with message:" ); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::FatalErrorCondition: printResultType( Colour::Error, failedString() ); printIssue( "fatal error condition with message:" ); printMessage(); printExpressionWas(); printRemainingMessages(); break; case ResultWas::DidntThrowException: printResultType( Colour::Error, failedString() ); printIssue( "expected exception, got none" ); printExpressionWas(); printRemainingMessages(); break; case ResultWas::Info: printResultType( Colour::None, "info" ); printMessage(); printRemainingMessages(); break; case ResultWas::Warning: printResultType( Colour::None, "warning" ); printMessage(); printRemainingMessages(); break; case ResultWas::ExplicitFailure: printResultType( Colour::Error, failedString() ); printIssue( "explicitly" ); printRemainingMessages( Colour::None ); break; // These cases are here to prevent compiler warnings case ResultWas::Unknown: case ResultWas::FailureBit: case ResultWas::Exception: printResultType( Colour::Error, "** internal error **" ); break; } } private: // Colour::LightGrey static Colour::Code dimColour() { return Colour::FileName; } #ifdef CATCH_PLATFORM_MAC static const char* failedString() { return "FAILED"; } static const char* passedString() { return "PASSED"; } #else static const char* failedString() { return "failed"; } static const char* passedString() { return "passed"; } #endif void printSourceInfo() const { Colour colourGuard( Colour::FileName ); stream << result.getSourceInfo() << ":"; } void printResultType( Colour::Code colour, std::string passOrFail ) const { if( !passOrFail.empty() ) { { Colour colourGuard( colour ); stream << " " << passOrFail; } stream << ":"; } } void printIssue( std::string issue ) const { stream << " " << issue; } void printExpressionWas() { if( result.hasExpression() ) { stream << ";"; { Colour colour( dimColour() ); stream << " expression was:"; } printOriginalExpression(); } } void printOriginalExpression() const { if( result.hasExpression() ) { stream << " " << result.getExpression(); } } void printReconstructedExpression() const { if( result.hasExpandedExpression() ) { { Colour colour( dimColour() ); stream << " for: "; } stream << result.getExpandedExpression(); } } void printMessage() { if ( itMessage != messages.end() ) { stream << " '" << itMessage->message << "'"; ++itMessage; } } void printRemainingMessages( Colour::Code colour = dimColour() ) { if ( itMessage == messages.end() ) return; // using messages.end() directly yields compilation error: std::vector::const_iterator itEnd = messages.end(); const std::size_t N = static_cast( std::distance( itMessage, itEnd ) ); { Colour colourGuard( colour ); stream << " with " << pluralise( N, "message" ) << ":"; } for(; itMessage != itEnd; ) { // If this assertion is a warning ignore any INFO messages if( printInfoMessages || itMessage->type != ResultWas::Info ) { stream << " '" << itMessage->message << "'"; if ( ++itMessage != itEnd ) { Colour colourGuard( dimColour() ); stream << " and"; } } } } private: std::ostream& stream; AssertionStats const& stats; AssertionResult const& result; std::vector messages; std::vector::const_iterator itMessage; bool printInfoMessages; }; // Colour, message variants: // - white: No tests ran. // - red: Failed [both/all] N test cases, failed [both/all] M assertions. // - white: Passed [both/all] N test cases (no assertions). // - red: Failed N tests cases, failed M assertions. // - green: Passed [both/all] N tests cases with M assertions. std::string bothOrAll( std::size_t count ) const { return count == 1 ? "" : count == 2 ? "both " : "all " ; } void printTotals( const Totals& totals ) const { if( totals.testCases.total() == 0 ) { stream << "No tests ran."; } else if( totals.testCases.failed == totals.testCases.total() ) { Colour colour( Colour::ResultError ); const std::string qualify_assertions_failed = totals.assertions.failed == totals.assertions.total() ? bothOrAll( totals.assertions.failed ) : ""; stream << "Failed " << bothOrAll( totals.testCases.failed ) << pluralise( totals.testCases.failed, "test case" ) << ", " "failed " << qualify_assertions_failed << pluralise( totals.assertions.failed, "assertion" ) << "."; } else if( totals.assertions.total() == 0 ) { stream << "Passed " << bothOrAll( totals.testCases.total() ) << pluralise( totals.testCases.total(), "test case" ) << " (no assertions)."; } else if( totals.assertions.failed ) { Colour colour( Colour::ResultError ); stream << "Failed " << pluralise( totals.testCases.failed, "test case" ) << ", " "failed " << pluralise( totals.assertions.failed, "assertion" ) << "."; } else { Colour colour( Colour::ResultSuccess ); stream << "Passed " << bothOrAll( totals.testCases.passed ) << pluralise( totals.testCases.passed, "test case" ) << " with " << pluralise( totals.assertions.passed, "assertion" ) << "."; } } }; INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter ) } // end namespace Catch namespace Catch { // These are all here to avoid warnings about not having any out of line // virtual methods NonCopyable::~NonCopyable() {} IShared::~IShared() {} IStream::~IStream() CATCH_NOEXCEPT {} FileStream::~FileStream() CATCH_NOEXCEPT {} CoutStream::~CoutStream() CATCH_NOEXCEPT {} DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {} StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {} IContext::~IContext() {} IResultCapture::~IResultCapture() {} ITestCase::~ITestCase() {} ITestCaseRegistry::~ITestCaseRegistry() {} IRegistryHub::~IRegistryHub() {} IMutableRegistryHub::~IMutableRegistryHub() {} IExceptionTranslator::~IExceptionTranslator() {} IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {} IReporter::~IReporter() {} IReporterFactory::~IReporterFactory() {} IReporterRegistry::~IReporterRegistry() {} IStreamingReporter::~IStreamingReporter() {} AssertionStats::~AssertionStats() {} SectionStats::~SectionStats() {} TestCaseStats::~TestCaseStats() {} TestGroupStats::~TestGroupStats() {} TestRunStats::~TestRunStats() {} CumulativeReporterBase::SectionNode::~SectionNode() {} CumulativeReporterBase::~CumulativeReporterBase() {} StreamingReporterBase::~StreamingReporterBase() {} ConsoleReporter::~ConsoleReporter() {} CompactReporter::~CompactReporter() {} IRunner::~IRunner() {} IMutableContext::~IMutableContext() {} IConfig::~IConfig() {} XmlReporter::~XmlReporter() {} JunitReporter::~JunitReporter() {} TestRegistry::~TestRegistry() {} FreeFunctionTestCase::~FreeFunctionTestCase() {} IGeneratorInfo::~IGeneratorInfo() {} IGeneratorsForTest::~IGeneratorsForTest() {} WildcardPattern::~WildcardPattern() {} TestSpec::Pattern::~Pattern() {} TestSpec::NamePattern::~NamePattern() {} TestSpec::TagPattern::~TagPattern() {} TestSpec::ExcludedPattern::~ExcludedPattern() {} Matchers::Impl::StdString::Equals::~Equals() {} Matchers::Impl::StdString::Contains::~Contains() {} Matchers::Impl::StdString::StartsWith::~StartsWith() {} Matchers::Impl::StdString::EndsWith::~EndsWith() {} void Config::dummy() {} namespace TestCaseTracking { ITracker::~ITracker() {} TrackerBase::~TrackerBase() {} SectionTracker::~SectionTracker() {} IndexTracker::~IndexTracker() {} } } #ifdef __clang__ #pragma clang diagnostic pop #endif #endif #ifdef CATCH_CONFIG_MAIN // #included from: internal/catch_default_main.hpp #define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED #ifndef __OBJC__ // Standard C/C++ main entry point int main (int argc, char * argv[]) { return Catch::Session().run( argc, argv ); } #else // __OBJC__ // Objective-C entry point int main (int argc, char * const argv[]) { #if !CATCH_ARC_ENABLED NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; #endif Catch::registerTestMethods(); int result = Catch::Session().run( argc, (char* const*)argv ); #if !CATCH_ARC_ENABLED [pool drain]; #endif return result; } #endif // __OBJC__ #endif #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED # undef CLARA_CONFIG_MAIN #endif ////// // If this config identifier is defined then all CATCH macros are prefixed with CATCH_ #ifdef CATCH_CONFIG_PREFIX_ALL #define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE" ) #define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE" ) #define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "", "CATCH_REQUIRE_THROWS" ) #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS" ) #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, matcher, "CATCH_REQUIRE_THROWS_WITH" ) #define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW" ) #define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK" ) #define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE" ) #define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF" ) #define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE" ) #define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL" ) #define CATCH_CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS" ) #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS" ) #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CATCH_CHECK_THROWS_WITH" ) #define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW" ) #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT" ) #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT" ) #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg ) #define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "CATCH_INFO" ) #define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) #define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CATCH_CAPTURE" ) #ifdef CATCH_CONFIG_VARIADIC_MACROS #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ ) #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__ ) #else #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description ) #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg ) #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg ) #endif #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) #define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) #define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) #define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) // "BDD-style" convenience wrappers #ifdef CATCH_CONFIG_VARIADIC_MACROS #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ ) #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) #else #define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags ) #define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) #endif #define CATCH_GIVEN( desc ) CATCH_SECTION( std::string( "Given: ") + desc, "" ) #define CATCH_WHEN( desc ) CATCH_SECTION( std::string( " When: ") + desc, "" ) #define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" ) #define CATCH_THEN( desc ) CATCH_SECTION( std::string( " Then: ") + desc, "" ) #define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" ) // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required #else #define REQUIRE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal, "REQUIRE" ) #define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE" ) #define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, "", "REQUIRE_THROWS" ) #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS" ) #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::Normal, matcher, "REQUIRE_THROWS_WITH" ) #define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW" ) #define CHECK( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK" ) #define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE" ) #define CHECKED_IF( expr ) INTERNAL_CATCH_IF( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF" ) #define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE" ) #define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL" ) #define CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, "", "CHECK_THROWS" ) #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS" ) #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CHECK_THROWS_WITH" ) #define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW" ) #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT" ) #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT" ) #define INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) #define WARN( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg ) #define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( msg, "INFO" ) #define CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) #define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( #msg " := " << msg, "CAPTURE" ) #ifdef CATCH_CONFIG_VARIADIC_MACROS #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) #define FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__ ) #define SUCCEED( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__ ) #else #define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description ) #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) #define FAIL( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg ) #define SUCCEED( msg ) INTERNAL_CATCH_MSG( Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg ) #endif #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) #define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) #define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) #define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) #endif #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) // "BDD-style" convenience wrappers #ifdef CATCH_CONFIG_VARIADIC_MACROS #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ ) #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) #else #define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags ) #define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) #endif #define GIVEN( desc ) SECTION( std::string(" Given: ") + desc, "" ) #define WHEN( desc ) SECTION( std::string(" When: ") + desc, "" ) #define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" ) #define THEN( desc ) SECTION( std::string(" Then: ") + desc, "" ) #define AND_THEN( desc ) SECTION( std::string(" And: ") + desc, "" ) using Catch::Detail::Approx; #endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED bpfcc-0.2.0+git0.02884a026/tests/cc/test_c_api.cc000066400000000000000000000142461305314114400206550ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include "bcc_elf.h" #include "bcc_perf_map.h" #include "bcc_proc.h" #include "bcc_syms.h" #include "common.h" #include "vendor/tinyformat.hpp" #include "catch.hpp" using namespace std; TEST_CASE("shared object resolution", "[c_api]") { char *libm = bcc_procutils_which_so("m", 0); REQUIRE(libm); REQUIRE(libm[0] == '/'); REQUIRE(string(libm).find("libm.so") != string::npos); free(libm); } TEST_CASE("shared object resolution using loaded libraries", "[c_api]") { char *libelf = bcc_procutils_which_so("elf", getpid()); REQUIRE(libelf); REQUIRE(libelf[0] == '/'); REQUIRE(string(libelf).find("libelf") != string::npos); free(libelf); } TEST_CASE("binary resolution with `which`", "[c_api]") { char *ld = bcc_procutils_which("ld"); REQUIRE(ld); REQUIRE(ld[0] == '/'); free(ld); } static void _test_ksym(const char *sym, uint64_t addr, void *_) { if (!strcmp(sym, "startup_64")) REQUIRE(addr != 0x0ull); } TEST_CASE("list all kernel symbols", "[c_api]") { if (geteuid() != 0) return; bcc_procutils_each_ksym(_test_ksym, NULL); } TEST_CASE("resolve symbol name in external library", "[c_api]") { struct bcc_symbol sym; REQUIRE(bcc_resolve_symname("c", "malloc", 0x0, 0, &sym) == 0); REQUIRE(string(sym.module).find("libc.so") != string::npos); REQUIRE(sym.module[0] == '/'); REQUIRE(sym.offset != 0); bcc_procutils_free(sym.module); } TEST_CASE("resolve symbol name in external library using loaded libraries", "[c_api]") { struct bcc_symbol sym; REQUIRE(bcc_resolve_symname("bcc", "bcc_procutils_which", 0x0, getpid(), &sym) == 0); REQUIRE(string(sym.module).find("libbcc.so") != string::npos); REQUIRE(sym.module[0] == '/'); REQUIRE(sym.offset != 0); bcc_procutils_free(sym.module); } extern "C" int _a_test_function(const char *a_string) { int i; for (i = 0; a_string[i]; ++i) ; return i; } TEST_CASE("resolve symbol addresses for a given PID", "[c_api]") { struct bcc_symbol sym; void *resolver = bcc_symcache_new(getpid()); REQUIRE(resolver); SECTION("resolve in our own binary memory space") { REQUIRE(bcc_symcache_resolve(resolver, (uint64_t)&_a_test_function, &sym) == 0); char *this_exe = realpath("/proc/self/exe", NULL); REQUIRE(string(this_exe) == sym.module); free(this_exe); REQUIRE(string("_a_test_function") == sym.name); } SECTION("resolve in libbcc.so") { void *libbcc = dlopen("libbcc.so", RTLD_LAZY | RTLD_NOLOAD); REQUIRE(libbcc); void *libbcc_fptr = dlsym(libbcc, "bcc_resolve_symname"); REQUIRE(libbcc_fptr); REQUIRE(bcc_symcache_resolve(resolver, (uint64_t)libbcc_fptr, &sym) == 0); REQUIRE(string(sym.module).find("libbcc.so") != string::npos); REQUIRE(string("bcc_resolve_symname") == sym.name); } SECTION("resolve in libc") { void *libc_fptr = dlsym(NULL, "strtok"); REQUIRE(libc_fptr); REQUIRE(bcc_symcache_resolve(resolver, (uint64_t)libc_fptr, &sym) == 0); REQUIRE(sym.module); REQUIRE(sym.module[0] == '/'); REQUIRE(string(sym.module).find("libc") != string::npos); REQUIRE(string("strtok") == sym.name); } } #define STACK_SIZE (1024 * 1024) static char child_stack[STACK_SIZE]; static string perf_map_path(pid_t pid) { return tfm::format("/tmp/perf-%d.map", pid); } static int child_func(void *arg) { unsigned long long map_addr = (unsigned long long)arg; string path = perf_map_path(getpid()); FILE *file = fopen(path.c_str(), "w"); if (file == NULL) { return -1; } fprintf(file, "%llx 10 dummy_fn\n", map_addr); fprintf(file, "%llx 10 right_next_door_fn\n", map_addr + 0x10); fclose(file); sleep(5); unlink(path.c_str()); return 0; } static pid_t spawn_child(void *map_addr, bool own_pidns) { int flags = 0; if (own_pidns) flags |= CLONE_NEWPID; pid_t child = clone(child_func, /* stack grows down */ child_stack + STACK_SIZE, flags, (void*)map_addr); if (child < 0) return -1; sleep(1); // let the child get set up return child; } TEST_CASE("resolve symbols using /tmp/perf-pid.map", "[c_api]") { const int map_sz = 4096; void *map_addr = mmap(NULL, map_sz, PROT_READ | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); REQUIRE(map_addr != MAP_FAILED); struct bcc_symbol sym; pid_t child = -1; SECTION("same namespace") { child = spawn_child(map_addr, /* own_pidns */ false); REQUIRE(child > 0); void *resolver = bcc_symcache_new(child); REQUIRE(resolver); REQUIRE(bcc_symcache_resolve(resolver, (unsigned long long)map_addr, &sym) == 0); REQUIRE(sym.module); REQUIRE(string(sym.module) == perf_map_path(child)); REQUIRE(string("dummy_fn") == sym.name); REQUIRE(bcc_symcache_resolve(resolver, (unsigned long long)map_addr + 0x10, &sym) == 0); REQUIRE(sym.module); REQUIRE(string(sym.module) == perf_map_path(child)); REQUIRE(string("right_next_door_fn") == sym.name); } SECTION("separate namespace") { child = spawn_child(map_addr, /* own_pidns */ true); REQUIRE(child > 0); void *resolver = bcc_symcache_new(child); REQUIRE(resolver); REQUIRE(bcc_symcache_resolve(resolver, (unsigned long long)map_addr, &sym) == 0); REQUIRE(sym.module); // child is PID 1 in its namespace REQUIRE(string(sym.module) == perf_map_path(1)); REQUIRE(string("dummy_fn") == sym.name); } munmap(map_addr, map_sz); } TEST_CASE("get online CPUs", "[c_api]") { std::vector cpus = ebpf::get_online_cpus(); int num_cpus = sysconf(_SC_NPROCESSORS_ONLN); REQUIRE(cpus.size() == num_cpus); } bpfcc-0.2.0+git0.02884a026/tests/cc/test_libbcc.cc000066400000000000000000000000571305314114400210130ustar00rootroot00000000000000#define CATCH_CONFIG_MAIN #include "catch.hpp" bpfcc-0.2.0+git0.02884a026/tests/cc/test_static.c000066400000000000000000000003011305314114400207110ustar00rootroot00000000000000#include "bpf_common.h" int main(int argc, char **argv) { void *mod = bpf_module_create_c_from_string("BPF_TABLE(\"array\", int, int, stats, 10);\n", 4, NULL, 0); return !(mod != NULL); } bpfcc-0.2.0+git0.02884a026/tests/cc/test_usdt_args.cc000066400000000000000000000063641305314114400215770ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include "catch.hpp" #include "usdt.h" using std::experimental::optional; using std::experimental::nullopt; static void verify_register(USDT::ArgumentParser_x64 &parser, int arg_size, int constant) { USDT::Argument arg; REQUIRE(parser.parse(&arg)); REQUIRE(arg.arg_size() == arg_size); REQUIRE(arg.constant()); REQUIRE(arg.constant() == constant); } static void verify_register(USDT::ArgumentParser_x64 &parser, int arg_size, const std::string ®name, optional deref_offset = nullopt, optional deref_ident = nullopt, optional index_regname = nullopt, optional scale = nullopt) { USDT::Argument arg; REQUIRE(parser.parse(&arg)); REQUIRE(arg.arg_size() == arg_size); REQUIRE(arg.base_register_name()); REQUIRE(arg.base_register_name() == regname); REQUIRE(arg.deref_offset() == deref_offset); REQUIRE(arg.deref_ident() == deref_ident); REQUIRE(arg.index_register_name() == index_regname); REQUIRE(arg.scale() == scale); } TEST_CASE("test usdt argument parsing", "[usdt]") { SECTION("parse failure") { USDT::ArgumentParser_x64 parser("4@i%ra+1r"); USDT::Argument arg; REQUIRE(!parser.parse(&arg)); int i; for (i = 0; i < 10 && !parser.done(); ++i) { parser.parse(&arg); } // Make sure we reach termination REQUIRE(i < 10); } SECTION("argument examples from the Python implementation") { USDT::ArgumentParser_x64 parser( "-4@$0 8@$1234 %rdi %rax %rsi " "-8@%rbx 4@%r12 8@-8(%rbp) 4@(%rax) " "-4@global_max_action(%rip) " "8@24+mp_(%rip) " "-4@CheckpointStats+40(%rip) " "4@glob-2(%rip) " "8@(%rax,%rdx,8) " "4@(%rbx,%rcx)"); verify_register(parser, -4, 0); verify_register(parser, 8, 1234); verify_register(parser, 8, "di"); verify_register(parser, 8, "ax"); verify_register(parser, 8, "si"); verify_register(parser, -8, "bx"); verify_register(parser, 4, "r12"); verify_register(parser, 8, "bp", -8); verify_register(parser, 4, "ax", 0); verify_register(parser, -4, "ip", 0, std::string("global_max_action")); verify_register(parser, 8, "ip", 24, std::string("mp_")); verify_register(parser, -4, "ip", 40, std::string("CheckpointStats")); verify_register(parser, 4, "ip", -2, std::string("glob")); verify_register(parser, 8, "ax", 0, nullopt, std::string("dx"), 8); verify_register(parser, 4, "bx", 0, nullopt, std::string("cx")); REQUIRE(parser.done()); } } bpfcc-0.2.0+git0.02884a026/tests/cc/test_usdt_probes.cc000066400000000000000000000106431305314114400221300ustar00rootroot00000000000000/* * Copyright (c) 2016 GitHub, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include "catch.hpp" #include "usdt.h" #ifdef HAVE_SDT_HEADER /* required to insert USDT probes on this very executable -- * we're gonna be testing them live! */ #include static int a_probed_function() { int an_int = 23 + getpid(); void *a_pointer = malloc(4); DTRACE_PROBE2(libbcc_test, sample_probe_1, an_int, a_pointer); free(a_pointer); return an_int; } TEST_CASE("test finding a probe in our own process", "[usdt]") { USDT::Context ctx(getpid()); REQUIRE(ctx.num_probes() >= 1); SECTION("our test probe") { auto probe = ctx.get("sample_probe_1"); REQUIRE(probe); REQUIRE(probe->in_shared_object() == false); REQUIRE(probe->name() == "sample_probe_1"); REQUIRE(probe->provider() == "libbcc_test"); REQUIRE(probe->bin_path().find("/test_libbcc") != std::string::npos); REQUIRE(probe->num_locations() == 1); REQUIRE(probe->num_arguments() == 2); REQUIRE(probe->need_enable() == false); REQUIRE(a_probed_function() != 0); } } #endif // HAVE_SDT_HEADER class ChildProcess { pid_t pid_; public: ChildProcess(const char *name, char *const argv[]) { pid_ = fork(); if (pid_ == 0) { execvp(name, argv); exit(0); } if (spawned()) { usleep(250000); if (kill(pid_, 0) < 0) pid_ = -1; } } ~ChildProcess() { if (spawned()) { int status; kill(pid_, SIGKILL); if (waitpid(pid_, &status, 0) != pid_) abort(); } } bool spawned() const { return pid_ > 0; } pid_t pid() const { return pid_; } }; TEST_CASE("test listing all USDT probes in Ruby/MRI", "[usdt]") { size_t mri_probe_count = 0; SECTION("without a running Ruby process") { USDT::Context ctx("ruby"); if (!ctx.loaded()) return; REQUIRE(ctx.num_probes() > 10); mri_probe_count = ctx.num_probes(); SECTION("GC static probe") { auto probe = ctx.get("gc__mark__begin"); REQUIRE(probe); REQUIRE(probe->in_shared_object() == true); REQUIRE(probe->name() == "gc__mark__begin"); REQUIRE(probe->provider() == "ruby"); REQUIRE(probe->bin_path().find("/ruby") != std::string::npos); REQUIRE(probe->num_locations() == 1); REQUIRE(probe->num_arguments() == 0); REQUIRE(probe->need_enable() == true); } SECTION("object creation probe") { auto probe = ctx.get("object__create"); REQUIRE(probe); REQUIRE(probe->in_shared_object() == true); REQUIRE(probe->name() == "object__create"); REQUIRE(probe->provider() == "ruby"); REQUIRE(probe->bin_path().find("/ruby") != std::string::npos); REQUIRE(probe->num_locations() == 1); REQUIRE(probe->num_arguments() == 3); REQUIRE(probe->need_enable() == true); } SECTION("array creation probe") { auto probe = ctx.get("array__create"); REQUIRE(probe); REQUIRE(probe->name() == "array__create"); REQUIRE(probe->num_locations() == 7); REQUIRE(probe->num_arguments() == 3); REQUIRE(probe->need_enable() == true); } } SECTION("with a running Ruby process") { static char _ruby[] = "ruby"; char *const argv[2] = {_ruby, NULL}; ChildProcess ruby(argv[0], argv); if (!ruby.spawned()) return; USDT::Context ctx(ruby.pid()); REQUIRE(ctx.num_probes() >= mri_probe_count); SECTION("get probe in running process") { auto probe = ctx.get("gc__mark__begin"); REQUIRE(probe); REQUIRE(probe->in_shared_object() == true); REQUIRE(probe->name() == "gc__mark__begin"); REQUIRE(probe->provider() == "ruby"); REQUIRE(probe->bin_path().find("/ruby") != std::string::npos); REQUIRE(probe->num_locations() == 1); REQUIRE(probe->num_arguments() == 0); REQUIRE(probe->need_enable() == true); } } } bpfcc-0.2.0+git0.02884a026/tests/lua/000077500000000000000000000000001305314114400164215ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tests/lua/.busted000066400000000000000000000002241305314114400177060ustar00rootroot00000000000000-- Configuration for unit tests -- See: http://olivinelabs.com/busted/ return { default = { lpath = "./?.lua", ["auto-insulate"] = false, } }bpfcc-0.2.0+git0.02884a026/tests/lua/.luacheckrc000066400000000000000000000004311305314114400205240ustar00rootroot00000000000000std = "luajit" ignore = { "211", "212", "411", "412", "421", "431", "542" } files["examples"] = { new_globals = { "pkt", "time", "xadd", "c" } } files["bpf/builtins.lua"] = { ignore = { "122" } } files["spec"] = { std = "+busted", new_globals = { "pkt", "time", "xadd", "c" } }bpfcc-0.2.0+git0.02884a026/tests/lua/CMakeLists.txt000066400000000000000000000016101305314114400211570ustar00rootroot00000000000000find_program(LUAJIT luajit) find_program(BUSTED busted) if(LUAJIT) add_test(NAME lua_test_clang WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} lua_test_clang sudo ${LUAJIT} test_clang.lua) add_test(NAME lua_test_uprobes WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} lua_test_uprobes sudo ${LUAJIT} test_uprobes.lua) add_test(NAME lua_test_dump WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} lua_test_dump sudo ${LUAJIT} test_dump.lua) add_test(NAME lua_test_standalone WORKING_DIRECTORY ${CMAKE_BINARY_DIR} COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test_standalone.sh) if(BUSTED) add_test(NAME lua_test_busted WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND busted --lua=${LUAJIT} -m "${CMAKE_CURRENT_SOURCE_DIR}/../../src/lua/?.lua" -m "${CMAKE_CURRENT_SOURCE_DIR}/../../src/lua/?/init.lua;") endif() endif() bpfcc-0.2.0+git0.02884a026/tests/lua/luaunit.lua000066400000000000000000002255541305314114400206220ustar00rootroot00000000000000--[[ luaunit.lua Description: A unit testing framework Homepage: https://github.com/bluebird75/luaunit Development by Philippe Fremy Based on initial work of Ryu, Gwang (http://www.gpgstudy.com/gpgiki/LuaUnit) License: BSD License, see LICENSE.txt Version: 3.2 ]]-- require("math") local M={} -- private exported functions (for testing) M.private = {} M.VERSION='3.2' --[[ Some people like assertEquals( actual, expected ) and some people prefer assertEquals( expected, actual ). ]]-- M.ORDER_ACTUAL_EXPECTED = true M.PRINT_TABLE_REF_IN_ERROR_MSG = false M.TABLE_EQUALS_KEYBYCONTENT = true M.LINE_LENGTH=80 -- set this to false to debug luaunit local STRIP_LUAUNIT_FROM_STACKTRACE=true M.VERBOSITY_DEFAULT = 10 M.VERBOSITY_LOW = 1 M.VERBOSITY_QUIET = 0 M.VERBOSITY_VERBOSE = 20 -- set EXPORT_ASSERT_TO_GLOBALS to have all asserts visible as global values -- EXPORT_ASSERT_TO_GLOBALS = true -- we need to keep a copy of the script args before it is overriden local cmdline_argv = rawget(_G, "arg") M.FAILURE_PREFIX = 'LuaUnit test FAILURE: ' -- prefix string for failed tests M.USAGE=[[Usage: lua [options] [testname1 [testname2] ... ] Options: -h, --help: Print this help --version: Print version information -v, --verbose: Increase verbosity -q, --quiet: Set verbosity to minimum -e, --error: Stop on first error -f, --failure: Stop on first failure or error -o, --output OUTPUT: Set output type to OUTPUT Possible values: text, tap, junit, nil -n, --name NAME: For junit only, mandatory name of xml file -p, --pattern PATTERN: Execute all test names matching the Lua PATTERN May be repeated to include severals patterns Make sure you escape magic chars like +? with % testname1, testname2, ... : tests to run in the form of testFunction, TestClass or TestClass.testMethod ]] ---------------------------------------------------------------- -- -- general utility functions -- ---------------------------------------------------------------- local crossTypeOrdering = { number = 1, boolean = 2, string = 3, table = 4, other = 5 } local crossTypeComparison = { number = function(a, b) return a < b end, string = function(a, b) return a < b end, other = function(a, b) return tostring(a) < tostring(b) end, } local function crossTypeSort(a, b) local type_a, type_b = type(a), type(b) if type_a == type_b then local func = crossTypeComparison[type_a] or crossTypeComparison.other return func(a, b) end type_a = crossTypeOrdering[type_a] or crossTypeOrdering.other type_b = crossTypeOrdering[type_b] or crossTypeOrdering.other return type_a < type_b end local function __genSortedIndex( t ) -- Returns a sequence consisting of t's keys, sorted. local sortedIndex = {} for key,_ in pairs(t) do table.insert(sortedIndex, key) end table.sort(sortedIndex, crossTypeSort) return sortedIndex end M.private.__genSortedIndex = __genSortedIndex local function sortedNext(state, control) -- Equivalent of the next() function of table iteration, but returns the -- keys in sorted order (see __genSortedIndex and crossTypeSort). -- The state is a temporary variable during iteration and contains the -- sorted key table (state.sortedIdx). It also stores the last index (into -- the keys) used by the iteration, to find the next one quickly. local key --print("sortedNext: control = "..tostring(control) ) if control == nil then -- start of iteration state.lastIdx = 1 key = state.sortedIdx[1] return key, state.t[key] end -- normally, we expect the control variable to match the last key used if control ~= state.sortedIdx[state.lastIdx] then -- strange, we have to find the next value by ourselves -- the key table is sorted in crossTypeSort() order! -> use bisection local count = #state.sortedIdx local lower, upper = 1, count repeat state.lastIdx = math.modf((lower + upper) / 2) key = state.sortedIdx[state.lastIdx] if key == control then break; end -- key found (and thus prev index) if crossTypeSort(key, control) then -- key < control, continue search "right" (towards upper bound) lower = state.lastIdx + 1 else -- key > control, continue search "left" (towards lower bound) upper = state.lastIdx - 1 end until lower > upper if lower > upper then -- only true if the key wasn't found, ... state.lastIdx = count -- ... so ensure no match for the code below end end -- proceed by retrieving the next value (or nil) from the sorted keys state.lastIdx = state.lastIdx + 1 key = state.sortedIdx[state.lastIdx] if key then return key, state.t[key] end -- getting here means returning `nil`, which will end the iteration end local function sortedPairs(tbl) -- Equivalent of the pairs() function on tables. Allows to iterate in -- sorted order. As required by "generic for" loops, this will return the -- iterator (function), an "invariant state", and the initial control value. -- (see http://www.lua.org/pil/7.2.html) return sortedNext, {t = tbl, sortedIdx = __genSortedIndex(tbl)}, nil end M.private.sortedPairs = sortedPairs local function strsplit(delimiter, text) -- Split text into a list consisting of the strings in text, -- separated by strings matching delimiter (which may be a pattern). -- example: strsplit(",%s*", "Anna, Bob, Charlie,Dolores") if string.find("", delimiter, 1, true) then -- this would result in endless loops error("delimiter matches empty string!") end local list, pos, first, last = {}, 1 while true do first, last = text:find(delimiter, pos, true) if first then -- found? table.insert(list, text:sub(pos, first - 1)) pos = last + 1 else table.insert(list, text:sub(pos)) break end end return list end M.private.strsplit = strsplit local function hasNewLine( s ) -- return true if s has a newline return (string.find(s, '\n', 1, true) ~= nil) end M.private.hasNewLine = hasNewLine local function prefixString( prefix, s ) -- Prefix all the lines of s with prefix return prefix .. table.concat(strsplit('\n', s), '\n' .. prefix) end M.private.prefixString = prefixString local function strMatch(s, pattern, start, final ) -- return true if s matches completely the pattern from index start to index end -- return false in every other cases -- if start is nil, matches from the beginning of the string -- if final is nil, matches to the end of the string start = start or 1 final = final or string.len(s) local foundStart, foundEnd = string.find(s, pattern, start, false) return foundStart == start and foundEnd == final end M.private.strMatch = strMatch local function xmlEscape( s ) -- Return s escaped for XML attributes -- escapes table: -- " " -- ' ' -- < < -- > > -- & & return string.gsub( s, '.', { ['&'] = "&", ['"'] = """, ["'"] = "'", ['<'] = "<", ['>'] = ">", } ) end M.private.xmlEscape = xmlEscape local function xmlCDataEscape( s ) -- Return s escaped for CData section, escapes: "]]>" return string.gsub( s, ']]>', ']]>' ) end M.private.xmlCDataEscape = xmlCDataEscape local function stripLuaunitTrace( stackTrace ) --[[ -- Example of a traceback: < [C]: in function 'xpcall' ./luaunit.lua:1449: in function 'protectedCall' ./luaunit.lua:1508: in function 'execOneFunction' ./luaunit.lua:1596: in function 'runSuiteByInstances' ./luaunit.lua:1660: in function 'runSuiteByNames' ./luaunit.lua:1736: in function 'runSuite' example_with_luaunit.lua:140: in main chunk [C]: in ?>> Other example: < [C]: in function 'xpcall' ./luaunit.lua:1517: in function 'protectedCall' ./luaunit.lua:1578: in function 'execOneFunction' ./luaunit.lua:1677: in function 'runSuiteByInstances' ./luaunit.lua:1730: in function 'runSuiteByNames' ./luaunit.lua:1806: in function 'runSuite' example_with_luaunit.lua:140: in main chunk [C]: in ?>> < [C]: in function 'xpcall' luaunit2/luaunit.lua:1532: in function 'protectedCall' luaunit2/luaunit.lua:1591: in function 'execOneFunction' luaunit2/luaunit.lua:1679: in function 'runSuiteByInstances' luaunit2/luaunit.lua:1743: in function 'runSuiteByNames' luaunit2/luaunit.lua:1819: in function 'runSuite' luaunit2/example_with_luaunit.lua:140: in main chunk [C]: in ?>> -- first line is "stack traceback": KEEP -- next line may be luaunit line: REMOVE -- next lines are call in the program under testOk: REMOVE -- next lines are calls from luaunit to call the program under test: KEEP -- Strategy: -- keep first line -- remove lines that are part of luaunit -- kepp lines until we hit a luaunit line ]] local function isLuaunitInternalLine( s ) -- return true if line of stack trace comes from inside luaunit return s:find('[/\\]luaunit%.lua:%d+: ') ~= nil end -- print( '<<'..stackTrace..'>>' ) local t = strsplit( '\n', stackTrace ) -- print( prettystr(t) ) local idx = 2 -- remove lines that are still part of luaunit while t[idx] and isLuaunitInternalLine( t[idx] ) do -- print('Removing : '..t[idx] ) table.remove(t, idx) end -- keep lines until we hit luaunit again while t[idx] and (not isLuaunitInternalLine(t[idx])) do -- print('Keeping : '..t[idx] ) idx = idx + 1 end -- remove remaining luaunit lines while t[idx] do -- print('Removing : '..t[idx] ) table.remove(t, idx) end -- print( prettystr(t) ) return table.concat( t, '\n') end M.private.stripLuaunitTrace = stripLuaunitTrace local function prettystr_sub(v, indentLevel, keeponeline, printTableRefs, recursionTable ) local type_v = type(v) if "string" == type_v then if keeponeline then v = v:gsub("\n", "\\n") end -- use clever delimiters according to content: -- enclose with single quotes if string contains ", but no ' if v:find('"', 1, true) and not v:find("'", 1, true) then return "'" .. v .. "'" end -- use double quotes otherwise, escape embedded " return '"' .. v:gsub('"', '\\"') .. '"' elseif "table" == type_v then --if v.__class__ then -- return string.gsub( tostring(v), 'table', v.__class__ ) --end return M.private._table_tostring(v, indentLevel, printTableRefs, recursionTable) end return tostring(v) end local function prettystr( v, keeponeline ) --[[ Better string conversion, to display nice variable content: For strings, if keeponeline is set to true, string is displayed on one line, with visible \n * string are enclosed with " by default, or with ' if string contains a " * if table is a class, display class name * tables are expanded ]]-- local recursionTable = {} local s = prettystr_sub(v, 1, keeponeline, M.PRINT_TABLE_REF_IN_ERROR_MSG, recursionTable) if recursionTable.recursionDetected and not M.PRINT_TABLE_REF_IN_ERROR_MSG then -- some table contain recursive references, -- so we must recompute the value by including all table references -- else the result looks like crap recursionTable = {} s = prettystr_sub(v, 1, keeponeline, true, recursionTable) end return s end M.prettystr = prettystr local function prettystrPadded(value1, value2, suffix_a, suffix_b) --[[ This function helps with the recurring task of constructing the "expected vs. actual" error messages. It takes two arbitrary values and formats corresponding strings with prettystr(). To keep the (possibly complex) output more readable in case the resulting strings contain line breaks, they get automatically prefixed with additional newlines. Both suffixes are optional (default to empty strings), and get appended to the "value1" string. "suffix_a" is used if line breaks were encountered, "suffix_b" otherwise. Returns the two formatted strings (including padding/newlines). ]] local str1, str2 = prettystr(value1), prettystr(value2) if hasNewLine(str1) or hasNewLine(str2) then -- line break(s) detected, add padding return "\n" .. str1 .. (suffix_a or ""), "\n" .. str2 end return str1 .. (suffix_b or ""), str2 end M.private.prettystrPadded = prettystrPadded local function _table_keytostring(k) -- like prettystr but do not enclose with "" if the string is just alphanumerical -- this is better for displaying table keys who are often simple strings if "string" == type(k) and k:match("^[_%a][_%w]*$") then return k end return prettystr(k) end M.private._table_keytostring = _table_keytostring local TABLE_TOSTRING_SEP = ", " local TABLE_TOSTRING_SEP_LEN = string.len(TABLE_TOSTRING_SEP) local function _table_tostring( tbl, indentLevel, printTableRefs, recursionTable ) printTableRefs = printTableRefs or M.PRINT_TABLE_REF_IN_ERROR_MSG recursionTable = recursionTable or {} recursionTable[tbl] = true local result, dispOnMultLines = {}, false local entry, count, seq_index = nil, 0, 1 for k, v in sortedPairs( tbl ) do if k == seq_index then -- for the sequential part of tables, we'll skip the "=" output entry = '' seq_index = seq_index + 1 else entry = _table_keytostring( k ) .. "=" end if recursionTable[v] then -- recursion detected! recursionTable.recursionDetected = true entry = entry .. "<"..tostring(v)..">" else entry = entry .. prettystr_sub( v, indentLevel+1, true, printTableRefs, recursionTable ) end count = count + 1 result[count] = entry end -- set dispOnMultLines if the maximum LINE_LENGTH would be exceeded local totalLength = 0 for k, v in ipairs( result ) do totalLength = totalLength + string.len( v ) if totalLength >= M.LINE_LENGTH then dispOnMultLines = true break end end if not dispOnMultLines then -- adjust with length of separator(s): -- two items need 1 sep, three items two seps, ... plus len of '{}' if count > 0 then totalLength = totalLength + TABLE_TOSTRING_SEP_LEN * (count - 1) end dispOnMultLines = totalLength + 2 >= M.LINE_LENGTH end -- now reformat the result table (currently holding element strings) if dispOnMultLines then local indentString = string.rep(" ", indentLevel - 1) result = {"{\n ", indentString, table.concat(result, ",\n " .. indentString), "\n", indentString, "}"} else result = {"{", table.concat(result, TABLE_TOSTRING_SEP), "}"} end if printTableRefs then table.insert(result, 1, "<"..tostring(tbl).."> ") -- prepend table ref end return table.concat(result) end M.private._table_tostring = _table_tostring -- prettystr_sub() needs it local function _table_contains(t, element) if t then for _, value in pairs(t) do if type(value) == type(element) then if type(element) == 'table' then -- if we wanted recursive items content comparison, we could use -- _is_table_items_equals(v, expected) but one level of just comparing -- items is sufficient if M.private._is_table_equals( value, element ) then return true end else if value == element then return true end end end end end return false end local function _is_table_items_equals(actual, expected ) if (type(actual) == 'table') and (type(expected) == 'table') then for k,v in pairs(actual) do if not _table_contains(expected, v) then return false end end for k,v in pairs(expected) do if not _table_contains(actual, v) then return false end end return true elseif type(actual) ~= type(expected) then return false elseif actual == expected then return true end return false end local function _is_table_equals(actual, expected) if (type(actual) == 'table') and (type(expected) == 'table') then if (#actual ~= #expected) then return false end local actualTableKeys = {} for k,v in pairs(actual) do if M.TABLE_EQUALS_KEYBYCONTENT and type(k) == "table" then -- If the keys are tables, things get a bit tricky here as we -- can have _is_table_equals(k1, k2) and t[k1] ~= t[k2]. So we -- collect actual's table keys, group them by length for -- performance, and then for each table key in expected we look -- it up in actualTableKeys. if not actualTableKeys[#k] then actualTableKeys[#k] = {} end table.insert(actualTableKeys[#k], k) else if not _is_table_equals(v, expected[k]) then return false end end end for k,v in pairs(expected) do if M.TABLE_EQUALS_KEYBYCONTENT and type(k) == "table" then local candidates = actualTableKeys[#k] if not candidates then return false end local found for i, candidate in pairs(candidates) do if _is_table_equals(candidate, k) then found = candidate -- Remove the candidate we matched against from the list -- of candidates, so each key in actual can only match -- one key in expected. candidates[i] = nil break end end if not(found and _is_table_equals(actual[found], v)) then return false end else if not _is_table_equals(v, actual[k]) then return false end end end if M.TABLE_EQUALS_KEYBYCONTENT then for _, keys in pairs(actualTableKeys) do -- if there are any keys left in any actualTableKeys[i] then -- that is a key in actual with no matching key in expected, -- and so the tables aren't equal. if next(keys) then return false end end end return true elseif type(actual) ~= type(expected) then return false elseif actual == expected then return true end return false end M.private._is_table_equals = _is_table_equals local function failure(msg, level) -- raise an error indicating a test failure -- for error() compatibility we adjust "level" here (by +1), to report the -- calling context error(M.FAILURE_PREFIX .. msg, (level or 1) + 1) end local function fail_fmt(level, ...) -- failure with printf-style formatted message and given error level failure(string.format(...), (level or 1) + 1) end M.private.fail_fmt = fail_fmt local function error_fmt(level, ...) -- printf-style error() error(string.format(...), (level or 1) + 1) end ---------------------------------------------------------------- -- -- assertions -- ---------------------------------------------------------------- local function errorMsgEquality(actual, expected) if not M.ORDER_ACTUAL_EXPECTED then expected, actual = actual, expected end if type(expected) == 'string' or type(expected) == 'table' then expected, actual = prettystrPadded(expected, actual) return string.format("expected: %s\nactual: %s", expected, actual) end return string.format("expected: %s, actual: %s", prettystr(expected), prettystr(actual)) end function M.assertError(f, ...) -- assert that calling f with the arguments will raise an error -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error if pcall( f, ... ) then failure( "Expected an error when calling function but no error generated", 2 ) end end function M.assertTrue(value) if not value then failure("expected: true, actual: " ..prettystr(value), 2) end end function M.assertFalse(value) if value then failure("expected: false, actual: " ..prettystr(value), 2) end end function M.assertIsNil(value) if value ~= nil then failure("expected: nil, actual: " ..prettystr(value), 2) end end function M.assertNotIsNil(value) if value == nil then failure("expected non nil value, received nil", 2) end end function M.assertEquals(actual, expected) if type(actual) == 'table' and type(expected) == 'table' then if not _is_table_equals(actual, expected) then failure( errorMsgEquality(actual, expected), 2 ) end elseif type(actual) ~= type(expected) then failure( errorMsgEquality(actual, expected), 2 ) elseif actual ~= expected then failure( errorMsgEquality(actual, expected), 2 ) end end -- Help Lua in corner cases like almostEquals(1.1, 1.0, 0.1), which by default -- may not work. We need to give margin a small boost; EPSILON defines the -- default value to use for this: local EPSILON = 0.00000000001 function M.almostEquals( actual, expected, margin, margin_boost ) if type(actual) ~= 'number' or type(expected) ~= 'number' or type(margin) ~= 'number' then error_fmt(3, 'almostEquals: must supply only number arguments.\nArguments supplied: %s, %s, %s', prettystr(actual), prettystr(expected), prettystr(margin)) end if margin <= 0 then error('almostEquals: margin must be positive, current value is ' .. margin, 3) end local realmargin = margin + (margin_boost or EPSILON) return math.abs(expected - actual) <= realmargin end function M.assertAlmostEquals( actual, expected, margin ) -- check that two floats are close by margin if not M.almostEquals(actual, expected, margin) then if not M.ORDER_ACTUAL_EXPECTED then expected, actual = actual, expected end fail_fmt(2, 'Values are not almost equal\nExpected: %s with margin of %s, received: %s', expected, margin, actual) end end function M.assertNotEquals(actual, expected) if type(actual) ~= type(expected) then return end if type(actual) == 'table' and type(expected) == 'table' then if not _is_table_equals(actual, expected) then return end elseif actual ~= expected then return end fail_fmt(2, 'Received the not expected value: %s', prettystr(actual)) end function M.assertNotAlmostEquals( actual, expected, margin ) -- check that two floats are not close by margin if M.almostEquals(actual, expected, margin) then if not M.ORDER_ACTUAL_EXPECTED then expected, actual = actual, expected end fail_fmt(2, 'Values are almost equal\nExpected: %s with a difference above margin of %s, received: %s', expected, margin, actual) end end function M.assertStrContains( str, sub, useRe ) -- this relies on lua string.find function -- a string always contains the empty string if not string.find(str, sub, 1, not useRe) then sub, str = prettystrPadded(sub, str, '\n') fail_fmt(2, 'Error, %s %s was not found in string %s', useRe and 'regexp' or 'substring', sub, str) end end function M.assertStrIContains( str, sub ) -- this relies on lua string.find function -- a string always contains the empty string if not string.find(str:lower(), sub:lower(), 1, true) then sub, str = prettystrPadded(sub, str, '\n') fail_fmt(2, 'Error, substring %s was not found (case insensitively) in string %s', sub, str) end end function M.assertNotStrContains( str, sub, useRe ) -- this relies on lua string.find function -- a string always contains the empty string if string.find(str, sub, 1, not useRe) then sub, str = prettystrPadded(sub, str, '\n') fail_fmt(2, 'Error, %s %s was found in string %s', useRe and 'regexp' or 'substring', sub, str) end end function M.assertNotStrIContains( str, sub ) -- this relies on lua string.find function -- a string always contains the empty string if string.find(str:lower(), sub:lower(), 1, true) then sub, str = prettystrPadded(sub, str, '\n') fail_fmt(2, 'Error, substring %s was found (case insensitively) in string %s', sub, str) end end function M.assertStrMatches( str, pattern, start, final ) -- Verify a full match for the string -- for a partial match, simply use assertStrContains with useRe set to true if not strMatch( str, pattern, start, final ) then pattern, str = prettystrPadded(pattern, str, '\n') fail_fmt(2, 'Error, pattern %s was not matched by string %s', pattern, str) end end function M.assertErrorMsgEquals( expectedMsg, func, ... ) -- assert that calling f with the arguments will raise an error -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error local no_error, error_msg = pcall( func, ... ) if no_error then failure( 'No error generated when calling function but expected error: "'..expectedMsg..'"', 2 ) end if error_msg ~= expectedMsg then error_msg, expectedMsg = prettystrPadded(error_msg, expectedMsg) fail_fmt(2, 'Exact error message expected: %s\nError message received: %s\n', expectedMsg, error_msg) end end function M.assertErrorMsgContains( partialMsg, func, ... ) -- assert that calling f with the arguments will raise an error -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error local no_error, error_msg = pcall( func, ... ) if no_error then failure( 'No error generated when calling function but expected error containing: '..prettystr(partialMsg), 2 ) end if not string.find( error_msg, partialMsg, nil, true ) then error_msg, partialMsg = prettystrPadded(error_msg, partialMsg) fail_fmt(2, 'Error message does not contain: %s\nError message received: %s\n', partialMsg, error_msg) end end function M.assertErrorMsgMatches( expectedMsg, func, ... ) -- assert that calling f with the arguments will raise an error -- example: assertError( f, 1, 2 ) => f(1,2) should generate an error local no_error, error_msg = pcall( func, ... ) if no_error then failure( 'No error generated when calling function but expected error matching: "'..expectedMsg..'"', 2 ) end if not strMatch( error_msg, expectedMsg ) then expectedMsg, error_msg = prettystrPadded(expectedMsg, error_msg) fail_fmt(2, 'Error message does not match: %s\nError message received: %s\n', expectedMsg, error_msg) end end --[[ Add type assertion functions to the module table M. Each of these functions takes a single parameter "value", and checks that its Lua type matches the expected string (derived from the function name): M.assertIsXxx(value) -> ensure that type(value) conforms to "xxx" ]] for _, funcName in ipairs( {'assertIsNumber', 'assertIsString', 'assertIsTable', 'assertIsBoolean', 'assertIsFunction', 'assertIsUserdata', 'assertIsThread'} ) do local typeExpected = funcName:match("^assertIs([A-Z]%a*)$") -- Lua type() always returns lowercase, also make sure the match() succeeded typeExpected = typeExpected and typeExpected:lower() or error("bad function name '"..funcName.."' for type assertion") M[funcName] = function(value) if type(value) ~= typeExpected then fail_fmt(2, 'Expected: a %s value, actual: type %s, value %s', typeExpected, type(value), prettystrPadded(value)) end end end --[[ Add non-type assertion functions to the module table M. Each of these functions takes a single parameter "value", and checks that its Lua type differs from the expected string (derived from the function name): M.assertNotIsXxx(value) -> ensure that type(value) is not "xxx" ]] for _, funcName in ipairs( {'assertNotIsNumber', 'assertNotIsString', 'assertNotIsTable', 'assertNotIsBoolean', 'assertNotIsFunction', 'assertNotIsUserdata', 'assertNotIsThread'} ) do local typeUnexpected = funcName:match("^assertNotIs([A-Z]%a*)$") -- Lua type() always returns lowercase, also make sure the match() succeeded typeUnexpected = typeUnexpected and typeUnexpected:lower() or error("bad function name '"..funcName.."' for type assertion") M[funcName] = function(value) if type(value) == typeUnexpected then fail_fmt(2, 'Not expected: a %s type, actual: value %s', typeUnexpected, prettystrPadded(value)) end end end function M.assertIs(actual, expected) if actual ~= expected then if not M.ORDER_ACTUAL_EXPECTED then actual, expected = expected, actual end expected, actual = prettystrPadded(expected, actual, '\n', ', ') fail_fmt(2, 'Expected object and actual object are not the same\nExpected: %sactual: %s', expected, actual) end end function M.assertNotIs(actual, expected) if actual == expected then if not M.ORDER_ACTUAL_EXPECTED then expected = actual end fail_fmt(2, 'Expected object and actual object are the same object: %s', prettystrPadded(expected)) end end function M.assertItemsEquals(actual, expected) -- checks that the items of table expected -- are contained in table actual. Warning, this function -- is at least O(n^2) if not _is_table_items_equals(actual, expected ) then expected, actual = prettystrPadded(expected, actual) fail_fmt(2, 'Contents of the tables are not identical:\nExpected: %s\nActual: %s', expected, actual) end end ---------------------------------------------------------------- -- Compatibility layer ---------------------------------------------------------------- -- for compatibility with LuaUnit v2.x function M.wrapFunctions(...) io.stderr:write( [[Use of WrapFunction() is no longer needed. Just prefix your test function names with "test" or "Test" and they will be picked up and run by LuaUnit.]] ) -- In LuaUnit version <= 2.1 , this function was necessary to include -- a test function inside the global test suite. Nowadays, the functions -- are simply run directly as part of the test discovery process. -- so just do nothing ! --[[ local testClass, testFunction testClass = {} local function storeAsMethod(idx, testName) testFunction = _G[testName] testClass[testName] = testFunction end for i,v in ipairs({...}) do storeAsMethod( i, v ) end return testClass ]] end local list_of_funcs = { -- { official function name , alias } -- general assertions { 'assertEquals' , 'assert_equals' }, { 'assertItemsEquals' , 'assert_items_equals' }, { 'assertNotEquals' , 'assert_not_equals' }, { 'assertAlmostEquals' , 'assert_almost_equals' }, { 'assertNotAlmostEquals' , 'assert_not_almost_equals' }, { 'assertTrue' , 'assert_true' }, { 'assertFalse' , 'assert_false' }, { 'assertStrContains' , 'assert_str_contains' }, { 'assertStrIContains' , 'assert_str_icontains' }, { 'assertNotStrContains' , 'assert_not_str_contains' }, { 'assertNotStrIContains' , 'assert_not_str_icontains' }, { 'assertStrMatches' , 'assert_str_matches' }, { 'assertError' , 'assert_error' }, { 'assertErrorMsgEquals' , 'assert_error_msg_equals' }, { 'assertErrorMsgContains' , 'assert_error_msg_contains' }, { 'assertErrorMsgMatches' , 'assert_error_msg_matches' }, { 'assertIs' , 'assert_is' }, { 'assertNotIs' , 'assert_not_is' }, { 'wrapFunctions' , 'WrapFunctions' }, { 'wrapFunctions' , 'wrap_functions' }, -- type assertions: assertIsXXX -> assert_is_xxx { 'assertIsNumber' , 'assert_is_number' }, { 'assertIsString' , 'assert_is_string' }, { 'assertIsTable' , 'assert_is_table' }, { 'assertIsBoolean' , 'assert_is_boolean' }, { 'assertIsNil' , 'assert_is_nil' }, { 'assertIsFunction' , 'assert_is_function' }, { 'assertIsThread' , 'assert_is_thread' }, { 'assertIsUserdata' , 'assert_is_userdata' }, -- type assertions: assertIsXXX -> assertXxx { 'assertIsNumber' , 'assertNumber' }, { 'assertIsString' , 'assertString' }, { 'assertIsTable' , 'assertTable' }, { 'assertIsBoolean' , 'assertBoolean' }, { 'assertIsNil' , 'assertNil' }, { 'assertIsFunction' , 'assertFunction' }, { 'assertIsThread' , 'assertThread' }, { 'assertIsUserdata' , 'assertUserdata' }, -- type assertions: assertIsXXX -> assert_xxx (luaunit v2 compat) { 'assertIsNumber' , 'assert_number' }, { 'assertIsString' , 'assert_string' }, { 'assertIsTable' , 'assert_table' }, { 'assertIsBoolean' , 'assert_boolean' }, { 'assertIsNil' , 'assert_nil' }, { 'assertIsFunction' , 'assert_function' }, { 'assertIsThread' , 'assert_thread' }, { 'assertIsUserdata' , 'assert_userdata' }, -- type assertions: assertNotIsXXX -> assert_not_is_xxx { 'assertNotIsNumber' , 'assert_not_is_number' }, { 'assertNotIsString' , 'assert_not_is_string' }, { 'assertNotIsTable' , 'assert_not_is_table' }, { 'assertNotIsBoolean' , 'assert_not_is_boolean' }, { 'assertNotIsNil' , 'assert_not_is_nil' }, { 'assertNotIsFunction' , 'assert_not_is_function' }, { 'assertNotIsThread' , 'assert_not_is_thread' }, { 'assertNotIsUserdata' , 'assert_not_is_userdata' }, -- type assertions: assertNotIsXXX -> assertNotXxx (luaunit v2 compat) { 'assertNotIsNumber' , 'assertNotNumber' }, { 'assertNotIsString' , 'assertNotString' }, { 'assertNotIsTable' , 'assertNotTable' }, { 'assertNotIsBoolean' , 'assertNotBoolean' }, { 'assertNotIsNil' , 'assertNotNil' }, { 'assertNotIsFunction' , 'assertNotFunction' }, { 'assertNotIsThread' , 'assertNotThread' }, { 'assertNotIsUserdata' , 'assertNotUserdata' }, -- type assertions: assertNotIsXXX -> assert_not_xxx { 'assertNotIsNumber' , 'assert_not_number' }, { 'assertNotIsString' , 'assert_not_string' }, { 'assertNotIsTable' , 'assert_not_table' }, { 'assertNotIsBoolean' , 'assert_not_boolean' }, { 'assertNotIsNil' , 'assert_not_nil' }, { 'assertNotIsFunction' , 'assert_not_function' }, { 'assertNotIsThread' , 'assert_not_thread' }, { 'assertNotIsUserdata' , 'assert_not_userdata' }, -- all assertions with Coroutine duplicate Thread assertions { 'assertIsThread' , 'assertIsCoroutine' }, { 'assertIsThread' , 'assertCoroutine' }, { 'assertIsThread' , 'assert_is_coroutine' }, { 'assertIsThread' , 'assert_coroutine' }, { 'assertNotIsThread' , 'assertNotIsCoroutine' }, { 'assertNotIsThread' , 'assertNotCoroutine' }, { 'assertNotIsThread' , 'assert_not_is_coroutine' }, { 'assertNotIsThread' , 'assert_not_coroutine' }, } -- Create all aliases in M for _,v in ipairs( list_of_funcs ) do funcname, alias = v[1], v[2] M[alias] = M[funcname] if EXPORT_ASSERT_TO_GLOBALS then _G[funcname] = M[funcname] _G[alias] = M[funcname] end end ---------------------------------------------------------------- -- -- Outputters -- ---------------------------------------------------------------- ---------------------------------------------------------------- -- class TapOutput ---------------------------------------------------------------- local TapOutput = { __class__ = 'TapOutput' } -- class local TapOutput_MT = { __index = TapOutput } -- metatable -- For a good reference for TAP format, check: http://testanything.org/tap-specification.html function TapOutput:new() return setmetatable( { verbosity = M.VERBOSITY_LOW }, TapOutput_MT) end function TapOutput:startSuite() print("1.."..self.result.testCount) print('# Started on '..self.result.startDate) end function TapOutput:startClass(className) if className ~= '[TestFunctions]' then print('# Starting class: '..className) end end function TapOutput:startTest(testName) end function TapOutput:addFailure( node ) io.stdout:write("not ok ", self.result.currentTestNumber, "\t", node.testName, "\n") if self.verbosity > M.VERBOSITY_LOW then print( prefixString( ' ', node.msg ) ) end if self.verbosity > M.VERBOSITY_DEFAULT then print( prefixString( ' ', node.stackTrace ) ) end end TapOutput.addError = TapOutput.addFailure function TapOutput:endTest( node ) if node:isPassed() then io.stdout:write("ok ", self.result.currentTestNumber, "\t", node.testName, "\n") end end function TapOutput:endClass() end function TapOutput:endSuite() print( '# '..M.LuaUnit.statusLine( self.result ) ) return self.result.notPassedCount end -- class TapOutput end ---------------------------------------------------------------- -- class JUnitOutput ---------------------------------------------------------------- -- See directory junitxml for more information about the junit format local JUnitOutput = { __class__ = 'JUnitOutput' } -- class local JUnitOutput_MT = { __index = JUnitOutput } -- metatable function JUnitOutput:new() return setmetatable( { testList = {}, verbosity = M.VERBOSITY_LOW }, JUnitOutput_MT) end function JUnitOutput:startSuite() -- open xml file early to deal with errors if self.fname == nil then error('With Junit, an output filename must be supplied with --name!') end if string.sub(self.fname,-4) ~= '.xml' then self.fname = self.fname..'.xml' end self.fd = io.open(self.fname, "w") if self.fd == nil then error("Could not open file for writing: "..self.fname) end print('# XML output to '..self.fname) print('# Started on '..self.result.startDate) end function JUnitOutput:startClass(className) if className ~= '[TestFunctions]' then print('# Starting class: '..className) end end function JUnitOutput:startTest(testName) print('# Starting test: '..testName) end function JUnitOutput:addFailure( node ) print('# Failure: ' .. node.msg) -- print('# ' .. node.stackTrace) end function JUnitOutput:addError( node ) print('# Error: ' .. node.msg) -- print('# ' .. node.stackTrace) end function JUnitOutput:endTest( node ) end function JUnitOutput:endClass() end function JUnitOutput:endSuite() print( '# '..M.LuaUnit.statusLine(self.result)) -- XML file writing self.fd:write('\n') self.fd:write('\n') self.fd:write(string.format( ' \n', self.result.runCount, self.result.startIsodate, self.result.duration, self.result.errorCount, self.result.failureCount )) self.fd:write(" \n") self.fd:write(string.format(' \n', _VERSION ) ) self.fd:write(string.format(' \n', M.VERSION) ) -- XXX please include system name and version if possible self.fd:write(" \n") for i,node in ipairs(self.result.tests) do self.fd:write(string.format(' \n', node.className, node.testName, node.duration ) ) if node:isNotPassed() then self.fd:write(node:statusXML()) end self.fd:write(' \n') end -- Next two lines are needed to validate junit ANT xsd, but really not useful in general: self.fd:write(' \n') self.fd:write(' \n') self.fd:write(' \n') self.fd:write('\n') self.fd:close() return self.result.notPassedCount end -- class TapOutput end ---------------------------------------------------------------- -- class TextOutput ---------------------------------------------------------------- --[[ -- Python Non verbose: For each test: . or F or E If some failed tests: ============== ERROR / FAILURE: TestName (testfile.testclass) --------- Stack trace then -------------- then "Ran x tests in 0.000s" then OK or FAILED (failures=1, error=1) -- Python Verbose: testname (filename.classname) ... ok testname (filename.classname) ... FAIL testname (filename.classname) ... ERROR then -------------- then "Ran x tests in 0.000s" then OK or FAILED (failures=1, error=1) -- Ruby: Started . Finished in 0.002695 seconds. 1 tests, 2 assertions, 0 failures, 0 errors -- Ruby: >> ruby tc_simple_number2.rb Loaded suite tc_simple_number2 Started F.. Finished in 0.038617 seconds. 1) Failure: test_failure(TestSimpleNumber) [tc_simple_number2.rb:16]: Adding doesn't work. <3> expected but was <4>. 3 tests, 4 assertions, 1 failures, 0 errors -- Java Junit .......F. Time: 0,003 There was 1 failure: 1) testCapacity(junit.samples.VectorTest)junit.framework.AssertionFailedError at junit.samples.VectorTest.testCapacity(VectorTest.java:87) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) FAILURES!!! Tests run: 8, Failures: 1, Errors: 0 -- Maven # mvn test ------------------------------------------------------- T E S T S ------------------------------------------------------- Running math.AdditionTest Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.03 sec <<< FAILURE! Results : Failed tests: testLireSymbole(math.AdditionTest) Tests run: 2, Failures: 1, Errors: 0, Skipped: 0 -- LuaUnit ---- non verbose * display . or F or E when running tests ---- verbose * display test name + ok/fail ---- * blank line * number) ERROR or FAILURE: TestName Stack trace * blank line * number) ERROR or FAILURE: TestName Stack trace then -------------- then "Ran x tests in 0.000s (%d not selected, %d skipped)" then OK or FAILED (failures=1, error=1) ]] local TextOutput = { __class__ = 'TextOutput' } -- class local TextOutput_MT = { __index = TextOutput } -- metatable function TextOutput:new() return setmetatable( { errorList = {}, verbosity = M.VERBOSITY_DEFAULT }, TextOutput_MT ) end function TextOutput:startSuite() if self.verbosity > M.VERBOSITY_DEFAULT then print( 'Started on '.. self.result.startDate ) end end function TextOutput:startClass(className) -- display nothing when starting a new class end function TextOutput:startTest(testName) if self.verbosity > M.VERBOSITY_DEFAULT then io.stdout:write( " ", self.result.currentNode.testName, " ... " ) end end function TextOutput:addFailure( node ) -- nothing end function TextOutput:addError( node ) -- nothing end function TextOutput:endTest( node ) if node:isPassed() then if self.verbosity > M.VERBOSITY_DEFAULT then io.stdout:write("Ok\n") else io.stdout:write(".") end else if self.verbosity > M.VERBOSITY_DEFAULT then print( node.status ) print( node.msg ) --[[ -- find out when to do this: if self.verbosity > M.VERBOSITY_DEFAULT then print( node.stackTrace ) end ]] else -- write only the first character of status io.stdout:write(string.sub(node.status, 1, 1)) end end end function TextOutput:endClass() -- nothing end function TextOutput:displayOneFailedTest( index, failure ) print(index..") "..failure.testName ) print( failure.msg ) print( failure.stackTrace ) print() end function TextOutput:displayFailedTests() if self.result.notPassedCount == 0 then return end print("Failed tests:") print("-------------") for i,v in ipairs(self.result.notPassed) do self:displayOneFailedTest( i, v ) end end function TextOutput:endSuite() if self.verbosity > M.VERBOSITY_DEFAULT then print("=========================================================") else print() end self:displayFailedTests() print( M.LuaUnit.statusLine( self.result ) ) local ignoredString = "" if self.result.notPassedCount == 0 then print('OK') end end -- class TextOutput end ---------------------------------------------------------------- -- class NilOutput ---------------------------------------------------------------- local function nopCallable() --print(42) return nopCallable end local NilOutput = { __class__ = 'NilOuptut' } -- class local NilOutput_MT = { __index = nopCallable } -- metatable function NilOutput:new() return setmetatable( { __class__ = 'NilOutput' }, NilOutput_MT ) end ---------------------------------------------------------------- -- -- class LuaUnit -- ---------------------------------------------------------------- M.LuaUnit = { outputType = TextOutput, verbosity = M.VERBOSITY_DEFAULT, __class__ = 'LuaUnit' } local LuaUnit_MT = { __index = M.LuaUnit } if EXPORT_ASSERT_TO_GLOBALS then LuaUnit = M.LuaUnit end function M.LuaUnit:new() return setmetatable( {}, LuaUnit_MT ) end -----------------[[ Utility methods ]]--------------------- function M.LuaUnit.asFunction(aObject) -- return "aObject" if it is a function, and nil otherwise if 'function' == type(aObject) then return aObject end end function M.LuaUnit.isClassMethod(aName) -- return true if aName contains a class + a method name in the form class:method return string.find(aName, '.', nil, true) ~= nil end function M.LuaUnit.splitClassMethod(someName) -- return a pair className, methodName for a name in the form class:method -- return nil if not a class + method name -- name is class + method local hasMethod, methodName, className hasMethod = string.find(someName, '.', nil, true ) if not hasMethod then return nil end methodName = string.sub(someName, hasMethod+1) className = string.sub(someName,1,hasMethod-1) return className, methodName end function M.LuaUnit.isMethodTestName( s ) -- return true is the name matches the name of a test method -- default rule is that is starts with 'Test' or with 'test' return string.sub(s, 1, 4):lower() == 'test' end function M.LuaUnit.isTestName( s ) -- return true is the name matches the name of a test -- default rule is that is starts with 'Test' or with 'test' return string.sub(s, 1, 4):lower() == 'test' end function M.LuaUnit.collectTests() -- return a list of all test names in the global namespace -- that match LuaUnit.isTestName local testNames = {} for k, v in pairs(_G) do if M.LuaUnit.isTestName( k ) then table.insert( testNames , k ) end end table.sort( testNames ) return testNames end function M.LuaUnit.parseCmdLine( cmdLine ) -- parse the command line -- Supported command line parameters: -- --verbose, -v: increase verbosity -- --quiet, -q: silence output -- --error, -e: treat errors as fatal (quit program) -- --output, -o, + name: select output type -- --pattern, -p, + pattern: run test matching pattern, may be repeated -- --name, -n, + fname: name of output file for junit, default to stdout -- [testnames, ...]: run selected test names -- -- Returns a table with the following fields: -- verbosity: nil, M.VERBOSITY_DEFAULT, M.VERBOSITY_QUIET, M.VERBOSITY_VERBOSE -- output: nil, 'tap', 'junit', 'text', 'nil' -- testNames: nil or a list of test names to run -- pattern: nil or a list of patterns local result = {} local state = nil local SET_OUTPUT = 1 local SET_PATTERN = 2 local SET_FNAME = 3 if cmdLine == nil then return result end local function parseOption( option ) if option == '--help' or option == '-h' then result['help'] = true return elseif option == '--version' then result['version'] = true return elseif option == '--verbose' or option == '-v' then result['verbosity'] = M.VERBOSITY_VERBOSE return elseif option == '--quiet' or option == '-q' then result['verbosity'] = M.VERBOSITY_QUIET return elseif option == '--error' or option == '-e' then result['quitOnError'] = true return elseif option == '--failure' or option == '-f' then result['quitOnFailure'] = true return elseif option == '--output' or option == '-o' then state = SET_OUTPUT return state elseif option == '--name' or option == '-n' then state = SET_FNAME return state elseif option == '--pattern' or option == '-p' then state = SET_PATTERN return state end error('Unknown option: '..option,3) end local function setArg( cmdArg, state ) if state == SET_OUTPUT then result['output'] = cmdArg return elseif state == SET_FNAME then result['fname'] = cmdArg return elseif state == SET_PATTERN then if result['pattern'] then table.insert( result['pattern'], cmdArg ) else result['pattern'] = { cmdArg } end return end error('Unknown parse state: '.. state) end for i, cmdArg in ipairs(cmdLine) do if state ~= nil then setArg( cmdArg, state, result ) state = nil else if cmdArg:sub(1,1) == '-' then state = parseOption( cmdArg ) else if result['testNames'] then table.insert( result['testNames'], cmdArg ) else result['testNames'] = { cmdArg } end end end end if result['help'] then M.LuaUnit.help() end if result['version'] then M.LuaUnit.version() end if state ~= nil then error('Missing argument after '..cmdLine[ #cmdLine ],2 ) end return result end function M.LuaUnit.help() print(M.USAGE) os.exit(0) end function M.LuaUnit.version() print('LuaUnit v'..M.VERSION..' by Philippe Fremy ') os.exit(0) end function M.LuaUnit.patternInclude( patternFilter, expr ) -- check if any of patternFilter is contained in expr. If so, return true. -- return false if None of the patterns are contained in expr -- if patternFilter is nil, return true (no filtering) if patternFilter == nil then return true end for i,pattern in ipairs(patternFilter) do if string.find(expr, pattern) then return true end end return false end ---------------------------------------------------------------- -- class NodeStatus ---------------------------------------------------------------- local NodeStatus = { __class__ = 'NodeStatus' } -- class local NodeStatus_MT = { __index = NodeStatus } -- metatable M.NodeStatus = NodeStatus -- values of status NodeStatus.PASS = 'PASS' NodeStatus.FAIL = 'FAIL' NodeStatus.ERROR = 'ERROR' function NodeStatus:new( number, testName, className ) local t = { number = number, testName = testName, className = className } setmetatable( t, NodeStatus_MT ) t:pass() return t end function NodeStatus:pass() self.status = self.PASS -- useless but we know it's the field we want to use self.msg = nil self.stackTrace = nil end function NodeStatus:fail(msg, stackTrace) self.status = self.FAIL self.msg = msg self.stackTrace = stackTrace end function NodeStatus:error(msg, stackTrace) self.status = self.ERROR self.msg = msg self.stackTrace = stackTrace end function NodeStatus:isPassed() return self.status == NodeStatus.PASS end function NodeStatus:isNotPassed() -- print('hasFailure: '..prettystr(self)) return self.status ~= NodeStatus.PASS end function NodeStatus:isFailure() return self.status == NodeStatus.FAIL end function NodeStatus:isError() return self.status == NodeStatus.ERROR end function NodeStatus:statusXML() if self:isError() then return table.concat( {' \n', ' \n'}) elseif self:isFailure() then return table.concat( {' \n', ' \n'}) end return ' \n' -- (not XSD-compliant! normally shouldn't get here) end --------------[[ Output methods ]]------------------------- function M.LuaUnit.statusLine(result) -- return status line string according to results local s = string.format('Ran %d tests in %0.3f seconds, %d successes', result.runCount, result.duration, result.passedCount ) if result.notPassedCount > 0 then if result.failureCount > 0 then s = s..string.format(', %d failures', result.failureCount ) end if result.errorCount > 0 then s = s..string.format(', %d errors', result.errorCount ) end else s = s..', 0 failures' end if result.nonSelectedCount > 0 then s = s..string.format(", %d non-selected", result.nonSelectedCount ) end return s end function M.LuaUnit:startSuite(testCount, nonSelectedCount) self.result = {} self.result.testCount = testCount self.result.nonSelectedCount = nonSelectedCount self.result.passedCount = 0 self.result.runCount = 0 self.result.currentTestNumber = 0 self.result.currentClassName = "" self.result.currentNode = nil self.result.suiteStarted = true self.result.startTime = os.clock() self.result.startDate = os.date(os.getenv('LUAUNIT_DATEFMT')) self.result.startIsodate = os.date('%Y-%m-%dT%H:%M:%S') self.result.patternFilter = self.patternFilter self.result.tests = {} self.result.failures = {} self.result.errors = {} self.result.notPassed = {} self.outputType = self.outputType or TextOutput self.output = self.outputType:new() self.output.runner = self self.output.result = self.result self.output.verbosity = self.verbosity self.output.fname = self.fname self.output:startSuite() end function M.LuaUnit:startClass( className ) self.result.currentClassName = className self.output:startClass( className ) end function M.LuaUnit:startTest( testName ) self.result.currentTestNumber = self.result.currentTestNumber + 1 self.result.runCount = self.result.runCount + 1 self.result.currentNode = NodeStatus:new( self.result.currentTestNumber, testName, self.result.currentClassName ) self.result.currentNode.startTime = os.clock() table.insert( self.result.tests, self.result.currentNode ) self.output:startTest( testName ) end function M.LuaUnit:addStatus( err ) -- "err" is expected to be a table / result from protectedCall() if err.status == NodeStatus.PASS then return end local node = self.result.currentNode --[[ As a first approach, we will report only one error or one failure for one test. However, we can have the case where the test is in failure, and the teardown is in error. In such case, it's a good idea to report both a failure and an error in the test suite. This is what Python unittest does for example. However, it mixes up counts so need to be handled carefully: for example, there could be more (failures + errors) count that tests. What happens to the current node ? We will do this more intelligent version later. ]] -- if the node is already in failure/error, just don't report the new error (see above) if node.status ~= NodeStatus.PASS then return end table.insert( self.result.notPassed, node ) if err.status == NodeStatus.FAIL then node:fail( err.msg, err.trace ) table.insert( self.result.failures, node ) self.output:addFailure( node ) elseif err.status == NodeStatus.ERROR then node:error( err.msg, err.trace ) table.insert( self.result.errors, node ) self.output:addError( node ) end end function M.LuaUnit:endTest() local node = self.result.currentNode -- print( 'endTest() '..prettystr(node)) -- print( 'endTest() '..prettystr(node:isNotPassed())) node.duration = os.clock() - node.startTime node.startTime = nil self.output:endTest( node ) if node:isPassed() then self.result.passedCount = self.result.passedCount + 1 elseif node:isError() then if self.quitOnError or self.quitOnFailure then -- Runtime error - abort test execution as requested by -- "--error" option. This is done by setting a special -- flag that gets handled in runSuiteByInstances(). print("\nERROR during LuaUnit test execution:\n" .. node.msg) self.result.aborted = true end elseif node:isFailure() then if self.quitOnFailure then -- Failure - abort test execution as requested by -- "--failure" option. This is done by setting a special -- flag that gets handled in runSuiteByInstances(). print("\nFailure during LuaUnit test execution:\n" .. node.msg) self.result.aborted = true end end self.result.currentNode = nil end function M.LuaUnit:endClass() self.output:endClass() end function M.LuaUnit:endSuite() if self.result.suiteStarted == false then error('LuaUnit:endSuite() -- suite was already ended' ) end self.result.duration = os.clock()-self.result.startTime self.result.suiteStarted = false -- Expose test counts for outputter's endSuite(). This could be managed -- internally instead, but unit tests (and existing use cases) might -- rely on these fields being present. self.result.notPassedCount = #self.result.notPassed self.result.failureCount = #self.result.failures self.result.errorCount = #self.result.errors self.output:endSuite() end function M.LuaUnit:setOutputType(outputType) -- default to text -- tap produces results according to TAP format if outputType:upper() == "NIL" then self.outputType = NilOutput return end if outputType:upper() == "TAP" then self.outputType = TapOutput return end if outputType:upper() == "JUNIT" then self.outputType = JUnitOutput return end if outputType:upper() == "TEXT" then self.outputType = TextOutput return end error( 'No such format: '..outputType,2) end --------------[[ Runner ]]----------------- function M.LuaUnit:protectedCall(classInstance, methodInstance, prettyFuncName) -- if classInstance is nil, this is just a function call -- else, it's method of a class being called. local function err_handler(e) -- transform error into a table, adding the traceback information return { status = NodeStatus.ERROR, msg = e, trace = string.sub(debug.traceback("", 3), 2) } end local ok, err if classInstance then -- stupid Lua < 5.2 does not allow xpcall with arguments so let's use a workaround ok, err = xpcall( function () methodInstance(classInstance) end, err_handler ) else ok, err = xpcall( function () methodInstance() end, err_handler ) end if ok then return {status = NodeStatus.PASS} end -- determine if the error was a failed test: -- We do this by stripping the failure prefix from the error message, -- while keeping track of the gsub() count. A non-zero value -> failure local failed err.msg, failed = err.msg:gsub(M.FAILURE_PREFIX, "", 1) if failed > 0 then err.status = NodeStatus.FAIL end -- reformat / improve the stack trace if prettyFuncName then -- we do have the real method name err.trace = err.trace:gsub("in (%a+) 'methodInstance'", "in %1 '"..prettyFuncName.."'") end if STRIP_LUAUNIT_FROM_STACKTRACE then err.trace = stripLuaunitTrace(err.trace) end return err -- return the error "object" (table) end function M.LuaUnit:execOneFunction(className, methodName, classInstance, methodInstance) -- When executing a test function, className and classInstance must be nil -- When executing a class method, all parameters must be set if type(methodInstance) ~= 'function' then error( tostring(methodName)..' must be a function, not '..type(methodInstance)) end local prettyFuncName if className == nil then className = '[TestFunctions]' prettyFuncName = methodName else prettyFuncName = className..'.'..methodName end if self.lastClassName ~= className then if self.lastClassName ~= nil then self:endClass() end self:startClass( className ) self.lastClassName = className end self:startTest(prettyFuncName) -- run setUp first (if any) if classInstance then local func = self.asFunction( classInstance.setUp ) or self.asFunction( classInstance.Setup ) or self.asFunction( classInstance.setup ) or self.asFunction( classInstance.SetUp ) if func then self:addStatus(self:protectedCall(classInstance, func, className..'.setUp')) end end -- run testMethod() if self.result.currentNode:isPassed() then self:addStatus(self:protectedCall(classInstance, methodInstance, prettyFuncName)) end -- lastly, run tearDown (if any) if classInstance then local func = self.asFunction( classInstance.tearDown ) or self.asFunction( classInstance.TearDown ) or self.asFunction( classInstance.teardown ) or self.asFunction( classInstance.Teardown ) if func then self:addStatus(self:protectedCall(classInstance, func, className..'.tearDown')) end end self:endTest() end function M.LuaUnit.expandOneClass( result, className, classInstance ) -- add all test methods of classInstance to result for methodName, methodInstance in sortedPairs(classInstance) do if M.LuaUnit.asFunction(methodInstance) and M.LuaUnit.isMethodTestName( methodName ) then table.insert( result, { className..'.'..methodName, classInstance } ) end end end function M.LuaUnit.expandClasses( listOfNameAndInst ) -- expand all classes (provided as {className, classInstance}) to a list of {className.methodName, classInstance} -- functions and methods remain untouched local result = {} for i,v in ipairs( listOfNameAndInst ) do local name, instance = v[1], v[2] if M.LuaUnit.asFunction(instance) then table.insert( result, { name, instance } ) else if type(instance) ~= 'table' then error( 'Instance must be a table or a function, not a '..type(instance)..', value '..prettystr(instance)) end if M.LuaUnit.isClassMethod( name ) then local className, methodName = M.LuaUnit.splitClassMethod( name ) local methodInstance = instance[methodName] if methodInstance == nil then error( "Could not find method in class "..tostring(className).." for method "..tostring(methodName) ) end table.insert( result, { name, instance } ) else M.LuaUnit.expandOneClass( result, name, instance ) end end end return result end function M.LuaUnit.applyPatternFilter( patternFilter, listOfNameAndInst ) local included, excluded = {}, {} for i, v in ipairs( listOfNameAndInst ) do -- local name, instance = v[1], v[2] if M.LuaUnit.patternInclude( patternFilter, v[1] ) then table.insert( included, v ) else table.insert( excluded, v ) end end return included, excluded end function M.LuaUnit:runSuiteByInstances( listOfNameAndInst ) -- Run an explicit list of tests. All test instances and names must be supplied. -- each test must be one of: -- * { function name, function instance } -- * { class name, class instance } -- * { class.method name, class instance } local expandedList, filteredList, filteredOutList, className, methodName, methodInstance expandedList = self.expandClasses( listOfNameAndInst ) filteredList, filteredOutList = self.applyPatternFilter( self.patternFilter, expandedList ) self:startSuite( #filteredList, #filteredOutList ) for i,v in ipairs( filteredList ) do local name, instance = v[1], v[2] if M.LuaUnit.asFunction(instance) then self:execOneFunction( nil, name, nil, instance ) else if type(instance) ~= 'table' then error( 'Instance must be a table or a function, not a '..type(instance)..', value '..prettystr(instance)) else assert( M.LuaUnit.isClassMethod( name ) ) className, methodName = M.LuaUnit.splitClassMethod( name ) methodInstance = instance[methodName] if methodInstance == nil then error( "Could not find method in class "..tostring(className).." for method "..tostring(methodName) ) end self:execOneFunction( className, methodName, instance, methodInstance ) end end if self.result.aborted then break end -- "--error" or "--failure" option triggered end if self.lastClassName ~= nil then self:endClass() end self:endSuite() if self.result.aborted then print("LuaUnit ABORTED (as requested by --error or --failure option)") os.exit(-2) end end function M.LuaUnit:runSuiteByNames( listOfName ) -- Run an explicit list of test names local className, methodName, instanceName, instance, methodInstance local listOfNameAndInst = {} for i,name in ipairs( listOfName ) do if M.LuaUnit.isClassMethod( name ) then className, methodName = M.LuaUnit.splitClassMethod( name ) instanceName = className instance = _G[instanceName] if instance == nil then error( "No such name in global space: "..instanceName ) end if type(instance) ~= 'table' then error( 'Instance of '..instanceName..' must be a table, not '..type(instance)) end methodInstance = instance[methodName] if methodInstance == nil then error( "Could not find method in class "..tostring(className).." for method "..tostring(methodName) ) end else -- for functions and classes instanceName = name instance = _G[instanceName] end if instance == nil then error( "No such name in global space: "..instanceName ) end if (type(instance) ~= 'table' and type(instance) ~= 'function') then error( 'Name must match a function or a table: '..instanceName ) end table.insert( listOfNameAndInst, { name, instance } ) end self:runSuiteByInstances( listOfNameAndInst ) end function M.LuaUnit.run(...) -- Run some specific test classes. -- If no arguments are passed, run the class names specified on the -- command line. If no class name is specified on the command line -- run all classes whose name starts with 'Test' -- -- If arguments are passed, they must be strings of the class names -- that you want to run or generic command line arguments (-o, -p, -v, ...) local runner = M.LuaUnit.new() return runner:runSuite(...) end function M.LuaUnit:runSuite( ... ) local args = {...} if type(args[1]) == 'table' and args[1].__class__ == 'LuaUnit' then -- run was called with the syntax M.LuaUnit:runSuite() -- we support both M.LuaUnit.run() and M.LuaUnit:run() -- strip out the first argument table.remove(args,1) end if #args == 0 then args = cmdline_argv end local no_error, val = pcall( M.LuaUnit.parseCmdLine, args ) if not no_error then print(val) -- error message print() print(M.USAGE) os.exit(-1) end local options = val -- We expect these option fields to be either `nil` or contain -- valid values, so it's safe to always copy them directly. self.verbosity = options.verbosity self.quitOnError = options.quitOnError self.quitOnFailure = options.quitOnFailure self.fname = options.fname self.patternFilter = options.pattern if options.output and options.output:lower() == 'junit' and options.fname == nil then print('With junit output, a filename must be supplied with -n or --name') os.exit(-1) end if options.output then no_error, val = pcall(self.setOutputType, self, options.output) if not no_error then print(val) -- error message print() print(M.USAGE) os.exit(-1) end end self:runSuiteByNames( options.testNames or M.LuaUnit.collectTests() ) return self.result.notPassedCount end -- class LuaUnit -- For compatbility with LuaUnit v2 M.run = M.LuaUnit.run M.Run = M.LuaUnit.run function M:setVerbosity( verbosity ) M.LuaUnit.verbosity = verbosity end M.set_verbosity = M.setVerbosity M.SetVerbosity = M.setVerbosity return M bpfcc-0.2.0+git0.02884a026/tests/lua/spec/000077500000000000000000000000001305314114400173535ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tests/lua/spec/README.md000066400000000000000000000002121305314114400206250ustar00rootroot00000000000000# Unit test specs This directory contains spec files for Lua BPF in [Busted] unit test format. [Busted]: http://olivinelabs.com/busted/ bpfcc-0.2.0+git0.02884a026/tests/lua/spec/compile_spec.lua000066400000000000000000000010361305314114400225200ustar00rootroot00000000000000describe('compile', function() local ffi = require('ffi') local bpf = require('bpf') it('can compile socket filter', function() -- Create mock BPF map local mock_map = { max_entries = 16, key_type = ffi.typeof('uint64_t [1]'), val_type = ffi.typeof('uint64_t [1]'), fd = 1, __map = true, } -- Compile small code example local code = bpf(function () local proto = pkt.ip.proto xadd(mock_map[proto], 1) end) assert.truthy(code) assert.same(type(code), 'table') assert.same(code.pc, 15) end) end) bpfcc-0.2.0+git0.02884a026/tests/lua/spec/decoder_spec.lua000066400000000000000000000016161305314114400225010ustar00rootroot00000000000000describe('decoder', function() -- Decode simple function local bytecode = require('bpf.ljbytecode') local f = function (x) return x + 1 end it('should decode functions', function() -- Make sure it calls LJ decoder local bc = bytecode.decoder(f) assert.truthy(bc) -- Decode bytecode bytecode to instructions local jutil = require("jit.util") spy.on(jutil, 'funcbc') local pc, op = bc() -- Check bytecode for sanity (starts with ADDVN(x, 1)) assert.equal(pc, 1) assert.equal(op, 'ADDVN') for pc, op in bc do assert.truthy(pc and op) end assert.spy(jutil.funcbc).was.called() end) it('should fail on bad input', function() assert.has_error(function() bytecode.decoder(nil)() end) assert.has_error(function() bytecode.decoder(5)() end) assert.has_error(function() bytecode.decoder('test')() end) end) it('should dump bytecode', function() bytecode.dump(f) end) end) bpfcc-0.2.0+git0.02884a026/tests/lua/spec/elf_spec.lua000066400000000000000000000011761305314114400216430ustar00rootroot00000000000000describe('elf reader', function() local ok, elf = pcall(require, 'bpf.elf') if not ok then return end it('should handle C library', function() -- Open libc local sh = elf.open('/bin/sh') assert.truthy(sh) -- Find load address local base = sh:loadaddr() assert.truthy(base) -- Find something from ISO C local malloc_addr = sh:resolve('malloc') assert.truthy(malloc_addr) -- Find something that doesn't exist local bad_addr = sh:resolve('thisnotexists') assert.falsy(bad_addr) end) it('should fail on bad input', function() assert.falsy(elf.open(nil)) assert.falsy(elf.open('/tmp'):loadaddr()) end) end) bpfcc-0.2.0+git0.02884a026/tests/lua/test_clang.lua000066400000000000000000000200771305314114400212550ustar00rootroot00000000000000local suite = require("test_helper") local TestClang = {} function TestClang:test_probe_read1() local text = [[ #include #include int count_sched(struct pt_regs *ctx, struct task_struct *prev) { pid_t p = prev->pid; return (p != -1); } ]] local b = BPF:new{text=text, debug=0} local fn = b:load_func("count_sched", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_probe_read2() local text = [[ #include #include int count_foo(struct pt_regs *ctx, unsigned long a, unsigned long b) { return (a != b); } ]] local b = BPF:new{text=text, debug=0} local fn = b:load_func("count_foo", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_probe_read_keys() local text = [[ #include #include BPF_HASH(start, struct request *); int do_request(struct pt_regs *ctx, struct request *req) { u64 ts = bpf_ktime_get_ns(); start.update(&req, &ts); return 0; } int do_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp = start.lookup(&req); if (tsp != 0) { start.delete(&req); } return 0; } ]] local b = BPF:new{text=text, debug=0} local fns = b:load_funcs('BPF_PROG_TYPE_KPROBE') end function TestClang:test_sscanf() local text = [[ BPF_TABLE("hash", int, struct { u64 a; u64 b; u32 c:18; u32 d:14; struct { u32 a; u32 b; } s; }, stats, 10); int foo(void *ctx) { return 0; } ]] local b = BPF:new{text=text, debug=0} local fn = b:load_func("foo", 'BPF_PROG_TYPE_KPROBE') local t = b:get_table("stats") local s1 = t:key_sprintf(2) assert_equals(s1, "0x2") local s2 = t:leaf_sprintf({{2, 3, 4, 1, {5, 6}}}) local l = t:leaf_scanf(s2) assert_equals(tonumber(l.a), 2) assert_equals(tonumber(l.b), 3) assert_equals(tonumber(l.c), 4) assert_equals(tonumber(l.d), 1) assert_equals(tonumber(l.s.a), 5) assert_equals(tonumber(l.s.b), 6) end function TestClang:test_sscanf_array() local text = [[ BPF_TABLE("hash", int, struct { u32 a[3]; u32 b; }, stats, 10); ]] local b = BPF:new{text=text, debug=0} local t = b:get_table("stats") local s1 = t:key_sprintf(2) assert_equals(s1, "0x2") local s2 = t:leaf_sprintf({{{1, 2, 3}, 4}}) assert_equals(s2, "{ [ 0x1 0x2 0x3 ] 0x4 }") local l = t:leaf_scanf(s2) assert_equals(l.a[0], 1) assert_equals(l.a[1], 2) assert_equals(l.a[2], 3) assert_equals(l.b, 4) end function TestClang:test_iosnoop() local text = [[ #include #include struct key_t { struct request *req; }; BPF_TABLE("hash", struct key_t, u64, start, 1024); int do_request(struct pt_regs *ctx, struct request *req) { struct key_t key = {}; bpf_trace_printk("traced start %d\\n", req->__data_len); return 0; } ]] local b = BPF:new{text=text, debug=0} local fn = b:load_func("do_request", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_blk_start_request() local text = [[ #include #include int do_request(struct pt_regs *ctx, int req) { bpf_trace_printk("req ptr: 0x%x\n", req); return 0; } ]] local b = BPF:new{text=text, debug=0} local fn = b:load_func("do_request", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_bpf_hash() local text = [[ BPF_HASH(table1); BPF_HASH(table2, u32); BPF_HASH(table3, u32, int); ]] local b = BPF:new{text=text, debug=0} end function TestClang:test_consecutive_probe_read() local text = [[ #include #include BPF_HASH(table1, struct super_block *); int trace_entry(struct pt_regs *ctx, struct file *file) { if (!file) return 0; struct vfsmount *mnt = file->f_path.mnt; if (mnt) { struct super_block *k = mnt->mnt_sb; u64 zero = 0; table1.update(&k, &zero); k = mnt->mnt_sb; table1.update(&k, &zero); } return 0; } ]] local b = BPF:new{text=text, debug=0} local fn = b:load_func("trace_entry", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_nested_probe_read() local text = [[ #include int trace_entry(struct pt_regs *ctx, struct file *file) { if (!file) return 0; const char *name = file->f_path.dentry->d_name.name; bpf_trace_printk("%s\\n", name); return 0; } ]] local b = BPF:new{text=text, debug=0} local fn = b:load_func("trace_entry", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_char_array_probe() local b = BPF:new{text=[[#include int kprobe__blk_update_request(struct pt_regs *ctx, struct request *req) { bpf_trace_printk("%s\\n", req->rq_disk->disk_name); return 0; }]]} end function TestClang:test_probe_read_helper() local b = BPF:new{text=[[ #include static void print_file_name(struct file *file) { if (!file) return; const char *name = file->f_path.dentry->d_name.name; bpf_trace_printk("%s\\n", name); } static void print_file_name2(int unused, struct file *file) { print_file_name(file); } int trace_entry1(struct pt_regs *ctx, struct file *file) { print_file_name(file); return 0; } int trace_entry2(struct pt_regs *ctx, int unused, struct file *file) { print_file_name2(unused, file); return 0; } ]]} local fn1 = b:load_func("trace_entry1", 'BPF_PROG_TYPE_KPROBE') local fn2 = b:load_func("trace_entry2", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_probe_struct_assign() local b = BPF:new{text = [[ #include struct args_t { const char *filename; int flags; int mode; }; int kprobe__sys_open(struct pt_regs *ctx, const char *filename, int flags, int mode) { struct args_t args = {}; args.filename = filename; args.flags = flags; args.mode = mode; bpf_trace_printk("%s\\n", args.filename); return 0; }; ]]} end function TestClang:test_task_switch() local b = BPF:new{text=[[ #include #include struct key_t { u32 prev_pid; u32 curr_pid; }; BPF_TABLE("hash", struct key_t, u64, stats, 1024); int kprobe__finish_task_switch(struct pt_regs *ctx, struct task_struct *prev) { struct key_t key = {}; u64 zero = 0, *val; key.curr_pid = bpf_get_current_pid_tgid(); key.prev_pid = prev->pid; val = stats.lookup_or_init(&key, &zero); (*val)++; return 0; } ]]} end function TestClang:test_probe_simple_assign() local b = BPF:new{text=[[ #include #include struct leaf { size_t size; }; BPF_HASH(simple_map, u32, struct leaf); int kprobe____kmalloc(struct pt_regs *ctx, size_t size) { u32 pid = bpf_get_current_pid_tgid(); struct leaf* leaf = simple_map.lookup(&pid); if (leaf) leaf->size += size; return 0; }]]} end function TestClang:test_unop_probe_read() local text = [[ #include int trace_entry(struct pt_regs *ctx, struct request *req) { if (!(req->bio->bi_flags & 1)) return 1; if (((req->bio->bi_flags))) return 1; return 0; } ]] local b = BPF:new{text=text} local fn = b:load_func("trace_entry", 'BPF_PROG_TYPE_KPROBE') end function TestClang:test_complex_leaf_types() local text = [[ struct list; struct list { struct list *selfp; struct list *another_selfp; struct list *selfp_array[2]; }; struct empty { }; union emptyu { struct empty *em1; struct empty em2; struct empty em3; struct empty em4; }; BPF_TABLE("array", int, struct list, t1, 1); BPF_TABLE("array", int, struct list *, t2, 1); BPF_TABLE("array", int, union emptyu, t3, 1); ]] local b = BPF:new{text=text} local ffi = require("ffi") -- TODO: ptrs? assert_equals(ffi.sizeof(b:get_table("t3").c_leaf), 8) end function TestClang:test_cflags() local text = [[ #ifndef MYFLAG #error "MYFLAG not set as expected" #endif ]] local b = BPF:new{text=text, cflags={"-DMYFLAG"}} end function TestClang:test_exported_maps() local b1 = BPF{text=[[BPF_TABLE_PUBLIC("hash", int, int, table1, 10);]]} local b2 = BPF{text=[[BPF_TABLE("extern", int, int, table1, 10);]]} end function TestClang:test_syntax_error() assert_error_msg_contains( "failed to compile BPF module", BPF.new, BPF, {text=[[int failure(void *ctx) { if (); return 0; }]]}) end suite("TestClang", TestClang) bpfcc-0.2.0+git0.02884a026/tests/lua/test_dump.lua000066400000000000000000000004661305314114400211360ustar00rootroot00000000000000local suite = require("test_helper") local TestDump = {} function TestDump:test_dump_func() local raw = "\xb7\x00\x00\x00\x01\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00" local b = BPF:new{text=[[int entry(void) { return 1; }]]} assert_equals(b:dump_func("entry"), raw) end suite("TestDump", TestDump) bpfcc-0.2.0+git0.02884a026/tests/lua/test_helper.lua000066400000000000000000000010231305314114400214360ustar00rootroot00000000000000function setup_path() local str = require("debug").getinfo(2, "S").source:sub(2) local cwd = str:match("(.*/)") local bpf_path = cwd.."/../../src/lua/?.lua;" local test_path = cwd.."/?.lua;" package.path = bpf_path..test_path..package.path end setup_path() USE_EXPECTED_ACTUAL_IN_ASSERT_EQUALS = false EXPORT_ASSERT_TO_GLOBALS = true require("luaunit") rawset(_G, "BCC", require("bcc.init")) rawset(_G, "BPF", BCC.BPF) log.enabled = false return function (name, f) rawset(_G, name, f) os.exit(LuaUnit.run()) end bpfcc-0.2.0+git0.02884a026/tests/lua/test_standalone.sh000077500000000000000000000011611305314114400221460ustar00rootroot00000000000000#!/bin/bash # Copyright (c) GitHub, Inc. # Licensed under the Apache License, Version 2.0 (the "License") set -xe cd "src/lua" function fail { echo "test failed: $1" >&2 exit 1 } if [[ ! -x bcc-lua ]]; then echo "bcc-lua not built --- skipping" exit 0 fi if ldd bcc-lua | grep -q luajit; then fail "bcc-lua depends on libluajit" fi rm -f probe.lua echo "return function(BPF) print(\"Hello world\") end" > probe.lua PROBE="../../../examples/lua/offcputime.lua" if ! sudo ./bcc-lua "$PROBE" -d 1 >/dev/null 2>/dev/null; then fail "bcc-lua cannot run complex probes" fi rm -f libbcc.so probe.lua bpfcc-0.2.0+git0.02884a026/tests/lua/test_uprobes.lua000066400000000000000000000032111305314114400216370ustar00rootroot00000000000000local suite = require("test_helper") local ffi = require("ffi") local TestUprobes = {} ffi.cdef[[ int getpid(void); void malloc_stats(void); ]] function TestUprobes:test_simple_library() local text = [[ #include BPF_TABLE("array", int, u64, stats, 1); static void incr(int idx) { u64 *ptr = stats.lookup(&idx); if (ptr) ++(*ptr); } int count(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); if (pid == PID) incr(0); return 0; }]] local pid = tonumber(ffi.C.getpid()) local text = text:gsub("PID", tostring(pid)) local b = BPF:new{text=text} b:attach_uprobe{name="c", sym="malloc_stats", fn_name="count", pid=pid} b:attach_uprobe{name="c", sym="malloc_stats", fn_name="count", pid=pid, retprobe=true} assert_equals(BPF.num_open_uprobes(), 2) ffi.C.malloc_stats() local stats = b:get_table("stats") assert_equals(tonumber(stats:get(0)), 2) end function TestUprobes:test_simple_binary() local text = [[ #include BPF_TABLE("array", int, u64, stats, 1); static void incr(int idx) { u64 *ptr = stats.lookup(&idx); if (ptr) ++(*ptr); } int count(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); incr(0); return 0; }]] local b = BPF:new{text=text} b:attach_uprobe{name="/usr/bin/python", sym="main", fn_name="count"} b:attach_uprobe{name="/usr/bin/python", sym="main", fn_name="count", retprobe=true} os.spawn("/usr/bin/python -V") local stats = b:get_table("stats") assert_true(tonumber(stats:get(0)) >= 2) end function TestUprobes:teardown() BPF.cleanup() end suite("TestUprobes", TestUprobes) bpfcc-0.2.0+git0.02884a026/tests/python/000077500000000000000000000000001305314114400171615ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tests/python/CMakeLists.txt000066400000000000000000000112541305314114400217240ustar00rootroot00000000000000# Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") find_program(ARPING arping) if(ARPING STREQUAL "ARPING-NOTFOUND") message(WARNING "Recommended test program 'arping' not found") endif() find_program(NETPERF netperf) if(NETPERF STREQUAL "NETPERF-NOTFOUND") message(WARNING "Recommended test program 'netperf' not found") endif() find_program(IPERF iperf) if(IPERF STREQUAL "IPERF-NOTFOUND") message(WARNING "Recommended test program 'iperf' not found") endif() add_test(NAME py_test_stat1_b WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_stat1_b namespace ${CMAKE_CURRENT_SOURCE_DIR}/test_stat1.py test_stat1.b proto.b) add_test(NAME py_test_bpf_log WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_bpf_prog sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_bpf_log.py) add_test(NAME py_test_stat1_c WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_stat1_c namespace ${CMAKE_CURRENT_SOURCE_DIR}/test_stat1.py test_stat1.c) #add_test(NAME py_test_xlate1_b WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} # COMMAND ${TEST_WRAPPER} py_xlate1_b namespace ${CMAKE_CURRENT_SOURCE_DIR}/test_xlate1.py test_xlate1.b proto.b) add_test(NAME py_test_xlate1_c WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_xlate1_c namespace ${CMAKE_CURRENT_SOURCE_DIR}/test_xlate1.py test_xlate1.c) add_test(NAME py_test_call1 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_call1_c namespace ${CMAKE_CURRENT_SOURCE_DIR}/test_call1.py test_call1.c) add_test(NAME py_test_trace1 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_trace1 sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_trace1.py test_trace1.b kprobe.b) add_test(NAME py_test_trace2 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_trace2 sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_trace2.py) add_test(NAME py_test_trace3_c WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_trace3_c sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_trace3.py test_trace3.c) add_test(NAME py_test_trace4 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_trace4 sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_trace4.py) add_test(NAME py_test_probe_count WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_probe_count sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_probe_count.py) add_test(NAME py_test_debuginfo WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_debuginfo sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_debuginfo.py) add_test(NAME py_test_brb WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_brb_c sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_brb.py test_brb.c) add_test(NAME py_test_brb2 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_brb2_c sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_brb2.py test_brb2.c) add_test(NAME py_test_clang WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_clang sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_clang.py) add_test(NAME py_test_histogram WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_histogram sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_histogram.py) add_test(NAME py_test_callchain WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_callchain sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_callchain.py) add_test(NAME py_array WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_array sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_array.py) add_test(NAME py_uprobes WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_uprobes sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_uprobes.py) add_test(NAME py_test_stackid WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_stackid sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_stackid.py) add_test(NAME py_test_tracepoint WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_tracepoint sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_tracepoint.py) add_test(NAME py_test_perf_event WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_perf_event sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_perf_event.py) add_test(NAME py_test_utils WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_utils sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_utils.py) add_test(NAME py_test_percpu WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_test_percpu sudo ${CMAKE_CURRENT_SOURCE_DIR}/test_percpu.py) add_test(NAME py_test_dump_func WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ${TEST_WRAPPER} py_dump_func simple ${CMAKE_CURRENT_SOURCE_DIR}/test_dump_func.py) bpfcc-0.2.0+git0.02884a026/tests/python/dummy.c000066400000000000000000000004351305314114400204620ustar00rootroot00000000000000#include #include static __attribute__((noinline)) int some_function(int x, int y) { volatile int z = x + y; return z; } int main() { printf("%p\n", &some_function); fflush(stdout); printf("result = %d\n", some_function(42, 11)); sleep(1000); return 0; } bpfcc-0.2.0+git0.02884a026/tests/python/kprobe.b000066400000000000000000000005231305314114400206060ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #packed "false" struct pt_regs { u64 r15:64; u64 r14:64; u64 r13:64; u64 r12:64; u64 bp:64; u64 bx:64; u64 r11:64; u64 r10:64; u64 r9:64; u64 r8:64; u64 ax:64; u64 cx:64; u64 dx:64; u64 si:64; u64 di:64; }; bpfcc-0.2.0+git0.02884a026/tests/python/proto.b000066400000000000000000000036331305314114400204740ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #packed "true" struct ethernet { u64 dst:48; u64 src:48; u32 type:16; }; state ethernet { switch $ethernet.type { case 0x0800 { next proto::ip; }; case 0x8100 { next proto::dot1q; }; case * { goto EOP; }; } } struct dot1q { u32 pri:3; u32 cfi:1; u32 vlanid:12; u32 type:16; }; state dot1q { switch $dot1q.type { case 0x0800 { next proto::ip; }; case * { goto EOP; }; } } struct ip { u32 ver:4; u32 hlen:4; u32 tos:8; u32 tlen:16; u32 identification:16; u32 ffo_unused:1; u32 df:1; u32 mf:1; u32 foffset:13; u32 ttl:8; u32 nextp:8; u32 hchecksum:16; u32 src:32; u32 dst:32; }; state ip { switch $ip.nextp { case 6 { next proto::tcp; }; case 17 { next proto::udp; }; case 47 { next proto::gre; }; case * { goto EOP; }; } } struct udp { u32 sport:16; u32 dport:16; u32 length:16; u32 crc:16; }; state udp { switch $udp.dport { case 8472 { next proto::vxlan; }; case * { goto EOP; }; } } struct tcp { u16 src_port:16; u16 dst_port:16; u32 seq_num:32; u32 ack_num:32; u8 offset:4; u8 reserved:4; u8 flag_cwr:1; u8 flag_ece:1; u8 flag_urg:1; u8 flag_ack:1; u8 flag_psh:1; u8 flag_rst:1; u8 flag_syn:1; u8 flag_fin:1; u16 rcv_wnd:16; u16 cksum:16; u16 urg_ptr:16; }; state tcp { goto EOP; } struct vxlan { u32 rsv1:4; u32 iflag:1; u32 rsv2:3; u32 rsv3:24; u32 key:24; u32 rsv4:8; }; state vxlan { goto EOP; } struct gre { u32 cflag:1; u32 rflag:1; u32 kflag:1; u32 snflag:1; u32 srflag:1; u32 recurflag:3; u32 reserved:5; u32 vflag:3; u32 protocol:16; u32 key:32; }; state gre { switch $gre.protocol { case * { goto EOP; }; } } bpfcc-0.2.0+git0.02884a026/tests/python/simulation.py000077700000000000000000000000001305314114400311032../../examples/networking/simulation.pyustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tests/python/test_array.py000077500000000000000000000057341305314114400217240ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF import ctypes as ct import random import time import subprocess from bcc.utils import get_online_cpus from unittest import main, TestCase class TestArray(TestCase): def test_simple(self): b = BPF(text="""BPF_TABLE("array", int, u64, table1, 128);""") t1 = b["table1"] t1[ct.c_int(0)] = ct.c_ulonglong(100) t1[ct.c_int(127)] = ct.c_ulonglong(1000) for i, v in t1.items(): if i.value == 0: self.assertEqual(v.value, 100) if i.value == 127: self.assertEqual(v.value, 1000) self.assertEqual(len(t1), 128) def test_native_type(self): b = BPF(text="""BPF_TABLE("array", int, u64, table1, 128);""") t1 = b["table1"] t1[0] = ct.c_ulonglong(100) t1[-2] = ct.c_ulonglong(37) t1[127] = ct.c_ulonglong(1000) for i, v in t1.items(): if i.value == 0: self.assertEqual(v.value, 100) if i.value == 127: self.assertEqual(v.value, 1000) self.assertEqual(len(t1), 128) self.assertEqual(t1[-2].value, 37) self.assertEqual(t1[-1].value, t1[127].value) def test_perf_buffer(self): self.counter = 0 class Data(ct.Structure): _fields_ = [("ts", ct.c_ulonglong)] def cb(cpu, data, size): self.assertGreater(size, ct.sizeof(Data)) event = ct.cast(data, ct.POINTER(Data)).contents self.counter += 1 text = """ BPF_PERF_OUTPUT(events); int kprobe__sys_nanosleep(void *ctx) { struct { u64 ts; } data = {bpf_ktime_get_ns()}; events.perf_submit(ctx, &data, sizeof(data)); return 0; } """ b = BPF(text=text) b["events"].open_perf_buffer(cb) time.sleep(0.1) b.kprobe_poll() self.assertGreater(self.counter, 0) b.cleanup() def test_perf_buffer_for_each_cpu(self): self.events = [] class Data(ct.Structure): _fields_ = [("cpu", ct.c_ulonglong)] def cb(cpu, data, size): self.assertGreater(size, ct.sizeof(Data)) event = ct.cast(data, ct.POINTER(Data)).contents self.events.append(event) text = """ BPF_PERF_OUTPUT(events); int kprobe__sys_nanosleep(void *ctx) { struct { u64 cpu; } data = {bpf_get_smp_processor_id()}; events.perf_submit(ctx, &data, sizeof(data)); return 0; } """ b = BPF(text=text) b["events"].open_perf_buffer(cb) online_cpus = get_online_cpus() for cpu in online_cpus: subprocess.call(['taskset', '-c', str(cpu), 'sleep', '0.1']) b.kprobe_poll() b.cleanup() self.assertGreaterEqual(len(self.events), len(online_cpus), 'Received only {}/{} events'.format(len(self.events), len(online_cpus))) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_bpf_log.py000077500000000000000000000031231305314114400222040ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF from simulation import Simulation import sys import os import tempfile from unittest import main, TestCase error_msg = "R0 invalid mem access 'map_value_or_null'\n" text = """ #include #include BPF_TABLE("hash", int, int, t1, 10); int sim_port(struct __sk_buff *skb) { int x = 0, *y; """ repeat = """ y = t1.lookup(&x); if (!y) return 0; x = *y; """ end = """ y = t1.lookup(&x); x = *y; return 0; } """ for i in range(0,300): text += repeat text += end class TestBPFProgLoad(TestCase): def setUp(self): self.fp = tempfile.TemporaryFile() os.dup2(self.fp.fileno(), sys.stderr.fileno()) def tearDown(self): self.fp.close() def test_log_debug(self): b = BPF(text=text, debug=2) try: ingress = b.load_func("sim_port",BPF.SCHED_CLS) except Exception: self.fp.flush() self.fp.seek(0) self.assertEqual(error_msg in self.fp.read().decode(), True) def test_log_no_debug(self): b = BPF(text=text, debug=0) try: ingress = b.load_func("sim_port",BPF.SCHED_CLS) except Exception: self.fp.flush() self.fp.seek(0) self.assertEqual(error_msg in self.fp.read().decode(), True) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_brb.c000066400000000000000000000143201305314114400211310ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include #define _memcpy __builtin_memcpy // meta data passed between bpf programs typedef struct bpf_metadata { u32 prog_id; u32 rx_port_id; } bpf_metadata_t; typedef struct bpf_dest { u32 prog_id; u32 port_id; } bpf_dest_t; // use u64 to represent eth_addr. // maintain the structure though to indicate the semantics typedef struct eth_addr { u64 addr; } eth_addr_t; // Program table definitions for tail calls BPF_TABLE("prog", u32, u32, jump, 16); // physical endpoint manager (pem) tables which connects to boeht bridge 1 and bridge 2 // BPF_TABLE("array", u32, bpf_dest_t, pem_dest, 256); // BPF_TABLE("array", u32, u32, pem_port, 256); // BPF_TABLE("hash", u32, u32, pem_ifindex, 256); // <0, tx2vm_pkts> BPF_TABLE("array", u32, u32, pem_stats, 1); // bridge 1 (br1) tables // BPF_TABLE("array", u32, bpf_dest_t, br1_dest, 256); // BPF_TABLE("hash", eth_addr_t, u32, br1_mac, 256); // <0, rtr_ifindex> BPF_TABLE("array", u32, u32, br1_rtr, 1); // BPF_TABLE("hash", eth_addr_t, u32, br1_mac_ifindex, 1); // bridge 2 (br2) tables // BPF_TABLE("array", u32, bpf_dest_t, br2_dest, 256); // BPF_TABLE("hash", eth_addr_t, u32, br2_mac, 256); // <0, rtr_ifindex> BPF_TABLE("array", u32, u32, br2_rtr, 1); // BPF_TABLE("hash", eth_addr_t, u32, br2_mac_ifindex, 1); int pem(struct __sk_buff *skb) { bpf_metadata_t meta = {}; u32 ifindex; u32 *tx_port_id_p; u32 tx_port_id; u32 rx_port; u32 *ifindex_p; bpf_dest_t *dest_p; // pem does not look at packet data if (skb->tc_index == 0) { skb->tc_index = 1; skb->cb[0] = skb->cb[1] = 0; meta.prog_id = meta.rx_port_id = 0; } else { meta.prog_id = skb->cb[0]; meta.rx_port_id = skb->cb[1]; } if (!meta.prog_id) { /* from external */ ifindex = skb->ingress_ifindex; tx_port_id_p = pem_ifindex.lookup(&ifindex); if (tx_port_id_p) { tx_port_id = *tx_port_id_p; dest_p = pem_dest.lookup(&tx_port_id); if (dest_p) { skb->cb[0] = dest_p->prog_id; skb->cb[1] = dest_p->port_id; jump.call(skb, dest_p->prog_id); } } } else { /* from internal */ rx_port = meta.rx_port_id; ifindex_p = pem_port.lookup(&rx_port); if (ifindex_p) { #if 1 /* accumulate stats, may hurt performance slightly */ u32 index = 0; u32 *value = pem_stats.lookup(&index); if (value) lock_xadd(value, 1); #endif bpf_clone_redirect(skb, *ifindex_p, 0); } } return 1; } static int br_common(struct __sk_buff *skb, int which_br) { u8 *cursor = 0; u16 proto; u16 arpop; eth_addr_t dmac; u8 *mac_p; u32 dip; u32 *tx_port_id_p; u32 tx_port_id; bpf_dest_t *dest_p; u32 index, *rtrif_p; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); /* handle ethernet packet header */ { dmac.addr = ethernet->dst; /* skb->tc_index may be preserved accross router namespace if router simply rewrite packet * and send it back. */ if (skb->tc_index == 1) { /* packet from pem, send to the router, set tc_index to 2 */ skb->tc_index = 2; if (dmac.addr == 0xffffffffffffULL) { index = 0; if (which_br == 1) rtrif_p = br1_rtr.lookup(&index); else rtrif_p = br2_rtr.lookup(&index); if (rtrif_p) bpf_clone_redirect(skb, *rtrif_p, 0); } else { /* the dmac address should match the router's */ if (which_br == 1) rtrif_p = br1_mac_ifindex.lookup(&dmac); else rtrif_p = br2_mac_ifindex.lookup(&dmac); if (rtrif_p) bpf_clone_redirect(skb, *rtrif_p, 0); } return 1; } /* set the tc_index to 1 so pem knows it is from internal */ skb->tc_index = 1; switch (ethernet->type) { case ETH_P_IP: goto ip; case ETH_P_ARP: goto arp; case ETH_P_8021Q: goto dot1q; default: goto EOP; } } dot1q: { struct dot1q_t *dot1q = cursor_advance(cursor, sizeof(*dot1q)); switch(dot1q->type) { case ETH_P_IP: goto ip; case ETH_P_ARP: goto arp; default: goto EOP; } } arp: { struct arp_t *arp = cursor_advance(cursor, sizeof(*arp)); /* mac learning */ arpop = arp->oper; if (arpop == 2) { index = 0; if (which_br == 1) rtrif_p = br1_rtr.lookup(&index); else rtrif_p = br2_rtr.lookup(&index); if (rtrif_p) { __u32 ifindex = *rtrif_p; eth_addr_t smac; smac.addr = ethernet->src; if (which_br == 1) br1_mac_ifindex.update(&smac, &ifindex); else br2_mac_ifindex.update(&smac, &ifindex); } } goto xmit; } ip: { struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); goto xmit; } xmit: if (which_br == 1) tx_port_id_p = br1_mac.lookup(&dmac); else tx_port_id_p = br2_mac.lookup(&dmac); if (tx_port_id_p) { tx_port_id = *tx_port_id_p; if (which_br == 1) dest_p = br1_dest.lookup(&tx_port_id); else dest_p = br2_dest.lookup(&tx_port_id); if (dest_p) { skb->cb[0] = dest_p->prog_id; skb->cb[1] = dest_p->port_id; jump.call(skb, dest_p->prog_id); } } EOP: return 1; } int br1(struct __sk_buff *skb) { return br_common(skb, 1); } int br2(struct __sk_buff *skb) { return br_common(skb, 2); } bpfcc-0.2.0+git0.02884a026/tests/python/test_brb.py000077500000000000000000000226101305314114400213430ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # This program implements a topology likes below: # pem: physical endpoint manager, implemented as a bpf program # # vm1 <--------+ +----> bridge1 <----+ # V V V # pem router # ^ ^ ^ # vm2 <--------+ +----> bridge2 <----+ # # The vm1, vm2 and router are implemented as namespaces. # The bridge is implemented with limited functionality in bpf program. # # vm1 and vm2 are in different subnet. For vm1 to communicate to vm2, # the packet will have to travel from vm1 to pem, bridge1, router, bridge2, pem, and # then come to vm2. # # When this test is run with verbose mode (ctest -R -V), # the following printout is observed on my local box: # # ...... # 8: ARPING 100.1.1.254 from 100.1.1.1 eth0 # 8: Unicast reply from 100.1.1.254 [76:62:B5:5C:8C:6F] 0.533ms # 8: Sent 1 probes (1 broadcast(s)) # 8: Received 1 response(s) # 8: ARPING 200.1.1.254 from 200.1.1.1 eth0 # 8: Unicast reply from 200.1.1.254 [F2:F0:B4:ED:7B:1B] 0.524ms # 8: Sent 1 probes (1 broadcast(s)) # 8: Received 1 response(s) # 8: PING 200.1.1.1 (200.1.1.1) 56(84) bytes of data. # 8: 64 bytes from 200.1.1.1: icmp_req=1 ttl=63 time=0.074 ms # 8: 64 bytes from 200.1.1.1: icmp_req=2 ttl=63 time=0.061 ms # 8: # 8: --- 200.1.1.1 ping statistics --- # 8: 2 packets transmitted, 2 received, 0% packet loss, time 999ms # 8: rtt min/avg/max/mdev = 0.061/0.067/0.074/0.010 ms # 8: [ ID] Interval Transfer Bandwidth # 8: [ 5] 0.0- 1.0 sec 4.00 GBytes 34.3 Gbits/sec # 8: Starting netserver with host 'IN(6)ADDR_ANY' port '12865' and family AF_UNSPEC # 8: MIGRATED TCP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 200.1.1.1 (200.1.1.1) port 0 AF_INET : demo # 8: Recv Send Send # 8: Socket Socket Message Elapsed # 8: Size Size Size Time Throughput # 8: bytes bytes bytes secs. 10^6bits/sec # 8: # 8: 87380 16384 65160 1.00 41991.68 # 8: MIGRATED TCP REQUEST/RESPONSE TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 200.1.1.1 (200.1.1.1) port 0 AF_INET : demo : first burst 0 # 8: Local /Remote # 8: Socket Size Request Resp. Elapsed Trans. # 8: Send Recv Size Size Time Rate # 8: bytes Bytes bytes bytes secs. per sec # 8: # 8: 16384 87380 1 1 1.00 48645.53 # 8: 16384 87380 # 8: . # 8: ---------------------------------------------------------------------- # 8: Ran 1 test in 11.296s # 8: # 8: OK from ctypes import c_uint from netaddr import IPAddress, EUI from bcc import BPF from pyroute2 import IPRoute, NetNS, IPDB, NSPopen import sys from time import sleep from unittest import main, TestCase from simulation import Simulation arg1 = sys.argv.pop(1) ipr = IPRoute() ipdb = IPDB(nl=ipr) sim = Simulation(ipdb) class TestBPFSocket(TestCase): def set_default_const(self): self.ns1 = "ns1" self.ns2 = "ns2" self.ns_router = "ns_router" self.vm1_ip = "100.1.1.1" self.vm2_ip = "200.1.1.1" self.vm1_rtr_ip = "100.1.1.254" self.vm2_rtr_ip = "200.1.1.254" self.vm1_rtr_mask = "100.1.1.0/24" self.vm2_rtr_mask = "200.1.1.0/24" def get_table(self, b): self.jump = b.get_table("jump") self.pem_dest = b.get_table("pem_dest") self.pem_port = b.get_table("pem_port") self.pem_ifindex = b.get_table("pem_ifindex") self.pem_stats = b.get_table("pem_stats") self.br1_dest = b.get_table("br1_dest") self.br1_mac = b.get_table("br1_mac") self.br1_rtr = b.get_table("br1_rtr") self.br2_dest = b.get_table("br2_dest") self.br2_mac = b.get_table("br2_mac") self.br2_rtr = b.get_table("br2_rtr") def connect_ports(self, prog_id_pem, prog_id_br, curr_pem_pid, curr_br_pid, br_dest_map, br_mac_map, ifindex, vm_mac, vm_ip): self.pem_dest[c_uint(curr_pem_pid)] = self.pem_dest.Leaf(prog_id_br, curr_br_pid) br_dest_map[c_uint(curr_br_pid)] = br_dest_map.Leaf(prog_id_pem, curr_pem_pid) self.pem_port[c_uint(curr_pem_pid)] = c_uint(ifindex) self.pem_ifindex[c_uint(ifindex)] = c_uint(curr_pem_pid) mac_addr = br_mac_map.Key(int(EUI(vm_mac))) br_mac_map[mac_addr] = c_uint(curr_br_pid) def config_maps(self): # program id prog_id_pem = 1 prog_id_br1 = 2 prog_id_br2 = 3 # initial port id and table pointers curr_pem_pid = 0 curr_br1_pid = 0 curr_br2_pid = 0 # configure jump table self.jump[c_uint(prog_id_pem)] = c_uint(self.pem_fn.fd) self.jump[c_uint(prog_id_br1)] = c_uint(self.br1_fn.fd) self.jump[c_uint(prog_id_br2)] = c_uint(self.br2_fn.fd) # connect pem and br1 curr_pem_pid = curr_pem_pid + 1 curr_br1_pid = curr_br1_pid + 1 self.connect_ports(prog_id_pem, prog_id_br1, curr_pem_pid, curr_br1_pid, self.br1_dest, self.br1_mac, self.ns1_eth_out.index, self.vm1_mac, self.vm1_ip) # connect pem and br2 curr_pem_pid = curr_pem_pid + 1 curr_br2_pid = curr_br2_pid + 1 self.connect_ports(prog_id_pem, prog_id_br2, curr_pem_pid, curr_br2_pid, self.br2_dest, self.br2_mac, self.ns2_eth_out.index, self.vm2_mac, self.vm2_ip) # connect and self.br1_rtr[c_uint(0)] = c_uint(self.nsrtr_eth0_out.index) self.br2_rtr[c_uint(0)] = c_uint(self.nsrtr_eth1_out.index) def test_brb(self): try: b = BPF(src_file=arg1, debug=0) self.pem_fn = b.load_func("pem", BPF.SCHED_CLS) self.br1_fn = b.load_func("br1", BPF.SCHED_CLS) self.br2_fn = b.load_func("br2", BPF.SCHED_CLS) self.get_table(b) # set up the topology self.set_default_const() (ns1_ipdb, self.ns1_eth_out, _) = sim._create_ns(self.ns1, ipaddr=self.vm1_ip+'/24', fn=self.pem_fn, action='drop', disable_ipv6=True) (ns2_ipdb, self.ns2_eth_out, _) = sim._create_ns(self.ns2, ipaddr=self.vm2_ip+'/24', fn=self.pem_fn, action='drop', disable_ipv6=True) ns1_ipdb.routes.add({'dst': self.vm2_rtr_mask, 'gateway': self.vm1_rtr_ip}).commit() ns2_ipdb.routes.add({'dst': self.vm1_rtr_mask, 'gateway': self.vm2_rtr_ip}).commit() self.vm1_mac = ns1_ipdb.interfaces['eth0'].address self.vm2_mac = ns2_ipdb.interfaces['eth0'].address (_, self.nsrtr_eth0_out, _) = sim._create_ns(self.ns_router, ipaddr=self.vm1_rtr_ip+'/24', fn=self.br1_fn, action='drop', disable_ipv6=True) (rt_ipdb, self.nsrtr_eth1_out, _) = sim._ns_add_ifc(self.ns_router, "eth1", "ns_router2", ipaddr=self.vm2_rtr_ip+'/24', fn=self.br2_fn, action='drop', disable_ipv6=True) nsp = NSPopen(rt_ipdb.nl.netns, ["sysctl", "-w", "net.ipv4.ip_forward=1"]) nsp.wait(); nsp.release() # configure maps self.config_maps() # our bridge is not smart enough, so send arping for router learning to prevent router # from sending out arp request nsp = NSPopen(ns1_ipdb.nl.netns, ["arping", "-w", "1", "-c", "1", "-I", "eth0", self.vm1_rtr_ip]) nsp.wait(); nsp.release() nsp = NSPopen(ns2_ipdb.nl.netns, ["arping", "-w", "1", "-c", "1", "-I", "eth0", self.vm2_rtr_ip]) nsp.wait(); nsp.release() # ping nsp = NSPopen(ns1_ipdb.nl.netns, ["ping", self.vm2_ip, "-c", "2"]) nsp.wait(); nsp.release() # pem_stats only counts pem->bridge traffic, each VM has 4: arping/arp request/2 icmp request # total 8 packets should be counted self.assertEqual(self.pem_stats[c_uint(0)].value, 8) nsp_server = NSPopen(ns2_ipdb.nl.netns, ["iperf", "-s", "-xSC"]) sleep(1) nsp = NSPopen(ns1_ipdb.nl.netns, ["iperf", "-c", self.vm2_ip, "-t", "1", "-xSC"]) nsp.wait(); nsp.release() nsp_server.kill(); nsp_server.wait(); nsp_server.release() nsp_server = NSPopen(ns2_ipdb.nl.netns, ["netserver", "-D"]) sleep(1) nsp = NSPopen(ns1_ipdb.nl.netns, ["netperf", "-l", "1", "-H", self.vm2_ip, "--", "-m", "65160"]) nsp.wait(); nsp.release() nsp = NSPopen(ns1_ipdb.nl.netns, ["netperf", "-l", "1", "-H", self.vm2_ip, "-t", "TCP_RR"]) nsp.wait(); nsp.release() nsp_server.kill(); nsp_server.wait(); nsp_server.release() finally: sim.release() ipdb.release() if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_brb2.c000066400000000000000000000016451305314114400212210ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include // physical endpoint manager (pem) tables which connects VMs and bridges // BPF_TABLE("hash", u32, u32, pem_dest, 256); // <0, tx_pkts> BPF_TABLE("array", u32, u32, pem_stats, 1); int pem(struct __sk_buff *skb) { u32 ifindex_in, *ifindex_p; u8 *cursor = 0; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); ifindex_in = skb->ingress_ifindex; ifindex_p = pem_dest.lookup(&ifindex_in); if (ifindex_p) { #if 1 if (ethernet->type == 0x0800 || ethernet->type == 0x0806) { /* accumulate stats */ u32 index = 0; u32 *value = pem_stats.lookup(&index); if (value) lock_xadd(value, 1); } #endif bpf_clone_redirect(skb, *ifindex_p, 0); } return 1; } bpfcc-0.2.0+git0.02884a026/tests/python/test_brb2.py000077500000000000000000000221351305314114400214270ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # This program implements a topology likes below: # pem: physical endpoint manager, implemented as a bpf program # # vm1 <--------+ +----> bridge1 <----+ # V V V # pem router # ^ ^ ^ # vm2 <--------+ +----> bridge2 <----+ # # The vm1, vm2 and router are implemented as namespaces. # The linux bridge device is used to provice bridge functionality. # pem bpf will be attached to related network devices for vm1, vm1, bridge1 and bridge2. # # vm1 and vm2 are in different subnet. For vm1 to communicate to vm2, # the packet will have to travel from vm1 to pem, bridge1, router, bridge2, pem, and # then come to vm2. # # When this test is run with verbose mode (ctest -R -V), # the following printout is observed on my local box: # # ...... # 9: PING 200.1.1.1 (200.1.1.1) 56(84) bytes of data. # 9: 64 bytes from 200.1.1.1: icmp_req=1 ttl=63 time=0.090 ms # 9: 64 bytes from 200.1.1.1: icmp_req=2 ttl=63 time=0.032 ms # 9: # 9: --- 200.1.1.1 ping statistics --- # 9: 2 packets transmitted, 2 received, 0% packet loss, time 999ms # 9: rtt min/avg/max/mdev = 0.032/0.061/0.090/0.029 ms # 9: [ ID] Interval Transfer Bandwidth # 9: [ 5] 0.0- 1.0 sec 3.80 GBytes 32.6 Gbits/sec # 9: Starting netserver with host 'IN(6)ADDR_ANY' port '12865' and family AF_UNSPEC # 9: MIGRATED TCP STREAM TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 200.1.1.1 (200.1.1.1) port 0 AF_INET : demo # 9: Recv Send Send # 9: Socket Socket Message Elapsed # 9: Size Size Size Time Throughput # 9: bytes bytes bytes secs. 10^6bits/sec # 9: # 9: 87380 16384 65160 1.00 39940.46 # 9: MIGRATED TCP REQUEST/RESPONSE TEST from 0.0.0.0 (0.0.0.0) port 0 AF_INET to 200.1.1.1 (200.1.1.1) port 0 AF_INET : demo : first burst 0 # 9: Local /Remote # 9: Socket Size Request Resp. Elapsed Trans. # 9: Send Recv Size Size Time Rate # 9: bytes Bytes bytes bytes secs. per sec # 9: # 9: 16384 87380 1 1 1.00 46387.80 # 9: 16384 87380 # 9: . # 9: ---------------------------------------------------------------------- # 9: Ran 1 test in 7.495s # 9: # 9: OK from ctypes import c_uint from bcc import BPF from pyroute2 import IPRoute, NetNS, IPDB, NSPopen import sys from time import sleep from unittest import main, TestCase import subprocess from simulation import Simulation arg1 = sys.argv.pop(1) ipr = IPRoute() ipdb = IPDB(nl=ipr) sim = Simulation(ipdb) allocated_interfaces = set(ipdb.interfaces.keys()) def get_next_iface(prefix): i = 0 while True: iface = "{0}{1}".format(prefix, i) if iface not in allocated_interfaces: allocated_interfaces.add(iface) return iface i += 1 class TestBPFSocket(TestCase): def setup_br(self, br, veth_rt_2_br, veth_pem_2_br, veth_br_2_pem): # create veth which connecting pem and br with ipdb.create(ifname=veth_pem_2_br, kind="veth", peer=veth_br_2_pem) as v: v.up() ipdb.interfaces[veth_br_2_pem].up().commit() subprocess.call(["sysctl", "-q", "-w", "net.ipv6.conf." + veth_pem_2_br + ".disable_ipv6=1"]) subprocess.call(["sysctl", "-q", "-w", "net.ipv6.conf." + veth_br_2_pem + ".disable_ipv6=1"]) # set up the bridge and add router interface as one of its slaves with ipdb.create(ifname=br, kind="bridge") as br1: br1.add_port(ipdb.interfaces[veth_pem_2_br]) br1.add_port(ipdb.interfaces[veth_rt_2_br]) br1.up() subprocess.call(["sysctl", "-q", "-w", "net.ipv6.conf." + br + ".disable_ipv6=1"]) def set_default_const(self): self.ns1 = "ns1" self.ns2 = "ns2" self.ns_router = "ns_router" self.br1 = get_next_iface("br") self.veth_pem_2_br1 = "v20" self.veth_br1_2_pem = "v21" self.br2 = get_next_iface("br") self.veth_pem_2_br2 = "v22" self.veth_br2_2_pem = "v23" self.vm1_ip = "100.1.1.1" self.vm2_ip = "200.1.1.1" self.vm1_rtr_ip = "100.1.1.254" self.vm2_rtr_ip = "200.1.1.254" self.vm1_rtr_mask = "100.1.1.0/24" self.vm2_rtr_mask = "200.1.1.0/24" def attach_filter(self, ifname, fd, name): ifindex = ipdb.interfaces[ifname].index ipr.tc("add", "ingress", ifindex, "ffff:") ipr.tc("add-filter", "bpf", ifindex, ":1", fd=fd, name=name, parent="ffff:", action="drop", classid=1) def config_maps(self): # pem just relays packets between VM and its corresponding # slave link in the bridge interface ns1_ifindex = self.ns1_eth_out.index ns2_ifindex = self.ns2_eth_out.index br1_ifindex = ipdb.interfaces[self.veth_br1_2_pem].index br2_ifindex = ipdb.interfaces[self.veth_br2_2_pem].index self.pem_dest[c_uint(ns1_ifindex)] = c_uint(br1_ifindex) self.pem_dest[c_uint(br1_ifindex)] = c_uint(ns1_ifindex) self.pem_dest[c_uint(ns2_ifindex)] = c_uint(br2_ifindex) self.pem_dest[c_uint(br2_ifindex)] = c_uint(ns2_ifindex) # tc filter setup with bpf programs attached self.attach_filter(self.veth_br1_2_pem, self.pem_fn.fd, self.pem_fn.name) self.attach_filter(self.veth_br2_2_pem, self.pem_fn.fd, self.pem_fn.name) def test_brb2(self): try: b = BPF(src_file=arg1, debug=0) self.pem_fn = b.load_func("pem", BPF.SCHED_CLS) self.pem_dest= b.get_table("pem_dest") self.pem_stats = b.get_table("pem_stats") # set up the topology self.set_default_const() (ns1_ipdb, self.ns1_eth_out, _) = sim._create_ns(self.ns1, ipaddr=self.vm1_ip+'/24', fn=self.pem_fn, action='drop', disable_ipv6=True) (ns2_ipdb, self.ns2_eth_out, _) = sim._create_ns(self.ns2, ipaddr=self.vm2_ip+'/24', fn=self.pem_fn, action='drop', disable_ipv6=True) ns1_ipdb.routes.add({'dst': self.vm2_rtr_mask, 'gateway': self.vm1_rtr_ip}).commit() ns2_ipdb.routes.add({'dst': self.vm1_rtr_mask, 'gateway': self.vm2_rtr_ip}).commit() (_, self.nsrtr_eth0_out, _) = sim._create_ns(self.ns_router, ipaddr=self.vm1_rtr_ip+'/24', disable_ipv6=True) (rt_ipdb, self.nsrtr_eth1_out, _) = sim._ns_add_ifc(self.ns_router, "eth1", "ns_router2", ipaddr=self.vm2_rtr_ip+'/24', disable_ipv6=True) # enable ip forwarding in router ns nsp = NSPopen(rt_ipdb.nl.netns, ["sysctl", "-w", "net.ipv4.ip_forward=1"]) nsp.wait(); nsp.release() # for each VM connecting to pem, there will be a corresponding veth connecting to the bridge self.setup_br(self.br1, self.nsrtr_eth0_out.ifname, self.veth_pem_2_br1, self.veth_br1_2_pem) self.setup_br(self.br2, self.nsrtr_eth1_out.ifname, self.veth_pem_2_br2, self.veth_br2_2_pem) # load the program and configure maps self.config_maps() # ping nsp = NSPopen(ns1_ipdb.nl.netns, ["ping", self.vm2_ip, "-c", "2"]); nsp.wait(); nsp.release() # one arp request/reply, 2 icmp request/reply per VM, total 6 packets per VM, 12 packets total self.assertEqual(self.pem_stats[c_uint(0)].value, 12) nsp_server = NSPopen(ns2_ipdb.nl.netns, ["iperf", "-s", "-xSC"]) sleep(1) nsp = NSPopen(ns1_ipdb.nl.netns, ["iperf", "-c", self.vm2_ip, "-t", "1", "-xSC"]) nsp.wait(); nsp.release() nsp_server.kill(); nsp_server.wait(); nsp_server.release() nsp_server = NSPopen(ns2_ipdb.nl.netns, ["netserver", "-D"]) sleep(1) nsp = NSPopen(ns1_ipdb.nl.netns, ["netperf", "-l", "1", "-H", self.vm2_ip, "--", "-m", "65160"]) nsp.wait(); nsp.release() nsp = NSPopen(ns1_ipdb.nl.netns, ["netperf", "-l", "1", "-H", self.vm2_ip, "-t", "TCP_RR"]) nsp.wait(); nsp.release() nsp_server.kill(); nsp_server.wait(); nsp_server.release() finally: if self.br1 in ipdb.interfaces: ipdb.interfaces[self.br1].remove().commit() if self.br2 in ipdb.interfaces: ipdb.interfaces[self.br2].remove().commit() if self.veth_pem_2_br1 in ipdb.interfaces: ipdb.interfaces[self.veth_pem_2_br1].remove().commit() if self.veth_pem_2_br2 in ipdb.interfaces: ipdb.interfaces[self.veth_pem_2_br2].remove().commit() sim.release() ipdb.release() if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_call1.c000066400000000000000000000021711305314114400213610ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") BPF_TABLE("prog", int, int, jump, 64); BPF_TABLE("array", int, u64, stats, 64); enum states { S_EOP = 1, S_ETHER, S_ARP, S_IP }; int parse_ether(struct __sk_buff *skb) { size_t cur = 0; size_t next = cur + 14; int key = S_ETHER; u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; switch (bpf_dext_pkt(skb, cur + 12, 0, 16)) { case 0x0800: jump.call(skb, S_IP); case 0x0806: jump.call(skb, S_ARP); } jump.call(skb, S_EOP); return 1; } int parse_arp(struct __sk_buff *skb) { size_t cur = 14; // TODO: get from ctx size_t next = cur + 28; int key = S_ARP; u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; jump.call(skb, S_EOP); return 1; } int parse_ip(struct __sk_buff *skb) { size_t cur = 14; // TODO: get from ctx size_t next = cur + 20; int key = S_IP; u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; jump.call(skb, S_EOP); return 1; } int eop(struct __sk_buff *skb) { int key = S_EOP; u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; return 1; } bpfcc-0.2.0+git0.02884a026/tests/python/test_call1.py000077500000000000000000000031401305314114400215670ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from ctypes import c_ushort, c_int, c_ulonglong from netaddr import IPAddress from bcc import BPF from pyroute2 import IPRoute from socket import socket, AF_INET, SOCK_DGRAM import sys from time import sleep from unittest import main, TestCase arg1 = sys.argv.pop(1) S_EOP = 1 S_ETHER = 2 S_ARP = 3 S_IP = 4 class TestBPFSocket(TestCase): def setUp(self): b = BPF(src_file=arg1, debug=0) ether_fn = b.load_func("parse_ether", BPF.SCHED_CLS) arp_fn = b.load_func("parse_arp", BPF.SCHED_CLS) ip_fn = b.load_func("parse_ip", BPF.SCHED_CLS) eop_fn = b.load_func("eop", BPF.SCHED_CLS) ip = IPRoute() ifindex = ip.link_lookup(ifname="eth0")[0] ip.tc("add", "sfq", ifindex, "1:") ip.tc("add-filter", "bpf", ifindex, ":1", fd=ether_fn.fd, name=ether_fn.name, parent="1:", action="ok", classid=1) self.jump = b.get_table("jump", c_int, c_int) self.jump[c_int(S_ARP)] = c_int(arp_fn.fd) self.jump[c_int(S_IP)] = c_int(ip_fn.fd) self.jump[c_int(S_EOP)] = c_int(eop_fn.fd) self.stats = b.get_table("stats", c_int, c_ulonglong) def test_jumps(self): udp = socket(AF_INET, SOCK_DGRAM) udp.sendto(b"a" * 10, ("172.16.1.1", 5000)) udp.close() self.assertGreater(self.stats[c_int(S_IP)].value, 0) self.assertGreater(self.stats[c_int(S_ARP)].value, 0) self.assertGreater(self.stats[c_int(S_EOP)].value, 1) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_callchain.py000077500000000000000000000014351305314114400225160ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF import time from unittest import main, TestCase class TestCallchain(TestCase): def test_callchain1(self): hist = {} def cb(pid, callchain): counter = hist.get(callchain, 0) counter += 1 hist[callchain] = counter b = BPF(text=""" #include int kprobe__finish_task_switch(struct pt_regs *ctx) { return 1; } """, cb=cb) start = time.time() while time.time() < start + 1: b.kprobe_poll() for k, v in hist.items(): syms = [b.ksym(addr) for addr in k] print("%-08d:" % v, syms) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_clang.py000077500000000000000000000240401305314114400216610ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF import ctypes from unittest import main, TestCase class TestClang(TestCase): def test_complex(self): b = BPF(src_file="test_clang_complex.c", debug=0) fn = b.load_func("handle_packet", BPF.SCHED_CLS) def test_printk(self): text = """ #include int handle_packet(void *ctx) { u8 *cursor = 0; struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); bpf_trace_printk("ethernet->dst = %llx, ethernet->src = %llx\\n", ethernet->dst, ethernet->src); return 0; } """ b = BPF(text=text, debug=0) fn = b.load_func("handle_packet", BPF.SCHED_CLS) def test_probe_read1(self): text = """ #include #include int count_sched(struct pt_regs *ctx, struct task_struct *prev) { pid_t p = prev->pid; return (p != -1); } """ b = BPF(text=text, debug=0) fn = b.load_func("count_sched", BPF.KPROBE) def test_probe_read2(self): text = """ #include #include int count_foo(struct pt_regs *ctx, unsigned long a, unsigned long b) { return (a != b); } """ b = BPF(text=text, debug=0) fn = b.load_func("count_foo", BPF.KPROBE) def test_probe_read_keys(self): text = """ #include #include BPF_HASH(start, struct request *); int do_request(struct pt_regs *ctx, struct request *req) { u64 ts = bpf_ktime_get_ns(); start.update(&req, &ts); return 0; } int do_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp = start.lookup(&req); if (tsp != 0) { start.delete(&req); } return 0; } """ b = BPF(text=text, debug=0) fns = b.load_funcs(BPF.KPROBE) def test_sscanf(self): text = """ BPF_TABLE("hash", int, struct { u64 a; u64 b; u64 c:36; u64 d:28; struct { u32 a; u32 b; } s; }, stats, 10); int foo(void *ctx) { return 0; } """ b = BPF(text=text, debug=0) fn = b.load_func("foo", BPF.KPROBE) t = b.get_table("stats") s1 = t.key_sprintf(t.Key(2)) self.assertEqual(s1, b"0x2") s2 = t.leaf_sprintf(t.Leaf(2, 3, 4, 1, (5, 6))) l = t.leaf_scanf(s2) self.assertEqual(l.a, 2) self.assertEqual(l.b, 3) self.assertEqual(l.c, 4) self.assertEqual(l.d, 1) self.assertEqual(l.s.a, 5) self.assertEqual(l.s.b, 6) def test_sscanf_array(self): text = """ BPF_TABLE("hash", int, struct { u32 a[3]; u32 b; }, stats, 10); """ b = BPF(text=text, debug=0) t = b.get_table("stats") s1 = t.key_sprintf(t.Key(2)) self.assertEqual(s1, b"0x2") s2 = t.leaf_sprintf(t.Leaf((ctypes.c_uint * 3)(1,2,3), 4)) self.assertEqual(s2, b"{ [ 0x1 0x2 0x3 ] 0x4 }") l = t.leaf_scanf(s2) self.assertEqual(l.a[0], 1) self.assertEqual(l.a[1], 2) self.assertEqual(l.a[2], 3) self.assertEqual(l.b, 4) def test_iosnoop(self): text = """ #include #include struct key_t { struct request *req; }; BPF_TABLE("hash", struct key_t, u64, start, 1024); int do_request(struct pt_regs *ctx, struct request *req) { struct key_t key = {}; bpf_trace_printk("traced start %d\\n", req->__data_len); return 0; } """ b = BPF(text=text, debug=0) fn = b.load_func("do_request", BPF.KPROBE) def test_blk_start_request(self): text = """ #include #include int do_request(struct pt_regs *ctx, int req) { bpf_trace_printk("req ptr: 0x%x\\n", req); return 0; } """ b = BPF(text=text, debug=0) fn = b.load_func("do_request", BPF.KPROBE) def test_bpf_hash(self): text = """ BPF_HASH(table1); BPF_HASH(table2, u32); BPF_HASH(table3, u32, int); """ b = BPF(text=text, debug=0) def test_consecutive_probe_read(self): text = """ #include #include BPF_HASH(table1, struct super_block *); int trace_entry(struct pt_regs *ctx, struct file *file) { if (!file) return 0; struct vfsmount *mnt = file->f_path.mnt; if (mnt) { struct super_block *k = mnt->mnt_sb; u64 zero = 0; table1.update(&k, &zero); k = mnt->mnt_sb; table1.update(&k, &zero); } return 0; } """ b = BPF(text=text, debug=0) fn = b.load_func("trace_entry", BPF.KPROBE) def test_nested_probe_read(self): text = """ #include int trace_entry(struct pt_regs *ctx, struct file *file) { if (!file) return 0; const char *name = file->f_path.dentry->d_name.name; bpf_trace_printk("%s\\n", name); return 0; } """ b = BPF(text=text, debug=0) fn = b.load_func("trace_entry", BPF.KPROBE) def test_char_array_probe(self): BPF(text="""#include int kprobe__blk_update_request(struct pt_regs *ctx, struct request *req) { bpf_trace_printk("%s\\n", req->rq_disk->disk_name); return 0; }""") def test_probe_read_helper(self): b = BPF(text=""" #include static void print_file_name(struct file *file) { if (!file) return; const char *name = file->f_path.dentry->d_name.name; bpf_trace_printk("%s\\n", name); } static void print_file_name2(int unused, struct file *file) { print_file_name(file); } int trace_entry1(struct pt_regs *ctx, struct file *file) { print_file_name(file); return 0; } int trace_entry2(struct pt_regs *ctx, int unused, struct file *file) { print_file_name2(unused, file); return 0; } """) fn = b.load_func("trace_entry1", BPF.KPROBE) fn = b.load_func("trace_entry2", BPF.KPROBE) def test_probe_unnamed_union_deref(self): text = """ #include int trace(struct pt_regs *ctx, struct page *page) { void *p = page->mapping; return p != NULL; } """ # depending on llvm, compile may pass/fail, but at least shouldn't crash try: b = BPF(text=text) except: pass def test_probe_struct_assign(self): b = BPF(text = """ #include struct args_t { const char *filename; int flags; int mode; }; int kprobe__sys_open(struct pt_regs *ctx, const char *filename, int flags, int mode) { struct args_t args = {}; args.filename = filename; args.flags = flags; args.mode = mode; bpf_trace_printk("%s\\n", args.filename); return 0; }; """) def test_task_switch(self): b = BPF(text=""" #include #include struct key_t { u32 prev_pid; u32 curr_pid; }; BPF_TABLE("hash", struct key_t, u64, stats, 1024); int kprobe__finish_task_switch(struct pt_regs *ctx, struct task_struct *prev) { struct key_t key = {}; u64 zero = 0, *val; key.curr_pid = bpf_get_current_pid_tgid(); key.prev_pid = prev->pid; val = stats.lookup_or_init(&key, &zero); (*val)++; return 0; } """) def test_probe_simple_assign(self): b = BPF(text=""" #include #include struct leaf { size_t size; }; BPF_HASH(simple_map, u32, struct leaf); int kprobe____kmalloc(struct pt_regs *ctx, size_t size) { u32 pid = bpf_get_current_pid_tgid(); struct leaf* leaf = simple_map.lookup(&pid); if (leaf) leaf->size += size; return 0; }""") def test_unop_probe_read(self): text = """ #include int trace_entry(struct pt_regs *ctx, struct request *req) { if (!(req->bio->bi_flags & 1)) return 1; if (((req->bio->bi_flags))) return 1; return 0; } """ b = BPF(text=text) fn = b.load_func("trace_entry", BPF.KPROBE) def test_complex_leaf_types(self): text = """ struct list; struct list { struct list *selfp; struct list *another_selfp; struct list *selfp_array[2]; }; struct empty { }; union emptyu { struct empty *em1; struct empty em2; struct empty em3; struct empty em4; }; BPF_TABLE("array", int, struct list, t1, 1); BPF_TABLE("array", int, struct list *, t2, 1); BPF_TABLE("array", int, union emptyu, t3, 1); """ b = BPF(text=text) import ctypes self.assertEqual(ctypes.sizeof(b["t3"].Leaf), 8) def test_cflags(self): text = """ #ifndef MYFLAG #error "MYFLAG not set as expected" #endif """ b = BPF(text=text, cflags=["-DMYFLAG"]) def test_exported_maps(self): b1 = BPF(text="""BPF_TABLE_PUBLIC("hash", int, int, table1, 10);""") b2 = BPF(text="""BPF_TABLE("extern", int, int, table1, 10);""") def test_syntax_error(self): with self.assertRaises(Exception): b = BPF(text="""int failure(void *ctx) { if (); return 0; }""") def test_nested_union(self): text = """ BPF_TABLE("hash", struct bpf_tunnel_key, int, t1, 1); """ b = BPF(text=text) t1 = b["t1"] print(t1.Key().remote_ipv4) def test_too_many_args(self): text = """ #include int many(struct pt_regs *ctx, int a, int b, int c, int d, int e, int f, int g) { return 0; } """ with self.assertRaises(Exception): b = BPF(text=text) def test_call_macro_arg(self): text = """ BPF_TABLE("prog", u32, u32, jmp, 32); #define JMP_IDX_PIPE (1U << 1) enum action { ACTION_PASS }; int process(struct xdp_md *ctx) { jmp.call((void *)ctx, ACTION_PASS); jmp.call((void *)ctx, JMP_IDX_PIPE); return XDP_PASS; } """ b = BPF(text=text) t = b["jmp"] self.assertEquals(len(t), 32); def test_update_macro_arg(self): text = """ BPF_TABLE("array", u32, u32, act, 32); #define JMP_IDX_PIPE (1U << 1) enum action { ACTION_PASS }; int process(struct xdp_md *ctx) { act.increment(ACTION_PASS); act.increment(JMP_IDX_PIPE); return XDP_PASS; } """ b = BPF(text=text) t = b["act"] self.assertEquals(len(t), 32); if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_clang_complex.c000066400000000000000000000077371305314114400232150ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include // hash struct FwdKey { u32 dip:32; }; struct FwdLeaf { u32 fwd_idx:32; }; BPF_TABLE("hash", struct FwdKey, struct FwdLeaf, fwd_map, 1); // array struct ConfigKey { u32 index; }; struct ConfigLeaf { u32 bpfdev_ip; u32 slave_ip; }; BPF_TABLE("array", struct ConfigKey, struct ConfigLeaf, config_map, 1); // hash struct MacaddrKey { u32 ip; }; struct MacaddrLeaf { u64 mac; }; BPF_TABLE("hash", struct MacaddrKey, struct MacaddrLeaf, macaddr_map, 11); // hash struct SlaveKey { u32 slave_ip; }; struct SlaveLeaf { u32 slave_ifindex; }; BPF_TABLE("hash", struct SlaveKey, struct SlaveLeaf, slave_map, 10); int handle_packet(struct __sk_buff *skb) { int ret = 0; u8 *cursor = 0; if (skb->pkt_type == 0) { // tx // make sure configured u32 slave_ip; struct ConfigKey cfg_key = {.index = 0}; struct ConfigLeaf *cfg_leaf = config_map.lookup(&cfg_key); if (cfg_leaf) { slave_ip = cfg_leaf->slave_ip; } else { return 0xffffffff; } // make sure slave configured // tx, default to the single slave struct SlaveKey slave_key = {.slave_ip = slave_ip}; struct SlaveLeaf *slave_leaf = slave_map.lookup(&slave_key); if (slave_leaf) { ret = slave_leaf->slave_ifindex; } else { return 0xffffffff; } } else { // rx, default to stack ret = 0; } struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); switch (ethernet->type) { case ETH_P_IP: goto ip; case ETH_P_ARP: goto arp; case ETH_P_8021Q: goto dot1q; default: goto EOP; } dot1q: { struct dot1q_t *dot1q = cursor_advance(cursor, sizeof(*dot1q)); switch (dot1q->type) { case ETH_P_IP: goto ip; case ETH_P_ARP: goto arp; default: goto EOP; } } arp: { struct arp_t *arp = cursor_advance(cursor, sizeof(*arp)); if (skb->pkt_type) { if (arp->oper == 1) { struct MacaddrKey mac_key = {.ip=arp->spa}; struct MacaddrLeaf mac_leaf = {.mac=arp->sha}; macaddr_map.update(&mac_key, &mac_leaf); } } goto EOP; } struct ip_t *ip; ip: { ip = cursor_advance(cursor, sizeof(*ip)); switch (ip->nextp) { case 6: goto tcp; case 17: goto udp; default: goto EOP; } } tcp: { struct tcp_t *tcp = cursor_advance(cursor, sizeof(*tcp)); goto EOP; } udp: { struct udp_t *udp = cursor_advance(cursor, sizeof(*udp)); if (udp->dport != 5000) { goto EOP; } if (skb->pkt_type) { // lookup and then forward struct FwdKey fwd_key = {.dip=ip->dst}; struct FwdLeaf *fwd_val = fwd_map.lookup(&fwd_key); if (fwd_val) { return fwd_val->fwd_idx; } } else { // rewrite the packet and send to a pre-configured index if needed u32 new_ip; u32 old_ip; u64 src_mac; u64 dst_mac; struct ConfigKey cfg_key = {.index = 0}; struct ConfigLeaf *cfg_leaf = config_map.lookup(&cfg_key); if (cfg_leaf) { struct MacaddrKey mac_key = {.ip = cfg_leaf->bpfdev_ip}; struct MacaddrLeaf *mac_leaf; mac_key.ip = cfg_leaf->bpfdev_ip; mac_leaf = macaddr_map.lookup(&mac_key); if (mac_leaf) { src_mac = mac_leaf->mac; } else { goto EOP; } mac_key.ip = cfg_leaf->slave_ip; mac_leaf = macaddr_map.lookup(&mac_key); if (mac_leaf) { dst_mac = mac_leaf->mac; } else { goto EOP; } // rewrite ethernet header ethernet->dst = dst_mac; ethernet->src = src_mac; // ip & udp checksum incr_cksum_l4(&udp->crc, ip->src, cfg_leaf->bpfdev_ip, 1); incr_cksum_l4(&udp->crc, ip->dst, cfg_leaf->slave_ip, 1); // rewrite ip src/dst fields ip->src = cfg_leaf->bpfdev_ip; ip->dst = cfg_leaf->slave_ip; } } goto EOP; } EOP: return ret; } bpfcc-0.2.0+git0.02884a026/tests/python/test_debuginfo.py000077500000000000000000000052161305314114400225430ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) Sasha Goldshtein # Licensed under the Apache License, Version 2.0 (the "License") import os import subprocess from bcc import SymbolCache from unittest import main, TestCase class Harness(TestCase): def setUp(self): self.build_command() subprocess.check_output('objcopy --only-keep-debug dummy dummy.debug' .split()) self.debug_command() subprocess.check_output('strip dummy'.split()) self.process = subprocess.Popen('./dummy', stdout=subprocess.PIPE) # The process prints out the address of some symbol, which we then # try to resolve in the test. self.addr = int(self.process.stdout.readline().strip(), 16) self.syms = SymbolCache(self.process.pid) def tearDown(self): self.process.kill() def resolve_addr(self): sym, offset, module = self.syms.resolve(self.addr) self.assertEqual(sym, 'some_function') self.assertEqual(offset, 0) self.assertTrue(module[-5:] == 'dummy') def resolve_name(self): script_dir = os.path.dirname(os.path.realpath(__file__)) addr = self.syms.resolve_name(os.path.join(script_dir, 'dummy'), 'some_function') self.assertEqual(addr, self.addr) pass class TestDebuglink(Harness): def build_command(self): subprocess.check_output('gcc -o dummy dummy.c'.split()) def debug_command(self): subprocess.check_output('objcopy --add-gnu-debuglink=dummy.debug dummy' .split()) def tearDown(self): subprocess.check_output('rm dummy dummy.debug'.split()) def test_resolve_addr(self): self.resolve_addr() def test_resolve_name(self): self.resolve_name() class TestBuildid(Harness): def build_command(self): subprocess.check_output(('gcc -o dummy -Xlinker ' + \ '--build-id=0x123456789abcdef0123456789abcdef012345678 dummy.c') .split()) def debug_command(self): subprocess.check_output('mkdir -p /usr/lib/debug/.build-id/12'.split()) subprocess.check_output(('mv dummy.debug /usr/lib/debug/.build-id' + \ '/12/3456789abcdef0123456789abcdef012345678.debug').split()) def tearDown(self): subprocess.check_output('rm dummy'.split()) subprocess.check_output(('rm /usr/lib/debug/.build-id/12' + '/3456789abcdef0123456789abcdef012345678.debug').split()) def test_resolve_name(self): self.resolve_addr() def test_resolve_addr(self): self.resolve_name() if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_dump_func.py000077500000000000000000000011121305314114400225500ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # test program for the 'dump_func' method from bcc import BPF from unittest import main, TestCase class TestDumpFunc(TestCase): def test_return(self): b = BPF(text=""" int entry(void) { return 1; }""") self.assertEqual( b"\xb7\x00\x00\x00\x01\x00\x00\x00" + b"\x95\x00\x00\x00\x00\x00\x00\x00", b.dump_func("entry")) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_flags.py000066400000000000000000000013101305314114400216610ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") import unittest from bcc import BPF class TestLru(unittest.TestCase): def test_lru_map_flags(self): test_prog1 = """ BPF_F_TABLE("lru_hash", int, u64, lru, 1024, BPF_F_NO_COMMON_LRU); """ b = BPF(text=test_prog1) t = b["lru"] self.assertEqual(t.flags, 2); def test_hash_map_flags(self): test_prog1 = """ BPF_F_TABLE("hash", int, u64, hash, 1024, BPF_F_NO_PREALLOC); """ b = BPF(text=test_prog1) t = b["hash"] self.assertEqual(t.flags, 1); if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_histogram.py000077500000000000000000000043161305314114400225760ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF from ctypes import c_int, c_ulonglong import random import time from unittest import main, TestCase class TestHistogram(TestCase): def test_simple(self): b = BPF(text=""" #include struct bpf_map; BPF_HISTOGRAM(hist1); BPF_HASH(stub); int kprobe__htab_map_delete_elem(struct pt_regs *ctx, struct bpf_map *map, u64 *k) { hist1.increment(bpf_log2l(*k)); return 0; } """) for i in range(0, 32): for j in range(0, random.randint(1, 10)): try: del b["stub"][c_ulonglong(1 << i)] except: pass b["hist1"].print_log2_hist() for i in range(32, 64): for j in range(0, random.randint(1, 10)): try: del b["stub"][c_ulonglong(1 << i)] except: pass b["hist1"].print_log2_hist() b.cleanup() def test_struct(self): b = BPF(text=""" #include struct bpf_map; typedef struct { void *map; u64 slot; } Key; BPF_HISTOGRAM(hist1, Key, 1024); BPF_HASH(stub1); BPF_HASH(stub2); int kprobe__htab_map_delete_elem(struct pt_regs *ctx, struct bpf_map *map, u64 *k) { hist1.increment((Key){map, bpf_log2l(*k)}); return 0; } """) for i in range(0, 64): for j in range(0, random.randint(1, 10)): try: del b["stub1"][c_ulonglong(1 << i)] except: pass try: del b["stub2"][c_ulonglong(1 << i)] except: pass b["hist1"].print_log2_hist() b.cleanup() def test_chars(self): b = BPF(text=""" #include #include typedef struct { char name[TASK_COMM_LEN]; u64 slot; } Key; BPF_HISTOGRAM(hist1, Key, 1024); int kprobe__finish_task_switch(struct pt_regs *ctx, struct task_struct *prev) { Key k = {.slot = bpf_log2l(prev->real_start_time)}; if (!bpf_get_current_comm(&k.name, sizeof(k.name))) hist1.increment(k); return 0; } """) for i in range(0, 100): time.sleep(0.01) b["hist1"].print_log2_hist() b.cleanup() if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_lpm_trie.py000066400000000000000000000037631305314114400224160ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) 2017 Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") import ctypes as ct import unittest from bcc import BPF from netaddr import IPAddress class KeyV4(ct.Structure): _fields_ = [("prefixlen", ct.c_uint), ("data", ct.c_ubyte * 4)] class KeyV6(ct.Structure): _fields_ = [("prefixlen", ct.c_uint), ("data", ct.c_ushort * 8)] class TestLpmTrie(unittest.TestCase): def test_lpm_trie_v4(self): test_prog1 = """ BPF_F_TABLE("lpm_trie", u64, int, trie, 16, BPF_F_NO_PREALLOC); """ b = BPF(text=test_prog1) t = b["trie"] k1 = KeyV4(24, (192, 168, 0, 0)) v1 = ct.c_int(24) t[k1] = v1 k2 = KeyV4(28, (192, 168, 0, 0)) v2 = ct.c_int(28) t[k2] = v2 k = KeyV4(32, (192, 168, 0, 15)) self.assertEqual(t[k].value, 28) k = KeyV4(32, (192, 168, 0, 127)) self.assertEqual(t[k].value, 24) with self.assertRaises(KeyError): k = KeyV4(32, (172, 16, 1, 127)) v = t[k] def test_lpm_trie_v6(self): test_prog1 = """ struct key_v6 { u32 prefixlen; u32 data[4]; }; BPF_F_TABLE("lpm_trie", struct key_v6, int, trie, 16, BPF_F_NO_PREALLOC); """ b = BPF(text=test_prog1) t = b["trie"] k1 = KeyV6(64, IPAddress('2a00:1450:4001:814:200e::').words) v1 = ct.c_int(64) t[k1] = v1 k2 = KeyV6(96, IPAddress('2a00:1450:4001:814::200e').words) v2 = ct.c_int(96) t[k2] = v2 k = KeyV6(128, IPAddress('2a00:1450:4001:814::1024').words) self.assertEqual(t[k].value, 96) k = KeyV6(128, IPAddress('2a00:1450:4001:814:2046::').words) self.assertEqual(t[k].value, 64) with self.assertRaises(KeyError): k = KeyV6(128, IPAddress('2a00:ffff::').words) v = t[k] if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_lru.py000066400000000000000000000037231305314114400214010ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") import ctypes as ct import os import unittest from bcc import BPF import multiprocessing class TestLru(unittest.TestCase): def test_lru_hash(self): b = BPF(text="""BPF_TABLE("lru_hash", int, u64, lru, 1024);""") t = b["lru"] for i in range(1, 1032): t[ct.c_int(i)] = ct.c_ulonglong(i) for i, v in t.items(): self.assertEqual(v.value, i.value) # BPF_MAP_TYPE_LRU_HASH eviction happens in batch and we expect less # items than specified size. self.assertLess(len(t), 1024); def test_lru_percpu_hash(self): test_prog1 = """ BPF_TABLE("lru_percpu_hash", u32, u32, stats, 1); int hello_world(void *ctx) { u32 key=0; u32 value = 0, *val; val = stats.lookup_or_init(&key, &value); *val += 1; return 0; } """ b = BPF(text=test_prog1) stats_map = b.get_table("stats") b.attach_kprobe(event="sys_clone", fn_name="hello_world") ini = stats_map.Leaf() for i in range(0, multiprocessing.cpu_count()): ini[i] = 0 # First initialize with key 1 stats_map[ stats_map.Key(1) ] = ini # Then initialize with key 0 stats_map[ stats_map.Key(0) ] = ini # Key 1 should have been evicted with self.assertRaises(KeyError): val = stats_map[ stats_map.Key(1) ] f = os.popen("hostname") f.close() self.assertEqual(len(stats_map),1) val = stats_map[ stats_map.Key(0) ] sum = stats_map.sum(stats_map.Key(0)) avg = stats_map.average(stats_map.Key(0)) max = stats_map.max(stats_map.Key(0)) self.assertGreater(sum.value, 0L) self.assertGreater(max.value, 0L) b.detach_kprobe("sys_clone") if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_percpu.py000077500000000000000000000070321305314114400220750ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") import os import unittest from bcc import BPF import multiprocessing class TestPercpu(unittest.TestCase): def setUp(self): try: b = BPF(text='BPF_TABLE("percpu_array", u32, u32, stub, 1);') except: raise unittest.SkipTest("PerCpu unsupported on this kernel") def test_u64(self): test_prog1 = """ BPF_TABLE("percpu_hash", u32, u64, stats, 1); int hello_world(void *ctx) { u32 key=0; u64 value = 0, *val; val = stats.lookup_or_init(&key, &value); *val += 1; return 0; } """ bpf_code = BPF(text=test_prog1) stats_map = bpf_code.get_table("stats") bpf_code.attach_kprobe(event="sys_clone", fn_name="hello_world") ini = stats_map.Leaf() for i in range(0, multiprocessing.cpu_count()): ini[i] = 0 stats_map[ stats_map.Key(0) ] = ini f = os.popen("hostname") f.close() self.assertEqual(len(stats_map),1) val = stats_map[ stats_map.Key(0) ] sum = stats_map.sum(stats_map.Key(0)) avg = stats_map.average(stats_map.Key(0)) max = stats_map.max(stats_map.Key(0)) self.assertGreater(sum.value, int(0)) self.assertGreater(max.value, int(0)) bpf_code.detach_kprobe("sys_clone") def test_u32(self): test_prog1 = """ BPF_TABLE("percpu_array", u32, u32, stats, 1); int hello_world(void *ctx) { u32 key=0; u32 value = 0, *val; val = stats.lookup_or_init(&key, &value); *val += 1; return 0; } """ bpf_code = BPF(text=test_prog1) stats_map = bpf_code.get_table("stats") bpf_code.attach_kprobe(event="sys_clone", fn_name="hello_world") ini = stats_map.Leaf() for i in range(0, multiprocessing.cpu_count()): ini[i] = 0 stats_map[ stats_map.Key(0) ] = ini f = os.popen("hostname") f.close() self.assertEqual(len(stats_map),1) val = stats_map[ stats_map.Key(0) ] sum = stats_map.sum(stats_map.Key(0)) avg = stats_map.average(stats_map.Key(0)) max = stats_map.max(stats_map.Key(0)) self.assertGreater(sum.value, int(0)) self.assertGreater(max.value, int(0)) bpf_code.detach_kprobe("sys_clone") def test_struct_custom_func(self): test_prog2 = """ typedef struct counter { u32 c1; u32 c2; } counter; BPF_TABLE("percpu_hash", u32, counter, stats, 1); int hello_world(void *ctx) { u32 key=0; counter value = {0,0}, *val; val = stats.lookup_or_init(&key, &value); val->c1 += 1; val->c2 += 1; return 0; } """ bpf_code = BPF(text=test_prog2) stats_map = bpf_code.get_table("stats", reducer=lambda x,y: stats_map.sLeaf(x.c1+y.c1)) bpf_code.attach_kprobe(event="sys_clone", fn_name="hello_world") ini = stats_map.Leaf() for i in ini: i = stats_map.sLeaf(0,0) stats_map[ stats_map.Key(0) ] = ini f = os.popen("hostname") f.close() self.assertEqual(len(stats_map),1) k = stats_map[ stats_map.Key(0) ] self.assertGreater(k.c1, int(0)) bpf_code.detach_kprobe("sys_clone") if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_perf_event.py000077500000000000000000000023661305314114400227410ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) 2016 PLUMgrid # Licensed under the Apache License, Version 2.0 (the "License") import bcc import ctypes import multiprocessing import os import time import unittest class TestPerfCounter(unittest.TestCase): def test_cycles(self): text = """ BPF_PERF_ARRAY(cnt1, NUM_CPUS); BPF_TABLE("array", u32, u64, prev, NUM_CPUS); BPF_HISTOGRAM(dist); int kprobe__sys_getuid(void *ctx) { u32 cpu = bpf_get_smp_processor_id(); u64 val = cnt1.perf_read(cpu); prev.update(&cpu, &val); return 0; } int kretprobe__sys_getuid(void *ctx) { u32 cpu = bpf_get_smp_processor_id(); u64 val = cnt1.perf_read(cpu); u64 *prevp = prev.lookup(&cpu); if (prevp) dist.increment(bpf_log2l(val - *prevp)); return 0; } """ b = bcc.BPF(text=text, debug=0, cflags=["-DNUM_CPUS=%d" % multiprocessing.cpu_count()]) cnt1 = b["cnt1"] try: cnt1.open_perf_event(cnt1.HW_CPU_CYCLES) except: if ctypes.get_errno() == 2: raise self.skipTest("hardware events unsupported") raise for i in range(0, 100): os.getuid() b["dist"].print_log2_hist() if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_probe_count.py000077500000000000000000000051421305314114400231160ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) Suchakra Sharma # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF, _get_num_open_probes import os import sys from unittest import main, TestCase class TestKprobeCnt(TestCase): def setUp(self): self.b = BPF(text=""" int wololo(void *ctx) { return 0; } """) self.b.attach_kprobe(event_re="^vfs_.*", fn_name="wololo") def test_attach1(self): actual_cnt = 0 with open("/sys/kernel/debug/tracing/available_filter_functions") as f: for line in f: if str(line).startswith("vfs_"): actual_cnt += 1 open_cnt = self.b.num_open_kprobes() self.assertEqual(actual_cnt, open_cnt) def tearDown(self): self.b.cleanup() class TestProbeGlobalCnt(TestCase): def setUp(self): self.b1 = BPF(text="""int count(void *ctx) { return 0; }""") self.b2 = BPF(text="""int count(void *ctx) { return 0; }""") def test_probe_quota(self): self.b1.attach_kprobe(event="schedule", fn_name="count") self.b2.attach_kprobe(event="submit_bio", fn_name="count") self.assertEqual(1, self.b1.num_open_kprobes()) self.assertEqual(1, self.b2.num_open_kprobes()) self.assertEqual(2, _get_num_open_probes()) self.b1.cleanup() self.b2.cleanup() self.assertEqual(0, _get_num_open_probes()) class TestAutoKprobe(TestCase): def setUp(self): self.b = BPF(text=""" int kprobe__schedule(void *ctx) { return 0; } int kretprobe__schedule(void *ctx) { return 0; } """) def test_count(self): self.assertEqual(2, self.b.num_open_kprobes()) def tearDown(self): self.b.cleanup() class TestProbeQuota(TestCase): def setUp(self): self.b = BPF(text="""int count(void *ctx) { return 0; }""") def test_probe_quota(self): with self.assertRaises(Exception): self.b.attach_kprobe(event_re=".*", fn_name="count") def test_uprobe_quota(self): with self.assertRaises(Exception): self.b.attach_uprobe(name="c", sym_re=".*", fn_name="count") def tearDown(self): self.b.cleanup() class TestProbeNotExist(TestCase): def setUp(self): self.b = BPF(text="""int count(void *ctx) { return 0; }""") def test_not_exist(self): with self.assertRaises(Exception): b.attach_kprobe(event="___doesnotexist", fn_name="count") def tearDown(self): self.b.cleanup() if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_shared_table.py000066400000000000000000000012661305314114400232140ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) 2016 Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") import ctypes as ct import unittest from bcc import BPF class TestSharedTable(unittest.TestCase): def test_close_extern(self): b1 = BPF(text="""BPF_TABLE_PUBLIC("array", int, int, table1, 10);""") with BPF(text="""BPF_TABLE("extern", int, int, table1, 10);""") as b2: t2 = b2["table1"] t2[ct.c_int(1)] = ct.c_int(10) self.assertEqual(len(t2), 10) t1 = b1["table1"] self.assertEqual(t1[ct.c_int(1)].value, 10) self.assertEqual(len(t1), 10) if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_stackid.py000077500000000000000000000027611305314114400222250ustar00rootroot00000000000000#!/usr/bin/python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") import bcc import distutils.version import os import unittest def kernel_version_ge(major, minor): # True if running kernel is >= X.Y version = distutils.version.LooseVersion(os.uname()[2]).version if version[0] > major: return True if version[0] < major: return False if minor and version[1] < minor: return False return True @unittest.skipUnless(kernel_version_ge(4,6), "requires kernel >= 4.6") class TestStackid(unittest.TestCase): def test_simple(self): b = bcc.BPF(text=""" #include struct bpf_map; BPF_STACK_TRACE(stack_traces, 10240); BPF_HASH(stack_entries, int, int); BPF_HASH(stub); int kprobe__htab_map_lookup_elem(struct pt_regs *ctx, struct bpf_map *map, u64 *k) { int id = stack_traces.get_stackid(ctx, BPF_F_REUSE_STACKID); if (id < 0) return 0; int key = 1; stack_entries.update(&key, &id); return 0; } """) stub = b["stub"] stack_traces = b["stack_traces"] stack_entries = b["stack_entries"] try: x = stub[stub.Key(1)] except: pass k = stack_entries.Key(1) self.assertIn(k, stack_entries) stackid = stack_entries[k] self.assertIsNotNone(stackid) stack = stack_traces[stackid].ip self.assertEqual(b.ksym(stack[0]), "htab_map_lookup_elem") if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_stat1.b000066400000000000000000000020201305314114400214110ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") struct IPKey { u32 dip:32; u32 sip:32; }; struct IPLeaf { u32 rx_pkts:64; u32 tx_pkts:64; }; Table stats(1024); struct skbuff { u32 type:32; }; u32 on_packet(struct skbuff *skb) { u32 ret:32 = 0; goto proto::ethernet; state proto::ethernet { } state proto::dot1q { } state proto::ip { u32 rx:32 = 0; u32 tx:32 = 0; u32 IPKey key; if $ip.dst > $ip.src { key.dip = $ip.dst; key.sip = $ip.src; rx = 1; // test arbitrary return stmt if false { return 3; } } else { key.dip = $ip.src; key.sip = $ip.dst; tx = 1; ret = 1; } struct IPLeaf *leaf; leaf = stats[key]; on_valid(leaf) { atomic_add(leaf.rx_pkts, rx); atomic_add(leaf.tx_pkts, tx); } } state proto::udp { } state proto::vxlan { } state proto::gre { } state EOP { return ret; } } bpfcc-0.2.0+git0.02884a026/tests/python/test_stat1.c000066400000000000000000000022731305314114400214240ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include struct IPKey { u32 dip; u32 sip; }; struct IPLeaf { u64 rx_pkts; u64 tx_pkts; }; BPF_TABLE("hash", struct IPKey, struct IPLeaf, stats, 256); int on_packet(struct __sk_buff *skb) { u8 *cursor = 0; ethernet: { struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); switch (ethernet->type) { case ETH_P_IP: goto ip; case ETH_P_8021Q: goto dot1q; default: goto EOP; } } dot1q: { struct dot1q_t *dot1q = cursor_advance(cursor, sizeof(*dot1q)); switch (dot1q->type) { case ETH_P_8021Q: goto ip; default: goto EOP; } } ip: { struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); int rx = 0, tx = 0; struct IPKey key; if (ip->dst > ip->src) { key.dip = ip->dst; key.sip = ip->src; rx = 1; } else { key.dip = ip->src; key.sip = ip->dst; tx = 1; } struct IPLeaf zleaf = {0}; struct IPLeaf *leaf = stats.lookup_or_init(&key, &zleaf); lock_xadd(&leaf->rx_pkts, rx); lock_xadd(&leaf->tx_pkts, tx); } EOP: return 0; } bpfcc-0.2.0+git0.02884a026/tests/python/test_stat1.py000077500000000000000000000051101305314114400216260ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # test program to count the packets sent to a device in a .5 # second period from ctypes import c_uint, c_ulong, Structure from netaddr import IPAddress from bcc import BPF from subprocess import check_call import sys from unittest import main, TestCase arg1 = sys.argv.pop(1) arg2 = "" if len(sys.argv) > 1: arg2 = sys.argv.pop(1) Key = None Leaf = None if arg1.endswith(".b"): class Key(Structure): _fields_ = [("dip", c_uint), ("sip", c_uint)] class Leaf(Structure): _fields_ = [("rx_pkts", c_ulong), ("tx_pkts", c_ulong)] class TestBPFSocket(TestCase): def setUp(self): b = BPF(arg1, arg2, debug=0) fn = b.load_func("on_packet", BPF.SOCKET_FILTER) BPF.attach_raw_socket(fn, "eth0") self.stats = b.get_table("stats", Key, Leaf) def test_ping(self): cmd = ["ping", "-f", "-c", "100", "172.16.1.1"] check_call(cmd) #for key, leaf in self.stats.items(): # print(IPAddress(key.sip), "=>", IPAddress(key.dip), # "rx", leaf.rx_pkts, "tx", leaf.tx_pkts) key = self.stats.Key(IPAddress("172.16.1.2").value, IPAddress("172.16.1.1").value) leaf = self.stats[key] self.assertEqual(leaf.rx_pkts, 100) self.assertEqual(leaf.tx_pkts, 100) del self.stats[key] with self.assertRaises(KeyError): x = self.stats[key] with self.assertRaises(KeyError): del self.stats[key] self.stats.clear() self.assertEqual(len(self.stats), 0) self.stats[key] = leaf self.assertEqual(len(self.stats), 1) self.stats.clear() self.assertEqual(len(self.stats), 0) def test_empty_key(self): # test with a 0 key self.stats.clear() self.stats[self.stats.Key()] = self.stats.Leaf(100, 200) x = self.stats.popitem() self.stats[self.stats.Key(10, 20)] = self.stats.Leaf(300, 400) with self.assertRaises(KeyError): x = self.stats[self.stats.Key()] (_, x) = self.stats.popitem() self.assertEqual(x.rx_pkts, 300) self.assertEqual(x.tx_pkts, 400) self.stats.clear() self.assertEqual(len(self.stats), 0) self.stats[self.stats.Key()] = x self.stats[self.stats.Key(0, 1)] = x self.stats[self.stats.Key(0, 2)] = x self.stats[self.stats.Key(0, 3)] = x self.assertEqual(len(self.stats), 4) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_trace1.b000066400000000000000000000017031305314114400215430ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") struct Ptr { u64 ptr:64; }; struct Counters { u64 stat1:64; u64 stat2:64; }; Table stats(1024); // example with on_valid syntax u32 sys_wr (struct proto::pt_regs *ctx) { struct Ptr key = {.ptr=ctx->di}; struct Counters *leaf; leaf = stats[key]; if leaf { atomic_add(leaf->stat2, 1); } log("sys_wr: %p\n", ctx->di); return 0; } // example with smallest available syntax // note: if stats[key] fails, program returns early u32 sys_rd (struct proto::pt_regs *ctx) { struct Ptr key = {.ptr=ctx->di}; atomic_add(stats[key].stat1, 1); } // example with if/else case u32 sys_bpf (struct proto::pt_regs *ctx) { struct Ptr key = {.ptr=ctx->di}; struct Counters *leaf; leaf = stats[key]; if leaf { atomic_add(leaf->stat1, 1); } else { log("update %llx failed\n", ctx->di); } return 0; } bpfcc-0.2.0+git0.02884a026/tests/python/test_trace1.py000077500000000000000000000025471305314114400217640ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from ctypes import c_uint, c_ulong, Structure from bcc import BPF import os from time import sleep import sys from unittest import main, TestCase arg1 = sys.argv.pop(1) arg2 = "" if len(sys.argv) > 1: arg2 = sys.argv.pop(1) Key = None Leaf = None if arg1.endswith(".b"): class Key(Structure): _fields_ = [("fd", c_ulong)] class Leaf(Structure): _fields_ = [("stat1", c_ulong), ("stat2", c_ulong)] class TestKprobe(TestCase): def setUp(self): b = BPF(arg1, arg2, debug=0) self.stats = b.get_table("stats", Key, Leaf) b.attach_kprobe(event="sys_write", fn_name="sys_wr", pid=0, cpu=-1) b.attach_kprobe(event="sys_read", fn_name="sys_rd", pid=0, cpu=-1) b.attach_kprobe(event="htab_map_get_next_key", fn_name="sys_rd", pid=0, cpu=-1) def test_trace1(self): with open("/dev/null", "a") as f: for i in range(0, 100): os.write(f.fileno(), b"") with open("/etc/services", "r") as f: for i in range(0, 200): os.read(f.fileno(), 1) for key, leaf in self.stats.items(): print("fd %x:" % key.fd, "stat1 %d" % leaf.stat1, "stat2 %d" % leaf.stat2) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_trace2.b000066400000000000000000000005421305314114400215440ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include "kprobe.b" struct Ptr { u64 ptr:64; }; struct Counters { u64 stat1:64; }; Table stats(1024); u32 count_sched (struct proto::pt_regs *ctx) { struct Ptr key = {.ptr=ctx->bx}; atomic_add(stats[key].stat1, 1); } bpfcc-0.2.0+git0.02884a026/tests/python/test_trace2.c000066400000000000000000000006461305314114400215520ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include struct Ptr { u64 ptr; }; struct Counters { u64 stat1; }; BPF_TABLE("hash", struct Ptr, struct Counters, stats, 1024); int count_sched(struct pt_regs *ctx) { struct Ptr key = {.ptr = PT_REGS_PARM1(ctx)}; struct Counters zleaf = {0}; stats.lookup_or_init(&key, &zleaf)->stat1++; return 0; } bpfcc-0.2.0+git0.02884a026/tests/python/test_trace2.py000077500000000000000000000020311305314114400217510ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from ctypes import c_uint, c_ulong, Structure from bcc import BPF from time import sleep import sys from unittest import main, TestCase text = """ #include struct Ptr { u64 ptr; }; struct Counters { u64 stat1; }; BPF_TABLE("hash", struct Ptr, struct Counters, stats, 1024); int count_sched(struct pt_regs *ctx) { struct Ptr key = {.ptr=PT_REGS_PARM1(ctx)}; struct Counters zleaf = {0}; stats.lookup_or_init(&key, &zleaf)->stat1++; return 0; } """ class TestTracingEvent(TestCase): def setUp(self): b = BPF(text=text, debug=0) self.stats = b.get_table("stats") b.attach_kprobe(event="finish_task_switch", fn_name="count_sched", pid=0, cpu=-1) def test_sched1(self): for i in range(0, 100): sleep(0.01) for key, leaf in self.stats.items(): print("ptr %x:" % key.ptr, "stat1 %d" % leaf.stat1) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_trace3.c000066400000000000000000000025711305314114400215520ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include #include struct Request { u64 rq; }; struct Time { u64 start; }; BPF_TABLE("hash", struct Request, struct Time, requests, 1024); #define SLOTS 100 BPF_TABLE("array", u32, u64, latency, SLOTS); static u32 log2(u32 v) { u32 r, shift; r = (v > 0xFFFF) << 4; v >>= r; shift = (v > 0xFF) << 3; v >>= shift; r |= shift; shift = (v > 0xF) << 2; v >>= shift; r |= shift; shift = (v > 0x3) << 1; v >>= shift; r |= shift; r |= (v >> 1); return r; } static u32 log2l(u64 v) { u32 hi = v >> 32; if (hi) return log2(hi) + 32; else return log2(v); } int probe_blk_start_request(struct pt_regs *ctx) { struct Request rq = {.rq = PT_REGS_PARM1(ctx)}; struct Time tm = {.start = bpf_ktime_get_ns()}; requests.update(&rq, &tm); return 0; } int probe_blk_update_request(struct pt_regs *ctx) { struct Request rq = {.rq = PT_REGS_PARM1(ctx)}; struct Time *tm = requests.lookup(&rq); if (!tm) return 0; u64 delta = bpf_ktime_get_ns() - tm->start; requests.delete(&rq); u64 lg = log2l(delta); u64 base = 1ull << lg; u32 index = (lg * 64 + (delta - base) * 64 / base) * 3 / 64; if (index >= SLOTS) index = SLOTS - 1; u64 zero = 0; u64 *val = latency.lookup_or_init(&index, &zero); lock_xadd(val, 1); return 0; } bpfcc-0.2.0+git0.02884a026/tests/python/test_trace3.py000077500000000000000000000025101305314114400217540ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from ctypes import c_uint, c_ulong, Structure from bcc import BPF from time import sleep import sys from unittest import main, TestCase arg1 = sys.argv.pop(1) arg2 = "" if len(sys.argv) > 1: arg2 = sys.argv.pop(1) class TestBlkRequest(TestCase): def setUp(self): b = BPF(arg1, arg2, debug=0) self.latency = b.get_table("latency", c_uint, c_ulong) b.attach_kprobe(event="blk_start_request", fn_name="probe_blk_start_request", pid=-1, cpu=0) b.attach_kprobe(event="blk_update_request", fn_name="probe_blk_update_request", pid=-1, cpu=0) def test_blk1(self): import subprocess import os # use /opt instead of /tmp so that it hits a real disk for i in range(0, 2): subprocess.call(["dd", "if=/dev/zero", "of=/opt/trace3.txt", "count=1024", "bs=4096"]) subprocess.call(["sync"]) os.unlink("/opt/trace3.txt") for key, leaf in self.latency.items(): print("latency %u:" % key.value, "count %u" % leaf.value) sys.stdout.flush() self.assertEqual(len(list(self.latency.keys())), len(self.latency)) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_trace4.py000077500000000000000000000023421305314114400217600ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from bcc import BPF import os import sys from unittest import main, TestCase class TestKprobeRgx(TestCase): def setUp(self): self.b = BPF(text=""" typedef struct { int idx; } Key; typedef struct { u64 val; } Val; BPF_TABLE("hash", Key, Val, stats, 3); int hello(void *ctx) { stats.lookup_or_init(&(Key){1}, &(Val){0})->val++; return 0; } int goodbye(void *ctx) { stats.lookup_or_init(&(Key){2}, &(Val){0})->val++; return 0; } """) self.b.attach_kprobe(event_re="^SyS_bp.*", fn_name="hello") self.b.attach_kretprobe(event_re="^SyS_bp.*", fn_name="goodbye") def test_send1(self): k1 = self.b["stats"].Key(1) k2 = self.b["stats"].Key(2) self.assertEqual(self.b["stats"][k1].val, self.b["stats"][k2].val + 1) class TestKprobeReplace(TestCase): def setUp(self): self.b = BPF(text="int empty(void *ctx) { return 0; }") def test_periods(self): self.b.attach_kprobe(event_re="^tcp_enter_cwr.*", fn_name="empty") if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/python/test_tracepoint.py000077500000000000000000000041201305314114400227420ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) Sasha Goldshtein # Licensed under the Apache License, Version 2.0 (the "License") import bcc import unittest from time import sleep import distutils.version import os import subprocess def kernel_version_ge(major, minor): # True if running kernel is >= X.Y version = distutils.version.LooseVersion(os.uname()[2]).version if version[0] > major: return True if version[0] < major: return False if minor and version[1] < minor: return False return True @unittest.skipUnless(kernel_version_ge(4,7), "requires kernel >= 4.7") class TestTracepoint(unittest.TestCase): def test_tracepoint(self): text = """ BPF_HASH(switches, u32, u64); TRACEPOINT_PROBE(sched, sched_switch) { u64 val = 0; u32 pid = args->next_pid; u64 *existing = switches.lookup_or_init(&pid, &val); (*existing)++; return 0; } """ b = bcc.BPF(text=text) sleep(1) total_switches = 0 for k, v in b["switches"].items(): total_switches += v.value self.assertNotEqual(0, total_switches) @unittest.skipUnless(kernel_version_ge(4,7), "requires kernel >= 4.7") class TestTracepointDataLoc(unittest.TestCase): def test_tracepoint_data_loc(self): text = """ struct value_t { char filename[64]; }; BPF_HASH(execs, u32, struct value_t); TRACEPOINT_PROBE(sched, sched_process_exec) { struct value_t val = {0}; char fn[64]; u32 pid = args->pid; struct value_t *existing = execs.lookup_or_init(&pid, &val); TP_DATA_LOC_READ_CONST(fn, filename, 64); __builtin_memcpy(existing->filename, fn, 64); return 0; } """ b = bcc.BPF(text=text) subprocess.check_output(["/bin/ls"]) sleep(1) self.assertTrue("/bin/ls" in [v.filename.decode() for v in b["execs"].values()]) if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_uprobes.py000077500000000000000000000040201305314114400222500ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") import bcc import ctypes import os import unittest class TestUprobes(unittest.TestCase): def test_simple_library(self): text = """ #include BPF_TABLE("array", int, u64, stats, 1); static void incr(int idx) { u64 *ptr = stats.lookup(&idx); if (ptr) ++(*ptr); } int count(struct pt_regs *ctx) { bpf_trace_printk("count() uprobe fired"); u32 pid = bpf_get_current_pid_tgid(); if (pid == PID) incr(0); return 0; }""" test_pid = os.getpid() text = text.replace("PID", "%d" % test_pid) b = bcc.BPF(text=text) b.attach_uprobe(name="c", sym="malloc_stats", fn_name="count", pid=test_pid) b.attach_uretprobe(name="c", sym="malloc_stats", fn_name="count", pid=test_pid) libc = ctypes.CDLL("libc.so.6") libc.malloc_stats.restype = None libc.malloc_stats.argtypes = [] libc.malloc_stats() self.assertEqual(b["stats"][ctypes.c_int(0)].value, 2) b.detach_uretprobe(name="c", sym="malloc_stats", pid=test_pid) b.detach_uprobe(name="c", sym="malloc_stats", pid=test_pid) def test_simple_binary(self): text = """ #include BPF_TABLE("array", int, u64, stats, 1); static void incr(int idx) { u64 *ptr = stats.lookup(&idx); if (ptr) ++(*ptr); } int count(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); incr(0); return 0; }""" b = bcc.BPF(text=text) b.attach_uprobe(name="/usr/bin/python", sym="main", fn_name="count") b.attach_uretprobe(name="/usr/bin/python", sym="main", fn_name="count") with os.popen("/usr/bin/python -V") as f: pass self.assertGreater(b["stats"][ctypes.c_int(0)].value, 0) b.detach_uretprobe(name="/usr/bin/python", sym="main") b.detach_uprobe(name="/usr/bin/python", sym="main") if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_utils.py000077500000000000000000000007111305314114400217340ustar00rootroot00000000000000#!/usr/bin/python # Copyright (c) Catalysts GmbH # Licensed under the Apache License, Version 2.0 (the "License") from bcc.utils import get_online_cpus import multiprocessing import unittest class TestUtils(unittest.TestCase): def test_get_online_cpus(self): online_cpus = get_online_cpus() num_cores = multiprocessing.cpu_count() self.assertEqual(len(online_cpus), num_cores) if __name__ == "__main__": unittest.main() bpfcc-0.2.0+git0.02884a026/tests/python/test_xlate1.b000066400000000000000000000026221305314114400215630ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") // test for packet modification #packed "false" struct IPKey { u32 dip:32; u32 sip:32; }; struct IPLeaf { u32 xdip:32; u32 xsip:32; u64 xlated_pkts:64; }; Table xlate(1024); struct skbuff { u32 type:32; }; u32 on_packet (struct skbuff *skb) { u32 ret:32 = 1; u32 orig_dip:32 = 0; u32 orig_sip:32 = 0; struct IPLeaf *xleaf; goto proto::ethernet; state proto::ethernet { } state proto::dot1q { } state proto::ip { orig_dip = $ip.dst; orig_sip = $ip.src; struct IPKey key = {.dip=orig_dip, .sip=orig_sip}; xlate.lookup(key, xleaf) {}; on_valid(xleaf) { incr_cksum(@ip.hchecksum, orig_dip, xleaf.xdip); incr_cksum(@ip.hchecksum, orig_sip, xleaf.xsip); // the below are equivalent pkt.rewrite_field($ip.dst, xleaf.xdip); $ip.src = xleaf.xsip; atomic_add(xleaf.xlated_pkts, 1); } } state proto::udp { on_valid(xleaf) { incr_cksum(@udp.crc, orig_dip, xleaf.xdip, 1); incr_cksum(@udp.crc, orig_sip, xleaf.xsip, 1); } } state proto::tcp { on_valid(xleaf) { incr_cksum(@tcp.cksum, orig_dip, xleaf.xdip, 1); incr_cksum(@tcp.cksum, orig_sip, xleaf.xsip, 1); } } state proto::vxlan { } state proto::gre { } state EOP { return ret; } } bpfcc-0.2.0+git0.02884a026/tests/python/test_xlate1.c000066400000000000000000000045041305314114400215650ustar00rootroot00000000000000// Copyright (c) PLUMgrid, Inc. // Licensed under the Apache License, Version 2.0 (the "License") #include struct IPKey { u32 dip; u32 sip; }; struct IPLeaf { u32 xdip; u32 xsip; u64 ip_xlated_pkts; u64 arp_xlated_pkts; }; BPF_TABLE("hash", struct IPKey, struct IPLeaf, xlate, 1024); int on_packet(struct __sk_buff *skb) { u8 *cursor = 0; u32 orig_dip = 0; u32 orig_sip = 0; struct IPLeaf xleaf = {}; ethernet: { struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet)); switch (ethernet->type) { case ETH_P_IP: goto ip; case ETH_P_ARP: goto arp; case ETH_P_8021Q: goto dot1q; default: goto EOP; } } dot1q: { struct dot1q_t *dot1q = cursor_advance(cursor, sizeof(*dot1q)); switch (dot1q->type) { case ETH_P_IP: goto ip; case ETH_P_ARP: goto arp; default: goto EOP; } } arp: { struct arp_t *arp = cursor_advance(cursor, sizeof(*arp)); orig_dip = arp->tpa; orig_sip = arp->spa; struct IPKey key = {.dip=orig_dip, .sip=orig_sip}; struct IPLeaf *xleafp = xlate.lookup(&key); if (xleafp) { xleaf = *xleafp; arp->tpa = xleaf.xdip; arp->spa = xleaf.xsip; lock_xadd(&xleafp->arp_xlated_pkts, 1); } goto EOP; } ip: { struct ip_t *ip = cursor_advance(cursor, sizeof(*ip)); orig_dip = ip->dst; orig_sip = ip->src; struct IPKey key = {.dip=orig_dip, .sip=orig_sip}; struct IPLeaf *xleafp = xlate.lookup(&key); if (xleafp) { xleaf = *xleafp; ip->dst = xleaf.xdip; incr_cksum_l3(&ip->hchecksum, orig_dip, xleaf.xdip); ip->src = xleaf.xsip; incr_cksum_l3(&ip->hchecksum, orig_sip, xleaf.xsip); lock_xadd(&xleafp->ip_xlated_pkts, 1); } switch (ip->nextp) { case 6: goto tcp; case 17: goto udp; default: goto EOP; } } udp: { struct udp_t *udp = cursor_advance(cursor, sizeof(*udp)); if (xleaf.xdip) { incr_cksum_l4(&udp->crc, orig_dip, xleaf.xdip, 1); incr_cksum_l4(&udp->crc, orig_sip, xleaf.xsip, 1); } goto EOP; } tcp: { struct tcp_t *tcp = cursor_advance(cursor, sizeof(*tcp)); if (xleaf.xdip) { incr_cksum_l4(&tcp->cksum, orig_dip, xleaf.xdip, 1); incr_cksum_l4(&tcp->cksum, orig_sip, xleaf.xsip, 1); } goto EOP; } EOP: return 0; } bpfcc-0.2.0+git0.02884a026/tests/python/test_xlate1.py000077500000000000000000000046621305314114400220030ustar00rootroot00000000000000#!/usr/bin/env python # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") from netaddr import IPAddress from bcc import BPF from pyroute2 import IPRoute, protocols from socket import socket, AF_INET, SOCK_DGRAM from subprocess import call import sys from time import sleep from unittest import main, TestCase arg1 = sys.argv.pop(1) arg2 = "" if len(sys.argv) > 1: arg2 = sys.argv.pop(1) class TestBPFFilter(TestCase): def setUp(self): b = BPF(arg1, arg2, debug=0) fn = b.load_func("on_packet", BPF.SCHED_ACT) ip = IPRoute() ifindex = ip.link_lookup(ifname="eth0")[0] # set up a network to change the flow: # outside | inside # 172.16.1.1 - 172.16.1.2 | 192.168.1.1 - 192.16.1.2 ip.addr("del", index=ifindex, address="172.16.1.2", mask=24) ip.addr("add", index=ifindex, address="192.168.1.2", mask=24) # add an ingress and egress qdisc ip.tc("add", "ingress", ifindex, "ffff:") ip.tc("add", "sfq", ifindex, "1:") # add same program to both ingress/egress, so pkt is translated in both directions action = {"kind": "bpf", "fd": fn.fd, "name": fn.name, "action": "ok"} ip.tc("add-filter", "u32", ifindex, ":1", parent="ffff:", action=[action], protocol=protocols.ETH_P_ALL, classid=1, target=0x10002, keys=['0x0/0x0+0']) ip.tc("add-filter", "u32", ifindex, ":2", parent="1:", action=[action], protocol=protocols.ETH_P_ALL, classid=1, target=0x10002, keys=['0x0/0x0+0']) self.xlate = b.get_table("xlate") def test_xlate(self): key1 = self.xlate.Key(IPAddress("172.16.1.2").value, IPAddress("172.16.1.1").value) leaf1 = self.xlate.Leaf(IPAddress("192.168.1.2").value, IPAddress("192.168.1.1").value, 0, 0) self.xlate[key1] = leaf1 key2 = self.xlate.Key(IPAddress("192.168.1.1").value, IPAddress("192.168.1.2").value) leaf2 = self.xlate.Leaf(IPAddress("172.16.1.1").value, IPAddress("172.16.1.2").value, 0, 0) self.xlate[key2] = leaf2 call(["ping", "-c1", "192.168.1.1"]) leaf = self.xlate[key1] self.assertGreater(leaf.ip_xlated_pkts, 0) self.assertGreater(leaf.arp_xlated_pkts, 0) leaf = self.xlate[key2] self.assertGreater(leaf.ip_xlated_pkts, 0) self.assertGreater(leaf.arp_xlated_pkts, 0) if __name__ == "__main__": main() bpfcc-0.2.0+git0.02884a026/tests/wrapper.sh.in000077500000000000000000000025601305314114400202670ustar00rootroot00000000000000#!/bin/bash # Copyright (c) PLUMgrid, Inc. # Licensed under the Apache License, Version 2.0 (the "License") #set -x name=$1; shift kind=$1; shift cmd=$1; shift PYTHONPATH=@CMAKE_SOURCE_DIR@/src/python LD_LIBRARY_PATH=@CMAKE_BINARY_DIR@:@CMAKE_BINARY_DIR@/src/cc ns=$name function cleanup() { trap - EXIT if [[ "$kind" = "namespace" ]]; then sudo ip netns delete $ns fi } trap cleanup EXIT function ns_run() { sudo ip netns add $ns sudo ip link add $ns.in type veth peer name $ns.out sudo ip link set $ns.in netns $ns sudo ip netns exec $ns ip link set $ns.in name eth0 sudo ip netns exec $ns ip addr add dev eth0 172.16.1.2/24 sudo ip netns exec $ns ip link set eth0 up sudo ip netns exec $ns ethtool -K eth0 tx off sudo ip addr add dev $ns.out 172.16.1.1/24 sudo ip link set $ns.out up sudo bash -c "PYTHONPATH=$PYTHONPATH LD_LIBRARY_PATH=$LD_LIBRARY_PATH ip netns exec $ns $cmd $1 $2" return $? } function sudo_run() { sudo bash -c "PYTHONPATH=$PYTHONPATH LD_LIBRARY_PATH=$LD_LIBRARY_PATH $cmd $1 $2" return $? } function simple_run() { PYTHONPATH=$PYTHONPATH LD_LIBRARY_PATH=$LD_LIBRARY_PATH $cmd $1 $2 return $? } case $kind in namespace) ns_run $@ ;; sudo) sudo_run $@ ;; simple) simple_run $@ ;; *) echo "Invalid kind $kind" exit 1 ;; esac [[ $? -ne 0 ]] && { echo "Failed"; exit 1; } exit 0 bpfcc-0.2.0+git0.02884a026/tools/000077500000000000000000000000001305314114400156365ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tools/CMakeLists.txt000066400000000000000000000006361305314114400204030ustar00rootroot00000000000000file(GLOB C_FILES *.c) file(GLOB PY_FILES *.py) file(GLOB TXT_FILES *.txt) list(REMOVE_ITEM TXT_FILES "CMakeLists.txt") foreach(FIL ${PY_FILES}) get_filename_component(FIL_WE ${FIL} NAME_WE) install(PROGRAMS ${FIL} DESTINATION share/bcc/tools RENAME ${FIL_WE}) endforeach() install(FILES ${C_FILES} DESTINATION share/bcc/tools) install(FILES ${TXT_FILES} DESTINATION share/bcc/tools/doc) add_subdirectory(old) bpfcc-0.2.0+git0.02884a026/tools/argdist.py000077500000000000000000001012001305314114400176420ustar00rootroot00000000000000#!/usr/bin/env python # # argdist Trace a function and display a distribution of its # parameter values as a histogram or frequency count. # # USAGE: argdist [-h] [-p PID] [-z STRING_SIZE] [-i INTERVAL] [-n COUNT] [-v] # [-c] [-T TOP] [-C specifier] [-H specifier] [-I header] # # Licensed under the Apache License, Version 2.0 (the "License") # Copyright (C) 2016 Sasha Goldshtein. from bcc import BPF, USDT from time import sleep, strftime import argparse import re import traceback import os import sys class Probe(object): next_probe_index = 0 streq_index = 0 aliases = {"$PID": "(bpf_get_current_pid_tgid() >> 32)"} def _substitute_aliases(self, expr): if expr is None: return expr for alias, subst in Probe.aliases.items(): expr = expr.replace(alias, subst) return expr def _parse_signature(self): params = map(str.strip, self.signature.split(',')) self.param_types = {} for param in params: # If the type is a pointer, the * can be next to the # param name. Other complex types like arrays are not # supported right now. index = param.rfind('*') index = index if index != -1 else param.rfind(' ') param_type = param[0:index + 1].strip() param_name = param[index + 1:].strip() self.param_types[param_name] = param_type def _generate_entry(self): self.entry_probe_func = self.probe_func_name + "_entry" text = """ int PROBENAME(struct pt_regs *ctx SIGNATURE) { u64 __pid_tgid = bpf_get_current_pid_tgid(); u32 __pid = __pid_tgid; // lower 32 bits u32 __tgid = __pid_tgid >> 32; // upper 32 bits PID_FILTER COLLECT return 0; } """ text = text.replace("PROBENAME", self.entry_probe_func) text = text.replace("SIGNATURE", "" if len(self.signature) == 0 else ", " + self.signature) text = text.replace("PID_FILTER", self._generate_pid_filter()) collect = "" for pname in self.args_to_probe: param_hash = self.hashname_prefix + pname if pname == "__latency": collect += """ u64 __time = bpf_ktime_get_ns(); %s.update(&__pid, &__time); """ % param_hash else: collect += "%s.update(&__pid, &%s);\n" % \ (param_hash, pname) text = text.replace("COLLECT", collect) return text def _generate_entry_probe(self): # Any $entry(name) expressions result in saving that argument # when entering the function. self.args_to_probe = set() regex = r"\$entry\((\w+)\)" for expr in self.exprs: for arg in re.finditer(regex, expr): self.args_to_probe.add(arg.group(1)) for arg in re.finditer(regex, self.filter): self.args_to_probe.add(arg.group(1)) if any(map(lambda expr: "$latency" in expr, self.exprs)) or \ "$latency" in self.filter: self.args_to_probe.add("__latency") self.param_types["__latency"] = "u64" # nanoseconds for pname in self.args_to_probe: if pname not in self.param_types: raise ValueError("$entry(%s): no such param" % arg) self.hashname_prefix = "%s_param_" % self.probe_hash_name text = "" for pname in self.args_to_probe: # Each argument is stored in a separate hash that is # keyed by pid. text += "BPF_HASH(%s, u32, %s);\n" % \ (self.hashname_prefix + pname, self.param_types[pname]) text += self._generate_entry() return text def _generate_retprobe_prefix(self): # After we're done here, there are __%s_val variables for each # argument we needed to probe using $entry(name), and they all # have values (which isn't necessarily the case if we missed # the method entry probe). text = "" self.param_val_names = {} for pname in self.args_to_probe: val_name = "__%s_val" % pname text += "%s *%s = %s.lookup(&__pid);\n" % \ (self.param_types[pname], val_name, self.hashname_prefix + pname) text += "if (%s == 0) { return 0 ; }\n" % val_name self.param_val_names[pname] = val_name return text def _replace_entry_exprs(self): for pname, vname in self.param_val_names.items(): if pname == "__latency": entry_expr = "$latency" val_expr = "(bpf_ktime_get_ns() - *%s)" % vname else: entry_expr = "$entry(%s)" % pname val_expr = "(*%s)" % vname for i in range(0, len(self.exprs)): self.exprs[i] = self.exprs[i].replace( entry_expr, val_expr) self.filter = self.filter.replace(entry_expr, val_expr) def _attach_entry_probe(self): if self.is_user: self.bpf.attach_uprobe(name=self.library, sym=self.function, fn_name=self.entry_probe_func, pid=self.pid or -1) else: self.bpf.attach_kprobe(event=self.function, fn_name=self.entry_probe_func) def _bail(self, error): raise ValueError("error parsing probe '%s': %s" % (self.raw_spec, error)) def _validate_specifier(self): # Everything after '#' is the probe label, ignore it spec = self.raw_spec.split('#')[0] parts = spec.strip().split(':') if len(parts) < 3: self._bail("at least the probe type, library, and " + "function signature must be specified") if len(parts) > 6: self._bail("extraneous ':'-separated parts detected") if parts[0] not in ["r", "p", "t", "u"]: self._bail("probe type must be 'p', 'r', 't', or 'u'" + " but got '%s'" % parts[0]) if re.match(r"\S+\(.*\)", parts[2]) is None: self._bail(("function signature '%s' has an invalid " + "format") % parts[2]) def _parse_expr_types(self, expr_types): if len(expr_types) == 0: self._bail("no expr types specified") self.expr_types = expr_types.split(',') def _parse_exprs(self, exprs): if len(exprs) == 0: self._bail("no exprs specified") self.exprs = exprs.split(',') def _make_valid_identifier(self, ident): return re.sub(r'[^A-Za-z0-9_]', '_', ident) def __init__(self, tool, type, specifier): self.usdt_ctx = None self.streq_functions = "" self.pid = tool.args.pid self.cumulative = tool.args.cumulative or False self.raw_spec = specifier self._validate_specifier() spec_and_label = specifier.split('#') self.label = spec_and_label[1] \ if len(spec_and_label) == 2 else None parts = spec_and_label[0].strip().split(':') self.type = type # hist or freq self.probe_type = parts[0] fparts = parts[2].split('(') self.function = fparts[0].strip() if self.probe_type == "t": self.library = "" # kernel self.tp_category = parts[1] self.tp_event = self.function elif self.probe_type == "u": self.library = parts[1] self.probe_func_name = self._make_valid_identifier( "%s_probe%d" % \ (self.function, Probe.next_probe_index)) self._enable_usdt_probe() else: self.library = parts[1] self.is_user = len(self.library) > 0 self.signature = fparts[1].strip()[:-1] self._parse_signature() # If the user didn't specify an expression to probe, we probe # the retval in a ret probe, or simply the value "1" otherwise. self.is_default_expr = len(parts) < 5 if not self.is_default_expr: self._parse_expr_types(parts[3]) self._parse_exprs(parts[4]) if len(self.exprs) != len(self.expr_types): self._bail("mismatched # of exprs and types") if self.type == "hist" and len(self.expr_types) > 1: self._bail("histograms can only have 1 expr") else: if not self.probe_type == "r" and self.type == "hist": self._bail("histograms must have expr") self.expr_types = \ ["u64" if not self.probe_type == "r" else "int"] self.exprs = \ ["1" if not self.probe_type == "r" else "$retval"] self.filter = "" if len(parts) != 6 else parts[5] self._substitute_exprs() # Do we need to attach an entry probe so that we can collect an # argument that is required for an exit (return) probe? def check(expr): keywords = ["$entry", "$latency"] return any(map(lambda kw: kw in expr, keywords)) self.entry_probe_required = self.probe_type == "r" and \ (any(map(check, self.exprs)) or check(self.filter)) self.probe_func_name = self._make_valid_identifier( "%s_probe%d" % \ (self.function, Probe.next_probe_index)) self.probe_hash_name = self._make_valid_identifier( "%s_hash%d" % \ (self.function, Probe.next_probe_index)) Probe.next_probe_index += 1 def _enable_usdt_probe(self): self.usdt_ctx = USDT(path=self.library, pid=self.pid) self.usdt_ctx.enable_probe( self.function, self.probe_func_name) def _generate_streq_function(self, string): fname = "streq_%d" % Probe.streq_index Probe.streq_index += 1 self.streq_functions += """ static inline bool %s(char const *ignored, char const *str) { char needle[] = %s; char haystack[sizeof(needle)]; bpf_probe_read(&haystack, sizeof(haystack), (void *)str); for (int i = 0; i < sizeof(needle) - 1; ++i) { if (needle[i] != haystack[i]) { return false; } } return true; } """ % (fname, string) return fname def _substitute_exprs(self): def repl(expr): expr = self._substitute_aliases(expr) matches = re.finditer('STRCMP\\(("[^"]+\\")', expr) for match in matches: string = match.group(1) fname = self._generate_streq_function(string) expr = expr.replace("STRCMP", fname, 1) return expr.replace("$retval", "PT_REGS_RC(ctx)") for i in range(0, len(self.exprs)): self.exprs[i] = repl(self.exprs[i]) self.filter = repl(self.filter) def _is_string(self, expr_type): return expr_type == "char*" or expr_type == "char *" def _generate_hash_field(self, i): if self._is_string(self.expr_types[i]): return "struct __string_t v%d;\n" % i else: return "%s v%d;\n" % (self.expr_types[i], i) def _generate_usdt_arg_assignment(self, i): expr = self.exprs[i] if self.probe_type == "u" and expr[0:3] == "arg": arg_index = int(expr[3]) arg_ctype = self.usdt_ctx.get_probe_arg_ctype( self.function, arg_index - 1) return (" %s %s = 0;\n" + " bpf_usdt_readarg(%s, ctx, &%s);\n") \ % (arg_ctype, expr, expr[3], expr) else: return "" def _generate_field_assignment(self, i): text = self._generate_usdt_arg_assignment(i) if self._is_string(self.expr_types[i]): return (text + " bpf_probe_read(&__key.v%d.s," + " sizeof(__key.v%d.s), (void *)%s);\n") % \ (i, i, self.exprs[i]) else: return text + " __key.v%d = %s;\n" % \ (i, self.exprs[i]) def _generate_hash_decl(self): if self.type == "hist": return "BPF_HISTOGRAM(%s, %s);" % \ (self.probe_hash_name, self.expr_types[0]) else: text = "struct %s_key_t {\n" % self.probe_hash_name for i in range(0, len(self.expr_types)): text += self._generate_hash_field(i) text += "};\n" text += "BPF_HASH(%s, struct %s_key_t, u64);\n" % \ (self.probe_hash_name, self.probe_hash_name) return text def _generate_key_assignment(self): if self.type == "hist": return self._generate_usdt_arg_assignment(0) + \ ("%s __key = %s;\n" % (self.expr_types[0], self.exprs[0])) else: text = "struct %s_key_t __key = {};\n" % \ self.probe_hash_name for i in range(0, len(self.exprs)): text += self._generate_field_assignment(i) return text def _generate_hash_update(self): if self.type == "hist": return "%s.increment(bpf_log2l(__key));" % \ self.probe_hash_name else: return "%s.increment(__key);" % self.probe_hash_name def _generate_pid_filter(self): # Kernel probes need to explicitly filter pid, because the # attach interface doesn't support pid filtering if self.pid is not None and not self.is_user: return "if (__tgid != %d) { return 0; }" % self.pid else: return "" def generate_text(self): program = "" probe_text = """ DATA_DECL """ + ( "TRACEPOINT_PROBE(%s, %s)" % (self.tp_category, self.tp_event) if self.probe_type == "t" else "int PROBENAME(struct pt_regs *ctx SIGNATURE)") + """ { u64 __pid_tgid = bpf_get_current_pid_tgid(); u32 __pid = __pid_tgid; // lower 32 bits u32 __tgid = __pid_tgid >> 32; // upper 32 bits PID_FILTER PREFIX if (!(FILTER)) return 0; KEY_EXPR COLLECT return 0; } """ prefix = "" signature = "" # If any entry arguments are probed in a ret probe, we need # to generate an entry probe to collect them if self.entry_probe_required: program += self._generate_entry_probe() prefix += self._generate_retprobe_prefix() # Replace $entry(paramname) with a reference to the # value we collected when entering the function: self._replace_entry_exprs() if self.probe_type == "p" and len(self.signature) > 0: # Only entry uprobes/kprobes can have user-specified # signatures. Other probes force it to (). signature = ", " + self.signature program += probe_text.replace("PROBENAME", self.probe_func_name) program = program.replace("SIGNATURE", signature) program = program.replace("PID_FILTER", self._generate_pid_filter()) decl = self._generate_hash_decl() key_expr = self._generate_key_assignment() collect = self._generate_hash_update() program = program.replace("DATA_DECL", decl) program = program.replace("KEY_EXPR", key_expr) program = program.replace("FILTER", "1" if len(self.filter) == 0 else self.filter) program = program.replace("COLLECT", collect) program = program.replace("PREFIX", prefix) return self.streq_functions + program def _attach_u(self): libpath = BPF.find_library(self.library) if libpath is None: libpath = BPF.find_exe(self.library) if libpath is None or len(libpath) == 0: self._bail("unable to find library %s" % self.library) if self.probe_type == "r": self.bpf.attach_uretprobe(name=libpath, sym=self.function, fn_name=self.probe_func_name, pid=self.pid or -1) else: self.bpf.attach_uprobe(name=libpath, sym=self.function, fn_name=self.probe_func_name, pid=self.pid or -1) def _attach_k(self): if self.probe_type == "t": pass # Nothing to do for tracepoints elif self.probe_type == "r": self.bpf.attach_kretprobe(event=self.function, fn_name=self.probe_func_name) else: self.bpf.attach_kprobe(event=self.function, fn_name=self.probe_func_name) def attach(self, bpf): self.bpf = bpf if self.probe_type == "u": return if self.is_user: self._attach_u() else: self._attach_k() if self.entry_probe_required: self._attach_entry_probe() def _v2s(self, v): # Most fields can be converted with plain str(), but strings # are wrapped in a __string_t which has an .s field if "__string_t" in type(v).__name__: return str(v.s) return str(v) def _display_expr(self, i): # Replace ugly latency calculation with $latency expr = self.exprs[i].replace( "(bpf_ktime_get_ns() - *____latency_val)", "$latency") # Replace alias values back with the alias name for alias, subst in Probe.aliases.items(): expr = expr.replace(subst, alias) # Replace retval expression with $retval expr = expr.replace("PT_REGS_RC(ctx)", "$retval") # Replace ugly (*__param_val) expressions with param name return re.sub(r"\(\*__(\w+)_val\)", r"\1", expr) def _display_key(self, key): if self.is_default_expr: if not self.probe_type == "r": return "total calls" else: return "retval = %s" % str(key.v0) else: # The key object has v0, ..., vk fields containing # the values of the expressions from self.exprs def str_i(i): key_i = self._v2s(getattr(key, "v%d" % i)) return "%s = %s" % \ (self._display_expr(i), key_i) return ", ".join(map(str_i, range(0, len(self.exprs)))) def display(self, top): data = self.bpf.get_table(self.probe_hash_name) if self.type == "freq": print(self.label or self.raw_spec) print("\t%-10s %s" % ("COUNT", "EVENT")) sdata = sorted(data.items(), key=lambda p: p[1].value) if top is not None: sdata = sdata[-top:] for key, value in sdata: # Print some nice values if the user didn't # specify an expression to probe if self.is_default_expr: if not self.probe_type == "r": key_str = "total calls" else: key_str = "retval = %s" % \ self._v2s(key.v0) else: key_str = self._display_key(key) print("\t%-10s %s" % (str(value.value), key_str)) elif self.type == "hist": label = self.label or (self._display_expr(0) if not self.is_default_expr else "retval") data.print_log2_hist(val_type=label) if not self.cumulative: data.clear() def __str__(self): return self.label or self.raw_spec class Tool(object): examples = """ Probe specifier syntax: {p,r,t,u}:{[library],category}:function(signature)[:type[,type...]:expr[,expr...][:filter]][#label] Where: p,r,t,u -- probe at function entry, function exit, kernel tracepoint, or USDT probe in exit probes: can use $retval, $entry(param), $latency library -- the library that contains the function (leave empty for kernel functions) category -- the category of the kernel tracepoint (e.g. net, sched) function -- the function name to trace (or tracepoint name) signature -- the function's parameters, as in the C header type -- the type of the expression to collect (supports multiple) expr -- the expression to collect (supports multiple) filter -- the filter that is applied to collected values label -- the label for this probe in the resulting output EXAMPLES: argdist -H 'p::__kmalloc(u64 size):u64:size' Print a histogram of allocation sizes passed to kmalloc argdist -p 1005 -C 'p:c:malloc(size_t size):size_t:size:size==16' Print a frequency count of how many times process 1005 called malloc with an allocation size of 16 bytes argdist -C 'r:c:gets():char*:(char*)$retval#snooped strings' Snoop on all strings returned by gets() argdist -H 'r::__kmalloc(size_t size):u64:$latency/$entry(size)#ns per byte' Print a histogram of nanoseconds per byte from kmalloc allocations argdist -C 'p::__kmalloc(size_t sz, gfp_t flags):size_t:sz:flags&GFP_ATOMIC' Print frequency count of kmalloc allocation sizes that have GFP_ATOMIC argdist -p 1005 -C 'p:c:write(int fd):int:fd' -T 5 Print frequency counts of how many times writes were issued to a particular file descriptor number, in process 1005, but only show the top 5 busiest fds argdist -p 1005 -H 'r:c:read()' Print a histogram of results (sizes) returned by read() in process 1005 argdist -C 'r::__vfs_read():u32:$PID:$latency > 100000' Print frequency of reads by process where the latency was >0.1ms argdist -H 'r::__vfs_read(void *file, void *buf, size_t count):size_t $entry(count):$latency > 1000000' Print a histogram of read sizes that were longer than 1ms argdist -H \\ 'p:c:write(int fd, const void *buf, size_t count):size_t:count:fd==1' Print a histogram of buffer sizes passed to write() across all processes, where the file descriptor was 1 (STDOUT) argdist -C 'p:c:fork()#fork calls' Count fork() calls in libc across all processes Can also use funccount.py, which is easier and more flexible argdist -H 't:block:block_rq_complete():u32:args->nr_sector' Print histogram of number of sectors in completing block I/O requests argdist -C 't:irq:irq_handler_entry():int:args->irq' Aggregate interrupts by interrupt request (IRQ) argdist -C 'u:pthread:pthread_start():u64:arg2' -p 1337 Print frequency of function addresses used as a pthread start function, relying on the USDT pthread_start probe in process 1337 argdist -H 'p:c:sleep(u32 seconds):u32:seconds' \\ -H 'p:c:nanosleep(struct timespec *req):long:req->tv_nsec' Print histograms of sleep() and nanosleep() parameter values argdist -p 2780 -z 120 \\ -C 'p:c:write(int fd, char* buf, size_t len):char*:buf:fd==1' Spy on writes to STDOUT performed by process 2780, up to a string size of 120 characters """ def __init__(self): parser = argparse.ArgumentParser(description="Trace a " + "function and display a summary of its parameter values.", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=Tool.examples) parser.add_argument("-p", "--pid", type=int, help="id of the process to trace (optional)") parser.add_argument("-z", "--string-size", default=80, type=int, help="maximum string size to read from char* arguments") parser.add_argument("-i", "--interval", default=1, type=int, help="output interval, in seconds") parser.add_argument("-n", "--number", type=int, dest="count", help="number of outputs") parser.add_argument("-v", "--verbose", action="store_true", help="print resulting BPF program code before executing") parser.add_argument("-c", "--cumulative", action="store_true", help="do not clear histograms and freq counts at " + "each interval") parser.add_argument("-T", "--top", type=int, help="number of top results to show (not applicable to " + "histograms)") parser.add_argument("-H", "--histogram", action="append", dest="histspecifier", metavar="specifier", help="probe specifier to capture histogram of " + "(see examples below)") parser.add_argument("-C", "--count", action="append", dest="countspecifier", metavar="specifier", help="probe specifier to capture count of " + "(see examples below)") parser.add_argument("-I", "--include", action="append", metavar="header", help="additional header files to include in the BPF program " "as either full path, or relative to '/usr/include'") self.args = parser.parse_args() self.usdt_ctx = None def _create_probes(self): self.probes = [] for specifier in (self.args.countspecifier or []): self.probes.append(Probe(self, "freq", specifier)) for histspecifier in (self.args.histspecifier or []): self.probes.append(Probe(self, "hist", histspecifier)) if len(self.probes) == 0: print("at least one specifier is required") exit() def _generate_program(self): bpf_source = """ struct __string_t { char s[%d]; }; #include """ % self.args.string_size for include in (self.args.include or []): if include.startswith((".", "/")): include = os.path.abspath(include) bpf_source += "#include \"%s\"\n" % include else: bpf_source += "#include <%s>\n" % include bpf_source += BPF.generate_auto_includes( map(lambda p: p.raw_spec, self.probes)) for probe in self.probes: bpf_source += probe.generate_text() if self.args.verbose: for text in [probe.usdt_ctx.get_text() for probe in self.probes if probe.usdt_ctx]: print(text) print(bpf_source) usdt_contexts = [probe.usdt_ctx for probe in self.probes if probe.usdt_ctx] self.bpf = BPF(text=bpf_source, usdt_contexts=usdt_contexts) def _attach(self): for probe in self.probes: probe.attach(self.bpf) if self.args.verbose: print("open uprobes: %s" % self.bpf.open_uprobes) print("open kprobes: %s" % self.bpf.open_kprobes) def _main_loop(self): count_so_far = 0 while True: try: sleep(self.args.interval) except KeyboardInterrupt: exit() print("[%s]" % strftime("%H:%M:%S")) for probe in self.probes: probe.display(self.args.top) count_so_far += 1 if self.args.count is not None and \ count_so_far >= self.args.count: exit() def run(self): try: self._create_probes() self._generate_program() self._attach() self._main_loop() except: if self.args.verbose: traceback.print_exc() elif sys.exc_info()[0] is not SystemExit: print(sys.exc_info()[1]) if __name__ == "__main__": Tool().run() bpfcc-0.2.0+git0.02884a026/tools/argdist_example.txt000066400000000000000000000507721305314114400215620ustar00rootroot00000000000000Demonstrations of argdist. argdist probes functions you specify and collects parameter values into a histogram or a frequency count. This can be used to understand the distribution of values a certain parameter takes, filter and print interesting parameters without attaching a debugger, and obtain general execution statistics on various functions. For example, suppose you want to find what allocation sizes are common in your application: # ./argdist -p 2420 -c -C 'p:c:malloc(size_t size):size_t:size' [01:42:29] p:c:malloc(size_t size):size_t:size COUNT EVENT [01:42:30] p:c:malloc(size_t size):size_t:size COUNT EVENT [01:42:31] p:c:malloc(size_t size):size_t:size COUNT EVENT 1 size = 16 [01:42:32] p:c:malloc(size_t size):size_t:size COUNT EVENT 2 size = 16 [01:42:33] p:c:malloc(size_t size):size_t:size COUNT EVENT 3 size = 16 [01:42:34] p:c:malloc(size_t size):size_t:size COUNT EVENT 4 size = 16 ^C It seems that the application is allocating blocks of size 16. The COUNT column contains the number of occurrences of a particular event, and the EVENT column describes the event. In this case, the "size" parameter was probed and its value was 16, repeatedly. Now, suppose you wanted a histogram of buffer sizes passed to the write() function across the system: # ./argdist -c -H 'p:c:write(int fd, void *buf, size_t len):size_t:len' [01:45:22] p:c:write(int fd, void *buf, size_t len):size_t:len len : count distribution 0 -> 1 : 0 | | 2 -> 3 : 2 |************* | 4 -> 7 : 0 | | 8 -> 15 : 2 |************* | 16 -> 31 : 0 | | 32 -> 63 : 6 |****************************************| [01:45:23] p:c:write(int fd, void *buf, size_t len):size_t:len len : count distribution 0 -> 1 : 0 | | 2 -> 3 : 11 |*************** | 4 -> 7 : 0 | | 8 -> 15 : 4 |***** | 16 -> 31 : 0 | | 32 -> 63 : 28 |****************************************| 64 -> 127 : 12 |***************** | [01:45:24] p:c:write(int fd, void *buf, size_t len):size_t:len len : count distribution 0 -> 1 : 0 | | 2 -> 3 : 21 |**************** | 4 -> 7 : 0 | | 8 -> 15 : 6 |**** | 16 -> 31 : 0 | | 32 -> 63 : 52 |****************************************| 64 -> 127 : 26 |******************** | ^C It seems that most writes fall into three buckets: very small writes of 2-3 bytes, medium writes of 32-63 bytes, and larger writes of 64-127 bytes. But these are writes across the board -- what if you wanted to focus on writes to STDOUT? # ./argdist -c -H 'p:c:write(int fd, void *buf, size_t len):size_t:len:fd==1' [01:47:17] p:c:write(int fd, void *buf, size_t len):size_t:len:fd==1 len : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |****************************************| 16 -> 31 : 0 | | 32 -> 63 : 1 |****************************************| [01:47:18] p:c:write(int fd, void *buf, size_t len):size_t:len:fd==1 len : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 2 |************* | 16 -> 31 : 0 | | 32 -> 63 : 3 |******************** | 64 -> 127 : 6 |****************************************| [01:47:19] p:c:write(int fd, void *buf, size_t len):size_t:len:fd==1 len : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 3 |********* | 16 -> 31 : 0 | | 32 -> 63 : 5 |*************** | 64 -> 127 : 13 |****************************************| ^C The "fd==1" part is a filter that is applied to every invocation of write(). Only if the filter condition is true, the value is recorded. You can also use argdist to trace kernel functions. For example, suppose you wanted a histogram of kernel allocation (kmalloc) sizes across the system, printed twice with 3 second intervals: # ./argdist -i 3 -n 2 -H 'p::__kmalloc(size_t size):size_t:size' [01:50:00] p::__kmalloc(size_t size):size_t:size size : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 6 |****************************************| [01:50:03] p::__kmalloc(size_t size):size_t:size size : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 22 |****************************************| 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 5 |********* | 128 -> 255 : 2 |*** | Occasionally, numeric information isn't enough and you want to capture strings. What are the strings printed by puts() across the system? # ./argdist -i 10 -n 1 -C 'p:c:puts(char *str):char*:str' [01:53:54] p:c:puts(char *str):char*:str COUNT EVENT 2 str = Press ENTER to start. It looks like the message "Press ENTER to start." was printed twice during the 10 seconds we were tracing. What about reads? You could trace gets() across the system and print the strings input by the user (note how "r" is used instead of "p" to attach a probe to the function's return): # ./argdist -i 10 -n 1 -C 'r:c:gets():char*:(char*)$retval:$retval!=0' [02:12:23] r:c:gets():char*:$retval:$retval!=0 COUNT EVENT 1 (char*)$retval = hi there 3 (char*)$retval = sasha 8 (char*)$retval = hello Similarly, we could get a histogram of the error codes returned by read(): # ./argdist -i 10 -c 1 -H 'r:c:read()' [02:15:36] r:c:read() retval : count distribution 0 -> 1 : 29 |****************************************| 2 -> 3 : 11 |*************** | 4 -> 7 : 0 | | 8 -> 15 : 3 |**** | 16 -> 31 : 2 |** | 32 -> 63 : 22 |****************************** | 64 -> 127 : 5 |****** | 128 -> 255 : 0 | | 256 -> 511 : 1 |* | 512 -> 1023 : 1 |* | 1024 -> 2047 : 0 | | 2048 -> 4095 : 2 |** | In return probes, you can also trace the latency of the function (unless it is recursive) and the parameters it had on entry. For example, we can identify which processes are performing slow synchronous filesystem reads -- say, longer than 0.1ms (100,000ns): # ./argdist -C 'r::__vfs_read():u32:$PID:$latency > 100000' [01:08:48] r::__vfs_read():u32:$PID:$latency > 100000 COUNT EVENT 1 $PID = 10457 21 $PID = 2780 [01:08:49] r::__vfs_read():u32:$PID:$latency > 100000 COUNT EVENT 1 $PID = 10457 21 $PID = 2780 ^C It looks like process 2780 performed 21 slow reads. Occasionally, entry parameter values are also interesting. For example, you might be curious how long it takes malloc() to allocate memory -- nanoseconds per byte allocated. Let's go: # ./argdist -H 'r:c:malloc(size_t size):u64:$latency/$entry(size);ns per byte' -n 1 -i 10 [01:11:13] ns per byte : count distribution 0 -> 1 : 0 | | 2 -> 3 : 4 |***************** | 4 -> 7 : 3 |************* | 8 -> 15 : 2 |******** | 16 -> 31 : 1 |**** | 32 -> 63 : 0 | | 64 -> 127 : 7 |******************************* | 128 -> 255 : 1 |**** | 256 -> 511 : 0 | | 512 -> 1023 : 1 |**** | 1024 -> 2047 : 1 |**** | 2048 -> 4095 : 9 |****************************************| 4096 -> 8191 : 1 |**** | It looks like a tri-modal distribution. Some allocations are extremely cheap, and take 2-15 nanoseconds per byte. Other allocations are slower, and take 64-127 nanoseconds per byte. And some allocations are slower still, and take multiple microseconds per byte. You could also group results by more than one field. For example, __kmalloc takes an additional flags parameter that describes how to allocate memory: # ./argdist -c -C 'p::__kmalloc(size_t size, gfp_t flags):gfp_t,size_t:flags,size' [03:42:29] p::__kmalloc(size_t size, gfp_t flags):gfp_t,size_t:flags,size COUNT EVENT 1 flags = 16, size = 152 2 flags = 131280, size = 8 7 flags = 131280, size = 16 [03:42:30] p::__kmalloc(size_t size, gfp_t flags):gfp_t,size_t:flags,size COUNT EVENT 1 flags = 16, size = 152 6 flags = 131280, size = 8 19 flags = 131280, size = 16 [03:42:31] p::__kmalloc(size_t size, gfp_t flags):gfp_t,size_t:flags,size COUNT EVENT 2 flags = 16, size = 152 10 flags = 131280, size = 8 31 flags = 131280, size = 16 [03:42:32] p::__kmalloc(size_t size, gfp_t flags):gfp_t,size_t:flags,size COUNT EVENT 2 flags = 16, size = 152 14 flags = 131280, size = 8 43 flags = 131280, size = 16 ^C The flags value must be expanded by hand, but it's still helpful to eliminate certain kinds of allocations or visually group them together. argdist also has basic support for kernel tracepoints. It is sometimes more convenient to use tracepoints because they are documented and don't vary a lot between kernel versions. For example, let's trace the net:net_dev_start_xmit tracepoint and print out the protocol field from the tracepoint structure: # argdist -C 't:net:net_dev_start_xmit():u16:args->protocol' [13:01:49] t:net:net_dev_start_xmit():u16:args->protocol COUNT EVENT 8 args->protocol = 2048 ^C Note that to discover the format of the net:net_dev_start_xmit tracepoint, you use the tplist tool (tplist -v net:net_dev_start_xmit). Occasionally, it is useful to filter certain expressions by string. This is not trivially supported by BPF, but argdist provides a STRCMP helper you can use in filter expressions. For example, to get a histogram of latencies opening a specific file, run this: # argdist -c -H 'r:c:open(char *file):u64:$latency/1000:STRCMP("test.txt",$entry(file))' [02:16:38] [02:16:39] [02:16:40] $latency/1000 : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 2 |****************************************| [02:16:41] $latency/1000 : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |********** | 16 -> 31 : 4 |****************************************| [02:16:42] $latency/1000 : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |******** | 16 -> 31 : 5 |****************************************| [02:16:43] $latency/1000 : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |******** | 16 -> 31 : 5 |****************************************| Here's a final example that finds how many write() system calls are performed by each process on the system: # argdist -c -C 'p:c:write():int:$PID;write per process' -n 2 [06:47:18] write by process COUNT EVENT 3 $PID = 8889 7 $PID = 7615 7 $PID = 2480 [06:47:19] write by process COUNT EVENT 9 $PID = 8889 23 $PID = 7615 23 $PID = 2480 USAGE message: # argdist -h usage: argdist [-h] [-p PID] [-z STRING_SIZE] [-i INTERVAL] [-n COUNT] [-v] [-c] [-T TOP] [-H specifier] [-C[specifier] [-I header] Trace a function and display a summary of its parameter values. optional arguments: -h, --help show this help message and exit -p PID, --pid PID id of the process to trace (optional) -z STRING_SIZE, --string-size STRING_SIZE maximum string size to read from char* arguments -i INTERVAL, --interval INTERVAL output interval, in seconds -n COUNT, --number COUNT number of outputs -v, --verbose print resulting BPF program code before executing -c, --cumulative do not clear histograms and freq counts at each interval -T TOP, --top TOP number of top results to show (not applicable to histograms) -H specifier, --histogram specifier probe specifier to capture histogram of (see examples below) -C specifier, --count specifier probe specifier to capture count of (see examples below) -I header, --include header additional header files to include in the BPF program as either full path, or relative to '/usr/include' Probe specifier syntax: {p,r,t,u}:{[library],category}:function(signature)[:type[,type...]:expr[,expr...][:filter]][#label] Where: p,r,t,u -- probe at function entry, function exit, kernel tracepoint, or USDT probe in exit probes: can use $retval, $entry(param), $latency library -- the library that contains the function (leave empty for kernel functions) category -- the category of the kernel tracepoint (e.g. net, sched) signature -- the function's parameters, as in the C header type -- the type of the expression to collect (supports multiple) expr -- the expression to collect (supports multiple) filter -- the filter that is applied to collected values label -- the label for this probe in the resulting output EXAMPLES: argdist -H 'p::__kmalloc(u64 size):u64:size' Print a histogram of allocation sizes passed to kmalloc argdist -p 1005 -C 'p:c:malloc(size_t size):size_t:size:size==16' Print a frequency count of how many times process 1005 called malloc with an allocation size of 16 bytes argdist -C 'r:c:gets():char*:$retval#snooped strings' Snoop on all strings returned by gets() argdist -H 'r::__kmalloc(size_t size):u64:$latency/$entry(size)#ns per byte' Print a histogram of nanoseconds per byte from kmalloc allocations argdist -C 'p::__kmalloc(size_t size, gfp_t flags):size_t:size:flags&GFP_ATOMIC' Print frequency count of kmalloc allocation sizes that have GFP_ATOMIC argdist -p 1005 -C 'p:c:write(int fd):int:fd' -T 5 Print frequency counts of how many times writes were issued to a particular file descriptor number, in process 1005, but only show the top 5 busiest fds argdist -p 1005 -H 'r:c:read()' Print a histogram of error codes returned by read() in process 1005 argdist -C 'r::__vfs_read():u32:$PID:$latency > 100000' Print frequency of reads by process where the latency was >0.1ms argdist -H 'r::__vfs_read(void *file, void *buf, size_t count):size_t:$entry(count):$latency > 1000000' Print a histogram of read sizes that were longer than 1ms argdist -H \ 'p:c:write(int fd, const void *buf, size_t count):size_t:count:fd==1' Print a histogram of buffer sizes passed to write() across all processes, where the file descriptor was 1 (STDOUT) argdist -C 'p:c:fork()#fork calls' Count fork() calls in libc across all processes Can also use funccount.py, which is easier and more flexible argdist -H 't:block:block_rq_complete():u32:args->nr_sector' Print histogram of number of sectors in completing block I/O requests argdist -C 't:irq:irq_handler_entry():int:args->irq' Aggregate interrupts by interrupt request (IRQ) argdist -C 'u:pthread:pthread_start():u64:arg2' -p 1337 Print frequency of function addresses used as a pthread start function, relying on the USDT pthread_start probe in process 1337 argdist -H 'p:c:sleep(u32 seconds):u32:seconds' \ -H 'p:c:nanosleep(struct timespec *req):long:req->tv_nsec' Print histograms of sleep() and nanosleep() parameter values argdist -p 2780 -z 120 \ -C 'p:c:write(int fd, char* buf, size_t len):char*:buf:fd==1' Spy on writes to STDOUT performed by process 2780, up to a string size of 120 characters bpfcc-0.2.0+git0.02884a026/tools/bashreadline.py000077500000000000000000000027701305314114400206420ustar00rootroot00000000000000#!/usr/bin/python # # bashreadline Print entered bash commands from all running shells. # For Linux, uses BCC, eBPF. Embedded C. # # This works by tracing the readline() function using a uretprobe (uprobes). # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 28-Jan-2016 Brendan Gregg Created this. # 12-Feb-2016 Allan McAleavy migrated to BPF_PERF_OUTPUT from __future__ import print_function from bcc import BPF from time import strftime import ctypes as ct # load BPF program bpf_text = """ #include struct str_t { u64 pid; char str[80]; }; BPF_PERF_OUTPUT(events); int printret(struct pt_regs *ctx) { struct str_t data = {}; u32 pid; if (!PT_REGS_RC(ctx)) return 0; pid = bpf_get_current_pid_tgid(); data.pid = pid; bpf_probe_read(&data.str, sizeof(data.str), (void *)PT_REGS_RC(ctx)); events.perf_submit(ctx,&data,sizeof(data)); return 0; }; """ STR_DATA = 80 class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("str", ct.c_char * STR_DATA) ] b = BPF(text=bpf_text) b.attach_uretprobe(name="/bin/bash", sym="readline", fn_name="printret") # header print("%-9s %-6s %s" % ("TIME", "PID", "COMMAND")) def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents print("%-9s %-6d %s" % (strftime("%H:%M:%S"), event.pid, event.str)) b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/bashreadline_example.txt000066400000000000000000000011631305314114400225340ustar00rootroot00000000000000Demonstrations of bashreadline, the Linux eBPF/bcc version. This prints bash commands from all running bash shells on the system. For example: # ./bashreadline TIME PID COMMAND 05:28:25 21176 ls -l 05:28:28 21176 date 05:28:35 21176 echo hello world 05:28:43 21176 foo this command failed 05:28:45 21176 df -h 05:29:04 3059 echo another shell 05:29:13 21176 echo first shell again The entered command may fail. This is just showing what command lines were entered interactively for bash to process. It works by tracing the return of the readline() function using uprobes (specifically a uretprobe). bpfcc-0.2.0+git0.02884a026/tools/biolatency.py000077500000000000000000000076651305314114400203620ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # biolatency Summarize block device I/O latency as a histogram. # For Linux, uses BCC, eBPF. # # USAGE: biolatency [-h] [-T] [-Q] [-m] [-D] [interval] [count] # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Sep-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse # arguments examples = """examples: ./biolatency # summarize block I/O latency as a histogram ./biolatency 1 10 # print 1 second summaries, 10 times ./biolatency -mT 1 # 1s summaries, milliseconds, and timestamps ./biolatency -Q # include OS queued time in I/O time ./biolatency -D # show each disk device separately """ parser = argparse.ArgumentParser( description="Summarize block device I/O latency as a histogram", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-Q", "--queued", action="store_true", help="include OS queued time in I/O time") parser.add_argument("-m", "--milliseconds", action="store_true", help="millisecond histogram") parser.add_argument("-D", "--disks", action="store_true", help="print a histogram per disk device") parser.add_argument("interval", nargs="?", default=99999999, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() countdown = int(args.count) debug = 0 # define BPF program bpf_text = """ #include #include typedef struct disk_key { char disk[DISK_NAME_LEN]; u64 slot; } disk_key_t; BPF_HASH(start, struct request *); STORAGE // time block I/O int trace_req_start(struct pt_regs *ctx, struct request *req) { u64 ts = bpf_ktime_get_ns(); start.update(&req, &ts); return 0; } // output int trace_req_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp, delta; // fetch timestamp and calculate delta tsp = start.lookup(&req); if (tsp == 0) { return 0; // missed issue } delta = bpf_ktime_get_ns() - *tsp; FACTOR // store as histogram STORE start.delete(&req); return 0; } """ # code substitutions if args.milliseconds: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000000;') label = "msecs" else: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000;') label = "usecs" if args.disks: bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist, disk_key_t);') bpf_text = bpf_text.replace('STORE', 'disk_key_t key = {.slot = bpf_log2l(delta)}; ' + 'bpf_probe_read(&key.disk, sizeof(key.disk), ' + 'req->rq_disk->disk_name); dist.increment(key);') else: bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist);') bpf_text = bpf_text.replace('STORE', 'dist.increment(bpf_log2l(delta));') if debug: print(bpf_text) # load BPF program b = BPF(text=bpf_text) if args.queued: b.attach_kprobe(event="blk_account_io_start", fn_name="trace_req_start") else: b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_req_completion") print("Tracing block device I/O... Hit Ctrl-C to end.") # output exiting = 0 if args.interval else 1 dist = b.get_table("dist") while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") dist.print_log2_hist(label, "disk") dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/biolatency_example.txt000066400000000000000000000272751305314114400222600ustar00rootroot00000000000000Demonstrations of biolatency, the Linux eBPF/bcc version. biolatency traces block device I/O (disk I/O), and records the distribution of I/O latency (time), printing this as a histogram when Ctrl-C is hit. For example: # ./biolatency Tracing block device I/O... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 12 |******** | 256 -> 511 : 15 |********** | 512 -> 1023 : 43 |******************************* | 1024 -> 2047 : 52 |**************************************| 2048 -> 4095 : 47 |********************************** | 4096 -> 8191 : 52 |**************************************| 8192 -> 16383 : 36 |************************** | 16384 -> 32767 : 15 |********** | 32768 -> 65535 : 2 |* | 65536 -> 131071 : 2 |* | The latency of the disk I/O is measured from the issue to the device to its completion. A -Q option can be used to include time queued in the kernel. This example output shows a large mode of latency from about 128 microseconds to about 32767 microseconds (33 milliseconds). The bulk of the I/O was between 1 and 8 ms, which is the expected block device latency for rotational storage devices. The highest latency seen while tracing was between 65 and 131 milliseconds: the last row printed, for which there were 2 I/O. For efficiency, biolatency uses an in-kernel eBPF map to store timestamps with requests, and another in-kernel map to store the histogram (the "count") column, which is copied to user-space only when output is printed. These methods lower the performance overhead when tracing is performed. In the following example, the -m option is used to print a histogram using milliseconds as the units (which eliminates the first several rows), -T to print timestamps with the output, and to print 1 second summaries 5 times: # ./biolatency -mT 1 5 Tracing block device I/O... Hit Ctrl-C to end. 06:20:16 msecs : count distribution 0 -> 1 : 36 |**************************************| 2 -> 3 : 1 |* | 4 -> 7 : 3 |*** | 8 -> 15 : 17 |***************** | 16 -> 31 : 33 |********************************** | 32 -> 63 : 7 |******* | 64 -> 127 : 6 |****** | 06:20:17 msecs : count distribution 0 -> 1 : 96 |************************************ | 2 -> 3 : 25 |********* | 4 -> 7 : 29 |*********** | 8 -> 15 : 62 |*********************** | 16 -> 31 : 100 |**************************************| 32 -> 63 : 62 |*********************** | 64 -> 127 : 18 |****** | 06:20:18 msecs : count distribution 0 -> 1 : 68 |************************* | 2 -> 3 : 76 |**************************** | 4 -> 7 : 20 |******* | 8 -> 15 : 48 |***************** | 16 -> 31 : 103 |**************************************| 32 -> 63 : 49 |****************** | 64 -> 127 : 17 |****** | 06:20:19 msecs : count distribution 0 -> 1 : 522 |*************************************+| 2 -> 3 : 225 |**************** | 4 -> 7 : 38 |** | 8 -> 15 : 8 | | 16 -> 31 : 1 | | 06:20:20 msecs : count distribution 0 -> 1 : 436 |**************************************| 2 -> 3 : 106 |********* | 4 -> 7 : 34 |** | 8 -> 15 : 19 |* | 16 -> 31 : 1 | | How the I/O latency distribution changes over time can be seen. The -Q option begins measuring I/O latency from when the request was first queued in the kernel, and includes queuing latency: # ./biolatency -Q Tracing block device I/O... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 3 |* | 256 -> 511 : 37 |************** | 512 -> 1023 : 30 |*********** | 1024 -> 2047 : 18 |******* | 2048 -> 4095 : 22 |******** | 4096 -> 8191 : 14 |***** | 8192 -> 16383 : 48 |******************* | 16384 -> 32767 : 96 |**************************************| 32768 -> 65535 : 31 |************ | 65536 -> 131071 : 26 |********** | 131072 -> 262143 : 12 |**** | This better reflects the latency suffered by the application (if it is synchronous I/O), whereas the default mode without kernel queueing better reflects the performance of the device. Note that the storage device (and storage device controller) usually have queues of their own, which are always included in the latency, with or without -Q. The -D option will print a histogram per disk. Eg: # ./biolatency -D Tracing block device I/O... Hit Ctrl-C to end. ^C Bucket disk = 'xvdb' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 1 | | 256 -> 511 : 33 |********************** | 512 -> 1023 : 36 |************************ | 1024 -> 2047 : 58 |****************************************| 2048 -> 4095 : 51 |*********************************** | 4096 -> 8191 : 21 |************** | 8192 -> 16383 : 2 |* | Bucket disk = 'xvdc' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 1 | | 256 -> 511 : 38 |*********************** | 512 -> 1023 : 42 |************************* | 1024 -> 2047 : 66 |****************************************| 2048 -> 4095 : 40 |************************ | 4096 -> 8191 : 14 |******** | Bucket disk = 'xvda1' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 18 |********** | 512 -> 1023 : 67 |************************************* | 1024 -> 2047 : 35 |******************* | 2048 -> 4095 : 71 |****************************************| 4096 -> 8191 : 65 |************************************ | 8192 -> 16383 : 65 |************************************ | 16384 -> 32767 : 20 |*********** | 32768 -> 65535 : 7 |*** | This output sows that xvda1 has much higher latency, usually between 0.5 ms and 32 ms, whereas xvdc is usually between 0.2 ms and 4 ms. USAGE message: # ./biolatency -h usage: biolatency [-h] [-T] [-Q] [-m] [-D] [interval] [count] Summarize block device I/O latency as a histogram positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -T, --timestamp include timestamp on output -Q, --queued include OS queued time in I/O time -m, --milliseconds millisecond histogram -D, --disks print a histogram per disk device examples: ./biolatency # summarize block I/O latency as a histogram ./biolatency 1 10 # print 1 second summaries, 10 times ./biolatency -mT 1 # 1s summaries, milliseconds, and timestamps ./biolatency -Q # include OS queued time in I/O time ./biolatency -D # show each disk device separately bpfcc-0.2.0+git0.02884a026/tools/biosnoop.lua000066400000000000000000000106141305314114400201730ustar00rootroot00000000000000#!/usr/bin/env bcc-lua --[[ Copyright 2016 GitHub, Inc Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --]] local program = [[ #include #include struct val_t { u32 pid; char name[TASK_COMM_LEN]; }; struct data_t { u32 pid; u64 rwflag; u64 delta; u64 sector; u64 len; u64 ts; char disk_name[DISK_NAME_LEN]; char name[TASK_COMM_LEN]; }; BPF_HASH(start, struct request *); BPF_HASH(infobyreq, struct request *, struct val_t); BPF_PERF_OUTPUT(events); // cache PID and comm by-req int trace_pid_start(struct pt_regs *ctx, struct request *req) { struct val_t val = {}; if (bpf_get_current_comm(&val.name, sizeof(val.name)) == 0) { val.pid = bpf_get_current_pid_tgid(); infobyreq.update(&req, &val); } return 0; } // time block I/O int trace_req_start(struct pt_regs *ctx, struct request *req) { u64 ts; ts = bpf_ktime_get_ns(); start.update(&req, &ts); return 0; } // output int trace_req_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp, delta; u32 *pidp = 0; struct val_t *valp; struct data_t data ={}; u64 ts; // fetch timestamp and calculate delta tsp = start.lookup(&req); if (tsp == 0) { // missed tracing issue return 0; } ts = bpf_ktime_get_ns(); data.delta = ts - *tsp; data.ts = ts / 1000; valp = infobyreq.lookup(&req); if (valp == 0) { data.len = req->__data_len; strcpy(data.name,"?"); } else { data.pid = valp->pid; data.len = req->__data_len; data.sector = req->__sector; bpf_probe_read(&data.name, sizeof(data.name), valp->name); bpf_probe_read(&data.disk_name, sizeof(data.disk_name), req->rq_disk->disk_name); } if (req->cmd_flags & REQ_WRITE) { data.rwflag=1; } else { data.rwflag=0; } events.perf_submit(ctx,&data,sizeof(data)); start.delete(&req); infobyreq.delete(&req); return 0; } ]] local ffi = require("ffi") return function(BPF, utils) local bpf = BPF:new{text=program} bpf:attach_kprobe{event="blk_account_io_start", fn_name="trace_pid_start"} bpf:attach_kprobe{event="blk_start_request", fn_name="trace_req_start"} bpf:attach_kprobe{event="blk_mq_start_request", fn_name="trace_req_start"} bpf:attach_kprobe{event="blk_account_io_completion", fn_name="trace_req_completion"} print("%-14s %-14s %-6s %-7s %-2s %-9s %-7s %7s" % {"TIME(s)", "COMM", "PID", "DISK", "T", "SECTOR", "BYTES", "LAT(ms)"}) local rwflg = "" local start_ts = 0 local prev_ts = 0 local delta = 0 local function print_event(cpu, event) local val = -1 local event_pid = event.pid local event_delta = tonumber(event.delta) local event_sector = tonumber(event.sector) local event_len = tonumber(event.len) local event_ts = tonumber(event.ts) local event_disk_name = ffi.string(event.disk_name) local event_name = ffi.string(event.name) if event.rwflag == 1 then rwflg = "W" end if event.rwflag == 0 then rwflg = "R" end if not event_name:match("%?") then val = event_sector end if start_ts == 0 then prev_ts = start_ts end if start_ts == 1 then delta = delta + (event_ts - prev_ts) end print("%-14.9f %-14.14s %-6s %-7s %-2s %-9s %-7s %7.2f" % { delta / 1000000, event_name, event_pid, event_disk_name, rwflg, val, event_len, event_delta / 1000000}) prev_ts = event_ts start_ts = 1 end local TASK_COMM_LEN = 16 -- linux/sched.h local DISK_NAME_LEN = 32 -- linux/genhd.h bpf:get_table("events"):open_perf_buffer(print_event, [[ struct { uint32_t pid; uint64_t rwflag; uint64_t delta; uint64_t sector; uint64_t len; uint64_t ts; char disk_name[%d]; char name[%d]; } ]] % {DISK_NAME_LEN, TASK_COMM_LEN}) bpf:kprobe_poll_loop() end bpfcc-0.2.0+git0.02884a026/tools/biosnoop.py000077500000000000000000000113341305314114400200450ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # biosnoop Trace block device I/O and print details including issuing PID. # For Linux, uses BCC, eBPF. # # This uses in-kernel eBPF maps to cache process details (PID and comm) by I/O # request, as well as a starting timestamp for calculating I/O latency. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 16-Sep-2015 Brendan Gregg Created this. # 11-Feb-2016 Allan McAleavy updated for BPF_PERF_OUTPUT from __future__ import print_function from bcc import BPF import ctypes as ct import re # load BPF program b = BPF(text=""" #include #include struct val_t { u32 pid; char name[TASK_COMM_LEN]; }; struct data_t { u32 pid; u64 rwflag; u64 delta; u64 sector; u64 len; u64 ts; char disk_name[DISK_NAME_LEN]; char name[TASK_COMM_LEN]; }; BPF_HASH(start, struct request *); BPF_HASH(infobyreq, struct request *, struct val_t); BPF_PERF_OUTPUT(events); // cache PID and comm by-req int trace_pid_start(struct pt_regs *ctx, struct request *req) { struct val_t val = {}; if (bpf_get_current_comm(&val.name, sizeof(val.name)) == 0) { val.pid = bpf_get_current_pid_tgid(); infobyreq.update(&req, &val); } return 0; } // time block I/O int trace_req_start(struct pt_regs *ctx, struct request *req) { u64 ts; ts = bpf_ktime_get_ns(); start.update(&req, &ts); return 0; } // output int trace_req_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp, delta; u32 *pidp = 0; struct val_t *valp; struct data_t data = {}; u64 ts; // fetch timestamp and calculate delta tsp = start.lookup(&req); if (tsp == 0) { // missed tracing issue return 0; } ts = bpf_ktime_get_ns(); data.delta = ts - *tsp; data.ts = ts / 1000; valp = infobyreq.lookup(&req); if (valp == 0) { data.len = req->__data_len; strcpy(data.name, "?"); } else { data.pid = valp->pid; data.len = req->__data_len; data.sector = req->__sector; bpf_probe_read(&data.name, sizeof(data.name), valp->name); bpf_probe_read(&data.disk_name, sizeof(data.disk_name), req->rq_disk->disk_name); } /* * The following deals with a kernel version change (in mainline 4.7, although * it may be backported to earlier kernels) with how block request write flags * are tested. We handle both pre- and post-change versions here. Please avoid * kernel version tests like this as much as possible: they inflate the code, * test, and maintenance burden. */ #ifdef REQ_WRITE data.rwflag = !!(req->cmd_flags & REQ_WRITE); #elif defined(REQ_OP_SHIFT) data.rwflag = !!((req->cmd_flags >> REQ_OP_SHIFT) == REQ_OP_WRITE); #else data.rwflag = !!((req->cmd_flags & REQ_OP_MASK) == REQ_OP_WRITE); #endif events.perf_submit(ctx, &data, sizeof(data)); start.delete(&req); infobyreq.delete(&req); return 0; } """, debug=0) b.attach_kprobe(event="blk_account_io_start", fn_name="trace_pid_start") b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_req_completion") TASK_COMM_LEN = 16 # linux/sched.h DISK_NAME_LEN = 32 # linux/genhd.h class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("rwflag", ct.c_ulonglong), ("delta", ct.c_ulonglong), ("sector", ct.c_ulonglong), ("len", ct.c_ulonglong), ("ts", ct.c_ulonglong), ("disk_name", ct.c_char * DISK_NAME_LEN), ("name", ct.c_char * TASK_COMM_LEN) ] # header print("%-14s %-14s %-6s %-7s %-2s %-9s %-7s %7s" % ("TIME(s)", "COMM", "PID", "DISK", "T", "SECTOR", "BYTES", "LAT(ms)")) rwflg = "" start_ts = 0 prev_ts = 0 delta = 0 # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents val = -1 global start_ts global prev_ts global delta if event.rwflag == 1: rwflg = "W" if event.rwflag == 0: rwflg = "R" if not re.match(b'\?', event.name): val = event.sector if start_ts == 0: prev_ts = start_ts if start_ts == 1: delta = float(delta) + (event.ts - prev_ts) print("%-14.9f %-14.14s %-6s %-7s %-2s %-9s %-7s %7.2f" % ( delta / 1000000, event.name, event.pid, event.disk_name, rwflg, val, event.len, float(event.delta) / 1000000)) prev_ts = event.ts start_ts = 1 # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/biosnoop_example.txt000066400000000000000000000045741305314114400217540ustar00rootroot00000000000000Demonstrations of biosnoop, the Linux eBPF/bcc version. biosnoop traces block device I/O (disk I/O), and prints a line of output per I/O. Example: # ./biosnoop TIME(s) COMM PID DISK T SECTOR BYTES LAT(ms) 0.000004001 supervise 1950 xvda1 W 13092560 4096 0.74 0.000178002 supervise 1950 xvda1 W 13092432 4096 0.61 0.001469001 supervise 1956 xvda1 W 13092440 4096 1.24 0.001588002 supervise 1956 xvda1 W 13115128 4096 1.09 1.022346001 supervise 1950 xvda1 W 13115272 4096 0.98 1.022568002 supervise 1950 xvda1 W 13188496 4096 0.93 1.023534000 supervise 1956 xvda1 W 13188520 4096 0.79 1.023585003 supervise 1956 xvda1 W 13189512 4096 0.60 2.003920000 xfsaild/md0 456 xvdc W 62901512 8192 0.23 2.003931001 xfsaild/md0 456 xvdb W 62901513 512 0.25 2.004034001 xfsaild/md0 456 xvdb W 62901520 8192 0.35 2.004042000 xfsaild/md0 456 xvdb W 63542016 4096 0.36 2.004204001 kworker/0:3 26040 xvdb W 41950344 65536 0.34 2.044352002 supervise 1950 xvda1 W 13192672 4096 0.65 2.044574000 supervise 1950 xvda1 W 13189072 4096 0.58 This includes the PID and comm (process name) that were on-CPU at the time of issue (which usually means the process responsible). The latency of the disk I/O, measured from the issue to the device to its completion, is included as the last column. This example output is from what should be an idle system, however, the following is visible in iostat: $ iostat -x 1 [...] avg-cpu: %user %nice %system %iowait %steal %idle 0.12 0.00 0.12 0.00 0.00 99.75 Device: rrqm/s wrqm/s r/s w/s rkB/s wkB/s await svctm %util xvda 0.00 0.00 0.00 4.00 0.00 16.00 0.00 0.00 0.00 xvdb 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 xvdc 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 md0 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 0.00 There are 4 write IOPS. The output of biosnoop identifies the reason: multiple supervise processes are issuing writes to the xvda1 disk. I can now drill down on supervise using other tools to understand its file system workload. bpfcc-0.2.0+git0.02884a026/tools/biotop.py000077500000000000000000000140201305314114400175040ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # biotop block device (disk) I/O by process. # For Linux, uses BCC, eBPF. # # USAGE: biotop.py [-h] [-C] [-r MAXROWS] [interval] [count] # # This uses in-kernel eBPF maps to cache process details (PID and comm) by I/O # request, as well as a starting timestamp for calculating I/O latency. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 06-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse import signal from subprocess import call # arguments examples = """examples: ./biotop # block device I/O top, 1 second refresh ./biotop -C # don't clear the screen ./biotop 5 # 5 second summaries ./biotop 5 10 # 5 second summaries, 10 times only """ parser = argparse.ArgumentParser( description="Block device (disk) I/O by process", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-C", "--noclear", action="store_true", help="don't clear the screen") parser.add_argument("-r", "--maxrows", default=20, help="maximum rows to print, default 20") parser.add_argument("interval", nargs="?", default=1, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() interval = int(args.interval) countdown = int(args.count) maxrows = int(args.maxrows) clear = not int(args.noclear) # linux stats loadavg = "/proc/loadavg" diskstats = "/proc/diskstats" # signal handler def signal_ignore(signal, frame): print() # load BPF program b = BPF(text=""" #include #include // for saving process info by request struct who_t { u32 pid; char name[TASK_COMM_LEN]; }; // the key for the output summary struct info_t { u32 pid; int rwflag; int major; int minor; char name[TASK_COMM_LEN]; }; // the value of the output summary struct val_t { u64 bytes; u64 us; u32 io; }; BPF_HASH(start, struct request *); BPF_HASH(whobyreq, struct request *, struct who_t); BPF_HASH(counts, struct info_t, struct val_t); // cache PID and comm by-req int trace_pid_start(struct pt_regs *ctx, struct request *req) { struct who_t who = {}; if (bpf_get_current_comm(&who.name, sizeof(who.name)) == 0) { who.pid = bpf_get_current_pid_tgid(); whobyreq.update(&req, &who); } return 0; } // time block I/O int trace_req_start(struct pt_regs *ctx, struct request *req) { u64 ts; ts = bpf_ktime_get_ns(); start.update(&req, &ts); return 0; } // output int trace_req_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp; // fetch timestamp and calculate delta tsp = start.lookup(&req); if (tsp == 0) { return 0; // missed tracing issue } struct who_t *whop; struct val_t *valp, zero = {}; u64 delta_us = (bpf_ktime_get_ns() - *tsp) / 1000; // setup info_t key struct info_t info = {}; info.major = req->rq_disk->major; info.minor = req->rq_disk->first_minor; /* * The following deals with a kernel version change (in mainline 4.7, although * it may be backported to earlier kernels) with how block request write flags * are tested. We handle both pre- and post-change versions here. Please avoid * kernel version tests like this as much as possible: they inflate the code, * test, and maintenance burden. */ #ifdef REQ_WRITE info.rwflag = !!(req->cmd_flags & REQ_WRITE); #elif defined(REQ_OP_SHIFT) info.rwflag = !!((req->cmd_flags >> REQ_OP_SHIFT) == REQ_OP_WRITE); #else info.rwflag = !!((req->cmd_flags & REQ_OP_MASK) == REQ_OP_WRITE); #endif whop = whobyreq.lookup(&req); if (whop == 0) { // missed pid who, save stats as pid 0 valp = counts.lookup_or_init(&info, &zero); } else { info.pid = whop->pid; __builtin_memcpy(&info.name, whop->name, sizeof(info.name)); valp = counts.lookup_or_init(&info, &zero); } // save stats valp->us += delta_us; valp->bytes += req->__data_len; valp->io++; start.delete(&req); whobyreq.delete(&req); return 0; } """, debug=0) b.attach_kprobe(event="blk_account_io_start", fn_name="trace_pid_start") b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_req_completion") print('Tracing... Output every %d secs. Hit Ctrl-C to end' % interval) # cache disk major,minor -> diskname disklookup = {} with open(diskstats) as stats: for line in stats: a = line.split() disklookup[a[0] + "," + a[1]] = a[2] # output exiting = 0 while 1: try: sleep(interval) except KeyboardInterrupt: exiting = 1 # header if clear: call("clear") else: print() with open(loadavg) as stats: print("%-8s loadavg: %s" % (strftime("%H:%M:%S"), stats.read())) print("%-6s %-16s %1s %-3s %-3s %-8s %5s %7s %6s" % ("PID", "COMM", "D", "MAJ", "MIN", "DISK", "I/O", "Kbytes", "AVGms")) # by-PID output counts = b.get_table("counts") line = 0 for k, v in reversed(sorted(counts.items(), key=lambda counts: counts[1].bytes)): # lookup disk disk = str(k.major) + "," + str(k.minor) if disk in disklookup: diskname = disklookup[disk] else: diskname = "?" # print line avg_ms = (float(v.us) / 1000) / v.io print("%-6d %-16s %1s %-3d %-3d %-8s %5s %7s %6.2f" % (k.pid, k.name, "W" if k.rwflag else "R", k.major, k.minor, diskname, v.io, v.bytes / 1024, avg_ms)) line += 1 if line >= maxrows: break counts.clear() countdown -= 1 if exiting or countdown == 0: print("Detaching...") exit() bpfcc-0.2.0+git0.02884a026/tools/biotop_example.txt000066400000000000000000000221561305314114400214140ustar00rootroot00000000000000Demonstrations of biotop, the Linux eBPF/bcc version. Short for block device I/O top, biotop summarizes which processes are performing disk I/O. It's top for disks. Sample output: # ./biotop Tracing... Output every 1 secs. Hit Ctrl-C to end 08:04:11 loadavg: 1.48 0.87 0.45 1/287 14547 PID COMM D MAJ MIN DISK I/O Kbytes AVGms 14501 cksum R 202 1 xvda1 361 28832 3.39 6961 dd R 202 1 xvda1 1628 13024 0.59 13855 dd R 202 1 xvda1 1627 13016 0.59 326 jbd2/xvda1-8 W 202 1 xvda1 3 168 3.00 1880 supervise W 202 1 xvda1 2 8 6.71 1873 supervise W 202 1 xvda1 2 8 2.51 1871 supervise W 202 1 xvda1 2 8 1.57 1876 supervise W 202 1 xvda1 2 8 1.22 1892 supervise W 202 1 xvda1 2 8 0.62 1878 supervise W 202 1 xvda1 2 8 0.78 1886 supervise W 202 1 xvda1 2 8 1.30 1894 supervise W 202 1 xvda1 2 8 3.46 1869 supervise W 202 1 xvda1 2 8 0.73 1888 supervise W 202 1 xvda1 2 8 1.48 By default the screen refreshes every 1 second, and shows the top 20 disk consumers, sorted on total Kbytes. The first line printed is the header, which has the time and then the contents of /proc/loadavg. For the interval summarized by the output above, the "cksum" command performed 361 disk reads to the "xvda1" device, for a total of 28832 Kbytes, with an average I/O time of 3.39 ms. Two "dd" processes were also reading from the same disk, which a higher I/O rate and lower latency. While the average I/O size is not printed, it can be determined by dividing the Kbytes column by the I/O column. The columns through to Kbytes show the workload applied. The final column, AVGms, shows resulting performance. Other bcc tools can be used to get more details when needed: biolatency and biosnoop. Many years ago I created the original "iotop", and later regretted not calling it diskiotop or blockiotop, as "io" alone is ambiguous. This time it is biotop. The -C option can be used to prevent the screen from clearing (my preference). Here's using it with a 5 second interval: # ./biotop -C 5 Tracing... Output every 5 secs. Hit Ctrl-C to end 08:09:44 loadavg: 0.42 0.44 0.39 2/282 22115 PID COMM D MAJ MIN DISK I/O Kbytes AVGms 22069 dd R 202 1 xvda1 5993 47976 0.33 326 jbd2/xvda1-8 W 202 1 xvda1 3 168 2.67 1866 svscan R 202 1 xvda1 33 132 1.24 1880 supervise W 202 1 xvda1 10 40 0.56 1873 supervise W 202 1 xvda1 10 40 0.79 1871 supervise W 202 1 xvda1 10 40 0.78 1876 supervise W 202 1 xvda1 10 40 0.68 1892 supervise W 202 1 xvda1 10 40 0.71 1878 supervise W 202 1 xvda1 10 40 0.65 1886 supervise W 202 1 xvda1 10 40 0.78 1894 supervise W 202 1 xvda1 10 40 0.80 1869 supervise W 202 1 xvda1 10 40 0.91 1888 supervise W 202 1 xvda1 10 40 0.63 22069 bash R 202 1 xvda1 1 16 19.94 9251 kworker/u16:2 W 202 16 xvdb 2 8 0.13 08:09:49 loadavg: 0.47 0.44 0.39 1/282 22231 PID COMM D MAJ MIN DISK I/O Kbytes AVGms 22069 dd R 202 1 xvda1 13450 107600 0.35 22199 cksum R 202 1 xvda1 941 45548 4.63 326 jbd2/xvda1-8 W 202 1 xvda1 3 168 2.93 24467 kworker/0:2 W 202 16 xvdb 1 64 0.28 1880 supervise W 202 1 xvda1 10 40 0.81 1873 supervise W 202 1 xvda1 10 40 0.81 1871 supervise W 202 1 xvda1 10 40 1.03 1876 supervise W 202 1 xvda1 10 40 0.76 1892 supervise W 202 1 xvda1 10 40 0.74 1878 supervise W 202 1 xvda1 10 40 0.94 1886 supervise W 202 1 xvda1 10 40 0.76 1894 supervise W 202 1 xvda1 10 40 0.69 1869 supervise W 202 1 xvda1 10 40 0.72 1888 supervise W 202 1 xvda1 10 40 1.70 22199 bash R 202 1 xvda1 2 20 0.35 482 xfsaild/md0 W 202 16 xvdb 5 13 0.27 482 xfsaild/md0 W 202 32 xvdc 2 8 0.33 31331 pickup R 202 1 xvda1 1 4 0.31 08:09:54 loadavg: 0.51 0.45 0.39 2/282 22346 PID COMM D MAJ MIN DISK I/O Kbytes AVGms 22069 dd R 202 1 xvda1 14689 117512 0.32 326 jbd2/xvda1-8 W 202 1 xvda1 3 168 2.33 1880 supervise W 202 1 xvda1 10 40 0.65 1873 supervise W 202 1 xvda1 10 40 1.08 1871 supervise W 202 1 xvda1 10 40 0.66 1876 supervise W 202 1 xvda1 10 40 0.79 1892 supervise W 202 1 xvda1 10 40 0.67 1878 supervise W 202 1 xvda1 10 40 0.66 1886 supervise W 202 1 xvda1 10 40 1.02 1894 supervise W 202 1 xvda1 10 40 0.88 1869 supervise W 202 1 xvda1 10 40 0.89 1888 supervise W 202 1 xvda1 10 40 1.25 08:09:59 loadavg: 0.55 0.46 0.40 2/282 22461 PID COMM D MAJ MIN DISK I/O Kbytes AVGms 22069 dd R 202 1 xvda1 14442 115536 0.33 326 jbd2/xvda1-8 W 202 1 xvda1 3 168 3.46 1880 supervise W 202 1 xvda1 10 40 0.87 1873 supervise W 202 1 xvda1 10 40 0.87 1871 supervise W 202 1 xvda1 10 40 0.78 1876 supervise W 202 1 xvda1 10 40 0.86 1892 supervise W 202 1 xvda1 10 40 0.89 1878 supervise W 202 1 xvda1 10 40 0.87 1886 supervise W 202 1 xvda1 10 40 0.86 1894 supervise W 202 1 xvda1 10 40 1.06 1869 supervise W 202 1 xvda1 10 40 1.12 1888 supervise W 202 1 xvda1 10 40 0.98 08:10:04 loadavg: 0.59 0.47 0.40 3/282 22576 PID COMM D MAJ MIN DISK I/O Kbytes AVGms 22069 dd R 202 1 xvda1 14179 113432 0.34 326 jbd2/xvda1-8 W 202 1 xvda1 3 168 2.39 1880 supervise W 202 1 xvda1 10 40 0.81 1873 supervise W 202 1 xvda1 10 40 1.02 1871 supervise W 202 1 xvda1 10 40 1.15 1876 supervise W 202 1 xvda1 10 40 1.10 1892 supervise W 202 1 xvda1 10 40 0.77 1878 supervise W 202 1 xvda1 10 40 0.72 1886 supervise W 202 1 xvda1 10 40 0.81 1894 supervise W 202 1 xvda1 10 40 0.86 1869 supervise W 202 1 xvda1 10 40 0.83 1888 supervise W 202 1 xvda1 10 40 0.79 24467 kworker/0:2 R 202 32 xvdc 3 12 0.26 1056 cron R 202 1 xvda1 2 8 0.30 24467 kworker/0:2 R 202 16 xvdb 1 4 0.23 08:10:09 loadavg: 0.54 0.46 0.40 2/281 22668 PID COMM D MAJ MIN DISK I/O Kbytes AVGms 22069 dd R 202 1 xvda1 250 2000 0.34 326 jbd2/xvda1-8 W 202 1 xvda1 3 168 2.40 1880 supervise W 202 1 xvda1 8 32 0.93 1873 supervise W 202 1 xvda1 8 32 0.76 1871 supervise W 202 1 xvda1 8 32 0.60 1876 supervise W 202 1 xvda1 8 32 0.61 1892 supervise W 202 1 xvda1 8 32 0.68 1878 supervise W 202 1 xvda1 8 32 0.90 1886 supervise W 202 1 xvda1 8 32 0.57 1894 supervise W 202 1 xvda1 8 32 0.97 1869 supervise W 202 1 xvda1 8 32 0.69 1888 supervise W 202 1 xvda1 8 32 0.67 This shows another "dd" command reading from xvda1. On this system, various "supervise" processes do 8 disk writes per second, every second (they are creating and updating "status" files). USAGE message: # ./biotop.py -h usage: biotop.py [-h] [-C] [-r MAXROWS] [interval] [count] Block device (disk) I/O by process positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -C, --noclear don't clear the screen -r MAXROWS, --maxrows MAXROWS maximum rows to print, default 20 examples: ./biotop # block device I/O top, 1 second refresh ./biotop -C # don't clear the screen ./biotop 5 # 5 second summaries ./biotop 5 10 # 5 second summaries, 10 times only bpfcc-0.2.0+git0.02884a026/tools/bitesize.py000077500000000000000000000032141305314114400200310ustar00rootroot00000000000000#!/usr/bin/python # # bitehist.py Block I/O size histogram. # For Linux, uses BCC, eBPF. See .c file. # # USAGE: bitesize # # Ctrl-C will print the partially gathered histogram then exit. # # Copyright (c) 2016 Allan McAleavy # Licensed under the Apache License, Version 2.0 (the "License") # # 05-Feb-2016 Allan McAleavy ran pep8 against file from bcc import BPF from time import sleep bpf_text = """ #include #include struct proc_key_t { char name[TASK_COMM_LEN]; u64 slot; }; struct val_t { char name[TASK_COMM_LEN]; }; BPF_HISTOGRAM(dist, struct proc_key_t); BPF_HASH(commbyreq, struct request *, struct val_t); int trace_pid_start(struct pt_regs *ctx, struct request *req) { struct val_t val = {}; if (bpf_get_current_comm(&val.name, sizeof(val.name)) == 0) { commbyreq.update(&req, &val); } return 0; } int do_count(struct pt_regs *ctx, struct request *req) { struct val_t *valp; valp = commbyreq.lookup(&req); if (valp == 0) { return 0; } if (req->__data_len > 0) { struct proc_key_t key = {.slot = bpf_log2l(req->__data_len / 1024)}; bpf_probe_read(&key.name, sizeof(key.name),valp->name); dist.increment(key); } return 0; } """ # load BPF program b = BPF(text=bpf_text) b.attach_kprobe(event="blk_account_io_start", fn_name="trace_pid_start") b.attach_kprobe(event="blk_account_io_completion", fn_name="do_count") print("Tracing... Hit Ctrl-C to end.") # trace until Ctrl-C dist = b.get_table("dist") try: sleep(99999999) except KeyboardInterrupt: dist.print_log2_hist("Kbytes", "Process Name") bpfcc-0.2.0+git0.02884a026/tools/bitesize_example.txt000066400000000000000000000117541305314114400217400ustar00rootroot00000000000000Examples of bitesize.py, the Linux bcc/eBPF version. The aim of this tool is to show I/O distribution for requested block sizes, by process name. # ./bitesize.py Tracing... Hit Ctrl-C to end. ^C Process Name = 'kworker/u128:1' Kbytes : count distribution 0 -> 1 : 1 |******************** | 2 -> 3 : 0 | | 4 -> 7 : 2 |****************************************| Process Name = 'bitesize.py' Kbytes : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 1 |****************************************| Process Name = 'dd' Kbytes : count distribution 0 -> 1 : 3 | | 2 -> 3 : 0 | | 4 -> 7 : 6 | | 8 -> 15 : 0 | | 16 -> 31 : 1 | | 32 -> 63 : 1 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 1 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 488 |****************************************| Process Name = 'jbd2/dm-1-8' Kbytes : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 1 |****************************************| Process Name = 'cat' Kbytes : count distribution 0 -> 1 : 1 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 1 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 1924 |****************************************| Process Name = 'ntpd' Kbytes : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 104 |****************************************| Process Name = 'vmtoolsd' Kbytes : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 1 |****************************************| Process Name = 'bash' Kbytes : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 2 |****************************************| Process Name = 'jbd2/sdb-8' Kbytes : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 1 |****************************************| 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 1 |****************************************| We can see from above that there was a dd command being run which generated 488 IOPS between 1MB and 2MB, we can also see the cat command generating 1924 IOPS between 256Kb and 512Kb. bpfcc-0.2.0+git0.02884a026/tools/btrfsdist.py000077500000000000000000000137701305314114400202270ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # btrfsdist Summarize btrfs operation latency. # For Linux, uses BCC, eBPF. # # USAGE: btrfsdist [-h] [-T] [-m] [-p PID] [interval] [count] # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 15-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse # symbols kallsyms = "/proc/kallsyms" # arguments examples = """examples: ./btrfsdist # show operation latency as a histogram ./btrfsdist -p 181 # trace PID 181 only ./btrfsdist 1 10 # print 1 second summaries, 10 times ./btrfsdist -m 5 # 5s summaries, milliseconds """ parser = argparse.ArgumentParser( description="Summarize btrfs operation latency", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--notimestamp", action="store_true", help="don't include timestamp on interval output") parser.add_argument("-m", "--milliseconds", action="store_true", help="output in milliseconds") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("interval", nargs="?", help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() pid = args.pid countdown = int(args.count) if args.milliseconds: factor = 1000000 label = "msecs" else: factor = 1000 label = "usecs" if args.interval and int(args.interval) == 0: print("ERROR: interval 0. Exiting.") exit() debug = 0 # define BPF program bpf_text = """ #include #include #include #define OP_NAME_LEN 8 typedef struct dist_key { char op[OP_NAME_LEN]; u64 slot; } dist_key_t; BPF_HASH(start, u32); BPF_HISTOGRAM(dist, dist_key_t); // time operation int trace_entry(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); if (FILTER_PID) return 0; u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); return 0; } // The current btrfs (Linux 4.5) uses generic_file_read_iter() instead of it's // own read function. So we need to trace that and then filter on btrfs, which // I do by checking file->f_op. int trace_read_entry(struct pt_regs *ctx, struct kiocb *iocb) { u32 pid = bpf_get_current_pid_tgid(); if (FILTER_PID) return 0; // btrfs filter on file->f_op == btrfs_file_operations struct file *fp = iocb->ki_filp; if ((u64)fp->f_op != BTRFS_FILE_OPERATIONS) return 0; u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); return 0; } // The current btrfs (Linux 4.5) uses generic_file_open(), instead of it's own // function. Same as with reads. Trace the generic path and filter: int trace_open_entry(struct pt_regs *ctx, struct inode *inode, struct file *file) { u32 pid; pid = bpf_get_current_pid_tgid(); if (FILTER_PID) return 0; // btrfs filter on file->f_op == btrfs_file_operations if ((u64)file->f_op != BTRFS_FILE_OPERATIONS) return 0; u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); return 0; } static int trace_return(struct pt_regs *ctx, const char *op) { u64 *tsp; u32 pid = bpf_get_current_pid_tgid(); // fetch timestamp and calculate delta tsp = start.lookup(&pid); if (tsp == 0) { return 0; // missed start or filtered } u64 delta = (bpf_ktime_get_ns() - *tsp) / FACTOR; // store as histogram dist_key_t key = {.slot = bpf_log2l(delta)}; __builtin_memcpy(&key.op, op, sizeof(key.op)); dist.increment(key); start.delete(&pid); return 0; } int trace_read_return(struct pt_regs *ctx) { char *op = "read"; return trace_return(ctx, op); } int trace_write_return(struct pt_regs *ctx) { char *op = "write"; return trace_return(ctx, op); } int trace_open_return(struct pt_regs *ctx) { char *op = "open"; return trace_return(ctx, op); } int trace_fsync_return(struct pt_regs *ctx) { char *op = "fsync"; return trace_return(ctx, op); } """ # code replacements with open(kallsyms) as syms: ops = '' for line in syms: a = line.rstrip().split() (addr, name) = (a[0], a[2]) name = name.split("\t")[0] if name == "btrfs_file_operations": ops = "0x" + addr break if ops == '': print("ERROR: no btrfs_file_operations in /proc/kallsyms. Exiting.") exit() bpf_text = bpf_text.replace('BTRFS_FILE_OPERATIONS', ops) bpf_text = bpf_text.replace('FACTOR', str(factor)) if args.pid: bpf_text = bpf_text.replace('FILTER_PID', 'pid != %s' % pid) else: bpf_text = bpf_text.replace('FILTER_PID', '0') if debug: print(bpf_text) # load BPF program b = BPF(text=bpf_text) # Common file functions. See earlier comment about generic_file_read_iter(). b.attach_kprobe(event="generic_file_read_iter", fn_name="trace_read_entry") b.attach_kprobe(event="btrfs_file_write_iter", fn_name="trace_entry") b.attach_kprobe(event="generic_file_open", fn_name="trace_open_entry") b.attach_kprobe(event="btrfs_sync_file", fn_name="trace_entry") b.attach_kretprobe(event="generic_file_read_iter", fn_name="trace_read_return") b.attach_kretprobe(event="btrfs_file_write_iter", fn_name="trace_write_return") b.attach_kretprobe(event="generic_file_open", fn_name="trace_open_return") b.attach_kretprobe(event="btrfs_sync_file", fn_name="trace_fsync_return") print("Tracing btrfs operation latency... Hit Ctrl-C to end.") # output exiting = 0 dist = b.get_table("dist") while (1): try: if args.interval: sleep(int(args.interval)) else: sleep(99999999) except KeyboardInterrupt: exiting = 1 print() if args.interval and (not args.notimestamp): print(strftime("%H:%M:%S:")) dist.print_log2_hist(label, "operation") dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/btrfsdist_example.txt000066400000000000000000000225111305314114400221170ustar00rootroot00000000000000Demonstrations of btrfsdist, the Linux eBPF/bcc version. btrfsdist traces btrfs reads, writes, opens, and fsyncs, and summarizes their latency as a power-of-2 histogram. For example: # ./btrfsdist Tracing btrfs operation latency... Hit Ctrl-C to end. ^C operation = 'read' usecs : count distribution 0 -> 1 : 15 | | 2 -> 3 : 1308 |******* | 4 -> 7 : 198 |* | 8 -> 15 : 0 | | 16 -> 31 : 11 | | 32 -> 63 : 361 |* | 64 -> 127 : 55 | | 128 -> 255 : 104 | | 256 -> 511 : 7312 |****************************************| 512 -> 1023 : 387 |** | 1024 -> 2047 : 10 | | 2048 -> 4095 : 4 | | operation = 'write' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 4 |****************************************| operation = 'open' usecs : count distribution 0 -> 1 : 1 |********** | 2 -> 3 : 4 |****************************************| This output shows a bi-modal distribution for read latency, with a faster mode of 1,308 reads that took between 2 and 3 microseconds, and a slower mode of over 7,312 reads that took between 256 and 511 microseconds. It's likely that the faster mode was a hit from the in-memory file system cache, and the slower mode is a read from a storage device (disk). This "latency" is measured from when the operation was issued from the VFS interface to the file system, to when it completed. This spans everything: block device I/O (disk I/O), file system CPU cycles, file system locks, run queue latency, etc. This is a better measure of the latency suffered by applications reading from the file system than measuring this down at the block device interface. Note that this only traces the common file system operations previously listed: other file system operations (eg, inode operations including getattr()) are not traced. An optional interval and a count can be provided, as well as -m to show the distributions in milliseconds. For example, two second summaries, five times: # ./btrfsdist 2 5 Tracing btrfs operation latency... Hit Ctrl-C to end. 03:40:49: operation = 'read' usecs : count distribution 0 -> 1 : 15 | | 2 -> 3 : 833 |******** | 4 -> 7 : 127 |* | 8 -> 15 : 0 | | 16 -> 31 : 8 | | 32 -> 63 : 907 |******** | 64 -> 127 : 91 | | 128 -> 255 : 246 |** | 256 -> 511 : 4164 |****************************************| 512 -> 1023 : 193 |* | 1024 -> 2047 : 4 | | 2048 -> 4095 : 6 | | 4096 -> 8191 : 2 | | 03:40:51: operation = 'read' usecs : count distribution 0 -> 1 : 25 | | 2 -> 3 : 1491 |*************** | 4 -> 7 : 218 |** | 8 -> 15 : 0 | | 16 -> 31 : 16 | | 32 -> 63 : 1527 |*************** | 64 -> 127 : 319 |*** | 128 -> 255 : 429 |**** | 256 -> 511 : 3841 |****************************************| 512 -> 1023 : 232 |** | 1024 -> 2047 : 3 | | 2048 -> 4095 : 6 | | 4096 -> 8191 : 1 | | 8192 -> 16383 : 1 | | 03:40:53: operation = 'read' usecs : count distribution 0 -> 1 : 27 | | 2 -> 3 : 2999 |********************************* | 4 -> 7 : 407 |**** | 8 -> 15 : 0 | | 16 -> 31 : 46 | | 32 -> 63 : 3538 |****************************************| 64 -> 127 : 595 |****** | 128 -> 255 : 621 |******* | 256 -> 511 : 3532 |*************************************** | 512 -> 1023 : 212 |** | 1024 -> 2047 : 1 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 0 | | 8192 -> 16383 : 0 | | 16384 -> 32767 : 1 | | 03:40:55: operation = 'read' usecs : count distribution 0 -> 1 : 221 | | 2 -> 3 : 12580 |****************************************| 4 -> 7 : 1366 |**** | 8 -> 15 : 0 | | 16 -> 31 : 289 | | 32 -> 63 : 10782 |********************************** | 64 -> 127 : 1232 |*** | 128 -> 255 : 807 |** | 256 -> 511 : 2299 |******* | 512 -> 1023 : 135 | | 1024 -> 2047 : 5 | | 2048 -> 4095 : 2 | | 03:40:57: operation = 'read' usecs : count distribution 0 -> 1 : 73951 |************************* | 2 -> 3 : 117639 |****************************************| 4 -> 7 : 7943 |** | 8 -> 15 : 1841 | | 16 -> 31 : 1143 | | 32 -> 63 : 5006 |* | 64 -> 127 : 483 | | 128 -> 255 : 242 | | 256 -> 511 : 253 | | 512 -> 1023 : 84 | | 1024 -> 2047 : 23 | | This shows a read workload that begins bimodal, and eventually the second mode disappears. The reason for this is that the workload cached during tracing. Note that the rate also increased, with over 200k reads for the final two second sample. USAGE message: # ./btrfsdist -h usage: btrfsdist [-h] [-T] [-m] [-p PID] [interval] [count] Summarize btrfs operation latency positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -T, --notimestamp don't include timestamp on interval output -m, --milliseconds output in milliseconds -p PID, --pid PID trace this PID only examples: ./btrfsdist # show operation latency as a histogram ./btrfsdist -p 181 # trace PID 181 only ./btrfsdist 1 10 # print 1 second summaries, 10 times ./btrfsdist -m 5 # 5s summaries, milliseconds bpfcc-0.2.0+git0.02884a026/tools/btrfsslower.py000077500000000000000000000230401305314114400205660ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # btrfsslower Trace slow btrfs operations. # For Linux, uses BCC, eBPF. # # USAGE: btrfsslower [-h] [-j] [-p PID] [min_ms] # # This script traces common btrfs file operations: reads, writes, opens, and # syncs. It measures the time spent in these operations, and prints details # for each that exceeded a threshold. # # WARNING: This adds low-overhead instrumentation to these btrfs operations, # including reads and writes from the file system cache. Such reads and writes # can be very frequent (depending on the workload; eg, 1M/sec), at which # point the overhead of this tool (even if it prints no "slower" events) can # begin to become significant. # # By default, a minimum millisecond threshold of 10 is used. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 15-Feb-2016 Brendan Gregg Created this. # 16-Oct-2016 Dina Goldshtein -p to filter by process ID. from __future__ import print_function from bcc import BPF import argparse from time import strftime import ctypes as ct # symbols kallsyms = "/proc/kallsyms" # arguments examples = """examples: ./btrfsslower # trace operations slower than 10 ms (default) ./btrfsslower 1 # trace operations slower than 1 ms ./btrfsslower -j 1 # ... 1 ms, parsable output (csv) ./btrfsslower 0 # trace all operations (warning: verbose) ./btrfsslower -p 185 # trace PID 185 only """ parser = argparse.ArgumentParser( description="Trace common btrfs file operations slower than a threshold", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-j", "--csv", action="store_true", help="just print fields: comma-separated values") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("min_ms", nargs="?", default='10', help="minimum I/O duration to trace, in ms (default 10)") args = parser.parse_args() min_ms = int(args.min_ms) pid = args.pid csv = args.csv debug = 0 # define BPF program bpf_text = """ #include #include #include #include // XXX: switch these to char's when supported #define TRACE_READ 0 #define TRACE_WRITE 1 #define TRACE_OPEN 2 #define TRACE_FSYNC 3 struct val_t { u64 ts; u64 offset; struct file *fp; }; struct data_t { // XXX: switch some to u32's when supported u64 ts_us; u64 type; u64 size; u64 offset; u64 delta_us; u64 pid; char task[TASK_COMM_LEN]; char file[DNAME_INLINE_LEN]; }; BPF_HASH(entryinfo, u64, struct val_t); BPF_PERF_OUTPUT(events); // // Store timestamp and size on entry // // The current btrfs (Linux 4.5) uses generic_file_read_iter() instead of it's // own read function. So we need to trace that and then filter on btrfs, which // I do by checking file->f_op. int trace_read_entry(struct pt_regs *ctx, struct kiocb *iocb) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // btrfs filter on file->f_op == btrfs_file_operations struct file *fp = iocb->ki_filp; if ((u64)fp->f_op != BTRFS_FILE_OPERATIONS) return 0; // store filep and timestamp by pid struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = fp; val.offset = iocb->ki_pos; if (val.fp) entryinfo.update(&id, &val); return 0; } // btrfs_file_write_iter(): int trace_write_entry(struct pt_regs *ctx, struct kiocb *iocb) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // store filep and timestamp by id struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = iocb->ki_filp; val.offset = iocb->ki_pos; if (val.fp) entryinfo.update(&id, &val); return 0; } // The current btrfs (Linux 4.5) uses generic_file_open(), instead of it's own // function. Same as with reads. Trace the generic path and filter: int trace_open_entry(struct pt_regs *ctx, struct inode *inode, struct file *file) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // btrfs filter on file->f_op == btrfs_file_operations if ((u64)file->f_op != BTRFS_FILE_OPERATIONS) return 0; // store filep and timestamp by id struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = file; val.offset = 0; if (val.fp) entryinfo.update(&id, &val); return 0; } // btrfs_sync_file(): int trace_fsync_entry(struct pt_regs *ctx, struct file *file) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // store filep and timestamp by id struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = file; val.offset = 0; if (val.fp) entryinfo.update(&id, &val); return 0; } // // Output // static int trace_return(struct pt_regs *ctx, int type) { struct val_t *valp; u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part valp = entryinfo.lookup(&id); if (valp == 0) { // missed tracing issue or filtered return 0; } // calculate delta u64 ts = bpf_ktime_get_ns(); u64 delta_us = (ts - valp->ts) / 1000; entryinfo.delete(&id); if (FILTER_US) return 0; // populate output struct u32 size = PT_REGS_RC(ctx); struct data_t data = {.type = type, .size = size, .delta_us = delta_us, .pid = pid}; data.ts_us = ts / 1000; data.offset = valp->offset; bpf_get_current_comm(&data.task, sizeof(data.task)); // workaround (rewriter should handle file to d_name in one step): struct dentry *de = NULL; struct qstr qs = {}; bpf_probe_read(&de, sizeof(de), &valp->fp->f_path.dentry); bpf_probe_read(&qs, sizeof(qs), (void *)&de->d_name); if (qs.len == 0) return 0; bpf_probe_read(&data.file, sizeof(data.file), (void *)qs.name); // output events.perf_submit(ctx, &data, sizeof(data)); return 0; } int trace_read_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_READ); } int trace_write_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_WRITE); } int trace_open_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_OPEN); } int trace_fsync_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_FSYNC); } """ # code replacements with open(kallsyms) as syms: ops = '' for line in syms: a = line.rstrip().split() (addr, name) = (a[0], a[2]) name = name.split("\t")[0] if name == "btrfs_file_operations": ops = "0x" + addr break if ops == '': print("ERROR: no btrfs_file_operations in /proc/kallsyms. Exiting.") exit() bpf_text = bpf_text.replace('BTRFS_FILE_OPERATIONS', ops) if min_ms == 0: bpf_text = bpf_text.replace('FILTER_US', '0') else: bpf_text = bpf_text.replace('FILTER_US', 'delta_us <= %s' % str(min_ms * 1000)) if args.pid: bpf_text = bpf_text.replace('FILTER_PID', 'pid != %s' % pid) else: bpf_text = bpf_text.replace('FILTER_PID', '0') if debug: print(bpf_text) # kernel->user event data: struct data_t DNAME_INLINE_LEN = 32 # linux/dcache.h TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [ ("ts_us", ct.c_ulonglong), ("type", ct.c_ulonglong), ("size", ct.c_ulonglong), ("offset", ct.c_ulonglong), ("delta_us", ct.c_ulonglong), ("pid", ct.c_ulonglong), ("task", ct.c_char * TASK_COMM_LEN), ("file", ct.c_char * DNAME_INLINE_LEN) ] # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents type = 'R' if event.type == 1: type = 'W' elif event.type == 2: type = 'O' elif event.type == 3: type = 'S' if (csv): print("%d,%s,%d,%s,%d,%d,%d,%s" % ( event.ts_us, event.task, event.pid, type, event.size, event.offset, event.delta_us, event.file)) return print("%-8s %-14.14s %-6s %1s %-7s %-8d %7.2f %s" % (strftime("%H:%M:%S"), event.task, event.pid, type, event.size, event.offset / 1024, float(event.delta_us) / 1000, event.file)) # initialize BPF b = BPF(text=bpf_text) # Common file functions. See earlier comment about generic_*(). b.attach_kprobe(event="generic_file_read_iter", fn_name="trace_read_entry") b.attach_kprobe(event="btrfs_file_write_iter", fn_name="trace_write_entry") b.attach_kprobe(event="generic_file_open", fn_name="trace_open_entry") b.attach_kprobe(event="btrfs_sync_file", fn_name="trace_fsync_entry") b.attach_kretprobe(event="generic_file_read_iter", fn_name="trace_read_return") b.attach_kretprobe(event="btrfs_file_write_iter", fn_name="trace_write_return") b.attach_kretprobe(event="generic_file_open", fn_name="trace_open_return") b.attach_kretprobe(event="btrfs_sync_file", fn_name="trace_fsync_return") # header if (csv): print("ENDTIME_us,TASK,PID,TYPE,BYTES,OFFSET_b,LATENCY_us,FILE") else: if min_ms == 0: print("Tracing btrfs operations") else: print("Tracing btrfs operations slower than %d ms" % min_ms) print("%-8s %-14s %-6s %1s %-7s %-8s %7s %s" % ("TIME", "COMM", "PID", "T", "BYTES", "OFF_KB", "LAT(ms)", "FILENAME")) # read events b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/btrfsslower_example.txt000066400000000000000000000147701305314114400224770ustar00rootroot00000000000000Demonstrations of btrfsslower, the Linux eBPF/bcc version. btrfsslower shows btrfs reads, writes, opens, and fsyncs, slower than a threshold. For example: # ./btrfsslower Tracing btrfs operations slower than 10 ms TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME 01:22:03 randread.pl 13602 R 8192 391384 10.40 data1 01:22:03 randread.pl 13602 R 8192 92632 10.41 data1 01:22:06 randread.pl 13602 R 8192 199800 17.33 data1 01:22:06 randread.pl 13602 R 8192 415160 17.21 data1 01:22:07 randread.pl 13602 R 8192 729984 11.93 data1 01:22:09 randread.pl 13602 R 8192 342784 11.90 data1 [...] This shows several reads from a "randread.pl" program, each 8 Kbytes in size, and from a "data1" file. These all had over 10 ms latency. This "latency" is measured from when the operation was issued from the VFS interface to the file system, to when it completed. This spans everything: block device I/O (disk I/O), file system CPU cycles, file system locks, run queue latency, etc. This is a better measure of the latency suffered by applications reading from the file system than measuring this down at the block device interface. Note that this only traces the common file system operations previously listed: other file system operations (eg, inode operations including getattr()) are not traced. The threshold can be provided as an argument. Eg, I/O slower than 1 ms: # ./btrfsslower 1 Tracing btrfs operations slower than 1 ms TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME 03:26:54 randread.pl 30578 R 8192 214864 1.87 data1 03:26:54 randread.pl 30578 R 8192 267600 1.48 data1 03:26:54 randread.pl 30578 R 8192 704200 1.30 data1 03:26:54 randread.pl 30578 R 8192 492352 3.09 data1 03:26:55 randread.pl 30578 R 8192 319448 1.34 data1 03:26:55 randread.pl 30578 R 8192 676032 1.88 data1 03:26:55 randread.pl 30578 R 8192 646712 2.24 data1 03:26:55 randread.pl 30578 R 8192 124376 1.02 data1 03:26:55 randread.pl 30578 R 8192 223064 2.64 data1 03:26:55 randread.pl 30578 R 8192 521280 1.55 data1 03:26:55 randread.pl 30578 R 8192 272992 2.48 data1 03:26:55 randread.pl 30578 R 8192 450112 2.67 data1 03:26:55 randread.pl 30578 R 8192 361808 1.78 data1 03:26:55 randread.pl 30578 R 8192 41088 1.46 data1 03:26:55 randread.pl 30578 R 8192 756576 1.67 data1 03:26:55 randread.pl 30578 R 8192 711776 2.74 data1 03:26:55 randread.pl 30578 R 8192 129472 1.34 data1 03:26:55 randread.pl 30578 R 8192 526928 1.82 data1 03:26:56 randread.pl 30578 R 8192 312768 1.44 data1 03:26:56 randread.pl 30578 R 8192 34720 1.14 data1 03:26:56 randread.pl 30578 R 8192 258376 1.13 data1 03:26:56 randread.pl 30578 R 8192 308456 1.44 data1 03:26:56 randread.pl 30578 R 8192 759656 1.27 data1 03:26:56 randread.pl 30578 R 8192 387424 3.24 data1 03:26:56 randread.pl 30578 R 8192 168864 3.38 data1 03:26:56 randread.pl 30578 R 8192 699296 1.38 data1 03:26:56 randread.pl 30578 R 8192 405688 2.37 data1 03:26:56 randread.pl 30578 R 8192 559064 1.18 data1 03:26:56 randread.pl 30578 R 8192 264808 1.13 data1 03:26:56 randread.pl 30578 R 8192 369240 2.20 data1 [...] There's now much more output (this spans less than 3 seconds, the previous output spanned 6 seconds), as the lower threshold is catching more I/O. A threshold of 0 will trace all operations. Warning: the output will be verbose, as it will include all file system cache hits. # ./btrfsslower 0 Tracing btrfs operations TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME 03:28:17 bash 32597 O 0 0 0.00 date.txt 03:28:17 date 32597 W 29 0 0.02 date.txt 03:28:23 cksum 32743 O 0 0 0.00 date.txt 03:28:23 cksum 32743 R 29 0 0.01 date.txt 03:28:23 cksum 32743 R 0 0 0.00 date.txt While tracing, the following commands were run in another window: # date > date.txt # cksum date.txt The output of btrfsslower now includes open operations ("O"), and writes ("W"). The first read from cksum(1) returned 29 bytes, and the second returned 0: causing cksum(1) to stop reading. A -j option will print just the fields (parsable output, csv): # ./btrfsslower -j 1 ENDTIME_us,TASK,PID,TYPE,BYTES,OFFSET_b,LATENCY_us,FILE 8930665366,randread.pl,2717,R,8192,230391808,4312,data1 8930670746,randread.pl,2717,R,8192,347832320,1296,data1 8930675995,randread.pl,2717,R,8192,409812992,4207,data1 8930680213,randread.pl,2717,R,8192,498204672,3104,data1 8930685970,randread.pl,2717,R,8192,553164800,1843,data1 8930687568,randread.pl,2717,R,8192,339492864,1475,data1 8930694108,randread.pl,2717,R,8192,500711424,6276,data1 8930697139,randread.pl,2717,R,8192,485801984,2180,data1 8930705755,randread.pl,2717,R,8192,376922112,7535,data1 8930711340,randread.pl,2717,R,8192,380084224,3314,data1 8930740964,randread.pl,2717,R,8192,226091008,24762,data1 8930743169,randread.pl,2717,R,8192,361570304,1809,data1 8930748789,randread.pl,2717,R,8192,346931200,1530,data1 8930763514,randread.pl,2717,R,8192,59719680,13938,data1 8930764870,randread.pl,2717,R,8192,406511616,1313,data1 8930774327,randread.pl,2717,R,8192,661430272,7361,data1 8930780360,randread.pl,2717,R,8192,406904832,2220,data1 8930785736,randread.pl,2717,R,8192,523419648,2005,data1 8930794560,randread.pl,2717,R,8192,342974464,8388,data1 [...] This may be useful for visualizing with another tool, for example, for producing a scatter plot of ENDTIME vs LATENCY, to look for time-based patterns. USAGE message: # ./btrfsslower -h usage: btrfsslower [-h] [-j] [-p PID] [min_ms] Trace common btrfs file operations slower than a threshold positional arguments: min_ms minimum I/O duration to trace, in ms (default 10) optional arguments: -h, --help show this help message and exit -j, --csv just print fields: comma-separated values -p PID, --pid PID trace this PID only examples: ./btrfsslower # trace operations slower than 10 ms (default) ./btrfsslower 1 # trace operations slower than 1 ms ./btrfsslower -j 1 # ... 1 ms, parsable output (csv) ./btrfsslower 0 # trace all operations (warning: verbose) ./btrfsslower -p 185 # trace PID 185 only bpfcc-0.2.0+git0.02884a026/tools/cachestat.py000077500000000000000000000115021305314114400201510ustar00rootroot00000000000000#!/usr/bin/python # # cachestat Count cache kernel function calls. # For Linux, uses BCC, eBPF. See .c file. # # USAGE: cachestat # Taken from funccount by Brendan Gregg # This is a rewrite of cachestat from perf to bcc # https://github.com/brendangregg/perf-tools/blob/master/fs/cachestat # # Copyright (c) 2016 Allan McAleavy. # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 09-Sep-2015 Brendan Gregg Created this. # 06-Nov-2015 Allan McAleavy # 13-Jan-2016 Allan McAleavy run pep8 against program from __future__ import print_function from bcc import BPF from time import sleep, strftime import signal import re from sys import argv # signal handler def signal_ignore(signal, frame): print() # Function to gather data from /proc/meminfo # return dictionary for quicker lookup of both values def get_meminfo(): result = dict() for line in open('/proc/meminfo'): k = line.split(':', 3) v = k[1].split() result[k[0]] = int(v[0]) return result # set global variables rtaccess = 0 wtaccess = 0 mpa = 0 mbd = 0 apcl = 0 apd = 0 access = 0 misses = 0 rhits = 0 whits = 0 debug = 0 # args def usage(): print("USAGE: %s [-T] [ interval [count] ]" % argv[0]) exit() # arguments interval = 5 count = -1 tstamp = 0 if len(argv) > 1: if str(argv[1]) == '-T': tstamp = 1 if len(argv) > 1 and tstamp == 0: try: if int(argv[1]) > 0: interval = int(argv[1]) if len(argv) > 2: if int(argv[2]) > 0: count = int(argv[2]) except: usage() elif len(argv) > 2 and tstamp == 1: try: if int(argv[2]) > 0: interval = int(argv[2]) if len(argv) >= 4: if int(argv[3]) > 0: count = int(argv[3]) except: usage() # load BPF program bpf_text = """ #include struct key_t { u64 ip; }; BPF_HASH(counts, struct key_t); int do_count(struct pt_regs *ctx) { struct key_t key = {}; u64 zero = 0, *val; u64 ip; key.ip = PT_REGS_IP(ctx); val = counts.lookup_or_init(&key, &zero); // update counter (*val)++; return 0; } """ b = BPF(text=bpf_text) b.attach_kprobe(event="add_to_page_cache_lru", fn_name="do_count") b.attach_kprobe(event="mark_page_accessed", fn_name="do_count") b.attach_kprobe(event="account_page_dirtied", fn_name="do_count") b.attach_kprobe(event="mark_buffer_dirty", fn_name="do_count") # header if tstamp: print("%-8s " % "TIME", end="") print("%8s %8s %8s %10s %10s %12s %10s" % ("HITS", "MISSES", "DIRTIES", "READ_HIT%", "WRITE_HIT%", "BUFFERS_MB", "CACHED_MB")) loop = 0 exiting = 0 while 1: if count > 0: loop += 1 if loop > count: exit() try: sleep(interval) except KeyboardInterrupt: exiting = 1 # as cleanup can take many seconds, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) counts = b.get_table("counts") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): if re.match('mark_page_accessed', b.ksym(k.ip)) is not None: mpa = max(0, v.value) if re.match('mark_buffer_dirty', b.ksym(k.ip)) is not None: mbd = max(0, v.value) if re.match('add_to_page_cache_lru', b.ksym(k.ip)) is not None: apcl = max(0, v.value) if re.match('account_page_dirtied', b.ksym(k.ip)) is not None: apd = max(0, v.value) # access = total cache access incl. reads(mpa) and writes(mbd) # misses = total of add to lru which we do when we write(mbd) # and also the mark the page dirty(same as mbd) access = (mpa + mbd) misses = (apcl + apd) # rtaccess is the read hit % during the sample period. # wtaccess is the write hit % during the smaple period. if mpa > 0: rtaccess = float(mpa) / (access + misses) if apcl > 0: wtaccess = float(apcl) / (access + misses) if wtaccess != 0: whits = 100 * wtaccess if rtaccess != 0: rhits = 100 * rtaccess if debug: print("%d %d %d %d %d %d %f %f %d %d\n" % (mpa, mbd, apcl, apd, access, misses, rtaccess, wtaccess, rhits, whits)) counts.clear() # Get memory info mem = get_meminfo() cached = int(mem["Cached"]) / 1024 buff = int(mem["Buffers"]) / 1024 if tstamp == 1: print("%-8s " % strftime("%H:%M:%S"), end="") print("%8d %8d %8d %9.1f%% %9.1f%% %12.0f %10.0f" % (access, misses, mbd, rhits, whits, buff, cached)) mpa = 0 mbd = 0 apcl = 0 apd = 0 access = 0 misses = 0 rhits = 0 cached = 0 buff = 0 whits = 0 rtaccess = 0 wtaccess = 0 if exiting: print("Detaching...") exit() bpfcc-0.2.0+git0.02884a026/tools/cachestat_example.txt000066400000000000000000000103511305314114400220510ustar00rootroot00000000000000# ./cachestat -h USAGE: ./cachestat [-T] [ interval [count] ] show Linux page cache hit/miss statistics including read and write hit % optional arguments: -T include timestamp on output examples: ./cachestat # run with default option of 5 seconds delay ./cachestat -T # run with default option of 5 seconds delay with timestamps ./cachestat 1 # print every second hit/miss stats ./cachestat -T 1 # include timestamps with one second samples ./cachestat 1 5 # run with interval of one second for five iterations ./cachestat -T 1 5 # include timestamps with interval of one second for five iterations # ./cachestat 1 HITS MISSES DIRTIES READ_HIT% WRITE_HIT% BUFFERS_MB CACHED_MB 0 58 0 0.0% 100.0% 0 11334 146113 0 0 100.0% 0.0% 0 11334 244143 0 0 100.0% 0.0% 0 11334 216833 0 0 100.0% 0.0% 0 11334 248209 0 0 100.0% 0.0% 0 11334 205825 0 0 100.0% 0.0% 0 11334 286654 0 0 100.0% 0.0% 0 11334 275850 0 0 100.0% 0.0% 0 11334 272883 0 0 100.0% 0.0% 0 11334 261633 0 0 100.0% 0.0% 0 11334 252826 0 0 100.0% 0.0% 0 11334 235253 70 3 100.0% 0.0% 0 11335 204946 0 0 100.0% 0.0% 0 11335 0 0 0 0.0% 0.0% 0 11335 0 0 0 0.0% 0.0% 0 11335 0 0 0 0.0% 0.0% 0 11335 Above shows the reading of a 12GB file already cached in the OS page cache and again below with timestamps. # ./cachestat -T 1 TIME HITS MISSES DIRTIES READ_HIT% WRITE_HIT% BUFFERS_MB CACHED_MB 16:07:10 0 0 0 0.0% 0.0% 0 11336 16:07:11 0 0 0 0.0% 0.0% 0 11336 16:07:12 117849 0 0 100.0% 0.0% 0 11336 16:07:13 212558 0 0 100.0% 0.0% 0 11336 16:07:14 302559 1 0 100.0% 0.0% 0 11336 16:07:15 309230 0 0 100.0% 0.0% 0 11336 16:07:16 305701 0 0 100.0% 0.0% 0 11336 16:07:17 312754 0 0 100.0% 0.0% 0 11336 16:07:18 308406 0 0 100.0% 0.0% 0 11336 16:07:19 298185 0 0 100.0% 0.0% 0 11336 16:07:20 236128 0 0 100.0% 0.0% 0 11336 16:07:21 257616 0 0 100.0% 0.0% 0 11336 16:07:22 179792 0 0 100.0% 0.0% 0 11336 Command used to generate the activity # dd if=/root/mnt2/testfile of=/dev/null bs=8192 1442795+0 records in 1442795+0 records out 11819376640 bytes (12 GB) copied, 3.9301 s, 3.0 GB/s Below shows the dirty ratio increasing as we add a file to the page cache # ./cachestat.py HITS MISSES DIRTIES READ_HIT% WRITE_HIT% BUFFERS_MB CACHED_MB 1074 44 13 94.9% 2.9% 1 223 2195 170 8 92.5% 6.8% 1 143 182 53 56 53.6% 1.3% 1 143 62480 40960 20480 40.6% 19.8% 1 223 7 2 5 22.2% 22.2% 1 223 348 0 0 100.0% 0.0% 1 223 0 0 0 0.0% 0.0% 1 223 0 0 0 0.0% 0.0% 1 223 0 0 0 0.0% 0.0% 1 223 0 0 0 0.0% 0.0% 1 223 The file copied into page cache was named 80m with a size of 83886080 (83886080/4096) = 20480, this matches what we see under dirties bpfcc-0.2.0+git0.02884a026/tools/cachetop.py000077500000000000000000000154511305314114400200070ustar00rootroot00000000000000#!/usr/bin/env python # @lint-avoid-python-3-compatibility-imports # # cachetop Count cache kernel function calls per processes # For Linux, uses BCC, eBPF. # # USAGE: cachetop # Taken from cachestat by Brendan Gregg # # Copyright (c) 2016-present, Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 13-Jul-2016 Emmanuel Bretelle first version from __future__ import absolute_import from __future__ import division # Do not import unicode_literals until #623 is fixed # from __future__ import unicode_literals from __future__ import print_function from bcc import BPF from collections import defaultdict from time import strftime import argparse import curses import pwd import re import signal from time import sleep FIELDS = ( "PID", "UID", "CMD", "HITS", "MISSES", "DIRTIES", "READ_HIT%", "WRITE_HIT%" ) DEFAULT_FIELD = "HITS" # signal handler def signal_ignore(signal, frame): print() # Function to gather data from /proc/meminfo # return dictionary for quicker lookup of both values def get_meminfo(): result = {} for line in open('/proc/meminfo'): k = line.split(':', 3) v = k[1].split() result[k[0]] = int(v[0]) return result def get_processes_stats( bpf, sort_field=FIELDS.index(DEFAULT_FIELD), sort_reverse=False): ''' Return a tuple containing: buffer cached list of tuple with per process cache stats ''' counts = bpf.get_table("counts") stats = defaultdict(lambda: defaultdict(int)) for k, v in counts.items(): stats["%d-%d-%s" % (k.pid, k.uid, k.comm)][k.ip] = v.value stats_list = [] for pid, count in sorted(stats.items(), key=lambda stat: stat[0]): rtaccess = 0 wtaccess = 0 mpa = 0 mbd = 0 apcl = 0 apd = 0 access = 0 misses = 0 rhits = 0 whits = 0 for k, v in count.items(): if re.match('mark_page_accessed', bpf.ksym(k)) is not None: mpa = max(0, v) if re.match('mark_buffer_dirty', bpf.ksym(k)) is not None: mbd = max(0, v) if re.match('add_to_page_cache_lru', bpf.ksym(k)) is not None: apcl = max(0, v) if re.match('account_page_dirtied', bpf.ksym(k)) is not None: apd = max(0, v) # access = total cache access incl. reads(mpa) and writes(mbd) # misses = total of add to lru which we do when we write(mbd) # and also the mark the page dirty(same as mbd) access = (mpa + mbd) misses = (apcl + apd) # rtaccess is the read hit % during the sample period. # wtaccess is the write hit % during the smaple period. if mpa > 0: rtaccess = float(mpa) / (access + misses) if apcl > 0: wtaccess = float(apcl) / (access + misses) if wtaccess != 0: whits = 100 * wtaccess if rtaccess != 0: rhits = 100 * rtaccess _pid, uid, comm = pid.split('-', 2) stats_list.append( (int(_pid), uid, comm, access, misses, mbd, rhits, whits)) stats_list = sorted( stats_list, key=lambda stat: stat[sort_field], reverse=sort_reverse ) counts.clear() return stats_list def handle_loop(stdscr, args): # don't wait on key press stdscr.nodelay(1) # set default sorting field sort_field = FIELDS.index(DEFAULT_FIELD) sort_reverse = False # load BPF program bpf_text = """ #include struct key_t { u64 ip; u32 pid; u32 uid; char comm[16]; }; BPF_HASH(counts, struct key_t); int do_count(struct pt_regs *ctx) { struct key_t key = {}; u64 zero = 0 , *val; u64 pid = bpf_get_current_pid_tgid(); u32 uid = bpf_get_current_uid_gid(); key.ip = PT_REGS_IP(ctx); key.pid = pid & 0xFFFFFFFF; key.uid = uid & 0xFFFFFFFF; bpf_get_current_comm(&(key.comm), 16); val = counts.lookup_or_init(&key, &zero); // update counter (*val)++; return 0; } """ b = BPF(text=bpf_text) b.attach_kprobe(event="add_to_page_cache_lru", fn_name="do_count") b.attach_kprobe(event="mark_page_accessed", fn_name="do_count") b.attach_kprobe(event="account_page_dirtied", fn_name="do_count") b.attach_kprobe(event="mark_buffer_dirty", fn_name="do_count") exiting = 0 while 1: s = stdscr.getch() if s == ord('q'): exiting = 1 elif s == ord('r'): sort_reverse = not sort_reverse elif s == ord('<'): sort_field = max(0, sort_field - 1) elif s == ord('>'): sort_field = min(len(FIELDS) - 1, sort_field + 1) try: sleep(args.interval) except KeyboardInterrupt: exiting = 1 # as cleanup can take many seconds, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) # Get memory info mem = get_meminfo() cached = int(mem["Cached"]) / 1024 buff = int(mem["Buffers"]) / 1024 process_stats = get_processes_stats( b, sort_field=sort_field, sort_reverse=sort_reverse) stdscr.clear() stdscr.addstr( 0, 0, "%-8s Buffers MB: %.0f / Cached MB: %.0f " "/ Sort: %s / Order: %s" % ( strftime("%H:%M:%S"), buff, cached, FIELDS[sort_field], sort_reverse and "descending" or "ascending" ) ) # header stdscr.addstr( 1, 0, "{0:8} {1:8} {2:16} {3:8} {4:8} {5:8} {6:10} {7:10}".format( *FIELDS ), curses.A_REVERSE ) (height, width) = stdscr.getmaxyx() for i, stat in enumerate(process_stats): stdscr.addstr( i + 2, 0, "{0:8} {username:8.8} {2:16} {3:8} {4:8} " "{5:8} {6:9.1f}% {7:9.1f}%".format( *stat, username=pwd.getpwuid(int(stat[1]))[0] ) ) if i > height - 4: break stdscr.refresh() if exiting: print("Detaching...") return def parse_arguments(): parser = argparse.ArgumentParser( description='show Linux page cache hit/miss statistics including read ' 'and write hit % per processes in a UI like top.' ) parser.add_argument( 'interval', type=int, default=5, nargs='?', help='Interval between probes.' ) args = parser.parse_args() return args args = parse_arguments() curses.wrapper(handle_loop, args) bpfcc-0.2.0+git0.02884a026/tools/cachetop_example.txt000066400000000000000000000075161305314114400217110ustar00rootroot00000000000000# ./cachetop -h usage: cachetop.py [-h] [interval] show Linux page cache hit/miss statistics including read and write hit % per processes in a UI like top. positional arguments: interval Interval between probes. optional arguments: -h, --help show this help message and exit examples: ./cachetop # run with default option of 5 seconds delay ./cachetop 1 # print every second hit/miss stats # ./cachetop 5 13:01:01 Buffers MB: 76 / Cached MB: 114 / Sort: HITS / Order: ascending PID UID CMD HITS MISSES DIRTIES READ_HIT% WRITE_HIT% 1 root systemd 2 0 0 100.0% 0.0% 680 root vminfo 3 4 2 14.3% 42.9% 567 syslog rs:main Q:Reg 10 4 2 57.1% 21.4% 986 root kworker/u2:2 10 2457 4 0.2% 99.5% 988 root kworker/u2:2 10 9 4 31.6% 36.8% 877 vagrant systemd 18 4 2 72.7% 13.6% 983 root python 148 3 143 3.3% 1.3% 981 root strace 419 3 143 65.4% 0.5% 544 messageb dbus-daemon 455 371 454 0.1% 0.4% 243 root jbd2/dm-0-8 457 371 454 0.4% 0.4% 985 root (mount) 560 2457 4 18.4% 81.4% 987 root systemd-udevd 566 9 4 97.7% 1.2% 988 root systemd-cgroups 569 9 4 97.8% 1.2% 986 root modprobe 578 9 4 97.8% 1.2% 287 root systemd-journal 598 371 454 14.9% 0.3% 985 root mount 692 2457 4 21.8% 78.0% 984 vagrant find 9529 2457 4 79.5% 20.5% Above shows the run of `find /` on a newly booted system. Command used to generate the activity # find / Below shows the hit rate increases as we run find a second time and it gets it its pages from the cache. # ./cachetop.py 13:01:01 Buffers MB: 76 / Cached MB: 115 / Sort: HITS / Order: ascending PID UID CMD HITS MISSES DIRTIES READ_HIT% WRITE_HIT% 544 messageb dbus-daemon 2 2 1 25.0% 50.0% 680 root vminfo 2 2 1 25.0% 50.0% 243 root jbd2/dm-0-8 3 2 1 40.0% 40.0% 1068 root python 5 0 0 100.0% 0.0% 1071 vagrant bash 350 0 0 100.0% 0.0% 1071 vagrant find 12959 0 0 100.0% 0.0% Below shows that the dirty pages increases as a file of 80M is created running # dd if=/dev/urandom of=/tmp/c bs=8192 count=10000 # ./cachetop.py 10 13:01:01 Buffers MB: 77 / Cached MB: 193 / Sort: HITS / Order: ascending PID UID CMD HITS MISSES DIRTIES READ_HIT% WRITE_HIT% 544 messageb dbus-daemon 9 10 7 10.5% 15.8% 680 root vminfo 9 10 7 10.5% 15.8% 1109 root python 22 0 0 100.0% 0.0% 243 root jbd2/dm-0-8 25 10 7 51.4% 8.6% 1070 root kworker/u2:2 85 0 0 100.0% 0.0% 1110 vagrant bash 366 0 0 100.0% 0.0% 1110 vagrant dd 42183 40000 20000 27.0% 24.3% The file copied into page cache was named /tmp/c with a size of 81920000 (81920000/4096) = 20000 bpfcc-0.2.0+git0.02884a026/tools/capable.py000077500000000000000000000100331305314114400175770ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # capable Trace security capabilitiy checks (cap_capable()). # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: capable [-h] [-v] [-p PID] # # ToDo: add -s for kernel stacks. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 13-Sep-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse from time import strftime import ctypes as ct # arguments examples = """examples: ./capable # trace capability checks ./capable -v # verbose: include non-audit checks ./capable -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace security capability checks", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-v", "--verbose", action="store_true", help="include non-audit checks") parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # capabilities to names, generated from (and will need updating): # awk '/^#define.CAP_.*[0-9]$/ { print " " $3 ": \"" $2 "\"," }' \ # include/uapi/linux/capability.h capabilities = { 0: "CAP_CHOWN", 1: "CAP_DAC_OVERRIDE", 2: "CAP_DAC_READ_SEARCH", 3: "CAP_FOWNER", 4: "CAP_FSETID", 5: "CAP_KILL", 6: "CAP_SETGID", 7: "CAP_SETUID", 8: "CAP_SETPCAP", 9: "CAP_LINUX_IMMUTABLE", 10: "CAP_NET_BIND_SERVICE", 11: "CAP_NET_BROADCAST", 12: "CAP_NET_ADMIN", 13: "CAP_NET_RAW", 14: "CAP_IPC_LOCK", 15: "CAP_IPC_OWNER", 16: "CAP_SYS_MODULE", 17: "CAP_SYS_RAWIO", 18: "CAP_SYS_CHROOT", 19: "CAP_SYS_PTRACE", 20: "CAP_SYS_PACCT", 21: "CAP_SYS_ADMIN", 22: "CAP_SYS_BOOT", 23: "CAP_SYS_NICE", 24: "CAP_SYS_RESOURCE", 25: "CAP_SYS_TIME", 26: "CAP_SYS_TTY_CONFIG", 27: "CAP_MKNOD", 28: "CAP_LEASE", 29: "CAP_AUDIT_WRITE", 30: "CAP_AUDIT_CONTROL", 31: "CAP_SETFCAP", 32: "CAP_MAC_OVERRIDE", 33: "CAP_MAC_ADMIN", 34: "CAP_SYSLOG", 35: "CAP_WAKE_ALARM", 36: "CAP_BLOCK_SUSPEND", 37: "CAP_AUDIT_READ", } # define BPF program bpf_text = """ #include #include struct data_t { // switch to u32s when supported u64 pid; u64 uid; int cap; int audit; char comm[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(events); int kprobe__cap_capable(struct pt_regs *ctx, const struct cred *cred, struct user_namespace *targ_ns, int cap, int audit) { u32 pid = bpf_get_current_pid_tgid(); FILTER1 FILTER2 u32 uid = bpf_get_current_uid_gid(); struct data_t data = {.pid = pid, .uid = uid, .cap = cap, .audit = audit}; bpf_get_current_comm(&data.comm, sizeof(data.comm)); events.perf_submit(ctx, &data, sizeof(data)); return 0; }; """ if args.pid: bpf_text = bpf_text.replace('FILTER1', 'if (pid != %s) { return 0; }' % args.pid) if not args.verbose: bpf_text = bpf_text.replace('FILTER2', 'if (audit == 0) { return 0; }') bpf_text = bpf_text.replace('FILTER1', '') bpf_text = bpf_text.replace('FILTER2', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("uid", ct.c_ulonglong), ("cap", ct.c_int), ("audit", ct.c_int), ("comm", ct.c_char * TASK_COMM_LEN) ] # header print("%-9s %-6s %-6s %-16s %-4s %-20s %s" % ( "TIME", "UID", "PID", "COMM", "CAP", "NAME", "AUDIT")) # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents if event.cap in capabilities: name = capabilities[event.cap] else: name = "?" print("%-9s %-6d %-6d %-16s %-4d %-20s %d" % (strftime("%H:%M:%S"), event.uid, event.pid, event.comm, event.cap, name, event.audit)) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/capable_example.txt000066400000000000000000000070711305314114400215060ustar00rootroot00000000000000Demonstrations of capable, the Linux eBPF/bcc version. capable traces calls to the kernel cap_capable() function, which does security capability checks, and prints details for each call. For example: # ./capable.py TIME UID PID COMM CAP NAME AUDIT 22:11:23 114 2676 snmpd 12 CAP_NET_ADMIN 1 22:11:23 0 6990 run 24 CAP_SYS_RESOURCE 1 22:11:23 0 7003 chmod 3 CAP_FOWNER 1 22:11:23 0 7003 chmod 4 CAP_FSETID 1 22:11:23 0 7005 chmod 4 CAP_FSETID 1 22:11:23 0 7005 chmod 4 CAP_FSETID 1 22:11:23 0 7006 chown 4 CAP_FSETID 1 22:11:23 0 7006 chown 4 CAP_FSETID 1 22:11:23 0 6990 setuidgid 6 CAP_SETGID 1 22:11:23 0 6990 setuidgid 6 CAP_SETGID 1 22:11:23 0 6990 setuidgid 7 CAP_SETUID 1 22:11:24 0 7013 run 24 CAP_SYS_RESOURCE 1 22:11:24 0 7026 chmod 3 CAP_FOWNER 1 22:11:24 0 7026 chmod 4 CAP_FSETID 1 22:11:24 0 7028 chmod 4 CAP_FSETID 1 22:11:24 0 7028 chmod 4 CAP_FSETID 1 22:11:24 0 7029 chown 4 CAP_FSETID 1 22:11:24 0 7029 chown 4 CAP_FSETID 1 22:11:24 0 7013 setuidgid 6 CAP_SETGID 1 22:11:24 0 7013 setuidgid 6 CAP_SETGID 1 22:11:24 0 7013 setuidgid 7 CAP_SETUID 1 22:11:25 0 7036 run 24 CAP_SYS_RESOURCE 1 22:11:25 0 7049 chmod 3 CAP_FOWNER 1 22:11:25 0 7049 chmod 4 CAP_FSETID 1 22:11:25 0 7051 chmod 4 CAP_FSETID 1 22:11:25 0 7051 chmod 4 CAP_FSETID 1 [...] This can be useful for general debugging, and also security enforcement: determining a whitelist of capabilities an application needs. The output above includes various capability checks: snmpd checking CAP_NET_ADMIN, run checking CAP_SYS_RESOURCES, then some short-lived processes checking CAP_FOWNER, CAP_FSETID, etc. To see what each of these capabilities does, check the capabilities(7) man page and the kernel source. Sometimes capable catches itself starting up: # ./capable.py TIME UID PID COMM CAP NAME AUDIT 22:22:19 0 21949 capable.py 21 CAP_SYS_ADMIN 1 22:22:19 0 21949 capable.py 21 CAP_SYS_ADMIN 1 22:22:19 0 21949 capable.py 21 CAP_SYS_ADMIN 1 22:22:19 0 21949 capable.py 21 CAP_SYS_ADMIN 1 22:22:19 0 21949 capable.py 21 CAP_SYS_ADMIN 1 22:22:19 0 21949 capable.py 21 CAP_SYS_ADMIN 1 22:22:19 0 21952 run 24 CAP_SYS_RESOURCE 1 [...] These are capability checks from BPF and perf_events syscalls. USAGE: # ./capable.py -h usage: capable.py [-h] [-v] [-p PID] Trace security capability checks optional arguments: -h, --help show this help message and exit -v, --verbose include non-audit checks -p PID, --pid PID trace this PID only examples: ./capable # trace capability checks ./capable -v # verbose: include non-audit checks ./capable -p 181 # only trace PID 181 bpfcc-0.2.0+git0.02884a026/tools/cpudist.py000077500000000000000000000115551305314114400176750ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # cpudist Summarize on- and off-CPU time per task as a histogram. # # USAGE: cpudist [-h] [-O] [-T] [-m] [-P] [-L] [-p PID] [interval] [count] # # This measures the time a task spends on or off the CPU, and shows this time # as a histogram, optionally per-process. # # Copyright 2016 Sasha Goldshtein # Licensed under the Apache License, Version 2.0 (the "License") from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse examples = """examples: cpudist # summarize on-CPU time as a histogram cpudist -O # summarize off-CPU time as a histogram cpudist 1 10 # print 1 second summaries, 10 times cpudist -mT 1 # 1s summaries, milliseconds, and timestamps cpudist -P # show each PID separately cpudist -p 185 # trace PID 185 only """ parser = argparse.ArgumentParser( description="Summarize on-CPU time per task as a histogram.", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-O", "--offcpu", action="store_true", help="measure off-CPU time") parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-m", "--milliseconds", action="store_true", help="millisecond histogram") parser.add_argument("-P", "--pids", action="store_true", help="print a histogram per process ID") parser.add_argument("-L", "--tids", action="store_true", help="print a histogram per thread ID") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("interval", nargs="?", default=99999999, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() countdown = int(args.count) debug = 0 bpf_text = """#include #include """ if not args.offcpu: bpf_text += "#define ONCPU\n" bpf_text += """ typedef struct pid_key { u64 id; u64 slot; } pid_key_t; BPF_HASH(start, u32, u64); STORAGE static inline void store_start(u32 tgid, u32 pid, u64 ts) { if (FILTER) return; start.update(&pid, &ts); } static inline void update_hist(u32 tgid, u32 pid, u64 ts) { if (FILTER) return; u64 *tsp = start.lookup(&pid); if (tsp == 0) return; if (ts < *tsp) { // Probably a clock issue where the recorded on-CPU event had a // timestamp later than the recorded off-CPU event, or vice versa. return; } u64 delta = ts - *tsp; FACTOR STORE } int sched_switch(struct pt_regs *ctx, struct task_struct *prev) { u64 ts = bpf_ktime_get_ns(); u64 pid_tgid = bpf_get_current_pid_tgid(); u32 tgid = pid_tgid >> 32, pid = pid_tgid; #ifdef ONCPU if (prev->state == TASK_RUNNING) { #else if (1) { #endif u32 prev_pid = prev->pid; u32 prev_tgid = prev->tgid; #ifdef ONCPU update_hist(prev_tgid, prev_pid, ts); #else store_start(prev_tgid, prev_pid, ts); #endif } BAIL: #ifdef ONCPU store_start(tgid, pid, ts); #else update_hist(tgid, pid, ts); #endif return 0; } """ if args.pid: bpf_text = bpf_text.replace('FILTER', 'tgid != %s' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '0') if args.milliseconds: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000000;') label = "msecs" else: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000;') label = "usecs" if args.pids or args.tids: section = "pid" pid = "tgid" if args.tids: pid = "pid" section = "tid" bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist, pid_key_t);') bpf_text = bpf_text.replace('STORE', 'pid_key_t key = {.id = ' + pid + ', .slot = bpf_log2l(delta)}; ' + 'dist.increment(key);') else: section = "" bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist);') bpf_text = bpf_text.replace('STORE', 'dist.increment(bpf_log2l(delta));') if debug: print(bpf_text) b = BPF(text=bpf_text) b.attach_kprobe(event="finish_task_switch", fn_name="sched_switch") print("Tracing %s-CPU time... Hit Ctrl-C to end." % ("off" if args.offcpu else "on")) exiting = 0 if args.interval else 1 dist = b.get_table("dist") while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") def pid_to_comm(pid): try: comm = open("/proc/%d/comm" % pid, "r").read() return "%d %s" % (pid, comm) except IOError: return str(pid) dist.print_log2_hist(label, section, section_print_fn=pid_to_comm) dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/cpudist_example.txt000066400000000000000000000402341305314114400215700ustar00rootroot00000000000000Demonstrations of cpudist. This program summarizes task on-CPU time as a histogram, showing how long tasks spent on the CPU before being descheduled. This provides valuable information that can indicate oversubscription (too many tasks for too few processors), overhead due to excessive context switching (e.g. a common shared lock for multiple threads), uneven workload distribution, too-granular tasks, and more. Alternatively, the same options are available for summarizing task off-CPU time, which helps understand how often threads are being descheduled and how long they spend waiting for I/O, locks, timers, and other causes of suspension. # ./cpudist.py Tracing on-CPU time... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 1 | | 4 -> 7 : 1 | | 8 -> 15 : 13 |** | 16 -> 31 : 187 |****************************************| 32 -> 63 : 89 |******************* | 64 -> 127 : 26 |***** | 128 -> 255 : 0 | | 256 -> 511 : 1 | | This is from a mostly idle system. Tasks wake up occasionally and run for only a few dozen microseconds, and then get descheduled. Here's some output from a system that is heavily loaded by threads that perform computation but also compete for a lock: # ./cpudist.py Tracing on-CPU time... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 51 |* | 2 -> 3 : 395 |*********** | 4 -> 7 : 259 |******* | 8 -> 15 : 61 |* | 16 -> 31 : 75 |** | 32 -> 63 : 31 | | 64 -> 127 : 7 | | 128 -> 255 : 5 | | 256 -> 511 : 3 | | 512 -> 1023 : 5 | | 1024 -> 2047 : 6 | | 2048 -> 4095 : 4 | | 4096 -> 8191 : 1361 |****************************************| 8192 -> 16383 : 523 |*************** | 16384 -> 32767 : 3 | | A bimodal distribution is now clearly visible. Most of the time, tasks were able to run for 4-16ms before being descheduled (this is likely the quantum length). Occasionally, tasks had to be descheduled a lot earlier -- possibly because they competed for a shared lock. If necessary, you can restrict the output to include only threads from a particular process -- this helps reduce noise: # ./cpudist.py -p $(pidof parprimes) Tracing on-CPU time... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 3 | | 2 -> 3 : 17 | | 4 -> 7 : 39 | | 8 -> 15 : 52 |* | 16 -> 31 : 43 | | 32 -> 63 : 12 | | 64 -> 127 : 13 | | 128 -> 255 : 0 | | 256 -> 511 : 1 | | 512 -> 1023 : 11 | | 1024 -> 2047 : 15 | | 2048 -> 4095 : 41 | | 4096 -> 8191 : 1134 |************************ | 8192 -> 16383 : 1883 |****************************************| 16384 -> 32767 : 65 |* | You can also ask for output at predefined intervals, and include timestamps for easier interpretation. While we're at it, the -P switch will print a histogram separately for each process: # ./cpudist.py -TP 5 3 Tracing on-CPU time... Hit Ctrl-C to end. 03:46:51 pid = 0 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 1 |** | 4 -> 7 : 17 |********************************** | 8 -> 15 : 11 |********************** | 16 -> 31 : 20 |****************************************| 32 -> 63 : 15 |****************************** | 64 -> 127 : 9 |****************** | 128 -> 255 : 6 |************ | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 1 |** | pid = 5068 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 1 |************* | 4 -> 7 : 3 |****************************************| 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 1 |************* | 03:46:56 pid = 0 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 1 |** | 4 -> 7 : 19 |****************************************| 8 -> 15 : 11 |*********************** | 16 -> 31 : 9 |****************** | 32 -> 63 : 3 |****** | 64 -> 127 : 1 |** | 128 -> 255 : 3 |****** | 256 -> 511 : 0 | | 512 -> 1023 : 1 |** | pid = 5068 usecs : count distribution 0 -> 1 : 1 |******************** | 2 -> 3 : 0 | | 4 -> 7 : 2 |****************************************| 03:47:01 pid = 0 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 12 |******************************** | 8 -> 15 : 15 |****************************************| 16 -> 31 : 15 |****************************************| 32 -> 63 : 0 | | 64 -> 127 : 3 |******** | 128 -> 255 : 1 |** | 256 -> 511 : 0 | | 512 -> 1023 : 1 |** | pid = 5068 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 1 |****** | 4 -> 7 : 6 |****************************************| 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 2 |************* | This histogram was obtained while executing `dd if=/dev/zero of=/dev/null` with fairly large block sizes. You could also ask for an off-CPU report using the -O switch. Here's a histogram of task block times while the system is heavily loaded: # ./cpudist -O -p $(parprimes) Tracing off-CPU time... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 1 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 3 | | 64 -> 127 : 1 | | 128 -> 255 : 1 | | 256 -> 511 : 0 | | 512 -> 1023 : 2 | | 1024 -> 2047 : 4 | | 2048 -> 4095 : 3 | | 4096 -> 8191 : 70 |*** | 8192 -> 16383 : 867 |****************************************| 16384 -> 32767 : 141 |****** | 32768 -> 65535 : 8 | | 65536 -> 131071 : 0 | | 131072 -> 262143 : 1 | | 262144 -> 524287 : 2 | | 524288 -> 1048575 : 3 | | As you can see, threads are switching out for relatively long intervals, even though we know the workload doesn't have any significant blocking. This can be a result of over-subscription -- too many threads contending over too few CPUs. Indeed, there are four available CPUs and more than four runnable threads: # nproc 4 # cat /proc/loadavg 0.04 0.11 0.06 9/147 7494 (This shows we have 9 threads runnable out of 147 total. This is more than 4, the number of available CPUs.) Finally, let's ask for a per-thread report and values in milliseconds instead of microseconds: # ./cpudist.py -p $(pidof parprimes) -mL Tracing on-CPU time... Hit Ctrl-C to end. tid = 5092 msecs : count distribution 0 -> 1 : 3 | | 2 -> 3 : 4 | | 4 -> 7 : 4 | | 8 -> 15 : 535 |****************************************| 16 -> 31 : 14 |* | tid = 5093 msecs : count distribution 0 -> 1 : 8 | | 2 -> 3 : 6 | | 4 -> 7 : 4 | | 8 -> 15 : 534 |****************************************| 16 -> 31 : 12 | | tid = 5094 msecs : count distribution 0 -> 1 : 38 |*** | 2 -> 3 : 5 | | 4 -> 7 : 5 | | 8 -> 15 : 476 |****************************************| 16 -> 31 : 25 |** | tid = 5095 msecs : count distribution 0 -> 1 : 31 |** | 2 -> 3 : 6 | | 4 -> 7 : 10 | | 8 -> 15 : 478 |****************************************| 16 -> 31 : 20 |* | tid = 5096 msecs : count distribution 0 -> 1 : 21 |* | 2 -> 3 : 5 | | 4 -> 7 : 4 | | 8 -> 15 : 523 |****************************************| 16 -> 31 : 16 |* | tid = 5097 msecs : count distribution 0 -> 1 : 11 | | 2 -> 3 : 7 | | 4 -> 7 : 7 | | 8 -> 15 : 502 |****************************************| 16 -> 31 : 23 |* | tid = 5098 msecs : count distribution 0 -> 1 : 21 |* | 2 -> 3 : 5 | | 4 -> 7 : 3 | | 8 -> 15 : 494 |****************************************| 16 -> 31 : 28 |** | tid = 5099 msecs : count distribution 0 -> 1 : 15 |* | 2 -> 3 : 4 | | 4 -> 7 : 6 | | 8 -> 15 : 521 |****************************************| 16 -> 31 : 12 | | It looks like all threads are more-or-less equally busy, and are typically switched out after running for 8-15 milliseconds (again, this is the typical quantum length). USAGE message: # ./cpudist.py -h usage: cpudist.py [-h] [-O] [-T] [-m] [-P] [-L] [-p PID] [interval] [count] Summarize on-CPU time per task as a histogram. positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -O, --offcpu measure off-CPU time -T, --timestamp include timestamp on output -m, --milliseconds millisecond histogram -P, --pids print a histogram per process ID -L, --tids print a histogram per thread ID -p PID, --pid PID trace this PID only examples: cpudist # summarize on-CPU time as a histogram cpudist -O # summarize off-CPU time as a histogram cpudist 1 10 # print 1 second summaries, 10 times cpudist -mT 1 # 1s summaries, milliseconds, and timestamps cpudist -P # show each PID separately cpudist -p 185 # trace PID 185 only bpfcc-0.2.0+git0.02884a026/tools/cpuunclaimed.py000077500000000000000000000305371305314114400206740ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # cpuunclaimed Sample CPU run queues and calculate unclaimed idle CPU. # For Linux, uses BCC, eBPF. # # This samples the length of the run queues and determine when there are idle # CPUs, yet queued threads waiting their turn. Report the amount of idle # (yet unclaimed by waiting threads) CPU as a system-wide percentage. # # This situation can happen for a number of reasons: # # - An application has been bound to some, but not all, CPUs, and has runnable # threads that cannot migrate to other CPUs due to this configuration. # - CPU affinity: an optimization that leaves threads on CPUs where the CPU # caches are warm, even if this means short periods of waiting while other # CPUs are idle. The wait period is tunale (see sysctl, kernel.sched*). # - Scheduler bugs. # # An unclaimed idle of < 1% is likely to be CPU affinity, and not usually a # cause for concern. By leaving the CPU idle, overall throughput of the system # may be improved. This tool is best for identifying larger issues, > 2%, due # to the coarseness of its 99 Hertz samples. # # This is an experimental tool that currently works by use of sampling to # keep overheads low. Tool assumptions: # # - CPU samples consistently fire around the same offset. There will sometimes # be a lag as a sample is delayed by higher-priority interrupts, but it is # assumed the subsequent samples will catch up to the expected offsets (as # is seen in practice). You can use -J to inspect sample offsets. Some # systems can power down CPUs when idle, and when they wake up again they # may begin firing at a skewed offset: this tool will detect the skew, print # an error, and exit. # - All CPUs are online (see ncpu). # # If this identifies unclaimed CPU, you can double check it by dumping raw # samples (-j), as well as using other tracing tools to instrument scheduler # events (although this latter approach has much higher overhead). # # This tool passes all sampled events to user space for post processing. # I originally wrote this to do the calculations entirerly in kernel context, # and only pass a summary. That involves a number of challenges, and the # overhead savings may not outweigh the caveats. You can see my WIP here: # https://gist.github.com/brendangregg/731cf2ce54bf1f9a19d4ccd397625ad9 # # USAGE: cpuunclaimed [-h] [-j] [-J] [-T] [interval] [count] # # If you see "Lost 1881 samples" warnings, try increasing wakeup_hz. # # REQUIRES: Linux 4.9+ (BPF_PROG_TYPE_PERF_EVENT support). Under tools/old is # a version of this tool that may work on Linux 4.6 - 4.8. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Dec-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF, PerfType, PerfSWConfig from time import sleep, strftime from ctypes import c_int import argparse import multiprocessing from os import getpid, system import ctypes as ct # arguments examples = """examples: ./cpuunclaimed # sample and calculate unclaimed idle CPUs, # output every 1 second (default) ./cpuunclaimed 5 10 # print 5 second summaries, 10 times ./cpuunclaimed -T 1 # 1s summaries and timestamps ./cpuunclaimed -j # raw dump of all samples (verbose), CSV """ parser = argparse.ArgumentParser( description="Sample CPU run queues and calculate unclaimed idle CPU", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-j", "--csv", action="store_true", help="print sample summaries (verbose) as comma-separated values") parser.add_argument("-J", "--fullcsv", action="store_true", help="print sample summaries with extra fields: CPU sample offsets") parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("interval", nargs="?", default=-1, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() countdown = int(args.count) frequency = 99 dobind = 1 wakeup_hz = 10 # frequency to read buffers wakeup_s = float(1) / wakeup_hz ncpu = multiprocessing.cpu_count() # assume all are online debug = 0 # process arguments if args.fullcsv: args.csv = True if args.csv: interval = 0.2 if args.interval != -1 and (args.fullcsv or args.csv): print("ERROR: cannot use interval with either -j or -J. Exiting.") exit() if args.interval == -1: args.interval = "1" interval = float(args.interval) # define BPF program bpf_text = """ #include #include #include struct data_t { u64 ts; u64 cpu; u64 len; }; BPF_PERF_OUTPUT(events); // Declare enough of cfs_rq to find nr_running, since we can't #import the // header. This will need maintenance. It is from kernel/sched/sched.h: struct cfs_rq_partial { struct load_weight load; unsigned int nr_running, h_nr_running; }; int do_perf_event(struct bpf_perf_event_data *ctx) { int cpu = bpf_get_smp_processor_id(); u64 now = bpf_ktime_get_ns(); /* * Fetch the run queue length from task->se.cfs_rq->nr_running. This is an * unstable interface and may need maintenance. Perhaps a future version * of BPF will support task_rq(p) or something similar as a more reliable * interface. */ unsigned int len = 0; struct task_struct *task = NULL; struct cfs_rq_partial *my_q = NULL; task = (struct task_struct *)bpf_get_current_task(); bpf_probe_read(&my_q, sizeof(my_q), &task->se.cfs_rq); bpf_probe_read(&len, sizeof(len), &my_q->nr_running); struct data_t data = {.ts = now, .cpu = cpu, .len = len}; events.perf_submit(ctx, &data, sizeof(data)); return 0; } """ # code substitutions if debug: print(bpf_text) # initialize BPF & perf_events b = BPF(text=bpf_text) # TODO: check for HW counters first and use if more accurate b.attach_perf_event(ev_type=PerfType.SOFTWARE, ev_config=PerfSWConfig.TASK_CLOCK, fn_name="do_perf_event", sample_period=0, sample_freq=frequency) if args.csv: if args.timestamp: print("TIME", end=",") print("TIMESTAMP_ns", end=",") print(",".join("CPU" + str(c) for c in xrange(ncpu)), end="") if args.fullcsv: print(",", end="") print(",".join("OFFSET_ns_CPU" + str(c) for c in xrange(ncpu)), end="") print() else: print(("Sampling run queues... Output every %s seconds. " + "Hit Ctrl-C to end.") % args.interval) class Data(ct.Structure): _fields_ = [ ("ts", ct.c_ulonglong), ("cpu", ct.c_ulonglong), ("len", ct.c_ulonglong) ] samples = {} group = {} last = 0 # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents samples[event.ts] = {} samples[event.ts]['cpu'] = event.cpu samples[event.ts]['len'] = event.len exiting = 0 if args.interval else 1 slept = float(0) # Choose the elapsed time from one sample group to the next that identifies a # new sample group (a group being a set of samples from all CPUs). The # earliest timestamp is compared in each group. This trigger is also used # for sanity testing, if a group's samples exceed half this value. trigger = int(0.8 * (1000000000 / frequency)) # read events b["events"].open_perf_buffer(print_event) while 1: # allow some buffering by calling sleep(), to reduce the context switch # rate and lower overhead. try: if not exiting: sleep(wakeup_s) except KeyboardInterrupt: exiting = 1 b.kprobe_poll() slept += wakeup_s if slept < 0.999 * interval: # floating point workaround continue slept = 0 positive = 0 # number of samples where an idle CPU could have run work running = 0 idle = 0 if debug >= 2: print("DEBUG: begin samples loop, count %d" % len(samples)) for e in sorted(samples): if debug >= 2: print("DEBUG: ts %d cpu %d len %d delta %d trig %d" % (e, samples[e]['cpu'], samples[e]['len'], e - last, e - last > trigger)) # look for time jumps to identify a new sample group if e - last > trigger: # first first group timestamp, and sanity test g_time = 0 g_max = 0 for ge in sorted(group): if g_time == 0: g_time = ge g_max = ge # process previous sample group if args.csv: lens = [0] * ncpu offs = [0] * ncpu for ge in sorted(group): lens[samples[ge]['cpu']] = samples[ge]['len'] if args.fullcsv: offs[samples[ge]['cpu']] = ge - g_time if g_time > 0: # else first sample if args.timestamp: print("%-8s" % strftime("%H:%M:%S"), end=",") print("%d" % g_time, end=",") print(",".join(str(lens[c]) for c in xrange(ncpu)), end="") if args.fullcsv: print(",", end="") print(",".join(str(offs[c]) for c in xrange(ncpu))) else: print() else: # calculate stats g_running = 0 g_queued = 0 for ge in group: if samples[ge]['len'] > 0: g_running += 1 if samples[ge]['len'] > 1: g_queued += samples[ge]['len'] - 1 g_idle = ncpu - g_running # calculate the number of threads that could have run as the # minimum of idle and queued if g_idle > 0 and g_queued > 0: if g_queued > g_idle: i = g_idle else: i = g_queued positive += i running += g_running idle += g_idle # now sanity test, after -J output g_range = g_max - g_time if g_range > trigger / 2: # if a sample group exceeds half the interval, we can no # longer draw conclusions about some CPUs idle while others # have queued work. Error and exit. This can happen when # CPUs power down, then start again on different offsets. # TODO: Since this is a sampling tool, an error margin should # be anticipated, so an improvement may be to bump a counter # instead of exiting, and only exit if this counter shows # a skewed sample rate of over, say, 1%. Such an approach # would allow a small rate of outliers (sampling error), # and, we could tighten the trigger to be, say, trigger / 5. # In the case of a power down, if it's detectable, perhaps # the tool could reinitialize the timers (although exiting # is simple and works). print(("ERROR: CPU samples arrived at skewed offsets " + "(CPUs may have powered down when idle), " + "spanning %d ns (expected < %d ns). Debug with -J, " + "and see the man page. As output may begin to be " + "unreliable, exiting.") % (g_range, trigger / 2)) exit() # these are done, remove for ge in sorted(group): del samples[ge] # begin next group group = {} last = e # stash this timestamp in a sample group dict group[e] = 1 if not args.csv: total = running + idle unclaimed = util = 0 if debug: print("DEBUG: hit %d running %d idle %d total %d buffered %d" % ( positive, running, idle, total, len(samples))) if args.timestamp: print("%-8s " % strftime("%H:%M:%S"), end="") # output if total: unclaimed = float(positive) / total util = float(running) / total print("%%CPU %6.2f%%, unclaimed idle %0.2f%%" % (100 * util, 100 * unclaimed)) countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/cpuunclaimed_example.txt000066400000000000000000000363171305314114400225750ustar00rootroot00000000000000Demonstrations of cpuunclaimed, the Linux eBPF/bcc version. This tool samples the length of the CPU run queues and determine when there are idle CPUs, yet queued threads waiting their turn. It reports the amount of idle (yet unclaimed by waiting threads) CPU as a system-wide percentage. For example: # ./cpuunclaimed.py Sampling run queues... Output every 1 seconds. Hit Ctrl-C to end. %CPU 83.00%, unclaimed idle 0.12% %CPU 87.25%, unclaimed idle 0.38% %CPU 85.00%, unclaimed idle 0.25% %CPU 85.00%, unclaimed idle 0.25% %CPU 80.88%, unclaimed idle 0.00% %CPU 82.25%, unclaimed idle 0.00% %CPU 83.50%, unclaimed idle 0.12% %CPU 81.50%, unclaimed idle 0.00% %CPU 81.38%, unclaimed idle 0.00% [...] This shows a system running at over 80% CPU utilization, and with less than 0.5% unclaimed idle CPUs. Unclaimed idle CPUs can happen for a number of reasons: - An application has been bound to some, but not all, CPUs, and has runnable threads that cannot migrate to other CPUs due to this configuration. - CPU affinity: an optimization that leaves threads on CPUs where the CPU caches are warm, even if this means short periods of waiting while other CPUs are idle. The wait period is tunale (see sysctl, kernel.sched*). - Scheduler bugs. An unclaimed idle of < 1% is likely to be CPU affinity, and not usually a cause for concern. By leaving the CPU idle, overall throughput of the system may be improved. This tool is best for identifying larger issues, > 2%, due to the coarseness of its 99 Hertz samples. This is an 8 CPU system, with an 8 CPU-bound threaded application running that has been bound to one CPU (via taskset): # ./cpuunclaimed.py Sampling run queues... Output every 1 seconds. Hit Ctrl-C to end. %CPU 12.63%, unclaimed idle 86.36% %CPU 12.50%, unclaimed idle 87.50% %CPU 12.63%, unclaimed idle 87.37% %CPU 12.75%, unclaimed idle 87.25% %CPU 12.50%, unclaimed idle 87.50% %CPU 12.63%, unclaimed idle 87.37% %CPU 12.50%, unclaimed idle 87.50% %CPU 12.50%, unclaimed idle 87.50% [...] It shows that 7 of the 8 CPUs (87.5%) are idle at the same time there are queued threads waiting to run on CPU. This is an artifical situation caused by binding threads to the same CPU, to demonstrate how the tool works. This is an 8 CPU system running a Linux kernel build with "make -j8", and -T to print timestamps: # ./cpuunclaimed.py -T Sampling run queues... Output every 1 seconds. Hit Ctrl-C to end. 22:25:55 %CPU 98.88%, unclaimed idle 0.12% 22:25:56 %CPU 99.75%, unclaimed idle 0.25% 22:25:57 %CPU 99.50%, unclaimed idle 0.50% 22:25:58 %CPU 99.25%, unclaimed idle 0.75% 22:25:59 %CPU 99.75%, unclaimed idle 0.25% 22:26:00 %CPU 99.50%, unclaimed idle 0.50% 22:26:01 %CPU 99.25%, unclaimed idle 0.75% 22:26:02 %CPU 99.25%, unclaimed idle 0.75% 22:26:03 %CPU 99.01%, unclaimed idle 0.87% 22:26:04 %CPU 99.88%, unclaimed idle 0.12% 22:26:05 %CPU 99.38%, unclaimed idle 0.62% There's now a consistent, yet small, amount of unclaimed idle CPU. This is expected to be deliberate: CPU affinity, as mentioned earlier. The -j option will print raw samples: around one hundred lines of output every second. For the same system with a Linux kernel build of "make -j8": # ./cpuunclaimed.py -j TIMESTAMP_ns,CPU0,CPU1,CPU2,CPU3,CPU4,CPU5,CPU6,CPU7 514606928954752,1,1,1,1,1,1,1,1 514606939054312,1,1,1,1,1,1,1,2 514606949156518,1,1,1,1,1,1,1,1 514606959256596,2,2,1,1,1,1,1,1 514606969357989,1,1,1,1,1,2,1,1 514606979459700,1,2,1,1,1,2,1,1 514606989560481,1,1,1,1,1,1,1,1 514606999661396,1,1,1,1,1,1,2,1 514607009795601,1,1,1,1,1,1,1,2 514607019862711,1,1,1,1,1,1,1,1 514607029963734,1,1,1,1,1,1,1,1 514607040062372,1,1,1,1,1,1,1,1 514607050197735,1,1,1,2,1,1,1,1 514607060266464,1,1,1,1,1,1,1,2 514607070368025,1,1,1,1,1,2,1,1 514607080468375,1,1,1,1,1,1,1,2 514607090570292,3,2,1,1,1,1,1,1 514607100670725,1,1,1,1,1,2,1,1 514607110771946,1,2,1,1,1,1,1,1 514607120873489,1,1,1,1,2,1,2,1 514607130973857,2,1,1,1,3,1,1,1 514607141080056,0,1,1,1,1,2,1,3 514607151176312,1,1,1,2,1,1,1,1 514607161277753,1,1,1,1,1,1,2,1 514607171379095,1,1,1,1,1,1,1,1 514607181479262,1,1,1,1,1,1,1,1 514607191580794,3,1,1,1,1,1,1,1 514607201680952,1,1,1,1,1,1,2,1 514607211783683,1,1,1,1,1,1,1,1 514607221883274,1,1,1,1,1,1,0,1 514607231984244,1,1,1,1,1,1,1,1 514607242085698,1,1,1,1,1,1,1,1 514607252216898,1,2,1,1,1,1,1,1 514607262289420,1,1,1,1,1,2,1,1 514607272389922,1,1,1,1,1,1,1,1 514607282489413,1,1,1,1,1,1,1,1 514607292589950,1,3,1,1,1,1,1,1 514607302693367,1,1,1,1,2,1,1,1 514607312793792,1,1,1,1,1,1,1,1 514607322895249,1,1,1,3,1,1,3,1 514607332994278,1,0,1,1,1,2,1,2 514607343095836,1,1,1,1,1,2,1,1 514607353196533,1,1,1,1,2,1,1,1 514607363297749,1,1,1,1,1,1,1,2 514607373399011,1,1,1,1,1,1,1,2 514607383499730,1,1,1,1,1,1,1,2 514607393601510,1,1,1,1,1,1,1,2 514607403704117,2,1,1,1,1,1,1,2 514607413802700,1,1,1,1,2,1,0,1 514607423904559,1,1,1,1,1,1,1,1 [...] The output is verbose: printing out a timestamp, and then the length of each CPU's run queue. The second last line, of timestamp 514607413802700, is an example of what this tool detects: CPU 4 has a run queue length of 4, which means one thread running and one thread queued, while CPU 6 has a run queue length of 0: idle. The very next sample shows all CPUs busy. The -J option prints raw samples with time offsets showing when the samples were collected on each CPU. It's mostly useful for debugging the tool itself. For example, during a Linux kernel build: # ./cpuunclaimed.py -J TIMESTAMP_ns,CPU0,CPU1,CPU2,CPU3,CPU4,CPU5,CPU6,CPU7,OFFSET_ns_CPU0,OFFSET_ns_CPU1,OFFSET_ns_CPU2,OFFSET_ns_CPU3,OFFSET_ns_CPU4,OFFSET_ns_CPU5,OFFSET_ns_CPU6,OFFSET_ns_CPU7 514722625198188,1,1,1,1,1,1,1,2,0,28321,51655,73396,89654,111172,132803,159792 514722635299034,1,1,1,1,1,2,1,1,0,28809,51999,74183,89552,110011,131995,153519 514722645400274,1,1,1,1,1,1,1,2,0,28024,51333,73652,88964,110075,131973,153568 514722655501816,1,2,1,1,1,1,1,1,0,28893,51671,75233,89496,109430,131945,153694 514722665602594,1,1,2,1,1,2,1,1,0,28623,50988,73866,89383,109186,131786,154555 514722675703498,1,1,1,1,1,1,1,1,0,27379,51031,73175,89625,110380,131482,104811 514722685804942,1,1,1,1,1,2,1,1,0,27213,50501,72183,88797,108780,130659,152153 514722695906294,1,1,1,1,1,1,1,1,0,27036,51182,73420,87861,109585,130364,155089 514722706005778,1,1,1,1,1,1,1,1,0,28492,51851,74138,89744,110208,132462,154060 514722716060705,1,1,1,1,1,1,1,1,0,154499,152528,155232,155046,154502,178746,200001 514722726209615,1,1,1,1,1,1,1,1,0,28170,49580,72605,87741,108144,130723,152138 514722736309475,1,2,1,1,1,1,1,1,0,27421,51386,73061,89358,109457,131273,153005 514722746410845,1,2,1,1,1,2,1,1,0,27788,50840,72720,88920,109111,131143,152979 514722756511363,1,1,1,1,1,1,2,1,0,28280,50977,73559,89848,109659,131579,152693 514722766613044,1,1,1,1,1,1,1,1,0,28046,50812,72754,89160,110108,130735,152948 514722776712932,1,1,1,2,1,1,1,1,0,28586,51177,73974,89588,109947,132376,154162 514722786815477,1,1,1,1,1,1,1,1,0,27973,71104,72539,88302,108896,130414,152236 514722796914955,1,1,1,1,1,1,1,1,0,29054,52354,74214,89592,110615,132586,153925 514722807044060,1,1,1,1,1,1,1,1,1587130,0,24079,46633,61787,82325,104706,125278 514722817117432,2,1,2,1,1,1,1,1,0,27628,51038,75138,89724,109340,132426,155348 514722827218254,1,1,1,1,1,1,2,1,0,29111,51868,74347,88904,109911,132764,153851 514722837340158,1,1,1,1,1,1,1,1,0,7366,30760,53528,68622,89317,111095,132319 514722847421305,1,1,1,1,1,1,1,1,0,28257,51105,73841,89037,110820,131605,153368 514722857521112,1,1,1,1,1,1,1,1,0,28544,51441,73857,89530,110497,131915,153513 514722867626129,0,2,1,1,1,1,1,1,0,24621,47917,70568,85391,106670,128081,150329 514722877727183,2,1,1,1,1,1,1,1,0,24869,47630,71547,84761,106048,128444,149285 514722887824589,1,1,1,1,1,1,2,1,0,28793,51212,73863,89584,109773,132348,153194 514722897925481,1,1,1,1,1,1,2,1,0,29278,51163,73961,89774,109592,132029,153715 514722908026097,1,1,1,1,1,1,1,1,0,30630,35595,36210,188001,190815,190072,190732 514722918127439,1,1,1,1,1,1,1,1,0,28544,51885,73948,89987,109763,132632,154083 514722928227399,1,1,1,1,1,1,1,1,0,31882,51574,74769,89939,110578,132951,154356 514722938329471,1,1,1,1,1,1,1,1,0,28498,51304,74101,89670,110278,132653,153176 514722948430589,1,1,1,1,1,1,1,1,0,27868,50925,73477,89676,109583,132360,153014 514722958531802,1,1,1,1,1,1,1,1,0,28505,50886,73729,89919,109618,131988,152896 514722968632181,1,1,1,1,1,1,1,1,0,28492,51749,73977,90334,109816,132897,152890 514722978733584,1,1,1,1,1,1,1,1,0,28847,50957,74121,90014,110019,132377,152978 514722988834321,1,1,1,1,1,1,1,1,0,28601,51437,74021,89968,110252,132233,153623 514722998937170,1,1,2,1,1,1,1,1,0,27007,50044,73259,87725,108663,132194,152459 514723009036821,1,2,1,2,1,1,1,1,0,28226,50937,73983,89110,110476,131740,153663 514723019137577,1,1,1,1,1,1,1,1,0,30261,52357,75657,87803,61823,131850,153585 514723029238745,1,1,1,1,1,1,1,1,0,28030,50752,74452,89240,110791,132187,153327 514723039339069,1,1,1,1,1,1,1,1,0,29791,52636,75996,90475,110414,132232,154714 514723049439822,1,1,1,1,2,1,1,1,0,29133,56662,74153,89520,110683,132740,154708 514723059541617,1,1,1,1,1,1,1,1,0,27932,51480,74644,89656,109176,131499,153732 514723069642500,1,1,2,1,1,1,2,1,0,27678,51509,73984,90136,110124,131554,153459 514723079743525,2,1,1,1,1,1,1,1,0,28029,51424,74394,90056,110087,132383,152963 514723089844091,2,1,1,2,1,1,1,1,0,28944,51692,74440,90339,110402,132722,154083 514723099945957,1,1,2,1,1,1,1,1,0,28425,51267,73164,89322,115048,114630,115187 514723110047020,1,1,2,0,1,1,1,2,0,28192,50811,76814,89835,109370,131265,153511 514723120216662,1,1,2,1,1,2,1,1,29,34,0,4514,19268,40293,62674,84009 [...] This is a Xen guest system, and it shows that CPU 0 usually completes first (an offset of 0), followed by CPU 1 around 28000 nanoseconds later, and so on. The spread of offsets is triggered by the bcc Python library that initializes the timers, which steps through the CPUs in sequence, with a small delay between them merely from executing its own loop code. Here's more output during a Linux kernel build: # ./cpuunclaimed.py -J TIMESTAMP_ns,CPU0,CPU1,CPU2,CPU3,CPU4,CPU5,CPU6,CPU7,OFFSET_ns_CPU0,OFFSET_ns_CPU1,OFFSET_ns_CPU2,OFFSET_ns_CPU3,OFFSET_ns_CPU4,OFFSET_ns_CPU5,OFFSET_ns_CPU6,OFFSET_ns_CPU7 514722625198188,1,1,1,1,1,1,1,2,0,28321,51655,73396,89654,111172,132803,159792 515700745758947,2,1,1,1,1,1,1,1,0,19835,34891,49397,59364,71988,87571,102769 515700755860451,2,1,1,1,1,1,1,2,0,19946,34323,49855,59844,72741,87925,102891 515700765960560,1,1,1,1,1,1,1,1,0,20805,35339,50436,59677,73557,88661,104796 515700776061744,1,1,1,1,1,1,1,1,1626,77,0,190,153452,154665,178218,154116 515700786162017,1,1,1,1,1,1,1,1,0,20497,35361,51552,59787,74451,147789,104545 515700796262811,1,1,1,1,1,1,1,2,0,20910,35657,50805,60175,73953,88492,103527 515700806364951,1,1,1,1,1,1,1,1,0,20140,35023,50074,59726,72757,88040,102421 515700816465253,1,1,1,1,1,1,2,1,0,20952,34899,50262,60048,72890,88067,103545 515700826566573,1,1,1,1,1,1,1,1,0,20898,35490,50609,59805,74060,88550,103354 515700836667480,1,1,1,1,1,1,2,1,0,20548,34760,50959,59490,73059,87820,103006 515700846768182,1,1,1,1,1,1,2,1,0,20571,35113,50777,59962,74139,88543,103192 515700856869468,1,1,2,1,1,2,2,1,0,20932,35382,50510,60106,73739,91818,103684 515700866971905,1,1,1,2,1,1,1,1,0,19780,33018,49075,58375,71949,86537,102136 515700877073459,2,1,1,1,1,1,1,1,0,20065,73966,48989,58832,71408,85714,101067 515700887172772,1,1,1,1,1,1,1,1,0,20909,34608,51493,59890,73564,88668,103454 515700897273292,1,2,1,1,1,1,1,1,0,20353,35292,50114,59773,73948,88615,103383 515700907374341,1,1,2,1,1,1,1,1,0,20816,35206,50915,60062,73878,88857,103794 515700917475331,1,1,6,1,1,2,1,1,0,20752,34931,50280,59764,73781,88329,103234 515700927576958,1,1,1,1,1,1,1,1,0,19929,34703,50181,59364,73004,88053,103127 515700937677298,1,1,2,2,1,1,1,1,0,21178,34724,50740,61193,73452,89030,103390 515700947778409,2,1,1,1,1,1,1,1,0,21059,35604,50853,60098,73919,88675,103506 515700957879196,2,1,1,1,1,1,1,1,0,21326,35939,51492,60083,74249,89474,103761 [...] Notice the tighter range of offsets? I began executing cpuunclaimed when the system was idle, and it initialized the CPU timers more quickly, and then I began the Linux kernel build. Here's some different output, this time from a physical system with 4 CPUs, also doing a kernel build, # ./cpuunclaimed.py -J TIMESTAMP_ns,CPU0,CPU1,CPU2,CPU3,OFFSET_ns_CPU0,OFFSET_ns_CPU1,OFFSET_ns_CPU2,OFFSET_ns_CPU3 4429382557480,1,1,1,1,0,6011,10895,16018 4429392655042,2,1,1,1,0,8217,13661,19378 4429402757604,1,1,1,1,0,6879,12433,18000 4429412857809,1,1,1,1,0,8303,13190,18719 4429422960709,2,1,1,1,0,6095,11234,17079 4429433060391,1,1,1,2,0,6747,12480,18070 4429443161699,1,1,1,1,0,6560,12264,17945 4429453262002,1,2,1,1,0,6992,12644,18341 4429463363706,1,2,1,1,0,6211,12071,17853 4429473465571,1,1,1,1,0,5766,11495,17638 4429483566920,1,1,1,1,0,5223,11736,16358 4429493666279,1,1,1,1,0,6964,12653,18410 4429503769113,1,1,1,1,0,5161,11399,16612 4429513870744,1,1,1,1,0,5943,10583,15768 4429523969826,1,1,1,1,0,6533,12336,18189 4429534070311,1,1,1,1,0,6834,12816,18488 4429544170456,1,1,1,1,0,7284,13401,19129 4429554274467,1,2,1,1,0,5941,11160,16594 4429564372365,1,2,1,1,0,7514,13618,19190 4429574474406,1,2,1,1,0,6687,12650,18248 4429584574220,1,2,1,1,0,7912,13705,19136 [...] If the offset range becomes too great, we can no longer conclude about when some CPUs were idle and others had queued work. The tool will detect this, and print an error message and exit. Some systems can power down CPUs when idle, and when they wake up again the timed samples may resume from different offsets. If this happens, this tool can no longer draw conclusions about when some CPUs were idle and others had queued work, so it prints an error, and exits. Eg: # ./cpuunclaimed.py 1 Sampling run queues... Output every 1 seconds. Hit Ctrl-C to end. %CPU 0.25%, unclaimed idle 0.00% %CPU 0.75%, unclaimed idle 0.00% %CPU 0.25%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% %CPU 0.12%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% %CPU 0.25%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% %CPU 0.12%, unclaimed idle 0.00% %CPU 0.13%, unclaimed idle 0.00% %CPU 0.12%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% %CPU 0.00%, unclaimed idle 0.00% ERROR: CPU samples arrived at skewed offsets (CPUs may have powered down when idle), spanning 4328176 ns (expected < 4040404 ns). Debug with -J, and see the man page. As output may begin to be unreliable, exiting. It's expected that this will only really occur on idle systems. USAGE: # ./cpuunclaimed.py -h usage: cpuunclaimed.py [-h] [-j] [-J] [-T] [interval] [count] Sample CPU run queues and calculate unclaimed idle CPU positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -j, --csv print sample summaries (verbose) as comma-separated values -J, --fullcsv print sample summaries with extra fields: CPU sample offsets -T, --timestamp include timestamp on output examples: ./cpuunclaimed # sample and calculate unclaimed idle CPUs, # output every 1 second (default) ./cpuunclaimed 5 10 # print 5 second summaries, 10 times ./cpuunclaimed -T 1 # 1s summaries and timestamps ./cpuunclaimed -j # raw dump of all samples (verbose), CSV bpfcc-0.2.0+git0.02884a026/tools/dbslower.py000077500000000000000000000102101305314114400200260ustar00rootroot00000000000000#!/usr/bin/python # # dbslower Trace MySQL and PostgreSQL queries slower than a threshold. # # USAGE: dbslower [-v] [-p PID [PID ...]] [-m THRESHOLD] {mysql,postgres} # # By default, a threshold of 1ms is used. Set the threshold to 0 to trace all # queries (verbose). If no PID is provided, the script attempts to discover # all MySQL or PostgreSQL database processes. # # This tool uses USDT probes, which means it needs MySQL and PostgreSQL built # with USDT (DTrace) support. # # Strongly inspired by Brendan Gregg's work on the mysqld_qslower script. # # Copyright 2017, Sasha Goldshtein # Licensed under the Apache License, Version 2.0 # # 15-Feb-2017 Sasha Goldshtein Created this. from bcc import BPF, USDT import argparse import ctypes as ct import subprocess examples = """examples: dbslower postgres # trace PostgreSQL queries slower than 1ms dbslower postgres -p 188 322 # trace specific PostgreSQL processes dbslower mysql -p 480 -m 30 # trace MySQL queries slower than 30ms dbslower mysql -p 480 -v # trace MySQL queries and print the BPF program """ parser = argparse.ArgumentParser( description="", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-v", "--verbose", action="store_true", help="print the BPF program") parser.add_argument("db", choices=["mysql", "postgres"], help="the database engine to use") parser.add_argument("-p", "--pid", type=int, nargs='*', dest="pids", metavar="PID", help="the pid(s) to trace") parser.add_argument("-m", "--threshold", type=int, default=1, help="trace queries slower than this threshold (ms)") args = parser.parse_args() if not args.pids or len(args.pids) == 0: if args.db == "mysql": args.pids = map(int, subprocess.check_output( "pidof mysqld".split()).split()) elif args.db == "postgres": args.pids = map(int, subprocess.check_output( "pidof postgres".split()).split()) threshold_ns = args.threshold * 1000000 program = """ #include struct temp_t { u64 timestamp; char *query; }; struct data_t { u64 pid; u64 timestamp; u64 duration; char query[256]; }; BPF_HASH(temp, u64, struct temp_t); BPF_PERF_OUTPUT(events); int probe_start(struct pt_regs *ctx) { struct temp_t tmp = {}; tmp.timestamp = bpf_ktime_get_ns(); bpf_usdt_readarg(1, ctx, &tmp.query); u64 pid = bpf_get_current_pid_tgid(); temp.update(&pid, &tmp); return 0; } int probe_end(struct pt_regs *ctx) { struct temp_t *tempp; u64 pid = bpf_get_current_pid_tgid(); tempp = temp.lookup(&pid); if (!tempp) return 0; u64 delta = bpf_ktime_get_ns() - tempp->timestamp; if (delta >= """ + str(threshold_ns) + """) { struct data_t data = {}; data.pid = pid >> 32; // only process id data.timestamp = tempp->timestamp; data.duration = delta; bpf_probe_read(&data.query, sizeof(data.query), tempp->query); events.perf_submit(ctx, &data, sizeof(data)); } temp.delete(&pid); return 0; } """ usdts = map(lambda pid: USDT(pid=pid), args.pids) for usdt in usdts: usdt.enable_probe("query__start", "probe_start") usdt.enable_probe("query__done", "probe_end") bpf = BPF(text=program, usdt_contexts=usdts) if args.verbose: print('\n'.join(map(lambda u: u.get_text(), usdts))) print(program) class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("timestamp", ct.c_ulonglong), ("delta", ct.c_ulonglong), ("query", ct.c_char * 256) ] start = BPF.monotonic_time() def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents print("%-14.6f %-6d %8.3f %s" % ( float(event.timestamp - start) / 1000000000, event.pid, float(event.delta) / 1000000, event.query)) print("Tracing database queries for pids %s slower than %d ms..." % (', '.join(map(str, args.pids)), args.threshold)) print("%-14s %-6s %8s %s" % ("TIME(s)", "PID", "MS", "QUERY")) bpf["events"].open_perf_buffer(print_event) while True: bpf.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/dbslower_example.txt000066400000000000000000000074221305314114400217400ustar00rootroot00000000000000Demonstrations of dbslower, the Linux eBPF/bcc version. dbslower traces queries served by a MySQL or PostgreSQL server, and prints those that exceed a latency (query time) threshold. By default a threshold of 1 ms is used. For example: # dbslower mysql Tracing database queries for pids 25776 slower than 1 ms... TIME(s) PID MS QUERY 1.315800 25776 2000.999 call getproduct(97) 3.360380 25776 3.226 call getproduct(6) ^C This traced two queries slower than 1ms, one of which is very slow: over 2 seconds. We can filter out the shorter ones and keep only the really slow ones: # dbslower mysql -m 1000 Tracing database queries for pids 25776 slower than 1000 ms... TIME(s) PID MS QUERY 1.421264 25776 2002.183 call getproduct(97) 3.572617 25776 2001.381 call getproduct(97) 5.661411 25776 2001.867 call getproduct(97) 7.748296 25776 2001.329 call getproduct(97) ^C This looks like a pattern -- we keep making this slow query every 2 seconds or so, and it takes approximately 2 seconds to run. By default, dbslower will try to detect mysqld and postgres processes, but if necessary, you can specify the process ids with the -p switch: # dbslower mysql -p $(pidof mysql) Tracing database queries for pids 25776 slower than 1 ms... TIME(s) PID MS QUERY 2.002125 25776 3.340 call getproduct(7) 2.045006 25776 2001.558 call getproduct(97) 4.131863 25776 2002.275 call getproduct(97) 6.190513 25776 3.248 call getproduct(33) ^C Specifying 0 as the threshold will print all the queries: # dbslower mysql -m 0 Tracing database queries for pids 25776 slower than 0 ms... TIME(s) PID MS QUERY 6.003720 25776 2.363 /* mysql-connector-java-5.1.40 ( Revision: 402933ef52cad9aa82624e80acbea46e3a701ce6 ) */SELECT @@session.auto_increment_increment AS auto_increment_increment, @@character_set_client AS character_set_client, @@character_set_connection AS character_set_conn 6.599219 25776 0.068 SET NAMES latin1 6.613944 25776 0.057 SET character_set_results = NULL 6.645228 25776 0.059 SET autocommit=1 6.653798 25776 0.059 SET sql_mode='NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES' 6.682184 25776 2.526 select * from users where id = 0 6.767888 25776 0.288 select id from products where userid = 0 6.790642 25776 2.255 call getproduct(0) 6.809865 25776 0.218 call getproduct(1) 6.846878 25776 0.248 select * from users where id = 1 6.847623 25776 0.166 select id from products where userid = 1 6.867363 25776 0.244 call getproduct(2) 6.868162 25776 0.107 call getproduct(3) 6.874726 25776 0.208 select * from users where id = 2 6.881722 25776 0.260 select id from products where userid = 2 ^C Here we can see the MySQL connector initialization and connection establishment, before the actual queries start coming in. USAGE: # dbslower -h usage: dbslower.py [-h] [-v] [-p [PIDS [PIDS ...]]] [-m THRESHOLD] {mysql,postgres} positional arguments: {mysql,postgres} the database engine to use optional arguments: -h, --help show this help message and exit -v, --verbose print the BPF program -p [PID [PID ...]], --pid [PID [PID ...]] the pid(s) to trace -m THRESHOLD, --threshold THRESHOLD trace queries slower than this threshold (ms) examples: dbslower postgres # trace PostgreSQL queries slower than 1ms dbslower postgres -p 188 322 # trace specific PostgreSQL processes dbslower mysql -p 480 -m 30 # trace MySQL queries slower than 30ms dbslower mysql -p 480 -v # trace MySQL queries and print the BPF program bpfcc-0.2.0+git0.02884a026/tools/dbstat.py000077500000000000000000000072771305314114400175110ustar00rootroot00000000000000#!/usr/bin/python # # dbstat Display a histogram of MySQL and PostgreSQL query latencies. # # USAGE: dbstat [-v] [-p PID [PID ...]] [-m THRESHOLD] [-u] # [-i INTERVAL] {mysql,postgres} # # This tool uses USDT probes, which means it needs MySQL and PostgreSQL built # with USDT (DTrace) support. # # Copyright 2017, Sasha Goldshtein # Licensed under the Apache License, Version 2.0 # # 15-Feb-2017 Sasha Goldshtein Created this. from bcc import BPF, USDT import argparse import subprocess from time import sleep, strftime examples = """ dbstat postgres # display a histogram of PostgreSQL query latencies dbstat mysql -v # display MySQL latencies and print the BPF program dbstat mysql -u # display query latencies in microseconds (default: ms) dbstat mysql -m 5 # trace only queries slower than 5ms dbstat mysql -p 408 # trace queries in a specific process """ parser = argparse.ArgumentParser( description="", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-v", "--verbose", action="store_true", help="print the BPF program") parser.add_argument("db", choices=["mysql", "postgres"], help="the database engine to use") parser.add_argument("-p", "--pid", type=int, nargs='*', dest="pids", metavar="PID", help="the pid(s) to trace") parser.add_argument("-m", "--threshold", type=int, default=0, help="trace queries slower than this threshold (ms)") parser.add_argument("-u", "--microseconds", action="store_true", help="display query latencies in microseconds (default: milliseconds)") parser.add_argument("-i", "--interval", type=int, default=99999999999, help="print summary at this interval (seconds)") args = parser.parse_args() if not args.pids or len(args.pids) == 0: if args.db == "mysql": args.pids = map(int, subprocess.check_output( "pidof mysqld".split()).split()) elif args.db == "postgres": args.pids = map(int, subprocess.check_output( "pidof postgres".split()).split()) program = """ #include BPF_HASH(temp, u64, u64); BPF_HISTOGRAM(latency); int probe_start(struct pt_regs *ctx) { u64 timestamp = bpf_ktime_get_ns(); u64 pid = bpf_get_current_pid_tgid(); temp.update(&pid, ×tamp); return 0; } int probe_end(struct pt_regs *ctx) { u64 *timestampp; u64 pid = bpf_get_current_pid_tgid(); timestampp = temp.lookup(&pid); if (!timestampp) return 0; u64 delta = bpf_ktime_get_ns() - *timestampp; FILTER delta /= SCALE; latency.increment(bpf_log2l(delta)); temp.delete(&pid); return 0; } """ program = program.replace("SCALE", str(1000 if args.microseconds else 1000000)) program = program.replace("FILTER", "" if args.threshold == 0 else \ "if (delta / 1000000 < %d) { return 0; }" % args.threshold) usdts = map(lambda pid: USDT(pid=pid), args.pids) for usdt in usdts: usdt.enable_probe("query__start", "probe_start") usdt.enable_probe("query__done", "probe_end") bpf = BPF(text=program, usdt_contexts=usdts) if args.verbose: print('\n'.join(map(lambda u: u.get_text(), usdts))) print(program) print("Tracing database queries for pids %s slower than %d ms..." % (', '.join(map(str, args.pids)), args.threshold)) latencies = bpf["latency"] def print_hist(): print("[%s]" % strftime("%H:%M:%S")) latencies.print_log2_hist("query latency (%s)" % ("us" if args.microseconds else "ms")) print("") latencies.clear() while True: try: sleep(args.interval) print_hist() except KeyboardInterrupt: print_hist() break bpfcc-0.2.0+git0.02884a026/tools/dbstat_example.txt000066400000000000000000000150001305314114400213670ustar00rootroot00000000000000Demonstrations of dbstat, the Linux eBPF/bcc version. dbstat traces queries performed by a MySQL or PostgreSQL database process, and displays a histogram of query latencies. For example: # dbstat mysql Tracing database queries for pids 25776 slower than 0 ms... query latency (ms) : count distribution 0 -> 1 : 990 |****************************************| 2 -> 3 : 7 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 2 | | ^C It's immediately evident that the vast majority of queries finish very quickly, in under 1ms, but there are some super-slow queries occasionally, in the 1-2 seconds bucket. We can filter out the shorter queries with the -m switch: # dbstat mysql -m 1000 Tracing database queries for pids 25776 slower than 1000 ms... query latency (ms) : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 8 |****************************************| ^C By default, dbstat will try to detect mysqld and postgres processes, but if necessary, you can specify the process ids with the -p switch. Here, the -i switch is also used to request histograms at 3 second intervals: # dbstat mysql -p $(pidof mysql) -i 3 Tracing database queries for pids 25776 slower than 0 ms... [06:14:36] query latency (ms) : count distribution 0 -> 1 : 758 |****************************************| 2 -> 3 : 1 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 1 | | [06:14:39] query latency (ms) : count distribution 0 -> 1 : 436 |****************************************| 2 -> 3 : 2 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 1 | | [06:14:42] query latency (ms) : count distribution 0 -> 1 : 399 |****************************************| 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 1 | | ^C USAGE: # dbstat -h usage: dbstat.py [-h] [-v] [-p [PID [PID ...]]] [-m THRESHOLD] [-u] [-i INTERVAL] {mysql,postgres} positional arguments: {mysql,postgres} the database engine to use optional arguments: -h, --help show this help message and exit -v, --verbose print the BPF program -p [PID [PID ...]], --pid [PID [PID ...]] the pid(s) to trace -m THRESHOLD, --threshold THRESHOLD trace queries slower than this threshold (ms) -u, --microseconds display query latencies in microseconds (default: milliseconds) -i INTERVAL, --interval INTERVAL print summary at this interval (seconds) dbstat postgres # display a histogram of PostgreSQL query latencies dbstat mysql -v # display MySQL latencies and print the BPF program dbstat mysql -u # display query latencies in microseconds (default: ms) dbstat mysql -m 5 # trace only queries slower than 5ms dbstat mysql -p 408 # trace queries in a specific process bpfcc-0.2.0+git0.02884a026/tools/dcsnoop.py000077500000000000000000000076101305314114400176640ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # dcsnoop Trace directory entry cache (dcache) lookups. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: dcsnoop [-h] [-a] # # By default, this traces every failed dcache lookup, and shows the process # performing the lookup and the filename requested. A -a option can be used # to show all lookups, not just failed ones. # # This uses kernel dynamic tracing of the d_lookup() function, and will need # to be modified to match kernel changes. # # Also see dcstat(8), for per-second summaries. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 09-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse import ctypes as ct import re import time # arguments examples = """examples: ./dcsnoop # trace failed dcache lookups ./dcsnoop -a # trace all dcache lookups """ parser = argparse.ArgumentParser( description="Trace directory entry cache (dcache) lookups", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-a", "--all", action="store_true", help="trace all lookups (default is fails only)") args = parser.parse_args() # define BPF program bpf_text = """ #include #include #include #define MAX_FILE_LEN 64 enum lookup_type { LOOKUP_MISS, LOOKUP_REFERENCE, }; struct entry_t { char name[MAX_FILE_LEN]; }; BPF_HASH(entrybypid, u32, struct entry_t); struct data_t { u32 pid; enum lookup_type type; char comm[TASK_COMM_LEN]; char filename[MAX_FILE_LEN]; }; BPF_PERF_OUTPUT(events); /* from fs/namei.c: */ struct nameidata { struct path path; struct qstr last; // [...] }; static inline void submit_event(struct pt_regs *ctx, void *name, int type, u32 pid) { struct data_t data = { .pid = pid, .type = type, }; bpf_get_current_comm(&data.comm, sizeof(data.comm)); bpf_probe_read(&data.filename, sizeof(data.filename), name); events.perf_submit(ctx, &data, sizeof(data)); } int trace_fast(struct pt_regs *ctx, struct nameidata *nd, struct path *path) { u32 pid = bpf_get_current_pid_tgid(); submit_event(ctx, (void *)nd->last.name, LOOKUP_REFERENCE, pid); return 1; } int kprobe__d_lookup(struct pt_regs *ctx, const struct dentry *parent, const struct qstr *name) { u32 pid = bpf_get_current_pid_tgid(); struct entry_t entry = {}; const char *fname = name->name; if (fname) { bpf_probe_read(&entry.name, sizeof(entry.name), (void *)fname); } entrybypid.update(&pid, &entry); return 0; } int kretprobe__d_lookup(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); struct entry_t *ep; ep = entrybypid.lookup(&pid); if (ep == 0 || PT_REGS_RC(ctx) != 0) { return 0; // missed entry or lookup didn't fail } submit_event(ctx, (void *)ep->name, LOOKUP_MISS, pid); entrybypid.delete(&pid); return 0; } """ TASK_COMM_LEN = 16 # linux/sched.h MAX_FILE_LEN = 64 # see inline C class Data(ct.Structure): _fields_ = [ ("pid", ct.c_uint), ("type", ct.c_int), ("comm", ct.c_char * TASK_COMM_LEN), ("filename", ct.c_char * MAX_FILE_LEN), ] # initialize BPF b = BPF(text=bpf_text) if args.all: b.attach_kprobe(event="lookup_fast", fn_name="trace_fast") mode_s = { 0: 'M', 1: 'R', } start_ts = time.time() def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents print("%-11.6f %-6d %-16s %1s %s" % ( time.time() - start_ts, event.pid, event.comm, mode_s[event.type], event.filename)) # header print("%-11s %-6s %-16s %1s %s" % ("TIME(s)", "PID", "COMM", "T", "FILE")) b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/dcsnoop_example.txt000066400000000000000000000104231305314114400215570ustar00rootroot00000000000000Demonstrations of dcsnoop, the Linux eBPF/bcc version. dcsnoop traces directory entry cache (dcache) lookups, and can be used for further investigation beyond dcstat(8). The output is likely verbose, as dcache lookups are likely frequent. By default, only failed lookups are shown. For example: # ./dcsnoop.py TIME(s) PID COMM T FILE 0.002837 1643 snmpd M net/dev 0.002852 1643 snmpd M 1643 0.002856 1643 snmpd M net 0.002863 1643 snmpd M dev 0.002952 1643 snmpd M net/if_inet6 0.002964 1643 snmpd M if_inet6 0.003180 1643 snmpd M net/ipv4/neigh/eth0/retrans_time_ms 0.003192 1643 snmpd M ipv4/neigh/eth0/retrans_time_ms 0.003197 1643 snmpd M neigh/eth0/retrans_time_ms 0.003203 1643 snmpd M eth0/retrans_time_ms 0.003206 1643 snmpd M retrans_time_ms 0.003245 1643 snmpd M ipv6/neigh/eth0/retrans_time_ms 0.003249 1643 snmpd M neigh/eth0/retrans_time_ms 0.003252 1643 snmpd M eth0/retrans_time_ms 0.003255 1643 snmpd M retrans_time_ms 0.003287 1643 snmpd M conf/eth0/forwarding 0.003292 1643 snmpd M eth0/forwarding 0.003295 1643 snmpd M forwarding 0.003326 1643 snmpd M base_reachable_time_ms [...] I ran a drop caches at the same time as executing this tool. The output shows the processes, the type of event ("T" column: M == miss, R == reference), and the filename for the dcache lookup. The way the dcache is currently implemented, each component of a path is checked in turn. The first line, showing "net/dev" from snmp, will be a lookup for "net" in a directory (that isn't shown here). If it finds "net", it will then lookup "dev" inside net. You can see this sequence a little later, starting at time 0.003180, where a pathname is being searched directory by directory. The -a option will show all lookups, although be warned, the output will be very verbose. For example: # ./dcsnoop TIME(s) PID COMM T FILE 0.000000 20279 dcsnoop.py M p_lookup_fast 0.000010 20279 dcsnoop.py M enable 0.000013 20279 dcsnoop.py M id 0.000015 20279 dcsnoop.py M filter 0.000017 20279 dcsnoop.py M trigger 0.000019 20279 dcsnoop.py M format 0.006148 20279 dcsnoop.py R sys/kernel/debug/tracing/trace_pipe 0.006158 20279 dcsnoop.py R kernel/debug/tracing/trace_pipe 0.006161 20279 dcsnoop.py R debug/tracing/trace_pipe 0.006164 20279 dcsnoop.py R tracing/trace_pipe 0.006166 20279 dcsnoop.py R trace_pipe 0.015900 1643 snmpd R proc/sys/net/ipv6/conf/lo/forwarding 0.015901 1643 snmpd R sys/net/ipv6/conf/lo/forwarding 0.015901 1643 snmpd R net/ipv6/conf/lo/forwarding 0.015902 1643 snmpd R ipv6/conf/lo/forwarding 0.015903 1643 snmpd R conf/lo/forwarding 0.015904 1643 snmpd R lo/forwarding 0.015905 1643 snmpd M lo/forwarding 0.015908 1643 snmpd R forwarding 0.015909 1643 snmpd M forwarding 0.015937 1643 snmpd R proc/sys/net/ipv6/neigh/lo/base_reachable_time_ms 0.015937 1643 snmpd R sys/net/ipv6/neigh/lo/base_reachable_time_ms 0.015938 1643 snmpd R net/ipv6/neigh/lo/base_reachable_time_ms 0.015939 1643 snmpd R ipv6/neigh/lo/base_reachable_time_ms 0.015940 1643 snmpd R neigh/lo/base_reachable_time_ms 0.015941 1643 snmpd R lo/base_reachable_time_ms 0.015941 1643 snmpd R base_reachable_time_ms 0.015943 1643 snmpd M base_reachable_time_ms 0.043569 1876 supervise M 20281 0.043573 1886 supervise M 20280 0.043582 1886 supervise R supervise/status.new [...] USAGE message: # ./dcsnoop.py -h usage: dcsnoop.py [-h] [-a] Trace directory entry cache (dcache) lookups optional arguments: -h, --help show this help message and exit -a, --all trace all lookups (default is fails only) examples: ./dcsnoop # trace failed dcache lookups ./dcsnoop -a # trace all dcache lookups bpfcc-0.2.0+git0.02884a026/tools/dcstat.py000077500000000000000000000075411305314114400175040ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # dcstat Directory entry cache (dcache) stats. # For Linux, uses BCC, eBPF. # # USAGE: dcstat [interval [count]] # # This uses kernel dynamic tracing of kernel functions, lookup_fast() and # d_lookup(), which will need to be modified to match kernel changes. See # code comments. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 09-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from ctypes import c_int from time import sleep, strftime from sys import argv def usage(): print("USAGE: %s [interval [count]]" % argv[0]) exit() # arguments interval = 1 count = -1 if len(argv) > 1: try: interval = int(argv[1]) if interval == 0: raise if len(argv) > 2: count = int(argv[2]) except: # also catches -h, --help usage() # define BPF program bpf_text = """ #include enum stats { S_REFS = 1, S_SLOW, S_MISS, S_MAXSTAT }; BPF_TABLE("array", int, u64, stats, S_MAXSTAT + 1); /* * How this is instrumented, and how to interpret the statistics, is very much * tied to the current kernel implementation (this was written on Linux 4.4). * This will need maintenance to keep working as the implementation changes. To * aid future adventurers, this is is what the current code does, and why. * * First problem: the current implementation takes a path and then does a * lookup of each component. So how do we count a reference? Once for the path * lookup, or once for every component lookup? I've chosen the latter * since it seems to map more closely to actual dcache lookups (via * __d_lookup_rcu()). It's counted via calls to lookup_fast(). * * The implementation tries different, progressively slower, approaches to * lookup a file. At what point do we call it a dcache miss? I've choosen when * a d_lookup() (which is called during lookup_slow()) returns zero. * * I've also included a "SLOW" statistic to show how often the fast lookup * failed. Whether this exists or is interesting is an implementation detail, * and the "SLOW" statistic may be removed in future versions. */ void count_fast(struct pt_regs *ctx) { int key = S_REFS; u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; } void count_lookup(struct pt_regs *ctx) { int key = S_SLOW; u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; if (PT_REGS_RC(ctx) == 0) { key = S_MISS; leaf = stats.lookup(&key); if (leaf) (*leaf)++; } } """ # load BPF program b = BPF(text=bpf_text) b.attach_kprobe(event="lookup_fast", fn_name="count_fast") b.attach_kretprobe(event="d_lookup", fn_name="count_lookup") # stat column labels and indexes stats = { "REFS": 1, "SLOW": 2, "MISS": 3 } # header print("%-8s " % "TIME", end="") for stype, idx in sorted(stats.items(), key=lambda k_v: (k_v[1], k_v[0])): print(" %8s" % (stype + "/s"), end="") print(" %8s" % "HIT%") # output i = 0 while (1): if count > 0: i += 1 if i > count: exit() try: sleep(interval) except KeyboardInterrupt: pass exit() print("%-8s: " % strftime("%H:%M:%S"), end="") # print each statistic as a column for stype, idx in sorted(stats.items(), key=lambda k_v: (k_v[1], k_v[0])): try: val = b["stats"][c_int(idx)].value / interval print(" %8d" % val, end="") except: print(" %8d" % 0, end="") # print hit ratio percentage try: ref = b["stats"][c_int(stats["REFS"])].value miss = b["stats"][c_int(stats["MISS"])].value hit = ref - miss pct = float(100) * hit / ref print(" %8.2f" % pct) except: print(" %7s%%" % "-") b["stats"].clear() bpfcc-0.2.0+git0.02884a026/tools/dcstat_example.txt000066400000000000000000000064171305314114400214040ustar00rootroot00000000000000Demonstrations of dcstat, the Linux eBPF/bcc version. dcstat shows directory entry cache (dcache) statistics. For example: # ./dcstat TIME REFS/s SLOW/s MISS/s HIT% 08:11:47: 2059 141 97 95.29 08:11:48: 79974 151 106 99.87 08:11:49: 192874 146 102 99.95 08:11:50: 2051 144 100 95.12 08:11:51: 73373 17239 17194 76.57 08:11:52: 54685 25431 25387 53.58 08:11:53: 18127 8182 8137 55.12 08:11:54: 22517 10345 10301 54.25 08:11:55: 7524 2881 2836 62.31 08:11:56: 2067 141 97 95.31 08:11:57: 2115 145 101 95.22 The output shows the total references per second ("REFS/s"), the number that took a slower code path to be processed ("SLOW/s"), the number of dcache misses ("MISS/s"), and the hit ratio as a percentage. By default, an interval of 1 second is used. At 08:11:49, there were 192 thousand references, which almost entirely hit from the dcache, with a hit ration of 99.95%. A little later, starting at 08:11:51, a workload began that walked many uncached files, reducing the hit ratio to 53%, and more importantly, a miss rate of over 10 thousand per second. Here's an interesting workload: # ./dcstat TIME REFS/s SLOW/s MISS/s HIT% 08:15:53: 250683 141 97 99.96 08:15:54: 266115 145 101 99.96 08:15:55: 268428 141 97 99.96 08:15:56: 260389 143 99 99.96 It's a 99.96% hit ratio, and these are all negative hits: accessing a file that does not exist. Here's the C program that generated the workload: # cat -n badopen.c 1 #include 2 #include 3 #include 4 5 int 6 main(int argc, char *argv[]) 7 { 8 int fd; 9 while (1) { 10 fd = open("bad", O_RDONLY); 11 } 12 return 0; 13 } This is a simple workload generator than tries to open a missing file ("bad") as quickly as possible. Lets see what happens if the workload attempts to open a different filename each time (which is also a missing file), using the following C code: # cat -n badopen2.c 1 #include 2 #include 3 #include 4 #include 5 6 int 7 main(int argc, char *argv[]) 8 { 9 int fd, i = 0; 10 char buf[128] = {}; 11 12 while (1) { 13 sprintf(buf, "bad%d", i++); 14 fd = open(buf, O_RDONLY); 15 } 16 return 0; 17 } Here's dcstat: # ./dcstat TIME REFS/s SLOW/s MISS/s HIT% 08:18:52: 241131 237544 237505 1.51 08:18:53: 238210 236323 236278 0.82 08:18:54: 235259 233307 233261 0.85 08:18:55: 233144 231256 231214 0.83 08:18:56: 231981 230097 230053 0.83 dcstat also supports an optional interval and optional count. For example, printing 5 second summaries 3 times: # ./dcstat 5 3 TIME REFS/s SLOW/s MISS/s HIT% 08:20:03: 2085 143 99 95.23 08:20:08: 2077 143 98 95.24 08:20:14: 2071 144 100 95.15 USAGE message: # ./dcstat -h USAGE: ./dcstat [interval [count]] bpfcc-0.2.0+git0.02884a026/tools/deadlock_detector.c000066400000000000000000000157551305314114400214560ustar00rootroot00000000000000/* * deadlock_detector.c Detects potential deadlocks in a running process. * For Linux, uses BCC, eBPF. See .py file. * * Copyright 2017 Facebook, Inc. * Licensed under the Apache License, Version 2.0 (the "License") * * 1-Feb-2016 Kenny Yu Created this. */ #include #include // Maximum number of mutexes a single thread can hold at once. // If the number is too big, the unrolled loops wil cause the stack // to be too big, and the bpf verifier will fail. #define MAX_HELD_MUTEXES 16 // Info about held mutexes. `mutex` will be 0 if not held. struct held_mutex_t { u64 mutex; u64 stack_id; }; // List of mutexes that a thread is holding. Whenever we loop over this array, // we need to force the compiler to unroll the loop, otherwise the bcc verifier // will fail because the loop will create a backwards edge. struct thread_to_held_mutex_leaf_t { struct held_mutex_t held_mutexes[MAX_HELD_MUTEXES]; }; // Map of thread ID -> array of (mutex addresses, stack id) BPF_TABLE("hash", u32, struct thread_to_held_mutex_leaf_t, thread_to_held_mutexes, 2097152); // Key type for edges. Represents an edge from mutex1 => mutex2. struct edges_key_t { u64 mutex1; u64 mutex2; }; // Leaf type for edges. Holds information about where each mutex was acquired. struct edges_leaf_t { u64 mutex1_stack_id; u64 mutex2_stack_id; u32 thread_pid; char comm[TASK_COMM_LEN]; }; // Represents all edges currently in the mutex wait graph. BPF_TABLE("hash", struct edges_key_t, struct edges_leaf_t, edges, 2097152); // Info about parent thread when a child thread is created. struct thread_created_leaf_t { u64 stack_id; u32 parent_pid; char comm[TASK_COMM_LEN]; }; // Map of child thread pid -> info about parent thread. BPF_TABLE("hash", u32, struct thread_created_leaf_t, thread_to_parent, 10240); // Stack traces when threads are created and when mutexes are locked/unlocked. BPF_STACK_TRACE(stack_traces, 655360); // The first argument to the user space function we are tracing // is a pointer to the mutex M held by thread T. // // For all mutexes N held by mutexes_held[T] // add edge N => M (held by T) // mutexes_held[T].add(M) int trace_mutex_acquire(struct pt_regs *ctx, void *mutex_addr) { // Higher 32 bits is process ID, Lower 32 bits is thread ID u32 pid = bpf_get_current_pid_tgid(); u64 mutex = (u64)mutex_addr; struct thread_to_held_mutex_leaf_t empty_leaf = {}; struct thread_to_held_mutex_leaf_t *leaf = thread_to_held_mutexes.lookup_or_init(&pid, &empty_leaf); if (!leaf) { bpf_trace_printk( "could not add thread_to_held_mutex key, thread: %d, mutex: %p\n", pid, mutex); return 1; // Could not insert, no more memory } // Recursive mutexes lock the same mutex multiple times. We cannot tell if // the mutex is recursive after the mutex is already created. To avoid noisy // reports, disallow self edges. Do one pass to check if we are already // holding the mutex, and if we are, do nothing. #pragma unroll for (int i = 0; i < MAX_HELD_MUTEXES; ++i) { if (leaf->held_mutexes[i].mutex == mutex) { return 1; // Disallow self edges } } u64 stack_id = stack_traces.get_stackid(ctx, BPF_F_USER_STACK | BPF_F_REUSE_STACKID); int added_mutex = 0; #pragma unroll for (int i = 0; i < MAX_HELD_MUTEXES; ++i) { // If this is a free slot, see if we can insert. if (!leaf->held_mutexes[i].mutex) { if (!added_mutex) { leaf->held_mutexes[i].mutex = mutex; leaf->held_mutexes[i].stack_id = stack_id; added_mutex = 1; } continue; // Nothing to do for a free slot } // Add edges from held mutex => current mutex struct edges_key_t edge_key = {}; edge_key.mutex1 = leaf->held_mutexes[i].mutex; edge_key.mutex2 = mutex; struct edges_leaf_t edge_leaf = {}; edge_leaf.mutex1_stack_id = leaf->held_mutexes[i].stack_id; edge_leaf.mutex2_stack_id = stack_id; edge_leaf.thread_pid = pid; bpf_get_current_comm(&edge_leaf.comm, sizeof(edge_leaf.comm)); // Returns non-zero on error int result = edges.update(&edge_key, &edge_leaf); if (result) { bpf_trace_printk("could not add edge key %p, %p, error: %d\n", edge_key.mutex1, edge_key.mutex2, result); continue; // Could not insert, no more memory } } // There were no free slots for this mutex. if (!added_mutex) { bpf_trace_printk("could not add mutex %p, added_mutex: %d\n", mutex, added_mutex); return 1; } return 0; } // The first argument to the user space function we are tracing // is a pointer to the mutex M held by thread T. // // mutexes_held[T].remove(M) int trace_mutex_release(struct pt_regs *ctx, void *mutex_addr) { // Higher 32 bits is process ID, Lower 32 bits is thread ID u32 pid = bpf_get_current_pid_tgid(); u64 mutex = (u64)mutex_addr; struct thread_to_held_mutex_leaf_t *leaf = thread_to_held_mutexes.lookup(&pid); if (!leaf) { // If the leaf does not exist for the pid, then it means we either missed // the acquire event, or we had no more memory and could not add it. bpf_trace_printk( "could not find thread_to_held_mutex, thread: %d, mutex: %p\n", pid, mutex); return 1; } // For older kernels without "Bpf: allow access into map value arrays" // (https://lkml.org/lkml/2016/8/30/287) the bpf verifier will fail with an // invalid memory access on `leaf->held_mutexes[i]` below. On newer kernels, // we can avoid making this extra copy in `value` and use `leaf` directly. struct thread_to_held_mutex_leaf_t value = {}; bpf_probe_read(&value, sizeof(struct thread_to_held_mutex_leaf_t), leaf); #pragma unroll for (int i = 0; i < MAX_HELD_MUTEXES; ++i) { // Find the current mutex (if it exists), and clear it. // Note: Can't use `leaf->` in this if condition, see comment above. if (value.held_mutexes[i].mutex == mutex) { leaf->held_mutexes[i].mutex = 0; leaf->held_mutexes[i].stack_id = 0; } } return 0; } // Trace return from clone() syscall in the child thread (return value > 0). int trace_clone(struct pt_regs *ctx, unsigned long flags, void *child_stack, void *ptid, void *ctid, struct pt_regs *regs) { u32 child_pid = PT_REGS_RC(ctx); if (child_pid <= 0) { return 1; } struct thread_created_leaf_t thread_created_leaf = {}; thread_created_leaf.parent_pid = bpf_get_current_pid_tgid(); thread_created_leaf.stack_id = stack_traces.get_stackid(ctx, BPF_F_USER_STACK | BPF_F_REUSE_STACKID); bpf_get_current_comm(&thread_created_leaf.comm, sizeof(thread_created_leaf.comm)); struct thread_created_leaf_t *insert_result = thread_to_parent.lookup_or_init(&child_pid, &thread_created_leaf); if (!insert_result) { bpf_trace_printk( "could not add thread_created_key, child: %d, parent: %d\n", child_pid, thread_created_leaf.parent_pid); return 1; // Could not insert, no more memory } return 0; } bpfcc-0.2.0+git0.02884a026/tools/deadlock_detector.py000077500000000000000000000471061305314114400216620ustar00rootroot00000000000000#!/usr/bin/env python # # deadlock_detector Detects potential deadlocks (lock order inversions) # on a running process. For Linux, uses BCC, eBPF. # # USAGE: deadlock_detector.py [-h] [--binary BINARY] [--dump-graph DUMP_GRAPH] # [--verbose] [--lock-symbols LOCK_SYMBOLS] # [--unlock-symbols UNLOCK_SYMBOLS] # pid # # This traces pthread mutex lock and unlock calls to build a directed graph # representing the mutex wait graph: # # - Nodes in the graph represent mutexes. # - Edge (A, B) exists if there exists some thread T where lock(A) was called # and lock(B) was called before unlock(A) was called. # # If the program finds a potential lock order inversion, the program will dump # the cycle of mutexes and the stack traces where each mutex was acquired, and # then exit. # # This program can only find potential deadlocks that occur while the program # is tracing the process. It cannot find deadlocks that may have occurred # before the program was attached to the process. # # Since this traces all mutex lock and unlock events and all thread creation # events on the traced process, the overhead of this bpf program can be very # high if the process has many threads and mutexes. You should only run this on # a process where the slowdown is acceptable. # # Note: This tool does not work for shared mutexes or recursive mutexes. # # For shared (read-write) mutexes, a deadlock requires a cycle in the wait # graph where at least one of the mutexes in the cycle is acquiring exclusive # (write) ownership. # # For recursive mutexes, lock() is called multiple times on the same mutex. # However, there is no way to determine if a mutex is a recursive mutex # after the mutex has been created. As a result, this tool will not find # potential deadlocks that involve only one mutex. # # Copyright 2017 Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 01-Feb-2017 Kenny Yu Created this. from __future__ import ( absolute_import, division, unicode_literals, print_function ) from bcc import BPF from collections import defaultdict import argparse import json import os import subprocess import sys import time class DiGraph(object): ''' Adapted from networkx: http://networkx.github.io/ Represents a directed graph. Edges can store (key, value) attributes. ''' def __init__(self): # Map of node -> set of nodes self.adjacency_map = {} # Map of (node1, node2) -> map string -> arbitrary attribute # This will not be copied in subgraph() self.attributes_map = {} def neighbors(self, node): return self.adjacency_map.get(node, set()) def edges(self): edges = [] for node, neighbors in self.adjacency_map.items(): for neighbor in neighbors: edges.append((node, neighbor)) return edges def nodes(self): return self.adjacency_map.keys() def attributes(self, node1, node2): return self.attributes_map[(node1, node2)] def add_edge(self, node1, node2, **kwargs): if node1 not in self.adjacency_map: self.adjacency_map[node1] = set() if node2 not in self.adjacency_map: self.adjacency_map[node2] = set() self.adjacency_map[node1].add(node2) self.attributes_map[(node1, node2)] = kwargs def remove_node(self, node): self.adjacency_map.pop(node, None) for _, neighbors in self.adjacency_map.items(): neighbors.discard(node) def subgraph(self, nodes): graph = DiGraph() for node in nodes: for neighbor in self.neighbors(node): if neighbor in nodes: graph.add_edge(node, neighbor) return graph def node_link_data(self): ''' Returns the graph as a dictionary in a format that can be serialized. ''' data = { 'directed': True, 'multigraph': False, 'graph': {}, 'links': [], 'nodes': [], } # Do one pass to build a map of node -> position in nodes node_to_number = {} for node in self.adjacency_map.keys(): node_to_number[node] = len(data['nodes']) data['nodes'].append({'id': node}) # Do another pass to build the link information for node, neighbors in self.adjacency_map.items(): for neighbor in neighbors: link = self.attributes_map[(node, neighbor)].copy() link['source'] = node_to_number[node] link['target'] = node_to_number[neighbor] data['links'].append(link) return data def strongly_connected_components(G): ''' Adapted from networkx: http://networkx.github.io/ Parameters ---------- G : DiGraph Returns ------- comp : generator of sets A generator of sets of nodes, one for each strongly connected component of G. ''' preorder = {} lowlink = {} scc_found = {} scc_queue = [] i = 0 # Preorder counter for source in G.nodes(): if source not in scc_found: queue = [source] while queue: v = queue[-1] if v not in preorder: i = i + 1 preorder[v] = i done = 1 v_nbrs = G.neighbors(v) for w in v_nbrs: if w not in preorder: queue.append(w) done = 0 break if done == 1: lowlink[v] = preorder[v] for w in v_nbrs: if w not in scc_found: if preorder[w] > preorder[v]: lowlink[v] = min([lowlink[v], lowlink[w]]) else: lowlink[v] = min([lowlink[v], preorder[w]]) queue.pop() if lowlink[v] == preorder[v]: scc_found[v] = True scc = {v} while ( scc_queue and preorder[scc_queue[-1]] > preorder[v] ): k = scc_queue.pop() scc_found[k] = True scc.add(k) yield scc else: scc_queue.append(v) def simple_cycles(G): ''' Adapted from networkx: http://networkx.github.io/ Parameters ---------- G : DiGraph Returns ------- cycle_generator: generator A generator that produces elementary cycles of the graph. Each cycle is represented by a list of nodes along the cycle. ''' def _unblock(thisnode, blocked, B): stack = set([thisnode]) while stack: node = stack.pop() if node in blocked: blocked.remove(node) stack.update(B[node]) B[node].clear() # Johnson's algorithm requires some ordering of the nodes. # We assign the arbitrary ordering given by the strongly connected comps # There is no need to track the ordering as each node removed as processed. # save the actual graph so we can mutate it here # We only take the edges because we do not want to # copy edge and node attributes here. subG = G.subgraph(G.nodes()) sccs = list(strongly_connected_components(subG)) while sccs: scc = sccs.pop() # order of scc determines ordering of nodes startnode = scc.pop() # Processing node runs 'circuit' routine from recursive version path = [startnode] blocked = set() # vertex: blocked from search? closed = set() # nodes involved in a cycle blocked.add(startnode) B = defaultdict(set) # graph portions that yield no elementary circuit stack = [(startnode, list(subG.neighbors(startnode)))] while stack: thisnode, nbrs = stack[-1] if nbrs: nextnode = nbrs.pop() if nextnode == startnode: yield path[:] closed.update(path) elif nextnode not in blocked: path.append(nextnode) stack.append((nextnode, list(subG.neighbors(nextnode)))) closed.discard(nextnode) blocked.add(nextnode) continue # done with nextnode... look for more neighbors if not nbrs: # no more nbrs if thisnode in closed: _unblock(thisnode, blocked, B) else: for nbr in subG.neighbors(thisnode): if thisnode not in B[nbr]: B[nbr].add(thisnode) stack.pop() path.pop() # done processing this node subG.remove_node(startnode) H = subG.subgraph(scc) # make smaller to avoid work in SCC routine sccs.extend(list(strongly_connected_components(H))) def find_cycle(graph): ''' Looks for a cycle in the graph. If found, returns the first cycle. If nodes a1, a2, ..., an are in a cycle, then this returns: [(a1,a2), (a2,a3), ... (an-1,an), (an, a1)] Otherwise returns an empty list. ''' cycles = list(simple_cycles(graph)) if cycles: nodes = cycles[0] nodes.append(nodes[0]) edges = [] prev = nodes[0] for node in nodes[1:]: edges.append((prev, node)) prev = node return edges else: return [] def print_cycle(binary, graph, edges, thread_info, print_stack_trace_fn): ''' Prints the cycle in the mutex graph in the following format: Potential Deadlock Detected! Cycle in lock order graph: M0 => M1 => M2 => M0 for (m, n) in cycle: Mutex n acquired here while holding Mutex m in thread T: [ stack trace ] Mutex m previously acquired by thread T here: [ stack trace ] for T in all threads: Thread T was created here: [ stack trace ] ''' # List of mutexes in the cycle, first and last repeated nodes_in_order = [] # Map mutex address -> readable alias node_addr_to_name = {} for counter, (m, n) in enumerate(edges): nodes_in_order.append(m) # For global or static variables, try to symbolize the mutex address. symbol = symbolize_with_objdump(binary, m) if symbol: symbol += ' ' node_addr_to_name[m] = 'Mutex M%d (%s0x%016x)' % (counter, symbol, m) nodes_in_order.append(nodes_in_order[0]) print('----------------\nPotential Deadlock Detected!\n') print( 'Cycle in lock order graph: %s\n' % (' => '.join([node_addr_to_name[n] for n in nodes_in_order])) ) # Set of threads involved in the lock inversion thread_pids = set() # For each edge in the cycle, print where the two mutexes were held for (m, n) in edges: thread_pid = graph.attributes(m, n)['thread_pid'] thread_comm = graph.attributes(m, n)['thread_comm'] first_mutex_stack_id = graph.attributes(m, n)['first_mutex_stack_id'] second_mutex_stack_id = graph.attributes(m, n)['second_mutex_stack_id'] thread_pids.add(thread_pid) print( '%s acquired here while holding %s in Thread %d (%s):' % ( node_addr_to_name[n], node_addr_to_name[m], thread_pid, thread_comm ) ) print_stack_trace_fn(second_mutex_stack_id) print('') print( '%s previously acquired by the same Thread %d (%s) here:' % (node_addr_to_name[m], thread_pid, thread_comm) ) print_stack_trace_fn(first_mutex_stack_id) print('') # Print where the threads were created, if available for thread_pid in thread_pids: parent_pid, stack_id, parent_comm = thread_info.get( thread_pid, (None, None, None) ) if parent_pid: print( 'Thread %d created by Thread %d (%s) here: ' % (thread_pid, parent_pid, parent_comm) ) print_stack_trace_fn(stack_id) else: print( 'Could not find stack trace where Thread %d was created' % thread_pid ) print('') def symbolize_with_objdump(binary, addr): ''' Searches the binary for the address using objdump. Returns the symbol if it is found, otherwise returns empty string. ''' try: command = ( 'objdump -tT %s | grep %x | awk {\'print $NF\'} | c++filt' % (binary, addr) ) output = subprocess.check_output(command, shell=True) return output.decode('utf-8').strip() except subprocess.CalledProcessError: return '' def strlist(s): '''Given a comma-separated string, returns a list of substrings''' return s.strip().split(',') def main(): examples = '''Examples: deadlock_detector 181 # Analyze PID 181 deadlock_detector 181 --binary /lib/x86_64-linux-gnu/libpthread.so.0 # Analyze PID 181 and locks from this binary. # If tracing a process that is running from # a dynamically-linked binary, this argument # is required and should be the path to the # pthread library. deadlock_detector 181 --verbose # Analyze PID 181 and print statistics about # the mutex wait graph. deadlock_detector 181 --lock-symbols my_mutex_lock1,my_mutex_lock2 \\ --unlock-symbols my_mutex_unlock1,my_mutex_unlock2 # Analyze PID 181 and trace custom mutex # symbols instead of pthread mutexes. deadlock_detector 181 --dump-graph graph.json # Analyze PID 181 and dump the mutex wait # graph to graph.json. ''' parser = argparse.ArgumentParser( description=( 'Detect potential deadlocks (lock inversions) in a running binary.' '\nMust be run as root.' ), formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples, ) parser.add_argument('pid', type=int, help='Pid to trace') # Binaries with `:` in the path will fail to attach uprobes on kernels # running without this patch: https://lkml.org/lkml/2017/1/13/585. # Symlinks to the binary without `:` in the path can get around this issue. parser.add_argument( '--binary', type=str, default='', help='If set, trace the mutexes from the binary at this path. ' 'For statically-linked binaries, this argument is not required. ' 'For dynamically-linked binaries, this argument is required and ' 'should be the path of the pthread library the binary is using. ' 'Example: /lib/x86_64-linux-gnu/libpthread.so.0', ) parser.add_argument( '--dump-graph', type=str, default='', help='If set, this will dump the mutex graph to the specified file.', ) parser.add_argument( '--verbose', action='store_true', help='Print statistics about the mutex wait graph.', ) parser.add_argument( '--lock-symbols', type=strlist, default=['pthread_mutex_lock'], help='Comma-separated list of lock symbols to trace. Default is ' 'pthread_mutex_lock. These symbols cannot be inlined in the binary.', ) parser.add_argument( '--unlock-symbols', type=strlist, default=['pthread_mutex_unlock'], help='Comma-separated list of unlock symbols to trace. Default is ' 'pthread_mutex_unlock. These symbols cannot be inlined in the binary.', ) args = parser.parse_args() if not args.binary: try: args.binary = os.readlink('/proc/%d/exe' % args.pid) except OSError as e: print('%s. Is the process (pid=%d) running?' % (str(e), args.pid)) sys.exit(1) bpf = BPF(src_file='deadlock_detector.c') # Trace where threads are created bpf.attach_kretprobe( event='sys_clone', fn_name='trace_clone', pid=args.pid ) # We must trace unlock first, otherwise in the time we attached the probe # on lock() and have not yet attached the probe on unlock(), a thread can # acquire mutexes and release them, but the release events will not be # traced, resulting in noisy reports. for symbol in args.unlock_symbols: try: bpf.attach_uprobe( name=args.binary, sym=symbol, fn_name='trace_mutex_release', pid=args.pid, ) except Exception as e: print('%s. Failed to attach to symbol: %s' % (str(e), symbol)) sys.exit(1) for symbol in args.lock_symbols: try: bpf.attach_uprobe( name=args.binary, sym=symbol, fn_name='trace_mutex_acquire', pid=args.pid, ) except Exception as e: print('%s. Failed to attach to symbol: %s' % (str(e), symbol)) sys.exit(1) def print_stack_trace(stack_id): '''Closure that prints the symbolized stack trace.''' for addr in bpf.get_table('stack_traces').walk(stack_id): line = bpf.sym(addr, args.pid) # Try to symbolize with objdump if we cannot with bpf. if line == '[unknown]': symbol = symbolize_with_objdump(args.binary, addr) if symbol: line = symbol print('@ %016x %s' % (addr, line)) print('Tracing... Hit Ctrl-C to end.') while True: try: # Map of child thread pid -> parent info thread_info = { child.value: (parent.parent_pid, parent.stack_id, parent.comm) for child, parent in bpf.get_table('thread_to_parent').items() } # Mutex wait directed graph. Nodes are mutexes. Edge (A,B) exists # if there exists some thread T where lock(A) was called and # lock(B) was called before unlock(A) was called. graph = DiGraph() for key, leaf in bpf.get_table('edges').items(): graph.add_edge( key.mutex1, key.mutex2, thread_pid=leaf.thread_pid, thread_comm=leaf.comm.decode('utf-8'), first_mutex_stack_id=leaf.mutex1_stack_id, second_mutex_stack_id=leaf.mutex2_stack_id, ) if args.verbose: print( 'Mutexes: %d, Edges: %d' % (len(graph.nodes()), len(graph.edges())) ) if args.dump_graph: with open(args.dump_graph, 'w') as f: data = graph.node_link_data() f.write(json.dumps(data, indent=2)) cycle = find_cycle(graph) if cycle: print_cycle( args.binary, graph, cycle, thread_info, print_stack_trace ) sys.exit(1) time.sleep(1) except KeyboardInterrupt: break if __name__ == '__main__': main() bpfcc-0.2.0+git0.02884a026/tools/deadlock_detector_example.txt000066400000000000000000000400461305314114400235550ustar00rootroot00000000000000Demonstrations of deadlock_detector. This program detects potential deadlocks on a running process. The program attaches uprobes on `pthread_mutex_lock` and `pthread_mutex_unlock` to build a mutex wait directed graph, and then looks for a cycle in this graph. This graph has the following properties: - Nodes in the graph represent mutexes. - Edge (A, B) exists if there exists some thread T where lock(A) was called and lock(B) was called before unlock(A) was called. If there is a cycle in this graph, this indicates that there is a lock order inversion (potential deadlock). If the program finds a lock order inversion, the program will dump the cycle of mutexes, dump the stack traces where each mutex was acquired, and then exit. This program can only find potential deadlocks that occur while the program is tracing the process. It cannot find deadlocks that may have occurred before the program was attached to the process. Since this traces all mutex lock and unlock events and all thread creation events on the traced process, the overhead of this bpf program can be very high if the process has many threads and mutexes. You should only run this on a process where the slowdown is acceptable. Note: This tool does not work for shared mutexes or recursive mutexes. For shared (read-write) mutexes, a deadlock requires a cycle in the wait graph where at least one of the mutexes in the cycle is acquiring exclusive (write) ownership. For recursive mutexes, lock() is called multiple times on the same mutex. However, there is no way to determine if a mutex is a recursive mutex after the mutex has been created. As a result, this tool will not find potential deadlocks that involve only one mutex. # ./deadlock_detector.py 181 Tracing... Hit Ctrl-C to end. ---------------- Potential Deadlock Detected! Cycle in lock order graph: Mutex M0 (main::static_mutex3 0x0000000000473c60) => Mutex M1 (0x00007fff6d738400) => Mutex M2 (global_mutex1 0x0000000000473be0) => Mutex M3 (global_mutex2 0x0000000000473c20) => Mutex M0 (main::static_mutex3 0x0000000000473c60) Mutex M1 (0x00007fff6d738400) acquired here while holding Mutex M0 (main::static_mutex3 0x0000000000473c60) in Thread 357250 (lockinversion): @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402e38 main::{lambda()#3}::operator()() const @ 0000000000406ba8 void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 0000000000406951 std::_Bind_simple::operator()() @ 000000000040673a std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Mutex M0 (main::static_mutex3 0x0000000000473c60) previously acquired by the same Thread 357250 (lockinversion) here: @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402e22 main::{lambda()#3}::operator()() const @ 0000000000406ba8 void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 0000000000406951 std::_Bind_simple::operator()() @ 000000000040673a std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Mutex M2 (global_mutex1 0x0000000000473be0) acquired here while holding Mutex M1 (0x00007fff6d738400) in Thread 357251 (lockinversion): @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402ea8 main::{lambda()#4}::operator()() const @ 0000000000406b46 void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 000000000040692d std::_Bind_simple::operator()() @ 000000000040671c std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Mutex M1 (0x00007fff6d738400) previously acquired by the same Thread 357251 (lockinversion) here: @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402e97 main::{lambda()#4}::operator()() const @ 0000000000406b46 void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 000000000040692d std::_Bind_simple::operator()() @ 000000000040671c std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Mutex M3 (global_mutex2 0x0000000000473c20) acquired here while holding Mutex M2 (global_mutex1 0x0000000000473be0) in Thread 357247 (lockinversion): @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402d5f main::{lambda()#1}::operator()() const @ 0000000000406c6c void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 0000000000406999 std::_Bind_simple::operator()() @ 0000000000406776 std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Mutex M2 (global_mutex1 0x0000000000473be0) previously acquired by the same Thread 357247 (lockinversion) here: @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402d4e main::{lambda()#1}::operator()() const @ 0000000000406c6c void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 0000000000406999 std::_Bind_simple::operator()() @ 0000000000406776 std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Mutex M0 (main::static_mutex3 0x0000000000473c60) acquired here while holding Mutex M3 (global_mutex2 0x0000000000473c20) in Thread 357248 (lockinversion): @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402dc9 main::{lambda()#2}::operator()() const @ 0000000000406c0a void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 0000000000406975 std::_Bind_simple::operator()() @ 0000000000406758 std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Mutex M3 (global_mutex2 0x0000000000473c20) previously acquired by the same Thread 357248 (lockinversion) here: @ 00000000004024d0 pthread_mutex_lock @ 0000000000406dd0 std::mutex::lock() @ 00000000004070d2 std::lock_guard::lock_guard(std::mutex&) @ 0000000000402db8 main::{lambda()#2}::operator()() const @ 0000000000406c0a void std::_Bind_simple::_M_invoke<>(std::_Index_tuple<>) @ 0000000000406975 std::_Bind_simple::operator()() @ 0000000000406758 std::thread::_Impl >::_M_run() @ 00007fd4496564e1 execute_native_thread_routine @ 00007fd449dd57f1 start_thread @ 00007fd44909746d __clone Thread 357248 created by Thread 350692 (lockinversion) here: @ 00007fd449097431 __clone @ 00007fd449dd5ef5 pthread_create @ 00007fd449658440 std::thread::_M_start_thread(std::shared_ptr) @ 00000000004033ac std::thread::thread(main::{lambda()#2}&&) @ 000000000040308f main @ 00007fd448faa0f6 __libc_start_main @ 0000000000402ad8 [unknown] Thread 357250 created by Thread 350692 (lockinversion) here: @ 00007fd449097431 __clone @ 00007fd449dd5ef5 pthread_create @ 00007fd449658440 std::thread::_M_start_thread(std::shared_ptr) @ 00000000004034b2 std::thread::thread(main::{lambda()#3}&&) @ 00000000004030b9 main @ 00007fd448faa0f6 __libc_start_main @ 0000000000402ad8 [unknown] Thread 357251 created by Thread 350692 (lockinversion) here: @ 00007fd449097431 __clone @ 00007fd449dd5ef5 pthread_create @ 00007fd449658440 std::thread::_M_start_thread(std::shared_ptr) @ 00000000004035b8 std::thread::thread(main::{lambda()#4}&&) @ 00000000004030e6 main @ 00007fd448faa0f6 __libc_start_main @ 0000000000402ad8 [unknown] Thread 357247 created by Thread 350692 (lockinversion) here: @ 00007fd449097431 __clone @ 00007fd449dd5ef5 pthread_create @ 00007fd449658440 std::thread::_M_start_thread(std::shared_ptr) @ 00000000004032a6 std::thread::thread(main::{lambda()#1}&&) @ 0000000000403070 main @ 00007fd448faa0f6 __libc_start_main @ 0000000000402ad8 [unknown] This is output from a process that has a potential deadlock involving 4 mutexes and 4 threads: - Thread 357250 acquired M1 while holding M0 (edge M0 -> M1) - Thread 357251 acquired M2 while holding M1 (edge M1 -> M2) - Thread 357247 acquired M3 while holding M2 (edge M2 -> M3) - Thread 357248 acquired M0 while holding M3 (edge M3 -> M0) This is the C++ program that generated the output above: ```c++ #include #include #include #include std::mutex global_mutex1; std::mutex global_mutex2; int main(void) { static std::mutex static_mutex3; std::mutex local_mutex4; std::cout << "sleeping for a bit to allow trace to attach..." << std::endl; std::this_thread::sleep_for(std::chrono::seconds(10)); std::cout << "starting program..." << std::endl; auto t1 = std::thread([] { std::lock_guard g1(global_mutex1); std::lock_guard g2(global_mutex2); }); t1.join(); auto t2 = std::thread([] { std::lock_guard g2(global_mutex2); std::lock_guard g3(static_mutex3); }); t2.join(); auto t3 = std::thread([&local_mutex4] { std::lock_guard g3(static_mutex3); std::lock_guard g4(local_mutex4); }); t3.join(); auto t4 = std::thread([&local_mutex4] { std::lock_guard g4(local_mutex4); std::lock_guard g1(global_mutex1); }); t4.join(); std::cout << "sleeping to allow trace to collect data..." << std::endl; std::this_thread::sleep_for(std::chrono::seconds(5)); std::cout << "done!" << std::endl; } ``` Note that an actual deadlock did not occur, although this mutex lock ordering creates the possibility of a deadlock, and this is a hint to the programmer to reconsider the lock ordering. If the mutexes are global or static and debug symbols are enabled, the output will contain the mutex symbol name. The output uses a similar format as ThreadSanitizer (https://github.com/google/sanitizers/wiki/ThreadSanitizerDeadlockDetector). # ./deadlock_detector.py 181 --binary /usr/local/bin/lockinversion Tracing... Hit Ctrl-C to end. ^C If the traced process is instantiated from a statically-linked executable, this argument is optional, and the program will determine the path of the executable from the pid. However, on older kernels without this patch ("uprobe: Find last occurrence of ':' when parsing uprobe PATH:OFFSET", https://lkml.org/lkml/2017/1/13/585), binaries that contain `:` in the path cannot be attached with uprobes. As a workaround, we can create a symlink to the binary, and provide the symlink name instead to the `--binary` option. # ./deadlock_detector.py 181 --binary /lib/x86_64-linux-gnu/libpthread.so.0 Tracing... Hit Ctrl-C to end. ^C If the traced process is instantiated from a dynamically-linked executable, this argument is required and needs to be the path to the pthread shared library used by the executable. # ./deadlock_detector.py 181 --dump-graph graph.json --verbose Tracing... Hit Ctrl-C to end. Mutexes: 0, Edges: 0 Mutexes: 532, Edges: 411 Mutexes: 735, Edges: 675 Mutexes: 1118, Edges: 1278 Mutexes: 1666, Edges: 2185 Mutexes: 2056, Edges: 2694 Mutexes: 2245, Edges: 2906 Mutexes: 2656, Edges: 3479 Mutexes: 2813, Edges: 3785 ^C If the program does not find a deadlock, it will keep running until you hit Ctrl-C. If you pass the `--verbose` flag, the program will also dump statistics about the number of mutexes and edges in the mutex wait graph. If you want to serialize the graph to analyze it later, you can pass the `--dump-graph FILE` flag, and the program will serialize the graph in json. # ./deadlock_detector.py 181 --lock-symbols custom_mutex1_lock,custom_mutex2_lock --unlock_symbols custom_mutex1_unlock,custom_mutex2_unlock --verbose Tracing... Hit Ctrl-C to end. Mutexes: 0, Edges: 0 Mutexes: 532, Edges: 411 Mutexes: 735, Edges: 675 Mutexes: 1118, Edges: 1278 Mutexes: 1666, Edges: 2185 Mutexes: 2056, Edges: 2694 Mutexes: 2245, Edges: 2906 Mutexes: 2656, Edges: 3479 Mutexes: 2813, Edges: 3785 ^C If your program is using custom mutexes and not pthread mutexes, you can use the `--lock-symbols` and `--unlock-symbols` flags to specify different mutex symbols to trace. The flags take a comma-separated string of symbol names. Note that if the symbols are inlined in the binary, then this program can result in false positives. USAGE message: # ./deadlock_detector.py -h usage: deadlock_detector.py [-h] [--binary BINARY] [--dump-graph DUMP_GRAPH] [--verbose] [--lock-symbols LOCK_SYMBOLS] [--unlock-symbols UNLOCK_SYMBOLS] pid Detect potential deadlocks (lock inversions) in a running binary. Must be run as root. positional arguments: pid Pid to trace optional arguments: -h, --help show this help message and exit --binary BINARY If set, trace the mutexes from the binary at this path. For statically-linked binaries, this argument is not required. For dynamically-linked binaries, this argument is required and should be the path of the pthread library the binary is using. Example: /lib/x86_64-linux-gnu/libpthread.so.0 --dump-graph DUMP_GRAPH If set, this will dump the mutex graph to the specified file. --verbose Print statistics about the mutex wait graph. --lock-symbols LOCK_SYMBOLS Comma-separated list of lock symbols to trace. Default is pthread_mutex_lock. These symbols cannot be inlined in the binary. --unlock-symbols UNLOCK_SYMBOLS Comma-separated list of unlock symbols to trace. Default is pthread_mutex_unlock. These symbols cannot be inlined in the binary. Examples: deadlock_detector 181 # Analyze PID 181 deadlock_detector 181 --binary /lib/x86_64-linux-gnu/libpthread.so.0 # Analyze PID 181 and locks from this binary. # If tracing a process that is running from # a dynamically-linked binary, this argument # is required and should be the path to the # pthread library. deadlock_detector 181 --verbose # Analyze PID 181 and print statistics about # the mutex wait graph. deadlock_detector 181 --lock-symbols my_mutex_lock1,my_mutex_lock2 \ --unlock-symbols my_mutex_unlock1,my_mutex_unlock2 # Analyze PID 181 and trace custom mutex # symbols instead of pthread mutexes. deadlock_detector 181 --dump-graph graph.json # Analyze PID 181 and dump the mutex wait # graph to graph.json. bpfcc-0.2.0+git0.02884a026/tools/execsnoop.py000077500000000000000000000150461305314114400202240ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # execsnoop Trace new processes via exec() syscalls. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: execsnoop [-h] [-t] [-x] [-n NAME] # # This currently will print up to a maximum of 19 arguments, plus the process # name, so 20 fields in total (MAXARG). # # This won't catch all new processes: an application may fork() but not exec(). # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 07-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse import ctypes as ct import re import time from collections import defaultdict # arguments examples = """examples: ./execsnoop # trace all exec() syscalls ./execsnoop -x # include failed exec()s ./execsnoop -t # include timestamps ./execsnoop -n main # only print command lines containing "main" """ parser = argparse.ArgumentParser( description="Trace exec() syscalls", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-t", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-x", "--fails", action="store_true", help="include failed exec()s") parser.add_argument("-n", "--name", help="only print commands matching this name (regex), any arg") args = parser.parse_args() # define BPF program bpf_text = """ #include #include #include #define MAXARG 20 #define ARGSIZE 128 enum event_type { EVENT_ARG, EVENT_RET, }; struct data_t { u32 pid; // PID as in the userspace term (i.e. task->tgid in kernel) char comm[TASK_COMM_LEN]; enum event_type type; char argv[ARGSIZE]; int retval; }; BPF_PERF_OUTPUT(events); static int __submit_arg(struct pt_regs *ctx, void *ptr, struct data_t *data) { bpf_probe_read(data->argv, sizeof(data->argv), ptr); events.perf_submit(ctx, data, sizeof(struct data_t)); return 1; } static int submit_arg(struct pt_regs *ctx, void *ptr, struct data_t *data) { const char *argp = NULL; bpf_probe_read(&argp, sizeof(argp), ptr); if (argp) { return __submit_arg(ctx, (void *)(argp), data); } return 0; } int kprobe__sys_execve(struct pt_regs *ctx, struct filename *filename, const char __user *const __user *__argv, const char __user *const __user *__envp) { // create data here and pass to submit_arg to save stack space (#555) struct data_t data = {}; data.pid = bpf_get_current_pid_tgid() >> 32; bpf_get_current_comm(&data.comm, sizeof(data.comm)); data.type = EVENT_ARG; __submit_arg(ctx, (void *)filename, &data); int i = 1; // skip first arg, as we submitted filename // unrolled loop to walk argv[] (MAXARG) if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; // X if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; if (submit_arg(ctx, (void *)&__argv[i], &data) == 0) goto out; i++; // XX // handle truncated argument list char ellipsis[] = "..."; __submit_arg(ctx, (void *)ellipsis, &data); out: return 0; } int kretprobe__sys_execve(struct pt_regs *ctx) { struct data_t data = {}; data.pid = bpf_get_current_pid_tgid() >> 32; bpf_get_current_comm(&data.comm, sizeof(data.comm)); data.type = EVENT_RET; data.retval = PT_REGS_RC(ctx); events.perf_submit(ctx, &data, sizeof(data)); return 0; } """ # initialize BPF b = BPF(text=bpf_text) # header if args.timestamp: print("%-8s" % ("TIME(s)"), end="") print("%-16s %-6s %-6s %3s %s" % ("PCOMM", "PID", "PPID", "RET", "ARGS")) TASK_COMM_LEN = 16 # linux/sched.h ARGSIZE = 128 # should match #define in C above class Data(ct.Structure): _fields_ = [ ("pid", ct.c_uint), ("comm", ct.c_char * TASK_COMM_LEN), ("type", ct.c_int), ("argv", ct.c_char * ARGSIZE), ("retval", ct.c_int), ] class EventType(object): EVENT_ARG = 0 EVENT_RET = 1 start_ts = time.time() argv = defaultdict(list) # TODO: This is best-effort PPID matching. Short-lived processes may exit # before we get a chance to read the PPID. This should be replaced with # fetching PPID via C when available (#364). def get_ppid(pid): try: with open("/proc/%d/status" % pid) as status: for line in status: if line.startswith("PPid:"): return int(line.split()[1]) except IOError: pass return 0 # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents skip = False if event.type == EventType.EVENT_ARG: argv[event.pid].append(event.argv) elif event.type == EventType.EVENT_RET: if args.fails and event.retval == 0: skip = True if args.name and not re.search(args.name, event.comm): skip = True if not skip: if args.timestamp: print("%-8.3f" % (time.time() - start_ts), end="") ppid = get_ppid(event.pid) print("%-16s %-6s %-6s %3s %s" % (event.comm.decode(), event.pid, ppid if ppid > 0 else "?", event.retval, b' '.join(argv[event.pid]).decode())) del(argv[event.pid]) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/execsnoop_example.txt000066400000000000000000000062711305314114400221230ustar00rootroot00000000000000Demonstrations of execsnoop, the Linux eBPF/bcc version. execsnoop traces new processes. For example, tracing the commands invoked when running "man ls": # ./execsnoop PCOMM PID RET ARGS bash 15887 0 /usr/bin/man ls preconv 15894 0 /usr/bin/preconv -e UTF-8 man 15896 0 /usr/bin/tbl man 15897 0 /usr/bin/nroff -mandoc -rLL=169n -rLT=169n -Tutf8 man 15898 0 /usr/bin/pager -s nroff 15900 0 /usr/bin/locale charmap nroff 15901 0 /usr/bin/groff -mtty-char -Tutf8 -mandoc -rLL=169n -rLT=169n groff 15902 0 /usr/bin/troff -mtty-char -mandoc -rLL=169n -rLT=169n -Tutf8 groff 15903 0 /usr/bin/grotty The output shows the parent process/command name (PCOMM), the PID, the return value of the exec() (RET), and the filename with arguments (ARGS). This works by traces the execve() system call (commonly used exec() variant), and shows details of the arguments and return value. This catches new processes that follow the fork->exec sequence, as well as processes that re-exec() themselves. Some applications fork() but do not exec(), eg, for worker processes, which won't be included in the execsnoop output. The -x option can be used to include failed exec()s. For example: # ./execsnoop -x PCOMM PID RET ARGS supervise 9660 0 ./run supervise 9661 0 ./run mkdir 9662 0 /bin/mkdir -p ./main run 9663 0 ./run chown 9664 0 /bin/chown nobody:nobody ./main run 9665 0 /bin/mkdir -p ./main supervise 9667 0 ./run run 9660 -2 /usr/local/bin/setuidgid nobody /command/multilog t ./main chown 9668 0 /bin/chown nobody:nobody ./main run 9666 0 /bin/chmod 0777 main run 9663 -2 /usr/local/bin/setuidgid nobody /command/multilog t ./main run 9669 0 /bin/mkdir -p ./main run 9661 -2 /usr/local/bin/setuidgid nobody /command/multilog t ./main supervise 9670 0 ./run [...] This example shows various regular system daemon activity, including some failures (trying to execute a /usr/local/bin/setuidgid, which I just noticed doesn't exist). A -t option can be used to include a timestamp column, and a -n option to match on a name or substring from the full command line (filename + args). Regular expressions are allowed. For example, matching commands containing "mount": # ./execsnoop -tn mount TIME(s) PCOMM PID RET ARGS 2.849 bash 18049 0 /bin/mount -p USAGE message: # ./execsnoop -h usage: execsnoop [-h] [-t] [-x] [-n NAME] Trace exec() syscalls optional arguments: -h, --help show this help message and exit -t, --timestamp include timestamp on output -x, --fails include failed exec()s -n NAME, --name NAME only print commands matching this name (regex), any arg examples: ./execsnoop # trace all exec() syscalls ./execsnoop -x # include failed exec()s ./execsnoop -t # include timestamps ./execsnoop -n main # only print command lines containing "main" bpfcc-0.2.0+git0.02884a026/tools/ext4dist.py000077500000000000000000000126751305314114400177760ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # ext4dist Summarize ext4 operation latency. # For Linux, uses BCC, eBPF. # # USAGE: ext4dist [-h] [-T] [-m] [-p PID] [interval] [count] # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 12-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse # symbols kallsyms = "/proc/kallsyms" # arguments examples = """examples: ./ext4dist # show operation latency as a histogram ./ext4dist -p 181 # trace PID 181 only ./ext4dist 1 10 # print 1 second summaries, 10 times ./ext4dist -m 5 # 5s summaries, milliseconds """ parser = argparse.ArgumentParser( description="Summarize ext4 operation latency", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--notimestamp", action="store_true", help="don't include timestamp on interval output") parser.add_argument("-m", "--milliseconds", action="store_true", help="output in milliseconds") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("interval", nargs="?", help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() pid = args.pid countdown = int(args.count) if args.milliseconds: factor = 1000000 label = "msecs" else: factor = 1000 label = "usecs" if args.interval and int(args.interval) == 0: print("ERROR: interval 0. Exiting.") exit() debug = 0 # define BPF program bpf_text = """ #include #include #include #define OP_NAME_LEN 8 typedef struct dist_key { char op[OP_NAME_LEN]; u64 slot; } dist_key_t; BPF_HASH(start, u32); BPF_HISTOGRAM(dist, dist_key_t); // time operation int trace_entry(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); if (FILTER_PID) return 0; u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); return 0; } // The current ext4 (Linux 4.5) uses generic_file_read_iter(), instead of it's // own function, for reads. So we need to trace that and then filter on ext4, // which I do by checking file->f_op. int trace_read_entry(struct pt_regs *ctx, struct kiocb *iocb) { u32 pid = bpf_get_current_pid_tgid(); if (FILTER_PID) return 0; // ext4 filter on file->f_op == ext4_file_operations struct file *fp = iocb->ki_filp; if ((u64)fp->f_op != EXT4_FILE_OPERATIONS) return 0; u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); return 0; } static int trace_return(struct pt_regs *ctx, const char *op) { u64 *tsp; u32 pid = bpf_get_current_pid_tgid(); // fetch timestamp and calculate delta tsp = start.lookup(&pid); if (tsp == 0) { return 0; // missed start or filtered } u64 delta = (bpf_ktime_get_ns() - *tsp) / FACTOR; // store as histogram dist_key_t key = {.slot = bpf_log2l(delta)}; __builtin_memcpy(&key.op, op, sizeof(key.op)); dist.increment(key); start.delete(&pid); return 0; } int trace_read_return(struct pt_regs *ctx) { char *op = "read"; return trace_return(ctx, op); } int trace_write_return(struct pt_regs *ctx) { char *op = "write"; return trace_return(ctx, op); } int trace_open_return(struct pt_regs *ctx) { char *op = "open"; return trace_return(ctx, op); } int trace_fsync_return(struct pt_regs *ctx) { char *op = "fsync"; return trace_return(ctx, op); } """ # code replacements with open(kallsyms) as syms: ops = '' for line in syms: (addr, size, name) = line.rstrip().split(" ", 2) name = name.split("\t")[0] if name == "ext4_file_operations": ops = "0x" + addr break if ops == '': print("ERROR: no ext4_file_operations in /proc/kallsyms. Exiting.") exit() bpf_text = bpf_text.replace('EXT4_FILE_OPERATIONS', ops) bpf_text = bpf_text.replace('FACTOR', str(factor)) if args.pid: bpf_text = bpf_text.replace('FILTER_PID', 'pid != %s' % pid) else: bpf_text = bpf_text.replace('FILTER_PID', '0') if debug: print(bpf_text) # load BPF program b = BPF(text=bpf_text) # Common file functions. See earlier comment about generic_file_read_iter(). b.attach_kprobe(event="generic_file_read_iter", fn_name="trace_read_entry") b.attach_kprobe(event="ext4_file_write_iter", fn_name="trace_entry") b.attach_kprobe(event="ext4_file_open", fn_name="trace_entry") b.attach_kprobe(event="ext4_sync_file", fn_name="trace_entry") b.attach_kretprobe(event="generic_file_read_iter", fn_name="trace_read_return") b.attach_kretprobe(event="ext4_file_write_iter", fn_name="trace_write_return") b.attach_kretprobe(event="ext4_file_open", fn_name="trace_open_return") b.attach_kretprobe(event="ext4_sync_file", fn_name="trace_fsync_return") print("Tracing ext4 operation latency... Hit Ctrl-C to end.") # output exiting = 0 dist = b.get_table("dist") while (1): try: if args.interval: sleep(int(args.interval)) else: sleep(99999999) except KeyboardInterrupt: exiting = 1 print() if args.interval and (not args.notimestamp): print(strftime("%H:%M:%S:")) dist.print_log2_hist(label, "operation") dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/ext4dist_example.txt000066400000000000000000000214371305314114400216710ustar00rootroot00000000000000Demonstrations of ext4dist, the Linux eBPF/bcc version. ext4dist traces ext4 reads, writes, opens, and fsyncs, and summarizes their latency as a power-of-2 histogram. For example: # ./ext4dist Tracing ext4 operation latency... Hit Ctrl-C to end. ^C operation = 'read' usecs : count distribution 0 -> 1 : 1210 |****************************************| 2 -> 3 : 126 |**** | 4 -> 7 : 376 |************ | 8 -> 15 : 86 |** | 16 -> 31 : 9 | | 32 -> 63 : 47 |* | 64 -> 127 : 6 | | 128 -> 255 : 24 | | 256 -> 511 : 137 |**** | 512 -> 1023 : 66 |** | 1024 -> 2047 : 13 | | 2048 -> 4095 : 7 | | 4096 -> 8191 : 13 | | 8192 -> 16383 : 3 | | operation = 'write' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 75 |****************************************| 16 -> 31 : 5 |** | operation = 'open' usecs : count distribution 0 -> 1 : 1278 |****************************************| 2 -> 3 : 40 |* | 4 -> 7 : 4 | | 8 -> 15 : 1 | | 16 -> 31 : 1 | | This output shows a bi-modal distribution for read latency, with a faster mode of less than 7 microseconds, and a slower mode of between 256 and 1023 microseconds. The count column shows how many events fell into that latency range. It's likely that the faster mode was a hit from the in-memory file system cache, and the slower mode is a read from a storage device (disk). This "latency" is measured from when the operation was issued from the VFS interface to the file system, to when it completed. This spans everything: block device I/O (disk I/O), file system CPU cycles, file system locks, run queue latency, etc. This is a better measure of the latency suffered by applications reading from the file system than measuring this down at the block device interface. Note that this only traces the common file system operations previously listed: other file system operations (eg, inode operations including getattr()) are not traced. An optional interval and a count can be provided, as well as -m to show the distributions in milliseconds. For example: # ./ext4dist -m 1 5 Tracing ext4 operation latency... Hit Ctrl-C to end. 10:19:00: operation = 'read' msecs : count distribution 0 -> 1 : 576 |****************************************| 2 -> 3 : 5 | | 4 -> 7 : 6 | | 8 -> 15 : 13 | | 16 -> 31 : 17 |* | 32 -> 63 : 5 | | 64 -> 127 : 1 | | operation = 'write' msecs : count distribution 0 -> 1 : 20 |****************************************| operation = 'open' msecs : count distribution 0 -> 1 : 346 |****************************************| 10:19:01: operation = 'read' msecs : count distribution 0 -> 1 : 584 |****************************************| 2 -> 3 : 10 | | 4 -> 7 : 11 | | 8 -> 15 : 16 |* | 16 -> 31 : 6 | | 32 -> 63 : 4 | | 64 -> 127 : 2 | | 128 -> 255 : 1 | | operation = 'write' msecs : count distribution 0 -> 1 : 20 |****************************************| operation = 'open' msecs : count distribution 0 -> 1 : 336 |****************************************| 10:19:02: operation = 'read' msecs : count distribution 0 -> 1 : 678 |****************************************| 2 -> 3 : 7 | | 4 -> 7 : 9 | | 8 -> 15 : 25 |* | 16 -> 31 : 10 | | 32 -> 63 : 3 | | operation = 'write' msecs : count distribution 0 -> 1 : 19 |****************************************| 2 -> 3 : 1 |** | operation = 'open' msecs : count distribution 0 -> 1 : 390 |****************************************| 10:19:03: operation = 'read' msecs : count distribution 0 -> 1 : 567 |****************************************| 2 -> 3 : 7 | | 4 -> 7 : 9 | | 8 -> 15 : 20 |* | 16 -> 31 : 15 |* | 32 -> 63 : 5 | | 64 -> 127 : 2 | | operation = 'write' msecs : count distribution 0 -> 1 : 20 |****************************************| operation = 'open' msecs : count distribution 0 -> 1 : 417 |****************************************| 10:19:04: operation = 'read' msecs : count distribution 0 -> 1 : 762 |****************************************| 2 -> 3 : 9 | | 4 -> 7 : 9 | | 8 -> 15 : 11 | | 16 -> 31 : 20 |* | 32 -> 63 : 4 | | 64 -> 127 : 1 | | operation = 'write' msecs : count distribution 0 -> 1 : 20 |****************************************| operation = 'open' msecs : count distribution 0 -> 1 : 427 |****************************************| This shows a mixed read/write workload. USAGE message: # ./ext4dist -h usage: ext4dist [-h] [-T] [-m] [-p PID] [interval] [count] Summarize ext4 operation latency positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -T, --notimestamp don't include timestamp on interval output -m, --milliseconds output in milliseconds -p PID, --pid PID trace this PID only examples: ./ext4dist # show operation latency as a histogram ./ext4dist -p 181 # trace PID 181 only ./ext4dist 1 10 # print 1 second summaries, 10 times ./ext4dist -m 5 # 5s summaries, milliseconds bpfcc-0.2.0+git0.02884a026/tools/ext4slower.py000077500000000000000000000224061305314114400203370ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # ext4slower Trace slow ext4 operations. # For Linux, uses BCC, eBPF. # # USAGE: ext4slower [-h] [-j] [-p PID] [min_ms] # # This script traces common ext4 file operations: reads, writes, opens, and # syncs. It measures the time spent in these operations, and prints details # for each that exceeded a threshold. # # WARNING: This adds low-overhead instrumentation to these ext4 operations, # including reads and writes from the file system cache. Such reads and writes # can be very frequent (depending on the workload; eg, 1M/sec), at which # point the overhead of this tool (even if it prints no "slower" events) can # begin to become significant. # # By default, a minimum millisecond threshold of 10 is used. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 11-Feb-2016 Brendan Gregg Created this. # 15-Oct-2016 Dina Goldshtein -p to filter by process ID. from __future__ import print_function from bcc import BPF import argparse from time import strftime import ctypes as ct # symbols kallsyms = "/proc/kallsyms" # arguments examples = """examples: ./ext4slower # trace operations slower than 10 ms (default) ./ext4slower 1 # trace operations slower than 1 ms ./ext4slower -j 1 # ... 1 ms, parsable output (csv) ./ext4slower 0 # trace all operations (warning: verbose) ./ext4slower -p 185 # trace PID 185 only """ parser = argparse.ArgumentParser( description="Trace common ext4 file operations slower than a threshold", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-j", "--csv", action="store_true", help="just print fields: comma-separated values") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("min_ms", nargs="?", default='10', help="minimum I/O duration to trace, in ms (default 10)") args = parser.parse_args() min_ms = int(args.min_ms) pid = args.pid csv = args.csv debug = 0 # define BPF program bpf_text = """ #include #include #include #include // XXX: switch these to char's when supported #define TRACE_READ 0 #define TRACE_WRITE 1 #define TRACE_OPEN 2 #define TRACE_FSYNC 3 struct val_t { u64 ts; u64 offset; struct file *fp; }; struct data_t { // XXX: switch some to u32's when supported u64 ts_us; u64 type; u64 size; u64 offset; u64 delta_us; u64 pid; char task[TASK_COMM_LEN]; char file[DNAME_INLINE_LEN]; }; BPF_HASH(entryinfo, u64, struct val_t); BPF_PERF_OUTPUT(events); // // Store timestamp and size on entry // // The current ext4 (Linux 4.5) uses generic_file_read_iter(), instead of it's // own function, for reads. So we need to trace that and then filter on ext4, // which I do by checking file->f_op. int trace_read_entry(struct pt_regs *ctx, struct kiocb *iocb) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // ext4 filter on file->f_op == ext4_file_operations struct file *fp = iocb->ki_filp; if ((u64)fp->f_op != EXT4_FILE_OPERATIONS) return 0; // store filep and timestamp by id struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = fp; val.offset = iocb->ki_pos; if (val.fp) entryinfo.update(&id, &val); return 0; } // ext4_file_write_iter(): int trace_write_entry(struct pt_regs *ctx, struct kiocb *iocb) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // store filep and timestamp by id struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = iocb->ki_filp; val.offset = iocb->ki_pos; if (val.fp) entryinfo.update(&id, &val); return 0; } // ext4_file_open(): int trace_open_entry(struct pt_regs *ctx, struct inode *inode, struct file *file) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // store filep and timestamp by id struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = file; val.offset = 0; if (val.fp) entryinfo.update(&id, &val); return 0; } // ext4_sync_file(): int trace_fsync_entry(struct pt_regs *ctx, struct file *file) { u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part if (FILTER_PID) return 0; // store filep and timestamp by id struct val_t val = {}; val.ts = bpf_ktime_get_ns(); val.fp = file; val.offset = 0; if (val.fp) entryinfo.update(&id, &val); return 0; } // // Output // static int trace_return(struct pt_regs *ctx, int type) { struct val_t *valp; u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part valp = entryinfo.lookup(&id); if (valp == 0) { // missed tracing issue or filtered return 0; } // calculate delta u64 ts = bpf_ktime_get_ns(); u64 delta_us = (ts - valp->ts) / 1000; entryinfo.delete(&id); if (FILTER_US) return 0; // populate output struct u32 size = PT_REGS_RC(ctx); struct data_t data = {.type = type, .size = size, .delta_us = delta_us, .pid = pid}; data.ts_us = ts / 1000; data.offset = valp->offset; bpf_get_current_comm(&data.task, sizeof(data.task)); // workaround (rewriter should handle file to d_name in one step): struct dentry *de = NULL; struct qstr qs = {}; bpf_probe_read(&de, sizeof(de), &valp->fp->f_path.dentry); bpf_probe_read(&qs, sizeof(qs), (void *)&de->d_name); if (qs.len == 0) return 0; bpf_probe_read(&data.file, sizeof(data.file), (void *)qs.name); // output events.perf_submit(ctx, &data, sizeof(data)); return 0; } int trace_read_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_READ); } int trace_write_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_WRITE); } int trace_open_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_OPEN); } int trace_fsync_return(struct pt_regs *ctx) { return trace_return(ctx, TRACE_FSYNC); } """ # code replacements with open(kallsyms) as syms: ops = '' for line in syms: (addr, size, name) = line.rstrip().split(" ", 2) name = name.split("\t")[0] if name == "ext4_file_operations": ops = "0x" + addr break if ops == '': print("ERROR: no ext4_file_operations in /proc/kallsyms. Exiting.") exit() bpf_text = bpf_text.replace('EXT4_FILE_OPERATIONS', ops) if min_ms == 0: bpf_text = bpf_text.replace('FILTER_US', '0') else: bpf_text = bpf_text.replace('FILTER_US', 'delta_us <= %s' % str(min_ms * 1000)) if args.pid: bpf_text = bpf_text.replace('FILTER_PID', 'pid != %s' % pid) else: bpf_text = bpf_text.replace('FILTER_PID', '0') if debug: print(bpf_text) # kernel->user event data: struct data_t DNAME_INLINE_LEN = 32 # linux/dcache.h TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [ ("ts_us", ct.c_ulonglong), ("type", ct.c_ulonglong), ("size", ct.c_ulonglong), ("offset", ct.c_ulonglong), ("delta_us", ct.c_ulonglong), ("pid", ct.c_ulonglong), ("task", ct.c_char * TASK_COMM_LEN), ("file", ct.c_char * DNAME_INLINE_LEN) ] # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents type = 'R' if event.type == 1: type = 'W' elif event.type == 2: type = 'O' elif event.type == 3: type = 'S' if (csv): print("%d,%s,%d,%s,%d,%d,%d,%s" % ( event.ts_us, event.task, event.pid, type, event.size, event.offset, event.delta_us, event.file)) return print("%-8s %-14.14s %-6s %1s %-7s %-8d %7.2f %s" % (strftime("%H:%M:%S"), event.task, event.pid, type, event.size, event.offset / 1024, float(event.delta_us) / 1000, event.file)) # initialize BPF b = BPF(text=bpf_text) # Common file functions. See earlier comment about generic_file_read_iter(). b.attach_kprobe(event="generic_file_read_iter", fn_name="trace_read_entry") b.attach_kprobe(event="ext4_file_write_iter", fn_name="trace_write_entry") b.attach_kprobe(event="ext4_file_open", fn_name="trace_open_entry") b.attach_kprobe(event="ext4_sync_file", fn_name="trace_fsync_entry") b.attach_kretprobe(event="generic_file_read_iter", fn_name="trace_read_return") b.attach_kretprobe(event="ext4_file_write_iter", fn_name="trace_write_return") b.attach_kretprobe(event="ext4_file_open", fn_name="trace_open_return") b.attach_kretprobe(event="ext4_sync_file", fn_name="trace_fsync_return") # header if (csv): print("ENDTIME_us,TASK,PID,TYPE,BYTES,OFFSET_b,LATENCY_us,FILE") else: if min_ms == 0: print("Tracing ext4 operations") else: print("Tracing ext4 operations slower than %d ms" % min_ms) print("%-8s %-14s %-6s %1s %-7s %-8s %7s %s" % ("TIME", "COMM", "PID", "T", "BYTES", "OFF_KB", "LAT(ms)", "FILENAME")) # read events b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/ext4slower_example.txt000066400000000000000000000261071305314114400222400ustar00rootroot00000000000000Demonstrations of ext4slower, the Linux eBPF/bcc version. ext4slower shows ext4 reads, writes, opens, and fsyncs, slower than a threshold. For example: # ./ext4slower Tracing ext4 operations slower than 10 ms TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME 06:35:01 cron 16464 R 1249 0 16.05 common-auth 06:35:01 cron 16463 R 1249 0 16.04 common-auth 06:35:01 cron 16465 R 1249 0 16.03 common-auth 06:35:01 cron 16465 R 4096 0 10.62 login.defs 06:35:01 cron 16464 R 4096 0 10.61 login.defs 06:35:01 cron 16463 R 4096 0 10.63 login.defs 06:35:01 cron 16465 R 2972 0 18.52 pam_env.conf 06:35:01 cron 16464 R 2972 0 18.51 pam_env.conf 06:35:01 cron 16463 R 2972 0 18.49 pam_env.conf 06:35:01 dumpsystemstat 16473 R 128 0 12.58 date 06:35:01 debian-sa1 16474 R 283 0 12.66 sysstat 06:35:01 debian-sa1 16474 R 128 0 10.39 sa1 06:35:01 dumpsystemstat 16491 R 128 0 13.22 ifconfig 06:35:01 DumpThreads 16534 R 128 0 12.78 cut 06:35:01 cron 16545 R 128 0 14.76 sendmail 06:35:01 sendmail 16545 R 274 0 10.88 dynamicmaps.cf 06:35:02 postdrop 16546 R 118 0 32.94 Universal 06:35:02 pickup 9574 R 118 0 21.02 localtime [...] This shows various system tasks reading from ext4. The high latency here is due to disk I/O, as I had just evicted the file system cache for this example. This "latency" is measured from when the operation was issued from the VFS interface to the file system, to when it completed. This spans everything: block device I/O (disk I/O), file system CPU cycles, file system locks, run queue latency, etc. This is a better measure of the latency suffered by applications reading from the file system than measuring this down at the block device interface. Note that this only traces the common file system operations previously listed: other file system operations (eg, inode operations including getattr()) are not traced. The threshold can be provided as an argument. Eg, I/O slower than 1 ms: # ./ext4slower 1 Tracing ext4 operations slower than 1 ms TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME 06:49:17 bash 3616 R 128 0 7.75 cksum 06:49:17 cksum 3616 R 39552 0 1.34 [ 06:49:17 cksum 3616 R 96 0 5.36 2to3-2.7 06:49:17 cksum 3616 R 96 0 14.94 2to3-3.4 06:49:17 cksum 3616 R 10320 0 6.82 411toppm 06:49:17 cksum 3616 R 65536 0 4.01 a2p 06:49:17 cksum 3616 R 55400 0 8.77 ab 06:49:17 cksum 3616 R 36792 0 16.34 aclocal-1.14 06:49:17 cksum 3616 R 15008 0 19.31 acpi_listen 06:49:17 cksum 3616 R 6123 0 17.23 add-apt-repository 06:49:17 cksum 3616 R 6280 0 18.40 addpart 06:49:17 cksum 3616 R 27696 0 2.16 addr2line 06:49:17 cksum 3616 R 58080 0 10.11 ag 06:49:17 cksum 3616 R 906 0 6.30 ec2-meta-data 06:49:17 cksum 3616 R 6320 0 10.00 animate.im6 06:49:17 cksum 3616 R 5680 0 18.69 anytopnm 06:49:17 cksum 3616 R 2671 0 20.27 apport-bug 06:49:17 cksum 3616 R 12566 0 16.72 apport-cli 06:49:17 cksum 3616 R 1622 0 7.95 apport-unpack 06:49:17 cksum 3616 R 10440 0 2.37 appres 06:49:17 cksum 3616 R 48112 0 5.42 whatis 06:49:17 cksum 3616 R 14832 0 6.24 apt 06:49:17 cksum 3616 R 65536 0 24.74 apt-cache 06:49:17 cksum 3616 R 27264 0 1.68 apt-cdrom 06:49:17 cksum 3616 R 23224 0 5.31 apt-extracttemplates 06:49:17 cksum 3616 R 65536 0 8.08 apt-ftparchive 06:49:17 cksum 3616 R 65536 128 2.92 apt-ftparchive 06:49:17 cksum 3616 R 65536 0 9.58 aptitude-curses 06:49:17 cksum 3616 R 65536 128 44.25 aptitude-curses 06:49:17 cksum 3616 R 65536 384 1.69 aptitude-curses [...] This time a cksum(1) command can be seen reading various files (from /usr/bin). A threshold of 0 will trace all operations. Warning: the output will be verbose, as it will include all file system cache hits. # ./ext4slower 0 Tracing ext4 operations TIME COMM PID T BYTES OFF_KB LAT(ms) FILENAME 06:58:05 supervise 1884 O 0 0 0.00 status.new 06:58:05 supervise 1884 W 18 0 0.02 status.new 06:58:05 supervise 1884 O 0 0 0.00 status.new 06:58:05 supervise 1884 W 18 0 0.01 status.new 06:58:05 supervise 15817 O 0 0 0.00 run 06:58:05 supervise 15817 R 92 0 0.00 run 06:58:05 supervise 15817 O 0 0 0.00 bash 06:58:05 supervise 15817 R 128 0 0.00 bash 06:58:05 supervise 15817 R 504 0 0.00 bash 06:58:05 supervise 15817 R 28 0 0.00 bash 06:58:05 supervise 15817 O 0 0 0.00 ld-2.19.so 06:58:05 supervise 15817 R 64 0 0.00 ld-2.19.so 06:58:05 supervise 15817 R 392 0 0.00 ld-2.19.so 06:58:05 run 15817 O 0 0 0.00 ld.so.cache 06:58:05 run 15817 O 0 0 0.00 libtinfo.so.5.9 06:58:05 run 15817 R 832 0 0.00 libtinfo.so.5.9 06:58:05 run 15817 O 0 0 0.00 libdl-2.19.so 06:58:05 run 15817 R 832 0 0.00 libdl-2.19.so 06:58:05 run 15817 O 0 0 0.00 libc-2.19.so 06:58:05 run 15817 R 832 0 0.00 libc-2.19.so 06:58:05 supervise 1876 O 0 0 0.00 status.new 06:58:05 supervise 1876 W 18 0 0.01 status.new 06:58:05 supervise 1895 O 0 0 0.00 status.new 06:58:05 supervise 1895 W 18 0 0.02 status.new 06:58:05 supervise 1876 O 0 0 0.00 status.new 06:58:05 supervise 1876 W 18 0 0.01 status.new 06:58:05 supervise 1872 O 0 0 0.00 status.new 06:58:05 supervise 1872 W 18 0 0.02 status.new 06:58:05 supervise 1895 O 0 0 0.00 status.new 06:58:05 supervise 1895 W 18 0 0.01 status.new 06:58:05 supervise 15818 R 92 0 0.00 run 06:58:05 supervise 15818 O 0 0 0.00 bash 06:58:05 supervise 15818 R 128 0 0.00 bash 06:58:05 supervise 15818 R 504 0 0.00 bash 06:58:05 supervise 15818 R 28 0 0.00 bash 06:58:05 supervise 15818 O 0 0 0.00 ld-2.19.so 06:58:05 supervise 15818 R 64 0 0.00 ld-2.19.so 06:58:05 supervise 15818 R 392 0 0.00 ld-2.19.so 06:58:05 supervise 15818 O 0 0 0.00 run 06:58:05 supervise 1888 O 0 0 0.00 status.new 06:58:05 supervise 1888 W 18 0 0.01 status.new 06:58:05 supervise 1888 O 0 0 0.00 status.new 06:58:05 supervise 1888 W 18 0 0.02 status.new 06:58:05 supervise 15822 R 119 0 0.00 run 06:58:05 supervise 15822 O 0 0 0.00 bash 06:58:05 supervise 15822 R 128 0 0.00 bash 06:58:05 supervise 15822 R 504 0 0.00 bash 06:58:05 supervise 15822 R 28 0 0.00 bash 06:58:05 supervise 15822 O 0 0 0.00 ld-2.19.so 06:58:05 supervise 15822 R 64 0 0.00 ld-2.19.so 06:58:05 supervise 15822 R 392 0 0.00 ld-2.19.so 06:58:05 supervise 1892 O 0 0 0.00 status.new 06:58:05 supervise 1892 W 18 0 0.02 status.new 06:58:05 supervise 1892 O 0 0 0.00 status.new 06:58:05 supervise 1892 W 18 0 0.02 status.new 06:58:05 supervise 15820 O 0 0 0.00 run [...] The output now includes open operations ("O"), and writes ("W"). A -j option will print just the fields (parsable output, csv): # ./ext4slower -j 1 ENDTIME_us,TASK,PID,TYPE,BYTES,OFFSET_b,LATENCY_us,FILE 127200712278,bash,17225,R,128,0,14329,cksum 127200722986,cksum,17225,R,3274,0,8368,command-not-found 127200735581,cksum,17225,R,65536,0,10903,libbfd-2.24-system.so 127200738482,cksum,17225,R,65536,131072,2419,libbfd-2.24-system.so 127200749226,cksum,17225,R,65536,655360,8995,libbfd-2.24-system.so 127200776273,cksum,17225,R,55080,0,25297,libbind9.so.90.0.9 127200784688,cksum,17225,R,65536,0,7873,libblas.so.3.0 127200787551,cksum,17225,R,65536,131072,2386,libblas.so.3.0 127200795524,cksum,17225,R,18624,0,4947,libcpupower.so.3.13.0-49 127200802073,cksum,17225,R,65536,0,6410,libcwidget.so.3.0.0 127200808718,cksum,17225,R,65536,131072,6181,libcwidget.so.3.0.0 127200829518,cksum,17225,R,65536,0,14213,libdns.so.100.2.2 127200832916,cksum,17225,R,65536,131072,2911,libdns.so.100.2.2 127200841044,cksum,17225,R,65536,655360,6376,libdns.so.100.2.2 127200853646,cksum,17225,R,956,0,1022,libdumbnet.la 127200857814,cksum,17225,R,61096,0,4111,libdumbnet.so.1.0.1 127200869655,cksum,17225,R,65536,0,11252,libgettextlib-0.18.3.so 127200872985,cksum,17225,R,65536,131072,2882,libgettextlib-0.18.3.so 127200883063,cksum,17225,R,65536,0,9661,libgettextsrc-0.18.3.so 127200884767,cksum,17225,R,65536,131072,1251,libgettextsrc-0.18.3.so 127200904830,cksum,17225,R,65536,0,19571,libgirepository-1.0.so.1.0.0 127200906354,cksum,17225,R,65536,131072,1080,libgirepository-1.0.so.1.0.0 127200936047,cksum,17225,R,65536,0,28674,libGraphicsMagick.a 127200939091,cksum,17225,R,65536,131072,2576,libGraphicsMagick.a 127200947295,cksum,17225,R,65536,655360,6463,libGraphicsMagick.a 127200958793,cksum,17225,R,65536,1966080,7034,libGraphicsMagick.a [...] This may be useful for visualizing with another tool, for example, for producing a scatter plot of ENDTIME vs LATENCY, to look for time-based patterns. USAGE message: # ./ext4slower -h usage: ext4slower [-h] [-j] [-p PID] [min_ms] Trace common ext4 file operations slower than a threshold positional arguments: min_ms minimum I/O duration to trace, in ms (default 10) optional arguments: -h, --help show this help message and exit -j, --csv just print fields: comma-separated values -p PID, --pid PID trace this PID only examples: ./ext4slower # trace operations slower than 10 ms (default) ./ext4slower 1 # trace operations slower than 1 ms ./ext4slower -j 1 # ... 1 ms, parsable output (csv) ./ext4slower 0 # trace all operations (warning: verbose) ./ext4slower -p 185 # trace PID 185 only bpfcc-0.2.0+git0.02884a026/tools/filelife.py000077500000000000000000000071671305314114400200050ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # filelife Trace the lifespan of short-lived files. # For Linux, uses BCC, eBPF. Embedded C. # # This traces the creation and deletion of files, providing information # on who deleted the file, the file age, and the file name. The intent is to # provide information on short-lived files, for debugging or performance # analysis. # # USAGE: filelife [-h] [-p PID] # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 08-Feb-2015 Brendan Gregg Created this. # 17-Feb-2016 Allan McAleavy updated for BPF_PERF_OUTPUT from __future__ import print_function from bcc import BPF import argparse from time import strftime import ctypes as ct # arguments examples = """examples: ./filelife # trace all stat() syscalls ./filelife -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace stat() syscalls", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include #include #include struct data_t { u32 pid; u64 delta; char comm[TASK_COMM_LEN]; char fname[DNAME_INLINE_LEN]; }; BPF_HASH(birth, struct dentry *); BPF_PERF_OUTPUT(events); // trace file creation time int trace_create(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { u32 pid = bpf_get_current_pid_tgid(); FILTER u64 ts = bpf_ktime_get_ns(); birth.update(&dentry, &ts); return 0; }; // trace file deletion and output details int trace_unlink(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { struct data_t data = {}; u32 pid = bpf_get_current_pid_tgid(); FILTER u64 *tsp, delta; tsp = birth.lookup(&dentry); if (tsp == 0) { return 0; // missed create } delta = (bpf_ktime_get_ns() - *tsp) / 1000000; birth.delete(&dentry); if (dentry->d_name.len == 0) return 0; if (bpf_get_current_comm(&data.comm, sizeof(data.comm)) == 0) { data.pid = pid; data.delta = delta; bpf_probe_read(&data.fname, sizeof(data.fname), (void *)dentry->d_name.name); } events.perf_submit(ctx, &data, sizeof(data)); return 0; } """ TASK_COMM_LEN = 16 # linux/sched.h DNAME_INLINE_LEN = 255 # linux/dcache.h class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("delta", ct.c_ulonglong), ("comm", ct.c_char * TASK_COMM_LEN), ("fname", ct.c_char * DNAME_INLINE_LEN) ] if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="vfs_create", fn_name="trace_create") # newer kernels (say, 4.8) may don't fire vfs_create, so record (or overwrite) # the timestamp in security_inode_create(): b.attach_kprobe(event="security_inode_create", fn_name="trace_create") b.attach_kprobe(event="vfs_unlink", fn_name="trace_unlink") # header print("%-8s %-6s %-16s %-7s %s" % ("TIME", "PID", "COMM", "AGE(s)", "FILE")) # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents print("%-8s %-6d %-16s %-7.2f %s" % (strftime("%H:%M:%S"), event.pid, event.comm, float(event.delta) / 1000, event.fname)) b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/filelife_example.txt000066400000000000000000000040541305314114400216740ustar00rootroot00000000000000Demonstrations of filelife, the Linux eBPF/bcc version. filelife traces short-lived files: those that have been created and then deleted while tracing. For example: # ./filelife TIME PID COMM AGE(s) FILE 05:57:59 8556 gcc 0.04 ccCB5EDe.s 05:57:59 8560 rm 0.02 .entry_64.o.d 05:57:59 8563 gcc 0.02 cc5UFHXf.s 05:57:59 8567 rm 0.01 .thunk_64.o.d 05:57:59 8578 rm 0.02 .syscall_64.o.d 05:58:00 8589 rm 0.03 .common.o.d 05:58:00 8596 rm 0.01 .8592.tmp 05:58:00 8601 rm 0.01 .8597.tmp 05:58:00 8606 rm 0.01 .8602.tmp 05:58:00 8639 rm 0.02 .vma.o.d 05:58:00 8650 rm 0.02 .vdso32-setup.o.d 05:58:00 8656 rm 0.00 .vdso.lds.d 05:58:00 8659 gcc 0.01 ccveeJAz.s 05:58:00 8663 rm 0.01 .vdso-note.o.d 05:58:00 8674 rm 0.02 .vclock_gettime.o.d 05:58:01 8684 rm 0.01 .vgetcpu.o.d 05:58:01 8690 collect2 0.00 ccvKMxdm.ld This has caught short-lived files that were created during a Linux kernel build. The PID shows the process ID that finally deleted the file, and COMM is its process name. The AGE(s) column shows the age of the file, in seconds, when it was deleted. These are all short-lived, and existed for less than one tenth of a second. Creating, populating, and then deleting files as part of another process can be an inefficient method of inter-process communication. It can cause disk I/O as files are closed and their file descriptors flushed, only later to be deleted. As such, short-lived files can be a target of performance optimizations. USAGE message: # ./filelife -h usage: filelife [-h] [-p PID] Trace stat() syscalls optional arguments: -h, --help show this help message and exit -p PID, --pid PID trace this PID only examples: ./filelife # trace all stat() syscalls ./filelife -p 181 # only trace PID 181 bpfcc-0.2.0+git0.02884a026/tools/fileslower.py000077500000000000000000000160421305314114400203710ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # fileslower Trace slow synchronous file reads and writes. # For Linux, uses BCC, eBPF. # # USAGE: fileslower [-h] [-p PID] [-a] [min_ms] # # This script uses kernel dynamic tracing of synchronous reads and writes # at the VFS interface, to identify slow file reads and writes for any file # system. # # This works by tracing __vfs_read() and __vfs_write(), and filtering for # synchronous I/O (the path to new_sync_read() and new_sync_write()), and # for I/O with filenames. This approach provides a view of just two file # system request types. There are typically many others: asynchronous I/O, # directory operations, file handle operations, etc, that this tool does not # instrument. # # WARNING: This traces VFS reads and writes, which can be extremely frequent, # and so the overhead of this tool can become severe depending on the # workload. # # By default, a minimum millisecond threshold of 10 is used. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 06-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse import ctypes as ct import time # arguments examples = """examples: ./fileslower # trace sync file I/O slower than 10 ms (default) ./fileslower 1 # trace sync file I/O slower than 1 ms ./fileslower -p 185 # trace PID 185 only """ parser = argparse.ArgumentParser( description="Trace slow synchronous file reads and writes", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", type=int, metavar="PID", dest="tgid", help="trace this PID only") parser.add_argument("-a", "--all-files", action="store_true", help="include non-regular file types (sockets, FIFOs, etc)") parser.add_argument("min_ms", nargs="?", default='10', help="minimum I/O duration to trace, in ms (default 10)") args = parser.parse_args() min_ms = int(args.min_ms) tgid = args.tgid debug = 0 # define BPF program bpf_text = """ #include #include #include enum trace_mode { MODE_READ, MODE_WRITE }; struct val_t { u32 sz; u64 ts; u32 name_len; // de->d_name.name may point to de->d_iname so limit len accordingly char name[DNAME_INLINE_LEN]; char comm[TASK_COMM_LEN]; }; struct data_t { enum trace_mode mode; u32 pid; u32 sz; u64 delta_us; u32 name_len; char name[DNAME_INLINE_LEN]; char comm[TASK_COMM_LEN]; }; BPF_HASH(entryinfo, pid_t, struct val_t); BPF_PERF_OUTPUT(events); // store timestamp and size on entry static int trace_rw_entry(struct pt_regs *ctx, struct file *file, char __user *buf, size_t count) { u32 tgid = bpf_get_current_pid_tgid() >> 32; if (TGID_FILTER) return 0; u32 pid = bpf_get_current_pid_tgid(); // skip I/O lacking a filename struct dentry *de = file->f_path.dentry; int mode = file->f_inode->i_mode; if (de->d_name.len == 0 || TYPE_FILTER) return 0; // store size and timestamp by pid struct val_t val = {}; val.sz = count; val.ts = bpf_ktime_get_ns(); val.name_len = de->d_name.len; bpf_probe_read(&val.name, sizeof(val.name), (void *)de->d_name.name); bpf_get_current_comm(&val.comm, sizeof(val.comm)); entryinfo.update(&pid, &val); return 0; } int trace_read_entry(struct pt_regs *ctx, struct file *file, char __user *buf, size_t count) { // skip non-sync I/O; see kernel code for __vfs_read() if (!(file->f_op->read_iter)) return 0; return trace_rw_entry(ctx, file, buf, count); } int trace_write_entry(struct pt_regs *ctx, struct file *file, char __user *buf, size_t count) { // skip non-sync I/O; see kernel code for __vfs_write() if (!(file->f_op->write_iter)) return 0; return trace_rw_entry(ctx, file, buf, count); } // output static int trace_rw_return(struct pt_regs *ctx, int type) { struct val_t *valp; u32 pid = bpf_get_current_pid_tgid(); valp = entryinfo.lookup(&pid); if (valp == 0) { // missed tracing issue or filtered return 0; } u64 delta_us = (bpf_ktime_get_ns() - valp->ts) / 1000; entryinfo.delete(&pid); if (delta_us < MIN_US) return 0; struct data_t data = {}; data.mode = type; data.pid = pid; data.sz = valp->sz; data.delta_us = delta_us; data.name_len = valp->name_len; bpf_probe_read(&data.name, sizeof(data.name), valp->name); bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); events.perf_submit(ctx, &data, sizeof(data)); return 0; } int trace_read_return(struct pt_regs *ctx) { return trace_rw_return(ctx, MODE_READ); } int trace_write_return(struct pt_regs *ctx) { return trace_rw_return(ctx, MODE_WRITE); } """ bpf_text = bpf_text.replace('MIN_US', str(min_ms * 1000)) if args.tgid: bpf_text = bpf_text.replace('TGID_FILTER', 'tgid != %d' % tgid) else: bpf_text = bpf_text.replace('TGID_FILTER', '0') if args.all_files: bpf_text = bpf_text.replace('TYPE_FILTER', '0') else: bpf_text = bpf_text.replace('TYPE_FILTER', '!S_ISREG(mode)') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text,) # I'd rather trace these via new_sync_read/new_sync_write (which used to be # do_sync_read/do_sync_write), but those became static. So trace these from # the parent functions, at the cost of more overhead, instead. # Ultimately, we should be using [V]FS tracepoints. b.attach_kprobe(event="__vfs_read", fn_name="trace_read_entry") b.attach_kretprobe(event="__vfs_read", fn_name="trace_read_return") try: b.attach_kprobe(event="__vfs_write", fn_name="trace_write_entry") b.attach_kretprobe(event="__vfs_write", fn_name="trace_write_return") except: # older kernels don't have __vfs_write so try vfs_write instead b.attach_kprobe(event="vfs_write", fn_name="trace_write_entry") b.attach_kretprobe(event="vfs_write", fn_name="trace_write_return") TASK_COMM_LEN = 16 # linux/sched.h DNAME_INLINE_LEN = 32 # linux/dcache.h class Data(ct.Structure): _fields_ = [ ("mode", ct.c_int), ("pid", ct.c_uint), ("sz", ct.c_uint), ("delta_us", ct.c_ulonglong), ("name_len", ct.c_uint), ("name", ct.c_char * DNAME_INLINE_LEN), ("comm", ct.c_char * TASK_COMM_LEN), ] mode_s = { 0: 'R', 1: 'W', } # header print("Tracing sync read/writes slower than %d ms" % min_ms) print("%-8s %-14s %-6s %1s %-7s %7s %s" % ("TIME(s)", "COMM", "TID", "D", "BYTES", "LAT(ms)", "FILENAME")) start_ts = time.time() def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents ms = float(event.delta_us) / 1000 name = event.name if event.name_len > DNAME_INLINE_LEN: name = name[:-3] + "..." print("%-8.3f %-14.14s %-6s %1s %-7s %7.2f %s" % ( time.time() - start_ts, event.comm, event.pid, mode_s[event.mode], event.sz, ms, name)) b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/fileslower_example.txt000066400000000000000000000131171305314114400222700ustar00rootroot00000000000000Demonstrations of fileslower, the Linux eBPF/bcc version. fileslower shows file-based synchronous reads and writes slower than a threshold. For example: # ./fileslower Tracing sync read/writes slower than 10 ms TIME(s) COMM PID D BYTES LAT(ms) FILENAME 0.000 randread.pl 4762 R 8192 12.70 data1 8.850 randread.pl 4762 R 8192 11.26 data1 12.852 randread.pl 4762 R 8192 10.43 data1 This showed a few reads from a "randread.pl" program, each 8 Kbytes in size, and from a "data1" file. These all had over 10 ms latency. This "latency" is measured from when the read or write was issued at the VFS interface, to when it completed. This spans everything: block device I/O (disk I/O), file system CPU cycles, file system locks, run queue latency, etc. This is a better measure of the latency suffered by applications reading from the file system than measuring this down at the block device interface. Note that this only traces file reads and writes: other file system operations (eg, directory operations, open(), fflush()) are not traced. The threshold can be provided as an argument. Eg, I/O slower than 1 ms: # ./fileslower 1 Tracing sync read/writes slower than 1 ms TIME(s) COMM PID D BYTES LAT(ms) FILENAME 0.000 randread.pl 6925 R 8192 1.06 data1 0.082 randread.pl 6925 R 8192 2.42 data1 0.116 randread.pl 6925 R 8192 1.78 data1 0.153 randread.pl 6925 R 8192 2.31 data1 0.330 randread.pl 6925 R 8192 1.14 data1 0.345 randread.pl 6925 R 8192 1.52 data1 0.359 randread.pl 6925 R 8192 1.04 data1 0.532 randread.pl 6925 R 8192 2.56 data1 0.609 supervise 1892 W 18 3.65 status.new 0.610 randread.pl 6925 R 8192 1.37 data1 0.614 randread.pl 6925 R 8192 3.04 data1 0.729 randread.pl 6925 R 8192 2.90 data1 0.755 randread.pl 6925 R 8192 1.12 data1 0.762 randread.pl 6925 R 8192 2.62 data1 0.771 randread.pl 6925 R 8192 1.07 data1 0.816 randread.pl 6925 R 8192 10.50 data1 0.983 randread.pl 6925 R 8192 1.73 data1 0.989 randread.pl 6925 R 8192 2.12 data1 0.992 randread.pl 6925 R 8192 2.17 data1 1.001 randread.pl 6925 R 8192 1.93 data1 1.007 randread.pl 6925 R 8192 2.03 data1 1.210 randread.pl 6925 R 8192 1.82 data1 1.213 randread.pl 6925 R 8192 2.58 data1 1.219 randread.pl 6925 R 8192 2.20 data1 1.430 randread.pl 6925 R 8192 1.01 data1 1.448 randread.pl 6925 R 8192 2.22 data1 [...] There's now much more output (this spans only 1.4 seconds, the previous output spanned 12 seconds), and the lower threshold is catching more I/O. In the following example, the file system caches were dropped before running fileslower, and then in another session a "man ls" was executed. The command and files read from disk can be seen: # echo 3 > /proc/sys/vm/drop_caches; ./fileslower 1 Tracing sync read/writes slower than 1 ms TIME(s) COMM PID D BYTES LAT(ms) FILENAME 0.000 bash 9647 R 128 5.83 man 0.050 man 9647 R 832 19.52 libmandb-2.6.7.1.so 0.066 man 9647 R 832 15.79 libman-2.6.7.1.so 0.123 man 9647 R 832 56.36 libpipeline.so.1.3.0 0.135 man 9647 R 832 9.79 libgdbm.so.3.0.0 0.323 man 9647 R 4096 59.52 locale.alias 0.540 man 9648 R 8192 11.11 ls.1.gz 0.558 man 9647 R 72 6.97 index.db 0.563 man 9647 R 4096 5.12 index.db 0.723 man 9658 R 128 12.06 less 0.725 man 9656 R 128 14.52 nroff 0.779 man 9655 R 128 68.86 tbl 0.814 nroff 9660 R 128 14.55 locale 0.830 pager 9658 R 4096 28.27 .lesshst 0.866 man 9654 R 128 163.12 preconv 0.980 nroff 9684 R 128 13.80 groff 0.999 groff 9684 R 4096 14.29 DESC 1.036 groff 9685 R 128 5.94 troff 1.038 groff 9686 R 128 7.76 grotty 1.065 troff 9685 R 4096 6.33 R 1.082 troff 9685 R 4096 10.52 BI 1.096 troff 9685 R 4096 8.70 troffrc 1.176 troff 9685 R 4096 80.12 composite.tmac 1.195 troff 9685 R 4096 19.20 fallbacks.tmac 1.202 troff 9685 R 4096 6.79 tty.tmac 1.221 troff 9685 R 4096 7.87 man.local 2.977 supervise 1876 W 18 4.23 status.new This caught an individual I/O reaching 163.12 ms, for the "preconv" file. While the file system cache was flushed, causing these to need to be read from disk, the duration here may not be entirely disk I/O: it can include file system locks, run queue latency, etc. These can be explored using other commands. USAGE message: # ./fileslower -h usage: fileslower.py [-h] [-p PID] [-a] [min_ms] Trace slow synchronous file reads and writes positional arguments: min_ms minimum I/O duration to trace, in ms (default 10) optional arguments: -h, --help show this help message and exit -p PID, --pid PID trace this PID only -a, --all-files include non-regular file types examples: ./fileslower # trace sync file I/O slower than 10 ms (default) ./fileslower 1 # trace sync file I/O slower than 1 ms ./fileslower -p 185 # trace PID 185 only bpfcc-0.2.0+git0.02884a026/tools/filetop.py000077500000000000000000000130231305314114400176540ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # filetop file reads and writes by process. # For Linux, uses BCC, eBPF. # # USAGE: filetop.py [-h] [-C] [-r MAXROWS] [interval] [count] # # This uses in-kernel eBPF maps to store per process summaries for efficiency. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 06-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse import signal from subprocess import call # arguments examples = """examples: ./filetop # file I/O top, 1 second refresh ./filetop -C # don't clear the screen ./filetop -p 181 # PID 181 only ./filetop 5 # 5 second summaries ./filetop 5 10 # 5 second summaries, 10 times only """ parser = argparse.ArgumentParser( description="File reads and writes by process", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-a", "--all-files", action="store_true", help="include non-regular file types (sockets, FIFOs, etc)") parser.add_argument("-C", "--noclear", action="store_true", help="don't clear the screen") parser.add_argument("-r", "--maxrows", default=20, help="maximum rows to print, default 20") parser.add_argument("-p", "--pid", type=int, metavar="PID", dest="tgid", help="trace this PID only") parser.add_argument("interval", nargs="?", default=1, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() interval = int(args.interval) countdown = int(args.count) maxrows = int(args.maxrows) clear = not int(args.noclear) debug = 0 # linux stats loadavg = "/proc/loadavg" # signal handler def signal_ignore(signal, frame): print() # define BPF program bpf_text = """ #include #include // the key for the output summary struct info_t { u32 pid; u32 name_len; char comm[TASK_COMM_LEN]; // de->d_name.name may point to de->d_iname so limit len accordingly char name[DNAME_INLINE_LEN]; char type; }; // the value of the output summary struct val_t { u64 reads; u64 writes; u64 rbytes; u64 wbytes; }; BPF_HASH(counts, struct info_t, struct val_t); static int do_entry(struct pt_regs *ctx, struct file *file, char __user *buf, size_t count, int is_read) { u32 tgid = bpf_get_current_pid_tgid() >> 32; if (TGID_FILTER) return 0; u32 pid = bpf_get_current_pid_tgid(); // skip I/O lacking a filename struct dentry *de = file->f_path.dentry; int mode = file->f_inode->i_mode; if (de->d_name.len == 0 || TYPE_FILTER) return 0; // store counts and sizes by pid & file struct info_t info = {.pid = pid}; bpf_get_current_comm(&info.comm, sizeof(info.comm)); info.name_len = de->d_name.len; bpf_probe_read(&info.name, sizeof(info.name), (void *)de->d_name.name); if (S_ISREG(mode)) { info.type = 'R'; } else if (S_ISSOCK(mode)) { info.type = 'S'; } else { info.type = 'O'; } struct val_t *valp, zero = {}; valp = counts.lookup_or_init(&info, &zero); if (is_read) { valp->reads++; valp->rbytes += count; } else { valp->writes++; valp->wbytes += count; } return 0; } int trace_read_entry(struct pt_regs *ctx, struct file *file, char __user *buf, size_t count) { return do_entry(ctx, file, buf, count, 1); } int trace_write_entry(struct pt_regs *ctx, struct file *file, char __user *buf, size_t count) { return do_entry(ctx, file, buf, count, 0); } """ if args.tgid: bpf_text = bpf_text.replace('TGID_FILTER', 'tgid != %d' % args.tgid) else: bpf_text = bpf_text.replace('TGID_FILTER', '0') if args.all_files: bpf_text = bpf_text.replace('TYPE_FILTER', '0') else: bpf_text = bpf_text.replace('TYPE_FILTER', '!S_ISREG(mode)') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="__vfs_read", fn_name="trace_read_entry") try: b.attach_kprobe(event="__vfs_write", fn_name="trace_write_entry") except: # older kernels don't have __vfs_write so try vfs_write instead b.attach_kprobe(event="vfs_write", fn_name="trace_write_entry") DNAME_INLINE_LEN = 32 # linux/dcache.h print('Tracing... Output every %d secs. Hit Ctrl-C to end' % interval) # output exiting = 0 while 1: try: sleep(interval) except KeyboardInterrupt: exiting = 1 # header if clear: call("clear") else: print() with open(loadavg) as stats: print("%-8s loadavg: %s" % (strftime("%H:%M:%S"), stats.read())) print("%-6s %-16s %-6s %-6s %-7s %-7s %1s %s" % ("TID", "COMM", "READS", "WRITES", "R_Kb", "W_Kb", "T", "FILE")) # by-TID output counts = b.get_table("counts") line = 0 for k, v in reversed(sorted(counts.items(), key=lambda counts: counts[1].rbytes)): name = k.name.decode() if k.name_len > DNAME_INLINE_LEN: name = name[:-3] + "..." # print line print("%-6d %-16s %-6d %-6d %-7d %-7d %1s %s" % (k.pid, k.comm.decode(), v.reads, v.writes, v.rbytes / 1024, v.wbytes / 1024, k.type.decode(), name)) line += 1 if line >= maxrows: break counts.clear() countdown -= 1 if exiting or countdown == 0: print("Detaching...") exit() bpfcc-0.2.0+git0.02884a026/tools/filetop_example.txt000066400000000000000000000152061305314114400215600ustar00rootroot00000000000000Demonstrations of filetop, the Linux eBPF/bcc version. filetop shows reads and writes by file, with process details. For example: # ./filetop -C Tracing... Output every 1 secs. Hit Ctrl-C to end 08:00:23 loadavg: 0.91 0.33 0.23 3/286 26635 PID COMM READS WRITES R_Kb W_Kb T FILE 26628 ld 161 186 643 152 R built-in.o 26634 cc1 1 0 200 0 R autoconf.h 26618 cc1 1 0 200 0 R autoconf.h 26634 cc1 12 0 192 0 R tracepoint.h 26584 cc1 2 0 143 0 R mm.h 26634 cc1 2 0 143 0 R mm.h 26631 make 34 0 136 0 R auto.conf 26634 cc1 1 0 98 0 R fs.h 26584 cc1 1 0 98 0 R fs.h 26634 cc1 1 0 91 0 R sched.h 26634 cc1 1 0 78 0 R printk.c 26634 cc1 3 0 73 0 R mmzone.h 26628 ld 18 0 72 0 R hibernate.o 26628 ld 16 0 64 0 R suspend.o 26628 ld 16 0 64 0 R snapshot.o 26628 ld 16 0 64 0 R qos.o 26628 ld 13 0 52 0 R main.o 26628 ld 12 0 52 0 R swap.o [...] This shows various files read and written during a Linux kernel build. The output is sorted by the total read size in Kbytes (R_Kb). This is instrumenting at the VFS interface, so this is reads and writes that may return entirely from the file system cache (page cache). While not printed, the average read and write size can be calculated by dividing R_Kb by READS, and the same for writes. The "T" column indicates the type of the file: "R" for regular files, "S" for sockets, and "O" for other (including pipes). By default only regular files are shown; use the -a option to show all file types. This script works by tracing the vfs_read() and vfs_write() functions using kernel dynamic tracing, which instruments explicit read and write calls. If files are read or written using another means (eg, via mmap()), then they will not be visible using this tool. This should be useful for file system workload characterization when analyzing the performance of applications. Note that tracing VFS level reads and writes can be a frequent activity, and this tool can begin to cost measurable overhead at high I/O rates. A -C option will stop clearing the screen, and -r with a number will restrict the output to that many rows (20 by default). For example, not clearing the screen and showing the top 5 only: # ./filetop -Cr 5 Tracing... Output every 1 secs. Hit Ctrl-C to end 08:05:11 loadavg: 0.75 0.35 0.25 3/285 822 PID COMM READS WRITES R_Kb W_Kb T FILE 32672 cksum 5006 0 320384 0 R data1 809 run 2 0 8 0 R nsswitch.conf 811 run 2 0 8 0 R nsswitch.conf 804 chown 2 0 8 0 R nsswitch.conf 08:05:12 loadavg: 0.75 0.35 0.25 3/285 845 PID COMM READS WRITES R_Kb W_Kb T FILE 32672 cksum 4986 0 319104 0 R data1 845 chown 2 0 8 0 R nsswitch.conf 828 run 2 0 8 0 R nsswitch.conf 835 run 2 0 8 0 R nsswitch.conf 830 run 2 0 8 0 R nsswitch.conf 08:05:13 loadavg: 0.75 0.35 0.25 3/285 868 PID COMM READS WRITES R_Kb W_Kb T FILE 32672 cksum 4985 0 319040 0 R data1 857 run 2 0 8 0 R nsswitch.conf 858 run 2 0 8 0 R nsswitch.conf 859 run 2 0 8 0 R nsswitch.conf 848 run 2 0 8 0 R nsswitch.conf [...] This output shows a cksum command reading data1. An optional interval and optional count can also be added to the end of the command line. For example, for 1 second interval, and 3 summaries in total: # ./filetop -Cr 5 -a 1 3 Tracing... Output every 1 secs. Hit Ctrl-C to end 08:08:20 loadavg: 0.30 0.42 0.31 3/282 5187 PID COMM READS WRITES R_Kb W_Kb T FILE 12421 sshd 14101 0 225616 0 O ptmx 12296 sshd 4 0 64 0 O ptmx 12421 sshd 3 14104 48 778 S TCP 5178 run 2 0 8 0 R nsswitch.conf 5165 run 2 0 8 0 R nsswitch.conf 08:08:21 loadavg: 0.30 0.42 0.31 5/282 5210 PID COMM READS WRITES R_Kb W_Kb T FILE 12421 sshd 9159 0 146544 0 O ptmx 12421 sshd 3 9161 48 534 S TCP 12296 sshd 1 0 16 0 S TCP 5188 run 2 0 8 0 R nsswitch.conf 5203 run 2 0 8 0 R nsswitch.conf 08:08:22 loadavg: 0.30 0.42 0.31 2/282 5233 PID COMM READS WRITES R_Kb W_Kb T FILE 12421 sshd 26166 0 418656 0 O ptmx 12421 sshd 4 26171 64 1385 S TCP 12296 sshd 1 0 16 0 O ptmx 5214 run 2 0 8 0 R nsswitch.conf 5227 run 2 0 8 0 R nsswitch.conf Detaching... This example shows the -a option to include all file types. It caught heavy socket I/O from an sshd process, showing up as non-regular file types (the "O" for other, and "S" for socket, in the type column: "T"). USAGE message: # ./filetop -h usage: filetop.py [-h] [-a] [-C] [-r MAXROWS] [-p PID] [interval] [count] File reads and writes by process positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -a, --all-files include non-regular file types (sockets, FIFOs, etc) -C, --noclear don't clear the screen -r MAXROWS, --maxrows MAXROWS maximum rows to print, default 20 -p PID, --pid PID trace this PID only examples: ./filetop # file I/O top, 1 second refresh ./filetop -C # don't clear the screen ./filetop -p 181 # PID 181 only ./filetop 5 # 5 second summaries ./filetop 5 10 # 5 second summaries, 10 times only bpfcc-0.2.0+git0.02884a026/tools/funccount.py000077500000000000000000000272431305314114400202270ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # funccount Count functions, tracepoints, and USDT probes. # For Linux, uses BCC, eBPF. # # USAGE: funccount [-h] [-p PID] [-i INTERVAL] [-T] [-r] pattern # # The pattern is a string with optional '*' wildcards, similar to file # globbing. If you'd prefer to use regular expressions, use the -r option. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 09-Sep-2015 Brendan Gregg Created this. # 18-Oct-2016 Sasha Goldshtein Generalized for uprobes, tracepoints, USDT. from __future__ import print_function from bcc import BPF, USDT from time import sleep, strftime import argparse import os import re import signal import sys import traceback debug = False def verify_limit(num): probe_limit = 1000 if num > probe_limit: raise Exception("maximum of %d probes allowed, attempted %d" % (probe_limit, num)) class Probe(object): def __init__(self, pattern, use_regex=False, pid=None): """Init a new probe. Init the probe from the pattern provided by the user. The supported patterns mimic the 'trace' and 'argdist' tools, but are simpler because we don't have to distinguish between probes and retprobes. func -- probe a kernel function lib:func -- probe a user-space function in the library 'lib' /path:func -- probe a user-space function in binary '/path' p::func -- same thing as 'func' p:lib:func -- same thing as 'lib:func' t:cat:event -- probe a kernel tracepoint u:lib:probe -- probe a USDT tracepoint """ parts = pattern.split(':') if len(parts) == 1: parts = ["p", "", parts[0]] elif len(parts) == 2: parts = ["p", parts[0], parts[1]] elif len(parts) == 3: if parts[0] == "t": parts = ["t", "", "%s:%s" % tuple(parts[1:])] if parts[0] not in ["p", "t", "u"]: raise Exception("Type must be 'p', 't', or 'u', but got %s" % parts[0]) else: raise Exception("Too many ':'-separated components in pattern %s" % pattern) (self.type, self.library, self.pattern) = parts if not use_regex: self.pattern = self.pattern.replace('*', '.*') self.pattern = '^' + self.pattern + '$' if (self.type == "p" and self.library) or self.type == "u": libpath = BPF.find_library(self.library) if libpath is None: # This might be an executable (e.g. 'bash') libpath = BPF.find_exe(self.library) if libpath is None or len(libpath) == 0: raise Exception("unable to find library %s" % self.library) self.library = libpath self.pid = pid self.matched = 0 self.trace_functions = {} # map location number to function name def is_kernel_probe(self): return self.type == "t" or (self.type == "p" and self.library == "") def attach(self): if self.type == "p" and not self.library: for index, function in self.trace_functions.items(): self.bpf.attach_kprobe( event=function, fn_name="trace_count_%d" % index, pid=self.pid or -1) elif self.type == "p" and self.library: for index, function in self.trace_functions.items(): self.bpf.attach_uprobe( name=self.library, sym=function, fn_name="trace_count_%d" % index, pid=self.pid or -1) elif self.type == "t": for index, function in self.trace_functions.items(): self.bpf.attach_tracepoint( tp=function, fn_name="trace_count_%d" % index, pid=self.pid or -1) elif self.type == "u": pass # Nothing to do -- attach already happened in `load` def _add_function(self, template, probe_name): new_func = "trace_count_%d" % self.matched text = template.replace("PROBE_FUNCTION", new_func) text = text.replace("LOCATION", str(self.matched)) self.trace_functions[self.matched] = probe_name self.matched += 1 return text def _generate_functions(self, template): self.usdt = None text = "" if self.type == "p" and not self.library: functions = BPF.get_kprobe_functions(self.pattern) verify_limit(len(functions)) for function in functions: text += self._add_function(template, function) elif self.type == "p" and self.library: # uprobes are tricky because the same function may have multiple # addresses, and the same address may be mapped to multiple # functions. We aren't allowed to create more than one uprobe # per address, so track unique addresses and ignore functions that # map to an address that we've already seen. Also ignore functions # that may repeat multiple times with different addresses. addresses, functions = (set(), set()) functions_and_addresses = BPF.get_user_functions_and_addresses( self.library, self.pattern) verify_limit(len(functions_and_addresses)) for function, address in functions_and_addresses: if address in addresses or function in functions: continue addresses.add(address) functions.add(function) text += self._add_function(template, function) elif self.type == "t": tracepoints = BPF.get_tracepoints(self.pattern) verify_limit(len(tracepoints)) for tracepoint in tracepoints: text += self._add_function(template, tracepoint) elif self.type == "u": self.usdt = USDT(path=self.library, pid=self.pid) matches = [] for probe in self.usdt.enumerate_probes(): if not self.pid and (probe.bin_path != self.library): continue if re.match(self.pattern, probe.name): matches.append(probe.name) verify_limit(len(matches)) for match in matches: new_func = "trace_count_%d" % self.matched text += self._add_function(template, match) self.usdt.enable_probe(match, new_func) if debug: print(self.usdt.get_text()) return text def load(self): trace_count_text = """ int PROBE_FUNCTION(void *ctx) { FILTER int loc = LOCATION; u64 *val = counts.lookup(&loc); if (!val) { return 0; // Should never happen, # of locations is known } (*val)++; return 0; } """ bpf_text = """#include BPF_TABLE("array", int, u64, counts, NUMLOCATIONS); """ # We really mean the tgid from the kernel's perspective, which is in # the top 32 bits of bpf_get_current_pid_tgid(). if self.pid: trace_count_text = trace_count_text.replace('FILTER', """u32 pid = bpf_get_current_pid_tgid() >> 32; if (pid != %d) { return 0; }""" % self.pid) else: trace_count_text = trace_count_text.replace('FILTER', '') bpf_text += self._generate_functions(trace_count_text) bpf_text = bpf_text.replace("NUMLOCATIONS", str(len(self.trace_functions))) if debug: print(bpf_text) if self.matched == 0: raise Exception("No functions matched by pattern %s" % self.pattern) self.bpf = BPF(text=bpf_text, usdt_contexts=[self.usdt] if self.usdt else []) self.clear() # Initialize all array items to zero def counts(self): return self.bpf["counts"] def clear(self): counts = self.bpf["counts"] for location, _ in list(self.trace_functions.items()): counts[counts.Key(location)] = counts.Leaf() class Tool(object): def __init__(self): examples = """examples: ./funccount 'vfs_*' # count kernel fns starting with "vfs" ./funccount -r '^vfs.*' # same as above, using regular expressions ./funccount -Ti 5 'vfs_*' # output every 5 seconds, with timestamps ./funccount -p 185 'vfs_*' # count vfs calls for PID 181 only ./funccount t:sched:sched_fork # count calls to the sched_fork tracepoint ./funccount -p 185 u:node:gc* # count all GC USDT probes in node, PID 185 ./funccount c:malloc # count all malloc() calls in libc ./funccount go:os.* # count all "os.*" calls in libgo ./funccount -p 185 go:os.* # count all "os.*" calls in libgo, PID 185 ./funccount ./test:read* # count "read*" calls in the ./test binary """ parser = argparse.ArgumentParser( description="Count functions, tracepoints, and USDT probes", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", type=int, help="trace this PID only") parser.add_argument("-i", "--interval", default=99999999, help="summary interval, seconds") parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-r", "--regexp", action="store_true", help="use regular expressions. Default is \"*\" wildcards only.") parser.add_argument("-d", "--debug", action="store_true", help="print BPF program before starting (for debugging purposes)") parser.add_argument("pattern", help="search expression for events") self.args = parser.parse_args() global debug debug = self.args.debug self.probe = Probe(self.args.pattern, self.args.regexp, self.args.pid) @staticmethod def _signal_ignore(signal, frame): print() def run(self): self.probe.load() self.probe.attach() print("Tracing %d functions for \"%s\"... Hit Ctrl-C to end." % (self.probe.matched, self.args.pattern)) exiting = 0 if self.args.interval else 1 while True: try: sleep(int(self.args.interval)) except KeyboardInterrupt: exiting = 1 # as cleanup can take many seconds, trap Ctrl-C: signal.signal(signal.SIGINT, Tool._signal_ignore) print() if self.args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") print("%-36s %8s" % ("FUNC", "COUNT")) counts = self.probe.counts() for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): if v.value == 0: continue print("%-36s %8d" % (self.probe.trace_functions[k.value], v.value)) if exiting: print("Detaching...") exit() else: self.probe.clear() if __name__ == "__main__": try: Tool().run() except Exception: if debug: traceback.print_exc() elif sys.exc_info()[0] is not SystemExit: print(sys.exc_info()[1]) bpfcc-0.2.0+git0.02884a026/tools/funccount_example.txt000066400000000000000000000255341305314114400221270ustar00rootroot00000000000000Demonstrations of funccount, the Linux eBPF/bcc version. This program traces functions, tracepoints, or USDT probes that match a specified pattern, and when Ctrl-C is hit prints a summary of their count while tracing. Eg, tracing all kernel functions that begin with "vfs_": # ./funccount 'vfs_*' Tracing... Ctrl-C to end. ^C FUNC COUNT vfs_create 1 vfs_rename 1 vfs_fsync_range 2 vfs_lock_file 30 vfs_fstatat 152 vfs_fstat 154 vfs_write 166 vfs_getattr_nosec 262 vfs_getattr 262 vfs_open 264 vfs_read 470 Detaching... The above output shows that while tracing the vfs_read() function was called 470 times, and vfs_open() 264 times, etc. This is useful for exploring kernel code, to figure out which functions are in use and which are not. This can narrow down an investigation to just a few functions, whose counts are similar to the workload investigated. Tracing all tcp functions: # ./funccount 'tcp_*' Tracing... Ctrl-C to end. ^C FUNC COUNT tcp_try_undo_recovery 1 tcp_twsk_destructor 1 tcp_enter_recovery 1 tcp_xmit_retransmit_queue 1 tcp_update_scoreboard 1 tcp_verify_retransmit_hint 1 tcp_tsq_handler.part.31 1 tcp_sacktag_write_queue 1 tcp_match_skb_to_sack 1 tcp_time_wait 1 tcp_mark_head_lost 1 tcp_init_cwnd_reduction 1 tcp_sacktag_one 1 tcp_sacktag_walk 1 tcp_retransmit_skb 1 tcp_tasklet_func 1 tcp_resume_early_retransmit 1 tcp_dsack_set 1 tcp_v4_syn_recv_sock 2 tcp_ca_openreq_child 2 tcp_try_fastopen 2 tcp_openreq_init_rwin 2 tcp_v4_init_req 2 tcp_create_openreq_child 2 tcp_v4_send_synack 2 tcp_v4_init_sequence 2 tcp_fragment 2 tcp_v4_conn_request 2 tcp_conn_request 2 tcp_v4_route_req 2 tcp_fragment_tstamp 2 tcp_try_keep_open 2 tcp_v4_reqsk_destructor 2 tcp_may_send_now 2 tcp_make_synack 2 tcp_child_process 2 tcp_check_req 2 tcp_fastretrans_alert 2 tcp_set_keepalive 2 tcp_finish_connect 3 tcp_connect_queue_skb 3 tcp_v4_connect 3 tcp_init_sock 3 tcp_v4_init_sock 3 tcp_connect 3 tcp_any_retrans_done.part.35 3 tcp_clear_retrans 3 tcp_setsockopt 4 tcp_update_metrics 5 tcp_done 5 tcp_initialize_rcv_mss 5 tcp_sndbuf_expand 5 tcp_fin 5 tcp_init_xmit_timers 5 tcp_close 5 tcp_init_congestion_control 5 tcp_init_metrics 5 tcp_gro_complete 5 tcp_free_fastopen_req 5 tcp_v4_destroy_sock 5 tcp_cleanup_congestion_control 5 tcp_send_fin 5 tcp_init_buffer_space 5 tcp_init_cwnd 5 tcp_select_initial_window 5 tcp_check_oom 5 tcp_default_init_rwnd 5 tcp_assign_congestion_control 5 tcp_getsockopt 6 tcp_ioctl 6 tcp_mtup_init 8 tcp_parse_options 8 tcp_mss_to_mtu 8 tcp_try_rmem_schedule 8 tcp_get_metrics 10 tcp_try_coalesce 10 tcp_rcv_state_process 14 tcp_sync_mss 14 tcp_write_timer_handler 15 tcp_write_timer 16 tcp_grow_window.isra.27 22 tcp_set_state 23 tcp_send_ack 37 tcp_delack_timer 42 tcp_delack_timer_handler 42 tcp_validate_incoming 91 tcp_prequeue_process 112 tcp_v4_early_demux 117 tcp_gro_receive 146 tcp_queue_rcv 167 tcp_data_queue 215 tcp_urg 219 tcp_send_delayed_ack 257 tcp_send_mss 275 tcp_push 275 tcp_sendmsg 275 tcp_event_data_recv 275 tcp_nagle_check 279 tcp_write_xmit 282 tcp_event_new_data_sent 282 tcp_current_mss 284 tcp_init_tso_segs 284 tcp_wfree 286 tcp_schedule_loss_probe 305 tcp_v4_send_check 323 tcp_transmit_skb 323 tcp_recvmsg 323 tcp_options_write 325 tcp_rcv_space_adjust 328 tcp_check_space 332 tcp_rcv_established 337 tcp_ack 337 tcp_parse_aligned_timestamp.part.43 345 tcp_prequeue 346 tcp_v4_do_rcv 351 tcp_v4_rcv 351 tcp_parse_md5sig_option 351 tcp_cleanup_rbuf 436 tcp_poll 468 tcp_established_options 604 tcp_v4_md5_lookup 615 tcp_release_cb 736 tcp_rearm_rto 843 tcp_md5_do_lookup 968 Detaching... The current implementation can take many seconds to detach from tracing, after Ctrl-C has been hit. User functions can be traced in executables or libraries, and per-process filtering is allowed: # ./funccount -p 1442 /home/ubuntu/contentions:* Tracing 15 functions for "/home/ubuntu/contentions:*"... Hit Ctrl-C to end. ^C FUNC COUNT main 1 _start 1 primes_thread 2 insert_result 87186 is_prime 1252772 Detaching... If /home/ubuntu is in the $PATH, then the following command will also work: # ./funccount -p 1442 contentions:* Counting libc write and read calls using regular expression syntax (-r): # ./funccount -r 'c:(write|read)$' Tracing 2 functions for "c:(write|read)$"... Hit Ctrl-C to end. ^C FUNC COUNT read 2 write 4 Detaching... Kernel tracepoints are also available as targets. For example, trace common block I/O tracepoints and see how often they are invoked: # ./funccount t:block:* Tracing 19 functions for "t:block:*"... Hit Ctrl-C to end. ^C FUNC COUNT block:block_rq_complete 7 block:block_rq_issue 7 block:block_getrq 7 block:block_rq_insert 7 Detaching... Likewise, user-mode statically defined traces (USDT) can also be probed. For example, count mutex-related events in pthreads: # ./funccount u:pthread:*mutex* -p 1442 Tracing 7 functions for "u:pthread:*mutex*"... Hit Ctrl-C to end. ^C FUNC COUNT mutex_init 1 mutex_entry 547122 mutex_acquired 547175 mutex_release 547185 Detaching... An interval can be provided. Eg, printing output every 1 second for vfs calls: # ./funccount -i 1 'vfs_*' Tracing... Ctrl-C to end. FUNC COUNT vfs_fstatat 1 vfs_fstat 16 vfs_getattr_nosec 17 vfs_getattr 17 vfs_write 52 vfs_read 79 vfs_open 98 FUNC COUNT vfs_fstatat 10 vfs_fstat 10 vfs_open 13 vfs_getattr_nosec 20 vfs_getattr 20 vfs_write 28 vfs_read 39 FUNC COUNT vfs_fsync_range 2 vfs_lock_file 30 vfs_write 107 vfs_fstatat 129 vfs_fstat 130 vfs_open 154 vfs_getattr_nosec 222 vfs_getattr 222 vfs_read 384 ^C Detaching... This can be useful for making some ad hoc tools, exposing new counts of kernel activity that aren't visible in other metrics. Include -T to print timestamps on output. The "*" wildcard can be used multiple times. Eg, matching functions that contain the word "readdir": # ./funccount '*readdir*' Tracing... Ctrl-C to end. ^C FUNC COUNT ext4_readdir 4 Detaching... Matching "tcp" then "send": # ./funccount '*tcp*send*' Tracing... Ctrl-C to end. ^C FUNC COUNT tcp_send_ack 4 tcp_send_delayed_ack 19 tcp_send_mss 26 tcp_sendmsg 26 tcp_v4_send_check 30 __tcp_v4_send_check 30 Detaching... Full USAGE: # ./funccount -h usage: funccount.py [-h] [-p PID] [-i INTERVAL] [-T] [-r] [-d] pattern Count functions, tracepoints, and USDT probes positional arguments: pattern search expression for events optional arguments: -h, --help show this help message and exit -p PID, --pid PID trace this PID only -i INTERVAL, --interval INTERVAL summary interval, seconds -T, --timestamp include timestamp on output -r, --regexp use regular expressions. Default is "*" wildcards only. -d, --debug print BPF program before starting (for debugging purposes) examples: ./funccount 'vfs_*' # count kernel fns starting with "vfs" ./funccount -r '^vfs.*' # same as above, using regular expressions ./funccount -Ti 5 'vfs_*' # output every 5 seconds, with timestamps ./funccount -p 185 'vfs_*' # count vfs calls for PID 181 only ./funccount t:sched:sched_fork # count calls to the sched_fork tracepoint ./funccount -p 185 u:node:gc* # count all GC USDT probes in node, PID 185 ./funccount c:malloc # count all malloc() calls in libc ./funccount go:os.* # count all "os.*" calls in libgo ./funccount -p 185 go:os.* # count all "os.*" calls in libgo, PID 185 ./funccount ./test:read* # count "read*" calls in the ./test binary bpfcc-0.2.0+git0.02884a026/tools/funclatency.py000077500000000000000000000164401305314114400205330ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # funclatency Time functions and print latency as a histogram. # For Linux, uses BCC, eBPF. # # USAGE: funclatency [-h] [-p PID] [-i INTERVAL] [-T] [-u] [-m] [-F] [-r] [-v] # pattern # # Run "funclatency -h" for full usage. # # The pattern is a string with optional '*' wildcards, similar to file # globbing. If you'd prefer to use regular expressions, use the -r option. # # Currently nested or recursive functions are not supported properly, and # timestamps will be overwritten, creating dubious output. Try to match single # functions, or groups of functions that run at the same stack layer, and # don't ultimately call each other. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Sep-2015 Brendan Gregg Created this. # 06-Oct-2016 Sasha Goldshtein Added user function support. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse import signal # arguments examples = """examples: ./funclatency do_sys_open # time the do_sys_open() kernel function ./funclatency c:read # time the read() C library function ./funclatency -u vfs_read # time vfs_read(), in microseconds ./funclatency -m do_nanosleep # time do_nanosleep(), in milliseconds ./funclatency -mTi 5 vfs_read # output every 5 seconds, with timestamps ./funclatency -p 181 vfs_read # time process 181 only ./funclatency 'vfs_fstat*' # time both vfs_fstat() and vfs_fstatat() ./funclatency 'c:*printf' # time the *printf family of functions ./funclatency -F 'vfs_r*' # show one histogram per matched function """ parser = argparse.ArgumentParser( description="Time functions and print latency as a histogram", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("-i", "--interval", default=99999999, help="summary interval, seconds") parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-u", "--microseconds", action="store_true", help="microsecond histogram") parser.add_argument("-m", "--milliseconds", action="store_true", help="millisecond histogram") parser.add_argument("-F", "--function", action="store_true", help="show a separate histogram per function") parser.add_argument("-r", "--regexp", action="store_true", help="use regular expressions. Default is \"*\" wildcards only.") parser.add_argument("-v", "--verbose", action="store_true", help="print the BPF program (for debugging purposes)") parser.add_argument("pattern", help="search expression for functions") args = parser.parse_args() def bail(error): print("Error: " + error) exit(1) parts = args.pattern.split(':') if len(parts) == 1: library = None pattern = args.pattern elif len(parts) == 2: library = parts[0] libpath = BPF.find_library(library) or BPF.find_exe(library) if not libpath: bail("can't resolve library %s" % library) library = libpath pattern = parts[1] else: bail("unrecognized pattern format '%s'" % pattern) if not args.regexp: pattern = pattern.replace('*', '.*') pattern = '^' + pattern + '$' # define BPF program bpf_text = """ #include #include typedef struct ip_pid { u64 ip; u64 pid; } ip_pid_t; typedef struct hist_key { ip_pid_t key; u64 slot; } hist_key_t; BPF_HASH(start, u32); STORAGE int trace_func_entry(struct pt_regs *ctx) { u64 pid_tgid = bpf_get_current_pid_tgid(); u32 pid = pid_tgid; u32 tgid = pid_tgid >> 32; u64 ts = bpf_ktime_get_ns(); FILTER ENTRYSTORE start.update(&pid, &ts); return 0; } int trace_func_return(struct pt_regs *ctx) { u64 *tsp, delta; u64 pid_tgid = bpf_get_current_pid_tgid(); u32 pid = pid_tgid; u32 tgid = pid_tgid >> 32; // calculate delta time tsp = start.lookup(&pid); if (tsp == 0) { return 0; // missed start } delta = bpf_ktime_get_ns() - *tsp; start.delete(&pid); FACTOR // store as histogram STORE return 0; } """ # do we need to store the IP and pid for each invocation? need_key = args.function or (library and not args.pid) # code substitutions if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (tgid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if args.milliseconds: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000000;') label = "msecs" elif args.microseconds: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000;') label = "usecs" else: bpf_text = bpf_text.replace('FACTOR', '') label = "nsecs" if need_key: bpf_text = bpf_text.replace('STORAGE', 'BPF_HASH(ipaddr, u32);\n' + 'BPF_HISTOGRAM(dist, hist_key_t);') # stash the IP on entry, as on return it's kretprobe_trampoline: bpf_text = bpf_text.replace('ENTRYSTORE', 'u64 ip = PT_REGS_IP(ctx); ipaddr.update(&pid, &ip);') pid = '-1' if not library else 'tgid' bpf_text = bpf_text.replace('STORE', """ u64 ip, *ipp = ipaddr.lookup(&pid); if (ipp) { ip = *ipp; hist_key_t key; key.key.ip = ip; key.key.pid = %s; key.slot = bpf_log2l(delta); dist.increment(key); ipaddr.delete(&pid); } """ % pid) else: bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist);') bpf_text = bpf_text.replace('ENTRYSTORE', '') bpf_text = bpf_text.replace('STORE', 'dist.increment(bpf_log2l(delta));') if args.verbose: print(bpf_text) # signal handler def signal_ignore(signal, frame): print() # load BPF program b = BPF(text=bpf_text) # attach probes if not library: b.attach_kprobe(event_re=pattern, fn_name="trace_func_entry") b.attach_kretprobe(event_re=pattern, fn_name="trace_func_return") matched = b.num_open_kprobes() else: b.attach_uprobe(name=library, sym_re=pattern, fn_name="trace_func_entry", pid=args.pid or -1) b.attach_uretprobe(name=library, sym_re=pattern, fn_name="trace_func_return", pid=args.pid or -1) matched = b.num_open_uprobes() if matched == 0: print("0 functions matched by \"%s\". Exiting." % args.pattern) exit() # header print("Tracing %d functions for \"%s\"... Hit Ctrl-C to end." % (matched / 2, args.pattern)) # output def print_section(key): if not library: return BPF.sym(key[0], -1) else: return "%s [%d]" % (BPF.sym(key[0], key[1]), key[1]) exiting = 0 if args.interval else 1 dist = b.get_table("dist") while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 # as cleanup can take many seconds, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") if need_key: dist.print_log2_hist(label, "Function", section_print_fn=print_section, bucket_fn=lambda k: (k.ip, k.pid)) else: dist.print_log2_hist(label) dist.clear() if exiting: print("Detaching...") exit() bpfcc-0.2.0+git0.02884a026/tools/funclatency_example.txt000066400000000000000000000502651305314114400224350ustar00rootroot00000000000000Demonstrations of funclatency, the Linux eBPF/bcc version. Timing the do_sys_open() kernel function until Ctrl-C: # ./funclatency do_sys_open Tracing do_sys_open... Hit Ctrl-C to end. ^C nsecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 124 |**************** | 4096 -> 8191 : 291 |**************************************| 8192 -> 16383 : 36 |**** | 16384 -> 32767 : 16 |** | 32768 -> 65535 : 8 |* | 65536 -> 131071 : 0 | | 131072 -> 262143 : 0 | | 262144 -> 524287 : 0 | | 524288 -> 1048575 : 0 | | 1048576 -> 2097151 : 0 | | 2097152 -> 4194303 : 1 | | Detaching... The output shows a histogram of function latency (call time), measured from when the function began executing (was called) to when it finished (returned). This example output shows that most of the time, do_sys_open() took between 2048 and 65536 nanoseconds (2 to 65 microseconds). The peak of this distribution shows 291 calls of between 4096 and 8191 nanoseconds. There was also one occurrence, an outlier, in the 2 to 4 millisecond range. How this works: the function entry and return are traced using the kernel kprobe and kretprobe tracer. Timestamps are collected, the delta time calculated, which is the bucketized and stored as an in-kernel histogram for efficiency. The histogram is visible in the output: it's the "count" column; everything else is decoration. Only the count column is copied to user-level on output. This is an efficient way to time kernel functions and examine their latency distribution. Now trace a user function, pthread_mutex_lock in libpthread, to determine if there is considerable lock contention: # ./funclatency pthread:pthread_mutex_lock -p $(pidof contentions) Tracing 1 function for "pthread:pthread_mutex_lock"... Hit Ctrl-C to end. nsecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 508967 |****************************************| 4096 -> 8191 : 70072 |***** | 8192 -> 16383 : 27686 |** | 16384 -> 32767 : 5075 | | 32768 -> 65535 : 2318 | | 65536 -> 131071 : 581 | | 131072 -> 262143 : 38 | | 262144 -> 524287 : 5 | | 524288 -> 1048575 : 1 | | 1048576 -> 2097151 : 9 | | Detaching... It seems that most calls to pthread_mutex_lock completed rather quickly (in under 4us), but there were some cases of considerable contention, sometimes over a full millisecond. Run a quick-and-dirty profiler over all the functions in an executable: # ./funclatency /home/user/primes:* -p $(pidof primes) -F Tracing 15 functions for "/home/user/primes:*"... Hit Ctrl-C to end. ^C Function = is_prime [6556] nsecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 1495322 |****************************************| 4096 -> 8191 : 95744 |** | 8192 -> 16383 : 9926 | | 16384 -> 32767 : 3070 | | 32768 -> 65535 : 1415 | | 65536 -> 131071 : 112 | | 131072 -> 262143 : 9 | | 262144 -> 524287 : 3 | | 524288 -> 1048575 : 0 | | 1048576 -> 2097151 : 8 | | Function = insert_result [6556] nsecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 111047 |****************************************| 4096 -> 8191 : 3998 |* | 8192 -> 16383 : 720 | | 16384 -> 32767 : 238 | | 32768 -> 65535 : 106 | | 65536 -> 131071 : 5 | | 131072 -> 262143 : 4 | | Detaching... From the results, we can see that the is_prime function has something resembling an exponential distribution -- very few primes take a very long time to test, while most numbers are verified as prime or composite in less than 4us. The insert_result function exhibits a similar phenomenon, likely due to contention over a shared results container. Now vfs_read() is traced, and a microseconds histogram printed: # ./funclatency -u vfs_read Tracing vfs_read... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 1143 |**************************************| 2 -> 3 : 420 |************* | 4 -> 7 : 159 |***** | 8 -> 15 : 295 |********* | 16 -> 31 : 25 | | 32 -> 63 : 5 | | 64 -> 127 : 1 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 1 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 5 | | 8192 -> 16383 : 0 | | 16384 -> 32767 : 0 | | 32768 -> 65535 : 0 | | 65536 -> 131071 : 7 | | 131072 -> 262143 : 7 | | 262144 -> 524287 : 3 | | 524288 -> 1048575 : 7 | | Detaching... This shows a bimodal distribution. Many vfs_read() calls were faster than 15 microseconds, however, there was also a small handful between 65 milliseconds and 1 second, seen at the bottom of the table. These are likely network reads from SSH, waiting on interactive keystrokes. Tracing do_nanosleep() in milliseconds: # ./funclatency -m do_nanosleep Tracing do_nanosleep... Hit Ctrl-C to end. ^C msecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 328 |**************************************| 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 32 |*** | 8192 -> 16383 : 0 | | 16384 -> 32767 : 0 | | 32768 -> 65535 : 2 | | Detaching... This looks like it has found threads that are sleeping every 1, 5, and 60 seconds. An interval can be provided using -i, and timestamps added using -T. For example, tracing vfs_read() latency in milliseconds and printing output every 5 seconds: # ./funclatency -mTi 5 vfs_read Tracing vfs_read... Hit Ctrl-C to end. 20:10:08 msecs : count distribution 0 -> 1 : 1500 |*************************************+| 2 -> 3 : 3 | | 4 -> 7 : 1 | | 8 -> 15 : 2 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 4 | | 128 -> 255 : 3 | | 256 -> 511 : 1 | | 512 -> 1023 : 7 | | 20:10:13 msecs : count distribution 0 -> 1 : 1251 |*************************************+| 2 -> 3 : 3 | | 4 -> 7 : 2 | | 8 -> 15 : 0 | | 16 -> 31 : 2 | | 32 -> 63 : 3 | | 64 -> 127 : 5 | | 128 -> 255 : 5 | | 256 -> 511 : 3 | | 512 -> 1023 : 6 | | 1024 -> 2047 : 2 | | 20:10:18 msecs : count distribution 0 -> 1 : 1265 |*************************************+| 2 -> 3 : 0 | | 4 -> 7 : 5 | | 8 -> 15 : 9 | | 16 -> 31 : 7 | | 32 -> 63 : 1 | | 64 -> 127 : 2 | | 128 -> 255 : 3 | | 256 -> 511 : 5 | | 512 -> 1023 : 5 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 1 | | ^C 20:10:20 msecs : count distribution 0 -> 1 : 249 |*************************************+| 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 1 | | Detaching... A single process can be traced, which filters in-kernel for efficiency. Here, the vfs_read() function is timed as milliseconds for PID 17064, which is a bash shell: # ./funclatency -mp 17064 vfs_read Tracing vfs_read... Hit Ctrl-C to end. ^C msecs : count distribution 0 -> 1 : 1 |** | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |** | 16 -> 31 : 2 |***** | 32 -> 63 : 0 | | 64 -> 127 : 13 |**************************************| 128 -> 255 : 10 |***************************** | 256 -> 511 : 4 |*********** | Detaching... The distribution between 64 and 511 milliseconds shows keystroke latency. The -F option can be used to print a histogram per function. Eg: # ./funclatency -uF 'vfs_r*' Tracing 5 functions for "vfs_r*"... Hit Ctrl-C to end. ^C Function = vfs_read usecs : count distribution 0 -> 1 : 1044 |****************************************| 2 -> 3 : 383 |************** | 4 -> 7 : 76 |** | 8 -> 15 : 41 |* | 16 -> 31 : 26 | | 32 -> 63 : 0 | | 64 -> 127 : 1 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 4 | | 4096 -> 8191 : 2 | | 8192 -> 16383 : 0 | | 16384 -> 32767 : 0 | | 32768 -> 65535 : 2 | | 65536 -> 131071 : 5 | | 131072 -> 262143 : 5 | | 262144 -> 524287 : 3 | | 524288 -> 1048575 : 7 | | Function = vfs_rename usecs : count distribution 0 -> 1 : 2 |**** | 2 -> 3 : 2 |**** | 4 -> 7 : 2 |**** | 8 -> 15 : 0 | | 16 -> 31 : 6 |************* | 32 -> 63 : 18 |****************************************| Detaching... USAGE message: # ./funclatency -h usage: funclatency [-h] [-p PID] [-i INTERVAL] [-T] [-u] [-m] [-F] [-r] [-v] pattern Time functions and print latency as a histogram positional arguments: pattern search expression for functions optional arguments: -h, --help show this help message and exit -p PID, --pid PID trace this PID only -i INTERVAL, --interval INTERVAL summary interval, seconds -T, --timestamp include timestamp on output -u, --microseconds microsecond histogram -m, --milliseconds millisecond histogram -F, --function show a separate histogram per function -r, --regexp use regular expressions. Default is "*" wildcards only. -v, --verbose print the BPF program (for debugging purposes) examples: ./funclatency do_sys_open # time the do_sys_open() kernel function ./funclatency c:read # time the read() C library function ./funclatency -u vfs_read # time vfs_read(), in microseconds ./funclatency -m do_nanosleep # time do_nanosleep(), in milliseconds ./funclatency -mTi 5 vfs_read # output every 5 seconds, with timestamps ./funclatency -p 181 vfs_read # time process 181 only ./funclatency 'vfs_fstat*' # time both vfs_fstat() and vfs_fstatat() ./funclatency 'c:*printf' # time the *printf family of functions ./funclatency -F 'vfs_r*' # show one histogram per matched function bpfcc-0.2.0+git0.02884a026/tools/gethostlatency.py000077500000000000000000000073511305314114400212560ustar00rootroot00000000000000#!/usr/bin/python # # gethostlatency Show latency for getaddrinfo/gethostbyname[2] calls. # For Linux, uses BCC, eBPF. Embedded C. # # This can be useful for identifying DNS latency, by identifying which # remote host name lookups were slow, and by how much. # # This uses dynamic tracing of user-level functions and registers, and may # need modifications to match your software and processor architecture. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 28-Jan-2016 Brendan Gregg Created this. # 30-Mar-2016 Allan McAleavy updated for BPF_PERF_OUTPUT from __future__ import print_function from bcc import BPF from time import strftime import argparse import ctypes as ct examples = """examples: ./gethostlatency # trace all TCP accept()s ./gethostlatency -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Show latency for getaddrinfo/gethostbyname[2] calls", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", help="trace this PID only", type=int, default=-1) args = parser.parse_args() # load BPF program bpf_text = """ #include #include struct val_t { u32 pid; char comm[TASK_COMM_LEN]; char host[80]; u64 ts; }; struct data_t { u32 pid; u64 delta; char comm[TASK_COMM_LEN]; char host[80]; }; BPF_HASH(start, u32, struct val_t); BPF_PERF_OUTPUT(events); int do_entry(struct pt_regs *ctx) { if (!PT_REGS_PARM1(ctx)) return 0; struct val_t val = {}; u32 pid = bpf_get_current_pid_tgid(); if (bpf_get_current_comm(&val.comm, sizeof(val.comm)) == 0) { bpf_probe_read(&val.host, sizeof(val.host), (void *)PT_REGS_PARM1(ctx)); val.pid = bpf_get_current_pid_tgid(); val.ts = bpf_ktime_get_ns(); start.update(&pid, &val); } return 0; } int do_return(struct pt_regs *ctx) { struct val_t *valp; struct data_t data = {}; u64 delta; u32 pid = bpf_get_current_pid_tgid(); u64 tsp = bpf_ktime_get_ns(); valp = start.lookup(&pid); if (valp == 0) return 0; // missed start bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); bpf_probe_read(&data.host, sizeof(data.host), (void *)valp->host); data.pid = valp->pid; data.delta = tsp - valp->ts; events.perf_submit(ctx, &data, sizeof(data)); start.delete(&pid); return 0; } """ b = BPF(text=bpf_text) b.attach_uprobe(name="c", sym="getaddrinfo", fn_name="do_entry", pid=args.pid) b.attach_uprobe(name="c", sym="gethostbyname", fn_name="do_entry", pid=args.pid) b.attach_uprobe(name="c", sym="gethostbyname2", fn_name="do_entry", pid=args.pid) b.attach_uretprobe(name="c", sym="getaddrinfo", fn_name="do_return", pid=args.pid) b.attach_uretprobe(name="c", sym="gethostbyname", fn_name="do_return", pid=args.pid) b.attach_uretprobe(name="c", sym="gethostbyname2", fn_name="do_return", pid=args.pid) TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("delta", ct.c_ulonglong), ("comm", ct.c_char * TASK_COMM_LEN), ("host", ct.c_char * 80) ] # header print("%-9s %-6s %-16s %10s %s" % ("TIME", "PID", "COMM", "LATms", "HOST")) def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents print("%-9s %-6d %-16s %10.2f %s" % (strftime("%H:%M:%S"), event.pid, event.comm, (event.delta / 1000000), event.host)) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/gethostlatency_example.txt000066400000000000000000000024251305314114400231520ustar00rootroot00000000000000Demonstrations of gethostlatency, the Linux eBPF/bcc version. This traces host name lookup calls (getaddrinfo(), gethostbyname(), and gethostbyname2()), and shows the PID and command performing the lookup, the latency (duration) of the call in milliseconds, and the host string: # ./gethostlatency TIME PID COMM LATms HOST 06:10:24 28011 wget 90.00 www.iovisor.org 06:10:28 28127 wget 0.00 www.iovisor.org 06:10:41 28404 wget 9.00 www.netflix.com 06:10:48 28544 curl 35.00 www.netflix.com.au 06:11:10 29054 curl 31.00 www.plumgrid.com 06:11:16 29195 curl 3.00 www.facebook.com 06:11:25 29404 curl 72.00 foo 06:11:28 29475 curl 1.00 foo In this example, the first call to lookup "www.iovisor.org" took 90 ms, and the second took 0 ms (cached). The slowest call in this example was to "foo", which was an unsuccessful lookup. USAGE message: # ./gethostlatency -h usage: gethostlatency [-h] [-p PID] Show latency for getaddrinfo/gethostbyname[2] calls optional arguments: -h, --help show this help message and exit -p PID, --pid PID trace this PID only examples: ./gethostlatency # trace all TCP accept()s ./gethostlatency -p 181 # only trace PID 181 bpfcc-0.2.0+git0.02884a026/tools/hardirqs.py000077500000000000000000000110331305314114400200260ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # hardirqs Summarize hard IRQ (interrupt) event time. # For Linux, uses BCC, eBPF. # # USAGE: hardirqs [-h] [-T] [-Q] [-m] [-D] [interval] [count] # # Thanks Amer Ather for help understanding irq behavior. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 19-Oct-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse # arguments examples = """examples: ./hardirqs # sum hard irq event time ./hardirqs -d # show hard irq event time as histograms ./hardirqs 1 10 # print 1 second summaries, 10 times ./hardirqs -NT 1 # 1s summaries, nanoseconds, and timestamps """ parser = argparse.ArgumentParser( description="Summarize hard irq event time as histograms", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-N", "--nanoseconds", action="store_true", help="output in nanoseconds") parser.add_argument("-d", "--dist", action="store_true", help="show distributions as histograms") parser.add_argument("interval", nargs="?", default=99999999, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() countdown = int(args.count) if args.nanoseconds: factor = 1 label = "nsecs" else: factor = 1000 label = "usecs" debug = 0 # define BPF program bpf_text = """ #include #include #include #include typedef struct irq_key { char name[32]; u64 slot; } irq_key_t; BPF_HASH(start, u32); BPF_HASH(irqdesc, u32, struct irq_desc *); BPF_HISTOGRAM(dist, irq_key_t); // time IRQ int trace_start(struct pt_regs *ctx, struct irq_desc *desc) { u32 pid = bpf_get_current_pid_tgid(); u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); irqdesc.update(&pid, &desc); return 0; } int trace_completion(struct pt_regs *ctx) { u64 *tsp, delta; struct irq_desc **descp; u32 pid = bpf_get_current_pid_tgid(); // fetch timestamp and calculate delta tsp = start.lookup(&pid); descp = irqdesc.lookup(&pid); if (tsp == 0 || descp == 0) { return 0; // missed start } // Note: descp is a value from map, so '&' can be done without // probe_read, but the next level irqaction * needs a probe read. // Do these steps first after reading the map, otherwise some of these // pointers may get pushed onto the stack and verifier will fail. struct irqaction *action = 0; bpf_probe_read(&action, sizeof(action), &(*descp)->action); const char **namep = &action->name; char *name = 0; bpf_probe_read(&name, sizeof(name), namep); delta = bpf_ktime_get_ns() - *tsp; // store as sum or histogram STORE start.delete(&pid); irqdesc.delete(&pid); return 0; } """ # code substitutions if args.dist: bpf_text = bpf_text.replace('STORE', 'irq_key_t key = {.slot = bpf_log2l(delta)};' + 'bpf_probe_read(&key.name, sizeof(key.name), name);' + 'dist.increment(key);') else: bpf_text = bpf_text.replace('STORE', 'irq_key_t key = {.slot = 0 /* ignore */};' + 'bpf_probe_read(&key.name, sizeof(key.name), name);' + 'u64 zero = 0, *vp = dist.lookup_or_init(&key, &zero);' + '(*vp) += delta;') if debug: print(bpf_text) # load BPF program b = BPF(text=bpf_text) # these should really use irq:irq_handler_entry/exit tracepoints: b.attach_kprobe(event="handle_irq_event_percpu", fn_name="trace_start") b.attach_kretprobe(event="handle_irq_event_percpu", fn_name="trace_completion") print("Tracing hard irq event time... Hit Ctrl-C to end.") # output exiting = 0 if args.interval else 1 dist = b.get_table("dist") while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") if args.dist: dist.print_log2_hist(label, "hardirq") else: print("%-26s %11s" % ("HARDIRQ", "TOTAL_" + label)) for k, v in sorted(dist.items(), key=lambda dist: dist[1].value): print("%-26s %11d" % (k.name, v.value / factor)) dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/hardirqs_example.txt000066400000000000000000001075401305314114400217360ustar00rootroot00000000000000Demonstrations of hardirqs, the Linux eBPF/bcc version. This program traces hard interrupts (irqs), and stores timing statistics in-kernel for efficiency. For example: # ./hardirqs Tracing hard irq event time... Hit Ctrl-C to end. ^C HARDIRQ TOTAL_usecs callfuncsingle0 2 callfuncsingle5 5 callfuncsingle6 5 callfuncsingle7 21 blkif 66 timer7 84 resched5 94 resched0 97 resched3 102 resched7 111 resched6 255 timer3 362 resched4 367 timer5 474 timer1 529 timer6 679 timer2 746 timer4 943 resched1 1048 timer0 1558 resched2 1750 eth0 11441 The HARDIRQ column prints the interrupt action name. While tracing, the eth0 hard irq action ran for 11441 microseconds (11 milliseconds) in total. Many other interrupts are visible in the output: this is an 8 CPU system, and some of these interrupts have a separate action per-CPU (eg, "timer", "resched"). An interval can be provided, and also optionally a count. Eg, printing output every 1 second, and including timestamps (-T): # ./hardirqs -T 1 3 Tracing hard irq event time... Hit Ctrl-C to end. 22:16:14 HARDIRQ TOTAL_usecs callfuncsingle0 2 callfuncsingle7 5 callfuncsingle3 5 callfuncsingle2 5 callfuncsingle6 6 callfuncsingle1 11 resched0 32 blkif 51 resched5 71 resched7 71 resched4 72 resched6 82 timer7 172 resched1 187 resched2 236 timer3 252 resched3 282 timer1 320 timer2 374 timer6 396 timer5 427 timer4 470 timer0 1430 eth0 7498 22:16:15 HARDIRQ TOTAL_usecs callfuncsingle7 6 callfuncsingle5 11 callfuncsingle4 13 timer2 17 callfuncsingle6 18 resched0 21 blkif 33 resched3 40 resched5 60 resched4 69 resched6 70 resched7 74 timer7 86 resched2 91 timer3 134 resched1 293 timer5 354 timer1 433 timer6 497 timer4 1112 timer0 1768 eth0 6972 22:16:16 HARDIRQ TOTAL_usecs callfuncsingle7 5 callfuncsingle3 5 callfuncsingle2 6 timer3 10 resched0 18 callfuncsingle4 22 resched5 27 resched6 44 blkif 45 resched7 65 resched4 69 timer4 77 resched2 97 timer7 98 resched3 103 timer2 169 resched1 226 timer5 525 timer1 691 timer6 697 timer0 1415 eth0 7152 This can be useful for quantifying where CPU cycles are spent among the hard interrupts (summarized as the %irq column from mpstat(1)). The output above shows that most time was spent processing for eth0 (network interface), which was around 7 milliseconds per second (total across all CPUs). Note that the time spent among the "timer" interrupts was low, and usually less than one microsecond per second. Here's the hardirq per-second output when the perf tool is performing a 999 Hertz CPU profile ("perf record -F 999 -a ..."): 22:13:59 HARDIRQ TOTAL_usecs callfuncsingle7 5 callfuncsingle5 5 callfuncsingle3 6 callfuncsingle4 7 callfuncsingle6 19 blkif 66 resched0 66 resched2 82 resched7 87 resched3 96 resched4 118 resched5 120 resched6 130 resched1 230 timer3 946 timer1 1981 timer7 2618 timer5 3063 timer6 3141 timer4 3511 timer2 3554 timer0 5044 eth0 16015 This sheds some light into the CPU overhead of the perf profiler, which cost around 3 milliseconds per second. Note that I'm usually profiling at a much lower rate, 99 Hertz, which looks like this: 22:22:12 HARDIRQ TOTAL_usecs callfuncsingle3 5 callfuncsingle6 5 callfuncsingle5 22 blkif 46 resched6 47 resched5 57 resched4 66 resched7 78 resched2 97 resched0 214 timer2 326 timer0 498 timer5 536 timer6 576 timer1 600 timer4 982 resched1 1315 timer7 1364 timer3 1825 resched3 5708 eth0 9743 Much lower (and remember to compare this to the baseline). Note that perf has other overheads (non-irq CPU cycles, file system storage). The distribution of interrupt run time can be printed as a histogram with the -d option. Eg: # ./hardirqs -d Tracing hard irq event time... Hit Ctrl-C to end. ^C hardirq = 'callfuncsingle1' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 0 | | 8192 -> 16383 : 1 |****************************************| hardirq = 'callfuncsingle0' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 1 |****************************************| hardirq = 'callfuncsingle3' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 3 |****************************************| hardirq = 'callfuncsingle2' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 2 |****************************************| hardirq = 'callfuncsingle5' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 5 |****************************************| hardirq = 'callfuncsingle4' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 6 |****************************************| hardirq = 'callfuncsingle7' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 4 |****************************************| hardirq = 'callfuncsingle6' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 4 |****************************************| hardirq = 'eth0' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 5102 |********* | 1024 -> 2047 : 20617 |****************************************| 2048 -> 4095 : 4832 |********* | 4096 -> 8191 : 12 | | hardirq = 'timer7' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 9 |*** | 2048 -> 4095 : 70 |***************************** | 4096 -> 8191 : 94 |****************************************| hardirq = 'timer6' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 1 | | 2048 -> 4095 : 86 |*********** | 4096 -> 8191 : 295 |****************************************| 8192 -> 16383 : 28 |*** | hardirq = 'timer5' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 1 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 137 |****************************************| 4096 -> 8191 : 123 |*********************************** | 8192 -> 16383 : 8 |** | hardirq = 'timer4' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 46 |********* | 4096 -> 8191 : 198 |****************************************| 8192 -> 16383 : 49 |********* | hardirq = 'timer3' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 4 | | 2048 -> 4095 : 210 |****************************************| 4096 -> 8191 : 186 |*********************************** | hardirq = 'timer2' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 245 |****************************************| 4096 -> 8191 : 227 |************************************* | 8192 -> 16383 : 6 | | hardirq = 'timer1' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 6 |* | 2048 -> 4095 : 112 |************************ | 4096 -> 8191 : 181 |****************************************| 8192 -> 16383 : 7 |* | hardirq = 'timer0' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 887 |****************************************| 8192 -> 16383 : 92 |**** | hardirq = 'blkif' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 9 |****************************************| 8192 -> 16383 : 7 |******************************* | 16384 -> 32767 : 2 |******** | hardirq = 'resched4' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 104 |****************************************| 2048 -> 4095 : 80 |****************************** | hardirq = 'resched5' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 27 |***** | 1024 -> 2047 : 216 |****************************************| 2048 -> 4095 : 27 |***** | 4096 -> 8191 : 1 | | hardirq = 'resched6' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 480 |******************* | 1024 -> 2047 : 1003 |****************************************| 2048 -> 4095 : 64 |** | hardirq = 'resched7' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 46 |********* | 1024 -> 2047 : 190 |****************************************| 2048 -> 4095 : 42 |******** | hardirq = 'resched0' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 11 |**** | 1024 -> 2047 : 100 |****************************************| 2048 -> 4095 : 23 |********* | hardirq = 'resched1' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 96 |******** | 1024 -> 2047 : 462 |****************************************| 2048 -> 4095 : 36 |*** | hardirq = 'resched2' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 120 |************************** | 1024 -> 2047 : 183 |****************************************| 2048 -> 4095 : 41 |******** | hardirq = 'resched3' usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 789 |****************************************| 2048 -> 4095 : 39 |* | USAGE message: # ./hardirqs -h usage: hardirqs [-h] [-T] [-N] [-d] [interval] [count] Summarize hard irq event time as histograms positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -T, --timestamp include timestamp on output -N, --nanoseconds output in nanoseconds -d, --dist show distributions as histograms examples: ./hardirqs # sum hard irq event time ./hardirqs -d # show hard irq event time as histograms ./hardirqs 1 10 # print 1 second summaries, 10 times ./hardirqs -NT 1 # 1s summaries, nanoseconds, and timestamps bpfcc-0.2.0+git0.02884a026/tools/killsnoop.py000077500000000000000000000063241305314114400202320ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # killsnoop Trace signals issued by the kill() syscall. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: killsnoop [-h] [-x] [-p PID] # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Sep-2015 Brendan Gregg Created this. # 19-Feb-2016 Allan McAleavy migrated to BPF_PERF_OUTPUT from __future__ import print_function from bcc import BPF import argparse from time import strftime import ctypes as ct # arguments examples = """examples: ./killsnoop # trace all kill() signals ./killsnoop -x # only show failed kills ./killsnoop -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace signals issued by the kill() syscall", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-x", "--failed", action="store_true", help="only show failed kill syscalls") parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include #include struct val_t { u64 pid; int sig; int tpid; char comm[TASK_COMM_LEN]; }; struct data_t { u64 pid; int tpid; int sig; int ret; char comm[TASK_COMM_LEN]; }; BPF_HASH(infotmp, u32, struct val_t); BPF_PERF_OUTPUT(events); int kprobe__sys_kill(struct pt_regs *ctx, int tpid, int sig) { u32 pid = bpf_get_current_pid_tgid(); FILTER struct val_t val = {.pid = pid}; if (bpf_get_current_comm(&val.comm, sizeof(val.comm)) == 0) { val.tpid = tpid; val.sig = sig; infotmp.update(&pid, &val); } return 0; }; int kretprobe__sys_kill(struct pt_regs *ctx) { struct data_t data = {}; struct val_t *valp; u32 pid = bpf_get_current_pid_tgid(); valp = infotmp.lookup(&pid); if (valp == 0) { // missed entry return 0; } bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); data.pid = pid; data.tpid = valp->tpid; data.ret = PT_REGS_RC(ctx); data.sig = valp->sig; events.perf_submit(ctx, &data, sizeof(data)); infotmp.delete(&pid); return 0; } """ if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("tpid", ct.c_int), ("sig", ct.c_int), ("ret", ct.c_int), ("comm", ct.c_char * TASK_COMM_LEN) ] # header print("%-9s %-6s %-16s %-4s %-6s %s" % ( "TIME", "PID", "COMM", "SIG", "TPID", "RESULT")) # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents if (args.failed and (event.ret >= 0)): return print("%-9s %-6d %-16s %-4d %-6d %d" % (strftime("%H:%M:%S"), event.pid, event.comm, event.sig, event.tpid, event.ret)) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/killsnoop_example.txt000066400000000000000000000017421305314114400221300ustar00rootroot00000000000000Demonstrations of killsnoop, the Linux eBPF/bcc version. This traces signals sent via the kill() syscall. For example: # ./killsnoop TIME PID COMM SIG TPID RESULT 12:10:51 13967 bash 9 13885 0 12:11:34 13967 bash 9 1024 -3 12:11:41 815 systemd-udevd 15 14076 0 The first line showed a SIGKILL (9) sent from PID 13967 (a bash shell) to PID 13885. The result, 0, means success. The second line showed the same signal sent, this time resulting in a -3 (ESRCH: no such process). USAGE message: # ./killsnoop -h usage: killsnoop [-h] [-x] [-p PID] Trace signals issued by the kill() syscall optional arguments: -h, --help show this help message and exit -x, --failed only show failed kill syscalls -p PID, --pid PID trace this PID only examples: ./killsnoop # trace all kill() signals ./killsnoop -x # only show failed kills ./killsnoop -p 181 # only trace PID 181 bpfcc-0.2.0+git0.02884a026/tools/llcstat.py000077500000000000000000000065431305314114400176710ustar00rootroot00000000000000#!/usr/bin/python # # llcstat.py Summarize cache references and cache misses by PID. # Cache reference and cache miss are corresponding events defined in # uapi/linux/perf_event.h, it varies to different architecture. # On x86-64, they mean LLC references and LLC misses. # # For Linux, uses BCC, eBPF. Embedded C. # # REQUIRES: Linux 4.9+ (BPF_PROG_TYPE_PERF_EVENT support). # # Copyright (c) 2016 Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 19-Oct-2016 Teng Qin Created this. from __future__ import print_function import argparse from bcc import BPF, PerfType, PerfHWConfig import signal from time import sleep parser = argparse.ArgumentParser( description="Summarize cache references and misses by PID", formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument( "-c", "--sample_period", type=int, default=100, help="Sample one in this many number of cache reference / miss events") parser.add_argument( "duration", nargs="?", default=10, help="Duration, in seconds, to run") args = parser.parse_args() # load BPF program b = BPF(text=""" #include #include struct key_t { int cpu; int pid; char name[TASK_COMM_LEN]; }; BPF_HASH(ref_count, struct key_t); BPF_HASH(miss_count, struct key_t); static inline __attribute__((always_inline)) void get_key(struct key_t* key) { key->cpu = bpf_get_smp_processor_id(); key->pid = bpf_get_current_pid_tgid(); bpf_get_current_comm(&(key->name), sizeof(key->name)); } int on_cache_miss(struct bpf_perf_event_data *ctx) { struct key_t key = {}; get_key(&key); u64 zero = 0, *val; val = miss_count.lookup_or_init(&key, &zero); (*val) += ctx->sample_period; return 0; } int on_cache_ref(struct bpf_perf_event_data *ctx) { struct key_t key = {}; get_key(&key); u64 zero = 0, *val; val = ref_count.lookup_or_init(&key, &zero); (*val) += ctx->sample_period; return 0; } """) b.attach_perf_event( ev_type=PerfType.HARDWARE, ev_config=PerfHWConfig.CACHE_MISSES, fn_name="on_cache_miss", sample_period=args.sample_period) b.attach_perf_event( ev_type=PerfType.HARDWARE, ev_config=PerfHWConfig.CACHE_REFERENCES, fn_name="on_cache_ref", sample_period=args.sample_period) print("Running for {} seconds or hit Ctrl-C to end.".format(args.duration)) try: sleep(float(args.duration)) except KeyboardInterrupt: signal.signal(signal.SIGINT, lambda signal, frame: print()) miss_count = {} for (k, v) in b.get_table('miss_count').items(): miss_count[(k.pid, k.cpu, k.name)] = v.value print('PID NAME CPU REFERENCE MISS HIT%') tot_ref = 0 tot_miss = 0 for (k, v) in b.get_table('ref_count').items(): try: miss = miss_count[(k.pid, k.cpu, k.name)] except KeyError: miss = 0 tot_ref += v.value tot_miss += miss # This happens on some PIDs due to missed counts caused by sampling hit = (v.value - miss) if (v.value >= miss) else 0 print('{:<8d} {:<16s} {:<4d} {:>12d} {:>12d} {:>6.2f}%'.format( k.pid, k.name.decode(), k.cpu, v.value, miss, (float(hit) / float(v.value)) * 100.0)) print('Total References: {} Total Misses: {} Hit Rate: {:.2f}%'.format( tot_ref, tot_miss, (float(tot_ref - tot_miss) / float(tot_ref)) * 100.0)) bpfcc-0.2.0+git0.02884a026/tools/llcstat_example.txt000066400000000000000000000044751305314114400215720ustar00rootroot00000000000000Demonstrations of llcstat. llcstat traces cache reference and cache miss events system-wide, and summarizes them by PID and CPU. These events, defined in uapi/linux/perf_event.h, have different meanings on different architecture. For x86-64, they mean misses and references to LLC. Example output: # ./llcstat.py 20 -c 5000 Running for 20 seconds or hit Ctrl-C to end. PID NAME CPU REFERENCE MISS HIT% 0 swapper/15 15 3515000 640000 81.79% 238 migration/38 38 5000 0 100.00% 4512 ntpd 11 5000 0 100.00% 150867 ipmitool 3 25000 5000 80.00% 150895 lscpu 17 280000 25000 91.07% 151807 ipmitool 15 15000 5000 66.67% 150757 awk 2 15000 5000 66.67% 151213 chef-client 5 1770000 240000 86.44% 151822 scribe-dispatch 12 15000 0 100.00% 123386 mysqld 5 5000 0 100.00% [...] Total References: 518920000 Total Misses: 90265000 Hit Rate: 82.61% This shows each PID's cache hit rate during the 20 seconds run period. A count of 5000 was used in this example, which means that one in every 5,000 events will trigger an in-kernel counter to be incremented. This is refactored on the output, which is why it is always in multiples of 5,000. We don't instrument every single event since the overhead would be prohibitive, nor do we need to: this is a type of sampling profiler. Because of this, the processes that trigger the 5,000'th cache reference or misses can happen to some degree by chance. Overall it should make sense. But for low counts, you might find a case where -- by chance -- a process has been tallied with more misses than references, which would seem impossible. USAGE message: # ./llcstat.py --help usage: llcstat.py [-h] [-c SAMPLE_PERIOD] [duration] Summarize cache references and misses by PID positional arguments: duration Duration, in seconds, to run optional arguments: -h, --help show this help message and exit -c SAMPLE_PERIOD, --sample_period SAMPLE_PERIOD Sample one in this many number of cache reference and miss events bpfcc-0.2.0+git0.02884a026/tools/mdflush.py000077500000000000000000000033371305314114400176630ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # mdflush Trace md flush events. # For Linux, uses BCC, eBPF. # # Todo: add more details of the flush (latency, I/O count). # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 13-Feb-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import strftime import ctypes as ct # load BPF program b = BPF(text=""" #include #include #include struct data_t { u64 pid; char comm[TASK_COMM_LEN]; char disk[DISK_NAME_LEN]; }; BPF_PERF_OUTPUT(events); int kprobe__md_flush_request(struct pt_regs *ctx, void *mddev, struct bio *bio) { struct data_t data = {}; u32 pid = bpf_get_current_pid_tgid(); data.pid = pid; bpf_get_current_comm(&data.comm, sizeof(data.comm)); bpf_probe_read(&data.disk, sizeof(data.disk), bio->bi_bdev->bd_disk->disk_name); events.perf_submit(ctx, &data, sizeof(data)); return 0; } """) # event data TASK_COMM_LEN = 16 # linux/sched.h DISK_NAME_LEN = 32 # linux/genhd.h class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("comm", ct.c_char * TASK_COMM_LEN), ("disk", ct.c_char * DISK_NAME_LEN) ] # header print("Tracing md flush requests... Hit Ctrl-C to end.") print("%-8s %-6s %-16s %s" % ("TIME", "PID", "COMM", "DEVICE")) # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents print("%-8s %-6d %-16s %s" % (strftime("%H:%M:%S"), event.pid, event.comm, event.disk)) # read events b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/mdflush_example.txt000066400000000000000000000033641305314114400215620ustar00rootroot00000000000000Demonstrations of mdflush, the Linux eBPF/bcc version. The mdflush tool traces flushes at the md driver level, and prints details including the time of the flush: # ./mdflush Tracing md flush requests... Hit Ctrl-C to end. TIME PID COMM DEVICE 03:13:49 16770 sync md0 03:14:08 16864 sync md0 03:14:49 496 kworker/1:0H md0 03:14:49 488 xfsaild/md0 md0 03:14:54 488 xfsaild/md0 md0 03:15:00 488 xfsaild/md0 md0 03:15:02 85 kswapd0 md0 03:15:02 488 xfsaild/md0 md0 03:15:05 488 xfsaild/md0 md0 03:15:08 488 xfsaild/md0 md0 03:15:10 488 xfsaild/md0 md0 03:15:11 488 xfsaild/md0 md0 03:15:11 488 xfsaild/md0 md0 03:15:11 488 xfsaild/md0 md0 03:15:11 488 xfsaild/md0 md0 03:15:11 488 xfsaild/md0 md0 03:15:12 488 xfsaild/md0 md0 03:15:13 488 xfsaild/md0 md0 03:15:15 488 xfsaild/md0 md0 03:15:19 496 kworker/1:0H md0 03:15:49 496 kworker/1:0H md0 03:15:55 18840 sync md0 03:16:49 496 kworker/1:0H md0 03:17:19 496 kworker/1:0H md0 03:20:19 496 kworker/1:0H md0 03:21:19 496 kworker/1:0H md0 03:21:49 496 kworker/1:0H md0 03:25:19 496 kworker/1:0H md0 [...] This can be useful for correlation with latency outliers or spikes in disk latency, as measured using another tool (eg, system monitoring). If spikes in disk latency often coincide with md flush events, then it would make flushing a target for tuning. Note that the flush events are likely to originate from higher in the I/O stack, such as from file systems. This traces md processing them, and the timestamp corresponds with when md began to issue the flush to disks. bpfcc-0.2.0+git0.02884a026/tools/memleak.py000077500000000000000000000230671305314114400176360ustar00rootroot00000000000000#!/usr/bin/env python # # memleak Trace and display outstanding allocations to detect # memory leaks in user-mode processes and the kernel. # # USAGE: memleak [-h] [-p PID] [-t] [-a] [-o OLDER] [-c COMMAND] # [-s SAMPLE_RATE] [-d STACK_DEPTH] [-T TOP] [-z MIN_SIZE] # [-Z MAX_SIZE] # [interval] [count] # # Licensed under the Apache License, Version 2.0 (the "License") # Copyright (C) 2016 Sasha Goldshtein. from bcc import BPF from time import sleep from datetime import datetime import argparse import subprocess import os class Allocation(object): def __init__(self, stack, size): self.stack = stack self.count = 1 self.size = size def update(self, size): self.count += 1 self.size += size def run_command_get_output(command): p = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT) return iter(p.stdout.readline, b'') def run_command_get_pid(command): p = subprocess.Popen(command.split()) return p.pid examples = """ EXAMPLES: ./memleak -p $(pidof allocs) Trace allocations and display a summary of "leaked" (outstanding) allocations every 5 seconds ./memleak -p $(pidof allocs) -t Trace allocations and display each individual call to malloc/free ./memleak -ap $(pidof allocs) 10 Trace allocations and display allocated addresses, sizes, and stacks every 10 seconds for outstanding allocations ./memleak -c "./allocs" Run the specified command and trace its allocations ./memleak Trace allocations in kernel mode and display a summary of outstanding allocations every 5 seconds ./memleak -o 60000 Trace allocations in kernel mode and display a summary of outstanding allocations that are at least one minute (60 seconds) old ./memleak -s 5 Trace roughly every 5th allocation, to reduce overhead """ description = """ Trace outstanding memory allocations that weren't freed. Supports both user-mode allocations made with malloc/free and kernel-mode allocations made with kmalloc/kfree. """ parser = argparse.ArgumentParser(description=description, formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", type=int, default=-1, help="the PID to trace; if not specified, trace kernel allocs") parser.add_argument("-t", "--trace", action="store_true", help="print trace messages for each alloc/free call") parser.add_argument("interval", nargs="?", default=5, type=int, help="interval in seconds to print outstanding allocations") parser.add_argument("count", nargs="?", type=int, help="number of times to print the report before exiting") parser.add_argument("-a", "--show-allocs", default=False, action="store_true", help="show allocation addresses and sizes as well as call stacks") parser.add_argument("-o", "--older", default=500, type=int, help="prune allocations younger than this age in milliseconds") parser.add_argument("-c", "--command", help="execute and trace the specified command") parser.add_argument("-s", "--sample-rate", default=1, type=int, help="sample every N-th allocation to decrease the overhead") parser.add_argument("-T", "--top", type=int, default=10, help="display only this many top allocating stacks (by size)") parser.add_argument("-z", "--min-size", type=int, help="capture only allocations larger than this size") parser.add_argument("-Z", "--max-size", type=int, help="capture only allocations smaller than this size") parser.add_argument("-O", "--obj", type=str, default="c", help="attach to malloc & free in the specified object") args = parser.parse_args() pid = args.pid command = args.command kernel_trace = (pid == -1 and command is None) trace_all = args.trace interval = args.interval min_age_ns = 1e6 * args.older sample_every_n = args.sample_rate num_prints = args.count top_stacks = args.top min_size = args.min_size max_size = args.max_size obj = args.obj if min_size is not None and max_size is not None and min_size > max_size: print("min_size (-z) can't be greater than max_size (-Z)") exit(1) if command is not None: print("Executing '%s' and tracing the resulting process." % command) pid = run_command_get_pid(command) bpf_source = """ #include struct alloc_info_t { u64 size; u64 timestamp_ns; int stack_id; }; BPF_HASH(sizes, u64); BPF_HASH(allocs, u64, struct alloc_info_t); BPF_STACK_TRACE(stack_traces, 1024) int alloc_enter(struct pt_regs *ctx, size_t size) { SIZE_FILTER if (SAMPLE_EVERY_N > 1) { u64 ts = bpf_ktime_get_ns(); if (ts % SAMPLE_EVERY_N != 0) return 0; } u64 pid = bpf_get_current_pid_tgid(); u64 size64 = size; sizes.update(&pid, &size64); if (SHOULD_PRINT) bpf_trace_printk("alloc entered, size = %u\\n", size); return 0; } int alloc_exit(struct pt_regs *ctx) { u64 address = PT_REGS_RC(ctx); u64 pid = bpf_get_current_pid_tgid(); u64* size64 = sizes.lookup(&pid); struct alloc_info_t info = {0}; if (size64 == 0) return 0; // missed alloc entry info.size = *size64; sizes.delete(&pid); info.timestamp_ns = bpf_ktime_get_ns(); info.stack_id = stack_traces.get_stackid(ctx, STACK_FLAGS); allocs.update(&address, &info); if (SHOULD_PRINT) { bpf_trace_printk("alloc exited, size = %lu, result = %lx\\n", info.size, address); } return 0; } int free_enter(struct pt_regs *ctx, void *address) { u64 addr = (u64)address; struct alloc_info_t *info = allocs.lookup(&addr); if (info == 0) return 0; allocs.delete(&addr); if (SHOULD_PRINT) { bpf_trace_printk("free entered, address = %lx, size = %lu\\n", address, info->size); } return 0; } """ bpf_source = bpf_source.replace("SHOULD_PRINT", "1" if trace_all else "0") bpf_source = bpf_source.replace("SAMPLE_EVERY_N", str(sample_every_n)) size_filter = "" if min_size is not None and max_size is not None: size_filter = "if (size < %d || size > %d) return 0;" % \ (min_size, max_size) elif min_size is not None: size_filter = "if (size < %d) return 0;" % min_size elif max_size is not None: size_filter = "if (size > %d) return 0;" % max_size bpf_source = bpf_source.replace("SIZE_FILTER", size_filter) stack_flags = "BPF_F_REUSE_STACKID" if not kernel_trace: stack_flags += "|BPF_F_USER_STACK" bpf_source = bpf_source.replace("STACK_FLAGS", stack_flags) bpf_program = BPF(text=bpf_source) if not kernel_trace: print("Attaching to malloc and free in pid %d, Ctrl+C to quit." % pid) bpf_program.attach_uprobe(name=obj, sym="malloc", fn_name="alloc_enter", pid=pid) bpf_program.attach_uretprobe(name=obj, sym="malloc", fn_name="alloc_exit", pid=pid) bpf_program.attach_uprobe(name=obj, sym="free", fn_name="free_enter", pid=pid) else: print("Attaching to kmalloc and kfree, Ctrl+C to quit.") bpf_program.attach_kprobe(event="__kmalloc", fn_name="alloc_enter") bpf_program.attach_kretprobe(event="__kmalloc", fn_name="alloc_exit") bpf_program.attach_kprobe(event="kfree", fn_name="free_enter") def print_outstanding(): print("[%s] Top %d stacks with outstanding allocations:" % (datetime.now().strftime("%H:%M:%S"), top_stacks)) alloc_info = {} allocs = bpf_program["allocs"] stack_traces = bpf_program["stack_traces"] for address, info in sorted(allocs.items(), key=lambda a: a[1].size): if BPF.monotonic_time() - min_age_ns < info.timestamp_ns: continue if info.stack_id < 0: continue if info.stack_id in alloc_info: alloc_info[info.stack_id].update(info.size) else: stack = list(stack_traces.walk(info.stack_id)) combined = [] for addr in stack: combined.append(bpf_program.sym(addr, pid, show_module=True, show_offset=True)) alloc_info[info.stack_id] = Allocation(combined, info.size) if args.show_allocs: print("\taddr = %x size = %s" % (address.value, info.size)) to_show = sorted(alloc_info.values(), key=lambda a: a.size)[-top_stacks:] for alloc in to_show: print("\t%d bytes in %d allocations from stack\n\t\t%s" % (alloc.size, alloc.count, "\n\t\t".join(alloc.stack))) count_so_far = 0 while True: if trace_all: print(bpf_program.trace_fields()) else: try: sleep(interval) except KeyboardInterrupt: exit() print_outstanding() count_so_far += 1 if num_prints is not None and count_so_far >= num_prints: exit() bpfcc-0.2.0+git0.02884a026/tools/memleak_example.txt000066400000000000000000000201631305314114400215270ustar00rootroot00000000000000Demonstrations of memleak. memleak traces and matches memory allocation and deallocation requests, and collects call stacks for each allocation. memleak can then print a summary of which call stacks performed allocations that weren't subsequently freed. For example: # ./memleak -p $(pidof allocs) Attaching to malloc and free in pid 5193, Ctrl+C to quit. [11:16:33] Top 2 stacks with outstanding allocations: 80 bytes in 5 allocations from stack main+0x6d [allocs] __libc_start_main+0xf0 [libc-2.21.so] [11:16:34] Top 2 stacks with outstanding allocations: 160 bytes in 10 allocations from stack main+0x6d [allocs] __libc_start_main+0xf0 [libc-2.21.so] Each entry printed is a set of allocations that originate from the same call stack, and that weren't freed yet. The number of bytes and number of allocs are followed by the call stack, top to bottom, of the allocation site. As time goes on, it becomes apparent that the main function in the allocs process is leaking memory, 16 bytes at a time. Fortunately, you don't have to inspect each allocation individually -- you get a nice summary of which stack is responsible for a large leak. Occasionally, you do want the individual allocation details. Perhaps the same stack is allocating various sizes and you want to confirm which sizes are prevalent. Use the -a switch: # ./memleak -p $(pidof allocs) -a Attaching to malloc and free in pid 5193, Ctrl+C to quit. [11:16:33] Top 2 stacks with outstanding allocations: addr = 948cd0 size = 16 addr = 948d10 size = 16 addr = 948d30 size = 16 addr = 948cf0 size = 16 64 bytes in 4 allocations from stack main+0x6d [allocs] __libc_start_main+0xf0 [libc-2.21.so] [11:16:34] Top 2 stacks with outstanding allocations: addr = 948d50 size = 16 addr = 948cd0 size = 16 addr = 948d10 size = 16 addr = 948d30 size = 16 addr = 948cf0 size = 16 addr = 948dd0 size = 16 addr = 948d90 size = 16 addr = 948db0 size = 16 addr = 948d70 size = 16 addr = 948df0 size = 16 160 bytes in 10 allocations from stack main+0x6d [allocs] __libc_start_main+0xf0 [libc-2.21.so] When using the -p switch, memleak traces the allocations of a particular process. Without this switch, kernel allocations (kmalloc) are traced instead. For example: # ./memleak Attaching to kmalloc and kfree, Ctrl+C to quit. ... 248 bytes in 4 allocations from stack bpf_prog_load [kernel] sys_bpf [kernel] 328 bytes in 1 allocations from stack perf_mmap [kernel] mmap_region [kernel] do_mmap [kernel] vm_mmap_pgoff [kernel] sys_mmap_pgoff [kernel] sys_mmap [kernel] 464 bytes in 1 allocations from stack traceprobe_command [kernel] traceprobe_probes_write [kernel] probes_write [kernel] __vfs_write [kernel] vfs_write [kernel] sys_write [kernel] entry_SYSCALL_64_fastpath [kernel] 8192 bytes in 1 allocations from stack alloc_and_copy_ftrace_hash.constprop.59 [kernel] ftrace_set_hash [kernel] ftrace_set_filter_ip [kernel] arm_kprobe [kernel] enable_kprobe [kernel] kprobe_register [kernel] perf_trace_init [kernel] perf_tp_event_init [kernel] Here you can see that arming the kprobe to which our eBPF program is attached consumed 8KB of memory. Loading the BPF program also consumed a couple hundred bytes (in bpf_prog_load). memleak stores each allocated block along with its size, timestamp, and the stack that allocated it. When the block is deleted, this information is freed to reduce the memory overhead. To avoid false positives, allocations younger than a certain age (500ms by default) are not printed. To change this threshold, use the -o switch. By default, memleak prints its output every 5 seconds. To change this interval, pass the interval as a positional parameter to memleak. You can also control the number of times the output will be printed before exiting. For example: # ./memleak 1 10 ... will print the outstanding allocation statistics every second, for ten times, and then exit. memleak may introduce considerable overhead if your application or kernel is allocating and freeing memory at a very high rate. In that case, you can control the overhead by sampling every N-th allocation. For example, to sample roughly 10% of the allocations and print the outstanding allocations every 5 seconds, 3 times before quitting: # ./memleak -p $(pidof allocs) -s 10 5 3 Attaching to malloc and free in pid 2614, Ctrl+C to quit. [11:16:33] Top 2 stacks with outstanding allocations: 16 bytes in 1 allocations from stack main+0x6d [allocs] __libc_start_main+0xf0 [libc-2.21.so] [11:16:38] Top 2 stacks with outstanding allocations: 16 bytes in 1 allocations from stack main+0x6d [allocs] __libc_start_main+0xf0 [libc-2.21.so] [11:16:43] Top 2 stacks with outstanding allocations: 32 bytes in 2 allocations from stack main+0x6d [allocs] __libc_start_main+0xf0 [libc-2.21.so] Note that even though the application leaks 16 bytes of memory every second, the report (printed every 5 seconds) doesn't "see" all the allocations because of the sampling rate applied. USAGE message: # ./memleak -h usage: memleak.py [-h] [-p PID] [-t] [-a] [-o OLDER] [-c COMMAND] [-s SAMPLE_RATE] [-T TOP] [-z MIN_SIZE] [-Z MAX_SIZE] [-O OBJ] [interval] [count] Trace outstanding memory allocations that weren't freed. Supports both user-mode allocations made with malloc/free and kernel-mode allocations made with kmalloc/kfree. positional arguments: interval interval in seconds to print outstanding allocations count number of times to print the report before exiting optional arguments: -h, --help show this help message and exit -p PID, --pid PID the PID to trace; if not specified, trace kernel allocs -t, --trace print trace messages for each alloc/free call -a, --show-allocs show allocation addresses and sizes as well as call stacks -o OLDER, --older OLDER prune allocations younger than this age in milliseconds -c COMMAND, --command COMMAND execute and trace the specified command -s SAMPLE_RATE, --sample-rate SAMPLE_RATE sample every N-th allocation to decrease the overhead -T TOP, --top TOP display only this many top allocating stacks (by size) -z MIN_SIZE, --min-size MIN_SIZE capture only allocations larger than this size -Z MAX_SIZE, --max-size MAX_SIZE capture only allocations smaller than this size -O OBJ, --obj OBJ attach to malloc & free in the specified object EXAMPLES: ./memleak -p $(pidof allocs) Trace allocations and display a summary of "leaked" (outstanding) allocations every 5 seconds ./memleak -p $(pidof allocs) -t Trace allocations and display each individual call to malloc/free ./memleak -ap $(pidof allocs) 10 Trace allocations and display allocated addresses, sizes, and stacks every 10 seconds for outstanding allocations ./memleak -c "./allocs" Run the specified command and trace its allocations ./memleak Trace allocations in kernel mode and display a summary of outstanding allocations every 5 seconds ./memleak -o 60000 Trace allocations in kernel mode and display a summary of outstanding allocations that are at least one minute (60 seconds) old ./memleak -s 5 Trace roughly every 5th allocation, to reduce overhead bpfcc-0.2.0+git0.02884a026/tools/mountsnoop.py000077500000000000000000000277671305314114400204570ustar00rootroot00000000000000#!/usr/bin/env python # # mountsnoop Trace mount() and umount syscalls. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: mountsnoop [-h] # # Copyright (c) 2016 Facebook, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 14-Oct-2016 Omar Sandoval Created this. from __future__ import print_function import argparse import bcc import ctypes import errno import functools import sys bpf_text = r""" #include #include #include #include /* * XXX: struct mnt_namespace is defined in fs/mount.h, which is private to the * VFS and not installed in any kernel-devel packages. So, let's duplicate the * important part of the definition. There are actually more members in the * real struct, but we don't need them, and they're more likely to change. */ struct mnt_namespace { atomic_t count; struct ns_common ns; }; /* * XXX: this could really use first-class string support in BPF. target is a * NUL-terminated path up to PATH_MAX in length. source and type are * NUL-terminated strings up to PAGE_SIZE in length. data is a weird case: it's * almost always a NUL-terminated string, but for some filesystems (e.g., older * NFS variants), it's a binary structure with plenty of NUL bytes, so the * kernel always copies up to PAGE_SIZE bytes, stopping when it hits a fault. * * The best we can do with the existing BPF helpers is to copy as much of each * argument as we can. Our stack space is limited, and we need to leave some * headroom for the rest of the function, so this should be a decent value. */ #define MAX_STR_LEN 412 enum event_type { EVENT_MOUNT, EVENT_MOUNT_SOURCE, EVENT_MOUNT_TARGET, EVENT_MOUNT_TYPE, EVENT_MOUNT_DATA, EVENT_MOUNT_RET, EVENT_UMOUNT, EVENT_UMOUNT_TARGET, EVENT_UMOUNT_RET, }; struct data_t { enum event_type type; pid_t pid, tgid; union { /* EVENT_MOUNT, EVENT_UMOUNT */ struct { /* current->nsproxy->mnt_ns->ns.inum */ unsigned int mnt_ns; char comm[TASK_COMM_LEN]; unsigned long flags; } enter; /* * EVENT_MOUNT_SOURCE, EVENT_MOUNT_TARGET, EVENT_MOUNT_TYPE, * EVENT_MOUNT_DATA, EVENT_UMOUNT_TARGET */ char str[MAX_STR_LEN]; /* EVENT_MOUNT_RET, EVENT_UMOUNT_RET */ int retval; }; }; BPF_PERF_OUTPUT(events); int kprobe__sys_mount(struct pt_regs *ctx, char __user *source, char __user *target, char __user *type, unsigned long flags) { /* sys_mount takes too many arguments */ char __user *data = (char __user *)PT_REGS_PARM5(ctx); struct data_t event = {}; struct task_struct *task; struct nsproxy *nsproxy; struct mnt_namespace *mnt_ns; event.pid = bpf_get_current_pid_tgid() & 0xffffffff; event.tgid = bpf_get_current_pid_tgid() >> 32; event.type = EVENT_MOUNT; bpf_get_current_comm(event.enter.comm, sizeof(event.enter.comm)); event.enter.flags = flags; task = (struct task_struct *)bpf_get_current_task(); bpf_probe_read(&nsproxy, sizeof(nsproxy), &task->nsproxy); bpf_probe_read(&mnt_ns, sizeof(mnt_ns), &nsproxy->mnt_ns); bpf_probe_read(&event.enter.mnt_ns, sizeof(event.enter.mnt_ns), &mnt_ns->ns.inum); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_MOUNT_SOURCE; memset(event.str, 0, sizeof(event.str)); bpf_probe_read(event.str, sizeof(event.str), source); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_MOUNT_TARGET; memset(event.str, 0, sizeof(event.str)); bpf_probe_read(event.str, sizeof(event.str), target); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_MOUNT_TYPE; memset(event.str, 0, sizeof(event.str)); bpf_probe_read(event.str, sizeof(event.str), type); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_MOUNT_DATA; memset(event.str, 0, sizeof(event.str)); bpf_probe_read(event.str, sizeof(event.str), data); events.perf_submit(ctx, &event, sizeof(event)); return 0; } int kretprobe__sys_mount(struct pt_regs *ctx) { struct data_t event = {}; event.type = EVENT_MOUNT_RET; event.pid = bpf_get_current_pid_tgid() & 0xffffffff; event.tgid = bpf_get_current_pid_tgid() >> 32; event.retval = PT_REGS_RC(ctx); events.perf_submit(ctx, &event, sizeof(event)); return 0; } int kprobe__sys_umount(struct pt_regs *ctx, char __user *target, int flags) { struct data_t event = {}; struct task_struct *task; struct nsproxy *nsproxy; struct mnt_namespace *mnt_ns; event.pid = bpf_get_current_pid_tgid() & 0xffffffff; event.tgid = bpf_get_current_pid_tgid() >> 32; event.type = EVENT_UMOUNT; bpf_get_current_comm(event.enter.comm, sizeof(event.enter.comm)); event.enter.flags = flags; task = (struct task_struct *)bpf_get_current_task(); bpf_probe_read(&nsproxy, sizeof(nsproxy), &task->nsproxy); bpf_probe_read(&mnt_ns, sizeof(mnt_ns), &nsproxy->mnt_ns); bpf_probe_read(&event.enter.mnt_ns, sizeof(event.enter.mnt_ns), &mnt_ns->ns.inum); events.perf_submit(ctx, &event, sizeof(event)); event.type = EVENT_UMOUNT_TARGET; memset(event.str, 0, sizeof(event.str)); bpf_probe_read(event.str, sizeof(event.str), target); events.perf_submit(ctx, &event, sizeof(event)); return 0; } int kretprobe__sys_umount(struct pt_regs *ctx) { struct data_t event = {}; event.type = EVENT_UMOUNT_RET; event.pid = bpf_get_current_pid_tgid() & 0xffffffff; event.tgid = bpf_get_current_pid_tgid() >> 32; event.retval = PT_REGS_RC(ctx); events.perf_submit(ctx, &event, sizeof(event)); return 0; } """ # sys/mount.h MS_MGC_VAL = 0xc0ed0000 MS_MGC_MSK = 0xffff0000 MOUNT_FLAGS = [ ('MS_RDONLY', 1), ('MS_NOSUID', 2), ('MS_NODEV', 4), ('MS_NOEXEC', 8), ('MS_SYNCHRONOUS', 16), ('MS_REMOUNT', 32), ('MS_MANDLOCK', 64), ('MS_DIRSYNC', 128), ('MS_NOATIME', 1024), ('MS_NODIRATIME', 2048), ('MS_BIND', 4096), ('MS_MOVE', 8192), ('MS_REC', 16384), ('MS_SILENT', 32768), ('MS_POSIXACL', 1 << 16), ('MS_UNBINDABLE', 1 << 17), ('MS_PRIVATE', 1 << 18), ('MS_SLAVE', 1 << 19), ('MS_SHARED', 1 << 20), ('MS_RELATIME', 1 << 21), ('MS_KERNMOUNT', 1 << 22), ('MS_I_VERSION', 1 << 23), ('MS_STRICTATIME', 1 << 24), ('MS_LAZYTIME', 1 << 25), ('MS_ACTIVE', 1 << 30), ('MS_NOUSER', 1 << 31), ] UMOUNT_FLAGS = [ ('MNT_FORCE', 1), ('MNT_DETACH', 2), ('MNT_EXPIRE', 4), ('UMOUNT_NOFOLLOW', 8), ] TASK_COMM_LEN = 16 # linux/sched.h MAX_STR_LEN = 412 class EventType(object): EVENT_MOUNT = 0 EVENT_MOUNT_SOURCE = 1 EVENT_MOUNT_TARGET = 2 EVENT_MOUNT_TYPE = 3 EVENT_MOUNT_DATA = 4 EVENT_MOUNT_RET = 5 EVENT_UMOUNT = 6 EVENT_UMOUNT_TARGET = 7 EVENT_UMOUNT_RET = 8 class EnterData(ctypes.Structure): _fields_ = [ ('mnt_ns', ctypes.c_uint), ('comm', ctypes.c_char * TASK_COMM_LEN), ('flags', ctypes.c_ulong), ] class DataUnion(ctypes.Union): _fields_ = [ ('enter', EnterData), ('str', ctypes.c_char * MAX_STR_LEN), ('retval', ctypes.c_int), ] class Event(ctypes.Structure): _fields_ = [ ('type', ctypes.c_uint), ('pid', ctypes.c_uint), ('tgid', ctypes.c_uint), ('union', DataUnion), ] def _decode_flags(flags, flag_list): str_flags = [] for flag, bit in flag_list: if flags & bit: str_flags.append(flag) flags &= ~bit if flags or not str_flags: str_flags.append('0x{:x}'.format(flags)) return str_flags def decode_flags(flags, flag_list): return '|'.join(_decode_flags(flags, flag_list)) def decode_mount_flags(flags): str_flags = [] if flags & MS_MGC_MSK == MS_MGC_VAL: flags &= ~MS_MGC_MSK str_flags.append('MS_MGC_VAL') str_flags.extend(_decode_flags(flags, MOUNT_FLAGS)) return '|'.join(str_flags) def decode_umount_flags(flags): return decode_flags(flags, UMOUNT_FLAGS) def decode_errno(retval): try: return '-' + errno.errorcode[-retval] except KeyError: return str(retval) _escape_chars = { ord('\a'): '\\a', ord('\b'): '\\b', ord('\t'): '\\t', ord('\n'): '\\n', ord('\v'): '\\v', ord('\f'): '\\f', ord('\r'): '\\r', ord('"'): '\\"', ord('\\'): '\\\\', } def escape_character(c): try: return _escape_chars[c] except KeyError: if 0x20 <= c <= 0x7e: return chr(c) else: return '\\x{:02x}'.format(c) if sys.version_info.major < 3: def decode_mount_string(s): return '"{}"'.format(''.join(escape_character(ord(c)) for c in s)) else: def decode_mount_string(s): return '"{}"'.format(''.join(escape_character(c) for c in s)) def print_event(mounts, umounts, cpu, data, size): event = ctypes.cast(data, ctypes.POINTER(Event)).contents try: if event.type == EventType.EVENT_MOUNT: mounts[event.pid] = { 'pid': event.pid, 'tgid': event.tgid, 'mnt_ns': event.union.enter.mnt_ns, 'comm': event.union.enter.comm, 'flags': event.union.enter.flags, } elif event.type == EventType.EVENT_MOUNT_SOURCE: mounts[event.pid]['source'] = event.union.str elif event.type == EventType.EVENT_MOUNT_TARGET: mounts[event.pid]['target'] = event.union.str elif event.type == EventType.EVENT_MOUNT_TYPE: mounts[event.pid]['type'] = event.union.str elif event.type == EventType.EVENT_MOUNT_DATA: # XXX: data is not always a NUL-terminated string mounts[event.pid]['data'] = event.union.str elif event.type == EventType.EVENT_UMOUNT: umounts[event.pid] = { 'pid': event.pid, 'tgid': event.tgid, 'mnt_ns': event.union.enter.mnt_ns, 'comm': event.union.enter.comm, 'flags': event.union.enter.flags, } elif event.type == EventType.EVENT_UMOUNT_TARGET: umounts[event.pid]['target'] = event.union.str elif (event.type == EventType.EVENT_MOUNT_RET or event.type == EventType.EVENT_UMOUNT_RET): if event.type == EventType.EVENT_MOUNT_RET: syscall = mounts.pop(event.pid) call = ('mount({source}, {target}, {type}, {flags}, {data}) ' + '= {retval}').format( source=decode_mount_string(syscall['source']), target=decode_mount_string(syscall['target']), type=decode_mount_string(syscall['type']), flags=decode_mount_flags(syscall['flags']), data=decode_mount_string(syscall['data']), retval=decode_errno(event.union.retval)) else: syscall = umounts.pop(event.pid) call = 'umount({target}, {flags}) = {retval}'.format( target=decode_mount_string(syscall['target']), flags=decode_umount_flags(syscall['flags']), retval=decode_errno(event.union.retval)) print('{:16} {:<7} {:<7} {:<11} {}'.format( syscall['comm'].decode(), syscall['tgid'], syscall['pid'], syscall['mnt_ns'], call)) except KeyError: # This might happen if we lost an event. pass def main(): parser = argparse.ArgumentParser( description='trace mount() and umount() syscalls' ) args = parser.parse_args() mounts = {} umounts = {} b = bcc.BPF(text=bpf_text) b['events'].open_perf_buffer( functools.partial(print_event, mounts, umounts)) print('{:16} {:<7} {:<7} {:<11} {}'.format( 'COMM', 'PID', 'TID', 'MNT_NS', 'CALL')) while True: b.kprobe_poll() if __name__ == '__main__': main() bpfcc-0.2.0+git0.02884a026/tools/mountsnoop_example.txt000066400000000000000000000022121305314114400223300ustar00rootroot00000000000000Demonstrations of mountsnoop. mountsnoop traces the mount() and umount syscalls system-wide. For example, running the following series of commands produces this output: # mount --bind /mnt /mnt # umount /mnt # unshare -m # mount --bind /mnt /mnt # umount /mnt # ./mountsnoop.py COMM PID TID MNT_NS CALL mount 710 710 4026531840 mount("/mnt", "/mnt", "", MS_MGC_VAL|MS_BIND, "") = 0 umount 714 714 4026531840 umount("/mnt", 0x0) = 0 unshare 717 717 4026532160 mount("none", "/", "", MS_REC|MS_PRIVATE, "") = 0 mount 725 725 4026532160 mount("/mnt", "/mnt", "", MS_MGC_VAL|MS_BIND, "") = 0 umount 728 728 4026532160 umount("/mnt", 0x0) = 0 The output shows the calling command, its process ID and thread ID, the mount namespace the call was made in, and the call itself. The mount namespace number is an inode number that uniquely identifies the namespace in the running system. This can also be obtained from readlink /proc/$PID/ns/mnt. Note that because of restrictions in BPF, the string arguments to either syscall may be truncated. bpfcc-0.2.0+git0.02884a026/tools/mysqld_qslower.py000077500000000000000000000062061305314114400213040ustar00rootroot00000000000000#!/usr/bin/python # # mysqld_qslower MySQL server queries slower than a threshold. # For Linux, uses BCC, BPF. Embedded C. # # USAGE: mysqld_qslower PID [min_ms] # # By default, a threshold of 1.0 ms is used. Set this to 0 ms to trace all # queries (verbose). # # This uses USDT probes, and needs a MySQL server with -DENABLE_DTRACE=1. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 30-Jul-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF, USDT import sys import ctypes as ct # arguments def usage(): print("USAGE: mysqld_latency PID [min_ms]") exit() if len(sys.argv) < 2: usage() if sys.argv[1][0:1] == "-": usage() pid = int(sys.argv[1]) min_ns = 1 * 1000000 min_ms_text = 1 if len(sys.argv) == 3: min_ns = float(sys.argv[2]) * 1000000 min_ms_text = sys.argv[2] debug = 0 QUERY_MAX = 128 # load BPF program bpf_text = """ #include #define QUERY_MAX """ + str(QUERY_MAX) + """ struct start_t { u64 ts; char *query; }; struct data_t { u64 pid; u64 ts; u64 delta; char query[QUERY_MAX]; }; BPF_HASH(start_tmp, u32, struct start_t); BPF_PERF_OUTPUT(events); int do_start(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); struct start_t start = {}; start.ts = bpf_ktime_get_ns(); bpf_usdt_readarg(1, ctx, &start.query); start_tmp.update(&pid, &start); return 0; }; int do_done(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); struct start_t *sp; sp = start_tmp.lookup(&pid); if (sp == 0) { // missed tracing start return 0; } // check if query exceeded our threshold u64 delta = bpf_ktime_get_ns() - sp->ts; if (delta >= """ + str(min_ns) + """) { // populate and emit data struct struct data_t data = {.pid = pid, .ts = sp->ts, .delta = delta}; bpf_probe_read(&data.query, sizeof(data.query), (void *)sp->query); events.perf_submit(ctx, &data, sizeof(data)); } start_tmp.delete(&pid); return 0; }; """ # enable USDT probe from given PID u = USDT(pid=pid) u.enable_probe(probe="query__start", fn_name="do_start") u.enable_probe(probe="query__done", fn_name="do_done") if debug: print(u.get_text()) print(bpf_text) # initialize BPF b = BPF(text=bpf_text, usdt_contexts=[u]) # header print("Tracing MySQL server queries for PID %d slower than %s ms..." % (pid, min_ms_text)) print("%-14s %-6s %8s %s" % ("TIME(s)", "PID", "MS", "QUERY")) class Data(ct.Structure): _fields_ = [ ("pid", ct.c_ulonglong), ("ts", ct.c_ulonglong), ("delta", ct.c_ulonglong), ("query", ct.c_char * QUERY_MAX) ] # process event start = 0 def print_event(cpu, data, size): global start event = ct.cast(data, ct.POINTER(Data)).contents if start == 0: start = event.ts print("%-14.6f %-6d %8.3f %s" % (float(event.ts - start) / 1000000000, event.pid, float(event.delta) / 1000000, event.query)) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/mysqld_qslower_example.txt000066400000000000000000000044571305314114400232110ustar00rootroot00000000000000Demonstrations of mysqld_qslower, the Linux eBPF/bcc version. mysqld_qslower traces queries served by a MySQL server, and prints those that exceed a latency (query time) threshold. By default a threshold of 1 ms is used. For example: # ./mysqld_qslower.py `pgrep -n mysqld` Tracing MySQL server queries for PID 14371 slower than 1 ms... TIME(s) PID MS QUERY 0.000000 18608 130.751 SELECT * FROM words WHERE word REGEXP '^bre.*n$' 2.921535 18608 130.590 SELECT * FROM words WHERE word REGEXP '^alex.*$' 4.603549 18608 24.164 SELECT COUNT(*) FROM words 9.733847 18608 130.936 SELECT count(*) AS count FROM words WHERE word REGEXP '^bre.*n$' 17.864776 18608 130.298 SELECT * FROM words WHERE word REGEXP '^bre.*n$' ORDER BY word This traced 5 queries, 4 of which took about 130 milliseconds. A pgrep command was used to specify the PID of mysqld. In this example, a lower threshold is used of 0.1 ms: # ./mysqld_qslower.py `pgrep -n mysqld` 0.1 Tracing MySQL server queries for PID 14371 slower than 0.1 ms... TIME(s) PID MS QUERY 0.000000 18608 24.201 SELECT COUNT(*) FROM words 13.242390 18608 130.378 SELECT * FROM words WHERE word REGEXP '^bre.*n$' 23.601751 18608 119.198 SELECT * FROM words WHERE word REGEXP '^zzzzzzzz$' It worked, but I'm not catching any faster queries in this example. Notice I added a query that searched for "zzzzzzzz": it returned an empty set, and ran 11 ms faster. A 0 ms threshold can be specified to trace all queries: # ./mysqld_qslower.py `pgrep -n mysqld` 0 Tracing MySQL server queries for PID 14371 slower than 0 ms... TIME(s) PID MS QUERY 0.000000 18608 0.105 select @@version_comment limit 1 2.049312 18608 0.099 SELECT DATABASE() 2.050666 18608 0.274 show databases 2.051040 18608 0.176 show tables 5.730044 18608 130.365 SELECT count(*) AS count FROM words WHERE word REGEXP '^bre.*n$' 9.273837 18608 0.096 select 1 9.553742 18608 0.059 select 1 9.986087 18608 0.080 select 1 This includes an initialization of a mysql client command, and selecting the database. I also added some "select 1;" queries, which do no work and return quickly. USAGE: # ./mysqld_qslower.py -h USAGE: mysqld_latency PID [min_ms] bpfcc-0.2.0+git0.02884a026/tools/offcputime.py000077500000000000000000000233461305314114400203640ustar00rootroot00000000000000#!/usr/bin/python # # offcputime Summarize off-CPU time by stack trace # For Linux, uses BCC, eBPF. # # USAGE: offcputime [-h] [-p PID | -u | -k] [-U | -K] [-f] [duration] # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 13-Jan-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from sys import stderr from time import sleep, strftime import argparse import errno import signal # arg validation def positive_int(val): try: ival = int(val) except ValueError: raise argparse.ArgumentTypeError("must be an integer") if ival < 0: raise argparse.ArgumentTypeError("must be positive") return ival def positive_nonzero_int(val): ival = positive_int(val) if ival == 0: raise argparse.ArgumentTypeError("must be nonzero") return ival # arguments examples = """examples: ./offcputime # trace off-CPU stack time until Ctrl-C ./offcputime 5 # trace for 5 seconds only ./offcputime -f 5 # 5 seconds, and output in folded format ./offcputime -m 1000 # trace only events that last more than 1000 usec ./offcputime -M 10000 # trace only events that last less than 10000 usec ./offcputime -p 185 # only trace threads for PID 185 ./offcputime -t 188 # only trace thread 188 ./offcputime -u # only trace user threads (no kernel) ./offcputime -k # only trace kernel threads (no user) ./offcputime -U # only show user space stacks (no kernel) ./offcputime -K # only show kernel space stacks (no user) """ parser = argparse.ArgumentParser( description="Summarize off-CPU time by stack trace", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) thread_group = parser.add_mutually_exclusive_group() # Note: this script provides --pid and --tid flags but their arguments are # referred to internally using kernel nomenclature: TGID and PID. thread_group.add_argument("-p", "--pid", metavar="PID", dest="tgid", help="trace this PID only", type=positive_int) thread_group.add_argument("-t", "--tid", metavar="TID", dest="pid", help="trace this TID only", type=positive_int) thread_group.add_argument("-u", "--user-threads-only", action="store_true", help="user threads only (no kernel threads)") thread_group.add_argument("-k", "--kernel-threads-only", action="store_true", help="kernel threads only (no user threads)") stack_group = parser.add_mutually_exclusive_group() stack_group.add_argument("-U", "--user-stacks-only", action="store_true", help="show stacks from user space only (no kernel space stacks)") stack_group.add_argument("-K", "--kernel-stacks-only", action="store_true", help="show stacks from kernel space only (no user space stacks)") parser.add_argument("-d", "--delimited", action="store_true", help="insert delimiter between kernel/user stacks") parser.add_argument("-f", "--folded", action="store_true", help="output folded format") parser.add_argument("--stack-storage-size", default=1024, type=positive_nonzero_int, help="the number of unique stack traces that can be stored and " "displayed (default 1024)") parser.add_argument("duration", nargs="?", default=99999999, type=positive_nonzero_int, help="duration of trace, in seconds") parser.add_argument("-m", "--min-block-time", default=1, type=positive_nonzero_int, help="the amount of time in microseconds over which we " + "store traces (default 1)") parser.add_argument("-M", "--max-block-time", default=(1 << 64) - 1, type=positive_nonzero_int, help="the amount of time in microseconds under which we " + "store traces (default U64_MAX)") args = parser.parse_args() if args.pid and args.tgid: parser.error("specify only one of -p and -t") folded = args.folded duration = int(args.duration) # signal handler def signal_ignore(signal, frame): print() # define BPF program bpf_text = """ #include #include #define MINBLOCK_US MINBLOCK_US_VALUEULL #define MAXBLOCK_US MAXBLOCK_US_VALUEULL struct key_t { u32 pid; u32 tgid; int user_stack_id; int kernel_stack_id; char name[TASK_COMM_LEN]; }; BPF_HASH(counts, struct key_t); BPF_HASH(start, u32); BPF_STACK_TRACE(stack_traces, STACK_STORAGE_SIZE) int oncpu(struct pt_regs *ctx, struct task_struct *prev) { u32 pid = prev->pid; u32 tgid = prev->tgid; u64 ts, *tsp; // record previous thread sleep time if (THREAD_FILTER) { ts = bpf_ktime_get_ns(); start.update(&pid, &ts); } // get the current thread's start time pid = bpf_get_current_pid_tgid(); tgid = bpf_get_current_pid_tgid() >> 32; tsp = start.lookup(&pid); if (tsp == 0) { return 0; // missed start or filtered } // calculate current thread's delta time u64 delta = bpf_ktime_get_ns() - *tsp; start.delete(&pid); delta = delta / 1000; if ((delta < MINBLOCK_US) || (delta > MAXBLOCK_US)) { return 0; } // create map key u64 zero = 0, *val; struct key_t key = {}; key.pid = pid; key.tgid = tgid; key.user_stack_id = USER_STACK_GET; key.kernel_stack_id = KERNEL_STACK_GET; bpf_get_current_comm(&key.name, sizeof(key.name)); val = counts.lookup_or_init(&key, &zero); (*val) += delta; return 0; } """ # set thread filter thread_context = "" if args.tgid is not None: thread_context = "PID %d" % args.tgid thread_filter = 'tgid == %d' % args.tgid elif args.pid is not None: thread_context = "TID %d" % args.pid thread_filter = 'pid == %d' % args.pid elif args.user_threads_only: thread_context = "user threads" thread_filter = '!(prev->flags & PF_KTHREAD)' elif args.kernel_threads_only: thread_context = "kernel threads" thread_filter = 'prev->flags & PF_KTHREAD' else: thread_context = "all threads" thread_filter = '1' bpf_text = bpf_text.replace('THREAD_FILTER', thread_filter) # set stack storage size bpf_text = bpf_text.replace('STACK_STORAGE_SIZE', str(args.stack_storage_size)) bpf_text = bpf_text.replace('MINBLOCK_US_VALUE', str(args.min_block_time)) bpf_text = bpf_text.replace('MAXBLOCK_US_VALUE', str(args.max_block_time)) # handle stack args kernel_stack_get = "stack_traces.get_stackid(ctx, BPF_F_REUSE_STACKID)" user_stack_get = \ "stack_traces.get_stackid(ctx, BPF_F_REUSE_STACKID | BPF_F_USER_STACK)" stack_context = "" if args.user_stacks_only: stack_context = "user" kernel_stack_get = "-1" elif args.kernel_stacks_only: stack_context = "kernel" user_stack_get = "-1" else: stack_context = "user + kernel" bpf_text = bpf_text.replace('USER_STACK_GET', user_stack_get) bpf_text = bpf_text.replace('KERNEL_STACK_GET', kernel_stack_get) need_delimiter = args.delimited and not (args.kernel_stacks_only or args.user_stacks_only) # check for an edge case; the code below will handle this case correctly # but ultimately nothing will be displayed if args.kernel_threads_only and args.user_stacks_only: print("ERROR: Displaying user stacks for kernel threads " + "doesn't make sense.", file=stderr) exit(1) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="finish_task_switch", fn_name="oncpu") matched = b.num_open_kprobes() if matched == 0: print("error: 0 functions traced. Exiting.", file=stderr) exit(1) # header if not folded: print("Tracing off-CPU time (us) of %s by %s stack" % (thread_context, stack_context), end="") if duration < 99999999: print(" for %d secs." % duration) else: print("... Hit Ctrl-C to end.") try: sleep(duration) except KeyboardInterrupt: # as cleanup can take many seconds, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) if not folded: print() missing_stacks = 0 has_enomem = False counts = b.get_table("counts") stack_traces = b.get_table("stack_traces") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): # handle get_stackid erorrs if (not args.user_stacks_only and k.kernel_stack_id < 0) or \ (not args.kernel_stacks_only and k.user_stack_id < 0 and k.user_stack_id != -errno.EFAULT): missing_stacks += 1 # check for an ENOMEM error if k.kernel_stack_id == -errno.ENOMEM or \ k.user_stack_id == -errno.ENOMEM: has_enomem = True continue # user stacks will be symbolized by tgid, not pid, to avoid the overhead # of one symbol resolver per thread user_stack = [] if k.user_stack_id < 0 else \ stack_traces.walk(k.user_stack_id) kernel_stack = [] if k.kernel_stack_id < 0 else \ stack_traces.walk(k.kernel_stack_id) if folded: # print folded stack output user_stack = list(user_stack) kernel_stack = list(kernel_stack) line = [k.name.decode()] + \ [b.sym(addr, k.tgid) for addr in reversed(user_stack)] + \ (need_delimiter and ["-"] or []) + \ [b.ksym(addr) for addr in reversed(kernel_stack)] print("%s %d" % (";".join(line), v.value)) else: # print default multi-line stack output for addr in kernel_stack: print(" %s" % b.ksym(addr)) if need_delimiter: print(" --") for addr in user_stack: print(" %s" % b.sym(addr, k.tgid)) print(" %-16s %s (%d)" % ("-", k.name, k.pid)) print(" %d\n" % v.value) if missing_stacks > 0: enomem_str = "" if not has_enomem else \ " Consider increasing --stack-storage-size." print("WARNING: %d stack traces could not be displayed.%s" % (missing_stacks, enomem_str), file=stderr) bpfcc-0.2.0+git0.02884a026/tools/offcputime_example.txt000066400000000000000000000445671305314114400222730ustar00rootroot00000000000000Demonstrations of offcputime, the Linux eBPF/bcc version. This program shows stack traces that were blocked, and the total duration they were blocked. It works by tracing when threads block and when they return to CPU, measuring both the time they were blocked (aka the "off-CPU time") and the blocked stack trace and the task name. This data is summarized in kernel by summing the blocked time by unique stack trace and task name. Here is some example output. The -K option was used to only match kernel stacks. To explain what we are seeing: the very first stack trace looks like a page fault (do_page_fault() etc) from the "chmod" command, and in total was off-CPU for 13 microseconds. # ./offcputime -K Tracing off-CPU time (us) of all threads by kernel stack... Hit Ctrl-C to end. ^C schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit wait_on_page_bit_killable __lock_page_or_retry filemap_fault __do_fault handle_mm_fault __do_page_fault do_page_fault page_fault chmod 13 schedule rcu_nocb_kthread kthread ret_from_fork ddebug_tables rcuos/0 22 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit_lock __lock_page lock_page __do_fault handle_mm_fault __do_page_fault do_page_fault page_fault run 27 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit wait_on_page_bit_killable __lock_page_or_retry filemap_fault __do_fault handle_mm_fault __do_page_fault do_page_fault page_fault clear_user padzero load_elf_binary search_binary_handler load_script search_binary_handler do_execveat_common.isra.27 run 28 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit wait_on_page_bit_killable __lock_page_or_retry filemap_fault __do_fault handle_mm_fault __do_page_fault do_page_fault page_fault run 82 schedule pipe_wait pipe_read __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath bash 94 schedule rcu_gp_kthread kthread ret_from_fork ddebug_tables rcu_sched 104 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit out_of_line_wait_on_bit __wait_on_buffer jbd2_journal_commit_transaction kjournald2 kthread ret_from_fork mb_cache_list jbd2/xvda1-8 986 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit out_of_line_wait_on_bit __wait_on_buffer jbd2_journal_commit_transaction kjournald2 kthread ret_from_fork mb_cache_list jbd2/xvda1-8 6630 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit out_of_line_wait_on_bit do_get_write_access jbd2_journal_get_write_access __ext4_journal_get_write_access ext4_mb_mark_diskspace_used ext4_mb_new_blocks ext4_ext_map_blocks ext4_map_blocks ext4_writepages do_writepages __filemap_fdatawrite_range filemap_flush ext4_alloc_da_blocks ext4_rename ext4_rename2 supervise 6645 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit out_of_line_wait_on_bit do_get_write_access jbd2_journal_get_write_access __ext4_journal_get_write_access __ext4_new_inode ext4_create vfs_create path_openat do_filp_open do_sys_open sys_open entry_SYSCALL_64_fastpath supervise 12702 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/2 16036 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/4 24085 schedule do_wait sys_wait4 entry_SYSCALL_64_fastpath run 233055 schedule schedule_timeout io_schedule_timeout bit_wait_io __wait_on_bit wait_on_page_bit truncate_inode_pages_range truncate_inode_pages_final ext4_evict_inode evict iput __dentry_kill dput sys_rename entry_SYSCALL_64_fastpath supervise 297113 schedule schedule_timeout wait_woken n_tty_read tty_read __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath bash 1789866 schedule schedule_timeout io_schedule_timeout do_blockdev_direct_IO __blockdev_direct_IO blkdev_direct_IO generic_file_read_iter blkdev_read_iter __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath dd 3310763 schedule smpboot_thread_fn kthread ret_from_fork watchdog/1 3999989 schedule smpboot_thread_fn kthread ret_from_fork watchdog/5 3999995 schedule smpboot_thread_fn kthread ret_from_fork watchdog/4 3999996 schedule smpboot_thread_fn kthread ret_from_fork watchdog/0 3999996 schedule smpboot_thread_fn kthread ret_from_fork watchdog/3 3999998 schedule smpboot_thread_fn kthread ret_from_fork watchdog/7 3999999 schedule smpboot_thread_fn kthread ret_from_fork watchdog/2 4000001 schedule smpboot_thread_fn kthread ret_from_fork watchdog/6 4000001 schedule do_wait sys_wait4 entry_SYSCALL_64_fastpath bash 4039675 schedule do_nanosleep hrtimer_nanosleep sys_nanosleep entry_SYSCALL_64_fastpath svscan 5000112 schedule schedule_hrtimeout_range_clock schedule_hrtimeout_range poll_schedule_timeout do_select core_sys_select sys_select entry_SYSCALL_64_fastpath snmpd 5998761 schedule smpboot_thread_fn kthread ret_from_fork migration/3 6149779 schedule schedule_hrtimeout_range_clock schedule_hrtimeout_range poll_schedule_timeout do_select core_sys_select sys_select entry_SYSCALL_64_fastpath ntpd 6999832 schedule worker_thread kthread ret_from_fork kworker/u16:2 7131941 schedule worker_thread kthread ret_from_fork kworker/3:0 7999844 schedule worker_thread kthread ret_from_fork kworker/1:1 7999872 schedule worker_thread kthread ret_from_fork kworker/2:1 7999889 schedule worker_thread kthread ret_from_fork kworker/5:1 7999936 schedule worker_thread kthread ret_from_fork kworker/7:1 7999938 schedule worker_thread kthread ret_from_fork kworker/6:1 7999940 schedule do_nanosleep hrtimer_nanosleep sys_nanosleep entry_SYSCALL_64_fastpath tail 8000905 schedule smpboot_thread_fn kthread ret_from_fork migration/7 8197046 schedule pipe_wait pipe_read __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath readproctitle 8197835 schedule smpboot_thread_fn kthread ret_from_fork migration/4 8201851 schedule smpboot_thread_fn kthread ret_from_fork migration/2 8203375 schedule smpboot_thread_fn kthread ret_from_fork migration/6 8208664 schedule smpboot_thread_fn kthread ret_from_fork migration/5 8209819 schedule smpboot_thread_fn kthread ret_from_fork ddebug_tables migration/0 8211292 schedule smpboot_thread_fn kthread ret_from_fork migration/1 8212100 schedule worker_thread kthread ret_from_fork kworker/0:2 8270305 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/3 8349697 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/2 8363357 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/1 8365338 schedule schedule_timeout xfs_buf_terminate kthread ret_from_fork xfsaild/md0 8371514 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/4 8384013 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/5 8390016 schedule rcu_nocb_kthread kthread ret_from_fork ddebug_tables rcuos/0 8405428 schedule schedule_timeout rcu_gp_kthread kthread ret_from_fork ddebug_tables rcu_sched 8406930 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/7 8409575 schedule rcu_nocb_kthread kthread ret_from_fork rcuos/6 8415062 schedule schedule_hrtimeout_range_clock schedule_hrtimeout_range poll_schedule_timeout do_select core_sys_select sys_select entry_SYSCALL_64_fastpath offcputime 8421478 schedule worker_thread kthread ret_from_fork kworker/4:0 8421492 schedule schedule_hrtimeout_range_clock schedule_hrtimeout_range poll_schedule_timeout do_select core_sys_select sys_select entry_SYSCALL_64_fastpath sshd 14249005 schedule schedule_hrtimeout_range_clock schedule_hrtimeout_range poll_schedule_timeout do_sys_poll sys_poll entry_SYSCALL_64_fastpath supervise 81670888 The last few stack traces aren't very interesting, since they are threads that are often blocked off-CPU waiting for work. Do be somewhat careful with overhead: this is tracing scheduler functions, which can be called very frequently. While this uses in-kernel summaries for efficiency, the rate of scheduler functions can be very high (> 1,000,000/sec), and this is performing stack walks when threads return to CPU. At some point the overhead will be measurable. A -p option can be used to filter (in-kernel) on a single process ID. For example, only matching PID 26651, which is a running "dd" command: # ./offcputime -K -p 26651 Tracing off-CPU time (us) of all threads by kernel stack... Hit Ctrl-C to end. ^C schedule schedule_timeout io_schedule_timeout do_blockdev_direct_IO __blockdev_direct_IO blkdev_direct_IO generic_file_read_iter blkdev_read_iter __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath dd 2405710 The stack trace shows "dd" is blocked waiting on disk I/O, as expected, for a total of 2.4 seconds during tracing. A duration can be added, for example, tracing for 5 seconds only: # ./offcputime -K -p 26651 5 Tracing off-CPU time (us) of all threads by kernel stack for 5 secs. schedule schedule_timeout io_schedule_timeout do_blockdev_direct_IO __blockdev_direct_IO blkdev_direct_IO generic_file_read_iter blkdev_read_iter __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath dd 4413909 Here, dd was blocked for 4.4 seconds out of 5. Or put differently, likely on-CPU for about 12% of the time. Which matches the ratio seen by time(1): # time dd if=/dev/md0 iflag=direct of=/dev/null bs=1k ^C108115+0 records in 108114+0 records out 110708736 bytes (111 MB) copied, 13.7565 s, 8.0 MB/s real 0m13.760s user 0m0.000s sys 0m1.739s A -f option will emit output using the "folded stacks" format, which can be read directly by flamegraph.pl from the FlameGraph open source software (https://github.com/brendangregg/FlameGraph). Eg: # ./offcputime -K -f 5 bash;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;tty_read;n_tty_read;call_rwsem_down_read_failed;rwsem_down_read_failed;schedule 8 yes;entry_SYSCALL_64_fastpath;sys_write;vfs_write;__vfs_write;tty_write;n_tty_write;call_rwsem_down_read_failed;rwsem_down_read_failed;schedule 14 run;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;__do_fault;filemap_fault;__lock_page_or_retry;wait_on_page_bit_killable;__wait_on_bit;bit_wait_io;io_schedule_timeout;schedule_timeout;schedule 33 rcuos/4;ret_from_fork;kthread;rcu_nocb_kthread;schedule 45 bash;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;pipe_read;pipe_wait;schedule 88 run;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;__do_fault;filemap_fault;__lock_page_or_retry;wait_on_page_bit_killable;__wait_on_bit;bit_wait_io;io_schedule_timeout;schedule_timeout;schedule 108 jbd2/xvda1-8;mb_cache_list;ret_from_fork;kthread;kjournald2;jbd2_journal_commit_transaction;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;io_schedule_timeout;schedule_timeout;schedule 828 jbd2/xvda1-8;mb_cache_list;ret_from_fork;kthread;kjournald2;jbd2_journal_commit_transaction;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;io_schedule_timeout;schedule_timeout;schedule 6201 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;truncate_inode_pages_final;truncate_inode_pages_range;wait_on_page_bit;__wait_on_bit;bit_wait_io;io_schedule_timeout;schedule_timeout;schedule 41049 run;entry_SYSCALL_64_fastpath;sys_wait4;do_wait;schedule 120709 bash;entry_SYSCALL_64_fastpath;sys_wait4;do_wait;schedule 699320 ksoftirqd/0;ret_from_fork;kthread;smpboot_thread_fn;schedule 1077529 bash;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;tty_read;n_tty_read;wait_woken;schedule_timeout;schedule 1362045 sshd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule 1377627 migration/0;ddebug_tables;ret_from_fork;kthread;smpboot_thread_fn;schedule 2040753 snmpd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule 2197568 migration/5;ret_from_fork;kthread;smpboot_thread_fn;schedule 3079426 migration/7;ret_from_fork;kthread;smpboot_thread_fn;schedule 3084746 kworker/6:2;ret_from_fork;kthread;worker_thread;schedule 3940583 kworker/5:1;ret_from_fork;kthread;worker_thread;schedule 3944892 kworker/1:2;ret_from_fork;kthread;worker_thread;schedule 3999646 ntpd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule 3999904 kworker/u16:0;ret_from_fork;kthread;worker_thread;schedule 3999967 kworker/7:0;ret_from_fork;kthread;worker_thread;schedule 3999987 tail;entry_SYSCALL_64_fastpath;sys_nanosleep;hrtimer_nanosleep;do_nanosleep;schedule 4000473 migration/1;ret_from_fork;kthread;smpboot_thread_fn;schedule 4091150 migration/4;ret_from_fork;kthread;smpboot_thread_fn;schedule 4095217 readproctitle;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;pipe_read;pipe_wait;schedule 4108470 migration/3;ret_from_fork;kthread;smpboot_thread_fn;schedule 4109264 migration/2;ret_from_fork;kthread;smpboot_thread_fn;schedule 4109280 migration/6;ret_from_fork;kthread;smpboot_thread_fn;schedule 4111143 kworker/4:0;ret_from_fork;kthread;worker_thread;schedule 4402350 kworker/3:0;ret_from_fork;kthread;worker_thread;schedule 4433988 kworker/2:1;ret_from_fork;kthread;worker_thread;schedule 4636142 kworker/0:2;ret_from_fork;kthread;worker_thread;schedule 4832023 rcuos/1;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4974186 rcuos/5;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4977137 rcuos/6;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4987769 rcuos/3;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4992282 rcuos/4;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4992364 rcuos/2;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4992714 rcuos/0;ddebug_tables;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4996504 rcuos/7;ret_from_fork;kthread;rcu_nocb_kthread;schedule 4998497 rcu_sched;ddebug_tables;ret_from_fork;kthread;rcu_gp_kthread;schedule_timeout;schedule 5000686 offcputime;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule 5005063 dd;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;blkdev_read_iter;generic_file_read_iter;blkdev_direct_IO;__blockdev_direct_IO;do_blockdev_direct_IO;io_schedule_timeout;schedule_timeout;schedule 8025599 supervise;entry_SYSCALL_64_fastpath;sys_poll;do_sys_poll;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule 40835611 The stack traces are shown as single lines, with functions separated by semicolons. The first entry is the task name. The 2nd column is the total off-CPU time. I'd save this output to a file, then move it to the system where you'll be creating your "off-CPU time flame graphs". USAGE message: # ./offcputime -h usage: offcputime.py [-h] [-p PID | -t TID | -u | -k] [-U | -K] [-d] [-f] [--stack-storage-size STACK_STORAGE_SIZE] [duration] Summarize off-CPU time by stack trace positional arguments: duration duration of trace, in seconds optional arguments: -h, --help show this help message and exit -p PID, --pid PID trace this PID only -t TID, --tid TID trace this TID only -u, --user-threads-only user threads only (no kernel threads) -k, --kernel-threads-only kernel threads only (no user threads) -U, --user-stacks-only show stacks from user space only (no kernel space stacks) -K, --kernel-stacks-only show stacks from kernel space only (no user space stacks) -d, --delimited insert delimiter between kernel/user stacks -f, --folded output folded format --stack-storage-size STACK_STORAGE_SIZE the number of unique stack traces that can be stored and displayed (default 1024) examples: ./offcputime # trace off-CPU stack time until Ctrl-C ./offcputime 5 # trace for 5 seconds only ./offcputime -f 5 # 5 seconds, and output in folded format ./offcputime -p 185 # only trace threads for PID 185 ./offcputime -t 188 # only trace thread 188 ./offcputime -u # only trace user threads (no kernel) ./offcputime -k # only trace kernel threads (no user) ./offcputime -U # only show user space stacks (no kernel) ./offcputime -K # only show kernel space stacks (no user) bpfcc-0.2.0+git0.02884a026/tools/offwaketime.py000066400000000000000000000255611305314114400205220ustar00rootroot00000000000000#!/usr/bin/python # # offwaketime Summarize blocked time by kernel off-CPU stack + waker stack # For Linux, uses BCC, eBPF. # # USAGE: offwaketime [-h] [-p PID | -u | -k] [-U | -K] [-f] [duration] # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Jan-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep import argparse import signal import errno from sys import stderr # arg validation def positive_int(val): try: ival = int(val) except ValueError: raise argparse.ArgumentTypeError("must be an integer") if ival < 0: raise argparse.ArgumentTypeError("must be positive") return ival def positive_nonzero_int(val): ival = positive_int(val) if ival == 0: raise argparse.ArgumentTypeError("must be nonzero") return ival # arguments examples = """examples: ./offwaketime # trace off-CPU + waker stack time until Ctrl-C ./offwaketime 5 # trace for 5 seconds only ./offwaketime -f 5 # 5 seconds, and output in folded format ./offwaketime -m 1000 # trace only events that last more than 1000 usec ./offwaketime -M 9000 # trace only events that last less than 9000 usec ./offwaketime -p 185 # only trace threads for PID 185 ./offwaketime -t 188 # only trace thread 188 ./offwaketime -u # only trace user threads (no kernel) ./offwaketime -k # only trace kernel threads (no user) ./offwaketime -U # only show user space stacks (no kernel) ./offwaketime -K # only show kernel space stacks (no user) """ parser = argparse.ArgumentParser( description="Summarize blocked time by kernel stack trace + waker stack", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) thread_group = parser.add_mutually_exclusive_group() # Note: this script provides --pid and --tid flags but their arguments are # referred to internally using kernel nomenclature: TGID and PID. thread_group.add_argument("-p", "--pid", metavar="PID", dest="tgid", help="trace this PID only", type=positive_int) thread_group.add_argument("-t", "--tid", metavar="TID", dest="pid", help="trace this TID only", type=positive_int) thread_group.add_argument("-u", "--user-threads-only", action="store_true", help="user threads only (no kernel threads)") thread_group.add_argument("-k", "--kernel-threads-only", action="store_true", help="kernel threads only (no user threads)") stack_group = parser.add_mutually_exclusive_group() stack_group.add_argument("-U", "--user-stacks-only", action="store_true", help="show stacks from user space only (no kernel space stacks)") stack_group.add_argument("-K", "--kernel-stacks-only", action="store_true", help="show stacks from kernel space only (no user space stacks)") parser.add_argument("-d", "--delimited", action="store_true", help="insert delimiter between kernel/user stacks") parser.add_argument("-f", "--folded", action="store_true", help="output folded format") parser.add_argument("--stack-storage-size", default=1024, type=positive_nonzero_int, help="the number of unique stack traces that can be stored and " "displayed (default 1024)") parser.add_argument("duration", nargs="?", default=99999999, type=positive_nonzero_int, help="duration of trace, in seconds") parser.add_argument("-m", "--min-block-time", default=1, type=positive_nonzero_int, help="the amount of time in microseconds over which we " + "store traces (default 1)") parser.add_argument("-M", "--max-block-time", default=(1 << 64) - 1, type=positive_nonzero_int, help="the amount of time in microseconds under which we " + "store traces (default U64_MAX)") args = parser.parse_args() folded = args.folded duration = int(args.duration) # signal handler def signal_ignore(signal, frame): print() # define BPF program bpf_text = """ #include #include #define MINBLOCK_US MINBLOCK_US_VALUEULL #define MAXBLOCK_US MAXBLOCK_US_VALUEULL struct key_t { char waker[TASK_COMM_LEN]; char target[TASK_COMM_LEN]; int w_k_stack_id; int w_u_stack_id; int t_k_stack_id; int t_u_stack_id; u32 t_pid; u32 w_pid; u32 tgid; }; BPF_HASH(counts, struct key_t); BPF_HASH(start, u32); struct wokeby_t { char name[TASK_COMM_LEN]; int k_stack_id; int u_stack_id; int w_pid; }; BPF_HASH(wokeby, u32, struct wokeby_t); BPF_STACK_TRACE(stack_traces, STACK_STORAGE_SIZE) int waker(struct pt_regs *ctx, struct task_struct *p) { u32 pid = p->pid; u32 tgid = p->tgid; if (!(THREAD_FILTER)) { return 0; } struct wokeby_t woke = {}; bpf_get_current_comm(&woke.name, sizeof(woke.name)); woke.k_stack_id = KERNEL_STACK_GET; woke.u_stack_id = USER_STACK_GET; woke.w_pid = pid; wokeby.update(&pid, &woke); return 0; } int oncpu(struct pt_regs *ctx, struct task_struct *p) { u32 pid = p->pid, t_pid=pid; u32 tgid = p->tgid; u64 ts, *tsp; // record previous thread sleep time if (THREAD_FILTER) { ts = bpf_ktime_get_ns(); start.update(&pid, &ts); } // calculate current thread's delta time pid = bpf_get_current_pid_tgid(); tgid = bpf_get_current_pid_tgid() >> 32; tsp = start.lookup(&pid); if (tsp == 0) { return 0; // missed start or filtered } u64 delta = bpf_ktime_get_ns() - *tsp; start.delete(&pid); delta = delta / 1000; if ((delta < MINBLOCK_US) || (delta > MAXBLOCK_US)) { return 0; } // create map key u64 zero = 0, *val; struct key_t key = {}; struct wokeby_t *woke; bpf_get_current_comm(&key.target, sizeof(key.target)); key.t_k_stack_id = KERNEL_STACK_GET; key.t_u_stack_id = USER_STACK_GET; key.t_pid = t_pid; woke = wokeby.lookup(&pid); if (woke) { key.w_k_stack_id = woke->k_stack_id; key.w_u_stack_id = woke->u_stack_id; key.w_pid = woke->w_pid; key.tgid = tgid; __builtin_memcpy(&key.waker, woke->name, TASK_COMM_LEN); wokeby.delete(&pid); } val = counts.lookup_or_init(&key, &zero); (*val) += delta; return 0; } """ # set thread filter thread_context = "" if args.tgid is not None: thread_context = "PID %d" % args.tgid thread_filter = 'tgid == %d' % args.tgid elif args.pid is not None: thread_context = "TID %d" % args.pid thread_filter = 'pid == %d' % args.pid elif args.user_threads_only: thread_context = "user threads" thread_filter = '!(p->flags & PF_KTHREAD)' elif args.kernel_threads_only: thread_context = "kernel threads" thread_filter = 'p->flags & PF_KTHREAD' else: thread_context = "all threads" thread_filter = '1' bpf_text = bpf_text.replace('THREAD_FILTER', thread_filter) # set stack storage size bpf_text = bpf_text.replace('STACK_STORAGE_SIZE', str(args.stack_storage_size)) bpf_text = bpf_text.replace('MINBLOCK_US_VALUE', str(args.min_block_time)) bpf_text = bpf_text.replace('MAXBLOCK_US_VALUE', str(args.max_block_time)) # handle stack args kernel_stack_get = "stack_traces.get_stackid(ctx, BPF_F_REUSE_STACKID)" user_stack_get = \ "stack_traces.get_stackid(ctx, BPF_F_REUSE_STACKID | BPF_F_USER_STACK)" stack_context = "" if args.user_stacks_only: stack_context = "user" kernel_stack_get = "-1" elif args.kernel_stacks_only: stack_context = "kernel" user_stack_get = "-1" else: stack_context = "user + kernel" bpf_text = bpf_text.replace('USER_STACK_GET', user_stack_get) bpf_text = bpf_text.replace('KERNEL_STACK_GET', kernel_stack_get) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="finish_task_switch", fn_name="oncpu") b.attach_kprobe(event="try_to_wake_up", fn_name="waker") matched = b.num_open_kprobes() if matched == 0: print("0 functions traced. Exiting.") exit() # header if not folded: print("Tracing blocked time (us) by %s off-CPU and waker stack" % stack_context, end="") if duration < 99999999: print(" for %d secs." % duration) else: print("... Hit Ctrl-C to end.") # as cleanup can take many seconds, trap Ctrl-C: # print a newline for folded output on Ctrl-C signal.signal(signal.SIGINT, signal_ignore) sleep(duration) if not folded: print() missing_stacks = 0 has_enomem = False counts = b.get_table("counts") stack_traces = b.get_table("stack_traces") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): # handle get_stackid errors # check for an ENOMEM error if k.w_k_stack_id == -errno.ENOMEM or \ k.t_k_stack_id == -errno.ENOMEM or \ k.w_u_stack_id == -errno.ENOMEM or \ k.t_u_stack_id == -errno.ENOMEM: missing_stacks += 1 continue waker_user_stack = [] if k.w_u_stack_id < 1 else \ reversed(list(stack_traces.walk(k.w_u_stack_id))[1:]) waker_kernel_stack = [] if k.w_k_stack_id < 1 else \ reversed(list(stack_traces.walk(k.w_k_stack_id))[1:]) target_user_stack = [] if k.t_u_stack_id < 1 else \ stack_traces.walk(k.t_u_stack_id) target_kernel_stack = [] if k.t_k_stack_id < 1 else \ stack_traces.walk(k.t_k_stack_id) if folded: # print folded stack output line = \ [k.target] + \ [b.sym(addr, k.tgid) for addr in reversed(list(target_user_stack)[1:])] + \ (["-"] if args.delimited else [""]) + \ [b.ksym(addr) for addr in reversed(list(target_kernel_stack)[1:])] + \ ["--"] + \ [b.ksym(addr) for addr in reversed(list(waker_kernel_stack))] + \ (["-"] if args.delimited else [""]) + \ [b.sym(addr, k.tgid) for addr in reversed(list(waker_user_stack))] + \ [k.waker] print("%s %d" % (";".join(line), v.value)) else: # print wakeup name then stack in reverse order print(" %-16s %s %s" % ("waker:", k.waker, k.t_pid)) for addr in waker_user_stack: print(" %s" % b.sym(addr, k.tgid)) if args.delimited: print(" -") for addr in waker_kernel_stack: print(" %s" % b.ksym(addr)) # print waker/wakee delimiter print(" %-16s %s" % ("--", "--")) # print default multi-line stack output for addr in target_kernel_stack: print(" %s" % b.ksym(addr)) if args.delimited: print(" -") for addr in target_user_stack: print(" %s" % b.sym(addr, k.tgid)) print(" %-16s %s %s" % ("target:", k.target, k.w_pid)) print(" %d\n" % v.value) if missing_stacks > 0: enomem_str = " Consider increasing --stack-storage-size." print("WARNING: %d stack traces could not be displayed.%s" % (missing_stacks, enomem_str), file=stderr) bpfcc-0.2.0+git0.02884a026/tools/offwaketime_example.txt000066400000000000000000001121411305314114400224130ustar00rootroot00000000000000Demonstrations of offwaketime, the Linux eBPF/bcc version. This program shows kernel stack traces and task names that were blocked and "off-CPU", along with the stack traces and task names for the threads that woke them, and the total elapsed time from when they blocked to when they were woken up. This combines the summaries from both the offcputime and wakeuptime tools. The time measurement will be very similar to off-CPU time, however, off-CPU time may include a little extra time spent waiting on a run queue to be scheduled. The combined stacks, task names, and total time is summarized in kernel context for efficiency, using an eBPF map. The output summary will further help you identify reasons why threads were blocking, and quantify the time from when they were blocked to woken up. This spans all types of blocking activity: disk I/O, network I/O, locks, page faults, swapping, sleeping, involuntary context switches, etc. Here is some sample output from a 5 second trace, truncated to highlight several stack pairs: # ./offwaketime 5 Tracing blocked time (us) by kernel off-CPU and waker stack for 5 secs. [...] waker: swapper/0 ffffffff8137897c blk_mq_complete_request ffffffff81378930 __blk_mq_complete_request ffffffff81378793 blk_mq_end_request ffffffff813778b9 blk_mq_free_request ffffffff8137782d __blk_mq_free_request ffffffff8137bc57 blk_mq_put_tag ffffffff8137b2c7 bt_clear_tag ffffffff810b54d9 __wake_up ffffffff810b5462 __wake_up_common ffffffff810b5b12 autoremove_wake_function - - ffffffff81785085 schedule ffffffff81787e16 schedule_timeout ffffffff81784634 __sched_text_start ffffffff8137b839 bt_get ffffffff8137bbf7 blk_mq_get_tag ffffffff8137761b __blk_mq_alloc_request ffffffff81379442 blk_mq_map_request ffffffff8137a445 blk_sq_make_request ffffffff8136ebc3 generic_make_request ffffffff8136ed07 submit_bio ffffffff81225adf submit_bh_wbc ffffffff81225b42 submit_bh ffffffff812721e0 __ext4_get_inode_loc ffffffff812751dd ext4_iget ffffffff81275c90 ext4_iget_normal ffffffff8127f45b ext4_lookup ffffffff811f94ed lookup_real ffffffff811fad43 __lookup_hash ffffffff811fc3fb walk_component ffffffff811fd050 link_path_walk target: cksum 56529 [...] waker: swapper/1 ffffffff81475cf0 xen_evtchn_do_upcall ffffffff81473e83 __xen_evtchn_do_upcall ffffffff814766f7 evtchn_2l_handle_events ffffffff810cb0c2 generic_handle_irq ffffffff810cf1ca handle_percpu_irq ffffffff810cb9c8 handle_irq_event_percpu ffffffff8100b9e1 xen_timer_interrupt ffffffff810dfba8 hrtimer_interrupt ffffffff810df494 __hrtimer_run_queues ffffffff810df082 hrtimer_wakeup - - ffffffff81785085 schedule ffffffff817880bf do_nanosleep ffffffff810e003d hrtimer_nanosleep ffffffff810e018c sys_nanosleep ffffffff81789076 entry_SYSCALL_64_fastpath target: vmstat 3000331 [...] waker: swapper/0 ffffffff81378930 __blk_mq_complete_request ffffffff8137875a blk_mq_end_request ffffffff8136f157 blk_update_request ffffffff8136836f bio_endio ffffffff812ba709 mpage_end_io ffffffff81176af9 unlock_page ffffffff810b5781 __wake_up_bit ffffffff810b54d9 __wake_up ffffffff810b5462 __wake_up_common ffffffff810b5b7e wake_bit_function - - ffffffff81785085 schedule ffffffff81787e16 schedule_timeout ffffffff81784634 __sched_text_start ffffffff8178586b bit_wait_io ffffffff8178563e __wait_on_bit_lock ffffffff8117616e __lock_page_killable ffffffff81177fce generic_file_read_iter ffffffff811ef9c7 __vfs_read ffffffff811f0206 vfs_read ffffffff811f0eb6 sys_read ffffffff81789076 entry_SYSCALL_64_fastpath target: cksum 4334521 [...] waker: kworker/u16:2 ffffffff8178940f ret_from_fork ffffffff81092979 kthread ffffffff8108caeb worker_thread ffffffff8108c80a process_one_work ffffffff81496df5 flush_to_ldisc ffffffff81494424 n_tty_receive_buf2 ffffffff814939fd n_tty_receive_buf_common ffffffff810b54d9 __wake_up ffffffff810b5462 __wake_up_common ffffffff812037b6 pollwake - - ffffffff81785085 schedule ffffffff81788234 schedule_hrtimeout_range_clock ffffffff81788253 schedule_hrtimeout_range ffffffff812035d4 poll_schedule_timeout ffffffff8120402a do_select ffffffff812042f0 core_sys_select ffffffff8120449b sys_select ffffffff81789076 entry_SYSCALL_64_fastpath target: sshd 6530897 [...] waker: swapper/0 ffffffff81475cf0 xen_evtchn_do_upcall ffffffff81473e83 __xen_evtchn_do_upcall ffffffff814766f7 evtchn_2l_handle_events ffffffff810cb0c2 generic_handle_irq ffffffff810cf1ca handle_percpu_irq ffffffff810cb9c8 handle_irq_event_percpu ffffffff8100b9e1 xen_timer_interrupt ffffffff810dfba8 hrtimer_interrupt ffffffff810df494 __hrtimer_run_queues ffffffff810df082 hrtimer_wakeup - - ffffffff81785085 schedule ffffffff81787fc3 schedule_hrtimeout_range_clock.part.23 ffffffff81788219 schedule_hrtimeout_range_clock ffffffff81788253 schedule_hrtimeout_range ffffffff812035d4 poll_schedule_timeout ffffffff81204b6d do_sys_poll ffffffff81204cf2 sys_poll ffffffff81789076 entry_SYSCALL_64_fastpath target: supervise 16332240 Detaching... The output includes two paths from the cksum(1) command, one for reading files via vfs_read() and the other doing a link_path_walk(). There is also a vmstat(8) stack showing it sleeping between intervals, and an sshd(8) stack showing it waiting on a file descriptor for input. The stack shown at the bottom is the off-CPU stack belonging to the task name shown after "target:". Then there is a separator, "-", and above it the waker stack and the waker task name after "waker:". The wakeup stack is printed in reverse order. The number beneath the stacks is the total time spent from the blocking event to the wakeup event. This is summed for all occurances with the same stack pairs. The -u option will print user-mode target threads only, and the -f option will show the stacks in "folded stacks" format. Eg: # ./offwaketime -fu 5 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;ext4_truncate;ext4_ext_truncate;ext4_ext_remove_space;ext4_free_blocks;__ext4_handle_dirty_metadata;_cond_resched;preempt_schedule_common;-; 2 sshd;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;tty_read;n_tty_read;down_read;_cond_resched;preempt_schedule_common;-; 2 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_iget_normal;ext4_iget;iget_locked;alloc_inode;ext4_alloc_inode;kmem_cache_alloc;_cond_resched;preempt_schedule_common;-; 3 mkdir;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;anon_vma_prepare;_cond_resched;preempt_schedule_common;-; 3 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;link_path_walk;walk_component;__lookup_hash;lookup_real;ext4_lookup;ext4_iget_normal;ext4_iget;__ext4_get_inode_loc;__breadahead;ll_rw_block;submit_bh_wbc;bio_alloc_bioset;mempool_alloc;_cond_resched;preempt_schedule_common;-; 3 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;page_cache_sync_readahead;ondemand_readahead;__do_page_cache_readahead;ext4_readpages;ext4_mpage_readpages;ext4_map_blocks;down_read;_cond_resched;preempt_schedule_common;-; 3 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;fd_install;__fd_install;_cond_resched;preempt_schedule_common;-; 3 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;elf_map;vm_munmap;down_write;_cond_resched;preempt_schedule_common;-; 3 svscan;entry_SYSCALL_64_fastpath;sys_getdents;iterate_dir;ext4_readdir;ext4_htree_fill_tree;htree_dirblock_to_tree;ext4_htree_store_dirent;__kmalloc;_cond_resched;preempt_schedule_common;-; 4 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;mutex_lock;_cond_resched;preempt_schedule_common;-; 4 run;entry_SYSCALL_64_fastpath;sys_mprotect;down_write;_cond_resched;preempt_schedule_common;-; 5 sshd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;_cond_resched;preempt_schedule_common;-; 5 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;set_brk;vm_brk;down_write;_cond_resched;preempt_schedule_common;-; 5 supervise;entry_SYSCALL_64_fastpath;sys_clone;_do_fork;copy_process;anon_vma_fork;anon_vma_clone;down_write;_cond_resched;preempt_schedule_common;-; 6 svscan;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;swapper/0 11 supervise;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;flush_old_exec;mmput;exit_mmap;free_pgtables;unlink_anon_vmas;down_write;_cond_resched;preempt_schedule_common;-; 12 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_elf_binary;flush_old_exec;mmput;_cond_resched;preempt_schedule_common;-; 13 sshd;entry_SYSCALL_64_fastpath;sys_write;vfs_write;__vfs_write;sock_write_iter;sock_sendmsg;inet_sendmsg;tcp_sendmsg;lock_sock_nested;_cond_resched;preempt_schedule_common;-; 14 cksum;entry_SYSCALL_64_fastpath;sys_write;vfs_write;__vfs_write;tty_write;n_tty_write;mutex_lock;_cond_resched;preempt_schedule_common;-; 19 sshd;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-; 24 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;vm_brk;down_write;_cond_resched;preempt_schedule_common;-; 31 sshd;entry_SYSCALL_64_fastpath;sys_write;vfs_write;__vfs_write;sock_write_iter;sock_sendmsg;inet_sendmsg;tcp_sendmsg;sk_stream_alloc_skb;__alloc_skb;kmem_cache_alloc_node;_cond_resched;preempt_schedule_common;-; 32 run;page_fault;do_page_fault;__do_page_fault;_cond_resched;preempt_schedule_common;-; 33 run;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;anon_vma_prepare;_cond_resched;preempt_schedule_common;-; 33 run;entry_SYSCALL_64_fastpath;sys_clone;_do_fork;copy_process;down_write;_cond_resched;preempt_schedule_common;-; 35 run;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;__do_fault;filemap_fault;_cond_resched;preempt_schedule_common;-; 36 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;elf_map;vm_mmap;vm_mmap_pgoff;down_write;_cond_resched;preempt_schedule_common;-; 38 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_iget_normal;ext4_iget;__ext4_get_inode_loc;__getblk_gfp;_cond_resched;preempt_schedule_common;-; 38 chmod;int_ret_from_sys_call;syscall_return_slowpath;exit_to_usermode_loop;schedule;-; 39 run;entry_SYSCALL_64_fastpath;sys_munmap;vm_munmap;do_munmap;unmap_region;unmap_vmas;unmap_single_vma;_cond_resched;preempt_schedule_common;-; 41 readproctitle;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;pipe_read;mutex_lock;_cond_resched;preempt_schedule_common;-; 44 run;entry_SYSCALL_64_fastpath;sys_clone;_do_fork;copy_process;kmem_cache_alloc;_cond_resched;preempt_schedule_common;-; 48 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_elf_binary;flush_old_exec;mmput;exit_mmap;unmap_vmas;unmap_single_vma;_cond_resched;preempt_schedule_common;-; 49 sshd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;tty_poll;tty_ldisc_ref_wait;ldsem_down_read;_cond_resched;preempt_schedule_common;-; 50 supervise;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;remove_arg_zero;get_user_pages;__get_user_pages;_cond_resched;preempt_schedule_common;-; 50 readproctitle;int_ret_from_sys_call;syscall_return_slowpath;exit_to_usermode_loop;schedule;-; 51 mkdir;int_ret_from_sys_call;syscall_return_slowpath;exit_to_usermode_loop;schedule;-; 53 supervise;entry_SYSCALL_64_fastpath;sys_clone;_do_fork;copy_process;copy_creds;prepare_creds;kmem_cache_alloc;_cond_resched;preempt_schedule_common;-; 66 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_find_entry;__ext4_read_dirblock;ext4_bread;ext4_getblk;__getblk_gfp;_cond_resched;preempt_schedule_common;-; 76 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_elf_binary;kernel_read;vfs_read;__vfs_read;generic_file_read_iter;_cond_resched;preempt_schedule_common;-; 96 chmod;entry_SYSCALL_64_fastpath;sys_exit_group;do_group_exit;do_exit;mmput;exit_mmap;unmap_vmas;unmap_single_vma;_cond_resched;preempt_schedule_common;-; 100 run;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;__do_fault;filemap_fault;__lock_page_or_retry;wait_on_page_bit_killable;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;handle_mm_fault;__do_page_fault;do_page_fault;page_fault;;run 117 run;entry_SYSCALL_64_fastpath;sys_clone;_do_fork;copy_process;copy_page_range;_cond_resched;preempt_schedule_common;-; 117 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;_cond_resched;preempt_schedule_common;-; 121 chown;entry_SYSCALL_64_fastpath;sys_mmap;sys_mmap_pgoff;vm_mmap_pgoff;down_write;_cond_resched;preempt_schedule_common;-; 137 chown;entry_SYSCALL_64_fastpath;sys_mmap;sys_mmap_pgoff;vm_mmap_pgoff;do_mmap;mmap_region;kmem_cache_alloc;_cond_resched;preempt_schedule_common;-; 138 run;return_from_execve;sys_execve;do_execveat_common.isra.33;count.isra.21.constprop.38;_cond_resched;preempt_schedule_common;-; 145 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;truncate_inode_pages_final;truncate_inode_pages_range;wait_on_page_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;end_page_writeback;ext4_finish_bio;ext4_end_bio;bio_endio;blk_update_request;blk_mq_end_request;mkdir 147 chmod;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_elf_binary;clear_user;page_fault;do_page_fault;__do_page_fault;_cond_resched;preempt_schedule_common;-; 159 chown;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_elf_binary;setup_arg_pages;shift_arg_pages;vma_adjust;down_write;_cond_resched;preempt_schedule_common;-; 173 chown;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-; 176 chmod;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-; 191 chmod;entry_SYSCALL_64_fastpath;sys_fchmodat;chmod_common;notify_change;ext4_setattr;__mark_inode_dirty;ext4_dirty_inode;ext4_mark_inode_dirty;ext4_reserve_inode_write;__ext4_get_inode_loc;__getblk_gfp;_cond_resched;preempt_schedule_common;-; 221 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;trailing_symlink;page_follow_link_light;page_getlink.isra.34.constprop.38;read_cache_page;do_read_cache_page;wait_on_page_read;wait_on_page_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;swapper/0 230 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_find_entry;__ext4_read_dirblock;ext4_bread;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;rcu_sched 231 supervise;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;flush_old_exec;mmput;_cond_resched;preempt_schedule_common;-; 234 chown;int_ret_from_sys_call;syscall_return_slowpath;exit_to_usermode_loop;schedule;-; 249 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;svscan 273 mkdir;entry_SYSCALL_64_fastpath;sys_exit_group;do_group_exit;do_exit;mmput;exit_mmap;unmap_vmas;unmap_single_vma;_cond_resched;preempt_schedule_common;-; 382 supervise;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;flush_old_exec;mmput;exit_mmap;unmap_vmas;unmap_single_vma;_cond_resched;preempt_schedule_common;-; 389 run;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;do_wp_page;wp_page_copy.isra.57;anon_vma_prepare;_cond_resched;preempt_schedule_common;-; 390 supervise;return_from_execve;sys_execve;do_execveat_common.isra.33;sched_exec;stop_one_cpu;wait_for_completion;_cond_resched;preempt_schedule_common;-; 409 run;return_from_execve;sys_execve;do_execveat_common.isra.33;sched_exec;stop_one_cpu;wait_for_completion;_cond_resched;preempt_schedule_common;-; 419 mkdir;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-; 457 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;rcuos/0 460 run;entry_SYSCALL_64_fastpath;sys_exit_group;do_group_exit;do_exit;mmput;exit_mmap;unmap_vmas;unmap_single_vma;_cond_resched;preempt_schedule_common;-; 481 sshd;int_ret_from_sys_call;syscall_return_slowpath;exit_to_usermode_loop;schedule;-; 495 cksum;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_find_entry;dx_probe;__ext4_read_dirblock;ext4_bread;ext4_getblk;ext4_map_blocks;ext4_ext_map_blocks;ext4_find_extent;__read_extent_tree_block;bh_submit_read;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;swapper/0 495 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_find_entry;dx_probe;__ext4_read_dirblock;ext4_bread;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;swapper/0 514 run;entry_SYSCALL_64_fastpath;sys_clone;_do_fork;copy_process;alloc_pid;kmem_cache_alloc;_cond_resched;preempt_schedule_common;-; 572 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_script;search_binary_handler;load_elf_binary;clear_user;page_fault;do_page_fault;__do_page_fault;handle_mm_fault;__pte_alloc;pte_alloc_one;alloc_pages_current;__alloc_pages_nodemask;_cond_resched;preempt_schedule_common;-; 579 supervise;entry_SYSCALL_64_fastpath;sys_clone;_do_fork;copy_process;copy_page_range;_cond_resched;preempt_schedule_common;-; 590 cksum;int_ret_from_sys_call;syscall_return_slowpath;exit_to_usermode_loop;schedule;-; 592 chmod;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_elf_binary;setup_arg_pages;shift_arg_pages;vma_adjust;down_write;_cond_resched;preempt_schedule_common;-; 697 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_find_entry;__ext4_read_dirblock;ext4_bread;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;swapper/0 706 cksum;entry_SYSCALL_64_fastpath;sys_write;vfs_write;__vfs_write;tty_write;n_tty_write;mutex_lock;_cond_resched;preempt_schedule_common;-;woken_wake_function;__wake_up_common;__wake_up;n_tty_read;tty_read;__vfs_read;vfs_read;sys_read;entry_SYSCALL_64_fastpath;;sshd 804 supervise;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-; 1101 run;return_from_execve;sys_execve;do_execveat_common.isra.33;search_binary_handler;load_elf_binary;flush_old_exec;mmput;exit_mmap;free_pgtables;unlink_anon_vmas;__put_anon_vma;_cond_resched;preempt_schedule_common;-; 1122 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;readproctitle 1319 run;int_ret_from_sys_call;syscall_return_slowpath;exit_to_usermode_loop;schedule;-; 1902 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;chown 1925 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;truncate_inode_pages_final;truncate_inode_pages_range;wait_on_page_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;end_page_writeback;ext4_finish_bio;ext4_end_bio;bio_endio;blk_update_request;blk_mq_end_request;cksum 2181 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;link_path_walk;walk_component;__lookup_hash;lookup_real;ext4_lookup;ext4_find_entry;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;swapper/0 2599 cksum;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-; 2816 supervise;ext4_rename2;ext4_rename;ext4_alloc_da_blocks;filemap_flush;__filemap_fdatawrite_range;do_writepages;ext4_writepages;ext4_map_blocks;ext4_ext_map_blocks;ext4_mb_new_blocks;ext4_mb_mark_diskspace_used;__ext4_journal_get_write_access;jbd2_journal_get_write_access;do_get_write_access;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;journal_end_buffer_io_sync;end_bio_bh_io_sync;bio_endio;blk_update_request;blk_mq_end_request;swapper/0 3393 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;truncate_inode_pages_final;truncate_inode_pages_range;wait_on_page_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;end_page_writeback;ext4_finish_bio;ext4_end_bio;bio_endio;blk_update_request;blk_mq_end_request;supervise 5398 sshd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule;-;pollwake;__wake_up_common;__wake_up_sync_key;sock_def_readable;tcp_data_queue;tcp_rcv_established;tcp_v4_do_rcv;tcp_v4_rcv;ip_local_deliver_finish;ip_local_deliver;mkdir 6582 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;chmod 8310 run;retint_user;prepare_exit_to_usermode;exit_to_usermode_loop;schedule;-; 8444 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;truncate_inode_pages_final;truncate_inode_pages_range;wait_on_page_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;end_page_writeback;ext4_finish_bio;ext4_end_bio;bio_endio;blk_update_request;blk_mq_end_request;readproctitle 9768 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;truncate_inode_pages_final;truncate_inode_pages_range;wait_on_page_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;end_page_writeback;ext4_finish_bio;ext4_end_bio;bio_endio;blk_update_request;blk_mq_end_request;run 9945 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;mkdir 11978 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;link_path_walk;walk_component;__lookup_hash;lookup_real;ext4_lookup;ext4_iget_normal;ext4_iget;__ext4_get_inode_loc;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;swapper/0 12120 cksum;link_path_walk;walk_component;__lookup_hash;lookup_real;ext4_lookup;ext4_iget_normal;ext4_iget;__ext4_get_inode_loc;submit_bh;submit_bh_wbc;submit_bio;generic_make_request;blk_sq_make_request;blk_mq_map_request;__blk_mq_alloc_request;blk_mq_get_tag;bt_get;__sched_text_start;schedule_timeout;schedule;-;autoremove_wake_function;__wake_up_common;__wake_up;bt_clear_tag;blk_mq_put_tag;__blk_mq_free_request;blk_mq_free_request;blk_mq_end_request;__blk_mq_complete_request;blk_mq_complete_request;swapper/0 23243 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_find_entry;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;swapper/0 24767 run;entry_SYSCALL_64_fastpath;sys_wait4;do_wait;schedule;-;child_wait_callback;__wake_up_common;__wake_up_sync_key;__wake_up_parent;do_notify_parent;do_exit;do_group_exit;sys_exit_group;entry_SYSCALL_64_fastpath;;chmod 33289 run;entry_SYSCALL_64_fastpath;sys_wait4;do_wait;schedule;-;child_wait_callback;__wake_up_common;__wake_up_sync_key;__wake_up_parent;do_notify_parent;do_exit;do_group_exit;sys_exit_group;entry_SYSCALL_64_fastpath;;mkdir 34991 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;supervise 35746 run;entry_SYSCALL_64_fastpath;sys_wait4;do_wait;schedule;-;child_wait_callback;__wake_up_common;__wake_up_sync_key;__wake_up_parent;do_notify_parent;do_exit;do_group_exit;sys_exit_group;entry_SYSCALL_64_fastpath;;chown 36942 supervise;entry_SYSCALL_64_fastpath;sys_rename;dput;__dentry_kill;iput;evict;ext4_evict_inode;truncate_inode_pages_final;truncate_inode_pages_range;wait_on_page_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;end_page_writeback;ext4_finish_bio;ext4_end_bio;bio_endio;blk_update_request;blk_mq_end_request;swapper/0 42993 cksum;entry_SYSCALL_64_fastpath;sys_open;do_sys_open;do_filp_open;path_openat;lookup_real;ext4_lookup;ext4_iget_normal;ext4_iget;__ext4_get_inode_loc;__wait_on_buffer;out_of_line_wait_on_bit;__wait_on_bit;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;wake_up_bit;unlock_buffer;__end_buffer_read_notouch;end_buffer_read_sync;end_bio_bh_io_sync;bio_endio;swapper/0 53348 sshd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule;-;pollwake;__wake_up_common;__wake_up;n_tty_receive_buf_common;n_tty_receive_buf2;flush_to_ldisc;process_one_work;worker_thread;kthread;ret_from_fork;kworker/u16:2 86256 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;run 109480 ntpd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule;-;signal_wake_up_state;complete_signal;__send_signal;send_signal;do_send_sig_info;group_send_sig_info;kill_pid_info;it_real_fn;__hrtimer_run_queues;hrtimer_interrupt;cksum 999975 ntpd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule;-;signal_wake_up_state;complete_signal;__send_signal;send_signal;do_send_sig_info;group_send_sig_info;kill_pid_info;it_real_fn;__hrtimer_run_queues;hrtimer_interrupt;swapper/0 999976 supervise;entry_SYSCALL_64_fastpath;sys_poll;do_sys_poll;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule_hrtimeout_range_clock.part.23;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;chmod 1021082 snmpd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule_hrtimeout_range_clock.part.23;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;swapper/0 1726275 ntpd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule;-;signal_wake_up_state;complete_signal;__send_signal;send_signal;do_send_sig_info;group_send_sig_info;kill_pid_info;it_real_fn;__hrtimer_run_queues;hrtimer_interrupt;swapper/1 1999944 supervise;entry_SYSCALL_64_fastpath;sys_poll;do_sys_poll;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule_hrtimeout_range_clock.part.23;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;cksum 2041945 cksum;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;generic_file_read_iter;__lock_page_killable;__wait_on_bit_lock;bit_wait_io;__sched_text_start;schedule_timeout;schedule;-;wake_bit_function;__wake_up_common;__wake_up;__wake_up_bit;unlock_page;mpage_end_io;bio_endio;blk_update_request;blk_mq_end_request;__blk_mq_complete_request;swapper/0 3720413 vmstat;entry_SYSCALL_64_fastpath;sys_nanosleep;hrtimer_nanosleep;do_nanosleep;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;swapper/0 4000402 tail;entry_SYSCALL_64_fastpath;sys_nanosleep;hrtimer_nanosleep;do_nanosleep;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;swapper/0 4000447 readproctitle;entry_SYSCALL_64_fastpath;sys_read;vfs_read;__vfs_read;pipe_read;pipe_wait;schedule;-;autoremove_wake_function;__wake_up_common;__wake_up_sync_key;pipe_write;__vfs_write;vfs_write;sys_write;entry_SYSCALL_64_fastpath;;run 4149862 offwaketime.py;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule_hrtimeout_range_clock.part.23;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;swapper/1 5005058 supervise;entry_SYSCALL_64_fastpath;sys_poll;do_sys_poll;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule_hrtimeout_range_clock.part.23;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;swapper/1 8168600 sshd;entry_SYSCALL_64_fastpath;sys_select;core_sys_select;do_select;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule;-;pollwake;__wake_up_common;__wake_up;n_tty_receive_buf_common;n_tty_receive_buf2;flush_to_ldisc;process_one_work;worker_thread;kthread;ret_from_fork;kworker/u16:1 8821767 supervise;entry_SYSCALL_64_fastpath;sys_poll;do_sys_poll;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule_hrtimeout_range_clock.part.23;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;run 9186846 supervise;entry_SYSCALL_64_fastpath;sys_poll;do_sys_poll;poll_schedule_timeout;schedule_hrtimeout_range;schedule_hrtimeout_range_clock;schedule_hrtimeout_range_clock.part.23;schedule;-;hrtimer_wakeup;__hrtimer_run_queues;hrtimer_interrupt;xen_timer_interrupt;handle_irq_event_percpu;handle_percpu_irq;generic_handle_irq;evtchn_2l_handle_events;__xen_evtchn_do_upcall;xen_evtchn_do_upcall;swapper/0 20415299 This output format is suitable for feeding into the open source FlameGraph software, which visualizes these. USAGE message: # ./offwaketime -h usage: offwaketime [-h] [-p PID | -t TID | -u | -k] [-U | -K] [-d] [-f] [--stack-storage-size STACK_STORAGE_SIZE] [-m MIN_BLOCK_TIME] [-M MAX_BLOCK_TIME] [duration] Summarize blocked time by kernel stack trace + waker stack positional arguments: duration duration of trace, in seconds optional arguments: -h, --help show this help message and exit -p PID, --pid PID trace this PID only -t TID, --tid TID trace this TID only -u, --user-threads-only user threads only (no kernel threads) -k, --kernel-threads-only kernel threads only (no user threads) -U, --user-stacks-only show stacks from user space only (no kernel space stacks) -K, --kernel-stacks-only show stacks from kernel space only (no user space stacks) -d, --delimited insert delimiter between kernel/user stacks -f, --folded output folded format --stack-storage-size STACK_STORAGE_SIZE the number of unique stack traces that can be stored and displayed (default 1024) -m MIN_BLOCK_TIME, --min-block-time MIN_BLOCK_TIME the amount of time in microseconds over which we store traces (default 1) -M MAX_BLOCK_TIME, --max-block-time MAX_BLOCK_TIME the amount of time in microseconds under which we store traces (default U64_MAX) examples: ./offwaketime # trace off-CPU + waker stack time until Ctrl-C ./offcputime 5 # trace for 5 seconds only ./offcputime -f 5 # 5 seconds, and output in folded format ./offcputime -m 1000 # trace only events that last more than 1000 usec ./offcputime -M 10000 # trace only events that last less than 10000 usec ./offcputime -p 185 # only trace threads for PID 185 ./offcputime -t 188 # only trace thread 188 ./offcputime -u # only trace user threads (no kernel) ./offcputime -k # only trace kernel threads (no user) ./offcputime -U # only show user space stacks (no kernel) ./offcputime -K # only show kernel space stacks (no user) bpfcc-0.2.0+git0.02884a026/tools/old/000077500000000000000000000000001305314114400164145ustar00rootroot00000000000000bpfcc-0.2.0+git0.02884a026/tools/old/CMakeLists.txt000066400000000000000000000002731305314114400211560ustar00rootroot00000000000000file(GLOB PY_FILES *.py) foreach(FIL ${PY_FILES}) get_filename_component(FIL_WE ${FIL} NAME_WE) install(PROGRAMS ${FIL} DESTINATION share/bcc/tools/old RENAME ${FIL_WE}) endforeach() bpfcc-0.2.0+git0.02884a026/tools/old/bashreadline.py000077500000000000000000000020751305314114400214160ustar00rootroot00000000000000#!/usr/bin/python # # bashreadline Print entered bash commands from all running shells. # For Linux, uses BCC, eBPF. Embedded C. # # This works by tracing the readline() function using a uretprobe (uprobes). # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 28-Jan-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import strftime # load BPF program bpf_text = """ #include int printret(struct pt_regs *ctx) { if (!ctx->ax) return 0; char str[80] = {}; bpf_probe_read(&str, sizeof(str), (void *)ctx->ax); bpf_trace_printk("%s\\n", &str); return 0; }; """ b = BPF(text=bpf_text) b.attach_uretprobe(name="/bin/bash", sym="readline", fn_name="printret") # header print("%-9s %-6s %s" % ("TIME", "PID", "COMMAND")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue print("%-9s %-6d %s" % (strftime("%H:%M:%S"), pid, msg)) bpfcc-0.2.0+git0.02884a026/tools/old/biosnoop.py000077500000000000000000000065301305314114400206250ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # biosnoop Trace block device I/O and print details including issuing PID. # For Linux, uses BCC, eBPF. # # This uses in-kernel eBPF maps to cache process details (PID and comm) by I/O # request, as well as a starting timestamp for calculating I/O latency. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 16-Sep-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF # load BPF program b = BPF(text=""" #include #include struct val_t { u32 pid; char name[TASK_COMM_LEN]; }; BPF_HASH(start, struct request *); BPF_HASH(infobyreq, struct request *, struct val_t); // cache PID and comm by-req int trace_pid_start(struct pt_regs *ctx, struct request *req) { struct val_t val = {}; if (bpf_get_current_comm(&val.name, sizeof(val.name)) == 0) { val.pid = bpf_get_current_pid_tgid(); infobyreq.update(&req, &val); } return 0; } // time block I/O int trace_req_start(struct pt_regs *ctx, struct request *req) { u64 ts; ts = bpf_ktime_get_ns(); start.update(&req, &ts); return 0; } // output int trace_req_completion(struct pt_regs *ctx, struct request *req) { u64 *tsp, delta; u32 *pidp = 0; struct val_t *valp; // fetch timestamp and calculate delta tsp = start.lookup(&req); if (tsp == 0) { // missed tracing issue return 0; } delta = bpf_ktime_get_ns() - *tsp; // // Fetch and output issuing pid and comm. // As bpf_trace_prink() is limited to a maximum of 1 string and 2 // integers, we'll use more than one to output the data. // valp = infobyreq.lookup(&req); if (valp == 0) { bpf_trace_printk("0 0 ? %d\\n", req->__data_len); } else { bpf_trace_printk("0 %d %s %d\\n", valp->pid, valp->name, req->__data_len); } // output remaining details if (req->cmd_flags & REQ_WRITE) { bpf_trace_printk("1 W %s %d %d ?\\n", req->rq_disk->disk_name, req->__sector, delta / 1000); } else { bpf_trace_printk("1 R %s %d %d ?\\n", req->rq_disk->disk_name, req->__sector, delta / 1000); } start.delete(&req); infobyreq.delete(&req); return 0; } """, debug=0) b.attach_kprobe(event="blk_account_io_start", fn_name="trace_pid_start") b.attach_kprobe(event="blk_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_mq_start_request", fn_name="trace_req_start") b.attach_kprobe(event="blk_account_io_completion", fn_name="trace_req_completion") # header print("%-14s %-14s %-6s %-7s %-2s %-9s %-7s %7s" % ("TIME(s)", "COMM", "PID", "DISK", "T", "SECTOR", "BYTES", "LAT(ms)")) start_ts = 0 # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() args = msg.split(" ") if start_ts == 0: start_ts = ts if args[0] == "0": (real_pid, real_comm, bytes_s) = (args[1], args[2], args[3]) continue else: (type_s, disk_s, sector_s, us_s) = (args[1], args[2], args[3], args[4]) ms = float(int(us_s, 10)) / 1000 print("%-14.9f %-14.14s %-6s %-7s %-2s %-9s %-7s %7.2f" % ( ts - start_ts, real_comm, real_pid, disk_s, type_s, sector_s, bytes_s, ms)) bpfcc-0.2.0+git0.02884a026/tools/old/filelife.py000077500000000000000000000051641305314114400205560ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # filelife Trace the lifespan of short-lived files. # For Linux, uses BCC, eBPF. Embedded C. # # This traces the creation and deletion of files, providing information # on who deleted the file, the file age, and the file name. The intent is to # provide information on short-lived files, for debugging or performance # analysis. # # USAGE: filelife [-h] [-p PID] # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 08-Feb-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse from time import strftime # arguments examples = """examples: ./filelife # trace all stat() syscalls ./filelife -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace stat() syscalls", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include #include BPF_HASH(birth, struct dentry *); // trace file creation time int trace_create(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { u32 pid = bpf_get_current_pid_tgid(); FILTER u64 ts = bpf_ktime_get_ns(); birth.update(&dentry, &ts); return 0; }; // trace file deletion and output details int trace_unlink(struct pt_regs *ctx, struct inode *dir, struct dentry *dentry) { u32 pid = bpf_get_current_pid_tgid(); FILTER u64 *tsp, delta; tsp = birth.lookup(&dentry); if (tsp == 0) { return 0; // missed create } delta = (bpf_ktime_get_ns() - *tsp) / 1000000; birth.delete(&dentry); if (dentry->d_iname[0] == 0) return 0; bpf_trace_printk("%d %s\\n", delta, dentry->d_iname); return 0; } """ if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="vfs_create", fn_name="trace_create") b.attach_kprobe(event="vfs_unlink", fn_name="trace_unlink") # header print("%-8s %-6s %-16s %-7s %s" % ("TIME", "PID", "COMM", "AGE(s)", "FILE")) start_ts = 0 # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (delta, filename) = msg.split(" ", 1) # print columns print("%-8s %-6d %-16s %-7.2f %s" % (strftime("%H:%M:%S"), pid, task, float(delta) / 1000, filename)) bpfcc-0.2.0+git0.02884a026/tools/old/gethostlatency.py000077500000000000000000000043461305314114400220350ustar00rootroot00000000000000#!/usr/bin/python # # gethostlatency Show latency for getaddrinfo/gethostbyname[2] calls. # For Linux, uses BCC, eBPF. Embedded C. # # This can be useful for identifying DNS latency, by identifying which # remote host name lookups were slow, and by how much. # # This uses dynamic tracing of user-level functions and registers, and may # need modifications to match your software and processor architecture. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 28-Jan-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import strftime # load BPF program bpf_text = """ #include struct val_t { char host[80]; u64 ts; }; BPF_HASH(start, u32, struct val_t); int do_entry(struct pt_regs *ctx) { if (!ctx->di) return 0; struct val_t val = {}; u32 pid = bpf_get_current_pid_tgid(); bpf_probe_read(&val.host, sizeof(val.host), (void *)ctx->di); val.ts = bpf_ktime_get_ns(); start.update(&pid, &val); return 0; } int do_return(struct pt_regs *ctx) { struct val_t *valp; u64 delta; u32 pid = bpf_get_current_pid_tgid(); valp = start.lookup(&pid); if (valp == 0) return 0; // missed start delta = (bpf_ktime_get_ns() - valp->ts) / 1000; bpf_trace_printk("%d %s\\n", delta, valp->host); start.delete(&pid); return 0; } """ b = BPF(text=bpf_text) b.attach_uprobe(name="c", sym="getaddrinfo", fn_name="do_entry") b.attach_uprobe(name="c", sym="gethostbyname", fn_name="do_entry") b.attach_uprobe(name="c", sym="gethostbyname2", fn_name="do_entry") b.attach_uretprobe(name="c", sym="getaddrinfo", fn_name="do_return") b.attach_uretprobe(name="c", sym="gethostbyname", fn_name="do_return") b.attach_uretprobe(name="c", sym="gethostbyname2", fn_name="do_return") # header print("%-9s %-6s %-12s %6s %s" % ("TIME", "PID", "COMM", "LATms", "HOST")) # format output while 1: try: (task, pid, cpu, flags, ts, msg) = b.trace_fields() except ValueError: continue (delta, host) = msg.split(" ") deltams = int(delta) / 1000 print("%-9s %-6d %-12.12s %6.2f %s" % (strftime("%H:%M:%S"), pid, task, deltams, host)) bpfcc-0.2.0+git0.02884a026/tools/old/killsnoop.py000077500000000000000000000052241305314114400210060ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # killsnoop Trace signals issued by the kill() syscall. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: killsnoop [-h] [-t] [-x] [-p PID] # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Sep-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse # arguments examples = """examples: ./killsnoop # trace all kill() signals ./killsnoop -t # include timestamps ./killsnoop -x # only show failed kills ./killsnoop -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace signals issued by the kill() syscall", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-t", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-x", "--failed", action="store_true", help="only show failed opens") parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include BPF_HASH(args_pid, u32, int); BPF_HASH(args_sig, u32, int); int kprobe__sys_kill(struct pt_regs *ctx, int tpid, int sig) { u32 pid = bpf_get_current_pid_tgid(); FILTER args_pid.update(&pid, &tpid); args_sig.update(&pid, &sig); return 0; }; int kretprobe__sys_kill(struct pt_regs *ctx) { int *tpidp, *sigp, ret = ctx->ax; u32 pid = bpf_get_current_pid_tgid(); tpidp = args_pid.lookup(&pid); sigp = args_sig.lookup(&pid); if (tpidp == 0 || sigp == 0) { return 0; // missed entry } bpf_trace_printk("%d %d %d\\n", *tpidp, *sigp, ret); args_pid.delete(&pid); args_sig.delete(&pid); return 0; } """ if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) # header if args.timestamp: print("%-14s" % ("TIME(s)"), end="") print("%-6s %-16s %-4s %-6s %s" % ("PID", "COMM", "SIG", "TPID", "RESULT")) start_ts = 0 # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (tpid_s, sig_s, ret_s) = msg.split(" ") ret = int(ret_s) if (args.failed and (ret >= 0)): continue # print columns if args.timestamp: if start_ts == 0: start_ts = ts print("%-14.9f" % (ts - start_ts), end="") print("%-6d %-16s %-4s %-6s %s" % (pid, task, sig_s, tpid_s, ret_s)) bpfcc-0.2.0+git0.02884a026/tools/old/memleak.py000077500000000000000000000236641305314114400204170ustar00rootroot00000000000000#!/usr/bin/env python # # memleak Trace and display outstanding allocations to detect # memory leaks in user-mode processes and the kernel. # # USAGE: memleak [-h] [-p PID] [-t] [-a] [-o OLDER] [-c COMMAND] # [-s SAMPLE_RATE] [-d STACK_DEPTH] [-T TOP] [-z MIN_SIZE] # [-Z MAX_SIZE] # [interval] [count] # # Licensed under the Apache License, Version 2.0 (the "License") # Copyright (C) 2016 Sasha Goldshtein. from bcc import BPF from time import sleep from datetime import datetime import argparse import subprocess import os def decode_stack(bpf, pid, info): stack = "" if info.num_frames <= 0: return "???" for i in range(0, info.num_frames): addr = info.callstack[i] stack += " %s ;" % bpf.sym(addr, pid, show_offset=True) return stack def run_command_get_output(command): p = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT) return iter(p.stdout.readline, b'') def run_command_get_pid(command): p = subprocess.Popen(command.split()) return p.pid examples = """ EXAMPLES: ./memleak -p $(pidof allocs) Trace allocations and display a summary of "leaked" (outstanding) allocations every 5 seconds ./memleak -p $(pidof allocs) -t Trace allocations and display each individual call to malloc/free ./memleak -ap $(pidof allocs) 10 Trace allocations and display allocated addresses, sizes, and stacks every 10 seconds for outstanding allocations ./memleak -c "./allocs" Run the specified command and trace its allocations ./memleak Trace allocations in kernel mode and display a summary of outstanding allocations every 5 seconds ./memleak -o 60000 Trace allocations in kernel mode and display a summary of outstanding allocations that are at least one minute (60 seconds) old ./memleak -s 5 Trace roughly every 5th allocation, to reduce overhead """ description = """ Trace outstanding memory allocations that weren't freed. Supports both user-mode allocations made with malloc/free and kernel-mode allocations made with kmalloc/kfree. """ parser = argparse.ArgumentParser(description=description, formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", type=int, default=-1, help="the PID to trace; if not specified, trace kernel allocs") parser.add_argument("-t", "--trace", action="store_true", help="print trace messages for each alloc/free call") parser.add_argument("interval", nargs="?", default=5, type=int, help="interval in seconds to print outstanding allocations") parser.add_argument("count", nargs="?", type=int, help="number of times to print the report before exiting") parser.add_argument("-a", "--show-allocs", default=False, action="store_true", help="show allocation addresses and sizes as well as call stacks") parser.add_argument("-o", "--older", default=500, type=int, help="prune allocations younger than this age in milliseconds") parser.add_argument("-c", "--command", help="execute and trace the specified command") parser.add_argument("-s", "--sample-rate", default=1, type=int, help="sample every N-th allocation to decrease the overhead") parser.add_argument("-d", "--stack-depth", default=10, type=int, help="maximum stack depth to capture") parser.add_argument("-T", "--top", type=int, default=10, help="display only this many top allocating stacks (by size)") parser.add_argument("-z", "--min-size", type=int, help="capture only allocations larger than this size") parser.add_argument("-Z", "--max-size", type=int, help="capture only allocations smaller than this size") args = parser.parse_args() pid = args.pid command = args.command kernel_trace = (pid == -1 and command is None) trace_all = args.trace interval = args.interval min_age_ns = 1e6 * args.older sample_every_n = args.sample_rate num_prints = args.count max_stack_size = args.stack_depth + 2 top_stacks = args.top min_size = args.min_size max_size = args.max_size if min_size is not None and max_size is not None and min_size > max_size: print("min_size (-z) can't be greater than max_size (-Z)") exit(1) if command is not None: print("Executing '%s' and tracing the resulting process." % command) pid = run_command_get_pid(command) bpf_source = """ #include struct alloc_info_t { u64 size; u64 timestamp_ns; int num_frames; u64 callstack[MAX_STACK_SIZE]; }; BPF_HASH(sizes, u64); BPF_HASH(allocs, u64, struct alloc_info_t); // Adapted from https://github.com/iovisor/bcc/tools/offcputime.py static u64 get_frame(u64 *bp) { if (*bp) { // The following stack walker is x86_64 specific u64 ret = 0; if (bpf_probe_read(&ret, sizeof(ret), (void *)(*bp+8))) return 0; if (bpf_probe_read(bp, sizeof(*bp), (void *)*bp)) *bp = 0; return ret; } return 0; } static int grab_stack(struct pt_regs *ctx, struct alloc_info_t *info) { int depth = 0; u64 bp = ctx->bp; GRAB_ONE_FRAME return depth; } int alloc_enter(struct pt_regs *ctx, size_t size) { SIZE_FILTER if (SAMPLE_EVERY_N > 1) { u64 ts = bpf_ktime_get_ns(); if (ts % SAMPLE_EVERY_N != 0) return 0; } u64 pid = bpf_get_current_pid_tgid(); u64 size64 = size; sizes.update(&pid, &size64); if (SHOULD_PRINT) bpf_trace_printk("alloc entered, size = %u\\n", size); return 0; } int alloc_exit(struct pt_regs *ctx) { u64 address = ctx->ax; u64 pid = bpf_get_current_pid_tgid(); u64* size64 = sizes.lookup(&pid); struct alloc_info_t info = {0}; if (size64 == 0) return 0; // missed alloc entry info.size = *size64; sizes.delete(&pid); info.timestamp_ns = bpf_ktime_get_ns(); info.num_frames = grab_stack(ctx, &info) - 2; allocs.update(&address, &info); if (SHOULD_PRINT) { bpf_trace_printk("alloc exited, size = %lu, result = %lx, frames = %d\\n", info.size, address, info.num_frames); } return 0; } int free_enter(struct pt_regs *ctx, void *address) { u64 addr = (u64)address; struct alloc_info_t *info = allocs.lookup(&addr); if (info == 0) return 0; allocs.delete(&addr); if (SHOULD_PRINT) { bpf_trace_printk("free entered, address = %lx, size = %lu\\n", address, info->size); } return 0; } """ bpf_source = bpf_source.replace("SHOULD_PRINT", "1" if trace_all else "0") bpf_source = bpf_source.replace("SAMPLE_EVERY_N", str(sample_every_n)) bpf_source = bpf_source.replace("GRAB_ONE_FRAME", max_stack_size * "\tif (!(info->callstack[depth++] = get_frame(&bp))) return depth;\n") bpf_source = bpf_source.replace("MAX_STACK_SIZE", str(max_stack_size)) size_filter = "" if min_size is not None and max_size is not None: size_filter = "if (size < %d || size > %d) return 0;" % \ (min_size, max_size) elif min_size is not None: size_filter = "if (size < %d) return 0;" % min_size elif max_size is not None: size_filter = "if (size > %d) return 0;" % max_size bpf_source = bpf_source.replace("SIZE_FILTER", size_filter) bpf_program = BPF(text=bpf_source) if not kernel_trace: print("Attaching to malloc and free in pid %d, Ctrl+C to quit." % pid) bpf_program.attach_uprobe(name="c", sym="malloc", fn_name="alloc_enter", pid=pid) bpf_program.attach_uretprobe(name="c", sym="malloc", fn_name="alloc_exit", pid=pid) bpf_program.attach_uprobe(name="c", sym="free", fn_name="free_enter", pid=pid) else: print("Attaching to kmalloc and kfree, Ctrl+C to quit.") bpf_program.attach_kprobe(event="__kmalloc", fn_name="alloc_enter") bpf_program.attach_kretprobe(event="__kmalloc", fn_name="alloc_exit") bpf_program.attach_kprobe(event="kfree", fn_name="free_enter") def print_outstanding(): stacks = {} print("[%s] Top %d stacks with outstanding allocations:" % (datetime.now().strftime("%H:%M:%S"), top_stacks)) allocs = bpf_program.get_table("allocs") for address, info in sorted(allocs.items(), key=lambda a: a[1].size): if BPF.monotonic_time() - min_age_ns < info.timestamp_ns: continue stack = decode_stack(bpf_program, pid, info) if stack in stacks: stacks[stack] = (stacks[stack][0] + 1, stacks[stack][1] + info.size) else: stacks[stack] = (1, info.size) if args.show_allocs: print("\taddr = %x size = %s" % (address.value, info.size)) to_show = sorted(stacks.items(), key=lambda s: s[1][1])[-top_stacks:] for stack, (count, size) in to_show: print("\t%d bytes in %d allocations from stack\n\t\t%s" % (size, count, stack.replace(";", "\n\t\t"))) count_so_far = 0 while True: if trace_all: print(bpf_program.trace_fields()) else: try: sleep(interval) except KeyboardInterrupt: exit() print_outstanding() count_so_far += 1 if num_prints is not None and count_so_far >= num_prints: exit() bpfcc-0.2.0+git0.02884a026/tools/old/offcputime.py000077500000000000000000000144241305314114400211370ustar00rootroot00000000000000#!/usr/bin/python # # offcputime Summarize off-CPU time by kernel stack trace # For Linux, uses BCC, eBPF. # # USAGE: offcputime [-h] [-u] [-p PID] [-v] [-f] [duration] # # The current implementation uses an unrolled loop for x86_64, and was written # as a proof of concept. This implementation should be replaced in the future # with an appropriate bpf_ call, when available. # # Currently limited to a stack trace depth of 21 (maxdepth + 1). # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 13-Jan-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse import signal # arguments examples = """examples: ./offcputime # trace off-CPU stack time until Ctrl-C ./offcputime 5 # trace for 5 seconds only ./offcputime -f 5 # 5 seconds, and output in folded format ./offcputime -u # don't include kernel threads (user only) ./offcputime -p 185 # trace fo PID 185 only """ parser = argparse.ArgumentParser( description="Summarize off-CPU time by kernel stack trace", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-u", "--useronly", action="store_true", help="user threads only (no kernel threads)") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("-v", "--verbose", action="store_true", help="show raw addresses") parser.add_argument("-f", "--folded", action="store_true", help="output folded format") parser.add_argument("duration", nargs="?", default=99999999, help="duration of trace, in seconds") args = parser.parse_args() folded = args.folded duration = int(args.duration) debug = 0 maxdepth = 20 # and MAXDEPTH if args.pid and args.useronly: print("ERROR: use either -p or -u.") exit() # signal handler def signal_ignore(signal, frame): print() # define BPF program bpf_text = """ #include #include #define MAXDEPTH 20 #define MINBLOCK_US 1 struct key_t { char name[TASK_COMM_LEN]; // Skip saving the ip u64 ret[MAXDEPTH]; }; BPF_HASH(counts, struct key_t); BPF_HASH(start, u32); static u64 get_frame(u64 *bp) { if (*bp) { // The following stack walker is x86_64 specific u64 ret = 0; if (bpf_probe_read(&ret, sizeof(ret), (void *)(*bp+8))) return 0; if (bpf_probe_read(bp, sizeof(*bp), (void *)*bp)) *bp = 0; if (ret < __START_KERNEL_map) return 0; return ret; } return 0; } int oncpu(struct pt_regs *ctx, struct task_struct *prev) { u32 pid = prev->pid; u64 ts, *tsp; // record previous thread sleep time if (FILTER) { ts = bpf_ktime_get_ns(); start.update(&pid, &ts); } // calculate current thread's delta time pid = bpf_get_current_pid_tgid(); tsp = start.lookup(&pid); if (tsp == 0) return 0; // missed start or filtered u64 delta = bpf_ktime_get_ns() - *tsp; start.delete(&pid); delta = delta / 1000; if (delta < MINBLOCK_US) return 0; // create map key u64 zero = 0, *val, bp = 0; int depth = 0; struct key_t key = {}; bpf_get_current_comm(&key.name, sizeof(key.name)); bp = ctx->bp; // unrolled loop (MAXDEPTH): if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; out: val = counts.lookup_or_init(&key, &zero); (*val) += delta; return 0; } """ if args.pid: filter = 'pid == %s' % args.pid elif args.useronly: filter = '!(prev->flags & PF_KTHREAD)' else: filter = '1' bpf_text = bpf_text.replace('FILTER', filter) if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="finish_task_switch", fn_name="oncpu") matched = b.num_open_kprobes() if matched == 0: print("0 functions traced. Exiting.") exit() # header if not folded: print("Tracing off-CPU time (us) by kernel stack", end="") if duration < 99999999: print(" for %d secs." % duration) else: print("... Hit Ctrl-C to end.") # output while (1): try: sleep(duration) except KeyboardInterrupt: # as cleanup can take many seconds, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) if not folded: print() counts = b.get_table("counts") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): if folded: # print folded stack output line = k.name.decode() + ";" for i in reversed(range(0, maxdepth)): if k.ret[i] == 0: continue line = line + b.ksym(k.ret[i]) if i != 0: line = line + ";" print("%s %d" % (line, v.value)) else: # print default multi-line stack output for i in range(0, maxdepth): if k.ret[i] == 0: break print(" %-16x %s" % (k.ret[i], b.ksym(k.ret[i]))) print(" %-16s %s" % ("-", k.name)) print(" %d\n" % v.value) counts.clear() if not folded: print("Detaching...") exit() bpfcc-0.2.0+git0.02884a026/tools/old/opensnoop.py000077500000000000000000000052611305314114400210150ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # opensnoop Trace open() syscalls. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: opensnoop [-h] [-t] [-x] [-p PID] # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 17-Sep-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse # arguments examples = """examples: ./opensnoop # trace all open() syscalls ./opensnoop -t # include timestamps ./opensnoop -x # only show failed opens ./opensnoop -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace open() syscalls", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-t", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-x", "--failed", action="store_true", help="only show failed opens") parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include BPF_HASH(args_filename, u32, const char *); int kprobe__sys_open(struct pt_regs *ctx, const char __user *filename) { u32 pid = bpf_get_current_pid_tgid(); FILTER args_filename.update(&pid, &filename); return 0; }; int kretprobe__sys_open(struct pt_regs *ctx) { const char **filenamep; int ret = ctx->ax; u32 pid = bpf_get_current_pid_tgid(); filenamep = args_filename.lookup(&pid); if (filenamep == 0) { // missed entry return 0; } bpf_trace_printk("%d %s\\n", ret, *filenamep); args_filename.delete(&pid); return 0; } """ if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) # header if args.timestamp: print("%-14s" % ("TIME(s)"), end="") print("%-6s %-16s %4s %3s %s" % ("PID", "COMM", "FD", "ERR", "PATH")) start_ts = 0 # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (ret_s, filename) = msg.split(" ", 1) ret = int(ret_s) if (args.failed and (ret >= 0)): continue # split return value into FD and errno columns if ret >= 0: fd_s = ret err = 0 else: fd_s = "-1" err = - ret # print columns if args.timestamp: if start_ts == 0: start_ts = ts print("%-14.9f" % (ts - start_ts), end="") print("%-6d %-16s %4s %3s %s" % (pid, task, fd_s, err, filename)) bpfcc-0.2.0+git0.02884a026/tools/old/profile.py000077500000000000000000000301171305314114400204330ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # profile Profile CPU usage by sampling stack traces at a timed interval. # For Linux, uses BCC, BPF, perf_events. Embedded C. # # This is an efficient profiler, as stack traces are frequency counted in # kernel context, rather than passing every stack to user space for frequency # counting there. Only the unique stacks and counts are passed to user space # at the end of the profile, greatly reducing the kernel<->user transfer. # # This uses perf_event_open to setup a timer which is instrumented by BPF, # and for efficiency it does not initialize the perf ring buffer, so the # redundant perf samples are not collected. # # Kernel stacks are post-process in user-land to skip the interrupt framework # frames. You can improve efficiency a little by specifying the exact number # of frames to skip with -s, provided you know what that is. If you get -s # wrong, note that the first line is the IP, and then the (skipped) stack. # # Note: if another perf-based sampling session is active, the output may become # polluted with their events. On older kernels, the ouptut may also become # polluted with tracing sessions (when the kprobe is used instead of the # tracepoint). If this becomes a problem, logic can be added to filter events. # # REQUIRES: Linux 4.6+ (BPF_MAP_TYPE_STACK_TRACE support), and the # perf_misc_flags() function symbol to exist. The latter may or may not # exist depending on your kernel build. Linux 4.9 provides a proper solution # to this (this tool will be updated). # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # THANKS: Sasha Goldshtein, Andrew Birchall, and Evgeny Vereshchagin, who wrote # much of the code here, borrowed from tracepoint.py and offcputime.py. # # 15-Jul-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF, Perf from sys import stderr from time import sleep import argparse import signal import os import errno import multiprocessing import ctypes as ct # # Process Arguments # # arg validation def positive_int(val): try: ival = int(val) except ValueError: raise argparse.ArgumentTypeError("must be an integer") if ival < 0: raise argparse.ArgumentTypeError("must be positive") return ival def positive_nonzero_int(val): ival = positive_int(val) if ival == 0: raise argparse.ArgumentTypeError("must be nonzero") return ival # arguments examples = """examples: ./profile # profile stack traces at 49 Hertz until Ctrl-C ./profile -F 99 # profile stack traces at 99 Hertz ./profile 5 # profile at 49 Hertz for 5 seconds only ./profile -f 5 # output in folded format for flame graphs ./profile -p 185 # only profile threads for PID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) ./profile -S 11 # always skip 11 frames of kernel stack """ parser = argparse.ArgumentParser( description="Profile CPU stack traces at a timed interval", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) thread_group = parser.add_mutually_exclusive_group() thread_group.add_argument("-p", "--pid", type=positive_int, help="profile this PID only") # TODO: add options for user/kernel threads only stack_group = parser.add_mutually_exclusive_group() stack_group.add_argument("-U", "--user-stacks-only", action="store_true", help="show stacks from user space only (no kernel space stacks)") stack_group.add_argument("-K", "--kernel-stacks-only", action="store_true", help="show stacks from kernel space only (no user space stacks)") parser.add_argument("-F", "--frequency", type=positive_int, default=49, help="sample frequency, Hertz (default 49)") parser.add_argument("-d", "--delimited", action="store_true", help="insert delimiter between kernel/user stacks") parser.add_argument("-a", "--annotations", action="store_true", help="add _[k] annotations to kernel frames") parser.add_argument("-f", "--folded", action="store_true", help="output folded format, one line per stack (for flame graphs)") parser.add_argument("--stack-storage-size", default=2048, type=positive_nonzero_int, help="the number of unique stack traces that can be stored and " "displayed (default 2048)") parser.add_argument("-S", "--kernel-skip", type=positive_int, default=0, help="skip this many kernel frames (default 3)") parser.add_argument("duration", nargs="?", default=99999999, type=positive_nonzero_int, help="duration of trace, in seconds") # option logic args = parser.parse_args() skip = args.kernel_skip pid = int(args.pid) if args.pid is not None else -1 duration = int(args.duration) debug = 0 need_delimiter = args.delimited and not (args.kernel_stacks_only or args.user_stacks_only) # TODO: add stack depth, and interval # # Setup BPF # # define BPF program bpf_text = """ #include #include struct key_t { u32 pid; u64 kernel_ip; u64 kernel_ret_ip; int user_stack_id; int kernel_stack_id; char name[TASK_COMM_LEN]; }; BPF_HASH(counts, struct key_t); BPF_HASH(start, u32); BPF_STACK_TRACE(stack_traces, STACK_STORAGE_SIZE) // This code gets a bit complex. Probably not suitable for casual hacking. PERF_TRACE_EVENT { u32 pid = bpf_get_current_pid_tgid(); if (!(THREAD_FILTER)) return 0; // create map key u64 zero = 0, *val; struct key_t key = {.pid = pid}; bpf_get_current_comm(&key.name, sizeof(key.name)); // get stacks key.user_stack_id = USER_STACK_GET; key.kernel_stack_id = KERNEL_STACK_GET; if (key.kernel_stack_id >= 0) { // populate extras to fix the kernel stack struct pt_regs regs = {}; bpf_probe_read(®s, sizeof(regs), (void *)REGS_LOCATION); u64 ip = PT_REGS_IP(®s); // if ip isn't sane, leave key ips as zero for later checking #ifdef CONFIG_RANDOMIZE_MEMORY if (ip > __PAGE_OFFSET_BASE) { #else if (ip > PAGE_OFFSET) { #endif key.kernel_ip = ip; if (DO_KERNEL_RIP) { /* * User didn't specify a skip value (-s), so we will figure * out how many interrupt framework frames to skip by recording * the kernel rip, then later scanning for it on the stack. * This is likely x86_64 specific; can use -s as a workaround * until this supports your architecture. */ bpf_probe_read(&key.kernel_ret_ip, sizeof(key.kernel_ret_ip), (void *)(regs.bp + 8)); } } } val = counts.lookup_or_init(&key, &zero); (*val)++; return 0; } """ # set thread filter thread_context = "" perf_filter = "-a" if args.pid is not None: thread_context = "PID %s" % args.pid thread_filter = 'pid == %s' % args.pid perf_filter = '-p %s' % args.pid else: thread_context = "all threads" thread_filter = '1' bpf_text = bpf_text.replace('THREAD_FILTER', thread_filter) # set stack storage size bpf_text = bpf_text.replace('STACK_STORAGE_SIZE', str(args.stack_storage_size)) # handle stack args kernel_stack_get = "stack_traces.get_stackid(args, " \ "%d | BPF_F_REUSE_STACKID)" % skip user_stack_get = \ "stack_traces.get_stackid(args, BPF_F_REUSE_STACKID | BPF_F_USER_STACK)" stack_context = "" if args.user_stacks_only: stack_context = "user" kernel_stack_get = "-1" elif args.kernel_stacks_only: stack_context = "kernel" user_stack_get = "-1" else: stack_context = "user + kernel" bpf_text = bpf_text.replace('USER_STACK_GET', user_stack_get) bpf_text = bpf_text.replace('KERNEL_STACK_GET', kernel_stack_get) if skip: # don't record the rip, as we won't use it bpf_text = bpf_text.replace('DO_KERNEL_RIP', '0') else: # rip is used to skip interrupt infrastructure frames bpf_text = bpf_text.replace('DO_KERNEL_RIP', '1') # header if not args.folded: print("Sampling at %d Hertz of %s by %s stack" % (args.frequency, thread_context, stack_context), end="") if duration < 99999999: print(" for %d secs." % duration) else: print("... Hit Ctrl-C to end.") # kprobe perf_misc_flags() bpf_text = bpf_text.replace('PERF_TRACE_EVENT', 'int kprobe__perf_misc_flags(struct pt_regs *args)') bpf_text = bpf_text.replace('REGS_LOCATION', 'PT_REGS_PARM1(args)') if debug: print(bpf_text) # initialize BPF try: b = BPF(text=bpf_text) except: print("BPF initialization failed. perf_misc_flags() may be inlined in " + "your kernel build.\nThis tool will be updated in the future to " + "support Linux 4.9, which has reliable profiling support. Exiting.") exit() # signal handler def signal_ignore(signal, frame): print() # # Setup perf_events # # use perf_events to sample try: Perf.perf_event_open(0, pid=-1, ptype=Perf.PERF_TYPE_SOFTWARE, freq=args.frequency) except: print("ERROR: initializing perf_events for sampling.\n" "To debug this, try running the following command:\n" " perf record -F 49 -e cpu-clock %s -- sleep 1\n" "If that also doesn't work, fix it first." % perf_filter, file=stderr) exit(0) # # Output Report # # collect samples try: sleep(duration) except KeyboardInterrupt: # as cleanup can take some time, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) if not args.folded: print() def aksym(addr): if args.annotations: return b.ksym(addr) + "_[k]" else: return b.ksym(addr) # output stacks missing_stacks = 0 has_enomem = False counts = b.get_table("counts") stack_traces = b.get_table("stack_traces") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): # handle get_stackid erorrs if (not args.user_stacks_only and k.kernel_stack_id < 0 and k.kernel_stack_id != -errno.EFAULT) or \ (not args.kernel_stacks_only and k.user_stack_id < 0 and k.user_stack_id != -errno.EFAULT): missing_stacks += 1 # check for an ENOMEM error if k.kernel_stack_id == -errno.ENOMEM or \ k.user_stack_id == -errno.ENOMEM: has_enomem = True user_stack = [] if k.user_stack_id < 0 else \ stack_traces.walk(k.user_stack_id) kernel_tmp = [] if k.kernel_stack_id < 0 else \ stack_traces.walk(k.kernel_stack_id) # fix kernel stack kernel_stack = [] if k.kernel_stack_id >= 0: if skip: # fixed skip for addr in kernel_tmp: kernel_stack.append(addr) kernel_stack = kernel_stack[skip:] else: # skip the interrupt framework stack by searching for our RIP skipping = 1 for addr in kernel_tmp: if k.kernel_ret_ip == addr: skipping = 0 if not skipping: kernel_stack.append(addr) if k.kernel_ip: kernel_stack.insert(0, k.kernel_ip) do_delimiter = need_delimiter and kernel_stack if args.folded: # print folded stack output user_stack = list(user_stack) kernel_stack = list(kernel_stack) line = [k.name.decode()] + \ [b.sym(addr, k.pid) for addr in reversed(user_stack)] + \ (do_delimiter and ["-"] or []) + \ [aksym(addr) for addr in reversed(kernel_stack)] print("%s %d" % (";".join(line), v.value)) else: # print default multi-line stack output. for addr in kernel_stack: print(" %s" % aksym(addr)) if do_delimiter: print(" --") for addr in user_stack: print(" %s" % b.sym(addr, k.pid)) print(" %-16s %s (%d)" % ("-", k.name, k.pid)) print(" %d\n" % v.value) # check missing if missing_stacks > 0: enomem_str = "" if not has_enomem else \ " Consider increasing --stack-storage-size." print("WARNING: %d stack traces could not be displayed.%s" % (missing_stacks, enomem_str), file=stderr) bpfcc-0.2.0+git0.02884a026/tools/old/profile_example.txt000066400000000000000000001035171305314114400223370ustar00rootroot00000000000000Demonstrations of profile, the Linux eBPF/bcc version. This is a CPU profiler. It works by taking samples of stack traces at timed intervals, and frequency counting them in kernel context for efficiency. Example output: # ./profile Sampling at 49 Hertz of all threads by user + kernel stack... Hit Ctrl-C to end. ^C ffffffff81189249 filemap_map_pages ffffffff811bd3f5 handle_mm_fault ffffffff81065990 __do_page_fault ffffffff81065caf do_page_fault ffffffff817ce228 page_fault 00007fed989afcc0 [unknown] - cp (9036) 1 00007f31d76c3251 [unknown] 47a2c1e752bf47f7 [unknown] - sign-file (8877) 1 ffffffff813d0af8 __clear_user ffffffff813d5277 iov_iter_zero ffffffff814ec5f2 read_iter_zero ffffffff8120be9d __vfs_read ffffffff8120c385 vfs_read ffffffff8120d786 sys_read ffffffff817cc076 entry_SYSCALL_64_fastpath 00007fc5652ad9b0 read - dd (25036) 4 0000000000400542 func_a 0000000000400598 main 00007f12a133e830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (13549) 5 [...] ffffffff8105eb66 native_safe_halt ffffffff8103659e default_idle ffffffff81036d1f arch_cpu_idle ffffffff810bba5a default_idle_call ffffffff810bbd07 cpu_startup_entry ffffffff817bf4a7 rest_init ffffffff81d65f58 start_kernel ffffffff81d652db x86_64_start_reservations ffffffff81d65418 x86_64_start_kernel - swapper/0 (0) 72 ffffffff8105eb66 native_safe_halt ffffffff8103659e default_idle ffffffff81036d1f arch_cpu_idle ffffffff810bba5a default_idle_call ffffffff810bbd07 cpu_startup_entry ffffffff8104df55 start_secondary - swapper/1 (0) 75 The output was long; I truncated some lines ("[...]"). This default output prints stack traces as two columns (raw addresses, and then translated symbol names), followed by a line to describe the process (a dash, the process name, and a PID in parenthesis), and then an integer count of how many times this stack trace was sampled. The output above shows the most frequent stack was from the "swapper/1" process (PID 0), running the native_safe_halt() function, which was called by default_idle(), which was called by arch_cpu_idle(), and so on. This is the idle thread. Stacks can be read top-down, to follow ancestry: child, parent, grandparent, etc. The func_ab process is running the func_a() function, called by main(), called by __libc_start_main(), and called by "[unknown]" with what looks like a bogus address (1st column). That's evidence of a broken stack trace. It's common for user-level software that hasn't been compiled with frame pointers (in this case, libc). The dd process has called read(), and then enters the kernel via entry_SYSCALL_64_fastpath(), calling sys_read(), and so on. Yes, I'm now reading it bottom up. That way follows the code flow. The dd process is actually "dd if=/dev/zero of=/dev/null": it's a simple workload to analyze that just moves bytes from /dev/zero to /dev/null. Profiling just that process: # ./profile -p 25036 Sampling at 49 Hertz of PID 25036 by user + kernel stack... Hit Ctrl-C to end. ^C 0000000000402748 [unknown] 00007fc56561422c [unknown] - dd (25036) 1 00007fc5652ada0e __write - dd (25036) 1 00007fc5652ad9b0 read - dd (25036) 1 [...] 00000000004047b2 [unknown] 00007fc56561422c [unknown] - dd (25036) 2 ffffffff817cc060 entry_SYSCALL_64_fastpath 00007fc5652ada10 __write 00007fc56561422c [unknown] - dd (25036) 3 ffffffff817cc060 entry_SYSCALL_64_fastpath 00007fc5652ad9b0 read - dd (25036) 3 ffffffff813d0af8 __clear_user ffffffff813d5277 iov_iter_zero ffffffff814ec5f2 read_iter_zero ffffffff8120be9d __vfs_read ffffffff8120c385 vfs_read ffffffff8120d786 sys_read ffffffff817cc076 entry_SYSCALL_64_fastpath 00007fc5652ad9b0 read 00007fc56561422c [unknown] - dd (25036) 3 ffffffff813d0af8 __clear_user ffffffff813d5277 iov_iter_zero ffffffff814ec5f2 read_iter_zero ffffffff8120be9d __vfs_read ffffffff8120c385 vfs_read ffffffff8120d786 sys_read ffffffff817cc076 entry_SYSCALL_64_fastpath 00007fc5652ad9b0 read - dd (25036) 7 Again, I've truncated some lines. Now we're just analyzing the dd process. The filtering is performed in kernel context, for efficiency. This output has some "[unknown]" frames that probably have valid addresses, but we're lacking the symbol translation. This is a common for all profilers on Linux, and is usually fixable. See the DEBUGGING section of the profile(8) man page. Lets add delimiters between the user and kernel stacks, using -d: # ./profile -p 25036 -d ^C ffffffff8120b385 __vfs_write ffffffff8120d826 sys_write ffffffff817cc076 entry_SYSCALL_64_fastpath -- 00007fc5652ada10 __write - dd (25036) 1 -- 00007fc565255ef3 [unknown] 00007fc56561422c [unknown] - dd (25036) 1 ffffffff813d4569 iov_iter_init ffffffff8120be8e __vfs_read ffffffff8120c385 vfs_read ffffffff8120d786 sys_read ffffffff817cc076 entry_SYSCALL_64_fastpath -- 00007fc5652ad9b0 read - dd (25036) 1 [...] ffffffff813d0af8 __clear_user ffffffff813d5277 iov_iter_zero ffffffff814ec5f2 read_iter_zero ffffffff8120be9d __vfs_read ffffffff8120c385 vfs_read ffffffff8120d786 sys_read ffffffff817cc076 entry_SYSCALL_64_fastpath -- 00007fc5652ad9b0 read - dd (25036) 9 In this mode, the delimiters are "--". Here's another example, a func_ab program that runs two functions, func_a() and func_b(). Profiling it for 5 seconds: # ./profile -p `pgrep -n func_ab` 5 Sampling at 49 Hertz of PID 2930 by user + kernel stack for 5 secs. 000000000040053e func_a 0000000000400598 main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 2 0000000000400566 func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 3 000000000040053a func_a 0000000000400598 main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 5 0000000000400562 func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 12 000000000040056a func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 19 0000000000400542 func_a 0000000000400598 main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 22 0000000000400571 func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 64 0000000000400549 func_a 0000000000400598 main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 72 Note that the same stack (2nd column) seems to be repeated. Weren't we doing frequency counting and only printing unique stacks? We are, but in terms of the raw addresses, not the symbols. See the 1st column: those stacks are all unique. We can output in "folded format", which puts the stack trace on one line, separating frames with semi-colons. Eg: # ./profile -f -p `pgrep -n func_ab` 5 func_ab;[unknown];__libc_start_main;main;func_a 2 func_ab;[unknown];__libc_start_main;main;func_b 2 func_ab;[unknown];__libc_start_main;main;func_a 11 func_ab;[unknown];__libc_start_main;main;func_b 12 func_ab;[unknown];__libc_start_main;main;func_a 23 func_ab;[unknown];__libc_start_main;main;func_b 28 func_ab;[unknown];__libc_start_main;main;func_b 57 func_ab;[unknown];__libc_start_main;main;func_a 64 I find this pretty useful for writing to files and later grepping. Folded format can also be used by flame graph stack visualizers, including the original implementation: https://github.com/brendangregg/FlameGraph I'd include delimiters, -d. For example: # ./profile -df -p `pgrep -n func_ab` 5 > out.profile # git clone https://github.com/brendangregg/FlameGraph # ./FlameGraph/flamegraph.pl < out.profile > out.svg (Yes, I could pipe profile directly into flamegraph.pl, however, I like to keep the raw folded profiles around: can be useful for regenerating flamegraphs with different options, and, for differential flame graphs.) Some flamegraph.pl palettes recognize kernel annotations, which can be added with -a. It simply adds a "_[k]" at the end of kernel function names. For example: # ./profile -adf -p `pgrep -n dd` 10 dd;[unknown] 1 dd;[unknown];[unknown] 1 dd;[unknown];[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];__fsnotify_parent_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__fsnotify_parent_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fdget_pos_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];__fsnotify_parent_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__fsnotify_parent_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fsnotify_parent_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];fsnotify_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fdget_pos_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;[unknown] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];__fsnotify_parent_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];security_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];fsnotify_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];fsnotify_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__fsnotify_parent_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];iov_iter_init_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];__fsnotify_parent_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__vfs_write_[k];write_null_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];__clear_user_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];security_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__vfs_read_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__vfs_write_[k] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fsnotify_parent_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];__write;-;sys_write_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fsnotify_parent_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];common_file_perm_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];vfs_read_[k] 1 dd;__write 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 1 dd;[unknown];[unknown] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown] 1 dd;[unknown] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;__write 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fdget_pos_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];_cond_resched_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];iov_iter_init_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];__fsnotify_parent_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];rw_verify_area_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];fsnotify_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fdget_pos_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;[unknown] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];fsnotify_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];fsnotify_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];fsnotify_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];__fdget_pos_[k] 2 dd;[unknown];[unknown] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fdget_pos_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 2 dd;[unknown];[unknown] 2 dd;[unknown];[unknown] 2 dd;[unknown];[unknown] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 2 dd;[unknown];[unknown] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];__clear_user_[k] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];__fdget_pos_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 2 dd;[unknown];[unknown] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];fsnotify_[k] 2 dd;__write;-;sys_write_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];fsnotify_[k] 2 dd;[unknown];[unknown] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 2 dd;read;-;SyS_read_[k] 2 dd;[unknown] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k] 2 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];__clear_user_[k] 2 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];rw_verify_area_[k] 2 dd;[unknown];[unknown] 3 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];rw_verify_area_[k] 3 dd;[unknown];[unknown] 3 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 3 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 3 dd;[unknown];[unknown] 3 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 3 dd;[unknown];[unknown] 3 dd;[unknown];[unknown] 3 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 3 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 3 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 3 dd;[unknown] 4 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 4 dd;[unknown];[unknown] 4 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 4 dd;[unknown] 4 dd;[unknown];[unknown] 4 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k] 4 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 5 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 5 dd;[unknown];[unknown] 5 dd;[unknown];[unknown] 5 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 6 dd;read 15 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 19 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k] 20 dd;read;-;entry_SYSCALL_64_fastpath_[k] 23 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 24 dd;__write;-;entry_SYSCALL_64_fastpath_[k] 25 dd;__write 29 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k] 31 This can be made into a flamegraph. Eg: # ./profile -adf -p `pgrep -n func_ab` 10 > out.profile # git clone https://github.com/brendangregg/FlameGraph # ./FlameGraph/flamegraph.pl --color=java < out.profile > out.svg It will highlight the kernel frames in orange, and user-level in red (and Java in green, and C++ in yellow). If you copy-n-paste the above output into a out.profile file, you can try it out. You can increase or decrease the sample frequency. Eg, sampling at 9 Hertz: # ./profile -F 9 Sampling at 9 Hertz of all threads by user + kernel stack... Hit Ctrl-C to end. ^C 000000000040056a func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 1 [...] ffffffff8105eb66 native_safe_halt ffffffff8103659e default_idle ffffffff81036d1f arch_cpu_idle ffffffff810bba5a default_idle_call ffffffff810bbd07 cpu_startup_entry ffffffff8104df55 start_secondary - swapper/3 (0) 8 ffffffff8105eb66 native_safe_halt ffffffff8103659e default_idle ffffffff81036d1f arch_cpu_idle ffffffff810bba5a default_idle_call ffffffff810bbd07 cpu_startup_entry ffffffff817bf497 rest_init ffffffff81d65f58 start_kernel ffffffff81d652db x86_64_start_reservations ffffffff81d65418 x86_64_start_kernel - swapper/0 (0) 8 You can also restrict profiling to just kernel stacks (-K) or user stacks (-U). For example, just user stacks: # ./profile -U Sampling at 49 Hertz of all threads by user stack... Hit Ctrl-C to end. ^C 0000000000402ccc [unknown] 00007f45a624422c [unknown] - dd (2931) 1 0000000000404b80 [unknown] 00007f45a624422c [unknown] - dd (2931) 1 0000000000404d77 [unknown] 00007f45a624422c [unknown] - dd (2931) 1 00007f45a5e85e5e [unknown] 00007f45a624422c [unknown] - dd (2931) 1 0000000000402d12 [unknown] 00007f45a624422c [unknown] - dd (2931) 1 0000000000400562 func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 1 0000000000404805 [unknown] - dd (2931) 1 00000000004047de [unknown] - dd (2931) 1 0000000000400542 func_a 0000000000400598 main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 3 00007f45a5edda10 __write 00007f45a624422c [unknown] - dd (2931) 3 000000000040053a func_a 0000000000400598 main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 4 000000000040056a func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 7 - swapper/6 (0) 10 0000000000400571 func_b 00000000004005ac main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 10 00007f45a5edda10 __write - dd (2931) 10 0000000000400549 func_a 0000000000400598 main 00007f0458819830 __libc_start_main 083e258d4c544155 [unknown] - func_ab (2930) 11 00007f45a5edd9b0 read - dd (2931) 12 00007f45a5edd9b0 read 00007f45a624422c [unknown] - dd (2931) 14 - swapper/7 (0) 46 - swapper/0 (0) 46 - swapper/2 (0) 46 - swapper/1 (0) 46 - swapper/3 (0) 46 - swapper/4 (0) 46 If there are too many unique stack traces for the kernel to save, a warning will be printed. Eg: # ./profile [...] WARNING: 8 stack traces could not be displayed. Consider increasing --stack-storage-size. Run ./profile -h to see the default. There is a -S option to skip kernel frames. You probably don't need to mess with this. Here's why it exists: consider the following kernel stack trace, and IP: ffffffff81174e78 perf_swevent_hrtimer ffffffff810e6984 __hrtimer_run_queues ffffffff810e70f8 hrtimer_interrupt ffffffff81022c69 xen_timer_interrupt ffffffff810d2942 handle_irq_event_percpu ffffffff810d62da handle_percpu_irq ffffffff810d1f52 generic_handle_irq ffffffff814a5137 evtchn_2l_handle_events ffffffff814a2853 __xen_evtchn_do_upcall ffffffff814a4740 xen_evtchn_do_upcall ffffffff817cd50c xen_hvm_callback_vector ffffffff8103663e default_idle ffffffff81036dbf arch_cpu_idle ffffffff810bb8ea default_idle_call ffffffff810bbb97 cpu_startup_entry ffffffff8104df85 start_secondary IP: ffffffff8105eb66 native_safe_halt This is the idle thread. The first function is native_safe_halt(), and its parent is default_idle(). But what you see there is really what we are profiling. All that stuff above default_idle()? Interrupt framework stack. So we have to exclude those interrupt frames. I do this by fetching the ret IP from the kernel stack, and then scanning for it in user-level: in this case it would be default_idle(). Ok. If this doesn't work on your architecture (and your kernel stacks are a single line, the IP), then you might consider setting a fixed skip count, which avoids this ret IP logic. For the above stack, I'd set "-S 11", and it would slice off those 11 interrupt frames nicely. It also does this in kernel context for efficiency. So how do you figure out what number to use? 11? 14? 5? Well.. Try "-S 1", and then see how much higher you need to set it. Remember on the real profile output that the IP line is printed on top of the sliced stack. USAGE message: # ./profile -h usage: profile [-h] [-p PID] [-U | -K] [-F FREQUENCY] [-d] [-a] [-f] [--stack-storage-size STACK_STORAGE_SIZE] [-S KERNEL_SKIP] [duration] Profile CPU stack traces at a timed interval positional arguments: duration duration of trace, in seconds optional arguments: -h, --help show this help message and exit -p PID, --pid PID profile this PID only -U, --user-stacks-only show stacks from user space only (no kernel space stacks) -K, --kernel-stacks-only show stacks from kernel space only (no user space stacks) -F FREQUENCY, --frequency FREQUENCY sample frequency, Hertz (default 49) -d, --delimited insert delimiter between kernel/user stacks -a, --annotations add _[k] annotations to kernel frames -f, --folded output folded format, one line per stack (for flame graphs) --stack-storage-size STACK_STORAGE_SIZE the number of unique stack traces that can be stored and displayed (default 2048) -S KERNEL_SKIP, --kernel-skip KERNEL_SKIP skip this many kernel frames (default 3) examples: ./profile # profile stack traces at 49 Hertz until Ctrl-C ./profile -F 99 # profile stack traces at 99 Hertz ./profile 5 # profile at 49 Hertz for 5 seconds only ./profile -f 5 # output in folded format for flame graphs ./profile -p 185 # only profile threads for PID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) ./profile -S 11 # always skip 11 frames of kernel stack bpfcc-0.2.0+git0.02884a026/tools/old/stackcount.py000077500000000000000000000126221305314114400211520ustar00rootroot00000000000000#!/usr/bin/python # # stackcount Count kernel function calls and their stack traces. # For Linux, uses BCC, eBPF. # # USAGE: stackcount [-h] [-p PID] [-i INTERVAL] [-T] [-r] pattern # # The pattern is a string with optional '*' wildcards, similar to file # globbing. If you'd prefer to use regular expressions, use the -r option. # # The current implementation uses an unrolled loop for x86_64, and was written # as a proof of concept. This implementation should be replaced in the future # with an appropriate bpf_ call, when available. # # Currently limited to a stack trace depth of 11 (maxdepth + 1). # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 12-Jan-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse import signal # arguments examples = """examples: ./stackcount submit_bio # count kernel stack traces for submit_bio ./stackcount ip_output # count kernel stack traces for ip_output ./stackcount -s ip_output # show symbol offsets ./stackcount -sv ip_output # show offsets and raw addresses (verbose) ./stackcount 'tcp_send*' # count stacks for funcs matching tcp_send* ./stackcount -r '^tcp_send.*' # same as above, using regular expressions ./stackcount -Ti 5 ip_output # output every 5 seconds, with timestamps ./stackcount -p 185 ip_output # count ip_output stacks for PID 185 only """ parser = argparse.ArgumentParser( description="Count kernel function calls and their stack traces", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("-i", "--interval", default=99999999, help="summary interval, seconds") parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-r", "--regexp", action="store_true", help="use regular expressions. Default is \"*\" wildcards only.") parser.add_argument("-s", "--offset", action="store_true", help="show address offsets") parser.add_argument("-v", "--verbose", action="store_true", help="show raw addresses") parser.add_argument("pattern", help="search expression for kernel functions") args = parser.parse_args() pattern = args.pattern if not args.regexp: pattern = pattern.replace('*', '.*') pattern = '^' + pattern + '$' offset = args.offset verbose = args.verbose debug = 0 maxdepth = 10 # and MAXDEPTH # signal handler def signal_ignore(signal, frame): print() # load BPF program bpf_text = """ #include #define MAXDEPTH 10 struct key_t { u64 ip; u64 ret[MAXDEPTH]; }; BPF_HASH(counts, struct key_t); static u64 get_frame(u64 *bp) { if (*bp) { // The following stack walker is x86_64 specific u64 ret = 0; if (bpf_probe_read(&ret, sizeof(ret), (void *)(*bp+8))) return 0; if (bpf_probe_read(bp, sizeof(*bp), (void *)*bp)) *bp = 0; if (ret < __START_KERNEL_map) return 0; return ret; } return 0; } int trace_count(struct pt_regs *ctx) { FILTER struct key_t key = {}; u64 zero = 0, *val, bp = 0; int depth = 0; key.ip = ctx->ip; bp = ctx->bp; // unrolled loop, 10 (MAXDEPTH) frames deep: if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; if (!(key.ret[depth++] = get_frame(&bp))) goto out; out: val = counts.lookup_or_init(&key, &zero); (*val)++; return 0; } """ if args.pid: bpf_text = bpf_text.replace('FILTER', ('u32 pid; pid = bpf_get_current_pid_tgid(); ' + 'if (pid != %s) { return 0; }') % (args.pid)) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) b = BPF(text=bpf_text) b.attach_kprobe(event_re=pattern, fn_name="trace_count") matched = b.num_open_kprobes() if matched == 0: print("0 functions matched by \"%s\". Exiting." % args.pattern) exit() # header print("Tracing %d functions for \"%s\"... Hit Ctrl-C to end." % (matched, args.pattern)) def print_frame(addr): print(" ", end="") if verbose: print("%-16x " % addr, end="") print(b.ksym(addr, show_offset=offset)) # output exiting = 0 if args.interval else 1 while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 # as cleanup can take many seconds, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") counts = b.get_table("counts") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): print_frame(k.ip) for i in range(0, maxdepth): if k.ret[i] == 0: break print_frame(k.ret[i]) print(" %d\n" % v.value) counts.clear() if exiting: print("Detaching...") exit() bpfcc-0.2.0+git0.02884a026/tools/old/stacksnoop.py000077500000000000000000000075311305314114400211630ustar00rootroot00000000000000#!/usr/bin/python # # stacksnoop Trace a kernel function and print all kernel stack traces. # For Linux, uses BCC, eBPF, and currently x86_64 only. Inline C. # # USAGE: stacksnoop [-h] [-p PID] [-s] [-v] function # # The current implementation uses an unrolled loop for x86_64, and was written # as a proof of concept. This implementation should be replaced in the future # with an appropriate bpf_ call, when available. # # The stack depth is limited to 10 (+1 for the current instruction pointer). # This could be tunable in a future version. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 12-Jan-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse # arguments examples = """examples: ./stacksnoop ext4_sync_fs # print kernel stack traces for ext4_sync_fs ./stacksnoop -s ext4_sync_fs # ... also show symbol offsets ./stacksnoop -v ext4_sync_fs # ... show extra columns ./stacksnoop -p 185 ext4_sync_fs # ... only when PID 185 is on-CPU """ parser = argparse.ArgumentParser( description="Trace and print kernel stack traces for a kernel function", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("-s", "--offset", action="store_true", help="show address offsets") parser.add_argument("-v", "--verbose", action="store_true", help="print more fields") parser.add_argument("function", help="kernel function name") args = parser.parse_args() function = args.function offset = args.offset verbose = args.verbose debug = 0 # define BPF program bpf_text = """ #include static int print_frame(u64 *bp, int *depth) { if (*bp) { // The following stack walker is x86_64 specific u64 ret = 0; if (bpf_probe_read(&ret, sizeof(ret), (void *)(*bp+8))) return 0; if (ret < __START_KERNEL_map) return 0; bpf_trace_printk("r%d: %llx\\n", *depth, ret); if (bpf_probe_read(bp, sizeof(*bp), (void *)*bp)) return 0; *depth += 1; return 1; } return 0; } void trace_stack(struct pt_regs *ctx) { FILTER u64 bp = 0; int depth = 0; bpf_trace_printk("\\n"); if (ctx->ip) bpf_trace_printk("ip: %llx\\n", ctx->ip); bp = ctx->bp; // unrolled loop, 10 frames deep: if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; if (!print_frame(&bp, &depth)) return; }; """ if args.pid: bpf_text = bpf_text.replace('FILTER', ('u32 pid; pid = bpf_get_current_pid_tgid(); ' + 'if (pid != %s) { return; }') % (args.pid)) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event=function, fn_name="trace_stack") matched = b.num_open_kprobes() if matched == 0: print("Function \"%s\" not found. Exiting." % function) exit() # header if verbose: print("%-18s %-12s %-6s %-3s %s" % ("TIME(s)", "COMM", "PID", "CPU", "STACK")) else: print("%-18s %s" % ("TIME(s)", "STACK")) # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() if msg != "": (reg, addr) = msg.split(" ") ip = b.ksym(int(addr, 16), show_offset=offset) msg = msg + " " + ip if verbose: print("%-18.9f %-12.12s %-6d %-3d %s" % (ts, task, pid, cpu, msg)) else: print("%-18.9f %s" % (ts, msg)) bpfcc-0.2.0+git0.02884a026/tools/old/statsnoop.py000077500000000000000000000060141305314114400210240ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # statsnoop Trace stat() syscalls. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: statsnoop [-h] [-t] [-x] [-p PID] # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 08-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse # arguments examples = """examples: ./statsnoop # trace all stat() syscalls ./statsnoop -t # include timestamps ./statsnoop -x # only show failed stats ./statsnoop -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace stat() syscalls", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-t", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-x", "--failed", action="store_true", help="only show failed stats") parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include BPF_HASH(args_filename, u32, const char *); int trace_entry(struct pt_regs *ctx, const char __user *filename) { u32 pid = bpf_get_current_pid_tgid(); FILTER args_filename.update(&pid, &filename); return 0; }; int trace_return(struct pt_regs *ctx) { const char **filenamep; int ret = ctx->ax; u32 pid = bpf_get_current_pid_tgid(); filenamep = args_filename.lookup(&pid); if (filenamep == 0) { // missed entry return 0; } bpf_trace_printk("%d %s\\n", ret, *filenamep); args_filename.delete(&pid); return 0; } """ if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="sys_stat", fn_name="trace_entry") b.attach_kprobe(event="sys_statfs", fn_name="trace_entry") b.attach_kprobe(event="sys_newstat", fn_name="trace_entry") b.attach_kretprobe(event="sys_stat", fn_name="trace_return") b.attach_kretprobe(event="sys_statfs", fn_name="trace_return") b.attach_kretprobe(event="sys_newstat", fn_name="trace_return") # header if args.timestamp: print("%-14s" % ("TIME(s)"), end="") print("%-6s %-16s %4s %3s %s" % ("PID", "COMM", "FD", "ERR", "PATH")) start_ts = 0 # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (ret_s, filename) = msg.split(" ", 1) ret = int(ret_s) if (args.failed and (ret >= 0)): continue # split return value into FD and errno columns if ret >= 0: fd_s = ret err = 0 else: fd_s = "-1" err = - ret # print columns if args.timestamp: if start_ts == 0: start_ts = ts print("%-14.9f" % (ts - start_ts), end="") print("%-6d %-16s %4s %3s %s" % (pid, task, fd_s, err, filename)) bpfcc-0.2.0+git0.02884a026/tools/old/syncsnoop.py000077500000000000000000000014061305314114400210250ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # syncsnoop Trace sync() syscall. # For Linux, uses BCC, eBPF. Embedded C. # # Written as a basic example of BCC trace & reformat. See # examples/hello_world.py for a BCC trace with default output example. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 13-Aug-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF # load BPF program b = BPF(text=""" void kprobe__sys_sync(void *ctx) { bpf_trace_printk("sync()\\n"); }; """) # header print("%-18s %s" % ("TIME(s)", "CALL")) # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() print("%-18.9f %s" % (ts, msg)) bpfcc-0.2.0+git0.02884a026/tools/old/tcpaccept.py000077500000000000000000000075761305314114400207560ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # tcpaccept Trace TCP accept()s. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: tcpaccept [-h] [-t] [-p PID] # # This uses dynamic tracing of the kernel inet_csk_accept() socket function # (from tcp_prot.accept), and will need to be modified to match kernel changes. # # IPv4 addresses are printed as dotted quads. For IPv6 addresses, the last four # bytes are printed after "..."; check for future versions with better IPv6 # support. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 13-Oct-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse # arguments examples = """examples: ./tcpaccept # trace all TCP accept()s ./tcpaccept -t # include timestamps ./tcpaccept -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace TCP accepts", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-t", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include #include #include int kretprobe__inet_csk_accept(struct pt_regs *ctx) { struct sock *newsk = (struct sock *)ctx->ax; u32 pid = bpf_get_current_pid_tgid(); if (newsk == NULL) return 0; // check this is TCP u8 protocol = 0; // workaround for reading the sk_protocol bitfield: bpf_probe_read(&protocol, 1, (void *)((long)&newsk->sk_wmem_queued) - 3); if (protocol != IPPROTO_TCP) return 0; // pull in details u16 family = 0, lport = 0; u32 saddr = 0, daddr = 0; bpf_probe_read(&family, sizeof(family), &newsk->__sk_common.skc_family); bpf_probe_read(&lport, sizeof(lport), &newsk->__sk_common.skc_num); if (family == AF_INET) { bpf_probe_read(&saddr, sizeof(saddr), &newsk->__sk_common.skc_rcv_saddr); bpf_probe_read(&daddr, sizeof(daddr), &newsk->__sk_common.skc_daddr); // output bpf_trace_printk("4 %x %x %d\\n", daddr, saddr, lport); } else if (family == AF_INET6) { // just grab the last 4 bytes for now bpf_probe_read(&saddr, sizeof(saddr), &newsk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32[3]); bpf_probe_read(&daddr, sizeof(daddr), &newsk->__sk_common.skc_v6_daddr.in6_u.u6_addr32[3]); // output and flip byte order of addresses bpf_trace_printk("6 %x %x %d\\n", bpf_ntohl(daddr), bpf_ntohl(saddr), lport); } // else drop return 0; } """ # code substitutions if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) # header if args.timestamp: print("%-9s" % ("TIME(s)"), end="") print("%-6s %-12s %-2s %-16s %-16s %-4s" % ("PID", "COMM", "IP", "RADDR", "LADDR", "LPORT")) start_ts = 0 def inet_ntoa(addr): dq = '' for i in range(0, 4): dq = dq + str(addr & 0xff) if (i != 3): dq = dq + '.' addr = addr >> 8 return dq # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (ip_s, raddr_hs, laddr_hs, lport_s) = msg.split(" ") if args.timestamp: if start_ts == 0: start_ts = ts print("%-9.3f" % (ts - start_ts), end="") print("%-6d %-12.12s %-2s %-16s %-16s %-4s" % (pid, task, ip_s, inet_ntoa(int(raddr_hs, 16)) if ip_s == "4" else "..." + raddr_hs, inet_ntoa(int(laddr_hs, 16)) if ip_s == "4" else "..." + laddr_hs, lport_s)) bpfcc-0.2.0+git0.02884a026/tools/old/tcpconnect.py000077500000000000000000000105151305314114400211330ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # tcpconnect Trace TCP connect()s. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: tcpconnect [-h] [-t] [-p PID] # # All connection attempts are traced, even if they ultimately fail. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 25-Sep-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF import argparse # arguments examples = """examples: ./tcpconnect # trace all TCP connect()s ./tcpconnect -t # include timestamps ./tcpconnect -p 181 # only trace PID 181 """ parser = argparse.ArgumentParser( description="Trace TCP connects", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-t", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-p", "--pid", help="trace this PID only") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include #include #include BPF_HASH(currsock, u32, struct sock *); int trace_connect_entry(struct pt_regs *ctx, struct sock *sk) { u32 pid = bpf_get_current_pid_tgid(); FILTER // stash the sock ptr for lookup on return currsock.update(&pid, &sk); return 0; }; static int trace_connect_return(struct pt_regs *ctx, short ipver) { int ret = ctx->ax; u32 pid = bpf_get_current_pid_tgid(); struct sock **skpp; skpp = currsock.lookup(&pid); if (skpp == 0) { return 0; // missed entry } if (ret != 0) { // failed to send SYNC packet, may not have populated // socket __sk_common.{skc_rcv_saddr, ...} currsock.delete(&pid); return 0; } // pull in details struct sock *skp = *skpp; u32 saddr = 0, daddr = 0; u16 dport = 0; bpf_probe_read(&dport, sizeof(dport), &skp->__sk_common.skc_dport); if (ipver == 4) { bpf_probe_read(&saddr, sizeof(saddr), &skp->__sk_common.skc_rcv_saddr); bpf_probe_read(&daddr, sizeof(daddr), &skp->__sk_common.skc_daddr); // output bpf_trace_printk("4 %x %x %d\\n", saddr, daddr, ntohs(dport)); } else /* 6 */ { // just grab the last 4 bytes for now bpf_probe_read(&saddr, sizeof(saddr), &skp->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32[3]); bpf_probe_read(&daddr, sizeof(daddr), &skp->__sk_common.skc_v6_daddr.in6_u.u6_addr32[3]); // output and flip byte order of addresses bpf_trace_printk("6 %x %x %d\\n", bpf_ntohl(saddr), bpf_ntohl(daddr), ntohs(dport)); } currsock.delete(&pid); return 0; } int trace_connect_v4_return(struct pt_regs *ctx) { return trace_connect_return(ctx, 4); } int trace_connect_v6_return(struct pt_regs *ctx) { return trace_connect_return(ctx, 6); } """ # code substitutions if args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="tcp_v4_connect", fn_name="trace_connect_entry") b.attach_kprobe(event="tcp_v6_connect", fn_name="trace_connect_entry") b.attach_kretprobe(event="tcp_v4_connect", fn_name="trace_connect_v4_return") b.attach_kretprobe(event="tcp_v6_connect", fn_name="trace_connect_v6_return") # header if args.timestamp: print("%-9s" % ("TIME(s)"), end="") print("%-6s %-12s %-2s %-16s %-16s %-4s" % ("PID", "COMM", "IP", "SADDR", "DADDR", "DPORT")) start_ts = 0 def inet_ntoa(addr): dq = '' for i in range(0, 4): dq = dq + str(addr & 0xff) if (i != 3): dq = dq + '.' addr = addr >> 8 return dq # format output while 1: (task, pid, cpu, flags, ts, msg) = b.trace_fields() (ip_s, saddr_hs, daddr_hs, dport_s) = msg.split(" ") if args.timestamp: if start_ts == 0: start_ts = ts print("%-9.3f" % (ts - start_ts), end="") print("%-6d %-12.12s %-2s %-16s %-16s %-4s" % (pid, task, ip_s, inet_ntoa(int(saddr_hs, 16)) if ip_s == "4" else "..." + saddr_hs, inet_ntoa(int(daddr_hs, 16)) if ip_s == "4" else "..." + daddr_hs, dport_s)) bpfcc-0.2.0+git0.02884a026/tools/oomkill.py000077500000000000000000000044111305314114400176610ustar00rootroot00000000000000#!/usr/bin/env python # # oomkill Trace oom_kill_process(). For Linux, uses BCC, eBPF. # # This traces the kernel out-of-memory killer, and prints basic details, # including the system load averages. This can provide more context on the # system state at the time of OOM: was it getting busier or steady, based # on the load averages? This tool may also be useful to customize for # investigations; for example, by adding other task_struct details at the time # of OOM. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 09-Feb-2016 Brendan Gregg Created this. from bcc import BPF from time import strftime import ctypes as ct # linux stats loadavg = "/proc/loadavg" # define BPF program bpf_text = """ #include #include struct data_t { u64 fpid; u64 tpid; u64 pages; char fcomm[TASK_COMM_LEN]; char tcomm[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(events); void kprobe__oom_kill_process(struct pt_regs *ctx, struct oom_control *oc, struct task_struct *p, unsigned int points, unsigned long totalpages) { struct data_t data = {}; u32 pid = bpf_get_current_pid_tgid(); data.fpid = pid; data.tpid = p->pid; data.pages = totalpages; bpf_get_current_comm(&data.fcomm, sizeof(data.fcomm)); bpf_probe_read(&data.tcomm, sizeof(data.tcomm), p->comm); events.perf_submit(ctx, &data, sizeof(data)); } """ # kernel->user event data: struct data_t TASK_COMM_LEN = 16 # linux/sched.h class Data(ct.Structure): _fields_ = [ ("fpid", ct.c_ulonglong), ("tpid", ct.c_ulonglong), ("pages", ct.c_ulonglong), ("fcomm", ct.c_char * TASK_COMM_LEN), ("tcomm", ct.c_char * TASK_COMM_LEN) ] # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents with open(loadavg) as stats: avgline = stats.read().rstrip() print(("%s Triggered by PID %d (\"%s\"), OOM kill of PID %d (\"%s\")" ", %d pages, loadavg: %s") % (strftime("%H:%M:%S"), event.fpid, event.fcomm, event.tpid, event.tcomm, event.pages, avgline)) # initialize BPF b = BPF(text=bpf_text) print("Tracing OOM kills... Ctrl-C to stop.") b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/oomkill_example.txt000066400000000000000000000036051305314114400215640ustar00rootroot00000000000000Demonstrations of oomkill, the Linux eBPF/bcc version. oomkill is a simple program that traces the Linux out-of-memory (OOM) killer, and shows basic details on one line per OOM kill: # ./oomkill Tracing oom_kill_process()... Ctrl-C to end. 21:03:39 Triggered by PID 3297 ("ntpd"), OOM kill of PID 22516 ("perl"), 3850642 pages, loadavg: 0.99 0.39 0.30 3/282 22724 21:03:48 Triggered by PID 22517 ("perl"), OOM kill of PID 22517 ("perl"), 3850642 pages, loadavg: 0.99 0.41 0.30 2/282 22932 The first line shows that PID 22516, with process name "perl", was OOM killed when it reached 3850642 pages (usually 4 Kbytes per page). This OOM kill happened to be triggered by PID 3297, process name "ntpd", doing some memory allocation. The system log (dmesg) shows pages of details and system context about an OOM kill. What it currently lacks, however, is context on how the system had been changing over time. I've seen OOM kills where I wanted to know if the system was at steady state at the time, or if there had been a recent increase in workload that triggered the OOM event. oomkill provides some context: at the end of the line is the load average information from /proc/loadavg. For both of the oomkills here, we can see that the system was getting busier at the time (a higher 1 minute "average" of 0.99, compared to the 15 minute "average" of 0.30). oomkill can also be the basis of other tools and customizations. For example, you can edit it to include other task_struct details from the target PID at the time of the OOM kill. The following commands can be used to test this program, and invoke a memory consuming process that exhausts system memory and is OOM killed: sysctl -w vm.overcommit_memory=1 # always overcommit perl -e 'while (1) { $a .= "A" x 1024; }' # eat all memory WARNING: This exhausts system memory after disabling some overcommit checks. Only test in a lab environment. bpfcc-0.2.0+git0.02884a026/tools/opensnoop.py000077500000000000000000000113311305314114400202320ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # opensnoop Trace open() syscalls. # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: opensnoop [-h] [-T] [-x] [-p PID] [-t TID] [-n NAME] # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 17-Sep-2015 Brendan Gregg Created this. # 29-Apr-2016 Allan McAleavy Updated for BPF_PERF_OUTPUT. # 08-Oct-2016 Dina Goldshtein Support filtering by PID and TID. from __future__ import print_function from bcc import BPF import argparse import ctypes as ct # arguments examples = """examples: ./opensnoop # trace all open() syscalls ./opensnoop -T # include timestamps ./opensnoop -x # only show failed opens ./opensnoop -p 181 # only trace PID 181 ./opensnoop -t 123 # only trace TID 123 ./opensnoop -n main # only print process names containing "main" """ parser = argparse.ArgumentParser( description="Trace open() syscalls", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-x", "--failed", action="store_true", help="only show failed opens") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("-t", "--tid", help="trace this TID only") parser.add_argument("-n", "--name", help="only print process names containing this name") args = parser.parse_args() debug = 0 # define BPF program bpf_text = """ #include #include #include struct val_t { u64 id; u64 ts; char comm[TASK_COMM_LEN]; const char *fname; }; struct data_t { u64 id; u64 ts; int ret; char comm[TASK_COMM_LEN]; char fname[NAME_MAX]; }; BPF_HASH(infotmp, u64, struct val_t); BPF_PERF_OUTPUT(events); int trace_entry(struct pt_regs *ctx, const char __user *filename) { struct val_t val = {}; u64 id = bpf_get_current_pid_tgid(); u32 pid = id >> 32; // PID is higher part u32 tid = id; // Cast and get the lower part FILTER if (bpf_get_current_comm(&val.comm, sizeof(val.comm)) == 0) { val.id = id; val.ts = bpf_ktime_get_ns(); val.fname = filename; infotmp.update(&id, &val); } return 0; }; int trace_return(struct pt_regs *ctx) { u64 id = bpf_get_current_pid_tgid(); struct val_t *valp; struct data_t data = {}; u64 tsp = bpf_ktime_get_ns(); valp = infotmp.lookup(&id); if (valp == 0) { // missed entry return 0; } bpf_probe_read(&data.comm, sizeof(data.comm), valp->comm); bpf_probe_read(&data.fname, sizeof(data.fname), (void *)valp->fname); data.id = valp->id; data.ts = tsp / 1000; data.ret = PT_REGS_RC(ctx); events.perf_submit(ctx, &data, sizeof(data)); infotmp.delete(&id); return 0; } """ if args.tid: # TID trumps PID bpf_text = bpf_text.replace('FILTER', 'if (tid != %s) { return 0; }' % args.tid) elif args.pid: bpf_text = bpf_text.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '') if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) b.attach_kprobe(event="sys_open", fn_name="trace_entry") b.attach_kretprobe(event="sys_open", fn_name="trace_return") TASK_COMM_LEN = 16 # linux/sched.h NAME_MAX = 255 # linux/limits.h class Data(ct.Structure): _fields_ = [ ("id", ct.c_ulonglong), ("ts", ct.c_ulonglong), ("ret", ct.c_int), ("comm", ct.c_char * TASK_COMM_LEN), ("fname", ct.c_char * NAME_MAX) ] initial_ts = 0 # header if args.timestamp: print("%-14s" % ("TIME(s)"), end="") print("%-6s %-16s %4s %3s %s" % ("TID" if args.tid else "PID", "COMM", "FD", "ERR", "PATH")) # process event def print_event(cpu, data, size): event = ct.cast(data, ct.POINTER(Data)).contents global initial_ts # split return value into FD and errno columns if event.ret >= 0: fd_s = event.ret err = 0 else: fd_s = -1 err = - event.ret if not initial_ts: initial_ts = event.ts if args.failed and (event.ret >= 0): return if args.name and args.name not in event.comm: return if args.timestamp: delta = event.ts - initial_ts print("%-14.9f" % (float(delta) / 1000000), end="") print("%-6d %-16s %4d %3d %s" % (event.id & 0xffffffff if args.tid else event.id >> 32, event.comm, fd_s, err, event.fname)) # loop with callback to print_event b["events"].open_perf_buffer(print_event) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/opensnoop_example.txt000066400000000000000000000137221305314114400221370ustar00rootroot00000000000000Demonstrations of opensnoop, the Linux eBPF/bcc version. opensnoop traces the open() syscall system-wide, and prints various details. Example output: # ./opensnoop PID COMM FD ERR PATH 17326 <...> 7 0 /sys/kernel/debug/tracing/trace_pipe 1576 snmpd 9 0 /proc/net/dev 1576 snmpd 11 0 /proc/net/if_inet6 1576 snmpd 11 0 /proc/sys/net/ipv4/neigh/eth0/retrans_time_ms 1576 snmpd 11 0 /proc/sys/net/ipv6/neigh/eth0/retrans_time_ms 1576 snmpd 11 0 /proc/sys/net/ipv6/conf/eth0/forwarding 1576 snmpd 11 0 /proc/sys/net/ipv6/neigh/eth0/base_reachable_time_ms 1576 snmpd 11 0 /proc/sys/net/ipv4/neigh/lo/retrans_time_ms 1576 snmpd 11 0 /proc/sys/net/ipv6/neigh/lo/retrans_time_ms 1576 snmpd 11 0 /proc/sys/net/ipv6/conf/lo/forwarding 1576 snmpd 11 0 /proc/sys/net/ipv6/neigh/lo/base_reachable_time_ms 1576 snmpd 9 0 /proc/diskstats 1576 snmpd 9 0 /proc/stat 1576 snmpd 9 0 /proc/vmstat 1956 supervise 9 0 supervise/status.new 1956 supervise 9 0 supervise/status.new 17358 run 3 0 /etc/ld.so.cache 17358 run 3 0 /lib/x86_64-linux-gnu/libtinfo.so.5 17358 run 3 0 /lib/x86_64-linux-gnu/libdl.so.2 17358 run 3 0 /lib/x86_64-linux-gnu/libc.so.6 17358 run -1 6 /dev/tty 17358 run 3 0 /proc/meminfo 17358 run 3 0 /etc/nsswitch.conf 17358 run 3 0 /etc/ld.so.cache 17358 run 3 0 /lib/x86_64-linux-gnu/libnss_compat.so.2 17358 run 3 0 /lib/x86_64-linux-gnu/libnsl.so.1 17358 run 3 0 /etc/ld.so.cache 17358 run 3 0 /lib/x86_64-linux-gnu/libnss_nis.so.2 17358 run 3 0 /lib/x86_64-linux-gnu/libnss_files.so.2 17358 run 3 0 /etc/passwd 17358 run 3 0 ./run ^C While tracing, the snmpd process opened various /proc files (reading metrics), and a "run" process read various libraries and config files (looks like it was starting up: a new process). opensnoop can be useful for discovering configuration and log files, if used during application startup. The -p option can be used to filter on a PID, which is filtered in-kernel. Here I've used it with -T to print timestamps: ./opensnoop -Tp 1956 TIME(s) PID COMM FD ERR PATH 0.000000000 1956 supervise 9 0 supervise/status.new 0.000289999 1956 supervise 9 0 supervise/status.new 1.023068000 1956 supervise 9 0 supervise/status.new 1.023381997 1956 supervise 9 0 supervise/status.new 2.046030000 1956 supervise 9 0 supervise/status.new 2.046363000 1956 supervise 9 0 supervise/status.new 3.068203997 1956 supervise 9 0 supervise/status.new 3.068544999 1956 supervise 9 0 supervise/status.new This shows the supervise process is opening the status.new file twice every second. The -x option only prints failed opens: # ./opensnoop -x PID COMM FD ERR PATH 18372 run -1 6 /dev/tty 18373 run -1 6 /dev/tty 18373 multilog -1 13 lock 18372 multilog -1 13 lock 18384 df -1 2 /usr/share/locale/en_US.UTF-8/LC_MESSAGES/coreutils.mo 18384 df -1 2 /usr/share/locale/en_US.utf8/LC_MESSAGES/coreutils.mo 18384 df -1 2 /usr/share/locale/en_US/LC_MESSAGES/coreutils.mo 18384 df -1 2 /usr/share/locale/en.UTF-8/LC_MESSAGES/coreutils.mo 18384 df -1 2 /usr/share/locale/en.utf8/LC_MESSAGES/coreutils.mo 18384 df -1 2 /usr/share/locale/en/LC_MESSAGES/coreutils.mo 18385 run -1 6 /dev/tty 18386 run -1 6 /dev/tty This caught a df command failing to open a coreutils.mo file, and trying from different directories. The ERR column is the system error number. Error number 2 is ENOENT: no such file or directory. The -n option can be used to filter on process name using partial matches: # ./opensnoop -n ed PID COMM FD ERR PATH 2679 sed 3 0 /etc/ld.so.cache 2679 sed 3 0 /lib/x86_64-linux-gnu/libselinux.so.1 2679 sed 3 0 /lib/x86_64-linux-gnu/libc.so.6 2679 sed 3 0 /lib/x86_64-linux-gnu/libpcre.so.3 2679 sed 3 0 /lib/x86_64-linux-gnu/libdl.so.2 2679 sed 3 0 /lib/x86_64-linux-gnu/libpthread.so.0 2679 sed 3 0 /proc/filesystems 2679 sed 3 0 /usr/lib/locale/locale-archive 2679 sed -1 2 2679 sed 3 0 /usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache 2679 sed 3 0 /dev/null 2680 sed 3 0 /etc/ld.so.cache 2680 sed 3 0 /lib/x86_64-linux-gnu/libselinux.so.1 2680 sed 3 0 /lib/x86_64-linux-gnu/libc.so.6 2680 sed 3 0 /lib/x86_64-linux-gnu/libpcre.so.3 2680 sed 3 0 /lib/x86_64-linux-gnu/libdl.so.2 2680 sed 3 0 /lib/x86_64-linux-gnu/libpthread.so.0 2680 sed 3 0 /proc/filesystems 2680 sed 3 0 /usr/lib/locale/locale-archive 2680 sed -1 2 ^C This caught the 'sed' command because it partially matches 'ed' that's passed to the '-n' option. USAGE message: # ./opensnoop -h usage: opensnoop [-h] [-T] [-x] [-p PID] [-t TID] [-n NAME] Trace open() syscalls optional arguments: -h, --help show this help message and exit -T, --timestamp include timestamp on output -x, --failed only show failed opens -p PID, --pid PID trace this PID only -t TID, --tid TID trace this TID only -n NAME, --name NAME only print process names containing this name examples: ./opensnoop # trace all open() syscalls ./opensnoop -T # include timestamps ./opensnoop -x # only show failed opens ./opensnoop -p 181 # only trace PID 181 ./opensnoop -t 123 # only trace TID 123 ./opensnoop -n main # only print process names containing "main" bpfcc-0.2.0+git0.02884a026/tools/pidpersec.py000077500000000000000000000021741305314114400201750ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # pidpersec Count new processes (via fork). # For Linux, uses BCC, eBPF. See .c file. # # USAGE: pidpersec # # Written as a basic example of counting an event. # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 11-Aug-2015 Brendan Gregg Created this. from bcc import BPF from ctypes import c_int from time import sleep, strftime # load BPF program b = BPF(text=""" #include enum stat_types { S_COUNT = 1, S_MAXSTAT }; BPF_TABLE("array", int, u64, stats, S_MAXSTAT + 1); void stats_increment(int key) { u64 *leaf = stats.lookup(&key); if (leaf) (*leaf)++; } void do_count(struct pt_regs *ctx) { stats_increment(S_COUNT); } """) b.attach_kprobe(event="sched_fork", fn_name="do_count") # stat indexes S_COUNT = c_int(1) # header print("Tracing... Ctrl-C to end.") # output while (1): try: sleep(1) except KeyboardInterrupt: exit() print("%s: PIDs/sec: %d" % (strftime("%H:%M:%S"), b["stats"][S_COUNT].value)) b["stats"].clear() bpfcc-0.2.0+git0.02884a026/tools/pidpersec_example.txt000066400000000000000000000012451305314114400220720ustar00rootroot00000000000000Demonstrations of pidpersec, the Linux eBPF/bcc version. This shows the number of new processes created per second, measured by tracing the kernel fork() routine: # ./pidpersec Tracing... Ctrl-C to end. 18:33:06: PIDs/sec: 4 18:33:07: PIDs/sec: 5 18:33:08: PIDs/sec: 4 18:33:09: PIDs/sec: 4 18:33:10: PIDs/sec: 21 18:33:11: PIDs/sec: 5 18:33:12: PIDs/sec: 4 18:33:13: PIDs/sec: 4 Each second there are four new processes (this happens to be caused by a launcher script that is retrying in a loop, and encountering errors). At 18:33:10, I typed "man ls" in another server session, which caused an increase in the number of new processes as the necessary commands were run. bpfcc-0.2.0+git0.02884a026/tools/profile.py000077500000000000000000000231341305314114400176560ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # profile Profile CPU usage by sampling stack traces at a timed interval. # For Linux, uses BCC, BPF, perf_events. Embedded C. # # This is an efficient profiler, as stack traces are frequency counted in # kernel context, rather than passing every stack to user space for frequency # counting there. Only the unique stacks and counts are passed to user space # at the end of the profile, greatly reducing the kernel<->user transfer. # # This uses perf_event_open to setup a timer which is instrumented by BPF, # and for efficiency it does not initialize the perf ring buffer, so the # redundant perf samples are not collected. # # REQUIRES: Linux 4.9+ (BPF_PROG_TYPE_PERF_EVENT support). Under tools/old is # a version of this tool that may work on Linux 4.6 - 4.8. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # THANKS: Alexei Starovoitov, who added proper BPF profiling support to Linux; # Sasha Goldshtein, Andrew Birchall, and Evgeny Vereshchagin, who wrote much # of the code here, borrowed from tracepoint.py and offcputime.py; and # Teng Qin, who added perf support in bcc. # # 15-Jul-2016 Brendan Gregg Created this. # 20-Oct-2016 " " Switched to use the new 4.9 support. from __future__ import print_function from bcc import BPF, PerfType, PerfSWConfig from sys import stderr from time import sleep import argparse import signal import os import errno import multiprocessing import ctypes as ct # # Process Arguments # # arg validation def positive_int(val): try: ival = int(val) except ValueError: raise argparse.ArgumentTypeError("must be an integer") if ival < 0: raise argparse.ArgumentTypeError("must be positive") return ival def positive_nonzero_int(val): ival = positive_int(val) if ival == 0: raise argparse.ArgumentTypeError("must be nonzero") return ival # arguments examples = """examples: ./profile # profile stack traces at 49 Hertz until Ctrl-C ./profile -F 99 # profile stack traces at 99 Hertz ./profile 5 # profile at 49 Hertz for 5 seconds only ./profile -f 5 # output in folded format for flame graphs ./profile -p 185 # only profile threads for PID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) """ parser = argparse.ArgumentParser( description="Profile CPU stack traces at a timed interval", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) thread_group = parser.add_mutually_exclusive_group() thread_group.add_argument("-p", "--pid", type=positive_int, help="profile this PID only") # TODO: add options for user/kernel threads only stack_group = parser.add_mutually_exclusive_group() stack_group.add_argument("-U", "--user-stacks-only", action="store_true", help="show stacks from user space only (no kernel space stacks)") stack_group.add_argument("-K", "--kernel-stacks-only", action="store_true", help="show stacks from kernel space only (no user space stacks)") parser.add_argument("-F", "--frequency", type=positive_int, default=49, help="sample frequency, Hertz (default 49)") parser.add_argument("-d", "--delimited", action="store_true", help="insert delimiter between kernel/user stacks") parser.add_argument("-a", "--annotations", action="store_true", help="add _[k] annotations to kernel frames") parser.add_argument("-f", "--folded", action="store_true", help="output folded format, one line per stack (for flame graphs)") parser.add_argument("--stack-storage-size", default=10240, type=positive_nonzero_int, help="the number of unique stack traces that can be stored and " "displayed (default 2048)") parser.add_argument("duration", nargs="?", default=99999999, type=positive_nonzero_int, help="duration of trace, in seconds") # option logic args = parser.parse_args() pid = int(args.pid) if args.pid is not None else -1 duration = int(args.duration) debug = 0 need_delimiter = args.delimited and not (args.kernel_stacks_only or args.user_stacks_only) # TODO: add stack depth, and interval # # Setup BPF # # define BPF program bpf_text = """ #include #include #include struct key_t { u32 pid; u64 kernel_ip; u64 kernel_ret_ip; int user_stack_id; int kernel_stack_id; char name[TASK_COMM_LEN]; }; BPF_HASH(counts, struct key_t); BPF_HASH(start, u32); BPF_STACK_TRACE(stack_traces, STACK_STORAGE_SIZE) // This code gets a bit complex. Probably not suitable for casual hacking. int do_perf_event(struct bpf_perf_event_data *ctx) { u32 pid = bpf_get_current_pid_tgid() >> 32; if (!(THREAD_FILTER)) return 0; // create map key u64 zero = 0, *val; struct key_t key = {.pid = pid}; bpf_get_current_comm(&key.name, sizeof(key.name)); // get stacks key.user_stack_id = USER_STACK_GET; key.kernel_stack_id = KERNEL_STACK_GET; if (key.kernel_stack_id >= 0) { // populate extras to fix the kernel stack struct pt_regs regs = {}; bpf_probe_read(®s, sizeof(regs), (void *)&ctx->regs); u64 ip = PT_REGS_IP(®s); // if ip isn't sane, leave key ips as zero for later checking #ifdef CONFIG_RANDOMIZE_MEMORY if (ip > __PAGE_OFFSET_BASE) { #else if (ip > PAGE_OFFSET) { #endif key.kernel_ip = ip; } } val = counts.lookup_or_init(&key, &zero); (*val)++; return 0; } """ # set thread filter thread_context = "" perf_filter = "-a" if args.pid is not None: thread_context = "PID %s" % args.pid thread_filter = 'pid == %s' % args.pid perf_filter = '-p %s' % args.pid else: thread_context = "all threads" thread_filter = '1' bpf_text = bpf_text.replace('THREAD_FILTER', thread_filter) # set stack storage size bpf_text = bpf_text.replace('STACK_STORAGE_SIZE', str(args.stack_storage_size)) # handle stack args kernel_stack_get = \ "stack_traces.get_stackid(&ctx->regs, 0 | BPF_F_REUSE_STACKID)" user_stack_get = \ "stack_traces.get_stackid(&ctx->regs, 0 | BPF_F_REUSE_STACKID | " \ "BPF_F_USER_STACK)" stack_context = "" if args.user_stacks_only: stack_context = "user" kernel_stack_get = "-1" elif args.kernel_stacks_only: stack_context = "kernel" user_stack_get = "-1" else: stack_context = "user + kernel" bpf_text = bpf_text.replace('USER_STACK_GET', user_stack_get) bpf_text = bpf_text.replace('KERNEL_STACK_GET', kernel_stack_get) # header if not args.folded: print("Sampling at %d Hertz of %s by %s stack" % (args.frequency, thread_context, stack_context), end="") if duration < 99999999: print(" for %d secs." % duration) else: print("... Hit Ctrl-C to end.") if debug: print(bpf_text) # initialize BPF & perf_events b = BPF(text=bpf_text) b.attach_perf_event(ev_type=PerfType.SOFTWARE, ev_config=PerfSWConfig.CPU_CLOCK, fn_name="do_perf_event", sample_period=0, sample_freq=args.frequency) # signal handler def signal_ignore(signal, frame): print() # # Output Report # # collect samples try: sleep(duration) except KeyboardInterrupt: # as cleanup can take some time, trap Ctrl-C: signal.signal(signal.SIGINT, signal_ignore) if not args.folded: print() def aksym(addr): if args.annotations: return b.ksym(addr) + "_[k]" else: return b.ksym(addr) # output stacks missing_stacks = 0 has_enomem = False counts = b.get_table("counts") stack_traces = b.get_table("stack_traces") for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): # handle get_stackid erorrs if (not args.user_stacks_only and k.kernel_stack_id < 0 and k.kernel_stack_id != -errno.EFAULT) or \ (not args.kernel_stacks_only and k.user_stack_id < 0 and k.user_stack_id != -errno.EFAULT): missing_stacks += 1 # check for an ENOMEM error if k.kernel_stack_id == -errno.ENOMEM or \ k.user_stack_id == -errno.ENOMEM: has_enomem = True user_stack = [] if k.user_stack_id < 0 else \ stack_traces.walk(k.user_stack_id) kernel_tmp = [] if k.kernel_stack_id < 0 else \ stack_traces.walk(k.kernel_stack_id) # fix kernel stack kernel_stack = [] if k.kernel_stack_id >= 0: for addr in kernel_tmp: kernel_stack.append(addr) # the later IP checking if k.kernel_ip: kernel_stack.insert(0, k.kernel_ip) do_delimiter = need_delimiter and kernel_stack if args.folded: # print folded stack output user_stack = list(user_stack) kernel_stack = list(kernel_stack) line = [k.name.decode()] + \ [b.sym(addr, k.pid) for addr in reversed(user_stack)] + \ (do_delimiter and ["-"] or []) + \ [aksym(addr) for addr in reversed(kernel_stack)] print("%s %d" % (";".join(line), v.value)) else: # print default multi-line stack output. for addr in kernel_stack: print(" %s" % aksym(addr)) if do_delimiter: print(" --") for addr in user_stack: print(" %s" % b.sym(addr, k.pid)) print(" %-16s %s (%d)" % ("-", k.name, k.pid)) print(" %d\n" % v.value) # check missing if missing_stacks > 0: enomem_str = "" if not has_enomem else \ " Consider increasing --stack-storage-size." print("WARNING: %d stack traces could not be displayed.%s" % (missing_stacks, enomem_str), file=stderr) bpfcc-0.2.0+git0.02884a026/tools/profile_example.txt000066400000000000000000000716231305314114400215630ustar00rootroot00000000000000Demonstrations of profile, the Linux eBPF/bcc version. This is a CPU profiler. It works by taking samples of stack traces at timed intervals, and frequency counting them in kernel context for efficiency. Example output: # ./profile Sampling at 49 Hertz of all threads by user + kernel stack... Hit Ctrl-C to end. ^C filemap_map_pages handle_mm_fault __do_page_fault do_page_fault page_fault [unknown] - cp (9036) 1 [unknown] [unknown] - sign-file (8877) 1 __clear_user iov_iter_zero read_iter_zero __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath read - dd (25036) 4 func_a main __libc_start_main [unknown] - func_ab (13549) 5 [...] native_safe_halt default_idle arch_cpu_idle default_idle_call cpu_startup_entry rest_init start_kernel x86_64_start_reservations x86_64_start_kernel - swapper/0 (0) 72 native_safe_halt default_idle arch_cpu_idle default_idle_call cpu_startup_entry start_secondary - swapper/1 (0) 75 The output was long; I truncated some lines ("[...]"). This default output prints stack traces, followed by a line to describe the process (a dash, the process name, and a PID in parenthesis), and then an integer count of how many times this stack trace was sampled. The output above shows the most frequent stack was from the "swapper/1" process (PID 0), running the native_safe_halt() function, which was called by default_idle(), which was called by arch_cpu_idle(), and so on. This is the idle thread. Stacks can be read top-down, to follow ancestry: child, parent, grandparent, etc. The func_ab process is running the func_a() function, called by main(), called by __libc_start_main(), and called by "[unknown]" with what looks like a bogus address (1st column). That's evidence of a broken stack trace. It's common for user-level software that hasn't been compiled with frame pointers (in this case, libc). The dd process has called read(), and then enters the kernel via entry_SYSCALL_64_fastpath(), calling sys_read(), and so on. Yes, I'm now reading it bottom up. That way follows the code flow. The dd process is actually "dd if=/dev/zero of=/dev/null": it's a simple workload to analyze that just moves bytes from /dev/zero to /dev/null. Profiling just that process: # ./profile -p 25036 Sampling at 49 Hertz of PID 25036 by user + kernel stack... Hit Ctrl-C to end. ^C [unknown] [unknown] - dd (25036) 1 __write - dd (25036) 1 read - dd (25036) 1 [...] [unknown] [unknown] - dd (25036) 2 entry_SYSCALL_64_fastpath __write [unknown] - dd (25036) 3 entry_SYSCALL_64_fastpath read - dd (25036) 3 __clear_user iov_iter_zero read_iter_zero __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath read [unknown] - dd (25036) 3 __clear_user iov_iter_zero read_iter_zero __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath read - dd (25036) 7 Again, I've truncated some lines. Now we're just analyzing the dd process. The filtering is performed in kernel context, for efficiency. This output has some "[unknown]" frames that probably have valid addresses, but we're lacking the symbol translation. This is a common for all profilers on Linux, and is usually fixable. See the DEBUGGING section of the profile(8) man page. Lets add delimiters between the user and kernel stacks, using -d: # ./profile -p 25036 -d ^C __vfs_write sys_write entry_SYSCALL_64_fastpath -- __write - dd (25036) 1 -- [unknown] [unknown] - dd (25036) 1 iov_iter_init __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath -- read - dd (25036) 1 [...] __clear_user iov_iter_zero read_iter_zero __vfs_read vfs_read sys_read entry_SYSCALL_64_fastpath -- read - dd (25036) 9 In this mode, the delimiters are "--". Here's another example, a func_ab program that runs two functions, func_a() and func_b(). Profiling it for 5 seconds: # ./profile -p `pgrep -n func_ab` 5 Sampling at 49 Hertz of PID 2930 by user + kernel stack for 5 secs. func_a main __libc_start_main [unknown] - func_ab (2930) 2 func_b main __libc_start_main [unknown] - func_ab (2930) 3 func_a main __libc_start_main [unknown] - func_ab (2930) 5 func_b main __libc_start_main [unknown] - func_ab (2930) 12 func_b main __libc_start_main [unknown] - func_ab (2930) 19 func_a main __libc_start_main [unknown] - func_ab (2930) 22 func_b main __libc_start_main [unknown] - func_ab (2930) 64 func_a main __libc_start_main [unknown] - func_ab (2930) 72 Note that the same stack (2nd column) seems to be repeated. Weren't we doing frequency counting and only printing unique stacks? We are, but in terms of the raw addresses, not the symbols. See the 1st column: those stacks are all unique. We can output in "folded format", which puts the stack trace on one line, separating frames with semi-colons. Eg: # ./profile -f -p `pgrep -n func_ab` 5 func_ab;[unknown];__libc_start_main;main;func_a 2 func_ab;[unknown];__libc_start_main;main;func_b 2 func_ab;[unknown];__libc_start_main;main;func_a 11 func_ab;[unknown];__libc_start_main;main;func_b 12 func_ab;[unknown];__libc_start_main;main;func_a 23 func_ab;[unknown];__libc_start_main;main;func_b 28 func_ab;[unknown];__libc_start_main;main;func_b 57 func_ab;[unknown];__libc_start_main;main;func_a 64 I find this pretty useful for writing to files and later grepping. Folded format can also be used by flame graph stack visualizers, including the original implementation: https://github.com/brendangregg/FlameGraph I'd include delimiters, -d. For example: # ./profile -df -p `pgrep -n func_ab` 5 > out.profile # git clone https://github.com/brendangregg/FlameGraph # ./FlameGraph/flamegraph.pl < out.profile > out.svg (Yes, I could pipe profile directly into flamegraph.pl, however, I like to keep the raw folded profiles around: can be useful for regenerating flamegraphs with different options, and, for differential flame graphs.) Some flamegraph.pl palettes recognize kernel annotations, which can be added with -a. It simply adds a "_[k]" at the end of kernel function names. For example: # ./profile -adf -p `pgrep -n dd` 10 dd;[unknown] 1 dd;[unknown];[unknown] 1 dd;[unknown];[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];__fsnotify_parent_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__fsnotify_parent_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fdget_pos_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];__fsnotify_parent_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__fsnotify_parent_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fsnotify_parent_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];fsnotify_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fdget_pos_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;[unknown] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];__fsnotify_parent_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];security_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];fsnotify_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];fsnotify_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__fsnotify_parent_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];iov_iter_init_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];__fsnotify_parent_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__vfs_write_[k];write_null_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];__clear_user_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];security_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__vfs_read_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__vfs_write_[k] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fsnotify_parent_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];__write;-;sys_write_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fsnotify_parent_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];common_file_perm_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];[unknown] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];vfs_read_[k] 1 dd;__write 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 1 dd;[unknown];[unknown] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;[unknown] 1 dd;[unknown] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;__write 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];[unknown] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fdget_pos_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];_cond_resched_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];iov_iter_init_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];__fsnotify_parent_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];rw_verify_area_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 1 dd;[unknown] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];fsnotify_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fdget_pos_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];__vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fget_light_[k] 1 dd;[unknown] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];fsnotify_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];fsnotify_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 1 dd;__write;-;entry_SYSCALL_64_fastpath_[k];vfs_write_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 1 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k] 1 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];fsnotify_[k] 1 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];apparmor_file_permission_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];__fdget_pos_[k] 2 dd;[unknown];[unknown] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];__fdget_pos_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k];common_file_perm_[k] 2 dd;[unknown];[unknown] 2 dd;[unknown];[unknown] 2 dd;[unknown];[unknown] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 2 dd;[unknown];[unknown] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];__clear_user_[k] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];__fdget_pos_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 2 dd;[unknown];[unknown] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];rw_verify_area_[k];security_file_permission_[k];fsnotify_[k] 2 dd;__write;-;sys_write_[k] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];fsnotify_[k] 2 dd;[unknown];[unknown] 2 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 2 dd;read;-;SyS_read_[k] 2 dd;[unknown] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k] 2 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];__fget_light_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k] 2 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k];rw_verify_area_[k];security_file_permission_[k];apparmor_file_permission_[k] 2 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];__clear_user_[k] 2 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];rw_verify_area_[k] 2 dd;[unknown];[unknown] 3 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];rw_verify_area_[k] 3 dd;[unknown];[unknown] 3 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 3 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 3 dd;[unknown];[unknown] 3 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 3 dd;[unknown];[unknown] 3 dd;[unknown];[unknown] 3 dd;__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 3 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 3 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 3 dd;[unknown] 4 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 4 dd;[unknown];[unknown] 4 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k] 4 dd;[unknown] 4 dd;[unknown];[unknown] 4 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k] 4 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 5 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k];sys_write_[k];vfs_write_[k] 5 dd;[unknown];[unknown] 5 dd;[unknown];[unknown] 5 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k] 6 dd;read 15 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 19 dd;[unknown];__write;-;entry_SYSCALL_64_fastpath_[k] 20 dd;read;-;entry_SYSCALL_64_fastpath_[k] 23 dd;read;-;entry_SYSCALL_64_fastpath_[k];SyS_read_[k];vfs_read_[k];__vfs_read_[k];read_iter_zero_[k];iov_iter_zero_[k];__clear_user_[k] 24 dd;__write;-;entry_SYSCALL_64_fastpath_[k] 25 dd;__write 29 dd;[unknown];read;-;entry_SYSCALL_64_fastpath_[k] 31 This can be made into a flamegraph. Eg: # ./profile -adf -p `pgrep -n func_ab` 10 > out.profile # git clone https://github.com/brendangregg/FlameGraph # ./FlameGraph/flamegraph.pl --color=java < out.profile > out.svg It will highlight the kernel frames in orange, and user-level in red (and Java in green, and C++ in yellow). If you copy-n-paste the above output into a out.profile file, you can try it out. You can increase or decrease the sample frequency. Eg, sampling at 9 Hertz: # ./profile -F 9 Sampling at 9 Hertz of all threads by user + kernel stack... Hit Ctrl-C to end. ^C func_b main __libc_start_main [unknown] - func_ab (2930) 1 [...] native_safe_halt default_idle arch_cpu_idle default_idle_call cpu_startup_entry start_secondary - swapper/3 (0) 8 native_safe_halt default_idle arch_cpu_idle default_idle_call cpu_startup_entry rest_init start_kernel x86_64_start_reservations x86_64_start_kernel - swapper/0 (0) 8 You can also restrict profiling to just kernel stacks (-K) or user stacks (-U). For example, just user stacks: # ./profile -U Sampling at 49 Hertz of all threads by user stack... Hit Ctrl-C to end. ^C [unknown] [unknown] - dd (2931) 1 [unknown] [unknown] - dd (2931) 1 [unknown] [unknown] - dd (2931) 1 [unknown] [unknown] - dd (2931) 1 [unknown] [unknown] - dd (2931) 1 func_b main __libc_start_main [unknown] - func_ab (2930) 1 [unknown] - dd (2931) 1 [unknown] - dd (2931) 1 func_a main __libc_start_main [unknown] - func_ab (2930) 3 __write [unknown] - dd (2931) 3 func_a main __libc_start_main [unknown] - func_ab (2930) 4 func_b main __libc_start_main [unknown] - func_ab (2930) 7 - swapper/6 (0) 10 func_b main __libc_start_main [unknown] - func_ab (2930) 10 __write - dd (2931) 10 func_a main __libc_start_main [unknown] - func_ab (2930) 11 read - dd (2931) 12 read [unknown] - dd (2931) 14 - swapper/7 (0) 46 - swapper/0 (0) 46 - swapper/2 (0) 46 - swapper/1 (0) 46 - swapper/3 (0) 46 - swapper/4 (0) 46 If there are too many unique stack traces for the kernel to save, a warning will be printed. Eg: # ./profile [...] WARNING: 8 stack traces could not be displayed. Consider increasing --stack-storage-size. Run ./profile -h to see the default. USAGE message: # ./profile -h usage: profile [-h] [-p PID] [-U | -K] [-F FREQUENCY] [-d] [-a] [-f] [--stack-storage-size STACK_STORAGE_SIZE] [duration] Profile CPU stack traces at a timed interval positional arguments: duration duration of trace, in seconds optional arguments: -h, --help show this help message and exit -p PID, --pid PID profile this PID only -U, --user-stacks-only show stacks from user space only (no kernel space stacks) -K, --kernel-stacks-only show stacks from kernel space only (no user space stacks) -F FREQUENCY, --frequency FREQUENCY sample frequency, Hertz (default 49) -d, --delimited insert delimiter between kernel/user stacks -a, --annotations add _[k] annotations to kernel frames -f, --folded output folded format, one line per stack (for flame graphs) --stack-storage-size STACK_STORAGE_SIZE the number of unique stack traces that can be stored and displayed (default 2048) examples: ./profile # profile stack traces at 49 Hertz until Ctrl-C ./profile -F 99 # profile stack traces at 99 Hertz ./profile 5 # profile at 49 Hertz for 5 seconds only ./profile -f 5 # output in folded format for flame graphs ./profile -p 185 # only profile threads for PID 185 ./profile -U # only show user space stacks (no kernel) ./profile -K # only show kernel space stacks (no user) bpfcc-0.2.0+git0.02884a026/tools/reset-trace.sh000077500000000000000000000066501305314114400204220ustar00rootroot00000000000000#!/bin/bash # # reset-trace - reset state of tracing, disabling all tracing. # Written for Linux. # # If a bcc tool crashed and you suspect tracing is partially enabled, you # can use this tool to reset the state of tracing, disabling anything still # enabled. Only use this tool in the case of error, and, consider filing a # bcc ticket so we can fix the error. # # bcc-used tracing facilities are reset. Other tracing facilities (ftrace) are # checked, and if not in an expected state, a note is printed. All tracing # files can be reset with -F for force, but this will interfere with any other # running tracing sessions (eg, ftrace). # # USAGE: ./reset-trace [-Fhqv] # # REQUIREMENTS: debugfs mounted on /sys/kernel/debug # # COPYRIGHT: Copyright (c) 2016 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Jul-2014 Brendan Gregg Created this. # 18-Oct-2016 " " Updated for bcc use. tracing=/sys/kernel/debug/tracing opt_force=0; opt_verbose=0; opt_quiet=0 function usage { cat <<-END >&2 USAGE: reset-trace [-Fhqv] -F # force: reset all tracing files -v # verbose: print details while working -h # this usage message -q # quiet: no output eg, reset-trace # disable semi-enabled tracing END exit } function die { echo >&2 "$@" exit 1 } function vecho { (( ! opt_verbose )) && return echo "$@" } function writefile { file=$1 write=$2 if [[ ! -w $file ]]; then echo >&2 "WARNING: file $file not writable/exists. Skipping." return fi vecho "Checking $PWD/$file" contents=$(grep -v '^#' $file) if [[ "$contents" != "$expected" ]]; then (( ! opt_quiet )) && echo "Needed to reset $PWD/$file" vecho "$file, before (line enumerated):" (( opt_verbose )) && cat -nv $file cmd="echo $write > $file" if ! eval "$cmd"; then echo >&2 "WARNING: command failed \"$cmd\"." \ "bcc still running? Continuing." fi vecho "$file, after (line enumerated):" (( opt_verbose )) && cat -nv $file vecho fi } # only write when force is used function checkfile { file=$1 write=$2 expected=$3 if [[ ! -e $file ]]; then echo >&2 "WARNING: file $file doesn't exist. Skipping." return fi if (( opt_force )); then writefile $file $write return fi (( opt_quiet )) && return vecho "Checking $PWD/$file" contents=$(grep -v '^#' $file) if [[ "$contents" != "$expected" ]]; then echo "Noticed unrelated tracing file $PWD/$file isn't set as" \ "expected. Not reseting (-F to force, -v for verbose)." vecho "Contents of $file is (line enumerated):" (( opt_verbose )) && cat -nv $file vecho "Expected \"$expected\"." fi } ### process options while getopts Fhqv opt do case $opt in F) opt_force=1 ;; q) opt_quiet=1 ;; v) opt_verbose=1 ;; h|?) usage ;; esac done shift $(( $OPTIND - 1 )) ### reset tracing state vecho "Reseting tracing state..." vecho cd $tracing || die "ERROR: accessing tracing. Root user? /sys/kernel/debug?" # files bcc uses writefile kprobe_events "" "" writefile uprobe_events "" "" writefile trace "" "" # clears trace_pipe # non-bcc files checkfile current_tracer nop nop checkfile set_ftrace_filter "" "" checkfile set_graph_function "" "" checkfile set_ftrace_pid "" "no pid" checkfile events/enable 0 0 checkfile tracing_thresh 0 0 checkfile tracing_on 1 1 vecho vecho "Done." bpfcc-0.2.0+git0.02884a026/tools/reset-trace_example.txt000066400000000000000000000222201305314114400223260ustar00rootroot00000000000000Demonstrations of reset-trace, for Linux bcc/BPF. You will probably never need this tool. If you kill -9 a bcc tool (plus other signals, like SIGTERM), or if a bcc tool crashes, then kernel tracing can be left in a semi-enabled state. It's not as bad as it sounds: there may just be overhead for writing to ring buffers that are never read. This tool can be used to clean up the tracing state, and reset and disable active tracing. WARNING: Make sure no other tracing sessions are active, as it will likely stop them from functioning (perhaps ungracefully). This specifically clears the state in at least the following files in /sys/kernel/debug/tracing: kprobe_events, uprobe_events, trace_pipe. Other tracing facilities (ftrace) are checked, and if not in an expected state, a note is printed. All tracing files can be reset with -F for force, but this will interfere with any other running tracing sessions (eg, ftrace). Here's an example: # ./reset-trace.sh # That's it. You can use -v to see what it does: # ./reset-trace.sh -v Reseting tracing state... Checking /sys/kernel/debug/tracing/kprobe_events Checking /sys/kernel/debug/tracing/uprobe_events Checking /sys/kernel/debug/tracing/trace Checking /sys/kernel/debug/tracing/current_tracer Checking /sys/kernel/debug/tracing/set_ftrace_filter Checking /sys/kernel/debug/tracing/set_graph_function Checking /sys/kernel/debug/tracing/set_ftrace_pid Checking /sys/kernel/debug/tracing/events/enable Checking /sys/kernel/debug/tracing/tracing_thresh Checking /sys/kernel/debug/tracing/tracing_on Done. In this example, no resetting was necessary. Here's an example of actually needing it: # ./funccount 'bash:r*' Tracing 317 functions for "bash:r*"... Hit Ctrl-C to end. ^C FUNC COUNT rl_free_undo_list 1 rl_deprep_terminal 1 readline_internal_teardown 1 rl_on_new_line 1 rl_crlf 1 rl_clear_signals 1 rl_prep_terminal 1 rl_reset_line_state 1 rl_initialize 1 rl_newline 1 readline_internal_setup 1 rl_set_screen_size 1 readline 1 rl_set_signals 1 rl_expand_prompt 1 replace_history_data 1 rl_set_prompt 1 rl_add_undo 1 rl_insert_text 2 rl_insert 2 rl_redisplay 3 rl_read_key 3 rl_getc 3 readline_internal_char 3 restore_parser_state 6 reap_dead_jobs 6 reset_parser 6 restore_input_line_state 6 realloc 7 read_octal 10 read_tty_modified 13 run_exit_trap 13 redirection_expand 13 restore_pipestatus_array 18 reader_loop 20 run_return_trap 21 remember_args 25 reset_signal_handlers 30 remove_quoted_escapes 60 run_unwind_frame 102 reset_terminating_signals 125 restore_original_signals 139 reset_internal_getopt 405 run_debug_trap 719 read_command 940 remove_quoted_nulls 1830 run_pending_traps 3207 ^C ^C ^C I've traced 317 functions using funccount, and when I hit Ctrl-C, funccount is not exiting (it can normally take many seconds, but this really looks stuck): # pidstat 1 Linux 4.9.0-rc1-virtual (bgregg-xenial-bpf-i-xxx) 10/18/2016 _x86_64_ (8 CPU) 10:00:33 PM UID PID %usr %system %guest %CPU CPU Command 10:00:34 PM 60004 3277 0.00 0.98 0.00 0.98 0 redis-server 10:00:34 PM 0 27980 87.25 10.78 0.00 98.04 3 funccount.py 10:00:34 PM 0 29965 0.00 0.98 0.00 0.98 6 pidstat 10:00:34 PM UID PID %usr %system %guest %CPU CPU Command 10:00:35 PM 65534 3276 0.00 1.00 0.00 1.00 2 multilog 10:00:35 PM 0 27980 77.00 23.00 0.00 100.00 3 funccount.py 10:00:35 PM 0 29965 0.00 1.00 0.00 1.00 6 pidstat 10:00:35 PM 60004 29990 0.00 1.00 0.00 1.00 6 catalina.sh funccount looks a lot like it's in an infinite loop (I can use a stack-sampling profiler to confirm). This is a known bug (#665) and may be fixed by the time you read this. But right now it's a good example of needing reset-trace. I'll send a SIGTERM, before resorting to a SIGKILL: # kill 27980 Terminated Ok, so the process is now gone, but it did leave tracing in a semi-enabled state. Using reset-trace: # ./reset-trace.sh -v Reseting tracing state... Checking /sys/kernel/debug/tracing/kprobe_events Checking /sys/kernel/debug/tracing/uprobe_events Needed to reset /sys/kernel/debug/tracing/uprobe_events uprobe_events, before (line enumerated): 1 p:uprobes/p__bin_bash_0xa2540 /bin/bash:0x00000000000a2540 2 p:uprobes/p__bin_bash_0x21220 /bin/bash:0x0000000000021220 3 p:uprobes/p__bin_bash_0x78530 /bin/bash:0x0000000000078530 4 p:uprobes/p__bin_bash_0xa3840 /bin/bash:0x00000000000a3840 5 p:uprobes/p__bin_bash_0x9c550 /bin/bash:0x000000000009c550 6 p:uprobes/p__bin_bash_0x5e360 /bin/bash:0x000000000005e360 7 p:uprobes/p__bin_bash_0xb2630 /bin/bash:0x00000000000b2630 8 p:uprobes/p__bin_bash_0xb1e70 /bin/bash:0x00000000000b1e70 9 p:uprobes/p__bin_bash_0xb2540 /bin/bash:0x00000000000b2540 10 p:uprobes/p__bin_bash_0xb16e0 /bin/bash:0x00000000000b16e0 [...] 312 p:uprobes/p__bin_bash_0xa80b0 /bin/bash:0x00000000000a80b0 313 p:uprobes/p__bin_bash_0x9e280 /bin/bash:0x000000000009e280 314 p:uprobes/p__bin_bash_0x9e100 /bin/bash:0x000000000009e100 315 p:uprobes/p__bin_bash_0xb2bd0 /bin/bash:0x00000000000b2bd0 316 p:uprobes/p__bin_bash_0x9d9c0 /bin/bash:0x000000000009d9c0 317 p:uprobes/p__bin_bash_0x4a930 /bin/bash:0x000000000004a930 uprobe_events, after (line enumerated): Checking /sys/kernel/debug/tracing/trace Checking /sys/kernel/debug/tracing/current_tracer Checking /sys/kernel/debug/tracing/set_ftrace_filter Checking /sys/kernel/debug/tracing/set_graph_function Checking /sys/kernel/debug/tracing/set_ftrace_pid Checking /sys/kernel/debug/tracing/events/enable Checking /sys/kernel/debug/tracing/tracing_thresh Checking /sys/kernel/debug/tracing/tracing_on Done. Now looks clean. I did truncate the output here: there were a few hundred lines from uprobe_events. Here's the same situation, but without the verbose option: # ./reset-trace.sh Needed to reset /sys/kernel/debug/tracing/uprobe_events # And again with quiet: # ./reset-trace.sh -q # Here is an example of reset-trace detecting an unrelated tracing session: # ./reset-trace.sh Noticed unrelated tracing file /sys/kernel/debug/tracing/set_ftrace_filter isn't set as expected. Not reseting (-F to force, -v for verbose). And verbose: # ./reset-trace.sh -v Reseting tracing state... Checking /sys/kernel/debug/tracing/kprobe_events Checking /sys/kernel/debug/tracing/uprobe_events Checking /sys/kernel/debug/tracing/trace Checking /sys/kernel/debug/tracing/current_tracer Checking /sys/kernel/debug/tracing/set_ftrace_filter Noticed unrelated tracing file /sys/kernel/debug/tracing/set_ftrace_filter isn't set as expected. Not reseting (-F to force, -v for verbose). Contents of set_ftrace_filter is (line enumerated): 1 tcp_send_mss 2 tcp_sendpage 3 tcp_sendmsg 4 tcp_send_dupack 5 tcp_send_challenge_ack.isra.53 6 tcp_send_rcvq 7 tcp_send_ack 8 tcp_send_loss_probe 9 tcp_send_fin 10 tcp_send_active_reset 11 tcp_send_synack 12 tcp_send_delayed_ack 13 tcp_send_window_probe 14 tcp_send_probe0 Expected "". Checking /sys/kernel/debug/tracing/set_graph_function Checking /sys/kernel/debug/tracing/set_ftrace_pid Checking /sys/kernel/debug/tracing/events/enable Checking /sys/kernel/debug/tracing/tracing_thresh Checking /sys/kernel/debug/tracing/tracing_on Done. So this file is not currently used by bcc, but it may be useful to know that it's not in the default state -- something is either using it or has left it enabled. These files can be reset with -F, but that may break other tools that are currently using them. Use -h to print the USAGE message: # ./reset-trace.sh -h USAGE: reset-trace [-Fhqv] -F # force: reset all tracing files -v # verbose: print details while working -h # this usage message -q # quiet: no output eg, reset-trace # disable semi-enabled tracing bpfcc-0.2.0+git0.02884a026/tools/runqlat.py000077500000000000000000000123241305314114400177030ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # runqlat Run queue (scheduler) latency as a histogram. # For Linux, uses BCC, eBPF. # # USAGE: runqlat [-h] [-T] [-m] [-P] [-L] [-p PID] [interval] [count] # # This measures the time a task spends waiting on a run queue for a turn # on-CPU, and shows this time as a histogram. This time should be small, but a # task may need to wait its turn due to CPU load. # # This measures two types of run queue latency: # 1. The time from a task being enqueued on a run queue to its context switch # and execution. This traces enqueue_task_*() -> finish_task_switch(), # and instruments the run queue latency after a voluntary context switch. # 2. The time from when a task was involuntary context switched and still # in the runnable state, to when it next executed. This is instrumented # from finish_task_switch() alone. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 07-Feb-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse # arguments examples = """examples: ./runqlat # summarize run queue latency as a histogram ./runqlat 1 10 # print 1 second summaries, 10 times ./runqlat -mT 1 # 1s summaries, milliseconds, and timestamps ./runqlat -P # show each PID separately ./runqlat -p 185 # trace PID 185 only """ parser = argparse.ArgumentParser( description="Summarize run queue (schedular) latency as a histogram", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-m", "--milliseconds", action="store_true", help="millisecond histogram") parser.add_argument("-P", "--pids", action="store_true", help="print a histogram per process ID") parser.add_argument("-L", "--tids", action="store_true", help="print a histogram per thread ID") parser.add_argument("-p", "--pid", help="trace this PID only") parser.add_argument("interval", nargs="?", default=99999999, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() countdown = int(args.count) debug = 0 # define BPF program bpf_text = """ #include #include typedef struct pid_key { u64 id; // work around u64 slot; } pid_key_t; BPF_HASH(start, u32); STORAGE struct rq; // record enqueue timestamp int trace_enqueue(struct pt_regs *ctx, struct rq *rq, struct task_struct *p, int flags) { u32 tgid = p->tgid; u32 pid = p->pid; if (FILTER) return 0; u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); return 0; } // calculate latency int trace_run(struct pt_regs *ctx, struct task_struct *prev) { u32 pid, tgid; // ivcsw: treat like an enqueue event and store timestamp if (prev->state == TASK_RUNNING) { tgid = prev->tgid; pid = prev->pid; if (!(FILTER)) { u64 ts = bpf_ktime_get_ns(); start.update(&pid, &ts); } } tgid = bpf_get_current_pid_tgid() >> 32; pid = bpf_get_current_pid_tgid(); if (FILTER) return 0; u64 *tsp, delta; // fetch timestamp and calculate delta tsp = start.lookup(&pid); if (tsp == 0) { return 0; // missed enqueue } delta = bpf_ktime_get_ns() - *tsp; FACTOR // store as histogram STORE start.delete(&pid); return 0; } """ # code substitutions if args.pid: # pid from userspace point of view is thread group from kernel pov bpf_text = bpf_text.replace('FILTER', 'tgid != %s' % args.pid) else: bpf_text = bpf_text.replace('FILTER', '0') if args.milliseconds: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000000;') label = "msecs" else: bpf_text = bpf_text.replace('FACTOR', 'delta /= 1000;') label = "usecs" if args.pids or args.tids: section = "pid" pid = "tgid" if args.tids: pid = "pid" section = "tid" bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist, pid_key_t);') bpf_text = bpf_text.replace('STORE', 'pid_key_t key = {.id = ' + pid + ', .slot = bpf_log2l(delta)}; ' + 'dist.increment(key);') else: section = "" bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist);') bpf_text = bpf_text.replace('STORE', 'dist.increment(bpf_log2l(delta));') if debug: print(bpf_text) # load BPF program b = BPF(text=bpf_text) b.attach_kprobe(event_re="enqueue_task_*", fn_name="trace_enqueue") b.attach_kprobe(event="finish_task_switch", fn_name="trace_run") print("Tracing run queue latency... Hit Ctrl-C to end.") # output exiting = 0 if args.interval else 1 dist = b.get_table("dist") while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") dist.print_log2_hist(label, section, section_print_fn=int) dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/runqlat_example.txt000066400000000000000000000701571305314114400216120ustar00rootroot00000000000000Demonstrations of runqlat, the Linux eBPF/bcc version. This program summarizes scheduler run queue latency as a histogram, showing how long tasks spent waiting their turn to run on-CPU. Here is a heavily loaded system: # ./runqlat Tracing run queue latency... Hit Ctrl-C to end. ^C usecs : count distribution 0 -> 1 : 233 |*********** | 2 -> 3 : 742 |************************************ | 4 -> 7 : 203 |********** | 8 -> 15 : 173 |******** | 16 -> 31 : 24 |* | 32 -> 63 : 0 | | 64 -> 127 : 30 |* | 128 -> 255 : 6 | | 256 -> 511 : 3 | | 512 -> 1023 : 5 | | 1024 -> 2047 : 27 |* | 2048 -> 4095 : 30 |* | 4096 -> 8191 : 20 | | 8192 -> 16383 : 29 |* | 16384 -> 32767 : 809 |****************************************| 32768 -> 65535 : 64 |*** | The distribution is bimodal, with one mode between 0 and 15 microseconds, and another between 16 and 65 milliseconds. These modes are visible as the spikes in the ASCII distribution (which is merely a visual representation of the "count" column). As an example of reading one line: 809 events fell into the 16384 to 32767 microsecond range (16 to 32 ms) while tracing. I would expect the two modes to be due the workload: 16 hot CPU-bound threads, and many other mostly idle threads doing occasional work. I suspect the mostly idle threads will run with a higher priority when they wake up, and are the reason for the low latency mode. The high latency mode will be the CPU-bound threads. More analysis with this and other tools can confirm. A -m option can be used to show milliseconds instead, as well as an interval and a count. For example, showing three x five second summary in milliseconds: # ./runqlat -m 5 3 Tracing run queue latency... Hit Ctrl-C to end. msecs : count distribution 0 -> 1 : 3818 |****************************************| 2 -> 3 : 39 | | 4 -> 7 : 39 | | 8 -> 15 : 62 | | 16 -> 31 : 2214 |*********************** | 32 -> 63 : 226 |** | msecs : count distribution 0 -> 1 : 3775 |****************************************| 2 -> 3 : 52 | | 4 -> 7 : 37 | | 8 -> 15 : 65 | | 16 -> 31 : 2230 |*********************** | 32 -> 63 : 212 |** | msecs : count distribution 0 -> 1 : 3816 |****************************************| 2 -> 3 : 49 | | 4 -> 7 : 40 | | 8 -> 15 : 53 | | 16 -> 31 : 2228 |*********************** | 32 -> 63 : 221 |** | This shows a similar distribution across the three summaries. A -p option can be used to show one PID only, which is filtered in kernel for efficiency. For example, PID 4505, and one second summaries: # ./runqlat -mp 4505 1 Tracing run queue latency... Hit Ctrl-C to end. msecs : count distribution 0 -> 1 : 1 |* | 2 -> 3 : 2 |*** | 4 -> 7 : 1 |* | 8 -> 15 : 0 | | 16 -> 31 : 25 |****************************************| 32 -> 63 : 3 |**** | msecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 2 |** | 4 -> 7 : 0 | | 8 -> 15 : 1 |* | 16 -> 31 : 30 |****************************************| 32 -> 63 : 1 |* | msecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 28 |****************************************| 32 -> 63 : 2 |** | msecs : count distribution 0 -> 1 : 1 |* | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 27 |****************************************| 32 -> 63 : 4 |***** | [...] For comparison, here is pidstat(1) for that process: # pidstat -p 4505 1 Linux 4.4.0-virtual (bgregg-xxxxxxxx) 02/08/2016 _x86_64_ (8 CPU) 08:56:11 AM UID PID %usr %system %guest %CPU CPU Command 08:56:12 AM 0 4505 9.00 3.00 0.00 12.00 0 bash 08:56:13 AM 0 4505 7.00 5.00 0.00 12.00 0 bash 08:56:14 AM 0 4505 10.00 2.00 0.00 12.00 0 bash 08:56:15 AM 0 4505 11.00 2.00 0.00 13.00 0 bash 08:56:16 AM 0 4505 9.00 3.00 0.00 12.00 0 bash [...] This is a synthetic workload that is CPU bound. It's only spending 12% on-CPU each second because of high CPU demand on this server: the remaining time is spent waiting on a run queue, as visualized by runqlat. Here is the same system, but when it is CPU idle: # ./runqlat 5 1 Tracing run queue latency... Hit Ctrl-C to end. usecs : count distribution 0 -> 1 : 2250 |******************************** | 2 -> 3 : 2340 |********************************** | 4 -> 7 : 2746 |****************************************| 8 -> 15 : 418 |****** | 16 -> 31 : 93 |* | 32 -> 63 : 28 | | 64 -> 127 : 119 |* | 128 -> 255 : 9 | | 256 -> 511 : 4 | | 512 -> 1023 : 20 | | 1024 -> 2047 : 22 | | 2048 -> 4095 : 5 | | 4096 -> 8191 : 2 | | Back to a microsecond scale, this time there is little run queue latency past 1 millisecond, as would be expected. Now 16 threads are performing heavy disk I/O: # ./runqlat 5 1 Tracing run queue latency... Hit Ctrl-C to end. usecs : count distribution 0 -> 1 : 204 | | 2 -> 3 : 944 |* | 4 -> 7 : 16315 |********************* | 8 -> 15 : 29897 |****************************************| 16 -> 31 : 1044 |* | 32 -> 63 : 23 | | 64 -> 127 : 128 | | 128 -> 255 : 24 | | 256 -> 511 : 5 | | 512 -> 1023 : 13 | | 1024 -> 2047 : 15 | | 2048 -> 4095 : 13 | | 4096 -> 8191 : 10 | | The distribution hasn't changed too much. While the disks are 100% busy, there is still plenty of CPU headroom, and threads still don't spend much time waiting their turn. A -P option will print a distribution for each PID: # ./runqlat -P Tracing run queue latency... Hit Ctrl-C to end. ^C pid = 0 usecs : count distribution 0 -> 1 : 351 |******************************** | 2 -> 3 : 96 |******** | 4 -> 7 : 437 |****************************************| 8 -> 15 : 12 |* | 16 -> 31 : 10 | | 32 -> 63 : 0 | | 64 -> 127 : 16 |* | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 0 | | 2048 -> 4095 : 0 | | 4096 -> 8191 : 0 | | 8192 -> 16383 : 1 | | pid = 12929 usecs : count distribution 0 -> 1 : 1 |****************************************| 2 -> 3 : 0 | | 4 -> 7 : 1 |****************************************| pid = 12930 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 1 |****************************************| 32 -> 63 : 0 | | 64 -> 127 : 1 |****************************************| pid = 12931 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 1 |******************** | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 2 |****************************************| pid = 12932 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 1 |****************************************| 256 -> 511 : 0 | | 512 -> 1023 : 1 |****************************************| pid = 7 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 426 |************************************* | 4 -> 7 : 457 |****************************************| 8 -> 15 : 16 |* | pid = 9 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 425 |****************************************| 8 -> 15 : 16 |* | pid = 11 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 10 |****************************************| pid = 14 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 8 |****************************************| 4 -> 7 : 2 |********** | pid = 18 usecs : count distribution 0 -> 1 : 414 |****************************************| 2 -> 3 : 0 | | 4 -> 7 : 20 |* | 8 -> 15 : 8 | | pid = 12928 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 1 |****************************************| 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 |****************************************| pid = 1867 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 15 |****************************************| 16 -> 31 : 1 |** | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 4 |********** | pid = 1871 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 2 |****************************************| 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 1 |******************** | pid = 1876 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |****************************************| 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 1 |****************************************| pid = 1878 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 3 |****************************************| pid = 1880 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 3 |****************************************| pid = 9307 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |****************************************| pid = 1886 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 1 |******************** | 8 -> 15 : 2 |****************************************| pid = 1888 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 3 |****************************************| pid = 3297 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |****************************************| pid = 1892 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 1 |******************** | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 2 |****************************************| pid = 7024 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 4 |****************************************| pid = 16468 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 3 |****************************************| pid = 12922 usecs : count distribution 0 -> 1 : 1 |****************************************| 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 1 |****************************************| 16 -> 31 : 1 |****************************************| 32 -> 63 : 0 | | 64 -> 127 : 1 |****************************************| pid = 12923 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 1 |******************** | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 2 |****************************************| 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 1 |******************** | 1024 -> 2047 : 1 |******************** | pid = 12924 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 2 |******************** | 8 -> 15 : 4 |****************************************| 16 -> 31 : 1 |********** | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 0 | | 1024 -> 2047 : 1 |********** | pid = 12925 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 1 |****************************************| pid = 12926 usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 1 |****************************************| 4 -> 7 : 0 | | 8 -> 15 : 1 |****************************************| 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 1 |****************************************| pid = 12927 usecs : count distribution 0 -> 1 : 1 |****************************************| 2 -> 3 : 0 | | 4 -> 7 : 1 |****************************************| A -L option will print a distribution for each TID: # ./runqlat -L Tracing run queue latency... Hit Ctrl-C to end. ^C tid = 0 usecs : count distribution 0 -> 1 : 593 |**************************** | 2 -> 3 : 829 |****************************************| 4 -> 7 : 300 |************** | 8 -> 15 : 321 |*************** | 16 -> 31 : 132 |****** | 32 -> 63 : 58 |** | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 13 | | tid = 7 usecs : count distribution 0 -> 1 : 8 |******** | 2 -> 3 : 19 |******************** | 4 -> 7 : 37 |****************************************| [...] USAGE message: # ./runqlat -h usage: runqlat [-h] [-T] [-m] [-P] [-L] [-p PID] [interval] [count] Summarize run queue (schedular) latency as a histogram positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -T, --timestamp include timestamp on output -m, --milliseconds millisecond histogram -P, --pids print a histogram per process ID -L, --tids print a histogram per thread ID -p PID, --pid PID trace this PID only examples: ./runqlat # summarize run queue latency as a histogram ./runqlat 1 10 # print 1 second summaries, 10 times ./runqlat -mT 1 # 1s summaries, milliseconds, and timestamps ./runqlat -P # show each PID separately ./runqlat -p 185 # trace PID 185 only bpfcc-0.2.0+git0.02884a026/tools/runqlen.py000077500000000000000000000130551305314114400177030ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # runqlen Summarize scheduler run queue length as a histogram. # For Linux, uses BCC, eBPF. # # This counts the length of the run queue, excluding the currently running # thread, and shows it as a histogram. # # Also answers run queue occupancy. # # USAGE: runqlen [-h] [-T] [-Q] [-m] [-D] [interval] [count] # # REQUIRES: Linux 4.9+ (BPF_PROG_TYPE_PERF_EVENT support). Under tools/old is # a version of this tool that may work on Linux 4.6 - 4.8. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 12-Dec-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF, PerfType, PerfSWConfig from time import sleep, strftime import argparse # arguments examples = """examples: ./runqlen # summarize run queue length as a histogram ./runqlen 1 10 # print 1 second summaries, 10 times ./runqlen -T 1 # 1s summaries and timestamps ./runqlen -O # report run queue occupancy ./runqlen -C # show each CPU separately """ parser = argparse.ArgumentParser( description="Summarize scheduler run queue length as a histogram", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-O", "--runqocc", action="store_true", help="report run queue occupancy") parser.add_argument("-C", "--cpus", action="store_true", help="print output for each CPU separately") parser.add_argument("interval", nargs="?", default=99999999, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() countdown = int(args.count) debug = 0 frequency = 99 # define BPF program bpf_text = """ #include #include // Declare enough of cfs_rq to find nr_running, since we can't #import the // header. This will need maintenance. It is from kernel/sched/sched.h: struct cfs_rq_partial { struct load_weight load; unsigned int nr_running, h_nr_running; }; typedef struct cpu_key { int cpu; unsigned int slot; } cpu_key_t; STORAGE int do_perf_event() { unsigned int len = 0; pid_t pid = 0; struct task_struct *task = NULL; struct cfs_rq_partial *my_q = NULL; // Fetch the run queue length from task->se.cfs_rq->nr_running. This is an // unstable interface and may need maintenance. Perhaps a future version // of BPF will support task_rq(p) or something similar as a more reliable // interface. task = (struct task_struct *)bpf_get_current_task(); bpf_probe_read(&my_q, sizeof(my_q), &task->se.cfs_rq); bpf_probe_read(&len, sizeof(len), &my_q->nr_running); // Calculate run queue length by subtracting the currently running task, // if present. len 0 == idle, len 1 == one running task. if (len > 0) len--; STORE return 0; } """ if args.cpus: bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist, cpu_key_t);') bpf_text = bpf_text.replace('STORE', 'cpu_key_t key = {.slot = len}; ' + 'key.cpu = bpf_get_smp_processor_id(); ' + 'dist.increment(key);') else: bpf_text = bpf_text.replace('STORAGE', 'BPF_HISTOGRAM(dist, unsigned int);') bpf_text = bpf_text.replace('STORE', 'dist.increment(len);') # code substitutions if debug: print(bpf_text) # load BPF program b = BPF(text=bpf_text) # initialize BPF & perf_events b = BPF(text=bpf_text) b.attach_perf_event(ev_type=PerfType.SOFTWARE, ev_config=PerfSWConfig.CPU_CLOCK, fn_name="do_perf_event", sample_period=0, sample_freq=frequency) print("Sampling run queue length... Hit Ctrl-C to end.") # output exiting = 0 if args.interval else 1 dist = b.get_table("dist") while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") if args.runqocc: if args.cpus: # run queue occupancy, per-CPU summary idle = {} queued = {} cpumax = 0 for k, v in dist.items(): if k.cpu > cpumax: cpumax = k.cpu for c in range(0, cpumax + 1): idle[c] = 0 queued[c] = 0 for k, v in dist.items(): if k.slot == 0: idle[k.cpu] += v.value else: queued[k.cpu] += v.value for c in range(0, cpumax + 1): samples = idle[c] + queued[c] if samples: runqocc = float(queued[c]) / samples else: runqocc = 0 print("runqocc, CPU %-3d %6.2f%%" % (c, 100 * runqocc)) else: # run queue occupancy, system-wide summary idle = 0 queued = 0 for k, v in dist.items(): if k.value == 0: idle += v.value else: queued += v.value samples = idle + queued if samples: runqocc = float(queued) / samples else: runqocc = 0 print("runqocc: %0.2f%%" % (100 * runqocc)) else: # run queue length histograms dist.print_linear_hist("runqlen", "cpu") dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/runqlen_example.txt000066400000000000000000000275511305314114400216100ustar00rootroot00000000000000Demonstrations of runqlen, the Linux eBPF/bcc version. This program summarizes scheduler queue length as a histogram, and can also show run queue occupancy. It works by sampling the run queue length on all CPUs at 99 Hertz. As an example, here is an idle system: # ./runqlen.py Sampling run queue length... Hit Ctrl-C to end. ^C runqlen : count distribution 0 : 1776 |****************************************| This shows a zero run queue length each time it was sampled. And now a heavily loaded system: # ./runqlen.py Sampling run queue length... Hit Ctrl-C to end. ^C runqlen : count distribution 0 : 1068 |****************************************| 1 : 642 |************************ | 2 : 369 |************* | 3 : 183 |****** | 4 : 104 |*** | 5 : 42 |* | 6 : 13 | | 7 : 2 | | 8 : 1 | | Now there is often threads queued, with one sample reaching a queue length of 8. This will cause run queue latency, which can be measured by the bcc runqlat tool. Here's an example of an issue that runqlen can indentify. Starting with the system-wide summary: # ./runqlen.py Sampling run queue length... Hit Ctrl-C to end. ^C runqlen : count distribution 0 : 1209 |****************************************| 1 : 372 |************ | 2 : 73 |** | 3 : 3 | | 4 : 1 | | 5 : 0 | | 6 : 0 | | 7 : 237 |******* | This shows there is often a run queue length of 7. Now using the -C option to see per-CPU histograms: # ./runqlen.py -C Sampling run queue length... Hit Ctrl-C to end. ^C cpu = 0 runqlen : count distribution 0 : 257 |****************************************| 1 : 64 |********* | 2 : 5 | | 3 : 0 | | 4 : 0 | | 5 : 0 | | 6 : 1 | | cpu = 1 runqlen : count distribution 0 : 226 |****************************************| 1 : 90 |*************** | 2 : 11 |* | cpu = 2 runqlen : count distribution 0 : 264 |****************************************| 1 : 52 |******* | 2 : 8 |* | 3 : 1 | | 4 : 0 | | 5 : 0 | | 6 : 1 | | 7 : 0 | | 8 : 1 | | cpu = 3 runqlen : count distribution 0 : 0 | | 1 : 0 | | 2 : 0 | | 3 : 0 | | 4 : 0 | | 5 : 0 | | 6 : 0 | | 7 : 327 |****************************************| cpu = 4 runqlen : count distribution 0 : 255 |****************************************| 1 : 63 |********* | 2 : 9 |* | cpu = 5 runqlen : count distribution 0 : 244 |****************************************| 1 : 78 |************ | 2 : 3 | | 3 : 2 | | cpu = 6 runqlen : count distribution 0 : 253 |****************************************| 1 : 66 |********** | 2 : 6 | | 3 : 1 | | 4 : 1 | | cpu = 7 runqlen : count distribution 0 : 243 |****************************************| 1 : 74 |************ | 2 : 6 | | 3 : 1 | | 4 : 0 | | 5 : 1 | | 6 : 2 | | The run queue length of 7 is isolated to CPU 3. It was caused by CPU binding (taskset). This can sometimes happen by applications that try to auto-bind to CPUs, leaving other CPUs idle while work is queued. runqlat accepts an interval and a count. For example, with -T for timestamps: # ./runqlen.py -T 1 5 Sampling run queue length... Hit Ctrl-C to end. 19:51:34 runqlen : count distribution 0 : 635 |****************************************| 1 : 142 |******** | 2 : 13 | | 3 : 0 | | 4 : 1 | | 19:51:35 runqlen : count distribution 0 : 640 |****************************************| 1 : 136 |******** | 2 : 13 | | 3 : 1 | | 4 : 0 | | 5 : 0 | | 6 : 0 | | 7 : 0 | | 8 : 0 | | 9 : 0 | | 10 : 1 | | 19:51:36 runqlen : count distribution 0 : 603 |****************************************| 1 : 170 |*********** | 2 : 16 |* | 3 : 1 | | 4 : 0 | | 5 : 0 | | 6 : 0 | | 7 : 0 | | 8 : 0 | | 9 : 1 | | 19:51:37 runqlen : count distribution 0 : 617 |****************************************| 1 : 154 |********* | 2 : 20 |* | 3 : 0 | | 4 : 0 | | 5 : 0 | | 6 : 0 | | 7 : 0 | | 8 : 0 | | 9 : 0 | | 10 : 0 | | 11 : 1 | | 19:51:38 runqlen : count distribution 0 : 603 |****************************************| 1 : 161 |********** | 2 : 24 |* | 3 : 4 | | The spikes in run queue length of 11 are likely threads waking up at the same time (a thundering herd), and then are scheduled and complete their execution quickly. The -O option prints run queue occupancy: the percentage of time that there was work queued waiting its turn. Eg: # ./runqlen.py -OT 1 Sampling run queue length... Hit Ctrl-C to end. 19:54:53 runqocc: 41.09% 19:54:54 runqocc: 41.85% 19:54:55 runqocc: 41.47% 19:54:56 runqocc: 42.35% 19:54:57 runqocc: 40.83% [...] This can also be examined per-CPU: # ./runqlen.py -COT 1 Sampling run queue length... Hit Ctrl-C to end. 19:55:03 runqocc, CPU 0 32.32% runqocc, CPU 1 26.26% runqocc, CPU 2 38.38% runqocc, CPU 3 100.00% runqocc, CPU 4 26.26% runqocc, CPU 5 32.32% runqocc, CPU 6 39.39% runqocc, CPU 7 46.46% 19:55:04 runqocc, CPU 0 35.00% runqocc, CPU 1 32.32% runqocc, CPU 2 37.00% runqocc, CPU 3 100.00% runqocc, CPU 4 43.43% runqocc, CPU 5 31.31% runqocc, CPU 6 28.00% runqocc, CPU 7 31.31% 19:55:05 runqocc, CPU 0 43.43% runqocc, CPU 1 32.32% runqocc, CPU 2 45.45% runqocc, CPU 3 100.00% runqocc, CPU 4 29.29% runqocc, CPU 5 36.36% runqocc, CPU 6 36.36% runqocc, CPU 7 30.30% 19:55:06 runqocc, CPU 0 40.00% runqocc, CPU 1 38.00% runqocc, CPU 2 31.31% runqocc, CPU 3 100.00% runqocc, CPU 4 31.31% runqocc, CPU 5 28.28% runqocc, CPU 6 31.00% runqocc, CPU 7 29.29% [...] USAGE message: # ./runqlen -h usage: runqlen [-h] [-T] [-O] [-C] [interval] [count] Summarize scheduler run queue length as a histogram positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -T, --timestamp include timestamp on output -O, --runqocc report run queue occupancy -C, --cpus print output for each CPU separately examples: ./runqlen # summarize run queue length as a histogram ./runqlen 1 10 # print 1 second summaries, 10 times ./runqlen -T 1 # 1s summaries and timestamps ./runqlen -O # report run queue occupancy ./runqlen -C # show each CPU separately bpfcc-0.2.0+git0.02884a026/tools/slabratetop.py000077500000000000000000000065061305314114400205420ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # slabratetop Summarize kmem_cache_alloc() calls. # For Linux, uses BCC, eBPF. # # USAGE: slabratetop [-h] [-C] [-r MAXROWS] [interval] [count] # # This uses in-kernel BPF maps to store cache summaries for efficiency. # # SEE ALSO: slabtop(1), which shows the cache volumes. # # Copyright 2016 Netflix, Inc. # Licensed under the Apache License, Version 2.0 (the "License") # # 15-Oct-2016 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse import signal from subprocess import call # arguments examples = """examples: ./slabratetop # kmem_cache_alloc() top, 1 second refresh ./slabratetop -C # don't clear the screen ./slabratetop 5 # 5 second summaries ./slabratetop 5 10 # 5 second summaries, 10 times only """ parser = argparse.ArgumentParser( description="Kernel SLAB/SLUB memory cache allocation rate top", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-C", "--noclear", action="store_true", help="don't clear the screen") parser.add_argument("-r", "--maxrows", default=20, help="maximum rows to print, default 20") parser.add_argument("interval", nargs="?", default=1, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() interval = int(args.interval) countdown = int(args.count) maxrows = int(args.maxrows) clear = not int(args.noclear) debug = 0 # linux stats loadavg = "/proc/loadavg" # signal handler def signal_ignore(signal, frame): print() # define BPF program bpf_text = """ #include #include #include #include #define CACHE_NAME_SIZE 32 // the key for the output summary struct info_t { char name[CACHE_NAME_SIZE]; }; // the value of the output summary struct val_t { u64 count; u64 size; }; BPF_HASH(counts, struct info_t, struct val_t); int kprobe__kmem_cache_alloc(struct pt_regs *ctx, struct kmem_cache *cachep) { struct info_t info = {}; bpf_probe_read(&info.name, sizeof(info.name), (void *)cachep->name); struct val_t *valp, zero = {}; valp = counts.lookup_or_init(&info, &zero); valp->count++; valp->size += cachep->size; return 0; } """ if debug: print(bpf_text) # initialize BPF b = BPF(text=bpf_text) print('Tracing... Output every %d secs. Hit Ctrl-C to end' % interval) # output exiting = 0 while 1: try: sleep(interval) except KeyboardInterrupt: exiting = 1 # header if clear: call("clear") else: print() with open(loadavg) as stats: print("%-8s loadavg: %s" % (strftime("%H:%M:%S"), stats.read())) print("%-32s %6s %10s" % ("CACHE", "ALLOCS", "BYTES")) # by-TID output counts = b.get_table("counts") line = 0 for k, v in reversed(sorted(counts.items(), key=lambda counts: counts[1].size)): print("%-32s %6d %10d" % (k.name, v.count, v.size)) line += 1 if line >= maxrows: break counts.clear() countdown -= 1 if exiting or countdown == 0: print("Detaching...") exit() bpfcc-0.2.0+git0.02884a026/tools/slabratetop_example.txt000066400000000000000000000123431305314114400224350ustar00rootroot00000000000000Demonstrations of slabratetop, the Linux eBPF/bcc version. slabratetop shows the rate of allocations and total bytes from the kernel memory allocation caches (SLAB or SLUB), in a top-like display that refreshes. For example: # ./slabratetop 07:01:35 loadavg: 0.38 0.21 0.12 1/342 13297 CACHE ALLOCS BYTES kmalloc-4096 3554 14557184 kmalloc-256 2382 609536 cred_jar 2568 493056 anon_vma_chain 2007 128448 anon_vma 972 77760 sighand_cache 24 50688 mm_struct 49 50176 RAW 52 49920 proc_inode_cache 59 38232 signal_cache 24 26112 dentry 135 25920 sock_inode_cache 29 18560 files_cache 24 16896 inode_cache 13 7696 TCP 2 3840 pid 24 3072 sigqueue 17 2720 ext4_inode_cache 2 2160 buffer_head 16 1664 xfs_trans 5 1160 By default the screen refreshes every one second, and only the top 20 caches are shown. These can be tuned with options: see USAGE (-h). The output above showed that the kmalloc-4096 cache allocated the most, about 14 Mbytes during this interval. This is a generic cache; other caches have more meaningful names ("dentry", "TCP", "pid", etc). slabtop(1) is a similar tool that shows the current static volume and usage of the caches. slabratetop shows the active call rates and total size of the allocations. Since "kmalloc-4096" isn't very descriptive, I'm interested in seeing the kernel stacks that led to this allocation. In the future (maybe by now) the bcc trace tool could do this. As I'm writing this, it can't, so I'll use my older ftrace-based kprobe tool as a workarond. This is from my perf-tools collection: https://github.com/brendangregg/perf-tools. # ./perf-tools/bin/kprobe -s 'p:kmem_cache_alloc name=+0(+96(%di)):string' 'name == "kmalloc-4096' | head -100 Tracing kprobe kmem_cache_alloc. Ctrl-C to end. kprobe-3892 [002] d... 7888274.478331: kmem_cache_alloc: (kmem_cache_alloc+0x0/0x1b0) name="kmalloc-4096" kprobe-3892 [002] d... 7888274.478333: => kmem_cache_alloc => user_path_at_empty => vfs_fstatat => SYSC_newstat => SyS_newstat => entry_SYSCALL_64_fastpath kprobe-3892 [002] d... 7888274.478340: kmem_cache_alloc: (kmem_cache_alloc+0x0/0x1b0) name="kmalloc-4096" kprobe-3892 [002] d... 7888274.478341: => kmem_cache_alloc => user_path_at_empty => vfs_fstatat => SYSC_newstat => SyS_newstat => entry_SYSCALL_64_fastpath kprobe-3892 [002] d... 7888274.478345: kmem_cache_alloc: (kmem_cache_alloc+0x0/0x1b0) name="kmalloc-4096" kprobe-3892 [002] d... 7888274.478346: => kmem_cache_alloc => user_path_at_empty => vfs_fstatat => SYSC_newstat => SyS_newstat => entry_SYSCALL_64_fastpath kprobe-3892 [002] d... 7888274.478350: kmem_cache_alloc: (kmem_cache_alloc+0x0/0x1b0) name="kmalloc-4096" kprobe-3892 [002] d... 7888274.478351: => kmem_cache_alloc => user_path_at_empty => vfs_fstatat => SYSC_newstat => SyS_newstat => entry_SYSCALL_64_fastpath kprobe-3892 [002] d... 7888274.478355: kmem_cache_alloc: (kmem_cache_alloc+0x0/0x1b0) name="kmalloc-4096" kprobe-3892 [002] d... 7888274.478355: => kmem_cache_alloc => user_path_at_empty => vfs_fstatat => SYSC_newstat => SyS_newstat => entry_SYSCALL_64_fastpath kprobe-3892 [002] d... 7888274.478359: kmem_cache_alloc: (kmem_cache_alloc+0x0/0x1b0) name="kmalloc-4096" kprobe-3892 [002] d... 7888274.478359: => kmem_cache_alloc => user_path_at_empty => vfs_fstatat => SYSC_newstat => SyS_newstat => entry_SYSCALL_64_fastpath [...] This is just an example so that you can see it's possible to dig further. Please don't copy-n-paste that kprobe command, as it's unlikely to work (the "+0(+96(%di))" text is specific to a kernel version and architecture). So these allocations are coming from user_path_at_empty(), which calls other functions (not seen in the stack: I suspect it's a tail-call compiler optimization). USAGE: # ./slabratetop -h usage: slabratetop [-h] [-C] [-r MAXROWS] [interval] [count] Kernel SLAB/SLUB memory cache allocation rate top positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -C, --noclear don't clear the screen -r MAXROWS, --maxrows MAXROWS maximum rows to print, default 20 examples: ./slabratetop # kmem_cache_alloc() top, 1 second refresh ./slabratetop -C # don't clear the screen ./slabratetop 5 # 5 second summaries ./slabratetop 5 10 # 5 second summaries, 10 times only bpfcc-0.2.0+git0.02884a026/tools/softirqs.py000077500000000000000000000102111305314114400200600ustar00rootroot00000000000000#!/usr/bin/python # @lint-avoid-python-3-compatibility-imports # # softirqs Summarize soft IRQ (interrupt) event time. # For Linux, uses BCC, eBPF. # # USAGE: softirqs [-h] [-T] [-N] [-d] [interval] [count] # # Copyright (c) 2015 Brendan Gregg. # Licensed under the Apache License, Version 2.0 (the "License") # # 20-Oct-2015 Brendan Gregg Created this. from __future__ import print_function from bcc import BPF from time import sleep, strftime import argparse # arguments examples = """examples: ./softirqs # sum soft irq event time ./softirqs -d # show soft irq event time as histograms ./softirqs 1 10 # print 1 second summaries, 10 times ./softirqs -NT 1 # 1s summaries, nanoseconds, and timestamps """ parser = argparse.ArgumentParser( description="Summarize soft irq event time as histograms", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-T", "--timestamp", action="store_true", help="include timestamp on output") parser.add_argument("-N", "--nanoseconds", action="store_true", help="output in nanoseconds") parser.add_argument("-d", "--dist", action="store_true", help="show distributions as histograms") parser.add_argument("interval", nargs="?", default=99999999, help="output interval, in seconds") parser.add_argument("count", nargs="?", default=99999999, help="number of outputs") args = parser.parse_args() countdown = int(args.count) if args.nanoseconds: factor = 1 label = "nsecs" else: factor = 1000 label = "usecs" debug = 0 # define BPF program bpf_text = """ #include typedef struct irq_key { u64 ip; u64 slot; } irq_key_t; BPF_HASH(start, u32); BPF_HASH(iptr, u32); BPF_HISTOGRAM(dist, irq_key_t); // time IRQ int trace_start(struct pt_regs *ctx) { u32 pid = bpf_get_current_pid_tgid(); u64 ip = PT_REGS_IP(ctx), ts = bpf_ktime_get_ns(); start.update(&pid, &ts); iptr.update(&pid, &ip); return 0; } int trace_completion(struct pt_regs *ctx) { u64 *tsp, delta, ip, *ipp; u32 pid = bpf_get_current_pid_tgid(); // fetch timestamp and calculate delta tsp = start.lookup(&pid); ipp = iptr.lookup(&pid); if (tsp == 0 || ipp == 0) { return 0; // missed start } delta = bpf_ktime_get_ns() - *tsp; ip = *ipp; // store as sum or histogram STORE start.delete(&pid); iptr.delete(&pid); return 0; } """ # code substitutions if args.dist: bpf_text = bpf_text.replace('STORE', 'irq_key_t key = {.ip = ip, .slot = bpf_log2l(delta)};' + 'dist.increment(key);') else: bpf_text = bpf_text.replace('STORE', 'irq_key_t key = {.ip = ip, .slot = 0 /* ignore */};' + 'u64 zero = 0, *vp = dist.lookup_or_init(&key, &zero);' + '(*vp) += delta;') if debug: print(bpf_text) # load BPF program b = BPF(text=bpf_text) # this should really use irq:softirq_entry/exit tracepoints; for now the # soft irq functions are individually traced (search your kernel for # open_softirq() calls, and adjust the following list as needed). for softirqfunc in ("blk_iopoll_softirq", "blk_done_softirq", "rcu_process_callbacks", "run_rebalance_domains", "tasklet_action", "tasklet_hi_action", "run_timer_softirq", "net_tx_action", "net_rx_action"): b.attach_kprobe(event=softirqfunc, fn_name="trace_start") b.attach_kretprobe(event=softirqfunc, fn_name="trace_completion") print("Tracing soft irq event time... Hit Ctrl-C to end.") # output exiting = 0 if args.interval else 1 dist = b.get_table("dist") while (1): try: sleep(int(args.interval)) except KeyboardInterrupt: exiting = 1 print() if args.timestamp: print("%-8s\n" % strftime("%H:%M:%S"), end="") if args.dist: dist.print_log2_hist(label, "softirq", section_print_fn=b.ksym) else: print("%-26s %11s" % ("SOFTIRQ", "TOTAL_" + label)) for k, v in sorted(dist.items(), key=lambda dist: dist[1].value): print("%-26s %11d" % (b.ksym(k.ip), v.value / factor)) dist.clear() countdown -= 1 if exiting or countdown == 0: exit() bpfcc-0.2.0+git0.02884a026/tools/softirqs_example.txt000066400000000000000000000246271305314114400217770ustar00rootroot00000000000000Demonstrations of softirqs, the Linux eBPF/bcc version. This program traces soft interrupts (irqs), and stores timing statistics in-kernel for efficiency. For example: # ./softirqs Tracing soft irq event time... Hit Ctrl-C to end. ^C SOFTIRQ TOTAL_usecs rcu_process_callbacks 974 run_rebalance_domains 1809 run_timer_softirq 2615 net_tx_action 14605 tasklet_action 38692 net_rx_action 88188 The SOFTIRQ column prints the interrupt action function name. While tracing, the net_rx_action() soft interrupt ran for 20199 microseconds (20 milliseconds) in total. This tool works by dynamic tracing the individual softirq functions, and will need to be adjusted to match kernel/module changes. Future versions should use the softirq tracepoints instead. An interval can be provided, and also optionally a count. Eg, printing output every 1 second, and including timestamps (-T): # ./softirqs -T 1 3 Tracing soft irq event time... Hit Ctrl-C to end. 22:29:16 SOFTIRQ TOTAL_usecs rcu_process_callbacks 456 run_rebalance_domains 1005 run_timer_softirq 1196 net_tx_action 2796 tasklet_action 5534 net_rx_action 15075 22:29:17 SOFTIRQ TOTAL_usecs rcu_process_callbacks 456 run_rebalance_domains 839 run_timer_softirq 1142 net_tx_action 1912 tasklet_action 4428 net_rx_action 14652 22:29:18 SOFTIRQ TOTAL_usecs rcu_process_callbacks 502 run_rebalance_domains 840 run_timer_softirq 1192 net_tx_action 2341 tasklet_action 5496 net_rx_action 15656 This can be useful for quantifying where CPU cycles are spent among the soft interrupts (summarized as the %softirq column from mpstat(1), and shown as event counts in /proc/softirqs). The output above shows that most time was spent processing net_rx_action(), which was around 15 milliseconds per second (total time across all CPUs). The distribution of interrupt run time can be printed as a histogram with the -d option. Eg: # ./softirqs -d Tracing soft irq event time... Hit Ctrl-C to end. ^C softirq = net_tx_action usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 440 | | 512 -> 1023 : 27613 |****************************************| 1024 -> 2047 : 5728 |******** | 2048 -> 4095 : 439 | | 4096 -> 8191 : 53 | | 8192 -> 16383 : 2 | | softirq = net_rx_action usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 6 | | 1024 -> 2047 : 35 | | 2048 -> 4095 : 3562 |**************** | 4096 -> 8191 : 7023 |******************************** | 8192 -> 16383 : 8770 |****************************************| 16384 -> 32767 : 1780 |******** | 32768 -> 65535 : 216 | | 65536 -> 131071 : 4 | | softirq = tasklet_action usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 95 | | 512 -> 1023 : 12521 |****************************************| 1024 -> 2047 : 1068 |*** | 2048 -> 4095 : 1077 |*** | 4096 -> 8191 : 12349 |*************************************** | 8192 -> 16383 : 464 |* | 16384 -> 32767 : 1 | | softirq = rcu_process_callbacks usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 0 | | 512 -> 1023 : 708 |****************************************| 1024 -> 2047 : 495 |*************************** | 2048 -> 4095 : 98 |***** | 4096 -> 8191 : 62 |*** | 8192 -> 16383 : 4 | | softirq = run_timer_softirq usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 2 | | 512 -> 1023 : 366 |********* | 1024 -> 2047 : 1525 |****************************************| 2048 -> 4095 : 629 |**************** | 4096 -> 8191 : 87 |** | 8192 -> 16383 : 1 | | softirq = run_rebalance_domains usecs : count distribution 0 -> 1 : 0 | | 2 -> 3 : 0 | | 4 -> 7 : 0 | | 8 -> 15 : 0 | | 16 -> 31 : 0 | | 32 -> 63 : 0 | | 64 -> 127 : 0 | | 128 -> 255 : 0 | | 256 -> 511 : 3 | | 512 -> 1023 : 18 |* | 1024 -> 2047 : 80 |******** | 2048 -> 4095 : 374 |****************************************| 4096 -> 8191 : 257 |*************************** | 8192 -> 16383 : 50 |***** | 16384 -> 32767 : 24 |** | USAGE message: # ./softirqs -h usage: softirqs [-h] [-T] [-N] [-d] [interval] [count] Summarize soft irq event time as histograms positional arguments: interval output interval, in seconds count number of outputs optional arguments: -h, --help show this help message and exit -T, --timestamp include timestamp on output -N, --nanoseconds output in nanoseconds -d, --dist show distributions as histograms examples: ./softirqs # sum soft irq event time ./softirqs -d # show soft irq event time as histograms ./softirqs 1 10 # print 1 second summaries, 10 times ./softirqs -NT 1 # 1s summaries, nanoseconds, and timestamps bpfcc-0.2.0+git0.02884a026/tools/solisten.py000077500000000000000000000144301305314114400200550ustar00rootroot00000000000000#!/usr/bin/env python # # solisten Trace TCP listen events # For Linux, uses BCC, eBPF. Embedded C. # # USAGE: solisten.py [-h] [-p PID] [--show-netns] # # This is provided as a basic example of TCP connection & socket tracing. # It could be usefull in scenarios where load balancers needs to be updated # dynamically as application is fully initialized. # # All IPv4 listen attempts are traced, even if they ultimately fail or the # the listening program is not willing to accept(). # # Copyright (c) 2016 Jean-Tiare Le Bigot. # Licensed under the Apache License, Version 2.0 (the "License") # # 04-Mar-2016 Jean-Tiare Le Bigot Created this. import os import socket import netaddr import argparse from bcc import BPF import ctypes as ct # Arguments examples = """Examples: ./solisten.py # Stream socket listen ./solisten.py -p 1234 # Stream socket listen for specified PID only ./solisten.py --netns 4242 # " for the specified network namespace ID only ./solisten.py --show-netns # Show network ns ID (useful for containers) """ parser = argparse.ArgumentParser( description="Stream sockets listen", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("--show-netns", action="store_true", help="show network namespace") parser.add_argument("-p", "--pid", default=0, type=int, help="trace this PID only") parser.add_argument("-n", "--netns", default=0, type=int, help="trace this Network Namespace only") # BPF Program bpf_text = """ #include #include #include #include // Common structure for UDP/TCP IPv4/IPv6 struct listen_evt_t { u64 ts_us; u64 pid_tgid; u64 backlog; u64 netns; u64 proto; // familiy << 16 | type u64 lport; // use only 16 bits u64 laddr[2]; // IPv4: store in laddr[0] char task[TASK_COMM_LEN]; }; BPF_PERF_OUTPUT(listen_evt); // Send an event for each IPv4 listen with PID, bound address and port int kprobe__inet_listen(struct pt_regs *ctx, struct socket *sock, int backlog) { // cast types. Intermediate cast not needed, kept for readability struct sock *sk = sock->sk; struct inet_sock *inet = inet_sk(sk); // Built event for userland struct listen_evt_t evt = { .ts_us = bpf_ktime_get_ns() / 1000, .backlog = backlog, }; // Get process comm. Needs LLVM >= 3.7.1 // see https://github.com/iovisor/bcc/issues/393 bpf_get_current_comm(evt.task, TASK_COMM_LEN); // Get socket IP family u16 family = sk->__sk_common.skc_family; evt.proto = family << 16 | SOCK_STREAM; // Get PID evt.pid_tgid = bpf_get_current_pid_tgid(); ##FILTER_PID## // Get port bpf_probe_read(&evt.lport, sizeof(u16), &(inet->inet_sport)); evt.lport = ntohs(evt.lport); // Get network namespace id, if kernel supports it #ifdef CONFIG_NET_NS evt.netns = sk->__sk_common.skc_net.net->ns.inum; #else evt.netns = 0; #endif ##FILTER_NETNS## // Get IP if (family == AF_INET) { bpf_probe_read(evt.laddr, sizeof(u32), &(inet->inet_rcv_saddr)); evt.laddr[0] = be32_to_cpu(evt.laddr[0]); } else if (family == AF_INET6) { bpf_probe_read(evt.laddr, sizeof(evt.laddr), sk->__sk_common.skc_v6_rcv_saddr.in6_u.u6_addr32); evt.laddr[0] = be64_to_cpu(evt.laddr[0]); evt.laddr[1] = be64_to_cpu(evt.laddr[1]); } // Send event to userland listen_evt.perf_submit(ctx, &evt, sizeof(evt)); return 0; }; """ # event data TASK_COMM_LEN = 16 # linux/sched.h class ListenEvt(ct.Structure): _fields_ = [ ("ts_us", ct.c_ulonglong), ("pid_tgid", ct.c_ulonglong), ("backlog", ct.c_ulonglong), ("netns", ct.c_ulonglong), ("proto", ct.c_ulonglong), ("lport", ct.c_ulonglong), ("laddr", ct.c_ulonglong * 2), ("task", ct.c_char * TASK_COMM_LEN) ] # TODO: properties to unpack protocol / ip / pid / tgid ... # Format output def event_printer(show_netns): def print_event(cpu, data, size): # Decode event event = ct.cast(data, ct.POINTER(ListenEvt)).contents pid = event.pid_tgid & 0xffffffff proto_family = event.proto & 0xff proto_type = event.proto >> 16 & 0xff if proto_family == socket.SOCK_STREAM: protocol = "TCP" elif proto_family == socket.SOCK_DGRAM: protocol = "UDP" else: protocol = "UNK" address = "" if proto_type == socket.AF_INET: protocol += "v4" address = netaddr.IPAddress(event.laddr[0]) elif proto_type == socket.AF_INET6: address = netaddr.IPAddress(event.laddr[0] << 64 | event.laddr[1], version=6) protocol += "v6" # Display if show_netns: print("%-6d %-12.12s %-12s %-6s %-8s %-5s %-39s" % ( pid, event.task, event.netns, protocol, event.backlog, event.lport, address, )) else: print("%-6d %-12.12s %-6s %-8s %-5s %-39s" % ( pid, event.task, protocol, event.backlog, event.lport, address, )) return print_event if __name__ == "__main__": # Parse arguments args = parser.parse_args() pid_filter = "" netns_filter = "" if args.pid: pid_filter = "if (evt.pid_tgid != %d) return 0;" % args.pid if args.netns: netns_filter = "if (evt.netns != %d) return 0;" % args.netns bpf_text = bpf_text.replace("##FILTER_PID##", pid_filter) bpf_text = bpf_text.replace("##FILTER_NETNS##", netns_filter) # Initialize BPF b = BPF(text=bpf_text) b["listen_evt"].open_perf_buffer(event_printer(args.show_netns)) # Print headers if args.show_netns: print("%-6s %-12s %-12s %-6s %-8s %-5s %-39s" % ("PID", "COMM", "NETNS", "PROTO", "BACKLOG", "PORT", "ADDR")) else: print("%-6s %-12s %-6s %-8s %-5s %-39s" % ("PID", "COMM", "PROTO", "BACKLOG", "PORT", "ADDR")) # Read events while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/solisten_example.txt000066400000000000000000000044621305314114400217600ustar00rootroot00000000000000Demonstrations of solisten.py, the Linux eBPF/bcc version. This tool traces the kernel function called when a program wants to listen for TCP connections. It will not see UDP neither UNIX domain sockets. It can be used to dynamically update a load balancer as a program is actually ready to accept connexion, hence avoiding the "downtime" while it is initializing. # ./solisten.py --show-netns PID COMM NETNS PROTO BACKLOG ADDR PORT 3643 nc 4026531957 TCPv4 1 0.0.0.0 4242 3659 nc 4026531957 TCPv6 1 2001:f0d0:1002:51::4 4242 4221 redis-server 4026532165 TCPv6 128 :: 6379 4221 redis-server 4026532165 TCPv4 128 0.0.0.0 6379 6067 nginx 4026531957 TCPv4 128 0.0.0.0 80 6067 nginx 4026531957 TCPv6 128 :: 80 6069 nginx 4026531957 TCPv4 128 0.0.0.0 80 6069 nginx 4026531957 TCPv6 128 :: 80 6069 nginx 4026531957 TCPv4 128 0.0.0.0 80 6069 nginx 4026531957 TCPv6 128 :: 80 This output show the listen event from 3 programs. Netcat was started twice as shown by the 2 different PIDs. The first time on the wilcard IPv4, the second time on an IPv6. Netcat being a "one shot" program. It can accept a single connection, hence the backlog of "1". The next program is redis-server. As the netns column shows, it is in a different network namespace than netcat and nginx. In this specific case it was launched in a docker container. It listens both on IPv4 and IPv4 with up to 128 pending connections. Determining the actual container is out if the scope of this tool. It could be derived by scrapping /proc//cgroup. Note that this is racy. The overhead of this tool is negligeable as it traces listen() calls which are invoked in the initialization path of a program. The operation part will remain unaffected. In particular, accept() calls will not be affected. Neither individual read() and write(). bpfcc-0.2.0+git0.02884a026/tools/sslsniff.py000077500000000000000000000145301305314114400200450ustar00rootroot00000000000000#!/usr/bin/python # # sslsniff Captures data on read/recv or write/send functions of OpenSSL and # GnuTLS # For Linux, uses BCC, eBPF. # # USAGE: sslsniff.py [-h] [-p PID] [-c COMM] [-o] [-g] [-d] # # Licensed under the Apache License, Version 2.0 (the "License") # # 12-Aug-2016 Adrian Lopez Created this. # 13-Aug-2016 Mark Drayton Fix SSL_Read # 17-Aug-2016 Adrian Lopez Capture GnuTLS and add options # from __future__ import print_function import ctypes as ct from bcc import BPF import argparse # arguments examples = """examples: ./sslsniff # sniff OpenSSL and GnuTLS functions ./sslsniff -p 181 # sniff PID 181 only ./sslsniff -c curl # sniff curl command only ./sslsniff --no-openssl # don't show OpenSSL calls ./sslsniff --no-gnutls # don't show GnuTLS calls """ parser = argparse.ArgumentParser( description="Sniff SSL data", formatter_class=argparse.RawDescriptionHelpFormatter, epilog=examples) parser.add_argument("-p", "--pid", help="sniff this PID only.") parser.add_argument("-c", "--comm", help="sniff only commands matching string.") parser.add_argument("-o", "--no-openssl", action="store_false", dest="openssl", help="do not show OpenSSL calls.") parser.add_argument("-g", "--no-gnutls", action="store_false", dest="gnutls", help="do not show GnuTLS calls.") parser.add_argument('-d', '--debug', dest='debug', action='count', default=0, help='debug mode.') args = parser.parse_args() prog = """ #include #include /* For TASK_COMM_LEN */ struct probe_SSL_data_t { u64 timestamp_ns; u32 pid; char comm[TASK_COMM_LEN]; char v0[472]; u32 len; }; BPF_PERF_OUTPUT(perf_SSL_write); int probe_SSL_write(struct pt_regs *ctx, void *ssl, void *buf, int num) { u32 pid = bpf_get_current_pid_tgid(); FILTER struct probe_SSL_data_t __data = {0}; __data.timestamp_ns = bpf_ktime_get_ns(); __data.pid = pid; __data.len = num; bpf_get_current_comm(&__data.comm, sizeof(__data.comm)); if ( buf != 0) { bpf_probe_read(&__data.v0, sizeof(__data.v0), buf); } perf_SSL_write.perf_submit(ctx, &__data, sizeof(__data)); return 0; } BPF_PERF_OUTPUT(perf_SSL_read); BPF_HASH(bufs, u32, u64); int probe_SSL_read_enter(struct pt_regs *ctx, void *ssl, void *buf, int num) { u32 pid = bpf_get_current_pid_tgid(); FILTER bufs.update(&pid, (u64*)&buf); return 0; } int probe_SSL_read_exit(struct pt_regs *ctx, void *ssl, void *buf, int num) { u32 pid = bpf_get_current_pid_tgid(); FILTER u64 *bufp = bufs.lookup(&pid); if (bufp == 0) { return 0; } struct probe_SSL_data_t __data = {0}; __data.timestamp_ns = bpf_ktime_get_ns(); __data.pid = pid; __data.len = PT_REGS_RC(ctx); bpf_get_current_comm(&__data.comm, sizeof(__data.comm)); if (bufp != 0) { bpf_probe_read(&__data.v0, sizeof(__data.v0), (char *)*bufp); } bufs.delete(&pid); perf_SSL_read.perf_submit(ctx, &__data, sizeof(__data)); return 0; } """ if args.pid: prog = prog.replace('FILTER', 'if (pid != %s) { return 0; }' % args.pid) else: prog = prog.replace('FILTER', '') if args.debug: print(prog) b = BPF(text=prog) # It looks like SSL_read's arguments aren't available in a return probe so you # need to stash the buffer address in a map on the function entry and read it # on its exit (Mark Drayton) # if args.openssl: b.attach_uprobe(name="ssl", sym="SSL_write", fn_name="probe_SSL_write", pid=args.pid or -1) b.attach_uprobe(name="ssl", sym="SSL_read", fn_name="probe_SSL_read_enter", pid=args.pid or -1) b.attach_uretprobe(name="ssl", sym="SSL_read", fn_name="probe_SSL_read_exit", pid=args.pid or -1) if args.gnutls: b.attach_uprobe(name="gnutls", sym="gnutls_record_send", fn_name="probe_SSL_write", pid=args.pid or -1) b.attach_uprobe(name="gnutls", sym="gnutls_record_recv", fn_name="probe_SSL_read_enter", pid=args.pid or -1) b.attach_uretprobe(name="gnutls", sym="gnutls_record_recv", fn_name="probe_SSL_read_exit", pid=args.pid or -1) # define output data structure in Python TASK_COMM_LEN = 16 # linux/sched.h MAX_BUF_SIZE = 472 # Limited by the BPF stack # Max size of the whole struct: 512 bytes class Data(ct.Structure): _fields_ = [ ("timestamp_ns", ct.c_ulonglong), ("pid", ct.c_uint), ("comm", ct.c_char * TASK_COMM_LEN), ("v0", ct.c_char * MAX_BUF_SIZE), ("len", ct.c_uint) ] # header print("%-12s %-18s %-16s %-6s %-6s" % ("FUNC", "TIME(s)", "COMM", "PID", "LEN")) # process event start = 0 def print_event_write(cpu, data, size): print_event(cpu, data, size, "WRITE/SEND") def print_event_read(cpu, data, size): print_event(cpu, data, size, "READ/RECV") def print_event(cpu, data, size, rw): global start event = ct.cast(data, ct.POINTER(Data)).contents # Filter events by command if args.comm: if not args.comm == event.comm: return if start == 0: start = event.timestamp_ns time_s = (float(event.timestamp_ns - start)) / 1000000000 s_mark = "-" * 5 + " DATA " + "-" * 5 e_mark = "-" * 5 + " END DATA " + "-" * 5 truncated_bytes = event.len - MAX_BUF_SIZE if truncated_bytes > 0: e_mark = "-" * 5 + " END DATA (TRUNCATED, " + str(truncated_bytes) + \ " bytes lost) " + "-" * 5 print("%-12s %-18.9f %-16s %-6d %-6d\n%s\n%s\n%s\n\n" % (rw, time_s, event.comm, event.pid, event.len, s_mark, event.v0, e_mark)) b["perf_SSL_write"].open_perf_buffer(print_event_write) b["perf_SSL_read"].open_perf_buffer(print_event_read) while 1: b.kprobe_poll() bpfcc-0.2.0+git0.02884a026/tools/sslsniff_example.txt000066400000000000000000000043401305314114400217420ustar00rootroot00000000000000Demonstrations of sslsniff.py This tool traces the OpenSSL functions SSL_READ and SSL_WRITE. Data passed to this functions is printed as plain text. Useful, for example, to sniff HTTP before encrypted with SSL. Output of tool executing in other shell "curl https://example.com" % sudo python sslsniff.py FUNC TIME(s) COMM PID LEN SSL_WRITE 0.000000000 curl 12915 75 ----- DATA ----- GET / HTTP/1.1 Host: example.com User-Agent: curl/7.50.1 Accept: */* ----- END DATA ----- SSL_READ 0.127144585 curl 12915 333 ----- DATA ----- HTTP/1.1 200 OK Cache-Control: max-age=604800 Content-Type: text/html Date: Tue, 16 Aug 2016 15:42:12 GMT Etag: "359670651+gzip+ident" Expires: Tue, 23 Aug 2016 15:42:12 GMT Last-Modified: Fri, 09 Aug 2013 23:54:35 GMT Server: ECS (iad/18CB) Vary: Accept-Encoding X-Cache: HIT x-ec-custom-error: 1 Content-Length: 1270 ----- END DATA ----- SSL_READ 0.129967972 curl 12915 1270 ----- DATA ----- Example Domain