2 *------------------------------------------------------------------
3 * Copyright (c) 2017 Cisco and/or its affiliates.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *------------------------------------------------------------------
18 #ifndef vapi_hpp_included
19 #define vapi_hpp_included
29 #include <vppinfra/types.h>
30 #include <vapi/vapi.h>
31 #include <vapi/vapi_internal.h>
32 #include <vapi/vapi_dbg.h>
33 #include <vapi/vpe.api.vapi.h>
35 #if VAPI_CPP_DEBUG_LEAKS
36 #include <unordered_set>
49 template <typename Req, typename Resp, typename... Args> class Request;
50 template <typename M> class Msg;
51 template <typename M> void vapi_swap_to_be (M *msg);
52 template <typename M> void vapi_swap_to_host (M *msg);
53 template <typename M, typename... Args>
54 M *vapi_alloc (Connection &con, Args...);
55 template <typename M> vapi_msg_id_t vapi_get_msg_id_t ();
56 template <typename M> class Event_registration;
58 class Unexpected_msg_id_exception : public std::exception
61 virtual const char *what () const throw ()
63 return "unexpected message id";
67 class Msg_not_available_exception : public std::exception
70 virtual const char *what () const throw ()
72 return "message unavailable";
77 /** response not ready yet */
80 /** response to request is ready */
83 /** no response to request (will never come) */
85 } vapi_response_state_e;
88 * Class representing common functionality of a request - response state
94 virtual ~Common_req (){};
96 Connection &get_connection ()
101 vapi_response_state_e get_response_state (void) const
103 return response_state;
108 Common_req (Connection &con)
109 : con (con), context{0}, response_state{RESPONSE_NOT_READY}
113 void set_response_state (vapi_response_state_e state)
115 response_state = state;
118 virtual std::tuple<vapi_error_e, bool> assign_response (vapi_msg_id_t id,
121 void set_context (u32 context)
123 this->context = context;
132 vapi_response_state_e response_state;
134 friend class Connection;
136 template <typename M> friend class Msg;
138 template <typename Req, typename Resp, typename... Args>
139 friend class Request;
141 template <typename Req, typename Resp, typename... Args> friend class Dump;
143 template <typename M> friend class Event_registration;
147 * Class representing a connection to VPP
149 * After creating a Connection object, call connect() to actually connect
150 * to VPP. Use is_msg_available to discover whether a specific message is known
151 * and supported by the VPP connected to.
156 Connection (void) : vapi_ctx{0}, event_count{0}
159 vapi_error_e rv = VAPI_OK;
162 if (VAPI_OK != (rv = vapi_ctx_alloc (&vapi_ctx)))
164 throw std::bad_alloc ();
167 events.reserve (vapi_get_message_count () + 1);
170 Connection (const Connection &) = delete;
174 vapi_ctx_free (vapi_ctx);
175 #if VAPI_CPP_DEBUG_LEAKS
176 for (auto x : shm_data_set)
178 printf ("Leaked shm_data@%p!\n", x);
184 * @brief check if message identified by it's message id is known by the
185 * vpp to which the connection is open
187 bool is_msg_available (vapi_msg_id_t type)
189 return vapi_is_msg_available (vapi_ctx, type);
193 * @brief connect to vpp
195 * @param name application name
196 * @param chroot_prefix shared memory prefix
197 * @param max_queued_request max number of outstanding requests queued
199 * @return VAPI_OK on success, other error code on error
201 vapi_error_e connect (const char *name, const char *chroot_prefix,
202 int max_outstanding_requests, int response_queue_size)
204 return vapi_connect (vapi_ctx, name, chroot_prefix,
205 max_outstanding_requests, response_queue_size,
210 * @brief disconnect from vpp
212 * @return VAPI_OK on success, other error code on error
214 vapi_error_e disconnect ()
216 auto x = requests.size ();
219 VAPI_DBG ("popping request @%p", requests.front ());
220 requests.pop_front ();
223 return vapi_disconnect (vapi_ctx);
227 * @brief get event file descriptor
229 * @note this file descriptor becomes readable when messages (from vpp)
230 * are waiting in queue
232 * @param[out] fd pointer to result variable
234 * @return VAPI_OK on success, other error code on error
236 vapi_error_e get_fd (int *fd)
238 return vapi_get_fd (vapi_ctx, fd);
242 * @brief wait for responses from vpp and assign them to appropriate objects
244 * @param limit stop dispatch after the limit object received it's response
246 * @return VAPI_OK on success, other error code on error
248 vapi_error_e dispatch (const Common_req *limit = nullptr)
250 std::lock_guard<std::mutex> lock (dispatch_mutex);
251 vapi_error_e rv = VAPI_OK;
252 bool loop_again = true;
256 size_t shm_data_size;
257 rv = vapi_recv (vapi_ctx, &shm_data, &shm_data_size);
262 #if VAPI_CPP_DEBUG_LEAKS
263 on_shm_data_alloc (shm_data);
265 std::lock_guard<std::recursive_mutex> requests_lock (requests_mutex);
266 std::lock_guard<std::recursive_mutex> events_lock (events_mutex);
267 vapi_msg_id_t id = vapi_lookup_vapi_msg_id_t (
268 vapi_ctx, be16toh (*static_cast<u16 *> (shm_data)));
269 bool has_context = vapi_msg_is_with_context (id);
270 bool break_dispatch = false;
271 Common_req *matching_req = nullptr;
274 u32 context = *reinterpret_cast<u32 *> (
275 (static_cast<u8 *> (shm_data) + vapi_get_context_offset (id)));
276 const auto x = requests.front ();
278 if (context == x->context)
280 std::tie (rv, break_dispatch) =
281 x->assign_response (id, shm_data);
285 std::tie (rv, break_dispatch) =
286 x->assign_response (id, nullptr);
290 requests.pop_front ();
297 std::tie (rv, break_dispatch) =
298 events[id]->assign_response (id, shm_data);
299 matching_req = events[id];
306 if ((matching_req && matching_req == limit && break_dispatch) ||
311 loop_again = !requests.empty () || (event_count > 0);
317 * @brief convenience wrapper function
319 vapi_error_e dispatch (const Common_req &limit)
321 return dispatch (&limit);
325 * @brief wait for response to a specific request
327 * @param req request to wait for response for
329 * @return VAPI_OK on success, other error code on error
331 vapi_error_e wait_for_response (const Common_req &req)
333 if (RESPONSE_READY == req.get_response_state ())
337 return dispatch (req);
341 void msg_free (void *shm_data)
343 #if VAPI_CPP_DEBUG_LEAKS
344 on_shm_data_free (shm_data);
346 vapi_msg_free (vapi_ctx, shm_data);
349 template <template <typename XReq, typename XResp, typename... XArgs>
351 typename Req, typename Resp, typename... Args>
352 vapi_error_e send (X<Req, Resp, Args...> *req)
359 req_context_counter.fetch_add (1, std::memory_order_relaxed);
360 req->request.shm_data->header.context = req_context;
361 vapi_swap_to_be<Req> (req->request.shm_data);
362 std::lock_guard<std::recursive_mutex> lock (requests_mutex);
363 vapi_error_e rv = vapi_send (vapi_ctx, req->request.shm_data);
366 VAPI_DBG ("Push %p", req);
367 requests.emplace_back (req);
368 req->set_context (req_context);
369 #if VAPI_CPP_DEBUG_LEAKS
370 on_shm_data_free (req->request.shm_data);
372 req->request.shm_data = nullptr; /* consumed by vapi_send */
376 vapi_swap_to_host<Req> (req->request.shm_data);
381 template <template <typename XReq, typename XResp, typename... XArgs>
383 typename Req, typename Resp, typename... Args>
384 vapi_error_e send_with_control_ping (X<Req, Resp, Args...> *req)
391 req_context_counter.fetch_add (1, std::memory_order_relaxed);
392 req->request.shm_data->header.context = req_context;
393 vapi_swap_to_be<Req> (req->request.shm_data);
394 std::lock_guard<std::recursive_mutex> lock (requests_mutex);
395 vapi_error_e rv = vapi_send_with_control_ping (
396 vapi_ctx, req->request.shm_data, req_context);
399 VAPI_DBG ("Push %p", req);
400 requests.emplace_back (req);
401 req->set_context (req_context);
402 #if VAPI_CPP_DEBUG_LEAKS
403 on_shm_data_free (req->request.shm_data);
405 req->request.shm_data = nullptr; /* consumed by vapi_send */
409 vapi_swap_to_host<Req> (req->request.shm_data);
414 void unregister_request (Common_req *request)
416 std::lock_guard<std::recursive_mutex> lock (requests_mutex);
417 std::remove (requests.begin (), requests.end (), request);
420 template <typename M> void register_event (Event_registration<M> *event)
422 const vapi_msg_id_t id = M::get_msg_id ();
423 std::lock_guard<std::recursive_mutex> lock (events_mutex);
428 template <typename M> void unregister_event (Event_registration<M> *event)
430 const vapi_msg_id_t id = M::get_msg_id ();
431 std::lock_guard<std::recursive_mutex> lock (events_mutex);
432 events[id] = nullptr;
437 std::atomic_ulong req_context_counter;
438 std::mutex dispatch_mutex;
440 std::recursive_mutex requests_mutex;
441 std::recursive_mutex events_mutex;
442 std::deque<Common_req *> requests;
443 std::vector<Common_req *> events;
446 template <typename Req, typename Resp, typename... Args>
447 friend class Request;
449 template <typename Req, typename Resp, typename... Args> friend class Dump;
451 template <typename M> friend class Result_set;
453 template <typename M> friend class Event_registration;
455 template <typename M, typename... Args>
456 friend M *vapi_alloc (Connection &con, Args...);
458 template <typename M> friend class Msg;
460 #if VAPI_CPP_DEBUG_LEAKS
461 void on_shm_data_alloc (void *shm_data)
465 auto pos = shm_data_set.find (shm_data);
466 if (pos == shm_data_set.end ())
468 shm_data_set.insert (shm_data);
472 printf ("Double-add shm_data @%p!\n", shm_data);
477 void on_shm_data_free (void *shm_data)
479 auto pos = shm_data_set.find (shm_data);
480 if (pos == shm_data_set.end ())
482 printf ("Freeing untracked shm_data @%p!\n", shm_data);
486 shm_data_set.erase (pos);
489 std::unordered_set<void *> shm_data_set;
493 template <typename Req, typename Resp, typename... Args> class Request;
495 template <typename Req, typename Resp, typename... Args> class Dump;
497 template <class, class = void> struct vapi_has_payload_trait : std::false_type
501 template <class... T> using vapi_void_t = void;
504 struct vapi_has_payload_trait<T, vapi_void_t<decltype (&T::payload)>>
509 template <typename M> void vapi_msg_set_msg_id (vapi_msg_id_t id)
511 Msg<M>::set_msg_id (id);
515 * Class representing a message stored in shared memory
517 template <typename M> class Msg
520 Msg (const Msg &) = delete;
524 VAPI_DBG ("Destroy Msg<%s>@%p, shm_data@%p",
525 vapi_get_msg_name (get_msg_id ()), this, shm_data);
528 con.get ().msg_free (shm_data);
533 static vapi_msg_id_t get_msg_id ()
535 return *msg_id_holder ();
538 template <typename X = M>
539 typename std::enable_if<vapi_has_payload_trait<X>::value,
540 decltype (X::payload) &>::type
543 return shm_data->payload;
547 Msg (Msg<M> &&msg) : con{msg.con}
549 VAPI_DBG ("Move construct Msg<%s> from msg@%p to msg@%p, shm_data@%p",
550 vapi_get_msg_name (get_msg_id ()), &msg, this, msg.shm_data);
551 shm_data = msg.shm_data;
552 msg.shm_data = nullptr;
555 Msg<M> &operator= (Msg<M> &&msg)
557 VAPI_DBG ("Move assign Msg<%s> from msg@%p to msg@%p, shm_data@%p",
558 vapi_get_msg_name (get_msg_id ()), &msg, this, msg.shm_data);
559 con.get ().msg_free (shm_data);
561 shm_data = msg.shm_data;
562 msg.shm_data = nullptr;
566 struct Msg_allocator : std::allocator<Msg<M>>
568 template <class U, class... Args> void construct (U *p, Args &&... args)
570 ::new ((void *)p) U (std::forward<Args> (args)...);
573 template <class U> struct rebind
575 typedef Msg_allocator other;
579 static void set_msg_id (vapi_msg_id_t id)
581 assert ((INVALID_MSG_ID == *msg_id_holder ()) ||
582 (id == *msg_id_holder ()));
583 *msg_id_holder () = id;
586 static vapi_msg_id_t *msg_id_holder ()
588 static vapi_msg_id_t my_id{INVALID_MSG_ID};
592 Msg (Connection &con, void *shm_data) : con{con}
594 if (!con.is_msg_available (get_msg_id ()))
596 throw Msg_not_available_exception ();
598 this->shm_data = static_cast<shm_data_type *> (shm_data);
599 VAPI_DBG ("New Msg<%s>@%p shm_data@%p", vapi_get_msg_name (get_msg_id ()),
603 void assign_response (vapi_msg_id_t resp_id, void *shm_data)
605 assert (nullptr == this->shm_data);
606 if (resp_id != get_msg_id ())
608 throw Unexpected_msg_id_exception ();
610 this->shm_data = static_cast<M *> (shm_data);
611 vapi_swap_to_host<M> (this->shm_data);
612 VAPI_DBG ("Assign response to Msg<%s>@%p shm_data@%p",
613 vapi_get_msg_name (get_msg_id ()), this, shm_data);
616 std::reference_wrapper<Connection> con;
617 using shm_data_type = M;
618 shm_data_type *shm_data;
620 friend class Connection;
622 template <typename Req, typename Resp, typename... Args>
623 friend class Request;
625 template <typename Req, typename Resp, typename... Args> friend class Dump;
627 template <typename X> friend class Event_registration;
629 template <typename X> friend class Result_set;
631 friend struct Msg_allocator;
633 template <typename X> friend void vapi_msg_set_msg_id (vapi_msg_id_t id);
637 * Class representing a simple request - with a single response message
639 template <typename Req, typename Resp, typename... Args>
640 class Request : public Common_req
643 Request (Connection &con, Args... args,
644 std::function<vapi_error_e (Request<Req, Resp, Args...> &)>
646 : Common_req{con}, callback{callback},
647 request{con, vapi_alloc<Req> (con, args...)}, response{con, nullptr}
651 Request (const Request &) = delete;
655 if (RESPONSE_NOT_READY == get_response_state ())
657 con.unregister_request (this);
661 vapi_error_e execute ()
663 return con.send (this);
666 const Msg<Req> &get_request (void) const
671 const Msg<Resp> &get_response (void)
677 virtual std::tuple<vapi_error_e, bool> assign_response (vapi_msg_id_t id,
680 assert (RESPONSE_NOT_READY == get_response_state ());
681 response.assign_response (id, shm_data);
682 set_response_state (RESPONSE_READY);
683 if (nullptr != callback)
685 return std::make_pair (callback (*this), true);
687 return std::make_pair (VAPI_OK, true);
689 std::function<vapi_error_e (Request<Req, Resp, Args...> &)> callback;
693 friend class Connection;
697 * Class representing iterable set of responses of the same type
699 template <typename M> class Result_set
706 Result_set (const Result_set &) = delete;
708 bool is_complete () const
718 using const_iterator =
719 typename std::vector<Msg<M>,
720 typename Msg<M>::Msg_allocator>::const_iterator;
722 const_iterator begin () const
727 const_iterator end () const
732 void free_response (const_iterator pos)
737 void free_all_responses ()
743 void mark_complete ()
748 void assign_response (vapi_msg_id_t resp_id, void *shm_data)
750 if (resp_id != Msg<M>::get_msg_id ())
753 throw Unexpected_msg_id_exception ();
758 vapi_swap_to_host<M> (static_cast<M *> (shm_data));
759 set.emplace_back (con, shm_data);
760 VAPI_DBG ("Result_set@%p emplace_back shm_data@%p", this, shm_data);
764 Result_set (Connection &con) : con (con), complete{false}
770 std::vector<Msg<M>, typename Msg<M>::Msg_allocator> set;
772 template <typename Req, typename Resp, typename... Args> friend class Dump;
774 template <typename X> friend class Event_registration;
778 * Class representing a dump request - zero or more identical responses to a
779 * single request message
781 template <typename Req, typename Resp, typename... Args>
782 class Dump : public Common_req
785 Dump (Connection &con, Args... args,
786 std::function<vapi_error_e (Dump<Req, Resp, Args...> &)> callback =
788 : Common_req{con}, request{con, vapi_alloc<Req> (con, args...)},
789 result_set{con}, callback{callback}
793 Dump (const Dump &) = delete;
799 virtual std::tuple<vapi_error_e, bool> assign_response (vapi_msg_id_t id,
802 if (id == vapi_msg_id_control_ping_reply)
804 con.msg_free (shm_data);
805 result_set.mark_complete ();
806 set_response_state (RESPONSE_READY);
807 if (nullptr != callback)
809 return std::make_pair (callback (*this), true);
811 return std::make_pair (VAPI_OK, true);
815 result_set.assign_response (id, shm_data);
817 return std::make_pair (VAPI_OK, false);
820 vapi_error_e execute ()
822 return con.send_with_control_ping (this);
825 Msg<Req> &get_request (void)
830 using resp_type = typename Msg<Resp>::shm_data_type;
832 const Result_set<Resp> &get_result_set (void) const
839 Result_set<resp_type> result_set;
840 std::function<vapi_error_e (Dump<Req, Resp, Args...> &)> callback;
842 friend class Connection;
846 * Class representing event registration - incoming events (messages) from
847 * vpp as a result of a subscription (typically a want_* simple request)
849 template <typename M> class Event_registration : public Common_req
854 std::function<vapi_error_e (Event_registration<M> &)> callback = nullptr)
855 : Common_req{con}, result_set{con}, callback{callback}
857 if (!con.is_msg_available (M::get_msg_id ()))
859 throw Msg_not_available_exception ();
861 con.register_event (this);
864 Event_registration (const Event_registration &) = delete;
866 virtual ~Event_registration ()
868 con.unregister_event (this);
871 virtual std::tuple<vapi_error_e, bool> assign_response (vapi_msg_id_t id,
874 result_set.assign_response (id, shm_data);
875 if (nullptr != callback)
877 return std::make_pair (callback (*this), true);
879 return std::make_pair (VAPI_OK, true);
882 using resp_type = typename M::shm_data_type;
884 Result_set<resp_type> &get_result_set (void)
890 Result_set<resp_type> result_set;
891 std::function<vapi_error_e (Event_registration<M> &)> callback;
898 * fd.io coding-style-patch-verification: ON
901 * eval: (c-set-style "gnu")