make zero_filled function required

Author: calccrypto

examples/providers/common.c

@@ -122,6 +122,23 @@ dpusm_provider_copy_to_generic(dpusm_mv_t *mv, void *buf, size_t size) {
     return DPUSM_OK;
 }
 
+int dpusm_zero_fill(void *handle, size_t offset, size_t size) {
+    alloc_t *alloc = (alloc_t *) handle;
+    if (!alloc) {
+        return DPUSM_ERROR;
+    }
+
+    /* would go past buffer */
+    if (alloc->size <= (offset + size)) {
+        return DPUSM_ERROR;
+    }
+
+    void *ptr = ptr_offset(alloc->ptr, offset);
+    memset(ptr, 0, size);
+
+    return DPUSM_OK;
+}
+
 const dpusm_pf_t example_dpusm_provider_functions = {
     .algorithms                = dpusm_provider_algorithms,
     .alloc                     = dpusm_provider_alloc,
@@ -140,10 +157,10 @@ const dpusm_pf_t example_dpusm_provider_functions = {
                                                  .scatterlist = NULL,
                                              },
                                  },
+    .zero_fill                 = dpusm_zero_fill,
     .at_connect                = NULL,
     .at_disconnect             = NULL,
     .mem_stats                 = NULL,
-    .zero_fill                 = NULL,
     .all_zeros                 = NULL,
     .compress                  = NULL,
     .decompress                = NULL,

examples/providers/common.h

@@ -3,16 +3,6 @@
 
 #include <dpusm/provider_api.h>
 
-/* required functions */
-int dpusm_provider_algorithms(int *compress, int *decompress,
-                              int *checksum, int *checksum_byteorder,
-                              int *raid);
-void *dpusm_provider_alloc(size_t size);
-void *dpusm_provider_ref(void *src, size_t offset, size_t size);
-void dpusm_provider_free(void *handle);
-int dpusm_provider_copy_from_mem(dpusm_mv_t *mv, const void *buf, size_t size);
-int dpusm_provider_copy_to_mem(dpusm_mv_t *mv, void *buf, size_t size);
-
 /* filled callback struct */
 extern const dpusm_pf_t example_dpusm_provider_functions;
 

include/dpusm/common.h

@@ -21,10 +21,9 @@ typedef enum {
     DPUSM_OPTIONAL_COPY_FROM_SCATTERLIST = 1 << 2,
     DPUSM_OPTIONAL_COPY_TO_SCATTERLIST   = 1 << 3,
     DPUSM_OPTIONAL_MEM_STATS             = 1 << 4,
-    DPUSM_OPTIONAL_ZERO_FILL             = 1 << 5,
-    DPUSM_OPTIONAL_ALL_ZEROS             = 1 << 6,
+    DPUSM_OPTIONAL_ALL_ZEROS             = 1 << 5,
 
-    DPUSM_OPTIONAL_MAX                   = 1 << 5,
+    DPUSM_OPTIONAL_MAX                   = 1 << 6,
 } dpusm_optional_t;
 
 extern const char *DPUSM_OPTIONAL_STR[];

include/dpusm/provider_api.h

@@ -77,6 +77,9 @@ typedef struct dpusm_provider_functions {
         } to;
     } copy;
 
+    /* fill in a buffer with zeros */
+    int (*zero_fill)(void *handle, size_t offset, size_t size);
+
     /*
      * optional
      */
@@ -111,9 +114,6 @@ typedef struct dpusm_provider_functions {
     int (*mem_stats)(size_t *t_count, size_t *t_size, size_t *t_actual,
                      size_t *a_count, size_t *a_size, size_t *a_actual);
 
-    /* fill in a buffer with zeros */
-    int (*zero_fill)(void *handle, size_t offset, size_t size);
-
     /* whether or not a buffer is all zeros */
     int (*all_zeros)(void *handle, size_t offset, size_t size);
 

include/dpusm/user_api.h

@@ -92,6 +92,9 @@ typedef struct dpusm_user_functions {
         } to;
     } copy;
 
+    /* fill in a buffer with zeros */
+    int (*zero_fill)(void *handle, size_t offset, size_t size);
+
     /*
      * optional
      */
