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

static void cmd_host_bus_list(struct vmm_chardev *cdev){    u32 num, dcount, count = vmm_devdrv_bus_count();    struct vmm_bus *b;    vmm_cprintf(cdev, "----------------------------------------/n");    vmm_cprintf(cdev, " %-7s %-15s %-15s/n",                "Num#", "Bus Name", "Device Count");    vmm_cprintf(cdev, "----------------------------------------/n");    for (num = 0; num < count; num++) {        b = vmm_devdrv_bus(num);        dcount = vmm_devdrv_bus_device_count(b);        vmm_cprintf(cdev, " %-7d %-15s %-15d/n",                    num, b->name, dcount);    }    vmm_cprintf(cdev, "----------------------------------------/n");}

static void cmd_host_class_list(struct vmm_chardev *cdev){    u32 num, dcount, count = vmm_devdrv_class_count();    struct vmm_class *c;    vmm_cprintf(cdev, "----------------------------------------/n");    vmm_cprintf(cdev, " %-7s %-15s %-15s/n",                "Num#", "Class Name", "Device Count");    vmm_cprintf(cdev, "----------------------------------------/n");    for (num = 0; num < count; num++) {        c = vmm_devdrv_class(num);        dcount = vmm_devdrv_class_device_count(c);        vmm_cprintf(cdev, " %-7d %-15s %-15d/n",                    num, c->name, dcount);    }    vmm_cprintf(cdev, "----------------------------------------/n");}

static void cmd_wboxtest_test_list(struct vmm_chardev *cdev){	struct cmd_wboxtest_test_list_args args;	args.index = 0;	args.cdev = cdev;	vmm_cprintf(cdev, "----------------------------------------"		   	  "----------------------------------------/n");	vmm_cprintf(cdev, " %-7s %-35s %-35s/n",		   	  "#", "Group Name", "Test Name");	vmm_cprintf(cdev, "----------------------------------------"		   	  "----------------------------------------/n");	wboxtest_iterate(cmd_wboxtest_test_list_iter, &args);	vmm_cprintf(cdev, "----------------------------------------"			  "----------------------------------------/n");}

static int cmd_flash_list(struct vmm_chardev *cdev,			  int __unused argc,			  char __unused **argv){	unsigned int i = 0;	struct mtd_info *mtd = NULL;	mtd = mtd_get_device(i++);	if (!mtd)		vmm_cprintf(cdev, "No MTD device registered/n");	while (mtd) {		vmm_cprintf(cdev, "MTD %d: %s/n", i, mtd->name);		mtd = mtd_get_device(i++);	}	return VMM_OK;}

static void cmd_host_vapool_bitmap(struct vmm_chardev *cdev, int colcnt){    u32 ite, total = vmm_host_vapool_total_page_count();    virtual_addr_t base = vmm_host_vapool_base();    vmm_cprintf(cdev, "0 : free/n");    vmm_cprintf(cdev, "1 : used");    for (ite = 0; ite < total; ite++) {        if (umod32(ite, colcnt) == 0) {            if (sizeof(u64) == sizeof(virtual_addr_t)) {                vmm_cprintf(cdev, "/n0x%016llx: ",                            base + ite * VMM_PAGE_SIZE);            } else {                vmm_cprintf(cdev, "/n0x%08x: ",                            base + ite * VMM_PAGE_SIZE);            }        }        if (vmm_host_vapool_page_isfree(base + ite * VMM_PAGE_SIZE)) {            vmm_cprintf(cdev, "0");        } else {            vmm_cprintf(cdev, "1");        }    }    vmm_cprintf(cdev, "/n");}

