自学教程：C++ INFO2函数代码示例

struct bendData *getBendData(int element_center,            enum hybridization centerHybridization,            int element1,            char bondOrder1,            int element2,            char bondOrder2){  struct bendData *bend;  char bendName[256]; // XXX Can overflow for long atom type names    generateBendName(bendName, element_center, centerHybridization, element1, bondOrder1, element2, bondOrder2);  bend = (struct bendData *)hashtable_get(bendDataHashtable, bendName);  if (bend == NULL) {    bend = generateGenericBendData(bendName, element_center, centerHybridization, element1, bondOrder1, element2, bondOrder2);  }  if (bend == NULL) {    return NULL;  }  if (bend->parameterQuality < QualityWarningLevel && !bend->warned) {    if (!ComputedParameterWarning) {      WARNING("Using a reduced quality parameter, see the trace output for details");      ComputedParameterWarning = 1;    }    INFO2("Using quality %d parameters for %s bend", bend->parameterQuality, bendName);    INFO2("Computed kb: %e, theta0: %e", bend->kb, bend->theta0);    bend->warned = 1;  }  return bend;}

  PCI_Device::PCI_Device(const uint16_t pci_addr, const uint32_t device_id)      : pci_addr_{pci_addr}, device_id_{device_id}  {    //We have device, so probe for details    devtype_.reg = read_dword(pci_addr, PCI::CONFIG_CLASS_REV);    //printf("/t[*] New PCI Device: Vendor: 0x%x Prod: 0x%x Class: 0x%x/n",     //device_id.vendor,device_id.product,classcode);        INFO2("|");          switch (devtype_.classcode) {    case PCI::BRIDGE:      INFO2("+--+ %s %s (0x%x)",            bridge_subclasses[devtype_.subclass < SS_BR ? devtype_.subclass : SS_BR-1],            classcodes[devtype_.classcode],devtype_.subclass);      break;    case PCI::NIC:      INFO2("+--+ %s %s (0x%x)",            nic_subclasses[devtype_.subclass < SS_NIC ? devtype_.subclass : SS_NIC-1],            classcodes[devtype_.classcode],devtype_.subclass);      break;    default:      if (devtype_.classcode < NUM_CLASSCODES) {        INFO2("+--+ %s ",classcodes[devtype_.classcode]);      } else {        INFO2("/t +--+ Other (Classcode 0x%x) /n",devtype_.classcode);      }     } //< switch (devtype_.classcode)  }

void PCI_manager::init(){  INFO("PCI Manager","Probing PCI bus");    /*      Probe the PCI bus     - Assuming bus number is 0, there are 255 possible addresses    */  uint32_t id = PCI::WTF;    for (uint16_t pci_addr = 0; pci_addr < 255; pci_addr++)    {      id = PCI_Device::read_dword(pci_addr, PCI::CONFIG_VENDOR);      if (id != PCI::WTF)	{	  	  PCI_Device dev (pci_addr,id);	  devices[dev.classcode()].emplace_back(dev);	}          }    // Pretty printing, end of device tree  // @todo should probably be moved, or optionally non-printed  INFO2("|");  INFO2("o");  }

int alert_push(int event, const char *msg){	/* 日志以及调试功能回调入口 */	switch(event){		case ERR_BASE:		case ERR_VERIFY:		case ERR_BRIDGE:		case ERR_PORT:		case ERR_CTRL_BRIDGE:		case ERR_CTRL_PORT:			ERROR2(GLOBAL_OUT_GROUP,"%s/n", msg);			break;		case ERR_MSTI:			ERROR2(MSTI_GROUP,"%s/n", msg);			break;		case ALERT_BASE:		case ALERT_BRIDGE:		case ALERT_PORT:			break;		case INFO_BRIDGE_TXBPDU:		case INFO_PORT_TXBPDU:			INFO2(BPDU_TX_GROUP,"%s/n", msg);			break;		case DEBUG_TXBPDU:			INFO3(BPDU_TX_GROUP,"%s/n", msg);			break;		case INFO_BRIDGE_RXBPDU:		case INFO_PORT_RXBPDU:			INFO2(BPDU_RX_GROUP,"%s/n", msg);			break;		case DEBUG_RXBPDU:			INFO3(BPDU_RX_GROUP,"%s/n", msg);			break;		case INFO_MSTI:			INFO2(MSTI_GROUP,"%s/n", msg);			break;		case INFO_BASE:		case INFO_BRIDGE:		case INFO_PORT:		case INFO_CTRL_BRIDGE:		case INFO_CTRL_PORT:		case INFO_CTRL_BRIDGE_MAC:			INFO2(GLOBAL_OUT_GROUP,"%s/n", msg);			break;		case DEBUG_INFO:			break;		case NOTIFY_MSG:			send_notify(event, msg);			break;		default:			break;	};	return 0;}

  void ACPI::walk_madt(const char* addr)  {    auto* hdr = (MADTHeader*) addr;    INFO("ACPI", "Reading APIC information");    // the base address for APIC registers    INFO2("LAPIC base: 0x%x  (flags: 0x%x)",        hdr->lapic_addr, hdr->flags);    this->apic_base = (uintptr_t) hdr->lapic_addr;    // the length remaining after MADT header    int len = hdr->hdr.Length - sizeof(MADTHeader);    // start walking    const char* ptr = (char*) hdr->record;    while (len) {      auto* rec = (MADTRecord*) ptr;      switch (rec->type) {      case 0:        {          auto& lapic = *(LAPIC*) rec;          lapics.push_back(lapic);          //INFO2("-> CPU %u ID %u  (flags=0x%x)",          //    lapic.cpu, lapic.id, lapic.flags);        }        break;      case 1:        {          auto& ioapic = *(IOAPIC*) rec;          ioapics.push_back(ioapic);          INFO2("I/O APIC %u   ADDR 0x%x  INTR 0x%x",              ioapic.id, ioapic.addr_base, ioapic.intr_base);        }        break;      case 2:        {          auto& redirect = *(override_t*) rec;          overrides.push_back(redirect);          INFO2("IRQ redirect for bus %u from IRQ %u to VEC %u",              redirect.bus_source, redirect.irq_source, redirect.global_intr);        }        break;      default:        debug("Unrecognized ACPI MADT type: %u/n", rec->type);      }      // decrease length as we go      len -= rec->length;      // go to next entry      ptr += rec->length;    }    INFO("SMP", "Found %u APs", (uint32_t) lapics.size());  }

NativeCodePtr compile_me(Method* method){    ASSERT_RAISE_AREA;    ASSERT_NO_INTERPRETER;    TRACE("compile_me " << method);    GcFrame gc;    compile_protect_arguments(method, &gc);    if (exn_raised()) {        return NULL;     }    tmn_suspend_enable();    if (method->is_abstract()) {         compile_raise_exception("java/lang/AbstractMethodError", "", method);         tmn_suspend_disable();         return NULL;     }    DebugUtilsTI *ti = VM_Global_State::loader_env->TI;    JIT_Result res = compile_do_compilation(method);    if (res != JIT_SUCCESS) {        INFO2("compile", "Cannot compile " << method);        if (!exn_raised()) {            compile_raise_exception("java/lang/InternalError", "Cannot compile ", method);        }        tmn_suspend_disable();        return NULL;    }    tmn_suspend_disable();    NativeCodePtr entry_point = method->get_code_addr();    INFO2("compile.code", "Compiled method " << method            << ", entry " << entry_point);    if (method->get_pending_breakpoints() != 0)        jvmti_set_pending_breakpoints(method);    if(ti->isEnabled() && ti->is_single_step_enabled()        && !method->is_native())    {        jvmti_thread_t jvmti_thread = jthread_self_jvmti();        assert(jvmti_thread);        jvmti_set_single_step_breakpoints_for_method(ti, jvmti_thread, method);    }    return entry_point;} // compile_me

static int command_move_clients (client_t *client, source_t *source, int response){    const char *dest_source;    xmlDocPtr doc;    xmlNodePtr node;    int parameters_passed = 0;    char buf[255];    if((COMMAND_OPTIONAL(client, "destination", dest_source))) {        parameters_passed = 1;    }    if (!parameters_passed) {        doc = admin_build_sourcelist(source->mount);        thread_mutex_unlock (&source->lock);        return admin_send_response(doc, client, response, "moveclients.xsl");    }    INFO2 ("source is /"%s/", destination is /"%s/"", source->mount, dest_source);    doc = xmlNewDoc(XMLSTR("1.0"));    node = xmlNewDocNode(doc, NULL, XMLSTR("iceresponse"), NULL);    xmlDocSetRootElement(doc, node);    source_set_fallback (source, dest_source);    source->termination_count = source->listeners;    source->flags |= SOURCE_LISTENERS_SYNC;    snprintf (buf, sizeof(buf), "Clients moved from %s to %s",            source->mount, dest_source);    thread_mutex_unlock (&source->lock);    xmlNewChild(node, NULL, XMLSTR("message"), XMLSTR(buf));    xmlNewChild(node, NULL, XMLSTR("return"), XMLSTR("1"));    return admin_send_response (doc, client, response, "response.xsl");}

void IRQ_manager::bsp_init(){  const auto WORDS_PER_BMP = IRQ_LINES / 32;  auto* bmp = new MemBitmap::word[WORDS_PER_BMP * 3]();  irq_subs.set_location(bmp + 0 * WORDS_PER_BMP, WORDS_PER_BMP);  irq_pend.set_location(bmp + 1 * WORDS_PER_BMP, WORDS_PER_BMP);  irq_todo.set_location(bmp + 2 * WORDS_PER_BMP, WORDS_PER_BMP);  //Create an idt entry for the 'lidt' instruction  idt_loc idt_reg;  idt_reg.limit = INTR_LINES * sizeof(IDTDescr) - 1;  idt_reg.base = (uint32_t)idt;  INFO("INTR", "Creating interrupt handlers");  for (size_t i = 0; i < 32; i++) {    create_gate(&idt[i],exception_handler,default_sel,default_attr);  }  // Set all interrupt-gates >= 32 to unused do-nothing handler  for (size_t i = 32; i < INTR_LINES; i++) {    create_gate(&idt[i],unused_interrupt_handler,default_sel,default_attr);  }  // spurious interrupts (should not happen)  // currently set to be the last interrupt vector  create_gate(&idt[INTR_LINES-1], spurious_intr, default_sel, default_attr);  INFO2("+ Default interrupt gates set for irq >= 32");  // Load IDT  asm volatile ("lidt %0": :"m"(idt_reg) );}

 uint16_t msix_t::setup_vector(uint8_t cpu, uint8_t intr) {   // find free table entry   uint16_t vec;   for (vec = 0; vec < this->vectors(); vec++)   {     // read data register     auto reg = get_entry(vec, ENT_MSG_DATA);     if ((mm_read(reg) & 0xff) == 0) break;   }   assert (vec != this->vectors());      // use free table entry   INFO2("MSI-X vector %u pointing to cpu %u intr %u",       vec, cpu, intr);      // mask entry   mask_entry(vec);      mm_write(get_entry(vec, ENT_MSG_ADDR), msix_addr_single_cpu(cpu));   mm_write(get_entry(vec, ENT_MSG_UPPER), 0x0);   mm_write(get_entry(vec, ENT_MSG_DATA), msix_data_single_vector(intr));      // unmask entry   unmask_entry(vec);   // return it   return vec; }

static void queue_auth_client (auth_client *auth_user, mount_proxy *mountinfo){    auth_t *auth;    if (auth_user == NULL)        return;    auth_user->next = NULL;    if (mountinfo)    {        auth = mountinfo->auth;        thread_mutex_lock (&auth->lock);        if (auth_user->client)            auth_user->client->auth = auth;        auth->refcount++;    }    else    {        if (auth_user->client == NULL || auth_user->client->auth == NULL)        {            WARN1 ("internal state is incorrect for %p", auth_user->client);            return;        }        auth = auth_user->client->auth;        thread_mutex_lock (&auth->lock);    }    DEBUG2 ("...refcount on auth_t %s is now %d", auth->mount, auth->refcount);    *auth->tailp = auth_user;    auth->tailp = &auth_user->next;    auth->pending_count++;    INFO2 ("auth on %s has %d pending", auth->mount, auth->pending_count);    thread_mutex_unlock (&auth->lock);}

struct bondStretch *getBondStretch(int element1, int element2, char bondOrder){  struct bondStretch *entry;  char bondName[256]; // XXX Can overflow for long atom type names  entry = getBondStretchEntry(element1, element2, bondOrder);  if (entry->parameterQuality < QualityWarningLevel && !entry->warned) {    if (!ComputedParameterWarning) {      WARNING("Using a reduced quality parameter, see the trace output for details");      ComputedParameterWarning = 1;    }    generateBondName(bondName, element1, element2, bondOrder);    INFO2("Using quality %d parameters for %s stretch", entry->parameterQuality, bondName);    INFO4("Computed ks: %e, r0: %e, de: %e, beta: %e",          entry->ks,          entry->r0,          entry->de,          entry->beta);    entry->warned = 1;  }  if (entry->maxPhysicalTableIndex == -1) {    // Only call initializeBondStretchInterpolater when we're actually    // going to use it.  That way, we don't warn about too large of an    // ExcessiveEnergyLevel    initializeBondStretchInterpolater(entry);  }  return entry;}

intmm_open(mm_file *mf, const char *fname){    assert(mf);    assert(fname);    INFO2("opening file `%s'", fname);    return mm_open_fp(mf, fopen(fname, "rb"));}

 inline static void disable_irq(const uint8_t irq) noexcept {   irq_mask_ |= (1 << irq);   if ((irq_mask_ & 0xFF00) == 0xFF00) {     irq_mask_ |= (1 << 2);   }   set_intr_mask(irq_mask_);   INFO2("- Disabling IRQ %i, mask: 0x%x", irq, irq_mask_); }

void PCI_manager::init() {  INFO("PCI Manager", "Probing PCI bus");  /*   * Probe the PCI bus   * - Assuming bus number is 0, there are 255 possible addresses   */  uint32_t id {PCI::WTF};  for (uint16_t pci_addr {0}; pci_addr < 255; ++pci_addr) {    id = hw::PCI_Device::read_dword(pci_addr, PCI::CONFIG_VENDOR);    if (id != PCI::WTF) {      hw::PCI_Device dev {pci_addr, id};      // store device      devices_[dev.classcode()].emplace_back(dev);      bool registered = false;      // translate classcode to device and register      switch(dev.classcode())      {        case PCI::STORAGE:          registered = register_device<hw::Drive>(dev);          break;        case PCI::NIC:          registered = register_device<hw::Nic>(dev);          break;        default:        {        }      }      debug("Device %s", registered ? "registed":"not registered");    }  }  // Pretty printing, end of device tree  // @todo should probably be moved, or optionally non-printed  INFO2("|");  INFO2("o");}

/* function to handle the re-populating of the avl tree containing IP addresses * for deciding whether a connection of an incoming request is to be dropped. */static void recheck_ip_file (cache_file_contents *cache){    time_t now = time(NULL);    if (now >= cache->file_recheck)    {        struct stat file_stat;        FILE *file = NULL;        int count = 0;        avl_tree *new_ips;        char line [MAX_LINE_LEN];        cache->file_recheck = now + 10;        if (cache->filename == NULL)        {            if (cache->contents)            {                avl_tree_free (cache->contents, free_filtered_ip);                cache->contents = NULL;            }            return;        }        if (stat (cache->filename, &file_stat) < 0)        {            WARN2 ("failed to check status of /"%s/": %s", cache->filename, strerror(errno));            return;        }        if (file_stat.st_mtime == cache->file_mtime)            return; /* common case, no update to file */        cache->file_mtime = file_stat.st_mtime;        file = fopen (cache->filename, "r");        if (file == NULL)        {            WARN2("Failed to open file /"%s/": %s", cache->filename, strerror (errno));            return;        }        new_ips = avl_tree_new (compare_ip, NULL);        while (get_line (file, line, MAX_LINE_LEN))        {            char *str;            if(!line[0] || line[0] == '#')                continue;            count++;            str = strdup (line);            if (str)                avl_insert (new_ips, str);        }        fclose (file);        INFO2 ("%d entries read from file /"%s/"", count, cache->filename);        if (cache->contents) avl_tree_free (cache->contents, free_filtered_ip);        cache->contents = new_ips;    }}

void elf_protect_symbol_areas(){  char* src = (char*) parser.symtab.base;  ptrdiff_t size = &parser.strtab.base[parser.strtab.size] - src;  if (size & 4095) size += 4096 - (size & 4095);  INFO2("* Protecting syms %p to %p (size %#zx)",        src, &parser.strtab.base[parser.strtab.size], size);  //os::mem::protect((uintptr_t) src, size, os::mem::Access::read);}

void OS::multiboot(uint32_t boot_magic, uint32_t boot_addr){  MYINFO("Booted with multiboot");  INFO2("* magic value: 0x%x Multiboot info at 0x%x", boot_magic, boot_addr);  multiboot_info_t* bootinfo = (multiboot_info_t*) boot_addr;  if (! bootinfo->flags & MULTIBOOT_INFO_MEMORY) {    INFO2("* No memory info provided in multiboot info");    return;  }  uint32_t mem_low_start = 0;  uint32_t mem_low_end = (bootinfo->mem_lower * 1024) - 1;  uint32_t mem_low_kb = bootinfo->mem_lower;  uint32_t mem_high_start = 0x100000;  uint32_t mem_high_end = mem_high_start + (bootinfo->mem_upper * 1024) - 1;  uint32_t mem_high_kb = bootinfo->mem_upper;  OS::low_memory_size_ = mem_low_kb * 1024;  OS::high_memory_size_ = mem_high_kb * 1024;  INFO2("* Valid memory (%i Kib):", mem_low_kb + mem_high_kb);  INFO2("/t 0x%08x - 0x%08x (%i Kib)",        mem_low_start, mem_low_end, mem_low_kb);  INFO2("/t 0x%08x - 0x%08x (%i Kib)",        mem_high_start, mem_high_end, mem_high_kb);  INFO2("");  if (bootinfo->flags & MULTIBOOT_INFO_CMDLINE) {    os_cmdline = (char*) bootinfo->cmdline;    INFO2("* Booted with parameters: %s", os_cmdline.c_str());  }  if (bootinfo->flags & MULTIBOOT_INFO_MEM_MAP) {    INFO2("* Multiboot provided memory map  (%i entries)",bootinfo->mmap_length / sizeof(multiboot_memory_map_t));    gsl::span<multiboot_memory_map_t> mmap { reinterpret_cast<multiboot_memory_map_t*>(bootinfo->mmap_addr),        (int)(bootinfo->mmap_length / sizeof(multiboot_memory_map_t))};    for (auto map : mmap) {      const char* str_type = map.type & MULTIBOOT_MEMORY_AVAILABLE ? "FREE" : "RESERVED";      INFO2("/t 0x%08llx - 0x%08llx %s (%llu Kb.)",            map.addr, map.addr + map.len - 1, str_type, map.len / 1024 );      /*if (map.addr + map.len > mem_high_end)        break;*/    }    printf("/n");  }}

/** Find and open file, if found return full path. * Caller is responsible for freeing the memory. */char*locate_file(const char *name, int type){	file f = try_find_file(name, "rb", type);	if (f.handle)	{		INFO2("found file `%s'", f.path);		fclose(f.handle);	}	return f.path;}

/* general send routine per listener.  The deletion_expected tells us whether * the last in the queue is about to disappear, so if this client is still * referring to it after writing then drop the client as it's fallen too far * behind  */ static void send_to_listener (source_t *source, client_t *client, int deletion_expected){    int bytes;    int loop = 10;   /* max number of iterations in one go */    int total_written = 0;    while (1)    {        /* check for limited listener time */        if (client->con->discon_time)            if (time(NULL) >= client->con->discon_time)            {                INFO1 ("time limit reached for client #%lu", client->con->id);                client->con->error = 1;            }        /* jump out if client connection has died */        if (client->con->error)            break;        /* lets not send too much to one client in one go, but don't           sleep for too long if more data can be sent */        if (total_written > 20000 || loop == 0)        {            if (client->check_buffer != format_check_file_buffer)                source->short_delay = 1;            break;        }        loop--;        if (client->check_buffer (source, client) < 0)            break;        bytes = client->write_to_client (client);        if (bytes <= 0)            break;  /* can't write any more */        total_written += bytes;    }    source->format->sent_bytes += total_written;    /* the refbuf referenced at head (last in queue) may be marked for deletion     * if so, check to see if this client is still referring to it */    if (deletion_expected && client->refbuf && client->refbuf == source->stream_data)    {        INFO2 ("Client %lu (%s) has fallen too far behind, removing",                client->con->id, client->con->ip);        stats_event_inc (source->mount, "slow_listeners");        client->con->error = 1;    }}