c bindings: add protection for big count

hppritcha · hppritcha · commit d38fe29e2c48 · 2025-03-17T15:17:50.000-06:00
when using internal ompi interfaces which can't handle
count &gt; INT_MAX.

Signed-off-by: Howard Pritchard &lt;howardp@lanl.gov&gt;
diff --git a/ompi/mpi/c/bindings.h b/ompi/mpi/c/bindings.h
@@ -104,6 +104,18 @@ BEGIN_C_DECLS
         }                                                               \
     } while (0)
 
+
+/* check for integer overflow - needed while parts of Open MPI have not been embiggened */
+#define OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(RC, x) \
+    do { \
+        if ((x) > INT_MAX) { \
+            (RC) = MPI_ERR_VALUE_TOO_LARGE; \
+        } else { \
+            (RC) = MPI_SUCCESS; \
+       }  \
+    } while (0)
+
+
 END_C_DECLS
 
 #endif /* OMPI_C_BINDINGS_H */
diff --git a/ompi/mpi/c/file_get_type_extent.c.in b/ompi/mpi/c/file_get_type_extent.c.in
@@ -58,7 +58,6 @@ PROTOTYPE ERROR_CLASS file_get_type_extent(FILE fh, DATATYPE datatype,
 
     switch (fh->f_io_version) {
     case MCA_IO_BASE_V_3_0_0:
-        /* TODO:BIGCOUNT: Need to update below code with bigcount variant */
         rc = fh->f_io_selected_module.v3_0_0.
             io_module_file_get_type_extent(fh, datatype, &tmp_extent);
         *extent = tmp_extent;
diff --git a/ompi/mpi/c/pack_external.c.in b/ompi/mpi/c/pack_external.c.in
@@ -58,10 +58,14 @@ PROTOTYPE ERROR_CLASS pack_external(STRING datarep, BUFFER inbuf, COUNT incount,
         OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME);
         OMPI_CHECK_USER_BUFFER(rc, inbuf, datatype, incount);
         OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME);
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, incount);
+        if (MPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
     }
 
-    /* TODO:BIGCOUNT: Update ompi_datatype_pack_external for bigcount */
-
     rc = ompi_datatype_pack_external(datarep, inbuf, incount,
                                      datatype, outbuf, 
                                      outsize, (MPI_Aint *)position);
diff --git a/ompi/mpi/c/pack_external_size.c.in b/ompi/mpi/c/pack_external_size.c.in
@@ -51,9 +51,14 @@ PROTOTYPE ERROR_CLASS pack_external_size(STRING datarep, COUNT incount,
         } else if (MPI_DATATYPE_NULL == datatype || NULL == datatype) {
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_TYPE, FUNC_NAME);
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, incount);
+        if (MPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
     }
 
-    /* TODO:BIGCOUNT: Update when the ompi_datatype code is updated for bigcount */
     rc = ompi_datatype_pack_external_size(datarep, (int) incount,
                                           datatype, &tmp_size);
     *size = tmp_size;
