Trim trailing whitespace

1 files changed, 105 insertions, 105 deletions

diff --git a/src/H5MF.c b/src/H5MF.c
index df1c88a..5c31f19 100644
--- a/src/H5MF.c
+++ b/src/H5MF.c
@@ -100,7 +100,7 @@ static herr_t H5MF__close_shrink_eoa(H5F_t *f);
 static herr_t H5MF__get_free_sects(H5F_t *f, H5FS_t *fspace, H5MF_sect_iter_ud_t *sect_udata, size_t *nums);
 static hbool_t H5MF__fsm_type_is_self_referential(H5F_shared_t *f_sh, H5F_mem_page_t fsm_type);
 static hbool_t H5MF__fsm_is_self_referential(H5F_shared_t *f_sh, H5FS_t *fspace);
-static herr_t H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace, 
+static herr_t H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace,
     H5FS_t  *lg_hdr_fspace, H5FS_t *lg_sinfo_fspace, hbool_t *continue_alloc_fsm);
 
 /* Free-space type manager routines */
@@ -1307,7 +1307,7 @@ HDfprintf(stderr, "%s: Entering: alloc_type = %u, addr = %a, size = %Hu, extra_r
     end = addr + size;
 
     /* For paged aggregation:
-     *   To extend a small block: can only extend if not crossing page boundary 
+     *   To extend a small block: can only extend if not crossing page boundary
      *   To extend a large block at EOA: calculate in advance mis-aligned fragment so EOA will still end at page boundary
      */
     if(H5F_PAGED_AGGR(f)) {
@@ -1658,8 +1658,8 @@ HDfprintf(stderr, "%s: Entering\n", FUNC);
     /* check args */
     HDassert(f);
 
-    /* If there have been no file space allocations / deallocation so 
-     * far, must call H5MF_tidy_self_referential_fsm_hack() to float 
+    /* If there have been no file space allocations / deallocation so
+     * far, must call H5MF_tidy_self_referential_fsm_hack() to float
      * all self referential FSMs and release file space allocated to
      * them.  Otherwise, the function will be called after the format
      * conversion, and will become very confused.
@@ -1797,9 +1797,9 @@ HDfprintf(stderr, "%s: Entering\n", FUNC);
          */
         HDassert(H5F_addr_defined(f->shared->sblock->ext_addr));
 
-        /* file space for all non-empty free space managers should be 
+        /* file space for all non-empty free space managers should be
          * allocated at this point, and these free space managers should
-         * be written to file and thus their headers and section info 
+         * be written to file and thus their headers and section info
          * entries in the metadata cache should be clean.
          */
 
@@ -1870,8 +1870,8 @@ HDfprintf(stderr, "%s: Entering\n", FUNC);
         if(HADDR_UNDEF == (final_eoa = H5FD_get_eoa(f->shared->lf, H5FD_MEM_DEFAULT)) )
             HGOTO_ERROR(H5E_FILE, H5E_CANTGET, FAIL, "unable to get file size")
 
-        /* f->shared->eoa_post_fsm_fsalloc is undefined if there has 
-         * been no file space allocation or deallocation since file 
+        /* f->shared->eoa_post_fsm_fsalloc is undefined if there has
+         * been no file space allocation or deallocation since file
          * open.
          */
         HDassert(H5F_NULL_FSM_ADDR(f) || final_eoa == f->shared->eoa_fsm_fsalloc);
@@ -2031,13 +2031,13 @@ HDfprintf(stderr, "%s: Entering\n", FUNC);
          * been no file space allocation or deallocation since file
          * open.
          *
-         * If there is a cache image in the file at file open, 
-         * f->shared->first_alloc_dealloc will always be FALSE unless 
+         * If there is a cache image in the file at file open,
+         * f->shared->first_alloc_dealloc will always be FALSE unless
          * the file is opened R/O, as otherwise, the image will have been
          * read and discarded by this point.
          *
-         * If a cache image was created on file close, the actual EOA 
-         * should be in f->shared->eoa_post_mdci_fsalloc.  Note that in 
+         * If a cache image was created on file close, the actual EOA
+         * should be in f->shared->eoa_post_mdci_fsalloc.  Note that in
          * this case, it is conceivable that f->shared->first_alloc_dealloc
          * will still be TRUE, as the cache image is allocated directly from
          * the file driver layer.  However, as this possibility seems remote,
@@ -2049,8 +2049,8 @@ HDfprintf(stderr, "%s: Entering\n", FUNC);
                   (final_eoa == f->shared->eoa_post_mdci_fsalloc)));
     } /* end if */
     else {
-        /* Iterate over all the free space types that have managers 
-         * and get each free list's space 
+        /* Iterate over all the free space types that have managers
+         * and get each free list's space
          */
         for(ptype = H5F_MEM_PAGE_META; ptype < H5F_MEM_PAGE_NTYPES; ptype++)
             if(H5MF__close_delete_fstype(f, ptype) < 0)
@@ -2365,16 +2365,16 @@ H5MF_get_free_sections(H5F_t *f, H5FD_mem_t type, size_t nsects, H5F_sect_info_t
     HDassert(f->shared);
     HDassert(f->shared->lf);
 
-    /* H5MF_tidy_self_referential_fsm_hack() will fail if any self 
+    /* H5MF_tidy_self_referential_fsm_hack() will fail if any self
      * referential FSM is opened prior to the call to it.  Thus call
      * it here if necessary and if it hasn't been called already.
      *
      * The situation is further complicated if a cache image exists
      * and had not yet been loaded into the metadata cache.  In this
-     * case, call H5AC_force_cache_image_load() instead of 
+     * case, call H5AC_force_cache_image_load() instead of
      * H5MF_tidy_self_referential_fsm_hack().  H5AC_force_cache_image_load()
-     * will load the cache image, and then call 
-     * H5MF_tidy_self_referential_fsm_hack() to discard the cache image 
+     * will load the cache image, and then call
+     * H5MF_tidy_self_referential_fsm_hack() to discard the cache image
      * block.
      */
 
@@ -2529,50 +2529,50 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5MF_settle_raw_data_fsm()
  *
- * Purpose: 	Handle any tasks required before the metadata cache 
+ * Purpose: 	Handle any tasks required before the metadata cache
  *		can serialize or flush the raw data free space manager
- *		and any metadata free space managers that reside in the 
+ *		and any metadata free space managers that reside in the
  *		raw data free space manager ring.
  *
- *              Specifically, this means any metadata managers that DON'T 
- *              handle space allocation for free space manager header or 
- *              section info will reside in the raw data free space manager 
+ *              Specifically, this means any metadata managers that DON'T
+ *              handle space allocation for free space manager header or
+ *              section info will reside in the raw data free space manager
  *              ring.
  *
- *              In the absence of page allocation, there is at most one 
+ *              In the absence of page allocation, there is at most one
  *		free space manager per memory type defined in H5F_mem_t.
- *		Of these, the one that allocates H5FD_MEM_DRAW will 
+ *		Of these, the one that allocates H5FD_MEM_DRAW will
  *		always reside in the raw data free space manager ring.
- *		If there is more than one metadata free space manager, 
- *		all that don't handle H5FD_MEM_FSPACE_HDR or 
- *              H5FD_MEM_FSPACE_SINFO (which map to H5FD_MEM_OHDR and 
- *              H5FD_MEM_LHEAP respectively) will reside in the raw 
+ *		If there is more than one metadata free space manager,
+ *		all that don't handle H5FD_MEM_FSPACE_HDR or
+ *              H5FD_MEM_FSPACE_SINFO (which map to H5FD_MEM_OHDR and
+ *              H5FD_MEM_LHEAP respectively) will reside in the raw
  *		data free space manager ring as well
  *
- *		With page allocation, the situation is conceptually 
+ *		With page allocation, the situation is conceptually
  *		identical, but more complex in practice.
  *
- *              In the worst case (multi file driver) page allocation 
- *		can result in two free space managers for each memory 
+ *              In the worst case (multi file driver) page allocation
+ *		can result in two free space managers for each memory
  *		type -- one for small (less than on equal to one page)
  *              allocations, and one for large (greater than one page)
  *              allocations.
  *
  *		In the more common one file case, page allocation will
- *              result in a total of three free space managers -- one for 
- *              small (<= one page) raw data allocations, one for small 
- *              metadata allocations (i.e, all memory types other than 
- *              H5FD_MEM_DRAW), and one for all large (> one page) 
+ *              result in a total of three free space managers -- one for
+ *              small (<= one page) raw data allocations, one for small
+ *              metadata allocations (i.e, all memory types other than
+ *              H5FD_MEM_DRAW), and one for all large (> one page)
  *              allocations.
  *
  *              Despite these complications, the solution is the same in
- *		the page allocation case -- free space managers (be they 
- *              small data or large) are assigned to the raw data free 
+ *		the page allocation case -- free space managers (be they
+ *              small data or large) are assigned to the raw data free
  *              space manager ring if they don't allocate file space for
- *              free space managers.  Note that in the one file case, the 
+ *              free space managers.  Note that in the one file case, the
  *		large free space manager must be assigned to the metadata
- *		free space manager ring, as it both allocates pages for 
- *		the metadata free space manager, and allocates space for 
+ *		free space manager ring, as it both allocates pages for
+ *		the metadata free space manager, and allocates space for
  *		large (> 1 page) metadata cache entries.
  *
  *              At present, the task list for this routine is:
@@ -2582,14 +2582,14 @@ done:
  *		    a) Free both aggregators.  Space not at EOA will be
  *		       added to the appropriate free space manager.
  *
- *		       The raw data aggregator should not be restarted 
+ *		       The raw data aggregator should not be restarted
  *		       after this point.  It is possible that the metadata
  *		       aggregator will be.
  *
  *		    b) Free all file space currently allocated to free
  *		       space managers.
  *
