Added protobuf support
[com/gs-lite.git] / include / lfta / rts.h
1 /* ------------------------------------------------
2  Copyright 2014 AT&T Intellectual Property
3  Licensed under the Apache License, Version 2.0 (the "License");
4  you may not use this file except in compliance with the License.
5  You may obtain a copy of the License at
6  
7  http://www.apache.org/licenses/LICENSE-2.0
8  
9  Unless required by applicable law or agreed to in writing, software
10  distributed under the License is distributed on an "AS IS" BASIS,
11  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  See the License for the specific language governing permissions and
13  limitations under the License.
14  ------------------------------------------- */
15
16 /*
17  * rts.h: ethernet card run-time system dfns
18  */
19 #ifndef RTS_H
20 #define RTS_H
21 #include "gstypes.h"
22 #include "gsconfig.h"
23 #include "byteswap.h"
24 #include "rts_external.h"
25
26 struct gs_string;       /* forward decl. */
27
28 #ifndef NULL
29 #define NULL 0
30 #endif
31
32 #include "fta.h"
33
34
35 /*
36  * dynamic memory allocation for FTAs (so they can store state, etc.).
37  * note that the allocator keeps track of which FTA owns what blocks and
38  * can free all allocated blocks for a given FTA in one go.
39  */
40
41 void *fta_alloc(struct FTA *, gs_int32_t size);
42 void fta_free(struct FTA *, void *mem);
43 void fta_free_all(struct FTA *);
44
45 /* memory allocation for scratchpad */
46
47 #define sp_fta_alloc fta_alloc
48 #define sp_fta_free fta_free
49 #define sp_fta_free_all fta_free_all
50
51
52 /* functions used to parse packet  (list is not complete)*/
53 #include "schema_prototypes.h"
54
55 /*
56  * FTA output: FTAs output tuples to the host using the post_tuple RTS function.
57  * Before the tuple can be output a tuple memory block has to be allocated
58  * in the tuple memory space. The allocate_tuple function is used for this.
59  * If an FTA is removed before post_tuple is called all allocated memory
60  * in the FTA's tuple space is reclaimed. If the FTA is removed after
61  * post_tuple is called the tuple will be deliverd to the host.
62  * If 0 is returned at no none suspended ringbuffer has not enough memory to
63  * allocate the tuple
64  */
65
66 void * allocate_tuple(struct FTA *,  gs_int32_t size);
67
68 /* post tuple posts the tuple if the atomic reingbuffer set can not suceed -1 is returned and the tuple is not
69  posted otherwise 0 is returned*/
70
71 gs_retval_t post_tuple(void *tuple);
72
73
74 /* the following function fills in the FTAID array r with the FTAIDs of processes receiving
75  * tuplese from the FTA specified in f. The space array indicates how many tuples of tuplesz
76  * can still fit in the ringbuffer corresponding to the FTAID of the process with the same index
77  * in r. The return values indicates how many ring buffers are valid in r. szr indicates the memory
78  * length (in elements) of  r and space. The function will fill at most szr elements into these array.
79  * If the return value is larger then szr it is an indication that not enough memory in r and space
80  * were provided to hold all results. A return value of -1 indicates an error.
81  */
82
83 gs_retval_t get_ringbuf_space(struct FTA * f, FTAID * r, gs_int32_t * space,  gs_int32_t szr, gs_int32_t tuplesz);
84
85
86 /* the following function can be used to put a ringbuffer to a process identified by the FTAID
87  * process into one of the following 3 modes. ATOMIC makes the ringbuffer part of the atomic set.
88  * A post to the atomic set either succeed or fails entirely. BESTEFORT is the besteffort set
89  * posts to BESTEFORT ringbuffers might fail quitely. SUSPEND will prevent any tuples of being
90  * posted to that proccess from the specified FTA. NOTE: Calling set_ringbuf_space between
91  * allocate_tuple and post_tuple might have unpredictable results for the tuple already
92  * allocated.
93  */
94
95 #define LFTA_RINGBUF_ATOMIC 1
96 #define LFTA_RINGBUF_BESTEFFORT 2
97 #define LFTA_RINGBUF_SUSPEND 3
98
99 gs_retval_t set_ringbuf_type(struct FTA * f, FTAID process, gs_int32_t state);
100
101 /* The following function returns TRUE if there is enough room in the post tuple
102  * queue for a speedy posting of the tuple. It should be used by FTAs which could
103  * possibly delay the posting of a tuple if FALSE is returned.
104  */
105
106 gs_retval_t post_ready(void);
107
108 /*
109  * the following function gives hints to the heap for binning
110  */
111
112 void fta_add_alloc_bin_size(struct FTA *, gs_int32_t sz, gs_int32_t maxcnt);
113 void fta_remove_alloc_bin_size(struct FTA *, gs_int32_t sz, gs_int32_t maxcnt);
114
115
116 gs_retval_t print_error(char *string);  /* XXXCDC: right place? */
117
118 /* Function to get the attributes of interfaces in an lfta */
119
120 gs_sp_t get_iface_properties (const gs_sp_t iface_name, const gs_sp_t property_name);
121
122
123 #endif