/* * Copyright (c) 2007 Shakir James and Washington University in St. Louis. * All rights reserved * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author or Washington University may not be used * to endorse or promote products derived from this source code * without specific prior written permission. * 4. Conditions of any other entities that contributed to this are also * met. If a copyright notice is present from another entity, it must * be maintained in redistributions of the source code. * * THIS INTELLECTUAL PROPERTY (WHICH MAY INCLUDE BUT IS NOT LIMITED TO SOFTWARE, * FIRMWARE, VHDL, etc) IS PROVIDED BY THE AUTHOR AND WASHINGTON UNIVERSITY * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR WASHINGTON UNIVERSITY * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS INTELLECTUAL PROPERTY, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * */ /* * File: tag.c * Author: Jessica Codr * Email: jmc5@cec.wustl.edu * Organization: Applied Research Laboratory * * Derived from: nstats.c and ipHdr.c * * Date Created: 07/21/08 * * Description: copy packet header info into a separate udp * packet and send this packet to a separate logging process. * * Modification History: * */ #ifndef _PLUGIN_LOG_C #define _PLUGIN_LOG_C // // // NOTE: See pluginFramework/null.c (null plugin) // for description pre-processors values // // #include "plugin_api.h" //#include "plugin_dl.h" //#include "scratch_rings_WU.h" #include "sram_rings_WU.h" //----------------------------------------------------------- // Global variables/Registers //----------------------------------------------------------- // thread-specific globals __declspec(gp_reg) int dlNextBlock; // where to send packets to next __declspec(gp_reg) int dlFromBlock; // where to get packets from __declspec(gp_reg) int msgNextBlock; // where to send control messages to next __declspec(gp_reg) int msgFromBlock; // where to get control messages from // see ring_formats.h for struct definitions volatile __declspec(gp_reg) plc_plugin_data ring_in; // ring data from PLC volatile __declspec(gp_reg) plugin_out_data ring_out; // ring data to next block __declspec(local_mem) unsigned int timeout; // time (cycles) between callbacks __declspec(gp_reg) unsigned int pluginId; // plugin id (0...7) __declspec(shared gp_reg) unsigned int lastTag; #include "plugin_helpers.h" //----------------------------------------------------------- // Function prototypes //----------------------------------------------------------- void handle_pkt_user(); void handle_msg_user(); void callback_user(); void plugin_init_user(); //delcared here so can use in handle_pkt_user() w/out implicit delcaration //XXX void default_format_out_data(unsigned int nextblock); void handle_pkt_user() { __declspec(gp_reg) onl_api_ip_hdr ipv4_hdr; // defined in ixp_lib.h __declspec(gp_reg) buf_handle_t buf_handle; // see dl_buf.h, ixp_lib.h __declspec(gp_reg) onl_api_buf_desc bufDescriptor; // see dl_buf.h, ixp_lib.h __declspec(sram) unsigned int bufDescPtr; //some of these might need to sram __declspec(sram) unsigned int ipv4HdrPtr; __declspec(sram) unsigned int dramBufferPtr; onl_api_plugin_cntr_inc(pluginId, 0); // Incr global plugin cntr 0 // Read the buf handle from the input Ring onl_api_get_buf_handle(&buf_handle); bufDescPtr = onl_api_getBufferDescriptorPtr(buf_handle); onl_api_readBufferDescriptor(bufDescPtr, &bufDescriptor); dramBufferPtr = onl_api_getBufferPtr(buf_handle); ipv4HdrPtr = onl_api_getIpv4HdrPtr(dramBufferPtr, bufDescriptor.offset); onl_api_readIpv4Hdr(ipv4HdrPtr, &ipv4_hdr); lastTag = ipv4_hdr.ip_tos + 1; helper_set_meta_default( MUX ); helper_set_meta_mux_tag( lastTag ); } void handle_msg_user(){} void callback_user() { } void plugin_init_user() { } /** ---------------------------------------------------------------- @User: YOU SHOULD NOT NEED TO MAKE ANY CHANGES TO THE REST OF THIS FILE ---------------------------------------------------------------- */ void default_format_out_data(unsigned int nextblock) { __declspec(gp_reg) int out_port; if(nextblock == QM) { __declspec(gp_reg) dl_buf_handle_t buf_handle; __declspec(sram) unsigned int *buf_desc_ptr; __declspec(sram_write_reg) unsigned int sram_wr_regs[3]; SIGNAL sram_sig; // assume unicast out_port = (ring_in.uc_mc_bits >> 3) & 0x7; ring_out.plugin_qm_data_out.out_port = out_port; ring_out.plugin_qm_data_out.qid = ((out_port+1) << 13) | ring_in.qid; ring_out.plugin_qm_data_out.l3_pkt_len = ring_in.l3_pkt_len; ring_out.plugin_qm_data_out.buf_handle_lo24 = ring_in.buf_handle_lo24; //not sure how to save the plugin_tag for qm? //ring_out.plugin_qm_data_out.plugin_tag = ring_in.plugin_tag; } else // assume MUX and ignore xscale data packets for now { // assume unicast out_port = (ring_in.uc_mc_bits >> 3) & 0x7; ring_out.plugin_mux_data_out.out_port = out_port; //changing this screws things up ring_out.plugin_mux_data_out.qid = ((out_port+1) << 13) | ring_in.qid; // was 1 to assume pass-through, changed to 0 for redo lookup ring_out.plugin_mux_data_out.flags = 0; ring_out.plugin_mux_data_out.plugin_tag = ring_in.plugin_tag; //change this plugin_tag??? ring_out.plugin_mux_data_out.in_port = ring_in.in_port; ring_out.plugin_mux_data_out.stats_index = ring_in.stats_index; ring_out.plugin_mux_data_out.l3_pkt_len = ring_in.l3_pkt_len; ring_out.plugin_mux_data_out.buf_handle_lo24 = ring_in.buf_handle_lo24; ring_out.plugin_xscale_data_out.buf_handle_lo24 = ring_in.buf_handle_lo24; ring_out.plugin_xscale_data_out.in_port = ring_in.in_port; ring_out.plugin_xscale_data_out.plugin_tag = ring_in.plugin_tag; ring_out.plugin_xscale_data_out.stats_index = ring_in.stats_index; ring_out.plugin_xscale_data_out.flags = ring_in.flags; ring_out.plugin_xscale_data_out.qid = ring_in.qid; ring_out.plugin_xscale_data_out.nh_eth_daddr_hi32 = ring_in.nh_eth_daddr_hi32; ring_out.plugin_xscale_data_out.nh_eth_daddr_lo16 = ring_in.nh_eth_daddr_lo16; ring_out.plugin_xscale_data_out.eth_type = ring_in.eth_type; ring_out.plugin_xscale_data_out.uc_mc_bits = ring_in.uc_mc_bits; ring_out.plugin_xscale_data_out.l3_pkt_len = ring_in.l3_pkt_len; ring_out.plugin_plugin_data_out.buf_handle_lo24 = ring_in.buf_handle_lo24; ring_out.plugin_plugin_data_out.in_port = ring_in.in_port; ring_out.plugin_plugin_data_out.plugin_tag = ring_in.plugin_tag; ring_out.plugin_plugin_data_out.stats_index = ring_in.stats_index; ring_out.plugin_plugin_data_out.flags = 0; ring_out.plugin_plugin_data_out.qid = ring_in.qid; ring_out.plugin_plugin_data_out.nh_eth_daddr_hi32 = ring_in.nh_eth_daddr_hi32; ring_out.plugin_plugin_data_out.nh_eth_daddr_lo16 = ring_in.nh_eth_daddr_lo16; ring_out.plugin_plugin_data_out.eth_type = ring_in.eth_type; ring_out.plugin_plugin_data_out.uc_mc_bits = ring_in.uc_mc_bits; ring_out.plugin_plugin_data_out.l3_pkt_len = ring_in.l3_pkt_len; } } /* handle packets */ void handle_pkt() { dl_source_packet( dlFromBlock ); handle_pkt_user( ); dl_sink_packet( dlNextBlock ); } /* handle control messages */ void handle_msg() { //has the structure to do stuff, but doesn't actually do anything __declspec(gp_reg) unsigned int message[8]; __declspec(gp_reg) unsigned int i; __declspec(local_mem) char msgstr[28]; __declspec(local_mem) char return_str[28]; __declspec(gp_reg) onl_api_ctrl_msg_hdr hdr; //for(i=0; i<8; ++i) { message[i] = 0; } //had to unroll loop like Dr. Wong did (after adding his methods) message[0] = 0; message[1] = 0; message[2] = 0; message[3] = 0; message[4] = 0; message[5] = 0; message[6] = 0; message[7] = 0; dl_source_message(msgFromBlock, message); hdr.value = message[0]; if(hdr.type != CM_CONTROLMSG) { return; } if(hdr.response_requested != 1) { return; } onl_api_intarr2str(&message[1], msgstr); hdr.type = CM_CONTROLMSGRSP; hdr.response_requested = 0; hdr.num_words = 7; message[0] = hdr.value; print_message_1(msgNextBlock, "Plugin tag: ", lastTag, 0); //dl_sink_message(msgNextBlock, message); } /* handle periodic functionality */ void callback() { } /* take care of any setup that needs to be done before processing begins */ void plugin_init() { /* set a default timeout value for callback of 10000 cycles */ timeout = 10000; /* set the default next block to be the Queue Manager */ dlNextBlock = QM; /* by default, get packets and get and put control messages from input rings * based on which microengine we are currently running on; this assumes a * default one to one mapping */ switch(__ME()) { case 0x7: pluginId = 0; dlFromBlock = PACKET_IN_RING_0; msgFromBlock = MESSAGE_IN_RING_0; msgNextBlock = MESSAGE_OUT_RING_0; break; case 0x10: pluginId = 1; dlFromBlock = PACKET_IN_RING_1; msgFromBlock = MESSAGE_IN_RING_1; msgNextBlock = MESSAGE_OUT_RING_1; break; case 0x11: pluginId = 2; dlFromBlock = PACKET_IN_RING_2; msgFromBlock = MESSAGE_IN_RING_2; msgNextBlock = MESSAGE_OUT_RING_2; break; case 0x12: pluginId = 3; dlFromBlock = PACKET_IN_RING_3; msgFromBlock = MESSAGE_IN_RING_3; msgNextBlock = MESSAGE_OUT_RING_3; break; case 0x13: pluginId = 4; dlFromBlock = PACKET_IN_RING_4; msgFromBlock = MESSAGE_IN_RING_4; msgNextBlock = MESSAGE_OUT_RING_4; break; default: // keep the compiler happy pluginId = 0; dlFromBlock = PACKET_IN_RING_0; msgFromBlock = MESSAGE_IN_RING_0; msgNextBlock = MESSAGE_OUT_RING_0; break; } plugin_init_user(); // user hook } /* entry point */ void main() { int c; /* do initialization */ plugin_init(); dl_sink_init(); dl_source_init(); /* get the current thread's context number (0-7) */ c = ctx(); if(c >= FIRST_PACKET_THREAD && c <= LAST_PACKET_THREAD) { while(1) { handle_pkt(); } } #ifdef MESSAGE_THREAD else if(c == MESSAGE_THREAD) { while(1) { handle_msg(); } } #endif #ifdef CALLBACK_THREAD else if(c == CALLBACK_THREAD) { while(1) { callback(); } } #endif } #endif // _PLUGIN_LOG_C