예제 #1
0
static inline lagopus_result_t
s_add_stage(lagopus_pipeline_stage_t ps) {
  lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;

  if (ps != NULL && IS_VALID_STRING(ps->m_name) == true) {
    void *val = (void *)ps;
    if ((ret = lagopus_hashmap_add(&s_ps_name_tbl,
                                   (void *)(ps->m_name), &val, false)) ==
        LAGOPUS_RESULT_OK) {
      val = (void *)true;
      ret = lagopus_hashmap_add(&s_ps_obj_tbl, (void *)ps, &val, true);
    }
  } else {
    ret = LAGOPUS_RESULT_INVALID_ARGS;
  }

  return ret;
}
예제 #2
0
파일: check1.c 프로젝트: 1514louluo/lagopus
static inline lagopus_result_t
s_config_add(testobj_config_t *o) {
  lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;

  if (o != NULL && IS_VALID_STRING(o->m_name) == true) {
    void *val = (void *)o;
    ret = lagopus_hashmap_add(&s_tbl, (void *)(o->m_name), &val, false);
  } else {
    ret = LAGOPUS_RESULT_INVALID_ARGS;
  }

  return ret;
}
예제 #3
0
static lagopus_result_t
channel_set_dpid(const char *channel_name, uint64_t dpid) {
  lagopus_result_t ret;
  struct channel *chan = NULL;
  struct channel_list *chan_list = NULL;
  void *valptr = NULL;

  if (dpid == UNUSED_DPID) {
    return LAGOPUS_RESULT_INVALID_ARGS;
  }

  ret = lagopus_hashmap_find(&main_table, (void *)channel_name, (void **)&chan);
  if (chan == NULL) {
    return LAGOPUS_RESULT_NOT_FOUND;
  }

  if (channel_dpid_get(chan) != UNUSED_DPID) {
    return LAGOPUS_RESULT_BUSY;
  }

  ret = channel_dpid_set(chan, dpid);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  ret = lagopus_hashmap_find(&dp_table, (void *)dpid, (void **)&chan_list);
  if (ret == LAGOPUS_RESULT_NOT_FOUND) {
    chan_list = channel_list_alloc();
    if (chan_list == NULL) {
      ret = LAGOPUS_RESULT_NO_MEMORY;
      goto done;
    }
    valptr = chan_list;
    ret = lagopus_hashmap_add(&dp_table, (void *)dpid, (void **)&valptr,
                              false);
    if (ret != LAGOPUS_RESULT_OK) {
      goto done;
    }
  } else if (ret != LAGOPUS_RESULT_OK) {
    goto done;
  }

  channel_id_set(chan, channel_list_channel_id_get(chan_list));
  ret = channel_list_insert(chan_list, chan);

done:

  return ret;
}
예제 #4
0
static inline lagopus_result_t
queue_conf_add(queue_conf_t *conf) {
  if (queue_table != NULL) {
    if (conf != NULL && IS_VALID_STRING(conf->name) == true) {
      void *val = (void *) conf;
      return lagopus_hashmap_add(&queue_table,
                                 (char *) (conf->name),
                                 &val, false);
    } else {
      return LAGOPUS_RESULT_INVALID_ARGS;
    }
  } else {
    return LAGOPUS_RESULT_NOT_STARTED;
  }
}
예제 #5
0
/**
 * Add ipv4 addr information notified from netlink.
 */