- *		    c) Delete the free space manager superblock 
+ *		    c) Delete the free space manager superblock
  *		       extension message if allocated.
  *
  *		   This done, reduce the EOA by moving it to just before
@@ -2597,23 +2597,23 @@ done:
  *
  *		2) Ensure that space is allocated for the free space
  *                 manager superblock extension message.  Must do this
- *                 now, before reallocating file space for free space 
+ *                 now, before reallocating file space for free space
  *		   managers, as it is possible that this allocation may
  *		   grab the last section in a FSM -- making it unnecessary
  *		   to re-allocate file space for it.
  *
  *		3) Scan all free space managers not involved in allocating
  *		   space for free space managers.  For each such free space
- *		   manager, test to see if it contains free space.  If 
+ *		   manager, test to see if it contains free space.  If
  *		   it does, allocate file space for its header and section
- *		   data.  If it contains no free space, leave it without 
- *		   allocated file space as there is no need to save it to 
+ *		   data.  If it contains no free space, leave it without
+ *		   allocated file space as there is no need to save it to
  *		   file.
  *
  *		   Note that all free space managers in this class should
- *		   see no further space allocations / deallocations as 
- *		   at this point, all raw data allocations should be 
- *		   finalized, as should all metadata allocations not 
+ *		   see no further space allocations / deallocations as
+ *		   at this point, all raw data allocations should be
+ *		   finalized, as should all metadata allocations not
  *		   involving free space managers.
  *
  *		   We will allocate space for free space managers involved
