SONiC Introduction.

1. Open Source Network OS for Datacenter
Dung-Ru Tsai, COSCUP2021

2. OCP Ecosystem with SONiC
https://github.com/Azure/SONiC/wiki/files/talks/SAI-SONiC-OCP-Summit-Mar16-shared.pdf

3. Nowadays, Datacenter Network: Spine Leaf Topology
https://www.cisco.com/c/en/us/products/collateral/switches/nexus-7000-series-switches/white-paper-c11-737022.html

4. https://www.cisco.com/c/en/us/products/collateral/switches/nexus-9000-series-switches/white-paper-c11-729383.html

5. Overlay Network- VxLAN
https://www.cisco.com/c/en/us/products/collateral/switches/nexus-9000-series-switches/white-paper-c11-729383.html

6. Control-Plane Address Learning: MP-BGP EVPN
https://www.ciscolive.com/c/dam/r/ciscolive/emea/docs/2016/pdf/LTRDCT-2223.pdf

7. SONiC Subsystem Architecture High Level View
https://github.com/Azure/SONiC/wiki/Architecture

8. BGP Routing state
Interactions

9. Supervisor: A Process Control System
- https://github.com/Supervisor/supervisor.git
- Supervisor daemon (dockers/docker-orchagent/supervisord.conf)
- [program:orchagent]
- command=/usr/bin/orchagent.sh
- priority=4
- autostart=false
- autorestart=false
- stdout_logfile=syslog
- stderr_logfile=syslog
- dependent_startup=true
- dependent_startup_wait_for=portsyncd:running
- Critical Process Listener
- files/scripts/supervisor-proc-exit-listener
- configuration: /etc/supervisor/critical_processes

10. Switch State Service (SWSS)
The SWitch State Service (SWSS) is a collection of
software that provides a database interface for
communication with and state representation of
network applications and network switch hardware.

11. sonic-swss-common
- Communication with REDIS
- DBConnector: set up DB connection.
- RedisPipeline: producer to database
- RedisTransactioner: database to subscriber (consumer)
- swss::ProducerStateTable ⇐ TableBase
- Producer Destination table
- swss: SubscriberStateTable ⇐ ConsumerTableBase
- Consumer source table
- NetDispatcher: Register Netlink message and handler

12. Application Main Loop

13. class Select

14. Where the “Selectable” (fd) come from ?
vector<string> cfg_vlan_tables = {
CFG_VLAN_TABLE_NAME,
CFG_VLAN_MEMBER_TABLE_NAME,
};
- DBConnector cfgDb("CONFIG_DB", 0); get the redis socket fd.
- std::vector<Orch *> cfgOrchList = {&vlanmgr};
- VlanMgr vlanmgr(&cfgDb, &appDb, &stateDb, cfg_vlan_tables);
- Orch(cfgDb, tableNames)
- Orch::addConsumer(db, it, default_orch_pri);
- Orch::addExecutor(new Consumer(new SubscriberStateTable(db, tableName,
TableConsumable::DEFAULT_POP_BATCH_SIZE, pri), this, tableName));
- SubscriberStateTable::SubscriberStateTable(DBConnector *db, const string
&tableName, int popBatchSize, int pri)
- class SubscriberStateTable : public ConsumerTableBase :
ConsumerTableBase:RedisSelect:Selectable
- void RedisSelect::psubscribe(DBConnector* db, const std::string
&channelName)

15. Class Orch : Handle multiple consumer source table
Binding
- DB table
- doTask function

16. class Execuator

17. https://hackmd.io/@octobersky/B1tohBQ7u

18. SWSS: Config Manger
- Mangers are table consumer and produce netlink message to kernel
- coppmgrd
- vlanmgrd
- intfmgrd
- portmgrd
- vrfmgrd
- nbrmgrd
- vxlanmgrd
- tunnelmgrd
- lldpmgrd (In LLDP Container)

19. SWSS: *syncd
- Direction: Receive Netlink message and push new data to the APPL_DB
- SWSS CNTR: portsyncd, neighsyncd, fdbsyncd
- BGP CNTR: fpmsyncd
- teamd CNTR: teamsyncd
- LLDP: lldp_syncd

20. Switch State Service: Orchagent
● The most critical component in the Swss
subsystem.
● Orchagent contains logic to extract all the
relevant state injected by *syncd
daemons, process and message this
information accordingly, and finally push it
towards its south-bound interface.
● Orchagent operates both as a consumer
(for example for state coming from
APPL_DB), and also as a producer (for
state being pushed into ASIC_DB).

21. Switch Abstraction Interface
https://github.com/Azure/SONiC/blob/gh-pages/doc/Barefoot-SAI-Workshop-03-21-2018-v4.pdf

22. Appendix
Contact information:
octobersky.tw@gmail.com

23. orchdaemon.cpp
---------------------------------------------
ret = m_select->select(&s, SELECT_TIMEOUT);
if (ret == Select::ERROR)
{
SWSS_LOG_NOTICE("Error: %s!n", strerror(errno));
continue;
}
if (ret == Select::TIMEOUT)
{
continue;
}
auto *c = (Executor *)s;
c->execute();
select.cpp
--------------------------------------------
int Select::poll_descriptors(Selectable **c, unsigned int timeout)
{
int sz_selectables = static_cast<int>(m_objects.size());
std::vector<struct epoll_event> events(sz_selectables);
int ret;
do
{
ret = ::epoll_wait(m_epoll_fd, events.data(), sz_selectables, timeout);
}
while(ret == -1 && errno == EINTR); // Retry the select if the process was interrupted by a signal
orch.cpp