devq: cleanup of error messages
authorRoni Häcki <roni.haecki@inf.ethz.ch>
Tue, 7 Mar 2017 09:58:04 +0000 (10:58 +0100)
committerRoni Häcki <roni.haecki@inf.ethz.ch>
Tue, 7 Mar 2017 09:58:04 +0000 (10:58 +0100)
Signed-off-by: Roni Häcki <roni.haecki@inf.ethz.ch>

errors/errno.fugu
lib/blk/blk_ahci/device_impl.c
lib/devif/backends/idc/desc_queue.c
lib/devif/backends/net/e10k/devif_backend_e10k.c
lib/devif/backends/net/solarflare/devif_backend_solarflare.c
lib/devif/queue_interface.c
lib/devif/region_pool.c
usr/drivers/ahcid/test.c

index e8f4e9d..1cea0f2 100755 (executable)
@@ -1039,17 +1039,6 @@ errors ahcid AHCI_ERR_ {
     failure ILLEGAL_ARGUMENT    "Illegal argument in call",
 };
 
-// errors generated by devif
-errors ahcid DEV_ERR_ {
-    failure NOT_INITIALIZED     "Queue exists but could not be initialized.",
-    failure NOT_FOUND           "Invalid queue requested, not found?",
-    failure ALREADY_CREATED     "The queue specified has already been created.",
-    failure REGISTER_BUFFER     "Unable to register the buffer with the driver.",
-    failure INVALID_BUFFER_ARGS "Invalid arguments for specified buffer.",
-    failure QUEUE_EMPTY         "Nothing to dequeue.",
-    failure QUEUE_FULL          "The queue is full.",
-};
-
 errors sata SATA_ERR_ {
     failure INVALID_TYPE        "Unknown FIS type or invalid/unimplemented field for type",
 };
@@ -1229,11 +1218,13 @@ errors cpuid DEVQ_ERR_ {
     failure BUFFER_NOT_IN_REGION    "The buffer id is not in this region",
     failure BUFFER_ALREADY_IN_USE   "The buffer is already in use",
     failure BUFFER_NOT_IN_USE       "The buffer not in use",
+    failure INVALID_BUFFER_ARGS     "Invalid arguments for specified buffer.",
     failure INVALID_REGION_ID       "The region id is not valid",
     failure REGION_DESTROY          "The region has still buffers that are in use",
-    failure REGION_INVALID          "Invalid arguments for region",
-    failure TX_FULL                 "Send queue full",
-    failure RX_EMPTY                "Receive queue emtpy",
+    failure INVALID_REGION_ARGS     "Invalid arguments for region",
+    failure REGISTER_REGION         "Unable to register region with queue",
+    failure QUEUE_EMPTY             "Nothing to dequeue.",
+    failure QUEUE_FULL              "The queue is full.",
     failure DESCQ_INIT              "Failure in descriptor queue init",
 };
 
index d83a965..dda23ce 100644 (file)
@@ -35,7 +35,7 @@ static errval_t request_slot_alloc(struct ahci_queue* dq, size_t* slot)
         }
     }
 