@@ -2648,7 +2648,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled)
     HDassert(f->shared);
     HDassert(fsm_settled);
 
-    /* 
+    /*
      * Only need to settle things if we are persisting free space and
      * the private property in f->shared->null_fsm_addr is not enabled.
      */
@@ -2683,7 +2683,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled)
          * Note that while the raw data aggregator should not be restarted during
          * the close process, this need not be the case for the metadata aggregator.
          *
-         * Note also that the aggregators will not exist if page aggregation 
+         * Note also that the aggregators will not exist if page aggregation
          * is enabled -- skip this if so.
          */
         /* Vailin -- is this correct? */
@@ -2719,10 +2719,10 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled)
          * referential nature of the problem.  These FSMs are dealt with in
          * H5MF_settle_meta_data_fsm().
          *
-         * Since paged allocation may be enabled, there may be up to two 
+         * Since paged allocation may be enabled, there may be up to two
          * free space managers per memory type -- one for small and one for
          * large allocation.  Hence we must loop over the memory types twice
-         * setting the allocation size accordingly if paged allocation is 
+         * setting the allocation size accordingly if paged allocation is
          * enabled.
          */
         for(pass_count = 0; pass_count <= 1; pass_count++) {
@@ -2783,7 +2783,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled)
 
                         /* Check if the free space manager has space in the file */
                         if(H5F_addr_defined(fs_stat.addr) || H5F_addr_defined(fs_stat.sect_addr)) {
-                            /* Delete the free space manager in the file.  Will 
+                            /* Delete the free space manager in the file.  Will
                              * reallocate later if the free space manager contains
                              * any free space.
                              */
@@ -2808,7 +2808,7 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled)
          *    extension messages will choke if the target message is
          *    unexpectedly either absent or present.
          *
-         *    Update: This is probably unnecessary, as I gather that the 
+         *    Update: This is probably unnecessary, as I gather that the
          *            file space manager info message is guaranteed to exist.
          *            Leave it in for now, but consider removing it.
          */