int vmm_host_vapool_print_state(struct vmm_chardev *cdev){	unsigned long idx;	vmm_cprintf(cdev, "VAPOOL State/n");	for (idx = VAPOOL_MIN_BIN; idx <= VAPOOL_MAX_BIN; idx++) {		if (idx < 10) {			vmm_cprintf(cdev, "  [BLOCK %4dB]: ", 1<<idx);		} else if (idx < 20) {			vmm_cprintf(cdev, "  [BLOCK %4dK]: ", 1<<(idx-10));		} else {			vmm_cprintf(cdev, "  [BLOCK %4dM]: ", 1<<(idx-20));		}		vmm_cprintf(cdev, "%5d area(s), %5d free block(s)/n",			    buddy_bins_area_count(&vpctrl.ba, idx),			    buddy_bins_block_count(&vpctrl.ba, idx));	}	vmm_cprintf(cdev, "VAPOOL House-Keeping State/n");	vmm_cprintf(cdev, "  Buddy Areas: %d free out of %d/n",		    buddy_hk_area_free(&vpctrl.ba),		    buddy_hk_area_total(&vpctrl.ba));	return VMM_OK;}

static int heap_print_state(struct vmm_heap_control *heap,			    struct vmm_chardev *cdev, const char *name){	unsigned long idx;	vmm_cprintf(cdev, "%s Heap State/n", name);	for (idx = HEAP_MIN_BIN; idx <= HEAP_MAX_BIN; idx++) {		if (idx < 10) {			vmm_cprintf(cdev, "  [BLOCK %4dB]: ", 1<<idx);		} else if (idx < 20) {			vmm_cprintf(cdev, "  [BLOCK %4dK]: ", 1<<(idx-10));		} else {			vmm_cprintf(cdev, "  [BLOCK %4dM]: ", 1<<(idx-20));		}		vmm_cprintf(cdev, "%5d area(s), %5d free block(s)/n",			    buddy_bins_area_count(&heap->ba, idx),			    buddy_bins_block_count(&heap->ba, idx));	}	vmm_cprintf(cdev, "%s Heap House-Keeping State/n", name);	vmm_cprintf(cdev, "  Buddy Areas: %d free out of %d/n",		    buddy_hk_area_free(&heap->ba),		    buddy_hk_area_total(&heap->ba));	return VMM_OK;}

static int cmd_vfs_rm(struct vmm_chardev *cdev, const char *path){	int rc;	struct stat st;	rc = vfs_stat(path, &st);	if (rc) {		vmm_cprintf(cdev, "Path %s does not exist./n", path);		return rc;	}	if (!(st.st_mode & S_IFREG)) {		vmm_cprintf(cdev, "Path %s should be regular file./n", path);		return VMM_EINVALID;	}	return vfs_unlink(path);}

static int cmd_vfs_rmdir(struct vmm_chardev *cdev, const char *path){	int rc;	struct stat st;	rc = vfs_stat(path, &st);	if (rc) {		vmm_cprintf(cdev, "Path %s does not exist./n", path);		return rc;	}	if (!(st.st_mode & S_IFDIR)) {		vmm_cprintf(cdev, "Path %s should be directory./n", path);		return VMM_EINVALID;	}	return vfs_rmdir(path);}

static int cmd_vserial_recv_putchar(struct cmd_vserial_recvcntx *v, u8 ch){	switch (ch) {	case '/r':		vmm_cprintf(v->cdev, "/r[%s] ", v->name);		break;	case '/n':		vmm_cprintf(v->cdev, "/n[%s] ", v->name);		break;	default:		vmm_cputc(v->cdev, ch);		break;	};		return VMM_OK;}

static void cmd_flash_usage(struct vmm_chardev *cdev){	vmm_cprintf(cdev, "Usage:/n");	vmm_cprintf(cdev, "   flash read <ID> [offset] [length] - Read flash "		    "device 'ID' /n"		    "  from 'offset' (0 by default), up to 'length' bytes "		    "(a page size for NAND, a block size for NOR) by "		    "default)/n");	vmm_cprintf(cdev, "   flash erase <ID> [offset] [length] - Erase "		    "flash device 'ID' /n"		    "  from 'offset' (0 by default), up to 'length' bytes "		    "(the length should be block aligned)/n");	vmm_cprintf(cdev, "   flash write <ID> <offset> <bytes> ... - Write "		    "on flash device 'ID' /n"		    "  at 'offset' the given bytes given in hexadecimal format"		    "/n");	vmm_cprintf(cdev, "   flash list - List flash device with their ID/n");}

