aboutsummaryrefslogtreecommitdiffstats
path: root/resources/tools/testbed-setup/ansible/roles/dpdk/tasks/main.yaml
blob: 1b4e398e2613812237ca286f4c5fd495ae060028 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

---
# file: roles/dpdk/tasks/main.yaml

- name: DPDK - Install Distribution - Release - Machine Prerequisites
  package:
    name: "{{ packages | flatten(levels=1) }}"
    state: latest
    update_cache: true
  tags:
    - install-dependencies

- name: DPDK - Download Release Archive
  get_url:
    url: "{{ dpdk_url }}/dpdk-{{ item }}.tar.xz"
    dest: "{{ dpdk_target_dir }}/dpdk-{{ item }}.tar.xz"
    mode: 0644
  loop: "{{ dpdk_version }}"
  register: "dpdk_downloaded"
  tags:
    - install-dpdk

- name: DPDK - Extract Release Archive
  unarchive:
    remote_src: true
    src: "{{ dpdk_target_dir }}/dpdk-{{ item }}.tar.xz"
    dest: "{{ dpdk_target_dir }}/"
    creates: "{{ dpdk_target_dir }}/dpdk-{{ item }}"
  loop: "{{ dpdk_version }}"
  when: "dpdk_downloaded"
  register: "dpdk_extracted"
  tags:
    - install-dpdk

- name: DPDK - Build igb_uio by default
  lineinfile:
    dest: "{{ dpdk_target_dir }}/dpdk-{{ item }}/config/common_base"
    regexp: "^CONFIG_RTE_EAL_IGB_UIO"
    line: "CONFIG_RTE_EAL_IGB_UIO=y"
  loop: "{{ dpdk_version }}"
  when: "dpdk_extracted"
  register: "dpdk_configured"
  tags:
    - install-dpdk

- name: DPDK - Compile Release I
  become: yes
  command: "make install T={{ dpdk_build_targets[item][ansible_machine] }} DESTDIR={{ dpdk_target_dir }}/dpdk-{{ item }} chdir={{ dpdk_target_dir }}/dpdk-{{ item }}"
  loop: "{{ dpdk_version }}"
  when: "dpdk_configured"
  register: "dpdk_compiled"
  tags:
    - install-dpdk

- name: DPDK - Link igb_uio Module
  shell: "ln -fs {{ dpdk_target_dir }}/dpdk-{{ item }}/{{ dpdk_build_targets[item][ansible_machine] }}/kmod/igb_uio.ko /lib/modules/`uname -r`/igb_uio.ko && depmod -a"
  ignore_errors: "yes"
  loop: "{{ dpdk_version }}"
  when: "dpdk_compiled"
  tags:
    - install-dpdk
