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;
}
