Trivial: Copyright headers

Signed-off-by: Lucy <[email protected]>

Author: lucypa

CMakeLists.txt

@@ -17,4 +17,4 @@ add_subdirectory(libvswitch)
 add_subdirectory(libfdtgen)
 add_subdirectory(libtx2bpmp)
 add_subdirectory(libplatsupportports)
-add_subdirectory(libsharedringbuffer)
+add_subdirectory(libsharedringbuffer)

libsharedringbuffer/CMakeLists.txt

@@ -1,6 +1,6 @@
 #
-# Copyright 2022, Trustworthy Systems, UNSW
-#
+# Copyright 2022, UNSW
+# SPDX-License-Identifier: BSD-2-Clause
 #
 
 cmake_minimum_required(VERSION 3.7.2)

libsharedringbuffer/README.md

@@ -1,66 +1,66 @@
 <!--
-    Copyright ?
+   Copyright 2022, UNSW
+   SPDX-License-Identifier: CC-BY-SA-4.0
 -->
 
 libsharedringbuffer
 -------------------
 
-This directory contains a library implementation of shared ring 
-buffers for the transportation of data. This is intended to be used as a 
+This directory contains a library implementation of shared ring
+buffers for the transportation of data. This is intended to be used as a
 communication mechanism between system components for bulk data transfer,
 and was originally created as a data plane between an ethernet driver and
 network stack for the sDDF. This library doesn't contain any code that
-interfaces with seL4. It is expected that the user will provide shared 
+interfaces with seL4. It is expected that the user will provide shared
 memory regions and notification/signalling handlers to this library.
 
 To use this library in a project you can link `shared_ringbuffer` in your
 target applications CMake configuration.
 
-This libary is intended to be used by both a producer and consumer. For 
+This libary is intended to be used by both a producer and a consumer. For
 example, an ethernet driver produces data for a network stack to consume.
 2 separate shared memory regions are required for each ring handle; one
 to store available buffers and one to store used buffers. Each ring buffer
-contains a separate read index and write index. The reader only ever 
-increments the read index, and the writer the write index. As read and 
+contains a separate read index and write index. The reader only ever
+increments the read index, and the writer the write index. As read and
 writes of a small integer are atomic, we can keep memory consistent
 without locks.
 The size of the ring buffers can be set with the cmake config option,
 `LIB_SHARED_RINGBUFFER_DESC_COUNT` but defaults to 512. The user must
-ensure that the shared memory regions handed to the library are of 
-appropriate size to match this. 
+ensure that the shared memory regions handed to the library are of
+appropriate size to match this.
 
 Use case
 ---------
 
 This library is intended to be used with a separate shared memory region,
 usually allocated for DMA for a driver. The ring buffers can then contain
 pointers into this shared memory, indicating which buffers are in use or
-available to be used by either component. 
+available to be used by either component.
 Typically, 2 shared ring buffers are required, with separate structures
 required on the recieve path and transmit path. Thus there are 4 regions
-of shared memory required: 1 storing pointers to available RX buffers, 
+of shared memory required: 1 storing pointers to available RX buffers,
 1 storing pointers to used RX buffers, 1 storing pointers to TX 
 buffers, and another storing pointers to available TX buffers.
 
-On initialisation, both the producer and consumer should allocate their 
+On initialisation, both the producer and consumer should allocate their
 own ring handles (`struct ring_handle`). These data structures simply
-store pointers to the actual shared memory regions and are used to 
+store pointers to the actual shared memory regions and are used to
 interface with this library. The ring handle should then be passed into
-`ring_init` along with 2 shared memory regions, an optional function 
-pointer to signal the other component, and either 1 or 0 to indicate 
+`ring_init` along with 2 shared memory regions, an optional function
+pointer to signal the other component, and either 1 or 0 to indicate
 whether the read/write indices need to be initialised (note that only one
-side of the shared memory regions needs to do this). 
+side of the shared memory regions needs to do this).
 
-After initialisation, a typical use case would look like: 
+After initialisation, a typical use case would look like:
 The driver wants to add some buffer that will be read by another component
-(for example, a network stack processing incoming packets). 
+(for example, a network stack processing incoming packets).
 
-    1. The driver dequeues a pointer to an available buffer from the 
+    1. The driver dequeues a pointer to an available buffer from the
     available ring.
-    2. Once data is inserted into the buffer (eg. via DMA), the driver 
+    2. Once data is inserted into the buffer (eg. via DMA), the driver
     then enqueues the pointer to it into the used ring.
-    3. The driver can then notify the reciever. 
-    4. Similarly, the reciever dequeues the pointer from the used ring, 
+    3. The driver can then notify the reciever.
+    4. Similarly, the reciever dequeues the pointer from the used ring,
     processes the data, and once finished, can enqueue it back into
     the available ring to be used once more by the driver.
-

libsharedringbuffer/include/shared_ringbuffer/shared_ringbuffer.h

@@ -1,8 +1,10 @@
 /*
- * Copyright 2022, UNSW ???
+ * Copyright 2022, UNSW
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
  */
 