@@ -111,9 +114,6 @@ typedef struct dpusm_user_functions {
                      size_t *t_count, size_t *t_size, size_t *t_actual,
                      size_t *a_count, size_t *a_size, size_t *a_actual);
 
-    /* fill in a buffer with zeros */
-    int (*zero_fill)(void *handle, size_t offset, size_t size);
-
     /* whether or not a buffer is all zeros */
     int (*all_zeros)(void *handle, size_t offset, size_t size);
 

src/provider.c

@@ -38,7 +38,8 @@ dpusm_provider_sane_at_load(const dpusm_pf_t *funcs)
         !!funcs->get_size +
         !!funcs->free +
         !!funcs->copy.from.generic +
-        !!funcs->copy.to.generic);
+        !!funcs->copy.to.generic +
+        !!funcs->zero_fill);
 
     const int raid_gen = (
         !!funcs->raid.can_compute +
@@ -65,7 +66,7 @@ dpusm_provider_sane_at_load(const dpusm_pf_t *funcs)
 
     // get bitmap of bad function groups
     const int rc = (
-        (!(required == 7)?DPUSM_PROVIDER_BAD_GROUP_REQUIRED:0) |
+        (!(required == 8)?DPUSM_PROVIDER_BAD_GROUP_REQUIRED:0) |
         (!((raid_gen == 0) || (raid_gen == 5))?DPUSM_PROVIDER_BAD_GROUP_RAID_GEN:0) |
         (!((raid_rec == 0) || ((raid_gen == 5) && (raid_rec == 2)))?DPUSM_PROVIDER_BAD_GROUP_RAID_REC:0) |
         (!((file == 0) || (file == 3))?DPUSM_PROVIDER_BAD_GROUP_FILE:0) |
@@ -139,11 +140,6 @@ dpusmph_init(struct module *module, const dpusm_pf_t *funcs)
             print_supported(name, enum2str(DPUSM_OPTIONAL_STR, DPUSM_OPTIONAL_MEM_STATS));
         }
 
-        if (funcs->zero_fill) {
-            dpusmph->capabilities.optional |= DPUSM_OPTIONAL_ZERO_FILL;
-            print_supported(name, enum2str(DPUSM_OPTIONAL_STR, DPUSM_OPTIONAL_ZERO_FILL));
-        }
-
         if (funcs->all_zeros) {
             dpusmph->capabilities.optional |= DPUSM_OPTIONAL_ALL_ZEROS;
             print_supported(name, enum2str(DPUSM_OPTIONAL_STR, DPUSM_OPTIONAL_ALL_ZEROS));

src/user.c

@@ -353,6 +353,12 @@ dpusm_copy_to_scatterlist(dpusm_mv_t *mv,
         sgl, nents, size);
 }
 
+static int
+dpusm_zero_fill(void *handle, size_t offset, size_t size) {
+    CHECK_HANDLE(handle, dpusmh, DPUSM_ERROR);
+    return FUNCS(dpusmh->provider)->zero_fill(dpusmh->handle, offset, size);
+}
+
 static int
 dpusm_provider_mem_stats(void *provider,
     size_t *t_count, size_t *t_size, size_t *t_actual,
@@ -365,15 +371,6 @@ dpusm_provider_mem_stats(void *provider,
         a_count, a_size, a_actual);
 }
 
-static int
-dpusm_zero_fill(void *handle, size_t offset, size_t size) {
-    CHECK_HANDLE(handle, dpusmh, DPUSM_ERROR);
-    if (!FUNCS(dpusmh->provider)->zero_fill) {
-        return DPUSM_NOT_IMPLEMENTED;
-    }
-    return FUNCS(dpusmh->provider)->zero_fill(dpusmh->handle, offset, size);
-}
-
 static int
 dpusm_all_zeros(void *handle, size_t offset, size_t size) {
     CHECK_HANDLE(handle, dpusmh, DPUSM_ERROR);
@@ -702,8 +699,8 @@ static const dpusm_uf_t user_functions = {
                                      .scatterlist = dpusm_copy_to_scatterlist,
                                  },
                      },
-    .mem_stats     = dpusm_provider_mem_stats,
     .zero_fill     = dpusm_zero_fill,
+    .mem_stats     = dpusm_provider_mem_stats,
     .all_zeros     = dpusm_all_zeros,
     .compress      = dpusm_compress,
     .decompress    = dpusm_decompress,