예제 #1
0
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");
}
예제 #2
0
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");
}
예제 #3
0
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");
}
예제 #4
0
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;
}
예제 #5
0
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");
}
예제 #6
0
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;
}
예제 #7
0
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;
}
예제 #8
0
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);
}
예제 #9
0
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);
}
예제 #10
0
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;
}
예제 #11
0
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");
}
예제 #12
0
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');
}
예제 #13
0
파일: cmd_host.c 프로젝트: HeidCloud/xvisor
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);
}
예제 #14
0
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;
}
예제 #15
0
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;
}
예제 #16
0
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");
}
예제 #17
0
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);
}
예제 #18
0
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;
}
예제 #19
0
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;
}
예제 #20
0
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;
}
예제 #21
0
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;
}
예제 #22
0
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");
}
예제 #23
0
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");
}
예제 #24
0
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");
}
예제 #25
0
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;
}
예제 #26
0
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;
}
예제 #27
0
파일: cmd_i2c.c 프로젝트: 32bitmicro/xvisor
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;
}
예제 #28
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;
}
예제 #29
0
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;
}
예제 #30
0
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");
}