static int flash_question(struct vmm_chardev *cdev){	char ans = 0;	vmm_cprintf(cdev, "Continue [Y/n]?/n");	ans = vmm_cgetc(cdev, FALSE);	vmm_printf("/n");	return (ans == '/n') || (ans == 'y') || (ans == 'Y');}

static void cmd_host_cpu_info(struct vmm_chardev *cdev){	u32 c, khz;	char name[25];	vmm_cprintf(cdev, "%-25s: %s/n", "CPU Type", CONFIG_CPU);	vmm_cprintf(cdev, "%-25s: %d/n", "CPU Present Count", vmm_num_present_cpus());	vmm_cprintf(cdev, "%-25s: %d/n", "CPU Possible Count", vmm_num_possible_cpus());	vmm_cprintf(cdev, "%-25s: %u/n", "CPU Online Count", vmm_num_online_cpus());	for_each_online_cpu(c) {		khz = vmm_delay_estimate_cpu_khz(c);		vmm_sprintf(name, "CPU%d Speed", c);		vmm_cprintf(cdev, "%-25s: %d.%d MHz (Estimated)/n", name,			udiv32(khz, 1000), umod32(khz, 1000));	}	arch_cpu_print_info(cdev);}

static int cmd_flash_write(struct vmm_chardev *cdev,			   int  argc,			   char **argv){	int err = VMM_OK;	int idx = 0;	size_t retlen = 0;	flash_op op;	u_char *buf = NULL;	if (VMM_OK != (err = flash_args_common(cdev, argc, argv, &op))) {		return err;	}	vmm_cprintf(cdev, "Before writing, the %s block at 0x%08X must have "		    "been erased?/n", op.mtd->name,		    op.offset & ~op.mtd->erasesize_mask);	if (!flash_question(cdev)) {		vmm_cprintf(cdev, "Exiting.../n");		return VMM_OK;	}	if (argc - 4 <= 0) {		vmm_cprintf(cdev, "Nothing to write, exiting/n");		return VMM_OK;	}	if (NULL == (buf = vmm_malloc(argc - 5))) {		return VMM_ENOMEM;	}	for (idx = 0; idx < argc - 4; ++idx) {		buf[idx] = strtoull(argv[idx + 4], NULL, 16);		vmm_cprintf(cdev, "Writing at 0x%08X 0x%02X/n",			    op.offset + idx, buf[idx]);	}	if (0 != mtd_write(op.mtd, op.offset, argc - 4, &retlen, buf)) {		vmm_cprintf(cdev, "Failed to write %s at 0x%08X/n",			    op.mtd->name, op.offset);	}	vmm_free(buf);	return err;}

static int flash_erase(struct vmm_chardev *cdev,		       flash_op *op){	struct erase_info info;	if (op->len & op->mtd->erasesize_mask) {		vmm_cprintf(cdev, "Uncorrect length 0x%X, a block size is "			    "0x%08X/n", op->len, op->mtd->erasesize);		return VMM_EFAIL;	}	op->offset &= ~op->mtd->erasesize_mask;	while (op->len) {		if (mtd_block_isbad(op->mtd, op->offset)) {			vmm_cprintf(cdev, "%s block at 0x%08X is bad, "				    "skipping...", op->mtd->name, op->offset);			op->offset += op->mtd->erasesize;			op->len -= op->mtd->erasesize;			continue;		}		vmm_cprintf(cdev, "This will erasing the %s block at "			    "0x%08X/n", op->mtd->name, op->offset);		if (!flash_question(cdev)) {			vmm_cprintf(cdev, "Skipping.../n");			op->offset += op->mtd->erasesize;			op->len -= op->mtd->erasesize;			continue;		}		vmm_cprintf(cdev, "Erasing.../n");		memset(&info, 0, sizeof (struct erase_info));		info.mtd = op->mtd;		info.addr = op->offset;		info.len = op->len;		info.priv = (u_long)cdev;		info.callback = flash_erase_cb;		vmm_printf("Sizeof %zu, Addr 0x%p, cb 0x%p/n",			   sizeof (struct erase_info),			   &info, info.callback);		mtd_erase(op->mtd, &info);	}	return VMM_OK;}

