We do call ctx.setRollbackOnly and do odmg-tx.abort() call.

@ejb:interface-method
187687
public void rollbackSetRollbackAndThrowException(List objects)
    {
        log.info("rollbackSetRollbackAndThrowException method was called");
        storeObjects(objects);
        getSessionContext().setRollbackOnly();
        /*
        seems that some appServer expect that all used resources will be closed before
        the JTA-TXManager does call Synchronization#beforeCompletion(), so we have
        to cleanup used resources. This could be done by call abort on odmg-api
        */
        getImplementation().currentTransaction().abort();
        // to notify the client about the failure we throw an exception
        // if we don't throw such an exception the client don't get notified
        // about the failure
        throw new EJBException("## Testing of rollback behaviour - rollbackSetRollbackAndThrowException ##");
    }
610834
private void onRollBack(PersistenceDelegator delegator, Map<Object, EventLog> eventCol)
    {
        if (eventCol != null && !eventCol.isEmpty())
        {
            Collection<EventLog> events = eventCol.values();
            Iterator<EventLog> iter = events.iterator();

            while (iter.hasNext())
            {
                try
                {
                    EventLog event = iter.next();
                    Node node = event.getNode();
                    Class clazz = node.getDataClass();
                    EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(delegator.getKunderaMetadata(), clazz);
                    Client client = delegator.getClient(metadata);

                    // do manual rollback, if data is processed, and running
                    // without transaction or with kundera's default transaction
                    // support!
                    if (node.isProcessed()
                            && (!delegator.isTransactionInProgress() || MetadataUtils
                                    .defaultTransactionSupported(metadata.getPersistenceUnit(), delegator.getKunderaMetadata())))
                    {
                        if (node.getOriginalNode() == null)
                        {
                            Object entityId = node.getEntityId();
                            client.remove(node.getData(), entityId);
                        }
                        else
                        {
                            client.persist(node.getOriginalNode());
                        }
                    }
                    // mark it null for garbage collection.
                    event = null;
                }
                catch (Exception ex)
                {
                    log.warn("Caught exception during rollback, Caused by:", ex);
                    // bypass to next event
                }
            }
        }
        // mark it null for garbage collection.
        eventCol = null;
    }
469966
public void rollbackOdmgAbort(List objects)
    {
        log.info("rollbackOdmgAbort method was called");
        storeObjects(objects);
        getImplementation().currentTransaction().abort();
    }
126382
@Override
    public void rollback() throws IllegalStateException, SystemException
    {
        for (ResourceManager implementor : implementors)
        {
            if (implementor != null)
            {
                implementor.doRollback();
                status = Status.STATUS_ROLLEDBACK;
            }
        }
    }
286090
protected function postRollback()
    {
        // Unset the inserted entities' Ids
        foreach ($this->scheduledForInsertion as $objectHashId => $index) {
            if (($entity = $this->scheduledActions[$index][1] ?? null) === null) {
                continue;
            }

            $idGenerator = $this->idGeneratorRegistry->getIdGenerator($this->entityRegistry->getClassName($entity));

            if ($idGenerator !== null) {
                $this->idAccessorRegistry->setEntityId(
                    $entity,
                    $idGenerator->getEmptyValue($entity)
                );
            }
        }
    }
920698
@Override
	public void setRollbackOnly() {
		Optional<LocalTransactionContext> txContext = currentTxContext();
		if (txContext.isPresent()) {
			txContext.get().setRollbackOnly();
		} else {
			this.unmanagedTransaction.ifPresent(LocalTransactionContext::setRollbackOnly);
		}
	}
1065713
public void rollback(Xid xid) throws XAException
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "rollback", new Object[]{_XARes, xid});

        try
        {
            _XARes.rollback(xid);
        }
        catch (XAException xae)
        {
            FFDCFilter.processException(xae, "com.ibm.ws.Transaction.JTA.XARminst.rollback", "295", this);
            int errorCode = xae.errorCode;
            if (tc.isDebugEnabled()) Tr.debug(tc, "XAException: error code " + XAReturnCodeHelper.convertXACode(errorCode), xae);
            if ((errorCode == XAException.XA_HEURRB) ||
                (errorCode == XAException.XA_HEURCOM) ||
                (errorCode == XAException.XA_HEURMIX) ||
                (errorCode == XAException.XA_HEURHAZ))
            {
                if (tc.isDebugEnabled()) Tr.debug(tc, "rollback returned heuristic");
                try
                {
                    _XARes.forget(xid);
                }
                catch (XAException xae2)
                {
                    FFDCFilter.processException(xae2, "com.ibm.ws.Transaction.JTA.XARminst.rollback", "676", this);
                    errorCode = xae2.errorCode;
                    if (errorCode != XAException.XAER_NOTA)
                    {
                        Tr.error(tc, "WTRN0054_XA_FORGET_ERROR", new Object[] {XAReturnCodeHelper.convertXACode(errorCode), xae2});
                        if (tc.isEntryEnabled()) Tr.exit(tc, "rollback", xae2);
                        throw xae2;
                    }
                }
            }
            else if ((errorCode == XAException.XAER_NOTA) ||
                     (errorCode == XAException.XAER_RMERR) ||
                     (errorCode >= XAException.XA_RBBASE &&
                      errorCode <= XAException.XA_RBEND))
            {
                if (tc.isDebugEnabled()) Tr.debug(tc, "rollback complete");
            }
            else
            {
                // XAER_PROTO, XAER_INVAL or XAER_RMFAIL
                Tr.warning(tc, "WTRN0031_XA_ROLLBACK_FAILED", new Object[] {xid, xae});
                if (tc.isEntryEnabled()) Tr.exit(tc, "rollback", xae);
                throw xae;
            }
        }

        if (tc.isEntryEnabled()) Tr.exit(tc, "rollback");
    }
