void KatranLb::loadBpfProgs()

in katran/lib/KatranLb.cpp [715:807]
81 lines of code
22 McCabe index (conditional complexity)

void KatranLb::loadBpfProgs() {
  int res;
  bool flowDebugInProg = false;
  bool globalLruInProg = false;

  if (!config_.disableForwarding) {
    flowDebugInProg = bpfAdapter_.isMapInBpfObject(
        config_.balancerProgPath, kFlowDebugParentMapName.data());
    globalLruInProg = bpfAdapter_.isMapInBpfObject(
        config_.balancerProgPath, kGlobalLruMapName.data());
    initLrus(flowDebugInProg, globalLruInProg);
    if (flowDebugInProg) {
      initFlowDebugPrototypeMap();
    }
    if (globalLruInProg) {
      initGlobalLruPrototypeMap();
    }
    res = bpfAdapter_.loadBpfProg(config_.balancerProgPath);
    if (res) {
      throw std::invalid_argument("can't load main bpf program");
    }
  }

  if (config_.enableHc) {
    res = bpfAdapter_.loadBpfProg(config_.healthcheckingProgPath);
    if (res) {
      throw std::invalid_argument(folly::sformat(
          "can't load healthchecking bpf program, error: {}",
          folly::errnoStr(errno)));
    }
  }

  initialSanityChecking(flowDebugInProg, globalLruInProg);
  featureDiscovering();

  if (!config_.disableForwarding && features_.gueEncap) {
    setupGueEnvironment();
  }

  if (!config_.disableForwarding && features_.inlineDecap) {
    enableRecirculation();
  }

  if (!config_.disableForwarding) {
    // add values to main prog ctl_array
    std::vector<uint32_t> balancer_ctl_keys = {kMacAddrPos};

    for (auto ctl_key : balancer_ctl_keys) {
      res = bpfAdapter_.bpfUpdateMap(
          bpfAdapter_.getMapFdByName("ctl_array"),
          &ctl_key,
          &ctlValues_[ctl_key]);

      if (res != 0) {
        throw std::invalid_argument(folly::sformat(
            "can't update ctl array for main program, error: {}",
            folly::errnoStr(errno)));
      }
    }
  }

  if (config_.enableHc) {
    std::vector<uint32_t> hc_ctl_keys = {kMainIntfPos};
    if (config_.tunnelBasedHCEncap) {
      hc_ctl_keys.push_back(kIpv4TunPos);
      hc_ctl_keys.push_back(kIpv6TunPos);
    }
    for (auto ctl_key : hc_ctl_keys) {
      res = bpfAdapter_.bpfUpdateMap(
          bpfAdapter_.getMapFdByName("hc_ctrl_map"),
          &ctl_key,
          &ctlValues_[ctl_key].ifindex);

      if (res != 0) {
        throw std::invalid_argument(folly::sformat(
            "can't update ctrl map for hc program, error: {}",
            folly::errnoStr(errno)));
      }
    }
    if (features_.directHealthchecking) {
      setupHcEnvironment();
    }
  }
  progsLoaded_ = true;
  if (!config_.disableForwarding && features_.introspection) {
    startIntrospectionRoutines();
    introspectionStarted_ = true;
  }

  if (!config_.disableForwarding) {
    attachLrus(flowDebugInProg, globalLruInProg);
  }
}