diff --git a/ompi/mpi/c/type_contiguous.c.in b/ompi/mpi/c/type_contiguous.c.in
@@ -50,14 +50,19 @@ PROTOTYPE ERROR_CLASS type_contiguous(COUNT count,
         } else if( count < 0 ) {
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_COUNT, FUNC_NAME);
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
+        if (OMPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
     }
 
     rc = ompi_datatype_create_contiguous( count, oldtype, newtype );
     OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME );
 
     /* data description */
     {
-/* TODO:BIGCOUNT: need to embiggen  ompi_datatype_set_args */
 #if OMPI_BIGCOUNT_SRC
         int icount = (int)count;
         const int* a_i[1] = {&icount};
diff --git a/ompi/mpi/c/type_create_darray.c.in b/ompi/mpi/c/type_create_darray.c.in
@@ -69,6 +69,14 @@ PROTOTYPE ERROR_CLASS type_create_darray(INT size,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG, FUNC_NAME);
         }
         if( ndims > 0 ) {
+#if OMPI_BIGCOUNT_SRC
+            for( i = 0; i < ndims; i++ ) {
+                OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, gsize_array[i]);
+                if (OMPI_SUCCESS != rc) {
+                    return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+                }
+            }
+#endif
             for( i = 0; i < ndims; i++ ) {
                 if( (MPI_DISTRIBUTE_BLOCK != distrib_array[i]) &&
                     (MPI_DISTRIBUTE_CYCLIC != distrib_array[i]) &&
@@ -90,9 +98,6 @@ PROTOTYPE ERROR_CLASS type_create_darray(INT size,
         }
     }
 
-/* TODO:BIGCOUNT: need to embiggen ompi_datatype_create_array and
- * ompi_datatype_set_args.
- */
 #if OMPI_BIGCOUNT_SRC
     igsize_array = (int *)malloc(ndims * sizeof(int));
     if (NULL == igsize_array) {
diff --git a/ompi/mpi/c/type_create_hindexed.c.in b/ompi/mpi/c/type_create_hindexed.c.in
@@ -67,9 +67,14 @@ PROTOTYPE ERROR_CLASS type_create_hindexed(COUNT count,
                                               FUNC_NAME );
             }
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
+        if (OMPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
     }
 
-/* TODO:BIGCOUNT: need to embiggen ompi_datatype_create_hindexed, etc. */
 #if OMPI_BIGCOUNT_SRC
     iarray_of_blocklengths = (int *)malloc(count * sizeof(int));
     if (NULL == iarray_of_blocklengths) {
diff --git a/ompi/mpi/c/type_create_hindexed_block.c.in b/ompi/mpi/c/type_create_hindexed_block.c.in
@@ -51,9 +51,14 @@ PROTOTYPE ERROR_CLASS type_create_hindexed_block(COUNT count,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_TYPE,
                                           FUNC_NAME );
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
+        if (OMPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
     }
 
-/* TODO:BIGCOUNT: Need to embiggen ompi_datatype_create_hindexed_block */
 #if OMPI_BIGCOUNT_SRC
     iarray_of_displacements = (MPI_Aint *)malloc(count * sizeof(MPI_Aint));
     if (NULL == iarray_of_displacements) {
diff --git a/ompi/mpi/c/type_create_hvector.c.in b/ompi/mpi/c/type_create_hvector.c.in
@@ -57,10 +57,14 @@ PROTOTYPE ERROR_CLASS type_create_hvector(COUNT count,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_TYPE,
                                           FUNC_NAME );
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
+        if (OMPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
     }
 
-/* TODO:BIGCOUNT: need to embiggen ompi_datatype_create_hvector */
-
     rc = ompi_datatype_create_hvector ( count, blocklength, stride, oldtype,
                                         newtype );
     OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME );
diff --git a/ompi/mpi/c/type_create_subarray.c.in b/ompi/mpi/c/type_create_subarray.c.in
@@ -62,6 +62,20 @@ PROTOTYPE ERROR_CLASS type_create_subarray(INT ndims,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG, FUNC_NAME);
         }
         for( i = 0; i < ndims; i++ ) {
+#if OMPI_BIGCOUNT_SRC
+            OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, size_array[i]);
+            if (OMPI_SUCCESS != rc) {
+                return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+            }
+            OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, subsize_array[i]);
+            if (OMPI_SUCCESS != rc) {
+                return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+            }
+            OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, start_array[i]);
+            if (OMPI_SUCCESS != rc) {
+                return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+            }
+#endif
             if( (subsize_array[i] < 1) || (subsize_array[i] > size_array[i]) ) {
                 return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG, FUNC_NAME);
             } else if( (start_array[i] < 0) || (start_array[i] > (size_array[i] - subsize_array[i])) ) {
@@ -70,8 +84,6 @@ PROTOTYPE ERROR_CLASS type_create_subarray(INT ndims,
         }
     }
 
-/* TODO:BIGCOUNT: Need to embiggen ompi_datatype_create_subarray */
-
 #if OMPI_BIGCOUNT_SRC
     isize_array = (int *)malloc(ndims * sizeof(int));
     if (NULL == isize_array) {
diff --git a/ompi/mpi/c/type_get_true_extent.c.in b/ompi/mpi/c/type_get_true_extent.c.in
@@ -52,7 +52,6 @@ PROTOTYPE ERROR_CLASS type_get_true_extent(DATATYPE datatype,
       }
    }
 
-/* TODO:BIGCOUNT: need to embiggen ompi_datatype_get_true_extent */
    rc = ompi_datatype_get_true_extent( datatype, (MPI_Aint *)true_lb, (MPI_Aint *)true_extent );
    OMPI_ERRHANDLER_NOHANDLE_RETURN(rc, rc, FUNC_NAME );
 }
