1/* 2 * Copyright (c) 2009, 2010, 2011, 2012, ETH Zurich. 3 * All rights reserved. 4 * 5 * This file is distributed under the terms in the attached LICENSE file. 6 * If you do not find this file, copies can be found by writing to: 7 * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group. 8 */ 9 10#ifndef BULK_SM_IMPL_H 11#define BULK_SM_IMPL_H 12 13#include <barrelfish/barrelfish.h> 14 15#include <bulk_transfer/bulk_transfer.h> 16#include <bulk_transfer/bulk_sm.h> 17 18#define VOID2CHANNEL(a) ((struct bulk_channel*)(a)) 19#define CHANNEL_EP(c) ((struct bulk_sm_endpoint_descriptor*)(c)->ep) 20#define CHANNEL_DATA(c) ((struct bulk_sm_impl_data*)(c)->impl_data) 21#define CHANNEL_BINDING(c) (CHANNEL_DATA(c)->b) 22 23// Flounder call/receive handler ------------------------------------------ 24 25void bulk_sm_channel_negotiate_rx_call( 26 struct bulk_ctrl_binding *b, 27 enum bulk_ctrl_role_t role, 28 enum bulk_ctrl_trust_t trust); 29 30void bulk_sm_channel_negotiate_rx_reply( 31 struct bulk_ctrl_binding *b, 32 uint64_t error, 33 enum bulk_ctrl_direction_t match_direction, 34 enum bulk_ctrl_role_t match_role, 35 uint64_t meta_size); 36 37void bulk_sm_assign_pool_rx_call( 38 struct bulk_ctrl_binding *b, 39 bulk_ctrl_pool_t pool, 40 uint64_t id); 41 42void bulk_sm_assign_pool_rx_response( 43 struct bulk_ctrl_binding *b, 44 uint64_t error, 45 uint64_t id); 46 47 48void bulk_sm_move_rx_call( 49 struct bulk_ctrl_binding *b, 50 bulk_ctrl_poolid_t poolid, 51 uint32_t bufferid, 52 uint32_t tid, 53 struct capref cap, 54 const uint8_t *meta, 55 size_t metasize); 56 57void bulk_sm_move_trusted_rx_call( 58 struct bulk_ctrl_binding *b, 59 bulk_ctrl_poolid_t poolid, 60 uint32_t bufferid, 61 uint32_t tid, 62 const uint8_t *meta, 63 size_t metasize); 64 65void bulk_sm_move_rx_response( 66 struct bulk_ctrl_binding *b, 67 bulk_ctrl_error_t error, 68 uint32_t tid); 69 70void bulk_sm_copy_rx_call( 71 struct bulk_ctrl_binding *b, 72 bulk_ctrl_poolid_t poolid, 73 uint32_t bufferid, 74 uint32_t tid, 75 struct capref cap, 76 const uint8_t *meta, 77 size_t metasize); 78 79void bulk_sm_copy_trusted_rx_call( 80 struct bulk_ctrl_binding *b, 81 bulk_ctrl_poolid_t poolid, 82 uint32_t bufferid, 83 uint32_t tid, 84 const uint8_t *meta, 85 size_t metasize); 86 87void bulk_sm_copy_rx_response( 88 struct bulk_ctrl_binding *b, 89 bulk_ctrl_error_t error, 90 uint32_t tid); 91 92void bulk_sm_pass_rx_call( 93 struct bulk_ctrl_binding *b, 94 bulk_ctrl_poolid_t poolid, 95 uint32_t bufferid, 96 uint32_t tid, 97 struct capref cap, 98 const uint8_t *meta, 99 size_t metasize); 100 101void bulk_sm_pass_trusted_rx_call( 102 struct bulk_ctrl_binding *b, 103 bulk_ctrl_poolid_t poolid, 104 uint32_t bufferid, 105 uint32_t tid, 106 const uint8_t *meta, 107 size_t metasize); 108 109void bulk_sm_pass_rx_response( 110 struct bulk_ctrl_binding *b, 111 bulk_ctrl_error_t error, 112 uint32_t tid); 113 114void bulk_sm_release_rx_call( 115 struct bulk_ctrl_binding *b, 116 bulk_ctrl_poolid_t poolid, 117 uint32_t bufferid, 118 uint32_t tid); 119 120void bulk_sm_release_rx_response( 121 struct bulk_ctrl_binding *b, 122 bulk_ctrl_error_t error, 123 uint32_t tid); 124 125// Flounder generic callbacks --------------------------------------------- 126 127//printing handler for asynchronous errors 128void bulk_sm_error_handler_debug(struct bulk_ctrl_binding *_binding, errval_t err); 129 130/** 131 * Callback for use with flounder. Prints to string provided by (void *a). 132 */ 133void bulk_sm_flounder_msg_sent_debug_cb(void *a); 134 135/** 136 * Function used as generic send that preserves fifo order. 137 * enqueues the message and registers resend handler if necessary 138 * 139 * @param channel: Channel of interest. Is used as argument for the callback. 140 * @param send_fn: send function to be called. this should be a very simple 141 * function that just reads arg, tries to send it and 142 * returns the error code. 143 */ 144void bulk_sm_flounder_send_fifo_msg(struct bulk_channel *channel, 145 errval_t (*send_fn)(void *arg)); 146 147void bulk_sm_flounder_send_fifo_msg_with_arg(struct bulk_channel *channel, 148 errval_t (*send_fn)(void *arg), 149 void *arg); 150 151 152 153// Flounder type conversion helpers --------------------------------------- 154 155static inline enum bulk_channel_direction flounder2bulk_direction( 156 enum bulk_ctrl_direction_t direction) 157{ 158 return ((direction == bulk_ctrl_SOURCE) ? BULK_DIRECTION_TX : 159 BULK_DIRECTION_RX ); 160} 161 162static inline enum bulk_channel_role flounder2bulk_role( 163 enum bulk_ctrl_role_t role) 164{ 165 return ((role == bulk_ctrl_GENERIC) ? BULK_ROLE_GENERIC : 166 (role == bulk_ctrl_MASTER) ? BULK_ROLE_MASTER : 167 BULK_ROLE_SLAVE ); 168} 169 170static inline enum bulk_trust_level flounder2bulk_trust( 171 enum bulk_ctrl_trust_t trust) 172{ 173 return ((trust == bulk_ctrl_NONE) ? BULK_TRUST_NONE : 174 (trust == bulk_ctrl_HALF) ? BULK_TRUST_HALF : 175 BULK_TRUST_FULL ); 176} 177 178static inline enum bulk_ctrl_direction_t bulk2flounder_direction( 179 enum bulk_channel_direction direction) 180{ 181 return ((direction == BULK_DIRECTION_TX) ? bulk_ctrl_SOURCE : 182 bulk_ctrl_SINK ); 183} 184 185static inline enum bulk_ctrl_role_t bulk2flounder_role( 186 enum bulk_channel_role role) 187{ 188 return ((role == BULK_ROLE_GENERIC) ? bulk_ctrl_GENERIC : 189 (role == BULK_ROLE_MASTER) ? bulk_ctrl_MASTER : 190 bulk_ctrl_SLAVE ); 191} 192 193static inline enum bulk_ctrl_trust_t bulk2flounder_trust( 194 enum bulk_trust_level trust) 195{ 196 assert(trust != BULK_TRUST_UNINITIALIZED); // what to do with that? 197 198 return ((trust == BULK_TRUST_NONE) ? bulk_ctrl_NONE : 199 (trust == BULK_TRUST_HALF) ? bulk_ctrl_HALF : 200 bulk_ctrl_FULL ); 201} 202 203/** 204 * Allocates and initializes a new bulk_pool struct based on flounder data. 205 * 206 * @param: pool Pointer where created and allocated pool is stored, by value. 207 * @param: f_pool Flounder data to create pool from. 208 */ 209errval_t create_pool_from_flounder(struct bulk_pool **pool, 210 const bulk_ctrl_pool_t *f_pool); 211 212/** 213 * Creates a flounder pool struct from a bulk_pool. 214 * 215 * @param: pool Pool to be represented 216 * @param: f_pool Pointer to unused flounder pool. 217 */ 218void generate_pool_for_flounder(const struct bulk_pool *pool, 219 bulk_ctrl_pool_t *f_pool); 220 221 222/** 223 * sets the fields of a bulk_pool_id struct from a flounder poolid struct. 224 * does not allocate any new memory. 225 * 226 */ 227void fill_pool_id_from_flounder(struct bulk_pool_id *poolid, 228 const bulk_ctrl_poolid_t *f_poolid); 229 230/** 231 * sets the fields of a flounder poolid struct from a bulk_pool_id struct. 232 * does not allocate any new memory. 233 */ 234void fill_pool_id_for_flounder(const struct bulk_pool_id *poolid, 235 bulk_ctrl_poolid_t *f_poolid); 236 237#endif // BULK_SM_IMPL_H 238