int main(int argc, char **argv) { install_default_signal_handler(); struct tesla_store *global_store, *perthread; check(tesla_store_get(TESLA_SCOPE_GLOBAL, CLASSES, 1, &global_store)); check(tesla_store_get(TESLA_SCOPE_PERTHREAD, CLASSES, 1, &perthread)); check_store(global_store); check_store(perthread); return 0; }
X509_CRL *STORE_get_crl(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { STORE_OBJECT *object; X509_CRL *crl; check_store(s,STORE_F_STORE_GET_CRL, get_object,STORE_R_NO_GET_OBJECT_FUNCTION); object = s->meth->get_object(s, STORE_OBJECT_TYPE_X509_CRL, attributes, parameters); if (!object || !object->data.crl) { STOREerr(STORE_F_STORE_GET_CRL, STORE_R_FAILED_GETTING_KEY); return 0; } CRYPTO_add(&object->data.crl->references,1,CRYPTO_LOCK_X509_CRL); #ifdef REF_PRINT REF_PRINT("X509_CRL",data); #endif crl = object->data.crl; STORE_OBJECT_free(object); return crl; }
int STORE_store_arbitrary(STORE *s, BUF_MEM *data, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { STORE_OBJECT *object; int i; check_store(s, STORE_F_STORE_STORE_ARBITRARY, store_object, STORE_R_NO_STORE_OBJECT_ARBITRARY_FUNCTION); object = STORE_OBJECT_new(); if (!object) { STOREerr(STORE_F_STORE_STORE_ARBITRARY, ERR_R_MALLOC_FAILURE); return 0; } object->data.arbitrary = data; i = s->meth->store_object(s, STORE_OBJECT_TYPE_ARBITRARY, object, attributes, parameters); STORE_OBJECT_free(object); if (!i) { STOREerr(STORE_F_STORE_STORE_ARBITRARY, STORE_R_FAILED_STORING_ARBITRARY); return 0; } return 1; }
EVP_PKEY *STORE_get_public_key(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { STORE_OBJECT *object; EVP_PKEY *pkey; check_store(s,STORE_F_STORE_GET_PUBLIC_KEY, get_object,STORE_R_NO_GET_OBJECT_FUNCTION); object = s->meth->get_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY, attributes, parameters); if (!object || !object->data.key || !object->data.key) { STOREerr(STORE_F_STORE_GET_PUBLIC_KEY, STORE_R_FAILED_GETTING_KEY); return 0; } CRYPTO_add(&object->data.key->references,1,CRYPTO_LOCK_EVP_PKEY); #ifdef REF_PRINT REF_PRINT("EVP_PKEY",data); #endif pkey = object->data.key; STORE_OBJECT_free(object); return pkey; }
bool OopNCode::scavenge_contents() { ResourceMark m; bool needToInvalICache = false; char* bound = Memory->new_gen->boundary(); rememberLink.init(); addrDesc* p = locs(), *end = locsEnd(); LocChange* changes = NEW_RESOURCE_ARRAY( LocChange, end - p); int32 locLen = 0; for (; p < end; p++) { if (p->isOop()) { oop oldOop = (oop)p->referent(this); oop newOop = oldOop->scavenge(); if (newOop != oldOop) { changes[locLen].p = p; changes[locLen].newOop = newOop; locLen ++; needToInvalICache = true; } check_store(newOop, bound); } } for (LocChange* l = &changes[0]; locLen > 0; locLen--, l++) { l->p->set_referent(this, (char*)l->newOop); } return needToInvalICache; }
X509 *STORE_get_certificate(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { STORE_OBJECT *object; X509 *x; check_store(s,STORE_F_STORE_GET_CERTIFICATE, get_object,STORE_R_NO_GET_OBJECT_FUNCTION); object = s->meth->get_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, attributes, parameters); if (!object || !object->data.x509.certificate) { STOREerr(STORE_F_STORE_GET_CERTIFICATE, STORE_R_FAILED_GETTING_CERTIFICATE); return 0; } CRYPTO_add(&object->data.x509.certificate->references,1,CRYPTO_LOCK_X509); #ifdef REF_PRINT REF_PRINT("X509",data); #endif x = object->data.x509.certificate; STORE_OBJECT_free(object); return x; }
bool OopNCode::code_oops_do(oopsDoFn f) { ResourceMark m; bool needToInvalICache = false; char* bound = Memory->new_gen->boundary(); addrDesc* p = locs(), *end = locsEnd(); LocChange* changes = NEW_RESOURCE_ARRAY( LocChange, end - p); int32 locLen = 0; for (; p < end; p++) { if (!p->isOop()) { // no oops here } else { oop oldOop = (oop)p->referent(this); oop newOop = oldOop; OOPS_DO_TEMPLATE(&newOop, f); if (newOop != oldOop) { changes[locLen].p = p; changes[locLen].newOop = newOop; locLen ++; check_store(newOop, bound); needToInvalICache = true; } } } for (LocChange* l = &changes[0]; locLen > 0; locLen--, l++) { l->p->set_referent(this, (char*)l->newOop); } return needToInvalICache; }
int STORE_store_crl(STORE *s, X509_CRL *data, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { STORE_OBJECT *object; int i; check_store(s, STORE_F_STORE_STORE_CRL, store_object, STORE_R_NO_STORE_OBJECT_FUNCTION); object = STORE_OBJECT_new(); if (!object) { STOREerr(STORE_F_STORE_STORE_CRL, ERR_R_MALLOC_FAILURE); return 0; } CRYPTO_add(&data->references, 1, CRYPTO_LOCK_X509_CRL); object->data.crl = data; i = s->meth->store_object(s, STORE_OBJECT_TYPE_X509_CRL, object, attributes, parameters); STORE_OBJECT_free(object); if (!i) { STOREerr(STORE_F_STORE_STORE_CRL, STORE_R_FAILED_STORING_KEY); return 0; } return i; }
bool OopNCode::switch_pointers(oop from, oop to, nmethodBList* nmethods_to_invalidate) { Unused(nmethods_to_invalidate); ResourceMark m; bool needToInvalICache = false; char* bound = Memory->new_gen->boundary(); addrDesc* p = locs(), *end = locsEnd(); LocChange* changes = NEW_RESOURCE_ARRAY( LocChange, end - p); int32 locLen = 0; for (; p < end; p++) { if (!p->isOop()) { // no oops here } else { oop oldOop = (oop)p->referent(this); if (oldOop == from) { changes[locLen].p = p; locLen ++; check_store(to, bound); needToInvalICache = true; } } } for (LocChange* l = &changes[0]; locLen > 0; locLen--, l++) { l->p->set_referent(this, (char*)to); } return needToInvalICache; }
int STORE_store_certificate(STORE *s, X509 *data, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { STORE_OBJECT *object; int i; check_store(s, STORE_F_STORE_CERTIFICATE, store_object, STORE_R_NO_STORE_OBJECT_FUNCTION); object = STORE_OBJECT_new(); if (!object) { STOREerr(STORE_F_STORE_STORE_CERTIFICATE, ERR_R_MALLOC_FAILURE); return 0; } CRYPTO_add(&data->references, 1, CRYPTO_LOCK_X509); object->data.x509.certificate = data; i = s->meth->store_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, object, attributes, parameters); STORE_OBJECT_free(object); if (!i) { STOREerr(STORE_F_STORE_STORE_CERTIFICATE, STORE_R_FAILED_STORING_CERTIFICATE); return 0; } return 1; }
int STORE_store_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { STORE_OBJECT *object; int i; check_store(s, STORE_F_STORE_STORE_NUMBER, store_object, STORE_R_NO_STORE_OBJECT_NUMBER_FUNCTION); object = STORE_OBJECT_new(); if (!object) { STOREerr(STORE_F_STORE_STORE_NUMBER, ERR_R_MALLOC_FAILURE); return 0; } object->data.number = data; i = s->meth->store_object(s, STORE_OBJECT_TYPE_NUMBER, object, attributes, parameters); STORE_OBJECT_free(object); if (!i) { STOREerr(STORE_F_STORE_STORE_NUMBER, STORE_R_FAILED_STORING_NUMBER); return 0; } return 1; }
bool nmethod::code_oops_do(oopsDoFn f) { key.oops_do(f); FOR_MY_CODETABLE_ENTRIES(e) e->key.oops_do(f); scopes->oops_do(f); check_store(); return OopNCode::code_oops_do(f); }
bool nmethod::switch_pointers(oop from, oop to, nmethodBList* nmethods_to_invalidate) { key.switch_pointers(from, to); FOR_MY_CODETABLE_ENTRIES(e) e->key.switch_pointers(from, to); scopes->switch_pointers(from, to, nmethods_to_invalidate); check_store(); return OopNCode::switch_pointers(from, to, nmethods_to_invalidate); }
LLVMValueRef gen_ge_assign(struct node *ast) { LLVMValueRef result; result = gen_ge(ast); check_store(result, lvalue(ast->one)); return result; }
LLVMValueRef gen_assign(struct node *ast) { LLVMValueRef result; result = codegen(ast->two); /* TODO: Forbid assignment to labels */ check_store(result, lvalue(ast->one)); return result; }
LLVMValueRef gen_predec(struct node *ast) { LLVMValueRef result; result = LLVMBuildSub(builder, codegen(ast->one), CONST(1), ""); check_store(result, lvalue(ast->one)); return result; }
int STORE_list_crl_endp(STORE *s, void *handle) { check_store(s, STORE_F_STORE_LIST_CRL_ENDP, list_object_endp, STORE_R_NO_LIST_OBJECT_ENDP_FUNCTION); if (!s->meth->list_object_endp(s, handle)) { STOREerr(STORE_F_STORE_LIST_CRL_ENDP, STORE_R_FAILED_LISTING_KEYS); return 0; } return 1; }
bool nmethod::scavenge_contents() { // scavenge all locations bool needToInvalICache = OopNCode::scavenge_contents(); // do this after OopNCode::scavenge_contents, since it resets rememberLink key.scavenge_contents(); FOR_MY_CODETABLE_ENTRIES(e) e->key.scavenge_contents(); scopes->scavenge_contents(); check_store(); return needToInvalICache; }
int STORE_list_certificate_endp(STORE *s, void *handle) { check_store(s, STORE_F_STORE_LIST_CERTIFICATE_ENDP, list_object_endp, STORE_R_NO_LIST_OBJECT_ENDP_FUNCTION); if (!s->meth->list_object_endp(s, handle)) { STOREerr(STORE_F_STORE_LIST_CERTIFICATE_ENDP, STORE_R_FAILED_LISTING_CERTIFICATES); return 0; } return 1; }
int STORE_list_public_key_end(STORE *s, void *handle) { check_store(s, STORE_F_STORE_LIST_PUBLIC_KEY_END, list_object_end, STORE_R_NO_LIST_OBJECT_END_FUNCTION); if (!s->meth->list_object_end(s, handle)) { STOREerr(STORE_F_STORE_LIST_PUBLIC_KEY_END, STORE_R_FAILED_LISTING_KEYS); return 0; } return 1; }
LLVMValueRef gen_postdec(struct node *ast) { LLVMValueRef orig, result; orig = codegen(ast->one); result = LLVMBuildSub(builder, orig, CONST(1), ""); check_store(result, lvalue(ast->one)); return orig; }
int STORE_delete_number(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { check_store(s, STORE_F_STORE_DELETE_NUMBER, delete_object, STORE_R_NO_DELETE_NUMBER_FUNCTION); if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_NUMBER, attributes, parameters)) { STOREerr(STORE_F_STORE_DELETE_NUMBER, STORE_R_FAILED_DELETING_NUMBER); return 0; } return 1; }
int STORE_revoke_certificate(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { check_store(s, STORE_F_STORE_REVOKE_CERTIFICATE, revoke_object, STORE_R_NO_REVOKE_OBJECT_FUNCTION); if (!s->meth->revoke_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, attributes, parameters)) { STOREerr(STORE_F_STORE_REVOKE_CERTIFICATE, STORE_R_FAILED_REVOKING_CERTIFICATE); return 0; } return 1; }
int STORE_delete_crl(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { check_store(s, STORE_F_STORE_DELETE_CRL, delete_object, STORE_R_NO_DELETE_OBJECT_FUNCTION); if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_X509_CRL, attributes, parameters)) { STOREerr(STORE_F_STORE_DELETE_CRL, STORE_R_FAILED_DELETING_KEY); return 0; } return 1; }
int STORE_delete_arbitrary(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { check_store(s, STORE_F_STORE_DELETE_ARBITRARY, delete_object, STORE_R_NO_DELETE_ARBITRARY_FUNCTION); if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_ARBITRARY, attributes, parameters)) { STOREerr(STORE_F_STORE_DELETE_ARBITRARY, STORE_R_FAILED_DELETING_ARBITRARY); return 0; } return 1; }
int STORE_list_private_key_endp(STORE *s, void *handle) { int ret; check_store(s,STORE_F_STORE_LIST_PRIVATE_KEY_ENDP, list_object_endp,STORE_R_NO_LIST_OBJECT_ENDP_FUNCTION); ret = s->meth->list_object_endp(s, handle); if (ret < 0) { STOREerr(STORE_F_STORE_LIST_PRIVATE_KEY_ENDP, STORE_R_FAILED_LISTING_KEYS); return -1; } return ret ? 1 : 0; }
int STORE_modify_private_key(STORE *s, OPENSSL_ITEM search_attributes[], OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[], OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[]) { check_store(s, STORE_F_STORE_MODIFY_PRIVATE_KEY, modify_object, STORE_R_NO_MODIFY_OBJECT_FUNCTION); if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY, search_attributes, add_attributes, modify_attributes, delete_attributes, parameters)) { STOREerr(STORE_F_STORE_MODIFY_PRIVATE_KEY, STORE_R_FAILED_MODIFYING_PRIVATE_KEY); return 0; } return 1; }
int STORE_modify_crl(STORE *s, OPENSSL_ITEM search_attributes[], OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[], OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[]) { check_store(s, STORE_F_STORE_MODIFY_CRL, modify_object, STORE_R_NO_MODIFY_OBJECT_FUNCTION); if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_X509_CRL, search_attributes, add_attributes, modify_attributes, delete_attributes, parameters)) { STOREerr(STORE_F_STORE_MODIFY_CRL, STORE_R_FAILED_MODIFYING_CRL); return 0; } return 1; }
void * STORE_list_crl_start(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { void *handle; check_store(s, STORE_F_STORE_LIST_CRL_START, list_object_start, STORE_R_NO_LIST_OBJECT_START_FUNCTION); handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_X509_CRL, attributes, parameters); if (!handle) { STOREerr(STORE_F_STORE_LIST_CRL_START, STORE_R_FAILED_LISTING_KEYS); return 0; } return handle; }
int STORE_revoke_public_key(STORE *s, OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]) { int i; check_store(s, STORE_F_STORE_REVOKE_PUBLIC_KEY, revoke_object, STORE_R_NO_REVOKE_OBJECT_FUNCTION); i = s->meth->revoke_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY, attributes, parameters); if (!i) { STOREerr(STORE_F_STORE_REVOKE_PUBLIC_KEY, STORE_R_FAILED_REVOKING_KEY); return 0; } return i; }