-    return DEV_ERR_QUEUE_FULL;
+    return DEVQ_ERR_QUEUE_FULL;
 }
 
 static errval_t get_port(struct ahci_disk* hba, size_t port_num, struct ahci_port** p) {
@@ -45,7 +45,7 @@ static errval_t get_port(struct ahci_disk* hba, size_t port_num, struct ahci_por
 
     struct ahci_port* port = &hba->ports[port_num];
     if (!port->is_initialized) {
-        return err_push(err, DEV_ERR_NOT_INITIALIZED);
+        return err_push(err, DEVQ_ERR_INIT_QUEUE);
     }
 
     *p = port;
@@ -126,7 +126,7 @@ static errval_t ahci_enqueue(struct devq *q,
     struct dma_mem* mem = &queue->buffers[(region_id % MAX_BUFFERS)];
 
     if (!slice_is_in_range(mem, offset, length)) {
-        return DEV_ERR_INVALID_BUFFER_ARGS;
+        return DEVQ_ERR_INVALID_BUFFER_ARGS;
     }
 
     size_t slot = 0;
@@ -183,7 +183,7 @@ static errval_t ahci_dequeue(struct devq* q,
         }
     }
 
-    return DEV_ERR_QUEUE_EMPTY;
+    return DEVQ_ERR_QUEUE_EMPTY;
 }
 
 static errval_t ahci_register(struct devq *q,
@@ -191,7 +191,7 @@ static errval_t ahci_register(struct devq *q,
                               regionid_t region_id)
 {
 
-    errval_t err = DEV_ERR_REGISTER_BUFFER;
+    errval_t err = DEVQ_ERR_REGISTER_REGION;
     assert(!capref_is_null(cap));
     struct ahci_queue *queue = (struct ahci_queue*) q;
 
@@ -209,7 +209,7 @@ static errval_t ahci_register(struct devq *q,
         err = dma_mem_from_capref(cap, mem);
         if (err_is_fail(err)) {
             DEBUG_ERR(err, "call failed");
-            return err_push(err, DEV_ERR_REGISTER_BUFFER);
+            return err_push(err, DEVQ_ERR_REGISTER_REGION);
         }
         return SYS_ERR_OK;
     }
index abab5cc..d19c35a 100644 (file)
@@ -98,7 +98,7 @@ static errval_t descq_enqueue(struct devq* queue,
     struct descq* q = (struct descq*) queue;
     size_t head = q->tx_seq % q->slots;
     if ((q->tx_seq - q->tx_seq_ack->value) > (q->slots-1)) {
-        return DEVQ_ERR_TX_FULL;
+        return DEVQ_ERR_QUEUE_FULL;
     }
     
     q->tx_descs[head].rid = region_id;
@@ -147,7 +147,7 @@ static errval_t descq_dequeue(struct devq* queue,
     uint64_t seq = q->rx_descs[q->rx_seq % q->slots].seq;   
     
     if (!(q->rx_seq == seq)) {
-        return DEVQ_ERR_RX_EMPTY;
+        return DEVQ_ERR_QUEUE_EMPTY;
     }
 
     size_t tail = q->rx_seq % q->slots;
index 22732b5..d2c5e5f 100644 (file)
@@ -264,14 +264,14 @@ static errval_t e10k_dequeue(struct devq* q, regionid_t* rid,
 
     if (!e10k_queue_get_rxbuf(que, rid, offset, length, valid_data, 
                              valid_length, flags, &last)) {
-        err = DEVQ_ERR_RX_EMPTY;
+        err = DEVQ_ERR_QUEUE_EMPTY;
     } else {
         return SYS_ERR_OK;
     }
      
     if (!e10k_queue_get_txbuf(que, rid, offset, length, valid_data,
                               valid_length, flags)) {
-        err = DEVQ_ERR_RX_EMPTY;
+        err = DEVQ_ERR_QUEUE_EMPTY;
     }  else {
         return SYS_ERR_OK;
     }
index 6266c6f..22c2e04 100644 (file)
@@ -154,7 +154,7 @@ static errval_t sfn5122f_deregister(struct devq* q, regionid_t rid)
     struct region_entry* cur = queue->regions;
 
     if (cur == NULL) {
-        return SFN_ERR_DEREGISTER_REGION;
+        return DEVQ_ERR_INVALID_REGION_ARGS;
     }
 
     while (cur->next != NULL && cur->rid != rid) {
@@ -200,7 +200,7 @@ static errval_t enqueue_rx_buf(struct sfn5122f_queue* q, regionid_t rid,
     if (sfn5122f_queue_free_rxslots(q) == 0) {
         printf("SFN5122F_%d: Not enough space in RX ring, not adding buffer\n",
                 q->id);
-        return SFN_ERR_ENQUEUE;
+        return DEVQ_ERR_QUEUE_FULL;
     }
 
     // find region
@@ -211,7 +211,7 @@ static errval_t enqueue_rx_buf(struct sfn5122f_queue* q, regionid_t rid,
     }
     
     if (entry == NULL) {
-        return SFN_ERR_ENQUEUE;
+        return DEVQ_ERR_INVALID_REGION_ARGS;
     }
     
     // compute buffer table entry of the rx buffer and the within it offset
@@ -247,7 +247,7 @@ static errval_t enqueue_tx_buf(struct sfn5122f_queue* q, regionid_t rid,
     if (sfn5122f_queue_free_txslots(q) == 0) {
         printf("SFN5122F_%d: Not enough space in TX ring, not adding buffer\n",
                 q->id);
-        return SFN_ERR_ENQUEUE;
+        return DEVQ_ERR_QUEUE_FULL;
     }
 
     // find region
@@ -258,7 +258,7 @@ static errval_t enqueue_tx_buf(struct sfn5122f_queue* q, regionid_t rid,
     }
     
     if (entry == NULL) {
-        return SFN_ERR_ENQUEUE;
+        return DEVQ_ERR_INVALID_REGION_ARGS;
     }
     
     // compute buffer table entry of the rx buffer and the within it offset
@@ -325,7 +325,7 @@ static errval_t sfn5122f_dequeue(struct devq* q, regionid_t* rid, genoffset_t* o
                                  genoffset_t* valid_length, uint64_t* flags)
 {
     uint8_t ev_code;
-    errval_t err = DEVQ_ERR_RX_EMPTY;
+    errval_t err = DEVQ_ERR_QUEUE_EMPTY;
     
     struct sfn5122f_queue* queue = (struct sfn5122f_queue*) q;
 
@@ -440,7 +440,7 @@ errval_t sfn5122f_queue_create(struct sfn5122f_queue** q, sfn5122f_event_cb_t cb
     total_size = sizeof(uint64_t)*(TX_ENTRIES + RX_ENTRIES + EV_ENTRIES);
     tx_virt = alloc_map_frame(VREGION_FLAGS_READ_WRITE, total_size, &frame);
     if (tx_virt == NULL) {
-        return SFN_ERR_ALLOC_QUEUE;
+        return DEVQ_ERR_INIT_QUEUE;
     }
 
     rx_virt = tx_virt + (sizeof(uint64_t) *TX_ENTRIES);
index a5b1af1..63573d1 100644 (file)
@@ -54,7 +54,7 @@ errval_t devq_enqueue(struct devq *q,
     // check if the buffer to enqueue is valid
     if (!region_pool_buffer_check_bounds(q->pool, region_id, offset, 
         length, valid_data, valid_length)) {
-        return DEV_ERR_INVALID_BUFFER_ARGS;
+        return DEVQ_ERR_INVALID_BUFFER_ARGS;
     }
 
 
@@ -108,7 +108,7 @@ errval_t devq_dequeue(struct devq *q,
     // check if the dequeue buffer is valid
     if (!region_pool_buffer_check_bounds(q->pool, *region_id, *offset, 
         *length, *valid_data, *valid_length)) {
-        return DEV_ERR_INVALID_BUFFER_ARGS;
+        return DEVQ_ERR_INVALID_BUFFER_ARGS;
     }
 
     DQI_DEBUG("Dequeue q=%p rid=%d, bid=%d \n", q, *region_id, *buffer_id);
index 6668bc3..fafe532 100644 (file)
@@ -179,7 +179,7 @@ errval_t region_pool_add_region(struct region_pool* pool,
 
         // check if region is already registered
         if (tmp->base_addr == id.base) {
-            return DEVQ_ERR_REGION_INVALID;
+            return DEVQ_ERR_INVALID_REGION_ARGS;
         }
 
         /* if region if entierly before other region or
@@ -187,7 +187,7 @@ errval_t region_pool_add_region(struct region_pool* pool,
          */
         if (!((id.base + id.bytes <= tmp->base_addr) ||
             (tmp->base_addr + tmp->len <= id.base))) {
-            return DEVQ_ERR_REGION_INVALID;
+            return DEVQ_ERR_INVALID_REGION_ARGS;
         }
 
     }
index 0a3d881..cae702c 100644 (file)
@@ -168,11 +168,11 @@ void ahci_simple_test(void)
         if (err_is_ok(err)) {
             break;
         }
-        if (err_is_fail(err) && err_no(err) != DEV_ERR_QUEUE_EMPTY) {
+        if (err_is_fail(err) && err_no(err) != DEVQ_ERR_QUEUE_EMPTY) {
             USER_PANIC_ERR(err, "devq dequeue");
         }
         wait_for_interrupt();
-    } while (err_no(err) == DEV_ERR_QUEUE_EMPTY);
+    } while (err_no(err) == DEVQ_ERR_QUEUE_EMPTY);
 
     assert (offset == 0);
     assert (length == 512);
@@ -197,13 +197,13 @@ static void blocking_dequeue(void* q, regionid_t* region_id,
         if (err_is_ok(err)) {
             break;
         }
-        if (err_is_fail(err) && err_no(err) != DEV_ERR_QUEUE_EMPTY) {
+        if (err_is_fail(err) && err_no(err) != DEVQ_ERR_QUEUE_EMPTY) {
             USER_PANIC_ERR(err, "devq dequeue");
         }
 
-        assert(err_no(err) == DEV_ERR_QUEUE_EMPTY);
+        assert(err_no(err) == DEVQ_ERR_QUEUE_EMPTY);
         wait_for_interrupt();
-    } while (err_no(err) == DEV_ERR_QUEUE_EMPTY);
+    } while (err_no(err) == DEVQ_ERR_QUEUE_EMPTY);
 }
 
 static void receive_block(void)
@@ -250,7 +250,7 @@ void ahci_perf_sequential(size_t buffer_size, size_t block_size, bool write)
             if (err_is_ok(err)) {
                 break;
             }
-            else if (err_no(err) == DEV_ERR_QUEUE_FULL) {
+            else if (err_no(err) == DEVQ_ERR_QUEUE_FULL) {
                 receive_block();
             }
             else {
@@ -326,7 +326,7 @@ void ahci_verify_sequential(size_t buffer_size, size_t block_size)
             if (err_is_ok(err)) {
                 break;
             }
-            else if (err_no(err) == DEV_ERR_QUEUE_FULL) {
+            else if (err_no(err) == DEVQ_ERR_QUEUE_FULL) {
                 receive_block();
             }
             else {
@@ -353,7 +353,7 @@ void ahci_verify_sequential(size_t buffer_size, size_t block_size)
             if (err_is_ok(err)) {
                 break;
             }
-            else if (err_no(err) == DEV_ERR_QUEUE_FULL) {
+            else if (err_no(err) == DEVQ_ERR_QUEUE_FULL) {
                 receive_block();
             }
             else {