@@ -2911,9 +2911,9 @@ H5MF_settle_raw_data_fsm(H5F_t *f, hbool_t *fsm_settled)
                     fsm_visited[fsm_type] = TRUE;
 
                     if(f->shared->fs_man[fsm_type]) {
-                        /* Only allocate file space if the target free space manager 
-                         * doesn't allocate file space for free space managers.  Note 
-                         * that this is also the deciding factor as to whether a FSM 
+                        /* Only allocate file space if the target free space manager
+                         * doesn't allocate file space for free space managers.  Note
+                         * that this is also the deciding factor as to whether a FSM
                          * in in the raw data FSM ring.
                          */
                         if(!H5MF__fsm_type_is_self_referential(f->shared, fsm_type)) {
@@ -2995,15 +2995,15 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5MF_settle_meta_data_fsm()
  *
- * Purpose: 	If the free space manager is persistent, handle any tasks 
- *		required before the metadata cache can serialize or flush 
- *		the metadata free space manager(s) that handle file space 
+ * Purpose: 	If the free space manager is persistent, handle any tasks
+ *		required before the metadata cache can serialize or flush
+ *		the metadata free space manager(s) that handle file space
  *		allocation for free space managers.
  *
- *		In most cases, there will be only one manager assigned 
+ *		In most cases, there will be only one manager assigned
  *		to this role.  However, since for reasons unknown,
- *		free space manager headers and section info blocks are 
- *		different classes of memory, it is possible that two free 
+ *		free space manager headers and section info blocks are
+ *		different classes of memory, it is possible that two free
  *		space managers will be involved.
  *
  *		On entry to this function, the raw data settle routine
@@ -3020,23 +3020,23 @@ done:
  *		5) Re-created the free space manager superblock extension
  *		   message.
  *
- *		6) Reallocated file space for all non-empty free space 
- *		   managers NOT involved in allocation of space for free 
+ *		6) Reallocated file space for all non-empty free space
+ *		   managers NOT involved in allocation of space for free
  *		   space managers.
  *
  *		   Note that these free space managers (if not empty) should
  *		   have been written to file by this point, and that no
- *		   further space allocations involving them should take 
+ *		   further space allocations involving them should take
  *		   place during file close.
  *
  *		On entry to this routine, the free space manager(s) involved
  *		in allocation of file space for free space managers should
- *		still be floating. (i.e. should not have any file space 
+ *		still be floating. (i.e. should not have any file space
  *		allocated to them.)
  *
- *		Similarly, the raw data aggregator should not have been 
- *		restarted.  Note that it is probable that reallocation of 
- *		space in 5) and 6) above will have re-started the metadata 
+ *		Similarly, the raw data aggregator should not have been
+ *		restarted.  Note that it is probable that reallocation of
+ *		space in 5) and 6) above will have re-started the metadata
  *		aggregator.
  *
  *
@@ -3048,35 +3048,35 @@ done:
  *      2) Free the aggregators.
  *
  *      3) Reduce the EOA to the extent possible, and make note
- *		   of the resulting value.  This value will be stored 
+ *		   of the resulting value.  This value will be stored
  *		   in the fsinfo superblock extension message and be used
  *          in the subsequent file open.
  *
  *		4) Re-allocate space for any free space manager(s) that:
  *
- *		   a) are involved in allocation of space for free space 
- *		      managers, and 
+ *		   a) are involved in allocation of space for free space
+ *		      managers, and
  *
  *		   b) contain free space.
  *
- *		   It is possible that we could allocate space for one 
- *		   of these free space manager(s) only to have the allocation 
- *		   result in the free space manager being empty and thus 
+ *		   It is possible that we could allocate space for one
+ *		   of these free space manager(s) only to have the allocation
+ *		   result in the free space manager being empty and thus
  *		   obliging us to free the space again.  Thus there is the
  *		   potential for an infinite loop if we want to avoid saving
  *		   empty free space managers.
  *
- *		   Similarly, it is possible that we could allocate space 
- *		   for a section info block, only to discover that this 
- *		   allocation has changed the size of the section info -- 
+ *		   Similarly, it is possible that we could allocate space
+ *		   for a section info block, only to discover that this
+ *		   allocation has changed the size of the section info --
  *		   forcing us to deallocate and start the loop over again.
  *