an class="n">svm_msg_q_msg_t svm_msg_q_alloc_msg (svm_msg_q_t * mq, u32 nbytes); /** * Allocate message buffer on ring * * Message is allocated, on requested ring. The caller MUST check that * the ring is not full. * * @param mq message queue * @param ring_index ring on which the allocation should occur * @return message structure pointing to the ring and position * allocated */ svm_msg_q_msg_t svm_msg_q_alloc_msg_w_ring (svm_msg_q_t * mq, u32 ring_index); /** * Lock message queue and allocate message buffer on ring * * This should be used when multiple writers/readers are expected to * compete for the rings/queue. Message should be enqueued by calling * @ref svm_msg_q_add_w_lock and the caller MUST unlock the queue once * the message in enqueued. * * @param mq message queue * @param ring_index ring on which the allocation should occur * @param noblock flag that indicates if request should block * @param msg pointer to message to be filled in * @return 0 on success, negative number otherwise */ int svm_msg_q_lock_and_alloc_msg_w_ring (svm_msg_q_t * mq, u32 ring_index, u8 noblock, svm_msg_q_msg_t * msg); /** * Free message buffer * * Marks message buffer on ring as free. * * @param mq message queue * @param msg message to be freed */ void svm_msg_q_free_msg (svm_msg_q_t * mq, svm_msg_q_msg_t * msg); /** * Producer enqueue one message to queue * * Prior to calling this, the producer should've obtained a message buffer * from one of the rings by calling @ref svm_msg_q_alloc_msg. * * @param mq message queue * @param msg message (pointer to ring position) to be enqueued * @param nowait flag to indicate if request is blocking or not * @return success status */ int svm_msg_q_add (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, int nowait); /** * Producer enqueue one message to queue with mutex held * * Prior to calling this, the producer should've obtained a message buffer * from one of the rings by calling @ref svm_msg_q_alloc_msg. It assumes * the queue mutex is held. * * @param mq message queue * @param msg message (pointer to ring position) to be enqueued * @return success status */ void svm_msg_q_add_and_unlock (svm_msg_q_t * mq, svm_msg_q_msg_t * msg); /** * Consumer dequeue one message from queue * * This returns the message pointing to the data in the message rings. * The consumer is expected to call @ref svm_msg_q_free_msg once it * finishes processing/copies the message data. * * @param mq message queue * @param msg pointer to structure where message is to be received * @param cond flag that indicates if request should block or not * @param time time to wait if condition it SVM_Q_TIMEDWAIT * @return success status */ int svm_msg_q_sub (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, svm_q_conditional_wait_t cond, u32 time); /** * Consumer dequeue one message from queue with mutex held * * Returns the message pointing to the data in the message rings under the * assumption that the message queue lock is already held. The consumer is * expected to call @ref svm_msg_q_free_msg once it finishes * processing/copies the message data. * * @param mq message queue * @param msg pointer to structure where message is to be received * @return success status */ void svm_msg_q_sub_w_lock (svm_msg_q_t * mq, svm_msg_q_msg_t * msg); /** * Get data for message in queue * * @param mq message queue * @param msg message for which the data is requested * @return pointer to data */ void *svm_msg_q_msg_data (svm_msg_q_t * mq, svm_msg_q_msg_t * msg); /** * Get message queue ring * * @param mq message queue * @param ring_index index of ring * @return pointer to ring */ svm_msg_q_ring_t *svm_msg_q_ring (svm_msg_q_t * mq, u32 ring_index); /** * Set event fd for queue consumer * * If set, queue will exclusively use eventfds for signaling. Moreover, * afterwards, the queue should only be used in non-blocking mode. Waiting * for events should be done externally using something like epoll. * * @param mq message queue * @param fd consumer eventfd */ void svm_msg_q_set_consumer_eventfd (svm_msg_q_t * mq, int fd); /** * Set event fd for queue producer * * If set, queue will exclusively use eventfds for signaling. Moreover, * afterwards, the queue should only be used in non-blocking mode. Waiting * for events should be done externally using something like epoll. * * @param mq message queue * @param fd producer eventfd */ void svm_msg_q_set_producer_eventfd (svm_msg_q_t * mq, int fd); /** * Allocate event fd for queue consumer */ int svm_msg_q_alloc_consumer_eventfd (svm_msg_q_t * mq); /** * Allocate event fd for queue consumer */ int svm_msg_q_alloc_producer_eventfd (svm_msg_q_t * mq); /** * Check if message queue is full */ static inline u8 svm_msg_q_is_full (svm_msg_q_t * mq) { return (mq->q->cursize == mq->q->maxsize); } static inline u8 svm_msg_q_ring_is_full (svm_msg_q_t * mq, u32 ring_index) { ASSERT (ring_index < vec_len (mq->rings)); return (mq->rings[ring_index].cursize == mq->rings[ring_index].nitems); } /** * Check if message queue is empty */ static inline u8 svm_msg_q_is_empty (svm_msg_q_t * mq) { return (mq->q->cursize == 0); } /** * Check length of message queue */ static inline u32 svm_msg_q_size (svm_msg_q_t * mq) { return mq->q->cursize; } /** * Check if message is invalid */ static inline u8 svm_msg_q_msg_is_invalid (svm_msg_q_msg_t * msg) { return (msg->as_u64 == (u64) ~ 0); } /** * Try locking message queue */ static inline int svm_msg_q_try_lock (svm_msg_q_t * mq) { return pthread_mutex_trylock (&mq->q->mutex); } /** * Lock, or block trying, the message queue */ static inline int svm_msg_q_lock (svm_msg_q_t * mq) { return pthread_mutex_lock (&mq->q->mutex); } /** * Unlock message queue */ static inline void svm_msg_q_unlock (svm_msg_q_t * mq) { pthread_mutex_unlock (&mq->q->mutex); } /** * Wait for message queue event * * Must be called with mutex held. The queue only works non-blocking * with eventfds, so handle blocking calls as an exception here. */ static inline void svm_msg_q_wait (svm_msg_q_t * mq) { svm_queue_wait (mq->q); } /** * Timed wait for message queue event * * Must be called with mutex held. * * @param mq message queue * @param timeout time in seconds */ static inline int svm_msg_q_timedwait (svm_msg_q_t * mq, double timeout) { return svm_queue_timedwait (mq->q, timeout); } static inline int svm_msg_q_get_consumer_eventfd (svm_msg_q_t * mq) { return mq->q->consumer_evtfd; } static inline int svm_msg_q_get_producer_eventfd (svm_msg_q_t * mq) { return mq->q->producer_evtfd; } #endif /* SRC_SVM_MESSAGE_QUEUE_H_ */ /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */