docs: void writeSection(RecoverableUnitSectionImpl target, int unwrittenDataSize) throws InternalLogException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "writeSection", new java.lang.Object[] { this, target, new Integer(unwrittenDataSize) });
  
          // If the parent recovery log instance has experienced a serious internal error then prevent
          // this operation from executing.
          if (_recLog.failed())
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "writeSection", this);
              throw new InternalLogException(null);
          }
  
          // If the log was not open then throw an exception
          if (_logHandle == null)
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "writeSection", "InternalLogException");
              throw new InternalLogException(null);
          }
  
          _controlLock.getSharedLock(LOCK_REQUEST_ID_RUI_WRITESECTION);
  
          try
          {
              if (tc.isDebugEnabled())
                  Tr.debug(tc, "Writing recoverable unit '" + target.identity() + "'");
  
              if (tc.isDebugEnabled())
                  Tr.debug(tc, "Unwritten data size = " + unwrittenDataSize);
  
              final int requiredRecordSize = _recordHeaderSize + _unwrittenDataSize;;
  
              // Obtain a WritableLogRecord that provides direct access to the underlying recovery log.
              // The WritableLogRecord will write the required log record header to the underlying
              // recovery log.
              final WriteableLogRecord logRecord = _logHandle.getWriteableLogRecord(requiredRecordSize);
  
              // In some situations, there will not be enough space in the underlying recovery to obtain a
              // WritableLogRecord of the required size. The recovery log will need to perform "housekeeping"
              // to clean up the recovery log before this latest record can be written. In such
              // situations, the getWritableLogRecord() will trigger a keypoint operation before returning. 
              // Given that the keypoint operation will actually cause all the information within this
              // recoverable unit to be (re)written to disk, this method need take no further action. This
              // condition is indicated by the return of a null log record.
              if (logRecord != null)
              {
                  // Write the records header to disk. This includes the recoverable unit's identity,
                  // the failure scope that the unit belongs to, and the record's type.
                  writeRecordHeader(logRecord, RECORDTYPENORMAL);
  
                  // Now direct the recoverable unit section to write its content. If the recoverable unit 
                  // section has no data to write then this will be a no-op.
                  target.format(false, logRecord);
  
                  // Finally write a negative recoverable unit section id to indicate the there are no
                  // more sections.
                  logRecord.putInt(END_OF_SECTIONS);
  
                  // Tell the WritableLogRecord that we have finished adding recoverable unit sections. This
                  // will cause it to add the appropriate record tail to the underlying recovery log.
                  logRecord.close();
  
                  // Flag the fact at least part of this recoverable unit has now been written to the 
                  // underlying recovery log.
                  _storedOnDisk = true;
  
                  _logHandle.writeLogRecord(logRecord);
              }
          } catch (IOException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.writeSection", "755", this);
              if (tc.isEventEnabled())
                  Tr.event(tc, "An unexpected error IO occurred whilst formatting the recovery log buffer", exc);
  
              _recLog.markFailed(exc); /* @MD19484C */
  
              try
              {
                  _controlLock.releaseSharedLock(LOCK_REQUEST_ID_RUI_WRITESECTION);
              } catch (Throwable exc2)
              {
                  FFDCFilter.processException(exc2, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.writeSection", "766", this);
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "writeSection", "InternalLogException");
                  throw new InternalLogException(exc2);
              }
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "writeSection", "InternalLogException");
              throw new InternalLogException(exc);
          } catch (Throwable exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.writeSection", "776", this);
              if (tc.isEventEnabled())
                  Tr.event(tc, "An unexpected error occurred whilst formatting the recovery log buffer", exc);
  
              _recLog.markFailed(exc); /* @MD19484C */
  
              try
              {
                  _controlLock.releaseSharedLock(LOCK_REQUEST_ID_RUI_WRITESECTION);
              } catch (Throwable exc2)
              {
                  FFDCFilter.processException(exc2, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.writeSection", "787", this);
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "writeSection", "InternalLogException");
                  throw new InternalLogException(exc2);
              }
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "writeSection", "InternalLogException");
              throw new InternalLogException(exc);
          }
  
          try
          {
              _controlLock.releaseSharedLock(LOCK_REQUEST_ID_RUI_WRITESECTION);
          } catch (NoSharedLockException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.writeSection", "802", this);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "writeSection", "InternalLogException");
              throw new InternalLogException(exc);
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "writeSection");
      }