static void cmd_host_cpu_stats(struct vmm_chardev *cdev){    u32 c, p, khz, util;    vmm_cprintf(cdev, "----------------------------------------"                "-------------------------/n");    vmm_cprintf(cdev, " %4s %15s %13s %12s %16s/n",                "CPU#", "Speed (MHz)", "Util. (%)",                "IRQs (%)", "Active VCPUs");    vmm_cprintf(cdev, "----------------------------------------"                "-------------------------/n");    for_each_online_cpu(c) {        vmm_cprintf(cdev, " %4d", c);        khz = vmm_delay_estimate_cpu_khz(c);        vmm_cprintf(cdev, " %11d.%03d",                    udiv32(khz, 1000), umod32(khz, 1000));        util = udiv64(vmm_scheduler_idle_time(c) * 1000,                      vmm_scheduler_get_sample_period(c));        util = (util > 1000) ? 1000 : util;        util = 1000 - util;        vmm_cprintf(cdev, " %11d.%01d",                    udiv32(util, 10), umod32(util, 10));        util = udiv64(vmm_scheduler_irq_time(c) * 1000,                      vmm_scheduler_get_sample_period(c));        util = (util > 1000) ? 1000 : util;        vmm_cprintf(cdev, " %10d.%01d",                    udiv32(util, 10), umod32(util, 10));        util = 1;        for (p = VMM_VCPU_MIN_PRIORITY; p <= VMM_VCPU_MAX_PRIORITY; p++) {            util += vmm_scheduler_ready_count(c, p);        }        vmm_cprintf(cdev, " %15d ", util);        vmm_cprintf(cdev, "/n");    }    vmm_cprintf(cdev, "----------------------------------------"                "-------------------------/n");}

void vmm_host_irqext_debug_dump(struct vmm_chardev *cdev){	int idx = 0;	irq_flags_t flags;	vmm_read_lock_irqsave_lite(&iectrl.lock, flags);	vmm_cprintf(cdev, "%d extended IRQs/n", iectrl.count);	vmm_cprintf(cdev, "  BITMAP:/n");	for (idx = 0; idx < BITS_TO_LONGS(iectrl.count); ++idx) {		if (0 == (idx % 4)) {			vmm_cprintf(cdev, "/n    %d:", idx);		}		vmm_cprintf(cdev, " 0x%x", iectrl.bitmap[idx]);	}	vmm_cprintf(cdev, "/n");	vmm_read_unlock_irqrestore_lite(&iectrl.lock, flags);}

static int cmd_host_bus_list_iter(struct vmm_bus *b, void *data){	u32 dcount;	struct cmd_host_list_iter *p = data;	dcount = vmm_devdrv_bus_device_count(b);	vmm_cprintf(p->cdev, " %-7d %-15s %-15d/n", p->num++, b->name, dcount);	return VMM_OK;}

int cmd_rtcdev_sync_device(struct vmm_chardev *cdev, const char * name){	int rc;	struct vmm_rtcdev * rtc = vmm_rtcdev_find(name);	if (!rtc) {		vmm_cprintf(cdev, "Error: cannot find rtc %s/n", name);		return VMM_EFAIL;	}	rc = vmm_rtcdev_sync_device(rtc);	if (rc) {		vmm_cprintf(cdev, "Error: sync_device failed for rtc %s/n", 									 name);		return rc;	}	return VMM_OK;}

static int cmd_blockdev_list_iter(struct vmm_blockdev *bdev, void *data){	struct vmm_chardev *cdev = data;	vmm_cprintf(cdev, " %-16s %-16s %-16ll %-11d %-16ll/n",		    bdev->name,  (bdev->parent) ? bdev->parent->name : "---",		    bdev->start_lba, bdev->block_size, bdev->num_blocks);	return VMM_OK;}

