Fix transaction aborting
During compilation, a java.lang.InternalError is used to indicate
that class initialization failed and the enclosing transaction
should be aborted and the changes rolled back. However there is
nothing preventing the code executed from a class initializer from
catching that exception (like catching Throwable and ignore it).
Therefore we may return from the class initializer with no pending
exception, even if the transaction was aborted, and not rollback
the changes properly.
To fix this, we now rely on the new Transaction::aborted_ field to
know whether a transaction aborted. When returning from the class
initializer without pending exception, we now check wether we aborted
the enclosing transaction. If that's the case, we set the status of
the class to kStatusError and throw a new java.lang.InternalError
with the original abort message.
This CL also contains some cleanup:
- Renames Transaction::Abort to Transaction::Rollback which is less
ambiguous and more reflect what is done.
- Moves the code throwing the java.lang.InternalError exception into
the Transaction::ThrowInternalError method so we do not duplicate
code. Now we may abort transaction more than once (because we may
have caught the java.lang.InternalError then execute code causing
new transaction abort), we only keep the first abort message to
throw the exception.
- Updates transaction_test with more cases and more checks.
- Bumps oat version to force recompilation with this fix.
Bug: 19202032
Change-Id: Iedc6969528a68bbdf3123146e990df4dbc57834b
diff --git a/runtime/transaction.cc b/runtime/transaction.cc
index 118c1a2..7e2e0a6 100644
--- a/runtime/transaction.cc
+++ b/runtime/transaction.cc
@@ -30,7 +30,8 @@
// TODO: remove (only used for debugging purpose).
static constexpr bool kEnableTransactionStats = false;
-Transaction::Transaction() : log_lock_("transaction log lock", kTransactionLogLock) {
+Transaction::Transaction()
+ : log_lock_("transaction log lock", kTransactionLogLock), aborted_(false) {
CHECK(Runtime::Current()->IsCompiler());
}
@@ -57,6 +58,35 @@
}
}
+void Transaction::Abort(const std::string& abort_message) {
+ MutexLock mu(Thread::Current(), log_lock_);
+ // We may abort more than once if the java.lang.InternalError thrown at the
+ // time of the abort has been caught during execution of a class initializer.
+ // We just keep the message of the first abort because it will cause the
+ // transaction to be rolled back anyway.
+ if (!aborted_) {
+ aborted_ = true;
+ abort_message_ = abort_message;
+ }
+}
+
+void Transaction::ThrowInternalError(Thread* self) {
+ DCHECK(IsAborted());
+ std::string abort_msg(GetAbortMessage());
+ self->ThrowNewException(self->GetCurrentLocationForThrow(), "Ljava/lang/InternalError;",
+ abort_msg.c_str());
+}
+
+bool Transaction::IsAborted() {
+ MutexLock mu(Thread::Current(), log_lock_);
+ return aborted_;
+}
+
+const std::string& Transaction::GetAbortMessage() {
+ MutexLock mu(Thread::Current(), log_lock_);
+ return abort_message_;
+}
+
void Transaction::RecordWriteFieldBoolean(mirror::Object* obj, MemberOffset field_offset,
uint8_t value, bool is_volatile) {
DCHECK(obj != nullptr);
@@ -150,7 +180,7 @@
intern_string_logs_.push_front(log);
}
-void Transaction::Abort() {
+void Transaction::Rollback() {
CHECK(!Runtime::Current()->IsActiveTransaction());
Thread* self = Thread::Current();
self->AssertNoPendingException();