208097
public void rollback() throws SQLException {

    cmdPrologue();

    lock.lock();
    try {

      if (inTransaction()) {
        executeQuery("ROLLBACK");
      }

    } catch (Exception e) {
      /* eat exception */
    } finally {
      lock.unlock();
    }
  }
360860
public static void rollbackQuietly(EntityManager entityManager) {
        if (entityManager.getTransaction().isActive()/* && entityManager.getTransaction().getRollbackOnly()*/) {
            try {
                entityManager.getTransaction().rollback();
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
        }
    }
1373157
@Override
	public void setRollbackOnly() throws TransactionManagementException {
		logger.entering(CLASSNAME, "setRollbackOnly");
		try {
			userTran.setRollbackOnly();
			logger.log(Level.FINE, "javax.transaction.Status: {0}", userTran.getStatus());
		} catch (IllegalStateException e) {
			throw new TransactionManagementException(e);
		} catch (SystemException e) {
			throw new TransactionManagementException(e);
		}
		logger.exiting(CLASSNAME, "setRollbackOnly");
	}
871284
protected Boolean getApplicationExceptionRollback(Throwable t) {
        Boolean rollback;
        if (ivIgnoreApplicationExceptions) {
            rollback = null;
        } else {
            ComponentMetaData cmd = getComponentMetaData();
            EJBModuleMetaDataImpl mmd = (EJBModuleMetaDataImpl) cmd.getModuleMetaData();
            rollback = mmd.getApplicationExceptionRollback(t);
        }
        return rollback;
    }
743017
public void abort() {
        if (asyncHandle != 0) {
            int handle = asyncHandle;
            asyncHandle = 0;
            broker.callRPCAbort(handle);
            ZKUtil.fireEvent(new AsyncRPCAbortEvent(rpcName, target, handle));
            rpcName = null;
        }
    }
794897
void rollbackTransaction() throws JMSException {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "rollbackTransaction");

        try {
            if (rolledBackDueToConnectionFailure) { //PK60857
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    SibTr.debug(tc, "rolledBackDueToConnectionFailure = true");
                }
                // No-op'ing the rollback because it has already happened during the commit.
                // This means rollback should never have been called, but some components insist on calling rollback after getting a TransactionRolledBackException.
                return; // exit trace handled by the finally block
            }

            jcaSession.rollbackLocalTransaction();
            uncommittedReceiveCount = 0;
        } catch (javax.resource.spi.IllegalStateException ise) {
            // No FFDC code needed
            // d238447 FFDC review. IllegalState is thrown if the jcaSession is closed, which
            //   might occur in a badly coded app due to concurrent race. No FFDC.
            throw (javax.jms.IllegalStateException) JmsErrorUtils.newThrowable(javax.jms.IllegalStateException.class,
                                                                               "EXCEPTION_RECEIVED_CWSIA0053",
                                                                               new Object[] { ise, "JmsSessionImpl.rollbackTransaction (#1)" },
                                                                               ise,
                                                                               null, // null probeId = no FFDC
                                                                               this,
                                                                               tc
                            );
        } catch (javax.resource.spi.LocalTransactionException lte) {
            // No FFDC code needed
            // d222942 review - ok
            // d238447 FFDC review. LTE thrown when no transaction is in progress. JMS layer shouldn't
            //   get this, so generate FFDC to indicate something has gone wrong.
            throw (javax.jms.IllegalStateException) JmsErrorUtils.newThrowable(javax.jms.IllegalStateException.class,
                                                                               "EXCEPTION_RECEIVED_CWSIA0053",
                                                                               new Object[] { lte, "JmsSessionImpl.rollbackTransaction (#2)" },
                                                                               lte,
                                                                               "JmsSessionImpl.rollbackTransaction#2",
                                                                               this,
                                                                               tc
                            );
        } catch (Exception e) {
            // No FFDC code needed
            // d238447 FFDC review - generate FFDC.
            throw (JMSException) JmsErrorUtils.newThrowable(JMSException.class,
                                                            "EXCEPTION_RECEIVED_CWSIA0053",
                                                            new Object[] { e, "JmsSessionImpl.rollbackTransaction (#3)" },
                                                            e,
                                                            "JmsSessionImpl.rollbackTransaction#3",
                                                            this,
                                                            tc
                            );
        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "commitTransaction");
        }
    }
1108284
public void rollback() throws DBCleanException
   {
      try
      {
         execute(rollbackingScripts);
      }
      catch (SQLException e)
      {
         throw new DBCleanException(JDBCUtils.getFullMessage(e), e);
      }
   }
574688
private void abort(List<TransactionableResourceManagerListener> listeners) throws XAException
   {
      boolean exception = false;
      for (int i = 0, length = listeners.size(); i < length; i++)
      {
         TransactionableResourceManagerListener listener = listeners.get(i);
         try
         {
            listener.onAbort();
         }
         catch (Exception e)
         {
            log.error("Could not execute the method onAbort", e);
            exception = true;
         }
      }
      if (exception)
      {
         throw new XAException(XAException.XAER_RMERR);
      }
   }
146010
@Override
    public void rollback(String globalId) throws HeuristicHazardException, HeuristicCommitException, HeuristicMixedException, SystemException {

        final TransactionWrapper t = TransactionWrapper.getTransactionWrapper(globalId);

        if (t != null) {
            t.rollback();
        } else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "No matching TransactionWrapper: " + globalId);
            throw new SystemException();
        }
    }
622349
public void rollback() throws SystemException {
        Transaction transaction = currentTransaction();
        if (transaction == null) {
            throw new IllegalStateException("No active transaction");
        }
        transaction.rollback();     
    }