From cb37cb336a2cca77bfbaf6b0cfab12e847e45623 Mon Sep 17 00:00:00 2001 From: Donald Sharp Date: Mon, 28 Feb 2022 10:40:31 -0500 Subject: *: Rename thread.[ch] to event.[ch] This is a first in a series of commits, whose goal is to rename the thread system in FRR to an event system. There is a continual problem where people are confusing `struct thread` with a true pthread. In reality, our entire thread.c is an event system. In this commit rename the thread.[ch] files to event.[ch]. Signed-off-by: Donald Sharp --- babeld/babel_main.c | 2 +- babeld/kernel.c | 2 +- bfdd/dplane.c | 2 +- bgpd/bgp_advertise.c | 2 +- bgpd/bgp_bfd.c | 2 +- bgpd/bgp_bmp.c | 2 +- bgpd/bgp_damp.c | 2 +- bgpd/bgp_dump.c | 2 +- bgpd/bgp_fsm.c | 2 +- bgpd/bgp_io.c | 2 +- bgpd/bgp_label.c | 2 +- bgpd/bgp_main.c | 2 +- bgpd/bgp_mplsvpn_snmp.c | 2 +- bgpd/bgp_network.c | 2 +- bgpd/bgp_nexthop.c | 2 +- bgpd/bgp_nht.c | 2 +- bgpd/bgp_open.c | 2 +- bgpd/bgp_packet.c | 2 +- bgpd/bgp_route.c | 2 +- bgpd/bgp_rpki.c | 3 +- bgpd/bgp_snmp.c | 2 +- bgpd/bgp_snmp_bgp4.c | 2 +- bgpd/bgp_snmp_bgp4v2.c | 2 +- bgpd/bgp_updgrp.c | 2 +- bgpd/bgp_updgrp_adv.c | 2 +- bgpd/bgp_updgrp_packet.c | 2 +- bgpd/bgp_vty.c | 2 +- bgpd/bgp_zebra.c | 2 +- bgpd/bgpd.c | 2 +- bgpd/rfapi/rfapi_import.c | 2 +- bgpd/rfapi/rfapi_import.h | 2 +- bgpd/rfapi/vnc_export_table.h | 2 +- doc/developer/modules.rst | 2 +- doc/developer/process-architecture.rst | 4 +- eigrpd/eigrp_dump.c | 2 +- eigrpd/eigrp_filter.c | 2 +- eigrpd/eigrp_fsm.c | 2 +- eigrpd/eigrp_hello.c | 2 +- eigrpd/eigrp_interface.c | 2 +- eigrpd/eigrp_main.c | 2 +- eigrpd/eigrp_neighbor.c | 2 +- eigrpd/eigrp_network.c | 2 +- eigrpd/eigrp_packet.c | 2 +- eigrpd/eigrp_query.c | 2 +- eigrpd/eigrp_reply.c | 2 +- eigrpd/eigrp_siaquery.c | 2 +- eigrpd/eigrp_siareply.c | 2 +- eigrpd/eigrp_snmp.c | 2 +- eigrpd/eigrp_update.c | 2 +- eigrpd/eigrp_vty.c | 2 +- eigrpd/eigrp_zebra.c | 2 +- eigrpd/eigrpd.c | 2 +- gdb/lib.txt | 2 +- isisd/isis_adjacency.c | 2 +- isisd/isis_circuit.c | 2 +- isisd/isis_csm.c | 2 +- isisd/isis_dr.c | 2 +- isisd/isis_dynhn.c | 2 +- isisd/isis_events.c | 2 +- isisd/isis_ldp_sync.c | 2 +- isisd/isis_lsp.c | 2 +- isisd/isis_main.c | 2 +- isisd/isis_pdu.c | 2 +- isisd/isis_route.c | 2 +- isisd/isis_routemap.c | 2 +- isisd/isis_spf.c | 2 +- isisd/isis_te.c | 2 +- isisd/isis_zebra.c | 2 +- isisd/isisd.c | 2 +- ldpd/ldpd.h | 2 +- lib/bfd.c | 2 +- lib/command.c | 2 +- lib/event.c | 2198 ++++++++++++++++++++++++++++++++ lib/event.h | 291 +++++ lib/frr_pthread.h | 2 +- lib/frr_zmq.c | 2 +- lib/frr_zmq.h | 2 +- lib/ldp_sync.c | 2 +- lib/libfrr.h | 2 +- lib/libfrr_trace.h | 2 +- lib/mgmt_fe_client.h | 2 +- lib/mgmt_msg.c | 2 +- lib/mgmt_msg.h | 2 +- lib/northbound.h | 2 +- lib/northbound_grpc.cpp | 2 +- lib/pullwr.h | 2 +- lib/qobj.c | 2 +- lib/resolver.c | 2 +- lib/resolver.h | 2 +- lib/sigevent.h | 2 +- lib/smux.h | 2 +- lib/spf_backoff.c | 2 +- lib/subdir.am | 6 +- lib/systemd.c | 2 +- lib/thread.c | 2198 -------------------------------- lib/thread.h | 291 ----- lib/vty.c | 2 +- lib/vty.h | 2 +- lib/wheel.c | 2 +- lib/workqueue.c | 2 +- lib/zclient.c | 2 +- lib/zlog.c | 2 +- lib/zlog_5424.c | 2 +- mgmtd/mgmt_be_adapter.c | 2 +- mgmtd/mgmt_history.c | 2 +- nhrpd/netlink_arp.c | 2 +- nhrpd/nhrp_cache.c | 2 +- nhrpd/nhrp_event.c | 2 +- nhrpd/nhrp_interface.c | 2 +- nhrpd/nhrp_main.c | 2 +- nhrpd/nhrp_multicast.c | 2 +- nhrpd/nhrp_nhs.c | 2 +- nhrpd/nhrp_packet.c | 2 +- nhrpd/nhrp_peer.c | 2 +- nhrpd/nhrp_shortcut.c | 2 +- nhrpd/nhrp_vc.c | 2 +- nhrpd/vici.c | 2 +- ospf6d/ospf6_abr.c | 2 +- ospf6d/ospf6_area.c | 2 +- ospf6d/ospf6_asbr.c | 2 +- ospf6d/ospf6_bfd.c | 2 +- ospf6d/ospf6_flood.c | 2 +- ospf6d/ospf6_interface.c | 2 +- ospf6d/ospf6_intra.c | 2 +- ospf6d/ospf6_lsa.c | 2 +- ospf6d/ospf6_main.c | 2 +- ospf6d/ospf6_message.c | 2 +- ospf6d/ospf6_neighbor.c | 2 +- ospf6d/ospf6_nssa.c | 2 +- ospf6d/ospf6_spf.c | 2 +- ospf6d/ospf6_top.c | 2 +- ospf6d/ospf6d.c | 2 +- ospf6d/ospf6d.h | 2 +- ospfclient/ospf_apiclient.c | 2 +- ospfclient/ospfclient.c | 2 +- ospfd/ospf_abr.c | 2 +- ospfd/ospf_api.c | 2 +- ospfd/ospf_apiserver.c | 2 +- ospfd/ospf_asbr.c | 2 +- ospfd/ospf_ase.c | 2 +- ospfd/ospf_bfd.c | 2 +- ospfd/ospf_dump.c | 2 +- ospfd/ospf_ext.c | 2 +- ospfd/ospf_flood.c | 2 +- ospfd/ospf_gr_helper.c | 2 +- ospfd/ospf_ia.c | 2 +- ospfd/ospf_interface.c | 2 +- ospfd/ospf_ism.c | 2 +- ospfd/ospf_ldp_sync.c | 2 +- ospfd/ospf_lsa.c | 2 +- ospfd/ospf_main.c | 2 +- ospfd/ospf_neighbor.c | 2 +- ospfd/ospf_network.c | 2 +- ospfd/ospf_nsm.c | 2 +- ospfd/ospf_opaque.c | 2 +- ospfd/ospf_packet.c | 2 +- ospfd/ospf_ri.c | 2 +- ospfd/ospf_spf.c | 2 +- ospfd/ospf_sr.c | 2 +- ospfd/ospf_te.c | 2 +- ospfd/ospf_vty.c | 2 +- ospfd/ospf_zebra.c | 2 +- ospfd/ospfd.c | 2 +- pathd/path_main.c | 2 +- pathd/path_pcep_config.c | 2 +- pathd/path_zebra.c | 2 +- pbrd/pbr_main.c | 2 +- pbrd/pbr_map.c | 2 +- pbrd/pbr_zebra.c | 2 +- pimd/pim6_mld.c | 2 +- pimd/pim_ifchannel.c | 2 +- pimd/pim_main.c | 2 +- pimd/pim_msdp.c | 2 +- pimd/pim_msdp_packet.c | 2 +- pimd/pim_msdp_socket.c | 2 +- pimd/pim_pim.c | 2 +- pimd/pim_register.c | 2 +- pimd/pim_time.c | 2 +- pimd/pim_time.h | 2 +- pimd/pim_upstream.c | 2 +- pimd/pim_zlookup.c | 2 +- python/xref2vtysh.py | 2 +- ripd/rip_interface.c | 2 +- ripd/rip_main.c | 2 +- ripd/rip_peer.c | 2 +- ripd/ripd.c | 2 +- ripngd/ripng_interface.c | 2 +- ripngd/ripng_main.c | 2 +- ripngd/ripng_peer.c | 2 +- ripngd/ripngd.c | 2 +- sharpd/sharp_logpump.c | 2 +- sharpd/sharp_main.c | 2 +- sharpd/sharp_zebra.c | 2 +- staticd/static_main.c | 2 +- staticd/static_zebra.c | 2 +- tests/helpers/c/main.c | 2 +- tests/isisd/test_fuzz_isis_tlv.c | 2 +- tests/isisd/test_isis_spf.c | 2 +- tests/lib/cli/common_cli.c | 2 +- tests/lib/cxxcompat.c | 2 +- tests/lib/northbound/test_oper_data.c | 2 +- tests/lib/test_assert.c | 2 +- tests/lib/test_grpc.cpp | 2 +- tests/lib/test_heavy.c | 2 +- tests/lib/test_heavy_thread.c | 2 +- tests/lib/test_heavy_wq.c | 2 +- tests/lib/test_stream.c | 2 +- tests/lib/test_timer_correctness.c | 2 +- tests/lib/test_timer_performance.c | 2 +- tests/ospfd/test_ospf_spf.c | 2 +- vrrpd/vrrp.h | 2 +- vrrpd/vrrp_main.c | 2 +- watchfrr/watchfrr.c | 2 +- zebra/if_netlink.c | 2 +- zebra/irdp_interface.c | 2 +- zebra/irdp_main.c | 2 +- zebra/irdp_packet.c | 2 +- zebra/kernel_netlink.c | 2 +- zebra/kernel_socket.c | 2 +- zebra/label_manager.h | 2 +- zebra/main.c | 2 +- zebra/rt_netlink.c | 2 +- zebra/rtadv.c | 2 +- zebra/table_manager.h | 2 +- zebra/zebra_fpm.c | 2 +- zebra/zebra_gr.c | 2 +- zebra/zebra_mlag_private.c | 2 +- zebra/zebra_mpls.c | 2 +- zebra/zebra_netns_notify.c | 2 +- zebra/zebra_pw.c | 2 +- zebra/zebra_rib.c | 2 +- zebra/zebra_rnh.c | 2 +- zebra/zserv.c | 2 +- zebra/zserv.h | 2 +- 234 files changed, 2722 insertions(+), 2723 deletions(-) create mode 100644 lib/event.c create mode 100644 lib/event.h delete mode 100644 lib/thread.c delete mode 100644 lib/thread.h diff --git a/babeld/babel_main.c b/babeld/babel_main.c index 0869c120ac..de0c8230fc 100644 --- a/babeld/babel_main.c +++ b/babeld/babel_main.c @@ -8,7 +8,7 @@ Copyright 2011 by Matthieu Boutier and Juliusz Chroboczek #include "getopt.h" #include "if.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "privs.h" #include "sigevent.h" #include "lib/version.h" diff --git a/babeld/kernel.c b/babeld/kernel.c index f89fe268df..bbbb9676eb 100644 --- a/babeld/kernel.c +++ b/babeld/kernel.c @@ -29,7 +29,7 @@ Copyright 2011, 2012 by Matthieu Boutier and Juliusz Chroboczek #include "command.h" #include "vty.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "nexthop.h" #include "util.h" diff --git a/bfdd/dplane.c b/bfdd/dplane.c index 99bd1886f4..7d160e868a 100644 --- a/bfdd/dplane.c +++ b/bfdd/dplane.c @@ -26,7 +26,7 @@ #include "lib/network.h" #include "lib/printfrr.h" #include "lib/stream.h" -#include "lib/thread.h" +#include "lib/event.h" #include "bfd.h" #include "bfddp_packet.h" diff --git a/bgpd/bgp_advertise.c b/bgpd/bgp_advertise.c index 3469d129e4..429abc1790 100644 --- a/bgpd/bgp_advertise.c +++ b/bgpd/bgp_advertise.c @@ -9,7 +9,7 @@ #include "memory.h" #include "prefix.h" #include "hash.h" -#include "thread.h" +#include "event.h" #include "queue.h" #include "filter.h" diff --git a/bgpd/bgp_bfd.c b/bgpd/bgp_bfd.c index 4a81b69ced..bdbaf62267 100644 --- a/bgpd/bgp_bfd.c +++ b/bgpd/bgp_bfd.c @@ -11,7 +11,7 @@ #include "linklist.h" #include "memory.h" #include "prefix.h" -#include "thread.h" +#include "event.h" #include "buffer.h" #include "stream.h" #include "vrf.h" diff --git a/bgpd/bgp_bmp.c b/bgpd/bgp_bmp.c index 40a27cad70..6ade0fc388 100644 --- a/bgpd/bgp_bmp.c +++ b/bgpd/bgp_bmp.c @@ -11,7 +11,7 @@ #include "sockunion.h" #include "command.h" #include "prefix.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "queue.h" #include "pullwr.h" diff --git a/bgpd/bgp_damp.c b/bgpd/bgp_damp.c index 54bbf9b9ca..ba16a33fb9 100644 --- a/bgpd/bgp_damp.c +++ b/bgpd/bgp_damp.c @@ -10,7 +10,7 @@ #include "memory.h" #include "command.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "queue.h" #include "filter.h" diff --git a/bgpd/bgp_dump.c b/bgpd/bgp_dump.c index 794dd7b8b6..6aad4ff2a7 100644 --- a/bgpd/bgp_dump.c +++ b/bgpd/bgp_dump.c @@ -10,7 +10,7 @@ #include "sockunion.h" #include "command.h" #include "prefix.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "queue.h" #include "memory.h" diff --git a/bgpd/bgp_fsm.c b/bgpd/bgp_fsm.c index aa9a6a8602..dc6ce6b8eb 100644 --- a/bgpd/bgp_fsm.c +++ b/bgpd/bgp_fsm.c @@ -9,7 +9,7 @@ #include "linklist.h" #include "prefix.h" #include "sockunion.h" -#include "thread.h" +#include "event.h" #include "log.h" #include "stream.h" #include "ringbuf.h" diff --git a/bgpd/bgp_io.c b/bgpd/bgp_io.c index 530b77987d..5dae39d40c 100644 --- a/bgpd/bgp_io.c +++ b/bgpd/bgp_io.c @@ -17,7 +17,7 @@ #include "network.h" // for ERRNO_IO_RETRY #include "stream.h" // for stream_get_endp, stream_getw_from, str... #include "ringbuf.h" // for ringbuf_remain, ringbuf_peek, ringbuf_... -#include "thread.h" // for THREAD_OFF, THREAD_ARG, thread... +#include "event.h" // for THREAD_OFF, THREAD_ARG, thread... #include "bgpd/bgp_io.h" #include "bgpd/bgp_debug.h" // for bgp_debug_neighbor_events, bgp_type_str diff --git a/bgpd/bgp_label.c b/bgpd/bgp_label.c index 414dafebd4..c13e0b0daf 100644 --- a/bgpd/bgp_label.c +++ b/bgpd/bgp_label.c @@ -6,7 +6,7 @@ #include #include "command.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "zclient.h" #include "stream.h" diff --git a/bgpd/bgp_main.c b/bgpd/bgp_main.c index 85e4904372..63dab9070a 100644 --- a/bgpd/bgp_main.c +++ b/bgpd/bgp_main.c @@ -9,7 +9,7 @@ #include "vector.h" #include "command.h" #include "getopt.h" -#include "thread.h" +#include "event.h" #include #include "memory.h" #include "prefix.h" diff --git a/bgpd/bgp_mplsvpn_snmp.c b/bgpd/bgp_mplsvpn_snmp.c index 8453133dff..52320031c7 100644 --- a/bgpd/bgp_mplsvpn_snmp.c +++ b/bgpd/bgp_mplsvpn_snmp.c @@ -12,7 +12,7 @@ #include "log.h" #include "prefix.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "smux.h" #include "filter.h" #include "hook.h" diff --git a/bgpd/bgp_network.c b/bgpd/bgp_network.c index 6f035358f1..8fcb5b017e 100644 --- a/bgpd/bgp_network.c +++ b/bgpd/bgp_network.c @@ -5,7 +5,7 @@ #include -#include "thread.h" +#include "event.h" #include "sockunion.h" #include "sockopt.h" #include "memory.h" diff --git a/bgpd/bgp_nexthop.c b/bgpd/bgp_nexthop.c index f1f6b031a9..2ccc5e2c33 100644 --- a/bgpd/bgp_nexthop.c +++ b/bgpd/bgp_nexthop.c @@ -6,7 +6,7 @@ #include #include "command.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "lib/json.h" #include "zclient.h" diff --git a/bgpd/bgp_nht.c b/bgpd/bgp_nht.c index 473c95071c..cb9de84cc5 100644 --- a/bgpd/bgp_nht.c +++ b/bgpd/bgp_nht.c @@ -6,7 +6,7 @@ #include #include "command.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "zclient.h" #include "stream.h" diff --git a/bgpd/bgp_open.c b/bgpd/bgp_open.c index 032767820f..457f7be7eb 100644 --- a/bgpd/bgp_open.c +++ b/bgpd/bgp_open.c @@ -8,7 +8,7 @@ #include "linklist.h" #include "prefix.h" #include "stream.h" -#include "thread.h" +#include "event.h" #include "log.h" #include "command.h" #include "memory.h" diff --git a/bgpd/bgp_packet.c b/bgpd/bgp_packet.c index 93672d29f1..97b26ea62a 100644 --- a/bgpd/bgp_packet.c +++ b/bgpd/bgp_packet.c @@ -8,7 +8,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "stream.h" #include "network.h" #include "prefix.h" diff --git a/bgpd/bgp_route.c b/bgpd/bgp_route.c index 14ce4e6bc9..efa367a56d 100644 --- a/bgpd/bgp_route.c +++ b/bgpd/bgp_route.c @@ -20,7 +20,7 @@ #include "buffer.h" #include "sockunion.h" #include "plist.h" -#include "thread.h" +#include "event.h" #include "workqueue.h" #include "queue.h" #include "memory.h" diff --git a/bgpd/bgp_rpki.c b/bgpd/bgp_rpki.c index 32ca909fe6..2aceca8bd7 100644 --- a/bgpd/bgp_rpki.c +++ b/bgpd/bgp_rpki.c @@ -23,7 +23,7 @@ #include "command.h" #include "linklist.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "filter.h" #include "bgpd/bgpd.h" #include "bgpd/bgp_table.h" @@ -36,7 +36,6 @@ #include "northbound_cli.h" #include "lib/network.h" -#include "lib/thread.h" #include "rtrlib/rtrlib.h" #include "hook.h" #include "libfrr.h" diff --git a/bgpd/bgp_snmp.c b/bgpd/bgp_snmp.c index 5aa5e14288..7408b77656 100644 --- a/bgpd/bgp_snmp.c +++ b/bgpd/bgp_snmp.c @@ -12,7 +12,7 @@ #include "log.h" #include "prefix.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "smux.h" #include "filter.h" #include "hook.h" diff --git a/bgpd/bgp_snmp_bgp4.c b/bgpd/bgp_snmp_bgp4.c index 186c9e2846..3bf3c61bf3 100644 --- a/bgpd/bgp_snmp_bgp4.c +++ b/bgpd/bgp_snmp_bgp4.c @@ -12,7 +12,7 @@ #include "log.h" #include "prefix.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "smux.h" #include "filter.h" #include "hook.h" diff --git a/bgpd/bgp_snmp_bgp4v2.c b/bgpd/bgp_snmp_bgp4v2.c index 9c2599d5f4..61615be2c5 100644 --- a/bgpd/bgp_snmp_bgp4v2.c +++ b/bgpd/bgp_snmp_bgp4v2.c @@ -13,7 +13,7 @@ #include "log.h" #include "prefix.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "smux.h" #include "filter.h" #include "hook.h" diff --git a/bgpd/bgp_updgrp.c b/bgpd/bgp_updgrp.c index 204b8092e5..68bfb4c139 100644 --- a/bgpd/bgp_updgrp.c +++ b/bgpd/bgp_updgrp.c @@ -12,7 +12,7 @@ #include #include "prefix.h" -#include "thread.h" +#include "event.h" #include "buffer.h" #include "stream.h" #include "command.h" diff --git a/bgpd/bgp_updgrp_adv.c b/bgpd/bgp_updgrp_adv.c index d8e0e7875c..181d57813d 100644 --- a/bgpd/bgp_updgrp_adv.c +++ b/bgpd/bgp_updgrp_adv.c @@ -17,7 +17,7 @@ #include "memory.h" #include "prefix.h" #include "hash.h" -#include "thread.h" +#include "event.h" #include "queue.h" #include "routemap.h" #include "filter.h" diff --git a/bgpd/bgp_updgrp_packet.c b/bgpd/bgp_updgrp_packet.c index 5106dcf354..279a7cce60 100644 --- a/bgpd/bgp_updgrp_packet.c +++ b/bgpd/bgp_updgrp_packet.c @@ -12,7 +12,7 @@ #include #include "prefix.h" -#include "thread.h" +#include "event.h" #include "buffer.h" #include "stream.h" #include "command.h" diff --git a/bgpd/bgp_vty.c b/bgpd/bgp_vty.c index 93b412240a..3bc64c3499 100644 --- a/bgpd/bgp_vty.c +++ b/bgpd/bgp_vty.c @@ -16,7 +16,7 @@ #include "buffer.h" #include "linklist.h" #include "stream.h" -#include "thread.h" +#include "event.h" #include "log.h" #include "memory.h" #include "lib_vty.h" diff --git a/bgpd/bgp_zebra.c b/bgpd/bgp_zebra.c index da598993d1..d4c98a2c73 100644 --- a/bgpd/bgp_zebra.c +++ b/bgpd/bgp_zebra.c @@ -13,7 +13,7 @@ #include "sockunion.h" #include "zclient.h" #include "routemap.h" -#include "thread.h" +#include "event.h" #include "queue.h" #include "memory.h" #include "lib/json.h" diff --git a/bgpd/bgpd.c b/bgpd/bgpd.c index 96c6a111ce..c7cd80b984 100644 --- a/bgpd/bgpd.c +++ b/bgpd/bgpd.c @@ -6,7 +6,7 @@ #include #include "prefix.h" -#include "thread.h" +#include "event.h" #include "buffer.h" #include "stream.h" #include "ringbuf.h" diff --git a/bgpd/rfapi/rfapi_import.c b/bgpd/rfapi/rfapi_import.c index 25a4403040..5fb2c5046d 100644 --- a/bgpd/rfapi/rfapi_import.c +++ b/bgpd/rfapi/rfapi_import.c @@ -15,7 +15,7 @@ #include "lib/memory.h" #include "lib/log.h" #include "lib/skiplist.h" -#include "lib/thread.h" +#include "event.h" #include "lib/stream.h" #include "lib/lib_errors.h" diff --git a/bgpd/rfapi/rfapi_import.h b/bgpd/rfapi/rfapi_import.h index 3bec225f65..7e021e8f7a 100644 --- a/bgpd/rfapi/rfapi_import.h +++ b/bgpd/rfapi/rfapi_import.h @@ -13,7 +13,7 @@ #ifndef QUAGGA_HGP_RFAPI_IMPORT_H #define QUAGGA_HGP_RFAPI_IMPORT_H -#include "lib/thread.h" +#include "event.h" /* * These are per-rt-import-list diff --git a/bgpd/rfapi/vnc_export_table.h b/bgpd/rfapi/vnc_export_table.h index 42c04f0c79..5716570cb0 100644 --- a/bgpd/rfapi/vnc_export_table.h +++ b/bgpd/rfapi/vnc_export_table.h @@ -9,7 +9,7 @@ #define _QUAGGA_VNC_VNC_EXPORT_TABLE_H_ #include "lib/table.h" -#include "lib/thread.h" +#include "event.h" #include "lib/vty.h" #include "bgpd/bgpd.h" diff --git a/doc/developer/modules.rst b/doc/developer/modules.rst index e95f8a1b4a..89d2f81f1b 100644 --- a/doc/developer/modules.rst +++ b/doc/developer/modules.rst @@ -56,7 +56,7 @@ Basic boilerplate: #include "hook.h" #include "module.h" #include "libfrr.h" - #include "thread.h" + #include "event.h" static int module_late_init(struct thread_master *master) { diff --git a/doc/developer/process-architecture.rst b/doc/developer/process-architecture.rst index 37bd620f24..4f6cfcc7c5 100644 --- a/doc/developer/process-architecture.rst +++ b/doc/developer/process-architecture.rst @@ -57,7 +57,7 @@ execute. At initialization, a daemon will typically create one fetch each task and execute it. These tasks have various types corresponding to their general action. The types -are given by integer macros in :file:`thread.h` and are: +are given by integer macros in :file:`event.h` and are: ``THREAD_READ`` Task which waits for a file descriptor to become ready for reading and then @@ -144,7 +144,7 @@ macros wrap underlying functions in :file:`thread.c` to provide additional information added at compile time, such as the line number the task was scheduled from, that can be accessed at runtime for debugging, logging and informational purposes. Each task type has its own specific scheduling function -that follow the naming convention ``thread_add_``; see :file:`thread.h` +that follow the naming convention ``thread_add_``; see :file:`event.h` for details. There are some gotchas to keep in mind: diff --git a/eigrpd/eigrp_dump.c b/eigrpd/eigrp_dump.c index 489b3bd1c5..b7c7e0070d 100644 --- a/eigrpd/eigrp_dump.c +++ b/eigrpd/eigrp_dump.c @@ -13,7 +13,7 @@ #include #include "linklist.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "command.h" #include "stream.h" diff --git a/eigrpd/eigrp_filter.c b/eigrpd/eigrp_filter.c index 09ae6be6dc..534b4fef56 100644 --- a/eigrpd/eigrp_filter.c +++ b/eigrpd/eigrp_filter.c @@ -21,7 +21,7 @@ #include "command.h" #include "prefix.h" #include "table.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "log.h" #include "stream.h" diff --git a/eigrpd/eigrp_fsm.c b/eigrpd/eigrp_fsm.c index d065af0cb9..cdfc99fce0 100644 --- a/eigrpd/eigrp_fsm.c +++ b/eigrpd/eigrp_fsm.c @@ -53,8 +53,8 @@ */ #include -#include +#include "event.h" #include "prefix.h" #include "table.h" #include "memory.h" diff --git a/eigrpd/eigrp_hello.c b/eigrpd/eigrp_hello.c index f62f54b680..55f0a3269f 100644 --- a/eigrpd/eigrp_hello.c +++ b/eigrpd/eigrp_hello.c @@ -16,7 +16,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/eigrpd/eigrp_interface.c b/eigrpd/eigrp_interface.c index 8d98dcf5a1..eeb2bd4d09 100644 --- a/eigrpd/eigrp_interface.c +++ b/eigrpd/eigrp_interface.c @@ -16,7 +16,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "prefix.h" #include "if.h" diff --git a/eigrpd/eigrp_main.c b/eigrpd/eigrp_main.c index 3c1e5da340..5cd1353a9f 100644 --- a/eigrpd/eigrp_main.c +++ b/eigrpd/eigrp_main.c @@ -17,7 +17,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "linklist.h" #include "if.h" diff --git a/eigrpd/eigrp_neighbor.c b/eigrpd/eigrp_neighbor.c index 9288b0f1cd..f427067b36 100644 --- a/eigrpd/eigrp_neighbor.c +++ b/eigrpd/eigrp_neighbor.c @@ -20,7 +20,7 @@ #include "prefix.h" #include "memory.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "stream.h" #include "table.h" #include "log.h" diff --git a/eigrpd/eigrp_network.c b/eigrpd/eigrp_network.c index 68edd0898a..4e5580480b 100644 --- a/eigrpd/eigrp_network.c +++ b/eigrpd/eigrp_network.c @@ -12,7 +12,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "prefix.h" #include "if.h" diff --git a/eigrpd/eigrp_packet.c b/eigrpd/eigrp_packet.c index e00d62fb08..02fb3d23b8 100644 --- a/eigrpd/eigrp_packet.c +++ b/eigrpd/eigrp_packet.c @@ -12,7 +12,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "vty.h" diff --git a/eigrpd/eigrp_query.c b/eigrpd/eigrp_query.c index 56498ed674..7e21eb79a0 100644 --- a/eigrpd/eigrp_query.c +++ b/eigrpd/eigrp_query.c @@ -12,7 +12,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/eigrpd/eigrp_reply.c b/eigrpd/eigrp_reply.c index a1413fe9c7..07d1fd75d6 100644 --- a/eigrpd/eigrp_reply.c +++ b/eigrpd/eigrp_reply.c @@ -16,7 +16,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/eigrpd/eigrp_siaquery.c b/eigrpd/eigrp_siaquery.c index 1c2ec3731f..f4ddf1da32 100644 --- a/eigrpd/eigrp_siaquery.c +++ b/eigrpd/eigrp_siaquery.c @@ -12,7 +12,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/eigrpd/eigrp_siareply.c b/eigrpd/eigrp_siareply.c index 37cca67373..aaea1df778 100644 --- a/eigrpd/eigrp_siareply.c +++ b/eigrpd/eigrp_siareply.c @@ -11,7 +11,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/eigrpd/eigrp_snmp.c b/eigrpd/eigrp_snmp.c index f159415ccb..efa72e3a09 100644 --- a/eigrpd/eigrp_snmp.c +++ b/eigrpd/eigrp_snmp.c @@ -16,7 +16,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/eigrpd/eigrp_update.c b/eigrpd/eigrp_update.c index 49acf30695..6d4b3eb8e9 100644 --- a/eigrpd/eigrp_update.c +++ b/eigrpd/eigrp_update.c @@ -16,7 +16,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/eigrpd/eigrp_vty.c b/eigrpd/eigrp_vty.c index 33f728ec4b..c4dba8bc31 100644 --- a/eigrpd/eigrp_vty.c +++ b/eigrpd/eigrp_vty.c @@ -17,7 +17,7 @@ #include #include "memory.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "table.h" #include "vty.h" diff --git a/eigrpd/eigrp_zebra.c b/eigrpd/eigrp_zebra.c index 179c2d0f2a..0ae8c3b45e 100644 --- a/eigrpd/eigrp_zebra.c +++ b/eigrpd/eigrp_zebra.c @@ -12,7 +12,7 @@ #include -#include "thread.h" +#include "event.h" #include "command.h" #include "network.h" #include "prefix.h" diff --git a/eigrpd/eigrpd.c b/eigrpd/eigrpd.c index a382862e3d..9db0531b59 100644 --- a/eigrpd/eigrpd.c +++ b/eigrpd/eigrpd.c @@ -12,7 +12,7 @@ #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "linklist.h" diff --git a/gdb/lib.txt b/gdb/lib.txt index b44c237985..5d22321b62 100644 --- a/gdb/lib.txt +++ b/gdb/lib.txt @@ -157,7 +157,7 @@ document walk_route_table Walk through a routing table (or subset thereof) and dump all the non-null (struct route_node *)->info pointers. -Argument: A lib/thread.h::(struct route_node *) pointing to the route_node +Argument: A lib/hread.h::(struct route_node *) pointing to the route_node under which all data should be dumped end diff --git a/isisd/isis_adjacency.c b/isisd/isis_adjacency.c index cb2cf8f611..16def982b7 100644 --- a/isisd/isis_adjacency.c +++ b/isisd/isis_adjacency.c @@ -15,7 +15,7 @@ #include "hash.h" #include "vty.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "if.h" #include "stream.h" #include "bfd.h" diff --git a/isisd/isis_circuit.c b/isisd/isis_circuit.c index 1ee7f4451d..8593aee8be 100644 --- a/isisd/isis_circuit.c +++ b/isisd/isis_circuit.c @@ -19,7 +19,7 @@ #include "if.h" #include "linklist.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "hash.h" #include "prefix.h" diff --git a/isisd/isis_csm.c b/isisd/isis_csm.c index 95bbc077a3..2b460e10cf 100644 --- a/isisd/isis_csm.c +++ b/isisd/isis_csm.c @@ -14,7 +14,7 @@ #include "if.h" #include "linklist.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "prefix.h" #include "stream.h" diff --git a/isisd/isis_dr.c b/isisd/isis_dr.c index b1a4215813..5b236a66d7 100644 --- a/isisd/isis_dr.c +++ b/isisd/isis_dr.c @@ -13,7 +13,7 @@ #include "log.h" #include "hash.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "vty.h" #include "stream.h" diff --git a/isisd/isis_dynhn.c b/isisd/isis_dynhn.c index ef21de327e..667a90c2cf 100644 --- a/isisd/isis_dynhn.c +++ b/isisd/isis_dynhn.c @@ -16,7 +16,7 @@ #include "stream.h" #include "command.h" #include "if.h" -#include "thread.h" +#include "event.h" #include "isisd/isis_constants.h" #include "isisd/isis_common.h" diff --git a/isisd/isis_events.c b/isisd/isis_events.c index d7b3969114..87b6061b58 100644 --- a/isisd/isis_events.c +++ b/isisd/isis_events.c @@ -13,7 +13,7 @@ #include "if.h" #include "linklist.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "prefix.h" #include "stream.h" diff --git a/isisd/isis_ldp_sync.c b/isisd/isis_ldp_sync.c index 817e2a2015..497906aaec 100644 --- a/isisd/isis_ldp_sync.c +++ b/isisd/isis_ldp_sync.c @@ -9,7 +9,7 @@ #include "monotime.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "table.h" #include "vty.h" diff --git a/isisd/isis_lsp.c b/isisd/isis_lsp.c index 4a332d0aed..59cedec706 100644 --- a/isisd/isis_lsp.c +++ b/isisd/isis_lsp.c @@ -12,7 +12,7 @@ #include #include "linklist.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "stream.h" #include "memory.h" diff --git a/isisd/isis_main.c b/isisd/isis_main.c index 25ea187492..99a18fc31c 100644 --- a/isisd/isis_main.c +++ b/isisd/isis_main.c @@ -10,7 +10,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "log.h" #include #include "command.h" diff --git a/isisd/isis_pdu.c b/isisd/isis_pdu.c index f659f3abc3..ec1b8d2686 100644 --- a/isisd/isis_pdu.c +++ b/isisd/isis_pdu.c @@ -11,7 +11,7 @@ #include #include "memory.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "log.h" #include "stream.h" diff --git a/isisd/isis_route.c b/isisd/isis_route.c index 711d5cbed9..57f5972123 100644 --- a/isisd/isis_route.c +++ b/isisd/isis_route.c @@ -11,7 +11,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "vty.h" #include "log.h" diff --git a/isisd/isis_routemap.c b/isisd/isis_routemap.c index 632b4ff95e..6d2a1f1599 100644 --- a/isisd/isis_routemap.c +++ b/isisd/isis_routemap.c @@ -18,7 +18,7 @@ #include "plist.h" #include "routemap.h" #include "table.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "isis_constants.h" diff --git a/isisd/isis_spf.c b/isisd/isis_spf.c index 9229f0a77d..90f5ff69a2 100644 --- a/isisd/isis_spf.c +++ b/isisd/isis_spf.c @@ -11,7 +11,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "vty.h" #include "log.h" diff --git a/isisd/isis_te.c b/isisd/isis_te.c index 3659f4e07c..9d859c222b 100644 --- a/isisd/isis_te.c +++ b/isisd/isis_te.c @@ -13,7 +13,7 @@ #include #include "linklist.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "stream.h" #include "memory.h" diff --git a/isisd/isis_zebra.c b/isisd/isis_zebra.c index 7e85576c7a..c344f16347 100644 --- a/isisd/isis_zebra.c +++ b/isisd/isis_zebra.c @@ -10,7 +10,7 @@ #include -#include "thread.h" +#include "event.h" #include "command.h" #include "memory.h" #include "log.h" diff --git a/isisd/isisd.c b/isisd/isisd.c index 586785b05f..ee402dad93 100644 --- a/isisd/isisd.c +++ b/isisd/isisd.c @@ -9,7 +9,7 @@ #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "log.h" diff --git a/ldpd/ldpd.h b/ldpd/ldpd.h index dc993e3d7c..cbf9165538 100644 --- a/ldpd/ldpd.h +++ b/ldpd/ldpd.h @@ -14,7 +14,7 @@ #include "queue.h" #include "openbsd-tree.h" #include "imsg.h" -#include "thread.h" +#include "event.h" #include "qobj.h" #include "prefix.h" #include "filter.h" diff --git a/lib/bfd.c b/lib/bfd.c index c1e0fff7f5..c430b1d7ef 100644 --- a/lib/bfd.c +++ b/lib/bfd.c @@ -10,7 +10,7 @@ #include "command.h" #include "memory.h" #include "prefix.h" -#include "thread.h" +#include "event.h" #include "stream.h" #include "vrf.h" #include "zclient.h" diff --git a/lib/command.c b/lib/command.c index 196d73d46a..e2de6f322b 100644 --- a/lib/command.c +++ b/lib/command.c @@ -17,7 +17,7 @@ #include "memory.h" #include "log.h" #include "log_vty.h" -#include "thread.h" +#include "event.h" #include "vector.h" #include "linklist.h" #include "vty.h" diff --git a/lib/event.c b/lib/event.c new file mode 100644 index 0000000000..b0f901ab0e --- /dev/null +++ b/lib/event.c @@ -0,0 +1,2198 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* Thread management routine + * Copyright (C) 1998, 2000 Kunihiro Ishiguro + */ + +/* #define DEBUG */ + +#include +#include + +#include "event.h" +#include "memory.h" +#include "frrcu.h" +#include "log.h" +#include "hash.h" +#include "command.h" +#include "sigevent.h" +#include "network.h" +#include "jhash.h" +#include "frratomic.h" +#include "frr_pthread.h" +#include "lib_errors.h" +#include "libfrr_trace.h" +#include "libfrr.h" + +DEFINE_MTYPE_STATIC(LIB, THREAD, "Thread"); +DEFINE_MTYPE_STATIC(LIB, THREAD_MASTER, "Thread master"); +DEFINE_MTYPE_STATIC(LIB, THREAD_POLL, "Thread Poll Info"); +DEFINE_MTYPE_STATIC(LIB, THREAD_STATS, "Thread stats"); + +DECLARE_LIST(thread_list, struct thread, threaditem); + +struct cancel_req { + int flags; + struct thread *thread; + void *eventobj; + struct thread **threadref; +}; + +/* Flags for task cancellation */ +#define THREAD_CANCEL_FLAG_READY 0x01 + +static int thread_timer_cmp(const struct thread *a, const struct thread *b) +{ + if (a->u.sands.tv_sec < b->u.sands.tv_sec) + return -1; + if (a->u.sands.tv_sec > b->u.sands.tv_sec) + return 1; + if (a->u.sands.tv_usec < b->u.sands.tv_usec) + return -1; + if (a->u.sands.tv_usec > b->u.sands.tv_usec) + return 1; + return 0; +} + +DECLARE_HEAP(thread_timer_list, struct thread, timeritem, thread_timer_cmp); + +#if defined(__APPLE__) +#include +#include +#endif + +#define AWAKEN(m) \ + do { \ + const unsigned char wakebyte = 0x01; \ + write(m->io_pipe[1], &wakebyte, 1); \ + } while (0); + +/* control variable for initializer */ +static pthread_once_t init_once = PTHREAD_ONCE_INIT; +pthread_key_t thread_current; + +static pthread_mutex_t masters_mtx = PTHREAD_MUTEX_INITIALIZER; +static struct list *masters; + +static void thread_free(struct thread_master *master, struct thread *thread); + +#ifndef EXCLUDE_CPU_TIME +#define EXCLUDE_CPU_TIME 0 +#endif +#ifndef CONSUMED_TIME_CHECK +#define CONSUMED_TIME_CHECK 0 +#endif + +bool cputime_enabled = !EXCLUDE_CPU_TIME; +unsigned long cputime_threshold = CONSUMED_TIME_CHECK; +unsigned long walltime_threshold = CONSUMED_TIME_CHECK; + +/* CLI start ---------------------------------------------------------------- */ +#include "lib/event_clippy.c" + +static unsigned int cpu_record_hash_key(const struct cpu_thread_history *a) +{ + int size = sizeof(a->func); + + return jhash(&a->func, size, 0); +} + +static bool cpu_record_hash_cmp(const struct cpu_thread_history *a, + const struct cpu_thread_history *b) +{ + return a->func == b->func; +} + +static void *cpu_record_hash_alloc(struct cpu_thread_history *a) +{ + struct cpu_thread_history *new; + new = XCALLOC(MTYPE_THREAD_STATS, sizeof(struct cpu_thread_history)); + new->func = a->func; + new->funcname = a->funcname; + return new; +} + +static void cpu_record_hash_free(void *a) +{ + struct cpu_thread_history *hist = a; + + XFREE(MTYPE_THREAD_STATS, hist); +} + +static void vty_out_cpu_thread_history(struct vty *vty, + struct cpu_thread_history *a) +{ + vty_out(vty, + "%5zu %10zu.%03zu %9zu %8zu %9zu %8zu %9zu %9zu %9zu %10zu", + a->total_active, a->cpu.total / 1000, a->cpu.total % 1000, + a->total_calls, (a->cpu.total / a->total_calls), a->cpu.max, + (a->real.total / a->total_calls), a->real.max, + a->total_cpu_warn, a->total_wall_warn, a->total_starv_warn); + vty_out(vty, " %c%c%c%c%c %s\n", + a->types & (1 << THREAD_READ) ? 'R' : ' ', + a->types & (1 << THREAD_WRITE) ? 'W' : ' ', + a->types & (1 << THREAD_TIMER) ? 'T' : ' ', + a->types & (1 << THREAD_EVENT) ? 'E' : ' ', + a->types & (1 << THREAD_EXECUTE) ? 'X' : ' ', a->funcname); +} + +static void cpu_record_hash_print(struct hash_bucket *bucket, void *args[]) +{ + struct cpu_thread_history *totals = args[0]; + struct cpu_thread_history copy; + struct vty *vty = args[1]; + uint8_t *filter = args[2]; + + struct cpu_thread_history *a = bucket->data; + + copy.total_active = + atomic_load_explicit(&a->total_active, memory_order_seq_cst); + copy.total_calls = + atomic_load_explicit(&a->total_calls, memory_order_seq_cst); + copy.total_cpu_warn = + atomic_load_explicit(&a->total_cpu_warn, memory_order_seq_cst); + copy.total_wall_warn = + atomic_load_explicit(&a->total_wall_warn, memory_order_seq_cst); + copy.total_starv_warn = atomic_load_explicit(&a->total_starv_warn, + memory_order_seq_cst); + copy.cpu.total = + atomic_load_explicit(&a->cpu.total, memory_order_seq_cst); + copy.cpu.max = atomic_load_explicit(&a->cpu.max, memory_order_seq_cst); + copy.real.total = + atomic_load_explicit(&a->real.total, memory_order_seq_cst); + copy.real.max = + atomic_load_explicit(&a->real.max, memory_order_seq_cst); + copy.types = atomic_load_explicit(&a->types, memory_order_seq_cst); + copy.funcname = a->funcname; + + if (!(copy.types & *filter)) + return; + + vty_out_cpu_thread_history(vty, ©); + totals->total_active += copy.total_active; + totals->total_calls += copy.total_calls; + totals->total_cpu_warn += copy.total_cpu_warn; + totals->total_wall_warn += copy.total_wall_warn; + totals->total_starv_warn += copy.total_starv_warn; + totals->real.total += copy.real.total; + if (totals->real.max < copy.real.max) + totals->real.max = copy.real.max; + totals->cpu.total += copy.cpu.total; + if (totals->cpu.max < copy.cpu.max) + totals->cpu.max = copy.cpu.max; +} + +static void cpu_record_print(struct vty *vty, uint8_t filter) +{ + struct cpu_thread_history tmp; + void *args[3] = {&tmp, vty, &filter}; + struct thread_master *m; + struct listnode *ln; + + if (!cputime_enabled) + vty_out(vty, + "\n" + "Collecting CPU time statistics is currently disabled. Following statistics\n" + "will be zero or may display data from when collection was enabled. Use the\n" + " \"service cputime-stats\" command to start collecting data.\n" + "\nCounters and wallclock times are always maintained and should be accurate.\n"); + + memset(&tmp, 0, sizeof(tmp)); + tmp.funcname = "TOTAL"; + tmp.types = filter; + + frr_with_mutex (&masters_mtx) { + for (ALL_LIST_ELEMENTS_RO(masters, ln, m)) { + const char *name = m->name ? m->name : "main"; + + char underline[strlen(name) + 1]; + memset(underline, '-', sizeof(underline)); + underline[sizeof(underline) - 1] = '\0'; + + vty_out(vty, "\n"); + vty_out(vty, "Showing statistics for pthread %s\n", + name); + vty_out(vty, "-------------------------------%s\n", + underline); + vty_out(vty, "%30s %18s %18s\n", "", + "CPU (user+system):", "Real (wall-clock):"); + vty_out(vty, + "Active Runtime(ms) Invoked Avg uSec Max uSecs"); + vty_out(vty, " Avg uSec Max uSecs"); + vty_out(vty, + " CPU_Warn Wall_Warn Starv_Warn Type Thread\n"); + + if (m->cpu_record->count) + hash_iterate( + m->cpu_record, + (void (*)(struct hash_bucket *, + void *))cpu_record_hash_print, + args); + else + vty_out(vty, "No data to display yet.\n"); + + vty_out(vty, "\n"); + } + } + + vty_out(vty, "\n"); + vty_out(vty, "Total thread statistics\n"); + vty_out(vty, "-------------------------\n"); + vty_out(vty, "%30s %18s %18s\n", "", + "CPU (user+system):", "Real (wall-clock):"); + vty_out(vty, "Active Runtime(ms) Invoked Avg uSec Max uSecs"); + vty_out(vty, " Avg uSec Max uSecs CPU_Warn Wall_Warn"); + vty_out(vty, " Type Thread\n"); + + if (tmp.total_calls > 0) + vty_out_cpu_thread_history(vty, &tmp); +} + +static void cpu_record_hash_clear(struct hash_bucket *bucket, void *args[]) +{ + uint8_t *filter = args[0]; + struct hash *cpu_record = args[1]; + + struct cpu_thread_history *a = bucket->data; + + if (!(a->types & *filter)) + return; + + hash_release(cpu_record, bucket->data); +} + +static void cpu_record_clear(uint8_t filter) +{ + uint8_t *tmp = &filter; + struct thread_master *m; + struct listnode *ln; + + frr_with_mutex (&masters_mtx) { + for (ALL_LIST_ELEMENTS_RO(masters, ln, m)) { + frr_with_mutex (&m->mtx) { + void *args[2] = {tmp, m->cpu_record}; + hash_iterate( + m->cpu_record, + (void (*)(struct hash_bucket *, + void *))cpu_record_hash_clear, + args); + } + } + } +} + +static uint8_t parse_filter(const char *filterstr) +{ + int i = 0; + int filter = 0; + + while (filterstr[i] != '\0') { + switch (filterstr[i]) { + case 'r': + case 'R': + filter |= (1 << THREAD_READ); + break; + case 'w': + case 'W': + filter |= (1 << THREAD_WRITE); + break; + case 't': + case 'T': + filter |= (1 << THREAD_TIMER); + break; + case 'e': + case 'E': + filter |= (1 << THREAD_EVENT); + break; + case 'x': + case 'X': + filter |= (1 << THREAD_EXECUTE); + break; + default: + break; + } + ++i; + } + return filter; +} + +DEFUN_NOSH (show_thread_cpu, + show_thread_cpu_cmd, + "show thread cpu [FILTER]", + SHOW_STR + "Thread information\n" + "Thread CPU usage\n" + "Display filter (rwtex)\n") +{ + uint8_t filter = (uint8_t)-1U; + int idx = 0; + + if (argv_find(argv, argc, "FILTER", &idx)) { + filter = parse_filter(argv[idx]->arg); + if (!filter) { + vty_out(vty, + "Invalid filter \"%s\" specified; must contain at leastone of 'RWTEXB'\n", + argv[idx]->arg); + return CMD_WARNING; + } + } + + cpu_record_print(vty, filter); + return CMD_SUCCESS; +} + +DEFPY (service_cputime_stats, + service_cputime_stats_cmd, + "[no] service cputime-stats", + NO_STR + "Set up miscellaneous service\n" + "Collect CPU usage statistics\n") +{ + cputime_enabled = !no; + return CMD_SUCCESS; +} + +DEFPY (service_cputime_warning, + service_cputime_warning_cmd, + "[no] service cputime-warning (1-4294967295)", + NO_STR + "Set up miscellaneous service\n" + "Warn for tasks exceeding CPU usage threshold\n" + "Warning threshold in milliseconds\n") +{ + if (no) + cputime_threshold = 0; + else + cputime_threshold = cputime_warning * 1000; + return CMD_SUCCESS; +} + +ALIAS (service_cputime_warning, + no_service_cputime_warning_cmd, + "no service cputime-warning", + NO_STR + "Set up miscellaneous service\n" + "Warn for tasks exceeding CPU usage threshold\n") + +DEFPY (service_walltime_warning, + service_walltime_warning_cmd, + "[no] service walltime-warning (1-4294967295)", + NO_STR + "Set up miscellaneous service\n" + "Warn for tasks exceeding total wallclock threshold\n" + "Warning threshold in milliseconds\n") +{ + if (no) + walltime_threshold = 0; + else + walltime_threshold = walltime_warning * 1000; + return CMD_SUCCESS; +} + +ALIAS (service_walltime_warning, + no_service_walltime_warning_cmd, + "no service walltime-warning", + NO_STR + "Set up miscellaneous service\n" + "Warn for tasks exceeding total wallclock threshold\n") + +static void show_thread_poll_helper(struct vty *vty, struct thread_master *m) +{ + const char *name = m->name ? m->name : "main"; + char underline[strlen(name) + 1]; + struct thread *thread; + uint32_t i; + + memset(underline, '-', sizeof(underline)); + underline[sizeof(underline) - 1] = '\0'; + + vty_out(vty, "\nShowing poll FD's for %s\n", name); + vty_out(vty, "----------------------%s\n", underline); + vty_out(vty, "Count: %u/%d\n", (uint32_t)m->handler.pfdcount, + m->fd_limit); + for (i = 0; i < m->handler.pfdcount; i++) { + vty_out(vty, "\t%6d fd:%6d events:%2d revents:%2d\t\t", i, + m->handler.pfds[i].fd, m->handler.pfds[i].events, + m->handler.pfds[i].revents); + + if (m->handler.pfds[i].events & POLLIN) { + thread = m->read[m->handler.pfds[i].fd]; + + if (!thread) + vty_out(vty, "ERROR "); + else + vty_out(vty, "%s ", thread->xref->funcname); + } else + vty_out(vty, " "); + + if (m->handler.pfds[i].events & POLLOUT) { + thread = m->write[m->handler.pfds[i].fd]; + + if (!thread) + vty_out(vty, "ERROR\n"); + else + vty_out(vty, "%s\n", thread->xref->funcname); + } else + vty_out(vty, "\n"); + } +} + +DEFUN_NOSH (show_thread_poll, + show_thread_poll_cmd, + "show thread poll", + SHOW_STR + "Thread information\n" + "Show poll FD's and information\n") +{ + struct listnode *node; + struct thread_master *m; + + frr_with_mutex (&masters_mtx) { + for (ALL_LIST_ELEMENTS_RO(masters, node, m)) { + show_thread_poll_helper(vty, m); + } + } + + return CMD_SUCCESS; +} + + +DEFUN (clear_thread_cpu, + clear_thread_cpu_cmd, + "clear thread cpu [FILTER]", + "Clear stored data in all pthreads\n" + "Thread information\n" + "Thread CPU usage\n" + "Display filter (rwtexb)\n") +{ + uint8_t filter = (uint8_t)-1U; + int idx = 0; + + if (argv_find(argv, argc, "FILTER", &idx)) { + filter = parse_filter(argv[idx]->arg); + if (!filter) { + vty_out(vty, + "Invalid filter \"%s\" specified; must contain at leastone of 'RWTEXB'\n", + argv[idx]->arg); + return CMD_WARNING; + } + } + + cpu_record_clear(filter); + return CMD_SUCCESS; +} + +static void show_thread_timers_helper(struct vty *vty, struct thread_master *m) +{ + const char *name = m->name ? m->name : "main"; + char underline[strlen(name) + 1]; + struct thread *thread; + + memset(underline, '-', sizeof(underline)); + underline[sizeof(underline) - 1] = '\0'; + + vty_out(vty, "\nShowing timers for %s\n", name); + vty_out(vty, "-------------------%s\n", underline); + + frr_each (thread_timer_list, &m->timer, thread) { + vty_out(vty, " %-50s%pTH\n", thread->hist->funcname, thread); + } +} + +DEFPY_NOSH (show_thread_timers, + show_thread_timers_cmd, + "show thread timers", + SHOW_STR + "Thread information\n" + "Show all timers and how long they have in the system\n") +{ + struct listnode *node; + struct thread_master *m; + + frr_with_mutex (&masters_mtx) { + for (ALL_LIST_ELEMENTS_RO(masters, node, m)) + show_thread_timers_helper(vty, m); + } + + return CMD_SUCCESS; +} + +void thread_cmd_init(void) +{ + install_element(VIEW_NODE, &show_thread_cpu_cmd); + install_element(VIEW_NODE, &show_thread_poll_cmd); + install_element(ENABLE_NODE, &clear_thread_cpu_cmd); + + install_element(CONFIG_NODE, &service_cputime_stats_cmd); + install_element(CONFIG_NODE, &service_cputime_warning_cmd); + install_element(CONFIG_NODE, &no_service_cputime_warning_cmd); + install_element(CONFIG_NODE, &service_walltime_warning_cmd); + install_element(CONFIG_NODE, &no_service_walltime_warning_cmd); + + install_element(VIEW_NODE, &show_thread_timers_cmd); +} +/* CLI end ------------------------------------------------------------------ */ + + +static void cancelreq_del(void *cr) +{ + XFREE(MTYPE_TMP, cr); +} + +/* initializer, only ever called once */ +static void initializer(void) +{ + pthread_key_create(&thread_current, NULL); +} + +struct thread_master *thread_master_create(const char *name) +{ + struct thread_master *rv; + struct rlimit limit; + + pthread_once(&init_once, &initializer); + + rv = XCALLOC(MTYPE_THREAD_MASTER, sizeof(struct thread_master)); + + /* Initialize master mutex */ + pthread_mutex_init(&rv->mtx, NULL); + pthread_cond_init(&rv->cancel_cond, NULL); + + /* Set name */ + name = name ? name : "default"; + rv->name = XSTRDUP(MTYPE_THREAD_MASTER, name); + + /* Initialize I/O task data structures */ + + /* Use configured limit if present, ulimit otherwise. */ + rv->fd_limit = frr_get_fd_limit(); + if (rv->fd_limit == 0) { + getrlimit(RLIMIT_NOFILE, &limit); + rv->fd_limit = (int)limit.rlim_cur; + } + + rv->read = XCALLOC(MTYPE_THREAD_POLL, + sizeof(struct thread *) * rv->fd_limit); + + rv->write = XCALLOC(MTYPE_THREAD_POLL, + sizeof(struct thread *) * rv->fd_limit); + + char tmhashname[strlen(name) + 32]; + snprintf(tmhashname, sizeof(tmhashname), "%s - threadmaster event hash", + name); + rv->cpu_record = hash_create_size( + 8, (unsigned int (*)(const void *))cpu_record_hash_key, + (bool (*)(const void *, const void *))cpu_record_hash_cmp, + tmhashname); + + thread_list_init(&rv->event); + thread_list_init(&rv->ready); + thread_list_init(&rv->unuse); + thread_timer_list_init(&rv->timer); + + /* Initialize thread_fetch() settings */ + rv->spin = true; + rv->handle_signals = true; + + /* Set pthread owner, should be updated by actual owner */ + rv->owner = pthread_self(); + rv->cancel_req = list_new(); + rv->cancel_req->del = cancelreq_del; + rv->canceled = true; + + /* Initialize pipe poker */ + pipe(rv->io_pipe); + set_nonblocking(rv->io_pipe[0]); + set_nonblocking(rv->io_pipe[1]); + + /* Initialize data structures for poll() */ + rv->handler.pfdsize = rv->fd_limit; + rv->handler.pfdcount = 0; + rv->handler.pfds = XCALLOC(MTYPE_THREAD_MASTER, + sizeof(struct pollfd) * rv->handler.pfdsize); + rv->handler.copy = XCALLOC(MTYPE_THREAD_MASTER, + sizeof(struct pollfd) * rv->handler.pfdsize); + + /* add to list of threadmasters */ + frr_with_mutex (&masters_mtx) { + if (!masters) + masters = list_new(); + + listnode_add(masters, rv); + } + + return rv; +} + +void thread_master_set_name(struct thread_master *master, const char *name) +{ + frr_with_mutex (&master->mtx) { + XFREE(MTYPE_THREAD_MASTER, master->name); + master->name = XSTRDUP(MTYPE_THREAD_MASTER, name); + } +} + +#define THREAD_UNUSED_DEPTH 10 + +/* Move thread to unuse list. */ +static void thread_add_unuse(struct thread_master *m, struct thread *thread) +{ + pthread_mutex_t mtxc = thread->mtx; + + assert(m != NULL && thread != NULL); + + thread->hist->total_active--; + memset(thread, 0, sizeof(struct thread)); + thread->type = THREAD_UNUSED; + + /* Restore the thread mutex context. */ + thread->mtx = mtxc; + + if (thread_list_count(&m->unuse) < THREAD_UNUSED_DEPTH) { + thread_list_add_tail(&m->unuse, thread); + return; + } + + thread_free(m, thread); +} + +/* Free all unused thread. */ +static void thread_list_free(struct thread_master *m, + struct thread_list_head *list) +{ + struct thread *t; + + while ((t = thread_list_pop(list))) + thread_free(m, t); +} + +static void thread_array_free(struct thread_master *m, + struct thread **thread_array) +{ + struct thread *t; + int index; + + for (index = 0; index < m->fd_limit; ++index) { + t = thread_array[index]; + if (t) { + thread_array[index] = NULL; + thread_free(m, t); + } + } + XFREE(MTYPE_THREAD_POLL, thread_array); +} + +/* + * thread_master_free_unused + * + * As threads are finished with they are put on the + * unuse list for later reuse. + * If we are shutting down, Free up unused threads + * So we can see if we forget to shut anything off + */ +void thread_master_free_unused(struct thread_master *m) +{ + frr_with_mutex (&m->mtx) { + struct thread *t; + while ((t = thread_list_pop(&m->unuse))) + thread_free(m, t); + } +} + +/* Stop thread scheduler. */ +void thread_master_free(struct thread_master *m) +{ + struct thread *t; + + frr_with_mutex (&masters_mtx) { + listnode_delete(masters, m); + if (masters->count == 0) { + list_delete(&masters); + } + } + + thread_array_free(m, m->read); + thread_array_free(m, m->write); + while ((t = thread_timer_list_pop(&m->timer))) + thread_free(m, t); + thread_list_free(m, &m->event); + thread_list_free(m, &m->ready); + thread_list_free(m, &m->unuse); + pthread_mutex_destroy(&m->mtx); + pthread_cond_destroy(&m->cancel_cond); + close(m->io_pipe[0]); + close(m->io_pipe[1]); + list_delete(&m->cancel_req); + m->cancel_req = NULL; + + hash_clean_and_free(&m->cpu_record, cpu_record_hash_free); + + XFREE(MTYPE_THREAD_MASTER, m->name); + XFREE(MTYPE_THREAD_MASTER, m->handler.pfds); + XFREE(MTYPE_THREAD_MASTER, m->handler.copy); + XFREE(MTYPE_THREAD_MASTER, m); +} + +/* Return remain time in milliseconds. */ +unsigned long thread_timer_remain_msec(struct thread *thread) +{ + int64_t remain; + + if (!thread_is_scheduled(thread)) + return 0; + + frr_with_mutex (&thread->mtx) { + remain = monotime_until(&thread->u.sands, NULL) / 1000LL; + } + + return remain < 0 ? 0 : remain; +} + +/* Return remain time in seconds. */ +unsigned long thread_timer_remain_second(struct thread *thread) +{ + return thread_timer_remain_msec(thread) / 1000LL; +} + +struct timeval thread_timer_remain(struct thread *thread) +{ + struct timeval remain; + frr_with_mutex (&thread->mtx) { + monotime_until(&thread->u.sands, &remain); + } + return remain; +} + +static int time_hhmmss(char *buf, int buf_size, long sec) +{ + long hh; + long mm; + int wr; + + assert(buf_size >= 8); + + hh = sec / 3600; + sec %= 3600; + mm = sec / 60; + sec %= 60; + + wr = snprintf(buf, buf_size, "%02ld:%02ld:%02ld", hh, mm, sec); + + return wr != 8; +} + +char *thread_timer_to_hhmmss(char *buf, int buf_size, + struct thread *t_timer) +{ + if (t_timer) { + time_hhmmss(buf, buf_size, + thread_timer_remain_second(t_timer)); + } else { + snprintf(buf, buf_size, "--:--:--"); + } + return buf; +} + +/* Get new thread. */ +static struct thread *thread_get(struct thread_master *m, uint8_t type, + void (*func)(struct thread *), void *arg, + const struct xref_threadsched *xref) +{ + struct thread *thread = thread_list_pop(&m->unuse); + struct cpu_thread_history tmp; + + if (!thread) { + thread = XCALLOC(MTYPE_THREAD, sizeof(struct thread)); + /* mutex only needs to be initialized at struct creation. */ + pthread_mutex_init(&thread->mtx, NULL); + m->alloc++; + } + + thread->type = type; + thread->add_type = type; + thread->master = m; + thread->arg = arg; + thread->yield = THREAD_YIELD_TIME_SLOT; /* default */ + thread->ref = NULL; + thread->ignore_timer_late = false; + + /* + * So if the passed in funcname is not what we have + * stored that means the thread->hist needs to be + * updated. We keep the last one around in unused + * under the assumption that we are probably + * going to immediately allocate the same + * type of thread. + * This hopefully saves us some serious + * hash_get lookups. + */ + if ((thread->xref && thread->xref->funcname != xref->funcname) + || thread->func != func) { + tmp.func = func; + tmp.funcname = xref->funcname; + thread->hist = + hash_get(m->cpu_record, &tmp, + (void *(*)(void *))cpu_record_hash_alloc); + } + thread->hist->total_active++; + thread->func = func; + thread->xref = xref; + + return thread; +} + +static void thread_free(struct thread_master *master, struct thread *thread) +{ + /* Update statistics. */ + assert(master->alloc > 0); + master->alloc--; + + /* Free allocated resources. */ + pthread_mutex_destroy(&thread->mtx); + XFREE(MTYPE_THREAD, thread); +} + +static int fd_poll(struct thread_master *m, const struct timeval *timer_wait, + bool *eintr_p) +{ + sigset_t origsigs; + unsigned char trash[64]; + nfds_t count = m->handler.copycount; + + /* + * If timer_wait is null here, that means poll() should block + * indefinitely, unless the thread_master has overridden it by setting + * ->selectpoll_timeout. + * + * If the value is positive, it specifies the maximum number of + * milliseconds to wait. If the timeout is -1, it specifies that + * we should never wait and always return immediately even if no + * event is detected. If the value is zero, the behavior is default. + */ + int timeout = -1; + + /* number of file descriptors with events */ + int num; + + if (timer_wait != NULL + && m->selectpoll_timeout == 0) // use the default value + timeout = (timer_wait->tv_sec * 1000) + + (timer_wait->tv_usec / 1000); + else if (m->selectpoll_timeout > 0) // use the user's timeout + timeout = m->selectpoll_timeout; + else if (m->selectpoll_timeout + < 0) // effect a poll (return immediately) + timeout = 0; + + zlog_tls_buffer_flush(); + rcu_read_unlock(); + rcu_assert_read_unlocked(); + + /* add poll pipe poker */ + assert(count + 1 < m->handler.pfdsize); + m->handler.copy[count].fd = m->io_pipe[0]; + m->handler.copy[count].events = POLLIN; + m->handler.copy[count].revents = 0x00; + + /* We need to deal with a signal-handling race here: we + * don't want to miss a crucial signal, such as SIGTERM or SIGINT, + * that may arrive just before we enter poll(). We will block the + * key signals, then check whether any have arrived - if so, we return + * before calling poll(). If not, we'll re-enable the signals + * in the ppoll() call. + */ + + sigemptyset(&origsigs); + if (m->handle_signals) { + /* Main pthread that handles the app signals */ + if (frr_sigevent_check(&origsigs)) { + /* Signal to process - restore signal mask and return */ + pthread_sigmask(SIG_SETMASK, &origsigs, NULL); + num = -1; + *eintr_p = true; + goto done; + } + } else { + /* Don't make any changes for the non-main pthreads */ + pthread_sigmask(SIG_SETMASK, NULL, &origsigs); + } + +#if defined(HAVE_PPOLL) + struct timespec ts, *tsp; + + if (timeout >= 0) { + ts.tv_sec = timeout / 1000; + ts.tv_nsec = (timeout % 1000) * 1000000; + tsp = &ts; + } else + tsp = NULL; + + num = ppoll(m->handler.copy, count + 1, tsp, &origsigs); + pthread_sigmask(SIG_SETMASK, &origsigs, NULL); +#else + /* Not ideal - there is a race after we restore the signal mask */ + pthread_sigmask(SIG_SETMASK, &origsigs, NULL); + num = poll(m->handler.copy, count + 1, timeout); +#endif + +done: + + if (num < 0 && errno == EINTR) + *eintr_p = true; + + if (num > 0 && m->handler.copy[count].revents != 0 && num--) + while (read(m->io_pipe[0], &trash, sizeof(trash)) > 0) + ; + + rcu_read_lock(); + + return num; +} + +/* Add new read thread. */ +void _thread_add_read_write(const struct xref_threadsched *xref, + struct thread_master *m, + void (*func)(struct thread *), void *arg, int fd, + struct thread **t_ptr) +{ + int dir = xref->thread_type; + struct thread *thread = NULL; + struct thread **thread_array; + + if (dir == THREAD_READ) + frrtrace(9, frr_libfrr, schedule_read, m, + xref->funcname, xref->xref.file, xref->xref.line, + t_ptr, fd, 0, arg, 0); + else + frrtrace(9, frr_libfrr, schedule_write, m, + xref->funcname, xref->xref.file, xref->xref.line, + t_ptr, fd, 0, arg, 0); + + assert(fd >= 0); + if (fd >= m->fd_limit) + assert(!"Number of FD's open is greater than FRR currently configured to handle, aborting"); + + frr_with_mutex (&m->mtx) { + if (t_ptr && *t_ptr) + // thread is already scheduled; don't reschedule + break; + + /* default to a new pollfd */ + nfds_t queuepos = m->handler.pfdcount; + + if (dir == THREAD_READ) + thread_array = m->read; + else + thread_array = m->write; + + /* if we already have a pollfd for our file descriptor, find and + * use it */ + for (nfds_t i = 0; i < m->handler.pfdcount; i++) + if (m->handler.pfds[i].fd == fd) { + queuepos = i; + +#ifdef DEV_BUILD + /* + * What happens if we have a thread already + * created for this event? + */ + if (thread_array[fd]) + assert(!"Thread already scheduled for file descriptor"); +#endif + break; + } + + /* make sure we have room for this fd + pipe poker fd */ + assert(queuepos + 1 < m->handler.pfdsize); + + thread = thread_get(m, dir, func, arg, xref); + + m->handler.pfds[queuepos].fd = fd; + m->handler.pfds[queuepos].events |= + (dir == THREAD_READ ? POLLIN : POLLOUT); + + if (queuepos == m->handler.pfdcount) + m->handler.pfdcount++; + + if (thread) { + frr_with_mutex (&thread->mtx) { + thread->u.fd = fd; + thread_array[thread->u.fd] = thread; + } + + if (t_ptr) { + *t_ptr = thread; + thread->ref = t_ptr; + } + } + + AWAKEN(m); + } +} + +static void _thread_add_timer_timeval(const struct xref_threadsched *xref, + struct thread_master *m, + void (*func)(struct thread *), void *arg, + struct timeval *time_relative, + struct thread **t_ptr) +{ + struct thread *thread; + struct timeval t; + + assert(m != NULL); + + assert(time_relative); + + frrtrace(9, frr_libfrr, schedule_timer, m, + xref->funcname, xref->xref.file, xref->xref.line, + t_ptr, 0, 0, arg, (long)time_relative->tv_sec); + + /* Compute expiration/deadline time. */ + monotime(&t); + timeradd(&t, time_relative, &t); + + frr_with_mutex (&m->mtx) { + if (t_ptr && *t_ptr) + /* thread is already scheduled; don't reschedule */ + return; + + thread = thread_get(m, THREAD_TIMER, func, arg, xref); + + frr_with_mutex (&thread->mtx) { + thread->u.sands = t; + thread_timer_list_add(&m->timer, thread); + if (t_ptr) { + *t_ptr = thread; + thread->ref = t_ptr; + } + } + + /* The timer list is sorted - if this new timer + * might change the time we'll wait for, give the pthread + * a chance to re-compute. + */ + if (thread_timer_list_first(&m->timer) == thread) + AWAKEN(m); + } +#define ONEYEAR2SEC (60 * 60 * 24 * 365) + if (time_relative->tv_sec > ONEYEAR2SEC) + flog_err( + EC_LIB_TIMER_TOO_LONG, + "Timer: %pTHD is created with an expiration that is greater than 1 year", + thread); +} + + +/* Add timer event thread. */ +void _thread_add_timer(const struct xref_threadsched *xref, + struct thread_master *m, void (*func)(struct thread *), + void *arg, long timer, struct thread **t_ptr) +{ + struct timeval trel; + + assert(m != NULL); + + trel.tv_sec = timer; + trel.tv_usec = 0; + + _thread_add_timer_timeval(xref, m, func, arg, &trel, t_ptr); +} + +/* Add timer event thread with "millisecond" resolution */ +void _thread_add_timer_msec(const struct xref_threadsched *xref, + struct thread_master *m, + void (*func)(struct thread *), void *arg, + long timer, struct thread **t_ptr) +{ + struct timeval trel; + + assert(m != NULL); + + trel.tv_sec = timer / 1000; + trel.tv_usec = 1000 * (timer % 1000); + + _thread_add_timer_timeval(xref, m, func, arg, &trel, t_ptr); +} + +/* Add timer event thread with "timeval" resolution */ +void _thread_add_timer_tv(const struct xref_threadsched *xref, + struct thread_master *m, + void (*func)(struct thread *), void *arg, + struct timeval *tv, struct thread **t_ptr) +{ + _thread_add_timer_timeval(xref, m, func, arg, tv, t_ptr); +} + +/* Add simple event thread. */ +void _thread_add_event(const struct xref_threadsched *xref, + struct thread_master *m, void (*func)(struct thread *), + void *arg, int val, struct thread **t_ptr) +{ + struct thread *thread = NULL; + + frrtrace(9, frr_libfrr, schedule_event, m, + xref->funcname, xref->xref.file, xref->xref.line, + t_ptr, 0, val, arg, 0); + + assert(m != NULL); + + frr_with_mutex (&m->mtx) { + if (t_ptr && *t_ptr) + /* thread is already scheduled; don't reschedule */ + break; + + thread = thread_get(m, THREAD_EVENT, func, arg, xref); + frr_with_mutex (&thread->mtx) { + thread->u.val = val; + thread_list_add_tail(&m->event, thread); + } + + if (t_ptr) { + *t_ptr = thread; + thread->ref = t_ptr; + } + + AWAKEN(m); + } +} + +/* Thread cancellation ------------------------------------------------------ */ + +/** + * NOT's out the .events field of pollfd corresponding to the given file + * descriptor. The event to be NOT'd is passed in the 'state' parameter. + * + * This needs to happen for both copies of pollfd's. See 'thread_fetch' + * implementation for details. + * + * @param master + * @param fd + * @param state the event to cancel. One or more (OR'd together) of the + * following: + * - POLLIN + * - POLLOUT + */ +static void thread_cancel_rw(struct thread_master *master, int fd, short state, + int idx_hint) +{ + bool found = false; + + /* find the index of corresponding pollfd */ + nfds_t i; + + /* Cancel POLLHUP too just in case some bozo set it */ + state |= POLLHUP; + + /* Some callers know the index of the pfd already */ + if (idx_hint >= 0) { + i = idx_hint; + found = true; + } else { + /* Have to look for the fd in the pfd array */ + for (i = 0; i < master->handler.pfdcount; i++) + if (master->handler.pfds[i].fd == fd) { + found = true; + break; + } + } + + if (!found) { + zlog_debug( + "[!] Received cancellation request for nonexistent rw job"); + zlog_debug("[!] threadmaster: %s | fd: %d", + master->name ? master->name : "", fd); + return; + } + + /* NOT out event. */ + master->handler.pfds[i].events &= ~(state); + + /* If all events are canceled, delete / resize the pollfd array. */ + if (master->handler.pfds[i].events == 0) { + memmove(master->handler.pfds + i, master->handler.pfds + i + 1, + (master->handler.pfdcount - i - 1) + * sizeof(struct pollfd)); + master->handler.pfdcount--; + master->handler.pfds[master->handler.pfdcount].fd = 0; + master->handler.pfds[master->handler.pfdcount].events = 0; + } + + /* If we have the same pollfd in the copy, perform the same operations, + * otherwise return. */ + if (i >= master->handler.copycount) + return; + + master->handler.copy[i].events &= ~(state); + + if (master->handler.copy[i].events == 0) { + memmove(master->handler.copy + i, master->handler.copy + i + 1, + (master->handler.copycount - i - 1) + * sizeof(struct pollfd)); + master->handler.copycount--; + master->handler.copy[master->handler.copycount].fd = 0; + master->handler.copy[master->handler.copycount].events = 0; + } +} + +/* + * Process task cancellation given a task argument: iterate through the + * various lists of tasks, looking for any that match the argument. + */ +static void cancel_arg_helper(struct thread_master *master, + const struct cancel_req *cr) +{ + struct thread *t; + nfds_t i; + int fd; + struct pollfd *pfd; + + /* We're only processing arg-based cancellations here. */ + if (cr->eventobj == NULL) + return; + + /* First process the ready lists. */ + frr_each_safe(thread_list, &master->event, t) { + if (t->arg != cr->eventobj) + continue; + thread_list_del(&master->event, t); + if (t->ref) + *t->ref = NULL; + thread_add_unuse(master, t); + } + + frr_each_safe(thread_list, &master->ready, t) { + if (t->arg != cr->eventobj) + continue; + thread_list_del(&master->ready, t); + if (t->ref) + *t->ref = NULL; + thread_add_unuse(master, t); + } + + /* If requested, stop here and ignore io and timers */ + if (CHECK_FLAG(cr->flags, THREAD_CANCEL_FLAG_READY)) + return; + + /* Check the io tasks */ + for (i = 0; i < master->handler.pfdcount;) { + pfd = master->handler.pfds + i; + + if (pfd->events & POLLIN) + t = master->read[pfd->fd]; + else + t = master->write[pfd->fd]; + + if (t && t->arg == cr->eventobj) { + fd = pfd->fd; + + /* Found a match to cancel: clean up fd arrays */ + thread_cancel_rw(master, pfd->fd, pfd->events, i); + + /* Clean up thread arrays */ + master->read[fd] = NULL; + master->write[fd] = NULL; + + /* Clear caller's ref */ + if (t->ref) + *t->ref = NULL; + + thread_add_unuse(master, t); + + /* Don't increment 'i' since the cancellation will have + * removed the entry from the pfd array + */ + } else + i++; + } + + /* Check the timer tasks */ + t = thread_timer_list_first(&master->timer); + while (t) { + struct thread *t_next; + + t_next = thread_timer_list_next(&master->timer, t); + + if (t->arg == cr->eventobj) { + thread_timer_list_del(&master->timer, t); + if (t->ref) + *t->ref = NULL; + thread_add_unuse(master, t); + } + + t = t_next; + } +} + +/** + * Process cancellation requests. + * + * This may only be run from the pthread which owns the thread_master. + * + * @param master the thread master to process + * @REQUIRE master->mtx + */ +static void do_thread_cancel(struct thread_master *master) +{ + struct thread_list_head *list = NULL; + struct thread **thread_array = NULL; + struct thread *thread; + struct cancel_req *cr; + struct listnode *ln; + + for (ALL_LIST_ELEMENTS_RO(master->cancel_req, ln, cr)) { + /* + * If this is an event object cancellation, search + * through task lists deleting any tasks which have the + * specified argument - use this handy helper function. + */ + if (cr->eventobj) { + cancel_arg_helper(master, cr); + continue; + } + + /* + * The pointer varies depending on whether the cancellation + * request was made asynchronously or not. If it was, we + * need to check whether the thread even exists anymore + * before cancelling it. + */ + thread = (cr->thread) ? cr->thread : *cr->threadref; + + if (!thread) + continue; + + list = NULL; + thread_array = NULL; + + /* Determine the appropriate queue to cancel the thread from */ + switch (thread->type) { + case THREAD_READ: + thread_cancel_rw(master, thread->u.fd, POLLIN, -1); + thread_array = master->read; + break; + case THREAD_WRITE: + thread_cancel_rw(master, thread->u.fd, POLLOUT, -1); + thread_array = master->write; + break; + case THREAD_TIMER: + thread_timer_list_del(&master->timer, thread); + break; + case THREAD_EVENT: + list = &master->event; + break; + case THREAD_READY: + list = &master->ready; + break; + default: + continue; + break; + } + + if (list) { + thread_list_del(list, thread); + } else if (thread_array) { + thread_array[thread->u.fd] = NULL; + } + + if (thread->ref) + *thread->ref = NULL; + + thread_add_unuse(thread->master, thread); + } + + /* Delete and free all cancellation requests */ + if (master->cancel_req) + list_delete_all_node(master->cancel_req); + + /* Wake up any threads which may be blocked in thread_cancel_async() */ + master->canceled = true; + pthread_cond_broadcast(&master->cancel_cond); +} + +/* + * Helper function used for multiple flavors of arg-based cancellation. + */ +static void cancel_event_helper(struct thread_master *m, void *arg, int flags) +{ + struct cancel_req *cr; + + assert(m->owner == pthread_self()); + + /* Only worth anything if caller supplies an arg. */ + if (arg == NULL) + return; + + cr = XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); + + cr->flags = flags; + + frr_with_mutex (&m->mtx) { + cr->eventobj = arg; + listnode_add(m->cancel_req, cr); + do_thread_cancel(m); + } +} + +/** + * Cancel any events which have the specified argument. + * + * MT-Unsafe + * + * @param m the thread_master to cancel from + * @param arg the argument passed when creating the event + */ +void thread_cancel_event(struct thread_master *master, void *arg) +{ + cancel_event_helper(master, arg, 0); +} + +/* + * Cancel ready tasks with an arg matching 'arg' + * + * MT-Unsafe + * + * @param m the thread_master to cancel from + * @param arg the argument passed when creating the event + */ +void thread_cancel_event_ready(struct thread_master *m, void *arg) +{ + + /* Only cancel ready/event tasks */ + cancel_event_helper(m, arg, THREAD_CANCEL_FLAG_READY); +} + +/** + * Cancel a specific task. + * + * MT-Unsafe + * + * @param thread task to cancel + */ +void thread_cancel(struct thread **thread) +{ + struct thread_master *master; + + if (thread == NULL || *thread == NULL) + return; + + master = (*thread)->master; + + frrtrace(9, frr_libfrr, thread_cancel, master, + (*thread)->xref->funcname, (*thread)->xref->xref.file, + (*thread)->xref->xref.line, NULL, (*thread)->u.fd, + (*thread)->u.val, (*thread)->arg, (*thread)->u.sands.tv_sec); + + assert(master->owner == pthread_self()); + + frr_with_mutex (&master->mtx) { + struct cancel_req *cr = + XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); + cr->thread = *thread; + listnode_add(master->cancel_req, cr); + do_thread_cancel(master); + } + + *thread = NULL; +} + +/** + * Asynchronous cancellation. + * + * Called with either a struct thread ** or void * to an event argument, + * this function posts the correct cancellation request and blocks until it is + * serviced. + * + * If the thread is currently running, execution blocks until it completes. + * + * The last two parameters are mutually exclusive, i.e. if you pass one the + * other must be NULL. + * + * When the cancellation procedure executes on the target thread_master, the + * thread * provided is checked for nullity. If it is null, the thread is + * assumed to no longer exist and the cancellation request is a no-op. Thus + * users of this API must pass a back-reference when scheduling the original + * task. + * + * MT-Safe + * + * @param master the thread master with the relevant event / task + * @param thread pointer to thread to cancel + * @param eventobj the event + */ +void thread_cancel_async(struct thread_master *master, struct thread **thread, + void *eventobj) +{ + assert(!(thread && eventobj) && (thread || eventobj)); + + if (thread && *thread) + frrtrace(9, frr_libfrr, thread_cancel_async, master, + (*thread)->xref->funcname, (*thread)->xref->xref.file, + (*thread)->xref->xref.line, NULL, (*thread)->u.fd, + (*thread)->u.val, (*thread)->arg, + (*thread)->u.sands.tv_sec); + else + frrtrace(9, frr_libfrr, thread_cancel_async, master, NULL, NULL, + 0, NULL, 0, 0, eventobj, 0); + + assert(master->owner != pthread_self()); + + frr_with_mutex (&master->mtx) { + master->canceled = false; + + if (thread) { + struct cancel_req *cr = + XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); + cr->threadref = thread; + listnode_add(master->cancel_req, cr); + } else if (eventobj) { + struct cancel_req *cr = + XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); + cr->eventobj = eventobj; + listnode_add(master->cancel_req, cr); + } + AWAKEN(master); + + while (!master->canceled) + pthread_cond_wait(&master->cancel_cond, &master->mtx); + } + + if (thread) + *thread = NULL; +} +/* ------------------------------------------------------------------------- */ + +static struct timeval *thread_timer_wait(struct thread_timer_list_head *timers, + struct timeval *timer_val) +{ + if (!thread_timer_list_count(timers)) + return NULL; + + struct thread *next_timer = thread_timer_list_first(timers); + monotime_until(&next_timer->u.sands, timer_val); + return timer_val; +} + +static struct thread *thread_run(struct thread_master *m, struct thread *thread, + struct thread *fetch) +{ + *fetch = *thread; + thread_add_unuse(m, thread); + return fetch; +} + +static int thread_process_io_helper(struct thread_master *m, + struct thread *thread, short state, + short actual_state, int pos) +{ + struct thread **thread_array; + + /* + * poll() clears the .events field, but the pollfd array we + * pass to poll() is a copy of the one used to schedule threads. + * We need to synchronize state between the two here by applying + * the same changes poll() made on the copy of the "real" pollfd + * array. + * + * This cleans up a possible infinite loop where we refuse + * to respond to a poll event but poll is insistent that + * we should. + */ + m->handler.pfds[pos].events &= ~(state); + + if (!thread) { + if ((actual_state & (POLLHUP|POLLIN)) != POLLHUP) + flog_err(EC_LIB_NO_THREAD, + "Attempting to process an I/O event but for fd: %d(%d) no thread to handle this!", + m->handler.pfds[pos].fd, actual_state); + return 0; + } + + if (thread->type == THREAD_READ) + thread_array = m->read; + else + thread_array = m->write; + + thread_array[thread->u.fd] = NULL; + thread_list_add_tail(&m->ready, thread); + thread->type = THREAD_READY; + + return 1; +} + +/** + * Process I/O events. + * + * Walks through file descriptor array looking for those pollfds whose .revents + * field has something interesting. Deletes any invalid file descriptors. + * + * @param m the thread master + * @param num the number of active file descriptors (return value of poll()) + */ +static void thread_process_io(struct thread_master *m, unsigned int num) +{ + unsigned int ready = 0; + struct pollfd *pfds = m->handler.copy; + + for (nfds_t i = 0; i < m->handler.copycount && ready < num; ++i) { + /* no event for current fd? immediately continue */ + if (pfds[i].revents == 0) + continue; + + ready++; + + /* + * Unless someone has called thread_cancel from another + * pthread, the only thing that could have changed in + * m->handler.pfds while we were asleep is the .events + * field in a given pollfd. Barring thread_cancel() that + * value should be a superset of the values we have in our + * copy, so there's no need to update it. Similarily, + * barring deletion, the fd should still be a valid index + * into the master's pfds. + * + * We are including POLLERR here to do a READ event + * this is because the read should fail and the + * read function should handle it appropriately + */ + if (pfds[i].revents & (POLLIN | POLLHUP | POLLERR)) { + thread_process_io_helper(m, m->read[pfds[i].fd], POLLIN, + pfds[i].revents, i); + } + if (pfds[i].revents & POLLOUT) + thread_process_io_helper(m, m->write[pfds[i].fd], + POLLOUT, pfds[i].revents, i); + + /* if one of our file descriptors is garbage, remove the same + * from + * both pfds + update sizes and index */ + if (pfds[i].revents & POLLNVAL) { + memmove(m->handler.pfds + i, m->handler.pfds + i + 1, + (m->handler.pfdcount - i - 1) + * sizeof(struct pollfd)); + m->handler.pfdcount--; + m->handler.pfds[m->handler.pfdcount].fd = 0; + m->handler.pfds[m->handler.pfdcount].events = 0; + + memmove(pfds + i, pfds + i + 1, + (m->handler.copycount - i - 1) + * sizeof(struct pollfd)); + m->handler.copycount--; + m->handler.copy[m->handler.copycount].fd = 0; + m->handler.copy[m->handler.copycount].events = 0; + + i--; + } + } +} + +/* Add all timers that have popped to the ready list. */ +static unsigned int thread_process_timers(struct thread_master *m, + struct timeval *timenow) +{ + struct timeval prev = *timenow; + bool displayed = false; + struct thread *thread; + unsigned int ready = 0; + + while ((thread = thread_timer_list_first(&m->timer))) { + if (timercmp(timenow, &thread->u.sands, <)) + break; + prev = thread->u.sands; + prev.tv_sec += 4; + /* + * If the timer would have popped 4 seconds in the + * past then we are in a situation where we are + * really getting behind on handling of events. + * Let's log it and do the right thing with it. + */ + if (timercmp(timenow, &prev, >)) { + atomic_fetch_add_explicit( + &thread->hist->total_starv_warn, 1, + memory_order_seq_cst); + if (!displayed && !thread->ignore_timer_late) { + flog_warn( + EC_LIB_STARVE_THREAD, + "Thread Starvation: %pTHD was scheduled to pop greater than 4s ago", + thread); + displayed = true; + } + } + + thread_timer_list_pop(&m->timer); + thread->type = THREAD_READY; + thread_list_add_tail(&m->ready, thread); + ready++; + } + + return ready; +} + +/* process a list en masse, e.g. for event thread lists */ +static unsigned int thread_process(struct thread_list_head *list) +{ + struct thread *thread; + unsigned int ready = 0; + + while ((thread = thread_list_pop(list))) { + thread->type = THREAD_READY; + thread_list_add_tail(&thread->master->ready, thread); + ready++; + } + return ready; +} + + +/* Fetch next ready thread. */ +struct thread *thread_fetch(struct thread_master *m, struct thread *fetch) +{ + struct thread *thread = NULL; + struct timeval now; + struct timeval zerotime = {0, 0}; + struct timeval tv; + struct timeval *tw = NULL; + bool eintr_p = false; + int num = 0; + + do { + /* Handle signals if any */ + if (m->handle_signals) + frr_sigevent_process(); + + pthread_mutex_lock(&m->mtx); + + /* Process any pending cancellation requests */ + do_thread_cancel(m); + + /* + * Attempt to flush ready queue before going into poll(). + * This is performance-critical. Think twice before modifying. + */ + if ((thread = thread_list_pop(&m->ready))) { + fetch = thread_run(m, thread, fetch); + if (fetch->ref) + *fetch->ref = NULL; + pthread_mutex_unlock(&m->mtx); + if (!m->ready_run_loop) + GETRUSAGE(&m->last_getrusage); + m->ready_run_loop = true; + break; + } + + m->ready_run_loop = false; + /* otherwise, tick through scheduling sequence */ + + /* + * Post events to ready queue. This must come before the + * following block since events should occur immediately + */ + thread_process(&m->event); + + /* + * If there are no tasks on the ready queue, we will poll() + * until a timer expires or we receive I/O, whichever comes + * first. The strategy for doing this is: + * + * - If there are events pending, set the poll() timeout to zero + * - If there are no events pending, but there are timers + * pending, set the timeout to the smallest remaining time on + * any timer. + * - If there are neither timers nor events pending, but there + * are file descriptors pending, block indefinitely in poll() + * - If nothing is pending, it's time for the application to die + * + * In every case except the last, we need to hit poll() at least + * once per loop to avoid starvation by events + */ + if (!thread_list_count(&m->ready)) + tw = thread_timer_wait(&m->timer, &tv); + + if (thread_list_count(&m->ready) || + (tw && !timercmp(tw, &zerotime, >))) + tw = &zerotime; + + if (!tw && m->handler.pfdcount == 0) { /* die */ + pthread_mutex_unlock(&m->mtx); + fetch = NULL; + break; + } + + /* + * Copy pollfd array + # active pollfds in it. Not necessary to + * copy the array size as this is fixed. + */ + m->handler.copycount = m->handler.pfdcount; + memcpy(m->handler.copy, m->handler.pfds, + m->handler.copycount * sizeof(struct pollfd)); + + pthread_mutex_unlock(&m->mtx); + { + eintr_p = false; + num = fd_poll(m, tw, &eintr_p); + } + pthread_mutex_lock(&m->mtx); + + /* Handle any errors received in poll() */ + if (num < 0) { + if (eintr_p) { + pthread_mutex_unlock(&m->mtx); + /* loop around to signal handler */ + continue; + } + + /* else die */ + flog_err(EC_LIB_SYSTEM_CALL, "poll() error: %s", + safe_strerror(errno)); + pthread_mutex_unlock(&m->mtx); + fetch = NULL; + break; + } + + /* Post timers to ready queue. */ + monotime(&now); + thread_process_timers(m, &now); + + /* Post I/O to ready queue. */ + if (num > 0) + thread_process_io(m, num); + + pthread_mutex_unlock(&m->mtx); + + } while (!thread && m->spin); + + return fetch; +} + +static unsigned long timeval_elapsed(struct timeval a, struct timeval b) +{ + return (((a.tv_sec - b.tv_sec) * TIMER_SECOND_MICRO) + + (a.tv_usec - b.tv_usec)); +} + +unsigned long thread_consumed_time(RUSAGE_T *now, RUSAGE_T *start, + unsigned long *cputime) +{ +#ifdef HAVE_CLOCK_THREAD_CPUTIME_ID + +#ifdef __FreeBSD__ + /* + * FreeBSD appears to have an issue when calling clock_gettime + * with CLOCK_THREAD_CPUTIME_ID really close to each other + * occassionally the now time will be before the start time. + * This is not good and FRR is ending up with CPU HOG's + * when the subtraction wraps to very large numbers + * + * What we are going to do here is cheat a little bit + * and notice that this is a problem and just correct + * it so that it is impossible to happen + */ + if (start->cpu.tv_sec == now->cpu.tv_sec && + start->cpu.tv_nsec > now->cpu.tv_nsec) + now->cpu.tv_nsec = start->cpu.tv_nsec + 1; + else if (start->cpu.tv_sec > now->cpu.tv_sec) { + now->cpu.tv_sec = start->cpu.tv_sec; + now->cpu.tv_nsec = start->cpu.tv_nsec + 1; + } +#endif + *cputime = (now->cpu.tv_sec - start->cpu.tv_sec) * TIMER_SECOND_MICRO + + (now->cpu.tv_nsec - start->cpu.tv_nsec) / 1000; +#else + /* This is 'user + sys' time. */ + *cputime = timeval_elapsed(now->cpu.ru_utime, start->cpu.ru_utime) + + timeval_elapsed(now->cpu.ru_stime, start->cpu.ru_stime); +#endif + return timeval_elapsed(now->real, start->real); +} + +/* We should aim to yield after yield milliseconds, which defaults + to THREAD_YIELD_TIME_SLOT . + Note: we are using real (wall clock) time for this calculation. + It could be argued that CPU time may make more sense in certain + contexts. The things to consider are whether the thread may have + blocked (in which case wall time increases, but CPU time does not), + or whether the system is heavily loaded with other processes competing + for CPU time. On balance, wall clock time seems to make sense. + Plus it has the added benefit that gettimeofday should be faster + than calling getrusage. */ +int thread_should_yield(struct thread *thread) +{ + int result; + frr_with_mutex (&thread->mtx) { + result = monotime_since(&thread->real, NULL) + > (int64_t)thread->yield; + } + return result; +} + +void thread_set_yield_time(struct thread *thread, unsigned long yield_time) +{ + frr_with_mutex (&thread->mtx) { + thread->yield = yield_time; + } +} + +void thread_getrusage(RUSAGE_T *r) +{ + monotime(&r->real); + if (!cputime_enabled) { + memset(&r->cpu, 0, sizeof(r->cpu)); + return; + } + +#ifdef HAVE_CLOCK_THREAD_CPUTIME_ID + /* not currently implemented in Linux's vDSO, but maybe at some point + * in the future? + */ + clock_gettime(CLOCK_THREAD_CPUTIME_ID, &r->cpu); +#else /* !HAVE_CLOCK_THREAD_CPUTIME_ID */ +#if defined RUSAGE_THREAD +#define FRR_RUSAGE RUSAGE_THREAD +#else +#define FRR_RUSAGE RUSAGE_SELF +#endif + getrusage(FRR_RUSAGE, &(r->cpu)); +#endif +} + +/* + * Call a thread. + * + * This function will atomically update the thread's usage history. At present + * this is the only spot where usage history is written. Nevertheless the code + * has been written such that the introduction of writers in the future should + * not need to update it provided the writers atomically perform only the + * operations done here, i.e. updating the total and maximum times. In + * particular, the maximum real and cpu times must be monotonically increasing + * or this code is not correct. + */ +void thread_call(struct thread *thread) +{ + RUSAGE_T before, after; + + /* if the thread being called is the CLI, it may change cputime_enabled + * ("service cputime-stats" command), which can result in nonsensical + * and very confusing warnings + */ + bool cputime_enabled_here = cputime_enabled; + + if (thread->master->ready_run_loop) + before = thread->master->last_getrusage; + else + GETRUSAGE(&before); + + thread->real = before.real; + + frrtrace(9, frr_libfrr, thread_call, thread->master, + thread->xref->funcname, thread->xref->xref.file, + thread->xref->xref.line, NULL, thread->u.fd, + thread->u.val, thread->arg, thread->u.sands.tv_sec); + + pthread_setspecific(thread_current, thread); + (*thread->func)(thread); + pthread_setspecific(thread_current, NULL); + + GETRUSAGE(&after); + thread->master->last_getrusage = after; + + unsigned long walltime, cputime; + unsigned long exp; + + walltime = thread_consumed_time(&after, &before, &cputime); + + /* update walltime */ + atomic_fetch_add_explicit(&thread->hist->real.total, walltime, + memory_order_seq_cst); + exp = atomic_load_explicit(&thread->hist->real.max, + memory_order_seq_cst); + while (exp < walltime + && !atomic_compare_exchange_weak_explicit( + &thread->hist->real.max, &exp, walltime, + memory_order_seq_cst, memory_order_seq_cst)) + ; + + if (cputime_enabled_here && cputime_enabled) { + /* update cputime */ + atomic_fetch_add_explicit(&thread->hist->cpu.total, cputime, + memory_order_seq_cst); + exp = atomic_load_explicit(&thread->hist->cpu.max, + memory_order_seq_cst); + while (exp < cputime + && !atomic_compare_exchange_weak_explicit( + &thread->hist->cpu.max, &exp, cputime, + memory_order_seq_cst, memory_order_seq_cst)) + ; + } + + atomic_fetch_add_explicit(&thread->hist->total_calls, 1, + memory_order_seq_cst); + atomic_fetch_or_explicit(&thread->hist->types, 1 << thread->add_type, + memory_order_seq_cst); + + if (cputime_enabled_here && cputime_enabled && cputime_threshold + && cputime > cputime_threshold) { + /* + * We have a CPU Hog on our hands. The time FRR has spent + * doing actual work (not sleeping) is greater than 5 seconds. + * Whinge about it now, so we're aware this is yet another task + * to fix. + */ + atomic_fetch_add_explicit(&thread->hist->total_cpu_warn, + 1, memory_order_seq_cst); + flog_warn( + EC_LIB_SLOW_THREAD_CPU, + "CPU HOG: task %s (%lx) ran for %lums (cpu time %lums)", + thread->xref->funcname, (unsigned long)thread->func, + walltime / 1000, cputime / 1000); + + } else if (walltime_threshold && walltime > walltime_threshold) { + /* + * The runtime for a task is greater than 5 seconds, but the + * cpu time is under 5 seconds. Let's whine about this because + * this could imply some sort of scheduling issue. + */ + atomic_fetch_add_explicit(&thread->hist->total_wall_warn, + 1, memory_order_seq_cst); + flog_warn( + EC_LIB_SLOW_THREAD_WALL, + "STARVATION: task %s (%lx) ran for %lums (cpu time %lums)", + thread->xref->funcname, (unsigned long)thread->func, + walltime / 1000, cputime / 1000); + } +} + +/* Execute thread */ +void _thread_execute(const struct xref_threadsched *xref, + struct thread_master *m, void (*func)(struct thread *), + void *arg, int val) +{ + struct thread *thread; + + /* Get or allocate new thread to execute. */ + frr_with_mutex (&m->mtx) { + thread = thread_get(m, THREAD_EVENT, func, arg, xref); + + /* Set its event value. */ + frr_with_mutex (&thread->mtx) { + thread->add_type = THREAD_EXECUTE; + thread->u.val = val; + thread->ref = &thread; + } + } + + /* Execute thread doing all accounting. */ + thread_call(thread); + + /* Give back or free thread. */ + thread_add_unuse(m, thread); +} + +/* Debug signal mask - if 'sigs' is NULL, use current effective mask. */ +void debug_signals(const sigset_t *sigs) +{ + int i, found; + sigset_t tmpsigs; + char buf[300]; + + /* + * We're only looking at the non-realtime signals here, so we need + * some limit value. Platform differences mean at some point we just + * need to pick a reasonable value. + */ +#if defined SIGRTMIN +# define LAST_SIGNAL SIGRTMIN +#else +# define LAST_SIGNAL 32 +#endif + + + if (sigs == NULL) { + sigemptyset(&tmpsigs); + pthread_sigmask(SIG_BLOCK, NULL, &tmpsigs); + sigs = &tmpsigs; + } + + found = 0; + buf[0] = '\0'; + + for (i = 0; i < LAST_SIGNAL; i++) { + char tmp[20]; + + if (sigismember(sigs, i) > 0) { + if (found > 0) + strlcat(buf, ",", sizeof(buf)); + snprintf(tmp, sizeof(tmp), "%d", i); + strlcat(buf, tmp, sizeof(buf)); + found++; + } + } + + if (found == 0) + snprintf(buf, sizeof(buf), ""); + + zlog_debug("%s: %s", __func__, buf); +} + +static ssize_t printfrr_thread_dbg(struct fbuf *buf, struct printfrr_eargs *ea, + const struct thread *thread) +{ + static const char * const types[] = { + [THREAD_READ] = "read", + [THREAD_WRITE] = "write", + [THREAD_TIMER] = "timer", + [THREAD_EVENT] = "event", + [THREAD_READY] = "ready", + [THREAD_UNUSED] = "unused", + [THREAD_EXECUTE] = "exec", + }; + ssize_t rv = 0; + char info[16] = ""; + + if (!thread) + return bputs(buf, "{(thread *)NULL}"); + + rv += bprintfrr(buf, "{(thread *)%p arg=%p", thread, thread->arg); + + if (thread->type < array_size(types) && types[thread->type]) + rv += bprintfrr(buf, " %-6s", types[thread->type]); + else + rv += bprintfrr(buf, " INVALID(%u)", thread->type); + + switch (thread->type) { + case THREAD_READ: + case THREAD_WRITE: + snprintfrr(info, sizeof(info), "fd=%d", thread->u.fd); + break; + + case THREAD_TIMER: + snprintfrr(info, sizeof(info), "r=%pTVMud", &thread->u.sands); + break; + } + + rv += bprintfrr(buf, " %-12s %s() %s from %s:%d}", info, + thread->xref->funcname, thread->xref->dest, + thread->xref->xref.file, thread->xref->xref.line); + return rv; +} + +printfrr_ext_autoreg_p("TH", printfrr_thread); +static ssize_t printfrr_thread(struct fbuf *buf, struct printfrr_eargs *ea, + const void *ptr) +{ + const struct thread *thread = ptr; + struct timespec remain = {}; + + if (ea->fmt[0] == 'D') { + ea->fmt++; + return printfrr_thread_dbg(buf, ea, thread); + } + + if (!thread) { + /* need to jump over time formatting flag characters in the + * input format string, i.e. adjust ea->fmt! + */ + printfrr_time(buf, ea, &remain, + TIMEFMT_TIMER_DEADLINE | TIMEFMT_SKIP); + return bputch(buf, '-'); + } + + TIMEVAL_TO_TIMESPEC(&thread->u.sands, &remain); + return printfrr_time(buf, ea, &remain, TIMEFMT_TIMER_DEADLINE); +} diff --git a/lib/event.h b/lib/event.h new file mode 100644 index 0000000000..128d11b6eb --- /dev/null +++ b/lib/event.h @@ -0,0 +1,291 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* Thread management routine header. + * Copyright (C) 1998 Kunihiro Ishiguro + */ + +#ifndef _ZEBRA_THREAD_H +#define _ZEBRA_THREAD_H + +#include +#include +#include +#include "monotime.h" +#include "frratomic.h" +#include "typesafe.h" +#include "xref.h" + +#ifdef __cplusplus +extern "C" { +#endif + +extern bool cputime_enabled; +extern unsigned long cputime_threshold; +/* capturing wallclock time is always enabled since it is fast (reading + * hardware TSC w/o syscalls) + */ +extern unsigned long walltime_threshold; + +struct rusage_t { +#ifdef HAVE_CLOCK_THREAD_CPUTIME_ID + struct timespec cpu; +#else + struct rusage cpu; +#endif + struct timeval real; +}; +#define RUSAGE_T struct rusage_t + +#define GETRUSAGE(X) thread_getrusage(X) + +PREDECL_LIST(thread_list); +PREDECL_HEAP(thread_timer_list); + +struct fd_handler { + /* number of pfd that fit in the allocated space of pfds. This is a + * constant and is the same for both pfds and copy. + */ + nfds_t pfdsize; + + /* file descriptors to monitor for i/o */ + struct pollfd *pfds; + /* number of pollfds stored in pfds */ + nfds_t pfdcount; + + /* chunk used for temp copy of pollfds */ + struct pollfd *copy; + /* number of pollfds stored in copy */ + nfds_t copycount; +}; + +struct xref_threadsched { + struct xref xref; + + const char *funcname; + const char *dest; + uint32_t thread_type; +}; + +/* Master of the theads. */ +struct thread_master { + char *name; + + struct thread **read; + struct thread **write; + struct thread_timer_list_head timer; + struct thread_list_head event, ready, unuse; + struct list *cancel_req; + bool canceled; + pthread_cond_t cancel_cond; + struct hash *cpu_record; + int io_pipe[2]; + int fd_limit; + struct fd_handler handler; + unsigned long alloc; + long selectpoll_timeout; + bool spin; + bool handle_signals; + pthread_mutex_t mtx; + pthread_t owner; + + bool ready_run_loop; + RUSAGE_T last_getrusage; +}; + +/* Thread itself. */ +struct thread { + uint8_t type; /* thread type */ + uint8_t add_type; /* thread type */ + struct thread_list_item threaditem; + struct thread_timer_list_item timeritem; + struct thread **ref; /* external reference (if given) */ + struct thread_master *master; /* pointer to the struct thread_master */ + void (*func)(struct thread *); /* event function */ + void *arg; /* event argument */ + union { + int val; /* second argument of the event. */ + int fd; /* file descriptor in case of r/w */ + struct timeval sands; /* rest of time sands value. */ + } u; + struct timeval real; + struct cpu_thread_history *hist; /* cache pointer to cpu_history */ + unsigned long yield; /* yield time in microseconds */ + const struct xref_threadsched *xref; /* origin location */ + pthread_mutex_t mtx; /* mutex for thread.c functions */ + bool ignore_timer_late; +}; + +#ifdef _FRR_ATTRIBUTE_PRINTFRR +#pragma FRR printfrr_ext "%pTH" (struct thread *) +#endif + +struct cpu_thread_history { + void (*func)(struct thread *); + atomic_size_t total_cpu_warn; + atomic_size_t total_wall_warn; + atomic_size_t total_starv_warn; + atomic_size_t total_calls; + atomic_size_t total_active; + struct time_stats { + atomic_size_t total, max; + } real; + struct time_stats cpu; + atomic_uint_fast32_t types; + const char *funcname; +}; + +/* Struct timeval's tv_usec one second value. */ +#define TIMER_SECOND_MICRO 1000000L + +/* Thread types. */ +#define THREAD_READ 0 +#define THREAD_WRITE 1 +#define THREAD_TIMER 2 +#define THREAD_EVENT 3 +#define THREAD_READY 4 +#define THREAD_UNUSED 5 +#define THREAD_EXECUTE 6 + +/* Thread yield time. */ +#define THREAD_YIELD_TIME_SLOT 10 * 1000L /* 10ms */ + +#define THREAD_TIMER_STRLEN 12 + +/* Macros. */ +#define THREAD_ARG(X) ((X)->arg) +#define THREAD_FD(X) ((X)->u.fd) +#define THREAD_VAL(X) ((X)->u.val) + +/* + * Please consider this macro deprecated, and do not use it in new code. + */ +#define THREAD_OFF(thread) \ + do { \ + if ((thread)) \ + thread_cancel(&(thread)); \ + } while (0) + +/* + * Macro wrappers to generate xrefs for all thread add calls. Includes + * file/line/function info for debugging/tracing. + */ +#include "lib/xref.h" + +#define _xref_t_a(addfn, type, m, f, a, v, t) \ + ({ \ + static const struct xref_threadsched _xref \ + __attribute__((used)) = { \ + .xref = XREF_INIT(XREFT_THREADSCHED, NULL, __func__), \ + .funcname = #f, \ + .dest = #t, \ + .thread_type = THREAD_ ## type, \ + }; \ + XREF_LINK(_xref.xref); \ + _thread_add_ ## addfn(&_xref, m, f, a, v, t); \ + }) \ + /* end */ + +#define thread_add_read(m,f,a,v,t) _xref_t_a(read_write, READ, m,f,a,v,t) +#define thread_add_write(m,f,a,v,t) _xref_t_a(read_write, WRITE, m,f,a,v,t) +#define thread_add_timer(m,f,a,v,t) _xref_t_a(timer, TIMER, m,f,a,v,t) +#define thread_add_timer_msec(m,f,a,v,t) _xref_t_a(timer_msec, TIMER, m,f,a,v,t) +#define thread_add_timer_tv(m,f,a,v,t) _xref_t_a(timer_tv, TIMER, m,f,a,v,t) +#define thread_add_event(m,f,a,v,t) _xref_t_a(event, EVENT, m,f,a,v,t) + +#define thread_execute(m,f,a,v) \ + ({ \ + static const struct xref_threadsched _xref \ + __attribute__((used)) = { \ + .xref = XREF_INIT(XREFT_THREADSCHED, NULL, __func__), \ + .funcname = #f, \ + .dest = NULL, \ + .thread_type = THREAD_EXECUTE, \ + }; \ + XREF_LINK(_xref.xref); \ + _thread_execute(&_xref, m, f, a, v); \ + }) /* end */ + +/* Prototypes. */ +extern struct thread_master *thread_master_create(const char *); +void thread_master_set_name(struct thread_master *master, const char *name); +extern void thread_master_free(struct thread_master *); +extern void thread_master_free_unused(struct thread_master *); + +extern void _thread_add_read_write(const struct xref_threadsched *xref, + struct thread_master *master, + void (*fn)(struct thread *), void *arg, + int fd, struct thread **tref); + +extern void _thread_add_timer(const struct xref_threadsched *xref, + struct thread_master *master, + void (*fn)(struct thread *), void *arg, long t, + struct thread **tref); + +extern void _thread_add_timer_msec(const struct xref_threadsched *xref, + struct thread_master *master, + void (*fn)(struct thread *), void *arg, + long t, struct thread **tref); + +extern void _thread_add_timer_tv(const struct xref_threadsched *xref, + struct thread_master *master, + void (*fn)(struct thread *), void *arg, + struct timeval *tv, struct thread **tref); + +extern void _thread_add_event(const struct xref_threadsched *xref, + struct thread_master *master, + void (*fn)(struct thread *), void *arg, int val, + struct thread **tref); + +extern void _thread_execute(const struct xref_threadsched *xref, + struct thread_master *master, + void (*fn)(struct thread *), void *arg, int val); + +extern void thread_cancel(struct thread **event); +extern void thread_cancel_async(struct thread_master *, struct thread **, + void *); +/* Cancel ready tasks with an arg matching 'arg' */ +extern void thread_cancel_event_ready(struct thread_master *m, void *arg); +/* Cancel all tasks with an arg matching 'arg', including timers and io */ +extern void thread_cancel_event(struct thread_master *m, void *arg); +extern struct thread *thread_fetch(struct thread_master *, struct thread *); +extern void thread_call(struct thread *); +extern unsigned long thread_timer_remain_second(struct thread *); +extern struct timeval thread_timer_remain(struct thread *); +extern unsigned long thread_timer_remain_msec(struct thread *); +extern int thread_should_yield(struct thread *); +/* set yield time for thread */ +extern void thread_set_yield_time(struct thread *, unsigned long); + +/* Internal libfrr exports */ +extern void thread_getrusage(RUSAGE_T *); +extern void thread_cmd_init(void); + +/* Returns elapsed real (wall clock) time. */ +extern unsigned long thread_consumed_time(RUSAGE_T *after, RUSAGE_T *before, + unsigned long *cpu_time_elapsed); + +/* only for use in logging functions! */ +extern pthread_key_t thread_current; +extern char *thread_timer_to_hhmmss(char *buf, int buf_size, + struct thread *t_timer); + +static inline bool thread_is_scheduled(struct thread *thread) +{ + if (thread) + return true; + + return false; +} + +/* Debug signal mask */ +void debug_signals(const sigset_t *sigs); + +static inline void thread_ignore_late_timer(struct thread *thread) +{ + thread->ignore_timer_late = true; +} + +#ifdef __cplusplus +} +#endif + +#endif /* _ZEBRA_THREAD_H */ diff --git a/lib/frr_pthread.h b/lib/frr_pthread.h index b1d08717fb..c14ba77922 100644 --- a/lib/frr_pthread.h +++ b/lib/frr_pthread.h @@ -11,7 +11,7 @@ #include "frratomic.h" #include "memory.h" #include "frrcu.h" -#include "thread.h" +#include "event.h" #ifdef __cplusplus extern "C" { diff --git a/lib/frr_zmq.c b/lib/frr_zmq.c index 2673d57605..525e49942c 100644 --- a/lib/frr_zmq.c +++ b/lib/frr_zmq.c @@ -15,7 +15,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "frr_zmq.h" #include "log.h" diff --git a/lib/frr_zmq.h b/lib/frr_zmq.h index f12291d602..bfc1e93b16 100644 --- a/lib/frr_zmq.h +++ b/lib/frr_zmq.h @@ -7,7 +7,7 @@ #ifndef _FRRZMQ_H #define _FRRZMQ_H -#include "thread.h" +#include "event.h" #include #ifdef __cplusplus diff --git a/lib/ldp_sync.c b/lib/ldp_sync.c index b01cf87287..3ecbfcabf9 100644 --- a/lib/ldp_sync.c +++ b/lib/ldp_sync.c @@ -10,7 +10,7 @@ #include "memory.h" #include "prefix.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "stream.h" #include "zclient.h" #include "table.h" diff --git a/lib/libfrr.h b/lib/libfrr.h index 97e9b93c10..3657346507 100644 --- a/lib/libfrr.h +++ b/lib/libfrr.h @@ -11,7 +11,7 @@ #include "typesafe.h" #include "sigevent.h" #include "privs.h" -#include "thread.h" +#include "event.h" #include "log.h" #include "getopt.h" #include "module.h" diff --git a/lib/libfrr_trace.h b/lib/libfrr_trace.h index 92c469706a..d13cdc20b1 100644 --- a/lib/libfrr_trace.h +++ b/lib/libfrr_trace.h @@ -21,7 +21,7 @@ #include #include "hash.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "table.h" diff --git a/lib/mgmt_fe_client.h b/lib/mgmt_fe_client.h index ac29b8f27c..10712964bd 100644 --- a/lib/mgmt_fe_client.h +++ b/lib/mgmt_fe_client.h @@ -13,7 +13,7 @@ extern "C" { #endif #include "mgmt_pb.h" -#include "thread.h" +#include "event.h" #include "mgmtd/mgmt_defines.h" /*************************************************************** diff --git a/lib/mgmt_msg.c b/lib/mgmt_msg.c index 2fab03bc54..e7564f2688 100644 --- a/lib/mgmt_msg.c +++ b/lib/mgmt_msg.c @@ -10,7 +10,7 @@ #include "network.h" #include "sockopt.h" #include "stream.h" -#include "thread.h" +#include "event.h" #include "mgmt_msg.h" diff --git a/lib/mgmt_msg.h b/lib/mgmt_msg.h index 854875170b..90dab8da76 100644 --- a/lib/mgmt_msg.h +++ b/lib/mgmt_msg.h @@ -8,7 +8,7 @@ #define _MGMT_MSG_H #include "stream.h" -#include "thread.h" +#include "event.h" #define MGMT_MSG_MARKER (0x4D724B21u) /* ASCII - "MrK!"*/ diff --git a/lib/northbound.h b/lib/northbound.h index 4b5028c87e..6820a59cc6 100644 --- a/lib/northbound.h +++ b/lib/northbound.h @@ -7,7 +7,7 @@ #ifndef _FRR_NORTHBOUND_H_ #define _FRR_NORTHBOUND_H_ -#include "thread.h" +#include "event.h" #include "hook.h" #include "linklist.h" #include "openbsd-tree.h" diff --git a/lib/northbound_grpc.cpp b/lib/northbound_grpc.cpp index 274a0ca45a..d68e22368c 100644 --- a/lib/northbound_grpc.cpp +++ b/lib/northbound_grpc.cpp @@ -12,7 +12,7 @@ #include "log.h" #include "libfrr.h" #include "lib/version.h" -#include "lib/thread.h" +#include "event.h" #include "command.h" #include "lib_errors.h" #include "northbound.h" diff --git a/lib/pullwr.h b/lib/pullwr.h index 77ecf855b4..8a028b9096 100644 --- a/lib/pullwr.h +++ b/lib/pullwr.h @@ -10,7 +10,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "stream.h" #ifdef __cplusplus diff --git a/lib/qobj.c b/lib/qobj.c index 09b156ba39..6ebdcbf9cb 100644 --- a/lib/qobj.c +++ b/lib/qobj.c @@ -7,7 +7,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "hash.h" #include "log.h" diff --git a/lib/resolver.c b/lib/resolver.c index 2918576c03..ffc84e5fe8 100644 --- a/lib/resolver.c +++ b/lib/resolver.c @@ -12,7 +12,7 @@ #include "typesafe.h" #include "jhash.h" -#include "thread.h" +#include "event.h" #include "lib_errors.h" #include "resolver.h" #include "command.h" diff --git a/lib/resolver.h b/lib/resolver.h index d3f38f742d..764e3e72ae 100644 --- a/lib/resolver.h +++ b/lib/resolver.h @@ -6,7 +6,7 @@ #ifndef _FRR_RESOLVER_H #define _FRR_RESOLVER_H -#include "thread.h" +#include "event.h" #include "sockunion.h" #ifdef __cplusplus diff --git a/lib/sigevent.h b/lib/sigevent.h index e58b9a70c0..69b3f54aa7 100644 --- a/lib/sigevent.h +++ b/lib/sigevent.h @@ -8,7 +8,7 @@ #ifndef _FRR_SIGNAL_H #define _FRR_SIGNAL_H -#include +#include #ifdef __cplusplus extern "C" { diff --git a/lib/smux.h b/lib/smux.h index 28a303cf72..dd1689f731 100644 --- a/lib/smux.h +++ b/lib/smux.h @@ -9,7 +9,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "hook.h" #ifdef __cplusplus diff --git a/lib/spf_backoff.c b/lib/spf_backoff.c index 1e80b5ec2d..36b059a990 100644 --- a/lib/spf_backoff.c +++ b/lib/spf_backoff.c @@ -17,7 +17,7 @@ #include "command.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "vty.h" DEFINE_MTYPE_STATIC(LIB, SPF_BACKOFF, "SPF backoff"); diff --git a/lib/subdir.am b/lib/subdir.am index d456629bbd..9f2f4033fc 100644 --- a/lib/subdir.am +++ b/lib/subdir.am @@ -108,7 +108,7 @@ lib_libfrr_la_SOURCES = \ lib/systemd.c \ lib/table.c \ lib/termtable.c \ - lib/thread.c \ + lib/event.c \ lib/typerb.c \ lib/typesafe.c \ lib/vector.c \ @@ -181,7 +181,7 @@ clippy_scan += \ lib/plist.c \ lib/routemap.c \ lib/routemap_cli.c \ - lib/thread.c \ + lib/event.c \ lib/vty.c \ lib/zlog_5424_cli.c \ # end @@ -288,7 +288,7 @@ pkginclude_HEADERS += \ lib/systemd.h \ lib/table.h \ lib/termtable.h \ - lib/thread.h \ + lib/event.h \ lib/trace.h \ lib/typerb.h \ lib/typesafe.h \ diff --git a/lib/systemd.c b/lib/systemd.c index 0106e88b93..458bea5144 100644 --- a/lib/systemd.c +++ b/lib/systemd.c @@ -7,7 +7,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "systemd.h" #include "lib_errors.h" diff --git a/lib/thread.c b/lib/thread.c deleted file mode 100644 index 87ad3d8823..0000000000 --- a/lib/thread.c +++ /dev/null @@ -1,2198 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* Thread management routine - * Copyright (C) 1998, 2000 Kunihiro Ishiguro - */ - -/* #define DEBUG */ - -#include -#include - -#include "thread.h" -#include "memory.h" -#include "frrcu.h" -#include "log.h" -#include "hash.h" -#include "command.h" -#include "sigevent.h" -#include "network.h" -#include "jhash.h" -#include "frratomic.h" -#include "frr_pthread.h" -#include "lib_errors.h" -#include "libfrr_trace.h" -#include "libfrr.h" - -DEFINE_MTYPE_STATIC(LIB, THREAD, "Thread"); -DEFINE_MTYPE_STATIC(LIB, THREAD_MASTER, "Thread master"); -DEFINE_MTYPE_STATIC(LIB, THREAD_POLL, "Thread Poll Info"); -DEFINE_MTYPE_STATIC(LIB, THREAD_STATS, "Thread stats"); - -DECLARE_LIST(thread_list, struct thread, threaditem); - -struct cancel_req { - int flags; - struct thread *thread; - void *eventobj; - struct thread **threadref; -}; - -/* Flags for task cancellation */ -#define THREAD_CANCEL_FLAG_READY 0x01 - -static int thread_timer_cmp(const struct thread *a, const struct thread *b) -{ - if (a->u.sands.tv_sec < b->u.sands.tv_sec) - return -1; - if (a->u.sands.tv_sec > b->u.sands.tv_sec) - return 1; - if (a->u.sands.tv_usec < b->u.sands.tv_usec) - return -1; - if (a->u.sands.tv_usec > b->u.sands.tv_usec) - return 1; - return 0; -} - -DECLARE_HEAP(thread_timer_list, struct thread, timeritem, thread_timer_cmp); - -#if defined(__APPLE__) -#include -#include -#endif - -#define AWAKEN(m) \ - do { \ - const unsigned char wakebyte = 0x01; \ - write(m->io_pipe[1], &wakebyte, 1); \ - } while (0); - -/* control variable for initializer */ -static pthread_once_t init_once = PTHREAD_ONCE_INIT; -pthread_key_t thread_current; - -static pthread_mutex_t masters_mtx = PTHREAD_MUTEX_INITIALIZER; -static struct list *masters; - -static void thread_free(struct thread_master *master, struct thread *thread); - -#ifndef EXCLUDE_CPU_TIME -#define EXCLUDE_CPU_TIME 0 -#endif -#ifndef CONSUMED_TIME_CHECK -#define CONSUMED_TIME_CHECK 0 -#endif - -bool cputime_enabled = !EXCLUDE_CPU_TIME; -unsigned long cputime_threshold = CONSUMED_TIME_CHECK; -unsigned long walltime_threshold = CONSUMED_TIME_CHECK; - -/* CLI start ---------------------------------------------------------------- */ -#include "lib/thread_clippy.c" - -static unsigned int cpu_record_hash_key(const struct cpu_thread_history *a) -{ - int size = sizeof(a->func); - - return jhash(&a->func, size, 0); -} - -static bool cpu_record_hash_cmp(const struct cpu_thread_history *a, - const struct cpu_thread_history *b) -{ - return a->func == b->func; -} - -static void *cpu_record_hash_alloc(struct cpu_thread_history *a) -{ - struct cpu_thread_history *new; - new = XCALLOC(MTYPE_THREAD_STATS, sizeof(struct cpu_thread_history)); - new->func = a->func; - new->funcname = a->funcname; - return new; -} - -static void cpu_record_hash_free(void *a) -{ - struct cpu_thread_history *hist = a; - - XFREE(MTYPE_THREAD_STATS, hist); -} - -static void vty_out_cpu_thread_history(struct vty *vty, - struct cpu_thread_history *a) -{ - vty_out(vty, - "%5zu %10zu.%03zu %9zu %8zu %9zu %8zu %9zu %9zu %9zu %10zu", - a->total_active, a->cpu.total / 1000, a->cpu.total % 1000, - a->total_calls, (a->cpu.total / a->total_calls), a->cpu.max, - (a->real.total / a->total_calls), a->real.max, - a->total_cpu_warn, a->total_wall_warn, a->total_starv_warn); - vty_out(vty, " %c%c%c%c%c %s\n", - a->types & (1 << THREAD_READ) ? 'R' : ' ', - a->types & (1 << THREAD_WRITE) ? 'W' : ' ', - a->types & (1 << THREAD_TIMER) ? 'T' : ' ', - a->types & (1 << THREAD_EVENT) ? 'E' : ' ', - a->types & (1 << THREAD_EXECUTE) ? 'X' : ' ', a->funcname); -} - -static void cpu_record_hash_print(struct hash_bucket *bucket, void *args[]) -{ - struct cpu_thread_history *totals = args[0]; - struct cpu_thread_history copy; - struct vty *vty = args[1]; - uint8_t *filter = args[2]; - - struct cpu_thread_history *a = bucket->data; - - copy.total_active = - atomic_load_explicit(&a->total_active, memory_order_seq_cst); - copy.total_calls = - atomic_load_explicit(&a->total_calls, memory_order_seq_cst); - copy.total_cpu_warn = - atomic_load_explicit(&a->total_cpu_warn, memory_order_seq_cst); - copy.total_wall_warn = - atomic_load_explicit(&a->total_wall_warn, memory_order_seq_cst); - copy.total_starv_warn = atomic_load_explicit(&a->total_starv_warn, - memory_order_seq_cst); - copy.cpu.total = - atomic_load_explicit(&a->cpu.total, memory_order_seq_cst); - copy.cpu.max = atomic_load_explicit(&a->cpu.max, memory_order_seq_cst); - copy.real.total = - atomic_load_explicit(&a->real.total, memory_order_seq_cst); - copy.real.max = - atomic_load_explicit(&a->real.max, memory_order_seq_cst); - copy.types = atomic_load_explicit(&a->types, memory_order_seq_cst); - copy.funcname = a->funcname; - - if (!(copy.types & *filter)) - return; - - vty_out_cpu_thread_history(vty, ©); - totals->total_active += copy.total_active; - totals->total_calls += copy.total_calls; - totals->total_cpu_warn += copy.total_cpu_warn; - totals->total_wall_warn += copy.total_wall_warn; - totals->total_starv_warn += copy.total_starv_warn; - totals->real.total += copy.real.total; - if (totals->real.max < copy.real.max) - totals->real.max = copy.real.max; - totals->cpu.total += copy.cpu.total; - if (totals->cpu.max < copy.cpu.max) - totals->cpu.max = copy.cpu.max; -} - -static void cpu_record_print(struct vty *vty, uint8_t filter) -{ - struct cpu_thread_history tmp; - void *args[3] = {&tmp, vty, &filter}; - struct thread_master *m; - struct listnode *ln; - - if (!cputime_enabled) - vty_out(vty, - "\n" - "Collecting CPU time statistics is currently disabled. Following statistics\n" - "will be zero or may display data from when collection was enabled. Use the\n" - " \"service cputime-stats\" command to start collecting data.\n" - "\nCounters and wallclock times are always maintained and should be accurate.\n"); - - memset(&tmp, 0, sizeof(tmp)); - tmp.funcname = "TOTAL"; - tmp.types = filter; - - frr_with_mutex (&masters_mtx) { - for (ALL_LIST_ELEMENTS_RO(masters, ln, m)) { - const char *name = m->name ? m->name : "main"; - - char underline[strlen(name) + 1]; - memset(underline, '-', sizeof(underline)); - underline[sizeof(underline) - 1] = '\0'; - - vty_out(vty, "\n"); - vty_out(vty, "Showing statistics for pthread %s\n", - name); - vty_out(vty, "-------------------------------%s\n", - underline); - vty_out(vty, "%30s %18s %18s\n", "", - "CPU (user+system):", "Real (wall-clock):"); - vty_out(vty, - "Active Runtime(ms) Invoked Avg uSec Max uSecs"); - vty_out(vty, " Avg uSec Max uSecs"); - vty_out(vty, - " CPU_Warn Wall_Warn Starv_Warn Type Thread\n"); - - if (m->cpu_record->count) - hash_iterate( - m->cpu_record, - (void (*)(struct hash_bucket *, - void *))cpu_record_hash_print, - args); - else - vty_out(vty, "No data to display yet.\n"); - - vty_out(vty, "\n"); - } - } - - vty_out(vty, "\n"); - vty_out(vty, "Total thread statistics\n"); - vty_out(vty, "-------------------------\n"); - vty_out(vty, "%30s %18s %18s\n", "", - "CPU (user+system):", "Real (wall-clock):"); - vty_out(vty, "Active Runtime(ms) Invoked Avg uSec Max uSecs"); - vty_out(vty, " Avg uSec Max uSecs CPU_Warn Wall_Warn"); - vty_out(vty, " Type Thread\n"); - - if (tmp.total_calls > 0) - vty_out_cpu_thread_history(vty, &tmp); -} - -static void cpu_record_hash_clear(struct hash_bucket *bucket, void *args[]) -{ - uint8_t *filter = args[0]; - struct hash *cpu_record = args[1]; - - struct cpu_thread_history *a = bucket->data; - - if (!(a->types & *filter)) - return; - - hash_release(cpu_record, bucket->data); -} - -static void cpu_record_clear(uint8_t filter) -{ - uint8_t *tmp = &filter; - struct thread_master *m; - struct listnode *ln; - - frr_with_mutex (&masters_mtx) { - for (ALL_LIST_ELEMENTS_RO(masters, ln, m)) { - frr_with_mutex (&m->mtx) { - void *args[2] = {tmp, m->cpu_record}; - hash_iterate( - m->cpu_record, - (void (*)(struct hash_bucket *, - void *))cpu_record_hash_clear, - args); - } - } - } -} - -static uint8_t parse_filter(const char *filterstr) -{ - int i = 0; - int filter = 0; - - while (filterstr[i] != '\0') { - switch (filterstr[i]) { - case 'r': - case 'R': - filter |= (1 << THREAD_READ); - break; - case 'w': - case 'W': - filter |= (1 << THREAD_WRITE); - break; - case 't': - case 'T': - filter |= (1 << THREAD_TIMER); - break; - case 'e': - case 'E': - filter |= (1 << THREAD_EVENT); - break; - case 'x': - case 'X': - filter |= (1 << THREAD_EXECUTE); - break; - default: - break; - } - ++i; - } - return filter; -} - -DEFUN_NOSH (show_thread_cpu, - show_thread_cpu_cmd, - "show thread cpu [FILTER]", - SHOW_STR - "Thread information\n" - "Thread CPU usage\n" - "Display filter (rwtex)\n") -{ - uint8_t filter = (uint8_t)-1U; - int idx = 0; - - if (argv_find(argv, argc, "FILTER", &idx)) { - filter = parse_filter(argv[idx]->arg); - if (!filter) { - vty_out(vty, - "Invalid filter \"%s\" specified; must contain at leastone of 'RWTEXB'\n", - argv[idx]->arg); - return CMD_WARNING; - } - } - - cpu_record_print(vty, filter); - return CMD_SUCCESS; -} - -DEFPY (service_cputime_stats, - service_cputime_stats_cmd, - "[no] service cputime-stats", - NO_STR - "Set up miscellaneous service\n" - "Collect CPU usage statistics\n") -{ - cputime_enabled = !no; - return CMD_SUCCESS; -} - -DEFPY (service_cputime_warning, - service_cputime_warning_cmd, - "[no] service cputime-warning (1-4294967295)", - NO_STR - "Set up miscellaneous service\n" - "Warn for tasks exceeding CPU usage threshold\n" - "Warning threshold in milliseconds\n") -{ - if (no) - cputime_threshold = 0; - else - cputime_threshold = cputime_warning * 1000; - return CMD_SUCCESS; -} - -ALIAS (service_cputime_warning, - no_service_cputime_warning_cmd, - "no service cputime-warning", - NO_STR - "Set up miscellaneous service\n" - "Warn for tasks exceeding CPU usage threshold\n") - -DEFPY (service_walltime_warning, - service_walltime_warning_cmd, - "[no] service walltime-warning (1-4294967295)", - NO_STR - "Set up miscellaneous service\n" - "Warn for tasks exceeding total wallclock threshold\n" - "Warning threshold in milliseconds\n") -{ - if (no) - walltime_threshold = 0; - else - walltime_threshold = walltime_warning * 1000; - return CMD_SUCCESS; -} - -ALIAS (service_walltime_warning, - no_service_walltime_warning_cmd, - "no service walltime-warning", - NO_STR - "Set up miscellaneous service\n" - "Warn for tasks exceeding total wallclock threshold\n") - -static void show_thread_poll_helper(struct vty *vty, struct thread_master *m) -{ - const char *name = m->name ? m->name : "main"; - char underline[strlen(name) + 1]; - struct thread *thread; - uint32_t i; - - memset(underline, '-', sizeof(underline)); - underline[sizeof(underline) - 1] = '\0'; - - vty_out(vty, "\nShowing poll FD's for %s\n", name); - vty_out(vty, "----------------------%s\n", underline); - vty_out(vty, "Count: %u/%d\n", (uint32_t)m->handler.pfdcount, - m->fd_limit); - for (i = 0; i < m->handler.pfdcount; i++) { - vty_out(vty, "\t%6d fd:%6d events:%2d revents:%2d\t\t", i, - m->handler.pfds[i].fd, m->handler.pfds[i].events, - m->handler.pfds[i].revents); - - if (m->handler.pfds[i].events & POLLIN) { - thread = m->read[m->handler.pfds[i].fd]; - - if (!thread) - vty_out(vty, "ERROR "); - else - vty_out(vty, "%s ", thread->xref->funcname); - } else - vty_out(vty, " "); - - if (m->handler.pfds[i].events & POLLOUT) { - thread = m->write[m->handler.pfds[i].fd]; - - if (!thread) - vty_out(vty, "ERROR\n"); - else - vty_out(vty, "%s\n", thread->xref->funcname); - } else - vty_out(vty, "\n"); - } -} - -DEFUN_NOSH (show_thread_poll, - show_thread_poll_cmd, - "show thread poll", - SHOW_STR - "Thread information\n" - "Show poll FD's and information\n") -{ - struct listnode *node; - struct thread_master *m; - - frr_with_mutex (&masters_mtx) { - for (ALL_LIST_ELEMENTS_RO(masters, node, m)) { - show_thread_poll_helper(vty, m); - } - } - - return CMD_SUCCESS; -} - - -DEFUN (clear_thread_cpu, - clear_thread_cpu_cmd, - "clear thread cpu [FILTER]", - "Clear stored data in all pthreads\n" - "Thread information\n" - "Thread CPU usage\n" - "Display filter (rwtexb)\n") -{ - uint8_t filter = (uint8_t)-1U; - int idx = 0; - - if (argv_find(argv, argc, "FILTER", &idx)) { - filter = parse_filter(argv[idx]->arg); - if (!filter) { - vty_out(vty, - "Invalid filter \"%s\" specified; must contain at leastone of 'RWTEXB'\n", - argv[idx]->arg); - return CMD_WARNING; - } - } - - cpu_record_clear(filter); - return CMD_SUCCESS; -} - -static void show_thread_timers_helper(struct vty *vty, struct thread_master *m) -{ - const char *name = m->name ? m->name : "main"; - char underline[strlen(name) + 1]; - struct thread *thread; - - memset(underline, '-', sizeof(underline)); - underline[sizeof(underline) - 1] = '\0'; - - vty_out(vty, "\nShowing timers for %s\n", name); - vty_out(vty, "-------------------%s\n", underline); - - frr_each (thread_timer_list, &m->timer, thread) { - vty_out(vty, " %-50s%pTH\n", thread->hist->funcname, thread); - } -} - -DEFPY_NOSH (show_thread_timers, - show_thread_timers_cmd, - "show thread timers", - SHOW_STR - "Thread information\n" - "Show all timers and how long they have in the system\n") -{ - struct listnode *node; - struct thread_master *m; - - frr_with_mutex (&masters_mtx) { - for (ALL_LIST_ELEMENTS_RO(masters, node, m)) - show_thread_timers_helper(vty, m); - } - - return CMD_SUCCESS; -} - -void thread_cmd_init(void) -{ - install_element(VIEW_NODE, &show_thread_cpu_cmd); - install_element(VIEW_NODE, &show_thread_poll_cmd); - install_element(ENABLE_NODE, &clear_thread_cpu_cmd); - - install_element(CONFIG_NODE, &service_cputime_stats_cmd); - install_element(CONFIG_NODE, &service_cputime_warning_cmd); - install_element(CONFIG_NODE, &no_service_cputime_warning_cmd); - install_element(CONFIG_NODE, &service_walltime_warning_cmd); - install_element(CONFIG_NODE, &no_service_walltime_warning_cmd); - - install_element(VIEW_NODE, &show_thread_timers_cmd); -} -/* CLI end ------------------------------------------------------------------ */ - - -static void cancelreq_del(void *cr) -{ - XFREE(MTYPE_TMP, cr); -} - -/* initializer, only ever called once */ -static void initializer(void) -{ - pthread_key_create(&thread_current, NULL); -} - -struct thread_master *thread_master_create(const char *name) -{ - struct thread_master *rv; - struct rlimit limit; - - pthread_once(&init_once, &initializer); - - rv = XCALLOC(MTYPE_THREAD_MASTER, sizeof(struct thread_master)); - - /* Initialize master mutex */ - pthread_mutex_init(&rv->mtx, NULL); - pthread_cond_init(&rv->cancel_cond, NULL); - - /* Set name */ - name = name ? name : "default"; - rv->name = XSTRDUP(MTYPE_THREAD_MASTER, name); - - /* Initialize I/O task data structures */ - - /* Use configured limit if present, ulimit otherwise. */ - rv->fd_limit = frr_get_fd_limit(); - if (rv->fd_limit == 0) { - getrlimit(RLIMIT_NOFILE, &limit); - rv->fd_limit = (int)limit.rlim_cur; - } - - rv->read = XCALLOC(MTYPE_THREAD_POLL, - sizeof(struct thread *) * rv->fd_limit); - - rv->write = XCALLOC(MTYPE_THREAD_POLL, - sizeof(struct thread *) * rv->fd_limit); - - char tmhashname[strlen(name) + 32]; - snprintf(tmhashname, sizeof(tmhashname), "%s - threadmaster event hash", - name); - rv->cpu_record = hash_create_size( - 8, (unsigned int (*)(const void *))cpu_record_hash_key, - (bool (*)(const void *, const void *))cpu_record_hash_cmp, - tmhashname); - - thread_list_init(&rv->event); - thread_list_init(&rv->ready); - thread_list_init(&rv->unuse); - thread_timer_list_init(&rv->timer); - - /* Initialize thread_fetch() settings */ - rv->spin = true; - rv->handle_signals = true; - - /* Set pthread owner, should be updated by actual owner */ - rv->owner = pthread_self(); - rv->cancel_req = list_new(); - rv->cancel_req->del = cancelreq_del; - rv->canceled = true; - - /* Initialize pipe poker */ - pipe(rv->io_pipe); - set_nonblocking(rv->io_pipe[0]); - set_nonblocking(rv->io_pipe[1]); - - /* Initialize data structures for poll() */ - rv->handler.pfdsize = rv->fd_limit; - rv->handler.pfdcount = 0; - rv->handler.pfds = XCALLOC(MTYPE_THREAD_MASTER, - sizeof(struct pollfd) * rv->handler.pfdsize); - rv->handler.copy = XCALLOC(MTYPE_THREAD_MASTER, - sizeof(struct pollfd) * rv->handler.pfdsize); - - /* add to list of threadmasters */ - frr_with_mutex (&masters_mtx) { - if (!masters) - masters = list_new(); - - listnode_add(masters, rv); - } - - return rv; -} - -void thread_master_set_name(struct thread_master *master, const char *name) -{ - frr_with_mutex (&master->mtx) { - XFREE(MTYPE_THREAD_MASTER, master->name); - master->name = XSTRDUP(MTYPE_THREAD_MASTER, name); - } -} - -#define THREAD_UNUSED_DEPTH 10 - -/* Move thread to unuse list. */ -static void thread_add_unuse(struct thread_master *m, struct thread *thread) -{ - pthread_mutex_t mtxc = thread->mtx; - - assert(m != NULL && thread != NULL); - - thread->hist->total_active--; - memset(thread, 0, sizeof(struct thread)); - thread->type = THREAD_UNUSED; - - /* Restore the thread mutex context. */ - thread->mtx = mtxc; - - if (thread_list_count(&m->unuse) < THREAD_UNUSED_DEPTH) { - thread_list_add_tail(&m->unuse, thread); - return; - } - - thread_free(m, thread); -} - -/* Free all unused thread. */ -static void thread_list_free(struct thread_master *m, - struct thread_list_head *list) -{ - struct thread *t; - - while ((t = thread_list_pop(list))) - thread_free(m, t); -} - -static void thread_array_free(struct thread_master *m, - struct thread **thread_array) -{ - struct thread *t; - int index; - - for (index = 0; index < m->fd_limit; ++index) { - t = thread_array[index]; - if (t) { - thread_array[index] = NULL; - thread_free(m, t); - } - } - XFREE(MTYPE_THREAD_POLL, thread_array); -} - -/* - * thread_master_free_unused - * - * As threads are finished with they are put on the - * unuse list for later reuse. - * If we are shutting down, Free up unused threads - * So we can see if we forget to shut anything off - */ -void thread_master_free_unused(struct thread_master *m) -{ - frr_with_mutex (&m->mtx) { - struct thread *t; - while ((t = thread_list_pop(&m->unuse))) - thread_free(m, t); - } -} - -/* Stop thread scheduler. */ -void thread_master_free(struct thread_master *m) -{ - struct thread *t; - - frr_with_mutex (&masters_mtx) { - listnode_delete(masters, m); - if (masters->count == 0) { - list_delete(&masters); - } - } - - thread_array_free(m, m->read); - thread_array_free(m, m->write); - while ((t = thread_timer_list_pop(&m->timer))) - thread_free(m, t); - thread_list_free(m, &m->event); - thread_list_free(m, &m->ready); - thread_list_free(m, &m->unuse); - pthread_mutex_destroy(&m->mtx); - pthread_cond_destroy(&m->cancel_cond); - close(m->io_pipe[0]); - close(m->io_pipe[1]); - list_delete(&m->cancel_req); - m->cancel_req = NULL; - - hash_clean_and_free(&m->cpu_record, cpu_record_hash_free); - - XFREE(MTYPE_THREAD_MASTER, m->name); - XFREE(MTYPE_THREAD_MASTER, m->handler.pfds); - XFREE(MTYPE_THREAD_MASTER, m->handler.copy); - XFREE(MTYPE_THREAD_MASTER, m); -} - -/* Return remain time in milliseconds. */ -unsigned long thread_timer_remain_msec(struct thread *thread) -{ - int64_t remain; - - if (!thread_is_scheduled(thread)) - return 0; - - frr_with_mutex (&thread->mtx) { - remain = monotime_until(&thread->u.sands, NULL) / 1000LL; - } - - return remain < 0 ? 0 : remain; -} - -/* Return remain time in seconds. */ -unsigned long thread_timer_remain_second(struct thread *thread) -{ - return thread_timer_remain_msec(thread) / 1000LL; -} - -struct timeval thread_timer_remain(struct thread *thread) -{ - struct timeval remain; - frr_with_mutex (&thread->mtx) { - monotime_until(&thread->u.sands, &remain); - } - return remain; -} - -static int time_hhmmss(char *buf, int buf_size, long sec) -{ - long hh; - long mm; - int wr; - - assert(buf_size >= 8); - - hh = sec / 3600; - sec %= 3600; - mm = sec / 60; - sec %= 60; - - wr = snprintf(buf, buf_size, "%02ld:%02ld:%02ld", hh, mm, sec); - - return wr != 8; -} - -char *thread_timer_to_hhmmss(char *buf, int buf_size, - struct thread *t_timer) -{ - if (t_timer) { - time_hhmmss(buf, buf_size, - thread_timer_remain_second(t_timer)); - } else { - snprintf(buf, buf_size, "--:--:--"); - } - return buf; -} - -/* Get new thread. */ -static struct thread *thread_get(struct thread_master *m, uint8_t type, - void (*func)(struct thread *), void *arg, - const struct xref_threadsched *xref) -{ - struct thread *thread = thread_list_pop(&m->unuse); - struct cpu_thread_history tmp; - - if (!thread) { - thread = XCALLOC(MTYPE_THREAD, sizeof(struct thread)); - /* mutex only needs to be initialized at struct creation. */ - pthread_mutex_init(&thread->mtx, NULL); - m->alloc++; - } - - thread->type = type; - thread->add_type = type; - thread->master = m; - thread->arg = arg; - thread->yield = THREAD_YIELD_TIME_SLOT; /* default */ - thread->ref = NULL; - thread->ignore_timer_late = false; - - /* - * So if the passed in funcname is not what we have - * stored that means the thread->hist needs to be - * updated. We keep the last one around in unused - * under the assumption that we are probably - * going to immediately allocate the same - * type of thread. - * This hopefully saves us some serious - * hash_get lookups. - */ - if ((thread->xref && thread->xref->funcname != xref->funcname) - || thread->func != func) { - tmp.func = func; - tmp.funcname = xref->funcname; - thread->hist = - hash_get(m->cpu_record, &tmp, - (void *(*)(void *))cpu_record_hash_alloc); - } - thread->hist->total_active++; - thread->func = func; - thread->xref = xref; - - return thread; -} - -static void thread_free(struct thread_master *master, struct thread *thread) -{ - /* Update statistics. */ - assert(master->alloc > 0); - master->alloc--; - - /* Free allocated resources. */ - pthread_mutex_destroy(&thread->mtx); - XFREE(MTYPE_THREAD, thread); -} - -static int fd_poll(struct thread_master *m, const struct timeval *timer_wait, - bool *eintr_p) -{ - sigset_t origsigs; - unsigned char trash[64]; - nfds_t count = m->handler.copycount; - - /* - * If timer_wait is null here, that means poll() should block - * indefinitely, unless the thread_master has overridden it by setting - * ->selectpoll_timeout. - * - * If the value is positive, it specifies the maximum number of - * milliseconds to wait. If the timeout is -1, it specifies that - * we should never wait and always return immediately even if no - * event is detected. If the value is zero, the behavior is default. - */ - int timeout = -1; - - /* number of file descriptors with events */ - int num; - - if (timer_wait != NULL - && m->selectpoll_timeout == 0) // use the default value - timeout = (timer_wait->tv_sec * 1000) - + (timer_wait->tv_usec / 1000); - else if (m->selectpoll_timeout > 0) // use the user's timeout - timeout = m->selectpoll_timeout; - else if (m->selectpoll_timeout - < 0) // effect a poll (return immediately) - timeout = 0; - - zlog_tls_buffer_flush(); - rcu_read_unlock(); - rcu_assert_read_unlocked(); - - /* add poll pipe poker */ - assert(count + 1 < m->handler.pfdsize); - m->handler.copy[count].fd = m->io_pipe[0]; - m->handler.copy[count].events = POLLIN; - m->handler.copy[count].revents = 0x00; - - /* We need to deal with a signal-handling race here: we - * don't want to miss a crucial signal, such as SIGTERM or SIGINT, - * that may arrive just before we enter poll(). We will block the - * key signals, then check whether any have arrived - if so, we return - * before calling poll(). If not, we'll re-enable the signals - * in the ppoll() call. - */ - - sigemptyset(&origsigs); - if (m->handle_signals) { - /* Main pthread that handles the app signals */ - if (frr_sigevent_check(&origsigs)) { - /* Signal to process - restore signal mask and return */ - pthread_sigmask(SIG_SETMASK, &origsigs, NULL); - num = -1; - *eintr_p = true; - goto done; - } - } else { - /* Don't make any changes for the non-main pthreads */ - pthread_sigmask(SIG_SETMASK, NULL, &origsigs); - } - -#if defined(HAVE_PPOLL) - struct timespec ts, *tsp; - - if (timeout >= 0) { - ts.tv_sec = timeout / 1000; - ts.tv_nsec = (timeout % 1000) * 1000000; - tsp = &ts; - } else - tsp = NULL; - - num = ppoll(m->handler.copy, count + 1, tsp, &origsigs); - pthread_sigmask(SIG_SETMASK, &origsigs, NULL); -#else - /* Not ideal - there is a race after we restore the signal mask */ - pthread_sigmask(SIG_SETMASK, &origsigs, NULL); - num = poll(m->handler.copy, count + 1, timeout); -#endif - -done: - - if (num < 0 && errno == EINTR) - *eintr_p = true; - - if (num > 0 && m->handler.copy[count].revents != 0 && num--) - while (read(m->io_pipe[0], &trash, sizeof(trash)) > 0) - ; - - rcu_read_lock(); - - return num; -} - -/* Add new read thread. */ -void _thread_add_read_write(const struct xref_threadsched *xref, - struct thread_master *m, - void (*func)(struct thread *), void *arg, int fd, - struct thread **t_ptr) -{ - int dir = xref->thread_type; - struct thread *thread = NULL; - struct thread **thread_array; - - if (dir == THREAD_READ) - frrtrace(9, frr_libfrr, schedule_read, m, - xref->funcname, xref->xref.file, xref->xref.line, - t_ptr, fd, 0, arg, 0); - else - frrtrace(9, frr_libfrr, schedule_write, m, - xref->funcname, xref->xref.file, xref->xref.line, - t_ptr, fd, 0, arg, 0); - - assert(fd >= 0); - if (fd >= m->fd_limit) - assert(!"Number of FD's open is greater than FRR currently configured to handle, aborting"); - - frr_with_mutex (&m->mtx) { - if (t_ptr && *t_ptr) - // thread is already scheduled; don't reschedule - break; - - /* default to a new pollfd */ - nfds_t queuepos = m->handler.pfdcount; - - if (dir == THREAD_READ) - thread_array = m->read; - else - thread_array = m->write; - - /* if we already have a pollfd for our file descriptor, find and - * use it */ - for (nfds_t i = 0; i < m->handler.pfdcount; i++) - if (m->handler.pfds[i].fd == fd) { - queuepos = i; - -#ifdef DEV_BUILD - /* - * What happens if we have a thread already - * created for this event? - */ - if (thread_array[fd]) - assert(!"Thread already scheduled for file descriptor"); -#endif - break; - } - - /* make sure we have room for this fd + pipe poker fd */ - assert(queuepos + 1 < m->handler.pfdsize); - - thread = thread_get(m, dir, func, arg, xref); - - m->handler.pfds[queuepos].fd = fd; - m->handler.pfds[queuepos].events |= - (dir == THREAD_READ ? POLLIN : POLLOUT); - - if (queuepos == m->handler.pfdcount) - m->handler.pfdcount++; - - if (thread) { - frr_with_mutex (&thread->mtx) { - thread->u.fd = fd; - thread_array[thread->u.fd] = thread; - } - - if (t_ptr) { - *t_ptr = thread; - thread->ref = t_ptr; - } - } - - AWAKEN(m); - } -} - -static void _thread_add_timer_timeval(const struct xref_threadsched *xref, - struct thread_master *m, - void (*func)(struct thread *), void *arg, - struct timeval *time_relative, - struct thread **t_ptr) -{ - struct thread *thread; - struct timeval t; - - assert(m != NULL); - - assert(time_relative); - - frrtrace(9, frr_libfrr, schedule_timer, m, - xref->funcname, xref->xref.file, xref->xref.line, - t_ptr, 0, 0, arg, (long)time_relative->tv_sec); - - /* Compute expiration/deadline time. */ - monotime(&t); - timeradd(&t, time_relative, &t); - - frr_with_mutex (&m->mtx) { - if (t_ptr && *t_ptr) - /* thread is already scheduled; don't reschedule */ - return; - - thread = thread_get(m, THREAD_TIMER, func, arg, xref); - - frr_with_mutex (&thread->mtx) { - thread->u.sands = t; - thread_timer_list_add(&m->timer, thread); - if (t_ptr) { - *t_ptr = thread; - thread->ref = t_ptr; - } - } - - /* The timer list is sorted - if this new timer - * might change the time we'll wait for, give the pthread - * a chance to re-compute. - */ - if (thread_timer_list_first(&m->timer) == thread) - AWAKEN(m); - } -#define ONEYEAR2SEC (60 * 60 * 24 * 365) - if (time_relative->tv_sec > ONEYEAR2SEC) - flog_err( - EC_LIB_TIMER_TOO_LONG, - "Timer: %pTHD is created with an expiration that is greater than 1 year", - thread); -} - - -/* Add timer event thread. */ -void _thread_add_timer(const struct xref_threadsched *xref, - struct thread_master *m, void (*func)(struct thread *), - void *arg, long timer, struct thread **t_ptr) -{ - struct timeval trel; - - assert(m != NULL); - - trel.tv_sec = timer; - trel.tv_usec = 0; - - _thread_add_timer_timeval(xref, m, func, arg, &trel, t_ptr); -} - -/* Add timer event thread with "millisecond" resolution */ -void _thread_add_timer_msec(const struct xref_threadsched *xref, - struct thread_master *m, - void (*func)(struct thread *), void *arg, - long timer, struct thread **t_ptr) -{ - struct timeval trel; - - assert(m != NULL); - - trel.tv_sec = timer / 1000; - trel.tv_usec = 1000 * (timer % 1000); - - _thread_add_timer_timeval(xref, m, func, arg, &trel, t_ptr); -} - -/* Add timer event thread with "timeval" resolution */ -void _thread_add_timer_tv(const struct xref_threadsched *xref, - struct thread_master *m, - void (*func)(struct thread *), void *arg, - struct timeval *tv, struct thread **t_ptr) -{ - _thread_add_timer_timeval(xref, m, func, arg, tv, t_ptr); -} - -/* Add simple event thread. */ -void _thread_add_event(const struct xref_threadsched *xref, - struct thread_master *m, void (*func)(struct thread *), - void *arg, int val, struct thread **t_ptr) -{ - struct thread *thread = NULL; - - frrtrace(9, frr_libfrr, schedule_event, m, - xref->funcname, xref->xref.file, xref->xref.line, - t_ptr, 0, val, arg, 0); - - assert(m != NULL); - - frr_with_mutex (&m->mtx) { - if (t_ptr && *t_ptr) - /* thread is already scheduled; don't reschedule */ - break; - - thread = thread_get(m, THREAD_EVENT, func, arg, xref); - frr_with_mutex (&thread->mtx) { - thread->u.val = val; - thread_list_add_tail(&m->event, thread); - } - - if (t_ptr) { - *t_ptr = thread; - thread->ref = t_ptr; - } - - AWAKEN(m); - } -} - -/* Thread cancellation ------------------------------------------------------ */ - -/** - * NOT's out the .events field of pollfd corresponding to the given file - * descriptor. The event to be NOT'd is passed in the 'state' parameter. - * - * This needs to happen for both copies of pollfd's. See 'thread_fetch' - * implementation for details. - * - * @param master - * @param fd - * @param state the event to cancel. One or more (OR'd together) of the - * following: - * - POLLIN - * - POLLOUT - */ -static void thread_cancel_rw(struct thread_master *master, int fd, short state, - int idx_hint) -{ - bool found = false; - - /* find the index of corresponding pollfd */ - nfds_t i; - - /* Cancel POLLHUP too just in case some bozo set it */ - state |= POLLHUP; - - /* Some callers know the index of the pfd already */ - if (idx_hint >= 0) { - i = idx_hint; - found = true; - } else { - /* Have to look for the fd in the pfd array */ - for (i = 0; i < master->handler.pfdcount; i++) - if (master->handler.pfds[i].fd == fd) { - found = true; - break; - } - } - - if (!found) { - zlog_debug( - "[!] Received cancellation request for nonexistent rw job"); - zlog_debug("[!] threadmaster: %s | fd: %d", - master->name ? master->name : "", fd); - return; - } - - /* NOT out event. */ - master->handler.pfds[i].events &= ~(state); - - /* If all events are canceled, delete / resize the pollfd array. */ - if (master->handler.pfds[i].events == 0) { - memmove(master->handler.pfds + i, master->handler.pfds + i + 1, - (master->handler.pfdcount - i - 1) - * sizeof(struct pollfd)); - master->handler.pfdcount--; - master->handler.pfds[master->handler.pfdcount].fd = 0; - master->handler.pfds[master->handler.pfdcount].events = 0; - } - - /* If we have the same pollfd in the copy, perform the same operations, - * otherwise return. */ - if (i >= master->handler.copycount) - return; - - master->handler.copy[i].events &= ~(state); - - if (master->handler.copy[i].events == 0) { - memmove(master->handler.copy + i, master->handler.copy + i + 1, - (master->handler.copycount - i - 1) - * sizeof(struct pollfd)); - master->handler.copycount--; - master->handler.copy[master->handler.copycount].fd = 0; - master->handler.copy[master->handler.copycount].events = 0; - } -} - -/* - * Process task cancellation given a task argument: iterate through the - * various lists of tasks, looking for any that match the argument. - */ -static void cancel_arg_helper(struct thread_master *master, - const struct cancel_req *cr) -{ - struct thread *t; - nfds_t i; - int fd; - struct pollfd *pfd; - - /* We're only processing arg-based cancellations here. */ - if (cr->eventobj == NULL) - return; - - /* First process the ready lists. */ - frr_each_safe(thread_list, &master->event, t) { - if (t->arg != cr->eventobj) - continue; - thread_list_del(&master->event, t); - if (t->ref) - *t->ref = NULL; - thread_add_unuse(master, t); - } - - frr_each_safe(thread_list, &master->ready, t) { - if (t->arg != cr->eventobj) - continue; - thread_list_del(&master->ready, t); - if (t->ref) - *t->ref = NULL; - thread_add_unuse(master, t); - } - - /* If requested, stop here and ignore io and timers */ - if (CHECK_FLAG(cr->flags, THREAD_CANCEL_FLAG_READY)) - return; - - /* Check the io tasks */ - for (i = 0; i < master->handler.pfdcount;) { - pfd = master->handler.pfds + i; - - if (pfd->events & POLLIN) - t = master->read[pfd->fd]; - else - t = master->write[pfd->fd]; - - if (t && t->arg == cr->eventobj) { - fd = pfd->fd; - - /* Found a match to cancel: clean up fd arrays */ - thread_cancel_rw(master, pfd->fd, pfd->events, i); - - /* Clean up thread arrays */ - master->read[fd] = NULL; - master->write[fd] = NULL; - - /* Clear caller's ref */ - if (t->ref) - *t->ref = NULL; - - thread_add_unuse(master, t); - - /* Don't increment 'i' since the cancellation will have - * removed the entry from the pfd array - */ - } else - i++; - } - - /* Check the timer tasks */ - t = thread_timer_list_first(&master->timer); - while (t) { - struct thread *t_next; - - t_next = thread_timer_list_next(&master->timer, t); - - if (t->arg == cr->eventobj) { - thread_timer_list_del(&master->timer, t); - if (t->ref) - *t->ref = NULL; - thread_add_unuse(master, t); - } - - t = t_next; - } -} - -/** - * Process cancellation requests. - * - * This may only be run from the pthread which owns the thread_master. - * - * @param master the thread master to process - * @REQUIRE master->mtx - */ -static void do_thread_cancel(struct thread_master *master) -{ - struct thread_list_head *list = NULL; - struct thread **thread_array = NULL; - struct thread *thread; - struct cancel_req *cr; - struct listnode *ln; - - for (ALL_LIST_ELEMENTS_RO(master->cancel_req, ln, cr)) { - /* - * If this is an event object cancellation, search - * through task lists deleting any tasks which have the - * specified argument - use this handy helper function. - */ - if (cr->eventobj) { - cancel_arg_helper(master, cr); - continue; - } - - /* - * The pointer varies depending on whether the cancellation - * request was made asynchronously or not. If it was, we - * need to check whether the thread even exists anymore - * before cancelling it. - */ - thread = (cr->thread) ? cr->thread : *cr->threadref; - - if (!thread) - continue; - - list = NULL; - thread_array = NULL; - - /* Determine the appropriate queue to cancel the thread from */ - switch (thread->type) { - case THREAD_READ: - thread_cancel_rw(master, thread->u.fd, POLLIN, -1); - thread_array = master->read; - break; - case THREAD_WRITE: - thread_cancel_rw(master, thread->u.fd, POLLOUT, -1); - thread_array = master->write; - break; - case THREAD_TIMER: - thread_timer_list_del(&master->timer, thread); - break; - case THREAD_EVENT: - list = &master->event; - break; - case THREAD_READY: - list = &master->ready; - break; - default: - continue; - break; - } - - if (list) { - thread_list_del(list, thread); - } else if (thread_array) { - thread_array[thread->u.fd] = NULL; - } - - if (thread->ref) - *thread->ref = NULL; - - thread_add_unuse(thread->master, thread); - } - - /* Delete and free all cancellation requests */ - if (master->cancel_req) - list_delete_all_node(master->cancel_req); - - /* Wake up any threads which may be blocked in thread_cancel_async() */ - master->canceled = true; - pthread_cond_broadcast(&master->cancel_cond); -} - -/* - * Helper function used for multiple flavors of arg-based cancellation. - */ -static void cancel_event_helper(struct thread_master *m, void *arg, int flags) -{ - struct cancel_req *cr; - - assert(m->owner == pthread_self()); - - /* Only worth anything if caller supplies an arg. */ - if (arg == NULL) - return; - - cr = XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); - - cr->flags = flags; - - frr_with_mutex (&m->mtx) { - cr->eventobj = arg; - listnode_add(m->cancel_req, cr); - do_thread_cancel(m); - } -} - -/** - * Cancel any events which have the specified argument. - * - * MT-Unsafe - * - * @param m the thread_master to cancel from - * @param arg the argument passed when creating the event - */ -void thread_cancel_event(struct thread_master *master, void *arg) -{ - cancel_event_helper(master, arg, 0); -} - -/* - * Cancel ready tasks with an arg matching 'arg' - * - * MT-Unsafe - * - * @param m the thread_master to cancel from - * @param arg the argument passed when creating the event - */ -void thread_cancel_event_ready(struct thread_master *m, void *arg) -{ - - /* Only cancel ready/event tasks */ - cancel_event_helper(m, arg, THREAD_CANCEL_FLAG_READY); -} - -/** - * Cancel a specific task. - * - * MT-Unsafe - * - * @param thread task to cancel - */ -void thread_cancel(struct thread **thread) -{ - struct thread_master *master; - - if (thread == NULL || *thread == NULL) - return; - - master = (*thread)->master; - - frrtrace(9, frr_libfrr, thread_cancel, master, - (*thread)->xref->funcname, (*thread)->xref->xref.file, - (*thread)->xref->xref.line, NULL, (*thread)->u.fd, - (*thread)->u.val, (*thread)->arg, (*thread)->u.sands.tv_sec); - - assert(master->owner == pthread_self()); - - frr_with_mutex (&master->mtx) { - struct cancel_req *cr = - XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); - cr->thread = *thread; - listnode_add(master->cancel_req, cr); - do_thread_cancel(master); - } - - *thread = NULL; -} - -/** - * Asynchronous cancellation. - * - * Called with either a struct thread ** or void * to an event argument, - * this function posts the correct cancellation request and blocks until it is - * serviced. - * - * If the thread is currently running, execution blocks until it completes. - * - * The last two parameters are mutually exclusive, i.e. if you pass one the - * other must be NULL. - * - * When the cancellation procedure executes on the target thread_master, the - * thread * provided is checked for nullity. If it is null, the thread is - * assumed to no longer exist and the cancellation request is a no-op. Thus - * users of this API must pass a back-reference when scheduling the original - * task. - * - * MT-Safe - * - * @param master the thread master with the relevant event / task - * @param thread pointer to thread to cancel - * @param eventobj the event - */ -void thread_cancel_async(struct thread_master *master, struct thread **thread, - void *eventobj) -{ - assert(!(thread && eventobj) && (thread || eventobj)); - - if (thread && *thread) - frrtrace(9, frr_libfrr, thread_cancel_async, master, - (*thread)->xref->funcname, (*thread)->xref->xref.file, - (*thread)->xref->xref.line, NULL, (*thread)->u.fd, - (*thread)->u.val, (*thread)->arg, - (*thread)->u.sands.tv_sec); - else - frrtrace(9, frr_libfrr, thread_cancel_async, master, NULL, NULL, - 0, NULL, 0, 0, eventobj, 0); - - assert(master->owner != pthread_self()); - - frr_with_mutex (&master->mtx) { - master->canceled = false; - - if (thread) { - struct cancel_req *cr = - XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); - cr->threadref = thread; - listnode_add(master->cancel_req, cr); - } else if (eventobj) { - struct cancel_req *cr = - XCALLOC(MTYPE_TMP, sizeof(struct cancel_req)); - cr->eventobj = eventobj; - listnode_add(master->cancel_req, cr); - } - AWAKEN(master); - - while (!master->canceled) - pthread_cond_wait(&master->cancel_cond, &master->mtx); - } - - if (thread) - *thread = NULL; -} -/* ------------------------------------------------------------------------- */ - -static struct timeval *thread_timer_wait(struct thread_timer_list_head *timers, - struct timeval *timer_val) -{ - if (!thread_timer_list_count(timers)) - return NULL; - - struct thread *next_timer = thread_timer_list_first(timers); - monotime_until(&next_timer->u.sands, timer_val); - return timer_val; -} - -static struct thread *thread_run(struct thread_master *m, struct thread *thread, - struct thread *fetch) -{ - *fetch = *thread; - thread_add_unuse(m, thread); - return fetch; -} - -static int thread_process_io_helper(struct thread_master *m, - struct thread *thread, short state, - short actual_state, int pos) -{ - struct thread **thread_array; - - /* - * poll() clears the .events field, but the pollfd array we - * pass to poll() is a copy of the one used to schedule threads. - * We need to synchronize state between the two here by applying - * the same changes poll() made on the copy of the "real" pollfd - * array. - * - * This cleans up a possible infinite loop where we refuse - * to respond to a poll event but poll is insistent that - * we should. - */ - m->handler.pfds[pos].events &= ~(state); - - if (!thread) { - if ((actual_state & (POLLHUP|POLLIN)) != POLLHUP) - flog_err(EC_LIB_NO_THREAD, - "Attempting to process an I/O event but for fd: %d(%d) no thread to handle this!", - m->handler.pfds[pos].fd, actual_state); - return 0; - } - - if (thread->type == THREAD_READ) - thread_array = m->read; - else - thread_array = m->write; - - thread_array[thread->u.fd] = NULL; - thread_list_add_tail(&m->ready, thread); - thread->type = THREAD_READY; - - return 1; -} - -/** - * Process I/O events. - * - * Walks through file descriptor array looking for those pollfds whose .revents - * field has something interesting. Deletes any invalid file descriptors. - * - * @param m the thread master - * @param num the number of active file descriptors (return value of poll()) - */ -static void thread_process_io(struct thread_master *m, unsigned int num) -{ - unsigned int ready = 0; - struct pollfd *pfds = m->handler.copy; - - for (nfds_t i = 0; i < m->handler.copycount && ready < num; ++i) { - /* no event for current fd? immediately continue */ - if (pfds[i].revents == 0) - continue; - - ready++; - - /* - * Unless someone has called thread_cancel from another - * pthread, the only thing that could have changed in - * m->handler.pfds while we were asleep is the .events - * field in a given pollfd. Barring thread_cancel() that - * value should be a superset of the values we have in our - * copy, so there's no need to update it. Similarily, - * barring deletion, the fd should still be a valid index - * into the master's pfds. - * - * We are including POLLERR here to do a READ event - * this is because the read should fail and the - * read function should handle it appropriately - */ - if (pfds[i].revents & (POLLIN | POLLHUP | POLLERR)) { - thread_process_io_helper(m, m->read[pfds[i].fd], POLLIN, - pfds[i].revents, i); - } - if (pfds[i].revents & POLLOUT) - thread_process_io_helper(m, m->write[pfds[i].fd], - POLLOUT, pfds[i].revents, i); - - /* if one of our file descriptors is garbage, remove the same - * from - * both pfds + update sizes and index */ - if (pfds[i].revents & POLLNVAL) { - memmove(m->handler.pfds + i, m->handler.pfds + i + 1, - (m->handler.pfdcount - i - 1) - * sizeof(struct pollfd)); - m->handler.pfdcount--; - m->handler.pfds[m->handler.pfdcount].fd = 0; - m->handler.pfds[m->handler.pfdcount].events = 0; - - memmove(pfds + i, pfds + i + 1, - (m->handler.copycount - i - 1) - * sizeof(struct pollfd)); - m->handler.copycount--; - m->handler.copy[m->handler.copycount].fd = 0; - m->handler.copy[m->handler.copycount].events = 0; - - i--; - } - } -} - -/* Add all timers that have popped to the ready list. */ -static unsigned int thread_process_timers(struct thread_master *m, - struct timeval *timenow) -{ - struct timeval prev = *timenow; - bool displayed = false; - struct thread *thread; - unsigned int ready = 0; - - while ((thread = thread_timer_list_first(&m->timer))) { - if (timercmp(timenow, &thread->u.sands, <)) - break; - prev = thread->u.sands; - prev.tv_sec += 4; - /* - * If the timer would have popped 4 seconds in the - * past then we are in a situation where we are - * really getting behind on handling of events. - * Let's log it and do the right thing with it. - */ - if (timercmp(timenow, &prev, >)) { - atomic_fetch_add_explicit( - &thread->hist->total_starv_warn, 1, - memory_order_seq_cst); - if (!displayed && !thread->ignore_timer_late) { - flog_warn( - EC_LIB_STARVE_THREAD, - "Thread Starvation: %pTHD was scheduled to pop greater than 4s ago", - thread); - displayed = true; - } - } - - thread_timer_list_pop(&m->timer); - thread->type = THREAD_READY; - thread_list_add_tail(&m->ready, thread); - ready++; - } - - return ready; -} - -/* process a list en masse, e.g. for event thread lists */ -static unsigned int thread_process(struct thread_list_head *list) -{ - struct thread *thread; - unsigned int ready = 0; - - while ((thread = thread_list_pop(list))) { - thread->type = THREAD_READY; - thread_list_add_tail(&thread->master->ready, thread); - ready++; - } - return ready; -} - - -/* Fetch next ready thread. */ -struct thread *thread_fetch(struct thread_master *m, struct thread *fetch) -{ - struct thread *thread = NULL; - struct timeval now; - struct timeval zerotime = {0, 0}; - struct timeval tv; - struct timeval *tw = NULL; - bool eintr_p = false; - int num = 0; - - do { - /* Handle signals if any */ - if (m->handle_signals) - frr_sigevent_process(); - - pthread_mutex_lock(&m->mtx); - - /* Process any pending cancellation requests */ - do_thread_cancel(m); - - /* - * Attempt to flush ready queue before going into poll(). - * This is performance-critical. Think twice before modifying. - */ - if ((thread = thread_list_pop(&m->ready))) { - fetch = thread_run(m, thread, fetch); - if (fetch->ref) - *fetch->ref = NULL; - pthread_mutex_unlock(&m->mtx); - if (!m->ready_run_loop) - GETRUSAGE(&m->last_getrusage); - m->ready_run_loop = true; - break; - } - - m->ready_run_loop = false; - /* otherwise, tick through scheduling sequence */ - - /* - * Post events to ready queue. This must come before the - * following block since events should occur immediately - */ - thread_process(&m->event); - - /* - * If there are no tasks on the ready queue, we will poll() - * until a timer expires or we receive I/O, whichever comes - * first. The strategy for doing this is: - * - * - If there are events pending, set the poll() timeout to zero - * - If there are no events pending, but there are timers - * pending, set the timeout to the smallest remaining time on - * any timer. - * - If there are neither timers nor events pending, but there - * are file descriptors pending, block indefinitely in poll() - * - If nothing is pending, it's time for the application to die - * - * In every case except the last, we need to hit poll() at least - * once per loop to avoid starvation by events - */ - if (!thread_list_count(&m->ready)) - tw = thread_timer_wait(&m->timer, &tv); - - if (thread_list_count(&m->ready) || - (tw && !timercmp(tw, &zerotime, >))) - tw = &zerotime; - - if (!tw && m->handler.pfdcount == 0) { /* die */ - pthread_mutex_unlock(&m->mtx); - fetch = NULL; - break; - } - - /* - * Copy pollfd array + # active pollfds in it. Not necessary to - * copy the array size as this is fixed. - */ - m->handler.copycount = m->handler.pfdcount; - memcpy(m->handler.copy, m->handler.pfds, - m->handler.copycount * sizeof(struct pollfd)); - - pthread_mutex_unlock(&m->mtx); - { - eintr_p = false; - num = fd_poll(m, tw, &eintr_p); - } - pthread_mutex_lock(&m->mtx); - - /* Handle any errors received in poll() */ - if (num < 0) { - if (eintr_p) { - pthread_mutex_unlock(&m->mtx); - /* loop around to signal handler */ - continue; - } - - /* else die */ - flog_err(EC_LIB_SYSTEM_CALL, "poll() error: %s", - safe_strerror(errno)); - pthread_mutex_unlock(&m->mtx); - fetch = NULL; - break; - } - - /* Post timers to ready queue. */ - monotime(&now); - thread_process_timers(m, &now); - - /* Post I/O to ready queue. */ - if (num > 0) - thread_process_io(m, num); - - pthread_mutex_unlock(&m->mtx); - - } while (!thread && m->spin); - - return fetch; -} - -static unsigned long timeval_elapsed(struct timeval a, struct timeval b) -{ - return (((a.tv_sec - b.tv_sec) * TIMER_SECOND_MICRO) - + (a.tv_usec - b.tv_usec)); -} - -unsigned long thread_consumed_time(RUSAGE_T *now, RUSAGE_T *start, - unsigned long *cputime) -{ -#ifdef HAVE_CLOCK_THREAD_CPUTIME_ID - -#ifdef __FreeBSD__ - /* - * FreeBSD appears to have an issue when calling clock_gettime - * with CLOCK_THREAD_CPUTIME_ID really close to each other - * occassionally the now time will be before the start time. - * This is not good and FRR is ending up with CPU HOG's - * when the subtraction wraps to very large numbers - * - * What we are going to do here is cheat a little bit - * and notice that this is a problem and just correct - * it so that it is impossible to happen - */ - if (start->cpu.tv_sec == now->cpu.tv_sec && - start->cpu.tv_nsec > now->cpu.tv_nsec) - now->cpu.tv_nsec = start->cpu.tv_nsec + 1; - else if (start->cpu.tv_sec > now->cpu.tv_sec) { - now->cpu.tv_sec = start->cpu.tv_sec; - now->cpu.tv_nsec = start->cpu.tv_nsec + 1; - } -#endif - *cputime = (now->cpu.tv_sec - start->cpu.tv_sec) * TIMER_SECOND_MICRO - + (now->cpu.tv_nsec - start->cpu.tv_nsec) / 1000; -#else - /* This is 'user + sys' time. */ - *cputime = timeval_elapsed(now->cpu.ru_utime, start->cpu.ru_utime) - + timeval_elapsed(now->cpu.ru_stime, start->cpu.ru_stime); -#endif - return timeval_elapsed(now->real, start->real); -} - -/* We should aim to yield after yield milliseconds, which defaults - to THREAD_YIELD_TIME_SLOT . - Note: we are using real (wall clock) time for this calculation. - It could be argued that CPU time may make more sense in certain - contexts. The things to consider are whether the thread may have - blocked (in which case wall time increases, but CPU time does not), - or whether the system is heavily loaded with other processes competing - for CPU time. On balance, wall clock time seems to make sense. - Plus it has the added benefit that gettimeofday should be faster - than calling getrusage. */ -int thread_should_yield(struct thread *thread) -{ - int result; - frr_with_mutex (&thread->mtx) { - result = monotime_since(&thread->real, NULL) - > (int64_t)thread->yield; - } - return result; -} - -void thread_set_yield_time(struct thread *thread, unsigned long yield_time) -{ - frr_with_mutex (&thread->mtx) { - thread->yield = yield_time; - } -} - -void thread_getrusage(RUSAGE_T *r) -{ - monotime(&r->real); - if (!cputime_enabled) { - memset(&r->cpu, 0, sizeof(r->cpu)); - return; - } - -#ifdef HAVE_CLOCK_THREAD_CPUTIME_ID - /* not currently implemented in Linux's vDSO, but maybe at some point - * in the future? - */ - clock_gettime(CLOCK_THREAD_CPUTIME_ID, &r->cpu); -#else /* !HAVE_CLOCK_THREAD_CPUTIME_ID */ -#if defined RUSAGE_THREAD -#define FRR_RUSAGE RUSAGE_THREAD -#else -#define FRR_RUSAGE RUSAGE_SELF -#endif - getrusage(FRR_RUSAGE, &(r->cpu)); -#endif -} - -/* - * Call a thread. - * - * This function will atomically update the thread's usage history. At present - * this is the only spot where usage history is written. Nevertheless the code - * has been written such that the introduction of writers in the future should - * not need to update it provided the writers atomically perform only the - * operations done here, i.e. updating the total and maximum times. In - * particular, the maximum real and cpu times must be monotonically increasing - * or this code is not correct. - */ -void thread_call(struct thread *thread) -{ - RUSAGE_T before, after; - - /* if the thread being called is the CLI, it may change cputime_enabled - * ("service cputime-stats" command), which can result in nonsensical - * and very confusing warnings - */ - bool cputime_enabled_here = cputime_enabled; - - if (thread->master->ready_run_loop) - before = thread->master->last_getrusage; - else - GETRUSAGE(&before); - - thread->real = before.real; - - frrtrace(9, frr_libfrr, thread_call, thread->master, - thread->xref->funcname, thread->xref->xref.file, - thread->xref->xref.line, NULL, thread->u.fd, - thread->u.val, thread->arg, thread->u.sands.tv_sec); - - pthread_setspecific(thread_current, thread); - (*thread->func)(thread); - pthread_setspecific(thread_current, NULL); - - GETRUSAGE(&after); - thread->master->last_getrusage = after; - - unsigned long walltime, cputime; - unsigned long exp; - - walltime = thread_consumed_time(&after, &before, &cputime); - - /* update walltime */ - atomic_fetch_add_explicit(&thread->hist->real.total, walltime, - memory_order_seq_cst); - exp = atomic_load_explicit(&thread->hist->real.max, - memory_order_seq_cst); - while (exp < walltime - && !atomic_compare_exchange_weak_explicit( - &thread->hist->real.max, &exp, walltime, - memory_order_seq_cst, memory_order_seq_cst)) - ; - - if (cputime_enabled_here && cputime_enabled) { - /* update cputime */ - atomic_fetch_add_explicit(&thread->hist->cpu.total, cputime, - memory_order_seq_cst); - exp = atomic_load_explicit(&thread->hist->cpu.max, - memory_order_seq_cst); - while (exp < cputime - && !atomic_compare_exchange_weak_explicit( - &thread->hist->cpu.max, &exp, cputime, - memory_order_seq_cst, memory_order_seq_cst)) - ; - } - - atomic_fetch_add_explicit(&thread->hist->total_calls, 1, - memory_order_seq_cst); - atomic_fetch_or_explicit(&thread->hist->types, 1 << thread->add_type, - memory_order_seq_cst); - - if (cputime_enabled_here && cputime_enabled && cputime_threshold - && cputime > cputime_threshold) { - /* - * We have a CPU Hog on our hands. The time FRR has spent - * doing actual work (not sleeping) is greater than 5 seconds. - * Whinge about it now, so we're aware this is yet another task - * to fix. - */ - atomic_fetch_add_explicit(&thread->hist->total_cpu_warn, - 1, memory_order_seq_cst); - flog_warn( - EC_LIB_SLOW_THREAD_CPU, - "CPU HOG: task %s (%lx) ran for %lums (cpu time %lums)", - thread->xref->funcname, (unsigned long)thread->func, - walltime / 1000, cputime / 1000); - - } else if (walltime_threshold && walltime > walltime_threshold) { - /* - * The runtime for a task is greater than 5 seconds, but the - * cpu time is under 5 seconds. Let's whine about this because - * this could imply some sort of scheduling issue. - */ - atomic_fetch_add_explicit(&thread->hist->total_wall_warn, - 1, memory_order_seq_cst); - flog_warn( - EC_LIB_SLOW_THREAD_WALL, - "STARVATION: task %s (%lx) ran for %lums (cpu time %lums)", - thread->xref->funcname, (unsigned long)thread->func, - walltime / 1000, cputime / 1000); - } -} - -/* Execute thread */ -void _thread_execute(const struct xref_threadsched *xref, - struct thread_master *m, void (*func)(struct thread *), - void *arg, int val) -{ - struct thread *thread; - - /* Get or allocate new thread to execute. */ - frr_with_mutex (&m->mtx) { - thread = thread_get(m, THREAD_EVENT, func, arg, xref); - - /* Set its event value. */ - frr_with_mutex (&thread->mtx) { - thread->add_type = THREAD_EXECUTE; - thread->u.val = val; - thread->ref = &thread; - } - } - - /* Execute thread doing all accounting. */ - thread_call(thread); - - /* Give back or free thread. */ - thread_add_unuse(m, thread); -} - -/* Debug signal mask - if 'sigs' is NULL, use current effective mask. */ -void debug_signals(const sigset_t *sigs) -{ - int i, found; - sigset_t tmpsigs; - char buf[300]; - - /* - * We're only looking at the non-realtime signals here, so we need - * some limit value. Platform differences mean at some point we just - * need to pick a reasonable value. - */ -#if defined SIGRTMIN -# define LAST_SIGNAL SIGRTMIN -#else -# define LAST_SIGNAL 32 -#endif - - - if (sigs == NULL) { - sigemptyset(&tmpsigs); - pthread_sigmask(SIG_BLOCK, NULL, &tmpsigs); - sigs = &tmpsigs; - } - - found = 0; - buf[0] = '\0'; - - for (i = 0; i < LAST_SIGNAL; i++) { - char tmp[20]; - - if (sigismember(sigs, i) > 0) { - if (found > 0) - strlcat(buf, ",", sizeof(buf)); - snprintf(tmp, sizeof(tmp), "%d", i); - strlcat(buf, tmp, sizeof(buf)); - found++; - } - } - - if (found == 0) - snprintf(buf, sizeof(buf), ""); - - zlog_debug("%s: %s", __func__, buf); -} - -static ssize_t printfrr_thread_dbg(struct fbuf *buf, struct printfrr_eargs *ea, - const struct thread *thread) -{ - static const char * const types[] = { - [THREAD_READ] = "read", - [THREAD_WRITE] = "write", - [THREAD_TIMER] = "timer", - [THREAD_EVENT] = "event", - [THREAD_READY] = "ready", - [THREAD_UNUSED] = "unused", - [THREAD_EXECUTE] = "exec", - }; - ssize_t rv = 0; - char info[16] = ""; - - if (!thread) - return bputs(buf, "{(thread *)NULL}"); - - rv += bprintfrr(buf, "{(thread *)%p arg=%p", thread, thread->arg); - - if (thread->type < array_size(types) && types[thread->type]) - rv += bprintfrr(buf, " %-6s", types[thread->type]); - else - rv += bprintfrr(buf, " INVALID(%u)", thread->type); - - switch (thread->type) { - case THREAD_READ: - case THREAD_WRITE: - snprintfrr(info, sizeof(info), "fd=%d", thread->u.fd); - break; - - case THREAD_TIMER: - snprintfrr(info, sizeof(info), "r=%pTVMud", &thread->u.sands); - break; - } - - rv += bprintfrr(buf, " %-12s %s() %s from %s:%d}", info, - thread->xref->funcname, thread->xref->dest, - thread->xref->xref.file, thread->xref->xref.line); - return rv; -} - -printfrr_ext_autoreg_p("TH", printfrr_thread); -static ssize_t printfrr_thread(struct fbuf *buf, struct printfrr_eargs *ea, - const void *ptr) -{ - const struct thread *thread = ptr; - struct timespec remain = {}; - - if (ea->fmt[0] == 'D') { - ea->fmt++; - return printfrr_thread_dbg(buf, ea, thread); - } - - if (!thread) { - /* need to jump over time formatting flag characters in the - * input format string, i.e. adjust ea->fmt! - */ - printfrr_time(buf, ea, &remain, - TIMEFMT_TIMER_DEADLINE | TIMEFMT_SKIP); - return bputch(buf, '-'); - } - - TIMEVAL_TO_TIMESPEC(&thread->u.sands, &remain); - return printfrr_time(buf, ea, &remain, TIMEFMT_TIMER_DEADLINE); -} diff --git a/lib/thread.h b/lib/thread.h deleted file mode 100644 index 128d11b6eb..0000000000 --- a/lib/thread.h +++ /dev/null @@ -1,291 +0,0 @@ -// SPDX-License-Identifier: GPL-2.0-or-later -/* Thread management routine header. - * Copyright (C) 1998 Kunihiro Ishiguro - */ - -#ifndef _ZEBRA_THREAD_H -#define _ZEBRA_THREAD_H - -#include -#include -#include -#include "monotime.h" -#include "frratomic.h" -#include "typesafe.h" -#include "xref.h" - -#ifdef __cplusplus -extern "C" { -#endif - -extern bool cputime_enabled; -extern unsigned long cputime_threshold; -/* capturing wallclock time is always enabled since it is fast (reading - * hardware TSC w/o syscalls) - */ -extern unsigned long walltime_threshold; - -struct rusage_t { -#ifdef HAVE_CLOCK_THREAD_CPUTIME_ID - struct timespec cpu; -#else - struct rusage cpu; -#endif - struct timeval real; -}; -#define RUSAGE_T struct rusage_t - -#define GETRUSAGE(X) thread_getrusage(X) - -PREDECL_LIST(thread_list); -PREDECL_HEAP(thread_timer_list); - -struct fd_handler { - /* number of pfd that fit in the allocated space of pfds. This is a - * constant and is the same for both pfds and copy. - */ - nfds_t pfdsize; - - /* file descriptors to monitor for i/o */ - struct pollfd *pfds; - /* number of pollfds stored in pfds */ - nfds_t pfdcount; - - /* chunk used for temp copy of pollfds */ - struct pollfd *copy; - /* number of pollfds stored in copy */ - nfds_t copycount; -}; - -struct xref_threadsched { - struct xref xref; - - const char *funcname; - const char *dest; - uint32_t thread_type; -}; - -/* Master of the theads. */ -struct thread_master { - char *name; - - struct thread **read; - struct thread **write; - struct thread_timer_list_head timer; - struct thread_list_head event, ready, unuse; - struct list *cancel_req; - bool canceled; - pthread_cond_t cancel_cond; - struct hash *cpu_record; - int io_pipe[2]; - int fd_limit; - struct fd_handler handler; - unsigned long alloc; - long selectpoll_timeout; - bool spin; - bool handle_signals; - pthread_mutex_t mtx; - pthread_t owner; - - bool ready_run_loop; - RUSAGE_T last_getrusage; -}; - -/* Thread itself. */ -struct thread { - uint8_t type; /* thread type */ - uint8_t add_type; /* thread type */ - struct thread_list_item threaditem; - struct thread_timer_list_item timeritem; - struct thread **ref; /* external reference (if given) */ - struct thread_master *master; /* pointer to the struct thread_master */ - void (*func)(struct thread *); /* event function */ - void *arg; /* event argument */ - union { - int val; /* second argument of the event. */ - int fd; /* file descriptor in case of r/w */ - struct timeval sands; /* rest of time sands value. */ - } u; - struct timeval real; - struct cpu_thread_history *hist; /* cache pointer to cpu_history */ - unsigned long yield; /* yield time in microseconds */ - const struct xref_threadsched *xref; /* origin location */ - pthread_mutex_t mtx; /* mutex for thread.c functions */ - bool ignore_timer_late; -}; - -#ifdef _FRR_ATTRIBUTE_PRINTFRR -#pragma FRR printfrr_ext "%pTH" (struct thread *) -#endif - -struct cpu_thread_history { - void (*func)(struct thread *); - atomic_size_t total_cpu_warn; - atomic_size_t total_wall_warn; - atomic_size_t total_starv_warn; - atomic_size_t total_calls; - atomic_size_t total_active; - struct time_stats { - atomic_size_t total, max; - } real; - struct time_stats cpu; - atomic_uint_fast32_t types; - const char *funcname; -}; - -/* Struct timeval's tv_usec one second value. */ -#define TIMER_SECOND_MICRO 1000000L - -/* Thread types. */ -#define THREAD_READ 0 -#define THREAD_WRITE 1 -#define THREAD_TIMER 2 -#define THREAD_EVENT 3 -#define THREAD_READY 4 -#define THREAD_UNUSED 5 -#define THREAD_EXECUTE 6 - -/* Thread yield time. */ -#define THREAD_YIELD_TIME_SLOT 10 * 1000L /* 10ms */ - -#define THREAD_TIMER_STRLEN 12 - -/* Macros. */ -#define THREAD_ARG(X) ((X)->arg) -#define THREAD_FD(X) ((X)->u.fd) -#define THREAD_VAL(X) ((X)->u.val) - -/* - * Please consider this macro deprecated, and do not use it in new code. - */ -#define THREAD_OFF(thread) \ - do { \ - if ((thread)) \ - thread_cancel(&(thread)); \ - } while (0) - -/* - * Macro wrappers to generate xrefs for all thread add calls. Includes - * file/line/function info for debugging/tracing. - */ -#include "lib/xref.h" - -#define _xref_t_a(addfn, type, m, f, a, v, t) \ - ({ \ - static const struct xref_threadsched _xref \ - __attribute__((used)) = { \ - .xref = XREF_INIT(XREFT_THREADSCHED, NULL, __func__), \ - .funcname = #f, \ - .dest = #t, \ - .thread_type = THREAD_ ## type, \ - }; \ - XREF_LINK(_xref.xref); \ - _thread_add_ ## addfn(&_xref, m, f, a, v, t); \ - }) \ - /* end */ - -#define thread_add_read(m,f,a,v,t) _xref_t_a(read_write, READ, m,f,a,v,t) -#define thread_add_write(m,f,a,v,t) _xref_t_a(read_write, WRITE, m,f,a,v,t) -#define thread_add_timer(m,f,a,v,t) _xref_t_a(timer, TIMER, m,f,a,v,t) -#define thread_add_timer_msec(m,f,a,v,t) _xref_t_a(timer_msec, TIMER, m,f,a,v,t) -#define thread_add_timer_tv(m,f,a,v,t) _xref_t_a(timer_tv, TIMER, m,f,a,v,t) -#define thread_add_event(m,f,a,v,t) _xref_t_a(event, EVENT, m,f,a,v,t) - -#define thread_execute(m,f,a,v) \ - ({ \ - static const struct xref_threadsched _xref \ - __attribute__((used)) = { \ - .xref = XREF_INIT(XREFT_THREADSCHED, NULL, __func__), \ - .funcname = #f, \ - .dest = NULL, \ - .thread_type = THREAD_EXECUTE, \ - }; \ - XREF_LINK(_xref.xref); \ - _thread_execute(&_xref, m, f, a, v); \ - }) /* end */ - -/* Prototypes. */ -extern struct thread_master *thread_master_create(const char *); -void thread_master_set_name(struct thread_master *master, const char *name); -extern void thread_master_free(struct thread_master *); -extern void thread_master_free_unused(struct thread_master *); - -extern void _thread_add_read_write(const struct xref_threadsched *xref, - struct thread_master *master, - void (*fn)(struct thread *), void *arg, - int fd, struct thread **tref); - -extern void _thread_add_timer(const struct xref_threadsched *xref, - struct thread_master *master, - void (*fn)(struct thread *), void *arg, long t, - struct thread **tref); - -extern void _thread_add_timer_msec(const struct xref_threadsched *xref, - struct thread_master *master, - void (*fn)(struct thread *), void *arg, - long t, struct thread **tref); - -extern void _thread_add_timer_tv(const struct xref_threadsched *xref, - struct thread_master *master, - void (*fn)(struct thread *), void *arg, - struct timeval *tv, struct thread **tref); - -extern void _thread_add_event(const struct xref_threadsched *xref, - struct thread_master *master, - void (*fn)(struct thread *), void *arg, int val, - struct thread **tref); - -extern void _thread_execute(const struct xref_threadsched *xref, - struct thread_master *master, - void (*fn)(struct thread *), void *arg, int val); - -extern void thread_cancel(struct thread **event); -extern void thread_cancel_async(struct thread_master *, struct thread **, - void *); -/* Cancel ready tasks with an arg matching 'arg' */ -extern void thread_cancel_event_ready(struct thread_master *m, void *arg); -/* Cancel all tasks with an arg matching 'arg', including timers and io */ -extern void thread_cancel_event(struct thread_master *m, void *arg); -extern struct thread *thread_fetch(struct thread_master *, struct thread *); -extern void thread_call(struct thread *); -extern unsigned long thread_timer_remain_second(struct thread *); -extern struct timeval thread_timer_remain(struct thread *); -extern unsigned long thread_timer_remain_msec(struct thread *); -extern int thread_should_yield(struct thread *); -/* set yield time for thread */ -extern void thread_set_yield_time(struct thread *, unsigned long); - -/* Internal libfrr exports */ -extern void thread_getrusage(RUSAGE_T *); -extern void thread_cmd_init(void); - -/* Returns elapsed real (wall clock) time. */ -extern unsigned long thread_consumed_time(RUSAGE_T *after, RUSAGE_T *before, - unsigned long *cpu_time_elapsed); - -/* only for use in logging functions! */ -extern pthread_key_t thread_current; -extern char *thread_timer_to_hhmmss(char *buf, int buf_size, - struct thread *t_timer); - -static inline bool thread_is_scheduled(struct thread *thread) -{ - if (thread) - return true; - - return false; -} - -/* Debug signal mask */ -void debug_signals(const sigset_t *sigs); - -static inline void thread_ignore_late_timer(struct thread *thread) -{ - thread->ignore_timer_late = true; -} - -#ifdef __cplusplus -} -#endif - -#endif /* _ZEBRA_THREAD_H */ diff --git a/lib/vty.c b/lib/vty.c index 3dcae0282f..c6bc29d968 100644 --- a/lib/vty.c +++ b/lib/vty.c @@ -22,7 +22,7 @@ #include #include "linklist.h" -#include "thread.h" +#include "event.h" #include "buffer.h" #include "command.h" #include "sockunion.h" diff --git a/lib/vty.h b/lib/vty.h index b302c14913..52453d0daa 100644 --- a/lib/vty.h +++ b/lib/vty.h @@ -18,7 +18,7 @@ #include #endif /* HAVE_LIBPCRE2_POSIX */ -#include "thread.h" +#include "event.h" #include "log.h" #include "sockunion.h" #include "qobj.h" diff --git a/lib/wheel.c b/lib/wheel.c index 4aca23481b..bd12105a3f 100644 --- a/lib/wheel.c +++ b/lib/wheel.c @@ -6,7 +6,7 @@ */ #include "zebra.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "wheel.h" #include "log.h" diff --git a/lib/workqueue.c b/lib/workqueue.c index 5477aadd65..e1ab4c48d1 100644 --- a/lib/workqueue.c +++ b/lib/workqueue.c @@ -6,7 +6,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "workqueue.h" #include "linklist.h" diff --git a/lib/zclient.c b/lib/zclient.c index 0e49d65528..2cd80cc585 100644 --- a/lib/zclient.c +++ b/lib/zclient.c @@ -14,7 +14,7 @@ #include "vrf_int.h" #include "if.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "zclient.h" #include "memory.h" #include "table.h" diff --git a/lib/zlog.c b/lib/zlog.c index e05720fd9e..d379ff8d3d 100644 --- a/lib/zlog.c +++ b/lib/zlog.c @@ -48,7 +48,7 @@ #include "frrcu.h" #include "zlog.h" #include "libfrr_trace.h" -#include "thread.h" +#include "event.h" DEFINE_MTYPE_STATIC(LIB, LOG_MESSAGE, "log message"); DEFINE_MTYPE_STATIC(LIB, LOG_TLSBUF, "log thread-local buffer"); diff --git a/lib/zlog_5424.c b/lib/zlog_5424.c index 5264dda0f8..23cad00344 100644 --- a/lib/zlog_5424.c +++ b/lib/zlog_5424.c @@ -26,7 +26,7 @@ #include "frr_pthread.h" #include "command.h" #include "monotime.h" -#include "thread.h" +#include "event.h" #include "lib/version.h" #include "lib/lib_errors.h" diff --git a/mgmtd/mgmt_be_adapter.c b/mgmtd/mgmt_be_adapter.c index 2957b2908f..22c0c4c044 100644 --- a/mgmtd/mgmt_be_adapter.c +++ b/mgmtd/mgmt_be_adapter.c @@ -7,7 +7,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "sockopt.h" #include "network.h" #include "libfrr.h" diff --git a/mgmtd/mgmt_history.c b/mgmtd/mgmt_history.c index 75def3a05e..600a5f564b 100644 --- a/mgmtd/mgmt_history.c +++ b/mgmtd/mgmt_history.c @@ -7,7 +7,7 @@ #include #include "md5.h" -#include "thread.h" +#include "event.h" #include "xref.h" #include "mgmt_fe_client.h" diff --git a/nhrpd/netlink_arp.c b/nhrpd/netlink_arp.c index 877659b4c0..552730d123 100644 --- a/nhrpd/netlink_arp.c +++ b/nhrpd/netlink_arp.c @@ -14,7 +14,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "stream.h" #include "prefix.h" #include "nhrpd.h" diff --git a/nhrpd/nhrp_cache.c b/nhrpd/nhrp_cache.c index 42c6c2fbba..ac1c8f9eb9 100644 --- a/nhrpd/nhrp_cache.c +++ b/nhrpd/nhrp_cache.c @@ -5,7 +5,7 @@ #include "zebra.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "nhrpd.h" diff --git a/nhrpd/nhrp_event.c b/nhrpd/nhrp_event.c index 9c11890831..25f5a701bc 100644 --- a/nhrpd/nhrp_event.c +++ b/nhrpd/nhrp_event.c @@ -11,7 +11,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "zbuf.h" #include "log.h" #include "nhrpd.h" diff --git a/nhrpd/nhrp_interface.c b/nhrpd/nhrp_interface.c index d396f510ed..7a0c3ba493 100644 --- a/nhrpd/nhrp_interface.c +++ b/nhrpd/nhrp_interface.c @@ -11,7 +11,7 @@ #include "zebra.h" #include "linklist.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "nhrpd.h" #include "os.h" diff --git a/nhrpd/nhrp_main.c b/nhrpd/nhrp_main.c index 10d3c8f82f..88bb1f871e 100644 --- a/nhrpd/nhrp_main.c +++ b/nhrpd/nhrp_main.c @@ -12,7 +12,7 @@ #include "zebra.h" #include "privs.h" #include "getopt.h" -#include "thread.h" +#include "event.h" #include "sigevent.h" #include "lib/version.h" #include "log.h" diff --git a/nhrpd/nhrp_multicast.c b/nhrpd/nhrp_multicast.c index cdd79e25f4..e37dfb5d8b 100644 --- a/nhrpd/nhrp_multicast.c +++ b/nhrpd/nhrp_multicast.c @@ -18,7 +18,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "nhrpd.h" #include "netlink.h" #include "znl.h" diff --git a/nhrpd/nhrp_nhs.c b/nhrpd/nhrp_nhs.c index 49f881df1f..358d1b94c5 100644 --- a/nhrpd/nhrp_nhs.c +++ b/nhrpd/nhrp_nhs.c @@ -6,7 +6,7 @@ #include "zebra.h" #include "zbuf.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "nhrpd.h" #include "nhrp_protocol.h" diff --git a/nhrpd/nhrp_packet.c b/nhrpd/nhrp_packet.c index ecf8aa0b13..d201eb6cc0 100644 --- a/nhrpd/nhrp_packet.c +++ b/nhrpd/nhrp_packet.c @@ -10,7 +10,7 @@ #include #include "nhrpd.h" #include "zbuf.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "nhrp_protocol.h" diff --git a/nhrpd/nhrp_peer.c b/nhrpd/nhrp_peer.c index 9b92cdffc3..25ce59a401 100644 --- a/nhrpd/nhrp_peer.c +++ b/nhrpd/nhrp_peer.c @@ -11,7 +11,7 @@ #include "zebra.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "network.h" diff --git a/nhrpd/nhrp_shortcut.c b/nhrpd/nhrp_shortcut.c index 90fb1d67c2..e5516ba727 100644 --- a/nhrpd/nhrp_shortcut.c +++ b/nhrpd/nhrp_shortcut.c @@ -10,7 +10,7 @@ #include "nhrpd.h" #include "table.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "log.h" #include "nhrp_protocol.h" diff --git a/nhrpd/nhrp_vc.c b/nhrpd/nhrp_vc.c index bffb2f6e94..65e9af854e 100644 --- a/nhrpd/nhrp_vc.c +++ b/nhrpd/nhrp_vc.c @@ -7,7 +7,7 @@ #include "memory.h" #include "stream.h" #include "hash.h" -#include "thread.h" +#include "event.h" #include "jhash.h" #include "nhrpd.h" diff --git a/nhrpd/vici.c b/nhrpd/vici.c index 1dbb4e4f5e..880e0c253f 100644 --- a/nhrpd/vici.c +++ b/nhrpd/vici.c @@ -11,7 +11,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "zbuf.h" #include "log.h" #include "lib_errors.h" diff --git a/ospf6d/ospf6_abr.c b/ospf6d/ospf6_abr.c index 5b2b204dd8..407de01c53 100644 --- a/ospf6d/ospf6_abr.c +++ b/ospf6d/ospf6_abr.c @@ -12,7 +12,7 @@ #include "vty.h" #include "linklist.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "plist.h" #include "filter.h" diff --git a/ospf6d/ospf6_area.c b/ospf6d/ospf6_area.c index 5795690a78..e7fefb72a7 100644 --- a/ospf6d/ospf6_area.c +++ b/ospf6d/ospf6_area.c @@ -8,7 +8,7 @@ #include "log.h" #include "memory.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "if.h" diff --git a/ospf6d/ospf6_asbr.c b/ospf6d/ospf6_asbr.c index 57c873b53b..8924c00a58 100644 --- a/ospf6d/ospf6_asbr.c +++ b/ospf6d/ospf6_asbr.c @@ -13,7 +13,7 @@ #include "routemap.h" #include "table.h" #include "plist.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "lib/northbound_cli.h" diff --git a/ospf6d/ospf6_bfd.c b/ospf6d/ospf6_bfd.c index 6cc9c3013b..1b879ae280 100644 --- a/ospf6d/ospf6_bfd.c +++ b/ospf6d/ospf6_bfd.c @@ -11,7 +11,7 @@ #include "linklist.h" #include "memory.h" #include "prefix.h" -#include "thread.h" +#include "event.h" #include "buffer.h" #include "stream.h" #include "zclient.h" diff --git a/ospf6d/ospf6_flood.c b/ospf6d/ospf6_flood.c index d519b0e119..a782d97304 100644 --- a/ospf6d/ospf6_flood.c +++ b/ospf6d/ospf6_flood.c @@ -6,7 +6,7 @@ #include #include "log.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "vty.h" #include "command.h" diff --git a/ospf6d/ospf6_interface.c b/ospf6d/ospf6_interface.c index 7afb47c752..5f0c3cf934 100644 --- a/ospf6d/ospf6_interface.c +++ b/ospf6d/ospf6_interface.c @@ -9,7 +9,7 @@ #include "if.h" #include "log.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "plist.h" #include "zclient.h" diff --git a/ospf6d/ospf6_intra.c b/ospf6d/ospf6_intra.c index e7ce2f5f72..d57e56bb37 100644 --- a/ospf6d/ospf6_intra.c +++ b/ospf6d/ospf6_intra.c @@ -7,7 +7,7 @@ #include "log.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "if.h" #include "prefix.h" diff --git a/ospf6d/ospf6_lsa.c b/ospf6d/ospf6_lsa.c index fe085b4cb4..d93115adc1 100644 --- a/ospf6d/ospf6_lsa.c +++ b/ospf6d/ospf6_lsa.c @@ -12,7 +12,7 @@ #include "vty.h" #include "command.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "checksum.h" #include "frrstr.h" diff --git a/ospf6d/ospf6_main.c b/ospf6d/ospf6_main.c index abc460249d..6b5134a2b8 100644 --- a/ospf6d/ospf6_main.c +++ b/ospf6d/ospf6_main.c @@ -9,7 +9,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "log.h" #include "command.h" #include "vty.h" diff --git a/ospf6d/ospf6_message.c b/ospf6d/ospf6_message.c index a499190a11..45d03bafe7 100644 --- a/ospf6d/ospf6_message.c +++ b/ospf6d/ospf6_message.c @@ -9,7 +9,7 @@ #include "log.h" #include "vty.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "lib_errors.h" #include "checksum.h" diff --git a/ospf6d/ospf6_neighbor.c b/ospf6d/ospf6_neighbor.c index 5ab5a49a4b..c90603e1ad 100644 --- a/ospf6d/ospf6_neighbor.c +++ b/ospf6d/ospf6_neighbor.c @@ -7,7 +7,7 @@ #include "log.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "vty.h" #include "command.h" diff --git a/ospf6d/ospf6_nssa.c b/ospf6d/ospf6_nssa.c index d62a3a6322..cd3b742def 100644 --- a/ospf6d/ospf6_nssa.c +++ b/ospf6d/ospf6_nssa.c @@ -13,7 +13,7 @@ #include "vty.h" #include "linklist.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "plist.h" #include "filter.h" diff --git a/ospf6d/ospf6_spf.c b/ospf6d/ospf6_spf.c index 112934bf1e..474cca0f3c 100644 --- a/ospf6d/ospf6_spf.c +++ b/ospf6d/ospf6_spf.c @@ -13,7 +13,7 @@ #include "vty.h" #include "prefix.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "lib_errors.h" #include "ospf6_lsa.h" diff --git a/ospf6d/ospf6_top.c b/ospf6d/ospf6_top.c index bd5aedb45e..0298483863 100644 --- a/ospf6d/ospf6_top.c +++ b/ospf6d/ospf6_top.c @@ -11,7 +11,7 @@ #include "linklist.h" #include "prefix.h" #include "table.h" -#include "thread.h" +#include "event.h" #include "command.h" #include "defaults.h" #include "lib/json.h" diff --git a/ospf6d/ospf6d.c b/ospf6d/ospf6d.c index 257a0f2b0e..eea487012c 100644 --- a/ospf6d/ospf6d.c +++ b/ospf6d/ospf6d.c @@ -5,7 +5,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "vty.h" #include "command.h" diff --git a/ospf6d/ospf6d.h b/ospf6d/ospf6d.h index 234a0e881d..3a2eb71c3e 100644 --- a/ospf6d/ospf6d.h +++ b/ospf6d/ospf6d.h @@ -7,7 +7,7 @@ #define OSPF6D_H #include "libospf.h" -#include "thread.h" +#include "event.h" #include "memory.h" DECLARE_MGROUP(OSPF6D); diff --git a/ospfclient/ospf_apiclient.c b/ospfclient/ospf_apiclient.c index c5bbc01501..a29c422277 100644 --- a/ospfclient/ospf_apiclient.c +++ b/ospfclient/ospf_apiclient.c @@ -8,7 +8,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "linklist.h" #include "if.h" diff --git a/ospfclient/ospfclient.c b/ospfclient/ospfclient.c index cbc53ad353..970a039d81 100644 --- a/ospfclient/ospfclient.c +++ b/ospfclient/ospfclient.c @@ -43,7 +43,7 @@ struct zebra_privs_t ospfd_privs = {.user = NULL, free to use any thread library (like pthreads). */ #include "ospfd/ospf_dump.h" /* for ospf_lsa_header_dump */ -#include "thread.h" +#include "event.h" #include "log.h" /* Local portnumber for async channel. Note that OSPF API library will also diff --git a/ospfd/ospf_abr.c b/ospfd/ospf_abr.c index 8f177cbce1..91f4d77a86 100644 --- a/ospfd/ospf_abr.c +++ b/ospfd/ospf_abr.c @@ -7,7 +7,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/ospfd/ospf_api.c b/ospfd/ospf_api.c index 3cb1287be5..922696f8bd 100644 --- a/ospfd/ospf_api.c +++ b/ospfd/ospf_api.c @@ -18,7 +18,7 @@ #include "vty.h" #include "stream.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "sockunion.h" /* for inet_aton() */ #include "buffer.h" diff --git a/ospfd/ospf_apiserver.c b/ospfd/ospf_apiserver.c index 086b5660b1..cc1ca66470 100644 --- a/ospfd/ospf_apiserver.c +++ b/ospfd/ospf_apiserver.c @@ -18,7 +18,7 @@ #include "vty.h" #include "stream.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "sockunion.h" /* for inet_aton() */ #include "buffer.h" diff --git a/ospfd/ospf_asbr.c b/ospfd/ospf_asbr.c index 6eada0b1a4..85b5377e5f 100644 --- a/ospfd/ospf_asbr.c +++ b/ospfd/ospf_asbr.c @@ -6,7 +6,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/ospfd/ospf_ase.c b/ospfd/ospf_ase.c index b43f0cb378..ad7dac0abd 100644 --- a/ospfd/ospf_ase.c +++ b/ospfd/ospf_ase.c @@ -6,7 +6,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "hash.h" #include "linklist.h" diff --git a/ospfd/ospf_bfd.c b/ospfd/ospf_bfd.c index 0b0016745d..3ed54d3bfb 100644 --- a/ospfd/ospf_bfd.c +++ b/ospfd/ospf_bfd.c @@ -12,7 +12,7 @@ #include "linklist.h" #include "memory.h" #include "prefix.h" -#include "thread.h" +#include "event.h" #include "buffer.h" #include "stream.h" #include "zclient.h" diff --git a/ospfd/ospf_dump.c b/ospfd/ospf_dump.c index b74b84e37d..d712d7b5fe 100644 --- a/ospfd/ospf_dump.c +++ b/ospfd/ospf_dump.c @@ -9,7 +9,7 @@ #include "lib/bfd.h" #include "monotime.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "command.h" #include "stream.h" diff --git a/ospfd/ospf_ext.c b/ospfd/ospf_ext.c index 5faaed076b..28f368e37f 100644 --- a/ospfd/ospf_ext.c +++ b/ospfd/ospf_ext.c @@ -25,7 +25,7 @@ #include "vty.h" #include "stream.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "sockunion.h" /* for inet_aton() */ #include "network.h" diff --git a/ospfd/ospf_flood.c b/ospfd/ospf_flood.c index d0453bbc4a..99bc4249fa 100644 --- a/ospfd/ospf_flood.c +++ b/ospfd/ospf_flood.c @@ -12,7 +12,7 @@ #include "if.h" #include "command.h" #include "table.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "log.h" #include "zclient.h" diff --git a/ospfd/ospf_gr_helper.c b/ospfd/ospf_gr_helper.c index 07ce0d66ea..522c9b71b6 100644 --- a/ospfd/ospf_gr_helper.c +++ b/ospfd/ospf_gr_helper.c @@ -8,7 +8,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/ospfd/ospf_ia.c b/ospfd/ospf_ia.c index d3c9626d9a..b4bf6cf3d0 100644 --- a/ospfd/ospf_ia.c +++ b/ospfd/ospf_ia.c @@ -7,7 +7,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "hash.h" #include "linklist.h" diff --git a/ospfd/ospf_interface.c b/ospfd/ospf_interface.c index 4ea367ecad..6f0faabc73 100644 --- a/ospfd/ospf_interface.c +++ b/ospfd/ospf_interface.c @@ -6,7 +6,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "prefix.h" #include "if.h" diff --git a/ospfd/ospf_ism.c b/ospfd/ospf_ism.c index 173ebdf207..bc236406d6 100644 --- a/ospfd/ospf_ism.c +++ b/ospfd/ospf_ism.c @@ -7,7 +7,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "prefix.h" #include "if.h" diff --git a/ospfd/ospf_ldp_sync.c b/ospfd/ospf_ldp_sync.c index d3da5003aa..c1f245d3be 100644 --- a/ospfd/ospf_ldp_sync.c +++ b/ospfd/ospf_ldp_sync.c @@ -9,7 +9,7 @@ #include "monotime.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "table.h" #include "vty.h" diff --git a/ospfd/ospf_lsa.c b/ospfd/ospf_lsa.c index 5c3f184c5d..9ad1fca74f 100644 --- a/ospfd/ospf_lsa.c +++ b/ospfd/ospf_lsa.c @@ -14,7 +14,7 @@ #include "memory.h" #include "stream.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "sockunion.h" /* for inet_aton() */ #include "checksum.h" diff --git a/ospfd/ospf_main.c b/ospfd/ospf_main.c index 05fc5c95d1..7c591c0526 100644 --- a/ospfd/ospf_main.c +++ b/ospfd/ospf_main.c @@ -9,7 +9,7 @@ #include #include "bfd.h" #include "getopt.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "linklist.h" #include "if.h" diff --git a/ospfd/ospf_neighbor.c b/ospfd/ospf_neighbor.c index 8338c43077..d341b2dba1 100644 --- a/ospfd/ospf_neighbor.c +++ b/ospfd/ospf_neighbor.c @@ -11,7 +11,7 @@ #include "prefix.h" #include "memory.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "stream.h" #include "table.h" #include "log.h" diff --git a/ospfd/ospf_network.c b/ospfd/ospf_network.c index e89ad020b1..ba74e67a32 100644 --- a/ospfd/ospf_network.c +++ b/ospfd/ospf_network.c @@ -6,7 +6,7 @@ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "prefix.h" #include "if.h" diff --git a/ospfd/ospf_nsm.c b/ospfd/ospf_nsm.c index 64bb454006..57aa492543 100644 --- a/ospfd/ospf_nsm.c +++ b/ospfd/ospf_nsm.c @@ -7,7 +7,7 @@ #include -#include "thread.h" +#include "event.h" #include "memory.h" #include "hash.h" #include "linklist.h" diff --git a/ospfd/ospf_opaque.c b/ospfd/ospf_opaque.c index fa04f092dc..0626f10600 100644 --- a/ospfd/ospf_opaque.c +++ b/ospfd/ospf_opaque.c @@ -16,7 +16,7 @@ #include "vty.h" #include "stream.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "sockunion.h" /* for inet_aton() */ #include "printfrr.h" diff --git a/ospfd/ospf_packet.c b/ospfd/ospf_packet.c index c4bccb3bc4..1462ad48f1 100644 --- a/ospfd/ospf_packet.c +++ b/ospfd/ospf_packet.c @@ -7,7 +7,7 @@ #include #include "monotime.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "linklist.h" #include "prefix.h" diff --git a/ospfd/ospf_ri.c b/ospfd/ospf_ri.c index a808ddc9f6..2503f39a3c 100644 --- a/ospfd/ospf_ri.c +++ b/ospfd/ospf_ri.c @@ -20,7 +20,7 @@ #include "vty.h" #include "stream.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "sockunion.h" /* for inet_aton() */ #include "mpls.h" diff --git a/ospfd/ospf_spf.c b/ospfd/ospf_spf.c index f731d1cf18..272ef5ce0d 100644 --- a/ospfd/ospf_spf.c +++ b/ospfd/ospf_spf.c @@ -6,7 +6,7 @@ #include #include "monotime.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "hash.h" #include "linklist.h" diff --git a/ospfd/ospf_sr.c b/ospfd/ospf_sr.c index d1af08c652..00422e6b9f 100644 --- a/ospfd/ospf_sr.c +++ b/ospfd/ospf_sr.c @@ -37,7 +37,7 @@ #include "sockunion.h" /* for inet_aton() */ #include "stream.h" #include "table.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "zclient.h" #include "sbuf.h" diff --git a/ospfd/ospf_te.c b/ospfd/ospf_te.c index e3869abe59..2c4bd17d91 100644 --- a/ospfd/ospf_te.c +++ b/ospfd/ospf_te.c @@ -24,7 +24,7 @@ #include "vty.h" #include "stream.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "hash.h" #include "sockunion.h" /* for inet_aton() */ #include "network.h" diff --git a/ospfd/ospf_vty.c b/ospfd/ospf_vty.c index 262f805468..610422bd54 100644 --- a/ospfd/ospf_vty.c +++ b/ospfd/ospf_vty.c @@ -10,7 +10,7 @@ #include "printfrr.h" #include "monotime.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "table.h" #include "vty.h" diff --git a/ospfd/ospf_zebra.c b/ospfd/ospf_zebra.c index d321a69668..67da49c21b 100644 --- a/ospfd/ospf_zebra.c +++ b/ospfd/ospf_zebra.c @@ -6,7 +6,7 @@ #include -#include "thread.h" +#include "event.h" #include "command.h" #include "network.h" #include "prefix.h" diff --git a/ospfd/ospfd.c b/ospfd/ospfd.c index 0296d9d9f5..c3edc9dd59 100644 --- a/ospfd/ospfd.c +++ b/ospfd/ospfd.c @@ -5,7 +5,7 @@ #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "linklist.h" diff --git a/pathd/path_main.c b/pathd/path_main.c index 3d35b9f9b3..7d54123d7f 100644 --- a/pathd/path_main.c +++ b/pathd/path_main.c @@ -6,7 +6,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "command.h" #include "log.h" #include "memory.h" diff --git a/pathd/path_pcep_config.c b/pathd/path_pcep_config.c index 21d127bcfe..0e63b56f57 100644 --- a/pathd/path_pcep_config.c +++ b/pathd/path_pcep_config.c @@ -13,7 +13,7 @@ #include "pathd/path_pcep.h" #include "pathd/path_pcep_config.h" #include "pathd/path_pcep_debug.h" -#include "thread.h" +#include "event.h" #define MAX_XPATH 256 #define MAX_FLOAT_LEN 22 diff --git a/pathd/path_zebra.c b/pathd/path_zebra.c index efc016f750..28daac60bd 100644 --- a/pathd/path_zebra.c +++ b/pathd/path_zebra.c @@ -5,7 +5,7 @@ #include -#include "thread.h" +#include "event.h" #include "log.h" #include "lib_errors.h" #include "if.h" diff --git a/pbrd/pbr_main.c b/pbrd/pbr_main.c index 9b34815c4d..2941dbeca7 100644 --- a/pbrd/pbr_main.c +++ b/pbrd/pbr_main.c @@ -8,7 +8,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "linklist.h" #include "if.h" diff --git a/pbrd/pbr_map.c b/pbrd/pbr_map.c index 0e18f1198d..1519af4eef 100644 --- a/pbrd/pbr_map.c +++ b/pbrd/pbr_map.c @@ -6,7 +6,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "linklist.h" #include "prefix.h" #include "table.h" diff --git a/pbrd/pbr_zebra.c b/pbrd/pbr_zebra.c index 1b18853d2b..c2c785fb6b 100644 --- a/pbrd/pbr_zebra.c +++ b/pbrd/pbr_zebra.c @@ -6,7 +6,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "command.h" #include "network.h" #include "prefix.h" diff --git a/pimd/pim6_mld.c b/pimd/pim6_mld.c index fa699cca5e..c722add848 100644 --- a/pimd/pim6_mld.c +++ b/pimd/pim6_mld.c @@ -19,7 +19,7 @@ #include "lib/jhash.h" #include "lib/prefix.h" #include "lib/checksum.h" -#include "lib/thread.h" +#include "lib/event.h" #include "termtable.h" #include "pimd/pim6_mld.h" diff --git a/pimd/pim_ifchannel.c b/pimd/pim_ifchannel.c index 136498beb7..98f594d0ca 100644 --- a/pimd/pim_ifchannel.c +++ b/pimd/pim_ifchannel.c @@ -7,7 +7,7 @@ #include #include "linklist.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "if.h" #include "vrf.h" diff --git a/pimd/pim_main.c b/pimd/pim_main.c index ce4326c616..0a782455ca 100644 --- a/pimd/pim_main.c +++ b/pimd/pim_main.c @@ -11,7 +11,7 @@ #include "lib/version.h" #include #include "command.h" -#include "thread.h" +#include "event.h" #include #include "memory.h" diff --git a/pimd/pim_msdp.c b/pimd/pim_msdp.c index 9d29a33a52..b3d30defe1 100644 --- a/pimd/pim_msdp.c +++ b/pimd/pim_msdp.c @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/pimd/pim_msdp_packet.c b/pimd/pim_msdp_packet.c index a6f318e61e..c3dd076967 100644 --- a/pimd/pim_msdp_packet.c +++ b/pimd/pim_msdp_packet.c @@ -8,7 +8,7 @@ #include #include #include -#include +#include "event.h" #include #include diff --git a/pimd/pim_msdp_socket.c b/pimd/pim_msdp_socket.c index a6b5ee11b6..3bf6b1d74b 100644 --- a/pimd/pim_msdp_socket.c +++ b/pimd/pim_msdp_socket.c @@ -9,7 +9,7 @@ #include #include #include -#include +#include "event.h" #include #include #include diff --git a/pimd/pim_pim.c b/pimd/pim_pim.c index 1248db3de4..697266e2b4 100644 --- a/pimd/pim_pim.c +++ b/pimd/pim_pim.c @@ -7,7 +7,7 @@ #include #include "log.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "if.h" #include "network.h" diff --git a/pimd/pim_register.c b/pimd/pim_register.c index 5144fe67b8..42b013815a 100644 --- a/pimd/pim_register.c +++ b/pimd/pim_register.c @@ -9,7 +9,7 @@ #include "log.h" #include "if.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "vty.h" #include "plist.h" diff --git a/pimd/pim_time.c b/pimd/pim_time.c index c9555f5310..3f3d67f591 100644 --- a/pimd/pim_time.c +++ b/pimd/pim_time.c @@ -11,7 +11,7 @@ #include #include "log.h" -#include "thread.h" +#include "event.h" #include "lib_errors.h" #include "pim_time.h" diff --git a/pimd/pim_time.h b/pimd/pim_time.h index fd1e79e2bb..a0707407e5 100644 --- a/pimd/pim_time.h +++ b/pimd/pim_time.h @@ -10,7 +10,7 @@ #include #include -#include "thread.h" +#include "event.h" int64_t pim_time_monotonic_sec(void); int64_t pim_time_monotonic_dsec(void); diff --git a/pimd/pim_upstream.c b/pimd/pim_upstream.c index b0f1158596..1ee044197a 100644 --- a/pimd/pim_upstream.c +++ b/pimd/pim_upstream.c @@ -9,7 +9,7 @@ #include "log.h" #include "zclient.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "linklist.h" #include "vty.h" #include "plist.h" diff --git a/pimd/pim_zlookup.c b/pimd/pim_zlookup.c index 08807d0dcc..5f574eb5b4 100644 --- a/pimd/pim_zlookup.c +++ b/pimd/pim_zlookup.c @@ -11,7 +11,7 @@ #include "zclient.h" #include "stream.h" #include "network.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "vty.h" #include "lib_errors.h" diff --git a/python/xref2vtysh.py b/python/xref2vtysh.py index b5873a3aac..c325979d24 100644 --- a/python/xref2vtysh.py +++ b/python/xref2vtysh.py @@ -44,7 +44,7 @@ daemon_flags = { "lib/routemap.c": "VTYSH_RMAP", "lib/routemap_cli.c": "VTYSH_RMAP", "lib/spf_backoff.c": "VTYSH_ISISD", - "lib/thread.c": "VTYSH_ALL", + "lib/event.c": "VTYSH_ALL", "lib/vrf.c": "VTYSH_VRF", "lib/vty.c": "VTYSH_ALL", } diff --git a/ripd/rip_interface.c b/ripd/rip_interface.c index 3e62321725..309c18f9c2 100644 --- a/ripd/rip_interface.c +++ b/ripd/rip_interface.c @@ -14,7 +14,7 @@ #include "table.h" #include "log.h" #include "stream.h" -#include "thread.h" +#include "event.h" #include "zclient.h" #include "filter.h" #include "sockopt.h" diff --git a/ripd/rip_main.c b/ripd/rip_main.c index e26424adeb..b6166b14c8 100644 --- a/ripd/rip_main.c +++ b/ripd/rip_main.c @@ -7,7 +7,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "command.h" #include "memory.h" #include "prefix.h" diff --git a/ripd/rip_peer.c b/ripd/rip_peer.c index a3cba598d2..85cd971509 100644 --- a/ripd/rip_peer.c +++ b/ripd/rip_peer.c @@ -9,7 +9,7 @@ #include "prefix.h" #include "command.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "ripd/ripd.h" diff --git a/ripd/ripd.c b/ripd/ripd.c index bde7e858f1..8b21af92ff 100644 --- a/ripd/ripd.c +++ b/ripd/ripd.c @@ -11,7 +11,7 @@ #include "command.h" #include "prefix.h" #include "table.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "log.h" #include "stream.h" diff --git a/ripngd/ripng_interface.c b/ripngd/ripng_interface.c index 1fc6f2553e..919f3c81d9 100644 --- a/ripngd/ripng_interface.c +++ b/ripngd/ripng_interface.c @@ -17,7 +17,7 @@ #include "zclient.h" #include "command.h" #include "agg_table.h" -#include "thread.h" +#include "event.h" #include "privs.h" #include "vrf.h" #include "lib_errors.h" diff --git a/ripngd/ripng_main.c b/ripngd/ripng_main.c index 14e69834ca..dcdd0c1f78 100644 --- a/ripngd/ripng_main.c +++ b/ripngd/ripng_main.c @@ -12,7 +12,7 @@ #include "vty.h" #include "command.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "log.h" #include "prefix.h" #include "if.h" diff --git a/ripngd/ripng_peer.c b/ripngd/ripng_peer.c index 75a9ed77fe..30b11aa143 100644 --- a/ripngd/ripng_peer.c +++ b/ripngd/ripng_peer.c @@ -13,7 +13,7 @@ #include "prefix.h" #include "command.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "ripngd/ripngd.h" diff --git a/ripngd/ripngd.c b/ripngd/ripngd.c index f01371f41e..24ff1bcd07 100644 --- a/ripngd/ripngd.c +++ b/ripngd/ripngd.c @@ -8,7 +8,7 @@ #include "prefix.h" #include "filter.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "memory.h" #include "if.h" #include "stream.h" diff --git a/sharpd/sharp_logpump.c b/sharpd/sharp_logpump.c index cadd818953..9ef9b2d0f4 100644 --- a/sharpd/sharp_logpump.c +++ b/sharpd/sharp_logpump.c @@ -11,7 +11,7 @@ #include "prefix.h" #include "nexthop.h" #include "log.h" -#include "thread.h" +#include "event.h" #include "vrf.h" #include "zclient.h" #include "frr_pthread.h" diff --git a/sharpd/sharp_main.c b/sharpd/sharp_main.c index 9d33fc89a7..1895a49d8e 100644 --- a/sharpd/sharp_main.c +++ b/sharpd/sharp_main.c @@ -8,7 +8,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "prefix.h" #include "linklist.h" #include "if.h" diff --git a/sharpd/sharp_zebra.c b/sharpd/sharp_zebra.c index df06f5537e..3c19435871 100644 --- a/sharpd/sharp_zebra.c +++ b/sharpd/sharp_zebra.c @@ -6,7 +6,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "command.h" #include "network.h" #include "prefix.h" diff --git a/staticd/static_main.c b/staticd/static_main.c index d429162196..1d9b0d16cb 100644 --- a/staticd/static_main.c +++ b/staticd/static_main.c @@ -8,7 +8,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "command.h" #include "log.h" #include "memory.h" diff --git a/staticd/static_zebra.c b/staticd/static_zebra.c index f220b476fb..6c59f04ee6 100644 --- a/staticd/static_zebra.c +++ b/staticd/static_zebra.c @@ -6,7 +6,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "command.h" #include "network.h" #include "prefix.h" diff --git a/tests/helpers/c/main.c b/tests/helpers/c/main.c index bb8acd2c44..209b4ad861 100644 --- a/tests/helpers/c/main.c +++ b/tests/helpers/c/main.c @@ -6,7 +6,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "memory.h" diff --git a/tests/isisd/test_fuzz_isis_tlv.c b/tests/isisd/test_fuzz_isis_tlv.c index 8f0b92d0fc..2443f3866f 100644 --- a/tests/isisd/test_fuzz_isis_tlv.c +++ b/tests/isisd/test_fuzz_isis_tlv.c @@ -9,7 +9,7 @@ #include "memory.h" #include "sbuf.h" #include "stream.h" -#include "thread.h" +#include "event.h" #include "isisd/isis_circuit.h" #include "isisd/isis_tlvs.h" diff --git a/tests/isisd/test_isis_spf.c b/tests/isisd/test_isis_spf.c index 0cccf05678..37c22c5439 100644 --- a/tests/isisd/test_isis_spf.c +++ b/tests/isisd/test_isis_spf.c @@ -8,7 +8,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "log.h" diff --git a/tests/lib/cli/common_cli.c b/tests/lib/cli/common_cli.c index 29dad7d80f..4170383389 100644 --- a/tests/lib/cli/common_cli.c +++ b/tests/lib/cli/common_cli.c @@ -8,7 +8,7 @@ #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "memory.h" diff --git a/tests/lib/cxxcompat.c b/tests/lib/cxxcompat.c index 7aab88eeb9..85dcea9e80 100644 --- a/tests/lib/cxxcompat.c +++ b/tests/lib/cxxcompat.c @@ -78,7 +78,7 @@ #include "lib/stream.h" #include "lib/table.h" #include "lib/termtable.h" -#include "lib/thread.h" +#include "event.h" #include "lib/typesafe.h" #include "lib/typerb.h" #include "lib/vector.h" diff --git a/tests/lib/northbound/test_oper_data.c b/tests/lib/northbound/test_oper_data.c index 3abda75f40..b841fea25e 100644 --- a/tests/lib/northbound/test_oper_data.c +++ b/tests/lib/northbound/test_oper_data.c @@ -6,7 +6,7 @@ #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "memory.h" diff --git a/tests/lib/test_assert.c b/tests/lib/test_assert.c index d68ee8a819..13f8daa5f3 100644 --- a/tests/lib/test_assert.c +++ b/tests/lib/test_assert.c @@ -22,7 +22,7 @@ static void func_for_bt(int number) #include #include "lib/zlog.h" -#include "lib/thread.h" +#include "event.h" #include "lib/sigevent.h" int main(int argc, char **argv) diff --git a/tests/lib/test_grpc.cpp b/tests/lib/test_grpc.cpp index 282161c3df..187b8091df 100644 --- a/tests/lib/test_grpc.cpp +++ b/tests/lib/test_grpc.cpp @@ -14,7 +14,7 @@ #include "libfrr.h" #include "routing_nb.h" #include "northbound_cli.h" -#include "thread.h" +#include "event.h" #include "vrf.h" #include "vty.h" diff --git a/tests/lib/test_heavy.c b/tests/lib/test_heavy.c index 2d54fe6c68..7bce1584ec 100644 --- a/tests/lib/test_heavy.c +++ b/tests/lib/test_heavy.c @@ -13,7 +13,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "memory.h" diff --git a/tests/lib/test_heavy_thread.c b/tests/lib/test_heavy_thread.c index afbd205451..0cee1e863c 100644 --- a/tests/lib/test_heavy_thread.c +++ b/tests/lib/test_heavy_thread.c @@ -14,7 +14,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "memory.h" diff --git a/tests/lib/test_heavy_wq.c b/tests/lib/test_heavy_wq.c index 9b2cfa5730..e09c4885c5 100644 --- a/tests/lib/test_heavy_wq.c +++ b/tests/lib/test_heavy_wq.c @@ -13,7 +13,7 @@ */ #include -#include "thread.h" +#include "event.h" #include "vty.h" #include "command.h" #include "memory.h" diff --git a/tests/lib/test_stream.c b/tests/lib/test_stream.c index 015dc41db1..8bf6f7fcc1 100644 --- a/tests/lib/test_stream.c +++ b/tests/lib/test_stream.c @@ -6,7 +6,7 @@ #include #include -#include +#include "event.h" #include "printfrr.h" diff --git a/tests/lib/test_timer_correctness.c b/tests/lib/test_timer_correctness.c index 37eb4939a1..fa197cd1c9 100644 --- a/tests/lib/test_timer_correctness.c +++ b/tests/lib/test_timer_correctness.c @@ -16,7 +16,7 @@ #include "memory.h" #include "prng.h" -#include "thread.h" +#include "event.h" #define SCHEDULE_TIMERS 800 #define REMOVE_TIMERS 200 diff --git a/tests/lib/test_timer_performance.c b/tests/lib/test_timer_performance.c index 21976e8d31..5af0604d1b 100644 --- a/tests/lib/test_timer_performance.c +++ b/tests/lib/test_timer_performance.c @@ -14,7 +14,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "prng.h" #define SCHEDULE_TIMERS 1000000 diff --git a/tests/ospfd/test_ospf_spf.c b/tests/ospfd/test_ospf_spf.c index b8a2aef69e..d40b37b927 100644 --- a/tests/ospfd/test_ospf_spf.c +++ b/tests/ospfd/test_ospf_spf.c @@ -1,7 +1,7 @@ #include #include "getopt.h" -#include "thread.h" +#include "event.h" #include #include "vty.h" #include "command.h" diff --git a/vrrpd/vrrp.h b/vrrpd/vrrp.h index 9da9c8a518..5cdba8677d 100644 --- a/vrrpd/vrrp.h +++ b/vrrpd/vrrp.h @@ -18,7 +18,7 @@ #include "lib/northbound.h" #include "lib/privs.h" #include "lib/stream.h" -#include "lib/thread.h" +#include "lib/event.h" #include "lib/vty.h" /* Global definitions */ diff --git a/vrrpd/vrrp_main.c b/vrrpd/vrrp_main.c index d3d230d205..90c3a77721 100644 --- a/vrrpd/vrrp_main.c +++ b/vrrpd/vrrp_main.c @@ -18,7 +18,7 @@ #include "lib/nexthop.h" #include "lib/privs.h" #include "lib/sigevent.h" -#include "lib/thread.h" +#include "lib/event.h" #include "lib/vrf.h" #include "lib/vty.h" diff --git a/watchfrr/watchfrr.c b/watchfrr/watchfrr.c index 84f4d02a8a..eb32cc9667 100644 --- a/watchfrr/watchfrr.c +++ b/watchfrr/watchfrr.c @@ -6,7 +6,7 @@ */ #include -#include +#include "event.h" #include #include #include diff --git a/zebra/if_netlink.c b/zebra/if_netlink.c index 21cad01374..8fb5b28c3d 100644 --- a/zebra/if_netlink.c +++ b/zebra/if_netlink.c @@ -33,7 +33,7 @@ #include "table.h" #include "memory.h" #include "rib.h" -#include "thread.h" +#include "event.h" #include "privs.h" #include "nexthop.h" #include "vrf.h" diff --git a/zebra/irdp_interface.c b/zebra/irdp_interface.c index 0c9b6f3d39..28d6b89ed4 100644 --- a/zebra/irdp_interface.c +++ b/zebra/irdp_interface.c @@ -24,7 +24,7 @@ #include "connected.h" #include "log.h" #include "zclient.h" -#include "thread.h" +#include "event.h" #include "lib_errors.h" #include "zebra/interface.h" #include "zebra/rtadv.h" diff --git a/zebra/irdp_main.c b/zebra/irdp_main.c index ddcad92bdc..8940970208 100644 --- a/zebra/irdp_main.c +++ b/zebra/irdp_main.c @@ -32,7 +32,7 @@ #include "connected.h" #include "log.h" #include "zclient.h" -#include "thread.h" +#include "event.h" #include "privs.h" #include "libfrr.h" #include "lib_errors.h" diff --git a/zebra/irdp_packet.c b/zebra/irdp_packet.c index 4f4f3772dc..7903f14e1a 100644 --- a/zebra/irdp_packet.c +++ b/zebra/irdp_packet.c @@ -34,7 +34,7 @@ #include "sockunion.h" #include "sockunion.h" #include "stream.h" -#include "thread.h" +#include "event.h" #include "vty.h" #include "zclient.h" #include "lib_errors.h" diff --git a/zebra/kernel_netlink.c b/zebra/kernel_netlink.c index a980b56b33..fdf4b850d3 100644 --- a/zebra/kernel_netlink.c +++ b/zebra/kernel_netlink.c @@ -15,7 +15,7 @@ #include "table.h" #include "memory.h" #include "rib.h" -#include "thread.h" +#include "event.h" #include "privs.h" #include "nexthop.h" #include "vrf.h" diff --git a/zebra/kernel_socket.c b/zebra/kernel_socket.c index 915fd087fe..04f484cd9a 100644 --- a/zebra/kernel_socket.c +++ b/zebra/kernel_socket.c @@ -1255,7 +1255,7 @@ int rtm_write(int message, union sockunion *dest, union sockunion *mask, } -#include "thread.h" +#include "event.h" #include "zebra/zserv.h" /* For debug purpose. */ diff --git a/zebra/label_manager.h b/zebra/label_manager.h index c0bd8e369f..e2f5d19019 100644 --- a/zebra/label_manager.h +++ b/zebra/label_manager.h @@ -14,7 +14,7 @@ #include #include "lib/linklist.h" -#include "lib/thread.h" +#include "event.h" #include "lib/hook.h" #include "zebra/zserv.h" diff --git a/zebra/main.c b/zebra/main.c index c40a03551d..49b928d09c 100644 --- a/zebra/main.c +++ b/zebra/main.c @@ -8,7 +8,7 @@ #include #include "getopt.h" #include "command.h" -#include "thread.h" +#include "event.h" #include "filter.h" #include "memory.h" #include "prefix.h" diff --git a/zebra/rt_netlink.c b/zebra/rt_netlink.c index e4ddbd95d7..e92fb19151 100644 --- a/zebra/rt_netlink.c +++ b/zebra/rt_netlink.c @@ -38,7 +38,7 @@ #include "table.h" #include "memory.h" #include "rib.h" -#include "thread.h" +#include "event.h" #include "privs.h" #include "nexthop.h" #include "vrf.h" diff --git a/zebra/rtadv.c b/zebra/rtadv.c index 1e0769fb6d..7f9a8ed00c 100644 --- a/zebra/rtadv.c +++ b/zebra/rtadv.c @@ -9,7 +9,7 @@ #include "memory.h" #include "sockopt.h" -#include "thread.h" +#include "event.h" #include "if.h" #include "stream.h" #include "log.h" diff --git a/zebra/table_manager.h b/zebra/table_manager.h index deed4fa30b..eb460c291f 100644 --- a/zebra/table_manager.h +++ b/zebra/table_manager.h @@ -9,7 +9,7 @@ #include #include "lib/linklist.h" -#include "lib/thread.h" +#include "event.h" #include "lib/ns.h" #include "zebra/zserv.h" diff --git a/zebra/zebra_fpm.c b/zebra/zebra_fpm.c index 15765b5e18..f7de5eb0c6 100644 --- a/zebra/zebra_fpm.c +++ b/zebra/zebra_fpm.c @@ -11,7 +11,7 @@ #include "log.h" #include "libfrr.h" #include "stream.h" -#include "thread.h" +#include "event.h" #include "network.h" #include "command.h" #include "lib/version.h" diff --git a/zebra/zebra_gr.c b/zebra/zebra_gr.c index 3724ea0901..c9881e51dc 100644 --- a/zebra/zebra_gr.c +++ b/zebra/zebra_gr.c @@ -13,7 +13,7 @@ #include "lib/prefix.h" #include "lib/command.h" #include "lib/if.h" -#include "lib/thread.h" +#include "event.h" #include "lib/stream.h" #include "lib/memory.h" #include "lib/table.h" diff --git a/zebra/zebra_mlag_private.c b/zebra/zebra_mlag_private.c index 334eb6dc46..d9189206fa 100644 --- a/zebra/zebra_mlag_private.c +++ b/zebra/zebra_mlag_private.c @@ -12,7 +12,7 @@ #include "hook.h" #include "module.h" -#include "thread.h" +#include "event.h" #include "frr_pthread.h" #include "libfrr.h" #include "lib/version.h" diff --git a/zebra/zebra_mpls.c b/zebra/zebra_mpls.c index 4aaf6f25af..dfb4875ffc 100644 --- a/zebra/zebra_mpls.c +++ b/zebra/zebra_mpls.c @@ -13,7 +13,7 @@ #include "log.h" #include "sockunion.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "workqueue.h" #include "prefix.h" #include "routemap.h" diff --git a/zebra/zebra_netns_notify.c b/zebra/zebra_netns_notify.c index 28f3c03abe..468acbdfe4 100644 --- a/zebra/zebra_netns_notify.c +++ b/zebra/zebra_netns_notify.c @@ -17,7 +17,7 @@ #include #include -#include "thread.h" +#include "event.h" #include "ns.h" #include "command.h" #include "memory.h" diff --git a/zebra/zebra_pw.c b/zebra/zebra_pw.c index dc56ba3c30..a3f7ba6280 100644 --- a/zebra/zebra_pw.c +++ b/zebra/zebra_pw.c @@ -7,7 +7,7 @@ #include "log.h" #include "memory.h" -#include "thread.h" +#include "event.h" #include "command.h" #include "vrf.h" #include "lib/json.h" diff --git a/zebra/zebra_rib.c b/zebra/zebra_rib.c index 6c499b77d7..5e9eda168e 100644 --- a/zebra/zebra_rib.c +++ b/zebra/zebra_rib.c @@ -18,7 +18,7 @@ #include "sockunion.h" #include "srcdest_table.h" #include "table.h" -#include "thread.h" +#include "event.h" #include "vrf.h" #include "workqueue.h" #include "nexthop_group_private.h" diff --git a/zebra/zebra_rnh.c b/zebra/zebra_rnh.c index 2666dc232f..61a4559e04 100644 --- a/zebra/zebra_rnh.c +++ b/zebra/zebra_rnh.c @@ -13,7 +13,7 @@ #include "log.h" #include "sockunion.h" #include "linklist.h" -#include "thread.h" +#include "event.h" #include "workqueue.h" #include "prefix.h" #include "routemap.h" diff --git a/zebra/zserv.c b/zebra/zserv.c index e064c27ad1..3563068a66 100644 --- a/zebra/zserv.c +++ b/zebra/zserv.c @@ -34,7 +34,7 @@ #include "lib/sockopt.h" /* for setsockopt_so_recvbuf, setsockopt... */ #include "lib/sockunion.h" /* for sockopt_reuseaddr, sockopt_reuseport */ #include "lib/stream.h" /* for STREAM_SIZE, stream (ptr only), ... */ -#include "lib/thread.h" /* for thread (ptr only), THREAD_ARG, ... */ +#include "event.h" /* for thread (ptr only), THREAD_ARG, ... */ #include "lib/vrf.h" /* for vrf_info_lookup, VRF_DEFAULT */ #include "lib/vty.h" /* for vty_out, vty (ptr only) */ #include "lib/zclient.h" /* for zmsghdr, ZEBRA_HEADER_SIZE, ZEBRA... */ diff --git a/zebra/zserv.h b/zebra/zserv.h index 1226cd7115..0faea9dd73 100644 --- a/zebra/zserv.h +++ b/zebra/zserv.h @@ -19,7 +19,7 @@ #include "lib/vrf.h" /* for vrf_bitmap_t */ #include "lib/zclient.h" /* for redist_proto */ #include "lib/stream.h" /* for stream, stream_fifo */ -#include "lib/thread.h" /* for thread, thread_master */ +#include "event.h" /* for thread, thread_master */ #include "lib/linklist.h" /* for list */ #include "lib/workqueue.h" /* for work_queue */ #include "lib/hook.h" /* for DECLARE_HOOK, DECLARE_KOOH */ -- cgit v1.2.3