[ { "path": ".android/Dockerfile", "content": "FROM ubuntu:latest\n\nARG ndk_version=r27c\n\nRUN apt-get update && apt-get install -y \\\n build-essential \\\n curl \\\n cmake \\\n ninja-build \\\n python3 \\\n unzip\n\nRUN curl -o ndk.zip https://dl.google.com/android/repository/android-ndk-${ndk_version}-linux.zip\nRUN unzip ndk.zip && mv android-ndk-${ndk_version} /ndk\n\nRUN curl -o capnproto.tar.gz https://capnproto.org/capnproto-c++-0.10.2.tar.gz\nRUN mkdir -p /src/capnproto\nRUN tar zxf capnproto.tar.gz -C /src/capnproto --strip-components=1\nRUN mkdir -p /build/capnproto\nRUN cd /build/capnproto\nRUN /src/capnproto/configure\nRUN make -j$(nproc) install\nRUN cd -\n\nRUN mkdir -p /build/rr\nRUN chmod 777 /build/rr\n\nWORKDIR /build/rr\nCMD [\"/bin/bash\", \"/src/rr/.android/build.sh\"]\n" }, { "path": ".android/README.md", "content": "# Building for Android\n\nTo build for Android (from the root of the rr source tree):\n\n```\ndocker build .android -t rr-android\nmkdir -p obj/dist\ndocker run -it --rm \\\n -u $UID:$GID \\\n -v $(pwd):/src/rr \\\n -v $(pwd)/obj/dist:/dist \\\n rr-android\n```\n\n`-u $UID:GID` ensures that the build runs with your current UID/GID, which is\nnecessary to avoid the output being only writable by root.\n\n`-v $(pwd):/src/rr` mounts the source tree in the container so it can be built.\n\n`-v $(pwd)/obj/dist:/dist` sets the output directory for the container to the\ncurrent directory. The last step of the build will copy the rr tarball to the\ndirectory on the left of `:`." }, { "path": ".android/build.sh", "content": "#!/usr/bin/env bash\nset -e\nset -x\n\nDEVICE_CMAKE_DEFS=\"-DCMAKE_TOOLCHAIN_FILE=/ndk/build/cmake/android.toolchain.cmake -DANDROID_ABI=x86_64 -DANDROID_PLATFORM=android-28\"\n\n# Build capnp again for the device\nINSTALL_PREFIX=$(pwd)/install\nmkdir -p $INSTALL_PREFIX\nmkdir capnproto-android\ncd capnproto-android\ncmake -G Ninja \\\n $DEVICE_CMAKE_DEFS \\\n -DEXTERNAL_CAPNP=True \\\n -DBUILD_SHARED_LIBS=True \\\n -DCMAKE_INSTALL_PREFIX=$INSTALL_PREFIX \\\n /src/capnproto\ncmake --build .\ncmake --install .\ncd -\n\nmkdir obj\ncd obj\ncmake -G Ninja \\\n $DEVICE_CMAKE_DEFS \\\n -Ddisable32bit=True \\\n -DBUILD_TESTS=False \\\n -DCMAKE_FIND_ROOT_PATH=$INSTALL_PREFIX \\\n -DSKIP_PKGCONFIG=True \\\n -DEXTRA_VERSION_STRING=\"$BUILD_ID\" \\\n -DZLIB_LDFLAGS=-lz \\\n -DEXTRA_EXTERNAL_SOLIBS=\"/build/rr/capnproto-android/src/kj/libkj.so;/build/rr/capnproto-android/src/capnp/libcapnp.so\" \\\n /src/rr\ncmake --build .\ncpack -G TGZ\n\ncp dist/* /dist/\n" }, { "path": ".buildkite/.gitignore", "content": "test.yml\ntest-*.yml\n" }, { "path": ".buildkite/CTestCostData.txt", "content": "check_environment 2 0.0177417\n64bit_child 2 0.388554\n64bit_child-no-syscallbuf 2 0.343397\n_llseek 2 0.178732\n_llseek-no-syscallbuf 2 0.176157\nabort 2 0.405355\nabort-no-syscallbuf 2 0.401123\naccept 2 0.296525\naccept-no-syscallbuf 2 0.238087\nacct 2 0.172497\nacct-no-syscallbuf 2 0.157378\nadjtimex 2 0.164065\nadjtimex-no-syscallbuf 2 0.157286\naio 2 0.174191\naio-no-syscallbuf 2 0.172184\nalarm 2 2.31239\nalarm-no-syscallbuf 2 2.62346\nalarm2 2 1.14969\nalarm2-no-syscallbuf 2 1.17563\nalsa_ioctl 2 0.183019\nalsa_ioctl-no-syscallbuf 2 0.175809\narch_prctl 2 0.165938\narch_prctl-no-syscallbuf 2 0.164753\nasync_segv_ignored 2 0.176697\nasync_segv_ignored-no-syscallbuf 2 0.158012\nat_threadexit 2 0.222064\nat_threadexit-no-syscallbuf 2 0.206986\nbad_ip 2 0.165407\nbad_ip-no-syscallbuf 2 0.187529\nbad_syscall 2 0.174693\nbad_syscall-no-syscallbuf 2 0.143219\nbarrier 2 0.33947\nbarrier-no-syscallbuf 2 0.335352\nbig_buffers 2 0.180078\nbig_buffers-no-syscallbuf 2 0.185628\nblock 2 9.35626\nblock-no-syscallbuf 2 9.41618\nblock_open 2 0.213755\nblock_open-no-syscallbuf 2 0.210349\nbpf 2 0.19726\nbpf-no-syscallbuf 2 0.178959\nbpf_map 2 0.182377\nbpf_map-no-syscallbuf 2 0.16628\nbrk 2 0.202035\nbrk-no-syscallbuf 2 0.268974\nbrk2 2 0.192675\nbrk2-no-syscallbuf 2 0.1618\ncapget 2 0.186253\ncapget-no-syscallbuf 2 0.178183\nchew_cpu 2 9.10871\nchew_cpu-no-syscallbuf 2 9.7596\nx86/chew_cpu_cpuid 2 0.909633\nx86/chew_cpu_cpuid-no-syscallbuf 2 0.241009\nchmod 2 0.175173\nchmod-no-syscallbuf 2 0.193\nchown 2 0.260438\nchown-no-syscallbuf 2 0.247314\nclock 2 0.321689\nclock-no-syscallbuf 2 0.405406\nclock_adjtime 2 0.179823\nclock_adjtime-no-syscallbuf 2 0.182865\nclock_nanosleep 2 1.17138\nclock_nanosleep-no-syscallbuf 2 1.15077\nclock_time64 2 0.18665\nclock_time64-no-syscallbuf 2 0.16131\nclone 2 0.184247\nclone-no-syscallbuf 2 0.194884\nclone_bad_stack 2 0.322686\nclone_bad_stack-no-syscallbuf 2 0.305627\nclone_bad_tls 2 0.200441\nclone_bad_tls-no-syscallbuf 2 0.159102\nclone_cleartid_coredump 2 0.382393\nclone_cleartid_coredump-no-syscallbuf 2 0.327541\nclone_fail 2 0.182033\nclone_fail-no-syscallbuf 2 0.160097\nclone_file_range 2 0.225524\nclone_file_range-no-syscallbuf 2 0.19126\nclone_immediate_exit 2 0.187786\nclone_immediate_exit-no-syscallbuf 2 0.184644\nclone_newflags 2 0.187025\nclone_newflags-no-syscallbuf 2 0.945696\nclone_parent 2 0.182157\nclone_parent-no-syscallbuf 2 0.204792\nclone_untraced 2 0.196201\nclone_untraced-no-syscallbuf 2 0.207853\nclone_vfork_pidfd 2 0.168749\nclone_vfork_pidfd-no-syscallbuf 2 0.169371\ncloned_sigmask 2 0.304638\ncloned_sigmask-no-syscallbuf 2 0.315861\nconstructor 2 2.22217\nconstructor-no-syscallbuf 2 2.21146\ncopy_file_range 2 0.187135\ncopy_file_range-no-syscallbuf 2 0.181734\nx86/cpuid_same_state 2 0.159951\nx86/cpuid_same_state-no-syscallbuf 2 0.165536\ncreat_address_not_truncated 2 0.182924\ncreat_address_not_truncated-no-syscallbuf 2 0.17218\nx86/cross_arch 2 0.175549\nx86/cross_arch-no-syscallbuf 2 0.173372\ncwd_inaccessible 2 0.275782\ncwd_inaccessible-no-syscallbuf 2 0.234584\ndaemon 2 0.205866\ndaemon-no-syscallbuf 2 0.174672\ndesched_blocking_poll 2 0.184894\ndesched_blocking_poll-no-syscallbuf 2 0.172352\ndesched_sigkill 2 0.30291\ndesched_sigkill-no-syscallbuf 2 0.240905\ndetach_state 2 0.219355\ndetach_state-no-syscallbuf 2 0.220512\ndetach_threads 2 0.314015\ndetach_threads-no-syscallbuf 2 0.280626\ndetach_sigkill 2 0.196443\ndetach_sigkill-no-syscallbuf 2 0.218506\ndetach_sigkill_exit 2 0.207984\ndetach_sigkill_exit-no-syscallbuf 2 0.197267\ndeterministic_sigsys 2 0.346079\ndeterministic_sigsys-no-syscallbuf 2 0.307801\ndev_zero 2 0.154614\ndev_zero-no-syscallbuf 2 0.23869\ndirect 2 0.243545\ndirect-no-syscallbuf 2 0.172084\ndup 2 0.232475\ndup-no-syscallbuf 2 0.189027\ndoublesegv 2 0.501823\ndoublesegv-no-syscallbuf 2 0.408514\nepoll_create 2 0.194815\nepoll_create-no-syscallbuf 2 0.153384\nepoll_create1 2 0.171597\nepoll_create1-no-syscallbuf 2 0.17207\nepoll_edge 2 0.178929\nepoll_edge-no-syscallbuf 2 0.158552\nepoll_pwait_eintr_sigmask 2 2.19519\nepoll_pwait_eintr_sigmask-no-syscallbuf 2 2.21515\neventfd 2 0.165454\neventfd-no-syscallbuf 2 0.166546\nexec_flags 2 0.161951\nexec_flags-no-syscallbuf 2 0.183996\nexec_no_env 2 0.220634\nexec_no_env-no-syscallbuf 2 0.212066\nexec_self 2 0.235062\nexec_self-no-syscallbuf 2 0.228894\nexec_from_main_thread 2 0.274183\nexec_from_main_thread-no-syscallbuf 2 0.293866\nexec_from_other_thread 2 16.1407\nexec_from_other_thread-no-syscallbuf 2 7.33557\nexec_stopsig 2 0.251712\nexec_stopsig-no-syscallbuf 2 0.344252\nexecveat 2 0.231512\nexecveat-no-syscallbuf 2 0.227455\nexit_with_syscallbuf_signal 2 0.217025\nexit_with_syscallbuf_signal-no-syscallbuf 2 0.167443\nfadvise 2 0.170039\nfadvise-no-syscallbuf 2 0.160222\nfanotify 2 0.174126\nfanotify-no-syscallbuf 2 0.166894\nfatal_init_signal 2 0.220292\nfatal_init_signal-no-syscallbuf 2 0.191934\nfatal_sigsegv_thread 2 0.645623\nfatal_sigsegv_thread-no-syscallbuf 2 0.624305\nx86/fault_in_code_page 2 0.18644\nx86/fault_in_code_page-no-syscallbuf 2 0.183687\nfcntl_dupfd 2 0.178214\nfcntl_dupfd-no-syscallbuf 2 0.18758\nfcntl_misc 2 0.178466\nfcntl_misc-no-syscallbuf 2 0.164349\nfcntl_notify 2 0.178185\nfcntl_notify-no-syscallbuf 2 0.17075\nfcntl_owner_ex 2 0.172739\nfcntl_owner_ex-no-syscallbuf 2 0.189245\nfcntl_rw_hints 2 0.177118\nfcntl_rw_hints-no-syscallbuf 2 0.169723\nfcntl_seals 2 0.169003\nfcntl_seals-no-syscallbuf 2 0.16143\nfcntl_sig 2 0.192377\nfcntl_sig-no-syscallbuf 2 0.172423\nfd_cleanup 2 0.181429\nfd_cleanup-no-syscallbuf 2 0.190582\nfd_tracking_across_threads 2 0.233957\nfd_tracking_across_threads-no-syscallbuf 2 0.202603\nfds_clean 2 0.281325\nfds_clean-no-syscallbuf 2 0.250604\nflock 2 0.684811\nflock-no-syscallbuf 2 1.10324\nflock_ofd 2 0.251028\nflock_ofd-no-syscallbuf 2 0.608903\nflock2 2 0.178437\nflock2-no-syscallbuf 2 0.166685\nfork_brk 2 0.22916\nfork_brk-no-syscallbuf 2 0.161856\nfork_child_crash 2 0.297335\nfork_child_crash-no-syscallbuf 2 0.305658\nfork_many 2 1.1968\nfork_many-no-syscallbuf 2 0.665619\nfutex_exit_race 2 0.580114\nfutex_exit_race-no-syscallbuf 2 0.402464\nfutex_exit_race_sigsegv 2 0.56445\nfutex_exit_race_sigsegv-no-syscallbuf 2 0.393731\nfutex_pi 2 0.215186\nfutex_pi-no-syscallbuf 2 0.181878\nfutex_priorities 2 0.261775\nfutex_priorities-no-syscallbuf 2 0.198346\nfutex_requeue 2 1.18771\nfutex_requeue-no-syscallbuf 2 1.18066\ngcrypt_rdrand 2 0.178023\ngcrypt_rdrand-no-syscallbuf 2 0.167756\ngetcpu 2 0.22876\ngetcpu-no-syscallbuf 2 0.167692\ngetgroups 2 0.172681\ngetgroups-no-syscallbuf 2 0.17935\ngetpwnam 2 0.237821\ngetpwnam-no-syscallbuf 2 0.32354\ngetrandom 2 0.204551\ngetrandom-no-syscallbuf 2 0.194019\nsetitimer 2 0.222777\nsetitimer-no-syscallbuf 2 0.175497\ngetsid 2 0.184714\ngetsid-no-syscallbuf 2 0.172561\ngettimeofday 2 0.179022\ngettimeofday-no-syscallbuf 2 0.18866\ngrandchild_threads 2 0.219542\ngrandchild_threads-no-syscallbuf 2 0.193676\ngrandchild_threads_main_running 2 2.24898\ngrandchild_threads_main_running-no-syscallbuf 2 2.27881\ngrandchild_threads_thread_running 2 5.26817\ngrandchild_threads_thread_running-no-syscallbuf 2 5.25683\ngrandchild_threads_parent_alive 2 0.197781\ngrandchild_threads_parent_alive-no-syscallbuf 2 0.224033\nx86/hle 2 1.06105\nx86/hle-no-syscallbuf 2 0.951817\ninotify 2 0.206718\ninotify-no-syscallbuf 2 0.161259\nint3 2 0.174208\nint3-no-syscallbuf 2 0.153777\nintr_futex_wait_restart 2 1.77408\nintr_futex_wait_restart-no-syscallbuf 2 1.69339\nintr_poll 2 3.71479\nintr_poll-no-syscallbuf 2 3.66918\nintr_ppoll 2 21.3612\nintr_ppoll-no-syscallbuf 2 21.3163\nintr_pselect 2 9.16476\nintr_pselect-no-syscallbuf 2 9.20851\nintr_read_no_restart 2 1.40236\nintr_read_no_restart-no-syscallbuf 2 1.32017\nintr_read_restart 2 2.42967\nintr_read_restart-no-syscallbuf 2 2.44465\nintr_sleep 2 4.18177\nintr_sleep-no-syscallbuf 2 4.16812\nintr_sleep_no_restart 2 2.16093\nintr_sleep_no_restart-no-syscallbuf 2 1.78601\ninvalid_exec 2 0.179465\ninvalid_exec-no-syscallbuf 2 0.174301\ninvalid_fcntl 2 0.175987\ninvalid_fcntl-no-syscallbuf 2 0.165666\ninvalid_ioctl 2 0.181297\ninvalid_ioctl-no-syscallbuf 2 0.176853\nio 2 0.171498\nio-no-syscallbuf 2 0.161433\nio_uring 2 0.170709\nio_uring-no-syscallbuf 2 0.225948\nioctl 2 0.182441\nioctl-no-syscallbuf 2 0.167527\nioctl_blk 2 0.176945\nioctl_blk-no-syscallbuf 2 0.184102\nioctl_fb 2 0.191506\nioctl_fb-no-syscallbuf 2 0.18009\nioctl_fs 2 0.185416\nioctl_fs-no-syscallbuf 2 0.183753\nioctl_pty 2 0.211126\nioctl_pty-no-syscallbuf 2 0.193052\nioctl_sg 2 0.18375\nioctl_sg-no-syscallbuf 2 0.16753\nioctl_tty 2 0.356545\nioctl_tty-no-syscallbuf 2 0.213868\nioctl_vt 2 0.244868\nioctl_vt-no-syscallbuf 2 0.159736\nioprio 2 0.169212\nioprio-no-syscallbuf 2 0.178082\nx86/ioperm 2 0.186083\nx86/ioperm-no-syscallbuf 2 0.164016\nx86/iopl 2 0.185867\nx86/iopl-no-syscallbuf 2 0.182458\njoin_threads 2 4.90819\njoin_threads-no-syscallbuf 2 3.54206\njoystick 2 0.159592\njoystick-no-syscallbuf 2 0.201406\nkcmp 2 0.19948\nkcmp-no-syscallbuf 2 0.168435\nkeyctl 2 0.187736\nkeyctl-no-syscallbuf 2 0.171832\nkill_newborn 2 0.413833\nkill_newborn-no-syscallbuf 2 0.300332\nkill_ptracee 2 1.81914\nkill_ptracee-no-syscallbuf 2 1.77773\nlarge_hole 2 0.188435\nlarge_hole-no-syscallbuf 2 0.170501\nlarge_write_deadlock 2 0.205733\nlarge_write_deadlock-no-syscallbuf 2 0.198197\nlegacy_ugid 2 0.165708\nlegacy_ugid-no-syscallbuf 2 0.182131\nx86/lsl 2 0.167781\nx86/lsl-no-syscallbuf 2 0.167028\nmadvise 2 0.190806\nmadvise-no-syscallbuf 2 0.196604\nmadvise_free 2 0.200002\nmadvise_free-no-syscallbuf 2 0.171689\nmadvise_wipeonfork 2 0.317507\nmadvise_wipeonfork-no-syscallbuf 2 0.348225\nmap_fixed 2 0.167354\nmap_fixed-no-syscallbuf 2 0.179426\nmap_shared_syscall 2 0.175052\nmap_shared_syscall-no-syscallbuf 2 0.170174\nmembarrier 2 0.228412\nmembarrier-no-syscallbuf 2 0.230171\nmemfd_create 2 0.182084\nmemfd_create-no-syscallbuf 2 0.169879\nmemfd_create_shared 2 0.222174\nmemfd_create_shared-no-syscallbuf 2 0.174558\nmemfd_create_shared_huge 2 0.185374\nmemfd_create_shared_huge-no-syscallbuf 2 0.223016\nmincore 2 0.174544\nmincore-no-syscallbuf 2 0.192059\nmknod 2 0.179847\nmknod-no-syscallbuf 2 0.196489\nmlock 2 0.173352\nmlock-no-syscallbuf 2 0.167404\nmmap_adjacent_to_rr_usage 2 0.17767\nmmap_adjacent_to_rr_usage-no-syscallbuf 2 0.186486\nmmap_private 2 1.12045\nmmap_private-no-syscallbuf 2 1.06585\nmmap_private_grow_under_map 2 0.189616\nmmap_private_grow_under_map-no-syscallbuf 2 0.155726\nmmap_recycle 2 0.20233\nmmap_recycle-no-syscallbuf 2 0.211311\nmmap_ro 2 0.185541\nmmap_ro-no-syscallbuf 2 0.169573\nmmap_self_maps_shared 2 0.229838\nmmap_self_maps_shared-no-syscallbuf 2 0.281218\nmmap_shared 2 0.191652\nmmap_shared-no-syscallbuf 2 0.220219\nmmap_shared_dev_zero 2 0.212095\nmmap_shared_dev_zero-no-syscallbuf 2 0.183368\nmmap_shared_grow 2 0.177507\nmmap_shared_grow-no-syscallbuf 2 0.178328\nmmap_shared_grow_under_map 2 0.199644\nmmap_shared_grow_under_map-no-syscallbuf 2 0.166737\nmmap_shared_multiple 2 0.19847\nmmap_shared_multiple-no-syscallbuf 2 0.157765\nmmap_shared_subpage 2 0.218759\nmmap_shared_subpage-no-syscallbuf 2 0.231295\nmmap_shared_write 2 6.26377\nmmap_shared_write-no-syscallbuf 2 7.91176\nmmap_shared_write_fork 2 0.237884\nmmap_shared_write_fork-no-syscallbuf 2 3.13827\nmmap_short_file 2 0.189922\nmmap_short_file-no-syscallbuf 2 0.171696\nmmap_write_complex 2 0.202205\nmmap_write_complex-no-syscallbuf 2 0.175287\nmmap_zero_size_fd 2 0.18312\nmmap_zero_size_fd-no-syscallbuf 2 0.162213\nx86/modify_ldt 2 0.188821\nx86/modify_ldt-no-syscallbuf 2 0.166663\nmount_ns_exec 2 0.23793\nmount_ns_exec-no-syscallbuf 2 0.250413\nmount_ns_exec2 2 0.24358\nmount_ns_exec2-no-syscallbuf 2 0.268304\nmprotect 2 0.191343\nmprotect-no-syscallbuf 2 0.166355\nmprotect_heterogenous 2 0.193389\nmprotect_heterogenous-no-syscallbuf 2 0.184813\nmprotect_none 2 0.19807\nmprotect_none-no-syscallbuf 2 0.172753\nmprotect_stack 2 0.171026\nmprotect_stack-no-syscallbuf 2 0.183265\nmq 2 2.18257\nmq-no-syscallbuf 2 2.24255\nmremap 2 2.04727\nmremap-no-syscallbuf 2 8.17459\nmremap_after_coalesce 2 0.17843\nmremap_after_coalesce-no-syscallbuf 2 0.20688\nmremap_grow 2 0.20804\nmremap_grow-no-syscallbuf 2 0.160446\nmremap_grow_shared 2 0.225226\nmremap_grow_shared-no-syscallbuf 2 0.16525\nmremap_non_page_size 2 0.177265\nmremap_non_page_size-no-syscallbuf 2 1.12233\nmremap_overwrite 2 0.17549\nmremap_overwrite-no-syscallbuf 2 0.160699\nmremap_private_grow_under_map 2 0.1715\nmremap_private_grow_under_map-no-syscallbuf 2 0.187527\nmremap_shrink 2 0.182712\nmremap_shrink-no-syscallbuf 2 0.167213\nmsg 2 1.72379\nmsg-no-syscallbuf 2 1.69238\nmsg_trunc 2 0.185576\nmsg_trunc-no-syscallbuf 2 0.170801\nmsync 2 1.10828\nmsync-no-syscallbuf 2 1.67113\nmtio 2 0.175655\nmtio-no-syscallbuf 2 0.185065\nmultiple_pending_signals 2 0.241691\nmultiple_pending_signals-no-syscallbuf 2 0.208994\nmultiple_pending_signals_sequential 2 0.228107\nmultiple_pending_signals_sequential-no-syscallbuf 2 0.247733\nmunmap_segv 2 0.187787\nmunmap_segv-no-syscallbuf 2 0.167144\nmunmap_discontinuous 2 0.178539\nmunmap_discontinuous-no-syscallbuf 2 0.168095\nnanosleep 2 1.17135\nnanosleep-no-syscallbuf 2 1.15676\nnetfilter 2 0.194444\nnetfilter-no-syscallbuf 2 0.247537\nnetlink_mmap_disable 2 0.179323\nnetlink_mmap_disable-no-syscallbuf 2 0.166943\nno_mask_timeslice 2 1.0076\nno_mask_timeslice-no-syscallbuf 2 0.869596\nnscd 2 0.166578\nnscd-no-syscallbuf 2 0.17653\nnuma 2 0.183699\nnuma-no-syscallbuf 2 0.199299\nx86/old_fork 2 0.180442\nx86/old_fork-no-syscallbuf 2 0.218585\norphan_process 2 0.197056\norphan_process-no-syscallbuf 2 0.188056\npacket_mmap_disable 2 0.183351\npacket_mmap_disable-no-syscallbuf 2 0.193332\npause 2 1.15275\npause-no-syscallbuf 2 1.17576\nperf_event 2 0.204277\nperf_event-no-syscallbuf 2 0.174976\npersonality 2 0.203447\npersonality-no-syscallbuf 2 0.18611\npid_ns_kill_child 2 0.46607\npid_ns_kill_child-no-syscallbuf 2 0.252649\npid_ns_kill_child_threads 2 0.239128\npid_ns_kill_child_threads-no-syscallbuf 2 0.204937\npid_ns_kill_child_zombie 2 0.275996\npid_ns_kill_child_zombie-no-syscallbuf 2 0.194321\npid_ns_kill_threads 2 0.269501\npid_ns_kill_threads-no-syscallbuf 2 0.216829\npid_ns_kill_threads_exit_wait 2 0.279025\npid_ns_kill_threads_exit_wait-no-syscallbuf 2 0.265377\npid_ns_reap 2 0.253094\npid_ns_reap-no-syscallbuf 2 0.221562\npid_ns_segv 2 0.305488\npid_ns_segv-no-syscallbuf 2 0.296093\npid_ns_shutdown 2 0.425677\npid_ns_shutdown-no-syscallbuf 2 0.401956\npidfd 2 0.239427\npidfd-no-syscallbuf 2 0.178746\nx86/pkeys 2 0.195752\nx86/pkeys-no-syscallbuf 2 0.151316\npoll_sig_race 2 2.97674\npoll_sig_race-no-syscallbuf 2 2.9028\nppoll 2 5.72922\nppoll-no-syscallbuf 2 5.73113\nprctl 2 0.207562\nprctl-no-syscallbuf 2 0.213663\nprctl_caps 2 0.522074\nprctl_caps-no-syscallbuf 2 0.399332\nprctl_deathsig 2 0.202488\nprctl_deathsig-no-syscallbuf 2 0.172917\nprctl_name 2 0.27457\nprctl_name-no-syscallbuf 2 0.272148\nprctl_short_name 2 0.2066\nprctl_short_name-no-syscallbuf 2 0.177081\nprctl_speculation_ctrl 2 0.197116\nprctl_speculation_ctrl-no-syscallbuf 2 0.161439\nx86/prctl_tsc 2 0.179877\nx86/prctl_tsc-no-syscallbuf 2 0.190523\nprivileged_net_ioctl 2 0.364182\nprivileged_net_ioctl-no-syscallbuf 2 0.405736\nproc_fds 2 0.805502\nproc_fds-no-syscallbuf 2 0.599653\nproc_mem 2 0.337102\nproc_mem-no-syscallbuf 2 0.315536\nprotect_rr_fds 2 3.74297\nprotect_rr_fds-no-syscallbuf 2 3.30292\nprw 2 0.168392\nprw-no-syscallbuf 2 0.194568\npthread_condvar_locking 2 0.185851\npthread_condvar_locking-no-syscallbuf 2 0.214291\npthread_mutex_timedlock 2 0.158389\npthread_mutex_timedlock-no-syscallbuf 2 0.183897\npthread_pi_mutex 2 0.205553\npthread_pi_mutex-no-syscallbuf 2 0.16821\npthread_rwlocks 2 0.211671\npthread_rwlocks-no-syscallbuf 2 0.196137\nx86/ptrace 2 0.225648\nx86/ptrace-no-syscallbuf 2 0.214048\nptrace_attach_null_status 2 0.239081\nptrace_attach_null_status-no-syscallbuf 2 0.236807\nptrace_attach_running 2 0.323048\nptrace_attach_running-no-syscallbuf 2 0.318352\nptrace_attach_sleeping 2 0.252628\nptrace_attach_sleeping-no-syscallbuf 2 0.212059\nptrace_attach_stopped 2 0.238656\nptrace_attach_stopped-no-syscallbuf 2 0.232865\nptrace_attach_thread_running 2 7.74088\nptrace_attach_thread_running-no-syscallbuf 2 9.15948\nptrace_breakpoint 2 0.205013\nptrace_breakpoint-no-syscallbuf 2 0.201343\nptrace_change_patched_syscall 2 0.195804\nptrace_change_patched_syscall-no-syscallbuf 2 0.195317\nx86/ptrace_debug_regs 2 0.193017\nx86/ptrace_debug_regs-no-syscallbuf 2 0.184957\nptrace_exec 2 0.301733\nptrace_exec-no-syscallbuf 2 0.29256\nx86/ptrace_exec32 2 0.182961\nx86/ptrace_exec32-no-syscallbuf 2 0.171233\nptrace_kill_grandtracee 2 0.200743\nptrace_kill_grandtracee-no-syscallbuf 2 0.213814\nx86/ptrace_tls 2 0.249886\nx86/ptrace_tls-no-syscallbuf 2 0.223517\nptrace_seize 2 0.188635\nptrace_seize-no-syscallbuf 2 0.195198\nptrace_sigchld_blocked 2 0.18947\nptrace_sigchld_blocked-no-syscallbuf 2 0.168162\nptrace_signals 2 0.345102\nptrace_signals-no-syscallbuf 2 0.289898\nptrace_singlestep 2 0.421221\nptrace_singlestep-no-syscallbuf 2 0.194343\nptrace_syscall 2 0.218101\nptrace_syscall-no-syscallbuf 2 0.179181\nptrace_syscall_clone_untraced 2 0.253265\nptrace_syscall_clone_untraced-no-syscallbuf 2 0.273692\nx86/ptrace_sysemu 2 0.280929\nx86/ptrace_sysemu-no-syscallbuf 2 0.260563\nptrace_sysemu_syscall 2 0.237037\nptrace_sysemu_syscall-no-syscallbuf 2 0.195508\nptrace_trace_clone 2 0.239851\nptrace_trace_clone-no-syscallbuf 2 0.228288\nptrace_trace_exit 2 0.193537\nptrace_trace_exit-no-syscallbuf 2 0.205698\nptrace_traceme 2 0.23772\nptrace_traceme-no-syscallbuf 2 0.186207\nptracer_death 2 0.231978\nptracer_death-no-syscallbuf 2 0.21803\nptracer_death_multithread 2 0.438148\nptracer_death_multithread-no-syscallbuf 2 0.64384\nptracer_death_multithread_peer 2 0.423491\nptracer_death_multithread_peer-no-syscallbuf 2 0.454556\nquotactl 2 0.217318\nquotactl-no-syscallbuf 2 0.195922\nx86/rdtsc 2 0.259211\nx86/rdtsc-no-syscallbuf 2 0.237116\nread_nothing 2 8.08106\nread_nothing-no-syscallbuf 2 14.8259\nreaddir 2 0.188428\nreaddir-no-syscallbuf 2 0.173345\nread_large 2 0.445476\nread_large-no-syscallbuf 2 1.57062\nread_oversize 2 0.179858\nread_oversize-no-syscallbuf 2 0.178238\nreadlink 2 0.188913\nreadlink-no-syscallbuf 2 0.225705\nreadlinkat 2 0.183314\nreadlinkat-no-syscallbuf 2 0.202814\nreadv 2 0.188892\nreadv-no-syscallbuf 2 0.184751\nrecord_replay_subject 2 3.55163\nrecord_replay_subject-no-syscallbuf 2 3.51079\nrecvfrom 2 0.167764\nrecvfrom-no-syscallbuf 2 0.21244\nredzone_integrity 2 1.14234\nredzone_integrity-no-syscallbuf 2 1.15655\nrename 2 0.184375\nrename-no-syscallbuf 2 0.167062\nrlimit 2 0.2005\nrlimit-no-syscallbuf 2 0.170453\nrobust_futex 2 0.212345\nrobust_futex-no-syscallbuf 2 0.206051\nrusage 2 0.19015\nrusage-no-syscallbuf 2 0.165888\nsamask 2 0.38831\nsamask-no-syscallbuf 2 0.328854\nsave_data_fd 2 0.177818\nsave_data_fd-no-syscallbuf 2 0.16115\nsched_attr 2 0.178041\nsched_attr-no-syscallbuf 2 0.199286\nsched_setaffinity 2 0.190171\nsched_setaffinity-no-syscallbuf 2 0.177428\nsched_setparam 2 0.183471\nsched_setparam-no-syscallbuf 2 0.164994\nsched_yield 2 0.270152\nsched_yield-no-syscallbuf 2 0.240553\nsched_yield_to_lower_priority 2 0.183273\nsched_yield_to_lower_priority-no-syscallbuf 2 0.190446\nscm_rights 2 0.671003\nscm_rights-no-syscallbuf 2 0.687657\nscratch_read 2 0.197939\nscratch_read-no-syscallbuf 2 0.186784\nseccomp 2 0.212935\nseccomp-no-syscallbuf 2 0.201332\nseccomp_cloning 2 0.186753\nseccomp_cloning-no-syscallbuf 2 0.181473\nseccomp_clone_fail 2 0.172286\nseccomp_clone_fail-no-syscallbuf 2 0.179858\nseccomp_desched 2 0.24543\nseccomp_desched-no-syscallbuf 2 0.181397\nseccomp_kill_exit 2 0.198507\nseccomp_kill_exit-no-syscallbuf 2 0.189345\nseccomp_null 2 0.178688\nseccomp_null-no-syscallbuf 2 0.231606\nseccomp_sigsys_args 2 0.181621\nseccomp_sigsys_args-no-syscallbuf 2 0.178718\nseccomp_sigsys_sigtrap 2 0.184341\nseccomp_sigsys_sigtrap-no-syscallbuf 2 0.185873\nseccomp_sigsys_syscallbuf 2 0.177722\nseccomp_sigsys_syscallbuf-no-syscallbuf 2 0.21653\nseccomp_tsync 2 0.224772\nseccomp_tsync-no-syscallbuf 2 0.198235\nseccomp_veto_exec 2 0.238224\nseccomp_veto_exec-no-syscallbuf 2 0.182102\nself_shebang 2 0.209619\nself_shebang-no-syscallbuf 2 0.234194\nself_sigint 2 0.16655\nself_sigint-no-syscallbuf 2 0.162785\nsem 2 0.240934\nsem-no-syscallbuf 2 0.220949\nsend_block 2 0.254059\nsend_block-no-syscallbuf 2 1.77992\nsendfile 2 0.198339\nsendfile-no-syscallbuf 2 0.186502\nset_ptracer 2 0.161933\nset_ptracer-no-syscallbuf 2 0.17299\nset_tid_address 2 0.190797\nset_tid_address-no-syscallbuf 2 0.189553\nsetgid 2 0.173111\nsetgid-no-syscallbuf 2 0.152735\nsetgroups 2 0.181831\nsetgroups-no-syscallbuf 2 0.162135\nsetsid 2 0.188063\nsetsid-no-syscallbuf 2 0.187996\nsetuid 2 0.360408\nsetuid-no-syscallbuf 2 0.245904\nshared_exec 2 0.172825\nshared_exec-no-syscallbuf 2 0.174199\nshared_monitor 2 0.172391\nshared_monitor-no-syscallbuf 2 0.168222\nshared_offset 2 0.242735\nshared_offset-no-syscallbuf 2 0.162085\nshared_write 2 0.183634\nshared_write-no-syscallbuf 2 0.178486\nshm 2 0.220493\nshm-no-syscallbuf 2 0.241913\nshm_unmap 2 0.186592\nshm_unmap-no-syscallbuf 2 0.170327\nsigaction_old 2 0.19866\nsigaction_old-no-syscallbuf 2 0.220548\nsigaltstack 2 0.180545\nsigaltstack-no-syscallbuf 2 0.1682\nsigchld_interrupt_signal 2 5.15186\nsigchld_interrupt_signal-no-syscallbuf 2 4.65416\nsigcont 2 0.189647\nsigcont-no-syscallbuf 2 0.192489\nsighandler_bad_rsp_sigsegv 2 0.192811\nsighandler_bad_rsp_sigsegv-no-syscallbuf 2 0.16453\nsighandler_fork 2 0.25179\nsighandler_fork-no-syscallbuf 2 0.223138\nsighandler_mask 2 0.192857\nsighandler_mask-no-syscallbuf 2 0.169821\nsigill 2 0.197423\nsigill-no-syscallbuf 2 0.153897\nsignal_deferred 2 0.206914\nsignal_deferred-no-syscallbuf 2 0.201921\nsignal_during_preload_init 2 0.207008\nsignal_during_preload_init-no-syscallbuf 2 0.195584\nsignal_frame 2 0.196477\nsignal_frame-no-syscallbuf 2 0.176133\nsignal_unstoppable 2 0.202938\nsignal_unstoppable-no-syscallbuf 2 0.181003\nsignalfd 2 0.174708\nsignalfd-no-syscallbuf 2 0.174824\nsigprocmask 2 0.553978\nsigprocmask-no-syscallbuf 2 0.545624\nsigprocmask_ensure_delivery 2 0.198806\nsigprocmask_ensure_delivery-no-syscallbuf 2 0.211635\nsigprocmask_exec 2 0.235655\nsigprocmask_exec-no-syscallbuf 2 0.224897\nsigprocmask_evil 2 0.163768\nsigprocmask_evil-no-syscallbuf 2 0.171957\nsigprocmask_in_syscallbuf_sighandler 2 1.15345\nsigprocmask_in_syscallbuf_sighandler-no-syscallbuf 2 1.14064\nsigprocmask_rr_sigs 2 0.203026\nsigprocmask_rr_sigs-no-syscallbuf 2 0.178018\nsigprocmask_syscallbuf 2 0.197603\nsigprocmask_syscallbuf-no-syscallbuf 2 0.183032\nsigqueueinfo 2 0.176825\nsigqueueinfo-no-syscallbuf 2 0.222178\nx86/sigreturn 2 0.207268\nx86/sigreturn-no-syscallbuf 2 0.203306\nsigreturn_reg 2 0.163808\nsigreturn_reg-no-syscallbuf 2 0.208531\nsigreturnmask 2 0.386215\nsigreturnmask-no-syscallbuf 2 0.342396\nsigrt 2 0.286826\nsigrt-no-syscallbuf 2 0.279347\nsigstop 2 0.259614\nsigstop-no-syscallbuf 2 0.223598\nsigstop2 2 0.2055\nsigstop2-no-syscallbuf 2 0.173578\nsigsuspend 2 0.193424\nsigsuspend-no-syscallbuf 2 0.208011\nsigtrap 2 0.208714\nsigtrap-no-syscallbuf 2 0.193717\nsimple_threads_stress 2 2.02023\nsimple_threads_stress-no-syscallbuf 2 2.52639\nsioc 2 0.611289\nsioc-no-syscallbuf 2 0.791008\nsmall_holes 2 0.186866\nsmall_holes-no-syscallbuf 2 0.160374\nsock_names_opts 2 0.196644\nsock_names_opts-no-syscallbuf 2 0.200876\nspinlock_priorities 2 0.883957\nspinlock_priorities-no-syscallbuf 2 1.77485\nsplice 2 0.1984\nsplice-no-syscallbuf 2 0.168069\nstack_growth_after_syscallbuf 2 0.184737\nstack_growth_after_syscallbuf-no-syscallbuf 2 0.180046\nstack_growth_syscallbuf 2 0.260481\nstack_growth_syscallbuf-no-syscallbuf 2 9.22802\nstack_growth_with_guard 2 0.203816\nstack_growth_with_guard-no-syscallbuf 2 0.187512\nstack_invalid 2 0.207892\nstack_invalid-no-syscallbuf 2 0.178875\nstack_overflow 2 0.291206\nstack_overflow-no-syscallbuf 2 0.270871\nstack_overflow_altstack 2 0.179979\nstack_overflow_altstack-no-syscallbuf 2 0.1755\nstack_overflow_with_guard 2 0.269542\nstack_overflow_with_guard-no-syscallbuf 2 0.235477\nstatfs 2 0.180439\nstatfs-no-syscallbuf 2 0.205603\nstatx 2 0.194644\nstatx-no-syscallbuf 2 0.163539\nstdout_child 2 0.225356\nstdout_child-no-syscallbuf 2 0.25816\nstdout_cloexec 2 0.258915\nstdout_cloexec-no-syscallbuf 2 0.218053\nstdout_dup 2 0.184115\nstdout_dup-no-syscallbuf 2 0.153221\nstdout_redirect 2 0.324121\nstdout_redirect-no-syscallbuf 2 0.236225\nswitch_read 2 0.69731\nswitch_read-no-syscallbuf 2 0.670853\nsymlink 2 0.185111\nsymlink-no-syscallbuf 2 0.19091\nsync 2 0.23794\nsync-no-syscallbuf 2 0.18673\nsync_file_range 2 0.173225\nsync_file_range-no-syscallbuf 2 0.236857\nsyscall_bp 2 0.177799\nsyscall_bp-no-syscallbuf 2 0.156245\nsyscall_in_writable_mem 2 0.174906\nsyscall_in_writable_mem-no-syscallbuf 2 0.177983\nsyscallbuf_signal_reset 2 0.183644\nsyscallbuf_signal_reset-no-syscallbuf 2 0.184238\nsyscallbuf_signal_blocking 2 0.190065\nsyscallbuf_signal_blocking-no-syscallbuf 2 0.198511\nsyscallbuf_sigstop 2 9.68564\nsyscallbuf_sigstop-no-syscallbuf 2 28.1754\nsyscallbuf_timeslice 2 0.251698\nsyscallbuf_timeslice-no-syscallbuf 2 3.52121\nsyscallbuf_timeslice2 2 0.249679\nsyscallbuf_timeslice2-no-syscallbuf 2 9.23084\nsysconf 2 0.186269\nsysconf-no-syscallbuf 2 0.159917\nsysctl 2 0.185003\nsysctl-no-syscallbuf 2 0.158481\nsysemu_singlestep 2 0.182821\nsysemu_singlestep-no-syscallbuf 2 0.162622\nx86/sysfs 2 0.227965\nx86/sysfs-no-syscallbuf 2 0.237494\nsysinfo 2 0.193888\nsysinfo-no-syscallbuf 2 0.164539\ntgkill 2 0.238723\ntgkill-no-syscallbuf 2 0.185187\nthread_yield 2 5.33778\nthread_yield-no-syscallbuf 2 3.68714\ntimer 2 63.0617\ntimer-no-syscallbuf 2 65.8362\ntimerfd 2 0.313991\ntimerfd-no-syscallbuf 2 0.272372\ntimes 2 0.20467\ntimes-no-syscallbuf 2 0.160248\ntruncate_temp 2 0.208904\ntruncate_temp-no-syscallbuf 2 0.200974\ntun 2 0.258967\ntun-no-syscallbuf 2 0.207755\ntwo_signals_with_mask 2 0.191743\ntwo_signals_with_mask-no-syscallbuf 2 0.177604\nulimit_low 2 0.193423\nulimit_low-no-syscallbuf 2 0.187551\nuname 2 0.189885\nuname-no-syscallbuf 2 0.16555\nunexpected_exit 2 0.244427\nunexpected_exit-no-syscallbuf 2 0.54684\nunexpected_exit_execve 2 0.267448\nunexpected_exit_execve-no-syscallbuf 2 0.494722\nunexpected_exit_execve_twice 2 1.3297\nunexpected_exit_execve_twice-no-syscallbuf 2 1.43974\nunexpected_exit_pid_ns 2 0.741595\nunexpected_exit_pid_ns-no-syscallbuf 2 0.233324\nunjoined_thread 2 0.182445\nunjoined_thread-no-syscallbuf 2 0.172195\nunshare 2 0.35039\nunshare-no-syscallbuf 2 1.13442\nuserfaultfd 2 0.169134\nuserfaultfd-no-syscallbuf 2 0.183975\nutimes 2 0.189225\nutimes-no-syscallbuf 2 0.168458\nvdso_parts 2 0.166982\nvdso_parts-no-syscallbuf 2 0.159098\nvfork_flush 2 0.20091\nvfork_flush-no-syscallbuf 2 0.169755\nvfork_shared 2 0.267209\nvfork_shared-no-syscallbuf 2 0.171063\nvideo_capture 2 0.17876\nvideo_capture-no-syscallbuf 2 0.184013\nvm_readv_writev 2 0.206471\nvm_readv_writev-no-syscallbuf 2 0.189777\nvsyscall 2 0.198179\nvsyscall-no-syscallbuf 2 0.18036\nvsyscall_timeslice 2 0.174966\nvsyscall_timeslice-no-syscallbuf 2 0.223726\nx86/x87env 2 0.192093\nx86/x87env-no-syscallbuf 2 0.220662\nwait 2 0.246499\nwait-no-syscallbuf 2 0.176315\nwait_sigstop 2 0.229046\nwait_sigstop-no-syscallbuf 2 0.194761\nwrite_race 2 2.69864\nwrite_race-no-syscallbuf 2 1.78352\nwritev 2 0.277556\nwritev-no-syscallbuf 2 0.195201\nxattr 2 0.187474\nxattr-no-syscallbuf 2 0.194899\nzero_length_read 2 0.1832\nzero_length_read-no-syscallbuf 2 0.169866\nstd_random 2 0.229802\nstd_random-no-syscallbuf 2 0.241042\nunwind_rr_page 2 1.15824\nunwind_rr_page-no-syscallbuf 2 1.1443\nabort_nonmain 2 0.477139\nabort_nonmain-no-syscallbuf 2 0.439677\nalternate_thread_diversion 2 0.937585\nalternate_thread_diversion-no-syscallbuf 2 0.893965\nargs 2 0.204811\nargs-no-syscallbuf 2 0.165566\nasync_kill_with_syscallbuf 2 2.82132\nasync_kill_with_syscallbuf-no-syscallbuf 2 3.81114\nasync_kill_with_syscallbuf2 2 2.27422\nasync_kill_with_syscallbuf2-no-syscallbuf 2 2.30266\nasync_kill_with_threads 2 2.21251\nasync_kill_with_threads-no-syscallbuf 2 2.31443\nasync_kill_with_threads_main_running 2 2.28136\nasync_kill_with_threads_main_running-no-syscallbuf 2 2.30519\nasync_kill_with_threads_thread_running 2 6.19838\nasync_kill_with_threads_thread_running-no-syscallbuf 2 6.15817\nasync_segv 2 4.7611\nasync_segv-no-syscallbuf 2 4.72077\nasync_signal_syscalls 2 1.11327\nasync_signal_syscalls-no-syscallbuf 2 0.0309316\nasync_signal_syscalls2 2 0.609031\nasync_signal_syscalls2-no-syscallbuf 2 0.0218664\nasync_signal_syscalls_siginfo 2 1.06276\nasync_signal_syscalls_siginfo-no-syscallbuf 2 0.0292908\nasync_usr1 2 4.92085\nasync_usr1-no-syscallbuf 2 4.47758\nblacklist 2 0.302815\nblacklist-no-syscallbuf 2 0.178595\nblock_clone_checkpoint 2 1.12958\nblock_clone_checkpoint-no-syscallbuf 2 1.19362\nblock_clone_interrupted 2 6.1536\nblock_clone_interrupted-no-syscallbuf 2 5.39331\nblock_clone_syscallbuf_overflow 2 3.62867\nblock_clone_syscallbuf_overflow-no-syscallbuf 2 7.05479\nblock_intr_sigchld 2 7.05565\nblock_intr_sigchld-no-syscallbuf 2 5.91357\nblocked_bad_ip 2 1.66722\nblocked_bad_ip-no-syscallbuf 2 1.21329\nblocked_sigill 2 0.475554\nblocked_sigill-no-syscallbuf 2 0.473601\nx86/blocked_sigsegv 2 0.454217\nx86/blocked_sigsegv-no-syscallbuf 2 0.409446\nbreakpoint 2 0.884155\nbreakpoint-no-syscallbuf 2 0.911315\nbreakpoint_conditions 2 0.970024\nbreakpoint_conditions-no-syscallbuf 2 1.02469\nbreakpoint_overlap 2 0.936155\nbreakpoint_overlap-no-syscallbuf 2 0.985176\ncall_function 2 0.946274\ncall_function-no-syscallbuf 2 0.90338\ncall_gettid 2 0.958785\ncall_gettid-no-syscallbuf 2 0.903787\ncheckpoint_dying_threads 2 0.936716\ncheckpoint_dying_threads-no-syscallbuf 2 0.896077\ncheckpoint_mixed_mode 2 1.07028\ncheckpoint_mixed_mode-no-syscallbuf 2 1.19646\nchecksum_sanity 2 2.8623\nchecksum_sanity-no-syscallbuf 2 1.60946\ncheck_lost_interrupts 2 1.68794\ncheck_lost_interrupts-no-syscallbuf 2 0.0205135\nclone_interruption 2 1.16011\nclone_interruption-no-syscallbuf 2 1.75708\nclone_vfork 2 0.316896\nclone_vfork-no-syscallbuf 2 0.238336\nconditional_breakpoint_calls 2 0.952078\nconditional_breakpoint_calls-no-syscallbuf 2 0.973057\nconditional_breakpoint_offload 2 96.5987\nconditional_breakpoint_offload-no-syscallbuf 2 90.719\ncondvar_stress 2 18.4794\ncondvar_stress-no-syscallbuf 2 29.7448\ncont_race 2 16.5406\ncont_race-no-syscallbuf 2 58.61349\nx86/cpuid_singlestep 2 0.841225\nx86/cpuid_singlestep-no-syscallbuf 2 0.858188\ncrash 2 0.417805\ncrash-no-syscallbuf 2 0.399749\ncrash_in_function 2 1.48377\ncrash_in_function-no-syscallbuf 2 1.42794\ndaemon_read 2 0.29565\ndaemon_read-no-syscallbuf 2 0.219573\ndconf_mock 2 0.20348\ndconf_mock-no-syscallbuf 2 0.186553\ndev_tty 2 0.168707\ndev_tty-no-syscallbuf 2 0.153884\ndiversion_sigtrap 2 1.33568\ndiversion_sigtrap-no-syscallbuf 2 1.33729\ndiversion_syscall 2 1.11462\ndiversion_syscall-no-syscallbuf 2 1.09594\ndlopen 2 8.35142\ndlopen-no-syscallbuf 2 6.31706\nearly_error 2 0.473624\nearly_error-no-syscallbuf 2 0.483345\nelapsed_time 2 1.85922\nelapsed_time-no-syscallbuf 2 1.81124\nexclusion_region 2 3.07792\nexclusion_region-no-syscallbuf 2 2.39734\nexec_failed 2 0.878224\nexec_failed-no-syscallbuf 2 0.87247\nexec_many 2 7.13534\nexec_many-no-syscallbuf 2 14.2697\nexecve_loop 2 7.54661\nexecve_loop-no-syscallbuf 2 5.2741\nexit_codes 2 0.478534\nexit_codes-no-syscallbuf 2 0.450373\nexit_group 2 0.184202\nexit_group-no-syscallbuf 2 0.196952\nexit_race 2 1.99785\nexit_race-no-syscallbuf 2 1.24573\nexit_status 2 0.129751\nexit_status-no-syscallbuf 2 0.11848\nx86/explicit_checkpoints 2 2.24325\nx86/explicit_checkpoints-no-syscallbuf 2 2.22522\nfd_limit 2 0.226523\nfd_limit-no-syscallbuf 2 1.05535\nfork_stress 2 2.18227\nfork_stress-no-syscallbuf 2 1.28322\nfork_syscalls 2 0.184567\nfork_syscalls-no-syscallbuf 2 0.223932\nfunction_calls 2 2.89782\nfunction_calls-no-syscallbuf 2 2.684\nx86/fxregs 2 0.885736\nx86/fxregs-no-syscallbuf 2 0.903752\ngetcwd 2 0.161177\ngetcwd-no-syscallbuf 2 0.164677\ngdb_bogus_breakpoint 2 0.858367\ngdb_bogus_breakpoint-no-syscallbuf 2 0.868942\ngoto_event 2 3.62863\ngoto_event-no-syscallbuf 2 3.38462\nhello 2 0.178746\nhello-no-syscallbuf 2 0.168594\nhooks 2 0.723224\nhooks-no-syscallbuf 2 0.0217813\nignored_async_usr1 2 4.34846\nignored_async_usr1-no-syscallbuf 2 2.41312\nignored_sigsegv 2 0.512287\nignored_sigsegv-no-syscallbuf 2 0.48108\nignore_nested 2 0.319942\nignore_nested-no-syscallbuf 2 0.329892\nimmediate_restart 2 1.10799\nimmediate_restart-no-syscallbuf 2 1.05464\nx86/int3_ok 2 0.196394\nx86/int3_ok-no-syscallbuf 2 0.164032\ninterrupt 2 5.08432\ninterrupt-no-syscallbuf 2 5.10831\nintr_ptrace_decline 2 4.76314\nintr_ptrace_decline-no-syscallbuf 2 4.71857\ninvalid_interpreter 2 1.39091\ninvalid_interpreter-no-syscallbuf 2 1.42361\ninvalid_jump 2 3.35074\ninvalid_jump-no-syscallbuf 2 2.0456\njit_proc_mem 2 0.923116\njit_proc_mem-no-syscallbuf 2 0.903665\nlink 2 0.196809\nlink-no-syscallbuf 2 0.202282\nmadvise_dontfork 2 1.23451\nmadvise_dontfork-no-syscallbuf 2 1.13971\nmain_thread_exit 2 1.27429\nmain_thread_exit-no-syscallbuf 2 1.21927\nmany_yields 2 3.52293\nmany_yields-no-syscallbuf 2 2.76882\nmmap_fd_reuse_checkpoint 2 1.20862\nmmap_fd_reuse_checkpoint-no-syscallbuf 2 1.17124\nmmap_replace_most_mappings 2 2.06602\nmmap_replace_most_mappings-no-syscallbuf 2 2.16168\nmmap_shared_prot 2 1.11115\nmmap_shared_prot-no-syscallbuf 2 1.139\nmmap_shared_write_exec_race 2 1.18982\nmmap_shared_write_exec_race-no-syscallbuf 2 3.74276\nmmap_tmpfs 2 0.203215\nmmap_tmpfs-no-syscallbuf 2 0.183339\nmmap_write 2 0.0232375\nmmap_write-no-syscallbuf 2 0.0192538\nmmap_write_private 2 0.33905\nmmap_write_private-no-syscallbuf 2 0.278782\nmorestack_unwind 1 0.810541\nmorestack_unwind-no-syscallbuf 1 0.0187404\nmprotect_growsdown 2 0.334716\nmprotect_growsdown-no-syscallbuf 2 0.307453\nmprotect_syscallbuf_overflow 2 0.286063\nmprotect_syscallbuf_overflow-no-syscallbuf 2 14.2703\nmutex_pi_stress 2 20.6333\nmutex_pi_stress-no-syscallbuf 2 27.5912\nnested_detach_wait 2 0.571855\nnested_detach_wait-no-syscallbuf 2 0.56148\noverflow_branch_counter 2 3.09102\noverflow_branch_counter-no-syscallbuf 2 3.21047\npatch_page_end 2 0.21362\npatch_page_end-no-syscallbuf 2 0.0250506\nx86/patch_40_80_f6_81 2 0.195303\nx86/patch_40_80_f6_81-no-syscallbuf 2 0.021418\nperf_event_mmap 2 1.40858\nperf_event_mmap-no-syscallbuf 2 1.49223\npriority 2 0.177644\npriority-no-syscallbuf 2 0.181065\nptrace_remote_unmap 2 4.98646\nptrace_remote_unmap-no-syscallbuf 2 3.95753\nread_big_struct 2 0.911023\nread_big_struct-no-syscallbuf 2 0.917618\nremove_latest_trace 2 1.27511\nremove_latest_trace-no-syscallbuf 2 1.20751\nrestart_abnormal_exit 2 1.33336\nrestart_abnormal_exit-no-syscallbuf 2 1.30786\nreverse_continue_breakpoint 2 1.8994\nreverse_continue_breakpoint-no-syscallbuf 2 1.58048\nreverse_continue_multiprocess 2 10.9357\nreverse_continue_multiprocess-no-syscallbuf 2 9.9408\nreverse_continue_process_signal 2 3.25294\nreverse_continue_process_signal-no-syscallbuf 2 3.37532\nreverse_many_breakpoints 2 4.68598\nreverse_many_breakpoints-no-syscallbuf 2 4.30084\nreverse_step_long 2 6.00979\nreverse_step_long-no-syscallbuf 2 7.54732\nreverse_step_threads 2 3.28319\nreverse_step_threads-no-syscallbuf 2 3.54332\nreverse_step_threads_break 2 4.64687\nreverse_step_threads_break-no-syscallbuf 2 3.3659\nrr_ps 2 0.430032\nrr_ps-no-syscallbuf 2 0.374333\nrr_ps_ns 2 0.214954\nrr_ps_ns-no-syscallbuf 2 0.183478\nrseq 2 20.632\nrseq-no-syscallbuf 2 20.3601\nsearch 2 0.934634\nsearch-no-syscallbuf 2 0.899349\nseccomp_blocks_rr 2 0.419835\nseccomp_blocks_rr-no-syscallbuf 2 0.168566\nseccomp_signals 2 2.46697\nseccomp_signals-no-syscallbuf 2 1.80603\nsegfault 2 0.184121\nsegfault-no-syscallbuf 2 0.171907\nshared_map 2 0.226207\nshared_map-no-syscallbuf 2 0.237703\nshared_persistent_file 2 1.2057\nshared_persistent_file-no-syscallbuf 2 1.19317\nsignal_numbers 2 1.16584\nsignal_numbers-no-syscallbuf 2 1.16436\nsigprocmask_race 2 0.201165\nsigprocmask_race-no-syscallbuf 2 0.0287277\nsigprocmask_rr_sigs_nondefault 2 0.0871455\nsigprocmask_rr_sigs_nondefault-no-syscallbuf 2 0.0841662\nsimple 2 0.302632\nsimple-no-syscallbuf 2 0.26711\nx86/singlestep_pushf 2 0.892934\nx86/singlestep_pushf-no-syscallbuf 2 0.900637\nstack_growth 2 0.89189\nstack_growth-no-syscallbuf 2 0.866447\nstep_thread 2 2.30356\nstep_thread-no-syscallbuf 2 1.30052\nstrict_priorities 2 12.1928\nstrict_priorities-no-syscallbuf 2 12.6763\nx86/string_instructions 2 0.595723\nx86/string_instructions-no-syscallbuf 2 0.760244\nx86/string_instructions_async_signals 2 0.232696\nx86/string_instructions_async_signals-no-syscallbuf 2 71.325464\nx86/string_instructions_async_signals_shared 2 0.28007\nx86/string_instructions_async_signals_shared-no-syscallbuf 2 96.599713\nx86/string_instructions_multiwatch 2 0.942324\nx86/string_instructions_multiwatch-no-syscallbuf 2 0.880441\nx86/string_instructions_replay 2 13.4061\nx86/string_instructions_replay-no-syscallbuf 2 13.7113\nx86/string_instructions_singlestep_fastforward 2 7.56842\nx86/string_instructions_singlestep_fastforward-no-syscallbuf 2 7.6374\nx86/string_instructions_watch 2 0.930721\nx86/string_instructions_watch-no-syscallbuf 2 0.889983\nsyscallbuf_fd_disabling 2 0.271232\nsyscallbuf_fd_disabling-no-syscallbuf 2 0.228286\nsyscallbuf_signal_blocking_read 2 1.02176\nsyscallbuf_signal_blocking_read-no-syscallbuf 2 1.43656\nsysconf_onln 2 0.35877\nsysconf_onln-no-syscallbuf 2 0.31309\ntarget_fork 2 1.73477\ntarget_fork-no-syscallbuf 2 1.63206\ntarget_process 2 1.7258\ntarget_process-no-syscallbuf 2 1.50867\ntcp_sockets 2 0.156821\ntcp_sockets-no-syscallbuf 2 0.155016\nterm_nonmain 2 0.177305\nterm_nonmain-no-syscallbuf 2 0.213272\nterm_rr 2 3.42756\nterm_rr-no-syscallbuf 2 3.40614\nterm_trace_reset 2 0.248562\nterm_trace_reset-no-syscallbuf 2 0.214772\nterm_trace_syscall 2 0.264866\nterm_trace_syscall-no-syscallbuf 2 0.235758\nthread_exit_signal 2 4.35567\nthread_exit_signal-no-syscallbuf 2 4.51597\nthread_open_race 2 35.2856\nthread_open_race-no-syscallbuf 2 0.0207266\nthread_stress 2 19.5549\nthread_stress-no-syscallbuf 2 15.7079\nthreaded_syscall_spam 2 1.11981\nthreaded_syscall_spam-no-syscallbuf 2 0.0223191\nthreads 2 1.22788\nthreads-no-syscallbuf 2 1.15627\ntls 2 0.912272\ntls-no-syscallbuf 2 0.891445\nttyname 2 0.168692\nttyname-no-syscallbuf 2 0.165043\nunexpected_stack_growth 2 1.10499\nunexpected_stack_growth-no-syscallbuf 2 1.1247\nuser_ignore_sig 2 0.195225\nuser_ignore_sig-no-syscallbuf 2 0.16423\nvdso_clock_gettime_stack 2 1.26935\nvdso_clock_gettime_stack-no-syscallbuf 2 0.0191466\nvdso_gettimeofday_stack 2 1.22336\nvdso_gettimeofday_stack-no-syscallbuf 2 0.0223277\nvdso_time_stack 2 1.09675\nvdso_time_stack-no-syscallbuf 2 0.0224125\nvfork 2 0.273825\nvfork-no-syscallbuf 2 0.235919\nvfork_read_clone_stress 2 2.57748\nvfork_read_clone_stress-no-syscallbuf 2 1.52819\nvsyscall_reverse_next 2 4.01991\nvsyscall_reverse_next-no-syscallbuf 2 3.6232\nwait_for_all 2 1.14849\nwait_for_all-no-syscallbuf 2 1.14272\nwatchpoint 2 1.4021\nwatchpoint-no-syscallbuf 2 1.45019\nwatchpoint_at_sched 2 1.26641\nwatchpoint_at_sched-no-syscallbuf 2 2.16817\nwatchpoint_before_signal 2 0.889821\nwatchpoint_before_signal-no-syscallbuf 2 0.873965\nwatchpoint_no_progress 2 2.94675\nwatchpoint_no_progress-no-syscallbuf 2 1.77617\nwatchpoint_size_change 2 0.914569\nwatchpoint_size_change-no-syscallbuf 2 0.914861\nwatchpoint_syscall 2 1.10858\nwatchpoint_syscall-no-syscallbuf 2 0.967778\nwatchpoint_unaligned 2 0.885318\nwatchpoint_unaligned-no-syscallbuf 2 0.850577\nasync_signal_syscalls_100 2 0.216078\nasync_signal_syscalls_100-no-syscallbuf 2 3.64995\nasync_signal_syscalls_1000 2 0.210203\nasync_signal_syscalls_1000-no-syscallbuf 2 3.41878\nbad_breakpoint 2 10.5237\nbad_breakpoint-no-syscallbuf 2 9.75803\nbreak_block 2 9.95668\nbreak_block-no-syscallbuf 2 9.98023\nbreak_clock 2 0.997136\nbreak_clock-no-syscallbuf 2 1.19868\nbreak_clone 2 0.860601\nbreak_clone-no-syscallbuf 2 0.866168\nbreak_exec 2 1.05496\nbreak_exec-no-syscallbuf 2 0.928972\nbreak_int3 2 0.84853\nbreak_int3-no-syscallbuf 2 0.826974\nbreak_mmap_private 2 2.2772\nbreak_mmap_private-no-syscallbuf 2 2.3963\nbreak_msg 2 2.33334\nbreak_msg-no-syscallbuf 2 2.31454\nx86/break_rdtsc 2 0.906172\nx86/break_rdtsc-no-syscallbuf 2 0.898956\nbreak_sigreturn 2 4.86845\nbreak_sigreturn-no-syscallbuf 2 4.7959\nbreak_sync_signal 2 0.889585\nbreak_sync_signal-no-syscallbuf 2 0.953888\nbreak_thread 2 0.987441\nbreak_thread-no-syscallbuf 2 0.95672\nbreak_time_slice 2 9.39381\nbreak_time_slice-no-syscallbuf 2 9.5303\nbreakpoint_consistent 2 0.864593\nbreakpoint_consistent-no-syscallbuf 2 0.862363\ncall_exit 2 1.24356\ncall_exit-no-syscallbuf 2 1.24033\ncheck_patched_pthread 2 2.17917\ncheck_patched_pthread-no-syscallbuf 2 1.88506\ncheckpoint_async_signal_syscalls_1000 2 3.53824\ncheckpoint_async_signal_syscalls_1000-no-syscallbuf 2 0.0191438\ncheckpoint_mmap_shared 2 25.9316\ncheckpoint_mmap_shared-no-syscallbuf 2 19.8694\ncheckpoint_prctl_name 2 36.1448\ncheckpoint_prctl_name-no-syscallbuf 2 33.1562\ncheckpoint_simple 2 17.1481\ncheckpoint_simple-no-syscallbuf 2 20.2543\nchecksum_sanity_noclone 2 2.47752\nchecksum_sanity_noclone-no-syscallbuf 2 1.57982\ncomm 2 0.628376\ncomm-no-syscallbuf 2 0.752701\ncont_signal 2 4.98586\ncont_signal-no-syscallbuf 2 5.02741\nx86/cpuid 2 0.967095\nx86/cpuid-no-syscallbuf 2 0.967151\ndead_thread_target 2 1.25742\ndead_thread_target-no-syscallbuf 2 1.15103\ndesched_ticks 2 0.933889\ndesched_ticks-no-syscallbuf 2 0.0205327\ndeliver_async_signal_during_syscalls 2 0.708237\ndeliver_async_signal_during_syscalls-no-syscallbuf 2 0.0201994\nenv_newline 2 0.172633\nenv_newline-no-syscallbuf 2 0.176236\nexec_deleted 2 0.174422\nexec_deleted-no-syscallbuf 2 0.154924\nexec_stop 2 0.971989\nexec_stop-no-syscallbuf 2 0.932378\nexecp 2 0.179868\nexecp-no-syscallbuf 2 0.172007\nexplicit_checkpoint_clone 2 1.16827\nexplicit_checkpoint_clone-no-syscallbuf 2 1.13606\nfile_name_newline 2 0.206819\nfile_name_newline-no-syscallbuf 2 0.186296\nfinal_sigkill 2 1.2137\nfinal_sigkill-no-syscallbuf 2 1.16333\nfirst_instruction 2 0.714622\nfirst_instruction-no-syscallbuf 2 0.727912\nfork_exec_info_thr 2 3.49358\nfork_exec_info_thr-no-syscallbuf 2 3.3585\nget_thread_list 2 1.14847\nget_thread_list-no-syscallbuf 2 1.12759\nhardlink_mmapped_files 2 2.21432\nhardlink_mmapped_files-no-syscallbuf 2 2.22769\nhbreak 2 0.98144\nhbreak-no-syscallbuf 2 1.06173\nmprotect_step 2 1.19977\nmprotect_step-no-syscallbuf 2 1.17342\nnested_detach 2 0.443621\nnested_detach-no-syscallbuf 2 0.426141\nnested_detach_kill 2 0.579554\nnested_detach_kill-no-syscallbuf 2 0.57556\nnested_release 2 0.416726\nnested_release-no-syscallbuf 2 0.320548\nparent_no_break_child_bkpt 2 1.35192\nparent_no_break_child_bkpt-no-syscallbuf 2 1.43833\nparent_no_stop_child_crash 2 1.27584\nparent_no_stop_child_crash-no-syscallbuf 2 1.28431\npost_exec_fpu_regs 2 0.609478\npost_exec_fpu_regs-no-syscallbuf 2 0.616487\nproc_maps 2 0.869244\nproc_maps-no-syscallbuf 2 0.917006\nread_bad_mem 2 0.884557\nread_bad_mem-no-syscallbuf 2 0.852502\nrecord_replay 2 141.185\nrecord_replay-no-syscallbuf 2 153.148\nremove_watchpoint 2 0.978183\nremove_watchpoint-no-syscallbuf 2 0.94822\nreplay_overlarge_event_number 2 0.194689\nreplay_overlarge_event_number-no-syscallbuf 2 0.159605\nreplay_serve_files 2 3.66096\nreplay_serve_files-no-syscallbuf 2 3.62241\nrestart_invalid_checkpoint 2 1.21307\nrestart_invalid_checkpoint-no-syscallbuf 2 1.27762\nrestart_unstable 2 1.19906\nrestart_unstable-no-syscallbuf 2 1.13003\nrestart_diversion 2 1.43123\nrestart_diversion-no-syscallbuf 2 1.32596\nreverse_alarm 2 4.70091\nreverse_alarm-no-syscallbuf 2 5.96815\nreverse_continue_exec_subprocess 2 2.35457\nreverse_continue_exec_subprocess-no-syscallbuf 2 2.94139\nreverse_continue_fork_subprocess 2 1.28133\nreverse_continue_fork_subprocess-no-syscallbuf 2 1.29387\nreverse_continue_int3 2 3.80374\nreverse_continue_int3-no-syscallbuf 2 5.79677\nreverse_continue_start 2 3.17295\nreverse_continue_start-no-syscallbuf 2 2.41344\nreverse_finish 2 3.16817\nreverse_finish-no-syscallbuf 2 1.85083\nreverse_step_breakpoint 2 3.3135\nreverse_step_breakpoint-no-syscallbuf 2 3.69605\nreverse_step_signal 2 4.24914\nreverse_step_signal-no-syscallbuf 2 4.50127\nreverse_step_threads2 2 4.63635\nreverse_step_threads2-no-syscallbuf 2 4.4955\nreverse_watchpoint 2 3.56927\nreverse_watchpoint-no-syscallbuf 2 3.64424\nreverse_watchpoint_syscall 2 7.81341\nreverse_watchpoint_syscall-no-syscallbuf 2 7.23407\nrun_end 2 1.51075\nrun_end-no-syscallbuf 2 1.48436\nrun_in_function 2 1.06551\nrun_in_function-no-syscallbuf 2 1.22989\nsanity 2 1.01111\nsanity-no-syscallbuf 2 0.787738\nseekticks 2 1.84473\nseekticks-no-syscallbuf 2 1.93585\nshm_checkpoint 2 1.19522\nshm_checkpoint-no-syscallbuf 2 1.15687\nsiginfo 2 0.772502\nsiginfo-no-syscallbuf 2 0.865984\nx86/sigreturn_checksum 2 0.778667\nx86/sigreturn_checksum-no-syscallbuf 2 0.733952\nsignal_stop 2 0.907598\nsignal_stop-no-syscallbuf 2 0.881811\nsignal_checkpoint 2 1.2013\nsignal_checkpoint-no-syscallbuf 2 1.15467\nsimple_script 2 0.197487\nsimple_script-no-syscallbuf 2 0.185854\nsimple_script_debug 2 0.86698\nsimple_script_debug-no-syscallbuf 2 0.876364\nsimple_winch 2 2.97679\nsimple_winch-no-syscallbuf 2 2.26149\nstack_overflow_debug 2 7.46715\nstack_overflow_debug-no-syscallbuf 2 6.59686\nstep1 2 0.895537\nstep1-no-syscallbuf 2 0.955415\nx86/step_rdtsc 2 1.0748\nx86/step_rdtsc-no-syscallbuf 2 0.934643\nstep_signal 2 0.947377\nstep_signal-no-syscallbuf 2 0.959475\nx86/string_instructions_break 2 6.82516\nx86/string_instructions_break-no-syscallbuf 2 7.17043\nx86/string_instructions_replay_quirk 2 7.50406\nx86/string_instructions_replay_quirk-no-syscallbuf 2 6.87678\nsubprocess_exit_ends_session 2 1.27728\nsubprocess_exit_ends_session-no-syscallbuf 2 1.21137\nswitch_processes 2 3.19626\nswitch_processes-no-syscallbuf 2 2.6858\nsyscallbuf_timeslice_250 2 0.249806\nsyscallbuf_timeslice_250-no-syscallbuf 2 3.29356\ntrace_version 2 2.53497\ntrace_version-no-syscallbuf 2 2.70248\nterm_trace_cpu 2 0.514448\nterm_trace_cpu-no-syscallbuf 2 0.565433\ntrace_events 2 0.134258\ntrace_events-no-syscallbuf 2 0.127315\ntty 2 0.151032\ntty-no-syscallbuf 2 0.150354\nunmap_vdso 2 0.353832\nunmap_vdso-no-syscallbuf 2 0.341826\nunwind_on_signal 2 0.948899\nunwind_on_signal-no-syscallbuf 2 0.914195\nvfork_exec 2 0.910633\nvfork_exec-no-syscallbuf 2 0.922927\nvfork_break_parent 2 0.932378\nvfork_break_parent-no-syscallbuf 2 0.953784\nvsyscall_singlestep 2 0.162971\nvsyscall_singlestep-no-syscallbuf 2 0.145158\nwatch_code 2 3.72841\nwatch_code-no-syscallbuf 2 2.43417\nwatchpoint_cond 2 0.891707\nwatchpoint_cond-no-syscallbuf 2 0.837046\nwhen 2 0.866097\nwhen-no-syscallbuf 2 0.885084\n64bit_child-32 2 0.343532\n64bit_child-32-no-syscallbuf 2 0.344224\n_llseek-32 2 0.236283\n_llseek-32-no-syscallbuf 2 0.159258\nabort-32 2 0.440587\nabort-32-no-syscallbuf 2 0.415051\naccept-32 2 0.303637\naccept-32-no-syscallbuf 2 0.273315\nacct-32 2 0.175651\nacct-32-no-syscallbuf 2 0.159558\nadjtimex-32 2 0.178372\nadjtimex-32-no-syscallbuf 2 0.157448\naio-32 2 0.156827\naio-32-no-syscallbuf 2 0.148936\nalarm-32 2 1.95172\nalarm-32-no-syscallbuf 2 2.48883\nalarm2-32 2 1.14684\nalarm2-32-no-syscallbuf 2 1.15135\nalsa_ioctl-32 2 0.164307\nalsa_ioctl-32-no-syscallbuf 2 0.170314\narch_prctl-32 2 0.183115\narch_prctl-32-no-syscallbuf 2 0.1533\nasync_segv_ignored-32 2 0.187489\nasync_segv_ignored-32-no-syscallbuf 2 0.16181\nat_threadexit-32 2 0.233616\nat_threadexit-32-no-syscallbuf 2 0.240465\nbad_ip-32 2 0.161617\nbad_ip-32-no-syscallbuf 2 0.153276\nbad_syscall-32 2 0.172995\nbad_syscall-32-no-syscallbuf 2 0.17333\nbarrier-32 2 0.304388\nbarrier-32-no-syscallbuf 2 0.367683\nbig_buffers-32 2 0.17837\nbig_buffers-32-no-syscallbuf 2 0.197323\nblock-32 2 9.32206\nblock-32-no-syscallbuf 2 9.33081\nblock_open-32 2 0.190076\nblock_open-32-no-syscallbuf 2 0.185152\nbpf-32 2 0.192451\nbpf-32-no-syscallbuf 2 0.202114\nbpf_map-32 2 0.169593\nbpf_map-32-no-syscallbuf 2 0.177982\nbrk-32 2 0.172165\nbrk-32-no-syscallbuf 2 0.153512\nbrk2-32 2 0.194184\nbrk2-32-no-syscallbuf 2 0.152208\ncapget-32 2 0.2065\ncapget-32-no-syscallbuf 2 0.175296\nchew_cpu-32 2 8.73853\nchew_cpu-32-no-syscallbuf 2 8.70924\nx86/chew_cpu_cpuid-32 2 0.622714\nx86/chew_cpu_cpuid-32-no-syscallbuf 2 0.4366\nchmod-32 2 0.21103\nchmod-32-no-syscallbuf 2 0.174042\nchown-32 2 0.21456\nchown-32-no-syscallbuf 2 0.223343\nclock-32 2 0.255467\nclock-32-no-syscallbuf 2 0.358987\nclock_adjtime-32 2 0.194787\nclock_adjtime-32-no-syscallbuf 2 0.162301\nclock_nanosleep-32 2 1.19261\nclock_nanosleep-32-no-syscallbuf 2 1.22023\nclock_time64-32 2 0.182615\nclock_time64-32-no-syscallbuf 2 0.169495\nclone-32 2 0.198422\nclone-32-no-syscallbuf 2 0.162276\nclone_bad_stack-32 2 0.258172\nclone_bad_stack-32-no-syscallbuf 2 0.227873\nclone_bad_tls-32 2 0.1688\nclone_bad_tls-32-no-syscallbuf 2 0.150977\nclone_cleartid_coredump-32 2 0.380296\nclone_cleartid_coredump-32-no-syscallbuf 2 0.357681\nclone_fail-32 2 0.175359\nclone_fail-32-no-syscallbuf 2 0.160996\nclone_file_range-32 2 0.179275\nclone_file_range-32-no-syscallbuf 2 0.166524\nclone_immediate_exit-32 2 0.180154\nclone_immediate_exit-32-no-syscallbuf 2 0.179751\nclone_newflags-32 2 0.213326\nclone_newflags-32-no-syscallbuf 2 1.04818\nclone_parent-32 2 0.195602\nclone_parent-32-no-syscallbuf 2 0.159968\nclone_untraced-32 2 0.173588\nclone_untraced-32-no-syscallbuf 2 0.205649\nclone_vfork_pidfd-32 2 0.183834\nclone_vfork_pidfd-32-no-syscallbuf 2 0.170767\ncloned_sigmask-32 2 0.31069\ncloned_sigmask-32-no-syscallbuf 2 0.264808\nconstructor-32 2 2.18134\nconstructor-32-no-syscallbuf 2 2.23034\ncopy_file_range-32 2 0.170721\ncopy_file_range-32-no-syscallbuf 2 0.185973\nx86/cpuid_same_state-32 2 0.168649\nx86/cpuid_same_state-32-no-syscallbuf 2 0.176264\ncreat_address_not_truncated-32 2 0.172016\ncreat_address_not_truncated-32-no-syscallbuf 2 0.160827\nx86/cross_arch-32 2 0.173734\nx86/cross_arch-32-no-syscallbuf 2 0.186919\ncwd_inaccessible-32 2 0.230593\ncwd_inaccessible-32-no-syscallbuf 2 0.228416\ndaemon-32 2 0.185343\ndaemon-32-no-syscallbuf 2 0.159593\ndesched_blocking_poll-32 2 0.191223\ndesched_blocking_poll-32-no-syscallbuf 2 0.177699\ndesched_sigkill-32 2 0.268607\ndesched_sigkill-32-no-syscallbuf 2 0.238282\ndetach_state-32 2 0.255978\ndetach_state-32-no-syscallbuf 2 0.217356\ndetach_threads-32 2 0.273998\ndetach_threads-32-no-syscallbuf 2 0.234168\ndetach_sigkill-32 2 0.270231\ndetach_sigkill-32-no-syscallbuf 2 0.204298\ndetach_sigkill_exit-32 2 0.266415\ndetach_sigkill_exit-32-no-syscallbuf 2 0.181115\ndeterministic_sigsys-32 2 0.341587\ndeterministic_sigsys-32-no-syscallbuf 2 0.313071\ndev_zero-32 2 0.166296\ndev_zero-32-no-syscallbuf 2 0.163734\ndirect-32 2 0.256896\ndirect-32-no-syscallbuf 2 0.200562\ndup-32 2 0.174304\ndup-32-no-syscallbuf 2 0.175881\ndoublesegv-32 2 0.384812\ndoublesegv-32-no-syscallbuf 2 0.339395\nepoll_create-32 2 0.168445\nepoll_create-32-no-syscallbuf 2 0.177292\nepoll_create1-32 2 0.24383\nepoll_create1-32-no-syscallbuf 2 0.176546\nepoll_edge-32 2 0.172137\nepoll_edge-32-no-syscallbuf 2 0.17578\nepoll_pwait_eintr_sigmask-32 2 2.18362\nepoll_pwait_eintr_sigmask-32-no-syscallbuf 2 2.17528\neventfd-32 2 0.170002\neventfd-32-no-syscallbuf 2 0.195814\nexec_flags-32 2 0.176703\nexec_flags-32-no-syscallbuf 2 0.158051\nexec_no_env-32 2 0.210186\nexec_no_env-32-no-syscallbuf 2 0.223995\nexec_self-32 2 0.212399\nexec_self-32-no-syscallbuf 2 0.278598\nexec_from_main_thread-32 2 0.256533\nexec_from_main_thread-32-no-syscallbuf 2 0.2547\nexec_from_other_thread-32 2 11.4391\nexec_from_other_thread-32-no-syscallbuf 2 7.97065\nexec_stopsig-32 2 0.248389\nexec_stopsig-32-no-syscallbuf 2 0.227471\nexecveat-32 2 0.33122\nexecveat-32-no-syscallbuf 2 0.212293\nexit_with_syscallbuf_signal-32 2 0.208462\nexit_with_syscallbuf_signal-32-no-syscallbuf 2 0.177881\nfadvise-32 2 0.189585\nfadvise-32-no-syscallbuf 2 0.188268\nfanotify-32 2 0.15869\nfanotify-32-no-syscallbuf 2 0.176326\nfatal_init_signal-32 2 0.19146\nfatal_init_signal-32-no-syscallbuf 2 0.217814\nfatal_sigsegv_thread-32 2 0.664268\nfatal_sigsegv_thread-32-no-syscallbuf 2 0.527767\nx86/fault_in_code_page-32 2 0.182553\nx86/fault_in_code_page-32-no-syscallbuf 2 0.176254\nfcntl_dupfd-32 2 0.177373\nfcntl_dupfd-32-no-syscallbuf 2 0.188962\nfcntl_misc-32 2 0.164345\nfcntl_misc-32-no-syscallbuf 2 0.16434\nfcntl_notify-32 2 0.190707\nfcntl_notify-32-no-syscallbuf 2 0.165259\nfcntl_owner_ex-32 2 0.197163\nfcntl_owner_ex-32-no-syscallbuf 2 0.155602\nfcntl_rw_hints-32 2 0.193598\nfcntl_rw_hints-32-no-syscallbuf 2 0.179665\nfcntl_seals-32 2 0.169677\nfcntl_seals-32-no-syscallbuf 2 0.155835\nfcntl_sig-32 2 0.188346\nfcntl_sig-32-no-syscallbuf 2 0.1586\nfd_cleanup-32 2 0.186579\nfd_cleanup-32-no-syscallbuf 2 0.186616\nfd_tracking_across_threads-32 2 0.194344\nfd_tracking_across_threads-32-no-syscallbuf 2 0.212191\nfds_clean-32 2 0.236395\nfds_clean-32-no-syscallbuf 2 0.235536\nflock-32 2 0.710811\nflock-32-no-syscallbuf 2 1.46662\nflock_ofd-32 2 0.194817\nflock_ofd-32-no-syscallbuf 2 0.958058\nflock2-32 2 0.160203\nflock2-32-no-syscallbuf 2 0.154417\nfork_brk-32 2 0.180829\nfork_brk-32-no-syscallbuf 2 0.192136\nfork_child_crash-32 2 0.286437\nfork_child_crash-32-no-syscallbuf 2 0.25726\nfork_many-32 2 1.1483\nfork_many-32-no-syscallbuf 2 0.676637\nfutex_exit_race-32 2 0.473886\nfutex_exit_race-32-no-syscallbuf 2 0.398697\nfutex_exit_race_sigsegv-32 2 0.768718\nfutex_exit_race_sigsegv-32-no-syscallbuf 2 0.395598\nfutex_pi-32 2 0.169976\nfutex_pi-32-no-syscallbuf 2 0.171053\nfutex_priorities-32 2 0.199389\nfutex_priorities-32-no-syscallbuf 2 0.193813\nfutex_requeue-32 2 1.16674\nfutex_requeue-32-no-syscallbuf 2 1.17668\ngcrypt_rdrand-32 2 0.198064\ngcrypt_rdrand-32-no-syscallbuf 2 0.17078\ngetcpu-32 2 0.203612\ngetcpu-32-no-syscallbuf 2 0.162867\ngetgroups-32 2 0.194776\ngetgroups-32-no-syscallbuf 2 0.210254\ngetpwnam-32 2 0.249385\ngetpwnam-32-no-syscallbuf 2 0.218375\ngetrandom-32 2 0.219942\ngetrandom-32-no-syscallbuf 2 0.163141\nsetitimer-32 2 0.197037\nsetitimer-32-no-syscallbuf 2 0.174438\ngetsid-32 2 0.163107\ngetsid-32-no-syscallbuf 2 0.173976\ngettimeofday-32 2 0.215287\ngettimeofday-32-no-syscallbuf 2 0.183324\ngrandchild_threads-32 2 0.194359\ngrandchild_threads-32-no-syscallbuf 2 0.18839\ngrandchild_threads_main_running-32 2 2.25777\ngrandchild_threads_main_running-32-no-syscallbuf 2 2.27805\ngrandchild_threads_thread_running-32 2 5.25249\ngrandchild_threads_thread_running-32-no-syscallbuf 2 5.23783\ngrandchild_threads_parent_alive-32 2 0.199\ngrandchild_threads_parent_alive-32-no-syscallbuf 2 0.187577\nx86/hle-32 2 2.22635\nx86/hle-32-no-syscallbuf 2 0.881525\ninotify-32 2 0.162154\ninotify-32-no-syscallbuf 2 0.16806\nint3-32 2 0.159417\nint3-32-no-syscallbuf 2 0.157118\nintr_futex_wait_restart-32 2 1.69813\nintr_futex_wait_restart-32-no-syscallbuf 2 1.69332\nintr_poll-32 2 3.68626\nintr_poll-32-no-syscallbuf 2 3.66997\nintr_ppoll-32 2 21.4084\nintr_ppoll-32-no-syscallbuf 2 21.2981\nintr_pselect-32 2 9.15019\nintr_pselect-32-no-syscallbuf 2 9.19517\nintr_read_no_restart-32 2 1.28784\nintr_read_no_restart-32-no-syscallbuf 2 1.28253\nintr_read_restart-32 2 2.30173\nintr_read_restart-32-no-syscallbuf 2 2.27716\nintr_sleep-32 2 4.18891\nintr_sleep-32-no-syscallbuf 2 4.16715\nintr_sleep_no_restart-32 2 1.77529\nintr_sleep_no_restart-32-no-syscallbuf 2 1.78142\ninvalid_exec-32 2 0.17303\ninvalid_exec-32-no-syscallbuf 2 0.156343\ninvalid_fcntl-32 2 0.17745\ninvalid_fcntl-32-no-syscallbuf 2 0.148237\ninvalid_ioctl-32 2 0.167459\ninvalid_ioctl-32-no-syscallbuf 2 0.153341\nio-32 2 0.153516\nio-32-no-syscallbuf 2 0.152155\nio_uring-32 2 0.156336\nio_uring-32-no-syscallbuf 2 0.172072\nioctl-32 2 0.168334\nioctl-32-no-syscallbuf 2 0.174499\nioctl_blk-32 2 0.172997\nioctl_blk-32-no-syscallbuf 2 0.14378\nioctl_fb-32 2 0.15604\nioctl_fb-32-no-syscallbuf 2 0.177303\nioctl_fs-32 2 0.1805\nioctl_fs-32-no-syscallbuf 2 0.182854\nioctl_pty-32 2 0.245727\nioctl_pty-32-no-syscallbuf 2 0.198318\nioctl_sg-32 2 0.171162\nioctl_sg-32-no-syscallbuf 2 0.154041\nioctl_tty-32 2 0.264824\nioctl_tty-32-no-syscallbuf 2 0.225188\nioctl_vt-32 2 0.170598\nioctl_vt-32-no-syscallbuf 2 0.16299\nioprio-32 2 0.169689\nioprio-32-no-syscallbuf 2 0.179517\nx86/ioperm-32 2 0.169697\nx86/ioperm-32-no-syscallbuf 2 0.156024\nx86/iopl-32 2 0.163983\nx86/iopl-32-no-syscallbuf 2 0.1679\njoin_threads-32 2 1.54955\njoin_threads-32-no-syscallbuf 2 1.7967\njoystick-32 2 0.180789\njoystick-32-no-syscallbuf 2 0.188287\nkcmp-32 2 0.172476\nkcmp-32-no-syscallbuf 2 0.173309\nkeyctl-32 2 0.213803\nkeyctl-32-no-syscallbuf 2 0.185761\nkill_newborn-32 2 0.434392\nkill_newborn-32-no-syscallbuf 2 0.352364\nkill_ptracee-32 2 0.245936\nkill_ptracee-32-no-syscallbuf 2 1.77335\nlarge_hole-32 2 0.19012\nlarge_hole-32-no-syscallbuf 2 0.152114\nlarge_write_deadlock-32 2 0.187997\nlarge_write_deadlock-32-no-syscallbuf 2 0.157017\nlegacy_ugid-32 2 0.172081\nlegacy_ugid-32-no-syscallbuf 2 0.154932\nx86/lsl-32 2 0.174847\nx86/lsl-32-no-syscallbuf 2 0.182991\nmadvise-32 2 0.171796\nmadvise-32-no-syscallbuf 2 0.168836\nmadvise_free-32 2 0.162956\nmadvise_free-32-no-syscallbuf 2 0.146138\nmadvise_wipeonfork-32 2 0.298329\nmadvise_wipeonfork-32-no-syscallbuf 2 0.248712\nmap_fixed-32 2 0.171006\nmap_fixed-32-no-syscallbuf 2 0.156162\nmap_shared_syscall-32 2 0.240547\nmap_shared_syscall-32-no-syscallbuf 2 0.188137\nmembarrier-32 2 0.230167\nmembarrier-32-no-syscallbuf 2 0.262814\nmemfd_create-32 2 0.159255\nmemfd_create-32-no-syscallbuf 2 0.159951\nmemfd_create_shared-32 2 0.168803\nmemfd_create_shared-32-no-syscallbuf 2 0.169416\nmemfd_create_shared_huge-32 2 0.166679\nmemfd_create_shared_huge-32-no-syscallbuf 2 0.168568\nmincore-32 2 0.195951\nmincore-32-no-syscallbuf 2 0.179282\nmknod-32 2 0.1707\nmknod-32-no-syscallbuf 2 0.220839\nmlock-32 2 0.178006\nmlock-32-no-syscallbuf 2 0.169444\nmmap_adjacent_to_rr_usage-32 2 0.173778\nmmap_adjacent_to_rr_usage-32-no-syscallbuf 2 0.168001\nmmap_private-32 2 1.00159\nmmap_private-32-no-syscallbuf 2 0.99163\nmmap_private_grow_under_map-32 2 0.173808\nmmap_private_grow_under_map-32-no-syscallbuf 2 0.165926\nmmap_recycle-32 2 0.191217\nmmap_recycle-32-no-syscallbuf 2 0.224146\nmmap_ro-32 2 0.174387\nmmap_ro-32-no-syscallbuf 2 0.168227\nmmap_self_maps_shared-32 2 0.235438\nmmap_self_maps_shared-32-no-syscallbuf 2 0.255654\nmmap_shared-32 2 0.223286\nmmap_shared-32-no-syscallbuf 2 0.177803\nmmap_shared_dev_zero-32 2 0.162855\nmmap_shared_dev_zero-32-no-syscallbuf 2 0.187624\nmmap_shared_grow-32 2 0.172259\nmmap_shared_grow-32-no-syscallbuf 2 0.167488\nmmap_shared_grow_under_map-32 2 0.177782\nmmap_shared_grow_under_map-32-no-syscallbuf 2 0.24619\nmmap_shared_multiple-32 2 0.165807\nmmap_shared_multiple-32-no-syscallbuf 2 0.182459\nmmap_shared_subpage-32 2 0.178498\nmmap_shared_subpage-32-no-syscallbuf 2 0.208066\nmmap_shared_write-32 2 7.86342\nmmap_shared_write-32-no-syscallbuf 2 7.60719\nmmap_shared_write_fork-32 2 3.38886\nmmap_shared_write_fork-32-no-syscallbuf 2 4.51516\nmmap_short_file-32 2 0.17335\nmmap_short_file-32-no-syscallbuf 2 0.167058\nmmap_write_complex-32 2 0.172373\nmmap_write_complex-32-no-syscallbuf 2 0.214238\nmmap_zero_size_fd-32 2 0.169857\nmmap_zero_size_fd-32-no-syscallbuf 2 0.178777\nx86/modify_ldt-32 2 0.180909\nx86/modify_ldt-32-no-syscallbuf 2 0.158959\nmount_ns_exec-32 2 0.242339\nmount_ns_exec-32-no-syscallbuf 2 0.231321\nmount_ns_exec2-32 2 0.226181\nmount_ns_exec2-32-no-syscallbuf 2 0.239407\nmprotect-32 2 0.181316\nmprotect-32-no-syscallbuf 2 0.175856\nmprotect_heterogenous-32 2 0.173654\nmprotect_heterogenous-32-no-syscallbuf 2 0.165665\nmprotect_none-32 2 0.180685\nmprotect_none-32-no-syscallbuf 2 0.165696\nmprotect_stack-32 2 0.172227\nmprotect_stack-32-no-syscallbuf 2 0.164478\nmq-32 2 2.15956\nmq-32-no-syscallbuf 2 2.16518\nmremap-32 2 2.73883\nmremap-32-no-syscallbuf 2 3.268\nmremap_after_coalesce-32 2 0.1893\nmremap_after_coalesce-32-no-syscallbuf 2 0.158341\nmremap_grow-32 2 0.197778\nmremap_grow-32-no-syscallbuf 2 0.157984\nmremap_grow_shared-32 2 0.182198\nmremap_grow_shared-32-no-syscallbuf 2 0.224127\nmremap_non_page_size-32 2 0.19472\nmremap_non_page_size-32-no-syscallbuf 2 0.978314\nmremap_overwrite-32 2 0.196536\nmremap_overwrite-32-no-syscallbuf 2 0.169694\nmremap_private_grow_under_map-32 2 0.250805\nmremap_private_grow_under_map-32-no-syscallbuf 2 0.154396\nmremap_shrink-32 2 0.166243\nmremap_shrink-32-no-syscallbuf 2 0.181565\nmsg-32 2 1.68107\nmsg-32-no-syscallbuf 2 1.68818\nmsg_trunc-32 2 0.176434\nmsg_trunc-32-no-syscallbuf 2 0.165524\nmsync-32 2 1.04094\nmsync-32-no-syscallbuf 2 1.28593\nmtio-32 2 0.189331\nmtio-32-no-syscallbuf 2 0.167114\nmultiple_pending_signals-32 2 0.188975\nmultiple_pending_signals-32-no-syscallbuf 2 0.192054\nmultiple_pending_signals_sequential-32 2 0.190957\nmultiple_pending_signals_sequential-32-no-syscallbuf 2 0.179665\nmunmap_segv-32 2 0.218063\nmunmap_segv-32-no-syscallbuf 2 0.173991\nmunmap_discontinuous-32 2 0.192355\nmunmap_discontinuous-32-no-syscallbuf 2 0.167422\nnanosleep-32 2 1.17149\nnanosleep-32-no-syscallbuf 2 1.15108\nnetfilter-32 2 0.236264\nnetfilter-32-no-syscallbuf 2 0.256435\nnetlink_mmap_disable-32 2 0.157522\nnetlink_mmap_disable-32-no-syscallbuf 2 0.165765\nno_mask_timeslice-32 2 0.850216\nno_mask_timeslice-32-no-syscallbuf 2 0.821699\nnscd-32 2 0.179882\nnscd-32-no-syscallbuf 2 0.160008\nnuma-32 2 0.197031\nnuma-32-no-syscallbuf 2 0.166399\nx86/old_fork-32 2 0.21567\nx86/old_fork-32-no-syscallbuf 2 0.18302\norphan_process-32 2 0.206772\norphan_process-32-no-syscallbuf 2 0.184401\npacket_mmap_disable-32 2 0.163268\npacket_mmap_disable-32-no-syscallbuf 2 0.151608\npause-32 2 1.15926\npause-32-no-syscallbuf 2 1.14328\nperf_event-32 2 0.207887\nperf_event-32-no-syscallbuf 2 0.182937\npersonality-32 2 0.184296\npersonality-32-no-syscallbuf 2 0.223865\npid_ns_kill_child-32 2 0.385645\npid_ns_kill_child-32-no-syscallbuf 2 0.3028\npid_ns_kill_child_threads-32 2 0.254021\npid_ns_kill_child_threads-32-no-syscallbuf 2 0.20647\npid_ns_kill_child_zombie-32 2 0.223784\npid_ns_kill_child_zombie-32-no-syscallbuf 2 0.196851\npid_ns_kill_threads-32 2 0.230732\npid_ns_kill_threads-32-no-syscallbuf 2 0.212946\npid_ns_kill_threads_exit_wait-32 2 0.328763\npid_ns_kill_threads_exit_wait-32-no-syscallbuf 2 0.248139\npid_ns_reap-32 2 0.227847\npid_ns_reap-32-no-syscallbuf 2 0.243935\npid_ns_segv-32 2 0.292908\npid_ns_segv-32-no-syscallbuf 2 0.241546\npid_ns_shutdown-32 2 0.508542\npid_ns_shutdown-32-no-syscallbuf 2 0.309565\npidfd-32 2 0.194201\npidfd-32-no-syscallbuf 2 0.179072\nx86/pkeys-32 2 0.16721\nx86/pkeys-32-no-syscallbuf 2 0.151803\npoll_sig_race-32 2 2.94428\npoll_sig_race-32-no-syscallbuf 2 2.89483\nppoll-32 2 5.72427\nppoll-32-no-syscallbuf 2 5.72158\nprctl-32 2 0.243426\nprctl-32-no-syscallbuf 2 0.168644\nprctl_caps-32 2 0.417118\nprctl_caps-32-no-syscallbuf 2 0.362039\nprctl_deathsig-32 2 0.253595\nprctl_deathsig-32-no-syscallbuf 2 0.175611\nprctl_name-32 2 0.28042\nprctl_name-32-no-syscallbuf 2 0.240042\nprctl_short_name-32 2 0.180561\nprctl_short_name-32-no-syscallbuf 2 0.153409\nprctl_speculation_ctrl-32 2 0.177203\nprctl_speculation_ctrl-32-no-syscallbuf 2 0.168493\nx86/prctl_tsc-32 2 0.195859\nx86/prctl_tsc-32-no-syscallbuf 2 0.180645\nprivileged_net_ioctl-32 2 0.435754\nprivileged_net_ioctl-32-no-syscallbuf 2 0.449377\nproc_fds-32 2 0.622971\nproc_fds-32-no-syscallbuf 2 0.766995\nproc_mem-32 2 0.386866\nproc_mem-32-no-syscallbuf 2 0.376723\nprotect_rr_fds-32 2 3.15255\nprotect_rr_fds-32-no-syscallbuf 2 3.95277\nprw-32 2 0.163791\nprw-32-no-syscallbuf 2 0.175139\npthread_condvar_locking-32 2 0.195831\npthread_condvar_locking-32-no-syscallbuf 2 0.198542\npthread_mutex_timedlock-32 2 0.172525\npthread_mutex_timedlock-32-no-syscallbuf 2 0.171628\npthread_pi_mutex-32 2 0.194426\npthread_pi_mutex-32-no-syscallbuf 2 0.147285\npthread_rwlocks-32 2 0.188592\npthread_rwlocks-32-no-syscallbuf 2 0.167646\nx86/ptrace-32 2 0.225572\nx86/ptrace-32-no-syscallbuf 2 0.230391\nptrace_attach_null_status-32 2 0.21989\nptrace_attach_null_status-32-no-syscallbuf 2 0.221423\nptrace_attach_running-32 2 0.322088\nptrace_attach_running-32-no-syscallbuf 2 1.81167\nptrace_attach_sleeping-32 2 0.229337\nptrace_attach_sleeping-32-no-syscallbuf 2 0.259472\nptrace_attach_stopped-32 2 0.254542\nptrace_attach_stopped-32-no-syscallbuf 2 0.254623\nptrace_attach_thread_running-32 2 7.71519\nptrace_attach_thread_running-32-no-syscallbuf 2 9.21576\nptrace_breakpoint-32 2 0.207377\nptrace_breakpoint-32-no-syscallbuf 2 0.205281\nptrace_change_patched_syscall-32 2 0.214222\nptrace_change_patched_syscall-32-no-syscallbuf 2 0.198213\nx86/ptrace_debug_regs-32 2 0.180522\nx86/ptrace_debug_regs-32-no-syscallbuf 2 0.192852\nptrace_exec-32 2 0.311664\nptrace_exec-32-no-syscallbuf 2 0.265444\nx86/ptrace_exec32-32 2 0.169313\nx86/ptrace_exec32-32-no-syscallbuf 2 0.209205\nptrace_kill_grandtracee-32 2 0.218563\nptrace_kill_grandtracee-32-no-syscallbuf 2 0.185387\nx86/ptrace_tls-32 2 0.264243\nx86/ptrace_tls-32-no-syscallbuf 2 0.186428\nptrace_seize-32 2 0.183568\nptrace_seize-32-no-syscallbuf 2 0.159259\nptrace_sigchld_blocked-32 2 0.200425\nptrace_sigchld_blocked-32-no-syscallbuf 2 0.200648\nptrace_signals-32 2 0.304559\nptrace_signals-32-no-syscallbuf 2 0.278018\nptrace_singlestep-32 2 0.639743\nptrace_singlestep-32-no-syscallbuf 2 0.222714\nptrace_syscall-32 2 0.189698\nptrace_syscall-32-no-syscallbuf 2 0.198213\nptrace_syscall_clone_untraced-32 2 0.303777\nptrace_syscall_clone_untraced-32-no-syscallbuf 2 0.238925\nx86/ptrace_sysemu-32 2 0.258322\nx86/ptrace_sysemu-32-no-syscallbuf 2 0.320688\nptrace_sysemu_syscall-32 2 0.185471\nptrace_sysemu_syscall-32-no-syscallbuf 2 0.220217\nptrace_trace_clone-32 2 0.212671\nptrace_trace_clone-32-no-syscallbuf 2 0.203035\nptrace_trace_exit-32 2 0.183704\nptrace_trace_exit-32-no-syscallbuf 2 0.167785\nptrace_traceme-32 2 0.184022\nptrace_traceme-32-no-syscallbuf 2 0.18187\nptracer_death-32 2 0.248333\nptracer_death-32-no-syscallbuf 2 0.249883\nptracer_death_multithread-32 2 0.388901\nptracer_death_multithread-32-no-syscallbuf 2 0.369612\nptracer_death_multithread_peer-32 2 0.419266\nptracer_death_multithread_peer-32-no-syscallbuf 2 0.395806\nquotactl-32 2 0.182772\nquotactl-32-no-syscallbuf 2 0.201297\nx86/rdtsc-32 2 0.255399\nx86/rdtsc-32-no-syscallbuf 2 0.229242\nread_nothing-32 2 7.46141\nread_nothing-32-no-syscallbuf 2 7.72549\nreaddir-32 2 0.174061\nreaddir-32-no-syscallbuf 2 0.167578\nread_large-32 2 0.428546\nread_large-32-no-syscallbuf 2 1.15199\nread_oversize-32 2 0.162112\nread_oversize-32-no-syscallbuf 2 0.162055\nreadlink-32 2 0.186308\nreadlink-32-no-syscallbuf 2 0.212726\nreadlinkat-32 2 0.165631\nreadlinkat-32-no-syscallbuf 2 0.160991\nreadv-32 2 0.190512\nreadv-32-no-syscallbuf 2 0.175585\nrecord_replay_subject-32 2 3.25793\nrecord_replay_subject-32-no-syscallbuf 2 3.43256\nrecvfrom-32 2 0.186827\nrecvfrom-32-no-syscallbuf 2 0.168322\nredzone_integrity-32 2 1.14239\nredzone_integrity-32-no-syscallbuf 2 1.13652\nrename-32 2 0.178096\nrename-32-no-syscallbuf 2 0.168682\nrlimit-32 2 0.182187\nrlimit-32-no-syscallbuf 2 0.165564\nrobust_futex-32 2 0.202095\nrobust_futex-32-no-syscallbuf 2 0.198996\nrusage-32 2 0.168172\nrusage-32-no-syscallbuf 2 0.206066\nsamask-32 2 0.337743\nsamask-32-no-syscallbuf 2 0.301596\nsave_data_fd-32 2 0.22658\nsave_data_fd-32-no-syscallbuf 2 0.16278\nsched_attr-32 2 0.164539\nsched_attr-32-no-syscallbuf 2 0.162087\nsched_setaffinity-32 2 0.20929\nsched_setaffinity-32-no-syscallbuf 2 0.173467\nsched_setparam-32 2 0.173069\nsched_setparam-32-no-syscallbuf 2 0.161447\nsched_yield-32 2 0.293288\nsched_yield-32-no-syscallbuf 2 0.246936\nsched_yield_to_lower_priority-32 2 0.177359\nsched_yield_to_lower_priority-32-no-syscallbuf 2 0.167451\nscm_rights-32 2 0.700044\nscm_rights-32-no-syscallbuf 2 0.681345\nscratch_read-32 2 0.19306\nscratch_read-32-no-syscallbuf 2 0.193434\nseccomp-32 2 0.289931\nseccomp-32-no-syscallbuf 2 0.188005\nseccomp_cloning-32 2 0.174185\nseccomp_cloning-32-no-syscallbuf 2 0.158513\nseccomp_clone_fail-32 2 0.20893\nseccomp_clone_fail-32-no-syscallbuf 2 0.162227\nseccomp_desched-32 2 0.213358\nseccomp_desched-32-no-syscallbuf 2 0.162138\nseccomp_kill_exit-32 2 0.189344\nseccomp_kill_exit-32-no-syscallbuf 2 0.155638\nseccomp_null-32 2 0.16527\nseccomp_null-32-no-syscallbuf 2 0.194281\nseccomp_sigsys_args-32 2 0.200211\nseccomp_sigsys_args-32-no-syscallbuf 2 0.161084\nseccomp_sigsys_sigtrap-32 2 0.210447\nseccomp_sigsys_sigtrap-32-no-syscallbuf 2 0.201276\nseccomp_sigsys_syscallbuf-32 2 0.209561\nseccomp_sigsys_syscallbuf-32-no-syscallbuf 2 0.162703\nseccomp_tsync-32 2 0.187879\nseccomp_tsync-32-no-syscallbuf 2 0.176498\nseccomp_veto_exec-32 2 0.173933\nseccomp_veto_exec-32-no-syscallbuf 2 0.203032\nself_shebang-32 2 0.24153\nself_shebang-32-no-syscallbuf 2 0.231292\nself_sigint-32 2 0.159231\nself_sigint-32-no-syscallbuf 2 0.153099\nsem-32 2 0.250009\nsem-32-no-syscallbuf 2 0.256186\nsend_block-32 2 1.14479\nsend_block-32-no-syscallbuf 2 2.88824\nsendfile-32 2 0.200584\nsendfile-32-no-syscallbuf 2 0.165255\nset_ptracer-32 2 0.189767\nset_ptracer-32-no-syscallbuf 2 0.167316\nset_tid_address-32 2 0.239881\nset_tid_address-32-no-syscallbuf 2 0.196003\nsetgid-32 2 0.172545\nsetgid-32-no-syscallbuf 2 0.205069\nsetgroups-32 2 0.171244\nsetgroups-32-no-syscallbuf 2 0.167926\nsetsid-32 2 0.169398\nsetsid-32-no-syscallbuf 2 0.152853\nsetuid-32 2 0.233078\nsetuid-32-no-syscallbuf 2 0.239728\nshared_exec-32 2 0.16772\nshared_exec-32-no-syscallbuf 2 0.156276\nshared_monitor-32 2 0.183911\nshared_monitor-32-no-syscallbuf 2 0.170766\nshared_offset-32 2 0.196638\nshared_offset-32-no-syscallbuf 2 0.159853\nshared_write-32 2 0.181719\nshared_write-32-no-syscallbuf 2 0.164443\nshm-32 2 0.217793\nshm-32-no-syscallbuf 2 0.201548\nshm_unmap-32 2 0.1996\nshm_unmap-32-no-syscallbuf 2 0.165694\nsigaction_old-32 2 0.163398\nsigaction_old-32-no-syscallbuf 2 0.148241\nsigaltstack-32 2 0.168017\nsigaltstack-32-no-syscallbuf 2 0.177744\nsigchld_interrupt_signal-32 2 4.17391\nsigchld_interrupt_signal-32-no-syscallbuf 2 4.64724\nsigcont-32 2 0.182719\nsigcont-32-no-syscallbuf 2 0.17846\nsighandler_bad_rsp_sigsegv-32 2 0.165357\nsighandler_bad_rsp_sigsegv-32-no-syscallbuf 2 0.200135\nsighandler_fork-32 2 0.229891\nsighandler_fork-32-no-syscallbuf 2 0.201362\nsighandler_mask-32 2 0.198156\nsighandler_mask-32-no-syscallbuf 2 0.197925\nsigill-32 2 0.175937\nsigill-32-no-syscallbuf 2 0.151933\nsignal_deferred-32 2 0.238068\nsignal_deferred-32-no-syscallbuf 2 0.22673\nsignal_during_preload_init-32 2 0.205667\nsignal_during_preload_init-32-no-syscallbuf 2 0.16874\nsignal_frame-32 2 0.183135\nsignal_frame-32-no-syscallbuf 2 0.163214\nsignal_unstoppable-32 2 0.172697\nsignal_unstoppable-32-no-syscallbuf 2 0.176041\nsignalfd-32 2 0.163957\nsignalfd-32-no-syscallbuf 2 0.173083\nsigprocmask-32 2 0.635516\nsigprocmask-32-no-syscallbuf 2 0.512729\nsigprocmask_ensure_delivery-32 2 0.188993\nsigprocmask_ensure_delivery-32-no-syscallbuf 2 0.197066\nsigprocmask_exec-32 2 0.224889\nsigprocmask_exec-32-no-syscallbuf 2 0.203679\nsigprocmask_evil-32 2 0.173367\nsigprocmask_evil-32-no-syscallbuf 2 0.161906\nsigprocmask_in_syscallbuf_sighandler-32 2 1.1356\nsigprocmask_in_syscallbuf_sighandler-32-no-syscallbuf 2 1.16151\nsigprocmask_rr_sigs-32 2 0.203465\nsigprocmask_rr_sigs-32-no-syscallbuf 2 0.154496\nsigprocmask_syscallbuf-32 2 0.257067\nsigprocmask_syscallbuf-32-no-syscallbuf 2 0.163535\nsigqueueinfo-32 2 0.192575\nsigqueueinfo-32-no-syscallbuf 2 0.183718\nx86/sigreturn-32 2 0.200426\nx86/sigreturn-32-no-syscallbuf 2 0.203151\nsigreturn_reg-32 2 0.164388\nsigreturn_reg-32-no-syscallbuf 2 0.157327\nsigreturnmask-32 2 0.360989\nsigreturnmask-32-no-syscallbuf 2 0.329691\nsigrt-32 2 0.279908\nsigrt-32-no-syscallbuf 2 0.273772\nsigstop-32 2 0.272004\nsigstop-32-no-syscallbuf 2 0.21508\nsigstop2-32 2 0.173375\nsigstop2-32-no-syscallbuf 2 0.1829\nsigsuspend-32 2 0.179968\nsigsuspend-32-no-syscallbuf 2 0.181647\nsigtrap-32 2 0.194202\nsigtrap-32-no-syscallbuf 2 0.198646\nsimple_threads_stress-32 2 1.55506\nsimple_threads_stress-32-no-syscallbuf 2 1.91246\nsioc-32 2 0.597241\nsioc-32-no-syscallbuf 2 0.984665\nsmall_holes-32 2 0.216759\nsmall_holes-32-no-syscallbuf 2 0.190171\nsock_names_opts-32 2 0.24013\nsock_names_opts-32-no-syscallbuf 2 0.208039\nspinlock_priorities-32 2 1.18743\nspinlock_priorities-32-no-syscallbuf 2 2.21217\nsplice-32 2 0.211997\nsplice-32-no-syscallbuf 2 0.175437\nstack_growth_after_syscallbuf-32 2 0.176133\nstack_growth_after_syscallbuf-32-no-syscallbuf 2 0.180134\nstack_growth_syscallbuf-32 2 0.224124\nstack_growth_syscallbuf-32-no-syscallbuf 2 7.43736\nstack_growth_with_guard-32 2 0.176287\nstack_growth_with_guard-32-no-syscallbuf 2 0.171927\nstack_invalid-32 2 0.198923\nstack_invalid-32-no-syscallbuf 2 0.158112\nstack_overflow-32 2 0.299813\nstack_overflow-32-no-syscallbuf 2 0.306432\nstack_overflow_altstack-32 2 0.172148\nstack_overflow_altstack-32-no-syscallbuf 2 0.180087\nstack_overflow_with_guard-32 2 0.277676\nstack_overflow_with_guard-32-no-syscallbuf 2 0.259982\nstatfs-32 2 0.247123\nstatfs-32-no-syscallbuf 2 0.223844\nstatx-32 2 0.18761\nstatx-32-no-syscallbuf 2 0.156038\nstdout_child-32 2 0.228882\nstdout_child-32-no-syscallbuf 2 0.202993\nstdout_cloexec-32 2 0.37312\nstdout_cloexec-32-no-syscallbuf 2 0.233512\nstdout_dup-32 2 0.158335\nstdout_dup-32-no-syscallbuf 2 0.180505\nstdout_redirect-32 2 0.233056\nstdout_redirect-32-no-syscallbuf 2 0.228063\nswitch_read-32 2 0.679615\nswitch_read-32-no-syscallbuf 2 0.705301\nsymlink-32 2 0.153647\nsymlink-32-no-syscallbuf 2 0.151247\nsync-32 2 0.224612\nsync-32-no-syscallbuf 2 0.373438\nsync_file_range-32 2 0.176229\nsync_file_range-32-no-syscallbuf 2 0.185675\nsyscall_bp-32 2 0.227873\nsyscall_bp-32-no-syscallbuf 2 0.152013\nsyscall_in_writable_mem-32 2 0.16217\nsyscall_in_writable_mem-32-no-syscallbuf 2 0.162692\nsyscallbuf_signal_reset-32 2 0.171769\nsyscallbuf_signal_reset-32-no-syscallbuf 2 0.172879\nsyscallbuf_signal_blocking-32 2 0.182044\nsyscallbuf_signal_blocking-32-no-syscallbuf 2 0.174233\nsyscallbuf_sigstop-32 2 8.3546\nsyscallbuf_sigstop-32-no-syscallbuf 2 19.726\nsyscallbuf_timeslice-32 2 0.195219\nsyscallbuf_timeslice-32-no-syscallbuf 2 3.18591\nsyscallbuf_timeslice2-32 2 0.235487\nsyscallbuf_timeslice2-32-no-syscallbuf 2 8.84544\nsysconf-32 2 0.216995\nsysconf-32-no-syscallbuf 2 0.183905\nsysctl-32 2 0.17549\nsysctl-32-no-syscallbuf 2 0.182945\nsysemu_singlestep-32 2 0.188511\nsysemu_singlestep-32-no-syscallbuf 2 0.160338\nx86/sysfs-32 2 0.216447\nx86/sysfs-32-no-syscallbuf 2 0.258669\nsysinfo-32 2 0.169013\nsysinfo-32-no-syscallbuf 2 0.159985\ntgkill-32 2 0.211264\ntgkill-32-no-syscallbuf 2 0.224148\nthread_yield-32 2 3.26443\nthread_yield-32-no-syscallbuf 2 3.18955\ntimer-32 2 65.4883\ntimer-32-no-syscallbuf 2 61.5215\ntimerfd-32 2 0.259309\ntimerfd-32-no-syscallbuf 2 0.25765\ntimes-32 2 0.190807\ntimes-32-no-syscallbuf 2 0.165569\ntruncate_temp-32 2 0.192476\ntruncate_temp-32-no-syscallbuf 2 0.183864\ntun-32 2 0.266826\ntun-32-no-syscallbuf 2 0.224363\ntwo_signals_with_mask-32 2 0.193805\ntwo_signals_with_mask-32-no-syscallbuf 2 0.200266\nulimit_low-32 2 0.202149\nulimit_low-32-no-syscallbuf 2 0.185735\nuname-32 2 0.164955\nuname-32-no-syscallbuf 2 0.178798\nunexpected_exit-32 2 0.230114\nunexpected_exit-32-no-syscallbuf 2 0.474315\nunexpected_exit_execve-32 2 0.310605\nunexpected_exit_execve-32-no-syscallbuf 2 0.483972\nunexpected_exit_execve_twice-32 2 1.27987\nunexpected_exit_execve_twice-32-no-syscallbuf 2 1.60515\nunexpected_exit_pid_ns-32 2 0.676718\nunexpected_exit_pid_ns-32-no-syscallbuf 2 0.21609\nunjoined_thread-32 2 0.171839\nunjoined_thread-32-no-syscallbuf 2 0.16768\nunshare-32 2 0.402218\nunshare-32-no-syscallbuf 2 1.21276\nuserfaultfd-32 2 0.189497\nuserfaultfd-32-no-syscallbuf 2 0.161169\nutimes-32 2 0.182642\nutimes-32-no-syscallbuf 2 0.170065\nvdso_parts-32 2 0.156907\nvdso_parts-32-no-syscallbuf 2 0.160536\nvfork_flush-32 2 0.240043\nvfork_flush-32-no-syscallbuf 2 0.182477\nvfork_shared-32 2 0.164851\nvfork_shared-32-no-syscallbuf 2 0.157664\nvideo_capture-32 2 0.1824\nvideo_capture-32-no-syscallbuf 2 0.151597\nvm_readv_writev-32 2 0.178979\nvm_readv_writev-32-no-syscallbuf 2 0.187688\nvsyscall-32 2 0.210085\nvsyscall-32-no-syscallbuf 2 0.158692\nvsyscall_timeslice-32 2 0.188542\nvsyscall_timeslice-32-no-syscallbuf 2 0.176226\nx86/x87env-32 2 0.178634\nx86/x87env-32-no-syscallbuf 2 0.156739\nwait-32 2 0.207803\nwait-32-no-syscallbuf 2 0.181911\nwait_sigstop-32 2 0.245489\nwait_sigstop-32-no-syscallbuf 2 0.20551\nwrite_race-32 2 2.81023\nwrite_race-32-no-syscallbuf 2 1.62455\nwritev-32 2 0.216639\nwritev-32-no-syscallbuf 2 0.158551\nxattr-32 2 0.175634\nxattr-32-no-syscallbuf 2 0.185673\nzero_length_read-32 2 0.20377\nzero_length_read-32-no-syscallbuf 2 0.175449\nstd_random-32 2 0.215086\nstd_random-32-no-syscallbuf 2 0.213033\nunwind_rr_page-32 2 1.15772\nunwind_rr_page-32-no-syscallbuf 2 1.19208\nabort_nonmain-32 2 0.419818\nabort_nonmain-32-no-syscallbuf 2 0.514262\nalternate_thread_diversion-32 2 0.765083\nalternate_thread_diversion-32-no-syscallbuf 2 0.754914\nargs-32 2 0.160012\nargs-32-no-syscallbuf 2 0.164688\nasync_kill_with_syscallbuf-32 2 2.96233\nasync_kill_with_syscallbuf-32-no-syscallbuf 2 3.71867\nasync_kill_with_syscallbuf2-32 2 2.31923\nasync_kill_with_syscallbuf2-32-no-syscallbuf 2 2.7653\nasync_kill_with_threads-32 2 2.28526\nasync_kill_with_threads-32-no-syscallbuf 2 2.25265\nasync_kill_with_threads_main_running-32 2 2.32524\nasync_kill_with_threads_main_running-32-no-syscallbuf 2 2.35965\nasync_kill_with_threads_thread_running-32 2 6.16048\nasync_kill_with_threads_thread_running-32-no-syscallbuf 2 6.17832\nasync_segv-32 2 4.58465\nasync_segv-32-no-syscallbuf 2 4.26574\nasync_signal_syscalls-32 2 1.24413\nasync_signal_syscalls-32-no-syscallbuf 2 0.0191033\nasync_signal_syscalls2-32 2 0.488521\nasync_signal_syscalls2-32-no-syscallbuf 2 0.0195984\nasync_signal_syscalls_siginfo-32 2 2.3458\nasync_signal_syscalls_siginfo-32-no-syscallbuf 2 0.0198688\nasync_usr1-32 2 4.18131\nasync_usr1-32-no-syscallbuf 2 4.37104\nblacklist-32 2 0.199968\nblacklist-32-no-syscallbuf 2 0.169581\nblock_clone_checkpoint-32 2 0.972619\nblock_clone_checkpoint-32-no-syscallbuf 2 1.0248\nblock_clone_interrupted-32 2 6.1161\nblock_clone_interrupted-32-no-syscallbuf 2 5.00848\nblock_clone_syscallbuf_overflow-32 2 7.25687\nblock_clone_syscallbuf_overflow-32-no-syscallbuf 2 7.23739\nblock_intr_sigchld-32 2 6.66237\nblock_intr_sigchld-32-no-syscallbuf 2 5.92013\nblocked_bad_ip-32 2 1.24533\nblocked_bad_ip-32-no-syscallbuf 2 1.06315\nblocked_sigill-32 2 0.449607\nblocked_sigill-32-no-syscallbuf 2 0.436688\nx86/blocked_sigsegv-32 2 0.427648\nx86/blocked_sigsegv-32-no-syscallbuf 2 0.440355\nbreakpoint-32 2 0.781104\nbreakpoint-32-no-syscallbuf 2 0.756534\nbreakpoint_conditions-32 2 0.931492\nbreakpoint_conditions-32-no-syscallbuf 2 0.899478\nbreakpoint_overlap-32 2 0.907463\nbreakpoint_overlap-32-no-syscallbuf 2 0.796609\ncall_function-32 2 0.895301\ncall_function-32-no-syscallbuf 2 0.835369\ncall_gettid-32 2 0.809616\ncall_gettid-32-no-syscallbuf 2 0.797137\ncheckpoint_dying_threads-32 2 0.870958\ncheckpoint_dying_threads-32-no-syscallbuf 2 0.886313\ncheckpoint_mixed_mode-32 2 0.781085\ncheckpoint_mixed_mode-32-no-syscallbuf 2 0.810389\nchecksum_sanity-32 2 2.25127\nchecksum_sanity-32-no-syscallbuf 2 1.54868\ncheck_lost_interrupts-32 2 1.64176\ncheck_lost_interrupts-32-no-syscallbuf 2 0.0340491\nclone_interruption-32 2 1.89058\nclone_interruption-32-no-syscallbuf 2 1.7642\nclone_vfork-32 2 0.228699\nclone_vfork-32-no-syscallbuf 2 0.284549\nconditional_breakpoint_calls-32 2 0.8973\nconditional_breakpoint_calls-32-no-syscallbuf 2 0.853431\nconditional_breakpoint_offload-32 2 97.907\nconditional_breakpoint_offload-32-no-syscallbuf 2 98.3436\ncondvar_stress-32 2 20.5983\ncondvar_stress-32-no-syscallbuf 2 55.8068\ncont_race-32 2 18.4938\ncont_race-32-no-syscallbuf 2 7.5187\nx86/cpuid_singlestep-32 2 0.788428\nx86/cpuid_singlestep-32-no-syscallbuf 2 0.775394\ncrash-32 2 0.375658\ncrash-32-no-syscallbuf 2 0.373543\ncrash_in_function-32 2 1.19966\ncrash_in_function-32-no-syscallbuf 2 1.1729\ndaemon_read-32 2 0.239872\ndaemon_read-32-no-syscallbuf 2 0.206172\ndconf_mock-32 2 0.190717\ndconf_mock-32-no-syscallbuf 2 0.210945\ndev_tty-32 2 0.15771\ndev_tty-32-no-syscallbuf 2 0.152782\ndiversion_sigtrap-32 2 1.14728\ndiversion_sigtrap-32-no-syscallbuf 2 1.14366\ndiversion_syscall-32 2 0.958771\ndiversion_syscall-32-no-syscallbuf 2 0.973065\ndlopen-32 2 5.03807\ndlopen-32-no-syscallbuf 2 6.69\nearly_error-32 2 0.407332\nearly_error-32-no-syscallbuf 2 0.493056\nelapsed_time-32 2 1.80462\nelapsed_time-32-no-syscallbuf 2 1.81788\nexclusion_region-32 2 0.18669\nexclusion_region-32-no-syscallbuf 2 0.165941\nexec_failed-32 2 0.730666\nexec_failed-32-no-syscallbuf 2 0.759682\nexec_many-32 2 6.45334\nexec_many-32-no-syscallbuf 2 4.53874\nexecve_loop-32 2 6.09311\nexecve_loop-32-no-syscallbuf 2 4.70132\nexit_codes-32 2 0.445052\nexit_codes-32-no-syscallbuf 2 0.477203\nexit_group-32 2 0.181852\nexit_group-32-no-syscallbuf 2 0.176978\nexit_race-32 2 1.38796\nexit_race-32-no-syscallbuf 2 1.21512\nexit_status-32 2 0.116335\nexit_status-32-no-syscallbuf 2 0.114189\nx86/explicit_checkpoints-32 2 1.30454\nx86/explicit_checkpoints-32-no-syscallbuf 2 1.26135\nfd_limit-32 2 0.187127\nfd_limit-32-no-syscallbuf 2 0.997723\nfork_stress-32 2 3.61525\nfork_stress-32-no-syscallbuf 2 1.40335\nfork_syscalls-32 2 0.168964\nfork_syscalls-32-no-syscallbuf 2 0.208122\nfunction_calls-32 2 3.03073\nfunction_calls-32-no-syscallbuf 2 3.51453\nx86/fxregs-32 2 0.765217\nx86/fxregs-32-no-syscallbuf 2 0.772687\ngetcwd-32 2 0.169073\ngetcwd-32-no-syscallbuf 2 0.169593\ngdb_bogus_breakpoint-32 2 0.772146\ngdb_bogus_breakpoint-32-no-syscallbuf 2 0.760645\ngoto_event-32 2 3.68828\ngoto_event-32-no-syscallbuf 2 1.69596\nhello-32 2 0.202056\nhello-32-no-syscallbuf 2 0.182372\nhooks-32 2 1.00194\nhooks-32-no-syscallbuf 2 0.0212301\nignored_async_usr1-32 2 2.39089\nignored_async_usr1-32-no-syscallbuf 2 3.59592\nignored_sigsegv-32 2 0.467501\nignored_sigsegv-32-no-syscallbuf 2 0.448767\nignore_nested-32 2 0.328183\nignore_nested-32-no-syscallbuf 2 0.321336\nimmediate_restart-32 2 0.901743\nimmediate_restart-32-no-syscallbuf 2 0.944109\nx86/int3_ok-32 2 0.170286\nx86/int3_ok-32-no-syscallbuf 2 0.175991\ninterrupt-32 2 4.98112\ninterrupt-32-no-syscallbuf 2 4.48325\nintr_ptrace_decline-32 2 5.18875\nintr_ptrace_decline-32-no-syscallbuf 2 4.69277\ninvalid_interpreter-32 2 1.16413\ninvalid_interpreter-32-no-syscallbuf 2 1.12651\ninvalid_jump-32 2 3.69128\ninvalid_jump-32-no-syscallbuf 2 1.89185\njit_proc_mem-32 2 0.871428\njit_proc_mem-32-no-syscallbuf 2 0.869078\nlink-32 2 0.190435\nlink-32-no-syscallbuf 2 0.166527\nmadvise_dontfork-32 2 0.915018\nmadvise_dontfork-32-no-syscallbuf 2 0.916182\nmain_thread_exit-32 2 0.976596\nmain_thread_exit-32-no-syscallbuf 2 0.988971\nmany_yields-32 2 2.70468\nmany_yields-32-no-syscallbuf 2 2.14603\nmmap_fd_reuse_checkpoint-32 2 0.941569\nmmap_fd_reuse_checkpoint-32-no-syscallbuf 2 0.939913\nmmap_replace_most_mappings-32 2 2.68514\nmmap_replace_most_mappings-32-no-syscallbuf 2 2.41771\nmmap_shared_prot-32 2 0.929817\nmmap_shared_prot-32-no-syscallbuf 2 0.92472\nmmap_shared_write_exec_race-32 2 3.81915\nmmap_shared_write_exec_race-32-no-syscallbuf 2 4.60813\nmmap_tmpfs-32 2 0.194743\nmmap_tmpfs-32-no-syscallbuf 2 0.18605\nmmap_write-32 2 0.0192549\nmmap_write-32-no-syscallbuf 2 0.0200511\nmmap_write_private-32 2 0.308225\nmmap_write_private-32-no-syscallbuf 2 0.324777\nmorestack_unwind-32 1 0.537327\nmorestack_unwind-32-no-syscallbuf 1 0.0202514\nmprotect_growsdown-32 2 0.339205\nmprotect_growsdown-32-no-syscallbuf 2 0.31326\nmprotect_syscallbuf_overflow-32 2 0.280952\nmprotect_syscallbuf_overflow-32-no-syscallbuf 2 8.061\nmutex_pi_stress-32 2 22.3886\nmutex_pi_stress-32-no-syscallbuf 2 27.1594\nnested_detach_wait-32 2 0.562413\nnested_detach_wait-32-no-syscallbuf 2 0.555944\noverflow_branch_counter-32 2 2.97918\noverflow_branch_counter-32-no-syscallbuf 2 3.1523\npatch_page_end-32 2 0.168311\npatch_page_end-32-no-syscallbuf 2 0.027147\nx86/patch_40_80_f6_81-32 2 0.164649\nx86/patch_40_80_f6_81-32-no-syscallbuf 2 0.0250984\nperf_event_mmap-32 2 1.20662\nperf_event_mmap-32-no-syscallbuf 2 1.20416\npriority-32 2 0.188146\npriority-32-no-syscallbuf 2 0.187545\nptrace_remote_unmap-32 2 4.96867\nptrace_remote_unmap-32-no-syscallbuf 2 4.48549\nread_big_struct-32 2 0.895185\nread_big_struct-32-no-syscallbuf 2 0.971367\nremove_latest_trace-32 2 1.19413\nremove_latest_trace-32-no-syscallbuf 2 1.18728\nrestart_abnormal_exit-32 2 1.15147\nrestart_abnormal_exit-32-no-syscallbuf 2 1.11481\nreverse_continue_breakpoint-32 2 1.68965\nreverse_continue_breakpoint-32-no-syscallbuf 2 1.79149\nreverse_continue_multiprocess-32 2 10.6853\nreverse_continue_multiprocess-32-no-syscallbuf 2 10.3271\nreverse_continue_process_signal-32 2 3.62473\nreverse_continue_process_signal-32-no-syscallbuf 2 5.01924\nreverse_many_breakpoints-32 2 4.38134\nreverse_many_breakpoints-32-no-syscallbuf 2 5.46287\nreverse_step_long-32 2 6.24439\nreverse_step_long-32-no-syscallbuf 2 9.08036\nreverse_step_threads-32 2 2.50329\nreverse_step_threads-32-no-syscallbuf 2 2.31751\nreverse_step_threads_break-32 2 5.17554\nreverse_step_threads_break-32-no-syscallbuf 2 5.72419\nrr_ps-32 2 0.436267\nrr_ps-32-no-syscallbuf 2 0.374363\nrr_ps_ns-32 2 0.234007\nrr_ps_ns-32-no-syscallbuf 2 0.240328\nrseq-32 2 67.2539\nrseq-32-no-syscallbuf 2 83.9439\nsearch-32 2 0.864452\nsearch-32-no-syscallbuf 2 0.817897\nseccomp_blocks_rr-32 2 0.445652\nseccomp_blocks_rr-32-no-syscallbuf 2 0.191702\nseccomp_signals-32 2 2.71263\nseccomp_signals-32-no-syscallbuf 2 3.18287\nsegfault-32 2 0.187947\nsegfault-32-no-syscallbuf 2 0.167304\nshared_map-32 2 0.231787\nshared_map-32-no-syscallbuf 2 0.217581\nshared_persistent_file-32 2 0.989357\nshared_persistent_file-32-no-syscallbuf 2 0.914795\nsignal_numbers-32 2 1.06353\nsignal_numbers-32-no-syscallbuf 2 1.02158\nsigprocmask_race-32 2 0.183223\nsigprocmask_race-32-no-syscallbuf 2 0.0195983\nsigprocmask_rr_sigs_nondefault-32 2 0.0950051\nsigprocmask_rr_sigs_nondefault-32-no-syscallbuf 2 0.0818044\nsimple-32 2 0.324804\nsimple-32-no-syscallbuf 2 0.29707\nx86/singlestep_pushf-32 2 0.870134\nx86/singlestep_pushf-32-no-syscallbuf 2 0.75588\nstack_growth-32 2 0.835045\nstack_growth-32-no-syscallbuf 2 0.865223\nstep_thread-32 2 1.00272\nstep_thread-32-no-syscallbuf 2 1.03955\nstrict_priorities-32 2 10.905\nstrict_priorities-32-no-syscallbuf 2 12.5371\nx86/string_instructions-32 2 0.732684\nx86/string_instructions-32-no-syscallbuf 2 0.690063\nx86/string_instructions_async_signals-32 2 0.243053\nx86/string_instructions_async_signals-32-no-syscallbuf 2 70.768027\nx86/string_instructions_async_signals_shared-32 2 0.280141\nx86/string_instructions_async_signals_shared-32-no-syscallbuf 2 91.424003\nx86/string_instructions_multiwatch-32 2 0.885137\nx86/string_instructions_multiwatch-32-no-syscallbuf 2 0.815804\nx86/string_instructions_replay-32 2 13.1396\nx86/string_instructions_replay-32-no-syscallbuf 2 13.083\nx86/string_instructions_singlestep_fastforward-32 2 7.99402\nx86/string_instructions_singlestep_fastforward-32-no-syscallbuf 2 8.02594\nx86/string_instructions_watch-32 2 0.944771\nx86/string_instructions_watch-32-no-syscallbuf 2 0.935292\nsyscallbuf_fd_disabling-32 2 0.305953\nsyscallbuf_fd_disabling-32-no-syscallbuf 2 0.282688\nsyscallbuf_signal_blocking_read-32 2 1.23466\nsyscallbuf_signal_blocking_read-32-no-syscallbuf 2 1.14413\nsysconf_onln-32 2 0.344965\nsysconf_onln-32-no-syscallbuf 2 0.327284\ntarget_fork-32 2 2.71431\ntarget_fork-32-no-syscallbuf 2 1.43742\ntarget_process-32 2 1.32236\ntarget_process-32-no-syscallbuf 2 1.21721\ntcp_sockets-32 2 0.14743\ntcp_sockets-32-no-syscallbuf 2 0.151912\nterm_nonmain-32 2 0.21022\nterm_nonmain-32-no-syscallbuf 2 0.208668\nterm_rr-32 2 3.27718\nterm_rr-32-no-syscallbuf 2 3.26641\nterm_trace_reset-32 2 0.214047\nterm_trace_reset-32-no-syscallbuf 2 0.213101\nterm_trace_syscall-32 2 0.228815\nterm_trace_syscall-32-no-syscallbuf 2 0.24171\nthread_exit_signal-32 2 3.09934\nthread_exit_signal-32-no-syscallbuf 2 2.99841\nthread_open_race-32 2 33.8294\nthread_open_race-32-no-syscallbuf 2 0.0212188\nthread_stress-32 2 13.7434\nthread_stress-32-no-syscallbuf 2 16.5669\nthreaded_syscall_spam-32 2 1.71365\nthreaded_syscall_spam-32-no-syscallbuf 2 0.0223637\nthreads-32 2 1.20922\nthreads-32-no-syscallbuf 2 1.14972\ntls-32 2 0.891054\ntls-32-no-syscallbuf 2 0.863566\nttyname-32 2 0.155298\nttyname-32-no-syscallbuf 2 0.185634\nunexpected_stack_growth-32 2 0.960644\nunexpected_stack_growth-32-no-syscallbuf 2 0.938926\nuser_ignore_sig-32 2 0.169817\nuser_ignore_sig-32-no-syscallbuf 2 0.166966\nvdso_clock_gettime_stack-32 2 0.0198637\nvdso_clock_gettime_stack-32-no-syscallbuf 2 0.0198518\nvdso_gettimeofday_stack-32 2 0.0196665\nvdso_gettimeofday_stack-32-no-syscallbuf 2 0.0200317\nvdso_time_stack-32 2 0.0221022\nvdso_time_stack-32-no-syscallbuf 2 0.0202745\nvfork-32 2 0.236849\nvfork-32-no-syscallbuf 2 0.305823\nvfork_read_clone_stress-32 2 1.58314\nvfork_read_clone_stress-32-no-syscallbuf 2 2.62239\nvsyscall_reverse_next-32 2 211.0415\nvsyscall_reverse_next-32-no-syscallbuf 2 205.237\nwait_for_all-32 2 1.14266\nwait_for_all-32-no-syscallbuf 2 1.14552\nwatchpoint-32 2 1.22955\nwatchpoint-32-no-syscallbuf 2 1.35199\nwatchpoint_at_sched-32 2 1.13428\nwatchpoint_at_sched-32-no-syscallbuf 2 1.25188\nwatchpoint_before_signal-32 2 0.910176\nwatchpoint_before_signal-32-no-syscallbuf 2 0.854977\nwatchpoint_no_progress-32 2 3.67209\nwatchpoint_no_progress-32-no-syscallbuf 2 1.86114\nwatchpoint_size_change-32 2 0.887745\nwatchpoint_size_change-32-no-syscallbuf 2 0.902858\nwatchpoint_syscall-32 2 0.901712\nwatchpoint_syscall-32-no-syscallbuf 2 0.813837\nwatchpoint_unaligned-32 2 0.781136\nwatchpoint_unaligned-32-no-syscallbuf 2 0.800987\nasync_signal_syscalls_100-32 2 0.197139\nasync_signal_syscalls_100-32-no-syscallbuf 2 4.47429\nasync_signal_syscalls_1000-32 2 0.18801\nasync_signal_syscalls_1000-32-no-syscallbuf 2 3.44946\nbad_breakpoint-32 2 7.34282\nbad_breakpoint-32-no-syscallbuf 2 8.09281\nbreak_block-32 2 9.83223\nbreak_block-32-no-syscallbuf 2 9.83806\nbreak_clock-32 2 0.946965\nbreak_clock-32-no-syscallbuf 2 1.12394\nbreak_clone-32 2 0.751169\nbreak_clone-32-no-syscallbuf 2 0.820749\nbreak_exec-32 2 0.84265\nbreak_exec-32-no-syscallbuf 2 0.874733\nbreak_int3-32 2 0.780189\nbreak_int3-32-no-syscallbuf 2 0.759644\nbreak_mmap_private-32 2 1.98541\nbreak_mmap_private-32-no-syscallbuf 2 1.89648\nbreak_msg-32 2 2.89203\nbreak_msg-32-no-syscallbuf 2 3.05882\nx86/break_rdtsc-32 2 0.848203\nx86/break_rdtsc-32-no-syscallbuf 2 0.841489\nbreak_sigreturn-32 2 4.78895\nbreak_sigreturn-32-no-syscallbuf 2 4.88569\nbreak_sync_signal-32 2 0.753919\nbreak_sync_signal-32-no-syscallbuf 2 0.750371\nbreak_thread-32 2 0.912845\nbreak_thread-32-no-syscallbuf 2 1.16875\nbreak_time_slice-32 2 9.33131\nbreak_time_slice-32-no-syscallbuf 2 9.28867\nbreakpoint_consistent-32 2 0.792691\nbreakpoint_consistent-32-no-syscallbuf 2 0.775111\ncall_exit-32 2 0.981659\ncall_exit-32-no-syscallbuf 2 0.993623\ncheck_patched_pthread-32 2 1.86368\ncheck_patched_pthread-32-no-syscallbuf 2 1.84408\ncheckpoint_async_signal_syscalls_1000-32 2 2.25777\ncheckpoint_async_signal_syscalls_1000-32-no-syscallbuf 2 0.0206373\ncheckpoint_mmap_shared-32 2 19.0184\ncheckpoint_mmap_shared-32-no-syscallbuf 2 13.8387\ncheckpoint_prctl_name-32 2 24.3736\ncheckpoint_prctl_name-32-no-syscallbuf 2 23.9934\ncheckpoint_simple-32 2 10.1515\ncheckpoint_simple-32-no-syscallbuf 2 7.59328\nchecksum_sanity_noclone-32 2 1.41863\nchecksum_sanity_noclone-32-no-syscallbuf 2 1.55539\ncomm-32 2 0.617483\ncomm-32-no-syscallbuf 2 0.60854\ncont_signal-32 2 4.82038\ncont_signal-32-no-syscallbuf 2 4.83081\nx86/cpuid-32 2 1.34973\nx86/cpuid-32-no-syscallbuf 2 0.999242\ndead_thread_target-32 2 0.989117\ndead_thread_target-32-no-syscallbuf 2 0.952645\ndesched_ticks-32 2 0.872766\ndesched_ticks-32-no-syscallbuf 2 0.0242881\ndeliver_async_signal_during_syscalls-32 2 0.708833\ndeliver_async_signal_during_syscalls-32-no-syscallbuf 2 0.0201246\nenv_newline-32 2 0.168631\nenv_newline-32-no-syscallbuf 2 0.156516\nexec_deleted-32 2 0.170722\nexec_deleted-32-no-syscallbuf 2 0.168588\nexec_stop-32 2 0.897157\nexec_stop-32-no-syscallbuf 2 0.909516\nexecp-32 2 0.180209\nexecp-32-no-syscallbuf 2 0.161059\nexplicit_checkpoint_clone-32 2 0.995701\nexplicit_checkpoint_clone-32-no-syscallbuf 2 0.952514\nfile_name_newline-32 2 0.187082\nfile_name_newline-32-no-syscallbuf 2 0.159259\nfinal_sigkill-32 2 0.985235\nfinal_sigkill-32-no-syscallbuf 2 0.96928\nfirst_instruction-32 2 0.741433\nfirst_instruction-32-no-syscallbuf 2 0.718259\nfork_exec_info_thr-32 2 3.71603\nfork_exec_info_thr-32-no-syscallbuf 2 3.23103\nget_thread_list-32 2 0.995385\nget_thread_list-32-no-syscallbuf 2 0.946593\nhardlink_mmapped_files-32 2 2.21809\nhardlink_mmapped_files-32-no-syscallbuf 2 2.19885\nhbreak-32 2 0.87166\nhbreak-32-no-syscallbuf 2 0.89237\nmprotect_step-32 2 1.05356\nmprotect_step-32-no-syscallbuf 2 1.12296\nnested_detach-32 2 0.48179\nnested_detach-32-no-syscallbuf 2 0.407968\nnested_detach_kill-32 2 0.620392\nnested_detach_kill-32-no-syscallbuf 2 0.522451\nnested_release-32 2 0.310225\nnested_release-32-no-syscallbuf 2 0.303973\nparent_no_break_child_bkpt-32 2 1.07206\nparent_no_break_child_bkpt-32-no-syscallbuf 2 1.04337\nparent_no_stop_child_crash-32 2 1.06683\nparent_no_stop_child_crash-32-no-syscallbuf 2 0.994023\npost_exec_fpu_regs-32 2 0.58547\npost_exec_fpu_regs-32-no-syscallbuf 2 0.584769\nproc_maps-32 2 0.743487\nproc_maps-32-no-syscallbuf 2 0.81206\nread_bad_mem-32 2 0.741059\nread_bad_mem-32-no-syscallbuf 2 0.746854\nrecord_replay-32 2 142.449\nrecord_replay-32-no-syscallbuf 2 142.207\nremove_watchpoint-32 2 0.887807\nremove_watchpoint-32-no-syscallbuf 2 0.848615\nreplay_overlarge_event_number-32 2 0.151729\nreplay_overlarge_event_number-32-no-syscallbuf 2 0.145948\nreplay_serve_files-32 2 3.53657\nreplay_serve_files-32-no-syscallbuf 2 3.72855\nrestart_invalid_checkpoint-32 2 0.979497\nrestart_invalid_checkpoint-32-no-syscallbuf 2 0.936837\nrestart_unstable-32 2 0.976465\nrestart_unstable-32-no-syscallbuf 2 0.946823\nrestart_diversion-32 2 1.05779\nrestart_diversion-32-no-syscallbuf 2 1.06658\nreverse_alarm-32 2 5.55884\nreverse_alarm-32-no-syscallbuf 2 4.26309\nreverse_continue_exec_subprocess-32 2 3.53948\nreverse_continue_exec_subprocess-32-no-syscallbuf 2 3.5475\nreverse_continue_fork_subprocess-32 2 1.11541\nreverse_continue_fork_subprocess-32-no-syscallbuf 2 1.12745\nreverse_continue_int3-32 2 4.08885\nreverse_continue_int3-32-no-syscallbuf 2 3.79756\nreverse_continue_start-32 2 1.74623\nreverse_continue_start-32-no-syscallbuf 2 1.84734\nreverse_finish-32 2 2.71542\nreverse_finish-32-no-syscallbuf 2 2.34464\nreverse_step_breakpoint-32 2 4.20755\nreverse_step_breakpoint-32-no-syscallbuf 2 4.30403\nreverse_step_signal-32 2 4.36456\nreverse_step_signal-32-no-syscallbuf 2 4.44296\nreverse_step_threads2-32 2 4.43858\nreverse_step_threads2-32-no-syscallbuf 2 4.3075\nreverse_watchpoint-32 2 3.28588\nreverse_watchpoint-32-no-syscallbuf 2 3.61425\nreverse_watchpoint_syscall-32 2 7.9328\nreverse_watchpoint_syscall-32-no-syscallbuf 2 7.61239\nrun_end-32 2 1.0957\nrun_end-32-no-syscallbuf 2 1.08614\nrun_in_function-32 2 0.9406\nrun_in_function-32-no-syscallbuf 2 0.975155\nsanity-32 2 0.730954\nsanity-32-no-syscallbuf 2 0.718052\nseekticks-32 2 1.89101\nseekticks-32-no-syscallbuf 2 1.71722\nshm_checkpoint-32 2 0.979113\nshm_checkpoint-32-no-syscallbuf 2 0.95366\nsiginfo-32 2 0.730536\nsiginfo-32-no-syscallbuf 2 0.768976\nx86/sigreturn_checksum-32 2 0.736871\nx86/sigreturn_checksum-32-no-syscallbuf 2 0.69224\nsignal_stop-32 2 0.766017\nsignal_stop-32-no-syscallbuf 2 0.824693\nsignal_checkpoint-32 2 0.958273\nsignal_checkpoint-32-no-syscallbuf 2 1.01121\nsimple_script-32 2 0.177902\nsimple_script-32-no-syscallbuf 2 0.191716\nsimple_script_debug-32 2 0.888283\nsimple_script_debug-32-no-syscallbuf 2 0.894607\nsimple_winch-32 2 2.32163\nsimple_winch-32-no-syscallbuf 2 2.12602\nstack_overflow_debug-32 2 6.3049\nstack_overflow_debug-32-no-syscallbuf 2 6.60805\nstep1-32 2 0.841349\nstep1-32-no-syscallbuf 2 0.766025\nx86/step_rdtsc-32 2 0.883087\nx86/step_rdtsc-32-no-syscallbuf 2 0.927036\nstep_signal-32 2 0.879484\nstep_signal-32-no-syscallbuf 2 0.916336\nx86/string_instructions_break-32 2 6.07348\nx86/string_instructions_break-32-no-syscallbuf 2 7.3036\nx86/string_instructions_replay_quirk-32 2 6.26888\nx86/string_instructions_replay_quirk-32-no-syscallbuf 2 6.62562\nsubprocess_exit_ends_session-32 2 1.00101\nsubprocess_exit_ends_session-32-no-syscallbuf 2 0.979481\nswitch_processes-32 2 5.00449\nswitch_processes-32-no-syscallbuf 2 3.96395\nsyscallbuf_timeslice_250-32 2 0.2163\nsyscallbuf_timeslice_250-32-no-syscallbuf 2 3.28733\ntrace_version-32 2 2.55284\ntrace_version-32-no-syscallbuf 2 2.55163\nterm_trace_cpu-32 2 0.541342\nterm_trace_cpu-32-no-syscallbuf 2 0.621864\ntrace_events-32 2 0.131738\ntrace_events-32-no-syscallbuf 2 0.127949\ntty-32 2 0.166929\ntty-32-no-syscallbuf 2 0.147314\nunmap_vdso-32 2 0.336841\nunmap_vdso-32-no-syscallbuf 2 0.340823\nunwind_on_signal-32 2 0.803562\nunwind_on_signal-32-no-syscallbuf 2 0.792202\nvfork_exec-32 2 0.942089\nvfork_exec-32-no-syscallbuf 2 0.957233\nvfork_break_parent-32 2 0.884067\nvfork_break_parent-32-no-syscallbuf 2 0.873047\nvsyscall_singlestep-32 2 0.0226703\nvsyscall_singlestep-32-no-syscallbuf 2 0.0210348\nwatch_code-32 2 1.8636\nwatch_code-32-no-syscallbuf 2 1.79997\nwatchpoint_cond-32 2 0.788546\nwatchpoint_cond-32-no-syscallbuf 2 0.766512\nwhen-32 2 0.761362\nwhen-32-no-syscallbuf 2 0.787807\nclose_range 1 0.187604\nclose_range-no-syscallbuf 1 0.169697\ndlchecksum 1 0.240732\ndlchecksum-no-syscallbuf 1 0.206452\nepoll_many 1 0.216123\nepoll_many-no-syscallbuf 1 0.240203\nepoll_pwait2 1 1.30869\nepoll_pwait2-no-syscallbuf 1 1.22883\nfutex_invalid_op 1 0.17379\nfutex_invalid_op-no-syscallbuf 1 0.213894\nfutex_restart_race 1 0.263257\nfutex_restart_race-no-syscallbuf 1 0.22909\nfutex_restart_clone 1 0.205975\nfutex_restart_clone-no-syscallbuf 1 0.196681\nioctl_br 1 0.40846\nioctl_br-no-syscallbuf 1 0.591008\nmremap_dontunmap 1 0.222197\nmremap_dontunmap-no-syscallbuf 1 0.192309\nppoll_deliver 1 0.165071\nppoll_deliver-no-syscallbuf 1 0.158939\nx86/rdtsc_flags 1 0.161648\nx86/rdtsc_flags-no-syscallbuf 1 0.149144\nx86/signal_xmm_state 1 6.5201\nx86/signal_xmm_state-no-syscallbuf 1 6.15106\nsigpwr 1 0.145139\nsigpwr-no-syscallbuf 1 0.161406\nsock_name_null 1 0.173122\nsock_name_null-no-syscallbuf 1 0.134844\nsysconf_conf 1 0.155498\nsysconf_conf-no-syscallbuf 1 0.13819\nchaos_oom 1 0.719051\nchaos_oom-no-syscallbuf 1 0.486065\nx86/diversion_rdtsc 1 0.97806\nx86/diversion_rdtsc-no-syscallbuf 1 1.08858\ngdb_qpasssignals 1 110.1108\ngdb_qpasssignals-no-syscallbuf 1 97.4456\nmadvise_fracture_flags 1 57.982\nmadvise_fracture_flags-no-syscallbuf 1 88.7955\nx86/morestack_unwind 1 1.05934\nx86/morestack_unwind-no-syscallbuf 1 0.033799\nnested_detach_kill_stuck 1 5.52231\nnested_detach_kill_stuck-no-syscallbuf 1 5.47973\nx86/rdtsc_loop 1 7.49252\nx86/rdtsc_loop-no-syscallbuf 1 0.0176659\nx86/rdtsc_loop2 1 3.23895\nx86/rdtsc_loop2-no-syscallbuf 1 0.0587636\nrseq_syscallbuf 1 1.68397\nrseq_syscallbuf-no-syscallbuf 1 0.0232907\nseccomp_open 1 0.256711\nseccomp_open-no-syscallbuf 1 0.224981\nx86/syscallbuf_branch_check 1 0.263251\nx86/syscallbuf_branch_check-no-syscallbuf 1 0.0358348\nx86/syscallbuf_rdtsc_page 1 0.224774\nx86/syscallbuf_rdtsc_page-no-syscallbuf 1 0.0200236\nterm_rr_ok 1 0.239889\nterm_rr_ok-no-syscallbuf 1 0.411474\ncopy_all 1 1.14145\ncopy_all-no-syscallbuf 1 0.99862\ntick0 1 0.810798\ntick0-no-syscallbuf 1 0.781358\ntick0_less 1 0.774784\ntick0_less-no-syscallbuf 1 0.708288\nwatchpoint_unaligned2 1 1.04218\nwatchpoint_unaligned2-no-syscallbuf 1 1.04466\nclose_range-32 1 0.145352\nclose_range-32-no-syscallbuf 1 0.189966\ndlchecksum-32 1 0.25934\ndlchecksum-32-no-syscallbuf 1 0.256462\nepoll_many-32 1 0.152067\nepoll_many-32-no-syscallbuf 1 0.201357\nepoll_pwait2-32 1 1.2001\nepoll_pwait2-32-no-syscallbuf 1 1.14867\nfutex_invalid_op-32 1 0.20886\nfutex_invalid_op-32-no-syscallbuf 1 0.211214\nfutex_restart_race-32 1 0.25145\nfutex_restart_race-32-no-syscallbuf 1 0.209322\nfutex_restart_clone-32 1 0.186733\nfutex_restart_clone-32-no-syscallbuf 1 0.187653\nioctl_br-32 1 0.192089\nioctl_br-32-no-syscallbuf 1 0.168439\nmremap_dontunmap-32 1 0.204069\nmremap_dontunmap-32-no-syscallbuf 1 0.121815\nppoll_deliver-32 1 0.149065\nppoll_deliver-32-no-syscallbuf 1 0.16973\nx86/rdtsc_flags-32 1 0.158374\nx86/rdtsc_flags-32-no-syscallbuf 1 0.161395\nx86/signal_xmm_state-32 1 5.82273\nx86/signal_xmm_state-32-no-syscallbuf 1 5.93857\nsigpwr-32 1 0.135917\nsigpwr-32-no-syscallbuf 1 0.12206\nsock_name_null-32 1 0.216395\nsock_name_null-32-no-syscallbuf 1 0.18803\nsysconf_conf-32 1 0.236007\nsysconf_conf-32-no-syscallbuf 1 0.170377\nchaos_oom-32 1 0.258801\nchaos_oom-32-no-syscallbuf 1 0.218391\nx86/diversion_rdtsc-32 1 1.00397\nx86/diversion_rdtsc-32-no-syscallbuf 1 1.03605\ngdb_qpasssignals-32 1 75.7295\ngdb_qpasssignals-32-no-syscallbuf 1 95.712\nmadvise_fracture_flags-32 1 58.9242\nmadvise_fracture_flags-32-no-syscallbuf 1 86.3502\nx86/morestack_unwind-32 1 1.2353\nx86/morestack_unwind-32-no-syscallbuf 1 0.134301\nnested_detach_kill_stuck-32 1 5.67408\nnested_detach_kill_stuck-32-no-syscallbuf 1 5.53669\nx86/rdtsc_loop-32 1 0.189036\nx86/rdtsc_loop-32-no-syscallbuf 1 0.0190103\nx86/rdtsc_loop2-32 1 0.119683\nx86/rdtsc_loop2-32-no-syscallbuf 1 0.0781239\nrseq_syscallbuf-32 1 1.66755\nrseq_syscallbuf-32-no-syscallbuf 1 0.0220513\nseccomp_open-32 1 0.240722\nseccomp_open-32-no-syscallbuf 1 0.183111\nx86/syscallbuf_branch_check-32 1 0.320975\nx86/syscallbuf_branch_check-32-no-syscallbuf 1 0.0538966\nx86/syscallbuf_rdtsc_page-32 1 0.187748\nx86/syscallbuf_rdtsc_page-32-no-syscallbuf 1 0.0202657\nterm_rr_ok-32 1 0.251002\nterm_rr_ok-32-no-syscallbuf 1 0.222906\ncopy_all-32 1 1.00337\ncopy_all-32-no-syscallbuf 1 0.934465\ntick0-32 1 0.61251\ntick0-32-no-syscallbuf 1 0.634147\ntick0_less-32 1 0.605018\ntick0_less-32-no-syscallbuf 1 0.652338\nwatchpoint_unaligned2-32 1 0.860627\nwatchpoint_unaligned2-32-no-syscallbuf 1 0.854681\n---\n" }, { "path": ".buildkite/Manifest.toml", "content": "# This file is machine-generated - editing it directly is not advised\n\njulia_version = \"1.7.2\"\nmanifest_format = \"2.0\"\n\n[[deps.ArgTools]]\nuuid = \"0dad84c5-d112-42e6-8d28-ef12dabb789f\"\n\n[[deps.Artifacts]]\nuuid = \"56f22d72-fd6d-98f1-02f0-08ddc0907c33\"\n\n[[deps.Base64]]\nuuid = \"2a0f44e3-6c83-55bd-87e4-b1978d98bd5f\"\n\n[[deps.Dates]]\ndeps = [\"Printf\"]\nuuid = \"ade2ca70-3891-5945-98fb-dc099432e06a\"\n\n[[deps.Downloads]]\ndeps = [\"ArgTools\", \"LibCURL\", \"NetworkOptions\"]\nuuid = \"f43a241f-c20a-4ad4-852c-f6b1247861c6\"\n\n[[deps.InteractiveUtils]]\ndeps = [\"Markdown\"]\nuuid = \"b77e0a4c-d291-57a0-90e8-8db25a27a240\"\n\n[[deps.JLLWrappers]]\ndeps = [\"Preferences\"]\ngit-tree-sha1 = \"abc9885a7ca2052a736a600f7fa66209f96506e1\"\nuuid = \"692b3bcd-3c85-4b1f-b108-f13ce0eb3210\"\nversion = \"1.4.1\"\n\n[[deps.LibCURL]]\ndeps = [\"LibCURL_jll\", \"MozillaCACerts_jll\"]\nuuid = \"b27032c2-a3e7-50c8-80cd-2d36dbcbfd21\"\n\n[[deps.LibCURL_jll]]\ndeps = [\"Artifacts\", \"LibSSH2_jll\", \"Libdl\", \"MbedTLS_jll\", \"Zlib_jll\", \"nghttp2_jll\"]\nuuid = \"deac9b47-8bc7-5906-a0fe-35ac56dc84c0\"\n\n[[deps.LibGit2]]\ndeps = [\"Base64\", \"NetworkOptions\", \"Printf\", \"SHA\"]\nuuid = \"76f85450-5226-5b5a-8eaa-529ad045b433\"\n\n[[deps.LibSSH2_jll]]\ndeps = [\"Artifacts\", \"Libdl\", \"MbedTLS_jll\"]\nuuid = \"29816b5a-b9ab-546f-933c-edad1886dfa8\"\n\n[[deps.Libdl]]\nuuid = \"8f399da3-3557-5675-b5ff-fb832c97cbdb\"\n\n[[deps.Libiconv_jll]]\ndeps = [\"Artifacts\", \"JLLWrappers\", \"Libdl\", \"Pkg\"]\ngit-tree-sha1 = \"42b62845d70a619f063a7da093d995ec8e15e778\"\nuuid = \"94ce4f54-9a6c-5748-9c1c-f9c7231a4531\"\nversion = \"1.16.1+1\"\n\n[[deps.Logging]]\nuuid = \"56ddb016-857b-54e1-b83d-db4d58db5568\"\n\n[[deps.Markdown]]\ndeps = [\"Base64\"]\nuuid = \"d6f4376e-aef5-505a-96c1-9c027394607a\"\n\n[[deps.MbedTLS_jll]]\ndeps = [\"Artifacts\", \"Libdl\"]\nuuid = \"c8ffd9c3-330d-5841-b78e-0817d7145fa1\"\n\n[[deps.MozillaCACerts_jll]]\nuuid = \"14a3606d-f60d-562e-9121-12d972cd8159\"\n\n[[deps.NetworkOptions]]\nuuid = \"ca575930-c2e3-43a9-ace4-1e988b2c1908\"\n\n[[deps.Pkg]]\ndeps = [\"Artifacts\", \"Dates\", \"Downloads\", \"LibGit2\", \"Libdl\", \"Logging\", \"Markdown\", \"Printf\", \"REPL\", \"Random\", \"SHA\", \"Serialization\", \"TOML\", \"Tar\", \"UUIDs\", \"p7zip_jll\"]\nuuid = \"44cfe95a-1eb2-52ea-b672-e2afdf69b78f\"\n\n[[deps.Preferences]]\ndeps = [\"TOML\"]\ngit-tree-sha1 = \"47e5f437cc0e7ef2ce8406ce1e7e24d44915f88d\"\nuuid = \"21216c6a-2e73-6563-6e65-726566657250\"\nversion = \"1.3.0\"\n\n[[deps.Printf]]\ndeps = [\"Unicode\"]\nuuid = \"de0858da-6303-5e67-8744-51eddeeeb8d7\"\n\n[[deps.REPL]]\ndeps = [\"InteractiveUtils\", \"Markdown\", \"Sockets\", \"Unicode\"]\nuuid = \"3fa0cd96-eef1-5676-8a61-b3b8758bbffb\"\n\n[[deps.Random]]\ndeps = [\"SHA\", \"Serialization\"]\nuuid = \"9a3f8284-a2c9-5f02-9a11-845980a1fd5c\"\n\n[[deps.SHA]]\nuuid = \"ea8e919c-243c-51af-8825-aaa63cd721ce\"\n\n[[deps.Serialization]]\nuuid = \"9e88b42a-f829-5b0c-bbe9-9e923198166b\"\n\n[[deps.Sockets]]\nuuid = \"6462fe0b-24de-5631-8697-dd941f90decc\"\n\n[[deps.StringEncodings]]\ndeps = [\"Libiconv_jll\"]\ngit-tree-sha1 = \"50ccd5ddb00d19392577902f0079267a72c5ab04\"\nuuid = \"69024149-9ee7-55f6-a4c4-859efe599b68\"\nversion = \"0.3.5\"\n\n[[deps.TOML]]\ndeps = [\"Dates\"]\nuuid = \"fa267f1f-6049-4f14-aa54-33bafae1ed76\"\n\n[[deps.Tar]]\ndeps = [\"ArgTools\", \"SHA\"]\nuuid = \"a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e\"\n\n[[deps.UUIDs]]\ndeps = [\"Random\", \"SHA\"]\nuuid = \"cf7118a7-6976-5b1a-9a39-7adc72f591a4\"\n\n[[deps.Unicode]]\nuuid = \"4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5\"\n\n[[deps.YAML]]\ndeps = [\"Base64\", \"Dates\", \"Printf\", \"StringEncodings\"]\ngit-tree-sha1 = \"3c6e8b9f5cdaaa21340f841653942e1a6b6561e5\"\nuuid = \"ddb6d928-2868-570f-bddf-ab3f9cf99eb6\"\nversion = \"0.4.7\"\n\n[[deps.Zlib_jll]]\ndeps = [\"Libdl\"]\nuuid = \"83775a58-1f1d-513f-b197-d71354ab007a\"\n\n[[deps.nghttp2_jll]]\ndeps = [\"Artifacts\", \"Libdl\"]\nuuid = \"8e850ede-7688-5339-a07c-302acd2aaf8d\"\n\n[[deps.p7zip_jll]]\ndeps = [\"Artifacts\", \"Libdl\"]\nuuid = \"3f19e933-33d8-53b3-aaab-bd5110c3b7a0\"\n" }, { "path": ".buildkite/Project.toml", "content": "[deps]\nYAML = \"ddb6d928-2868-570f-bddf-ab3f9cf99eb6\"\n" }, { "path": ".buildkite/capture_tmpdir.jl", "content": "import Dates\nimport Pkg\nimport Tar\n\nfunction my_exit(process::Base.Process)\n wait(process)\n\n @info(\n \"\",\n process.exitcode,\n process.termsignal,\n )\n\n # Pass the exit code back up\n if process.termsignal != 0\n ccall(:raise, Cvoid, (Cint,), process.termsignal)\n\n # If for some reason the signal did not cause an exit, we'll exit manually.\n # We need to make sure that we exit with a non-zero exit code.\n if process.exitcode != 0\n exit(process.exitcode)\n else\n exit(1)\n end\n end\n exit(process.exitcode)\nend\n\nfunction get_from_env(name::AbstractString)\n value = ENV[name]\n result = convert(String, strip(value))::String\n return result\nend\n\ncleanup_string(str::AbstractString) = replace(str, r\"[^A-Za-z0-9_]\" => \"_\")\n\nif Base.VERSION < v\"1.6\"\n throw(ErrorException(\"The `$(basename(@__FILE__))` script requires Julia 1.6 or greater\"))\nend\n\nif length(ARGS) < 1\n throw(ErrorException(\"Usage: julia $(basename(@__FILE__)) [command...]\"))\nend\n\nconst build_number = get_from_env(\"BUILDKITE_BUILD_NUMBER\") |> cleanup_string\nconst commit_full = get_from_env(\"BUILDKITE_COMMIT\") |> cleanup_string\nconst job_name = get_from_env(\"BUILDKITE_STEP_KEY\") |> cleanup_string\nconst buildkite_timeout_minutes_string = get_from_env(\"BUILDKITE_TIMEOUT\")\n\nconst commit_short = first(commit_full, 10)\nconst buildkite_timeout_minutes = parse(Int, buildkite_timeout_minutes_string)::Int\nconst cleanup_minutes = 15\nconst ctest_timeout_minutes = buildkite_timeout_minutes - cleanup_minutes\nif ctest_timeout_minutes < 1\n msg = \"ctest_timeout_minutes must be strictly positive\"\n @error(\n msg,\n ctest_timeout_minutes,\n buildkite_timeout_minutes,\n cleanup_minutes,\n )\n throw(ErrorException(msg))\nend\n\n@info(\n \"\",\n build_number,\n job_name,\n commit_full,\n commit_short,\n ctest_timeout_minutes,\n buildkite_timeout_minutes,\n cleanup_minutes,\n)\n\nconst my_archives_dir = joinpath(pwd(), \"my_archives_dir\")\nconst my_temp_parent_dir = joinpath(pwd(), \"my_temp_parent_dir\")\n\nmkpath(my_archives_dir)\nmkpath(my_temp_parent_dir)\n\nconst TMPDIR = mktempdir(my_temp_parent_dir)\n\nproc = nothing\n\nmktempdir(my_temp_parent_dir) do dir\n Pkg.activate(dir)\n Pkg.add(\"Zstd_jll\")\n zstd_jll = Base.require(Base.PkgId(Base.UUID(\"3161d3a3-bdf6-5164-811a-617609db77b4\"), \"Zstd_jll\"))\n # zstdmt(func) = Base.invokelatest(zstd_jll.zstdmt, func; adjust_LIBPATH=false)\n zstdmt(func) = Base.invokelatest(zstd_jll.zstdmt, func)\n\n new_env = copy(ENV)\n new_env[\"TMPDIR\"] = TMPDIR\n command = setenv(`$ARGS`, new_env)\n global proc = run(command, (stdin, stdout, stderr); wait = false)\n\n # Start asynchronous timer that will kill `ctest`\n @async begin\n sleep(ctest_timeout_minutes * 60)\n\n # If we've exceeded the timeout and `ctest` is still running, kill it\n if isopen(proc)\n @error(\n string(\n \"Process timed out \",\n \"(with a timeout of $(ctest_timeout_minutes) minutes). \",\n \"Killing with SIGTERM.\",\n\n )\n )\n kill(proc, Base.SIGTERM)\n end\n end\n\n # Wait for `ctest` to finish, either through naturally finishing its run, or `SIGTERM`\n wait(proc)\n\n if proc.termsignal != 0\n @info \"Command signalled $(proc.termsignal)\"\n else\n @info \"Command returned $(proc.exitcode)\"\n end\n date_str = Dates.format(Dates.now(), Dates.dateformat\"yyyy_mm_dd_HH_MM_SS\")\n artifact_specifications = [\n (\"TMPDIR\", TMPDIR),\n ]\n for (artifact_name, artifact_input_dir) in artifact_specifications\n dst_file_name = string(\n artifact_name,\n \"--build_$(build_number)\",\n \"--$(job_name)\",\n \"--commit_$(commit_short)\",\n \"--$(date_str)\",\n \".tar.zst\",\n )\n dst_full_path = joinpath(my_archives_dir, dst_file_name)\n run(`find . -type p`) # list the named pipes before we delete them\n run(`find . -type p -delete`)\n run(`find . -type s`) # list the sockets before we delete them\n run(`find . -type s -delete`)\n zstdmt() do zstdp\n tarproc = open(`$(zstdp) -o $(dst_full_path)`, \"w\")\n Tar.create(artifact_input_dir, tarproc)\n close(tarproc.in)\n end\n\n buildkite_upload_cmd = `buildkite-agent artifact upload $(dst_file_name)`\n if !success(proc)\n run(setenv(buildkite_upload_cmd; dir = my_archives_dir))\n end\n end\nend\n\nmy_exit(proc)\n" }, { "path": ".buildkite/pipeline.yml", "content": "steps:\n - label: \"Launch jobs\"\n plugins:\n - JuliaCI/julia#v1:\n persist_depot_dirs: packages,artifacts,compiled\n version: '1.7'\n timeout_in_minutes: 15\n agents:\n queue: \"juliaecosystem\"\n os: \"linux\"\n commands: |\n echo \"--- Instantiate the environment\"\n julia --project=.buildkite -e 'import Pkg; Pkg.instantiate()'\n\n echo \"--- Precompile the environment\"\n julia --project=.buildkite -e 'import Pkg; Pkg.precompile()'\n\n echo \"--- Generate the Buildkite pipeline YAML files\"\n julia --project=.buildkite .buildkite/lib/generate.jl\n\n echo \"--- Upload the Buildkite pipeline YAML files\"\n julia --project=.buildkite .buildkite/lib/launch.jl\n" }, { "path": ".clang-format", "content": "# BasedOnStyle: Mozilla\nAccessModifierOffset: -2\nConstructorInitializerIndentWidth: 4\nAlignEscapedNewlinesLeft: false\nAlignTrailingComments: true\nAllowAllParametersOfDeclarationOnNextLine: false\nAllowShortIfStatementsOnASingleLine: false\nAllowShortLoopsOnASingleLine: false\nAlwaysBreakTemplateDeclarations: false\nAlwaysBreakBeforeMultilineStrings: false\nBreakBeforeBinaryOperators: false\nBreakBeforeTernaryOperators: true\nBreakConstructorInitializersBeforeComma: false\nBinPackParameters: true\nColumnLimit: 80\nConstructorInitializerAllOnOneLineOrOnePerLine: true\nDerivePointerBinding: false\nExperimentalAutoDetectBinPacking: false\nIndentCaseLabels: true\nMaxEmptyLinesToKeep: 1\nNamespaceIndentation: None\nObjCSpaceBeforeProtocolList: false\nPenaltyBreakBeforeFirstCallParameter: 19\nPenaltyBreakComment: 60\nPenaltyBreakString: 1000\nPenaltyBreakFirstLessLess: 120\nPenaltyExcessCharacter: 1000000\nPenaltyReturnTypeOnItsOwnLine: 200\nPointerBindsToType: true\nSpacesBeforeTrailingComments: 1\nCpp11BracedListStyle: false\nStandard: Cpp11\nIndentWidth: 2\nTabWidth: 8\nUseTab: Never\nBreakBeforeBraces: Attach\nIndentFunctionDeclarationAfterType: false\nSpacesInParentheses: false\nSpacesInAngles: false\nSpaceInEmptyParentheses: false\nSpacesInCStyleCastParentheses: false\nSpaceAfterControlStatementKeyword: true\nSpaceBeforeAssignmentOperators: true\nContinuationIndentWidth: 4\n" }, { "path": ".github/workflows/android-build.yml", "content": "name: Android Build\n\non: [push, pull_request]\n\njobs:\n android-build:\n name: Android Build\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n\n - name: Build Dockerfile\n shell: bash\n run: docker build -t rr-android .android\n\n - name: Create dist dir\n shell: bash\n run: mkdir -p obj/dist\n\n - name: Build RR\n shell: bash\n run: |\n docker run --rm \\\n -v $(pwd):/src/rr \\\n -v $(pwd)/obj/dist:/dist \\\n rr-android\n\n - uses: actions/upload-artifact@v4\n with:\n name: rr\n path: obj/dist/rr-*-Android-x86_64.tar.gz\n" }, { "path": ".github/workflows/build-and-test-main.yml", "content": "name: Build and test\n\non: [push, pull_request]\n\njobs:\n setup:\n name: Setup runners\n runs-on: ubuntu-latest\n if: github.repository == 'rr-debugger/rr'\n steps:\n - id: generate\n name: Generate runner label\n run: |\n RUNNER_LABEL=rr_runner_$(uuidgen|tr -d -)\n echo \"RUNNER_LABEL=$RUNNER_LABEL\" >> \"$GITHUB_OUTPUT\"\n - name: Start runners\n run: |2-\n curl --fail -s -X POST -H \"Content-Type: application/json\" --data \"{\\\"operation\\\": \\\"create\\\", \\\"architectures\\\":[\\\"x86_64\\\", \\\"arm64\\\"], \\\"label\\\": \\\"${{ steps.generate.outputs.RUNNER_LABEL }}\\\"}\" https://bqugdqmvcql6yvz4i362qohyea0namsk.lambda-url.us-east-2.on.aws\n outputs:\n RUNNER_LABEL: ${{ steps.generate.outputs.RUNNER_LABEL }}\n\n x86-64:\n uses: ./.github/workflows/build-and-test.yml\n needs: setup\n if: github.repository == 'rr-debugger/rr'\n with:\n label: ${{ needs.setup.outputs.RUNNER_LABEL }}\n architecture: x86_64\n\n arm64:\n uses: ./.github/workflows/build-and-test.yml\n needs: setup\n if: github.repository == 'rr-debugger/rr'\n with:\n label: ${{ needs.setup.outputs.RUNNER_LABEL }}\n architecture: arm64\n\n stop-runners:\n name: Stop runners\n runs-on: ubuntu-latest\n needs:\n - setup\n - x86-64\n - arm64\n if: ${{ always() && github.repository == 'rr-debugger/rr' }}\n steps:\n - name: \"Stop runners\"\n run: |2-\n curl --fail -s -X POST -H \"Content-Type: application/json\" --data \"{\\\"operation\\\": \\\"destroy\\\", \\\"label\\\": \\\"${{ needs.setup.outputs.RUNNER_LABEL }}\\\"}\" https://bqugdqmvcql6yvz4i362qohyea0namsk.lambda-url.us-east-2.on.aws\n" }, { "path": ".github/workflows/build-and-test.yml", "content": "name: Build and test on runner\n\non:\n workflow_call:\n inputs:\n label:\n required: true\n type: string\n architecture:\n required: true\n type: string\n\njobs:\n build-and-test:\n name: On runner\n runs-on:\n - ${{ inputs.label }}\n - arch_${{ inputs.architecture }}\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n\n - name: Build\n run: ./scripts/github-actions-build.sh\n\n - name: Test\n id: test\n run: ./scripts/github-actions-test.sh\n\n - name: Upload failed-test artifacts\n uses: actions/upload-artifact@v4\n if: failure() && steps.test.outcome == 'failure'\n with:\n name: failed-tests-${{ inputs.architecture }}\n path: failed-tests/*\n compression-level: 0\n" }, { "path": ".gitignore", "content": "*~\n.cache\n.cproject\nCMakeCache.txt\nCMakeFiles/\ncmake_install.cmake\nCPackConfig.cmake\nCPackSourceConfig.cmake\n_CPack_Packages/\nCTestTestfile.cmake\ncompile_commands.json\nDebug\nbin_dir\nsource_dir\ndist/\ninstall_manifest.txt\nMakefile\nProfile\nobj/\n.project\n.vscode/\n*.log\n*.orig\n*.rej\n*.pyc\n*.record\n*.replay\n.settings/\nTesting/\n.idea/\n.*.swp\n*generated\nbuild/\nbin/\nlib/\nshare/\nlibbrotli*\nextra_version_string.h\ngit_revision.h\nthird-party/zen-pmu-workaround/.*\nthird-party/zen-pmu-workaround/*.ko\nthird-party/zen-pmu-workaround/*.o\nthird-party/zen-pmu-workaround/*.mod\nthird-party/zen-pmu-workaround/*.mod.c\nthird-party/zen-pmu-workaround/Module.symvers\nthird-party/zen-pmu-workaround/modules.order\nrr_trace.capnp.*\ntest32.c\nsrc/preload/rr_page.ld\n" }, { "path": "CMakeLists.txt", "content": "# *-* Mode: cmake; *-*\n\ncmake_minimum_required(VERSION 3.12)\nproject(rr C CXX ASM)\n\n# Require c++17 as minimum\nif(NOT DEFINED CMAKE_CXX_STANDARD)\n set(CMAKE_CXX_STANDARD 17)\nendif()\n\n# Configure so that we use -std=c++17 (as previously done) not -std=gnu++17\nif(NOT DEFINED CMAKE_CXX_EXTENSIONS)\n set(CMAKE_CXX_EXTENSIONS OFF)\nendif()\n\nset(CMAKE_CXX_STANDARD_REQUIRED ON)\n\n# Because `CMAKE_CXX_STANDARD_REQUIRED ON` does not enforce this for us.\nif(CMAKE_CXX_STANDARD LESS 17)\n message(FATAL_ERROR \"C++ standard too low: CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}. Minimum required is C++17.\")\nendif()\n\n# \"Do not add flags to export symbols from executables without the ENABLE_EXPORTS target property.\"\n# This avoids linking executables with -rdynamic. -rdynamic has been observed\n# to cause rr_exec_stub to be linked with the dynamic linker with some\n# version(s) of clang (but linked to an incorrect file name, causing\n# exec of rr_exec_stub to fail).\nif(POLICY CMP0065)\n cmake_policy(SET CMP0065 NEW)\nendif()\n\n# We should switch to using FindPython3, but that requires CMake 3.12.\n# We'll switch later.\nif(POLICY CMP0148)\n cmake_policy(SET CMP0148 OLD)\nendif()\n\n# On single configuration generators, make Debug the default configuration\nif(NOT CMAKE_CONFIGURATION_TYPES)\n if(NOT CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE \"Debug\" CACHE STRING \"Whether to build in `Debug` or `Release` mode.\" FORCE)\n endif()\nendif()\n\noption(INSTALL_TESTSUITE \"Install the testsuite\")\noption(force32bit \"Force a 32-bit rr build, rather than both 64 and 32-bit. rr will only be able to record and replay 32-bit processes.\")\noption(disable32bit \"On a 64-bit platform, avoid requiring a 32-bit cross-compilation toolchain by not building 32-bit components. rr will be able to record 32-bit processes but not replay them.\")\noption(staticlibs \"Force usage of static linkage for non-standard libraries like capnproto\")\noption(bpf \"Enable bpf acceleration\")\noption(asan \"Build with address sanitizer enabled.\")\noption(intel_pt_decoding \"Build with Intel PT decoding enabled.\")\noption(strip \"Strip debug info from rr binary\")\n\nenable_testing()\nset(BUILD_SHARED_LIBS ON)\n\nset(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)\nset(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib/rr)\nset(CMAKE_EXPORT_COMPILE_COMMANDS ON)\n\nset(BUILD_TESTS ON CACHE BOOL \"Build tests\")\nset(WILL_RUN_TESTS ${BUILD_TESTS} CACHE BOOL \"Run tests\")\n\n# CAREFUL! \"-\" is an invalid character in RPM package names, while\n# debian is happy with it. However, \"_\" is illegal in debs, while RPM\n# is cool with it. Sigh.\nset(rr_VERSION_MAJOR 5)\nset(rr_VERSION_MINOR 9)\nset(rr_VERSION_PATCH 0)\n\nif(ANDROID)\n find_package(CapnProto REQUIRED)\nendif()\n\nadd_definitions(-DRR_VERSION=\"${rr_VERSION_MAJOR}.${rr_VERSION_MINOR}.${rr_VERSION_PATCH}\")\n\nexecute_process(\n COMMAND git rev-parse HEAD\n WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}\n OUTPUT_VARIABLE GIT_REVISION\n OUTPUT_STRIP_TRAILING_WHITESPACE\n)\nconfigure_file(\n \"${PROJECT_SOURCE_DIR}/src/git_revision.h.in\"\n \"${PROJECT_BINARY_DIR}/git_revision.h\"\n)\nconfigure_file(\n \"${PROJECT_SOURCE_DIR}/src/extra_version_string.h.in\"\n \"${PROJECT_BINARY_DIR}/extra_version_string.h\"\n)\n\nset(FLAGS_COMMON \"-D_FILE_OFFSET_BITS=64 -pthread\")\nset(supports32bit true)\nset(x86ish false)\nset(has_syscallbuf false)\nif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\")\n set(has_syscallbuf true)\n set(supports32bit false)\n set(FLAGS_COMMON \"${FLAGS_COMMON} -march=armv8.3-a -moutline-atomics\")\n set(PRELOAD_LIBRARY_PAGE_SIZE 65536)\n set(VDSO_NAME \"LINUX_2.6.39\")\n set(VDSO_SYMBOLS \"__kernel_clock_getres; __kernel_rt_sigreturn; __kernel_gettimeofday; __kernel_clock_gettime;\")\nelseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES i386|i686|x86|x86_64)\n set(x86ish true)\n set(has_syscallbuf true)\n set(FLAGS_COMMON \"${FLAGS_COMMON} -msse2 -D__MMX__ -D__SSE__ -D__SSE2__\")\n set(PRELOAD_LIBRARY_PAGE_SIZE 4096)\n set(VDSO_NAME \"LINUX_2.6\")\n set(VDSO_SYMBOLS \"gettimeofday; clock_gettime; __vdso_gettimeofday; __vdso_clock_getres; __vdso_time; __vdso_clock_gettime; __vdso_getcpu;\")\nelse()\n message(FATAL_ERROR \"The architecture \" ${CMAKE_SYSTEM_PROCESSOR} \" is not yet supported\")\nendif()\nconfigure_file(src/preload/rr_page.ld.in src/preload/rr_page.ld @ONLY)\n\ninclude(CheckCCompilerFlag)\nCHECK_C_COMPILER_FLAG(\"-fmacro-prefix-map=foo=bar\" SUPPORTS_MACRO_PREFIX_MAP)\nif (SUPPORTS_MACRO_PREFIX_MAP)\n set(FLAGS_COMMON \"${FLAGS_COMMON} -fmacro-prefix-map='${PROJECT_SOURCE_DIR}/'=\")\nendif()\n\nset(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} ${FLAGS_COMMON} -Wstrict-prototypes -std=gnu11\")\n# Define __STDC_LIMIT_MACROS so |#include | works as expected.\n# Define __STDC_FORMAT_MACROS so |#include | works as expected.\nset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${FLAGS_COMMON} -D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS\")\n\n# We support three build types:\n# DEBUG: suitable for debugging rr\n# RELEASE: suitable for using rr in production (but keeps rr debuginfo)\n# OTHER: suitable for using rr in production, but honouring distro/user opt/debug settings\n# (which we assume are suitable for production use)\n\n# Base settings for debug and release/unspecified builds.\n# Use -Werror for debug builds because we assume a developer is building, not a user.\nset(RR_FLAGS_DEBUG \"-Wall -Wextra -DDEBUG -UNDEBUG\")\nset(RR_FLAGS_RELEASE \"-Wall -Wextra -UDEBUG -DNDEBUG\")\n\n# The following settings are the defaults for the OTHER build type.\n# Flags used to build the preload library. MUST have debuginfo enabled. SHOULD be optimized.\n# LTO breaks us by moving code around.\nset(PRELOAD_COMPILE_FLAGS \"${RR_FLAGS_RELEASE} -fno-stack-protector -g3 -U_FORTIFY_SOURCE -fno-lto\")\nset(PRELOAD_LINK_FLAGS \"-nostartfiles -fno-lto\")\n# Flags used to build Brotli. SHOULD be optimized. MUST NOT error on warnings.\nset(BROTLI_COMPILE_FLAGS ${RR_FLAGS_RELEASE})\n# Flags used to build tests. MUST have -DDEBUG and debuginfo enabled, MUST NOT be optimized.\nset(RR_TEST_FLAGS \"${RR_FLAGS_DEBUG} -g3 -O0\")\n# Flags used to build other files. Entirely build-type-dependent.\nset(RR_FLAGS ${RR_FLAGS_RELEASE})\n\n# Now override for build type.\nstring(TOLOWER ${CMAKE_BUILD_TYPE} LOWERCASE_CMAKE_BUILD_TYPE)\nif(LOWERCASE_CMAKE_BUILD_TYPE STREQUAL \"debug\")\n set(PRELOAD_COMPILE_FLAGS \"${PRELOAD_COMPILE_FLAGS} -O2 -Werror\")\n set(BROTLI_COMPILE_FLAGS \"${RR_FLAGS_RELEASE} -O2\")\n set(RR_TEST_FLAGS \"${RR_TEST_FLAGS} -Werror\")\n set(RR_FLAGS \"${RR_FLAGS_DEBUG} -g3 -Werror\")\nelseif(LOWERCASE_CMAKE_BUILD_TYPE STREQUAL \"release\")\n # CMake itself will add optimization flags\n set(RR_FLAGS \"${RR_FLAGS_RELEASE} -g3 -flto\")\nendif()\n\nset(LINKER_FLAGS \"\")\nif(CMAKE_C_COMPILER_ID STREQUAL \"GNU\")\n # Gcc generates bogus R_386_GOTOFF relocations in .debug_info which\n # lld 9 rejects\n set(LINKER_FLAGS \"-fuse-ld=bfd\")\nendif()\n\nif(CMAKE_C_COMPILER_ID STREQUAL \"Clang\")\n set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} -Wno-unused-command-line-argument\")\nendif()\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"Clang\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-unused-command-line-argument\")\nendif()\n# -fno-integrated-as tells Clang to use whatever \"as\" happens to be. For an\n# Android build that will end up being whatever /usr/bin/as is, and whatever it\n# is, it's the wrong assembler for Android, because Android only supports the\n# Clang assembler.\nif (CMAKE_ASM_COMPILER_ID STREQUAL \"Clang\" AND NOT ANDROID)\n set(CMAKE_ASM_FLAGS \"${CMAKE_ASM_FLAGS} -fno-integrated-as\")\nendif()\n\nif(force32bit)\n set(rr_32BIT true)\n set(rr_64BIT false)\n set(rr_MBITNESS_OPTION -m32)\nelse()\n if(CMAKE_SIZEOF_VOID_P EQUAL 8)\n if(disable32bit OR NOT supports32bit)\n set(rr_32BIT false)\n else()\n set(rr_32BIT true)\n endif()\n set(rr_64BIT true)\n else()\n set(rr_32BIT true)\n set(rr_64BIT false)\n endif()\n set(rr_MBITNESS_OPTION)\nendif()\n\n# Check that compiling 32-bit code on a 64-bit target works, if required.\nif(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL \"x86_64\" AND rr_32BIT)\n # try_compile won't accept LINK_FLAGS, so do this manually.\n file(WRITE \"${CMAKE_BINARY_DIR}/test32.c\" \"int main() { return 0; }\")\n execute_process(COMMAND ${CMAKE_C_COMPILER} -o ${CMAKE_BINARY_DIR}/test32 ${CMAKE_BINARY_DIR}/test32.c -m32\n RESULT_VARIABLE COMPILER_32BIT_RESULT)\n if(NOT (COMPILER_32BIT_RESULT EQUAL 0))\n message(FATAL_ERROR \"Your toolchain doesn't support 32-bit cross-compilation. Install the required packages or pass -Ddisable32bit=ON to cmake.\")\n endif()\nendif()\n\nset(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} ${rr_MBITNESS_OPTION}\")\nset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${rr_MBITNESS_OPTION}\")\nset(CMAKE_ASM_FLAGS \"${CMAKE_ASM_FLAGS} ${rr_MBITNESS_OPTION}\")\n\n# If SKIP_PKGCONFIG is set then ${PKG}_CFLAGS and ${PKG}_LDFLAGS must be\n# provided as well.\nif(NOT SKIP_PKGCONFIG)\n find_package(PkgConfig REQUIRED)\n\n # If we're cross-compiling a 32-bit rr build on a 64-bit host we need\n # to ensure we're looking for the right libraries.\n # This has been tested on Ubuntu and Fedora.\n if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL \"x86_64\" AND NOT rr_64BIT)\n set(LIBDIR32_CANDIDATES\n /usr/lib/i386-linux-gnu/pkgconfig/\n /usr/lib/pkgconfig/\n )\n foreach(libdir ${LIBDIR32_CANDIDATES})\n if(IS_DIRECTORY ${libdir})\n set(ENV{PKG_CONFIG_LIBDIR} ${libdir})\n break()\n endif()\n endforeach(libdir)\n if(NOT DEFINED ENV{PKG_CONFIG_LIBDIR})\n message(FATAL_ERROR \"Couldn't find a suitable 32-bit pkgconfig lib dir. You probably need to install a 32-bit pkgconfig package (pkgconfig.i686 for Fedora or pkg-config:i386 for Ubuntu\")\n endif()\n endif()\nendif()\n\nfind_program(CAPNP capnp)\nif(${CAPNP} STREQUAL \"CAPNP-NOTFOUND\")\n message(FATAL_ERROR \"Can't find 'capnp' command; install Capnproto packages? https://github.com/rr-debugger/rr/wiki/Building-And-Installing#tldr\")\nendif()\n\nset(REQUIRED_LIBS\n capnp\n# zlib is required to handle ELF compression\n zlib\n)\n\nif(NOT ANDROID)\n set(REQUIRED_LIBS\n ${REQUIRED_LIBS}\n # zstd is required to handle ELF compression, but isn't available on Android.\n libzstd\n )\n set(ZSTD 1)\n add_definitions(-DZSTD=1)\nendif()\n\nif(bpf)\n add_definitions(-DBPF=1)\n set(REQUIRED_LIBS\n ${REQUIRED_LIBS}\n libbpf\n )\nendif(bpf)\n\nforeach(required_lib ${REQUIRED_LIBS})\n string(TOUPPER ${required_lib} PKG)\n if(NOT SKIP_PKGCONFIG)\n pkg_check_modules(${PKG} REQUIRED ${required_lib})\n endif()\n if(staticlibs)\n string(REPLACE \";\" \" \" ${PKG}_STATIC_CFLAGS \"${${PKG}_STATIC_CFLAGS}\")\n set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} ${${PKG}_STATIC_CFLAGS}\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${${PKG}_STATIC_CFLAGS}\")\n else()\n string(REPLACE \";\" \" \" ${PKG}_CFLAGS \"${${PKG}_CFLAGS}\")\n set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} ${${PKG}_CFLAGS}\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} ${${PKG}_CFLAGS}\")\n endif()\nendforeach(required_lib)\n\n# ==== brotli ====\nset(BROTLI_FILES\n third-party/brotli/common/constants.c\n third-party/brotli/common/context.c\n third-party/brotli/common/dictionary.c\n third-party/brotli/common/platform.c\n third-party/brotli/common/shared_dictionary_internal.h\n third-party/brotli/common/shared_dictionary.c\n third-party/brotli/common/transform.c\n third-party/brotli/dec/bit_reader.c\n third-party/brotli/dec/decode.c\n third-party/brotli/dec/huffman.c\n third-party/brotli/dec/state.c\n third-party/brotli/enc/backward_references.c\n third-party/brotli/enc/backward_references.h\n third-party/brotli/enc/backward_references_hq.c\n third-party/brotli/enc/backward_references_hq.h\n third-party/brotli/enc/backward_references_inc.h\n third-party/brotli/enc/bit_cost.c\n third-party/brotli/enc/bit_cost.h\n third-party/brotli/enc/bit_cost_inc.h\n third-party/brotli/enc/block_encoder_inc.h\n third-party/brotli/enc/block_splitter.c\n third-party/brotli/enc/block_splitter.h\n third-party/brotli/enc/block_splitter_inc.h\n third-party/brotli/enc/brotli_bit_stream.c\n third-party/brotli/enc/brotli_bit_stream.h\n third-party/brotli/enc/command.c\n third-party/brotli/enc/cluster.c\n third-party/brotli/enc/cluster.h\n third-party/brotli/enc/cluster_inc.h\n third-party/brotli/enc/command.h\n third-party/brotli/enc/compress_fragment.c\n third-party/brotli/enc/compress_fragment.h\n third-party/brotli/enc/compound_dictionary.c\n third-party/brotli/enc/compound_dictionary.h\n third-party/brotli/enc/compress_fragment_two_pass.c\n third-party/brotli/enc/compress_fragment_two_pass.h\n third-party/brotli/enc/dictionary_hash.c\n third-party/brotli/enc/dictionary_hash.h\n third-party/brotli/enc/encode.c\n third-party/brotli/enc/encoder_dict.c\n third-party/brotli/enc/entropy_encode.c\n third-party/brotli/enc/entropy_encode.h\n third-party/brotli/enc/entropy_encode_static.h\n third-party/brotli/enc/fast_log.c\n third-party/brotli/enc/fast_log.h\n third-party/brotli/enc/find_match_length.h\n third-party/brotli/enc/hash_forgetful_chain_inc.h\n third-party/brotli/enc/hash.h\n third-party/brotli/enc/hash_longest_match64_inc.h\n third-party/brotli/enc/hash_longest_match_inc.h\n third-party/brotli/enc/hash_longest_match_quickly_inc.h\n third-party/brotli/enc/hash_to_binary_tree_inc.h\n third-party/brotli/enc/histogram.c\n third-party/brotli/enc/histogram.h\n third-party/brotli/enc/histogram_inc.h\n third-party/brotli/enc/literal_cost.c\n third-party/brotli/enc/literal_cost.h\n third-party/brotli/enc/memory.c\n third-party/brotli/enc/memory.h\n third-party/brotli/enc/metablock.c\n third-party/brotli/enc/metablock.h\n third-party/brotli/enc/metablock_inc.h\n third-party/brotli/enc/prefix.h\n third-party/brotli/enc/quality.h\n third-party/brotli/enc/ringbuffer.h\n third-party/brotli/enc/state.h\n third-party/brotli/enc/static_dict.c\n third-party/brotli/enc/static_dict.h\n third-party/brotli/enc/static_dict_lut.h\n third-party/brotli/enc/utf8_util.c\n third-party/brotli/enc/utf8_util.h\n third-party/brotli/enc/write_bits.h\n third-party/brotli/include/brotli/decode.h\n third-party/brotli/include/brotli/encode.h\n third-party/brotli/include/brotli/port.h\n third-party/brotli/include/brotli/shared_dictionary.h\n)\nadd_library(brotli STATIC ${BROTLI_FILES})\nset_source_files_properties(${BROTLI_FILES}\n PROPERTIES COMPILE_FLAGS ${BROTLI_COMPILE_FLAGS})\n# ==== brotli ====\n\nfind_library(LIBRT rt)\n\nset_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS OFF)\nset_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS ON)\nfind_library(LIBRT_32 rt PATHS \"/usr/lib32\" \"/usr/lib\" NO_DEFAULT_PATH)\nset_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS ON)\nset_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS OFF)\n\nfind_path(SECCOMP NAMES \"linux/seccomp.h\")\nif(NOT SECCOMP)\n message(FATAL_ERROR \"Couldn't find linux/seccomp.h. You may need to upgrade your kernel.\")\nendif()\n\nfind_path(PROC_SERVICE_H NAMES \"proc_service.h\")\nif(PROC_SERVICE_H)\n add_definitions(-DPROC_SERVICE_H=1)\nelse()\n message(AUTHOR_WARNING \"proc_service.h not present. Support for libthread_db.so is disabled.\")\nendif()\n\n# Test only includes\nfind_path(MQUEUE_H NAMES \"mqueue.h\")\nif(MQUEUE_H)\n add_definitions(-DMQUEUE_H=1)\nendif()\n\nfind_path(FANOTIFY_H NAMES \"sys/fanotify.h\")\nif(FANOTIFY_H)\n add_definitions(-DFANOTIFY_H=1)\nendif()\n\ninclude(CheckSymbolExists)\nlist(APPEND CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)\ncheck_symbol_exists(LAV_CURRENT \"link.h\" RTLD_AUDIT)\nif(NOT RTLD_AUDIT)\n message(AUTHOR_WARNING \"Couldn't find rtld-audit support. librraudit skipped.\")\nendif()\nlist(REMOVE_ITEM CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)\n\ncheck_symbol_exists(backtrace \"execinfo.h\" EXECINFO_BACKTRACE)\nif(EXECINFO_BACKTRACE)\n add_definitions(-DEXECINFO_BACKTRACE)\nelse()\n message(AUTHOR_WARNING \"backtrace(3) not present in execinfo.h. Automatic backtraces for failures in rr are disabled.\")\nendif()\n\ninclude(CheckTypeSize)\nset(SAVE_CMAKE_EXTRA_INCLUDE_FILES \"${CMAKE_EXTRA_INCLUDE_FILES}\")\nlist(APPEND CMAKE_EXTRA_INCLUDE_FILES \"termios.h\")\ncheck_type_size(\"struct termios2\" SIZEOF_TERMIOS2)\nif(HAVE_SIZEOF_TERMIOS2)\n add_definitions(-DHAVE_TERMIOS2)\nendif()\nset(CMAKE_EXTRA_INCLUDE_FILES \"${SAVE_CMAKE_EXTRA_INCLUDE_FILES}\")\n\n# Test only symbols\ncheck_symbol_exists(pthread_mutexattr_setrobust \"pthread.h\" HAVE_ROBUST_MUTEX)\n\nset(Python_ADDITIONAL_VERSIONS 3 3.8 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0)\nfind_package(PythonInterp 3 REQUIRED)\n\nexecute_process(COMMAND \"${PYTHON_EXECUTABLE}\" \"-c\" \"# nothing\"\n RESULT_VARIABLE python_status)\nif(python_status)\n message(FATAL_ERROR \"Couldn't run python interpreter ${PYTHON_EXECUTABLE}.\")\nendif()\n\n# Check for required Python modules\nif(WILL_RUN_TESTS)\n if(NOT BUILD_TESTS)\n message(FATAL_ERROR \"Running tests requires building them\")\n endif()\n\n set(REQUIRED_PYTHON_MODULES\n pexpect\n )\nelse()\n set(REQUIRED_PYTHON_MODULES)\nendif()\n\nforeach(py_module ${REQUIRED_PYTHON_MODULES})\n execute_process(COMMAND \"${PYTHON_EXECUTABLE}\" \"-c\"\n \"import ${py_module}\"\n RESULT_VARIABLE module_status)\n if(module_status)\n message(FATAL_ERROR \"Couldn't find required Python module ${py_module}.\")\n endif()\nendforeach(py_module)\n\nif(WILL_RUN_TESTS)\n # Check for gdb and lldb\n execute_process(COMMAND \"gdb\" \"--version\" RESULT_VARIABLE module_status OUTPUT_QUIET)\n if(module_status)\n message(FATAL_ERROR \"Couldn't find gdb.\")\n endif()\n execute_process(COMMAND \"lldb\" \"--version\" RESULT_VARIABLE module_status OUTPUT_QUIET)\n if(module_status)\n message(FATAL_ERROR \"Couldn't find lldb.\")\n endif()\nendif()\n\ninclude_directories(\"${PROJECT_SOURCE_DIR}/include\")\ninclude_directories(\"${PROJECT_SOURCE_DIR}/third-party/proc-service\")\ninclude_directories(\"${PROJECT_SOURCE_DIR}/third-party/brotli/include\")\n# We need to know where our generated files are.\ninclude_directories(\"${CMAKE_CURRENT_BINARY_DIR}\")\n\nset(RR_PAGE_FILES\n rr_page.S\n)\nset(RR_PAGE_SOURCE_FILES\n ${RR_PAGE_FILES}\n rr_page_instructions.S\n rr_vdso.S\n)\nadd_library(rrpage)\nforeach(file ${RR_PAGE_FILES})\n target_sources(rrpage PUBLIC \"${PROJECT_SOURCE_DIR}/src/preload/${file}\")\n set_source_files_properties(\"${PROJECT_SOURCE_DIR}/src/preload/${file}\"\n PROPERTIES COMPILE_FLAGS ${PRELOAD_COMPILE_FLAGS})\nendforeach(file)\n\n# Since librrpage replaces the kernel vDSO for processes exec'd by rr,\n# we want it to have the same SONAME as the real vDSO to trick things\n# like AddressSanitizer into recognising it as the vDSO.\nset_target_properties(rrpage PROPERTIES NO_SONAME ON)\nset_target_properties(rrpage PROPERTIES LINK_FLAGS \"-Wl,-T -Wl,'${PROJECT_BINARY_DIR}/src/preload/rr_page.ld' -Wl,--hash-style=both -nostdlib ${PRELOAD_LINK_FLAGS} -Wl,-z,max-page-size=${PRELOAD_LIBRARY_PAGE_SIZE} -Wl,-soname,linux-vdso.so.1 ${LINKER_FLAGS}\")\nset_target_properties(rrpage PROPERTIES LINK_DEPENDS \"${PROJECT_BINARY_DIR}/src/preload/rr_page.ld\")\n# CMake seems to have trouble generating the link line without this\nset_target_properties(rrpage PROPERTIES LINKER_LANGUAGE C)\n\nadd_custom_command(TARGET rrpage POST_BUILD\n COMMAND \"${PROJECT_SOURCE_DIR}/src/preload/tweak_librrpage.py\" $ ${PRELOAD_LIBRARY_PAGE_SIZE})\n\n# Order matters here! syscall_hook.S must be immediately before syscallbuf.c,\n# raw_syscall.S must be before overrides.c, which must be last.\nif(has_syscallbuf)\n set(PRELOAD_FILES\n syscall_hook.S\n syscallbuf.c\n raw_syscall.S\n overrides.c\n )\nelse()\n set(PRELOAD_FILES\n overrides.c\n )\nendif()\nset(PRELOAD_SOURCE_FILES\n ${PRELOAD_FILES}\n preload_interface.h\n rrcalls.h\n syscallbuf.h\n)\nadd_library(rrpreload)\nforeach(file ${PRELOAD_FILES})\n target_sources(rrpreload PUBLIC \"${PROJECT_SOURCE_DIR}/src/preload/${file}\")\n set_source_files_properties(\"${PROJECT_SOURCE_DIR}/src/preload/${file}\"\n PROPERTIES COMPILE_FLAGS ${PRELOAD_COMPILE_FLAGS})\nendforeach(file)\nset_target_properties(rrpreload PROPERTIES LINK_FLAGS \"${PRELOAD_LINK_FLAGS} ${LINKER_FLAGS}\")\nset_target_properties(rrpreload PROPERTIES INSTALL_RPATH \"\\$ORIGIN\")\n\nif(RTLD_AUDIT)\n set(AUDIT_FILES\n rtld-audit.c\n stap-note-iter.c\n ../preload/raw_syscall.S\n )\n set(AUDIT_SOURCE_FILES\n ${AUDIT_FILES}\n rtld-audit.h\n stap-note-iter.h\n ../preload/preload_interface.h\n ../preload/rrcalls.h\n )\n add_library(rraudit)\n foreach(file ${AUDIT_FILES})\n target_sources(rraudit PUBLIC \"${PROJECT_SOURCE_DIR}/src/audit/${file}\")\n set_source_files_properties(\"${PROJECT_SOURCE_DIR}/src/audit/${file}\"\n PROPERTIES COMPILE_FLAGS ${PRELOAD_COMPILE_FLAGS})\n endforeach(file)\n set_target_properties(rraudit PROPERTIES LINK_FLAGS \"${PRELOAD_LINK_FLAGS} -ldl ${LINKER_FLAGS}\")\nendif()\n\n# Ensure that CMake knows about our generated files.\n#\n# Alphabetical, please.\nset(GENERATED_FILES\n AssemblyTemplates.generated\n CheckSyscallNumbers.generated\n SyscallEnumsX64.generated\n SyscallEnumsX86.generated\n SyscallEnumsGeneric.generated\n SyscallEnumsForTestsX64.generated\n SyscallEnumsForTestsX86.generated\n SyscallEnumsForTestsGeneric.generated\n SyscallHelperFunctions.generated\n SyscallnameArch.generated\n SyscallRecordCase.generated\n)\n\nforeach(generated_file ${GENERATED_FILES})\n set_source_files_properties(${generated_file}\n PROPERTIES GENERATED true HEADER_FILE_ONLY true)\n add_custom_command(OUTPUT \"${CMAKE_CURRENT_BINARY_DIR}/${generated_file}\"\n COMMAND \"${CMAKE_CURRENT_SOURCE_DIR}/src/generate_syscalls.py\"\n \"${CMAKE_CURRENT_BINARY_DIR}/${generated_file}\"\n DEPENDS \"${CMAKE_CURRENT_SOURCE_DIR}/src/generate_syscalls.py\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/src/syscalls.py\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/src/assembly_templates.py\")\nendforeach(generated_file)\n\nadd_custom_target(Generated DEPENDS ${GENERATED_FILES})\n\nadd_custom_command(OUTPUT \"${CMAKE_CURRENT_BINARY_DIR}/rr_trace.capnp.c++\"\n \"${CMAKE_CURRENT_BINARY_DIR}/rr_trace.capnp.h\"\n COMMAND capnp compile\n \"--src-prefix=${CMAKE_CURRENT_SOURCE_DIR}/src\"\n \"-oc++:${CMAKE_CURRENT_BINARY_DIR}\"\n \"${CMAKE_CURRENT_SOURCE_DIR}/src/rr_trace.capnp\"\n DEPENDS \"${CMAKE_CURRENT_SOURCE_DIR}/src/rr_trace.capnp\")\nset_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/rr_trace.capnp.c++\"\n PROPERTIES GENERATED true)\nset_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/rr_trace.capnp.h\"\n PROPERTIES GENERATED true HEADER_FILE_ONLY true)\n\nif (${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\")\n set(BLAKE_ARCH_DIR third-party/blake2/neon)\nelse()\n set(BLAKE_ARCH_DIR third-party/blake2/sse)\nendif()\n\nset(RR_SOURCES\n src/AddressSpace.cc\n src/AutoRemoteSyscalls.cc\n src/BuildidCommand.cc\n src/Command.cc\n src/CompressedReader.cc\n src/CompressedWriter.cc\n src/ContextSwitchEvent.cc\n src/CPUFeaturesCommand.cc\n src/CPUIDBugDetector.cc\n src/CPUs.cc\n src/DiversionSession.cc\n src/DumpCommand.cc\n src/Dwarf.cc\n src/ElfReader.cc\n src/EmuFs.cc\n src/Event.cc\n src/ExtraRegisters.cc\n src/fast_forward.cc\n src/FdTable.cc\n src/FileMonitor.cc\n src/FileNameCommand.cc\n src/Flags.cc\n src/ftrace.cc\n src/DebuggerExtensionCommand.cc\n src/DebuggerExtensionCommandHandler.cc\n src/GdbServerConnection.cc\n src/GdbServerExpression.cc\n src/GdbInitCommand.cc\n src/GdbServer.cc\n src/HasTaskSet.cc\n src/HelpCommand.cc\n src/ExportImportCheckpoints.cc\n src/kernel_abi.cc\n src/kernel_metadata.cc\n src/launch_debugger.cc\n src/log.cc\n src/LldbInitCommand.cc\n src/LsCommand.cc\n src/main.cc\n src/MagicSaveDataMonitor.cc\n src/MmappedFileMonitor.cc\n src/MonitoredSharedMemory.cc\n src/Monkeypatcher.cc\n src/MvCommand.cc\n src/PackCommand.cc\n src/PerfCounters.cc\n src/PerfCounterBuffers.cc\n src/PidFdMonitor.cc\n src/processor_trace_check.cc\n src/ProcFdDirMonitor.cc\n src/ProcMemMonitor.cc\n src/ProcStatMonitor.cc\n src/PsCommand.cc\n src/RecordCommand.cc\n src/RecordSession.cc\n src/record_signal.cc\n src/record_syscall.cc\n src/RecordTask.cc\n src/Registers.cc\n src/remote_code_ptr.cc\n src/ReplayCommand.cc\n src/ReplaySession.cc\n src/replay_syscall.cc\n src/ReplayTask.cc\n src/ReplayTimeline.cc\n src/RerunCommand.cc\n src/ReturnAddressList.cc\n src/RmCommand.cc\n src/Scheduler.cc\n src/SeccompFilterRewriter.cc\n src/Session.cc\n src/SourcesCommand.cc\n src/StdioMonitor.cc\n src/SysCpuMonitor.cc\n src/TargetDescription.cc\n src/Task.cc\n src/ThreadGroup.cc\n src/TraceeAttentionSet.cc\n src/TraceField.cc\n src/TraceFrame.cc\n src/TraceInfoCommand.cc\n src/TraceStream.cc\n src/VirtualPerfCounterMonitor.cc\n src/util.cc\n src/WaitManager.cc\n src/WaitStatus.cc\n ${CMAKE_CURRENT_BINARY_DIR}/rr_trace.capnp.c++\n ${BLAKE_ARCH_DIR}/blake2b.c\n)\n\nif(PROC_SERVICE_H)\n set(RR_SOURCES ${RR_SOURCES} src/ThreadDb.cc)\nendif()\n\nif (x86ish)\n set(RR_SOURCES ${RR_SOURCES} src/test/x86/cpuid_loop.S)\nendif()\n\nif (asan)\n set(ASAN_FLAGS \"-fsanitize=address -fno-omit-frame-pointer\")\n # Without no-omit-frame-pointer incomplete backtraces get stored.\n set(RR_FLAGS \"${ASAN_FLAGS} ${RR_FLAGS}\")\nendif()\n\nset_source_files_properties(${RR_SOURCES}\n PROPERTIES COMPILE_FLAGS ${RR_FLAGS})\n\nfunction(post_build_executable target)\n# grsecurity needs these. But if we add them ourselves, they may conflict\n# with other flags added in other ways, and they all have to match :-(. So\n# don't do this until a better solution presents itself\n# add_custom_command(TARGET ${target}\n# POST_BUILD\n# COMMAND setfattr ARGS -n user.pax.flags -v m $)\nendfunction(post_build_executable)\n\nif(UNIX)\n include(GNUInstallDirs)\nelse()\n set(CMAKE_INSTALL_LIBDIR \"lib\")\n set(CMAKE_INSTALL_BINDIR \"bin\")\n set(CMAKE_INSTALL_DATADIR \"share\")\n set(CMAKE_INSTALL_DOCDIR \"${CMAKE_INSTALL_DATADIR}/doc\")\n set(CMAKE_INSTALL_INCLUDEDIR \"include\")\nendif()\n\nif (intel_pt_decoding)\n set(RR_SOURCES ${RR_SOURCES} src/ProcessorTraceDecoder.cc)\n add_definitions(-DINTEL_PT_DECODING=1)\nendif()\n\nadd_executable(rr ${RR_SOURCES})\ntarget_compile_definitions(rr PRIVATE\n \"FULL_LIBDIR=\\\"${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}\\\"\")\nset_target_properties(rr PROPERTIES ENABLE_EXPORTS true)\npost_build_executable(rr)\nset(RR_BIN rr)\nadd_dependencies(rr Generated)\n\nif(bpf)\n add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/share/rr/async_event_filter.o\n DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/src/bpf/async_event_filter.c\n COMMAND clang -g -target bpf -Wall -O2 -c ${CMAKE_CURRENT_SOURCE_DIR}/src/bpf/async_event_filter.c -o ${CMAKE_CURRENT_BINARY_DIR}/share/rr/async_event_filter.o)\n\n install(FILES ${CMAKE_CURRENT_BINARY_DIR}/share/rr/async_event_filter.o\n DESTINATION ${CMAKE_INSTALL_DATADIR}/rr)\n\n add_custom_target(BPF DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/share/rr/async_event_filter.o)\n\n add_dependencies(rr BPF)\nendif()\n\nset(RR_MAIN_LINKER_FLAGS ${LINKER_FLAGS})\nif(strip)\n set(RR_MAIN_LINKER_FLAGS \"-s ${RR_MAIN_LINKER_FLAGS}\")\nendif()\nif (asan)\n set(RR_MAIN_LINKER_FLAGS \" ${ASAN_FLAGS} ${RR_MAIN_LINKER_FLAGS}\")\nendif()\n\n# Add -flto option to linking step if release\nif(LOWERCASE_CMAKE_BUILD_TYPE STREQUAL \"release\")\n CHECK_C_COMPILER_FLAG(\"-flto=auto\" SUPPORTS_LTO_AUTO)\n if(SUPPORTS_LTO_AUTO)\n set(RR_MAIN_LINKER_FLAGS \"${RR_MAIN_LINKER_FLAGS} -flto=auto\")\n else()\n set(RR_MAIN_LINKER_FLAGS \"${RR_MAIN_LINKER_FLAGS} -flto\")\n endif()\nendif()\n\nif(intel_pt_decoding)\n find_library(LIBIPT ipt)\n target_link_libraries(rr ${LIBIPT})\nendif()\n\nif(LIBRT)\n target_link_libraries(rr ${LIBRT})\nendif()\n\ntarget_link_libraries(rr\n ${CMAKE_DL_LIBS}\n ${ZLIB_LDFLAGS}\n ${LIBBPF_LDFLAGS}\n brotli\n)\n\nif(ZSTD)\n target_link_libraries(rr ${LIBZSTD_LDFLAGS})\nendif()\n\nif(staticlibs)\n # Urgh ... this might not work for everyone, but there doesn't seem to be\n # a way to persuade pkg-config/pkg_check_modules to produce the right flags\n target_link_libraries(rr -L/home/roc/lib -l:libcapnp.a -l:libkj.a)\n # Note that this works for both clang++ and g++\n set(RR_MAIN_LINKER_FLAGS \"-static-libstdc++ ${RR_MAIN_LINKER_FLAGS}\")\nelseif(ANDROID)\n target_link_libraries(rr CapnProto::capnp)\nelse()\n target_link_libraries(rr ${CAPNP_LDFLAGS})\nendif()\n\nset_target_properties(rr PROPERTIES LINK_FLAGS \"${RR_MAIN_LINKER_FLAGS}\")\n\ntarget_link_libraries(rrpreload\n ${CMAKE_DL_LIBS}\n)\n\nadd_executable(rr_exec_stub src/exec_stub.c)\npost_build_executable(rr_exec_stub)\nset_target_properties(rr_exec_stub\n PROPERTIES LINK_FLAGS \"-static -nostartfiles -nodefaultlibs ${LINKER_FLAGS}\")\nset_source_files_properties(src/exec_stub.c\n COMPILE_FLAGS \"-fno-stack-protector\")\n\nset(RR_GDB_RESOURCES\n 32bit-avx.xml\n 32bit-avx512.xml\n 32bit-core.xml\n 32bit-linux.xml\n 32bit-sse.xml\n 32bit-pkeys.xml\n 64bit-avx.xml\n 64bit-avx512.xml\n 64bit-core.xml\n 64bit-linux.xml\n 64bit-seg.xml\n 64bit-sse.xml\n 64bit-pkeys.xml\n aarch64-core.xml\n aarch64-fpu.xml\n aarch64-pauth.xml\n)\nforeach(file ${RR_GDB_RESOURCES})\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/third-party/gdb/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/share/rr/${file}\"\n COPYONLY)\n install(FILES third-party/gdb/${file}\n DESTINATION ${CMAKE_INSTALL_DATADIR}/rr)\nendforeach(file)\n\nforeach(file ${PRELOAD_SOURCE_FILES})\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/preload/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/share/rr/src/preload/${file}\"\n COPYONLY)\n install(FILES src/preload/${file}\n DESTINATION ${CMAKE_INSTALL_DATADIR}/rr/src/preload)\nendforeach(file)\n\nforeach(file ${RR_PAGE_SOURCE_FILES})\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/preload/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/share/rr/src/preload/${file}\"\n COPYONLY)\n install(FILES src/preload/${file}\n DESTINATION ${CMAKE_INSTALL_DATADIR}/rr/src/preload)\nendforeach(file)\nconfigure_file(\"${CMAKE_CURRENT_BINARY_DIR}/src/preload/rr_page.ld\"\n \"${CMAKE_CURRENT_BINARY_DIR}/share/rr/src/preload/rr_page.ld\"\n COPYONLY)\ninstall(FILES \"${CMAKE_CURRENT_BINARY_DIR}/src/preload/rr_page.ld\"\n DESTINATION ${CMAKE_INSTALL_DATADIR}/rr/src/preload)\n\nconfigure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/scripts/rr-collect-symbols.py\"\n \"${CMAKE_CURRENT_BINARY_DIR}/bin/rr-collect-symbols.py\"\n COPYONLY)\nconfigure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/scripts/rr-gdb-script-host.py\"\n \"${CMAKE_CURRENT_BINARY_DIR}/bin/rr-gdb-script-host.py\"\n COPYONLY)\n\ninstall(PROGRAMS scripts/signal-rr-recording.sh\n scripts/rr-collect-symbols.py\n DESTINATION ${CMAKE_INSTALL_BINDIR})\n\ninstall(PROGRAMS scripts/rr_completion\n DESTINATION ${CMAKE_INSTALL_DATADIR}/bash-completion/completions RENAME rr)\n\n# Note that this works fine when installing to /usr/local, but zsh by default doesn't autoload *any* completions in HOME,\n# so people will still have to manually set `FPATH=~/.local/share/zsh/site-functions`.\ninstall(PROGRAMS scripts/rr_completion.zsh\n DESTINATION ${CMAKE_INSTALL_DATADIR}/zsh/site-functions RENAME _rr)\n\nset(RR_INSTALL_LIBS rrpreload rrpage rr_exec_stub)\nif(RTLD_AUDIT)\n set(RR_INSTALL_LIBS ${RR_INSTALL_LIBS} rraudit)\nendif()\ninstall(TARGETS ${RR_BIN} ${RR_INSTALL_LIBS}\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr)\n\nif(EXTRA_EXTERNAL_SOLIBS)\n install(PROGRAMS ${EXTRA_EXTERNAL_SOLIBS}\n DESTINATION ${CMAKE_INSTALL_LIBDIR})\nendif()\n\n# Build 32-bit librrpreload and librraudit on 64-bit builds.\n# We copy the source files into '32' subdirectories in the output\n# directory, so we can set different compile options on them.\n# This sucks but I can't find a better way to get CMake to build\n# the same source file in two different ways.\nif(rr_32BIT AND rr_64BIT)\n set(RR_INSTALL_LIBS_32 rrpreload_32 rrpage_32 rr_exec_stub_32)\n add_library(rrpage_32)\n\n foreach(file ${RR_PAGE_SOURCE_FILES})\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/preload/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/preload/${file}\"\n COPYONLY)\n endforeach(file)\n\n foreach(file ${RR_PAGE_FILES})\n target_sources(rrpage_32 PUBLIC \"${CMAKE_CURRENT_BINARY_DIR}/32/preload/${file}\")\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/preload/${file}\"\n PROPERTIES COMPILE_FLAGS \"-m32 ${PRELOAD_COMPILE_FLAGS}\")\n endforeach(file)\n\n set_target_properties(rrpage_32 PROPERTIES NO_SONAME ON)\n set_target_properties(rrpage_32 PROPERTIES LINK_FLAGS \"-m32 -Wl,-T -Wl,'${PROJECT_BINARY_DIR}/src/preload/rr_page.ld' -Wl,--hash-style=both -nostdlib ${PRELOAD_LINK_FLAGS} -Wl,-soname,linux-vdso.so.1 ${LINKER_FLAGS}\")\n set_target_properties(rrpage_32 PROPERTIES LINK_DEPENDS \"${PROJECT_BINARY_DIR}/src/preload/rr_page.ld\")\n set_target_properties(rrpage_32 PROPERTIES LINKER_LANGUAGE C)\n\n add_custom_command(TARGET rrpage_32 POST_BUILD\n COMMAND \"${PROJECT_SOURCE_DIR}/src/preload/tweak_librrpage.py\" $ ${PRELOAD_LIBRARY_PAGE_SIZE})\n\n\n add_library(rrpreload_32)\n\n foreach(file ${PRELOAD_SOURCE_FILES})\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/preload/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/preload/${file}\"\n COPYONLY)\n endforeach(file)\n\n foreach(file ${PRELOAD_FILES})\n target_sources(rrpreload_32 PUBLIC \"${CMAKE_CURRENT_BINARY_DIR}/32/preload/${file}\")\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/preload/${file}\"\n PROPERTIES COMPILE_FLAGS \"-m32 ${PRELOAD_COMPILE_FLAGS}\")\n endforeach(file)\n\n set_target_properties(rrpreload_32 PROPERTIES LINK_FLAGS \"-m32 ${PRELOAD_LINK_FLAGS} ${LINKER_FLAGS}\")\n set_target_properties(rrpreload_32 PROPERTIES INSTALL_RPATH \"\\$ORIGIN\")\n target_link_libraries(rrpreload_32\n ${CMAKE_DL_LIBS}\n )\n\n if(RTLD_AUDIT)\n add_library(rraudit_32)\n\n foreach(file ${AUDIT_SOURCE_FILES})\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/audit/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/audit/${file}\"\n COPYONLY)\n endforeach(file)\n\n foreach(file ${AUDIT_FILES})\n target_sources(rraudit_32 PUBLIC \"${CMAKE_CURRENT_BINARY_DIR}/32/audit/${file}\")\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/audit/${file}\"\n PROPERTIES COMPILE_FLAGS \"-m32 ${PRELOAD_COMPILE_FLAGS}\")\n endforeach(file)\n\n set_target_properties(rraudit_32 PROPERTIES LINK_FLAGS \"-m32 -nostartfiles ${LINKER_FLAGS}\")\n target_link_libraries(rraudit_32\n ${CMAKE_DL_LIBS}\n )\n\n set(RR_INSTALL_LIBS_32 ${RR_INSTALL_LIBS_32} rraudit_32)\n endif()\n\n foreach(file exec_stub.c)\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/${file}\"\n COPYONLY)\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/${file}\"\n PROPERTIES COMPILE_FLAGS \"-m32 -fno-stack-protector\")\n endforeach(file)\n\n add_executable(rr_exec_stub_32 32/exec_stub.c)\n post_build_executable(rr_exec_stub_32)\n set_target_properties(rr_exec_stub_32\n PROPERTIES LINK_FLAGS \"-static -nostartfiles -nodefaultlibs -m32 ${LINKER_FLAGS}\")\n\n install(TARGETS ${RR_INSTALL_LIBS_32}\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr)\nendif()\n\n##--------------------------------------------------\n## Testing\n\n# A \"basic test\" consists of a foo.c source file. All basic tests use the\n# same basic_test.run driver script. The test name is passed as an additional\n# parameter to the driver script. This script just does\n# \"compare_test EXIT-SUCCESS\", i.e. records and replays the program and verifies\n# that the output of both runs is identical and contains EXIT-SUCCESS.\n#\n# NB: you must update this variable when adding a new test source\n# file. The list is not generated automatically.\n#\n# Alphabetical, please.\nset(BASIC_TESTS\n 64bit_child\n _llseek\n abort\n accept\n acct\n adjtimex\n aio\n alarm\n alarm2\n alsa_ioctl\n x86/arch_prctl_x86\n x86/arch_prctl_xstate\n async_segv_ignored\n at_threadexit\n bad_ip\n bad_syscall\n barrier\n big_buffers\n big_select\n block\n block_open\n bpf\n bpf_map\n bpf_prog_map\n bpf_query\n brk\n brk2\n arm/brk_nonzero\n capget\n chew_cpu\n x86/chew_cpu_cpuid\n chmod\n chown\n clock\n clock_adjtime\n clock_nanosleep\n clock_time64\n clone\n clone_bad_stack\n clone_bad_tls\n clone_cleartid_coredump\n clone_fail\n clone_immediate_exit\n clone_newflags\n clone_parent\n clone_untraced\n clone_vfork_pidfd\n cloned_sigmask\n close_range\n constructor\n copy_file_range\n x86/cpuid_same_state\n creat_address_not_truncated\n x86/cross_arch\n cwd_inaccessible\n daemon\n x86/deferred_patch\n desched_blocking_poll\n desched_sigkill\n detach_huge_mmap\n detach_state\n detach_threads\n detach_sigkill\n detach_sigkill_exit\n deterministic_sigsys\n dev_zero\n direct\n dlchecksum\n dup\n doublesegv\n epoll_create\n epoll_create1\n epoll_edge\n epoll_many\n epoll_pwait_eintr_sigmask\n epoll_pwait2\n eventfd\n exec_flags\n exec_no_env\n exec_self\n exec_from_main_thread\n exec_from_other_thread\n exec_stopsig\n execveat\n exit_with_syscallbuf_signal\n fadvise\n fatal_init_signal\n fatal_sigsegv_thread\n x86/fault_in_code_page\n fcntl_dupfd\n fcntl_lease\n fcntl_misc\n fcntl_notify\n fcntl_owner_ex\n fcntl_rw_hints\n fcntl_seals\n fcntl_sig\n fd_cleanup\n fd_tracking_across_threads\n fds_clean\n fexecve\n fexecve_memfd\n flock\n flock_ofd\n flock2\n fork_brk\n fork_child_crash\n fork_many\n fsmount\n fstatat\n futex_exit_race\n futex_exit_race_sigsegv\n futex_invalid_op\n futex_pi\n futex_priorities\n futex_requeue\n futex_restart_race\n futex_restart_clone\n gcrypt_rdrand\n getcpu\n getgroups\n getpwnam\n getrandom\n setitimer\n getsid\n gettimeofday\n grandchild_threads\n grandchild_threads_main_running\n grandchild_threads_thread_running\n grandchild_threads_parent_alive\n group_stop_thundering_herd\n x86/hle\n x86/hlt\n inotify\n int3\n intr_futex_wait_restart\n intr_poll\n intr_ppoll\n intr_pselect\n intr_read_no_restart\n intr_read_restart\n intr_sleep\n intr_sleep_no_restart\n invalid_exec\n invalid_fcntl\n invalid_ioctl\n io\n io_uring\n ioctl\n ioctl_blk\n ioctl_br\n ioctl_fb\n ioctl_fs\n ioctl_pty\n ioctl_sg\n ioctl_tty\n ioctl_ttyS\n ioctl_vt\n ioprio\n x86/ioperm\n x86/iopl\n join_threads\n joystick\n kcmp\n keyctl\n kill_newborn\n kill_ptracee\n landlock\n x86/la57\n large_hole\n large_write_deadlock\n legacy_ugid\n x86/lsl\n madvise\n madvise_dontneed_private\n madvise_free\n madvise_misc\n madvise_remove\n madvise_wipeonfork\n map_fixed\n map_shared_syscall\n membarrier\n memfd_create\n memfd_create_efault\n memfd_create_shared\n memfd_create_shared_huge\n memfd_create_dotnet_huge_mapping\n mincore\n mknod\n mlock\n mlock_madvise\n mmap_adjacent_to_rr_usage\n mmap_huge\n mmap_private\n mmap_private_grow_under_map\n mmap_recycle\n mmap_ro\n mmap_self_maps_shared\n mmap_shared\n mmap_shared_dev_zero\n mmap_shared_grow\n mmap_shared_grow_under_map\n mmap_shared_multiple\n mmap_shared_subpage\n mmap_shared_write\n mmap_shared_write_fork\n mmap_short_file\n mmap_write_complex\n mmap_zero_size_fd\n x86/modify_ldt\n mount_ns_exec\n mount_ns_exec2\n mount_ns_execveat\n mprotect\n mprotect_heterogenous\n mprotect_none\n mprotect_stack\n mremap\n mremap_after_coalesce\n mremap_dontunmap\n mremap_grow\n mremap_grow_shared\n mremap_non_page_size\n mremap_overwrite\n mremap_private_grow_under_map\n mremap_shrink\n msg\n msg_trunc\n msync\n mtio\n multiple_pending_signals\n multiple_pending_signals_sequential\n munmap_segv\n munmap_discontinuous\n nanosleep\n netfilter\n netfilter_ipv6\n netlink_mmap_disable\n no_mask_timeslice\n nscd\n numa\n x86/old_fork\n openat2\n openat_null\n open_tree\n orphan_process\n packet_mmap_disable\n x86/patch_syscall_restart\n pause\n perf_event\n perf_event_ioctl\n perf_event_mmap\n personality\n pid_ns_kill_child\n pid_ns_kill_child_threads\n pid_ns_kill_child_zombie\n pid_ns_kill_threads\n pid_ns_kill_threads_exit_wait\n pid_ns_reap\n pid_ns_segv\n pid_ns_shutdown\n pidfd\n pidfd_getfd\n x86/pkeys\n poll_sig_race\n ppoll\n ppoll_deliver\n prctl\n prctl_anon_vma_name\n prctl_auxv\n prctl_caps\n prctl_deathsig\n prctl_mdwe\n prctl_name\n prctl_short_name\n prctl_speculation_ctrl\n privileged_net_ioctl\n proc_fds\n proc_mem\n protect_rr_fds\n prw\n pthread_condvar_locking\n pthread_mutex_timedlock\n pthread_pi_mutex\n pthread_rwlocks\n x86/ptrace\n ptrace_attach_null_status\n ptrace_attach_running\n ptrace_attach_sleeping\n ptrace_attach_stopped\n ptrace_attach_syscall\n ptrace_attach_thread_running\n ptrace_breakpoint\n ptrace_change_patched_syscall\n x86/ptrace_debug_regs\n ptrace_exec\n x86/ptrace_exec32\n ptrace_group_stop\n ptrace_kill_grandtracee\n x86/ptrace_tls\n ptrace_seize\n ptrace_sigchld\n ptrace_sigchld_blocked\n ptrace_signals\n ptrace_singlestep\n ptrace_syscall\n ptrace_syscall_clone_untraced\n x86/ptrace_sysemu\n ptrace_sysemu_syscall\n ptrace_trace_clone\n ptrace_trace_exit\n ptrace_traceme\n ptrace_traceme_thread\n ptrace_waiter_thread\n ptracer_death\n ptracer_death_multithread\n ptracer_death_multithread_peer\n # pivot_root ... disabled because it fails when run as root and does nothing otherwise\n quotactl\n x86/rdtsc\n x86/rdtsc_flags\n read_nothing\n readdir\n read_large\n read_oversize\n readlink\n readlinkat\n readv\n record_replay_subject\n recvfrom\n redzone_integrity\n rename\n rlimit\n rseq_cpu_id_reset\n rusage\n samask\n save_data_fd\n sched_attr\n sched_setaffinity\n sched_setparam\n sched_yield\n sched_yield_to_lower_priority\n scm_rights\n scratch_read\n seccomp\n seccomp_cloning\n seccomp_clone_fail\n seccomp_desched\n seccomp_kill_exit\n seccomp_madvise\n seccomp_null\n seccomp_sigsys_args\n seccomp_sigsys_sigtrap\n seccomp_sigsys_syscallbuf\n seccomp_tsync\n seccomp_veto_exec\n self_shebang\n self_sigint\n sem\n send_block\n sendfile\n set_ptracer\n x86/set_thread_area\n set_tid_address\n setgid\n setgroups\n setsid\n shared_exec\n shared_monitor\n shared_offset\n shared_write\n shm\n shm_unmap\n sigaction_old\n sigaltstack\n sigchld_interrupt_signal\n sigcont\n sigcont_threaded\n sigframe_grow_stack\n sighandler_bad_rsp_sigsegv\n sighandler_fork\n sighandler_mask\n sigill\n signal_deferred\n signal_during_preload_init\n signal_frame\n signal_unstoppable\n x86/signal_xmm_state\n signalfd\n sigprocmask\n sigprocmask_ensure_delivery\n sigprocmask_exec\n sigprocmask_evil\n sigprocmask_in_syscallbuf_sighandler\n sigprocmask_rr_sigs\n sigprocmask_syscallbuf\n # sigprof\n sigpwr\n sigqueueinfo\n sigtrap_process_group\n x86/sigreturn\n sigreturn_reg\n sigreturnmask\n sigrt\n sigstop\n sigstop2\n sigsuspend\n sigtrap\n simple_threads_stress\n sioc\n small_holes\n sock_name_null\n sock_names_opts\n spinlock_priorities\n splice\n stack_growth_after_syscallbuf\n stack_growth_syscallbuf\n stack_growth_with_guard\n stack_invalid\n stack_overflow\n stack_overflow_altstack\n stack_overflow_with_guard\n statfs\n statx\n stdout_child\n stdout_cloexec\n stdout_dup\n stdout_redirect\n switch_read\n symlink\n sync\n sync_file_range\n syscall_bp\n syscall_in_writable_mem\n syscallbuf_signal_reset\n syscallbuf_signal_blocking\n syscallbuf_sigstop\n syscallbuf_timeslice\n syscallbuf_timeslice2\n sysconf\n sysconf_conf\n sysctl\n sysemu_singlestep\n x86/sysfs\n sysinfo\n syslog\n arm/tagged_addr_ctrl\n tgkill\n thread_yield\n timer\n timerfd\n times\n truncate_temp\n tty_tostop\n tun\n two_signals_with_mask\n ulimit_low\n uname\n unexpected_exit\n unexpected_exit_execve\n unexpected_exit_execve_twice\n unexpected_exit_pid_ns\n unjoined_thread\n unshare\n userfaultfd\n utimes\n v4l_dmabuf\n vdso_parts\n vdso_symbols\n vfork_done\n vfork_flush\n vfork_setopts\n vfork_shared\n video_capture\n vm_readv_writev\n vsyscall\n vsyscall_timeslice\n x86/x87env\n wait\n wait_sigstop\n write_race\n writev\n xattr\n zero_length_read\n)\n\nif(MQUEUE_H)\n set(BASIC_TESTS ${BASIC_TESTS} mq)\nendif()\n\nif(FANOTIFY_H)\n set(BASIC_TESTS ${BASIC_TESTS} fanotify)\nendif()\n\nif(HAVE_ROBUST_MUTEX)\n set(BASIC_TESTS ${BASIC_TESTS} robust_futex)\nendif()\n\nset(BASIC_CPP_TESTS\n std_random\n unwind_rr_page\n)\n\n# A \"test with program\" consists of a foo.c source file and a foo.run driver\n# script. See src/test/util.sh to learn how the .run files work.\n#\n# NB: you must update this variable when adding a new test source\n# file. The list is not generated automatically.\n#\n# Alphabetical, please.\nset(TESTS_WITH_PROGRAM\n abort_nonmain\n alternate_thread_diversion\n arm/arch_timer\n args\n async_kill_with_syscallbuf\n async_kill_with_syscallbuf2\n async_kill_with_threads\n async_kill_with_threads_main_running\n async_kill_with_threads_thread_running\n async_segv\n async_signal_syscalls\n async_signal_syscalls2\n async_signal_syscalls_siginfo\n async_usr1\n blacklist\n block_clone_checkpoint\n block_clone_interrupted\n block_clone_syscallbuf_overflow\n block_intr_sigchld\n blocked_bad_ip\n blocked_sigill\n x86/blocked_sigsegv\n breakpoint\n breakpoint_conditions\n breakpoint_overlap\n call_function\n call_gettid\n chaos_oom\n # Disabled because it's very slow\n # check_session_leaks\n checkpoint_dying_threads\n checkpoint_mixed_mode\n checksum_sanity\n check_lost_interrupts\n clone_file_range\n clone_interruption\n # Disabled because it fails\n # clone_share_vm\n clone_syscallbuf_cleanup_blocked\n clone_syscallbuf_cleanup_cpu\n clone_vfork\n concurrent_signals\n conditional_breakpoint_calls\n conditional_breakpoint_offload\n condvar_stress\n cont_race\n context_switch_after_patch\n x86/cpuid_singlestep\n crash\n crash_in_function\n daemon_read\n dconf_mock\n detach_terminal\n dev_tty\n x86/diversion_rdtsc\n diversion_sigtrap\n diversion_syscall\n dlopen\n early_error\n elapsed_time\n exclusion_region\n exec_failed\n exec_many\n exec_shared_as\n execve_loop\n exit_codes\n exit_group\n exit_race\n exit_status\n x86/explicit_checkpoints\n fd_limit\n fork_stress\n fork_syscalls\n function_calls\n x86/fxregs\n x86/gdb_avx512\n getcwd\n gdb_bogus_breakpoint\n gdb_qpasssignals\n goto_event\n hello\n hooks\n # Disabled because issue #1806 makes tests fail on Debian 8.5 at least\n # history\n ignored_async_usr1\n ignored_sigsegv\n ignore_nested\n immediate_restart\n x86/int3_ok\n interrupt\n intr_ptrace_decline\n invalid_interpreter\n invalid_jump\n jit_proc_mem\n link\n madvise_dontfork\n madvise_fracture_flags\n main_thread_exit\n many_yields\n mmap_fd_reuse_checkpoint\n mmap_replace_most_mappings\n mmap_shared_extern\n mmap_shared_prot\n mmap_shared_write_exec_race\n mmap_tmpfs\n mmap_write\n mmap_write_private\n mprotect_checkpoint\n x86/morestack_unwind\n mprotect_growsdown\n mprotect_syscallbuf_overflow\n mutex_pi_stress\n nested_detach_wait\n nested_detach_kill_stuck\n nested_release_signal\n overflow_branch_counter\n pack\n patch_page_end\n x86/patch_40_80_f6_81\n x86/patch_pc_rel\n prctl_tsc\n priority\n ptrace_remote_unmap\n x86/rdtsc_loop\n x86/rdtsc_loop2\n x86/rdtsc_interfering\n read_big_struct\n remove_latest_trace\n restart_abnormal_exit\n reverse_continue_breakpoint\n reverse_continue_multiprocess\n reverse_continue_process_signal\n reverse_many_breakpoints\n reverse_step_long\n reverse_step_threads\n reverse_step_threads_break\n # Not called ps, because that interferes with using real 'ps' in tests\n rr_ps\n rr_ps_ns\n rseq\n rseq_syscallbuf\n rseq_cpu_id_reset_longrunning\n search\n seccomp_blocks_rr\n seccomp_open\n seccomp_signals\n seekticks_threads\n segfault\n setuid\n shared_map\n shared_persistent_file\n signal_numbers\n sigprocmask_race\n sigprocmask_rr_sigs_nondefault\n simple\n x86/singlestep_pushf\n stack_growth\n step_into_lib\n step_thread\n strict_priorities\n x86/string_instructions\n x86/string_instructions_async_signals\n x86/string_instructions_async_signals_shared\n x86/string_instructions_multiwatch\n x86/string_instructions_replay\n x86/string_instructions_singlestep_fastforward\n x86/string_instructions_watch\n x86/syscallbuf_branch_check\n syscallbuf_fd_disabling\n x86/syscallbuf_rdtsc_page\n syscallbuf_signal_blocking_read\n sysconf_onln\n target_fork\n target_process\n tcp_sockets\n term_nonmain\n term_rr\n term_rr_ok\n term_trace_reset\n term_trace_syscall\n thread_exit_signal\n thread_open_race\n thread_stress\n threaded_syscall_spam\n threads\n tls\n tracee_unmap_vdso\n ttyname\n unexpected_stack_growth\n unicode\n user_ignore_sig\n vdso_clock_gettime_stack\n vdso_gettimeofday_stack\n vdso_time_stack\n vfork\n vfork_read_clone_stress\n vsyscall_reverse_next\n wait_for_all\n watchpoint\n watchpoint_at_sched\n watchpoint_before_signal\n x86/watchpoint_error\n watchpoint_no_progress\n watchpoint_size_change\n watchpoint_syscall\n watchpoint_unaligned\n when_threads\n)\n\n# A \"test without program\" is a foo.run driver script only, which does\n# something with one of the test executables above (or has special rules\n# to build its own executable).\n#\n# NB: you must update this variable when adding a new test source\n# file. The list is not generated automatically.\n#\n# Alphabetical, please.\nset(TESTS_WITHOUT_PROGRAM\n async_signal_syscalls_100\n async_signal_syscalls_1000\n bad_breakpoint\n break_block\n break_clock\n break_clone\n break_exec\n break_int3\n break_mmap_private\n break_msg\n x86/break_rdtsc\n break_sigreturn\n break_sync_signal\n break_thread\n break_time_slice\n breakpoint_consistent\n breakpoint_print\n call_exit\n check_patched_pthread\n checkpoint_async_signal_syscalls_1000\n checkpoint_invalid\n checkpoint_mmap_shared\n checkpoint_prctl_name\n checkpoint_simple\n checksum_block_open\n checksum_sanity_noclone\n comm\n cont_signal\n copy_all\n x86/cpuid\n dead_thread_target\n desched_ticks\n deliver_async_signal_during_syscalls\n env_newline\n exec_deleted\n exec_stop\n execp\n explicit_checkpoint_clone\n fd_leak\n file_name_newline\n final_sigkill\n first_instruction\n fork_exec_info_thr\n get_thread_list\n hardlink_mmapped_files\n hbreak\n large_file\n mprotect_step\n nested_detach\n nested_detach_kill\n nested_detach_stop\n nested_release\n nested_release_exit_code\n pack_dir\n parent_no_break_child_bkpt\n parent_no_stop_child_crash\n personality_chaos\n post_exec_fpu_regs\n proc_maps\n read_bad_mem\n record_replay\n remove_watchpoint\n replay_overlarge_event_number\n replay_serve_files\n restart_invalid_checkpoint\n restart_unstable\n restart_diversion\n reverse_alarm\n reverse_continue_exec_subprocess\n reverse_continue_fork_subprocess\n reverse_continue_int3\n reverse_continue_start\n reverse_finish\n reverse_step_breakpoint\n reverse_step_signal\n reverse_step_threads2\n reverse_watchpoint\n reverse_watchpoint_syscall\n run_end\n run_in_function\n sanity\n seekticks\n shm_checkpoint\n siginfo\n x86/sigreturn_checksum\n signal_stop\n signal_checkpoint\n simple_script\n simple_script_debug\n simple_winch\n stack_overflow_debug\n step1\n x86/step_rdtsc\n step_signal\n x86/string_instructions_break\n x86/string_instructions_replay_quirk\n subprocess_exit_ends_session\n switch_processes\n syscallbuf_timeslice_250\n tick0\n tick0_less\n trace_version\n term_trace_cpu\n trace_events\n traceinfo\n transient_fault_replay_all\n tty\n unmap_vdso\n unwind_on_signal\n vfork_done_clone\n vfork_exec\n vfork_break_parent\n vsyscall_singlestep\n watch_code\n watchpoint_cond\n watchpoint_step\n watchpoint_unaligned2\n when\n)\n\nif(BUILD_TESTS)\n # Part of the installable testsuite (test files).\n if(INSTALL_TESTSUITE)\n install(DIRECTORY ${CMAKE_SOURCE_DIR}/src/test/\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/rr/src/test\n USE_SOURCE_PERMISSIONS)\n endif(INSTALL_TESTSUITE)\n\n # We use symlinks in the tests to access the build and source directories.\n # This is needed because we cannot change the paths used by the tests when\n # the testsuite is installed. We work around this by using symlinks during\n # the normal build, and then installing symlinks with the testsuite that\n # have the same name but, the new link targets.\n execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_SOURCE_DIR} source_dir)\n execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${PROJECT_BINARY_DIR} bin_dir)\n\n if(INSTALL_TESTSUITE)\n # Create the directory for the symlinks first and then create symlinks.\n install(CODE \"execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory\n \\$ENV{DESTDIR}\\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj)\n execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink\n \\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/rr/testsuite/rr\n \\$ENV{DESTDIR}\\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/source_dir)\n execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink\n \\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj\n \\$ENV{DESTDIR}\\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin_dir)\")\n endif(INSTALL_TESTSUITE)\n\n foreach(test ${BASIC_TESTS} ${TESTS_WITH_PROGRAM})\n if (NOT x86ish AND ${test} MATCHES \"^x86/.*\")\n continue()\n endif()\n if (NOT ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\" AND ${test} MATCHES \"^arm/.*\")\n continue()\n endif()\n get_filename_component(testname ${test} NAME)\n\n add_executable(${testname} src/test/${test}.c)\n target_include_directories(${testname} PRIVATE src/preload)\n post_build_executable(${testname})\n set_source_files_properties(src/test/${test}.c\n PROPERTIES COMPILE_FLAGS ${RR_TEST_FLAGS})\n add_dependencies(${testname} Generated)\n if(LIBRT)\n target_link_libraries(${testname} ${LIBRT})\n endif()\n target_link_libraries(${testname} -ldl)\n # Part of the installable testsuite (test programs).\n if(INSTALL_TESTSUITE)\n install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/bin/${testname}\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin)\n endif(INSTALL_TESTSUITE)\n endforeach(test)\n\n add_executable(tick0 src/test/tick0.c)\n post_build_executable(tick0)\n set_target_properties(tick0\n PROPERTIES LINK_FLAGS \"-static -nostdlib -nodefaultlibs\"\n COMPILE_FLAGS \"-static -nostdlib -nodefaultlibs -O3 -g2 -DHAS_TICK0=1\")\n\n add_executable(tick0_less src/test/tick0.c)\n post_build_executable(tick0_less)\n set_target_properties(tick0_less\n PROPERTIES LINK_FLAGS \"-static -nostdlib -nodefaultlibs\"\n COMPILE_FLAGS \"-static -nostdlib -nodefaultlibs -O3 -g2\")\n\n add_executable(watchpoint_unaligned2 src/test/watchpoint_unaligned2.c)\n post_build_executable(watchpoint_unaligned2)\n set_target_properties(watchpoint_unaligned2\n PROPERTIES COMPILE_FLAGS \"${RR_TEST_FLAGS} -g -O3\")\n add_dependencies(watchpoint_unaligned2 Generated)\n\n add_executable(prctl_tsc_supported src/test/prctl_tsc_supported.c)\n post_build_executable(prctl_tsc_supported)\n\n # Test disabled because it requires libuvc to be built and installed, and a\n # working USB camera\n # add_executable(usb src/test/usb.c)\n # post_build_executable(usb)\n # add_dependencies(usb Generated)\n # target_link_libraries(usb ${LIBRT} -L/usr/local/lib -luvc -lusb-1.0)\n\n foreach(test ${BASIC_CPP_TESTS})\n add_executable(${test} src/test/${test}.cc)\n post_build_executable(${test})\n set_source_files_properties(src/test/${test}.cc\n PROPERTIES COMPILE_FLAGS ${RR_TEST_FLAGS})\n add_dependencies(${test} Generated)\n if(LIBRT)\n target_link_libraries(${test} ${LIBRT})\n endif()\n # Part of the installable testsuite (test programs).\n if(INSTALL_TESTSUITE)\n install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/bin/${test}\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin)\n endif(INSTALL_TESTSUITE)\n endforeach(test)\n\n add_library(test_lib\n src/test/test_lib.c\n )\n add_dependencies(test_lib Generated)\n set_source_files_properties(src/test/test_lib.c\n PROPERTIES COMPILE_FLAGS ${RR_TEST_FLAGS})\n if(LIBRT)\n target_link_libraries(constructor ${LIBRT})\n target_link_libraries(step_into_lib ${LIBRT})\n endif()\n target_link_libraries(constructor test_lib)\n target_link_libraries(step_into_lib test_lib)\n\n # cpuid test needs to link with cpuid_loop.S\n if (x86ish)\n add_executable(cpuid src/test/x86/cpuid.c src/test/x86/cpuid_loop.S)\n post_build_executable(cpuid)\n set_source_files_properties(src/test/x86/cpuid.c\n PROPERTIES COMPILE_FLAGS ${RR_TEST_FLAGS})\n add_dependencies(cpuid Generated)\n if(LIBRT)\n target_link_libraries(cpuid ${LIBRT})\n endif()\n endif()\n\n # Add exit_fast test executable\n add_executable(exit_fast src/test/exit_fast.c)\n set_target_properties(exit_fast\n PROPERTIES LINK_FLAGS \"-static -nostartfiles -nodefaultlibs ${LINKER_FLAGS}\")\n post_build_executable(exit_fast)\n add_dependencies(exit_fast Generated)\n set_source_files_properties(src/test/exit_fast.c\n COMPILE_FLAGS \"-fno-stack-protector\")\n\n # Check if we're running on KNL. If so, we allot more time to tests, due to\n # reduced single-core performance.\n execute_process(COMMAND cat /proc/cpuinfo OUTPUT_VARIABLE CPUINFO)\n string(REGEX MATCH \"^.*(Xeon Phi).*$\" CPU_MODEL_PHI ${CPUINFO})\n if(NOT \"${CPU_MODEL_PHI}\" STREQUAL \"\")\n set(TEST_MONITOR_DEFAULT_TIMEOUT 480)\n else()\n set(TEST_MONITOR_DEFAULT_TIMEOUT 120)\n endif()\n\n # The real timeouts are handled by test-monitor\n set(CTEST_TEST_TIMEOUT 1000)\n\n function(configure_test test)\n set_tests_properties(${test} PROPERTIES FAIL_REGULAR_EXPRESSION \"FAILED\" SKIP_RETURN_CODE 77)\n endfunction(configure_test)\n\n if(INSTALL_TESTSUITE)\n install(TARGETS test_lib\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr)\n install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/bin/test-monitor\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin)\n install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/bin/exit_fast\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin)\n if (x86ish)\n install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/bin/cpuid\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin)\n endif(x86ish)\n install(FILES ${CMAKE_CURRENT_BINARY_DIR}/CTestTestfile.cmake\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj)\n endif(INSTALL_TESTSUITE)\n\n foreach(test ${BASIC_TESTS} ${BASIC_CPP_TESTS} ${OTHER_TESTS})\n if (NOT x86ish AND ${test} MATCHES \"^x86/.*\")\n continue()\n endif()\n if (NOT ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\" AND ${test} MATCHES \"^arm/.*\")\n continue()\n endif()\n get_filename_component(testname ${test} NAME)\n add_test(${test}\n bash source_dir/src/test/basic_test.run ${testname} \"\" bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test})\n add_test(${test}-no-syscallbuf\n bash source_dir/src/test/basic_test.run ${testname} -n bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test}-no-syscallbuf)\n endforeach(test)\n\n foreach(test ${TESTS_WITH_PROGRAM} ${TESTS_WITHOUT_PROGRAM})\n if (NOT x86ish AND ${test} MATCHES \"^x86/.*\")\n continue()\n endif()\n if (NOT ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\" AND ${test} MATCHES \"^arm/.*\")\n continue()\n endif()\n get_filename_component(testname ${test} NAME)\n add_test(${test}\n bash source_dir/src/test/${test}.run ${testname} \"\" bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test})\n add_test(${test}-no-syscallbuf\n bash source_dir/src/test/${test}.run ${testname} -n bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test}-no-syscallbuf)\n endforeach(test)\n\n # Run 32-bit tests on 64-bit builds.\n # We copy the test files into '32' subdirectories in the output\n # directory, so we can set different compile options on them.\n # This sucks but I can't find a better way to get CMake to build\n # the same source file in two different ways.\n if(rr_32BIT AND rr_64BIT)\n foreach(header util.h nsutils.h ptrace_util.h util_syscall.h util_internal.h)\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/test/${header}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/${header}\"\n COPYONLY)\n endforeach(header)\n\n foreach(test ${BASIC_TESTS} ${TESTS_WITH_PROGRAM} x86/cpuid test_lib tick0 watchpoint_unaligned2 exit_fast)\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/test/${test}.c\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/${test}.c\"\n COPYONLY)\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/${test}.c\"\n PROPERTIES COMPILE_FLAGS \"-m32 ${RR_TEST_FLAGS}\")\n endforeach(test)\n\n foreach(test ${BASIC_CPP_TESTS})\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/test/${test}.cc\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/${test}.cc\"\n COPYONLY)\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/${test}.cc\"\n PROPERTIES COMPILE_FLAGS \"-m32 ${RR_TEST_FLAGS}\")\n endforeach(test)\n\n foreach(file x86/cpuid_loop.S x86/util.h)\n configure_file(\"${CMAKE_CURRENT_SOURCE_DIR}/src/test/${file}\"\n \"${CMAKE_CURRENT_BINARY_DIR}/32/${file}\"\n COPYONLY)\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/${file}\"\n PROPERTIES COMPILE_FLAGS \"-m32 ${RR_TEST_FLAGS}\")\n endforeach(file)\n\n foreach(test ${BASIC_TESTS} ${BASIC_CPP_TESTS} ${TESTS_WITH_PROGRAM})\n if (NOT ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\" AND ${test} MATCHES \"^arm/.*\")\n continue()\n endif()\n get_filename_component(testname ${test} NAME)\n if(EXISTS \"${CMAKE_CURRENT_BINARY_DIR}/32/${test}.c\")\n add_executable(${testname}_32 \"${CMAKE_CURRENT_BINARY_DIR}/32/${test}.c\")\n else()\n add_executable(${testname}_32 \"${CMAKE_CURRENT_BINARY_DIR}/32/${test}.cc\")\n endif()\n target_include_directories(${testname}_32 PRIVATE src/preload)\n post_build_executable(${testname}_32)\n add_dependencies(${testname}_32 Generated)\n set_target_properties(${testname}_32 PROPERTIES LINK_FLAGS \"-m32 ${RR_TEST_FLAGS} ${LINKER_FLAGS}\")\n if(LIBRT_32)\n target_link_libraries(${testname}_32 ${LIBRT_32})\n endif()\n target_link_libraries(${testname}_32 -ldl)\n # Part of the installable testsuite (test programs).\n if (INSTALL_TESTSUITE)\n install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/bin/${testname}_32\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin)\n endif (INSTALL_TESTSUITE)\n endforeach(test)\n\n add_executable(tick0_32 \"${CMAKE_CURRENT_BINARY_DIR}/32/tick0.c\")\n post_build_executable(tick0_32)\n set_target_properties(tick0_32\n PROPERTIES LINK_FLAGS \"-m32 -static -nostdlib -nodefaultlibs\"\n COMPILE_FLAGS \"-m32 -static -nostdlib -nodefaultlibs -O3 -g2 -DHAS_TICK0=1\")\n\n add_executable(tick0_less_32 \"${CMAKE_CURRENT_BINARY_DIR}/32/tick0.c\")\n post_build_executable(tick0_less_32)\n set_target_properties(tick0_less_32\n PROPERTIES LINK_FLAGS \"-m32 -static -nostdlib -nodefaultlibs\"\n COMPILE_FLAGS \"-m32 -static -nostdlib -nodefaultlibs -O3 -g2\")\n\n # Add exit_fast test executable\n add_executable(exit_fast_32 \"${CMAKE_CURRENT_BINARY_DIR}/32/exit_fast.c\")\n set_target_properties(exit_fast_32\n PROPERTIES LINK_FLAGS \"-static -nostartfiles -nodefaultlibs ${LINKER_FLAGS}\")\n add_dependencies(exit_fast_32 Generated)\n post_build_executable(exit_fast_32)\n set_source_files_properties(\"${CMAKE_CURRENT_BINARY_DIR}/32/exit_fast.c\" COMPILE_FLAGS \"-fno-stack-protector\")\n\n add_executable(watchpoint_unaligned2_32 \"${CMAKE_CURRENT_BINARY_DIR}/32/watchpoint_unaligned2.c\")\n post_build_executable(watchpoint_unaligned2_32)\n set_target_properties(watchpoint_unaligned2_32\n PROPERTIES LINK_FLAGS \"-m32\"\n COMPILE_FLAGS \"-m32 ${RR_TEST_FLAGS} -g -O3\")\n add_dependencies(watchpoint_unaligned2_32 Generated)\n\n add_library(test_lib_32\n \"${CMAKE_CURRENT_BINARY_DIR}/32/test_lib.c\"\n )\n add_dependencies(test_lib_32 Generated)\n set_target_properties(test_lib_32 PROPERTIES LINK_FLAGS \"-m32 ${LINKER_FLAGS}\")\n\n if(LIBRT_32)\n target_link_libraries(constructor_32 ${LIBRT_32})\n target_link_libraries(step_into_lib_32 ${LIBRT_32})\n endif()\n target_link_libraries(constructor_32 test_lib_32)\n target_link_libraries(step_into_lib_32 test_lib_32)\n\n # cpuid test needs to link with cpuid_loop.S\n add_executable(cpuid_32 32/x86/cpuid.c 32/x86/cpuid_loop.S)\n post_build_executable(cpuid_32)\n add_dependencies(cpuid_32 Generated)\n set_target_properties(cpuid_32 PROPERTIES LINK_FLAGS \"-m32 ${LINKER_FLAGS}\")\n if(LIBRT_32)\n target_link_libraries(cpuid_32 ${LIBRT_32})\n endif()\n\n if(INSTALL_TESTSUITE)\n install(TARGETS test_lib_32\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr)\n install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/bin/cpuid_32\n DESTINATION ${CMAKE_INSTALL_LIBDIR}/rr/testsuite/obj/bin)\n endif(INSTALL_TESTSUITE)\n\n foreach(test ${BASIC_TESTS} ${BASIC_CPP_TESTS} ${OTHER_TESTS})\n if (NOT ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\" AND ${test} MATCHES \"^arm/.*\")\n continue()\n endif()\n get_filename_component(testname ${test} NAME)\n add_test(${test}-32\n bash source_dir/src/test/basic_test.run ${testname}_32 \"\" bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test}-32)\n add_test(${test}-32-no-syscallbuf\n bash source_dir/src/test/basic_test.run ${testname}_32 -n bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test}-32-no-syscallbuf)\n endforeach(test)\n\n foreach(test ${TESTS_WITH_PROGRAM} ${TESTS_WITHOUT_PROGRAM})\n if (NOT ${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"aarch64\" AND ${test} MATCHES \"^arm/.*\")\n continue()\n endif()\n get_filename_component(testname ${test} NAME)\n add_test(${test}-32\n bash source_dir/src/test/${test}.run ${testname}_32 \"\" bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test}-32)\n add_test(${test}-32-no-syscallbuf\n bash source_dir/src/test/${test}.run ${testname}_32 -n bin_dir ${TEST_MONITOR_DEFAULT_TIMEOUT})\n configure_test(${test}-32-no-syscallbuf)\n endforeach(test)\n endif()\n\n set(CHAOS_TESTS\n core_count\n futex_wakeup\n getaffinity_core_count\n pipe_wakeup\n mmap_adjacent\n mmap_bits\n startup\n starvation_multithreaded\n starvation_singlethreaded\n )\n\n foreach(test ${CHAOS_TESTS})\n add_executable(${test} src/chaos-test/${test}.c)\n post_build_executable(${test})\n if(LIBRT)\n target_link_libraries(${test} ${LIBRT})\n endif()\n endforeach(test)\n\n add_executable(test-monitor src/test-monitor/test-monitor.cc)\n\n add_executable(ftrace_helper src/ftrace/ftrace_helper.c)\n add_executable(counters src/counters-test/counters.cc)\n set_source_files_properties(src/counters-test/counters.cc\n PROPERTIES COMPILE_FLAGS \"-fno-stack-protector\")\nendif()\n\ninclude(ProcessorCount)\nProcessorCount(N)\nif(NOT N EQUAL 0)\n set(JFLAG -j${N})\nendif()\n\nadd_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --verbose ${JFLAG} USES_TERMINAL)\n# Run only syscallbuf-enabled and native-bitness tests\nadd_custom_target(fastcheck COMMAND ${CMAKE_CTEST_COMMAND} --verbose --exclude-regex '[-]' ${JFLAG} USES_TERMINAL)\n\n##--------------------------------------------------\n## Package configuration\n\ninclude (InstallRequiredSystemLibraries)\n\nset(CPACK_PACKAGE_NAME \"rr\")\nset(CPACK_PACKAGE_VERSION_MAJOR \"${rr_VERSION_MAJOR}\")\nset(CPACK_PACKAGE_VERSION_MINOR \"${rr_VERSION_MINOR}\")\nset(CPACK_PACKAGE_VERSION_PATCH \"${rr_VERSION_PATCH}\")\nset(CPACK_SYSTEM_NAME \"${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}\")\n\nset(CPACK_OUTPUT_FILE_PREFIX dist)\nset(CPACK_GENERATOR \"TGZ;RPM;DEB\" CACHE STRING \"CPack generators\")\nset(CPACK_SOURCE_GENERATOR \"TGZ\")\nset(CPACK_BINARY_DIR \"${PROJECT_BINARY_DIR}\")\n# Don't strip binaries. It's important/useful for librrpreload at least to\n# have debug symbols. For package releases, pass -Dstrip=TRUE to strip symbols\n# from the rr binary at build time.\nset(CPACK_STRIP_FILES FALSE)\n\nset(CPACK_RESOURCE_FILE_LICENSE \"${CMAKE_SOURCE_DIR}/LICENSE\")\nset(CPACK_PACKAGE_DESCRIPTION_SUMMARY\n \"Lightweight tool for recording and replaying execution of applications (trees of processes and threads)\")\nset(CPACK_PACKAGE_DESCRIPTION_FILE \"${CMAKE_SOURCE_DIR}/README.md\")\nset(CPACK_PACKAGE_VENDOR \"rr-debugger\")\n\nset(CPACK_DEBIAN_PACKAGE_MAINTAINER \"rr-debugger\")\nset(CPACK_DEBIAN_PACKAGE_SECTION \"devel\")\nif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL \"x86_64\")\n set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE \"amd64\")\nelseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES \"i.86\")\n set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE \"i386\")\nelseif(${CMAKE_SYSTEM_PROCESSOR} MATCHES \"arm.*\")\n set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE \"arm\")\nendif()\n\n# XXX Cmake 2.8.7 doesn't know how to avoid specifying /usr,\n# /usr/bin, etc, as files to be installed, but distros are finicky\n# about their specification. We want to manually filter those paths\n# out of our install list but 2.8.7 also isn't capable of that.\nset(CPACK_RPM_USER_BINARY_SPECFILE \"${CMAKE_SOURCE_DIR}/rr.spec\")\nset(CPACK_RPM_PACKAGE_RELEASE 1)\nset(CPACK_RPM_PACKAGE_GROUP \"Development/Debuggers\")\nset(CPACK_RPM_PACKAGE_LICENSE \"MIT and BSD\")\n# Prevent binaries from being stripped\nset(CPACK_RPM_SPEC_INSTALL_POST \"/bin/true\")\n\ninclude (CPack)\n" }, { "path": "CODE_OF_CONDUCT.md", "content": "# Community Participation Guidelines\n\nThis repository is governed by Mozilla's code of conduct and etiquette guidelines. \nFor more details, please read the\n[Mozilla Community Participation Guidelines](https://www.mozilla.org/about/governance/policies/participation/). \n\n## How to Report\nFor more information on how to report violations of the Community Participation Guidelines, please read our '[How to Report](https://www.mozilla.org/about/governance/policies/participation/reporting/)' page.\n\n\n" }, { "path": "CONTRIBUTING.md", "content": "## Submission Checklist\n\nPlease make sure you go through this list before submitting a patch. The rules aren't hard and fast, but mostly adhering to them will make for quicker mergings.\n\n- [ ] Does your PR add support for a new kernel API? For example, supporting a new syscall. If so, your patch should include at least one new test for the API. This is usually pretty easy. See `$rr/src/test` for examples.\n\n- [ ] Did you run the rr test suite (including your new tests, if any), and pass all the tests? `make -C $objdir check`. Unfortunately, rr doesn't have automated infrastructure that can run the tests yet, so developers have to run them locally.\n\n- [ ] If you created new files for your PR, did you `git add` them? Habitually (or with a script or push hook) checking `git status` is a good habit to acquire.\n\n- [ ] If you changed the trace layout or format, did you bump `TRACE_VERSION`?\n\n- [ ] If you added new command-line parameters, did you update `print_usage()` to document them?\n\n- [ ] Does your PR apply cleanly on top of upstream/master HEAD? It's dangerous to have someone else sort out your merge conflicts, so just don't do it. Best of all is to have a PR *rebased* on top of upstream/master HEAD, so that the merge is simply a fast-forward.\n\n- [ ] If your PR includes multiple changesets, do they all (i) build cleanly in sequence; (ii) pass all tests in sequence? This is important for bisecting over commit history.\n\n- [ ] If your PR is a very large-scale change (for example, a rewrite in Rust to use the visitor pattern), did you discuss the proposed changes in an issue or the mailing list? It's hard to review large patches that just fall in ones lap. It's much easier to discuss the important changes at a high level and then approach the patch knowing what's important and what's not.\n\n- [ ] If your PR is large or includes many changesets, would it have been possible to break the changes into a series of smaller PRs? For example, it's hard to review a big patch that, say, fixes whitespace errors in a file along with a one-line, important, bug fix. It's much easier to review one PR that fixes whitespace (which can just be skimmed), and then review another PR that makes the one-line bug fix (which would be scrutinized more). This approach is also better for the patch author in that it usually allows the work to land faster, and reduces the burden of continually un-bit-rotting large, trivial, changes.\n\n- [ ] Did you check your code is formatted correctly? It's easiest to run `scripts/reformat.sh` on each commit.\n\n## Coding Guidelines\n\nrr uses assertions heavily, for code documentation, for automated checking that the code matches the documentation, and to improve the power of automated tests. Assertions are turned on in release builds. Whenever you depend on an invariant not immediately obvious, consider adding assertions to check it.\n\nrr ships with debugging enabled and compiler optimizations disabled for the rr process itself. That's because rr performance almost always depends on algorithmic issues --- minimizing the number of system calls, and especially, minimizing the number of context switches between the tracees and the rr process --- much more than the performance of the code running in the rr process. For the same reason, rr-process code should be as simple as possible even if that's less efficient. To some extent, once we're running code in the rr process, we've already lost performance-wise. OTOH we do enable optimizations in `preload.c` because that runs in tracees.\n\n## Coding Style\n\nPut braces around all statement blocks, even one-line `if` bodies etc.\n\nAll C++ declarations are in the `rr` namespace.\n\nAll C++ types are in CamelCase; all C types are underscore_names.\n" }, { "path": "LICENSE", "content": "Copyright (c) 2013 Mozilla Foundation\nCopyright 2015 VMware, Inc\nCopyright 2015 Google Inc.\n\nContributors: Albert Noll , Thomas Anderegg , Nimrod Partush \n Andrew Walton \n\nPermission is hereby granted, free of charge, to any person obtaining a\ncopy of this software and associated documentation files (the \"Software\"),\nto deal in the Software without restriction, including without limitation\nthe rights to use, copy, modify, merge, publish, distribute, sublicense,\nand/or sell copies of the Software, and to permit persons to whom the\nSoftware is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\nTHE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\nFROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n\n/*\n * Copyright 2002 Niels Provos \n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n * 1. Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\n * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\n * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\n * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\n * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\n====================================================================================\n\nThe following applies only to files under third-party/gdb:\n\n\n\n====================================================================================\n\nThe following applies only to files under third-party/zen-pmu-workaround:\n\n\t\t GNU GENERAL PUBLIC LICENSE\n\t\t Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n\t\t\t Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicense is intended to guarantee your freedom to share and change free\nsoftware--to make sure the software is free for all its users. This\nGeneral Public License applies to most of the Free Software\nFoundation's software and to any other program whose authors commit to\nusing it. (Some other Free Software Foundation software is covered by\nthe GNU Library General Public License instead.) You can apply it to\nyour programs, too.\n\n When we speak of free software, we are referring to freedom, not\nprice. Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthis service if you wish), that you receive source code or can get it\nif you want it, that you can change the software or use pieces of it\nin new free programs; and that you know you can do these things.\n\n To protect your rights, we need to make restrictions that forbid\nanyone to deny you these rights or to ask you to surrender the rights.\nThese restrictions translate qto certain responsibilities for you if you\ndistribute copies of the software, or if you modify it.\n\n For example, if you distribute copies of such a program, whether\ngratis or for a fee, you must give the recipients all the rights that\nyou have. You must make sure that they, too, receive or can get the\nsource code. And you must show them these terms so they know their\nrights.\n\n We protect your rights with two steps: (1) copyright the software, and\n(2) offer you this license which gives you legal permission to copy,\ndistribute and/or modify the software.\n\n Also, for each author's protection and ours, we want to make certain\nthat everyone understands that there is no warranty for this free\nsoftware. If the software is modified by someone else and passed on, we\nwant its recipients to know that what they have is not the original, so\nthat any problems introduced by others will not reflect on the original\nauthors' reputations.\n\n Finally, any free program is threatened constantly by software\npatents. We wish to avoid the danger that redistributors of a free\nprogram will individually obtain patent licenses, in effect making the\nprogram proprietary. To prevent this, we have made it clear that any\npatent must be licensed for everyone's free use or not licensed at all.\n\n The precise terms and conditions for copying, distribution and\nmodification follow.\n\f\n\t\t GNU GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License applies to any program or other work which contains\na notice placed by the copyright holder saying it may be distributed\nunder the terms of this General Public License. The \"Program\", below,\nrefers to any such program or work, and a \"work based on the Program\"\nmeans either the Program or any derivative work under copyright law:\nthat is to say, a work containing the Program or a portion of it,\neither verbatim or with modifications and/or translated into another\nlanguage. (Hereinafter, translation is included without limitation in\nthe term \"modification\".) Each licensee is addressed as \"you\".\n\nActivities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning the Program is not restricted, and the output from the Program\nis covered only if its contents constitute a work based on the\nProgram (independent of having been made by running the Program).\nWhether that is true depends on what the Program does.\n\n 1. You may copy and distribute verbatim copies of the Program's\nsource code as you receive it, in any medium, provided that you\nconspicuously and appropriately publish on each copy an appropriate\ncopyright notice and disclaimer of warranty; keep intact all the\nnotices that refer to this License and to the absence of any warranty;\nand give any other recipients of the Program a copy of this License\nalong with the Program.\n\nYou may charge a fee for the physical act of transferring a copy, and\nyou may at your option offer warranty protection in exchange for a fee.\n\n 2. You may modify your copy or copies of the Program or any portion\nof it, thus forming a work based on the Program, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) You must cause the modified files to carry prominent notices\n stating that you changed the files and the date of any change.\n\n b) You must cause any work that you distribute or publish, that in\n whole or in part contains or is derived from the Program or any\n part thereof, to be licensed as a whole at no charge to all third\n parties under the terms of this License.\n\n c) If the modified program normally reads commands interactively\n when run, you must cause it, when started running for such\n interactive use in the most ordinary way, to print or display an\n announcement including an appropriate copyright notice and a\n notice that there is no warranty (or else, saying that you provide\n a warranty) and that users may redistribute the program under\n these conditions, and telling the user how to view a copy of this\n License. (Exception: if the Program itself is interactive but\n does not normally print such an announcement, your work based on\n the Program is not required to print an announcement.)\n\f\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Program,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Program, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote it.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Program.\n\nIn addition, mere aggregation of another work not based on the Program\nwith the Program (or with a work based on the Program) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may copy and distribute the Program (or a work based on it,\nunder Section 2) in object code or executable form under the terms of\nSections 1 and 2 above provided that you also do one of the following:\n\n a) Accompany it with the complete corresponding machine-readable\n source code, which must be distributed under the terms of Sections\n 1 and 2 above on a medium customarily used for software interchange; or,\n\n b) Accompany it with a written offer, valid for at least three\n years, to give any third party, for a charge no more than your\n cost of physically performing source distribution, a complete\n machine-readable copy of the corresponding source code, to be\n distributed under the terms of Sections 1 and 2 above on a medium\n customarily used for software interchange; or,\n\n c) Accompany it with the information you received as to the offer\n to distribute corresponding source code. (This alternative is\n allowed only for noncommercial distribution and only if you\n received the program in object code or executable form with such\n an offer, in accord with Subsection b above.)\n\nThe source code for a work means the preferred form of the work for\nmaking modifications to it. For an executable work, complete source\ncode means all the source code for all modules it contains, plus any\nassociated interface definition files, plus the scripts used to\ncontrol compilation and installation of the executable. However, as a\nspecial exception, the source code distributed need not include\nanything that is normally distributed (in either source or binary\nform) with the major components (compiler, kernel, and so on) of the\noperating system on which the executable runs, unless that component\nitself accompanies the executable.\n\nIf distribution of executable or object code is made by offering\naccess to copy from a designated place, then offering equivalent\naccess to copy the source code from the same place counts as\ndistribution of the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\f\n 4. You may not copy, modify, sublicense, or distribute the Program\nexcept as expressly provided under this License. Any attempt\notherwise to copy, modify, sublicense or distribute the Program is\nvoid, and will automatically terminate your rights under this License.\nHowever, parties who have received copies, or rights, from you under\nthis License will not have their licenses terminated so long as such\nparties remain in full compliance.\n\n 5. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Program or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Program (or any work based on the\nProgram), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Program or works based on it.\n\n 6. Each time you redistribute the Program (or any work based on the\nProgram), the recipient automatically receives a license from the\noriginal licensor to copy, distribute or modify the Program subject to\nthese terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties to\nthis License.\n\n 7. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Program at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Program by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Program.\n\nIf any portion of this section is held invalid or unenforceable under\nany particular circumstance, the balance of the section is intended to\napply and the section as a whole is intended to apply in other\ncircumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system, which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\f\n 8. If the distribution and/or use of the Program is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Program under this License\nmay add an explicit geographical distribution limitation excluding\nthose countries, so that distribution is permitted only in or among\ncountries not thus excluded. In such case, this License incorporates\nthe limitation as if written in the body of this License.\n\n 9. The Free Software Foundation may publish revised and/or new versions\nof the General Public License from time to time. Such new versions will\nbe similar in spirit to the present version, but may differ in detail to\naddress new problems or concerns.\n\nEach version is given a distinguishing version number. If the Program\nspecifies a version number of this License which applies to it and \"any\nlater version\", you have the option of following the terms and conditions\neither of that version or of any later version published by the Free\nSoftware Foundation. If the Program does not specify a version number of\nthis License, you may choose any version ever published by the Free Software\nFoundation.\n\n 10. If you wish to incorporate parts of the Program into other free\nprograms whose distribution conditions are different, write to the author\nto ask for permission. For software which is copyrighted by the Free\nSoftware Foundation, write to the Free Software Foundation; we sometimes\nmake exceptions for this. Our decision will be guided by the two goals\nof preserving the free status of all derivatives of our free software and\nof promoting the sharing and reuse of software generally.\n\n\t\t\t NO WARRANTY\n\n 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\nFOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\nOTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\nPROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\nOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\nTO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\nPROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\nREPAIR OR CORRECTION.\n\n 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\nREDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\nINCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\nOUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\nTO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\nYOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\nPROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\nPOSSIBILITY OF SUCH DAMAGES.\n\n\t\t END OF TERMS AND CONDITIONS\n\f\n\t How to Apply These Terms to Your New Programs\n\n If you develop a new program, and you want it to be of the greatest\npossible use to the public, the best way to achieve this is to make it\nfree software which everyone can redistribute and change under these terms.\n\n To do so, attach the following notices to the program. It is safest\nto attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least\nthe \"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with this program; if not, write to the Free Software\n Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this\nwhen it starts in an interactive mode:\n\n Gnomovision version 69, Copyright (C) year name of author\n Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n This is free software, and you are welcome to redistribute it\n under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate\nparts of the General Public License. Of course, the commands you use may\nbe called something other than `show w' and `show c'; they could even be\nmouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the program, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the program\n `Gnomovision' (which makes passes at compilers) written by James Hacker.\n\n , 1 April 1989\n Ty Coon, President of Vice\n\nThis General Public License does not permit incorporating your program into\nproprietary programs. If your program is a subroutine library, you may\nconsider it more useful to permit linking proprietary applications with the\nlibrary. If this is what you want to do, use the GNU Library General\nPublic License instead of this License.\n\n====================================================================================\n\nThe following applies only to src/test/dlchecksum.c:\n\n/*\n Copyright (C) The Julia contributors.\n Copyright (C) 2013 Mark Adler\n\n This software is provided 'as-is', without any express or implied\n warranty. In no event will the author be held liable for any damages\n arising from the use of this software.\n Permission is granted to anyone to use this software for any purpose,\n including commercial applications, and to alter it and redistribute it\n freely, subject to the following restrictions:\n 1. The origin of this software must not be misrepresented; you must not\n claim that you wrote the original software. If you use this software\n in a product, an acknowledgment in the product documentation would be\n appreciated but is not required.\n 2. Altered source versions must be plainly marked as such, and must not be\n misrepresented as being the original software.\n 3. This notice may not be removed or altered from any source distribution.\n Mark Adler\n madler@alumni.caltech.edu\n*/\n" }, { "path": "README.md", "content": "# Overview\n\n[![Build and test status](https://github.com/rr-debugger/rr/actions/workflows/build-and-test-main.yml/badge.svg?branch=master)](https://github.com/rr-debugger/rr/actions)\n\nrr is a lightweight tool for recording, replaying and debugging execution of applications (trees of processes and threads).\nDebugging extends gdb with very efficient reverse-execution, which in combination with standard gdb/x86 features like hardware data watchpoints, makes debugging much more fun. More information about the project, including instructions on how to install, run, and build rr, is at [https://rr-project.org](https://rr-project.org). The best technical overview is currently the paper [Engineering Record And Replay For Deployability: Extended Technical Report](https://arxiv.org/pdf/1705.05937.pdf).\n\nOr go directly to the [installation and building instructions](https://github.com/rr-debugger/rr/wiki/Building-And-Installing).\n\nPlease contribute! Make sure to review the [pull request checklist](/CONTRIBUTING.md) before submitting a pull request.\n\nIf you find rr useful, please [add a testimonial](https://github.com/rr-debugger/rr/wiki/Testimonials).\n\nrr development is sponsored by [Pernosco](https://pernos.co) and was originated by [Mozilla](https://www.mozilla.org).\n\n# System requirements\n\n* Linux kernel >= 4.7 (for support of `__WALL` in `waitid()`)\n * rr 5.6.0 worked with kernel 3.11 (requiring `PTRACE_SETSIGMASK`)\n* rr currently requires either:\n * An Intel CPU with [Nehalem](https://en.wikipedia.org/wiki/Nehalem_%28microarchitecture%29) (2010) or later microarchitecture.\n * Certain AMD Zen or later processors (see https://github.com/rr-debugger/rr/wiki/Zen)\n * Certain AArch64 microarchitectures (e.g. ARM Neoverse N1 or the Apple Silicon M-series)\n* Running in a VM guest is supported, as long as the VM supports virtualization of hardware performance counters. (VMware and KVM are known to work; Xen does not.)\n" }, { "path": "Vagrantfile", "content": "# -*- mode: ruby -*-\n# vi: set ft=ruby :\n# Author: David Manouchehri\n\nVagrant.configure(\"2\") do |config|\n\tconfig.vm.box = \"bento/ubuntu-16.04\"\n\n\tconfig.vm.synced_folder \".\", \"/vagrant\", disabled: true\n\n\tconfig.vm.provision \"shell\", inline: <<-SHELL\n\t\tapt-get update\n\t\t# DEBIAN_FRONTEND=noninteractive apt-get -y upgrade\n\t\tDEBIAN_FRONTEND=noninteractive apt-get -y install ccache cmake make g++-multilib gdb pkg-config realpath python-pexpect manpages-dev git ninja-build capnproto libcapnp-dev zlib1g-dev jq\n\t\tapt-get clean\n\tSHELL\n\n\tconfig.vm.provision \"shell\", privileged: false, inline: <<-SHELL\n\t\tgit clone https://github.com/rr-debugger/rr.git\n\t\tcd rr\n\t\tmkdir obj\n\t\tcd obj\n\t\tcmake .. -DPYTHON_EXECUTABLE=/usr/bin/python\n\t\tmake -j8\n\t\tmake test\n\tSHELL\n\n\tconfig.vm.provision \"shell\", inline: <<-SHELL\n\t\tcd /home/vagrant/rr/obj/\n\t\tmake install\n\tSHELL\n\n\t%w(vmware_fusion vmware_workstation vmware_appcatalyst).each do |provider|\n\t\tconfig.vm.provider provider do |v|\n\t\t\tv.vmx[\"memsize\"] = \"4096\"\n\t\t\tv.vmx['vpmc.enable'] = 'true'\n\t\t\tv.vmx['vhv.enable'] = 'true'\n\t\t\tv.vmx['vvtd.enable'] = 'true'\n\t\t\tv.vmx['monitor_control.disable_hvsim_clusters'] = 'true'\n\t\t\tv.vmx['virtualHW.version'] = '14'\n\t\t\tv.vmx['ethernet0.virtualDev'] = 'vmxnet3'\n\t\tend\n\tend\nend\n" }, { "path": "configure", "content": "#!/usr/bin/env bash\n\n# Helper to make |./configure && make| do what you expect.\ncmake .\n" }, { "path": "include/rr/rr.h", "content": "/* -*- Mode: C; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_H_\n#define RR_H_\n\n/**\n * rr tracees can write data to this special fd that they want\n * verified across record/replay. When it's written in recording, rr\n * saves the data. During replay, the data are checked against the\n * recorded data.\n *\n * Tracees using this interface should take care that the buffers\n * storing the data are either not racy, or are synchronized by the\n * tracee.\n *\n * To simplify things, we make this a valid fd opened to /dev/null during\n * recording.\n *\n * Tracees may close this fd, or dup() something over it, etc. If that happens,\n * it will lose its magical properties.\n */\n#define RR_MAGIC_SAVE_DATA_FD 999\n\n/**\n * Tracees use this fd to send other fds to rr.\n * This is only set up during recording.\n * Only the outermost rr uses this. Inner rr replays will use a different fd.\n */\n#define RR_RESERVED_SOCKET_FD 1001\n\n/**\n * The preferred fd that rr uses to control tracee desched. Some software\n * (e.g. the chromium IPC code) wants to have the first few fds all to itself,\n * so we need to stay above some floor. Tracee close()es of the fd that is\n * actually assigned will be silently ignored, and tracee dup()s to that fd will\n * fail with EBADF.\n */\n#define RR_DESCHED_EVENT_FLOOR_FD 100\n\n#endif /* RR_H_ */\n" }, { "path": "release-process/README.md", "content": "# Setting up AWS-based rr release testing\n\n* Create an AWS account.\n* Switch to the `us-east-2` (Ohio) region. The AMI IDs under `distro-configs` are all for the `us-east-2` region so this region must be used.\n* Use the EC2 console to create a keypair named `rr-testing`. This will download a file called `rr-testing.pem` containing the private key; move it somewhere safe and `chmod go-r /rr-testing.pem` to make ssh happy.\n* Install `boto3` locally, e.g. using `pip install boto3`.\n* Install `aws-cli` locally, e.g. using [these instructions](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).\n* Set `AWS_DEFAULT_REGION=us-east-2`, `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` in your environment.\n* Create AWS resources using `aws cloudformation create-stack --stack-name rr-testing --template-body file://path/to/rr-testing-cloud-formation.json`.\n * In the future, use `aws cloudformation update-stack --stack-name rr-testing --template-body file://path/to/rr-testing-cloud-formation.json` to update when that configuration file changes.\n\n# Preparing a release\n\nIf you want to support any new distro versions, add files to `release-process/distro-configs`. Likewise remove any config files for distro versions no longer supported. Make sure to commit all changes to the local `master` branch before runnging `prepare-release.py`. Then:\n```\nrelease-process/prepare-release.py ..0 /rr-testing.pem\n```\nThis will (re)create a `release` branch in Github, then start a number of EC2 VMs for testing and packaging. When a VM successfully completes its work, you will see lines like\n```\nTests succeeded for centos9 arm64\n```\nWhen a VM fails, you will see something like\n```\nTests failed (VM kept): see /tmp/rr-release-logs/debian12.arm64\n```\nThe output log should help diagnose the problem. At the end of the log is an SSH command you can use to log into the VM for further debugging. Make sure to shut down any failing VMs when you're done, either using `sudo shutdown now` in an SSH session, or from the AWS EC2 console.\n\nRepeat until there are no more failures or any failures are ignorable (e.g. due to [#3607](https://github.com/rr-debugger/rr/issues/3607)). The built packages will be in `/tmp/rr-dist`; there should be two `.deb`s, two `.rpm`s, and two `.tar.gz`s.\n\n# Completing the release\n\n- [ ] Cherry-pick `release` to `master` and update tag: `git cherry-pick release; git tag -f ..0` (Not sure why the tag needs to be updated...)\n- [ ] Delete the local and remote release branches: `git branch -d release; git push origin -d release`\n- [ ] Push changes to Github: `git push origin; git push --tags origin`. Once this is done there is no turning back!\n- [ ] [Create release and upload packages](https://github.com/mozilla/rr/releases) from `/tmp/rr-dist`\n- [ ] Update gh-pages: `./scripts/update-gh-pages.sh && git push origin`\n- [ ] Update [News wiki page](https://github.com/mozilla/rr/wiki/News)\n- [ ] Post to [rr-devel mailing list](mailto:rr-devel@googlegroups.com).\n\n# Testing a specific distro/CPU configuration\n\nThe `release-process/test-system.py` script can be used to start an AWS EC2 VM to test a specific distro version and CPU combination. E.g.\n```\nrelease-process/test-system.py --keep-vm release-process/distro-configs/centos9.json arm64 ~/rr-testing.pem >& /tmp/output\n```\nThis will start the VM, build rr, and run tests. Whether or not the tests succed, the VM will keep running and `/tmp/output` will end with an SSH command to log into the VM --- very handy for testing new distro versions or just running rr tests on a beefy machine. `test-system.py` has various options for customizing the instance type etc.\n\nThis is helpful for debugging intermittent rr test failures. For example, in a VM, you can run\n```\ncd ~/rr/src/test\nfor i in `seq 1 100`; do bash cont_race.run & done\n```\nto run 100 parallel instances of the `cont_race` test. If that doesn't show your bug, try 1000 instances instead. Running instances in parallel stresses thread scheduling and exposes more bugs.\n" }, { "path": "release-process/distro-configs/centos9.json", "content": "{\n \"name\": \"CentOS Stream 9\",\n \"ami_owner\": \"125523088429\",\n \"ami_name_pattern\": \"CentOS Stream 9 *\",\n \"user\": \"ec2-user\",\n \"archs\": [\"x86_64\", \"arm64\"],\n \"staticlibs\": false,\n \"setup_commands\": [\n \"cloud-init status --wait\",\n \"sudo dnf config-manager --set-enabled crb\",\n \"sudo dnf install -y epel-release epel-next-release\",\n \"sudo dnf update -y\"\n ],\n \"install_build_deps\": \"sudo dnf install -y rpm ccache cmake gcc gcc-c++ gdb lldb glibc-devel libstdc++-devel zlib-devel git python3 python3-pexpect rpm-build ninja-build capnproto capnproto-libs capnproto-devel libzstd libzstd-devel jq\",\n \"install_build_deps_x86_64\": \"sudo dnf install -y glibc-devel.i686 libstdc++-devel.i686\",\n \"install_app_test_deps\": \"sudo dnf install -y gtk3 dbus-glib xorg-x11-utils gnutls-devel libacl-devel openldap-devel tigervnc-server-minimal curl tar bzip2 libreoffice-writer\",\n \"exclude_tests_arm64\": [\"when.*\"]\n}\n" }, { "path": "release-process/distro-configs/debian11.json", "content": "{\n \"name\": \"Debian 11\",\n \"ami_owner\": \"136693071363\",\n \"ami_name_pattern\": \"debian-11-*\",\n \"user\": \"admin\",\n \"setup_commands\": [\n \"cloud-init status --wait\",\n \"export DEBIAN_FRONTEND=noninteractive UCF_FORCE_CONFNEW=1\",\n \"sudo -E apt-get update -y\",\n \"sudo -E apt-get dist-upgrade -f -y\"\n ],\n \"install_build_deps\": [\n \"sudo -E apt-get install -y locales-all rpm ccache cmake g++ pkg-config zlib1g-dev git python-dev libacl1-dev ninja-build manpages-dev capnproto libcapnp-dev gdb lldb-16 python3-pexpect libzstd1 libzstd-dev jq\",\n \"sudo update-alternatives --install /usr/bin/lldb lldb /usr/bin/lldb-16 50\"\n ],\n \"install_build_deps_x86_64\": \"sudo -E apt-get install -y g++-multilib\",\n \"install_app_test_deps\": \"sudo -E apt-get install -y tightvncserver xtightvncviewer curl tar bzip2 libdbus-glib-1-2 libreoffice\"\n}\n" }, { "path": "release-process/distro-configs/debian12.json", "content": "{\n \"name\": \"Debian 12\",\n \"ami_owner\": \"136693071363\",\n \"ami_name_pattern\": \"debian-12-*\",\n \"user\": \"admin\",\n \"archs\": [\"x86_64\", \"arm64\"],\n \"setup_commands\": [\n \"cloud-init status --wait\",\n \"export DEBIAN_FRONTEND=noninteractive UCF_FORCE_CONFNEW=1\",\n \"sudo -E apt-get update -y\",\n \"sudo -E apt-get dist-upgrade -f -y\"\n ],\n \"install_build_deps\": [\n \"sudo -E apt-get install -y locales-all rpm ccache cmake g++ pkg-config zlib1g-dev git python-dev-is-python3 libacl1-dev ninja-build manpages-dev capnproto libcapnp-dev gdb lldb-16 python3-pexpect libzstd1 libzstd-dev jq\",\n \"sudo update-alternatives --install /usr/bin/lldb lldb /usr/bin/lldb-16 50\"\n ],\n \"install_build_deps_x86_64\": \"sudo -E apt-get install -y g++-multilib\",\n \"install_app_test_deps\": \"sudo -E apt-get install -y tightvncserver xtightvncviewer curl tar bzip2 libdbus-glib-1-2 libreoffice\"\n}\n" }, { "path": "release-process/distro-configs/ubuntu20-lts.json", "content": "{\n \"name\": \"Ubuntu 20.04 LTS\",\n \"ami_owner\": \"099720109477\",\n \"ami_name_pattern\": \"ubuntu/images/hvm-ssd/ubuntu-focal-20.04-*\",\n \"user\": \"ubuntu\",\n \"setup_commands\": [\n \"cloud-init status --wait\",\n \"sudo apt-get update -y\",\n \"sudo apt-get dist-upgrade -f -y\"\n ],\n \"install_build_deps\": [\n \"sudo apt-get install -y rpm ccache cmake g++ pkg-config zlib1g-dev git python-dev libacl1-dev ninja-build manpages-dev capnproto libcapnp-dev gdb lldb-18 python3-pexpect libzstd1 libzstd-dev jq\",\n \"sudo update-alternatives --install /usr/bin/lldb lldb /usr/bin/lldb-18 50\"\n ],\n \"install_build_deps_x86_64\": \"sudo apt-get install -y g++-multilib\",\n \"install_app_test_deps\": \"sudo apt-get install -y tightvncserver xtightvncviewer curl tar bzip2 libdbus-glib-1-2 libreoffice\",\n \"exclude_tests\": [\"x86/pkeys.*\"]\n}\n" }, { "path": "release-process/distro-configs/ubuntu22-lts.json", "content": "{\n \"name\": \"Ubuntu 22.04 LTS\",\n \"ami_owner\": \"099720109477\",\n \"ami_name_pattern\": \"ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-*\",\n \"user\": \"ubuntu\",\n \"archs\": [\"x86_64\", \"arm64\"],\n \"setup_commands\": [\n \"cloud-init status --wait\",\n \"sudo apt-get update -y\",\n \"sudo apt-get dist-upgrade -f -y\"\n ],\n \"install_build_deps\": [\n \"sudo apt-get install -y rpm ccache cmake g++ pkg-config zlib1g-dev git python-dev-is-python3 libacl1-dev ninja-build manpages-dev capnproto libcapnp-dev gdb lldb-15 python3-pexpect libzstd1 libzstd-dev jq\",\n \"sudo update-alternatives --install /usr/bin/lldb lldb /usr/bin/lldb-15 50\",\n \"export PYTHONPATH=\\\"/usr/lib/llvm-15/lib/python3.10/dist-packages/:$PYTHONPATH\\\"\"\n ],\n \"install_build_deps_x86_64\": \"sudo apt-get install -y g++-multilib\",\n \"install_app_test_deps\": \"sudo apt-get install -y tightvncserver xtightvncviewer curl tar bzip2 libdbus-glib-1-2 libreoffice\"\n}\n" }, { "path": "release-process/distro-configs/ubuntu24-lts.json", "content": "{\n \"name\": \"Ubuntu 24.04 LTS\",\n \"ami_owner\": \"099720109477\",\n \"ami_name_pattern\": \"ubuntu/images/hvm-ssd-gp3/ubuntu-noble-24.04-*\",\n \"user\": \"ubuntu\",\n \"archs\": [\"x86_64\", \"arm64\"],\n \"setup_commands\": [\n \"cloud-init status --wait\",\n \"sudo apt-get update -y\",\n \"sudo apt-get dist-upgrade -f -y\"\n ],\n \"install_build_deps\": \"sudo apt-get install -y rpm ccache cmake g++ pkg-config zlib1g-dev git python-dev-is-python3 libacl1-dev ninja-build manpages-dev capnproto libcapnp-dev gdb lldb python3-pexpect libzstd1 libzstd-dev jq\",\n \"install_build_deps_x86_64\": \"sudo apt-get install -y g++-multilib\",\n \"install_app_test_deps\": \"sudo apt-get install -y tightvncserver xtightvncviewer curl tar bzip2 libdbus-glib-1-2 libreoffice\"\n}\n" }, { "path": "release-process/distro-configs/ubuntu24.10.json", "content": "{\n \"name\": \"Ubuntu 24.10\",\n \"ami_owner\": \"099720109477\",\n \"ami_name_pattern\": \"ubuntu/images/hvm-ssd-gp3/ubuntu-oracular-24.10-*\",\n \"user\": \"ubuntu\",\n \"archs\": [\"x86_64\"],\n \"setup_commands\": [\n \"cloud-init status --wait\",\n \"sudo apt-get update -y\",\n \"sudo apt-get dist-upgrade -f -y\"\n ],\n \"install_build_deps\": \"sudo apt-get install -y rpm ccache cmake g++ pkg-config zlib1g-dev git python-dev-is-python3 libacl1-dev ninja-build manpages-dev capnproto libcapnp-dev gdb lldb python3-pexpect libzstd1 libzstd-dev jq\",\n \"install_build_deps_x86_64\": \"sudo apt-get install -y g++-multilib\",\n \"install_app_test_deps\": \"sudo apt-get install -y tightvncserver xtightvncviewer curl tar bzip2 libdbus-glib-1-2 libreoffice\"\n}\n" }, { "path": "release-process/prepare-release.py", "content": "#!/usr/bin/python3\n\nimport argparse\nimport glob\nimport json\nimport os\nimport re\nimport subprocess\nimport sys\nimport time\n\n# These are where we build the release binaries. They should be as old as possible\n# while still supported. Update these when the distro release is no longer supported.\ndist_packaging = {\n ('ubuntu20-lts', 'x86_64'): 'TGZ;DEB',\n ('ubuntu22-lts', 'arm64'): 'TGZ;DEB',\n ('centos9', 'x86_64'): 'RPM',\n ('centos9', 'arm64'): 'RPM',\n}\n\nos.chdir(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))\n\nparser = argparse.ArgumentParser()\nparser.add_argument('version')\nparser.add_argument('keypair_pem_file')\nargs = parser.parse_args()\n\nversion_re = re.compile(r'(\\d+)\\.(\\d+)\\.(\\d+)')\nm = version_re.match(args.version)\nif not m:\n raise ValueError('version must have three numeric components, got %s' % args.version)\nmajor = int(m.group(1))\nminor = int(m.group(2))\npatch = int(m.group(3))\nversion = '%d.%d.%d' % (major, minor, patch)\n\ndist_dir = '/tmp/rr-dist'\nlog_dir = '/tmp/rr-release-logs'\n\ndef check_call(args):\n print('Running %s' % args)\n subprocess.check_call(args)\n\ndef update_cmake(name, num):\n check_call(['sed', '-i',\n 's/rr_VERSION_%s [0-9][0-9]*/rr_VERSION_%s %d/g' % (name, name, num),\n 'CMakeLists.txt'])\n\ndef prepare_branch():\n output = subprocess.check_output(['git', 'status',\n '--untracked-files=no', '--porcelain'], stderr=subprocess.STDOUT)\n if output:\n print('Uncommitted changes in git workspace, aborting', file=sys.stderr)\n sys.exit(2)\n check_call(['git', 'checkout', '-B', 'release', 'master'])\n update_cmake('MAJOR', major)\n update_cmake('MINOR', minor)\n update_cmake('PATCH', patch)\n check_call(['git', 'commit', '-a', '-m', 'Bump version to %s' % version])\n check_call(['git', 'tag', '-f', version])\n check_call(['git', 'push', '-f', '--set-upstream', 'origin', 'release'])\n check_call(['git', 'checkout', 'master'])\n\ndef prepare_dirs():\n check_call(['rm', '-rf', dist_dir, log_dir])\n check_call(['mkdir', dist_dir, log_dir])\n\ndef output_file_name(distro_name, arch):\n return os.path.join(log_dir, '%s.%s' % (distro_name, arch))\n\ndef has_line_starting(output_file, prefix):\n with open(output_file, 'r') as f:\n for line in f:\n if line.startswith(prefix):\n return True\n return False\n\ndef start_vm(cmd, output_file):\n with open(output_file, 'w') as f:\n process = subprocess.Popen(cmd, stderr=subprocess.STDOUT, stdout=f)\n while True:\n time.sleep(1)\n if process.poll() is not None:\n if has_line_starting(output_file, 'botocore.exceptions.ClientError: An error occurred (VcpuLimitExceeded) '):\n return None\n return process\n if has_line_starting(output_file, 'Started VM '):\n return process\n\nCOLOR_SUCCESS = '\\033[92m'\nCOLOR_FAILURE = '\\033[91m'\nCOLOR_NORMAL = '\\033[0m'\n\ndef run_tests():\n distro_files = glob.glob('release-process/distro-configs/*.json')\n pending = []\n for distro_file in sorted(distro_files):\n distro_name = os.path.basename(distro_file).rsplit('.', 1)[0]\n with open(distro_file, 'r') as f:\n distro_config = json.load(f)\n archs = distro_config['archs'] if 'archs' in distro_config else ['x86_64']\n for arch in sorted(archs):\n cmd = ['release-process/test-system.py', '--keep-vm-on-error',\n '--git-revision', 'release',\n distro_file, arch, args.keypair_pem_file]\n generators = dist_packaging.get((distro_name, arch))\n if generators is not None:\n cmd += ['--dist-files-dir', dist_dir, '--cpack-generators', generators]\n pending.append((distro_name, arch, cmd))\n running = []\n fail_count = 0\n while pending or running:\n while pending:\n distro_name, arch, cmd = pending[0]\n output_file = output_file_name(distro_name, arch)\n process = start_vm(cmd, output_file)\n if process:\n pending.pop(0)\n running.append((distro_name, arch, process))\n print('Started %s %s' % (distro_name, arch))\n else:\n break\n # If no exits are seen after 60 seconds, try to launch a new VM anyway.\n for i in range(60):\n ready_index = None\n for running_index, (distro_name, arch, process) in enumerate(running):\n if process.poll() is not None:\n ready_index = running_index\n break\n if ready_index is not None:\n distro_name, arch, process = running.pop(ready_index)\n output_file = output_file_name(distro_name, arch)\n vm_kept = has_line_starting(output_file, 'VM kept; ')\n if process.returncode:\n print('%sTests failed%s: see %s%s' %\n (COLOR_FAILURE, ' (VM kept)' if vm_kept else '', output_file, COLOR_NORMAL), file=sys.stderr)\n fail_count += 1\n else:\n print('%sTests succeeded for %s %s%s' % (COLOR_SUCCESS, distro_name, arch, COLOR_NORMAL))\n break\n time.sleep(1)\n print('%d failures total' % fail_count)\n if fail_count:\n sys.exit(1)\n else:\n print('Dist files left in %s' % dist_dir)\n\nprepare_branch()\nprepare_dirs()\nrun_tests()\n" }, { "path": "release-process/rr-testing-cloud-formation.json", "content": "{\n \"AWSTemplateFormatVersion\" : \"2010-09-09\",\n \"Resources\": {\n \"SecurityGroup\": {\n \"Type\": \"AWS::EC2::SecurityGroup\",\n \"Properties\": {\n \"GroupDescription\": \"rr testing security group\",\n \"GroupName\": \"rr-testing\",\n \"SecurityGroupIngress\" : [\n {\n \"IpProtocol\": \"tcp\",\n \"FromPort\": 22,\n \"ToPort\": 22,\n \"CidrIp\": \"0.0.0.0/0\"\n }\n ]\n }\n }\n }\n}\n" }, { "path": "release-process/rr-testing.sh", "content": "# Bash script to build rr and run tests.\n#\n# Requires variables and functions to be set. See test-system.py.\n# $git_revision : git revision to check out, build and test\n# $staticlibs : TRUE or FALSE to build with static libs\n# $build_dist : 1 if we should build dist packages, 0 otherwise\n# $test_firefox : 1 to run firefox tests, 0 to skip\n# $ctest_options : options to pass to ctest, e.g to exclude certain tests\n# $cpack_generators : CPack generators to build dist\n# setup_commands : function to setup environment, e.g. 'apt update'\n# install_build_deps : function to install dependencies required to build rr\n# install_app_test_deps : function to install dependencies required by tests\n\nset -e # default to exiting on error\"\n\nuname -a\n\nsetup_commands\ninstall_build_deps\n\ninstall_app_test_deps & # job %1\n\n# Free up space before we (re)start\n\nrm -rf ~/rr || true\ngit clone https://github.com/rr-debugger/rr ~/rr\ncd ~/rr\ngit checkout $git_revision\n\nrm -rf ~/obj || true\nmkdir ~/obj\ncd ~/obj\ncmake -G Ninja -DCMAKE_BUILD_TYPE=RELEASE -Dstaticlibs=$staticlibs -Dstrip=TRUE -DCPACK_GENERATOR=$cpack_generators ../rr\nninja\n\n# Enable perf events for rr\necho 0 | sudo tee /proc/sys/kernel/perf_event_paranoid\n# Enable ptrace-attach to any process. This lets us get more data when tests fail.\necho 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope\n# Disable AppArmor restrictions on user namespaces, which our tests need to use\n(echo 0 | sudo tee /proc/sys/kernel/apparmor_restrict_unprivileged_userns) || true\nrm -rf /tmp/rr-* || true\nlet halfproc=`nproc`/2\nctest -j$halfproc --verbose $ctest_options\n echo \"For some reason I cannot figure out, bash drops the first four characters from the line following ctest\"\n\n# Integration test deps are installed in parallel with our build.\n# Make sure that install has finished before running tests\nwait %1\n\nrm -rf ~/.local/share/rr/* || true\n\nfunction xvnc-runner { CMD=$1 EXPECT=$2\n rm -f /tmp/xvnc /tmp/xvnc-client /tmp/xvnc-wininfo /tmp/xvnc-client-replay || true\n\n Xvnc :9 > /tmp/xvnc 2>&1 &\n for retries in `seq 1 60`; do\n if grep -q \"Listening\" /tmp/xvnc; then\n break\n fi\n if [[ $retries == 60 ]]; then\n echo FAILED: too many retries of $CMD\n exit 1\n fi\n sleep 1\n done\n DISPLAY=:9 ~/obj/bin/rr $CMD > /tmp/xvnc-client 2>&1 &\n for retries in `seq 1 60`; do\n DISPLAY=:9 xwininfo -tree -root > /tmp/xvnc-wininfo 2>&1\n if grep -q \"$EXPECT\" /tmp/xvnc-wininfo; then\n break\n fi\n if [[ $retries == 60 ]]; then\n echo FAILED: too many retries of $CMD\n exit 1\n fi\n sleep 1\n done\n # kill Xvnc\n kill -9 %1\n # wait for $CMD to exit. Since we killed the X server it may\n # exit with a failure code.\n wait %2 || true\n ~/obj/bin/rr replay -a > /tmp/xvnc-client-replay 2>&1 || (echo \"FAILED: replay failed\"; exit 1)\n diff /tmp/xvnc-client /tmp/xvnc-client-replay || (echo \"FAILED: replay differs\"; exit 1)\n echo PASSED: $CMD\n}\n\nif [[ $test_firefox == 1 ]]; then\n rm -rf /tmp/firefox /tmp/firefox-profile || true\n mkdir /tmp/firefox-profile\n ( cd /tmp; curl -L 'https://download.mozilla.org/?product=firefox-latest&os=linux64&lang=en-US' | tar -Jxf - )\n xvnc-runner \"/tmp/firefox/firefox --profile /tmp/firefox-profile $HOME/rr/release-process/test-data/test.html\" \"rr Test Page\"\nfi\n\nif [[ $test_libreoffice == 1 ]]; then\n rm -rf ~/.config/libreoffice || true\n xvnc-runner \"libreoffice $HOME/rr/release-process/test-data/rr-test-doc.odt\" \"rr-test-doc.odt\"\nfi\n\nif [[ $build_dist != 0 ]]; then\n ninja package\n rm /tmp/dist || true\n ln -s ~/obj/dist /tmp/dist\nfi\n" }, { "path": "release-process/test-data/test.html", "content": "\n\n\n

Hello!\n\n" }, { "path": "release-process/test-system.py", "content": "#!/usr/bin/python3\n\nimport argparse\nimport boto3\nfrom datetime import datetime\nimport json\nimport pathlib\nimport subprocess\nimport sys\nimport time\n\nparser = argparse.ArgumentParser()\nparser.add_argument('distro_config_json')\nparser.add_argument('architecture')\nparser.add_argument('keypair_pem_file')\nparser.add_argument('--cpack-generators', default='TGZ')\nparser.add_argument('--git-revision', default='master')\nparser.add_argument('--timeout', default=1200) # 20 minutes\nparser.add_argument('--machine-type')\nparser.add_argument('--keep-vm', action='store_true')\nparser.add_argument('--keep-vm-on-error', action='store_true')\nparser.add_argument('--dist-files-dir')\nargs = parser.parse_args()\n\nclass Ec2Vm:\n def __init__(self, machine_type, architecture, distro_config, keypair_pem_file):\n \"\"\"Start an EC2 VM using the latest available AMI.\n If this completes without throwing an exception, then terminate()\n should be called eventually (unless you want to keep the VM running).\"\"\"\n self.distro_name = distro_config['name']\n self.user = distro_config['user']\n self.keypair_pem_file = keypair_pem_file\n self.ssh_ready = False\n self.ec2 = boto3.resource('ec2')\n self.ec2_client = boto3.client('ec2')\n\n # For some reason adding MaxResults here causes AWS\n # to return no results in some cases :-(\n response = self.ec2_client.describe_images(Owners=[distro_config['ami_owner']], Filters=[\n {'Name': 'architecture', 'Values': [architecture]},\n {'Name': 'name', 'Values': [distro_config['ami_name_pattern']]}\n ])\n images = response['Images']\n if len(images) >= 1000:\n raise Exception('Too many AMIs match filter')\n if len(images) == 0:\n raise Exception('No AMIs match filter')\n latest_image = sorted(response['Images'],\n key=lambda img: datetime.strptime(img['CreationDate'], '%Y-%m-%dT%H:%M:%S.%f%z').timestamp(),\n reverse=True\n )[0]\n ami = latest_image['ImageId']\n block_device = None\n for mapping in latest_image['BlockDeviceMappings']:\n if 'Ebs' in mapping:\n if block_device is not None:\n raise Exception('Multiple block devices found')\n block_device = mapping['DeviceName']\n if block_device is None:\n raise Exception('No block device found')\n print('Found AMI %s created %s with block device %s'%(ami, latest_image['CreationDate'], block_device), file=sys.stderr)\n\n tags = [{\n 'ResourceType': 'instance',\n 'Tags': [{'Key': 'Name', 'Value': \"rr-test %s %s\"%(self.distro_name, architecture)}]\n }]\n response = self.ec2.create_instances(ImageId=ami, InstanceType=machine_type,\n KeyName='rr-testing', MinCount=1, MaxCount=1,\n BlockDeviceMappings=[{'DeviceName': block_device, 'Ebs': {'VolumeSize': 32}}],\n InstanceInitiatedShutdownBehavior='terminate',\n SecurityGroups=['rr-testing'],\n TagSpecifications=tags)\n self.instance = response[0]\n print('Starting VM %s \"%s\"'%(self.instance.id, self.distro_name), file=sys.stderr)\n\n def wait_for_ssh(self):\n \"\"\"Wait until the instance is ready to accept ssh commands.\"\"\"\n self.instance.wait_until_running()\n self.instance.reload()\n print('Started VM %s \"%s\" at %s'%(self.instance.id, self.distro_name, self.instance.public_ip_address), file=sys.stderr)\n for retries in range(60):\n result = subprocess.run(self.ssh_command() + ['true'], stdin=subprocess.DEVNULL, stderr=subprocess.PIPE)\n if result.returncode == 0:\n self.ssh_ready = True\n return\n if (b'Connection refused' not in result.stderr and\n b'reset by peer' not in result.stderr and\n b'Connection timed out' not in result.stderr and\n b'Unprivileged users are not permitted to log in yet' not in result.stderr):\n raise Exception('SSH connection failed:\\n%s'%result.stderr.decode('utf-8'))\n time.sleep(1)\n raise Exception('Too many retries, cannot connect via SSH')\n\n def ssh(self, cmd, input):\n \"\"\"Run `cmd` (command + args list) via SSH and wait for it to finish.\n Command stdout and stderr are echoed to our stdout/stderr.\n If the command fails, throws an exception with the exit status.\n Returns nothing.\"\"\"\n full_cmd = self.ssh_command() + cmd\n print('Running %s'%full_cmd, file=sys.stderr)\n process = subprocess.Popen(full_cmd, stdin=subprocess.PIPE)\n process.communicate(input=input, timeout=args.timeout)\n if process.returncode != 0:\n raise Exception('Command failed with %d'%process.returncode)\n\n def scp_from(self, options, src, dst):\n \"\"\"Copies files from remote `src` to local `dst`.\"\"\"\n full_cmd = ['scp'] + self.ssh_options() + options + ['%s:%s'%(self.ssh_dest(), src), dst]\n print('Running %s'%full_cmd, file=sys.stderr)\n subprocess.check_call(full_cmd)\n\n def ssh_command(self):\n return ['ssh'] + self.ssh_options() + [self.ssh_dest()]\n\n def ssh_options(self):\n return ['-i', self.keypair_pem_file,\n '-o', 'StrictHostKeyChecking=no',\n # A broken agent config can stop SSH from working. Bypass that.\n '-o', 'IdentityAgent=none',\n '-o', 'BatchMode=yes',\n '-o', 'ConnectTimeout=5',\n '-o', 'IdentitiesOnly=yes']\n\n def ssh_dest(self):\n return '%s@%s'%(self.user, self.instance.public_ip_address)\n\n def terminate(self):\n response = self.instance.terminate()\n if response['ResponseMetadata']['HTTPStatusCode'] != 200:\n print('Terminating VM %s failed: %s'%(self.instance_id, response), file=sys.stderr)\n self.instance.wait_until_terminated()\n\nwith open(args.distro_config_json, 'r') as f:\n distro_config = json.load(f)\n\nwith pathlib.Path(__file__).with_name('rr-testing.sh').open('rb') as f:\n rr_testing_script = f.read()\n\ndef get_config_lines(config_key):\n entry = distro_config.get(config_key)\n if isinstance(entry, str):\n return [entry]\n if isinstance(entry, list):\n return entry\n if entry is None:\n return []\n raise ValueError('Invalid config entry %s: %s' % (config_key, entry))\n\ndef get_config_lines_arch(config_key):\n return get_config_lines(config_key) + get_config_lines('%s_%s'%(config_key, args.architecture))\n\ndef config_script_function(config_key):\n lines = get_config_lines_arch(config_key)\n return ('function %s {\\n%s\\n}' % (config_key, '\\n'.join(lines)))\n\nmachine_type = args.machine_type\nif not machine_type:\n if args.architecture == 'x86_64':\n machine_type = 'c5.9xlarge'\n elif args.architecture == 'arm64':\n machine_type = 'c6g.8xlarge'\n\nvm = Ec2Vm(machine_type, args.architecture, distro_config, args.keypair_pem_file)\nsuccess = False\ntry:\n vm.wait_for_ssh()\n exclude_tests = get_config_lines_arch('exclude_tests')\n if args.architecture == 'arm64':\n # Currently AWS Graviton instances have a high failure rate on the `rseq` test\n # because of missed timer interrupts\n exclude_tests += [\"rseq.*\"]\n ctest_options = []\n if exclude_tests:\n ctest_options = ['-E', '|'.join(exclude_tests)]\n full_script = '\\n'.join(\n [\n 'set -x', # echo commands\n config_script_function('setup_commands'),\n config_script_function('install_build_deps'),\n config_script_function('install_app_test_deps'),\n 'git_revision=\"%s\"'%args.git_revision,\n 'staticlibs=%s'%('TRUE' if distro_config.get('staticlibs', True) else 'FALSE'),\n 'build_dist=%d'%(1 if args.dist_files_dir is not None else 0),\n # Firefox doesn't have release tarballs for Aarch64\n 'test_firefox=%d'%(1 if args.architecture == 'x86_64' else 0),\n # libreoffice uses STREX\n 'test_libreoffice=%d'%(1 if args.architecture == 'x86_64' else 0),\n 'ctest_options=\"%s\"'%' '.join(c for c in ctest_options),\n 'cpack_generators=\"%s\"'%args.cpack_generators\n ]).encode('utf-8') + b'\\n' + rr_testing_script\n vm.ssh(['/bin/bash', '-s'], full_script)\n if args.dist_files_dir is not None:\n vm.scp_from(['-r'], '/tmp/dist/*', args.dist_files_dir)\n success = True\nfinally:\n if (not success and args.keep_vm_on_error) or args.keep_vm:\n if vm.ssh_ready:\n print('VM kept; connect with: %s'%(' '.join(vm.ssh_command())), file=sys.stderr)\n else:\n print('VM %s still starting up'%vm.instance.id)\n else:\n vm.terminate()\n" }, { "path": "rr.spec", "content": "Buildroot: @CPACK_BINARY_DIR@/_CPack_Packages/@CPACK_SYSTEM_NAME@/RPM/@CPACK_PACKAGE_FILE_NAME@\nSummary: Lightweight tool for recording and replaying execution of applications (trees of processes and threads)\nName: @CPACK_PACKAGE_NAME@\nVersion: @CPACK_PACKAGE_VERSION@\nRelease: @CPACK_RPM_PACKAGE_RELEASE@\nLicense: @CPACK_RPM_PACKAGE_LICENSE@\nGroup: Development/Debuggers\nVendor: @CPACK_PACKAGE_VENDOR@\nPrefix: @CPACK_PACKAGING_INSTALL_PREFIX@\n@CPACK_RPM_PACKAGE_REQUIRES@\n\n%define _rpmfilename @CPACK_PACKAGE_FILE_NAME@.rpm\n%define _unpackaged_files_terminate_build 0\n \n%description\nrr is a lightweight tool for recording and replaying execution of applications (trees of processes and threads). For more information, please visit\n\nhttp://rr-project.org\n \n# This is a shortcutted spec file generated by CMake RPM generator\n# we skip _install step because CPack does that for us.\n# We do only save CPack installed tree in _prepr\n# and then restore it in build.\n\n%files\n%defattr(-,root,root,-)\n@CPACK_PACKAGING_INSTALL_PREFIX@/lib64/*\n@CPACK_PACKAGING_INSTALL_PREFIX@/bin/rr\n@CPACK_PACKAGING_INSTALL_PREFIX@/bin/rr_exec_stub*\n@CPACK_PACKAGING_INSTALL_PREFIX@/bin/signal-rr-recording.sh\n@CPACK_PACKAGING_INSTALL_PREFIX@/share/rr/*.xml\n\n%changelog\n* Tue Jun 25 2013 Chris Jones - \n- Initial build.\n" }, { "path": "scripts/checkpoint-visualizer.html", "content": "\n\n\n\n\n \n \n
CheckpointTimeTime to next
\n\n" }, { "path": "scripts/github-actions-CTestCostData.txt", "content": "check_environment 3 0.0164291\n64bit_child 3 0.337334\n64bit_child-no-syscallbuf 3 0.302363\n_llseek 3 0.157875\n_llseek-no-syscallbuf 3 0.158812\nabort 3 0.304707\nabort-no-syscallbuf 3 0.299669\naccept 3 0.284387\naccept-no-syscallbuf 3 0.239335\nacct 3 0.154535\nacct-no-syscallbuf 3 0.149707\nadjtimex 3 0.149192\nadjtimex-no-syscallbuf 3 0.150965\naio 3 0.162193\naio-no-syscallbuf 3 0.156213\nalarm 3 2.19231\nalarm-no-syscallbuf 3 2.36203\nalarm2 3 1.1351\nalarm2-no-syscallbuf 3 1.15334\nalsa_ioctl 3 0.161643\nalsa_ioctl-no-syscallbuf 3 0.156718\narch_prctl 3 0.15381\narch_prctl-no-syscallbuf 3 0.153508\nasync_segv_ignored 3 0.157473\nasync_segv_ignored-no-syscallbuf 3 0.145451\nat_threadexit 3 0.19424\nat_threadexit-no-syscallbuf 3 0.182429\nbad_ip 3 0.151295\nbad_ip-no-syscallbuf 3 0.161028\nbad_syscall 3 0.157744\nbad_syscall-no-syscallbuf 3 0.13592\nbarrier 3 0.320478\nbarrier-no-syscallbuf 3 0.315113\nbig_buffers 3 0.163305\nbig_buffers-no-syscallbuf 3 0.171716\nblock 3 9.33639\nblock-no-syscallbuf 3 9.37496\nblock_open 3 0.188278\nblock_open-no-syscallbuf 3 0.186365\nbpf 3 0.168066\nbpf-no-syscallbuf 3 0.158176\nbpf_map 3 0.159372\nbpf_map-no-syscallbuf 3 0.152375\nbrk 3 0.172667\nbrk-no-syscallbuf 3 0.21366\nbrk2 3 0.16919\nbrk2-no-syscallbuf 3 0.157624\ncapget 3 0.172001\ncapget-no-syscallbuf 3 0.159812\nchew_cpu 3 8.01593\nchew_cpu-no-syscallbuf 3 8.45056\nx86/chew_cpu_cpuid 3 0.659385\nx86/chew_cpu_cpuid-no-syscallbuf 3 0.208381\nchmod 3 0.165601\nchmod-no-syscallbuf 3 0.170718\nchown 3 0.224577\nchown-no-syscallbuf 3 0.217927\nclock 3 0.291529\nclock-no-syscallbuf 3 0.376562\nclock_adjtime 3 0.158049\nclock_adjtime-no-syscallbuf 3 0.160917\nclock_nanosleep 3 1.15919\nclock_nanosleep-no-syscallbuf 3 1.14622\nclock_time64 3 0.16596\nclock_time64-no-syscallbuf 3 0.145465\nclone 3 0.16978\nclone-no-syscallbuf 3 0.175969\nclone_bad_stack 3 0.250671\nclone_bad_stack-no-syscallbuf 3 0.242454\nclone_bad_tls 3 0.172232\nclone_bad_tls-no-syscallbuf 3 0.146773\nclone_cleartid_coredump 3 0.300219\nclone_cleartid_coredump-no-syscallbuf 3 0.256838\nclone_fail 3 0.15996\nclone_fail-no-syscallbuf 3 0.147497\nclone_file_range 3 0.186542\nclone_file_range-no-syscallbuf 3 0.163602\nclone_immediate_exit 3 0.170451\nclone_immediate_exit-no-syscallbuf 3 0.169469\nclone_newflags 3 0.185066\nclone_newflags-no-syscallbuf 3 0.921083\nclone_parent 3 0.171129\nclone_parent-no-syscallbuf 3 0.173956\nclone_untraced 3 0.174148\nclone_untraced-no-syscallbuf 3 0.176188\nclone_vfork_pidfd 3 0.154905\nclone_vfork_pidfd-no-syscallbuf 3 0.151696\ncloned_sigmask 3 0.240172\ncloned_sigmask-no-syscallbuf 3 0.24506\nconstructor 3 2.19692\nconstructor-no-syscallbuf 3 2.18588\ncopy_file_range 3 0.163762\ncopy_file_range-no-syscallbuf 3 0.165092\nx86/cpuid_same_state 3 0.147253\nx86/cpuid_same_state-no-syscallbuf 3 0.153602\ncreat_address_not_truncated 3 0.161669\ncreat_address_not_truncated-no-syscallbuf 3 0.155895\nx86/cross_arch 3 0.157302\nx86/cross_arch-no-syscallbuf 3 0.153614\ncwd_inaccessible 3 0.223587\ncwd_inaccessible-no-syscallbuf 3 0.196703\ndaemon 3 0.180253\ndaemon-no-syscallbuf 3 0.159867\ndesched_blocking_poll 3 0.169864\ndesched_blocking_poll-no-syscallbuf 3 0.157374\ndesched_sigkill 3 0.281728\ndesched_sigkill-no-syscallbuf 3 0.228313\ndetach_state 3 0.205698\ndetach_state-no-syscallbuf 3 0.193471\ndetach_threads 3 0.25549\ndetach_threads-no-syscallbuf 3 0.229942\ndetach_sigkill 3 0.179927\ndetach_sigkill-no-syscallbuf 3 0.188678\ndetach_sigkill_exit 3 0.18524\ndetach_sigkill_exit-no-syscallbuf 3 0.174088\ndeterministic_sigsys 3 0.270055\ndeterministic_sigsys-no-syscallbuf 3 0.249215\ndev_zero 3 0.144176\ndev_zero-no-syscallbuf 3 0.192823\ndirect 3 0.205225\ndirect-no-syscallbuf 3 0.165835\ndup 3 0.192603\ndup-no-syscallbuf 3 0.164489\ndoublesegv 3 0.381171\ndoublesegv-no-syscallbuf 3 0.312939\nepoll_create 3 0.166363\nepoll_create-no-syscallbuf 3 0.140522\nepoll_create1 3 0.153205\nepoll_create1-no-syscallbuf 3 0.153613\nepoll_edge 3 0.158166\nepoll_edge-no-syscallbuf 3 0.144885\nepoll_pwait_eintr_sigmask 3 2.17026\nepoll_pwait_eintr_sigmask-no-syscallbuf 3 2.18145\neventfd 3 0.15034\neventfd-no-syscallbuf 3 0.149446\nexec_flags 3 0.149154\nexec_flags-no-syscallbuf 3 0.160262\nexec_no_env 3 0.197531\nexec_no_env-no-syscallbuf 3 0.18554\nexec_self 3 0.209195\nexec_self-no-syscallbuf 3 0.200386\nexec_from_main_thread 3 0.240319\nexec_from_main_thread-no-syscallbuf 3 0.255829\nexec_from_other_thread 3 13.8722\nexec_from_other_thread-no-syscallbuf 3 8.111\nexec_stopsig 3 0.229359\nexec_stopsig-no-syscallbuf 3 0.278794\nexecveat 3 0.205381\nexecveat-no-syscallbuf 3 0.210941\nexit_with_syscallbuf_signal 3 0.205309\nexit_with_syscallbuf_signal-no-syscallbuf 3 0.15339\nfadvise 3 0.156232\nfadvise-no-syscallbuf 3 0.144128\nfanotify 3 0.15563\nfanotify-no-syscallbuf 3 0.15289\nfatal_init_signal 3 0.202159\nfatal_init_signal-no-syscallbuf 3 0.172656\nfatal_sigsegv_thread 3 3.10984\nfatal_sigsegv_thread-no-syscallbuf 3 3.33673\nx86/fault_in_code_page 3 0.17993\nx86/fault_in_code_page-no-syscallbuf 3 0.168079\nfcntl_dupfd 3 0.162022\nfcntl_dupfd-no-syscallbuf 3 0.175576\nfcntl_misc 3 0.165599\nfcntl_misc-no-syscallbuf 3 0.145983\nfcntl_notify 3 0.163588\nfcntl_notify-no-syscallbuf 3 0.154498\nfcntl_owner_ex 3 0.155885\nfcntl_owner_ex-no-syscallbuf 3 0.16322\nfcntl_rw_hints 3 0.161478\nfcntl_rw_hints-no-syscallbuf 3 0.1507\nfcntl_seals 3 0.157493\nfcntl_seals-no-syscallbuf 3 0.145734\nfcntl_sig 3 0.170472\nfcntl_sig-no-syscallbuf 3 0.152661\nfd_cleanup 3 0.169983\nfd_cleanup-no-syscallbuf 3 0.183182\nfd_tracking_across_threads 3 0.201\nfd_tracking_across_threads-no-syscallbuf 3 0.179575\nfds_clean 3 0.246435\nfds_clean-no-syscallbuf 3 0.223065\nflock 3 0.677845\nflock-no-syscallbuf 3 1.0678\nflock_ofd 3 0.213914\nflock_ofd-no-syscallbuf 3 0.580972\nflock2 3 0.158132\nflock2-no-syscallbuf 3 0.149122\nfork_brk 3 0.197026\nfork_brk-no-syscallbuf 3 0.147554\nfork_child_crash 3 0.237483\nfork_child_crash-no-syscallbuf 3 0.239962\nfork_many 3 1.14265\nfork_many-no-syscallbuf 3 0.631239\nfutex_exit_race 3 0.52669\nfutex_exit_race-no-syscallbuf 3 0.386538\nfutex_exit_race_sigsegv 3 0.512517\nfutex_exit_race_sigsegv-no-syscallbuf 3 0.401706\nfutex_pi 3 0.179632\nfutex_pi-no-syscallbuf 3 0.158569\nfutex_priorities 3 0.219008\nfutex_priorities-no-syscallbuf 3 0.174828\nfutex_requeue 3 1.17145\nfutex_requeue-no-syscallbuf 3 1.16684\ngcrypt_rdrand 3 0.161925\ngcrypt_rdrand-no-syscallbuf 3 0.152451\ngetcpu 3 0.190398\ngetcpu-no-syscallbuf 3 0.151586\ngetgroups 3 0.160673\ngetgroups-no-syscallbuf 3 0.159069\ngetpwnam 3 0.198918\ngetpwnam-no-syscallbuf 3 0.254073\ngetrandom 3 0.18004\ngetrandom-no-syscallbuf 3 0.166992\nsetitimer 3 0.190327\nsetitimer-no-syscallbuf 3 0.160196\ngetsid 3 0.162228\ngetsid-no-syscallbuf 3 0.157766\ngettimeofday 3 0.159695\ngettimeofday-no-syscallbuf 3 0.162379\ngrandchild_threads 3 0.189786\ngrandchild_threads-no-syscallbuf 3 0.175099\ngrandchild_threads_main_running 3 4.2474\ngrandchild_threads_main_running-no-syscallbuf 3 4.26134\ngrandchild_threads_thread_running 3 4.25645\ngrandchild_threads_thread_running-no-syscallbuf 3 4.24836\ngrandchild_threads_parent_alive 3 0.191652\ngrandchild_threads_parent_alive-no-syscallbuf 3 0.188965\nx86/hle 3 0.978571\nx86/hle-no-syscallbuf 3 0.900915\ninotify 3 0.177146\ninotify-no-syscallbuf 3 0.154308\nint3 3 0.15784\nint3-no-syscallbuf 3 0.142212\nintr_futex_wait_restart 3 1.73505\nintr_futex_wait_restart-no-syscallbuf 3 1.68099\nintr_poll 3 3.69626\nintr_poll-no-syscallbuf 3 3.65486\nintr_ppoll 3 21.3328\nintr_ppoll-no-syscallbuf 3 21.2959\nintr_pselect 3 9.15265\nintr_pselect-no-syscallbuf 3 9.18344\nintr_read_no_restart 3 1.35779\nintr_read_no_restart-no-syscallbuf 3 1.29708\nintr_read_restart 3 2.37985\nintr_read_restart-no-syscallbuf 3 2.39035\nintr_sleep 3 4.16267\nintr_sleep-no-syscallbuf 3 4.15123\nintr_sleep_no_restart 3 2.02373\nintr_sleep_no_restart-no-syscallbuf 3 1.77107\ninvalid_exec 3 0.158076\ninvalid_exec-no-syscallbuf 3 0.151837\ninvalid_fcntl 3 0.162009\ninvalid_fcntl-no-syscallbuf 3 0.146827\ninvalid_ioctl 3 0.163682\ninvalid_ioctl-no-syscallbuf 3 0.156615\nio 3 0.15664\nio-no-syscallbuf 3 0.148634\nio_uring 3 0.1553\nio_uring-no-syscallbuf 3 0.183143\nioctl 3 0.160556\nioctl-no-syscallbuf 3 0.151208\nioctl_blk 3 0.156395\nioctl_blk-no-syscallbuf 3 0.158194\nioctl_fb 3 0.167029\nioctl_fb-no-syscallbuf 3 0.162058\nioctl_fs 3 0.169586\nioctl_fs-no-syscallbuf 3 0.169723\nioctl_pty 3 0.19172\nioctl_pty-no-syscallbuf 3 0.17487\nioctl_sg 3 0.166832\nioctl_sg-no-syscallbuf 3 0.148805\nioctl_tty 3 0.273182\nioctl_tty-no-syscallbuf 3 0.181178\nioctl_vt 3 0.198363\nioctl_vt-no-syscallbuf 3 0.147784\nioprio 3 0.151776\nioprio-no-syscallbuf 3 0.159645\nx86/ioperm 3 0.16163\nx86/ioperm-no-syscallbuf 3 0.147295\nx86/iopl 3 0.161969\nx86/iopl-no-syscallbuf 3 0.157894\njoin_threads 3 4.08561\njoin_threads-no-syscallbuf 3 3.21145\njoystick 3 0.148518\njoystick-no-syscallbuf 3 0.168141\nkcmp 3 0.174444\nkcmp-no-syscallbuf 3 0.15277\nkeyctl 3 0.189017\nkeyctl-no-syscallbuf 3 0.159288\nkill_newborn 3 0.361927\nkill_newborn-no-syscallbuf 3 0.305505\nkill_ptracee 3 1.28076\nkill_ptracee-no-syscallbuf 3 1.25036\nlarge_hole 3 0.16602\nlarge_hole-no-syscallbuf 3 0.153725\nlarge_write_deadlock 3 0.181911\nlarge_write_deadlock-no-syscallbuf 3 0.17404\nlegacy_ugid 3 0.1513\nlegacy_ugid-no-syscallbuf 3 0.157001\nx86/lsl 3 0.154411\nx86/lsl-no-syscallbuf 3 0.148669\nmadvise 3 0.166297\nmadvise-no-syscallbuf 3 0.173114\nmadvise_free 3 0.174214\nmadvise_free-no-syscallbuf 3 0.156153\nmadvise_wipeonfork 3 3.66742\nmadvise_wipeonfork-no-syscallbuf 3 0.269445\nmap_fixed 3 0.151788\nmap_fixed-no-syscallbuf 3 0.16034\nmap_shared_syscall 3 0.165261\nmap_shared_syscall-no-syscallbuf 3 0.154912\nmembarrier 3 0.193292\nmembarrier-no-syscallbuf 3 0.192042\nmemfd_create 3 0.16205\nmemfd_create-no-syscallbuf 3 0.150445\nmemfd_create_shared 3 0.184875\nmemfd_create_shared-no-syscallbuf 3 0.152934\nmemfd_create_shared_huge 3 0.166387\nmemfd_create_shared_huge-no-syscallbuf 3 0.183357\nmincore 3 0.161753\nmincore-no-syscallbuf 3 0.166001\nmknod 3 0.164454\nmknod-no-syscallbuf 3 0.16799\nmlock 3 0.157979\nmlock-no-syscallbuf 3 0.150461\nmmap_adjacent_to_rr_usage 3 0.164043\nmmap_adjacent_to_rr_usage-no-syscallbuf 3 0.170133\nmmap_private 3 1.05677\nmmap_private-no-syscallbuf 3 1.00645\nmmap_private_grow_under_map 3 0.173552\nmmap_private_grow_under_map-no-syscallbuf 3 0.142529\nmmap_recycle 3 0.182601\nmmap_recycle-no-syscallbuf 3 0.201383\nmmap_ro 3 0.163455\nmmap_ro-no-syscallbuf 3 0.150009\nmmap_self_maps_shared 3 0.209532\nmmap_self_maps_shared-no-syscallbuf 3 0.252583\nmmap_shared 3 0.178129\nmmap_shared-no-syscallbuf 3 0.188647\nmmap_shared_dev_zero 3 0.179758\nmmap_shared_dev_zero-no-syscallbuf 3 0.158756\nmmap_shared_grow 3 0.158899\nmmap_shared_grow-no-syscallbuf 3 0.155628\nmmap_shared_grow_under_map 3 0.17396\nmmap_shared_grow_under_map-no-syscallbuf 3 0.149174\nmmap_shared_multiple 3 0.169186\nmmap_shared_multiple-no-syscallbuf 3 0.14368\nmmap_shared_subpage 3 0.190767\nmmap_shared_subpage-no-syscallbuf 3 0.197527\nmmap_shared_write 3 6.98721\nmmap_shared_write-no-syscallbuf 3 7.85066\nmmap_shared_write_fork 3 0.221389\nmmap_shared_write_fork-no-syscallbuf 3 2.86303\nmmap_short_file 3 0.176901\nmmap_short_file-no-syscallbuf 3 0.155923\nmmap_write_complex 3 0.175376\nmmap_write_complex-no-syscallbuf 3 0.157194\nmmap_zero_size_fd 3 0.160154\nmmap_zero_size_fd-no-syscallbuf 3 0.147295\nx86/modify_ldt 3 0.163115\nx86/modify_ldt-no-syscallbuf 3 0.155589\nmount_ns_exec 3 0.223752\nmount_ns_exec-no-syscallbuf 3 0.224786\nmount_ns_exec2 3 0.227892\nmount_ns_exec2-no-syscallbuf 3 0.238692\nmprotect 3 0.176637\nmprotect-no-syscallbuf 3 0.149591\nmprotect_heterogenous 3 0.17239\nmprotect_heterogenous-no-syscallbuf 3 0.161125\nmprotect_none 3 0.170764\nmprotect_none-no-syscallbuf 3 0.153895\nmprotect_stack 3 0.154884\nmprotect_stack-no-syscallbuf 3 0.166553\nmq 3 2.16\nmq-no-syscallbuf 3 2.1974\nmremap 3 2.05014\nmremap-no-syscallbuf 3 7.23566\nmremap_after_coalesce 3 0.163365\nmremap_after_coalesce-no-syscallbuf 3 0.186969\nmremap_grow 3 0.176338\nmremap_grow-no-syscallbuf 3 0.15289\nmremap_grow_shared 3 0.186728\nmremap_grow_shared-no-syscallbuf 3 0.15187\nmremap_non_page_size 3 0.171094\nmremap_non_page_size-no-syscallbuf 3 1.03439\nmremap_overwrite 3 0.156689\nmremap_overwrite-no-syscallbuf 3 0.146222\nmremap_private_grow_under_map 3 0.157212\nmremap_private_grow_under_map-no-syscallbuf 3 0.166445\nmremap_shrink 3 0.168334\nmremap_shrink-no-syscallbuf 3 0.149695\nmsg 3 1.71135\nmsg-no-syscallbuf 3 1.67623\nmsg_trunc 3 0.161656\nmsg_trunc-no-syscallbuf 3 0.166105\nmsync 3 1.04228\nmsync-no-syscallbuf 3 1.55702\nmtio 3 0.155943\nmtio-no-syscallbuf 3 0.162524\nmultiple_pending_signals 3 0.208215\nmultiple_pending_signals-no-syscallbuf 3 0.183328\nmultiple_pending_signals_sequential 3 0.198208\nmultiple_pending_signals_sequential-no-syscallbuf 3 0.208821\nmunmap_segv 3 0.170282\nmunmap_segv-no-syscallbuf 3 0.159075\nmunmap_discontinuous 3 0.16428\nmunmap_discontinuous-no-syscallbuf 3 0.150675\nnanosleep 3 1.15837\nnanosleep-no-syscallbuf 3 1.1456\nnetfilter 3 0.177477\nnetfilter-no-syscallbuf 3 0.228226\nnetlink_mmap_disable 3 0.159134\nnetlink_mmap_disable-no-syscallbuf 3 0.150545\nno_mask_timeslice 3 0.753243\nno_mask_timeslice-no-syscallbuf 3 0.65877\nnscd 3 0.161502\nnscd-no-syscallbuf 3 0.157484\nnuma 3 0.16366\nnuma-no-syscallbuf 3 0.170196\nx86/old_fork 3 0.160469\nx86/old_fork-no-syscallbuf 3 0.180753\norphan_process 3 0.18387\norphan_process-no-syscallbuf 3 0.183225\npacket_mmap_disable 3 0.163229\npacket_mmap_disable-no-syscallbuf 3 0.170774\npause 3 1.14168\npause-no-syscallbuf 3 1.15297\nperf_event 3 0.183064\nperf_event-no-syscallbuf 3 0.16078\npersonality 3 0.177953\npersonality-no-syscallbuf 3 0.170125\npid_ns_kill_child 3 0.381137\npid_ns_kill_child-no-syscallbuf 3 0.240087\npid_ns_kill_child_threads 3 0.20782\npid_ns_kill_child_threads-no-syscallbuf 3 0.19151\npid_ns_kill_child_zombie 3 0.234559\npid_ns_kill_child_zombie-no-syscallbuf 3 0.178648\npid_ns_kill_threads 3 0.250399\npid_ns_kill_threads-no-syscallbuf 3 0.204639\npid_ns_kill_threads_exit_wait 3 0.263656\npid_ns_kill_threads_exit_wait-no-syscallbuf 3 0.241576\npid_ns_reap 3 0.231407\npid_ns_reap-no-syscallbuf 3 0.219442\npid_ns_segv 3 0.247395\npid_ns_segv-no-syscallbuf 3 0.238687\npid_ns_shutdown 3 0.390584\npid_ns_shutdown-no-syscallbuf 3 0.358182\npidfd 3 0.20572\npidfd-no-syscallbuf 3 0.164093\nx86/pkeys 3 0.169784\nx86/pkeys-no-syscallbuf 3 0.140272\npoll_sig_race 3 2.89585\npoll_sig_race-no-syscallbuf 3 2.83986\nppoll 3 5.70976\nppoll-no-syscallbuf 3 5.71209\nprctl 3 0.182093\nprctl-no-syscallbuf 3 0.184639\nprctl_caps 3 0.461576\nprctl_caps-no-syscallbuf 3 0.364208\nprctl_deathsig 3 0.180646\nprctl_deathsig-no-syscallbuf 3 0.157487\nprctl_name 3 0.252168\nprctl_name-no-syscallbuf 3 0.243093\nprctl_short_name 3 0.182303\nprctl_short_name-no-syscallbuf 3 0.157695\nprctl_speculation_ctrl 3 0.168457\nprctl_speculation_ctrl-no-syscallbuf 3 0.145312\nx86/prctl_tsc 3 0.169962\nx86/prctl_tsc-no-syscallbuf 3 0.169196\nprivileged_net_ioctl 3 0.312798\nprivileged_net_ioctl-no-syscallbuf 3 0.35125\nproc_fds 3 0.853602\nproc_fds-no-syscallbuf 3 0.776133\nproc_mem 3 0.343661\nproc_mem-no-syscallbuf 3 0.313879\nprotect_rr_fds 3 4.2672\nprotect_rr_fds-no-syscallbuf 3 4.24387\nprw 3 0.154393\nprw-no-syscallbuf 3 0.178059\npthread_condvar_locking 3 0.168729\npthread_condvar_locking-no-syscallbuf 3 0.182665\npthread_mutex_timedlock 3 0.146394\npthread_mutex_timedlock-no-syscallbuf 3 0.157668\npthread_pi_mutex 3 0.172794\npthread_pi_mutex-no-syscallbuf 3 0.150446\npthread_rwlocks 3 0.18842\npthread_rwlocks-no-syscallbuf 3 0.171502\nx86/ptrace 3 0.203384\nx86/ptrace-no-syscallbuf 3 0.193072\nptrace_attach_null_status 3 0.216968\nptrace_attach_null_status-no-syscallbuf 3 0.214387\nptrace_attach_running 3 0.301554\nptrace_attach_running-no-syscallbuf 3 0.296038\nptrace_attach_sleeping 3 0.223261\nptrace_attach_sleeping-no-syscallbuf 3 0.195324\nptrace_attach_stopped 3 0.216737\nptrace_attach_stopped-no-syscallbuf 3 0.208754\nptrace_attach_thread_running 3 7.25312\nptrace_attach_thread_running-no-syscallbuf 3 8.20121\nptrace_breakpoint 3 0.192547\nptrace_breakpoint-no-syscallbuf 3 0.17809\nptrace_change_patched_syscall 3 0.183003\nptrace_change_patched_syscall-no-syscallbuf 3 0.17081\nx86/ptrace_debug_regs 3 0.175538\nx86/ptrace_debug_regs-no-syscallbuf 3 0.165851\nptrace_exec 3 0.281701\nptrace_exec-no-syscallbuf 3 0.273225\nx86/ptrace_exec32 3 0.163584\nx86/ptrace_exec32-no-syscallbuf 3 0.155955\nptrace_kill_grandtracee 3 0.178142\nptrace_kill_grandtracee-no-syscallbuf 3 0.187404\nx86/ptrace_tls 3 0.219246\nx86/ptrace_tls-no-syscallbuf 3 0.20432\nptrace_seize 3 0.178107\nptrace_seize-no-syscallbuf 3 0.169647\nptrace_sigchld_blocked 3 0.172059\nptrace_sigchld_blocked-no-syscallbuf 3 0.154022\nptrace_signals 3 0.270799\nptrace_signals-no-syscallbuf 3 0.232762\nptrace_singlestep 3 0.397147\nptrace_singlestep-no-syscallbuf 3 0.176721\nptrace_syscall 3 0.195\nptrace_syscall-no-syscallbuf 3 0.174687\nptrace_syscall_clone_untraced 3 0.231657\nptrace_syscall_clone_untraced-no-syscallbuf 3 0.242292\nx86/ptrace_sysemu 3 0.248957\nx86/ptrace_sysemu-no-syscallbuf 3 0.230749\nptrace_sysemu_syscall 3 0.201321\nptrace_sysemu_syscall-no-syscallbuf 3 0.170117\nptrace_trace_clone 3 0.21894\nptrace_trace_clone-no-syscallbuf 3 0.205261\nptrace_trace_exit 3 0.178731\nptrace_trace_exit-no-syscallbuf 3 0.174462\nptrace_traceme 3 0.202485\nptrace_traceme-no-syscallbuf 3 0.168764\nptracer_death 3 0.21575\nptracer_death-no-syscallbuf 3 0.205591\nptracer_death_multithread 3 0.42858\nptracer_death_multithread-no-syscallbuf 3 0.543963\nptracer_death_multithread_peer 3 0.409316\nptracer_death_multithread_peer-no-syscallbuf 3 0.411511\nquotactl 3 0.197055\nquotactl-no-syscallbuf 3 0.175854\nx86/rdtsc 3 0.23707\nx86/rdtsc-no-syscallbuf 3 0.221782\nread_nothing 3 7.95296\nread_nothing-no-syscallbuf 3 13.0242\nreaddir 3 0.164987\nreaddir-no-syscallbuf 3 0.159109\nread_large 3 0.409282\nread_large-no-syscallbuf 3 1.37766\nread_oversize 3 0.163473\nread_oversize-no-syscallbuf 3 0.157164\nreadlink 3 0.166481\nreadlink-no-syscallbuf 3 0.18727\nreadlinkat 3 0.162334\nreadlinkat-no-syscallbuf 3 0.171786\nreadv 3 0.176152\nreadv-no-syscallbuf 3 0.16353\nrecord_replay_subject 3 3.42196\nrecord_replay_subject-no-syscallbuf 3 3.41249\nrecvfrom 3 0.15454\nrecvfrom-no-syscallbuf 3 0.177744\nredzone_integrity 3 1.13301\nredzone_integrity-no-syscallbuf 3 1.13952\nrename 3 0.166925\nrename-no-syscallbuf 3 0.150449\nrlimit 3 0.173492\nrlimit-no-syscallbuf 3 0.155836\nrobust_futex 3 0.19713\nrobust_futex-no-syscallbuf 3 0.188571\nrusage 3 0.164429\nrusage-no-syscallbuf 3 0.147817\nsamask 3 0.302997\nsamask-no-syscallbuf 3 0.259254\nsave_data_fd 3 0.161685\nsave_data_fd-no-syscallbuf 3 0.151627\nsched_attr 3 0.161715\nsched_attr-no-syscallbuf 3 0.168602\nsched_setaffinity 3 0.166564\nsched_setaffinity-no-syscallbuf 3 0.15648\nsched_setparam 3 0.162107\nsched_setparam-no-syscallbuf 3 0.147661\nsched_yield 3 0.2494\nsched_yield-no-syscallbuf 3 0.227094\nsched_yield_to_lower_priority 3 0.174122\nsched_yield_to_lower_priority-no-syscallbuf 3 0.166403\nscm_rights 3 0.661961\nscm_rights-no-syscallbuf 3 0.663789\nscratch_read 3 0.176737\nscratch_read-no-syscallbuf 3 0.171718\nseccomp 3 0.191926\nseccomp-no-syscallbuf 3 0.183121\nseccomp_cloning 3 0.16685\nseccomp_cloning-no-syscallbuf 3 0.161844\nseccomp_clone_fail 3 0.156072\nseccomp_clone_fail-no-syscallbuf 3 0.157549\nseccomp_desched 3 0.203677\nseccomp_desched-no-syscallbuf 3 0.160223\nseccomp_kill_exit 3 0.177956\nseccomp_kill_exit-no-syscallbuf 3 0.16329\nseccomp_null 3 0.159922\nseccomp_null-no-syscallbuf 3 0.188436\nseccomp_sigsys_args 3 0.160948\nseccomp_sigsys_args-no-syscallbuf 3 0.164235\nseccomp_sigsys_sigtrap 3 0.167303\nseccomp_sigsys_sigtrap-no-syscallbuf 3 0.164632\nseccomp_sigsys_syscallbuf 3 0.158658\nseccomp_sigsys_syscallbuf-no-syscallbuf 3 0.179574\nseccomp_tsync 3 0.203706\nseccomp_tsync-no-syscallbuf 3 0.17357\nseccomp_veto_exec 3 0.19662\nseccomp_veto_exec-no-syscallbuf 3 0.159613\nself_shebang 3 0.193248\nself_shebang-no-syscallbuf 3 0.206473\nself_sigint 3 0.1518\nself_sigint-no-syscallbuf 3 0.148422\nsem 3 0.230406\nsem-no-syscallbuf 3 0.199575\nsend_block 3 0.245719\nsend_block-no-syscallbuf 3 1.87236\nsendfile 3 0.176642\nsendfile-no-syscallbuf 3 0.17185\nset_ptracer 3 0.151456\nset_ptracer-no-syscallbuf 3 0.152836\nset_tid_address 3 0.188306\nset_tid_address-no-syscallbuf 3 0.172786\nsetgid 3 0.160902\nsetgid-no-syscallbuf 3 0.141594\nsetgroups 3 0.158919\nsetgroups-no-syscallbuf 3 0.149756\nsetsid 3 0.164533\nsetsid-no-syscallbuf 3 0.161501\nsetuid 3 0.30755\nsetuid-no-syscallbuf 3 0.317326\nshared_exec 3 0.154033\nshared_exec-no-syscallbuf 3 0.155572\nshared_monitor 3 0.158261\nshared_monitor-no-syscallbuf 3 0.150617\nshared_offset 3 0.197663\nshared_offset-no-syscallbuf 3 0.150751\nshared_write 3 0.166272\nshared_write-no-syscallbuf 3 0.15558\nshm 3 0.207179\nshm-no-syscallbuf 3 0.204714\nshm_unmap 3 0.174612\nshm_unmap-no-syscallbuf 3 0.151011\nsigaction_old 3 0.169635\nsigaction_old-no-syscallbuf 3 0.186299\nsigaltstack 3 0.159728\nsigaltstack-no-syscallbuf 3 0.155618\nsigchld_interrupt_signal 3 4.37595\nsigchld_interrupt_signal-no-syscallbuf 3 4.00963\nsigcont 3 0.176276\nsigcont-no-syscallbuf 3 0.167049\nsighandler_bad_rsp_sigsegv 3 0.167042\nsighandler_bad_rsp_sigsegv-no-syscallbuf 3 0.149173\nsighandler_fork 3 0.232608\nsighandler_fork-no-syscallbuf 3 0.194239\nsighandler_mask 3 0.171254\nsighandler_mask-no-syscallbuf 3 0.160348\nsigill 3 0.169078\nsigill-no-syscallbuf 3 0.142355\nsignal_deferred 3 0.18936\nsignal_deferred-no-syscallbuf 3 0.170904\nsignal_during_preload_init 3 0.18183\nsignal_during_preload_init-no-syscallbuf 3 0.171621\nsignal_frame 3 0.171874\nsignal_frame-no-syscallbuf 3 0.162511\nsignal_unstoppable 3 0.177569\nsignal_unstoppable-no-syscallbuf 3 0.157658\nsignalfd 3 0.157376\nsignalfd-no-syscallbuf 3 0.161101\nsigprocmask 3 0.526391\nsigprocmask-no-syscallbuf 3 0.518456\nsigprocmask_ensure_delivery 3 0.187085\nsigprocmask_ensure_delivery-no-syscallbuf 3 0.183378\nsigprocmask_exec 3 0.209065\nsigprocmask_exec-no-syscallbuf 3 0.198225\nsigprocmask_evil 3 0.150119\nsigprocmask_evil-no-syscallbuf 3 0.152954\nsigprocmask_in_syscallbuf_sighandler 3 1.13988\nsigprocmask_in_syscallbuf_sighandler-no-syscallbuf 3 1.13529\nsigprocmask_rr_sigs 3 0.171017\nsigprocmask_rr_sigs-no-syscallbuf 3 0.160015\nsigprocmask_syscallbuf 3 0.172349\nsigprocmask_syscallbuf-no-syscallbuf 3 0.160637\nsigqueueinfo 3 0.160929\nsigqueueinfo-no-syscallbuf 3 0.187513\nx86/sigreturn 3 0.188428\nx86/sigreturn-no-syscallbuf 3 0.200912\nsigreturn_reg 3 0.15936\nsigreturn_reg-no-syscallbuf 3 0.195472\nsigreturnmask 3 0.301815\nsigreturnmask-no-syscallbuf 3 0.268609\nsigrt 3 0.261165\nsigrt-no-syscallbuf 3 0.298723\nsigstop 3 0.228819\nsigstop-no-syscallbuf 3 0.203024\nsigstop2 3 0.177842\nsigstop2-no-syscallbuf 3 0.154846\nsigsuspend 3 0.176223\nsigsuspend-no-syscallbuf 3 0.181212\nsigtrap 3 0.185501\nsigtrap-no-syscallbuf 3 0.181996\nsimple_threads_stress 3 2.10814\nsimple_threads_stress-no-syscallbuf 3 2.74932\nsioc 3 0.469445\nsioc-no-syscallbuf 3 0.596984\nsmall_holes 3 0.168045\nsmall_holes-no-syscallbuf 3 0.145796\nsock_names_opts 3 0.182547\nsock_names_opts-no-syscallbuf 3 0.180697\nspinlock_priorities 3 0.680331\nspinlock_priorities-no-syscallbuf 3 1.27508\nsplice 3 0.171734\nsplice-no-syscallbuf 3 0.152318\nstack_growth_after_syscallbuf 3 0.161991\nstack_growth_after_syscallbuf-no-syscallbuf 3 0.158776\nstack_growth_syscallbuf 3 0.266059\nstack_growth_syscallbuf-no-syscallbuf 3 9.337\nstack_growth_with_guard 3 0.180035\nstack_growth_with_guard-no-syscallbuf 3 0.162457\nstack_invalid 3 0.175009\nstack_invalid-no-syscallbuf 3 0.15628\nstack_overflow 3 0.235214\nstack_overflow-no-syscallbuf 3 3.59651\nstack_overflow_altstack 3 0.160196\nstack_overflow_altstack-no-syscallbuf 3 0.154725\nstack_overflow_with_guard 3 0.219329\nstack_overflow_with_guard-no-syscallbuf 3 3.49059\nstatfs 3 0.161696\nstatfs-no-syscallbuf 3 0.176756\nstatx 3 0.170974\nstatx-no-syscallbuf 3 0.152931\nstdout_child 3 0.205053\nstdout_child-no-syscallbuf 3 0.221371\nstdout_cloexec 3 0.228643\nstdout_cloexec-no-syscallbuf 3 0.195781\nstdout_dup 3 0.161649\nstdout_dup-no-syscallbuf 3 0.141799\nstdout_redirect 3 0.270862\nstdout_redirect-no-syscallbuf 3 0.21584\nswitch_read 3 0.677802\nswitch_read-no-syscallbuf 3 0.660996\nsymlink 3 0.16442\nsymlink-no-syscallbuf 3 0.173125\nsync 3 0.218387\nsync-no-syscallbuf 3 0.200264\nsync_file_range 3 0.161356\nsync_file_range-no-syscallbuf 3 0.195714\nsyscall_bp 3 0.157682\nsyscall_bp-no-syscallbuf 3 0.145953\nsyscall_in_writable_mem 3 0.158828\nsyscall_in_writable_mem-no-syscallbuf 3 0.162497\nsyscallbuf_signal_reset 3 0.1669\nsyscallbuf_signal_reset-no-syscallbuf 3 0.160377\nsyscallbuf_signal_blocking 3 0.17366\nsyscallbuf_signal_blocking-no-syscallbuf 3 0.169817\nsyscallbuf_sigstop 3 9.64068\nsyscallbuf_sigstop-no-syscallbuf 3 26.3563\nsyscallbuf_timeslice 3 0.232011\nsyscallbuf_timeslice-no-syscallbuf 3 3.40972\nsyscallbuf_timeslice2 3 0.262001\nsyscallbuf_timeslice2-no-syscallbuf 3 9.18104\nsysconf 3 0.177462\nsysconf-no-syscallbuf 3 0.148994\nsysctl 3 0.169718\nsysctl-no-syscallbuf 3 0.146148\nsysemu_singlestep 3 0.158838\nsysemu_singlestep-no-syscallbuf 3 0.14519\nx86/sysfs 3 0.203504\nx86/sysfs-no-syscallbuf 3 0.209395\nsysinfo 3 0.167864\nsysinfo-no-syscallbuf 3 0.156011\ntgkill 3 0.198617\ntgkill-no-syscallbuf 3 0.169099\nthread_yield 3 4.09239\nthread_yield-no-syscallbuf 3 3.31\ntimer 3 54.6266\ntimer-no-syscallbuf 3 50.1859\ntimerfd 3 0.281036\ntimerfd-no-syscallbuf 3 0.250613\ntimes 3 0.179322\ntimes-no-syscallbuf 3 0.14615\ntruncate_temp 3 0.179651\ntruncate_temp-no-syscallbuf 3 0.17779\ntun 3 0.22692\ntun-no-syscallbuf 3 0.193409\ntwo_signals_with_mask 3 0.174087\ntwo_signals_with_mask-no-syscallbuf 3 0.159943\nulimit_low 3 0.184641\nulimit_low-no-syscallbuf 3 0.168013\nuname 3 0.163994\nuname-no-syscallbuf 3 0.149448\nunexpected_exit 3 0.231308\nunexpected_exit-no-syscallbuf 3 0.425223\nunexpected_exit_execve 3 0.256596\nunexpected_exit_execve-no-syscallbuf 3 0.398299\nunexpected_exit_execve_twice 3 1.31064\nunexpected_exit_execve_twice-no-syscallbuf 3 1.38882\nunexpected_exit_pid_ns 3 0.5777\nunexpected_exit_pid_ns-no-syscallbuf 3 0.270752\nunjoined_thread 3 0.162801\nunjoined_thread-no-syscallbuf 3 0.15667\nunshare 3 0.301114\nunshare-no-syscallbuf 3 1.33806\nuserfaultfd 3 0.156784\nuserfaultfd-no-syscallbuf 3 0.158499\nutimes 3 0.163511\nutimes-no-syscallbuf 3 0.150974\nvdso_parts 3 0.154998\nvdso_parts-no-syscallbuf 3 0.146384\nvfork_flush 3 0.173198\nvfork_flush-no-syscallbuf 3 0.152217\nvfork_shared 3 0.216045\nvfork_shared-no-syscallbuf 3 0.152351\nvideo_capture 3 0.16015\nvideo_capture-no-syscallbuf 3 0.159067\nvm_readv_writev 3 0.178576\nvm_readv_writev-no-syscallbuf 3 0.175043\nvsyscall 3 0.172098\nvsyscall-no-syscallbuf 3 0.16576\nvsyscall_timeslice 3 0.165062\nvsyscall_timeslice-no-syscallbuf 3 0.186885\nx86/x87env 3 0.167093\nx86/x87env-no-syscallbuf 3 0.180754\nwait 3 0.211953\nwait-no-syscallbuf 3 0.164549\nwait_sigstop 3 0.21506\nwait_sigstop-no-syscallbuf 3 0.173565\nwrite_race 3 2.57581\nwrite_race-no-syscallbuf 3 1.75822\nwritev 3 0.253563\nwritev-no-syscallbuf 3 0.168006\nxattr 3 0.172238\nxattr-no-syscallbuf 3 0.170306\nzero_length_read 3 0.160153\nzero_length_read-no-syscallbuf 3 0.149279\nstd_random 3 0.201614\nstd_random-no-syscallbuf 3 0.221352\nunwind_rr_page 3 1.14505\nunwind_rr_page-no-syscallbuf 3 1.13666\nabort_nonmain 3 0.359039\nabort_nonmain-no-syscallbuf 3 0.330682\nalternate_thread_diversion 3 1.57744\nalternate_thread_diversion-no-syscallbuf 3 1.13474\nargs 3 0.177209\nargs-no-syscallbuf 3 0.147602\nasync_kill_with_syscallbuf 3 2.59776\nasync_kill_with_syscallbuf-no-syscallbuf 3 3.93823\nasync_kill_with_syscallbuf2 3 2.21036\nasync_kill_with_syscallbuf2-no-syscallbuf 3 2.22822\nasync_kill_with_threads 3 2.1719\nasync_kill_with_threads-no-syscallbuf 3 2.23957\nasync_kill_with_threads_main_running 3 2.21748\nasync_kill_with_threads_main_running-no-syscallbuf 3 2.23232\nasync_kill_with_threads_thread_running 3 6.17095\nasync_kill_with_threads_thread_running-no-syscallbuf 3 6.14075\nasync_segv 3 4.55141\nasync_segv-no-syscallbuf 3 4.53096\nasync_signal_syscalls 3 1.20161\nasync_signal_syscalls-no-syscallbuf 3 0.0266551\nasync_signal_syscalls2 3 1.33672\nasync_signal_syscalls2-no-syscallbuf 3 0.0215027\nasync_signal_syscalls_siginfo 3 1.16121\nasync_signal_syscalls_siginfo-no-syscallbuf 3 0.025899\nasync_usr1 3 4.6427\nasync_usr1-no-syscallbuf 3 4.34284\nblacklist 3 0.24007\nblacklist-no-syscallbuf 3 0.159517\nblock_clone_checkpoint 3 1.06659\nblock_clone_checkpoint-no-syscallbuf 3 1.1087\nblock_clone_interrupted 3 5.4597\nblock_clone_interrupted-no-syscallbuf 3 4.53533\nblock_clone_syscallbuf_overflow 3 3.26066\nblock_clone_syscallbuf_overflow-no-syscallbuf 3 6.11108\nblock_intr_sigchld 3 6.86856\nblock_intr_sigchld-no-syscallbuf 3 5.89219\nblocked_bad_ip 3 2.25961\nblocked_bad_ip-no-syscallbuf 3 6.46548\nblocked_sigill 3 0.361856\nblocked_sigill-no-syscallbuf 3 0.363938\nx86/blocked_sigsegv 3 0.351694\nx86/blocked_sigsegv-no-syscallbuf 3 0.310531\nbreakpoint 3 1.11305\nbreakpoint-no-syscallbuf 3 1.14492\nbreakpoint_conditions 3 0.93368\nbreakpoint_conditions-no-syscallbuf 3 0.967242\nbreakpoint_overlap 3 0.924194\nbreakpoint_overlap-no-syscallbuf 3 0.93391\ncall_function 3 0.901007\ncall_function-no-syscallbuf 3 0.87467\ncall_gettid 3 0.905643\ncall_gettid-no-syscallbuf 3 0.870804\ncheckpoint_dying_threads 3 0.915922\ncheckpoint_dying_threads-no-syscallbuf 3 0.873478\ncheckpoint_mixed_mode 3 0.990307\ncheckpoint_mixed_mode-no-syscallbuf 3 1.07708\nchecksum_sanity 3 2.40068\nchecksum_sanity-no-syscallbuf 3 1.53533\ncheck_lost_interrupts 3 2.24072\ncheck_lost_interrupts-no-syscallbuf 3 0.0208667\nclone_interruption 3 1.08289\nclone_interruption-no-syscallbuf 3 1.90038\nclone_vfork 3 0.267157\nclone_vfork-no-syscallbuf 3 0.229166\nconditional_breakpoint_calls 3 0.917675\nconditional_breakpoint_calls-no-syscallbuf 3 0.942403\nconditional_breakpoint_offload 3 66.8135\nconditional_breakpoint_offload-no-syscallbuf 3 63.8071\ncondvar_stress 3 19.5301\ncondvar_stress-no-syscallbuf 3 27.9413\ncont_race 3 12.5732\ncont_race-no-syscallbuf 3 40.7727\nx86/cpuid_singlestep 3 0.828577\nx86/cpuid_singlestep-no-syscallbuf 3 0.845506\ncrash 3 0.31033\ncrash-no-syscallbuf 3 0.297819\ncrash_in_function 3 2.74531\ncrash_in_function-no-syscallbuf 3 4.74481\ndaemon_read 3 0.269816\ndaemon_read-no-syscallbuf 3 0.21177\ndconf_mock 3 0.176625\ndconf_mock-no-syscallbuf 3 0.17023\ndev_tty 3 0.155365\ndev_tty-no-syscallbuf 3 0.138834\ndiversion_sigtrap 3 10.6187\ndiversion_sigtrap-no-syscallbuf 3 9.65374\ndiversion_syscall 3 1.04017\ndiversion_syscall-no-syscallbuf 3 1.023\ndlopen 3 5.85379\ndlopen-no-syscallbuf 3 4.56277\nearly_error 3 0.329303\nearly_error-no-syscallbuf 3 0.335078\nelapsed_time 3 1.84526\nelapsed_time-no-syscallbuf 3 1.82311\nexclusion_region 3 2.95212\nexclusion_region-no-syscallbuf 3 2.16854\nexec_failed 3 0.846901\nexec_failed-no-syscallbuf 3 0.845736\nexec_many 3 6.58017\nexec_many-no-syscallbuf 3 10.9563\nexecve_loop 3 6.68547\nexecve_loop-no-syscallbuf 3 4.94738\nexit_codes 3 0.364494\nexit_codes-no-syscallbuf 3 0.338858\nexit_group 3 0.167024\nexit_group-no-syscallbuf 3 0.171674\nexit_race 3 1.9038\nexit_race-no-syscallbuf 3 1.25688\nexit_status 3 0.114959\nexit_status-no-syscallbuf 3 0.104345\nx86/explicit_checkpoints 3 1.95774\nx86/explicit_checkpoints-no-syscallbuf 3 1.94198\nfd_limit 3 0.203426\nfd_limit-no-syscallbuf 3 0.987276\nfork_stress 3 1.69422\nfork_stress-no-syscallbuf 3 1.13269\nfork_syscalls 3 0.164541\nfork_syscalls-no-syscallbuf 3 0.198481\nfunction_calls 3 2.54722\nfunction_calls-no-syscallbuf 3 2.43375\nx86/fxregs 3 0.860057\nx86/fxregs-no-syscallbuf 3 0.870847\ngetcwd 3 0.148878\ngetcwd-no-syscallbuf 3 0.154948\ngdb_bogus_breakpoint 3 0.843596\ngdb_bogus_breakpoint-no-syscallbuf 3 0.856495\ngoto_event 3 3.06602\ngoto_event-no-syscallbuf 3 3.03297\nhello 3 0.174916\nhello-no-syscallbuf 3 0.154474\nhooks 3 0.850872\nhooks-no-syscallbuf 3 0.0219273\nignored_async_usr1 3 3.37766\nignored_async_usr1-no-syscallbuf 3 2.07633\nignored_sigsegv 3 0.382166\nignored_sigsegv-no-syscallbuf 3 0.358145\nignore_nested 3 0.290748\nignore_nested-no-syscallbuf 3 0.305353\nimmediate_restart 3 1.02683\nimmediate_restart-no-syscallbuf 3 1.0017\nx86/int3_ok 3 0.167423\nx86/int3_ok-no-syscallbuf 3 0.147515\ninterrupt 3 4.95536\ninterrupt-no-syscallbuf 3 4.72557\nintr_ptrace_decline 3 4.7439\nintr_ptrace_decline-no-syscallbuf 3 4.70112\ninvalid_interpreter 3 4.37543\ninvalid_interpreter-no-syscallbuf 3 3.48256\ninvalid_jump 3 2.54397\ninvalid_jump-no-syscallbuf 3 1.63359\njit_proc_mem 3 0.904904\njit_proc_mem-no-syscallbuf 3 0.883142\nlink 3 0.169285\nlink-no-syscallbuf 3 0.170742\nmadvise_dontfork 3 1.14195\nmadvise_dontfork-no-syscallbuf 3 1.0685\nmain_thread_exit 3 1.1676\nmain_thread_exit-no-syscallbuf 3 1.13967\nmany_yields 3 3.15188\nmany_yields-no-syscallbuf 3 2.78943\nmmap_fd_reuse_checkpoint 3 1.11664\nmmap_fd_reuse_checkpoint-no-syscallbuf 3 1.09184\nmmap_replace_most_mappings 3 1.77734\nmmap_replace_most_mappings-no-syscallbuf 3 1.84276\nmmap_shared_prot 3 1.06173\nmmap_shared_prot-no-syscallbuf 3 1.10953\nmmap_shared_write_exec_race 3 1.19321\nmmap_shared_write_exec_race-no-syscallbuf 3 3.79371\nmmap_tmpfs 3 0.173133\nmmap_tmpfs-no-syscallbuf 3 0.159476\nmmap_write 3 0.0216368\nmmap_write-no-syscallbuf 3 0.0215376\nmmap_write_private 3 0.288292\nmmap_write_private-no-syscallbuf 3 0.256622\nmorestack_unwind 1 0.810541\nmorestack_unwind-no-syscallbuf 1 0.0187404\nmprotect_growsdown 3 0.294224\nmprotect_growsdown-no-syscallbuf 3 0.268717\nmprotect_syscallbuf_overflow 3 0.281185\nmprotect_syscallbuf_overflow-no-syscallbuf 3 12.2115\nmutex_pi_stress 3 23.7823\nmutex_pi_stress-no-syscallbuf 3 27.247\nnested_detach_wait 3 0.50088\nnested_detach_wait-no-syscallbuf 3 0.510102\noverflow_branch_counter 3 2.81702\noverflow_branch_counter-no-syscallbuf 3 2.87377\npatch_page_end 3 0.1791\npatch_page_end-no-syscallbuf 3 0.0231666\nx86/patch_40_80_f6_81 3 0.170802\nx86/patch_40_80_f6_81-no-syscallbuf 3 0.021558\nperf_event_mmap 3 0.978108\nperf_event_mmap-no-syscallbuf 3 1.03341\npriority 3 0.16131\npriority-no-syscallbuf 3 0.157811\nptrace_remote_unmap 3 3.76436\nptrace_remote_unmap-no-syscallbuf 3 3.04355\nread_big_struct 3 0.891689\nread_big_struct-no-syscallbuf 3 0.890305\nremove_latest_trace 3 1.23464\nremove_latest_trace-no-syscallbuf 3 1.18878\nrestart_abnormal_exit 3 1.27785\nrestart_abnormal_exit-no-syscallbuf 3 1.25203\nreverse_continue_breakpoint 3 1.6634\nreverse_continue_breakpoint-no-syscallbuf 3 1.55189\nreverse_continue_multiprocess 3 10.3054\nreverse_continue_multiprocess-no-syscallbuf 3 9.46503\nreverse_continue_process_signal 3 2.79022\nreverse_continue_process_signal-no-syscallbuf 3 2.83602\nreverse_many_breakpoints 3 3.43429\nreverse_many_breakpoints-no-syscallbuf 3 3.17411\nreverse_step_long 3 5.2054\nreverse_step_long-no-syscallbuf 3 6.35501\nreverse_step_threads 3 2.90159\nreverse_step_threads-no-syscallbuf 3 3.05253\nreverse_step_threads_break 3 3.47602\nreverse_step_threads_break-no-syscallbuf 3 2.58121\nrr_ps 3 0.350603\nrr_ps-no-syscallbuf 3 0.303961\nrr_ps_ns 3 0.191974\nrr_ps_ns-no-syscallbuf 3 0.169622\nrseq 3 16.6959\nrseq-no-syscallbuf 3 16.5372\nsearch 3 0.89271\nsearch-no-syscallbuf 3 0.870175\nseccomp_blocks_rr 3 0.303424\nseccomp_blocks_rr-no-syscallbuf 3 0.151506\nseccomp_signals 3 2.24617\nseccomp_signals-no-syscallbuf 3 1.80499\nsegfault 3 0.167595\nsegfault-no-syscallbuf 3 0.158185\nshared_map 3 0.206508\nshared_map-no-syscallbuf 3 0.209229\nshared_persistent_file 3 1.118\nshared_persistent_file-no-syscallbuf 3 1.10357\nsignal_numbers 3 1.09917\nsignal_numbers-no-syscallbuf 3 1.09911\nsigprocmask_race 3 0.172178\nsigprocmask_race-no-syscallbuf 3 0.0254089\nsigprocmask_rr_sigs_nondefault 3 0.0987354\nsigprocmask_rr_sigs_nondefault-no-syscallbuf 3 0.0967041\nsimple 3 0.262466\nsimple-no-syscallbuf 3 0.236866\nx86/singlestep_pushf 3 0.857486\nx86/singlestep_pushf-no-syscallbuf 3 0.86649\nstack_growth 3 0.865849\nstack_growth-no-syscallbuf 3 0.862781\nstep_thread 3 2.19503\nstep_thread-no-syscallbuf 3 1.22219\nstrict_priorities 3 10.3645\nstrict_priorities-no-syscallbuf 3 11.1165\nx86/string_instructions 3 0.609023\nx86/string_instructions-no-syscallbuf 3 0.685759\nx86/string_instructions_async_signals 3 0.207032\nx86/string_instructions_async_signals-no-syscallbuf 3 47.6509\nx86/string_instructions_async_signals_shared 3 0.243325\nx86/string_instructions_async_signals_shared-no-syscallbuf 3 64.5042\nx86/string_instructions_multiwatch 3 0.902929\nx86/string_instructions_multiwatch-no-syscallbuf 3 0.863364\nx86/string_instructions_replay 3 13.1062\nx86/string_instructions_replay-no-syscallbuf 3 13.3725\nx86/string_instructions_singlestep_fastforward 3 11.3088\nx86/string_instructions_singlestep_fastforward-no-syscallbuf 3 10.5199\nx86/string_instructions_watch 3 0.894201\nx86/string_instructions_watch-no-syscallbuf 3 0.869626\nsyscallbuf_fd_disabling 3 0.23601\nsyscallbuf_fd_disabling-no-syscallbuf 3 0.210209\nsyscallbuf_signal_blocking_read 3 0.994903\nsyscallbuf_signal_blocking_read-no-syscallbuf 3 1.32862\nsysconf_onln 3 0.329179\nsysconf_onln-no-syscallbuf 3 0.301906\ntarget_fork 3 1.72084\ntarget_fork-no-syscallbuf 3 1.61481\ntarget_process 3 1.60957\ntarget_process-no-syscallbuf 3 1.47944\ntcp_sockets 3 0.142919\ntcp_sockets-no-syscallbuf 3 0.147933\nterm_nonmain 3 0.166076\nterm_nonmain-no-syscallbuf 3 0.186748\nterm_rr 3 4.21286\nterm_rr-no-syscallbuf 3 4.20073\nterm_trace_reset 3 0.213788\nterm_trace_reset-no-syscallbuf 3 0.197926\nterm_trace_syscall 3 0.222559\nterm_trace_syscall-no-syscallbuf 3 0.211105\nthread_exit_signal 3 3.06793\nthread_exit_signal-no-syscallbuf 3 3.15729\nthread_open_race 3 48.2834\nthread_open_race-no-syscallbuf 3 0.0215275\nthread_stress 3 18.203\nthread_stress-no-syscallbuf 3 19.9251\nthreaded_syscall_spam 3 1.19269\nthreaded_syscall_spam-no-syscallbuf 3 0.0218339\nthreads 3 1.20615\nthreads-no-syscallbuf 3 1.14746\ntls 3 0.90699\ntls-no-syscallbuf 3 0.881923\nttyname 3 0.150335\nttyname-no-syscallbuf 3 0.147432\nunexpected_stack_growth 3 6.57491\nunexpected_stack_growth-no-syscallbuf 3 1.01145\nuser_ignore_sig 3 0.167483\nuser_ignore_sig-no-syscallbuf 3 0.150179\nvdso_clock_gettime_stack 3 1.33203\nvdso_clock_gettime_stack-no-syscallbuf 3 0.0214651\nvdso_gettimeofday_stack 3 1.37839\nvdso_gettimeofday_stack-no-syscallbuf 3 0.0211004\nvdso_time_stack 3 1.11583\nvdso_time_stack-no-syscallbuf 3 0.0211016\nvfork 3 0.238179\nvfork-no-syscallbuf 3 0.216255\nvfork_read_clone_stress 3 2.13853\nvfork_read_clone_stress-no-syscallbuf 3 1.46609\nvsyscall_reverse_next 3 3.05977\nvsyscall_reverse_next-no-syscallbuf 3 2.77844\nwait_for_all 3 1.13809\nwait_for_all-no-syscallbuf 3 1.13027\nwatchpoint 3 1.36864\nwatchpoint-no-syscallbuf 3 1.41259\nwatchpoint_at_sched 3 1.2043\nwatchpoint_at_sched-no-syscallbuf 3 1.79064\nwatchpoint_before_signal 3 0.891807\nwatchpoint_before_signal-no-syscallbuf 3 0.857241\nwatchpoint_no_progress 3 2.28605\nwatchpoint_no_progress-no-syscallbuf 3 1.50392\nwatchpoint_size_change 3 0.891056\nwatchpoint_size_change-no-syscallbuf 3 0.887724\nwatchpoint_syscall 3 1.02153\nwatchpoint_syscall-no-syscallbuf 3 0.909816\nwatchpoint_unaligned 3 1.23545\nwatchpoint_unaligned-no-syscallbuf 3 1.21433\nasync_signal_syscalls_100 3 0.202603\nasync_signal_syscalls_100-no-syscallbuf 3 3.8296\nasync_signal_syscalls_1000 3 0.188268\nasync_signal_syscalls_1000-no-syscallbuf 3 3.62992\nbad_breakpoint 3 9.76737\nbad_breakpoint-no-syscallbuf 3 9.30115\nbreak_block 3 9.95194\nbreak_block-no-syscallbuf 3 9.95062\nbreak_clock 3 0.958868\nbreak_clock-no-syscallbuf 3 1.13506\nbreak_clone 3 0.842634\nbreak_clone-no-syscallbuf 3 0.83947\nbreak_exec 3 0.979672\nbreak_exec-no-syscallbuf 3 0.883294\nbreak_int3 3 0.838053\nbreak_int3-no-syscallbuf 3 0.817321\nbreak_mmap_private 3 2.21591\nbreak_mmap_private-no-syscallbuf 3 2.3374\nbreak_msg 3 2.32206\nbreak_msg-no-syscallbuf 3 2.30288\nx86/break_rdtsc 3 0.889362\nx86/break_rdtsc-no-syscallbuf 3 0.871792\nbreak_sigreturn 3 4.83707\nbreak_sigreturn-no-syscallbuf 3 4.82174\nbreak_sync_signal 3 0.85105\nbreak_sync_signal-no-syscallbuf 3 0.888775\nbreak_thread 3 0.960811\nbreak_thread-no-syscallbuf 3 0.937708\nbreak_time_slice 3 8.95734\nbreak_time_slice-no-syscallbuf 3 9.1059\nbreakpoint_consistent 3 0.853028\nbreakpoint_consistent-no-syscallbuf 3 0.843801\ncall_exit 3 1.17147\ncall_exit-no-syscallbuf 3 1.17408\ncheck_patched_pthread 3 2.07588\ncheck_patched_pthread-no-syscallbuf 3 1.8827\ncheckpoint_async_signal_syscalls_1000 3 3.29167\ncheckpoint_async_signal_syscalls_1000-no-syscallbuf 3 0.0219982\ncheckpoint_mmap_shared 3 23.8657\ncheckpoint_mmap_shared-no-syscallbuf 3 18.2314\ncheckpoint_prctl_name 3 33.8154\ncheckpoint_prctl_name-no-syscallbuf 3 31.0433\ncheckpoint_simple 3 11.4629\ncheckpoint_simple-no-syscallbuf 3 13.5317\nchecksum_sanity_noclone 3 2.28681\nchecksum_sanity_noclone-no-syscallbuf 3 1.70638\ncomm 3 0.634081\ncomm-no-syscallbuf 3 0.7202\ncont_signal 3 4.92468\ncont_signal-no-syscallbuf 3 4.92682\nx86/cpuid 3 1.06468\nx86/cpuid-no-syscallbuf 3 1.065\ndead_thread_target 3 1.16267\ndead_thread_target-no-syscallbuf 3 1.0941\ndesched_ticks 3 0.896582\ndesched_ticks-no-syscallbuf 3 0.021897\ndeliver_async_signal_during_syscalls 3 0.661812\ndeliver_async_signal_during_syscalls-no-syscallbuf 3 0.0206239\nenv_newline 3 0.155365\nenv_newline-no-syscallbuf 3 0.15244\nexec_deleted 3 0.154572\nexec_deleted-no-syscallbuf 3 0.141445\nexec_stop 3 0.927636\nexec_stop-no-syscallbuf 3 0.902712\nexecp 3 0.162819\nexecp-no-syscallbuf 3 0.152149\nexplicit_checkpoint_clone 3 1.09532\nexplicit_checkpoint_clone-no-syscallbuf 3 1.06678\nfile_name_newline 3 0.175127\nfile_name_newline-no-syscallbuf 3 0.170133\nfinal_sigkill 3 1.1112\nfinal_sigkill-no-syscallbuf 3 1.08854\nfirst_instruction 3 6.4099\nfirst_instruction-no-syscallbuf 3 5.80319\nfork_exec_info_thr 3 3.28546\nfork_exec_info_thr-no-syscallbuf 3 3.18561\nget_thread_list 3 1.07744\nget_thread_list-no-syscallbuf 3 1.07444\nhardlink_mmapped_files 3 2.20039\nhardlink_mmapped_files-no-syscallbuf 3 2.21085\nhbreak 3 0.923998\nhbreak-no-syscallbuf 3 0.984052\nmprotect_step 3 1.12762\nmprotect_step-no-syscallbuf 3 1.11766\nnested_detach 3 2.06587\nnested_detach-no-syscallbuf 3 2.05377\nnested_detach_kill 3 0.514043\nnested_detach_kill-no-syscallbuf 3 0.506464\nnested_release 3 0.351153\nnested_release-no-syscallbuf 3 0.286465\nparent_no_break_child_bkpt 3 2.25801\nparent_no_break_child_bkpt-no-syscallbuf 3 1.68964\nparent_no_stop_child_crash 3 3.8874\nparent_no_stop_child_crash-no-syscallbuf 3 3.06564\npost_exec_fpu_regs 3 0.625056\npost_exec_fpu_regs-no-syscallbuf 3 0.618626\nproc_maps 3 0.835174\nproc_maps-no-syscallbuf 3 0.875045\nread_bad_mem 3 0.852118\nread_bad_mem-no-syscallbuf 3 0.832199\nrecord_replay 3 135.637\nrecord_replay-no-syscallbuf 3 150.387\nremove_watchpoint 3 0.934846\nremove_watchpoint-no-syscallbuf 3 0.914737\nreplay_overlarge_event_number 3 0.166307\nreplay_overlarge_event_number-no-syscallbuf 3 0.142443\nreplay_serve_files 3 3.61885\nreplay_serve_files-no-syscallbuf 3 3.61468\nrestart_invalid_checkpoint 3 1.20532\nrestart_invalid_checkpoint-no-syscallbuf 3 1.241\nrestart_unstable 3 1.12942\nrestart_unstable-no-syscallbuf 3 1.06681\nrestart_diversion 3 1.34119\nrestart_diversion-no-syscallbuf 3 1.25404\nreverse_alarm 3 4.39127\nreverse_alarm-no-syscallbuf 3 5.23622\nreverse_continue_exec_subprocess 3 1.9878\nreverse_continue_exec_subprocess-no-syscallbuf 3 2.34593\nreverse_continue_fork_subprocess 3 1.21381\nreverse_continue_fork_subprocess-no-syscallbuf 3 1.2511\nreverse_continue_int3 3 2.87374\nreverse_continue_int3-no-syscallbuf 3 4.17258\nreverse_continue_start 3 2.42242\nreverse_continue_start-no-syscallbuf 3 1.90444\nreverse_finish 3 2.42719\nreverse_finish-no-syscallbuf 3 1.55052\nreverse_step_breakpoint 3 2.57344\nreverse_step_breakpoint-no-syscallbuf 3 2.76297\nreverse_step_signal 3 3.23417\nreverse_step_signal-no-syscallbuf 3 3.38695\nreverse_step_threads2 3 3.82985\nreverse_step_threads2-no-syscallbuf 3 3.91421\nreverse_watchpoint 3 2.84927\nreverse_watchpoint-no-syscallbuf 3 2.85867\nreverse_watchpoint_syscall 3 5.70676\nreverse_watchpoint_syscall-no-syscallbuf 3 5.29028\nrun_end 3 1.43338\nrun_end-no-syscallbuf 3 1.4049\nrun_in_function 3 1.0343\nrun_in_function-no-syscallbuf 3 1.13816\nsanity 3 0.935729\nsanity-no-syscallbuf 3 0.779338\nseekticks 3 2.28586\nseekticks-no-syscallbuf 3 2.43285\nshm_checkpoint 3 1.12118\nshm_checkpoint-no-syscallbuf 3 1.07186\nsiginfo 3 0.774631\nsiginfo-no-syscallbuf 3 0.83633\nx86/sigreturn_checksum 3 0.700085\nx86/sigreturn_checksum-no-syscallbuf 3 0.665849\nsignal_stop 3 0.871721\nsignal_stop-no-syscallbuf 3 0.850539\nsignal_checkpoint 3 1.1177\nsignal_checkpoint-no-syscallbuf 3 1.07433\nsimple_script 3 0.171676\nsimple_script-no-syscallbuf 3 0.166602\nsimple_script_debug 3 0.83504\nsimple_script_debug-no-syscallbuf 3 0.843184\nsimple_winch 3 2.38524\nsimple_winch-no-syscallbuf 3 1.88033\nstack_overflow_debug 3 5.67621\nstack_overflow_debug-no-syscallbuf 3 5.43747\nstep1 3 0.863026\nstep1-no-syscallbuf 3 0.899019\nx86/step_rdtsc 3 0.996719\nx86/step_rdtsc-no-syscallbuf 3 0.916034\nstep_signal 3 0.912971\nstep_signal-no-syscallbuf 3 0.932546\nx86/string_instructions_break 3 6.31161\nx86/string_instructions_break-no-syscallbuf 3 6.64242\nx86/string_instructions_replay_quirk 3 6.41861\nx86/string_instructions_replay_quirk-no-syscallbuf 3 6.25792\nsubprocess_exit_ends_session 3 3.19729\nsubprocess_exit_ends_session-no-syscallbuf 3 1.1328\nswitch_processes 3 3.02708\nswitch_processes-no-syscallbuf 3 2.54582\nsyscallbuf_timeslice_250 3 0.23855\nsyscallbuf_timeslice_250-no-syscallbuf 3 3.77326\ntrace_version 3 3.4036\ntrace_version-no-syscallbuf 3 2.9073\nterm_trace_cpu 3 0.396909\nterm_trace_cpu-no-syscallbuf 3 0.429927\ntrace_events 3 0.121537\ntrace_events-no-syscallbuf 3 0.114667\ntty 3 0.139457\ntty-no-syscallbuf 3 0.14484\nunmap_vdso 3 0.250266\nunmap_vdso-no-syscallbuf 3 0.242583\nunwind_on_signal 3 0.905326\nunwind_on_signal-no-syscallbuf 3 0.888245\nvfork_exec 3 8.49189\nvfork_exec-no-syscallbuf 3 8.50641\nvfork_break_parent 3 0.897031\nvfork_break_parent-no-syscallbuf 3 0.911991\nvsyscall_singlestep 3 0.144564\nvsyscall_singlestep-no-syscallbuf 3 0.135444\nwatch_code 3 2.77929\nwatch_code-no-syscallbuf 3 1.93848\nwatchpoint_cond 3 0.862841\nwatchpoint_cond-no-syscallbuf 3 0.8413\nwhen 3 0.867488\nwhen-no-syscallbuf 3 0.853477\n64bit_child-32 3 0.304826\n64bit_child-32-no-syscallbuf 3 0.303787\n_llseek-32 3 0.191999\n_llseek-32-no-syscallbuf 3 0.146433\nabort-32 3 0.327658\nabort-32-no-syscallbuf 3 0.308266\naccept-32 3 0.282175\naccept-32-no-syscallbuf 3 0.260281\nacct-32 3 0.15421\nacct-32-no-syscallbuf 3 0.143942\nadjtimex-32 3 0.15552\nadjtimex-32-no-syscallbuf 3 0.142696\naio-32 3 0.14638\naio-32-no-syscallbuf 3 0.140127\nalarm-32 3 1.93498\nalarm-32-no-syscallbuf 3 2.30969\nalarm2-32 3 1.13196\nalarm2-32-no-syscallbuf 3 1.13435\nalsa_ioctl-32 3 0.152554\nalsa_ioctl-32-no-syscallbuf 3 0.148061\narch_prctl-32 3 0.15952\narch_prctl-32-no-syscallbuf 3 0.140761\nasync_segv_ignored-32 3 0.162406\nasync_segv_ignored-32-no-syscallbuf 3 0.147537\nat_threadexit-32 3 0.213141\nat_threadexit-32-no-syscallbuf 3 0.204783\nbad_ip-32 3 0.148684\nbad_ip-32-no-syscallbuf 3 0.150585\nbad_syscall-32 3 0.15528\nbad_syscall-32-no-syscallbuf 3 0.152477\nbarrier-32 3 0.319439\nbarrier-32-no-syscallbuf 3 0.335742\nbig_buffers-32 3 0.162654\nbig_buffers-32-no-syscallbuf 3 0.176969\nblock-32 3 9.30324\nblock-32-no-syscallbuf 3 9.30678\nblock_open-32 3 0.17208\nblock_open-32-no-syscallbuf 3 0.172969\nbpf-32 3 0.163595\nbpf-32-no-syscallbuf 3 0.168828\nbpf_map-32 3 0.150942\nbpf_map-32-no-syscallbuf 3 0.159654\nbrk-32 3 0.157593\nbrk-32-no-syscallbuf 3 0.150036\nbrk2-32 3 0.170542\nbrk2-32-no-syscallbuf 3 0.139161\ncapget-32 3 0.185465\ncapget-32-no-syscallbuf 3 0.156354\nchew_cpu-32 3 8.99645\nchew_cpu-32-no-syscallbuf 3 7.87251\nx86/chew_cpu_cpuid-32 3 0.459509\nx86/chew_cpu_cpuid-32-no-syscallbuf 3 0.338245\nchmod-32 3 0.185436\nchmod-32-no-syscallbuf 3 0.160527\nchown-32 3 0.202622\nchown-32-no-syscallbuf 3 0.197929\nclock-32 3 0.23462\nclock-32-no-syscallbuf 3 0.341852\nclock_adjtime-32 3 0.165316\nclock_adjtime-32-no-syscallbuf 3 0.148155\nclock_nanosleep-32 3 1.16946\nclock_nanosleep-32-no-syscallbuf 3 1.18848\nclock_time64-32 3 0.167807\nclock_time64-32-no-syscallbuf 3 0.151238\nclone-32 3 0.173019\nclone-32-no-syscallbuf 3 0.154217\nclone_bad_stack-32 3 0.210942\nclone_bad_stack-32-no-syscallbuf 3 3.52335\nclone_bad_tls-32 3 0.149978\nclone_bad_tls-32-no-syscallbuf 3 0.140113\nclone_cleartid_coredump-32 3 0.296896\nclone_cleartid_coredump-32-no-syscallbuf 3 0.276544\nclone_fail-32 3 0.157975\nclone_fail-32-no-syscallbuf 3 0.144172\nclone_file_range-32 3 0.15726\nclone_file_range-32-no-syscallbuf 3 0.151451\nclone_immediate_exit-32 3 0.16223\nclone_immediate_exit-32-no-syscallbuf 3 0.160084\nclone_newflags-32 3 0.187997\nclone_newflags-32-no-syscallbuf 3 0.975865\nclone_parent-32 3 0.170891\nclone_parent-32-no-syscallbuf 3 0.151979\nclone_untraced-32 3 0.158722\nclone_untraced-32-no-syscallbuf 3 0.173181\nclone_vfork_pidfd-32 3 0.169316\nclone_vfork_pidfd-32-no-syscallbuf 3 0.154079\ncloned_sigmask-32 3 0.25057\ncloned_sigmask-32-no-syscallbuf 3 0.211312\nconstructor-32 3 2.16525\nconstructor-32-no-syscallbuf 3 2.20915\ncopy_file_range-32 3 0.169187\ncopy_file_range-32-no-syscallbuf 3 0.162071\nx86/cpuid_same_state-32 3 0.153435\nx86/cpuid_same_state-32-no-syscallbuf 3 0.15183\ncreat_address_not_truncated-32 3 0.159988\ncreat_address_not_truncated-32-no-syscallbuf 3 0.146481\nx86/cross_arch-32 3 0.155172\nx86/cross_arch-32-no-syscallbuf 3 0.170779\ncwd_inaccessible-32 3 0.189995\ncwd_inaccessible-32-no-syscallbuf 3 0.200617\ndaemon-32 3 0.168574\ndaemon-32-no-syscallbuf 3 0.148032\ndesched_blocking_poll-32 3 0.180458\ndesched_blocking_poll-32-no-syscallbuf 3 0.160495\ndesched_sigkill-32 3 0.251088\ndesched_sigkill-32-no-syscallbuf 3 0.218754\ndetach_state-32 3 0.218282\ndetach_state-32-no-syscallbuf 3 0.191154\ndetach_threads-32 3 0.231366\ndetach_threads-32-no-syscallbuf 3 0.200302\ndetach_sigkill-32 3 0.224815\ndetach_sigkill-32-no-syscallbuf 3 0.183264\ndetach_sigkill_exit-32 3 0.223165\ndetach_sigkill_exit-32-no-syscallbuf 3 0.164191\ndeterministic_sigsys-32 3 0.265504\ndeterministic_sigsys-32-no-syscallbuf 3 0.244816\ndev_zero-32 3 0.163044\ndev_zero-32-no-syscallbuf 3 0.147487\ndirect-32 3 0.210761\ndirect-32-no-syscallbuf 3 0.176374\ndup-32 3 0.162847\ndup-32-no-syscallbuf 3 0.161734\ndoublesegv-32 3 0.298704\ndoublesegv-32-no-syscallbuf 3 0.266586\nepoll_create-32 3 0.151417\nepoll_create-32-no-syscallbuf 3 0.156274\nepoll_create1-32 3 0.197557\nepoll_create1-32-no-syscallbuf 3 0.153539\nepoll_edge-32 3 0.155009\nepoll_edge-32-no-syscallbuf 3 0.157554\nepoll_pwait_eintr_sigmask-32 3 2.16118\nepoll_pwait_eintr_sigmask-32-no-syscallbuf 3 2.15432\neventfd-32 3 0.152283\neventfd-32-no-syscallbuf 3 0.174019\nexec_flags-32 3 0.154672\nexec_flags-32-no-syscallbuf 3 0.145737\nexec_no_env-32 3 0.192882\nexec_no_env-32-no-syscallbuf 3 0.189718\nexec_self-32 3 0.192453\nexec_self-32-no-syscallbuf 3 0.23233\nexec_from_main_thread-32 3 0.224688\nexec_from_main_thread-32-no-syscallbuf 3 0.223033\nexec_from_other_thread-32 3 11.0073\nexec_from_other_thread-32-no-syscallbuf 3 7.28493\nexec_stopsig-32 3 0.225907\nexec_stopsig-32-no-syscallbuf 3 0.199559\nexecveat-32 3 0.270121\nexecveat-32-no-syscallbuf 3 0.19012\nexit_with_syscallbuf_signal-32 3 0.202789\nexit_with_syscallbuf_signal-32-no-syscallbuf 3 0.165164\nfadvise-32 3 0.166598\nfadvise-32-no-syscallbuf 3 0.162007\nfanotify-32 3 0.146968\nfanotify-32-no-syscallbuf 3 0.158168\nfatal_init_signal-32 3 0.170639\nfatal_init_signal-32-no-syscallbuf 3 0.199012\nfatal_sigsegv_thread-32 3 2.84744\nfatal_sigsegv_thread-32-no-syscallbuf 3 3.65648\nx86/fault_in_code_page-32 3 0.162844\nx86/fault_in_code_page-32-no-syscallbuf 3 0.157253\nfcntl_dupfd-32 3 0.155242\nfcntl_dupfd-32-no-syscallbuf 3 0.160921\nfcntl_misc-32 3 0.147074\nfcntl_misc-32-no-syscallbuf 3 0.151391\nfcntl_notify-32 3 0.164578\nfcntl_notify-32-no-syscallbuf 3 0.148522\nfcntl_owner_ex-32 3 0.180492\nfcntl_owner_ex-32-no-syscallbuf 3 0.144062\nfcntl_rw_hints-32 3 0.172539\nfcntl_rw_hints-32-no-syscallbuf 3 0.156038\nfcntl_seals-32 3 0.15401\nfcntl_seals-32-no-syscallbuf 3 0.140758\nfcntl_sig-32 3 0.164499\nfcntl_sig-32-no-syscallbuf 3 0.144048\nfd_cleanup-32 3 0.171341\nfd_cleanup-32-no-syscallbuf 3 0.17852\nfd_tracking_across_threads-32 3 0.173681\nfd_tracking_across_threads-32-no-syscallbuf 3 0.184136\nfds_clean-32 3 0.215464\nfds_clean-32-no-syscallbuf 3 0.212869\nflock-32 3 0.692259\nflock-32-no-syscallbuf 3 1.43193\nflock_ofd-32 3 0.181016\nflock_ofd-32-no-syscallbuf 3 0.937886\nflock2-32 3 0.150836\nflock2-32-no-syscallbuf 3 0.141763\nfork_brk-32 3 0.162246\nfork_brk-32-no-syscallbuf 3 0.163701\nfork_child_crash-32 3 0.22847\nfork_child_crash-32-no-syscallbuf 3 0.206394\nfork_many-32 3 1.0621\nfork_many-32-no-syscallbuf 3 0.644679\nfutex_exit_race-32 3 0.449855\nfutex_exit_race-32-no-syscallbuf 3 0.383261\nfutex_exit_race_sigsegv-32 3 0.659378\nfutex_exit_race_sigsegv-32-no-syscallbuf 3 0.401827\nfutex_pi-32 3 0.159368\nfutex_pi-32-no-syscallbuf 3 0.154366\nfutex_priorities-32 3 0.178058\nfutex_priorities-32-no-syscallbuf 3 0.171578\nfutex_requeue-32 3 1.15704\nfutex_requeue-32-no-syscallbuf 3 1.16548\ngcrypt_rdrand-32 3 0.169223\ngcrypt_rdrand-32-no-syscallbuf 3 0.151264\ngetcpu-32 3 0.172906\ngetcpu-32-no-syscallbuf 3 0.149694\ngetgroups-32 3 0.17908\ngetgroups-32-no-syscallbuf 3 0.175706\ngetpwnam-32 3 0.203393\ngetpwnam-32-no-syscallbuf 3 0.183748\ngetrandom-32 3 0.184073\ngetrandom-32-no-syscallbuf 3 0.148054\nsetitimer-32 3 0.170033\nsetitimer-32-no-syscallbuf 3 0.161577\ngetsid-32 3 0.149776\ngetsid-32-no-syscallbuf 3 0.150727\ngettimeofday-32 3 0.179861\ngettimeofday-32-no-syscallbuf 3 0.157841\ngrandchild_threads-32 3 0.17692\ngrandchild_threads-32-no-syscallbuf 3 0.177978\ngrandchild_threads_main_running-32 3 4.2573\ngrandchild_threads_main_running-32-no-syscallbuf 3 4.26033\ngrandchild_threads_thread_running-32 3 4.22672\ngrandchild_threads_thread_running-32-no-syscallbuf 3 4.23036\ngrandchild_threads_parent_alive-32 3 0.175372\ngrandchild_threads_parent_alive-32-no-syscallbuf 3 0.17191\nx86/hle-32 3 1.75993\nx86/hle-32-no-syscallbuf 3 0.868235\ninotify-32 3 0.14979\ninotify-32-no-syscallbuf 3 0.155873\nint3-32 3 0.153066\nint3-32-no-syscallbuf 3 0.142991\nintr_futex_wait_restart-32 3 1.68006\nintr_futex_wait_restart-32-no-syscallbuf 3 1.67666\nintr_poll-32 3 3.66217\nintr_poll-32-no-syscallbuf 3 3.65309\nintr_ppoll-32 3 21.356\nintr_ppoll-32-no-syscallbuf 3 21.2727\nintr_pselect-32 3 9.1412\nintr_pselect-32-no-syscallbuf 3 9.16791\nintr_read_no_restart-32 3 1.27337\nintr_read_no_restart-32-no-syscallbuf 3 1.26838\nintr_read_restart-32 3 2.29083\nintr_read_restart-32-no-syscallbuf 3 2.26823\nintr_sleep-32 3 4.16515\nintr_sleep-32-no-syscallbuf 3 4.15069\nintr_sleep_no_restart-32 3 1.76225\nintr_sleep_no_restart-32-no-syscallbuf 3 1.76728\ninvalid_exec-32 3 0.153112\ninvalid_exec-32-no-syscallbuf 3 0.143637\ninvalid_fcntl-32 3 0.155597\ninvalid_fcntl-32-no-syscallbuf 3 0.143971\ninvalid_ioctl-32 3 0.151773\ninvalid_ioctl-32-no-syscallbuf 3 0.141787\nio-32 3 0.141118\nio-32-no-syscallbuf 3 0.144485\nio_uring-32 3 0.143135\nio_uring-32-no-syscallbuf 3 0.153721\nioctl-32 3 0.153616\nioctl-32-no-syscallbuf 3 0.16096\nioctl_blk-32 3 0.153993\nioctl_blk-32-no-syscallbuf 3 0.134024\nioctl_fb-32 3 0.142905\nioctl_fb-32-no-syscallbuf 3 0.160278\nioctl_fs-32 3 0.166305\nioctl_fs-32-no-syscallbuf 3 0.166838\nioctl_pty-32 3 0.212408\nioctl_pty-32-no-syscallbuf 3 0.182692\nioctl_sg-32 3 0.15514\nioctl_sg-32-no-syscallbuf 3 0.139962\nioctl_tty-32 3 0.211347\nioctl_tty-32-no-syscallbuf 3 0.183449\nioctl_vt-32 3 0.157438\nioctl_vt-32-no-syscallbuf 3 0.147469\nioprio-32 3 0.151004\nioprio-32-no-syscallbuf 3 0.154964\nx86/ioperm-32 3 0.156565\nx86/ioperm-32-no-syscallbuf 3 0.140728\nx86/iopl-32 3 0.147943\nx86/iopl-32-no-syscallbuf 3 0.148907\njoin_threads-32 3 1.81576\njoin_threads-32-no-syscallbuf 3 2.03578\njoystick-32 3 0.157531\njoystick-32-no-syscallbuf 3 0.162038\nkcmp-32 3 0.154256\nkcmp-32-no-syscallbuf 3 0.159314\nkeyctl-32 3 0.181774\nkeyctl-32-no-syscallbuf 3 0.163745\nkill_newborn-32 3 0.374656\nkill_newborn-32-no-syscallbuf 3 0.31533\nkill_ptracee-32 3 0.228514\nkill_ptracee-32-no-syscallbuf 3 1.246\nlarge_hole-32 3 0.165388\nlarge_hole-32-no-syscallbuf 3 0.147838\nlarge_write_deadlock-32 3 0.167368\nlarge_write_deadlock-32-no-syscallbuf 3 0.149762\nlegacy_ugid-32 3 0.15176\nlegacy_ugid-32-no-syscallbuf 3 0.145744\nx86/lsl-32 3 0.153843\nx86/lsl-32-no-syscallbuf 3 0.157294\nmadvise-32 3 0.153776\nmadvise-32-no-syscallbuf 3 0.155182\nmadvise_free-32 3 0.149715\nmadvise_free-32-no-syscallbuf 3 0.136664\nmadvise_wipeonfork-32 3 3.64301\nmadvise_wipeonfork-32-no-syscallbuf 3 3.40596\nmap_fixed-32 3 0.153551\nmap_fixed-32-no-syscallbuf 3 0.143067\nmap_shared_syscall-32 3 0.196505\nmap_shared_syscall-32-no-syscallbuf 3 0.164814\nmembarrier-32 3 0.196551\nmembarrier-32-no-syscallbuf 3 0.215238\nmemfd_create-32 3 0.145081\nmemfd_create-32-no-syscallbuf 3 0.144793\nmemfd_create_shared-32 3 0.149983\nmemfd_create_shared-32-no-syscallbuf 3 0.149288\nmemfd_create_shared_huge-32 3 0.150715\nmemfd_create_shared_huge-32-no-syscallbuf 3 0.149097\nmincore-32 3 0.168283\nmincore-32-no-syscallbuf 3 0.155869\nmknod-32 3 0.160622\nmknod-32-no-syscallbuf 3 0.189022\nmlock-32 3 0.157306\nmlock-32-no-syscallbuf 3 0.151448\nmmap_adjacent_to_rr_usage-32 3 0.16504\nmmap_adjacent_to_rr_usage-32-no-syscallbuf 3 0.153358\nmmap_private-32 3 0.955459\nmmap_private-32-no-syscallbuf 3 0.93923\nmmap_private_grow_under_map-32 3 0.156459\nmmap_private_grow_under_map-32-no-syscallbuf 3 0.150686\nmmap_recycle-32 3 0.178728\nmmap_recycle-32-no-syscallbuf 3 0.200388\nmmap_ro-32 3 0.15381\nmmap_ro-32-no-syscallbuf 3 0.152539\nmmap_self_maps_shared-32 3 0.212991\nmmap_self_maps_shared-32-no-syscallbuf 3 0.235169\nmmap_shared-32 3 0.189508\nmmap_shared-32-no-syscallbuf 3 0.165505\nmmap_shared_dev_zero-32 3 0.152691\nmmap_shared_dev_zero-32-no-syscallbuf 3 0.161642\nmmap_shared_grow-32 3 0.154202\nmmap_shared_grow-32-no-syscallbuf 3 0.15251\nmmap_shared_grow_under_map-32 3 0.15559\nmmap_shared_grow_under_map-32-no-syscallbuf 3 0.198992\nmmap_shared_multiple-32 3 0.150452\nmmap_shared_multiple-32-no-syscallbuf 3 0.157868\nmmap_shared_subpage-32 3 0.17358\nmmap_shared_subpage-32-no-syscallbuf 3 0.180505\nmmap_shared_write-32 3 8.93786\nmmap_shared_write-32-no-syscallbuf 3 7.83023\nmmap_shared_write_fork-32 3 3.03776\nmmap_shared_write_fork-32-no-syscallbuf 3 4.18879\nmmap_short_file-32 3 0.157907\nmmap_short_file-32-no-syscallbuf 3 0.152402\nmmap_write_complex-32 3 0.156462\nmmap_write_complex-32-no-syscallbuf 3 0.179488\nmmap_zero_size_fd-32 3 0.151921\nmmap_zero_size_fd-32-no-syscallbuf 3 0.159179\nx86/modify_ldt-32 3 0.16214\nx86/modify_ldt-32-no-syscallbuf 3 0.142049\nmount_ns_exec-32 3 0.218357\nmount_ns_exec-32-no-syscallbuf 3 0.210181\nmount_ns_exec2-32 3 0.210198\nmount_ns_exec2-32-no-syscallbuf 3 0.217898\nmprotect-32 3 0.159588\nmprotect-32-no-syscallbuf 3 0.158859\nmprotect_heterogenous-32 3 0.156733\nmprotect_heterogenous-32-no-syscallbuf 3 0.148801\nmprotect_none-32 3 0.162975\nmprotect_none-32-no-syscallbuf 3 0.165251\nmprotect_stack-32 3 0.157941\nmprotect_stack-32-no-syscallbuf 3 0.15318\nmq-32 3 2.14778\nmq-32-no-syscallbuf 3 2.14405\nmremap-32 3 2.71509\nmremap-32-no-syscallbuf 3 3.77905\nmremap_after_coalesce-32 3 0.167336\nmremap_after_coalesce-32-no-syscallbuf 3 0.15215\nmremap_grow-32 3 0.172376\nmremap_grow-32-no-syscallbuf 3 0.143557\nmremap_grow_shared-32 3 0.161398\nmremap_grow_shared-32-no-syscallbuf 3 0.184349\nmremap_non_page_size-32 3 0.173966\nmremap_non_page_size-32-no-syscallbuf 3 0.960082\nmremap_overwrite-32 3 0.167889\nmremap_overwrite-32-no-syscallbuf 3 0.149849\nmremap_private_grow_under_map-32 3 0.208637\nmremap_private_grow_under_map-32-no-syscallbuf 3 0.141832\nmremap_shrink-32 3 0.149815\nmremap_shrink-32-no-syscallbuf 3 0.159473\nmsg-32 3 1.67129\nmsg-32-no-syscallbuf 3 1.66959\nmsg_trunc-32 3 0.161193\nmsg_trunc-32-no-syscallbuf 3 0.152021\nmsync-32 3 0.980204\nmsync-32-no-syscallbuf 3 1.13639\nmtio-32 3 0.161772\nmtio-32-no-syscallbuf 3 0.150394\nmultiple_pending_signals-32 3 0.172009\nmultiple_pending_signals-32-no-syscallbuf 3 0.181682\nmultiple_pending_signals_sequential-32 3 0.171168\nmultiple_pending_signals_sequential-32-no-syscallbuf 3 0.168579\nmunmap_segv-32 3 0.180509\nmunmap_segv-32-no-syscallbuf 3 0.155486\nmunmap_discontinuous-32 3 0.167498\nmunmap_discontinuous-32-no-syscallbuf 3 0.150001\nnanosleep-32 3 1.15722\nnanosleep-32-no-syscallbuf 3 1.14139\nnetfilter-32 3 0.225731\nnetfilter-32-no-syscallbuf 3 0.253314\nnetlink_mmap_disable-32 3 0.152069\nnetlink_mmap_disable-32-no-syscallbuf 3 0.151469\nno_mask_timeslice-32 3 0.649534\nno_mask_timeslice-32-no-syscallbuf 3 0.631615\nnscd-32 3 0.155986\nnscd-32-no-syscallbuf 3 0.142495\nnuma-32 3 0.169945\nnuma-32-no-syscallbuf 3 0.154122\nx86/old_fork-32 3 0.181812\nx86/old_fork-32-no-syscallbuf 3 0.16164\norphan_process-32 3 0.189727\norphan_process-32-no-syscallbuf 3 0.16286\npacket_mmap_disable-32 3 0.151169\npacket_mmap_disable-32-no-syscallbuf 3 0.13895\npause-32 3 1.14206\npause-32-no-syscallbuf 3 1.12912\nperf_event-32 3 0.178988\nperf_event-32-no-syscallbuf 3 0.163082\npersonality-32 3 0.165676\npersonality-32-no-syscallbuf 3 0.186562\npid_ns_kill_child-32 3 0.315863\npid_ns_kill_child-32-no-syscallbuf 3 0.257869\npid_ns_kill_child_threads-32 3 0.218288\npid_ns_kill_child_threads-32-no-syscallbuf 3 0.181862\npid_ns_kill_child_zombie-32 3 0.197205\npid_ns_kill_child_zombie-32-no-syscallbuf 3 0.178299\npid_ns_kill_threads-32 3 0.212746\npid_ns_kill_threads-32-no-syscallbuf 3 0.197092\npid_ns_kill_threads_exit_wait-32 3 0.288347\npid_ns_kill_threads_exit_wait-32-no-syscallbuf 3 0.237707\npid_ns_reap-32 3 0.224205\npid_ns_reap-32-no-syscallbuf 3 0.219411\npid_ns_segv-32 3 0.244841\npid_ns_segv-32-no-syscallbuf 3 3.5191\npid_ns_shutdown-32 3 0.436881\npid_ns_shutdown-32-no-syscallbuf 3 0.300734\npidfd-32 3 0.170489\npidfd-32-no-syscallbuf 3 0.168095\nx86/pkeys-32 3 0.156903\nx86/pkeys-32-no-syscallbuf 3 0.151483\npoll_sig_race-32 3 2.86617\npoll_sig_race-32-no-syscallbuf 3 2.84212\nppoll-32 3 5.71335\nppoll-32-no-syscallbuf 3 5.71978\nprctl-32 3 0.205522\nprctl-32-no-syscallbuf 3 0.160626\nprctl_caps-32 3 0.418496\nprctl_caps-32-no-syscallbuf 3 0.337073\nprctl_deathsig-32 3 0.211914\nprctl_deathsig-32-no-syscallbuf 3 0.161506\nprctl_name-32 3 0.250287\nprctl_name-32-no-syscallbuf 3 0.219074\nprctl_short_name-32 3 0.157873\nprctl_short_name-32-no-syscallbuf 3 0.139269\nprctl_speculation_ctrl-32 3 0.160405\nprctl_speculation_ctrl-32-no-syscallbuf 3 0.15103\nx86/prctl_tsc-32 3 0.178406\nx86/prctl_tsc-32-no-syscallbuf 3 0.162318\nprivileged_net_ioctl-32 3 0.379696\nprivileged_net_ioctl-32-no-syscallbuf 3 0.387907\nproc_fds-32 3 0.669816\nproc_fds-32-no-syscallbuf 3 0.755054\nproc_mem-32 3 0.37817\nproc_mem-32-no-syscallbuf 3 0.352366\nprotect_rr_fds-32 3 3.79314\nprotect_rr_fds-32-no-syscallbuf 3 4.68026\nprw-32 3 0.159067\nprw-32-no-syscallbuf 3 0.157042\npthread_condvar_locking-32 3 0.171883\npthread_condvar_locking-32-no-syscallbuf 3 0.172416\npthread_mutex_timedlock-32 3 0.157664\npthread_mutex_timedlock-32-no-syscallbuf 3 0.152356\npthread_pi_mutex-32 3 0.180342\npthread_pi_mutex-32-no-syscallbuf 3 0.141443\npthread_rwlocks-32 3 0.171323\npthread_rwlocks-32-no-syscallbuf 3 0.155313\nx86/ptrace-32 3 0.202802\nx86/ptrace-32-no-syscallbuf 3 0.203137\nptrace_attach_null_status-32 3 0.201859\nptrace_attach_null_status-32-no-syscallbuf 3 0.202679\nptrace_attach_running-32 3 0.302493\nptrace_attach_running-32-no-syscallbuf 3 1.29286\nptrace_attach_sleeping-32 3 0.20655\nptrace_attach_sleeping-32-no-syscallbuf 3 0.224097\nptrace_attach_stopped-32 3 0.225358\nptrace_attach_stopped-32-no-syscallbuf 3 0.226626\nptrace_attach_thread_running-32 3 5.23279\nptrace_attach_thread_running-32-no-syscallbuf 3 6.23923\nptrace_breakpoint-32 3 0.187927\nptrace_breakpoint-32-no-syscallbuf 3 0.175526\nptrace_change_patched_syscall-32 3 0.191564\nptrace_change_patched_syscall-32-no-syscallbuf 3 0.178473\nx86/ptrace_debug_regs-32 3 0.165021\nx86/ptrace_debug_regs-32-no-syscallbuf 3 0.170646\nptrace_exec-32 3 0.284666\nptrace_exec-32-no-syscallbuf 3 0.263863\nx86/ptrace_exec32-32 3 0.156262\nx86/ptrace_exec32-32-no-syscallbuf 3 0.177857\nptrace_kill_grandtracee-32 3 0.187637\nptrace_kill_grandtracee-32-no-syscallbuf 3 0.168497\nx86/ptrace_tls-32 3 0.217899\nx86/ptrace_tls-32-no-syscallbuf 3 0.172283\nptrace_seize-32 3 0.166657\nptrace_seize-32-no-syscallbuf 3 0.150007\nptrace_sigchld_blocked-32 3 0.174692\nptrace_sigchld_blocked-32-no-syscallbuf 3 0.170833\nptrace_signals-32 3 0.247924\nptrace_signals-32-no-syscallbuf 3 0.223317\nptrace_singlestep-32 3 0.588033\nptrace_singlestep-32-no-syscallbuf 3 0.208037\nptrace_syscall-32 3 0.175065\nptrace_syscall-32-no-syscallbuf 3 0.175047\nptrace_syscall_clone_untraced-32 3 0.265815\nptrace_syscall_clone_untraced-32-no-syscallbuf 3 0.234984\nx86/ptrace_sysemu-32 3 0.245813\nx86/ptrace_sysemu-32-no-syscallbuf 3 0.281432\nptrace_sysemu_syscall-32 3 0.172529\nptrace_sysemu_syscall-32-no-syscallbuf 3 0.184325\nptrace_trace_clone-32 3 0.192627\nptrace_trace_clone-32-no-syscallbuf 3 0.196129\nptrace_trace_exit-32 3 0.167728\nptrace_trace_exit-32-no-syscallbuf 3 0.152608\nptrace_traceme-32 3 0.170265\nptrace_traceme-32-no-syscallbuf 3 0.167408\nptracer_death-32 3 0.225048\nptracer_death-32-no-syscallbuf 3 0.22157\nptracer_death_multithread-32 3 0.36814\nptracer_death_multithread-32-no-syscallbuf 3 0.355059\nptracer_death_multithread_peer-32 3 0.425597\nptracer_death_multithread_peer-32-no-syscallbuf 3 0.368566\nquotactl-32 3 0.16327\nquotactl-32-no-syscallbuf 3 0.171614\nx86/rdtsc-32 3 0.237795\nx86/rdtsc-32-no-syscallbuf 3 0.23056\nread_nothing-32 3 8.23326\nread_nothing-32-no-syscallbuf 3 8.74176\nreaddir-32 3 0.170494\nreaddir-32-no-syscallbuf 3 0.154295\nread_large-32 3 0.373234\nread_large-32-no-syscallbuf 3 1.08149\nread_oversize-32 3 0.160709\nread_oversize-32-no-syscallbuf 3 0.145395\nreadlink-32 3 0.167153\nreadlink-32-no-syscallbuf 3 0.178274\nreadlinkat-32 3 0.169105\nreadlinkat-32-no-syscallbuf 3 0.148272\nreadv-32 3 0.166935\nreadv-32-no-syscallbuf 3 0.157705\nrecord_replay_subject-32 3 3.17351\nrecord_replay_subject-32-no-syscallbuf 3 3.32555\nrecvfrom-32 3 0.167627\nrecvfrom-32-no-syscallbuf 3 0.152596\nredzone_integrity-32 3 1.13169\nredzone_integrity-32-no-syscallbuf 3 1.12603\nrename-32 3 0.157525\nrename-32-no-syscallbuf 3 0.149803\nrlimit-32 3 0.160895\nrlimit-32-no-syscallbuf 3 0.159288\nrobust_futex-32 3 0.186858\nrobust_futex-32-no-syscallbuf 3 0.174649\nrusage-32 3 0.16248\nrusage-32-no-syscallbuf 3 0.177407\nsamask-32 3 3.67966\nsamask-32-no-syscallbuf 3 0.24021\nsave_data_fd-32 3 0.194628\nsave_data_fd-32-no-syscallbuf 3 0.150419\nsched_attr-32 3 0.151563\nsched_attr-32-no-syscallbuf 3 0.148402\nsched_setaffinity-32 3 0.187992\nsched_setaffinity-32-no-syscallbuf 3 0.155224\nsched_setparam-32 3 0.159496\nsched_setparam-32-no-syscallbuf 3 0.145659\nsched_yield-32 3 0.259235\nsched_yield-32-no-syscallbuf 3 0.229347\nsched_yield_to_lower_priority-32 3 0.162573\nsched_yield_to_lower_priority-32-no-syscallbuf 3 0.153827\nscm_rights-32 3 0.674781\nscm_rights-32-no-syscallbuf 3 0.658719\nscratch_read-32 3 0.17575\nscratch_read-32-no-syscallbuf 3 0.168705\nseccomp-32 3 0.238751\nseccomp-32-no-syscallbuf 3 0.174795\nseccomp_cloning-32 3 0.154522\nseccomp_cloning-32-no-syscallbuf 3 0.144178\nseccomp_clone_fail-32 3 0.186049\nseccomp_clone_fail-32-no-syscallbuf 3 0.144807\nseccomp_desched-32 3 0.185211\nseccomp_desched-32-no-syscallbuf 3 0.14652\nseccomp_kill_exit-32 3 0.165099\nseccomp_kill_exit-32-no-syscallbuf 3 0.146084\nseccomp_null-32 3 0.148407\nseccomp_null-32-no-syscallbuf 3 0.172433\nseccomp_sigsys_args-32 3 0.169652\nseccomp_sigsys_args-32-no-syscallbuf 3 0.148725\nseccomp_sigsys_sigtrap-32 3 0.176765\nseccomp_sigsys_sigtrap-32-no-syscallbuf 3 0.169305\nseccomp_sigsys_syscallbuf-32 3 0.17534\nseccomp_sigsys_syscallbuf-32-no-syscallbuf 3 0.15083\nseccomp_tsync-32 3 0.166462\nseccomp_tsync-32-no-syscallbuf 3 0.161381\nseccomp_veto_exec-32 3 0.155642\nseccomp_veto_exec-32-no-syscallbuf 3 0.171488\nself_shebang-32 3 0.225915\nself_shebang-32-no-syscallbuf 3 0.201259\nself_sigint-32 3 0.146967\nself_sigint-32-no-syscallbuf 3 0.13868\nsem-32 3 0.221923\nsem-32-no-syscallbuf 3 0.232999\nsend_block-32 3 1.20601\nsend_block-32-no-syscallbuf 3 2.74609\nsendfile-32 3 0.174107\nsendfile-32-no-syscallbuf 3 0.160439\nset_ptracer-32 3 0.163169\nset_ptracer-32-no-syscallbuf 3 0.158607\nset_tid_address-32 3 0.203349\nset_tid_address-32-no-syscallbuf 3 0.177229\nsetgid-32 3 0.157202\nsetgid-32-no-syscallbuf 3 0.170407\nsetgroups-32 3 0.152816\nsetgroups-32-no-syscallbuf 3 0.154193\nsetsid-32 3 0.157229\nsetsid-32-no-syscallbuf 3 0.141788\nsetuid-32 3 0.199234\nsetuid-32-no-syscallbuf 3 0.206858\nshared_exec-32 3 0.155282\nshared_exec-32-no-syscallbuf 3 0.141731\nshared_monitor-32 3 0.159804\nshared_monitor-32-no-syscallbuf 3 0.152979\nshared_offset-32 3 0.167958\nshared_offset-32-no-syscallbuf 3 0.14582\nshared_write-32 3 0.16008\nshared_write-32-no-syscallbuf 3 0.148777\nshm-32 3 0.192733\nshm-32-no-syscallbuf 3 0.185219\nshm_unmap-32 3 0.17174\nshm_unmap-32-no-syscallbuf 3 0.152336\nsigaction_old-32 3 0.154676\nsigaction_old-32-no-syscallbuf 3 0.138014\nsigaltstack-32 3 0.152159\nsigaltstack-32-no-syscallbuf 3 0.163207\nsigchld_interrupt_signal-32 3 3.69105\nsigchld_interrupt_signal-32-no-syscallbuf 3 4.02921\nsigcont-32 3 0.168805\nsigcont-32-no-syscallbuf 3 0.163479\nsighandler_bad_rsp_sigsegv-32 3 0.150089\nsighandler_bad_rsp_sigsegv-32-no-syscallbuf 3 0.170034\nsighandler_fork-32 3 0.201522\nsighandler_fork-32-no-syscallbuf 3 0.183042\nsighandler_mask-32 3 0.176638\nsighandler_mask-32-no-syscallbuf 3 0.170064\nsigill-32 3 0.159255\nsigill-32-no-syscallbuf 3 0.142759\nsignal_deferred-32 3 0.200955\nsignal_deferred-32-no-syscallbuf 3 0.193946\nsignal_during_preload_init-32 3 0.181614\nsignal_during_preload_init-32-no-syscallbuf 3 0.153711\nsignal_frame-32 3 0.1648\nsignal_frame-32-no-syscallbuf 3 0.150419\nsignal_unstoppable-32 3 0.160193\nsignal_unstoppable-32-no-syscallbuf 3 0.155311\nsignalfd-32 3 0.150485\nsignalfd-32-no-syscallbuf 3 0.153559\nsigprocmask-32 3 0.564137\nsigprocmask-32-no-syscallbuf 3 0.478055\nsigprocmask_ensure_delivery-32 3 0.173297\nsigprocmask_ensure_delivery-32-no-syscallbuf 3 0.173071\nsigprocmask_exec-32 3 0.201982\nsigprocmask_exec-32-no-syscallbuf 3 0.183497\nsigprocmask_evil-32 3 0.156691\nsigprocmask_evil-32-no-syscallbuf 3 0.158505\nsigprocmask_in_syscallbuf_sighandler-32 3 1.12744\nsigprocmask_in_syscallbuf_sighandler-32-no-syscallbuf 3 1.14572\nsigprocmask_rr_sigs-32 3 0.171702\nsigprocmask_rr_sigs-32-no-syscallbuf 3 0.140313\nsigprocmask_syscallbuf-32 3 0.209291\nsigprocmask_syscallbuf-32-no-syscallbuf 3 0.148303\nsigqueueinfo-32 3 0.172461\nsigqueueinfo-32-no-syscallbuf 3 0.168942\nx86/sigreturn-32 3 0.190793\nx86/sigreturn-32-no-syscallbuf 3 0.193286\nsigreturn_reg-32 3 0.154534\nsigreturn_reg-32-no-syscallbuf 3 0.144831\nsigreturnmask-32 3 3.69684\nsigreturnmask-32-no-syscallbuf 3 0.269075\nsigrt-32 3 0.265449\nsigrt-32-no-syscallbuf 3 0.255231\nsigstop-32 3 0.235289\nsigstop-32-no-syscallbuf 3 0.195399\nsigstop2-32 3 0.161917\nsigstop2-32-no-syscallbuf 3 0.160208\nsigsuspend-32 3 0.163447\nsigsuspend-32-no-syscallbuf 3 0.163487\nsigtrap-32 3 0.19183\nsigtrap-32-no-syscallbuf 3 0.175125\nsimple_threads_stress-32 3 1.88103\nsimple_threads_stress-32-no-syscallbuf 3 2.13344\nsioc-32 3 0.46054\nsioc-32-no-syscallbuf 3 0.71351\nsmall_holes-32 3 0.188756\nsmall_holes-32-no-syscallbuf 3 0.176645\nsock_names_opts-32 3 0.207226\nsock_names_opts-32-no-syscallbuf 3 0.183982\nspinlock_priorities-32 3 0.87841\nspinlock_priorities-32-no-syscallbuf 3 1.52971\nsplice-32 3 0.178047\nsplice-32-no-syscallbuf 3 0.156996\nstack_growth_after_syscallbuf-32 3 0.164017\nstack_growth_after_syscallbuf-32-no-syscallbuf 3 0.163837\nstack_growth_syscallbuf-32 3 0.255754\nstack_growth_syscallbuf-32-no-syscallbuf 3 7.78853\nstack_growth_with_guard-32 3 0.161785\nstack_growth_with_guard-32-no-syscallbuf 3 0.153335\nstack_invalid-32 3 0.169688\nstack_invalid-32-no-syscallbuf 3 0.146576\nstack_overflow-32 3 0.238862\nstack_overflow-32-no-syscallbuf 3 0.240195\nstack_overflow_altstack-32 3 0.154164\nstack_overflow_altstack-32-no-syscallbuf 3 0.162658\nstack_overflow_with_guard-32 3 0.222723\nstack_overflow_with_guard-32-no-syscallbuf 3 0.209434\nstatfs-32 3 0.208717\nstatfs-32-no-syscallbuf 3 0.184497\nstatx-32 3 0.161829\nstatx-32-no-syscallbuf 3 0.145453\nstdout_child-32 3 0.205012\nstdout_child-32-no-syscallbuf 3 0.185209\nstdout_cloexec-32 3 0.30459\nstdout_cloexec-32-no-syscallbuf 3 0.216534\nstdout_dup-32 3 0.144612\nstdout_dup-32-no-syscallbuf 3 0.155127\nstdout_redirect-32 3 0.223423\nstdout_redirect-32-no-syscallbuf 3 0.200103\nswitch_read-32 3 0.663024\nswitch_read-32-no-syscallbuf 3 0.67711\nsymlink-32 3 0.144237\nsymlink-32-no-syscallbuf 3 0.137486\nsync-32 3 0.200357\nsync-32-no-syscallbuf 3 0.317546\nsync_file_range-32 3 0.155488\nsync_file_range-32-no-syscallbuf 3 0.160627\nsyscall_bp-32 3 0.19815\nsyscall_bp-32-no-syscallbuf 3 0.139347\nsyscall_in_writable_mem-32 3 0.151691\nsyscall_in_writable_mem-32-no-syscallbuf 3 0.146629\nsyscallbuf_signal_reset-32 3 0.153528\nsyscallbuf_signal_reset-32-no-syscallbuf 3 0.152267\nsyscallbuf_signal_blocking-32 3 0.163952\nsyscallbuf_signal_blocking-32-no-syscallbuf 3 0.162264\nsyscallbuf_sigstop-32 3 10.053\nsyscallbuf_sigstop-32-no-syscallbuf 3 21.1144\nsyscallbuf_timeslice-32 3 0.20007\nsyscallbuf_timeslice-32-no-syscallbuf 3 3.39877\nsyscallbuf_timeslice2-32 3 0.25615\nsyscallbuf_timeslice2-32-no-syscallbuf 3 9.4888\nsysconf-32 3 0.180379\nsysconf-32-no-syscallbuf 3 0.160266\nsysctl-32 3 0.157521\nsysctl-32-no-syscallbuf 3 0.157257\nsysemu_singlestep-32 3 0.161507\nsysemu_singlestep-32-no-syscallbuf 3 0.147615\nx86/sysfs-32 3 0.202258\nx86/sysfs-32-no-syscallbuf 3 0.235382\nsysinfo-32 3 0.153731\nsysinfo-32-no-syscallbuf 3 0.148979\ntgkill-32 3 0.180015\ntgkill-32-no-syscallbuf 3 0.189076\nthread_yield-32 3 2.72622\nthread_yield-32-no-syscallbuf 3 2.83493\ntimer-32 3 66.233\ntimer-32-no-syscallbuf 3 53.5698\ntimerfd-32 3 0.241996\ntimerfd-32-no-syscallbuf 3 0.245579\ntimes-32 3 0.167239\ntimes-32-no-syscallbuf 3 0.147307\ntruncate_temp-32 3 0.174554\ntruncate_temp-32-no-syscallbuf 3 0.168496\ntun-32 3 0.227859\ntun-32-no-syscallbuf 3 0.206458\ntwo_signals_with_mask-32 3 0.172679\ntwo_signals_with_mask-32-no-syscallbuf 3 0.175765\nulimit_low-32 3 0.181231\nulimit_low-32-no-syscallbuf 3 0.16547\nuname-32 3 0.152877\nuname-32-no-syscallbuf 3 0.154804\nunexpected_exit-32 3 0.221514\nunexpected_exit-32-no-syscallbuf 3 0.376083\nunexpected_exit_execve-32 3 0.291641\nunexpected_exit_execve-32-no-syscallbuf 3 0.389679\nunexpected_exit_execve_twice-32 3 1.27175\nunexpected_exit_execve_twice-32-no-syscallbuf 3 1.50441\nunexpected_exit_pid_ns-32 3 0.559279\nunexpected_exit_pid_ns-32-no-syscallbuf 3 0.259957\nunjoined_thread-32 3 0.161565\nunjoined_thread-32-no-syscallbuf 3 0.152121\nunshare-32 3 0.333582\nunshare-32-no-syscallbuf 3 1.35282\nuserfaultfd-32 3 0.162787\nuserfaultfd-32-no-syscallbuf 3 0.147239\nutimes-32 3 0.163314\nutimes-32-no-syscallbuf 3 0.151632\nvdso_parts-32 3 0.143693\nvdso_parts-32-no-syscallbuf 3 0.1437\nvfork_flush-32 3 0.196677\nvfork_flush-32-no-syscallbuf 3 0.162488\nvfork_shared-32 3 0.156936\nvfork_shared-32-no-syscallbuf 3 0.146859\nvideo_capture-32 3 0.160758\nvideo_capture-32-no-syscallbuf 3 0.138877\nvm_readv_writev-32 3 0.17866\nvm_readv_writev-32-no-syscallbuf 3 0.163655\nvsyscall-32 3 0.175241\nvsyscall-32-no-syscallbuf 3 0.144635\nvsyscall_timeslice-32 3 0.161879\nvsyscall_timeslice-32-no-syscallbuf 3 0.154139\nx86/x87env-32 3 0.157463\nx86/x87env-32-no-syscallbuf 3 0.143789\nwait-32 3 0.189688\nwait-32-no-syscallbuf 3 0.163083\nwait_sigstop-32 3 0.209228\nwait_sigstop-32-no-syscallbuf 3 0.185075\nwrite_race-32 3 2.69575\nwrite_race-32-no-syscallbuf 3 1.71615\nwritev-32 3 0.181917\nwritev-32-no-syscallbuf 3 0.148252\nxattr-32 3 0.161601\nxattr-32-no-syscallbuf 3 0.169778\nzero_length_read-32 3 0.171758\nzero_length_read-32-no-syscallbuf 3 0.152607\nstd_random-32 3 0.190289\nstd_random-32-no-syscallbuf 3 0.197247\nunwind_rr_page-32 3 1.14592\nunwind_rr_page-32-no-syscallbuf 3 1.16719\nabort_nonmain-32 3 0.316806\nabort_nonmain-32-no-syscallbuf 3 0.380755\nalternate_thread_diversion-32 3 0.943783\nalternate_thread_diversion-32-no-syscallbuf 3 0.939422\nargs-32 3 0.146008\nargs-32-no-syscallbuf 3 0.148513\nasync_kill_with_syscallbuf-32 3 2.69049\nasync_kill_with_syscallbuf-32-no-syscallbuf 3 3.7005\nasync_kill_with_syscallbuf2-32 3 2.21314\nasync_kill_with_syscallbuf2-32-no-syscallbuf 3 2.54384\nasync_kill_with_threads-32 3 2.22036\nasync_kill_with_threads-32-no-syscallbuf 3 2.19775\nasync_kill_with_threads_main_running-32 3 2.25137\nasync_kill_with_threads_main_running-32-no-syscallbuf 3 2.2716\nasync_kill_with_threads_thread_running-32 3 6.13926\nasync_kill_with_threads_thread_running-32-no-syscallbuf 3 6.1491\nasync_segv-32 3 4.38816\nasync_segv-32-no-syscallbuf 3 4.20831\nasync_signal_syscalls-32 3 1.50166\nasync_signal_syscalls-32-no-syscallbuf 3 0.0224907\nasync_signal_syscalls2-32 3 1.06915\nasync_signal_syscalls2-32-no-syscallbuf 3 0.0208089\nasync_signal_syscalls_siginfo-32 3 2.1386\nasync_signal_syscalls_siginfo-32-no-syscallbuf 3 0.0208899\nasync_usr1-32 3 4.14552\nasync_usr1-32-no-syscallbuf 3 4.29349\nblacklist-32 3 0.177599\nblacklist-32-no-syscallbuf 3 0.151851\nblock_clone_checkpoint-32 3 0.905129\nblock_clone_checkpoint-32-no-syscallbuf 3 0.944421\nblock_clone_interrupted-32 3 5.37544\nblock_clone_interrupted-32-no-syscallbuf 3 4.34796\nblock_clone_syscallbuf_overflow-32 3 6.43809\nblock_clone_syscallbuf_overflow-32-no-syscallbuf 3 6.23606\nblock_intr_sigchld-32 3 6.71056\nblock_intr_sigchld-32-no-syscallbuf 3 5.87732\nblocked_bad_ip-32 3 5.48907\nblocked_bad_ip-32-no-syscallbuf 3 0.953725\nblocked_sigill-32 3 0.348823\nblocked_sigill-32-no-syscallbuf 3 0.33688\nx86/blocked_sigsegv-32 3 0.334973\nx86/blocked_sigsegv-32-no-syscallbuf 3 0.331443\nbreakpoint-32 3 0.933407\nbreakpoint-32-no-syscallbuf 3 0.899296\nbreakpoint_conditions-32 3 0.875905\nbreakpoint_conditions-32-no-syscallbuf 3 0.850744\nbreakpoint_overlap-32 3 0.854787\nbreakpoint_overlap-32-no-syscallbuf 3 0.794347\ncall_function-32 3 0.836484\ncall_function-32-no-syscallbuf 3 0.801419\ncall_gettid-32 3 0.791342\ncall_gettid-32-no-syscallbuf 3 0.769617\ncheckpoint_dying_threads-32 3 0.841963\ncheckpoint_dying_threads-32-no-syscallbuf 3 0.854261\ncheckpoint_mixed_mode-32 3 0.747812\ncheckpoint_mixed_mode-32-no-syscallbuf 3 0.768738\nchecksum_sanity-32 3 1.84333\nchecksum_sanity-32-no-syscallbuf 3 1.63785\ncheck_lost_interrupts-32 3 2.15464\ncheck_lost_interrupts-32-no-syscallbuf 3 0.0292697\nclone_interruption-32 3 1.81224\nclone_interruption-32-no-syscallbuf 3 1.69677\nclone_vfork-32 3 0.216188\nclone_vfork-32-no-syscallbuf 3 0.2384\nconditional_breakpoint_calls-32 3 0.859498\nconditional_breakpoint_calls-32-no-syscallbuf 3 0.822861\nconditional_breakpoint_offload-32 3 67.6523\nconditional_breakpoint_offload-32-no-syscallbuf 3 68.5646\ncondvar_stress-32 3 20.5078\ncondvar_stress-32-no-syscallbuf 3 49.5064\ncont_race-32 3 14.3118\ncont_race-32-no-syscallbuf 3 6.75519\nx86/cpuid_singlestep-32 3 0.757824\nx86/cpuid_singlestep-32-no-syscallbuf 3 0.741373\ncrash-32 3 0.28169\ncrash-32-no-syscallbuf 3 0.279738\ncrash_in_function-32 3 5.8669\ncrash_in_function-32-no-syscallbuf 3 5.09821\ndaemon_read-32 3 0.218933\ndaemon_read-32-no-syscallbuf 3 0.196873\ndconf_mock-32 3 0.173531\ndconf_mock-32-no-syscallbuf 3 0.17913\ndev_tty-32 3 0.14228\ndev_tty-32-no-syscallbuf 3 0.143919\ndiversion_sigtrap-32 3 10.8416\ndiversion_sigtrap-32-no-syscallbuf 3 10.9284\ndiversion_syscall-32 3 0.899496\ndiversion_syscall-32-no-syscallbuf 3 0.897231\ndlopen-32 3 3.6474\ndlopen-32-no-syscallbuf 3 4.79812\nearly_error-32 3 3.69384\nearly_error-32-no-syscallbuf 3 0.3424\nelapsed_time-32 3 1.77463\nelapsed_time-32-no-syscallbuf 3 1.78306\nexclusion_region-32 3 0.163736\nexclusion_region-32-no-syscallbuf 3 0.173001\nexec_failed-32 3 0.716326\nexec_failed-32-no-syscallbuf 3 0.735136\nexec_many-32 3 6.51486\nexec_many-32-no-syscallbuf 3 4.77725\nexecve_loop-32 3 6.01457\nexecve_loop-32-no-syscallbuf 3 4.5922\nexit_codes-32 3 0.337132\nexit_codes-32-no-syscallbuf 3 0.357051\nexit_group-32 3 0.165823\nexit_group-32-no-syscallbuf 3 0.160489\nexit_race-32 3 1.42874\nexit_race-32-no-syscallbuf 3 1.20134\nexit_status-32 3 0.104493\nexit_status-32-no-syscallbuf 3 0.10491\nx86/explicit_checkpoints-32 3 1.19559\nx86/explicit_checkpoints-32-no-syscallbuf 3 1.16154\nfd_limit-32 3 0.190347\nfd_limit-32-no-syscallbuf 3 1.10721\nfork_stress-32 3 2.70758\nfork_stress-32-no-syscallbuf 3 1.18989\nfork_syscalls-32 3 0.155506\nfork_syscalls-32-no-syscallbuf 3 0.188712\nfunction_calls-32 3 2.63949\nfunction_calls-32-no-syscallbuf 3 2.96793\nx86/fxregs-32 3 0.746486\nx86/fxregs-32-no-syscallbuf 3 0.750233\ngetcwd-32 3 0.151393\ngetcwd-32-no-syscallbuf 3 0.14999\ngdb_bogus_breakpoint-32 3 0.751957\ngdb_bogus_breakpoint-32-no-syscallbuf 3 0.747864\ngoto_event-32 3 3.01067\ngoto_event-32-no-syscallbuf 3 1.68248\nhello-32 3 0.169985\nhello-32-no-syscallbuf 3 0.155974\nhooks-32 3 1.30262\nhooks-32-no-syscallbuf 3 0.0218813\nignored_async_usr1-32 3 2.06897\nignored_async_usr1-32-no-syscallbuf 3 2.86715\nignored_sigsegv-32 3 0.359044\nignored_sigsegv-32-no-syscallbuf 3 0.33573\nignore_nested-32 3 0.303741\nignore_nested-32-no-syscallbuf 3 0.289081\nimmediate_restart-32 3 0.849732\nimmediate_restart-32-no-syscallbuf 3 0.865976\nx86/int3_ok-32 3 0.159444\nx86/int3_ok-32-no-syscallbuf 3 0.152736\ninterrupt-32 3 4.60296\ninterrupt-32-no-syscallbuf 3 4.15208\nintr_ptrace_decline-32 3 5.00777\nintr_ptrace_decline-32-no-syscallbuf 3 4.69584\ninvalid_interpreter-32 3 5.5485\ninvalid_interpreter-32-no-syscallbuf 3 6.50341\ninvalid_jump-32 3 2.73029\ninvalid_jump-32-no-syscallbuf 3 1.53563\njit_proc_mem-32 3 0.831693\njit_proc_mem-32-no-syscallbuf 3 0.821895\nlink-32 3 0.174756\nlink-32-no-syscallbuf 3 0.152836\nmadvise_dontfork-32 3 0.867081\nmadvise_dontfork-32-no-syscallbuf 3 0.872768\nmain_thread_exit-32 3 0.912936\nmain_thread_exit-32-no-syscallbuf 3 0.921572\nmany_yields-32 3 2.5944\nmany_yields-32-no-syscallbuf 3 2.02695\nmmap_fd_reuse_checkpoint-32 3 0.881817\nmmap_fd_reuse_checkpoint-32-no-syscallbuf 3 0.889229\nmmap_replace_most_mappings-32 3 2.14156\nmmap_replace_most_mappings-32-no-syscallbuf 3 1.99783\nmmap_shared_prot-32 3 0.891155\nmmap_shared_prot-32-no-syscallbuf 3 0.884203\nmmap_shared_write_exec_race-32 3 3.65566\nmmap_shared_write_exec_race-32-no-syscallbuf 3 4.31505\nmmap_tmpfs-32 3 0.168187\nmmap_tmpfs-32-no-syscallbuf 3 0.160034\nmmap_write-32 3 0.0215652\nmmap_write-32-no-syscallbuf 3 0.020991\nmmap_write_private-32 3 0.265184\nmmap_write_private-32-no-syscallbuf 3 0.274526\nmorestack_unwind-32 1 0.537327\nmorestack_unwind-32-no-syscallbuf 1 0.0202514\nmprotect_growsdown-32 3 0.296293\nmprotect_growsdown-32-no-syscallbuf 3 0.277314\nmprotect_syscallbuf_overflow-32 3 0.27817\nmprotect_syscallbuf_overflow-32-no-syscallbuf 3 9.01023\nmutex_pi_stress-32 3 23.3154\nmutex_pi_stress-32-no-syscallbuf 3 26.4688\nnested_detach_wait-32 3 0.507768\nnested_detach_wait-32-no-syscallbuf 3 0.494804\noverflow_branch_counter-32 3 2.63386\noverflow_branch_counter-32-no-syscallbuf 3 2.79984\npatch_page_end-32 3 0.163768\npatch_page_end-32-no-syscallbuf 3 0.0242372\nx86/patch_40_80_f6_81-32 3 0.156124\nx86/patch_40_80_f6_81-32-no-syscallbuf 3 0.0233381\nperf_event_mmap-32 3 0.838548\nperf_event_mmap-32-no-syscallbuf 3 0.835866\npriority-32 3 0.16253\npriority-32-no-syscallbuf 3 0.161785\nptrace_remote_unmap-32 3 3.71517\nptrace_remote_unmap-32-no-syscallbuf 3 3.35802\nread_big_struct-32 3 0.836645\nread_big_struct-32-no-syscallbuf 3 0.896171\nremove_latest_trace-32 3 1.18545\nremove_latest_trace-32-no-syscallbuf 3 1.17654\nrestart_abnormal_exit-32 3 1.05629\nrestart_abnormal_exit-32-no-syscallbuf 3 1.03347\nreverse_continue_breakpoint-32 3 1.46066\nreverse_continue_breakpoint-32-no-syscallbuf 3 1.52823\nreverse_continue_multiprocess-32 3 10.0453\nreverse_continue_multiprocess-32-no-syscallbuf 3 9.53719\nreverse_continue_process_signal-32 3 2.93655\nreverse_continue_process_signal-32-no-syscallbuf 3 3.84094\nreverse_many_breakpoints-32 3 3.22103\nreverse_many_breakpoints-32-no-syscallbuf 3 3.91635\nreverse_step_long-32 3 5.47224\nreverse_step_long-32-no-syscallbuf 3 7.10854\nreverse_step_threads-32 3 2.41595\nreverse_step_threads-32-no-syscallbuf 3 2.25214\nreverse_step_threads_break-32 3 3.85589\nreverse_step_threads_break-32-no-syscallbuf 3 4.13086\nrr_ps-32 3 0.352589\nrr_ps-32-no-syscallbuf 3 0.303507\nrr_ps_ns-32 3 0.201816\nrr_ps_ns-32-no-syscallbuf 3 0.203488\nrseq-32 3 48.676\nrseq-32-no-syscallbuf 3 59.1352\nsearch-32 3 0.823497\nsearch-32-no-syscallbuf 3 0.791839\nseccomp_blocks_rr-32 3 0.320542\nseccomp_blocks_rr-32-no-syscallbuf 3 0.163554\nseccomp_signals-32 3 2.67807\nseccomp_signals-32-no-syscallbuf 3 2.71289\nsegfault-32 3 0.168754\nsegfault-32-no-syscallbuf 3 0.15359\nshared_map-32 3 0.207258\nshared_map-32-no-syscallbuf 3 0.194363\nshared_persistent_file-32 3 0.913624\nshared_persistent_file-32-no-syscallbuf 3 0.867889\nsignal_numbers-32 3 0.999511\nsignal_numbers-32-no-syscallbuf 3 0.976622\nsigprocmask_race-32 3 0.161489\nsigprocmask_race-32-no-syscallbuf 3 0.0207901\nsigprocmask_rr_sigs_nondefault-32 3 0.107611\nsigprocmask_rr_sigs_nondefault-32-no-syscallbuf 3 0.0949726\nsimple-32 3 0.274747\nsimple-32-no-syscallbuf 3 0.254695\nx86/singlestep_pushf-32 3 0.813864\nx86/singlestep_pushf-32-no-syscallbuf 3 0.743535\nstack_growth-32 3 0.800243\nstack_growth-32-no-syscallbuf 3 0.822085\nstep_thread-32 3 0.922024\nstep_thread-32-no-syscallbuf 3 0.945214\nstrict_priorities-32 3 9.52235\nstrict_priorities-32-no-syscallbuf 3 10.5882\nx86/string_instructions-32 3 0.666767\nx86/string_instructions-32-no-syscallbuf 3 0.631986\nx86/string_instructions_async_signals-32 3 0.230043\nx86/string_instructions_async_signals-32-no-syscallbuf 3 47.2284\nx86/string_instructions_async_signals_shared-32 3 0.248879\nx86/string_instructions_async_signals_shared-32-no-syscallbuf 3 61.0602\nx86/string_instructions_multiwatch-32 3 0.847261\nx86/string_instructions_multiwatch-32-no-syscallbuf 3 0.779672\nx86/string_instructions_replay-32 3 12.2112\nx86/string_instructions_replay-32-no-syscallbuf 3 11.6733\nx86/string_instructions_singlestep_fastforward-32 3 11.808\nx86/string_instructions_singlestep_fastforward-32-no-syscallbuf 3 11.9804\nx86/string_instructions_watch-32 3 0.872193\nx86/string_instructions_watch-32-no-syscallbuf 3 0.862499\nsyscallbuf_fd_disabling-32 3 0.258406\nsyscallbuf_fd_disabling-32-no-syscallbuf 3 0.238307\nsyscallbuf_signal_blocking_read-32 3 1.11503\nsyscallbuf_signal_blocking_read-32-no-syscallbuf 3 1.03876\nsysconf_onln-32 3 0.316152\nsysconf_onln-32-no-syscallbuf 3 0.306085\ntarget_fork-32 3 2.28992\ntarget_fork-32-no-syscallbuf 3 1.51753\ntarget_process-32 3 1.20558\ntarget_process-32-no-syscallbuf 3 1.13331\ntcp_sockets-32 3 0.146079\ntcp_sockets-32-no-syscallbuf 3 0.139738\nterm_nonmain-32 3 0.179605\nterm_nonmain-32-no-syscallbuf 3 0.17684\nterm_rr-32 3 4.09212\nterm_rr-32-no-syscallbuf 3 4.08009\nterm_trace_reset-32 3 0.190674\nterm_trace_reset-32-no-syscallbuf 3 0.191812\nterm_trace_syscall-32 3 0.197947\nterm_trace_syscall-32-no-syscallbuf 3 0.204153\nthread_exit_signal-32 3 2.23372\nthread_exit_signal-32-no-syscallbuf 3 2.15126\nthread_open_race-32 3 55.872\nthread_open_race-32-no-syscallbuf 3 0.0219118\nthread_stress-32 3 14.8451\nthread_stress-32-no-syscallbuf 3 16.8795\nthreaded_syscall_spam-32 3 1.84407\nthreaded_syscall_spam-32-no-syscallbuf 3 0.0210993\nthreads-32 3 1.18562\nthreads-32-no-syscallbuf 3 1.14132\ntls-32 3 0.882768\ntls-32-no-syscallbuf 3 0.82319\nttyname-32 3 0.144578\nttyname-32-no-syscallbuf 3 0.158472\nunexpected_stack_growth-32 3 6.15177\nunexpected_stack_growth-32-no-syscallbuf 3 0.856114\nuser_ignore_sig-32 3 0.158082\nuser_ignore_sig-32-no-syscallbuf 3 0.150497\nvdso_clock_gettime_stack-32 3 0.0208382\nvdso_clock_gettime_stack-32-no-syscallbuf 3 0.0207882\nvdso_gettimeofday_stack-32 3 0.0206608\nvdso_gettimeofday_stack-32-no-syscallbuf 3 0.0209766\nvdso_time_stack-32 3 0.0216031\nvdso_time_stack-32-no-syscallbuf 3 0.0212657\nvfork-32 3 0.211262\nvfork-32-no-syscallbuf 3 0.25298\nvfork_read_clone_stress-32 3 1.43335\nvfork_read_clone_stress-32-no-syscallbuf 3 2.11159\nvsyscall_reverse_next-32 3 141.046\nvsyscall_reverse_next-32-no-syscallbuf 3 137.178\nwait_for_all-32 3 1.13133\nwait_for_all-32-no-syscallbuf 3 1.13018\nwatchpoint-32 3 1.13577\nwatchpoint-32-no-syscallbuf 3 1.23384\nwatchpoint_at_sched-32 3 1.11\nwatchpoint_at_sched-32-no-syscallbuf 3 1.14594\nwatchpoint_before_signal-32 3 0.854689\nwatchpoint_before_signal-32-no-syscallbuf 3 0.810239\nwatchpoint_no_progress-32 3 2.72562\nwatchpoint_no_progress-32-no-syscallbuf 3 1.50164\nwatchpoint_size_change-32 3 0.858281\nwatchpoint_size_change-32-no-syscallbuf 3 0.850796\nwatchpoint_syscall-32 3 0.856296\nwatchpoint_syscall-32-no-syscallbuf 3 0.782193\nwatchpoint_unaligned-32 3 1.03794\nwatchpoint_unaligned-32-no-syscallbuf 3 1.05474\nasync_signal_syscalls_100-32 3 0.176285\nasync_signal_syscalls_100-32-no-syscallbuf 3 4.23242\nasync_signal_syscalls_1000-32 3 0.169197\nasync_signal_syscalls_1000-32-no-syscallbuf 3 3.55888\nbad_breakpoint-32 3 7.62464\nbad_breakpoint-32-no-syscallbuf 3 7.8842\nbreak_block-32 3 9.81985\nbreak_block-32-no-syscallbuf 3 9.85605\nbreak_clock-32 3 0.891678\nbreak_clock-32-no-syscallbuf 3 1.05496\nbreak_clone-32 3 0.740432\nbreak_clone-32-no-syscallbuf 3 0.790172\nbreak_exec-32 3 0.802764\nbreak_exec-32-no-syscallbuf 3 0.826882\nbreak_int3-32 3 0.750634\nbreak_int3-32-no-syscallbuf 3 0.731741\nbreak_mmap_private-32 3 1.91277\nbreak_mmap_private-32-no-syscallbuf 3 1.85261\nbreak_msg-32 3 2.67174\nbreak_msg-32-no-syscallbuf 3 2.77454\nx86/break_rdtsc-32 3 0.820217\nx86/break_rdtsc-32-no-syscallbuf 3 0.805801\nbreak_sigreturn-32 3 4.76704\nbreak_sigreturn-32-no-syscallbuf 3 4.826\nbreak_sync_signal-32 3 0.731987\nbreak_sync_signal-32-no-syscallbuf 3 0.739062\nbreak_thread-32 3 0.878548\nbreak_thread-32-no-syscallbuf 3 1.04768\nbreak_time_slice-32 3 8.40304\nbreak_time_slice-32-no-syscallbuf 3 8.37739\nbreakpoint_consistent-32 3 0.76863\nbreakpoint_consistent-32-no-syscallbuf 3 0.751159\ncall_exit-32 3 0.944958\ncall_exit-32-no-syscallbuf 3 0.939937\ncheck_patched_pthread-32 3 1.81349\ncheck_patched_pthread-32-no-syscallbuf 3 1.79483\ncheckpoint_async_signal_syscalls_1000-32 3 2.22798\ncheckpoint_async_signal_syscalls_1000-32-no-syscallbuf 3 0.0215992\ncheckpoint_mmap_shared-32 3 18.6084\ncheckpoint_mmap_shared-32-no-syscallbuf 3 13.8794\ncheckpoint_prctl_name-32 3 23.0868\ncheckpoint_prctl_name-32-no-syscallbuf 3 21.7651\ncheckpoint_simple-32 3 6.7996\ncheckpoint_simple-32-no-syscallbuf 3 5.09097\nchecksum_sanity_noclone-32 3 1.31514\nchecksum_sanity_noclone-32-no-syscallbuf 3 1.49628\ncomm-32 3 0.61876\ncomm-32-no-syscallbuf 3 0.620591\ncont_signal-32 3 4.73211\ncont_signal-32-no-syscallbuf 3 4.75449\nx86/cpuid-32 3 1.16829\nx86/cpuid-32-no-syscallbuf 3 0.923756\ndead_thread_target-32 3 0.942176\ndead_thread_target-32-no-syscallbuf 3 0.926653\ndesched_ticks-32 3 0.821425\ndesched_ticks-32-no-syscallbuf 3 0.0225863\ndeliver_async_signal_during_syscalls-32 3 0.66533\ndeliver_async_signal_during_syscalls-32-no-syscallbuf 3 0.0210904\nenv_newline-32 3 0.15028\nenv_newline-32-no-syscallbuf 3 0.143948\nexec_deleted-32 3 0.158318\nexec_deleted-32-no-syscallbuf 3 0.150836\nexec_stop-32 3 0.851366\nexec_stop-32-no-syscallbuf 3 0.850134\nexecp-32 3 0.160006\nexecp-32-no-syscallbuf 3 0.144344\nexplicit_checkpoint_clone-32 3 0.917372\nexplicit_checkpoint_clone-32-no-syscallbuf 3 0.899579\nfile_name_newline-32 3 0.162767\nfile_name_newline-32-no-syscallbuf 3 0.146534\nfinal_sigkill-32 3 0.907278\nfinal_sigkill-32-no-syscallbuf 3 0.899301\nfirst_instruction-32 3 5.60671\nfirst_instruction-32-no-syscallbuf 3 2.67149\nfork_exec_info_thr-32 3 3.29816\nfork_exec_info_thr-32-no-syscallbuf 3 2.95928\nget_thread_list-32 3 0.942064\nget_thread_list-32-no-syscallbuf 3 0.911207\nhardlink_mmapped_files-32 3 2.19101\nhardlink_mmapped_files-32-no-syscallbuf 3 2.17723\nhbreak-32 3 0.837334\nhbreak-32-no-syscallbuf 3 0.845015\nmprotect_step-32 3 0.980319\nmprotect_step-32-no-syscallbuf 3 1.03667\nnested_detach-32 3 2.10512\nnested_detach-32-no-syscallbuf 3 2.05432\nnested_detach_kill-32 3 0.5623\nnested_detach_kill-32-no-syscallbuf 3 0.510195\nnested_release-32 3 0.282025\nnested_release-32-no-syscallbuf 3 0.305014\nparent_no_break_child_bkpt-32 3 0.984814\nparent_no_break_child_bkpt-32-no-syscallbuf 3 0.961328\nparent_no_stop_child_crash-32 3 0.969948\nparent_no_stop_child_crash-32-no-syscallbuf 3 3.786\npost_exec_fpu_regs-32 3 0.600815\npost_exec_fpu_regs-32-no-syscallbuf 3 0.599346\nproc_maps-32 3 0.736028\nproc_maps-32-no-syscallbuf 3 0.774179\nread_bad_mem-32 3 0.722698\nread_bad_mem-32-no-syscallbuf 3 0.729764\nrecord_replay-32 3 136.043\nrecord_replay-32-no-syscallbuf 3 150.954\nremove_watchpoint-32 3 0.843034\nremove_watchpoint-32-no-syscallbuf 3 0.806226\nreplay_overlarge_event_number-32 3 0.139763\nreplay_overlarge_event_number-32-no-syscallbuf 3 0.134153\nreplay_serve_files-32 3 3.41732\nreplay_serve_files-32-no-syscallbuf 3 3.58874\nrestart_invalid_checkpoint-32 3 0.990035\nrestart_invalid_checkpoint-32-no-syscallbuf 3 0.946249\nrestart_unstable-32 3 0.910166\nrestart_unstable-32-no-syscallbuf 3 0.891157\nrestart_diversion-32 3 0.989601\nrestart_diversion-32-no-syscallbuf 3 0.997177\nreverse_alarm-32 3 4.879\nreverse_alarm-32-no-syscallbuf 3 4.06193\nreverse_continue_exec_subprocess-32 3 2.78078\nreverse_continue_exec_subprocess-32-no-syscallbuf 3 2.77524\nreverse_continue_fork_subprocess-32 3 1.08481\nreverse_continue_fork_subprocess-32-no-syscallbuf 3 1.05656\nreverse_continue_int3-32 3 3.04754\nreverse_continue_int3-32-no-syscallbuf 3 2.85159\nreverse_continue_start-32 3 1.45292\nreverse_continue_start-32-no-syscallbuf 3 1.55508\nreverse_finish-32 3 2.07223\nreverse_finish-32-no-syscallbuf 3 1.89863\nreverse_step_breakpoint-32 3 3.09712\nreverse_step_breakpoint-32-no-syscallbuf 3 3.14195\nreverse_step_signal-32 3 3.29368\nreverse_step_signal-32-no-syscallbuf 3 3.35527\nreverse_step_threads2-32 3 3.66363\nreverse_step_threads2-32-no-syscallbuf 3 3.6717\nreverse_watchpoint-32 3 2.6772\nreverse_watchpoint-32-no-syscallbuf 3 2.79468\nreverse_watchpoint_syscall-32 3 5.7712\nreverse_watchpoint_syscall-32-no-syscallbuf 3 5.42939\nrun_end-32 3 1.04191\nrun_end-32-no-syscallbuf 3 1.04049\nrun_in_function-32 3 0.900408\nrun_in_function-32-no-syscallbuf 3 0.916535\nsanity-32 3 0.71032\nsanity-32-no-syscallbuf 3 0.712727\nseekticks-32 3 1.99423\nseekticks-32-no-syscallbuf 3 1.8498\nshm_checkpoint-32 3 0.939245\nshm_checkpoint-32-no-syscallbuf 3 0.913725\nsiginfo-32 3 0.712749\nsiginfo-32-no-syscallbuf 3 0.756536\nx86/sigreturn_checksum-32 3 0.663451\nx86/sigreturn_checksum-32-no-syscallbuf 3 0.632378\nsignal_stop-32 3 0.747289\nsignal_stop-32-no-syscallbuf 3 0.789135\nsignal_checkpoint-32 3 0.888263\nsignal_checkpoint-32-no-syscallbuf 3 0.923522\nsimple_script-32 3 0.161959\nsimple_script-32-no-syscallbuf 3 0.1755\nsimple_script_debug-32 3 0.876329\nsimple_script_debug-32-no-syscallbuf 3 0.861925\nsimple_winch-32 3 1.86968\nsimple_winch-32-no-syscallbuf 3 1.74261\nstack_overflow_debug-32 3 5.38016\nstack_overflow_debug-32-no-syscallbuf 3 5.08019\nstep1-32 3 0.805849\nstep1-32-no-syscallbuf 3 0.742349\nx86/step_rdtsc-32 3 0.837208\nx86/step_rdtsc-32-no-syscallbuf 3 0.879747\nstep_signal-32 3 0.841635\nstep_signal-32-no-syscallbuf 3 0.867701\nx86/string_instructions_break-32 3 6.13452\nx86/string_instructions_break-32-no-syscallbuf 3 6.81011\nx86/string_instructions_replay_quirk-32 3 6.07682\nx86/string_instructions_replay_quirk-32-no-syscallbuf 3 6.45033\nsubprocess_exit_ends_session-32 3 3.62394\nsubprocess_exit_ends_session-32-no-syscallbuf 3 4.04868\nswitch_processes-32 3 4.0944\nswitch_processes-32-no-syscallbuf 3 3.3082\nsyscallbuf_timeslice_250-32 3 0.220478\nsyscallbuf_timeslice_250-32-no-syscallbuf 3 3.58343\ntrace_version-32 3 2.79074\ntrace_version-32-no-syscallbuf 3 3.11765\nterm_trace_cpu-32 3 0.41638\nterm_trace_cpu-32-no-syscallbuf 3 0.466491\ntrace_events-32 3 0.119915\ntrace_events-32-no-syscallbuf 3 0.11621\ntty-32 3 0.147832\ntty-32-no-syscallbuf 3 0.135114\nunmap_vdso-32 3 0.240556\nunmap_vdso-32-no-syscallbuf 3 0.241763\nunwind_on_signal-32 3 0.772052\nunwind_on_signal-32-no-syscallbuf 3 0.761767\nvfork_exec-32 3 0.835302\nvfork_exec-32-no-syscallbuf 3 4.25382\nvfork_break_parent-32 3 0.841462\nvfork_break_parent-32-no-syscallbuf 3 0.834457\nvsyscall_singlestep-32 3 0.0212182\nvsyscall_singlestep-32-no-syscallbuf 3 0.0217498\nwatch_code-32 3 1.55016\nwatch_code-32-no-syscallbuf 3 1.52215\nwatchpoint_cond-32 3 0.761356\nwatchpoint_cond-32-no-syscallbuf 3 0.742508\nwhen-32 3 0.747301\nwhen-32-no-syscallbuf 3 0.762781\nclose_range 2 0.148235\nclose_range-no-syscallbuf 2 0.144619\ndlchecksum 2 0.172606\ndlchecksum-no-syscallbuf 2 0.15371\nepoll_many 2 0.173947\nepoll_many-no-syscallbuf 2 0.171837\nepoll_pwait2 2 1.21091\nepoll_pwait2-no-syscallbuf 2 1.16894\nfutex_invalid_op 2 0.144616\nfutex_invalid_op-no-syscallbuf 2 0.165618\nfutex_restart_race 2 0.24007\nfutex_restart_race-no-syscallbuf 2 0.203436\nfutex_restart_clone 2 0.170832\nfutex_restart_clone-no-syscallbuf 2 0.157809\nioctl_br 2 0.297665\nioctl_br-no-syscallbuf 2 0.406779\nmremap_dontunmap 2 0.167215\nmremap_dontunmap-no-syscallbuf 2 0.149812\nppoll_deliver 2 0.160526\nppoll_deliver-no-syscallbuf 2 0.159987\nx86/rdtsc_flags 2 0.137952\nx86/rdtsc_flags-no-syscallbuf 2 0.129515\nx86/signal_xmm_state 2 3.57247\nx86/signal_xmm_state-no-syscallbuf 2 3.39495\nsigpwr 2 0.140614\nsigpwr-no-syscallbuf 2 0.140422\nsock_name_null 2 0.145081\nsock_name_null-no-syscallbuf 2 0.124984\nsysconf_conf 2 0.137988\nsysconf_conf-no-syscallbuf 2 0.135366\nchaos_oom 2 0.560681\nchaos_oom-no-syscallbuf 2 0.452135\nx86/diversion_rdtsc 2 0.872436\nx86/diversion_rdtsc-no-syscallbuf 2 0.924278\ngdb_qpasssignals 2 81.0278\ngdb_qpasssignals-no-syscallbuf 2 87.6319\nmadvise_fracture_flags 2 29.0459\nmadvise_fracture_flags-no-syscallbuf 2 44.4081\nx86/morestack_unwind 2 0.931251\nx86/morestack_unwind-no-syscallbuf 2 0.026461\nnested_detach_kill_stuck 2 5.47602\nnested_detach_kill_stuck-no-syscallbuf 2 5.4523\nx86/rdtsc_loop 2 9.70436\nx86/rdtsc_loop-no-syscallbuf 2 0.0229299\nx86/rdtsc_loop2 2 3.61317\nx86/rdtsc_loop2-no-syscallbuf 2 0.0397882\nrseq_syscallbuf 2 2.17548\nrseq_syscallbuf-no-syscallbuf 2 0.0213682\nseccomp_open 2 0.198042\nseccomp_open-no-syscallbuf 2 0.165744\nx86/syscallbuf_branch_check 2 0.19857\nx86/syscallbuf_branch_check-no-syscallbuf 2 0.0296137\nx86/syscallbuf_rdtsc_page 2 0.169948\nx86/syscallbuf_rdtsc_page-no-syscallbuf 2 0.0215339\nterm_rr_ok 2 0.183501\nterm_rr_ok-no-syscallbuf 2 0.255434\ncopy_all 2 0.893463\ncopy_all-no-syscallbuf 2 0.834937\ntick0 2 0.799063\ntick0-no-syscallbuf 2 0.782866\ntick0_less 2 0.749213\ntick0_less-no-syscallbuf 2 0.703801\nwatchpoint_unaligned2 2 0.899431\nwatchpoint_unaligned2-no-syscallbuf 2 0.904094\nclose_range-32 2 0.143941\nclose_range-32-no-syscallbuf 2 0.148777\ndlchecksum-32 2 0.181072\ndlchecksum-32-no-syscallbuf 2 0.182325\nepoll_many-32 2 0.139354\nepoll_many-32-no-syscallbuf 2 0.153966\nepoll_pwait2-32 2 1.15499\nepoll_pwait2-32-no-syscallbuf 2 1.12574\nfutex_invalid_op-32 2 0.184322\nfutex_invalid_op-32-no-syscallbuf 2 0.156609\nfutex_restart_race-32 2 0.212542\nfutex_restart_race-32-no-syscallbuf 2 0.187618\nfutex_restart_clone-32 2 0.167387\nfutex_restart_clone-32-no-syscallbuf 2 0.168281\nioctl_br-32 2 0.176593\nioctl_br-32-no-syscallbuf 2 0.151187\nmremap_dontunmap-32 2 0.155741\nmremap_dontunmap-32-no-syscallbuf 2 0.120021\nppoll_deliver-32 2 0.144606\nppoll_deliver-32-no-syscallbuf 2 0.15629\nx86/rdtsc_flags-32 2 0.145916\nx86/rdtsc_flags-32-no-syscallbuf 2 0.150495\nx86/signal_xmm_state-32 2 3.22473\nx86/signal_xmm_state-32-no-syscallbuf 2 3.29032\nsigpwr-32 2 0.133221\nsigpwr-32-no-syscallbuf 2 0.124058\nsock_name_null-32 2 0.161211\nsock_name_null-32-no-syscallbuf 2 0.146322\nsysconf_conf-32 2 0.18367\nsysconf_conf-32-no-syscallbuf 2 0.145432\nchaos_oom-32 2 0.185595\nchaos_oom-32-no-syscallbuf 2 0.16476\nx86/diversion_rdtsc-32 2 0.838864\nx86/diversion_rdtsc-32-no-syscallbuf 2 0.855848\ngdb_qpasssignals-32 2 54.7265\ngdb_qpasssignals-32-no-syscallbuf 2 81.3144\nmadvise_fracture_flags-32 2 29.5068\nmadvise_fracture_flags-32-no-syscallbuf 2 43.1837\nx86/morestack_unwind-32 2 0.966484\nx86/morestack_unwind-32-no-syscallbuf 2 0.0770165\nnested_detach_kill_stuck-32 2 5.57303\nnested_detach_kill_stuck-32-no-syscallbuf 2 5.4918\nx86/rdtsc_loop-32 2 0.149644\nx86/rdtsc_loop-32-no-syscallbuf 2 0.0242253\nx86/rdtsc_loop2-32 2 0.0696302\nx86/rdtsc_loop2-32-no-syscallbuf 2 0.0495866\nrseq_syscallbuf-32 2 2.78341\nrseq_syscallbuf-32-no-syscallbuf 2 0.02137\nseccomp_open-32 2 0.173412\nseccomp_open-32-no-syscallbuf 2 0.149496\nx86/syscallbuf_branch_check-32 2 0.222951\nx86/syscallbuf_branch_check-32-no-syscallbuf 2 0.0375623\nx86/syscallbuf_rdtsc_page-32 2 0.1562\nx86/syscallbuf_rdtsc_page-32-no-syscallbuf 2 0.0225459\nterm_rr_ok-32 2 0.178006\nterm_rr_ok-32-no-syscallbuf 2 0.164041\ncopy_all-32 2 0.830029\ncopy_all-32-no-syscallbuf 2 0.798218\ntick0-32 2 0.696756\ntick0-32-no-syscallbuf 2 0.728154\ntick0_less-32 2 0.692545\ntick0_less-32-no-syscallbuf 2 0.680031\nwatchpoint_unaligned2-32 2 0.785344\nwatchpoint_unaligned2-32-no-syscallbuf 2 0.785254\nbig_select 1 0.122241\nbig_select-no-syscallbuf 1 0.115932\nbpf_query 1 0.142361\nbpf_query-no-syscallbuf 1 0.131865\ndetach_huge_mmap 1 0.148339\ndetach_huge_mmap-no-syscallbuf 1 0.139783\nfstatat 1 0.122254\nfstatat-no-syscallbuf 1 0.146384\nx86/hlt 1 0.131581\nx86/hlt-no-syscallbuf 1 0.145791\nlandlock 1 0.123054\nlandlock-no-syscallbuf 1 0.117692\nmadvise_dontneed_private 1 0.150188\nmadvise_dontneed_private-no-syscallbuf 1 0.120028\nmadvise_misc 1 0.15378\nmadvise_misc-no-syscallbuf 1 0.15016\nmadvise_remove 1 0.146105\nmadvise_remove-no-syscallbuf 1 0.114897\nmemfd_create_efault 1 0.130846\nmemfd_create_efault-no-syscallbuf 1 0.110675\nmlock_madvise 1 0.12743\nmlock_madvise-no-syscallbuf 1 0.110031\nmount_ns_execveat 1 0.194777\nmount_ns_execveat-no-syscallbuf 1 0.181548\nnetfilter_ipv6 1 0.139157\nnetfilter_ipv6-no-syscallbuf 1 0.161424\nopenat2 1 0.121073\nopenat2-no-syscallbuf 1 0.115417\nx86/patch_syscall_restart 1 0.160512\nx86/patch_syscall_restart-no-syscallbuf 1 0.168672\nperf_event_ioctl 1 0.148594\nperf_event_ioctl-no-syscallbuf 1 0.138686\npidfd_getfd 1 0.169156\npidfd_getfd-no-syscallbuf 1 0.128923\nprctl_anon_vma_name 1 0.173153\nprctl_anon_vma_name-no-syscallbuf 1 0.140698\nptrace_attach_syscall 1 0.206087\nptrace_attach_syscall-no-syscallbuf 1 0.188015\nptrace_sigchld 1 0.145944\nptrace_sigchld-no-syscallbuf 1 0.137416\nptrace_waiter_thread 1 0.166131\nptrace_waiter_thread-no-syscallbuf 1 0.157813\nsigframe_grow_stack 1 3.1515\nsigframe_grow_stack-no-syscallbuf 1 4.08248\nvfork_done 1 2.63613\nvfork_done-no-syscallbuf 1 2.4733\nvfork_setopts 1 0.148868\nvfork_setopts-no-syscallbuf 1 0.129542\nconcurrent_signals 1 1.67194\nconcurrent_signals-no-syscallbuf 1 1.66581\ncontext_switch_after_patch 1 0.191045\ncontext_switch_after_patch-no-syscallbuf 1 0.168646\nmprotect_checkpoint 1 4.0859\nmprotect_checkpoint-no-syscallbuf 1 2.99924\npack 1 0.47493\npack-no-syscallbuf 1 0.467682\nx86/rdtsc_interfering 1 10.2643\nx86/rdtsc_interfering-no-syscallbuf 1 0.0197651\nseekticks_threads 1 4.06068\nseekticks_threads-no-syscallbuf 1 4.30202\nstep_into_lib 1 1.00011\nstep_into_lib-no-syscallbuf 1 0.970043\ntracee_unmap_vdso 1 0.0180032\ntracee_unmap_vdso-no-syscallbuf 1 0.134259\nunicode 1 0.918995\nunicode-no-syscallbuf 1 0.953097\nwhen_threads 1 1.99325\nwhen_threads-no-syscallbuf 1 1.92408\nbreakpoint_print 1 1.71038\nbreakpoint_print-no-syscallbuf 1 1.6519\nchecksum_block_open 1 0.517415\nchecksum_block_open-no-syscallbuf 1 0.327791\nlarge_file 1 0.115809\nlarge_file-no-syscallbuf 1 0.13297\nnested_detach_stop 1 1.5455\nnested_detach_stop-no-syscallbuf 1 1.46919\ntransient_fault_replay_all 1 0.17006\ntransient_fault_replay_all-no-syscallbuf 1 0.155604\nvfork_done_clone 1 2.52903\nvfork_done_clone-no-syscallbuf 1 2.56115\nbig_select-32 1 0.132507\nbig_select-32-no-syscallbuf 1 0.11967\nbpf_query-32 1 0.124146\nbpf_query-32-no-syscallbuf 1 0.122492\ndetach_huge_mmap-32 1 0.167636\ndetach_huge_mmap-32-no-syscallbuf 1 0.180431\nfstatat-32 1 0.117417\nfstatat-32-no-syscallbuf 1 0.10673\nx86/hlt-32 1 0.139103\nx86/hlt-32-no-syscallbuf 1 0.128721\nlandlock-32 1 0.15054\nlandlock-32-no-syscallbuf 1 0.104344\nmadvise_dontneed_private-32 1 0.126815\nmadvise_dontneed_private-32-no-syscallbuf 1 0.137481\nmadvise_misc-32 1 0.139222\nmadvise_misc-32-no-syscallbuf 1 0.136681\nmadvise_remove-32 1 0.111512\nmadvise_remove-32-no-syscallbuf 1 0.104271\nmemfd_create_efault-32 1 0.152346\nmemfd_create_efault-32-no-syscallbuf 1 0.101308\nmlock_madvise-32 1 0.134032\nmlock_madvise-32-no-syscallbuf 1 0.117457\nmount_ns_execveat-32 1 0.182306\nmount_ns_execveat-32-no-syscallbuf 1 0.198207\nnetfilter_ipv6-32 1 0.148315\nnetfilter_ipv6-32-no-syscallbuf 1 0.127724\nopenat2-32 1 0.137687\nopenat2-32-no-syscallbuf 1 0.123855\nx86/patch_syscall_restart-32 1 0.127288\nx86/patch_syscall_restart-32-no-syscallbuf 1 0.115894\nperf_event_ioctl-32 1 0.123464\nperf_event_ioctl-32-no-syscallbuf 1 0.139612\npidfd_getfd-32 1 0.128887\npidfd_getfd-32-no-syscallbuf 1 0.129746\nprctl_anon_vma_name-32 1 0.156351\nprctl_anon_vma_name-32-no-syscallbuf 1 0.142877\nptrace_attach_syscall-32 1 0.199311\nptrace_attach_syscall-32-no-syscallbuf 1 0.183041\nptrace_sigchld-32 1 0.139781\nptrace_sigchld-32-no-syscallbuf 1 0.139409\nptrace_waiter_thread-32 1 0.164846\nptrace_waiter_thread-32-no-syscallbuf 1 0.12313\nsigframe_grow_stack-32 1 2.57634\nsigframe_grow_stack-32-no-syscallbuf 1 3.44717\nvfork_done-32 1 1.28647\nvfork_done-32-no-syscallbuf 1 1.25884\nvfork_setopts-32 1 0.119982\nvfork_setopts-32-no-syscallbuf 1 0.132373\nconcurrent_signals-32 1 1.68507\nconcurrent_signals-32-no-syscallbuf 1 1.74336\ncontext_switch_after_patch-32 1 0.17055\ncontext_switch_after_patch-32-no-syscallbuf 1 0.166858\nmprotect_checkpoint-32 1 5.38933\nmprotect_checkpoint-32-no-syscallbuf 1 5.27459\npack-32 1 0.46317\npack-32-no-syscallbuf 1 0.44023\nx86/rdtsc_interfering-32 1 0.0194198\nx86/rdtsc_interfering-32-no-syscallbuf 1 0.0188702\nseekticks_threads-32 1 2.5432\nseekticks_threads-32-no-syscallbuf 1 2.45435\nstep_into_lib-32 1 0.840179\nstep_into_lib-32-no-syscallbuf 1 0.772617\ntracee_unmap_vdso-32 1 0.0179555\ntracee_unmap_vdso-32-no-syscallbuf 1 0.0167012\nunicode-32 1 0.73177\nunicode-32-no-syscallbuf 1 0.74138\nwhen_threads-32 1 1.72537\nwhen_threads-32-no-syscallbuf 1 1.69476\nbreakpoint_print-32 1 1.26928\nbreakpoint_print-32-no-syscallbuf 1 1.31566\nchecksum_block_open-32 1 0.391778\nchecksum_block_open-32-no-syscallbuf 1 0.305321\nlarge_file-32 1 0.125391\nlarge_file-32-no-syscallbuf 1 0.107834\nnested_detach_stop-32 1 1.39362\nnested_detach_stop-32-no-syscallbuf 1 1.39936\ntransient_fault_replay_all-32 1 0.164634\ntransient_fault_replay_all-32-no-syscallbuf 1 0.181707\nvfork_done_clone-32 1 1.1347\nvfork_done_clone-32-no-syscallbuf 1 1.10141\n---\n" }, { "path": "scripts/github-actions-build.sh", "content": "#!/bin/bash\n\nset +x # echo commands\nset -e # default to exiting on error\"\n\nuname -a\n\nEXTRA_PACKAGES=\nMACHINE_TYPE=`uname -m`\nif [ $MACHINE_TYPE == 'x86_64' ]; then\n EXTRA_PACKAGES=g++-multilib\nfi\n\nsudo apt-get update -y\nsudo apt-get dist-upgrade -f -y\nsudo apt-get install -y $EXTRA_PACKAGES cmake g++ pkg-config zlib1g-dev git python-dev-is-python3 libacl1-dev ninja-build manpages-dev capnproto libcapnp-dev gdb lldb python3-pexpect libzstd1 libzstd-dev jq\n\nmkdir obj\ncd obj\ncmake -G Ninja -DCMAKE_BUILD_TYPE=DEBUG -Dstaticlibs=FALSE ..\nninja\n" }, { "path": "scripts/github-actions-test.sh", "content": "#!/bin/bash\n\nset +x # echo commands\n\n# Enable perf events for rr\necho 0 | sudo tee /proc/sys/kernel/perf_event_paranoid > /dev/null\n# Enable ptrace-attach to any process. This lets us get more data when tests fail.\necho 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope > /dev/null\n# Disable AppArmor restrictions on user namespaces, which our tests need to use\n(echo 0 | sudo tee /proc/sys/kernel/apparmor_restrict_unprivileged_userns) > /dev/null || true\nlet halfproc=`nproc`/2\ncd obj\nmkdir -p Testing/Temporary\nmv ../scripts/github-actions-CTestCostData.txt Testing/Temporary/CTestCostData.txt\nctest -j$halfproc --verbose\n\nSTATUS=$?\nif [[ $STATUS != 0 ]]; then\n mkdir $GITHUB_WORKSPACE/failed-tests\n #cp -a Testing/Temporary/CTestCostData.txt $GITHUB_WORKSPACE/failed-tests/rr-test-ctestcostdata.txt\n cd /tmp\n rm rr-test-cpu-lock || true\n for dir in rr-test-*; do\n echo \"Packing test /tmp/$dir\"\n $GITHUB_WORKSPACE/obj/bin/rr pack $dir/latest-trace\n tar zcf $GITHUB_WORKSPACE/failed-tests/$dir.tar.gz $dir\n rm -rf $dir\n done\nfi\n\nexit $STATUS\n" }, { "path": "scripts/reformat.sh", "content": "#!/bin/sh\n\nfind src -regex '.*\\.\\(c\\|h\\|cc\\)$'|xargs clang-format -style=file -i\n" }, { "path": "scripts/rr-collect-symbols.py", "content": "#!/usr/bin/env python3\n\nimport errno\nimport glob\nimport os\nimport re\nimport shutil\nimport subprocess\nimport sys\nimport tempfile\nfrom urllib.request import urlretrieve\nfrom urllib.error import HTTPError, ContentTooShortError\n\n# Usage: rr-collect-symbols.py [ | ]\n#\n# Given a , downloads the zip/.tar.zst file at , uncompresses it,\n# runs \"gunzip\" on any .gz files, and for any ELF files found whose build-ids\n# match the build-id of an ELF file in the trace, moves it into the trace.\n#\n# Given a , which must contain a .build-id directory with the usual\n# structure (e.g. as Ubuntu and Fedora create under /usr/lib/debug), searches\n# the directory tree for any ELF files whose build-ids match the build-id of\n# an ELF file in the trace and copies them into the trace. defaults to\n# \"/usr/lib/debug\", which will grab any available system debuginfo files\n# in Ubuntu and Fedora at least.\n#\n# This script assumes that the trace-dir has been packed via `rr pack` so all\n# relevant files actually appear in the trace-dir.\n# It also assumes rr is on the PATH.\n#\n# The debuginfo files are placed in the trace under a \"debug\" subdirectory,\n# in a \".build-id\" subdirectory with the usual structure.\n#\n# If a debuginfo file contains a .gnu_debugaltlink section then we also\n# attempt to find the referenced file and copy it into the trace with the\n# same file name as the .debug file, but with a .sup suffix.\n\nif len(sys.argv) < 2:\n print(\"Usage: rr-collect-symbols.py [ | ]\", file=sys.stderr)\n sys.exit(1)\ntrace_dir = sys.argv[1]\n\nif len(sys.argv) < 3:\n source = \"/usr/lib/debug\"\nelse:\n source = sys.argv[2]\n\nrr_buildid = subprocess.Popen([\"rr\", \"buildid\"],\n stdin=subprocess.PIPE,\n stdout=subprocess.PIPE)\n\ndef build_id_for(file):\n global rr_buildid\n rr_buildid.stdin.write((\"%s\\n\"%file).encode('utf-8'))\n try:\n rr_buildid.stdin.flush()\n except BrokenPipeError:\n print(\"Can't write to rr, termination code %s\"%rr_buildid.returncode, file=sys.stderr)\n sys.exit(2)\n return rr_buildid.stdout.readline().rstrip().decode('utf-8')\n\naltref_regex = re.compile(rb\"^\\s+\\[\\s*0\\]\\s+(.*)\");\n\ndef find_altref(file):\n proc = subprocess.Popen([\"readelf\", \"-p\", \".gnu_debugaltlink\", file], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)\n try:\n for line in proc.stdout:\n m = altref_regex.match(line)\n if m:\n return m.group(1).rstrip()\n finally:\n proc.wait()\n return None\n\ndef find_altref_for_trace_file(trace_file, altref):\n proc = subprocess.Popen([\"rr\", \"filename\", trace_file], stdout=subprocess.PIPE)\n try:\n for line in proc.stdout:\n file = line.rstrip()\n altref_file = os.path.join(os.path.dirname(file), altref)\n if os.path.isfile(altref_file):\n return altref_file\n finally:\n proc.wait()\n return None\n\ndef mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise\n\n# 'dst' must be a complete file name, not a directory.\ndef copy_file(src, dst):\n try:\n # Remove the destination file in case it's a hard link\n # or owned by someone else.\n os.remove(dst)\n except:\n pass\n shutil.copy(src, dst)\n\n# 'dst' must be a complete file name, not a directory\ndef create_link(src, dst):\n try:\n # Remove the destination file in case it's wrong.\n os.remove(dst)\n except:\n pass\n os.symlink(src, dst)\n\ndef collect_trace_build_ids():\n ret = {}\n for file in glob.iglob(\"%s/mmap_*\"%trace_dir):\n build_id = build_id_for(file)\n if build_id:\n ret[build_id] = True\n altref = find_altref(file)\n if altref:\n altref_file = find_altref_for_trace_file(file, altref)\n if not altref_file:\n print(\"WARNING: Can't find alt file %s for %s\"%(altref, file))\n continue\n dir = \"%s/debug/.build-id/%s\"%(trace_dir, build_id[:2])\n mkdir_p(dir)\n copy_file(altref_file, \"%s/%s.sup\"%(dir, build_id[2:]))\n return ret\n\ntrace_build_ids = collect_trace_build_ids()\n\ndef collect_archive(url):\n is_tar_zst = url.endswith(\".tar.zst\")\n tmp_dir = tempfile.mkdtemp(dir=trace_dir)\n if is_tar_zst:\n tmp_file_name = \"%s/archive.tar.zst\"%tmp_dir\n else:\n # Assume its a ZIP\n tmp_file_name = \"%s/archive.zip\"%tmp_dir\n try:\n (file, headers) = urlretrieve(url, tmp_file_name)\n except (HTTPError, ContentTooShortError) as exc:\n print(\"Failed to load archive %s: %s\"%(url, exc), file=sys.stderr)\n sys.exit(2)\n if is_tar_zst:\n subprocess.check_call([\"tar\", \"-C\", tmp_dir, \"-I\", \"zstd\", \"-xvf\", file])\n else:\n subprocess.check_call([\"unzip\", \"-d\", tmp_dir, file])\n os.remove(file)\n\n for root, dirs, files in os.walk(tmp_dir):\n for name in files:\n file = os.path.join(root, name)\n if file.endswith(\".gz\"):\n subprocess.check_call([\"gunzip\", file])\n file = file[:-3]\n build_id = build_id_for(file)\n if build_id and build_id in trace_build_ids:\n dir = \"%s/debug/.build-id/%s\"%(trace_dir, build_id[:2])\n mkdir_p(dir)\n dst = \"%s/%s.debug\"%(dir, build_id[2:])\n os.rename(file, dst)\n else:\n os.remove(file)\n\n shutil.rmtree(tmp_dir)\n\ndef collect_filesystem(path):\n for root, dirs, files in os.walk(path):\n for name in files:\n file = os.path.join(root, name)\n if not os.path.islink(file):\n build_id = build_id_for(file)\n if build_id and build_id in trace_build_ids:\n dir = \"%s/debug/.build-id/%s\"%(trace_dir, build_id[:2])\n mkdir_p(dir)\n copy_file(file, \"%s/%s.debug\"%(dir, build_id[2:]))\n altref = find_altref(file)\n if altref:\n altref = altref.decode('utf-8')\n altref_file = os.path.join(os.path.dirname(file), altref)\n copy_file(altref_file, \"%s/%s.sup\"%(dir, build_id[2:]))\n if altref.startswith(\"../../../.dwz/\"):\n mkdir_p(\"%s/.dwz\"%trace_dir)\n src = \"../debug/.build-id/%s/%s.sup\"%(build_id[:2], build_id[2:])\n create_link(src, \"%s/.dwz/%s\"%(trace_dir, altref[14:]))\n elif altref.startswith(\"../../.dwz/\"):\n mkdir_p(\"%s/debug/.dwz\"%trace_dir)\n src = \"../.build-id/%s/%s.sup\"%(build_id[:2], build_id[2:])\n create_link(src, \"%s/debug/.dwz/%s\"%(trace_dir, altref[11:]))\n elif altref.startswith(\"../.dwz/\"):\n mkdir_p(\"%s/debug/.build-id/.dwz\"%trace_dir)\n src = \"../%s/%s.sup\"%(build_id[:2], build_id[2:])\n create_link(src, \"%s/debug/.build-id/.dwz/%s\"%(trace_dir, altref[8:]))\n\nif re.search(\"^[^:/]+:\", source):\n collect_archive(source)\nelse:\n collect_filesystem(source)\n\nrr_buildid.terminate()\n" }, { "path": "scripts/rr-gdb-script-host.py", "content": "#!/usr/bin/env python3\n\"\"\" rr-gdb-script-host.py \"\"\"\n# Performs a limited emulation of the runtime environment of gdb scripts so that\n# we can run them for `rr sources` to locate debug information.\nfrom typing import Optional, List, Callable, Type\nimport logging\nimport os\nimport signal\nimport sys\n\ndef strip_prefix(s: str, needle: str) -> Optional[str]:\n if s.startswith(needle):\n return s[len(needle):]\n\n return None\n\ndef print_wrapper(*args, **kwargs):\n # Don't allow the script to print to stdout and interfere\n # with our communication with the rr process.\n f = kwargs.get(\"file\")\n if f is None or f == sys.stdout:\n kwargs[\"file\"] = sys.stderr\n print(*args, **kwargs)\n\nGdbNewObjfileEventCallback = Callable[[object], None]\n\nclass DebuggerExtensionCommand:\n def __init__(self, *args, **kwargs):\n logging.debug(\"DebuggerExtensionCommand(%s, %s)\" % (args, kwargs))\n\nclass GdbScriptHost:\n \"\"\" The filename of the main symbol file \"\"\"\n _filename: str = \"\"\n \"\"\" The current value of the gdb dir \"\"\"\n _dir: str = \"\"\n \"\"\" The current value of debug-file-directory \"\"\"\n debug_file_directory: str = \"/usr/lib/debug\"\n\n new_objfile_events: List[GdbNewObjfileEventCallback] = []\n\n def __init__(self, *args, **kwargs):\n self._filename = args[0]\n\n def show(self, cmd: str) -> Optional[str]:\n cmd.rstrip()\n if cmd == \"debug-file-directory\":\n return self.debug_file_directory\n if cmd == \"dir\":\n return \"Source directories searched: %s:$cdir:$cwd\"%self._dir\n\n return None\n\n def set(self, cmd: str) -> str:\n dfd = strip_prefix(cmd, \"debug-file-directory \")\n if dfd:\n self.debug_file_directory = dfd\n # Prints nothing upon success.\n return \"\"\n\n # This seems to be the default error message.\n return \"No symbol table is loaded. Use the \\\"file\\\" command.\"\n\n def execute_script(self, script: str):\n gdb_api: GdbApiRoot = GdbApiRoot(self)\n exec(script, {'gdb': gdb_api, \"print\": print_wrapper})\n\n def new_objfile(self, f: str):\n new_objfile: GdbNewObjfile = GdbNewObjfile(self, f)\n new_objfile_event: GdbNewObjfileEvent = GdbNewObjfileEvent(self, new_objfile)\n for callback in self.new_objfile_events:\n callback(new_objfile_event)\n\nclass GdbApiObject(object):\n def __init__(self, *args, **kwargs):\n self.gdb = args[0]\n\n def __getattr__(self, attr):\n logging.warning(\"Accessing unsupported GDB api %s.%s\" % (self.__class__.__name__, attr))\n\nclass GdbProgspace(GdbApiObject):\n filename: str\n\n def __init__(self, *args, **kwargs):\n GdbApiObject.__init__(self, *args, **kwargs)\n self.filename = self.gdb._filename\n\nclass GdbNewObjfile(GdbApiObject):\n filename: str\n def __init__(self, *args, **kwargs):\n GdbApiObject.__init__(self, *args, **kwargs)\n self.filename = args[1]\n\nclass GdbNewObjfileEvent(GdbApiObject):\n new_objfile: GdbNewObjfile\n\n def __init__(self, *args, **kwargs):\n GdbApiObject.__init__(self, *args, **kwargs)\n self.new_objfile = args[1]\n\nclass GdbNewObjfileEvents(GdbApiObject):\n def connect(self, c: GdbNewObjfileEventCallback):\n logging.debug(\"EventRegistry.connect\")\n self.gdb.new_objfile_events.append(c)\n\nclass GdbApiEvents(GdbApiObject):\n _new_objfile: Optional[GdbNewObjfileEvents] = None\n\n @property\n def new_objfile(self) -> GdbNewObjfileEvents:\n logging.debug(\"gdb.events.new_objfile\")\n if self._new_objfile is None:\n self._new_objfile = GdbNewObjfileEvents(self.gdb)\n return self._new_objfile\n\nclass GdbApiRoot(GdbApiObject):\n _events: Optional[GdbApiEvents] = None\n _current_progspace: Optional[GdbProgspace] = None\n\n def execute(self, command: str, from_tty: bool = False, to_string: bool = False) -> Optional[str]:\n logging.debug(\"gdb.execute(\\\"%s\\\", from_tty=%s, to_string=%s)\" % (command, str(from_tty), str(to_string)))\n if from_tty:\n logging.warning(\"Unsupported gdb.execute with from_tty == True\")\n return None\n\n remainder = strip_prefix(command, \"show \")\n if remainder:\n r = self.gdb.show(remainder)\n if to_string:\n return r\n else:\n print(r, file=sys.stderr)\n return None\n remainder = strip_prefix(command, \"set \")\n if remainder:\n r = self.gdb.set(remainder)\n if to_string:\n return r\n else:\n print(r, file=sys.stderr)\n return None\n remainder = strip_prefix(command, \"dir \")\n if remainder:\n self.gdb._dir = remainder\n s = \"Source directories searched: %s:$cdir:$cwd\"%remainder\n if to_string:\n return s\n else:\n print(s, file=sys.stderr)\n return None\n\n logging.warning(\"Unsupported gdb.execute \\\"%s\\\"\"%command)\n return None\n\n def lookup_global_symbol(self, s: str) -> Optional[object]:\n #logging.debug(\"gdb.lookup_global_symbol(\\\"%s\\\")\"%s)\n logging.warning(\"gdb.lookup_global_symbol(\\\"%s\\\") is not yet implemented, pretending we found something\"%s)\n return object()\n\n def current_progspace(self) -> GdbProgspace:\n logging.debug(\"gdb.current_progspace()\")\n if self._current_progspace is None:\n self._current_progspace = GdbProgspace(self.gdb)\n return self._current_progspace\n\n @property\n def events(self) -> GdbApiEvents:\n logging.debug(\"gdb.events\")\n if self._events is None:\n self._events = GdbApiEvents(self.gdb)\n return self._events\n\n @property\n def COMMAND_USER(self) -> int:\n return 13\n\n @property\n def Command(self) -> Type[DebuggerExtensionCommand]:\n return DebuggerExtensionCommand\n\nif __name__ == '__main__':\n with open(sys.argv[1], 'r') as user_script_file:\n user_script = user_script_file.read()\n host = GdbScriptHost(sys.argv[2])\n try:\n host.execute_script(user_script)\n except NameError as e:\n if getattr(e, \"name\", None) == \"python\" or e == \"NameError: name 'python' is not defined\":\n # This might be a gdb script that wraps a python script.\n start = user_script.find(\"python\") + len(\"python\")\n end = user_script.find(\"end\")\n if end == -1:\n raise(e)\n user_script = user_script[start:end]\n try:\n host.execute_script(user_script)\n except:\n raise(e)\n\n print(\"%s\\n%s\" % (host.debug_file_directory, host._dir), flush=True)\n for line in sys.stdin:\n line = line.rstrip()\n logging.debug(\"Processing %s\"%line)\n host.new_objfile(line)\n print(\"%s\\n%s\" % (host.debug_file_directory, host._dir), flush=True)\n" }, { "path": "scripts/rr_completion", "content": "# vi:syntax=sh\n#\n# completion script for rr commands (to be sourced)\n\n_rr_subcmd_completion() {\n local cmd=$1\n local short_opts=$(rr help $cmd | sed -n 's/\\s*-\\([a-zA-Z]\\),.*/-\\1/p')\n local long_opts=$(rr help $cmd | sed -n 's/.*--\\([^= ]*\\).*/--\\1/p')\n echo \"$short_opts\" \"$long_opts\"\n}\n\n_rr_completion() {\n COMPREPLY=()\n local rr_commands=\"$(rr --list-commands | cut -s -d ' ' -f 3)\"\n\n # completion for rr\n if [ $COMP_CWORD -eq 1 ]; then\n COMPREPLY=( $( compgen -W \"$rr_commands\" -- \"${COMP_WORDS[1]}\" ) )\n return\n fi\n\n # completion for rr 's options\n local cmd=\"$(echo \"${COMP_WORDS[1]}\" | tr -d '[:space:]')\"\n\n if [ \"$(echo $rr_commands | grep -w \"$cmd\")\" ] ; then\n COMPREPLY=( $( compgen -W \"$(_rr_subcmd_completion \"$cmd\")\" -f -- \"${COMP_WORDS[COMP_CWORD]}\" ) )\n fi\n}\ncomplete -F _rr_completion rr\n" }, { "path": "scripts/rr_completion.zsh", "content": "#compdef rr\n\n_rr() {\n # allow overridding rr with another command (e.g. if multiple versions are installed)\n zstyle -s :completion${curcontext}options command rr\n : ${rr:=rr}\n\n _rr_subcommands() {\n $rr --list-commands | cut -s -d ' ' -f 3\n }\n _rr_traces() {\n $rr ls | grep -v '^cpu_lock$'\n }\n\n _arguments -C \\\n '1:subcommand:($(_rr_subcommands))' \\\n '*::arg:->args'\n\n case $state in\n args) ;;\n *) return;;\n esac\n\n # different subcommands can have different options. show the appropriate options for each.\n # this is not ideal; `reply=` forces zsh to rerun `rr help` each time you hit tab.\n # the alternative though is rewriting half the code in _arguments.\n zstyle -e ':completion:*:*:rr:*:options' command \\\n 'reply=( '${(q)service}' help ${words:#-*} )'\n\n case $line[1] in\n # complete a command, then delegate to that command's completion script\n # -A means \"don't use _normal until we've completed a non-option\"\n record) _arguments -A '-*' '1:command: _precommand' '*:: :_normal -p $service' --;;\n replay|rerun|ps|sources|traceinfo|pack|dump) _arguments '*:trace:($(_rr_traces))' --;;\n help) _arguments ':subcommand:($(_rr_subcommands))' --;;\n explicit-sources|filename) _gnu_generic;;\n *) _arguments --;\n esac\n}\n" }, { "path": "scripts/signal-rr-recording.sh", "content": "#!/usr/bin/env bash\n\nsignal=$1\nif [[ \"$signal\" == \"\" ]]; then\n echo \"Usage: $0 \" >&2\n echo \"Sends to all processes being recorded by rr\" >&2\n exit 1\nfi\n\nfunction signal_descendants { pid=$1\n for child in `ps -o pid= --ppid $pid`; do\n echo Sending $signal to $child\n kill -s $signal $child\n signal_descendants $child\n done\n}\n\nfor rr_pid in `pidof rr` ; do\n if cat /proc/$rr_pid/cmdline | tr '\\0' '\\n' | head -n2 | tail -n1 | grep -qz '\\(^record$\\)\\|/' ; then\n signal_descendants $rr_pid\n fi\ndone\n" }, { "path": "scripts/update-gh-pages.sh", "content": "#!/usr/bin/env bash\n\nfunction fatal { why=$1;\n echo \"[FATAL]\" $why >&2\n exit 1\n}\n\nrev=HEAD\nif [[ $1 != \"\" ]]; then\n rev=$1\nfi\nver=`git name-rev --name-only --tags $rev`\nif [[ $ver == undefined ]]; then\n fatal \"No tag found\"\nfi\n\necho \"Updating repo ...\"\ngit checkout gh-pages || fatal \"Failed to checkout gh-pages branch.\"\n\nverfile=index.html\necho \"Patching $verfile with new version $ver ...\"\nsed -i \"s/[^<]*$ver= 0 and ssb_mode & PR_SPEC_PRCTL:\n mitigated = (prctl(PR_SET_SPECULATION_CTRL, PR_SPEC_STORE_BYPASS, PR_SPEC_DISABLE, 0, 0) == 0)\n if not mitigated:\n print('Failed to enable SSB mitigation')\n else:\n ssb_status = 'mitigated'\n else:\n ssb_status = 'immutable'\n\n\nmsrs = [read_msr(cpu) & BIT for cpu in cpus]\n\nif all(msr for msr in msrs):\n if ssb_status in ('mitigated', 'immutable') or args.check:\n print('Zen workaround in place')\n else:\n print('Zen workaround maybe in place.')\nelif args.reset or args.check:\n if all(not msr for msr in msrs):\n print('Zen workaround disabled')\n elif args.reset:\n print('Zen workaround somehow not entirely disabled?')\n else:\n print('Zen workaround not entirely enabled?')\nelse:\n print('Zen workaround does not stick. Please see https://github.com/rr-debugger/rr/wiki/Zen')\n" }, { "path": "scripts/zen_workaround.service", "content": "# systemd service for AMD Zen `rr` workaround\n# See https://github.com/rr-debugger/rr/wiki/Zen for more details\n# To install:\n# - Save this file as `/etc/systemd/system/zen_workaround.service`\n# - Download the `zen_workaround.py` script to a secure location, example:\n# - sudo mkdir -p /usr/share/zen_workaround\n# - cd /usr/share/zen_workaround\n# - curl -L https://github.com/rr-debugger/rr/raw/master/scripts/zen_workaround.py | sudo tee -a zen_workaround.py >/dev/null\n# - chmod +x ./zen_workaround.py\n# - run `sudo systemctl enable zen_workaround` to enable on startup\n# - run `sudo systemctl start zen_workaround` to manually start it immediately\n# - run `systemctl status zen_workaround` to ensure that it completed successfully on your hardware\n\n[Unit]\nDescription = Startup script for rr zen workaround\n\n[Service]\n# Step to actually run `zen_workaround.py`.\nExecStart =+/usr/share/zen_workaround/zen_workaround.py\n\n# Only run this once, report it as \"(active)\" even after we've exited.\nType = oneshot\nRemainAfterExit = yes\n\n[Install]\nWantedBy = default.target\n" }, { "path": "snap/snapcraft.yaml", "content": "name: rr\nbase: core20 # the base snap is the execution environment for this snap\nversion: git\nsummary: low-overhead record-replay debugging tool\ndescription: |\n rr aspires to be your primary C/C++ debugging tool for Linux, replacing —\n well, enhancing — gdb. You record a failure once, then debug the recording,\n deterministically, as many times as you want. The same execution is\n replayed every time.\n\n rr also provides efficient reverse execution under gdb. Set breakpoints and\n data watchpoints and quickly reverse-execute to where they were hit.\n\n * Low overhead compared to other similar tools, especially on\n mostly-single-threaded workloads\n * Supports recording and replay of all kinds of applications:\n Firefox, Chrome, QEMU, LibreOffice, Go programs, ...\n * Record, replay and debug multiple-process workloads, including entire containers\n * Works with gdb scripting and\n [IDE integration](https://github.com/rr-debugger/rr/wiki/Using-rr-in-an-IDE)\n * [Durable](http://robert.ocallahan.org/2017/06/new-rr-pack-command.html),\n [compact](http://robert.ocallahan.org/2017/07/selecting-compression-algorithm-for-rr.html)\n traces that can be \n [ported](http://robert.ocallahan.org/2017/09/rr-trace-portability.html) between machines\n * [Chaos mode](http://robert.ocallahan.org/2016/02/introducing-rr-chaos-mode.html)\n to make intermittent bugs more reproducible \n\ngrade: stable # must be 'stable' to release into candidate/stable channels\nconfinement: classic\n\napps:\n rr:\n command: usr/bin/rr\n\nparts:\n rr:\n plugin: cmake\n cmake-parameters:\n - -DCMAKE_INSTALL_PREFIX=/usr\n source: .\n source-type: git\n build-packages:\n - g++\n - g++-multilib\n - gdb\n - pkg-config\n - coreutils\n - python3-pexpect\n - manpages-dev\n - ninja-build\n - capnproto\n - libcapnp-dev\n - zlib1g-dev\n - libzstd-dev\n stage-packages:\n - libcapnp-0.7.0\n - zlib1g\n - libzstd1\n" }, { "path": "src/AddressSpace.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"AddressSpace.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"rr/rr.h\"\n\n#include \"preload/preload_interface.h\"\n\n#include \"AutoRemoteSyscalls.h\"\n#include \"MonitoredSharedMemory.h\"\n#include \"RecordSession.h\"\n#include \"RecordTask.h\"\n#include \"Session.h\"\n#include \"Task.h\"\n#include \"core.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstatic const uint8_t x86_breakpoint_insn[] = { 0xcc }; // int $3\nstatic const uint8_t arm64_breakpoint_insn[4] = {0x0, 0x0, 0x20, 0xd4}; // brk #0\n\nstatic const uint8_t *breakpoint_insn(SupportedArch arch) {\n switch (arch) {\n case x86:\n case x86_64:\n return x86_breakpoint_insn;\n case aarch64:\n return arm64_breakpoint_insn;\n default:\n DEBUG_ASSERT(0 && \"Must define breakpoint insn for this architecture\");\n return nullptr;\n }\n}\n\n\n/**\n * Advance *str to skip leading blank characters.\n */\nstatic const char* trim_leading_blanks(const char* str) {\n const char* trimmed = str;\n while (isblank(*trimmed)) {\n ++trimmed;\n }\n return trimmed;\n}\n\n/**\n * Returns true if a task in t's thread-group other than t is doing an exec.\n */\nstatic bool thread_group_in_exec(Task* t) {\n if (!t->session().is_recording()) {\n return false;\n }\n for (Task* tt : t->thread_group()->task_set()) {\n if (tt == t || t->already_exited()) {\n continue;\n }\n RecordTask* rt = static_cast(tt);\n Event& ev = rt->ev();\n if (ev.is_syscall_event() && ev.Syscall().is_exec()) {\n return true;\n }\n }\n return false;\n}\n\nKernelMapIterator::KernelMapIterator(Task* t, bool* ok)\n : tid(t->tid) {\n // See https://lkml.org/lkml/2016/9/21/423\n ASSERT(t, !thread_group_in_exec(t)) << \"Task-group in execve, so reading \"\n \"/proc/.../maps may trigger kernel \"\n \"deadlock!\";\n init(ok);\n}\n\nKernelMapIterator::~KernelMapIterator() {\n if (maps_file) {\n fclose(maps_file);\n }\n}\n\nvoid KernelMapIterator::init(bool* ok) {\n char maps_path[PATH_MAX];\n sprintf(maps_path, \"/proc/%d/maps\", tid);\n if (ok) {\n *ok = true;\n }\n if (!(maps_file = fopen(maps_path, \"r\"))) {\n if (ok) {\n *ok = false;\n } else {\n FATAL() << \"Failed to open \" << maps_path;\n }\n }\n ++*this;\n}\n\nvoid KernelMapIterator::operator++() {\n if (!maps_file) {\n return;\n }\n\n char line[PATH_MAX * 2];\n if (!fgets(line, sizeof(line), maps_file)) {\n fclose(maps_file);\n maps_file = nullptr;\n return;\n }\n\n uint64_t start, end, offset, inode;\n int dev_major, dev_minor;\n char flags[32];\n int chars_scanned;\n int nparsed = sscanf(line, \"%\" SCNx64 \"-%\" SCNx64 \" %31s %\" SCNx64\n \" %x:%x %\" SCNu64 \" %n\",\n &start, &end, flags, &offset, &dev_major, &dev_minor,\n &inode, &chars_scanned);\n DEBUG_ASSERT(8 /*number of info fields*/ == nparsed ||\n 7 /*num fields if name is blank*/ == nparsed);\n\n // trim trailing newline, if any\n int last_char = strlen(line) - 1;\n if (line[last_char] == '\\n') {\n line[last_char] = 0;\n }\n raw_line = line;\n\n const char* name = trim_leading_blanks(line + chars_scanned);\n#if defined(__i386__)\n if (start > numeric_limits::max() ||\n end > numeric_limits::max() ||\n strcmp(name, \"[vsyscall]\") == 0) {\n // We manually read the exe link here because\n // this helper is used to set\n // |t->vm()->exe_image()|, so we can't rely on\n // that being correct yet.\n char proc_exe[PATH_MAX];\n char exe[PATH_MAX];\n snprintf(proc_exe, sizeof(proc_exe), \"/proc/%d/exe\", tid);\n ssize_t size = readlink(proc_exe, exe, sizeof(exe));\n if (size < 0) {\n FATAL() << \"readlink failed\";\n }\n FATAL() << \"Sorry, tracee \" << tid << \" has x86-64 image \" << exe\n << \" and that's not supported with a 32-bit rr.\";\n }\n#endif\n int prot = (strchr(flags, 'r') ? PROT_READ : 0) |\n (strchr(flags, 'w') ? PROT_WRITE : 0) |\n (strchr(flags, 'x') ? PROT_EXEC : 0);\n int f = (strchr(flags, 'p') ? MAP_PRIVATE : 0) |\n (strchr(flags, 's') ? MAP_SHARED : 0);\n\n string tmp_name;\n if (strchr(name, '\\\\')) {\n // Unescape any '\\012' sequences\n while (*name) {\n if (strncmp(name, \"\\\\012\", 4) == 0) {\n tmp_name.push_back('\\n');\n name += 4;\n } else {\n tmp_name.push_back(*name);\n ++name;\n }\n }\n name = tmp_name.c_str();\n }\n\n km = KernelMapping(start, end, name, MKDEV(dev_major, dev_minor), inode, prot,\n f, offset);\n}\n\nstatic KernelMapping read_kernel_mapping(pid_t tid, remote_ptr addr) {\n MemoryRange range(addr, 1);\n bool ok;\n KernelMapIterator it(tid, &ok);\n if (!ok) {\n return KernelMapping();\n }\n for (; !it.at_end(); ++it) {\n const KernelMapping& km = it.current();\n if (km.contains(range)) {\n return km;\n }\n }\n return KernelMapping();\n}\n\nKernelMapping AddressSpace::read_kernel_mapping(Task* t,\n remote_ptr addr) {\n return rr::read_kernel_mapping(t->tid, addr);\n}\n\nKernelMapping AddressSpace::read_local_kernel_mapping(uint8_t* addr) {\n return rr::read_kernel_mapping(getpid(), remote_ptr((uintptr_t)addr));\n}\n\n/**\n * Cat the /proc/[t->tid]/maps file to stdout, line by line.\n */\nvoid AddressSpace::print_process_maps(Task* t) {\n for (KernelMapIterator it(t); !it.at_end(); ++it) {\n string line;\n it.current(&line);\n cerr << line << '\\n';\n }\n}\n\nAddressSpace::Mapping::Mapping(const KernelMapping& map,\n const KernelMapping& recorded_map,\n EmuFile::shr_ptr emu_file,\n std::unique_ptr mapped_file_stat,\n void* local_addr,\n shared_ptr&& monitored)\n : map(map),\n recorded_map(recorded_map),\n emu_file(emu_file),\n mapped_file_stat(std::move(mapped_file_stat)),\n local_addr(static_cast(local_addr)),\n monitored_shared_memory(std::move(monitored)),\n flags(FLAG_NONE) {}\n\nstatic unique_ptr clone_stat(\n const unique_ptr& other) {\n return other ? unique_ptr(new struct stat(*other)) : nullptr;\n}\n\nAddressSpace::Mapping::Mapping(const Mapping& other)\n : map(other.map),\n recorded_map(other.recorded_map),\n emu_file(other.emu_file),\n mapped_file_stat(clone_stat(other.mapped_file_stat)),\n local_addr(other.local_addr),\n monitored_shared_memory(other.monitored_shared_memory),\n flags(other.flags) {}\n\nAddressSpace::Mapping::~Mapping() {}\n\nAddressSpace::Mapping AddressSpace::Mapping::subrange(MemoryRange range,\n std::function f) const {\n Mapping mapping(\n f(map.subrange(range.start(), range.end())),\n f(recorded_map.subrange(range.start(), range.end())),\n emu_file, clone_stat(mapped_file_stat),\n local_addr ? local_addr + (range.start() - map.start()) : 0,\n monitored_shared_memory\n ? monitored_shared_memory->subrange(range.start() - map.start(),\n range.size())\n : nullptr);\n mapping.flags = flags;\n return mapping;\n}\n\nAddressSpace::~AddressSpace() {\n for (auto& m : mem) {\n if (m.second.local_addr) {\n int ret = munmap(m.second.local_addr, m.second.map.size());\n if (ret < 0) {\n FATAL() << \"Can't munmap\";\n }\n }\n }\n session_->on_destroy(this);\n}\n\nstatic uint32_t find_offset_of_syscall_instruction_in(SupportedArch arch,\n uint8_t* vdso_data,\n size_t vdso_len) {\n auto instruction = syscall_instruction(arch);\n for (uint32_t i = 1; i < vdso_len - instruction.size(); ++i) {\n if (memcmp(vdso_data + i, instruction.data(), instruction.size()) == 0) {\n return i;\n }\n }\n return 0;\n}\n\nuint32_t AddressSpace::offset_to_syscall_in_vdso[SupportedArch_MAX + 1];\n\nremote_code_ptr AddressSpace::find_syscall_instruction_in_vdso(Task* t) {\n SupportedArch arch = t->arch();\n if (!offset_to_syscall_in_vdso[arch]) {\n if (!vdso_start_addr) {\n return remote_code_ptr();\n }\n auto vdso_data = t->read_mem(vdso().start().cast(), vdso().size());\n offset_to_syscall_in_vdso[arch] = find_offset_of_syscall_instruction_in(\n arch, vdso_data.data(), vdso_data.size());\n ASSERT(t, offset_to_syscall_in_vdso[arch])\n << \"No syscall instruction found in VDSO\";\n }\n return remote_code_ptr(\n (vdso().start().cast() + offset_to_syscall_in_vdso[arch])\n .as_int());\n}\n\nstatic string rr_page_file_name(SupportedArch arch, const char** fname_out) {\n string file_name;\n const char *fname = nullptr;\n switch (arch) {\n case x86_64:\n case aarch64:\n fname = RRPAGE_LIB_FILENAME;\n break;\n case x86:\n#if defined(__x86_64__)\n fname = RRPAGE_LIB_FILENAME_32;\n#else\n fname = RRPAGE_LIB_FILENAME;\n#endif\n break;\n }\n *fname_out = fname;\n\n string path = find_helper_library(fname);\n if (path.empty()) {\n return path;\n }\n path += fname;\n return path;\n}\n\nvoid AddressSpace::map_rr_page(AutoRemoteSyscalls& remote) {\n int prot = PROT_EXEC | PROT_READ;\n int flags = MAP_PRIVATE | MAP_FIXED;\n\n Task* t = remote.task();\n SupportedArch arch = t->arch();\n const char* fname;\n string path = rr_page_file_name(arch, &fname);\n if (path.empty()) {\n FATAL() << \"Failed to locate \" << fname << \"; needed by \"\n << t->exe_path() << \" (\" << arch_name(arch) << \")\";\n }\n\n size_t offset_pages = t->session().is_recording() ?\n RRPAGE_RECORD_PAGE_OFFSET : RRPAGE_REPLAY_PAGE_OFFSET;\n size_t offset_bytes = offset_pages * PRELOAD_LIBRARY_PAGE_SIZE;\n\n {\n ScopedFd page(path.c_str(), O_RDONLY);\n ASSERT(t, page.is_open()) << \"Failed to open rrpage library \" << path;\n int child_fd = remote.infallible_send_fd_if_alive(page);\n if (child_fd >= 0) {\n if (t->session().is_recording()) {\n remote.infallible_mmap_syscall_if_alive(rr_page_start() - offset_bytes, offset_bytes, prot, flags,\n child_fd, 0);\n }\n remote.infallible_mmap_syscall_if_alive(rr_page_start(), PRELOAD_LIBRARY_PAGE_SIZE, prot, flags,\n child_fd, offset_bytes);\n\n struct stat fstat = t->stat_fd(child_fd);\n string file_name = t->file_name_of_fd(child_fd);\n\n remote.infallible_close_syscall_if_alive(child_fd);\n\n map(t, rr_page_start(), PRELOAD_LIBRARY_PAGE_SIZE, prot, flags,\n offset_bytes, file_name,\n fstat.st_dev, fstat.st_ino);\n mapping_flags_of(rr_page_start()) = Mapping::IS_RR_PAGE;\n if (t->session().is_recording()) {\n map(t, rr_page_start() - offset_bytes, offset_bytes, prot, flags,\n 0, file_name,\n fstat.st_dev, fstat.st_ino);\n mapping_flags_of(rr_page_start() - offset_bytes) = Mapping::IS_RR_VDSO_PAGE;\n }\n }\n }\n\n if (t->session().is_recording()) {\n // brk() will not have been called yet so the brk area is empty.\n brk_start = brk_end =\n remote.infallible_syscall(syscall_number_for_brk(arch), 0);\n ASSERT(t, !brk_end.is_null());\n }\n}\n\nvector AddressSpace::read_rr_page_for_recording(SupportedArch arch) {\n const char* fname;\n string path = rr_page_file_name(arch, &fname);\n if (path.empty()) {\n FATAL() << \"Failed to locate \" << fname;\n }\n\n ScopedFd page(path.c_str(), O_RDONLY);\n vector result;\n result.resize(PRELOAD_LIBRARY_PAGE_SIZE);\n ssize_t ret = read_to_end(page,\n RRPAGE_RECORD_PAGE_OFFSET * PRELOAD_LIBRARY_PAGE_SIZE, result.data(),\n result.size());\n if (ret != static_cast(result.size())) {\n FATAL() << \"Failed to read full page from \" << path;\n }\n return result;\n}\n\nvoid AddressSpace::unmap_all_but_rr_mappings(AutoRemoteSyscalls& remote,\n UnmapOptions options) {\n vector unmaps;\n for (const auto& m : maps()) {\n // Do not attempt to unmap [vsyscall] --- it doesn't work.\n if (m.map.start() != AddressSpace::rr_page_start() &&\n m.map.start() != AddressSpace::preload_thread_locals_start() &&\n !m.map.is_vsyscall() &&\n (!options.exclude_vdso_vvar || (!m.map.is_vdso() && (m.map.is_vvar() || m.map.is_vvar_vclock())))) {\n unmaps.push_back(m.map);\n }\n }\n for (auto& m : unmaps) {\n remote.infallible_syscall(syscall_number_for_munmap(remote.task()->arch()),\n m.start(), m.size());\n unmap(remote.task(), m.start(), m.size());\n }\n}\n\n/**\n * Must match generate_rr_page.py\n */\nstatic const AddressSpace::SyscallType entry_points[] = {\n { AddressSpace::TRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::RECORDING_AND_REPLAY },\n { AddressSpace::TRACED, AddressSpace::PRIVILEGED,\n AddressSpace::RECORDING_AND_REPLAY },\n { AddressSpace::UNTRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::RECORDING_AND_REPLAY },\n { AddressSpace::UNTRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::REPLAY_ONLY },\n { AddressSpace::UNTRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::RECORDING_ONLY },\n { AddressSpace::UNTRACED, AddressSpace::PRIVILEGED,\n AddressSpace::RECORDING_AND_REPLAY },\n { AddressSpace::UNTRACED, AddressSpace::PRIVILEGED,\n AddressSpace::REPLAY_ONLY },\n { AddressSpace::UNTRACED, AddressSpace::PRIVILEGED,\n AddressSpace::RECORDING_ONLY },\n { AddressSpace::UNTRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::REPLAY_ASSIST },\n};\n\nstatic int rr_page_syscall_stub_size(SupportedArch arch) {\n int val = 0;\n switch (arch) {\n case x86:\n case x86_64:\n val = 3;\n break;\n case aarch64:\n val = 8;\n break;\n default:\n FATAL() << \"Syscall stub size not defined for this architecture\";\n }\n if (arch == NativeArch::arch()) {\n DEBUG_ASSERT(val == RR_PAGE_SYSCALL_STUB_SIZE);\n }\n return val;\n}\n\nstatic int rr_page_syscall_instruction_end(SupportedArch arch) {\n int val = 0;\n switch (arch) {\n case x86:\n case x86_64:\n val = 2;\n break;\n case aarch64:\n val = 4;\n break;\n default:\n FATAL() << \"Syscall stub size not defined for this architecture\";\n }\n if (arch == NativeArch::arch()) {\n DEBUG_ASSERT(val == RR_PAGE_SYSCALL_INSTRUCTION_END);\n }\n return val;\n}\n\nstatic remote_code_ptr entry_ip_from_index(SupportedArch arch, size_t i) {\n return remote_code_ptr(RR_PAGE_ADDR + rr_page_syscall_stub_size(arch) * i);\n}\n\nstatic remote_code_ptr exit_ip_from_index(SupportedArch arch, size_t i) {\n return remote_code_ptr(RR_PAGE_ADDR + rr_page_syscall_stub_size(arch) * i +\n rr_page_syscall_instruction_end(arch));\n}\n\nremote_code_ptr AddressSpace::rr_page_syscall_exit_point(Traced traced,\n Privileged privileged,\n Enabled enabled,\n SupportedArch arch) {\n for (auto& e : entry_points) {\n if (e.traced == traced && e.privileged == privileged &&\n e.enabled == enabled) {\n return exit_ip_from_index(arch, &e - entry_points);\n }\n }\n return nullptr;\n}\n\nremote_code_ptr AddressSpace::rr_page_syscall_entry_point(Traced traced,\n Privileged privileged,\n Enabled enabled,\n SupportedArch arch) {\n for (auto& e : entry_points) {\n if (e.traced == traced && e.privileged == privileged &&\n e.enabled == enabled) {\n return entry_ip_from_index(arch, &e - entry_points);\n }\n }\n return nullptr;\n}\n\nconst AddressSpace::SyscallType* AddressSpace::rr_page_syscall_from_exit_point(\n SupportedArch arch, remote_code_ptr ip) {\n for (size_t i = 0; i < array_length(entry_points); ++i) {\n if (exit_ip_from_index(arch, i) == ip) {\n return &entry_points[i];\n }\n }\n return nullptr;\n}\n\nconst AddressSpace::SyscallType* AddressSpace::rr_page_syscall_from_entry_point(\n SupportedArch arch, remote_code_ptr ip) {\n for (size_t i = 0; i < array_length(entry_points); ++i) {\n if (entry_ip_from_index(arch, i) == ip) {\n return &entry_points[i];\n }\n }\n return nullptr;\n}\n\nvector AddressSpace::rr_page_syscalls() {\n vector result;\n for (auto& e : entry_points) {\n result.push_back(e);\n }\n return result;\n}\n\nvoid AddressSpace::save_auxv(Task* t) {\n saved_auxv_ = read_auxv(t);\n save_interpreter_base(t, saved_auxv());\n}\n\nvoid AddressSpace::save_interpreter_base(Task* t, std::vector auxv) {\n saved_interpreter_base_ = read_interpreter_base(auxv);\n save_ld_path(t, saved_interpreter_base());\n}\n\nvoid AddressSpace::save_ld_path(Task* t, remote_ptr interpreter_base) {\n saved_ld_path_ = read_ld_path(t, interpreter_base);\n}\n\nvoid AddressSpace::read_mm_map(Task* t, NativeArch::prctl_mm_map* map) {\n char buf[PATH_MAX+1024];\n {\n string proc_stat = t->proc_stat_path();\n ScopedFd fd(proc_stat.c_str(), O_RDONLY);\n memset(buf, 0, sizeof(buf));\n int err = read_to_end(fd, 0, buf, sizeof(buf)-1);\n if (err < 0) {\n FATAL() << \"Failed to read /proc//stat\";\n }\n }\n // The last close-paren indicates the end of the comm and the\n // start of the fixed-width area\n char* fixed = strrchr(buf, ')');\n // We don't change /proc/pid/exe, since we're unlikely to have CAP_SYS_ADMIN\n map->exe_fd = -1;\n // auxv is restored separately\n map->auxv.val = 0;\n map->auxv_size = 0;\n // All of these fields of /proc/pid/stat, we don't use (currently)\n char state;\n pid_t ppid;\n pid_t pgrp;\n int session;\n int tty_nr;\n int tpgid;\n unsigned int flags;\n unsigned long minflt, cminflt, majflt, cmajflt, utime, stime;\n long cutime, cstime, priority, nice, num_threads, itrealvalue;\n unsigned long long starttime;\n unsigned long vsize;\n long rss;\n unsigned long rsslim, kstkesp, kstskip, signal;\n unsigned long blocked, sigignore, sigcatch, wchan, nswap, cnswap;\n int exit_signal, processor;\n unsigned int rt_priority, policy;\n unsigned long long delayacct_blkio_ticks;\n unsigned long guest_time;\n long cguest_time;\n int exit_code;\n // See the proc(5) man page for the correct scan codes for these\n size_t n = sscanf(fixed + 1,\n // state ppid pgrp session tty_nr tpgid\n \" %c %d %d %d %d %d\"\n // flags minflt cminflt majflt cmajflt utime stime cutime cstime\n \" %u %lu %lu %lu %lu %lu %lu %ld %ld\"\n // priority nice num_threads itrealvalue starttime vsize rss\n \" %ld %ld %ld %ld %llu %lu %ld\"\n // rsslim startcode endcode startstack kstkesp kstskip signal\n \" %lu %lu %lu %lu %lu %lu %lu\"\n // blocked sigignore sigcatch wchan nswap cnswap exit_signal\n \" %lu %lu %lu %lu %lu %lu %d\"\n // processor rt_priority policy delayacct_blkio_ticks guest_time cguest_time\n \" %d %u %u %llu %lu %ld \"\n // start_data end_data start_brk arg_start arg_end env_start env_end exit_code\n \" %lu %lu %lu %lu %lu %lu %lu %d\",\n &state, &ppid, &pgrp, &session, &tty_nr, &tpgid,\n &flags, &minflt, &cminflt, &majflt, &cmajflt, &utime, &stime, &cutime, &cstime,\n &priority, &nice, &num_threads, &itrealvalue, &starttime, &vsize, &rss,\n &rsslim, (unsigned long *)&map->start_code, (unsigned long *)&map->end_code,\n (unsigned long *)&map->start_stack, &kstkesp, &kstskip, &signal,\n &blocked, &sigignore, &sigcatch, &wchan, &nswap, &cnswap, &exit_signal,\n &processor, &rt_priority, &policy, &delayacct_blkio_ticks, &guest_time,\n &cguest_time, (unsigned long *)&map->start_data, (unsigned long *)&map->end_data,\n (unsigned long *)&map->start_brk, (unsigned long *)&map->arg_start,\n (unsigned long *)&map->arg_end, (unsigned long *)&map->env_start,\n (unsigned long *)&map->env_end, &exit_code);\n ASSERT(t, n == 50);\n // Fill in brk end\n ASSERT(t, map->start_brk == this->brk_start.as_int());\n map->brk = this->brk_end.as_int();\n}\n\nvoid AddressSpace::post_exec_syscall(Task* t) {\n // First locate a syscall instruction we can use for remote syscalls.\n traced_syscall_ip_ = find_syscall_instruction_in_vdso(t);\n privileged_traced_syscall_ip_ = nullptr;\n\n do_breakpoint_fault_addr_ = nullptr;\n stopping_breakpoint_table_ = nullptr;\n stopping_breakpoint_table_entry_size_ = 0;\n\n // Now remote syscalls work, we can open_mem_fd.\n t->open_mem_fd();\n\n // Set up AutoRemoteSyscalls again now that the mem-fd is open.\n AutoRemoteSyscalls remote(t);\n // Now we can set up the \"rr page\" at its fixed address. This gives\n // us traced and untraced syscall instructions at known, fixed addresses.\n map_rr_page(remote);\n // Set up the preload_thread_locals shared area.\n t->session().create_shared_mmap(remote, PRELOAD_THREAD_LOCALS_SIZE,\n preload_thread_locals_start(),\n \"preload_thread_locals\");\n mapping_flags_of(preload_thread_locals_start()) |=\n AddressSpace::Mapping::IS_THREAD_LOCALS;\n}\n\nvoid AddressSpace::brk(Task* t, remote_ptr addr, int prot) {\n LOG(debug) << \"brk(\" << addr << \")\";\n\n remote_ptr old_brk = ceil_page_size(brk_end);\n remote_ptr new_brk = ceil_page_size(addr);\n if (old_brk < new_brk) {\n map(t, old_brk, new_brk - old_brk, prot, MAP_ANONYMOUS | MAP_PRIVATE, 0,\n \"[heap]\");\n } else {\n unmap(t, new_brk, old_brk - new_brk);\n }\n brk_end = addr;\n}\n\nstatic const char* stringify_flags(int flags) {\n switch (flags) {\n case AddressSpace::Mapping::FLAG_NONE:\n return \"\";\n case AddressSpace::Mapping::IS_SYSCALLBUF:\n return \" [syscallbuf]\";\n case AddressSpace::Mapping::IS_THREAD_LOCALS:\n return \" [thread_locals]\";\n case AddressSpace::Mapping::IS_PATCH_STUBS:\n return \" [patch_stubs]\";\n case AddressSpace::Mapping::IS_RR_PAGE:\n return \" [rr_page]\";\n case AddressSpace::Mapping::IS_RR_VDSO_PAGE:\n return \" [rr_vdso_page]\";\n default:\n return \" [unknown_flags]\";\n }\n}\n\nvoid AddressSpace::dump() const {\n fprintf(stderr, \" (heap: %p-%p)\\n\", (void*)brk_start.as_int(),\n (void*)brk_end.as_int());\n for (auto it = mem.begin(); it != mem.end(); ++it) {\n const KernelMapping& m = it->second.map;\n fprintf(stderr, \"%s%s\\n\", m.str().c_str(),\n stringify_flags(it->second.flags));\n }\n}\n\nSupportedArch AddressSpace::arch() const {\n return (*task_set().begin())->arch();\n}\n\nBreakpointType AddressSpace::get_breakpoint_type_for_retired_insn(\n remote_code_ptr ip) {\n remote_code_ptr addr = ip.undo_executed_bkpt(arch());\n return get_breakpoint_type_at_addr(addr);\n}\n\nBreakpointType AddressSpace::get_breakpoint_type_at_addr(remote_code_ptr addr) {\n auto it = breakpoints.find(addr);\n return it == breakpoints.end() ? BKPT_NONE : it->second.type();\n}\n\nbool AddressSpace::is_exec_watchpoint(remote_code_ptr addr) {\n for (auto& kv : watchpoints) {\n if (kv.first.contains(addr.to_data_ptr()) &&\n (kv.second.watched_bits() & EXEC_BIT)) {\n return true;\n }\n }\n return false;\n}\n\nbool AddressSpace::is_breakpoint_in_private_read_only_memory(\n remote_code_ptr addr) {\n for (const auto& m : maps_containing_or_after(addr.to_data_ptr())) {\n if (m.map.start() >=\n addr.increment_by_bkpt_insn_length(arch()).to_data_ptr()) {\n break;\n }\n if ((m.map.prot() & PROT_WRITE) || (m.map.flags() & MAP_SHARED)) {\n return false;\n }\n }\n return true;\n}\n\nvoid AddressSpace::replace_breakpoints_with_original_values(\n uint8_t* dest, size_t length, remote_ptr addr) {\n for (auto& it : breakpoints) {\n replace_in_buffer(MemoryRange(it.first.to_data_ptr(), bkpt_instruction_length(arch())),\n it.second.original_data(),\n MemoryRange(addr, length), dest);\n }\n}\n\nbool AddressSpace::is_breakpoint_instruction(Task* t, remote_code_ptr ip) {\n bool ok = true;\n uint8_t data[MAX_BKPT_INSTRUCTION_LENGTH];\n t->read_bytes_helper(ip.to_data_ptr(),\n bkpt_instruction_length(t->arch()), data, &ok);\n if (!ok) {\n return false;\n }\n switch (t->arch()) {\n case x86:\n case x86_64:\n return data[0] == 0xcc;\n case aarch64:\n return (data[0] & 0x1f) == 0 && (data[2] & 0xe0) == 0x20 &&\n data[3] == 0xd4;\n default:\n DEBUG_ASSERT(0 && \"Must define breakpoint insn for this architecture\");\n return false;\n }\n}\n\nstatic void remove_range(set& ranges, const MemoryRange& range) {\n if (ranges.empty()) {\n return;\n }\n\n auto start = ranges.lower_bound(range);\n // An earlier range might extend into range, so check for that.\n if (start != ranges.begin()) {\n --start;\n if (start->end() <= range.start()) {\n ++start;\n }\n }\n auto end = start;\n auto prev_end = start;\n while (end != ranges.end() && end->start() < range.end()) {\n prev_end = end;\n ++end;\n }\n if (start == end) {\n return;\n }\n MemoryRange start_range = *start;\n MemoryRange end_range = *prev_end;\n ranges.erase(start, end);\n if (start_range.start() < range.start()) {\n ranges.insert(MemoryRange(start_range.start(), range.start()));\n }\n if (range.end() < end_range.end()) {\n ranges.insert(MemoryRange(range.end(), end_range.end()));\n }\n}\n\nstatic void add_range(set& ranges, const MemoryRange& range) {\n // Remove overlapping ranges\n remove_range(ranges, range);\n ranges.insert(range);\n // We could coalesce adjacent ranges, but there's probably no need.\n}\n\nKernelMapping AddressSpace::map(Task* t, remote_ptr addr,\n size_t num_bytes, int prot, int flags,\n off_t offset_bytes, const string& fsname,\n dev_t device, ino_t inode,\n unique_ptr mapped_file_stat,\n const KernelMapping* recorded_map,\n EmuFile::shr_ptr emu_file, void* local_addr,\n shared_ptr monitored) {\n LOG(debug) << \"mmap(\" << addr << \", \" << num_bytes << \", \" << HEX(prot)\n << \", \" << HEX(flags) << \", \" << HEX(offset_bytes) << \")\";\n num_bytes = ceil_page_size(num_bytes);\n KernelMapping m(addr, addr + num_bytes, fsname, device, inode, prot, flags,\n offset_bytes);\n if (!num_bytes) {\n return m;\n }\n\n if (t->session().is_recording()) {\n uint8_t bits = virtual_address_size(t->arch(), addr + num_bytes - 1);\n // NB: Ignore addresses with no leading zeroes on 64 bit architectures\n // (where they are in the kernel) but not on 32 bit x86 (where the\n // 2-3GB range is available to userspace).\n if (bits != 64) {\n static_cast(t)->\n trace_writer().note_virtual_address_size(bits);\n }\n }\n\n remove_range(dont_fork, MemoryRange(addr, num_bytes));\n remove_range(wipe_on_fork, MemoryRange(addr, num_bytes));\n\n // The mmap() man page doesn't specifically describe\n // what should happen if an existing map is\n // \"overwritten\" by a new map (of the same resource).\n // In testing, the behavior seems to be as if the\n // overlapping region is unmapped and then remapped\n // per the arguments to the second call.\n unmap_internal(t, addr, num_bytes);\n\n const KernelMapping& actual_recorded_map = recorded_map ? *recorded_map : m;\n map_and_coalesce(t, m, actual_recorded_map, emu_file,\n std::move(mapped_file_stat),\n std::move(local_addr),\n std::move(monitored));\n\n // During an emulated exec, we will explicitly map in a (copy of) the VDSO\n // at the recorded address.\n if (actual_recorded_map.is_vdso()) {\n vdso_start_addr = addr;\n }\n\n if (MemoryRange(addr, num_bytes).contains(RR_PAGE_ADDR)) {\n update_syscall_ips(t);\n }\n\n return m;\n}\n\ntemplate void AddressSpace::at_preload_init_arch(Task* t) {\n auto params = t->read_mem(\n remote_ptr>(t->regs().orig_arg1()));\n\n if (t->session().is_recording()) {\n ASSERT(t,\n t->session().as_record()->use_syscall_buffer() ==\n params.syscallbuf_enabled)\n << \"Tracee thinks syscallbuf is \"\n << (params.syscallbuf_enabled ? \"en\" : \"dis\")\n << \"abled, but tracer thinks \"\n << (t->session().as_record()->use_syscall_buffer() ? \"en\" : \"dis\")\n << \"abled\";\n } else {\n if (params.breakpoint_table_entry_size == -1) {\n do_breakpoint_fault_addr_ = params.breakpoint_instr_addr.rptr().as_int();\n } else {\n stopping_breakpoint_table_ = params.breakpoint_table.rptr().as_int();\n stopping_breakpoint_table_entry_size_ =\n params.breakpoint_table_entry_size;\n }\n }\n\n if (!params.syscallbuf_enabled) {\n return;\n }\n\n syscallbuf_enabled_ = true;\n\n if (t->session().is_recording()) {\n monkeypatch_state->patch_at_preload_init(static_cast(t));\n }\n}\n\nvoid AddressSpace::at_preload_init(Task* t) {\n RR_ARCH_FUNCTION(at_preload_init_arch, t->arch(), t);\n}\n\nconst AddressSpace::Mapping& AddressSpace::mapping_of(\n remote_ptr addr) const {\n MemoryRange range(floor_page_size(addr), 1);\n auto it = mem.find(range);\n DEBUG_ASSERT(it != mem.end());\n DEBUG_ASSERT(it->second.map.contains(range));\n return it->second;\n}\nuint32_t& AddressSpace::mapping_flags_of(remote_ptr addr) {\n return const_cast(\n static_cast(this)->mapping_of(addr))\n .flags;\n}\n\nuint8_t* AddressSpace::local_mapping(remote_ptr addr, size_t size) {\n MemoryRange range(floor_page_size(addr), 1);\n auto it = mem.find(range);\n if (it == mem.end()) {\n return nullptr;\n }\n DEBUG_ASSERT(it->second.map.contains(range));\n const Mapping& map = it->second;\n // Fall back to the slow path if we can't get the entire region\n if (size > static_cast(map.map.end() - addr)) {\n return nullptr;\n }\n if (map.local_addr != nullptr) {\n size_t offset = addr - map.map.start();\n return static_cast(map.local_addr) + offset;\n }\n return nullptr;\n}\n\nvoid* AddressSpace::detach_local_mapping(remote_ptr addr) {\n auto m = const_cast(mapping_of(addr));\n void* p = m.local_addr;\n m.local_addr = nullptr;\n return p;\n}\n\nbool AddressSpace::has_mapping(remote_ptr addr) const {\n if (addr + page_size() < addr) {\n // Assume the last byte in the address space is never mapped; avoid overflow\n return false;\n }\n MemoryRange m(floor_page_size(addr), 1);\n auto it = mem.find(m);\n return it != mem.end() && it->first.contains(m);\n}\n\nbool AddressSpace::has_rr_page() const {\n MemoryRange m(RR_PAGE_ADDR, 1);\n auto it = mem.find(m);\n return it != mem.end() && (it->second.flags & Mapping::IS_RR_PAGE);\n}\n\nvoid AddressSpace::protect(Task* t, remote_ptr addr, size_t num_bytes,\n int prot) {\n LOG(debug) << \"mprotect(\" << addr << \", \" << num_bytes << \", \" << HEX(prot)\n << \")\";\n\n MemoryRange last_overlap;\n auto protector = [this, prot, &last_overlap](Mapping m,\n MemoryRange rem) {\n LOG(debug) << \" protecting (\" << rem << \") ...\";\n\n remove_from_map(m.map);\n\n // PROT_GROWSDOWN means that if this is a grows-down segment\n // (which for us means \"stack\") then the change should be\n // extended to the start of the segment.\n // We don't try to handle the analogous PROT_GROWSUP, because we\n // don't understand the idea of a grows-up segment.\n remote_ptr new_start;\n if ((m.map.start() < rem.start()) && (prot & PROT_GROWSDOWN)) {\n new_start = m.map.start();\n LOG(debug) << \" PROT_GROWSDOWN: expanded region down to \" << new_start;\n } else {\n new_start = rem.start();\n }\n\n LOG(debug) << \" erased (\" << m.map << \")\";\n\n // If the first segment we protect underflows the\n // region, remap the underflow region with previous\n // prot.\n if (m.map.start() < new_start) {\n Mapping underflow = m.subrange(MemoryRange(m.map.start(), new_start),\n [](const KernelMapping& km) { return km; });\n add_to_map(underflow);\n }\n // Remap the overlapping region with the new prot.\n remote_ptr new_end = min(rem.end(), m.map.end());\n\n int new_prot = prot & (PROT_READ | PROT_WRITE | PROT_EXEC);\n Mapping overlap = m.subrange(MemoryRange(new_start, new_end),\n [new_prot](const KernelMapping& km) { return km.set_prot(new_prot); });\n add_to_map(overlap);\n last_overlap = overlap.map;\n\n // If the last segment we protect overflows the\n // region, remap the overflow region with previous\n // prot.\n if (new_end < m.map.end()) {\n Mapping overflow = m.subrange(MemoryRange(new_end, m.map.end()),\n [](const KernelMapping& km) { return km; });\n add_to_map(overflow);\n }\n };\n for_each_in_range(addr, num_bytes, protector, ITERATE_CONTIGUOUS);\n if (last_overlap.size()) {\n // All mappings that we altered which might need coalescing\n // are adjacent to |last_overlap|.\n coalesce_around(t, mem.find(last_overlap));\n }\n}\n\nvoid AddressSpace::fixup_mprotect_growsdown_parameters(Task* t) {\n ASSERT(t, !(t->regs().arg3() & PROT_GROWSUP));\n if (t->regs().arg3() & PROT_GROWSDOWN) {\n Registers r = t->regs();\n if (r.arg1() == floor_page_size(r.arg1()) && has_mapping(r.arg1())) {\n auto& km = mapping_of(r.arg1()).map;\n if (km.flags() & MAP_GROWSDOWN) {\n auto new_start = km.start();\n r.set_arg2(remote_ptr(r.arg1()) + size_t(r.arg2()) - new_start);\n r.set_arg1(new_start);\n r.set_arg3(r.arg3() & ~PROT_GROWSDOWN);\n t->set_regs(r);\n }\n }\n }\n}\n\nvoid AddressSpace::remap(Task* t, remote_ptr old_addr,\n size_t old_num_bytes, remote_ptr new_addr,\n size_t new_num_bytes, int flags) {\n LOG(debug) << \"mremap(\" << old_addr << \", \" << old_num_bytes << \", \"\n << new_addr << \", \" << new_num_bytes << \")\";\n old_num_bytes = ceil_page_size(old_num_bytes);\n\n Mapping mr = mapping_of(old_addr);\n DEBUG_ASSERT(!mr.monitored_shared_memory);\n KernelMapping km = mr.map.subrange(old_addr, min(mr.map.end(), old_addr + old_num_bytes));\n\n unmap_internal(t, old_addr, old_num_bytes);\n if (flags & MREMAP_DONTUNMAP) {\n // This can only ever be an anonymous private mapping.\n map(t, old_addr, old_num_bytes, km.prot(), km.flags(), 0, string());\n }\n if (0 == new_num_bytes) {\n return;\n }\n new_num_bytes = ceil_page_size(new_num_bytes);\n\n auto it = dont_fork.lower_bound(MemoryRange(old_addr, old_num_bytes));\n if (it != dont_fork.end() && it->start() < old_addr + old_num_bytes) {\n // mremap fails if some but not all pages are marked DONTFORK\n DEBUG_ASSERT(*it == MemoryRange(old_addr, old_num_bytes));\n remove_range(dont_fork, MemoryRange(old_addr, old_num_bytes));\n add_range(dont_fork, MemoryRange(new_addr, new_num_bytes));\n } else {\n remove_range(dont_fork, MemoryRange(old_addr, old_num_bytes));\n remove_range(dont_fork, MemoryRange(new_addr, new_num_bytes));\n }\n\n it = wipe_on_fork.lower_bound(MemoryRange(old_addr, old_num_bytes));\n if (it != wipe_on_fork.end() && it->start() < old_addr + old_num_bytes) {\n // hopefully mremap fails if some but not all pages are marked DONTFORK\n DEBUG_ASSERT(*it == MemoryRange(old_addr, old_num_bytes));\n remove_range(wipe_on_fork, MemoryRange(old_addr, old_num_bytes));\n add_range(wipe_on_fork, MemoryRange(new_addr, new_num_bytes));\n } else {\n remove_range(wipe_on_fork, MemoryRange(old_addr, old_num_bytes));\n remove_range(wipe_on_fork, MemoryRange(new_addr, new_num_bytes));\n }\n\n unmap_internal(t, new_addr, new_num_bytes);\n\n remote_ptr new_end = new_addr + new_num_bytes;\n map_and_coalesce(t, km.set_range(new_addr, new_end),\n mr.recorded_map.set_range(new_addr, new_end), mr.emu_file,\n clone_stat(mr.mapped_file_stat), nullptr, nullptr);\n\n if (MemoryRange(old_addr, old_num_bytes).contains(RR_PAGE_ADDR) ||\n MemoryRange(new_addr, new_num_bytes).contains(RR_PAGE_ADDR)) {\n update_syscall_ips(t);\n }\n}\n\nvoid AddressSpace::remove_breakpoint(remote_code_ptr addr,\n BreakpointType type) {\n auto it = breakpoints.find(addr);\n if (it == breakpoints.end() || it->second.unref(type) > 0) {\n return;\n }\n destroy_breakpoint(it);\n}\n\nbool AddressSpace::add_breakpoint(remote_code_ptr addr, BreakpointType type) {\n auto it = breakpoints.find(addr);\n if (it == breakpoints.end()) {\n uint8_t overwritten_data[MAX_BKPT_INSTRUCTION_LENGTH];\n ssize_t bkpt_size = bkpt_instruction_length(arch());\n // Grab a random task from the VM so we can use its\n // read/write_mem() helpers.\n Task* t = first_running_task();\n if (!t ||\n bkpt_size !=\n t->read_bytes_fallible(addr.to_data_ptr(),\n bkpt_size, overwritten_data)) {\n return false;\n }\n t->write_bytes_helper(addr.to_data_ptr(), bkpt_size,\n breakpoint_insn(arch()), nullptr,\n Task::IS_BREAKPOINT_RELATED);\n\n auto it_and_is_new = breakpoints.insert(make_pair(addr, Breakpoint()));\n DEBUG_ASSERT(it_and_is_new.second);\n memcpy(it_and_is_new.first->second.overwritten_data,\n overwritten_data, sizeof(overwritten_data));\n it = it_and_is_new.first;\n }\n it->second.ref(type);\n return true;\n}\n\nvoid AddressSpace::remove_all_breakpoints() {\n while (!breakpoints.empty()) {\n destroy_breakpoint(breakpoints.begin());\n }\n}\n\nvoid AddressSpace::suspend_breakpoint_at(remote_code_ptr addr) {\n auto it = breakpoints.find(addr);\n if (it != breakpoints.end()) {\n Task* t = first_running_task();\n if (t) {\n t->write_bytes_helper(addr.to_data_ptr(),\n bkpt_instruction_length(arch()), it->second.overwritten_data);\n }\n }\n}\n\nvoid AddressSpace::restore_breakpoint_at(remote_code_ptr addr) {\n auto it = breakpoints.find(addr);\n if (it != breakpoints.end()) {\n Task* t = first_running_task();\n if (t) {\n t->write_bytes_helper(addr.to_data_ptr(),\n bkpt_instruction_length(arch()),\n breakpoint_insn(arch()));\n }\n }\n}\n\nint AddressSpace::access_bits_of(WatchType type) {\n switch (type) {\n case WATCH_EXEC:\n return EXEC_BIT;\n case WATCH_WRITE:\n return WRITE_BIT;\n case WATCH_READWRITE:\n return READ_BIT | WRITE_BIT;\n default:\n FATAL() << \"Unknown watchpoint type \" << type;\n return 0; // not reached\n }\n}\n\n/**\n * We do not allow a watchpoint to watch the last byte of memory addressable\n * by rr. This avoids constructing a MemoryRange that wraps around.\n * For 64-bit builds this is no problem because addresses at the top of memory\n * are in kernel space. For 32-bit builds it seems impossible to map the last\n * page of memory in Linux so we should be OK there too.\n * Note that zero-length watchpoints are OK. configure_watch_registers just\n * ignores them.\n */\nstatic MemoryRange range_for_watchpoint(remote_ptr addr,\n size_t num_bytes) {\n uintptr_t p = addr.as_int();\n uintptr_t max_len = UINTPTR_MAX - p;\n return MemoryRange(addr, min(num_bytes, max_len));\n}\n\nvoid AddressSpace::remove_watchpoint(remote_ptr addr, size_t num_bytes,\n WatchType type) {\n auto it = watchpoints.find(range_for_watchpoint(addr, num_bytes));\n if (it != watchpoints.end() &&\n 0 == it->second.unwatch(access_bits_of(type))) {\n watchpoints.erase(it);\n }\n allocate_watchpoints();\n}\n\nbool AddressSpace::add_watchpoint(remote_ptr addr, size_t num_bytes,\n WatchType type) {\n MemoryRange key = range_for_watchpoint(addr, num_bytes);\n auto it = watchpoints.find(key);\n if (it == watchpoints.end()) {\n auto it_and_is_new =\n watchpoints.insert(make_pair(key, Watchpoint(num_bytes)));\n DEBUG_ASSERT(it_and_is_new.second);\n it = it_and_is_new.first;\n update_watchpoint_value(it->first, it->second);\n }\n it->second.watch(access_bits_of(type));\n bool ok = allocate_watchpoints();\n if (!ok) {\n remove_watchpoint(addr, num_bytes, type);\n }\n return ok;\n}\n\nvoid AddressSpace::save_watchpoints() {\n saved_watchpoints.push_back(watchpoints);\n}\n\nbool AddressSpace::restore_watchpoints() {\n DEBUG_ASSERT(!saved_watchpoints.empty());\n watchpoints = saved_watchpoints[saved_watchpoints.size() - 1];\n saved_watchpoints.pop_back();\n return allocate_watchpoints();\n}\n\nbool AddressSpace::update_watchpoint_value(const MemoryRange& range,\n Watchpoint& watchpoint) {\n Task* t = first_running_task();\n if (!t) {\n return false;\n }\n bool valid = true;\n vector value_bytes = watchpoint.value_bytes;\n for (size_t i = 0; i < value_bytes.size(); ++i) {\n value_bytes[i] = 0xFF;\n }\n remote_ptr addr = range.start();\n size_t num_bytes = range.size();\n while (num_bytes > 0) {\n ssize_t bytes_read = t->read_bytes_fallible(\n addr, num_bytes, value_bytes.data() + (addr - range.start()));\n if (bytes_read <= 0) {\n valid = false;\n // advance to next page and try to read more. We want to know\n // when the valid part of a partially invalid watchpoint changes.\n bytes_read =\n min(num_bytes, (floor_page_size(addr) + page_size()) - addr);\n }\n addr += bytes_read;\n num_bytes -= bytes_read;\n }\n\n bool changed = valid != watchpoint.valid ||\n memcmp(value_bytes.data(), watchpoint.value_bytes.data(),\n value_bytes.size()) != 0;\n watchpoint.valid = valid;\n watchpoint.value_bytes = value_bytes;\n return changed;\n}\n\nvoid AddressSpace::update_watchpoint_values(remote_ptr start,\n remote_ptr end) {\n MemoryRange r(start, end);\n for (auto& it : watchpoints) {\n if (it.first.intersects(r) &&\n update_watchpoint_value(it.first, it.second)) {\n it.second.changed = true;\n // We do nothing to track kernel reads of read-write watchpoints...\n }\n }\n}\n\nstatic int DR_WATCHPOINT(int n) { return 1 << n; }\n\nstatic bool watchpoint_triggered(uintptr_t debug_status,\n const vector& regs) {\n for (auto reg : regs) {\n if (debug_status & DR_WATCHPOINT(reg)) {\n return true;\n }\n }\n return false;\n}\n\nbool AddressSpace::notify_watchpoint_fired(uintptr_t debug_status,\n remote_ptr hit_addr,\n remote_code_ptr address_of_singlestep_start) {\n bool triggered = false;\n for (auto& it : watchpoints) {\n // On Skylake/4.14.13-300.fc27.x86_64 at least, we have observed a\n // situation where singlestepping through the instruction before a hardware\n // execution watchpoint causes singlestep completion *and* also reports the\n // hardware execution watchpoint being triggered. The latter is incorrect.\n // This could be a HW issue or a kernel issue. Work around it by ignoring\n // triggered watchpoints that aren't on the instruction we just tried to\n // execute.\n bool write_triggered = (it.second.watched_bits() & WRITE_BIT) &&\n update_watchpoint_value(it.first, it.second);\n // Depending on the architecture the hardware may indicate hit watchpoints\n // either by number, or by the address that triggered the watchpoint hit\n // - support either.\n bool read_triggered = false;\n bool exec_triggered = false;\n bool watchpoint_in_range = false;\n if (is_x86ish(arch())) {\n read_triggered = (it.second.watched_bits() & READ_BIT) &&\n watchpoint_triggered(debug_status,\n it.second.debug_regs_for_exec_read);\n exec_triggered = (it.second.watched_bits() & EXEC_BIT) &&\n (address_of_singlestep_start.is_null() ||\n it.first.start() == address_of_singlestep_start.to_data_ptr()) &&\n watchpoint_triggered(debug_status,\n it.second.debug_regs_for_exec_read);\n } else {\n // The reported address may not match our watchpoint exactly. The ARM\n // manual specifies a number of conditions that apply to the address for\n // various types of instructions (see D2.10.5, \"Determining the memory\n // location that caused a Watchpoint exception\"), but at a minimum it is\n // required that the reported address is in the same block as one of the\n // addresses monitored by the watchpoint, where the block size is defined\n // by DCZID_EL0.BS. So we construct a range spanning the whole block, then\n // test that the range intersects a watchpoint range.\n auto block_size = dczid_el0_block_size();\n auto slop = hit_addr.as_int() % block_size;\n auto hit_range = MemoryRange(hit_addr - slop, block_size);\n watchpoint_in_range = it.first.intersects(hit_range);\n }\n if (write_triggered || read_triggered || exec_triggered || watchpoint_in_range) {\n it.second.changed = true;\n triggered = true;\n }\n }\n return triggered;\n}\n\nvoid AddressSpace::notify_written(remote_ptr addr, size_t num_bytes,\n uint32_t flags) {\n if (!(flags & Task::IS_BREAKPOINT_RELATED)) {\n update_watchpoint_values(addr, addr + num_bytes);\n }\n session()->accumulate_bytes_written(num_bytes);\n}\n\nvoid AddressSpace::remove_all_watchpoints() {\n watchpoints.clear();\n allocate_watchpoints();\n}\n\nvoid AddressSpace::unmap(Task* t, remote_ptr addr, ssize_t num_bytes) {\n LOG(debug) << \"munmap(\" << addr << \", \" << num_bytes << \")\";\n num_bytes = ceil_page_size(num_bytes);\n if (!num_bytes) {\n return;\n }\n\n remove_range(dont_fork, MemoryRange(addr, num_bytes));\n remove_range(wipe_on_fork, MemoryRange(addr, num_bytes));\n\n unmap_internal(t, addr, num_bytes);\n\n if (MemoryRange(addr, num_bytes).contains(RR_PAGE_ADDR)) {\n update_syscall_ips(t);\n }\n}\n\nvoid AddressSpace::update_syscall_ips(Task* t) {\n remote_code_ptr traced_syscall_in_rr_page = rr_page_syscall_entry_point(\n TRACED, UNPRIVILEGED, RECORDING_AND_REPLAY, t->arch());\n SupportedArch arch;\n bool ok = true;\n if (get_syscall_instruction_arch(t, traced_syscall_in_rr_page, &arch, &ok) &&\n arch == t->arch()) {\n // Even if our rr page has been removed, there might still be\n // an rr-page-alike with a syscall in the right place (e.g. when recording rr replay).\n traced_syscall_ip_ = traced_syscall_in_rr_page;\n } else {\n traced_syscall_ip_ = find_syscall_instruction_in_vdso(t);\n }\n\n remote_code_ptr privileged_traced_syscall_in_rr_page = rr_page_syscall_entry_point(\n TRACED, PRIVILEGED, RECORDING_AND_REPLAY, t->arch());\n ok = true;\n if (get_syscall_instruction_arch(t, privileged_traced_syscall_in_rr_page, &arch, &ok) &&\n arch == t->arch()) {\n privileged_traced_syscall_ip_ = privileged_traced_syscall_in_rr_page;\n } else {\n // Only the syscall at the privileged address can be privileged.\n privileged_traced_syscall_ip_ = nullptr;\n }\n}\n\nvoid AddressSpace::unmap_internal(Task* t, remote_ptr addr,\n ssize_t num_bytes) {\n LOG(debug) << \"munmap(\" << addr << \", \" << num_bytes << \")\";\n\n if (MemoryRange(addr, num_bytes).contains(RR_DL_RUNTIME_RESOLVE_CLEAR_FIP) &&\n monkeypatch_state) {\n monkeypatch_state->unpatch_dl_runtime_resolves(\n static_cast(t));\n }\n\n auto unmapper = [this](Mapping m, MemoryRange rem) {\n LOG(debug) << \" unmapping (\" << rem << \") ...\";\n\n remove_from_map(m.map);\n\n LOG(debug) << \" erased (\" << m.map << \") ...\";\n\n // If the first segment we unmap underflows the unmap\n // region, remap the underflow region.\n auto monitored = m.monitored_shared_memory;\n if (m.map.start() < rem.start()) {\n Mapping underflow(m.map.subrange(m.map.start(), rem.start()),\n m.recorded_map.subrange(m.map.start(), rem.start()),\n m.emu_file, clone_stat(m.mapped_file_stat),\n m.local_addr, std::move(monitored));\n underflow.flags = m.flags;\n add_to_map(underflow);\n }\n // If the last segment we unmap overflows the unmap\n // region, remap the overflow region.\n if (rem.end() < m.map.end()) {\n Mapping overflow(\n m.map.subrange(rem.end(), m.map.end()),\n m.recorded_map.subrange(rem.end(), m.map.end()), m.emu_file,\n clone_stat(m.mapped_file_stat),\n m.local_addr ? m.local_addr + (rem.end() - m.map.start()) : 0,\n m.monitored_shared_memory\n ? m.monitored_shared_memory->subrange(rem.end() - m.map.start(),\n m.map.end() - rem.end())\n : nullptr);\n overflow.flags = m.flags;\n add_to_map(overflow);\n }\n\n if (m.local_addr) {\n auto addr = m.local_addr + (rem.start() - m.map.start());\n auto size = std::min(rem.size(), m.map.size() - (rem.start() - m.map.start()));\n int ret = munmap(addr, size);\n if (ret < 0) {\n FATAL() << \"Can't munmap\";\n }\n }\n };\n for_each_in_range(addr, num_bytes, unmapper);\n update_watchpoint_values(addr, addr + num_bytes);\n}\n\nvoid AddressSpace::advise(Task*, remote_ptr addr, ssize_t num_bytes,\n int advice) {\n LOG(debug) << \"madvise(\" << addr << \", \" << num_bytes << \", \" << advice\n << \")\";\n num_bytes = ceil_page_size(num_bytes);\n\n switch (advice) {\n case MADV_DONTFORK:\n add_range(dont_fork, MemoryRange(addr, num_bytes));\n break;\n case MADV_DOFORK:\n remove_range(dont_fork, MemoryRange(addr, num_bytes));\n break;\n case MADV_WIPEONFORK:\n add_range(wipe_on_fork, MemoryRange(addr, num_bytes));\n break;\n case MADV_KEEPONFORK:\n remove_range(wipe_on_fork, MemoryRange(addr, num_bytes));\n break;\n default:\n break;\n }\n}\n\nvoid AddressSpace::did_fork_into(Task* t) {\n // MADV_WIPEONFORK is inherited across fork and cleared on exec.\n // We'll copy it here, then do the `dont_fork` unmappings, and then\n // whatever survives in the new AddressSpace's wipe_on_fork gets wiped.\n t->vm()->wipe_on_fork = wipe_on_fork;\n\n for (auto& range : dont_fork) {\n // During recording we execute MADV_DONTFORK so the forked child will\n // have had its dontfork areas unmapped by the kernel already\n if (!t->session().is_recording()) {\n AutoRemoteSyscalls remote(t);\n remote.infallible_syscall(syscall_number_for_munmap(remote.arch()),\n range.start(), range.size());\n }\n t->vm()->unmap(t, range.start(), range.size());\n }\n\n // Any ranges that were dropped were unmapped (and thus removed from\n // wipe_on_fork), so now we can record anything that's left.\n for (auto& range : t->vm()->wipe_on_fork) {\n if (t->session().is_recording()) {\n // Record that these mappings were wiped.\n RecordTask* rt = static_cast(t);\n rt->record_remote(range);\n }\n }\n}\n\nvoid AddressSpace::set_anon_name(Task* t, MemoryRange range, const std::string* name) {\n bool saw_only_anonymous = true;\n MemoryRange last_overlap;\n auto setter = [this, t, &name, &saw_only_anonymous, &last_overlap](Mapping m, MemoryRange rem) {\n if (!(m.map.flags() & MAP_ANONYMOUS) || !saw_only_anonymous) {\n saw_only_anonymous = false;\n return;\n }\n remove_from_map(m.map);\n\n if (m.map.start() < rem.start()) {\n Mapping underflow = m.subrange(MemoryRange(m.map.start(), rem.start()),\n [](const KernelMapping& km) { return km; });\n add_to_map(underflow);\n }\n // Remap the overlapping region with the new prot.\n remote_ptr new_end = min(rem.end(), m.map.end());\n\n Mapping overlap;\n if (!name && (m.map.flags() & MAP_SHARED)) {\n // We're resetting the name to whatever the original name was.\n string new_name = read_kernel_mapping(t, rem.start()).fsname();\n overlap = m.subrange(MemoryRange(rem.start(), new_end),\n [&new_name, t](const KernelMapping& km) {\n if (km.fsname().empty() && !t->session().is_recording()) {\n // record_map case\n return km;\n }\n return km.set_fsname(new_name);\n });\n } else {\n string new_name;\n if (name) {\n if (m.map.flags() & MAP_SHARED) {\n new_name = \"[anon_shmem:\" + *name + \"]\";\n } else {\n new_name = \"[anon:\" + *name + \"]\";\n }\n }\n overlap = m.subrange(MemoryRange(rem.start(), new_end),\n [&new_name](const KernelMapping& km) { return km.set_fsname(new_name); });\n }\n add_to_map(overlap);\n last_overlap = overlap.map;\n\n // If the last segment we protect overflows the\n // region, remap the overflow region with previous\n // prot.\n if (new_end < m.map.end()) {\n Mapping overflow = m.subrange(MemoryRange(new_end, m.map.end()),\n [](const KernelMapping& km) { return km; });\n add_to_map(overflow);\n }\n };\n for_each_in_range(range.start(), range.size(), setter, ITERATE_CONTIGUOUS);\n if (last_overlap.size()) {\n // All mappings that we altered which might need coalescing\n // are adjacent to |last_overlap|.\n coalesce_around(t, mem.find(last_overlap));\n }\n}\n\nstatic string strip_deleted(const string& s) {\n static const char deleted[] = \" (deleted)\";\n ssize_t find_deleted = s.size() - (sizeof(deleted) - 1);\n if (s.find(deleted) == size_t(find_deleted)) {\n return s.substr(0, find_deleted);\n }\n return s;\n}\n\nstring KernelMapping::fsname_strip_deleted() const {\n return strip_deleted(fsname_);\n}\n\nenum HandleHeap { TREAT_HEAP_AS_ANONYMOUS, RESPECT_HEAP };\n\nstatic bool normalized_file_names_equal(const KernelMapping& km1,\n const KernelMapping& km2,\n HandleHeap handle_heap) {\n if (km1.is_stack() || km2.is_stack()) {\n // The kernel seems to use \"[stack:]\" for any mapping area containing\n // thread |tid|'s stack pointer. When the thread exits, the next read of\n // the maps doesn't treat the area as stack at all. We don't want to track\n // thread exits, so if one of the mappings is a stack, skip the name\n // comparison. Device and inode numbers will still be checked.\n return true;\n }\n if (handle_heap == TREAT_HEAP_AS_ANONYMOUS &&\n (km1.is_heap() || km2.is_heap())) {\n // The kernel's heuristics for treating an anonymous mapping as \"[heap]\"\n // are obscure. Just skip the name check. Device and inode numbers will\n // still be checked.\n return true;\n }\n // We don't track when a file gets deleted, so it's possible for the kernel\n // to have \" (deleted)\" when we don't.\n return strip_deleted(km1.fsname()) == strip_deleted(km2.fsname());\n}\n\n/**\n * Return true iff |left| and |right| are located adjacently in memory\n * with the same metadata, and map adjacent locations of the same\n * underlying (real) device.\n */\nstatic bool is_adjacent_mapping(const KernelMapping& mleft,\n const KernelMapping& mright,\n HandleHeap handle_heap,\n int32_t flags_to_check = 0xFFFFFFFF) {\n if (mleft.end() != mright.start()) {\n return false;\n }\n if (((mleft.flags() ^ mright.flags()) & flags_to_check) ||\n mleft.prot() != mright.prot()) {\n return false;\n }\n if (!normalized_file_names_equal(mleft, mright, handle_heap)) {\n return false;\n }\n if (mleft.device() != mright.device() || mleft.inode() != mright.inode()) {\n return false;\n }\n if (mleft.is_real_device() &&\n mleft.file_offset_bytes() + off_t(mleft.size()) !=\n mright.file_offset_bytes()) {\n return false;\n }\n return true;\n}\n\n/**\n * If |*left_m| and |right_m| are adjacent (see\n * |is_adjacent_mapping()|), write a merged segment descriptor to\n * |*left_m| and return true. Otherwise return false.\n */\nstatic bool try_merge_adjacent(KernelMapping* left_m,\n const KernelMapping& right_m) {\n if (is_adjacent_mapping(*left_m, right_m, TREAT_HEAP_AS_ANONYMOUS,\n KernelMapping::checkable_flags_mask)) {\n *left_m = KernelMapping(left_m->start(), right_m.end(), left_m->fsname(),\n left_m->device(), left_m->inode(), right_m.prot(),\n right_m.flags(), left_m->file_offset_bytes());\n return true;\n }\n return false;\n}\n\nstatic dev_t normalized_device_number(const KernelMapping& m) {\n if (m.fsname().c_str()[0] != '/') {\n return m.device();\n }\n // btrfs files can report the wrong device number in /proc//maps, so\n // restrict ourselves to checking whether the device number is != 0\n if (m.device() != KernelMapping::NO_DEVICE) {\n return (dev_t)-1;\n }\n return m.device();\n}\n\nstatic void assert_segments_match(Task* t, const KernelMapping& input_m,\n const KernelMapping& km) {\n KernelMapping m = input_m;\n string err;\n if (m.start() != km.start()) {\n err = \"starts differ\";\n } else if (m.end() != km.end()) {\n err = \"ends differ\";\n } else if ((m.prot() ^ km.prot()) & KernelMapping::checkable_prot_mask) {\n err = \"prots differ\";\n } else if ((m.flags() ^ km.flags()) & KernelMapping::checkable_flags_mask) {\n err = \"flags differ\";\n } else if (!normalized_file_names_equal(m, km, TREAT_HEAP_AS_ANONYMOUS) &&\n !(km.is_heap() && m.fsname() == \"\") &&\n !(m.is_heap() && km.fsname() == \"\") && !km.is_vdso()) {\n // Due to emulated exec, the kernel may identify any of our anonymous maps\n // as [heap] (or not).\n // Kernels before 3.16 have a bug where any mapping at the original VDSO\n // address is marked [vdso] even if the VDSO was unmapped and replaced by\n // something else, so if the kernel reports [vdso] it may be spurious and\n // we skip this check. See kernel commit\n // a62c34bd2a8a3f159945becd57401e478818d51c.\n err = \"filenames differ\";\n } else if (normalized_device_number(m) != normalized_device_number(km)) {\n err = \"devices_differ\";\n } else if (m.inode() != km.inode()) {\n err = \"inodes differ\";\n }\n if (err.size()) {\n cerr << \"cached mmap:\" << endl;\n t->vm()->dump();\n cerr << \"/proc/\" << t->tid << \"/mmaps:\" << endl;\n AddressSpace::print_process_maps(t);\n ASSERT(t, false) << \"\\nCached mapping \" << m << \" should be \" << km << \"; \"\n << err;\n }\n}\n\nvoid AddressSpace::ensure_replay_matches_single_recorded_mapping(Task* t, MemoryRange range) {\n // The only case where we eagerly coalesced during recording but not replay should\n // be where we mapped private memory beyond-end-of-file.\n // Don't do an actual coalescing check here; we rely on the caller to tell us\n // the range to coalesce.\n ASSERT(t, range.start() == floor_page_size(range.start()));\n ASSERT(t, range.end() == ceil_page_size(range.end()));\n\n auto fixer = [this, t, range](Mapping mapping, MemoryRange) {\n if (mapping.map == range) {\n // Existing single mapping covers entire range; nothing to do.\n return;\n }\n\n // These should be null during replay\n ASSERT(t, !mapping.mapped_file_stat);\n // These should not be in use for a beyond-end-of-file mapping\n ASSERT(t, !mapping.local_addr);\n // The mapping should be private\n ASSERT(t, mapping.map.flags() & MAP_PRIVATE);\n ASSERT(t, !mapping.emu_file);\n ASSERT(t, !mapping.monitored_shared_memory);\n // Flagged mappings shouldn't be coalescable ever\n ASSERT(t, !mapping.flags);\n\n if (!(mapping.map.flags() & MAP_ANONYMOUS)) {\n // Direct-mapped piece. Turn it into an anonymous mapping.\n vector buffer;\n buffer.resize(mapping.map.size());\n t->read_bytes_helper(mapping.map.start(), buffer.size(), buffer.data());\n {\n AutoRemoteSyscalls remote(t);\n remote.infallible_mmap_syscall_if_alive(mapping.map.start(), buffer.size(),\n mapping.map.prot(), mapping.map.flags() | MAP_ANONYMOUS | MAP_FIXED, -1, 0);\n }\n t->write_bytes_helper(mapping.map.start(), buffer.size(), buffer.data());\n\n // We replace the entire mapping even if part of it falls outside the desired range.\n // That's OK, this replacement preserves behaviour, it's simpler, even if a bit\n // less efficient in weird cases.\n mem.erase(mapping.map);\n KernelMapping anonymous_km(mapping.map.start(), mapping.map.end(),\n string(), KernelMapping::NO_DEVICE, KernelMapping::NO_INODE,\n mapping.map.prot(), mapping.map.flags() | MAP_ANONYMOUS);\n Mapping new_mapping(anonymous_km, mapping.recorded_map);\n mem[new_mapping.map] = new_mapping;\n }\n };\n for_each_in_range(range.start(), range.size(), fixer);\n\n coalesce_around(t, mem.find(range));\n}\n\nKernelMapping AddressSpace::vdso() const {\n DEBUG_ASSERT(!vdso_start_addr.is_null());\n return mapping_of(vdso_start_addr).map;\n}\n\n/**\n * Iterate over /proc/maps segments for a task and verify that the\n * task's cached mapping matches the kernel's (given a lenient fuzz\n * factor).\n */\nvoid AddressSpace::verify(Task* t) const {\n ASSERT(t, task_set().end() != task_set().find(t));\n\n if (thread_group_in_exec(t)) {\n return;\n }\n\n LOG(debug) << \"Verifying address space for task \" << t->tid;\n\n MemoryMap::const_iterator mem_it = mem.begin();\n bool ok = false;\n // Must pass ok parameter otherwise KernelMapIterator constructor will become\n // infallible if /proc/[tid]/maps cannot be opened\n KernelMapIterator kernel_it(t, &ok);\n // checking at_end() is equivalent to checking if ok\n if (kernel_it.at_end()) {\n LOG(debug) << \"Task \" << t->tid << \" exited unexpectedly, ignoring\";\n return;\n }\n while (!kernel_it.at_end() && mem_it != mem.end()) {\n KernelMapping km = kernel_it.current();\n ++kernel_it;\n while (!kernel_it.at_end()) {\n KernelMapping next_km = kernel_it.current();\n if (!try_merge_adjacent(&km, next_km)) {\n break;\n }\n ++kernel_it;\n }\n\n KernelMapping vm = mem_it->second.map;\n ++mem_it;\n while (mem_it != mem.end() && try_merge_adjacent(&vm, mem_it->second.map)) {\n ++mem_it;\n }\n\n assert_segments_match(t, vm, km);\n }\n\n ASSERT(t, kernel_it.at_end() && mem_it == mem.end());\n}\n\n// Just a place that rr's AutoSyscall functionality can use as a syscall\n// instruction in rr's address space for use before we have exec'd.\nextern \"C\" {\n// Mark this as hidden, otherwise we might get the address of the GOT entry,\n// which could cause problems.\nextern char rr_syscall_addr __attribute__ ((visibility (\"hidden\")));\n}\nstatic void __attribute__((noinline, used)) fake_syscall() {\n __asm__ __volatile__(\".global rr_syscall_addr\\n\\t\");\n#ifdef __i386__\n __asm__ __volatile__(\"rr_syscall_addr: int $0x80\\n\\t\"\n \"nop\\n\\t\"\n \"nop\\n\\t\"\n \"nop\\n\\t\");\n#elif defined(__x86_64__)\n __asm__ __volatile__(\"rr_syscall_addr: syscall\\n\\t\"\n \"nop\\n\\t\"\n \"nop\\n\\t\"\n \"nop\\n\\t\");\n#elif defined(__aarch64__)\n __asm__ __volatile__(\"rr_syscall_addr: svc #0\\n\\t\"\n \"nop\\n\\t\"\n \"nop\\n\\t\"\n \"nop\\n\\t\");\n#endif\n}\n\nAddressSpace::AddressSpace(Task* t, const string& exe, uint32_t exec_count)\n : exe(exe),\n leader_tid_(t->rec_tid),\n leader_serial(t->tuid().serial()),\n exec_count(exec_count),\n session_(&t->session()),\n monkeypatch_state(t->session().is_recording() ? new Monkeypatcher()\n : nullptr),\n syscallbuf_enabled_(false),\n layout_randomization_disabled_(false),\n do_breakpoint_fault_addr_(nullptr),\n stopping_breakpoint_table_(nullptr),\n stopping_breakpoint_table_entry_size_(0),\n first_run_event_(0) {\n // TODO: this is a workaround of\n // https://github.com/rr-debugger/rr/issues/1113 .\n if (session_->done_initial_exec()) {\n populate_address_space(t);\n DEBUG_ASSERT(!vdso_start_addr.is_null());\n } else {\n // Setup traced_syscall_ip_ now because we need to do AutoRemoteSyscalls\n // (for open_mem_fd) before the first exec. We rely on the fact that we\n // haven't execed yet, so the address space layout is the same.\n traced_syscall_ip_ = remote_code_ptr((uintptr_t)&rr_syscall_addr);\n }\n}\n\n// Does not copy the task set; the new AddressSpace will be for new tasks.\nAddressSpace::AddressSpace(Session* session, const AddressSpace& o,\n pid_t leader_tid, uint32_t leader_serial,\n uint32_t exec_count)\n : exe(o.exe),\n leader_tid_(leader_tid),\n leader_serial(leader_serial),\n exec_count(exec_count),\n brk_start(o.brk_start),\n brk_end(o.brk_end),\n mem(o.mem),\n shm_sizes(o.shm_sizes),\n monitored_mem(o.monitored_mem),\n dont_fork(o.dont_fork),\n wipe_on_fork(o.wipe_on_fork),\n session_(session),\n vdso_start_addr(o.vdso_start_addr),\n monkeypatch_state(o.monkeypatch_state\n ? new Monkeypatcher(*o.monkeypatch_state)\n : nullptr),\n traced_syscall_ip_(o.traced_syscall_ip_),\n privileged_traced_syscall_ip_(o.privileged_traced_syscall_ip_),\n syscallbuf_enabled_(o.syscallbuf_enabled_),\n layout_randomization_disabled_(o.layout_randomization_disabled_),\n do_breakpoint_fault_addr_(o.do_breakpoint_fault_addr_),\n stopping_breakpoint_table_(o.stopping_breakpoint_table_),\n stopping_breakpoint_table_entry_size_(o.stopping_breakpoint_table_entry_size_),\n saved_auxv_(o.saved_auxv_),\n saved_interpreter_base_(o.saved_interpreter_base_),\n saved_ld_path_(o.saved_ld_path_),\n last_free_memory(o.last_free_memory),\n first_run_event_(0) {\n for (auto& m : mem) {\n // The original address space continues to have exclusive ownership of\n // all local mappings.\n m.second.local_addr = nullptr;\n }\n\n for (auto& it : o.breakpoints) {\n breakpoints.insert(make_pair(it.first, it.second));\n }\n for (auto& it : o.watchpoints) {\n watchpoints.insert(make_pair(it.first, it.second));\n }\n if (session != o.session()) {\n // Cloning into a new session means we're checkpointing.\n first_run_event_ = o.first_run_event_;\n }\n // cloned tasks will automatically get cloned debug registers and\n // cloned address-space memory, so we don't need to do any more work here.\n}\n\nbool AddressSpace::post_vm_clone(Task* t) {\n if (has_mapping(preload_thread_locals_start()) &&\n (mapping_flags_of(preload_thread_locals_start()) &\n AddressSpace::Mapping::IS_THREAD_LOCALS) == 0) {\n // The tracee already has a mapping at this address that doesn't belong to\n // us. Don't touch it.\n return false;\n }\n\n // Otherwise, the preload_thread_locals mapping is nonexistent or ours.\n // Recreate it.\n AutoRemoteSyscalls remote(t);\n t->session().create_shared_mmap(remote, PRELOAD_THREAD_LOCALS_SIZE,\n preload_thread_locals_start(),\n \"preload_thread_locals\");\n mapping_flags_of(preload_thread_locals_start()) |=\n AddressSpace::Mapping::IS_THREAD_LOCALS;\n return true;\n}\n\nstatic bool try_split_unaligned_range(MemoryRange& range, size_t bytes,\n vector& result) {\n if ((range.start().as_int() & (bytes - 1)) || range.size() < bytes) {\n return false;\n }\n result.push_back(MemoryRange(range.start(), bytes));\n range = MemoryRange(range.start() + bytes, range.end());\n return true;\n}\n\nstatic vector split_range(const MemoryRange& range) {\n vector result;\n MemoryRange r = range;\n while (r.size() > 0) {\n if ((sizeof(void*) < 8 || !try_split_unaligned_range(r, 8, result)) &&\n !try_split_unaligned_range(r, 4, result) &&\n !try_split_unaligned_range(r, 2, result)) {\n bool ret = try_split_unaligned_range(r, 1, result);\n DEBUG_ASSERT(ret);\n }\n }\n return result;\n}\n\nstatic void configure_watch_registers(vector& regs,\n const MemoryRange& range, WatchType type,\n vector* assigned_regs,\n AddressSpace::WatchpointAlignment alignment) {\n if (alignment == AddressSpace::UNALIGNED) {\n regs.push_back(WatchConfig(range.start(), range.size(), type));\n return;\n }\n\n // Zero-sized WatchConfigs return no ranges here, so are ignored.\n auto split_ranges = split_range(range);\n\n if (type == WATCH_WRITE && range.size() > 1) {\n // We can suppress spurious write-watchpoint triggerings by checking\n // whether memory values have changed. So we can sometimes conserve\n // debug registers by upgrading an unaligned range to an aligned range\n // of a larger size.\n uintptr_t align;\n if (range.size() <= 2) {\n align = 2;\n } else if (range.size() <= 4 || sizeof(void*) <= 4) {\n align = 4;\n } else {\n align = 8;\n }\n remote_ptr aligned_start(range.start().as_int() & ~(align - 1));\n remote_ptr aligned_end((range.end().as_int() + (align - 1)) &\n ~(align - 1));\n auto split = split_range(MemoryRange(aligned_start, aligned_end));\n // If the aligned range doesn't reduce register usage, use the original\n // split to avoid spurious triggerings\n if (split.size() < split_ranges.size()) {\n split_ranges = split;\n }\n }\n\n for (auto& r : split_ranges) {\n if (assigned_regs) {\n assigned_regs->push_back(regs.size());\n }\n regs.push_back(WatchConfig(r.start(), r.size(), type));\n }\n}\n\nvector AddressSpace::get_watchpoints_internal(\n WatchpointFilter filter,\n WatchpointAlignment alignment,\n UpdateWatchpointRegisterAssignments update_watchpoint_register_assignments) {\n vector result;\n for (auto& kv : watchpoints) {\n if (filter == CHANGED_WATCHPOINTS) {\n if (!kv.second.changed) {\n continue;\n }\n kv.second.changed = false;\n }\n vector* assigned_regs = nullptr;\n if (update_watchpoint_register_assignments == UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS) {\n kv.second.debug_regs_for_exec_read.clear();\n assigned_regs = &kv.second.debug_regs_for_exec_read;\n }\n const MemoryRange& r = kv.first;\n int watching = kv.second.watched_bits();\n if (EXEC_BIT & watching) {\n configure_watch_registers(result, r, WATCH_EXEC, assigned_regs, alignment);\n }\n if (READ_BIT & watching) {\n configure_watch_registers(result, r, WATCH_READWRITE, assigned_regs, alignment);\n } else if (WRITE_BIT & watching) {\n configure_watch_registers(result, r, WATCH_WRITE, nullptr, alignment);\n }\n }\n return result;\n}\n\nbool AddressSpace::has_any_watchpoint_changes() {\n for (auto& kv : watchpoints) {\n if (kv.second.changed) {\n return true;\n }\n }\n return false;\n}\n\nbool AddressSpace::has_exec_watchpoint_fired(remote_code_ptr addr) {\n for (auto& kv : watchpoints) {\n if (kv.second.changed && kv.second.exec_count > 0 &&\n kv.first.start() == addr.to_data_ptr()) {\n return true;\n }\n }\n return false;\n}\n\nbool AddressSpace::allocate_watchpoints() {\n vector regs = get_watchpoints_internal(ALL_WATCHPOINTS, ALIGNED,\n UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS);\n\n if (task_set().empty()) {\n // We can't validate the watchpoint set in this case\n FATAL() << \"No tasks???\";\n }\n if ((*task_set().begin())->set_debug_regs(regs)) {\n return true;\n }\n\n for (auto kv : watchpoints) {\n kv.second.debug_regs_for_exec_read.clear();\n }\n return false;\n}\n\nstatic inline void assert_coalescable(Task* t,\n const AddressSpace::Mapping& lower,\n const AddressSpace::Mapping& higher) {\n ASSERT(t, lower.emu_file == higher.emu_file);\n ASSERT(t, lower.flags == higher.flags);\n ASSERT(t,\n (lower.local_addr == 0 && higher.local_addr == 0) ||\n lower.local_addr + lower.map.size() == higher.local_addr);\n ASSERT(t, !lower.monitored_shared_memory && !higher.monitored_shared_memory);\n}\n\nstatic bool is_coalescable(const AddressSpace::Mapping& mleft,\n const AddressSpace::Mapping& mright) {\n if (!is_adjacent_mapping(mleft.map, mright.map, RESPECT_HEAP) ||\n !is_adjacent_mapping(mleft.recorded_map, mright.recorded_map,\n RESPECT_HEAP)) {\n return false;\n }\n return mleft.flags == mright.flags;\n}\n\nvoid AddressSpace::coalesce_around(Task* t, MemoryMap::iterator it) {\n auto first_kv = it;\n while (mem.begin() != first_kv) {\n auto next = first_kv;\n --first_kv;\n if (!is_coalescable(first_kv->second, next->second)) {\n first_kv = next;\n break;\n }\n assert_coalescable(t, first_kv->second, next->second);\n }\n auto last_kv = it;\n while (true) {\n auto prev = last_kv;\n ++last_kv;\n if (mem.end() == last_kv ||\n !is_coalescable(prev->second, last_kv->second)) {\n last_kv = prev;\n break;\n }\n assert_coalescable(t, prev->second, last_kv->second);\n }\n ASSERT(t, last_kv != mem.end());\n if (first_kv == last_kv) {\n LOG(debug) << \" no mappings to coalesce\";\n return;\n }\n\n Mapping new_m(first_kv->second.map.extend(last_kv->first.end()),\n first_kv->second.recorded_map.extend(last_kv->first.end()),\n first_kv->second.emu_file,\n clone_stat(first_kv->second.mapped_file_stat),\n first_kv->second.local_addr);\n new_m.flags = first_kv->second.flags;\n LOG(debug) << \" coalescing \" << new_m.map;\n\n // monitored-memory currently isn't coalescable so we don't need to\n // adjust monitored_mem\n mem.erase(first_kv, ++last_kv);\n\n auto ins = mem.insert(MemoryMap::value_type(new_m.map, new_m));\n DEBUG_ASSERT(ins.second); // key didn't already exist\n}\n\nvoid AddressSpace::destroy_breakpoint(BreakpointMap::const_iterator it) {\n if (task_set().empty()) {\n return;\n }\n Task* t = first_running_task();\n if (!t) {\n return;\n }\n auto ptr = it->first.to_data_ptr();\n auto data = it->second.overwritten_data;\n if (bkpt_instruction_length(arch()) == 1) {\n LOG(debug) << \"Writing back \" << HEX(data[0]) << \" at \" << ptr;\n } else {\n LOG(debug) << \"Writing back \" << bkpt_instruction_length(arch()) << \" bytes at \" << ptr;\n }\n t->write_bytes_helper(ptr, bkpt_instruction_length(arch()),\n data, nullptr, Task::IS_BREAKPOINT_RELATED);\n breakpoints.erase(it);\n}\n\nvoid AddressSpace::maybe_update_breakpoints(Task* t, remote_ptr addr,\n size_t len) {\n if (!len) {\n return;\n }\n for (auto& it : breakpoints) {\n remote_ptr bp_addr = it.first.to_data_ptr();\n if (addr <= bp_addr && bp_addr < addr + len - 1) {\n // This breakpoint was overwritten. Note the new data and reset the\n // breakpoint.\n bool ok = true;\n t->read_bytes_helper(bp_addr, bkpt_instruction_length(arch()),\n &it.second.overwritten_data, &ok);\n ASSERT(t, ok);\n t->write_bytes_helper(bp_addr, bkpt_instruction_length(arch()),\n breakpoint_insn(arch()));\n }\n }\n}\n\nvoid AddressSpace::for_each_in_range(\n remote_ptr addr, ssize_t num_bytes,\n function f, int how) {\n remote_ptr region_start = floor_page_size(addr);\n remote_ptr last_unmapped_end = region_start;\n remote_ptr region_end = ceil_page_size(addr + num_bytes);\n while (last_unmapped_end < region_end) {\n // Invariant: |rem| is always exactly the region of\n // memory remaining to be examined for pages to be\n // unmapped.\n MemoryRange rem(last_unmapped_end, region_end);\n\n // The next page to iterate may not be contiguous with\n // the last one seen.\n auto it = mem.lower_bound(rem);\n if (mem.end() == it) {\n LOG(debug) << \" not found, done.\";\n return;\n }\n\n // Don't make a reference here. |f| is allowed to erase Mappings.\n MemoryRange range = it->first;\n if (rem.end() <= range.start()) {\n LOG(debug) << \" mapping at \" << range.start() << \" out of range, done.\";\n return;\n }\n if (ITERATE_CONTIGUOUS == how &&\n !(range.start() < region_start || rem.start() == range.start())) {\n LOG(debug) << \" discontiguous mapping at \" << range.start() << \", done.\";\n return;\n }\n\n f(it->second, rem);\n\n // Maintain the loop invariant.\n last_unmapped_end = range.end();\n }\n}\n\nvoid AddressSpace::map_and_coalesce(\n Task* t, const KernelMapping& m, const KernelMapping& recorded_map,\n EmuFile::shr_ptr emu_file, unique_ptr mapped_file_stat,\n void* local_addr, shared_ptr monitored) {\n LOG(debug) << \" mapping \" << m;\n\n if (monitored) {\n monitored_mem.insert(m.start());\n }\n auto ins = mem.insert(MemoryMap::value_type(\n m, Mapping(m, recorded_map, emu_file, std::move(mapped_file_stat),\n local_addr, std::move(monitored))));\n coalesce_around(t, ins.first);\n\n update_watchpoint_values(m.start(), m.end());\n}\n\nstatic bool could_be_stack(const KernelMapping& km) {\n // On 4.1.6-200.fc22.x86_64 we observe that during exec of the rr_exec_stub\n // during replay, when the process switches from 32-bit to 64-bit, the 64-bit\n // registers seem truncated to 32 bits during the initial PTRACE_GETREGS so\n // our sp looks wrong and /proc//maps doesn't identify the region as\n // stack.\n // On stub execs there should only be one read-writable memory area anyway.\n return km.prot() == (PROT_READ | PROT_WRITE) && km.fsname() == \"\" &&\n km.device() == KernelMapping::NO_DEVICE &&\n km.inode() == KernelMapping::NO_INODE;\n}\n\nstatic dev_t check_device(const KernelMapping& km) {\n if (km.fsname().c_str()[0] != '/') {\n return km.device();\n }\n // btrfs files can return the wrong device number in /proc//maps\n struct stat st;\n int ret = stat(km.fsname().c_str(), &st);\n if (ret < 0) {\n return km.device();\n }\n return st.st_dev;\n}\n\nvoid AddressSpace::populate_address_space(Task* t) {\n bool found_proper_stack = false;\n for (KernelMapIterator it(t); !it.at_end(); ++it) {\n auto& km = it.current();\n if (km.is_stack()) {\n found_proper_stack = true;\n }\n }\n\n // If we're being recorded by rr, we'll see the outer rr's rr_page and\n // preload_thread_locals. In post_exec() we'll remap those with our\n // own mappings. That's OK because a) the rr_page contents are the same\n // anyway and immutable and b) the preload_thread_locals page is only\n // used by the preload library, and the preload library only knows about\n // the inner rr. I.e. as far as the outer rr is concerned, the tracee is\n // not doing syscall buffering.\n\n int found_stacks = 0;\n for (KernelMapIterator it(t); !it.at_end(); ++it) {\n auto& km = it.current();\n int flags = km.flags();\n remote_ptr start = km.start();\n bool is_stack = found_proper_stack ? km.is_stack() : could_be_stack(km);\n if (is_stack) {\n ++found_stacks;\n flags |= MAP_GROWSDOWN;\n if (uses_invisible_guard_page()) {\n // MAP_GROWSDOWN segments really occupy one additional page before\n // the start address shown by /proc//maps --- unless that page\n // is already occupied by another mapping.\n if (!has_mapping(start - page_size())) {\n start -= page_size();\n }\n }\n }\n\n map(t, start, km.end() - start, km.prot(), flags, km.file_offset_bytes(),\n km.fsname(), check_device(km), km.inode(), nullptr);\n }\n ASSERT(t, found_stacks == 1);\n}\n\nstatic MemoryRange adjust_range_for_stack_growth(const KernelMapping& km) {\n remote_ptr start = km.start();\n remote_ptr end = km.end();\n if (km.flags() & MAP_GROWSDOWN) {\n start = min(start, km.end() - AddressSpace::chaos_mode_min_stack_size());\n // We actually must separate mappings from the stack by at least one page - otherwise the\n // kernel might merge the VMA we're allocating with the stack! That actually can only happen\n // under rr anyway, because we strip out the MAP_GROWSDOWN flag out of the mmap flags. This\n // causes problems for glibc - in particular pthread_attr_getstack will open /proc/self/maps\n // and fish around for the top of the initial thread's stack, and it will get the wrong value\n // if the stack VMA is merged with the one above it.\n start -= page_size();\n end += page_size();\n }\n return MemoryRange(start, end);\n}\n\nstatic MemoryRange overlaps_excluded_range(const RecordSession& session, MemoryRange range) {\n for (const auto& r : session.excluded_ranges()) {\n if (r.intersects(range)) {\n return r;\n }\n }\n return MemoryRange();\n}\n\nstatic bool is_all_memory_excluded(const RecordSession& session) {\n for (const auto& r : session.excluded_ranges()) {\n if (r == MemoryRange::all()) {\n return true;\n }\n }\n return false;\n}\n\n// Choose a 4TB range to exclude from random mappings. This makes room for\n// advanced trace analysis tools that require a large address range in tracees\n// that is never mapped.\nstatic MemoryRange choose_global_exclusion_range(const RecordSession* session) {\n if (session && is_all_memory_excluded(*session)) {\n return MemoryRange(nullptr, 0);\n }\n if (session && session->fixed_global_exclusion_range().size()) {\n // For TSAN we have a hardcoded range stored in the session.\n return session->fixed_global_exclusion_range();\n }\n\n const uint64_t range_size = uint64_t(4)*1024*1024*1024*1024;\n while (true) {\n int bits = addr_bits(x86_64);\n uint64_t r = ((uint64_t)(uint32_t)random() << 32) | (uint32_t)random();\n uint64_t r_addr = r & ((uint64_t(1) << bits) - 1);\n r_addr = min(r_addr, (uint64_t(1) << bits) - range_size);\n remote_ptr addr = floor_page_size(remote_ptr(r_addr));\n MemoryRange ret(addr, (uintptr_t)range_size);\n if (!session || !overlaps_excluded_range(*session, ret).size()) {\n return ret;\n }\n }\n}\n\nMemoryRange AddressSpace::get_global_exclusion_range(const RecordSession* session) {\n static MemoryRange global_exclusion_range = choose_global_exclusion_range(session);\n return global_exclusion_range;\n}\n\nstatic const remote_ptr addr_space_start(0x40000);\n\nremote_ptr AddressSpace::chaos_mode_find_free_memory(RecordTask* t,\n size_t len, remote_ptr hint) {\n if (is_all_memory_excluded(t->session())) {\n return nullptr;\n }\n\n MemoryRange global_exclusion_range = get_global_exclusion_range(&t->session());\n // NB: Above RR_PAGE_ADDR is probably not free anyways, but if it somehow is\n // don't hand it out again.\n static MemoryRange rrpage_so_range = MemoryRange(remote_ptr(RR_PAGE_ADDR - PRELOAD_LIBRARY_PAGE_SIZE),\n remote_ptr(RR_PAGE_ADDR + PRELOAD_LIBRARY_PAGE_SIZE));\n assert(rrpage_so_range.size() == 2 * PRELOAD_LIBRARY_PAGE_SIZE);\n\n // Ignore the hint half the time.\n if (hint && (random() & 1)) {\n hint = nullptr;\n }\n\n remote_ptr start = hint;\n if (!start) {\n // Half the time, try to allocate at a completely random address. The other\n // half of the time, we'll try to allocate immediately before or after a\n // randomly chosen existing mapping.\n if (random() % 2) {\n uint64_t r = ((uint64_t)(uint32_t)random() << 32) | (uint32_t)random();\n start = floor_page_size(remote_ptr(r & ((uint64_t(1) << addr_bits(t->arch())) - 1)));\n } else {\n ASSERT(t, !mem.empty());\n int map_index = random() % mem.size();\n int map_count = 0;\n for (const auto& m : maps()) {\n if (map_count == map_index) {\n start = m.map.start();\n break;\n }\n ++map_count;\n }\n }\n }\n // Reserve 3 pages at the end of userspace in case Monkeypatcher wants\n // to allocate something there.\n uint64_t reserve_area_for_monkeypatching = 3 * page_size();\n remote_ptr addr_space_end =\n usable_address_space_end(t->arch()) - reserve_area_for_monkeypatching;\n // Clamp start so that we're in the usable address space.\n start = max(start, addr_space_start);\n start = min(start, addr_space_end - len);\n\n // Search the address space in one direction all the way to the end,\n // then in the other direction.\n int direction = (random() % 2) ? 1 : -1;\n remote_ptr addr;\n for (int iteration = 0; iteration < 2; ++iteration) {\n // Invariant: [addr, addr+len) is always in the usable address space\n // [addr_space_start, addr_space_end).\n addr = start;\n while (true) {\n // Look for any reserved address space that overlaps [addr, addr+len]\n // and store any overlapping range here. If multiple reserved areas\n // overlap, we just pick one arbitrarily.\n MemoryRange overlapping_range;\n Maps m = maps_containing_or_after(addr);\n if (m.begin() != m.end()) {\n MemoryRange range = adjust_range_for_stack_growth(m.begin()->map);\n if (range.start() < addr + len) {\n overlapping_range = range;\n }\n }\n if (!overlapping_range.size()) {\n MemoryRange r(addr, ceil_page_size(len));\n if (r.intersects(rrpage_so_range)) {\n overlapping_range = rrpage_so_range;\n } else if (r.intersects(global_exclusion_range)) {\n overlapping_range = global_exclusion_range;\n } else if (!t->session().excluded_ranges().empty()) {\n ASSERT(t, word_size(t->arch()) >= 8)\n << \"Chaos mode with ASAN/TSAN not supported in 32-bit processes\";\n MemoryRange excluded = overlaps_excluded_range(t->session(), r);\n if (excluded.size()) {\n overlapping_range = excluded;\n }\n }\n }\n if (!overlapping_range.size()) {\n // No overlap and the range fits into our address space. Stop.\n return addr;\n }\n if (direction == -1) {\n // Try moving backwards to allocate just before the start of\n // the overlapping range.\n if (overlapping_range.start() < addr_space_start + len) {\n break;\n }\n addr = overlapping_range.start() - len;\n } else {\n // Try moving forwards to allocate just after the end of\n // the overlapping range.\n if (overlapping_range.end() + len > addr_space_end) {\n break;\n }\n addr = overlapping_range.end();\n }\n }\n\n direction = -direction;\n }\n\n return nullptr;\n}\n\nremote_ptr AddressSpace::find_free_memory(Task* t,\n size_t required_space,\n remote_ptr after,\n FindFreeMemoryPolicy policy) {\n if (after < last_free_memory &&\n policy == FindFreeMemoryPolicy::USE_LAST_FREE_HINT) {\n // Search for free memory starting at the last place we finished\n // our search. This is more efficient than starting at the beginning\n // every time.\n after = last_free_memory;\n }\n remote_ptr addr_space_end = usable_address_space_end(t->arch());\n ASSERT(t, required_space < UINT64_MAX - addr_space_end.as_int());\n\n bool started_from_beginning = after.is_null();\n while (true) {\n auto maps = maps_starting_at(after);\n auto current = maps.begin();\n while (current != maps.end()) {\n auto next = current;\n ++next;\n remote_ptr end_of_free_space;\n if (next == maps.end()) {\n end_of_free_space = addr_space_end;\n } else {\n end_of_free_space = min(addr_space_end, next->map.start());\n }\n if (current->map.end() + required_space <= end_of_free_space) {\n return current->map.end();\n }\n current = next;\n }\n if (started_from_beginning) {\n return nullptr;\n }\n started_from_beginning = true;\n after = addr_space_start;\n }\n}\n\nvoid AddressSpace::add_stap_semaphore_range(Task* task, MemoryRange range) {\n ASSERT(task, range.start() != range.end())\n << \"Unexpected zero-length SystemTap semaphore range: \" << range;\n ASSERT(task, (range.size() & 1) == 0)\n << \"Invalid SystemTap semaphore range at \"\n << range\n << \": size is not a multiple of the size of a STap semaphore!\";\n\n auto ptr = range.start().cast(),\n end = range.end().cast();\n for (; ptr < end; ++ptr) {\n stap_semaphores.insert(ptr);\n }\n}\n\nvoid AddressSpace::remove_stap_semaphore_range(Task* task, MemoryRange range) {\n ASSERT(task, range.start() != range.end())\n << \"Unexpected zero-length SystemTap semaphore range: \" << range;\n ASSERT(task, (range.size() & 1) == 0)\n << \"Invalid SystemTap semaphore range at \"\n << range\n << \": size is not a multiple of the size of a STap semaphore!\";\n\n auto ptr = range.start().cast(),\n end = range.end().cast();\n for (; ptr < end; ++ptr) {\n stap_semaphores.erase(ptr);\n }\n}\n\nbool AddressSpace::is_stap_semaphore(remote_ptr addr) {\n return stap_semaphores.find(addr) != stap_semaphores.end();\n}\n\nvoid AddressSpace::fd_tables_changed() {\n if (!session()->is_recording()) {\n // All modifications are recorded during record\n return;\n }\n if (!syscallbuf_enabled()) {\n return;\n }\n DEBUG_ASSERT(task_set().size() != 0);\n uint8_t fdt_uniform = true;\n RecordTask* rt = static_cast(first_running_task());\n if (!rt) {\n return;\n }\n auto fdt = rt->fd_table();\n for (auto* t : task_set()) {\n if (t->fd_table() != fdt) {\n fdt_uniform = false;\n }\n }\n auto addr = REMOTE_PTR_FIELD(rt->preload_globals, fdt_uniform);\n bool ok = true;\n if (rt->read_mem(addr, &ok) != fdt_uniform) {\n if (!ok) {\n return;\n }\n rt->write_mem(addr, fdt_uniform);\n rt->record_local(addr, sizeof(fdt_uniform), &fdt_uniform);\n }\n}\n\nbool AddressSpace::range_is_private_mapping(const MemoryRange& range) const {\n MemoryRange r = range;\n while (r.size() > 0) {\n if (!has_mapping(r.start())) {\n return false;\n }\n const AddressSpace::Mapping& m = mapping_of(r.start());\n if (!(m.map.flags() & MAP_PRIVATE)) {\n return false;\n }\n if (m.map.end() >= r.end()) {\n return true;\n }\n r = MemoryRange(m.map.end(), r.end());\n }\n return true;\n}\n\n} // namespace rr\n" }, { "path": "src/AddressSpace.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_ADDRESS_SPACE_H_\n#define RR_ADDRESS_SPACE_H_\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"preload/preload_interface.h\"\n\n#include \"EmuFs.h\"\n#include \"HasTaskSet.h\"\n#include \"MemoryRange.h\"\n#include \"Monkeypatcher.h\"\n#include \"TaskishUid.h\"\n#include \"TraceStream.h\"\n#include \"core.h\"\n#include \"kernel_abi.h\"\n#include \"log.h\"\n#include \"remote_code_ptr.h\"\n#include \"util.h\"\n\nnamespace rr {\n\nclass AutoRemoteSyscalls;\nclass MonitoredSharedMemory;\nclass RecordSession;\nclass RecordTask;\nclass Session;\nclass Task;\n\n/**\n * Records information that the kernel knows about a mapping. This includes\n * everything returned through /proc//maps but also information that\n * we know from observing mmap and mprotect calls.\n */\nclass KernelMapping : public MemoryRange {\npublic:\n /**\n * These are the flags we track internally to distinguish\n * between adjacent segments. For example, the kernel\n * considers a NORESERVE anonymous mapping that's adjacent to\n * a non-NORESERVE mapping distinct, even if all other\n * metadata are the same. See |is_adjacent_mapping()|.\n */\n static const int map_flags_mask = MAP_ANONYMOUS | MAP_NORESERVE |\n MAP_PRIVATE | MAP_SHARED | MAP_STACK |\n MAP_GROWSDOWN;\n static const int checkable_flags_mask = MAP_PRIVATE | MAP_SHARED;\n static const int checkable_prot_mask = PROT_READ | PROT_WRITE | PROT_EXEC;\n static const dev_t NO_DEVICE = 0;\n static const ino_t NO_INODE = 0;\n\n KernelMapping() : device_(0), inode_(0), prot_(0), flags_(0), offset(0) {}\n KernelMapping(remote_ptr start, remote_ptr end,\n const std::string& fsname, dev_t device, ino_t inode, int prot,\n int flags, off_t offset = 0)\n : MemoryRange(start, end),\n fsname_(fsname),\n device_(device),\n inode_(inode),\n prot_(prot),\n flags_(flags & map_flags_mask),\n offset(offset) {\n assert_valid();\n }\n\n KernelMapping(const KernelMapping& o)\n : MemoryRange(o),\n fsname_(o.fsname_),\n device_(o.device_),\n inode_(o.inode_),\n prot_(o.prot_),\n flags_(o.flags_),\n offset(o.offset) {\n assert_valid();\n }\n KernelMapping operator=(const KernelMapping& o) {\n this->~KernelMapping();\n new (this) KernelMapping(o);\n return *this;\n }\n\n void assert_valid() const {\n DEBUG_ASSERT(end() >= start());\n DEBUG_ASSERT(size() % page_size() == 0);\n DEBUG_ASSERT(!(flags_ & ~map_flags_mask));\n DEBUG_ASSERT(offset % page_size() == 0);\n }\n\n KernelMapping extend(remote_ptr end) const {\n DEBUG_ASSERT(end >= MemoryRange::end());\n return KernelMapping(start(), end, fsname_, device_, inode_, prot_, flags_,\n offset);\n }\n KernelMapping set_range(remote_ptr start, remote_ptr end) const {\n return KernelMapping(start, end, fsname_, device_, inode_, prot_, flags_,\n offset);\n }\n KernelMapping subrange(remote_ptr start, remote_ptr end) const {\n DEBUG_ASSERT(start >= MemoryRange::start() && end <= MemoryRange::end());\n return KernelMapping(\n start, end, fsname_, device_, inode_, prot_, flags_,\n offset + (is_real_device() ? start - MemoryRange::start() : 0));\n }\n KernelMapping set_prot(int prot) const {\n return KernelMapping(start(), end(), fsname_, device_, inode_, prot, flags_,\n offset);\n }\n KernelMapping set_fsname(const std::string& name) const {\n return KernelMapping(start(), end(), name, device_, inode_, prot_, flags_,\n offset);\n }\n\n /**\n * Dump a representation of |this| to a string in a format\n * similar to the former part of /proc/[tid]/maps.\n */\n std::string str() const {\n char str[200];\n sprintf(str, \"%8p-%8p %c%c%c%c %08\" PRIx64 \" %02x:%02x %-10ld \",\n (void*)start().as_int(), (void*)end().as_int(),\n (PROT_READ & prot_) ? 'r' : '-', (PROT_WRITE & prot_) ? 'w' : '-',\n (PROT_EXEC & prot_) ? 'x' : '-', (MAP_SHARED & flags_) ? 's' : 'p',\n offset, (int)MAJOR(device()), (int)MINOR(device()), (long)inode());\n return str + fsname();\n }\n\n const std::string& fsname() const { return fsname_; }\n std::string fsname_strip_deleted() const;\n dev_t device() const { return device_; }\n ino_t inode() const { return inode_; }\n int prot() const { return prot_; }\n int flags() const { return flags_; }\n uint64_t file_offset_bytes() const { return offset; }\n\n /**\n * Return true if this file is/was backed by an external\n * device, as opposed to a transient RAM mapping.\n */\n bool is_real_device() const { return device() > NO_DEVICE; }\n bool is_vdso() const { return fsname() == \"[vdso]\"; }\n bool is_heap() const { return fsname() == \"[heap]\"; }\n bool is_stack() const { return fsname().find(\"[stack\") == 0; }\n bool is_vvar() const { return fsname() == \"[vvar]\"; }\n bool is_vvar_vclock() const { return fsname() == \"[vvar_vclock]\"; }\n bool is_vsyscall() const { return fsname() == \"[vsyscall]\"; }\n bool is_named_anonymous() const {\n return fsname().find(\"[anon:\") == 0 || fsname().find(\"[anon_shmem:\") == 0;\n }\n\n struct stat fake_stat() const {\n struct stat fake_stat;\n memset(&fake_stat, 0, sizeof(fake_stat));\n fake_stat.st_dev = device();\n fake_stat.st_ino = inode();\n fake_stat.st_size = size();\n return fake_stat;\n }\n\nprivate:\n // The kernel's name for the mapping, as per /proc//maps. This must\n // be exactly correct.\n const std::string fsname_;\n // Note that btrfs has weird behavior and /proc/.../maps can show a different\n // device number to the device from stat()ing the file that was mapped.\n // https://www.mail-archive.com/linux-btrfs@vger.kernel.org/msg57667.html\n // We store here the device number obtained from fstat()ing the file.\n // This also seems to be consistent with what we read from populate_address_space\n // for the initial post-exec mappings. It is NOT consistent with what we get\n // from reading /proc/.../maps for non-initial mappings.\n dev_t device_;\n ino_t inode_;\n const int prot_;\n const int flags_;\n const uint64_t offset;\n};\ninline std::ostream& operator<<(std::ostream& o, const KernelMapping& m) {\n o << m.str();\n return o;\n}\n\n/**\n * Compare |a| and |b| so that \"subset\" lookups will succeed. What\n * does that mean? If |a| and |b| overlap (intersect), then this\n * comparator considers them equivalent. That means that if |a|\n * represents one byte within a mapping |b|, then |a| and |b| will be\n * considered equivalent.\n *\n * If |a| and |b| don't overlap, return true if |a|'s start address is\n * less than |b|'s/\n */\nstruct MappingComparator {\n bool operator()(const MemoryRange& a, const MemoryRange& b) const {\n return !a.intersects(b) && a.start() < b.start();\n }\n};\n\nenum BreakpointType {\n BKPT_NONE = 0,\n // Trap for internal rr purposes, f.e. replaying async\n // signals.\n BKPT_INTERNAL,\n // Trap on behalf of a debugger user.\n BKPT_USER,\n};\n\nenum WatchType {\n // NB: these random-looking enumeration values are chosen to\n // match the numbers programmed into x86 debug registers.\n WATCH_EXEC = 0x00,\n WATCH_WRITE = 0x01,\n WATCH_READWRITE = 0x03\n};\n\nenum ArmWatchType {\n ARM_WATCH_EXEC = 0x0,\n ARM_WATCH_READ = 0x1,\n ARM_WATCH_WRITE = 0x2,\n ARM_WATCH_READWRITE = ARM_WATCH_READ | ARM_WATCH_WRITE\n};\n\nenum ArmPrivLevel {\n ARM_PRIV_EL0 = 0x2\n};\n\nenum DebugStatus {\n DS_WATCHPOINT_ANY = 0xf,\n DS_SINGLESTEP = 1 << 14,\n};\n\n/**\n * A distinct watchpoint, corresponding to the information needed to\n * program a single hardware watchpoint.\n */\nstruct WatchConfig {\n WatchConfig(remote_ptr addr, size_t num_bytes, WatchType type)\n : addr(addr), num_bytes(num_bytes), type(type) {}\n remote_ptr addr;\n size_t num_bytes;\n WatchType type;\n\n bool operator==(const WatchConfig& other) const {\n return addr == other.addr && num_bytes == other.num_bytes &&\n type == other.type;\n }\n bool operator!=(const WatchConfig& other) const {\n return !(*this == other);\n }\n};\n\n/**\n * Models the address space for a set of tasks. This includes the set\n * of mapped pages, and the resources those mappings refer to.\n */\nclass AddressSpace : public HasTaskSet {\n friend class Session;\n friend struct VerifyAddressSpace;\n\npublic:\n class Mapping {\n public:\n Mapping(const KernelMapping& map, const KernelMapping& recorded_map,\n EmuFile::shr_ptr emu_file = nullptr,\n std::unique_ptr mapped_file_stat = nullptr,\n void* local_addr = nullptr,\n std::shared_ptr&& monitored = nullptr);\n ~Mapping();\n Mapping(const Mapping&);\n Mapping() : local_addr(nullptr), flags(0) {}\n const Mapping& operator=(const Mapping& other) {\n this->~Mapping();\n new (this) Mapping(other);\n return *this;\n }\n Mapping subrange(MemoryRange range,\n std::function f) const;\n\n const KernelMapping map;\n // The corresponding KernelMapping in the recording. During recording,\n // equal to 'map'.\n const KernelMapping recorded_map;\n const EmuFile::shr_ptr emu_file;\n std::unique_ptr mapped_file_stat;\n // If this mapping has been mapped into the local address space,\n // this is the address of the first byte of the equivalent local mapping.\n // This mapping is always mapped as PROT_READ|PROT_WRITE regardless of the\n // mapping's permissions in the tracee. Also note that it is the caller's\n // responsibility to keep this alive at least as long as this mapping is\n // present in the address space.\n uint8_t* local_addr;\n const std::shared_ptr monitored_shared_memory;\n // Flags indicate mappings that require special handling. Adjacent mappings\n // may only be merged if their `flags` value agree.\n enum : uint32_t {\n FLAG_NONE = 0x0,\n // This mapping represents a syscallbuf. It needs to handled specially\n // during checksumming since its contents are not fully restored by the\n // replay.\n IS_SYSCALLBUF = 0x1,\n // This mapping is used as our thread-local variable area for this\n // address space\n IS_THREAD_LOCALS = 0x2,\n // This mapping is used for syscallbuf patch stubs\n IS_PATCH_STUBS = 0x4,\n // This mapping is the rr page\n IS_RR_PAGE = 0x8,\n // This mapping is the rr vdso page\n IS_RR_VDSO_PAGE = 0x10,\n };\n uint32_t flags;\n };\n\n typedef std::map MemoryMap;\n typedef std::shared_ptr shr_ptr;\n\n virtual ~AddressSpace();\n\n /**\n * Call this after a successful execve syscall has completed. At this point\n * it is safe to perform remote syscalls.\n */\n void post_exec_syscall(Task* t);\n\n /**\n * Change the program data break of this address space to\n * |addr|. Only called during recording!\n */\n void brk(Task* t, remote_ptr addr, int prot);\n\n /**\n * This can only be called during recording.\n */\n remote_ptr current_brk() const {\n DEBUG_ASSERT(!brk_end.is_null());\n return brk_end;\n }\n\n /**\n * Dump a representation of |this| to stderr in a format\n * similar to /proc/[tid]/maps.\n *\n * XXX/ostream-ify me.\n */\n void dump() const;\n\n /**\n * Return tid of the first task for this address space.\n */\n pid_t leader_tid() const { return leader_tid_; }\n\n /**\n * Return AddressSpaceUid for this address space.\n */\n AddressSpaceUid uid() const {\n return AddressSpaceUid(leader_tid_, leader_serial, exec_count);\n }\n\n Session* session() const { return session_; }\n\n SupportedArch arch() const;\n\n /**\n * Return the path this address space was exec()'d with.\n */\n const std::string& exe_image() const { return exe; }\n\n const std::string& interp_name() const { return interp_name_; }\n void set_interp_name(std::string name) { interp_name_ = name; }\n\n remote_ptr interp_base() const { return interp_base_; }\n void set_interp_base(remote_ptr base) { interp_base_ = base; }\n\n // Set anonymous region name as per PR_SET_VMA_ANON_NAME.\n // Stops at the first unmapped memory page.\n void set_anon_name(Task* t, MemoryRange range, const std::string* name);\n\n /**\n * Assuming the last retired instruction has raised a SIGTRAP\n * and might be a breakpoint trap instruction, return the type\n * of breakpoint set at |ip() - sizeof(breakpoint_insn)|, if\n * one exists. Otherwise return TRAP_NONE.\n */\n BreakpointType get_breakpoint_type_for_retired_insn(remote_code_ptr ip);\n\n /**\n * Return the type of breakpoint that's been registered for\n * |addr|.\n */\n BreakpointType get_breakpoint_type_at_addr(remote_code_ptr addr);\n\n /**\n * Check if the user has placed a hardware EXEC watchpoint at addr.\n */\n bool is_exec_watchpoint(remote_code_ptr addr);\n\n /**\n * Returns true when the breakpoint at |addr| is in private\n * non-writeable memory. When this returns true, the breakpoint can't be\n * overwritten by the tracee without an intervening mprotect or mmap\n * syscall.\n */\n bool is_breakpoint_in_private_read_only_memory(remote_code_ptr addr);\n\n /**\n * Return true if there's a breakpoint instruction at |ip|. This might\n * be an explicit instruction, even if there's no breakpoint set via our API.\n */\n bool is_breakpoint_instruction(Task* t, remote_code_ptr ip);\n\n /**\n * The buffer |dest| of length |length| represents the contents of tracee\n * memory at |addr|. Replace the bytes in |dest| that have been overwritten\n * by breakpoints with the original data that was replaced by the breakpoints.\n */\n void replace_breakpoints_with_original_values(uint8_t* dest, size_t length,\n remote_ptr addr);\n\n /**\n * Map |num_bytes| into this address space at |addr|, with\n * |prot| protection and |flags|. The pages are (possibly\n * initially) backed starting at |offset| of |res|. |fsname|, |device| and\n * |inode| are values that will appear in the /proc//maps entry.\n * |mapped_file_stat| is a complete copy of the 'stat' data for the mapped\n * file, or null if this isn't a file mapping or isn't during recording.\n * |*recorded_map| is the mapping during recording, or null if the mapping\n * during recording is known to be the same as the new map (e.g. because\n * we are recording!).\n * |local_addr| is the local address of the memory shared with the tracee,\n * or null if it's not shared with the tracee. AddressSpace takes ownership\n * of the shared memory and is responsible for unmapping it.\n */\n KernelMapping map(\n Task* t, remote_ptr addr, size_t num_bytes, int prot, int flags,\n off_t offset_bytes, const std::string& fsname,\n dev_t device = KernelMapping::NO_DEVICE,\n ino_t inode = KernelMapping::NO_INODE,\n std::unique_ptr mapped_file_stat = nullptr,\n const KernelMapping* recorded_map = nullptr,\n EmuFile::shr_ptr emu_file = nullptr, void* local_addr = nullptr,\n std::shared_ptr monitored = nullptr);\n\n /**\n * Return the mapping and mapped resource for the byte at address 'addr'.\n * There must be such a mapping.\n */\n const Mapping& mapping_of(remote_ptr addr) const;\n\n /**\n * Detach local mapping and return it.\n */\n void* detach_local_mapping(remote_ptr addr);\n\n /**\n * Return a reference to the flags of the mapping at this address, allowing\n * manipulation. There must exist a mapping at `addr`.\n */\n uint32_t& mapping_flags_of(remote_ptr addr);\n\n /**\n * Return true if there is some mapping for the byte at 'addr'.\n */\n bool has_mapping(remote_ptr addr) const;\n\n /**\n * If the given memory region is mapped into the local address space, obtain\n * the local address from which the `size` bytes at `addr` can be accessed.\n */\n uint8_t* local_mapping(remote_ptr addr, size_t size);\n\n /**\n * Return true if the rr page is mapped at its expected address.\n */\n bool has_rr_page() const;\n\n /**\n * Object that generates robust iterators through the memory map. The\n * memory map can be updated without invalidating iterators, as long as\n * Mappings are not added or removed.\n */\n class Maps {\n public:\n Maps(const AddressSpace& outer, remote_ptr start)\n : outer(outer), start(start) {}\n class iterator {\n public:\n iterator(const iterator& it) = default;\n const iterator& operator++() {\n ptr = to_it()->second.map.end();\n return *this;\n }\n bool operator==(const iterator& other) const {\n return to_it() == other.to_it();\n }\n bool operator!=(const iterator& other) const { return !(*this == other); }\n const Mapping* operator->() const { return &to_it()->second; }\n const Mapping& operator*() const { return to_it()->second; }\n iterator& operator=(const iterator& other) {\n this->~iterator();\n new (this) iterator(other);\n return *this;\n }\n\n private:\n friend class Maps;\n iterator(const MemoryMap& outer, remote_ptr ptr)\n : outer(outer), ptr(ptr), at_end(false) {}\n iterator(const MemoryMap& outer) : outer(outer), at_end(true) {}\n MemoryMap::const_iterator to_it() const {\n return at_end ? outer.end() : outer.lower_bound(MemoryRange(ptr, ptr));\n }\n const MemoryMap& outer;\n remote_ptr ptr;\n bool at_end;\n };\n iterator begin() const { return iterator(outer.mem, start); }\n iterator end() const { return iterator(outer.mem); }\n\n private:\n const AddressSpace& outer;\n remote_ptr start;\n };\n friend class Maps;\n Maps maps() const { return Maps(*this, remote_ptr()); }\n Maps maps_starting_at(remote_ptr start) { return Maps(*this, start); }\n Maps maps_containing_or_after(remote_ptr start) {\n if (has_mapping(start)) {\n return Maps(*this, mapping_of(start).map.start());\n } else {\n return Maps(*this, start);\n }\n }\n\n const std::set>& monitored_addrs() const {\n return monitored_mem;\n }\n\n /**\n * Change the protection bits of [addr, addr + num_bytes) to\n * |prot|.\n */\n void protect(Task* t, remote_ptr addr, size_t num_bytes, int prot);\n\n /**\n * Fix up mprotect registers parameters to take account of PROT_GROWSDOWN.\n */\n void fixup_mprotect_growsdown_parameters(Task* t);\n\n /**\n * Move the mapping [old_addr, old_addr + old_num_bytes) to\n * [new_addr, old_addr + new_num_bytes), preserving metadata.\n */\n void remap(Task* t, remote_ptr old_addr, size_t old_num_bytes,\n remote_ptr new_addr, size_t new_num_bytes, int flags);\n\n /**\n * Notify that data was written to this address space by rr or\n * by the kernel.\n * |flags| can contain values from Task::WriteFlags.\n */\n void notify_written(remote_ptr addr, size_t num_bytes, uint32_t flags);\n\n /** Ensure a breakpoint of |type| is set at |addr|. */\n bool add_breakpoint(remote_code_ptr addr, BreakpointType type);\n /**\n * Remove a |type| reference to the breakpoint at |addr|. If\n * the removed reference was the last, the breakpoint is\n * destroyed.\n */\n void remove_breakpoint(remote_code_ptr addr, BreakpointType type);\n /**\n * Destroy all breakpoints in this VM, regardless of their\n * reference counts.\n */\n void remove_all_breakpoints();\n\n /**\n * Temporarily remove the breakpoint at |addr|.\n */\n void suspend_breakpoint_at(remote_code_ptr addr);\n /**\n * Restore any temporarily removed breakpoint at |addr|.\n */\n void restore_breakpoint_at(remote_code_ptr addr);\n\n /**\n * Manage watchpoints. Analogous to breakpoint-managing\n * methods above, except that watchpoints can be set for an\n * address range.\n */\n bool add_watchpoint(remote_ptr addr, size_t num_bytes, WatchType type);\n void remove_watchpoint(remote_ptr addr, size_t num_bytes,\n WatchType type);\n void remove_all_watchpoints();\n std::vector all_watchpoints() {\n return get_watchpoints_internal(ALL_WATCHPOINTS, UNALIGNED,\n DONT_UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS);\n }\n\n /**\n * Save all watchpoint state onto a stack.\n */\n void save_watchpoints();\n /**\n * Pop all watchpoint state from the saved-state stack.\n */\n bool restore_watchpoints();\n\n /**\n * Notify that at least one watchpoint was hit --- recheck them all.\n * Returns true if any watchpoint actually triggered. Note that\n * debug_status can indicate a hit watchpoint that doesn't actually\n * trigger, because the value of a write-watchpoint did not change.\n * Likewise, debug_status can indicate a watchpoint wasn't hit that\n * actually was (because in some configurations, e.g. VMWare\n * hypervisor with 32-bit x86 guest, debug_status watchpoint bits\n * are known to not be set on singlestep).\n */\n bool notify_watchpoint_fired(uintptr_t debug_status,\n remote_ptr hit_addr,\n remote_code_ptr address_of_singlestep_start);\n /**\n * Return true if any watchpoint has fired. Will keep returning true until\n * consume_watchpoint_changes() is called.\n */\n bool has_any_watchpoint_changes();\n /**\n * Return true if an EXEC watchpoint has fired at addr since the last\n * consume_watchpoint_changes.\n */\n bool has_exec_watchpoint_fired(remote_code_ptr addr);\n\n /**\n * Return all changed watchpoints in |watches| and clear their changed flags.\n */\n std::vector consume_watchpoint_changes() {\n return get_watchpoints_internal(CHANGED_WATCHPOINTS, UNALIGNED,\n DONT_UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS);\n }\n\n /**\n * Get hardware watchpoint assignments.\n */\n std::vector get_hw_watchpoints() {\n return get_watchpoints_internal(ALL_WATCHPOINTS, ALIGNED,\n DONT_UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS);\n }\n\n void set_shm_size(remote_ptr addr, size_t bytes) {\n shm_sizes[addr] = bytes;\n }\n /**\n * Dies if no shm size is registered for the address.\n */\n size_t get_shm_size(remote_ptr addr) { return shm_sizes[addr]; }\n void remove_shm_size(remote_ptr addr) { shm_sizes.erase(addr); }\n\n /**\n * Make [addr, addr + num_bytes) inaccessible within this\n * address space.\n */\n void unmap(Task* t, remote_ptr addr, ssize_t num_bytes);\n\n /**\n * Notification of madvise call.\n */\n void advise(Task* t, remote_ptr addr, ssize_t num_bytes, int advice);\n\n /** Return the vdso mapping of this. */\n KernelMapping vdso() const;\n bool has_vdso() const { return has_mapping(vdso_start_addr); }\n\n /**\n * Verify that this cached address space matches what the\n * kernel thinks it should be.\n */\n void verify(Task* t) const;\n\n bool has_breakpoints() { return !breakpoints.empty(); }\n bool has_watchpoints() { return !watchpoints.empty(); }\n\n ScopedFd& mem_fd() { return child_mem_fd; }\n void set_mem_fd(ScopedFd&& fd) { child_mem_fd = std::move(fd); }\n\n ScopedFd& pagemap_fd() { return child_pagemap_fd; }\n void set_pagemap_fd(ScopedFd&& fd) { child_pagemap_fd = std::move(fd); }\n\n Monkeypatcher& monkeypatcher() {\n DEBUG_ASSERT(monkeypatch_state);\n return *monkeypatch_state;\n }\n\n void at_preload_init(Task* t);\n\n /* The address of the syscall instruction from which traced syscalls made by\n * the syscallbuf will originate. */\n remote_code_ptr traced_syscall_ip() const { return traced_syscall_ip_; }\n /* The address of the syscall instruction from which privileged traced\n * syscalls made by the syscallbuf will originate. */\n remote_code_ptr privileged_traced_syscall_ip() const {\n return privileged_traced_syscall_ip_;\n }\n\n bool syscallbuf_enabled() const { return syscallbuf_enabled_; }\n bool layout_randomization_disabled() const {\n return layout_randomization_disabled_;\n }\n void disable_layout_randomization(bool disable) {\n layout_randomization_disabled_ = disable;\n }\n\n /**\n * We'll map a page of memory here into every exec'ed process for our own\n * use.\n */\n static remote_ptr rr_page_start() { return RR_PAGE_ADDR; }\n static remote_ptr rr_page_end() {\n return rr_page_start() + PRELOAD_LIBRARY_PAGE_SIZE;\n }\n\n static remote_ptr preload_thread_locals_start() {\n return rr_page_start() + PRELOAD_LIBRARY_PAGE_SIZE;\n }\n static uint32_t preload_thread_locals_size() {\n return PRELOAD_THREAD_LOCALS_SIZE;\n }\n\n enum Traced { TRACED, UNTRACED };\n enum Privileged { PRIVILEGED, UNPRIVILEGED };\n /**\n * Depending on which entry point this is and whether or not we're recording\n * or replaying, the instruction in the rr page, may be something other than\n * a syscall. This enum encodes the combination of instructions for each entry\n * point:\n *\n * Enabled | Record | Replay\n * ---------------------|---------|-------\n * RECORDING_ONLY | syscall | nop\n * REPLAY_ONLY | nop | syscall\n * RECORDING_AND_REPLAY | syscall | syscall\n * REPLAY_ASSIST | syscall | int3\n *\n * The REPLAY_ASSIST is used for a syscall that is untraced during record (so\n * we can save the context switch penalty), but requires us to apply side\n * effects during replay. The int3 lets the replayer stop and apply these\n * at the appropriate point.\n */\n enum Enabled { RECORDING_ONLY, REPLAY_ONLY, RECORDING_AND_REPLAY, REPLAY_ASSIST };\n static remote_code_ptr rr_page_syscall_exit_point(Traced traced,\n Privileged privileged,\n Enabled enabled,\n SupportedArch arch);\n static remote_code_ptr rr_page_syscall_entry_point(Traced traced,\n Privileged privileged,\n Enabled enabled,\n SupportedArch arch);\n\n struct SyscallType {\n Traced traced;\n Privileged privileged;\n Enabled enabled;\n };\n static std::vector rr_page_syscalls();\n static const SyscallType* rr_page_syscall_from_exit_point(\n SupportedArch arch, remote_code_ptr ip);\n static const SyscallType* rr_page_syscall_from_entry_point(\n SupportedArch arch, remote_code_ptr ip);\n\n /**\n * Return a pointer to 8 bytes of 0xFF.\n * (Currently only set during record / not part of the ABI)\n */\n static remote_ptr rr_page_record_ff_bytes() { return RR_PAGE_FF_BYTES; }\n\n /**\n * Locate a syscall instruction in t's VDSO (the real one, not our fake one).\n * This gives us a way to execute remote syscalls without having to write\n * a syscall instruction into executable tracee memory (which might not be\n * possible with some kernels, e.g. PaX).\n */\n remote_code_ptr find_syscall_instruction_in_vdso(Task* t);\n\n /**\n * Task |t| just forked from this address space. Apply dont_fork and\n * wipe_on_fork settings.\n */\n void did_fork_into(Task* t);\n\n void set_first_run_event(FrameTime event) { first_run_event_ = event; }\n FrameTime first_run_event() { return first_run_event_; }\n\n const std::vector& saved_auxv() { return saved_auxv_; }\n void save_auxv(Task* t);\n\n remote_ptr saved_interpreter_base() { return saved_interpreter_base_; }\n void save_interpreter_base(Task* t, std::vector auxv);\n\n std::string saved_ld_path() { return saved_ld_path_;}\n void save_ld_path(Task* t, remote_ptr);\n\n void read_mm_map(Task* t, NativeArch::prctl_mm_map* map);\n\n /**\n * Reads the /proc//maps entry for a specific address. Does no caching.\n * If performed on a file in a btrfs file system, this may return the\n * wrong device number! If you stick to anonymous or special file\n * mappings, this should be OK.\n */\n KernelMapping read_kernel_mapping(Task* t, remote_ptr addr);\n\n /**\n * Same as read_kernel_mapping, but reads rr's own memory map.\n */\n static KernelMapping read_local_kernel_mapping(uint8_t* addr);\n\n static uint32_t chaos_mode_min_stack_size() { return 8 * 1024 * 1024; }\n\n /* Returns null if we should return ENOMEM because there is no free space available. */\n remote_ptr chaos_mode_find_free_memory(RecordTask* t, size_t len, remote_ptr hint);\n enum class FindFreeMemoryPolicy {\n /* Use the first free memory after `after` */\n STRICT_SEARCH,\n /* Optimize for speed by starting the search from the address of the last\n area returned by find_free_memory (if greater than `after`). */\n USE_LAST_FREE_HINT,\n };\n remote_ptr find_free_memory(Task* t,\n size_t len, remote_ptr after = remote_ptr(),\n FindFreeMemoryPolicy policy = FindFreeMemoryPolicy::STRICT_SEARCH);\n\n /**\n * The return value indicates whether we (re)created the preload_thread_locals\n * area.\n */\n bool post_vm_clone(Task* t);\n /**\n * TaskUid for the task whose locals are stored in the preload_thread_locals\n * area.\n */\n const TaskUid& thread_locals_tuid() { return thread_locals_tuid_; }\n void set_thread_locals_tuid(const TaskUid& tuid) {\n thread_locals_tuid_ = tuid;\n }\n\n /**\n * Call this when the memory at [addr,addr+len) was externally overwritten.\n * This will attempt to update any breakpoints that may be set within the\n * range (resetting them and storing the new value).\n */\n void maybe_update_breakpoints(Task* t, remote_ptr addr, size_t len);\n\n /**\n * Call this to ensure that the mappings in `range` during replay has the same length\n * is collapsed to a single mapping. The caller guarantees that all the\n * mappings in the range can be coalesced (because they corresponded to a single\n * mapping during recording).\n * The end of the range might be in the middle of a mapping.\n * The start of the range might also be in the middle of a mapping.\n */\n void ensure_replay_matches_single_recorded_mapping(Task* t, MemoryRange range);\n\n /**\n * Print process maps.\n */\n static void print_process_maps(Task* t);\n\n void add_stap_semaphore_range(Task* t, MemoryRange range);\n void remove_stap_semaphore_range(Task* t, MemoryRange range);\n bool is_stap_semaphore(remote_ptr addr);\n\n bool legacy_breakpoint_mode() { return stopping_breakpoint_table_ != nullptr; }\n remote_code_ptr do_breakpoint_fault_addr() { return do_breakpoint_fault_addr_; }\n remote_code_ptr stopping_breakpoint_table() { return stopping_breakpoint_table_; }\n int stopping_breakpoint_table_entry_size() { return stopping_breakpoint_table_entry_size_; }\n\n // Also sets brk_ptr.\n enum {\n RRVDSO_PAGE_OFFSET = 2,\n RRPAGE_RECORD_PAGE_OFFSET = 3,\n RRPAGE_REPLAY_PAGE_OFFSET = 4\n };\n\n void map_rr_page(AutoRemoteSyscalls& remote);\n static std::vector read_rr_page_for_recording(SupportedArch arch);\n struct UnmapOptions {\n bool exclude_vdso_vvar;\n UnmapOptions() : exclude_vdso_vvar(false) {}\n };\n void unmap_all_but_rr_mappings(AutoRemoteSyscalls& remote,\n UnmapOptions options = UnmapOptions());\n\n void erase_task(Task* t) {\n this->HasTaskSet::erase_task(t);\n if (task_set().size() != 0) {\n fd_tables_changed();\n }\n }\n\n /**\n * Called when the set of different fd tables associated with tasks\n * in this address space may have changed (e.g. a task changed its fd table,\n * or a task got added or removed, etc).\n */\n void fd_tables_changed();\n\n static MemoryRange get_global_exclusion_range(const RecordSession* session);\n\n // Whether to return WatchConfigs consisting of only aligned locations\n // suitable for hardware watchpoint registers.\n enum WatchpointAlignment { UNALIGNED, ALIGNED };\n\n // Returns true if the range is completely covered by private mappings\n bool range_is_private_mapping(const MemoryRange& range) const;\n\n /**\n * When two processes share an address space (e.g. with vfork(2) or\n * clone(2) CLONE_VM), and one process calls execve(2), we need to unmap\n * that process's syscallbuf. This list is checked the next time a task\n * in that address space runs to perform the unmapping\n */\n std::vector regions_pending_unmap;\n\nprivate:\n struct Breakpoint;\n typedef std::map BreakpointMap;\n class Watchpoint;\n\n /**\n * Called after a successful execve to set up the new AddressSpace.\n * Also called once for the initial spawn.\n */\n AddressSpace(Task* t, const std::string& exe, uint32_t exec_count);\n /**\n * Called when an AddressSpace is cloned due to a fork() or a Session\n * clone. After this, and the task is properly set up, post_vm_clone will\n * be called.\n */\n AddressSpace(Session* session, const AddressSpace& o, pid_t leader_tid,\n uint32_t leader_serial, uint32_t exec_count);\n\n /**\n * After an exec, populate the new address space of |t| with\n * the existing mappings we find in /proc/maps.\n */\n void populate_address_space(Task* t);\n\n void unmap_internal(Task* t, remote_ptr addr, ssize_t num_bytes);\n void update_syscall_ips(Task* t);\n\n bool update_watchpoint_value(const MemoryRange& range,\n Watchpoint& watchpoint);\n void update_watchpoint_values(remote_ptr start, remote_ptr end);\n // Whether to handle all watchpoints or just data watchpoints whose data\n // has changed. In the latter case we clear their changed status.\n enum WatchpointFilter { ALL_WATCHPOINTS, CHANGED_WATCHPOINTS };\n // Whether to update the watchpoint's assigned register list. Use\n // UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS when we'll use the watchpoints\n // to configure HW watchpoint registers.\n enum UpdateWatchpointRegisterAssignments { UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS,\n DONT_UPDATE_WATCHPOINT_REGISTER_ASSIGNMENTS };\n std::vector get_watchpoints_internal(WatchpointFilter filter,\n WatchpointAlignment alignment,\n UpdateWatchpointRegisterAssignments update_watchpoint_register_assignments);\n\n /**\n * Construct a minimal set of watchpoints to be enabled based\n * on |set_watchpoint()| calls, and program them for each task\n * in this address space.\n */\n bool allocate_watchpoints();\n\n /**\n * Merge the mappings adjacent to |it| in memory that are\n * semantically \"adjacent mappings\" of the same resource as\n * well, for example have adjacent file offsets and the same\n * prot and flags.\n */\n void coalesce_around(Task* t, MemoryMap::iterator it);\n\n /**\n * Erase |it| from |breakpoints| and restore any memory in\n * this it may have overwritten.\n */\n void destroy_breakpoint(BreakpointMap::const_iterator it);\n\n /**\n * For each mapped segment overlapping [addr, addr +\n * num_bytes), call |f|. Pass |f| the overlapping mapping,\n * the mapped resource, and the range of addresses remaining\n * to be iterated over.\n *\n * Pass |ITERATE_CONTIGUOUS| to stop iterating when the last\n * contiguous mapping after |addr| within the region is seen.\n * Default is to iterate all mappings in the region.\n *\n * The callback takes parameters by value to avoid dangling\n * references if the memory map is modified inside the callback.\n */\n enum { ITERATE_DEFAULT, ITERATE_CONTIGUOUS };\n void for_each_in_range(\n remote_ptr addr, ssize_t num_bytes,\n std::function f,\n int how = ITERATE_DEFAULT);\n\n /**\n * Map |m| of |r| into this address space, and coalesce any\n * mappings of |r| that are adjacent to |m|.\n */\n void map_and_coalesce(Task* t, const KernelMapping& m,\n const KernelMapping& recorded_map,\n EmuFile::shr_ptr emu_file,\n std::unique_ptr mapped_file_stat,\n void* local_addr,\n std::shared_ptr monitored);\n\n void remove_from_map(const MemoryRange& range) {\n mem.erase(range);\n monitored_mem.erase(range.start());\n }\n void add_to_map(const Mapping& m) {\n mem[m.map] = m;\n if (m.monitored_shared_memory) {\n monitored_mem.insert(m.map.start());\n }\n }\n\n /**\n * Call this only during recording.\n */\n template void at_preload_init_arch(Task* t);\n\n enum { EXEC_BIT = 1 << 0, READ_BIT = 1 << 1, WRITE_BIT = 1 << 2 };\n\n /** Return the access bits above needed to watch |type|. */\n static int access_bits_of(WatchType type);\n\n /**\n * Represents a refcount set on a particular address. Because there\n * can be multiple refcounts of multiple types set on a single\n * address, Breakpoint stores explicit USER and INTERNAL breakpoint\n * refcounts. Clients adding/removing breakpoints at this addr must\n * call ref()/unref() as appropriate.\n */\n struct Breakpoint {\n Breakpoint() : internal_count(0), user_count(0) {}\n Breakpoint(const Breakpoint& o) = default;\n // AddressSpace::destroy_all_breakpoints() can cause this\n // destructor to be invoked while we have nonzero total\n // refcount, so the most we can DEBUG_ASSERT is that the refcounts\n // are valid.\n ~Breakpoint() { DEBUG_ASSERT(internal_count >= 0 && user_count >= 0); }\n\n void ref(BreakpointType which) {\n DEBUG_ASSERT(internal_count >= 0 && user_count >= 0);\n ++*counter(which);\n }\n int unref(BreakpointType which) {\n DEBUG_ASSERT(internal_count > 0 || user_count > 0);\n --*counter(which);\n DEBUG_ASSERT(internal_count >= 0 && user_count >= 0);\n return internal_count + user_count;\n }\n\n BreakpointType type() const {\n // NB: USER breakpoints need to be processed before\n // INTERNAL ones. We want to give the debugger a\n // chance to dispatch commands before we attend to the\n // internal rr business. So if there's a USER \"ref\"\n // on the breakpoint, treat it as a USER breakpoint.\n return user_count > 0 ? BKPT_USER : BKPT_INTERNAL;\n }\n\n uint8_t* original_data() { return overwritten_data; }\n\n // \"Refcounts\" of breakpoints set at |addr|. The breakpoint\n // object must be unique since we have to save the overwritten\n // data, and we can't enforce the order in which breakpoints\n // are set/removed.\n int internal_count, user_count;\n uint8_t overwritten_data[MAX_BKPT_INSTRUCTION_LENGTH];\n\n int* counter(BreakpointType which) {\n DEBUG_ASSERT(BKPT_INTERNAL == which || BKPT_USER == which);\n int* p = BKPT_USER == which ? &user_count : &internal_count;\n DEBUG_ASSERT(*p >= 0);\n return p;\n }\n };\n\n // XXX one is tempted to merge Breakpoint and Watchpoint into a single\n // entity, but the semantics are just different enough that separate\n // objects are easier for now.\n /**\n * Track the watched accesses of a contiguous range of memory\n * addresses.\n */\n class Watchpoint {\n public:\n Watchpoint(size_t num_bytes)\n : exec_count(0),\n read_count(0),\n write_count(0),\n value_bytes(num_bytes),\n valid(false),\n changed(false) {}\n Watchpoint(const Watchpoint&) = default;\n ~Watchpoint() { assert_valid(); }\n\n void watch(int which) {\n assert_valid();\n exec_count += (EXEC_BIT & which) != 0;\n read_count += (READ_BIT & which) != 0;\n write_count += (WRITE_BIT & which) != 0;\n }\n int unwatch(int which) {\n assert_valid();\n if (EXEC_BIT & which) {\n DEBUG_ASSERT(exec_count > 0);\n --exec_count;\n }\n if (READ_BIT & which) {\n DEBUG_ASSERT(read_count > 0);\n --read_count;\n }\n if (WRITE_BIT & which) {\n DEBUG_ASSERT(write_count > 0);\n --write_count;\n }\n return exec_count + read_count + write_count;\n }\n\n int watched_bits() const {\n return (exec_count > 0 ? EXEC_BIT : 0) | (read_count > 0 ? READ_BIT : 0) |\n (write_count > 0 ? WRITE_BIT : 0);\n }\n\n void assert_valid() const {\n DEBUG_ASSERT(exec_count >= 0 && read_count >= 0 && write_count >= 0);\n }\n\n // Watchpoints stay alive until all watched access typed have\n // been cleared. We track refcounts of each watchable access\n // separately.\n int exec_count, read_count, write_count;\n // Debug registers allocated for read/exec access checking.\n // Write watchpoints are always triggered by checking for actual memory\n // value changes. Read/exec watchpoints can't be triggered that way, so\n // we look for these registers being triggered instead.\n std::vector debug_regs_for_exec_read;\n std::vector value_bytes;\n bool valid;\n bool changed;\n };\n\n // All breakpoints set in this VM.\n BreakpointMap breakpoints;\n /* Path of the real executable image this address space was\n * exec()'d with. */\n std::string exe;\n /* Path of the interpreter, if any, of exe. */\n std::string interp_name_;\n /* Base address of the interpreter (might be null!) */\n remote_ptr interp_base_;\n /* Pid of first task for this address space */\n pid_t leader_tid_;\n /* Serial number of first task for this address space */\n uint32_t leader_serial;\n uint32_t exec_count;\n // Only valid during recording\n remote_ptr brk_start;\n /* Current brk. Not necessarily page-aligned. */\n remote_ptr brk_end;\n /* All segments mapped into this address space. */\n MemoryMap mem;\n /* Sizes of SYSV shm segments, by address. We use this to determine the size\n * of memory regions unmapped via shmdt(). */\n std::map, size_t> shm_sizes;\n std::set> monitored_mem;\n /* madvise DONTFORK regions */\n std::set dont_fork;\n /* madvise WIPEONFORK regions */\n std::set wipe_on_fork;\n // The session that created this. We save a ref to it so that\n // we can notify it when we die.\n Session* session_;\n // tid of the task whose thread-locals are in preload_thread_locals\n TaskUid thread_locals_tuid_;\n /* First mapped byte of the vdso. */\n remote_ptr vdso_start_addr;\n // The monkeypatcher that's handling this address space.\n std::unique_ptr monkeypatch_state;\n // The watchpoints set for tasks in this VM. Watchpoints are\n // programmed per Task, but we track them per address space on\n // behalf of debuggers that assume that model.\n std::map watchpoints;\n std::vector> saved_watchpoints;\n // Tracee memory is read and written through this fd, which is\n // opened for the tracee's magic /proc/[tid]/mem device. The\n // advantage of this over ptrace is that we can access it even\n // when the tracee isn't at a ptrace-stop. It's also\n // theoretically faster for large data transfers, which rr can\n // do often.\n //\n // Users of child_mem_fd should fall back to ptrace-based memory\n // access when child_mem_fd is not open.\n ScopedFd child_mem_fd;\n remote_code_ptr traced_syscall_ip_;\n remote_code_ptr privileged_traced_syscall_ip_;\n bool syscallbuf_enabled_;\n bool layout_randomization_disabled_;\n\n remote_code_ptr do_breakpoint_fault_addr_;\n // These fields are deprecated and have been replaced by the\n // breakpoint_value mechanism. They are retained for replayability\n // of old traces.\n remote_code_ptr stopping_breakpoint_table_;\n int stopping_breakpoint_table_entry_size_;\n\n std::vector saved_auxv_;\n remote_ptr saved_interpreter_base_;\n std::string saved_ld_path_;\n\n remote_ptr last_free_memory;\n\n /**\n * The time of the first event that ran code for a task in this address space.\n * 0 if no such event has occurred.\n */\n FrameTime first_run_event_;\n\n std::set> stap_semaphores;\n\n /**\n * For each architecture, the offset of a syscall instruction with that\n * architecture's VDSO, or 0 if not known.\n */\n static uint32_t offset_to_syscall_in_vdso[SupportedArch_MAX + 1];\n\n /**\n * Ensure that the cached mapping of |t| matches /proc/maps,\n * using adjacent-map-merging heuristics that are as lenient\n * as possible given the data available from /proc/maps.\n */\n static void check_segment_iterator(void* vasp, Task* t,\n const struct map_iterator_data* data);\n\n AddressSpace operator=(const AddressSpace&) = delete;\n\n ScopedFd child_pagemap_fd;\n};\n\n/**\n * The following helper is used to iterate over a tracee's memory\n * map.\n */\nclass KernelMapIterator {\npublic:\n KernelMapIterator(Task* t, bool* ok = nullptr);\n KernelMapIterator(pid_t tid, bool* ok = nullptr) : tid(tid) { init(ok); }\n ~KernelMapIterator();\n\n // It's very important to keep in mind that btrfs files can have the wrong\n // device number!\n const KernelMapping& current(std::string* raw_line = nullptr) {\n if (raw_line) {\n *raw_line = this->raw_line;\n }\n return km;\n }\n bool at_end() { return !maps_file; }\n void operator++();\n\nprivate:\n void init(bool* ok = nullptr);\n\n pid_t tid;\n FILE* maps_file;\n std::string raw_line;\n KernelMapping km;\n};\n\n} // namespace rr\n\n#endif /* RR_ADDRESS_SPACE_H_ */\n" }, { "path": "src/AutoRemoteSyscalls.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"AutoRemoteSyscalls.h\"\n\n#include \n#include \n#include \n#include \n\n#include \n\n#include \"rr/rr.h\"\n\n#include \"RecordSession.h\"\n#include \"RecordTask.h\"\n#include \"ReplaySession.h\"\n#include \"Session.h\"\n#include \"Task.h\"\n#include \"core.h\"\n#include \"kernel_abi.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n#include \"record_signal.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n/**\n * The ABI of the socketcall syscall is a nightmare; the first arg to\n * the kernel is the sub-operation, and the second argument is a\n * pointer to the args. The args depend on the sub-op.\n */\ntemplate struct socketcall_args {\n typename Arch::signed_long args[3];\n} __attribute__((packed));\n\nvoid AutoRestoreMem::init(const void* mem, ssize_t num_bytes) {\n ASSERT(remote.task(),\n remote.enable_mem_params() == AutoRemoteSyscalls::ENABLE_MEMORY_PARAMS)\n << \"Memory parameters were disabled\";\n\n len = num_bytes;\n saved_sp = remote.regs().sp();\n\n remote.regs().set_sp(remote.regs().sp() - len);\n remote.task()->set_regs(remote.regs());\n if (remote.task()->is_exiting()) {\n // Leave addr == nullptr\n return;\n }\n\n addr = remote.regs().sp();\n\n data.resize(len);\n bool ok = true;\n remote.task()->read_bytes_helper(addr, len, data.data(), &ok);\n if (mem) {\n remote.task()->write_bytes_helper(addr, len, mem, &ok);\n }\n if (!ok) {\n addr = nullptr;\n }\n}\n\nAutoRestoreMem::~AutoRestoreMem() {\n DEBUG_ASSERT(saved_sp == remote.regs().sp() + len);\n\n if (addr) {\n // XXX what should we do if this task was sigkilled but the address\n // space is used by other live tasks?\n remote.task()->write_bytes_helper(addr, len, data.data());\n }\n remote.regs().set_sp(remote.regs().sp() + len);\n remote.task()->set_regs(remote.regs());\n}\n\nstatic bool is_SIGTRAP_default_and_unblocked(Task* t) {\n if (!t->session().is_recording()) {\n return true;\n }\n RecordTask* rt = static_cast(t);\n return rt->sig_disposition(SIGTRAP) == SIGNAL_DEFAULT &&\n !rt->is_sig_blocked(SIGTRAP);\n}\n\nAutoRemoteSyscalls::AutoRemoteSyscalls(Task* t,\n MemParamsEnabled enable_mem_params)\n : t(t),\n initial_regs(t->regs()),\n initial_ip(t->ip()),\n initial_sp(t->regs().sp()),\n initial_at_seccomp(t->ptrace_event() == PTRACE_EVENT_SECCOMP),\n restore_wait_status(t->status()),\n new_tid_(-1),\n scratch_mem_was_mapped(false),\n use_singlestep_path(false),\n enable_mem_params_(enable_mem_params),\n restore_sigmask(false),\n need_sigpending_renable(false),\n need_desched_event_reenable(false) {\n if (initial_at_seccomp) {\n // This should only ever happen during recording - we don't use the\n // seccomp traps during replay.\n ASSERT(t, t->session().is_recording());\n }\n // We support two paths for syscalls:\n // -- a fast path using a privileged untraced syscall and PTRACE_SINGLESTEP.\n // This only requires a single task-wait.\n // -- a slower path using a privileged traced syscall and PTRACE_SYSCALL/\n // PTRACE_CONT via Task::enter_syscall(). This requires 2 or 3 task-waits\n // depending on whether the seccomp event fires before the syscall-entry\n // event.\n // Use the slow path when running under rr, because the rr recording us\n // needs to see and trace these tracee syscalls, and if they're untraced by\n // us they're also untraced by the outer rr.\n // Use the slow path if SIGTRAP is blocked or ignored because otherwise\n // the PTRACE_SINGLESTEP will cause the kernel to unblock it.\n setup_path(t->vm()->has_rr_page() && !running_under_rr() &&\n is_SIGTRAP_default_and_unblocked(t));\n if (enable_mem_params == ENABLE_MEMORY_PARAMS) {\n maybe_fix_stack_pointer();\n }\n if (t->status().is_syscall() && t->regs().syscall_may_restart()) {\n // VERY rare corner case alert: It is possible for the following sequence\n // of events to occur:\n //\n // 1. Thread A is in a blocking may-restart syscall and gets interrupted by a tg-targeted signal\n // 2. Thread B dequeues the signal\n // 3. Thread A is in the syscall-exit-stop with TIF_SIGPENDING set (with registers indicating syscall restart)\n // 4. We get here to perform an AutoRemoteSyscall\n // 5. During AutoRemoteSyscall, TIF_SIGPENDING gets cleared on return to userspace\n // 6. We finish the AutoRemoteSyscall and re-apply the registers.\n // 7. ... As a result, the kernel does not check whether it needs to perform the\n /// syscall-restart register adjustment because TIF_SIGPENDING is not set.\n // 8. The -ERESTART error code leaks to userspace.\n //\n // Arguably this is a kernel bug, but it's not clear how the behavior should be changed.\n //\n // To work around this, we forcibly re-enable TIF_SIGPENDING when cleaning up\n // AutoRemoteSyscall (see below).\n need_sigpending_renable = true;\n }\n if (t->session().is_recording()) {\n RecordTask *rt = static_cast(t);\n sig_set_t signals_to_block = 0;\n\n if (rt->schedule_frozen) {\n // If we're explicitly controlling the schedule, make sure not to accidentally run\n // any signals that we were not meant to be able to see.\n memset(&signals_to_block, 0xff, sizeof(sig_set_t));\n }\n if (desched_event_armed(rt)) {\n // If the desched event is enabled, we need to disable it, so that we don't get\n // the desched signal interrupting the syscall we're trying to make. We also\n // need to mask it, so that if there's a pending desched signal from before\n // we disable it, we don't accidently steal it.\n signals_to_block |= signal_bit(rt->session().syscallbuf_desched_sig());\n need_desched_event_reenable = true;\n disarm_desched_event(rt);\n }\n\n if (signals_to_block) {\n restore_sigmask = true;\n sigmask_to_restore = rt->get_sigmask();\n // Ignore the process dying here - we'll notice later.\n (void)rt->set_sigmask(signals_to_block | sigmask_to_restore);\n }\n }\n}\n\nvoid AutoRemoteSyscalls::setup_path(bool enable_singlestep_path) {\n#if defined(__aarch64__)\n // XXXkhuey this fast path doesn't work on AArch64 yet, go slow instead\n enable_singlestep_path = false;\n#endif\n\n if (!replaced_bytes.empty()) {\n // XXX what to do here to clean up if the task died unexpectedly?\n t->write_mem(remote_ptr(initial_regs.ip().to_data_ptr()),\n replaced_bytes.data(), replaced_bytes.size());\n }\n\n remote_code_ptr syscall_ip;\n use_singlestep_path = enable_singlestep_path;\n if (use_singlestep_path) {\n syscall_ip = AddressSpace::rr_page_syscall_entry_point(\n AddressSpace::UNTRACED, AddressSpace::PRIVILEGED,\n AddressSpace::RECORDING_AND_REPLAY, t->arch());\n } else {\n syscall_ip = t->vm()->traced_syscall_ip();\n }\n initial_regs.set_ip(syscall_ip);\n\n // We need to make sure to clear any breakpoints or other alterations of\n // the syscall instruction we're using. Note that the tracee may have set its\n // own breakpoints or otherwise modified the instruction, so suspending our\n // own breakpoint is insufficient.\n std::vector syscall = rr::syscall_instruction(t->arch());\n bool ok = true;\n replaced_bytes =\n t->read_mem(initial_regs.ip().to_data_ptr(), syscall.size(), &ok);\n if (!ok) {\n // The task died\n return;\n }\n if (replaced_bytes == syscall) {\n replaced_bytes.clear();\n } else {\n t->write_mem(initial_regs.ip().to_data_ptr(), syscall.data(),\n syscall.size(), &ok);\n }\n}\n\nstatic bool is_usable_area(const KernelMapping& km) {\n return (km.prot() & (PROT_READ | PROT_WRITE)) == (PROT_READ | PROT_WRITE) &&\n (km.flags() & MAP_PRIVATE);\n}\n\nvoid AutoRemoteSyscalls::maybe_fix_stack_pointer() {\n if (!t->session().done_initial_exec()) {\n return;\n }\n\n remote_ptr last_stack_byte = t->regs().sp() - 1;\n if (t->vm()->has_mapping(last_stack_byte)) {\n auto m = t->vm()->mapping_of(last_stack_byte);\n if (is_usable_area(m.map) && m.map.start() + 2048 <= t->regs().sp()) {\n // 'sp' is in a stack region and there's plenty of space there. No need\n // to fix anything.\n return;\n }\n }\n\n MemoryRange found_stack;\n for (const auto& m : t->vm()->maps()) {\n if (is_usable_area(m.map)) {\n found_stack = m.map;\n break;\n }\n };\n\n if (found_stack.start().is_null()) {\n AutoRemoteSyscalls remote(t, DISABLE_MEMORY_PARAMS);\n found_stack =\n MemoryRange(remote.infallible_mmap_syscall_if_alive(\n remote_ptr(), 4096, PROT_READ | PROT_WRITE,\n MAP_PRIVATE | MAP_ANONYMOUS, -1, 0),\n 4096);\n ASSERT(t, !found_stack.start().is_null())\n << \"Tracee unexpectedly died here\";\n scratch_mem_was_mapped = true;\n }\n\n fixed_sp = found_stack.end();\n DEBUG_ASSERT(!fixed_sp.is_null());\n initial_regs.set_sp(fixed_sp);\n}\n\nAutoRemoteSyscalls::~AutoRemoteSyscalls() { restore_state_to(t); }\n\nvoid AutoRemoteSyscalls::restore_state_to(Task* t) {\n // Check if the task was unexpectedly killed via SIGKILL or equivalent.\n bool is_exiting = !t->is_stopped() || t->ptrace_event() == PTRACE_EVENT_EXIT ||\n t->was_reaped();\n\n // Unmap our scatch region if required\n if (scratch_mem_was_mapped && !is_exiting) {\n AutoRemoteSyscalls remote(t, DISABLE_MEMORY_PARAMS);\n remote.infallible_syscall(syscall_number_for_munmap(arch()),\n fixed_sp - 4096, 4096);\n }\n if (!replaced_bytes.empty()) {\n // XXX how to clean up if the task died and the address space is shared with live task?\n t->write_mem(remote_ptr(initial_regs.ip().to_data_ptr()),\n replaced_bytes.data(), replaced_bytes.size());\n }\n auto regs = initial_regs;\n regs.set_ip(initial_ip);\n regs.set_sp(initial_sp);\n if (is_exiting) {\n // Don't restore status; callers need to see the task is exiting.\n // And the other stuff we don't below won't work.\n // But do restore registers so it looks like the exit happened in a clean state.\n t->set_regs(regs);\n return;\n }\n\n if (t->arch() == aarch64 && regs.syscall_may_restart()) {\n // On AArch64, the kernel restarts aborted syscalls using an internal `orig_x0`.\n // This gets overwritten everytime we make a syscall so we need to restore it\n // if we are at a syscall that may restart.\n // The kernel `orig_x0` isn't accessible from ptrace AFAICT but fortunately\n // it does **NOT** get reset on syscall exit so we can actually set it's value\n // just by making a dummy syscall with the correct x0 value.\n auto restart_res = regs.syscall_result();\n regs.set_ip(t->vm()->traced_syscall_ip());\n // This can be any side-effect-free syscall that doesn't care about arg1.\n // The kernel sets its `orig_x0` no matter whether the syscall actually needs it.\n regs.set_syscallno(rr::ARM64Arch::getpid);\n regs.set_arg1(regs.orig_arg1());\n t->set_regs(regs);\n if (t->enter_syscall(aarch64, true)) {\n if (!t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee died unexpectedly, there is nothing more we can do.\n // Do not restore the status, we want callers to see that the task died.\n return;\n }\n }\n regs.set_ip(initial_ip);\n regs.set_syscallno(regs.original_syscallno());\n regs.set_syscall_result(restart_res);\n }\n // If we were sitting at a seccomp trap, try to get back there by resuming\n // here. Since the original register contents caused a seccomp trap,\n // re-running the syscall with the same registers should put us right back\n // to this same seccomp trap.\n if (initial_at_seccomp && t->ptrace_event() != PTRACE_EVENT_SECCOMP) {\n regs.set_ip(initial_ip.decrement_by_syscall_insn_length(t->arch()));\n regs.set_syscallno(regs.original_syscallno());\n t->set_regs(regs);\n RecordTask* rt = static_cast(t);\n while (true) {\n if (!rt->resume_execution(RESUME_CONT, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee died unexpectedly, there is nothing more we can do.\n // Do not restore the status, we want callers to see that the task died.\n return;\n }\n if (rt->ptrace_event())\n break;\n rt->stash_sig();\n }\n ASSERT(rt, rt->ptrace_event() == PTRACE_EVENT_SECCOMP);\n } else {\n // Restore stomped registers.\n t->set_regs(regs);\n }\n t->set_status(restore_wait_status);\n if (restore_sigmask) {\n static_cast(t)->set_sigmask(sigmask_to_restore);\n }\n if (need_desched_event_reenable) {\n arm_desched_event(static_cast(t));\n }\n if (need_sigpending_renable) {\n // The purpose of this PTRACE_INTERRUPT is to re-enable TIF_SIGPENDING on\n // the tracee, without forcing any actual signals on it. Since PTRACE_INTERRUPT\n // needs to be able to interrupt re-startable system calls, it is required\n // to set TIF_SIGPENDING, but the fact that this works is of course a very\n // deep implementation detail.\n // If this fails then the tracee must be dead or no longer traced, in which\n // case we no longer care about its TIF_SIGPENDING status.\n t->do_ptrace_interrupt();\n }\n}\n\nstatic bool ignore_signal(Task* t) {\n int sig = t->stop_sig();\n if (!sig) {\n return false;\n }\n if (t->session().is_replaying()) {\n if (ReplaySession::is_ignored_signal(sig)) {\n return true;\n }\n } else if (t->session().is_recording()) {\n auto rt = static_cast(t);\n if (sig != rt->session().syscallbuf_desched_sig()) {\n rt->stash_sig();\n }\n return true;\n }\n siginfo_t siginfo;\n errno = 0;\n t->fallible_ptrace(PTRACE_GETSIGINFO, nullptr, &siginfo);\n if (errno) {\n ASSERT(t, false) << \"Unexpected signal \" << signal_name(sig);\n } else {\n ASSERT(t, false) << \"Unexpected signal \" << siginfo;\n }\n return false;\n}\n\nlong AutoRemoteSyscalls::syscall_base(int syscallno, Registers& callregs) {\n SupportedArch arch = t->arch();\n LOG(debug) << \"syscall \" << syscall_name(syscallno, arch) << \" \" << callregs;\n\n if (t->is_exiting()) {\n LOG(debug) << \"Task is dying, don't try anything.\";\n ASSERT(t, t->stopped_or_unexpected_exit()) << \"Already seen exit event\";\n return -ESRCH;\n }\n\n if ((int)callregs.arg1() == SIGTRAP && use_singlestep_path &&\n (is_sigaction_syscall(syscallno, arch) ||\n is_rt_sigaction_syscall(syscallno, arch) ||\n is_signal_syscall(syscallno, arch))) {\n // Don't use the fast path if we're about to set up a signal handler\n // for SIGTRAP!\n LOG(debug) << \"Disabling singlestep path due to SIGTRAP sigaction\";\n setup_path(false);\n callregs.set_ip(initial_regs.ip());\n }\n\n callregs.set_original_syscallno(syscallno);\n callregs.set_syscallno(syscallno);\n t->set_regs(callregs);\n\n bool from_seccomp = initial_at_seccomp && t->ptrace_event() == PTRACE_EVENT_SECCOMP;\n if (use_singlestep_path && !from_seccomp) {\n while (true) {\n if (!t->resume_execution(RESUME_SINGLESTEP, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee was killed, there is nothing more we can do.\n ASSERT(t, t->stopped_or_unexpected_exit()) << \"Couldn't singlestep\";\n return -ESRCH;\n }\n LOG(debug) << \"Used singlestep path; status=\" << t->status();\n // When a PTRACE_EVENT_EXIT is returned we don't update registers\n if (t->ip() != callregs.ip()) {\n // We entered the syscall, so stop now\n break;\n }\n if (t->stop_sig() == SIGTRAP && t->get_siginfo().si_code == TRAP_TRACE) {\n // On aarch64, if we were previously in a syscall-exit stop, continuing\n // with PTRACE_SINGLESTEP will result in incurring a trap upon execution\n // of the first instruction in userspace. Ignore such a trap.\n continue;\n }\n if (ignore_signal(t)) {\n // We were interrupted by a signal before we even entered the syscall\n continue;\n }\n ASSERT(t, false) << \"Unexpected status \" << t->status();\n }\n } else {\n if (from_seccomp) {\n LOG(debug) << \"Skipping enter_syscall - already at seccomp stop\";\n } else {\n if (!t->enter_syscall(arch, true)) {\n // Tracee was killed, there is nothing more we can do.\n // Ensure callers see the task death status.\n ASSERT(t, t->stopped_or_unexpected_exit()) << \"couldn't enter syscall\";\n return -ESRCH;\n }\n LOG(debug) << \"Used enter_syscall; status=\" << t->status();\n }\n if (!t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee was killed, there is nothing more we can do.\n // Ensure callers see the task death status.\n ASSERT(t, t->stopped_or_unexpected_exit()) << \"couldn't resume syscall\";\n return -ESRCH;\n }\n LOG(debug) << \"syscall exit status=\" << t->status();\n }\n while (true) {\n if (t->status().is_syscall() ||\n (t->stop_sig() == SIGTRAP &&\n is_kernel_trap(t->get_siginfo().si_code))) {\n // If we got a SIGTRAP then we assume that's our singlestep and we're\n // done.\n break;\n }\n if (is_clone_syscall(syscallno, arch) &&\n t->clone_syscall_is_complete(&new_tid_, arch)) {\n if (!t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee was killed, there is nothing more we can do.\n ASSERT(t, t->stopped_or_unexpected_exit()) << \"Couldn't resume clone\";\n return -ESRCH;\n }\n LOG(debug) << \"got clone event; new status=\" << t->status();\n continue;\n }\n if (ignore_signal(t)) {\n if (t->regs().syscall_may_restart()) {\n if (!t->enter_syscall(arch, true)) {\n // Tracee was killed, there is nothing more we can do.\n ASSERT(t, t->stopped_or_unexpected_exit()) << \"Couldn't restart\";\n return -ESRCH;\n }\n LOG(debug) << \"signal ignored; restarting syscall, status=\"\n << t->status();\n if (!t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee was killed, there is nothing more we can do.\n ASSERT(t, t->stopped_or_unexpected_exit()) << \"Couldn't resume restart\";\n return -ESRCH;\n }\n LOG(debug) << \"syscall exit status=\" << t->status();\n continue;\n }\n LOG(debug) << \"signal ignored\";\n // We have been notified of a signal after a non-interruptible syscall\n // completed. Don't continue, we're done here.\n break;\n }\n ASSERT(t, false) << \"Unexpected status \" << t->status();\n break;\n }\n\n LOG(debug) << \"done, result=\" << t->regs().syscall_result();\n return t->regs().syscall_result();\n}\n\nSupportedArch AutoRemoteSyscalls::arch() const { return t->arch(); }\n\ntemplate \nstatic void write_socketcall_args(Task* t, remote_ptr remote_mem,\n typename Arch::signed_long arg1,\n typename Arch::signed_long arg2,\n typename Arch::signed_long arg3,\n bool* ok) {\n socketcall_args sc_args = { { arg1, arg2, arg3 } };\n t->write_mem(remote_mem.cast>(), sc_args, ok);\n}\n\ntemplate \nstruct fd_message {\n // Unfortunately we need to send at least one byte of data in our\n // message for it to work\n char data;\n typename Arch::iovec msgdata;\n char cmsgbuf[Arch::cmsg_space(sizeof(int))];\n typename Arch::msghdr msg;\n // XXX: Could make this conditional on Arch\n socketcall_args socketcall;\n void init(remote_ptr> base) {\n data = 0;\n msgdata.iov_base = REMOTE_PTR_FIELD(base, data);\n msgdata.iov_len = 1;\n memset(&msg, 0, sizeof(msg));\n msg.msg_control = REMOTE_PTR_FIELD(base, cmsgbuf);\n msg.msg_controllen = sizeof(cmsgbuf);\n msg.msg_iov = REMOTE_PTR_FIELD(base, msgdata);\n msg.msg_iovlen = 1;\n }\n fd_message(remote_ptr> base) {\n init(base);\n }\n fd_message() {\n init((uintptr_t)this);\n }\n remote_ptr> remote_this() {\n return msgdata.iov_base.rptr().as_int();\n }\n remote_ptr remote_msg() {\n return REMOTE_PTR_FIELD(remote_this(), msg);\n }\n remote_ptr> remote_sc_args() {\n return REMOTE_PTR_FIELD(remote_this(), socketcall);\n }\n remote_ptr remote_cmsgdata() {\n return REMOTE_PTR_FIELD(remote_this(), cmsgbuf).as_int() +\n sizeof(typename Arch::cmsghdr);\n }\n};\n\ntemplate \nstatic long child_sendmsg(AutoRemoteSyscalls& remote, int child_sock, int fd) {\n AutoRestoreMem remote_buf(remote, nullptr, sizeof(fd_message));\n fd_message msg(remote_buf.get().cast>());\n // Pull the puppet strings to have the child send its fd\n // to us. Similarly to above, we DONT_WAIT on the\n // call to finish, since it's likely not defined whether the\n // sendmsg() may block on our recvmsg()ing what the tracee\n // sent us (in which case we would deadlock with the tracee).\n // We call sendmsg on child socket, but first we have to prepare a lot of\n // data.\n auto cmsg = reinterpret_cast(msg.cmsgbuf);\n cmsg->cmsg_len = Arch::cmsg_len(sizeof(fd));\n cmsg->cmsg_level = SOL_SOCKET;\n cmsg->cmsg_type = SCM_RIGHTS;\n *static_cast(Arch::cmsg_data(cmsg)) = fd;\n\n if (has_socketcall_syscall(Arch::arch())) {\n socketcall_args sc_args = { { child_sock, (typename Arch::signed_long)msg.remote_msg().as_int(), 0 } };\n msg.socketcall = sc_args;\n }\n\n bool ok = true;\n remote.task()->write_bytes_helper(remote_buf.get().cast(),\n sizeof(msg), &msg, &ok);\n\n if (!ok) {\n return -ESRCH;\n }\n if (!has_socketcall_syscall(Arch::arch())) {\n return remote.syscall(Arch::sendmsg, child_sock, msg.remote_msg(), 0);\n }\n return remote.syscall(Arch::socketcall, SYS_SENDMSG, msg.remote_sc_args());\n}\n\ntemplate \nstatic long child_recvmsg(AutoRemoteSyscalls& remote, int child_sock) {\n AutoRestoreMem remote_buf(remote, nullptr, sizeof(fd_message));\n fd_message msg(remote_buf.get().cast>());\n bool ok = true;\n\n if (has_socketcall_syscall(Arch::arch())) {\n socketcall_args sc_args = { { child_sock,\n (typename Arch::signed_long)msg.remote_msg().as_int(), 0 } };\n msg.socketcall = sc_args;\n }\n\n remote.task()->write_bytes_helper(remote_buf.get().cast(),\n sizeof(msg), &msg, &ok);\n\n if (!ok) {\n ASSERT(remote.task(), errno == ESRCH || errno == EIO)\n << \"Error writing \" << remote_buf.get() << \" in \" << remote.task()->tid;\n LOG(debug) << \"Failed to write memory\";\n return -ESRCH;\n }\n int ret = 0;\n if (has_socketcall_syscall(Arch::arch())) {\n ret = remote.syscall(Arch::socketcall, SYS_RECVMSG, msg.remote_sc_args());\n } else {\n ret = remote.syscall(Arch::recvmsg, child_sock, msg.remote_msg(), 0);\n }\n if (ret < 0) {\n LOG(debug) << \"Failed to recvmsg \" << ret;\n return ret;\n }\n\n typename Arch::msghdr msghdr =\n remote.task()->read_mem(msg.remote_msg(), &ok);\n if (!ok) {\n ASSERT(remote.task(), errno == ESRCH || errno == EIO);\n LOG(debug) << \"Failed to read msghdr\";\n return -ESRCH;\n }\n ASSERT(remote.task(), !(msghdr.msg_flags & MSG_CTRUNC))\n << \"Control message was truncated; error in receiving fd in \"\n \"AutoRemoteSyscalls::child_recvmsg(). msghdr.msg_flags: \"\n << HEX(msghdr.msg_flags) << \"\\n\"\n << \"This error has been most likely caused by a process\\n\"\n << \"exceeding the max allowed open files limit set by\\n\"\n << \"Linux. Please consult `man 1 ulimit' and `man 1 prlimit' to\\n\"\n << \"learn how the max open files limit may be changed/checked.\\n\"\n << \"As usual, always carefully think through all implications of\\n\"\n << \"changing the process limits on your programs before making any\\n\"\n << \"changes.\\n\\n\"\n << \"If the above Assertion still fails, then (a) The limit you set was\\n\"\n << \"not high enough, or (b) the program could be opening files in an\\n\"\n << \"unbounded fashion, or (c) there is some other reason why socket\\n\"\n << \"control messages are being truncated and file descriptors cannot be\\n\"\n << \"received via SCM_RIGHTS.\";\n\n int their_fd = remote.task()->read_mem(msg.remote_cmsgdata(), &ok);\n if (!ok) {\n ASSERT(remote.task(), errno == ESRCH || errno == EIO);\n LOG(debug) << \"Failed to read msg\";\n return -ESRCH;\n }\n return their_fd;\n}\n\n#define MAX_FDS_READ 2\n\n// Try to read a single-character message from `sock`. Will collect\n// up to MAX_FDS_READ fds in an SCM_RIGHTS control message and return those\n// fds. Returns an empty vector if reading the message fails.\nstatic vector maybe_receive_fds(ScopedFd& sock, bool blocking = true) {\n vector ret;\n struct msghdr msg;\n memset(&msg, 0, sizeof(msg));\n char ch;\n struct iovec iov = { &ch, 1 };\n msg.msg_iov = &iov;\n msg.msg_iovlen = 1;\n char cmsgbuf[(CMSG_SPACE(MAX_FDS_READ * sizeof(int)))];\n msg.msg_control = cmsgbuf;\n msg.msg_controllen = sizeof(cmsgbuf);\n int flags = MSG_CMSG_CLOEXEC;\n if (!blocking) {\n flags |= MSG_DONTWAIT;\n }\n if (recvmsg(sock, &msg, flags) < 0) {\n return ret;\n }\n\n struct cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);\n if (!cmsg || cmsg->cmsg_level != SOL_SOCKET ||\n cmsg->cmsg_type != SCM_RIGHTS) {\n FATAL() << \"Invalid cmsg\";\n }\n int num_fds = (cmsg->cmsg_len - CMSG_LEN(0))/sizeof(int);\n for (int i = 0; i < num_fds; i++) {\n int fd;\n memcpy(&fd, CMSG_DATA(cmsg) + i*sizeof(int), sizeof(int));\n DEBUG_ASSERT(fd >= 0);\n ret.push_back(ScopedFd(fd));\n }\n return ret;\n}\n\nstatic void sendmsg_socket(ScopedFd& sock, int fd_to_send)\n{\n fd_message msg;\n\n struct msghdr *msgp = (struct msghdr*)&msg.msg;\n struct cmsghdr* cmsg = CMSG_FIRSTHDR(msgp);\n cmsg->cmsg_level = SOL_SOCKET;\n cmsg->cmsg_type = SCM_RIGHTS;\n cmsg->cmsg_len = CMSG_LEN(sizeof(fd_to_send));\n *(int*)CMSG_DATA(cmsg) = fd_to_send;\n\n if (0 > sendmsg(sock, msgp, 0)) {\n FATAL() << \"Failed to send fd\";\n }\n}\n\nstatic Task* thread_group_leader_for_fds(Task* t) {\n for (Task* tt : t->fd_table()->task_set()) {\n if (tt->tgid() == tt->rec_tid && !tt->seen_ptrace_exit_event()) {\n return tt;\n }\n }\n return nullptr;\n}\n\ntemplate ScopedFd AutoRemoteSyscalls::retrieve_fd_arch(int fd) {\n ScopedFd ret;\n if (!pid_fd.is_open()) {\n // Try to use pidfd_getfd to get the fd without round-tripping to the tracee.\n // pidfd_getfd requires a threadgroup leader, so find one if we can.\n Task* tg_leader_for_fds = thread_group_leader_for_fds(t);\n if (tg_leader_for_fds) {\n // N.B.: pidfd_open fds are always cloexec\n pid_fd = ScopedFd(::syscall(NativeArch::pidfd_open, tg_leader_for_fds->tid, 0));\n ASSERT(t, pid_fd.is_open() || errno == ENOSYS)\n << \"Error in pidfd_open errno=\" << errno_name(errno);\n }\n }\n if (pid_fd.is_open()) {\n ret = ScopedFd(::syscall(NativeArch::pidfd_getfd, pid_fd.get(), fd, 0));\n if (ret.is_open()) {\n return ret;\n }\n if (errno == EBADF) {\n // This can happen when the child was unexpectedly killed.\n return ret;\n }\n ASSERT(t, errno == ENOSYS) << \"Failed in pidfd_getfd errno=\" << errno_name(errno);\n }\n\n // Clear out any pending message in the socket.\n maybe_receive_fds(task()->session().tracee_socket_receiver_fd(), false);\n\n long child_syscall_result =\n child_sendmsg(*this, task()->session().tracee_fd_number(), fd);\n if (child_syscall_result == -ESRCH) {\n return ret;\n }\n ASSERT(t, child_syscall_result > 0) << \"Failed to sendmsg() in tracee; err=\"\n << errno_name(-child_syscall_result);\n vector fds = maybe_receive_fds(task()->session().tracee_socket_fd());\n ASSERT(t, !fds.empty()) << \"Failed to receive fd\";\n ASSERT(t, fds.size() == 1);\n return std::move(fds[0]);\n}\n\nScopedFd AutoRemoteSyscalls::retrieve_fd(int fd) {\n RR_ARCH_FUNCTION(retrieve_fd_arch, arch(), fd);\n}\n\ntemplate int AutoRemoteSyscalls::send_fd_arch(const ScopedFd &our_fd) {\n if (!our_fd.is_open()) {\n return -EBADF;\n }\n\n // Clear out any pending message from the socket.\n maybe_receive_fds(task()->session().tracee_socket_receiver_fd(), false);\n\n LOG(debug) << \"Sending fd \" << our_fd.get() << \" via socket fd \" << task()->session().tracee_socket_fd().get();\n sendmsg_socket(task()->session().tracee_socket_fd(), our_fd.get());\n\n long child_syscall_result =\n child_recvmsg(*this, task()->session().tracee_fd_number());\n // If the child died before reading the message from the socket,\n // the message will still be in the socket buffer and will be received\n // the next time we try to send something to a tracee. That's why\n // before using tracee_socket_receiver_fd we need to drain up to one message\n // from it.\n ASSERT(t, child_syscall_result >= 0 || child_syscall_result == -ESRCH)\n << \"Failed to recvmsg() in tracee; err=\" << errno_name(-child_syscall_result);\n return child_syscall_result;\n}\n\nint AutoRemoteSyscalls::send_fd(const ScopedFd &our_fd) {\n RR_ARCH_FUNCTION(send_fd_arch, arch(), our_fd);\n}\n\nvoid AutoRemoteSyscalls::infallible_close_syscall_if_alive(int child_fd) {\n infallible_syscall_if_alive(syscall_number_for_close(arch()), child_fd);\n}\n\nint AutoRemoteSyscalls::infallible_send_fd_if_alive(const ScopedFd &our_fd) {\n int child_fd = send_fd(our_fd);\n ASSERT(t, child_fd >= 0 || (child_fd == -ESRCH && !t->session().is_replaying()))\n << \"Failed to send fd; err=\" << errno_name(-child_fd);\n return child_fd;\n}\n\nvoid AutoRemoteSyscalls::infallible_send_fd_dup(const ScopedFd& our_fd, int dup_to, int dup3_flags) {\n int remote_fd = infallible_send_fd_if_alive(our_fd);\n ASSERT(t, remote_fd >= 0);\n if (remote_fd != dup_to) {\n long ret = infallible_syscall(syscall_number_for_dup3(arch()), remote_fd,\n dup_to, dup3_flags);\n ASSERT(task(), ret == dup_to);\n infallible_close_syscall_if_alive(remote_fd);\n }\n}\n\nremote_ptr AutoRemoteSyscalls::infallible_mmap_syscall_if_alive(\n remote_ptr addr, size_t length, int prot, int flags, int child_fd,\n uint64_t offset_bytes) {\n ASSERT(t, offset_bytes % page_size() == 0)\n << \"mmap offset (\" << offset_bytes << \") must be multiple of page size (\"\n << page_size() << \")\";\n // The first syscall argument is called \"arg 1\", so\n // our syscall-arg-index template parameter starts\n // with \"1\".\n remote_ptr ret =\n has_mmap2_syscall(arch())\n ? infallible_syscall_ptr_if_alive(syscall_number_for_mmap2(arch()), addr,\n length, prot, flags, child_fd,\n (off_t)offset_bytes / 4096)\n : infallible_syscall_ptr_if_alive(syscall_number_for_mmap(arch()), addr,\n length, prot, flags, child_fd,\n offset_bytes);\n if (flags & MAP_FIXED) {\n if (ret) {\n ASSERT(t, addr == ret) << \"MAP_FIXED at \" << addr << \" but got \" << ret;\n } else {\n if (!t->vm()->has_mapping(addr)) {\n KernelMapping km = t->vm()->read_kernel_mapping(t, addr);\n if (km.size()) {\n ASSERT(t, km.start() == addr && km.size() == ceil_page_size(length));\n // The mapping was created. Pretend this call succeeded.\n ret = addr;\n }\n }\n }\n }\n return ret;\n}\n\nbool AutoRemoteSyscalls::infallible_munmap_syscall_if_alive(\n remote_ptr addr, size_t length) {\n long ret = infallible_syscall_if_alive(syscall_number_for_munmap(arch()),\n addr, length);\n if (ret) {\n if (t->vm()->has_mapping(addr)) {\n KernelMapping km = t->vm()->read_kernel_mapping(t, addr);\n if (!km.size()) {\n // The unmap happened but the task must have died before\n // reporting the status.\n ret = 0;\n }\n }\n }\n return !ret;\n}\n\nint64_t AutoRemoteSyscalls::infallible_lseek_syscall(int fd, int64_t offset,\n int whence) {\n switch (arch()) {\n case x86: {\n AutoRestoreMem mem(*this, &offset, sizeof(int64_t));\n infallible_syscall(syscall_number_for__llseek(arch()), fd, offset >> 32,\n offset, mem.get(), whence);\n return t->read_mem(mem.get().cast());\n }\n case x86_64:\n case aarch64:\n return infallible_syscall(syscall_number_for_lseek(arch()), fd, offset,\n whence);\n default:\n ASSERT(t, false) << \"Unknown arch\";\n return -1;\n }\n}\n\nbool AutoRemoteSyscalls::check_syscall_result(long ret, int syscallno, bool allow_death) {\n if (word_size(t->arch()) == 4) {\n // Sign-extend ret because it can be a 32-bit negative errno\n ret = (int)ret;\n }\n if (ret == -ESRCH && allow_death && !t->session().is_replaying()) {\n return true;\n }\n if (-4096 < ret && ret < 0) {\n string extra_msg;\n if (is_open_syscall(syscallno, arch())) {\n extra_msg = \" opening \" + t->read_c_str(t->regs().arg1());\n } else if (is_openat_syscall(syscallno, arch()) || is_openat2_syscall(syscallno, arch())) {\n extra_msg = \" opening \" + t->read_c_str(t->regs().arg2());\n } else if (is_mremap_syscall(syscallno, arch())) {\n AddressSpace::print_process_maps(t);\n } else if (is_mmap_syscall(syscallno, arch())) {\n AddressSpace::print_process_maps(t);\n if ((t->regs().arg4() & MAP_ANONYMOUS) == 0) {\n extra_msg = \" mmapping \" + t->file_name_of_fd(t->regs().arg5());\n }\n }\n ASSERT(t, false) << \"Syscall \" << syscall_name(syscallno, arch())\n << \" failed with errno \" << errno_name(-ret) << extra_msg\n << \" arg1=0x\" << hex << t->regs().arg1() << \" arg2=0x\" << t->regs().arg2()\n << \" arg3=0x\" << hex << t->regs().arg3() << \" arg4=0x\" << t->regs().arg4()\n << \" arg5=0x\" << hex << t->regs().arg5() << \" arg6=0x\" << t->regs().arg6();\n }\n return false;\n}\n\nvoid AutoRemoteSyscalls::finish_direct_mmap(\n remote_ptr rec_addr, size_t length,\n int prot, int flags,\n const string& backing_file_name,\n int backing_file_open_flags,\n off_t backing_offset_bytes,\n struct stat& real_file, string& real_file_name) {\n int fd;\n\n LOG(debug) << \"directly mmap'ing \" << length << \" bytes of \"\n << backing_file_name << \" at offset \"\n << HEX(backing_offset_bytes);\n\n ASSERT(task(), !(flags & MAP_GROWSDOWN));\n\n /* Open in the tracee the file that was mapped during\n * recording. */\n {\n AutoRestoreMem child_str(*this, backing_file_name.c_str());\n if (word_size(t->arch()) == 4) {\n backing_file_open_flags |= RR_LARGEFILE_32;\n }\n fd = infallible_syscall(syscall_number_for_openat(arch()), -1,\n child_str.get().as_int(),\n backing_file_open_flags);\n }\n /* And mmap that file. */\n infallible_mmap_syscall_if_alive(rec_addr, length,\n /* (We let SHARED|WRITEABLE\n * mappings go through while\n * they're not handled properly,\n * but we shouldn't do that.) */\n prot, (flags & ~MAP_SYNC) | MAP_FIXED, fd,\n /* MAP_SYNC is used to request direct mapping\n * (DAX) from the filesystem for persistent\n * memory devices (requires\n * MAP_SHARED_VALIDATE). Drop it for the\n * backing file. */\n backing_offset_bytes);\n\n // While it's open, grab the link reference.\n real_file = task()->stat_fd(fd);\n real_file_name = task()->file_name_of_fd(fd);\n\n /* Don't leak the tmp fd. The mmap doesn't need the fd to\n * stay open. */\n infallible_close_syscall_if_alive(fd);\n}\n\n\n} // namespace rr\n" }, { "path": "src/AutoRemoteSyscalls.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_AUTO_REMOTE_SYSCALLS_H_\n#define RR_AUTO_REMOTE_SYSCALLS_H_\n\n#include \n\n#include \n\n#include \"Registers.h\"\n#include \"ScopedFd.h\"\n#include \"Task.h\"\n\nnamespace rr {\n\nclass AutoRemoteSyscalls;\nclass Task;\n\n/**\n * Helpers to make remote syscalls on behalf of a Task. Usage looks\n * like\n *\n * AutoRemoteSyscalls remote(t); // prepare remote syscalls\n * remote.syscall(syscall_number_for_open(remote.arch()), ...); // make\n *syscalls\n * ...\n * // when |remote| goes out of scope, remote syscalls are finished\n */\n\n/**\n * Cookie used to restore stomped memory, usually prepared as the\n * argument to a remote syscall.\n */\nclass AutoRestoreMem {\npublic:\n /**\n * Write |mem| into address space of the Task prepared for\n * remote syscalls in |remote|, in such a way that the write\n * will be undone. The address of the reserved mem space is\n * available via |get|.\n * If |mem| is null, data is not written, only the space is reserved.\n */\n AutoRestoreMem(AutoRemoteSyscalls& remote, const void* mem, ssize_t num_bytes)\n : remote(remote) {\n init(mem, num_bytes);\n }\n\n /**\n * Convenience constructor for pushing a C string |str|, including\n * the trailing '\\0' byte.\n */\n AutoRestoreMem(AutoRemoteSyscalls& remote, const char* str) : remote(remote) {\n init((const uint8_t*)str, strlen(str) + 1 /*null byte*/);\n }\n\n ~AutoRestoreMem();\n\n /**\n * Get a pointer to the reserved memory.\n * Returns null if we failed.\n */\n remote_ptr get() const { return addr; }\n\n /**\n * Return size of reserved memory buffer.\n */\n size_t size() const { return data.size(); }\n\nprivate:\n void init(const void* mem, ssize_t num_bytes);\n\n AutoRemoteSyscalls& remote;\n /* Address of tmp mem. */\n remote_ptr addr;\n /* Saved data. */\n std::vector data;\n /* (We keep this around for error checking.) */\n remote_ptr saved_sp;\n /* Length of tmp mem. */\n size_t len;\n\n AutoRestoreMem& operator=(const AutoRestoreMem&) = delete;\n AutoRestoreMem(const AutoRestoreMem&) = delete;\n void* operator new(size_t) = delete;\n void operator delete(void*) = delete;\n};\n\n/**\n * RAII helper to prepare a Task for remote syscalls and undo any\n * preparation upon going out of scope. Note that this restores register\n * values when going out of scope, so *all* changes to Task's register\n * state are lost.\n */\nclass AutoRemoteSyscalls {\npublic:\n enum MemParamsEnabled { ENABLE_MEMORY_PARAMS, DISABLE_MEMORY_PARAMS };\n\n /**\n * Prepare |t| for a series of remote syscalls.\n *\n * NBBB! Before preparing for a series of remote syscalls,\n * the caller *must* ensure the callee will not receive any\n * signals. This code does not attempt to deal with signals.\n */\n AutoRemoteSyscalls(Task* t,\n MemParamsEnabled enable_mem_params = ENABLE_MEMORY_PARAMS);\n /**\n * Undo in |t| any preparations that were made for a series of\n * remote syscalls.\n */\n ~AutoRemoteSyscalls();\n\n /**\n * If t's stack pointer doesn't look valid, temporarily adjust it to\n * the top of *some* stack area.\n */\n void maybe_fix_stack_pointer();\n\n /**\n * \"Initial\" registers saved from the target task.\n *\n * NB: a non-const reference is returned because some power\n * users want to update the registers that are restored after\n * finishing remote syscalls. Perhaps these users should be\n * fixed, or you should just be careful.\n */\n Registers& regs() { return initial_regs; }\n\n /**\n * Undo any preparations to make remote syscalls in the context of |t|.\n *\n * This is usually called automatically by the destructor;\n * don't call it directly unless you really know what you'd\n * doing. *ESPECIALLY* don't call this on a |t| other than\n * the one passed to the constructor, unless you really know\n * what you're doing.\n */\n void restore_state_to(Task* t);\n\n /**\n * Make |syscallno| with variadic |args| (limited to 6 on\n * x86). Return the raw kernel return value.\n * Returns -ESRCH if the process dies or has died.\n */\n template long syscall(int syscallno, Rest... args) {\n Registers callregs = regs();\n // The first syscall argument is called \"arg 1\", so\n // our syscall-arg-index template parameter starts\n // with \"1\".\n return syscall_helper<1>(syscallno, callregs, args...);\n }\n\n // Aborts on all errors.\n // DEPRECATED. Use infallible_syscall_if_alive instead.\n template \n long infallible_syscall(int syscallno, Rest... args) {\n Registers callregs = regs();\n // The first syscall argument is called \"arg 1\", so\n // our syscall-arg-index template parameter starts\n // with \"1\".\n long ret = syscall_helper<1>(syscallno, callregs, args...);\n check_syscall_result(ret, syscallno, false);\n return ret;\n }\n\n // Aborts on all errors other than -ESRCH. Aborts on -ESRCH\n // if this is a replay task (they should never unexpectedly die).\n template \n long infallible_syscall_if_alive(int syscallno, Rest... args) {\n Registers callregs = regs();\n // The first syscall argument is called \"arg 1\", so\n // our syscall-arg-index template parameter starts\n // with \"1\".\n long ret = syscall_helper<1>(syscallno, callregs, args...);\n check_syscall_result(ret, syscallno);\n return ret;\n }\n\n /** Returns null if the tracee is dead */\n template \n remote_ptr infallible_syscall_ptr_if_alive(int syscallno, Rest... args) {\n Registers callregs = regs();\n long ret = syscall_helper<1>(syscallno, callregs, args...);\n check_syscall_result(ret, syscallno);\n return ret == -ESRCH ? 0 : ret;\n }\n\n /**\n * Remote mmap syscalls are common and non-trivial due to the need to\n * select either mmap2 or mmap.\n * Returns null if the process died (or was already dead) without\n * creating the map. \"Dead\" includes reaching PTRACE_EVENT_EXIT.\n * If the mapping is FIXED and no mapping currently exists at the address,\n * and the syscall creates the mapping but the process dies before returning\n * success, we fix the result to indicate that the syscall succeeded.\n * Creating FIXED mappings in areas free according to AddressSpace is the only\n * reliable way to keep AddressSpace in sync with reality in the event of\n * unexpected process death racing with this operation.\n */\n remote_ptr infallible_mmap_syscall_if_alive(remote_ptr addr, size_t length,\n int prot, int flags, int child_fd,\n uint64_t offset_bytes);\n\n /**\n * Returns false if the process died (or was already dead) without\n * unmapping the area. \"Dead\" includes reaching PTRACE_EVENT_EXIT.\n * If a mapping currently exists at the address, and the syscall unmaps\n * the mapping but the process dies before returning success, we fix\n * the result to indicate that the syscall succeeded.\n */\n bool infallible_munmap_syscall_if_alive(remote_ptr addr, size_t length);\n\n /** TODO replace with infallible_lseek_syscall_if_alive */\n int64_t infallible_lseek_syscall(int fd, int64_t offset, int whence);\n\n /** Close the fd in the child. If the child died, just ignore that. */\n void infallible_close_syscall_if_alive(int child_fd);\n\n /** The Task in the context of which we're making syscalls. */\n Task* task() const { return t; }\n\n /**\n * A small helper to get at the Task's arch.\n * Out-of-line to avoid including Task.h here.\n */\n SupportedArch arch() const;\n\n /**\n * Arranges for 'fd' to be transmitted to this process and returns\n * our opened version of it.\n * Returns a closed fd if the process dies or has died.\n */\n ScopedFd retrieve_fd(int fd);\n\n /**\n * Arranges for 'fd' to be transmitted to the tracee and returns\n * a file descriptor in the tracee that corresponds to the same file\n * description.\n * Returns a negative value if this fails.\n */\n int send_fd(const ScopedFd &fd);\n\n /**\n * Arranges for 'fd' to be transmitted to the tracee and returns\n * a file descriptor in the tracee that corresponds to the same file\n * description.\n * Aborts if that fails.\n * Returns -ESRCH if the tracee is dead (and is not replaying)\n */\n int infallible_send_fd_if_alive(const ScopedFd& our_fd);\n\n /**\n * `send_fd` the given file descriptor, making sure that it ends up as fd\n * `dup_to`, (dup'ing it there and closing the original if necessary)\n * TODO replace with infallible_send_fd_dup_if_alive\n */\n void infallible_send_fd_dup(const ScopedFd& our_fd, int dup_to, int dup3_flags);\n\n /**\n * Remotely invoke in |t| the specified syscall with the given\n * arguments. The arguments must of course be valid in |t|,\n * and no checking of that is done by this function.\n *\n * The syscall is finished in |t| and the result is returned.\n */\n long syscall_base(int syscallno, Registers& callregs);\n\n MemParamsEnabled enable_mem_params() { return enable_mem_params_; }\n\n /**\n * When the syscall is 'clone', this will be recovered from the\n * PTRACE_EVENT_FORK/VFORK/CLONE.\n */\n pid_t new_tid() { return new_tid_; }\n\n /* Do the open/mmap/close dance for a particular file */\n void finish_direct_mmap(remote_ptr rec_addr, size_t length,\n int prot, int flags,\n const std::string& backing_file_name,\n int backing_file_open_flags,\n off_t backing_offset_bytes,\n struct stat& real_file, std::string& real_file_name);\n\n // Calling this with allow_death false is DEPRECATED.\n // Returns true iff session was not replaying and allow_death is true and process is not alive (-ESRCH)\n bool check_syscall_result(long ret, int syscallno, bool allow_death = true);\n\nprivate:\n void setup_path(bool enable_singlestep_path);\n\n /**\n * \"Recursively\" build the set of syscall registers in\n * |callregs|. |Index| is the syscall arg that will be set to\n * |arg|, and |args| are the remaining arguments.\n */\n template \n long syscall_helper(int syscallno, Registers& callregs, T arg, Rest... args) {\n callregs.set_arg(arg);\n return syscall_helper(syscallno, callregs, args...);\n }\n /**\n * \"Recursion\" \"base case\": no more arguments to build, so\n * just make the syscall and return the kernel return value.\n */\n template long syscall_helper(int syscallno, Registers& callregs) {\n return syscall_base(syscallno, callregs);\n }\n\n template ScopedFd retrieve_fd_arch(int fd);\n template int send_fd_arch(const ScopedFd &fd);\n\n Task* t;\n Registers initial_regs;\n remote_code_ptr initial_ip;\n remote_ptr initial_sp;\n bool initial_at_seccomp;\n remote_ptr fixed_sp;\n std::vector replaced_bytes;\n WaitStatus restore_wait_status;\n ScopedFd pid_fd;\n\n pid_t new_tid_;\n /* Whether we had to mmap a scratch region because none was found */\n bool scratch_mem_was_mapped;\n bool use_singlestep_path;\n\n MemParamsEnabled enable_mem_params_;\n\n bool restore_sigmask;\n sig_set_t sigmask_to_restore;\n\n bool need_sigpending_renable;\n bool need_desched_event_reenable;\n\n AutoRemoteSyscalls& operator=(const AutoRemoteSyscalls&) = delete;\n AutoRemoteSyscalls(const AutoRemoteSyscalls&) = delete;\n};\n\n} // namespace rr\n\n#endif // RR_AUTO_REMOTE_SYSCALLS_H_\n" }, { "path": "src/BpfMapMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_BPF_MAP_MONITOR_H_\n#define RR_BPF_MAP_MONITOR_H_\n\n#include \"FileMonitor.h\"\n\nnamespace rr {\n\n/**\n * A FileMonitor attached to BPF map fds to record their key and value size.\n */\nclass BpfMapMonitor : public FileMonitor {\npublic:\n BpfMapMonitor(uint64_t key_size, uint64_t value_size) : key_size_(key_size), value_size_(value_size) {}\n\n virtual Type type() override { return BpfMap; }\n\n uint64_t key_size() const { return key_size_; }\n uint64_t value_size() const { return value_size_; }\n\nprivate:\n uint64_t key_size_;\n uint64_t value_size_;\n};\n\n} // namespace rr\n\n#endif /* RR_BPF_MAP_MONITOR_H_ */\n" }, { "path": "src/BreakpointCondition.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_BREAKPOINT_CONDITION_H_\n#define RR_BREAKPOINT_CONDITION_H_\n\nnamespace rr {\n\nclass ReplayTask;\n\nclass BreakpointCondition {\npublic:\n virtual ~BreakpointCondition() {}\n virtual bool evaluate(ReplayTask* t) const = 0;\n};\n\n} // namespace rr\n\n#endif // RR_BREAKPOINT_CONDITION_H_\n" }, { "path": "src/BuildidCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n\n#include \"log.h\"\n#include \"Command.h\"\n#include \"ElfReader.h\"\n#include \"ScopedFd.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass BuildidCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n BuildidCommand(const char* name, const char* help) : Command(name, help) {}\n\n static BuildidCommand singleton;\n};\n\nBuildidCommand BuildidCommand::singleton(\n \"buildid\",\n \" rr buildid\\n\"\n \" Accepts paths on stdin, prints buildids on stdout. Will terminate when\\n\"\n \" either an empty line or an invalid path is provided.\\n\");\n\nint BuildidCommand::run(vector& args) {\n if (!args.empty()) {\n fprintf(stderr, \"Unexpected arguments!\");\n return 1;\n }\n\n string input;\n while (getline(cin, input)) {\n if (input.empty()) {\n break;\n }\n\n ScopedFd fd = ScopedFd(input.c_str(), O_RDONLY, 0);\n if (!fd.is_open()) {\n LOG(error) << \"Failed to open `\" << input << \"`\";\n return 1;\n }\n\n ElfFileReader reader(fd);\n auto buildid = reader.read_buildid();\n fprintf(stdout, \"%s\\n\", buildid.c_str());\n }\n\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/CPUFeaturesCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"GdbServer.h\"\n#include \"main.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass CPUFeaturesCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n CPUFeaturesCommand(const char* name, const char* help) : Command(name, help) {}\n\n static CPUFeaturesCommand singleton;\n};\n\nCPUFeaturesCommand CPUFeaturesCommand::singleton(\n \"cpufeatures\",\n \" rr cpufeatures\\n\"\n \" Print `rr record` command line options that will limit the tracee\\n\"\n \" to CPU features this machine supports.\\n\"\n \" Useful for trace portability: run `rr cpufeatures` on the machine\\n\"\n \" you plan to replay on, then add those command-line parameters to\\n\"\n \" `rr record` on the recording machine.\\n\");\n\nint CPUFeaturesCommand::run(vector& args) {\n while (parse_global_option(args)) {\n }\n\n CPUIDData features = cpuid(CPUID_GETFEATURES, 0);\n CPUIDData extended_features = cpuid(CPUID_GETEXTENDEDFEATURES, 0);\n CPUIDData features_xsave = cpuid(CPUID_GETXSAVE, 1);\n fprintf(stdout, \"--disable-cpuid-features 0x%x,0x%x \"\n \"--disable-cpuid-features-ext 0x%x,0x%x,0x%x \"\n \"--disable-cpuid-features-xsave 0x%x\\n\",\n ~features.ecx, ~features.edx,\n ~extended_features.ebx, ~extended_features.ecx,\n ~extended_features.edx, ~features_xsave.eax);\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/CPUIDBugDetector.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CPUIDBugDetector.h\"\n#include \"Event.h\"\n#include \"Flags.h\"\n#include \"ReplaySession.h\"\n#include \"ReplayTask.h\"\n#include \"kernel_abi.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n#if defined(__i386__) || defined(__x86_64__)\nextern \"C\" int cpuid_loop(int iterations);\nvoid CPUIDBugDetector::run_detection_code() {\n // Call cpuid_loop to generate trace data we can use to detect\n // the cpuid rcb undercount bug. This generates 4 geteuid\n // calls which should have 2 rcbs between each of the\n // 3 consecutive pairs.\n cpuid_loop(4);\n}\n#else\n// Other platforms don't have cpuid, but keep the calling code clean, by\n// just making this a no-op there.\nvoid CPUIDBugDetector::run_detection_code() {}\n#endif\n\nstatic bool rcb_counts_ok(ReplayTask* t, uint64_t prev, uint64_t current) {\n uint32_t expected_count = 2 + PerfCounters::ticks_for_direct_call(t);\n if (current - prev == expected_count) {\n return true;\n }\n if (!Flags::get().suppress_environment_warnings) {\n fprintf(\n stderr,\n \"\\n\"\n \"rr: Warning: You appear to be running in a VMWare guest with a bug\\n\"\n \" where a conditional branch instruction between two CPUID \"\n \"instructions\\n\"\n \" sometimes fails to be counted by the conditional branch \"\n \"performance\\n\"\n \" counter. Work around this problem by adding\\n\"\n \" monitor_control.disable_hvsim_clusters = true\\n\"\n \" to your .vmx file.\\n\"\n \"\\n\");\n }\n return false;\n}\n\nvoid CPUIDBugDetector::notify_reached_syscall_during_replay(ReplayTask* t) {\n // We only care about events that happen before the first exec,\n // when our detection code runs.\n if (!is_x86ish(t->arch())) {\n return;\n }\n if (t->session().done_initial_exec()) {\n return;\n }\n const Event& ev = t->current_trace_frame().event();\n if (!is_geteuid32_syscall(ev.Syscall().number, t->arch()) &&\n !is_geteuid_syscall(ev.Syscall().number, t->arch())) {\n return;\n }\n uint64_t trace_rcb_count = t->current_trace_frame().ticks();\n uint64_t actual_rcb_count = t->tick_count();\n if (trace_rcb_count_at_last_geteuid32 > 0 && !detected_cpuid_bug) {\n if (!rcb_counts_ok(t, trace_rcb_count_at_last_geteuid32, trace_rcb_count) ||\n !rcb_counts_ok(t, actual_rcb_count_at_last_geteuid32, actual_rcb_count)) {\n detected_cpuid_bug = true;\n }\n }\n trace_rcb_count_at_last_geteuid32 = trace_rcb_count;\n actual_rcb_count_at_last_geteuid32 = actual_rcb_count;\n}\n\n} // namespace rr\n" }, { "path": "src/CPUIDBugDetector.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_CPUID_BUG_DETECTOR_H_\n#define RR_CPUID_BUG_DETECTOR_H_\n\n#include \n\nnamespace rr {\n\nclass ReplayTask;\n\n/**\n * Helper to detect when the \"CPUID can cause rcbs to be lost\" bug is present.\n * See http://robert.ocallahan.org/2014/09/vmware-cpuid-conditional-branch.html\n *\n * This bug is caused by VMM optimizations described in\n * https://www.usenix.org/system/files/conference/atc12/atc12-final158.pdf\n * that cause instruction sequences related to CPUID to be optimized,\n * eliminating the user-space execution of a conditional branch between two\n * CPUID instructions (in some circumstances).\n */\nclass CPUIDBugDetector {\npublic:\n CPUIDBugDetector()\n : trace_rcb_count_at_last_geteuid32(0),\n actual_rcb_count_at_last_geteuid32(0),\n detected_cpuid_bug(false) {}\n /**\n * Call this in the context of the first spawned process to run the\n * code that triggers the bug.\n */\n static void run_detection_code();\n /**\n * Call this when task t enters a traced syscall during replay.\n */\n void notify_reached_syscall_during_replay(ReplayTask* t);\n\nprivate:\n uint64_t trace_rcb_count_at_last_geteuid32;\n uint64_t actual_rcb_count_at_last_geteuid32;\n bool detected_cpuid_bug;\n};\n\n} // namespace rr\n\n#endif /* RR_CPUID_BUG_DETECTOR_H_ */\n" }, { "path": "src/CPUs.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CPUs.h\"\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstatic bool hybrid_cpu_arch_parse_cpus(const filesystem::path& dir,\n CPUGroup* group) {\n ifstream file(dir / \"cpus\");\n if (!file.good()) {\n LOG(warn) << \"File \" << dir.string() << \"/cpus not found\";\n return false;\n }\n ostringstream sstr;\n sstr << file.rdbuf();\n string s = sstr.str();\n while (!s.empty() && s[s.size() - 1] == '\\n') {\n s.resize(s.size() - 1);\n }\n if (s.empty()) {\n LOG(info) << \"File \" << dir.string() << \"/cpus is empty after trimming.\";\n return false;\n }\n size_t dash = s.find('-');\n if (dash == string::npos) {\n size_t end;\n group->start_cpu = stoi(s, &end);\n if (end != s.size()) {\n LOG(warn) << \"Bad CPU index\";\n return false;\n }\n group->end_cpu = group->start_cpu + 1;\n return true;\n }\n size_t end;\n group->start_cpu = stoi(s.substr(0, dash), &end);\n if (end != dash) {\n LOG(warn) << \"Bad CPU index\";\n return false;\n }\n int last_cpu = stoi(s.substr(dash + 1), &end);\n if (end != s.size() - (dash + 1)) {\n LOG(warn) << \"Bad end CPU index\";\n return false;\n }\n group->end_cpu = last_cpu + 1;\n return true;\n}\n\nstatic bool hybrid_cpu_arch_parse_type(const filesystem::path& dir,\n CPUGroup* group) {\n // See https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/intel-hybrid.txt\n ifstream file(dir / \"type\");\n if (!file.good()) {\n LOG(warn) << \"File \" << dir.string() << \"/type not found\";\n return false;\n }\n ostringstream sstr;\n sstr << file.rdbuf();\n string s = sstr.str();\n while (!s.empty() && s[s.size() - 1] == '\\n') {\n s.resize(s.size() - 1);\n }\n size_t end;\n group->type = stoi(s, &end);\n if (end != s.size()) {\n LOG(warn) << \"Bad type\";\n return false;\n }\n return true;\n}\n\n// Returns an empty list on many (all?) systems that aren't using hybrid cores.\n// In that case, assume all CPUs have the same microarch.\nstatic vector hybrid_cpu_arch_groups() {\n vector result;\n filesystem::path dir_path = \"/sys/devices\";\n if (!filesystem::is_directory(dir_path)) {\n return result;\n }\n for (const auto& entry : filesystem::directory_iterator(dir_path)) {\n auto file_name = entry.path().filename().string();\n if (file_name.find(\"cpu_\") != 0) {\n continue;\n }\n CPUGroup group;\n group.name = file_name.substr(4);\n if (!hybrid_cpu_arch_parse_cpus(entry.path(), &group)) {\n continue;\n }\n if (!hybrid_cpu_arch_parse_type(entry.path(), &group)) {\n continue;\n }\n if (group.name == \"core\") {\n group.kind = CPUGroup::P_CORE;\n } else if (group.name == \"atom\" || group.name == \"lowpower\") {\n group.kind = CPUGroup::E_CORE;\n } else {\n group.kind = CPUGroup::UNKNOWN;\n }\n result.push_back(std::move(group));\n }\n return result;\n}\n\nconst CPUs& CPUs::get() {\n static CPUs singleton;\n return singleton;\n}\n\nstd::vector CPUs::initial_affinity() const {\n std::vector result;\n for (int i = 0; i < CPU_SETSIZE; ++i) {\n if (CPU_ISSET(i, &initial_affinity_)) {\n result.push_back(i);\n }\n }\n return result;\n}\n\nbool CPUs::set_affinity_to_cpu(int cpu) {\n DEBUG_ASSERT(cpu >= 0);\n\n cpu_set_t mask;\n CPU_ZERO(&mask);\n CPU_SET(cpu, &mask);\n if (0 > sched_setaffinity(0, sizeof(mask), &mask)) {\n if (errno == EINVAL) {\n return false;\n }\n FATAL() << \"Couldn't bind to CPU \" << cpu;\n }\n return true;\n}\n\nvoid CPUs::restore_initial_affinity(pid_t tid) const {\n int ret = sched_setaffinity(tid, sizeof(initial_affinity_), &initial_affinity_);\n if (ret < 0) {\n FATAL() << \"restore_initial_affinity failed\";\n }\n}\n\nCPUs::CPUs() {\n // sched_getaffinity intersects the task's `cpu_mask`\n // (/proc/.../status Cpus_allowed_list) with `cpu_active_mask`\n // which is almost the same as /sys/devices/system/cpu/online\n int ret = sched_getaffinity(0, sizeof(initial_affinity_), &initial_affinity_);\n if (ret < 0) {\n FATAL() << \"failed to get initial affinity\";\n }\n cpu_groups_ = hybrid_cpu_arch_groups();\n}\n\n}\n\n" }, { "path": "src/CPUs.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_CPUS_H_\n#define RR_CPUS_H_\n\n#include \n\n#include \n#include \n\nnamespace rr {\n\nstruct BindCPU {\n enum Mode {\n // Bind to any core.\n ANY,\n // Perfer high-performance core if CPU affinity settings allow.\n PREFER_PERF_CORE,\n // Bind to a specified core unconditionally.\n SPECIFIED_CORE,\n // Don't bind.\n UNBOUND,\n };\n\n explicit BindCPU(Mode mode) : mode(mode) {}\n explicit BindCPU(int specified_core)\n : mode(SPECIFIED_CORE), specified_core(specified_core) {}\n\n Mode mode;\n int specified_core;\n};\n\nstruct CPUGroup {\n enum Kind { P_CORE, E_CORE, UNKNOWN };\n\n int start_cpu;\n // Exclusive\n int end_cpu;\n std::string name;\n // PERF_TYPE_RAW or something else usable in the perf-attr\n // event_type field.\n int type;\n Kind kind;\n};\n\nclass CPUs {\npublic:\n static const CPUs& get();\n\n // Returns the CPU indices in the initial affinity mask, in increasing order.\n std::vector initial_affinity() const;\n static bool set_affinity_to_cpu(int cpu);\n // Restore the initial affinity mask to the given tid.\n // If unspecified, defaults to this thread.\n void restore_initial_affinity(pid_t tid = 0) const;\n\n // Returns the CPU group list. May be empty on systems where that\n // information is not available or relevant.\n const std::vector& cpu_groups() const { return cpu_groups_; }\n\nprivate:\n CPUs();\n\n cpu_set_t initial_affinity_;\n std::vector cpu_groups_;\n};\n\n}\n\n#endif\n" }, { "path": "src/Command.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#define _BSD_SOURCE\n\n#include \"Command.h\"\n\n#include \n#include \n\n#include \n\n#include \"TraceStream.h\"\n#include \"core.h\"\n#include \"main.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nbool ParsedOption::verify_valid_int(int64_t min, int64_t max) const {\n if (int_value < min || int_value > max) {\n fprintf(\n stderr,\n \"Value %s for parameter %s was not valid (allowed range %lld-%lld)\\n\",\n value.c_str(), arg.c_str(), (long long)min, (long long)max);\n return false;\n }\n return true;\n}\n\nstatic vector* command_list;\n\nCommand::Command(const char* name, const char* help) : name(name), help(help) {\n if (!command_list) {\n command_list = new vector();\n }\n command_list->push_back(this);\n}\n\nCommand* Command::command_for_name(const std::string& name) {\n for (auto& it : *command_list) {\n if (strcmp(it->name, name.c_str()) == 0) {\n return it;\n }\n }\n return nullptr;\n}\n\nbool Command::less_than_by_name(Command* c1, Command* c2) {\n return strcmp(c1->name, c2->name) < 0;\n}\n\nvoid Command::print_help_all(FILE* out) {\n vector cmds;\n for (auto& it : *command_list) {\n if (!it->help) {\n continue;\n }\n cmds.push_back(it);\n }\n\n sort(cmds.begin(), cmds.end(), less_than_by_name);\n\n for (auto& it : cmds) {\n const char* c = strchr(it->help, '\\n');\n if (c) {\n fprintf(out, \"%.*s\\n\", (int)(c - it->help), it->help);\n } else {\n fputs(it->help, out);\n }\n }\n}\n\nvoid Command::print_help(FILE* out) {\n if (help) {\n fputs(help, out);\n print_global_options(out);\n } else {\n print_usage(out);\n }\n}\n\nstatic bool consume_args(std::vector& args, size_t count) {\n args.erase(args.begin(), args.begin() + count);\n return true;\n}\n\nstatic void assign_param(ParsedOption* opt, const char* s) {\n opt->value = s;\n opt->int_value = INT64_MIN;\n if (!opt->value.empty()) {\n char* end;\n int64_t v = strtoll(s, &end, 0);\n if (*end == 0) {\n opt->int_value = v;\n }\n }\n}\n\nbool Command::parse_option(std::vector& args,\n const OptionSpec* option_specs, size_t count,\n ParsedOption* out) {\n if (args.size() == 0 || args[0][0] != '-') {\n return false;\n }\n\n out->arg = args[0];\n\n for (size_t i = 0; i < count; ++i) {\n if (args[0][1] == option_specs[i].short_name && args[0][1] >= 32) {\n out->short_name = option_specs[i].short_name;\n switch (option_specs[i].param) {\n case NO_PARAMETER:\n if (args[0][2] == 0) {\n return consume_args(args, 1);\n }\n return false;\n case HAS_PARAMETER:\n if (args[0][2] == '=') {\n assign_param(out, args[0].c_str() + 3);\n return consume_args(args, 1);\n }\n if (args[0][2] != 0) {\n assign_param(out, args[0].c_str() + 2);\n return consume_args(args, 1);\n }\n if (args.size() >= 2) {\n assign_param(out, args[1].c_str());\n return consume_args(args, 2);\n }\n return false;\n default:\n DEBUG_ASSERT(0 && \"Unknown parameter type\");\n }\n } else if (args[0][1] == '-') {\n size_t equals = args[0].find('=');\n size_t cmp_len = (equals == string::npos ? 9999 : equals) - 2;\n if (cmp_len >= strlen(option_specs[i].long_name) &&\n strncmp(args[0].c_str() + 2, option_specs[i].long_name, cmp_len) == 0) {\n out->short_name = option_specs[i].short_name;\n switch (option_specs[i].param) {\n case NO_PARAMETER:\n return consume_args(args, 1);\n case HAS_PARAMETER:\n if (equals == string::npos) {\n if (args.size() >= 2) {\n assign_param(out, args[1].c_str());\n return consume_args(args, 2);\n }\n return false;\n }\n assign_param(out, args[0].c_str() + equals + 1);\n return consume_args(args, 1);\n default:\n DEBUG_ASSERT(0 && \"Unknown parameter type\");\n }\n }\n }\n }\n\n return false;\n}\n\nbool Command::verify_not_option(std::vector& args) {\n if (args.size() > 0 && args[0][0] == '-') {\n if (args[0].length() == 2 && args[0][1] == '-') {\n args.erase(args.begin());\n return true;\n }\n fprintf(stderr, \"Invalid option %s\\n\", args[0].c_str());\n return false;\n }\n return true;\n}\n\nbool Command::parse_optional_trace_dir(vector& args, string* out) {\n if (!verify_not_option(args)) {\n return false;\n }\n if (args.size() > 0) {\n *out = args[0];\n args.erase(args.begin());\n } else {\n *out = string();\n }\n return true;\n}\n\nbool Command::parse_literal(std::vector& args, const char* lit) {\n if (args.size() > 0 && args[0] == lit) {\n args.erase(args.begin());\n return true;\n } else {\n return false;\n }\n}\n\n} // namespace rr\n" }, { "path": "src/Command.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_COMMAND_H_\n#define RR_COMMAND_H_\n\n#ifndef _DEFAULT_SOURCE\n#define _DEFAULT_SOURCE 1\n#endif\n\n#include \n#include \n\n#include \n#include \n#include \n\nnamespace rr {\n\nclass TraceReader;\n\nenum OptionParameters { NO_PARAMETER, HAS_PARAMETER };\nstruct OptionSpec {\n char short_name;\n const char* long_name;\n OptionParameters param;\n};\nstruct ParsedOption {\n char short_name;\n std::string arg;\n std::string value;\n int64_t int_value;\n bool verify_valid_int(int64_t min = INT64_MIN + 1,\n int64_t max = INT64_MAX) const;\n};\n\n/**\n * rr command-line commands. Objects of this class must be static, since\n * they are expected to be immortal.\n */\nclass Command {\npublic:\n static Command* command_for_name(const std::string& name);\n static void print_help_all(FILE* out);\n\n /* Runs the command with the given parameters. Returns an exit code. */\n virtual int run(std::vector& args) = 0;\n void print_help(FILE* out);\n\n static bool verify_not_option(std::vector& args);\n static bool parse_optional_trace_dir(std::vector& args,\n std::string* out);\n static bool parse_option(std::vector& args,\n const OptionSpec* option_specs, size_t count,\n ParsedOption* out);\n template \n static bool parse_option(std::vector& args,\n const OptionSpec (&option_specs)[N],\n ParsedOption* out) {\n return parse_option(args, option_specs, N, out);\n }\n static bool parse_literal(std::vector& args, const char* lit);\n\nprotected:\n Command(const char* name, const char* help);\n virtual ~Command() {}\n\n static bool less_than_by_name(Command* c1, Command* c2);\n\n const char* name;\n const char* help;\n};\n\n} // namespace rr\n\n#endif // RR_COMMAND_H_\n" }, { "path": "src/CompressedReader.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CompressedReader.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"CompressedWriter.h\"\n#include \"core.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nCompressedReader::CompressedReader(const string& filename)\n : fd(new ScopedFd(filename.c_str(), O_CLOEXEC | O_RDONLY | O_LARGEFILE)) {\n fd_offset = 0;\n error = !fd->is_open();\n if (error) {\n eof = false;\n } else {\n char ch;\n eof = pread(*fd, &ch, 1, fd_offset) == 0;\n }\n buffer_read_pos = 0;\n buffer_skip_bytes = 0;\n have_saved_state = false;\n}\n\nCompressedReader::CompressedReader(const CompressedReader& other) {\n fd = other.fd;\n fd_offset = other.fd_offset;\n error = other.error;\n eof = other.eof;\n buffer_read_pos = other.buffer_read_pos;\n buffer_skip_bytes = other.buffer_skip_bytes;\n buffer = other.buffer;\n have_saved_state = false;\n DEBUG_ASSERT(!other.have_saved_state);\n}\n\nCompressedReader::~CompressedReader() { close(); }\n\nstatic bool read_all(const ScopedFd& fd, size_t size, void* data,\n uint64_t* offset) {\n ssize_t ret = read_to_end(fd, *offset, data, size);\n if (ret == (ssize_t)size) {\n *offset += size;\n return true;\n }\n return false;\n}\n\nstatic bool do_decompress(std::vector& compressed,\n std::vector& uncompressed) {\n size_t out_size = uncompressed.size();\n return BrotliDecoderDecompress(compressed.size(), compressed.data(),\n &out_size, uncompressed.data()) ==\n BROTLI_DECODER_RESULT_SUCCESS &&\n out_size == uncompressed.size();\n}\n\nbool CompressedReader::get_buffer(const uint8_t** data, size_t* size) {\n process_skip();\n\n if (error) {\n return false;\n }\n\n if (buffer_read_pos >= buffer.size() && !eof) {\n if (!refill_buffer()) {\n return false;\n }\n DEBUG_ASSERT(buffer_read_pos < buffer.size());\n }\n\n *data = &buffer[buffer_read_pos];\n *size = buffer.size() - buffer_read_pos;\n return true;\n}\n\nvoid CompressedReader::process_skip() {\n while (buffer_skip_bytes > 0 && !error) {\n if (buffer_read_pos < buffer.size()) {\n size_t amount = std::min(buffer_skip_bytes, buffer.size() - buffer_read_pos);\n buffer_skip_bytes -= amount;\n buffer_read_pos += amount;\n continue;\n }\n\n if (!refill_buffer(&buffer_skip_bytes)) {\n return;\n }\n }\n}\n\nbool CompressedReader::read(void* data, size_t size) {\n process_skip();\n\n while (size > 0) {\n if (error) {\n return false;\n }\n\n if (buffer_read_pos < buffer.size()) {\n size_t amount = std::min(size, buffer.size() - buffer_read_pos);\n memcpy(data, &buffer[buffer_read_pos], amount);\n size -= amount;\n data = static_cast(data) + amount;\n buffer_read_pos += amount;\n continue;\n }\n\n if (!refill_buffer()) {\n return false;\n }\n }\n return true;\n}\n\nbool CompressedReader::refill_buffer(size_t* skip_bytes) {\n if (have_saved_state && !have_saved_buffer) {\n std::swap(buffer, saved_buffer);\n have_saved_buffer = true;\n }\n\n while (true) {\n CompressedWriter::BlockHeader header;\n if (!read_all(*fd, sizeof(header), &header, &fd_offset)) {\n error = true;\n return false;\n }\n\n if (skip_bytes && *skip_bytes >= header.uncompressed_length) {\n fd_offset += header.compressed_length;\n *skip_bytes -= header.uncompressed_length;\n char ch;\n if (pread(*fd, &ch, 1, fd_offset) == 0) {\n eof = true;\n return false;\n }\n continue;\n }\n\n std::vector compressed_buf;\n compressed_buf.resize(header.compressed_length);\n if (!read_all(*fd, compressed_buf.size(), &compressed_buf[0], &fd_offset)) {\n error = true;\n return false;\n }\n\n char ch;\n if (pread(*fd, &ch, 1, fd_offset) == 0) {\n eof = true;\n }\n\n buffer.resize(header.uncompressed_length);\n buffer_read_pos = 0;\n if (!do_decompress(compressed_buf, buffer)) {\n error = true;\n return false;\n }\n\n return true;\n }\n}\n\nvoid CompressedReader::rewind() {\n DEBUG_ASSERT(!have_saved_state);\n fd_offset = 0;\n buffer_read_pos = 0;\n buffer_skip_bytes = 0;\n buffer.clear();\n eof = false;\n}\n\nvoid CompressedReader::close() { fd = nullptr; }\n\nvoid CompressedReader::save_state() {\n DEBUG_ASSERT(!have_saved_state);\n process_skip();\n have_saved_state = true;\n have_saved_buffer = false;\n saved_fd_offset = fd_offset;\n saved_buffer_read_pos = buffer_read_pos;\n}\n\nvoid CompressedReader::restore_state() {\n DEBUG_ASSERT(have_saved_state);\n have_saved_state = false;\n if (saved_fd_offset < fd_offset) {\n eof = false;\n }\n fd_offset = saved_fd_offset;\n if (have_saved_buffer) {\n std::swap(buffer, saved_buffer);\n saved_buffer.clear();\n }\n buffer_read_pos = saved_buffer_read_pos;\n buffer_skip_bytes = 0;\n}\n\nvoid CompressedReader::discard_state() {\n DEBUG_ASSERT(have_saved_state);\n have_saved_state = false;\n if (have_saved_buffer) {\n saved_buffer.clear();\n }\n}\n\nuint64_t CompressedReader::uncompressed_bytes() const {\n uint64_t offset = 0;\n uint64_t uncompressed_bytes = 0;\n CompressedWriter::BlockHeader header;\n while (read_all(*fd, sizeof(header), &header, &offset)) {\n uncompressed_bytes += header.uncompressed_length;\n offset += header.compressed_length;\n }\n return uncompressed_bytes;\n}\n\nuint64_t CompressedReader::compressed_bytes() const {\n return lseek(*fd, 0, SEEK_END);\n}\n\n} // namespace rr\n" }, { "path": "src/CompressedReader.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_COMPRESSED_READER_H_\n#define RR_COMPRESSED_READER_H_\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \"ScopedFd.h\"\n\nnamespace rr {\n\n/**\n * CompressedReader opens an input file written by CompressedWriter\n * and reads data from it. Currently data is decompressed by the thread that\n * calls read().\n */\nclass CompressedReader {\npublic:\n CompressedReader(const std::string& filename);\n CompressedReader(const CompressedReader& aOther);\n ~CompressedReader();\n bool good() const { return !error; }\n bool at_end() const {\n const_cast(this)->process_skip();\n return eof && buffer_read_pos == buffer.size();\n }\n // Returns true if successful. Otherwise there's an error and good()\n // will be false.\n bool read(void* data, size_t size);\n // Returns pointer/size of some buffered data. Does not change the state.\n // Returns zero size if at EOF.\n bool get_buffer(const uint8_t** data, size_t* size);\n // Advances the read position by the given size.\n void skip(size_t size) {\n buffer_skip_bytes += size;\n }\n void rewind();\n void close();\n\n /**\n * Save the current position. Nested saves are not allowed.\n */\n void save_state();\n /**\n * Restore previously saved position.\n */\n void restore_state();\n /**\n * Discard saved position\n */\n void discard_state();\n\n /**\n * Gathers stats on the file stream. These are independent of what's\n * actually been read.\n */\n uint64_t uncompressed_bytes() const;\n uint64_t compressed_bytes() const;\n\nprotected:\n void process_skip();\n bool refill_buffer(size_t* skip_bytes = nullptr);\n\n /* Our fd might be the dup of another fd, so we can't rely on its current file\n position.\n Instead track the current position in fd_offset and use pread. */\n uint64_t fd_offset;\n std::shared_ptr fd;\n bool error;\n bool eof;\n std::vector buffer;\n // within `buffer`\n size_t buffer_read_pos;\n size_t buffer_skip_bytes;\n\n bool have_saved_state;\n bool have_saved_buffer;\n uint64_t saved_fd_offset;\n std::vector saved_buffer;\n size_t saved_buffer_read_pos;\n};\n\n} // namespace rr\n\n#endif /* RR_COMPRESSED_READER_H_ */\n" }, { "path": "src/CompressedWriter.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"CompressedWriter.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"core.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n/* See\n * http://robert.ocallahan.org/2017/07/selecting-compression-algorithm-for-rr.html\n */\nstatic const int BROTLI_LEVEL = 5;\n\nvoid* CompressedWriter::compression_thread_callback(void* p) {\n static_cast(p)->compression_thread();\n return nullptr;\n}\n\nCompressedWriter::CompressedWriter(const string& filename, size_t block_size,\n uint32_t num_threads)\n : fd(filename.c_str(),\n O_CLOEXEC | O_WRONLY | O_CREAT | O_EXCL | O_LARGEFILE, 0400) {\n this->block_size = block_size;\n threads.resize(num_threads);\n thread_pos.resize(num_threads);\n buffer.resize(block_size * (num_threads + 2));\n pthread_mutex_init(&mutex, nullptr);\n pthread_cond_init(&cond, nullptr);\n\n for (uint32_t i = 0; i < num_threads; ++i) {\n thread_pos[i] = UINT64_MAX;\n }\n next_thread_pos = 0;\n next_thread_end_pos = 0;\n closing = false;\n write_error = false;\n\n producer_reserved_pos = 0;\n producer_reserved_write_pos = 0;\n producer_reserved_upto_pos = 0;\n error = false;\n if (fd < 0) {\n error = true;\n return;\n }\n\n // Make sure the compression threads block all signals\n sigset_t set;\n sigset_t old_mask;\n sigfillset(&set);\n sigprocmask(SIG_BLOCK, &set, &old_mask);\n // Hold the lock so threads don't inspect the 'threads' array\n // until we've finished initializing it.\n pthread_mutex_lock(&mutex);\n for (uint32_t i = 0; i < num_threads; ++i) {\n while (true) {\n int err = pthread_create(&threads[i], nullptr, compression_thread_callback, this);\n if (err == EAGAIN) {\n sched_yield(); // Give other processes a chance to exit.\n continue;\n } else if (err != 0) {\n SAFE_FATAL(err, \"Failed to create compression threads!\");\n }\n break;\n }\n size_t last_slash = filename.rfind('/');\n string thread_name =\n string(\"compress \") + (last_slash == string::npos\n ? filename\n : filename.substr(last_slash + 1));\n pthread_setname_np(threads[i], thread_name.substr(0, 15).c_str());\n }\n pthread_mutex_unlock(&mutex);\n sigprocmask(SIG_SETMASK, &old_mask, nullptr);\n}\n\nCompressedWriter::~CompressedWriter() {\n close();\n pthread_mutex_destroy(&mutex);\n pthread_cond_destroy(&cond);\n}\n\nvoid CompressedWriter::write(const void* data, size_t size) {\n while (!error && size > 0) {\n uint64_t reservation_size =\n producer_reserved_upto_pos - producer_reserved_write_pos;\n if (reservation_size == 0) {\n update_reservation(WAIT);\n continue;\n }\n size_t buf_offset = (size_t)(producer_reserved_write_pos % buffer.size());\n size_t amount = min(buffer.size() - buf_offset,\n (size_t)min(reservation_size, size));\n memcpy(&buffer[buf_offset], data, amount);\n producer_reserved_write_pos += amount;\n data = static_cast(data) + amount;\n size -= amount;\n }\n\n if (!error &&\n producer_reserved_write_pos - producer_reserved_pos >=\n buffer.size() / 2) {\n update_reservation(NOWAIT);\n }\n}\n\nvoid CompressedWriter::update_reservation(WaitFlag wait_flag) {\n pthread_mutex_lock(&mutex);\n\n next_thread_end_pos = producer_reserved_write_pos;\n producer_reserved_pos = producer_reserved_write_pos;\n\n // Wake up threads that might be waiting to consume data.\n pthread_cond_broadcast(&cond);\n\n while (!error) {\n if (write_error) {\n error = true;\n break;\n }\n\n uint64_t completed_pos = next_thread_pos;\n for (uint32_t i = 0; i < thread_pos.size(); ++i) {\n completed_pos = min(completed_pos, thread_pos[i]);\n }\n producer_reserved_upto_pos = completed_pos + buffer.size();\n if (producer_reserved_pos < producer_reserved_upto_pos ||\n wait_flag == NOWAIT) {\n break;\n }\n\n pthread_cond_wait(&cond, &mutex);\n }\n\n pthread_mutex_unlock(&mutex);\n}\n\nvoid CompressedWriter::compression_thread() {\n pthread_mutex_lock(&mutex);\n\n int thread_index;\n pthread_t self = pthread_self();\n for (thread_index = 0; threads[thread_index] != self; ++thread_index) {\n }\n\n // Add slop for incompressible data\n vector outputbuf;\n outputbuf.resize((size_t)(block_size * 1.1) + sizeof(BlockHeader));\n BlockHeader* header = reinterpret_cast(&outputbuf[0]);\n\n while (true) {\n if (!write_error && next_thread_pos < next_thread_end_pos &&\n (closing || next_thread_pos + block_size <= next_thread_end_pos)) {\n thread_pos[thread_index] = next_thread_pos;\n next_thread_pos = min(next_thread_end_pos, next_thread_pos + block_size);\n // header->uncompressed_length must be <= block_size,\n // therefore fits in a size_t.\n header->uncompressed_length =\n (size_t)(next_thread_pos - thread_pos[thread_index]);\n\n pthread_mutex_unlock(&mutex);\n header->compressed_length =\n do_compress(thread_pos[thread_index], header->uncompressed_length,\n &outputbuf[sizeof(BlockHeader)],\n outputbuf.size() - sizeof(BlockHeader));\n pthread_mutex_lock(&mutex);\n\n if (header->compressed_length == 0) {\n write_error = true;\n }\n\n // wait until we're the next thread that needs to write\n while (!write_error) {\n bool other_thread_write_first = false;\n for (uint32_t i = 0; i < thread_pos.size(); ++i) {\n if (thread_pos[i] < thread_pos[thread_index]) {\n other_thread_write_first = true;\n }\n }\n if (!other_thread_write_first) {\n break;\n }\n pthread_cond_wait(&cond, &mutex);\n }\n\n if (!write_error) {\n pthread_mutex_unlock(&mutex);\n write_all(fd, &outputbuf[0],\n sizeof(BlockHeader) + header->compressed_length);\n pthread_mutex_lock(&mutex);\n }\n\n thread_pos[thread_index] = UINT64_MAX;\n // do a broadcast because we might need to unblock\n // the producer thread or a compressor thread waiting\n // for us to write.\n pthread_cond_broadcast(&cond);\n continue;\n }\n\n if (closing && (write_error || next_thread_pos == next_thread_end_pos)) {\n break;\n }\n\n pthread_cond_wait(&cond, &mutex);\n }\n\n pthread_mutex_unlock(&mutex);\n}\n\nvoid CompressedWriter::close(Sync sync) {\n if (!fd.is_open()) {\n return;\n }\n\n update_reservation(NOWAIT);\n\n pthread_mutex_lock(&mutex);\n closing = true;\n pthread_cond_broadcast(&cond);\n pthread_mutex_unlock(&mutex);\n\n for (auto i = threads.begin(); i != threads.end(); ++i) {\n pthread_join(*i, nullptr);\n }\n\n if (sync == SYNC) {\n if (fsync(fd) < 0) {\n error = true;\n }\n }\n\n if (write_error) {\n error = true;\n }\n\n fd.close();\n}\n\nsize_t CompressedWriter::do_compress(uint64_t offset, size_t length,\n uint8_t* outputbuf, size_t outputbuf_len) {\n BrotliEncoderState* state = BrotliEncoderCreateInstance(NULL, NULL, NULL);\n if (!state) {\n DEBUG_ASSERT(0 && \"BrotliEncoderCreateInstance failed\");\n }\n if (!BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, BROTLI_LEVEL)) {\n DEBUG_ASSERT(0 && \"Brotli initialization failed\");\n }\n\n size_t ret = 0;\n while (length > 0) {\n size_t buf_offset = (size_t)(offset % buffer.size());\n size_t amount = min(length, buffer.size() - buf_offset);\n const uint8_t* in = &buffer[buf_offset];\n if (!BrotliEncoderCompressStream(state, BROTLI_OPERATION_PROCESS, &amount,\n &in, &outputbuf_len, &outputbuf, &ret)) {\n DEBUG_ASSERT(0 && \"Brotli compression failed\");\n }\n size_t consumed = in - &buffer[buf_offset];\n offset += consumed;\n length -= consumed;\n }\n size_t zero = 0;\n if (!BrotliEncoderCompressStream(state, BROTLI_OPERATION_FINISH, &zero, NULL,\n &outputbuf_len, &outputbuf, &ret)) {\n DEBUG_ASSERT(0 && \"Brotli compression failed\");\n }\n\n BrotliEncoderDestroyInstance(state);\n return ret;\n}\n\n} // namespace rr\n" }, { "path": "src/CompressedWriter.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_COMPRESSED_WRITER_H_\n#define RR_COMPRESSED_WRITER_H_\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \"ScopedFd.h\"\n\nnamespace rr {\n\n/**\n * CompressedWriter opens an output file and writes compressed blocks to it.\n * Blocks of a fixed but unspecified size (currently 1MB) are compressed.\n * Each block of compressed data is written to the file preceded by two\n * 32-bit words: the size of the compressed data (excluding block header)\n * and the size of the uncompressed data, in that order. See BlockHeader below.\n *\n * We use multiple threads to perform compression. The threads are\n * responsible for the actual data writes. The thread that creates the\n * CompressedWriter is the \"producer\" thread and must also be the caller of\n * 'write'. The producer thread may block in 'write' if 'buffer_size' bytes are\n * being compressed.\n *\n * Each data block is compressed independently using zlib.\n */\nclass CompressedWriter {\npublic:\n CompressedWriter(const std::string& filename, size_t buffer_size,\n uint32_t num_threads);\n ~CompressedWriter();\n // Call only on producer thread\n bool good() const { return !error; }\n // Call only on producer thread.\n void write(const void* data, size_t size);\n enum Sync { DONT_SYNC, SYNC };\n // Call only on producer thread\n void close(Sync sync = DONT_SYNC);\n\n struct BlockHeader {\n uint32_t compressed_length;\n uint32_t uncompressed_length;\n };\n\nprotected:\n enum WaitFlag { WAIT, NOWAIT };\n void update_reservation(WaitFlag wait_flag);\n\n static void* compression_thread_callback(void* p);\n void compression_thread();\n size_t do_compress(uint64_t offset, size_t length, uint8_t* outputbuf,\n size_t outputbuf_len);\n\n // Immutable while threads are running\n ScopedFd fd;\n int block_size;\n pthread_mutex_t mutex;\n pthread_cond_t cond;\n std::vector threads;\n\n // Carefully shared...\n std::vector buffer;\n\n // BEGIN protected by 'mutex'\n /* position in output stream that this thread is currently working on,\n * or UINT64_MAX if it's idle */\n std::vector thread_pos;\n /* position in output stream of data to dispatch to next thread */\n uint64_t next_thread_pos;\n /* position in output stream of end of data ready to dispatch */\n uint64_t next_thread_end_pos;\n bool closing;\n bool write_error;\n // END protected by 'mutex'\n\n /* producer thread only */\n /* Areas in the buffer that have been reserved for write() */\n uint64_t producer_reserved_pos;\n uint64_t producer_reserved_write_pos;\n uint64_t producer_reserved_upto_pos;\n bool error;\n};\n\n} // namespace rr\n\n#endif /* RR_COMPRESSED_WRITER_H_ */\n" }, { "path": "src/ContextSwitchEvent.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ContextSwitchEvent.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstatic volatile int sigio_count;\n\nstatic void sigio_handler(int, siginfo_t*, void*) {\n sigio_count += 1;\n}\n\nstatic bool can_use_switch_records() {\n struct perf_event_attr attr;\n memset(&attr, 0, sizeof(attr));\n attr.size = sizeof(attr);\n attr.type = PERF_TYPE_SOFTWARE;\n attr.config = PERF_COUNT_SW_DUMMY;\n attr.sample_period = 1;\n attr.watermark = 1;\n // We can't easily check PERF_RECORD_SWITCH directly\n // because there's no reliable way (as far as I know) to\n // force a context switch but still recover if no signal is\n // generated. So we test that generating a PERF_RECORD_MMAP\n // raises a signal instead.\n attr.mmap_data = 1;\n attr.wakeup_watermark = 1;\n attr.exclude_kernel = 1;\n attr.exclude_guest = 1;\n attr.disabled = 1;\n\n ScopedFd fd(syscall(SYS_perf_event_open, &attr, 0, -1, -1, 0));\n if (!fd.is_open()) {\n LOG(warn) << \"Couldn't open a dummy event\";\n return false;\n }\n\n PerfCounterBuffers buffers;\n buffers.allocate(fd, page_size(), 0);\n\n int ret = fcntl(fd, F_SETFL, FASYNC);\n if (ret < 0) {\n FATAL() << \"Can't make fd async\";\n }\n struct f_owner_ex own;\n own.type = F_OWNER_TID;\n own.pid = syscall(SYS_gettid);\n ret = fcntl(fd, F_SETOWN_EX, &own);\n if (ret < 0) {\n FATAL() << \"Failed to fcntl(SETOWN_EX)\";\n }\n\n struct sigaction sa;\n struct sigaction old_sa;\n sa.sa_sigaction = sigio_handler;\n sigemptyset(&sa.sa_mask);\n sa.sa_flags = SA_SIGINFO;\n ret = sigaction(SIGIO, &sa, &old_sa);\n if (ret < 0) {\n FATAL() << \"Failed to install sighandler\";\n }\n\n sigio_count = 0;\n ret = ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);\n if (ret < 0) {\n FATAL() << \"Failed to enable event\";\n }\n void* p = mmap(nullptr, 1, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);\n if (p == MAP_FAILED) {\n FATAL() << \"Failed to mmap\";\n }\n ret = ioctl(fd, PERF_EVENT_IOC_DISABLE, 0);\n if (ret < 0) {\n FATAL() << \"Failed to disable event\";\n }\n\n ret = munmap(p, 1);\n if (ret < 0) {\n FATAL() << \"Failed to munmap\";\n }\n ret = sigaction(SIGIO, &old_sa, nullptr);\n if (ret < 0) {\n FATAL() << \"Failed to clean up sighandler\";\n }\n\n if (sigio_count == 0) {\n // Old kernel\n LOG(info) << \"PERF_RECORD_MMAP watermark failed to deliver signal\";\n return false;\n }\n if (sigio_count > 1) {\n FATAL() << \"Invalid SIGIO count\";\n }\n\n return true;\n}\n\nstatic ContextSwitchEventStrategy init_strategy() {\n if (has_effective_caps(uint64_t(1) << CAP_SYS_ADMIN) ||\n has_effective_caps(uint64_t(1) << CAP_PERFMON)) {\n return ContextSwitchEventStrategy::STRATEGY_SW_CONTEXT_SWITCHES;\n }\n optional perf_event_paranoid = read_perf_event_paranoid();\n if (perf_event_paranoid.has_value() && *perf_event_paranoid <= 1) {\n return ContextSwitchEventStrategy::STRATEGY_SW_CONTEXT_SWITCHES;\n }\n\n if (can_use_switch_records()) {\n return ContextSwitchEventStrategy::STRATEGY_RECORD_SWITCH;\n }\n\n string paranoid_value = \"unknown\";\n if (perf_event_paranoid.has_value()) {\n paranoid_value = std::to_string(*perf_event_paranoid);\n }\n CLEAN_FATAL() <<\n \"rr needs /proc/sys/kernel/perf_event_paranoid <= 1, but it is \"\n << paranoid_value << \".\\n\"\n << \"Change it to 1, or use 'rr record -n' (slow).\\n\"\n << \"Consider putting 'kernel.perf_event_paranoid = 1' in /etc/sysctl.d/10-rr.conf.\\n\"\n << \"See 'man 8 sysctl', 'man 5 sysctl.d' (systemd systems)\\n\"\n << \"and 'man 5 sysctl.conf' (non-systemd systems) for more details.\";\n return ContextSwitchEventStrategy::STRATEGY_SW_CONTEXT_SWITCHES;\n}\n\nContextSwitchEventStrategy ContextSwitchEvent::strategy() {\n static ContextSwitchEventStrategy strat = init_strategy();\n return strat;\n}\n\nbool ContextSwitchEvent::init(ScopedFd tracee_fd) {\n tracee_fd_ = std::move(tracee_fd);\n if (strategy() == ContextSwitchEventStrategy::STRATEGY_RECORD_SWITCH) {\n mmap_buffer = make_unique();\n bool ok = false;\n mmap_buffer->allocate(tracee_fd_, page_size(), 0, &ok);\n return ok;\n }\n return true;\n}\n\nvoid ContextSwitchEvent::drain_events() {\n if (mmap_buffer) {\n while (auto packet = mmap_buffer->next_packet()) {\n }\n }\n}\n\n} // namespace rr\n" }, { "path": "src/ContextSwitchEvent.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_CONTEXT_SWITCH_EVENT_H_\n#define RR_CONTEXT_SWITCH_EVENT_H_\n\n#include \n\n#include \n\n#include \"PerfCounterBuffers.h\"\n#include \"ScopedFd.h\"\n#include \"preload/preload_interface.h\"\n\nnamespace rr {\n\n/**\n * For syscall buffering, we need to interrupt a tracee when it would block.\n * We do this by configuring a perf event to detect when the tracee is subject\n * to a context switch. When the perf event fires, it delivers a signal to the\n * tracee. The tracee syscallbuf code allocates the event fd and rr retrieves\n * it. We do it that way because both the tracee and rr need access to the\n * event fd.\n *\n * We can use `PERF_COUNT_SW_CONTEXT_SWITCHES` as the event. This is easy but\n * since it's a kernel event, unprivileged rr can't use it when\n * `perf_event_paranoid` is >= 2.\n *\n * Alternatively we can configure a dummy event and observe `PERF_RECORD_SWITCH`\n * records. This works with unprivileged rr when `perf_event_paranoid` == 2.\n * To trigger a signal when we get a `PERF_RECORD_SWITCH`, we set\n * `wakeup_watermark` so that appending any record to the ring buffer triggers\n * a wakeup. This requries configuring a ring buffer per tracee task; we can't\n * use a single ring buffer for multiple tracees, since when a tracee blocks\n * we need to send a signal directly to that specific tracee, not any others\n * and not rr. (We could deliver to rr and have rr interrupt the right tracee\n * but that would be slow.)\n * Unfortunately, in Linux kernels before 6.10, `watermark_wakeup` doesn't\n * trigger signals associated with the event fd. This bug was fixed in 6.10.\n *\n * So this class manages all the necessary logic. In particular we have to figure\n * out which strategy to use. We prefer to use `PERF_COUNT_SW_CONTEXT_SWITCHES`\n * if possible since we don't have to allocate ring buffers for those, so we'll\n * first check if that works. If it doesn't, we'll test if `PERF_RECORD_SWITCH`\n * works properly. If it doesn't, we produce the right error message and abort.\n * Then, if we're using `PERF_RECORD_SWITCH`, we need to allocate the ring buffer\n * and configure `wakeup_watermark`.\n */\nclass ContextSwitchEvent {\npublic:\n bool init(ScopedFd tracee_fd);\n\n ScopedFd& tracee_fd() { return tracee_fd_; }\n\n // We need to determine the strategy before we configure syscallbuf to create\n // its tracee perf event fds.\n static ContextSwitchEventStrategy strategy();\n\n void drain_events();\n\nprivate:\n // The fd retrieved from the tracee task that created it.\n ScopedFd tracee_fd_;\n // If we're using `PERF_RECORD_SWITCH` records, the\n // buffer we're using to trigger the watermark-wakeups.\n std::unique_ptr mmap_buffer;\n};\n\n} // namespace rr\n\n#endif /* RR_CONTEXT_SWITCH_EVENT_H_ */\n" }, { "path": "src/DebuggerExtensionCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DebuggerExtensionCommand.h\"\n\n#include \"ReplayTask.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstatic SimpleDebuggerExtensionCommand elapsed_time(\n \"elapsed-time\",\n \"Print elapsed time (in seconds) since the start of the trace, in the\"\n \" 'record' timeline.\",\n [](GdbServer&, Task* t, const vector&) {\n if (!t->session().is_replaying()) {\n return DebuggerExtensionCommandHandler::cmd_end_diversion();\n }\n\n ReplayTask* replay_t = static_cast(t);\n double elapsed_time = replay_t->current_trace_frame().monotonic_time() -\n replay_t->session().get_trace_start_time();\n\n return string(\"Elapsed Time (s): \") + to_string(elapsed_time);\n });\n\nstatic SimpleDebuggerExtensionCommand when(\n \"when\", \"Print the number of the last completely replayed rr event.\",\n [](GdbServer&, Task* t, const vector&) {\n if (!t->session().is_replaying()) {\n return DebuggerExtensionCommandHandler::cmd_end_diversion();\n }\n // The current event has not been completely replayed, so\n // we report the number of the previuos event.\n return string(\"Completed event: \") +\n to_string(\n static_cast(t)->current_trace_frame().time() - 1);\n });\n\nstatic SimpleDebuggerExtensionCommand when_ticks(\n \"when-ticks\", \"Print the current rr tick count for the current thread.\",\n [](GdbServer&, Task* t, const vector&) {\n if (!t->session().is_replaying()) {\n return DebuggerExtensionCommandHandler::cmd_end_diversion();\n }\n return string(\"Current tick: \") + to_string(t->tick_count());\n });\n\nstatic SimpleDebuggerExtensionCommand when_tid(\n \"when-tid\", \"Print the real tid for the current thread.\",\n [](GdbServer&, Task* t, const vector&) {\n if (!t->session().is_replaying()) {\n return DebuggerExtensionCommandHandler::cmd_end_diversion();\n }\n return string(\"Current tid: \") + to_string(t->tid);\n });\n\nstatic std::vector back_stack;\nstatic ReplayTimeline::Mark current_history_cp;\nstatic std::vector forward_stack;\nstatic SimpleDebuggerExtensionCommand rr_history_push(\n \"rr-history-push\", \"Push an entry into the rr history.\",\n [](GdbServer& gdb_server, Task* t, const vector&) {\n if (!gdb_server.timeline()) {\n return string(\"Command requires a full debugging session.\");\n }\n if (!t->session().is_replaying()) {\n // Don't create new history state inside a diversion\n return string();\n }\n if (current_history_cp) {\n back_stack.push_back(current_history_cp);\n }\n current_history_cp = gdb_server.timeline()->mark();\n forward_stack.clear();\n return string();\n });\nstatic SimpleDebuggerExtensionCommand back(\n \"back\", \"Go back one entry in the rr history.\",\n [](GdbServer& gdb_server, Task* t, const vector&) {\n if (!gdb_server.timeline()) {\n return string(\"Command requires a full debugging session.\");\n }\n if (!t->session().is_replaying()) {\n return DebuggerExtensionCommandHandler::cmd_end_diversion();\n }\n if (back_stack.size() == 0) {\n return string(\"Can't go back. No more history entries.\");\n }\n forward_stack.push_back(current_history_cp);\n current_history_cp = back_stack.back();\n back_stack.pop_back();\n gdb_server.timeline()->seek_to_mark(current_history_cp);\n return string();\n });\nstatic SimpleDebuggerExtensionCommand forward(\n \"forward\", \"Go forward one entry in the rr history.\",\n [](GdbServer& gdb_server, Task* t, const vector&) {\n if (!gdb_server.timeline()) {\n return string(\"Command requires a full debugging session.\");\n }\n if (!t->session().is_replaying()) {\n return DebuggerExtensionCommandHandler::cmd_end_diversion();\n }\n if (forward_stack.size() == 0) {\n return string(\"Can't go forward. No more history entries.\");\n }\n back_stack.push_back(current_history_cp);\n current_history_cp = forward_stack.back();\n forward_stack.pop_back();\n gdb_server.timeline()->seek_to_mark(current_history_cp);\n return string();\n });\n\nstatic int gNextCheckpointId = 0;\n\nstring invoke_checkpoint(GdbServer& gdb_server, Task*,\n const vector& args) {\n if (!gdb_server.timeline()) {\n return string(\"Command requires a full debugging session.\");\n }\n const string& where = args[0];\n if (gdb_server.in_debuggee_end_state) {\n return string(\"The program is not being run.\");\n }\n int checkpoint_id = ++gNextCheckpointId;\n GdbServer::Checkpoint::Explicit e;\n if (gdb_server.timeline()->can_add_checkpoint()) {\n e = GdbServer::Checkpoint::EXPLICIT;\n } else {\n e = GdbServer::Checkpoint::NOT_EXPLICIT;\n }\n gdb_server.checkpoints[checkpoint_id] = GdbServer::Checkpoint(\n *gdb_server.timeline(), gdb_server.last_continue_task, e, where);\n return string(\"Checkpoint \") + to_string(checkpoint_id) + \" at \" + where;\n}\nstatic SimpleDebuggerExtensionCommand checkpoint(\n \"checkpoint\",\n \"create a checkpoint representing a point in the execution\\n\"\n \"use the 'restart' command to return to the checkpoint\",\n invoke_checkpoint);\n\nstring invoke_delete_checkpoint(GdbServer& gdb_server, Task*,\n const vector& args) {\n if (args.size() < 1) {\n return \"'delete checkpoint' requires an argument\";\n }\n if (!gdb_server.timeline()) {\n return string(\"Command requires a full debugging session.\");\n }\n char* endptr;\n long id = strtol(args[0].c_str(), &endptr, 10);\n if (*endptr) {\n return string(\"Invalid checkpoint number \") + args[0] + \".\";\n }\n auto it = gdb_server.checkpoints.find(id);\n if (it != gdb_server.checkpoints.end()) {\n if (it->second.is_explicit == GdbServer::Checkpoint::EXPLICIT) {\n gdb_server.timeline()->remove_explicit_checkpoint(it->second.mark);\n }\n gdb_server.checkpoints.erase(it);\n return string(\"Deleted checkpoint \") + to_string(id) + \".\";\n } else {\n return string(\"No checkpoint number \") + to_string(id) + \".\";\n }\n}\nstatic SimpleDebuggerExtensionCommand delete_checkpoint(\n \"delete checkpoint\",\n \"remove a checkpoint created with the 'checkpoint' command\",\n invoke_delete_checkpoint);\n\nstring invoke_info_checkpoints(GdbServer& gdb_server, Task*,\n const vector&) {\n if (gdb_server.checkpoints.size() == 0) {\n return \"No checkpoints.\";\n }\n string out = \"ID\\tWhen\\tWhere\";\n for (auto& c : gdb_server.checkpoints) {\n out += string(\"\\n\") + to_string(c.first) + \"\\t\" +\n to_string(c.second.mark.time()) + \"\\t\" + c.second.where;\n }\n return out;\n}\nstatic SimpleDebuggerExtensionCommand info_checkpoints(\n \"info checkpoints\",\n \"list all checkpoints created with the 'checkpoint' command\",\n invoke_info_checkpoints);\n\nvoid DebuggerExtensionCommand::init_auto_args() {\n static __attribute__((unused)) int dummy = []() {\n checkpoint.add_auto_arg(\"rr-where\");\n return 0;\n }();\n}\n\n} // namespace rr\n" }, { "path": "src/DebuggerExtensionCommand.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DEBUGGER_EXTENSION_COMMAND_H_\n#define RR_DEBUGGER_EXTENSION_COMMAND_H_\n\n#include \"DebuggerExtensionCommandHandler.h\"\n#include \"GdbServer.h\"\n\n#include \n#include \n#include \n\nnamespace rr {\n\nclass DebuggerExtensionCommand {\nprotected:\n DebuggerExtensionCommand(const std::string& cmd_name, const std::string& documentation)\n : cmd_name(cmd_name), documentation(documentation) {\n DebuggerExtensionCommandHandler::register_command(*this);\n }\n\npublic:\n virtual ~DebuggerExtensionCommand() {}\n\n const std::string& name() const { return cmd_name; }\n const std::string& docs() const { return documentation; }\n\n /**\n * Handle the RR Cmd and return a string response to be echo'd\n * to the user.\n *\n * NOTE: args[0] is the command name\n */\n virtual std::string invoke(GdbServer& gdb_server, Task* t,\n const std::vector& args) = 0;\n\n /**\n * When called, gdb will automatically run gdb.execute() on this string and\n * pass it as an argument to the rr command. This is useful to pass gdb\n * state alongside the command invocation.\n */\n void add_auto_arg(const std::string& auto_arg) {\n cmd_auto_args.push_back(auto_arg);\n }\n\n const std::vector& auto_args() const { return cmd_auto_args; }\n\n /**\n * Setup all the automatic auto_args for our commands.\n */\n static void init_auto_args();\n\nprivate:\n const std::string cmd_name;\n const std::string documentation;\n std::vector cmd_auto_args;\n};\n\nclass SimpleDebuggerExtensionCommand : public DebuggerExtensionCommand {\npublic:\n SimpleDebuggerExtensionCommand(\n const std::string& cmd_name, const std::string& documentation,\n const std::function&)>& invoker)\n : DebuggerExtensionCommand(cmd_name, documentation), invoker(invoker) {}\n\n virtual std::string invoke(GdbServer& gdb_server, Task* t,\n const std::vector& args) override {\n return invoker(gdb_server, t, args);\n }\n\n std::function&)>\n invoker;\n};\n\n} // namespace rr\n\n#endif /* RR_DEBUGGER_EXTENSION_COMMAND_H_ */\n" }, { "path": "src/DebuggerExtensionCommandHandler.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DebuggerExtensionCommandHandler.h\"\n#include \"DebuggerExtensionCommand.h\"\n#include \"log.h\"\n\n#include \n#include \n\nusing namespace std;\n\nnamespace rr {\n\n// HashMap would be better here but the unordered_map API is annoying\n// and linear search is fine.\nstatic vector* debugger_command_list;\n\nstatic void print_python_string_array(ostream& out, const std::vector& strs) {\n out << \"[\";\n for (size_t i = 0; i < strs.size(); i++) {\n if (i > 0) {\n out << \", \";\n }\n out << \"'\" << strs[i] << \"'\";\n }\n out << \"]\";\n}\n\nstatic void gdb_macro_binding(ostream& out, const DebuggerExtensionCommand& cmd) {\n out << \"python RRCmd('\" << cmd.name() << \"', \";\n print_python_string_array(out, cmd.auto_args());\n out << \")\\n\";\n if (!cmd.docs().empty()) {\n out << \"document \" << cmd.name() << \"\\n\" << cmd.docs() << \"\\nend\\n\";\n }\n}\n\nstatic const char shared_python[] = R\"Delimiter(\ndef hex_unescape(string):\n str_len = len(string)\n if str_len % 2: # check for unexpected string length\n return \"\"\n result = bytearray()\n try:\n pos = 0\n while pos < str_len:\n hex_char = string[pos:pos+2]\n result.append(int(hex_char, 16))\n pos += 2\n except: # check for unexpected string value\n return \"\"\n return result.decode('utf-8')\n\ndef hex_escape(string):\n result = \"\"\n for curr_char in string.encode('utf-8'):\n if isinstance(curr_char, str):\n curr_char = ord(curr_char)\n result += format(curr_char, '02x')\n return result\n)Delimiter\";\n\nstring DebuggerExtensionCommandHandler::gdb_macros() {\n DebuggerExtensionCommand::init_auto_args();\n stringstream ss;\n ss << R\"Delimiter(set python print-stack full\npython\nimport re\n)Delimiter\"\n << shared_python\n << R\"Delimiter(\nclass RRWhere(gdb.Command):\n \"\"\"Helper to get the location for checkpoints/history. Used by auto-args\"\"\"\n def __init__(self):\n gdb.Command.__init__(self, 'rr-where',\n gdb.COMMAND_USER, gdb.COMPLETE_NONE, False)\n\n def invoke(self, arg, from_tty):\n#Get the symbol name from 'frame 0' in the format:\n# '#0 0x00007f9d81a04c46 in _dl_start (arg=0x7ffee1f1c740) at rtld.c:356\n# 356 in rtld.c'\n try:\n rv = gdb.execute('frame 0', to_string=True)\n except:\n rv = \"???\" # This may occurs if we're not running\n m = re.match(r\"#0\\w*(.*)\", rv);\n if m:\n rv = m.group(1)\n else:\n rv = rv + \"???\"\n gdb.write(rv)\n\nRRWhere()\n\nclass RRDenied(gdb.Command):\n \"\"\"Helper to prevent use of breaking commands. Used by auto-args\"\"\"\n def __init__(self):\n gdb.Command.__init__(self, 'rr-denied',\n gdb.COMMAND_USER, gdb.COMPLETE_NONE, False)\n\n def invoke(self, arg, from_tty):\n raise gdb.GdbError(\"Execution of '\" + arg + \"' is not possible in recorded executions.\")\n\nRRDenied()\n\nclass RRCmd(gdb.Command):\n def __init__(self, name, auto_args):\n gdb.Command.__init__(self, name,\n gdb.COMMAND_USER, gdb.COMPLETE_NONE, False)\n self.cmd_name = name\n self.auto_args = auto_args\n\n def invoke(self, arg, from_tty):\n args = gdb.string_to_argv(arg)\n self.rr_cmd(args)\n\n def rr_cmd(self, args):\n # Ensure gdb tells rr its current thread\n curr_thread = gdb.selected_thread()\n cmd_prefix = (\"maint packet qRRCmd:%s:%d\"%\n (self.cmd_name, -1 if curr_thread is None else curr_thread.ptid[1]))\n arg_strs = []\n for auto_arg in self.auto_args:\n arg_strs.append(\":\" + hex_escape(gdb.execute(auto_arg, to_string=True)))\n for arg in args:\n arg_strs.append(\":\" + hex_escape(arg))\n rv = gdb.execute(cmd_prefix + ''.join(arg_strs), to_string=True);\n rv_match = re.search('received: \"(.*)\"', rv, re.MULTILINE);\n if not rv_match:\n gdb.write(\"Response error: \" + rv)\n return\n response = hex_unescape(rv_match.group(1))\n if response != '\\n':\n gdb.write(response)\n\ndef history_push(p):\n # ensure any output (e.g. produced by breakpoint commands running during our\n # processing, that were triggered by the stop we've been notified for)\n # is echoed as normal.\n gdb.execute(\"rr-history-push\")\n\nrr_suppress_run_hook = False\n\nclass RRHookRun(gdb.Command):\n def __init__(self):\n gdb.Command.__init__(self, 'rr-hook-run',\n gdb.COMMAND_USER, gdb.COMPLETE_NONE, False)\n \n def invoke(self, arg, from_tty): \n thread = int(gdb.parse_and_eval(\"$_thread\"))\n if thread != 0 and not rr_suppress_run_hook:\n gdb.execute(\"stepi\")\n \nclass RRSetSuppressRunHook(gdb.Command):\n def __init__(self):\n gdb.Command.__init__(self, 'rr-set-suppress-run-hook',\n gdb.COMMAND_USER, gdb.COMPLETE_NONE, False)\n \n def invoke(self, arg, from_tty):\n rr_suppress_run_hook = arg == '1'\n\nRRHookRun()\nRRSetSuppressRunHook()\n\n#Automatically push an history entry when the program execution stops\n#(signal, breakpoint).This is fired before an interactive prompt is shown.\n#Disabled for now since it's not fully working.\ngdb.events.stop.connect(history_push)\n\nend\n)Delimiter\";\n\n if (debugger_command_list) {\n for (auto& it : *debugger_command_list) {\n gdb_macro_binding(ss, *it);\n }\n }\n\n ss << string(R\"Delimiter(\ndefine hookpost-back\nmaintenance flush register-cache\nframe\nend\n\ndefine hookpost-forward\nmaintenance flush register-cache\nframe\nend\n)Delimiter\");\n\n return ss.str();\n}\n\nstatic void lldb_macro_binding(ostream& def_stream, ostream& call_stream,\n const string* module_name,\n const DebuggerExtensionCommand& cmd) {\n string func_name = \"rr_command_\";\n for (char ch : cmd.name()) {\n if (ch == ' ') {\n // We don't support commands with spaces in LLDB yet\n return;\n }\n if (ch == '-') {\n ch = '_';\n }\n func_name.push_back(ch);\n }\n def_stream << \"def \" << func_name << \"(debugger, command, exe_ctx, result, internal_dict):\\n\";\n if (!cmd.docs().empty()) {\n def_stream << \" \\\"\\\"\\\"\" << cmd.docs() << \"\\\"\\\"\\\"\\n\";\n }\n def_stream << \" cmd_name = '\" << cmd.name() << \"'\\n\"\n << \" auto_args = \";\n print_python_string_array(def_stream, cmd.auto_args());\n def_stream << \"\\n\"\n << \" command_impl(debugger, command, exe_ctx, result, cmd_name, auto_args)\\n\"\n << \"\\n\";\n call_stream << \" debugger.HandleCommand('command script add -f \";\n if (module_name) {\n call_stream << *module_name << \".\";\n }\n call_stream << func_name << \" \" << cmd.name() << \"')\\n\";\n}\n\nDebuggerExtensionCommandHandler::LldbCommands\nDebuggerExtensionCommandHandler::lldb_python_macros(const string* module_name) {\n DebuggerExtensionCommand::init_auto_args();\n stringstream ss;\n ss << R\"Delimiter(import lldb\nimport re\nimport shlex\n)Delimiter\"\n << shared_python\n << R\"Delimiter(\ndef run_command_and_get_output(debugger, command):\n result = lldb.SBCommandReturnObject()\n debugger.GetCommandInterpreter().HandleCommand(command, result)\n assert result.Succeeded()\n return result.GetOutput()\n\ndef command_impl(debugger, command, exe_ctx, result, cmd_name, auto_args):\n interpreter = debugger.GetCommandInterpreter()\n args = shlex.split(command)\n # Ensure lldb tells rr its current thread\n curr_thread = exe_ctx.thread\n cmd_prefix = (\"process plugin packet send qRRCmd:%s:%d\"%\n (cmd_name, -1 if curr_thread is None else curr_thread.GetThreadID()))\n arg_strs = []\n for auto_arg in auto_args:\n arg_strs.append(\":\" + hex_escape(run_command_and_get_output(debugger, auto_arg)))\n for arg in args:\n arg_strs.append(\":\" + hex_escape(arg))\n rv = run_command_and_get_output(debugger, cmd_prefix + ''.join(arg_strs));\n rv_match = re.search('response: (.*)$', rv, re.MULTILINE);\n if not rv_match:\n result.SetError(None, \"Invalid response: %s\" % rv)\n return\n response = hex_unescape(rv_match.group(1))\n result.Print(response.strip())\n\n)Delimiter\";\n\n stringstream call_stream;\n if (debugger_command_list) {\n for (auto& it : *debugger_command_list) {\n lldb_macro_binding(ss, call_stream, module_name, *it);\n }\n }\n LldbCommands cmds;\n cmds.toplevel_definitions = ss.str();\n cmds.run_on_startup = call_stream.str();\n return cmds;\n}\n\n/*static*/ DebuggerExtensionCommand* DebuggerExtensionCommandHandler::command_for_name(const string& name) {\n if (!debugger_command_list) {\n return nullptr;\n }\n for (auto& it : *debugger_command_list) {\n if (it->name() == name) {\n return it;\n }\n }\n return nullptr;\n}\n\nvoid DebuggerExtensionCommandHandler::register_command(DebuggerExtensionCommand& cmd) {\n LOG(debug) << \"registering command: \" << cmd.name();\n if (!debugger_command_list) {\n debugger_command_list = new vector();\n }\n debugger_command_list->push_back(&cmd);\n}\n\n// applies the simplest two hex character by byte encoding\nstatic string hex_escape(const string& str) {\n stringstream ss;\n ss << hex;\n const size_t len = str.size();\n const char *data = str.data();\n for (size_t i = 0; i < len; i++) {\n int chr = (uint8_t)data[i];\n if (chr < 16) {\n ss << \"0\";\n }\n ss << chr;\n }\n return ss.str();\n}\n// undo the two hex character byte encoding,\n// in case of error returns an empty string\nstatic string hex_unescape(const string& str) {\n const size_t len = str.size();\n // check for unexpected string length\n if (len % 2) {\n return \"\";\n }\n stringstream ss;\n for (size_t i = 0; i < len; i += 2) {\n string substr = str.substr(i, 2);\n const char *hex_str = substr.c_str();\n char *ptr = nullptr;\n ss << (char)strtoul(hex_str, &ptr, 16);\n // check for unexpected character\n if (*ptr) {\n return \"\";\n }\n }\n return ss.str();\n}\n\n/* static */ string DebuggerExtensionCommandHandler::process_command(GdbServer& gdb_server,\n Task* t,\n const GdbRequest::RRCmd& rr_cmd) {\n vector args;\n for (const auto& arg : rr_cmd.args) {\n args.push_back(hex_unescape(arg));\n }\n\n DebuggerExtensionCommand* cmd = command_for_name(rr_cmd.name);\n if (!cmd) {\n return hex_escape(string() + \"Command '\" + rr_cmd.name + \"' not found.\\n\");\n }\n LOG(debug) << \"invoking command: \" << cmd->name();\n Task* target = t->session().find_task(rr_cmd.target_tid);\n \n // perhaps not the best option, but better than a nullptr\n if (target == nullptr) target = t;\n \n string resp = cmd->invoke(gdb_server, target, args);\n\n if (resp == DebuggerExtensionCommandHandler::cmd_end_diversion()) {\n LOG(debug) << \"cmd must run outside of diversion (\" << resp << \")\";\n return resp;\n }\n\n LOG(debug) << \"cmd response: \" << resp;\n return hex_escape(resp + \"\\n\");\n}\n\n} // namespace rr\n" }, { "path": "src/DebuggerExtensionCommandHandler.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DEBUGGER_EXTENSION_COMMAND_HANDLER_H_\n#define RR_DEBUGGER_EXTENSION_COMMAND_HANDLER_H_\n\n#include \n\n#include \"GdbServerConnection.h\"\n\nnamespace rr {\n\nclass DebuggerExtensionCommand;\nclass GdbServer;\nclass Task;\n\n/**\n * rr extends debuggers (GDB, LLDB) with custom commands such as `when`.\n * This class manages those commands.\n */\nclass DebuggerExtensionCommandHandler {\npublic:\n // Declare any registered command with supporting\n // wrapper code --- GDB script.\n static std::string gdb_macros();\n\n // Declare any registered command with supporting\n // wrapper code --- LLDB Python script.\n struct LldbCommands {\n std::string toplevel_definitions;\n // 2-space-indented code to run on startup.\n std::string run_on_startup;\n };\n static LldbCommands lldb_python_macros(const string* module_name);\n\n static void register_command(DebuggerExtensionCommand& cmd);\n\n /**\n * Process an incoming debugger payload of the following form:\n * :::...\n *\n * NOTE: RR Command are typically sent with the qRRCmd: prefix which\n * should of been striped already.\n */\n static std::string process_command(GdbServer& gdb_server, Task* t,\n const GdbRequest::RRCmd& rr_cmd);\n\n static DebuggerExtensionCommand* command_for_name(const std::string& name);\n\n /**\n * Special return value for commands that immediately end a diversion session\n */\n static std::string cmd_end_diversion() {\n return std::string(\"RRCmd_EndDiversion\");\n }\n\nprivate:\n};\n\n} // namespace rr\n\n#endif /* RR_DEBUGGER_EXTENSION_COMMAND_HANDLER_H_ */\n" }, { "path": "src/DiversionSession.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DiversionSession.h\"\n\n#include \n\n#include \"AutoRemoteSyscalls.h\"\n#include \"ReplaySession.h\"\n#include \"core.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nDiversionSession::DiversionSession(BindCPU cpu_binding) :\n emu_fs(EmuFs::create()), fake_timer_counter(uint64_t(1) << 60), cpu_binding_(cpu_binding) {}\n\nDiversionSession::~DiversionSession() {\n // We won't permanently leak any OS resources by not ensuring\n // we've cleaned up here, but sessions can be created and\n // destroyed many times, and we don't want to temporarily hog\n // resources.\n kill_all_tasks();\n DEBUG_ASSERT(tasks().size() == 0 && vms().size() == 0);\n DEBUG_ASSERT(emu_fs->size() == 0);\n}\n\nstatic void finish_emulated_syscall_with_ret(Task* t, long ret) {\n t->finish_emulated_syscall();\n Registers r = t->regs();\n r.set_syscall_result(ret);\n t->set_regs(r);\n}\n\n/**\n * Execute the syscall contained in |t|'s current register set. The\n * return value of the syscall is set for |t|'s registers, to be\n * returned to the tracee task.\n */\nstatic void execute_syscall(Task* t) {\n t->finish_emulated_syscall();\n\n AutoRemoteSyscalls remote(t);\n remote.syscall(remote.regs().original_syscallno(), remote.regs().arg1(),\n remote.regs().arg2(), remote.regs().arg3(),\n remote.regs().arg4(), remote.regs().arg5(),\n remote.regs().arg6());\n remote.regs().set_syscall_result(t->regs().syscall_result());\n}\n\nuint64_t DiversionSession::next_timer_counter() {\n uint64_t value = fake_timer_counter;\n fake_timer_counter += 1 << 20; // 1M cycles\n return value;\n}\n\ntemplate \nstatic void process_syscall_arch(Task* t, int syscallno) {\n LOG(debug) << \"Processing \" << syscall_name(syscallno, Arch::arch());\n\n if (syscallno == Arch::ioctl && t->is_desched_event_syscall()) {\n // The arm/disarm-desched ioctls are emulated as no-ops.\n // However, because the rr preload library expects these\n // syscalls to succeed and aborts if they don't, we fudge a\n // \"0\" return value.\n finish_emulated_syscall_with_ret(t, 0);\n return;\n }\n\n if (syscallno == t->session().syscall_number_for_rrcall_rdtsc()) {\n uint64_t rdtsc_value = static_cast(&t->session())->next_timer_counter();\n LOG(debug) << \"Faking rrcall_rdtsc syscall with value \" << rdtsc_value;\n remote_ptr out_param(t->regs().arg1());\n t->write_mem(out_param, rdtsc_value);\n finish_emulated_syscall_with_ret(t, 0);\n return;\n }\n\n switch (syscallno) {\n // We blacklist these syscalls because the params include\n // namespaced identifiers that are different in replay than\n // recording, and during replay they may refer to different,\n // live resources. For example, if a recorded tracees kills\n // one of its threads, then during replay that killed pid\n // might refer to a live process outside the tracee tree. We\n // don't want diversion tracees randomly shooting down other\n // processes!\n //\n // We optimistically assume that filesystem operations were\n // intended by the user.\n //\n // There's a potential problem with \"fd confusion\": in the\n // diversion tasks, fds returned from open() during replay are\n // emulated. But those fds may accidentally refer to live fds\n // in the task fd table. So write()s etc may not be writing\n // to the file the tracee expects. However, the only real fds\n // that leak into tracees are the stdio fds, and there's not\n // much harm that can be caused by accidental writes to them.\n case Arch::ipc:\n case Arch::kill:\n case Arch::rt_sigqueueinfo:\n case Arch::rt_tgsigqueueinfo:\n case Arch::tgkill:\n case Arch::tkill:\n // fork/vfork/clone are likely to lead to disaster because we only\n // ever allow a single task to run.\n case Arch::fork:\n case Arch::vfork:\n case Arch::clone: {\n LOG(debug) << \"Suppressing syscall \"\n << syscall_name(syscallno, t->arch());\n Registers r = t->regs();\n r.set_syscall_result(-ENOSYS);\n t->set_regs(r);\n return;\n }\n\n case Arch::prctl: {\n Registers r = t->regs();\n int op = r.arg1();\n if (op == PR_SET_TSC) {\n LOG(debug) << \"Suppressing syscall \"\n << syscall_name(syscallno, t->arch());\n r.set_syscall_result(-ENOSYS);\n t->set_regs(r);\n return;\n }\n break;\n }\n\n case Arch::gettid: {\n auto tid = t->own_namespace_tid();\n LOG(debug) << \"Emulating gettid with \" << tid;\n Registers r = t->regs();\n r.set_syscall_result(tid);\n t->set_regs(r);\n return;\n }\n\n case Arch::getpid: {\n auto pid = t->thread_group()->tgid_own_namespace;\n LOG(debug) << \"Emulating getpid with \" << pid;\n Registers r = t->regs();\n r.set_syscall_result(pid);\n t->set_regs(r);\n return;\n }\n }\n\n LOG(debug) << \"Executing syscall \" << syscall_name(syscallno, t->arch());\n execute_syscall(t);\n}\n\nstatic void process_syscall(Task* t, int syscallno){\n RR_ARCH_FUNCTION(process_syscall_arch, t->arch(), t, syscallno)\n}\n\nstatic bool maybe_handle_task_exit(Task* t, TaskContext* context,\n DiversionSession::DiversionResult* result) {\n if (t->ptrace_event() != PTRACE_EVENT_EXIT && !t->was_reaped()) {\n return false;\n }\n t->did_kill();\n t->detach();\n delete t;\n // This is now a dangling pointer, so clear it.\n context->task = nullptr;\n result->status = DiversionSession::DIVERSION_EXITED;\n result->break_status.task_context = *context;\n result->break_status.task_exit = true;\n return true;\n}\n\n/**\n * Advance execution until either a signal is received (including a SIGTRAP\n * generated by a single-step) or a syscall is made.\n */\nDiversionSession::DiversionResult DiversionSession::diversion_step(\n Task* t, RunCommand command, int signal_to_deliver) {\n DEBUG_ASSERT(command != RUN_SINGLESTEP_FAST_FORWARD);\n assert_fully_initialized();\n\n DiversionResult result;\n TaskContext context(t);\n\n // An exit might have occurred while processing a previous syscall.\n if (maybe_handle_task_exit(t, &context, &result)) {\n return result;\n }\n\n t->set_in_diversion(true);\n\n while (true) {\n switch (command) {\n case RUN_CONTINUE: {\n LOG(debug) << \"Continuing to next syscall\";\n bool ok = t->resume_execution(RESUME_SYSEMU, RESUME_WAIT,\n RESUME_UNLIMITED_TICKS, signal_to_deliver);\n ASSERT(t, ok) << \"Tracee was killed unexpectedly\";\n break;\n }\n case RUN_SINGLESTEP: {\n LOG(debug) << \"Stepping to next insn/syscall\";\n bool ok = t->resume_execution(RESUME_SYSEMU_SINGLESTEP, RESUME_WAIT,\n RESUME_UNLIMITED_TICKS, signal_to_deliver);\n ASSERT(t, ok) << \"Tracee was killed unexpectedly\";\n break;\n }\n default:\n FATAL() << \"Illegal run command \" << command;\n }\n\n if (maybe_handle_task_exit(t, &context, &result)) {\n return result;\n }\n\n result.status = DIVERSION_CONTINUE;\n if (t->stop_sig()) {\n LOG(debug) << \"Pending signal: \" << t->get_siginfo();\n result.break_status = diagnose_debugger_trap(t, command);\n if (t->stop_sig() == SIGTRAP &&\n !result.break_status.breakpoint_hit &&\n result.break_status.watchpoints_hit.empty() &&\n !result.break_status.singlestep_complete) {\n result.break_status.signal = unique_ptr(new siginfo_t(t->get_siginfo()));\n result.break_status.signal->si_signo = t->stop_sig();\n } else if (t->stop_sig() == SIGSEGV) {\n auto special_instruction = special_instruction_at(t, t->ip());\n if (special_instruction.opcode == SpecialInstOpcode::X86_RDTSC) {\n size_t len = special_instruction_len(special_instruction.opcode);\n uint64_t rdtsc_value = next_timer_counter();\n LOG(debug) << \"Faking RDTSC instruction with value \" << rdtsc_value;\n Registers r = t->regs();\n r.set_ip(r.ip() + len);\n r.set_ax((uint32_t)rdtsc_value);\n r.set_dx(rdtsc_value >> 32);\n t->set_regs(r);\n result.break_status = BreakStatus();\n continue;\n } else if (special_instruction.opcode == SpecialInstOpcode::ARM_MRS_CNTVCT_EL0 ||\n special_instruction.opcode == SpecialInstOpcode::ARM_MRS_CNTVCTSS_EL0) {\n size_t len = special_instruction_len(special_instruction.opcode);\n uint64_t cntvct_value = next_timer_counter();\n Registers r = t->regs();\n r.set_ip(r.ip() + len);\n if (special_instruction.regno != 31) {\n r.set_x(special_instruction.regno, cntvct_value);\n }\n t->set_regs(r);\n result.break_status = BreakStatus();\n continue;\n } else if (special_instruction.opcode == SpecialInstOpcode::ARM_MRS_CNTFRQ_EL0) {\n size_t len = special_instruction_len(special_instruction.opcode);\n Registers r = t->regs();\n r.set_ip(r.ip() + len);\n if (special_instruction.regno != 31) {\n r.set_x(special_instruction.regno, cntfrq());\n }\n t->set_regs(r);\n result.break_status = BreakStatus();\n continue;\n }\n }\n LOG(debug) << \"Diversion break at ip=\" << (void*)t->ip().register_value()\n << \"; break=\" << result.break_status.breakpoint_hit\n << \", watch=\" << !result.break_status.watchpoints_hit.empty()\n << \", singlestep=\" << result.break_status.singlestep_complete;\n ASSERT(t,\n !result.break_status.singlestep_complete ||\n command == RUN_SINGLESTEP);\n return result;\n }\n break;\n }\n\n if (t->status().is_syscall()) {\n t->apply_syscall_entry_regs();\n }\n\n process_syscall(t, t->regs().original_syscallno());\n check_for_watchpoint_changes(t, result.break_status);\n return result;\n}\n\n} // namespace rr\n" }, { "path": "src/DiversionSession.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DIVERSION_SESSION_H_\n#define RR_DIVERSION_SESSION_H_\n\n#include \"EmuFs.h\"\n#include \"Session.h\"\n\nnamespace rr {\n\nclass ReplaySession;\n\n/**\n * A DiversionSession lets you run task(s) forward without replay.\n * Clone a ReplaySession to a DiversionSession to execute some arbitrary\n * code for its side effects.\n *\n * Diversion allows tracees to execute freely, as in \"recorder\"\n * mode, but doesn't attempt to record any data. Diverter\n * emulates the syscalls it's able to (such as writes to stdio fds),\n * and essentially ignores the syscalls it doesn't know how to\n * implement. Tracees can easily get into inconsistent states within\n * diversion mode, and no attempt is made to detect or rectify that.\n *\n * Diverter mode is designed to support short-lived diversions from\n * \"replayer\" sessions, as required to support gdb's |call foo()|\n * feature. A diversion is created for the call frame, then discarded\n * when the call finishes (loosely speaking).\n */\nclass DiversionSession final : public Session {\npublic:\n DiversionSession(BindCPU cpu_binding);\n\n typedef std::shared_ptr shr_ptr;\n\n ~DiversionSession();\n\n EmuFs& emufs() const { return *emu_fs; }\n\n enum DiversionStatus {\n // Some execution was done. diversion_step() can be called again.\n DIVERSION_CONTINUE,\n // All tracees are dead. diversion_step() should not be called again.\n DIVERSION_EXITED\n };\n struct DiversionResult {\n DiversionStatus status;\n BreakStatus break_status;\n };\n /**\n * Try make progress in this diversion session. Run task t if possible.\n */\n DiversionResult diversion_step(Task* t, RunCommand command = RUN_CONTINUE,\n int signal_to_deliver = 0);\n\n virtual DiversionSession* as_diversion() override { return this; }\n virtual BindCPU cpu_binding() const override { return cpu_binding_; }\n\n void set_tracee_fd_number(int fd_number) { tracee_socket_fd_number = fd_number; }\n void on_create(Task *t) override { this->Session::on_create(t); }\n\n uint64_t next_timer_counter();\n\nprivate:\n friend class ReplaySession;\n\n std::shared_ptr emu_fs;\n uint64_t fake_timer_counter;\n BindCPU cpu_binding_;\n};\n\n} // namespace rr\n\n#endif // RR_DIVERSION_SESSION_H_\n" }, { "path": "src/DumpCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"DumpCommand.h\"\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \"preload/preload_interface.h\"\n\n#include \"AddressSpace.h\"\n#include \"Command.h\"\n#include \"TraceStream.h\"\n#include \"core.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n#include \"main.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass DumpCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n DumpCommand(const char* name, const char* help) : Command(name, help) {}\n\n static DumpCommand singleton;\n};\n\nDumpCommand DumpCommand::singleton(\n \"dump\",\n \" rr dump [OPTIONS] [] [...]\\n\"\n \" Event specs can be either an event number like `127', or a range\\n\"\n \" like `1000-5000', or `end' for the last record in the trace.\\n\"\n \" By default, all events are dumped.\\n\"\n \" -b, --syscallbuf dump syscallbuf contents\\n\"\n \" -e, --task-events dump task events\\n\"\n \" -m, --recorded-metadata dump recorded data metadata\\n\"\n \" -p, --mmaps dump mmap data\\n\"\n \" -r, --raw dump trace frames in a more easily\\n\"\n \" machine-parseable format instead of the\\n\"\n \" default human-readable format\\n\"\n \" -s, --statistics dump statistics about the trace\\n\"\n \" -t, --tid= dump events only for the specified tid\\n\");\n\nstatic bool parse_dump_arg(vector& args, DumpFlags& flags) {\n if (parse_global_option(args)) {\n return true;\n }\n\n static const OptionSpec options[] = {\n { 0, \"socket-addresses\", NO_PARAMETER },\n { 'b', \"syscallbuf\", NO_PARAMETER },\n { 'e', \"task-events\", NO_PARAMETER },\n { 'm', \"recorded-metadata\", NO_PARAMETER },\n { 'p', \"mmaps\", NO_PARAMETER },\n { 'r', \"raw\", NO_PARAMETER },\n { 's', \"statistics\", NO_PARAMETER },\n { 't', \"tid\", HAS_PARAMETER },\n };\n ParsedOption opt;\n if (!Command::parse_option(args, options, &opt)) {\n return false;\n }\n\n switch (opt.short_name) {\n case 'b':\n flags.dump_syscallbuf = true;\n break;\n case 'e':\n flags.dump_task_events = true;\n break;\n case 'm':\n flags.dump_recorded_data_metadata = true;\n break;\n case 'p':\n flags.dump_mmaps = true;\n break;\n case 'r':\n flags.raw_dump = true;\n break;\n case 's':\n flags.dump_statistics = true;\n break;\n case 't':\n if (!opt.verify_valid_int(1, INT32_MAX)) {\n return false;\n }\n flags.only_tid = opt.int_value;\n break;\n case 0:\n flags.dump_socket_addrs = true;\n break;\n default:\n DEBUG_ASSERT(0 && \"Unknown option\");\n }\n return true;\n}\n\nstatic void dump_syscallbuf_data(TraceReader& trace, FILE* out,\n const TraceFrame& frame,\n const DumpFlags& flags) {\n if (frame.event().type() != EV_SYSCALLBUF_FLUSH) {\n return;\n }\n TraceReader::RawData buf;\n bool ok = trace.read_raw_data_for_frame(buf);\n if (!ok) {\n FATAL() << \"Can't read raw-data record for syscallbuf\";\n }\n size_t bytes_remaining = buf.data.size() - trace.syscallbuf_hdr_size();\n auto flush_hdr = reinterpret_cast(buf.data.data());\n if (flush_hdr->num_rec_bytes > bytes_remaining) {\n CLEAN_FATAL() << \"Malformed trace file (bad recorded-bytes count)\";\n }\n if (flags.raw_dump) {\n fprintf(out, \" \");\n for (unsigned long i = 0; i < sizeof(syscallbuf_hdr); ++i) {\n fprintf(out, \"%2.2x\", *(buf.data.data() + (uintptr_t)i));\n }\n fprintf(out, \"\\n\");\n }\n bytes_remaining = flush_hdr->num_rec_bytes;\n\n auto record_ptr = reinterpret_cast(flush_hdr) + trace.syscallbuf_hdr_size();\n auto end_ptr = record_ptr + bytes_remaining;\n while (record_ptr < end_ptr) {\n auto record = reinterpret_cast(record_ptr);\n // Buffered syscalls always use the task arch\n fprintf(out, \" { syscall:'%s', ret:0x%lx, size:0x%lx%s%s }\\n\",\n syscall_name(record->syscallno, frame.regs().arch()).c_str(),\n (long)record->ret, (long)record->size,\n record->desched ? \", desched:1\" : \"\",\n record->replay_assist ? \", replay_assist:1\" : \"\");\n if (flags.raw_dump) {\n fprintf(out, \" \");\n for (unsigned long i = 0; i < record->size; ++i) {\n fprintf(out, \"%2.2x\", *(record_ptr + (uintptr_t)i));\n }\n fprintf(out, \"\\n\");\n }\n if (record->size < sizeof(*record)) {\n CLEAN_FATAL() << \"Malformed trace file (bad record size)\";\n }\n record_ptr += stored_record_size(record->size);\n }\n if (flags.dump_mmaps) {\n for (auto& record : frame.event().SyscallbufFlush().mprotect_records) {\n fprintf(out, \" { start:%p, size:%\" PRIx64 \", prot:'%s' }\\n\",\n (void*)record.start, record.size, prot_flags_string(record.prot).c_str());\n if (flags.raw_dump) {\n fprintf(out, \" \");\n for (unsigned long i = 0; i < sizeof(record); ++i) {\n fprintf(out, \"%2.2x\", *(reinterpret_cast(&record) + (uintptr_t)i));\n }\n fprintf(out, \"\\n\");\n }\n }\n }\n}\n\nstatic void print_socket_addr(FILE* out, const struct NativeArch::sockaddr_storage& sa) {\n char buf[256];\n auto sockaddr = reinterpret_cast(&sa);\n switch (sockaddr->ss_family) {\n case AF_INET: {\n auto sockaddr_in = reinterpret_cast(sockaddr);\n if (inet_ntop(AF_INET, &sockaddr_in->sin_addr, buf, sizeof(buf) - 1)) {\n fprintf(out, \"%s:%d\", buf, sockaddr_in->sin_port);\n } else {\n FATAL();\n }\n break;\n }\n case AF_INET6: {\n auto sockaddr_in6 = reinterpret_cast(sockaddr);\n if (inet_ntop(AF_INET6, &sockaddr_in6->sin6_addr, buf, sizeof(buf) - 1)) {\n fprintf(out, \"%s:%d\", buf, sockaddr_in6->sin6_port);\n } else {\n FATAL();\n }\n break;\n }\n default:\n fputs(\"\", out);\n break;\n }\n}\n\nstatic void dump_socket_addrs(FILE* out, const TraceFrame& frame) {\n if (frame.event().type() != EV_SYSCALL) {\n return;\n }\n\n auto syscall = frame.event().Syscall();\n if (syscall.socket_addrs) {\n fputs(\" Local socket address '\", out);\n print_socket_addr(out, (*syscall.socket_addrs.get())[0]);\n fputs(\"' Remote socket address '\", out);\n print_socket_addr(out, (*syscall.socket_addrs.get())[1]);\n fputs(\"'\\n\", out);\n }\n}\n\nstatic void dump_task_event(FILE* out, const TraceTaskEvent& event) {\n switch (event.type()) {\n case TraceTaskEvent::CLONE:\n fprintf(out, \" TraceTaskEvent::CLONE tid=%d parent=%d clone_flags=0x%x\\n\",\n event.tid(), event.parent_tid(), event.clone_flags());\n break;\n case TraceTaskEvent::EXEC:\n fprintf(out, \" TraceTaskEvent::EXEC tid=%d file=%s\\n\", event.tid(),\n event.file_name().c_str());\n break;\n case TraceTaskEvent::EXIT:\n fprintf(out, \" TraceTaskEvent::EXIT tid=%d status=%d\\n\", event.tid(),\n event.exit_status().get());\n break;\n case TraceTaskEvent::DETACH:\n fprintf(out, \" TraceTaskEvent::DETACH tid=%d\\n\", event.tid());\n break;\n default:\n FATAL() << \"Unknown TraceTaskEvent\";\n break;\n }\n}\n\n/**\n * Dump all events from the current to trace that match |spec| to\n * |out|. |spec| has the following syntax: /\\d+(-\\d+)?/, expressing\n * either a single event number of a range, and may be null to\n * indicate \"dump all events\".\n *\n * This function is side-effect-y, in that the trace file isn't\n * rewound in between matching each spec. Therefore specs should be\n * constructed so as to match properly on a serial linear scan; that\n * is, they should comprise disjoint and monotonically increasing\n * event sets. No attempt is made to enforce this or normalize specs.\n */\nstatic void dump_events_matching(TraceReader& trace, const DumpFlags& flags,\n FILE* out, const string* spec,\n const unordered_multimap& task_events) {\n\n uint32_t start = 0, end = numeric_limits::max();\n bool only_end = false;\n\n if (spec && *spec == \"end\") {\n only_end = true;\n } else {\n // Try to parse the \"range\" syntax '[start]-[end]'.\n if (spec && 2 > sscanf(spec->c_str(), \"%u-%u\", &start, &end)) {\n // Fall back on assuming the spec is a single event\n // number, however it parses out with atoi().\n start = end = atoi(spec->c_str());\n }\n }\n\n bool process_raw_data =\n flags.dump_syscallbuf || flags.dump_recorded_data_metadata;\n while (!trace.at_end()) {\n auto frame = trace.read_frame(start);\n if (end < frame.time()) {\n return;\n }\n if (only_end ? trace.at_end() :\n (start <= frame.time() && frame.time() <= end &&\n (!flags.only_tid || flags.only_tid == frame.tid()))) {\n if (flags.raw_dump) {\n frame.dump_raw(out);\n } else {\n frame.dump(out);\n }\n if (flags.dump_syscallbuf) {\n dump_syscallbuf_data(trace, out, frame, flags);\n }\n if (flags.dump_task_events) {\n auto range = task_events.equal_range(frame.time());\n for (auto it = range.first; it != range.second; ++it) {\n dump_task_event(out, it->second);\n }\n }\n\n while (true) {\n TraceReader::MappedData data;\n bool found;\n KernelMapping km =\n trace.read_mapped_region(&data, &found, TraceReader::DONT_VALIDATE);\n if (!found) {\n break;\n }\n if (flags.dump_mmaps) {\n char prot_flags[] = \"rwxp\";\n if (!(km.prot() & PROT_READ)) {\n prot_flags[0] = '-';\n }\n if (!(km.prot() & PROT_WRITE)) {\n prot_flags[1] = '-';\n }\n if (!(km.prot() & PROT_EXEC)) {\n prot_flags[2] = '-';\n }\n if (km.flags() & MAP_SHARED) {\n prot_flags[3] = 's';\n }\n const char* fsname = km.fsname().c_str();\n if (data.source == TraceReader::SOURCE_ZERO) {\n static const char source_zero[] = \"\";\n fsname = source_zero;\n }\n fprintf(out, \" { map_file:\\\"%s\\\", addr:%p, length:%p, \"\n \"prot_flags:\\\"%s\\\", file_offset:0x%llx, \"\n \"device:%lld, inode:%lld, \"\n \"data_file:\\\"%s\\\", data_offset:0x%llx, \"\n \"file_size:0x%llx }\\n\",\n fsname, (void*)km.start().as_int(), (void*)km.size(),\n prot_flags, (long long)km.file_offset_bytes(),\n (long long)km.device(), (long long)km.inode(),\n data.file_name.c_str(), (long long)data.data_offset_bytes,\n (long long)data.file_size_bytes);\n }\n }\n\n TraceReader::RawDataMetadata data;\n while (process_raw_data && trace.read_raw_data_metadata_for_frame(data)) {\n if (flags.dump_recorded_data_metadata) {\n fprintf(out, \" { tid:%d, addr:%p, length:%p\", data.rec_tid,\n (void*)data.addr.as_int(), (void*)data.size);\n if (!data.holes.empty()) {\n fputs(\", holes:[\", out);\n bool first = true;\n for (auto& h : data.holes) {\n if (!first) {\n fputs(\", \", out);\n }\n first = false;\n fprintf(out, \"%p-%p\", (void*)h.offset, (void*)(h.offset + h.size));\n }\n fputs(\"]\", out);\n }\n fputs(\" }\\n\", out);\n }\n }\n if (flags.dump_socket_addrs) {\n dump_socket_addrs(out, frame);\n }\n if (!flags.raw_dump) {\n fprintf(out, \"}\\n\");\n }\n } else {\n while (true) {\n TraceReader::MappedData data;\n KernelMapping km = trace.read_mapped_region(&data, nullptr,\n TraceReader::DONT_VALIDATE);\n if (km.size() == 0) {\n break;\n }\n }\n TraceReader::RawDataMetadata data;\n while (process_raw_data && trace.read_raw_data_metadata_for_frame(data)) {\n }\n }\n }\n}\n\nstatic void dump_statistics(const TraceReader& trace, FILE* out) {\n uint64_t uncompressed = trace.uncompressed_bytes();\n uint64_t compressed = trace.compressed_bytes();\n fprintf(out, \"// Uncompressed bytes %\" PRIu64 \", compressed bytes %\" PRIu64\n \", ratio %.2fx\\n\",\n uncompressed, compressed, double(uncompressed) / compressed);\n}\n\nvoid dump(const string& trace_dir, const DumpFlags& flags,\n const vector& specs, FILE* out) {\n TraceReader trace(trace_dir);\n\n if (flags.raw_dump) {\n fprintf(out, \"global_time tid reason ticks \"\n \"hw_interrupts page_faults instructions \"\n \"eax ebx ecx edx esi edi ebp orig_eax esp eip eflags\\n\");\n }\n\n unordered_multimap task_events;\n FrameTime last_time = 0;\n while (true) {\n FrameTime time;\n TraceTaskEvent r = trace.read_task_event(&time);\n if (time < last_time) {\n FATAL() << \"TraceTaskEvent times non-monotonic\";\n }\n if (r.type() == TraceTaskEvent::NONE) {\n break;\n }\n task_events.insert(make_pair(time, r));\n last_time = time;\n }\n\n if (specs.size() > 0) {\n for (size_t i = 0; i < specs.size(); ++i) {\n dump_events_matching(trace, flags, out, &specs[i], task_events);\n }\n } else {\n // No specs => dump all events.\n dump_events_matching(trace, flags, out, nullptr /*all events*/, task_events);\n }\n\n if (flags.dump_statistics) {\n dump_statistics(trace, out);\n }\n}\n\nint DumpCommand::run(vector& args) {\n DumpFlags flags;\n\n while (parse_dump_arg(args, flags)) {\n }\n\n string trace_dir;\n if (!parse_optional_trace_dir(args, &trace_dir)) {\n print_help(stderr);\n return 1;\n }\n\n dump(trace_dir, flags, args, stdout);\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/DumpCommand.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DUMP_COMMAND_H_\n#define RR_DUMP_COMMAND_H_\n\n#ifndef _DEFAULT_SOURCE\n#define _DEFAULT_SOURCE 1\n#endif\n\n#include \n\n#include \n#include \n#include \n\nnamespace rr {\n\nstruct DumpFlags {\n bool dump_syscallbuf;\n bool dump_recorded_data_metadata;\n bool dump_mmaps;\n bool dump_task_events;\n bool raw_dump;\n bool dump_statistics;\n bool dump_socket_addrs;\n int only_tid;\n\n DumpFlags()\n : dump_syscallbuf(false),\n dump_recorded_data_metadata(false),\n dump_mmaps(false),\n dump_task_events(false),\n raw_dump(false),\n dump_statistics(false),\n dump_socket_addrs(false),\n only_tid(0) {}\n};\n\nvoid dump(const std::string& trace_dir, const DumpFlags& flags,\n const std::vector& specs, FILE* out);\n\n} // namespace rr\n\n#endif // RR_DUMP_COMMAND_H_\n" }, { "path": "src/Dwarf.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Dwarf.h\"\n\n#include \n\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstruct Dwarf32 {\n typedef uint32_t Offset;\n static const uint8_t EntrySize = 4;\n struct CompilationUnitPreamble {\n uint32_t unit_length;\n };\n};\nstruct Dwarf64 {\n typedef uint64_t Offset;\n static const uint8_t EntrySize = 8;\n struct __attribute__((packed)) CompilationUnitPreamble {\n uint32_t magic; /* 0xffffffff */\n uint64_t unit_length;\n };\n};\n\ntemplate struct __attribute__((packed)) Dwarf4CompilationUnitHeader {\n typedef D Size;\n typename D::CompilationUnitPreamble preamble;\n uint16_t version;\n typename D::Offset debug_abbrev_offset;\n uint8_t address_size;\n\n void install_dwo_id(DwarfCompilationUnit* unit) const {\n unit->set_dwo_id(0);\n }\n};\n\ntemplate struct __attribute__((packed)) Dwarf5CompilationUnitHeader {\n typedef D Size;\n typename D::CompilationUnitPreamble preamble;\n uint16_t version;\n uint8_t unit_type;\n uint8_t address_size;\n typename D::Offset debug_abbrev_offset;\n\n void install_dwo_id(DwarfCompilationUnit* unit) const {\n unit->set_dwo_id(0);\n }\n};\n\ntemplate struct __attribute__((packed)) Dwarf5SkeletonSplitCompilationUnitHeader {\n typedef D Size;\n typename D::CompilationUnitPreamble preamble;\n uint16_t version;\n uint8_t unit_type;\n uint8_t address_size;\n typename D::Offset debug_abbrev_offset;\n uint64_t dwo_id;\n\n void install_dwo_id(DwarfCompilationUnit* unit) const {\n unit->set_dwo_id(dwo_id);\n }\n};\n\ntemplate struct __attribute__((packed)) Dwarf2LineNumberTableHeader {\n typedef D Size;\n typename D::CompilationUnitPreamble preamble;\n uint16_t version;\n typename D::Offset header_length;\n uint8_t minimum_instruction_length;\n uint8_t default_is_stmt;\n int8_t line_base;\n uint8_t line_range;\n uint8_t opcode_base;\n\n bool read_directories(const DwarfCompilationUnit& cu,\n DwarfSpan span,\n const DebugStrSpans& debug_str,\n std::vector& directories,\n std::vector& files) const;\n};\n\ntemplate struct __attribute__((packed)) Dwarf4LineNumberTableHeader {\n typedef D Size;\n typename D::CompilationUnitPreamble preamble;\n uint16_t version;\n typename D::Offset header_length;\n uint8_t minimum_instruction_length;\n uint8_t maximum_operations_per_instruction;\n uint8_t default_is_stmt;\n int8_t line_base;\n uint8_t line_range;\n uint8_t opcode_base;\n\n bool read_directories(const DwarfCompilationUnit& cu,\n DwarfSpan span,\n const DebugStrSpans& debug_str,\n std::vector& directories,\n std::vector& files) const;\n};\n\ntemplate struct __attribute__((packed)) Dwarf5LineNumberTableHeader {\n typedef D Size;\n typename D::CompilationUnitPreamble preamble;\n uint16_t version;\n uint8_t address_size;\n uint8_t segment_selector_size;\n typename D::Offset header_length;\n uint8_t minimum_instruction_length;\n uint8_t maximum_operations_per_instruction;\n uint8_t default_is_stmt;\n int8_t line_base;\n uint8_t line_range;\n uint8_t opcode_base;\n\n bool read_directories(const DwarfCompilationUnit& cu,\n DwarfSpan span,\n const DebugStrSpans& debug_str,\n std::vector& directories,\n std::vector& files) const;\n};\n\nuint64_t DwarfSpan::read_uleb(bool* ok) {\n uint64_t ret = 0;\n int shift = 0;\n while (start < end) {\n uint8_t b = *start;\n ++start;\n ret |= (b & 0x7f) << shift;\n if (!(b & 0x80)) {\n return ret;\n }\n shift += 7;\n if (shift >= 64) {\n *ok = false;\n return 0;\n }\n }\n *ok = false;\n return 0;\n}\n\nDwarfSpan DwarfSpan::read_leb_ref(bool* ok) {\n DwarfSpan ret(*this);\n while (start < end) {\n if (!(*start & 0x80)) {\n ++start;\n ret.end = start;\n return ret;\n }\n ++start;\n }\n *ok = false;\n return ret;\n}\n\nconst char* DwarfSpan::read_null_terminated_string(bool* ok) {\n const void* p = memchr(start, 0, size());\n if (!p) {\n LOG(warn) << \"String was not null-terminated\";\n *ok = false;\n return nullptr;\n }\n const char* ret = reinterpret_cast(start);\n start = static_cast(p) + 1;\n return ret;\n}\n\nDwarfAbbrev* DwarfAbbrevSet::lookup(uint64_t code) {\n auto it = abbrevs.find(code);\n if (it != abbrevs.end()) {\n return it->second.get();\n }\n\n while (!remaining_span.empty()) {\n bool ok = true;\n uint64_t abbrev_code = remaining_span.read_uleb(&ok);\n unique_ptr abbrev(new DwarfAbbrev);\n abbrev->tag = (DWTag)remaining_span.read_uleb(&ok);\n abbrev->children = (DWChildren)remaining_span.read_value(&ok);\n auto abbrev_raw = abbrev.get();\n while (true) {\n uint64_t name = remaining_span.read_uleb(&ok);\n DWForm form = (DWForm)remaining_span.read_uleb(&ok);\n if (!name && !form) {\n break;\n }\n DwarfSpan constant;\n if (form == DW_FORM_implicit_const) {\n constant = remaining_span.read_leb_ref(&ok);\n }\n abbrev->attributes.push_back({ name, form, constant });\n }\n if (!ok) {\n LOG(warn) << \"Invalid DWARF abbrev table!\";\n return nullptr;\n }\n abbrevs.insert(make_pair(abbrev_code, std::move(abbrev)));\n if (code == abbrev_code) {\n return abbrev_raw;\n }\n }\n\n return nullptr;\n}\n\nDwarfAbbrevSet& DwarfAbbrevs::lookup(uint64_t offset) {\n auto it = abbrevs.find(offset);\n if (it != abbrevs.end()) {\n return *it->second;\n }\n\n unique_ptr set(new DwarfAbbrevSet(debug_abbrev.subspan(offset)));\n auto set_raw = set.get();\n abbrevs.insert(make_pair(offset, std::move(set)));\n return *set_raw;\n}\n\nstatic DwarfAbbrev null_abbrev;\n\nDwarfDIE::DwarfDIE(DwarfSpan span, DwarfAbbrevSet& abbrevs, uint8_t dwarf_size, uint8_t address_size, bool* ok)\n : address_size(address_size), dwarf_size(dwarf_size) {\n uint64_t code = span.read_uleb(ok);\n if (!*ok) {\n return;\n }\n if (code == 0) {\n abbrev = &null_abbrev;\n return;\n }\n abbrev = abbrevs.lookup(code);\n if (!abbrev) {\n LOG(warn) << \"No abbrev found for DIE\";\n *ok = false;\n return;\n }\n attr_span = span;\n}\n\nstatic size_t form_size(DWForm form, size_t address_size, size_t dwarf_size, DwarfSpan* span, bool* ok) {\n if (form == DW_FORM_indirect) {\n form = (DWForm)span->read_uleb(ok);\n if (!*ok) {\n return 0;\n }\n }\n if (form == DW_FORM_udata) {\n auto before = span->size();\n DwarfSpan a_span(*span);\n a_span.read_uleb(ok);\n if (!*ok) {\n return 0;\n }\n return before - a_span.size();\n }\n switch (form) {\n case DW_FORM_addr: return address_size;\n case DW_FORM_addrx: return dwarf_size;\n case DW_FORM_data1: return 1;\n case DW_FORM_data2: return 2;\n case DW_FORM_data4: return 4;\n case DW_FORM_data8: return 8;\n case DW_FORM_data16: return 16;\n case DW_FORM_flag: return 1;\n case DW_FORM_strp: return dwarf_size;\n case DW_FORM_line_strp: return dwarf_size;\n case DW_FORM_strx: return dwarf_size;\n case DW_FORM_strx1: return 1;\n case DW_FORM_strx2: return 2;\n case DW_FORM_strx3: return 3;\n case DW_FORM_strx4: return 4;\n case DW_FORM_string: {\n auto before = span->size();\n DwarfSpan a_span(*span);\n a_span.read_null_terminated_string(ok);\n if (!*ok) {\n return 0;\n }\n return before - a_span.size();\n }\n case DW_FORM_sec_offset: return dwarf_size;\n case DW_FORM_flag_present: return 0;\n case DW_FORM_implicit_const: return 0;\n case DW_FORM_rnglistx: return dwarf_size;\n case DW_FORM_strp_sup: return dwarf_size;\n case DW_FORM_GNU_strp_alt: return dwarf_size;\n default:\n LOG(warn) << \"form \" << form << \" not supported!\";\n *ok = false;\n return 0;\n }\n}\n\nDwarfSpan DwarfDIE::find_attribute(DWAttr attr, DWForm* form, bool* ok) const {\n DwarfSpan span = attr_span;\n for (auto& a : abbrev->attributes) {\n size_t size = form_size(a.form, address_size, dwarf_size, &span, ok);\n DwarfSpan a_span = span.consume(size);\n if (a.name == attr) {\n *form = a.form;\n if (a.form == DW_FORM_implicit_const) {\n a_span = a.constant;\n }\n return a_span;\n }\n }\n return DwarfSpan();\n}\n\nstatic uint64_t decode_unsigned_literal(DwarfSpan span, bool* ok) {\n int shift = 0;\n uint64_t ret = 0;\n while (!span.empty()) {\n if (shift >= 64) {\n LOG(warn) << \"Literal too large\";\n *ok = false;\n return 0;\n }\n ret |= (uint64_t)span.read_value(ok) << shift;\n shift += 8;\n }\n return ret;\n}\n\nstatic int64_t decode_section_ptr(DwarfSpan span, DWForm form, bool* ok) {\n switch (form) {\n case DW_FORM_data1:\n case DW_FORM_data2:\n case DW_FORM_data4:\n case DW_FORM_data8:\n case DW_FORM_sec_offset: {\n uint64_t ret = decode_unsigned_literal(span, ok);\n if (ret > INT64_MAX) {\n LOG(warn) << \"section ptr out of range\";\n *ok = false;\n return 0;\n }\n return ret;\n }\n default:\n LOG(warn) << \"Unknown section ptr form \" << form;\n *ok = false;\n return 0;\n }\n}\n\nstatic uint64_t decode_unsigned(DwarfSpan span, DWForm form, bool* ok) {\n switch (form) {\n case DW_FORM_data1:\n case DW_FORM_data2:\n case DW_FORM_data4:\n case DW_FORM_data8: {\n return decode_unsigned_literal(span, ok);\n }\n case DW_FORM_udata: {\n return span.read_uleb(ok);\n }\n default:\n LOG(warn) << \"Unknown unsigned form \" << form;\n *ok = false;\n return 0;\n }\n}\n\nstatic const char* decode_string(const DwarfCompilationUnit& cu, DwarfSpan span, DWForm form, const DebugStrSpans& debug_strs, bool* ok) {\n switch (form) {\n case DW_FORM_strp: {\n uint64_t offset = decode_unsigned_literal(span, ok);\n if (!*ok) {\n return nullptr;\n }\n return debug_strs.debug_str.subspan(offset).read_null_terminated_string(ok);\n }\n case DW_FORM_strp_sup:\n case DW_FORM_GNU_strp_alt: {\n uint64_t offset = decode_unsigned_literal(span, ok);\n if (!*ok) {\n return nullptr;\n }\n return debug_strs.debug_str_sup.subspan(offset).read_null_terminated_string(ok);\n }\n case DW_FORM_line_strp: {\n uint64_t offset = decode_unsigned_literal(span, ok);\n if (!*ok) {\n return nullptr;\n }\n return debug_strs.debug_line_str.subspan(offset).read_null_terminated_string(ok);\n }\n case DW_FORM_strx:\n case DW_FORM_strx1:\n case DW_FORM_strx2:\n case DW_FORM_strx3:\n case DW_FORM_strx4: {\n uint64_t index = decode_unsigned_literal(span, ok) * cu.entry_size() + cu.str_offsets_base();\n if (!*ok) {\n return nullptr;\n }\n uint64_t offset = cu.read_entry_sized_value(debug_strs.debug_str_offsets.subspan(index), ok);\n if (!*ok) {\n return nullptr;\n }\n return debug_strs.debug_str.subspan(offset).read_null_terminated_string(ok);\n }\n case DW_FORM_string:\n return span.read_null_terminated_string(ok);\n default:\n LOG(warn) << \"Unknown string form \" << form;\n *ok = false;\n return 0;\n }\n}\n\nint64_t DwarfDIE::section_ptr_attr(DWAttr attr, bool* ok) const {\n DWForm form;\n auto span = find_attribute(attr, &form, ok);\n if (span.empty() || !*ok) {\n return -1;\n }\n return decode_section_ptr(span, form, ok);\n}\n\nuint64_t DwarfDIE::unsigned_attr(DWAttr attr, bool* found, bool* ok) const {\n DWForm form;\n auto span = find_attribute(attr, &form, ok);\n if (span.empty() || !*ok) {\n *found = false;\n return 0;\n }\n *found = true;\n return decode_unsigned(span, form, ok);\n}\n\nconst char* DwarfDIE::string_attr(const DwarfCompilationUnit& cu, DWAttr attr, const DebugStrSpans& debug_strs, bool* ok) const {\n DWForm form;\n auto span = find_attribute(attr, &form, ok);\n if (span.empty() || !*ok) {\n return nullptr;\n }\n return decode_string(cu, span, form, debug_strs, ok);\n}\n\nDwarfCompilationUnit DwarfCompilationUnit::next(DwarfSpan* debug_info, DwarfAbbrevs& abbrevs, bool* ok) {\n DwarfCompilationUnit ret;\n uint32_t word = DwarfSpan(*debug_info).read_value(ok);\n if (!*ok) {\n return ret;\n }\n if (word == 0xFFFFFFFF) {\n ret.init_size(debug_info, abbrevs, ok);\n } else {\n ret.init_size(debug_info, abbrevs, ok);\n }\n return ret;\n}\n\ntemplate void DwarfCompilationUnit::init_size(DwarfSpan* debug_info, DwarfAbbrevs& abbrevs, bool* ok) {\n auto h = DwarfSpan(*debug_info).read>(ok);\n if (!*ok) {\n return;\n }\n if (2 <= h->version && h->version <= 4) {\n init>(debug_info, abbrevs, ok);\n } else if (h->version == 5) {\n auto hh = DwarfSpan(*debug_info).read>(ok);\n if (!*ok) {\n return;\n }\n if (hh->unit_type == DW_UT_skeleton || hh->unit_type == DW_UT_split_compile) {\n init>(debug_info, abbrevs, ok);\n } else {\n init>(debug_info, abbrevs, ok);\n }\n } else {\n LOG(warn) << \"Unknown compilation unit version \" << h->version;\n *ok = false;\n }\n}\n\ntemplate void DwarfCompilationUnit::init(DwarfSpan* debug_info, DwarfAbbrevs& abbrevs, bool* ok) {\n DwarfSpan span(*debug_info);\n auto h = span.read(ok);\n if (!*ok) {\n return;\n }\n uint64_t length = h->preamble.unit_length;\n if (length >= UINT64_MAX - 12) {\n LOG(warn) << \"Invalid CU length\";\n *ok = false;\n return;\n }\n debug_info->consume(length + sizeof(h->preamble));\n DwarfAbbrevSet& abbrev_set = abbrevs.lookup(h->debug_abbrev_offset);\n die_ = make_unique(span, abbrev_set, sizeof(typename H::Size::Offset), h->address_size, ok);\n if (!*ok) {\n return;\n }\n if (die_->tag() != DW_TAG_compile_unit &&\n die_->tag() != DW_TAG_partial_unit &&\n die_->tag() != DW_TAG_skeleton_unit) {\n LOG(warn) << \"CU DIE is not DW_TAG_compilation_unit/DW_TAG_partial_unit/DW_TAG_skeleton_unit!\";\n *ok = false;\n return;\n }\n entry_size_ = H::Size::EntrySize;\n h->install_dwo_id(this);\n}\n\nuint64_t DwarfCompilationUnit::read_entry_sized_value(DwarfSpan span, bool* ok) const {\n if (entry_size() == 4) {\n return span.read_value(ok);\n } else if (entry_size() == 8) {\n return span.read_value(ok);\n } else {\n LOG(warn) << \"Unknown entry size \" << entry_size();\n *ok = false;\n return 0;\n }\n}\n\nDwarfLineNumberTable::DwarfLineNumberTable(const DwarfCompilationUnit& cu, DwarfSpan span, const DebugStrSpans& debug_str, bool* ok) {\n uint32_t word = DwarfSpan(span).read_value(ok);\n if (!*ok) {\n return;\n }\n if (word == 0xFFFFFFFF) {\n init_size(cu, span, debug_str, ok);\n } else {\n init_size(cu, span, debug_str, ok);\n }\n}\n\ntemplate void DwarfLineNumberTable::init_size(const DwarfCompilationUnit& cu, DwarfSpan span, const DebugStrSpans& debug_str, bool* ok) {\n auto h = DwarfSpan(span).read>(ok);\n if (!*ok) {\n return;\n }\n if (2 <= h->version && h->version <= 3) {\n init>(cu, span, debug_str, ok);\n } else if (h->version == 4) {\n init>(cu, span, debug_str, ok);\n } else if (h->version == 5) {\n init>(cu, span, debug_str, ok);\n } else {\n LOG(warn) << \"Unknown compilation unit version \" << h->version;\n *ok = false;\n }\n}\n\nstatic bool read_dwarf2_directories(DwarfSpan span, std::vector& directories, std::vector& files) {\n bool ok = true;\n directories.push_back(nullptr);\n while (true) {\n const char* dir = span.read_null_terminated_string(&ok);\n if (!ok) {\n return ok;\n }\n if (!*dir) {\n break;\n }\n directories.push_back(dir);\n }\n files.push_back({ 0, nullptr });\n while (true) {\n const char* file = span.read_null_terminated_string(&ok);\n if (!ok) {\n return ok;\n }\n if (!*file) {\n break;\n }\n uint64_t dir = span.read_uleb(&ok);\n if (dir >= directories.size()) {\n LOG(warn) << \"Invalid directory index, bailing\";\n return false;\n }\n span.read_uleb(&ok); // timestamp\n span.read_uleb(&ok); // length\n if (!ok) {\n return ok;\n }\n files.push_back({ dir, file });\n }\n\n return ok;\n}\n\ntemplate\nbool Dwarf2LineNumberTableHeader::read_directories(const DwarfCompilationUnit&,\n DwarfSpan span,\n const DebugStrSpans&,\n std::vector& directories,\n std::vector& files) const {\n return read_dwarf2_directories(span, directories, files);\n}\n\ntemplate\nbool Dwarf4LineNumberTableHeader::read_directories(const DwarfCompilationUnit&,\n DwarfSpan span,\n const DebugStrSpans&,\n std::vector& directories,\n std::vector& files) const {\n return read_dwarf2_directories(span, directories, files);\n}\n\nstruct FileEntryFormat {\n DWLnct content_type;\n DWForm form;\n};\n\ntemplate\nbool Dwarf5LineNumberTableHeader::read_directories(const DwarfCompilationUnit& cu,\n DwarfSpan span,\n const DebugStrSpans& debug_str,\n std::vector& directories,\n std::vector& files) const {\n bool ok = true;\n uint64_t directory_entry_format_count = span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n\n bool seen_lnct_path = false;\n std::vector directory_formats;\n for (uint64_t i = 0; i < directory_entry_format_count; ++i) {\n DWLnct content_type = (DWLnct)span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n if (content_type == DW_LNCT_path) {\n if (seen_lnct_path) {\n LOG(warn) << \"DW_LNCT_path appears twice in directories!\";\n return false;\n }\n seen_lnct_path = true;\n }\n\n DWForm form = (DWForm)span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n directory_formats.push_back({ content_type, form });\n }\n\n if (!seen_lnct_path) {\n LOG(warn) << \"DW_LNCT_path does not appear in directories\";\n return false;\n }\n\n uint64_t directories_count = span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n\n for (uint64_t i = 0; i < directories_count; ++i) {\n for (auto format: directory_formats) {\n switch (format.content_type) {\n case DW_LNCT_path: {\n size_t size = form_size(format.form, address_size, Size::EntrySize, &span, &ok);\n DwarfSpan a_span = span.consume(size);\n auto directory = decode_string(cu, a_span, format.form, debug_str, &ok);\n if (!ok) {\n return ok;\n }\n directories.push_back(directory);\n break;\n }\n default:\n LOG(warn) << \"Unknown DW_LNCT \" << format.content_type << \" for directory\";\n return false;\n }\n }\n }\n\n uint64_t file_entry_format_count = span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n\n seen_lnct_path = false;\n std::vector file_formats;\n for (uint64_t i = 0; i < file_entry_format_count; ++i) {\n DWLnct content_type = (DWLnct)span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n if (content_type == DW_LNCT_path) {\n if (seen_lnct_path) {\n LOG(warn) << \"DW_LNCT_path appears twice in files!\";\n return false;\n }\n seen_lnct_path = true;\n }\n\n DWForm form = (DWForm)span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n file_formats.push_back({ content_type, form });\n }\n\n if (!seen_lnct_path) {\n LOG(warn) << \"DW_LNCT_path does not appear in files\";\n return false;\n }\n\n uint64_t files_count = span.read_uleb(&ok);\n if (!ok) {\n return ok;\n }\n\n for (uint64_t i = 0; i < files_count; ++i) {\n uint64_t directory_index = 0;\n const char* file_path = NULL;\n for (auto format: file_formats) {\n switch (format.content_type) {\n case DW_LNCT_path: {\n size_t size = form_size(format.form, address_size, Size::EntrySize, &span, &ok);\n DwarfSpan a_span = span.consume(size);\n file_path = decode_string(cu, a_span, format.form, debug_str, &ok);\n if (!ok) {\n return ok;\n }\n break;\n }\n case DW_LNCT_directory_index: {\n size_t size = form_size(format.form, address_size, Size::EntrySize, &span, &ok);\n DwarfSpan a_span = span.consume(size);\n directory_index = decode_unsigned(a_span, format.form, &ok);\n if (!ok) {\n return ok;\n }\n break;\n }\n case DW_LNCT_md5: {\n if (format.form != DW_FORM_data16) {\n LOG(warn) << \"md5 has unexpected form \" << format.form;\n return false;\n }\n size_t size = form_size(format.form, address_size, Size::EntrySize, &span, &ok);\n span.consume(size);\n break;\n }\n default:\n LOG(warn) << \"Unknown DW_LNCT \" << format.content_type << \" for file\";\n return false;\n }\n }\n\n files.push_back({ directory_index, file_path });\n }\n\n return true;\n}\n\ntemplate void DwarfLineNumberTable::init(const DwarfCompilationUnit& cu,\n DwarfSpan span,\n const DebugStrSpans& debug_str,\n bool* ok) {\n auto h = span.read(ok);\n if (!*ok) {\n return;\n }\n for (uint8_t i = 1; i < h->opcode_base; ++i) {\n span.read_uleb(ok);\n }\n if (!*ok) {\n return;\n }\n *ok = h->read_directories(cu, span, debug_str, directories_, file_names_);\n}\n\n} // namespace rr\n" }, { "path": "src/Dwarf.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_DWARF_H_\n#define RR_DWARF_H_\n\n#include \n\n#include \n#include \n#include \n\n#include \"cpp_supplement.h\"\n\nnamespace rr {\n\nenum DWTag {\n DW_TAG_null = 0,\n DW_TAG_compile_unit = 0x11,\n DW_TAG_partial_unit = 0x3c,\n DW_TAG_skeleton_unit = 0x4a,\n};\n\nenum DWAttr {\n DW_AT_name = 0x03,\n DW_AT_stmt_list = 0x10,\n DW_AT_comp_dir = 0x1b,\n DW_AT_str_offsets_base = 0x72,\n DW_AT_dwo_name = 0x76,\n DW_AT_GNU_dwo_name = 0x2130,\n DW_AT_GNU_dwo_id = 0x2131,\n};\n\nenum DWChildren {\n DW_CHILDREN_no = 0x00,\n DW_CHILDREN_yes = 0x01\n};\n\nenum DWForm {\n DW_FORM_addr = 0x01,\n DW_FORM_block2 = 0x03,\n DW_FORM_block4 = 0x04,\n DW_FORM_data2 = 0x05,\n DW_FORM_data4 = 0x06,\n DW_FORM_data8 = 0x07,\n DW_FORM_string = 0x08,\n DW_FORM_data1 = 0x0b,\n DW_FORM_flag = 0x0c,\n DW_FORM_strp = 0x0e,\n DW_FORM_udata= 0x0f,\n DW_FORM_indirect = 0x16,\n DW_FORM_sec_offset = 0x17,\n DW_FORM_flag_present = 0x19,\n DW_FORM_strx = 0x1a,\n DW_FORM_addrx = 0x1b,\n DW_FORM_strp_sup = 0x1d,\n DW_FORM_data16 = 0x1e,\n DW_FORM_line_strp = 0x1f,\n DW_FORM_implicit_const = 0x21,\n DW_FORM_rnglistx = 0x23,\n DW_FORM_strx1 = 0x25,\n DW_FORM_strx2 = 0x26,\n DW_FORM_strx3 = 0x27,\n DW_FORM_strx4 = 0x28,\n DW_FORM_GNU_strp_alt = 0x1f21,\n};\n\nenum DWLnct {\n DW_LNCT_path = 0x1,\n DW_LNCT_directory_index = 0x2,\n DW_LNCT_md5 = 0x5,\n};\n\nenum DWUt {\n DW_UT_compile = 0x01,\n DW_UT_skeleton = 0x04,\n DW_UT_split_compile = 0x05,\n};\n\nclass DwarfSpan {\npublic:\n DwarfSpan(const uint8_t* start, const uint8_t* end) : start(start), end(end) {}\n DwarfSpan(const DwarfSpan& other) = default;\n DwarfSpan& operator=(const DwarfSpan& other) = default;\n DwarfSpan() : start(nullptr), end(nullptr) {}\n size_t size() const { return end - start; }\n uint64_t read_uleb(bool* ok);\n DwarfSpan read_leb_ref(bool* ok);\n const char* read_null_terminated_string(bool* ok);\n template const T* read(bool *ok) {\n if (size() < sizeof(T)) {\n *ok = false;\n return nullptr;\n }\n auto ret = reinterpret_cast(start);\n start += sizeof(T);\n return ret;\n }\n template T read_value(bool *ok) {\n const T* r = read(ok);\n return r ? *r : T();\n }\n bool empty() {\n return start == end;\n }\n DwarfSpan subspan(uint64_t offset, uint64_t sz = UINT64_MAX) const {\n DwarfSpan ret(*this);\n if (size() <= offset) {\n ret.start = end;\n return ret;\n }\n ret.start += offset;\n if (ret.size() <= sz) {\n return ret;\n }\n ret.end = ret.start + sz;\n return ret;\n }\n DwarfSpan consume(uint64_t sz) {\n DwarfSpan ret(*this);\n if (size() <= sz) {\n start = end;\n return ret;\n }\n ret.end = ret.start + sz;\n start = ret.end;\n return ret;\n }\nprivate:\n const uint8_t* start;\n const uint8_t* end;\n};\n\nstruct DebugStrSpans {\n DwarfSpan debug_str;\n DwarfSpan debug_str_sup;\n DwarfSpan debug_str_offsets;\n DwarfSpan debug_line_str;\n};\n\nstruct DwarfAbbrevAttribute {\n uint64_t name;\n DWForm form;\n DwarfSpan constant; // DWARF5\n};\n\nstruct DwarfAbbrev {\n DwarfAbbrev() : tag(DW_TAG_null), children(DW_CHILDREN_no) {}\n std::vector attributes;\n DWTag tag;\n DWChildren children;\n};\n\nclass DwarfAbbrevSet {\npublic:\n DwarfAbbrevSet(DwarfSpan span) : remaining_span(span) {}\n DwarfAbbrev* lookup(uint64_t code);\nprivate:\n std::unordered_map> abbrevs;\n DwarfSpan remaining_span;\n};\n\nclass DwarfAbbrevs {\npublic:\n DwarfAbbrevs(DwarfSpan debug_abbrev) : debug_abbrev(debug_abbrev) {}\n DwarfAbbrevSet& lookup(uint64_t offset);\nprivate:\n DwarfSpan debug_abbrev;\n std::unordered_map> abbrevs;\n};\n\nclass DwarfCompilationUnit;\n\nclass DwarfDIE {\npublic:\n DwarfDIE(DwarfSpan span, DwarfAbbrevSet& abbrevs, uint8_t dwarf_size, uint8_t address_size, bool* ok);\n DWTag tag() const { return abbrev->tag; }\n // Returns empty span if not found\n DwarfSpan find_attribute(DWAttr attr, DWForm* form, bool* ok) const;\n // Returns -1 if no attr\n int64_t section_ptr_attr(DWAttr attr, bool* ok) const;\n // Sets *found to false if not found.\n uint64_t unsigned_attr(DWAttr attr, bool* found, bool* ok) const;\n // Returns nullptr if no attr\n const char* string_attr(const DwarfCompilationUnit& unit, DWAttr attr, const DebugStrSpans& debug_str, bool* ok) const;\nprivate:\n DwarfAbbrev* abbrev;\n DwarfSpan attr_span;\n uint8_t address_size;\n uint8_t dwarf_size;\n};\n\nclass DwarfCompilationUnit {\npublic:\n // Consumes debug_info span and leaves rest behind\n static DwarfCompilationUnit next(DwarfSpan* debug_info, DwarfAbbrevs& abbrevs, bool* ok);\n const DwarfDIE& die() const { return *die_; }\n uint64_t dwo_id() const { return dwo_id_; }\n void set_dwo_id(uint64_t dwo_id) { dwo_id_ = dwo_id; }\n uint64_t str_offsets_base() const { return str_offsets_base_; }\n void set_str_offsets_base(uint64_t str_offsets_base) { str_offsets_base_ = str_offsets_base; }\n uint8_t entry_size() const { return entry_size_; }\n uint64_t read_entry_sized_value(DwarfSpan span, bool* ok) const;\nprivate:\n DwarfCompilationUnit() {}\n template void init_size(DwarfSpan* debug_info, DwarfAbbrevs& abbrevs, bool* ok);\n template void init(DwarfSpan* debug_info, DwarfAbbrevs& abbrevs, bool* ok);\n std::unique_ptr die_;\n uint64_t dwo_id_;\n uint64_t str_offsets_base_;\n uint8_t entry_size_;\n};\n\nstruct DwarfSourceFile {\n uint64_t directory_index;\n const char* file_name;\n};\n\nclass DwarfLineNumberTable {\npublic:\n DwarfLineNumberTable(const DwarfCompilationUnit& cu, DwarfSpan span, const DebugStrSpans& debug_strs, bool* ok);\n // Null directory pointer means \"compilation dir\". The first entry is null.\n const std::vector& directories() const { return directories_; }\n // Null file name means \"compilation unit name\". The first entry is null.\n const std::vector& file_names() const { return file_names_; }\nprivate:\n template void init_size(const DwarfCompilationUnit& cu, DwarfSpan span, const DebugStrSpans& debug_strs, bool* ok);\n template void init(const DwarfCompilationUnit& cu, DwarfSpan span, const DebugStrSpans& debug_strs, bool* ok);\n std::vector directories_;\n std::vector file_names_;\n};\n\n} // namespace rr\n\n#endif /* RR_DWARF_H_ */\n" }, { "path": "src/ElfReader.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ElfReader.h\"\n\n#include \n#include \n#include \n#include \n#include \n#ifdef ZSTD\n#include \n#endif\n\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass ElfReaderImplBase {\npublic:\n ElfReaderImplBase(ElfReader& r) : r(r), ok_(false) {}\n virtual ~ElfReaderImplBase() {}\n virtual SymbolTable read_symbols(const char* symtab, const char* strtab) = 0;\n virtual DynamicSection read_dynamic() = 0;\n virtual Debuglink read_debuglink() = 0;\n virtual Debugaltlink read_debugaltlink() = 0;\n virtual string read_buildid() = 0;\n virtual string read_interp() = 0;\n virtual bool addr_to_phdr(uintptr_t addr, PhdrInfo& phdr) = 0;\n virtual SectionOffsets find_section_file_offsets(const char* name) = 0;\n virtual const vector* decompress_section(SectionOffsets offsets) = 0;\n bool ok() { return ok_; }\n\nprotected:\n ElfReader& r;\n vector>> decompressed_sections;\n bool ok_;\n};\n\ntemplate class ElfReaderImpl : public ElfReaderImplBase {\npublic:\n ElfReaderImpl(ElfReader& r);\n virtual SymbolTable read_symbols(const char* symtab,\n const char* strtab) override;\n virtual DynamicSection read_dynamic() override;\n virtual Debuglink read_debuglink() override;\n virtual Debugaltlink read_debugaltlink() override;\n virtual string read_buildid() override;\n virtual string read_interp() override;\n virtual bool addr_to_phdr(uintptr_t addr, PhdrInfo& phdr) override;\n virtual SectionOffsets find_section_file_offsets(const char* name) override;\n virtual const vector* decompress_section(SectionOffsets offsets) override;\n\nprivate:\n const typename Arch::ElfShdr* find_section(const char* n);\n const typename Arch::ElfPhdr* find_programheader(uint32_t pt);\n\n const typename Arch::ElfEhdr* elfheader;\n const typename Arch::ElfPhdr* programheader;\n const typename Arch::ElfShdr* sections;\n size_t programheader_size;\n size_t sections_size;\n vector section_names;\n};\n\ntemplate \nunique_ptr elf_reader_impl_arch(ElfReader& r) {\n return unique_ptr(new ElfReaderImpl(r));\n}\n\nunique_ptr elf_reader_impl(ElfReader& r,\n SupportedArch arch) {\n RR_ARCH_FUNCTION(elf_reader_impl_arch, arch, r);\n}\n\ntemplate \nElfReaderImpl::ElfReaderImpl(ElfReader& r) : ElfReaderImplBase(r) {\n elfheader = r.read(0);\n if (!elfheader || memcmp(elfheader, ELFMAG, SELFMAG) != 0 ||\n elfheader->e_ident[EI_CLASS] != Arch::elfclass ||\n elfheader->e_ident[EI_DATA] != Arch::elfendian ||\n elfheader->e_machine != Arch::elfmachine ||\n elfheader->e_shentsize != sizeof(typename Arch::ElfShdr) ||\n elfheader->e_phentsize != sizeof(typename Arch::ElfPhdr) ||\n elfheader->e_shstrndx >= elfheader->e_shnum) {\n LOG(debug) << \"Invalid ELF file: invalid header\";\n return;\n }\n\n programheader =\n r.read(elfheader->e_phoff, elfheader->e_phnum);\n if (!programheader) {\n LOG(debug) << \"Invalid ELF file: no program headers\";\n return;\n }\n programheader_size = elfheader->e_phnum;\n\n sections =\n r.read(elfheader->e_shoff, elfheader->e_shnum);\n if (!sections || !elfheader->e_shnum) {\n LOG(debug) << \"Invalid ELF file: no sections\";\n return;\n }\n sections_size = elfheader->e_shnum;\n\n auto& section_names_section = sections[elfheader->e_shstrndx];\n const char* section_names_ptr = r.read(section_names_section.sh_offset,\n section_names_section.sh_size);\n if (!section_names_ptr || !section_names_section.sh_size) {\n LOG(debug) << \"Invalid ELF file: can't read section names\";\n return;\n }\n // Ensure final 0\n section_names.resize(section_names_section.sh_size);\n memcpy(section_names.data(), section_names_ptr, section_names.size());\n section_names[section_names.size() - 1] = 0;\n\n ok_ = true;\n}\n\ntemplate \nconst typename Arch::ElfPhdr* ElfReaderImpl::find_programheader(uint32_t pt) {\n const typename Arch::ElfPhdr* ph = nullptr;\n\n for (size_t i = 0; i < programheader_size; ++i) {\n auto& p = programheader[i];\n if (p.p_type == pt) {\n ph = &p;\n }\n }\n\n if (!ph) {\n LOG(debug) << \"Missing program header \" << pt;\n }\n return ph;\n}\n\ntemplate \nconst typename Arch::ElfShdr* ElfReaderImpl::find_section(const char* n) {\n const typename Arch::ElfShdr* section = nullptr;\n\n for (size_t i = 0; i < sections_size; ++i) {\n auto& s = sections[i];\n if (s.sh_name >= section_names.size()) {\n LOG(debug) << \"Invalid ELF file: invalid name offset for section \" << i;\n continue;\n }\n const char* name = section_names.data() + s.sh_name;\n if (strcmp(name, n) == 0) {\n if (section) {\n LOG(debug) << \"Invalid ELF file: duplicate symbol section \" << n;\n return nullptr;\n }\n section = &s;\n }\n }\n\n if (!section) {\n LOG(debug) << \"Missing section \" << n;\n }\n return section;\n}\n\ntemplate \nSectionOffsets ElfReaderImpl::find_section_file_offsets(\n const char* name) {\n SectionOffsets offsets = { 0, 0, false };\n const typename Arch::ElfShdr* section = find_section(name);\n if (!section) {\n return offsets;\n }\n offsets.start = section->sh_offset;\n offsets.end = section->sh_offset + section->sh_size;\n offsets.compressed = !!(section->sh_flags & SHF_COMPRESSED);\n return offsets;\n}\n\ntemplate \nconst vector* ElfReaderImpl::decompress_section(SectionOffsets offsets) {\n bool zlib = false;\n __attribute__((unused)) bool zstd = false;\n DEBUG_ASSERT(offsets.compressed);\n auto hdr = r.read(offsets.start);\n if (!hdr) {\n LOG(warn) << \"section at \" << offsets.start\n << \" is marked compressed but is too small\";\n return nullptr;\n }\n\n size_t decompressed_size = 0;\n if (hdr->ch_type == ELFCOMPRESS_ZLIB || hdr->ch_type == ELFCOMPRESS_ZSTD) {\n decompressed_size = hdr->ch_size;\n offsets.start += sizeof(typename Arch::ElfChdr);\n if (hdr->ch_type == ELFCOMPRESS_ZLIB) {\n zlib = true;\n } else {\n zstd = true;\n }\n } else {\n auto legacy_hdr = r.read_bytes(offsets.start, 4);\n if (!memcmp(\"ZLIB\", legacy_hdr, 4)) {\n auto be_size = r.read(offsets.start + 4);\n decompressed_size = be64toh(*be_size);\n offsets.start += 12;\n zlib = true;\n } else {\n LOG(warn) << \"section at \" << offsets.start\n << \" is marked compressed but uses unrecognized\"\n << \" type \" << HEX(hdr->ch_type);\n return nullptr;\n }\n }\n\n unique_ptr> v(new vector());\n v->resize(decompressed_size);\n\n if (zlib) {\n z_stream stream;\n memset(&stream, 0, sizeof(stream));\n int result = inflateInit(&stream);\n if (result != Z_OK) {\n FATAL() << \"inflateInit failed!\";\n return nullptr;\n }\n\n stream.avail_in = offsets.end - offsets.start;\n stream.next_in = (unsigned char*)r.read_bytes(offsets.start, stream.avail_in);\n stream.next_out = &v->front();\n stream.avail_out = v->size();\n result = inflate(&stream, Z_FINISH);\n if (result != Z_STREAM_END) {\n FATAL() << \"inflate failed!\";\n return nullptr;\n }\n\n result = inflateEnd(&stream);\n if (result != Z_OK) {\n FATAL() << \"inflateEnd failed!\";\n return nullptr;\n }\n#ifdef ZSTD\n } else if (zstd) {\n size_t compressed_size = offsets.end - offsets.start;\n size_t size = ZSTD_decompress(&v->front(), v->size(),\n r.read_bytes(offsets.start, compressed_size), compressed_size);\n if (size != v->size()) {\n FATAL() << \"zstd decompression failed\";\n }\n#endif\n } else {\n FATAL() << \"Unrecognized compression algorithm\";\n }\n\n decompressed_sections.push_back(std::move(v));\n return decompressed_sections.back().get();\n}\n\ntemplate \nSymbolTable ElfReaderImpl::read_symbols(const char* symtab,\n const char* strtab) {\n SymbolTable result;\n if (!ok()) {\n return result;\n }\n\n const typename Arch::ElfShdr* symbols = find_section(symtab);\n if (!symbols) {\n return result;\n }\n const typename Arch::ElfShdr* strings = find_section(strtab);\n if (!strings) {\n return result;\n }\n\n if (symbols->sh_entsize != sizeof(typename Arch::ElfSym)) {\n LOG(debug) << \"Invalid ELF file: incorrect symbol size \"\n << symbols->sh_entsize;\n return result;\n }\n if (symbols->sh_size % symbols->sh_entsize) {\n LOG(debug) << \"Invalid ELF file: incorrect symbol section size \"\n << symbols->sh_size;\n return result;\n }\n if (strings->sh_size == 0) {\n LOG(debug) << \"Invalid ELF file: empty string table\";\n return result;\n }\n\n size_t symbol_list_size = symbols->sh_size / symbols->sh_entsize;\n auto symbol_list = r.read(\n symbols->sh_offset, symbol_list_size);\n if (!symbol_list) {\n LOG(debug) << \"Invalid ELF file: can't read symbols \" << symtab;\n return result;\n }\n auto strtab_ptr = r.read(strings->sh_offset, strings->sh_size);\n if (!strtab_ptr) {\n LOG(debug) << \"Invalid ELF file: can't read strings \" << strtab;\n return result;\n }\n result.strtab.resize(strings->sh_size);\n memcpy(result.strtab.data(), strtab_ptr, result.strtab.size());\n result.strtab[result.strtab.size() - 1] = 0;\n result.symbols.resize(symbol_list_size);\n for (size_t i = 0; i < symbol_list_size; ++i) {\n auto& s = symbol_list[i];\n if (s.st_shndx >= sections_size) {\n // Don't leave this entry uninitialized\n result.symbols[i] = SymbolTable::Symbol(0, 0);\n continue;\n }\n result.symbols[i] = SymbolTable::Symbol(s.st_value, s.st_name);\n }\n return result;\n}\n\ntemplate DynamicSection ElfReaderImpl::read_dynamic() {\n DynamicSection result;\n if (!ok()) {\n return result;\n }\n\n const typename Arch::ElfShdr* dynamic = find_section(\".dynamic\");\n if (!dynamic) {\n return result;\n }\n const typename Arch::ElfShdr* dynstr = find_section(\".dynstr\");\n if (!dynstr) {\n return result;\n }\n\n if (dynamic->sh_entsize != sizeof(typename Arch::ElfDyn)) {\n LOG(debug) << \"Invalid ELF file: incorrect .dynamic size \"\n << dynamic->sh_entsize;\n return result;\n }\n if (!dynamic->sh_size) {\n return result;\n }\n if (dynamic->sh_size % dynamic->sh_entsize) {\n LOG(debug) << \"Invalid ELF file: incorrect .dynamic section size \"\n << dynamic->sh_size;\n return result;\n }\n if (dynstr->sh_size == 0) {\n LOG(debug) << \"Invalid ELF file: empty string table\";\n return result;\n }\n\n size_t dyn_list_size = dynamic->sh_size / dynamic->sh_entsize;\n auto dyn_list = r.read(\n dynamic->sh_offset, dyn_list_size);\n if (!dyn_list) {\n LOG(debug) << \"Invalid ELF file: can't read .dynamic\";\n return result;\n }\n auto strtab = r.read(dynstr->sh_offset, dynstr->sh_size);\n if (!strtab) {\n LOG(debug) << \"Invalid ELF file: can't read .dynstr\";\n return result;\n }\n result.strtab.resize(dynstr->sh_size);\n memcpy(result.strtab.data(), strtab, result.strtab.size());\n result.strtab[result.strtab.size() - 1] = 0;\n result.entries.resize(dyn_list_size);\n for (size_t i = 0; i < dyn_list_size; ++i) {\n auto& s = dyn_list[i];\n result.entries[i] = DynamicSection::Entry(s.d_tag, s.d_val);\n }\n return result;\n}\n\nstatic bool null_terminated(const char* p, size_t size, string& out) {\n size_t len = strnlen(p, size);\n if (len == size) {\n LOG(warn) << \"Invalid file name\";\n return false;\n }\n out = string(p, len);\n return true;\n}\n\ntemplate Debuglink ElfReaderImpl::read_debuglink() {\n Debuglink result;\n if (!ok()) {\n return result;\n }\n\n const typename Arch::ElfShdr* debuglink = find_section(\".gnu_debuglink\");\n if (!debuglink) {\n return result;\n }\n if (debuglink->sh_size < 8) {\n LOG(warn) << \"Invalid ELF file: unexpected .gnu_debuglink length\";\n return result;\n }\n\n size_t crc_offset = debuglink->sh_size - 4;\n if (!r.read_into(debuglink->sh_offset + crc_offset, &result.crc)) {\n LOG(warn) << \"Invalid ELF file: can't read .gnu_debuglink crc checksum\";\n return result;\n }\n\n const char* file_name = r.read(debuglink->sh_offset, crc_offset);\n if (!file_name) {\n LOG(warn) << \"Invalid ELF file: can't read .gnu_debuglink file_name\";\n return result;\n }\n\n null_terminated(file_name, crc_offset, result.file_name);\n return result;\n}\n\ntemplate Debugaltlink ElfReaderImpl::read_debugaltlink() {\n Debugaltlink result;\n if (!ok()) {\n return result;\n }\n\n const typename Arch::ElfShdr* debuglink = find_section(\".gnu_debugaltlink\");\n if (!debuglink) {\n return result;\n }\n // Last 20 bytes are the build ID of the target file. Ignore for now.\n if (debuglink->sh_size < 21) {\n LOG(warn) << \"Invalid ELF file: unexpected .gnu_debugaltlink length\";\n return result;\n }\n\n size_t build_id_offset = debuglink->sh_size - 20;\n const char* file_name = r.read(debuglink->sh_offset, build_id_offset);\n if (!file_name) {\n LOG(warn) << \"Invalid ELF file: can't read .gnu_debugaltlink file_name\";\n return result;\n }\n\n null_terminated(file_name, build_id_offset, result.file_name);\n return result;\n}\n\ntemplate \nstring ElfReaderImpl::read_buildid() {\n string result;\n if (!ok()) {\n return result;\n }\n\n for (size_t i = 0; i < sections_size; ++i) {\n auto& s = sections[i];\n if (s.sh_type != SHT_NOTE) {\n continue;\n }\n\n auto offset = s.sh_offset;\n auto nhdr = r.read(offset);\n if (!nhdr) {\n LOG(error) << \"Failed to read ELF note\";\n return result;\n }\n offset += sizeof(*nhdr);\n\n char name[4] = { 0 };\n if (!(nhdr->n_namesz == 4 &&\n r.read_into(offset, &name) &&\n memcmp(\"GNU\", name, 4) == 0 &&\n nhdr->n_descsz > 0)) {\n continue;\n }\n // Note members are 4 byte aligned, twiddle bits to round up if necessary.\n offset += (nhdr->n_namesz + 3) & ~0x3;\n\n if (nhdr->n_type != NT_GNU_BUILD_ID) {\n continue;\n }\n\n const uint8_t* id = r.read(offset, nhdr->n_descsz);\n if (!id) {\n LOG(error) << \"Failed to read ELF note contents\";\n return result;\n }\n\n result.reserve(nhdr->n_descsz);\n for (unsigned i = 0; i < nhdr->n_descsz; ++i) {\n char byte[3] = { 0 };\n snprintf(&byte[0], 3, \"%02x\", id[i]);\n result.append(byte);\n }\n\n break;\n }\n\n return result;\n}\n\ntemplate \nstring ElfReaderImpl::read_interp() {\n string result;\n if (!ok()) {\n return result;\n }\n\n const typename Arch::ElfPhdr* ph = find_programheader(PT_INTERP);\n if (!ph) {\n return result;\n }\n\n const char* file_name = r.read(ph->p_offset, ph->p_filesz);\n if (!file_name) {\n LOG(warn) << \"Invalid ELF file: can't read PT_INTERP\";\n return result;\n }\n\n null_terminated(file_name, ph->p_filesz, result);\n return result;\n}\n\ntemplate \nbool ElfReaderImpl::addr_to_phdr(uintptr_t addr, PhdrInfo& phdr) {\n for (size_t i = 0; i < programheader_size; ++i) {\n auto& p = programheader[i];\n if (p.p_type == PT_LOAD && addr >= p.p_vaddr &&\n addr - p.p_vaddr < p.p_memsz) {\n phdr.vaddr = p.p_vaddr;\n phdr.offset = p.p_offset;\n phdr.filesz = p.p_filesz;\n phdr.flags = p.p_flags;\n return true;\n }\n }\n\n return false;\n}\n\nElfReader::ElfReader(SupportedArch arch) : arch_(arch), map(nullptr), size(0) {}\n\nElfReader::~ElfReader() {}\n\nElfReaderImplBase& ElfReader::impl() {\n if (!impl_) {\n impl_ = elf_reader_impl(*this, arch_);\n }\n return *impl_;\n}\n\nSymbolTable ElfReader::read_symbols(const char* symtab, const char* strtab) {\n return impl().read_symbols(symtab, strtab);\n}\n\nDynamicSection ElfReader::read_dynamic() { return impl().read_dynamic(); }\n\nDebuglink ElfReader::read_debuglink() { return impl().read_debuglink(); }\n\nDebugaltlink ElfReader::read_debugaltlink() { return impl().read_debugaltlink(); }\n\nSectionOffsets ElfReader::find_section_file_offsets(const char* name) {\n return impl().find_section_file_offsets(name);\n}\n\nDwarfSpan ElfReader::dwarf_section(const char* name, bool known_to_be_compressed) {\n SectionOffsets offsets = impl().find_section_file_offsets(name);\n offsets.compressed |= known_to_be_compressed;\n if (offsets.start && offsets.compressed) {\n auto decompressed = impl().decompress_section(offsets);\n return DwarfSpan(decompressed->data(), decompressed->data() + decompressed->size());\n }\n return DwarfSpan(map + offsets.start, map + offsets.end);\n}\n\nstring ElfReader::read_buildid() { return impl().read_buildid(); }\nstring ElfReader::read_interp() { return impl().read_interp(); }\n\nbool ElfReader::addr_to_phdr(uintptr_t addr, PhdrInfo& phdr) {\n return impl().addr_to_phdr(addr, phdr);\n}\n\nbool ElfReader::ok() { return impl().ok(); }\n\nElfFileReader::ElfFileReader(ScopedFd& fd, SupportedArch arch) : ElfReader(arch) {\n struct stat st;\n if (fstat(fd, &st) < 0) {\n FATAL() << \"Can't stat fd\";\n }\n if (st.st_size > 0) {\n map = static_cast(mmap(nullptr, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0));\n if (map == MAP_FAILED) {\n FATAL() << \"Can't map fd\";\n }\n }\n size = st.st_size;\n}\n\nElfFileReader::~ElfFileReader() {\n if (map) {\n munmap(map, size);\n }\n}\n\nScopedFd ElfFileReader::open_debug_file(const std::string& elf_file_name) {\n if (elf_file_name.empty() || elf_file_name[0] != '/') {\n return ScopedFd();\n }\n\n Debuglink debuglink = read_debuglink();\n if (debuglink.file_name.empty()) {\n return ScopedFd();\n }\n\n size_t last_slash = elf_file_name.find_last_of('/');\n string debug_path = \"/usr/lib/debug/\";\n debug_path += elf_file_name.substr(0, last_slash) + '/' + debuglink.file_name;\n ScopedFd debug_fd(debug_path.c_str(), O_RDONLY);\n if (!debug_fd.is_open()) {\n return ScopedFd();\n }\n\n // Verify that the CRC checksum matches, in case the debuginfo and text file\n // are in separate packages that are out of sync.\n uint32_t crc = 0xffffffff;\n while (true) {\n unsigned char buf[4096];\n ssize_t ret = ::read(debug_fd.get(), buf, sizeof(buf));\n if (ret < 0) {\n if (errno != EINTR) {\n LOG(debug) << \"Error reading \" << debug_path;\n return ScopedFd();\n }\n } else if (ret == 0) {\n break;\n } else {\n crc = update_crc32(crc, buf, ret);\n }\n }\n\n if ((crc ^ 0xffffffff) == debuglink.crc) {\n return debug_fd;\n }\n return ScopedFd();\n}\n\nSupportedArch ElfFileReader::identify_arch(ScopedFd& fd) {\n /**\n * This code is quite lax. That's OK because this is only used to create\n * a specific ElfReaderImpl, which does much more thorough checking of the\n * header.\n */\n static const int header_prefix_size = 20;\n char buf[header_prefix_size];\n ssize_t ret = read_to_end(fd, 0, buf, sizeof(buf));\n if (ret != (ssize_t)sizeof(buf) || buf[5] != 1) {\n return NativeArch::arch();\n }\n switch (buf[18] | (buf[19] << 8)) {\n case 0x03:\n return x86;\n case 0x3e:\n return x86_64;\n default:\n return NativeArch::arch();\n }\n}\n\nbool ElfFileReader::is_x32_abi(__attribute__((unused)) ScopedFd& fd) {\n#if defined(__x86_64__)\n static const int header_prefix_size = 20;\n char buf[header_prefix_size];\n ssize_t ret = read_to_end(fd, 0, buf, sizeof(buf));\n if (ret != (ssize_t)sizeof(buf) || buf[5] != 1) {\n // Who knows what this is.\n return false;\n }\n if ((buf[18] | (buf[19] << 8)) == 0x3e) {\n // x32 ABI programs declare themselves with the amd64 architecture but\n // only 4 byte wide pointers.\n return buf[4] == 1;\n }\n#endif\n\n return false;\n}\n\n} // namespace rr\n" }, { "path": "src/ElfReader.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_ELF_READER_H_\n#define RR_ELF_READER_H_\n\n#include \n\n#include \n#include \n\n#include \"Dwarf.h\"\n#include \"ScopedFd.h\"\n#include \"kernel_abi.h\"\n\nnamespace rr {\n\nclass ElfReaderImplBase;\n\nclass SymbolTable {\npublic:\n const char* name(size_t i) const {\n size_t offset = symbols[i].name_index;\n return offset < strtab.size() ? &strtab[offset] : nullptr;\n }\n bool is_name(size_t i, const char* name) const {\n size_t offset = symbols[i].name_index;\n return offset < strtab.size() && strcmp(&strtab[offset], name) == 0;\n }\n uintptr_t addr(size_t i) const { return symbols[i].addr; }\n size_t size() const { return symbols.size(); }\n\n struct Symbol {\n Symbol(uintptr_t addr, size_t name_index)\n : addr(addr), name_index(name_index) {}\n Symbol() {}\n uintptr_t addr;\n size_t name_index;\n };\n std::vector symbols;\n // Last character is always null map = static_cast(fd);\n\n std::vector strtab;\n};\n\nclass DynamicSection {\npublic:\n struct Entry {\n public:\n Entry(uint64_t tag, uint64_t val) : tag(tag), val(val) {}\n Entry() {}\n uint64_t tag;\n uint64_t val;\n };\n\n std::vector entries;\n // Last character is always null\n std::vector strtab;\n};\n\nclass Debuglink {\npublic:\n std::string file_name;\n uint32_t crc;\n};\n\nclass Debugaltlink {\npublic:\n std::string file_name;\n};\n\nstruct SectionOffsets {\n uint64_t start;\n uint64_t end;\n bool compressed;\n};\n\nstruct PhdrInfo {\n uint64_t vaddr;\n uint64_t offset;\n uint64_t filesz;\n uint64_t flags;\n};\n\nclass ElfReader {\npublic:\n ElfReader(SupportedArch arch);\n virtual ~ElfReader();\n const void* read_bytes(size_t offset, size_t size) {\n if (offset + size > this->size) {\n return nullptr;\n }\n return map + offset;\n }\n template const T* read(size_t offset, size_t count = 1) {\n return static_cast(read_bytes(offset, sizeof(T)*count));\n }\n template bool read_into(size_t offset, T* out) {\n auto r = read(offset);\n if (!r) {\n return false;\n }\n memcpy(out, r, sizeof(*out));\n return true;\n }\n bool ok();\n SymbolTable read_symbols(const char* symtab, const char* strtab);\n DynamicSection read_dynamic();\n Debuglink read_debuglink();\n Debugaltlink read_debugaltlink();\n std::string read_buildid();\n std::string read_interp();\n // Returns true if ELF address |addr| is mapped from a program header in the\n // ELF file, and sets the fields of |phdr| to the program header fields.\n // Returns false if no program header maps to |addr|. |addr| is an address\n // indicated by the ELF file, not its relocated address in memory.\n bool addr_to_phdr(uintptr_t addr, PhdrInfo& phdr);\n SectionOffsets find_section_file_offsets(const char* name);\n DwarfSpan dwarf_section(const char* name, bool known_to_be_compressed = false);\n SupportedArch arch() const { return arch_; }\nprivate:\n ElfReaderImplBase& impl();\n std::unique_ptr impl_;\n SupportedArch arch_;\nprotected:\n uint8_t* map;\n size_t size;\n};\n\nclass ElfFileReader : public ElfReader {\npublic:\n ElfFileReader(ScopedFd& fd, SupportedArch arch);\n ElfFileReader(ScopedFd& fd) : ElfFileReader(fd, identify_arch(fd)) {}\n ~ElfFileReader();\n // Finds and opens the debug file corresponding to this reader.\n // |elf_file_name| is the name of the file already opened by this reader.\n ScopedFd open_debug_file(const std::string& elf_file_name);\n\n static SupportedArch identify_arch(ScopedFd& fd);\n static bool is_x32_abi(ScopedFd& fd);\n};\n\n} // namespace rr\n\n#endif /* RR_ELF_READER_H_ */\n" }, { "path": "src/EmuFs.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"EmuFs.h\"\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n// muslc defines those, but we want a typedef instead\n#if defined(loff_t)\ntypedef loff_t __musl_loff_t;\n#undef loff_t\ntypedef __musl_loff_t loff_t;\n#endif\n\n#include \"AddressSpace.h\"\n#include \"ReplaySession.h\"\n#include \"core.h\"\n#include \"kernel_abi.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nEmuFile::~EmuFile() {\n LOG(debug) << \" EmuFs::~File(einode:\" << inode_ << \")\";\n owner.destroyed_file(*this);\n}\n\nEmuFile::shr_ptr EmuFile::clone(EmuFs& owner) {\n auto f = EmuFile::create(owner, orig_path.c_str(), device(), inode(), size_);\n\n // We could try using FICLONE but tmpfs doesn't support that yet so let's just\n // not bother for now.\n\n // Avoid copying holes.\n vector buf;\n uint64_t offset = 0;\n while (offset < size_) {\n ssize_t ret = lseek(fd(), offset, SEEK_HOLE);\n if (ret < 0) {\n ret = size_;\n } else {\n if (uint64_t(ret) < offset) {\n FATAL() << \"lseek returned hole before requested offset\";\n }\n }\n uint64_t hole = ret;\n // Copy data\n while (offset < hole) {\n loff_t off_in = offset;\n loff_t off_out = offset;\n ssize_t ncopied = syscall(NativeArch::copy_file_range, file.get(), &off_in,\n f->fd().get(), &off_out, hole - offset, 0);\n if (ncopied >= 0) {\n if (ncopied == 0) {\n FATAL() << \"Didn't copy anything\";\n }\n offset += ncopied;\n continue;\n }\n\n ssize_t amount = min(hole - offset, 4*1024*1024);\n buf.resize(amount);\n ret = pread64(fd(), buf.data(), amount, offset);\n if (ret <= 0) {\n FATAL() << \"Couldn't read all the data\";\n }\n ssize_t written = pwrite_all_fallible(f->fd(), buf.data(), ret, offset);\n if (written < ret) {\n FATAL() << \"Couldn't write all the data\";\n }\n offset += written;\n }\n if (offset < size_) {\n // Look for the end of the hole, if any\n ret = lseek(fd(), offset, SEEK_DATA);\n if (ret < 0) {\n if (errno != ENXIO) {\n FATAL() << \"Couldn't find data\";\n }\n break;\n }\n if (uint64_t(ret) <= offset) {\n FATAL() << \"Zero sized hole? Got \" << ret << \" expected \" << offset;\n }\n // Skip the hole\n offset = ret;\n }\n }\n\n return f;\n}\n\nstring EmuFile::proc_path() const {\n stringstream ss;\n ss << \"/proc/\" << getpid() << \"/fd/\" << fd().get();\n return ss.str();\n}\n\nvoid EmuFile::update(dev_t device, ino_t inode, uint64_t size) {\n DEBUG_ASSERT(device_ == device && inode_ == inode);\n ensure_size(size);\n}\n\nvoid EmuFile::ensure_size(uint64_t size) {\n if (size_ < size) {\n resize_shmem_segment(file, size);\n size_ = size;\n }\n}\n\nstd::string make_temp_name(const string& orig_path, dev_t orig_device,\n ino_t orig_inode)\n{\n stringstream name;\n name << \"rr-emufs-\" << getpid() << \"-dev-\" << orig_device\n << \"-inode-\" << orig_inode << \"-\" << orig_path;\n // The linux man page for memfd_create says the length limit for the name\n // argument is 249 bytes, evidently because it prepends \"memfd:\" to the\n // parameter before using it.\n return name.str().substr(0, 249);\n}\n\n/*static*/ EmuFile::shr_ptr EmuFile::create(EmuFs& owner,\n const string& orig_path,\n dev_t orig_device, ino_t orig_inode,\n uint64_t orig_file_size) {\n string real_name = make_temp_name(orig_path, orig_device, orig_inode);\n ScopedFd fd(open_memory_file(real_name));\n if (!fd.is_open()) {\n FATAL() << \"Failed to create shmem segment for \" << real_name;\n }\n resize_shmem_segment(fd, orig_file_size);\n\n shr_ptr f(new EmuFile(owner, std::move(fd), orig_path, real_name, orig_device,\n orig_inode, orig_file_size));\n\n LOG(debug) << \"created emulated file for \" << orig_path << \" as \"\n << real_name;\n return f;\n}\n\nEmuFile::EmuFile(EmuFs& owner, ScopedFd&& fd, const string& orig_path,\n const string& real_path, dev_t orig_device, ino_t orig_inode,\n uint64_t orig_file_size)\n : orig_path(orig_path),\n tmp_path(real_path),\n file(std::move(fd)),\n owner(owner),\n size_(orig_file_size),\n device_(orig_device),\n inode_(orig_inode) {}\n\nEmuFile::shr_ptr EmuFs::at(const KernelMapping& recorded_map) const {\n return files.at(FileId(recorded_map)).lock();\n}\n\nbool EmuFs::has_file_for(const KernelMapping& recorded_map) const {\n return files.find(FileId(recorded_map)) != files.end();\n}\n\nEmuFile::shr_ptr EmuFs::clone_file(EmuFile::shr_ptr file) {\n DEBUG_ASSERT(file);\n auto c = file->clone(*this);\n files[FileId(*file)] = c;\n return c;\n}\n\nEmuFile::shr_ptr EmuFs::get_or_create(const KernelMapping& recorded_km) {\n FileId id(recorded_km);\n auto it = files.find(id);\n uint64_t min_file_size =\n recorded_km.file_offset_bytes() + recorded_km.size();\n if (it != files.end()) {\n it->second.lock()->update(recorded_km.device(), recorded_km.inode(),\n min_file_size);\n return it->second.lock();\n }\n auto vf = EmuFile::create(*this, recorded_km.fsname(), recorded_km.device(),\n recorded_km.inode(), min_file_size);\n files[id] = vf;\n return vf;\n}\n\nEmuFile::shr_ptr EmuFs::find(dev_t device, ino_t inode) {\n FileId id(device, inode);\n auto it = files.find(id);\n if (it == files.end()) {\n return EmuFile::shr_ptr();\n }\n return it->second.lock();\n}\n\nvoid EmuFs::log() const {\n LOG(error) << \"EmuFs \" << this << \" with \" << files.size() << \" files:\";\n for (auto& kv : files) {\n auto file = kv.second.lock();\n LOG(error) << \" \" << file->emu_path();\n }\n}\n\n/*static*/ EmuFs::shr_ptr EmuFs::create() { return shr_ptr(new EmuFs()); }\n\nEmuFs::EmuFs() {}\n\nFileId::FileId(const KernelMapping& recorded_map)\n : device(recorded_map.device()), inode(recorded_map.inode()) {}\n\nFileId::FileId(const EmuFile& emu_file)\n : device(emu_file.device()), inode(emu_file.inode()) {}\n\n} // namespace rr\n" }, { "path": "src/EmuFs.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EMUFS_H_\n#define RR_EMUFS_H_\n\n#include \n#include \n#include \n#include \n\n#include \"ScopedFd.h\"\n\nnamespace rr {\n\nclass AddressSpace;\nclass EmuFs;\nclass KernelMapping;\nclass ReplaySession;\nclass Session;\nclass Task;\n\n/**\n * Implement an \"emulated file system\" consisting of files that were\n * mmap'd shared during recording. These files require special\n * treatment because (i) they were most likely modified during\n * recording, so (ii) the original file contents only exist as\n * snapshots in the trace, but (iii) all mappings of the file must\n * point at the same underlying resource, so that modifications are\n * seen by all mappees.\n *\n * The rr EmuFs creates \"emulated files\" in shared memory during\n * replay. Each efile is uniquely identified at a given event in the\n * trace by |(edev, einode)| (i.e., the recorded device ID and inode).\n * \"What about inode recycling\", you're probably thinking to yourself.\n * This scheme can cope with inode recycling, given a very important\n * assumption discussed below.\n *\n * Why is inode recycling not a problem? Assume that an mmap'd file\n * F_0 at trace time t_0 has the same (device, inode) ID as a\n * different file F_1 at trace time t_1. By definition, if the inode\n * ID was recycled in [t_0, t_1), then all references to F_0 must have\n * been dropped in that interval. A corollary of that is that all\n * memory mappings of F_0 must have been fully unmapped in the\n * interval. As per the first long comment in |gc()| below, an\n * emulated file can only be \"live\" during replay if some tracee still\n * has a mapping of it. Tracees' mappings of emulated files is a\n * subset of the ways they can create references to real files during\n * recording. Therefore the event during replay that drops the last\n * reference to the emulated F_0 must be a tracee unmapping of F_0.\n *\n * So as long as we GC emulated F_0 at the event of its fatal\n * unmapping, the lifetimes of emulated F_0 and emulated F_1 must be\n * disjoint. And F_0 being GC'd at that point is the important\n * assumption mentioned above.\n */\n\nclass EmuFile;\nstruct FileId {\n FileId(const KernelMapping& recorded_map);\n FileId(const EmuFile& emu_file);\n FileId(dev_t device, ino_t inode)\n : device(device), inode(inode) {}\n bool operator==(const FileId& other) const {\n return (device == other.device && inode == other.inode);\n }\n bool operator<(const FileId& other) const {\n return device < other.device ||\n (device == other.device && inode < other.inode);\n }\n dev_t device;\n ino_t inode;\n};\n\n/**\n * A file within an EmuFs. The file is real, but it's mapped to file\n * ID that was recorded during replay.\n */\nclass EmuFile {\npublic:\n typedef std::shared_ptr shr_ptr;\n\n ~EmuFile();\n\n /**\n * Return the fd of the real file backing this.\n */\n const ScopedFd& fd() const { return file; }\n\n /**\n * Return a pathname referring to the fd of this in this\n * tracer's address space. For example, \"/proc/12345/fd/5\".\n */\n std::string proc_path() const;\n\n /**\n * Return the path of the original file from recording, the\n * one this is emulating.\n */\n const std::string emu_path() const { return orig_path; }\n\n const std::string real_path() const { return tmp_path; }\n\n dev_t device() const { return device_; }\n ino_t inode() const { return inode_; }\n\n void ensure_size(uint64_t size);\n\nprivate:\n friend class EmuFs;\n\n EmuFile(EmuFs& owner, ScopedFd&& fd, const std::string& orig_path,\n const std::string& real_path, dev_t device, ino_t inode,\n uint64_t file_size);\n\n /**\n * Return a copy of this file. See |create()| for the meaning\n * of |fs_tag|.\n */\n shr_ptr clone(EmuFs& owner);\n\n /**\n * Ensure that the emulated file is sized to match a later\n * stat() of it.\n */\n void update(dev_t device, ino_t inode, uint64_t size);\n\n /**\n * Create a new emulated file for |orig_path| that will\n * emulate the recorded attributes |est|. |tag| is used to\n * uniquely identify this file among multiple EmuFs's that\n * might exist concurrently in this tracer process.\n */\n static shr_ptr create(EmuFs& owner, const std::string& orig_path,\n dev_t orig_device, ino_t orig_inode,\n uint64_t orig_file_size);\n\n std::string orig_path;\n std::string tmp_path;\n ScopedFd file;\n EmuFs& owner;\n uint64_t size_;\n dev_t device_;\n ino_t inode_;\n\n EmuFile(const EmuFile&) = delete;\n EmuFile operator=(const EmuFile&) = delete;\n};\n\nclass EmuFs {\npublic:\n typedef std::shared_ptr shr_ptr;\n\n /**\n * Return the EmuFile for |recorded_map|, which must exist or this won't\n * return.\n */\n EmuFile::shr_ptr at(const KernelMapping& recorded_map) const;\n\n bool has_file_for(const KernelMapping& recorded_map) const;\n\n EmuFile::shr_ptr clone_file(EmuFile::shr_ptr emu_file);\n\n /**\n * Return an emulated file representing the recorded shared mapping\n * |recorded_km|.\n */\n EmuFile::shr_ptr get_or_create(const KernelMapping& recorded_km);\n\n /**\n * Return an already-existing emulated file for the given device/inode.\n * Returns null if not found.\n */\n EmuFile::shr_ptr find(dev_t device, ino_t inode);\n\n /**\n * Dump information about this emufs to the \"error\" log.\n */\n void log() const;\n\n size_t size() const { return files.size(); }\n\n /** Create and return a new emufs. */\n static shr_ptr create();\n\n void destroyed_file(EmuFile& emu_file) { files.erase(FileId(emu_file)); }\n\nprivate:\n EmuFs();\n\n typedef std::map> FileMap;\n\n FileMap files;\n\n EmuFs(const EmuFs&) = delete;\n EmuFs& operator=(const EmuFs&) = delete;\n};\n\n} // namespace rr\n\n#endif // RR_EMUFS_H\n" }, { "path": "src/Event.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Event.h\"\n\n#include \n\n#include \n#include \n\n#include \"kernel_abi.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nEvent::Event(const Event& o) : event_type(o.event_type) {\n switch (event_type) {\n case EV_DESCHED:\n new (&Desched()) DeschedEvent(o.Desched());\n return;\n case EV_PATCH_SYSCALL:\n new (&PatchSyscall()) PatchSyscallEvent(o.PatchSyscall());\n return;\n case EV_SCHED:\n new (&Sched()) SchedEvent(o.Sched());\n return;\n case EV_SIGNAL:\n case EV_SIGNAL_DELIVERY:\n case EV_SIGNAL_HANDLER:\n new (&Signal()) SignalEvent(o.Signal());\n return;\n case EV_SYSCALL:\n case EV_SYSCALL_INTERRUPTION:\n new (&Syscall()) SyscallEvent(o.Syscall());\n return;\n case EV_SYSCALLBUF_FLUSH:\n new (&SyscallbufFlush()) SyscallbufFlushEvent(o.SyscallbufFlush());\n return;\n default:\n return;\n }\n}\n\nEvent::~Event() {\n switch (event_type) {\n case EV_DESCHED:\n Desched().~DeschedEvent();\n return;\n case EV_PATCH_SYSCALL:\n PatchSyscall().~PatchSyscallEvent();\n return;\n case EV_SIGNAL:\n case EV_SIGNAL_DELIVERY:\n case EV_SIGNAL_HANDLER:\n Signal().~SignalEvent();\n return;\n case EV_SYSCALL:\n case EV_SYSCALL_INTERRUPTION:\n Syscall().~SyscallEvent();\n return;\n case EV_SYSCALLBUF_FLUSH:\n SyscallbufFlush().~SyscallbufFlushEvent();\n return;\n default:\n return;\n }\n}\n\nEvent& Event::operator=(const Event& o) {\n if (this == &o) {\n return *this;\n }\n this->~Event();\n new (this) Event(o);\n return *this;\n}\n\nbool Event::record_regs() const {\n switch (type()) {\n case EV_INSTRUCTION_TRAP:\n case EV_PATCH_SYSCALL:\n case EV_SCHED:\n case EV_SYSCALL:\n case EV_SIGNAL:\n case EV_SIGNAL_DELIVERY:\n case EV_SIGNAL_HANDLER:\n return true;\n default:\n return false;\n }\n}\n\nbool Event::record_extra_regs() const {\n switch (type()) {\n case EV_SYSCALL: {\n const SyscallEvent& sys_ev = Syscall();\n // sigreturn/rt_sigreturn restores register state\n // execve sets everything under the sun, and\n // pkey_alloc modifies the PKRU register.\n return sys_ev.state == EXITING_SYSCALL &&\n (is_sigreturn(sys_ev.number, sys_ev.arch()) ||\n sys_ev.is_exec() ||\n is_pkey_alloc_syscall(sys_ev.number, sys_ev.arch()));\n }\n case EV_SIGNAL:\n // Record extra regs so we can deliver the signal at the\n // right time even when GP regs and ticks values are unchanged\n // but extra regs have changed.\n return true;\n case EV_SIGNAL_HANDLER:\n // entering a signal handler seems to clear FP/SSE regs,\n // so record these effects.\n return true;\n default:\n return false;\n }\n}\n\nbool Event::has_ticks_slop() const {\n switch (type()) {\n case EV_SYSCALLBUF_ABORT_COMMIT:\n case EV_SYSCALLBUF_FLUSH:\n case EV_SYSCALLBUF_RESET:\n case EV_DESCHED:\n case EV_GROW_MAP:\n return true;\n default:\n return false;\n }\n}\n\nbool Event::is_signal_event() const {\n switch (event_type) {\n case EV_SIGNAL:\n case EV_SIGNAL_DELIVERY:\n case EV_SIGNAL_HANDLER:\n return true;\n default:\n return false;\n }\n}\n\nbool Event::is_syscall_event() const {\n switch (event_type) {\n case EV_SYSCALL:\n case EV_SYSCALL_INTERRUPTION:\n return true;\n default:\n return false;\n }\n}\n\nstring Event::str() const {\n stringstream ss;\n ss << type_name();\n switch (event_type) {\n case EV_SIGNAL:\n case EV_SIGNAL_DELIVERY:\n case EV_SIGNAL_HANDLER:\n ss << \": \" << signal_name(Signal().siginfo.si_signo) << \"(\"\n << (const char*)(Signal().deterministic == DETERMINISTIC_SIG ? \"det\"\n : \"async\")\n << \")\";\n break;\n case EV_SYSCALL:\n case EV_SYSCALL_INTERRUPTION:\n ss << \": \" << syscall_name(Syscall().number, Syscall().regs.arch());\n break;\n default:\n // No auxiliary information.\n break;\n }\n return ss.str();\n}\n\nvoid Event::transform(EventType new_type) {\n switch (event_type) {\n case EV_SIGNAL:\n DEBUG_ASSERT(EV_SIGNAL_DELIVERY == new_type);\n break;\n case EV_SIGNAL_DELIVERY:\n DEBUG_ASSERT(EV_SIGNAL_HANDLER == new_type);\n break;\n case EV_SYSCALL:\n DEBUG_ASSERT(EV_SYSCALL_INTERRUPTION == new_type);\n break;\n case EV_SYSCALL_INTERRUPTION:\n DEBUG_ASSERT(EV_SYSCALL == new_type);\n break;\n default:\n FATAL() << \"Can't transform immutable \" << *this << \" into \" << new_type;\n }\n event_type = new_type;\n}\n\nstd::string Event::type_name() const {\n switch (event_type) {\n case EV_SENTINEL:\n return \"(none)\";\n#define CASE(_t) \\\n case EV_##_t: \\\n return #_t\n CASE(EXIT);\n CASE(NOOP);\n CASE(SCHED);\n CASE(SECCOMP_TRAP);\n CASE(INSTRUCTION_TRAP);\n CASE(SYSCALLBUF_FLUSH);\n CASE(SYSCALLBUF_ABORT_COMMIT);\n CASE(SYSCALLBUF_RESET);\n CASE(PATCH_SYSCALL);\n CASE(GROW_MAP);\n CASE(DESCHED);\n CASE(SIGNAL);\n CASE(SIGNAL_DELIVERY);\n CASE(SIGNAL_HANDLER);\n CASE(SYSCALL);\n CASE(SYSCALL_INTERRUPTION);\n CASE(TRACE_TERMINATION);\n#undef CASE\n default:\n FATAL() << \"Unknown event type \" << event_type;\n return \"\"; // not reached\n }\n}\n\nconst char* state_name(SyscallState state) {\n switch (state) {\n#define CASE(_id) \\\n case _id: \\\n return #_id\n CASE(NO_SYSCALL);\n CASE(ENTERING_SYSCALL_PTRACE);\n CASE(ENTERING_SYSCALL);\n CASE(PROCESSING_SYSCALL);\n CASE(EXITING_SYSCALL);\n#undef CASE\n default:\n return \"???state\";\n }\n}\n\n} // namespace rr\n" }, { "path": "src/Event.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EVENT_H_\n#define RR_EVENT_H_\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"MemoryRange.h\"\n#include \"Registers.h\"\n#include \"core.h\"\n#include \"kernel_abi.h\"\n#include \"kernel_metadata.h\"\n#include \"preload/preload_interface.h\"\n\nstruct syscallbuf_record;\n\nnamespace rr {\n\n/**\n * During recording, sometimes we need to ensure that an iteration of\n * RecordSession::record_step schedules the same task as in the previous\n * iteration. The PREVENT_SWITCH value indicates that this is required.\n * For example, the futex operation FUTEX_WAKE_OP modifies userspace\n * memory; those changes are only recorded after the system call completes;\n * and they must be replayed before we allow a context switch to a woken-up\n * task (because the kernel guarantees those effects are seen by woken-up\n * tasks).\n * Entering a potentially blocking system call must use ALLOW_SWITCH, or\n * we risk deadlock. Most non-blocking system calls could use PREVENT_SWITCH\n * or ALLOW_SWITCH; for simplicity we use ALLOW_SWITCH to indicate a call could\n * block and PREVENT_SWITCH otherwise.\n * Note that even if a system call uses PREVENT_SWITCH, as soon as we've\n * recorded the completion of the system call, we can switch to another task.\n */\nenum Switchable { PREVENT_SWITCH, ALLOW_SWITCH };\n\n/**\n * Events serve two purposes: tracking Task state during recording, and\n * being stored in traces to guide replay. Some events are only used during\n * recording and are never actually stored in traces (and are thus irrelevant\n * to replay).\n */\nenum EventType {\n EV_UNASSIGNED,\n EV_SENTINEL,\n // TODO: this is actually a pseudo-pseudosignal: it will never\n // appear in a trace, but is only used to communicate between\n // different parts of the recorder code that should be\n // refactored to not have to do that.\n EV_NOOP,\n EV_DESCHED,\n EV_SECCOMP_TRAP,\n EV_SYSCALL_INTERRUPTION,\n // Not stored in trace, but synthesized when we reach the end of the trace.\n EV_TRACE_TERMINATION,\n\n // Events present in traces:\n\n // No associated data.\n EV_EXIT,\n // Scheduling signal interrupted the trace.\n EV_SCHED,\n // A disabled RDTSC or CPUID instruction.\n EV_INSTRUCTION_TRAP,\n // Recorded syscallbuf data for one or more buffered syscalls.\n EV_SYSCALLBUF_FLUSH,\n EV_SYSCALLBUF_ABORT_COMMIT,\n // The syscallbuf was reset to the empty state. We record this event\n // later than it really happens, because during replay we must proceed to\n // the event *after* a syscallbuf flush and then reset the syscallbuf,\n // to ensure we don't reset it while preload code is still using the data.\n EV_SYSCALLBUF_RESET,\n // Syscall was entered, the syscall instruction was patched, and the\n // syscall was aborted. Resume execution at the patch.\n EV_PATCH_SYSCALL,\n // Map memory pages due to a (future) memory access. This is associated\n // with a mmap entry for the new pages.\n EV_GROW_MAP,\n // Use .signal.\n EV_SIGNAL,\n EV_SIGNAL_DELIVERY,\n EV_SIGNAL_HANDLER,\n // Use .syscall.\n EV_SYSCALL,\n\n EV_LAST\n};\n\n/**\n * Desched events track the fact that a tracee's desched-event\n * notification fired during a may-block buffered syscall, which rr\n * interprets as the syscall actually blocking (for a potentially\n * unbounded amount of time). After the syscall exits, rr advances\n * the tracee to where the desched is \"disarmed\" by the tracee.\n */\nstruct DeschedEvent {\n /** Desched of |rec|. */\n DeschedEvent(remote_ptr rec) : rec(rec) {}\n // Record of the syscall that was interrupted by a desched\n // notification. It's legal to reference this memory /while\n // the desched is being processed only/, because |t| is in the\n // middle of a desched, which means it's successfully\n // allocated (but not yet committed) this syscall record.\n remote_ptr rec;\n};\n\nstruct PatchSyscallEvent {\n PatchSyscallEvent() : patch_trapping_instruction(false),\n patch_after_syscall(false), patch_vsyscall(false) {}\n // If true, this patch is for a trapping instruction, not a real syscall\n bool patch_trapping_instruction;\n // If true, this patch event comes after a syscall (whereas usually they\n // come before). We assume the trace has put us in the correct place\n // and don't try to execute any code to reach this event.\n bool patch_after_syscall;\n // If true, this patch is for the caller of a vsyscall entry point\n bool patch_vsyscall;\n};\n\n/**\n * Sched events track points at which context switches happen that are not\n * otherwise associated with an rr event.\n * Also used to record the point at which a tracee is SIGKILLed, which\n * may require special handling if in the syscallbuf.\n */\nstruct SchedEvent {\n SchedEvent(remote_code_ptr in_syscallbuf_syscall_hook)\n : in_syscallbuf_syscall_hook(in_syscallbuf_syscall_hook) {}\n // If this SchedEvent represents the tracee being SIGKILLed,\n // and syscall buffering is enabled, this contains the address\n // of the 'syscall_hook' function, otherwise zero.\n remote_code_ptr in_syscallbuf_syscall_hook;\n};\n\nstruct SyscallbufFlushEvent {\n SyscallbufFlushEvent() {}\n std::vector mprotect_records;\n};\n\nenum SignalDeterministic { NONDETERMINISTIC_SIG = 0, DETERMINISTIC_SIG = 1 };\nenum SignalResolvedDisposition {\n DISPOSITION_FATAL = 0,\n DISPOSITION_USER_HANDLER = 1,\n DISPOSITION_IGNORED = 2,\n};\nstruct SignalEvent {\n /**\n * Signal |signo| is the signum, and |deterministic| is true\n * for deterministically-delivered signals (see\n * record_signal.cc).\n */\n SignalEvent(const siginfo_t& siginfo, SignalDeterministic deterministic,\n SignalResolvedDisposition disposition)\n : siginfo(siginfo),\n deterministic(deterministic),\n disposition(disposition) {}\n\n // Signal info\n siginfo_t siginfo;\n // True if this signal will be deterministically raised as the\n // side effect of retiring an instruction during replay, for\n // example |load $r 0x0| deterministically raises SIGSEGV.\n SignalDeterministic deterministic;\n SignalResolvedDisposition disposition;\n};\n\n/**\n * Syscall events track syscalls through entry into the kernel,\n * processing in the kernel, and exit from the kernel.\n *\n * This also models interrupted syscalls. During recording, only\n * descheduled buffered syscalls /push/ syscall interruptions; all\n * others are detected at exit time and transformed into syscall\n * interruptions from the original, normal syscalls.\n *\n * Normal system calls (interrupted or not) record two events: ENTERING_SYSCALL\n * and EXITING_SYSCALL. If the process exits before the syscall exit (because\n * this is an exit/exit_group syscall or the process gets SIGKILL), there's no\n * syscall exit event.\n *\n * When PTRACE_SYSCALL is used, there will be three events:\n * ENTERING_SYSCALL_PTRACE to run the process until it gets into the kernel,\n * then ENTERING_SYSCALL and EXITING_SYSCALL. We need three events to handle\n * PTRACE_SYSCALL with clone/fork/vfork and execve. The tracee must run to\n * the ENTERING_SYSCALL_PTRACE state, allow a context switch so the ptracer\n * can modify tracee registers, then perform ENTERING_SYSCALL (which actually\n * creates the new task or does the exec), allow a context switch so the\n * ptracer can modify the new task or post-exec state in a PTRACE_EVENT_EXEC/\n * CLONE/FORK/VFORK, then perform EXITING_SYSCALL to get into the correct\n * post-syscall state.\n *\n * When PTRACE_SYSEMU is used, there will only be one event: an\n * ENTERING_SYSCALL_PTRACE.\n */\nenum SyscallState {\n // Not present in trace. Just a dummy value.\n NO_SYSCALL,\n // Run to the given register state and enter the kernel but don't\n // perform any system call processing yet.\n ENTERING_SYSCALL_PTRACE,\n // Run to the given register state and enter the kernel, if not already\n // there due to a ENTERING_SYSCALL_PTRACE, and then perform the initial part\n // of the system call (any work required before issuing a during-system-call\n // ptrace event).\n ENTERING_SYSCALL,\n // Not present in trace.\n PROCESSING_SYSCALL,\n // Already in the kernel. Perform the final part of the system call and exit\n // with the recorded system call result.\n EXITING_SYSCALL\n};\n\nstruct OpenedFd {\n std::string path;\n int fd;\n dev_t device;\n ino_t inode;\n};\n\nstruct SyscallEvent {\n /** Syscall |syscallno| is the syscall number. */\n SyscallEvent(int syscallno, SupportedArch arch)\n : arch_(arch),\n regs(arch),\n desched_rec(nullptr),\n write_offset(-1),\n state(NO_SYSCALL),\n number(syscallno),\n switchable(PREVENT_SWITCH),\n is_restart(false),\n failed_during_preparation(false),\n in_sysemu(false),\n should_retry_patch(false) {}\n\n std::string syscall_name() const { return rr::syscall_name(number, arch()); }\n\n SupportedArch arch() const { return arch_; }\n /** Change the architecture for this event. */\n void set_arch(SupportedArch a) { arch_ = a; }\n\n bool is_exec() const {\n return is_execve_syscall(number, arch()) || is_execveat_syscall(number, arch());\n }\n\n SupportedArch arch_;\n // The original (before scratch is set up) arguments to the\n // syscall passed by the tracee. These are used to detect\n // restarted syscalls.\n Registers regs;\n // If this is a descheduled buffered syscall, points at the\n // record for that syscall.\n remote_ptr desched_rec;\n\n // Extra data for specific syscalls.\n // -1 to indicate there isn't a write offset.\n int64_t write_offset;\n std::vector exec_fds_to_close;\n std::vector opened;\n std::shared_ptr> socket_addrs;\n // Memory ranges affected by an madvise(). If empty, a successful madvise affected\n // the range indicated by its parameters, and an unsuccessful madvise affected\n // nothing.\n std::vector madvise_ranges;\n\n SyscallState state;\n // Syscall number.\n int number;\n // Records the switchable state when this syscall was prepared\n Switchable switchable;\n // True when this syscall was restarted after a signal interruption.\n bool is_restart;\n // True when this syscall failed during preparation: syscall entry events\n // that were interrupted by a user seccomp filter forcing SIGSYS or errno,\n // and clone system calls that failed. These system calls failed no matter\n // what the syscall-result register says.\n bool failed_during_preparation;\n // Syscall is being emulated via PTRACE_SYSEMU.\n bool in_sysemu;\n // True if we should retry patching on exit from this syscall\n bool should_retry_patch;\n};\n\nstruct syscall_interruption_t {\n syscall_interruption_t(){};\n};\nstatic const syscall_interruption_t interrupted;\n\n/**\n * Sum type for all events (well, a C++ approximation thereof). An\n * Event always has a defined EventType. It can be down-casted to\n * one of the leaf types above iff the type tag is correct.\n */\nstruct Event {\n Event() : event_type(EV_UNASSIGNED) {}\n Event(const DeschedEvent& ev) : event_type(EV_DESCHED), desched(ev) {}\n Event(EventType type, const SignalEvent& ev) : event_type(type), signal(ev) {}\n Event(const SyscallbufFlushEvent& ev)\n : event_type(EV_SYSCALLBUF_FLUSH), syscallbuf_flush(ev) {}\n Event(const SyscallEvent& ev) : event_type(EV_SYSCALL), syscall(ev) {}\n Event(const syscall_interruption_t&, const SyscallEvent& ev)\n : event_type(EV_SYSCALL_INTERRUPTION), syscall(ev) {}\n Event(const Event& o);\n ~Event();\n Event& operator=(const Event& o);\n\n DeschedEvent& Desched() {\n DEBUG_ASSERT(EV_DESCHED == event_type);\n return desched;\n }\n const DeschedEvent& Desched() const {\n DEBUG_ASSERT(EV_DESCHED == event_type);\n return desched;\n }\n\n PatchSyscallEvent& PatchSyscall() {\n DEBUG_ASSERT(EV_PATCH_SYSCALL == event_type);\n return patch;\n }\n const PatchSyscallEvent& PatchSyscall() const {\n DEBUG_ASSERT(EV_PATCH_SYSCALL == event_type);\n return patch;\n }\n\n SchedEvent& Sched() {\n DEBUG_ASSERT(is_sched_event());\n return sched_;\n }\n const SchedEvent& Sched() const {\n DEBUG_ASSERT(is_sched_event());\n return sched_;\n }\n\n SyscallbufFlushEvent& SyscallbufFlush() {\n DEBUG_ASSERT(EV_SYSCALLBUF_FLUSH == event_type);\n return syscallbuf_flush;\n }\n const SyscallbufFlushEvent& SyscallbufFlush() const {\n DEBUG_ASSERT(EV_SYSCALLBUF_FLUSH == event_type);\n return syscallbuf_flush;\n }\n\n SignalEvent& Signal() {\n DEBUG_ASSERT(is_signal_event());\n return signal;\n }\n const SignalEvent& Signal() const {\n DEBUG_ASSERT(is_signal_event());\n return signal;\n }\n\n SyscallEvent& Syscall() {\n DEBUG_ASSERT(is_syscall_event());\n return syscall;\n }\n const SyscallEvent& Syscall() const {\n DEBUG_ASSERT(is_syscall_event());\n return syscall;\n }\n\n bool record_regs() const;\n\n bool record_extra_regs() const;\n\n bool has_ticks_slop() const;\n\n /**\n * Return true if this is one of the indicated type of events.\n */\n bool is_signal_event() const;\n bool is_sched_event() const {\n return event_type == EV_SCHED;\n }\n bool is_syscall_event() const;\n bool is_syscallbuf_flush_event() const {\n return event_type == EV_SYSCALLBUF_FLUSH;\n }\n\n /** Return a string describing this. */\n std::string str() const;\n\n /**\n * Dynamically change the type of this. Only a small number\n * of type changes are allowed.\n */\n void transform(EventType new_type);\n\n /** Return the current type of this. */\n EventType type() const { return event_type; }\n\n /** Return a string naming |ev|'s type. */\n std::string type_name() const;\n\n static Event noop() { return Event(EV_NOOP); }\n static Event trace_termination() { return Event(EV_TRACE_TERMINATION); }\n static Event instruction_trap() { return Event(EV_INSTRUCTION_TRAP); }\n static Event patch_syscall() {\n auto ev = Event(EV_PATCH_SYSCALL);\n ev.PatchSyscall().patch_after_syscall = false;\n ev.PatchSyscall().patch_vsyscall = false;\n ev.PatchSyscall().patch_trapping_instruction = false;\n return ev;\n }\n static Event sched() {\n auto ev = Event(EV_SCHED);\n ev.Sched().in_syscallbuf_syscall_hook = remote_code_ptr();\n return ev;\n }\n static Event seccomp_trap() { return Event(EV_SECCOMP_TRAP); }\n static Event syscallbuf_abort_commit() {\n return Event(EV_SYSCALLBUF_ABORT_COMMIT);\n }\n static Event syscallbuf_reset() { return Event(EV_SYSCALLBUF_RESET); }\n static Event grow_map() { return Event(EV_GROW_MAP); }\n static Event exit() { return Event(EV_EXIT); }\n static Event sentinel() { return Event(EV_SENTINEL); }\n\nprivate:\n Event(EventType type) : event_type(type) {}\n\n EventType event_type;\n union {\n DeschedEvent desched;\n PatchSyscallEvent patch;\n SchedEvent sched_;\n SignalEvent signal;\n SyscallEvent syscall;\n SyscallbufFlushEvent syscallbuf_flush;\n };\n};\n\ninline static std::ostream& operator<<(std::ostream& o, const Event& ev) {\n return o << ev.str();\n}\n\nconst char* state_name(SyscallState state);\n\n} // namespace rr\n\n#endif // EVENT_H_\n" }, { "path": "src/ExportImportCheckpoints.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ExportImportCheckpoints.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"log.h\"\n#include \"main.h\"\n#include \"WaitManager.h\"\n\nusing namespace std;\n\n/* Clients connect to the checkpoints socket and may send a one-byte command.\n Currently the only valid command value is 0: create a checkpoint.\n*/\n\nnamespace rr {\n\nbool parse_export_checkpoints(const string& arg, FrameTime& export_checkpoints_event,\n int& export_checkpoints_count, string& export_checkpoints_socket) {\n size_t first_comma = arg.find(',');\n if (first_comma == string::npos) {\n fprintf(stderr, \"Missing parameter for --export-checkpoints\");\n return false;\n }\n size_t second_comma = arg.find(',', first_comma + 1);\n if (second_comma == string::npos) {\n fprintf(stderr, \"Missing parameter for --export-checkpoints\");\n return false;\n }\n char* endptr;\n string event_str = arg.substr(0, first_comma);\n export_checkpoints_event = strtoul(event_str.c_str(), &endptr, 0);\n if (*endptr) {\n fprintf(stderr, \"Invalid for --export-checkpoints: %s\\n\", event_str.c_str());\n return false;\n }\n string num_str = arg.substr(first_comma + 1, second_comma - (first_comma + 1));\n export_checkpoints_count = strtoul(num_str.c_str(), &endptr, 0);\n if (*endptr) {\n fprintf(stderr, \"Invalid for --export-checkpoints: %s\\n\", num_str.c_str());\n return false;\n }\n export_checkpoints_socket = arg.substr(second_comma + 1);\n return true;\n}\n\nScopedFd bind_export_checkpoints_socket(int count, const string& socket_file_name) {\n unlink(socket_file_name.c_str());\n\n ScopedFd sock = ScopedFd(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0));\n if (!sock.is_open()) {\n FATAL() << \"Can't create Unix socket \" << socket_file_name;\n }\n if (socket_file_name.size() + 1 > sizeof(sockaddr_un::sun_path)) {\n FATAL() << \"Socket file name \" << socket_file_name << \" too long\";\n }\n int reuse = 1;\n int ret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));\n if (ret < 0) {\n FATAL() << \"Failed to set SO_REUSEADDR\";\n }\n sockaddr_un addr;\n addr.sun_family = AF_UNIX;\n strcpy(addr.sun_path, socket_file_name.c_str());\n ret = ::bind(sock, (const sockaddr*)&addr, sizeof(addr));\n if (ret < 0) {\n FATAL() << \"Can't bind Unix socket \" << socket_file_name;\n }\n ret = listen(sock, count);\n if (ret < 0) {\n FATAL() << \"Can't listen on Unix socket \" << socket_file_name;\n }\n return sock;\n}\n\nstatic void send_all(ScopedFd& sock, const void* vbuf, size_t count) {\n const char* buf = static_cast(vbuf);\n while (count > 0) {\n ssize_t ret = send(sock, buf, count, 0);\n if (ret <= 0) {\n FATAL() << \"Failed to send complete message\";\n }\n count -= ret;\n buf += ret;\n }\n}\n\nstatic void recv_all(ScopedFd& sock, void* vbuf, size_t count) {\n char* buf = static_cast(vbuf);\n while (count > 0) {\n ssize_t ret = recv(sock, buf, count, 0);\n if (ret <= 0) {\n FATAL() << \"Failed to recv complete message\";\n }\n count -= ret;\n buf += ret;\n }\n}\n\nstatic void setup_child_fds(vector fds, CommandForCheckpoint& command_for_checkpoint) {\n command_for_checkpoint.exit_notification_fd = ScopedFd(fds[0]);\n for (int our_fd = 0; our_fd < 3; ++our_fd) {\n // We deliberately don't set CLOEXEC here since we might want these\n // to be inherited.\n int ret = dup2(fds[our_fd + 1], our_fd);\n if (ret < 0) {\n FATAL() << \"Can't dup over stdin/stdout/stderr\";\n }\n close(fds[our_fd + 1]);\n }\n\n for (size_t i = 4; i < fds.size(); ++i) {\n command_for_checkpoint.fds.push_back(ScopedFd(fds[i]));\n }\n}\n\nstatic void set_title(const vector& args) {\n string line = \"rr:\";\n for (auto& a : args) {\n line += ' ';\n line += a;\n }\n\n char* arg0 = saved_argv0();\n size_t space = saved_argv0_space() - 1;\n if (space < 3) {\n return;\n }\n // To simplify things, instead of moving the environment around when the new command is too long,\n // we just truncate it.\n if (line.size() > space) {\n line[space - 3] = line[space - 2] = line[space - 1] = '.';\n line.resize(space);\n }\n memcpy(arg0, line.data(), line.size());\n memset(arg0 + line.size(), 0, space - line.size());\n}\n\nCommandForCheckpoint export_checkpoints(ReplaySession::shr_ptr session, int count, ScopedFd& sock,\n const std::string&) {\n if (!session->can_clone()) {\n FATAL() << \"Can't create checkpoints at this time, aborting: \" << session->current_frame_time();\n }\n\n CommandForCheckpoint command_for_checkpoint;\n\n vector children;\n for (int i = 0; i < count; ++i) {\n ScopedFd client = ScopedFd(accept4(sock, nullptr, nullptr, SOCK_CLOEXEC));\n if (!client.is_open()) {\n FATAL() << \"Failed to accept client connection\";\n }\n\n ssize_t priority;\n recv_all(client, &priority, sizeof(priority));\n ssize_t ret = setpriority(PRIO_PROCESS, 0, priority);\n if (ret < 0) {\n if (errno == EACCES) {\n LOG(warn) << \"Failed to increase priority\";\n } else {\n FATAL() << \"Failed setpriority\";\n }\n }\n\n size_t fds_size;\n recv_all(client, &fds_size, sizeof(fds_size));\n\n // Do the SCM_RIGHTS dance to receive file descriptors\n msghdr msg;\n memset(&msg, 0, sizeof(msg));\n char dummy_buf;\n iovec iov = { &dummy_buf, 1 };\n msg.msg_iov = &iov;\n msg.msg_iovlen = 1;\n vector cbuf;\n size_t data_len = sizeof(int)*fds_size;\n cbuf.resize(CMSG_SPACE(data_len));\n msg.msg_control = cbuf.data();\n msg.msg_controllen = cbuf.size();\n ret = recvmsg(client, &msg, MSG_CMSG_CLOEXEC);\n if (ret != 1) {\n FATAL() << \"Failed to read fds\";\n }\n cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);\n if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS || cmsg->cmsg_len != CMSG_LEN(data_len)) {\n FATAL() << \"Invalid cmsg metadata\";\n }\n vector fds_data;\n fds_data.resize(fds_size);\n memcpy(fds_data.data(), CMSG_DATA(cmsg), data_len);\n\n size_t arg_count;\n recv_all(client, &arg_count, sizeof(arg_count));\n vector args;\n for (size_t i = 0; i < arg_count; ++i) {\n size_t arg_size;\n recv_all(client, &arg_size, sizeof(arg_size));\n vector arg;\n arg.resize(arg_size);\n recv_all(client, arg.data(), arg_size);\n args.push_back(string(arg.data(), arg.size()));\n }\n\n ReplaySession::shr_ptr checkpoint = session->clone();\n int parent_to_child_fds[2];\n ret = pipe(parent_to_child_fds);\n if (ret < 0) {\n FATAL() << \"Can't pipe\";\n }\n ScopedFd parent_to_child_read(parent_to_child_fds[0]);\n ScopedFd parent_to_child_write(parent_to_child_fds[1]);\n\n checkpoint->prepare_to_detach_tasks();\n\n // We need to create a new control socket for the child, we can't use the shared control socket\n // safely in multiple processes.\n int sockets[2];\n ret = socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sockets);\n if (ret < 0) {\n FATAL() << \"socketpair failed\";\n }\n ScopedFd new_tracee_socket(sockets[0]);\n ScopedFd new_tracee_socket_receiver(sockets[1]);\n\n pid_t child = fork();\n if (!child) {\n set_title(args);\n session->forget_tasks();\n command_for_checkpoint.args = std::move(args);\n command_for_checkpoint.session = std::move(checkpoint);\n setup_child_fds(fds_data, command_for_checkpoint);\n char ch;\n ret = read(parent_to_child_read, &ch, 1);\n if (ret != 1) {\n FATAL() << \"Failed to read parent notification\";\n }\n command_for_checkpoint.session->reattach_tasks(std::move(new_tracee_socket),\n std::move(new_tracee_socket_receiver));\n return command_for_checkpoint;\n }\n children.push_back(child);\n\n checkpoint->detach_tasks(child, new_tracee_socket_receiver);\n ret = write(parent_to_child_write, \"x\", 1);\n if (ret != 1) {\n FATAL() << \"Failed to write parent notification\";\n }\n for (auto d : fds_data) {\n close(d);\n }\n }\n\n // Wait for and reap all children\n for (size_t i = 0; i < children.size(); ++i) {\n WaitResult result = WaitManager::wait_exit(WaitOptions(children[i]));\n if (result.code != WAIT_OK) {\n FATAL() << \"Failed to wait for child \" << children[i];\n }\n }\n\n return command_for_checkpoint;\n}\n\nvoid notify_normal_exit(ScopedFd& exit_notification_fd) {\n ssize_t ret = write(exit_notification_fd, \"\", 1);\n if (ret != 1) {\n FATAL() << \"Can't send exit notification\";\n }\n}\n\nint invoke_checkpoint_command(const string& socket_file_name,\n vector args, vector fds) {\n ScopedFd sock = ScopedFd(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0));\n if (!sock.is_open()) {\n FATAL() << \"Can't create Unix socket \" << socket_file_name;\n }\n if (socket_file_name.size() + 1 > sizeof(sockaddr_un::sun_path)) {\n FATAL() << \"Socket file name \" << socket_file_name << \" too long\";\n }\n sockaddr_un addr;\n addr.sun_family = AF_UNIX;\n strcpy(addr.sun_path, socket_file_name.c_str());\n while (true) {\n ssize_t ret = connect(sock, (const sockaddr*)&addr, sizeof(addr));\n if (ret < 0) {\n // We might try to connect between the socket being bound and listen()ed on\n if (errno == ENOENT || errno == ECONNREFUSED) {\n sleep(1);\n continue;\n }\n FATAL() << \"Can't connect socket \" << socket_file_name;\n }\n break;\n }\n\n ssize_t ret = getpriority(PRIO_PROCESS, 0);\n if (ret < 0) {\n FATAL() << \"Failed getpriority\";\n }\n send_all(sock, &ret, sizeof(ret));\n\n size_t total_fds = 4 + fds.size();\n send_all(sock, &total_fds, sizeof(total_fds));\n\n int exit_notification_pipe_fds[2];\n ret = pipe(exit_notification_pipe_fds);\n if (ret < 0) {\n FATAL() << \"Failed pipe\";\n }\n\n // Do the SCM_RIGHTS dance to send file descriptors.\n msghdr msg;\n memset(&msg, 0, sizeof(msg));\n char ch = 'x';\n iovec iov = { &ch, 1 };\n msg.msg_iov = &iov;\n msg.msg_iovlen = 1;\n vector cbuf;\n size_t data_len = sizeof(int)*total_fds;\n cbuf.resize(CMSG_SPACE(data_len));\n msg.msg_control = cbuf.data();\n msg.msg_controllen = cbuf.size();\n cmsghdr* cmsg = CMSG_FIRSTHDR(&msg);\n cmsg->cmsg_level = SOL_SOCKET;\n cmsg->cmsg_type = SCM_RIGHTS;\n cmsg->cmsg_len = CMSG_LEN(data_len);\n char* cmsg_data = (char*)CMSG_DATA(cmsg);\n vector int_fds;\n int_fds.push_back(exit_notification_pipe_fds[1]);\n int_fds.push_back(0);\n int_fds.push_back(1);\n int_fds.push_back(2);\n for (auto& fd : fds) {\n int_fds.push_back(fd);\n }\n memcpy(cmsg_data, int_fds.data(), sizeof(int)*int_fds.size());\n ret = sendmsg(sock, &msg, 0);\n if (ret != 1) {\n FATAL() << \"Can't send file descriptors\";\n }\n close(exit_notification_pipe_fds[1]);\n // Close stdin but keep stdout/stderr open in case we need to print something ourselves.\n close(0);\n\n size_t arg_count = args.size();\n send_all(sock, &arg_count, sizeof(arg_count));\n for (auto& arg : args) {\n size_t arg_size = arg.size();\n send_all(sock, &arg_size, sizeof(arg_size));\n send_all(sock, arg.data(), arg_size);\n }\n\n ret = read(exit_notification_pipe_fds[0], &ch, 1);\n if (ret < 0) {\n FATAL() << \"Can't read from notification pipe\";\n }\n if (ret == 0) {\n // abnormal termination\n return 1;\n }\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/ExportImportCheckpoints.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EXPORT_IMPORT_CHECKPOINTS_H_\n#define RR_EXPORT_IMPORT_CHECKPOINTS_H_\n\n#include \"ReplaySession.h\"\n\n#include \n#include \n\nnamespace rr {\n\nbool parse_export_checkpoints(const std::string& arg, FrameTime& export_checkpoints_event,\n int& export_checkpoints_count, std::string& export_checkpoints_socket);\n\n/* Bind the socket so clients can try to connect to it and block. */\nScopedFd bind_export_checkpoints_socket(int count, const std::string& socket_file_name);\n\n/* A command to run on the checkpoint */\nstruct CommandForCheckpoint {\n std::vector args;\n std::vector fds;\n ReplaySession::shr_ptr session;\n ScopedFd exit_notification_fd;\n};\n\n/* Export checkpoints from the given session.\n This function will return `count` + 1 times; the first `count` times in a forked child\n with a valid CommandForCheckpoint with a nonnull `session`; the last time with a null\n `session` when all forked children have exited and been reaped.\n For the child returns, stdin/stdout/stderr will have been rebound to fds passed in over\n the socket.\n*/\nCommandForCheckpoint export_checkpoints(ReplaySession::shr_ptr session, int count, ScopedFd& sock,\n const std::string& socket_file_name);\n\n/* After performing the CommandForCheckpoint, notify that we have exited normally. */\nvoid notify_normal_exit(ScopedFd& exit_notification_fd);\n\n/* Invoke a command on a checkpoint. stdin/stdout/stderr and the args and fds\n are passed to the exporter process, then we wait for it to complete and exit, and return\n an appropriate exit code.\n*/\nint invoke_checkpoint_command(const std::string& socket_file_name,\n std::vector args, std::vector fds = std::vector());\n\n} // namespace rr\n\n#endif /* RR_EXPORT_IMPORT_CHECKPOINTS_H_ */\n" }, { "path": "src/ExtraRegisters.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ExtraRegisters.h\"\n\n#include \n\n#include \"GdbServerRegister.h\"\n#include \"ReplayTask.h\"\n#include \"core.h\"\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n// This is the byte offset at which the ST0-7 register data begins\n// with an xsave (or fxsave) block.\nstatic const int st_regs_offset = 32;\n// NB: each STx register holds 10 bytes of actual data, but each\n// occupies 16 bytes of space within (f)xsave, presumably for\n// alignment purposes.\nstatic const int st_reg_space = 16;\n\n// Byte offset at which the XMM0-15 register data begins with (f)xsave.\nstatic const int xmm_regs_offset = 160;\nstatic const int xmm_reg_space = 16;\n\nstatic const uint8_t fxsave_387_ctrl_offsets[] = {\n // The Intel documentation says that the following layout is only valid in\n // 32-bit mode, or when fxsave is executed in 64-bit mode without an\n // appropriate REX prefix. The kernel seems to only use fxsave with the\n // REX prefix, so one would think these offsets would be different. But\n // GDB seems happy to use these offsets, so that's what we use too.\n 0, // DREG_64_FCTRL\n 2, // DREG_64_FSTAT\n 4, // DREG_64_FTAG\n 12, // DREG_64_FISEG\n 8, // DREG_64_FIOFF\n 20, // DREG_64_FOSEG\n 16, // DREG_64_FOOFF\n 6, // DREG_64_FOP\n};\n\nstatic const int fip_offset = 8;\nstatic const int fop_offset = 6;\nstatic const int fdp_offset = 16;\nstatic const int mxcsr_offset = 24;\n\nstruct RegData {\n int offset;\n int size;\n int xsave_feature_bit;\n\n RegData(int offset = -1, int size = 0)\n : offset(offset), size(size), xsave_feature_bit(-1) {}\n};\n\nstatic bool reg_in_range(GdbServerRegister regno, GdbServerRegister low, GdbServerRegister high,\n int offset_base, int offset_stride, int size,\n RegData* out) {\n if (regno < low || regno > high) {\n return false;\n }\n out->offset = offset_base + offset_stride * (regno - low);\n out->size = size;\n return true;\n}\n\nstatic constexpr int AVX_FEATURE_BIT = 2;\nstatic constexpr int AVX_OPMASK_FEATURE_BIT = 5;\nstatic constexpr int AVX_ZMM_HI256_FEATURE_BIT = 6;\nstatic constexpr int AVX_ZMM_HI16_FEATURE_BIT = 7;\nstatic constexpr int PKRU_FEATURE_BIT = 9;\n\nstatic const uint64_t PKRU_FEATURE_MASK = 1 << PKRU_FEATURE_BIT;\n\nstatic const size_t xsave_header_offset = 512;\nstatic const size_t xsave_header_size = 64;\nstatic const size_t xsave_header_end = xsave_header_offset + xsave_header_size;\nstruct RegisterDescriptor {\n // Feature bits given by CPUID\n int8_t feature;\n // Width in bytes in the xsave area\n int8_t size;\n // If the registers described by this descriptor is laid out in Hi16 ranges,\n // value can be non-zero.\n int8_t hi16_offset;\n // Range of registers described by descriptor\n GdbServerRegister base;\n GdbServerRegister end_inclusive;\n // The stride of the register (how far between the start of this register to\n // the next register of the same type, in the xsave area)\n int stride;\n\n int register_offset(GdbServerRegister reg) const noexcept {\n DEBUG_ASSERT(reg >= base && reg < (base + 16));\n const auto& layout = xsave_native_layout();\n return layout.feature_layouts[feature].offset + hi16_offset +\n (reg - base) * stride;\n }\n\n bool describes_register(GdbServerRegister gdb_register) const {\n // compare end first because we search table linerarly.\n return gdb_register <= end_inclusive && gdb_register >= base;\n }\n};\n\n/**\n * These descriptors describe the layout of the XSAVE area for avx2 and\n * avx512 extensions. where the actual contents for the registers get read from.\n * `RegisterDescriptor::feature` is used to index into `XSaveFeatureLayout` to\n * get the base offset for a particular range.\n *\n * Register ranges in the xsave area that differ is the Hi16 ones.\n * In these ranges, the registers are laid out like [xmmN, ymmN, zmmN],\n * instead of [xmm0..N], [ymm0..N]. So to get e.g. zmm18 we need 3 offsets;\n * 1. offset to the sub-region of xsave for [xmmN, ymmN, zmmN] are found (N>15)\n * 2. offset to where register-range N=18 begins, e.g. [xmm18, ymm18, zmm18]\n * 3. offset to where zmm begins; which is 32 bytes.\n */\nstatic constexpr std::array register_config_lookup_table{\n { { AVX_FEATURE_BIT, 16, 0, DREG_64_YMM0H,\n GdbServerRegister(DREG_64_YMM15H), 16 },\n { AVX_ZMM_HI16_FEATURE_BIT, 16, 0, DREG_64_XMM16,\n GdbServerRegister(DREG_64_XMM31), 64 },\n { AVX_ZMM_HI16_FEATURE_BIT, 16, 16, DREG_64_YMM16H,\n GdbServerRegister(DREG_64_YMM31H), 64 },\n { AVX_ZMM_HI256_FEATURE_BIT, 32, 0, DREG_64_ZMM0H,\n GdbServerRegister(DREG_64_ZMM15H), 32 },\n { AVX_ZMM_HI16_FEATURE_BIT, 32, 32, DREG_64_ZMM16H,\n GdbServerRegister(DREG_64_ZMM31H), 64 },\n { AVX_OPMASK_FEATURE_BIT, 8, 0, DREG_64_K0,\n GdbServerRegister(DREG_64_K7), 8 } }\n};\n\n// Every range of registers (except K0-7) are 16 registers long. We use this\n// fact to build a lookup table, for the AVX2 and AVX512 registers.\nstatic bool reg_is_avx2_or_512(GdbServerRegister reg, RegData& out) noexcept {\n if (reg < DREG_64_YMM0H || reg > DREG_64_K7) {\n return false;\n }\n\n for (const auto& descriptor : register_config_lookup_table) {\n if (descriptor.describes_register(reg)) {\n out.xsave_feature_bit = descriptor.feature;\n out.size = descriptor.size;\n out.offset = descriptor.register_offset(reg);\n return true;\n }\n }\n FATAL() << \"Unknown AVX512F register: \" << reg;\n return true;\n}\n\n// Return the size and data location of register |regno|.\n// If we can't read the register, returns -1 in 'offset'.\nstatic RegData xsave_register_data(SupportedArch arch, GdbServerRegister regno) {\n // Check regno is in range, and if it's 32-bit then convert it to the\n // equivalent 64-bit register.\n switch (arch) {\n case x86:\n // Convert regno to the equivalent 64-bit version since the XSAVE layout\n // is compatible\n if (regno >= DREG_XMM0 && regno <= DREG_XMM7) {\n regno = (GdbServerRegister)(regno - DREG_XMM0 + DREG_64_XMM0);\n break;\n }\n if (regno >= DREG_YMM0H && regno <= DREG_YMM7H) {\n regno = (GdbServerRegister)(regno - DREG_YMM0H + DREG_64_YMM0H);\n break;\n }\n if (regno >= DREG_ZMM0H && regno <= DREG_ZMM7H) {\n regno = (GdbServerRegister)(regno - DREG_ZMM0H + DREG_64_ZMM0H);\n break;\n }\n if (regno >= DREG_K0 && regno <= DREG_K7) {\n regno = (GdbServerRegister)(regno - DREG_K0 + DREG_64_K0);\n break;\n }\n if (regno == DREG_MXCSR) {\n regno = DREG_64_MXCSR;\n } else if (regno == DREG_PKRU) {\n regno = DREG_64_PKRU;\n } else if (regno < DREG_FIRST_FXSAVE_REG || regno > DREG_LAST_FXSAVE_REG) {\n return RegData();\n } else {\n regno = (GdbServerRegister)(regno - DREG_FIRST_FXSAVE_REG +\n DREG_64_FIRST_FXSAVE_REG);\n }\n break;\n case x86_64:\n break;\n default:\n DEBUG_ASSERT(0 && \"Unknown arch\");\n return RegData();\n }\n\n RegData result;\n if (reg_in_range(regno, DREG_64_ST0, DREG_64_ST7, st_regs_offset,\n st_reg_space, 10, &result)) {\n return result;\n }\n if (reg_in_range(regno, DREG_64_XMM0, DREG_64_XMM15, xmm_regs_offset,\n xmm_reg_space, 16, &result)) {\n return result;\n }\n\n if (reg_is_avx2_or_512(regno, result)) {\n return result;\n }\n\n if (regno == DREG_64_PKRU) {\n const XSaveLayout& layout = xsave_native_layout();\n if (PKRU_FEATURE_BIT > layout.feature_layouts.size()) {\n return RegData();\n }\n\n const XSaveFeatureLayout& fl = layout.feature_layouts[PKRU_FEATURE_BIT];\n result.offset = fl.offset;\n // NB: the PKRU *region* may be 8 bytes to maintain alignment but the\n // PKRU *register* is only the first 4 bytes.\n result.size = 4;\n result.xsave_feature_bit = PKRU_FEATURE_BIT;\n return result;\n }\n\n if (regno < DREG_64_FIRST_FXSAVE_REG || regno > DREG_64_LAST_FXSAVE_REG) {\n return RegData();\n }\n if (regno == DREG_64_MXCSR) {\n return RegData(24, 4);\n }\n DEBUG_ASSERT(regno >= DREG_64_FCTRL && regno <= DREG_64_FOP);\n // NB: most of these registers only occupy 2 bytes of space in\n // the (f)xsave region, but gdb's default x86 target\n // config expects us to send back 4 bytes of data for\n // each.\n return RegData(fxsave_387_ctrl_offsets[regno - DREG_64_FCTRL], 4);\n}\n\nstatic const uint64_t* xsave_features(const vector& data) {\n // If this is just FXSAVE(64) data then we we have no XSAVE header and no\n // XSAVE(64) features enabled.\n return data.size() < xsave_header_offset + xsave_header_size\n ? nullptr\n : reinterpret_cast(data.data() +\n xsave_header_offset);\n\n}\n\nstatic uint64_t* xsave_features(vector& data) {\n // If this is just FXSAVE(64) data then we we have no XSAVE header and no\n // XSAVE(64) features enabled.\n return data.size() < xsave_header_offset + xsave_header_size\n ? nullptr\n : reinterpret_cast(data.data() + xsave_header_offset);\n}\n\nsize_t ExtraRegisters::read_register(uint8_t* buf, GdbServerRegister regno,\n bool* defined) const {\n if (format_ == NT_FPR) {\n if (arch() != aarch64) {\n *defined = false;\n return 0;\n }\n\n RegData reg_data;\n if (DREG_V0 <= regno && regno <= DREG_V31) {\n reg_data = RegData(offsetof(ARM64Arch::user_fpsimd_state, vregs[0]) +\n ((regno - DREG_V0) * 16), 16);\n } else if (regno == DREG_FPSR) {\n reg_data = RegData(offsetof(ARM64Arch::user_fpsimd_state, fpsr),\n sizeof(uint32_t));\n } else if (regno == DREG_FPCR) {\n reg_data = RegData(offsetof(ARM64Arch::user_fpsimd_state, fpcr),\n sizeof(uint32_t));\n } else {\n *defined = false;\n return 0;\n }\n\n DEBUG_ASSERT(size_t(reg_data.offset + reg_data.size) <= data_.size());\n *defined = true;\n memcpy(buf, data_.data() + reg_data.offset, reg_data.size);\n return reg_data.size;\n }\n\n if (format_ != XSAVE) {\n *defined = false;\n return 0;\n }\n\n auto reg_data = xsave_register_data(arch(), regno);\n if (reg_data.offset < 0 || empty()) {\n *defined = false;\n return reg_data.size;\n }\n\n DEBUG_ASSERT(reg_data.size > 0);\n\n *defined = true;\n\n // Apparently before any AVX registers are used, the feature bit is not set\n // in the XSAVE data, so we'll just return 0 for them here.\n const uint64_t* xsave_features_ = xsave_features(data_);\n if (reg_data.xsave_feature_bit >= 0 &&\n (!xsave_features_ ||\n !(*xsave_features_ & (1 << reg_data.xsave_feature_bit)))) {\n memset(buf, 0, reg_data.size);\n } else {\n DEBUG_ASSERT(size_t(reg_data.offset + reg_data.size) <= data_.size());\n memcpy(buf, data_.data() + reg_data.offset, reg_data.size);\n }\n return reg_data.size;\n}\n\nbool ExtraRegisters::write_register(GdbServerRegister regno, const void* value,\n size_t value_size) {\n if (format_ == NT_FPR) {\n if (arch() != aarch64) {\n return false;\n }\n\n RegData reg_data;\n if (DREG_V0 <= regno && regno <= DREG_V31) {\n reg_data = RegData(offsetof(ARM64Arch::user_fpsimd_state, vregs[0]) +\n ((regno - DREG_V0) * 16), 16);\n } else if (regno == DREG_FPSR) {\n reg_data = RegData(offsetof(ARM64Arch::user_fpsimd_state, fpsr),\n sizeof(uint32_t));\n } else if (regno == DREG_FPCR) {\n reg_data = RegData(offsetof(ARM64Arch::user_fpsimd_state, fpcr),\n sizeof(uint32_t));\n } else {\n return false;\n }\n\n DEBUG_ASSERT(reg_data.size > 0);\n if ((size_t)reg_data.size != value_size) {\n LOG(warn) << \"Register \" << regno << \"has mismatched sizes (\"\n << reg_data.size << \" vs \" << value_size << \")\";\n return false;\n }\n\n DEBUG_ASSERT(size_t(reg_data.offset + reg_data.size) <= data_.size());\n memcpy(data_.data() + reg_data.offset, value, value_size);\n return true;\n }\n\n if (format_ != XSAVE) {\n return false;\n }\n\n auto reg_data = xsave_register_data(arch(), regno);\n if (reg_data.offset < 0 || empty()) {\n return false;\n }\n\n DEBUG_ASSERT(reg_data.size > 0);\n if ((size_t)reg_data.size != value_size) {\n LOG(warn) << \"Register \" << regno << \"has mismatched sizes (\"\n << reg_data.size << \" vs \" << value_size << \")\";\n return false;\n }\n\n if (reg_data.xsave_feature_bit >= 0) {\n uint64_t* xsave_features_ = xsave_features(data_);\n if (!xsave_features_) {\n return false;\n }\n\n *xsave_features_ |= (1 << reg_data.xsave_feature_bit);\n }\n\n memcpy(data_.data() + reg_data.offset, value, value_size);\n return true;\n}\n\nstatic const int xinuse_offset = 512;\n\nuint64_t ExtraRegisters::read_xinuse(bool* defined) const {\n uint64_t ret;\n if (format_ != XSAVE || data_.size() < 512 + sizeof(ret)) {\n *defined = false;\n return 0;\n }\n\n memcpy(&ret, data_.data() + xinuse_offset, sizeof(ret));\n return ret;\n}\n\nuint64_t ExtraRegisters::read_fip(bool* defined) const {\n if (format_ != XSAVE) {\n *defined = false;\n return 0;\n }\n\n uint64_t ret;\n memcpy(&ret, data_.data() + fip_offset, sizeof(ret));\n return ret;\n}\n\nuint16_t ExtraRegisters::read_fop(bool* defined) const {\n if (format_ != XSAVE) {\n *defined = false;\n return 0;\n }\n\n uint16_t ret;\n memcpy(&ret, data_.data() + fop_offset, sizeof(ret));\n return ret;\n}\n\nuint32_t ExtraRegisters::read_mxcsr(bool* defined) const {\n if (format_ != XSAVE) {\n *defined = false;\n return 0;\n }\n\n uint32_t ret;\n memcpy(&ret, data_.data() + mxcsr_offset, sizeof(ret));\n return ret;\n}\n\nbool ExtraRegisters::clear_fip_fdp() {\n if (format_ != XSAVE) {\n return false;\n }\n\n bool ret = false;\n uint64_t v;\n memcpy(&v, data_.data() + fip_offset, sizeof(v));\n if (v != 0) {\n ret = true;\n memset(data_.data() + fip_offset, 0, 8);\n }\n memcpy(&v, data_.data() + fdp_offset, sizeof(v));\n if (v != 0) {\n ret = true;\n memset(data_.data() + fdp_offset, 0, 8);\n }\n return ret;\n}\n\nvoid ExtraRegisters::validate(Task* t) {\n if (format_ != XSAVE) {\n return;\n }\n\n ASSERT(t, data_.size() >= 512);\n uint32_t offset = 512;\n if (data_.size() > offset) {\n ASSERT(t, data_.size() >= offset + 64);\n offset += 64;\n const uint64_t* features = xsave_features(data_);\n if (features && (*features & (1 << AVX_FEATURE_BIT))) {\n ASSERT(t, data_.size() >= offset + 256);\n }\n }\n}\n\nstatic size_t get_full_value(const ExtraRegisters& r, GdbServerRegister low, GdbServerRegister hi,\n uint8_t buf[128]) {\n bool defined = false;\n size_t len = r.read_register(buf, low, &defined);\n DEBUG_ASSERT(defined && len <= 64);\n if (hi != GdbServerRegister(0)) {\n size_t len2 = r.read_register(buf + len, hi, &defined);\n if (defined) {\n DEBUG_ASSERT(len == len2);\n len += len2;\n }\n }\n return len;\n}\n\nstatic string reg_to_string(const ExtraRegisters& r, GdbServerRegister low, GdbServerRegister hi) {\n uint8_t buf[128];\n size_t len = get_full_value(r, low, hi, buf);\n bool printed_digit = false;\n char out_buf[257];\n char* p = out_buf;\n for (int i = len - 1; i >= 0; --i) {\n if (!printed_digit && !buf[i] && i > 0) {\n continue;\n }\n p += sprintf(p, printed_digit ? \"%02x\" : \"%x\", buf[i]);\n printed_digit = true;\n }\n return out_buf;\n}\n\nstatic void print_reg(const ExtraRegisters& r, GdbServerRegister low, GdbServerRegister hi,\n const char* name, FILE* f) {\n string out = reg_to_string(r, low, hi);\n fprintf(f, \"%s:0x%s\", name, out.c_str());\n}\n\nstatic void print_regs(const ExtraRegisters& r, GdbServerRegister low, GdbServerRegister hi,\n int num_regs, const char* name_base, FILE* f) {\n for (int i = 0; i < num_regs; ++i) {\n char buf[80];\n sprintf(buf, \"%s%d\", name_base, i);\n print_reg(r, (GdbServerRegister)(low + i),\n hi == GdbServerRegister(0) ? hi : (GdbServerRegister)(hi + i), buf, f);\n if (i < num_regs - 1) {\n fputc(' ', f);\n }\n }\n}\n\nvoid ExtraRegisters::print_register_file_compact(FILE* f) const {\n switch (arch_) {\n case x86:\n print_regs(*this, DREG_ST0, GdbServerRegister(0), 8, \"st\", f);\n fputc(' ', f);\n print_regs(*this, DREG_XMM0, DREG_YMM0H, 8, \"ymm\", f);\n break;\n case x86_64:\n print_regs(*this, DREG_64_ST0, GdbServerRegister(0), 8, \"st\", f);\n fputc(' ', f);\n print_regs(*this, DREG_64_XMM0, DREG_64_YMM0H, 16, \"ymm\", f);\n break;\n case aarch64:\n DEBUG_ASSERT(format_ == NT_FPR);\n print_regs(*this, DREG_V0, GdbServerRegister(0), 32, \"v\", f);\n fputc(' ', f);\n print_reg(*this, DREG_FPSR, GdbServerRegister(0), \"fpsr\", f);\n fputc(' ', f);\n print_reg(*this, DREG_FPCR, GdbServerRegister(0), \"fpcr\", f);\n break;\n default:\n DEBUG_ASSERT(0 && \"Unknown arch\");\n break;\n }\n}\n\nstatic X86Arch::user_fpregs_struct convert_fxsave_to_x86_fpregs(\n const X86Arch::user_fpxregs_struct& buf) {\n X86Arch::user_fpregs_struct result;\n\n for (int i = 0; i < 8; ++i) {\n memcpy(reinterpret_cast(result.st_space) + i * 10,\n &buf.st_space[i * 4], 10);\n }\n\n result.cwd = buf.cwd | 0xffff0000;\n result.swd = buf.swd | 0xffff0000;\n // XXX Computing the correct twd is a pain. It probably doesn't matter to us\n // in practice.\n result.twd = 0;\n result.fip = buf.fip;\n result.fcs = buf.fcs;\n result.foo = buf.foo;\n result.fos = buf.fos;\n\n return result;\n}\n\nstatic void convert_x86_fpregs_to_fxsave(const X86Arch::user_fpregs_struct& buf,\n X86Arch::user_fpxregs_struct* result) {\n for (int i = 0; i < 8; ++i) {\n memcpy(&result->st_space[i * 4],\n reinterpret_cast(buf.st_space) + i * 10, 10);\n }\n\n result->cwd = buf.cwd;\n result->swd = buf.swd;\n // XXX Computing the correct twd is a pain. It probably doesn't matter to us\n // in practice.\n result->fip = buf.fip;\n result->fcs = buf.fcs;\n result->foo = buf.foo;\n result->fos = buf.fos;\n}\n\ntemplate static vector to_vector(const T& v) {\n vector result;\n result.resize(sizeof(T));\n memcpy(result.data(), &v, sizeof(T));\n return result;\n}\n\nstatic uint32_t features_used(const uint8_t* data) {\n uint64_t features;\n memcpy(&features, data + xsave_header_offset, sizeof(features));\n return features;\n}\n\ntemplate \nbool memcpy_fpr_regs_arch(std::vector& dest, const uint8_t* src,\n size_t data_size) {\n if (data_size != sizeof(typename Arch::user_fpregs_struct)) {\n LOG(error) << \"Invalid FPR data length: \" << data_size << \" for architecture \" <<\n arch_name(Arch::arch()) << \", expected \" << sizeof(typename Arch::user_fpregs_struct);\n return false;\n }\n dest.resize(sizeof(typename Arch::user_fpregs_struct));\n memcpy(dest.data(), src, sizeof(typename Arch::user_fpregs_struct));\n return true;\n}\n\nbool memcpy_fpr_regs_arch(SupportedArch arch, std::vector& dest,\n const uint8_t* src, size_t data_size) {\n RR_ARCH_FUNCTION(memcpy_fpr_regs_arch, arch, dest, src, data_size)\n}\n\nbool ExtraRegisters::set_to_raw_data(SupportedArch a, Format format,\n const uint8_t* data, size_t data_size,\n const XSaveLayout& layout) {\n arch_ = a;\n format_ = NONE;\n\n if (format == NONE) {\n return true;\n } else if (format == NT_FPR) {\n if (!memcpy_fpr_regs_arch(a, data_, data, data_size)) {\n return false;\n }\n format_ = NT_FPR;\n return true;\n }\n\n if (format != XSAVE) {\n LOG(error) << \"Unknown ExtraRegisters format: \" << format;\n return false;\n }\n format_ = XSAVE;\n\n // Now we have to convert from the input XSAVE format to our\n // native XSAVE format. Be careful to handle possibly-corrupt input data.\n\n const XSaveLayout& native_layout = xsave_native_layout();\n if (data_size != layout.full_size) {\n LOG(error) << \"Invalid XSAVE data length: \" << data_size << \", expected \"\n << layout.full_size;\n return false;\n }\n data_.resize(native_layout.full_size);\n DEBUG_ASSERT(data_.size() >= xsave_header_offset);\n if (layout.full_size < xsave_header_offset) {\n LOG(error) << \"Invalid XSAVE layout size: \" << layout.full_size;\n return false;\n }\n memcpy(data_.data(), data, xsave_header_offset);\n memset(data_.data() + xsave_header_offset, 0,\n data_.size() - xsave_header_offset);\n\n // Check for unsupported features being used\n if (layout.full_size >= xsave_header_end) {\n uint64_t features = features_used(data);\n /* Mask off the PKRU bit unconditionally here.\n * We want traces that are recorded on machines with PKRU but\n * that don't actually use PKRU to be replayable on machines\n * without PKRU. Linux, however, sets the PKRU register to\n * 0x55555554 (only the default key is allowed to access memory),\n * while the default hardware value is 0, so in some sense\n * PKRU is always in use.\n *\n * There are three classes of side effects of the pkey feature.\n * 1. The direct effects of syscalls such as pkey_alloc/pkey_mprotect\n * on registers.\n * 2. Traps generated by the CPU when the protection keys are violated.\n * 3. The RDPKRU instruction writing to EAX.\n *\n * The first two are replayed exactly by rr. The latter will trigger\n * SIGILL on any machine without PKRU, which is no different from\n * any other new CPU instruction that doesn't have its own XSAVE\n * feature bit. So ignore the PKRU bit here and leave users on their\n * own with respect to RDPKRU.\n */\n features &= ~PKRU_FEATURE_MASK;\n if (features & ~native_layout.supported_feature_bits) {\n LOG(error) << \"Unsupported CPU features found: got \" << HEX(features)\n << \" (\" << xsave_feature_string(features)\n << \"), supported: \"\n << HEX(native_layout.supported_feature_bits)\n << \" (\"\n << xsave_feature_string(native_layout.supported_feature_bits)\n << \"); Consider using `rr cpufeatures` and \"\n << \"`rr record --disable-cpuid-features-(ext)`\";\n return false;\n }\n }\n\n if (native_layout.full_size < xsave_header_end) {\n // No XSAVE supported here, we're done!\n return true;\n }\n if (layout.full_size < xsave_header_end) {\n // Degenerate XSAVE format without an actual XSAVE header. Assume x87+XMM\n // are in use.\n uint64_t assume_features_used = 0x3;\n memcpy(data_.data() + xsave_header_offset, &assume_features_used,\n sizeof(assume_features_used));\n return true;\n }\n\n uint64_t features = features_used(data);\n // OK, now both our native layout and the input layout are using the full\n // XSAVE header. Copy each optional and present area into the right place\n // in our struct.\n for (size_t i = 2; i < 64; ++i) {\n if (features & (uint64_t(1) << i)) {\n if (i >= layout.feature_layouts.size()) {\n LOG(error) << \"Invalid feature \" << i << \" beyond max layout \"\n << layout.feature_layouts.size();\n return false;\n }\n const XSaveFeatureLayout& feature = layout.feature_layouts[i];\n if (uint64_t(feature.offset) + feature.size > layout.full_size) {\n LOG(error) << \"Invalid feature region: \" << feature.offset << \"+\"\n << feature.size << \" > \" << layout.full_size;\n return false;\n }\n if (i >= native_layout.feature_layouts.size()) {\n if (i == PKRU_FEATURE_BIT) {\n // The native arch doesn't support PKRU.\n // This must be during replay, and as the comments above explain,\n // it's OK to not set PKRU during replay on a pre-PKRU CPU, so\n // we can just ignore this.\n features &= ~PKRU_FEATURE_MASK;\n continue;\n } else {\n LOG(error) << \"Invalid feature \" << i << \" beyond max layout \"\n << layout.feature_layouts.size();\n return false;\n }\n }\n const XSaveFeatureLayout& native_feature =\n native_layout.feature_layouts[i];\n if (native_feature.size == 0 && i == PKRU_FEATURE_BIT) {\n // See the above comment about PKRU.\n features &= ~PKRU_FEATURE_MASK;\n continue;\n }\n if (feature.size != native_feature.size) {\n LOG(error) << \"Feature \" << i << \" has wrong size \" << feature.size\n << \", expected \" << native_feature.size;\n return false;\n }\n // The CPU should guarantee these\n DEBUG_ASSERT(native_feature.offset > 0);\n DEBUG_ASSERT(native_feature.offset + native_feature.size <=\n native_layout.full_size);\n memcpy(data_.data() + native_feature.offset, data + feature.offset,\n feature.size);\n }\n }\n\n // Copy the header. Make sure to use our updated `features`.\n memcpy(data_.data() + xsave_header_offset, &features, sizeof(features));\n memcpy(data_.data() + xsave_header_offset + sizeof(features),\n data + xsave_header_offset + sizeof(features),\n xsave_header_size - sizeof(features));\n\n return true;\n}\n\nvector ExtraRegisters::get_user_fpregs_struct(\n SupportedArch arch) const {\n switch (arch) {\n case x86:\n DEBUG_ASSERT(format_ == XSAVE);\n DEBUG_ASSERT(data_.size() >= sizeof(X86Arch::user_fpxregs_struct));\n return to_vector(convert_fxsave_to_x86_fpregs(\n *reinterpret_cast(\n data_.data())));\n case x86_64:\n DEBUG_ASSERT(format_ == XSAVE);\n DEBUG_ASSERT(data_.size() >= sizeof(X64Arch::user_fpregs_struct));\n return to_vector(\n *reinterpret_cast(data_.data()));\n case aarch64:\n DEBUG_ASSERT(format_ == NT_FPR);\n DEBUG_ASSERT(data_.size() == sizeof(ARM64Arch::user_fpregs_struct));\n return to_vector(\n *reinterpret_cast(data_.data()));\n default:\n DEBUG_ASSERT(0 && \"Unknown arch\");\n return vector();\n }\n}\n\nvoid ExtraRegisters::set_user_fpregs_struct(Task* t, SupportedArch arch,\n void* data, size_t size) {\n switch (arch) {\n case x86:\n DEBUG_ASSERT(format_ == XSAVE);\n ASSERT(t, size >= sizeof(X86Arch::user_fpregs_struct));\n ASSERT(t, data_.size() >= sizeof(X86Arch::user_fpxregs_struct));\n convert_x86_fpregs_to_fxsave(\n *static_cast(data),\n reinterpret_cast(data_.data()));\n return;\n case x86_64:\n DEBUG_ASSERT(format_ == XSAVE);\n ASSERT(t, data_.size() >= sizeof(X64Arch::user_fpregs_struct));\n ASSERT(t, size >= sizeof(X64Arch::user_fpregs_struct));\n memcpy(data_.data(), data, sizeof(X64Arch::user_fpregs_struct));\n return;\n case aarch64:\n DEBUG_ASSERT(format_ == NT_FPR);\n ASSERT(t, size >= sizeof(ARM64Arch::user_fpregs_struct));\n ASSERT(t, data_.size() >= sizeof(ARM64Arch::user_fpregs_struct));\n memcpy(data_.data(), data, sizeof(ARM64Arch::user_fpregs_struct));\n return;\n default:\n DEBUG_ASSERT(0 && \"Unknown arch\");\n }\n}\n\nX86Arch::user_fpxregs_struct ExtraRegisters::get_user_fpxregs_struct() const {\n DEBUG_ASSERT(format_ == XSAVE);\n DEBUG_ASSERT(arch_ == x86);\n DEBUG_ASSERT(data_.size() >= sizeof(X86Arch::user_fpxregs_struct));\n return *reinterpret_cast(data_.data());\n}\n\nvoid ExtraRegisters::set_user_fpxregs_struct(\n Task* t, const X86Arch::user_fpxregs_struct& regs) {\n ASSERT(t, format_ == XSAVE);\n ASSERT(t, arch_ == x86);\n ASSERT(t, data_.size() >= sizeof(X86Arch::user_fpxregs_struct));\n memcpy(data_.data(), ®s, sizeof(regs));\n}\n\nstatic void set_word(SupportedArch arch, vector& v, GdbServerRegister r,\n int word) {\n RegData d = xsave_register_data(arch, r);\n DEBUG_ASSERT(d.size == 4);\n DEBUG_ASSERT(d.offset + d.size <= (int)v.size());\n DEBUG_ASSERT(-1 == d.xsave_feature_bit);\n *reinterpret_cast(v.data() + d.offset) = word;\n}\n\nvoid ExtraRegisters::reset() {\n memset(data_.data(), 0, data_.size());\n if (is_x86ish(arch())) {\n DEBUG_ASSERT(format_ == XSAVE);\n if (arch() == x86_64) {\n set_word(arch(), data_, DREG_64_MXCSR, 0x1f80);\n set_word(arch(), data_, DREG_64_FCTRL, 0x37f);\n } else {\n set_word(arch(), data_, DREG_MXCSR, 0x1f80);\n set_word(arch(), data_, DREG_FCTRL, 0x37f);\n }\n uint64_t xinuse;\n if (data_.size() >= xinuse_offset + sizeof(xinuse)) {\n memcpy(&xinuse, data_.data() + xinuse_offset, sizeof(xinuse));\n\n /* We have observed (Skylake, Linux 4.10) the system setting XINUSE's 0 bit\n * to indicate x87-in-use, at times unrelated to x87 actually being used.\n * Work around this by setting the bit unconditionally after exec.\n */\n xinuse |= 1;\n\n /* If the system supports the PKRU feature, the PKRU feature bit must be\n * set in order to get the kernel to properly update the PKRU register\n * value. If this is not set, it has been observed that the PKRU register\n * may occasionally contain \"stale\" values, particularly after involuntary\n * context switches.\n * Avoid this issue by setting the bit if the feature is supported by the\n * CPU.\n */\n if (xcr0() & PKRU_FEATURE_MASK) {\n RegData d = xsave_register_data(arch(), arch() == x86_64 ? DREG_64_PKRU : DREG_PKRU);\n DEBUG_ASSERT(d.xsave_feature_bit == PKRU_FEATURE_BIT);\n DEBUG_ASSERT(d.offset + d.size <= (int)data_.size());\n *reinterpret_cast(data_.data() + d.offset) = 0x55555554;\n xinuse |= PKRU_FEATURE_MASK;\n }\n\n memcpy(data_.data() + xinuse_offset, &xinuse, sizeof(xinuse));\n }\n } else {\n DEBUG_ASSERT(format_ == NT_FPR);\n DEBUG_ASSERT(arch() == aarch64 &&\n \"Ensure that nothing is required here for your architecture.\");\n }\n}\n\nstatic void compare_regs(const ExtraRegisters& reg1,\n const ExtraRegisters& reg2,\n GdbServerRegister low, GdbServerRegister hi,\n int num_regs, const char* name_base,\n Registers::Comparison& result) {\n for (int i = 0; i < num_regs; ++i) {\n GdbServerRegister this_low = (GdbServerRegister)(low + i);\n GdbServerRegister this_hi = hi == GdbServerRegister(0) ? hi : (GdbServerRegister)(hi + i);\n uint8_t buf1[128];\n size_t len1 = get_full_value(reg1, this_low, this_hi, buf1);\n uint8_t buf2[128];\n size_t len2 = get_full_value(reg2, this_low, this_hi, buf2);\n DEBUG_ASSERT(len1 == len2);\n\n if (!memcmp(buf1, buf2, len1)) {\n continue;\n }\n\n ++result.mismatch_count;\n if (result.store_mismatches) {\n char regname[80];\n sprintf(regname, \"%s%d\", name_base, i);\n result.mismatches.push_back({regname, reg_to_string(reg1, this_low, this_hi),\n reg_to_string(reg2, this_low, this_hi)});\n }\n }\n}\n\nvoid ExtraRegisters::compare_internal(const ExtraRegisters& reg2,\n Registers::Comparison& result) const {\n const GdbServerRegister NOT_PRESENT = GdbServerRegister(0);\n if (arch() != reg2.arch()) {\n FATAL() << \"Can't compare register files with different archs\";\n }\n\n if (format() == NONE || reg2.format() == NONE) {\n // Not enough data to check anything\n return;\n }\n if (format() != reg2.format()) {\n FATAL() << \"Can't compare register files with different formats\";\n }\n bool avx_present = false;\n if (format() == XSAVE) {\n avx_present = !!(xsave_native_layout().supported_feature_bits & (1 << AVX_FEATURE_BIT));\n }\n\n switch (arch()) {\n case x86:\n compare_regs(*this, reg2, DREG_ST0, NOT_PRESENT, 8, \"st\", result);\n compare_regs(*this, reg2, DREG_XMM0, avx_present ? DREG_YMM0H : NOT_PRESENT, 8, \"ymm\", result);\n break;\n case x86_64:\n compare_regs(*this, reg2, DREG_64_ST0, NOT_PRESENT, 8, \"st\", result);\n compare_regs(*this, reg2, DREG_64_XMM0, avx_present ? DREG_64_YMM0H : NOT_PRESENT, 8, \"ymm\", result);\n break;\n case aarch64:\n DEBUG_ASSERT(format_ == NT_FPR);\n compare_regs(*this, reg2, DREG_V0, NOT_PRESENT, 32, \"v\", result);\n break;\n default:\n DEBUG_ASSERT(0 && \"Unknown arch\");\n break;\n }\n}\n\n} // namespace rr\n" }, { "path": "src/ExtraRegisters.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_EXTRA_REGISTERS_H_\n#define RR_EXTRA_REGISTERS_H_\n\n#include \n#include \n\n#include \n\n#include \"GdbServerRegister.h\"\n#include \"Registers.h\"\n#include \"kernel_abi.h\"\n\nnamespace rr {\n\nclass ReplayTask;\nstruct XSaveLayout;\n\n/**\n * An ExtraRegisters object contains values for all user-space-visible\n * registers other than those in Registers.\n *\n * Task is responsible for creating meaningful values of this class.\n *\n * The only reason this class has an arch() is to enable us to\n * interpret GdbServerRegister.\n */\nclass ExtraRegisters {\npublic:\n // Create empty (uninitialized/unknown registers) value\n ExtraRegisters(SupportedArch arch = x86)\n : format_(NONE), arch_(arch) {}\n enum Format { NONE,\n /**\n * The XSAVE format is x86(_64) only.\n * On a x86 64-bit kernel, these structures are initialized by an XSAVE64 or\n * FXSAVE64.\n * On a x86 32-bit kernel, they are initialized by an XSAVE or FXSAVE.\n *\n * The layouts are basically the same in the first 512 bytes --- an\n * FXSAVE(64) area. The differences are:\n * -- On a 64-bit kernel, registers XMM8-XMM15 are saved, but on a 32-bit\n * kernel they are not (that space is reserved).\n * -- On a 64-bit kernel, bytes 8-15 store a 64-bit \"FPU IP\" address,\n * but on a 32-bit kernel they store \"FPU IP/CS\". Likewise,\n * bytes 16-23 store \"FPU DP\" or \"FPU DP/DS\".\n * We basically ignore these differences. If gdb requests 32-bit-specific\n * registers, we return them, assuming that the data there is valid.\n *\n * XSAVE/XSAVE64 have extra information after the first 512 bytes, which we\n * currently save and restore but do not otherwise use. If the data record\n * has more than 512 bytes then it's an XSAVE(64) area, otherwise it's just\n * the FXSAVE(64) area.\n *\n * The data always uses our CPU's native XSAVE layout. When reading a trace,\n * we need to convert from the trace's CPU's XSAVE layout to our layout.\n */\n XSAVE,\n /**\n * Stores the content of the NT_FPREGS regset. The format depends on the\n * architecture. It is given by Arch::user_fpregs_struct for the appropriate\n * architecture.\n */\n NT_FPR };\n\n // Set values from raw data, with the given XSAVE layout. Returns false\n // if this could not be done.\n bool set_to_raw_data(SupportedArch a, Format format, const uint8_t* data,\n size_t data_size, const XSaveLayout& layout);\n Format format() const { return format_; }\n SupportedArch arch() const { return arch_; }\n const std::vector data() const { return data_; }\n int data_size() const { return data_.size(); }\n const uint8_t* data_bytes() const { return data_.data(); }\n bool empty() const { return data_.empty(); }\n\n /**\n * Read XSAVE `xinuse` field\n */\n uint64_t read_xinuse(bool* defined) const;\n\n /**\n * Read FIP field\n */\n uint64_t read_fip(bool* defined) const;\n\n /**\n * Read FOP field\n */\n uint16_t read_fop(bool* defined) const;\n\n /**\n * Read MXCSR field\n */\n uint32_t read_mxcsr(bool* defined) const;\n\n /**\n * Clear FIP and FDP registers if they're present.\n * Returns true if the registers changed.\n */\n bool clear_fip_fdp();\n\n /**\n * Like |Registers::read_register()|, except attempts to read\n * the value of an \"extra register\" (floating point / vector).\n */\n size_t read_register(uint8_t* buf, GdbServerRegister regno, bool* defined) const;\n\n /**\n * Like |Registers::write_register()|, except attempts to write\n * the value of an \"extra register\" (floating point / vector).\n */\n bool write_register(GdbServerRegister regno, const void* value, size_t value_size);\n\n /**\n * Get a user_fpregs_struct for a particular Arch from these ExtraRegisters.\n */\n std::vector get_user_fpregs_struct(SupportedArch arch) const;\n\n /**\n * Update registers from a user_fpregs_struct.\n */\n void set_user_fpregs_struct(Task* t, SupportedArch arch, void* data,\n size_t size);\n\n /**\n * Get a user_fpxregs_struct for from these ExtraRegisters.\n */\n X86Arch::user_fpxregs_struct get_user_fpxregs_struct() const;\n\n /**\n * Update registers from a user_fpxregs_struct.\n */\n void set_user_fpxregs_struct(Task* t,\n const X86Arch::user_fpxregs_struct& regs);\n\n void print_register_file_compact(FILE* f) const;\n\n /**\n * Reset to post-exec initial state\n */\n void reset();\n\n void validate(Task* t);\n\n /**\n * Return true if |reg1| matches |reg2|. Passing EXPECT_MISMATCHES\n * indicates that the caller is using this as a general register\n * compare and nothing special should be done if the register files\n * mismatch. Passing LOG_MISMATCHES will log the registers that don't\n * match. Passing BAIL_ON_MISMATCH will additionally abort on\n * mismatch.\n * This is conservative; we only return false if we have enough\n * information to verify that the registers definitely don't match.\n * The register files must have the same arch.\n */\n Registers::Comparison compare_with(const ExtraRegisters& reg2) const {\n Registers::Comparison result;\n compare_internal(reg2, result);\n return result;\n }\n\n bool matches(const ExtraRegisters& reg2) const {\n Registers::Comparison result;\n result.store_mismatches = false;\n compare_internal(reg2, result);\n return !result.mismatch_count;\n }\n\nprivate:\n friend class Task;\n\n void compare_internal(const ExtraRegisters& reg2, Registers::Comparison& result) const;\n\n Format format_;\n SupportedArch arch_;\n std::vector data_;\n};\n\n} // namespace rr\n\n#endif /* RR_EXTRA_REGISTERS_H_ */\n" }, { "path": "src/FdTable.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"FdTable.h\"\n\n#include \n\n#include \n#include \n\n#include \"rr/rr.h\"\n\n#include \"AddressSpace.h\"\n#include \"RecordTask.h\"\n#include \"ReplayTask.h\"\n#include \"Session.h\"\n#include \"core.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nFdTable::shr_ptr FdTable::create(Task* t) {\n shr_ptr fds(new FdTable(t->session().syscallbuf_fds_disabled_size()));\n fds->insert_task(t);\n return fds;\n}\n\nvoid FdTable::insert_task(Task* t) {\n HasTaskSet::insert_task(t);\n ++vms[t->vm().get()];\n}\n\nvoid FdTable::erase_task(Task* t) {\n if (task_set().find(t) == task_set().end()) {\n return;\n }\n HasTaskSet::erase_task(t);\n auto it = vms.find(t->vm().get());\n if (it == vms.end()) {\n FATAL() << \"Lost track of VM already?\";\n }\n --it->second;\n if (!it->second) {\n vms.erase(it);\n }\n}\n\nvoid FdTable::add_monitor(Task* t, int fd, FileMonitor* monitor) {\n // In the future we could support multiple monitors on an fd, but we don't\n // need to yet.\n FileMonitor* current = get_monitor(fd);\n if (current) {\n ASSERT(t, false) << \"Task \" << t->rec_tid << \" already monitoring fd \"\n << fd << \" \" << file_monitor_type_name(current->type());\n }\n if (fd >= syscallbuf_fds_disabled_size && fds.count(fd) == 0) {\n fd_count_beyond_limit++;\n }\n fds[fd] = FileMonitor::shr_ptr(monitor);\n update_syscallbuf_fds_disabled(fd);\n}\n\nvoid FdTable::replace_monitor(Task* t, int fd, FileMonitor* monitor) {\n if (!is_monitoring(fd)) {\n add_monitor(t, fd, monitor);\n } else {\n fds[fd] = FileMonitor::shr_ptr(monitor);\n }\n}\n\nbool FdTable::is_rr_fd(int fd) {\n auto it = fds.find(fd);\n if (it == fds.end()) {\n return false;\n }\n return it->second->is_rr_fd();\n}\n\nbool FdTable::emulate_ioctl(int fd, RecordTask* t, uint64_t* result) {\n auto it = fds.find(fd);\n if (it == fds.end()) {\n return false;\n }\n return it->second->emulate_ioctl(t, result);\n}\n\nbool FdTable::emulate_fcntl(int fd, RecordTask* t, uint64_t* result) {\n auto it = fds.find(fd);\n if (it == fds.end()) {\n return false;\n }\n return it->second->emulate_fcntl(t, result);\n}\n\nbool FdTable::emulate_read(int fd, RecordTask* t,\n const std::vector& ranges,\n FileMonitor::LazyOffset& offset, uint64_t* result) {\n auto it = fds.find(fd);\n if (it == fds.end()) {\n return false;\n }\n return it->second->emulate_read(t, ranges, offset, result);\n}\n\nvoid FdTable::filter_getdents(int fd, RecordTask* t) {\n auto it = fds.find(fd);\n if (it == fds.end()) {\n return;\n }\n it->second->filter_getdents(t);\n}\n\nSwitchable FdTable::will_write(Task* t, int fd) {\n auto it = fds.find(fd);\n if (it == fds.end()) {\n return ALLOW_SWITCH;\n }\n return it->second->will_write(t);\n}\n\nvoid FdTable::did_write(Task* t, int fd,\n const std::vector& ranges,\n FileMonitor::LazyOffset& offset) {\n auto it = fds.find(fd);\n if (it != fds.end()) {\n it->second->did_write(t, ranges, offset);\n }\n}\n\nvoid FdTable::did_dup(FdTable* table, int from, int to) {\n if (table->fds.count(from)) {\n if (to >= syscallbuf_fds_disabled_size && fds.count(to) == 0) {\n fd_count_beyond_limit++;\n }\n fds[to] = table->fds[from];\n } else {\n if (to >= syscallbuf_fds_disabled_size && fds.count(to) > 0) {\n fd_count_beyond_limit--;\n }\n fds.erase(to);\n }\n update_syscallbuf_fds_disabled(to);\n}\n\nvoid FdTable::did_close(int fd) {\n LOG(debug) << \"Close fd \" << fd;\n if (fd >= syscallbuf_fds_disabled_size && fds.count(fd) > 0) {\n fd_count_beyond_limit--;\n }\n fds.erase(fd);\n update_syscallbuf_fds_disabled(fd);\n}\n\nFileMonitor* FdTable::get_monitor(int fd) {\n auto it = fds.find(fd);\n if (it == fds.end()) {\n return nullptr;\n }\n return it->second.get();\n}\n\nstatic syscallbuf_fd_classes join_fd_classes_over_tasks(AddressSpace* vm, int fd,\n int syscallbuf_fds_disabled_size) {\n syscallbuf_fd_classes cls = FD_CLASS_UNTRACED;\n for (Task* t : vm->task_set()) {\n auto table = t->fd_table();\n if (table->is_monitoring(fd)) {\n if (cls != FD_CLASS_UNTRACED) {\n return FD_CLASS_TRACED;\n }\n cls = table->get_monitor(fd)->get_syscallbuf_class();\n } else if (fd >= syscallbuf_fds_disabled_size - 1 &&\n table->count_beyond_limit() > 0) {\n return FD_CLASS_TRACED;\n }\n }\n return cls;\n}\n\nvoid FdTable::update_syscallbuf_fds_disabled(int fd) {\n DEBUG_ASSERT(fd >= 0);\n DEBUG_ASSERT(task_set().size() > 0);\n\n // It's possible for tasks with different VMs to share this fd table.\n // But tasks with the same VM might have different fd tables...\n for (auto address_space : vms) {\n RecordTask* rt = nullptr;\n if (address_space.first->task_set().empty()) {\n FATAL() << \"Address space must have at least one task\";\n }\n for (Task* t : address_space.first->task_set()) {\n if (!t->session().is_recording()) {\n // We could return but we want to check that all our\n // AddressSpaces have tasks (i.e. aren't dead/dangling)\n break;\n }\n rt = static_cast(t);\n if (!rt->already_exited()) {\n break;\n }\n rt = nullptr;\n }\n if (rt && !rt->preload_globals.is_null()) {\n if (fd >= syscallbuf_fds_disabled_size) {\n fd = syscallbuf_fds_disabled_size - 1;\n }\n char disable = (char)join_fd_classes_over_tasks(address_space.first, fd,\n syscallbuf_fds_disabled_size);\n auto addr =\n REMOTE_PTR_FIELD(rt->preload_globals, syscallbuf_fd_class[0]) + fd;\n rt->write_mem(addr, disable);\n rt->record_local(addr, &disable);\n }\n }\n}\n\nvoid FdTable::init_syscallbuf_fds_disabled(Task* t) {\n if (!t->session().is_recording()) {\n return;\n }\n RecordTask* rt = static_cast(t);\n\n ASSERT(rt, has_task(rt));\n\n if (rt->preload_globals.is_null()) {\n return;\n }\n\n vector disabled;\n disabled.resize(syscallbuf_fds_disabled_size, 0);\n\n // It's possible that some tasks in this address space have a different\n // FdTable. We need to disable syscallbuf for an fd if any tasks for this\n // address space are monitoring the fd.\n for (Task* vm_t : rt->vm()->task_set()) {\n for (auto& it : vm_t->fd_table()->fds) {\n int fd = it.first;\n DEBUG_ASSERT(fd >= 0);\n if (fd >= syscallbuf_fds_disabled_size) {\n fd = syscallbuf_fds_disabled_size - 1;\n }\n if (disabled[fd] == FD_CLASS_UNTRACED) {\n disabled[fd] = it.second->get_syscallbuf_class();\n } else {\n disabled[fd] = FD_CLASS_TRACED;\n }\n }\n }\n\n auto addr = REMOTE_PTR_FIELD(t->preload_globals, syscallbuf_fd_class[0]);\n rt->write_mem(addr, disabled.data(), syscallbuf_fds_disabled_size);\n rt->record_local(addr, disabled.data(), syscallbuf_fds_disabled_size);\n}\n\nvoid FdTable::close_after_exec(ReplayTask* t, const vector& fds_to_close) {\n ASSERT(t, has_task(t));\n\n for (auto fd : fds_to_close) {\n did_close(fd);\n }\n}\n\nstatic bool is_fd_open(Task* t, int fd) {\n char path[PATH_MAX];\n sprintf(path, \"/proc/%d/fd/%d\", t->tid, fd);\n struct stat st;\n return 0 == lstat(path, &st);\n}\n\nvector FdTable::fds_to_close_after_exec(RecordTask* t) {\n ASSERT(t, has_task(t));\n\n vector fds_to_close;\n for (auto& it : fds) {\n if (!is_fd_open(t, it.first)) {\n fds_to_close.push_back(it.first);\n }\n }\n for (auto fd : fds_to_close) {\n did_close(fd);\n }\n return fds_to_close;\n}\n\n} // namespace rr\n" }, { "path": "src/FdTable.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_FD_TABLE_H_\n#define RR_FD_TABLE_H_\n\n#include \n#include \n#include \n\n#include \"FileMonitor.h\"\n#include \"HasTaskSet.h\"\n\nnamespace rr {\n\nclass AddressSpace;\nclass RecordTask;\nclass ReplayTask;\nclass Task;\n\nclass FdTable final : public HasTaskSet {\npublic:\n typedef std::shared_ptr shr_ptr;\n\n void add_monitor(Task* t, int fd, FileMonitor* monitor);\n void replace_monitor(Task* t, int fd, FileMonitor* monitor);\n bool emulate_ioctl(int fd, RecordTask* t, uint64_t* result);\n bool emulate_fcntl(int fd, RecordTask* t, uint64_t* result);\n bool emulate_read(int fd, RecordTask* t,\n const std::vector& ranges,\n FileMonitor::LazyOffset& offset, uint64_t* result);\n void filter_getdents(int fd, RecordTask* t);\n bool is_rr_fd(int fd);\n Switchable will_write(Task* t, int fd);\n void did_write(Task* t, int fd, const std::vector& ranges,\n FileMonitor::LazyOffset& offset);\n void did_dup(int from, int to) {\n did_dup(this, from, to);\n }\n void did_dup(FdTable* table, int from, int to);\n void did_close(int fd);\n\n shr_ptr clone() const {\n return shr_ptr(new FdTable(*this));\n }\n\n static shr_ptr create(Task* t);\n\n bool is_monitoring(int fd) const { return fds.count(fd) > 0; }\n uint32_t count_beyond_limit() const { return fd_count_beyond_limit; }\n\n FileMonitor* get_monitor(int fd);\n\n /**\n * Regenerate syscallbuf_fds_disabled in task |t|.\n * Called during initialization of the preload library.\n */\n void init_syscallbuf_fds_disabled(Task* t);\n\n /**\n * Get list of fds that have been closed after |t| has done an execve.\n * Rather than tracking CLOEXEC flags (which would be complicated), we just\n * scan /proc//fd during recording and note any monitored fds that have\n * been closed.\n * This also updates our table to match reality.\n */\n std::vector fds_to_close_after_exec(RecordTask* t);\n\n /**\n * Close fds in list after an exec.\n */\n void close_after_exec(ReplayTask* t, const std::vector& fds_to_close);\n\n // Used to optimize ReplayTask's find_free_file_descriptor\n int last_free_fd() const { return last_free_fd_; }\n void set_last_free_fd(int last_free_fd) { last_free_fd_ = last_free_fd; }\n\n void insert_task(Task* t) override;\n void erase_task(Task* t) override;\n\nprivate:\n explicit FdTable(uint32_t syscallbuf_fds_disabled_size)\n : syscallbuf_fds_disabled_size(syscallbuf_fds_disabled_size),\n fd_count_beyond_limit(0), last_free_fd_(0) {}\n // Does not call the base-class copy constructor because\n // we don't want to copy the task set; the new FdTable will\n // be for new tasks.\n FdTable(const FdTable& other) : fds(other.fds),\n syscallbuf_fds_disabled_size(other.syscallbuf_fds_disabled_size),\n fd_count_beyond_limit(other.fd_count_beyond_limit),\n last_free_fd_(other.last_free_fd_) {}\n\n void update_syscallbuf_fds_disabled(int fd);\n\n std::unordered_map fds;\n std::unordered_map vms;\n // Currently this is only used during recording, so we could use\n // SYSCALLBUF_FDS_DISABLED_SIZE directly and not bother tracking it in\n // the trace header, but to make things less fragile in case we ever need to\n // know it during replay, we track it here.\n int syscallbuf_fds_disabled_size;\n // Number of elements of `fds` that are >= syscallbuf_fds_disabled_size.\n // Only used during recording.\n uint32_t fd_count_beyond_limit;\n // Only used during recording.\n int last_free_fd_;\n};\n\n} // namespace rr\n\n#endif /* RR_FD_TABLE_H_ */\n" }, { "path": "src/FileMonitor.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"FileMonitor.h\"\n\n#include \n\n#include \n\n#include \n\n#include \"RecordTask.h\"\n#include \"ReplayTask.h\"\n#include \"Session.h\"\n#include \"log.h\"\n\nnamespace rr {\nusing namespace std;\n\ntemplate \nstatic bool is_implicit_offset_syscall_arch(int syscallno) {\n return syscallno == Arch::writev || syscallno == Arch::write ||\n syscallno == Arch::readv || syscallno == Arch::read;\n}\n\ntemplate \nstatic bool is_write_syscall_arch(int syscallno) {\n return syscallno == Arch::writev || syscallno == Arch::write ||\n syscallno == Arch::pwrite64 || syscallno == Arch::pwritev;\n}\n\nstatic bool is_implicit_offset_syscall(SupportedArch arch, int syscallno) {\n RR_ARCH_FUNCTION(is_implicit_offset_syscall_arch, arch, syscallno);\n}\n\ntemplate \nstatic int64_t retrieve_offset_arch(Task* t, int syscallno,\n const Registers& regs) {\n switch (syscallno) {\n case Arch::pwrite64:\n case Arch::pwritev:\n case Arch::pread64:\n case Arch::preadv: {\n if (sizeof(typename Arch::unsigned_word) == 4) {\n return regs.arg4() | (uint64_t(regs.arg5_signed()) << 32);\n }\n return regs.arg4_signed();\n }\n case Arch::readv:\n case Arch::read:\n case Arch::writev:\n case Arch::write: {\n ASSERT(t, t->session().is_recording())\n << \"Can only read a file descriptor's offset while recording\";\n int fd = regs.orig_arg1_signed();\n int64_t offset = t->fd_offset(fd);\n return is_write_syscall_arch(syscallno) ?\n // The pos we just read, was after the write completed. Luckily, we do\n // know how many bytes were written.\n offset - regs.syscall_result() :\n offset;\n }\n default: {\n ASSERT(t, false) << \"Can not retrieve offset for this system call.\";\n return -1;\n }\n }\n}\n\nstatic int64_t retrieve_offset(Task* t, int syscallno, const Registers& regs) {\n RR_ARCH_FUNCTION(retrieve_offset_arch, t->arch(), t, syscallno, regs);\n}\n\nint64_t FileMonitor::LazyOffset::retrieve(bool needed_for_replay) {\n bool is_replay = t->session().is_replaying();\n bool is_implicit_offset = is_implicit_offset_syscall(t->arch(), syscallno);\n ASSERT(t, needed_for_replay || !is_replay);\n // There is no way we can figure out this information now, so retrieve it\n // from the trace (we record it below under the same circumstance).\n if (is_replay && is_implicit_offset) {\n return static_cast(t)\n ->current_trace_frame()\n .event()\n .Syscall()\n .write_offset;\n }\n int64_t offset = retrieve_offset(t, syscallno, regs);\n if (needed_for_replay && is_implicit_offset) {\n static_cast(t)->ev().Syscall().write_offset = offset;\n }\n return offset;\n}\n\n#define CASE(v) case FileMonitor::v: return #v\nstd::string file_monitor_type_name(FileMonitor::Type t) {\n switch (t) {\n CASE(Base);\n CASE(MagicSaveData);\n CASE(Mmapped);\n CASE(Preserve);\n CASE(ProcFd);\n CASE(ProcMem);\n CASE(Stdio);\n CASE(VirtualPerfCounter);\n CASE(NonvirtualPerfCounter);\n CASE(SysCpu);\n CASE(ProcStat);\n CASE(RRPage);\n CASE(ODirect);\n CASE(BpfMap);\n CASE(PidFd);\n default:\n FATAL() << \"Unknown type \" << (int)t;\n return \"\";\n }\n}\n\n}\n" }, { "path": "src/FileMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_FILE_MONITOR_H_\n#define RR_FILE_MONITOR_H_\n\nclass Task;\n\n#include \n#include \n\n#include \n#include \n\n#include \"preload/preload_interface.h\"\n#include \"util.h\"\n\nnamespace rr {\n\nclass RecordTask;\nclass Registers;\n\nclass FileMonitor {\npublic:\n typedef std::shared_ptr shr_ptr;\n\n virtual ~FileMonitor() {}\n\n enum Type {\n Base,\n MagicSaveData,\n Mmapped,\n Preserve,\n ProcFd,\n ProcMem,\n Stdio,\n VirtualPerfCounter,\n NonvirtualPerfCounter,\n SysCpu,\n ProcStat,\n RRPage,\n ODirect,\n BpfMap,\n PidFd,\n };\n\n virtual Type type() { return Base; }\n\n /**\n * Overriding this to return true will cause close() (and related fd-smashing\n * operations such as dup2) to return EBADF, and hide it from the tracee's\n * /proc/pid/fd/\n */\n virtual bool is_rr_fd() { return false; }\n\n /**\n * Notification that task |t| is about to write |data| bytes of length\n * |length| to the file.\n * In general writes can block, and concurrent blocking writes to the same\n * file may race so that the kernel performs writes out of order\n * with respect to will_write notifications.\n * If it is known that the write cannot block (or that blocking all of rr\n * on it is OK), this notification can return PREVENT_SWITCH to make the\n * write a blocking write. This ensures that writes are performed in the order\n * of will_write notifications.\n */\n virtual Switchable will_write(Task*) { return ALLOW_SWITCH; }\n /**\n * Notification that task |t| wrote to the file descriptor.\n * Due to races, if will_write did not return PREVENT_SWITCH, it's possible\n * that the data in the buffers is not what was actually written.\n */\n struct Range {\n remote_ptr data;\n size_t length;\n Range(remote_ptr data, size_t length) : data(data), length(length) {}\n };\n\n /**\n * Encapsulates the offset at which to read or write. Computing this may be\n * an expensive operation if the offset is implicit (i.e. is taken from the\n * file descriptor), so we only do it if we actually need to look at the\n * offset.\n */\n class LazyOffset {\n public:\n LazyOffset(Task* t, const Registers& regs, int64_t syscallno)\n : t(t), regs(regs), syscallno(syscallno) {}\n int64_t retrieve(bool needed_for_replay);\n\n private:\n Task* t;\n const Registers& regs;\n int64_t syscallno;\n };\n\n virtual void did_write(Task*, const std::vector&, LazyOffset&) {}\n\n /**\n * Return true if the ioctl should be fully emulated. If so the result\n * is stored in the last parameter.\n * Only called during recording.\n */\n virtual bool emulate_ioctl(RecordTask*, uint64_t*) { return false; }\n\n /**\n * Return true if the fcntl should be fully emulated. If so the\n * result is stored in the last parameter.\n * Only called during recording.\n */\n virtual bool emulate_fcntl(RecordTask*, uint64_t*) { return false; }\n\n /**\n * Return true if the read should be fully emulated. If so the\n * result is stored in the last parameter. The emulation should write to the\n * task's memory ranges.\n * Only called during recording.\n */\n virtual bool emulate_read(RecordTask*, const std::vector&, LazyOffset&,\n uint64_t*) {\n return false;\n }\n\n /**\n * Allows the FileMonitor to rewrite the output of a getdents/getdents64 call\n * if desired.\n */\n virtual void filter_getdents(RecordTask*) {}\n\n virtual enum syscallbuf_fd_classes get_syscallbuf_class() {\n return FD_CLASS_TRACED;\n }\n};\n\nstd::string file_monitor_type_name(FileMonitor::Type t);\n\n} // namespace rr\n\n#endif /* RR_FILE_MONITOR_H_ */\n" }, { "path": "src/FileNameCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n\n#include \"AddressSpace.h\"\n#include \"Command.h\"\n#include \"TraceStream.h\"\n#include \"core.h\"\n#include \"main.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass FileNameCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n FileNameCommand(const char* name, const char* help) : Command(name, help) {}\n bool parse_file_name(vector& args, string* out);\n\n static FileNameCommand singleton;\n};\n\nFileNameCommand FileNameCommand::singleton(\n \"filename\",\n \" rr filename \\n\"\n \" Prints the original filename for a given trace file name.\\n\");\n\nstatic void print_original_file_name(const string& trace_dir,\n const string& file_name, FILE* out) {\n TraceReader trace(trace_dir);\n unordered_set original_files;\n string full_file_name = trace.dir() + \"/\" + file_name;\n while (true) {\n TraceReader::MappedData data;\n bool found;\n KernelMapping km = trace.read_mapped_region(\n &data, &found, TraceReader::VALIDATE, TraceReader::ANY_TIME);\n if (!found) {\n break;\n }\n if (data.source == TraceReader::SOURCE_FILE &&\n data.file_name == full_file_name && !km.fsname().empty() &&\n original_files.find(km.fsname()) == original_files.end()) {\n fprintf(out, \"%s\\n\", km.fsname().c_str());\n original_files.insert(km.fsname());\n }\n }\n}\n\nbool FileNameCommand::parse_file_name(vector& args, string* out) {\n if (args.empty() || !verify_not_option(args)) {\n return false;\n }\n *out = args[0];\n args.erase(args.begin());\n return true;\n}\n\nint FileNameCommand::run(vector& args) {\n string file_name;\n if (!parse_file_name(args, &file_name) || !args.empty()) {\n print_help(stderr);\n return 1;\n }\n\n string trace_dir;\n size_t last_slash = file_name.rfind('/');\n if (last_slash == string::npos) {\n trace_dir = \".\";\n } else {\n trace_dir = file_name.substr(0, last_slash);\n file_name = file_name.substr(last_slash + 1);\n }\n print_original_file_name(trace_dir, file_name, stdout);\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/Flags.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Flags.h\"\n\nnamespace rr {\n\nFlags& Flags::get_for_init() { return singleton; }\n\nFlags Flags::singleton;\n\n} // namespace rr\n" }, { "path": "src/Flags.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_FLAGS_H_\n#define RR_FLAGS_H_\n\n#include \n#include \n\n#include \n\n#include \"Ticks.h\"\n#include \"TraceFrame.h\"\n\nnamespace rr {\n\n/**\n * Command line arguments for rr\n */\nstruct Flags {\n enum { CHECKSUM_NONE = -3, CHECKSUM_SYSCALL = -2, CHECKSUM_ALL = -1 };\n /* When to generate or check memory checksums. One of CHECKSUM_NONE,\n * CHECKSUM_SYSCALL or CHECKSUM_ALL, or a positive integer representing the\n * event time at which to start checksumming.\n */\n FrameTime checksum;\n\n enum {\n DUMP_ON_ALL = 10000,\n DUMP_ON_RDTSC = 10001,\n DUMP_ON_NONE = -DUMP_ON_ALL\n };\n int dump_on;\n\n enum { DUMP_AT_NONE = -1 };\n /* time at which to create memory dump */\n FrameTime dump_at; // global time\n\n // Force rr to do some things that it otherwise wouldn't, for\n // example launching an emergency debugger when the output\n // doesn't seem to be a tty.\n bool force_things;\n\n // Force rr to assume that the terminal is non-interactive, disabling e.g.\n // the interactive emergency debugger. If used with --force-things, this\n // option prevails.\n bool non_interactive;\n\n /* Mark the trace global time along with tracee writes to\n * stdio. */\n bool mark_stdio;\n\n // Check that cached mmaps match /proc/maps after each event.\n bool check_cached_mmaps;\n\n // Suppress warnings related to environmental features outside rr's\n // control.\n bool suppress_environment_warnings;\n\n // Any warning or error that would be printed is treated as fatal\n bool fatal_errors_and_warnings;\n\n // Pretend CPUID faulting support doesn't exist\n bool disable_cpuid_faulting;\n\n // Don't listen for PTRACE_EVENT_EXIT events, to test how rr handles\n // missing PTRACE_EVENT_EXITs.\n bool disable_ptrace_exit_events;\n\n // User override for architecture detection, e.g. when running\n // under valgrind.\n std::string forced_uarch;\n\n // User override for the path to page files and other resources.\n std::string resource_path;\n\n Flags()\n : checksum(CHECKSUM_NONE),\n dump_on(DUMP_ON_NONE),\n dump_at(DUMP_AT_NONE),\n force_things(false),\n mark_stdio(false),\n check_cached_mmaps(false),\n suppress_environment_warnings(false),\n fatal_errors_and_warnings(false),\n disable_cpuid_faulting(false),\n disable_ptrace_exit_events(false) {}\n\n static const Flags& get() { return singleton; }\n\n /**\n * Get a reference that can be used to initialize the global Flags.\n */\n static Flags& get_for_init();\n\nprivate:\n static Flags singleton;\n};\n\n} // namespace rr\n\n#endif /* RR_FLAGS_H_ */\n" }, { "path": "src/GdbInitCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"GdbServer.h\"\n#include \"launch_debugger.h\"\n#include \"main.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass GdbInitCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n GdbInitCommand(const char* name, const char* help) : Command(name, help) {}\n\n static GdbInitCommand singleton;\n};\n\nGdbInitCommand GdbInitCommand::singleton(\"gdbinit\", \" rr gdbinit\\n\");\n\nint GdbInitCommand::run(vector& args) {\n while (parse_global_option(args)) {\n }\n\n fputs(gdb_init_script().c_str(), stdout);\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/GdbServer.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"GdbServer.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"BreakpointCondition.h\"\n#include \"ElfReader.h\"\n#include \"Event.h\"\n#include \"DebuggerExtensionCommandHandler.h\"\n#include \"GdbServerExpression.h\"\n#include \"GdbServerRegister.h\"\n#include \"ReplaySession.h\"\n#include \"ReplayTask.h\"\n#include \"ScopedFd.h\"\n#include \"StringVectorToCharArray.h\"\n#include \"Task.h\"\n#include \"ThreadGroup.h\"\n#include \"TraceField.h\"\n#include \"core.h\"\n#include \"kernel_metadata.h\"\n#include \"launch_debugger.h\"\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n/**\n * The \"outermost\" saved register state is associated with the diversion.\n * \"Restoring\" it exits the diversion and restores all state of the tracee.\n */\nconst int DIVERSION_SAVED_REGISTER_STATE = 1;\n\n/**\n * If non-empty, the trace fields to print when singlestepping a diversion\n * session. Only intended for debugging rr itself.\n */\nconst string DIVERSION_SINGLESTEP_PRINT = \"\";\n\nGdbServer::ConnectionFlags::ConnectionFlags()\n : dbg_port(-1),\n keep_listening(false),\n serve_files(false),\n debugger_params_write_pipe(nullptr) {}\n\nstatic ExtendedTaskId extended_task_id(Task* t) {\n return ExtendedTaskId(t->thread_group()->tguid(), t->tuid());\n}\n\nGdbServer::GdbServer(std::unique_ptr& connection,\n Task* t, ReplayTimeline* timeline,\n const Target& target)\n : dbg(std::move(connection)),\n debuggee_tguid(t->thread_group()->tguid()),\n target(target),\n last_continue_task(extended_task_id(t)),\n last_query_task(extended_task_id(t)),\n final_event(UINT32_MAX),\n in_debuggee_end_state(false),\n failed_restart(false),\n stop_replaying_to_target(nullptr),\n interrupt_pending(false),\n exit_sigkill_pending(false),\n timeline_(timeline),\n emergency_debug_session(timeline ? nullptr : &t->session()),\n file_scope_pid(0) {\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n}\n\n/**\n * Attempt to find the value of |regname| (a DebuggerRegister\n * name), and if so (i) write it to |buf|; (ii)\n * set |*defined = true|; (iii) return the size of written\n * data. If |*defined == false|, the value of |buf| is\n * meaningless.\n *\n * This helper can fetch the values of both general-purpose\n * and \"extra\" registers.\n *\n * NB: |buf| must be large enough to hold the largest register\n * value that can be named by |regname|.\n */\nstatic size_t get_reg(const Registers& regs, const ExtraRegisters& extra_regs,\n uint8_t* buf, GdbServerRegister regname, bool* defined) {\n size_t num_bytes = regs.read_register(buf, regname, defined);\n if (!*defined) {\n num_bytes = extra_regs.read_register(buf, regname, defined);\n }\n return num_bytes;\n}\n\nstatic bool set_reg(Task* target, const GdbServerRegisterValue& reg) {\n if (!reg.defined) {\n return false;\n }\n\n Registers regs = target->regs();\n if (regs.write_register(reg.name, reg.value, reg.size)) {\n target->set_regs(regs);\n return true;\n }\n\n auto extra_regs_p = target->extra_regs_fallible();\n ASSERT(target, extra_regs_p) << \"Task died\";\n ExtraRegisters extra_regs = *extra_regs_p;\n if (extra_regs.write_register(reg.name, reg.value, reg.size)) {\n target->set_extra_regs(extra_regs);\n return true;\n }\n\n LOG(warn) << \"Unhandled register name \" << reg.name;\n return false;\n}\n\n/**\n * Return the register |which|, which may not have a defined value.\n */\nGdbServerRegisterValue GdbServer::get_reg(const Registers& regs,\n const ExtraRegisters& extra_regs,\n GdbServerRegister which) {\n GdbServerRegisterValue reg;\n memset(®, 0, sizeof(reg));\n reg.name = which;\n reg.size = rr::get_reg(regs, extra_regs, ®.value[0], which, ®.defined);\n return reg;\n}\n\nstatic bool matches_threadid(const ExtendedTaskId& tid,\n const GdbThreadId& target) {\n return (target.pid <= 0 || target.pid == tid.tguid.tid()) &&\n (target.tid <= 0 || target.tid == tid.tuid.tid());\n}\n\nstatic bool matches_threadid(Task* t, const GdbThreadId& target) {\n return matches_threadid(extended_task_id(t), target);\n}\n\nstatic WatchType watchpoint_type(GdbRequestType req) {\n switch (req) {\n case DREQ_SET_HW_BREAK:\n case DREQ_REMOVE_HW_BREAK:\n return WATCH_EXEC;\n case DREQ_SET_WR_WATCH:\n case DREQ_REMOVE_WR_WATCH:\n return WATCH_WRITE;\n case DREQ_REMOVE_RDWR_WATCH:\n case DREQ_SET_RDWR_WATCH:\n // NB: x86 doesn't support read-only watchpoints (who would\n // ever want to use one?) so we treat them as readwrite\n // watchpoints and hope that gdb can figure out what's going\n // on. That is, if a user ever tries to set a read\n // watchpoint.\n case DREQ_REMOVE_RD_WATCH:\n case DREQ_SET_RD_WATCH:\n return WATCH_READWRITE;\n default:\n FATAL() << \"Unknown dbg request \" << req;\n return WatchType(-1); // not reached\n }\n}\n\nstatic void maybe_singlestep_for_event(Task* t, GdbRequest* req) {\n ReplayTask* rt = t->as_replay();\n if (!rt) {\n return;\n }\n if (trace_instructions_up_to_event(\n rt->session().current_trace_frame().time())) {\n fputs(\"Stepping: \", stderr);\n t->regs().print_register_file_compact(stderr);\n fprintf(stderr, \" ticks:%\" PRId64 \"\\n\", t->tick_count());\n *req = GdbRequest(DREQ_CONT);\n req->suppress_debugger_stop = true;\n req->cont().actions.push_back(\n GdbContAction(ACTION_STEP,\n extended_task_id(t).to_debugger_thread_id()));\n }\n}\n\nvoid GdbServer::dispatch_regs_request(const Registers& regs,\n const ExtraRegisters& extra_regs) {\n const auto& registers = target_registers(regs.arch());\n vector rs;\n rs.reserve(registers.size());\n for (const auto r : registers) {\n rs.push_back(get_reg(regs, extra_regs, r));\n }\n dbg->reply_get_regs(rs);\n}\n\nclass GdbBreakpointCondition : public BreakpointCondition {\npublic:\n GdbBreakpointCondition(const vector>& bytecodes) {\n for (auto& b : bytecodes) {\n expressions.push_back(GdbServerExpression(b.data(), b.size()));\n }\n }\n virtual bool evaluate(ReplayTask* t) const override {\n for (auto& e : expressions) {\n GdbServerExpression::Value v;\n // Break if evaluation fails or the result is nonzero\n if (!e.evaluate(t, &v) || v.i != 0) {\n return true;\n }\n }\n return false;\n }\n\nprivate:\n vector expressions;\n};\n\nstatic unique_ptr breakpoint_condition(\n const GdbRequest& request) {\n if (request.watch().conditions.empty()) {\n return nullptr;\n }\n return unique_ptr(\n new GdbBreakpointCondition(request.watch().conditions));\n}\n\nstatic bool search_memory(Task* t, const MemoryRange& where,\n const vector& find,\n remote_ptr* result) {\n vector buf;\n buf.resize(page_size() + find.size() - 1);\n for (const auto& m : t->vm()->maps()) {\n MemoryRange r = MemoryRange(m.map.start(), m.map.end() + find.size() - 1)\n .intersect(where);\n // We basically read page by page here, but we read past the end of the\n // page to handle the case where a found string crosses page boundaries.\n // This approach isn't great for handling long search strings but gdb's find\n // command isn't really suited to that.\n // Reading page by page lets us avoid problems where some pages in a\n // mapping aren't readable (e.g. reading beyond end of file).\n while (r.size() >= find.size()) {\n ssize_t nread = t->read_bytes_fallible(\n r.start(), std::min(buf.size(), r.size()), buf.data());\n if (nread >= ssize_t(find.size())) {\n void* found = memmem(buf.data(), nread, find.data(), find.size());\n if (found) {\n *result = r.start() + (static_cast(found) - buf.data());\n return true;\n }\n }\n r = MemoryRange(\n std::min(r.end(), floor_page_size(r.start()) + page_size()), r.end());\n }\n }\n return false;\n}\n\nstatic bool is_in_patch_stubs(Task* t, remote_code_ptr ip) {\n auto p = ip.to_data_ptr();\n return t->vm()->has_mapping(p) &&\n (t->vm()->mapping_flags_of(p) & AddressSpace::Mapping::IS_PATCH_STUBS);\n}\n\nvoid GdbServer::maybe_intercept_mem_request(Task* target, const GdbRequest& req,\n vector* result) {\n DEBUG_ASSERT(req.mem_.len >= result->size());\n /* Crazy hack!\n * When gdb tries to read the word at the top of the stack, and we're in our\n * dynamically-generated stub code, tell it the value is zero, so that gdb's\n * stack-walking code doesn't find a bogus value that it treats as a return\n * address and sets a breakpoint there, potentially corrupting program data.\n * gdb sometimes reads a whole block of memory around the stack pointer so\n * handle cases where the top-of-stack word is contained in a larger range.\n */\n size_t size = word_size(target->arch());\n if (target->regs().sp().as_int() >= req.mem_.addr &&\n target->regs().sp().as_int() + size <= req.mem_.addr + result->size() &&\n is_in_patch_stubs(target, target->ip())) {\n memset(result->data() + target->regs().sp().as_int() - req.mem_.addr, 0,\n size);\n }\n}\n\nstatic vector thread_info(const Session& session) {\n vector threads;\n for (auto& kv : session.tasks()) {\n threads.push_back({\n extended_task_id(kv.second),\n kv.second->regs().ip().register_value()\n });\n }\n return threads;\n}\n\nvoid GdbServer::notify_stop_internal(const Session& session,\n ExtendedTaskId which, int sig,\n const string& reason) {\n dbg->notify_stop(which, sig, thread_info(session), reason);\n}\n\nvoid GdbServer::dispatch_debugger_request(Session& session,\n const GdbRequest& req,\n ReportState state) {\n DEBUG_ASSERT(!req.is_resume_request());\n\n // These requests don't require a target task.\n switch (req.type) {\n case DREQ_RESTART:\n DEBUG_ASSERT(false);\n return; // unreached\n case DREQ_GET_CURRENT_THREAD:\n dbg->reply_get_current_thread(last_continue_task);\n return;\n case DREQ_GET_OFFSETS:\n /* TODO */\n dbg->reply_get_offsets();\n return;\n case DREQ_GET_THREAD_LIST: {\n vector tids;\n if (state != REPORT_THREADS_DEAD && !failed_restart) {\n for (auto& kv : session.tasks()) {\n tids.push_back(extended_task_id(kv.second));\n }\n }\n dbg->reply_get_thread_list(tids);\n return;\n }\n case DREQ_INTERRUPT:\n notify_stop_internal(session, last_continue_task, 0);\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n last_query_task = last_continue_task;\n return;\n case DREQ_GET_EXEC_FILE: {\n // We shouldn't normally receive this since we try to pass the exe file\n // name on gdb's command line, but the user might start gdb manually\n // and this is easy to support in case some other debugger or\n // configuration needs it.\n Task* t = nullptr;\n if (req.target.tid) {\n ThreadGroup* tg = session.find_thread_group(req.target.tid);\n if (tg) {\n t = *tg->task_set().begin();\n }\n } else {\n t = session.find_task(last_continue_task.tuid);\n }\n if (t) {\n dbg->reply_get_exec_file(t->vm()->exe_image());\n } else {\n dbg->reply_get_exec_file(string());\n }\n return;\n }\n case DREQ_FILE_SETFS:\n // Only the filesystem as seen by the remote stub is supported currently\n file_scope_pid = req.file_setfs().pid;\n dbg->reply_setfs(0);\n return;\n case DREQ_FILE_OPEN:\n // We only support reading files\n if (req.file_open().flags == O_RDONLY) {\n Task* t = session.find_task(last_continue_task.tuid);\n int fd = open_file(session, t, req.file_open().file_name);\n dbg->reply_open(fd, fd >= 0 ? 0 : ENOENT);\n } else {\n dbg->reply_open(-1, EACCES);\n }\n return;\n case DREQ_FILE_PREAD: {\n GdbRequest::FilePread read_req = req.file_pread();\n {\n auto it = files.find(read_req.fd);\n if (it != files.end()) {\n size_t size = min(read_req.size, 1024 * 1024);\n vector data;\n data.resize(size);\n ssize_t bytes =\n read_to_end(it->second, read_req.offset, data.data(), size);\n dbg->reply_pread(data.data(), bytes, bytes >= 0 ? 0 : -errno);\n return;\n }\n }\n {\n auto it = memory_files.find(read_req.fd);\n if (it != memory_files.end() && timeline_) {\n // Search our mmap stream for a record that can satisfy this request\n TraceReader tmp_reader(timeline_->current_session().trace_reader());\n tmp_reader.rewind();\n while (true) {\n TraceReader::MappedData data;\n bool found;\n KernelMapping km = tmp_reader.read_mapped_region(\n &data, &found, TraceReader::DONT_VALIDATE, TraceReader::ANY_TIME);\n if (!found)\n break;\n if (it->second == FileId(km)) {\n if (data.source != TraceReader::SOURCE_FILE) {\n LOG(warn) << \"Not serving file because it is not a file source\";\n break;\n }\n ScopedFd fd(data.file_name.c_str(), O_RDONLY);\n vector data;\n data.resize(read_req.size);\n LOG(debug) << \"Reading \" << read_req.size << \" bytes at offset \" <<\n read_req.offset;\n ssize_t bytes =\n read_to_end(fd, read_req.offset, data.data(), read_req.size);\n if (bytes < (ssize_t)read_req.size) {\n LOG(warn) << \"Requested \" << read_req.size << \" bytes but only got \" << bytes;\n }\n dbg->reply_pread(data.data(), bytes, bytes >= 0 ? 0 : -errno);\n return;\n }\n }\n LOG(warn) << \"No mapping found\";\n }\n }\n LOG(warn) << \"Unknown file descriptor requested\";\n dbg->reply_pread(nullptr, 0, EIO);\n return;\n }\n case DREQ_FILE_CLOSE: {\n {\n auto it = files.find(req.file_close().fd);\n if (it != files.end()) {\n files.erase(it);\n dbg->reply_close(0);\n return;\n }\n } {\n auto it = memory_files.find(req.file_close().fd);\n if (it != memory_files.end()) {\n memory_files.erase(it);\n dbg->reply_close(0);\n return;\n }\n }\n LOG(warn) << \"Unable to find file descriptor for close\";\n dbg->reply_close(EBADF);\n return;\n }\n default:\n /* fall through to next switch stmt */\n break;\n }\n\n bool is_query = req.type != DREQ_SET_CONTINUE_THREAD;\n Task* target =\n req.target.tid > 0\n ? session.find_task(req.target.tid)\n : session.find_task(is_query ? last_query_task.tuid : last_continue_task.tuid);\n if (target) {\n if (is_query) {\n last_query_task = extended_task_id(target);\n } else {\n last_continue_task = extended_task_id(target);\n }\n }\n // These requests query or manipulate which task is the\n // target, so it's OK if the task doesn't exist.\n switch (req.type) {\n case DREQ_GET_IS_THREAD_ALIVE:\n dbg->reply_get_is_thread_alive(target != nullptr);\n return;\n case DREQ_GET_THREAD_EXTRA_INFO:\n dbg->reply_get_thread_extra_info(target->name());\n return;\n case DREQ_SET_CONTINUE_THREAD:\n dbg->reply_select_thread(target != nullptr);\n return;\n case DREQ_SET_QUERY_THREAD:\n dbg->reply_select_thread(target != nullptr);\n return;\n default:\n // fall through to next switch stmt\n break;\n }\n\n // These requests require a valid target task. We don't trust\n // the debugger to use the information provided above to only\n // query valid tasks.\n if (!target) {\n dbg->notify_no_such_thread(req);\n return;\n }\n switch (req.type) {\n case DREQ_GET_AUXV: {\n dbg->reply_get_auxv(target->vm()->saved_auxv());\n return;\n }\n case DREQ_GET_MEM:\n case DREQ_GET_MEM_BINARY: {\n vector mem;\n uintptr_t end = req.mem().addr + req.mem().len;\n if (end < req.mem().addr) {\n // Overflow\n dbg->reply_get_mem(mem);\n return;\n }\n mem.resize(req.mem().len);\n\n if (!session.is_diversion() &&\n read_debugger_mem(target->thread_group()->tguid(),\n MemoryRange(req.mem().addr, req.mem().len), mem.data())) {\n } else {\n ssize_t nread = target->read_bytes_fallible(req.mem().addr, req.mem().len,\n mem.data());\n mem.resize(max(ssize_t(0), nread));\n }\n target->vm()->replace_breakpoints_with_original_values(\n mem.data(), mem.size(), req.mem().addr);\n maybe_intercept_mem_request(target, req, &mem);\n dbg->reply_get_mem(mem);\n return;\n }\n case DREQ_SET_MEM:\n case DREQ_SET_MEM_BINARY: {\n // gdb has been observed to send requests of length 0 at\n // odd times\n // (e.g. before sending the magic write to create a checkpoint)\n if (req.mem().len == 0) {\n dbg->reply_set_mem(true);\n return;\n }\n uintptr_t end = req.mem().addr + req.mem().len;\n if (end < req.mem().addr) {\n // Overflow\n dbg->reply_set_mem(false);\n return;\n }\n // If an address is recognised as belonging to a SystemTap semaphore it's\n // because it was detected by the audit library during recording and\n // pre-incremented.\n if (target->vm()->is_stap_semaphore(req.mem().addr)) {\n LOG(info) << \"Suppressing write to SystemTap semaphore\";\n dbg->reply_set_mem(true);\n return;\n }\n // We only allow the debugger to write memory if the\n // memory will be written to an diversion session.\n // Arbitrary writes to replay sessions cause\n // divergence.\n if (!session.is_diversion()) {\n if (write_debugger_mem(target->thread_group()->tguid(),\n MemoryRange(req.mem().addr, req.mem().len),\n req.mem().data.data())) {\n dbg->reply_set_mem(true);\n return;\n }\n\n LOG(error) << \"Attempt to write memory outside diversion session\";\n dbg->reply_set_mem(false);\n return;\n }\n LOG(debug) << \"Writing \" << req.mem().len << \" bytes to \"\n << HEX(req.mem().addr);\n // TODO fallible\n target->write_bytes_helper(req.mem().addr, req.mem().len,\n req.mem().data.data());\n dbg->reply_set_mem(true);\n return;\n }\n case DREQ_SEARCH_MEM_BINARY: {\n remote_ptr addr;\n bool found =\n search_memory(target, MemoryRange(req.mem().addr, req.mem().len),\n req.mem().data, &addr);\n dbg->reply_search_mem_binary(found, addr);\n return;\n }\n case DREQ_MEM_INFO: {\n ASSERT(target, req.mem().len == 1);\n MemoryRange range;\n int prot;\n if (debugger_mem_region(target->thread_group()->tguid(), req.mem().addr,\n &prot, &range)) {\n dbg->reply_mem_info(range, prot, \"\");\n return;\n }\n if (target->vm()->has_mapping(req.mem().addr)) {\n AddressSpace::Mapping m = target->vm()->mapping_of(req.mem().addr);\n dbg->reply_mem_info(m.recorded_map, m.recorded_map.prot(),\n m.recorded_map.fsname());\n } else {\n AddressSpace::Maps maps = target->vm()->maps();\n remote_ptr last_end;\n remote_ptr next_start;\n for (auto it : maps) {\n if (it.recorded_map.start() > req.mem().addr) {\n next_start = it.recorded_map.start();\n break;\n }\n last_end = it.recorded_map.end();\n }\n if (next_start.is_null()) {\n next_start = usable_address_space_end(target->arch());\n }\n dbg->reply_mem_info(MemoryRange(last_end, next_start), 0, string());\n }\n return;\n }\n case DREQ_MEM_ALLOC: {\n remote_ptr addr = allocate_debugger_mem(target->thread_group()->tguid(),\n req.mem_alloc().size, req.mem_alloc().prot);\n if (!addr.is_null() && session.is_diversion()) {\n map_debugger_mem(*session.as_diversion(), target->thread_group()->tguid(),\n addr);\n }\n dbg->reply_mem_alloc(addr);\n return;\n }\n case DREQ_MEM_FREE: {\n size_t size = free_debugger_mem(target->thread_group()->tguid(), req.mem_free().address);\n if (size && session.is_diversion()) {\n unmap_debugger_mem(*session.as_diversion(), target->thread_group()->tguid(),\n req.mem_free().address, size);\n }\n dbg->reply_mem_free(size);\n return;\n }\n case DREQ_GET_REG: {\n GdbServerRegisterValue reg =\n get_reg(target->regs(), *target->extra_regs_fallible(), req.reg().name);\n dbg->reply_get_reg(reg);\n return;\n }\n case DREQ_GET_REGS: {\n dispatch_regs_request(target->regs(), *target->extra_regs_fallible());\n return;\n }\n case DREQ_SET_REG: {\n if (!session.is_diversion()) {\n // gdb sets orig_eax to -1 during a restart. For a\n // replay session this is not correct (we might be\n // restarting from an rr checkpoint inside a system\n // call, and we must not tamper with replay state), so\n // just ignore it.\n if ((target->arch() == x86 && req.reg().name == DREG_ORIG_EAX) ||\n (target->arch() == x86_64 && req.reg().name == DREG_ORIG_RAX)) {\n dbg->reply_set_reg(true);\n return;\n }\n LOG(error) << \"Attempt to write register outside diversion session\";\n dbg->reply_set_reg(false);\n return;\n }\n if (!set_reg(target, req.reg())) {\n LOG(warn) << \"Attempt to set register \" << req.reg().name << \" failed\";\n }\n dbg->reply_set_reg(true /*currently infallible*/);\n return;\n }\n case DREQ_GET_STOP_REASON: {\n dbg->reply_get_stop_reason(last_continue_task, stop_siginfo.si_signo,\n thread_info(session));\n return;\n }\n case DREQ_SET_SW_BREAK: {\n ASSERT(target, req.watch().kind == bkpt_instruction_length(target->arch()))\n << \"Debugger setting bad breakpoint insn\";\n // Mirror all breakpoint/watchpoint sets/unsets to the target process\n // if it's not part of the timeline (i.e. it's a diversion).\n if (!timeline_) {\n dbg->reply_watchpoint_request(false);\n return;\n }\n ReplayTask* replay_task =\n timeline_->current_session().find_task(target->tuid());\n bool ok = timeline_->add_breakpoint(replay_task, req.watch().addr,\n breakpoint_condition(req));\n if (ok && &session != &timeline_->current_session()) {\n bool diversion_ok =\n target->vm()->add_breakpoint(req.watch().addr, BKPT_USER);\n ASSERT(target, diversion_ok);\n }\n dbg->reply_watchpoint_request(ok);\n return;\n }\n case DREQ_SET_HW_BREAK:\n case DREQ_SET_RD_WATCH:\n case DREQ_SET_WR_WATCH:\n case DREQ_SET_RDWR_WATCH: {\n if (!timeline_) {\n dbg->reply_watchpoint_request(false);\n return;\n }\n ReplayTask* replay_task =\n timeline_->current_session().find_task(target->tuid());\n bool ok = timeline_->add_watchpoint(\n replay_task, req.watch().addr, req.watch().kind,\n watchpoint_type(req.type), breakpoint_condition(req));\n if (ok && &session != &timeline_->current_session()) {\n bool diversion_ok = target->vm()->add_watchpoint(\n req.watch().addr, req.watch().kind, watchpoint_type(req.type));\n ASSERT(target, diversion_ok);\n }\n dbg->reply_watchpoint_request(ok);\n return;\n }\n case DREQ_REMOVE_SW_BREAK: {\n if (!timeline_) {\n dbg->reply_watchpoint_request(true);\n return;\n }\n ReplayTask* replay_task =\n timeline_->current_session().find_task(target->tuid());\n timeline_->remove_breakpoint(replay_task, req.watch().addr);\n if (&session != &timeline_->current_session()) {\n target->vm()->remove_breakpoint(req.watch().addr, BKPT_USER);\n }\n dbg->reply_watchpoint_request(true);\n return;\n }\n case DREQ_REMOVE_HW_BREAK:\n case DREQ_REMOVE_RD_WATCH:\n case DREQ_REMOVE_WR_WATCH:\n case DREQ_REMOVE_RDWR_WATCH: {\n if (!timeline_) {\n dbg->reply_watchpoint_request(true);\n return;\n }\n ReplayTask* replay_task =\n timeline_->current_session().find_task(target->tuid());\n timeline_->remove_watchpoint(replay_task, req.watch().addr,\n req.watch().kind, watchpoint_type(req.type));\n if (&session != &timeline_->current_session()) {\n target->vm()->remove_watchpoint(req.watch().addr, req.watch().kind,\n watchpoint_type(req.type));\n }\n dbg->reply_watchpoint_request(true);\n return;\n }\n case DREQ_READ_SIGINFO: {\n vector si_bytes;\n si_bytes.resize(req.mem().len);\n memset(si_bytes.data(), 0, si_bytes.size());\n memcpy(si_bytes.data(), &stop_siginfo,\n min(si_bytes.size(), sizeof(stop_siginfo)));\n dbg->reply_read_siginfo(si_bytes);\n return;\n }\n case DREQ_WRITE_SIGINFO:\n LOG(warn) << \"WRITE_SIGINFO request outside of diversion session\";\n dbg->reply_write_siginfo();\n return;\n case DREQ_SAVE_REGISTER_STATE: {\n int state_index = DIVERSION_SAVED_REGISTER_STATE + 1;\n while (saved_register_states.find(state_index) != saved_register_states.end()) {\n ++state_index;\n }\n SavedRegisters& regs = saved_register_states[state_index];\n regs.regs = target->regs();\n regs.extra_regs = *target->extra_regs_fallible();\n dbg->reply_save_register_state(true, state_index);\n return;\n }\n case DREQ_RESTORE_REGISTER_STATE: {\n if (!session.is_diversion()) {\n LOG(error) << \"RESTORE_REGISTER_STATE request outside of diversion session\";\n dbg->reply_restore_register_state(false);\n return;\n }\n int state_index = req.restore_register_state().state_index;\n auto it = saved_register_states.find(state_index);\n if (it == saved_register_states.end()) {\n LOG(error) << \"Unknown register state\";\n dbg->reply_restore_register_state(false);\n return;\n }\n target->set_regs(it->second.regs);\n target->set_extra_regs(it->second.extra_regs);\n saved_register_states.erase(it);\n dbg->reply_restore_register_state(true);\n return;\n }\n case DREQ_RR_CMD:\n dbg->reply_rr_cmd(\n DebuggerExtensionCommandHandler::process_command(*this, target, req.rr_cmd()));\n return;\n#ifdef PROC_SERVICE_H\n case DREQ_QSYMBOL: {\n // When gdb sends \"qSymbol::\", it means that gdb is ready to\n // respond to symbol requests. This can be sent multiple times\n // during the course of a session -- gdb sends it whenever\n // something in the inferior has changed, making it possible\n // that previous failed symbol lookups could now succeed. In\n // response to a qSymbol request from gdb, we either send back a\n // qSymbol response, requesting the address of a symbol; or we\n // send back OK. We have to do this as an ordinary response and\n // maintain our own state explicitly, as opposed to simply\n // reading another packet from gdb, because when gdb looks up a\n // symbol it might send other requests that must be served. So,\n // we keep a copy of the symbol names, and an iterator into this\n // copy. When gdb sends a plain \"qSymbol::\" packet, because gdb\n // has detected some change in the inferior state that might\n // enable more symbol lookups, we restart the iterator.\n if (!thread_db) {\n thread_db =\n std::unique_ptr(new ThreadDb(debuggee_tguid.tid()));\n }\n\n const string& name = req.sym().name;\n if (req.sym().has_address) {\n // Got a response holding a previously-requested symbol's name\n // and address.\n thread_db->register_symbol(name, req.sym().address);\n } else if (name == \"\") {\n // Plain \"qSymbol::\" request.\n symbols =\n thread_db->get_symbols_and_clear_map(target->thread_group().get());\n symbols_iter = symbols.begin();\n }\n\n if (symbols_iter == symbols.end()) {\n dbg->qsymbols_finished();\n } else {\n string symbol = *symbols_iter++;\n dbg->send_qsymbol(symbol);\n }\n return;\n }\n case DREQ_TLS: {\n if (!thread_db) {\n thread_db =\n std::unique_ptr(new ThreadDb(debuggee_tguid.tid()));\n }\n remote_ptr address;\n bool ok = thread_db->get_tls_address(target->thread_group().get(),\n target->rec_tid, req.tls().offset,\n req.tls().load_module, &address);\n dbg->reply_tls_addr(ok, address);\n return;\n }\n#endif\n default:\n FATAL() << \"Unknown debugger request \" << req.type;\n }\n}\n\nstatic bool any_action_targets_match(const ExtendedTaskId& thread,\n const vector& actions) {\n return any_of(actions.begin(), actions.end(), [&thread](GdbContAction action) {\n return matches_threadid(thread, action.target);\n });\n}\n\nstatic Task* find_first_task_matching_target(\n const Session& session, const vector& actions) {\n const Session::TaskMap& tasks = session.tasks();\n auto it = find_first_of(\n tasks.begin(), tasks.end(),\n actions.begin(), actions.end(),\n [](Session::TaskMap::value_type task_pair, GdbContAction action) {\n return matches_threadid(task_pair.second, action.target);\n });\n return it != tasks.end() ? it->second : nullptr;\n}\n\nbool GdbServer::diverter_process_debugger_requests(\n DiversionSession& diversion_session, uint32_t& diversion_refcount,\n GdbRequest* req) {\n while (true) {\n *req = dbg->get_request();\n\n if (req->is_resume_request()) {\n const vector& actions = req->cont().actions;\n DEBUG_ASSERT(actions.size() > 0);\n // GDB may ask us to resume more than one task, so we have to\n // choose one. We give priority to the task last resumed, as\n // this is likely to be the context in which GDB is executing\n // code; selecting any other task runs the risk of resuming\n // replay, denying the diverted code an opportunity to complete\n // and end the diversion session.\n if (!any_action_targets_match(last_continue_task, actions)) {\n // If none of the resumption targets match the task last\n // resumed, we simply choose any matching task. This ensures\n // that GDB (and the user) can choose an arbitrary thread to\n // serve as the context of the code being evaluated.\n // TODO: maybe it makes sense to try and select the matching\n // task that was most recently resumed, or possibly the\n // matching task with an event in the replay trace nearest to\n // 'now'.\n Task* task =\n find_first_task_matching_target(diversion_session, actions);\n DEBUG_ASSERT(task != nullptr);\n last_continue_task = extended_task_id(task);\n }\n return diversion_refcount > 0;\n }\n\n switch (req->type) {\n case DREQ_RESTART:\n case DREQ_DETACH:\n diversion_refcount = 0;\n return false;\n\n case DREQ_READ_SIGINFO: {\n LOG(debug) << \"Adding ref to diversion session\";\n ++diversion_refcount;\n // TODO: maybe share with replayer.cc?\n vector si_bytes;\n si_bytes.resize(req->mem().len);\n memset(si_bytes.data(), 0, si_bytes.size());\n dbg->reply_read_siginfo(si_bytes);\n continue;\n }\n\n case DREQ_RESTORE_REGISTER_STATE: {\n int state_index = req->restore_register_state().state_index;\n if (state_index == DIVERSION_SAVED_REGISTER_STATE) {\n diversion_refcount = 0;\n dbg->reply_restore_register_state(true);\n // This request does not need to be retried outside the diversion\n *req = GdbRequest(DREQ_NONE);\n return false;\n }\n break;\n }\n\n case DREQ_SET_QUERY_THREAD: {\n if (req->target.tid) {\n Task* next = diversion_session.find_task(req->target.tid);\n if (next) {\n last_query_task = extended_task_id(next);\n }\n }\n break;\n }\n\n case DREQ_WRITE_SIGINFO:\n LOG(debug) << \"Removing reference to diversion session ...\";\n DEBUG_ASSERT(diversion_refcount > 0);\n --diversion_refcount;\n if (diversion_refcount == 0) {\n LOG(debug) << \" ... dying at next continue request\";\n }\n dbg->reply_write_siginfo();\n continue;\n\n case DREQ_RR_CMD: {\n DEBUG_ASSERT(req->type == DREQ_RR_CMD);\n Task* task = diversion_session.find_task(last_continue_task.tuid);\n if (task) {\n std::string reply =\n DebuggerExtensionCommandHandler::process_command(*this, task, req->rr_cmd());\n // Certain commands cause the diversion to end immediately\n // while other commands must work within a diversion.\n if (reply == DebuggerExtensionCommandHandler::cmd_end_diversion()) {\n diversion_refcount = 0;\n return false;\n }\n dbg->reply_rr_cmd(reply);\n continue;\n } else {\n diversion_refcount = 0;\n return false;\n }\n break;\n }\n\n default:\n break;\n }\n dispatch_debugger_request(diversion_session, *req, REPORT_NORMAL);\n }\n}\n\nstatic bool is_last_thread_exit(const BreakStatus& break_status) {\n // The task set may be empty if the task has already exited.\n return break_status.task_exit &&\n break_status.task_context.thread_group->task_set().size() <= 1;\n}\n\nstatic Task* is_in_exec(ReplayTimeline* timeline) {\n if (!timeline) {\n return nullptr;\n }\n Task* t = timeline->current_session().current_task();\n if (!t) {\n return nullptr;\n }\n return timeline->current_session().next_step_is_successful_exec_syscall_exit()\n ? t\n : nullptr;\n}\n\nvoid GdbServer::maybe_notify_stop(const Session& session,\n const GdbRequest& req,\n const BreakStatus& break_status) {\n bool do_stop = false;\n stringstream reason;\n if (!break_status.watchpoints_hit.empty()) {\n do_stop = true;\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n stop_siginfo.si_signo = SIGTRAP;\n remote_ptr watch_addr = break_status.watchpoints_hit[0].addr;\n bool any_hw_break = false;\n for (const auto& w : break_status.watchpoints_hit) {\n if (w.type == WATCH_EXEC) {\n any_hw_break = true;\n }\n }\n if (dbg->hwbreak_supported() && any_hw_break) {\n reason << \"hwbreak:;\";\n } else if (watch_addr) {\n reason << \"watch:\" << std::hex << watch_addr.as_int() << \";\";\n }\n LOG(debug) << \"Stopping for watchpoint at \" << watch_addr;\n }\n if (break_status.breakpoint_hit || break_status.singlestep_complete) {\n do_stop = true;\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n stop_siginfo.si_signo = SIGTRAP;\n if (break_status.breakpoint_hit) {\n if (dbg->swbreak_supported()) {\n reason << \"swbreak:;\";\n }\n LOG(debug) << \"Stopping for breakpoint\";\n } else {\n LOG(debug) << \"Stopping for singlestep\";\n }\n }\n if (break_status.signal) {\n do_stop = true;\n stop_siginfo = *break_status.signal;\n LOG(debug) << \"Stopping for signal \" << stop_siginfo;\n }\n if (is_last_thread_exit(break_status)) {\n if (break_status.task_context.session->is_diversion()) {\n // If the last task of a diversion session has exited, we need\n // to make sure GDB knows it's unrecoverable. There's no good\n // way to do this: a stop is insufficient, but an inferior exit\n // typically signals the end of a debugging session. Using the\n // latter approach appears to work, but stepping through GDB's\n // processing of the event seems to indicate it isn't really\n // supposed to. FIXME.\n LOG(debug) << \"Last task of diversion exiting. \"\n << \"Notifying exit with synthetic SIGKILL\";\n dbg->notify_exit_signal(SIGKILL);\n return;\n } else if (dbg->features().reverse_execution) {\n do_stop = true;\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n if (req.cont().run_direction == RUN_FORWARD) {\n // The exit of the last task in a thread group generates a fake SIGKILL,\n // when reverse-execution is enabled, because users often want to run\n // backwards from the end of the task.\n stop_siginfo.si_signo = SIGKILL;\n LOG(debug) << \"Stopping for synthetic SIGKILL\";\n } else {\n // The start of the debuggee task-group should trigger a silent stop.\n stop_siginfo.si_signo = 0;\n // Documented as \"has reached the end (or the beginning when executing\n // backward) of the log\"\n reason << \"replaylog:begin;\";\n LOG(debug) << \"Stopping at start of execution while running backwards\";\n }\n }\n }\n Task* t = break_status.task();\n Task* in_exec_task = is_in_exec(timeline_);\n if (in_exec_task) {\n do_stop = true;\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n t = in_exec_task;\n LOG(debug) << \"Stopping at exec\";\n }\n if (do_stop && t->thread_group()->tguid() == debuggee_tguid) {\n /* Notify the debugger and process any new requests\n * that might have triggered before resuming. */\n notify_stop_internal(session, extended_task_id(t), stop_siginfo.si_signo,\n reason.str());\n last_query_task = last_continue_task = extended_task_id(t);\n }\n}\n\nstatic RunCommand compute_run_command_from_actions(Task* t,\n const GdbRequest& req,\n int* signal_to_deliver) {\n for (auto& action : req.cont().actions) {\n if (matches_threadid(t, action.target)) {\n // We can only run task |t|; neither diversion nor replay sessions\n // support running multiple threads. So even if gdb tells us to continue\n // multiple threads, we don't do that.\n *signal_to_deliver = action.signal_to_deliver;\n return action.type == ACTION_STEP ? RUN_SINGLESTEP : RUN_CONTINUE;\n }\n }\n // gdb told us to run (or step) some thread that's not |t|, without resuming\n // |t|. It sometimes does this even though its target thread is entering a\n // blocking syscall and |t| must run before gdb's target thread can make\n // progress. So, allow |t| to run anyway.\n *signal_to_deliver = 0;\n return RUN_CONTINUE;\n}\n\nstruct AllowedTasks {\n TaskUid task; // tid 0 means 'any member of debuggee_tguid'\n RunCommand command;\n};\nstatic RunCommand compute_run_command_for_reverse_exec(\n Session& session, const ThreadGroupUid& debuggee_tguid,\n const GdbRequest& req, vector& allowed_tasks) {\n // Singlestep if any of the actions request singlestepping.\n RunCommand result = RUN_CONTINUE;\n for (auto& action : req.cont().actions) {\n if (action.target.pid > 0 && action.target.pid != debuggee_tguid.tid()) {\n continue;\n }\n AllowedTasks allowed;\n allowed.command = RUN_CONTINUE;\n if (action.type == ACTION_STEP) {\n allowed.command = result = RUN_SINGLESTEP;\n }\n if (action.target.tid > 0) {\n Task* t = session.find_task(action.target.tid);\n if (t) {\n allowed.task = t->tuid();\n }\n }\n allowed_tasks.push_back(allowed);\n }\n return result;\n}\n\n/**\n * Create a new diversion session using |replay| session as the\n * template. The |replay| session isn't mutated.\n *\n * Execution begins in the new diversion session under the control of\n * |dbg| starting with initial thread target |task|. The diversion\n * session ends at the request of |dbg|, and |req| returns the first\n * request made that wasn't handled by the diversion session. That\n * is, the first request that should be handled by |replay| upon\n * resuming execution in that session.\n */\nGdbRequest GdbServer::divert(ReplaySession& replay) {\n GdbRequest req;\n LOG(debug) << \"Starting debugging diversion for \" << &replay;\n\n if (timeline_) {\n // Ensure breakpoints and watchpoints are applied before we fork the\n // diversion, to ensure the diversion is consistent with the timeline\n // breakpoint/watchpoint state.\n timeline_->apply_breakpoints_and_watchpoints();\n }\n DiversionSession::shr_ptr diversion_session = replay.clone_diversion();\n uint32_t diversion_refcount = 1;\n ExtendedTaskId saved_query_task = last_query_task;\n ExtendedTaskId saved_continue_task = last_continue_task;\n\n for (const auto& dbg_mem : debugger_mem) {\n for (const auto& region : dbg_mem.second.regions) {\n map_debugger_mem(*diversion_session, dbg_mem.first, region.first.start());\n }\n }\n\n vector fields;\n if (!DIVERSION_SINGLESTEP_PRINT.empty()) {\n parse_trace_fields(DIVERSION_SINGLESTEP_PRINT, &fields);\n }\n\n while (true) {\n if (!diverter_process_debugger_requests(*diversion_session,\n diversion_refcount, &req)) {\n read_back_debugger_mem(*diversion_session);\n break;\n }\n\n DEBUG_ASSERT(req.is_resume_request());\n\n if (req.cont().run_direction == RUN_BACKWARD) {\n // We don't support reverse execution in a diversion. Just issue\n // an immediate stop.\n notify_stop_internal(*diversion_session, last_continue_task, 0);\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n last_query_task = last_continue_task;\n continue;\n }\n\n Task* t = diversion_session->find_task(last_continue_task.tuid);\n DEBUG_ASSERT(t != nullptr);\n\n int signal_to_deliver = 0;\n RunCommand command = DIVERSION_SINGLESTEP_PRINT.empty() ? \n compute_run_command_from_actions(t, req, &signal_to_deliver) : RUN_SINGLESTEP;\n auto result =\n diversion_session->diversion_step(t, command, signal_to_deliver);\n\n if (result.status == DiversionSession::DIVERSION_EXITED) {\n diversion_refcount = 0;\n maybe_notify_stop(*diversion_session, req, result.break_status);\n if (timeline_) {\n // gdb assumes that the process is gone and all its\n // breakpoints have gone with it. It will set new breakpoints.\n timeline_->remove_breakpoints_and_watchpoints();\n }\n req = GdbRequest(DREQ_NONE);\n // Deliberately not reading back debugger mem\n break;\n }\n\n DEBUG_ASSERT(result.status == DiversionSession::DIVERSION_CONTINUE);\n\n if (!DIVERSION_SINGLESTEP_PRINT.empty() && result.break_status.singlestep_complete) {\n print_trace_fields(t->as_replay(), 0, 0, false, fields, stdout);\n continue;\n }\n\n maybe_notify_stop(*diversion_session, req, result.break_status);\n }\n\n LOG(debug) << \"... ending debugging diversion\";\n DEBUG_ASSERT(diversion_refcount == 0);\n\n diversion_session->kill_all_tasks();\n\n last_query_task = saved_query_task;\n last_continue_task = saved_continue_task;\n return req;\n}\n\n/**\n * Reply to debugger requests until the debugger asks us to resume\n * execution, detach, restart, or interrupt.\n */\nGdbRequest GdbServer::process_debugger_requests(ReportState state) {\n while (true) {\n GdbRequest req = dbg->get_request();\n req.suppress_debugger_stop = false;\n try_lazy_reverse_singlesteps(req);\n\n if (req.type == DREQ_READ_SIGINFO) {\n vector si_bytes;\n si_bytes.resize(req.mem().len);\n memset(si_bytes.data(), 0, si_bytes.size());\n memcpy(si_bytes.data(), &stop_siginfo,\n min(si_bytes.size(), sizeof(stop_siginfo)));\n dbg->reply_read_siginfo(si_bytes);\n\n if (!timeline_) {\n continue;\n }\n // READ_SIGINFO is usually the start of a diversion. It can also be\n // triggered by \"print $_siginfo\" but that is rare so we just assume it's\n // a diversion start; if \"print $_siginfo\" happens we'll print the correct\n // siginfo and then incorrectly start a diversion and go haywire :-(.\n // Ideally we'd come up with a better way to detect diversions so that\n // \"print $_siginfo\" works.\n req = divert(timeline_->current_session());\n if (req.type == DREQ_NONE) {\n continue;\n }\n // Carry on to process the request that was rejected by\n // the diversion session\n }\n\n if (req.type == DREQ_SAVE_REGISTER_STATE && timeline_) {\n dbg->reply_save_register_state(true, DIVERSION_SAVED_REGISTER_STATE);\n req = divert(timeline_->current_session());\n if (req.type == DREQ_NONE) {\n continue;\n }\n // Carry on to process the request that was rejected by\n // the diversion session\n }\n\n if (req.is_resume_request()) {\n Task* t = current_session().find_task(last_continue_task.tuid);\n if (t) {\n maybe_singlestep_for_event(t, &req);\n }\n return req;\n }\n\n if (req.type == DREQ_INTERRUPT) {\n LOG(debug) << \" request to interrupt\";\n return req;\n }\n\n if (req.type == DREQ_RESTART) {\n // Debugger client requested that we restart execution\n // from the beginning. Restart our debug session.\n LOG(debug) << \" request to restart at event \" << req.restart().param;\n return req;\n }\n if (req.type == DREQ_DETACH) {\n LOG(debug) << \" debugger detached\";\n dbg->reply_detach();\n return req;\n }\n\n dispatch_debugger_request(current_session(), req, state);\n }\n}\n\nvoid GdbServer::try_lazy_reverse_singlesteps(GdbRequest& req) {\n if (!timeline_) {\n return;\n }\n\n ReplayTimeline::Mark now;\n bool need_seek = false;\n ReplayTask* t = timeline_->current_session().current_task();\n while (t && req.type == DREQ_CONT &&\n req.cont().run_direction == RUN_BACKWARD &&\n req.cont().actions.size() == 1 &&\n req.cont().actions[0].type == ACTION_STEP &&\n req.cont().actions[0].signal_to_deliver == 0 &&\n matches_threadid(t, req.cont().actions[0].target) &&\n !req.suppress_debugger_stop) {\n if (!now) {\n now = timeline_->mark();\n }\n ReplayTimeline::Mark previous = timeline_->lazy_reverse_singlestep(now, t);\n if (!previous) {\n break;\n }\n\n now = previous;\n need_seek = true;\n BreakStatus break_status;\n break_status.task_context = TaskContext(t);\n break_status.singlestep_complete = true;\n LOG(debug) << \" using lazy reverse-singlestep\";\n maybe_notify_stop(timeline_->current_session(), req, break_status);\n\n while (true) {\n req = dbg->get_request();\n req.suppress_debugger_stop = false;\n if (req.type != DREQ_GET_REGS) {\n break;\n }\n LOG(debug) << \" using lazy reverse-singlestep registers\";\n dispatch_regs_request(now.regs(), now.extra_regs());\n }\n }\n\n if (need_seek) {\n timeline_->seek_to_mark(now);\n }\n}\n\nbool GdbServer::detach_or_restart(const GdbRequest& req, ContinueOrStop* s) {\n if (DREQ_RESTART == req.type) {\n restart_session(req);\n *s = CONTINUE_DEBUGGING;\n return true;\n }\n if (DREQ_DETACH == req.type) {\n *s = STOP_DEBUGGING;\n return true;\n }\n return false;\n}\n\nGdbServer::ContinueOrStop GdbServer::handle_exited_state(\n GdbRequest& last_resume_request) {\n // TODO return real exit code, if it's useful.\n dbg->notify_exit_code(0);\n if (timeline_) {\n final_event = timeline_->current_session().trace_reader().time();\n }\n while (true) {\n GdbRequest req = process_debugger_requests(REPORT_THREADS_DEAD);\n ContinueOrStop s;\n if (detach_or_restart(req, &s)) {\n last_resume_request = GdbRequest();\n return s;\n }\n if (req.type == DREQ_INTERRUPT) {\n // Ignore this. Sometimes LLDB seems to send it automatically\n // after the task has exited, before we detach I guess.\n continue;\n }\n FATAL() << \"Received continue/interrupt request after end-of-trace: \"\n << req.type;\n }\n}\n\nReplayTask* GdbServer::require_timeline_current_task() {\n if (!timeline_) {\n FATAL() << \"Timeline required here\";\n }\n ReplayTask* t = timeline_->current_session().current_task();\n if (!t) {\n FATAL() << \"Expected current task but none found; expected task with tid \"\n << timeline_->current_session().current_trace_frame().tid()\n << \" at event \" << timeline_->current_session().current_frame_time();\n }\n return t;\n}\n\nGdbServer::ContinueOrStop GdbServer::debug_one_step(\n GdbRequest& last_resume_request) {\n if (!timeline_) {\n FATAL() << \"Timeline required here\";\n }\n\n ReplayResult result;\n GdbRequest req;\n\n if (in_debuggee_end_state) {\n // Treat the state where the last thread is about to exit like\n // termination.\n req = process_debugger_requests();\n // If it's a forward execution request, fake the exited state.\n if (req.is_resume_request() && req.cont().run_direction == RUN_FORWARD) {\n if (interrupt_pending) {\n // Just process this. We're getting it after a restart.\n } else {\n return handle_exited_state(last_resume_request);\n }\n } else {\n if (req.type != DREQ_DETACH) {\n in_debuggee_end_state = false;\n }\n }\n // Otherwise (e.g. detach, restart, interrupt or reverse-exec) process\n // the request as normal.\n } else if (!interrupt_pending || last_resume_request.type == DREQ_NONE) {\n req = process_debugger_requests();\n } else {\n req = last_resume_request;\n }\n\n ContinueOrStop s;\n if (detach_or_restart(req, &s)) {\n last_resume_request = GdbRequest();\n return s;\n }\n\n if (req.is_resume_request()) {\n last_resume_request = req;\n } else {\n DEBUG_ASSERT(req.type == DREQ_INTERRUPT);\n interrupt_pending = true;\n req = last_resume_request;\n DEBUG_ASSERT(req.is_resume_request());\n }\n\n if (interrupt_pending) {\n Task* t = require_timeline_current_task();\n if (t->thread_group()->tguid() == debuggee_tguid) {\n interrupt_pending = false;\n notify_stop_internal(timeline_->current_session(),\n extended_task_id(t), in_debuggee_end_state ? SIGKILL : 0);\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n return CONTINUE_DEBUGGING;\n }\n }\n\n if (exit_sigkill_pending) {\n Task* t = require_timeline_current_task();\n if (t->thread_group()->tguid() == debuggee_tguid) {\n exit_sigkill_pending = false;\n if (req.cont().run_direction == RUN_FORWARD) {\n notify_stop_internal(timeline_->current_session(),\n extended_task_id(t), SIGKILL);\n memset(&stop_siginfo, 0, sizeof(stop_siginfo));\n return CONTINUE_DEBUGGING;\n }\n }\n }\n\n if (req.cont().run_direction == RUN_FORWARD) {\n if (is_in_exec(timeline_) &&\n require_timeline_current_task()->thread_group()->tguid() ==\n debuggee_tguid) {\n // Don't go any further forward. maybe_notify_stop will generate a\n // stop.\n result = ReplayResult();\n } else {\n int signal_to_deliver;\n RunCommand command = compute_run_command_from_actions(\n require_timeline_current_task(), req, &signal_to_deliver);\n // Ignore gdb's |signal_to_deliver|; we just have to follow the replay.\n result = timeline_->replay_step_forward(command);\n }\n if (result.status == REPLAY_EXITED) {\n return handle_exited_state(last_resume_request);\n }\n } else {\n vector allowed_tasks;\n // Convert the tids in GdbContActions into TaskUids to avoid issues\n // if tids get reused.\n RunCommand command = compute_run_command_for_reverse_exec(\n timeline_->current_session(), debuggee_tguid, req, allowed_tasks);\n auto stop_filter = [&](ReplayTask* t, const BreakStatus &break_status) -> bool {\n if (t->thread_group()->tguid() != debuggee_tguid) {\n return false;\n }\n\n // don't stop for a signal that has been specified by QPassSignal\n if (break_status.signal && dbg->is_pass_signal(break_status.signal->si_signo)) {\n LOG(debug) << \"Filtering out event for signal \" << break_status.signal->si_signo;\n return false;\n }\n\n // If gdb's requested actions don't allow the task to run, we still\n // let it run (we can't do anything else, since we're replaying), but\n // we won't report stops in that task.\n for (auto& a : allowed_tasks) {\n if (a.task.tid() == 0 || a.task == t->tuid()) {\n return true;\n }\n }\n return false;\n };\n\n auto interrupt_check = [&]() { return dbg->sniff_packet(); };\n switch (command) {\n case RUN_CONTINUE:\n result = timeline_->reverse_continue(stop_filter, interrupt_check);\n break;\n case RUN_SINGLESTEP: {\n Task* t = timeline_->current_session().find_task(last_continue_task.tuid);\n DEBUG_ASSERT(t);\n result = timeline_->reverse_singlestep(\n last_continue_task.tuid, t->tick_count(), stop_filter, interrupt_check);\n break;\n }\n default:\n DEBUG_ASSERT(0 && \"Unknown RunCommand\");\n }\n\n if (result.status == REPLAY_EXITED) {\n return handle_exited_state(last_resume_request);\n }\n }\n if (!req.suppress_debugger_stop) {\n maybe_notify_stop(timeline_->current_session(),\n req, result.break_status);\n }\n if (req.cont().run_direction == RUN_FORWARD &&\n is_last_thread_exit(result.break_status) &&\n result.break_status.task_context.thread_group->tguid() == debuggee_tguid) {\n in_debuggee_end_state = true;\n }\n return CONTINUE_DEBUGGING;\n}\n\nstatic bool target_event_reached(const ReplayTimeline& timeline,\n const GdbServer::Target& target,\n const ReplayResult& result) {\n if (target.event == -1) {\n return is_last_thread_exit(result.break_status) &&\n (target.pid <= 0 || result.break_status.task_context.thread_group->tgid == target.pid);\n } else {\n return timeline.current_session().current_trace_frame().time() > target.event;\n }\n}\n\nstatic bool at_target(ReplayTimeline& timeline,\n const GdbServer::Target& target,\n volatile bool* stop_replaying_to_target,\n const ReplayResult& result) {\n // Don't launch the debugger for the initial rr fork child.\n // No one ever wants that to happen.\n if (!timeline.current_session().done_initial_exec()) {\n return false;\n }\n Task* t = timeline.current_session().current_task();\n if (!t) {\n return false;\n }\n bool target_is_exit = target.event == -1;\n if (!(timeline.can_add_checkpoint() || target_is_exit)) {\n return false;\n }\n if (stop_replaying_to_target && *stop_replaying_to_target) {\n return true;\n }\n // When we decide to create the debugger, we may end up\n // creating a checkpoint. In that case, we want the\n // checkpoint to retain the state it had *before* we started\n // replaying the next frame. Otherwise, the TraceIfstream\n // will be one frame ahead of its tracee tree.\n //\n // So we make the decision to create the debugger based on the\n // frame we're *about to* replay, without modifying the\n // TraceIfstream.\n // NB: we'll happily attach to whichever task within the\n // group happens to be scheduled here. We don't take\n // \"attach to process\" to mean \"attach to thread-group\n // leader\".\n return target_event_reached(timeline, target, result) &&\n (!target.pid || t->tgid() == target.pid) &&\n (!target.require_exec || t->execed()) &&\n // Ensure we're at the start of processing an event. We don't\n // want to attach while we're finishing an exec() since that's a\n // slightly confusing state for ReplayTimeline's reverse execution.\n (!timeline.current_session().current_step_key().in_execution() || target_is_exit);\n}\n\n/**\n * The trace has reached the event at which the user wanted to start debugging.\n * Set up the appropriate state.\n */\nvoid GdbServer::activate_debugger() {\n if (!timeline_) {\n FATAL() << \"Should only be called with a timeline\";\n }\n TraceFrame next_frame = timeline_->current_session().current_trace_frame();\n FrameTime completed_event = next_frame.time() - 1;\n Task* t = require_timeline_current_task();\n if (target.event || target.pid) {\n if (stop_replaying_to_target && *stop_replaying_to_target) {\n fprintf(stderr, \"\\a\\n\"\n \"--------------------------------------------------\\n\"\n \" ---> Interrupted; attached to NON-TARGET process %d at event %llu.\\n\"\n \"--------------------------------------------------\\n\",\n t->tgid(), (long long)completed_event);\n } else if (target.event >= 0) {\n fprintf(stderr, \"\\a\\n\"\n \"--------------------------------------------------\\n\"\n \" ---> Reached target process %d at event %llu.\\n\"\n \"--------------------------------------------------\\n\",\n t->tgid(), (long long)completed_event);\n } else {\n ASSERT(t, target.event == -1);\n fprintf(stderr, \"\\a\\n\"\n \"--------------------------------------------------\\n\"\n \" ---> Reached exit of target process %d at event %llu.\\n\"\n \"--------------------------------------------------\\n\",\n t->tgid(), (long long)completed_event);\n exit_sigkill_pending = true;\n }\n }\n\n // Store the current tgid and event as the \"execution target\"\n // for the next replay session, if we end up restarting. This\n // allows us to determine if a later session has reached this\n // target without necessarily replaying up to this point.\n target.pid = t->tgid();\n target.require_exec = false;\n target.event = completed_event;\n\n last_query_task = last_continue_task = extended_task_id(t);\n\n // Have the \"checkpoint\" be the original replay\n // session, and then switch over to using the cloned\n // session. The cloned tasks will look like children\n // of the clonees, so this scheme prevents |pstree|\n // output from getting /too/ far out of whack.\n const char* where = \"???\";\n if (timeline_->can_add_checkpoint()) {\n debugger_restart_checkpoint =\n Checkpoint(*timeline_, last_continue_task, Checkpoint::EXPLICIT, where);\n } else {\n debugger_restart_checkpoint = Checkpoint(*timeline_, last_continue_task,\n Checkpoint::NOT_EXPLICIT, where);\n }\n}\n\nstatic FrameTime compute_time_from_ticks(ReplayTimeline& timeline, Ticks target) {\n ReplaySession &session = timeline.current_session();\n Task* task = session.current_task();\n FrameTime current_time = session.current_frame_time();\n TraceReader tmp_reader(session.trace_reader());\n FrameTime last_time = current_time;\n if (session.ticks_at_start_of_current_event() > target) {\n tmp_reader.rewind();\n FrameTime task_time;\n // EXEC and CLONE reset the ticks counter. Find the first event\n // where the tuid matches our current task.\n // We'll always hit at least one CLONE/EXEC event for a task\n // (we can't debug the time before the initial exec)\n // but set this to 0 anyway to silence compiler warnings.\n FrameTime ticks_start_time = 0;\n while (true) {\n TraceTaskEvent r = tmp_reader.read_task_event(&task_time);\n if (task_time >= current_time) {\n break;\n }\n if (r.type() == TraceTaskEvent::CLONE || r.type() == TraceTaskEvent::EXEC) {\n if (r.tid() == task->tuid().tid()) {\n ticks_start_time = task_time;\n }\n }\n }\n // Forward the frame reader to the current event\n last_time = ticks_start_time + 1;\n while (true) {\n TraceFrame frame = tmp_reader.read_frame();\n if (frame.time() >= ticks_start_time) {\n break;\n }\n }\n } else if (target < session.current_trace_frame().ticks()) {\n // The target tick is entirely within the current frame.\n // If not handled here, the below loop might otherwise skip over\n // it if the next frame is for another tid.\n return last_time;\n }\n \n while (true) {\n if (tmp_reader.at_end()) {\n return -1;\n }\n TraceFrame frame = tmp_reader.read_frame();\n if (frame.tid() == task->tuid().tid() && target < frame.ticks()) {\n break;\n }\n last_time = frame.time() + 1;\n }\n return last_time;\n}\n\nvoid GdbServer::restart_session(const GdbRequest& req) {\n DEBUG_ASSERT(req.type == DREQ_RESTART);\n DEBUG_ASSERT(dbg);\n\n failed_restart = false;\n in_debuggee_end_state = false;\n if (!timeline_) {\n failed_restart = true;\n dbg->notify_restart_failed();\n return;\n }\n\n timeline_->remove_breakpoints_and_watchpoints();\n\n Checkpoint checkpoint_to_restore;\n if (req.restart().type == RESTART_FROM_CHECKPOINT) {\n auto it = checkpoints.find(req.restart().param);\n if (it == checkpoints.end()) {\n cout << \"Checkpoint \" << req.restart().param_str << \" not found.\\n\";\n cout << \"Valid checkpoints:\";\n for (auto& c : checkpoints) {\n cout << \" \" << c.first;\n }\n cout << \"\\n\";\n failed_restart = true;\n dbg->notify_restart_failed();\n return;\n }\n checkpoint_to_restore = it->second;\n } else if (req.restart().type == RESTART_FROM_PREVIOUS) {\n checkpoint_to_restore = debugger_restart_checkpoint;\n } else if (req.restart().type == RESTART_FROM_TICKS) {\n Ticks ticks = req.restart().param;\n FrameTime time = compute_time_from_ticks(*timeline_, ticks);\n if (time == -1) {\n cout << \"No event found matching specified ticks target.\\n\";\n failed_restart = true;\n dbg->notify_restart_failed();\n return;\n }\n timeline_->seek_to_ticks(time, ticks);\n }\n\n interrupt_pending = true;\n\n if (checkpoint_to_restore.mark) {\n timeline_->seek_to_mark(checkpoint_to_restore.mark);\n last_query_task = last_continue_task =\n checkpoint_to_restore.last_continue_task;\n if (debugger_restart_checkpoint.is_explicit == Checkpoint::EXPLICIT) {\n timeline_->remove_explicit_checkpoint(debugger_restart_checkpoint.mark);\n }\n debugger_restart_checkpoint = checkpoint_to_restore;\n if (timeline_->can_add_checkpoint()) {\n timeline_->add_explicit_checkpoint();\n }\n return;\n }\n\n if (req.restart().type == RESTART_FROM_EVENT) {\n // Note that we don't reset the target pid; we intentionally keep targeting\n // the same process no matter what is running when we hit the event.\n target.event = req.restart().param;\n target.event = min(final_event - 1, target.event);\n timeline_->seek_to_before_event(target.event);\n ReplayResult result;\n do {\n result = timeline_->replay_step_forward(RUN_CONTINUE);\n // We should never reach the end of the trace without hitting the stop\n // condition below.\n DEBUG_ASSERT(result.status != REPLAY_EXITED);\n if (is_last_thread_exit(result.break_status) &&\n result.break_status.task_context.thread_group->tgid == target.pid) {\n // Debuggee task is about to exit. Stop here.\n in_debuggee_end_state = true;\n break;\n }\n } while (!at_target(*timeline_, target, stop_replaying_to_target, result));\n }\n activate_debugger();\n}\n\nvoid GdbServer::serve_replay(std::shared_ptr session,\n const Target& target,\n volatile bool* stop_replaying_to_target,\n DebuggerType debugger_type,\n const ConnectionFlags& flags) {\n ReplayTimeline timeline(std::move(session));\n\n ReplayResult result;\n do {\n result = timeline.replay_step_forward(RUN_CONTINUE);\n if (result.status == REPLAY_EXITED) {\n LOG(info) << \"Debugger was not launched before end of trace\";\n return;\n }\n } while (!at_target(timeline, target, stop_replaying_to_target, result));\n\n unsigned short port = flags.dbg_port > 0 ? flags.dbg_port : getpid();\n // Don't probe if the user specified a port. Explicitly\n // selecting a port is usually done by scripts, which would\n // presumably break if a different port were to be selected by\n // rr (otherwise why would they specify a port in the first\n // place). So fail with a clearer error message.\n auto probe = flags.dbg_port > 0 ? DONT_PROBE : PROBE_PORT;\n Task* t = timeline.current_session().current_task();\n OpenedSocket listen_socket = open_socket(flags.dbg_host, port, probe);\n if (flags.debugger_params_write_pipe) {\n DebuggerParams params;\n memset(¶ms, 0, sizeof(params));\n strncpy(params.exe_image, t->vm()->exe_image().c_str(),\n sizeof(params.exe_image) - 1);\n params.socket_domain = listen_socket.domain;\n strncpy(params.host, listen_socket.host.c_str(), sizeof(params.host) - 1);\n params.port = listen_socket.port;\n\n ssize_t nwritten =\n write(*flags.debugger_params_write_pipe, ¶ms, sizeof(params));\n DEBUG_ASSERT(nwritten == sizeof(params));\n } else {\n vector cmd = debugger_launch_command(t, listen_socket.domain,\n listen_socket.host, listen_socket.port, flags.serve_files,\n flags.debugger_name, debugger_type);\n fprintf(stderr, \"Launch debugger with\\n %s\\n\", to_shell_string(cmd).c_str());\n }\n\n if (flags.debugger_params_write_pipe) {\n flags.debugger_params_write_pipe->close();\n }\n\n FrameTime first_run_event = std::max(t->vm()->first_run_event(),\n t->thread_group()->first_run_event());\n if (first_run_event) {\n timeline.set_reverse_execution_barrier_event(first_run_event);\n }\n\n do {\n LOG(debug) << \"initializing debugger connection\";\n auto connection = GdbServerConnection::await_connection(t, listen_socket.fd,\n debugger_type);\n\n GdbServer server(connection, timeline.current_session().current_task(),\n &timeline, target);\n server.activate_debugger();\n\n GdbRequest last_resume_request;\n while (server.debug_one_step(last_resume_request) == CONTINUE_DEBUGGING) {\n }\n\n timeline.remove_breakpoints_and_watchpoints();\n } while (flags.keep_listening);\n\n LOG(debug) << \"debugger server exiting ...\";\n}\n\nstatic ScopedFd generate_fake_proc_maps(Task* t) {\n TempFile file = create_temporary_file(\"rr-fake-proc-maps-XXXXXX\");\n unlink(file.name.c_str());\n\n int fd = dup(file.fd);\n if (fd < 0) {\n FATAL() << \"Cannot dup\";\n }\n FILE* f = fdopen(fd, \"w\");\n\n\n int addr_min_width = word_size(t->arch()) == 8 ? 10 : 8;\n for (AddressSpace::Maps::iterator it = t->vm()->maps().begin();\n it != t->vm()->maps().end(); ++it) {\n // If this is the mapping just before the rr page and it's still librrpage,\n // merge this mapping with the subsequent one. We'd like gdb to treat\n // librrpage as the vdso, but it'll only do so if the entire vdso is one\n // mapping.\n auto m = *it;\n uintptr_t map_end = (long long)m.recorded_map.end().as_int();\n if (m.recorded_map.end() == t->vm()->rr_page_start()) {\n auto it2 = it;\n if (++it2 != t->vm()->maps().end()) {\n auto m2 = *it2;\n if (m2.flags & AddressSpace::Mapping::IS_RR_PAGE) {\n // Extend this mapping\n map_end += PRELOAD_LIBRARY_PAGE_SIZE;\n // Skip the rr page\n ++it;\n }\n }\n }\n\n int len =\n fprintf(f, \"%0*llx-%0*llx %s%s%s%s %08llx %02x:%02x %lld\",\n addr_min_width, (long long)m.recorded_map.start().as_int(),\n addr_min_width, (long long)map_end,\n (m.recorded_map.prot() & PROT_READ) ? \"r\" : \"-\",\n (m.recorded_map.prot() & PROT_WRITE) ? \"w\" : \"-\",\n (m.recorded_map.prot() & PROT_EXEC) ? \"x\" : \"-\",\n (m.recorded_map.flags() & MAP_SHARED) ? \"s\" : \"p\",\n (long long)m.recorded_map.file_offset_bytes(),\n major(m.recorded_map.device()), minor(m.recorded_map.device()),\n (long long)m.recorded_map.inode());\n while (len < 72) {\n fputc(' ', f);\n ++len;\n }\n fputc(' ', f);\n\n string name;\n const string& fsname = m.recorded_map.fsname();\n for (size_t i = 0; i < fsname.size(); ++i) {\n if (fsname[i] == '\\n') {\n name.append(\"\\\\012\");\n } else {\n name.push_back(fsname[i]);\n }\n }\n fputs(name.c_str(), f);\n fputc('\\n', f);\n }\n if (ferror(f) || fclose(f)) {\n FATAL() << \"Can't write\";\n }\n\n return std::move(file.fd);\n}\n\nstatic bool is_ld_mapping(string map_name) {\n char ld_start[] = \"ld-\";\n size_t matchpos = map_name.find_last_of('/');\n string fname = map_name.substr(matchpos == string::npos ? 0 : matchpos + 1);\n return memcmp(fname.c_str(), ld_start,\n sizeof(ld_start)-1) == 0;\n}\n\nstatic bool is_likely_interp(string fsname) {\n#ifdef __aarch64__\n return fsname == \"/lib/ld-linux-aarch64.so.1\";\n#else\n return fsname == \"/lib64/ld-linux-x86-64.so.2\" || fsname == \"/lib/ld-linux.so.2\";\n#endif\n}\n\n#ifndef __BIONIC__\nstatic remote_ptr base_addr_from_rendezvous(Task* t, string fname)\n{\n remote_ptr interpreter_base = t->vm()->saved_interpreter_base();\n if (!interpreter_base || !t->vm()->has_mapping(interpreter_base)) {\n return nullptr;\n }\n string ld_path = t->vm()->saved_ld_path();\n if (ld_path.length() == 0) {\n FATAL() << \"Failed to retrieve interpreter name with interpreter_base=\" << interpreter_base;\n }\n ScopedFd ld(ld_path.c_str(), O_RDONLY);\n if (ld < 0) {\n FATAL() << \"Open failed: \" << ld_path;\n }\n ElfFileReader reader(ld);\n auto syms = reader.read_symbols(\".dynsym\", \".dynstr\");\n static const char r_debug[] = \"_r_debug\";\n bool found = false;\n uintptr_t r_debug_offset = 0;\n for (size_t i = 0; i < syms.size(); ++i) {\n if (!syms.is_name(i, r_debug)) {\n continue;\n }\n r_debug_offset = syms.addr(i);\n found = true;\n }\n if (!found) {\n return nullptr;\n }\n bool ok = true;\n remote_ptr r_debug_remote = interpreter_base.as_int()+r_debug_offset;\n remote_ptr link_map = t->read_mem(REMOTE_PTR_FIELD(r_debug_remote, r_map), &ok);\n while (ok && link_map != nullptr) {\n if (fname == t->read_c_str(t->read_mem(REMOTE_PTR_FIELD(link_map, l_name), &ok), &ok)) {\n remote_ptr result = t->read_mem(REMOTE_PTR_FIELD(link_map, l_addr), &ok);\n return ok ? result : nullptr;\n }\n link_map = t->read_mem(REMOTE_PTR_FIELD(link_map, l_next), &ok);\n }\n return nullptr;\n}\n#endif\n\nint GdbServer::open_file(Session& session, Task* continue_task, const std::string& file_name) {\n // XXX should we require file_scope_pid == 0 here?\n ScopedFd contents;\n\n if (file_name.empty()) {\n return -1;\n }\n\n LOG(debug) << \"Trying to open \" << file_name;\n\n if (file_name.substr(0, 6) == \"/proc/\") {\n char* tid_end;\n long tid = strtol(file_name.c_str() + 6, &tid_end, 10);\n if (*tid_end != '/') {\n return -1;\n }\n if (!strncmp(tid_end, \"/task/\", 6)) {\n tid = strtol(tid_end + 6, &tid_end, 10);\n if (*tid_end != '/') {\n return -1;\n }\n }\n if (tid != (pid_t)tid) {\n return -1;\n }\n Task* t = session.find_task(tid);\n if (!t) {\n return -1;\n }\n if (!strcmp(tid_end, \"/maps\")) {\n contents = generate_fake_proc_maps(t);\n } else {\n return -1;\n }\n } else if (file_name == continue_task->vm()->interp_name()) {\n remote_ptr interp_base = continue_task->vm()->interp_base();\n auto m = continue_task->vm()->mapping_of(interp_base);\n LOG(debug) << \"Found dynamic linker as memory mapping \" << m.recorded_map;\n int ret_fd = 0;\n while (files.find(ret_fd) != files.end() ||\n memory_files.find(ret_fd) != memory_files.end()) {\n ++ret_fd;\n }\n memory_files.insert(make_pair(ret_fd, FileId(m.recorded_map)));\n return ret_fd;\n } else {\n // See if we can find the file by serving one of our mappings\n std::string normalized_file_name = file_name;\n normalize_file_name(normalized_file_name);\n for (const auto& m : continue_task->vm()->maps()) {\n // The dynamic linker is generally a symlink that is resolved by the\n // kernel when the process image gets loaded. We add a special case to\n // substitute the correct mapping, so gdb can find the dynamic linker\n // rendezvous structures.\n // Use our old hack for ld from before we read PT_INTERP for backwards\n // compat with older traces.\n if (m.recorded_map.fsname().compare(0, normalized_file_name.length(), normalized_file_name) == 0\n || m.map.fsname().compare(0, normalized_file_name.length(), normalized_file_name) == 0\n || (is_ld_mapping(m.recorded_map.fsname()) &&\n is_likely_interp(normalized_file_name)))\n {\n int ret_fd = 0;\n while (files.find(ret_fd) != files.end() ||\n memory_files.find(ret_fd) != memory_files.end()) {\n ++ret_fd;\n }\n LOG(debug) << \"Found as memory mapping \" << m.recorded_map;\n memory_files.insert(make_pair(ret_fd, FileId(m.recorded_map)));\n return ret_fd;\n }\n }\n // Last ditch attempt: Dig through the tracee's libc rendezvous struct to\n // see if we can find this file by a different name (e.g. if it was opened\n // via symlink)\n#ifndef __BIONIC__\n remote_ptr base = base_addr_from_rendezvous(continue_task, file_name);\n if (base != nullptr && continue_task->vm()->has_mapping(base)) {\n int ret_fd = 0;\n while (files.find(ret_fd) != files.end() ||\n memory_files.find(ret_fd) != memory_files.end()) {\n ++ret_fd;\n }\n memory_files.insert(make_pair(ret_fd, FileId(continue_task->vm()->mapping_of(base).recorded_map)));\n return ret_fd;\n }\n#endif\n LOG(debug) << \"... not found\";\n return -1;\n }\n\n int ret_fd = 0;\n while (files.find(ret_fd) != files.end()) {\n ++ret_fd;\n }\n files.insert(make_pair(ret_fd, std::move(contents)));\n return ret_fd;\n}\n\nstatic void remove_trailing_guard_pages(ReplaySession::MemoryRanges& ranges) {\n remote_ptr ptr;\n while (true) {\n auto it = ranges.lower_bound(MemoryRange(ptr, 1));\n if (it == ranges.end()) {\n return;\n }\n MemoryRange r = *it;\n ranges.erase(it);\n remote_ptr end = floor_page_size(r.end() - 1);\n if (end > r.start()) {\n ranges.insert(MemoryRange(r.start(), end));\n }\n ptr = end;\n }\n}\n\nremote_ptr GdbServer::allocate_debugger_mem(ThreadGroupUid tguid, size_t size,\n int prot) {\n if (!timeline_) {\n return nullptr;\n }\n\n auto it = debugger_mem.find(tguid);\n if (it == debugger_mem.end()) {\n it = debugger_mem.insert(make_pair(tguid, DebuggerMem())).first;\n it->second.free_memory = timeline_->current_session().\n always_free_address_space(ReplaySession::FAST);\n remove_trailing_guard_pages(it->second.free_memory);\n it->second.did_get_accurate_free_memory = false;\n }\n DebuggerMem& dbg_mem = it->second;\n\n if (size >= (1 << 30)) {\n return nullptr;\n }\n size = ceil_page_size(size);\n while (true) {\n for (auto it = dbg_mem.free_memory.begin();\n it != dbg_mem.free_memory.end(); ++it) {\n if (it->size() >= size + page_size()) {\n MemoryRange r = *it;\n dbg_mem.free_memory.erase(it);\n // Skip guard page\n remote_ptr result = r.start() + page_size();\n if (r.end() > result + size) {\n dbg_mem.free_memory.insert(MemoryRange(result + size, r.end()));\n }\n DebuggerMemRegion& region =\n dbg_mem.regions[MemoryRange(result, size)];\n region.values.resize(size, 0);\n region.prot = prot;\n return result;\n }\n }\n\n if (dbg_mem.did_get_accurate_free_memory) {\n LOG(warn) << \"Can't allocate free memory for debugger\";\n return nullptr;\n }\n dbg_mem.did_get_accurate_free_memory = true;\n dbg_mem.free_memory = timeline_->current_session().\n always_free_address_space(ReplaySession::ACCURATE);\n for (const auto& kv : dbg_mem.regions) {\n ReplaySession::delete_range(dbg_mem.free_memory,\n MemoryRange(kv.first.start() - page_size(),\n kv.second.values.size() + page_size()));\n }\n }\n}\n\nstatic void coalesce_free_memory(ReplaySession::MemoryRanges& ranges,\n remote_ptr addr) {\n if (addr.is_null()) {\n return;\n }\n auto before = ranges.find(MemoryRange(addr - 1, 1));\n if (before == ranges.end() || before->end() != addr) {\n return;\n }\n MemoryRange before_range = *before;\n ranges.erase(before);\n\n auto after = ranges.find(MemoryRange(addr, 1));\n if (after == ranges.end()) {\n return;\n }\n MemoryRange after_range = *after;\n ranges.erase(after);\n\n ranges.insert(MemoryRange(before_range.start(), after_range.end()));\n}\n\nsize_t GdbServer::free_debugger_mem(ThreadGroupUid tguid, remote_ptr addr) {\n auto it = debugger_mem.find(tguid);\n if (it == debugger_mem.end()) {\n return 0;\n }\n DebuggerMem& dbg_mem = it->second;\n auto region_it = dbg_mem.regions.find(MemoryRange(addr, 1));\n if (region_it == dbg_mem.regions.end() || region_it->first.start() != addr) {\n return 0;\n }\n\n size_t ret = region_it->first.size();\n MemoryRange freed(addr - page_size(), region_it->first.end());\n dbg_mem.free_memory.insert(freed);\n coalesce_free_memory(dbg_mem.free_memory, freed.start());\n coalesce_free_memory(dbg_mem.free_memory, freed.end());\n\n dbg_mem.regions.erase(region_it);\n return ret;\n}\n\nbool GdbServer::read_debugger_mem(ThreadGroupUid tguid, MemoryRange range,\n uint8_t* values) {\n auto it = debugger_mem.find(tguid);\n if (it == debugger_mem.end()) {\n return false;\n }\n DebuggerMem& dbg_mem = it->second;\n auto region_it = dbg_mem.regions.lower_bound(range);\n if (region_it == dbg_mem.regions.end() || range.end() <= region_it->first.start()) {\n return false;\n }\n if (!region_it->first.contains(range)) {\n FATAL() << \"Debugger read beyond bounds of region, no idea what's going on\";\n }\n size_t offset = range.start() - region_it->first.start();\n memcpy(values, region_it->second.values.data() + offset, range.size());\n return true;\n}\n\nbool GdbServer::write_debugger_mem(ThreadGroupUid tguid, MemoryRange range,\n const uint8_t* values) {\n auto it = debugger_mem.find(tguid);\n if (it == debugger_mem.end()) {\n return false;\n }\n DebuggerMem& dbg_mem = it->second;\n auto region_it = dbg_mem.regions.lower_bound(range);\n if (region_it == dbg_mem.regions.end() || range.end() <= region_it->first.start()) {\n return false;\n }\n if (!region_it->first.contains(range)) {\n FATAL() << \"Debugger write beyond bounds of region, no idea what's going on\";\n }\n size_t offset = range.start() - region_it->first.start();\n memcpy(region_it->second.values.data() + offset, values, range.size());\n return true;\n}\n\nvoid GdbServer::map_debugger_mem(DiversionSession& session,\n ThreadGroupUid tguid, remote_ptr addr) {\n for (const auto& dbg_mem : debugger_mem) {\n if (!addr.is_null() && tguid != dbg_mem.first) {\n continue;\n }\n ThreadGroup* tg = session.find_thread_group(dbg_mem.first);\n if (!tg || tg->task_set().empty()) {\n // Threadgroup doesn't exist or is somehow empty at this point in time\n continue;\n }\n\n Task* t = *tg->task_set().begin();\n AddressSpace::shr_ptr vm = (*tg->task_set().begin())->vm();\n AutoRemoteSyscalls remote(t);\n for (const auto& region : dbg_mem.second.regions) {\n remote_ptr start = region.first.start();\n if (!addr.is_null() && addr != start) {\n continue;\n }\n size_t size = region.second.values.size();\n // Mask debugger-provided prot bits here just in case someone\n // tries to do something silly/dangerous/malicious.\n int prot = region.second.prot & (PROT_READ | PROT_WRITE | PROT_EXEC);\n int flags = MAP_PRIVATE | MAP_ANONYMOUS;\n remote.infallible_mmap_syscall_if_alive(start, size, prot, flags, -1, 0);\n vm->map(t, start, size, prot, flags, 0, \"\");\n t->write_bytes_helper(start, size, region.second.values.data());\n }\n }\n}\n\nvoid GdbServer::unmap_debugger_mem(DiversionSession& session,\n ThreadGroupUid tguid, remote_ptr addr,\n size_t size) {\n ThreadGroup* tg = session.find_thread_group(tguid);\n if (!tg || tg->task_set().empty()) {\n // Threadgroup doesn't exist or is somehow empty at this point in time\n return;\n }\n\n Task* t = *tg->task_set().begin();\n AddressSpace::shr_ptr vm = (*tg->task_set().begin())->vm();\n AutoRemoteSyscalls remote(t);\n remote.infallible_munmap_syscall_if_alive(addr, size);\n vm->unmap(t, addr, size);\n}\n\nvoid GdbServer::read_back_debugger_mem(DiversionSession& session) {\n for (auto& dbg_mem : debugger_mem) {\n ThreadGroup* tg = session.find_thread_group(dbg_mem.first);\n if (!tg || tg->task_set().empty()) {\n // Threadgroup doesn't exist or is somehow empty at this point in time\n continue;\n }\n\n Task* t = *tg->task_set().begin();\n AddressSpace::shr_ptr vm = (*tg->task_set().begin())->vm();\n for (auto& region : dbg_mem.second.regions) {\n remote_ptr start = region.first.start();\n size_t size = region.second.values.size();\n t->read_bytes_helper(start, size, region.second.values.data());\n }\n }\n}\n\nconst vector& GdbServer::target_registers(\n SupportedArch arch) {\n if (!register_description.empty()) {\n return register_description;\n }\n\n const auto add_range = [&](GdbServerRegister start, GdbServerRegister end_inclusive) {\n for (auto reg = start; reg <= end_inclusive; reg = GdbServerRegister(reg + 1)) {\n register_description.push_back(reg);\n }\n };\n\n bool have_PKU = dbg->cpu_features() & GdbServerConnection::CPU_PKU;\n bool have_AVX = dbg->cpu_features() & GdbServerConnection::CPU_AVX;\n bool have_AVX512 = dbg->cpu_features() & GdbServerConnection::CPU_AVX512;\n switch (arch) {\n case x86: {\n add_range(GdbServerRegister(0), GdbServerRegister(DREG_ORIG_EAX));\n\n if (have_AVX) {\n add_range(GdbServerRegister::DREG_YMM0H,\n GdbServerRegister(DREG_YMM7H));\n }\n\n if (have_AVX512) {\n add_range(GdbServerRegister::DREG_ZMM0H,\n GdbServerRegister(DREG_K7));\n }\n\n if (have_PKU) {\n register_description.push_back(DREG_PKRU);\n }\n break;\n }\n case x86_64: {\n add_range(GdbServerRegister(0), GdbServerRegister(DREG_GS_BASE));\n if (have_AVX) {\n add_range(GdbServerRegister::DREG_64_YMM0H,\n GdbServerRegister(DREG_64_YMM15H));\n }\n if (have_AVX512) {\n add_range(GdbServerRegister::DREG_64_XMM16,\n GdbServerRegister(DREG_64_K7));\n }\n if (have_PKU) {\n register_description.push_back(DREG_64_PKRU);\n }\n break;\n }\n case aarch64:\n add_range(GdbServerRegister::DREG_X0,\n GdbServerRegister::DREG_NUM_LINUX_AARCH64);\n break;\n default:\n FATAL() << \"Unknown architecture\";\n }\n return register_description;\n}\n\nbool GdbServer::debugger_mem_region(ThreadGroupUid tguid, remote_ptr addr,\n int* prot, MemoryRange* mem_range) {\n auto it = debugger_mem.find(tguid);\n if (it == debugger_mem.end()) {\n return false;\n }\n DebuggerMem& dbg_mem = it->second;\n auto region_it = dbg_mem.regions.find(MemoryRange(addr, 1));\n if (region_it == dbg_mem.regions.end()) {\n return false;\n }\n *prot = region_it->second.prot;\n *mem_range = region_it->first;\n return true;\n}\n\n} // namespace rr\n" }, { "path": "src/GdbServer.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_SERVER_H_\n#define RR_GDB_SERVER_H_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"AddressSpace.h\"\n#include \"DiversionSession.h\"\n#include \"GdbServerConnection.h\"\n#include \"ReplaySession.h\"\n#include \"ReplayTimeline.h\"\n#include \"ScopedFd.h\"\n#ifdef PROC_SERVICE_H\n#include \"ThreadDb.h\"\n#endif\n#include \"TraceFrame.h\"\n\nnamespace rr {\n\nclass GdbServer {\n // Not ideal but we can't inherit friend from DebuggerExtensionCommand\n friend std::string invoke_checkpoint(GdbServer&, Task*,\n const std::vector&);\n friend std::string invoke_delete_checkpoint(GdbServer&, Task*,\n const std::vector&);\n friend std::string invoke_info_checkpoints(GdbServer&, Task*,\n const std::vector&);\n\npublic:\n struct Target {\n Target() : pid(0), require_exec(false), event(0) {}\n // Target process to debug, or 0 to just debug the first process\n pid_t pid;\n // If true, wait for the target process to exec() before attaching debugger\n bool require_exec;\n // Wait until at least 'event' has elapsed before attaching\n FrameTime event;\n };\n\n struct ConnectionFlags {\n // -1 to let GdbServer choose the port, a positive integer to select a\n // specific port to listen on. If keep_listening is on, wait for another\n // debugger connection after the first one is terminated.\n int dbg_port;\n std::string dbg_host;\n bool keep_listening;\n bool serve_files;\n // If non-null, then when the gdbserver is set up, we write its connection\n // parameters through this pipe. GdbServer::launch_gdb is passed the\n // other end of this pipe to exec gdb with the parameters.\n ScopedFd* debugger_params_write_pipe;\n // Name of the debugger to suggest. Only used if debugger_params_write_pipe\n // is null.\n std::string debugger_name;\n\n ConnectionFlags();\n };\n\n /**\n * Serve the replay of 'session'.\n * When `stop_replaying_to_target` is non-null, setting it to true\n * (e.g. in a signal handler) will interrupt the replay.\n * Returns only when the debugger disconnects.\n */\n static void serve_replay(std::shared_ptr session,\n const Target& target,\n volatile bool* stop_replaying_to_target,\n DebuggerType debugger_type,\n const ConnectionFlags& flags);\n\n /**\n * Return the register |which|, which may not have a defined value.\n */\n static GdbServerRegisterValue get_reg(const Registers& regs,\n const ExtraRegisters& extra_regs,\n GdbServerRegister which);\n\n // Null if this is an emergency debug session.\n ReplayTimeline* timeline() { return timeline_; }\n\n static void serve_emergency_debugger(\n std::unique_ptr dbg, Task* t) {\n GdbServer(dbg, t, nullptr, Target()).process_debugger_requests();\n }\n\nprivate:\n GdbServer(std::unique_ptr& connection, Task* t,\n ReplayTimeline* timeline, const Target& target);\n\n Session& current_session() {\n return timeline_ ? timeline_->current_session() :\n *emergency_debug_session;\n }\n ReplayTask* require_timeline_current_task();\n\n void dispatch_regs_request(const Registers& regs,\n const ExtraRegisters& extra_regs);\n enum ReportState { REPORT_NORMAL, REPORT_THREADS_DEAD };\n void maybe_intercept_mem_request(Task* target, const GdbRequest& req,\n std::vector* result);\n /**\n * Process the single debugger request |req| inside the session |session|.\n *\n * Callers should implement any special semantics they want for\n * particular debugger requests before calling this helper, to do\n * generic processing.\n */\n void dispatch_debugger_request(Session& session, const GdbRequest& req,\n ReportState state);\n void activate_debugger();\n void restart_session(const GdbRequest& req);\n GdbRequest process_debugger_requests(ReportState state = REPORT_NORMAL);\n enum ContinueOrStop { CONTINUE_DEBUGGING, STOP_DEBUGGING };\n bool detach_or_restart(const GdbRequest& req, ContinueOrStop* s);\n ContinueOrStop handle_exited_state(GdbRequest& last_resume_request);\n ContinueOrStop debug_one_step(GdbRequest& last_resume_request);\n /**\n * If 'req' is a reverse-singlestep, try to obtain the resulting state\n * directly from ReplayTimeline's mark database. If that succeeds,\n * report the singlestep break status to gdb and process any get-registers\n * requests. Repeat until we get a request that isn't reverse-singlestep\n * or get-registers, returning that request in 'req'.\n * During reverse-next commands, gdb tends to issue a series of\n * reverse-singlestep/get-registers pairs, and this makes those much\n * more efficient by avoiding having to actually reverse-singlestep the\n * session.\n */\n void try_lazy_reverse_singlesteps(GdbRequest& req);\n\n /**\n * Process debugger requests made in |diversion_session| until action needs\n * to be taken by the caller (a resume-execution request is received).\n * The received request is returned through |req|.\n * Returns true if diversion should continue, false if it should end.\n */\n bool diverter_process_debugger_requests(DiversionSession& diversion_session,\n uint32_t& diversion_refcount,\n GdbRequest* req);\n /**\n * Create a new diversion session using |replay| session as the\n * template. The |replay| session isn't mutated.\n *\n * Execution begins in the new diversion session under the control of\n * |dbg| starting with initial thread target |task|. The diversion\n * session ends at the request of |dbg|, and |divert| returns the first\n * request made that wasn't handled by the diversion session. That\n * is, the first request that should be handled by |replay| upon\n * resuming execution in that session.\n */\n GdbRequest divert(ReplaySession& replay);\n\n /**\n * If |break_status| indicates a stop that we should report to gdb,\n * report it. |req| is the resume request that generated the stop.\n */\n void maybe_notify_stop(const Session& session,\n const GdbRequest& req,\n const BreakStatus& break_status);\n\n void notify_stop_internal(const Session& session,\n ExtendedTaskId which, int sig,\n const std::string& reason = std::string());\n\n /**\n * Return the checkpoint stored as |checkpoint_id| or nullptr if there\n * isn't one.\n */\n ReplaySession::shr_ptr get_checkpoint(int checkpoint_id);\n\n /**\n * Handle GDB file open requests. If we can serve this read request, add\n * an entry to `files` with the file contents and return our internal\n * file descriptor.\n */\n int open_file(Session& session, Task *continue_task, const std::string& file_name);\n\n /**\n * Allocates debugger-owned memory region.\n * We pretend this memory exists in all sessions, but it actually only\n * exists in diversion sessions. When there is no diversion session,\n * we divert reads and writes to it to our internal storage.\n * During a diversion, the diversion session is the source of truth\n * and all reads and writes should go directly to the session.\n * If the diversion exits normally we update the memory values from\n * the diversion session, but if it crashes, we don't.\n */\n remote_ptr allocate_debugger_mem(ThreadGroupUid tguid,\n size_t size, int prot);\n /**\n * Frees a debugger-owned memory region. Returns 0\n * if there is no such region, otherwise returns the size\n * of the freed region.\n */\n size_t free_debugger_mem(ThreadGroupUid tguid, remote_ptr addr);\n // If the address is in debugger memory, return its size and prot and\n // return true.\n // Otherwise returns false.\n bool debugger_mem_region(ThreadGroupUid tguid, remote_ptr addr, int* prot,\n MemoryRange* mem_range);\n // Read from debugger memory. Returns false if the range is not in debugger memory.\n // Fatal error if the range partially overlaps debugger memory.\n // Don't call this if the session is a diversion, read from the diversion directly\n // since it has the values.\n bool read_debugger_mem(ThreadGroupUid tguid, MemoryRange range, uint8_t* values);\n // Write to debugger memory. Returns false if the range is not in debugger memory.\n // Fatal error if the range partially overlaps debugger memory.\n // Don't call this if the session is a diversion, write to the diversion directly\n // since it has the values.\n bool write_debugger_mem(ThreadGroupUid tguid, MemoryRange range, const uint8_t* values);\n // Add mappings of the debugger memory to the session.\n // If `addr` is null then all mappings are added, otherwise only mappings\n // at that address are added.\n void map_debugger_mem(DiversionSession& session, ThreadGroupUid tguid,\n remote_ptr addr);\n // Unmap mapping of a specific debugger memory region from the session.\n void unmap_debugger_mem(DiversionSession& session,\n ThreadGroupUid tguid, remote_ptr addr,\n size_t size);\n // Read back the contents of all debugger memory regions from the session.\n void read_back_debugger_mem(DiversionSession& session);\n\n // Get the last GdbServerRegister for \"this\" arch. If it hasn't be determined, configure it.\n const vector& target_registers(SupportedArch arch);\n\n // dbg is never null.\n std::unique_ptr dbg;\n // The ThreadGroupUid of the task being debugged.\n // This should really not be needed and should go away so we can debug\n // multiple processes.\n ThreadGroupUid debuggee_tguid;\n // What we were trying to reach.\n Target target;\n // ThreadDb for debuggee ThreadGroup\n#ifdef PROC_SERVICE_H\n std::unique_ptr thread_db;\n#endif\n // The last continued task.\n ExtendedTaskId last_continue_task;\n // The last queried task.\n ExtendedTaskId last_query_task;\n FrameTime final_event;\n // siginfo for last notified stop.\n siginfo_t stop_siginfo;\n bool in_debuggee_end_state;\n // True when a restart was attempted but didn't succeed.\n bool failed_restart;\n // Set to true when the user has interrupted replaying to a target event.\n volatile bool* stop_replaying_to_target;\n // True when a DREQ_INTERRUPT has been received but not handled, or when\n // we've restarted and want the first continue to be interrupted immediately.\n bool interrupt_pending;\n // True when a user has run to exit before attaching the debugger.\n bool exit_sigkill_pending;\n\n // Exactly one of the following two pointers is null.\n ReplayTimeline* timeline_;\n Session* emergency_debug_session;\n\n struct Checkpoint {\n enum Explicit { EXPLICIT, NOT_EXPLICIT };\n Checkpoint(ReplayTimeline& timeline, ExtendedTaskId last_continue_task, Explicit e,\n const std::string& where)\n : last_continue_task(last_continue_task), is_explicit(e), where(where) {\n if (e == EXPLICIT) {\n mark = timeline.add_explicit_checkpoint();\n } else {\n mark = timeline.mark();\n }\n }\n Checkpoint() : is_explicit(NOT_EXPLICIT) {}\n ReplayTimeline::Mark mark;\n ExtendedTaskId last_continue_task;\n Explicit is_explicit;\n std::string where;\n };\n // |debugger_restart_mark| is the point where we will restart from with\n // a no-op debugger \"run\" command.\n Checkpoint debugger_restart_checkpoint;\n\n // gdb checkpoints, indexed by ID\n std::map checkpoints;\n\n // Set of symbols to look up, for qSymbol.\n std::set symbols;\n // Iterator into |symbols|.\n std::set::iterator symbols_iter;\n\n // Contents of opened files. Maps our internal file descriptor to a real\n // file descriptor. Exposing our real file descriptor values is probably a\n // bad idea.\n std::map files;\n std::map memory_files;\n // The pid for gdb's last vFile:setfs\n pid_t file_scope_pid;\n\n // LLDB wants to allocate memory in tracees. Instead of modifying tracee ReplaySessions,\n // we store the memory outside the session and copy it into DiversionSessions as needed.\n struct DebuggerMemRegion {\n std::vector values;\n int prot;\n };\n struct DebuggerMem {\n std::map regions;\n // Virtual memory ranges that are never used by any tracee, also excluding\n // memory used by debugger_mem and guard pages.\n ReplaySession::MemoryRanges free_memory;\n bool did_get_accurate_free_memory;\n };\n // Maps from tgid to the DebuggerMem.\n std::unordered_map debugger_mem;\n\n struct SavedRegisters {\n Registers regs;\n ExtraRegisters extra_regs;\n };\n std::unordered_map saved_register_states;\n\n vector register_description;\n};\n\n} // namespace rr\n\n#endif /* RR_GDB_SERVER_H_ */\n" }, { "path": "src/GdbServerConnection.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#define REVERSE_EXECUTION\n\n/**\n * Much of this implementation is based on the documentation at\n *\n * http://sourceware.org/gdb/onlinedocs/gdb/Packets.html\n * See also\n * https://github.com/llvm/llvm-project/blob/main/lldb/docs/lldb-gdb-remote.txt\n */\n\n#include \"GdbServerConnection.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"DebuggerExtensionCommandHandler.h\"\n#include \"ReplaySession.h\"\n#include \"ScopedFd.h\"\n#include \"TargetDescription.h\"\n#include \"core.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstatic const char INTERRUPT_CHAR = '\\x03';\n\n#define UNHANDLED_REQ() \\\n write_packet(\"\"); \\\n LOG(info)\n\nconst GdbThreadId GdbThreadId::ANY(0, 0);\nconst GdbThreadId GdbThreadId::ALL(-1, -1);\n\n#ifdef DEBUG\nstatic bool request_needs_immediate_response(const GdbRequest* req) {\n switch (req->type) {\n case DREQ_NONE:\n case DREQ_CONT:\n return false;\n default:\n return true;\n }\n}\n#endif\n\nGdbServerConnection::GdbServerConnection(ThreadGroupUid tguid,\n DebuggerType debugger_type, const Features& features)\n : tguid(tguid),\n cpu_features_(0),\n debugger_type(debugger_type),\n no_ack(false),\n features_(features),\n connection_alive_(true),\n multiprocess_supported_(false),\n hwbreak_supported_(false),\n swbreak_supported_(false),\n list_threads_in_stop_reply_(false),\n target_description(nullptr) {\n#ifndef REVERSE_EXECUTION\n features_.reverse_execution = false;\n#endif\n}\n\nstatic uint32_t get_cpu_features(SupportedArch arch) {\n uint32_t cpu_features;\n switch (arch) {\n case x86:\n case x86_64: {\n cpu_features = arch == x86_64 ? GdbServerConnection::CPU_X86_64 : 0;\n unsigned int AVX_cpuid_flags = AVX_FEATURE_FLAG | OSXSAVE_FEATURE_FLAG;\n auto cpuid_data = cpuid(CPUID_GETEXTENDEDFEATURES, 0);\n if ((cpuid_data.ecx & PKU_FEATURE_FLAG) == PKU_FEATURE_FLAG) {\n // PKU (Skylake) implies AVX (Sandy Bridge).\n cpu_features |= GdbServerConnection::CPU_PKU;\n }\n\n if ((cpuid_data.ebx & AVX_512_FOUNDATION_FLAG) == AVX_512_FOUNDATION_FLAG) {\n cpu_features |= GdbServerConnection::CPU_AVX512 | GdbServerConnection::CPU_AVX;\n break;\n }\n\n cpuid_data = cpuid(CPUID_GETFEATURES, 0);\n // We're assuming here that AVX support on the system making the recording\n // is the same as the AVX support during replay. But if that's not true,\n // rr is totally broken anyway.\n if ((cpuid_data.ecx & AVX_cpuid_flags) == AVX_cpuid_flags) {\n cpu_features |= GdbServerConnection::CPU_AVX;\n }\n break;\n }\n case aarch64:\n cpu_features = GdbServerConnection::CPU_AARCH64;\n break;\n default:\n FATAL() << \"Unknown architecture\";\n return 0;\n }\n\n LOG(debug) << \"cpu features \" << std::hex << cpu_features;\n\n return cpu_features;\n}\n\nunique_ptr GdbServerConnection::await_connection(\n Task* t, ScopedFd& listen_fd, DebuggerType debugger_type,\n const GdbServerConnection::Features& features) {\n auto dbg = unique_ptr(\n new GdbServerConnection(t->thread_group()->tguid(), debugger_type, features));\n dbg->set_cpu_features(t->arch());\n dbg->await_debugger(listen_fd);\n return dbg;\n}\n\nvoid GdbServerConnection::await_debugger(ScopedFd& listen_fd) {\n sock_fd = ScopedFd(accept(listen_fd, nullptr, nullptr));\n // We might restart this debugging session, so don't set the\n // socket fd CLOEXEC.\n}\n\n/**\n * Poll for data to or from gdb, waiting |timeoutMs|. 0 means \"don't\n * wait\", and -1 means \"wait forever\". Return true if data is ready.\n */\nstatic bool poll_socket(const ScopedFd& sock_fd, short events, int timeoutMs) {\n struct pollfd pfd;\n memset(&pfd, 0, sizeof(pfd));\n pfd.fd = sock_fd;\n pfd.events = events;\n\n int ret = poll(&pfd, 1, timeoutMs);\n if (ret < 0 && errno != EINTR) {\n LOG(info) << \"debugger socket has been closed\";\n }\n return ret > 0;\n}\n\nstatic bool poll_incoming(const ScopedFd& sock_fd, int timeoutMs) {\n return poll_socket(sock_fd, POLLIN /* TODO: |POLLERR */, timeoutMs);\n}\n\nstatic void poll_outgoing(const ScopedFd& sock_fd, int timeoutMs) {\n poll_socket(sock_fd, POLLOUT /* TODO: |POLLERR */, timeoutMs);\n}\n\n/**\n * read() incoming data exactly one time, successfully. May block.\n */\nvoid GdbServerConnection::read_data_once() {\n ssize_t nread;\n /* Wait until there's data, instead of busy-looping on\n * EAGAIN. */\n poll_incoming(sock_fd, -1 /* wait forever */);\n uint8_t buf[4096];\n nread = read(sock_fd, buf, sizeof(buf));\n if (nread <= 0) {\n LOG(info) << \"Could not read data from debugger socket, \"\n \"marking connection as closed\";\n connection_alive_ = false;\n } else {\n inbuf.insert(inbuf.end(), buf, buf + nread);\n }\n}\n\nvoid GdbServerConnection::write_flush() {\n size_t write_index = 0;\n\n outbuf.push_back(0);\n LOG(debug) << \"write_flush: '\" << outbuf.data() << \"'\";\n outbuf.pop_back();\n\n while (write_index < outbuf.size()) {\n ssize_t nwritten;\n\n poll_outgoing(sock_fd, -1 /*wait forever*/);\n nwritten = write(sock_fd, outbuf.data() + write_index,\n outbuf.size() - write_index);\n if (nwritten < 0) {\n LOG(info) << \"Could not write data to debugger socket, \"\n \"marking connection as closed\";\n connection_alive_ = false;\n outbuf.clear();\n return;\n } else {\n write_index += nwritten;\n }\n }\n outbuf.clear();\n}\n\nvoid GdbServerConnection::write_data_raw(const uint8_t* data, ssize_t len) {\n outbuf.insert(outbuf.end(), data, data + len);\n}\n\nvoid GdbServerConnection::write_hex(unsigned long hex) {\n char buf[32];\n size_t len;\n\n len = snprintf(buf, sizeof(buf) - 1, \"%02lx\", hex);\n write_data_raw((uint8_t*)buf, len);\n}\n\nvoid GdbServerConnection::write_packet_bytes(const uint8_t* data, size_t num_bytes) {\n uint8_t checksum;\n size_t i;\n\n write_data_raw((uint8_t*)\"$\", 1);\n for (i = 0, checksum = 0; i < num_bytes; ++i) {\n checksum += data[i];\n }\n write_data_raw((uint8_t*)data, num_bytes);\n write_data_raw((uint8_t*)\"#\", 1);\n write_hex(checksum);\n}\n\nvoid GdbServerConnection::write_packet(const char* data) {\n return write_packet_bytes((const uint8_t*)data, strlen(data));\n}\n\nvoid GdbServerConnection::write_binary_packet(const char* pfx, const uint8_t* data,\n ssize_t num_bytes) {\n ssize_t pfx_num_chars = strlen(pfx);\n vector buf;\n buf.resize(2 * num_bytes + pfx_num_chars + 1);\n ssize_t buf_num_bytes = 0;\n int i;\n\n memcpy((char*)buf.data(), pfx, pfx_num_chars);\n buf_num_bytes += pfx_num_chars;\n\n for (i = 0; i < num_bytes; ++i) {\n uint8_t b = data[i];\n\n if (buf_num_bytes + 2 > ssize_t(buf.size())) {\n break;\n }\n switch (b) {\n case '#':\n case '$':\n case '}':\n case '*':\n buf.data()[buf_num_bytes++] = '}';\n buf.data()[buf_num_bytes++] = b ^ 0x20;\n break;\n default:\n buf.data()[buf_num_bytes++] = b;\n break;\n }\n }\n\n LOG(debug) << \" ***** NOTE: writing binary data, upcoming debug output may \"\n \"be truncated\";\n return write_packet_bytes(buf.data(), buf_num_bytes);\n}\n\nstatic string string_to_hex(const string& s) {\n stringstream sstr;\n for (char ch : s) {\n char buf[16];\n sprintf(buf, \"%02x\", ch);\n sstr << buf;\n }\n return sstr.str();\n}\n\nvoid GdbServerConnection::write_hex_bytes_packet(const char* prefix,\n const uint8_t* bytes, size_t len) {\n if (prefix[0] == '\\0' && 0 == len) {\n write_packet(\"\");\n return;\n }\n\n ssize_t pfx_num_chars = strlen(prefix);\n vector buf;\n buf.resize(pfx_num_chars + 2 * len + 1);\n memcpy(buf.data(), prefix, pfx_num_chars);\n for (size_t i = 0; i < len; ++i) {\n unsigned long b = bytes[i];\n snprintf(&buf.data()[pfx_num_chars + 2 * i], 3, \"%02lx\", b);\n }\n write_packet(buf.data());\n}\n\nvoid GdbServerConnection::write_hex_bytes_packet(const uint8_t* bytes, size_t len) {\n write_hex_bytes_packet(\"\", bytes, len);\n}\n\nstatic void parser_assert(bool cond) {\n if (!cond) {\n fputs(\"Failed to parse debugger request\\n\", stderr);\n DEBUG_ASSERT(false);\n exit(2);\n }\n}\n\nstatic string decode_ascii_encoded_hex_str(const char* encoded) {\n ssize_t enc_len = strlen(encoded);\n parser_assert(enc_len % 2 == 0);\n string str;\n for (int i = 0; i < enc_len / 2; ++i) {\n char enc_byte[] = { encoded[2 * i], encoded[2 * i + 1], '\\0' };\n char* endp;\n int c = strtol(enc_byte, &endp, 16);\n parser_assert(c < 128);\n str += static_cast(c);\n }\n return str;\n}\n\nbool GdbServerConnection::skip_to_packet_start() {\n ssize_t end = -1;\n /* XXX we want memcspn() here ... */\n for (size_t i = 0; i < inbuf.size(); ++i) {\n if (inbuf[i] == '$' || inbuf[i] == INTERRUPT_CHAR) {\n end = i;\n break;\n }\n }\n\n if (end < 0) {\n /* Discard all read bytes, which we don't care\n * about. */\n inbuf.clear();\n return false;\n }\n /* Discard bytes up to start-of-packet. */\n inbuf.erase(inbuf.begin(), inbuf.begin() + end);\n\n parser_assert(1 <= inbuf.size());\n parser_assert('$' == inbuf[0] || INTERRUPT_CHAR == inbuf[0]);\n return true;\n}\n\nbool GdbServerConnection::sniff_packet() {\n if (skip_to_packet_start()) {\n /* We've already seen a (possibly partial) packet. */\n return true;\n }\n parser_assert(inbuf.empty());\n return poll_incoming(sock_fd, 0 /*don't wait*/);\n}\n\nvoid GdbServerConnection::read_packet() {\n /* Read and discard bytes until we see the start of a\n * packet.\n *\n * NB: we're ignoring \"+/-\" responses from gdb. There doesn't\n * seem to be any sane reason why we would send a damaged\n * packet to gdb over TCP, then see a \"-\" reply from gdb and\n * somehow magically fix our bug that led to the malformed\n * packet in the first place.\n */\n while (!skip_to_packet_start() && connection_alive_) {\n read_data_once();\n }\n\n if (!connection_alive_) {\n return;\n }\n\n if (inbuf[0] == INTERRUPT_CHAR) {\n /* Interrupts are kind of an ugly duckling in the gdb\n * protocol ... */\n packetend = 1;\n return;\n }\n\n /* Read until we see end-of-packet. */\n size_t checkedlen = 0;\n while (true) {\n uint8_t* p = (uint8_t*)memchr(inbuf.data() + checkedlen, '#',\n inbuf.size() - checkedlen);\n if (p) {\n packetend = p - inbuf.data();\n break;\n }\n checkedlen = inbuf.size();\n read_data_once();\n if (!connection_alive_) {\n return;\n }\n }\n\n /* NB: we're ignoring the gdb packet checksums here too. If\n * gdb is corrupted enough to garble a checksum over TCP, it's\n * not really clear why asking for the packet again might make\n * the bug go away. */\n parser_assert('$' == inbuf[0] && packetend < inbuf.size());\n\n /* Acknowledge receipt of the packet. */\n if (!no_ack) {\n write_data_raw((uint8_t*)\"+\", 1);\n write_flush();\n }\n}\n\nstatic void read_hex_data(const char* payload, const char* payload_end,\n vector& data) {\n data.clear();\n char buf[3] = { 0, 0, 0 };\n while (payload + 2 <= payload_end) {\n buf[0] = *payload++;\n buf[1] = *payload++;\n char* endp;\n int value = strtol(buf, &endp, 16);\n parser_assert(endp == buf + 2);\n data.push_back(value);\n }\n}\n\nstatic void read_binary_data(const uint8_t* payload, const uint8_t* payload_end,\n vector& data) {\n data.clear();\n while (payload < payload_end) {\n uint8_t b = *payload++;\n if ('}' == b) {\n parser_assert(payload < payload_end);\n b = 0x20 ^ *payload++;\n }\n data.push_back(b);\n }\n}\n\n/**\n * Parse and return a gdb thread-id from |str|. |endptr| points to\n * the character just after the last character in the thread-id. It\n * may be nullptr.\n */\nstatic GdbThreadId parse_threadid(const char* str, char** endptr) {\n GdbThreadId t;\n char* endp;\n bool multiprocess = false;\n\n if ('p' == *str) {\n multiprocess = true;\n ++str;\n }\n t.pid = strtol(str, &endp, 16);\n parser_assert(endp);\n\n /* terminators (single process, no PID or TID, depending on 'p' prefix) */ \n if (*endp == '\\0' || *endp == ';' || *endp == ',') {\n if (multiprocess) {\n t.tid = -1;\n } else {\n t.tid = t.pid;\n t.pid = -1;\n }\n /* multiprocess syntax \".\" */\n } else if (*endp == '.') {\n str = endp + 1;\n t.tid = strtol(str, &endp, 16);\n }\n\n parser_assert(*endp == '\\0' || *endp == ';' || *endp == ',');\n\n *endptr = endp;\n return t;\n}\n\nvoid GdbServerConnection::write_xfer_response(const void* data, size_t size,\n uint64_t offset, uint64_t len) {\n if (offset > size) {\n write_packet(\"E01\");\n return;\n }\n if (offset == size) {\n write_packet(\"l\");\n return;\n }\n if (offset + len < size) {\n write_binary_packet(\"m\", static_cast(data) + offset, len);\n return;\n }\n write_binary_packet(\"l\", static_cast(data) + offset,\n size - offset);\n}\n\nstatic string read_target_desc(const char* file_name) {\n#ifdef __BIONIC__\n const char* share_path = \"usr/share/rr/\";\n#else\n const char* share_path = \"share/rr/\";\n#endif\n string path = resource_path() + share_path + string(file_name);\n stringstream ss;\n FILE* f = fopen(path.c_str(), \"r\");\n if (f == NULL) {\n FATAL() << \"Failed to load target description file: \" << file_name;\n }\n while (true) {\n int ch = getc(f);\n if (ch == EOF) {\n break;\n }\n ss << (char)ch;\n }\n fclose(f);\n return ss.str();\n}\n\nbool GdbServerConnection::xfer(const char* name, char* args) {\n const char* mode = args;\n args = strchr(args, ':');\n parser_assert(args);\n *args++ = '\\0';\n\n if (strcmp(mode, \"read\") && strcmp(mode, \"write\")) {\n write_packet(\"\");\n return false;\n }\n\n const char* annex = args;\n args = strchr(args, ':');\n parser_assert(args);\n *args++ = '\\0';\n\n uint64_t offset = strtoul(args, &args, 16);\n\n uint64_t len = 0;\n if (!strcmp(mode, \"read\")) {\n parser_assert(',' == *args++);\n len = strtoul(args, &args, 16);\n parser_assert(!*args);\n } else {\n parser_assert(*args == ':');\n ++args;\n }\n\n LOG(debug) << \"debugger asks us to transfer \" << name << \" mode=\" << mode\n << \", annex=\" << annex << \", offset=\" << offset << \" len=\" << len;\n\n if (!strcmp(name, \"auxv\")) {\n if (strcmp(annex, \"\")) {\n write_packet(\"E00\");\n return false;\n }\n if (strcmp(mode, \"read\")) {\n write_packet(\"\");\n return false;\n }\n\n req = GdbRequest(DREQ_GET_AUXV);\n req.target = query_thread;\n // XXX handle offset/len here!\n return true;\n }\n\n if (!strcmp(name, \"exec-file\")) {\n if (strcmp(mode, \"read\")) {\n write_packet(\"\");\n return false;\n }\n\n req = GdbRequest(DREQ_GET_EXEC_FILE);\n req.target.pid = req.target.tid = strtoul(annex, nullptr, 16);\n // XXX handle offset/len here!\n return true;\n }\n\n if (!strcmp(name, \"siginfo\")) {\n if (strcmp(annex, \"\")) {\n write_packet(\"E00\");\n return false;\n }\n if (!strcmp(mode, \"read\")) {\n req = GdbRequest(DREQ_READ_SIGINFO);\n req.target = query_thread;\n req.mem().addr = offset;\n req.mem().len = len;\n return true;\n }\n\n req = GdbRequest(DREQ_WRITE_SIGINFO);\n req.target = query_thread;\n return true;\n }\n\n if (!strcmp(name, \"features\")) {\n if (strcmp(mode, \"read\")) {\n write_packet(\"\");\n return false;\n }\n\n const auto desc = strcmp(annex, \"\") && strcmp(annex, \"target.xml\") ? read_target_desc(annex) : target_description->to_xml();\n write_xfer_response(desc.c_str(), desc.size(), offset, len);\n return false;\n }\n\n write_packet(\"\");\n return false;\n}\n\n/**\n * Format |value| into |buf| in the manner gdb expects. |buf| must\n * point at a buffer with at least |1 + 2*DBG_MAX_REG_SIZE| bytes\n * available. Fewer bytes than that may be written, but |buf| is\n * guaranteed to be null-terminated.\n */\nstatic size_t print_reg_value(const GdbServerRegisterValue& reg, char* buf) {\n parser_assert(reg.size <= GdbServerRegisterValue::MAX_SIZE);\n if (reg.defined) {\n /* gdb wants the register value in native endianness.\n * reg.value read in native endianness is exactly that.\n */\n for (size_t i = 0; i < reg.size; ++i) {\n snprintf(&buf[2 * i], 3, \"%02lx\", (unsigned long)reg.value[i]);\n }\n } else {\n for (size_t i = 0; i < reg.size; ++i) {\n strcpy(&buf[2 * i], \"xx\");\n }\n }\n return reg.size * 2;\n}\n\n/**\n * Read the encoded register value in |strp| into |reg|. |strp| may\n * be mutated.\n */\nstatic void read_reg_value(char** strp, GdbServerRegisterValue* reg) {\n char* str = *strp;\n\n if ('x' == str[0]) {\n reg->defined = false;\n reg->size = 0;\n return;\n }\n\n reg->defined = true;\n reg->size = strlen(str) / 2;\n for (size_t i = 0; i < reg->size; ++i) {\n char tmp = str[2];\n str[2] = '\\0';\n\n reg->value[i] = strtoul(str, &str, 16);\n parser_assert('\\0' == *str);\n\n str[0] = tmp;\n }\n\n *strp = str;\n}\n\nbool GdbServerConnection::query(char* payload) {\n const char* name;\n char* args;\n\n args = strchr(payload, ':');\n if (args) {\n *args++ = 0;\n }\n name = payload;\n\n if (strstr(name, \"RRCmd\") == name) {\n LOG(debug) << \"debugger requests rr cmd: \" << name;\n req = GdbRequest(DREQ_RR_CMD);\n parser_assert(args && *args);\n char* endp = strchr(args, ':');\n parser_assert(endp);\n *endp = 0;\n req.rr_cmd_.name = string(args);\n args = endp + 1;\n req.rr_cmd_.target_tid = strtol(args, &endp, 10);\n if (*endp) {\n parser_assert(*endp == ':');\n args = endp + 1;\n while (args) {\n endp = strchr(args, ':');\n if (endp) {\n *endp++ = 0;\n }\n req.rr_cmd_.args.emplace_back(args);\n args = endp;\n }\n }\n return true;\n }\n if (!strcmp(name, \"C\")) {\n LOG(debug) << \"debugger requests current thread ID\";\n req = GdbRequest(DREQ_GET_CURRENT_THREAD);\n return true;\n }\n if (!strcmp(name, \"Attached\")) {\n LOG(debug) << \"debugger asks if this is a new or existing process\";\n /* Tell gdb this is an existing process; it might be\n * (see emergency_debug()). */\n write_packet(\"1\");\n return false;\n }\n if (!strcmp(name, \"fThreadInfo\")) {\n LOG(debug) << \"debugger asks for thread list\";\n req = GdbRequest(DREQ_GET_THREAD_LIST);\n return true;\n }\n if (!strcmp(name, \"sThreadInfo\")) {\n write_packet(\"l\"); /* \"end of list\" */\n return false;\n }\n if (!strcmp(name, \"GetTLSAddr\")) {\n LOG(debug) << \"debugger asks for TLS addr\";\n req = GdbRequest(DREQ_TLS);\n req.target = parse_threadid(args, &args);\n parser_assert(*args == ',');\n ++args;\n size_t offset = strtoul(args, &args, 16);\n parser_assert(*args == ',');\n ++args;\n remote_ptr load_module = strtoul(args, &args, 16);\n parser_assert(*args == '\\0');\n req.tls().offset = offset;\n req.tls().load_module = load_module;\n return true;\n }\n if (!strcmp(name, \"Offsets\")) {\n LOG(debug) << \"debugger asks for section offsets\";\n req = GdbRequest(DREQ_GET_OFFSETS);\n req.target = query_thread;\n return true;\n }\n if (!strcmp(name, \"Supported\")) {\n /* TODO process these */\n LOG(debug) << \"debugger supports \" << args;\n\n multiprocess_supported_ = strstr(args, \"multiprocess+\") != nullptr;\n hwbreak_supported_ = strstr(args, \"hwbreak+\") != nullptr;\n swbreak_supported_ = strstr(args, \"swbreak+\") != nullptr;\n\n stringstream supported;\n // Encourage gdb to use very large packets since we support any packet size\n supported << \"PacketSize=1048576\"\n \";QStartNoAckMode+\"\n \";qXfer:features:read+\"\n \";qXfer:auxv:read+\"\n \";qXfer:exec-file:read+\"\n \";qXfer:siginfo:read+\"\n \";qXfer:siginfo:write+\"\n \";multiprocess+\"\n \";hwbreak+\"\n \";swbreak+\"\n \";ConditionalBreakpoints+\"\n \";vContSupported+\"\n \";QPassSignals+\";\n if (features().reverse_execution) {\n supported << \";ReverseContinue+\"\n \";ReverseStep+\";\n }\n write_packet(supported.str().c_str());\n return false;\n }\n if (!strcmp(name, \"Symbol\")) {\n#ifdef PROC_SERVICE_H\n LOG(debug) << \"debugger is ready for symbol lookups\";\n const char* colon = strchr(args, ':');\n parser_assert(colon != nullptr);\n req = GdbRequest(DREQ_QSYMBOL);\n if (*args == ':') {\n req.sym().has_address = false;\n } else {\n req.sym().has_address = true;\n req.sym().address = strtoul(args, &args, 16);\n }\n parser_assert(*args == ':');\n ++args;\n req.sym().name = decode_ascii_encoded_hex_str(args);\n return true;\n#else\n LOG(debug) << \"debugger is ready for symbol lookups, but we don't support them\";\n write_packet(\"\");\n return false;\n#endif\n }\n if (strstr(name, \"ThreadExtraInfo\") == name) {\n // ThreadExtraInfo is a special snowflake that\n // delimits its args with ','.\n parser_assert(!args);\n args = payload;\n args = 1 + strchr(args, ',' /*sic*/);\n\n req = GdbRequest(DREQ_GET_THREAD_EXTRA_INFO);\n req.target = parse_threadid(args, &args);\n parser_assert('\\0' == *args);\n return true;\n }\n if (!strcmp(name, \"TStatus\")) {\n LOG(debug) << \"debugger asks for trace status\";\n /* XXX from the docs, it appears that we should reply\n * with \"T0\" here. But if we do, gdb keeps bothering\n * us with trace queries. So pretend we don't know\n * what it's talking about. */\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"Xfer\")) {\n name = args;\n args = strchr(args, ':');\n parser_assert(args);\n *args++ = '\\0';\n\n return xfer(name, args);\n }\n if (!strcmp(name, \"Search\")) {\n name = args;\n args = strchr(args, ':');\n if (args) {\n *args++ = '\\0';\n }\n if (!strcmp(name, \"memory\") && args) {\n req = GdbRequest(DREQ_SEARCH_MEM_BINARY);\n req.target = query_thread;\n req.mem().addr = strtoul(args, &args, 16);\n parser_assert(';' == *args++);\n req.mem().len = strtoull(args, &args, 16);\n parser_assert(';' == *args++);\n read_binary_data((const uint8_t*)args, inbuf.data() + packetend,\n req.mem().data);\n\n LOG(debug) << \"debugger searching memory (addr=\" << HEX(req.mem().addr)\n << \", len=\" << req.mem().len << \")\";\n return true;\n }\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"MemoryRegionInfo\") && args &&\n debugger_type == DebuggerType::LLDB) {\n req = GdbRequest(DREQ_MEM_INFO);\n req.target = query_thread;\n req.mem().addr = strtoul(args, &args, 16);\n parser_assert(!*args);\n req.mem().len = 1;\n LOG(debug) << \"debugger requesting mem info (addr=\"\n << HEX(req.mem().addr) << \")\";\n return true;\n }\n\n // Packets that we intentionally don't support\n\n if (!strcmp(name, \"P\")) {\n /* The docs say not to use this packet ... */\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"HostInfo\") && debugger_type == DebuggerType::LLDB) {\n // lldb-server sends a reply like\n // triple:7838365f36342d2d6c696e75782d676e75;ptrsize:8;distribution_id:6665646f7261;\n // watchpoint_exceptions_received:after;endian:little;os_version:6.6.13;\n // os_build:362e362e31332d3230302e666333392e7838365f3634;\n // os_kernel:233120534d5020505245454d50545f44594e414d494320536174204a616e2032302031383a30333a3238205554432032303234;\n // hostname:6c6f63616c686f73742e6c6f63616c646f6d61696e\n // So far there is no benefit for handling it AFAICT.\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"VAttachOrWaitSupported\") && debugger_type == DebuggerType::LLDB) {\n // We don't handle vAttach and variants.\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"ProcessInfo\") && debugger_type == DebuggerType::LLDB) {\n // lldb-server sends a reply like\n // pid:3663df;parent-pid:3663de;real-uid:3e8;real-gid:3e8;effective-uid:3e8;effective-gid:3e8;\n // triple:7838365f36342d2d6c696e75782d676e75;ostype:linux;endian:little;ptrsize:8\n // Currently we don't have the parent PID or uids, so we're\n // not going to handle this.\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"StructuredDataPlugins\") && debugger_type == DebuggerType::LLDB) {\n // This isn't documented and lldb-server doesn't support it\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"ShlibInfoAddr\") && debugger_type == DebuggerType::LLDB) {\n // This isn't documented and lldb-server doesn't seem to support it\n write_packet(\"\");\n return false;\n }\n\n UNHANDLED_REQ() << \"Unhandled debugger query: q\" << name;\n return false;\n}\n\n// LLDB QThreadSuffixSupported extension\nvoid GdbServerConnection::parse_thread_suffix_threadid(char* payload, GdbThreadId* out) {\n if (debugger_type != DebuggerType::LLDB) {\n return;\n }\n char* semicolon = strrchr(payload, ';');\n if (!semicolon) {\n return;\n }\n if (!semicolon[1]) {\n semicolon[0] = 0;\n semicolon = strrchr(payload, ';');\n if (!semicolon) {\n return;\n }\n }\n if (strncmp(semicolon + 1, \"thread:\", 7)) {\n return;\n }\n char* endptr;\n *out = parse_threadid(semicolon + 8, &endptr);\n *semicolon = 0;\n}\n\nbool GdbServerConnection::set_var(char* payload) {\n GdbThreadId target = query_thread;\n parse_thread_suffix_threadid(payload, &target);\n\n char* args = strchr(payload, ':');\n if (args) {\n *args++ = '\\0';\n }\n const char* name = payload;\n\n if (!strcmp(name, \"StartNoAckMode\")) {\n write_packet(\"OK\");\n no_ack = true;\n return false;\n }\n if (!strncmp(name, \"PassSignals\", sizeof(\"PassSignals\"))) {\n pass_signals.clear();\n while (*args != '\\0') {\n char *next = nullptr;\n int sig = std::strtol(args, &next, 16);\n parser_assert(next != nullptr);\n\n LOG(debug) << \"registered \" << sig << \" by QPassSignal\";\n pass_signals.insert(sig);\n\n args = next;\n if (*args == '\\0') {\n break;\n }\n\n parser_assert(*args == ';');\n args++;\n }\n\n write_packet(\"OK\");\n return false;\n }\n if (!strcmp(name, \"ListThreadsInStopReply\") &&\n debugger_type == DebuggerType::LLDB) {\n write_packet(\"OK\");\n list_threads_in_stop_reply_ = true;\n return false;\n }\n\n if (!strcmp(name, \"ThreadSuffixSupported\") &&\n debugger_type == DebuggerType::LLDB) {\n write_packet(\"OK\");\n return false;\n }\n if (!strcmp(name, \"EnableErrorStrings\") &&\n debugger_type == DebuggerType::LLDB) {\n // We don't support human-readable error strings.\n write_packet(\"\");\n return false;\n }\n if (!strcmp(name, \"SaveRegisterState\") &&\n debugger_type == DebuggerType::LLDB) {\n req = GdbRequest(DREQ_SAVE_REGISTER_STATE);\n req.target = target;\n return true;\n }\n if (!strcmp(name, \"RestoreRegisterState\") &&\n debugger_type == DebuggerType::LLDB) {\n req = GdbRequest(DREQ_RESTORE_REGISTER_STATE);\n req.target = target;\n char* end;\n req.restore_register_state().state_index = strtol(args, &end, 16);\n parser_assert(!*end || *end == ';');\n return true;\n }\n\n UNHANDLED_REQ() << \"Unhandled debugger set: Q\" << name;\n return false;\n}\n\nbool GdbServerConnection::process_underscore(char* payload) {\n char* args = payload + 1;\n\n switch (payload[0]) {\n case 'M': {\n if (debugger_type != DebuggerType::LLDB) {\n break;\n }\n char* end = nullptr;\n req = GdbRequest(DREQ_MEM_ALLOC);\n req.mem_alloc().size = strtol(args, &end, 16);\n parser_assert(*end == ',');\n int prot = 0;\n ++end;\n if (*end == 'r') {\n prot |= PROT_READ;\n ++end;\n }\n if (*end == 'w') {\n prot |= PROT_WRITE;\n ++end;\n }\n if (*end == 'x') {\n prot |= PROT_EXEC;\n }\n req.mem_alloc().prot = prot;\n return true;\n }\n case 'm': {\n if (debugger_type != DebuggerType::LLDB) {\n break;\n }\n char* end = nullptr;\n req = GdbRequest(DREQ_MEM_FREE);\n req.mem_free().address = strtol(args, &end, 16);\n parser_assert(!*end);\n return true;\n }\n default:\n break;\n }\n\n UNHANDLED_REQ() << \"Unhandled debugger request: _\" << payload;\n return false;\n}\n\nvoid GdbServerConnection::consume_request() {\n req = GdbRequest();\n write_flush();\n}\n\nbool GdbServerConnection::process_bpacket(char* payload) {\n if (strcmp(payload, \"c\") == 0) {\n req = GdbRequest(DREQ_CONT);\n req.cont().run_direction = RUN_BACKWARD;\n req.cont().actions.push_back(GdbContAction(ACTION_CONTINUE, resume_thread));\n return true;\n } else if (strcmp(payload, \"s\") == 0) {\n req = GdbRequest(DREQ_CONT);\n req.cont().run_direction = RUN_BACKWARD;\n req.cont().actions.push_back(GdbContAction(ACTION_STEP, resume_thread));\n return true;\n } else {\n UNHANDLED_REQ() << \"Unhandled debugger bpacket: b\" << payload;\n return false;\n }\n}\n\nstatic int gdb_open_flags_to_system_flags(int64_t flags) {\n int ret;\n switch (flags & 3) {\n case 0:\n ret = O_RDONLY;\n break;\n case 1:\n ret = O_WRONLY;\n break;\n case 2:\n ret = O_RDWR;\n break;\n default:\n parser_assert(false);\n return 0;\n }\n parser_assert(!(flags & ~int64_t(3 | 0x8 | 0x200 | 0x400 | 0x800)));\n if (flags & 0x8) {\n ret |= O_APPEND;\n }\n if (flags & 0x200) {\n ret |= O_CREAT;\n }\n if (flags & 0x400) {\n ret |= O_TRUNC;\n }\n if (flags & 0x800) {\n ret |= O_EXCL;\n }\n return ret;\n}\n\nbool GdbServerConnection::process_vpacket(char* payload) {\n const char* name;\n char* args;\n\n args = strchr(payload, ';');\n if (args) {\n *args++ = '\\0';\n }\n name = payload;\n\n if (!strcmp(\"Cont\", name)) {\n vector actions;\n bool has_default_action = false;\n GdbContAction default_action;\n\n while (args) {\n char* cmd = args;\n while (*args != ':' && *args != ';') {\n if (!*args) {\n args = nullptr;\n break;\n }\n ++args;\n }\n bool is_default = true;\n GdbThreadId target;\n if (args) {\n if (*args == ':') {\n is_default = false;\n *args = '\\0';\n target = parse_threadid(args + 1, &args);\n }\n args = strchr(args, ';');\n if (args) {\n *args = '\\0';\n ++args;\n }\n }\n\n GdbActionType action;\n int signal_to_deliver = 0;\n char* endptr = NULL;\n switch (cmd[0]) {\n case 'C':\n action = ACTION_CONTINUE;\n signal_to_deliver = strtol(cmd + 1, &endptr, 16);\n break;\n case 'c':\n action = ACTION_CONTINUE;\n break;\n case 'S':\n action = ACTION_STEP;\n signal_to_deliver = strtol(cmd + 1, &cmd, 16);\n break;\n case 's':\n action = ACTION_STEP;\n break;\n default:\n UNHANDLED_REQ() << \"Unhandled vCont command \" << cmd << \"(\" << args\n << \")\";\n return false;\n }\n if (endptr && *endptr) {\n UNHANDLED_REQ() << \"Unhandled vCont command parameters \" << cmd;\n return false;\n }\n if (is_default) {\n if (has_default_action) {\n UNHANDLED_REQ()\n << \"Unhandled vCont command with multiple default actions\";\n return false;\n }\n has_default_action = true;\n default_action =\n GdbContAction(action, GdbThreadId::ALL, signal_to_deliver);\n } else {\n actions.push_back(GdbContAction(action, target, signal_to_deliver));\n }\n }\n\n if (has_default_action) {\n actions.push_back(default_action);\n }\n req = GdbRequest(DREQ_CONT);\n req.cont().run_direction = RUN_FORWARD;\n req.cont().actions = std::move(actions);\n return true;\n }\n\n if (!strcmp(\"Cont?\", name)) {\n LOG(debug) << \"debugger queries which continue commands we support\";\n write_packet(\"vCont;c;C;s;S;\");\n return false;\n }\n\n if (!strcmp(\"Kill\", name)) {\n // We can't kill tracees or replay can diverge. We\n // assume that this kill request is being made because\n // a \"vRun\" restart is coming right up. We know how\n // to implement vRun, so we'll ignore this one.\n LOG(debug) << \"debugger asks us to kill tracee(s); ignoring\";\n write_packet(\"OK\");\n return false;\n }\n\n if (!strcmp(\"Run\", name)) {\n req = GdbRequest(DREQ_RESTART);\n\n const char* filename = args;\n args = strchr(args, ';');\n if (args) {\n *args++ = '\\0';\n }\n if (strlen(filename)) {\n FATAL() << \"debugger wants us to run the exe image `\" << filename\n << \"', but we don't support that.\";\n }\n if (!args) {\n req.restart().type = RESTART_FROM_PREVIOUS;\n return true;\n }\n const char* arg1 = args;\n args = strchr(args, ';');\n if (args) {\n *args++ = 0;\n LOG(debug) << \"Ignoring extra parameters \" << args;\n }\n string event_str = decode_ascii_encoded_hex_str(arg1);\n char* endp;\n if (event_str[0] == 'c') {\n int64_t param = strtoll(event_str.c_str() + 1, &endp, 0);\n req.restart().type = RESTART_FROM_CHECKPOINT;\n req.restart().param_str = event_str.substr(1);\n req.restart().param = param;\n LOG(debug) << \"next replayer restarting from checkpoint \"\n << param;\n } else if (event_str[0] == 't') {\n int64_t param = strtoll(event_str.c_str() + 1, &endp, 0);\n req.restart().type = RESTART_FROM_TICKS;\n req.restart().param_str = event_str.substr(1);\n req.restart().param = param;\n LOG(debug) << \"next replayer restarting from tick count \"\n << param;\n } else {\n req.restart().type = RESTART_FROM_EVENT;\n req.restart().param = strtoll(event_str.c_str(), &endp, 0);\n LOG(debug) << \"next replayer advancing to event \" << req.restart().param;\n }\n if (!endp || *endp != '\\0') {\n LOG(debug) << \"Couldn't parse event string `\" << event_str << \"'\"\n << \"; restarting from previous\";\n req.restart().type = RESTART_FROM_PREVIOUS;\n req.restart().param = -1;\n }\n return true;\n }\n\n if (name == strstr(name, \"File:\")) {\n char* operation = payload + 5;\n if (operation == strstr(operation, \"open:\")) {\n char* file_name_end = strchr(operation + 5, ',');\n parser_assert(file_name_end != nullptr);\n *file_name_end = 0;\n req = GdbRequest(DREQ_FILE_OPEN);\n req.file_open().file_name = decode_ascii_encoded_hex_str(operation + 5);\n char* flags_end;\n int64_t flags = strtol(file_name_end + 1, &flags_end, 16);\n parser_assert(*flags_end == ',');\n req.file_open().flags = gdb_open_flags_to_system_flags(flags);\n char* mode_end;\n int64_t mode = strtol(flags_end + 1, &mode_end, 16);\n parser_assert(*mode_end == 0);\n parser_assert((mode & ~(int64_t)0777) == 0);\n req.file_open().mode = mode;\n return true;\n } else if (operation == strstr(operation, \"close:\")) {\n char* endptr;\n int64_t fd = strtol(operation + 6, &endptr, 16);\n parser_assert(*endptr == 0);\n req = GdbRequest(DREQ_FILE_CLOSE);\n req.file_close().fd = fd;\n parser_assert(req.file_close().fd == fd);\n return true;\n } else if (operation == strstr(operation, \"pread:\")) {\n char* fd_end;\n int64_t fd = strtol(operation + 6, &fd_end, 16);\n parser_assert(*fd_end == ',');\n req = GdbRequest(DREQ_FILE_PREAD);\n req.file_pread().fd = fd;\n parser_assert(req.file_pread().fd == fd);\n char* size_end;\n int64_t size = strtol(fd_end + 1, &size_end, 16);\n parser_assert(*size_end == ',');\n parser_assert(size >= 0);\n req.file_pread().size = size;\n char* offset_end;\n int64_t offset = strtol(size_end + 1, &offset_end, 16);\n parser_assert(*offset_end == 0);\n parser_assert(offset >= 0);\n req.file_pread().offset = offset;\n return true;\n } else if (operation == strstr(operation, \"setfs:\")) {\n char* endptr;\n int64_t pid = strtol(operation + 6, &endptr, 16);\n parser_assert(*endptr == 0);\n req = GdbRequest(DREQ_FILE_SETFS);\n req.file_setfs().pid = pid;\n parser_assert(req.file_setfs().pid == pid);\n return true;\n } else {\n write_packet(\"\");\n return false;\n }\n }\n\n UNHANDLED_REQ() << \"Unhandled debugger vpacket: v\" << name;\n return false;\n}\n\nstatic string to_string(const vector& bytes, size_t max_len) {\n stringstream ss;\n for (size_t i = 0; i < bytes.size(); ++i) {\n if (i >= max_len) {\n ss << \"...\";\n break;\n }\n char buf[3];\n sprintf(buf, \"%02x\", bytes[i]);\n ss << buf;\n }\n return ss.str();\n}\n\nbool GdbServerConnection::process_packet() {\n parser_assert(\n INTERRUPT_CHAR == inbuf[0] ||\n ('$' == inbuf[0] && (uint8_t*)memchr(inbuf.data(), '#', inbuf.size()) ==\n inbuf.data() + packetend));\n\n if (INTERRUPT_CHAR == inbuf[0]) {\n LOG(debug) << \"debugger requests interrupt\";\n req = GdbRequest(DREQ_INTERRUPT);\n inbuf.erase(inbuf.begin());\n return true;\n }\n\n char request = inbuf[1];\n char* payload = (char*)&inbuf[2];\n inbuf[packetend] = '\\0';\n LOG(debug) << \"raw request \" << request << payload;\n\n bool ret;\n switch (request) {\n case 'b':\n ret = process_bpacket(payload);\n break;\n case 'c':\n LOG(debug) << \"debugger is asking to continue\";\n req = GdbRequest(DREQ_CONT);\n req.cont().run_direction = RUN_FORWARD;\n req.cont().actions.push_back(GdbContAction(ACTION_CONTINUE));\n ret = true;\n break;\n case 'D':\n LOG(debug) << \"debugger is detaching from us\";\n req = GdbRequest(DREQ_DETACH);\n ret = true;\n break;\n case 'g':\n req = GdbRequest(DREQ_GET_REGS);\n req.target = query_thread;\n parse_thread_suffix_threadid(payload, &req.target);\n LOG(debug) << \"debugger requests registers in thread \"\n << req.target;\n ret = true;\n break;\n case 'G':\n /* XXX we can't let gdb spray registers in general,\n * because it may cause replay to diverge. But some\n * writes may be OK. Let's see how far we can get\n * with ignoring these requests. */\n write_packet(\"\");\n ret = false;\n break;\n case 'H':\n if ('c' == *payload++) {\n req = GdbRequest(DREQ_SET_CONTINUE_THREAD);\n } else {\n req = GdbRequest(DREQ_SET_QUERY_THREAD);\n }\n req.target = parse_threadid(payload, &payload);\n parser_assert('\\0' == *payload);\n\n LOG(debug) << \"debugger selecting \" << req.target;\n\n ret = true;\n break;\n case 'j':\n // Prefer to avoid implementing any JSON-formatted-output\n // packets unless we have to\n write_packet(\"\");\n ret = false;\n break;\n case 'k':\n LOG(info) << \"debugger requests kill, exiting\";\n write_packet(\"OK\");\n exit(0);\n case 'm':\n req = GdbRequest(DREQ_GET_MEM);\n req.target = query_thread;\n req.mem().addr = strtoul(payload, &payload, 16);\n parser_assert(',' == *payload++);\n req.mem().len = strtoul(payload, &payload, 16);\n parser_assert('\\0' == *payload);\n\n LOG(debug) << \"debugger requests memory (addr=\" << HEX(req.mem().addr)\n << \", len=\" << req.mem().len << \")\";\n\n ret = true;\n break;\n case 'M':\n req = GdbRequest(DREQ_SET_MEM);\n req.target = query_thread;\n req.mem().addr = strtoul(payload, &payload, 16);\n parser_assert(',' == *payload++);\n req.mem().len = strtoul(payload, &payload, 16);\n parser_assert(':' == *payload++);\n read_hex_data(payload, reinterpret_cast(inbuf.data() + packetend),\n req.mem().data);\n parser_assert(req.mem().len == req.mem().data.size());\n\n LOG(debug) << \"debugger setting memory (addr=\" << HEX(req.mem().addr)\n << \", len=\" << req.mem().len\n << \", data=\" << to_string(req.mem().data, 32) << \")\";\n\n ret = true;\n break;\n case 'p':\n req = GdbRequest(DREQ_GET_REG);\n req.target = query_thread;\n parse_thread_suffix_threadid(payload, &req.target);\n req.reg().name = GdbServerRegister(strtoul(payload, &payload, 16));\n parser_assert('\\0' == *payload);\n LOG(debug) << \"debugger requests register value (\" << req.reg().name\n << \") in thread \" << req.target;\n ret = true;\n break;\n case 'P':\n req = GdbRequest(DREQ_SET_REG);\n req.target = query_thread;\n parse_thread_suffix_threadid(payload, &req.target);\n req.reg().name = GdbServerRegister(strtoul(payload, &payload, 16));\n parser_assert('=' == *payload++);\n\n read_reg_value(&payload, &req.reg());\n\n parser_assert('\\0' == *payload);\n LOG(debug) << \"debugger requests set register value (\" << req.reg().name\n << \") in thread \" << req.target;\n\n ret = true;\n break;\n case 'q':\n ret = query(payload);\n break;\n case 'Q':\n ret = set_var(payload);\n break;\n case 'T':\n req = GdbRequest(DREQ_GET_IS_THREAD_ALIVE);\n req.target = parse_threadid(payload, &payload);\n parser_assert('\\0' == *payload);\n LOG(debug) << \"debugger wants to know if \" << req.target << \" is alive\";\n ret = true;\n break;\n case 'v':\n ret = process_vpacket(payload);\n break;\n case 'x':\n req = GdbRequest(DREQ_GET_MEM_BINARY);\n req.target = query_thread;\n req.mem().addr = strtoul(payload, &payload, 16);\n parser_assert(',' == *payload++);\n req.mem().len = strtoul(payload, &payload, 16);\n parser_assert(!*payload);\n LOG(debug) << \"debugger requests binary memory (addr=\" << HEX(req.mem().addr)\n << \", len=\" << req.mem().len << \")\";\n ret = true;\n break;\n case 'X':\n req = GdbRequest(DREQ_SET_MEM_BINARY);\n req.target = query_thread;\n req.mem().addr = strtoul(payload, &payload, 16);\n parser_assert(',' == *payload++);\n req.mem().len = strtoul(payload, &payload, 16);\n parser_assert(':' == *payload++);\n read_binary_data((const uint8_t*)payload, inbuf.data() + packetend,\n req.mem().data);\n parser_assert(req.mem().len == req.mem().data.size());\n\n LOG(debug) << \"debugger setting memory (addr=\" << HEX(req.mem().addr)\n << \", len=\" << req.mem().len\n << \", data=\" << to_string(req.mem().data, 32) << \")\";\n\n ret = true;\n break;\n case 'z':\n case 'Z': {\n int type = strtol(payload, &payload, 16);\n parser_assert(',' == *payload++);\n if (!(0 <= type && type <= 4)) {\n LOG(warn) << \"Unknown watch type \" << type;\n write_packet(\"\");\n ret = false;\n break;\n }\n req = GdbRequest(GdbRequestType(\n type + (request == 'Z' ? DREQ_SET_SW_BREAK : DREQ_REMOVE_SW_BREAK)));\n req.watch().addr = strtoul(payload, &payload, 16);\n parser_assert(',' == *payload);\n payload++;\n req.watch().kind = strtoul(payload, &payload, 16);\n if (';' == *payload) {\n ++payload;\n while ('X' == *payload) {\n ++payload;\n int len = strtol(payload, &payload, 16);\n parser_assert(',' == *payload);\n payload++;\n vector bytes;\n for (int i = 0; i < len; ++i) {\n parser_assert(payload[0] && payload[1]);\n char tmp = payload[2];\n payload[2] = '\\0';\n bytes.push_back(strtol(payload, &payload, 16));\n parser_assert('\\0' == *payload);\n payload[0] = tmp;\n }\n req.watch().conditions.push_back(std::move(bytes));\n }\n }\n parser_assert('\\0' == *payload);\n\n LOG(debug) << \"debugger requests \" << ('Z' == request ? \"set\" : \"remove\")\n << \"breakpoint (addr=\" << HEX(req.watch().addr)\n << \", len=\" << req.watch().kind << \")\";\n\n ret = true;\n break;\n }\n case '!':\n LOG(debug) << \"debugger requests extended mode\";\n write_packet(\"OK\");\n ret = false;\n break;\n case '?':\n LOG(debug) << \"debugger requests stop reason\";\n req = GdbRequest(DREQ_GET_STOP_REASON);\n req.target = query_thread;\n ret = true;\n break;\n case '_':\n ret = process_underscore(payload);\n break;\n default:\n UNHANDLED_REQ() << \"Unhandled debugger request '\" << inbuf[1] << \"'\";\n ret = false;\n }\n /* Erase the newly processed packet from the input buffer. The checksum\n * after the '#' will be skipped later as we look for the next packet start.\n */\n inbuf.erase(inbuf.begin(), inbuf.begin() + packetend + 1);\n\n /* If we processed the request internally, consume it. */\n if (!ret) {\n consume_request();\n }\n return ret;\n}\n\nvoid GdbServerConnection::notify_no_such_thread(const GdbRequest& req) {\n DEBUG_ASSERT(req.target == this->req.target && req.type == this->req.type);\n\n /* '10' is the errno ECHILD. We use it as a magic code to\n * notify the user that the thread that was the target of this\n * request has died, and either gdb didn't notice that, or rr\n * didn't notify gdb. Either way, the user should restart\n * their debugging session. */\n LOG(error) << \"Targeted thread no longer exists; this is the result of \"\n \"either a debugger or\\n\"\n \"rr bug. Please restart your debugging session and avoid \"\n \"doing whatever\\n\"\n \"triggered this bug.\";\n write_packet(\"E10\");\n consume_request();\n}\n\nvoid GdbServerConnection::notify_restart() {\n DEBUG_ASSERT(DREQ_RESTART == req.type);\n\n // These threads may not exist at the first trace-stop after\n // restart. The gdb client should reset this state, but help\n // it out just in case.\n resume_thread = GdbThreadId::ANY;\n query_thread = GdbThreadId::ANY;\n\n req = GdbRequest();\n}\n\nGdbRequest GdbServerConnection::get_request() {\n if (DREQ_RESTART == req.type) {\n LOG(debug) << \"consuming RESTART request\";\n notify_restart();\n // gdb wants to be notified with a stop packet when\n // the process \"relaunches\". In rr's case, the\n // traceee may be very far away from process creation,\n // but that's OK.\n req = GdbRequest(DREQ_GET_STOP_REASON);\n req.target = query_thread;\n return req;\n }\n\n/* Can't ask for the next request until you've satisfied the\n * current one, for requests that need an immediate\n * response. */\n#ifdef DEBUG\n DEBUG_ASSERT(!request_needs_immediate_response(&req));\n#endif\n\n if (!sniff_packet() && req.is_resume_request()) {\n /* There's no new request data available and the debugger has\n * already asked us to resume. OK, do that (or keep\n * doing that) now. */\n return req;\n }\n\n while (true) {\n /* There's either new request data, or we have nothing\n * to do. Either way, block until we read a complete\n * packet from the debugger. */\n read_packet();\n\n if (!connection_alive_) {\n return req = GdbRequest(DREQ_DETACH);\n }\n\n if (process_packet()) {\n /* We couldn't process the packet internally,\n * so the target has to do something. */\n return req;\n }\n /* The packet we got was \"internal\", debugger details.\n * Nothing for the target to do yet. Keep waiting. */\n }\n}\n\nvoid GdbServerConnection::notify_exit_code(int code) {\n char buf[64];\n\n DEBUG_ASSERT(req.is_resume_request() || req.type == DREQ_INTERRUPT);\n\n snprintf(buf, sizeof(buf) - 1, \"W%02x\", code);\n write_packet(buf);\n\n consume_request();\n}\n\nvoid GdbServerConnection::notify_exit_signal(int sig) {\n char buf[64];\n\n DEBUG_ASSERT(req.is_resume_request() || req.type == DREQ_INTERRUPT);\n\n snprintf(buf, sizeof(buf) - 1, \"X%02x\", sig);\n write_packet(buf);\n\n consume_request();\n}\n\n/**\n * Translate linux-x86 |sig| to gdb's internal numbering. Translation\n * made according to gdb/include/gdb/signals.def.\n */\nstatic int to_gdb_signum(int sig) {\n switch (sig) {\n case 0:\n return 0;\n case SIGHUP:\n return 1;\n case SIGINT:\n return 2;\n case SIGQUIT:\n return 3;\n case SIGILL:\n return 4;\n case SIGTRAP:\n return 5;\n case SIGABRT /*case SIGIOT*/:\n return 6;\n case SIGBUS:\n return 10;\n case SIGFPE:\n return 8;\n case SIGKILL:\n return 9;\n case SIGUSR1:\n return 30;\n case SIGSEGV:\n return 11;\n case SIGUSR2:\n return 31;\n case SIGPIPE:\n return 13;\n case SIGALRM:\n return 14;\n case SIGTERM:\n return 15;\n /* gdb hasn't heard of SIGSTKFLT, so this is\n * arbitrarily made up. SIGDANGER just sounds cool.*/\n case SIGSTKFLT:\n return 38 /*GDB_SIGNAL_DANGER*/;\n /*case SIGCLD*/ case SIGCHLD:\n return 20;\n case SIGCONT:\n return 19;\n case SIGSTOP:\n return 17;\n case SIGTSTP:\n return 18;\n case SIGTTIN:\n return 21;\n case SIGTTOU:\n return 22;\n case SIGURG:\n return 16;\n case SIGXCPU:\n return 24;\n case SIGXFSZ:\n return 25;\n case SIGVTALRM:\n return 26;\n case SIGPROF:\n return 27;\n case SIGWINCH:\n return 28;\n /*case SIGPOLL*/ case SIGIO:\n return 23;\n case SIGPWR:\n return 32;\n case SIGSYS:\n return 12;\n case 32:\n return 77;\n default:\n if (33 <= sig && sig <= 63) {\n /* GDB_SIGNAL_REALTIME_33 is numbered 45, hence this offset. */\n return sig + 12;\n }\n if (64 <= sig && sig <= 127) {\n /* GDB_SIGNAL_REALTIME_64 is numbered 78, hence this offset. */\n return sig + 14;\n }\n LOG(warn) << \"Unknown signal \" << sig;\n return 143; // GDB_SIGNAL_UNKNOWN\n }\n}\n\nvoid GdbServerConnection::send_stop_reply_packet(ExtendedTaskId thread, int sig,\n const vector& threads,\n const string& reason) {\n if (sig < 0) {\n write_packet(\"E01\");\n return;\n }\n stringstream sstr;\n sstr << \"T\" << std::setfill('0') << std::setw(2) << std::hex\n << to_gdb_signum(sig) << std::setw(0);\n sstr << \"thread:\" << format_thread_id(thread) << \";\" << reason;\n if (list_threads_in_stop_reply_) {\n sstr << \"threads:\";\n bool first = true;\n for (const auto& thread : threads) {\n if (thread.id.tguid != tguid) {\n continue;\n }\n if (!first) {\n sstr << \",\";\n }\n first = false;\n sstr << thread.id.tuid.tid();\n }\n sstr << \";thread-pcs:\";\n first = true;\n for (const auto& thread : threads) {\n if (thread.id.tguid != tguid) {\n continue;\n }\n if (!first) {\n sstr << \",\";\n }\n first = false;\n sstr << thread.pc;\n }\n sstr << \";\";\n }\n\n write_packet(sstr.str().c_str());\n}\n\nvoid GdbServerConnection::notify_stop(ExtendedTaskId thread, int sig,\n const vector& threads,\n const string& reason) {\n DEBUG_ASSERT(req.is_resume_request() || req.type == DREQ_INTERRUPT);\n\n // don't pass this signal to gdb if it is specified not to\n if (pass_signals.find(to_gdb_signum(sig)) != pass_signals.end()) {\n LOG(debug) << \"discarding stop notification for signal \" << sig \n << \" on thread \" << thread << \" as specified by QPassSignal\";\n\n return;\n }\n\n if (tguid != thread.tguid) {\n LOG(debug) << \"ignoring stop of \" << thread\n << \" because we're debugging tgid \" << tguid.tid();\n // Re-use the existing continue request to advance to\n // the next stop we're willing to tell gdb about.\n return;\n }\n\n send_stop_reply_packet(thread, sig, threads, reason);\n\n // This isn't documented in the gdb remote protocol, but if we\n // don't do this, gdb will sometimes continue to send requests\n // for the previously-stopped thread when it obviously intends\n // to be making requests about the stopped thread.\n // To make things even better, gdb expects different behavior\n // for forward continue/interrupt and reverse continue.\n if (req.is_resume_request() && req.cont().run_direction == RUN_BACKWARD) {\n LOG(debug) << \"Setting query/resume_thread to ANY after reverse continue\";\n query_thread = resume_thread = GdbThreadId::ANY;\n } else {\n LOG(debug) << \"Setting query/resume_thread to \" << thread\n << \" after forward continue or interrupt\";\n query_thread = resume_thread = thread.to_debugger_thread_id();\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::notify_restart_failed() {\n DEBUG_ASSERT(DREQ_RESTART == req.type);\n\n // TODO: it's not known by this author whether gdb knows how\n // to recover from a failed \"run\" request.\n write_packet(\"E01\");\n\n consume_request();\n}\n\nstring GdbServerConnection::format_thread_id(ExtendedTaskId thread) {\n char buf[32];\n if (multiprocess_supported_) {\n snprintf(buf, sizeof(buf), \"p%x.%x\", thread.tguid.tid(),\n thread.tuid.tid());\n } else {\n snprintf(buf, sizeof(buf), \"%x\", thread.tuid.tid());\n }\n return buf;\n}\n\nvoid GdbServerConnection::reply_get_current_thread(ExtendedTaskId thread) {\n DEBUG_ASSERT(DREQ_GET_CURRENT_THREAD == req.type);\n\n write_packet((\"QC\" + format_thread_id(thread)).c_str());\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_auxv(const vector& auxv) {\n DEBUG_ASSERT(DREQ_GET_AUXV == req.type);\n\n if (!auxv.empty()) {\n write_binary_packet(\"l\", auxv.data(), auxv.size());\n } else {\n write_packet(\"E01\");\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_exec_file(const string& exec_file) {\n DEBUG_ASSERT(DREQ_GET_EXEC_FILE == req.type);\n\n if (!exec_file.empty()) {\n write_binary_packet(\"l\",\n reinterpret_cast(exec_file.c_str()),\n exec_file.size());\n } else {\n write_packet(\"E01\");\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_is_thread_alive(bool alive) {\n DEBUG_ASSERT(DREQ_GET_IS_THREAD_ALIVE == req.type);\n\n write_packet(alive ? \"OK\" : \"E01\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_thread_extra_info(const string& info) {\n DEBUG_ASSERT(DREQ_GET_THREAD_EXTRA_INFO == req.type);\n\n LOG(debug) << \"thread extra info: '\" << info.c_str() << \"'\";\n write_hex_bytes_packet((const uint8_t*)info.c_str(), 1 + info.length());\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_select_thread(bool ok) {\n DEBUG_ASSERT(DREQ_SET_CONTINUE_THREAD == req.type ||\n DREQ_SET_QUERY_THREAD == req.type);\n\n if (ok && DREQ_SET_CONTINUE_THREAD == req.type) {\n resume_thread = req.target;\n } else if (ok && DREQ_SET_QUERY_THREAD == req.type) {\n query_thread = req.target;\n }\n write_packet(ok ? \"OK\" : \"E01\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_mem(const vector& mem) {\n DEBUG_ASSERT(DREQ_GET_MEM == req.type || DREQ_GET_MEM_BINARY == req.type);\n DEBUG_ASSERT(mem.size() <= req.mem().len);\n\n if (DREQ_GET_MEM == req.type) {\n if (req.mem().len > 0 && mem.size() == 0) {\n write_packet(\"E01\");\n } else {\n write_hex_bytes_packet(mem.data(), mem.size());\n }\n } else {\n if (debugger_type == DebuggerType::LLDB) {\n if (!req.mem().len) {\n write_packet(\"OK\");\n } else if (!mem.size()) {\n write_packet(\"E01\");\n } else {\n write_binary_packet(\"\", mem.data(), mem.size());\n }\n } else {\n if (!req.mem().len) {\n write_packet(\"b\");\n } else if (!mem.size()) {\n write_packet(\"E01\");\n } else {\n write_binary_packet(\"b\", mem.data(), mem.size());\n }\n }\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_set_mem(bool ok) {\n DEBUG_ASSERT(DREQ_SET_MEM == req.type || DREQ_SET_MEM_BINARY == req.type);\n\n write_packet(ok ? \"OK\" : \"E01\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_mem_alloc(remote_ptr addr) {\n DEBUG_ASSERT(DREQ_MEM_ALLOC == req.type);\n\n if (addr.is_null()) {\n write_packet(\"E01\");\n } else {\n char buf[256];\n sprintf(buf, \"%llx\", (long long)addr.as_int());\n write_packet(buf);\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_mem_free(bool ok) {\n DEBUG_ASSERT(DREQ_MEM_FREE == req.type);\n\n write_packet(ok ? \"OK\" : \"E01\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_search_mem_binary(\n bool found, remote_ptr addr) {\n DEBUG_ASSERT(DREQ_SEARCH_MEM_BINARY == req.type);\n\n if (found) {\n char buf[256];\n sprintf(buf, \"1,%llx\", (long long)addr.as_int());\n write_packet(buf);\n } else {\n write_packet(\"0\");\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_mem_info(MemoryRange range,\n int prot,\n const string& fs_name) {\n DEBUG_ASSERT(DREQ_MEM_INFO == req.type);\n\n stringstream sstr;\n sstr << hex << \"start:\" << range.start().as_int()\n << \";size:\" << range.size() << \";\";\n\n string permissions;\n if (prot & PROT_READ) {\n permissions += 'r';\n }\n if (prot & PROT_WRITE) {\n permissions += 'w';\n }\n if (prot & PROT_EXEC) {\n permissions += 'x';\n }\n if (!permissions.empty()) {\n sstr << \"permissions:\" << permissions << \";\";\n }\n if (!fs_name.empty()) {\n sstr << \"name:\" << string_to_hex(fs_name) << \";\";\n }\n\n write_packet(sstr.str().c_str());\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_offsets(/* TODO */) {\n DEBUG_ASSERT(DREQ_GET_OFFSETS == req.type);\n\n /* XXX FIXME TODO */\n write_packet(\"\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_reg(const GdbServerRegisterValue& reg) {\n char buf[2 * GdbServerRegisterValue::MAX_SIZE + 1];\n\n DEBUG_ASSERT(DREQ_GET_REG == req.type);\n\n print_reg_value(reg, buf);\n write_packet(buf);\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_regs(const vector& file) {\n std::unique_ptr buf(\n new char[file.size() * 2 * GdbServerRegisterValue::MAX_SIZE + 1]);\n\n DEBUG_ASSERT(DREQ_GET_REGS == req.type);\n\n size_t offset = 0;\n for (auto& reg : file) {\n offset += print_reg_value(reg, &buf[offset]);\n }\n write_packet(buf.get());\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_set_reg(bool ok) {\n DEBUG_ASSERT(DREQ_SET_REG == req.type);\n\n // TODO: what happens if we're forced to reply to a\n // set-register request with |ok = false|, leading us to\n // pretend not to understand the packet? If, later, an\n // experimental session needs the set-register request will it\n // not be sent?\n //\n // We can't reply with an error packet here because gdb thinks\n // that failed set-register requests are catastrophic.\n write_packet(ok ? \"OK\" : \"\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_stop_reason(ExtendedTaskId which, int sig,\n const std::vector& threads) {\n DEBUG_ASSERT(DREQ_GET_STOP_REASON == req.type);\n\n send_stop_reply_packet(which, sig, threads, string());\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_get_thread_list(const vector& threads) {\n DEBUG_ASSERT(DREQ_GET_THREAD_LIST == req.type);\n if (threads.empty()) {\n write_packet(\"l\");\n } else {\n stringstream sstr;\n sstr << 'm';\n for (size_t i = 0; i < threads.size(); ++i) {\n const ExtendedTaskId& t = threads[i];\n if (tguid != t.tguid) {\n continue;\n }\n if (multiprocess_supported_) {\n sstr << 'p' << setw(2) << setfill('0') << hex << t.tguid.tid() << dec << '.'\n << setw(2) << setfill('0') << hex << t.tuid.tid() << ',';\n } else {\n sstr << setw(2) << setfill('0') << hex << t.tuid.tid() << ',';\n }\n }\n\n string str = sstr.str();\n /* Overwrite the trailing ',' */\n str.back() = 0;\n write_packet(str.c_str());\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_watchpoint_request(bool ok) {\n DEBUG_ASSERT(DREQ_WATCH_FIRST <= req.type && req.type <= DREQ_WATCH_LAST);\n\n write_packet(ok ? \"OK\" : \"E01\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_detach() {\n DEBUG_ASSERT(DREQ_DETACH <= req.type);\n\n write_packet(\"OK\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_read_siginfo(const vector& si_bytes) {\n DEBUG_ASSERT(DREQ_READ_SIGINFO == req.type);\n\n if (si_bytes.empty()) {\n write_packet(\"E01\");\n } else {\n write_binary_packet(\"l\", si_bytes.data(), si_bytes.size());\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_write_siginfo(/* TODO*/) {\n DEBUG_ASSERT(DREQ_WRITE_SIGINFO == req.type);\n\n write_packet(\"E01\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_rr_cmd(const std::string& text) {\n DEBUG_ASSERT(DREQ_RR_CMD == req.type);\n\n write_packet(text.c_str());\n\n consume_request();\n}\n\nvoid GdbServerConnection::send_qsymbol(const std::string& name) {\n DEBUG_ASSERT(DREQ_QSYMBOL == req.type);\n\n const void* data = static_cast(name.c_str());\n write_hex_bytes_packet(\"qSymbol:\", static_cast(data),\n name.length());\n\n consume_request();\n}\n\nvoid GdbServerConnection::qsymbols_finished() {\n DEBUG_ASSERT(DREQ_QSYMBOL == req.type);\n\n write_packet(\"OK\");\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_tls_addr(bool ok, remote_ptr address) {\n DEBUG_ASSERT(DREQ_TLS == req.type);\n\n if (ok) {\n char buf[256];\n sprintf(buf, \"%llx\", (long long)address.as_int());\n write_packet(buf);\n } else {\n write_packet(\"E01\");\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_setfs(int err) {\n DEBUG_ASSERT(DREQ_FILE_SETFS == req.type);\n if (err) {\n send_file_error_reply(err);\n } else {\n write_packet(\"F0\");\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_open(int fd, int err) {\n DEBUG_ASSERT(DREQ_FILE_OPEN == req.type);\n if (err) {\n send_file_error_reply(err);\n } else {\n char buf[32];\n sprintf(buf, \"F%x\", fd);\n write_packet(buf);\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_pread(const uint8_t* bytes, ssize_t len, int err) {\n DEBUG_ASSERT(DREQ_FILE_PREAD == req.type);\n if (err) {\n send_file_error_reply(err);\n } else {\n char buf[32];\n sprintf(buf, \"F%llx;\", (long long)len);\n write_binary_packet(buf, bytes, len);\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_close(int err) {\n DEBUG_ASSERT(DREQ_FILE_CLOSE == req.type);\n if (err) {\n send_file_error_reply(err);\n } else {\n write_packet(\"F0\");\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::send_file_error_reply(int system_errno) {\n int gdb_err;\n switch (system_errno) {\n case EPERM:\n gdb_err = 1;\n break;\n case ENOENT:\n gdb_err = 2;\n break;\n case EINTR:\n gdb_err = 4;\n break;\n case EBADF:\n gdb_err = 9;\n break;\n case EACCES:\n gdb_err = 13;\n break;\n case EFAULT:\n gdb_err = 14;\n break;\n case EBUSY:\n gdb_err = 16;\n break;\n case EEXIST:\n gdb_err = 17;\n break;\n case ENODEV:\n gdb_err = 19;\n break;\n case ENOTDIR:\n gdb_err = 20;\n break;\n case EISDIR:\n gdb_err = 21;\n break;\n case EINVAL:\n gdb_err = 22;\n break;\n case ENFILE:\n gdb_err = 23;\n break;\n case EMFILE:\n gdb_err = 24;\n break;\n case EFBIG:\n gdb_err = 27;\n break;\n case ENOSPC:\n gdb_err = 28;\n break;\n case ESPIPE:\n gdb_err = 29;\n break;\n case EROFS:\n gdb_err = 30;\n break;\n case ENAMETOOLONG:\n gdb_err = 91;\n break;\n default:\n gdb_err = 9999;\n break;\n }\n char buf[32];\n sprintf(buf, \"F-01,%x\", gdb_err);\n write_packet(buf);\n}\n\nvoid GdbServerConnection::reply_save_register_state(bool ok, int state_index) {\n DEBUG_ASSERT(DREQ_SAVE_REGISTER_STATE == req.type);\n\n if (ok) {\n char buf[256];\n sprintf(buf, \"%llx\", (long long)state_index);\n write_packet(buf);\n } else {\n write_packet(\"E01\");\n }\n\n consume_request();\n}\n\nvoid GdbServerConnection::reply_restore_register_state(bool ok) {\n DEBUG_ASSERT(DREQ_RESTORE_REGISTER_STATE == req.type);\n\n write_packet(ok ? \"OK\" : \"E01\");\n\n consume_request();\n}\n\nbool GdbServerConnection::is_connection_alive() { return connection_alive_; }\n\nbool GdbServerConnection::is_pass_signal(int sig) { return pass_signals.find(to_gdb_signum(sig)) != pass_signals.end(); }\n\nvoid GdbServerConnection::set_cpu_features(SupportedArch arch) {\n cpu_features_ = get_cpu_features(arch);\n DEBUG_ASSERT(target_description == nullptr &&\n \"Target description already created\");\n target_description = std::make_unique(arch, cpu_features_);\n}\n\n} // namespace rr\n" }, { "path": "src/GdbServerConnection.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_CONNECTION_H_\n#define RR_GDB_CONNECTION_H_\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"GdbServerRegister.h\"\n#include \"Registers.h\"\n#include \"ReplaySession.h\"\n#include \"ReplayTimeline.h\"\n#include \"ScopedFd.h\"\n#include \"TargetDescription.h\"\n#include \"TaskishUid.h\"\n#include \"core.h\"\n#include \"launch_debugger.h\"\n\nnamespace rr {\n\n/**\n * Descriptor for task, that carries both the pid (thread-group ID)\n * and the thread ID. On Linux the thread ID is unique in rr's pid namespace\n * *at a specific point in time*. Thread IDs can potentially be reused\n * over long periods of time.\n * Also has special `ANY` and `ALL` values used by the debugger protocol.\n * These values can be passed from the debugger so the task might not\n * actually exist.\n * Because of the special values and the fact that thread IDs can be\n * reused, this is more like a pattern that can match specific tasks than\n * a unique task ID.\n */\nstruct GdbThreadId {\n GdbThreadId(pid_t pid = -1, pid_t tid = -1) : pid(pid), tid(tid) {}\n\n pid_t pid;\n pid_t tid;\n\n bool operator==(const GdbThreadId& o) const {\n return pid == o.pid && tid == o.tid;\n }\n\n static const GdbThreadId ANY;\n static const GdbThreadId ALL;\n};\n\ninline std::ostream& operator<<(std::ostream& o, const GdbThreadId& t) {\n o << t.pid << \".\" << t.tid;\n return o;\n}\n\n/**\n * A really-unique `TaskUid` and its `ThreadGroupUid`. This always corresponds\n * to a specific task that exist(ed) somewhere in the recording, unless\n * tguid and tuid are zero.\n */\nstruct ExtendedTaskId {\n ThreadGroupUid tguid;\n TaskUid tuid;\n\n ExtendedTaskId(ThreadGroupUid tguid, TaskUid tuid)\n : tguid(tguid), tuid(tuid) {}\n ExtendedTaskId() {}\n\n GdbThreadId to_debugger_thread_id() const {\n return GdbThreadId(tguid.tid(), tuid.tid());\n }\n};\n\ninline std::ostream& operator<<(std::ostream& o, const ExtendedTaskId& t) {\n o << t.tguid.tid() << \".\" << t.tuid.tid();\n return o;\n}\n\n/**\n * Represents a possibly-undefined register |name|. |size| indicates how\n * many bytes of |value| are valid, if any.\n */\nstruct GdbServerRegisterValue {\n enum { MAX_SIZE = Registers::MAX_SIZE };\n GdbServerRegister name;\n union {\n uint8_t value[MAX_SIZE];\n uint8_t value1;\n uint16_t value2;\n uint32_t value4;\n uint64_t value8;\n };\n size_t size;\n bool defined;\n};\n\nenum GdbRequestType {\n DREQ_NONE = 0,\n\n /* None of these requests have parameters. */\n DREQ_GET_CURRENT_THREAD,\n DREQ_GET_OFFSETS,\n DREQ_GET_REGS,\n DREQ_GET_STOP_REASON,\n DREQ_GET_THREAD_LIST,\n DREQ_INTERRUPT,\n DREQ_DETACH,\n\n /* These use params.target. */\n DREQ_GET_AUXV,\n DREQ_GET_EXEC_FILE,\n DREQ_GET_IS_THREAD_ALIVE,\n DREQ_GET_THREAD_EXTRA_INFO,\n DREQ_SET_CONTINUE_THREAD,\n DREQ_SET_QUERY_THREAD,\n // TLS lookup, uses params.target and params.tls.\n DREQ_TLS,\n // gdb wants to write back siginfo_t to a tracee. More\n // importantly, this packet arrives before an experiment\n // session for a |call foo()| is about to be torn down.\n //\n // TODO: actual interface NYI.\n DREQ_WRITE_SIGINFO,\n\n /* These use params.mem. */\n DREQ_GET_MEM,\n DREQ_GET_MEM_BINARY,\n DREQ_SET_MEM,\n DREQ_SET_MEM_BINARY,\n // gdb wants to read the current siginfo_t for a stopped\n // tracee. More importantly, this packet arrives at the very\n // beginning of a |call foo()| experiment.\n //\n // Uses .mem for offset/len.\n DREQ_READ_SIGINFO,\n DREQ_SEARCH_MEM_BINARY,\n DREQ_MEM_INFO,\n DREQ_MEM_FIRST = DREQ_GET_MEM,\n DREQ_MEM_LAST = DREQ_MEM_INFO,\n\n DREQ_REMOVE_SW_BREAK,\n DREQ_REMOVE_HW_BREAK,\n DREQ_REMOVE_WR_WATCH,\n DREQ_REMOVE_RD_WATCH,\n DREQ_REMOVE_RDWR_WATCH,\n DREQ_SET_SW_BREAK,\n DREQ_SET_HW_BREAK,\n DREQ_SET_WR_WATCH,\n DREQ_SET_RD_WATCH,\n DREQ_SET_RDWR_WATCH,\n DREQ_WATCH_FIRST = DREQ_REMOVE_SW_BREAK,\n DREQ_WATCH_LAST = DREQ_SET_RDWR_WATCH,\n\n /* Use params.reg. */\n DREQ_GET_REG,\n DREQ_SET_REG,\n DREQ_REG_FIRST = DREQ_GET_REG,\n DREQ_REG_LAST = DREQ_SET_REG,\n\n /* Use params.cont. */\n DREQ_CONT,\n\n /* gdb host detaching from stub. No parameters. */\n\n /* Uses params.restart. */\n DREQ_RESTART,\n\n /* Uses params.text. */\n DREQ_RR_CMD,\n\n // qSymbol packet, uses params.sym.\n DREQ_QSYMBOL,\n\n // vFile:setfs packet, uses params.file_setfs.\n DREQ_FILE_SETFS,\n // vFile:open packet, uses params.file_open.\n DREQ_FILE_OPEN,\n // vFile:pread packet, uses params.file_pread.\n DREQ_FILE_PREAD,\n // vFile:close packet, uses params.file_close.\n DREQ_FILE_CLOSE,\n\n // Uses params.mem_alloc\n DREQ_MEM_ALLOC,\n // Uses params.mem_free\n DREQ_MEM_FREE,\n\n DREQ_SAVE_REGISTER_STATE,\n // Uses params.restore_register_state\n DREQ_RESTORE_REGISTER_STATE,\n};\n\nenum GdbRestartType {\n RESTART_FROM_PREVIOUS,\n RESTART_FROM_EVENT,\n RESTART_FROM_CHECKPOINT,\n RESTART_FROM_TICKS\n};\n\nenum GdbActionType { ACTION_CONTINUE, ACTION_STEP };\n\nstruct GdbContAction {\n GdbContAction(GdbActionType type = ACTION_CONTINUE,\n const GdbThreadId& target = GdbThreadId::ANY,\n int signal_to_deliver = 0)\n : type(type), target(target), signal_to_deliver(signal_to_deliver) {}\n GdbActionType type;\n GdbThreadId target;\n int signal_to_deliver;\n};\n\n/**\n * These requests are made by the debugger host and honored in proxy\n * by rr, the target.\n */\nstruct GdbRequest {\n GdbRequest(GdbRequestType type = DREQ_NONE)\n : type(type), suppress_debugger_stop(false) {}\n GdbRequest(const GdbRequest& other)\n : type(other.type),\n target(other.target),\n suppress_debugger_stop(other.suppress_debugger_stop) {\n if (type >= DREQ_MEM_FIRST && type <= DREQ_MEM_LAST) {\n mem_ = other.mem_;\n } else if (type >= DREQ_WATCH_FIRST && type <= DREQ_WATCH_LAST) {\n watch_ = other.watch_;\n } else if (type >= DREQ_REG_FIRST && type <= DREQ_REG_LAST) {\n reg_ = other.reg_;\n } else if (type == DREQ_RESTART) {\n restart_ = other.restart_;\n } else if (type == DREQ_CONT) {\n cont_ = other.cont_;\n } else if (type == DREQ_RR_CMD) {\n rr_cmd_ = other.rr_cmd_;\n } else if (type == DREQ_TLS) {\n tls_ = other.tls_;\n } else if (type == DREQ_QSYMBOL) {\n sym_ = other.sym_;\n } else if (type == DREQ_FILE_SETFS) {\n file_setfs_ = other.file_setfs_;\n } else if (type == DREQ_FILE_OPEN) {\n file_open_ = other.file_open_;\n } else if (type == DREQ_FILE_PREAD) {\n file_pread_ = other.file_pread_;\n } else if (type == DREQ_FILE_CLOSE) {\n file_close_ = other.file_close_;\n } else if (type == DREQ_MEM_ALLOC) {\n mem_alloc_ = other.mem_alloc_;\n } else if (type == DREQ_MEM_FREE) {\n mem_free_ = other.mem_free_;\n } else if (type == DREQ_RESTORE_REGISTER_STATE) {\n restore_register_state_ = other.restore_register_state_;\n }\n }\n GdbRequest& operator=(const GdbRequest& other) {\n this->~GdbRequest();\n new (this) GdbRequest(other);\n return *this;\n }\n\n const GdbRequestType type;\n GdbThreadId target;\n bool suppress_debugger_stop;\n\n struct Mem {\n uintptr_t addr = 0;\n size_t len = 0;\n // For SET_MEM requests, the |len| raw bytes that are to be written.\n // For SEARCH_MEM requests, the bytes to search for.\n std::vector data;\n } mem_;\n struct Watch {\n uintptr_t addr = 0;\n int kind = 0;\n std::vector> conditions;\n } watch_;\n GdbServerRegisterValue reg_;\n struct Restart {\n int64_t param = 0;\n std::string param_str;\n GdbRestartType type = RESTART_FROM_PREVIOUS;\n } restart_;\n struct Cont {\n RunDirection run_direction = RUN_FORWARD;\n std::vector actions;\n } cont_;\n struct RRCmd {\n std::string name;\n pid_t target_tid = -1;\n std::vector args; \n } rr_cmd_;\n struct Tls {\n size_t offset = 0;\n remote_ptr load_module;\n } tls_;\n struct Symbol {\n bool has_address = false;\n remote_ptr address;\n std::string name;\n } sym_;\n struct FileSetfs {\n pid_t pid = -1;\n } file_setfs_;\n struct FileOpen {\n std::string file_name;\n // In system format, not gdb's format\n int flags = 0;\n int mode = 0;\n } file_open_;\n struct FilePread {\n int fd = -1;\n size_t size = 0;\n uint64_t offset = 0;\n } file_pread_;\n struct FileClose {\n int fd = -1;\n } file_close_;\n struct MemAlloc {\n size_t size = 0;\n int prot = 0;\n } mem_alloc_;\n struct MemFree {\n remote_ptr address;\n } mem_free_;\n struct RestoreRegisterState {\n int state_index = 0;\n } restore_register_state_;\n\n Mem& mem() {\n DEBUG_ASSERT(type >= DREQ_MEM_FIRST && type <= DREQ_MEM_LAST);\n return mem_;\n }\n const Mem& mem() const {\n DEBUG_ASSERT(type >= DREQ_MEM_FIRST && type <= DREQ_MEM_LAST);\n return mem_;\n }\n Watch& watch() {\n DEBUG_ASSERT(type >= DREQ_WATCH_FIRST && type <= DREQ_WATCH_LAST);\n return watch_;\n }\n const Watch& watch() const {\n DEBUG_ASSERT(type >= DREQ_WATCH_FIRST && type <= DREQ_WATCH_LAST);\n return watch_;\n }\n GdbServerRegisterValue& reg() {\n DEBUG_ASSERT(type >= DREQ_REG_FIRST && type <= DREQ_REG_LAST);\n return reg_;\n }\n const GdbServerRegisterValue& reg() const {\n DEBUG_ASSERT(type >= DREQ_REG_FIRST && type <= DREQ_REG_LAST);\n return reg_;\n }\n Restart& restart() {\n DEBUG_ASSERT(type == DREQ_RESTART);\n return restart_;\n }\n const Restart& restart() const {\n DEBUG_ASSERT(type == DREQ_RESTART);\n return restart_;\n }\n Cont& cont() {\n DEBUG_ASSERT(type == DREQ_CONT);\n return cont_;\n }\n const Cont& cont() const {\n DEBUG_ASSERT(type == DREQ_CONT);\n return cont_;\n }\n RRCmd& rr_cmd() {\n DEBUG_ASSERT(type == DREQ_RR_CMD);\n return rr_cmd_;\n }\n const RRCmd& rr_cmd() const {\n DEBUG_ASSERT(type == DREQ_RR_CMD);\n return rr_cmd_;\n }\n Tls& tls() {\n DEBUG_ASSERT(type == DREQ_TLS);\n return tls_;\n }\n const Tls& tls() const {\n DEBUG_ASSERT(type == DREQ_TLS);\n return tls_;\n }\n Symbol& sym() {\n DEBUG_ASSERT(type == DREQ_QSYMBOL);\n return sym_;\n }\n const Symbol& sym() const {\n DEBUG_ASSERT(type == DREQ_QSYMBOL);\n return sym_;\n }\n FileSetfs& file_setfs() {\n DEBUG_ASSERT(type == DREQ_FILE_SETFS);\n return file_setfs_;\n }\n const FileSetfs& file_setfs() const {\n DEBUG_ASSERT(type == DREQ_FILE_SETFS);\n return file_setfs_;\n }\n FileOpen& file_open() {\n DEBUG_ASSERT(type == DREQ_FILE_OPEN);\n return file_open_;\n }\n const FileOpen& file_open() const {\n DEBUG_ASSERT(type == DREQ_FILE_OPEN);\n return file_open_;\n }\n FilePread& file_pread() {\n DEBUG_ASSERT(type == DREQ_FILE_PREAD);\n return file_pread_;\n }\n const FilePread& file_pread() const {\n DEBUG_ASSERT(type == DREQ_FILE_PREAD);\n return file_pread_;\n }\n FileClose& file_close() {\n DEBUG_ASSERT(type == DREQ_FILE_CLOSE);\n return file_close_;\n }\n const FileClose& file_close() const {\n DEBUG_ASSERT(type == DREQ_FILE_CLOSE);\n return file_close_;\n }\n MemAlloc& mem_alloc() {\n DEBUG_ASSERT(type == DREQ_MEM_ALLOC);\n return mem_alloc_;\n }\n const MemAlloc& mem_alloc() const {\n DEBUG_ASSERT(type == DREQ_MEM_ALLOC);\n return mem_alloc_;\n }\n MemFree& mem_free() {\n DEBUG_ASSERT(type == DREQ_MEM_FREE);\n return mem_free_;\n }\n const MemFree& mem_free() const {\n DEBUG_ASSERT(type == DREQ_MEM_FREE);\n return mem_free_;\n }\n RestoreRegisterState& restore_register_state() {\n DEBUG_ASSERT(type == DREQ_RESTORE_REGISTER_STATE);\n return restore_register_state_;\n }\n const RestoreRegisterState& restore_register_state() const {\n DEBUG_ASSERT(type == DREQ_RESTORE_REGISTER_STATE);\n return restore_register_state_;\n }\n\n /**\n * Return nonzero if this requires that program execution be resumed\n * in some way.\n */\n bool is_resume_request() const { return type == DREQ_CONT; }\n};\n\n/**\n * This struct wraps up the state of the gdb protocol, so that we can\n * offer a (mostly) stateless interface to clients.\n */\nclass GdbServerConnection {\npublic:\n struct Features {\n Features() : reverse_execution(true) {}\n bool reverse_execution;\n };\n\n /**\n * Wait for exactly one gdb host to connect to this remote target on\n * the specified IP address |host|, port |port|. If |probe| is nonzero,\n * a unique port based on |start_port| will be searched for. Otherwise,\n * if |port| is already bound, this function will fail.\n *\n * Pass the `Task` on which this debug-connection request\n * is being made. The remaining debugging session will be limited to\n * traffic regarding this task, but clients don't need to and shouldn't\n * need to assume that.\n *\n * If we're opening this connection on behalf of a known client, pass\n * an fd in |client_params_fd|; we'll write the allocated port and |exe_image|\n * through the fd before waiting for a connection. |exe_image| is the\n * process that will be debugged by client, or null ptr if there isn't\n * a client.\n *\n * This function is infallible: either it will return a valid\n * debugging context, or it won't return.\n */\n static std::unique_ptr await_connection(\n Task* t, ScopedFd& listen_fd, DebuggerType debugger_type,\n const Features& features = Features());\n\n /**\n * Call this when the target of |req| is needed to fulfill the\n * request, but the target is dead. This situation is a symptom of a\n * gdb or rr bug.\n */\n void notify_no_such_thread(const GdbRequest& req);\n\n /**\n * Finish a DREQ_RESTART request. Should be invoked after replay\n * restarts and prior GdbServerConnection has been restored.\n */\n void notify_restart();\n\n /**\n * Return the current request made by the debugger host, that needs to\n * be satisfied. This function will block until either there's a\n * debugger host request that needs a response, or until a request is\n * made to resume execution of the target. In the latter case,\n * calling this function multiple times will return an appropriate\n * resume request each time (see above).\n *\n * The target should peek at the debugger request in between execution\n * steps. A new request may need to be serviced.\n */\n GdbRequest get_request();\n\n /**\n * Notify the host that this process has exited with |code|.\n */\n void notify_exit_code(int code);\n\n /**\n * Notify the host that this process has exited from |sig|.\n */\n void notify_exit_signal(int sig);\n\n struct ThreadInfo {\n ExtendedTaskId id;\n uintptr_t pc;\n };\n\n /**\n * Notify the host that a resume request has \"finished\", i.e., the\n * target has stopped executing for some reason. |sig| is the signal\n * that stopped execution, or 0 if execution stopped otherwise.\n */\n void notify_stop(ExtendedTaskId which, int sig,\n const std::vector& threads,\n const std::string& reason);\n\n /** Notify the debugger that a restart request failed. */\n void notify_restart_failed();\n\n /**\n * Tell the host that |thread| is the current thread.\n */\n void reply_get_current_thread(ExtendedTaskId thread);\n\n /**\n * Reply with the target thread's |auxv| pairs. |auxv.empty()|\n * if there was an error reading the auxiliary vector.\n */\n void reply_get_auxv(const std::vector& auxv);\n\n /**\n * Reply with the target thread's executable file name\n */\n void reply_get_exec_file(const std::string& exec_file);\n\n /**\n * |alive| is true if the requested thread is alive, false if dead.\n */\n void reply_get_is_thread_alive(bool alive);\n\n /**\n * |info| is a string containing data about the request target that\n * might be relevant to the debugger user.\n */\n void reply_get_thread_extra_info(const std::string& info);\n\n /**\n * |ok| is true if req->target can be selected, false otherwise.\n */\n void reply_select_thread(bool ok);\n\n /**\n * The first |mem.size()| bytes of the request were read into |mem|.\n * |mem.size()| must be less than or equal to the length of the request.\n */\n void reply_get_mem(const std::vector& mem);\n\n /**\n * |ok| is true if a SET_MEM(_BINARY) request succeeded, false otherwise. This\n * function *must* be called whenever a SET_MEM(_BINARY) request is made,\n * regardless of success/failure or special interpretation.\n */\n void reply_set_mem(bool ok);\n\n /**\n * Reply to the DREQ_SEARCH_MEM_BINARY request.\n * |found| is true if we found the searched-for bytes starting at address\n * |addr|.\n */\n void reply_search_mem_binary(bool found, remote_ptr addr);\n\n /**\n * Reply to the DREQ_MEM_INFO request.\n */\n void reply_mem_info(MemoryRange range, int prot,\n const std::string& fs_name);\n\n /**\n * Reply to the DREQ_MEM_ALLOC request.\n */\n void reply_mem_alloc(remote_ptr addr);\n\n /**\n * Reply to the DREQ_MEM_FREE request.\n */\n void reply_mem_free(bool ok);\n\n /**\n * Reply to the DREQ_GET_OFFSETS request.\n */\n void reply_get_offsets(/* TODO */);\n\n /**\n * Send |value| back to the debugger host. |value| may be undefined.\n */\n void reply_get_reg(const GdbServerRegisterValue& value);\n\n /**\n * Send |file| back to the debugger host. |file| may contain\n * undefined register values.\n */\n void reply_get_regs(const std::vector& file);\n\n /**\n * Pass |ok = true| iff the requested register was successfully set.\n */\n void reply_set_reg(bool ok);\n\n /**\n * Reply to the DREQ_GET_STOP_REASON request.\n */\n void reply_get_stop_reason(ExtendedTaskId which, int sig,\n const std::vector& threads);\n\n /**\n * |threads| contains the list of live threads, of which there are\n * |len|.\n */\n void reply_get_thread_list(const std::vector& threads);\n\n /**\n * |ok| is true if the request was successfully applied, false if\n * not.\n */\n void reply_watchpoint_request(bool ok);\n\n /**\n * DREQ_DETACH was processed.\n *\n * There's no functional reason to reply to the detach request.\n * However, some versions of gdb expect a response and time out\n * awaiting it, wasting developer time.\n */\n void reply_detach();\n\n /**\n * Pass the siginfo_t and its size (as requested by the debugger) in\n * |si_bytes| and |num_bytes| if successfully read. Otherwise pass\n * |si_bytes = nullptr|.\n */\n void reply_read_siginfo(const std::vector& si_bytes);\n /**\n * Not yet implemented, but call this after a WRITE_SIGINFO request\n * anyway.\n */\n void reply_write_siginfo(/* TODO*/);\n\n /**\n * Send a manual text response to a rr cmd (maintenance) packet.\n */\n void reply_rr_cmd(const std::string& text);\n\n /**\n * Send a qSymbol response to gdb, requesting the address of the\n * symbol |name|.\n */\n void send_qsymbol(const std::string& name);\n\n /**\n * The \"all done\" response to a qSymbol packet from gdb.\n */\n void qsymbols_finished();\n\n /**\n * Respond to a qGetTLSAddr packet. If |ok| is true, then respond\n * with |address|. If |ok| is false, respond with an error.\n */\n void reply_tls_addr(bool ok, remote_ptr address);\n\n /**\n * Respond to a vFile:setfs\n */\n void reply_setfs(int err);\n /**\n * Respond to a vFile:open\n */\n void reply_open(int fd, int err);\n /**\n * Respond to a vFile:pread\n */\n void reply_pread(const uint8_t* bytes, ssize_t len, int err);\n /**\n * Respond to a vFile:close\n */\n void reply_close(int err);\n\n /**\n * Respond to a QSaveRegisterState.\n * -1 for failure.\n */\n void reply_save_register_state(bool ok, int state_index);\n /**\n * Respond to a QRestoreRegisterState.\n */\n void reply_restore_register_state(bool ok);\n\n /**\n * Create a checkpoint of the given Session with the given id. Delete the\n * existing checkpoint with that id if there is one.\n */\n void created_checkpoint(ReplaySession::shr_ptr& checkpoint,\n int checkpoint_id);\n\n /**\n * Delete the checkpoint with the given id. Silently fail if the checkpoint\n * does not exist.\n */\n void delete_checkpoint(int checkpoint_id);\n\n /**\n * Get the checkpoint with the given id. Return null if not found.\n */\n ReplaySession::shr_ptr get_checkpoint(int checkpoint_id);\n\n /**\n * Return true if there's a new packet to be read/process (whether\n * incomplete or not), and false if there isn't one.\n */\n bool sniff_packet();\n\n const Features& features() { return features_; }\n\n enum {\n CPU_X86_64 = 1 << 0,\n CPU_AVX = 1 << 1,\n CPU_AARCH64 = 1 << 2,\n CPU_PKU = 1 << 3,\n CPU_AVX512 = 1 << 4\n };\n\n void set_cpu_features(SupportedArch arch);\n uint32_t cpu_features() const { return cpu_features_; }\n\n GdbServerConnection(ThreadGroupUid tguid, DebuggerType debugger_type,\n const Features& features);\n\n /**\n * Wait for a debugger client to connect to |dbg|'s socket. Blocks\n * indefinitely.\n */\n void await_debugger(ScopedFd& listen_fd);\n\n /**\n * Returns false if the connection has been closed\n */\n bool is_connection_alive();\n\n bool hwbreak_supported() const { return hwbreak_supported_; }\n bool swbreak_supported() const { return swbreak_supported_; }\n bool multiprocess_supported() const { return multiprocess_supported_; }\n\n bool is_pass_signal(int sig);\n\nprivate:\n /**\n * read() incoming data exactly one time, successfully. May block.\n */\n void read_data_once();\n /**\n * Send all pending output to gdb. May block.\n */\n void write_flush();\n void write_data_raw(const uint8_t* data, ssize_t len);\n void write_hex(unsigned long hex);\n void write_packet_bytes(const uint8_t* data, size_t num_bytes);\n void write_packet(const char* data);\n void write_binary_packet(const char* pfx, const uint8_t* data,\n ssize_t num_bytes);\n void write_hex_bytes_packet(const char* prefix, const uint8_t* bytes,\n size_t len);\n void write_hex_bytes_packet(const uint8_t* bytes, size_t len);\n void write_xfer_response(const void* data, size_t size, uint64_t offset,\n uint64_t len);\n void parse_thread_suffix_threadid(char* payload, GdbThreadId* out);\n /**\n * Consume bytes in the input buffer until start-of-packet ('$') or\n * the interrupt character is seen. Does not block. Return true if\n * seen, false if not.\n */\n bool skip_to_packet_start();\n /**\n * Block until the sequence of bytes\n *\n * \"[^$]*\\$[^#]*#.*\"\n *\n * has been read from the client fd. This is one (or more) gdb\n * packet(s).\n */\n void read_packet();\n /**\n * Return true if we need to do something in a debugger request,\n * false if we already handled the packet internally.\n */\n bool xfer(const char* name, char* args);\n /**\n * Return true if we need to do something in a debugger request,\n * false if we already handled the packet internally.\n */\n bool query(char* payload);\n /**\n * Return true if we need to do something in a debugger request,\n * false if we already handled the packet internally.\n */\n bool set_var(char* payload);\n /**\n * Return true if we need to do something in a debugger request,\n * false if we already handled the packet internally.\n */\n bool process_underscore(char* payload);\n /**\n * Return true if we need to do something in a debugger request,\n * false if we already handled the packet internally.\n */\n bool process_vpacket(char* payload);\n /**\n * Return true if we need to do something in a debugger request,\n * false if we already handled the packet internally.\n */\n bool process_bpacket(char* payload);\n /**\n * Return true if we need to do something in a debugger request,\n * false if we already handled the packet internally.\n */\n bool process_packet();\n void consume_request();\n void send_stop_reply_packet(ExtendedTaskId thread, int sig,\n const std::vector& threads,\n const std::string& reason);\n void send_file_error_reply(int system_errno);\n std::string format_thread_id(ExtendedTaskId thread);\n\n // Current request to be processed.\n GdbRequest req;\n // Thread to be resumed.\n GdbThreadId resume_thread;\n // Thread for get/set requests.\n GdbThreadId query_thread;\n // gdb and rr don't work well together in multi-process and\n // multi-exe-image debugging scenarios, so we pretend only\n // this thread group exists when interfacing with gdb\n ThreadGroupUid tguid;\n uint32_t cpu_features_;\n DebuggerType debugger_type;\n // true when \"no-ack mode\" enabled, in which we don't have\n // to send ack packets back to gdb. This is a huge perf win.\n bool no_ack;\n // contains signals (gdb not native) which should be passed directly to the\n // debuggee without gdb being informed, speeding up\n // reverse execution\n std::unordered_set pass_signals;\n ScopedFd sock_fd;\n std::vector inbuf; /* buffered input from gdb */\n size_t packetend; /* index of '#' character */\n std::vector outbuf; /* buffered output for gdb */\n Features features_;\n bool connection_alive_;\n bool multiprocess_supported_; // client supports multiprocess extension\n bool hwbreak_supported_; // client supports hwbreak extension\n bool swbreak_supported_; // client supports swbreak extension\n bool list_threads_in_stop_reply_; // client requested threads: and thread-pcs: in stop replies\n std::unique_ptr target_description;\n};\n\n} // namespace rr\n\n#endif /* RR_GDB_CONNECTION_H_ */\n" }, { "path": "src/GdbServerExpression.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"GdbServerExpression.h\"\n\n#include \"GdbServer.h\"\n#include \"Task.h\"\n#include \"core.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n#define WORKAROUND_GDB_BUGS\n\n// Extracted from\n// https://sourceware.org/gdb/current/onlinedocs/gdb/Bytecode-Descriptions.html\nenum Opcode {\n OP_float = 0x01,\n OP_add = 0x02,\n OP_sub = 0x03,\n OP_mul = 0x04,\n OP_div_signed = 0x05,\n OP_div_unsigned = 0x06,\n OP_rem_signed = 0x07,\n OP_rem_unsigned = 0x08,\n OP_lsh = 0x09,\n OP_rsh_signed = 0x0a,\n OP_rsh_unsigned = 0x0b,\n OP_trace = 0x0c,\n OP_trace_quick = 0x0d,\n OP_log_not = 0x0e,\n OP_bit_and = 0x0f,\n OP_bit_or = 0x10,\n OP_bit_xor = 0x11,\n OP_bit_not = 0x12,\n OP_equal = 0x13,\n OP_less_signed = 0x14,\n OP_less_unsigned = 0x15,\n OP_ext = 0x16,\n OP_ref8 = 0x17,\n OP_ref16 = 0x18,\n OP_ref32 = 0x19,\n OP_ref64 = 0x1a,\n OP_ref_float = 0x1b,\n OP_ref_double = 0x1c,\n OP_ref_long_double = 0x1d,\n OP_l_to_d = 0x1e,\n OP_d_to_l = 0x1f,\n OP_if_goto = 0x20,\n OP_goto = 0x21,\n OP_const8 = 0x22,\n OP_const16 = 0x23,\n OP_const32 = 0x24,\n OP_const64 = 0x25,\n OP_reg = 0x26,\n OP_end = 0x27,\n OP_dup = 0x28,\n OP_pop = 0x29,\n OP_zero_ext = 0x2a,\n OP_swap = 0x2b,\n OP_getv = 0x2c,\n OP_setv = 0x2d,\n OP_tracev = 0x2e,\n OP_tracenz = 0x2f,\n OP_trace16 = 0x30,\n OP_pick = 0x32,\n OP_rot = 0x33,\n OP_printf = 0x34,\n};\n\nstruct ExpressionState {\n typedef GdbServerExpression::Value Value;\n\n ExpressionState(const vector& bytecode)\n : bytecode(bytecode), pc(0), error(false), end(false) {}\n\n void set_error() { error = true; }\n\n // Methods set error to true if there's an error and return some sentinel\n // Value.\n Value pop() {\n if (stack.empty()) {\n set_error();\n return Value(-1);\n }\n Value v = stack.back();\n stack.pop_back();\n return v;\n }\n struct BinaryOperands {\n BinaryOperands(int64_t a = 0, int64_t b = 0) : a(a), b(b) {}\n int64_t a;\n int64_t b;\n };\n BinaryOperands pop_a_b() {\n int64_t b = pop().i;\n return BinaryOperands(pop().i, b);\n }\n int64_t nonzero(int64_t v) {\n if (!v) {\n set_error();\n return 1;\n }\n return v;\n }\n int64_t pop_a() { return pop().i; }\n void push(int64_t i) { stack.push_back(Value(i)); }\n template T fetch() {\n if (pc + sizeof(T) > bytecode.size()) {\n set_error();\n return T(-1);\n }\n T v = 0;\n for (size_t i = 0; i < sizeof(T); ++i) {\n v = (v << 8) | bytecode[pc + i];\n }\n pc += sizeof(T);\n return v;\n }\n template void load(Task* t) {\n uint64_t addr = pop().i;\n if (error) {\n // Don't do unnecessary syscalls if we're already in an error state.\n return;\n }\n bool ok = true;\n T v = t->read_mem(remote_ptr(addr), &ok);\n if (!ok) {\n set_error();\n return;\n }\n push(v);\n }\n void pick(size_t offset) {\n if (offset >= stack.size()) {\n set_error();\n return;\n }\n push(stack[stack.size() - 1 - offset].i);\n }\n\n void step(ReplayTask* t) {\n DEBUG_ASSERT(!error);\n BinaryOperands operands;\n switch (fetch()) {\n case OP_add:\n operands = pop_a_b();\n return push(operands.a + operands.b);\n case OP_sub:\n operands = pop_a_b();\n return push(operands.a - operands.b);\n case OP_mul:\n operands = pop_a_b();\n return push(operands.a * operands.b);\n case OP_div_signed:\n operands = pop_a_b();\n return push(operands.a / nonzero(operands.b));\n case OP_div_unsigned:\n operands = pop_a_b();\n return push(uint64_t(operands.a) / uint64_t(nonzero(operands.b)));\n case OP_rem_signed:\n operands = pop_a_b();\n return push(operands.a % nonzero(operands.b));\n case OP_rem_unsigned:\n operands = pop_a_b();\n return push(uint64_t(operands.a) % uint64_t(nonzero(operands.b)));\n case OP_lsh:\n operands = pop_a_b();\n return push(operands.a << operands.b);\n case OP_rsh_signed:\n operands = pop_a_b();\n return push(operands.a >> operands.b);\n case OP_rsh_unsigned:\n operands = pop_a_b();\n return push(uint64_t(operands.a) >> operands.b);\n case OP_log_not:\n return push(!pop_a());\n case OP_bit_and:\n operands = pop_a_b();\n return push(operands.a & operands.b);\n case OP_bit_or:\n operands = pop_a_b();\n return push(operands.a | operands.b);\n case OP_bit_xor:\n operands = pop_a_b();\n return push(operands.a ^ operands.b);\n case OP_bit_not:\n return push(~pop_a());\n case OP_equal:\n operands = pop_a_b();\n return push(operands.a == operands.b);\n case OP_less_signed:\n operands = pop_a_b();\n return push(operands.a < operands.b);\n case OP_less_unsigned:\n operands = pop_a_b();\n return push(uint64_t(operands.a) < uint64_t(operands.b));\n case OP_ext: {\n int64_t n = nonzero(fetch());\n if (n >= 64) {\n return;\n }\n int64_t a = pop_a();\n int64_t n_mask = (int64_t(1) << n) - 1;\n int sign_bit = (a >> (n - 1)) & 1;\n return push((sign_bit * ~n_mask) | (a & n_mask));\n }\n case OP_zero_ext: {\n int64_t n = fetch();\n if (n >= 64) {\n return;\n }\n int64_t a = pop_a();\n int64_t n_mask = (int64_t(1) << n) - 1;\n return push(a & n_mask);\n }\n case OP_ref8:\n return load(t);\n case OP_ref16:\n return load(t);\n case OP_ref32:\n return load(t);\n case OP_ref64:\n return load(t);\n case OP_dup:\n return pick(0);\n case OP_swap:\n operands = pop_a_b();\n push(operands.b);\n return push(operands.a);\n case OP_pop:\n pop_a();\n return;\n case OP_pick:\n return pick(fetch());\n case OP_rot: {\n int64_t c = pop_a();\n int64_t b = pop_a();\n int64_t a = pop_a();\n push(c);\n push(b);\n return push(a);\n }\n case OP_if_goto: {\n uint16_t offset = fetch();\n if (pop_a()) {\n pc = offset;\n }\n return;\n }\n case OP_goto:\n pc = fetch();\n return;\n case OP_const8:\n return push(fetch());\n case OP_const16:\n return push(fetch());\n case OP_const32:\n return push(fetch());\n case OP_const64:\n return push(fetch());\n case OP_reg: {\n GdbServerRegisterValue v = GdbServer::get_reg(t->regs(), t->extra_regs(),\n GdbServerRegister(fetch()));\n if (!v.defined) {\n set_error();\n return;\n }\n switch (v.size) {\n case 1:\n return push(v.value1);\n case 2:\n return push(v.value2);\n case 4:\n return push(v.value4);\n case 8:\n return push(v.value8);\n }\n set_error();\n return;\n }\n case OP_end:\n end = true;\n return;\n default:\n set_error();\n return;\n }\n }\n\n const vector& bytecode;\n vector stack;\n size_t pc;\n bool error;\n bool end;\n};\n\n#ifdef WORKAROUND_GDB_BUGS\n/* https://sourceware.org/bugzilla/show_bug.cgi?id=18617 means that\n * gdb generates incorrect operands for OP_ext and OP_zero_ext.\n * We work around this bug by generating all the alternative programs that gdb\n * maybe should have generated, and evaluating all of them. If they agree on\n * the result, we return that as the correct result, otherwise we return\n * failure.\n */\nstatic int count_variants(int bits) {\n int result = 1;\n if (bits > 8) {\n ++result;\n }\n if (bits > 16) {\n ++result;\n }\n if (bits > 32) {\n ++result;\n }\n return result;\n}\n\ntemplate \nstatic T fetch(const uint8_t* data, size_t size, size_t pc) {\n if (pc + sizeof(T) > size) {\n return T(-1);\n }\n T v = 0;\n for (size_t i = 0; i < sizeof(T); ++i) {\n v = (v << 8) | data[pc + i];\n }\n return v;\n}\n\nGdbServerExpression::GdbServerExpression(const uint8_t* data, size_t size) {\n vector instruction_starts;\n instruction_starts.resize(size);\n fill(instruction_starts.begin(), instruction_starts.end(), false);\n\n int64_t num_variants = 1;\n\n vector unvisited;\n unvisited.push_back(0);\n while (!unvisited.empty()) {\n size_t pc = unvisited.back();\n unvisited.pop_back();\n if (pc >= instruction_starts.size() || instruction_starts[pc]) {\n continue;\n }\n instruction_starts[pc] = true;\n switch (data[pc]) {\n case OP_ext:\n case OP_zero_ext:\n if (pc + 1 < size) {\n num_variants *= count_variants(data[pc + 1]);\n if (num_variants > 64) {\n // Too many variants, giving up on this expression\n return;\n }\n }\n unvisited.push_back(pc + 2);\n break;\n case OP_pick:\n case OP_const8:\n unvisited.push_back(pc + 2);\n break;\n case OP_if_goto:\n unvisited.push_back(fetch(data, size, pc + 1));\n unvisited.push_back(pc + 3);\n break;\n case OP_goto:\n unvisited.push_back(fetch(data, size, pc + 1));\n break;\n case OP_const16:\n case OP_reg:\n unvisited.push_back(pc + 3);\n break;\n case OP_const32:\n unvisited.push_back(pc + 5);\n break;\n case OP_const64:\n unvisited.push_back(pc + 9);\n break;\n case OP_end:\n break;\n default:\n unvisited.push_back(pc + 1);\n break;\n }\n }\n\n bytecode_variants.push_back(vector(data, data + size));\n for (size_t i = 0; i < size; ++i) {\n if (!instruction_starts[i]) {\n continue;\n }\n if ((data[i] == OP_ext || data[i] == OP_zero_ext) && i + 1 < size) {\n uint8_t bits = data[i + 1];\n vector> variants;\n for (auto& b : bytecode_variants) {\n // gdb perhaps should have used a smaller type width here --- 8, 16 or\n // 32 bits.\n if (bits > 8) {\n vector v = b;\n v[i + 1] = 8;\n variants.push_back(std::move(v));\n }\n if (bits > 16) {\n vector v = b;\n v[i + 1] = 16;\n variants.push_back(std::move(v));\n }\n if (bits > 32) {\n vector v = b;\n v[i + 1] = 32;\n variants.push_back(std::move(v));\n }\n variants.push_back(std::move(b));\n }\n bytecode_variants = std::move(variants);\n }\n }\n}\n#else\nGdbServerExpression::GdbServerExpression(const uint8_t* data, size_t size) {\n bytecode_variants.push_back(vector(data, data + size));\n}\n#endif\n\nbool GdbServerExpression::evaluate(ReplayTask* t, Value* result) const {\n if (bytecode_variants.empty()) {\n return false;\n }\n\n bool first = true;\n\n for (auto& b : bytecode_variants) {\n ExpressionState state(b);\n for (int steps = 0; !state.end; ++steps) {\n if (steps >= 10000 || state.error) {\n return false;\n }\n state.step(t);\n }\n Value v = state.pop();\n if (state.error) {\n return false;\n }\n if (first) {\n *result = v;\n first = false;\n } else if (*result != v) {\n return false;\n }\n }\n\n return true;\n}\n\n} // namespace rr\n" }, { "path": "src/GdbServerExpression.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_EXPRESSION_H_\n#define RR_GDB_EXPRESSION_H_\n\n#include \n#include \n\n#include \n\nnamespace rr {\n\nclass ReplayTask;\n\n/**\n * gdb has a simple bytecode language for writing expressions to be evaluated\n * in a remote target. This class implements evaluation of such expressions.\n * See https://sourceware.org/gdb/current/onlinedocs/gdb/Agent-Expressions.html\n */\nclass GdbServerExpression {\npublic:\n GdbServerExpression(const uint8_t* data, size_t size);\n\n struct Value {\n Value(int64_t i = 0) : i(i) {}\n bool operator==(const Value& v) { return i == v.i; }\n bool operator!=(const Value& v) { return !(*this == v); }\n int64_t i;\n };\n /**\n * If evaluation succeeds, store the final result in *result and return true.\n * Otherwise return false.\n */\n bool evaluate(ReplayTask* t, Value* result) const;\n\nprivate:\n /**\n * To work around gdb bugs, we may generate and evaluate multiple versions of\n * the same expression program.\n */\n std::vector> bytecode_variants;\n};\n\n} // namespace rr\n\n#endif // RR_GDB_EXPRESSION_H_\n" }, { "path": "src/GdbServerRegister.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_GDB_SERVER_REGISTER_H_\n#define RR_GDB_SERVER_REGISTER_H_\n\nnamespace rr {\n\n/**\n * This is the register numbering used by GDB.\n */\nenum GdbServerRegister {\n DREG_EAX,\n DREG_ECX,\n DREG_EDX,\n DREG_EBX,\n DREG_ESP,\n DREG_EBP,\n DREG_ESI,\n DREG_EDI,\n DREG_EIP,\n DREG_EFLAGS,\n DREG_CS,\n DREG_SS,\n DREG_DS,\n DREG_ES,\n DREG_FS,\n DREG_GS,\n DREG_FIRST_FXSAVE_REG,\n DREG_ST0 = DREG_FIRST_FXSAVE_REG,\n DREG_ST1,\n DREG_ST2,\n DREG_ST3,\n DREG_ST4,\n DREG_ST5,\n DREG_ST6,\n DREG_ST7,\n // These are the names GDB gives the registers.\n DREG_FCTRL,\n DREG_FSTAT,\n DREG_FTAG,\n DREG_FISEG,\n DREG_FIOFF,\n DREG_FOSEG,\n DREG_FOOFF,\n DREG_FOP,\n DREG_XMM0,\n DREG_XMM1,\n DREG_XMM2,\n DREG_XMM3,\n DREG_XMM4,\n DREG_XMM5,\n DREG_XMM6,\n DREG_XMM7,\n DREG_MXCSR,\n // XXX the last fxsave reg on *x86*\n DREG_LAST_FXSAVE_REG = DREG_MXCSR,\n DREG_ORIG_EAX,\n DREG_YMM0H,\n DREG_YMM1H,\n DREG_YMM2H,\n DREG_YMM3H,\n DREG_YMM4H,\n DREG_YMM5H,\n DREG_YMM6H,\n DREG_YMM7H,\n DREG_ZMM0H,\n DREG_ZMM1H,\n DREG_ZMM2H,\n DREG_ZMM3H,\n DREG_ZMM4H,\n DREG_ZMM5H,\n DREG_ZMM6H,\n DREG_ZMM7H,\n DREG_K0,\n DREG_K1,\n DREG_K2,\n DREG_K3,\n DREG_K4,\n DREG_K5,\n DREG_K6,\n DREG_K7,\n DREG_PKRU,\n DREG_NUM_LINUX_I386,\n // Last register we can find in user_regs_struct\n // (except for orig_eax).\n DREG_NUM_USER_REGS = DREG_GS + 1,\n\n // x86-64 register numbers\n DREG_RAX = 0,\n DREG_RBX,\n DREG_RCX,\n DREG_RDX,\n DREG_RSI,\n DREG_RDI,\n DREG_RBP,\n DREG_RSP,\n DREG_R8,\n DREG_R9,\n DREG_R10,\n DREG_R11,\n DREG_R12,\n DREG_R13,\n DREG_R14,\n DREG_R15,\n DREG_RIP,\n // Things get a little tricky here, because x86-64 has some registers\n // named identically to its x86 counterpart, but we've used the names\n // in the x86 register definitions above, and the numbers they need\n // to represent are different. Hence the unique names here.\n DREG_64_EFLAGS,\n DREG_64_CS,\n DREG_64_SS,\n DREG_64_DS,\n DREG_64_ES,\n DREG_64_FS,\n DREG_64_GS,\n DREG_64_FIRST_FXSAVE_REG,\n DREG_64_ST0 = DREG_64_FIRST_FXSAVE_REG,\n DREG_64_ST1,\n DREG_64_ST2,\n DREG_64_ST3,\n DREG_64_ST4,\n DREG_64_ST5,\n DREG_64_ST6,\n DREG_64_ST7,\n // These are the names GDB gives the registers.\n DREG_64_FCTRL,\n DREG_64_FSTAT,\n DREG_64_FTAG,\n DREG_64_FISEG,\n DREG_64_FIOFF,\n DREG_64_FOSEG,\n DREG_64_FOOFF,\n DREG_64_FOP,\n DREG_64_XMM0,\n DREG_64_XMM1,\n DREG_64_XMM2,\n DREG_64_XMM3,\n DREG_64_XMM4,\n DREG_64_XMM5,\n DREG_64_XMM6,\n DREG_64_XMM7,\n DREG_64_XMM8,\n DREG_64_XMM9,\n DREG_64_XMM10,\n DREG_64_XMM11,\n DREG_64_XMM12,\n DREG_64_XMM13,\n DREG_64_XMM14,\n DREG_64_XMM15,\n DREG_64_MXCSR,\n DREG_64_LAST_FXSAVE_REG = DREG_64_MXCSR,\n DREG_ORIG_RAX,\n DREG_FS_BASE,\n DREG_GS_BASE,\n DREG_64_YMM0H,\n DREG_64_YMM1H,\n DREG_64_YMM2H,\n DREG_64_YMM3H,\n DREG_64_YMM4H,\n DREG_64_YMM5H,\n DREG_64_YMM6H,\n DREG_64_YMM7H,\n DREG_64_YMM8H,\n DREG_64_YMM9H,\n DREG_64_YMM10H,\n DREG_64_YMM11H,\n DREG_64_YMM12H,\n DREG_64_YMM13H,\n DREG_64_YMM14H,\n DREG_64_YMM15H,\n DREG_64_XMM16,\n DREG_64_XMM17,\n DREG_64_XMM18,\n DREG_64_XMM19,\n DREG_64_XMM20,\n DREG_64_XMM21,\n DREG_64_XMM22,\n DREG_64_XMM23,\n DREG_64_XMM24,\n DREG_64_XMM25,\n DREG_64_XMM26,\n DREG_64_XMM27,\n DREG_64_XMM28,\n DREG_64_XMM29,\n DREG_64_XMM30,\n DREG_64_XMM31,\n DREG_64_YMM16H,\n DREG_64_YMM17H,\n DREG_64_YMM18H,\n DREG_64_YMM19H,\n DREG_64_YMM20H,\n DREG_64_YMM21H,\n DREG_64_YMM22H,\n DREG_64_YMM23H,\n DREG_64_YMM24H,\n DREG_64_YMM25H,\n DREG_64_YMM26H,\n DREG_64_YMM27H,\n DREG_64_YMM28H,\n DREG_64_YMM29H,\n DREG_64_YMM30H,\n DREG_64_YMM31H,\n DREG_64_ZMM0H,\n DREG_64_ZMM1H,\n DREG_64_ZMM2H,\n DREG_64_ZMM3H,\n DREG_64_ZMM4H,\n DREG_64_ZMM5H,\n DREG_64_ZMM6H,\n DREG_64_ZMM7H,\n DREG_64_ZMM8H,\n DREG_64_ZMM9H,\n DREG_64_ZMM10H,\n DREG_64_ZMM11H,\n DREG_64_ZMM12H,\n DREG_64_ZMM13H,\n DREG_64_ZMM14H,\n DREG_64_ZMM15H,\n DREG_64_ZMM16H,\n DREG_64_ZMM17H,\n DREG_64_ZMM18H,\n DREG_64_ZMM19H,\n DREG_64_ZMM20H,\n DREG_64_ZMM21H,\n DREG_64_ZMM22H,\n DREG_64_ZMM23H,\n DREG_64_ZMM24H,\n DREG_64_ZMM25H,\n DREG_64_ZMM26H,\n DREG_64_ZMM27H,\n DREG_64_ZMM28H,\n DREG_64_ZMM29H,\n DREG_64_ZMM30H,\n DREG_64_ZMM31H,\n // We've moved K0..K7 to here, because it simplifies offset calculation for XMM16/YMM16/HiZMM offsets\n // target description 64bit-avx512.xml also reflects this\n DREG_64_K0,\n DREG_64_K1,\n DREG_64_K2,\n DREG_64_K3,\n DREG_64_K4,\n DREG_64_K5,\n DREG_64_K6,\n DREG_64_K7,\n DREG_64_PKRU,\n DREG_NUM_LINUX_X86_64,\n // Last register we can find in user_regs_struct (except for orig_rax).\n DREG_64_NUM_USER_REGS = DREG_64_GS + 1,\n\n // aarch64-core.xml\n DREG_X0 = 0,\n DREG_X1,\n DREG_X2,\n DREG_X3,\n DREG_X4,\n DREG_X5,\n DREG_X6,\n DREG_X7,\n DREG_X8,\n DREG_X9,\n DREG_X10,\n DREG_X11,\n DREG_X12,\n DREG_X13,\n DREG_X14,\n DREG_X15,\n DREG_X16,\n DREG_X17,\n DREG_X18,\n DREG_X19,\n DREG_X20,\n DREG_X21,\n DREG_X22,\n DREG_X23,\n DREG_X24,\n DREG_X25,\n DREG_X26,\n DREG_X27,\n DREG_X28,\n DREG_X29,\n DREG_X30,\n DREG_SP,\n DREG_PC,\n DREG_CPSR,\n\n // aarch64-fpu.xml\n DREG_V0 = 34,\n DREG_V1,\n DREG_V2,\n DREG_V3,\n DREG_V4,\n DREG_V5,\n DREG_V6,\n DREG_V7,\n DREG_V8,\n DREG_V9,\n DREG_V10,\n DREG_V11,\n DREG_V12,\n DREG_V13,\n DREG_V14,\n DREG_V15,\n DREG_V16,\n DREG_V17,\n DREG_V18,\n DREG_V19,\n DREG_V20,\n DREG_V21,\n DREG_V22,\n DREG_V23,\n DREG_V24,\n DREG_V25,\n DREG_V26,\n DREG_V27,\n DREG_V28,\n DREG_V29,\n DREG_V30,\n DREG_V31,\n DREG_FPSR,\n DREG_FPCR,\n\n DREG_NUM_LINUX_AARCH64 = DREG_FPCR + 1,\n};\n\n} // namespace rr\n\n#endif /* RR_GDB_SERVER_REGISTER_H_ */\n" }, { "path": "src/HasTaskSet.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"HasTaskSet.h\"\n\n#include \"Task.h\"\n#include \"log.h\"\n\nnamespace rr {\n\nvoid HasTaskSet::insert_task(Task* t) {\n LOG(debug) << \"adding \" << t->tid << \" to task set \" << this;\n tasks.insert(t);\n}\n\nvoid HasTaskSet::erase_task(Task* t) {\n LOG(debug) << \"removing \" << t->tid << \" from task set \" << this;\n tasks.erase(t);\n}\n\nTask* HasTaskSet::first_running_task() const {\n for (Task* t : task_set()) {\n if (!t->already_exited() && !t->seen_ptrace_exit_event()) {\n return t;\n }\n }\n return nullptr;\n}\n\nTask* HasTaskSet::find_other_thread_group(Task* t) const {\n for (Task* tt : task_set()) {\n if (tt->thread_group() != t->thread_group()) {\n return tt;\n }\n }\n return nullptr;\n}\n\n} // namespace rr\n" }, { "path": "src/HasTaskSet.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_HASTASKSET_H_\n#define RR_HASTASKSET_H_\n\n#include \n\nnamespace rr {\n\nclass Task;\n\n/**\n * Base class for classes that manage a set of Tasks.\n */\nclass HasTaskSet {\npublic:\n // Has virtual methods, therefore must have virtual destructor\n virtual ~HasTaskSet() {}\n\n typedef std::set TaskSet;\n\n const TaskSet& task_set() const { return tasks; }\n\n virtual void insert_task(Task* t);\n virtual void erase_task(Task* t);\n bool has_task(Task* t) const { return tasks.find(t) != tasks.end(); }\n Task* find_other_thread_group(Task* t) const;\n Task* first_running_task() const;\n\nprotected:\n TaskSet tasks;\n};\n\n} // namespace rr\n\n#endif /* RR_HASTASKSET_H_ */\n" }, { "path": "src/HelpCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"main.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass HelpCommand : public Command {\npublic:\n virtual int run(std::vector& args) override;\n\nprotected:\n HelpCommand(const char* name, const char* help) : Command(name, help) {}\n\n static HelpCommand help1;\n static HelpCommand help2;\n static HelpCommand help3;\n};\n\nHelpCommand HelpCommand::help1(\"help\", \" rr help [command]\\n\");\nHelpCommand HelpCommand::help2(\"-h\", nullptr);\nHelpCommand HelpCommand::help3(\"--help\", nullptr);\n\nint HelpCommand::run(std::vector& args) {\n if (args.size() == 0) {\n print_usage(stdout);\n }\n\n Command* command = Command::command_for_name(args[0]);\n if (!command) {\n print_usage(stderr);\n }\n command->print_help(stdout);\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/LldbInitCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Command.h\"\n#include \"GdbServer.h\"\n#include \"launch_debugger.h\"\n#include \"main.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass LldbInitCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n LldbInitCommand(const char* name, const char* help) : Command(name, help) {}\n\n static LldbInitCommand singleton;\n};\n\nLldbInitCommand LldbInitCommand::singleton(\"lldbinit\", \" rr lldbinit\\n\");\n\nint LldbInitCommand::run(vector& args) {\n while (parse_global_option(args)) {\n }\n\n puts(\"# This is a Python script. Save it to a file and run it from LLDB using\");\n puts(\"# script exec(open('').read())\");\n puts(\"# or similar.\");\n fputs(lldb_init_script().c_str(), stdout);\n return 0;\n}\n\n} // namespace rr\n" }, { "path": "src/LsCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"Command.h\"\n#include \"main.h\"\n#include \"TraceStream.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass LsCommand : public Command {\npublic:\n virtual int run(vector& args);\n\nprotected:\n LsCommand(const char* name, const char* help) : Command(name, help) {}\n\n static LsCommand singleton;\n};\n\nLsCommand LsCommand::singleton(\n \"ls\", \" rr ls [OPTION]...\\n\"\n \" -l, --long-listing use a long listing format\\n\"\n \" (trace name | start time | size | command line)\\n\"\n \" -t, --sort-by-age, sort from newest to oldest\\n\"\n \" -r, --reverse, the sort order\\n\");\n\nstruct LsFlags {\n bool reverse;\n bool full_listing;\n bool sort_by_time;\n LsFlags() : reverse(false), full_listing(false), sort_by_time(false) {}\n};\n\nstatic bool parse_ls_arg(vector& args, LsFlags& flags) {\n if (parse_global_option(args)) {\n return true;\n }\n\n static const OptionSpec options[] = { { 'r', \"reverse\", NO_PARAMETER },\n { 'l', \"long-listing\", NO_PARAMETER },\n { 't', \"sort-by-age\", NO_PARAMETER } };\n ParsedOption opt;\n if (!Command::parse_option(args, options, &opt)) {\n return false;\n }\n\n switch (opt.short_name) {\n case 'r':\n flags.reverse = true;\n break;\n case 'l':\n flags.full_listing = true;\n break;\n case 't':\n flags.sort_by_time = true;\n break;\n default:\n assert(0 && \"Unknown option\");\n }\n\n return true;\n}\n\nstruct TraceInfo {\n string name;\n struct timespec ctime;\n string exit;\n\n TraceInfo(string in_name) : name(in_name) {}\n};\n\nstatic bool compare_by_name(const TraceInfo& at, const TraceInfo& bt) {\n auto a = at.name;\n auto b = bt.name;\n return lexicographical_compare(begin(a), end(a), begin(b), end(b));\n}\n\nstatic bool get_folder_size(string dir_name, string& size_str) {\n DIR* dir = opendir(dir_name.c_str());\n if (!dir) {\n cerr << \"Cannot open \" << dir_name << endl;\n return false;\n }\n\n size_t bytes = 0;\n while (struct dirent* ent = readdir(dir)) {\n string path = dir_name + \"/\" + ent->d_name;\n\n struct stat st;\n if (stat(path.c_str(), &st) == -1) {\n cerr << \"stat \" << path << \" failed\\n\";\n return false;\n }\n\n bytes += st.st_size;\n }\n closedir(dir);\n\n static const char suffixes[] = \" KMGT\";\n double size = bytes;\n size_t suffix_idx = 0;\n while (size >= 1000.0) {\n size /= 1024.0;\n suffix_idx++;\n }\n char suffix = suffixes[suffix_idx];\n\n ostringstream cvt;\n\n if (suffix == ' ') {\n cvt << bytes;\n } else if (size >= 10) {\n cvt << int(size) << suffix;\n } else {\n cvt << fixed << setprecision(1) << size << suffix;\n }\n\n size_str = cvt.str();\n return true;\n}\n\nstatic string get_exec_path(TraceReader& reader) {\n while (true) {\n TraceTaskEvent r = reader.read_task_event();\n if (r.type() == TraceTaskEvent::NONE) {\n break;\n }\n if (r.type() == TraceTaskEvent::EXEC) {\n return r.cmd_line()[0];\n }\n }\n return string();\n}\n\nstring find_exit_code(pid_t pid, const vector& events,\n size_t current_event,\n const map current_tid_to_pid);\n\nstatic int ls(const string& traces_dir, const LsFlags& flags, FILE* out) {\n DIR* dir = opendir(traces_dir.c_str());\n if (!dir) {\n fprintf(stderr, \"Cannot open %s\\n\", traces_dir.c_str());\n return 1;\n }\n\n const string cpu_lock = real_path(get_cpu_lock_file());\n const string full_traces_dir = real_path(traces_dir) + \"/\";\n vector traces;\n\n while (struct dirent* trace_dir = readdir(dir)) {\n if (full_traces_dir + trace_dir->d_name == cpu_lock) {\n continue;\n }\n if (!is_valid_trace_name(trace_dir->d_name)) {\n continue;\n }\n traces.emplace_back(TraceInfo(string(trace_dir->d_name)));\n if (flags.sort_by_time || flags.full_listing) {\n struct stat st;\n stat((traces_dir + \"/\" + trace_dir->d_name + \"/data\").c_str(), &st);\n traces.back().ctime = st.st_ctim;\n }\n\n if (flags.full_listing) {\n TraceReader trace(traces_dir + \"/\" + trace_dir->d_name);\n\n vector events;\n while (true) {\n TraceTaskEvent r = trace.read_task_event();\n if (r.type() == TraceTaskEvent::NONE) {\n break;\n }\n events.push_back(r);\n }\n\n if (events.empty() || events[0].type() != TraceTaskEvent::EXEC) {\n traces.back().exit = \"????\";\n continue;\n }\n\n map tid_to_pid;\n pid_t initial_tid = events[0].tid();\n tid_to_pid[initial_tid] = initial_tid;\n traces.back().exit = find_exit_code(initial_tid, events, 0, tid_to_pid);\n }\n }\n closedir(dir);\n\n if (flags.sort_by_time) {\n auto compare_by_time = [&](const TraceInfo& at,\n const TraceInfo& bt) -> bool {\n if (at.ctime.tv_sec == bt.ctime.tv_sec) {\n return at.ctime.tv_nsec < bt.ctime.tv_nsec;\n }\n return at.ctime.tv_sec < bt.ctime.tv_sec;\n };\n sort(traces.begin(), traces.end(), compare_by_time);\n } else {\n sort(traces.begin(), traces.end(), compare_by_name);\n }\n\n if (flags.reverse) {\n reverse(begin(traces), end(traces));\n };\n\n if (!flags.full_listing) {\n for (TraceInfo& t : traces) {\n cout << t.name << \"\\n\";\n }\n return 0;\n }\n\n int max_name_size =\n accumulate(traces.begin(), traces.end(), 0, [](int m, TraceInfo& t) {\n return max(m, static_cast(t.name.length()));\n });\n\n fprintf(out, \"%-*s %-19s %5s %6s %s\\n\", max_name_size,\n \"NAME\", \"WHEN\", \"SIZE\", \"EXIT\", \"CMD\");\n\n for (TraceInfo& t : traces) {\n // Record date & runtime estimates\n string data_file = traces_dir + \"/\" + t.name + \"/data\";\n char outstr[200];\n struct tm ctime_tm;\n if (localtime_r(&t.ctime.tv_sec, &ctime_tm)) {\n strftime(outstr, sizeof(outstr), \"%F %T\", &ctime_tm);\n } else {\n strcpy(outstr, \"\");\n }\n\n string folder_size = \"????\";\n string exe = \"(incomplete)\";\n string version_file = traces_dir + \"/\" + t.name + \"/version\";\n struct stat st;\n if (stat(version_file.c_str(), &st) != -1) {\n TraceReader reader(traces_dir + \"/\" + t.name);\n get_folder_size(reader.dir(), folder_size);\n exe = get_exec_path(reader);\n }\n\n fprintf(out, \"%-*s %s %5s %6s %s\\n\", max_name_size, t.name.c_str(),\n outstr, folder_size.c_str(), t.exit.c_str(), exe.c_str());\n }\n\n return 0;\n}\n\nint LsCommand::run(vector& args) {\n bool found_dir = false;\n string trace_dir;\n LsFlags flags;\n\n while (!args.empty()) {\n if (parse_ls_arg(args, flags)) {\n continue;\n }\n if (!found_dir && parse_optional_trace_dir(args, &trace_dir)) {\n found_dir = true;\n continue;\n }\n print_help(stderr);\n return 1;\n };\n\n if (!found_dir) {\n trace_dir = trace_save_dir();\n }\n return ls(trace_dir, flags, stdout);\n};\n\n} // namespace rr\n" }, { "path": "src/MagicSaveDataMonitor.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"MagicSaveDataMonitor.h\"\n\n#include \n\n#include \n\n#include \"RecordTask.h\"\n#include \"ReplayTask.h\"\n#include \"Session.h\"\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstatic string dump_path_data(Task* t, FrameTime global_time, const char* tag,\n const void* buf, size_t buf_len,\n remote_ptr addr) {\n string filename = format_dump_filename(t, global_time, tag);\n dump_binary_data(filename.c_str(), tag, (const uint32_t*)buf, buf_len / 4,\n addr);\n return filename;\n}\n\nstatic void notify_save_data_error(ReplayTask* t, remote_ptr addr,\n const void* rec_buf, size_t rec_buf_len,\n const void* rep_buf, size_t rep_buf_len) {\n FrameTime global_time = t->current_trace_frame().time();\n string rec_dump = dump_path_data(t, global_time, \"rec_save_data\",\n rec_buf, rec_buf_len, addr);\n string rep_dump = dump_path_data(t, global_time, \"rep_save_data\",\n rep_buf, rep_buf_len, addr);\n\n ASSERT(t,\n (rec_buf_len == rep_buf_len && !memcmp(rec_buf, rep_buf, rec_buf_len)))\n << \"Divergence in contents of 'tracee-save buffer'. Recording executed\\n\"\n \"\\n\"\n \" write(\"\n << RR_MAGIC_SAVE_DATA_FD << \", \" << addr << \", \" << rec_buf_len\n << \")\\n\"\n \"\\n\"\n \"and replay executed\\n\"\n \"\\n\"\n \" write(\"\n << RR_MAGIC_SAVE_DATA_FD << \", \" << addr << \", \" << rep_buf_len\n << \")\\n\"\n \"\\n\"\n \"The contents of the tracee-save buffers have been dumped to disk.\\n\"\n \"Compare them by using the following command\\n\"\n \"\\n\"\n \"$ diff -u \"\n << rec_dump << \" \" << rep_dump << \" >save-data-diverge.diff\\n\";\n}\n\nvoid MagicSaveDataMonitor::did_write(Task* t, const std::vector& ranges,\n LazyOffset&) {\n for (auto& r : ranges) {\n if (t->session().is_recording()) {\n static_cast(t)->record_remote(r.data.cast(),\n r.length);\n } else if (t->session().is_replaying()) {\n auto rt = static_cast(t);\n auto bytes = rt->read_mem(r.data.cast(), r.length);\n TraceReader::RawData rec;\n bool ok = rt->trace_reader().read_raw_data_for_frame(rec);\n ASSERT(t, ok);\n if (rec.data != bytes) {\n notify_save_data_error(rt, rec.addr, rec.data.data(), rec.data.size(),\n bytes.data(), bytes.size());\n }\n }\n }\n}\n\n} // namespace rr\n" }, { "path": "src/MagicSaveDataMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MAGIC_SAVE_DATA_MONITOR_H_\n#define RR_MAGIC_SAVE_DATA_MONITOR_H_\n\n#include \"FileMonitor.h\"\n\nnamespace rr {\n\n/**\n * A FileMonitor to track writes to RR_MAGIC_SAVE_DATA_FD.\n */\nclass MagicSaveDataMonitor : public FileMonitor {\npublic:\n MagicSaveDataMonitor() {}\n\n virtual Type type() override { return MagicSaveData; }\n\n virtual void did_write(Task* t, const std::vector& ranges,\n LazyOffset& offset) override;\n};\n\n} // namespace rr\n\n#endif /* RR_MAGIC_SAVE_DATA_MONITOR_H_ */\n" }, { "path": "src/MemoryRange.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MEMORY_RANGE_H_\n#define RR_MEMORY_RANGE_H_\n\n#include \"core.h\"\n#include \"log.h\"\n#include \"remote_ptr.h\"\n\nnamespace rr {\n\n/**\n * Range of memory addresses that can be used as a std::map key.\n */\nclass MemoryRange {\npublic:\n MemoryRange() {}\n MemoryRange(remote_ptr addr, size_t num_bytes)\n : start_(addr), end_(addr + num_bytes) {\n DEBUG_ASSERT(start_ <= end_);\n }\n MemoryRange(remote_ptr addr, remote_ptr end)\n : start_(addr), end_(end) {\n DEBUG_ASSERT(start_ <= end);\n }\n MemoryRange(const MemoryRange&) = default;\n MemoryRange& operator=(const MemoryRange&) = default;\n\n bool operator==(const MemoryRange& o) const {\n return start_ == o.start_ && end_ == o.end_;\n }\n bool operator<(const MemoryRange& o) const {\n return start_ != o.start_ ? start_ < o.start_ : end_ < o.end_;\n }\n\n /**\n * Return true iff |o| is an address range fully contained by\n * this.\n */\n bool contains(const MemoryRange& o) const {\n return start_ <= o.start_ && o.end_ <= end_;\n }\n bool contains(remote_ptr p) const { return start_ <= p && p < end_; }\n\n template bool contains(remote_ptr ptr, size_t count = 1) const {\n auto o_start_ = ptr.template cast();\n auto o_end_ = (ptr + count).template cast();\n return start_ <= o_start_ && o_end_ <= end_;\n }\n\n bool intersects(const MemoryRange& other) const {\n remote_ptr s = std::max(start_, other.start_);\n remote_ptr e = std::min(end_, other.end_);\n return s < e;\n }\n\n MemoryRange intersect(const MemoryRange& other) const {\n remote_ptr s = std::max(start_, other.start_);\n remote_ptr e = std::min(end_, other.end_);\n return MemoryRange(s, std::max(s, e));\n }\n\n remote_ptr start() const { return start_; }\n remote_ptr end() const { return end_; }\n size_t size() const { return end_ - start_; }\n\n static MemoryRange all() {\n return MemoryRange(remote_ptr(), remote_ptr(UINTPTR_MAX));\n }\n\n // XXX DO NOT USE\n void update_start(remote_ptr s) const {\n const_cast(this)->start_ = s;\n }\n\nprivate:\n remote_ptr start_;\n remote_ptr end_;\n};\n\ninline std::ostream& operator<<(std::ostream& o, const MemoryRange& m) {\n o << m.start() << \"-\" << m.end();\n return o;\n}\n\n} // namespace rr\n\n#endif /* RR_MEMORY_RANGE_H_ */\n" }, { "path": "src/MmappedFileMonitor.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"MmappedFileMonitor.h\"\n\n#include \"RecordSession.h\"\n#include \"RecordTask.h\"\n#include \"ReplayTask.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nMmappedFileMonitor::MmappedFileMonitor(Task* t, int fd) {\n ASSERT(t, !t->session().is_replaying());\n dead_ = false;\n auto stat = t->stat_fd(fd);\n device_ = stat.st_dev;\n inode_ = stat.st_ino;\n}\n\nMmappedFileMonitor::MmappedFileMonitor(Task* t, EmuFile::shr_ptr f) {\n ASSERT(t, t->session().is_replaying());\n\n dead_ = false;\n device_ = f->device();\n inode_ = f->inode();\n}\n\nvoid MmappedFileMonitor::did_write(Task* t, const std::vector& ranges,\n LazyOffset& offset) {\n // If there are no remaining mappings that we care about, those can't reappear\n // without going through mmap again, at which point this will be reset to\n // false.\n if (dead_) {\n return;\n }\n\n if (ranges.empty()) {\n return;\n }\n\n // Dead until proven otherwise\n dead_ = true;\n int64_t realized_offset = 0;\n\n bool is_replay = t->session().is_replaying();\n for (auto v : t->session().vms()) {\n for (const auto& m : v->maps()) {\n auto km = m.map;\n\n if (is_replay) {\n if (!m.emu_file || m.emu_file->device() != device_ ||\n m.emu_file->inode() != inode_) {\n continue;\n }\n } else {\n if (km.device() != device_ || km.inode() != inode_) {\n continue;\n }\n // If the mapping is MAP_PRIVATE then this write is dangerous\n // because it's unpredictable what will be seen in the mapping.\n // However, it could be OK if the application doesn't read from\n // this part of the mapping. Just optimistically assume this mapping\n // is not affected.\n if (!(km.flags() & MAP_SHARED)) {\n LOG(warn) << \"MAP_PRIVATE mapping affected by write\";\n continue;\n }\n }\n\n // We're discovering a mapping we care about\n if (dead_) {\n dead_ = false;\n realized_offset = offset.retrieve(true);\n }\n\n // stat matches.\n uint64_t mapping_offset = km.file_offset_bytes();\n int64_t local_offset = realized_offset;\n for (auto r : ranges) {\n remote_ptr start = km.start() + local_offset - mapping_offset;\n MemoryRange mr(start, r.length);\n if (km.intersects(mr)) {\n if (is_replay) {\n // If we're writing beyond the EmuFile's end, resize it.\n m.emu_file->ensure_size(local_offset + r.length);\n } else {\n ASSERT(t, !v->task_set().empty());\n // We will record multiple writes if the file is mapped multiple\n // times. This is inefficient --- one is sufficient --- but not\n // wrong.\n // Make sure we use a task for this address space. `t` might have\n // a different address space.\n for (auto tt : v->task_set()) {\n // If the task here has execed, we may not be able to record its\n // memory any longer, so loop through all tasks in this address\n // space in turn in case any *didn't* exec.\n if (!tt->already_exited() && static_cast(tt)->record_remote_fallible(km.intersect(mr)) > 0) {\n break;\n }\n }\n }\n }\n local_offset += r.length;\n }\n }\n }\n}\n\n} // namespace rr\n" }, { "path": "src/MmappedFileMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MMAPPED_FILE_MONITOR_H_\n#define RR_MMAPPED_FILE_MONITOR_H_\n\n#include \"EmuFs.h\"\n#include \"FileMonitor.h\"\n\n#include \n\nnamespace rr {\n\n/**\n * A FileMonitor to track writes to files that are mmapped in so they can be\n * replayed.\n */\nclass MmappedFileMonitor : public FileMonitor {\npublic:\n MmappedFileMonitor(Task* t, int fd);\n MmappedFileMonitor(Task* t, EmuFile::shr_ptr f);\n\n virtual Type type() override { return Mmapped; }\n void revive() { dead_ = false; }\n // If this write could potentially affect memory we need to PREVENT_SWITCH,\n // since the timing of the write is otherwise unpredictable from our\n // perspective.\n virtual Switchable will_write(Task*) override {\n return dead_ ? ALLOW_SWITCH : PREVENT_SWITCH;\n }\n\n /**\n * During recording, note writes to mapped segments.\n */\n virtual void did_write(Task* t, const std::vector& ranges,\n LazyOffset& offset) override;\n\nprivate:\n // Whether this monitor is still actively monitoring\n bool dead_;\n dev_t device_;\n ino_t inode_;\n};\n\n} // namespace rr\n\n#endif /* RR_MMAPPED_FILE_MONITOR_H_ */\n" }, { "path": "src/MonitoredSharedMemory.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"MonitoredSharedMemory.h\"\n\n#include \n\n#include \"AddressSpace.h\"\n#include \"AutoRemoteSyscalls.h\"\n#include \"RecordTask.h\"\n#include \"Session.h\"\n#include \"core.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nMonitoredSharedMemory::~MonitoredSharedMemory() { munmap(real_mem, size); }\n\nstatic const char dconf_suffix[] = \"/dconf/user\";\n\nvoid MonitoredSharedMemory::maybe_monitor(RecordTask* t,\n const string& file_name,\n const AddressSpace::Mapping& m,\n int tracee_fd, uint64_t offset) {\n size_t dconf_suffix_len = sizeof(dconf_suffix) - 1;\n if (file_name.size() < dconf_suffix_len ||\n file_name.substr(file_name.size() - dconf_suffix_len) != dconf_suffix) {\n return;\n }\n\n AutoRemoteSyscalls remote(t);\n\n ScopedFd fd = remote.retrieve_fd(tracee_fd);\n if (!fd.is_open()) {\n // Tracee died\n return;\n }\n uint8_t* real_mem = static_cast(\n mmap(NULL, m.map.size(), PROT_READ, MAP_SHARED, fd, offset));\n ASSERT(t, real_mem != MAP_FAILED);\n\n auto result = shared_ptr(\n new MonitoredSharedMemory(real_mem, m.map.size()));\n\n AddressSpace::Mapping shared =\n Session::steal_mapping(remote, m, std::move(result));\n // m may be invalid now\n if (!shared.local_addr) {\n // tracee died\n return;\n }\n memcpy(shared.local_addr, real_mem, shared.map.size());\n}\n\nMonitoredSharedMemory::shr_ptr MonitoredSharedMemory::subrange(uintptr_t,\n uintptr_t) {\n DEBUG_ASSERT(false && \"Subranges not supported yet!\");\n return nullptr;\n}\n\nvoid MonitoredSharedMemory::check_all(RecordTask* t) {\n vector> addrs;\n for (auto a : t->vm()->monitored_addrs()) {\n addrs.push_back(a);\n }\n for (auto a : addrs) {\n auto m = t->vm()->mapping_of(a);\n if (m.monitored_shared_memory) {\n m.monitored_shared_memory->check_for_changes(t, m);\n }\n }\n}\n\nvoid MonitoredSharedMemory::check_for_changes(RecordTask* t,\n AddressSpace::Mapping& m) {\n ASSERT(t, m.map.size() == size);\n if (!m.local_addr) {\n // reestablish local mapping after a fork or whatever\n AutoRemoteSyscalls remote(t);\n auto msm = m.monitored_shared_memory;\n m = Session::recreate_shared_mmap(remote, m, Session::DISCARD_CONTENTS,\n std::move(msm));\n if (!m.local_addr) {\n // Tracee died.\n return;\n }\n }\n if (!memcmp(m.local_addr, real_mem, size)) {\n return;\n }\n memcpy(m.local_addr, real_mem, size);\n t->record_local(m.map.start(), size, real_mem);\n}\n}\n" }, { "path": "src/MonitoredSharedMemory.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MONITORED_SHARED_MEMORY_H_\n#define RR_MONITORED_SHARED_MEMORY_H_\n\n#include \n\n#include \"AddressSpace.h\"\n\nnamespace rr {\n\nclass RecordTask;\n\n/**\n * Support tracees that share memory read-only with a non-tracee that\n * writes to the memory. Currently this just supports limited cases that\n * suffice for dconf: no remapping, coalescing or splitting of the memory is\n * allowed (|subrange| below just asserts). It doesn't handle mappings where\n * the mapping has more pages than the file.\n *\n * After such memory is mapped in the tracee, we also map it in rr at |real_mem|\n * and replace the tracee's mapping with a \"shadow buffer\" that's only shared\n * with rr. Then periodically rr reads the real memory, and if it doesn't match\n * the shadow buffer, we update the shadow buffer with the new values and\n * record that we did so.\n *\n * Currently we check the real memory after each syscall exit. This ensures\n * that if the tracee is woken up by some IPC mechanism (or after sched_yield),\n * it will get a chance to see updated memory values.\n */\nclass MonitoredSharedMemory {\npublic:\n ~MonitoredSharedMemory();\n\n typedef std::shared_ptr shr_ptr;\n\n static void maybe_monitor(RecordTask* t, const std::string& file_name,\n const AddressSpace::Mapping& m, int tracee_fd,\n uint64_t offset);\n\n static void check_all(RecordTask* t);\n\n shr_ptr subrange(uintptr_t start, uintptr_t size);\n\nprivate:\n void check_for_changes(RecordTask* t, AddressSpace::Mapping& m);\n\n MonitoredSharedMemory(uint8_t* real_mem, size_t size)\n : real_mem(real_mem), size(size) {}\n uint8_t* real_mem;\n size_t size;\n};\n\n} // namespace rr\n\n#endif /* RR_MONITORED_SHARED_MEMORY_H_ */\n" }, { "path": "src/Monkeypatcher.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Monkeypatcher.h\"\n\n#include \n#include \n#include \n\n#include \n\n#include \"AddressSpace.h\"\n#include \"AutoRemoteSyscalls.h\"\n#include \"ElfReader.h\"\n#include \"Flags.h\"\n#include \"RecordSession.h\"\n#include \"RecordTask.h\"\n#include \"ReplaySession.h\"\n#include \"ScopedFd.h\"\n#include \"core.h\"\n#include \"kernel_abi.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n#include \"AssemblyTemplates.generated\"\n\nstatic void write_and_record_bytes(RecordTask* t, remote_ptr child_addr,\n size_t size, const void* buf, bool* ok = nullptr) {\n t->write_bytes_helper(child_addr, size, buf, ok);\n if (!ok || *ok) {\n t->record_local(child_addr, size, buf);\n }\n}\n\ntemplate \nstatic void write_and_record_bytes(RecordTask* t, remote_ptr child_addr,\n const uint8_t (&buf)[N], bool* ok = nullptr) {\n write_and_record_bytes(t, child_addr, N, buf, ok);\n}\n\ntemplate \nstatic void write_and_record_mem(RecordTask* t, remote_ptr child_addr,\n const T* val, int count) {\n t->write_bytes_helper(child_addr, sizeof(*val) * count,\n static_cast(val));\n t->record_local(child_addr, sizeof(T) * count, val);\n}\n\n/**\n * RecordSession sets up an LD_PRELOAD environment variable with an entry\n * SYSCALLBUF_LIB_FILENAME_PADDED (and, if enabled, an LD_AUDIT environment\n * variable with an entry RTLDAUDIT_LIB_FILENAME_PADDED) which is big enough to\n * hold either the 32-bit or 64-bit preload/audit library file names.\n * Immediately after exec we enter this function, which patches the environment\n * variable value with the correct library name for the task's architecture.\n *\n * It's possible for this to fail if a tracee alters the LD_PRELOAD value\n * and then does an exec. That's just too bad. If we ever have to handle that,\n * we should modify the environment passed to the exec call. This function\n * failing isn't necessarily fatal; a tracee might not rely on the functions\n * overridden by the preload library, or might override them itself (e.g.\n * because we're recording an rr replay).\n */\n#define setup_library_path(arch, env_var, soname, task) \\\n setup_library_path_arch(task, env_var, soname ## _BASE, \\\n soname ## _PADDED, soname ## _32)\n\ntemplate \nstatic void setup_library_path_arch(RecordTask* t, const char* env_var,\n const char* soname_base,\n const char* soname_padded,\n const char* soname_32) {\n const char* lib_name =\n sizeof(typename Arch::unsigned_word) < sizeof(uintptr_t)\n ? soname_32\n : soname_padded;\n auto env_assignment = string(env_var) + \"=\";\n\n auto p = t->regs().sp().cast();\n auto argc = t->read_mem(p);\n p += 1 + argc + 1; // skip argc, argc parameters, and trailing NULL\n while (true) {\n auto envp = t->read_mem(p);\n if (!envp) {\n LOG(debug) << env_var << \" not found\";\n return;\n }\n string env = t->read_c_str(envp);\n if (env.find(env_assignment) != 0) {\n ++p;\n continue;\n }\n size_t lib_pos = env.find(soname_base);\n if (lib_pos == string::npos) {\n LOG(debug) << soname_base << \" not found in \" << env_var;\n return;\n }\n size_t next_colon = env.find(':', lib_pos);\n if (next_colon != string::npos) {\n while ((next_colon + 1 < env.length()) &&\n (env[next_colon + 1] == ':' || env[next_colon + 1] == 0)) {\n ++next_colon;\n }\n if (next_colon + 1 <\n lib_pos + sizeof(soname_padded) - 1) {\n LOG(debug) << \"Insufficient space for \" << lib_name\n << \" in \" << env_var << \" before next ':'\";\n return;\n }\n }\n if (env.length() < lib_pos + sizeof(soname_padded) - 1) {\n LOG(debug) << \"Insufficient space for \" << lib_name\n << \" in \" << env_var << \" before end of string\";\n return;\n }\n remote_ptr dest = envp + lib_pos;\n write_and_record_mem(t, dest.cast(), lib_name, strlen(soname_padded));\n return;\n }\n}\n\ntemplate static void setup_preload_library_path(RecordTask* t) {\n static_assert(sizeof(SYSCALLBUF_LIB_FILENAME_PADDED) ==\n sizeof(SYSCALLBUF_LIB_FILENAME_32),\n \"filename length mismatch\");\n setup_library_path(Arch, \"LD_PRELOAD\", SYSCALLBUF_LIB_FILENAME, t);\n}\n\ntemplate static void setup_audit_library_path(RecordTask* t) {\n static_assert(sizeof(RTLDAUDIT_LIB_FILENAME_PADDED) ==\n sizeof(RTLDAUDIT_LIB_FILENAME_32),\n \"filename length mismatch\");\n if (t->session().use_audit()) {\n setup_library_path(Arch, \"LD_AUDIT\", RTLDAUDIT_LIB_FILENAME, t);\n }\n}\n\nvoid Monkeypatcher::init_dynamic_syscall_patching(\n RecordTask* t, int syscall_patch_hook_count,\n remote_ptr syscall_patch_hooks) {\n if (syscall_patch_hook_count && syscall_hooks.empty()) {\n syscall_hooks = t->read_mem(syscall_patch_hooks, syscall_patch_hook_count);\n }\n}\n\ntemplate \nstatic bool patch_syscall_with_hook_arch(Monkeypatcher& patcher, RecordTask* t,\n const syscall_patch_hook& hook,\n remote_code_ptr ip_of_instruction,\n size_t instruction_length,\n uint32_t fake_syscall_number);\n\ntemplate \nstatic void substitute(uint8_t* buffer, uint64_t return_addr,\n uint32_t trampoline_relative_addr);\n\ntemplate \nstatic void substitute_extended_jump(uint8_t* buffer, uint64_t patch_addr,\n uint64_t return_addr,\n uint64_t target_addr,\n uint32_t fake_syscall_number);\n\ntemplate <>\nvoid substitute_extended_jump(\n uint8_t* buffer, uint64_t patch_addr, uint64_t return_addr,\n uint64_t target_addr, uint32_t) {\n int64_t offset =\n target_addr -\n (patch_addr + X86SyscallStubExtendedJump::trampoline_relative_addr_end);\n // An offset that appears to be > 2GB is OK here, since EIP will just\n // wrap around.\n X86SyscallStubExtendedJump::substitute(buffer, (uint32_t)return_addr,\n (uint32_t)offset);\n}\n\ntemplate <>\nvoid substitute_extended_jump(\n uint8_t* buffer, uint64_t, uint64_t return_addr, uint64_t target_addr,\n uint32_t) {\n X64SyscallStubExtendedJump::substitute(buffer, (uint32_t)return_addr,\n (uint32_t)(return_addr >> 32),\n target_addr);\n}\n\ntemplate <>\nvoid substitute_extended_jump(\n uint8_t* buffer, uint64_t patch_addr, uint64_t return_addr,\n uint64_t target_addr, uint32_t fake_syscall_number) {\n int64_t offset =\n target_addr -\n (patch_addr + X86SyscallStubExtendedJump::trampoline_relative_addr_end);\n // An offset that appears to be > 2GB is OK here, since EIP will just\n // wrap around.\n X86TrapInstructionStubExtendedJump::substitute(buffer, (uint32_t)return_addr,\n fake_syscall_number, (uint32_t)offset);\n}\n\ntemplate <>\nvoid substitute_extended_jump(\n uint8_t* buffer, uint64_t, uint64_t return_addr, uint64_t target_addr,\n uint32_t fake_syscall_number) {\n X64TrapInstructionStubExtendedJump::substitute(buffer, (uint32_t)return_addr,\n (uint32_t)(return_addr >> 32),\n fake_syscall_number,\n target_addr);\n}\n\n/**\n * Allocate an extended jump in an extended jump page and return its address.\n * The resulting address must be within 2G of from_end, and the instruction\n * there must jump to to_start.\n */\ntemplate \nstatic remote_ptr allocate_extended_jump_x86ish(\n RecordTask* t, vector& pages,\n remote_ptr from_end) {\n Monkeypatcher::ExtendedJumpPage* page = nullptr;\n for (auto& p : pages) {\n remote_ptr page_jump_start = p.addr + p.allocated;\n int64_t offset = page_jump_start - from_end;\n if ((int32_t)offset == offset &&\n p.allocated + ExtendedJumpPatch::size <= page_size()) {\n page = &p;\n break;\n }\n }\n\n if (!page) {\n // We're looking for a gap of three pages --- one page to allocate and\n // a page on each side as a guard page.\n uint32_t required_space = 3 * page_size();\n remote_ptr free_mem =\n t->vm()->find_free_memory(t, required_space,\n // Find free space after the patch site.\n t->vm()->mapping_of(from_end).map.start());\n if (!free_mem) {\n LOG(debug) << \"Can't find free memory anywhere after the jump\";\n return nullptr;\n }\n\n remote_ptr addr = (free_mem + page_size()).cast();\n int64_t offset = addr - from_end;\n if ((int32_t)offset != offset) {\n LOG(debug) << \"Can't find space close enough for the jump\";\n return nullptr;\n }\n\n {\n AutoRemoteSyscalls remote(t);\n int prot = PROT_READ | PROT_EXEC;\n int flags = MAP_ANONYMOUS | MAP_FIXED | MAP_PRIVATE;\n auto ret = remote.infallible_mmap_syscall_if_alive(addr, page_size(), prot, flags, -1, 0);\n if (!ret) {\n /* Tracee died */\n return nullptr;\n }\n KernelMapping recorded(addr, addr + page_size(), string(),\n KernelMapping::NO_DEVICE, KernelMapping::NO_INODE,\n prot, flags);\n t->vm()->map(t, addr, page_size(), prot, flags, 0, string(),\n KernelMapping::NO_DEVICE, KernelMapping::NO_INODE, nullptr,\n &recorded);\n t->vm()->mapping_flags_of(addr) |= AddressSpace::Mapping::IS_PATCH_STUBS;\n t->trace_writer().write_mapped_region(t, recorded, recorded.fake_stat(),\n recorded.fsname(),\n vector(),\n TraceWriter::PATCH_MAPPING);\n }\n\n pages.push_back(Monkeypatcher::ExtendedJumpPage(addr));\n page = &pages.back();\n }\n\n remote_ptr jump_addr = page->addr + page->allocated;\n page->allocated += ExtendedJumpPatch::size;\n return jump_addr;\n}\n\n/**\n * Encode the standard movz|movk sequence for moving constant `v` into register `reg`\n */\nstatic void encode_immediate_aarch64(std::vector &buff,\n uint8_t reg, uint64_t v)\n{\n DEBUG_ASSERT(reg < 31);\n const uint32_t movz_inst = 0xd2800000;\n const uint32_t movk_inst = 0xf2800000;\n uint32_t mov_inst = movz_inst;\n for (int lsl = 3; lsl >= 0; lsl--) {\n uint32_t bits = (v >> (lsl * 16)) & 0xffff;\n if (bits == 0 && !(lsl == 0 && mov_inst == movz_inst)) {\n // Skip zero bits unless it's the only instruction, i.e. v == 0\n continue;\n }\n // movz|movk x[reg], #bits, LSL #lsl\n buff.push_back(mov_inst | (uint32_t(lsl) << 21) | (bits << 5) | reg);\n mov_inst = movk_inst;\n }\n}\n\n/**\n * Encode the following assembly.\n *\n * cmp x8, 1024\n * b.hi .Lnosys\n * movk x8, preload_thread_locals >> 16, lsl 16\n * stp x15, x30, [x8, stub_scratch_2 - preload_thread_locals]\n * movz x30, #:abs_g3:_syscall_hook_trampoline\n * movk x30, #:abs_g2_nc:_syscall_hook_trampoline\n * movk x30, #:abs_g1_nc:_syscall_hook_trampoline\n * movk x30, #:abs_g0_nc:_syscall_hook_trampoline // Might be shorter depending on the address\n * blr x30\n * ldp x15, x30, [x15]\n.Lreturn:\n * b syscall_return_address\n.Lnosys:\n * svc 0x0 // the test relies on invalid syscall triggering an event.\n * // mov x0, -ENOSYS\n * b .Lreturn\n * .long \n *\n * And return the instruction index of `.Lreturn`.\n * The branch instruction following that label will not be encoded\n * since it depends on the address of this code.\n */\nstatic uint32_t encode_extended_jump_aarch64(std::vector &buff,\n uint64_t target, uint64_t return_addr,\n uint32_t *_retaddr_idx = nullptr)\n{\n // cmp x8, 1024\n buff.push_back(0xf110011f);\n uint32_t b_hi_idx = buff.size();\n buff.push_back(0); // place holder\n // movk x8, preload_thread_locals >> 16, lsl 16\n buff.push_back(0xf2ae0028);\n // stp x15, x30, [x8, #104]\n buff.push_back(0xa906f90f);\n encode_immediate_aarch64(buff, 30, target);\n // blr x30\n buff.push_back(0xd63f03c0);\n // ldp x15, x30, [x15]\n buff.push_back(0xa94079ef);\n uint32_t ret_idx = buff.size();\n buff.push_back(0); // place holder\n // b.hi . + (ret_inst + 4 - .)\n buff[b_hi_idx] = 0x54000000 | ((ret_idx + 1 - b_hi_idx) << 5) | 0x8;\n // movn x0, (ENOSYS - 1), i.e. mov x0, -ENOSYS\n // buff.push_back(0x92800000 | ((ENOSYS - 1) << 5) | 0);\n buff.push_back(0xd4000001); // svc 0\n // b .-2\n buff.push_back(0x17fffffe);\n uint32_t retaddr_idx = buff.size();\n if (_retaddr_idx)\n *_retaddr_idx = retaddr_idx;\n buff.resize(retaddr_idx + 2);\n memcpy(&buff[retaddr_idx], &return_addr, 8);\n return ret_idx;\n}\n\n// b and bl has a 26bit signed immediate in unit of 4 bytes\nconstexpr int32_t aarch64_b_max_offset = ((1 << 25) - 1) * 4;\nconstexpr int32_t aarch64_b_min_offset = (1 << 25) * -4;\n\nstatic remote_ptr allocate_extended_jump_aarch64(\n RecordTask* t, vector& pages,\n remote_ptr svc_ip, uint64_t to, std::vector &inst_buff) {\n uint64_t return_addr = svc_ip.as_int() + 4;\n auto ret_idx = encode_extended_jump_aarch64(inst_buff, to, return_addr);\n auto total_patch_size = inst_buff.size() * 4;\n\n Monkeypatcher::ExtendedJumpPage* page = nullptr;\n\n // There are two jumps we need to worry about for the offset\n // (actually 3 since there's also the jump back after unpatching\n // but the requirement for that is always more relaxed than the combination\n // of these two),\n // the jump to the stub and the jump back.\n // The jump to the stub has offset `stub - syscall` and the jump back has offset\n // `syscall + 4 - (stub + ret_idx * 4)`\n // We need to make sure both are within the offset range so\n // * aarch64_b_min_offset <= stub - syscall <= aarch64_b_max_offset\n // * aarch64_b_min_offset <= syscall + 4 - (stub + ret_idx * 4) <= aarch64_b_max_offset\n // or\n // * aarch64_b_min_offset <= stub - syscall <= aarch64_b_max_offset\n // * -aarch64_b_max_offset + 4 - ret_idx * 4 <= stub - syscall <= -aarch64_b_min_offset + 4 - ret_idx * 4\n\n int64_t patch_offset_min = std::max(aarch64_b_min_offset,\n -aarch64_b_max_offset + 4 - int(ret_idx) * 4);\n int64_t patch_offset_max = std::min(aarch64_b_max_offset,\n -aarch64_b_min_offset + 4 - int(ret_idx) * 4);\n for (auto& p : pages) {\n remote_ptr page_jump_start = p.addr + p.allocated;\n int64_t offset = page_jump_start - svc_ip;\n if (offset <= patch_offset_max && offset >= patch_offset_min &&\n p.allocated + total_patch_size <= page_size()) {\n page = &p;\n break;\n }\n }\n\n if (!page) {\n // We're looking for a gap of three pages --- one page to allocate and\n // a page on each side as a guard page.\n uint32_t required_space = 3 * page_size();\n remote_ptr free_mem =\n t->vm()->find_free_memory(t, required_space,\n // Find free space after the patch site.\n t->vm()->mapping_of(svc_ip).map.start());\n if (!free_mem) {\n LOG(debug) << \"Can't find free memory anywhere after the jump\";\n return nullptr;\n }\n\n remote_ptr addr = (free_mem + page_size()).cast();\n int64_t offset = addr - svc_ip;\n if (offset > patch_offset_max || offset < patch_offset_min) {\n LOG(debug) << \"Can't find space close enough for the jump\";\n return nullptr;\n }\n\n {\n AutoRemoteSyscalls remote(t);\n int prot = PROT_READ | PROT_EXEC;\n int flags = MAP_ANONYMOUS | MAP_FIXED | MAP_PRIVATE;\n auto ret = remote.infallible_mmap_syscall_if_alive(addr, page_size(), prot, flags, -1, 0);\n if (!ret) {\n /* Tracee died */\n return nullptr;\n }\n KernelMapping recorded(addr, addr + page_size(), string(),\n KernelMapping::NO_DEVICE, KernelMapping::NO_INODE,\n prot, flags);\n t->vm()->map(t, addr, page_size(), prot, flags, 0, string(),\n KernelMapping::NO_DEVICE, KernelMapping::NO_INODE, nullptr,\n &recorded);\n t->vm()->mapping_flags_of(addr) |= AddressSpace::Mapping::IS_PATCH_STUBS;\n t->trace_writer().write_mapped_region(t, recorded, recorded.fake_stat(),\n recorded.fsname(),\n vector(),\n TraceWriter::PATCH_MAPPING);\n }\n\n pages.push_back(Monkeypatcher::ExtendedJumpPage(addr));\n page = &pages.back();\n }\n\n remote_ptr jump_addr = page->addr + page->allocated;\n\n const uint64_t reverse_jump_addr = jump_addr.as_int() + ret_idx * 4;\n const int64_t reverse_offset = int64_t(return_addr - reverse_jump_addr);\n const uint32_t offset_imm26 = (reverse_offset >> 2) & 0x03ffffff;\n inst_buff[ret_idx] = 0x14000000 | offset_imm26;\n\n page->allocated += total_patch_size;\n\n return jump_addr;\n}\n\nbool Monkeypatcher::is_jump_stub_instruction(remote_code_ptr ip, bool include_safearea) {\n remote_ptr pp = ip.to_data_ptr();\n auto it = syscallbuf_stubs.upper_bound(pp);\n if (it == syscallbuf_stubs.begin()) {\n return false;\n }\n --it;\n auto begin = it->first;\n auto end = begin + it->second.size;\n if (!include_safearea) {\n begin += it->second.safe_prefix;\n end -= it->second.safe_suffix;\n }\n return begin <= pp && pp < end;\n}\n\nremote_code_ptr Monkeypatcher::get_jump_stub_exit_breakpoint(remote_code_ptr ip,\n RecordTask *t) {\n if (t->arch() != aarch64) {\n return nullptr;\n }\n remote_ptr pp = ip.to_data_ptr();\n auto it = syscallbuf_stubs.upper_bound(pp);\n if (it == syscallbuf_stubs.begin()) {\n return nullptr;\n }\n --it;\n auto bp = it->first + it->second.size - it->second.safe_suffix;\n if (pp == bp || pp == bp - 4) {\n return remote_code_ptr(bp.as_int());\n }\n return nullptr;\n}\n\nstatic bool hook_can_ignore_interfering_branches(const syscall_patch_hook& hook, size_t jump_patch_size) {\n return hook.patch_region_length >= jump_patch_size &&\n (hook.flags & (PATCH_IS_MULTIPLE_INSTRUCTIONS |\n PATCH_IS_NOP_INSTRUCTIONS |\n PATCH_NO_MATCH_TRAILING_4_BYTES)) == PATCH_IS_NOP_INSTRUCTIONS;\n}\n\n/**\n * Some functions make system calls while storing local variables in memory\n * below the stack pointer. We need to decrement the stack pointer by\n * some \"safety zone\" amount to get clear of those variables before we make\n * a call instruction. So, we allocate a stub per patched callsite, and jump\n * from the callsite to the stub. The stub decrements the stack pointer,\n * calls the appropriate syscall hook function, reincrements the stack pointer,\n * and jumps back to immediately after the patched callsite.\n *\n * It's important that gdb stack traces work while a thread is stopped in the\n * syscallbuf code. To ensure that the above manipulations don't foil gdb's\n * stack walking code, we add CFI data to all the stubs. To ease that, the\n * stubs are written in assembly and linked into the preload library.\n *\n * On x86-64 with ASLR, we need to be able to patch a call to a stub from\n * sites more than 2^31 bytes away. We only have space for a 5-byte jump\n * instruction. So, we allocate \"extender pages\" --- pages of memory within\n * 2GB of the patch site, that contain the stub code. We don't really need this\n * on x86, but we do it there too for consistency.\n *\n * If fake_syscall_number > 0 then we'll ensure AX is set to that number\n * by the stub code.\n */\ntemplate \nstatic bool patch_syscall_with_hook_x86ish(Monkeypatcher& patcher,\n RecordTask* t,\n const syscall_patch_hook& hook,\n remote_code_ptr ip_of_instruction,\n size_t instruction_length,\n uint32_t fake_syscall_number) {\n size_t patch_region_size = instruction_length + hook.patch_region_length;\n // We're patching in a relative jump, so we need to compute the offset from\n // the end of the jump to our actual destination.\n remote_ptr jump_patch_start = ip_of_instruction.to_data_ptr();\n if (hook.flags & PATCH_SYSCALL_INSTRUCTION_IS_LAST) {\n jump_patch_start -= hook.patch_region_length;\n }\n remote_ptr jump_patch_end = jump_patch_start + JumpPatch::size;\n remote_ptr return_addr =\n jump_patch_start + patch_region_size;\n\n remote_ptr extended_jump_start;\n if (fake_syscall_number) {\n extended_jump_start = allocate_extended_jump_x86ish(\n t, patcher.extended_jump_pages, jump_patch_end);\n } else {\n extended_jump_start = allocate_extended_jump_x86ish(\n t, patcher.extended_jump_pages, jump_patch_end);\n }\n if (extended_jump_start.is_null()) {\n return false;\n }\n\n if (fake_syscall_number) {\n uint8_t stub_patch[FakeSyscallExtendedJumpPatch::size];\n substitute_extended_jump(stub_patch,\n extended_jump_start.as_int(),\n return_addr.as_int(),\n hook.hook_address,\n fake_syscall_number);\n write_and_record_bytes(t, extended_jump_start, stub_patch);\n\n patcher.syscallbuf_stubs[extended_jump_start] = { &hook, FakeSyscallExtendedJumpPatch::size };\n } else {\n uint8_t stub_patch[ExtendedJumpPatch::size];\n substitute_extended_jump(stub_patch,\n extended_jump_start.as_int(),\n return_addr.as_int(),\n hook.hook_address,\n 0);\n write_and_record_bytes(t, extended_jump_start, stub_patch);\n\n patcher.syscallbuf_stubs[extended_jump_start] = { &hook, ExtendedJumpPatch::size };\n }\n\n intptr_t jump_offset = extended_jump_start - jump_patch_end;\n int32_t jump_offset32 = (int32_t)jump_offset;\n ASSERT(t, jump_offset32 == jump_offset)\n << \"allocate_extended_jump_x86ish didn't work\";\n\n // pad with NOPs to the next instruction\n static const uint8_t NOP = 0x90;\n vector jump_patch;\n int patch_size = patch_region_size;\n if (hook.flags & PATCH_NO_MATCH_TRAILING_4_BYTES) {\n patch_size -= 4;\n }\n jump_patch.resize(patch_size, NOP);\n if (hook_can_ignore_interfering_branches(hook, JumpPatch::size)) {\n // If the preceding instruction is long enough to contain the entire jump,\n // and is a nop, replace the original instruction by a jump back to the\n // start of the patch region. This allows us to ignore (likely spurious,\n // but nevertheless), interfering branches, because whether we jump to the\n // instruction or the start of the patch region, the effect is the same.\n jump_patch[patch_region_size-2] = 0xeb; // jmp rel\n jump_patch[patch_region_size-1] = (int8_t)-patch_size;\n }\n JumpPatch::substitute(jump_patch.data(), jump_offset32);\n bool ok = true;\n write_and_record_bytes(t, jump_patch_start, jump_patch.size(), jump_patch.data(), &ok);\n if (!ok) {\n LOG(warn) << \"Couldn't write patch; errno=\" << errno;\n }\n return ok;\n}\n\ntemplate <>\nbool patch_syscall_with_hook_arch(Monkeypatcher& patcher,\n RecordTask* t,\n const syscall_patch_hook& hook,\n remote_code_ptr ip_of_instruction,\n size_t instruction_length,\n uint32_t fake_syscall_number) {\n return patch_syscall_with_hook_x86ish(patcher, t,\n hook,\n ip_of_instruction,\n instruction_length,\n fake_syscall_number);\n}\n\ntemplate <>\nbool patch_syscall_with_hook_arch(Monkeypatcher& patcher,\n RecordTask* t,\n const syscall_patch_hook& hook,\n remote_code_ptr ip_of_instruction,\n size_t instruction_length,\n uint32_t fake_syscall_number) {\n return patch_syscall_with_hook_x86ish(patcher, t,\n hook,\n ip_of_instruction,\n instruction_length,\n fake_syscall_number);\n}\n\ntemplate <>\nbool patch_syscall_with_hook_arch(Monkeypatcher& patcher,\n RecordTask *t,\n const syscall_patch_hook &hook,\n remote_code_ptr,\n size_t,\n uint32_t) {\n Registers r = t->regs();\n remote_ptr svc_ip = r.ip().to_data_ptr();\n std::vector inst_buff;\n\n remote_ptr extended_jump_start =\n allocate_extended_jump_aarch64(\n t, patcher.extended_jump_pages, svc_ip, hook.hook_address, inst_buff);\n if (extended_jump_start.is_null()) {\n return false;\n }\n LOG(debug) << \"Allocated stub size \" << inst_buff.size() * sizeof(uint32_t)\n << \" bytes at \" << extended_jump_start << \" for syscall at \"\n << svc_ip;\n\n auto total_patch_size = inst_buff.size() * 4;\n write_and_record_bytes(t, extended_jump_start, total_patch_size, &inst_buff[0]);\n\n patcher.syscallbuf_stubs[extended_jump_start] = {\n &hook, total_patch_size,\n /**\n * safe_prefix:\n * We have not modified any registers yet in the first two instructions.\n * More importantly, we may bail out and return to user code without\n * hitting the breakpoint in syscallbuf\n */\n 2 * 4,\n /**\n * safe_suffix:\n * We've returned from syscallbuf and continue execution\n * won't hit syscallbuf breakpoint\n * (this also include the 8 bytes that stores the return address)\n * Note that the 4th last instruction also belongs to the syscallbuf return path\n * However, since it is still using the scratch memory,\n * it doesn't belong to the safe area.\n * The caller needs to have special handling for that instruction.\n */\n 3 * 4 + 8\n };\n\n intptr_t jump_offset = extended_jump_start - svc_ip;\n ASSERT(t, jump_offset <= aarch64_b_max_offset && jump_offset >= aarch64_b_min_offset)\n << \"allocate_extended_jump_aarch64 didn't work\";\n\n const uint32_t offset_imm26 = (jump_offset >> 2) & 0x03ffffff;\n const uint32_t b_inst = 0x14000000 | offset_imm26;\n bool ok = true;\n write_and_record_bytes(t, svc_ip, 4, &b_inst, &ok);\n if (!ok) {\n LOG(warn) << \"Couldn't write patch; errno=\" << errno;\n }\n return ok;\n}\n\n\nstatic bool patch_syscall_with_hook(Monkeypatcher& patcher, RecordTask* t,\n const syscall_patch_hook& hook,\n remote_code_ptr ip_of_instruction,\n size_t instruction_length,\n uint32_t fake_syscall_number) {\n RR_ARCH_FUNCTION(patch_syscall_with_hook_arch, t->arch(), patcher, t, hook,\n ip_of_instruction, instruction_length, fake_syscall_number);\n}\n\ntemplate \nstatic bool match_extended_jump_patch(Task* t,\n uint8_t patch[], uint64_t* return_addr, vector* instruction);\n\ntemplate <>\nbool match_extended_jump_patch(\n Task*, uint8_t patch[], uint64_t* return_addr, vector* instruction) {\n uint32_t return_addr_lo, return_addr_hi;\n uint64_t jmp_target;\n if (!X64SyscallStubExtendedJump::match(patch, &return_addr_lo, &return_addr_hi, &jmp_target)) {\n return false;\n }\n *instruction = rr::syscall_instruction(x86_64);\n *return_addr = return_addr_lo | (((uint64_t)return_addr_hi) << 32);\n return true;\n}\n\ntemplate <>\nbool match_extended_jump_patch(\n Task* t, uint8_t patch[], uint64_t* return_addr, vector* instruction) {\n uint32_t return_addr_lo, return_addr_hi, fake_syscall_no;\n uint64_t jmp_target;\n if (!X64TrapInstructionStubExtendedJump::match(patch, &return_addr_lo, &return_addr_hi,\n &fake_syscall_no, &jmp_target)) {\n return false;\n }\n *return_addr = return_addr_lo | (((uint64_t)return_addr_hi) << 32);\n if ((int)fake_syscall_no == t->session().syscall_number_for_rrcall_rdtsc()) {\n instruction->resize(sizeof(rdtsc_insn));\n memcpy(instruction->data(), rdtsc_insn, instruction->size());\n } else {\n ASSERT(t, false) << \"Unknown fake-syscall number \" << fake_syscall_no;\n }\n return true;\n}\n\ntemplate <>\nbool match_extended_jump_patch(\n Task*, uint8_t patch[], uint64_t* return_addr, vector* instruction) {\n uint32_t return_addr_32, jmp_target_relative;\n if (!X86SyscallStubExtendedJump::match(patch, &return_addr_32, &jmp_target_relative)) {\n return false;\n }\n *return_addr = return_addr_32;\n *instruction = rr::syscall_instruction(x86);\n return true;\n}\n\ntemplate \nstatic void substitute_replacement_patch(uint8_t *buffer, uint64_t patch_addr,\n uint64_t jmp_target);\n\ntemplate <>\nvoid substitute_replacement_patch(uint8_t *buffer, uint64_t patch_addr,\n uint64_t jmp_target) {\n (void)patch_addr;\n X64SyscallStubRestore::substitute(buffer, jmp_target);\n}\n\ntemplate <>\nvoid substitute_replacement_patch(uint8_t *buffer, uint64_t patch_addr,\n uint64_t jmp_target) {\n int64_t offset =\n jmp_target -\n (patch_addr + X86SyscallStubRestore::trampoline_relative_addr_end);\n // An offset that appears to be > 2GB is OK here, since EIP will just\n // wrap around.\n X86SyscallStubRestore::substitute(buffer, (uint32_t)offset);\n}\n\ntemplate \nstatic void unpatch_extended_jumps(Monkeypatcher& patcher,\n Task* t) {\n static_assert(ExtendedJumpPatch::size < FakeSyscallExtendedJumpPatch::size,\n \"If these were the same size then the logic below wouldn't work\");\n for (auto patch : patcher.syscallbuf_stubs) {\n const syscall_patch_hook &hook = *patch.second.hook;\n uint8_t bytes[FakeSyscallExtendedJumpPatch::size];\n t->read_bytes_helper(patch.first, patch.second.size, bytes);\n uint64_t return_addr = 0;\n vector syscall;\n if (patch.second.size == ExtendedJumpPatch::size) {\n if (!match_extended_jump_patch(\n t, bytes, &return_addr, &syscall)) {\n ASSERT(t, false) << \"Failed to match extended jump patch at \" << patch.first;\n return;\n }\n } else if (patch.second.size == FakeSyscallExtendedJumpPatch::size) {\n if (!match_extended_jump_patch(\n t, bytes, &return_addr, &syscall)) {\n ASSERT(t, false) << \"Failed to match trap-instruction extended jump patch at \" << patch.first;\n return;\n }\n } else {\n ASSERT(t, false) << \"Unknown patch size \" << patch.second.size;\n }\n\n // Replace with\n // extended_jump:\n // (unless PATCH_SYSCALL_INSTRUCTION_IS_LAST)\n // \n // (if PATCH_SYSCALL_INSTRUCTION_IS_LAST)\n // jmp *(return_addr)\n // As long as there are not relative branches or anything, this should\n // always be correct.\n size_t new_patch_size = hook.patch_region_length + syscall.size() + ReplacementPatch::size;\n ASSERT(t, new_patch_size <= sizeof(bytes));\n uint8_t* ptr = bytes;\n if (!(hook.flags & PATCH_SYSCALL_INSTRUCTION_IS_LAST)) {\n memcpy(ptr, syscall.data(), syscall.size());\n ptr += syscall.size();\n }\n memcpy(ptr, hook.patch_region_bytes, hook.patch_region_length);\n ptr += hook.patch_region_length;\n if (hook.flags & PATCH_SYSCALL_INSTRUCTION_IS_LAST) {\n memcpy(ptr, syscall.data(), syscall.size());\n ptr += syscall.size();\n }\n substitute_replacement_patch(ptr,\n patch.first.as_int() + hook.patch_region_length + syscall.size(), return_addr);\n t->write_bytes_helper(patch.first, new_patch_size, bytes);\n }\n}\n\ntemplate \nstatic void unpatch_syscalls_arch(Monkeypatcher &patcher, Task *t);\n\ntemplate <>\nvoid unpatch_syscalls_arch(Monkeypatcher &patcher, Task *t) {\n // There is no 32-bit equivalent to X64TrapInstructionStubExtendedJump.\n // We just pass the X64TrapInstructionStubExtendedJump; its length\n // will never match any jump stub for 32-bit.\n return unpatch_extended_jumps(patcher, t);\n}\n\ntemplate <>\nvoid unpatch_syscalls_arch(Monkeypatcher &patcher, Task *t) {\n return unpatch_extended_jumps(patcher, t);\n}\n\ntemplate <>\nvoid unpatch_syscalls_arch(Monkeypatcher &patcher, Task *t) {\n for (auto patch : patcher.syscallbuf_stubs) {\n const syscall_patch_hook &hook = *patch.second.hook;\n std::vector hook_prefix;\n uint32_t prefix_ninst;\n encode_extended_jump_aarch64(hook_prefix, hook.hook_address, 0, &prefix_ninst);\n uint32_t prefix_size = prefix_ninst * 4;\n DEBUG_ASSERT(prefix_size <= 13 * 4);\n ASSERT(t, patch.second.size >= prefix_size + 8);\n uint8_t bytes[15 * 4];\n t->read_bytes_helper(patch.first, prefix_size + 8, bytes);\n // 3rd last instruction is the one jumping back and it won't match\n if (memcmp(&hook_prefix[0], bytes, prefix_size - 3 * 4) != 0) {\n ASSERT(t, false) << \"Failed to match extended jump patch at \" << patch.first;\n return;\n }\n\n uint64_t return_addr;\n memcpy(&return_addr, &bytes[prefix_size], 8);\n\n uint32_t svc_inst = 0xd4000001;\n memcpy(bytes, &svc_inst, 4);\n\n uint64_t reverse_jump_addr = patch.first.as_int() + 4;\n int64_t reverse_offset = int64_t(return_addr - reverse_jump_addr);\n ASSERT(t, reverse_offset <= aarch64_b_max_offset &&\n reverse_offset >= aarch64_b_min_offset)\n << \"Cannot encode b instruction to jump back\";\n uint32_t offset_imm26 = (reverse_offset >> 2) & 0x03ffffff;\n uint32_t binst = 0x14000000 | offset_imm26;\n memcpy(&bytes[4], &binst, 4);\n\n t->write_bytes_helper(patch.first, 4 * 2, bytes);\n }\n}\n\nvoid Monkeypatcher::unpatch_syscalls_in(Task *t) {\n RR_ARCH_FUNCTION(unpatch_syscalls_arch, t->arch(), *this, t);\n}\n\nstatic string bytes_to_string(uint8_t* bytes, size_t size) {\n stringstream ss;\n for (size_t i = 0; i < size; ++i) {\n if (i > 0) {\n ss << ' ';\n }\n ss << HEX(bytes[i]);\n }\n return ss.str();\n}\n\nstatic bool safe_for_syscall_patching(remote_code_ptr start,\n remote_code_ptr end,\n RecordTask* exclude_stopped) {\n for (auto& p : exclude_stopped->session().tasks()) {\n RecordTask* rt = static_cast(p.second);\n if (rt != exclude_stopped && rt->is_stopped()) {\n remote_code_ptr ip = rt->ip();\n if (start <= ip && ip < end) {\n return false;\n }\n }\n\n for (auto& e : rt->pending_events) {\n if (e.is_syscall_event()) {\n remote_code_ptr ip = e.Syscall().regs.ip();\n if (start <= ip && ip < end) {\n return false;\n }\n }\n }\n }\n return true;\n}\n\nbool Monkeypatcher::try_patch_vsyscall_caller(RecordTask* t, remote_code_ptr ret_addr)\n{\n // Emit FLUSH_SYSCALLBUF if there's one pending.\n // We want our mmap records to be associated with the next (PATCH_SYSCALL)\n // event, not a FLUSH_SYSCALLBUF event.\n t->maybe_flush_syscallbuf();\n\n uint8_t bytes[X64VSyscallEntry::size];\n remote_ptr patch_start = ret_addr.to_data_ptr() - sizeof(bytes);\n size_t bytes_count = t->read_bytes_fallible(patch_start, sizeof(bytes), bytes);\n if (bytes_count < sizeof(bytes)) {\n return false;\n }\n uint32_t target_addr = 0;\n if (!X64VSyscallEntry::match(bytes, &target_addr)) {\n return false;\n }\n uint64_t target_addr_sext = (uint64_t)(int32_t)target_addr;\n int syscallno = 0;\n switch (target_addr_sext) {\n case 0xffffffffff600000:\n syscallno = X64Arch::gettimeofday;\n break;\n case 0xffffffffff600400:\n syscallno = X64Arch::time;\n break;\n case 0xffffffffff600800:\n syscallno = X64Arch::getcpu;\n break;\n default:\n return false;\n }\n X64VSyscallReplacement::substitute(bytes, syscallno);\n write_and_record_bytes(t, patch_start, bytes);\n LOG(debug) << \"monkeypatched vsyscall caller at \" << patch_start;\n return true;\n}\n\nstatic uint64_t jump_patch_size(SupportedArch arch)\n{\n switch (arch) {\n case x86: return X86SysenterVsyscallSyscallHook::size;\n case x86_64: return X64JumpMonkeypatch::size;\n case aarch64: return 2*rr::syscall_instruction_length(arch);\n default:\n FATAL() << \"Unimplemented for this architecture\";\n return 0;\n }\n}\n\nstatic bool patch_matches(const syscall_patch_hook& hook, const uint8_t* bytes) {\n int region_len = hook.patch_region_length;\n if (hook.flags & PATCH_NO_MATCH_TRAILING_4_BYTES) {\n region_len -= 4;\n }\n return memcmp(bytes, hook.patch_region_bytes, region_len) == 0;\n}\n\nconst syscall_patch_hook* Monkeypatcher::find_syscall_hook(RecordTask* t,\n remote_code_ptr ip,\n bool entering_syscall,\n size_t instruction_length,\n bool &should_retry,\n bool &transient_failure) {\n /* we need to inspect this many bytes before the start of the instruction,\n to find every short jump that might land after it. Conservative. */\n static const intptr_t LOOK_BACK = 0x80;\n /* we need to inspect this many bytes after the start of the instruction,\n to find every short jump that might land after it into the patch area.\n Conservative. */\n static const intptr_t LOOK_FORWARD = 15 + 15 + 0x80;\n uint8_t bytes[LOOK_BACK + LOOK_FORWARD];\n memset(bytes, 0, sizeof(bytes));\n\n // Split reading the code into separate reads for each page, so that if we can't read\n // from one page, we still get the data from the other page.\n ASSERT(t, sizeof(bytes) < page_size());\n remote_ptr code_start = ip.to_data_ptr() - LOOK_BACK;\n size_t buf_valid_start_offset = 0;\n size_t buf_valid_end_offset = sizeof(bytes);\n ssize_t first_page_bytes = min(ceil_page_size(code_start) - code_start, sizeof(bytes));\n if (t->read_bytes_fallible(code_start, first_page_bytes, bytes) < first_page_bytes) {\n buf_valid_start_offset = first_page_bytes;\n }\n if (first_page_bytes < (ssize_t)sizeof(bytes)) {\n if (t->read_bytes_fallible(code_start + first_page_bytes, sizeof(bytes) - first_page_bytes,\n bytes + first_page_bytes) < (ssize_t)sizeof(bytes) - first_page_bytes) {\n buf_valid_end_offset = first_page_bytes;\n }\n }\n\n if (buf_valid_start_offset > LOOK_BACK ||\n buf_valid_end_offset < LOOK_BACK + instruction_length) {\n ASSERT(t, false)\n << \"Can't read memory containing patchable instruction, why are we trying this?\";\n }\n\n uint8_t* following_bytes = &bytes[LOOK_BACK + instruction_length];\n size_t following_bytes_count = buf_valid_end_offset - (LOOK_BACK + instruction_length);\n size_t preceding_bytes_count = LOOK_BACK - buf_valid_start_offset;\n\n for (const auto& hook : syscall_hooks) {\n bool matches_hook = false;\n if ((!(hook.flags & PATCH_SYSCALL_INSTRUCTION_IS_LAST) &&\n following_bytes_count >= hook.patch_region_length &&\n patch_matches(hook, following_bytes))) {\n matches_hook = true;\n } else if ((hook.flags & PATCH_SYSCALL_INSTRUCTION_IS_LAST) &&\n hook.patch_region_length <= preceding_bytes_count &&\n patch_matches(hook, bytes + LOOK_BACK - hook.patch_region_length)) {\n if (entering_syscall) {\n // A patch that uses bytes before the syscall can't be done when\n // entering the syscall, it must be done when exiting. So set a flag on\n // the Task that tells us to come back later.\n should_retry = true;\n LOG(debug) << \"Deferring syscall patching at \" << ip << \" in \" << t\n << \" until syscall exit.\";\n return nullptr;\n }\n matches_hook = true;\n }\n\n if (!matches_hook) {\n continue;\n }\n\n if (!hook_can_ignore_interfering_branches(hook, jump_patch_size(t->arch()))) {\n // Search for a following short-jump instruction that targets an\n // instruction\n // after the syscall. False positives are OK.\n // glibc-2.23.1-8.fc24.x86_64's __clock_nanosleep needs this.\n bool found_potential_interfering_branch = false;\n for (size_t i = buf_valid_start_offset; i + 2 <= buf_valid_end_offset; ++i) {\n uint8_t b = bytes[i];\n // Check for short conditional or unconditional jump\n int branch_instruction_len = 0;\n int32_t branch_offset = 0;\n if (b == 0xeb || b == 0xe3 || (b >= 0x70 && b < 0x80)) {\n branch_instruction_len = 2;\n branch_offset = (int8_t)bytes[i + 1];\n } else if (b == 0x0f && i + 6 <= buf_valid_end_offset &&\n (bytes[i + 1] >= 0x80 && bytes[i + 1] < 0x90)) {\n branch_instruction_len = 6;\n memcpy(&branch_offset, bytes + i + 2, 4);\n }\n if (branch_instruction_len) {\n int offset_from_instruction_end = (int)i + branch_instruction_len +\n branch_offset - (LOOK_BACK + instruction_length);\n if (hook.flags & PATCH_SYSCALL_INSTRUCTION_IS_LAST) {\n if (hook.flags & PATCH_IS_MULTIPLE_INSTRUCTIONS) {\n found_potential_interfering_branch =\n offset_from_instruction_end <= -(ssize_t)instruction_length &&\n offset_from_instruction_end > -(ssize_t)(instruction_length + hook.patch_region_length);\n } else {\n found_potential_interfering_branch = offset_from_instruction_end == -(ssize_t)instruction_length;\n }\n } else {\n if (hook.flags & PATCH_IS_MULTIPLE_INSTRUCTIONS) {\n found_potential_interfering_branch =\n offset_from_instruction_end >= 0 && offset_from_instruction_end < hook.patch_region_length;\n } else {\n found_potential_interfering_branch = offset_from_instruction_end == 0;\n }\n }\n if (found_potential_interfering_branch) {\n LOG(debug) << \"Found potential interfering branch at \"\n << ip.to_data_ptr() - LOOK_BACK + i;\n break;\n }\n }\n }\n if (found_potential_interfering_branch) {\n continue;\n }\n }\n\n remote_code_ptr start_range, end_range;\n if (hook.flags & PATCH_SYSCALL_INSTRUCTION_IS_LAST) {\n start_range = ip - hook.patch_region_length;\n // if a thread has its RIP at the end of our range,\n // it could be immediately after a syscall instruction that\n // will need to be restarted. Patching out that instruction will\n // prevent the kernel from restarting it. So, extend our range by\n // one byte to detect such threads.\n end_range = ip + instruction_length + 1;\n } else {\n start_range = ip;\n end_range = ip + instruction_length + hook.patch_region_length;\n }\n if (!safe_for_syscall_patching(start_range, end_range, t)) {\n transient_failure = true;\n LOG(debug)\n << \"Temporarily declining to patch syscall at \" << ip\n << \" because a different task has its ip in the patched range\";\n return nullptr;\n }\n LOG(debug) << \"Trying to patch bytes \"\n << bytes_to_string(\n following_bytes,\n min(following_bytes_count,\n sizeof(syscall_patch_hook::patch_region_bytes)));\n\n return &hook;\n }\n\n LOG(debug) << \"Failed to find a syscall hook for bytes \"\n << bytes_to_string(\n following_bytes,\n min(following_bytes_count,\n sizeof(syscall_patch_hook::patch_region_bytes)));\n\n return nullptr;\n}\n\n// Syscalls can be patched either on entry or exit. For most syscall\n// instruction code patterns we can steal bytes after the syscall instruction\n// and thus we patch on entry, but some patterns require using bytes from\n// before the syscall instruction itself and thus can only be patched on exit.\n// The `entering_syscall` flag tells us whether or not we're at syscall entry.\n// If we are, and we find a pattern that can only be patched at exit, we'll\n// set a flag on the RecordTask telling it to try again after syscall exit.\nbool Monkeypatcher::try_patch_syscall_x86ish(RecordTask* t, remote_code_ptr ip, bool entering_syscall,\n SupportedArch arch, bool &should_retry) {\n ASSERT(t, is_x86ish(arch)) << \"Unsupported architecture\";\n\n size_t instruction_length = rr::syscall_instruction_length(arch);\n bool transient_failure = false;\n const syscall_patch_hook* hook_ptr = find_syscall_hook(t, ip - instruction_length,\n entering_syscall, instruction_length, should_retry, transient_failure);\n bool success = false;\n // `syscallno` isn't necessarily correct here (in the extremely rare corner case that we\n // deferred a patch and the signal handler changed it), but we only use it for logging.\n intptr_t syscallno = t->regs().original_syscallno();\n if (hook_ptr) {\n // Get out of executing the current syscall before we patch it.\n if (entering_syscall && !t->exit_syscall_and_prepare_restart(arch)) {\n return false;\n }\n\n LOG(debug) << \"Patching syscall at \" << ip << \" syscall \"\n << syscall_name(syscallno, t->arch()) << \" tid \" << t->tid;\n\n success = patch_syscall_with_hook(*this, t, *hook_ptr, ip - instruction_length, instruction_length, 0);\n if (!success && entering_syscall) {\n // Need to reenter the syscall to undo exit_syscall_and_prepare_restart\n t->enter_syscall(arch);\n }\n }\n\n if (!success) {\n if (!should_retry && !transient_failure) {\n LOG(debug) << \"Failed to patch syscall at \" << ip << \" syscall \"\n << syscall_name(syscallno, t->arch()) << \" tid \" << t->tid;\n tried_to_patch_syscall_addresses.insert(ip);\n }\n return false;\n }\n\n return true;\n}\n\nbool Monkeypatcher::try_patch_syscall_aarch64(RecordTask* t, remote_code_ptr ip, bool entering_syscall) {\n uint32_t inst[2] = {0, 0};\n size_t bytes_count = t->read_bytes_fallible(ip.to_data_ptr() - 8, 8, &inst);\n if (bytes_count < sizeof(inst) || inst[1] != 0xd4000001) {\n LOG(debug) << \"Declining to patch syscall at \"\n << ip - 4 << \" for unexpected instruction\";\n tried_to_patch_syscall_addresses.insert(ip);\n return false;\n }\n // mov x8, 0xdc\n if (inst[0] == 0xd2801b88) {\n // Clone may either cause the new and the old process to share stack (vfork)\n // or replacing the stack (pthread_create)\n // and requires special handling on the caller.\n // Our syscall hook cannot do that so this would have to be a raw syscall.\n // We can handle this at runtime but if we know the call is definitely\n // a clone we can avoid patching it here.\n LOG(debug) << \"Declining to patch clone syscall at \" << ip - 4;\n tried_to_patch_syscall_addresses.insert(ip);\n return false;\n }\n\n ASSERT(t, (syscall_hooks.size() == 1 && syscall_hooks[0].patch_region_length == 4 &&\n memcmp(syscall_hooks[0].patch_region_bytes, &inst[1], 4) == 0))\n << \"Unknown syscall hook\";\n\n if (!safe_for_syscall_patching(ip - 4, ip, t)) {\n LOG(debug)\n << \"Temporarily declining to patch syscall at \" << ip - 4\n << \" because a different task has its ip in the patched range\";\n return false;\n }\n\n // Get out of executing the current syscall before we patch it.\n if (entering_syscall && !t->exit_syscall_and_prepare_restart(aarch64)) {\n return false;\n }\n\n LOG(debug) << \"Patching syscall at \" << ip - 4 << \" syscall \"\n << syscall_name(t->regs().original_syscallno(), aarch64) << \" tid \" << t->tid;\n\n auto success = patch_syscall_with_hook(*this, t, syscall_hooks[0], ip - 4, 4, 0);\n if (!success && entering_syscall) {\n // Need to reenter the syscall to undo exit_syscall_and_prepare_restart\n if (!t->enter_syscall(aarch64)) {\n return false;\n }\n }\n\n if (!success) {\n LOG(debug) << \"Failed to patch syscall at \" << ip - 4 << \" syscall \"\n << syscall_name(t->regs().original_syscallno(), aarch64) << \" tid \" << t->tid;\n tried_to_patch_syscall_addresses.insert(ip);\n return false;\n }\n\n return true;\n}\n\n\nbool Monkeypatcher::try_patch_syscall(RecordTask* t, bool entering_syscall, bool &should_retry) {\n Registers r = t->regs();\n remote_code_ptr ip = r.ip();\n return try_patch_syscall(t, entering_syscall, should_retry, ip);\n}\n\nbool Monkeypatcher::try_patch_syscall(RecordTask* t, bool entering_syscall, bool &should_retry, remote_code_ptr ip) {\n if (syscall_hooks.empty()) {\n // Syscall hooks not set up yet. Don't spew warnings, and don't\n // fill tried_to_patch_syscall_addresses with addresses that we might be\n // able to patch later.\n return false;\n }\n if (t->emulated_ptracer) {\n // Syscall patching can confuse ptracers, which may be surprised to see\n // a syscall instruction at the current IP but then when running\n // forwards, that the syscall occurs deep in the preload library instead.\n return false;\n }\n if (t->is_in_traced_syscall()) {\n // Never try to patch the traced-syscall in our preload library!\n return false;\n }\n int syscallno = t->regs().original_syscallno();\n if (is_clone_syscall(syscallno, t->arch()) ||\n is_fork_syscall(syscallno, t->arch()) ||\n is_vfork_syscall(syscallno, t->arch()) ||\n is_clone3_syscall(syscallno, t->arch())) {\n // If these end up in the syscallbuf when we fork/clone then very bad\n // things happen. Of course if these are called via some\n // syscall()-type multiplexer we're in trouble anyway...\n return false;\n }\n\n // We should not get here for untraced syscalls or anything else from the rr page.\n // These should be normally prevented by our seccomp filter\n // and in the case of syscalls interrupted by signals,\n // the check for the syscall restart should prevent us from reaching here.\n ASSERT(t, ip.to_data_ptr() < AddressSpace::rr_page_start() ||\n ip.to_data_ptr() >= AddressSpace::rr_page_end());\n if (tried_to_patch_syscall_addresses.count(ip) || is_jump_stub_instruction(ip, true)) {\n return false;\n }\n\n // We could examine the current syscall number and if it's not one that\n // we support syscall buffering for, refuse to patch the syscall instruction.\n // This would, on the face of it, reduce overhead since patching the\n // instruction just means a useless trip through the syscall buffering logic.\n // However, it actually wouldn't help much since we'd still do a switch\n // on the syscall number in this function instead, and due to context\n // switching costs any overhead saved would be insignificant.\n // Also, implementing that would require keeping a buffered-syscalls\n // list in sync with the preload code, which is unnecessary complexity.\n\n SupportedArch arch;\n if (!get_syscall_instruction_arch(\n t, ip.decrement_by_syscall_insn_length(t->arch()), &arch) ||\n arch != t->arch()) {\n LOG(debug) << \"Declining to patch cross-architecture syscall at \" << ip;\n tried_to_patch_syscall_addresses.insert(ip);\n return false;\n }\n\n // Emit FLUSH_SYSCALLBUF if there's one pending.\n // We want our mmap records to be associated with the next (PATCH_SYSCALL)\n // event, not a FLUSH_SYSCALLBUF event.\n t->maybe_flush_syscallbuf();\n if (!t->is_stopped()) {\n // Tracee was unexpectedly kicked out of a ptrace-stop by SIGKILL or\n // equivalent. Abort trying to patch.\n return false;\n }\n\n if (arch == aarch64) {\n return try_patch_syscall_aarch64(t, ip, entering_syscall);\n }\n return try_patch_syscall_x86ish(t, ip, entering_syscall, arch, should_retry);\n}\n\nbool Monkeypatcher::try_patch_trapping_instruction(RecordTask* t, size_t instruction_length,\n bool before_instruction, bool &should_retry) {\n if (syscall_hooks.empty()) {\n // Syscall hooks not set up yet. Don't spew warnings, and don't\n // fill tried_to_patch_syscall_addresses with addresses that we might be\n // able to patch later.\n return false;\n }\n if (t->emulated_ptracer) {\n // Patching can confuse ptracers.\n return false;\n }\n\n Registers r = t->regs();\n remote_code_ptr ip_of_instruction = r.ip() - (before_instruction ? 0 : instruction_length);\n if (tried_to_patch_syscall_addresses.count(ip_of_instruction + instruction_length)) {\n return false;\n }\n\n // Emit FLUSH_SYSCALLBUF if there's one pending.\n // We want our mmap records to be associated with the next (PATCH_SYSCALL)\n // event, not a FLUSH_SYSCALLBUF event.\n t->maybe_flush_syscallbuf();\n\n bool transient_failure = false;\n const syscall_patch_hook* hook_ptr =\n find_syscall_hook(t, ip_of_instruction, before_instruction, instruction_length, should_retry, transient_failure);\n bool success = false;\n if (hook_ptr) {\n LOG(debug) << \"Patching trapping instruction at \" << ip_of_instruction << \" tid \" << t->tid;\n\n success = patch_syscall_with_hook(*this, t, *hook_ptr, ip_of_instruction,\n instruction_length, SYS_rrcall_rdtsc);\n }\n\n if (!success) {\n if (!should_retry && !transient_failure) {\n LOG(debug) << \"Failed to patch trapping instruction at \" << ip_of_instruction << \" tid \" << t->tid;\n tried_to_patch_syscall_addresses.insert(ip_of_instruction + instruction_length);\n }\n return false;\n }\n\n return true;\n}\n\n// VDSOs are filled with overhead critical functions related to getting the\n// time and current CPU. We need to ensure that these syscalls get redirected\n// into actual trap-into-the-kernel syscalls so rr can intercept them.\n\ntemplate \nstatic void patch_after_exec_arch(RecordTask* t, Monkeypatcher& patcher);\n\ntemplate \nstatic void patch_at_preload_init_arch(RecordTask* t, Monkeypatcher& patcher);\n\ntemplate <>\nvoid patch_after_exec_arch(RecordTask* t, Monkeypatcher& patcher) {\n (void)patcher;\n setup_preload_library_path(t);\n setup_audit_library_path(t);\n\n if (!t->vm()->has_vdso()) {\n patch_auxv_vdso(t, AT_SYSINFO_EHDR, AT_IGNORE);\n } else {\n size_t librrpage_base = RR_PAGE_ADDR - AddressSpace::RRPAGE_RECORD_PAGE_OFFSET*PRELOAD_LIBRARY_PAGE_SIZE;\n patch_auxv_vdso(t, AT_SYSINFO_EHDR, librrpage_base);\n patch_auxv_vdso(t, X86Arch::RR_AT_SYSINFO, librrpage_base +\n AddressSpace::RRVDSO_PAGE_OFFSET*PRELOAD_LIBRARY_PAGE_SIZE);\n }\n}\n\n// Monkeypatch x86 vsyscall hook only after the preload library\n// has initialized. The vsyscall hook expects to be able to use the syscallbuf.\n// Before the preload library has initialized, the regular vsyscall code\n// will trigger ptrace traps and be handled correctly by rr.\ntemplate <>\nvoid patch_at_preload_init_arch(RecordTask* t,\n Monkeypatcher& patcher) {\n auto params = t->read_mem(\n remote_ptr>(t->regs().arg1()));\n if (!params.syscallbuf_enabled) {\n return;\n }\n\n patcher.init_dynamic_syscall_patching(t, params.syscall_patch_hook_count,\n params.syscall_patch_hooks);\n}\n\ntemplate <>\nvoid patch_after_exec_arch(RecordTask* t, Monkeypatcher& patcher) {\n setup_preload_library_path(t);\n setup_audit_library_path(t);\n\n for (const auto& m : t->vm()->maps()) {\n auto& km = m.map;\n patcher.patch_after_mmap(t, km.start(), km.size(), km.file_offset_bytes(),\n km.prot(), -1, Monkeypatcher::MMAP_EXEC);\n }\n\n if (!t->vm()->has_vdso()) {\n patch_auxv_vdso(t, AT_SYSINFO_EHDR, AT_IGNORE);\n } else {\n size_t librrpage_base = RR_PAGE_ADDR - AddressSpace::RRPAGE_RECORD_PAGE_OFFSET*PRELOAD_LIBRARY_PAGE_SIZE;\n patch_auxv_vdso(t, AT_SYSINFO_EHDR, librrpage_base);\n }\n}\n\ntemplate <>\nvoid patch_after_exec_arch(RecordTask* t, Monkeypatcher& patcher) {\n setup_preload_library_path(t);\n setup_audit_library_path(t);\n\n for (const auto& m : t->vm()->maps()) {\n auto& km = m.map;\n patcher.patch_after_mmap(t, km.start(), km.size(), km.file_offset_bytes(),\n km.prot(), -1, Monkeypatcher::MMAP_EXEC);\n }\n\n if (!t->vm()->has_vdso()) {\n patch_auxv_vdso(t, AT_SYSINFO_EHDR, AT_IGNORE);\n } else {\n size_t librrpage_base = RR_PAGE_ADDR - AddressSpace::RRPAGE_RECORD_PAGE_OFFSET*PRELOAD_LIBRARY_PAGE_SIZE;\n patch_auxv_vdso(t, AT_SYSINFO_EHDR, librrpage_base);\n }\n}\n\ntemplate <>\nvoid patch_at_preload_init_arch(RecordTask* t,\n Monkeypatcher& patcher) {\n auto params = t->read_mem(\n remote_ptr>(t->regs().arg1()));\n if (!params.syscallbuf_enabled) {\n return;\n }\n\n patcher.init_dynamic_syscall_patching(t, params.syscall_patch_hook_count,\n params.syscall_patch_hooks);\n}\n\ntemplate <>\nvoid patch_at_preload_init_arch(RecordTask* t,\n Monkeypatcher& patcher) {\n auto params = t->read_mem(\n remote_ptr>(t->regs().orig_arg1()));\n if (!params.syscallbuf_enabled) {\n return;\n }\n\n patcher.init_dynamic_syscall_patching(t, params.syscall_patch_hook_count,\n params.syscall_patch_hooks);\n}\n\nvoid Monkeypatcher::patch_after_exec(RecordTask* t) {\n ASSERT(t, 1 == t->vm()->task_set().size())\n << \"Can't have multiple threads immediately after exec!\";\n\n RR_ARCH_FUNCTION(patch_after_exec_arch, t->arch(), t, *this);\n}\n\nvoid Monkeypatcher::patch_at_preload_init(RecordTask* t) {\n // NB: the tracee can't be interrupted with a signal while\n // we're processing the rrcall, because it's masked off all\n // signals.\n RR_ARCH_FUNCTION(patch_at_preload_init_arch, t->arch(), t, *this);\n}\n\nstatic remote_ptr resolve_address(ElfReader& reader, uintptr_t elf_addr,\n remote_ptr map_start,\n size_t map_size, uintptr_t map_offset,\n uint64_t prot) {\n PhdrInfo phdr;\n if (!reader.addr_to_phdr(elf_addr, phdr)) {\n LOG(warn) << \"ELF address \" << HEX(elf_addr) << \" not in file\";\n }\n if (phdr.offset < map_offset ||\n phdr.offset + phdr.filesz > map_offset + map_size ||\n bool(phdr.flags & PF_R) != bool(prot & PROT_READ) ||\n bool(phdr.flags & PF_W) != bool(prot & PROT_WRITE) ||\n bool(phdr.flags & PF_X) != bool(prot & PROT_EXEC)) {\n // The value(s) to be set are outside the mapped range or belong to another\n // mapping as indicated by the flags. This happens because code and data can\n // be mapped in separate, partial mmaps in which case some symbols will be\n // outside the mapped range.\n return nullptr;\n }\n\n // This is the distance from the file offset of the mapping to p_offset, which\n // is the same as the distance from map_start to p_vaddr + load bias.\n auto page_start_offset = phdr.offset - map_offset;\n\n // Adjust map_start so that it points to p_vaddr + load bias.\n map_start += page_start_offset;\n\n // Now subtract p_vaddr to make it point to virtual address 0 (the load bias).\n map_start -= phdr.vaddr;\n\n // Finally, add the address from the symbol table to adjust it by the load\n // bias.\n return map_start + elf_addr;\n}\n\nstatic void set_and_record_bytes(RecordTask* t, ElfReader& reader,\n uintptr_t elf_addr, const void* bytes,\n size_t size, remote_ptr map_start,\n size_t map_size, size_t map_offset,\n uint64_t prot) {\n remote_ptr addr =\n resolve_address(reader, elf_addr, map_start, map_size, map_offset, prot);\n if (!addr) {\n return;\n }\n bool ok = true;\n t->write_bytes_helper(addr, size, bytes, &ok);\n // Writing can fail when the value appears to be in the mapped range, but it\n // actually is beyond the file length.\n if (ok) {\n t->record_local(addr, size, bytes);\n }\n}\n\n/**\n * Patch _dl_runtime_resolve_(fxsave,xsave,xsavec) to clear \"FDP Data Pointer\"\n * register so that CPU-specific behaviors involving that register don't leak\n * into stack memory.\n */\nvoid Monkeypatcher::patch_dl_runtime_resolve(RecordTask* t, ElfReader& reader,\n uintptr_t elf_addr,\n remote_ptr map_start,\n size_t map_size, size_t map_offset,\n uint64_t prot) {\n if (t->arch() != x86_64) {\n return;\n }\n remote_ptr addr =\n resolve_address(reader, elf_addr, map_start, map_size, map_offset, prot);\n if (!addr) {\n return;\n }\n\n uint8_t impl[X64DLRuntimeResolve::size + X64EndBr::size];\n uint8_t *impl_start = impl;\n t->read_bytes(addr, impl);\n if (X64EndBr::match(impl) || X86EndBr::match(impl)) {\n static_assert(X64EndBr::size == X86EndBr::size, \"EndBr patch size mismatch\");\n LOG(debug) << \"Starts with endbr, skipping\";\n addr += X64EndBr::size;\n impl_start += X64EndBr::size;\n }\n\n static_assert(X64DLRuntimeResolve::size == X64DLRuntimeResolve2::size,\n \"DLRuntimeResolve patch size mismatch\");\n if (!X64DLRuntimeResolve::match(impl_start) &&\n !X64DLRuntimeResolve2::match(impl_start)) {\n LOG(warn) << \"_dl_runtime_resolve implementation doesn't look right\";\n return;\n }\n\n vector bytes(impl_start, impl_start + X64DLRuntimeResolve::size);\n auto call_patch_start = addr.cast();\n saved_dl_runtime_resolve_code[call_patch_start] = std::move(bytes);\n\n uint8_t call_patch[X64AbsoluteIndirectCallMonkeypatch::size];\n X64AbsoluteIndirectCallMonkeypatch::substitute(call_patch,\n RR_DL_RUNTIME_RESOLVE_CLEAR_FIP);\n write_and_record_bytes(t, call_patch_start, call_patch);\n\n // pad with NOPs to the next instruction\n static const uint8_t NOP = 0x90;\n uint8_t nops[X64DLRuntimeResolve::size - sizeof(call_patch)];\n memset(nops, NOP, sizeof(nops));\n write_and_record_mem(t, call_patch_start + sizeof(call_patch), nops,\n sizeof(nops));\n}\n\nvoid Monkeypatcher::unpatch_dl_runtime_resolves(RecordTask* t) {\n for (auto entry : saved_dl_runtime_resolve_code) {\n remote_ptr addr = entry.first;\n uint8_t impl[X64DLRuntimeResolve::size];\n bool ok = true;\n t->read_bytes_helper(addr, sizeof(impl), impl, &ok);\n if (!ok) {\n LOG(warn) << \"dl_runtime_resolve code has gone!\";\n continue;\n }\n uint8_t call_patch[X64AbsoluteIndirectCallMonkeypatch::size];\n X64AbsoluteIndirectCallMonkeypatch::substitute(call_patch,\n RR_PAGE_ADDR - PRELOAD_LIBRARY_PAGE_SIZE);\n if (memcmp(impl, call_patch, sizeof(call_patch))) {\n LOG(warn) << \"dl_runtime_resolve code has changed!\";\n continue;\n }\n write_and_record_mem(t, addr, entry.second.data(), entry.second.size());\n }\n saved_dl_runtime_resolve_code.clear();\n}\n\n// https://documentation-service.arm.com/static/67581b3355451e3c38d97c22\nstatic bool is_aarch64_bti(uint32_t instruction) {\n if ((instruction >> 12) == 0b11010101000000110010 && (instruction & 0x1f) == 0b11111) {\n // Hint instruction.\n uint32_t crm = (instruction >> 8) & ((1 << 4) - 1);\n uint32_t op2 = (instruction >> 5) & ((1 << 3) - 1);\n return crm == 0b0100 && (op2 & 1) == 0;\n }\n return false;\n}\n\nstatic bool is_aarch64_adrp(uint32_t instruction, remote_ptr pc, remote_ptr* address) {\n if ((instruction >> 31) == 1 && ((instruction >> 24) & 0x1f) == 0b10000) {\n uint64_t base = (pc.as_int() >> 12) << 12;\n uint64_t imm = ((instruction >> 29) & 0x3) +\n (((instruction >> 5) & ((1 << 19) - 1)) << 2);\n *address = remote_ptr(base + (imm << 12));\n return true;\n }\n return false;\n}\n\nstatic bool is_aarch64_ldrb(uint32_t instruction, uint32_t* offset) {\n if ((instruction >> 22) == 0b0011100101) {\n *offset = (instruction >> 10) & ((1 << 12) - 1);\n return true;\n }\n return false;\n}\n\n/**\n * Patch the __aarch64_have_lse_atomics variable to ensure that LSE atomics are\n * always used even if init_lse_atomics\n */\nvoid Monkeypatcher::patch_aarch64_have_lse_atomics(\n RecordTask* t, ElfReader& reader, uintptr_t ldadd4_addr,\n remote_ptr map_start, size_t map_size, size_t map_offset,\n uint64_t prot) {\n ASSERT(t, t->arch() == aarch64);\n remote_ptr addr =\n resolve_address(reader, ldadd4_addr, map_start, map_size, map_offset, prot);\n if (!addr) {\n return;\n }\n\n bool ok = true;\n uint8_t instruction_bytes[12];\n t->read_bytes_helper(addr, sizeof(instruction_bytes), instruction_bytes, &ok);\n if (!ok) {\n LOG(warn) << \"Can't read ldadd4 instruction bytes at \" << addr;\n return;\n }\n uint32_t instructions[3];\n memcpy(instructions, instruction_bytes, sizeof(instructions));\n int index = 0;\n if (is_aarch64_bti(instructions[0])) {\n ++index;\n }\n remote_ptr adrp_address;\n if (!is_aarch64_adrp(instructions[index], addr + index*4, &adrp_address)) {\n LOG(warn) << \"Instruction 0x\" << HEX(instructions[index]) << \" is not ADRP\";\n return;\n }\n uint32_t ldrb_offset;\n if (!is_aarch64_ldrb(instructions[index + 1], &ldrb_offset)) {\n LOG(warn) << \"Instruction 0x\" << HEX(instructions[index + 1]) << \" is not LDRB\";\n return;\n }\n remote_ptr have_lse_atomics_addr = adrp_address + ldrb_offset;\n uint8_t enable = 1;\n write_and_record_mem(t, have_lse_atomics_addr.cast(), &enable, 1);\n}\n\nstatic bool file_may_need_instrumentation(const AddressSpace::Mapping& map) {\n size_t file_part = map.map.fsname().rfind('/');\n if (file_part == string::npos) {\n file_part = 0;\n } else {\n ++file_part;\n }\n const string& fsname = map.map.fsname();\n return fsname.find(\"libpthread\", file_part) != string::npos ||\n fsname.find(\"ld\", file_part) != string::npos;\n}\n\nvoid Monkeypatcher::patch_after_mmap(RecordTask* t, remote_ptr start,\n size_t size, size_t offset_bytes, uint64_t prot,\n int child_fd, MmapMode mode) {\n const auto& map = t->vm()->mapping_of(start);\n if (!file_may_need_instrumentation(map)) {\n return;\n }\n if (t->arch() == aarch64 && mode != MMAP_EXEC) {\n return;\n }\n ScopedFd open_fd;\n if (child_fd >= 0) {\n open_fd = t->open_fd(child_fd, O_RDONLY);\n ASSERT(t, open_fd.is_open()) << \"Failed to open child fd \" << child_fd;\n } else {\n char buf[100];\n sprintf(buf, \"/proc/%d/map_files/%llx-%llx\", t->tid,\n (long long)start.as_int(), (long long)start.as_int() + size);\n // Reading these directly requires CAP_SYS_ADMIN, so open the link target\n // instead.\n char link[PATH_MAX];\n int ret = readlink(buf, link, sizeof(link) - 1);\n if (ret < 0) {\n return;\n }\n link[ret] = 0;\n open_fd = ScopedFd(link, O_RDONLY);\n if (!open_fd.is_open()) {\n return;\n }\n }\n ElfFileReader reader(open_fd, t->arch());\n // Check for symbols first in the library itself, regardless of whether\n // there is a debuglink. For example, on Fedora 26, the .symtab and\n // .strtab sections are stripped from the debuginfo file for\n // libpthread.so.\n SymbolTable syms = reader.read_symbols(\".symtab\", \".strtab\");\n if (syms.size() == 0) {\n ScopedFd debug_fd = reader.open_debug_file(map.map.fsname());\n if (debug_fd.is_open()) {\n ElfFileReader debug_reader(debug_fd, t->arch());\n syms = debug_reader.read_symbols(\".symtab\", \".strtab\");\n }\n }\n switch (t->arch()) {\n case x86:\n case x86_64:\n for (size_t i = 0; i < syms.size(); ++i) {\n if (syms.is_name(i, \"__elision_aconf\")) {\n static const int zero = 0;\n // Setting __elision_aconf.retry_try_xbegin to zero means that\n // pthread rwlocks don't try to use elision at all. See ELIDE_LOCK\n // in glibc's elide.h.\n set_and_record_bytes(t, reader, syms.addr(i) + 8, &zero, sizeof(zero),\n start, size, offset_bytes, prot);\n }\n if (syms.is_name(i, \"elision_init\")) {\n // Make elision_init return without doing anything. This means\n // the __elision_available and __pthread_force_elision flags will\n // remain zero, disabling elision for mutexes. See glibc's\n // elision-conf.c.\n static const uint8_t ret = 0xC3;\n set_and_record_bytes(t, reader, syms.addr(i), &ret, sizeof(ret), start,\n size, offset_bytes, prot);\n }\n // The following operations can only be applied once because after the\n // patch is applied the code no longer matches the expected template.\n // For replaying a replay to work, we need to only apply these changes\n // during a real exec, not during the mmap operations performed when rr\n // replays an exec.\n if (mode == MMAP_EXEC &&\n (syms.is_name(i, \"_dl_runtime_resolve_fxsave\") ||\n syms.is_name(i, \"_dl_runtime_resolve_xsave\") ||\n syms.is_name(i, \"_dl_runtime_resolve_xsavec\"))) {\n patch_dl_runtime_resolve(t, reader, syms.addr(i), start, size,\n offset_bytes, prot);\n }\n }\n break;\n case aarch64:\n for (size_t i = 0; i < syms.size(); ++i) {\n if (syms.is_name(i, \"__aarch64_ldadd4_relax\")) {\n patch_aarch64_have_lse_atomics(t, reader, syms.addr(i), start, size,\n offset_bytes, prot);\n }\n }\n break;\n }\n}\n\n} // namespace rr\n" }, { "path": "src/Monkeypatcher.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_MONKEYPATCHER_H_\n#define RR_MONKEYPATCHER_H_\n\n#include \n#include \n#include \n\n#include \"preload/preload_interface.h\"\n\n#include \"remote_code_ptr.h\"\n#include \"remote_ptr.h\"\n\nnamespace rr {\n\nclass ElfReader;\nclass RecordTask;\nclass ScopedFd;\nclass Task;\n\n/**\n * A class encapsulating patching state. There is one instance of this\n * class per tracee address space. Currently this class performs the following\n * tasks:\n *\n * 1) Patch the VDSO's user-space-only implementation of certain system calls\n * (e.g. gettimeofday) to do a proper kernel system call instead, so rr can\n * trap and record it (x86-64 only).\n *\n * 2) Patch the VDSO __kernel_vsyscall fast-system-call stub to redirect to\n * our syscall hook in the preload library (x86 only).\n *\n * 3) Patch syscall instructions whose following instructions match a known\n * pattern to call the syscall hook.\n *\n * Monkeypatcher only runs during recording, never replay.\n */\nclass Monkeypatcher {\npublic:\n Monkeypatcher() {}\n Monkeypatcher(const Monkeypatcher&) = default;\n\n /**\n * Apply any necessary patching immediately after exec.\n * In this hook we patch everything that doesn't depend on the preload\n * library being loaded.\n */\n void patch_after_exec(RecordTask* t);\n\n /**\n * During librrpreload initialization, apply patches that require the\n * preload library to be initialized.\n */\n void patch_at_preload_init(RecordTask* t);\n\n /**\n * Try to patch the syscall instruction that |t| just entered. If this\n * returns false, patching failed and the syscall should be processed\n * as normal. If this returns true, patching succeeded and the syscall\n * was aborted; ip() has been reset to the start of the patched syscall,\n * and execution should resume normally to execute the patched code.\n * Zero or more mapping operations are also recorded to the trace and must\n * be replayed.\n */\n bool try_patch_syscall(RecordTask* t, bool entering_syscall, bool &should_retry);\n bool try_patch_syscall(RecordTask* t, bool entering_syscall, bool &should_retry, remote_code_ptr ip);\n\n bool try_patch_syscall_x86ish(RecordTask* t, remote_code_ptr ip, bool entering_syscall,\n SupportedArch arch, bool &should_retry);\n bool try_patch_syscall_aarch64(RecordTask* t, remote_code_ptr ip, bool entering_syscall);\n\n /**\n * Try to patch the trapping instruction that |t| just trapped on. If this\n * returns false, patching failed and the instruction should be processed\n * as normal. If this returns true, patching succeeded.\n * t->ip() is the address of the trapping instruction.\n * and execution should resume normally to execute the patched code.\n * Zero or more mapping operations are also recorded to the trace and must\n * be replayed.\n */\n bool try_patch_trapping_instruction(RecordTask* t, size_t instruction_length,\n bool before_instruction,\n bool &should_retry);\n\n /**\n * Replace all extended jumps by syscalls again. Note that we do not try to\n * patch the original locations, since we don't know what the tracee may have\n * done with them in the meantime, we only patch the extended jump stubs,\n * which the tracee isn't allowed to touch.\n */\n void unpatch_syscalls_in(Task *t);\n\n /**\n * Try to patch the vsyscall-entry pattern occurring right before ret_addr\n * to instead point into the corresponding entry points in the vdso.\n * Returns true if the patching succeeded, false if it doesn't. The tasks\n * registers are left unmodified.\n */\n bool try_patch_vsyscall_caller(RecordTask *t, remote_code_ptr ret_addr);\n\n void init_dynamic_syscall_patching(\n RecordTask* t, int syscall_patch_hook_count,\n remote_ptr syscall_patch_hooks);\n\n /**\n * Try to allocate a stub from the sycall patching stub buffer. Returns null\n * if there's no buffer or we've run out of free stubs.\n */\n remote_ptr allocate_stub(RecordTask* t, size_t bytes);\n\n enum MmapMode {\n MMAP_EXEC,\n MMAP_SYSCALL,\n };\n /**\n * Apply any necessary patching immediately after an mmap. We use this to\n * patch libpthread.so.\n */\n void patch_after_mmap(RecordTask* t, remote_ptr start, size_t size,\n size_t offset_bytes, uint64_t prot, int child_fd,\n MmapMode mode);\n\n /**\n * The list of pages we've allocated to hold our extended jumps.\n */\n struct ExtendedJumpPage {\n ExtendedJumpPage(remote_ptr addr) : addr(addr), allocated(0) {}\n remote_ptr addr;\n size_t allocated;\n };\n std::vector extended_jump_pages;\n\n bool is_jump_stub_instruction(remote_code_ptr p, bool include_safearea);\n // Return the breakpoint instruction (i.e. the last branch back to caller)\n // if we are on the exit path in the jump stub\n remote_code_ptr get_jump_stub_exit_breakpoint(remote_code_ptr ip, RecordTask *t);\n\n void unpatch_dl_runtime_resolves(RecordTask* t);\n\n struct patched_syscall {\n // Pointer to hook inside the syscall_hooks array, which gets initialized\n // once and is fixed afterwards.\n const syscall_patch_hook *hook;\n size_t size;\n uint16_t safe_prefix = 0;\n uint16_t safe_suffix = 0;\n };\n\n /**\n * Addresses/lengths of syscallbuf stubs.\n */\n std::map, patched_syscall> syscallbuf_stubs;\n\nprivate:\n void patch_dl_runtime_resolve(RecordTask* t, ElfReader& reader,\n uintptr_t elf_addr, remote_ptr map_start,\n size_t map_size, size_t map_offset,\n uint64_t prot);\n void patch_aarch64_have_lse_atomics(RecordTask* t, ElfReader& reader,\n uintptr_t elf_addr,\n remote_ptr map_start,\n size_t map_size, size_t map_offset,\n uint64_t prot);\n\n /**\n * `ip` is the address of the instruction that triggered the syscall or trap\n */\n const syscall_patch_hook* find_syscall_hook(RecordTask* t,\n remote_code_ptr ip,\n bool entering_syscall,\n size_t instruction_length,\n bool &should_retry,\n bool &transient_failure);\n\n /**\n * The list of supported syscall patches obtained from the preload\n * library. Each one matches a specific byte signature for the instruction(s)\n * after a syscall instruction.\n */\n std::vector syscall_hooks;\n /**\n * The addresses of the instructions following syscalls or other\n * instructions that we've tried (or are currently trying) to patch.\n */\n std::unordered_set tried_to_patch_syscall_addresses;\n\n std::map, std::vector> saved_dl_runtime_resolve_code;\n};\n\n} // namespace rr\n\n#endif /* RR_MONKEYPATCHER_H_ */\n" }, { "path": "src/MvCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n#include \n\n#include \n\n#include \"Command.h\"\n#include \"TraceStream.h\"\n#include \"main.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass MvCommand : public Command {\npublic:\n virtual int run(vector& args);\n\nprotected:\n MvCommand(const char* name, const char* help) : Command(name, help) {}\n\n static MvCommand singleton;\n};\n\nMvCommand MvCommand::singleton(\"mv\", \" rr mv \\n\");\n\nstatic int mv(const string& from, const string& to, FILE* out) {\n string reason;\n if (!is_valid_trace_name(from, &reason) ||\n !is_valid_trace_name(to, &reason)) {\n fprintf(stderr,\n \"\\n\"\n \"rr: Trace name is invalid: %s\\n\"\n \"\\n\",\n reason.c_str());\n return 1;\n }\n\n string from_path = resolve_trace_name(from);\n\n if (!is_trace(from_path)) {\n fprintf(stderr,\n \"\\n\"\n \"rr: Could not access / identify '%s' as a trace (errno %d).\\n\"\n \"\\n\",\n from_path.c_str(), errno);\n return 1;\n }\n\n // resolve symlinks like latest_trace\n from_path = real_path(from_path);\n\n string to_path = to;\n // if 'to' is not a path, view it as trace name and move to trace_dir/to\n if (to.find(\"/\") == string::npos) {\n to_path = trace_save_dir() + \"/\" + to;\n }\n\n string to_fname = filename(to_path.c_str());\n if (to_fname == \"latest-trace\") {\n fprintf(stderr, \"\\nrr: Cannot rename to latest-trace.\\n\\n\");\n return 1;\n }\n\n if (access(to_path.c_str(), F_OK) == 0) {\n fprintf(stderr,\n \"\\n\"\n \"rr: New trace '%s' already exists or cannot be accessed.\\n\"\n \"\\n\",\n to_path.c_str());\n return 1;\n } else if (errno != ENOENT) {\n fprintf(stderr,\n \"\\n\"\n \"rr: Cannot access new trace path '%s': errno %d\\n\"\n \"\\n\",\n to_path.c_str(), errno);\n return 1;\n }\n\n // remove symlink before removing trace in case the former fails\n // a bad symlink crashes e.g. rr ls and midas\n if (is_latest_trace(from_path)) {\n if (!remove_latest_trace_symlink()) {\n return 1;\n }\n }\n\n int ret = rename(from_path.c_str(), to_path.c_str());\n if (ret != 0) {\n const string err = strerror(errno);\n fprintf(stderr,\n \"\\n\"\n \"rr: Cannot move '%s' to '%s': %s\\n\"\n \"\\n\",\n from_path.c_str(), to_path.c_str(), err.c_str());\n return 1;\n }\n\n fprintf(out,\n \"rr: Moved '%s' to '%s'\\n\",\n from_path.c_str(),\n to_path.c_str());\n return 0;\n}\n\nint MvCommand::run(vector& args) {\n if (args.size() == 2 && verify_not_option(args)) {\n string from = args[0];\n args.erase(args.begin());\n if (verify_not_option(args)) {\n string to = args[0];\n return mv(from, to, stdout);\n }\n }\n\n print_help(stderr);\n return 1;\n};\n\n} // namespace rr\n" }, { "path": "src/NonvirtualPerfCounterMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_NONVIRTUAL_PERF_COUNTER_MONITOR_H_\n#define RR_NONVIRTUAL_PERF_COUNTER_MONITOR_H_\n\n#include \"FileMonitor.h\"\n\nnamespace rr {\n\n/**\n * A FileMonitor attached to (nonvirtualized) perf counter fds. This just stops those fds from\n * being mmaped.\n */\nclass NonvirtualPerfCounterMonitor : public FileMonitor {\npublic:\n NonvirtualPerfCounterMonitor() {}\n\n virtual Type type() override { return NonvirtualPerfCounter; }\n};\n\n} // namespace rr\n\n#endif /* RR_NONVIRTUAL_PERF_COUNTER_MONITOR_H_ */\n" }, { "path": "src/ODirectFileMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_ODIRECT_MONITOR_H_\n#define RR_ODIRECT_MONITOR_H_\n\n#include \"FileMonitor.h\"\n#include \"TraceStream.h\"\n\nnamespace rr {\n\n/**\n * ODirectFileMonitor gets installed upon any use of O_DIRECT.\n * This monitor can get replaced by an MMappedFileMonitor if the\n * file is later MAP_SHARED.\n */\nclass ODirectFileMonitor : public FileMonitor {\npublic:\n ODirectFileMonitor() : FileMonitor() {};\n\n virtual Type type() override { return ODirect; }\n};\n\n} // namespace rr\n\n#endif /* RR_ODIRECT_MONITOR_H_ */\n" }, { "path": "src/PackCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"Command.h\"\n#include \"Flags.h\"\n#include \"GdbServer.h\"\n#include \"ReplaySession.h\"\n#include \"ScopedFd.h\"\n#include \"TraceStream.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n#include \"main.h\"\n\n#include \"../third-party/blake2/blake2.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n/**\n * Pack the trace directory to eliminate duplicate files and to include all\n * files needed for transportation.\n *\n * We try VERY HARD to avoid losing data if a PackCommand is interrupted.\n */\nclass PackCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n PackCommand(const char* name, const char* help) : Command(name, help) {}\n\n static PackCommand singleton;\n};\n\nPackCommand PackCommand::singleton(\n \"pack\",\n \" rr pack [OPTION]... [...]\\n\"\n \" --symlink Create symlinks to all mmapped files\\n\"\n \" instead of copying them.\\n\"\n \" --pack-dir= Specify a directory in which to pack common files.\\n\"\n \" This helps conserve space when packing multiple traces\\n\"\n \" with common files. Both the trace dir and pack dir\\n\"\n \" (at the same relative path) are required for replay\\n\"\n \"\\n\"\n \"Eliminates duplicate files in the trace directory, and copies files into\\n\"\n \"the trace directory as necessary to ensure that all needed files are in\\n\"\n \"the trace directory and none of them are links to files outside the\\n\"\n \"trace directory. This makes the trace directory independent of changes\\n\"\n \"to other files and ready to be transported elsewhere (e.g. by packaging\\n\"\n \"it into a ZIP or tar archive).\\n\"\n \"Be careful sharing traces with others; they may contain sensitive information.\\n\");\n\nstruct PackFlags {\n /* If true, insert symlinks into the trace dir which point to the original\n * files, rather than copying the files themselves */\n bool symlink;\n std::string pack_dir;\n\n PackFlags()\n : symlink(false) {}\n};\n\nstruct FileHash {\n uint8_t bytes[32];\n};\n\nbool operator<(const FileHash& h1, const FileHash& h2) {\n return memcmp(h1.bytes, h2.bytes, sizeof(h1)) < 0;\n}\n\n// Allocate a fresh FileHash different from every other\n// FileHash. Not thread-safe!\nstatic FileHash allocate_unique_file_hash() {\n static uint32_t hash = 0;\n FileHash result;\n memcpy(&result.bytes[0], &hash, sizeof(hash));\n ++hash;\n memset(&result.bytes[4], 0, sizeof(result.bytes) - sizeof(hash));\n return result;\n}\n\nstruct FsExtentsHash {\n uint8_t bytes[32];\n};\n\nbool operator<(const FsExtentsHash& h1, const FsExtentsHash& h2) {\n return memcmp(h1.bytes, h2.bytes, sizeof(h1)) < 0;\n}\n\nstruct PackDir {\n string dir;\n map mapped_files;\n PackDir(string dir) : dir(dir) {}\n};\n\nstatic bool name_comparator(const TraceReader::MappedData& d1,\n const TraceReader::MappedData d2) {\n return d1.file_name < d2.file_name;\n}\n\nstatic bool names_equal(const TraceReader::MappedData& d1,\n const TraceReader::MappedData d2) {\n return d1.file_name == d2.file_name;\n}\n\nstatic bool decreasing_size_comparator(const TraceReader::MappedData* d1,\n const TraceReader::MappedData* d2) {\n return d1->file_size_bytes > d2->file_size_bytes;\n}\n\nstatic bool is_hardlink(const string& file_name) {\n const char* name = file_name.c_str();\n const char* right_slash = strrchr(name, '/');\n return right_slash && strncmp(right_slash + 1, \"mmap_hardlink_\", 14) == 0;\n}\n\nstatic void* process_files_thread(void* p) {\n // Don't use log.h macros here since they're not necessarily thread-safe\n auto data = static_cast>*>(p);\n for (auto& pair : *data) {\n const char* name = pair.first->c_str();\n ScopedFd fd(name, O_RDONLY);\n if (!fd.is_open()) {\n fprintf(stderr, \"Failed to open %s\\n\", name);\n exit(1);\n }\n blake2b_state b2_state;\n if (blake2b_init(&b2_state, sizeof(pair.second.bytes))) {\n fprintf(stderr, \"blake2b_init failed\");\n exit(1);\n }\n while (true) {\n char buf[1024 * 1024];\n ssize_t r = read(fd, buf, sizeof(buf));\n if (r < 0) {\n fprintf(stderr, \"Failed reading from %s\\n\", name);\n exit(1);\n }\n if (r == 0) {\n break;\n }\n if (blake2b_update(&b2_state, buf, r)) {\n fprintf(stderr, \"blake2b_update failed\");\n exit(1);\n }\n }\n if (blake2b_final(&b2_state, pair.second.bytes,\n sizeof(pair.second.bytes))) {\n fprintf(stderr, \"blake2b_final failed\");\n exit(1);\n }\n }\n return nullptr;\n}\n\n// Return a size-sorted list of all mmapped files found in the trace\nstatic vector gather_files(const string& trace_dir) {\n TraceReader trace(trace_dir);\n vector files;\n while (true) {\n TraceReader::MappedData data;\n bool found;\n trace.read_mapped_region(&data, &found, TraceReader::VALIDATE,\n TraceReader::ANY_TIME);\n if (!found) {\n break;\n }\n if (data.source == TraceReader::SOURCE_FILE) {\n files.push_back(data);\n }\n }\n\n // Eliminate duplicates\n stable_sort(files.begin(), files.end(), name_comparator);\n auto last = unique(files.begin(), files.end(), names_equal);\n files.erase(last, files.end());\n\n return files;\n}\n\n// Returns true if FS_IOC_FIEMAP was supported and no extents are\n// UNKNOWN, storing a BLAKE2b hash of the extents metadata, file\n// size and filesystem ID in `result`. Otherwise returns false and\n// `result` is not initialized. `size` is always initialized.\n// If two files have the same FsExtentsHash then they have the same extents\n// and therefore the same contents.\n// If FS_IOC_FIEMAP is supported and the extents are known then this\n// deduplicates reflinked, hardlinked and symlinked files.\nstatic bool get_file_extents_hash(const string& file_name, FsExtentsHash* result,\n uint64_t* size) {\n const char* name = file_name.c_str();\n ScopedFd fd(name, O_RDONLY);\n if (!fd.is_open()) {\n fprintf(stderr, \"Failed to open %s\\n\", name);\n exit(1);\n }\n off_t seek_end = lseek(fd, 0, SEEK_END);\n if (seek_end < 0) {\n fprintf(stderr, \"Failed to SEEK_END %s\\n\", name);\n exit(1);\n }\n *size = seek_end;\n\n blake2b_state b2_state;\n if (blake2b_init(&b2_state, sizeof(result->bytes))) {\n fprintf(stderr, \"blake2b_init failed\\n\");\n exit(1);\n }\n uint64_t offset = 0;\n bool saw_last = false;\n do {\n union {\n struct fiemap request;\n char bytes[16384];\n } buffer;\n memset(&buffer.request, 0, sizeof(buffer.request));\n buffer.request.fm_start = offset;\n buffer.request.fm_length = FIEMAP_MAX_OFFSET;\n buffer.request.fm_extent_count = ((char*)&buffer.bytes[sizeof(buffer.bytes)] -\n (char*)&buffer.request.fm_extents[0])/sizeof(buffer.request.fm_extents[0]);\n int ret = ioctl(fd, FS_IOC_FIEMAP, &buffer.request);\n if (ret < 0) {\n if (errno == ENOTTY || errno == EOPNOTSUPP) {\n return false;\n }\n fprintf(stderr, \"FIEMAP ioctl failed\\n\");\n exit(1);\n }\n if (!buffer.request.fm_mapped_extents) {\n break;\n }\n for (size_t i = 0; i < buffer.request.fm_mapped_extents; ++i) {\n const struct fiemap_extent& extent = buffer.request.fm_extents[i];\n // Be super paranoid here. In btrfs at least, we see file extents where\n // fe_physical is 0 and FIEMAP_EXTENT_DATA_INLINE|FIEMAP_EXTENT_NOT_ALIGNED\n // are set; these are not real extents and the file contents are different\n // even though the extent records are the same.\n if ((extent.fe_flags & (FIEMAP_EXTENT_UNKNOWN | FIEMAP_EXTENT_DATA_INLINE |\n FIEMAP_EXTENT_DATA_TAIL | FIEMAP_EXTENT_NOT_ALIGNED))\n || !extent.fe_physical) {\n return false;\n }\n // It's not clear if file holes appear in the extents list or not.\n // To be on the safe side, we hash the logical offsets so any holes\n // will change the hash.\n struct {\n uint64_t fe_logical;\n uint64_t fe_physical;\n uint64_t fe_length;\n uint32_t fe_flags;\n uint32_t padding;\n } buf = {\n extent.fe_logical,\n extent.fe_physical,\n extent.fe_length,\n extent.fe_flags,\n 0\n };\n if (blake2b_update(&b2_state, &buf, sizeof(buf))) {\n fprintf(stderr, \"blake2b_update failed\\n\");\n exit(1);\n }\n if (extent.fe_flags & FIEMAP_EXTENT_LAST) {\n saw_last = true;\n break;\n }\n offset = extent.fe_logical + extent.fe_length;\n }\n } while (!saw_last);\n\n struct statvfs vfs_buf;\n int ret = fstatvfs(fd, &vfs_buf);\n if (ret < 0) {\n fprintf(stderr, \"fstatvfs failed\\n\");\n exit(1);\n }\n struct {\n uint64_t size;\n uint64_t fsid;\n } buf = { *size, vfs_buf.f_fsid };\n // Make sure the file size is hashed just in case it doesn't\n // show up in the extents. We also need to hash the filesystem\n // ID because the physical extents are local to the filesystem.\n if (blake2b_update(&b2_state, &buf, sizeof(buf))) {\n fprintf(stderr, \"blake2b_update failed\\n\");\n exit(1);\n }\n if (blake2b_final(&b2_state, result->bytes, sizeof(result->bytes))) {\n fprintf(stderr, \"blake2b_final failed\\n\");\n exit(1);\n }\n return true;\n}\n\n// Makes a list of all mmapped files and computes their BLAKE2b hashes.\n// BLAKE2b was chosen because it's fast and cryptographically strong (we don't\n// compare the actual file contents, we're relying on hash collision avoidance).\n// Files with the same FileHash have the same contents.\n// The keys of the returned map are the full file names of the mapped files.\nstatic map gather_file_info(const string& trace_dir) {\n vector files = gather_files(trace_dir);\n int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);\n if (online_cpus < 1) {\n FATAL() << \"sysconf(_SC_NPROCESSORS_ONLN) failed\";\n }\n int use_cpus = min(20, online_cpus);\n use_cpus = min((int)files.size(), use_cpus);\n\n // List of files indexed by their extents hash. All files\n // with the same FsExtentsHash have the same contents.\n map> extents_to_file;\n // All files for which we failed to get extents. We know nothing\n // about their contents.\n vector files_with_no_extents;\n for (const auto& file : files) {\n FsExtentsHash extents_hash;\n uint64_t size;\n if (get_file_extents_hash(file.file_name, &extents_hash, &size)) {\n extents_to_file[extents_hash].push_back(&file);\n } else {\n files_with_no_extents.push_back(&file);\n }\n if (size != file.file_size_bytes) {\n fprintf(stderr, \"File size mismatch for %s\\n\", file.file_name.c_str());\n exit(1);\n }\n }\n\n // Make a list of files with possibly unique contents (i.e. excluding\n // duplicates with the same FsExtentsHash).\n vector files_to_hash = files_with_no_extents;\n for (const auto& entry : extents_to_file) {\n files_to_hash.push_back(entry.second[0]);\n }\n // We'll assign files to threads in round-robin order, ordered by decreasing size.\n stable_sort(files_to_hash.begin(), files_to_hash.end(),\n decreasing_size_comparator);\n\n map file_size_to_file_count;\n for (auto file : files_to_hash) {\n ++file_size_to_file_count[file->file_size_bytes];\n }\n\n map result;\n vector>> thread_files;\n thread_files.resize(use_cpus);\n int num_files_to_hash = 0;\n for (auto file : files_to_hash) {\n if (file_size_to_file_count[file->file_size_bytes] == 1) {\n // There is only one file with this size, so it can't be a duplicate\n // of any other files in `files_to_hash` and there is no need to hash\n // its contents. We'll just make up a fake, unique hash value for it.\n result[file->file_name] = allocate_unique_file_hash();\n continue;\n }\n thread_files[num_files_to_hash % use_cpus].push_back(\n make_pair(&file->file_name, FileHash()));\n ++num_files_to_hash;\n }\n\n // Use multiple threads to actually hash the files we need to hash.\n vector threads;\n for (size_t i = 0; i < thread_files.size(); ++i) {\n pthread_t thread;\n pthread_create(&thread, nullptr, process_files_thread, &thread_files[i]);\n threads.push_back(thread);\n }\n for (pthread_t t : threads) {\n pthread_join(t, nullptr);\n }\n for (auto& f : thread_files) {\n for (auto& ff : f) {\n result[*ff.first] = ff.second;\n }\n }\n\n // Populate results for files we skipped because they had duplicate\n // FsExtentsHashes.\n for (const auto& entry : extents_to_file) {\n for (size_t i = 1; i < entry.second.size(); ++i) {\n // Taking a reference into `result` while we potentially\n // rehash it could be bad.\n FileHash h = result[entry.second[0]->file_name];\n result[entry.second[i]->file_name] = h;\n }\n }\n\n return result;\n}\n\nstatic bool is_in_trace_dir(const string& file_name, const string& trace_dir) {\n return file_name.find(trace_dir) == 0;\n}\n\nstatic const char* last_filename_component(const string& file_name) {\n const char* last_slash = strrchr(file_name.c_str(), '/');\n const char* last_component = last_slash ? last_slash + 1 : file_name.c_str();\n if (strncmp(last_component, \"mmap_hardlink_\", 14) == 0) {\n last_component += 14;\n while (*last_component && *last_component != '_') {\n ++last_component;\n }\n if (*last_component == '_') {\n ++last_component;\n }\n }\n return last_component;\n}\n\nstatic string copy_into_trace(const string& file_name, const string& trace_dir,\n int* name_index) {\n // We don't bother trying to do a reflink-copy here because if that was going\n // to succeed, rr would probably already have used it during recording.\n string new_name;\n ScopedFd out_fd;\n const char* last_component = last_filename_component(file_name);\n while (true) {\n char new_name_buf[PATH_MAX];\n snprintf(new_name_buf, sizeof(new_name_buf) - 1, \"mmap_pack_%d_%s\",\n *name_index, last_component);\n new_name_buf[sizeof(new_name_buf) - 1] = 0;\n new_name = trace_dir + \"/\" + new_name_buf;\n ++*name_index;\n out_fd = ScopedFd(new_name.c_str(), O_WRONLY | O_CREAT | O_EXCL, 0700);\n if (!out_fd.is_open()) {\n if (errno == EEXIST) {\n continue;\n }\n FATAL() << \"Couldn't create \" << new_name;\n }\n break;\n }\n\n ScopedFd in_fd(file_name.c_str(), O_RDONLY);\n if (!in_fd.is_open()) {\n FATAL() << \"Couldn't open \" << file_name;\n }\n\n while (true) {\n char buf[1024 * 1024];\n ssize_t r = read(in_fd, buf, sizeof(buf));\n if (r < 0) {\n FATAL() << \"Can't read from \" << file_name;\n }\n if (r == 0) {\n break;\n }\n ssize_t written = 0;\n while (written < r) {\n ssize_t w = write(out_fd, buf + written, r - written);\n if (w <= 0) {\n FATAL() << \"Can't write to \" << new_name;\n }\n written += w;\n }\n }\n\n // Try to avoid dataloss\n if (fsync(out_fd) < 0) {\n FATAL() << \"Can't write to \" << new_name;\n }\n\n return new_name;\n}\n\n// Generates a symlink inside the trace directory, pointing to the provided\n// file name.\nstatic string symlink_into_trace(const string& file_name,\n const string& trace_dir, int* name_index) {\n string new_name;\n ScopedFd out_fd;\n const char* last_component = last_filename_component(file_name);\n while (true) {\n char new_name_buf[PATH_MAX];\n snprintf(new_name_buf, sizeof(new_name_buf) - 1, \"mmap_symlink_%d_%s\",\n *name_index, last_component);\n new_name_buf[sizeof(new_name_buf) - 1] = 0;\n new_name = trace_dir + \"/\" + new_name_buf;\n ++*name_index;\n int ret = symlink(file_name.c_str(), new_name.c_str());\n if (ret < 0) {\n if (errno == EEXIST) {\n continue;\n }\n FATAL() << \"Couldn't create symlink `\" << new_name << \"' to `\"\n << file_name << \"'.\";\n }\n break;\n }\n return new_name;\n}\n\n// Insert symlinks into the trace directory, one for each mmapped file found in\n// the trace. Returns a mapping of absolute original file paths and the new\n// relative paths to the symlinks which are to be used in their place. Files\n// that already exist in the trace directory (including hardlinks) are left\n// in place and not symlinked.\nstatic map compute_canonical_symlink_map(\n const string& trace_dir) {\n map symlink_map;\n int name_index = 0;\n\n // Get all mmapped files from trace\n vector files = gather_files(trace_dir);\n\n for (auto& p : files) {\n string name = p.file_name;\n // If file is not in trace dir, create a symlink to it\n if (!is_in_trace_dir(p.file_name, trace_dir)) {\n name = symlink_into_trace(p.file_name, trace_dir, &name_index);\n }\n // Update the file map with the relative path of the target file\n symlink_map[p.file_name] = string(strrchr(name.c_str(), '/') + 1);\n }\n\n return symlink_map;\n}\n\n/**\n * This computes a map giving, for each file referenced in the trace, the name\n * of a trace file to use instead. This copies files into the\n * trace directory if they're not in the tracedir already, or if they're\n * hardlinks to files outside the trace directory. All of the copied files\n * will have names starting with \"mmap_pack_\". For files in the trace directory\n * that have the same hash, we select just one of the files as the destination\n * for all files with that hash.\n */\nstatic map compute_canonical_mmapped_files(\n const string& trace_dir,\n PackDir &pack_dir) {\n map file_info = gather_file_info(trace_dir);\n\n map hash_to_name;\n for (auto& p : file_info) {\n const auto& existing = hash_to_name.find(p.second);\n if (existing != hash_to_name.end()) {\n if (!is_hardlink(existing->second) &&\n is_in_trace_dir(existing->second, trace_dir)) {\n continue;\n }\n }\n hash_to_name[p.second] = p.first;\n }\n\n int name_index = 0;\n for (auto& p : hash_to_name) {\n // Check if this in our common pack directory\n auto it = pack_dir.mapped_files.find(p.first);\n if (it != pack_dir.mapped_files.end()) {\n LOG(debug) << \"Found in common pack dir\";\n p.second = symlink_into_trace(filesystem::relative(it->second, trace_dir), trace_dir, &name_index);\n continue;\n }\n\n // Copy hardlinked files into the trace to avoid the possibility of someone\n // overwriting the original file.\n if (is_hardlink(p.second) || !is_in_trace_dir(p.second, trace_dir)) {\n if (pack_dir.dir != \"\") {\n // If a pack dir is specified, first copy into pack dir, then symlink into trace.\n auto path = pack_dir.mapped_files[p.first] = copy_into_trace(p.second, pack_dir.dir, &name_index);\n p.second = symlink_into_trace(filesystem::relative(path, trace_dir), trace_dir, &name_index);\n } else {\n p.second = copy_into_trace(p.second, trace_dir, &name_index);\n }\n }\n }\n\n map file_map;\n for (auto& p : file_info) {\n string name = hash_to_name[p.second];\n if (!is_in_trace_dir(name, trace_dir)) {\n FATAL() << \"Internal error; file is not in trace dir\";\n }\n // Replace absolute paths with trace-relative file names\n file_map[p.first] = string(strrchr(name.c_str(), '/') + 1);\n }\n\n return file_map;\n}\n\n// Write out a new 'mmaps' file with the new file names and atomically\n// replace the existing 'mmaps' file with it.\nstatic void rewrite_mmaps(const map& file_map,\n const string& trace_dir) {\n string path = trace_dir + \"/pack_mmaps\";\n CompressedWriter writer(path, TraceStream::mmaps_block_size(), 1);\n\n TraceReader trace(trace_dir);\n vector files;\n while (true) {\n TraceReader::MappedData data;\n bool found;\n vector extra_fds;\n bool skip_monitoring_mapped_fd;\n KernelMapping km = trace.read_mapped_region(\n &data, &found, TraceReader::VALIDATE, TraceReader::ANY_TIME,\n &extra_fds, &skip_monitoring_mapped_fd);\n if (!found) {\n break;\n }\n if (data.source == TraceReader::SOURCE_FILE) {\n auto m = file_map.find(data.file_name);\n if (m == file_map.end()) {\n FATAL() << \"Internal error, didn't assign file \" << data.file_name;\n }\n data.file_name = m->second;\n }\n TraceWriter::write_mapped_region_to_alternative_stream(\n writer, data, km, extra_fds, skip_monitoring_mapped_fd);\n }\n\n // Try not to lose data!\n writer.close(CompressedWriter::SYNC);\n if (!writer.good()) {\n FATAL() << \"Error writing \" << path;\n }\n\n // OK, now the atomic switchover to the new maps file.\n // BEFORE this point, we haven't altered any of the original trace files.\n // A crash might leave some \"mmap_pack_\" files around but that's OK. A retried\n // \"rr pack\" that runs to completion will clean them all up.\n // AFTER this point, we have altered the mmaps file and the trace remains\n // valid.\n string mmaps_path = trace_dir + \"/mmaps\";\n if (rename(path.c_str(), mmaps_path.c_str()) < 0) {\n FATAL() << \"Error renaming \" << path << \" to \" << mmaps_path;\n }\n}\n\n// Delete any \"mmap_\" files that aren't destination files in our file_map.\nstatic void delete_unnecessary_files(const map& file_map,\n const string& trace_dir) {\n set retain;\n for (auto& p : file_map) {\n retain.insert(p.second);\n }\n\n DIR* dir = opendir(trace_dir.c_str());\n if (!dir) {\n FATAL() << \"Can't open directory \" << trace_dir;\n }\n struct dirent* d;\n errno = 0;\n vector names;\n while ((d = readdir(dir)) != nullptr) {\n if (strncmp(d->d_name, \"mmap_\", 5) == 0 &&\n retain.count(string(d->d_name)) == 0) {\n names.push_back(string(d->d_name));\n }\n }\n if (errno) {\n FATAL() << \"Can't read directory \" << trace_dir;\n }\n closedir(dir);\n\n for (auto& n : names) {\n string name = trace_dir + \"/\" + n;\n if (unlink(name.c_str()) < 0) {\n FATAL() << \"Can't delete file \" << name;\n }\n }\n}\n\nstatic int pack(const vector& trace_dirs, const PackFlags& flags) {\n for (const string &trace_dir : trace_dirs) {\n string dir;\n {\n // validate trace and produce default trace directory if trace_dir is empty\n TraceReader reader(trace_dir);\n dir = reader.dir();\n }\n\n PackDir pack_dir(flags.pack_dir);\n char buf[PATH_MAX];\n char* ret = realpath(dir.c_str(), buf);\n if (!ret) {\n FATAL() << \"realpath failed on \" << dir;\n }\n string abspath(buf);\n\n if (flags.symlink) {\n map canonical_symlink_map =\n compute_canonical_symlink_map(abspath);\n rewrite_mmaps(canonical_symlink_map, abspath);\n delete_unnecessary_files(canonical_symlink_map, abspath);\n } else {\n map canonical_mmapped_files =\n compute_canonical_mmapped_files(abspath, pack_dir);\n rewrite_mmaps(canonical_mmapped_files, abspath);\n delete_unnecessary_files(canonical_mmapped_files, abspath);\n }\n\n if (!probably_not_interactive(STDOUT_FILENO)) {\n printf(\"rr: Packed trace directory `%s'.\\n\", dir.c_str());\n }\n }\n\n return 0;\n}\n\nstatic bool parse_pack_arg(vector& args, PackFlags& flags) {\n static const OptionSpec options[] = {\n { 0, \"symlink\", NO_PARAMETER },\n { 1, \"pack-dir\", HAS_PARAMETER },\n };\n ParsedOption opt;\n auto args_copy = args;\n if (!Command::parse_option(args_copy, options, &opt)) {\n return false;\n }\n\n switch (opt.short_name) {\n case 0:\n flags.symlink = true;\n break;\n case 1:\n flags.pack_dir = opt.value;\n break;\n default:\n DEBUG_ASSERT(0 && \"Unknown pack option\");\n }\n\n args = args_copy;\n return true;\n}\n\nint PackCommand::run(vector& args) {\n PackFlags flags;\n\n while (parse_pack_arg(args, flags)) {\n }\n\n vector trace_dirs;\n while (!args.empty()) {\n string trace_dir;\n if (!parse_optional_trace_dir(args, &trace_dir)) {\n print_help(stderr);\n return 1;\n }\n trace_dirs.push_back(trace_dir);\n }\n\n // If no trace dirs were supplied, default to packing \"\", i.e. the latest trace.\n if (trace_dirs.empty()) {\n trace_dirs.push_back(\"\");\n }\n\n return pack(trace_dirs, flags);\n}\n\n} // namespace rr\n" }, { "path": "src/PerfCounterBuffers.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"PerfCounterBuffers.h\"\n\n#include \n\n#include \"util.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nvoid PerfCounterBuffers::destroy() {\n if (mmap_aux_buffer) {\n munmap(mmap_aux_buffer, mmap_header->aux_size);\n mmap_aux_buffer = nullptr;\n }\n if (mmap_header) {\n munmap(mmap_header, page_size() + buffer_size);\n mmap_header = nullptr;\n }\n}\n\nvoid PerfCounterBuffers::allocate(ScopedFd& perf_event_fd,\n uint64_t buffer_size, uint64_t aux_size, bool *ok) {\n this->buffer_size = buffer_size;\n if (ok) {\n *ok = true;\n }\n\n void* base = mmap(NULL, page_size() + buffer_size,\n PROT_READ | PROT_WRITE, MAP_SHARED, perf_event_fd, 0);\n if (base == MAP_FAILED) {\n const auto msg = \"Can't allocate memory for PT DATA area\";\n if (!ok) {\n FATAL() << msg;\n }\n LOG(warn) << msg;\n *ok = false;\n return;\n }\n mmap_header = static_cast(base);\n\n if (aux_size > 0) {\n mmap_header->aux_offset = mmap_header->data_offset + mmap_header->data_size;\n mmap_header->aux_size = aux_size;\n\n void* aux = mmap(NULL, mmap_header->aux_size, PROT_READ | PROT_WRITE, MAP_SHARED,\n perf_event_fd, mmap_header->aux_offset);\n if (aux == MAP_FAILED) {\n const auto msg = \"Can't allocate memory for PT AUX area\";\n if (!ok) {\n FATAL() << msg;\n }\n LOG(warn) << msg;\n *ok = false;\n return;\n }\n mmap_aux_buffer = static_cast(aux);\n }\n}\n\noptional PerfCounterBuffers::next_packet() {\n if (packet_in_use) {\n FATAL() << \"Can't offer more than one packet at a time\";\n }\n\n // Equivalent of kernel's READ_ONCE. This value is written\n // by the kernel.\n uint64_t data_end =\n *reinterpret_cast(&mmap_header->data_head);\n\n // Force memory barrier to ensure that we see all memory updates that were\n // performed before `data_head `was updated.\n __sync_synchronize();\n\n if (mmap_header->data_tail >= data_end) {\n return nullopt;\n }\n\n char* data_buf = reinterpret_cast(mmap_header) + mmap_header->data_offset;\n uint64_t data_start = mmap_header->data_tail;\n size_t start_offset = data_start % mmap_header->data_size;\n auto header_ptr = reinterpret_cast(data_buf + start_offset);\n struct perf_event_header header;\n memcpy(&header, header_ptr, sizeof(header));\n\n size_t first_chunk_size = min(header.size,\n mmap_header->data_size - start_offset);\n\n if (first_chunk_size < header.size) {\n packet_storage.resize(header.size);\n memcpy(packet_storage.data(), const_cast(header_ptr), first_chunk_size);\n memcpy(packet_storage.data() + first_chunk_size, const_cast(data_buf), header.size - first_chunk_size);\n header_ptr = reinterpret_cast(packet_storage.data());\n }\n\n void* aux_ptr = nullptr;\n packet_data_aux_end = mmap_header->aux_tail;\n if (header.type == PERF_RECORD_AUX) {\n PerfEventAux aux_packet = *reinterpret_cast(header_ptr);\n size_t aux_start_offset = aux_packet.aux_offset % mmap_header->aux_size;\n aux_ptr = mmap_aux_buffer + aux_start_offset;\n first_chunk_size = min(aux_packet.aux_size, mmap_header->aux_size - aux_start_offset);\n if (first_chunk_size < aux_packet.aux_size) {\n aux_packet_storage.resize(aux_packet.aux_size);\n memcpy(aux_packet_storage.data(), aux_ptr, first_chunk_size);\n memcpy(aux_packet_storage.data() + first_chunk_size, mmap_aux_buffer,\n aux_packet.aux_size - first_chunk_size);\n aux_ptr = aux_packet_storage.data();\n }\n packet_data_aux_end += aux_packet.aux_size;\n }\n\n packet_in_use = true;\n packet_data_end = data_start + header.size;\n return Packet(*this, header_ptr, aux_ptr);\n}\n\nvoid PerfCounterBuffers::release_packet() {\n if (!packet_in_use) {\n FATAL() << \"No packet!\";\n }\n mmap_header->data_tail = packet_data_end;\n mmap_header->aux_tail = packet_data_aux_end;\n packet_in_use = false;\n}\n\n}\n" }, { "path": "src/PerfCounterBuffers.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PERF_COUNTER_BUFFERS_H_\n#define RR_PERF_COUNTER_BUFFERS_H_\n\n#include \n\n#include \n\n#include \n\n#include \"ScopedFd.h\"\n\nnamespace rr {\n\n// I wish I knew why this type isn't defined in perf_event.h but is just\n// commented out there...\nstruct PerfEventAux {\n struct perf_event_header header;\n uint64_t aux_offset;\n uint64_t aux_size;\n uint64_t flags;\n uint64_t sample_id;\n};\n\n/**\n * Encapsulates the mmap buffers used for perf events.\n */\nclass PerfCounterBuffers {\npublic:\n PerfCounterBuffers() : mmap_header(nullptr), mmap_aux_buffer(nullptr),\n buffer_size(0), packet_in_use(false) {}\n ~PerfCounterBuffers() { destroy(); }\n\n void allocate(ScopedFd& perf_event_fd, uint64_t buffer_size, uint64_t aux_size, bool *ok = nullptr);\n void destroy();\n\n bool allocated() const { return mmap_header != nullptr; }\n\n class Packet {\n public:\n Packet(Packet&& other) : buffers(other.buffers), data_(other.data_),\n aux_data_(other.aux_data_) {\n other.buffers = nullptr;\n }\n ~Packet() {\n if (buffers) {\n buffers->release_packet();\n }\n }\n struct perf_event_header* data() const { return data_; }\n void* aux_data() const { return aux_data_; }\n\n private:\n friend class PerfCounterBuffers;\n\n Packet(PerfCounterBuffers& buffers, struct perf_event_header* data,\n void* aux_data)\n : buffers(&buffers), data_(data), aux_data_(aux_data) {}\n\n PerfCounterBuffers* buffers;\n struct perf_event_header* data_;\n void* aux_data_;\n };\n\n std::optional next_packet();\n\nprivate:\n friend class Packet;\n\n void release_packet();\n\n perf_event_mmap_page* mmap_header;\n char* mmap_aux_buffer;\n uint64_t buffer_size;\n uint64_t packet_data_end;\n uint64_t packet_data_aux_end;\n std::vector packet_storage;\n std::vector aux_packet_storage;\n bool packet_in_use;\n};\n\n} // namespace rr\n\n#endif /* RR_PERF_COUNTER_BUFFERS_H_ */\n" }, { "path": "src/PerfCounters.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"PerfCounters.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef BPF\n#include \n#include \n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"CPUs.h\"\n#include \"Flags.h\"\n#include \"Session.h\"\n#include \"Task.h\"\n#include \"core.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n#define PERF_COUNT_RR 0x72727272L\n\nstatic bool attributes_initialized;\nstatic bool cpu_improperly_configured;\n// At some point we might support multiple kinds of ticks for the same CPU arch.\n// At that point this will need to become more complicated.\nstruct perf_event_attrs {\n // bug_flags is an architecture dependent flags to determine\n // what bugs need to be checked.\n // Current, this is simply the uarch on x86 and unused on aarch64.\n int bug_flags = 0;\n perf_event_attr ticks{};\n perf_event_attr minus_ticks{};\n perf_event_attr cycles{};\n perf_event_attr llsc_fail{};\n const char *pmu_name = nullptr;\n uint32_t pmu_flags = 0;\n uint32_t skid_size = 0;\n uint32_t ticks_min_period = 1;\n bool checked = false;\n bool has_ioc_period_bug = false;\n bool only_one_counter = false;\n bool activate_useless_counter = false;\n};\n// If this contains more than one element, it's indexed by the CPU index.\nstatic std::vector perf_attrs;\nstatic uint32_t pmu_semantics_flags;\n\n/*\n * Find out the cpu model using the cpuid instruction.\n *\n * A 3rd party list of CPUIDs at https://sandpile.org/x86/cpuid.htm\n *\n * Intel's up-to-date and complete list is in\n * \"Volume 4: Model-Specific Registers\", Chapter 2.\n * See \"Intel 64 and IA-32 Architectures Software Developer Manual\"\n * https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html\n *\n * Alternatively you can find the recently added CPUIDs in the lighter document\n * called \"Documentation Changes\", navigate in table of contents to\n * \"27. Updates to Chapter 2, Volume 4\"\n * and then \"Chapter 2 Model-Specific Registers (MSRs)\"\n *\n * AMD: your best bet is https://www.amd.com/en/search/documentation/hub.html\n * Search for \"revision guide Family 17h\" and \"Model 31h\" or \"Models 00h-0Fh\"\n * For example \"Revision Guide for AMD Family 19h Models 00h-0Fh Processors\"\n * has a \"Table 2\" with \"CPUID Values for AMD\" showing the specific model and\n * revisions.\n *\n * These are roughly sorted by vendor, then by lineage, and then by time.\n */\nenum CpuMicroarch {\n UnknownCpu,\n FirstIntel,\n IntelMerom = FirstIntel,\n IntelPenryn,\n IntelNehalem,\n IntelWestmere,\n IntelSandyBridge,\n IntelIvyBridge,\n IntelHaswell,\n IntelBroadwell,\n IntelSkylake,\n IntelKabyLake,\n IntelCometLake,\n IntelIceLake,\n IntelTigerLake,\n IntelRocketLake,\n IntelAlderLake,\n IntelRaptorLake,\n IntelSapphireRapids,\n IntelEmeraldRapids,\n IntelGraniteRapids,\n IntelMeteorLake,\n IntelLunarLake,\n IntelArrowLake,\n IntelSilvermont,\n IntelGoldmont,\n IntelTremont,\n IntelGracemont,\n IntelCrestmont,\n IntelSkymont,\n LastIntel = IntelSkymont,\n FirstAMD,\n AMDF15 = FirstAMD,\n AMDZen,\n AMDZen2,\n AMDZen3,\n AMDZen4,\n AMDZen5,\n LastAMD = AMDZen5,\n FirstARM,\n ARMNeoverseN1 = FirstARM,\n ARMNeoverseN2,\n ARMNeoverseN3,\n ARMNeoverseE1,\n ARMNeoverseV1,\n ARMNeoverseV2,\n ARMNeoverseV3AE,\n ARMNeoverseV3,\n ARMCortexA55,\n ARMCortexA75,\n ARMCortexA76,\n ARMCortexA77,\n ARMCortexA78,\n ARMCortexX1,\n AmpereOne,\n AppleM1Icestorm,\n AppleM1Firestorm,\n AppleM2Blizzard,\n AppleM2Avalanche,\n LastARM = AppleM2Avalanche,\n};\n\n/*\n * Set if this CPU supports ticks counting retired conditional branches.\n */\n#define PMU_TICKS_RCB (1<<0)\n\n/*\n * Some CPUs turn off the whole PMU when there are no remaining events\n * scheduled (perhaps as a power consumption optimization). This can be a\n * very expensive operation, and is thus best avoided. For cpus, where this\n * is a problem, we keep a cycles counter (which corresponds to one of the\n * fixed function counters, so we don't use up a programmable PMC) that we\n * don't otherwise use, but keeps the PMU active, greatly increasing\n * performance.\n */\n#define PMU_BENEFITS_FROM_USELESS_COUNTER (1<<1)\n\n/*\n * Set if this CPU supports ticks counting all taken branches\n * (excluding interrupts, far branches, and rets).\n */\n#define PMU_TICKS_TAKEN_BRANCHES (1<<3)\n\n/*\n * Set if this CPU is known to have essentially unbounded skid,\n * i.e. the provided skid value is exceeded in rare cases.\n */\n#define PMU_SKID_UNBOUNDED (1<<4)\n\nstruct PmuConfig {\n CpuMicroarch uarch;\n const char* name;\n uint64_t rcb_cntr_event;\n uint64_t minus_ticks_cntr_event;\n uint64_t llsc_cntr_event;\n uint32_t skid_size;\n uint32_t flags;\n const char* pmu_name = nullptr; // ARM only\n uint64_t cycle_event = PERF_COUNT_HW_CPU_CYCLES;\n int cycle_type = PERF_TYPE_HARDWARE;\n int event_type = PERF_TYPE_RAW;\n};\n\n// XXX please only edit this if you really know what you're doing.\n// event = 0x5101c4:\n// - 51 = generic PMU\n// - 01 = umask for event BR_INST_RETIRED.CONDITIONAL\n// - c4 = eventsel for event BR_INST_RETIRED.CONDITIONAL\n// event = 0x5301cb:\n// - 51 = generic PMU\n// - 01 = umask for event HW_INTERRUPTS.RECEIVED\n// - cb = eventsel for event HW_INTERRUPTS.RECEIVED\n// See Intel 64 and IA32 Architectures Performance Monitoring Events.\n// See check_events from libpfm4.\n// Match order of CpuMicroarch.\n// For the Intel Core lineage, we use the name of the product rather than\n// the official name of the microarchitecture. For hybrid products the\n// data in this table is for the P-cores of that product. For E-cores\n// we use their actual Atom (\"mont\") microarchitecture.\nstatic const PmuConfig pmu_configs[] = {\n { UnknownCpu, \"Unknown\", 0, 0, 0, 0, 0 },\n { IntelMerom, \"Intel Merom\", 0, 0, 0, 100, 0 },\n { IntelPenryn, \"Intel Penryn\", 0, 0, 0, 100, 0 },\n { IntelNehalem, \"Intel Nehalem\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelWestmere, \"Intel Westmere\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelSandyBridge, \"Intel Sandy Bridge\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelIvyBridge, \"Intel Ivy Bridge\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelHaswell, \"Intel Haswell\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelBroadwell, \"Intel Broadwell\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelSkylake, \"Intel Skylake\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelKabyLake, \"Intel Kaby Lake\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelCometLake, \"Intel Comet Lake\", 0x5101c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelIceLake, \"Intel Ice Lake\", 0x5111c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelTigerLake, \"Intel Tiger Lake\", 0x5111c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelRocketLake, \"Intel Rocket Lake\", 0x5111c4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelAlderLake, \"Intel Alder Lake\", 0x5111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelRaptorLake, \"Intel Raptor Lake\", 0x5111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelSapphireRapids, \"Intel Sapphire Rapids\", 0x5111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelEmeraldRapids, \"Intel Emerald Rapids\", 0x5111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelGraniteRapids, \"Intel Granite Rapids\", 0x5111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelMeteorLake, \"Intel Meteor Lake\", 0x5111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelLunarLake, \"Intel Lunar Lake\", 0x100005111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelArrowLake, \"Intel Arrow Lake\", 0x100005111c4, 0, 0, 125, PMU_TICKS_RCB },\n { IntelSilvermont, \"Intel Silvermont\", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelGoldmont, \"Intel Goldmont\", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelTremont, \"Intel Tremont\", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelGracemont, \"Intel Gracemont\", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelCrestmont, \"Intel Crestmont\", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },\n { IntelSkymont, \"Intel Skymont\", 0x517ec4, 0, 0, 100, PMU_TICKS_RCB },\n { AMDF15, \"AMD Family 15h\", 0xc4, 0xc6, 0, 250, PMU_TICKS_TAKEN_BRANCHES },\n // 0xd1 == RETIRED_CONDITIONAL_BRANCH_INSTRUCTIONS - Number of retired conditional branch instructions\n // 0x2c == INTERRUPT_TAKEN - Counts the number of interrupts taken\n // Both counters are available on all Zen microarchitecures so far.\n { AMDZen, \"AMD Zen\", 0x5100d1, 0, 0, 10000, PMU_TICKS_RCB | PMU_SKID_UNBOUNDED },\n { AMDZen2, \"AMD Zen 2\", 0x5100d1, 0, 0, 10000, PMU_TICKS_RCB | PMU_SKID_UNBOUNDED },\n { AMDZen3, \"AMD Zen 3\", 0x5100d1, 0, 0, 10000, PMU_TICKS_RCB | PMU_SKID_UNBOUNDED },\n { AMDZen4, \"AMD Zen 4\", 0x5100d1, 0, 0, 10000, PMU_TICKS_RCB | PMU_SKID_UNBOUNDED },\n { AMDZen5, \"AMD Zen 5\", 0x5100d1, 0, 0, 10000, PMU_TICKS_RCB | PMU_SKID_UNBOUNDED },\n // Performance cores from ARM from cortex-a76 on (including neoverse-n1 and later)\n // have the following counters that are reliable enough for us.\n // 0x21 == BR_RETIRED - Architecturally retired taken branches\n // 0x6F == STREX_SPEC - Speculatively executed strex instructions\n // 0x11 == CPU_CYCLES - Cycle\n { ARMNeoverseN1, \"ARM Neoverse N1\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n { ARMNeoverseN2, \"ARM Neoverse N2\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n { ARMNeoverseN3, \"ARM Neoverse N3\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n { ARMNeoverseE1, \"ARM Neoverse E1\", 0, 0, 0, 0, 0 },\n { ARMNeoverseV1, \"ARM Neoverse V1\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n { ARMNeoverseV2, \"ARM Neoverse V2\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n { ARMNeoverseV3AE, \"ARM Neoverse V3AE\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n { ARMNeoverseV3, \"ARM Neoverse V3\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n // cortex-a55, cortex-a75 and neoverse-e1 counts uarch ISB\n // as retired branches so the BR_RETIRED counter is not reliable.\n // There are some counters that are somewhat more reliable than\n // the total branch count (0x21) including\n // 0x0D (BR_IMMED_RETIRED) 0x0E (BR_RETURN_RETIRED)\n // 0xCD (BR_INDIRECT_ADDR_PRED) 0x76 (PC_WRITE_SPEC)\n // 0x78 (BR_IMMED_SPEC), 0xC9 (BR_COND_PRED)\n // 0xCD (BR_INDIRECT_ADDR_PRED)\n // but according to tests on the LITTLE core on a snapdragon 865\n // none of them (including the sums) seems to be useful/reliable enough.\n { ARMCortexA55, \"ARM Cortex A55\", 0, 0, 0, 0, 0 },\n { ARMCortexA75, \"ARM Cortex A75\", 0, 0, 0, 0, 0 },\n { ARMCortexA76, \"ARM Cortex A76\", 0x21, 0, 0x6F, 10000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3\", 0x11, -1, -1 },\n { ARMCortexA77, \"ARM Cortex A77\", 0x21, 0, 0x6F, 10000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3\", 0x11, -1, -1 },\n { ARMCortexA78, \"ARM Cortex A78\", 0x21, 0, 0x6F, 10000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3\", 0x11, -1, -1 },\n { ARMCortexX1, \"ARM Cortex X1\", 0x21, 0, 0x6F, 10000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3\", 0x11, -1, -1 },\n { AmpereOne, \"AmpereOne\", 0x21, 0, 0x6F, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"armv8_pmuv3_0\", 0x11, -1, -1 },\n { AppleM1Icestorm, \"Apple M1 Icestorm\", 0x90, 0, 0, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"apple_icestorm_pmu\", 0x8c, -1, -1 },\n { AppleM1Firestorm, \"Apple M1 Firestorm\", 0x90, 0, 0, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"apple_firestorm_pmu\", 0x8c, -1, -1 },\n { AppleM2Blizzard, \"Apple M2 Blizzard\", 0x90, 0, 0, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"apple_blizzard_pmu\", 0x8c, -1, -1 },\n { AppleM2Avalanche, \"Apple M2 Avalanche\", 0x90, 0, 0, 1000, PMU_TICKS_TAKEN_BRANCHES,\n \"apple_avalanche_pmu\", 0x8c, -1, -1 },\n};\n\n#define RR_SKID_MAX 10000\n\nstatic string lowercase(const string& s) {\n string c = s;\n transform(c.begin(), c.end(), c.begin(), ::tolower);\n return c;\n}\n\n// The index of the PMU we are using within perf_attrs.\n// This is always 0 if we detected a single PMU type\n// and will be the same as the CPU index if we detected multiple PMU types.\nstatic int get_pmu_index(BindCPU cpu_binding) {\n if (cpu_binding.mode == BindCPU::UNBOUND) {\n if (perf_attrs.size() > 1) {\n CLEAN_FATAL() << \"\\nMultiple PMU types detected. Unbinding CPU is not supported.\";\n }\n return 0;\n }\n if (cpu_binding.mode != BindCPU::SPECIFIED_CORE) {\n FATAL() << \"Only specified-core mode supported at this point\";\n }\n int cpu = cpu_binding.specified_core;\n if (!PerfCounters::support_cpu(cpu)) {\n CLEAN_FATAL() << \"\\nPMU on cpu \" << cpu << \" is not supported.\";\n }\n if (perf_attrs.size() == 1) {\n // Single PMU type.\n return 0;\n }\n if ((size_t)cpu >= perf_attrs.size()) {\n CLEAN_FATAL() << \"\\nUnable to find PMU type for CPU \" << cpu;\n }\n return cpu;\n}\n\nstatic void init_perf_event_attr(struct perf_event_attr* attr,\n unsigned type, uint64_t config) {\n memset(attr, 0, sizeof(*attr));\n attr->type = perf_type_id(type);\n attr->size = sizeof(*attr);\n attr->config = config;\n // rr requires that its events count userspace tracee code\n // only.\n attr->exclude_kernel = 1;\n attr->exclude_guest = 1;\n}\n\nstatic const uint64_t IN_TX = 1ULL << 32;\nstatic const uint64_t IN_TXCP = 1ULL << 33;\n\nstatic int64_t read_counter(ScopedFd& fd) {\n int64_t val;\n ssize_t nread = read(fd, &val, sizeof(val));\n DEBUG_ASSERT(nread == sizeof(val));\n return val;\n}\n\n// Can return a closed fd if `tid > 0` and the task was just SIGKILLed.\nstatic ScopedFd start_counter(pid_t tid, int group_fd,\n struct perf_event_attr* attr,\n bool* disabled_txcp = nullptr) {\n if (disabled_txcp) {\n *disabled_txcp = false;\n }\n attr->pinned = group_fd == -1;\n int fd = syscall(__NR_perf_event_open, attr, tid, -1, group_fd, PERF_FLAG_FD_CLOEXEC);\n if (fd < 0 && errno == EINVAL && attr->type == PERF_TYPE_RAW &&\n (attr->config & IN_TXCP)) {\n // The kernel might not support IN_TXCP, so try again without it.\n struct perf_event_attr tmp_attr = *attr;\n tmp_attr.config &= ~IN_TXCP;\n fd = syscall(__NR_perf_event_open, &tmp_attr, tid, -1, group_fd, PERF_FLAG_FD_CLOEXEC);\n if (fd >= 0) {\n if (disabled_txcp) {\n *disabled_txcp = true;\n }\n LOG(warn) << \"kernel does not support IN_TXCP\";\n if ((cpuid(CPUID_GETEXTENDEDFEATURES, 0).ebx & HLE_FEATURE_FLAG) &&\n !Flags::get().suppress_environment_warnings) {\n fprintf(stderr,\n \"Your CPU supports Hardware Lock Elision but your kernel does\\n\"\n \"not support setting the IN_TXCP PMU flag. Record and replay\\n\"\n \"of code that uses HLE will fail unless you update your\\n\"\n \"kernel.\\n\");\n }\n }\n }\n if (fd < 0) {\n switch (errno) {\n case EACCES: {\n // Debian/Ubuntu/Android? are known to carry a patch that creates\n // additional perf_event_paranoid levels, and at level 4 no\n // perf_event_open() is allowed at all.\n // https://git.launchpad.net/~ubuntu-kernel/ubuntu/+source/linux/+git/noble/commit/kernel/events/core.c?id=e88769f04a4f050e02980f776942c28431e56faf\n // XXXkhuey ideally we could suggest adding CAP_PERFMON to rr here\n // but the patch only accepts CAP_SYS_ADMIN.\n auto perf_event_paranoid = read_perf_event_paranoid();\n if (perf_event_paranoid.has_value() && *perf_event_paranoid > 3) {\n string paranoid_value = std::to_string(*perf_event_paranoid);\n CLEAN_FATAL() <<\n \"rr needs /proc/sys/kernel/perf_event_paranoid <= 3, but it is \"\n << paranoid_value << \".\\n\"\n << \"Change it to <= 3.\\n\"\n << \"Consider putting 'kernel.perf_event_paranoid = 3' in /etc/sysctl.d/10-rr.conf.\\n\"\n << \"See 'man 8 sysctl', 'man 5 sysctl.d' (systemd systems)\\n\"\n << \"and 'man 5 sysctl.conf' (non-systemd systems) for more details.\";\n }\n RR_FALLTHROUGH;\n }\n case EPERM:\n CLEAN_FATAL() << \"Permission denied to use 'perf_event_open'; are hardware perf events \"\n \"available? See https://github.com/rr-debugger/rr/wiki/Will-rr-work-on-my-system\";\n break;\n case ENOENT:\n CLEAN_FATAL() << \"Unable to open performance counter with 'perf_event_open'; \"\n \"are hardware perf events available? See https://github.com/rr-debugger/rr/wiki/Will-rr-work-on-my-system\";\n break;\n case ESRCH:\n if (tid > 0) {\n break;\n }\n RR_FALLTHROUGH;\n default:\n FATAL() << \"Failed to initialize counter\";\n break;\n }\n }\n return ScopedFd(fd);\n}\n\n// Returns the ticks minimum period.\nstatic uint32_t check_for_ioc_period_bug(perf_event_attrs &perf_attr) {\n // Start a cycles counter\n struct perf_event_attr attr = perf_attr.ticks;\n attr.sample_period = 0xffffffff;\n attr.exclude_kernel = 1;\n ScopedFd bug_fd = start_counter(0, -1, &attr);\n\n uint64_t period = 1;\n if (ioctl(bug_fd, PERF_EVENT_IOC_PERIOD, &period)) {\n // On some hardware the kernel imposes a minimum period of 32 to work\n // around errata, e.g.\n // https://github.com/torvalds/linux/blob/11066801dd4b7c4d75fce65c812723a80c1481ae/arch/x86/events/intel/core.c#L4610\n period = 32;\n if (ioctl(bug_fd, PERF_EVENT_IOC_PERIOD, &period)) {\n FATAL() << \"ioctl(PERF_EVENT_IOC_PERIOD) failed\";\n }\n }\n\n struct pollfd poll_bug_fd = {.fd = bug_fd, .events = POLL_IN, .revents = 0 };\n poll(&poll_bug_fd, 1, 0);\n\n perf_attr.has_ioc_period_bug = poll_bug_fd.revents == 0;\n LOG(debug) << \"has_ioc_period_bug=\" << perf_attr.has_ioc_period_bug\n << \" min_period=\" << period;\n return period;\n}\n\nstatic const int NUM_BRANCHES = 500;\n\nvolatile uint32_t accumulator_sink = 0;\n\nstatic void do_branches() {\n // Do NUM_BRANCHES conditional branches that can't be optimized out.\n // 'accumulator' is always odd and can't be zero\n uint32_t accumulator = uint32_t(rand()) * 2 + 1;\n for (int i = 0; i < NUM_BRANCHES && accumulator; ++i) {\n accumulator = ((accumulator * 7) + 2) & 0xffffff;\n }\n // Use 'accumulator' so it can't be optimized out.\n accumulator_sink = accumulator;\n}\n\nstruct CPUInfo {\n // The microarch of the CPU core.\n CpuMicroarch microarch;\n // Either PERF_TYPE_RAW or some alternative type that should be used\n // instead of PERF_TYPE_RAW for raw events on this core.\n int raw_perf_event_type;\n};\n\n// Architecture specific detection code\n#if defined(__i386__) || defined(__x86_64__)\n#include \"PerfCounters_x86.h\"\n#elif defined(__aarch64__)\n#include \"PerfCounters_aarch64.h\"\n#else\n#error Must define microarchitecture detection code for this architecture\n#endif\n\nstatic void check_working_counters(perf_event_attrs &perf_attr, int pmu_index) {\n struct perf_event_attr attr = perf_attr.ticks;\n attr.sample_period = 0;\n struct perf_event_attr attr2 = perf_attr.cycles;\n attr2.sample_period = 0;\n ScopedFd fd = start_counter(0, -1, &attr);\n ScopedFd fd2 = start_counter(0, -1, &attr2);\n do_branches();\n int64_t events = read_counter(fd);\n int64_t events2 = read_counter(fd2);\n\n if (events < NUM_BRANCHES) {\n char config[100];\n sprintf(config, \"%llx\", (long long)perf_attr.ticks.config);\n std::string perf_cmdline = \"perf stat -e \";\n if (perf_attr.pmu_name) {\n perf_cmdline = perf_cmdline + perf_attr.pmu_name + \"/r\" + config + \"/ true\";\n }\n else {\n perf_cmdline = perf_cmdline + \"r\" + config + \" true\";\n }\n FATAL()\n << \"\\nGot \" << events << \" branch events, expected at least \"\n << NUM_BRANCHES\n << \".\\n\"\n \"\\nThe hardware performance counter seems to not be working on cpu \"\n << pmu_index << \"\\n\"\n \"Check that hardware performance counters are working by running\\n\"\n \" \"\n << perf_cmdline\n << \"\\n\"\n \"and checking that it reports a nonzero number of events.\\n\"\n \"If performance counters seem to be working with 'perf', file an\\n\"\n \"rr issue, otherwise check your hardware/OS/VM configuration. Also\\n\"\n \"check that other software is not using performance counters on\\n\"\n \"this CPU.\";\n }\n\n perf_attr.only_one_counter = events2 == 0;\n LOG(debug) << \"only_one_counter=\" << perf_attr.only_one_counter;\n\n if (perf_attr.only_one_counter) {\n arch_check_restricted_counter();\n }\n}\n\n// Returns the ticks minimum period.\n// Must be run on the CPU that we're checking for bugs.\nstatic uint32_t check_for_bugs(perf_event_attrs &perf_attr, int pmu_index) {\n DEBUG_ASSERT(!running_under_rr());\n cpu_improperly_configured = false;\n\n uint32_t min_period = check_for_ioc_period_bug(perf_attr);\n check_working_counters(perf_attr, pmu_index);\n check_for_arch_bugs(perf_attr);\n return min_period;\n}\n\nstatic vector get_cpus_info() {\n string forced_uarch = lowercase(Flags::get().forced_uarch);\n if (!forced_uarch.empty()) {\n for (size_t i = 0; i < array_length(pmu_configs); ++i) {\n const PmuConfig& pmu = pmu_configs[i];\n string name = lowercase(pmu.name);\n if (name.npos != name.find(forced_uarch)) {\n LOG(info) << \"Using forced uarch \" << pmu.name;\n return {\n { pmu.uarch, PERF_TYPE_RAW }\n };\n }\n }\n CLEAN_FATAL() << \"Forced uarch \" << Flags::get().forced_uarch\n << \" isn't known.\";\n }\n return compute_cpus_info();\n}\n\n// Similar to rr::perf_attrs, if this contains more than one element,\n// it's indexed by the CPU index.\nstatic std::vector get_pmu_microarchs() {\n std::vector pmu_uarchs;\n auto cpus_info = get_cpus_info();\n bool found_working_pmu = false;\n for (const auto& info : cpus_info) {\n bool found = false;\n for (const auto& pmu_config : pmu_configs) {\n if (info.microarch == pmu_config.uarch) {\n found = true;\n if (pmu_config.flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES)) {\n found_working_pmu |= true;\n }\n pmu_uarchs.push_back(pmu_config);\n pmu_uarchs.back().event_type = info.raw_perf_event_type;\n break;\n }\n }\n if (!found) {\n FATAL() << \"Can't find PMU config for \" << info.microarch;\n }\n LOG(info) << \"Found PMU config for \" << info.microarch;\n }\n if (!found_working_pmu) {\n CLEAN_FATAL() << \"No supported microarchitectures found.\";\n }\n DEBUG_ASSERT(!pmu_uarchs.empty());\n // Note that the `uarch` field after processed by `post_init_pmu_uarchs`\n // is used to store the bug_flags and may not be the actual uarch.\n post_init_pmu_uarchs(pmu_uarchs);\n return pmu_uarchs;\n}\n\nstatic void init_attributes() {\n if (attributes_initialized) {\n return;\n }\n attributes_initialized = true;\n\n auto pmu_uarchs = get_pmu_microarchs();\n pmu_semantics_flags = PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES;\n for (auto &pmu_uarch : pmu_uarchs) {\n if (!(pmu_uarch.flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES))) {\n continue;\n }\n pmu_semantics_flags = pmu_semantics_flags & pmu_uarch.flags;\n }\n if (!(pmu_semantics_flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES))) {\n if (pmu_uarchs.size() == 1) {\n FATAL() << \"Microarchitecture `\" << pmu_uarchs[0].name\n << \"' currently unsupported.\";\n } else {\n std::string uarch_list;\n for (auto &pmu_uarch : pmu_uarchs) {\n uarch_list += \"\\n \";\n uarch_list += pmu_uarch.name;\n }\n FATAL() << \"Microarchitecture combination currently unsupported:\"\n << uarch_list;\n }\n }\n\n if (running_under_rr()) {\n perf_attrs.resize(1);\n init_perf_event_attr(&perf_attrs[0].ticks, PERF_TYPE_HARDWARE, PERF_COUNT_RR);\n perf_attrs[0].skid_size = RR_SKID_MAX;\n perf_attrs[0].pmu_flags = pmu_semantics_flags;\n } else {\n auto npmus = pmu_uarchs.size();\n perf_attrs.resize(npmus);\n for (size_t i = 0; i < npmus; i++) {\n auto &perf_attr = perf_attrs[i];\n auto &pmu_uarch = pmu_uarchs[i];\n if (!(pmu_uarch.flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES))) {\n perf_attr.pmu_flags = 0; // Mark as unsupported\n continue;\n }\n perf_attr.pmu_name = pmu_uarch.pmu_name;\n perf_attr.skid_size = pmu_uarch.skid_size;\n perf_attr.pmu_flags = pmu_uarch.flags;\n perf_attr.bug_flags = (int)pmu_uarch.uarch;\n init_perf_event_attr(&perf_attr.ticks, pmu_uarch.event_type,\n pmu_uarch.rcb_cntr_event);\n if (pmu_uarch.minus_ticks_cntr_event != 0) {\n init_perf_event_attr(&perf_attr.minus_ticks, pmu_uarch.event_type,\n pmu_uarch.minus_ticks_cntr_event);\n }\n init_perf_event_attr(&perf_attr.cycles, pmu_uarch.cycle_type,\n pmu_uarch.cycle_event);\n init_perf_event_attr(&perf_attr.llsc_fail, pmu_uarch.event_type,\n pmu_uarch.llsc_cntr_event);\n }\n }\n}\n\nbool PerfCounters::support_cpu(int cpu) {\n // We could probably make cpu=-1 mean whether all CPUs are supported\n // if there's a need for it...\n DEBUG_ASSERT(cpu >= 0);\n init_attributes();\n\n auto nattrs = (int)perf_attrs.size();\n if (nattrs == 1) {\n cpu = 0;\n }\n if (cpu >= nattrs) {\n return false;\n }\n auto &perf_attr = perf_attrs[cpu];\n return perf_attr.pmu_flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES);\n}\n\nstatic void check_pmu(int pmu_index) {\n auto &perf_attr = perf_attrs[pmu_index];\n if (perf_attr.checked) {\n return;\n }\n perf_attr.checked = true;\n\n // Under rr we emulate idealized performance counters, so we can assume\n // none of the bugs apply.\n if (running_under_rr()) {\n return;\n }\n\n if (perf_attrs.size() > 1 && !CPUs::set_affinity_to_cpu(pmu_index)) {\n FATAL() << \"Couldn't set affinity to the right PMU\";\n }\n perf_attr.ticks_min_period = check_for_bugs(perf_attr, pmu_index);\n if (perf_attrs.size() > 1) {\n CPUs::get().restore_initial_affinity();\n }\n\n /*\n * For maintainability, and since it doesn't impact performance when not\n * needed, we always activate this. If it ever turns out to be a problem,\n * this can be set to pmu->flags & PMU_BENEFITS_FROM_USELESS_COUNTER,\n * instead.\n *\n * We also disable this counter when running under rr. Even though it's the\n * same event for the same task as the outer rr, the linux kernel does not\n * coalesce them and tries to schedule the new one on a general purpose PMC.\n * On CPUs with only 2 general PMCs (e.g. KNL), we'd run out.\n */\n perf_attr.activate_useless_counter = perf_attr.has_ioc_period_bug;\n}\n\nbool PerfCounters::is_rr_ticks_attr(const perf_event_attr& attr) {\n return attr.type == PERF_TYPE_HARDWARE && attr.config == PERF_COUNT_RR;\n}\n\nbool PerfCounters::supports_ticks_semantics(TicksSemantics ticks_semantics) {\n init_attributes();\n switch (ticks_semantics) {\n case TICKS_RETIRED_CONDITIONAL_BRANCHES:\n return (pmu_semantics_flags & PMU_TICKS_RCB) != 0;\n case TICKS_TAKEN_BRANCHES:\n return (pmu_semantics_flags & PMU_TICKS_TAKEN_BRANCHES) != 0;\n default:\n FATAL() << \"Unknown ticks_semantics \" << ticks_semantics;\n return false;\n }\n}\n\nTicksSemantics PerfCounters::default_ticks_semantics() {\n init_attributes();\n if (pmu_semantics_flags & PMU_TICKS_TAKEN_BRANCHES) {\n return TICKS_TAKEN_BRANCHES;\n }\n if (pmu_semantics_flags & PMU_TICKS_RCB) {\n return TICKS_RETIRED_CONDITIONAL_BRANCHES;\n }\n FATAL() << \"Unsupported architecture\";\n return TICKS_TAKEN_BRANCHES;\n}\n\nuint32_t PerfCounters::skid_size() {\n DEBUG_ASSERT(attributes_initialized);\n DEBUG_ASSERT(perf_attrs[pmu_index].checked);\n // If we want to stop after one event, and our minimum period is Y,\n // and the skid size is X, then we'll actually use a period of Y\n // and potentially skid to Y + X, so report Y + X as the skid size.\n return perf_attrs[pmu_index].skid_size +\n perf_attrs[pmu_index].ticks_min_period;\n}\n\nPerfCounters::PerfCounters(pid_t tid, BindCPU cpu_binding,\n TicksSemantics ticks_semantics, Enabled enabled,\n IntelPTEnabled enable_pt)\n : tid(tid), pmu_index(0), ticks_semantics_(ticks_semantics),\n enabled(enabled), opened(false), counting(false) {\n if (enabled == Enabled::DISABLE) {\n return;\n }\n pmu_index = get_pmu_index(cpu_binding);\n if (!supports_ticks_semantics(ticks_semantics)) {\n FATAL() << \"Ticks semantics \" << ticks_semantics << \" not supported\";\n }\n if (enable_pt == PT_ENABLE) {\n pt_state = make_unique();\n }\n}\n\nstatic void make_counter_async(ScopedFd& fd, int signal) {\n if (fcntl(fd, F_SETFL, O_ASYNC) || fcntl(fd, F_SETSIG, signal)) {\n FATAL() << \"Failed to make ticks counter ASYNC with sig\"\n << signal_name(signal);\n }\n}\n\nstatic void infallible_perf_event_reset_if_open(ScopedFd& fd) {\n if (fd.is_open()) {\n if (ioctl(fd, PERF_EVENT_IOC_RESET, 0)) {\n FATAL() << \"ioctl(PERF_EVENT_IOC_RESET) failed\";\n }\n }\n}\n\nstatic void infallible_perf_event_enable_if_open(ScopedFd& fd) {\n if (fd.is_open()) {\n if (ioctl(fd, PERF_EVENT_IOC_ENABLE, 0)) {\n FATAL() << \"ioctl(PERF_EVENT_IOC_ENABLE) failed\";\n }\n }\n}\n\nstatic void infallible_perf_event_disable_if_open(ScopedFd& fd) {\n if (fd.is_open()) {\n if (ioctl(fd, PERF_EVENT_IOC_DISABLE, 0)) {\n FATAL() << \"ioctl(PERF_EVENT_IOC_ENABLE) failed\";\n }\n }\n}\n\nstatic uint32_t pt_event_type() {\n static const char file_name[] = \"/sys/bus/event_source/devices/intel_pt/type\";\n ScopedFd fd(file_name, O_RDONLY);\n if (!fd.is_open()) {\n FATAL() << \"Can't open \" << file_name << \", PT events not available\";\n }\n char buf[6];\n ssize_t ret = read(fd, buf, sizeof(buf));\n if (ret < 1 || ret > 5) {\n FATAL() << \"Invalid value in \" << file_name;\n }\n char* end_ptr;\n unsigned long value = strtoul(buf, &end_ptr, 10);\n if (end_ptr < buf + ret && *end_ptr && *end_ptr != '\\n') {\n FATAL() << \"Invalid value in \" << file_name;\n }\n return value;\n}\n\nstatic const size_t PT_PERF_DATA_SIZE = 8*1024*1024;\nstatic const size_t PT_PERF_AUX_SIZE = 128*1024*1024;\n\nstruct PTCopyThreadState {\n pthread_mutex_t mutex;\n unordered_set counting_pt_states;\n\n PTCopyThreadState() {\n pthread_mutex_init(&mutex, nullptr);\n pthread_t thread;\n pthread_create(&thread, nullptr, do_thread, this);\n pthread_setname_np(thread, \"pt_copy\");\n }\n void start_copying(PerfCounters::PTState* state) {\n pthread_mutex_lock(&mutex);\n counting_pt_states.insert(state);\n pthread_mutex_unlock(&mutex);\n }\n void stop_copying(PerfCounters::PTState* state) {\n pthread_mutex_lock(&mutex);\n counting_pt_states.erase(state);\n pthread_mutex_unlock(&mutex);\n }\n\nprivate:\n static void* do_thread(void* p) {\n static_cast(p)->thread_run();\n return nullptr;\n }\n void thread_run() {\n while (true) {\n pthread_mutex_lock(&mutex);\n while (true) {\n bool did_work = false;\n for (PerfCounters::PTState* state : counting_pt_states) {\n size_t bytes = state->flush();\n if (bytes > 0) {\n did_work = true;\n }\n }\n if (!did_work) {\n break;\n }\n }\n pthread_mutex_unlock(&mutex);\n\n struct timespec ts = { 0, 250000 };\n nanosleep(&ts, nullptr);\n }\n }\n};\n\nstatic PTCopyThreadState* pt_thread_state;\n\nvoid PerfCounters::start_pt_copy_thread() {\n if (!pt_thread_state) {\n pt_thread_state = new PTCopyThreadState();\n }\n}\n\nbool PerfCounters::improperly_configured() {\n return cpu_improperly_configured;\n}\n\n// See https://github.com/intel/libipt/blob/master/doc/howto_capture.md\nvoid PerfCounters::PTState::open(pid_t tid) {\n static uint32_t event_type = pt_event_type();\n\n struct perf_event_attr attr;\n init_perf_event_attr(&attr, event_type, 0);\n attr.aux_watermark = 8 * 1024 * 1024;\n pt_perf_event_fd = start_counter(tid, -1, &attr);\n if (!pt_perf_event_fd.is_open()) {\n return;\n }\n\n perf_buffers.allocate(pt_perf_event_fd, PT_PERF_DATA_SIZE, PT_PERF_AUX_SIZE);\n}\n\nsize_t PerfCounters::PTState::flush() {\n if (!perf_buffers.allocated()) {\n return 0;\n }\n\n size_t ret = 0;\n\n while (auto packet = perf_buffers.next_packet()) {\n struct perf_event_header header = *packet->data();\n switch (header.type) {\n case PERF_RECORD_LOST:\n FATAL() << \"PT records lost!\";\n break;\n case PERF_RECORD_ITRACE_START:\n break;\n case PERF_RECORD_AUX: {\n auto aux_packet = *reinterpret_cast(packet->data());\n if (aux_packet.flags) {\n if (aux_packet.flags & PERF_AUX_FLAG_TRUNCATED) {\n CLEAN_FATAL() << \"PT aux data truncated. Try increasing \"\n \"PT_PERF_AUX_SIZE in src/PerfCounters.cc and rerecording.\";\n }\n FATAL() << \"Unexpected AUX packet flags \" << aux_packet.flags;\n }\n pt_data.data.emplace_back();\n vector& data = pt_data.data.back();\n data.resize(aux_packet.aux_size);\n memcpy(data.data(), packet->aux_data(), aux_packet.aux_size);\n ret += aux_packet.aux_size;\n break;\n }\n default:\n FATAL() << \"Unknown record \" << header.type;\n break;\n }\n }\n\n return ret;\n}\n\nPTData PerfCounters::extract_intel_pt_data() {\n PTData result;\n if (pt_state) {\n result = std::move(pt_state->pt_data);\n }\n return result;\n}\n\nvoid PerfCounters::PTState::close() {\n pt_perf_event_fd.close();\n perf_buffers.destroy();\n}\n\nvoid PerfCounters::start(Task* t, Ticks ticks_period) {\n ASSERT(t, !counting);\n ASSERT(t, ticks_period >= 0);\n\n if (enabled == DISABLE) {\n return;\n }\n\n check_pmu(pmu_index);\n\n auto &perf_attr = perf_attrs[pmu_index];\n if (ticks_period == 0) {\n // We can't switch a counter between sampling and non-sampling via\n // PERF_EVENT_IOC_PERIOD so just turn 0 into a very big number.\n ticks_period = uint64_t(1) << 60;\n }\n ticks_period = max(ticks_period, perf_attr.ticks_min_period);\n\n if (!opened) {\n LOG(debug) << \"Recreating counters with period \" << ticks_period;\n\n struct perf_event_attr attr = perf_attr.ticks;\n struct perf_event_attr minus_attr = perf_attr.minus_ticks;\n attr.sample_period = ticks_period;\n fd_ticks_interrupt = start_counter(tid, -1, &attr);\n if (minus_attr.config != 0) {\n fd_minus_ticks_measure = start_counter(tid, fd_ticks_interrupt, &minus_attr);\n }\n\n if (!perf_attr.only_one_counter && !running_under_rr()) {\n reset_arch_extras(pmu_index);\n }\n\n if (perf_attr.activate_useless_counter && !fd_useless_counter.is_open()) {\n // N.B.: This is deliberately not in the same group as the other counters\n // since we want to keep it scheduled at all times.\n fd_useless_counter = start_counter(tid, -1, &perf_attr.cycles);\n }\n\n if (fd_ticks_interrupt.is_open()) {\n struct f_owner_ex own;\n own.type = F_OWNER_TID;\n own.pid = tid;\n if (fcntl(fd_ticks_interrupt, F_SETOWN_EX, &own)) {\n FATAL() << \"Failed to SETOWN_EX ticks event fd\";\n }\n make_counter_async(fd_ticks_interrupt, PerfCounters::TIME_SLICE_SIGNAL);\n }\n\n if (pt_state) {\n pt_state->open(tid);\n pt_thread_state->start_copying(pt_state.get());\n }\n } else {\n LOG(debug) << \"Resetting counters with period \" << ticks_period;\n\n infallible_perf_event_reset_if_open(fd_ticks_interrupt);\n if (ioctl(fd_ticks_interrupt, PERF_EVENT_IOC_PERIOD, &ticks_period)) {\n FATAL() << \"ioctl(PERF_EVENT_IOC_PERIOD) failed with period \"\n << ticks_period;\n }\n infallible_perf_event_enable_if_open(fd_ticks_interrupt);\n\n infallible_perf_event_reset_if_open(fd_minus_ticks_measure);\n infallible_perf_event_enable_if_open(fd_minus_ticks_measure);\n\n infallible_perf_event_reset_if_open(fd_ticks_measure);\n infallible_perf_event_enable_if_open(fd_ticks_measure);\n\n infallible_perf_event_reset_if_open(fd_ticks_in_transaction);\n infallible_perf_event_enable_if_open(fd_ticks_in_transaction);\n\n if (pt_state) {\n infallible_perf_event_enable_if_open(pt_state->pt_perf_event_fd);\n pt_thread_state->start_copying(pt_state.get());\n }\n }\n\n opened = true;\n counting = true;\n counting_period = ticks_period;\n}\n\nvoid PerfCounters::set_tid(pid_t tid) {\n close();\n this->tid = tid;\n}\n\nvoid PerfCounters::close() {\n if (counting) {\n FATAL() << \"Can't close while counting task \" << tid;\n }\n\n if (!opened) {\n return;\n }\n opened = false;\n if (pt_state) {\n pt_state->close();\n }\n\n fd_ticks_interrupt.close();\n fd_ticks_measure.close();\n fd_minus_ticks_measure.close();\n fd_useless_counter.close();\n fd_ticks_in_transaction.close();\n fd_async_signal_accelerator.close();\n}\n\nTicks PerfCounters::stop(Task* t, Error* error) {\n if (!counting) {\n if (error) {\n *error = Error::None;\n }\n return 0;\n }\n\n Ticks ticks = read_ticks(t, error);\n counting = false;\n if (pt_state) {\n pt_thread_state->stop_copying(pt_state.get());\n pt_state->flush();\n }\n if (always_recreate_counters(perf_attrs[pmu_index])) {\n close();\n } else {\n infallible_perf_event_disable_if_open(fd_ticks_interrupt);\n infallible_perf_event_disable_if_open(fd_minus_ticks_measure);\n infallible_perf_event_disable_if_open(fd_ticks_measure);\n infallible_perf_event_disable_if_open(fd_ticks_in_transaction);\n if (pt_state) {\n infallible_perf_event_disable_if_open(pt_state->pt_perf_event_fd);\n }\n infallible_perf_event_disable_if_open(fd_async_signal_accelerator);\n }\n return ticks;\n}\n\n// Note that on aarch64 this is also used to get the count for `ret`\nTicks PerfCounters::ticks_for_unconditional_indirect_branch(Task*) {\n DEBUG_ASSERT(attributes_initialized);\n return (pmu_semantics_flags & PMU_TICKS_TAKEN_BRANCHES) ? 1 : 0;\n}\n\nTicks PerfCounters::ticks_for_unconditional_direct_branch(Task*) {\n DEBUG_ASSERT(attributes_initialized);\n return (pmu_semantics_flags & PMU_TICKS_TAKEN_BRANCHES) ? 1 : 0;\n}\n\nTicks PerfCounters::ticks_for_direct_call(Task*) {\n DEBUG_ASSERT(attributes_initialized);\n return (pmu_semantics_flags & PMU_TICKS_TAKEN_BRANCHES) ? 1 : 0;\n}\n\nTicks PerfCounters::read_ticks(Task* t, Error* error) {\n if (error) {\n *error = Error::None;\n }\n\n ASSERT(t, opened);\n ASSERT(t, counting);\n ASSERT(t, counting_period > 0);\n\n if (fd_ticks_in_transaction.is_open()) {\n uint64_t transaction_ticks = read_counter(fd_ticks_in_transaction);\n if (transaction_ticks > 0) {\n LOG(debug) << transaction_ticks << \" IN_TX ticks detected\";\n if (!Flags::get().force_things) {\n ASSERT(t, false)\n << transaction_ticks\n << \" IN_TX ticks detected while HLE not supported due to KVM PMU\\n\"\n \"virtualization bug. See \"\n \"http://marc.info/?l=linux-kernel&m=148582794808419&w=2\\n\"\n \"Aborting. Retry with -F to override, but it will probably\\n\"\n \"fail.\";\n }\n }\n }\n\n if (fd_strex_counter.is_open()) {\n uint64_t strex_count = read_counter(fd_strex_counter);\n if (strex_count > 0) {\n LOG(debug) << strex_count << \" strex detected\";\n if (!Flags::get().force_things) {\n ASSERT(t, false)\n << strex_count\n << \" (speculatively) executed strex instructions detected. \\n\"\n \"On aarch64, rr only supports applications making use of LSE\\n\"\n \"atomics rather than legacy LL/SC-based atomics.\\n\"\n \"Aborting. Retry with -F to override, but replaying such\\n\"\n \"a recording will probably fail.\";\n }\n }\n }\n\n uint64_t adjusted_counting_period =\n counting_period +\n (t->session().is_recording() ? recording_skid_size() : skid_size());\n uint64_t interrupt_val = 0;\n if (fd_ticks_interrupt.is_open()) {\n interrupt_val = read_counter(fd_ticks_interrupt);\n }\n uint64_t ret;\n if (!fd_ticks_measure.is_open()) {\n if (fd_minus_ticks_measure.is_open()) {\n uint64_t minus_measure_val = read_counter(fd_minus_ticks_measure);\n interrupt_val -= minus_measure_val;\n }\n if (t->session().is_recording()) {\n if (interrupt_val > adjusted_counting_period) {\n LOG(warn) << \"Recorded ticks of \" << interrupt_val\n << \" overshot requested ticks target by \" << interrupt_val - counting_period\n << \" ticks.\\n\"\n \"On AMD systems this is known to occur occasionally for unknown reasons.\\n\"\n \"Recording should continue normally. Please report any unexpected rr failures\\n\"\n \"received after this warning, any conditions that reliably reproduce it,\\n\"\n \"or sightings of this warning on non-AMD systems.\";\n }\n }\n ret = interrupt_val;\n } else {\n uint64_t measure_val = read_counter(fd_ticks_measure);\n if (measure_val > interrupt_val) {\n // There is some kind of kernel or hardware bug that means we sometimes\n // see more events with IN_TXCP set than without. These are clearly\n // spurious events :-(. For now, work around it by returning the\n // interrupt_val. That will work if HLE hasn't been used in this interval.\n // Note that interrupt_val > measure_val is valid behavior (when HLE is\n // being used).\n LOG(debug) << \"Measured too many ticks; measure=\" << measure_val\n << \", interrupt=\" << interrupt_val;\n ret = interrupt_val;\n } else {\n ret = measure_val;\n }\n }\n if (!t->session().is_recording() && ret > adjusted_counting_period) {\n if (error && (perf_attrs[pmu_index].pmu_flags & PMU_SKID_UNBOUNDED)) {\n *error = Error::Transient;\n } else {\n ASSERT(t, false) << \"Detected \" << ret\n << \" ticks, expected no more than \" << adjusted_counting_period;\n }\n }\n return ret;\n}\n\n#ifdef BPF\nclass BpfAccelerator {\npublic:\n static std::shared_ptr get_or_create();\n\n ScopedFd create_counter(pid_t tid);\n void match_regs_and_open_counter(const Registers& regs, ScopedFd& counter);\n uint64_t skips() const {\n return *bpf_skips;\n }\n\n // Can't be private because of make_shared.\n BpfAccelerator(struct bpf_object* bpf_obj, int bpf_prog_fd,\n user_regs_struct* bpf_regs, uint64_t* bpf_skips)\n : bpf_obj(bpf_obj), bpf_prog_fd(bpf_prog_fd), bpf_regs(bpf_regs), bpf_skips(bpf_skips)\n {}\n\n ~BpfAccelerator() {\n munmap(bpf_skips, 4096);\n munmap(bpf_regs, 4096);\n bpf_object__close(bpf_obj);\n }\n\nprivate:\n static std::shared_ptr singleton;\n\n struct perf_event_attr attr;\n struct bpf_object* bpf_obj;\n // Not a ScopedFd because the bpf_object maintains ownership.\n int bpf_prog_fd;\n user_regs_struct* bpf_regs;\n uint64_t* bpf_skips;\n};\n\nstd::shared_ptr BpfAccelerator::singleton;\n\n/* static */ std::shared_ptr BpfAccelerator::get_or_create() {\n static int initialized;\n if (BpfAccelerator::singleton) {\n return BpfAccelerator::singleton;\n }\n\n if (!initialized) {\n initialized = -1;\n\n libbpf_set_strict_mode(LIBBPF_STRICT_DIRECT_ERRS);\n string path = resource_path() + \"share/rr/async_event_filter.o\";\n struct bpf_object* obj = bpf_object__open(path.c_str());\n if ((intptr_t)obj <= 0) {\n LOG(error) << \"Failed to find bpf at \" << path;\n return nullptr;\n }\n if (bpf_object__load(obj) < 0) {\n LOG(error) << \"Failed to load bpf at \" << path << \" into the kernel. Do we have permissions?\";\n bpf_object__close(obj);\n return nullptr;\n }\n int bpf_map_fd = bpf_object__find_map_fd_by_name(obj, \"registers\");\n if (bpf_map_fd < 0) {\n CLEAN_FATAL() << \"rr's bpf at \" << path << \" is corrupt\";\n return nullptr;\n }\n struct bpf_program* prog = bpf_object__next_program(obj, nullptr);\n if (!prog) {\n CLEAN_FATAL() << \"rr's bpf at \" << path << \" is corrupt\";\n return nullptr;\n }\n int bpf_prog_fd = bpf_program__fd(prog);\n if (bpf_prog_fd < 0) {\n CLEAN_FATAL() << \"rr's bpf at \" << path << \" is corrupt\";\n return nullptr;\n }\n\n auto bpf_regs = (struct user_regs_struct*)\n mmap(NULL, 4096, PROT_READ | PROT_WRITE,\n MAP_SHARED, bpf_map_fd, 0);\n if (bpf_regs == MAP_FAILED) {\n CLEAN_FATAL() << \"Failed to mmap bpf maps\";\n return nullptr;\n }\n\n bpf_map_fd = bpf_object__find_map_fd_by_name(obj, \"skips\");\n if (bpf_map_fd < 0) {\n CLEAN_FATAL() << \"rr's bpf at \" << path << \" is corrupt\";\n return nullptr;\n }\n\n auto bpf_skips = (uint64_t*)\n mmap(NULL, 4096, PROT_READ | PROT_WRITE,\n MAP_SHARED, bpf_map_fd, 0);\n if (bpf_regs == MAP_FAILED) {\n CLEAN_FATAL() << \"Failed to mmap bpf maps\";\n return nullptr;\n }\n\n BpfAccelerator::singleton =\n std::make_shared(obj, bpf_prog_fd, bpf_regs, bpf_skips);\n memset(&singleton->attr, 0, sizeof(singleton->attr));\n singleton->attr.type = PERF_TYPE_BREAKPOINT;\n singleton->attr.size = sizeof(attr);\n singleton->attr.bp_type = HW_BREAKPOINT_X;\n singleton->attr.bp_len = sizeof(long);\n singleton->attr.sample_period = 1;\n singleton->attr.sample_type = PERF_SAMPLE_IP;\n singleton->attr.pinned = 1;\n singleton->attr.exclude_kernel = 1;\n singleton->attr.exclude_hv = 1;\n singleton->attr.wakeup_events = 1;\n singleton->attr.precise_ip = 3;\n singleton->attr.disabled = 1;\n initialized = 1;\n }\n\n return BpfAccelerator::singleton;\n}\n\nScopedFd BpfAccelerator::create_counter(pid_t tid) {\n attr.bp_addr = 0;\n ScopedFd fd = start_counter(tid, -1, &attr);\n\n struct f_owner_ex own;\n own.type = F_OWNER_TID;\n own.pid = tid;\n if (fcntl(fd, F_SETOWN_EX, &own)) {\n FATAL() << \"Failed to SETOWN_EX bpf-accelerated breakpoint fd\";\n }\n\n make_counter_async(fd, SIGTRAP);\n\n if (ioctl(fd, PERF_EVENT_IOC_SET_BPF, bpf_prog_fd)) {\n FATAL() << \"Failed PERF_EVENT_IOC_SET_BPF\";\n }\n\n return fd;\n}\n\nvoid BpfAccelerator::match_regs_and_open_counter(const Registers& regs, ScopedFd& fd) {\n attr.bp_addr = regs.ip().register_value();\n if (ioctl(fd, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, &attr)) {\n FATAL() << \"Failed PERF_EVENT_IOC_MODIFY_ATTRIBUTES\";\n }\n\n auto r = regs.get_ptrace();\n memcpy(bpf_regs, &r, sizeof(struct user_regs_struct));\n *bpf_skips = 0;\n\n infallible_perf_event_enable_if_open(fd);\n}\n\nbool PerfCounters::accelerate_async_signal(const Registers& regs) {\n if (!fd_async_signal_accelerator.is_open()) {\n if (!bpf) {\n bpf = BpfAccelerator::get_or_create();\n }\n\n if (!bpf) {\n return false;\n }\n\n fd_async_signal_accelerator = bpf->create_counter(tid);\n }\n\n if (!fd_async_signal_accelerator.is_open()) {\n return false;\n }\n\n bpf->match_regs_and_open_counter(regs, fd_async_signal_accelerator);\n return true;\n}\n\nuint64_t PerfCounters::bpf_skips() const {\n if (!bpf) {\n return 0;\n }\n\n return bpf->skips();\n}\n#endif\n\n} // namespace rr\n" }, { "path": "src/PerfCounters.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PERF_COUNTERS_H_\n#define RR_PERF_COUNTERS_H_\n\n#ifndef _GNU_SOURCE\n#define _GNU_SOURCE 1\n#endif\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"CPUs.h\"\n#include \"PerfCounterBuffers.h\"\n#include \"ScopedFd.h\"\n#include \"Ticks.h\"\n\nnamespace rr {\n\nclass Registers;\nclass Task;\nclass BpfAccelerator;\n\nenum TicksSemantics {\n TICKS_RETIRED_CONDITIONAL_BRANCHES,\n TICKS_TAKEN_BRANCHES,\n};\n\n/**\n * A buffer of Intel PT control-flow data.\n */\nstruct PTData {\n PTData() {}\n explicit PTData(std::vector> data)\n : data(std::move(data)) {}\n std::vector> data;\n};\n\n/**\n * A class encapsulating the performance counters we use to monitor\n * each task during recording and replay.\n *\n * Normally we monitor a single kind of event that we use as a proxy\n * for progress, which we call \"ticks\". Currently this is the count of retired\n * conditional branches. We support dispatching a signal when the counter\n * reaches a particular value.\n */\nclass PerfCounters {\npublic:\n /**\n * Create performance counters monitoring the given task.\n * When enable is false, we always report 0 and don't do any interrupts.\n */\n enum Enabled {\n ENABLE,\n DISABLE\n };\n enum IntelPTEnabled {\n PT_DISABLE,\n PT_ENABLE\n };\n // `cpu_binding` must be `UNBOUND` or `SPECIFIED_CORE`.\n PerfCounters(pid_t tid, BindCPU cpu_binding, TicksSemantics ticks_semantics,\n Enabled enabled, IntelPTEnabled enable_pt);\n ~PerfCounters() { close(); }\n\n struct PTState {\n PTData pt_data;\n ScopedFd pt_perf_event_fd;\n PerfCounterBuffers perf_buffers;\n\n PTState() {}\n ~PTState() { close(); }\n\n void open(pid_t tid);\n // Returns number of bytes flushed\n size_t flush();\n void close();\n };\n\n void set_tid(pid_t tid);\n\n /**\n * Reset all counter values to 0 and program the counters to send\n * TIME_SLICE_SIGNAL when 'ticks_period' tick events have elapsed. (In reality\n * the hardware triggers its interrupt some time after that. We also allow\n * the interrupt to fire early.)\n * This must be called while the task is stopped, and it must be called\n * before the task is allowed to run again if it's going to trigger ticks.\n * `ticks_period` of zero means don't interrupt at all.\n * Opens all relevant fds if necessary.\n */\n void start(Task* t, Ticks ticks_period);\n\n enum class Error {\n // Everything ok\n None,\n // A transient error was detected. Retrying might succeed.\n Transient,\n };\n\n /**\n * Suspend counting until the next start.\n * Returns the current value of the ticks counter.\n * `t` is used for debugging purposes.\n * If `error` is non-null,`*error` will be set to `Error::Transient`\n * if a transient error is detected, otherwise `Error::None`.\n * If `error` is null and a transient error is detected, it will be\n * treated as fatal.\n */\n Ticks stop(Task* t, Error* error = nullptr);\n\n /**\n * Close the perfcounter fds (if open). They will be automatically reopened if/when\n * reset is called again. The counters must not be currently running.\n */\n void close();\n\n /**\n * Return the number of ticks we need for an emulated branch.\n */\n static Ticks ticks_for_unconditional_indirect_branch(Task*);\n /**\n * Return the number of ticks we need for an emulated direct branch.\n */\n static Ticks ticks_for_unconditional_direct_branch(Task*);\n /**\n * Return the number of ticks we need for a direct call.\n */\n static Ticks ticks_for_direct_call(Task*);\n\n /**\n * Whether PMU on core i is supported.\n */\n static bool support_cpu(int cpu);\n\n /**\n * Returns what ticks mean for these counters.\n */\n TicksSemantics ticks_semantics() const { return ticks_semantics_; }\n\n /**\n * Return the fd we last used to generate the ticks-counter signal.\n */\n int ticks_interrupt_fd() const { return fd_ticks_interrupt.get(); }\n\n /* This choice is fairly arbitrary; linux doesn't use SIGSTKFLT so we\n * hope that tracees don't either. */\n enum { TIME_SLICE_SIGNAL = SIGSTKFLT };\n\n static bool is_rr_ticks_attr(const perf_event_attr& attr);\n\n static bool supports_ticks_semantics(TicksSemantics ticks_semantics);\n\n static TicksSemantics default_ticks_semantics();\n\n /**\n * When an interrupt is requested, at most this many ticks may elapse before\n * the interrupt is delivered.\n */\n uint32_t skid_size();\n\n /**\n * If Intel PT data collection is on, returns the accumulated raw PT data\n * and clears the internal buffer.\n * Otherwise returns an empty buffer.\n */\n PTData extract_intel_pt_data();\n\n /**\n * Start the PT copy thread. We need to do this early, before CPU binding\n * has occurred.\n */\n static void start_pt_copy_thread();\n\n /**\n * Returns true iff we detected issues with performance counter configuration\n * and wanted to die but the user forced continuation.\n */\n static bool improperly_configured();\n\n /**\n * Try to use BPF to accelerate async signal processing\n */\n#ifdef BPF\n bool accelerate_async_signal(const Registers& regs);\n uint64_t bpf_skips() const;\n#else\n bool accelerate_async_signal(const Registers&) {\n return false;\n }\n uint64_t bpf_skips() const {\n return 0;\n }\n#endif\n\nprivate:\n template void reset_arch_extras(int pmu_index);\n\n /**\n * Use a separate skid_size for recording since we seem to see more skid\n * in practice during recording, in particular during the\n * async_signal_syscalls tests\n */\n uint32_t recording_skid_size() { return skid_size() * 5; }\n\n /**\n * If `error` is non-null,`*error` will be set to `Error::Transient`\n * if a transient error is detected, otherwise `Error::None`.\n * If `error` is null and a transient error is detected, it will be\n * treated as fatal.\n */\n Ticks read_ticks(Task* t, Error* error);\n\n // Only valid while 'counting' is true\n Ticks counting_period;\n pid_t tid;\n // Either 0 or the cpu index. Used to index into `perf_attrs`.\n int pmu_index;\n // We use separate fds for counting ticks and for generating interrupts. The\n // former ignores ticks in aborted transactions, and does not support\n // sample_period; the latter does not ignore ticks in aborted transactions,\n // but does support sample_period.\n ScopedFd fd_ticks_measure;\n ScopedFd fd_minus_ticks_measure;\n ScopedFd fd_ticks_interrupt;\n ScopedFd fd_useless_counter;\n\n // x86(_64) specific counter to support recording HLE\n ScopedFd fd_ticks_in_transaction;\n\n // aarch64 specific counter to detect use of ll/sc instructions\n ScopedFd fd_strex_counter;\n\n // BPF-enabled hardware breakpoint for fast async signal emulation.\n ScopedFd fd_async_signal_accelerator;\n\n std::shared_ptr bpf;\n\n std::unique_ptr pt_state;\n\n TicksSemantics ticks_semantics_;\n Enabled enabled;\n bool opened;\n bool counting;\n};\n\n} // namespace rr\n\n#endif /* RR_PERF_COUNTERS_H_ */\n" }, { "path": "src/PerfCounters_aarch64.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n// This file is included from PerfCounters.cc\n\nstruct CPUID {\n uint8_t implementer = 0;\n uint8_t variant = 0;\n uint16_t part = 0;\n operator bool() const\n {\n return implementer || variant || part;\n }\n // bool operator==(const CPUID&) const = default; // c++20\n bool operator==(const CPUID &other) const\n {\n return implementer == other.implementer &&\n variant == other.variant && part == other.part;\n }\n bool operator!=(const CPUID &other) const\n {\n return !(*this == other);\n }\n};\nstatic std::ostream &operator<<(std::ostream &stm, const CPUID &cpuid)\n{\n stm << std::hex << \"implementer: 0x\" << int(cpuid.implementer)\n << \", variant: 0x\" << int(cpuid.variant) << \" part: 0x\" << int(cpuid.part);\n return stm;\n}\n\n/**\n * Return the detected, known microarchitecture of this CPU, or don't\n * return; i.e. never return UnknownCpu.\n */\nstatic CpuMicroarch compute_cpu_microarch(const CPUID &cpuid) {\n switch (cpuid.implementer) {\n case 0x41: // ARM\n switch (cpuid.part) {\n case 0xd05:\n return ARMCortexA55;\n case 0xd0a:\n return ARMCortexA75;\n case 0xd0b:\n return ARMCortexA76;\n case 0xd0d:\n return ARMCortexA77;\n case 0xd41:\n case 0xd4b: // ARM Cortex A78C\n return ARMCortexA78;\n case 0xd44:\n case 0xd4c: // ARM Cortex X1C\n return ARMCortexX1;\n case 0xd0c:\n return ARMNeoverseN1;\n case 0xd49:\n return ARMNeoverseN2;\n case 0xd8e:\n return ARMNeoverseN3;\n case 0xd4a:\n return ARMNeoverseE1;\n case 0xd40:\n return ARMNeoverseV1;\n case 0xd4f:\n return ARMNeoverseV2;\n case 0xd83:\n return ARMNeoverseV3AE;\n case 0xd84:\n return ARMNeoverseV3;\n }\n break;\n case 0x51: // Qualcomm\n switch (cpuid.part) {\n case 0x802:\n return ARMCortexA75;\n case 0x803:\n return ARMCortexA55;\n case 0x804:\n return ARMCortexA76;\n case 0x805:\n return ARMCortexA55;\n }\n break;\n case 0x61: // Apple\n switch (cpuid.part) {\n case 0x22:\n case 0x24:\n case 0x28:\n return AppleM1Icestorm;\n case 0x23:\n case 0x25:\n case 0x29:\n return AppleM1Firestorm;\n case 0x32:\n case 0x34:\n case 0x38:\n return AppleM2Blizzard;\n case 0x33:\n case 0x35:\n case 0x39:\n return AppleM2Avalanche;\n }\n break;\n case 0xc0: // Ampere\n switch (cpuid.part) {\n case 0xac3:\n return AmpereOne;\n }\n break;\n }\n CLEAN_FATAL() << \"Unknown aarch64 CPU type \" << cpuid;\n return UnknownCpu; // not reached\n}\n\nstatic void set_cpuid(std::vector &cpuids, unsigned long cpuidx, CPUID cpuid)\n{\n if (cpuids.size() <= cpuidx) {\n cpuids.resize(cpuidx + 1);\n }\n if (cpuids[cpuidx]) {\n CLEAN_FATAL() << \"Duplicated CPUID for core \" << cpuidx;\n }\n cpuids[cpuidx] = cpuid;\n}\n\n/**\n * The new interface to get ID register values on AArch64\n * `/sys/devices/system/cpu/cpu([0-9]+)/regs/identification/midr_el1`\n * The register value is stored in hex.\n */\nstatic inline void get_cpuinfo_sysfs(std::vector &res)\n{\n const std::string cpu_dir = \"/sys/devices/system/cpu/\";\n const std::regex cpuname_regex(\"cpu([0-9]+)\");\n auto dir = opendir(cpu_dir.c_str());\n if (!dir) {\n return;\n }\n while (auto entry = readdir(dir)) {\n std::cmatch match;\n if (entry->d_type != DT_DIR ||\n !std::regex_match(entry->d_name, match, cpuname_regex)) {\n continue;\n }\n auto cpuidx = std::stoul(match[1].str());\n std::string name = cpu_dir + entry->d_name + \"/regs/identification/midr_el1\";\n std::ifstream file(name);\n if (!file) {\n CLEAN_FATAL() << \"Failed to read midr register from kernel\";\n }\n uint64_t val = 0;\n file >> std::hex >> val;\n if (!file) {\n CLEAN_FATAL() << \"Failed to read midr register from kernel\";\n }\n set_cpuid(res, cpuidx, {\n uint8_t(val >> 24),\n uint8_t((val >> 20) & 0xf),\n uint16_t((val >> 4) & 0xfff)\n });\n }\n closedir(dir);\n}\n\n/**\n * A line we care about in /proc/cpuinfo starts with a prefix followed by\n * `:` and some white space characters, then followed by the value we care about.\n * Return true if we've found the prefix. Set `flag` to `false`\n * if the value parsing failed.\n *\n * Use an external template since lambda's can't be templated in C++11\n */\ntemplate\nstatic inline bool try_read_procfs_line(const std::string &line,\n const char *prefix, T &out,\n bool &flag, F &&reset)\n{\n size_t prefix_len = strlen(prefix);\n if (line.size() < prefix_len) {\n return false;\n }\n if (memcmp(&line[0], prefix, prefix_len) != 0) {\n return false;\n }\n if (flag) {\n // We've seen this already,\n // i.e. we didn't see a new line between the processor lines\n reset();\n }\n const char *p = &line[prefix_len];\n // Skip blank and `:`.\n while (*p == '\\t' || *p == ' ' || *p == ':') {\n p++;\n }\n char *str_end;\n auto num = std::strtoull(p, &str_end, 0);\n out = (T)num;\n if (str_end == p) {\n flag = false;\n } else if (num > (unsigned long long)std::numeric_limits::max()) {\n flag = false;\n } else {\n flag = true;\n }\n return true;\n}\n\n/**\n * /proc/cpuinfo reader\n * The cpuinfo file contains blocks of text for each core.\n * The blocks are separated by empty lines and it should start with a\n * `processor : ` line followed by lines showing properties of the core.\n * The three property lines we are looking for starts with\n * `CPU implementer`, `CPU variant` and `CPU part`.\n */\nstatic inline void get_cpuinfo_procfs(std::vector &res)\n{\n std::ifstream file(\"/proc/cpuinfo\");\n CPUID cpuid = {0, 0, 0};\n unsigned cpuidx = 0;\n bool has_cpuidx = false;\n bool has_impl = false;\n bool has_part = false;\n bool has_var = false;\n auto reset = [&] () {\n // Few (none) of the detection code care about the variant number\n // so we'll accept it if we couldn't read it.\n if (has_cpuidx && has_impl && has_part) {\n set_cpuid(res, cpuidx, cpuid);\n }\n has_cpuidx = false;\n has_impl = false;\n has_part = false;\n has_var = false;\n cpuid = {0, 0, 0};\n };\n for (std::string line; std::getline(file, line);) {\n // Empty lines means that we've finished processing of a block\n if (line.empty()) {\n reset();\n continue;\n }\n // First find the processor line\n if (try_read_procfs_line(line, \"processor\", cpuidx, has_cpuidx, reset)) {\n continue;\n }\n // and ignore the line until we found the processor line.\n if (!has_cpuidx) {\n continue;\n }\n\n // Try parsing as one of the data lines.\n // Short circuiting after the first hit.\n try_read_procfs_line(line, \"CPU implementer\", cpuid.implementer, has_impl, reset) ||\n try_read_procfs_line(line, \"CPU variant\", cpuid.variant, has_var, reset) ||\n try_read_procfs_line(line, \"CPU part\", cpuid.part, has_part, reset);\n }\n reset();\n}\n\nstatic vector compute_cpus_info() {\n vector result;\n vector cpuids;\n get_cpuinfo_sysfs(cpuids);\n if (cpuids.empty()) {\n LOG(warn) << \"Unable to read CPU type from sysfs, trying procfs instead.\";\n get_cpuinfo_procfs(cpuids);\n }\n if (cpuids.empty()) {\n CLEAN_FATAL() << \"Failed to read midr register from kernel\";\n }\n for (auto &cpuid : cpuids) {\n if (!cpuid) {\n CLEAN_FATAL() << \"Unable to find CPU id for core \" << &cpuid - &cpuids[0];\n }\n }\n auto cpuid0 = cpuids[0];\n bool single_uarch = true;\n for (auto &cpuid : cpuids) {\n if (cpuid != cpuid0) {\n single_uarch = false;\n break;\n }\n }\n if (single_uarch) {\n result.push_back({compute_cpu_microarch(cpuid0), PERF_TYPE_RAW});\n return result;\n }\n for (auto &cpuid : cpuids) {\n result.push_back({compute_cpu_microarch(cpuid), PERF_TYPE_RAW});\n }\n return result;\n}\n\nstatic void arch_check_restricted_counter() {\n if (!Flags::get().suppress_environment_warnings) {\n fprintf(stderr,\n \"Your CPU supports only one performance counter.\\n\"\n \"Use of LL/SC instructions will not be detected and will\\n\"\n \"cause silently corrupt recordings. It is highly recommended\\n\"\n \"that you alter your configuration to enable additional performance\\n\"\n \"counters.\\n\");\n }\n}\n\nstatic bool always_recreate_counters(__attribute__((unused)) const perf_event_attrs &perf_attr) {\n return false;\n}\n\nstatic void check_for_arch_bugs(__attribute__((unused)) perf_event_attrs &perf_attr) {}\n\nstatic void post_init_pmu_uarchs(std::vector &pmu_uarchs)\n{\n std::map pmu_types;\n size_t npmus = pmu_uarchs.size();\n int pmu_type_failed = 0;\n auto fallback_pmu = [] (PmuConfig &pmu_uarch) {\n pmu_uarch.pmu_name = nullptr;\n if (pmu_uarch.cycle_type != PERF_TYPE_HARDWARE) {\n pmu_uarch.cycle_type = PERF_TYPE_HARDWARE;\n pmu_uarch.cycle_event = PERF_COUNT_HW_CPU_CYCLES;\n }\n if (pmu_uarch.event_type != PERF_TYPE_RAW) {\n pmu_uarch.event_type = PERF_TYPE_RAW;\n }\n };\n auto set_pmu_type = [] (PmuConfig &pmu_uarch, int type) {\n if (pmu_uarch.cycle_type != PERF_TYPE_HARDWARE) {\n pmu_uarch.cycle_type = type;\n }\n if (pmu_uarch.event_type != PERF_TYPE_RAW) {\n pmu_uarch.event_type = type;\n }\n };\n bool has_unknown = false;\n for (size_t i = 0; i < npmus; i++) {\n auto &pmu_uarch = pmu_uarchs[i];\n if (!(pmu_uarch.flags & (PMU_TICKS_RCB | PMU_TICKS_TAKEN_BRANCHES))) {\n has_unknown = true;\n continue;\n }\n if (!pmu_uarch.pmu_name) {\n CLEAN_FATAL() << \"Unknown PMU name for core \" << i;\n continue;\n }\n std::string pmu_name(pmu_uarch.pmu_name);\n auto &pmu_type = pmu_types[pmu_name];\n if (pmu_type == -1) {\n fallback_pmu(pmu_uarch);\n continue;\n }\n if (pmu_type) {\n set_pmu_type(pmu_uarch, pmu_type);\n continue;\n }\n auto filename = \"/sys/bus/event_source/devices/\" + pmu_name + \"/type\";\n std::ifstream file(filename);\n int val = 0;\n bool failed = false;\n if (!file) {\n failed = true;\n LOG(warn) << \"Cannot open \" << filename;\n }\n else {\n file >> val;\n if (!file) {\n failed = true;\n LOG(warn) << \"Cannot read \" << filename;\n }\n }\n if (failed) {\n // Record the failure and fallback to the kernel raw and hardware events instead\n pmu_type_failed++;\n fallback_pmu(pmu_uarch);\n pmu_type = -1;\n }\n else {\n set_pmu_type(pmu_uarch, val);\n pmu_type = val;\n }\n }\n if (pmu_types.size() == 1 && !has_unknown) {\n bool single_type = true;\n auto &pmu_uarch0 = pmu_uarchs[0];\n // Apparently the same PMU type doesn't actually mean the same PMU events...\n for (auto &pmu_uarch: pmu_uarchs) {\n if (&pmu_uarch == &pmu_uarch0) {\n // Skip first\n continue;\n }\n if (pmu_uarch.rcb_cntr_event != pmu_uarch0.rcb_cntr_event ||\n pmu_uarch.minus_ticks_cntr_event != pmu_uarch0.minus_ticks_cntr_event ||\n pmu_uarch.llsc_cntr_event != pmu_uarch0.llsc_cntr_event) {\n single_type = false;\n break;\n }\n }\n if (single_type) {\n // Single PMU type\n pmu_uarchs.resize(1);\n }\n }\n if (pmu_uarchs.size() != 1 && pmu_type_failed) {\n // If reading PMU type failed, we only allow a single PMU type to be sure\n // that we get what we want from the kernel events.\n CLEAN_FATAL() << \"Unable to read PMU event types\";\n }\n}\n\ntemplate <>\nvoid PerfCounters::reset_arch_extras(int pmu_index) {\n // LL/SC can't be recorded reliably. Start a counter to detect\n // any usage, such that we can give an intelligent error message.\n struct perf_event_attr attr = perf_attrs[pmu_index].llsc_fail;\n attr.sample_period = 0;\n fd_strex_counter = start_counter(tid, fd_ticks_interrupt, &attr);\n}\n" }, { "path": "src/PerfCounters_x86.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n// This file is included from PerfCounters.cc\n\nstatic bool has_kvm_in_txcp_bug;\nstatic bool has_xen_pmi_bug;\nstatic bool supports_txcp;\n\n/**\n * Return the detected, known microarchitecture of this CPU, or don't\n * return; i.e. never return UnknownCpu.\n *\n * Another way to do this would be to read the pmu type under\n * /sys/devices/.../caps/pmu_name. There are tradeoffs:\n * * With the current approach, rr works with old kernels that haven't\n * been updated with specific knowledge of the CPU type. Reading\n * `pmu_name`, rr would not work.\n * * Reading `pmu_name`, rr would work with new CPUs that use an\n * existing PMU type, if the kernel is new enough to know about those\n * CPUs. With the current approach users have to have an rr that has\n * been updated for those CPUs.\n * Assuming that it's easier to update rr than update one's kernel,\n * the current approach seems a little better.\n *\n * This detects the overall microarchitecture, which we also use\n * as the microarchitecture identifier for the P-cores of that architecture\n * in a hybrid setup.\n */\nstatic CpuMicroarch compute_cpu_microarch() {\n auto cpuid_vendor = cpuid(CPUID_GETVENDORSTRING, 0);\n char vendor[12];\n memcpy(&vendor[0], &cpuid_vendor.ebx, 4);\n memcpy(&vendor[4], &cpuid_vendor.edx, 4);\n memcpy(&vendor[8], &cpuid_vendor.ecx, 4);\n if (strncmp(vendor, \"GenuineIntel\", sizeof(vendor)) &&\n strncmp(vendor, \"AuthenticAMD\", sizeof(vendor))) {\n CLEAN_FATAL() << \"Unknown CPU vendor '\" << vendor << \"'\";\n }\n\n auto cpuid_data = cpuid(CPUID_GETFEATURES, 0);\n unsigned int cpu_type = cpuid_data.eax & 0xF0FF0;\n unsigned int ext_family = (cpuid_data.eax >> 20) & 0xff;\n switch (cpu_type) {\n case 0x006F0:\n case 0x10660:\n return IntelMerom;\n case 0x10670:\n case 0x106D0:\n return IntelPenryn;\n case 0x106A0:\n case 0x106E0:\n case 0x206E0:\n return IntelNehalem;\n case 0x20650:\n case 0x206C0:\n case 0x206F0:\n return IntelWestmere;\n case 0x206A0:\n case 0x206D0:\n case 0x306e0:\n return IntelSandyBridge;\n case 0x306A0:\n return IntelIvyBridge;\n case 0x306C0: /* Devil's Canyon */\n case 0x306F0:\n case 0x40650:\n case 0x40660:\n return IntelHaswell;\n case 0x306D0:\n case 0x40670:\n case 0x406F0:\n case 0x50660:\n return IntelBroadwell;\n case 0x406e0:\n case 0x50650:\n case 0x506e0:\n return IntelSkylake;\n case 0x30670:\n case 0x406c0:\n case 0x50670:\n return IntelSilvermont;\n case 0x506f0:\n case 0x706a0:\n case 0x506c0:\n return IntelGoldmont;\n case 0x906c0:\n return IntelTremont;\n case 0x706e0:\n case 0x606a0:\n case 0x80660:\n return IntelIceLake;\n case 0x806c0:\n case 0x806d0:\n return IntelTigerLake;\n case 0x806e0:\n case 0x906e0:\n return IntelKabyLake;\n case 0xa0650:\n case 0xa0660:\n return IntelCometLake;\n case 0xa0670:\n return IntelRocketLake;\n case 0x90670:\n case 0x906a0:\n return IntelAlderLake;\n case 0xb0670:\n case 0xb06a0:\n case 0xb06f0:\n return IntelRaptorLake;\n case 0x806f0:\n return IntelSapphireRapids;\n case 0xc06f0:\n return IntelEmeraldRapids;\n case 0xa06d0:\n return IntelGraniteRapids;\n case 0xa06a0:\n return IntelMeteorLake;\n case 0xb06d0:\n return IntelLunarLake;\n case 0xb06e0:\n return IntelGracemont;\n case 0xb0650:\n case 0xc0650:\n case 0xc0660:\n return IntelArrowLake;\n case 0xf20: // Piledriver\n case 0x30f00: // Steamroller\n return AMDF15;\n case 0x00f10: // A8-3530MX, Naples, Whitehaven, Summit Ridge, Snowy Owl (Zen), Milan (Zen 3) (UNTESTED)\n if (ext_family == 8) {\n return AMDZen;\n } else if (ext_family == 0xa) {\n return AMDZen3;\n } else if (ext_family == 3) {\n return AMDF15;\n }\n break;\n case 0x00f80: // Colfax, Pinnacle Ridge (Zen+), Chagall (Zen3) (UNTESTED)\n if (ext_family == 8) {\n return AMDZen;\n } else if (ext_family == 0xa) {\n return AMDZen3;\n }\n break;\n case 0x10f10: // Raven Ridge, Great Horned Owl (Zen) (UNTESTED)\n case 0x10f80: // Banded Kestrel (Zen), Picasso (Zen+), 7975WX (Zen2)\n case 0x20f00: // Dali (Zen)\n if (ext_family == 8) {\n return AMDZen;\n } else if (ext_family == 0xa) {\n return AMDZen2;\n }\n break;\n case 0x30f10: // Rome, Castle Peak (Zen 2)\n case 0x60f00: // Renoir (Zen 2), Krackan Point (Zen 5) (EXPERIMENTAL)\n case 0x70f10: // Matisse (Zen 2)\n case 0x60f80: // Lucienne (Zen 2)\n case 0x90f00: // Van Gogh (Zen 2)\n if (ext_family == 8) {\n return AMDZen2;\n } else if (ext_family == 0xb) {\n return AMDZen5;\n }\n break;\n case 0x20f10: // Vermeer (Zen 3)\n case 0x50f00: // Cezanne (Zen 3)\n case 0x40f40: // Rembrandt (Zen 3+)\n return AMDZen3;\n case 0x60f10: // Raphael (Zen 4)\n case 0x70f40: // Phoenix (Zen 4)\n case 0x70f50: // Hawk Point (Zen 4)\n return AMDZen4;\n case 0x20f40: // Strix Point (Zen 5)\n case 0x70f00: // Strix Halo (Zen 5)\n return AMDZen5;\n default:\n break;\n }\n\n if (!strncmp(vendor, \"AuthenticAMD\", sizeof(vendor))) {\n CLEAN_FATAL() << \"AMD CPU type \" << HEX(cpu_type) <<\n \" (ext family \" << HEX(ext_family) << \") unknown\";\n } else {\n CLEAN_FATAL() << \"Intel CPU type \" << HEX(cpu_type) << \" unknown\";\n }\n return UnknownCpu; // not reached\n}\n\nstatic vector compute_cpus_info() {\n vector result;\n auto groups = CPUs::get().cpu_groups();\n if (groups.empty()) {\n // Only one kind of CPU core.\n result.push_back({compute_cpu_microarch(), PERF_TYPE_RAW});\n return result;\n }\n\n for (int cpu : CPUs::get().initial_affinity()) {\n if (cpu < static_cast(result.size()) &&\n result[cpu].microarch != UnknownCpu) {\n // This cpu belongs to a group we already computed the microarch for.\n // Using groups like this lets us avoid having to schedule this thread\n // on every single CPU in the system.\n continue;\n }\n while (static_cast(result.size()) < cpu) {\n result.push_back({UnknownCpu, PERF_TYPE_RAW});\n }\n if (!CPUs::set_affinity_to_cpu(cpu)) {\n FATAL() << \"Can't set affinity to previously allowed CPU\";\n }\n CpuMicroarch uarch = compute_cpu_microarch();\n // May be overwritten below if this is part of a known hybrid core grouping.\n result.push_back({uarch, PERF_TYPE_RAW});\n // Fill in `result` for all CPUs in the same group as the current CPU.\n // This avoids having to schedule this thread on every single CPU in the\n // system.\n for (auto group : groups) {\n if (group.start_cpu <= cpu && cpu < group.end_cpu) {\n result.resize(group.end_cpu);\n if (group.name == \"atom\") {\n switch (uarch) {\n case IntelAlderLake:\n case IntelRaptorLake:\n uarch = IntelGracemont;\n break;\n case IntelMeteorLake:\n uarch = IntelCrestmont;\n break;\n case IntelLunarLake:\n case IntelArrowLake:\n // Some Arrow Lakes use Crestmont E-cores maybe? Hopefully doesn't matter\n // for the PMU.\n uarch = IntelSkymont;\n break;\n default:\n FATAL() << \"Atom architecture detected but not known for \" << uarch;\n }\n } else if (group.name == \"lowpower\") {\n switch (uarch) {\n case IntelArrowLake:\n uarch = IntelCrestmont;\n break;\n default:\n FATAL() << \"Lowpower architecture detected but not known for \" << uarch;\n }\n } else if (group.name != \"core\") {\n FATAL() << \"Hybrid architecture group name not known: \" << group.name;\n }\n for (int i = group.start_cpu; i < group.end_cpu; ++i) {\n result[i] = {uarch, group.type};\n }\n break;\n }\n }\n }\n CPUs::get().restore_initial_affinity();\n return result;\n}\n\nstatic void check_for_kvm_in_txcp_bug(const perf_event_attrs &perf_attr) {\n int64_t count = 0;\n struct perf_event_attr attr = perf_attr.ticks;\n attr.config |= IN_TXCP;\n attr.sample_period = 0;\n bool disabled_txcp;\n ScopedFd fd = start_counter(0, -1, &attr, &disabled_txcp);\n if (fd.is_open() && !disabled_txcp) {\n ioctl(fd, PERF_EVENT_IOC_DISABLE, 0);\n ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);\n do_branches();\n count = read_counter(fd);\n }\n\n supports_txcp = count > 0;\n has_kvm_in_txcp_bug = supports_txcp && count < NUM_BRANCHES;\n LOG(debug) << \"supports txcp=\" << supports_txcp;\n LOG(debug) << \"has_kvm_in_txcp_bug=\" << has_kvm_in_txcp_bug\n << \" count=\" << count;\n}\n\nstatic void check_for_xen_pmi_bug(const perf_event_attrs &perf_attr) {\n int32_t count = -1;\n struct perf_event_attr attr = perf_attr.ticks;\n attr.sample_period = NUM_BRANCHES - 1;\n ScopedFd fd = start_counter(0, -1, &attr);\n if (fd.is_open()) {\n // Do NUM_BRANCHES conditional branches that can't be optimized out.\n // 'accumulator' is always odd and can't be zero\n uint32_t accumulator = uint32_t(rand()) * 2 + 1;\n int raw_fd = fd;\n asm volatile(\n#if defined(__x86_64__)\n \"mov %[_SYS_ioctl], %%rax;\"\n \"mov %[raw_fd], %%edi;\"\n \"xor %%rdx, %%rdx;\"\n \"mov %[_PERF_EVENT_IOC_ENABLE], %%rsi;\"\n \"syscall;\"\n \"cmp $-4095, %%rax;\"\n \"jae 2f;\"\n \"mov %[_SYS_ioctl], %%rax;\"\n \"mov %[_PERF_EVENT_IOC_RESET], %%rsi;\"\n \"syscall;\"\n // From this point on all conditional branches count!\n \"cmp $-4095, %%rax;\"\n \"jae 2f;\"\n // Reset the counter period to the desired value.\n \"mov %[_SYS_ioctl], %%rax;\"\n \"mov %[_PERF_EVENT_IOC_PERIOD], %%rsi;\"\n \"mov %[period], %%rdx;\"\n \"syscall;\"\n \"cmp $-4095, %%rax;\"\n \"jae 2f;\"\n \"mov %[_iterations], %%rax;\"\n \"1: dec %%rax;\"\n // Multiply by 7.\n \"mov %[accumulator], %%edx;\"\n \"shl $3, %[accumulator];\"\n \"sub %%edx, %[accumulator];\"\n // Add 2.\n \"add $2, %[accumulator];\"\n // Mask off bits.\n \"and $0xffffff, %[accumulator];\"\n // And loop.\n \"test %%rax, %%rax;\"\n \"jnz 1b;\"\n \"mov %[_PERF_EVENT_IOC_DISABLE], %%rsi;\"\n \"mov %[_SYS_ioctl], %%rax;\"\n \"xor %%rdx, %%rdx;\"\n // We didn't touch rdi.\n \"syscall;\"\n \"cmp $-4095, %%rax;\"\n \"jae 2f;\"\n \"movl $0, %[count];\"\n \"2: nop;\"\n#elif defined(__i386__)\n \"mov %[_SYS_ioctl], %%eax;\"\n \"mov %[raw_fd], %%ebx;\"\n \"xor %%edx, %%edx;\"\n \"mov %[_PERF_EVENT_IOC_ENABLE], %%ecx;\"\n \"int $0x80;\"\n \"cmp $-4095, %%eax;\"\n \"jae 2f;\"\n \"mov %[_SYS_ioctl], %%eax;\"\n \"mov %[_PERF_EVENT_IOC_RESET], %%ecx;\"\n \"int $0x80;\"\n // From this point on all conditional branches count!\n \"cmp $-4095, %%eax;\"\n \"jae 2f;\"\n // Reset the counter period to the desired value.\n \"mov %[_SYS_ioctl], %%eax;\"\n \"mov %[_PERF_EVENT_IOC_PERIOD], %%ecx;\"\n \"mov %[period], %%edx;\"\n \"int $0x80;\"\n \"cmp $-4095, %%eax;\"\n \"jae 2f;\"\n \"mov %[_iterations], %%eax;\"\n \"1: dec %%eax;\"\n // Multiply by 7.\n \"mov %[accumulator], %%edx;\"\n \"shll $3, %[accumulator];\"\n \"sub %%edx, %[accumulator];\"\n // Add 2.\n \"addl $2, %[accumulator];\"\n // Mask off bits.\n \"andl $0xffffff, %[accumulator];\"\n // And loop.\n \"test %%eax, %%eax;\"\n \"jnz 1b;\"\n \"mov %[_PERF_EVENT_IOC_DISABLE], %%ecx;\"\n \"mov %[_SYS_ioctl], %%eax;\"\n \"xor %%edx, %%edx;\"\n // We didn't touch rdi.\n \"int $0x80;\"\n \"cmp $-4095, %%eax;\"\n \"jae 2f;\"\n \"movl $0, %[count];\"\n \"2: nop;\"\n#else\n#error unknown CPU architecture\n#endif\n : [accumulator] \"+rm\"(accumulator), [count] \"=rm\"(count)\n : [_SYS_ioctl] \"i\"(SYS_ioctl),\n [_PERF_EVENT_IOC_DISABLE] \"i\"(PERF_EVENT_IOC_DISABLE),\n [_PERF_EVENT_IOC_ENABLE] \"i\"(PERF_EVENT_IOC_ENABLE),\n [_PERF_EVENT_IOC_PERIOD] \"i\"(PERF_EVENT_IOC_PERIOD),\n [_PERF_EVENT_IOC_RESET] \"i\"(PERF_EVENT_IOC_RESET),\n // The check for the failure of some of our ioctls is in\n // the measured region, so account for that when looping.\n [_iterations] \"i\"(NUM_BRANCHES - 2),\n [period] \"rm\"(&attr.sample_period), [raw_fd] \"rm\"(raw_fd)\n :\n#if defined(__x86_64__)\n \"rax\", \"rdx\", \"rdi\", \"rsi\"\n // `syscall` clobbers rcx and r11.\n ,\n \"rcx\", \"r11\"\n#elif defined(__i386__)\n \"eax\", \"ebx\", \"ecx\", \"edx\"\n#else\n#error unknown CPU architecture\n#endif\n );\n // If things worked above, `count` should have been set to 0.\n if (count == 0) {\n count = read_counter(fd);\n }\n // Use 'accumulator' so it can't be optimized out.\n accumulator_sink = accumulator;\n }\n\n has_xen_pmi_bug = count > NUM_BRANCHES || count == -1;\n if (has_xen_pmi_bug) {\n LOG(debug) << \"has_xen_pmi_bug=\" << has_xen_pmi_bug << \" count=\" << count;\n if (!Flags::get().force_things) {\n FATAL()\n << \"Overcount triggered by PMU interrupts detected due to Xen PMU \"\n \"virtualization bug.\\n\"\n \"Aborting. Retry with -F to override, but it will probably\\n\"\n \"fail.\";\n } else {\n cpu_improperly_configured = true;\n }\n }\n}\n\nstatic void check_for_zen_speclockmap() {\n // When the SpecLockMap optimization is not disabled, rr will not work\n // reliably (e.g. it would work fine on a single process with a single\n // thread, but not more). When the optimization is disabled, the\n // perf counter for retired lock instructions of type SpecLockMapCommit\n // (on PMC 0x25) stays at 0.\n // See more details at https://github.com/rr-debugger/rr/issues/2034.\n struct perf_event_attr attr;\n // 0x25 == RETIRED_LOCK_INSTRUCTIONS - Counts the number of retired locked instructions\n // + 0x08 == SPECLOCKMAPCOMMIT\n init_perf_event_attr(&attr, PERF_TYPE_RAW, 0x510825);\n\n ScopedFd fd = start_counter(0, -1, &attr);\n if (fd.is_open()) {\n int atomic = 0;\n int64_t count = read_counter(fd);\n // A lock add is known to increase the perf counter we're looking at.\n asm volatile(\"lock addl $1, %0\": \"+m\" (atomic));\n if (read_counter(fd) == count) {\n LOG(debug) << \"SpecLockMap is disabled\";\n } else {\n LOG(debug) << \"SpecLockMap is not disabled\";\n if (!Flags::get().force_things) {\n CLEAN_FATAL() <<\n \"On Zen CPUs, rr will not work reliably unless you disable the \"\n \"hardware SpecLockMap optimization.\\nFor instructions on how to \"\n \"do this, see https://github.com/rr-debugger/rr/wiki/Zen\\n\";\n } else {\n cpu_improperly_configured = true;\n }\n }\n }\n}\n\nstatic void check_for_freeze_on_smi() {\n ScopedFd fd = ScopedFd(\"/sys/devices/cpu/freeze_on_smi\", O_RDONLY);\n if (!fd.is_open()) {\n LOG(debug) << \"/sys/devices/cpu/freeze_on_smi not present\";\n return;\n }\n\n char freeze_on_smi = 0;\n ssize_t ret = read(fd, &freeze_on_smi, 1);\n if (ret != 1) {\n FATAL() << \"Can't read freeze_on_smi\";\n }\n if (freeze_on_smi == 0) {\n LOG(warn) << \"Failed to read freeze_on_smi\";\n } else if (freeze_on_smi == '1') {\n LOG(debug) << \"freeze_on_smi is set\";\n } else if (freeze_on_smi == '0') {\n LOG(warn) << \"freeze_on_smi is not set\";\n if (!Flags::get().force_things) {\n CLEAN_FATAL() <<\n \"Freezing performance counters on SMIs should be enabled for maximum rr\\n\"\n \"reliability on Comet Lake and later CPUs. To manually enable this setting, run\\n\"\n \"\\techo 1 | sudo tee /sys/devices/cpu/freeze_on_smi\\n\"\n \"On systemd systems, consider putting\\n\"\n \"'w /sys/devices/cpu/freeze_on_smi - - - - 1' into /etc/tmpfiles.d/10-rr.conf\\n\"\n \"to automatically apply this setting on every reboot.\\n\"\n \"See 'man 5 sysfs', 'man 5 tmpfiles.d'.\\n\"\n \"If you are seeing this message, the setting has not been enabled.\\n\";\n } else {\n cpu_improperly_configured = true;\n }\n } else {\n LOG(warn) << \"Unrecognized freeze_on_smi value \" << freeze_on_smi;\n }\n}\n\n// Must be run on the CPU where we're checking for bugs.\nstatic void check_for_arch_bugs(perf_event_attrs &perf_attr) {\n CpuMicroarch uarch = (CpuMicroarch)perf_attr.bug_flags;\n if (uarch >= FirstIntel && uarch <= LastIntel) {\n check_for_kvm_in_txcp_bug(perf_attr);\n check_for_xen_pmi_bug(perf_attr);\n }\n if (uarch >= IntelCometLake && uarch <= LastIntel) {\n check_for_freeze_on_smi();\n }\n if (uarch >= AMDZen && uarch <= LastAMD) {\n check_for_zen_speclockmap();\n }\n}\n\nstatic void post_init_pmu_uarchs(std::vector &) {\n\n}\n\nstatic bool always_recreate_counters(const perf_event_attrs &perf_attr) {\n // When we have the KVM IN_TXCP bug, reenabling the TXCP counter after\n // disabling it does not work.\n DEBUG_ASSERT(perf_attr.checked);\n return perf_attr.has_ioc_period_bug || has_kvm_in_txcp_bug;\n}\n\nstatic void arch_check_restricted_counter() {\n if ((cpuid(CPUID_GETEXTENDEDFEATURES, 0).ebx & HLE_FEATURE_FLAG) &&\n !Flags::get().suppress_environment_warnings) {\n fprintf(stderr,\n \"Your CPU supports Hardware Lock Elision but you only have one\\n\"\n \"hardware performance counter available. Record and replay\\n\"\n \"of code that uses HLE will fail unless you alter your\\n\"\n \"configuration to make more than one hardware performance counter\\n\"\n \"available.\\n\");\n }\n}\n\ntemplate \nvoid PerfCounters::reset_arch_extras(int pmu_index) {\n if (supports_txcp) {\n struct perf_event_attr attr = rr::perf_attrs[pmu_index].ticks;\n if (has_kvm_in_txcp_bug) {\n // IN_TXCP isn't going to work reliably. Assume that HLE/RTM are not\n // used,\n // and check that.\n attr.sample_period = 0;\n attr.config |= IN_TX;\n fd_ticks_in_transaction = start_counter(tid, fd_ticks_interrupt, &attr);\n } else {\n // Set up a separate counter for measuring ticks, which does not have\n // a sample period and does not count events during aborted\n // transactions.\n // We have to use two separate counters here because the kernel does\n // not support setting a sample_period with IN_TXCP, apparently for\n // reasons related to this Intel note on IA32_PERFEVTSEL2:\n // ``When IN_TXCP=1 & IN_TX=1 and in sampling, spurious PMI may\n // occur and transactions may continuously abort near overflow\n // conditions. Software should favor using IN_TXCP for counting over\n // sampling. If sampling, software should use large “sample-after“\n // value after clearing the counter configured to use IN_TXCP and\n // also always reset the counter even when no overflow condition\n // was reported.''\n attr.sample_period = 0;\n attr.config |= IN_TXCP;\n fd_ticks_measure = start_counter(tid, fd_ticks_interrupt, &attr);\n }\n }\n}\n" }, { "path": "src/PidFdMonitor.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"PidFdMonitor.h\"\n\n#include \"Session.h\"\n\nnamespace rr {\n\n/* static */ PidFdMonitor*\nPidFdMonitor::get(FdTable* fd_table, int fd) {\n FileMonitor* monitor = fd_table->get_monitor(fd);\n if (!monitor) {\n return NULL;\n }\n\n if (monitor->type() == PidFd) {\n return static_cast(monitor);\n }\n\n return NULL;\n}\n\nFdTable::shr_ptr\nPidFdMonitor::fd_table(Session& session) const {\n Task* t = session.find_task(tuid);\n if (!t) {\n return NULL;\n }\n\n return t->fd_table();\n}\n\n}\n" }, { "path": "src/PidFdMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PID_FD_MONITOR_H_\n#define RR_PID_FD_MONITOR_H_\n\n#include \"FdTable.h\"\n#include \"FileMonitor.h\"\n#include \"TaskishUid.h\"\n\nstruct perf_event_attr;\n\nnamespace rr {\n\nclass Session;\n\n/**\n * A FileMonitor to handle pidfd fds\n */\nclass PidFdMonitor : public FileMonitor {\npublic:\n PidFdMonitor(TaskUid tuid)\n : tuid(tuid) {}\n\n virtual Type type() override { return PidFd; }\n\n static PidFdMonitor* get(FdTable* fd_table, int fd);\n\n FdTable::shr_ptr fd_table(Session& session) const;\n\nprivate:\n // 0 if this doesn't object doesn't refer to a tracee's proc-mem.\n TaskUid tuid;\n};\n\n} // namespace rr\n\n#endif /* RR_PID_FD_MONITOR_H_ */\n" }, { "path": "src/PreserveFileMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PRESERVE_FILE_MONITOR_H_\n#define RR_PRESERVE_FILE_MONITOR_H_\n\n#include \"FileMonitor.h\"\n\nnamespace rr {\n\n/**\n * A FileMonitor that does no monitoring of I/O itself, but prevents the file\n * descriptor from being closed (except via privileged syscalls made by\n * preload.c) or seen in /proc/pid/fd/.\n *\n * The mere existence of this monitor disables syscall buffering for the fd, so\n * we get syscall traps for close() etc on the fd. Then\n * rec_prepare_syscall_arch calls allow_close() to check whether closing is\n * allowed.\n */\nclass PreserveFileMonitor : public FileMonitor {\npublic:\n PreserveFileMonitor() {}\n virtual Type type() override { return Preserve; }\n virtual bool is_rr_fd() override { return true; }\n};\n\n} // namespace rr\n\n#endif /* RR_PRESERVE_FILE_MONITOR_H_ */\n" }, { "path": "src/ProcFdDirMonitor.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ProcFdDirMonitor.h\"\n\n#include \n#include \n\n#include \"AutoRemoteSyscalls.h\"\n#include \"RecordSession.h\"\n#include \"RecordTask.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nProcFdDirMonitor::ProcFdDirMonitor(Task* t, const string& pathname) {\n // XXX this makes some assumptions about namespaces... Probably fails\n // if |t| is not the same pid namespace as rr\n int tid = parse_tid_from_proc_path(pathname, \"/fd\");\n if (tid > 0) {\n Task* target = t->session().find_task(tid);\n if (target) {\n tuid = target->tuid();\n }\n }\n}\n\n// returns the number of valid dirent structs left in the buffer\ntemplate \nstatic int filter_dirent_structs(RecordTask* t, uint8_t* buf, size_t size) {\n int bytes = 0;\n size_t current_offset = 0;\n while (1) {\n if (current_offset == size) {\n break;\n }\n\n D* current_struct = reinterpret_cast(buf + current_offset);\n auto next_off = current_offset + current_struct->d_reclen;\n\n char* fname = (char*)current_struct->d_name;\n char* end;\n int fd = strtol(fname, &end, 10);\n if (!*end && t->fd_table()->is_rr_fd(fd)) {\n // Skip this entry.\n memmove(current_struct, buf + next_off, size - next_off);\n size -= (next_off - current_offset);\n next_off = current_offset;\n } else {\n // Either this is a tracee fd or not an fd at all (e.g. '.')\n bytes += current_struct->d_reclen;\n }\n\n current_offset = next_off;\n }\n\n return bytes;\n}\n\ntemplate static void filter_dirents_arch(RecordTask* t) {\n auto regs = t->regs();\n remote_ptr ptr(regs.arg2());\n size_t len = regs.arg3();\n\n if (regs.syscall_failed() || !regs.syscall_result()) {\n return;\n }\n\n while (1) {\n vector buf = t->read_mem(ptr, len);\n int bytes = regs.syscall_result();\n if (regs.original_syscallno() == Arch::getdents64) {\n bytes =\n filter_dirent_structs(t, buf.data(), bytes);\n } else {\n bytes =\n filter_dirent_structs(t, buf.data(), bytes);\n }\n\n if (bytes > 0) {\n t->write_mem(ptr, buf.data(), bytes);\n regs.set_syscall_result(bytes);\n t->set_regs(regs);\n // Explicitly record what the kernel may have touched and we discarded,\n // because it's userspace modification that will not be caught otherwise.\n if (len > (size_t)bytes) {\n t->record_remote(ptr + bytes, len - bytes);\n }\n return;\n }\n\n // We filtered out all the entries, so we need to repeat the syscall.\n {\n AutoRemoteSyscalls remote(t);\n remote.syscall(regs.original_syscallno(), regs.orig_arg1(), regs.arg2(),\n regs.arg3());\n // Only copy over the syscall result. In particular, we don't want to\n // copy the AutoRemoteSyscalls ip().\n regs.set_syscall_result(t->regs().syscall_result());\n }\n\n if (regs.syscall_failed() || regs.syscall_result() == 0) {\n // Save the new syscall result, and record the buffer we will otherwise\n // ignore.\n t->record_remote(ptr, len);\n t->set_regs(regs);\n return;\n }\n }\n}\n\nstatic void filter_dirents(RecordTask* t) {\n RR_ARCH_FUNCTION(filter_dirents_arch, t->arch(), t);\n}\n\nvoid ProcFdDirMonitor::filter_getdents(RecordTask* t) {\n ASSERT(t, !t->session().is_replaying());\n auto* target = static_cast(t->session().find_task(tuid));\n if (!target) {\n return;\n }\n\n filter_dirents(t);\n}\n\n} // namespace rr\n" }, { "path": "src/ProcFdDirMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROC_FD_DIR_MONITOR_H_\n#define RR_PROC_FD_DIR_MONITOR_H_\n\n#include \"FileMonitor.h\"\n#include \"TaskishUid.h\"\n\nnamespace rr {\n\n/**\n * A FileMonitor to intercept enumerations of /proc//fd so that entries\n * for rr's private fds can be hidden when is a tracee.\n */\nclass ProcFdDirMonitor : public FileMonitor {\npublic:\n ProcFdDirMonitor(Task* t, const std::string& pathname);\n\n virtual Type type() override { return ProcFd; }\n\n virtual void filter_getdents(RecordTask* t) override;\n\nprivate:\n // 0 if this doesn't object doesn't refer to a tracee's proc-mem.\n TaskUid tuid;\n};\n\n} // namespace rr\n\n#endif /* RR_PROC_FD_DIR_MONITOR_H_ */\n" }, { "path": "src/ProcMemMonitor.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ProcMemMonitor.h\"\n\n#include \n\n#include \"AutoRemoteSyscalls.h\"\n#include \"RecordSession.h\"\n#include \"ReplaySession.h\"\n#include \"ReplayTask.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nProcMemMonitor::ProcMemMonitor(Task* t, const string& pathname) {\n // XXX this makes some assumptions about namespaces... Probably fails\n // if |t| is not the same pid namespace as rr\n int tid = parse_tid_from_proc_path(pathname, \"/mem\");\n if (tid > 0) {\n Task* target = t->session().find_task(tid);\n if (target) {\n auid = target->vm()->uid();\n }\n }\n}\n\nvoid ProcMemMonitor::did_write(Task* t, const std::vector& ranges,\n LazyOffset& lazy_offset) {\n if (ranges.empty()) {\n return;\n }\n int64_t offset = lazy_offset.retrieve(true);\n\n // In prior versions of rr, we recorded this directly into the trace.\n // If so, there's nothing to do here.\n if (t->session().is_replaying() && t->session().as_replay()->has_trace_quirk(TraceReader::ExplicitProcMem)) {\n return;\n }\n\n if (t->session().is_recording()) {\n // Nothing to do now (though we may have just recorded the offset)\n return;\n }\n\n auto* target = t->session().find_address_space(auid);\n if (!target) {\n return;\n }\n\n ReplayTask* task = static_cast(target->first_running_task());\n if (!task) {\n return;\n }\n\n for (auto& r : ranges) {\n auto bytes = t->read_mem(r.data.cast(), r.length);\n remote_ptr target_addr = offset;\n task->write_mem(target_addr, bytes.data(), r.length);\n target->maybe_update_breakpoints(task, target_addr,\n r.length);\n offset += r.length;\n }\n}\n\nbool ProcMemMonitor::target_is_vm(AddressSpace *vm) {\n return auid == vm->uid();\n}\n\n} // namespace rr\n" }, { "path": "src/ProcMemMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROC_MEM_MONITOR_H_\n#define RR_PROC_MEM_MONITOR_H_\n\n#include \"FileMonitor.h\"\n#include \"TaskishUid.h\"\n\nnamespace rr {\n\n/**\n * A FileMonitor to track writes to /proc//mem so they can be replayed\n * when is a replayed tracee.\n */\nclass ProcMemMonitor : public FileMonitor {\npublic:\n ProcMemMonitor(Task* t, const std::string& pathname);\n\n virtual Type type() override { return ProcMem; }\n\n // We need to PREVENT_SWITCH, since the timing of the write is otherwise\n // unpredictable from our perspective.\n virtual Switchable will_write(Task*) override { return PREVENT_SWITCH; }\n\n virtual void did_write(Task* t, const std::vector& ranges,\n LazyOffset& lazy_offset) override;\n\n virtual enum syscallbuf_fd_classes get_syscallbuf_class() override {\n return FD_CLASS_PROC_MEM;\n }\n\n bool target_is_vm(AddressSpace *t);\n\nprivate:\n // 0 if this doesn't object doesn't refer to a tracee's proc-mem.\n AddressSpaceUid auid;\n};\n\n} // namespace rr\n\n#endif /* RR_PROC_MEM_MONITOR_H_ */\n" }, { "path": "src/ProcStatMonitor.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n#include \n\n#include \n#include \n\n#include \"ProcStatMonitor.h\"\n#include \"RecordTask.h\"\n#include \"RecordSession.h\"\n#include \"Scheduler.h\"\n\n#include \"log.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n// Skip any lines that contain CPUs not in our cpu mask\nstatic void filter_proc_stat(string& data, const cpu_set_t& active) {\n string::iterator pos = data.begin();\n while (pos + 4 < data.end()) {\n const char *cur_data = &*pos;\n static char cpu_str[] = \"cpu\";\n if (memcmp(cur_data, cpu_str, sizeof(cpu_str)-1) == 0 && isdigit(*(cur_data + 3))) {\n unsigned long cpu = strtoul((char*)cur_data + 3, NULL, 10);\n if (!CPU_ISSET(cpu, &active)) {\n pos = data.erase(pos, ++std::find(pos, data.end(), '\\n'));\n continue;\n }\n }\n pos = ++std::find(pos, data.end(), '\\n');\n }\n}\n\nProcStatMonitor::ProcStatMonitor(Task* t, const string&) {\n if (t->session().is_replaying())\n return;\n // Grab all the data now and buffer it for later access. This matches what the\n // kernel does (except that it does the buffering on first access) and is\n // required to give userspace code a consistent view of the file.\n std::ifstream proc_stat(\"/proc/stat\");\n if (!proc_stat.is_open()) {\n FATAL() << \"Failed to process /proc/stat\";\n }\n data = string(\n (std::istreambuf_iterator(proc_stat)),\n (std::istreambuf_iterator()));\n const cpu_set_t cpus = static_cast(t)->session().scheduler().pretend_affinity_mask();\n filter_proc_stat(data, cpus);\n}\n\nbool ProcStatMonitor::emulate_read(\n RecordTask* t, const vector& ranges,\n LazyOffset& lazy_offset, uint64_t* result) {\n int64_t offset = lazy_offset.retrieve(false);\n *result = t->write_ranges(ranges, (uint8_t*)data.data() + offset,\n (offset > (ssize_t)data.size()) ? 0 : data.size() - offset);\n return true;\n}\n\n} // namespace rr\n" }, { "path": "src/ProcStatMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROC_STAT_MONITOR_H_\n#define RR_PROC_STAT_MONITOR_H_\n\n#include \"FileMonitor.h\"\n\nnamespace rr {\n\n/**\n * A FileMonitor to intercept /proc/stat in order to pretend to the\n * tracee that it only has the CPUs that rr is willing to give it.\n * This is necessary on top of the SysCpuMonitor, because some versions\n * of glibc have bugs that cause it to fail to parse the\n * /sys/devices/system/cpu/online format, causing them to fallback to /proc/stat\n */\nclass ProcStatMonitor : public FileMonitor {\npublic:\n ProcStatMonitor(Task* t, const std::string& pathname);\n\n virtual Type type() override { return ProcStat; }\n\n bool emulate_read(RecordTask* t, const std::vector& ranges,\n LazyOffset&, uint64_t* result) override;\nprivate:\n std::string data;\n};\n\n} // namespace rr\n\n#endif /* RR_PROC_STAT_MONITOR_H_ */\n" }, { "path": "src/ProcessorTraceDecoder.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n\n#include \n#include \n#include \n\n#include \"AddressSpace.h\"\n#include \"ProcessorTraceDecoder.h\"\n#include \"Session.h\"\n#include \"log.h\"\n#include \"preload/preload_interface.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstatic string pt_err(int status) {\n char buf[1024];\n sprintf(buf, \"%s (%d)\", pt_errstr(pt_errcode(status)), status);\n return buf;\n}\n\nProcessorTraceDecoder::~ProcessorTraceDecoder() {\n if (decoder) {\n pt_insn_free_decoder(decoder);\n }\n}\n\nint read_mem_callback(uint8_t *buffer, size_t size,\n const pt_asid *,\n uint64_t ip, void *context) {\n return static_cast(context)->\n read_mem(ip, buffer, size);\n}\n\nstatic constexpr uint8_t injected_header_packets[] =\n { /*PSB*/ 0x02, 0x82, 0x02, 0x82, 0x02, 0x82, 0x02, 0x82,\n 0x02, 0x82, 0x02, 0x82, 0x02, 0x82, 0x02, 0x82,\n /*CBR 31*/ 0x02, 0x03, 0x1f, 0x00,\n /*PSBEND*/ 0x02, 0x23 };\nstatic constexpr size_t PSB_LEN = 16;\n\nvoid ProcessorTraceDecoder::init(const vector& trace_data) {\n if (trace_data.empty()) {\n return;\n }\n\n if (trace_data.size() < PSB_LEN ||\n memcmp(injected_header_packets, trace_data.data(), PSB_LEN)) {\n full_trace_data.reserve(sizeof(injected_header_packets) + trace_data.size());\n full_trace_data.insert(full_trace_data.end(), injected_header_packets,\n injected_header_packets + sizeof(injected_header_packets));\n }\n full_trace_data.insert(full_trace_data.end(), trace_data.begin(),\n trace_data.end());\n\n init_decoder();\n}\n\nvoid ProcessorTraceDecoder::dump_full_trace_data_to_file() {\n ScopedFd out(\"/tmp/ptdata\", O_WRONLY | O_CREAT | O_TRUNC, 0700);\n write_all(out, full_trace_data.data(), full_trace_data.size());\n}\n\nvoid ProcessorTraceDecoder::init_decoder() {\n pt_config config;\n memset(&config, 0, sizeof(config));\n config.size = sizeof(config);\n config.begin = const_cast(full_trace_data.data());\n config.end = const_cast(full_trace_data.data() + full_trace_data.size());\n\n decoder = pt_insn_alloc_decoder(&config);\n if (!decoder) {\n FATAL() << \"Cannot create PT decoder\";\n }\n\n pt_image* image = pt_insn_get_image(decoder);\n int status = pt_image_set_callback(image, read_mem_callback, this);\n if (status < 0) {\n FATAL() << \"Can't set PT mem callback: \" << pt_errstr(pt_errcode(status));\n }\n\n need_sync = true;\n}\n\nstatic vector* cached_rr_page_for_recording[2];\n\nstatic const vector& rr_page_for_recording(SupportedArch arch) {\n if (arch != x86 && arch != x86_64) {\n FATAL() << \"Unsupported arch \" << arch_name(arch);\n }\n int index = arch == x86_64;\n vector* page = cached_rr_page_for_recording[index];\n if (page) {\n return *page;\n }\n page = new vector();\n *page = AddressSpace::read_rr_page_for_recording(arch);\n cached_rr_page_for_recording[index] = page;\n return *page;\n}\n\nint ProcessorTraceDecoder::read_mem(uint64_t ip, uint8_t *buffer, size_t size) {\n ssize_t ret = task->read_bytes_fallible(ip, size, buffer);\n if (ret <= 0) {\n return ret;\n }\n if (mode == IS_RECORDING) {\n // The rr page instructions differ between recording and replay. The\n // task's rr page contains the replay values; if we're analyzing\n // PT data from the recording, make sure to use the rr page instructions\n // from the recording.\n const vector& rr_page_data = rr_page_for_recording(task->arch());\n remote_ptr rr_page_addr(RR_PAGE_ADDR);\n remote_ptr ip_addr(ip);\n replace_in_buffer(MemoryRange(rr_page_addr, rr_page_data.size()),\n rr_page_data.data(), MemoryRange(ip, ret), buffer);\n }\n replace_in_buffer(MemoryRange(patch_addr, patch_data.size()),\n patch_data.data(), MemoryRange(ip, ret), buffer);\n return ret;\n}\n\nvoid ProcessorTraceDecoder::maybe_process_events(int status) {\n while (status & pts_event_pending) {\n pt_event event;\n status = pt_insn_event(decoder, &event, sizeof(event));\n if (status < 0) {\n FATAL() << \"Cannot get PT event: \" << pt_err(status);\n }\n switch (event.type) {\n case ptev_enabled:\n case ptev_disabled:\n case ptev_async_disabled:\n case ptev_exec_mode:\n case ptev_cbr:\n case ptev_tsx:\n case ptev_async_vmcs:\n break;\n case ptev_overflow:\n FATAL() << \"Detected ptev_overflow\";\n break;\n default:\n FATAL() << \"Unhandled event type: \" << event.type;\n break;\n }\n }\n}\n\nstring ProcessorTraceDecoder::internal_error_context_string() {\n ProcessorTraceDecoder helper(task, full_trace_data, mode);\n vector instructions;\n while (true) {\n int pt_status = 0;\n Instruction instruction;\n if (helper.next_instruction(&instruction, &pt_status)) {\n instructions.push_back(instruction);\n } else {\n break;\n }\n }\n size_t start_index = 0;\n stringstream out;\n if (instructions.size() > 10000) {\n start_index = instructions.size() - 10000;\n out << \"\\n... skipped \" << start_index << \" instructions\";\n }\n for (size_t i = start_index; i < instructions.size(); ++i) {\n out << \"\\n\" << instructions[i].address;\n }\n return out.str();\n}\n\nbool ProcessorTraceDecoder::next_instruction(Instruction* out, int* pt_status) {\n if (!decoder) {\n return false;\n }\n\n while (true) {\n if (need_sync) {\n int status = pt_insn_sync_forward(decoder);\n if (pt_errcode(status) == pte_eos) {\n return false;\n }\n if (status < 0) {\n if (pt_status) {\n *pt_status = status;\n return false;\n }\n FATAL() << \"Can't sync forward: \" << pt_err(status)\n << internal_error_context_string();\n }\n need_sync = false;\n maybe_process_events(status);\n }\n\n pt_insn insn;\n int status = pt_insn_next(decoder, &insn, sizeof(insn));\n if (pt_errcode(status) == pte_eos) {\n need_sync = true;\n continue;\n }\n if (status < 0) {\n if (pt_status) {\n *pt_status = status;\n return false;\n }\n FATAL() << \"Can't read next instruction: \" << pt_err(status)\n << internal_error_context_string();\n }\n maybe_process_events(status);\n out->address = insn.ip;\n return true;\n }\n}\n\n}\n" }, { "path": "src/ProcessorTraceDecoder.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_PROCESSOR_TRACE_DECODER_H_\n#define RR_PROCESSOR_TRACE_DECODER_H_\n\n#include \n\n#include \n\n#include \"log.h\"\n#include \"Task.h\"\n#include \"remote_code_ptr.h\"\n\nstruct pt_insn_decoder;\n\nnamespace rr {\n\n/**\n * Decodes Intel PT data to produce a control flow trace as a sequence\n * of executed instructions.\n *\n * If intel_pt_decoding was not explicitly set to TRUE via `cmake -Dintel_pt_decoding=TRUE`,\n * then libipt is not linked in and this always returns no instructions.\n */\nclass ProcessorTraceDecoder {\npublic:\n enum Mode {\n IS_RECORDING,\n IS_REPLAY\n };\n\n struct Instruction {\n remote_code_ptr address;\n };\n\n ProcessorTraceDecoder(Task* t, const std::vector& trace_data, Mode mode)\n : task(t), decoder(nullptr), mode(mode), need_sync(false) {\n init(trace_data);\n }\n#ifdef INTEL_PT_DECODING\n ~ProcessorTraceDecoder();\n bool next_instruction(Instruction* out, int* pt_status = nullptr);\n#else\n bool next_instruction(Instruction*, int* = nullptr)\n {\n FATAL() << \"Intel PT support not built\";\n return false;\n }\n#endif\n\n // Override a memory range with specific data to be seen by libipt.\n // This is needed when memory (other than the rr page) is different between\n // when the PT data was gathered and its current contents.\n void set_patch(remote_ptr addr, const std::vector& data) {\n patch_addr = addr;\n patch_data = data;\n }\n int read_mem(uint64_t ip, uint8_t *buffer, size_t size);\n\nprivate:\n#ifdef INTEL_PT_DECODING\n void init(const std::vector& trace_data);\n#else\n void init(const std::vector&)\n {\n FATAL() << \"Intel PT decoding support not built; run CMake with -Dintel_pt_decoding=TRUE\";\n }\n#endif\n void init_decoder();\n\n void dump_full_trace_data_to_file();\n\n void maybe_process_events(int status);\n std::string internal_error_context_string();\n\n Task* const task;\n std::vector full_trace_data;\n pt_insn_decoder* decoder;\n remote_ptr patch_addr;\n std::vector patch_data;\n Mode mode;\n bool need_sync;\n};\n\n} // namespace rr\n\n#endif /* RR_PROCESSOR_TRACE_DECODER_H_ */\n" }, { "path": "src/PsCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \n\n#include \"Command.h\"\n#include \"TraceStream.h\"\n#include \"TraceTaskEvent.h\"\n#include \"core.h\"\n#include \"main.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nclass PsCommand : public Command {\npublic:\n virtual int run(vector& args) override;\n\nprotected:\n PsCommand(const char* name, const char* help) : Command(name, help) {}\n\n static PsCommand singleton;\n};\n\nPsCommand PsCommand::singleton(\"ps\", \" rr ps []\\n\");\n\nstatic void print_exec_cmd_line(const TraceTaskEvent& event, FILE* out) {\n bool first = true;\n for (auto& word : event.cmd_line()) {\n fprintf(out, \"%s%s\", first ? \"\" : \" \", word.c_str());\n first = false;\n }\n fprintf(out, \"\\n\");\n}\n\nstatic void update_tid_to_pid_map(map& tid_to_pid,\n const TraceTaskEvent& e) {\n if (e.type() == TraceTaskEvent::CLONE) {\n if (e.clone_flags() & CLONE_THREAD) {\n // thread clone. Record thread's pid.\n tid_to_pid[e.tid()] = tid_to_pid[e.parent_tid()];\n } else {\n // Some kind of fork. This task is its own pid.\n tid_to_pid[e.tid()] = e.tid();\n }\n } else if (e.type() == TraceTaskEvent::EXIT) {\n tid_to_pid.erase(e.tid());\n }\n}\n\nstatic int count_tids_for_pid(const std::map tid_to_pid,\n pid_t pid) {\n int count = 0;\n for (auto& tp : tid_to_pid) {\n if (tp.second == pid) {\n ++count;\n }\n }\n return count;\n}\n\nstatic ssize_t find_cmd_line(pid_t pid, const vector& events,\n size_t current_event,\n const map current_tid_to_pid) {\n map tid_to_pid = current_tid_to_pid;\n for (size_t i = current_event; i < events.size(); ++i) {\n const TraceTaskEvent& e = events[i];\n if (e.type() == TraceTaskEvent::EXEC && tid_to_pid[e.tid()] == pid) {\n return i;\n }\n if (e.type() == TraceTaskEvent::EXIT && tid_to_pid[e.tid()] == pid &&\n count_tids_for_pid(tid_to_pid, pid) == 1) {\n return -1;\n }\n update_tid_to_pid_map(tid_to_pid, e);\n }\n return -1;\n}\n\nstring find_exit_code(pid_t pid, const vector& events,\n size_t current_event,\n const map current_tid_to_pid) {\n map tid_to_pid = current_tid_to_pid;\n for (size_t i = current_event; i < events.size(); ++i) {\n const TraceTaskEvent& e = events[i];\n if (e.type() == TraceTaskEvent::EXIT && tid_to_pid[e.tid()] == pid &&\n count_tids_for_pid(tid_to_pid, pid) == 1) {\n WaitStatus status = e.exit_status();\n if (status.type() == WaitStatus::EXIT) {\n return to_string(status.exit_code());\n }\n DEBUG_ASSERT(status.type() == WaitStatus::FATAL_SIGNAL);\n return to_string(-status.fatal_sig());\n } else if (e.type() == TraceTaskEvent::DETACH && tid_to_pid[e.tid()] == pid &&\n count_tids_for_pid(tid_to_pid, pid) == 1) {\n return string(\"detach\");\n }\n update_tid_to_pid_map(tid_to_pid, e);\n }\n return string(\"none\");\n}\n\nstatic int ps(const string& trace_dir, FILE* out) {\n TraceReader trace(trace_dir);\n\n fprintf(out, \"PID\\tPPID\\tEXIT\\tCMD\\n\");\n\n vector events;\n while (true) {\n TraceTaskEvent r = trace.read_task_event();\n if (r.type() == TraceTaskEvent::NONE) {\n break;\n }\n events.push_back(r);\n }\n\n if (events.empty() || events[0].type() != TraceTaskEvent::EXEC) {\n fprintf(stderr, \"Invalid trace\\n\");\n return 1;\n }\n\n map tid_to_pid;\n\n pid_t initial_tid = events[0].tid();\n tid_to_pid[initial_tid] = initial_tid;\n fprintf(out, \"%d\\t--\\t%s\\t\", initial_tid,\n find_exit_code(initial_tid, events, 0, tid_to_pid).c_str());\n print_exec_cmd_line(events[0], out);\n\n for (size_t i = 1; i < events.size(); ++i) {\n auto& e = events[i];\n update_tid_to_pid_map(tid_to_pid, e);\n\n if (e.type() == TraceTaskEvent::CLONE &&\n !(e.clone_flags() & CLONE_THREAD)) {\n pid_t pid = tid_to_pid[e.tid()];\n fprintf(out, \"%d\", e.tid());\n if (e.own_ns_tid() != e.tid()) {\n fprintf(out, \" (%d)\", e.own_ns_tid());\n }\n fprintf(out, \"\\t%d\\t%s\\t\", tid_to_pid[e.parent_tid()],\n find_exit_code(pid, events, i, tid_to_pid).c_str());\n\n ssize_t cmd_line_index = find_cmd_line(pid, events, i, tid_to_pid);\n if (cmd_line_index < 0) {\n // The main thread exited. All other threads must too, so there\n // is no more opportunity for e's pid to exec.\n fprintf(out, \"(forked without exec)\\n\");\n } else {\n print_exec_cmd_line(events[cmd_line_index], out);\n }\n }\n }\n return 0;\n}\n\nint PsCommand::run(vector& args) {\n while (parse_global_option(args)) {\n }\n\n string trace_dir;\n if (!parse_optional_trace_dir(args, &trace_dir)) {\n print_help(stderr);\n return 1;\n }\n\n return ps(trace_dir, stdout);\n}\n\n} // namespace rr\n" }, { "path": "src/RRPageMonitor.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RR_PAGE_MONITOR_H_\n#define RR_RR_PAGE_MONITOR_H_\n\n#include \"FileMonitor.h\"\n#include \"TraceStream.h\"\n\nnamespace rr {\n\n/**\n * RRPageMonitor gets installed upon any open of the librrpage.so preload library.\n * If this file gets mmaped, rr will attempt to map it to coincide with the\n * required fixed location for the rr page.\n */\nclass RRPageMonitor : public FileMonitor {\npublic:\n RRPageMonitor() : FileMonitor() {};\n\n virtual Type type() override { return RRPage; }\n};\n\nstatic_assert(TraceReader::SpecialLibRRpage != 0,\n \"Remember to delete this if support for the quirk is ever dropped\");\n\n} // namespace rr\n\n#endif /* RR_RR_PAGE_MONITOR_H_ */\n" }, { "path": "src/RecordCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"RecordCommand.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"preload/preload_interface.h\"\n\n#include \"Flags.h\"\n#include \"RecordSession.h\"\n#include \"StringVectorToCharArray.h\"\n#include \"WaitManager.h\"\n#include \"WaitStatus.h\"\n#include \"core.h\"\n#include \"git_revision.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n#include \"main.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nRecordCommand RecordCommand::singleton(\n \"record\",\n \" rr record [OPTION]... [exe-args]...\\n\"\n \" -c, --num-cpu-ticks= maximum number of 'CPU ticks' (currently \\n\"\n \" retired conditional branches) to allow a \\n\"\n \" task to run before interrupting it\\n\"\n \" --disable-avx-512 Masks out the CPUID bits for AVX512\\n\"\n \" This can improve trace portability\\n\"\n \" --disable-cpuid-features [,]\\n\"\n \" Mask out CPUID EAX=1 feature bits\\n\"\n \" : Bitmask of bits to clear from ECX\\n\"\n \" : Bitmask of bits to clear from EDX\\n\"\n \" --disable-cpuid-features-ext [,[,]]\\n\"\n \" Mask out CPUID EAX=7,ECX=0 feature bits\\n\"\n \" : Bitmask of bits to clear from EBX\\n\"\n \" : Bitmask of bits to clear from ECX\\n\"\n \" : Bitmask of bits to clear from EDX\\n\"\n \" --disable-cpuid-features-xsave \\n\"\n \" Mask out CPUID EAX=0xD,ECX=1 feature bits\\n\"\n \" : Bitmask of bits to clear from EAX\\n\"\n \" -h, --chaos randomize scheduling decisions to try to \\n\"\n \" reproduce bugs\\n\"\n \" -n, --no-syscall-buffer disable syscall buffering even if it would\\n\"\n \" otherwise be used\\n\"\n \" --no-preload disable the preload library; useful when\\n\"\n \" tracee uses a non-standard C ABI but may\\n\"\n \" cause replay issues. Implies -n.\\n\"\n \" --no-file-cloning disable file cloning for mmapped files\\n\"\n \" --no-read-cloning disable file-block cloning for syscallbuf\\n\"\n \" reads\\n\"\n \" --num-cores=N pretend to have N cores (rr will still\\n\"\n \" only run on a single core). Overrides\\n\"\n \" random setting from --chaos.\\n\"\n \" -o, --output-trace-dir

set the output trace directory.\\n\"\n \" _RR_TRACE_DIR gets ignored.\\n\"\n \" Directory name is given name, not the\\n\"\n \" application name.\\n\"\n \" -p --print-trace-dir= print trace directory followed by a newline\\n\"\n \" to given file descriptor\\n\"\n \" --syscall-buffer-sig= the signal used for communication with the\\n\"\n \" syscall buffer. SIGPWR by default, unused\\n\"\n \" if --no-syscall-buffer is passed\\n\"\n \" -s, --always-switch Context-switch after every rr event\\n\"\n \" (mainly for testing)\\n\"\n \" -t, --continue-through-signal=\\n\"\n \" Unhandled signals will be ignored\\n\"\n \" instead of terminating the program. The\\n\"\n \" signal will still be delivered for user\\n\"\n \" handlers and debugging.\\n\"\n \" --intel-pt Enable PT collection of control flow\\n\"\n \" (for debugging rr)\\n\"\n \" -u, --cpu-unbound allow tracees to run on any virtual CPU.\\n\"\n \" Default is to bind to a random CPU. This \"\n \"option\\n\"\n \" can cause replay divergence: use with\\n\"\n \" caution.\\n\"\n \" --bind-to-cpu= Bind to a CPU core. can be 'any',\\n\"\n \" 'p-core' (default), or a specific number.\\n\"\n \" -v, --env=NAME=VALUE value to add to the environment of the\\n\"\n \" tracee. There can be any number of these.\\n\"\n \" -w, --wait Wait for all child processes to exit, not\\n\"\n \" just the initial process.\\n\"\n \" --nested= Control behavior when run inside an outer\\n\"\n \" rr recording. Default: exit with error\\n\"\n \" --nested=ignore Directly start child process so it's part\\n\"\n \" of the outer recording\\n\"\n \" --nested=detach Start a separate recording session.\\n\"\n \" Must not share memory with the outer.\\n\"\n \" --nested=release Run the child without recording it.\\n\"\n \" Must not share memory with the outer.\\n\"\n \" --setuid-sudo If running under sudo, pretend to be the\\n\"\n \" user that ran sudo rather than root. This\\n\"\n \" allows recording setuid/setcap binaries.\\n\"\n \" --trace-id Sets the trace id to the specified id.\\n\"\n \" --copy-preload-src Copy preload sources to trace dir\\n\"\n \" --stap-sdt Enables the use of SystemTap statically-\\n\"\n \" defined tracepoints\\n\"\n \" --asan Override heuristics and always enable ASAN\\n\"\n \" compatibility.\\n\"\n \" --tsan Override heuristics and always enable TSAN\\n\"\n \" compatibility.\\n\"\n \" --check-outside-mmaps Try to identify files that are mapped outside\\n\"\n \" of the trace and could cause diversions.\\n\");\n\nstruct RecordFlags {\n vector extra_env;\n\n /* Max counter value before the scheduler interrupts a tracee. */\n Ticks max_ticks;\n\n /* Whenever |ignore_sig| is pending for a tracee, decline to\n * deliver it. */\n int ignore_sig;\n /* Whenever |continue_through_sig| is delivered to a tracee, if there is no\n * user handler and the signal would terminate the program, just ignore it. */\n int continue_through_sig;\n\n /* Whether to use syscall buffering optimization during recording. */\n RecordSession::SyscallBuffering use_syscall_buffer;\n\n /* If nonzero, the desired syscall buffer size. Must be a multiple of the page\n * size.\n */\n size_t syscall_buffer_size;\n\n /* CPUID features to disable */\n DisableCPUIDFeatures disable_cpuid_features;\n\n int print_trace_dir;\n\n string output_trace_dir;\n\n /* Whether to use file-cloning optimization during recording. */\n bool use_file_cloning;\n\n /* Whether to use read-cloning optimization during recording. */\n bool use_read_cloning;\n\n /* Whether tracee processes in record and replay are allowed\n * to run on any logical CPU. */\n BindCPU bind_cpu;\n\n /* True if we should context switch after every rr event */\n bool always_switch;\n\n /* Whether to enable chaos mode in the scheduler */\n bool chaos;\n\n /* Controls number of cores reported to recorded process. */\n int num_cores;\n\n /* True if we should wait for all processes to exit before finishing\n * recording. */\n bool wait_for_all;\n\n /* Start child process directly if run under nested rr recording */\n NestedBehavior nested;\n\n bool scarce_fds;\n\n bool setuid_sudo;\n\n unique_ptr trace_id;\n\n /* Copy preload sources to trace dir */\n bool copy_preload_src;\n\n /* The signal to use for syscallbuf desched events */\n int syscallbuf_desched_sig;\n\n /* True if we should load the audit library for SystemTap SDT support. */\n bool stap_sdt;\n\n /* True if we should unmap the vdso */\n bool unmap_vdso;\n\n /* True if we should always enable ASAN compatibility. */\n bool asan;\n\n /* True if we should always enable TSAN compatibility. */\n bool tsan;\n\n /* True if we should enable collection of control flow\n with PT. */\n bool intel_pt;\n\n /* True if we should check files being mapped outside of the recording. */\n bool check_outside_mmaps;\n\n /* True if we should not add the preload library to LD_PRELOAD. */\n bool no_preload = false;\n\n RecordFlags()\n : max_ticks(Scheduler::DEFAULT_MAX_TICKS),\n ignore_sig(0),\n continue_through_sig(0),\n use_syscall_buffer(RecordSession::ENABLE_SYSCALL_BUF),\n syscall_buffer_size(0),\n print_trace_dir(-1),\n output_trace_dir(\"\"),\n use_file_cloning(true),\n use_read_cloning(true),\n bind_cpu(BindCPU::PREFER_PERF_CORE),\n always_switch(false),\n chaos(false),\n num_cores(0),\n wait_for_all(false),\n nested(NESTED_ERROR),\n scarce_fds(false),\n setuid_sudo(false),\n copy_preload_src(false),\n syscallbuf_desched_sig(SYSCALLBUF_DEFAULT_DESCHED_SIGNAL),\n stap_sdt(false),\n unmap_vdso(false),\n asan(false),\n tsan(false),\n intel_pt(false),\n check_outside_mmaps(false) {}\n};\n\nstatic void parse_signal_name(ParsedOption& opt) {\n if (opt.int_value != INT64_MIN) {\n return;\n }\n\n for (int i = 1; i < _NSIG; i++) {\n std::string signame = signal_name(i);\n if (signame == opt.value) {\n opt.int_value = i;\n return;\n }\n DEBUG_ASSERT(signame[0] == 'S' && signame[1] == 'I' && signame[2] == 'G');\n if (signame.substr(3) == opt.value) {\n opt.int_value = i;\n return;\n }\n }\n}\n\nstatic vector parse_feature_bits(ParsedOption& opt) {\n vector ret;\n const char* p = opt.value.c_str();\n while (*p) {\n char* endptr;\n unsigned long long v = strtoull(p, &endptr, 0);\n if (v > UINT32_MAX || (*endptr && *endptr != ',')) {\n return vector();\n }\n ret.push_back(v);\n p = *endptr == ',' ? endptr + 1 : endptr;\n }\n return ret;\n}\n\nstatic bool parse_record_arg(vector& args, RecordFlags& flags) {\n if (parse_global_option(args)) {\n return true;\n }\n\n static const OptionSpec options[] = {\n { 0, \"no-read-cloning\", NO_PARAMETER },\n { 1, \"no-file-cloning\", NO_PARAMETER },\n { 2, \"syscall-buffer-size\", HAS_PARAMETER },\n { 3, \"nested\", HAS_PARAMETER },\n { 4, \"scarce-fds\", NO_PARAMETER },\n { 5, \"setuid-sudo\", NO_PARAMETER },\n { 6, \"bind-to-cpu\", HAS_PARAMETER },\n { 7, \"disable-cpuid-features\", HAS_PARAMETER },\n { 8, \"disable-cpuid-features-ext\", HAS_PARAMETER },\n { 9, \"disable-cpuid-features-xsave\", HAS_PARAMETER },\n { 10, \"num-cores\", HAS_PARAMETER },\n { 11, \"trace-id\", HAS_PARAMETER },\n { 12, \"copy-preload-src\", NO_PARAMETER },\n { 13, \"syscall-buffer-sig\", HAS_PARAMETER },\n { 14, \"stap-sdt\", NO_PARAMETER },\n { 15, \"unmap-vdso\", NO_PARAMETER },\n { 16, \"disable-avx-512\", NO_PARAMETER },\n { 17, \"asan\", NO_PARAMETER },\n { 18, \"tsan\", NO_PARAMETER },\n { 19, \"intel-pt\", NO_PARAMETER },\n { 20, \"check-outside-mmaps\", NO_PARAMETER },\n { 21, \"no-preload\", NO_PARAMETER },\n { 'c', \"num-cpu-ticks\", HAS_PARAMETER },\n { 'h', \"chaos\", NO_PARAMETER },\n { 'i', \"ignore-signal\", HAS_PARAMETER },\n { 'n', \"no-syscall-buffer\", NO_PARAMETER },\n { 'p', \"print-trace-dir\", HAS_PARAMETER },\n { 'o', \"output-trace-dir\", HAS_PARAMETER },\n { 's', \"always-switch\", NO_PARAMETER },\n { 't', \"continue-through-signal\", HAS_PARAMETER },\n { 'u', \"cpu-unbound\", NO_PARAMETER },\n { 'v', \"env\", HAS_PARAMETER },\n { 'w', \"wait\", NO_PARAMETER }};\n ParsedOption opt;\n auto args_copy = args;\n if (!Command::parse_option(args_copy, options, &opt)) {\n return false;\n }\n\n switch (opt.short_name) {\n case 'c':\n if (!opt.verify_valid_int(1, Scheduler::MAX_MAX_TICKS)) {\n return false;\n }\n flags.max_ticks = opt.int_value;\n break;\n case 'h':\n LOG(info) << \"Enabled chaos mode\";\n flags.chaos = true;\n break;\n case 'i':\n parse_signal_name(opt);\n if (!opt.verify_valid_int(1, _NSIG - 1)) {\n return false;\n }\n flags.ignore_sig = opt.int_value;\n break;\n case 'n':\n flags.use_syscall_buffer = RecordSession::DISABLE_SYSCALL_BUF;\n break;\n case 'p':\n if (!opt.verify_valid_int(0, INT32_MAX)) {\n return false;\n }\n flags.print_trace_dir = opt.int_value;\n break;\n case 'o':\n flags.output_trace_dir = opt.value;\n break;\n case 0:\n flags.use_read_cloning = false;\n break;\n case 1:\n flags.use_file_cloning = false;\n break;\n case 2:\n if (!opt.verify_valid_int(4, 1024 * 1024)) {\n return false;\n }\n flags.syscall_buffer_size = ceil_page_size(opt.int_value * 1024);\n break;\n case 3:\n if (opt.value == \"default\" || opt.value == \"error\") {\n flags.nested = NESTED_ERROR;\n } else if (opt.value == \"ignore\") {\n flags.nested = NESTED_IGNORE;\n } else if (opt.value == \"detach\") {\n flags.nested = NESTED_DETACH;\n } else if (opt.value == \"release\") {\n flags.nested = NESTED_RELEASE;\n } else {\n LOG(warn) << \"Unknown nesting behavior `\" << opt.value << \"`\";\n flags.nested = NESTED_ERROR;\n }\n break;\n case 4:\n flags.scarce_fds = true;\n break;\n case 5:\n flags.setuid_sudo = true;\n break;\n case 6:\n if (opt.value == \"any\") {\n flags.bind_cpu = BindCPU(BindCPU::ANY);\n } else if (opt.value == \"p-core\") {\n flags.bind_cpu = BindCPU(BindCPU::PREFER_PERF_CORE);\n } else {\n if (!opt.verify_valid_int(0, INT32_MAX)) {\n return false;\n }\n flags.bind_cpu = BindCPU(opt.int_value);\n }\n break;\n case 7: {\n vector bits = parse_feature_bits(opt);\n if (bits.empty() || bits.size() > 2) {\n return false;\n }\n flags.disable_cpuid_features.features_ecx = bits[0];\n if (bits.size() > 1) {\n flags.disable_cpuid_features.features_edx = bits[1];\n }\n break;\n }\n case 8: {\n vector bits = parse_feature_bits(opt);\n if (bits.empty() || bits.size() > 3) {\n return false;\n }\n flags.disable_cpuid_features.extended_features_ebx = bits[0];\n if (bits.size() > 1) {\n flags.disable_cpuid_features.extended_features_ecx = bits[1];\n if (bits.size() > 2) {\n flags.disable_cpuid_features.extended_features_edx = bits[2];\n }\n }\n break;\n }\n case 9: {\n vector bits = parse_feature_bits(opt);\n if (bits.size() != 1) {\n return false;\n }\n flags.disable_cpuid_features.xsave_features_eax = bits[0];\n break;\n }\n case 10: {\n if (!opt.verify_valid_int(1, 128)) {\n return false;\n }\n flags.num_cores = opt.int_value;\n break;\n }\n case 11: {\n const uint8_t SUM_GROUP_LENS[5] = { 8, 12, 16, 20, 32 };\n /* Parse UUIDs from string form optionally with hyphens */\n uint8_t digit = 0; // This counts only hex digits (i.e. not hyphens)\n uint8_t group = 0;\n uint8_t acc = 0;\n unique_ptr buf(new TraceUuid);\n auto it = opt.value.begin();\n while (it < opt.value.end()) {\n auto c = *it;\n\n if (digit > SUM_GROUP_LENS[4]) {\n return false;\n }\n\n if (digit % 2 == 0) {\n // First digit of the byte.\n if ('0' <= c && c <= '9') {\n acc = c - '0';\n } else if ('a' <= c && c <= 'f') {\n acc = c - 'a' + 10;\n } else if ('A' <= c && c <= 'F') {\n acc = c - 'A' + 10;\n } else if (c == '-') {\n // Group delimiter.\n if (SUM_GROUP_LENS[group] != digit) {\n return false;\n }\n ++group;\n ++it;\n continue;\n } else {\n return false;\n }\n } else {\n // Second digit of the byte.\n acc <<= 4;\n if ('0' <= c && c <= '9') {\n acc += c - '0';\n } else if ('a' <= c && c <= 'f') {\n acc += c - 'a' + 10;\n } else if ('A' <= c && c <= 'F') {\n acc += c - 'A' + 10;\n } else {\n return false;\n }\n\n buf->bytes[digit / 2] = acc;\n }\n\n ++digit;\n ++it;\n }\n\n if (SUM_GROUP_LENS[4] != digit) {\n return false;\n }\n\n flags.trace_id.swap(buf);\n break;\n }\n case 12:\n flags.copy_preload_src = true;\n break;\n case 13:\n parse_signal_name(opt);\n if (!opt.verify_valid_int(1, _NSIG - 1)) {\n return false;\n }\n flags.syscallbuf_desched_sig = opt.int_value;\n break;\n case 14:\n flags.stap_sdt = true;\n break;\n case 15:\n flags.unmap_vdso = true;\n break;\n case 16:\n flags.disable_cpuid_features.extended_features_ebx |= 0xdc230000;\n flags.disable_cpuid_features.extended_features_ecx |= 0x00002c42;\n flags.disable_cpuid_features.extended_features_edx |= 0x0000000c;\n break;\n case 17:\n flags.asan = true;\n break;\n case 18:\n flags.tsan = true;\n break;\n case 19:\n flags.intel_pt = true;\n break;\n case 20:\n flags.check_outside_mmaps = true;\n break;\n case 21:\n flags.no_preload = true;\n break;\n case 's':\n flags.always_switch = true;\n break;\n case 't':\n parse_signal_name(opt);\n if (!opt.verify_valid_int(1, _NSIG - 1)) {\n return false;\n }\n flags.continue_through_sig = opt.int_value;\n break;\n case 'u':\n flags.bind_cpu = BindCPU(BindCPU::UNBOUND);\n break;\n case 'v':\n flags.extra_env.push_back(opt.value);\n break;\n case 'w':\n flags.wait_for_all = true;\n break;\n default:\n DEBUG_ASSERT(0 && \"Unknown option\");\n }\n\n args = args_copy;\n return true;\n}\n\nstatic volatile double term_requested;\nstatic bool did_print_reassurance = false;\n\nstatic const double TRACEE_SIGTERM_RESPONSE_MAX_TIME = 5;\nstatic const double RR_SIGKILL_GRACE_TIME = 5;\n\n/**\n * A terminating signal was received.\n *\n * First we forward it to the tracee. Then if the tracee is still\n * running after TRACEE_SIGTERM_RESPONSE_MAX_TIME, we kill it with SIGKILL.\n * If a term request remains pending for more than one second,\n * then assume rr is wedged and abort().\n *\n * Note that this is called in a signal handler and could also\n * be called off the main thread.\n */\nstatic void handle_SIGTERM(__attribute__((unused)) int sig) {\n // Don't use LOG() here because we're in a signal handler. If we do anything\n // that could allocate, we could deadlock.\n if (term_requested > 0) {\n double now = monotonic_now_sec();\n if (now - term_requested > 1 + TRACEE_SIGTERM_RESPONSE_MAX_TIME) {\n if (!did_print_reassurance) {\n static const char msg[] =\n \"[rr] Tracee failed to exit within 1s after SIGKILL. Recording will forcibly terminate in 4s.\\n\";\n did_print_reassurance = true;\n write_all(STDERR_FILENO, msg, sizeof(msg) - 1);\n } else if (now - term_requested > RR_SIGKILL_GRACE_TIME + TRACEE_SIGTERM_RESPONSE_MAX_TIME) {\n errno = 0;\n FATAL() << \"SIGTERM grace period expired\";\n }\n }\n } else {\n term_requested = monotonic_now_sec();\n }\n}\n\n/**\n * Something segfaulted - this is probably a bug in rr. Try to at least\n * give a stacktrace.\n */\nstatic void handle_SIGSEGV(__attribute__((unused)) int sig) {\n errno = 0;\n FATAL() << \"rr itself crashed (SIGSEGV). This shouldn't happen!\";\n}\n\nstatic void install_signal_handlers(void) {\n struct sigaction sa;\n memset(&sa, 0, sizeof(sa));\n sa.sa_handler = handle_SIGTERM;\n sigaction(SIGTERM, &sa, nullptr);\n\n sa.sa_handler = handle_SIGSEGV;\n sigaction(SIGSEGV, &sa, nullptr);\n\n sa.sa_handler = SIG_IGN;\n sigaction(SIGHUP, &sa, nullptr);\n sigaction(SIGINT, &sa, nullptr);\n sigaction(SIGABRT, &sa, nullptr);\n sigaction(SIGQUIT, &sa, nullptr);\n sigaction(SIGTRAP, &sa, nullptr);\n sigaction(SIGTTIN, &sa, nullptr);\n sigaction(SIGTTOU, &sa, nullptr);\n sigaction(SIGWINCH, &sa, nullptr);\n}\n\nstatic void setup_session_from_flags(RecordSession& session,\n const RecordFlags& flags) {\n session.scheduler().set_max_ticks(flags.max_ticks);\n session.scheduler().set_always_switch(flags.always_switch);\n session.set_enable_chaos(flags.chaos);\n if (flags.num_cores) {\n // Set the number of cores reported, possibly overriding the chaos mode\n // setting.\n session.set_num_cores(flags.num_cores);\n }\n session.set_use_read_cloning(flags.use_read_cloning);\n session.set_use_file_cloning(flags.use_file_cloning);\n session.set_ignore_sig(flags.ignore_sig);\n session.set_continue_through_sig(flags.continue_through_sig);\n session.set_wait_for_all(flags.wait_for_all);\n if (flags.syscall_buffer_size > 0) {\n session.set_syscall_buffer_size(flags.syscall_buffer_size);\n }\n\n if (flags.scarce_fds) {\n for (int i = 0; i < 950; ++i) {\n open(\"/dev/null\", O_RDONLY);\n }\n }\n}\n\nstatic RecordSession* static_session;\n\n// This can be called during debugging to close the trace so it can be used\n// later.\nvoid force_close_record_session() {\n if (static_session) {\n static_session->close_trace_writer(TraceWriter::CLOSE_ERROR);\n }\n}\n\nstatic void copy_preload_sources_to_trace(const string& trace_dir) {\n string files_dir = trace_dir + \"/files.rr\";\n mkdir(files_dir.c_str(), 0700);\n pid_t pid;\n string dest_path = files_dir + \"/librrpreload.zip\";\n string src_path = resource_path() + \"share/rr/src\";\n char zip[] = \"zip\";\n char r[] = \"-r\";\n char j[] = \"-j\";\n char* argv[] = {\n zip, r, j,\n const_cast(dest_path.c_str()),\n const_cast(src_path.c_str()),\n NULL\n };\n posix_spawn_file_actions_t actions;\n posix_spawn_file_actions_init(&actions);\n posix_spawn_file_actions_addopen(&actions, STDOUT_FILENO, \"/dev/null\", O_RDONLY, 0);\n posix_spawn_file_actions_addopen(&actions, STDERR_FILENO, \"/dev/null\", O_RDONLY, 0);\n int ret = posix_spawnp(&pid, argv[0], &actions, NULL, argv, environ);\n if (ret) {\n FATAL() << \"Can't spawn 'zip'\";\n }\n posix_spawn_file_actions_destroy(&actions);\n WaitResult result = WaitManager::wait_exit(WaitOptions(pid));\n if (result.code != WAIT_OK) {\n FATAL() << \"Wait failed\";\n }\n LOG(info) << \"Got zip status \" << result.status;\n}\n\nstatic void save_rr_git_revision(const string& trace_dir) {\n string files_dir = trace_dir + \"/files.rr\";\n mkdir(files_dir.c_str(), 0700);\n string dest_path = files_dir + \"/rr_git_revision\";\n ScopedFd fd(dest_path.c_str(), O_CREAT | O_WRONLY, 0600);\n ssize_t written = write(fd, GIT_REVISION, sizeof(GIT_REVISION) - 1);\n if (written != sizeof(GIT_REVISION) - 1) {\n FATAL() << \"Can't write GIT_REVISION\";\n }\n}\n\nstatic void* repeat_SIGTERM(__attribute__((unused)) void* p) {\n sleep_time(TRACEE_SIGTERM_RESPONSE_MAX_TIME);\n /* send another SIGTERM so we wake up and SIGKILL our tracees */\n kill(getpid(), SIGTERM);\n sleep_time(RR_SIGKILL_GRACE_TIME);\n /* Ok, now we're really wedged, just repeatedly SIGTERM until we're out */\n while (1) {\n kill(getpid(), SIGTERM);\n sleep_time(0.01);\n }\n}\n\nstatic WaitStatus record(const vector& args, const RecordFlags& flags) {\n LOG(info) << \"Start recording...\";\n\n auto session = RecordSession::create(\n args, flags.extra_env, flags.disable_cpuid_features,\n flags.use_syscall_buffer, flags.syscallbuf_desched_sig, flags.bind_cpu,\n flags.output_trace_dir, flags.trace_id.get(), flags.stap_sdt,\n flags.unmap_vdso, flags.asan, flags.tsan, flags.intel_pt,\n flags.check_outside_mmaps, flags.no_preload);\n setup_session_from_flags(*session, flags);\n\n static_session = session.get();\n\n if (flags.print_trace_dir >= 0) {\n const string& dir = session->trace_writer().dir();\n write_all(flags.print_trace_dir, dir.c_str(), dir.size());\n write_all(flags.print_trace_dir, \"\\n\", 1);\n }\n\n if (flags.copy_preload_src) {\n const string& dir = session->trace_writer().dir();\n copy_preload_sources_to_trace(dir);\n save_rr_git_revision(dir);\n }\n\n // Install signal handlers after creating the session, to ensure they're not\n // inherited by the tracee.\n install_signal_handlers();\n\n RecordSession::RecordResult step_result;\n bool did_forward_SIGTERM = false;\n bool did_term_detached_tasks = false;\n pthread_t term_repeater_thread;\n do {\n bool done_initial_exec = session->done_initial_exec();\n step_result = session->record_step();\n // Only create latest-trace symlink if --output-trace-dir is not being used\n if (!done_initial_exec && session->done_initial_exec() && flags.output_trace_dir.empty()) {\n session->trace_writer().make_latest_trace();\n }\n if (term_requested) {\n if (monotonic_now_sec() - term_requested > TRACEE_SIGTERM_RESPONSE_MAX_TIME) {\n /* time ran out for the tracee to respond to SIGTERM; kill everything */\n session->terminate_tracees();\n } else if (!did_forward_SIGTERM) {\n session->forward_SIGTERM();\n // Start a thread to send a SIGTERM to ourselves (again)\n // in case the tracee doesn't respond to SIGTERM.\n pthread_create(&term_repeater_thread, NULL, repeat_SIGTERM, NULL);\n did_forward_SIGTERM = true;\n }\n /* Forward SIGTERM to detached tasks immediately */\n if (!did_term_detached_tasks) {\n session->term_detached_tasks();\n did_term_detached_tasks = true;\n }\n }\n } while (step_result.status == RecordSession::STEP_CONTINUE);\n\n session->close_trace_writer(TraceWriter::CLOSE_OK);\n static_session = nullptr;\n\n switch (step_result.status) {\n case RecordSession::STEP_CONTINUE:\n // SIGTERM interrupted us.\n return WaitStatus::for_fatal_sig(SIGTERM);\n\n case RecordSession::STEP_EXITED:\n return step_result.exit_status;\n\n case RecordSession::STEP_SPAWN_FAILED:\n cerr << \"\\n\" << step_result.failure_message << \"\\n\";\n return WaitStatus::for_exit_code(EX_UNAVAILABLE);\n\n default:\n DEBUG_ASSERT(0 && \"Unknown exit status\");\n return WaitStatus();\n }\n}\n\nstatic void exec_child(vector& args) {\n execvp(args[0].c_str(), StringVectorToCharArray(args).get());\n // That failed. Try executing the file directly.\n execv(args[0].c_str(), StringVectorToCharArray(args).get());\n switch (errno) {\n case ENOENT:\n fprintf(stderr, \"execv failed: '%s' (or interpreter) not found (%s)\",\n args[0].c_str(), errno_name(errno).c_str());\n break;\n default:\n fprintf(stderr, \"execv of '%s' failed (%s)\", args[0].c_str(),\n errno_name(errno).c_str());\n break;\n }\n _exit(1);\n // Never returns!\n}\n\nstatic void reset_uid_sudo() {\n // Let's change our uids now. We do keep capabilities though, since that's\n // the point of the exercise. The first exec will reset both the keepcaps,\n // and the capabilities in the child\n std::string sudo_uid = getenv(\"SUDO_UID\");\n std::string sudo_gid = getenv(\"SUDO_GID\");\n DEBUG_ASSERT(!sudo_uid.empty() && !sudo_gid.empty());\n uid_t tracee_uid = stoi(sudo_uid);\n gid_t tracee_gid = stoi(sudo_gid);\n // Setuid will drop effective capabilities. Save them now and set them\n // back after\n struct NativeArch::cap_header header = {.version =\n _LINUX_CAPABILITY_VERSION_3,\n .pid = 0 };\n struct NativeArch::cap_data data[2];\n if (syscall(NativeArch::capget, &header, data) != 0) {\n FATAL() << \"FAILED to read capabilities\";\n }\n if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0)) {\n FATAL() << \"FAILED to set keepcaps\";\n }\n if (setgid(tracee_gid) != 0) {\n FATAL() << \"FAILED to setgid to sudo group\";\n }\n if (setuid(tracee_uid) != 0) {\n FATAL() << \"FAILED to setuid to sudo user\";\n }\n if (syscall(NativeArch::capset, &header, data) != 0) {\n FATAL() << \"FAILED to set capabilities\";\n }\n // Just make sure the ambient set is cleared, to avoid polluting the tracee\n prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_CLEAR_ALL, 0, 0, 0);\n}\n\nstatic ScopedFd open_controlling_terminal_if_foreground_process_group_leader() {\n char path[L_ctermid + 1];\n ctermid(path);\n ScopedFd terminal_fd(path, O_RDONLY);\n if (terminal_fd.is_open()) {\n pid_t fg_process_group = tcgetpgrp(terminal_fd);\n if (fg_process_group != getpid()) {\n terminal_fd.close();\n }\n }\n return terminal_fd;\n}\n\nstatic void detach_teleport() {\n int ret = syscall(SYS_rrcall_detach_teleport, (uintptr_t)0, (uintptr_t)0,\n (uintptr_t)0, (uintptr_t)0, (uintptr_t)0, (uintptr_t)0);\n if (ret < 0) {\n FATAL() << \"Failed to detach from parent rr\";\n }\n if (running_under_rr(false)) {\n FATAL() << \"Detaching from parent rr did not work\";\n }\n}\n\nint RecordCommand::run(vector& args) {\n RecordFlags flags;\n while (parse_record_arg(args, flags)) {\n }\n\n if (running_under_rr()) {\n switch (flags.nested) {\n case NESTED_IGNORE:\n exec_child(args);\n return 1;\n case NESTED_DETACH:\n case NESTED_RELEASE: {\n bool is_process_group_leader = getpgrp() == getpid();\n ScopedFd terminal_fd = open_controlling_terminal_if_foreground_process_group_leader();\n\n detach_teleport();\n\n if (is_process_group_leader) {\n setpgid(0, 0);\n }\n if (terminal_fd.is_open()) {\n struct sigaction sa;\n struct sigaction sa_old;\n memset(&sa, 0, sizeof(sa));\n sa.sa_handler = SIG_IGN;\n // Ignore SIGTTOU while we change settings, we don't want it to stop us\n sigaction(SIGTTOU, &sa, &sa_old);\n int ret = tcsetpgrp(terminal_fd, getpid());\n if (ret) {\n LOG(warn) << \"Failed to make ourselves the foreground process: \" << errno_name(errno);\n }\n sigaction(SIGTTOU, &sa_old, nullptr);\n }\n\n if (flags.nested == NESTED_RELEASE) {\n exec_child(args);\n return 1;\n }\n // running_under_rr() changed - respect the log specification from RR_LOG\n // just as if we hadn't been running under rr.\n apply_log_spec_from_env();\n break;\n }\n default:\n fprintf(stderr, \"rr: cannot run rr recording under rr. Exiting.\\n\"\n \"Use `rr record --nested=ignore` to start the child \"\n \"process directly.\\n\");\n return 1;\n }\n }\n\n if (!verify_not_option(args) || args.size() == 0) {\n print_help(stderr);\n return 1;\n }\n\n assert_prerequisites(flags.use_syscall_buffer);\n\n if (flags.setuid_sudo) {\n if (geteuid() != 0 || getenv(\"SUDO_UID\") == NULL) {\n fprintf(stderr, \"rr: --setuid-sudo option may only be used under sudo.\\n\"\n \"Re-run as `sudo -EP --preserve-env=HOME rr record --setuid-sudo` to \"\n \"record privileged executables.\\n\");\n return 1;\n }\n\n reset_uid_sudo();\n }\n\n if (flags.chaos) {\n // Add up to one page worth of random padding to the environment to induce\n // a variety of possible stack pointer offsets\n vector chars;\n chars.resize(random() % page_size());\n memset(chars.data(), '0', chars.size());\n chars.push_back(0);\n string padding = string(\"RR_CHAOS_PADDING=\") + chars.data();\n flags.extra_env.push_back(padding);\n }\n\n WaitStatus status = record(args, flags);\n\n // Everything should have been cleaned up by now.\n check_for_leaks();\n\n switch (status.type()) {\n case WaitStatus::EXIT:\n return status.exit_code();\n case WaitStatus::FATAL_SIGNAL:\n signal(status.fatal_sig(), SIG_DFL);\n prctl(PR_SET_DUMPABLE, 0);\n kill(getpid(), status.fatal_sig());\n break;\n default:\n FATAL() << \"Don't know why we exited: \" << status;\n break;\n }\n return 1;\n}\n\n} // namespace rr\n" }, { "path": "src/RecordCommand.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RECORD_COMMAND_H_\n#define RR_RECORD_COMMAND_H_\n\n#include \"Command.h\"\n\nnamespace rr {\n\nvoid force_close_record_session();\n\nclass RecordCommand : public Command {\npublic:\n virtual int run(std::vector& args) override;\n\n static RecordCommand* get() { return &singleton; }\n\nprotected:\n RecordCommand(const char* name, const char* help) : Command(name, help) {}\n\n static RecordCommand singleton;\n};\n\n} // namespace rr\n\n#endif // RR_RECORD_COMMAND_H_\n" }, { "path": "src/RecordSession.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"RecordSession.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"AutoRemoteSyscalls.h\"\n#include \"ElfReader.h\"\n#include \"Flags.h\"\n#include \"PerfCounters.h\"\n#include \"RecordTask.h\"\n#include \"TraceeAttentionSet.h\"\n#include \"TraceStream.h\"\n#include \"VirtualPerfCounterMonitor.h\"\n#include \"WaitManager.h\"\n#include \"core.h\"\n#include \"ftrace.h\"\n#include \"kernel_metadata.h\"\n#include \"kernel_supplement.h\"\n#include \"log.h\"\n#include \"record_signal.h\"\n#include \"record_syscall.h\"\n#include \"seccomp-bpf.h\"\n\nnamespace rr {\n\n// Undef si_addr_lsb since it's an alias for a field name that doesn't exist,\n// and we need to use the actual field name.\n#ifdef si_addr_lsb\n#undef si_addr_lsb\n#endif\n\nusing namespace rr;\nusing namespace std;\n\ntemplate static remote_ptr mask_low_bit(remote_ptr p) {\n return p.as_int() & ~uintptr_t(1);\n}\n\ntemplate \nstatic void record_robust_futex_change(\n RecordTask* t, const typename Arch::robust_list_head& head,\n remote_ptr base) {\n if (base.is_null()) {\n return;\n }\n remote_ptr futex_void_ptr = base + head.futex_offset;\n auto futex_ptr = futex_void_ptr.cast();\n // We can't just record the current futex value because at this point\n // in task exit the robust futex handling has not happened yet. So we have\n // to emulate what the kernel will do!\n bool ok = true;\n uint32_t val = t->read_mem(futex_ptr, &ok);\n if (!ok) {\n return;\n }\n if (pid_t(val & FUTEX_TID_MASK) != t->own_namespace_rec_tid) {\n return;\n }\n val = (val & FUTEX_WAITERS) | FUTEX_OWNER_DIED;\n // Update memory now so that the kernel doesn't decide to do it later, at\n // a time that might race with other tracee execution.\n t->write_mem(futex_ptr, val);\n t->record_local(futex_ptr, &val);\n}\n\n/**\n * Any user-space writes performed by robust futex handling are captured here.\n * They must be emulated during replay; the kernel will not do it for us\n * during replay because the TID value in each futex is the recorded\n * TID, not the actual TID of the dying task.\n */\ntemplate \nstatic void record_robust_futex_changes_arch(RecordTask* t) {\n if (t->did_record_robust_futex_changes) {\n return;\n }\n t->did_record_robust_futex_changes = true;\n\n auto head_ptr = t->robust_list().cast();\n if (head_ptr.is_null()) {\n return;\n }\n ASSERT(t, t->robust_list_len() == sizeof(typename Arch::robust_list_head));\n bool ok = true;\n auto head = t->read_mem(head_ptr, &ok);\n if (!ok) {\n return;\n }\n record_robust_futex_change(t, head,\n mask_low_bit(head.list_op_pending.rptr()));\n for (auto current = mask_low_bit(head.list.next.rptr());\n current.as_int() != head_ptr.as_int();) {\n record_robust_futex_change(t, head, current);\n auto next = t->read_mem(current, &ok);\n if (!ok) {\n return;\n }\n current = mask_low_bit(next.next.rptr());\n }\n}\n\nstatic void record_robust_futex_changes(RecordTask* t) {\n RR_ARCH_FUNCTION(record_robust_futex_changes_arch, t->arch(), t);\n}\n\nstatic bool looks_like_syscall_entry(RecordTask* t) {\n bool ok;\n bool at_syscall = is_at_syscall_instruction(t,\n t->regs().ip().decrement_by_syscall_insn_length(t->arch()), &ok);\n // It's possible for the task to have died (e.g. if it got signaled twice\n // in rapid succession). In that case, try to just go by register contents.\n if (ok && !at_syscall) {\n return false;\n }\n if (is_x86ish(t->arch())) {\n // On x86 rax gets set to ENOSYS on entry. Elsewhere this does not happen.\n // Further, even if we did ask about the syscallno, it might have been\n // reset by the signal handler. However, on non-x86 platforms we currently\n // count taken braches, rather than only conditional ones, so it should\n // be impossible to see the same syscall ip twice without intervening\n // ticks, so the check that follows these conditions, should be sufficient\n // there.\n return t->regs().original_syscallno() >= 0 &&\n t->regs().syscall_result_signed() == -ENOSYS;\n } else if (t->arch() == aarch64) {\n // We recorded when we saw the last syscall entry\n // so just use that to determine if we've already save it in the trace.\n if (t->ticks_at_last_syscall_entry == t->tick_count() &&\n t->ip_at_last_syscall_entry == t->regs().ip()) {\n return !t->last_syscall_entry_recorded;\n }\n }\n // Getting a sched event here is better than a spurious syscall event.\n // Syscall entry does not cause visible register modification, so upon\n // hitting the sched event the register state would indeed match.\n return ok;\n}\n\n/**\n * Return true if we handle a ptrace exit event for task t. When this returns\n * true, t may have been deleted.\n */\nstatic bool handle_ptrace_exit_event(RecordTask* t) {\n if (t->was_reaped()) {\n if (t->handled_ptrace_exit_event()) {\n t->did_reach_zombie();\n return true;\n }\n } else if (t->ptrace_event() != PTRACE_EVENT_EXIT) {\n return false;\n }\n\n if (t->stable_exit || t->was_reaped()) {\n LOG(debug) << \"stable exit\";\n } else {\n if (!t->may_be_blocked()) {\n // might have been hit by a SIGKILL or a SECCOMP_RET_KILL, in which case\n // there might be some execution since its last recorded event that we\n // need to replay.\n // There's a weird case (in 4.13.5-200.fc26.x86_64 at least) where the\n // task can enter the kernel but instead of receiving a syscall ptrace\n // event, we receive a PTRACE_EVENT_EXIT due to a concurrent execve\n // (and probably a concurrent SIGKILL could do the same). The task state\n // has been updated to reflect syscall entry. If we record a SCHED in\n // that state replay of the SCHED will fail. So detect that state and fix\n // it up.\n // If we got killed in an untraced syscall on AArch64,\n // it is difficult/impossible to tell if the value of x0 has been overwritten\n // with the syscall result/error number\n // and it's even harder to recover the correct value of x0.\n // Simply ignore these since we weren't going to record them anyway.\n if (looks_like_syscall_entry(t) && !t->is_in_untraced_syscall()) {\n // Either we're in a syscall, or we're immediately after a syscall\n // and it exited.\n if (t->ticks_at_last_recorded_syscall_exit == t->tick_count() &&\n t->regs().ip() == t->ip_at_last_recorded_syscall_exit) {\n LOG(debug) << \"Nothing to record after PTRACE_EVENT_EXIT\";\n // It's the latter case; do nothing.\n } else {\n // It's the former case ... probably. Theoretically we could have\n // re-executed a syscall without any ticks in between, but that seems\n // highly improbable.\n // Record the syscall-entry event that we otherwise failed to record.\n t->canonicalize_regs(t->arch());\n auto r = t->regs();\n if (t->arch() == aarch64) {\n // On AArch64, when we get here, there are 3 different cases,\n // 1. EXIT before we hit the syscall entry stop\n // 2. EXIT after syscall entry stop but\n // before the result (X0) is overwritten\n // 3. EXIT after syscall entry stop and\n // after the result (X0) is overwritten\n // (i.e. after the syscall but we got an EXIT\n // before the syscall exit stop.)\n\n // We detect the first case based on `*_at_last_syscall_entry`\n // set by `apply_syscall_entry_regs` and trust the current values\n // `x0` and `x8`.\n\n // For the second and third cases, we rely on the syscall enter stop\n // to set the orig_arg1 and original_syscallno correctly.\n if (t->ticks_at_last_syscall_entry == t->tick_count() &&\n t->ip_at_last_syscall_entry == r.ip()) {\n // We need to rely on the saved `orig_arg1` since in the third case\n // the `x0` may already be overwritten.\n // The assertion here assumes that\n // `apply_syscall_entry_regs` is called when we enter the syscall\n // and `x8` still holds the correct syscall number\n // when we hit the process exit stop.\n ASSERT(t, r.original_syscallno() == r.syscallno())\n << \"syscallno not saved by syscall enter handler: \" << r;\n r.set_arg1(r.orig_arg1());\n } else {\n r.set_original_syscallno(r.syscallno());\n }\n }\n // Assume it's a native-arch syscall. If it isn't, it doesn't matter\n // all that much since we aren't actually going to do anything with it\n // in this task.\n // Avoid calling detect_syscall_arch here since it could fail if the\n // task is already completely dead and gone.\n SyscallEvent event(r.original_syscallno(), t->arch());\n event.state = ENTERING_SYSCALL;\n // Don't try to reset the syscallbuf here. The task may be exiting\n // while in arbitrary syscallbuf code. And of course, because it's\n // exiting, it doesn't matter if we don't reset the syscallbuf.\n t->record_event(event, RecordTask::FLUSH_SYSCALLBUF,\n RecordTask::DONT_RESET_SYSCALLBUF, &r);\n }\n } else {\n // Don't try to reset the syscallbuf here. The task may be exiting\n // while in arbitrary syscallbuf code. And of course, because it's\n // exiting, it doesn't matter if we don't reset the syscallbuf.\n // XXX flushing the syscallbuf may be risky too...\n auto event = Event::sched();\n // When replaying this SCHED, we won't proceed past the `syscall_hook`\n // entry point. Code inside the syscallbuf may be in a bad state during\n // replay because we didn't save buffered syscalls.\n event.Sched().in_syscallbuf_syscall_hook = t->syscallbuf_code_layout.syscallbuf_syscall_hook;\n t->record_event(event, RecordTask::FLUSH_SYSCALLBUF,\n RecordTask::DONT_RESET_SYSCALLBUF);\n }\n }\n /* XXX: We could try to find some tasks here to unmap our buffers, but it\n * seems hardly worth it.\n * Mark buffers as gone after recording events, in case they need to flush the syscallbuf.\n */\n t->destroy_buffers(nullptr, nullptr);\n }\n\n WaitStatus exit_status;\n if (t->was_reaped()) {\n exit_status = t->status();\n } else {\n record_robust_futex_changes(t);\n\n unsigned long msg = 0;\n // If ptrace_if_stopped fails, then the task has been killed by SIGKILL\n // or equivalent.\n if (t->ptrace_if_stopped(PTRACE_GETEVENTMSG, nullptr, &msg)) {\n exit_status = WaitStatus(msg);\n } else {\n exit_status = WaitStatus::for_fatal_sig(SIGKILL);\n }\n }\n\n t->did_handle_ptrace_exit_event();\n // The counters might be running if we did not read the final register values\n // (e.g. because our registers are dirty). Stop them now so we can close them\n // safely.\n t->hpc.stop(t);\n\n // If we died because of a coredumping signal, that is a barrier event, and\n // every task in the address space needs to pass its PTRACE_EXIT_EVENT before\n // they proceed to (potentially hidden) zombie state, so we can't wait for\n // that to happen.\n // Similarly we can't wait for this task to exit if there are other\n // tasks in its pid namespace that need to exit and this is the last thread\n // of pid-1 in that namespace, because the kernel must reap them before\n // letting this task complete its exit.\n bool may_wait_exit = !t->was_reaped() && !is_coredumping_signal(exit_status.fatal_sig()) &&\n !t->waiting_for_pid_namespace_tasks_to_exit();\n t->record_exit_trace_event(exit_status);\n t->record_exit_event(\n (!t->was_reaped() && !may_wait_exit) ? RecordTask::WRITE_CHILD_TID : RecordTask::KERNEL_WRITES_CHILD_TID);\n if (!t->was_reaped()) {\n t->proceed_to_exit(may_wait_exit);\n }\n t->do_ptrace_exit_stop(exit_status);\n if (may_wait_exit) {\n t->did_reach_zombie();\n } else if (!t->was_reaped()) {\n t->waiting_for_reap = true;\n }\n return true;\n}\n\nstatic void note_entering_syscall(RecordTask* t) {\n ASSERT(t, EV_SYSCALL == t->ev().type());\n t->ev().Syscall().state = ENTERING_SYSCALL;\n if (!t->ev().Syscall().is_restart) {\n /* Save a copy of the arg registers so that we\n * can use them to detect later restarted\n * syscalls, if this syscall ends up being\n * restarted. We have to save the registers\n * in this rather awkward place because we\n * need the original registers; the restart\n * (if it's not a SYS_restart_syscall restart)\n * will use the original registers. */\n t->ev().Syscall().regs = t->regs();\n } else {\n t->ev().Syscall().regs.set_syscallno(t->regs().syscallno());\n // We may have intentionally stored the syscall result here.\n // Now that we're safely past the signal delivery, make the\n // registers look like they did at the original syscall entry\n // again.\n t->ev().Syscall().regs.set_arg1(t->ev().Syscall().regs.orig_arg1());\n if (t->arch() == aarch64) {\n // We probably got here with a PTRACE_SYSCALL. The x7\n // value will be wrong due to the aarch64 kernel bug.\n // Get it from the syscall event.\n Registers r = t->regs();\n r.set_x(7, t->ev().Syscall().regs.x(7));\n t->set_regs(r);\n }\n }\n}\n\n#if defined (__x86_64__)\nstatic bool is_in_vsyscall(remote_code_ptr ip)\n{\n // This is hardcoded by the Linux ABI\n remote_code_ptr vsyscall_start = 0xffffffffff600000;\n remote_code_ptr vsyscall_end = 0xffffffffff601000;\n return vsyscall_start <= ip && ip < vsyscall_end;\n}\n#else\nstatic bool is_in_vsyscall(remote_code_ptr)\n{\n return false;\n}\n#endif\n\nvoid RecordSession::handle_seccomp_traced_syscall(RecordTask* t,\n StepState* step_state,\n RecordResult* result,\n bool* did_enter_syscall) {\n *did_enter_syscall = false;\n\n // Special case: If the tracee issues a vsyscall, we will get a seccomp trap,\n // but no syscall traps whatsoever. In particular, we wouldn't see it during\n // replay either. We try to monkeypatch the caller on the assumption that known\n // callers of this (deprecated) interface all follow a common pattern. If we\n // can't patch the caller, this is a fatal error, since the recording will\n // otherwise be broken.\n remote_code_ptr ip = t->regs().ip();\n if (is_in_vsyscall(ip)) {\n remote_ptr sp = t->regs().sp();\n // The kernel assumes the return address is on the stack - we do the same\n remote_ptr ret_addr_addr = sp.cast();\n remote_code_ptr ret_addr = t->read_mem(ret_addr_addr);\n\n // Skip this syscall. We will attempt to patch it to the vdso entry and\n // let the tracee retry there.\n Registers regs = t->regs();\n regs.set_original_syscallno(-1);\n // We can't modify the ip here, the kernel will kill the tracee with\n // SIGSYS. Instead, we set a breakpoint at the return instruction.\n t->set_regs(regs);\n t->vm()->add_breakpoint(ret_addr, BKPT_INTERNAL);\n while (true) {\n if (!t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee exited unexpectedly\n return;\n }\n ASSERT(t, !t->ptrace_event());\n if (t->stop_sig() == syscallbuf_desched_sig()) {\n continue;\n }\n if (t->stop_sig() == SIGTRAP &&\n is_kernel_trap(t->get_siginfo().si_code)) {\n // Hit the breakpoint\n break;\n }\n t->stash_sig();\n }\n t->vm()->remove_breakpoint(ret_addr, BKPT_INTERNAL);\n\n ASSERT(t, t->regs().ip().undo_executed_bkpt(t->arch()) == ret_addr);\n\n // Now that we're in a sane state, ask the Monkeypatcher to try and patch\n // that.\n bool patch_ok = t->vm()->monkeypatcher().try_patch_vsyscall_caller(t, ret_addr);\n ASSERT(t, patch_ok) << \"The tracee issues a vsyscall to \" << ip\n << \" but we failed to monkeypatch the caller (return address \"\n << ret_addr << \", sp=\" << sp << \"). Recording will not succeed. Exiting.\";\n\n // Reset to the start of the region and continue\n regs = t->regs();\n regs.set_ip(ret_addr.decrement_by_vsyscall_entry_length(t->arch()));\n t->set_regs(regs);\n\n // We patched this syscall, record that\n auto ev = Event::patch_syscall();\n ev.PatchSyscall().patch_vsyscall = true;\n t->record_event(ev);\n\n step_state->continue_type = RecordSession::CONTINUE;\n return;\n }\n\n int syscallno = t->regs().original_syscallno();\n if (syscallno < 0) {\n // negative syscall numbers after a SECCOMP event\n // are treated as \"skip this syscall\". There will be one syscall event\n // reported instead of two. So fake an enter-syscall event now.\n // It doesn't really matter what the syscall-arch is.\n t->canonicalize_regs(t->arch());\n if (syscall_seccomp_ordering_ == SECCOMP_BEFORE_PTRACE_SYSCALL) {\n // If the ptrace entry stop hasn't happened yet, we're at a weird\n // intermediate state where the behavior of the next PTRACE_SYSCALL\n // will depend on the register state (i.e. whether we see an entry\n // trap or proceed right to the exit trap). To make things easier\n // on the rest of the system, do a fake syscall entry, then reset\n // the register state.\n Registers orig_regs = t->regs();\n Registers r = orig_regs;\n r.set_original_syscallno(syscall_number_for_gettid(t->arch()));\n t->set_regs(r);\n if (!t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n // Tracee died unexpectedly. We did not enter a syscall.\n // We shouldn't try to resume it now.\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = RecordSession::DONT_CONTINUE;\n return;\n }\n t->set_regs(orig_regs);\n }\n\n // Don't continue yet. At the next iteration of record_step, we'll\n // enter syscall_state_changed and that will trigger a continue to\n // the syscall exit.\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = RecordSession::DONT_CONTINUE;\n if (!process_syscall_entry(t, step_state, result, t->arch())) {\n return;\n }\n *did_enter_syscall = true;\n return;\n }\n\n if (syscall_seccomp_ordering_ == SECCOMP_BEFORE_PTRACE_SYSCALL) {\n // The next continue needs to be a PTRACE_SYSCALL to observe\n // the enter-syscall event.\n step_state->continue_type = RecordSession::CONTINUE_SYSCALL;\n } else {\n ASSERT(t, syscall_seccomp_ordering_ == PTRACE_SYSCALL_BEFORE_SECCOMP);\n if (t->ev().is_syscall_event() &&\n t->ev().Syscall().state == PROCESSING_SYSCALL) {\n // We did PTRACE_SYSCALL and already saw a syscall trap. Just ignore this.\n LOG(debug) << \"Ignoring SECCOMP syscall trap since we already got a \"\n \"PTRACE_SYSCALL trap\";\n // The next continue needs to be a PTRACE_SYSCALL to observe\n // the exit-syscall event.\n step_state->continue_type = RecordSession::CONTINUE_SYSCALL;\n // Need to restore last_task_switchable since it will have been\n // reset to PREVENT_SWITCH\n last_task_switchable = t->ev().Syscall().switchable;\n } else {\n // We've already passed the PTRACE_SYSCALL trap for syscall entry, so\n // we need to handle that now.\n SupportedArch syscall_arch = t->detect_syscall_arch();\n t->canonicalize_regs(syscall_arch);\n if (!process_syscall_entry(t, step_state, result, syscall_arch)) {\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = RecordSession::DONT_CONTINUE;\n return;\n }\n *did_enter_syscall = true;\n }\n }\n}\n\nstatic void seccomp_trap_done(RecordTask* t) {\n t->pop_seccomp_trap();\n\n // It's safe to reset the syscall buffer now.\n t->delay_syscallbuf_reset_for_seccomp_trap = false;\n\n t->write_and_record(REMOTE_PTR_FIELD(t->syscallbuf_child, failed_during_preparation),\n (uint8_t)1);\n if (EV_DESCHED == t->ev().type()) {\n // Desched processing will do the rest for us\n return;\n }\n\n // Abort the current syscallbuf record, which corresponds to the syscall that\n // wasn't actually executed due to seccomp.\n t->write_mem(REMOTE_PTR_FIELD(t->syscallbuf_child, abort_commit), (uint8_t)1);\n t->record_event(Event::syscallbuf_abort_commit());\n\n // In fact, we need to. Running the syscall exit hook will ensure we\n // reset the buffer before we try to buffer another a syscall.\n t->write_mem(\n REMOTE_PTR_FIELD(t->syscallbuf_child, notify_on_syscall_hook_exit),\n (uint8_t)1);\n}\n\nvoid RecordSession::handle_seccomp_trap(RecordTask* t,\n RecordSession::StepState* step_state,\n uint16_t seccomp_data) {\n // The architecture may be wrong, but that's ok, because an actual syscall\n // entry did happen, so the registers are already updated according to the\n // architecture of the system call.\n t->canonicalize_regs(t->detect_syscall_arch());\n t->apply_syscall_entry_regs();\n\n Registers r = t->regs();\n int syscallno = r.original_syscallno();\n // Cause kernel processing to skip the syscall\n r.set_original_syscallno(SECCOMP_MAGIC_SKIP_ORIGINAL_SYSCALLNO);\n t->set_regs(r);\n\n bool syscall_entry_already_recorded = false;\n if (t->ev().is_syscall_event()) {\n // A syscall event was already pushed, probably because we did a\n // PTRACE_SYSCALL to enter the syscall during handle_desched_event. Cancel\n // that event now since the seccomp SIGSYS aborts it completely.\n ASSERT(t, t->ev().Syscall().number == syscallno);\n // Make sure any prepared syscall state is discarded and any temporary\n // effects (e.g. redirecting pointers to scratch) undone.\n rec_abort_prepared_syscall(t);\n if (t->ev().type() == EV_SYSCALL_INTERRUPTION) {\n // The event could be a syscall-interruption if it was pushed by\n // `handle_desched_event`. In that case, it has not been recorded yet.\n t->pop_syscall_interruption();\n } else {\n t->pop_syscall();\n syscall_entry_already_recorded = true;\n }\n }\n\n if (t->is_in_untraced_syscall()) {\n ASSERT(t, !t->delay_syscallbuf_reset_for_seccomp_trap);\n // Don't reset the syscallbuf immediately after delivering the trap. We have\n // to wait until this buffered syscall aborts completely before resetting\n // the buffer.\n t->delay_syscallbuf_reset_for_seccomp_trap = true;\n\n t->push_event(Event::seccomp_trap());\n\n // desched may be armed but we're not going to execute the syscall, let\n // alone block. If it fires, ignore it.\n t->write_mem(\n REMOTE_PTR_FIELD(t->syscallbuf_child, desched_signal_may_be_relevant),\n (uint8_t)0);\n }\n\n t->push_syscall_event(syscallno);\n t->ev().Syscall().failed_during_preparation = true;\n note_entering_syscall(t);\n\n if (t->is_in_untraced_syscall() && !syscall_entry_already_recorded) {\n t->record_current_event();\n }\n\n // Use NativeArch here because different versions of system headers\n // have inconsistent field naming.\n union {\n NativeArch::siginfo_t native_api;\n siginfo_t linux_api;\n } si;\n memset(&si, 0, sizeof(si));\n si.native_api.si_signo = SIGSYS;\n si.native_api.si_errno = seccomp_data;\n si.native_api.si_code = SYS_SECCOMP;\n si.native_api._sifields._sigsys._arch = to_audit_arch(r.arch());\n si.native_api._sifields._sigsys._syscall = syscallno;\n // Documentation says that si_call_addr is the address of the syscall\n // instruction, but in tests it's immediately after the syscall\n // instruction.\n si.native_api._sifields._sigsys._call_addr = t->ip().to_data_ptr();\n LOG(debug) << \"Synthesizing \" << si.linux_api;\n t->stash_synthetic_sig(si.linux_api, DETERMINISTIC_SIG);\n\n // Tests show that the current registers are preserved (on x86, eax/rax\n // retains the syscall number).\n r.set_syscallno(syscallno);\n t->set_regs(r);\n t->maybe_restore_original_syscall_registers();\n\n if (t->is_in_untraced_syscall()) {\n // For buffered syscalls, go ahead and record the exit state immediately.\n t->ev().Syscall().state = EXITING_SYSCALL;\n t->record_current_event();\n t->pop_syscall();\n\n // The tracee is currently in the seccomp ptrace-stop. Advance it to the\n // syscall-exit stop so that when we try to deliver the SIGSYS via\n // PTRACE_SINGLESTEP, that doesn't trigger a SIGTRAP stop.\n // If this fails, that's fine, we're not going to deliver the SIGSYS.\n t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS);\n }\n\n // Don't continue yet. At the next iteration of record_step, if we\n // recorded the syscall-entry we'll enter syscall_state_changed and\n // that will trigger a continue to the syscall exit. If we recorded the\n // syscall-exit we'll go straight into signal delivery.\n step_state->continue_type = RecordSession::DONT_CONTINUE;\n}\n\nvoid RecordSession::handle_seccomp_errno(RecordTask* t,\n RecordSession::StepState* step_state,\n uint16_t seccomp_data) {\n t->canonicalize_regs(t->detect_syscall_arch());\n\n Registers r = t->regs();\n int syscallno = r.original_syscallno();\n // Cause kernel processing to skip the syscall\n r.set_original_syscallno(SECCOMP_MAGIC_SKIP_ORIGINAL_SYSCALLNO);\n t->set_regs(r);\n\n if (!t->is_in_untraced_syscall()) {\n t->push_syscall_event(syscallno);\n // Note that the syscall failed. prepare_clone() needs to know\n // this during replay of the syscall entry.\n t->ev().Syscall().failed_during_preparation = true;\n note_entering_syscall(t);\n }\n\n r.set_syscall_result(-seccomp_data);\n t->set_regs(r);\n // Don't continue yet. At the next iteration of record_step, if we\n // recorded the syscall-entry we'll enter syscall_state_changed and\n // that will trigger a continue to the syscall exit.\n step_state->continue_type = RecordSession::DONT_CONTINUE;\n}\n\nbool RecordSession::handle_ptrace_event(RecordTask** t_ptr,\n StepState* step_state,\n RecordResult* result,\n bool* did_enter_syscall) {\n *did_enter_syscall = false;\n\n RecordTask* t = *t_ptr;\n if (t->status().group_stop() || t->has_stashed_group_stop()) {\n t->clear_stashed_group_stop();\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = DONT_CONTINUE;\n return true;\n }\n\n int event = t->ptrace_event();\n if (!event) {\n return false;\n }\n\n LOG(debug) << \" \" << t->tid << \": handle_ptrace_event \"\n << ptrace_event_name(event) << \": event \" << t->ev();\n\n switch (event) {\n case PTRACE_EVENT_SECCOMP_OBSOLETE:\n case PTRACE_EVENT_SECCOMP: {\n if (syscall_seccomp_ordering_ == PTRACE_SYSCALL_BEFORE_SECCOMP_UNKNOWN) {\n syscall_seccomp_ordering_ = SECCOMP_BEFORE_PTRACE_SYSCALL;\n }\n\n int seccomp_data = t->get_ptrace_eventmsg_seccomp_data();\n // We need to set the orig_* values before we let the process continue to exit\n // since the handler for the exit event will need them.\n // See `handle_ptrace_exit_event` above.\n t->apply_syscall_entry_regs();\n if (seccomp_data < 0) {\n // Process just died. Urk. Just wait for the exit event and pretend this stop never happened!\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = DONT_CONTINUE;\n return true;\n }\n int syscallno = t->regs().original_syscallno();\n if (seccomp_data == SECCOMP_RET_DATA) {\n LOG(debug) << \" traced syscall entered: \"\n << syscall_name(syscallno, t->arch());\n handle_seccomp_traced_syscall(t, step_state, result, did_enter_syscall);\n } else {\n // Note that we make no attempt to patch the syscall site when the\n // user handle does not return ALLOW. Apart from the ERRNO case,\n // handling these syscalls is necessarily slow anyway.\n uint32_t real_result;\n if (!seccomp_filter_rewriter().map_filter_data_to_real_result(\n t, seccomp_data, &real_result)) {\n LOG(debug)\n << \"Process terminated unexpectedly during PTRACE_GETEVENTMSG\";\n step_state->continue_type = RecordSession::CONTINUE;\n break;\n }\n uint16_t real_result_data = real_result & SECCOMP_RET_DATA;\n switch (real_result & SECCOMP_RET_ACTION) {\n case SECCOMP_RET_TRAP:\n LOG(debug) << \" seccomp trap for syscall: \"\n << syscall_name(syscallno, t->arch());\n handle_seccomp_trap(t, step_state, real_result_data);\n break;\n case SECCOMP_RET_ERRNO:\n LOG(debug) << \" seccomp errno \" << errno_name(real_result_data)\n << \" for syscall: \"\n << syscall_name(syscallno, t->arch());\n handle_seccomp_errno(t, step_state, real_result_data);\n break;\n case SECCOMP_RET_KILL:\n LOG(debug) << \" seccomp kill for syscall: \"\n << syscall_name(syscallno, t->arch());\n t->tgkill(SIGKILL);\n // Rely on the SIGKILL to bump us out of the ptrace stop.\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = RecordSession::DONT_CONTINUE;\n // Now wait for us to actually exit our ptrace-stop and proceed\n // to the PTRACE_EVENT_EXIT. This avoids the race where our\n // PTRACE_CONT might kick us out of the PTRACE_EVENT_EXIT before\n // we can process it.\n // If this fails because of *another* SIGKILL that's fine.\n t->wait();\n break;\n default:\n ASSERT(t, false) << \"Seccomp result not handled\";\n break;\n }\n }\n break;\n }\n\n case PTRACE_EVENT_EXEC: {\n if (t->thread_group()->task_set().size() > 1) {\n // All tasks but the task that did the execve should have exited by\n // now and notified us of their exits. However, it's possible that\n // while running the thread-group leader, our PTRACE_CONT raced with its\n // PTRACE_EVENT_EXIT and it exited, and the next event we got is this\n // PTRACE_EVENT_EXEC after the exec'ing task changed its tid to the\n // leader's tid. Or maybe there are kernel bugs; on\n // 4.2.0-42-generic running exec_from_other_thread, we reproducibly\n // enter PTRACE_EVENT_EXEC for the thread-group leader without seeing\n // its PTRACE_EVENT_EXIT.\n\n // So, record this task's exit and destroy it.\n // XXX We can't do record_robust_futex_changes here because the address\n // space has already gone. That would only matter if some of them were\n // in memory accessible to another process even after exec, i.e. a\n // shared-memory mapping or two different thread-groups sharing the same\n // address space.\n pid_t tid = t->rec_tid;\n WaitStatus status = t->status();\n t->record_exit_trace_event(WaitStatus(0));\n t->record_exit_event();\n // Don't call RecordTask::destroy() because we don't want to\n // PTRACE_DETACH.\n delete t;\n // Steal the exec'ing task and make it the thread-group leader, and\n // carry on!\n t = revive_task_for_exec(tid);\n scheduler().set_current(t);\n *t_ptr = t;\n // Tell t that it is actually stopped, because the stop we got is really\n // for this task, not the old dead task.\n if (!t->did_waitpid(status)) {\n // This is totally untested and almost certainly broken, but if the\n // task was SIGKILLed out of the EXEC stop then we should probably\n // just pretend the exec never happened.\n step_state->continue_type = CONTINUE_SYSCALL;\n break;\n }\n }\n t->post_exec();\n t->session().scheduler().did_exit_execve(t);\n\n // Forward ptrace exec notification\n if (t->emulated_ptracer) {\n if (t->emulated_ptrace_options & PTRACE_O_TRACEEXEC) {\n t->emulate_ptrace_stop(\n WaitStatus::for_ptrace_event(PTRACE_EVENT_EXEC));\n } else if (!t->emulated_ptrace_seized) {\n // Inject legacy SIGTRAP-after-exec\n t->tgkill(SIGTRAP);\n }\n }\n\n if (t->emulated_stop_pending) {\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = DONT_CONTINUE;\n } else {\n // Skip past the ptrace event.\n step_state->continue_type = CONTINUE_SYSCALL;\n }\n break;\n }\n\n default:\n ASSERT(t, false) << \"Unhandled ptrace event \" << ptrace_event_name(event)\n << \"(\" << event << \")\";\n break;\n }\n\n return true;\n}\n\nstatic void debug_exec_state(const char* msg, RecordTask* t) {\n LOG(debug) << msg << \": status=\" << t->status();\n}\n\ntemplate \nstatic bool is_ptrace_any_singlestep_arch(int command) {\n return command >= 0 &&\n (command == PTRACE_SINGLESTEP || command == Arch::PTRACE_SYSEMU_SINGLESTEP);\n}\n\nstatic bool is_ptrace_any_singlestep(SupportedArch arch, int command)\n{\n RR_ARCH_FUNCTION(is_ptrace_any_singlestep_arch, arch, command);\n}\n\nvoid RecordSession::task_continue(const StepState& step_state) {\n RecordTask* t = scheduler().current();\n\n ASSERT(t, step_state.continue_type != DONT_CONTINUE);\n // A task in an emulated ptrace-stop must really stay stopped\n ASSERT(t, !t->emulated_stop_pending);\n\n bool may_restart = t->at_may_restart_syscall();\n\n if (may_restart && t->seccomp_bpf_enabled) {\n LOG(debug) << \" PTRACE_SYSCALL to possibly-restarted \" << t->ev();\n }\n\n if (!t->vm()->first_run_event()) {\n t->vm()->set_first_run_event(trace_writer().time());\n }\n\n if (!t->thread_group()->first_run_event()) {\n t->thread_group()->set_first_run_event(trace_writer().time());\n }\n\n TicksRequest ticks_request;\n ResumeRequest resume;\n if (step_state.continue_type == CONTINUE_SYSCALL) {\n ticks_request = RESUME_NO_TICKS;\n resume = RESUME_SYSCALL;\n } else {\n if (t->has_stashed_sig(PerfCounters::TIME_SLICE_SIGNAL)) {\n // timeslice signal already stashed, no point in generating another one\n // (and potentially slow)\n ticks_request = RESUME_UNLIMITED_TICKS;\n } else if (scheduler().may_use_unlimited_ticks()) {\n ticks_request = RESUME_UNLIMITED_TICKS;\n } else {\n ticks_request = (TicksRequest)max(\n 0, scheduler().current_timeslice_end() - t->tick_count());\n }\n\n // Clear any lingering state, then see if we need to stop earlier for a\n // tracee-requested pmc interrupt on the virtualized performance counter.\n t->next_pmc_interrupt_is_for_user = false;\n if (auto vpmc =\n VirtualPerfCounterMonitor::interrupting_virtual_pmc_for_task(t)) {\n ASSERT(t, vpmc->target_tuid() == t->tuid());\n\n Ticks after = max(vpmc->target_ticks() - t->tick_count(), 0);\n if ((uint64_t)after < (uint64_t)ticks_request) {\n LOG(debug) << \"ticks_request constrained from \" << ticks_request\n << \" to \" << after << \" for vpmc\";\n ticks_request = (TicksRequest)after;\n t->next_pmc_interrupt_is_for_user = true;\n }\n }\n\n // Override requested by the tracee for testing purposes\n if (t->tick_request_override != (TicksRequest)0) {\n ASSERT(t, !t->next_pmc_interrupt_is_for_user);\n ticks_request = t->tick_request_override;\n t->tick_request_override = (TicksRequest)0;\n }\n\n bool singlestep = is_ptrace_any_singlestep(t->arch(),\n t->emulated_ptrace_cont_command);\n if (singlestep && is_at_syscall_instruction(t, t->ip())) {\n // We're about to singlestep into a syscall instruction.\n // Act like we're NOT singlestepping since doing a PTRACE_SINGLESTEP would\n // skip over the system call.\n LOG(debug)\n << \"Clearing singlestep because we're about to enter a syscall\";\n singlestep = false;\n }\n if (singlestep) {\n resume = RESUME_SINGLESTEP;\n } else {\n /* We won't receive PTRACE_EVENT_SECCOMP events until\n * the seccomp filter is installed by the\n * syscall_buffer lib in the child, therefore we must\n * record in the traditional way (with PTRACE_SYSCALL)\n * until it is installed. */\n /* Kernel commit\n https://github.com/torvalds/linux/commit/93e35efb8de45393cf61ed07f7b407629bf698ea\n makes PTRACE_SYSCALL traps be delivered *before* seccomp RET_TRACE\n traps.\n Detect and handle this. */\n if (!t->seccomp_bpf_enabled || may_restart ||\n syscall_seccomp_ordering_ == PTRACE_SYSCALL_BEFORE_SECCOMP_UNKNOWN) {\n resume = RESUME_SYSCALL;\n } else {\n /* When the seccomp filter is on, instead of capturing\n * syscalls by using PTRACE_SYSCALL, the filter will\n * generate the ptrace events. This means we allow the\n * process to run using PTRACE_CONT, and rely on the\n * seccomp filter to generate the special\n * PTRACE_EVENT_SECCOMP event once a syscall happens.\n * This event is handled here by simply allowing the\n * process to continue to the actual entry point of\n * the syscall (using cont_syscall_block()) and then\n * using the same logic as before. */\n resume = RESUME_CONT;\n }\n }\n }\n t->resume_execution(resume, RESUME_NONBLOCKING, ticks_request);\n}\n\n/**\n * Step |t| forward until the tracee syscall that disarms the desched\n * event. If a signal becomes pending in the interim, we stash it.\n * This allows the caller to deliver the signal after this returns.\n * (In reality the desched event will already have been disarmed before we\n * enter this function.)\n */\nstatic void advance_to_disarm_desched_syscall(RecordTask* t) {\n int old_sig = 0;\n\n LOG(debug) << \"desched: DISARMING_DESCHED_EVENT\";\n /* TODO: send this through main loop. */\n /* TODO: mask off signals and avoid this loop. */\n do {\n if (!t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_UNLIMITED_TICKS)) {\n return;\n }\n if (t->status().is_syscall()) {\n t->apply_syscall_entry_regs();\n }\n /* We can safely ignore TIME_SLICE_SIGNAL while trying to\n * reach the disarm-desched ioctl: once we reach it,\n * the desched'd syscall will be \"done\" and the tracee\n * will be at a preemption point. In fact, we *want*\n * to ignore this signal. Syscalls like read() can\n * have large buffers passed to them, and we have to\n * copy-out the buffered out data to the user's\n * buffer. This happens in the interval where we're\n * reaching the disarm-desched ioctl, so that code is\n * susceptible to receiving TIME_SLICE_SIGNAL. */\n int sig = t->stop_sig();\n if (PerfCounters::TIME_SLICE_SIGNAL == sig) {\n continue;\n }\n // We should not receive SYSCALLBUF_DESCHED_SIGNAL since it should already\n // have been disarmed. However, we observe these being received here when\n // we arm the desched signal before we restart a blocking syscall, which\n // completes successfully, then we disarm, then we see a desched signal\n // here.\n if (t->session().syscallbuf_desched_sig() == sig) {\n continue;\n }\n if (sig && sig == old_sig) {\n LOG(debug) << \" coalescing pending \" << signal_name(sig);\n continue;\n }\n if (sig) {\n LOG(debug) << \" \" << signal_name(sig) << \" now pending\";\n t->stash_sig();\n }\n } while (!t->is_disarm_desched_event_syscall());\n\n // Exit the syscall. If this fails, that's fine, we can ignore it.\n t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS);\n}\n\n/**\n * |t| is at a desched event and some relevant aspect of its state\n * changed. (For now, changes except the original desched'd syscall\n * being restarted.)\n */\nvoid RecordSession::desched_state_changed(RecordTask* t) {\n LOG(debug) << \"desched: IN_SYSCALL\";\n /* We need to ensure that the syscallbuf code doesn't\n * try to commit the current record; we've already\n * recorded that syscall. The following event sets\n * the abort-commit bit. */\n t->write_mem(REMOTE_PTR_FIELD(t->syscallbuf_child, abort_commit), (uint8_t)1);\n t->record_event(Event::syscallbuf_abort_commit());\n\n advance_to_disarm_desched_syscall(t);\n\n t->pop_desched();\n\n /* The tracee has just finished sanity-checking the\n * aborted record, and won't touch the syscallbuf\n * during this (aborted) transaction again. So now\n * is a good time for us to reset the record counter. */\n t->delay_syscallbuf_reset_for_desched = false;\n // Run the syscallbuf exit hook. This ensures we'll be able to reset\n // the syscallbuf before trying to buffer another syscall.\n t->write_mem(\n REMOTE_PTR_FIELD(t->syscallbuf_child, notify_on_syscall_hook_exit),\n (uint8_t)1);\n}\n\nstatic void retry_syscall_patch(RecordTask* t, remote_code_ptr orig_syscall_ip)\n{\n bool should_retry = false;\n if (t->vm()->monkeypatcher().try_patch_syscall(t, false, should_retry, orig_syscall_ip)) {\n // Syscall was patched. Emit event and continue execution.\n LOG(debug) << \"Retried patch applied successfully\";\n auto ev = Event::patch_syscall();\n ev.PatchSyscall().patch_after_syscall = true;\n t->record_event(ev);\n }\n ASSERT(t, !should_retry);\n}\n\nstatic void syscall_not_restarted(RecordTask* t) {\n LOG(debug) << \" \" << t->tid << \": popping abandoned interrupted \" << t->ev()\n << \"; pending events:\";\n if (IS_LOGGING(debug)) {\n t->log_pending_events();\n }\n bool should_retry_patch = t->ev().Syscall().should_retry_patch;\n remote_code_ptr orig_syscall_ip = t->ev().Syscall().regs.ip();\n t->pop_syscall_interruption();\n if (should_retry_patch) {\n LOG(debug) << \"Retrying deferred syscall patching non-restarted syscall at \" << orig_syscall_ip << \" (current ip \" << t->regs().ip() << \")\";\n retry_syscall_patch(t, orig_syscall_ip);\n }\n}\n\n/**\n * \"Thaw\" a frozen interrupted syscall if |t| is restarting it.\n * Return true if a syscall is indeed restarted.\n *\n * A postcondition of this function is that |t->ev| is no longer a\n * syscall interruption, whether or whether not a syscall was\n * restarted.\n */\nstatic bool maybe_restart_syscall(RecordTask* t) {\n if (is_restart_syscall_syscall(t->regs().original_syscallno(), t->arch())) {\n LOG(debug) << \" \" << t->tid << \": SYS_restart_syscall'ing \" << t->ev();\n }\n if (t->is_syscall_restart()) {\n t->ev().transform(EV_SYSCALL);\n Registers regs = t->regs();\n regs.set_original_syscallno(t->ev().Syscall().regs.original_syscallno());\n t->set_regs(regs);\n t->canonicalize_regs(t->arch());\n return true;\n }\n if (EV_SYSCALL_INTERRUPTION == t->ev().type()) {\n syscall_not_restarted(t);\n }\n return false;\n}\n\n/**\n * After a SYS_sigreturn \"exit\" of task |t| with return value |ret|,\n * check to see if there's an interrupted syscall that /won't/ be\n * restarted, and if so, pop it off the pending event stack.\n */\nstatic void maybe_discard_syscall_interruption(RecordTask* t, intptr_t ret) {\n int syscallno;\n\n if (EV_SYSCALL_INTERRUPTION != t->ev().type()) {\n /* We currently don't track syscalls interrupted with\n * ERESTARTSYS or ERESTARTNOHAND, so it's possible for\n * a sigreturn not to affect the event stack. */\n LOG(debug) << \" (no interrupted syscall to retire)\";\n return;\n }\n\n syscallno = t->ev().Syscall().number;\n if (0 > ret) {\n syscall_not_restarted(t);\n } else if (t->arch() == x86 || t->arch() == x86_64) {\n SupportedArch arch;\n if (get_syscall_instruction_arch(t, t->regs().ip(), &arch) && arch == t->arch() &&\n (syscallno == ret || is_restart_syscall_syscall(ret, t->ev().Syscall().arch()))) {\n return;\n }\n syscall_not_restarted(t);\n }\n}\n\n/**\n * Copy the registers used for syscall arguments (not including\n * syscall number) from |from| to |to|.\n */\nstatic void copy_syscall_arg_regs(Registers* to, const Registers& from) {\n to->set_orig_arg1(from.arg1());\n to->set_arg2(from.arg2());\n to->set_arg3(from.arg3());\n to->set_arg4(from.arg4());\n to->set_arg5(from.arg5());\n to->set_arg6(from.arg6());\n}\n\nstatic void maybe_trigger_emulated_ptrace_syscall_exit_stop(RecordTask* t) {\n if (t->emulated_ptrace_cont_command == PTRACE_SYSCALL) {\n t->emulate_ptrace_stop(WaitStatus::for_syscall(t), SYSCALL_EXIT_STOP);\n } else if (is_ptrace_any_singlestep(t->arch(), t->emulated_ptrace_cont_command)) {\n // Deliver the singlestep trap now that we've finished executing the\n // syscall.\n t->emulate_ptrace_stop(WaitStatus::for_stop_sig(SIGTRAP), SIGNAL_DELIVERY_STOP, nullptr,\n SI_KERNEL);\n }\n}\n\nstatic void save_interrupted_syscall_ret_in_syscallbuf(RecordTask* t,\n intptr_t retval) {\n // Record storing the return value in the syscallbuf record, where\n // we expect to find it during replay.\n auto child_rec = t->next_syscallbuf_record();\n // Also store it there now so that our memory checksums are correct.\n // It will be overwritten by the tracee's syscallbuf code.\n t->write_and_record(REMOTE_PTR_FIELD(child_rec, ret),\n static_cast(retval));\n}\n\nstatic bool is_in_privileged_syscall(RecordTask* t) {\n auto type = AddressSpace::rr_page_syscall_from_exit_point(t->arch(), t->ip());\n return type && type->privileged == AddressSpace::PRIVILEGED;\n}\n\nvoid RecordSession::syscall_state_changed(RecordTask* t,\n StepState* step_state) {\n switch (t->ev().Syscall().state) {\n case ENTERING_SYSCALL_PTRACE:\n debug_exec_state(\"EXEC_SYSCALL_ENTRY_PTRACE\", t);\n step_state->continue_type = DONT_CONTINUE;\n last_task_switchable = ALLOW_SWITCH;\n if (t->emulated_stop_type != NOT_STOPPED) {\n // Don't go any further.\n return;\n }\n if (t->ev().Syscall().in_sysemu) {\n // We'll have recorded just the ENTERING_SYSCALL_PTRACE event and\n // nothing else. Resume with an invalid syscall to ensure no real\n // syscall runs.\n t->pop_syscall();\n Registers r = t->regs();\n Registers orig_regs = r;\n r.set_original_syscallno(-1);\n t->set_regs(r);\n // If this fails because of premature exit, don't mess with the\n // task anymore.\n if (t->resume_execution(RESUME_SYSCALL, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS)) {\n ASSERT(t, t->ip() == r.ip());\n t->set_regs(orig_regs);\n maybe_trigger_emulated_ptrace_syscall_exit_stop(t);\n }\n return;\n }\n last_task_switchable = PREVENT_SWITCH;\n t->ev().Syscall().regs = t->regs();\n t->ev().Syscall().state = ENTERING_SYSCALL;\n // The syscallno may have been changed by the ptracer\n t->ev().Syscall().number = t->regs().original_syscallno();\n return;\n\n case ENTERING_SYSCALL: {\n debug_exec_state(\"EXEC_SYSCALL_ENTRY\", t);\n ASSERT(t, !t->emulated_stop_pending);\n\n // Flush syscallbuf now so that anything recorded by\n // rec_prepare_syscall is associated with the syscall event\n t->maybe_flush_syscallbuf();\n\n last_task_switchable = t->ev().Syscall().switchable =\n rec_prepare_syscall(t);\n t->record_event(t->ev(), RecordTask::DONT_FLUSH_SYSCALLBUF,\n RecordTask::ALLOW_RESET_SYSCALLBUF,\n &t->ev().Syscall().regs);\n\n debug_exec_state(\"after cont\", t);\n t->ev().Syscall().state = PROCESSING_SYSCALL;\n\n if (t->emulated_stop_pending) {\n step_state->continue_type = DONT_CONTINUE;\n } else {\n // Resume the syscall execution in the kernel context.\n step_state->continue_type = CONTINUE_SYSCALL;\n }\n\n if (t->session().done_initial_exec() && Flags::get().check_cached_mmaps) {\n t->vm()->verify(t);\n }\n\n if (t->desched_rec() && t->is_in_untraced_syscall() &&\n t->has_stashed_sig()) {\n // We have a signal to deliver but we're about to (re?)enter an untraced\n // syscall that may block and the desched event has been disarmed.\n // Rearm the desched event so if the syscall blocks, it will be\n // interrupted and we'll have a chance to deliver our signal.\n LOG(debug) << \"Rearming desched event so we'll get a chance to deliver \"\n \"stashed signal\";\n arm_desched_event(t);\n }\n\n if (t->detached_proxy) {\n // We detached. Record that.\n t->session().trace_writer().write_task_event(\n TraceTaskEvent::for_detach(t->tid));\n t->record_event(Event::exit(), RecordTask::DONT_FLUSH_SYSCALLBUF,\n RecordTask::DONT_RESET_SYSCALLBUF);\n step_state->continue_type = DONT_CONTINUE;\n }\n\n return;\n }\n\n case PROCESSING_SYSCALL:\n debug_exec_state(\"EXEC_IN_SYSCALL\", t);\n\n // Linux kicks tasks out of syscalls before delivering\n // signals.\n ASSERT(t, !t->stop_sig()) << \"Signal \" << signal_name(t->stop_sig())\n << \" pending while in syscall???\";\n\n t->ev().Syscall().state = EXITING_SYSCALL;\n step_state->continue_type = DONT_CONTINUE;\n return;\n\n case EXITING_SYSCALL: {\n debug_exec_state(\"EXEC_SYSCALL_DONE\", t);\n\n DEBUG_ASSERT(t->stop_sig() == 0);\n\n SupportedArch syscall_arch = t->ev().Syscall().arch();\n int syscallno = t->ev().Syscall().number;\n intptr_t retval = t->regs().syscall_result_signed();\n\n if (t->desched_rec()) {\n // If we enabled the desched event above, disable it.\n disarm_desched_event(t);\n // Write syscall return value to the syscallbuf now. This lets replay\n // get the correct value even though we're aborting the commit. This\n // value affects register values in the preload code (which must be\n // correct since register values may escape).\n save_interrupted_syscall_ret_in_syscallbuf(t, retval);\n }\n\n // sigreturn is a special snowflake, because it\n // doesn't actually return. Instead, it undoes the\n // setup for signal delivery, which possibly includes\n // preparing the tracee for a restart-syscall. So we\n // take this opportunity to possibly pop an\n // interrupted-syscall event.\n if (is_sigreturn(syscallno, syscall_arch)) {\n if (is_x86ish(t->arch())) {\n ASSERT(t, t->regs().original_syscallno() == -1);\n }\n rec_did_sigreturn(t);\n t->record_current_event();\n t->pop_syscall();\n\n // We've finished processing this signal now.\n t->pop_signal_handler();\n t->invalidate_sigmask();\n\n maybe_discard_syscall_interruption(t, retval);\n\n if (EV_SECCOMP_TRAP == t->ev().type()) {\n LOG(debug) << \" exiting seccomp trap\";\n save_interrupted_syscall_ret_in_syscallbuf(t, retval);\n seccomp_trap_done(t);\n }\n if (EV_DESCHED == t->ev().type()) {\n LOG(debug) << \" exiting desched critical section\";\n // The signal handler could have modified the apparent syscall\n // return handler. Save that value into the syscall buf again so\n // replay will pick it up later.\n save_interrupted_syscall_ret_in_syscallbuf(t, retval);\n desched_state_changed(t);\n }\n } else {\n LOG(debug) << \" original_syscallno:\" << t->regs().original_syscallno()\n << \" (\" << syscall_name(syscallno, syscall_arch)\n << \"); return val:\" << HEX(t->regs().syscall_result());\n\n /* a syscall_restart ending is equivalent to the\n * restarted syscall ending */\n if (t->ev().Syscall().is_restart) {\n LOG(debug) << \" exiting restarted \"\n << syscall_name(syscallno, syscall_arch);\n }\n\n // Wait-like syscalls always check for notifications from waited-for processes\n // before they check for pending signals. So, if the tracee has a pending\n // notification that also generated a signal, the wait syscall returns\n // normally rather than returning with ERESTARTSYS etc. (The signal will\n // be dequeued and any handler run on the return to userspace, however.)\n bool return_normally_from_wait = rec_return_normally_from_wait(t);\n\n /* TODO: is there any reason a restart_syscall can't\n * be interrupted by a signal and itself restarted? */\n bool may_restart = !is_restart_syscall_syscall(syscallno, t->arch())\n // SYS_pause is either interrupted or\n // never returns. It doesn't restart.\n && !is_pause_syscall(syscallno, t->arch()) &&\n t->regs().syscall_may_restart() &&\n !return_normally_from_wait;\n /* no need to process the syscall in case its\n * restarted this will be done in the exit from the\n * restart_syscall */\n if (!may_restart) {\n rec_process_syscall(t);\n if (t->session().done_initial_exec() &&\n Flags::get().check_cached_mmaps) {\n t->vm()->verify(t);\n }\n } else {\n LOG(debug) << \" may restart \"\n << syscall_name(syscallno, syscall_arch)\n << \" (from retval \" << HEX(retval) << \")\";\n\n rec_prepare_restart_syscall(t);\n /* If we may restart this syscall, we've most\n * likely fudged some of the argument\n * registers with scratch pointers. We don't\n * want to record those fudged registers,\n * because scratch doesn't exist in replay.\n * So cover our tracks here. */\n Registers r = t->regs();\n copy_syscall_arg_regs(&r, t->ev().Syscall().regs);\n t->set_regs(r);\n // We need to track what the return value was on architectures\n // where the kernel replaces the return value by the new arg1\n // on restart.\n t->ev().Syscall().regs = r;\n }\n t->record_current_event();\n\n /* If we're not going to restart this syscall, we're\n * done with it. But if we are, \"freeze\" it on the\n * event stack until the execution point where it\n * might be restarted. */\n bool need_patch_retry = false;\n remote_code_ptr orig_syscall_ip;\n if (!may_restart) {\n need_patch_retry = t->ev().Syscall().should_retry_patch;\n if (need_patch_retry) {\n orig_syscall_ip = t->ev().Syscall().regs.ip();\n }\n t->pop_syscall();\n if (EV_DESCHED == t->ev().type()) {\n LOG(debug) << \" exiting desched critical section\";\n desched_state_changed(t);\n }\n } else {\n t->ev().transform(EV_SYSCALL_INTERRUPTION);\n t->ev().Syscall().is_restart = true;\n }\n\n t->canonicalize_regs(syscall_arch);\n\n if (need_patch_retry) {\n LOG(debug) << \"Retrying deferred syscall patching at \" << orig_syscall_ip << \" (current ip \" << t->regs().ip() << \")\";\n retry_syscall_patch(t, orig_syscall_ip);\n }\n }\n\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = DONT_CONTINUE;\n\n if (!is_in_privileged_syscall(t)) {\n maybe_trigger_emulated_ptrace_syscall_exit_stop(t);\n }\n return;\n }\n\n default:\n FATAL() << \"Unknown exec state \" << t->ev().Syscall().state;\n }\n}\n\n/** If the perf counters seem to be working return, otherwise don't return. */\nvoid RecordSession::check_initial_task_syscalls(RecordTask* t,\n RecordResult* step_result) {\n if (done_initial_exec()) {\n return;\n }\n\n if (is_write_syscall(t->ev().Syscall().number, t->arch()) &&\n t->regs().arg1_signed() == -1) {\n Ticks ticks = t->tick_count();\n LOG(debug) << \"ticks on entry to dummy write: \" << ticks;\n if (ticks == 0) {\n step_result->status = RecordSession::STEP_SPAWN_FAILED;\n step_result->failure_message = string(\n \"rr internal recorder error: Performance counter doesn't seem to \"\n \"be working. Are you perhaps running rr in a VM but didn't enable \"\n \"perf-counter virtualization?\");\n }\n }\n\n if (is_exit_group_syscall(t->ev().Syscall().number, t->arch())) {\n step_result->status = RecordSession::STEP_SPAWN_FAILED;\n step_result->failure_message = read_spawned_task_error();\n }\n}\n\nRecordTask* RecordSession::revive_task_for_exec(pid_t rec_tid) {\n unsigned long msg = 0;\n int ret =\n ptrace(_ptrace_request(PTRACE_GETEVENTMSG), rec_tid, nullptr, &msg);\n if (ret < 0) {\n FATAL() << \"Can't get old tid for execve (leader=\" << rec_tid << \")\";\n }\n RecordTask* t = find_task(msg);\n if (!t) {\n FATAL() << \"Can't find old task for execve\";\n }\n ASSERT(t, rec_tid == t->tgid());\n pid_t own_namespace_tid = t->thread_group()->tgid_own_namespace;\n\n LOG(debug) << \"Changing task tid from \" << t->tid << \" to \" << rec_tid;\n\n // Pretend the old task cloned a new task with the right tid, and then exited\n trace_writer().write_task_event(TraceTaskEvent::for_clone(\n rec_tid, t->tid, own_namespace_tid,\n CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD |\n CLONE_SYSVSEM));\n trace_writer().write_task_event(\n TraceTaskEvent::for_exit(t->tid, WaitStatus::for_exit_code(0)));\n\n // Account for tid change\n task_map.erase(t->tid);\n task_map.insert(make_pair(rec_tid, t));\n // Update the serial as if this task was really created by cloning the old\n // task.\n t->set_tid_and_update_serial(rec_tid, own_namespace_tid);\n\n return t;\n}\n\n/**\n * Take a NativeArch::siginfo_t& here instead of siginfo_t because different\n * versions of system headers have inconsistent field naming.\n */\ntemplate \nstatic void setup_sigframe_siginfo_arch(RecordTask* t,\n const siginfo_t& siginfo) {\n remote_ptr dest;\n switch (Arch::arch()) {\n case x86: {\n auto p = t->regs().sp().cast() + 2;\n dest = t->read_mem(p);\n break;\n }\n case x86_64:\n dest = t->regs().si();\n break;\n case aarch64:\n dest = t->regs().x(1);\n break;\n default:\n DEBUG_ASSERT(0 && \"Unknown architecture\");\n break;\n }\n typename Arch::siginfo_t si = t->read_mem(dest);\n set_arch_siginfo(siginfo, t->arch(), &si, sizeof(si));\n t->write_mem(dest, si);\n}\n\nstatic void setup_sigframe_siginfo(RecordTask* t, const siginfo_t& siginfo) {\n RR_ARCH_FUNCTION(setup_sigframe_siginfo_arch, t->arch(), t, siginfo);\n}\n\n/**\n * Get t into a state where resume_execution with a signal will actually work.\n */\nstatic bool preinject_signal(RecordTask* t) {\n int sig = t->ev().Signal().siginfo.si_signo;\n\n /* Signal injection is tricky. Per the ptrace(2) man page, injecting\n * a signal while the task is not in a signal-stop is not guaranteed to work\n * (and indeed, we see that the kernel sometimes ignores such signals).\n * But some signals must be delayed until after the signal-stop that notified\n * us of them.\n * So, first we check if we're in a signal-stop that we can use to inject\n * a signal.\n */\n if (t->in_injectable_signal_stop()) {\n LOG(debug) << \" in signal-stop for \" << signal_name(t->stop_sig());\n } else {\n /* We're not in a usable signal-stop. Force a signal-stop by sending\n * a new signal with tgkill (as the ptrace(2) man page recommends).\n */\n LOG(debug) << \" maybe not in signal-stop (status \" << t->status()\n << \"); doing tgkill(SYSCALLBUF_DESCHED_SIGNAL)\";\n if (!t->move_to_signal_stop()) {\n /* We raced with an exit (e.g. due to a pending SIGKILL). */\n return false;\n }\n\n ASSERT(t, t->stop_sig() == t->session().syscallbuf_desched_sig())\n << \"Expected SYSCALLBUF_DESCHED_SIGNAL, got \" << t->status();\n /* We're now in a signal-stop */\n }\n\n /* Now that we're in a signal-stop, we can inject our signal and advance\n * to the signal handler with one single-step.\n */\n LOG(debug) << \" injecting signal \" << signal_name(sig);\n t->set_siginfo(t->ev().Signal().siginfo);\n return true;\n}\n\n// More memory than we'll need for a sigframe\nstatic const size_t CONSERVATIVE_SIGFRAME_MEM = 0x10000;\n\n// We might need to extend a MAP_GROWSDOWN stack mapping to have\n// space for the sigframe. Do that now. We don't know how big\n// the sigframe is going to be, so we just try to ensure we have 64K\n// available. Should be harmless to allocate more than we strictly need.\n// If something's in the way we just allocate as much as we can.\nstatic void maybe_grow_stack_for_sigframe(RecordTask* t) {\n auto sp = t->regs().sp();\n AddressSpace& vm = *t->vm();\n if (!vm.has_mapping(sp)) {\n return;\n }\n AddressSpace::Mapping stack_mapping = vm.mapping_of(sp);\n remote_ptr desired_sp =\n max(remote_ptr(CONSERVATIVE_SIGFRAME_MEM + page_size()), sp) - CONSERVATIVE_SIGFRAME_MEM;\n if (desired_sp >= stack_mapping.map.start()) {\n // desired_sp is in the current stack map so we're good.\n return;\n }\n auto maps = vm.maps_containing_or_after(desired_sp - page_size());\n // The iterator must have the current stack map at least\n ASSERT(t, maps.begin() != maps.end());\n\n const AddressSpace::Mapping& m = *maps.begin();\n if (m.map.start() == stack_mapping.map.start()) {\n // No mapping is in the way.\n t->try_grow_map(desired_sp);\n return;\n }\n\n remote_ptr last_end;\n auto iter = maps.begin();\n while (true) {\n last_end = iter->map.end();\n ++iter;\n if (iter->map.start() == stack_mapping.map.start()) {\n break;\n }\n }\n if (last_end + page_size() >= stack_mapping.map.start()) {\n // Don't try to grow the stack if there's no room for a guard page.\n return;\n }\n t->try_grow_map(last_end + page_size());\n}\n\n/**\n * Returns true if the signal should be delivered.\n * Returns false if this signal should not be delivered because another signal\n * occurred during delivery or there was a premature exit.\n * Must call t->stashed_signal_processed() once we're ready to unmask signals.\n */\nstatic bool inject_handled_signal(RecordTask* t) {\n maybe_grow_stack_for_sigframe(t);\n\n if (!preinject_signal(t)) {\n // Task prematurely exited.\n return false;\n }\n // If there aren't any more stashed signals, it's OK to stop blocking all\n // signals.\n t->stashed_signal_processed();\n\n int sig = t->ev().Signal().siginfo.si_signo;\n int stop_sig;\n while (true) {\n // We are ready to inject our signal.\n // Ideally we would block signals here so only the signal we care about can be raised.\n // But that breaks all kinds of things because signal delivery itself can update\n // the sigmaks (e.g. via sa_mask). Emulating all that would be painful, so we\n // don't change the sigmask.\n if (!t->resume_execution(RESUME_SINGLESTEP, RESUME_WAIT_NO_EXIT, RESUME_NO_TICKS, sig)) {\n return false;\n }\n // We're expecting a kernel SIGTRAP from the singlestep, but we can also be notified\n // of other pending signals unfortunately :-(.\n stop_sig = t->stop_sig();\n ASSERT(t, stop_sig) << \"Only signal-stops should occur here\";\n if (t->get_siginfo().si_code > 0) {\n // Signal was generated by the kernel (i.e. not via kill() etc).\n // Signal injection can change the sigmask due to sa_mask effects, lack of\n // SA_NODEFER, and signal frame construction triggering a synchronous\n // SIGSEGV.\n t->invalidate_sigmask();\n // We should either have a SIGTRAP or possibly a SIGSEGV due to\n // sigframe construction overflowing the stack.\n break;\n }\n if (stop_sig == t->session().syscallbuf_desched_sig()) {\n // Repeat injection if we got a desched signal. We observe in Linux 4.14.12\n // that we get SYSCALLBUF_DESCHED_SIGNAL here once in a while.\n continue;\n }\n if (stop_sig == sig && sig < SIGRTMIN) {\n // Repeat injection if we got the same non-RT signal. We can coalesce\n // this with the current undelivered signal so there's no need to stash it.\n continue;\n }\n // Stash it for later processing and retry injecting our signal.\n t->stash_sig();\n }\n\n if (stop_sig == SIGSEGV) {\n // Constructing the signal handler frame must have failed. Stash the signal\n // to deliver it later.\n t->stash_sig();\n if (sig == SIGSEGV) {\n // The kernel will kill the process after this. Make sure we know to treat\n // it as fatal when we inject it. Also disable the signal handler to match\n // what the kernel does.\n t->did_set_sig_handler_default(SIGSEGV);\n t->thread_group()->received_sigframe_SIGSEGV = true;\n }\n return false;\n }\n\n // We stepped into a user signal handler.\n ASSERT(t, stop_sig == SIGTRAP)\n << \"Got unexpected status \" << t->status() << \" trying to deliver \"\n << signal_name(sig) << \" siginfo is \" << t->get_siginfo();\n ASSERT(t, t->get_signal_user_handler(sig) == t->ip())\n << \"Expected handler IP \" << t->get_signal_user_handler(sig) << \", got \"\n << t->ip()\n << \"; actual signal mask=\" << HEX(t->read_sigmask_from_process())\n << \" (cached \" << HEX(t->get_sigmask()) << \")\";\n\n if (t->signal_handler_takes_siginfo(sig)) {\n // The kernel copied siginfo into userspace so it can pass a pointer to\n // the signal handler. Replace the contents of that siginfo with\n // the exact data we want to deliver. (We called Task::set_siginfo\n // above to set that data, but the kernel sanitizes the passed-in data\n // which wipes out certain fields; e.g. we can't set SI_KERNEL in si_code.)\n setup_sigframe_siginfo(t, t->ev().Signal().siginfo);\n }\n\n // The kernel clears the FPU state on entering the signal handler, but prior\n // to 4.7 or thereabouts ptrace can still return stale values. Fix that here.\n // This also sets bit 0 of the XINUSE register to 1 to avoid issues where it\n // get set to 1 nondeterministically.\n if (auto e_ptr = t->extra_regs_fallible()) {\n ExtraRegisters e = *e_ptr;\n e.reset();\n t->set_extra_regs(e);\n }\n\n return true;\n}\n\n/**\n * |t| is being delivered a signal, and its state changed.\n * Must call t->stashed_signal_processed() once we're ready to unmask signals.\n */\nbool RecordSession::signal_state_changed(RecordTask* t, StepState* step_state) {\n int sig = t->ev().Signal().siginfo.si_signo;\n\n switch (t->ev().type()) {\n case EV_SIGNAL: {\n // This event is used by the replayer to advance to\n // the point of signal delivery.\n if (t->arch() == aarch64 && t->status().is_syscall() &&\n t->prev_ev() && t->prev_ev()->type() == EV_SYSCALL_INTERRUPTION) {\n // On aarch64, replaying expects the signal to be delivered before\n // the syscall instruction but the current pc during recording\n // is after the syscall instruction with the arg1 clobbered\n // with the return value (aborted syscall).\n auto regs = t->regs();\n auto &syscall_regs = t->prev_ev()->Syscall().regs;\n regs.set_ip(syscall_regs.ip().decrement_by_syscall_insn_length(t->arch()));\n regs.set_arg1(syscall_regs.orig_arg1());\n t->record_event(t->ev(), RecordTask::FLUSH_SYSCALLBUF,\n RecordTask::ALLOW_RESET_SYSCALLBUF, ®s);\n } else {\n t->record_current_event();\n }\n t->ev().transform(EV_SIGNAL_DELIVERY);\n ssize_t sigframe_size = 0;\n\n bool has_handler = t->signal_has_user_handler(sig);\n if (has_handler) {\n LOG(debug) << \" \" << t->tid << \": \" << signal_name(sig)\n << \" has user handler\";\n\n if (!inject_handled_signal(t)) {\n // Signal delivery isn't happening. Prepare to process the new\n // signal that aborted signal delivery.\n t->signal_delivered(sig);\n t->pop_signal_delivery();\n step_state->continue_type = DONT_CONTINUE;\n last_task_switchable = PREVENT_SWITCH;\n break;\n }\n\n if (is_x86ish(t->arch())) {\n // It's somewhat difficult engineering-wise to\n // compute the sigframe size at compile time,\n // and it can vary across kernel versions and CPU\n // microarchitectures. So this size is an overestimate\n // of the real size(s).\n //\n // If this size becomes too small in the\n // future, and unit tests that use sighandlers\n // are run with checksumming enabled, then\n // they can catch errors here.\n sigframe_size = 1152 /* Overestimate of kernel sigframe */ +\n 128 /* Redzone */ +\n /* this returns 512 when XSAVE unsupported */\n xsave_area_size();\n } else if (t->arch() == aarch64) {\n sigframe_size = sizeof(ARM64Arch::rt_sigframe);\n } else {\n DEBUG_ASSERT(0 && \"Add sigframe size for your architecture here\");\n }\n\n t->ev().transform(EV_SIGNAL_HANDLER);\n t->signal_delivered(sig);\n // We already continued! Don't continue now, and allow switching.\n step_state->continue_type = DONT_CONTINUE;\n last_task_switchable = ALLOW_SWITCH;\n } else {\n t->stashed_signal_processed();\n LOG(debug) << \" \" << t->tid << \": no user handler for \"\n << signal_name(sig);\n // Don't do another task continue. We want to deliver the signal\n // as the next thing that the task does.\n step_state->continue_type = DONT_CONTINUE;\n // If we didn't set up the sighandler frame, we need\n // to ensure that this tracee is scheduled next so\n // that we can deliver the signal normally. We have\n // to do that because setting up the sighandler frame\n // is synchronous, but delivery otherwise is async.\n // But right after this, we may have to process some\n // syscallbuf state, so we can't let the tracee race\n // with us.\n last_task_switchable = PREVENT_SWITCH;\n }\n\n // We record this data even if sigframe_size is zero to simplify replay.\n // Stop recording data if we run off the end of a writable mapping.\n // Our sigframe size is conservative so we need to do this.\n t->record_remote_writable(t->regs().sp(), sigframe_size,\n MemWriteSizeValidation::CONSERVATIVE);\n\n // This event is used by the replayer to set up the signal handler frame.\n // But if we don't have a handler, we don't want to record the event\n // until we deal with the EV_SIGNAL_DELIVERY.\n if (has_handler) {\n t->record_current_event();\n }\n break;\n }\n\n case EV_SIGNAL_DELIVERY: {\n // A SIGSTOP requires us to allow switching to another task.\n // So does a fatal, core-dumping signal, since we need to allow other\n // tasks to proceed to their exit events.\n bool is_deterministic = t->ev().Signal().deterministic == DETERMINISTIC_SIG;\n // Signals that would normally be fatal are just ignored for init processes,\n // unless they're deterministic.\n bool is_fatal = t->ev().Signal().disposition == DISPOSITION_FATAL &&\n (!t->is_container_init() || is_deterministic);\n Switchable can_switch =\n ((is_fatal && is_coredumping_signal(sig)) || t->is_sig_stopping(sig)) ?\n ALLOW_SWITCH : PREVENT_SWITCH;\n\n // We didn't record this event above, so do that now.\n // NB: If there is no handler, and we interrupted a syscall, and there are\n // no more actionable signals, the kernel sets us up for a syscall\n // restart. But it does that *after* the ptrace trap. To replay this\n // correctly we need to fake those changes here. But we don't do this\n // if we're going to switch away at the ptrace trap, and for the moment,\n // 'can_switch' is actually 'will_switch'.\n // This is essentially copied from do_signal in arch/x86/kernel/signal.c\n bool has_other_signals = t->has_any_actionable_signal();\n auto r = t->regs();\n if (!is_fatal) {\n Event *prev_ev = t->prev_ev();\n if (can_switch == PREVENT_SWITCH && !has_other_signals && prev_ev &&\n EV_SYSCALL_INTERRUPTION == prev_ev->type()) {\n switch (prev_ev->Syscall().regs.syscall_result_signed()) {\n case -ERESTARTNOHAND:\n case -ERESTARTSYS:\n case -ERESTARTNOINTR:\n r.set_syscallno(r.original_syscallno());\n break;\n case -ERESTART_RESTARTBLOCK:\n r.set_syscallno(syscall_number_for_restart_syscall(t->arch()));\n break;\n }\n // On aarch64, the kernel modifies the registers before the signal stop.\n // so we should not decrement the pc again or we'll rerun the instruction\n // before the syscall.\n // [1] https://github.com/torvalds/linux/blob/caffb99b6929f41a69edbb5aef3a359bf45f3315/arch/arm64/kernel/signal.c#L855-L862\n if (t->arch() != aarch64)\n r.set_ip(r.ip().decrement_by_syscall_insn_length(t->arch()));\n // Now that we've mucked with the registers, we can't switch tasks. That\n // could allow more signals to be generated, breaking our assumption\n // that we are the last signal.\n } else {\n // But if we didn't touch the registers switching here is ok.\n can_switch = ALLOW_SWITCH;\n }\n }\n\n t->record_event(t->ev(), RecordTask::FLUSH_SYSCALLBUF,\n RecordTask::ALLOW_RESET_SYSCALLBUF, &r);\n // Don't actually set_regs(r), the kernel does these modifications.\n\n if (t->is_container_init() && is_fatal) {\n // Nondeterministic signals were already filtered out.\n ASSERT(t, is_deterministic);\n // Usually, the kernel removes the killable-protection from an init process\n // when a deterministic fatal signal gets executed, but (due to what is\n // arguably a bug) when a ptracer is attached, this does not happen.\n // If we try to inject it here, the kernel will just ignore it,\n // and we'll go around again. As a hack, we detach here, in the\n // expectation that the deterministic instruction will run again and\n // actually kill the task now that it isn't under ptrace control anymore.\n t->destroy_buffers(nullptr, nullptr);\n WaitStatus exit_status = WaitStatus::for_fatal_sig(sig);\n t->record_exit_trace_event(exit_status);\n // Allow writing child_tid now because otherwise the write will race\n t->record_exit_event(RecordTask::WRITE_CHILD_TID);\n // On a real affected kernel, we probably would have never gotten here,\n // since the signal we would be seeing was not deterministic, but let's\n // be conservative and still try to emulate the ptrace stop.\n t->do_ptrace_exit_stop(exit_status);\n t->did_kill();\n t->detach();\n // Not really, but we detached, so we're never gonna see that event\n // anyway, so just pretend we're there already\n t->did_reach_zombie();\n return true;\n }\n\n // Only inject fatal signals. Non-fatal signals with signal handlers\n // were taken care of above; for non-fatal signals without signal\n // handlers, there is no need to deliver the signal at all. In fact,\n // there is really no way to inject a non-fatal, non-handled signal\n // without letting the task execute at least one instruction, which\n // we don't want to do here.\n bool inject_signal = is_fatal && sig != get_continue_through_sig();\n if (inject_signal) {\n preinject_signal(t);\n t->resume_execution(RESUME_CONT, RESUME_NONBLOCKING, RESUME_NO_TICKS,\n sig);\n }\n\n t->signal_delivered(sig);\n if (!inject_signal || !is_coredumping_signal(sig)) {\n /* Fatal signals may core-dump, so we don't consider the signal\n * delivery complete until we've actually managed to advance past that\n */\n t->pop_signal_delivery();\n }\n\n // Mark each task in this address space as expecting a ptrace exit\n // to avoid causing any ptrace_exit races.\n if (is_fatal && is_coredumping_signal(sig)) {\n for (Task *ot : t->vm()->task_set()) {\n if (t != ot) {\n if (t->tgid() == ot->tgid() || coredumping_signal_takes_down_entire_vm()) {\n ((RecordTask *)ot)->waiting_for_ptrace_exit = true;\n }\n }\n }\n }\n\n last_task_switchable = can_switch;\n step_state->continue_type = DONT_CONTINUE;\n break;\n }\n\n default:\n FATAL() << \"Unhandled signal state \" << t->ev().type();\n break;\n }\n return false;\n}\n\nbool RecordSession::handle_signal_event(RecordTask* t, StepState* step_state) {\n int sig = t->stop_sig();\n if (!sig) {\n return false;\n }\n if (!done_initial_exec()) {\n // If the initial tracee isn't prepared to handle\n // signals yet, then us ignoring the ptrace\n // notification here will have the side effect of\n // declining to deliver the signal.\n //\n // This doesn't really occur in practice, only in\n // tests that force a degenerately low time slice.\n LOG(warn) << \"Dropping \" << signal_name(sig)\n << \" because it can't be delivered yet\";\n // These signals might have effects on the sigmask.\n t->invalidate_sigmask();\n // No events to be recorded, so no syscallbuf updates\n // needed.\n return true;\n }\n\n if (sig == SIGTRAP && handle_syscallbuf_breakpoint(t)) {\n return true;\n }\n\n SignalDeterministic deterministic = is_deterministic_signal(t);\n // The kernel might have forcibly unblocked the signal. Check whether it\n // was blocked now, before we update our cached sigmask.\n SignalBlocked signal_was_blocked =\n t->is_sig_blocked(sig) ? SIG_BLOCKED : SIG_UNBLOCKED;\n if (deterministic || sig == t->session().syscallbuf_desched_sig()) {\n // Don't stash these signals; deliver them immediately.\n // We don't want them to be reordered around other signals.\n // invalidate_sigmask() must not be called before we reach handle_signal!\n siginfo_t siginfo = t->get_siginfo();\n switch (handle_signal(t, &siginfo, deterministic, signal_was_blocked)) {\n case SIGNAL_PTRACE_STOP:\n // Emulated ptrace-stop. Don't run the task again yet.\n last_task_switchable = ALLOW_SWITCH;\n step_state->continue_type = DONT_CONTINUE;\n return true;\n case DEFER_SIGNAL:\n ASSERT(t, false) << \"Can't defer deterministic or internal signal \"\n << siginfo << \" at ip \" << t->ip();\n break;\n case SIGNAL_HANDLED:\n if (t->ptrace_event() == PTRACE_EVENT_SECCOMP) {\n // `handle_desched_event` detected a spurious desched followed\n // by a SECCOMP event, which it left pending. Handle that SECCOMP\n // event now.\n bool dummy_did_enter_syscall;\n handle_ptrace_event(&t, step_state, nullptr,\n &dummy_did_enter_syscall);\n ASSERT(t, !dummy_did_enter_syscall);\n }\n if (t->ptrace_event() == PTRACE_EVENT_EXIT) {\n // Tracee was nuked (probably SIGKILL) during desched processing.\n return true;\n }\n break;\n }\n return false;\n }\n // Conservatively invalidate the sigmask in case just accepting a signal has\n // sigmask effects.\n t->invalidate_sigmask();\n if (sig == PerfCounters::TIME_SLICE_SIGNAL) {\n if (t->next_pmc_interrupt_is_for_user) {\n auto vpmc =\n VirtualPerfCounterMonitor::interrupting_virtual_pmc_for_task(t);\n ASSERT(t, vpmc);\n\n // Synthesize the requested signal.\n vpmc->synthesize_signal(t);\n\n t->next_pmc_interrupt_is_for_user = false;\n return true;\n }\n\n auto& si = t->get_siginfo();\n /* This implementation will of course fall over if rr tries to\n * record itself.\n *\n * NB: we can't check that the ticks is >= the programmed\n * target, because this signal may have become pending before\n * we reset the HPC counters. There be a way to handle that\n * more elegantly, but bridge will be crossed in due time.\n *\n * We can't check that the fd matches t->hpc.ticks_fd() because this\n * signal could have been queued quite a long time ago and the PerfCounters\n * might have been stopped (and restarted!), perhaps even more than once,\n * since the signal was queued. possibly changing its fd. We could check\n * against all fds the PerfCounters have ever used, but that seems like\n * overkill.\n */\n ASSERT(t,\n PerfCounters::TIME_SLICE_SIGNAL == si.si_signo &&\n (RecordTask::SYNTHETIC_TIME_SLICE_SI_CODE == si.si_code ||\n POLL_IN == si.si_code))\n << \"Tracee is using SIGSTKFLT??? (code=\" << si.si_code\n << \", fd=\" << si.si_fd << \")\";\n }\n t->stash_sig();\n return true;\n}\n\ntemplate \nstatic bool is_ptrace_any_sysemu_arch(int command) {\n return command >= 0 &&\n (command == Arch::PTRACE_SYSEMU ||\n command == Arch::PTRACE_SYSEMU_SINGLESTEP);\n}\n\nstatic bool is_ptrace_any_sysemu(SupportedArch arch, int command)\n{\n RR_ARCH_FUNCTION(is_ptrace_any_sysemu_arch, arch, command);\n}\n\nbool RecordSession::process_syscall_entry(RecordTask* t, StepState* step_state,\n RecordResult* step_result,\n SupportedArch syscall_arch) {\n if (const RecordTask::StashedSignal* sig = t->stashed_sig_not_synthetic_SIGCHLD()) {\n // The only four cases where we allow a stashed signal to be pending on\n // syscall entry are:\n // -- the signal is a ptrace-related signal, in which case if it's generated\n // during a blocking syscall, it does not interrupt the syscall\n // -- rrcall_notify_syscall_hook_exit, which is effectively a noop and\n // lets us dispatch signals afterward\n // -- when we're entering a blocking untraced syscall. If it really blocks,\n // we'll get the desched-signal notification and dispatch our stashed\n // signal.\n // -- when we're doing a privileged syscall that's internal to the preload\n // logic\n // We do not generally want to have stashed signals pending when we enter\n // a syscall, because that will execute with a hacked signal mask\n // (see RecordTask::will_resume_execution) which could make things go wrong.\n ASSERT(t,\n t->desched_rec() || is_rrcall_notify_syscall_hook_exit_syscall(\n t->regs().original_syscallno(), t->arch()) ||\n t->ip() ==\n t->vm()\n ->privileged_traced_syscall_ip()\n .increment_by_syscall_insn_length(t->arch()))\n << \"Stashed signal pending on syscall entry when it shouldn't be: \"\n << sig->siginfo << \"; regs=\" << t->regs()\n << \"; last_execution_resume=\" << t->last_execution_resume()\n << \"; sig ip=\" << sig->ip;\n }\n\n // We just entered a syscall.\n if (!maybe_restart_syscall(t)) {\n if (syscall_seccomp_ordering_ == PTRACE_SYSCALL_BEFORE_SECCOMP_UNKNOWN &&\n t->seccomp_bpf_enabled) {\n // We received a PTRACE_SYSCALL notification before the seccomp\n // notification. Ignore it and continue to the seccomp notification.\n syscall_seccomp_ordering_ = PTRACE_SYSCALL_BEFORE_SECCOMP;\n step_state->continue_type = CONTINUE;\n return true;\n }\n\n // Don't ever patch a sigreturn syscall. These can't go through the syscallbuf.\n bool should_retry = false;\n if (!is_sigreturn(t->regs().original_syscallno(), t->arch())) {\n if (t->vm()->monkeypatcher().try_patch_syscall(t, true, should_retry)) {\n // Syscall was patched. Emit event and continue execution.\n t->record_event(Event::patch_syscall());\n return true;\n }\n if (!t->is_stopped()) {\n // task exited while we were trying to patch it.\n // Make sure that this exit event gets processed\n step_state->continue_type = DONT_CONTINUE;\n return false;\n }\n }\n\n t->push_event(SyscallEvent(t->regs().original_syscallno(), syscall_arch));\n t->ev().Syscall().should_retry_patch = should_retry;\n }\n\n check_initial_task_syscalls(t, step_result);\n note_entering_syscall(t);\n if ((t->emulated_ptrace_cont_command == PTRACE_SYSCALL ||\n is_ptrace_any_sysemu(t->arch(),\n t->emulated_ptrace_cont_command)) &&\n !is_in_privileged_syscall(t)) {\n t->ev().Syscall().state = ENTERING_SYSCALL_PTRACE;\n t->emulate_ptrace_stop(WaitStatus::for_syscall(t), SYSCALL_ENTRY_STOP);\n t->record_current_event();\n\n t->ev().Syscall().in_sysemu = is_ptrace_any_sysemu(t->arch(),\n t->emulated_ptrace_cont_command);\n }\n return true;\n}\n\n/**\n * The execution of |t| has just been resumed, and it most likely has\n * a new event that needs to be processed. Prepare that new event.\n * Returns false if the task exits during processing\n */\nvoid RecordSession::runnable_state_changed(RecordTask* t, StepState* step_state,\n RecordResult* step_result,\n bool can_consume_wait_status) {\n switch (t->ev().type()) {\n case EV_NOOP:\n t->pop_noop();\n return;\n case EV_INSTRUCTION_TRAP:\n t->record_current_event();\n t->pop_event(t->ev().type());\n return;\n case EV_SENTINEL:\n case EV_SIGNAL_HANDLER:\n case EV_SYSCALL_INTERRUPTION: {\n if (!can_consume_wait_status) {\n return;\n }\n\n SupportedArch syscall_arch = t->detect_syscall_arch();\n t->canonicalize_regs(syscall_arch);\n t->apply_syscall_entry_regs();\n process_syscall_entry(t, step_state, step_result, syscall_arch);\n return;\n }\n\n default:\n return;\n }\n}\n\nbool RecordSession::prepare_to_inject_signal(RecordTask* t,\n StepState* step_state) {\n if (!done_initial_exec() || step_state->continue_type != CONTINUE) {\n return false;\n }\n\n union {\n NativeArch::siginfo_t native_api;\n siginfo_t linux_api;\n } si;\n const RecordTask::StashedSignal* sig;\n\n while (true) {\n sig = t->peek_stashed_sig_to_deliver();\n if (!sig) {\n return false;\n }\n si.linux_api = sig->siginfo;\n if (si.linux_api.si_signo == get_ignore_sig()) {\n LOG(debug) << \"Declining to deliver \"\n << signal_name(si.linux_api.si_signo) << \" by user request\";\n t->pop_stash_sig(sig);\n t->stashed_signal_processed();\n } else {\n break;\n }\n }\n\n if (sig->deterministic == DETERMINISTIC_SIG &&\n sig->siginfo.si_signo == SIGSYS &&\n t->is_sig_blocked(sig->siginfo.si_signo) == SIG_BLOCKED) {\n // Our synthesized deterministic SIGSYS (seccomp trap) needs to match the\n // kernel behavior of unblocking the signal and resetting disposition to\n // default.\n t->unblock_signal(SIGSYS);\n t->set_sig_handler_default(SIGSYS);\n }\n switch (handle_signal(t, &si.linux_api, sig->deterministic, SIG_UNBLOCKED)) {\n case SIGNAL_PTRACE_STOP:\n // Emulated ptrace-stop. Don't run the task again yet.\n last_task_switchable = ALLOW_SWITCH;\n LOG(debug) << signal_name(si.linux_api.si_signo)\n << \", emulating ptrace stop\";\n break;\n case DEFER_SIGNAL:\n LOG(debug) << signal_name(si.linux_api.si_signo) << \" deferred\";\n // Leave signal on the stack and continue task execution. We'll try again\n // later.\n return false;\n case SIGNAL_HANDLED:\n LOG(debug) << signal_name(si.linux_api.si_signo) << \" handled\";\n // Signal is now a pending event on |t|'s event stack\n\n if (t->ev().type() == EV_SCHED) {\n if (t->maybe_in_spinlock()) {\n LOG(debug) << \"Detected possible spinlock, forcing one round-robin\";\n scheduler().schedule_one_round_robin(t);\n }\n // Allow switching after a SCHED. We'll flush the SCHED if and only\n // if we really do a switch.\n last_task_switchable = ALLOW_SWITCH;\n }\n break;\n }\n step_state->continue_type = DONT_CONTINUE;\n t->pop_stash_sig(sig);\n if (t->ev().type() != EV_SIGNAL) {\n t->stashed_signal_processed();\n }\n return true;\n}\n\nstatic void inject_ld_helper_library(vector& env,\n string env_var,\n string value) {\n // Our preload lib should come first if possible, because that will speed up\n // the loading of the other libraries; it's also a good idea to put our audit\n // library at the head of the list, since there's only sixteen possible link\n // namespaces on glibc and each audit library uses up one.\n //\n // We supply a placeholder which is then mutated to the correct filename in\n // Monkeypatcher::patch_after_exec.\n auto env_assignment = env_var + \"=\";\n auto it = env.begin();\n for (; it != env.end(); ++it) {\n if (it->find(env_assignment) != 0) {\n continue;\n }\n // Honor old preloads too. This may cause\n // problems, but only in those libs, and\n // that's the user's problem.\n value += \":\";\n value += it->substr(it->find(\"=\") + 1);\n break;\n }\n value = env_assignment + value;\n if (it == env.end()) {\n env.push_back(value);\n } else {\n *it = value;\n }\n}\n\nvoid strip_outer_ld_preload(vector& env) {\n auto env_assignment = \"LD_PRELOAD=\";\n auto it = env.begin();\n for (; it != env.end(); ++it) {\n if (it->find(env_assignment) != 0) {\n continue;\n }\n size_t colon_pos = it->find(\":\");\n if (colon_pos != string::npos) {\n // If the preload library is loaded at all, it must be first\n size_t preload_pos = it->find(\"librrpreload\");\n if (preload_pos < colon_pos) {\n string new_ld_preload = it->substr(++colon_pos);\n *it = env_assignment + new_ld_preload;\n return;\n } else {\n DEBUG_ASSERT(preload_pos == string::npos);\n }\n }\n }\n}\n\nstatic const MemoryRange asan_shadow(remote_ptr((uintptr_t)0x00007fff7000LL),\n remote_ptr((uintptr_t)0x10007fff8000LL));\nstatic const MemoryRange asan_allocator_reserved(remote_ptr((uintptr_t)0x600000000000LL),\n remote_ptr((uintptr_t)0x640000002000LL));\n// See https://github.com/llvm/llvm-project/commit/fb77ca05ffb4f8e666878f2f6718a9fb4d686839\n// and https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/asan/asan_allocator.h\nstatic const MemoryRange asan_allocator_reserved2(remote_ptr((uintptr_t)0x500000000000LL),\n remote_ptr((uintptr_t)0x540000000000LL));\n\n// See https://github.com/llvm/llvm-project/blob/main/compiler-rt/lib/tsan/rtl/tsan_platform_posix.cpp\nstatic const MemoryRange tsan_shadow(remote_ptr((uintptr_t)0x008000000000LL),\n remote_ptr((uintptr_t)0x550000000000LL));\n// The memory area 0x7b0000000000-0x7c0000002000 is reserved for TSAN's\n// custom heap allocator --- applications end up using it, but *we* can't use\n// it.\nstatic const MemoryRange tsan_exclude(remote_ptr((uintptr_t)0x568000000000LL),\n remote_ptr((uintptr_t)0x7e8000000000LL));\n// It's only 1TB because tsan can't fit more\nstatic const MemoryRange tsan_fixed_global_exclusion_range(remote_ptr((uintptr_t)0x7e8000000000LL),\n remote_ptr((uintptr_t)0x7f8000000000LL));\n\nstruct ExeInfo {\n ExeInfo() : arch(NativeArch::arch()) {}\n SupportedArch arch;\n // Empty if anything fails\n string sanitizer_path;\n vector sanitizer_exclude_memory_ranges;\n // If non-empty, use this as the global exclusion range.\n MemoryRange fixed_global_exclusion_range;\n\n void setup_asan_memory_ranges() {\n if (!check_sanitizer_arch()) {\n return;\n }\n sanitizer_exclude_memory_ranges.push_back(asan_shadow);\n sanitizer_exclude_memory_ranges.push_back(asan_allocator_reserved);\n sanitizer_exclude_memory_ranges.push_back(asan_allocator_reserved2);\n }\n void setup_tsan_memory_ranges() {\n if (!check_sanitizer_arch()) {\n return;\n }\n sanitizer_exclude_memory_ranges.push_back(tsan_shadow);\n sanitizer_exclude_memory_ranges.push_back(tsan_exclude);\n fixed_global_exclusion_range = tsan_fixed_global_exclusion_range;\n }\nprivate:\n bool check_sanitizer_arch() {\n switch (arch) {\n case x86_64:\n return true;\n default:\n // We have no idea what's going on. Disable mmap randomization if\n // chaos mode is active.\n sanitizer_exclude_memory_ranges.push_back(MemoryRange::all());\n return false;\n }\n }\n};\n\nstatic ExeInfo read_exe_info(const string& exe_file) {\n ExeInfo ret;\n ScopedFd fd(exe_file.c_str(), O_RDONLY);\n if (!fd.is_open()) {\n return ret;\n }\n ElfFileReader reader(fd);\n ret.arch = reader.arch();\n\n DynamicSection dynamic = reader.read_dynamic();\n for (auto& entry : dynamic.entries) {\n if (entry.tag == DT_NEEDED && entry.val < dynamic.strtab.size()) {\n const char* name = &dynamic.strtab[entry.val];\n if (!strncmp(name, \"libasan\", 7)) {\n ret.sanitizer_path = string(name);\n ret.setup_asan_memory_ranges();\n } else if (!strncmp(name, \"libtsan\", 7)) {\n ret.sanitizer_path = string(name);\n ret.setup_tsan_memory_ranges();\n }\n }\n }\n\n auto syms = reader.read_symbols(\".dynsym\", \".dynstr\");\n for (size_t i = 0; i < syms.size(); ++i) {\n if (syms.is_name(i, \"__asan_init\")) {\n ret.setup_asan_memory_ranges();\n } else if (syms.is_name(i, \"__tsan_init\")) {\n ret.setup_tsan_memory_ranges();\n }\n }\n\n return ret;\n}\n\nstatic string lookup_by_path(const string& name) {\n if (name.find('/') != string::npos) {\n return name;\n }\n const char* env = getenv(\"PATH\");\n if (!env) {\n return name;\n }\n char* p = strdup(env);\n char* s = p;\n while (*s) {\n char* next = strchr(s, ':');\n if (next) {\n *next = 0;\n }\n string file = string(s) + \"/\" + name;\n struct stat st;\n if (!stat(file.c_str(), &st) && S_ISREG(st.st_mode) &&\n !access(file.c_str(), X_OK)) {\n free(p);\n return file;\n }\n if (!next) {\n break;\n }\n s = next + 1;\n }\n free(p);\n return name;\n}\n\n/*static*/ RecordSession::shr_ptr RecordSession::create(\n const vector& argv, const vector& extra_env,\n const DisableCPUIDFeatures& disable_cpuid_features,\n SyscallBuffering syscallbuf,\n unsigned char syscallbuf_desched_sig,\n BindCPU bind_cpu,\n const string& output_trace_dir,\n const TraceUuid* trace_id,\n bool use_audit,\n bool unmap_vdso,\n bool force_asan_active,\n bool force_tsan_active,\n bool intel_pt,\n bool check_outside_mmaps,\n bool no_preload) {\n TraceeAttentionSet::initialize();\n\n // The syscallbuf library interposes some critical\n // external symbols like XShmQueryExtension(), so we\n // preload it whether or not syscallbuf is enabled. Indicate here whether\n // syscallbuf is enabled.\n if (syscallbuf == DISABLE_SYSCALL_BUF) {\n unsetenv(SYSCALLBUF_ENABLED_ENV_VAR);\n } else {\n setenv(SYSCALLBUF_ENABLED_ENV_VAR, \"1\", 1);\n }\n\n vector env = current_env();\n\n // Have extra_env override anything already in the environment\n for (string extra : extra_env) {\n string extra_var = extra.substr(0, extra.find('='));\n auto it = env.begin();\n for (; it != env.end(); ++it) {\n if (it->find(extra_var) != 0) {\n continue;\n }\n it = env.erase(it);\n break;\n }\n }\n env.insert(env.end(), extra_env.begin(), extra_env.end());\n\n string full_path = lookup_by_path(argv[0]);\n struct stat st;\n if (stat(full_path.c_str(), &st) == 0 && S_ISDIR(st.st_mode)) {\n CLEAN_FATAL() << \"Provided tracee '\" << argv[0] << \"' is a directory, not an executable\";\n }\n ExeInfo exe_info = read_exe_info(full_path);\n if (exe_info.sanitizer_exclude_memory_ranges.empty()) {\n if (force_asan_active) {\n exe_info.setup_asan_memory_ranges();\n } else if (force_tsan_active) {\n exe_info.setup_tsan_memory_ranges();\n }\n }\n\n // Strip any LD_PRELOAD that an outer rr may have inserted\n strip_outer_ld_preload(env);\n\n // LD_PRELOAD the syscall interception lib\n string syscall_buffer_lib_path = find_helper_library(SYSCALLBUF_LIB_FILENAME);\n if (!no_preload && !syscall_buffer_lib_path.empty()) {\n string ld_preload = \"\";\n if (!exe_info.sanitizer_path.empty()) {\n LOG(debug) << \"Prepending \" << exe_info.sanitizer_path << \" to LD_PRELOAD\";\n // Put an LD_PRELOAD entry for it before our preload library, because\n // it checks that it's loaded first\n ld_preload += exe_info.sanitizer_path + \":\";\n }\n ld_preload += syscall_buffer_lib_path + SYSCALLBUF_LIB_FILENAME_PADDED;\n#ifndef __BIONIC__\n // When librrpreload is built against glibc 2.34 but runs in a process linking pre-2.34 glibc,\n // its call to dlsym needs to search libdl before libc. When librrpreload found dlsym\n // in libc at link time, pre-2.34 ld.so throws a fatal error if it searches for dlsym in libc and\n // can't find it.\n ld_preload += \":libdl.so.2\";\n#endif\n inject_ld_helper_library(env, \"LD_PRELOAD\", ld_preload);\n }\n\n if (use_audit) {\n string rtld_audit_lib_path = find_helper_library(RTLDAUDIT_LIB_FILENAME);\n if (!rtld_audit_lib_path.empty()) {\n string ld_audit = rtld_audit_lib_path + RTLDAUDIT_LIB_FILENAME_PADDED;\n inject_ld_helper_library(env, \"LD_AUDIT\", ld_audit);\n }\n }\n\n env.push_back(\"RUNNING_UNDER_RR=1\");\n // Stop Mesa using the GPU\n env.push_back(\"LIBGL_ALWAYS_SOFTWARE=1\");\n env.push_back(\"GBM_ALWAYS_SOFTWARE=1\");\n env.push_back(\"SDL_RENDER_DRIVER=software\");\n // Stop sssd from using shared-memory with its daemon\n env.push_back(\"SSS_NSS_USE_MEMCACHE=NO\");\n\n // Disable Gecko's \"wait for gdb to attach on process crash\" behavior, since\n // it is useless when running under rr.\n env.push_back(\"MOZ_GDB_SLEEP=0\");\n\n // Avoid GVFS using separate processes that might run\n // outside the recording but share memory mapped files.\n env.push_back(\"GIO_USE_VFS=local\");\n\n // If we have CPUID faulting, don't use these environment hacks. We don't\n // need them and the user might want to use them themselves for other reasons.\n if (!Session::has_cpuid_faulting()) {\n // OpenSSL uses RDRAND, but we can disable it. These bitmasks are inverted\n // and ANDed with the results of CPUID. The number below is 2^62, which is the\n // bit for RDRAND support.\n env.push_back(\"OPENSSL_ia32cap=~4611686018427387904:0\");\n // Disable Qt's use of RDRAND/RDSEED/RTM\n env.push_back(\"QT_NO_CPU_FEATURE=rdrnd rdseed rtm\");\n // Disable systemd's use of RDRAND\n env.push_back(\"SYSTEMD_RDRAND=0\");\n }\n\n shr_ptr session(\n new RecordSession(full_path, argv, env, disable_cpuid_features,\n syscallbuf, syscallbuf_desched_sig, bind_cpu,\n output_trace_dir, trace_id, use_audit, unmap_vdso,\n intel_pt, check_outside_mmaps));\n session->excluded_ranges_ = std::move(exe_info.sanitizer_exclude_memory_ranges);\n session->fixed_global_exclusion_range_ = std::move(exe_info.fixed_global_exclusion_range);\n return session;\n}\n\nRecordSession::RecordSession(const std::string& exe_path,\n const std::vector& argv,\n const std::vector& envp,\n const DisableCPUIDFeatures& disable_cpuid_features,\n SyscallBuffering syscallbuf,\n int syscallbuf_desched_sig,\n BindCPU bind_cpu,\n const string& output_trace_dir,\n const TraceUuid* trace_id,\n bool use_audit,\n bool unmap_vdso,\n bool intel_pt_enabled,\n bool check_outside_mmaps)\n : trace_out(argv[0], output_trace_dir, ticks_semantics_),\n scheduler_(*this),\n trace_id(trace_id),\n disable_cpuid_features_(disable_cpuid_features),\n ignore_sig(0),\n continue_through_sig(0),\n last_task_switchable(PREVENT_SWITCH),\n syscall_buffer_size_(1024 * 1024),\n syscallbuf_desched_sig_(syscallbuf_desched_sig),\n use_syscall_buffer_(syscallbuf == ENABLE_SYSCALL_BUF),\n use_file_cloning_(true),\n use_read_cloning_(true),\n enable_chaos_(false),\n wait_for_all_(false),\n use_audit_(use_audit),\n unmap_vdso_(unmap_vdso),\n check_outside_mmaps_(check_outside_mmaps) {\n set_intel_pt_enabled(intel_pt_enabled);\n if (intel_pt_enabled) {\n PerfCounters::start_pt_copy_thread();\n }\n\n if (!has_cpuid_faulting() &&\n disable_cpuid_features.any_features_disabled()) {\n FATAL() << \"CPUID faulting required to disable CPUID features\";\n }\n\n if (rr::syscall_number_for_rrcall_init_preload(x86_64) != RR_CALL_BASE) {\n FATAL() << \"RR_CALL_BASE is incorrect\";\n }\n\n trace_out.set_bound_cpu(choose_cpu(bind_cpu, cpu_lock));\n do_bind_cpu();\n ScopedFd error_fd = create_spawn_task_error_pipe();\n RecordTask* t = static_cast(\n Task::spawn(*this, error_fd, &tracee_socket_fd(),\n &tracee_socket_receiver_fd(),\n &tracee_socket_fd_number,\n exe_path, argv, envp));\n\n if (NativeArch::is_x86ish()) {\n // CPU affinity has been set.\n trace_out.setup_cpuid_records(has_cpuid_faulting(), disable_cpuid_features_);\n if (cpu_has_xsave_fip_fdp_quirk()) {\n trace_out.set_xsave_fip_fdp_quirk(true);\n // Clear FIP/FDP on every event to reduce the probability of this quirk\n // causing divergence, especially when porting traces to Intel machines\n trace_out.set_clear_fip_fdp(true);\n }\n if (cpu_has_fdp_exception_only_quirk()) {\n trace_out.set_fdp_exception_only_quirk(true);\n }\n }\n\n initial_thread_group = t->thread_group();\n on_create(t);\n}\n\nRecordSession::~RecordSession() {\n // Do this now while we're still a RecordSession. When Session's\n // destructor calls kill_all_tasks(), things turn bad.\n kill_all_tasks();\n}\n\nRecordSession::RecordResult RecordSession::record_step() {\n RecordResult result;\n\n if (task_map.empty()) {\n result.status = STEP_EXITED;\n result.exit_status = initial_thread_group->exit_status;\n return result;\n }\n\n if (!wait_for_all_ && initial_thread_group->task_set().empty()) {\n // SIGKILL any tasks we haven't already killed.\n terminate_tracees();\n }\n\n result.status = STEP_CONTINUE;\n\n TaskUid prev_task_tuid;\n if (scheduler().current()) {\n prev_task_tuid = scheduler().current()->tuid();\n }\n auto rescheduled = scheduler().reschedule(last_task_switchable);\n if (rescheduled.interrupted_by_signal) {\n // The scheduler was waiting for some task to become active, but was\n // interrupted by a signal. Yield to our caller now to give the caller\n // a chance to do something triggered by the signal\n // (e.g. terminate the recording).\n return result;\n }\n RecordTask* t = scheduler().current();\n if (!t) {\n // No child to schedule. Yield to our caller to give it a chance\n // to do something (e.g. terminate the recording).\n return result;\n }\n // If the task has been reaped prematurely then it's not running\n // and we can't get registers etc, so minimize what we do between here\n // to handle_ptrace_exit_event().\n if (t->waiting_for_reap) {\n // Give it another chance to be reaped\n t->did_reach_zombie();\n return result;\n }\n RecordTask* prev_task = find_task(prev_task_tuid);\n if (prev_task && prev_task->ev().type() == EV_SCHED) {\n if (prev_task != t) {\n // We did do a context switch, so record the SCHED event. Otherwise\n // we'll just discard it.\n prev_task->record_current_event();\n }\n prev_task->pop_event(EV_SCHED);\n }\n if (t->tuid() != prev_task_tuid) {\n t->will_schedule();\n }\n\n // Have to disable context-switching until we know it's safe\n // to allow switching the context.\n last_task_switchable = PREVENT_SWITCH;\n\n LOG(debug) << \"trace time \" << t->trace_time() << \": Active task is \"\n << t->tid << \". Events:\";\n if (IS_LOGGING(debug)) {\n t->log_pending_events();\n }\n\n if (handle_ptrace_exit_event(t)) {\n // t may have been deleted.\n last_task_switchable = ALLOW_SWITCH;\n return result;\n }\n\n if (rescheduled.started_new_timeslice) {\n t->registers_at_start_of_last_timeslice = t->regs();\n t->time_at_start_of_last_timeslice = trace_writer().time();\n }\n\n StepState step_state(CONTINUE);\n\n ASSERT(t, t->is_stopped()) << \"Somehow we're not stopped here; status=\"\n << t->status();\n bool did_enter_syscall;\n if (rescheduled.by_waitpid &&\n handle_ptrace_event(&t, &step_state, &result, &did_enter_syscall)) {\n if (step_state.continue_type == DONT_CONTINUE) {\n return result;\n }\n if (result.status != STEP_CONTINUE) {\n last_task_switchable = ALLOW_SWITCH;\n return result;\n }\n\n if (did_enter_syscall && t->ev().type() == EV_SYSCALL) {\n syscall_state_changed(t, &step_state);\n }\n } else {\n ASSERT(t, t->is_stopped()) << \"handle_ptrace_event left us in a not-stopped state\";\n if (rescheduled.by_waitpid && handle_signal_event(t, &step_state)) {\n // Tracee may have exited while processing descheds; handle that.\n if (handle_ptrace_exit_event(t)) {\n // t may have been deleted.\n last_task_switchable = ALLOW_SWITCH;\n return result;\n }\n } else {\n ASSERT(t, t->is_stopped()) << \"handle_signal_event left us in a not-stopped state\";\n runnable_state_changed(t, &step_state, &result, rescheduled.by_waitpid);\n\n if (result.status != STEP_CONTINUE ||\n step_state.continue_type == DONT_CONTINUE) {\n return result;\n }\n\n switch (t->ev().type()) {\n case EV_DESCHED:\n desched_state_changed(t);\n break;\n case EV_SYSCALL:\n syscall_state_changed(t, &step_state);\n break;\n case EV_SIGNAL:\n case EV_SIGNAL_DELIVERY:\n if (signal_state_changed(t, &step_state)) {\n // t may have been deleted\n return result;\n }\n break;\n default:\n break;\n }\n }\n }\n\n t->verify_signal_states();\n t->unmap_dead_syscallbufs_if_required();\n\n // We try to inject a signal if there's one pending; otherwise we continue\n // task execution.\n if (!prepare_to_inject_signal(t, &step_state) &&\n step_state.continue_type != DONT_CONTINUE) {\n // Ensure that we aren't allowing switches away from a running task.\n // Only tasks blocked in a syscall can be switched away from, otherwise\n // we have races.\n ASSERT(t,\n last_task_switchable == PREVENT_SWITCH ||\n t->may_be_blocked());\n\n debug_exec_state(\"EXEC_START\", t);\n\n task_continue(step_state);\n }\n\n return result;\n}\n\nvoid RecordSession::terminate_tracees() {\n for (auto& v : task_map) {\n RecordTask* t = static_cast(v.second);\n if (!t->detached_proxy && !t->sent_shutdown_kill) {\n LOG(debug) << \"Terminating tracee \" << t->tid;\n ::kill(t->rec_tid, SIGKILL);\n t->sent_shutdown_kill = true;\n t->emulate_SIGCONT();\n }\n }\n}\n\nvoid RecordSession::forward_SIGTERM() {\n if (!initial_thread_group->task_set().empty()) {\n kill(initial_thread_group->tgid, SIGTERM);\n }\n}\n\nvoid RecordSession::term_detached_tasks() {\n // Send SIGTERM to all detached child tasks first, so they may clean up\n // in parallel.\n for (auto& v : task_map) {\n RecordTask* t = static_cast(v.second);\n if (!t->detached_proxy) {\n continue;\n }\n ::kill(t->rec_tid, SIGTERM);\n }\n for (auto it = task_map.begin(); it != task_map.end(); ) {\n RecordTask* t = static_cast(it->second);\n if (!t->detached_proxy) {\n ++it;\n continue;\n }\n WaitResult result = WaitManager::wait_exit(WaitOptions(t->rec_tid));\n if (result.code != WAIT_OK) {\n LOG(warn) << \"Wait failed\";\n } else if (result.status.type() != WaitStatus::EXIT) {\n LOG(warn) << \"Unexpected wait status \" << result.status <<\n \" while waiting for detached child \" << t->rec_tid;\n }\n ++it;\n delete t;\n }\n}\n\nvoid RecordSession::close_trace_writer(TraceWriter::CloseStatus status) {\n trace_out.close(status, trace_id.get());\n}\n\nTask* RecordSession::new_task(pid_t tid, pid_t, uint32_t serial,\n SupportedArch a, const std::string&) {\n return new RecordTask(*this, tid, serial, a);\n}\n\nvoid RecordSession::on_create(Task* t) {\n Session::on_create(t);\n scheduler().on_create(static_cast(t));\n}\n\nRecordTask* RecordSession::find_task(pid_t rec_tid) const {\n return static_cast(Session::find_task(rec_tid));\n}\n\nRecordTask* RecordSession::find_task(const TaskUid& tuid) const {\n return static_cast(Session::find_task(tuid));\n}\n\nRecordTask* RecordSession::find_detached_proxy_task(pid_t proxy_tid) const {\n auto it = detached_task_map.find(proxy_tid);\n return detached_task_map.end() != it ? it->second : nullptr;\n}\n\nvoid RecordSession::on_proxy_detach(RecordTask *t, pid_t new_tid) {\n Session::on_destroy(t);\n task_map[new_tid] = t;\n detached_task_map[t->tid] = t;\n}\n\nvoid RecordSession::on_destroy_record_task(RecordTask* t) {\n if (t->detached_proxy) {\n detached_task_map.erase(t->tid);\n }\n scheduler().on_destroy(t);\n}\n\nuint64_t RecordSession::rr_signal_mask() const {\n return signal_bit(PerfCounters::TIME_SLICE_SIGNAL) |\n signal_bit(syscallbuf_desched_sig_);\n}\n\nstatic const uint32_t CPUID_RDRAND_FLAG = 1 << 30;\nstatic const uint32_t CPUID_RTM_FLAG = 1 << 11;\nstatic const uint32_t CPUID_RDSEED_FLAG = 1 << 18;\nstatic const uint32_t CPUID_XSAVEOPT_FLAG = 1 << 0;\n\nvoid DisableCPUIDFeatures::amend_cpuid_data(uint32_t eax_in, uint32_t ecx_in,\n CPUIDData* cpuid_data) const {\n switch (eax_in) {\n case CPUID_GETFEATURES:\n cpuid_data->ecx &= ~(CPUID_RDRAND_FLAG | features_ecx);\n cpuid_data->edx &= ~features_edx;\n break;\n case CPUID_GETEXTENDEDFEATURES:\n if (ecx_in == 0) {\n cpuid_data->ebx &= ~(CPUID_RDSEED_FLAG | CPUID_RTM_FLAG\n | extended_features_ebx);\n cpuid_data->ecx &= ~extended_features_ecx;\n cpuid_data->edx &= ~extended_features_edx;\n }\n break;\n case CPUID_GETXSAVE:\n if (ecx_in == 1) {\n // Always disable XSAVEOPT because it's nondeterministic,\n // possibly depending on context switching behavior. Intel\n // recommends not using it from user space.\n cpuid_data->eax &= ~(CPUID_XSAVEOPT_FLAG | xsave_features_eax);\n }\n break;\n default:\n break;\n }\n}\n\n} // namespace rr\n" }, { "path": "src/RecordSession.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RECORD_SESSION_H_\n#define RR_RECORD_SESSION_H_\n\n#include \n#include \n\n#include \"Scheduler.h\"\n#include \"SeccompFilterRewriter.h\"\n#include \"Session.h\"\n#include \"ThreadGroup.h\"\n#include \"TraceFrame.h\"\n#include \"WaitStatus.h\"\n\nnamespace rr {\n\nclass RecordTask;\n\nstruct DisableCPUIDFeatures {\n DisableCPUIDFeatures()\n : features_ecx(0)\n , features_edx(0)\n , extended_features_ebx(0)\n , extended_features_ecx(0)\n , extended_features_edx(0)\n , xsave_features_eax(0)\n {}\n bool any_features_disabled() const {\n return features_ecx || features_edx || extended_features_ebx\n || extended_features_ecx || extended_features_edx || xsave_features_eax;\n }\n /**\n * Includes disabling TSX and other rr-incompatible features */\n void amend_cpuid_data(uint32_t eax_in, uint32_t ecx_in,\n CPUIDData* cpuid_data) const;\n\n /* in: EAX=0x01 */\n uint32_t features_ecx;\n uint32_t features_edx;\n /* in: EAX=0x07 ECX=0 */\n uint32_t extended_features_ebx;\n uint32_t extended_features_ecx;\n uint32_t extended_features_edx;\n /* in: EAX=0x0D ECX=1 */\n uint32_t xsave_features_eax;\n};\n\nstruct TraceUuid {\n uint8_t bytes[16];\n};\n\n/** Encapsulates additional session state related to recording. */\nclass RecordSession final : public Session {\npublic:\n typedef std::shared_ptr shr_ptr;\n\n /**\n * Create a recording session for the initial command line |argv|.\n */\n enum SyscallBuffering { ENABLE_SYSCALL_BUF, DISABLE_SYSCALL_BUF };\n static shr_ptr create(\n const std::vector& argv,\n const std::vector& extra_env,\n const DisableCPUIDFeatures& features,\n SyscallBuffering syscallbuf = ENABLE_SYSCALL_BUF,\n unsigned char syscallbuf_desched_sig = SIGPWR,\n BindCPU bind_cpu = BindCPU(BindCPU::ANY),\n const std::string& output_trace_dir = \"\",\n const TraceUuid* trace_id = nullptr,\n bool use_audit = false,\n bool unmap_vdso = false,\n bool force_asan_active = false,\n bool force_tsan_active = false,\n bool intel_pt = false,\n bool check_outside_mmaps = false,\n bool no_preload = false);\n\n ~RecordSession() override;\n\n const DisableCPUIDFeatures& disable_cpuid_features() const {\n return disable_cpuid_features_;\n }\n bool use_syscall_buffer() const { return use_syscall_buffer_; }\n size_t syscall_buffer_size() const { return syscall_buffer_size_; }\n unsigned char syscallbuf_desched_sig() const { return syscallbuf_desched_sig_; }\n bool use_read_cloning() const { return use_read_cloning_; }\n bool use_file_cloning() const { return use_file_cloning_; }\n void set_ignore_sig(int sig) { ignore_sig = sig; }\n int get_ignore_sig() const { return ignore_sig; }\n void set_continue_through_sig(int sig) { continue_through_sig = sig; }\n int get_continue_through_sig() const { return continue_through_sig; }\n // Returns ranges to exclude from chaos mode memory allocation.\n // Used to exclude ranges used by sanitizers.\n const std::vector excluded_ranges() const {\n return excluded_ranges_;\n }\n MemoryRange fixed_global_exclusion_range() const {\n return fixed_global_exclusion_range_;\n }\n bool use_audit() const { return use_audit_; }\n bool unmap_vdso() { return unmap_vdso_; }\n bool check_outside_mmaps() { return check_outside_mmaps_; }\n uint64_t rr_signal_mask() const;\n\n enum RecordStatus {\n // Some execution was recorded. record_step() can be called again.\n STEP_CONTINUE,\n // All tracees are dead. record_step() should not be called again.\n STEP_EXITED,\n // Spawning the initial tracee failed. An error message will be in\n // failure_message.\n STEP_SPAWN_FAILED\n };\n struct RecordResult {\n RecordStatus status;\n // When status == STEP_EXITED\n WaitStatus exit_status;\n // When status == STEP_SPAWN_FAILED\n std::string failure_message;\n };\n /**\n * Record some tracee execution.\n * This may block. If blocking is interrupted by a signal, will return\n * STEP_CONTINUE.\n * Typically you'd call this in a loop until it returns something other than\n * STEP_CONTINUE.\n * Note that when this returns, some tasks may be running (not in a ptrace-\n * stop). In particular, up to one task may be executing user code and any\n * number of tasks may be blocked in syscalls.\n */\n RecordResult record_step();\n\n /**\n * SIGKILL all tracees.\n */\n void terminate_tracees();\n\n /**\n * Close trace output without flushing syscall buffers or writing\n * task exit/termination records to the trace.\n */\n void close_trace_writer(TraceWriter::CloseStatus status);\n\n virtual RecordSession* as_record() override { return this; }\n\n TraceWriter& trace_writer() { return trace_out; }\n\n Scheduler& scheduler() { return scheduler_; }\n\n SeccompFilterRewriter& seccomp_filter_rewriter() {\n return seccomp_filter_rewriter_;\n }\n\n enum ContinueType { DONT_CONTINUE = 0, CONTINUE, CONTINUE_SYSCALL };\n\n struct StepState {\n // Continue with this continuation type.\n ContinueType continue_type;\n StepState(ContinueType continue_type) : continue_type(continue_type) {}\n };\n\n void set_enable_chaos(bool enable_chaos) {\n scheduler().set_enable_chaos(enable_chaos);\n enable_chaos_ = enable_chaos;\n trace_out.set_chaos_mode(enable_chaos);\n }\n bool enable_chaos() const { return enable_chaos_; }\n\n void set_num_cores(int num_cores) {\n scheduler().set_num_cores(num_cores);\n }\n void set_use_read_cloning(bool enable) { use_read_cloning_ = enable; }\n void set_use_file_cloning(bool enable) { use_file_cloning_ = enable; }\n void set_syscall_buffer_size(size_t size) { syscall_buffer_size_ = size; }\n\n void set_wait_for_all(bool wait_for_all) {\n this->wait_for_all_ = wait_for_all;\n }\n\n virtual Task* new_task(pid_t tid, pid_t rec_tid, uint32_t serial,\n SupportedArch a, const std::string& name) override;\n\n RecordTask* find_task(pid_t rec_tid) const;\n RecordTask* find_task(const TaskUid& tuid) const;\n RecordTask* find_detached_proxy_task(pid_t proxy_tid) const;\n\n void on_proxy_detach(RecordTask *t, pid_t new_tid);\n\n /**\n * This gets called when we detect that a task has been revived from the\n * dead with a PTRACE_EVENT_EXEC. See ptrace man page under \"execve(2) under\n * ptrace\" for the horrid details.\n *\n * The task in the thread-group that triggered the successful execve has changed\n * its tid to |rec_tid|. We mirror that, and emit TraceTaskEvents to make it\n * look like a new task was spawned and the old task exited.\n */\n RecordTask* revive_task_for_exec(pid_t rec_tid);\n\n virtual TraceStream* trace_stream() override { return &trace_out; }\n\n /**\n * Send SIGTERM to all detached tasks and wait for them to finish.\n */\n void term_detached_tasks();\n\n /**\n * Forward SIGTERM to initial task\n */\n void forward_SIGTERM();\n\n void on_destroy_record_task(RecordTask* t);\n\nprivate:\n RecordSession(const std::string& exe_path,\n const std::vector& argv,\n const std::vector& envp,\n const DisableCPUIDFeatures& features,\n SyscallBuffering syscallbuf,\n int syscallbuf_desched_sig,\n BindCPU bind_cpu,\n const std::string& output_trace_dir,\n const TraceUuid* trace_id,\n bool use_audit,\n bool unmap_vdso,\n bool intel_pt,\n bool check_outside_mmaps);\n\n virtual void on_create(Task* t) override;\n\n void handle_seccomp_traced_syscall(RecordTask* t,\n RecordSession::StepState* step_state,\n RecordResult* result,\n bool* did_enter_syscall);\n // Returns false if the task exits during processing\n bool process_syscall_entry(RecordTask* t, StepState* step_state,\n RecordResult* step_result,\n SupportedArch syscall_arch);\n void check_initial_task_syscalls(RecordTask* t, RecordResult* step_result);\n void handle_seccomp_trap(RecordTask* t, StepState* step_state,\n uint16_t seccomp_data);\n void handle_seccomp_errno(RecordTask* t, StepState* step_state,\n uint16_t seccomp_data);\n bool handle_ptrace_event(RecordTask** t_ptr, StepState* step_state,\n RecordResult* result, bool* did_enter_syscall);\n bool handle_signal_event(RecordTask* t, StepState* step_state);\n void runnable_state_changed(RecordTask* t, StepState* step_state,\n RecordResult* step_result,\n bool can_consume_wait_status);\n bool signal_state_changed(RecordTask* t, StepState* step_state);\n void syscall_state_changed(RecordTask* t, StepState* step_state);\n void desched_state_changed(RecordTask* t);\n bool prepare_to_inject_signal(RecordTask* t, StepState* step_state);\n void task_continue(const StepState& step_state);\n\n TraceWriter trace_out;\n Scheduler scheduler_;\n ThreadGroup::shr_ptr initial_thread_group;\n SeccompFilterRewriter seccomp_filter_rewriter_;\n std::unique_ptr trace_id;\n\n DisableCPUIDFeatures disable_cpuid_features_;\n int ignore_sig;\n int continue_through_sig;\n Switchable last_task_switchable;\n size_t syscall_buffer_size_;\n unsigned char syscallbuf_desched_sig_;\n bool use_syscall_buffer_;\n\n bool use_file_cloning_;\n bool use_read_cloning_;\n /**\n * When true, try to increase the probability of finding bugs.\n */\n bool enable_chaos_;\n /**\n * When true, wait for all tracees to exit before finishing recording.\n */\n bool wait_for_all_;\n\n std::vector excluded_ranges_;\n MemoryRange fixed_global_exclusion_range_;\n /**\n * Keeps track of detached tasks.\n */\n std::map detached_task_map;\n\n std::string output_trace_dir;\n\n bool use_audit_;\n bool unmap_vdso_;\n bool check_outside_mmaps_;\n};\n\n} // namespace rr\n\n#endif // RR_RECORD_SESSION_H_\n" }, { "path": "src/RecordTask.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"RecordTask.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"AutoRemoteSyscalls.h\"\n#include \"ContextSwitchEvent.h\"\n#include \"PreserveFileMonitor.h\"\n#include \"RecordSession.h\"\n#include \"WaitManager.h\"\n#include \"core.h\"\n#include \"kernel_abi.h\"\n#include \"kernel_metadata.h\"\n#include \"log.h\"\n#include \"record_signal.h\"\n#include \"rr/rr.h\"\n#include \"util.h\"\n\nusing namespace std;\n\nnamespace rr {\n\n/**\n * Stores the table of signal dispositions and metadata for an\n * arbitrary set of tasks. Each of those tasks must own one of\n * the |refcount|s while they still refer to this.\n */\nstruct Sighandler {\n Sighandler() : resethand(false), takes_siginfo(false) {}\n\n template \n void init_arch(const typename Arch::kernel_sigaction& ksa) {\n k_sa_handler = ksa.k_sa_handler;\n sa.resize(sizeof(ksa));\n memcpy(sa.data(), &ksa, sizeof(ksa));\n resethand = (ksa.sa_flags & SA_RESETHAND) != 0;\n takes_siginfo = (ksa.sa_flags & SA_SIGINFO) != 0;\n }\n\n template void reset_arch() {\n typename Arch::kernel_sigaction ksa;\n memset(&ksa, 0, sizeof(ksa));\n DEBUG_ASSERT(uintptr_t(SIG_DFL) == 0);\n init_arch(ksa);\n }\n\n SignalDisposition disposition() const {\n DEBUG_ASSERT(uintptr_t(SIG_DFL) == 0);\n DEBUG_ASSERT(uintptr_t(SIG_IGN) == 1);\n switch (k_sa_handler.as_int()) {\n case 0:\n return SIGNAL_DEFAULT;\n case 1:\n return SIGNAL_IGNORE;\n default:\n return SIGNAL_HANDLER;\n }\n }\n\n remote_code_ptr get_user_handler() const {\n return disposition() == SIGNAL_HANDLER\n ? remote_code_ptr(k_sa_handler.as_int())\n : remote_code_ptr();\n }\n\n remote_ptr k_sa_handler;\n // Saved kernel_sigaction; used to restore handler\n vector sa;\n bool resethand;\n bool takes_siginfo;\n};\n\nstatic void reset_handler(Sighandler* handler, SupportedArch arch) {\n RR_ARCH_FUNCTION(handler->reset_arch, arch);\n}\n\nstruct Sighandlers {\n typedef shared_ptr shr_ptr;\n\n shr_ptr clone() const {\n shr_ptr s(new Sighandlers());\n // NB: depends on the fact that Sighandler is for all\n // intents and purposes a POD type, though not\n // technically.\n for (size_t i = 0; i < array_length(handlers); ++i) {\n s->handlers[i] = handlers[i];\n }\n return s;\n }\n\n Sighandler& get(int sig) {\n assert_valid(sig);\n return handlers[sig];\n }\n const Sighandler& get(int sig) const {\n assert_valid(sig);\n return handlers[sig];\n }\n\n void init_from_current_process() {\n for (size_t i = 1; i < array_length(handlers); ++i) {\n Sighandler& h = handlers[i];\n\n NativeArch::kernel_sigaction sa;\n if (::syscall(SYS_rt_sigaction, i, nullptr, &sa, sizeof(uint64_t))) {\n /* EINVAL means we're querying an\n * unused signal number. */\n DEBUG_ASSERT(EINVAL == errno);\n continue;\n }\n msan_unpoison(&sa, sizeof(NativeArch::kernel_sigaction));\n\n h.init_arch(sa);\n }\n }\n\n /**\n * For each signal in |table| such that is_user_handler() is\n * true, reset the disposition of that signal to SIG_DFL, and\n * clear the resethand flag if it's set. SIG_IGN signals are\n * not modified.\n *\n * (After an exec() call copies the original sighandler table,\n * this is the operation required by POSIX to initialize that\n * table copy.)\n */\n void reset_user_handlers(SupportedArch arch) {\n for (int i = 0; i < ssize_t(array_length(handlers)); ++i) {\n Sighandler& h = handlers[i];\n // If the handler was a user handler, reset to\n // default. If it was SIG_IGN or SIG_DFL,\n // leave it alone.\n if (h.disposition() == SIGNAL_HANDLER) {\n reset_handler(&h, arch);\n }\n }\n }\n\n void assert_valid(int sig) const {\n DEBUG_ASSERT(0 < sig && sig < ssize_t(array_length(handlers)));\n }\n\n static shr_ptr create() { return shr_ptr(new Sighandlers()); }\n\n Sighandler handlers[_NSIG];\n\nprivate:\n Sighandlers() {}\n Sighandlers(const Sighandlers&);\n Sighandlers operator=(const Sighandlers&);\n};\n\nRecordTask::RecordTask(RecordSession& session, pid_t _tid, uint32_t serial,\n SupportedArch a)\n : Task(session, _tid, _tid, serial, a),\n scheduler_token(0),\n ticks_at_last_recorded_syscall_exit(0),\n ip_at_last_recorded_syscall_exit(nullptr),\n time_at_start_of_last_timeslice(0),\n priority(0),\n in_round_robin_queue(false),\n stable_exit(false),\n detached_proxy(false),\n emulated_ptracer(nullptr),\n emulated_ptrace_event_msg(0),\n emulated_ptrace_options(0),\n emulated_ptrace_cont_command(0),\n emulated_stop_pending(false),\n emulated_ptrace_SIGCHLD_pending(false),\n emulated_SIGCHLD_pending(false),\n emulated_ptrace_seized(false),\n in_wait_type(WAIT_TYPE_NONE),\n in_wait_pid(0),\n creator_tid(0),\n emulated_stop_type(NOT_STOPPED),\n blocked_sigs_dirty(true),\n syscallbuf_blocked_sigs_generation(0),\n flushed_num_rec_bytes(0),\n flushed_syscallbuf(false),\n delay_syscallbuf_reset_for_desched(false),\n delay_syscallbuf_reset_for_seccomp_trap(false),\n prctl_seccomp_status(0),\n robust_futex_list_len(0),\n termination_signal(0),\n tsc_mode(PR_TSC_ENABLE),\n cpuid_mode(1),\n stashed_signals_blocking_more_signals(false),\n stashed_group_stop(false),\n break_at_syscallbuf_traced_syscalls(false),\n break_at_syscallbuf_untraced_syscalls(false),\n break_at_syscallbuf_final_instruction(false),\n syscallstub_exit_breakpoint(),\n next_pmc_interrupt_is_for_user(false),\n did_record_robust_futex_changes(false),\n waiting_for_reap(false),\n waiting_for_ptrace_exit(false),\n sent_shutdown_kill(false),\n did_execveat(false),\n tick_request_override((TicksRequest)0),\n schedule_frozen(false) {\n push_event(Event::sentinel());\n if (session.tasks().empty()) {\n // Initial tracee.\n auto sh = Sighandlers::create();\n sh->init_from_current_process();\n // Task::set_up_process resets all non-RT signals to\n // default handling, so mimic that now.\n for (int sig = 1; sig <= 31; ++sig) {\n reset_handler(&sh->get(sig), arch());\n }\n sighandlers.swap(sh);\n own_namespace_rec_tid = _tid;\n }\n}\n\nRecordTask::~RecordTask() {\n if (emulated_ptracer) {\n emulated_ptracer->emulated_ptrace_tracees.erase(this);\n if (emulated_ptrace_options & PTRACE_O_TRACEEXIT) {\n ASSERT(this, stable_exit)\n << \"PTRACE_O_TRACEEXIT only supported for stable exits for now\";\n }\n }\n for (RecordTask* t : emulated_ptrace_tracees) {\n // XXX emulate PTRACE_O_EXITKILL\n ASSERT(this, t->emulated_ptracer == this);\n t->emulated_ptracer = nullptr;\n t->emulated_ptrace_options = 0;\n t->emulated_stop_pending = false;\n t->emulated_stop_type = NOT_STOPPED;\n }\n\n // We expect tasks to usually exit by a call to exit() or\n // exit_group(), so it's not helpful to warn about that.\n if (EV_SENTINEL != ev().type() &&\n (pending_events.size() > 2 ||\n !(ev().type() == EV_SYSCALL &&\n (is_exit_syscall(ev().Syscall().number, ev().Syscall().regs.arch()) ||\n is_exit_group_syscall(ev().Syscall().number,\n ev().Syscall().regs.arch()))))) {\n LOG(info) << tid << \" still has pending events. From top down:\";\n log_pending_events();\n }\n\n if (detached_proxy) {\n // Kill it so that proceed_to_exit will reach PTRACE_EVENT_EXIT.\n ::kill(tid, SIGKILL);\n // We kept the zombie of the original task around to prevent its pid from\n // being re-used. Reap that now.\n proceed_to_exit();\n if (!was_reaped() && may_reap()) {\n reap();\n }\n did_kill();\n }\n\n // If this was stopped, notify the scheduler.\n set_stopped(false);\n\n session().on_destroy_record_task(this);\n}\n\nvoid RecordTask::record_exit_trace_event(WaitStatus exit_status) {\n session().trace_writer().write_task_event(\n TraceTaskEvent::for_exit(tid, exit_status));\n if (thread_group()->tgid == tid) {\n thread_group()->exit_status = exit_status;\n }\n}\n\nvoid RecordTask::record_exit_event(WriteChildTid write_child_tid) {\n // The kernel explicitly only clears the futex if the address space is shared.\n // If the address space has no other users then the futex will not be cleared\n // even if it lives in shared memory which other tasks can read.\n if (!tid_futex.is_null() && as->task_set().size() > 1 &&\n as->has_mapping(tid_futex)) {\n int val = 0;\n record_local(tid_futex, &val);\n if (write_child_tid == WRITE_CHILD_TID) {\n // Write the memory now, otherwise the kernel will write it later and that can\n // race with the execution of other threads if we don't wait for this\n // thread to fully exit.\n // This could fail since the address space might have gone away/been switched\n // by execve.\n bool ok = true;\n write_mem(tid_futex, 0, &ok);\n // The kernel will do an unconditional futex wake on that location so we don't\n // need to do it.\n }\n }\n\n // Write the exit event here so that the value recorded above is captured.\n // Don't flush syscallbuf. Whatever triggered the exit (syscall, signal)\n // should already have flushed it, if it was running. If it was blocked,\n // then the syscallbuf would already have been flushed too. Trying to flush\n // syscallbuf for an exiting task could be bad,\n // e.g. it could be in the middle of syscallbuf code that's supposed to be\n // atomic. For the same reasons don't allow syscallbuf to be reset here.\n record_event(Event::exit(), DONT_FLUSH_SYSCALLBUF, DONT_RESET_SYSCALLBUF);\n}\n\nRecordSession& RecordTask::session() const {\n return *Task::session().as_record();\n}\n\nTraceWriter& RecordTask::trace_writer() const {\n return session().trace_writer();\n}\n\nTask* RecordTask::clone(CloneReason reason, int flags, remote_ptr stack,\n remote_ptr tls, remote_ptr cleartid_addr,\n pid_t new_tid, pid_t new_rec_tid, uint32_t new_serial,\n Session* other_session, FdTable::shr_ptr new_fds,\n ThreadGroup::shr_ptr new_tg) {\n ASSERT(this, reason == Task::TRACEE_CLONE);\n ASSERT(this, !new_fds);\n ASSERT(this, !new_tg);\n Task* t = Task::clone(reason, flags, stack, tls, cleartid_addr, new_tid,\n new_rec_tid, new_serial, other_session, new_fds,\n new_tg);\n if (t->session().is_recording()) {\n RecordTask* rt = static_cast(t);\n if (CLONE_CLEARTID & flags) {\n LOG(debug) << \"cleartid futex is \" << cleartid_addr;\n ASSERT(this, !cleartid_addr.is_null());\n rt->tid_futex = cleartid_addr;\n } else {\n LOG(debug) << \"(clone child not enabling CLEARTID)\";\n }\n if (reason == TRACEE_CLONE) {\n rt->creator_tid = tid;\n }\n }\n return t;\n}\n\nvoid RecordTask::post_wait_clone(Task* cloned_from, int flags) {\n ASSERT(cloned_from, cloned_from->session().is_recording());\n Task::post_wait_clone(cloned_from, flags);\n\n RecordTask* rt = static_cast(cloned_from);\n priority = rt->priority;\n syscallbuf_code_layout = rt->syscallbuf_code_layout;\n prctl_seccomp_status = rt->prctl_seccomp_status;\n robust_futex_list = rt->robust_futex_list;\n robust_futex_list_len = rt->robust_futex_list_len;\n tsc_mode = rt->tsc_mode;\n cpuid_mode = rt->cpuid_mode;\n if (CLONE_SHARE_SIGHANDLERS & flags) {\n sighandlers = rt->sighandlers;\n } else {\n auto sh = rt->sighandlers->clone();\n sighandlers.swap(sh);\n }\n\n update_own_namespace_tid();\n}\n\nvoid RecordTask::post_exec() {\n // Change syscall number to execve/execveat *for the new arch*. If we don't do this,\n // and the arch changes, then the syscall number for execve in the old arch/\n // is treated as the syscall we're executing in the new arch, with hilarious\n // results.\n int new_syscallno = did_execveat ? syscall_number_for_execveat(arch())\n : syscall_number_for_execve(arch());\n registers.set_original_syscallno(new_syscallno);\n // Fix event architecture and syscall number\n ev().Syscall().number = new_syscallno;\n ev().Syscall().set_arch(arch());\n\n // The signal mask is inherited across execve so we don't need to invalidate.\n Task::post_exec(exe_path());\n if (emulated_ptracer) {\n ASSERT(this, !(emulated_ptracer->arch() == x86 && arch() == x86_64))\n << \"We don't support a 32-bit process tracing a 64-bit process\";\n }\n\n // Clear robust_list state to match kernel state. If this task is cloned\n // soon after exec, we must not do a bogus set_robust_list syscall for\n // the clone.\n set_robust_list(nullptr, 0);\n sighandlers = sighandlers->clone();\n sighandlers->reset_user_handlers(arch());\n\n // Newly execed tasks always have non-faulting mode (from their point of\n // view, even if rr is secretly causing faults).\n cpuid_mode = 1;\n}\n\ntemplate static void do_preload_init_arch(RecordTask* t) {\n auto params = t->read_mem(\n remote_ptr>(t->regs().orig_arg1()));\n\n t->syscallbuf_code_layout.syscallbuf_syscall_hook =\n params.syscallbuf_syscall_hook.rptr().as_int();\n t->syscallbuf_code_layout.syscallbuf_final_exit_instruction =\n params.syscallbuf_final_exit_instruction.rptr().as_int();\n t->syscallbuf_code_layout.syscallbuf_code_start =\n params.syscallbuf_code_start.rptr().as_int();\n t->syscallbuf_code_layout.syscallbuf_code_end =\n params.syscallbuf_code_end.rptr().as_int();\n t->syscallbuf_code_layout.get_pc_thunks_start =\n params.get_pc_thunks_start.rptr().as_int();\n t->syscallbuf_code_layout.get_pc_thunks_end =\n params.get_pc_thunks_end.rptr().as_int();\n\n unsigned char in_chaos = t->session().enable_chaos();\n auto in_chaos_ptr REMOTE_PTR_FIELD(params.globals.rptr(), in_chaos);\n t->write_mem(in_chaos_ptr, in_chaos);\n t->record_local(in_chaos_ptr, &in_chaos);\n\n auto desched_sig = t->session().syscallbuf_desched_sig();\n auto desched_sig_ptr = REMOTE_PTR_FIELD(params.globals.rptr(), desched_sig);\n t->write_mem(desched_sig_ptr, desched_sig);\n t->record_local(desched_sig_ptr, &desched_sig);\n\n uint64_t random_seed;\n do {\n random_seed = rand() | (uint64_t(rand()) << 32);\n } while (!random_seed);\n auto random_seed_ptr REMOTE_PTR_FIELD(params.globals.rptr(), random_seed);\n t->write_mem(random_seed_ptr, random_seed);\n t->record_local(random_seed_ptr, &random_seed);\n\n auto cpu_binding = t->session().cpu_binding();\n int core_num = cpu_binding.mode == BindCPU::SPECIFIED_CORE ?\n cpu_binding.specified_core : -1;\n auto cpu_binding_ptr = REMOTE_PTR_FIELD(params.globals.rptr(), cpu_binding);\n t->write_mem(cpu_binding_ptr, core_num);\n t->record_local(cpu_binding_ptr, &core_num);\n\n auto context_switch_event_strategy = ContextSwitchEvent::strategy();\n auto context_switch_event_strategy_ptr =\n REMOTE_PTR_FIELD(params.globals.rptr(), context_switch_event_strategy);\n t->write_mem(context_switch_event_strategy_ptr, context_switch_event_strategy);\n t->record_local(context_switch_event_strategy_ptr, &context_switch_event_strategy);\n}\n\nvoid RecordTask::push_syscall_event(int syscallno) {\n push_event(SyscallEvent(syscallno, detect_syscall_arch()));\n}\n\nstatic void do_preload_init(RecordTask* t) {\n RR_ARCH_FUNCTION(do_preload_init_arch, t->arch(), t);\n}\n\nvoid RecordTask::at_preload_init() {\n Task::at_preload_init();\n do_preload_init(this);\n}\n\n/**\n * Avoid using low-numbered file descriptors since that can confuse\n * developers.\n */\nstatic int find_free_file_descriptor(RecordTask* t) {\n int fd;\n int fd_limit;\n struct rlimit limit;\n // Try to determine what the maximum fd is. If we can't, just\n // start the search from 0 and bail out if we hit an absurd\n // number of fds;\n if (prlimit(t->tgid(), RLIMIT_NOFILE, nullptr, &limit) < 0) {\n // We might get EPERM if the tracee has changed UID. If that\n // happens fall back to being slow. (We can probably go faster\n // using readdir().)\n ASSERT(t, errno == EPERM) << \"Unknown error in prlimit\";\n fd_limit = 128*1024;\n fd = 0;\n } else {\n fd_limit = limit.rlim_cur;\n fd = max(300, t->fd_table()->last_free_fd());\n }\n\n bool searched_from_start = fd == 0;\n while (true) {\n if (fd >= fd_limit) {\n ASSERT(t, !searched_from_start) << \"No free fds available\";\n fd = 0;\n searched_from_start = true;\n }\n\n char buf[PATH_MAX];\n sprintf(buf, \"/proc/%d/fd/%d\", t->tid, fd);\n if (access(buf, F_OK) == -1 && errno == ENOENT) {\n t->fd_table()->set_last_free_fd(fd);\n return fd;\n }\n ++fd;\n }\n}\n\ntemplate void RecordTask::init_buffers_arch() {\n ASSERT(this, as->syscallbuf_enabled())\n << \"Someone called rrcall_init_buffers with syscallbuf disabled?\";\n\n // NB: the tracee can't be interrupted with a signal while\n // we're processing the rrcall, because it's masked off all\n // signals.\n AutoRemoteSyscalls remote(this);\n\n // Arguments to the rrcall.\n remote_ptr> child_args = regs().orig_arg1();\n auto args = read_mem(child_args);\n\n args.cloned_file_data_fd = -1;\n args.syscallbuf_size = syscallbuf_size = session().syscall_buffer_size();\n KernelMapping syscallbuf_km = init_syscall_buffer(remote, nullptr);\n if (!syscallbuf_km.size()) {\n // Syscallbuf allocation failed. This should mean the child is dead,\n // but just in case, return an error.\n remote.regs().set_syscall_result(-ENOMEM);\n return;\n }\n\n args.syscallbuf_ptr = syscallbuf_child;\n if (syscallbuf_child != nullptr) {\n // This needs to be skipped if we couldn't allocate the buffer\n // since replaying only reads (and advances) the mmap record\n // if `args.syscallbuf_ptr != nullptr`.\n auto record_in_trace = trace_writer().write_mapped_region(\n this, syscallbuf_km, syscallbuf_km.fake_stat(), syscallbuf_km.fsname(),\n vector(),\n TraceWriter::RR_BUFFER_MAPPING);\n ASSERT(this, record_in_trace == TraceWriter::DONT_RECORD_IN_TRACE);\n } else {\n // This can fail, e.g. if the tracee died unexpectedly.\n LOG(debug) << \"Syscallbuf initialization failed\";\n args.syscallbuf_size = 0;\n }\n\n if (args.syscallbuf_ptr) {\n desched_fd_child = args.desched_counter_fd;\n // Prevent the child from closing this fd\n fds->add_monitor(this, desched_fd_child, new PreserveFileMonitor());\n if (!desched_fd.init(remote.retrieve_fd(desched_fd_child))) {\n LOG(warn)\n << \"ContextSwitchEvent initialization with strategy \"\n \"STRATEGY_RECORD_SWITCH failed. tracee died unexpectedly or killed ??\";\n }\n\n if (trace_writer().supports_file_data_cloning() &&\n session().use_read_cloning()) {\n cloned_file_data_fname = trace_writer().file_data_clone_file_name(tuid());\n ScopedFd clone_file(cloned_file_data_fname.c_str(), O_RDWR | O_CREAT, 0600);\n int cloned_file_data = remote.infallible_send_fd_if_alive(clone_file);\n if (cloned_file_data >= 0) {\n int free_fd = find_free_file_descriptor(this);\n cloned_file_data_fd_child =\n remote.syscall(syscall_number_for_dup3(arch()), cloned_file_data,\n free_fd, O_CLOEXEC);\n if (cloned_file_data_fd_child != free_fd) {\n ASSERT(this, cloned_file_data_fd_child < 0);\n LOG(warn) << \"Couldn't dup clone-data file to free fd\";\n cloned_file_data_fd_child = cloned_file_data;\n } else {\n // Prevent the child from closing this fd. We're going to close it\n // ourselves and we don't want the child closing it and then reopening\n // its own file with this fd.\n fds->add_monitor(this, cloned_file_data_fd_child,\n new PreserveFileMonitor());\n remote.infallible_close_syscall_if_alive(cloned_file_data);\n }\n args.cloned_file_data_fd = cloned_file_data_fd_child;\n }\n }\n }\n args.scratch_buf = scratch_ptr;\n args.usable_scratch_size = usable_scratch_size();\n\n // Return the mapped buffers to the child.\n write_mem(child_args, args);\n\n // The tracee doesn't need this addr returned, because it's\n // already written to the inout |args| param, but we stash it\n // away in the return value slot so that we can easily check\n // that we map the segment at the same addr during replay.\n remote.regs().set_syscall_result(syscallbuf_child);\n}\n\nvoid RecordTask::init_buffers() { RR_ARCH_FUNCTION(init_buffers_arch, arch()); }\n\ntemplate \nvoid RecordTask::on_syscall_exit_arch(int syscallno, const Registers& regs) {\n switch (syscallno) {\n // These syscalls affect the sigmask even if they fail.\n case Arch::epoll_pwait:\n case Arch::epoll_pwait2:\n case Arch::pselect6:\n case Arch::pselect6_time64:\n case Arch::ppoll:\n case Arch::ppoll_time64:\n invalidate_sigmask();\n break;\n }\n\n if (regs.original_syscallno() == SECCOMP_MAGIC_SKIP_ORIGINAL_SYSCALLNO ||\n regs.syscall_failed()) {\n return;\n }\n\n switch (syscallno) {\n case Arch::set_robust_list:\n set_robust_list(regs.orig_arg1(), (size_t)regs.arg2());\n return;\n case Arch::sigaction:\n case Arch::rt_sigaction:\n // TODO: SYS_signal\n update_sigaction(regs);\n return;\n case Arch::set_tid_address:\n set_tid_addr(regs.orig_arg1());\n return;\n case Arch::sigsuspend:\n case Arch::rt_sigsuspend:\n case Arch::sigprocmask:\n case Arch::rt_sigprocmask:\n case Arch::pselect6:\n case Arch::pselect6_time64:\n case Arch::ppoll:\n case Arch::ppoll_time64:\n invalidate_sigmask();\n return;\n }\n}\n\nvoid RecordTask::on_syscall_exit(int syscallno, SupportedArch arch,\n const Registers& regs) {\n with_converted_registers(regs, arch, [&](const Registers& regs) {\n Task::on_syscall_exit(syscallno, arch, regs);\n RR_ARCH_FUNCTION(on_syscall_exit_arch, arch, syscallno, regs)\n });\n}\n\nbool RecordTask::is_at_syscallbuf_syscall_entry_breakpoint() {\n auto i = ip().undo_executed_bkpt(arch());\n for (auto p : syscallbuf_syscall_entry_breakpoints()) {\n if (i == p) {\n return true;\n }\n }\n return false;\n}\n\nbool RecordTask::is_at_syscallbuf_final_instruction_breakpoint() {\n if (!break_at_syscallbuf_final_instruction) {\n return false;\n }\n auto i = ip().undo_executed_bkpt(arch());\n return i == syscallbuf_code_layout.syscallbuf_final_exit_instruction;\n}\n\nbool RecordTask::is_at_syscallstub_exit_breakpoint() {\n if (!break_at_syscallbuf_final_instruction || !syscallstub_exit_breakpoint) {\n return false;\n }\n auto i = ip().undo_executed_bkpt(arch());\n return i == syscallstub_exit_breakpoint;\n}\n\nvoid RecordTask::will_resume_execution(ResumeRequest, WaitRequest,\n TicksRequest ticks_request, int sig) {\n // We may execute user code, which could lead to an RDTSC or grow-map\n // operation which unblocks SIGSEGV, and we'll need to know whether to\n // re-block it. So we need our cached sigmask to be up to date.\n // We don't need to this if we're not going to execute user code\n // (i.e. ticks_request == RESUME_NO_TICKS) except that did_wait can't\n // easily check for that and may restore blocked_sigs so it had better be\n // accurate.\n get_sigmask();\n\n if (stashed_signals_blocking_more_signals) {\n // A stashed signal we have already accepted for this task may\n // have a sigaction::sa_mask that would block the next signal to be\n // delivered and cause it to be delivered to a different task. If we allow\n // such a signal to be delivered to this task then we run the risk of never\n // being able to process the signal (if it stays blocked indefinitely).\n // To prevent this, block any further signal delivery as long as there are\n // stashed signals.\n // We assume the kernel can't report a new signal of the same number\n // in response to us injecting a signal. XXX is this true??? We don't\n // have much choice, signal injection won't work if we block the signal.\n // We leave rr signals unblocked. TIME_SLICE_SIGNAL has to be unblocked\n // because blocking it seems to cause problems for some hardware/kernel\n // configurations (see https://github.com/rr-debugger/rr/issues/1979),\n // causing them to stop counting events.\n sig_set_t sigset = ~session().rr_signal_mask();\n if (sig) {\n // We're injecting a signal, so make sure that signal is unblocked.\n sigset &= ~signal_bit(sig);\n }\n LOG(debug) << \"Set signal mask for \" << tid << \" to block all signals (bar \"\n << \"SYSCALLBUF_DESCHED_SIGNAL/TIME_SLICE_SIGNAL) while we \"\n << \"have a stashed signal\";\n set_sigmask(sigset);\n }\n\n // RESUME_NO_TICKS means that tracee code is not going to run so there's no\n // need to set breakpoints and in fact they might interfere with rr\n // processing.\n if (ticks_request != RESUME_NO_TICKS) {\n if (!at_may_restart_syscall()) {\n // If the tracee has SIGTRAP blocked or ignored and we hit one of these\n // breakpoints, the kernel will automatically unblock the signal and set\n // its disposition to DFL, effects which we ought to undo to keep these\n // SIGTRAPs invisible to tracees. Fixing the sigmask happens\n // automatically in did_wait(). Restoring the signal-ignored status is\n // handled in `handle_syscallbuf_breakpoint`.\n\n // Set breakpoints at untraced syscalls to catch us entering an untraced\n // syscall. We don't need to do this (and shouldn't do this) if the\n // execution requestor wants to stop inside untraced syscalls.\n // If we have an interrupted syscall that we may restart, don't\n // set the breakpoints because we should restart the syscall instead\n // of breaking and delivering signals. The syscallbuf code doesn't\n // (and must not) perform more than one blocking syscall for any given\n // buffered syscall.\n for (auto p : syscallbuf_syscall_entry_breakpoints()) {\n vm()->add_breakpoint(p, BKPT_INTERNAL);\n }\n }\n if (break_at_syscallbuf_final_instruction) {\n vm()->add_breakpoint(\n syscallbuf_code_layout.syscallbuf_final_exit_instruction,\n BKPT_INTERNAL);\n auto stub_bp = as->monkeypatcher().get_jump_stub_exit_breakpoint(ip(), this);\n if (stub_bp) {\n syscallstub_exit_breakpoint = stub_bp;\n vm()->add_breakpoint(stub_bp, BKPT_INTERNAL);\n }\n }\n }\n\n desched_fd.drain_events();\n}\n\nvector RecordTask::syscallbuf_syscall_entry_breakpoints() {\n vector result;\n if (break_at_syscallbuf_untraced_syscalls) {\n result.push_back(AddressSpace::rr_page_syscall_entry_point(\n AddressSpace::UNTRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::RECORDING_ONLY, arch()));\n result.push_back(AddressSpace::rr_page_syscall_entry_point(\n AddressSpace::UNTRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::RECORDING_AND_REPLAY, arch()));\n }\n if (break_at_syscallbuf_traced_syscalls) {\n result.push_back(AddressSpace::rr_page_syscall_entry_point(\n AddressSpace::TRACED, AddressSpace::UNPRIVILEGED,\n AddressSpace::RECORDING_AND_REPLAY, arch()));\n }\n return result;\n}\n\nvoid RecordTask::did_wait() {\n for (auto p : syscallbuf_syscall_entry_breakpoints()) {\n vm()->remove_breakpoint(p, BKPT_INTERNAL);\n }\n if (break_at_syscallbuf_final_instruction) {\n vm()->remove_breakpoint(\n syscallbuf_code_layout.syscallbuf_final_exit_instruction,\n BKPT_INTERNAL);\n }\n if (syscallstub_exit_breakpoint) {\n vm()->remove_breakpoint(syscallstub_exit_breakpoint, BKPT_INTERNAL);\n }\n\n if (stashed_signals_blocking_more_signals) {\n // Saved 'blocked_sigs' must still be correct regardless of syscallbuf\n // state, because we do not allow stashed_signals_blocking_more_signals\n // to hold across syscalls (traced or untraced) that change the signal mask.\n ASSERT(this, !blocked_sigs_dirty);\n // If this fails the tracee is on the exit path and its sigmask is irrelevant.\n ptrace_if_stopped(PTRACE_SETSIGMASK, remote_ptr(8), &blocked_sigs);\n } else if (syscallbuf_child) {\n // The syscallbuf struct is only 32 bytes currently so read the whole thing\n // at once to avoid multiple calls to read_mem. Even though this shouldn't\n // need a syscall because we use a local-mapping, apparently that lookup\n // is still noticeably expensive.\n auto syscallbuf = read_mem(syscallbuf_child);\n if (syscallbuf.in_sigprocmask_critical_section) {\n // |blocked_sigs| may have been updated but the syscall not yet issued.\n // Use the kernel's value.\n invalidate_sigmask();\n } else {\n uint32_t syscallbuf_generation = syscallbuf.blocked_sigs_generation;\n if (syscallbuf_generation > syscallbuf_blocked_sigs_generation) {\n syscallbuf_blocked_sigs_generation = syscallbuf_generation;\n blocked_sigs = syscallbuf.blocked_sigs;\n }\n }\n }\n}\n\nvoid RecordTask::set_emulated_ptracer(RecordTask* tracer) {\n if (tracer) {\n ASSERT(this, !emulated_ptracer);\n emulated_ptracer = tracer;\n emulated_ptracer->emulated_ptrace_tracees.insert(this);\n } else {\n ASSERT(this, emulated_ptracer);\n ASSERT(this,\n emulated_stop_type == NOT_STOPPED ||\n emulated_stop_type == GROUP_STOP);\n emulated_ptracer->emulated_ptrace_tracees.erase(this);\n emulated_ptracer = nullptr;\n }\n}\n\nbool RecordTask::emulate_ptrace_stop(WaitStatus status, EmulatedStopType stop_type,\n const siginfo_t* siginfo, int si_code) {\n ASSERT(this, emulated_stop_type == NOT_STOPPED);\n if (!emulated_ptracer) {\n return false;\n }\n if (siginfo) {\n ASSERT(this, status.ptrace_signal() == siginfo->si_signo);\n save_ptrace_signal_siginfo(*siginfo);\n } else {\n siginfo_t si;\n memset(&si, 0, sizeof(si));\n si.si_signo = status.ptrace_signal();\n if (status.ptrace_event() || status.is_syscall()) {\n si.si_code = status.get() >> 8;\n } else {\n si.si_code = si_code;\n }\n save_ptrace_signal_siginfo(si);\n }\n force_emulate_ptrace_stop(status, stop_type);\n return true;\n}\n\nvoid RecordTask::force_emulate_ptrace_stop(WaitStatus status, EmulatedStopType stop_type) {\n emulated_stop_type = stop_type;\n emulated_stop_code = status;\n emulated_stop_pending = true;\n emulated_ptrace_SIGCHLD_pending = true;\n\n emulated_ptracer->send_synthetic_SIGCHLD_if_necessary();\n // The SIGCHLD will eventually be reported to rr via a ptrace stop,\n // interrupting wake_task's syscall (probably a waitpid) if necessary. At\n // that point, we'll fix up the siginfo data with values that match what\n // the kernel would have delivered for a real ptracer's SIGCHLD. When the\n // signal handler (if any) returns, if wake_task was in a blocking wait that\n // wait will be resumed, at which point rec_prepare_syscall_arch will\n // discover the pending ptrace result and emulate the wait syscall to\n // return that result immediately.\n}\n\nvoid RecordTask::do_ptrace_exit_stop(WaitStatus exit_status) {\n // Notify ptracer of the exit if it's not going to receive it from the\n // kernel because it's not the parent. (The kernel has similar logic to\n // deliver two stops in this case.)\n if (emulated_ptracer &&\n (is_clone_child() ||\n get_parent_pid() != emulated_ptracer->real_tgid())) {\n // The task is dead so treat it as not stopped so we can deliver a new stop\n emulated_stop_type = NOT_STOPPED;\n // This is a bit wrong; this is an exit stop, not a signal/ptrace stop.\n emulate_ptrace_stop(exit_status);\n }\n}\n\nvoid RecordTask::did_reach_zombie() {\n // Remove from address-space and fds list since we really aren't associated\n // with them anymore (and we can't be used to operate on them)\n as->erase_task(this);\n fds->erase_task(this);\n\n if (!was_reaped()) {\n if (may_reap()) {\n reap();\n } else {\n waiting_for_reap = true;\n }\n }\n if ((was_reaped() || !waiting_for_reap) && !emulated_stop_pending) {\n delete this;\n }\n}\n\nvoid RecordTask::set_stopped(bool stopped) {\n if (is_stopped_ == stopped) {\n return;\n }\n is_stopped_ = stopped;\n if (stopped) {\n session().scheduler().stopped_task(this);\n } else {\n session().scheduler().started_task(this);\n }\n}\n\nvoid RecordTask::send_synthetic_SIGCHLD_if_necessary() {\n RecordTask* wake_task = nullptr;\n bool need_signal = false;\n for (RecordTask* tracee : emulated_ptrace_tracees) {\n if (tracee->emulated_ptrace_SIGCHLD_pending) {\n need_signal = true;\n // check to see if any thread in the ptracer process is in a waitpid that\n // could read the status of 'tracee'. If it is, we should wake up that\n // thread. Otherwise we send SIGCHLD to the ptracer thread.\n for (Task* t : thread_group()->task_set()) {\n auto rt = static_cast(t);\n if (rt->is_waiting_for_ptrace(tracee)) {\n wake_task = rt;\n break;\n }\n }\n if (wake_task) {\n break;\n }\n }\n }\n if (!need_signal) {\n for (ThreadGroup* child_tg : thread_group()->children()) {\n for (Task* child : child_tg->task_set()) {\n RecordTask* rchild = static_cast(child);\n if (rchild->emulated_SIGCHLD_pending) {\n need_signal = true;\n // check to see if any thread in the ptracer process is in a waitpid\n // that could read the status of 'tracee'. If it is, we should wake\n // up that thread. Otherwise we send SIGCHLD to the ptracer thread.\n for (Task* t : thread_group()->task_set()) {\n auto rt = static_cast(t);\n if (rt->is_waiting_for(rchild)) {\n wake_task = rt;\n break;\n }\n }\n if (wake_task) {\n break;\n }\n }\n }\n }\n if (!need_signal) {\n return;\n }\n }\n\n // ptrace events trigger SIGCHLD in the ptracer's wake_task.\n // We can't set all the siginfo values to their correct values here, so\n // we'll patch this up when the signal is received.\n // If there's already a pending SIGCHLD, this signal will be ignored,\n // but at some point the pending SIGCHLD will be delivered and then\n // send_synthetic_SIGCHLD_if_necessary will be called again to deliver a new\n // SIGCHLD if necessary.\n siginfo_t si;\n memset(&si, 0, sizeof(si));\n si.si_code = SI_QUEUE;\n si.si_value.sival_int = SIGCHLD_SYNTHETIC;\n int ret;\n if (wake_task) {\n LOG(debug) << \"Sending synthetic SIGCHLD to waiting tid \" << wake_task->tid;\n // We must use the raw SYS_rt_tgsigqueueinfo syscall here to ensure the\n // signal is sent to the correct thread by tid.\n ret = syscall(SYS_rt_tgsigqueueinfo, wake_task->tgid(), wake_task->tid,\n SIGCHLD, &si);\n ASSERT(this, ret == 0);\n // `stashed_signals_blocking_more_signals` means that SIGCHLD can be\n // blocked even when `is_sig_blocked` is false.\n if (wake_task->is_sig_blocked(SIGCHLD) ||\n wake_task->stashed_signals_blocking_more_signals) {\n LOG(debug) << \"SIGCHLD is blocked, kicking it out of the syscall\";\n // Just sending SIGCHLD won't wake it up. Send it a TIME_SLICE_SIGNAL\n // as well to make sure it exits a blocking syscall. We ensure those\n // can never be blocked.\n // We have to send a negative code here because only the kernel can set\n // positive codes. We set a magic number so we can recognize it\n // when received.\n si.si_code = SYNTHETIC_TIME_SLICE_SI_CODE;\n ret = syscall(SYS_rt_tgsigqueueinfo, wake_task->tgid(), wake_task->tid,\n PerfCounters::TIME_SLICE_SIGNAL, &si);\n ASSERT(this, ret == 0);\n }\n } else {\n // Send the signal to the process as a whole and let the kernel\n // decide which thread gets it.\n ret = syscall(SYS_rt_sigqueueinfo, tgid(), SIGCHLD, &si);\n ASSERT(this, ret == 0);\n LOG(debug) << \"Sending synthetic SIGCHLD to pid \" << tgid();\n }\n}\n\nstatic bool is_synthetic_SIGCHLD(const siginfo_t& si) {\n return si.si_signo == SIGCHLD && si.si_value.sival_int == SIGCHLD_SYNTHETIC;\n}\n\nvoid RecordTask::set_siginfo_for_synthetic_SIGCHLD(siginfo_t* si) {\n if (!is_synthetic_SIGCHLD(*si)) {\n return;\n }\n\n RecordTask* from_task = nullptr;\n for (RecordTask* tracee : emulated_ptrace_tracees) {\n if (tracee->emulated_ptrace_SIGCHLD_pending) {\n if (!from_task) {\n from_task = tracee;\n }\n tracee->emulated_ptrace_SIGCHLD_pending = false;\n }\n }\n\n if (!from_task) {\n for (ThreadGroup* child_tg : thread_group()->children()) {\n for (Task* child : child_tg->task_set()) {\n auto rchild = static_cast(child);\n if (rchild->emulated_SIGCHLD_pending) {\n if (!from_task) {\n from_task = rchild;\n }\n rchild->emulated_SIGCHLD_pending = false;\n }\n }\n }\n\n if (!from_task) {\n // Maybe the task died after the synthetic SIGCHLD was sent\n LOG(warn) << \"Can't find traced task that send synthetic SIGCHLD\";\n return;\n }\n }\n\n from_task->set_siginfo_for_waited_task(\n reinterpret_cast(si));\n si->si_value.sival_int = 0;\n}\n\nbool RecordTask::is_waiting_for_ptrace(RecordTask* t) {\n // This task's process must be a ptracer of t.\n if (!t->emulated_ptracer ||\n t->emulated_ptracer->thread_group() != thread_group()) {\n return false;\n }\n // XXX need to check |options| to make sure this task is eligible!!\n switch (in_wait_type) {\n case WAIT_TYPE_NONE:\n return false;\n case WAIT_TYPE_ANY:\n return true;\n case WAIT_TYPE_SAME_PGID:\n return getpgid(t->tgid()) == getpgid(tgid());\n case WAIT_TYPE_PGID:\n return getpgid(t->tgid()) == in_wait_pid;\n case WAIT_TYPE_PID:\n // When waiting for a ptracee, a specific pid is interpreted as the\n // exact tid.\n return t->tid == in_wait_pid;\n default:\n ASSERT(this, false);\n return false;\n }\n}\n\nbool RecordTask::is_waiting_for(RecordTask* t) {\n // t must be a child of this task.\n if (t->thread_group()->parent() != thread_group().get()) {\n return false;\n }\n switch (in_wait_type) {\n case WAIT_TYPE_NONE:\n return false;\n case WAIT_TYPE_ANY:\n return true;\n case WAIT_TYPE_SAME_PGID:\n return getpgid(t->tgid()) == getpgid(tgid());\n case WAIT_TYPE_PGID:\n return getpgid(t->tgid()) == in_wait_pid;\n case WAIT_TYPE_PID:\n return t->tgid() == in_wait_pid;\n default:\n ASSERT(this, false);\n return false;\n }\n}\n\nvoid RecordTask::save_ptrace_signal_siginfo(const siginfo_t& si) {\n for (auto it = saved_ptrace_siginfos.begin();\n it != saved_ptrace_siginfos.end(); ++it) {\n if (it->si_signo == si.si_signo) {\n saved_ptrace_siginfos.erase(it);\n break;\n }\n }\n saved_ptrace_siginfos.push_back(si);\n}\n\nsiginfo_t& RecordTask::get_saved_ptrace_siginfo() {\n int sig = emulated_stop_code.ptrace_signal();\n ASSERT(this, sig > 0);\n for (auto it = saved_ptrace_siginfos.begin();\n it != saved_ptrace_siginfos.end(); ++it) {\n if (it->si_signo == sig) {\n return *it;\n }\n }\n ASSERT(this, false) << \"No saved siginfo found for stop-signal???\";\n while (true) {\n // Avoid having to return anything along this (unreachable) path\n }\n}\n\nsiginfo_t RecordTask::take_ptrace_signal_siginfo(int sig) {\n for (auto it = saved_ptrace_siginfos.begin();\n it != saved_ptrace_siginfos.end(); ++it) {\n if (it->si_signo == sig) {\n siginfo_t si = *it;\n saved_ptrace_siginfos.erase(it);\n return si;\n }\n }\n siginfo_t si;\n memset(&si, 0, sizeof(si));\n si.si_signo = sig;\n return si;\n}\n\nstatic pid_t get_ppid(pid_t pid) {\n auto ppid_str = read_proc_status_fields(pid, \"PPid\");\n if (ppid_str.empty()) {\n return -1;\n }\n char* end;\n int actual_ppid = strtol(ppid_str[0].c_str(), &end, 10);\n return *end ? -1 : actual_ppid;\n}\n\nvoid RecordTask::apply_group_stop(int sig) {\n if (emulated_stop_type == NOT_STOPPED) {\n LOG(debug) << \"setting \" << tid << \" to GROUP_STOP due to signal \" << sig;\n WaitStatus status = WaitStatus::for_group_sig(sig, this);\n if (!emulate_ptrace_stop(status)) {\n emulated_stop_type = GROUP_STOP;\n emulated_stop_code = status;\n emulated_stop_pending = true;\n emulated_SIGCHLD_pending = true;\n RecordTask* t = session().find_task(get_ppid(tid));\n if (t) {\n t->send_synthetic_SIGCHLD_if_necessary();\n }\n }\n }\n}\n\nbool RecordTask::is_signal_pending(int sig) {\n auto pending_strs = read_proc_status_fields(tid, \"SigPnd\", \"ShdPnd\");\n if (pending_strs.size() < 2) {\n return false;\n }\n char* end1;\n sig_set_t mask1 = strtoull(pending_strs[0].c_str(), &end1, 16);\n char* end2;\n sig_set_t mask2 = strtoull(pending_strs[1].c_str(), &end2, 16);\n return !*end1 && !*end2 && ((mask1 | mask2) & signal_bit(sig));\n}\n\nbool RecordTask::has_any_actionable_signal() {\n auto sig_strs = read_proc_status_fields(tid, \"SigPnd\", \"ShdPnd\", \"SigBlk\");\n if (sig_strs.size() < 3) {\n return false;\n }\n\n char* end1;\n uint64_t mask1 = strtoull(sig_strs[0].c_str(), &end1, 16);\n char* end2;\n uint64_t mask2 = strtoull(sig_strs[1].c_str(), &end2, 16);\n char* end3;\n uint64_t mask_blk = strtoull(sig_strs[2].c_str(), &end3, 16);\n return !*end1 && !*end2 && !*end3 && ((mask1 | mask2) & ~mask_blk);\n}\n\nvoid RecordTask::emulate_SIGCONT() {\n // All threads in the process are resumed.\n for (Task* t : thread_group()->task_set()) {\n auto rt = static_cast(t);\n LOG(debug) << \"setting \" << rt->tid << \" to NOT_STOPPED due to SIGCONT\";\n rt->clear_stashed_group_stop();\n rt->emulated_stop_pending = false;\n rt->emulated_stop_type = NOT_STOPPED;\n }\n}\n\nvoid RecordTask::signal_delivered(int sig) {\n bool needs_SIGCHLD = true;\n Sighandler& h = sighandlers->get(sig);\n if (h.resethand) {\n reset_handler(&h, arch());\n }\n\n if (is_sig_stopping(sig)) {\n // All threads in the process are stopped.\n for (Task* t : thread_group()->task_set()) {\n auto rt = static_cast(t);\n rt->apply_group_stop(sig);\n }\n // apply_group_stop calls send_synthetic_SIGCHLD_if_necessary(). Don't\n // do it again.\n needs_SIGCHLD = false;\n } else if (sig == SIGCONT && !is_sig_ignored(sig)) {\n emulate_SIGCONT();\n }\n\n if (needs_SIGCHLD) {\n send_synthetic_SIGCHLD_if_necessary();\n }\n}\n\nbool RecordTask::signal_has_user_handler(int sig) const {\n return sighandlers->get(sig).disposition() == SIGNAL_HANDLER;\n}\n\nremote_code_ptr RecordTask::get_signal_user_handler(int sig) const {\n return sighandlers->get(sig).get_user_handler();\n}\n\nconst vector& RecordTask::signal_action(int sig) const {\n return sighandlers->get(sig).sa;\n}\n\nbool RecordTask::signal_handler_takes_siginfo(int sig) const {\n return sighandlers->get(sig).takes_siginfo;\n}\n\nstatic bool is_unstoppable_signal(int sig) {\n return sig == SIGSTOP || sig == SIGKILL;\n}\n\nbool RecordTask::is_sig_blocked(int sig) {\n if (is_unstoppable_signal(sig)) {\n // These can never be blocked\n return false;\n }\n int sig_bit = sig - 1;\n return (get_sigmask() >> sig_bit) & 1;\n}\n\nbool RecordTask::is_sig_ignored(int sig) const {\n if (is_unstoppable_signal(sig)) {\n // These can never be ignored\n return false;\n }\n switch (sighandlers->get(sig).disposition()) {\n case SIGNAL_IGNORE:\n return true;\n case SIGNAL_DEFAULT:\n return IGNORE == default_action(sig);\n default:\n return false;\n }\n}\n\nbool RecordTask::is_sig_stopping(int sig) const {\n switch (sig) {\n case SIGTSTP:\n case SIGTTIN:\n case SIGTTOU:\n if (sig_disposition(sig) != SIGNAL_DEFAULT) {\n break;\n }\n RR_FALLTHROUGH;\n case SIGSTOP:\n return true;\n }\n return false;\n}\n\nSignalDisposition RecordTask::sig_disposition(int sig) const {\n return sighandlers->get(sig).disposition();\n}\n\nSignalResolvedDisposition RecordTask::sig_resolved_disposition(\n int sig, SignalDeterministic deterministic) {\n if (is_fatal_signal(sig, deterministic)) {\n return DISPOSITION_FATAL;\n }\n if (signal_has_user_handler(sig) && !is_sig_blocked(sig)) {\n return DISPOSITION_USER_HANDLER;\n }\n return DISPOSITION_IGNORED;\n}\n\nvoid RecordTask::set_siginfo(const siginfo_t& si) {\n pending_siginfo = si;\n // If this fails, the tracee is on the exit path and its siginfo\n // is irrelevant.\n ptrace_if_stopped(PTRACE_SETSIGINFO, nullptr, (void*)&si);\n}\n\ntemplate \nvoid RecordTask::update_sigaction_arch(const Registers& regs) {\n int sig = regs.orig_arg1_signed();\n remote_ptr new_sigaction = regs.arg2();\n if (0 == regs.syscall_result() && !new_sigaction.is_null()) {\n // A new sighandler was installed. Update our\n // sighandler table.\n // TODO: discard attempts to handle or ignore signals\n // that can't be by POSIX\n typename Arch::kernel_sigaction sa;\n memset(&sa, 0, sizeof(sa));\n read_bytes_helper(new_sigaction, sizeof(sa), &sa);\n sighandlers->get(sig).init_arch(sa);\n }\n}\n\nvoid RecordTask::update_sigaction(const Registers& regs) {\n RR_ARCH_FUNCTION(update_sigaction_arch, regs.arch(), regs);\n}\n\nsig_set_t RecordTask::read_sigmask_from_process() {\n // During syscall interruptions, PTRACE_GETSIGMASK may return the sigmask that is going\n // to be restored, not the kernel's current (internal) sigmask, which is what\n // /proc/.../status reports. Always go with what /proc/.../status reports. See\n // https://github.com/torvalds/linux/commit/fcfc2aa0185f4a731d05a21e9f359968fdfd02e7\n // XXXkhuey and yet that's not what we actually do here ...\n if (at_interrupted_non_restartable_signal_modifying_syscall()) {\n // Mark the sigmask as already invalid. The moment we exit the kernel and run more\n // of the tracee the sigmask will change, so we need to keep refetching the\n // sigmask until that happens.\n invalidate_sigmask();\n } else if (!at_may_restart_syscall()) {\n sig_set_t mask;\n long ret = fallible_ptrace(PTRACE_GETSIGMASK,\n remote_ptr(sizeof(sig_set_t)), &mask);\n if (ret >= 0) {\n return mask;\n }\n }\n\n auto results = read_proc_status_fields(tid, \"SigBlk\");\n if (results.empty()) {\n // Read failed, process probably died\n return 0;\n }\n ASSERT(this, results.size() == 1);\n return strtoull(results[0].c_str(), NULL, 16);\n}\n\nsig_set_t RecordTask::get_sigmask() {\n if (blocked_sigs_dirty) {\n // Clear this first, read_sigmask_from_process might set it again.\n blocked_sigs_dirty = false;\n blocked_sigs = read_sigmask_from_process();\n LOG(debug) << \"Refreshed sigmask, now \" << HEX(blocked_sigs);\n }\n return blocked_sigs;\n}\n\nvoid RecordTask::unblock_signal(int sig) {\n sig_set_t mask = get_sigmask();\n mask &= ~signal_bit(sig);\n set_sigmask(mask);\n invalidate_sigmask();\n}\n\nvoid RecordTask::set_sigmask(sig_set_t mask) {\n ASSERT(this, is_stopped_);\n int ret = fallible_ptrace(PTRACE_SETSIGMASK, remote_ptr(8), &mask);\n if (ret < 0) {\n if (errno == EIO) {\n FATAL() << \"PTRACE_SETSIGMASK not supported; rr requires Linux kernel >= 3.11\";\n }\n if (errno == ESRCH) {\n // The task has been unexpectedly killed due to SIGKILL or equivalent.\n // Just pretend we set the mask; it doesn't matter anymore.\n // Reporting this to the caller is pointless because callers still need\n // to handle the case where this function succeeds but the task\n // is unexpectedly killed immediately afterwards.\n return;\n }\n ASSERT(this, errno == EINVAL);\n }\n}\n\nvoid RecordTask::set_sig_handler_default(int sig) {\n did_set_sig_handler_default(sig);\n // This could happen during a syscallbuf untraced syscall. In that case\n // our remote syscall here could trigger a desched signal if that event\n // is armed, making progress impossible. Disarm the event now.\n disarm_desched_event(this);\n AutoRemoteSyscalls remote(this);\n Sighandler& h = sighandlers->get(sig);\n AutoRestoreMem mem(remote, h.sa.data(), h.sa.size());\n remote.infallible_syscall(syscall_number_for_rt_sigaction(arch()),\n sig, mem.get().as_int(), nullptr,\n sigaction_sigset_size(arch()));\n}\n\nvoid RecordTask::did_set_sig_handler_default(int sig) {\n Sighandler& h = sighandlers->get(sig);\n reset_handler(&h, arch());\n}\n\nvoid RecordTask::verify_signal_states() {\n#ifndef DEBUG\n return;\n#endif\n if (ev().is_syscall_event()) {\n // If the syscall event is on the event stack with PROCESSING or EXITING\n // states, we won't have applied the signal-state updates yet while the\n // kernel may have.\n return;\n }\n if (detached_proxy) {\n // This task isn't real\n return;\n }\n\n auto results = read_proc_status_fields(tid, \"SigBlk\", \"SigIgn\", \"SigCgt\");\n if (results.empty()) {\n // Read failed, process probably died\n return;\n }\n ASSERT(this, results.size() == 3);\n sig_set_t blocked = strtoull(results[0].c_str(), NULL, 16);\n sig_set_t ignored = strtoull(results[1].c_str(), NULL, 16);\n sig_set_t caught = strtoull(results[2].c_str(), NULL, 16);\n for (int sig = 1; sig < _NSIG; ++sig) {\n sig_set_t mask = signal_bit(sig);\n if (is_unstoppable_signal(sig)) {\n ASSERT(this, !(blocked & mask))\n << \"Expected \" << signal_name(sig) << \" to not be blocked, but it is\";\n ASSERT(this, !(ignored & mask))\n << \"Expected \" << signal_name(sig) << \" to not be ignored, but it is\";\n ASSERT(this, !(caught & mask))\n << \"Expected \" << signal_name(sig) << \" to not be caught, but it is\";\n } else {\n ASSERT(this, !!(blocked & mask) == is_sig_blocked(sig))\n << signal_name(sig)\n << ((blocked & mask) ? \" is blocked\" : \" is not blocked\");\n if (sig == SIGCHLD && is_container_init() && (ignored & mask)) {\n // pid-1-in-its-own-pid-namespace tasks can have their SIGCHLD set\n // to \"ignore\" when they die (in zap_pid_ns_processes). We may\n // not have observed anything relating to this death yet. We could\n // probe to ensure it's already marked as a zombie but why bother.\n // XXX arguably we should actually change our disposition here but\n // it would only matter in certain very weird cases: a vfork() where\n // the child process is pid-1 in its namespace.\n continue;\n }\n auto disposition = sighandlers->get(sig).disposition();\n ASSERT(this, !!(ignored & mask) == (disposition == SIGNAL_IGNORE))\n << signal_name(sig)\n << ((ignored & mask) ? \" is ignored\" : \" is not ignored\");\n ASSERT(this, !!(caught & mask) == (disposition == SIGNAL_HANDLER))\n << signal_name(sig)\n << ((caught & mask) ? \" is caught\" : \" is not caught\");\n }\n }\n}\n\nvoid RecordTask::stash_sig() {\n int sig = stop_sig();\n ASSERT(this, sig);\n // Callers should avoid passing SYSCALLBUF_DESCHED_SIGNAL in here.\n ASSERT(this, sig != session().syscallbuf_desched_sig());\n // multiple non-RT signals coalesce\n if (sig < SIGRTMIN) {\n for (auto it = stashed_signals.begin(); it != stashed_signals.end(); ++it) {\n if (it->siginfo.si_signo == sig) {\n LOG(debug) << \"discarding stashed signal \" << sig\n << \" since we already have one pending\";\n return;\n }\n }\n }\n\n const siginfo_t& si = get_siginfo();\n stashed_signals.push_back(StashedSignal(si, is_deterministic_signal(this), ip()));\n // Once we've stashed a signal, stop at the next traced/untraced syscall to\n // check whether we need to process the signal before it runs.\n stashed_signals_blocking_more_signals =\n break_at_syscallbuf_final_instruction =\n break_at_syscallbuf_traced_syscalls =\n break_at_syscallbuf_untraced_syscalls = true;\n syscallstub_exit_breakpoint = nullptr;\n}\n\nvoid RecordTask::stash_synthetic_sig(const siginfo_t& si,\n SignalDeterministic deterministic) {\n int sig = si.si_signo;\n DEBUG_ASSERT(sig);\n // Callers should avoid passing SYSCALLBUF_DESCHED_SIGNAL in here.\n DEBUG_ASSERT(sig != session().syscallbuf_desched_sig());\n // multiple non-RT signals coalesce\n if (sig < SIGRTMIN) {\n for (auto it = stashed_signals.begin(); it != stashed_signals.end(); ++it) {\n if (it->siginfo.si_signo == sig) {\n if (deterministic == DETERMINISTIC_SIG &&\n it->deterministic == NONDETERMINISTIC_SIG) {\n stashed_signals.erase(it);\n break;\n } else {\n LOG(debug) << \"discarding stashed signal \" << sig\n << \" since we already have one pending\";\n return;\n }\n }\n }\n }\n\n stashed_signals.insert(stashed_signals.begin(),\n StashedSignal(si, deterministic, ip()));\n stashed_signals_blocking_more_signals =\n break_at_syscallbuf_final_instruction =\n break_at_syscallbuf_traced_syscalls =\n break_at_syscallbuf_untraced_syscalls = true;\n syscallstub_exit_breakpoint = nullptr;\n}\n\nbool RecordTask::has_stashed_sig(int sig) const {\n for (auto it = stashed_signals.begin(); it != stashed_signals.end(); ++it) {\n if (it->siginfo.si_signo == sig) {\n return true;\n }\n }\n return false;\n}\n\nconst RecordTask::StashedSignal* RecordTask::stashed_sig_not_synthetic_SIGCHLD() const {\n for (auto it = stashed_signals.begin(); it != stashed_signals.end(); ++it) {\n if (!is_synthetic_SIGCHLD(it->siginfo)) {\n return &*it;\n }\n }\n return nullptr;\n}\n\nvoid RecordTask::pop_stash_sig(const StashedSignal* stashed) {\n for (auto it = stashed_signals.begin(); it != stashed_signals.end(); ++it) {\n if (&*it == stashed) {\n stashed_signals.erase(it);\n return;\n }\n }\n ASSERT(this, false) << \"signal not found\";\n}\n\nvoid RecordTask::stashed_signal_processed() {\n break_at_syscallbuf_final_instruction = break_at_syscallbuf_traced_syscalls =\n break_at_syscallbuf_untraced_syscalls =\n stashed_signals_blocking_more_signals = has_stashed_sig();\n syscallstub_exit_breakpoint = nullptr;\n}\n\nconst RecordTask::StashedSignal* RecordTask::peek_stashed_sig_to_deliver()\n const {\n if (stashed_signals.empty()) {\n return nullptr;\n }\n // Choose the first non-synthetic-SIGCHLD signal so that if a syscall should\n // be interrupted, we'll interrupt it.\n for (auto& sig : stashed_signals) {\n if (!is_synthetic_SIGCHLD(sig.siginfo)) {\n return &sig;\n }\n }\n return &stashed_signals[0];\n}\n\nbool RecordTask::is_syscall_restart() {\n if (EV_SYSCALL_INTERRUPTION != ev().type()) {\n return false;\n }\n\n int syscallno = regs().original_syscallno();\n SupportedArch syscall_arch = ev().Syscall().arch();\n string call_name = syscall_name(syscallno, syscall_arch);\n bool is_restart = false;\n LOG(debug) << \" is syscall interruption of recorded \" << ev() << \"? (now \"\n << call_name << \")\";\n\n /* It's possible for the tracee to resume after a sighandler\n * with a fresh syscall that happens to be the same as the one\n * that was interrupted. So we check here if the args are the\n * same.\n *\n * Of course, it's possible (but less likely) for the tracee\n * to incidentally resume with a fresh syscall that just\n * happens to have the same *arguments* too. But in that\n * case, we would usually set up scratch buffers etc the same\n * was as for the original interrupted syscall, so we just\n * save a step here.\n *\n * TODO: it's possible for arg structures to be mutated\n * between the original call and restarted call in such a way\n * that it might change the scratch allocation decisions. */\n if (is_restart_syscall_syscall(syscallno, syscall_arch)) {\n is_restart = true;\n syscallno = ev().Syscall().number;\n LOG(debug) << \" (SYS_restart_syscall)\";\n }\n if (ev().Syscall().number != syscallno) {\n LOG(debug) << \" interrupted \" << ev() << \" != \" << call_name;\n goto done;\n }\n\n {\n const Registers& old_regs = ev().Syscall().regs;\n if (!(old_regs.orig_arg1() == regs().arg1() &&\n old_regs.arg2() == regs().arg2() &&\n old_regs.arg3() == regs().arg3() &&\n old_regs.arg4() == regs().arg4() &&\n old_regs.arg5() == regs().arg5() &&\n old_regs.arg6() == regs().arg6())) {\n LOG(debug) << \" regs different at interrupted \" << call_name << \": \"\n << old_regs << \" vs \" << regs();\n goto done;\n }\n }\n\n is_restart = true;\n\ndone:\n if (is_restart) {\n LOG(debug) << \" restart of \" << call_name;\n }\n return is_restart;\n}\n\ntemplate \nstatic uint64_t read_ptr_arch(Task* t, remote_ptr p, bool* ok) {\n return t->read_mem(p.cast(), ok);\n}\n\nstatic uint64_t read_ptr(Task* t, remote_ptr p, bool* ok) {\n RR_ARCH_FUNCTION(read_ptr_arch, t->arch(), t, p, ok);\n}\n\nbool RecordTask::is_in_syscallbuf() {\n if (!as->syscallbuf_enabled()) {\n // Even if we're in the rr page, if syscallbuf isn't enabled then the\n // rr page is not being used by syscallbuf.\n return false;\n }\n remote_code_ptr p = ip();\n if (is_in_rr_page() || (syscallbuf_code_layout.get_pc_thunks_start <= p &&\n p < syscallbuf_code_layout.get_pc_thunks_end)) {\n // Look at the caller to see if we're in the syscallbuf or not.\n bool ok = true;\n uint64_t addr;\n if (arch() == aarch64) {\n addr = regs().x(30);\n }\n else {\n ASSERT(this, is_x86ish(arch())) << \"Unknown architecture\";\n addr = read_ptr(this, regs().sp(), &ok);\n }\n if (ok) {\n p = addr;\n }\n }\n return as->monkeypatcher().is_jump_stub_instruction(p, false) ||\n (syscallbuf_code_layout.syscallbuf_code_start <= p &&\n p < syscallbuf_code_layout.syscallbuf_code_end);\n}\n\nbool RecordTask::at_may_restart_syscall() const {\n ssize_t depth = pending_events.size();\n const Event* prev_ev = depth > 2 ? &pending_events[depth - 2] : nullptr;\n return EV_SYSCALL_INTERRUPTION == ev().type() ||\n (EV_SIGNAL_DELIVERY == ev().type() && prev_ev &&\n EV_SYSCALL_INTERRUPTION == prev_ev->type());\n}\n\nbool RecordTask::at_interrupted_non_restartable_signal_modifying_syscall() const {\n auto r = regs();\n // XXXkhuey io_uring_enter (not yet supported) can do this too.\n return r.syscall_result_signed() == -EINTR &&\n (is_epoll_pwait_syscall(r.original_syscallno(), arch()) ||\n is_epoll_pwait2_syscall(r.original_syscallno(), arch()));\n}\n\nbool RecordTask::is_arm_desched_event_syscall() {\n return is_desched_event_syscall() && PERF_EVENT_IOC_ENABLE == regs().arg2();\n}\n\nbool RecordTask::is_disarm_desched_event_syscall() {\n return (is_desched_event_syscall() &&\n PERF_EVENT_IOC_DISABLE == regs().arg2());\n}\n\nbool RecordTask::may_be_blocked() const {\n return (EV_SYSCALL == ev().type() &&\n PROCESSING_SYSCALL == ev().Syscall().state) ||\n emulated_stop_type != NOT_STOPPED ||\n (EV_SIGNAL_DELIVERY == ev().type() &&\n DISPOSITION_FATAL == ev().Signal().disposition) ||\n waiting_for_ptrace_exit;\n}\n\nbool RecordTask::maybe_in_spinlock() {\n return time_at_start_of_last_timeslice == session().trace_writer().time() &&\n regs().matches(registers_at_start_of_last_timeslice);\n}\n\nremote_ptr RecordTask::desched_rec() const {\n return (ev().is_syscall_event()\n ? ev().Syscall().desched_rec\n : (EV_DESCHED == ev().type()) ? ev().Desched().rec : nullptr);\n}\n\nbool RecordTask::running_inside_desched() const {\n for (auto& e : pending_events) {\n if (e.type() == EV_DESCHED) {\n return e.Desched().rec != desched_rec();\n }\n }\n return false;\n}\n\nint RecordTask::get_ptrace_eventmsg_seccomp_data() {\n unsigned long data = 0;\n // in theory we could hit an assertion failure if the tracee suffers\n // a SIGKILL before we get here. But the SIGKILL would have to be\n // precisely timed between the generation of a PTRACE_EVENT_FORK/CLONE/\n // SYS_clone event, and us fetching the event message here.\n if (fallible_ptrace(PTRACE_GETEVENTMSG, nullptr, &data) < 0) {\n ASSERT(this, errno == ESRCH);\n return -1;\n }\n return data;\n}\n\nvoid RecordTask::record_local(remote_ptr addr, ssize_t num_bytes,\n const void* data) {\n ASSERT(this, num_bytes >= 0);\n\n if (!addr) {\n return;\n }\n\n trace_writer().write_raw(rec_tid, data, num_bytes, addr);\n}\n\nbool RecordTask::record_remote_by_local_map(remote_ptr addr,\n size_t num_bytes) {\n if (uint8_t* local_addr = as->local_mapping(addr, num_bytes)) {\n record_local(addr, num_bytes, local_addr);\n return true;\n }\n return false;\n}\n\nvoid RecordTask::record_remote(remote_ptr addr, ssize_t num_bytes,\n MemWriteSizeValidation size_validation) {\n ASSERT(this, num_bytes >= 0);\n\n if (!addr) {\n return;\n }\n\n if (record_remote_by_local_map(addr, num_bytes) != 0) {\n return;\n }\n\n bool ok = true;\n auto buf = read_mem(addr.cast(), num_bytes, &ok);\n if (!ok) {\n // Tracee probably died unexpectedly. This should only happen\n // due to SIGKILL racing with our PTRACE_CONT.\n if (!vm()->find_other_thread_group(this) &&\n vm()->range_is_private_mapping(MemoryRange(addr, num_bytes))) {\n // The recording range is mapped private and no other threadgroup shares the\n // address space, so the new memory contents should be unobservable, and we can\n // just not record the data.\n return;\n }\n ASSERT(this, false) << \"Should have recorded \" << num_bytes << \" bytes from \"\n << addr << \", but failed\";\n }\n trace_writer().write_raw(rec_tid, buf.data(), num_bytes, addr, size_validation);\n}\n\nvoid RecordTask::record_remote_writable(remote_ptr addr, ssize_t num_bytes,\n MemWriteSizeValidation size_validation) {\n ASSERT(this, num_bytes >= 0);\n\n remote_ptr p = addr;\n bool seen_rr_mapping = false;\n int mapping_count = 0;\n while (p < addr + num_bytes) {\n if (!as->has_mapping(p)) {\n break;\n }\n ++mapping_count;\n auto m = as->mapping_of(p);\n if (m.flags) {\n seen_rr_mapping = true;\n }\n if (!(m.map.prot() & PROT_WRITE) ||\n (seen_rr_mapping && mapping_count > 1)) {\n break;\n }\n p = m.map.end();\n }\n num_bytes = min(num_bytes, p - addr);\n\n record_remote(addr, num_bytes, size_validation);\n}\n\nssize_t RecordTask::record_remote_fallible(remote_ptr addr,\n uintptr_t num_bytes,\n const std::vector& holes) {\n auto hole_iter = holes.begin();\n uintptr_t offset = 0;\n vector buf;\n while (offset < num_bytes) {\n if (hole_iter != holes.end() && hole_iter->offset == offset) {\n offset += hole_iter->size;\n ++hole_iter;\n continue;\n }\n\n uintptr_t bytes = min(uintptr_t(4*1024*1024), num_bytes - offset);\n if (hole_iter != holes.end()) {\n ASSERT(this, hole_iter->offset > offset);\n bytes = min(bytes, uintptr_t(hole_iter->offset) - offset);\n }\n if (record_remote_by_local_map(addr + offset, bytes)) {\n offset += bytes;\n continue;\n }\n\n if (addr) {\n buf.resize(bytes);\n ssize_t nread = read_bytes_fallible(addr + offset, bytes, buf.data());\n if (nread <= 0) {\n break;\n }\n trace_writer().write_raw_data(buf.data(), nread);\n offset += nread;\n } else {\n offset += bytes;\n }\n }\n trace_writer().write_raw_header(rec_tid, offset, addr, holes);\n return offset;\n}\n\nvoid RecordTask::record_remote_even_if_null(remote_ptr addr,\n ssize_t num_bytes) {\n DEBUG_ASSERT(num_bytes >= 0);\n\n if (!addr) {\n trace_writer().write_raw(rec_tid, nullptr, 0, addr);\n return;\n }\n\n if (record_remote_by_local_map(addr, num_bytes) != 0) {\n return;\n }\n\n auto buf = read_mem(addr.cast(), num_bytes);\n trace_writer().write_raw(rec_tid, buf.data(), num_bytes, addr);\n}\n\nvoid RecordTask::pop_event(EventType expected_type) {\n ASSERT(this, pending_events.back().type() == expected_type);\n pending_events.pop_back();\n}\n\nvoid RecordTask::log_pending_events() const {\n ssize_t depth = pending_events.size();\n\n DEBUG_ASSERT(depth > 0);\n if (1 == depth) {\n LOG(info) << \"(no pending events)\";\n return;\n }\n\n /* The event at depth 0 is the placeholder event, which isn't\n * useful to log. Skip it. */\n for (auto it = pending_events.rbegin(); it != pending_events.rend(); ++it) {\n LOG(info) << *it;\n }\n}\n\ntemplate \nstatic void maybe_handle_set_robust_list_arch(RecordTask* t) {\n auto remote_locals = AddressSpace::preload_thread_locals_start()\n .cast>();\n if (!remote_locals) {\n return;\n }\n auto robust_list_ptr = REMOTE_PTR_FIELD(remote_locals, robust_list);\n auto robust_list = t->read_mem(robust_list_ptr);\n if (robust_list.len) {\n t->set_robust_list(robust_list.head.rptr(), robust_list.len);\n\n auto robust_list_len_ptr = REMOTE_PTR_FIELD(robust_list_ptr, len);\n t->write_mem(robust_list_len_ptr, static_cast(0));\n robust_list.len = 0;\n t->record_local(robust_list_len_ptr, &robust_list.len);\n }\n}\n\nstatic void maybe_handle_set_robust_list(RecordTask* t) {\n RR_ARCH_FUNCTION(maybe_handle_set_robust_list_arch, t->arch(), t);\n}\n\ntemplate \nstatic void maybe_handle_rseq_arch(RecordTask* t) {\n auto remote_locals = AddressSpace::preload_thread_locals_start()\n .cast>();\n if (!remote_locals) {\n return;\n }\n auto rseq_ptr = REMOTE_PTR_FIELD(remote_locals, rseq);\n auto rseq = t->read_mem(rseq_ptr);\n if (rseq.len) {\n t->rseq_state = make_unique(rseq.rseq.rptr(), rseq.sig);\n\n auto rseq_len_ptr = REMOTE_PTR_FIELD(rseq_ptr, len);\n t->write_mem(rseq_len_ptr, static_cast(0));\n rseq.len = 0;\n t->record_local(rseq_len_ptr, &rseq.len);\n }\n}\n\nstatic void maybe_handle_rseq(RecordTask* t) {\n RR_ARCH_FUNCTION(maybe_handle_rseq_arch, t->arch(), t);\n}\n\nvoid RecordTask::maybe_flush_syscallbuf() {\n if (EV_SYSCALLBUF_FLUSH == ev().type()) {\n // Already flushing.\n return;\n }\n if (!syscallbuf_child) {\n return;\n }\n\n // This can be called while the task is not stopped, when we prematurely\n // terminate the trace. In that case, the tracee could be concurrently\n // modifying the header. We'll take a snapshot of the header now.\n // The syscallbuf code ensures that writes to syscallbuf records\n // complete before num_rec_bytes is incremented.\n struct syscallbuf_hdr hdr = read_mem(syscallbuf_child);\n\n ASSERT(this,\n !flushed_syscallbuf || flushed_num_rec_bytes == hdr.num_rec_bytes);\n\n if (!hdr.num_rec_bytes || flushed_syscallbuf) {\n // no records, or we've already flushed.\n return;\n }\n\n push_event(Event(SyscallbufFlushEvent()));\n\n // Apply buffered mprotect operations and flush the buffer in the tracee.\n if (hdr.mprotect_record_count) {\n auto& records = ev().SyscallbufFlush().mprotect_records;\n records = read_mem(REMOTE_PTR_FIELD(preload_globals, mprotect_records[0]),\n hdr.mprotect_record_count);\n for (auto& r : records) {\n as->protect(this, r.start, r.size, r.prot);\n }\n }\n\n // Write the entire buffer in one shot without parsing it,\n // because replay will take care of that.\n if (is_stopped()) {\n record_remote(syscallbuf_child, syscallbuf_data_size());\n } else {\n vector buf;\n buf.resize(sizeof(hdr) + hdr.num_rec_bytes);\n memcpy(buf.data(), &hdr, sizeof(hdr));\n read_bytes_helper(syscallbuf_child + 1, hdr.num_rec_bytes,\n buf.data() + sizeof(hdr));\n record_local(syscallbuf_child, buf.size(), buf.data());\n }\n maybe_handle_rseq(this);\n maybe_handle_set_robust_list(this);\n\n record_current_event();\n pop_event(EV_SYSCALLBUF_FLUSH);\n\n flushed_syscallbuf = true;\n flushed_num_rec_bytes = hdr.num_rec_bytes;\n\n LOG(debug) << \"Syscallbuf flushed with num_rec_bytes=\"\n << (uint32_t)hdr.num_rec_bytes;\n}\n\n/**\n * If the syscallbuf has just been flushed, and resetting hasn't been\n * overridden with a delay request, then record the reset event for\n * replay.\n */\nvoid RecordTask::maybe_reset_syscallbuf() {\n if (flushed_syscallbuf && !delay_syscallbuf_reset_for_desched &&\n !delay_syscallbuf_reset_for_seccomp_trap) {\n flushed_syscallbuf = false;\n LOG(debug) << \"Syscallbuf reset\";\n reset_syscallbuf();\n syscallbuf_blocked_sigs_generation = 0;\n record_event(Event::syscallbuf_reset());\n }\n}\n\nvoid RecordTask::record_event(Event ev, FlushSyscallbuf flush,\n AllowSyscallbufReset reset,\n const Registers* registers) {\n if (flush == FLUSH_SYSCALLBUF) {\n maybe_flush_syscallbuf();\n }\n\n FrameTime current_time = trace_writer().time();\n if (should_dump_memory(ev, current_time)) {\n dump_process_memory(this, current_time, \"rec\");\n }\n if (should_checksum(ev, current_time)) {\n checksum_process_memory(this, current_time);\n }\n if (!ev.has_ticks_slop()) {\n // Only associate PT data with events whose timing is\n // exactly the same between recording and replay.\n PTData pt_data = hpc.extract_intel_pt_data();\n if (!pt_data.data.empty()) {\n write_pt_data(this, current_time, pt_data.data);\n }\n }\n\n if (trace_writer().clear_fip_fdp()) {\n const ExtraRegisters* maybe_extra = extra_regs_fallible();\n if (maybe_extra) {\n ExtraRegisters extra_registers = *maybe_extra;\n extra_registers.clear_fip_fdp();\n set_extra_regs(extra_registers);\n }\n }\n\n const ExtraRegisters* extra_registers = nullptr;\n if (ev.record_regs()) {\n if (!registers) {\n registers = ®s();\n }\n if (ev.record_extra_regs()) {\n extra_registers = extra_regs_fallible();\n }\n }\n\n if (ev.is_syscall_event()) {\n auto state = ev.Syscall().state;\n if (state == EXITING_SYSCALL) {\n ticks_at_last_recorded_syscall_exit = tick_count();\n ip_at_last_recorded_syscall_exit = registers->ip();\n if (ticks_at_last_recorded_syscall_exit == ticks_at_last_syscall_entry &&\n ip_at_last_recorded_syscall_exit == ip_at_last_syscall_entry) {\n // We've done processing this syscall so we can forget about the entry now\n // This makes sure that any restarted syscalls would not be treated\n // as the same entry.\n ticks_at_last_syscall_entry = 0;\n ip_at_last_syscall_entry = nullptr;\n last_syscall_entry_recorded = false;\n }\n } else if (state == ENTERING_SYSCALL || state == ENTERING_SYSCALL_PTRACE) {\n if (tick_count() == ticks_at_last_syscall_entry &&\n registers->ip() == ip_at_last_syscall_entry) {\n // Let the process handler know that we've recorded the entry already\n last_syscall_entry_recorded = true;\n }\n }\n }\n\n remote_code_ptr rseq_new_ip = ip();\n bool invalid_rseq_cs = false;\n if (should_apply_rseq_abort(ev.type(), &rseq_new_ip, &invalid_rseq_cs)) {\n auto addr = REMOTE_PTR_FIELD(rseq_state->ptr.cast(), rseq_cs);\n uint64_t value = 0;\n write_mem(addr, value);\n record_local(addr, &value);\n } else {\n ASSERT(this, !invalid_rseq_cs) << \"Invalid rseq_cs found, not currently emulated properly by rr (should segfault)\";\n }\n\n trace_writer().write_frame(this, ev, registers, extra_registers);\n LOG(debug) << \"Wrote event \" << ev << \" for time \" << current_time;\n\n if (rseq_new_ip != ip()) {\n Registers r = regs();\n r.set_ip(rseq_new_ip);\n set_regs(r);\n }\n\n if (!ev.has_ticks_slop() && reset == ALLOW_RESET_SYSCALLBUF) {\n // After we've output an event, it's safe to reset the syscallbuf (if not\n // explicitly delayed) since we will have exited the syscallbuf code that\n // consumed the syscallbuf data.\n // This only works if the event has a reliable tick count so when we\n // reach it, we're done.\n maybe_reset_syscallbuf();\n }\n}\n\nbool RecordTask::is_fatal_signal(int sig,\n SignalDeterministic deterministic) const {\n if (thread_group()->received_sigframe_SIGSEGV) {\n // Can't be blocked, caught or ignored\n return true;\n }\n\n auto action = default_action(sig);\n if (action != DUMP_CORE && action != TERMINATE) {\n // If the default action doesn't kill the process, it won't die.\n return false;\n }\n\n if (is_sig_ignored(sig)) {\n // Deterministic fatal signals can't be ignored.\n return deterministic == DETERMINISTIC_SIG;\n }\n // If there's a signal handler, the signal won't be fatal.\n return !signal_has_user_handler(sig);\n}\n\nvoid RecordTask::record_current_event() { record_event(ev()); }\n\nvoid RecordTask::set_tid_addr(remote_ptr tid_addr) {\n LOG(debug) << \"updating cleartid futex to \" << tid_addr;\n tid_futex = tid_addr;\n}\n\nvoid RecordTask::update_own_namespace_tid() {\n AutoRemoteSyscalls remote(this);\n own_namespace_rec_tid =\n remote.infallible_syscall_if_alive(syscall_number_for_gettid(arch()));\n if (own_namespace_rec_tid == -ESRCH) {\n own_namespace_rec_tid = -1;\n }\n}\n\nvoid RecordTask::kill_if_alive() {\n if (!seen_ptrace_exit_event()) {\n tgkill(SIGKILL);\n }\n}\n\npid_t RecordTask::get_parent_pid() const { return get_ppid(tid); }\n\nvoid RecordTask::set_tid_and_update_serial(pid_t tid,\n pid_t own_namespace_tid) {\n hpc.set_tid(tid);\n this->tid = rec_tid = tid;\n serial = session().next_task_serial();\n own_namespace_rec_tid = own_namespace_tid;\n}\n\nbool RecordTask::may_reap() {\n if (emulated_stop_pending) {\n LOG(debug) << \"Declining to reap \" << tid << \"; emulated stop pending \" << emulated_stop_code;\n // Don't reap until the emulated ptrace stop has been processed.\n return false;\n }\n // Non thread-group-leaders may always be reaped\n if (tid != real_tgid()) {\n return true;\n }\n for (auto it : thread_group()->task_set()) {\n if (&*it != this) {\n LOG(debug) << \"Declining to reap \" << tid << \"; leader of non-empty thread-group with active thread \" << it->tid;\n return false;\n }\n }\n return true;\n}\n\nvoid RecordTask::reap() {\n ASSERT(this, !was_reaped_);\n LOG(debug) << \"Reaping \" << tid;\n WaitOptions options(tid);\n options.block_seconds = 0;\n WaitManager::wait_exit(options);\n was_reaped_ = true;\n}\n\nstatic uint64_t read_pid_ns(const RecordTask* t) {\n char buf[PATH_MAX];\n sprintf(buf, \"/proc/%d/ns/pid\", t->tid);\n char link[PATH_MAX];\n int ret = readlink(buf, link, sizeof(link));\n ASSERT(t, ret >= 0);\n ASSERT(t, ret < (int)sizeof(link));\n link[ret] = 0;\n ASSERT(t, strncmp(link, \"pid:[\", 5) == 0);\n char* end;\n uint64_t result = strtoul(link + 5, &end, 10);\n ASSERT(t, strcmp(end, \"]\") == 0);\n return result;\n}\n\nbool RecordTask::waiting_for_pid_namespace_tasks_to_exit() const {\n // read_pid_ns() will fail if we're reaped\n if (tg->tgid_own_namespace != 1 || was_reaped()) {\n return false;\n }\n // This might be the last live thread for pid-1 in the pid namespace.\n // Checking that it *is* the last live thread is tricky because other\n // threads could unexpectedly die asynchronously :-(.\n // See if there are any other tasks in the pid namespace.\n // Note that due to setns there can be tasks in the pid namespace\n // with parents outside the pid namespace other than our thread-group.\n\n // If there are multiple threads in our threadgroup, they're in our\n // pid namespace.\n if (thread_group()->task_set().size() > 1) {\n return true;\n }\n // If we have any child processes then those belong to our pid namespace\n // (or a descendant).\n for (auto p : session().thread_group_map()) {\n if (p.second->parent() == tg.get()) {\n return true;\n }\n }\n // If there are any other tasks in the pid namespace at least one must be\n // directly in the namespace.\n uint64_t pid_ns = read_pid_ns(this);\n for (auto it : session().tasks()) {\n auto rt = static_cast(it.second);\n if (rt == this) {\n continue;\n }\n if (read_pid_ns(rt) == pid_ns) {\n return true;\n }\n }\n return false;\n}\n\n// Disable chaos mode memory randomization for 32-bit ASAN builds. There isn't\n// much address space to play with and it gets tricky.\nbool RecordTask::enable_chaos_memory_allocations() const {\n return session().enable_chaos() &&\n !as->layout_randomization_disabled() &&\n (session().excluded_ranges().empty() || word_size(arch()) >= 8);\n}\n\nint RecordTask::process_depth() const {\n int depth = 0;\n ThreadGroup* tg = this->tg.get();\n while (tg) {\n ++depth;\n tg = tg->parent();\n }\n return depth;\n}\n\ntemplate \nstatic void maybe_restore_original_syscall_registers_arch(RecordTask* t,\n void* local_addr) {\n if (!local_addr) {\n return;\n }\n auto locals = reinterpret_cast*>(local_addr);\n static_assert(sizeof(*locals) <= PRELOAD_THREAD_LOCALS_SIZE,\n \"bad PRELOAD_THREAD_LOCALS_SIZE\");\n if (!locals->original_syscall_parameters) {\n return;\n }\n auto args = t->read_mem(locals->original_syscall_parameters.rptr());\n Registers r = t->regs();\n if (args.no != r.syscallno()) {\n // Maybe a preparatory syscall before the real syscall (e.g. sys_read)\n return;\n }\n r.set_arg1(args.args[0]);\n r.set_arg2(args.args[1]);\n r.set_arg3(args.args[2]);\n r.set_arg4(args.args[3]);\n r.set_arg5(args.args[4]);\n r.set_arg6(args.args[5]);\n t->set_regs(r);\n}\n\nvoid RecordTask::maybe_restore_original_syscall_registers() {\n RR_ARCH_FUNCTION(maybe_restore_original_syscall_registers_arch, arch(), this,\n preload_thread_locals());\n}\n\nbool RecordTask::post_vm_clone(CloneReason reason, int flags, Task* origin) {\n if (Task::post_vm_clone(reason, flags, origin)) {\n KernelMapping preload_thread_locals_mapping =\n vm()->mapping_of(AddressSpace::preload_thread_locals_start()).map;\n auto mode = trace_writer().write_mapped_region(\n this, preload_thread_locals_mapping,\n preload_thread_locals_mapping.fake_stat(),\n preload_thread_locals_mapping.fsname(),\n vector(),\n TraceWriter::RR_BUFFER_MAPPING);\n ASSERT(this, mode == TraceWriter::DONT_RECORD_IN_TRACE);\n return true;\n }\n\n return false;\n};\n\nbool RecordTask::try_grow_map(remote_ptr addr) {\n if (vm()->has_mapping(addr)) {\n LOG(debug) << \"try_grow_map \" << addr << \": address already mapped\";\n return false;\n }\n auto maps = vm()->maps_starting_at(floor_page_size(addr));\n auto it = maps.begin();\n if (it == maps.end()) {\n LOG(debug) << \"try_grow_map \" << addr << \": no later map to grow downward\";\n return false;\n }\n if (!(it->map.flags() & MAP_GROWSDOWN)) {\n LOG(debug) << \"try_grow_map \" << addr << \": map is not MAP_GROWSDOWN (\"\n << it->map << \")\";\n return false;\n }\n if (addr >= page_size() && vm()->has_mapping(addr - page_size())) {\n LOG(debug) << \"try_grow_map \" << addr << \": address would be in guard page\";\n return false;\n }\n remote_ptr limit_bottom;\n#if defined (__i386__)\n struct rlimit stack_limit;\n int ret = prlimit(tid, RLIMIT_STACK, NULL, &stack_limit);\n#else\n struct rlimit64 stack_limit;\n int ret = syscall(__NR_prlimit64, tid, RLIMIT_STACK, (void*)0, &stack_limit);\n#endif\n if (ret >= 0 && stack_limit.rlim_cur != RLIM_INFINITY) {\n limit_bottom = ceil_page_size(it->map.end() - stack_limit.rlim_cur);\n if (limit_bottom > addr) {\n LOG(debug) << \"try_grow_map \" << addr << \": RLIMIT_STACK exceeded\";\n return false;\n }\n }\n\n // Try to grow by 64K at a time to reduce signal frequency.\n auto new_start = floor_page_size(addr);\n static const uintptr_t grow_size = 0x10000;\n if (it->map.start().as_int() >= grow_size) {\n auto possible_new_start = std::max(\n limit_bottom, std::min(new_start, it->map.start() - grow_size));\n // Ensure that no mapping exists between possible_new_start - page_size()\n // and new_start. If there is, possible_new_start is not valid, in which\n // case we just abandon the optimization.\n if (possible_new_start >= page_size() &&\n !vm()->has_mapping(possible_new_start - page_size()) &&\n vm()->maps_starting_at(possible_new_start - page_size())\n .begin()\n ->map.start() == it->map.start()) {\n new_start = possible_new_start;\n }\n }\n LOG(debug) << \"try_grow_map \" << addr << \": trying to grow map \" << it->map;\n\n {\n AutoRemoteSyscalls remote(this, AutoRemoteSyscalls::DISABLE_MEMORY_PARAMS);\n remote.infallible_mmap_syscall_if_alive(\n new_start, it->map.start() - new_start, it->map.prot(),\n (it->map.flags() & ~MAP_GROWSDOWN) | MAP_ANONYMOUS | MAP_FIXED, -1, 0);\n }\n\n KernelMapping km =\n vm()->map(this, new_start, it->map.start() - new_start, it->map.prot(),\n it->map.flags() | MAP_ANONYMOUS, 0, string(),\n KernelMapping::NO_DEVICE, KernelMapping::NO_INODE);\n trace_writer().write_mapped_region(this, km, km.fake_stat(), km.fsname(), vector());\n // No need to flush syscallbuf here. It's safe to map these pages \"early\"\n // before they're really needed.\n record_event(Event::grow_map(), RecordTask::DONT_FLUSH_SYSCALLBUF);\n LOG(debug) << \"try_grow_map \" << addr << \": extended map \"\n << vm()->mapping_of(addr).map;\n return true;\n}\n\n} // namespace rr\n" }, { "path": "src/RecordTask.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_RECORD_TASK_H_\n#define RR_RECORD_TASK_H_\n\n#include \"ContextSwitchEvent.h\"\n#include \"Registers.h\"\n#include \"Task.h\"\n#include \"TraceFrame.h\"\n\nnamespace rr {\n\nstruct Sighandlers;\nclass TaskSyscallStateBase {\npublic:\n virtual ~TaskSyscallStateBase() {}\n};\n\n/** Different kinds of waits a task can do.\n */\nenum WaitType {\n // Not waiting for anything\n WAIT_TYPE_NONE,\n // Waiting for any child process\n WAIT_TYPE_ANY,\n // Waiting for any child with the same process group ID\n WAIT_TYPE_SAME_PGID,\n // Waiting for any child with a specific process group ID\n WAIT_TYPE_PGID,\n // Waiting for a specific process ID\n WAIT_TYPE_PID\n};\n\n/** Reasons why we simulate stopping of a task (see ptrace(2) man page).\n */\nenum EmulatedStopType {\n NOT_STOPPED,\n GROUP_STOP, // stopped by a signal. This applies to non-ptracees too.\n SIGNAL_DELIVERY_STOP,// Stopped before delivering a signal. ptracees only.\n SYSCALL_ENTRY_STOP, // Stopped at syscall entry. ptracees only\n SYSCALL_EXIT_STOP, // Stopped at syscall exit. ptracees only\n SECCOMP_STOP, // Stopped at seccomp stop. ptracees only\n CHILD_STOP // All other kinds of non-ptrace stops\n};\n\n/**\n * Pass USE_SYSGOOD to emulate_ptrace_stop to add 0x80 to the signal\n * if PTRACE_O_TRACESYSGOOD is in effect.\n */\nenum AddSysgoodFlag { IGNORE_SYSGOOD, USE_SYSGOOD };\n\nstruct SyscallbufCodeLayout {\n remote_code_ptr syscallbuf_code_start;\n remote_code_ptr syscallbuf_code_end;\n remote_code_ptr get_pc_thunks_start;\n remote_code_ptr get_pc_thunks_end;\n remote_code_ptr syscallbuf_syscall_hook;\n remote_code_ptr syscallbuf_final_exit_instruction;\n};\n\nenum SignalDisposition { SIGNAL_DEFAULT, SIGNAL_IGNORE, SIGNAL_HANDLER };\n\n/**\n * Every Task owned by a RecordSession is a RecordTask. Functionality that\n * only applies during recording belongs here.\n */\nclass RecordTask final : public Task {\npublic:\n RecordTask(RecordSession& session, pid_t _tid, uint32_t serial,\n SupportedArch a);\n\n Task* clone(CloneReason reason, int flags, remote_ptr stack,\n remote_ptr tls, remote_ptr cleartid_addr,\n pid_t new_tid, pid_t new_rec_tid, uint32_t new_serial,\n Session* other_session = nullptr,\n FdTable::shr_ptr new_fds = nullptr,\n ThreadGroup::shr_ptr new_tg = nullptr) override;\n virtual void post_wait_clone(Task* cloned_from, int flags) override;\n virtual void on_syscall_exit(int syscallno, SupportedArch arch,\n const Registers& regs) override;\n virtual void will_resume_execution(ResumeRequest, WaitRequest, TicksRequest,\n int /*sig*/) override;\n virtual void did_wait() override;\n\n bool enable_chaos_memory_allocations() const;\n\n std::vector syscallbuf_syscall_entry_breakpoints();\n bool is_at_syscallbuf_syscall_entry_breakpoint();\n bool is_at_syscallbuf_final_instruction_breakpoint();\n bool is_at_syscallstub_exit_breakpoint();\n\n /**\n * Initialize tracee buffers in this, i.e., implement\n * RRCALL_init_syscall_buffer. This task must be at the point\n * of *exit from* the rrcall. Registers will be updated with\n * the return value from the rrcall, which is also returned\n * from this call.\n */\n void init_buffers();\n void post_exec();\n /**\n * Called when SYS_rrcall_init_preload has happened.\n */\n virtual void at_preload_init() override;\n\n RecordSession& session() const;\n TraceWriter& trace_writer() const;\n\n /**\n * Emulate 'tracer' ptracing this task.\n */\n void set_emulated_ptracer(RecordTask* tracer);\n /**\n * Call this when an event occurs that should stop a ptraced task.\n * If we're emulating ptrace of the task, stop the task and wake the ptracer\n * if it's waiting, and queue \"status\" to be reported to the\n * ptracer. If siginfo is non-null, we'll report that siginfo, otherwise we'll\n * make one up based on the status (unless the status is an exit code).\n * Returns true if the task is stopped-for-emulated-ptrace, false otherwise.\n */\n bool emulate_ptrace_stop(WaitStatus status,\n const siginfo_t* siginfo = nullptr, int si_code = 0) {\n return emulate_ptrace_stop(status, status.group_stop() ? GROUP_STOP : SIGNAL_DELIVERY_STOP,\n siginfo, si_code);\n }\n bool emulate_ptrace_stop(WaitStatus status, EmulatedStopType stop_type,\n const siginfo_t* siginfo = nullptr, int si_code = 0);\n\n /**\n * Force the ptrace-stop state no matter what state the task is currently in.\n */\n void force_emulate_ptrace_stop(WaitStatus status, EmulatedStopType stop_type);\n /**\n * If necessary, signal the ptracer that this task has exited.\n */\n void do_ptrace_exit_stop(WaitStatus exit_status);\n\n void record_exit_trace_event(WaitStatus exit_status);\n /**\n * Return the exit event.\n * If write_child_tid is set, zero out child_tid now if applicable.\n */\n enum WriteChildTid {\n KERNEL_WRITES_CHILD_TID,\n WRITE_CHILD_TID,\n };\n void record_exit_event(WriteChildTid write_child_tid = KERNEL_WRITES_CHILD_TID);\n /**\n * Called when we're about to deliver a signal to this task. If it's a\n * synthetic SIGCHLD and there's a ptraced task that needs to SIGCHLD,\n * update the siginfo to reflect the status and note that that\n * ptraced task has had its SIGCHLD sent.\n * Note that we can't set the correct siginfo when we send the signal, because\n * it requires us to set information only the kernel has permission to set.\n */\n void set_siginfo_for_synthetic_SIGCHLD(siginfo_t* si);\n /**\n * Sets up |si| as if we're delivering a SIGCHLD/waitid for this waited task.\n */\n template \n void set_siginfo_for_waited_task(typename Arch::siginfo_t* si) {\n // XXX: The `ptrace` argument is likely incorrect here.\n emulated_stop_code.fill_siginfo(si,\n emulated_stop_type != GROUP_STOP, emulated_ptrace_options);\n si->_sifields._sigchld.si_pid_ = tgid();\n si->_sifields._sigchld.si_uid_ = getuid();\n }\n /**\n * Return a reference to the saved siginfo record for the stop-signal\n * that we're currently in a ptrace-stop for.\n */\n siginfo_t& get_saved_ptrace_siginfo();\n /**\n * When emulating a ptrace-continue with a signal number, extract the siginfo\n * that was saved by |save_ptrace_signal_siginfo|. If no such siginfo was\n * saved, make one up.\n */\n siginfo_t take_ptrace_signal_siginfo(int sig);\n\n /**\n * Returns true if this task is in a waitpid or similar that would return\n * when t's status changes due to a ptrace event.\n */\n bool is_waiting_for_ptrace(RecordTask* t);\n /**\n * Returns true if this task is in a waitpid or similar that would return\n * when t's status changes due to a regular event (exit).\n */\n bool is_waiting_for(RecordTask* t);\n\n bool already_exited() const override {\n return waiting_for_reap;\n }\n\n bool is_detached_proxy() const override {\n return detached_proxy;\n }\n\n /**\n * Call this to force a group stop for this task with signal 'sig',\n * notifying ptracer if necessary.\n */\n void apply_group_stop(int sig);\n /**\n * Call this after |sig| is delivered to this task. Emulate\n * sighandler updates induced by the signal delivery.\n */\n void signal_delivered(int sig);\n /**\n * Return true if |sig| is pending but hasn't been reported to ptrace yet\n */\n bool is_signal_pending(int sig);\n /**\n * Return true if there are any signals pending that are not blocked.\n */\n bool has_any_actionable_signal();\n /**\n * Get all threads out of an emulated GROUP_STOP\n */\n void emulate_SIGCONT();\n /**\n * Return true if the disposition of |sig| in |table| isn't\n * SIG_IGN or SIG_DFL, that is, if a user sighandler will be\n * invoked when |sig| is received.\n */\n bool signal_has_user_handler(int sig) const;\n /**\n * If signal_has_user_handler(sig) is true, return the address of the\n * user handler, otherwise return null.\n */\n remote_code_ptr get_signal_user_handler(int sig) const;\n /**\n * Return true if the signal handler for |sig| takes a siginfo_t*\n * parameter.\n */\n bool signal_handler_takes_siginfo(int sig) const;\n /**\n * Return |sig|'s current sigaction. Returned as raw bytes since the\n * data is architecture-dependent.\n */\n const std::vector& signal_action(int sig) const;\n /** Return true iff |sig| is blocked for this. */\n bool is_sig_blocked(int sig);\n /**\n * Return true iff |sig| is SIG_IGN, or it's SIG_DFL and the\n * default disposition is \"ignore\".\n */\n bool is_sig_ignored(int sig) const;\n /**\n * Return true iff |sig| is a stopping signal.\n */\n bool is_sig_stopping(int sig) const;\n /**\n * Return the applications current disposition of |sig|.\n */\n SignalDisposition sig_disposition(int sig) const;\n /**\n * Return the resolved disposition --- what this signal will actually do,\n * taking into account the default behavior.\n */\n SignalResolvedDisposition sig_resolved_disposition(\n int sig, SignalDeterministic deterministic);\n /**\n * Set the siginfo for the signal-stop of this.\n */\n void set_siginfo(const siginfo_t& si);\n /** Note that the task sigmask needs to be refetched. */\n void invalidate_sigmask() { blocked_sigs_dirty = true; }\n /**\n * Reset the signal handler for this signal to the default.\n */\n void did_set_sig_handler_default(int sig);\n\n /**\n * Check that our status for |sig| matches what's in /proc//status.\n */\n void verify_signal_states();\n\n /**\n * Stashed-signal API: if a signal becomes pending at an\n * awkward time, but could be handled \"soon\", call\n * |stash_sig()| to stash the current pending-signal state.\n *\n * |has_stashed_sig()| obviously returns true if |stash_sig()|\n * has been called successfully.\n *\n * |pop_stash_sig()| restores the (relevant) state of this\n * Task to what was saved in |stash_sig()|, and returns the\n * saved siginfo. After this call, |has_stashed_sig()| is\n * false.\n *\n * NB: |get_siginfo()| will always return the \"real\" siginfo,\n * regardless of stash popped-ness state. Callers must ensure\n * they do the right thing with the popped siginfo.\n *\n * If the process unexpectedly died (due to SIGKILL), we don't\n * stash anything.\n */\n void stash_sig();\n void stash_synthetic_sig(const siginfo_t& si,\n SignalDeterministic deterministic);\n bool has_stashed_sig() const { return !stashed_signals.empty(); }\n struct StashedSignal {\n StashedSignal(const siginfo_t& siginfo, SignalDeterministic deterministic,\n remote_code_ptr ip)\n : siginfo(siginfo), deterministic(deterministic), ip(ip) {}\n siginfo_t siginfo;\n SignalDeterministic deterministic;\n remote_code_ptr ip;\n };\n const StashedSignal* stashed_sig_not_synthetic_SIGCHLD() const;\n bool has_stashed_sig(int sig) const;\n const StashedSignal* peek_stashed_sig_to_deliver() const;\n void pop_stash_sig(const StashedSignal* stashed);\n void stashed_signal_processed();\n\n /**\n * If a group-stop occurs at an inconvenient time, stash it and\n * process it later.\n */\n void stash_group_stop() { stashed_group_stop = true; }\n void clear_stashed_group_stop() { stashed_group_stop = false; }\n bool has_stashed_group_stop() const { return stashed_group_stop; }\n\n /**\n * Return true if the current state of this looks like the\n * interrupted syscall at the top of our event stack, if there\n * is one.\n */\n bool is_syscall_restart();\n /**\n * Return true iff this is at an execution state where\n * resuming execution may lead to the restart of an\n * interrupted syscall.\n *\n * For example, if a signal without a user handler is about to\n * be delivered to this just after a syscall interruption,\n * then delivering the signal may restart the first syscall\n * and this method will return true.\n */\n bool at_may_restart_syscall() const;\n /**\n * Return true iff this is at an execution state where\n * a syscall that modifies signals was interrupted but will not\n * be automatically restarted.\n **/\n bool at_interrupted_non_restartable_signal_modifying_syscall() const;\n /**\n * Return true if this is at an arm-desched-event syscall.\n */\n bool is_arm_desched_event_syscall();\n /**\n * Return true if this is at a disarm-desched-event syscall.\n */\n bool is_disarm_desched_event_syscall();\n /**\n * Return true if |t| may not be immediately runnable,\n * i.e., resuming execution and then |waitpid()|'ing may block\n * for an unbounded amount of time. When the task is in this\n * state, the tracer must await a |waitpid()| notification\n * that the task is no longer possibly-blocked before resuming\n * its execution.\n */\n bool may_be_blocked() const;\n /**\n * Returns true if it looks like this task has been spinning on an atomic\n * access/lock.\n */\n bool maybe_in_spinlock();\n /**\n * Return true if this is within the syscallbuf library. This\n * *does not* imply that $ip is at a buffered syscall.\n * This also includes the runtime stub code that runs\n * before entering syscallbuf but does not include the \"safe area\".\n * Returning true from this function implies that the code will execute\n * `_syscallbuf_final_exit_instruction` before returning to normal code.\n */\n bool is_in_syscallbuf();\n /**\n * Shortcut to the most recent |pending_event->desched.rec| when\n * there's a desched event on the stack, and nullptr otherwise.\n * Exists just so that clients don't need to dig around in the\n * event stack to find this record.\n */\n remote_ptr desched_rec() const;\n /**\n * Returns true when the task is in a signal handler in an interrupted\n * system call being handled by syscall buffering.\n */\n bool running_inside_desched() const;\n /**\n * Returns -1 if we failed (the process unexpectedly exited).\n */\n int get_ptrace_eventmsg_seccomp_data();\n\n /**\n * Save tracee data to the trace. |addr| is the address in\n * the address space of this task. The |record_local*()|\n * variants record data that's already been read from this,\n * and the |record_remote*()| variants read the data and then\n * record it.\n * If 'addr' is null then no record is written.\n */\n void record_local(remote_ptr addr, ssize_t num_bytes, const void* buf);\n template \n void record_local(remote_ptr addr, const T* buf, size_t count = 1) {\n record_local(addr, sizeof(T) * count, buf);\n }\n void record_remote(remote_ptr addr, ssize_t num_bytes,\n MemWriteSizeValidation size_validation = MemWriteSizeValidation::EXACT);\n template void record_remote(remote_ptr addr) {\n record_remote(addr, sizeof(T));\n }\n void record_remote(const MemoryRange& range) {\n record_remote(range.start(), range.size());\n }\n ssize_t record_remote_fallible(const MemoryRange& range) {\n return record_remote_fallible(range.start(), range.size());\n }\n // Record as much as we can of the bytes in this range. Will record only\n // contiguous mapped data starting at `addr`.\n ssize_t record_remote_fallible(remote_ptr addr, uintptr_t num_bytes,\n const std::vector& holes = std::vector());\n // Record as much as we can of the bytes in this range. Will record only\n // contiguous mapped-writable data starting at `addr`. rr mappings (e.g. syscallbuf)\n // are treated as non-contiguous with any other mapping.\n void record_remote_writable(remote_ptr addr, ssize_t num_bytes,\n MemWriteSizeValidation size_validation = MemWriteSizeValidation::EXACT);\n\n // Simple helper that attempts to use the local mapping to record if one\n // exists\n bool record_remote_by_local_map(remote_ptr addr, size_t num_bytes);\n\n template \n void write_and_record(remote_ptr addr, const T& value, bool* ok = nullptr,\n uint32_t flags = 0) {\n write_mem(addr, value, ok, flags);\n record_local(addr, &value, 1);\n }\n\n /**\n * Save tracee data to the trace. |addr| is the address in\n * the address space of this task.\n * If 'addr' is null then a zero-length record is written.\n */\n void record_remote_even_if_null(remote_ptr addr, ssize_t num_bytes);\n template void record_remote_even_if_null(remote_ptr addr) {\n record_remote_even_if_null(addr, sizeof(T));\n }\n\n /**\n * Manage pending events. |push_event()| pushes the given\n * event onto the top of the event stack. The |pop_*()|\n * helpers pop the event at top of the stack, which must be of\n * the specified type.\n */\n void push_event(const Event& ev) { pending_events.push_back(ev); }\n void push_syscall_event(int syscallno);\n void pop_event(EventType expected_type);\n void pop_noop() { pop_event(EV_NOOP); }\n void pop_desched() { pop_event(EV_DESCHED); }\n void pop_seccomp_trap() { pop_event(EV_SECCOMP_TRAP); }\n void pop_signal_delivery() { pop_event(EV_SIGNAL_DELIVERY); }\n void pop_signal_handler() { pop_event(EV_SIGNAL_HANDLER); }\n void pop_syscall() { pop_event(EV_SYSCALL); }\n void pop_syscall_interruption() { pop_event(EV_SYSCALL_INTERRUPTION); }\n virtual void log_pending_events() const override;\n /** Return the event at the top of this's stack. */\n Event& ev() { return pending_events.back(); }\n const Event& ev() const { return pending_events.back(); }\n\n /**\n * Obtain the previous event on the stack (if any) or nullptr (if not)\n */\n Event *prev_ev() {\n ssize_t depth = pending_events.size();\n return depth > 2 ? &pending_events[depth - 2] : nullptr;\n }\n\n /**\n * Call this before recording events or data. Records\n * syscallbuf data and flushes the buffer, if there's buffered\n * data.\n *\n * The timing of calls to this is tricky. We must flush the syscallbuf\n * before recording any data associated with events that happened after the\n * buffered syscalls. But we don't support flushing a syscallbuf twice with\n * no intervening reset, i.e. after flushing we have to be sure we'll get\n * a chance to reset the syscallbuf (i.e. record some other kind of event)\n * before the tracee runs again in a way that might append another buffered\n * syscall --- so we can't flush too early\n */\n void maybe_flush_syscallbuf();\n /**\n * Call this after recording an event when it might be safe to reset the\n * syscallbuf. It must be after recording an event to ensure during replay\n * we run past any syscallbuf after-syscall code that uses the buffer data.\n */\n void maybe_reset_syscallbuf();\n /**\n * Record an event on behalf of this. Record the registers of\n * this (and other relevant execution state) so that it can be\n * used or verified during replay, if that state is available\n * and meaningful at this's current execution point.\n * |record_current_event()| record |this->ev()|, and\n * |record_event()| records the specified event.\n */\n void record_current_event();\n enum FlushSyscallbuf {\n FLUSH_SYSCALLBUF,\n /* Pass this if it's safe to replay the event before we process the\n * syscallbuf records.\n */\n DONT_FLUSH_SYSCALLBUF\n };\n enum AllowSyscallbufReset {\n ALLOW_RESET_SYSCALLBUF,\n /* Pass this if it's safe to replay the event before we process the\n * syscallbuf records.\n */\n DONT_RESET_SYSCALLBUF\n };\n // Take `ev` by value to avoid bugs where we pass in an event in\n // `pending_events`, which could lead to dangling references when\n // flushing the syscallbuf manipulates `pending_events`.\n void record_event(Event ev, FlushSyscallbuf flush = FLUSH_SYSCALLBUF,\n AllowSyscallbufReset reset = ALLOW_RESET_SYSCALLBUF,\n const Registers* registers = nullptr);\n\n bool is_fatal_signal(int sig, SignalDeterministic deterministic) const;\n\n /**\n * If the process looks alive, kill it.\n */\n void kill_if_alive();\n\n remote_ptr robust_list() const { return robust_futex_list; }\n size_t robust_list_len() const { return robust_futex_list_len; }\n\n /** Uses /proc so not trivially cheap. */\n pid_t get_parent_pid() const;\n\n /**\n * Return true if this is a \"clone child\" per the wait(2) man page.\n */\n bool is_clone_child() { return termination_signal != SIGCHLD; }\n\n void set_termination_signal(int sig) { termination_signal = sig; }\n\n /**\n * When a signal triggers an emulated a ptrace-stop for this task,\n * save the siginfo so a later emulated ptrace-continue with this signal\n * number can use it.\n */\n void save_ptrace_signal_siginfo(const siginfo_t& si);\n\n enum { SYNTHETIC_TIME_SLICE_SI_CODE = -9999 };\n\n /**\n * Tasks normally can't change their tid. There is one very special situation\n * where they can: when a non-main-thread does an execve, its tid changes\n * to the tid of the thread-group leader.\n */\n void set_tid_and_update_serial(pid_t tid, pid_t own_namespace_tid);\n\n /**\n * Return our cached copy of the signal mask, updating it if necessary.\n */\n sig_set_t get_sigmask();\n /**\n * Just get the signal mask of the process.\n */\n sig_set_t read_sigmask_from_process();\n /**\n * Unblock the signal for the process.\n */\n void unblock_signal(int sig);\n /**\n * Set the signal handler to default for the process.\n */\n void set_sig_handler_default(int sig);\n\n ~RecordTask();\n\n void maybe_restore_original_syscall_registers();\n\n /**\n * The task reached zombie state. Do whatever processing is necessary (reaping\n * it, emulating ptrace stops, etc.)\n */\n void did_reach_zombie();\n\n // Is this task a container init? (which has special signal behavior)\n bool is_container_init() const { return tg->tgid_own_namespace == 1; }\n\n /**\n * Linux requires the invariant that all members of a thread group\n * are reaped before the thread group leader. This determines whether or\n * not we're allowed to attempt reaping this thread or whether doing so\n * risks deadlock.\n */\n bool may_reap();\n\n /**\n * Reaps a task-exit notification, thus detaching us from the tracee.\n * N.B.: If may_reap is false, this risks a deadlock.\n */\n void reap();\n\n bool waiting_for_pid_namespace_tasks_to_exit() const;\n int process_depth() const;\n\n /**\n * Called when this task is able to receive a SIGCHLD (e.g. because\n * we completed delivery of a signal). Sends a new synthetic\n * SIGCHLD to the task if there are still tasks that need a SIGCHLD\n * sent for them.\n * May queue signals for specific tasks.\n */\n void send_synthetic_SIGCHLD_if_necessary();\n\n void set_sigmask(sig_set_t mask);\n\n /**\n * Update the futex robust list head pointer to |list| (which\n * is of size |len|).\n */\n void set_robust_list(remote_ptr list, size_t len) {\n robust_futex_list = list;\n robust_futex_list_len = len;\n }\n\n void set_stopped(bool stopped) override;\n\n // Tries to extend an adjacent `MAP_GROWSDOWN` mapping to include the\n // given address. Returns false if nothing was done.\n bool try_grow_map(remote_ptr addr);\n\nprivate:\n /* Retrieve the tid of this task from the tracee and store it */\n void update_own_namespace_tid();\n\n /**\n * Wait for |futex| in this address space to have the value\n * |val|.\n *\n * WARNING: this implementation semi-busy-waits for the value\n * change. This must only be used in contexts where the futex\n * will change \"soon\".\n */\n void futex_wait(remote_ptr futex, int val, bool* ok);\n\n /**\n * Call this when SYS_sigaction is finishing with |regs|.\n */\n void update_sigaction(const Registers& regs);\n\n template void init_buffers_arch();\n template \n void on_syscall_exit_arch(int syscallno, const Registers& regs);\n /** Helper function for update_sigaction. */\n template void update_sigaction_arch(const Registers& regs);\n\n /** Update the clear-tid futex to |tid_addr|. */\n void set_tid_addr(remote_ptr tid_addr);\n\n virtual bool post_vm_clone(CloneReason reason, int flags, Task* origin) override;\n\npublic:\n uint64_t scheduler_token;\n std::unique_ptr syscall_state;\n Ticks ticks_at_last_recorded_syscall_exit;\n remote_code_ptr ip_at_last_recorded_syscall_exit;\n\n // Scheduler state\n\n Registers registers_at_start_of_last_timeslice;\n FrameTime time_at_start_of_last_timeslice;\n /* Task 'nice' value set by setpriority(2).\n We use this to drive scheduling decisions. rr's scheduler is\n deliberately simple and unfair; a task never runs as long as there's\n another runnable task with a lower nice value. */\n int priority;\n /* Tasks with in_round_robin_queue set are in the session's\n * in_round_robin_queue instead of its task_priority_set.\n */\n bool in_round_robin_queue;\n /* exit(), or exit_group() with one task, has been called, so\n * the exit can be treated as stable. */\n bool stable_exit;\n\n bool detached_proxy;\n\n // ptrace emulation state\n\n // Task for which we're emulating ptrace of this task, or null\n RecordTask* emulated_ptracer;\n std::set emulated_ptrace_tracees;\n uintptr_t emulated_ptrace_event_msg;\n // Saved emulated-ptrace signals\n std::vector saved_ptrace_siginfos;\n // Code to deliver to ptracer/waiter when it waits. Note that zero can be a\n // valid code! Reset to zero when leaving the stop due to PTRACE_CONT etc.\n WaitStatus emulated_stop_code;\n // Always zero while no ptracer is attached.\n int emulated_ptrace_options;\n // One of PTRACE_CONT, PTRACE_SYSCALL --- or 0 if the tracee has not been\n // continued by its ptracer yet, or has no ptracer.\n int emulated_ptrace_cont_command;\n // true when a ptracer/waiter wait() can return |emulated_stop_code|.\n bool emulated_stop_pending;\n // true if this task needs to send a SIGCHLD to its ptracer for its\n // emulated ptrace stop\n bool emulated_ptrace_SIGCHLD_pending;\n // true if this task needs to send a SIGCHLD to its parent for its\n // emulated stop\n bool emulated_SIGCHLD_pending;\n // tracer attached via PTRACE_SEIZE\n bool emulated_ptrace_seized;\n WaitType in_wait_type;\n int in_wait_options;\n pid_t in_wait_pid;\n pid_t creator_tid;\n\n // Signal handler state\n\n // Points to the signal-hander table of this task. If this\n // task is a non-fork clone child, then the table will be\n // shared with all its \"thread\" siblings. Any updates made to\n // that shared table are immediately visible to all sibling\n // threads.\n //\n // fork children always get their own copies of the table.\n // And if this task exec()s, the table is copied and stripped\n // of user sighandlers (see below). */\n std::shared_ptr sighandlers;\n // If not NOT_STOPPED, then the task is logically stopped and this is the type\n // of stop.\n EmulatedStopType emulated_stop_type;\n // True if the task sigmask may have changed and we need to refetch it.\n bool blocked_sigs_dirty;\n // Most accesses to this should use set_sigmask and get_sigmask to ensure\n // the mirroring to syscallbuf is correct.\n sig_set_t blocked_sigs;\n uint32_t syscallbuf_blocked_sigs_generation;\n\n // Syscallbuf state\n\n SyscallbufCodeLayout syscallbuf_code_layout;\n ContextSwitchEvent desched_fd;\n /* Value of hdr->num_rec_bytes when the buffer was flushed */\n uint32_t flushed_num_rec_bytes;\n /* Nonzero after the trace recorder has flushed the\n * syscallbuf. When this happens, the recorder must prepare a\n * \"reset\" of the buffer, to zero the record count, at the\n * next available slow (taking |desched| into\n * consideration). */\n bool flushed_syscallbuf;\n /* This bit is set when code wants to prevent the syscall\n * record buffer from being reset when it normally would be.\n * This bit is set by the desched code. */\n bool delay_syscallbuf_reset_for_desched;\n /* This is set when code wants to prevent the syscall\n * record buffer from being reset when it normally would be.\n * This is set by the code for handling seccomp SIGSYS signals. */\n bool delay_syscallbuf_reset_for_seccomp_trap;\n // Value to return from PR_GET_SECCOMP\n uint8_t prctl_seccomp_status;\n\n // Mirrored kernel state\n // This state agrees with kernel-internal values\n\n // Futex list passed to |set_robust_list()|. We could keep a\n // strong type for this list head and read it if we wanted to,\n // but for now we only need to remember its address / size at\n // the time of the most recent set_robust_list() call.\n remote_ptr robust_futex_list;\n size_t robust_futex_list_len;\n // The memory cell the kernel will clear and notify on exit,\n // if our clone parent requested it.\n remote_ptr tid_futex;\n // Signal delivered by the kernel when this task terminates, or zero\n int termination_signal;\n\n // Our value for PR_GET/SET_TSC (one of PR_TSC_ENABLED, PR_TSC_SIGSEGV).\n int tsc_mode;\n // Our value for ARCH_GET/SET_CPUID (0 -> generate SIGSEGV, 1 -> do CPUID).\n // Only used if session().has_cpuid_faulting().\n int cpuid_mode;\n // The current stack of events being processed.\n std::vector pending_events;\n // Stashed signal-delivery state, ready to be delivered at\n // next opportunity.\n std::deque stashed_signals;\n // When true, we're blocking signals during a syscall to\n // prevent new signals from being delivered. `blocked_sigs_dirty`\n // is false and `blocked_sigs` contains the previous sigmask.\n bool stashed_signals_blocking_more_signals;\n bool stashed_group_stop;\n bool break_at_syscallbuf_traced_syscalls;\n bool break_at_syscallbuf_untraced_syscalls;\n bool break_at_syscallbuf_final_instruction;\n remote_code_ptr syscallstub_exit_breakpoint;\n\n // The pmc is programmed to interrupt at a value requested by the tracee, not\n // by rr.\n bool next_pmc_interrupt_is_for_user;\n\n bool did_record_robust_futex_changes;\n\n // This task is just waiting to be reaped.\n bool waiting_for_reap;\n\n // This task is waiting for a ptrace exit event. It should not\n // be manually run.\n bool waiting_for_ptrace_exit;\n\n // We've sent a SIGKILL during shutdown for this task.\n bool sent_shutdown_kill;\n\n // Last exec system call was an execveat\n bool did_execveat;\n\n // Set if the tracee requested an override of the ticks request.\n // Used for testing.\n TicksRequest tick_request_override;\n\n // Set to prevent the scheduler from scheduling this tid, even\n // if it is otherwise considered runnable. Used for testing.\n bool schedule_frozen;\n};\n\n} // namespace rr\n\n#endif /* RR_RECORD_TASK_H_ */\n" }, { "path": "src/Registers.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"Registers.h\"\n\n#include \n#include \n#include \n\n#include \n\n#include \"ReplayTask.h\"\n#include \"core.h\"\n#include \"log.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nstruct RegisterValue {\n // The name of this register.\n const char* name;\n // The offsetof the register in user_regs_struct.\n size_t offset;\n // The size of the register. 0 means we cannot read it.\n size_t nbytes;\n // Mask to be applied to register values prior to comparing them. Will\n // typically be ((1 << nbytes) - 1), but some registers may have special\n // comparison semantics.\n uint64_t comparison_mask;\n\n constexpr RegisterValue()\n : name(nullptr), offset(0), nbytes(0), comparison_mask(0) {}\n\n RegisterValue(const char* name_, size_t offset_, size_t nbytes_)\n : name(name_), offset(offset_), nbytes(nbytes_) {\n comparison_mask = mask_for_nbytes(nbytes_);\n }\n\n RegisterValue(const char* name_, size_t offset_, size_t nbytes_,\n uint64_t comparison_mask_, size_t size_override = 0)\n : name(name_),\n offset(offset_),\n nbytes(nbytes_),\n comparison_mask(comparison_mask_) {\n // Ensure no bits are set outside of the register's bitwidth.\n DEBUG_ASSERT((comparison_mask_ & ~mask_for_nbytes(nbytes_)) == 0);\n if (size_override > 0) {\n nbytes = size_override;\n }\n }\n // Returns a pointer to the register in |regs| represented by |offset|.\n // |regs| is assumed to be a pointer to the user_struct_regs for the\n // appropriate architecture.\n void* pointer_into(void* regs) { return static_cast(regs) + offset; }\n\n const void* pointer_into(const void* regs) {\n return static_cast(regs) + offset;\n }\n\n static uint64_t mask_for_nbytes(size_t nbytes) {\n DEBUG_ASSERT(nbytes <= sizeof(comparison_mask));\n return ((nbytes == sizeof(comparison_mask)) ? uint64_t(0)\n : (uint64_t(1) << nbytes * 8)) -\n 1;\n }\n};\n\ntypedef std::pair RegisterInit;\n\ntemplate struct RegisterTable : std::array {\n RegisterTable(std::initializer_list list) {\n for (auto& ri : list) {\n (*this)[ri.first] = ri.second;\n }\n }\n};\n\ntemplate struct RegisterInfo;\n\ntemplate <> struct RegisterInfo {\n static bool ignore_undefined_register(GdbServerRegister regno) {\n return regno == DREG_FOSEG || regno == DREG_MXCSR;\n }\n static const size_t num_registers = DREG_NUM_LINUX_I386;\n typedef RegisterTable Table;\n static Table registers;\n};\n\ntemplate <> struct RegisterInfo {\n static bool ignore_undefined_register(GdbServerRegister regno) {\n return regno == DREG_64_FOSEG || regno == DREG_64_MXCSR;\n }\n static const size_t num_registers = DREG_NUM_LINUX_X86_64;\n typedef RegisterTable Table;\n static Table registers;\n};\n\ntemplate <> struct RegisterInfo {\n static bool ignore_undefined_register(GdbServerRegister) {\n return false;\n }\n static const size_t num_registers = DREG_NUM_LINUX_AARCH64;\n typedef RegisterTable Table;\n static Table registers;\n};\n\n#define RV_ARCH(gdb_suffix, name, arch, extra_ctor_args) \\\n RegisterInit(DREG_##gdb_suffix, \\\n RegisterValue(#name, offsetof(arch::user_regs_struct, name), \\\n sizeof(((arch::user_regs_struct*)0)->name) \\\n extra_ctor_args))\n#define RV_X86(gdb_suffix, name) \\\n RV_ARCH(gdb_suffix, name, rr::X86Arch, /* empty */)\n#define RV_X64(gdb_suffix, name) \\\n RV_ARCH(gdb_suffix, name, rr::X64Arch, /* empty */)\n#define COMMA ,\n#define RV_X86_WITH_MASK(gdb_suffix, name, comparison_mask) \\\n RV_ARCH(gdb_suffix, name, rr::X86Arch, COMMA comparison_mask)\n#define RV_X64_WITH_MASK(gdb_suffix, name, comparison_mask, size) \\\n RV_ARCH(gdb_suffix, name, rr::X64Arch, COMMA comparison_mask COMMA size)\n#define RV_AARCH64(gdb_suffix, name) RV_ARCH(gdb_suffix, name, rr::ARM64Arch, /* empty */)\n#define RV_AARCH64_WITH_MASK(gdb_suffix, name, comparison_mask, size) \\\n RV_ARCH(gdb_suffix, name, rr::ARM64Arch, COMMA comparison_mask COMMA size)\n\nRegisterInfo::Table RegisterInfo::registers = {\n RV_X86(EAX, eax), RV_X86(ECX, ecx), RV_X86(EDX, edx), RV_X86(EBX, ebx),\n RV_X86(ESP, esp), RV_X86(EBP, ebp), RV_X86(ESI, esi), RV_X86(EDI, edi),\n RV_X86(EIP, eip), RV_X86_WITH_MASK(EFLAGS, eflags, 0),\n RV_X86_WITH_MASK(CS, xcs, 0), RV_X86_WITH_MASK(SS, xss, 0),\n RV_X86_WITH_MASK(DS, xds, 0), RV_X86_WITH_MASK(ES, xes, 0),\n // Mask out the RPL from the fs and gs segment selectors. The kernel\n // unconditionally sets RPL=3 on sigreturn, but if the segment index is 0,\n // the RPL doesn't matter, and the CPU resets the entire register to 0,\n // so whether or not we see this depends on whether the value round-tripped\n // to the CPU yet.\n RV_X86_WITH_MASK(FS, xfs, (uint16_t)~3),\n RV_X86_WITH_MASK(GS, xgs, (uint16_t)~3),\n // The comparison for this is handled specially elsewhere.\n RV_X86_WITH_MASK(ORIG_EAX, orig_eax, 0),\n};\n\nRegisterInfo::Table RegisterInfo::registers = {\n RV_X64(RAX, rax), RV_X64(RCX, rcx), RV_X64(RDX, rdx), RV_X64(RBX, rbx),\n RV_X64_WITH_MASK(RSP, rsp, 0, 8), RV_X64(RBP, rbp), RV_X64(RSI, rsi),\n RV_X64(RDI, rdi), RV_X64(R8, r8), RV_X64(R9, r9), RV_X64(R10, r10),\n RV_X64(R11, r11), RV_X64(R12, r12), RV_X64(R13, r13), RV_X64(R14, r14),\n RV_X64(R15, r15), RV_X64(RIP, rip), RV_X64_WITH_MASK(64_EFLAGS, eflags, 0, 4),\n RV_X64_WITH_MASK(64_CS, cs, 0, 4), RV_X64_WITH_MASK(64_SS, ss, 0, 4),\n RV_X64_WITH_MASK(64_DS, ds, 0, 4), RV_X64_WITH_MASK(64_ES, es, 0, 4),\n RV_X64_WITH_MASK(64_FS, fs, 0xffffffffLL, 4),\n RV_X64_WITH_MASK(64_GS, gs, 0xffffffffLL, 4),\n // The comparison for this is handled specially\n // elsewhere.\n RV_X64_WITH_MASK(ORIG_RAX, orig_rax, 0, 8), RV_X64(FS_BASE, fs_base),\n RV_X64(GS_BASE, gs_base),\n};\n\nRegisterInfo::Table RegisterInfo::registers = {\n RV_AARCH64(X0, x[0]), RV_AARCH64(X1, x[1]), RV_AARCH64(X2, x[2]),\n RV_AARCH64(X3, x[3]), RV_AARCH64(X4, x[4]), RV_AARCH64(X5, x[5]),\n RV_AARCH64(X6, x[6]),\n // Don't compare these - the kernel sometimes lies [1] about this value\n // [1] https://github.com/torvalds/linux/blob/d2f8825ab78e4c18686f3e1a756a30255bb00bf3/arch/arm64/kernel/ptrace.c#L1814-L1820\n RV_AARCH64_WITH_MASK(X7, x[7], 0, 8),\n RV_AARCH64(X8, x[8]), RV_AARCH64(X9, x[9]),\n RV_AARCH64(X10, x[10]), RV_AARCH64(X11, x[11]), RV_AARCH64(X12, x[12]),\n RV_AARCH64(X13, x[13]), RV_AARCH64(X14, x[14]), RV_AARCH64(X15, x[15]),\n RV_AARCH64(X16, x[16]), RV_AARCH64(X17, x[17]), RV_AARCH64(X18, x[18]),\n RV_AARCH64(X19, x[19]),\n RV_AARCH64(X20, x[20]), RV_AARCH64(X21, x[21]), RV_AARCH64(X22, x[22]),\n RV_AARCH64(X23, x[23]), RV_AARCH64(X24, x[24]), RV_AARCH64(X25, x[25]),\n RV_AARCH64(X26, x[26]), RV_AARCH64(X27, x[27]), RV_AARCH64(X28, x[28]),\n RV_AARCH64(X29, x[29]), RV_AARCH64(X30, x[30]),\n RV_AARCH64(SP, sp), RV_AARCH64(PC, pc),\n // Mask out the single-step flag from the pstate. During replay, we may\n // single-step to an execution point, which could set the single-step bit\n // when it wasn't set during record.\n //\n // In Apple Air M2 SPSR bit 11 seems to be sometimes set leading to record/replay register\n // comparison errors. This seems to be a unused/undocumented bit in SPSR as per aarch64\n // documentation anyways so ignore it.\n RV_AARCH64_WITH_MASK(CPSR, pstate, 0xffffffffLL & ~AARCH64_DBG_SPSR_SS & ~AARCH64_DBG_SPSR_11, 4),\n};\n\n#undef RV_X64\n#undef RV_X86\n#undef RV_AARCH64\n#undef RV_X64_WITH_MASK\n#undef RV_X86_WITH_MASK\n#undef RV_AARCH64_WITH_MASK\n#undef RV_ARCH\n\n// 32-bit format, 64-bit format for all of these.\n// format_index in RegisterPrinting depends on the ordering here.\nstatic const char* hex_format_leading_0x[] = { \"0x%\" PRIx32, \"0x%\" PRIx64 };\n// static const char* decimal_format[] = { \"%\" PRId32, \"%\" PRId64 };\n\ntemplate struct RegisterPrinting;\n\ntemplate <> struct RegisterPrinting<4> {\n typedef uint32_t type;\n static const size_t format_index = 0;\n};\n\ntemplate <> struct RegisterPrinting<8> {\n typedef uint64_t type;\n static const size_t format_index = 1;\n};\n\ntemplate \nvoid print_single_register(FILE* f, const char* name, const void* register_ptr,\n const char* formats[]) {\n typename RegisterPrinting::type val;\n memcpy(&val, register_ptr, nbytes);\n if (name) {\n fprintf(f, \"%s:\", name);\n } else {\n fprintf(f, \" \");\n }\n fprintf(f, formats[RegisterPrinting::format_index], val);\n}\n\ntemplate \nvoid Registers::print_register_file_arch(FILE* f, const char* formats[]) const {\n fprintf(f, \"Printing register file:\\n\");\n const void* user_regs = &u;\n for (auto& rv : RegisterInfo::registers) {\n if (rv.nbytes == 0) {\n continue;\n }\n switch (rv.nbytes) {\n case 8:\n print_single_register<8>(f, rv.name, rv.pointer_into(user_regs),\n formats);\n break;\n case 4:\n print_single_register<4>(f, rv.name, rv.pointer_into(user_regs),\n formats);\n break;\n default:\n DEBUG_ASSERT(0 && \"bad register size\");\n }\n fprintf(f, \"\\n\");\n }\n fprintf(f, \"\\n\");\n}\n\nvoid Registers::print_register_file(FILE* f) const {\n RR_ARCH_FUNCTION(print_register_file_arch, arch(), f, hex_format_leading_0x);\n}\n\ntemplate \nvoid Registers::print_register_file_for_trace_arch(\n FILE* f, TraceStyle style, const char* formats[]) const {\n const void* user_regs = &u;\n bool first = true;\n for (auto& rv : RegisterInfo::registers) {\n if (rv.nbytes == 0) {\n continue;\n }\n\n if (!first) {\n fputc(' ', f);\n }\n first = false;\n const char* name = (style == Annotated ? rv.name : nullptr);\n\n switch (rv.nbytes) {\n case 8:\n print_single_register<8>(f, name, rv.pointer_into(user_regs), formats);\n break;\n case 4:\n print_single_register<4>(f, name, rv.pointer_into(user_regs), formats);\n break;\n default:\n DEBUG_ASSERT(0 && \"bad register size\");\n }\n }\n}\n\nvoid Registers::print_register_file_compact(FILE* f) const {\n RR_ARCH_FUNCTION(print_register_file_for_trace_arch, arch(), f, Annotated,\n hex_format_leading_0x);\n}\n\nvoid Registers::print_register_file_for_trace_raw(FILE* f) const {\n fprintf(f, \" %d %d %d %d %d %d %d\"\n \" %d %d %d %d\",\n u.x86regs.eax, u.x86regs.ebx, u.x86regs.ecx, u.x86regs.edx,\n u.x86regs.esi, u.x86regs.edi, u.x86regs.ebp, u.x86regs.orig_eax,\n u.x86regs.esp, u.x86regs.eip, u.x86regs.eflags);\n}\n\nstd::ostream& operator<<(std::ostream& stream, const Registers::Comparison& c) {\n if (c.store_mismatches) {\n bool first = true;\n for (const Registers::Mismatch& mismatch : c.mismatches) {\n if (first) {\n first = false;\n } else {\n stream << \", \";\n }\n stream << mismatch.register_name << \" \" << mismatch.val1 << \" != \" << mismatch.val2;\n }\n } else {\n stream << c.mismatch_count << \" register mismatches\";\n }\n return stream;\n}\n\nvoid Registers::Comparison::add_mismatch(const char* reg_name, uint64_t val1, uint64_t val2) {\n ++mismatch_count;\n if (store_mismatches) {\n char buf1[40];\n sprintf(buf1, \"%p\", reinterpret_cast(val1));\n char buf2[40];\n sprintf(buf2, \"%p\", reinterpret_cast(val2));\n mismatches.push_back({reg_name, buf1, buf2});\n }\n}\n\ntemplate \nvoid Registers::compare_registers_core(const Registers& reg1,\n const Registers& reg2, Comparison& result) {\n for (auto& rv : RegisterInfo::registers) {\n if (rv.nbytes == 0) {\n continue;\n }\n\n // Disregard registers that will trivially compare equal.\n if (rv.comparison_mask == 0) {\n continue;\n }\n\n // XXX correct but oddly displayed for big-endian processors.\n uint64_t val1 = 0, val2 = 0;\n memcpy(&val1, rv.pointer_into(®1.u), rv.nbytes);\n memcpy(&val2, rv.pointer_into(®2.u), rv.nbytes);\n\n if ((val1 ^ val2) & rv.comparison_mask) {\n result.add_mismatch(rv.name, val1, val2);\n }\n }\n}\n\n// A handy macro for compare_registers_arch specializations.\n#define REGCMP(user_regs, _reg, result) \\\n do { \\\n if (reg1.user_regs._reg != reg2.user_regs._reg) { \\\n result.add_mismatch(#_reg, reg1.user_regs._reg, reg2.user_regs._reg);\\\n } \\\n } while (0)\n#define X86_REGCMP(_reg, result) REGCMP(u.x86regs, _reg, result)\n#define X64_REGCMP(_reg, result) REGCMP(u.x64regs, _reg, result)\n\n// A wrapper around compare_registers_core so registers requiring special\n// processing can be handled via template specialization.\ntemplate \n/* static */ void Registers::compare_registers_arch(\n const Registers& reg1, const Registers& reg2, Comparison& result) {\n // Default behavior.\n return compare_registers_core(reg1, reg2, result);\n}\n\ntemplate <>\n/* static */ void Registers::compare_registers_arch(\n const Registers& reg1, const Registers& reg2, Comparison& result) {\n compare_registers_core(reg1, reg2, result);\n /* When the kernel is entered via an interrupt, orig_rax is set to -IRQ.\n We observe negative orig_eax values at SCHED events and signals and other\n timer interrupts. These values are only really meaningful to compare when\n they reflect original syscall numbers, in which case both will be positive.\n */\n if (reg1.u.x86regs.orig_eax >= 0 && reg2.u.x86regs.orig_eax >= 0) {\n X86_REGCMP(orig_eax, result);\n }\n}\n\ntemplate <>\n/* static */ void Registers::compare_registers_arch(\n const Registers& reg1, const Registers& reg2, Comparison& result) {\n compare_registers_core(reg1, reg2, result);\n // See comment in the x86 case\n if ((intptr_t)reg1.u.x64regs.orig_rax >= 0 &&\n (intptr_t)reg2.u.x64regs.orig_rax >= 0) {\n X64_REGCMP(orig_rax, result);\n }\n}\n\nvoid Registers::compare_internal(const Registers& other,\n Comparison& result) const {\n DEBUG_ASSERT(arch() == other.arch());\n RR_ARCH_FUNCTION(compare_registers_arch, arch(), *this, other, result);\n}\n\ntemplate \nsize_t Registers::read_register_arch(uint8_t* buf, GdbServerRegister regno,\n bool* defined) const {\n if (regno >= array_length(RegisterInfo::registers)) {\n *defined = false;\n return 0;\n }\n\n RegisterValue& rv = RegisterInfo::registers[regno];\n if (rv.nbytes == 0) {\n *defined = false;\n } else {\n *defined = true;\n memcpy(buf, rv.pointer_into(&u), rv.nbytes);\n }\n\n return rv.nbytes;\n}\n\nsize_t Registers::read_register(uint8_t* buf, GdbServerRegister regno,\n bool* defined) const {\n RR_ARCH_FUNCTION(read_register_arch, arch(), buf, regno, defined);\n}\n\ntemplate \nsize_t Registers::read_register_by_user_offset_arch(uint8_t* buf,\n uintptr_t offset,\n bool* defined) const {\n for (size_t regno = 0; regno < RegisterInfo::num_registers; ++regno) {\n RegisterValue& rv = RegisterInfo::registers[regno];\n if (rv.offset == offset) {\n return read_register_arch(buf, GdbServerRegister(regno), defined);\n }\n }\n\n *defined = false;\n return 0;\n}\n\nsize_t Registers::read_register_by_user_offset(uint8_t* buf, uintptr_t offset,\n bool* defined) const {\n RR_ARCH_FUNCTION(read_register_by_user_offset_arch, arch(), buf, offset,\n defined);\n}\n\ntemplate \nbool Registers::write_register_arch(GdbServerRegister regno, const void* value,\n size_t value_size) {\n RegisterValue& rv = RegisterInfo::registers[regno];\n\n if (rv.nbytes == 0) {\n // TODO: can we get away with not writing these?\n if (RegisterInfo::ignore_undefined_register(regno)) {\n return true;\n }\n return false;\n } else {\n DEBUG_ASSERT(value_size == rv.nbytes);\n memcpy(rv.pointer_into(&u), value, value_size);\n return true;\n }\n}\n\nbool Registers::write_register(GdbServerRegister regno, const void* value,\n size_t value_size) {\n RR_ARCH_FUNCTION(write_register_arch, arch(), regno, value, value_size);\n}\n\ntemplate \nvoid Registers::write_register_by_user_offset_arch(uintptr_t offset,\n uintptr_t value) {\n for (size_t regno = 0; regno < RegisterInfo::num_registers; ++regno) {\n RegisterValue& rv = RegisterInfo::registers[regno];\n if (rv.offset == offset) {\n DEBUG_ASSERT(rv.nbytes <= sizeof(value));\n memcpy(rv.pointer_into(&u), &value, rv.nbytes);\n return;\n }\n }\n}\n\nvoid Registers::write_register_by_user_offset(uintptr_t offset,\n uintptr_t value) {\n RR_ARCH_FUNCTION(write_register_by_user_offset_arch, arch(), offset, value);\n}\n\n// In theory it doesn't matter how 32-bit register values are sign extended\n// to 64 bits for PTRACE_SETREGS. However:\n// -- When setting up a signal handler frame, the kernel does some arithmetic\n// on the 64-bit SP value and validates that the result points to writeable\n// memory. This validation fails if SP has been sign-extended to point\n// outside the 32-bit address space.\n// -- Some kernels (e.g. 4.3.3-301.fc23.x86_64) with commit\n// c5c46f59e4e7c1ab244b8d38f2b61d317df90bba have a bug where if you clear\n// the upper 32 bits of %rax while in the kernel, syscalls may fail to\n// restart. So sign-extension is necessary for %eax in this case. We may as\n// well sign-extend %eax in all cases.\n\ntypedef void (*NarrowConversion)(int32_t& r32, uint64_t& r64);\ntemplate \nvoid convert_x86(X86Arch::user_regs_struct& x86,\n X64Arch::user_regs_struct& x64) {\n narrow_signed(x86.eax, x64.rax);\n narrow(x86.ebx, x64.rbx);\n narrow(x86.ecx, x64.rcx);\n narrow(x86.edx, x64.rdx);\n narrow(x86.esi, x64.rsi);\n narrow(x86.edi, x64.rdi);\n narrow(x86.esp, x64.rsp);\n narrow(x86.ebp, x64.rbp);\n narrow(x86.eip, x64.rip);\n narrow(x86.orig_eax, x64.orig_rax);\n narrow(x86.eflags, x64.eflags);\n narrow(x86.xcs, x64.cs);\n narrow(x86.xds, x64.ds);\n narrow(x86.xes, x64.es);\n narrow(x86.xfs, x64.fs);\n narrow(x86.xgs, x64.gs);\n narrow(x86.xss, x64.ss);\n}\n\nvoid to_x86_narrow(int32_t& r32, uint64_t& r64) { r32 = r64; }\nvoid from_x86_narrow(int32_t& r32, uint64_t& r64) { r64 = (uint32_t)r32; }\nvoid from_x86_narrow_signed(int32_t& r32, uint64_t& r64) { r64 = (int64_t)r32; }\n\nvoid Registers::set_from_ptrace(const NativeArch::user_regs_struct& ptrace_regs) {\n if (arch() == NativeArch::arch()) {\n memcpy(&u, &ptrace_regs, sizeof(ptrace_regs));\n return;\n }\n\n DEBUG_ASSERT(arch() == x86 && NativeArch::arch() == x86_64);\n convert_x86(\n u.x86regs,\n *const_cast(\n reinterpret_cast(&ptrace_regs)));\n}\n\n/**\n * Get a user_regs_struct from these Registers. If the tracee architecture\n * is not rr's native architecture, then it must be a 32-bit tracee with a\n * 64-bit rr. In that case the user_regs_struct is 64-bit and we copy\n * the 32-bit register values from u.x86regs into it.\n */\nNativeArch::user_regs_struct Registers::get_ptrace() const {\n union {\n NativeArch::user_regs_struct linux_api;\n struct X64Arch::user_regs_struct x64arch_api;\n } result;\n if (arch() == NativeArch::arch()) {\n memcpy(&result, &u, sizeof(result));\n return result.linux_api;\n }\n\n DEBUG_ASSERT(arch() == x86 && NativeArch::arch() == x86_64);\n memset(&result, 0, sizeof(result));\n convert_x86(\n const_cast(this)->u.x86regs, result.x64arch_api);\n return result.linux_api;\n}\n\niovec Registers::get_ptrace_iovec() {\n if (arch() == NativeArch::arch()) {\n iovec iov = { &u, sizeof(NativeArch::user_regs_struct) };\n return iov;\n }\n\n DEBUG_ASSERT(arch() == x86 && NativeArch::arch() == x86_64);\n iovec iov = { &u.x86regs, sizeof(u.x86regs) };\n return iov;\n}\n\nRegisters::InternalData Registers::get_ptrace_for_self_arch() const {\n switch (arch_) {\n case x86:\n return { reinterpret_cast(&u.x86regs),\n sizeof(u.x86regs) };\n case x86_64:\n return { reinterpret_cast(&u.x64regs),\n sizeof(u.x64regs) };\n case aarch64:\n return { reinterpret_cast(&u.arm64regs._ptrace),\n sizeof(u.arm64regs._ptrace) };\n default:\n DEBUG_ASSERT(0 && \"Unknown arch\");\n return { nullptr, 0 };\n }\n}\n\nRegisters::InternalData Registers::get_regs_for_trace() const {\n switch (arch_) {\n case x86:\n return { reinterpret_cast(&u.x86regs),\n sizeof(u.x86regs) };\n case x86_64:\n return { reinterpret_cast(&u.x64regs),\n sizeof(u.x64regs) };\n case aarch64:\n return { reinterpret_cast(&u.arm64regs),\n sizeof(u.arm64regs) };\n default:\n DEBUG_ASSERT(0 && \"Unknown arch\");\n return { nullptr, 0 };\n }\n}\n\nvector Registers::get_ptrace_for_arch(SupportedArch arch) const {\n Registers tmp_regs(arch);\n tmp_regs.set_from_ptrace(get_ptrace());\n\n InternalData tmp_data = tmp_regs.get_ptrace_for_self_arch();\n vector result;\n result.resize(tmp_data.size);\n memcpy(result.data(), tmp_data.data, tmp_data.size);\n return result;\n}\n\nvoid Registers::set_from_ptrace_for_arch(SupportedArch a, const void* data,\n size_t size) {\n if (a == NativeArch::arch()) {\n DEBUG_ASSERT(size == sizeof(NativeArch::user_regs_struct));\n set_from_ptrace(*static_cast(data));\n return;\n }\n\n DEBUG_ASSERT(a == x86 && NativeArch::arch() == x86_64);\n // We don't support a 32-bit tracee trying to set registers of a 64-bit tracee\n DEBUG_ASSERT(arch() == x86);\n DEBUG_ASSERT(size == sizeof(u.x86regs));\n memcpy(&u.x86regs, data, sizeof(u.x86regs));\n}\n\nvoid Registers::set_from_trace(SupportedArch a, const void* data,\n size_t size) {\n if (is_x86ish(a)) {\n return set_from_ptrace_for_arch(a, data, size);\n }\n\n DEBUG_ASSERT(a == aarch64);\n DEBUG_ASSERT(size == sizeof(u.arm64regs));\n memcpy(&u.arm64regs, data, sizeof(u.arm64regs));\n}\n\nbool Registers::aarch64_singlestep_flag() const {\n switch (arch()) {\n case aarch64:\n return pstate() & AARCH64_DBG_SPSR_SS;\n default:\n DEBUG_ASSERT(0 && \"X86 only code path\");\n return false;\n }\n}\n\nvoid Registers::set_aarch64_singlestep_flag() {\n switch (arch()) {\n case aarch64:\n return set_pstate(pstate() | AARCH64_DBG_SPSR_SS);\n default:\n DEBUG_ASSERT(0 && \"AArch64 only code path\");\n return;\n }\n}\n\nbool Registers::x86_singlestep_flag() const {\n switch (arch()) {\n case x86:\n case x86_64:\n return flags() & X86_TF_FLAG;\n default:\n DEBUG_ASSERT(0 && \"X86 only code path\");\n return false;\n }\n}\n\nvoid Registers::clear_x86_singlestep_flag() {\n switch (arch()) {\n case x86:\n case x86_64:\n set_flags(flags() & ~X86_TF_FLAG);\n return;\n default:\n DEBUG_ASSERT(0 && \"X86 only code path\");\n break;\n }\n}\n\nbool Registers::syscall_failed() const {\n auto result = syscall_result_signed();\n return -4096 < result && result < 0;\n}\n\nbool Registers::syscall_may_restart() const {\n switch (-syscall_result_signed()) {\n case ERESTART_RESTARTBLOCK:\n case ERESTARTNOINTR:\n case ERESTARTNOHAND:\n case ERESTARTSYS:\n return true;\n default:\n return false;\n }\n}\n\nostream& operator<<(ostream& stream, const Registers& r) {\n stream << \"{ ip:\" << HEX(r.ip().register_value()) << \" args:(\" << HEX(r.arg1()) << \",\" << HEX(r.arg2()) << \",\"\n << HEX(r.arg3()) << \",\" << HEX(r.arg4()) << \",\" << HEX(r.arg5()) << \",\"\n << r.arg6() << \") orig_syscall: \" << r.original_syscallno()\n << \" syscallno: \" << r.syscallno();\n if (r.arch() == aarch64) {\n stream << \" orig_arg1: \" << HEX(r.orig_arg1());\n }\n stream << \" }\";\n return stream;\n}\n\nvoid Registers::emulate_syscall_entry() {\n set_original_syscallno(syscallno());\n set_orig_arg1(arg1());\n /**\n * The aarch64 kernel has a quirk where if the syscallno is -1 (and only -1),\n * it will apply the -ENOSYS result before any ptrace entry stop.\n * On x86, this happens unconditionally for every syscall, but there the\n * result isn't shared with arg1, and we usually don't care because we have\n * access to original_syscallno.\n */\n if (is_x86ish(arch()) || (arch() == aarch64 && syscallno() == -1)) {\n set_syscall_result(-ENOSYS);\n }\n}\n\n} // namespace rr\n" }, { "path": "src/Registers.h", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#ifndef RR_REGISTERS_H_\n#define RR_REGISTERS_H_\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"GdbServerRegister.h\"\n#include \"core.h\"\n#include \"kernel_abi.h\"\n#include \"remote_code_ptr.h\"\n#include \"remote_ptr.h\"\n\nstruct iovec;\n\nnamespace rr {\n\nclass ReplayTask;\n\nconst uintptr_t X86_RESERVED_FLAG = 1 << 1;\nconst uintptr_t X86_ZF_FLAG = 1 << 6;\nconst uintptr_t X86_TF_FLAG = 1 << 8;\nconst uintptr_t X86_IF_FLAG = 1 << 9;\nconst uintptr_t X86_DF_FLAG = 1 << 10;\nconst uintptr_t X86_RF_FLAG = 1 << 16;\nconst uintptr_t X86_ID_FLAG = 1 << 21;\n\nconst uintptr_t AARCH64_DBG_SPSR_SS = 1 << 21;\nconst uintptr_t AARCH64_DBG_SPSR_11 = 1 << 11;\n\n/**\n * A Registers object contains values for all general-purpose registers.\n * These must include all registers used to pass syscall parameters and return\n * syscall results.\n *\n * When reading register values, be sure to cast the result to the correct\n * type according to the kernel docs. E.g. int values should be cast\n * to int explicitly (or implicitly, by assigning to an int-typed variable),\n * size_t should be cast to size_t, etc. If the type is signed, call the\n * _signed getter. This ensures that when building rr 64-bit we will use the\n * right number of register bits whether the tracee is 32-bit or 64-bit, and\n * get sign-extension right.\n *\n * We have different register sets for different architectures. To ensure a\n * trace can be dumped/processed by an rr build on any platform, we allow\n * Registers to contain registers for any architecture. So we store them\n * in a union of Arch::user_regs_structs for each known Arch.\n */\nclass Registers {\npublic:\n enum { MAX_SIZE = 32 };\n\n Registers(SupportedArch a = x86) : arch_(a) {\n memset(&u, 0, sizeof(u));\n }\n\n SupportedArch arch() const { return arch_; }\n\n void set_arch(SupportedArch a) { arch_ = a; }\n\n /**\n * Copy a user_regs_struct into these Registers. If the tracee architecture\n * is not rr's native architecture, then it must be a 32-bit tracee with a\n * 64-bit rr. In that case the user_regs_struct is 64-bit and we extract\n * the 32-bit register values from it into u.x86regs.\n * It's invalid to call this when the Registers' arch is 64-bit and the\n * rr build is 32-bit, or when the Registers' arch is completely different\n * to the rr build (e.g. ARM vs x86).\n */\n void set_from_ptrace(const NativeArch::user_regs_struct& ptrace_regs);\n\n /**\n * Get a user_regs_struct from these Registers. If the tracee architecture\n * is not rr's native architecture, then it must be a 32-bit tracee with a\n * 64-bit rr. In that case the user_regs_struct is 64-bit and we copy\n * the 32-bit register values from u.x86regs into it.\n * It's invalid to call this when the Registers' arch is 64-bit and the\n * rr build is 32-bit, or when the Registers' arch is completely different\n * to the rr build (e.g. ARM vs x86).\n */\n NativeArch::user_regs_struct get_ptrace() const;\n iovec get_ptrace_iovec();\n\n /**\n * Get a user_regs_struct for a particular Arch from these Registers.\n * It's invalid to call this when 'arch' is 64-bit and the\n * rr build is 32-bit, or when the Registers' arch is completely different\n * to the rr build (e.g. ARM vs x86).\n */\n std::vector get_ptrace_for_arch(SupportedArch arch) const;\n struct InternalData {\n const uint8_t* data;\n size_t size;\n };\n\n /**\n * Get the register content to save in the trace.\n */\n InternalData get_regs_for_trace() const;\n\n /**\n * Equivalent to get_ptrace_for_arch(arch()) but doesn't copy.\n */\n InternalData get_ptrace_for_self_arch() const;\n\n /**\n * Copy an arch-specific user_regs_struct into these Registers.\n * It's invalid to call this when 'arch' is 64-bit and the\n * rr build is 32-bit, or when the Registers' arch is completely different\n * to the rr build (e.g. ARM vs x86).\n */\n void set_from_ptrace_for_arch(SupportedArch arch, const void* data,\n size_t size);\n\n /**\n * Copy from the arch-specific structure returned in get_regs_for_trace()\n * back into *this\n */\n void set_from_trace(SupportedArch arch, const void* data,\n size_t size);\n\n#define ARCH_SWITCH_CASE(rettype, x86case, x64case, arm64case) \\\n(([&](void) -> rettype { \\\n switch (arch()) { \\\n default: \\\n DEBUG_ASSERT(0 && \"unknown architecture\"); \\\n RR_FALLTHROUGH; /* Fall through to avoid warnings */ \\\n case x86: { \\\n x86case; \\\n break; \\\n } \\\n case x86_64: { \\\n x64case; \\\n break; \\\n } \\\n case aarch64: { \\\n arm64case; \\\n break; \\\n } \\\n } \\\n})())\n\n#define RR_GET_REG(x86case, x64case, arm64case) \\\n ARCH_SWITCH_CASE(uint64_t, \\\n return (uint32_t)u.x86regs.x86case, \\\n return u.x64regs.x64case, \\\n return u.arm64regs.arm64case)\n\n#define RR_GET_REG_SIGNED(x86case, x64case, arm64case) \\\n ARCH_SWITCH_CASE(int64_t, \\\n return (int32_t)u.x86regs.x86case, \\\n return u.x64regs.x64case, \\\n return u.arm64regs.arm64case)\n\n#define RR_GET_REG_X86(x86case, x64case) \\\n ARCH_SWITCH_CASE(uint64_t, \\\n return (uint32_t)u.x86regs.x86case, \\\n return u.x64regs.x64case, \\\n DEBUG_ASSERT(0 && \"Hit an x86-only case, but this is not x86\"); return 0)\n\n#define RR_UPDATE_CHECK(loc, value) bool changed = (uintptr_t)loc != (uintptr_t)(value); \\\n loc = (value); \\\n return changed;\n#define RR_SET_REG(x86case, x64case, arm64case, value) \\\n ARCH_SWITCH_CASE(bool, \\\n RR_UPDATE_CHECK(u.x86regs.x86case, value), \\\n RR_UPDATE_CHECK(u.x64regs.x64case, value), \\\n RR_UPDATE_CHECK(u.arm64regs.arm64case, value))\n\n#define RR_SET_REG_X86(x86case, x64case, value) \\\n ARCH_SWITCH_CASE(bool, \\\n RR_UPDATE_CHECK(u.x86regs.x86case, value), \\\n RR_UPDATE_CHECK(u.x64regs.x64case, value), \\\n DEBUG_ASSERT(0 && \"Hit an x86-only case, but this is not x86\"); return false)\n\n remote_code_ptr ip() const { return RR_GET_REG(eip, rip, pc); }\n bool set_ip(remote_code_ptr addr) {\n return RR_SET_REG(eip, rip, pc, addr.register_value());\n }\n remote_ptr sp() const { return RR_GET_REG(esp, rsp, sp); }\n bool set_sp(remote_ptr addr) { return RR_SET_REG(esp, rsp, sp, addr.as_int()); }\n\n // Access the registers holding system-call numbers, results, and\n // parameters.\n\n intptr_t syscallno() const { return (int)RR_GET_REG(eax, rax, x[8]); }\n bool set_syscallno(intptr_t syscallno) { return RR_SET_REG(eax, rax, x[8], syscallno); }\n\n /**\n * This pseudo-register holds the system-call number when we get ptrace\n * enter-system-call and exit-system-call events. Setting it changes\n * the system-call executed when resuming after an enter-system-call\n * event.\n */\n intptr_t original_syscallno() const {\n return RR_GET_REG_SIGNED(orig_eax, orig_rax, orig_syscall);\n }\n bool set_original_syscallno(intptr_t syscallno) {\n return RR_SET_REG(orig_eax, orig_rax, orig_syscall, syscallno);\n }\n\n #define SYSCALL_REGISTER(name, x86case, x64case, arm64case) \\\n uintptr_t name() const { return RR_GET_REG(x86case, x64case, arm64case); } \\\n intptr_t name ## _signed() const { \\\n return RR_GET_REG_SIGNED(x86case, x64case, arm64case); \\\n } \\\n bool set_ ## name(uintptr_t value) { \\\n return RR_SET_REG(x86case, x64case, arm64case, value); \\\n } \\\n template bool set_ ## name(remote_ptr value) { \\\n return RR_SET_REG(x86case, x64case, arm64case, value.as_int()); \\\n }\n\n SYSCALL_REGISTER(syscall_result, eax, rax, x[0]);\n SYSCALL_REGISTER(orig_arg1, ebx, rdi, orig_x0)\n SYSCALL_REGISTER(arg1, ebx, rdi, x[0])\n SYSCALL_REGISTER(arg2, ecx, rsi, x[1])\n SYSCALL_REGISTER(arg3, edx, rdx, x[2])\n SYSCALL_REGISTER(arg4, esi, r10, x[3])\n SYSCALL_REGISTER(arg5, edi, r8, x[4])\n SYSCALL_REGISTER(arg6, ebp, r9, x[5])\n\n uintptr_t arg(int index) const {\n switch (index) {\n case 1:\n return arg1();\n case 2:\n return arg2();\n case 3:\n return arg3();\n case 4:\n return arg4();\n case 5:\n return arg5();\n case 6:\n return arg6();\n default:\n DEBUG_ASSERT(0 && \"Argument index out of range\");\n return 0;\n }\n }\n\n /**\n * Set the register containing syscall argument |Index| to\n * |value|.\n */\n template bool set_arg(std::nullptr_t) { return set_arg(Index, 0); }\n template bool set_arg(remote_ptr value) {\n return set_arg(Index, value.as_int());\n }\n template bool set_arg(T value) {\n return set_arg(Index, uintptr_t(value));\n }\n\n bool set_arg(int index, uintptr_t value) {\n switch (index) {\n case 1:\n return set_arg1(value);\n case 2:\n return set_arg2(value);\n case 3:\n return set_arg3(value);\n case 4:\n return set_arg4(value);\n case 5:\n return set_arg5(value);\n case 6:\n return set_arg6(value);\n default:\n DEBUG_ASSERT(0 && \"Argument index out of range\");\n return false;\n }\n }\n\n bool set_orig_arg(int index, uintptr_t value) {\n switch (index) {\n case 1:\n return set_orig_arg1(value);\n case 2:\n return set_arg2(value);\n case 3:\n return set_arg3(value);\n case 4:\n return set_arg4(value);\n case 5:\n return set_arg5(value);\n case 6:\n return set_arg6(value);\n default:\n DEBUG_ASSERT(0 && \"Argument index out of range\");\n return false;\n }\n }\n\n /**\n * Returns true if syscall_result() indicates failure.\n */\n bool syscall_failed() const;\n\n /**\n * Returns true if syscall_result() indicates a syscall restart.\n */\n bool syscall_may_restart() const;\n\n // Some X86-specific stuff follows. Use of these accessors should be guarded\n // by an architecture test.\n /**\n * Set the output registers of the |rdtsc| instruction.\n */\n void set_rdtsc_output(uint64_t value) {\n RR_SET_REG_X86(eax, rax, value & 0xffffffff);\n RR_SET_REG_X86(edx, rdx, value >> 32);\n }\n\n void set_cpuid_output(uint32_t eax, uint32_t ebx, uint32_t ecx,\n uint32_t edx) {\n RR_SET_REG_X86(eax, rax, eax);\n RR_SET_REG_X86(ebx, rbx, ebx);\n RR_SET_REG_X86(ecx, rcx, ecx);\n RR_SET_REG_X86(edx, rdx, edx);\n }\n\n bool set_r8(uintptr_t value) {\n DEBUG_ASSERT(arch() == x86_64);\n RR_UPDATE_CHECK(u.x64regs.r8, value);\n }\n\n bool set_r9(uintptr_t value) {\n DEBUG_ASSERT(arch() == x86_64);\n RR_UPDATE_CHECK(u.x64regs.r9, value);\n }\n\n bool set_r10(uintptr_t value) {\n DEBUG_ASSERT(arch() == x86_64);\n RR_UPDATE_CHECK(u.x64regs.r10, value);\n }\n\n bool set_r11(uintptr_t value) {\n DEBUG_ASSERT(arch() == x86_64);\n RR_UPDATE_CHECK(u.x64regs.r11, value);\n }\n\n uintptr_t di() const { return RR_GET_REG_X86(edi, rdi); }\n bool set_di(uintptr_t value) { return RR_SET_REG_X86(edi, rdi, value); }\n\n uintptr_t si() const { return RR_GET_REG_X86(esi, rsi); }\n bool set_si(uintptr_t value) { return RR_SET_REG_X86(esi, rsi, value); }\n\n uintptr_t cx() const { return RR_GET_REG_X86(ecx, rcx); }\n bool set_cx(uintptr_t value) { return RR_SET_REG_X86(ecx, rcx, value); }\n\n uintptr_t ax() const { return RR_GET_REG_X86(eax, rax); }\n bool set_ax(uintptr_t value) { return RR_SET_REG_X86(eax, rax, value); }\n\n uintptr_t dx() const { return RR_GET_REG_X86(edx, rdx); }\n bool set_dx(uintptr_t value) { return RR_SET_REG_X86(edx, rdx, value); }\n\n uintptr_t bp() const { return RR_GET_REG_X86(ebp, rbp); }\n\n uintptr_t flags() const { return RR_GET_REG_X86(eflags, eflags); };\n bool set_flags(uintptr_t value) { return RR_SET_REG_X86(eflags, eflags, value); }\n bool zf_flag() const { return flags() & X86_ZF_FLAG; }\n bool df_flag() const { return flags() & X86_DF_FLAG; }\n\n uintptr_t fs_base() const {\n DEBUG_ASSERT(arch() == x86_64);\n return u.x64regs.fs_base;\n }\n uintptr_t gs_base() const {\n DEBUG_ASSERT(arch() == x86_64);\n return u.x64regs.gs_base;\n }\n\n void set_fs_base(uintptr_t fs_base) {\n DEBUG_ASSERT(arch() == x86_64);\n u.x64regs.fs_base = fs_base;\n }\n void set_gs_base(uintptr_t gs_base) {\n DEBUG_ASSERT(arch() == x86_64);\n u.x64regs.gs_base = gs_base;\n }\n\n uint64_t cs() const { return RR_GET_REG_X86(xcs, cs); }\n uint64_t ss() const { return RR_GET_REG_X86(xss, ss); }\n uint64_t ds() const { return RR_GET_REG_X86(xds, ds); }\n uint64_t es() const { return RR_GET_REG_X86(xes, es); }\n uint64_t fs() const { return RR_GET_REG_X86(xfs, fs); }\n uint64_t gs() const { return RR_GET_REG_X86(xgs, gs); }\n\n // End of X86-specific stuff\n // Begin aarch64 specific accessors\n uintptr_t pstate() const {\n DEBUG_ASSERT(arch() == aarch64);\n return u.arm64regs.pstate;\n }\n\n void set_pstate(uintptr_t pstate) {\n DEBUG_ASSERT(arch() == aarch64);\n u.arm64regs.pstate = pstate;\n }\n\n void set_x(unsigned regno, uintptr_t val) {\n DEBUG_ASSERT(arch() == aarch64 && regno < 31);\n u.arm64regs.x[regno] = val;\n }\n\n uintptr_t x(unsigned regno) const {\n DEBUG_ASSERT(arch() == aarch64 && regno < 31);\n return u.arm64regs.x[regno];\n }\n // End of aarch64 specific accessors\n\n /**\n * Modify the processor's single step flag. On x86 this is the TF flag in the\n * eflags register.\n */\n bool x86_singlestep_flag() const;\n void clear_x86_singlestep_flag();\n\n /**\n * Aarch64 has two flags that control single stepping. An EL1 one that\n * enables singlestep exceptions and an EL0 one in pstate (SPSR_SS). The EL1 bit\n * is controlled by PTRACE_SINGLESTEP (it gets turned on upon the first\n * PTRACE_(SYSEMU_)SINGLESTEP and turned off on any other ptrace resume).\n * The EL0 bit controls whether an exception is taken *before* execution\n * of the next instruction (an exception is taken when the bit is *clear*).\n * The hardware clears this bit whenever an instruction completes. Thus, to\n * ensure that a single step actually happens, regardless of how we got to\n * this step, we must both using PTRACE_SINGLESTEP and *set* the SPSR_SS bit.\n * Otherwise, if we got to this stop via single step, the SPSR_SS bit will\n * likely already be clear, and we'd take a single step exception without\n * ever having executed any userspace instructions whatsoever.\n */\n bool aarch64_singlestep_flag() const;\n void set_aarch64_singlestep_flag();\n\n void print_register_file(FILE* f) const;\n void print_register_file_compact(FILE* f) const;\n void print_register_file_for_trace_raw(FILE* f) const;\n\n struct Mismatch {\n std::string register_name;\n std::string val1;\n std::string val2;\n };\n struct Comparison {\n std::vector mismatches;\n int mismatch_count = 0;\n bool store_mismatches = true;\n\n void add_mismatch(const char* reg_name, uint64_t val1, uint64_t val2);\n };\n\n // This is cheap when there are no mismatches. It can be a bit expensive\n // (allocation) when mismatches are expected; call matches() instead in\n // that case, which doesn't allocate.\n Comparison compare_with(const Registers& other) const {\n Comparison result;\n compare_internal(other, result);\n return result;\n }\n\n bool matches(const Registers& other) const {\n Comparison result;\n result.store_mismatches = false;\n compare_internal(other, result);\n return !result.mismatch_count;\n }\n\n // TODO: refactor me to use the GdbServerRegisterValue helper from\n // GdbServerConnection.h.\n\n /**\n * Write the value for register |regno| into |buf|, which should\n * be large enough to hold any register supported by the target.\n * Return the size of the register in bytes and set |defined| to\n * indicate whether a useful value has been written to |buf|.\n */\n size_t read_register(uint8_t* buf, GdbServerRegister regno, bool* defined) const;\n\n /**\n * Write the value for register |offset| into |buf|, which should\n * be large enough to hold any register supported by the target.\n * Return the size of the register in bytes and set |defined| to\n * indicate whether a useful value has been written to |buf|.\n * |offset| is the offset of the register within a user_regs_struct.\n */\n size_t read_register_by_user_offset(uint8_t* buf, uintptr_t offset,\n bool* defined) const;\n\n /**\n * Update the register named |reg_name| to |value| with\n * |value_size| number of bytes.\n */\n bool write_register(GdbServerRegister reg_name, const void* value,\n size_t value_size);\n\n /**\n * Update the register at user offset |offset| to |value|, taking the low\n * bytes if necessary.\n */\n void write_register_by_user_offset(uintptr_t offset, uintptr_t value);\n\n\n bool operator==(const Registers &other) const {\n if (arch() != other.arch()) {\n return false;\n }\n switch (arch()) {\n case x86:\n return memcmp(&u.x86regs, &other.u.x86regs, sizeof(u.x86regs)) == 0;\n case x86_64:\n return memcmp(&u.x64regs, &other.u.x64regs, sizeof(u.x64regs)) == 0;\n case aarch64:\n return memcmp(&u.arm64regs, &other.u.arm64regs, sizeof(u.arm64regs)) == 0;\n default:\n DEBUG_ASSERT(0 && \"Unknown architecture\");\n return false;\n }\n }\n\n bool operator!=(const Registers &other) const {\n return !(*this == other);\n }\n\n void emulate_syscall_entry();\n\nprivate:\n template \n void print_register_file_arch(FILE* f, const char* formats[]) const;\n\n enum TraceStyle {\n Annotated,\n Raw,\n };\n\n template \n void print_register_file_for_trace_arch(FILE* f, TraceStyle style,\n const char* formats[]) const;\n\n template \n static void compare_registers_core(const Registers& reg1,\n const Registers& reg2,\n Comparison& result);\n\n template \n static void compare_registers_arch(const Registers& reg1,\n const Registers& reg2,\n Comparison& result);\n\n void compare_internal(const Registers& other, Comparison& result) const;\n\n template \n size_t read_register_arch(uint8_t* buf, GdbServerRegister regno,\n bool* defined) const;\n\n template \n size_t read_register_by_user_offset_arch(uint8_t* buf, uintptr_t offset,\n bool* defined) const;\n\n template \n bool write_register_arch(GdbServerRegister regno, const void* value,\n size_t value_size);\n\n template \n void write_register_by_user_offset_arch(uintptr_t offset, uintptr_t value);\n\n template size_t total_registers_arch() const;\n\n SupportedArch arch_;\n union {\n rr::X86Arch::user_regs_struct x86regs;\n rr::X64Arch::user_regs_struct x64regs;\n struct {\n // This is the NT_PRSTATUS regset\n union {\n rr::ARM64Arch::user_regs_struct _ptrace;\n // This duplicates the field names of the user_regs_struct and makes\n // them available as fields of arm64regs for easy access.\n struct {\n uint64_t x[31];\n uint64_t sp;\n uint64_t pc;\n uint64_t pstate;\n };\n };\n // This is not exposed through GETREGSET. We track it manually\n uint64_t orig_x0;\n // This is the NT_ARM_SYSTEM_CALL regset\n int orig_syscall;\n } arm64regs;\n } u;\n};\n\ntemplate \nret with_converted_registers(const Registers& regs, SupportedArch arch,\n callback f) {\n if (regs.arch() != arch) {\n // If this is a cross architecture syscall, first convert the registers.\n Registers converted_regs(arch);\n std::vector data = regs.get_ptrace_for_arch(arch);\n converted_regs.set_from_ptrace_for_arch(arch, data.data(), data.size());\n return f(converted_regs);\n }\n return f(regs);\n}\n\nstd::ostream& operator<<(std::ostream& stream, const Registers& r);\n\nstd::ostream& operator<<(std::ostream& stream, const Registers::Comparison& c);\n\n} // namespace rr\n\n#endif /* RR_REGISTERS_H_ */\n" }, { "path": "src/ReplayCommand.cc", "content": "/* -*- Mode: C++; tab-width: 8; c-basic-offset: 2; indent-tabs-mode: nil; -*- */\n\n#include \"ReplayCommand.h\"\n\n#include \n#include \n#include \n#include \n\n#include \n\n#include \"Command.h\"\n#include \"Flags.h\"\n#include \"GdbServer.h\"\n#include \"ReplaySession.h\"\n#include \"ScopedFd.h\"\n#include \"WaitManager.h\"\n#include \"core.h\"\n#include \"kernel_metadata.h\"\n#include \"launch_debugger.h\"\n#include \"log.h\"\n#include \"main.h\"\n\nusing namespace std;\n\nnamespace rr {\n\nReplayCommand ReplayCommand::singleton(\n \"replay\",\n \" rr replay [OPTION]... [] [-- ]\\n\"\n \" -a, --autopilot replay without debugger server\\n\"\n \" -f, --onfork= start a debug server when has been\\n\"\n \" fork()d, AND the target event has been\\n\"\n \" reached.\\n\"\n \" -g, --goto= start a debug server on reaching \"\n \"\\n\"\n \" in the trace. See -M in the general \"\n \"options.\\n\"\n \" -e, --goto-exit start a debug server at the end of the \"\n \"recording\\n\"\n \" or the end of the specified process.\\n\"\n \" -o, --debugger-option=