Merge "Simpleperf: support callgraph option in report command."
diff --git a/simpleperf/cmd_help.cpp b/simpleperf/cmd_help.cpp
index 75df732..cc66376 100644
--- a/simpleperf/cmd_help.cpp
+++ b/simpleperf/cmd_help.cpp
@@ -55,10 +55,16 @@
}
void HelpCommand::PrintShortHelp() {
- printf("Usage: simpleperf [--help] subcommand [args_for_subcommand]\n\n");
+ printf(
+ "Usage: simpleperf [common options] subcommand [args_for_subcommand]\n"
+ "common options:\n"
+ " -h/--help Print this help information.\n"
+ " --log <severity> Set the minimum severity of logging. Possible severities\n"
+ " include debug, warning, error, fatal. Default is error.\n"
+ "subcommands:\n");
for (auto& cmd_name : GetAllCommandNames()) {
std::unique_ptr<Command> cmd = CreateCommandInstance(cmd_name);
- printf("%-20s%s\n", cmd_name.c_str(), cmd->ShortHelpString().c_str());
+ printf(" %-20s%s\n", cmd_name.c_str(), cmd->ShortHelpString().c_str());
}
}
diff --git a/simpleperf/main.cpp b/simpleperf/main.cpp
index 93c52e5..7cc04b8 100644
--- a/simpleperf/main.cpp
+++ b/simpleperf/main.cpp
@@ -15,6 +15,7 @@
*/
#include <string.h>
+#include <map>
#include <string>
#include <vector>
@@ -22,9 +23,17 @@
#include "command.h"
+static std::map<std::string, android::base::LogSeverity> log_severity_map = {
+ {"debug", android::base::DEBUG},
+ {"warning", android::base::WARNING},
+ {"error", android::base::ERROR},
+ {"fatal", android::base::FATAL},
+};
+
int main(int argc, char** argv) {
InitLogging(argv, android::base::StderrLogger);
std::vector<std::string> args;
+ android::base::LogSeverity log_severity = android::base::ERROR;
if (argc == 1) {
args.push_back("help");
@@ -32,11 +41,26 @@
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
args.insert(args.begin(), "help");
+ } else if (strcmp(argv[i], "--log") == 0) {
+ if (i + 1 < argc) {
+ ++i;
+ auto it = log_severity_map.find(argv[i]);
+ if (it != log_severity_map.end()) {
+ log_severity = it->second;
+ } else {
+ LOG(ERROR) << "Unknown log severity: " << argv[i];
+ return 1;
+ }
+ } else {
+ LOG(ERROR) << "Missing argument for --log option.\n";
+ return 1;
+ }
} else {
args.push_back(argv[i]);
}
}
}
+ android::base::ScopedLogSeverity severity(log_severity);
std::unique_ptr<Command> command = CreateCommandInstance(args[0]);
if (command == nullptr) {
diff --git a/tests/net_test/iproute.py b/tests/net_test/iproute.py
index cf1f282..9cc8257 100644
--- a/tests/net_test/iproute.py
+++ b/tests/net_test/iproute.py
@@ -33,6 +33,7 @@
# Request constants.
NLM_F_REQUEST = 1
NLM_F_ACK = 4
+NLM_F_REPLACE = 0x100
NLM_F_EXCL = 0x200
NLM_F_CREATE = 0x400
NLM_F_DUMP = 0x300
@@ -407,13 +408,14 @@
def _AddressFamily(self, version):
return {4: socket.AF_INET, 6: socket.AF_INET6}[version]
- def _SendNlRequest(self, command, data):
+ def _SendNlRequest(self, command, data, flags=0):
"""Sends a netlink request and expects an ack."""
- flags = NLM_F_REQUEST
+ flags |= NLM_F_REQUEST
if CommandVerb(command) != "GET":
flags |= NLM_F_ACK
if CommandVerb(command) == "NEW":
- flags |= (NLM_F_EXCL | NLM_F_CREATE)
+ if not flags & NLM_F_REPLACE:
+ flags |= (NLM_F_EXCL | NLM_F_CREATE)
length = len(NLMsgHdr) + len(data)
nlmsg = NLMsgHdr((length, command, flags, self.seq, self.pid)).Pack()
@@ -497,7 +499,7 @@
if nlmsghdr.type == NLMSG_ERROR or nlmsghdr.type == NLMSG_DONE:
print "done"
- return None, data
+ return (None, None), data
nlmsg, data = cstruct.Read(data, msgtype)
self._Debug(" %s" % nlmsg)
@@ -657,12 +659,12 @@
routes = self._GetMsgList(RTMsg, data, False)
return routes
- def _Neighbour(self, version, is_add, addr, lladdr, dev, state):
+ def _Neighbour(self, version, is_add, addr, lladdr, dev, state, flags=0):
"""Adds or deletes a neighbour cache entry."""
family = self._AddressFamily(version)
# Convert the link-layer address to a raw byte string.
- if is_add:
+ if is_add and lladdr:
lladdr = lladdr.split(":")
if len(lladdr) != 6:
raise ValueError("Invalid lladdr %s" % ":".join(lladdr))
@@ -670,10 +672,10 @@
ndmsg = NdMsg((family, dev, state, 0, RTN_UNICAST)).Pack()
ndmsg += self._NlAttrIPAddress(NDA_DST, family, addr)
- if is_add:
+ if is_add and lladdr:
ndmsg += self._NlAttr(NDA_LLADDR, lladdr)
command = RTM_NEWNEIGH if is_add else RTM_DELNEIGH
- self._SendNlRequest(command, ndmsg)
+ self._SendNlRequest(command, ndmsg, flags)
def AddNeighbour(self, version, addr, lladdr, dev):
self._Neighbour(version, True, addr, lladdr, dev, NUD_PERMANENT)
@@ -681,10 +683,18 @@
def DelNeighbour(self, version, addr, lladdr, dev):
self._Neighbour(version, False, addr, lladdr, dev, 0)
+ def UpdateNeighbour(self, version, addr, lladdr, dev, state):
+ self._Neighbour(version, True, addr, lladdr, dev, state,
+ flags=NLM_F_REPLACE)
+
def DumpNeighbours(self, version):
ndmsg = NdMsg((self._AddressFamily(version), 0, 0, 0, 0))
return self._Dump(RTM_GETNEIGH, ndmsg, NdMsg)
+ def ParseNeighbourMessage(self, msg):
+ msg, _ = self._ParseNLMsg(msg, NdMsg)
+ return msg
+
if __name__ == "__main__":
iproute = IPRoute()
diff --git a/tests/net_test/multinetwork_base.py b/tests/net_test/multinetwork_base.py
index 5952d56..97e4d37 100644
--- a/tests/net_test/multinetwork_base.py
+++ b/tests/net_test/multinetwork_base.py
@@ -190,6 +190,10 @@
return {4: cls._MyIPv4Address(netid),
6: cls._MyIPv6Address(netid)}[version]
+ @classmethod
+ def MyLinkLocalAddress(cls, netid):
+ return net_test.GetLinkAddress(cls.GetInterfaceName(netid), True)
+
@staticmethod
def IPv6Prefix(netid):
return "2001:db8:%02x::" % netid
@@ -221,7 +225,7 @@
return f
@classmethod
- def SendRA(cls, netid, retranstimer=None):
+ def SendRA(cls, netid, retranstimer=None, reachabletime=0):
validity = 300 # seconds
macaddr = cls.RouterMacAddress(netid)
lladdr = cls._RouterAddress(netid, 6)
@@ -238,7 +242,8 @@
ra = (scapy.Ether(src=macaddr, dst="33:33:00:00:00:01") /
scapy.IPv6(src=lladdr, hlim=255) /
- scapy.ICMPv6ND_RA(retranstimer=retranstimer,
+ scapy.ICMPv6ND_RA(reachabletime=reachabletime,
+ retranstimer=retranstimer,
routerlifetime=routerlifetime) /
scapy.ICMPv6NDOptSrcLLAddr(lladdr=macaddr) /
scapy.ICMPv6NDOptPrefixInfo(prefix=cls.IPv6Prefix(netid),
diff --git a/tests/net_test/multinetwork_test.py b/tests/net_test/multinetwork_test.py
index 6ffb5d0..e9cd8f1 100755
--- a/tests/net_test/multinetwork_test.py
+++ b/tests/net_test/multinetwork_test.py
@@ -33,15 +33,11 @@
PING_SEQ = 3
PING_TOS = 0x83
+# For brevity.
+UDP_PAYLOAD = net_test.UDP_PAYLOAD
+
IPV6_FLOWINFO = 11
-
-UDP_PAYLOAD = str(scapy.DNS(rd=1,
- id=random.randint(0, 65535),
- qd=scapy.DNSQR(qname="wWW.GoOGle.CoM",
- qtype="AAAA")))
-
-
IPV4_MARK_REFLECT_SYSCTL = "/proc/sys/net/ipv4/fwmark_reflect"
IPV6_MARK_REFLECT_SYSCTL = "/proc/sys/net/ipv6/fwmark_reflect"
SYNCOOKIES_SYSCTL = "/proc/sys/net/ipv4/tcp_syncookies"
diff --git a/tests/net_test/neighbour_test.py b/tests/net_test/neighbour_test.py
new file mode 100755
index 0000000..828a86b
--- /dev/null
+++ b/tests/net_test/neighbour_test.py
@@ -0,0 +1,216 @@
+#!/usr/bin/python
+#
+# Copyright 2015 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import errno
+import random
+from socket import * # pylint: disable=wildcard-import
+import time
+import unittest
+
+from scapy import all as scapy
+
+import multinetwork_base
+import net_test
+
+
+RTMGRP_NEIGH = 4
+
+NUD_INCOMPLETE = 0x01
+NUD_REACHABLE = 0x02
+NUD_STALE = 0x04
+NUD_DELAY = 0x08
+NUD_PROBE = 0x10
+NUD_FAILED = 0x20
+NUD_PERMANENT = 0x80
+
+
+# TODO: Support IPv4.
+class NeighbourTest(multinetwork_base.MultiNetworkBaseTest):
+
+ # Set a 100-ms retrans timer so we can test for ND retransmits without
+ # waiting too long. Apparently this cannot go below 500ms.
+ RETRANS_TIME_MS = 500
+
+ # This can only be in seconds, so 1000 is the minimum.
+ DELAY_TIME_MS = 1000
+
+ # Unfortunately, this must be above the delay timer or the kernel ND code will
+ # not behave correctly (e.g., go straight from REACHABLE into DELAY). This is
+ # is fuzzed by the kernel from 0.5x to 1.5x of its value, so we need a value
+ # that's 2x the delay timer.
+ REACHABLE_TIME_MS = 2 * DELAY_TIME_MS
+
+ @classmethod
+ def setUpClass(cls):
+ super(NeighbourTest, cls).setUpClass()
+ for netid in cls.tuns:
+ iface = cls.GetInterfaceName(netid)
+ # This can't be set in an RA.
+ cls.SetSysctl(
+ "/proc/sys/net/ipv6/neigh/%s/delay_first_probe_time" % iface,
+ cls.DELAY_TIME_MS / 1000)
+
+ def setUp(self):
+ super(NeighbourTest, self).setUp()
+
+ self.sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)
+ self.sock.bind((0, RTMGRP_NEIGH))
+ net_test.SetNonBlocking(self.sock)
+
+ for netid in self.tuns:
+ self.SendRA(netid,
+ retranstimer=self.RETRANS_TIME_MS,
+ reachabletime=self.REACHABLE_TIME_MS)
+
+ self.netid = random.choice(self.tuns.keys())
+ self.ifindex = self.ifindices[self.netid]
+
+ def GetNeighbour(self, addr):
+ version = 6 if ":" in addr else 4
+ for msg, args in self.iproute.DumpNeighbours(version):
+ if args["NDA_DST"] == addr:
+ return msg, args
+
+ def GetNdEntry(self, addr):
+ return self.GetNeighbour(addr)
+
+ def CheckNoNdEvents(self):
+ self.assertRaisesErrno(errno.EAGAIN, self.sock.recvfrom, 4096, MSG_PEEK)
+
+ def assertNeighbourState(self, state, addr):
+ self.assertEquals(state, self.GetNdEntry(addr)[0].state)
+
+ def assertNeighbourAttr(self, addr, name, value):
+ self.assertEquals(value, self.GetNdEntry(addr)[1][name])
+
+ def ExpectNeighbourNotification(self, addr, state, attrs=None):
+ msg = self.sock.recv(4096)
+ msg, actual_attrs = self.iproute.ParseNeighbourMessage(msg)
+ self.assertEquals(addr, actual_attrs["NDA_DST"])
+ self.assertEquals(state, msg.state)
+ if attrs:
+ for name in attrs:
+ self.assertEquals(attrs[name], actual_attrs[name])
+
+ def ExpectUnicastProbe(self, addr):
+ version = 6 if ":" in addr else 4
+ if version == 6:
+ expected = (
+ scapy.IPv6(src=self.MyLinkLocalAddress(self.netid), dst=addr) /
+ scapy.ICMPv6ND_NS(tgt=addr) /
+ scapy.ICMPv6NDOptSrcLLAddr(lladdr=self.MyMacAddress(self.netid))
+ )
+ self.ExpectPacketOn(self.netid, "Unicast probe", expected)
+ else:
+ raise NotImplementedError
+
+ def ReceiveUnicastAdvertisement(self, addr, mac):
+ version = 6 if ":" in addr else 4
+ if version == 6:
+ packet = (
+ scapy.Ether(src=mac, dst=self.MyMacAddress(self.netid)) /
+ scapy.IPv6(src=addr, dst=self.MyLinkLocalAddress(self.netid)) /
+ scapy.ICMPv6ND_NA(tgt=addr, S=1, O=0) /
+ scapy.ICMPv6NDOptDstLLAddr(lladdr=mac)
+ )
+ self.ReceiveEtherPacketOn(self.netid, packet)
+ else:
+ raise NotImplementedError
+
+ def MonitorSleep(self, intervalseconds, addr):
+ slept = 0
+ while slept < intervalseconds:
+ time.sleep(0.1)
+ slept += 0.1
+ print self.GetNdEntry(addr)
+
+ def SleepMs(self, ms):
+ time.sleep(ms / 1000.0)
+
+ def testNotifications(self):
+ router4 = self._RouterAddress(self.netid, 4)
+ router6 = self._RouterAddress(self.netid, 6)
+ self.assertNeighbourState(NUD_PERMANENT, router4)
+ self.assertNeighbourState(NUD_STALE, router6)
+
+ # Send a packet and check that we go into DELAY.
+ routing_mode = random.choice(["mark", "oif", "uid"])
+ s = self.BuildSocket(6, net_test.UDPSocket, self.netid, routing_mode)
+ s.connect((net_test.IPV6_ADDR, 53))
+ s.send(net_test.UDP_PAYLOAD)
+ self.assertNeighbourState(NUD_DELAY, router6)
+
+ # Wait for the probe interval, then check that we're in PROBE, and that the
+ # kernel has notified us.
+ self.SleepMs(self.DELAY_TIME_MS)
+ self.ExpectNeighbourNotification(router6, NUD_PROBE)
+ self.assertNeighbourState(NUD_PROBE, router6)
+ self.ExpectUnicastProbe(router6)
+
+ # Respond to the NS and verify we're in REACHABLE again.
+ self.ReceiveUnicastAdvertisement(router6, self.RouterMacAddress(self.netid))
+ self.assertNeighbourState(NUD_REACHABLE, router6)
+
+ # Wait until the reachable time has passed, and verify we're in STALE.
+ self.SleepMs(self.REACHABLE_TIME_MS * 1.5)
+ self.assertNeighbourState(NUD_STALE, router6)
+ self.ExpectNeighbourNotification(router6, NUD_STALE)
+
+ # Send a packet, and verify we go into DELAY and then to PROBE.
+ s.send(net_test.UDP_PAYLOAD)
+ self.assertNeighbourState(NUD_DELAY, router6)
+ self.SleepMs(self.DELAY_TIME_MS)
+ self.assertNeighbourState(NUD_PROBE, router6)
+ self.ExpectNeighbourNotification(router6, NUD_PROBE)
+
+ # Wait for the probes to time out, and expect a FAILED notification.
+ self.assertNeighbourAttr(router6, "NDA_PROBES", 1)
+ self.ExpectUnicastProbe(router6)
+
+ self.SleepMs(self.RETRANS_TIME_MS)
+ self.ExpectUnicastProbe(router6)
+ self.assertNeighbourAttr(router6, "NDA_PROBES", 2)
+
+ self.SleepMs(self.RETRANS_TIME_MS)
+ self.ExpectUnicastProbe(router6)
+ self.assertNeighbourAttr(router6, "NDA_PROBES", 3)
+
+ self.SleepMs(self.RETRANS_TIME_MS)
+ self.assertNeighbourState(NUD_FAILED, router6)
+ self.ExpectNeighbourNotification(router6, NUD_FAILED, {"NDA_PROBES": 3})
+
+ def testRepeatedProbes(self):
+ router4 = self._RouterAddress(self.netid, 4)
+ router6 = self._RouterAddress(self.netid, 6)
+ routermac = self.RouterMacAddress(self.netid)
+ self.assertNeighbourState(NUD_PERMANENT, router4)
+ self.assertNeighbourState(NUD_STALE, router6)
+
+ def ForceProbe(addr, mac):
+ self.iproute.UpdateNeighbour(6, addr, None, self.ifindex, NUD_PROBE)
+ self.assertNeighbourState(NUD_PROBE, addr)
+ self.SleepMs(1) # TODO: Why is this necessary?
+ self.assertNeighbourState(NUD_PROBE, addr)
+ self.ExpectUnicastProbe(addr)
+ self.ReceiveUnicastAdvertisement(addr, mac)
+ self.assertNeighbourState(NUD_REACHABLE, addr)
+
+ for i in xrange(5):
+ ForceProbe(router6, routermac)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/net_test/net_test.py b/tests/net_test/net_test.py
index a87b71b..be034d0 100755
--- a/tests/net_test/net_test.py
+++ b/tests/net_test/net_test.py
@@ -16,6 +16,7 @@
import fcntl
import os
+import random
from socket import * # pylint: disable=wildcard-import
import struct
import unittest
@@ -63,6 +64,12 @@
"st tx_queue rx_queue tr tm->when retrnsmt"
" uid timeout inode ref pointer drops\n")
+# Arbitrary packet payload.
+UDP_PAYLOAD = str(scapy.DNS(rd=1,
+ id=random.randint(0, 65535),
+ qd=scapy.DNSQR(qname="wWW.GoOGle.CoM",
+ qtype="AAAA")))
+
# Unix group to use if we want to open sockets as non-root.
AID_INET = 3003
diff --git a/tests/net_test/run_net_test.sh b/tests/net_test/run_net_test.sh
index a12f3cf..119171e 100755
--- a/tests/net_test/run_net_test.sh
+++ b/tests/net_test/run_net_test.sh
@@ -93,7 +93,7 @@
fi
# Compile the kernel.
-make -j12 linux ARCH=um SUBARCH=x86_64 CROSS_COMPILE=
+make -j32 linux ARCH=um SUBARCH=x86_64 CROSS_COMPILE=
# Get the absolute path to the test file that's being run.
dir=/host$(dirname $(readlink -f $0))