void
rib_notifier_ipv4_addr_add(int ifindex, struct in_addr *addr, int prefixlen,
                           struct in_addr *broad, char *label) {
  lagopus_result_t rv;
  struct ifinfo_entry *entry;
  struct ifinfo_entry *dentry;
  uint8_t hwaddr[UPDATER_ETH_LEN];
  struct bridge *bridge;
  struct notification_entry *nentry = NULL;

  addr_ipv4_log("add", ifindex, addr, prefixlen, broad, label);

  /* new ifinfo entry to registered to ifinfo_hashmap. */
  entry = calloc(1, sizeof(struct ifinfo_entry));
  if (entry == NULL) {
    lagopus_msg_warning("no memory.\n");
    return;
  }
  memset(entry, 0, sizeof(struct ifinfo_entry));
  memcpy(entry->ifname, label, strlen(label));

  if (dp_tapio_interface_info_get(label, hwaddr, &bridge)
      != LAGOPUS_RESULT_OK) {
    lagopus_msg_warning("get interface info failed.\n");
    ifinfo_entry_free(entry);
    return;
  }
  memcpy(entry->hwaddr, hwaddr, UPDATER_ETH_LEN);
  entry->rib = &(bridge->rib);
  dentry = entry;
  lagopus_hashmap_add(&ifinfo_hashmap, (void *)ifindex, (void **)&dentry, true);

  /* create and set notification entry. */
  nentry = rib_create_notification_entry(NOTIFICATION_TYPE_IFADDR,
                                         NOTIFICATION_ACTION_TYPE_ADD);
  if (nentry) {
    /* add notification entry to queue. */
    nentry->ifaddr.ifindex = ifindex;
    rv = rib_add_notification_entry(&bridge->rib, nentry);
  } else {
    lagopus_msg_warning("create notification entry failed\n");
    ifinfo_entry_free(entry);
  }

  return;
}
예제 #6
0
static inline lagopus_result_t
bridge_register(uint64_t dpid, struct ofp_bridgeq *bridgeq) {
  lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
  struct ofp_bridgeq *brq = bridgeq;

  if (bridgeq != NULL && bridgeq->ofp_bridge != NULL
      && dpid == bridgeq->ofp_bridge->dpid) {
    /* add to bridgeq_table */
    ret = lagopus_hashmap_add(&bridgeq_table,
                              (void *)bridgeq->ofp_bridge->dpid,
                              (void **)&brq, true);
  } else {
    ret = LAGOPUS_RESULT_INVALID_ARGS;
  }

  return ret;
}
예제 #7
0
static lagopus_result_t
channel_add_internal(const char *channel_name, struct addrunion *addr,
                     struct channel **channel) {
  lagopus_result_t ret;
  struct channel *chan = NULL;
  void *valptr = NULL;

  if (main_table == NULL) {
    return LAGOPUS_RESULT_ANY_FAILURES;
  }

  ret = lagopus_hashmap_find(&main_table, (void *)channel_name, (void **)&chan);
  if (ret == LAGOPUS_RESULT_OK && chan != NULL) {
    /* FIXME support auxiliary connections */
    return LAGOPUS_RESULT_ALREADY_EXISTS;
  } else if (ret != LAGOPUS_RESULT_NOT_FOUND) {
    return ret;
  }

#define UNUSED_DPID 0
  chan = channel_alloc(addr, em, UNUSED_DPID);
  if (chan == NULL) {
    return LAGOPUS_RESULT_NO_MEMORY;
  }

  lagopus_msg_debug(10, "channel allocated  %p\n", chan);

  valptr = chan;
  ret = lagopus_hashmap_add(&main_table, (void *)channel_name, (void **)&valptr,
                            false);
  if (ret != LAGOPUS_RESULT_OK) {
    channel_free(chan);
  }

  if (ret != LAGOPUS_RESULT_OK) {
    channel_delete_internal((const char *) channel_name);
  } else {
    *channel = chan;
  }

  return ret;
}
예제 #8
0
파일: numa.c 프로젝트: roccen/lagopus
static inline lagopus_result_t
s_add_addr(void *addr, size_t sz) {
  lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;

  if (likely(s_tbl != NULL)) {
    if (likely(addr != NULL)) {
      void *val;
#ifdef LAGOPUS_ARCH_32_BITS
      val = (void *)((uint32_t)sz);
#else
      val = (void *)sz;
#endif /* LAGOPUS_ARCH_32_BITS */

      ret = lagopus_hashmap_add(&s_tbl, addr, &val, false);
    } else {
      ret = LAGOPUS_RESULT_INVALID_ARGS;
    }
  } else {
    ret = LAGOPUS_RESULT_NOT_OPERATIONAL;
  }

  return ret;
}
예제 #9
0
파일: snmpmgr.c 프로젝트: tidatida/lagopus
static void
check_status_and_send_traps(void) {
  lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
  struct port_stat *port_stat;
  size_t index;
  char ifname[IFNAMSIZ + 1];
  size_t len = 0;
  struct ifTable_entry *entry = NULL;
  int32_t ifAdminStatus, ifOperStatus;
  int32_t old_ifAdminStatus, old_ifOperStatus;

  if ((ret = dp_get_port_stat(&port_stat)) == LAGOPUS_RESULT_OK) {
    /* check each port_stat, send trap if needed! */
    for (index = 0;
         dataplane_interface_get_ifDescr(
           port_stat, index, ifname, &len) == LAGOPUS_RESULT_OK;
         index++) {
      if (len > 0) {
        int32_t ifIndex = (int32_t) (index + 1);
        if (dataplane_interface_get_ifAdminStatus(
              port_stat, index, &ifAdminStatus) == LAGOPUS_RESULT_OK
            && dataplane_interface_get_ifOperStatus(
              port_stat, index, &ifOperStatus) == LAGOPUS_RESULT_OK) {
          /* Note:
           *  index may be changed if a port is attached/detacched to vSwitch,
           *  so use ifName as key.
           */
          ret = lagopus_hashmap_find(&iftable_entry_hash,
                                     (void *)ifname,
                                     (void *)&entry);
          if (ret == LAGOPUS_RESULT_OK) {
            old_ifAdminStatus = entry->ifAdminStatus;
            old_ifOperStatus = entry->ifOperStatus;
            entry->ifAdminStatus = ifAdminStatus;
            entry->ifOperStatus = ifOperStatus;
            if (ifOperStatus != old_ifOperStatus) {
              /* operation status prior to administration status */
              if (ifOperStatus == up) { /* is up */
                (void)send_linkUp_trap(ifIndex, ifAdminStatus, ifOperStatus);
              } else if (ifOperStatus != up && old_ifOperStatus == up) {
                (void)send_linkDown_trap(ifIndex, ifAdminStatus, ifOperStatus);
              }
            } else if (ifAdminStatus != old_ifAdminStatus) {
              if (ifAdminStatus == up) {
                (void)send_linkUp_trap(ifIndex, ifAdminStatus, ifOperStatus);
              } else if (ifAdminStatus != up && old_ifAdminStatus == up) {
                (void)send_linkDown_trap(ifIndex, ifAdminStatus, ifOperStatus);
              }
            }
          } else {
            /* The entry does not exist in previous status checking, */
            /* so the port_stat is attached recentry. */
            if (ifOperStatus == up) {
              (void)send_linkUp_trap(ifIndex, ifAdminStatus, ifOperStatus);
            }
            if ((entry = (struct ifTable_entry *)
                         malloc (sizeof(*entry))) != NULL) {
              entry->ifAdminStatus = ifAdminStatus;
              entry->ifOperStatus = ifOperStatus;
              if ((ret = lagopus_hashmap_add(&iftable_entry_hash,
                                             (void *)ifname,
                                             (void **)&entry, false))
                  != LAGOPUS_RESULT_OK) {
                lagopus_perror(ret);
                free(entry);
              }
            } else {
              lagopus_perror(LAGOPUS_RESULT_NO_MEMORY);
            }
          }
        }
      }
    }
  }
}