mfib_signal.c

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#include <vnet/vnet.h>
#include <vnet/mfib/mfib_signal.h>
#include <vppinfra/dlist.h>
 
/**
 * @brief Pool of signals
 */
static mfib_signal_t *mfib_signal_pool;
 
/**
 * @brief pool of dlist elements
 */
static dlist_elt_t *mfib_signal_dlist_pool;
 
/**
 * the list/set of interfaces with signals pending
 */
typedef struct mfib_signal_q_t_
{
    /**
     * the dlist indext that is the head of the list
     */
    u32 mip_head;
 
    /**
     * Spin lock to protect the list
     */
    int mip_lock;
} mfib_signal_q_t;
 
/**
 * @brief The pending queue of signals to deliver to the control plane
 */
static mfib_signal_q_t mfib_signal_pending ;
 
static void
mfib_signal_list_init (void)
{
    dlist_elt_t *head;
    u32 hi;
 
    pool_get(mfib_signal_dlist_pool, head);
    hi = head - mfib_signal_dlist_pool;
 
    mfib_signal_pending.mip_head = hi;
    clib_dlist_init(mfib_signal_dlist_pool, hi);
}
 
void
mfib_signal_module_init (void)
{
    mfib_signal_list_init();
}
 
static inline void
mfib_signal_lock_aquire (void)
{
    while (clib_atomic_test_and_set (&mfib_signal_pending.mip_lock))
        ;
}
 
static inline void
mfib_signal_lock_release (void)
{
  clib_atomic_release(&mfib_signal_pending.mip_lock);
}
 
#define MFIB_SIGNAL_CRITICAL_SECTION(_body) \
{                                           \
    mfib_signal_lock_aquire();              \
    do {                                    \
        _body;                              \
    } while (0);                            \
    mfib_signal_lock_release();             \
}
 
int
mfib_signal_send_one (struct vl_api_registration_ *reg,
                      u32 context)
{
    u32 li, si;
 
    /*
     * with the lock held, pop a signal from the q.
     */
    MFIB_SIGNAL_CRITICAL_SECTION(
    ({
        li = clib_dlist_remove_head(mfib_signal_dlist_pool,
                                    mfib_signal_pending.mip_head);
    }));
 
    if (~0 != li)
    {
        mfib_signal_t *mfs;
        mfib_itf_t *mfi;
        dlist_elt_t *elt;
 
        elt = pool_elt_at_index(mfib_signal_dlist_pool, li);
        si = elt->value;
 
        mfs = pool_elt_at_index(mfib_signal_pool, si);
        mfi = mfib_itf_get(mfs->mfs_itf);
        mfi->mfi_si = INDEX_INVALID;
        clib_atomic_fetch_and(&mfi->mfi_flags,
                              ~MFIB_ITF_FLAG_SIGNAL_PRESENT);
 
 
        vl_mfib_signal_send_one(reg, context, mfs);
 
        /*
         * with the lock held, return the resoruces of the signals posted
         */
        MFIB_SIGNAL_CRITICAL_SECTION(
        ({
            pool_put_index(mfib_signal_pool, si);
            pool_put_index(mfib_signal_dlist_pool, li);
        }));
 
        return (1);
    }
    return (0);
}
 
void
mfib_signal_push (const mfib_entry_t *mfe,
                  mfib_itf_t *mfi,
                  vlib_buffer_t *b0)
{
    mfib_signal_t *mfs;
    dlist_elt_t *elt;
    u32 si, li;
 
    MFIB_SIGNAL_CRITICAL_SECTION(
    ({
        pool_get(mfib_signal_pool, mfs);
        pool_get(mfib_signal_dlist_pool, elt);
 
        si = mfs - mfib_signal_pool;
        li = elt - mfib_signal_dlist_pool;
 
        elt->value = si;
        mfi->mfi_si = li;
 
        clib_dlist_addhead(mfib_signal_dlist_pool,
                           mfib_signal_pending.mip_head,
                           li);
    }));
 
    mfs->mfs_entry = mfib_entry_get_index(mfe);
    mfs->mfs_itf = mfib_itf_get_index(mfi);
 
    if (NULL != b0)
    {
        mfs->mfs_buffer_len = b0->current_length;
        memcpy(mfs->mfs_buffer,
               vlib_buffer_get_current(b0),
               (mfs->mfs_buffer_len > MFIB_SIGNAL_BUFFER_SIZE ?
                MFIB_SIGNAL_BUFFER_SIZE :
                mfs->mfs_buffer_len));
    }
    else
    {
        mfs->mfs_buffer_len = 0;
    }
}
 
void
mfib_signal_remove_itf (const mfib_itf_t *mfi)
{
    u32 li;
 
    /*
     * lock the queue to prevent further additions while we fiddle.
     */
    li = mfi->mfi_si;
 
    if (INDEX_INVALID != li)
    {
        /*
         * it's in the pending q
         */
        MFIB_SIGNAL_CRITICAL_SECTION(
        ({
            dlist_elt_t *elt;
 
            /*
             * with the lock held;
             *  - remove the signal from the pending list
             *  - free up the signal and list entry obejcts
             */
            clib_dlist_remove(mfib_signal_dlist_pool, li);
 
            elt = pool_elt_at_index(mfib_signal_dlist_pool, li);
            pool_put_index(mfib_signal_pool, elt->value);
            pool_put(mfib_signal_dlist_pool, elt);
        }));
    }
}