/* * Convert a dquot list to an ASCII file. */ int writeprivs(struct dquot *qlist, int outfd, char *name, int quotatype) { struct dquot *q; FILE *fd; ftruncate(outfd, 0); lseek(outfd, 0, SEEK_SET); if (!(fd = fdopen(dup(outfd), "w"))) die(1, _("Cannot duplicate descriptor of file to write to: %s\n"), strerror(errno)); fprintf(fd, _("Disk quotas for %s %s (%cid %d):\n"), _(type2name(quotatype)), name, *type2name(quotatype), qlist->dq_id); fprintf(fd, _(" Filesystem blocks soft hard inodes soft hard\n")); for (q = qlist; q; q = q->dq_next) { fprintf(fd, " %-24s %10llu %10llu %10llu %10llu %8llu %8llu\n", q->dq_h->qh_quotadev, (long long)toqb(q->dq_dqb.dqb_curspace), (long long)q->dq_dqb.dqb_bsoftlimit, (long long)q->dq_dqb.dqb_bhardlimit, (long long)q->dq_dqb.dqb_curinodes, (long long)q->dq_dqb.dqb_isoftlimit, (long long)q->dq_dqb.dqb_ihardlimit); } fclose(fd); return 0; }
static int syncquotas(int type) { struct quota_handle **handles, *h; int i, ret = 0; if (flags & FL_ALL) { if (sync_one(type, NULL) < 0) { errstr(_("%s quota sync failed: %s\n"), _(type2name(type)), strerror(errno)); ret = -1; } return ret; } handles = create_handle_list(mntcnt, mnt, type, fmt, IOI_READONLY, MS_LOCALONLY | MS_NO_AUTOFS); for (i = 0; handles[i]; i++) { h = handles[i]; if (sync_one(type, h->qh_quotadev)) { errstr(_("%s quota sync failed for %s: %s\n"), _(type2name(type)), h->qh_quotadev, strerror(errno)); ret = -1; } } dispose_handle_list(handles); return ret; }
static std::string type2name_symbol( const typet &type, const namespacet &ns, symbol_numbert &symbol_number) { const irep_idt &identifier=type.get(ID_identifier); const symbolt *symbol; if(ns.lookup(identifier, symbol)) return "SYM#"+id2string(identifier)+"#"; assert(symbol && symbol->is_type); if(symbol->type.id()!=ID_struct && symbol->type.id()!=ID_union) return type2name(symbol->type, ns, symbol_number); std::string result; // assign each symbol a number when seen for the first time std::pair<symbol_numbert::iterator, bool> entry= symbol_number.insert(std::make_pair( identifier, std::make_pair(symbol_number.size(), true))); // new entry, add definition if(entry.second) { result="SYM#"+std::to_string(entry.first->second.first); result+="={"; result+=type2name(symbol->type, ns, symbol_number); result+='}'; entry.first->second.second=false; } #if 0 // in recursion, print the shorthand only else if(entry.first->second.second) result="SYM#"+std::to_string(entry.first->second.first); // entering recursion else { entry.first->second.second=true; result=type2name(symbol->type, ns, symbol_number); entry.first->second.second=false; } #else // shorthand only as structs/unions are always symbols else
// Create a binary tree form for Packs. [lo, hi) (half-open) range PackNode* PackNode::binary_tree_pack(Compile* C, int lo, int hi) { int ct = hi - lo; assert(is_power_of_2(ct), "power of 2"); if (ct == 2) { PackNode* pk = PackNode::make(C, in(lo), 2, vect_type()->element_basic_type()); pk->add_opd(in(lo+1)); return pk; } else { int mid = lo + ct/2; PackNode* n1 = binary_tree_pack(C, lo, mid); PackNode* n2 = binary_tree_pack(C, mid, hi ); BasicType bt = n1->vect_type()->element_basic_type(); assert(bt == n2->vect_type()->element_basic_type(), "should be the same"); switch (bt) { case T_BOOLEAN: case T_BYTE: return new (C) PackSNode(n1, n2, TypeVect::make(T_SHORT, 2)); case T_CHAR: case T_SHORT: return new (C) PackINode(n1, n2, TypeVect::make(T_INT, 2)); case T_INT: return new (C) PackLNode(n1, n2, TypeVect::make(T_LONG, 2)); case T_LONG: return new (C) Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2)); case T_FLOAT: return new (C) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); case T_DOUBLE: return new (C) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); } fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); } return NULL; }
/* * Convert a dquot list to an ASCII file of grace times. */ int writetimes(struct quota_handle **handles, int outfd) { FILE *fd; char itimebuf[MAXTIMELEN], btimebuf[MAXTIMELEN]; int i; if (!handles[0]) return 0; ftruncate(outfd, 0); lseek(outfd, 0, SEEK_SET); if ((fd = fdopen(dup(outfd), "w")) == NULL) die(1, _("Cannot duplicate descriptor of file to edit: %s\n"), strerror(errno)); fprintf(fd, _("Grace period before enforcing soft limits for %ss:\n"), _(type2name(handles[0]->qh_type))); fprintf(fd, _("Time units may be: days, hours, minutes, or seconds\n")); fprintf(fd, _(" Filesystem Block grace period Inode grace period\n")); for (i = 0; handles[i]; i++) { time2str(handles[i]->qh_info.dqi_bgrace, btimebuf, 0); time2str(handles[i]->qh_info.dqi_igrace, itimebuf, 0); fprintf(fd, " %-12s %22s %22s\n", handles[i]->qh_quotadev, btimebuf, itimebuf); } fclose(fd); return 0; }
GenericPointerMessage(const std::string& frame_id = "/", Message::Stamp stamp = 0) : Message(type<GenericPointerMessage<Type>>::name(), frame_id, stamp) { static csapex::DirectMessageConstructorRegistered<connection_types::GenericPointerMessage, Type> reg_c; static csapex::DirectMessageSerializerRegistered<connection_types::GenericPointerMessage, Type> reg_s; setDescriptiveName(type2name(typeid(Type))); }
// ------------------------------------------------------------------ // ciInstance::field_value_impl ciConstant ciInstance::field_value_impl(BasicType field_btype, int offset) { Handle obj = get_oop(); assert(!obj.is_null(), "bad oop"); switch(field_btype) { case T_BYTE: return ciConstant(field_btype, obj->byte_field(offset)); case T_CHAR: return ciConstant(field_btype, obj->char_field(offset)); case T_SHORT: return ciConstant(field_btype, obj->short_field(offset)); case T_BOOLEAN: return ciConstant(field_btype, obj->bool_field(offset)); case T_INT: return ciConstant(field_btype, obj->int_field(offset)); case T_FLOAT: return ciConstant(obj->float_field(offset)); case T_DOUBLE: return ciConstant(obj->double_field(offset)); case T_LONG: return ciConstant(obj->long_field(offset)); case T_OBJECT: // fall through case T_ARRAY: { oop o = obj->obj_field(offset); // A field will be "constant" if it is known always to be // a non-null reference to an instance of a particular class, // or to a particular array. This can happen even if the instance // or array is not perm. In such a case, an "unloaded" ciArray // or ciInstance is created. The compiler may be able to use // information about the object's class (which is exact) or length. if (o == NULL) { return ciConstant(field_btype, ciNullObject::make()); } else { return ciConstant(field_btype, CURRENT_ENV->get_object(o)); } } } fatal("no field value: %s", type2name(field_btype)); return ciConstant(); }
/** * Print heap as array. */ void print_array_int_heap(heap_int_t* heap) { int i; printf("Heap: size=%d, allocated=%d, type=%s\n", heap->size, heap->nalloc, type2name(heap->type)); for (i=0; i<heap->size; i++) printf("%d ", heap->data[i]); printf("\nHeap end.\n"); }
// ------------------------------------------------------------------ // ciType::name // // Return the name of this type const char* ciType::name() { if (is_primitive_type()) { return type2name(basic_type()); } else { assert(is_klass(), "must be"); return as_klass()->name()->as_utf8(); } }
Result* get_handler(SEXP call, const ILazySubsets& subsets, const Environment& env) { LOG_INFO << "Looking up hybrid handler for call of type " << type2name(call); if (TYPEOF(call) == LANGSXP) { int depth = Rf_length(call); HybridHandlerMap& handlers = get_handlers(); SEXP fun_symbol = CAR(call); if (TYPEOF(fun_symbol) != SYMSXP) { LOG_VERBOSE << "Not a function: " << type2name(fun_symbol); return 0; } LOG_VERBOSE << "Searching hybrid handler for function " << CHAR(PRINTNAME(fun_symbol)); HybridHandlerMap::const_iterator it = handlers.find(fun_symbol); if (it == handlers.end()) { LOG_VERBOSE << "Not found"; return 0; } LOG_INFO << "Using hybrid handler for " << CHAR(PRINTNAME(fun_symbol)); return it->second(call, subsets, depth - 1); } else if (TYPEOF(call) == SYMSXP) { SymbolString name = SymbolString(Symbol(call)); LOG_VERBOSE << "Searching hybrid handler for symbol " << name.get_cstring(); if (subsets.count(name)) { LOG_VERBOSE << "Using hybrid variable handler"; return variable_handler(subsets, name); } else { SEXP data = env.find(name.get_string()); // Constants of length != 1 are handled via regular evaluation if (Rf_length(data) == 1) { LOG_VERBOSE << "Using hybrid constant handler"; return constant_handler(data); } } } else { // TODO: perhaps deal with SYMSXP separately if (Rf_length(call) == 1) return constant_handler(call); } return 0; }
void InstructionPrinter::do_TypeCast(TypeCast* x) { output()->print("type_cast("); print_value(x->obj()); output()->print(") "); if (x->declared_type()->is_klass()) print_klass(x->declared_type()->as_klass()); else output()->print(type2name(x->declared_type()->basic_type())); }
static void print_attr_detail(stat_attr_t *a, void *arg) { char *rx_u, *tx_u; int rxprec, txprec; double rx = cancel_down(attr_get_rx(a), a->a_unit, &rx_u, &rxprec); double tx = cancel_down(attr_get_tx(a), a->a_unit, &tx_u, &txprec); printf(" %-14s %12.*f %s %12.*f %s\n", type2name(a->a_type), rxprec, rx, rx_u, txprec, tx, tx_u); }
/* *!!! ENABLE *!! SYNTAX *! \tok{\sc ENAble} *! \begin{stack} \tok{ALL} \\ <rdev> \end{stack} *!! XATNYS *!! AUTH A *!! PURPOSE *! Enables a real device. */ static int cmd_enable(struct virt_sys *sys, char *cmd, int len) { u64 devnum; struct device *dev; struct console *con; SHELL_CMD_AUTH(sys, A); if (!strcasecmp(cmd, "ALL")) { con_printf(sys->con, "ENABLE ALL not yet implemented!\n"); return 0; } cmd = __extract_hex(cmd, &devnum); if (IS_ERR(cmd)) return PTR_ERR(cmd); /* device number must be 16-bit */ if (devnum & ~0xffffUL) return -EINVAL; dev = find_device_by_ccuu(devnum); if (IS_ERR(dev)) { con_printf(sys->con, "Device %04llX not found in configuration\n", devnum); return 0; } mutex_lock(&dev->lock); if (dev->in_use) { con_printf(sys->con, "Device %04llX is already in use\n", devnum); goto out_err; } if (!dev->dev->enable) { con_printf(sys->con, "Device type %-4s cannot be enabled\n", type2name(dev->type)); goto out_err; } con = dev->dev->enable(dev); if (IS_ERR(con)) { con_printf(sys->con, "Failed to enable %04llX: %s\n", devnum, errstrings[-PTR_ERR(con)]); goto out_err; } mutex_unlock(&dev->lock); return 0; out_err: mutex_unlock(&dev->lock); dev_put(dev); return 0; }
static int remove_quota_files_iterate(struct ocfs2_dir_entry *dirent, uint64_t blocknr, int offset, int blocksize, char *buf, void *priv_data) { struct remove_quota_files_ctxt *ctxt = priv_data; char dname[OCFS2_MAX_FILENAME_LEN]; char wname[OCFS2_MAX_FILENAME_LEN]; errcode_t ret; int tail, i; int ret_flags = 0; strncpy(dname, dirent->name, dirent->name_len); dname[dirent->name_len] = 0; /* Check whether entry is quota file of type we want - i.e. matching * aquota.user:[0-9][0-9][0-9][0-9] or aquota.user for type == USRQUOTA * and similarly for type == GRPQUOTA */ strcpy(wname, "aquota."); strcat(wname, type2name(ctxt->type)); tail = strlen(wname); if (strncmp(dname, wname, tail)) return 0; if (dname[tail] == ':') { /* May be local file? */ tail++; for (i = 0; i < 4; i++) if (dname[tail + i] < '0' || dname[tail + i] > '9') return 0; if (dname[tail + i]) return 0; } else if (dname[tail]) /* May be global file? */ return 0; verbosef(VL_APP, "Deleting quota file %s\n", dname); ret = ocfs2_truncate(ctxt->fs, dirent->inode, 0); if (ret) { tcom_err(ret, "while truncating quota file \"%s\"", dname); ret_flags |= OCFS2_DIRENT_ERROR; ctxt->err = ret; goto out; } ret = ocfs2_delete_inode(ctxt->fs, dirent->inode); if (ret) { tcom_err(ret, "while deleting quota file \"%s\"", dname); ret_flags |= OCFS2_DIRENT_ERROR; ctxt->err = ret; } else { dirent->inode = 0; ret_flags |= OCFS2_DIRENT_CHANGED; } out: return ret_flags; }
/* Get dquot from kernel */ int vfs_get_dquot(struct dquot *dquot) { struct if_dqblk kdqblk; if (quotactl(QCMD(Q_GETQUOTA, dquot->dq_h->qh_type), dquot->dq_h->qh_quotadev, dquot->dq_id, (void *)&kdqblk) < 0) { errstr(_("Cannot get quota for %s %d from kernel on %s: %s\n"), type2name(dquot->dq_h->qh_type), dquot->dq_id, dquot->dq_h->qh_quotadev, strerror(errno)); return -1; } generic_kern2utildqblk(&dquot->dq_dqb, &kdqblk); return 0; }
PyObject * CCNObject_Borrow(enum _pyccn_capsules type, void *pointer) { PyObject *r; assert(pointer); r = PyCapsule_New(pointer, type2name(type), NULL); assert(r); return r; }
void * CCNObject_Get(enum _pyccn_capsules type, PyObject *capsule) { void *p; assert(CCNObject_IsValid(type, capsule)); p = PyCapsule_GetPointer(capsule, type2name(type)); assert(p); return p; }
/* Get info from kernel to handle */ int vfs_get_info(struct quota_handle *h) { struct if_dqinfo kinfo; if (quotactl(QCMD(Q_GETINFO, h->qh_type), h->qh_quotadev, 0, (void *)&kinfo) < 0) { errstr(_("Cannot get info for %s quota file from kernel on %s: %s\n"), type2name(h->qh_type), h->qh_quotadev, strerror(errno)); return -1; } h->qh_info.dqi_bgrace = kinfo.dqi_bgrace; h->qh_info.dqi_igrace = kinfo.dqi_igrace; return 0; }
/* Set dquot in kernel */ int vfs_set_dquot(struct dquot *dquot, int flags) { struct if_dqblk kdqblk; generic_util2kerndqblk(&kdqblk, &dquot->dq_dqb); kdqblk.dqb_valid = flags; if (quotactl(QCMD(Q_SETQUOTA, dquot->dq_h->qh_type), dquot->dq_h->qh_quotadev, dquot->dq_id, (void *)&kdqblk) < 0) { errstr(_("Cannot set quota for %s %d from kernel on %s: %s\n"), type2name(dquot->dq_h->qh_type), dquot->dq_id, dquot->dq_h->qh_quotadev, strerror(errno)); return -1; } return 0; }
int CCNObject_ReqType(enum _pyccn_capsules type, PyObject *capsule) { int r; const char *t = type2name(type); r = PyCapsule_IsValid(capsule, t); if (!r) PyErr_Format(PyExc_TypeError, "Argument needs to be of %s type", t); return r; }
static void draw_attr_detail(intf_attr_t *attr, void *arg) { int *t = (int *) arg; if (0 == *t) { NEXT_ROW; putl(" %-12s%11llu %11llu", type2name(attr->a_type), attr->a_rx, attr->a_tx); if (!attr->a_rx_enabled) { move(row, 21); addstr("N/A"); } if (!attr->a_tx_enabled) { move(row, 33); addstr("N/A"); } move(row, 44); *t = 1; } else { putl("%-12s%11llu %11llu", type2name(attr->a_type), attr->a_rx, attr->a_tx); if (!attr->a_rx_enabled) { move(row, 64); addstr("N/A"); } if (!attr->a_tx_enabled) { move(row, 76); addstr("N/A"); } move(row, 0); *t = 0; } }
/* * Write grace times of user to file */ int writeindividualtimes(struct dquot *qlist, int outfd, char *name, int quotatype) { struct dquot *q; FILE *fd; time_t now; char btimestr[MAXTIMELEN], itimestr[MAXTIMELEN]; ftruncate(outfd, 0); lseek(outfd, 0, SEEK_SET); if (!(fd = fdopen(dup(outfd), "w"))) die(1, _("Cannot duplicate descriptor of file to write to: %s\n"), strerror(errno)); fprintf(fd, _("Times to enforce softlimit for %s %s (%cid %d):\n"), _(type2name(quotatype)), name, *type2name(quotatype), qlist->dq_id); fprintf(fd, _("Time units may be: days, hours, minutes, or seconds\n")); fprintf(fd, _(" Filesystem block grace inode grace\n")); time(&now); for (q = qlist; q; q = q->dq_next) { if (!q->dq_dqb.dqb_btime) strcpy(btimestr, _("unset")); else if (q->dq_dqb.dqb_btime <= now) strcpy(btimestr, _("0seconds")); else sprintf(btimestr, _("%useconds"), (unsigned)(q->dq_dqb.dqb_btime - now)); if (!q->dq_dqb.dqb_itime) strcpy(itimestr, _("unset")); else if (q->dq_dqb.dqb_itime <= now) strcpy(itimestr, _("0seconds")); else sprintf(itimestr, _("%useconds"), (unsigned)(q->dq_dqb.dqb_itime - now)); fprintf(fd, " %-24s %22s %22s\n", q->dq_h->qh_quotadev, btimestr, itimestr); } fclose(fd); return 0; }
/* Set info in kernel from handle */ int vfs_set_info(struct quota_handle *h, int flags) { struct if_dqinfo kinfo; kinfo.dqi_bgrace = h->qh_info.dqi_bgrace; kinfo.dqi_igrace = h->qh_info.dqi_igrace; kinfo.dqi_valid = flags; if (quotactl(QCMD(Q_SETINFO, h->qh_type), h->qh_quotadev, 0, (void *)&kinfo) < 0) { errstr(_("Cannot set info for %s quota file from kernel on %s: %s\n"), type2name(h->qh_type), h->qh_quotadev, strerror(errno)); return -1; } return 0; }
/** * Print heap on levels. */ void print_tree_int_heap(heap_int_t* heap) { int h, i, j; printf("Heap: size=%d, allocated=%d, type=%s\n", heap->size, heap->nalloc, type2name(heap->type)); i = 0; for (h=0; h<=mylog2(heap->size); h++) { for (j=0; j<(1<<h) && i<heap->size; j++, i++) printf("%d ", heap->data[i]); printf("\n"); } printf("Heap end.\n"); }
PyObject * CCNObject_New(enum _pyccn_capsules type, void *pointer) { PyObject *capsule; int r; assert(pointer); capsule = PyCapsule_New(pointer, type2name(type), pyccn_Capsule_Destructor); if (!capsule) return NULL; switch (type) { case CONTENT_OBJECT: { struct content_object_data *context; context = calloc(1, sizeof(*context)); JUMP_IF_NULL_MEM(context, error); r = PyCapsule_SetContext(capsule, context); if (r < 0) { free(context); goto error; } break; } case INTEREST: { struct interest_data *context; context = calloc(1, sizeof(*context)); JUMP_IF_NULL_MEM(context, error); r = PyCapsule_SetContext(capsule, context); if (r < 0) { free(context); goto error; } break; } default: break; } return capsule; error: Py_XDECREF(capsule); return NULL; }
// Return initial Pack node. Additional operands added with add_opd() calls. PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) { const TypeVect* vt = TypeVect::make(bt, vlen); switch (bt) { case T_BOOLEAN: case T_BYTE: return new (C) PackBNode(s, vt); case T_CHAR: case T_SHORT: return new (C) PackSNode(s, vt); case T_INT: return new (C) PackINode(s, vt); case T_LONG: return new (C) PackLNode(s, vt); case T_FLOAT: return new (C) PackFNode(s, vt); case T_DOUBLE: return new (C) PackDNode(s, vt); } fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); return NULL; }
// Scalar promotion VectorNode* VectorNode::scalar2vector(Compile* C, Node* s, uint vlen, const Type* opd_t) { BasicType bt = opd_t->array_element_basic_type(); const TypeVect* vt = opd_t->singleton() ? TypeVect::make(opd_t, vlen) : TypeVect::make(bt, vlen); switch (bt) { case T_BOOLEAN: case T_BYTE: return new (C) ReplicateBNode(s, vt); case T_CHAR: case T_SHORT: return new (C) ReplicateSNode(s, vt); case T_INT: return new (C) ReplicateINode(s, vt); case T_LONG: return new (C) ReplicateLNode(s, vt); case T_FLOAT: return new (C) ReplicateFNode(s, vt); case T_DOUBLE: return new (C) ReplicateDNode(s, vt); } fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); return NULL; }
// Extract a scalar element of vector. Node* ExtractNode::make(Compile* C, Node* v, uint position, BasicType bt) { assert((int)position < Matcher::max_vector_size(bt), "pos in range"); ConINode* pos = ConINode::make(C, (int)position); switch (bt) { case T_BOOLEAN: return new (C) ExtractUBNode(v, pos); case T_BYTE: return new (C) ExtractBNode(v, pos); case T_CHAR: return new (C) ExtractCNode(v, pos); case T_SHORT: return new (C) ExtractSNode(v, pos); case T_INT: return new (C) ExtractINode(v, pos); case T_LONG: return new (C) ExtractLNode(v, pos); case T_FLOAT: return new (C) ExtractFNode(v, pos); case T_DOUBLE: return new (C) ExtractDNode(v, pos); } fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); return NULL; }
void BytecodePrinter::print_attributes(int bci, outputStream* st) { // Show attributes of pre-rewritten codes Bytecodes::Code code = Bytecodes::java_code(raw_code()); // If the code doesn't have any fields there's nothing to print. // note this is ==1 because the tableswitch and lookupswitch are // zero size (for some reason) and we want to print stuff out for them. if (Bytecodes::length_for(code) == 1) { st->cr(); return; } switch(code) { // Java specific bytecodes only matter. case Bytecodes::_bipush: st->print_cr(" " INT32_FORMAT, get_byte()); break; case Bytecodes::_sipush: st->print_cr(" " INT32_FORMAT, get_short()); break; case Bytecodes::_ldc: if (Bytecodes::uses_cp_cache(raw_code())) { print_constant(get_index_u1_cpcache(), st); } else { print_constant(get_index_u1(), st); } break; case Bytecodes::_ldc_w: case Bytecodes::_ldc2_w: if (Bytecodes::uses_cp_cache(raw_code())) { print_constant(get_index_u2_cpcache(), st); } else { print_constant(get_index_u2(), st); } break; case Bytecodes::_iload: case Bytecodes::_lload: case Bytecodes::_fload: case Bytecodes::_dload: case Bytecodes::_aload: case Bytecodes::_istore: case Bytecodes::_lstore: case Bytecodes::_fstore: case Bytecodes::_dstore: case Bytecodes::_astore: st->print_cr(" #%d", get_index_special()); break; case Bytecodes::_iinc: { int index = get_index_special(); jint offset = is_wide() ? get_short(): get_byte(); st->print_cr(" #%d " INT32_FORMAT, index, offset); } break; case Bytecodes::_newarray: { BasicType atype = (BasicType)get_index_u1(); const char* str = type2name(atype); if (str == NULL || atype == T_OBJECT || atype == T_ARRAY) { assert(false, "Unidentified basic type"); } st->print_cr(" %s", str); } break; case Bytecodes::_anewarray: { int klass_index = get_index_u2(); ConstantPool* constants = method()->constants(); Symbol* name = constants->klass_name_at(klass_index); st->print_cr(" %s ", name->as_C_string()); } break; case Bytecodes::_multianewarray: { int klass_index = get_index_u2(); int nof_dims = get_index_u1(); ConstantPool* constants = method()->constants(); Symbol* name = constants->klass_name_at(klass_index); st->print_cr(" %s %d", name->as_C_string(), nof_dims); } break; case Bytecodes::_ifeq: case Bytecodes::_ifnull: case Bytecodes::_iflt: case Bytecodes::_ifle: case Bytecodes::_ifne: case Bytecodes::_ifnonnull: case Bytecodes::_ifgt: case Bytecodes::_ifge: case Bytecodes::_if_icmpeq: case Bytecodes::_if_icmpne: case Bytecodes::_if_icmplt: case Bytecodes::_if_icmpgt: case Bytecodes::_if_icmple: case Bytecodes::_if_icmpge: case Bytecodes::_if_acmpeq: case Bytecodes::_if_acmpne: case Bytecodes::_goto: case Bytecodes::_jsr: st->print_cr(" %d", bci + get_short()); break; case Bytecodes::_goto_w: case Bytecodes::_jsr_w: st->print_cr(" %d", bci + get_int()); break; case Bytecodes::_ret: st->print_cr(" %d", get_index_special()); break; case Bytecodes::_tableswitch: { align(); int default_dest = bci + get_int(); int lo = get_int(); int hi = get_int(); int len = hi - lo + 1; jint* dest = NEW_RESOURCE_ARRAY(jint, len); for (int i = 0; i < len; i++) { dest[i] = bci + get_int(); } st->print(" %d " INT32_FORMAT " " INT32_FORMAT " ", default_dest, lo, hi); int first = true; for (int ll = lo; ll <= hi; ll++, first = false) { int idx = ll - lo; const char *format = first ? " %d:" INT32_FORMAT " (delta: %d)" : ", %d:" INT32_FORMAT " (delta: %d)"; st->print(format, ll, dest[idx], dest[idx]-bci); } st->cr(); } break; case Bytecodes::_lookupswitch: { align(); int default_dest = bci + get_int(); int len = get_int(); jint* key = NEW_RESOURCE_ARRAY(jint, len); jint* dest = NEW_RESOURCE_ARRAY(jint, len); for (int i = 0; i < len; i++) { key [i] = get_int(); dest[i] = bci + get_int(); }; st->print(" %d %d ", default_dest, len); bool first = true; for (int ll = 0; ll < len; ll++, first = false) { const char *format = first ? " " INT32_FORMAT ":" INT32_FORMAT : ", " INT32_FORMAT ":" INT32_FORMAT ; st->print(format, key[ll], dest[ll]); } st->cr(); } break; case Bytecodes::_putstatic: case Bytecodes::_getstatic: case Bytecodes::_putfield: case Bytecodes::_getfield: print_field_or_method(get_index_u2_cpcache(), st); break; case Bytecodes::_invokevirtual: case Bytecodes::_invokespecial: case Bytecodes::_invokestatic: print_field_or_method(get_index_u2_cpcache(), st); break; case Bytecodes::_invokeinterface: { int i = get_index_u2_cpcache(); int n = get_index_u1(); get_byte(); // ignore zero byte print_field_or_method(i, st); } break; case Bytecodes::_invokedynamic: print_field_or_method(get_index_u4(), st); break; case Bytecodes::_new: case Bytecodes::_checkcast: case Bytecodes::_instanceof: { int i = get_index_u2(); ConstantPool* constants = method()->constants(); Symbol* name = constants->klass_name_at(i); st->print_cr(" %d <%s>", i, name->as_C_string()); } break; case Bytecodes::_wide: // length is zero not one, but printed with no more info. break; default: ShouldNotReachHere(); break; } }
static int update_sync_interval(ocfs2_filesys *fs, int type, unsigned long syncms) { errcode_t err; struct tools_progress *prog; int feature = (type == USRQUOTA) ? OCFS2_FEATURE_RO_COMPAT_USRQUOTA : OCFS2_FEATURE_RO_COMPAT_GRPQUOTA; struct ocfs2_global_disk_dqinfo *qinfo; if (!OCFS2_HAS_RO_COMPAT_FEATURE(OCFS2_RAW_SB(fs->fs_super), feature)) { errorf("The %s quota is not enabled on device \"%s\"\n", type2name(type), fs->fs_devname); return 1; } err = ocfs2_init_fs_quota_info(fs, type); if (err) { tcom_err(err, "while looking up %s quota file on device " "\"%s\"", type2name(type), fs->fs_devname); return 1; } err = ocfs2_read_global_quota_info(fs, type); if (err) { tcom_err(err, "while reading %s quota info on device \"%s\"", type2name(type), fs->fs_devname); return 1; } qinfo = &fs->qinfo[type].qi_info; if (qinfo->dqi_syncms == syncms) { verbosef(VL_APP, "Device \"%s\" already has interval %lu set; " "nothing to do\n", fs->fs_devname, syncms); return 0; } if (!tools_interact("Change quota syncing interval on device \"%s\" " "from %lu to %lu? ", fs->fs_devname, (unsigned long)qinfo->dqi_syncms, syncms)) return 0; prog = tools_progress_start("Setting syncing interval", "interval", 1); if (!prog) { tcom_err(err, "while initializing the progress display"); return 1; } tunefs_block_signals(); qinfo->dqi_syncms = syncms; err = ocfs2_write_global_quota_info(fs, type); tunefs_unblock_signals(); tools_progress_step(prog, 1); tools_progress_stop(prog); if (err) { tcom_err(err, "- unable to update %s quota syncing interval on " "device \"%s\"", type2name(type), fs->fs_devname); return 1; } return 0; }