diff --git a/ompi/mpi/c/type_indexed.c.in b/ompi/mpi/c/type_indexed.c.in
@@ -60,6 +60,12 @@ PROTOTYPE ERROR_CLASS type_indexed(COUNT count,
             return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG,
                                           FUNC_NAME);
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
+        if (OMPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
         for( i = 0; i < count; i++ ) {
             if( array_of_blocklengths[i] < 0 ) {
                 return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_ARG,
@@ -68,7 +74,6 @@ PROTOTYPE ERROR_CLASS type_indexed(COUNT count,
         }
     }
 
-/* TODO:BIGCOUNT: Need to embiggen ompi_datatype_create_indexed */
 #if OMPI_BIGCOUNT_SRC
     iarray_of_blocklengths = (int *)malloc(count * sizeof(int));
     if (NULL == iarray_of_blocklengths) {
diff --git a/ompi/mpi/c/type_vector.c.in b/ompi/mpi/c/type_vector.c.in
@@ -57,9 +57,14 @@ PROTOTYPE ERROR_CLASS type_vector(COUNT count,
             OMPI_ERRHANDLER_NOHANDLE_RETURN( MPI_ERR_ARG, 
                                     MPI_ERR_ARG, FUNC_NAME );
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);
+        if (OMPI_SUCCESS != rc) {
+            OMPI_ERRHANDLER_NOHANDLE_RETURN(rc, rc, FUNC_NAME);
+        }
+#endif
     }
 
-/* TODO:BIGCOUNT: Need to embiggen ompi_datatype_set_args */
     rc = ompi_datatype_create_vector ( count, blocklength, stride, oldtype, newtype );
     OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME );
 
diff --git a/ompi/mpi/c/unpack_external.c.in b/ompi/mpi/c/unpack_external.c.in
@@ -55,10 +55,14 @@ PROTOTYPE ERROR_CLASS unpack_external (STRING datarep, BUFFER inbuf, AINT_COUNT
         OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME);
         OMPI_CHECK_USER_BUFFER(rc, outbuf, datatype, outcount);
         OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME);
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, insize);
+        if (MPI_SUCCESS != rc) {
+            return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);
+        }
+#endif
     }
 
-    /* TODO:BIGCOUNT: Update once ompi_datatype_unpack_external() is updated with a bigcount variant */
-
     rc = ompi_datatype_unpack_external(datarep, inbuf, (MPI_Aint) insize,
                                        (MPI_Aint *)position, outbuf, (int) outcount,
                                        datatype);
diff --git a/ompi/mpi/c/win_allocate.c.in b/ompi/mpi/c/win_allocate.c.in
@@ -67,8 +67,15 @@ PROTOTYPE ERROR_CLASS win_allocate(AINT size, DISP disp_unit, INFO info,
         return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM, FUNC_NAME);
     }
 
+#if OMPI_BIGCOUNT_SRC
+    OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(ret, disp_unit);
+    if (OMPI_SUCCESS != ret) {
+        *win = MPI_WIN_NULL;
+        return OMPI_ERRHANDLER_INVOKE(comm, ret, FUNC_NAME);
+    }
+#endif
+
     /* create window and return */
-    /* TODO:BIGCOUNT: Update ompi_win_allocate to take ptrdiff_t/MPI_Aint disp units */
     ret = ompi_win_allocate((size_t)size, (int)disp_unit, &(info->super),
                             comm, baseptr, win);
     if (OMPI_SUCCESS != ret) {
diff --git a/ompi/mpi/c/win_allocate_shared.c.in b/ompi/mpi/c/win_allocate_shared.c.in
@@ -61,6 +61,13 @@ PROTOTYPE ERROR_CLASS win_allocate_shared(AINT size, DISP disp_unit, INFO info,
         } else if ( size < 0 ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_SIZE, FUNC_NAME);
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(ret, disp_unit);
+        if (OMPI_SUCCESS != ret) {
+            *win = MPI_WIN_NULL;
+            return OMPI_ERRHANDLER_INVOKE(comm, ret, FUNC_NAME);
+        }
+#endif
     }
 
     /* communicator must be an intracommunicator */
