qemu block_resize(动态修改磁盘大小)实现简记

4110阅读　0评论2014-08-04　sak0
分类：虚拟化

host:
命令block_resize $block_id $size(单位MB)

virtio_blk_resize
    virtio_notify_config
        virtio_notify_vector
            virtio_pci_notify
                msix_notify
                    msg = msix_get_message(dev, vector);
                    stl_le_phys(msg.address, msg.data);
                        stl_phys_internal
                            io_mem_write(mr, addr1, val, 4);



guest:
设备初始化时注册中断，对应的处理方法是vp_config_changed
    err = request_irq(vp_dev->msix_entries[v].vector,
              vp_config_changed, 0, vp_dev->msix_names[v],
              vp_dev);


点击(此处)折叠或打开

  1. static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
  2.                    bool per_vq_vectors)
  3. {
  4.     struct virtio_pci_device *vp_dev = to_vp_device(vdev);
  5.     const char *name = dev_name(&vp_dev->vdev.dev);
  6.     unsigned i, v;
  7.     int err = -ENOMEM;

  9.     vp_dev->msix_entries = kmalloc(nvectors * sizeof *vp_dev->msix_entries,
  10.                        GFP_KERNEL);
  11.     if (!vp_dev->msix_entries)
  12.         goto error;
  13.     vp_dev->msix_names = kmalloc(nvectors * sizeof *vp_dev->msix_names,
  14.                      GFP_KERNEL);
  15.     if (!vp_dev->msix_names)
  16.         goto error;

  18.     for (i = 0; i < nvectors; ++i)
  19.         vp_dev->msix_entries[i].entry = i;

  21.     /* pci_enable_msix returns positive if we can't get this many. */
  22.     err = pci_enable_msix(vp_dev->pci_dev, vp_dev->msix_entries, nvectors);
  23.     if (err > 0)
  24.         err = -ENOSPC;
  25.     if (err)
  26.         goto error;
  27.     vp_dev->msix_vectors = nvectors;
  28.     vp_dev->msix_enabled = 1;

  30.     /* Set the vector used for configuration */
  31.     v = vp_dev->msix_used_vectors;
  32.     snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  33.          "%s-config", name);
  34.     err = request_irq(vp_dev->msix_entries[v].vector,
  35.               vp_config_changed, 0, vp_dev->msix_names[v],
  36.               vp_dev);
  37.     if (err)
  38.         goto error;
  39.     ++vp_dev->msix_used_vectors;

  41.     iowrite16(v, vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
  42.     /* Verify we had enough resources to assign the vector */
  43.     v = ioread16(vp_dev->ioaddr + VIRTIO_MSI_CONFIG_VECTOR);
  44.     if (v == VIRTIO_MSI_NO_VECTOR) {
  45.         err = -EBUSY;
  46.         goto error;
  47.     }

  49.     if (!per_vq_vectors) {
  50.         /* Shared vector for all VQs */
  51.         v = vp_dev->msix_used_vectors;
  52.         snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
  53.              "%s-virtqueues", name);
  54.         err = request_irq(vp_dev->msix_entries[v].vector,
  55.                   vp_vring_interrupt, 0, vp_dev->msix_names[v],
  56.                   vp_dev);
  57.         if (err)
  58.             goto error;
  59.         ++vp_dev->msix_used_vectors;
  60.     }
  61.     return 0;
  62. error:
  63.     vp_free_vectors(vdev);
  64.     return err;
  65. }

  67. 处理中断
  68. static irqreturn_t vp_config_changed(int irq, void *opaque)
  69. {
  70.     struct virtio_pci_device *vp_dev = opaque;
  71.     struct virtio_driver *drv;
  72.     drv = container_of(vp_dev->vdev.dev.driver,
  73.                struct virtio_driver, driver);

  75.     if (drv && drv->config_changed)
  76.         drv->config_changed(&vp_dev->vdev);
  77.     return IRQ_HANDLED;
  78. }

  80. static void virtblk_config_changed_work(struct work_struct *work)
  81. {
  82.     struct virtio_blk *vblk =
  83.         container_of(work, struct virtio_blk, config_work);
  84.     struct virtio_device *vdev = vblk->vdev;
  85.     struct request_queue *q = vblk->disk->queue;
  86.     char cap_str_2[10], cap_str_10[10];
  87.     u64 capacity, size;

  89.     mutex_lock(&vblk->config_lock);
  90.     if (!vblk->config_enable)
  91.         goto done;

  93.     /* Host must always specify the capacity. */
  94.     vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
  95.               &capacity, sizeof(capacity));//vm退出到host

  97.     /* If capacity is too big, truncate with warning. */
  98.     if ((sector_t)capacity != capacity) {
  99.         dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",
  100.              (unsigned long long)capacity);
  101.         capacity = (sector_t)-1;
  102.     }

  104.     size = capacity * queue_logical_block_size(q);
  105.     string_get_size(size, STRING_UNITS_2, cap_str_2, sizeof(cap_str_2));
  106.     string_get_size(size, STRING_UNITS_10, cap_str_10, sizeof(cap_str_10));

  108.     dev_notice(&vdev->dev,
  109.           "new size: %llu %d-byte logical blocks (%s/%s)\n",
  110.           (unsigned long long)capacity,
  111.           queue_logical_block_size(q),
  112.           cap_str_10, cap_str_2);

  114.     set_capacity(vblk->disk, capacity);
  115.     revalidate_disk(vblk->disk);
  116. done:
  117.     mutex_unlock(&vblk->config_lock);
  118. }

  120. host:
  121. uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr)
  122. {
  123.     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
  124.     uint8_t val;

  126.     if (addr + sizeof(val) > vdev->config_len) {
  127.         return (uint32_t)-1;
  128.     }

  130.     k->get_config(vdev, vdev->config);//对应到virtio_blk_update_config

  132.     val = ldub_p(vdev->config + addr);
  133.     return val;
  134. }

  136. static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
  137. {
  138.     VirtIOBlock *s = VIRTIO_BLK(vdev);
  139.     struct virtio_blk_config blkcfg;
  140.     uint64_t capacity;
  141.     int blk_size = s->conf->logical_block_size;

  143.     bdrv_get_geometry(s->bs, &capacity);
  144.     memset(&blkcfg, 0, sizeof(blkcfg));
  145.     stq_raw(&blkcfg.capacity, capacity);
  146.     stl_raw(&blkcfg.seg_max, 128 - 2);
  147.     stw_raw(&blkcfg.cylinders, s->conf->cyls);
  148.     stl_raw(&blkcfg.blk_size, blk_size);
  149.     stw_raw(&blkcfg.min_io_size, s->conf->min_io_size / blk_size);
  150.     stw_raw(&blkcfg.opt_io_size, s->conf->opt_io_size / blk_size);
  151.     blkcfg.heads = s->conf->heads;
  152.     /*
  153.      * We must ensure that the block device capacity is a multiple of
  154.      * the logical block size. If that is not the case, let's use
  155.      * sector_mask to adopt the geometry to have a correct picture.
  156.      * For those devices where the capacity is ok for the given geometry
  157.      * we don't touch the sector value of the geometry, since some devices
  158.      * (like s390 dasd) need a specific value. Here the capacity is already
  159.      * cyls*heads*secs*blk_size and the sector value is not block size
  160.      * divided by 512 - instead it is the amount of blk_size blocks
  161.      * per track (cylinder).
  162.      */
  163.     if (bdrv_getlength(s->bs) / s->conf->heads / s->conf->secs % blk_size) {
  164.         blkcfg.sectors = s->conf->secs & ~s->sector_mask;
  165.     } else {
  166.         blkcfg.sectors = s->conf->secs;
  167.     }
  168.     blkcfg.size_max = 0;
  169.     blkcfg.physical_block_exp = get_physical_block_exp(s->conf);
  170.     blkcfg.alignment_offset = 0;
  171.     blkcfg.wce = bdrv_enable_write_cache(s->bs);
  172.     memcpy(config, &blkcfg, sizeof(struct virtio_blk_config));
  173. }

上一篇：libvirt对监控虚机内存的改进
下一篇：对cinder volume live snapshot（在线快照）实现的一点疑问