static int cmd_vfs_sha256(struct vmm_chardev *cdev, const char *path){	int fd, rc, i;	u32 len;	size_t buf_rd;	u8 buf[VFS_LOAD_BUF_SZ];	struct stat st;	struct sha256_context sha256c;	sha256_digest_t digest;	fd = vfs_open(path, O_RDONLY, 0);	if (fd < 0) {		vmm_cprintf(cdev, "Failed to open %s/n", path);		return fd;	}	rc = vfs_fstat(fd, &st);	if (rc) {		vfs_close(fd);		vmm_cprintf(cdev, "Failed to stat %s/n", path);		return rc;	}	if (!(st.st_mode & S_IFREG)) {		vfs_close(fd);		vmm_cprintf(cdev, "Cannot read %s/n", path);		return VMM_EINVALID;	}	len = st.st_size;	sha256_init(&sha256c);	while (len) {		memset(buf, 0, sizeof(buf));		buf_rd = (len < VFS_LOAD_BUF_SZ) ? len : VFS_LOAD_BUF_SZ;		buf_rd = vfs_read(fd, buf, buf_rd);		if (buf_rd < 1) {			break;		}		sha256_update(&sha256c, buf, buf_rd);	}	sha256_final(digest, &sha256c);	vmm_cprintf(cdev, "SHA-256 Digest: ");	for (i = 0; i < SHA256_DIGEST_LEN; i++)		vmm_cprintf(cdev, "%x", digest[i]);	vmm_cprintf(cdev, "/n");	rc = vfs_close(fd);	if (rc) {		vmm_cprintf(cdev, "Failed to close %s/n", path);		return rc;	}	return VMM_OK;}

void cmd_memory_usage(struct vmm_chardev *cdev){	vmm_cprintf(cdev, "Usage: ");	vmm_cprintf(cdev, "   memory help/n");	vmm_cprintf(cdev, "   memory dump8    <phys_addr> <count>/n");	vmm_cprintf(cdev, "   memory dump16   <phys_addr> <count>/n");	vmm_cprintf(cdev, "   memory dump32   <phys_addr> <count>/n");	vmm_cprintf(cdev, "   memory modify8  <phys_addr> "						"<val0> <val1> .../n");	vmm_cprintf(cdev, "   memory modify16 <phys_addr> "						"<val0> <val1> .../n");	vmm_cprintf(cdev, "   memory modify32 <phys_addr> "						"<val0> <val1> .../n");	vmm_cprintf(cdev, "   memory copy     <phys_addr> <src_phys_addr> "						"<byte_count>/n");}

static void cmd_vsdaemon_usage(struct vmm_chardev *cdev){    vmm_cprintf(cdev, "Usage:/n");    vmm_cprintf(cdev, "   vsdaemon help/n");    vmm_cprintf(cdev, "   vsdaemon transport_list/n");    vmm_cprintf(cdev, "   vsdaemon list/n");    vmm_cprintf(cdev, "   vsdaemon create <transport_name>"                " <vserial_name> <daemon_name> .../n");    vmm_cprintf(cdev, "      vsdaemon create mterm"                " <vserial_name> <daemon_name>/n");    vmm_cprintf(cdev, "      vsdaemon create chardev"                " <vserial_name> <daemon_name> <chardev_name>/n");    vmm_cprintf(cdev, "      vsdaemon create telnet"                " <vserial_name> <daemon_name> <port_number>/n");    vmm_cprintf(cdev, "   vsdaemon destroy <daemon_name>/n");}

