The Tor Browser: js/src/perf/pm_linux.cpp@129ffea94266 (annotated)

js/src/perf/pm_linux.cpp@129ffea94266 (annotated)

js/src/perf/pm_linux.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /* This variant of nsIPerfMeasurement uses the perf_event interface
  * added in Linux 2.6.31.  We key compilation of this file off the
  * existence of <linux/perf_event.h>.
  */
 #include <errno.h>
 #include <linux/perf_event.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 #include "perf/jsperf.h"
 using namespace js;
 // As of July 2010, this system call has not been added to the
 // C library, so we have to provide our own wrapper function.
 // If this code runs on a kernel that does not implement the
 // system call (2.6.30 or older) nothing unpredictable will
 // happen - it will just always fail and return -1.
 static int
 sys_perf_event_open(struct perf_event_attr *attr, pid_t pid, int cpu,
                     int group_fd, unsigned long flags)
 {
     return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
 }
 namespace {
 using JS::PerfMeasurement;
 typedef PerfMeasurement::EventMask EventMask;
 // Additional state required by this implementation.
 struct Impl
 {
     // Each active counter corresponds to an open file descriptor.
     int f_cpu_cycles;
     int f_instructions;
     int f_cache_references;
     int f_cache_misses;
     int f_branch_instructions;
     int f_branch_misses;
     int f_bus_cycles;
     int f_page_faults;
     int f_major_page_faults;
     int f_context_switches;
     int f_cpu_migrations;
     // Counter group leader, for Start and Stop.
     int group_leader;
     // Whether counters are running.
     bool running;
     Impl();
     ~Impl();
     EventMask init(EventMask toMeasure);
     void start();
     void stop(PerfMeasurement* counters);
 };
 // Mapping from our event bitmask to codes passed into the kernel, and
 // to fields in the PerfMeasurement and PerfMeasurement::impl structures.
 static const struct
 {
     EventMask bit;
     uint32_t type;
     uint32_t config;
     uint64_t PerfMeasurement::* counter;
     int Impl::* fd;
 } kSlots[PerfMeasurement::NUM_MEASURABLE_EVENTS] = {
 #define HW(mask, constant, fieldname)                                   \
     { PerfMeasurement::mask, PERF_TYPE_HARDWARE, PERF_COUNT_HW_##constant, \
       &PerfMeasurement::fieldname, &Impl::f_##fieldname }
 #define SW(mask, constant, fieldname)                                   \
     { PerfMeasurement::mask, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_##constant, \
       &PerfMeasurement::fieldname, &Impl::f_##fieldname }
     HW(CPU_CYCLES,          CPU_CYCLES,          cpu_cycles),
     HW(INSTRUCTIONS,        INSTRUCTIONS,        instructions),
     HW(CACHE_REFERENCES,    CACHE_REFERENCES,    cache_references),
     HW(CACHE_MISSES,        CACHE_MISSES,        cache_misses),
     HW(BRANCH_INSTRUCTIONS, BRANCH_INSTRUCTIONS, branch_instructions),
     HW(BRANCH_MISSES,       BRANCH_MISSES,       branch_misses),
     HW(BUS_CYCLES,          BUS_CYCLES,          bus_cycles),
     SW(PAGE_FAULTS,         PAGE_FAULTS,         page_faults),
     SW(MAJOR_PAGE_FAULTS,   PAGE_FAULTS_MAJ,     major_page_faults),
     SW(CONTEXT_SWITCHES,    CONTEXT_SWITCHES,    context_switches),
     SW(CPU_MIGRATIONS,      CPU_MIGRATIONS,      cpu_migrations),
 #undef HW
 #undef SW
 };
 Impl::Impl()
   : f_cpu_cycles(-1),
     f_instructions(-1),
     f_cache_references(-1),
     f_cache_misses(-1),
     f_branch_instructions(-1),
     f_branch_misses(-1),
     f_bus_cycles(-1),
     f_page_faults(-1),
     f_major_page_faults(-1),
     f_context_switches(-1),
     f_cpu_migrations(-1),
     group_leader(-1),
     running(false)
 {
 }
 Impl::~Impl()
 {
     // Close all active counter descriptors.  Take care to do the group
     // leader last (this may not be necessary, but it's unclear what
     // happens if you close the group leader out from under a group).
     for (int i = 0; i < PerfMeasurement::NUM_MEASURABLE_EVENTS; i++) {
         int fd = this->*(kSlots[i].fd);
         if (fd != -1 && fd != group_leader)
             close(fd);
     }
     if (group_leader != -1)
         close(group_leader);
 }
 EventMask
 Impl::init(EventMask toMeasure)
 {
     JS_ASSERT(group_leader == -1);
     if (!toMeasure)
         return EventMask(0);
     EventMask measured = EventMask(0);
     struct perf_event_attr attr;
     for (int i = 0; i < PerfMeasurement::NUM_MEASURABLE_EVENTS; i++) {
         if (!(toMeasure & kSlots[i].bit))
             continue;
         memset(&attr, 0, sizeof(attr));
         attr.size = sizeof(attr);
         // Set the type and config fields to indicate the counter we
         // want to enable.  We want read format 0, and we're not using
         // sampling, so leave those fields unset.
         attr.type = kSlots[i].type;
         attr.config = kSlots[i].config;
         // If this will be the group leader it should start off
         // disabled.  Otherwise it should start off enabled (but blocked
         // on the group leader).
         if (group_leader == -1)
             attr.disabled = 1;
         // The rest of the bit fields are really poorly documented.
         // For instance, I have *no idea* whether we should be setting
         // the inherit, inherit_stat, or task flags.  I'm pretty sure
         // we do want to set mmap and comm, and not any of the ones I
         // haven't mentioned.
         attr.mmap = 1;
         attr.comm = 1;
         int fd = sys_perf_event_open(&attr,
 /* trace self */,
                                      -1 /* on any cpu */,
                                      group_leader,
 /* no flags presently defined */);
         if (fd == -1)
             continue;
         measured = EventMask(measured | kSlots[i].bit);
         this->*(kSlots[i].fd) = fd;
         if (group_leader == -1)
             group_leader = fd;
     }
     return measured;
 }
 void
 Impl::start()
 {
     if (running || group_leader == -1)
         return;
     running = true;
     ioctl(group_leader, PERF_EVENT_IOC_ENABLE, 0);
 }
 void
 Impl::stop(PerfMeasurement* counters)
 {
     // This scratch buffer is to ensure that we have read all the
     // available data, even if that's more than we expect.
     unsigned char buf[1024];
     if (!running || group_leader == -1)
         return;
     ioctl(group_leader, PERF_EVENT_IOC_DISABLE, 0);
     running = false;
     // read out and reset all the counter values
     for (int i = 0; i < PerfMeasurement::NUM_MEASURABLE_EVENTS; i++) {
         int fd = this->*(kSlots[i].fd);
         if (fd == -1)
             continue;
         if (read(fd, buf, sizeof(buf)) == sizeof(uint64_t)) {
             uint64_t cur;
             memcpy(&cur, buf, sizeof(uint64_t));
             counters->*(kSlots[i].counter) += cur;
         }
         // Reset the counter regardless of whether the read did what
         // we expected.
         ioctl(fd, PERF_EVENT_IOC_RESET, 0);
     }
 }
 } // anonymous namespace
 namespace JS {
 #define initCtr(flag) ((eventsMeasured & flag) ? 0 : -1)
 PerfMeasurement::PerfMeasurement(PerfMeasurement::EventMask toMeasure)
   : impl(js_new<Impl>()),
     eventsMeasured(impl ? static_cast<Impl*>(impl)->init(toMeasure)
                    : EventMask(0)),
     cpu_cycles(initCtr(CPU_CYCLES)),
     instructions(initCtr(INSTRUCTIONS)),
     cache_references(initCtr(CACHE_REFERENCES)),
     cache_misses(initCtr(CACHE_MISSES)),
     branch_instructions(initCtr(BRANCH_INSTRUCTIONS)),
     branch_misses(initCtr(BRANCH_MISSES)),
     bus_cycles(initCtr(BUS_CYCLES)),
     page_faults(initCtr(PAGE_FAULTS)),
     major_page_faults(initCtr(MAJOR_PAGE_FAULTS)),
     context_switches(initCtr(CONTEXT_SWITCHES)),
     cpu_migrations(initCtr(CPU_MIGRATIONS))
 {
 }
 #undef initCtr
 PerfMeasurement::~PerfMeasurement()
 {
     js_delete(static_cast<Impl*>(impl));
 }
 void
 PerfMeasurement::start()
 {
     if (impl)
         static_cast<Impl*>(impl)->start();
 }
 void
 PerfMeasurement::stop()
 {
     if (impl)
         static_cast<Impl*>(impl)->stop(this);
 }
 void
 PerfMeasurement::reset()
 {
     for (int i = 0; i < NUM_MEASURABLE_EVENTS; i++) {
         if (eventsMeasured & kSlots[i].bit)
             this->*(kSlots[i].counter) = 0;
         else
             this->*(kSlots[i].counter) = -1;
     }
 }
 bool
 PerfMeasurement::canMeasureSomething()
 {
     // Find out if the kernel implements the performance measurement
     // API.  If it doesn't, syscall(__NR_perf_event_open, ...) is
     // guaranteed to return -1 and set errno to ENOSYS.
     //
     // We set up input parameters that should provoke an EINVAL error
     // from a kernel that does implement perf_event_open, but we can't
     // be sure it will (newer kernels might add more event types), so
     // we have to take care to close any valid fd it might return.
     struct perf_event_attr attr;
     memset(&attr, 0, sizeof(attr));
     attr.size = sizeof(attr);
     attr.type = PERF_TYPE_MAX;
     int fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
     if (fd >= 0) {
         close(fd);
         return true;
     } else {
         return errno != ENOSYS;
     }
 }
 } // namespace JS

The Tor Browser / annotate

js/src/perf/pm_linux.cpp@129ffea94266 (annotated)

js/src/perf/pm_linux.cpp