docs: private void setFileSizesAfterRestart(boolean coldStart,
                                            long minimumPermanentStoreSize, long maximumPermanentStoreSize, boolean isPermanentStoreSizeUnlimited,
                                            long minimumTemporaryStoreSize, long maximumTemporaryStoreSize, boolean isTemporaryStoreSizeUnlimited,
                                            long logSize) throws ObjectManagerException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setFileSizesAfterRestart", new Object[]{"ColdStart="+coldStart, "LogSize="+logSize,
              "MinimumPermanentStoreSize="+minimumPermanentStoreSize, "MaximumPermanentStoreSize="+maximumPermanentStoreSize, "IsPermanentStoreSizeUnlimited="+isPermanentStoreSizeUnlimited,
              "MinimumTemporaryStoreSize="+minimumTemporaryStoreSize, "MaximumTemporaryStoreSize="+maximumTemporaryStoreSize, "IsTemporaryStoreSizeUnlimited="+isTemporaryStoreSizeUnlimited});
  
          try
          {
              // The recommendation is to set the log file size
              // before the store file sizes when cold-starting
              if (coldStart)
              {
                  long currentLogSize = _objectManager.getLogFileSize();
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(this, tc, "The current size of the log file is " + Long.valueOf(currentLogSize) + " bytes. The size in the configuration information of the log file is " + Long.valueOf(logSize) + " bytes.");
  
                  if (currentLogSize != logSize)
                  {
                      // Defect 326589
                      // Check the values provided to us to make sure we are attempting
                      // sensible modifications. Each check is only worth doing if the matching
                      // store size unlimited flag is set to false. If this is true then we are
                      // going to ignore the maximum store size parameters anyway.
                      if ((!isPermanentStoreSizeUnlimited && (logSize > maximumPermanentStoreSize)) || // Log larger than permanent store
                          (!isTemporaryStoreSizeUnlimited && (logSize > maximumTemporaryStoreSize)))   // Log larger than temporary store
                      {
                          SibTr.warning(tc, "FILE_STORE_LOG_SIZE_CHANGE_PREVENTED_SIMS1548");
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Log size not changed!");
                      }
                      else
                      {
                          _objectManager.setLogFileSize(logSize);
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Log size changed");
                      }
                  }
              }
  
              // Change the permanent store file sizes.
              SingleFileObjectStore store = (SingleFileObjectStore)_permanentStore;
  
              long currentPermanentStoreUsed        = store.getStoreFileUsed();
              long currentPermanentStoreSize        = store.getStoreFileSize();
              long currentMinimumPermanentStoreSize = store.getMinimumStoreFileSize();
              long currentMaximumPermanentStoreSize = store.getMaximumStoreFileSize();
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              {
                  SibTr.debug(this, tc, "currentPermanentStoreUsed        = " + currentPermanentStoreUsed);
                  SibTr.debug(this, tc, "currentPermanentStoreSize        = " + currentPermanentStoreSize);
                  SibTr.debug(this, tc, "currentMinimumPermanentStoreSize = " + currentMinimumPermanentStoreSize);
                  SibTr.debug(this, tc, "currentMaximumPermanentStoreSize = " + currentMaximumPermanentStoreSize);
                  // Defect 342044
                  // Output the current size of the data in the permanent store
                  SibTr.debug(this, tc, "The data in the permanent store file occupies " + Long.valueOf(currentPermanentStoreUsed) + " bytes.");
                  // Output the current file size limits.
                  if (currentMaximumPermanentStoreSize != MAXIMUM_STORE_FILE_SIZE)
                  {
                      SibTr.debug(this, tc, "The current minimum reserved size of the permanent store file is " + Long.valueOf(currentMinimumPermanentStoreSize) + " bytes. The current maximum size is " + Long.valueOf(currentMaximumPermanentStoreSize) + " bytes.");
                  }
                  else
                  {
                      SibTr.debug(this, tc, "The current minimum reserved size of the permanent store file is " + Long.valueOf(currentMinimumPermanentStoreSize) + " bytes. The current maximum size is unlimited");
                  }
  
              }
  
              // Defect 326589
              // Check the values provided to us to make sure we are attempting
              // sensible modifications. Each check is only worth doing if the matching
              // store size unlimited flag is set to false. If this is true then we are
              // going to ignore the maximum store size parameters anyway.
              if ((!isPermanentStoreSizeUnlimited && (minimumPermanentStoreSize > maximumPermanentStoreSize)))  // Permanent store minimum larger than maximum
              {
                  SibTr.info(tc, "FILE_STORE_PERMANENT_STORE_SIZE_CONFIGURATION_INFO_SIMS1553", new Object[] {Long.valueOf(minimumPermanentStoreSize), Long.valueOf(maximumPermanentStoreSize)});
                  SibTr.warning(tc, "FILE_STORE_STORE_SIZE_CHANGE_PREVENTED_SIMS1549");
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Permanent store size not changed!");
              }
              else
              {
                  if ((currentMinimumPermanentStoreSize != minimumPermanentStoreSize) ||                                     /* Minimum is not the same as the current minimum.     */
                      (!isPermanentStoreSizeUnlimited && (currentMaximumPermanentStoreSize != maximumPermanentStoreSize)) || /* Maximum is not the same as current limited maximum. */
                      (isPermanentStoreSizeUnlimited && (currentMaximumPermanentStoreSize != MAXIMUM_STORE_FILE_SIZE)))      /* Maximum is not already set to unlimited.            */
                  {
                      if (!isPermanentStoreSizeUnlimited)
                      {
                          SibTr.info(tc, "FILE_STORE_PERMANENT_STORE_SIZE_CONFIGURATION_INFO_SIMS1553", new Object[] {Long.valueOf(minimumPermanentStoreSize), Long.valueOf(maximumPermanentStoreSize)});
                          store.setStoreFileSize(minimumPermanentStoreSize, maximumPermanentStoreSize);
                      }
                      else
                      {
                          SibTr.info(tc, "FILE_STORE_PERMANENT_STORE_SIZE_CONFIGURATION_INFO_UNLIMITED_SIMS1554", new Object[] {Long.valueOf(minimumPermanentStoreSize)});
                          store.setStoreFileSize(minimumPermanentStoreSize, MAXIMUM_STORE_FILE_SIZE);
                      }
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Permanent Store size changed");
                  }
              }
  
              // Change the temporary store file sizes.
              store = (SingleFileObjectStore)_temporaryStore;
  
              long currentTemporaryStoreUsed        = store.getStoreFileUsed();
              long currentTemporaryStoreSize        = store.getStoreFileSize();
              long currentMinimumTemporaryStoreSize = store.getMinimumStoreFileSize();
              long currentMaximumTemporaryStoreSize = store.getMaximumStoreFileSize();
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              {
                  SibTr.debug(this, tc, "currentTemporaryStoreUsed        = " + currentTemporaryStoreUsed);
                  SibTr.debug(this, tc, "currentTemporaryStoreSize        = " + currentTemporaryStoreSize);
                  SibTr.debug(this, tc, "currentMinimumTemporaryStoreSize = " + currentMinimumTemporaryStoreSize);
                  SibTr.debug(this, tc, "currentMaximumTemporaryStoreSize = " + currentMaximumTemporaryStoreSize);
                  // Defect 342044
                  // Output the current size of the data in the temporary store
                  SibTr.debug(this, tc, "The data in the temporary store file occupies " + Long.valueOf(currentTemporaryStoreUsed) + " bytes.");
  
                  // Output the current file size limits.
                  if (currentMaximumTemporaryStoreSize != MAXIMUM_STORE_FILE_SIZE)
                  {
                      SibTr.debug(this, tc, "The current minimum reserved size of the temporary store file is " + Long.valueOf(currentMinimumTemporaryStoreSize) + " bytes. The current maximum size is " + Long.valueOf(currentMaximumTemporaryStoreSize) +" bytes.");
                  }
                  else
                  {
                      SibTr.debug(this, tc, "The current minimum reserved size of the temporary store file is " + Long.valueOf(currentMinimumTemporaryStoreSize) + " bytes. The current maximum size is unlimited.");
                  }
  
              }
  
              // Defect 326589
              // Check the values provided to us to make sure we are attempting
              // sensible modifications. Each check is only worth doing if the matching
              // store size unlimited flag is set to false. If this is true then we are
              // going to ignore the maximum store size parameters anyway.
              if ((!isTemporaryStoreSizeUnlimited && (minimumTemporaryStoreSize > maximumTemporaryStoreSize)))  // Temporary store minimum larger than maximum
              {
                  SibTr.info(tc, "FILE_STORE_TEMPORARY_STORE_SIZE_CONFIGURATION_INFO_SIMS1557", new Object[] {Long.valueOf(minimumTemporaryStoreSize), Long.valueOf(maximumTemporaryStoreSize)});
                  SibTr.warning(tc, "FILE_STORE_STORE_SIZE_CHANGE_PREVENTED_SIMS1549");
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Temporary store size not changed!");
              }
              else
              {
                  if ((currentMinimumTemporaryStoreSize != minimumTemporaryStoreSize) ||                                     /* Minimum is not the same as the current minimum.     */
                      (!isTemporaryStoreSizeUnlimited && (currentMaximumTemporaryStoreSize != maximumTemporaryStoreSize)) || /* Maximum is not the same as current limited maximum. */
                      (isTemporaryStoreSizeUnlimited && (currentMaximumTemporaryStoreSize != MAXIMUM_STORE_FILE_SIZE)))      /* Maximum is not already set to unlimited.            */
                  {
                      if (!isTemporaryStoreSizeUnlimited)
                      {
                          SibTr.info(tc, "FILE_STORE_TEMPORARY_STORE_SIZE_CONFIGURATION_INFO_SIMS1557", new Object[] {Long.valueOf(minimumTemporaryStoreSize), Long.valueOf(maximumTemporaryStoreSize)});
                          store.setStoreFileSize(minimumTemporaryStoreSize, maximumTemporaryStoreSize);
                      }
                      else
                      {
                          SibTr.info(tc, "FILE_STORE_TEMPORARY_STORE_SIZE_CONFIGURATION_INFO_UNLIMITED_SIMS1558", new Object[] {Long.valueOf(minimumTemporaryStoreSize)});
                          store.setStoreFileSize(minimumTemporaryStoreSize, MAXIMUM_STORE_FILE_SIZE);
                      }
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Temporary Store size changed");
                  }
              }
  
              // The recommendation is to set the log file size
              // after the store file sizes when warm-starting
              if (!coldStart)
              {
                  long currentLogSize = _objectManager.getLogFileSize();
  
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(this, tc, "The current size of the log file is " + Long.valueOf(currentLogSize) + " bytes. The size in the configuration information of the log file is " + Long.valueOf(logSize) + " bytes.");
  
                  if (currentLogSize != logSize)
                  {
                      // Defect 326589
                      // Check the values provided to us to make sure we are attempting
                      // sensible modifications. Each check is only worth doing if the matching
                      // store size unlimited flag is set to false. If this is true then we are
                      // going to ignore the maximum store size parameters anyway.
                      if ((!isPermanentStoreSizeUnlimited && (logSize > maximumPermanentStoreSize)) || // Log larger than permanent store
                          (!isTemporaryStoreSizeUnlimited && (logSize > maximumTemporaryStoreSize)))   // Log larger than temporary store
                      {
                          SibTr.warning(tc, "FILE_STORE_LOG_SIZE_CHANGE_PREVENTED_SIMS1548");
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Log size not changed!");
                      }
                      else
                      {
                          _objectManager.setLogFileSize(logSize);
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Log size changed");
                      }
                  }
              }
          }
          catch (LogFileSizeTooSmallException lfse)   // This is due to the minimum log size not being big
          {                                           // enough for existing data.
              com.ibm.ws.ffdc.FFDCFilter.processException(lfse, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableMessageStoreImpl.setFileSizesAfterRestart", "1:2531:1.81.1.6", this);
              SibTr.warning(tc, "FILE_STORE_LOG_SIZE_CHANGE_PREVENTED_SIMS1548");
          }
          catch (IllegalArgumentException iae)        // This is due to invalid file sizes i.e. min > max
          {
              com.ibm.ws.ffdc.FFDCFilter.processException(iae, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableMessageStoreImpl.setFileSizesAfterRestart", "1:2536:1.81.1.6", this);
              SibTr.warning(tc, "FILE_STORE_STORE_SIZE_CHANGE_PREVENTED_SIMS1549");
          }
          catch (StoreFileSizeTooSmallException sfse) // This is due to the minimum store size not being big
          {                                           // enough for existing data.
              com.ibm.ws.ffdc.FFDCFilter.processException(sfse, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableMessageStoreImpl.setFileSizesAfterRestart", "1:2541:1.81.1.6", this);
              SibTr.warning(tc, "FILE_STORE_STORE_SIZE_CHANGE_PREVENTED_SIMS1549");
          }
          catch (PermanentIOException pie)            // This is due to an error setting the minimum store size
          {                                           // on the local file system.
              com.ibm.ws.ffdc.FFDCFilter.processException(pie, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableMessageStoreImpl.setFileSizesAfterRestart", "1:2546:1.81.1.6", this);
              SibTr.warning(tc, "FILE_STORE_STORE_SIZE_CHANGE_PREVENTED_SIMS1549");
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setFileSizesAfterRestart");
      }