-#pragma once 
+#pragma once
 
 #include <stdint.h>
 #include <stddef.h>
@@ -35,7 +37,6 @@ typedef struct ring_handle {
     notify_fn notify;
 } ring_handle_t;
 
-
 /**
  * Initialise the shared ring buffer.
  *
@@ -44,7 +45,7 @@ typedef struct ring_handle {
  * @param used pointer to 'used' ring in shared memory.
  * @param notify function pointer used to notify the other user.
  * @param buffer_init 1 indicates the read and write indices in shared memory need to be initialised.
- *                    0 inidicates they do not. Only one side of the shared memory regions needs to do this. 
+ *                    0 inidicates they do not. Only one side of the shared memory regions needs to do this.
  */
 void ring_init(ring_handle_t *ring, ring_buffer_t *avail, ring_buffer_t *used, notify_fn notify, int buffer_init);
 
@@ -55,7 +56,7 @@ void ring_init(ring_handle_t *ring, ring_buffer_t *avail, ring_buffer_t *used, n
  *
  * @return true indicates the buffer is empty, false otherwise.
  */
-static inline int ring_empty(ring_buffer_t *ring) 
+static inline int ring_empty(ring_buffer_t *ring)
 {
     return !((ring->write_idx - ring->read_idx) % CONFIG_LIB_SHARED_RINGBUFFER_DESC_COUNT);
 }
@@ -74,11 +75,11 @@ static inline int ring_full(ring_buffer_t *ring)
 
 /**
  * Notify the other user of changes to the shared ring buffers.
- * 
+ *
  * @param ring the ring handle used.
  *
  */
-static inline void notify(ring_handle_t *ring) 
+static inline void notify(ring_handle_t *ring)
 {
     return ring->notify();
 }
@@ -89,15 +90,15 @@ static inline void notify(ring_handle_t *ring)
  * @param ring Ring buffer to enqueue into.
  * @param buffer address into shared memory where data is stored.
  * @param len length of data inside the buffer above.
- * @param cookie optional pointer to data required on dequeueing. 
+ * @param cookie optional pointer to data required on dequeueing.
  *
  * @return -1 when ring is empty, 0 on success.
  */
-static inline int enqueue(ring_buffer_t *ring, uintptr_t buffer, unsigned int len, void *cookie) 
+static inline int enqueue(ring_buffer_t *ring, uintptr_t buffer, unsigned int len, void *cookie)
 {
     if (ring_full(ring)) {
         ZF_LOGE("Ring full");
-        return -1; 
+        return -1;
     }
 
     ring->buffers[ring->write_idx % CONFIG_LIB_SHARED_RINGBUFFER_DESC_COUNT].encoded_addr = buffer;
@@ -116,11 +117,11 @@ static inline int enqueue(ring_buffer_t *ring, uintptr_t buffer, unsigned int le
  * @param ring Ring buffer to Dequeue from.
  * @param buffer pointer to the address of where to store buffer address.
  * @param len pointer to variable to store length of data dequeueing.
- * @param cookie pointer optional pointer to data required on dequeueing. 
+ * @param cookie pointer optional pointer to data required on dequeueing.
  *
  * @return -1 when ring is empty, 0 on success.
  */
-static inline int dequeue(ring_buffer_t *ring, uintptr_t *addr, unsigned int *len, void **cookie) 
+static inline int dequeue(ring_buffer_t *ring, uintptr_t *addr, unsigned int *len, void **cookie)
 {
     if (ring_empty(ring)) {
         ZF_LOGF("Ring is empty");
@@ -139,16 +140,16 @@ static inline int dequeue(ring_buffer_t *ring, uintptr_t *addr, unsigned int *le
 
 /**
  * Enqueue an element into an available ring buffer.
- * This indicates the buffer address parameter is currently available for use. 
+ * This indicates the buffer address parameter is currently available for use.
  *
  * @param ring Ring handle to enqueue into.
  * @param buffer address into shared memory where data is stored.
  * @param len length of data inside the buffer above.
- * @param cookie optional pointer to data required on dequeueing. 
+ * @param cookie optional pointer to data required on dequeueing.
  *
  * @return -1 when ring is empty, 0 on success.
  */
-static inline int enqueue_avail(ring_handle_t *ring, uintptr_t addr, unsigned int len, void *cookie) 
+static inline int enqueue_avail(ring_handle_t *ring, uintptr_t addr, unsigned int len, void *cookie)
 {
     return enqueue(ring->avail_ring, addr, len, cookie);
 }
@@ -160,11 +161,11 @@ static inline int enqueue_avail(ring_handle_t *ring, uintptr_t addr, unsigned in
  * @param ring Ring handle to enqueue into.
  * @param buffer address into shared memory where data is stored.
  * @param len length of data inside the buffer above.
- * @param cookie optional pointer to data required on dequeueing. 
+ * @param cookie optional pointer to data required on dequeueing.
  *
  * @return -1 when ring is empty, 0 on success.
  */
-static inline int enqueue_used(ring_handle_t *ring, uintptr_t addr, unsigned int len, void *cookie) 
+static inline int enqueue_used(ring_handle_t *ring, uintptr_t addr, unsigned int len, void *cookie)
 {
     return enqueue(ring->used_ring, addr, len, cookie);
 }
@@ -175,11 +176,11 @@ static inline int enqueue_used(ring_handle_t *ring, uintptr_t addr, unsigned int
  * @param ring Ring handle to dequeue from.
  * @param buffer pointer to the address of where to store buffer address.
  * @param len pointer to variable to store length of data dequeueing.
- * @param cookie pointer optional pointer to data required on dequeueing. 
+ * @param cookie pointer optional pointer to data required on dequeueing.
  *
  * @return -1 when ring is empty, 0 on success.
  */
-static inline int dequeue_avail(ring_handle_t *ring, uintptr_t *addr, unsigned int *len, void **cookie) 
+static inline int dequeue_avail(ring_handle_t *ring, uintptr_t *addr, unsigned int *len, void **cookie)
 {
     return dequeue(ring->avail_ring, addr, len, cookie);
 }
@@ -190,19 +191,19 @@ static inline int dequeue_avail(ring_handle_t *ring, uintptr_t *addr, unsigned i
  * @param ring Ring handle to dequeue from.
  * @param buffer pointer to the address of where to store buffer address.
  * @param len pointer to variable to store length of data dequeueing.
- * @param cookie pointer optional pointer to data required on dequeueing. 
+ * @param cookie pointer optional pointer to data required on dequeueing.
  *
  * @return -1 when ring is empty, 0 on success.
  */
-static inline int dequeue_used(ring_handle_t *ring, uintptr_t *addr, unsigned int *len, void **cookie) 
+static inline int dequeue_used(ring_handle_t *ring, uintptr_t *addr, unsigned int *len, void **cookie)
 {
     return dequeue(ring->used_ring, addr, len, cookie);
 }
 
 /**
  * Dequeue an element from a ring buffer.
  * This function is intended for use by the driver, to collect a pointer
- * into this structure to be passed around as a cookie. 
+ * into this structure to be passed around as a cookie.
  *
  * @param ring Ring buffer to dequeue from.
  * @param addr pointer to the address of where to store buffer address.
@@ -211,7 +212,6 @@ static inline int dequeue_used(ring_handle_t *ring, uintptr_t *addr, unsigned in
  *
  * @return -1 when ring is empty, 0 on success.
  */
-
 static int driver_dequeue(ring_buffer_t *ring, uintptr_t *addr, unsigned int *len, void **cookie)
 {
     if (!((ring->write_idx - ring->read_idx) % CONFIG_LIB_SHARED_RINGBUFFER_DESC_COUNT)) {
@@ -228,4 +228,4 @@ static int driver_dequeue(ring_buffer_t *ring, uintptr_t *addr, unsigned int *le
     ring->read_idx++;
 
     return 0;
-}
+}

libsharedringbuffer/src/shared_ringbuffer.c

@@ -1,5 +1,6 @@
 /*
- * Copyright 2022, UNSW ??
+ * Copyright 2022, UNSW
+ * SPDX-License-Identifier: BSD-2-Clause
  */
 
 #include <shared_ringbuffer/shared_ringbuffer.h>
@@ -16,4 +17,4 @@ void ring_init(ring_handle_t *ring, ring_buffer_t *avail, ring_buffer_t *used, n
         ring->avail_ring->write_idx = 0;
         ring->avail_ring->read_idx = 0;
     }
-}
+}

libvirtqueue/include/virtqueue.h

@@ -188,4 +188,4 @@ int virtqueue_gather_available(virtqueue_device_t *vq, virtqueue_ring_object_t *
  * @return 1 on success, 0 on failure (no more buffer available)
  */
 int virtqueue_gather_used(virtqueue_driver_t *vq, virtqueue_ring_object_t *robj,
-                          void **buf, unsigned *len, vq_flags_t *flag);
+                          void **buf, unsigned *len, vq_flags_t *flag);

libvirtqueue/src/virtqueue.c

@@ -129,7 +129,6 @@ int virtqueue_add_available_buf(virtqueue_driver_t *vq, virtqueue_ring_object_t
         vq->avail_ring->ring[vq->avail_ring->idx] = idx;
         vq->avail_ring->idx = (vq->avail_ring->idx + 1) & (vq->queue_len - 1);
     }
-
     return 1;
 }
 
@@ -154,7 +153,6 @@ int virtqueue_add_used_buf(virtqueue_device_t *vq, virtqueue_ring_object_t *robj
     vq->used_ring->ring[cur].id = robj->first;
     vq->used_ring->ring[cur].len = len;
     vq->used_ring->idx = (cur + 1) & (vq->queue_len - 1);
-
     return 1;
 }
 
@@ -216,4 +214,4 @@ int virtqueue_gather_used(virtqueue_driver_t *vq, virtqueue_ring_object_t *robj,
     }
     robj->cur = vq_pop_desc(vq, robj->cur, buf, len, flag);
     return 1;
-}
+}