docs: public void keypoint() throws InternalLogException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "keypoint", this);
  
          try
          {
              if (tc.isDebugEnabled())
                  Tr.debug(tc, "Keypointing with isSnapshotSafe set to " + Configuration._isSnapshotSafe);
  
              // Attempt to get exclusive lock on the lock object provided by RecoveryLogService
              // to protect access to the isSuspended flag, which is toggled during calls
              // to RecoveryLogService suspend/resume
              synchronized (RLSControllerImpl.SUSPEND_LOCK)
              {
                  while (RLSControllerImpl.isSuspended())
                  {
                      try
                      {
                          if (tc.isDebugEnabled())
                              Tr.debug(tc, "Waiting for RecoveryLogService to resume");
                          RLSControllerImpl.SUSPEND_LOCK.wait();
                      } catch (InterruptedException exc)
                      {
                          // This exception is received if another thread interrupts this thread by calling this threads 
                          // Thread.interrupt method. The RecoveryLogService class does not use this mechanism for 
                          // breaking out of the wait call - it uses notifyAll to wake up all waiting threads. This
                          // exception should never be generated. If for some reason it is called then ignore it and 
                          // start to wait again.
                          FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypoint", "923", this);
                      }
                  }
  
                  if (Configuration._isSnapshotSafe)
                  {
                      if (tc.isDebugEnabled())
                          Tr.debug(tc, "Keypointing with isSnapshotSafe set to " + Configuration._isSnapshotSafe);
  
                      // Check if we've been configured to run in snapshot safe mode
                      // With this in place we synchronize all keypointInternal method calls and
                      // take the synchronization performance hit.  The benefit is that we
                      // can be sure that the log files will be in a consistent state
                      // for snapshotting
                      keypointInternal();
                  }
              }
  
              //  If we're not configured to be snapshot safe then we
              //  run a slight risk here that a force operation could be called
              //  just after the RecoveryLogService has been called to suspend,
              //  as we're outwith the sync block.
              //  The benefit is that we don't have the synchronization performance 
              //  hit when calling the force method 
              if (!Configuration._isSnapshotSafe)
              {
                  if (tc.isDebugEnabled())
                      Tr.debug(tc, "Keypointing with isSnapshotSafe set to " + Configuration._isSnapshotSafe);
  
                  keypointInternal();
              }
          } catch (InternalLogException exc)
          {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypoint", "932", this);
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "keypoint", exc);
              throw exc;
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "keypoint");
      }