static void cmd_thread_list(struct vmm_chardev *cdev){	int rc, index, count;	char state[10], name[VMM_FIELD_NAME_SIZE];	struct vmm_thread *tinfo;	vmm_cprintf(cdev, "----------------------------------------"		   	  "----------------------------------------/n");	vmm_cprintf(cdev, " %-6s %-7s %-10s %-53s/n", 		   	  "ID ", "Prio", "State", "Name");	vmm_cprintf(cdev, "----------------------------------------"		   	  "----------------------------------------/n");	count = vmm_threads_count();	for (index = 0; index < count; index++) {		tinfo = vmm_threads_index2thread(index);		switch (vmm_threads_get_state(tinfo)) {		case VMM_THREAD_STATE_CREATED:			strcpy(state, "Created");			break;		case VMM_THREAD_STATE_RUNNING:			strcpy(state, "Running");			break;		case VMM_THREAD_STATE_SLEEPING:			strcpy(state, "Sleeping");			break;		case VMM_THREAD_STATE_STOPPED:			strcpy(state, "Stopped");			break;		default:			strcpy(state, "Invalid");			break;		}		if ((rc = vmm_threads_get_name(name, tinfo))) {			strcpy(name, "(NA)");		}		vmm_cprintf(cdev, " %-6d %-7d %-10s %-53s/n", 				  vmm_threads_get_id(tinfo), 				  vmm_threads_get_priority(tinfo), 				  state, name);	}	vmm_cprintf(cdev, "----------------------------------------"			  "----------------------------------------/n");}

static int cmd_rtcdev_sync_wallclock(struct vmm_chardev *cdev,				     const char * name){	int rc;	struct rtc_device *rtc = rtc_device_find(name);	if (!rtc) {		vmm_cprintf(cdev, "Error: cannot find rtc %s/n", name);		return VMM_EFAIL;	}	rc = rtc_device_sync_wallclock(rtc);	if (rc) {		vmm_cprintf(cdev, "Error: sync_wallclock failed "				  "for rtc %s/n", name);		return rc;	}	return VMM_OK;}

static int cmd_vfs_fslist(struct vmm_chardev *cdev){	int num, count;	struct filesystem *fs;	vmm_cprintf(cdev, "----------------------------------------"			  "----------------------------------------/n");	vmm_cprintf(cdev, " %-9s %-69s/n", "Num", "Name");	vmm_cprintf(cdev, "----------------------------------------"			  "----------------------------------------/n");	count = vfs_filesystem_count();	for (num = 0; num < count; num++) {		fs = vfs_filesystem_get(num);		vmm_cprintf(cdev, " %-9d %-69s/n", num, fs->name);	}	vmm_cprintf(cdev, "----------------------------------------"			  "----------------------------------------/n");	return VMM_OK;}

static int i2c_print_dev(struct device *dev, void *data){	struct vmm_chardev *cdev = data;	struct i2c_adapter *adap = NULL;	if (NULL != (adap = i2c_verify_adapter(dev))) {		vmm_cprintf(cdev, " %2d %-16s %-16s", adap->nr, dev->name,			    "adapter");	} else {		vmm_cprintf(cdev, "    %-16s %-16s", dev->name, "client");	}	if (dev->parent) {		vmm_cprintf(cdev, " %-16s/n", dev->parent->name);	} else {		vmm_cprintf(cdev, " ----------------/n");	}	return 0;}

static int cmd_vfs_mv(struct vmm_chardev *cdev, 			const char *old_path, const char *new_path){	int rc;	struct stat st;	rc = vfs_stat(old_path, &st);	if (rc) {		vmm_cprintf(cdev, "Path %s does not exist./n", old_path);		return rc;	}	rc = vfs_rename(old_path, new_path);	if (rc) {		vmm_cprintf(cdev, "Failed to rename./n");		return rc;	}	return VMM_OK;}

static int cmd_vsdaemon_destroy(struct vmm_chardev *cdev,                                const char *name){    int ret = VMM_EFAIL;    if ((ret = vsdaemon_destroy(name))) {        vmm_cprintf(cdev, "Failed to destroy vsdaemon %s/n", name);    }    return ret;}

static void cmd_vsdaemon_transport_list(struct vmm_chardev *cdev){    int i, count;    struct vsdaemon_transport *trans;    vmm_cprintf(cdev, "------------------------------/n");    vmm_cprintf(cdev, " %-4s %-24s/n", "#", "Transport Name");    vmm_cprintf(cdev, "------------------------------/n");    count = vsdaemon_transport_count();    for (i = 0; i < count; i++) {        trans = vsdaemon_transport_get(i);        if (!trans) {            continue;        }        vmm_cprintf(cdev, " %-4d %-24s/n", i, trans->name);    }    vmm_cprintf(cdev, "------------------------------/n");}