docs: @Override
      public RecoverableUnit createRecoverableUnit(FailureScope failureScope) throws LogClosedException, InternalLogException, LogIncompatibleException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "createRecoverableUnit", new Object[] { failureScope, this });
  
          // If this recovery log instance has been marked as incompatible then throw an exception
          // accordingly.
          if (incompatible())
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "createRecoverableUnit", "LogIncompatibleException");
              throw new LogIncompatibleException();
          }
  
          // If this recovery log instance has experienced a serious internal error then prevent this operation from
          // executing.
          if (failed())
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "createRecoverableUnit", "InternalLogException");
              throw new InternalLogException(null);
          }
  
          // Check that the log is actually open.
          if (_logHandle == null)
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "createRecoverableUnit", "LogClosedException");
              throw new LogClosedException(null);
          }
  
          RecoverableUnitImpl recoverableUnit = null;
  
          // We are going to change the internal data structures by adding a new recoverable unit. Take a shared lock
          // to avoid a clash with the keypoint logic.
          _controlLock.getSharedLock(LOCK_REQUEST_ID_MSRL_CREATE);
  
          synchronized (this)
          {
              long identity = _recUnitIdTable.nextId(this);
              recoverableUnit = new RecoverableUnitImpl(this, identity, failureScope, _logHandle, _storageMode, _controlLock);
              if (tc.isEventEnabled())
                  Tr.event(tc, "MultiScopeRecoveryLog '" + _logName + "' created a new RecoverableUnit with id '" + identity + "'");
          }
  
          try
          {
              _controlLock.releaseSharedLock(LOCK_REQUEST_ID_MSRL_CREATE);
          } catch (NoSharedLockException exc)
          {
              // In practice this exception will not be generated as we have obtained the shared lock at the top of this method
              // so we should be able to release it here. If this exception is generated then all we can do is throw the
              // InternalLogException exception to indicate a serious problem with the recovery log service.
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.createRecoverableUnit", "1070", this);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "createRecoverableUnit", "InternalLogException");
              throw new InternalLogException(exc);
          } catch (Throwable exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.createRecoverableUnit", "1076", this);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "createRecoverableUnit", "InternalLogException");
              throw new InternalLogException(exc);
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "createRecoverableUnit", recoverableUnit);
          return recoverableUnit;
      }