@@ -69,7 +76,6 @@ PROTOTYPE ERROR_CLASS win_allocate_shared(AINT size, DISP disp_unit, INFO info,
     }
 
     /* create window and return */
-    /* TODO:BIGCOUNT: Update internal code to use ptrdiff_t for disp_unit */
     ret = ompi_win_allocate_shared((size_t)size, (int)disp_unit, &(info->super),
                                    comm, baseptr, win);
     if (OMPI_SUCCESS != ret) {
diff --git a/ompi/mpi/c/win_create.c.in b/ompi/mpi/c/win_create.c.in
@@ -60,6 +60,13 @@ PROTOTYPE ERROR_CLASS win_create(BUFFER_OUT base, AINT size, DISP disp_unit,
         } else if ( disp_unit <= 0 ) {
             return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_DISP, FUNC_NAME);
         }
+#if OMPI_BIGCOUNT_SRC
+        OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(ret, disp_unit);
+        if (OMPI_SUCCESS != ret) {
+            *win = MPI_WIN_NULL;
+            return OMPI_ERRHANDLER_INVOKE(comm, ret, FUNC_NAME);
+        }
+#endif
     }
 
     /* communicator must be an intracommunicator */
@@ -68,8 +75,7 @@ PROTOTYPE ERROR_CLASS win_create(BUFFER_OUT base, AINT size, DISP disp_unit,
     }
 
     /* create window and return */
-    /* TODO:BIGCOUNT: Need to update internal function with ptrdiff_t for disp_unit argument */
-    ret = ompi_win_create(base, (size_t)size, disp_unit, comm,
+    ret = ompi_win_create(base, (size_t)size, (int)disp_unit, comm,
                           &(info->super), win);
     if (OMPI_SUCCESS != ret) {
         *win = MPI_WIN_NULL;

Original file line number	Diff line number	Diff line change
`@@ -50,14 +50,19 @@ PROTOTYPE ERROR_CLASS type_contiguous(COUNT count,`
`50`	`50`	`} else if( count < 0 ) {`
`51`	`51`	`return OMPI_ERRHANDLER_NOHANDLE_INVOKE(MPI_ERR_COUNT, FUNC_NAME);`
`52`	`52`	`}`
	`53`	`+#if OMPI_BIGCOUNT_SRC`
	`54`	`+ OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);`
	`55`	`+ if (OMPI_SUCCESS != rc) {`
	`56`	`+ return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);`
	`57`	`+ }`
	`58`	`+#endif`
`53`	`59`	`}`
`54`	`60`
`55`	`61`	`rc = ompi_datatype_create_contiguous( count, oldtype, newtype );`
`56`	`62`	`OMPI_ERRHANDLER_NOHANDLE_CHECK(rc, rc, FUNC_NAME );`
`57`	`63`
`58`	`64`	`/* data description */`
`59`	`65`	`{`
`60`		`-/* TODO:BIGCOUNT: need to embiggen ompi_datatype_set_args */`
`61`	`66`	`#if OMPI_BIGCOUNT_SRC`
`62`	`67`	`int icount = (int)count;`
`63`	`68`	`const int* a_i[1] = {&icount};`
Original file line number	Diff line number	Diff line change
`@@ -67,9 +67,14 @@ PROTOTYPE ERROR_CLASS type_create_hindexed(COUNT count,`
`67`	`67`	`FUNC_NAME );`
`68`	`68`	`}`
`69`	`69`	`}`
	`70`	`+#if OMPI_BIGCOUNT_SRC`
	`71`	`+ OMPI_CHECK_MPI_COUNT_INT_CONVERSION_OVERFLOW(rc, count);`
	`72`	`+ if (OMPI_SUCCESS != rc) {`
	`73`	`+ return OMPI_ERRHANDLER_NOHANDLE_INVOKE(rc, FUNC_NAME);`
	`74`	`+ }`
	`75`	`+#endif`
`70`	`76`	`}`
`71`	`77`
`72`		`-/* TODO:BIGCOUNT: need to embiggen ompi_datatype_create_hindexed, etc. */`
`73`	`78`	`#if OMPI_BIGCOUNT_SRC`
`74`	`79`	`iarray_of_blocklengths = (int )malloc(count sizeof(int));`
`75`	`80`	`if (NULL == iarray_of_blocklengths) {`