void Dictionary::verify() {
guarantee(number_of_entries() >= 0, "Verify of system dictionary failed");
int element_count = 0;
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
Klass* e = probe->klass();
ClassLoaderData* loader_data = probe->loader_data();
guarantee(e->oop_is_instance(),
"Verify of system dictionary failed");
// class loader must be present; a null class loader is the
// boostrap loader
guarantee(loader_data != NULL || DumpSharedSpaces ||
loader_data->class_loader() == NULL ||
loader_data->class_loader()->is_instance(),
"checking type of class_loader");
e->verify();
probe->verify_protection_domain_set();
element_count++;
}
}
guarantee(number_of_entries() == element_count,
"Verify of system dictionary failed");
debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
_pd_cache_table->verify();
}
void Dictionary::print() {
ResourceMark rm;
HandleMark hm;
tty->print_cr("Java system dictionary (table_size=%d, classes=%d)",
table_size(), number_of_entries());
tty->print_cr("^ indicates that initiating loader is different from "
"defining loader");
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
if (Verbose) tty->print("%4d: ", index);
Klass* e = probe->klass();
ClassLoaderData* loader_data = probe->loader_data();
bool is_defining_class =
(loader_data == InstanceKlass::cast(e)->class_loader_data());
tty->print("%s%s", is_defining_class ? " " : "^",
e->external_name());
tty->print(", loader ");
loader_data->print_value();
tty->cr();
}
}
tty->cr();
_pd_cache_table->print();
tty->cr();
}
void ProtectionDomainCacheTable::print() {
tty->print_cr("Protection domain cache table (table_size=%d, classes=%d)",
table_size(), number_of_entries());
for (int index = 0; index < table_size(); index++) {
for (ProtectionDomainCacheEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
probe->print();
}
}
}
void ProtectionDomainCacheTable::verify() {
int element_count = 0;
for (int index = 0; index < table_size(); index++) {
for (ProtectionDomainCacheEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
probe->verify();
element_count++;
}
}
guarantee(number_of_entries() == element_count,
"Verify of protection domain cache table failed");
debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
}
void Dictionary::reorder_dictionary() {
// Copy all the dictionary entries into a single master list.
DictionaryEntry* master_list = NULL;
for (int i = 0; i < table_size(); ++i) {
DictionaryEntry* p = bucket(i);
while (p != NULL) {
DictionaryEntry* tmp;
tmp = p->next();
p->set_next(master_list);
master_list = p;
p = tmp;
}
set_entry(i, NULL);
}
// Add the dictionary entries back to the list in the correct buckets.
while (master_list != NULL) {
DictionaryEntry* p = master_list;
master_list = master_list->next();
p->set_next(NULL);
Symbol* class_name = InstanceKlass::cast((Klass*)(p->klass()))->name();
// Since the null class loader data isn't copied to the CDS archive,
// compute the hash with NULL for loader data.
unsigned int hash = compute_hash(class_name, NULL);
int index = hash_to_index(hash);
p->set_hash(hash);
p->set_loader_data(NULL); // loader_data isn't copied to CDS
p->set_next(bucket(index));
set_entry(index, p);
}
}
void cam::reset_table()
{
for (uint32_t i = 0; i < table_size(); i++) {
axi_write(cam[i][0], 0); // ensure to be in state WR_ISTATE_PROCESSING by potentially writing a DROP action to that address (FORWARD without port/vport bits set)
axi_write(cam[i][7], 0); // clear the last word including the valid bit (FSM goes back to state WR_ISTATE_WAITING_FOR_ACTION)
}
}
/**
* Invoked to process a part of request body data.
*
* @param d
*/
int htp_ch_urlencoded_callback_request_body_data(htp_tx_data_t *d) {
if (d->data != NULL) {
// Process one chunk of data
htp_urlenp_parse_partial(d->tx->request_urlenp_body, d->data, d->len);
} else {
// Finalize parsing
htp_urlenp_finalize(d->tx->request_urlenp_body);
if (d->tx->connp->cfg->parameter_processor == NULL) {
// We are going to use the parser table directly
d->tx->request_params_body = d->tx->request_urlenp_body->params;
d->tx->request_params_body_reused = 1;
htp_transcode_params(d->tx->connp, &d->tx->request_params_body, 0);
} else {
// We have a parameter processor defined, which means we'll
// need to create a new table
d->tx->request_params_body =
d->tx->cfg->create_table(table_size(d->tx->request_urlenp_body->params));
// Transform parameters and store them into the new table
bstr *name;
void *tvalue;
table_iterator_reset(d->tx->request_urlenp_body->params);
while ((name = table_iterator_next(d->tx->request_urlenp_body->params, & tvalue)) != NULL) {
d->tx->connp->cfg->parameter_processor(d->tx->request_params_body, name, (bstr *)tvalue);
// TODO Check return code
}
htp_transcode_params(d->tx->connp, &d->tx->request_params_body, 1);
}
}
return HOOK_OK;
}
static void get_format_range(Instance *pi, Range *range)
{
//int i;
//int rc;
ALSAio_private *priv = (ALSAio_private *)pi;
if (!priv->c.handle) {
fprintf(stderr, "*** device is not open!\n");
return;
}
Range_clear(range);
range->type = RANGE_STRINGS;
#if 0
for (i=0; i < table_size(formats); i++) {
rc = snd_pcm_hw_params_test_format(priv->c.handle, priv->c.hwparams, formats[i].value);
if (rc == 0) {
fprintf(stderr, " %s sampling available\n", formats[i].label);
IndexedSet_add(range->strings, String_new(formats[i].label));
}
}
#else
fprintf(stderr, "*** %s is disabled or now\n", __func__);
#endif
}
/* Devolve número de elementos na tabela.
*/
int ptable_size(struct ptable_t *ptable)
{
if(ptable->isOpen)
{
return table_size(ptable->table);
}
return 0;
}
void ProtectionDomainCacheTable::oops_do(OopClosure* f) {
for (int index = 0; index < table_size(); index++) {
for (ProtectionDomainCacheEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
probe->oops_do(f);
}
}
}
void PlaceholderTable::classes_do(KlassClosure* f) {
for (int index = 0; index < table_size(); index++) {
for (PlaceholderEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
probe->classes_do(f);
}
}
}
// do all entries in the placeholder table
void PlaceholderTable::entries_do(void f(Symbol*)) {
for (int index = 0; index < table_size(); index++) {
for (PlaceholderEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
f(probe->klassname());
}
}
}
// do all entries in the placeholder table
void PlaceholderTable::entries_do(void f(symbolOop, oop)) {
for (int index = 0; index < table_size(); index++) {
for (PlaceholderEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
f(probe->klass(), probe->loader());
}
}
}
/**
* unpack_table - unpack a dfa table (one of accept, default, base, next check)
* @blob: data to unpack
* @bsize: size of blob
*
* Returns: pointer to table else NULL on failure
*
* NOTE: must be freed by free_table (not kmalloc)
*/
static struct table_header *unpack_table(char *blob, size_t bsize)
{
struct table_header *table = NULL;
struct table_header th;
int unmap_alias = 0;
size_t tsize;
if (bsize < sizeof(struct table_header))
goto out;
/* loaded td_id's start at 1, subtract 1 now to avoid doing
* it every time we use td_id as an index
*/
th.td_id = be16_to_cpu(*(u16 *) (blob)) - 1;
th.td_flags = be16_to_cpu(*(u16 *) (blob + 2));
th.td_lolen = be32_to_cpu(*(u32 *) (blob + 8));
blob += sizeof(struct table_header);
if (!(th.td_flags == YYTD_DATA16 || th.td_flags == YYTD_DATA32 ||
th.td_flags == YYTD_DATA8))
goto out;
tsize = table_size(th.td_lolen, th.td_flags);
if (bsize < tsize)
goto out;
/* freed by free_table */
table = kmalloc(tsize, GFP_KERNEL | __GFP_NOWARN);
if (!table) {
tsize = tsize < sizeof(struct work_struct) ?
sizeof(struct work_struct) : tsize;
unmap_alias = 1;
table = vmalloc(tsize);
}
if (table) {
*table = th;
if (th.td_flags == YYTD_DATA8)
UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
u8, byte_to_byte);
else if (th.td_flags == YYTD_DATA16)
UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
u16, be16_to_cpu);
else if (th.td_flags == YYTD_DATA32)
UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
u32, be32_to_cpu);
else
goto fail;
}
out:
if (unmap_alias)
vm_unmap_aliases();
return table;
fail:
free_table(table);
return NULL;
}
void SymbolPropertyTable::oops_do(OopClosure* f) {
for (int index = 0; index < table_size(); index++) {
for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
if (p->method_type() != NULL) {
f->do_oop(p->method_type_addr());
}
}
}
}
/**
* unpack_table - unpack a dfa table (one of accept, default, base, next check)
* @blob: data to unpack (NOT NULL)
* @bsize: size of blob
*
* Returns: pointer to table else NULL on failure
*
* NOTE: must be freed by kvfree (not kfree)
*/
static struct table_header *unpack_table(char *blob, size_t bsize)
{
struct table_header *table = NULL;
struct table_header th;
size_t tsize;
if (bsize < sizeof(struct table_header))
goto out;
/* loaded td_id's start at 1, subtract 1 now to avoid doing
* it every time we use td_id as an index
*/
th.td_id = be16_to_cpu(*(__be16 *) (blob)) - 1;
if (th.td_id > YYTD_ID_MAX)
goto out;
th.td_flags = be16_to_cpu(*(__be16 *) (blob + 2));
th.td_lolen = be32_to_cpu(*(__be32 *) (blob + 8));
blob += sizeof(struct table_header);
if (!(th.td_flags == YYTD_DATA16 || th.td_flags == YYTD_DATA32 ||
th.td_flags == YYTD_DATA8))
goto out;
tsize = table_size(th.td_lolen, th.td_flags);
if (bsize < tsize)
goto out;
table = kvzalloc(tsize, GFP_KERNEL);
if (table) {
table->td_id = th.td_id;
table->td_flags = th.td_flags;
table->td_lolen = th.td_lolen;
if (th.td_flags == YYTD_DATA8)
UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
u8, u8, byte_to_byte);
else if (th.td_flags == YYTD_DATA16)
UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
u16, __be16, be16_to_cpu);
else if (th.td_flags == YYTD_DATA32)
UNPACK_ARRAY(table->td_data, blob, th.td_lolen,
u32, __be32, be32_to_cpu);
else
goto fail;
/* if table was vmalloced make sure the page tables are synced
* before it is used, as it goes live to all cpus.
*/
if (is_vmalloc_addr(table))
vm_unmap_aliases();
}
out:
return table;
fail:
kvfree(table);
return NULL;
}
void SymbolPropertyTable::methods_do(void f(Method*)) {
for (int index = 0; index < table_size(); index++) {
for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
Method* prop = p->method();
if (prop != NULL) {
f((Method*)prop);
}
}
}
}
// All classes, and their class loaders
// Don't iterate over placeholders
void Dictionary::classes_do(void f(Klass*, ClassLoaderData*)) {
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
Klass* k = probe->klass();
f(k, probe->loader_data());
}
}
}
// We must keep the symbolOop used in the name alive. We'll use the
// loaders to decide if a particular entry can be purged.
void LoaderConstraintTable::always_strong_classes_do(OopClosure* blk) {
// We must keep the symbolOop used in the name alive.
for (int cindex = 0; cindex < table_size(); cindex++) {
for (LoaderConstraintEntry* lc_probe = bucket(cindex);
lc_probe != NULL;
lc_probe = lc_probe->next()) {
assert (lc_probe->name() != NULL, "corrupted loader constraint table");
blk->do_oop((oop*)lc_probe->name_addr());
}
}
}
// Added for initialize_itable_for_klass to handle exceptions
// Just the classes from defining class loaders
void Dictionary::classes_do(void f(Klass*, TRAPS), TRAPS) {
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
Klass* k = probe->klass();
if (probe->loader_data() == InstanceKlass::cast(k)->class_loader_data()) {
f(k, CHECK);
}
}
}
}
Klass* Dictionary::try_get_next_class() {
while (true) {
if (_current_class_entry != NULL) {
Klass* k = _current_class_entry->klass();
_current_class_entry = _current_class_entry->next();
return k;
}
_current_class_index = (_current_class_index + 1) % table_size();
_current_class_entry = bucket(_current_class_index);
}
// never reached
}
void PlaceholderTable::print() {
for (int pindex = 0; pindex < table_size(); pindex++) {
for (PlaceholderEntry* probe = bucket(pindex);
probe != NULL;
probe = probe->next()) {
if (Verbose) tty->print("%4d: ", pindex);
tty->print(" place holder ");
probe->print();
tty->cr();
}
}
}
void PlaceholderTable::verify() {
int element_count = 0;
for (int pindex = 0; pindex < table_size(); pindex++) {
for (PlaceholderEntry* probe = bucket(pindex);
probe != NULL;
probe = probe->next()) {
probe->verify();
element_count++; // both klasses and place holders count
}
}
guarantee(number_of_entries() == element_count,
"Verify of system dictionary failed");
}
void Dictionary::methods_do(void f(Method*)) {
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
Klass* k = probe->klass();
if (probe->loader_data() == InstanceKlass::cast(k)->class_loader_data()) {
// only take klass is we have the entry with the defining class loader
InstanceKlass::cast(k)->methods_do(f);
}
}
}
}
void ProtectionDomainCacheTable::always_strong_oops_do(OopClosure* f) {
// the caller marked the protection domain cache entries that we need to apply
// the closure on. Only process them.
for (int index = 0; index < table_size(); index++) {
for (ProtectionDomainCacheEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
if (probe->is_strongly_reachable()) {
probe->reset_strongly_reachable();
probe->oops_do(f);
}
}
}
}
void Dictionary::always_strong_classes_do(KlassClosure* closure) {
// Follow all system classes and temporary placeholders in dictionary
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
Klass* e = probe->klass();
ClassLoaderData* loader_data = probe->loader_data();
if (is_strongly_reachable(loader_data, e)) {
closure->do_klass(e);
}
}
}
}
static void table_object(void* T)
{
fprintf(stdout,
"\t__table__ -> {\n"
"\t object=>0x%p,\n"
"\t size=>%d,\n"
"\t empty=>'%s',\n"
"\t begin=>0x%p,\n"
"\t end=>0x%p,\n"
"\t}\n",
T, table_size(T), (table_empty(T) ? "yes" : "no"),
table_begin(T), table_end(T)
);
}
/**
* Parse query string, if available. This method is invoked after the
* request line has been processed.
*
* @param connp
*/
int htp_ch_urlencoded_callback_request_line(htp_connp_t *connp) {
// Parse query string, when available
if ((connp->in_tx->parsed_uri->query != NULL) && (bstr_len(connp->in_tx->parsed_uri->query) > 0)) {
connp->in_tx->request_urlenp_query = htp_urlenp_create(connp->in_tx);
if (connp->in_tx->request_urlenp_query == NULL) {
return HOOK_ERROR;
}
htp_urlenp_parse_complete(connp->in_tx->request_urlenp_query,
(unsigned char *) bstr_ptr(connp->in_tx->parsed_uri->query),
bstr_len(connp->in_tx->parsed_uri->query));
// Is there a parameter processor?
if (connp->cfg->parameter_processor == NULL) {
// There's no parameter processor
if (connp->cfg->internal_encoding == NULL) {
// No transcoding; use the parser table directly
connp->in_tx->request_params_query = connp->in_tx->request_urlenp_query->params;
connp->in_tx->request_params_query_reused = 1;
} else {
// Transcode values
connp->in_tx->request_params_query = connp->in_tx->request_urlenp_query->params;
htp_transcode_params(connp, &connp->in_tx->request_params_query, 0);
}
} else {
// We have a parameter processor defined, which
// means we'll need to create a new table
connp->in_tx->request_params_query =
connp->cfg->create_table(table_size(connp->in_tx->request_urlenp_query->params));
// Use the parameter processor on each parameter, storing
// the results in the newly created table
bstr *name;
void *tvalue;
table_iterator_reset(connp->in_tx->request_urlenp_query->params);
while ((name = table_iterator_next(connp->in_tx->request_urlenp_query->params, & tvalue)) != NULL) {
connp->cfg->parameter_processor(connp->in_tx->request_params_query, name, (bstr *)tvalue);
// TODO Check return code
}
// Transcode as necessary
htp_transcode_params(connp, &connp->in_tx->request_params_query, 1);
}
}
return HOOK_OK;
}
void ProtectionDomainCacheTable::unlink(BoolObjectClosure* is_alive) {
assert(SafepointSynchronize::is_at_safepoint(), "must be");
for (int i = 0; i < table_size(); ++i) {
ProtectionDomainCacheEntry** p = bucket_addr(i);
ProtectionDomainCacheEntry* entry = bucket(i);
while (entry != NULL) {
if (is_alive->do_object_b(entry->literal())) {
p = entry->next_addr();
} else {
*p = entry->next();
free_entry(entry);
}
entry = *p;
}
}
}
void LoaderConstraintTable::oops_do(OopClosure* f) {
for (int index = 0; index < table_size(); index++) {
for (LoaderConstraintEntry* probe = bucket(index);
probe != NULL;
probe = probe->next()) {
f->do_oop((oop*)(probe->name_addr()));
if (probe->klass() != NULL) {
f->do_oop((oop*)probe->klass_addr());
}
for (int n = 0; n < probe->num_loaders(); n++) {
if (probe->loader(n) != NULL) {
f->do_oop(probe->loader_addr(n));
}
}
}
}
}