docs: void resizeLog(int targetSize) throws InternalLogException, LogFullException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "resizeLog", new Object[] { this, targetSize });
  
          // Check that both files are actually open
          if (_activeFile == null || _inactiveFile == null)
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "resizeLog", "InternalLogException");
              throw new InternalLogException(null);
          }
  
          try
          {
              _file1.fileExtend(targetSize);
              _file2.fileExtend(targetSize);
          } catch (LogAllocationException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.resizeLog", "1612", this);
  
              // "Reset" the _activeFile reference. This is very important because when this keypoint operation
              // was started (keypointStarting) we switched the target file to the inactive file and prepared it
              // for a keypoint operation by updating its header block. Subsequently, the keypoint operation fails
              // which means that _activeFile currently points at an empty file into which we have been unable to
              // keypoint.
              //
              // We must leave this method with _activeFile pointing at the active file (as was the case prior
              // to the keypoint attempt). If we do not do this then any further keypoint operation will re-attempt
              // the same logic by switching from this empty file back to the active file. The active file will
              // be cleared in preparation for the keypoint operation (which will subsequently fail) and all
              // persistent information will be destroyed from disk.
  
              if (_activeFile == _file1)
              {
                  _activeFile = _file2;
              }
              else
              {
                  _activeFile = _file1;
              }
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "resizeLog", "WriteOperationFailedException");
              throw new WriteOperationFailedException(exc);
          } catch (Throwable exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.resizeLog", "1555", this);
  
              // Reset the target file reference (see description above for why this must be done)
              if (_activeFile == _file1)
              {
                  _activeFile = _file2;
              }
              else
              {
                  _activeFile = _file1;
              }
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "resizeLog", "InternalLogException");
              throw new InternalLogException(exc);
          }
  
          // Now determine how many bytes are currently available in the new target log file.
          _physicalFreeBytes = _activeFile.freeBytes();
  
          if (tc.isDebugEnabled())
              Tr.debug(tc, "Log file " + _activeFile.fileName() + " now has " + _physicalFreeBytes + " bytes of storage available");
          if (tc.isEntryEnabled())
              Tr.exit(tc, "resizeLog");
      }