- *		   The solution is to modify the FSM code to 
+ *		   The solution is to modify the FSM code to
  *		   save empty FSMs to file, and to allow section info blocks
  *		   to be oversized.  That is, only allow section info to increase
  *         in size, not shrink.  The solution is now implemented.
  *
- *      5) Make note of the EOA -- used for sanity checking on 
+ *      5) Make note of the EOA -- used for sanity checking on
  *         FSM shutdown.  This is saved as eoa_pre_fsm_fsalloc in
  *         the free-space info message for backward compatibility
  *         with the 1.10 library that has the hack.
@@ -3112,7 +3112,7 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled)
     HDassert(f->shared);
     HDassert(fsm_settled);
 
-    /* 
+    /*
      * Only need to settle things if we are persisting free space and
      * the private property in f->shared->null_fsm_addr is not enabled.
      */
@@ -3197,8 +3197,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled)
                 HDassert(fs_stat.alloc_sect_size == 0);
             } /* end if */
 
-            /* Verify that lg_sinfo_fspace is floating if it 
-             * exists and is distinct 
+            /* Verify that lg_sinfo_fspace is floating if it
+             * exists and is distinct
              */
             if((lg_sinfo_fspace) && (lg_hdr_fspace != lg_sinfo_fspace)) {
                 /* Query free space manager info for this type */
@@ -3217,7 +3217,7 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled)
          * H5MF_free_aggrs() call.  Note that the raw data aggregator must
          * have already been freed.  Sanity checks for this?
          *
-         * Note that the aggregators will not exist if paged aggregation 
+         * Note that the aggregators will not exist if paged aggregation
          * is enabled -- don't attempt to free if this is the case.
          */
         /* (for space not at EOF, it may be put into free space managers) */
@@ -3228,30 +3228,30 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled)
         if(H5MF__close_shrink_eoa(f) < 0)
             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTSHRINK, FAIL, "can't shrink eoa")
 
-        /* WARNING:  This approach settling the self referential free space 
-         *           managers and allocating space for them in the file will 
-         *           not work as currently implemented with the split and 
-         *           multi file drivers, as the self referential free space 
-         *           manager header and section info can be stored in up to 
-         *           two different files -- requiring that up to two EOA's 
-         *           be stored in the the free space managers super block 
-         *           extension message.  
+        /* WARNING:  This approach settling the self referential free space
+         *           managers and allocating space for them in the file will
+         *           not work as currently implemented with the split and
+         *           multi file drivers, as the self referential free space
+         *           manager header and section info can be stored in up to
+         *           two different files -- requiring that up to two EOA's
+         *           be stored in the the free space managers super block
+         *           extension message.
          *
-         *           As of this writing, we are solving this problem by 
-         *           simply not supporting persistent FSMs with the split 
+         *           As of this writing, we are solving this problem by
+         *           simply not supporting persistent FSMs with the split
          *           and multi file drivers.
          *
-         *           Current plans are to do away with the multi file 
+         *           Current plans are to do away with the multi file
          *           driver, so this should be a non-issue in this case.
          *
-         *           We should be able to support the split file driver 
-         *           without a file format change.  However, the code to 
+         *           We should be able to support the split file driver
+         *           without a file format change.  However, the code to
          *           do so does not exist at present.
          * NOTE: not sure whether to remove or keep the above comments
          */
 
-        /* 
-         * Continue allocating file space for the header and section info until 
+        /*
+         * Continue allocating file space for the header and section info until
          * they are all settled,
          */
         do {
@@ -3288,8 +3288,8 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hbool_t *fsm_settled)
 
         /* All free space managers should have file space allocated for them
          * now, and should see no further allocations / deallocations.
-         * For backward compatibility, store the eoa in f->shared->eoa_fsm_fsalloc 
-         * which will be set to fsinfo.eoa_pre_fsm_fsalloc when we actually write 
+         * For backward compatibility, store the eoa in f->shared->eoa_fsm_fsalloc
+         * which will be set to fsinfo.eoa_pre_fsm_fsalloc when we actually write
          * the free-space info message to the superblock extension.
          * This will allow the 1.10 library with the hack to open the file with
          * the new solution.
@@ -3330,7 +3330,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace, 
+H5MF__continue_alloc_fsm(H5F_shared_t *f_sh, H5FS_t *sm_hdr_fspace, H5FS_t *sm_sinfo_fspace,
     H5FS_t  *lg_hdr_fspace, H5FS_t *lg_sinfo_fspace, hbool_t *continue_alloc_fsm)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR