14 files changed, 160 insertions, 56 deletions

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index ebdfde8fe556..0b1a6cae9de1 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1226,6 +1226,8 @@ struct block_device_operations {
         int (*direct_access) (struct block_device *, sector_t,
                                                 void **, unsigned long *);
         int (*media_changed) (struct gendisk *);
+        unsigned long long (*set_capacity) (struct gendisk *,
+                                                unsigned long long);
         int (*revalidate_disk) (struct gendisk *);
         int (*getgeo)(struct block_device *, struct hd_geometry *);
         struct module *owner;
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 37bcb50a4d7c..04fb5135b4e1 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -261,6 +261,11 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 # define __section(S) __attribute__ ((__section__(#S)))
 #endif
 
+/* Are two types/vars the same type (ignoring qualifiers)? */
+#ifndef __same_type
+# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
+#endif
+
 /*
  * Prevent the compiler from merging or refetching accesses.  The compiler
  * is also forbidden from reordering successive instances of ACCESS_ONCE(),
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index 162e5defe683..d41ed593f79f 100644
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -121,6 +121,13 @@ struct fuse_file_lock {
 #define FUSE_BIG_WRITES         (1 << 5)
 
 /**
+ * CUSE INIT request/reply flags
+ *
+ * CUSE_UNRESTRICTED_IOCTL:  use unrestricted ioctl
+ */
+#define CUSE_UNRESTRICTED_IOCTL (1 << 0)
+
+/**
  * Release flags
  */
 #define FUSE_RELEASE_FLUSH      (1 << 0)
@@ -210,6 +217,9 @@ enum fuse_opcode {
         FUSE_DESTROY       = 38,
         FUSE_IOCTL         = 39,
         FUSE_POLL          = 40,
+
+        /* CUSE specific operations */
+        CUSE_INIT          = 4096,
 };
 
 enum fuse_notify_code {
@@ -401,6 +411,27 @@ struct fuse_init_out {
         __u32   max_write;
 };
 
+#define CUSE_INIT_INFO_MAX 4096
+
+struct cuse_init_in {
+        __u32   major;
+        __u32   minor;
+        __u32   unused;
+        __u32   flags;
+};
+
+struct cuse_init_out {
+        __u32   major;
+        __u32   minor;
+        __u32   unused;
+        __u32   flags;
+        __u32   max_read;
+        __u32   max_write;
+        __u32   dev_major;              /* chardev major */
+        __u32   dev_minor;              /* chardev minor */
+        __u32   spare[10];
+};
+
 struct fuse_interrupt_in {
         __u64   unique;
 };
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 149fda264c86..7cbd38d363a2 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -114,6 +114,7 @@ struct hd_struct {
 #define GENHD_FL_UP                             16
 #define GENHD_FL_SUPPRESS_PARTITION_INFO        32
 #define GENHD_FL_EXT_DEVT                       64 /* allow extended devt */
+#define GENHD_FL_NATIVE_CAPACITY                128
 
 #define BLK_SCSI_MAX_CMDS       (256)
 #define BLK_SCSI_CMD_PER_LONG   (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 867cb68d8461..a6c6a2fad7c8 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -178,7 +178,7 @@ typedef u8 hwif_chipset_t;
 /*
  * Structure to hold all information about the location of this port
  */
-typedef struct hw_regs_s {
+struct ide_hw {
         union {
                 struct ide_io_ports     io_ports;
                 unsigned long           io_ports_array[IDE_NR_PORTS];
@@ -186,12 +186,11 @@ typedef struct hw_regs_s {
 
         int             irq;                    /* our irq number */
         ide_ack_intr_t  *ack_intr;              /* acknowledge interrupt */
-        hwif_chipset_t  chipset;
         struct device   *dev, *parent;
         unsigned long   config;
-} hw_regs_t;
+};
 
-static inline void ide_std_init_ports(hw_regs_t *hw,
+static inline void ide_std_init_ports(struct ide_hw *hw,
                                       unsigned long io_addr,
                                       unsigned long ctl_addr)
 {
@@ -218,21 +217,12 @@ static inline void ide_std_init_ports(hw_regs_t *hw,
 
 /*
  * Special Driver Flags
- *
- * set_geometry : respecify drive geometry
- * recalibrate  : seek to cyl 0
- * set_multmode : set multmode count
- * reserved     : unused
  */
-typedef union {
-        unsigned all                    : 8;
-        struct {
-                unsigned set_geometry   : 1;
-                unsigned recalibrate    : 1;
-                unsigned set_multmode   : 1;
-                unsigned reserved       : 5;
-        } b;
-} special_t;
+enum {
+        IDE_SFLAG_SET_GEOMETRY          = (1 << 0),
+        IDE_SFLAG_RECALIBRATE           = (1 << 1),
+        IDE_SFLAG_SET_MULTMODE          = (1 << 2),
+};
 
 /*
  * Status returned from various ide_ functions
@@ -391,6 +381,7 @@ struct ide_drive_s;
 struct ide_disk_ops {
         int             (*check)(struct ide_drive_s *, const char *);
         int             (*get_capacity)(struct ide_drive_s *);
+        u64             (*set_capacity)(struct ide_drive_s *, u64);
         void            (*setup)(struct ide_drive_s *);
         void            (*flush)(struct ide_drive_s *);
         int             (*init_media)(struct ide_drive_s *, struct gendisk *);
@@ -468,6 +459,8 @@ enum {
         IDE_DFLAG_NICE1                 = (1 << 5),
         /* device is physically present */
         IDE_DFLAG_PRESENT               = (1 << 6),
+        /* disable Host Protected Area */
+        IDE_DFLAG_NOHPA                 = (1 << 7),
         /* id read from device (synthetic if not set) */
         IDE_DFLAG_ID_READ               = (1 << 8),
         IDE_DFLAG_NOPROBE               = (1 << 9),
@@ -506,6 +499,7 @@ enum {
         /* write protect */
         IDE_DFLAG_WP                    = (1 << 29),
         IDE_DFLAG_FORMAT_IN_PROGRESS    = (1 << 30),
+        IDE_DFLAG_NIEN_QUIRK            = (1 << 31),
 };
 
 struct ide_drive_s {
@@ -530,14 +524,13 @@ struct ide_drive_s {
         unsigned long sleep;            /* sleep until this time */
         unsigned long timeout;          /* max time to wait for irq */
 
-        special_t       special;        /* special action flags */
+        u8      special_flags;          /* special action flags */
 
         u8      select;                 /* basic drive/head select reg value */
         u8      retry_pio;              /* retrying dma capable host in pio */
         u8      waiting_for_dma;        /* dma currently in progress */
         u8      dma;                    /* atapi dma flag */
 
-        u8      quirk_list;     /* considered quirky, set for a specific host */
         u8      init_speed;     /* transfer rate set at boot */
         u8      current_speed;  /* current transfer rate set */
         u8      desired_speed;  /* desired transfer rate set */
@@ -562,8 +555,7 @@ struct ide_drive_s {
         unsigned int    drive_data;     /* used by set_pio_mode/dev_select() */
         unsigned int    failures;       /* current failure count */
         unsigned int    max_failures;   /* maximum allowed failure count */
-        u64             probed_capacity;/* initial reported media capacity (ide-cd only currently) */
-
+        u64             probed_capacity;/* initial/native media capacity */
         u64             capacity64;     /* total number of sectors */
 
         int             lun;            /* logical unit */
@@ -1222,7 +1214,7 @@ static inline int ide_pci_is_in_compatibility_mode(struct pci_dev *dev)
 }
 
 void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *,
-                         hw_regs_t *, hw_regs_t **);
+                         struct ide_hw *, struct ide_hw **);
 void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *);
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
@@ -1461,16 +1453,18 @@ static inline void ide_acpi_set_state(ide_hwif_t *hwif, int on) {}
 void ide_register_region(struct gendisk *);
 void ide_unregister_region(struct gendisk *);
 
+void ide_check_nien_quirk_list(ide_drive_t *);
 void ide_undecoded_slave(ide_drive_t *);
 
 void ide_port_apply_params(ide_hwif_t *);
 int ide_sysfs_register_port(ide_hwif_t *);
 
-struct ide_host *ide_host_alloc(const struct ide_port_info *, hw_regs_t **);
+struct ide_host *ide_host_alloc(const struct ide_port_info *, struct ide_hw **,
+                                unsigned int);
 void ide_host_free(struct ide_host *);
 int ide_host_register(struct ide_host *, const struct ide_port_info *,
-                      hw_regs_t **);
-int ide_host_add(const struct ide_port_info *, hw_regs_t **,
+                      struct ide_hw **);
+int ide_host_add(const struct ide_port_info *, struct ide_hw **, unsigned int,
                  struct ide_host **);
 void ide_host_remove(struct ide_host *);
 int ide_legacy_device_add(const struct ide_port_info *, unsigned long);
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index cfe4fe1b7132..60e8934d10b5 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -79,6 +79,7 @@
 #define ETH_P_AOE       0x88A2          /* ATA over Ethernet            */
 #define ETH_P_TIPC      0x88CA          /* TIPC                         */
 #define ETH_P_FCOE      0x8906          /* Fibre Channel over Ethernet  */
+#define ETH_P_FIP       0x8914          /* FCoE Initialization Protocol */
 #define ETH_P_EDSA      0xDADA          /* Ethertype DSA [ NOT AN OFFICIALLY REGISTERED ID ] */
 
 /*
diff --git a/include/linux/lguest.h b/include/linux/lguest.h
index 175e63f4a8c0..7bc1440fc473 100644
--- a/include/linux/lguest.h
+++ b/include/linux/lguest.h
@@ -30,6 +30,10 @@ struct lguest_data
         /* Wallclock time set by the Host. */
         struct timespec time;
 
+        /* Interrupt pending set by the Host.  The Guest should do a hypercall
+         * if it re-enables interrupts and sees this set (to X86_EFLAGS_IF). */
+        int irq_pending;
+
         /* Async hypercall ring.  Instead of directly making hypercalls, we can
          * place them in here for processing the next time the Host wants.
          * This batching can be quite efficient. */
diff --git a/include/linux/lguest_launcher.h b/include/linux/lguest_launcher.h
index a53407a4165c..bfefbdf7498a 100644
--- a/include/linux/lguest_launcher.h
+++ b/include/linux/lguest_launcher.h
@@ -57,7 +57,8 @@ enum lguest_req
         LHREQ_INITIALIZE, /* + base, pfnlimit, start */
         LHREQ_GETDMA, /* No longer used */
         LHREQ_IRQ, /* + irq */
-        LHREQ_BREAK, /* + on/off flag (on blocks until someone does off) */
+        LHREQ_BREAK, /* No longer used */
+        LHREQ_EVENTFD, /* + address, fd. */
 };
 
 /* The alignment to use between consumer and producer parts of vring.
diff --git a/include/linux/module.h b/include/linux/module.h
index a8f2c0aa4c32..a7bc6e7b43a7 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -77,6 +77,7 @@ search_extable(const struct exception_table_entry *first,
 void sort_extable(struct exception_table_entry *start,
                   struct exception_table_entry *finish);
 void sort_main_extable(void);
+void trim_init_extable(struct module *m);
 
 #ifdef MODULE
 #define MODULE_GENERIC_TABLE(gtype,name)                        \
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index a4f0b931846c..6547c3cdbc4c 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -36,9 +36,14 @@ typedef int (*param_set_fn)(const char *val, struct kernel_param *kp);
 /* Returns length written or -errno.  Buffer is 4k (ie. be short!) */
 typedef int (*param_get_fn)(char *buffer, struct kernel_param *kp);
 
+/* Flag bits for kernel_param.flags */
+#define KPARAM_KMALLOCED        1
+#define KPARAM_ISBOOL           2
+
 struct kernel_param {
         const char *name;
-        unsigned int perm;
+        u16 perm;
+        u16 flags;
         param_set_fn set;
         param_get_fn get;
         union {
@@ -79,7 +84,7 @@ struct kparam_array
    parameters.  perm sets the visibility in sysfs: 000 means it's
    not there, read bits mean it's readable, write bits mean it's
    writable. */
-#define __module_param_call(prefix, name, set, get, arg, perm)          \
+#define __module_param_call(prefix, name, set, get, arg, isbool, perm)  \
         /* Default value instead of permissions? */                     \
         static int __param_perm_check_##name __attribute__((unused)) =  \
         BUILD_BUG_ON_ZERO((perm) < 0 || (perm) > 0777 || ((perm) & 2))  \
@@ -88,10 +93,13 @@ struct kparam_array
         static struct kernel_param __moduleparam_const __param_##name   \
         __used                                                          \
     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
-        = { __param_str_##name, perm, set, get, { arg } }
+        = { __param_str_##name, perm, isbool ? KPARAM_ISBOOL : 0,       \
+            set, get, { arg } }
 
 #define module_param_call(name, set, get, arg, perm)                          \
-        __module_param_call(MODULE_PARAM_PREFIX, name, set, get, arg, perm)
+        __module_param_call(MODULE_PARAM_PREFIX,                              \
+                            name, set, get, arg,                              \
+                            __same_type(*(arg), bool), perm)
 
 /* Helper functions: type is byte, short, ushort, int, uint, long,
    ulong, charp, bool or invbool, or XXX if you define param_get_XXX,
@@ -120,15 +128,16 @@ struct kparam_array
 #define core_param(name, var, type, perm)                               \
         param_check_##type(name, &(var));                               \
         __module_param_call("", name, param_set_##type, param_get_##type, \
-                            &var, perm)
+                            &var, __same_type(var, bool), perm)
 #endif /* !MODULE */
 
 /* Actually copy string: maxlen param is usually sizeof(string). */
 #define module_param_string(name, string, len, perm)                    \
         static const struct kparam_string __param_string_##name         \
                 = { len, string };                                      \
-        module_param_call(name, param_set_copystring, param_get_string, \
-                          .str = &__param_string_##name, perm);         \
+        __module_param_call(MODULE_PARAM_PREFIX, name,                  \
+                            param_set_copystring, param_get_string,     \
+                            .str = &__param_string_##name, 0, perm);    \
         __MODULE_PARM_TYPE(name, "string")
 
 /* Called on module insert or kernel boot */
@@ -186,21 +195,30 @@ extern int param_set_charp(const char *val, struct kernel_param *kp);
 extern int param_get_charp(char *buffer, struct kernel_param *kp);
 #define param_check_charp(name, p) __param_check(name, p, char *)
 
+/* For historical reasons "bool" parameters can be (unsigned) "int". */
 extern int param_set_bool(const char *val, struct kernel_param *kp);
 extern int param_get_bool(char *buffer, struct kernel_param *kp);
-#define param_check_bool(name, p) __param_check(name, p, int)
+#define param_check_bool(name, p)                                       \
+        static inline void __check_##name(void)                         \
+        {                                                               \
+                BUILD_BUG_ON(!__same_type(*(p), bool) &&                \
+                             !__same_type(*(p), unsigned int) &&        \
+                             !__same_type(*(p), int));                  \
+        }
 
 extern int param_set_invbool(const char *val, struct kernel_param *kp);
 extern int param_get_invbool(char *buffer, struct kernel_param *kp);
-#define param_check_invbool(name, p) __param_check(name, p, int)
+#define param_check_invbool(name, p) __param_check(name, p, bool)
 
 /* Comma-separated array: *nump is set to number they actually specified. */
 #define module_param_array_named(name, array, type, nump, perm)         \
         static const struct kparam_array __param_arr_##name             \
         = { ARRAY_SIZE(array), nump, param_set_##type, param_get_##type,\
             sizeof(array[0]), array };                                  \
-        module_param_call(name, param_array_set, param_array_get,       \
-                          .arr = &__param_arr_##name, perm);            \
+        __module_param_call(MODULE_PARAM_PREFIX, name,                  \
+                            param_array_set, param_array_get,           \
+                            .arr = &__param_arr_##name,                 \
+                            __same_type(array[0], bool), perm);         \
         __MODULE_PARM_TYPE(name, "array of " #type)
 
 #define module_param_array(name, type, nump, perm)              \
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 06005fa9e982..4fca4f5440ba 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -10,14 +10,17 @@
 
 /**
  * virtqueue - a queue to register buffers for sending or receiving.
+ * @list: the chain of virtqueues for this device
  * @callback: the function to call when buffers are consumed (can be NULL).
+ * @name: the name of this virtqueue (mainly for debugging)
  * @vdev: the virtio device this queue was created for.
  * @vq_ops: the operations for this virtqueue (see below).
  * @priv: a pointer for the virtqueue implementation to use.
  */
-struct virtqueue
-{
+struct virtqueue {
+        struct list_head list;
         void (*callback)(struct virtqueue *vq);
+        const char *name;
         struct virtio_device *vdev;
         struct virtqueue_ops *vq_ops;
         void *priv;
@@ -76,15 +79,16 @@ struct virtqueue_ops {
  * @dev: underlying device.
  * @id: the device type identification (used to match it with a driver).
  * @config: the configuration ops for this device.
+ * @vqs: the list of virtqueues for this device.
  * @features: the features supported by both driver and device.
  * @priv: private pointer for the driver's use.
  */
-struct virtio_device
-{
+struct virtio_device {
         int index;
         struct device dev;
         struct virtio_device_id id;
         struct virtio_config_ops *config;
+        struct list_head vqs;
         /* Note that this is a Linux set_bit-style bitmap. */
         unsigned long features[1];
         void *priv;
@@ -99,8 +103,7 @@ void unregister_virtio_device(struct virtio_device *dev);
  * @id_table: the ids serviced by this driver.
  * @feature_table: an array of feature numbers supported by this device.
  * @feature_table_size: number of entries in the feature table array.
- * @probe: the function to call when a device is found.  Returns a token for
- *    remove, or PTR_ERR().
+ * @probe: the function to call when a device is found.  Returns 0 or -errno.
  * @remove: the function when a device is removed.
  * @config_changed: optional function to call when the device configuration
  *    changes; may be called in interrupt context.
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index bf8ec283b232..99f514575f6a 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -29,6 +29,7 @@
 #define VIRTIO_F_NOTIFY_ON_EMPTY        24
 
 #ifdef __KERNEL__
+#include <linux/err.h>
 #include <linux/virtio.h>
 
 /**
@@ -49,15 +50,26 @@
  * @set_status: write the status byte
  *      vdev: the virtio_device
  *      status: the new status byte
+ * @request_vqs: request the specified number of virtqueues
+ *      vdev: the virtio_device
+ *      max_vqs: the max number of virtqueues we want
+ *      If supplied, must call before any virtqueues are instantiated.
+ *      To modify the max number of virtqueues after request_vqs has been
+ *      called, call free_vqs and then request_vqs with a new value.
+ * @free_vqs: cleanup resources allocated by request_vqs
+ *      vdev: the virtio_device
+ *      If supplied, must call after all virtqueues have been deleted.
  * @reset: reset the device
  *      vdev: the virtio device
  *      After this, status and feature negotiation must be done again
- * @find_vq: find a virtqueue and instantiate it.
+ * @find_vqs: find virtqueues and instantiate them.
  *      vdev: the virtio_device
- *      index: the 0-based virtqueue number in case there's more than one.
- *      callback: the virqtueue callback
- *      Returns the new virtqueue or ERR_PTR() (eg. -ENOENT).
- * @del_vq: free a virtqueue found by find_vq().
+ *      nvqs: the number of virtqueues to find
+ *      vqs: on success, includes new virtqueues
+ *      callbacks: array of callbacks, for each virtqueue
+ *      names: array of virtqueue names (mainly for debugging)
+ *      Returns 0 on success or error status
+ * @del_vqs: free virtqueues found by find_vqs().
  * @get_features: get the array of feature bits for this device.
  *      vdev: the virtio_device
  *      Returns the first 32 feature bits (all we currently need).
@@ -66,6 +78,7 @@
  *      This gives the final feature bits for the device: it can change
  *      the dev->feature bits if it wants.
  */
+typedef void vq_callback_t(struct virtqueue *);
 struct virtio_config_ops
 {
         void (*get)(struct virtio_device *vdev, unsigned offset,
@@ -75,10 +88,11 @@ struct virtio_config_ops
         u8 (*get_status)(struct virtio_device *vdev);
         void (*set_status)(struct virtio_device *vdev, u8 status);
         void (*reset)(struct virtio_device *vdev);
-        struct virtqueue *(*find_vq)(struct virtio_device *vdev,
-                                     unsigned index,
-                                     void (*callback)(struct virtqueue *));
-        void (*del_vq)(struct virtqueue *vq);
+        int (*find_vqs)(struct virtio_device *, unsigned nvqs,
+                        struct virtqueue *vqs[],
+                        vq_callback_t *callbacks[],
+                        const char *names[]);
+        void (*del_vqs)(struct virtio_device *);
         u32 (*get_features)(struct virtio_device *vdev);
         void (*finalize_features)(struct virtio_device *vdev);
 };
@@ -99,7 +113,9 @@ static inline bool virtio_has_feature(const struct virtio_device *vdev,
         if (__builtin_constant_p(fbit))
                 BUILD_BUG_ON(fbit >= 32);
 
-        virtio_check_driver_offered_feature(vdev, fbit);
+        if (fbit < VIRTIO_TRANSPORT_F_START)
+                virtio_check_driver_offered_feature(vdev, fbit);
+
         return test_bit(fbit, vdev->features);
 }
 
@@ -126,5 +142,18 @@ static inline int virtio_config_buf(struct virtio_device *vdev,
         vdev->config->get(vdev, offset, buf, len);
         return 0;
 }
+
+static inline
+struct virtqueue *virtio_find_single_vq(struct virtio_device *vdev,
+                                        vq_callback_t *c, const char *n)
+{
+        vq_callback_t *callbacks[] = { c };
+        const char *names[] = { n };
+        struct virtqueue *vq;
+        int err = vdev->config->find_vqs(vdev, 1, &vq, callbacks, names);
+        if (err < 0)
+                return ERR_PTR(err);
+        return vq;
+}
 #endif /* __KERNEL__ */
 #endif /* _LINUX_VIRTIO_CONFIG_H */
diff --git a/include/linux/virtio_pci.h b/include/linux/virtio_pci.h
index cd0fd5d181a6..9a3d7c48c622 100644
--- a/include/linux/virtio_pci.h
+++ b/include/linux/virtio_pci.h
@@ -47,9 +47,17 @@
 /* The bit of the ISR which indicates a device configuration change. */
 #define VIRTIO_PCI_ISR_CONFIG           0x2
 
+/* MSI-X registers: only enabled if MSI-X is enabled. */
+/* A 16-bit vector for configuration changes. */
+#define VIRTIO_MSI_CONFIG_VECTOR        20
+/* A 16-bit vector for selected queue notifications. */
+#define VIRTIO_MSI_QUEUE_VECTOR         22
+/* Vector value used to disable MSI for queue */
+#define VIRTIO_MSI_NO_VECTOR            0xffff
+
 /* The remaining space is defined by each driver as the per-driver
  * configuration space */
-#define VIRTIO_PCI_CONFIG               20
+#define VIRTIO_PCI_CONFIG(dev)          ((dev)->msix_enabled ? 24 : 20)
 
 /* Virtio ABI version, this must match exactly */
 #define VIRTIO_PCI_ABI_VERSION          0
diff --git a/include/linux/virtio_ring.h b/include/linux/virtio_ring.h
index 71e03722fb59..693e0ec5afa6 100644
--- a/include/linux/virtio_ring.h
+++ b/include/linux/virtio_ring.h
@@ -14,6 +14,8 @@
 #define VRING_DESC_F_NEXT       1
 /* This marks a buffer as write-only (otherwise read-only). */
 #define VRING_DESC_F_WRITE      2
+/* This means the buffer contains a list of buffer descriptors. */
+#define VRING_DESC_F_INDIRECT   4
 
 /* The Host uses this in used->flags to advise the Guest: don't kick me when
  * you add a buffer.  It's unreliable, so it's simply an optimization.  Guest
@@ -24,6 +26,9 @@
  * optimization.  */
 #define VRING_AVAIL_F_NO_INTERRUPT      1
 
+/* We support indirect buffer descriptors */
+#define VIRTIO_RING_F_INDIRECT_DESC     28
+
 /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
 struct vring_desc
 {
@@ -119,7 +124,8 @@ struct virtqueue *vring_new_virtqueue(unsigned int num,
                                       struct virtio_device *vdev,
                                       void *pages,
                                       void (*notify)(struct virtqueue *vq),
-                                      void (*callback)(struct virtqueue *vq));
+                                      void (*callback)(struct virtqueue *vq),
+                                      const char *name);
 void vring_del_virtqueue(struct virtqueue *vq);
 /* Filter out transport-specific feature bits. */
 void vring_transport_features(struct virtio_device *vdev);