docs: public void rollback(PersistentTransaction transaction) throws PersistenceException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "rollback", "Transaction="+transaction);
  
          // Defect 363755
          if (!_available)
          {
              MessageStoreUnavailableException msue = new MessageStoreUnavailableException("Operation not possible as MessageStore is unavailable!");
              if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Operation not possible as MessageStore is unavailable!");
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
              throw msue;
          }
  
          TaskList    taskList = (TaskList) transaction.getWorkList();
          PersistentTranId xid = transaction.getPersistentTranId();
  
          // Defect 292594
          // We only need to do any work if we have STORE_ALWAYS or
          // STORE_EVENTUALLY. STORE_MAYBE work will not have been done
          // in prepare so it doesn't need rolling back.
          if (taskList.hasStoreAlways() || taskList.hasStoreEventually())
          {
              // Defect 298584
              // We only need to get a bacthing context if did some
              // synchronous work during prepare.
  
              // Get the batching context for this two-phase operation.
              // One must exist from the prepare phase. If it does not
              // exist in the MS transaction then it must exist in the
              // object manager indoubt list. 
              // PM31431 if one does not exist then we can only assume 
              // we did not get as far as doing the prepare and so just
              // accept the rollback
              
              BatchingContext batch = transaction.getBatchingContext();
              if (batch == null)
              {
                  Transaction tran = null;
                  try
                  {
                      tran = _objectManager.getTransactionByXID(xid.toByteArray());
                  }
                  catch (ObjectManagerException ome)
                  {
                      com.ibm.ws.ffdc.FFDCFilter.processException(ome, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableMessageStoreImpl.rollback", "1:1950:1.81.1.6", this);
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Exception caught requesting recovered transaction from object manager!", ome);
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
                      throw new PersistenceException("Exception caught requesting recovered transaction from object manager: "+ome.getMessage(), ome);
                  }
  
                  if (tran != null)
                  {
                      batch = new BatchingContextImpl(_objectManager, _permanentStore, tran);
                  }
                  else
                  {
                      // no transaction could be found which must mean we did not manage to get to the prepare.
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Transaction could not be found");
                  }
              }
  
              if (batch != null)
              {
                  try
                  {
                      // As this is a rollback we use the updateXIDToRolledBack()
                      // method to inform the batching context that we now
                      // wish to backout all existing work during the next
                      // executeBatch() call.
                      batch.updateXIDToRolledback(xid);
  
                      // Submit the batch and trigger the rollback in the
                      // object manager.
                      batch.executeBatch();
  
                      //If we get to this point then the rollback was successful.
                      //However, we don't need to invoke the OperationBegun/Completed
                      //callbacks on the Persistable. The rollback can only be for
                      //addition and removal of Persistables, not for updates. In
                      //the case of a rollback of an addition, the Persistable will
                      //be removed from the cache which will no longer be interested
                      //in its persistent representation. In the case of a rollback
                      //of a removal, the Persistable will be re-instated in the cache
                      //and the disk representation is exactly the same as it was
                      //before the rollback.
                  }
                  catch (PersistenceException pe)
                  {
                      com.ibm.ws.ffdc.FFDCFilter.processException(pe, "com.ibm.ws.sib.msgstore.persistence.objectManager.PersistableMessageStoreImpl.rollback", "1:1994:1.81.1.6", this);
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Exception caught rolling back transction in object store!", pe);
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
                      throw pe;
                  }
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "rollback");
      }