Merge git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus

* git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus: (25 commits)
  virtio: balloon driver
  virtio: Use PCI revision field to indicate virtio PCI ABI version
  virtio: PCI device
  virtio_blk: implement naming for vda-vdz,vdaa-vdzz,vdaaa-vdzzz
  virtio_blk: Dont waste major numbers
  virtio_blk: provide getgeo
  virtio_net: parametrize the napi_weight for virtio receive queue.
  virtio: free transmit skbs when notified, not on next xmit.
  virtio: flush buffers on open
  virtnet: remove double ether_setup
  virtio: Allow virtio to be modular and used by modules
  virtio: Use the sg_phys convenience function.
  virtio: Put the virtio under the virtualization menu
  virtio: handle interrupts after callbacks turned off
  virtio: reset function
  virtio: populate network rings in the probe routine, not open
  virtio: Tweak virtio_net defines
  virtio: Net header needs hdr_len
  virtio: remove unused id field from struct virtio_blk_outhdr
  virtio: clarify NO_NOTIFY flag usage
  ...

9 files changed, 180 insertions, 96 deletions

diff --git a/include/linux/lguest_launcher.h b/include/linux/lguest_launcher.h
index 697104da91f1..589be3e1f3ac 100644
--- a/include/linux/lguest_launcher.h
+++ b/include/linux/lguest_launcher.h
@@ -23,7 +23,12 @@
 struct lguest_device_desc {
         /* The device type: console, network, disk etc.  Type 0 terminates. */
         __u8 type;
-        /* The number of bytes of the config array. */
+        /* The number of virtqueues (first in config array) */
+        __u8 num_vq;
+        /* The number of bytes of feature bits.  Multiply by 2: one for host
+         * features and one for guest acknowledgements. */
+        __u8 feature_len;
+        /* The number of bytes of the config array after virtqueues. */
         __u8 config_len;
         /* A status byte, written by the Guest. */
         __u8 status;
@@ -31,7 +36,7 @@ struct lguest_device_desc {
 };
 
 /*D:135 This is how we expect the device configuration field for a virtqueue
- * (type VIRTIO_CONFIG_F_VIRTQUEUE) to be laid out: */
+ * to be laid out in config space. */
 struct lguest_vqconfig {
         /* The number of entries in the virtio_ring */
         __u16 num;
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index dfe975a9967e..412672a79e8a 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1810,5 +1810,6 @@ static inline void skb_forward_csum(struct sk_buff *skb)
                 skb->ip_summed = CHECKSUM_NONE;
 }
 
+bool skb_partial_csum_set(struct sk_buff *skb, u16 start, u16 off);
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_SKBUFF_H */
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 14e1379876d3..260d1fcf29a4 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -11,15 +11,13 @@
 /**
  * virtqueue - a queue to register buffers for sending or receiving.
  * @callback: the function to call when buffers are consumed (can be NULL).
- *    If this returns false, callbacks are suppressed until vq_ops->restart
- *    is called.
  * @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
 {
-        bool (*callback)(struct virtqueue *vq);
+        void (*callback)(struct virtqueue *vq);
         struct virtio_device *vdev;
         struct virtqueue_ops *vq_ops;
         void *priv;
@@ -41,13 +39,12 @@ struct virtqueue
  *      vq: the struct virtqueue we're talking about.
  *      len: the length written into the buffer
  *      Returns NULL or the "data" token handed to add_buf.
- * @restart: restart callbacks after callback returned false.
+ * @disable_cb: disable callbacks
+ *      vq: the struct virtqueue we're talking about.
+ * @enable_cb: restart callbacks after disable_cb.
  *      vq: the struct virtqueue we're talking about.
  *      This returns "false" (and doesn't re-enable) if there are pending
  *      buffers in the queue, to avoid a race.
- * @shutdown: "unadd" all buffers.
- *      vq: the struct virtqueue we're talking about.
- *      Remove everything from the queue.
  *
  * Locking rules are straightforward: the driver is responsible for
  * locking.  No two operations may be invoked simultaneously.
@@ -65,9 +62,8 @@ struct virtqueue_ops {
 
         void *(*get_buf)(struct virtqueue *vq, unsigned int *len);
 
-        bool (*restart)(struct virtqueue *vq);
-
-        void (*shutdown)(struct virtqueue *vq);
+        void (*disable_cb)(struct virtqueue *vq);
+        bool (*enable_cb)(struct virtqueue *vq);
 };
 
 /**
@@ -97,12 +93,15 @@ void unregister_virtio_device(struct virtio_device *dev);
  * @probe: the function to call when a device is found.  Returns a token for
  *    remove, or PTR_ERR().
  * @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.
  */
 struct virtio_driver {
         struct device_driver driver;
         const struct virtio_device_id *id_table;
         int (*probe)(struct virtio_device *dev);
         void (*remove)(struct virtio_device *dev);
+        void (*config_changed)(struct virtio_device *dev);
 };
 
 int register_virtio_driver(struct virtio_driver *drv);
diff --git a/include/linux/virtio_balloon.h b/include/linux/virtio_balloon.h
new file mode 100644
index 000000000000..979524ee75b7
--- /dev/null
+++ b/include/linux/virtio_balloon.h
@@ -0,0 +1,18 @@
+#ifndef _LINUX_VIRTIO_BALLOON_H
+#define _LINUX_VIRTIO_BALLOON_H
+#include <linux/virtio_config.h>
+
+/* The ID for virtio_balloon */
+#define VIRTIO_ID_BALLOON       5
+
+/* The feature bitmap for virtio balloon */
+#define VIRTIO_BALLOON_F_MUST_TELL_HOST 0 /* Tell before reclaiming pages */
+
+struct virtio_balloon_config
+{
+        /* Number of pages host wants Guest to give up. */
+        __le32 num_pages;
+        /* Number of pages we've actually got in balloon. */
+        __le32 actual;
+};
+#endif /* _LINUX_VIRTIO_BALLOON_H */
diff --git a/include/linux/virtio_blk.h b/include/linux/virtio_blk.h
index 7bd2bce0cfd9..bca0b10d7947 100644
--- a/include/linux/virtio_blk.h
+++ b/include/linux/virtio_blk.h
@@ -6,15 +6,19 @@
 #define VIRTIO_ID_BLOCK 2
 
 /* Feature bits */
-#define VIRTIO_CONFIG_BLK_F     0x40
-#define VIRTIO_BLK_F_BARRIER    1       /* Does host support barriers? */
+#define VIRTIO_BLK_F_BARRIER    0       /* Does host support barriers? */
+#define VIRTIO_BLK_F_SIZE_MAX   1       /* Indicates maximum segment size */
+#define VIRTIO_BLK_F_SEG_MAX    2       /* Indicates maximum # of segments */
 
-/* The capacity (in 512-byte sectors). */
-#define VIRTIO_CONFIG_BLK_F_CAPACITY    0x41
-/* The maximum segment size. */
-#define VIRTIO_CONFIG_BLK_F_SIZE_MAX    0x42
-/* The maximum number of segments. */
-#define VIRTIO_CONFIG_BLK_F_SEG_MAX     0x43
+struct virtio_blk_config
+{
+        /* The capacity (in 512-byte sectors). */
+        __le64 capacity;
+        /* The maximum segment size (if VIRTIO_BLK_F_SIZE_MAX) */
+        __le32 size_max;
+        /* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */
+        __le32 seg_max;
+} __attribute__((packed));
 
 /* These two define direction. */
 #define VIRTIO_BLK_T_IN         0
@@ -35,8 +39,6 @@ struct virtio_blk_outhdr
         __u32 ioprio;
         /* Sector (ie. 512 byte offset) */
         __u64 sector;
-        /* Where to put reply. */
-        __u64 id;
 };
 
 #define VIRTIO_BLK_S_OK         0
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index bcc01888df78..d581b2914b34 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -5,7 +5,7 @@
  * store and access that space differently. */
 #include <linux/types.h>
 
-/* Status byte for guest to report progress, and synchronize config. */
+/* Status byte for guest to report progress, and synchronize features. */
 /* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
 #define VIRTIO_CONFIG_S_ACKNOWLEDGE     1
 /* We have found a driver for the device. */
@@ -15,34 +15,27 @@
 /* We've given up on this device. */
 #define VIRTIO_CONFIG_S_FAILED          0x80
 
-/* Feature byte (actually 7 bits availabe): */
-/* Requirements/features of the virtio implementation. */
-#define VIRTIO_CONFIG_F_VIRTIO 1
-/* Requirements/features of the virtqueue (may have more than one). */
-#define VIRTIO_CONFIG_F_VIRTQUEUE 2
-
 #ifdef __KERNEL__
 struct virtio_device;
 
 /**
  * virtio_config_ops - operations for configuring a virtio device
- * @find: search for the next configuration field of the given type.
+ * @feature: search for a feature in this config
  *      vdev: the virtio_device
- *      type: the feature type
- *      len: the (returned) length of the field if found.
- *      Returns a token if found, or NULL.  Never returnes the same field twice
- *      (ie. it's used up).
- * @get: read the value of a configuration field after find().
+ *      bit: the feature bit
+ *      Returns true if the feature is supported.  Acknowledges the feature
+ *      so the host can see it.
+ * @get: read the value of a configuration field
  *      vdev: the virtio_device
- *      token: the token returned from find().
+ *      offset: the offset of the configuration field
  *      buf: the buffer to write the field value into.
- *      len: the length of the buffer (given by find()).
+ *      len: the length of the buffer
  *      Note that contents are conventionally little-endian.
- * @set: write the value of a configuration field after find().
+ * @set: write the value of a configuration field
  *      vdev: the virtio_device
- *      token: the token returned from find().
+ *      offset: the offset of the configuration field
  *      buf: the buffer to read the field value from.
- *      len: the length of the buffer (given by find()).
+ *      len: the length of the buffer
  *      Note that contents are conventionally little-endian.
  * @get_status: read the status byte
  *      vdev: the virtio_device
@@ -50,62 +43,67 @@ struct virtio_device;
  * @set_status: write the status byte
  *      vdev: the virtio_device
  *      status: the new status byte
- * @find_vq: find the first VIRTIO_CONFIG_F_VIRTQUEUE and create a virtqueue.
+ * @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.
  *      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().
+ *      Returns the new virtqueue or ERR_PTR() (eg. -ENOENT).
  * @del_vq: free a virtqueue found by find_vq().
  */
 struct virtio_config_ops
 {
-        void *(*find)(struct virtio_device *vdev, u8 type, unsigned *len);
-        void (*get)(struct virtio_device *vdev, void *token,
+        bool (*feature)(struct virtio_device *vdev, unsigned bit);
+        void (*get)(struct virtio_device *vdev, unsigned offset,
                     void *buf, unsigned len);
-        void (*set)(struct virtio_device *vdev, void *token,
+        void (*set)(struct virtio_device *vdev, unsigned offset,
                     const void *buf, unsigned len);
         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,
-                                     bool (*callback)(struct virtqueue *));
+                                     unsigned index,
+                                     void (*callback)(struct virtqueue *));
         void (*del_vq)(struct virtqueue *vq);
 };
 
 /**
- * virtio_config_val - get a single virtio config and mark it used.
- * @config: the virtio config space
- * @type: the type to search for.
+ * virtio_config_val - look for a feature and get a single virtio config.
+ * @vdev: the virtio device
+ * @fbit: the feature bit
+ * @offset: the type to search for.
  * @val: a pointer to the value to fill in.
  *
- * Once used, the config type is marked with VIRTIO_CONFIG_F_USED so it can't
- * be found again.  This version does endian conversion. */
-#define virtio_config_val(vdev, type, v) ({                             \
-        int _err = __virtio_config_val((vdev),(type),(v),sizeof(*(v))); \
-                                                                        \
-        BUILD_BUG_ON(sizeof(*(v)) != 1 && sizeof(*(v)) != 2             \
-                     && sizeof(*(v)) != 4 && sizeof(*(v)) != 8);        \
-        if (!_err) {                                                    \
-                switch (sizeof(*(v))) {                                 \
-                case 2: le16_to_cpus((__u16 *) v); break;               \
-                case 4: le32_to_cpus((__u32 *) v); break;               \
-                case 8: le64_to_cpus((__u64 *) v); break;               \
-                }                                                       \
-        }                                                               \
+ * The return value is -ENOENT if the feature doesn't exist.  Otherwise
+ * the value is endian-corrected and returned in v. */
+#define virtio_config_val(vdev, fbit, offset, v) ({                     \
+        int _err;                                                       \
+        if ((vdev)->config->feature((vdev), (fbit))) {                  \
+                __virtio_config_val((vdev), (offset), (v));             \
+                _err = 0;                                               \
+        } else                                                          \
+                _err = -ENOENT;                                         \
         _err;                                                           \
 })
 
-int __virtio_config_val(struct virtio_device *dev,
-                        u8 type, void *val, size_t size);
-
 /**
- * virtio_use_bit - helper to use a feature bit in a bitfield value.
- * @dev: the virtio device
- * @token: the token as returned from vdev->config->find().
- * @len: the length of the field.
- * @bitnum: the bit to test.
+ * __virtio_config_val - get a single virtio config without feature check.
+ * @vdev: the virtio device
+ * @offset: the type to search for.
+ * @val: a pointer to the value to fill in.
  *
- * If handed a NULL token, it returns false, otherwise returns bit status.
- * If it's one, it sets the mirroring acknowledgement bit. */
-int virtio_use_bit(struct virtio_device *vdev,
-                   void *token, unsigned int len, unsigned int bitnum);
+ * The value is endian-corrected and returned in v. */
+#define __virtio_config_val(vdev, offset, v) do {                       \
+        BUILD_BUG_ON(sizeof(*(v)) != 1 && sizeof(*(v)) != 2             \
+                     && sizeof(*(v)) != 4 && sizeof(*(v)) != 8);        \
+        (vdev)->config->get((vdev), (offset), (v), sizeof(*(v)));       \
+        switch (sizeof(*(v))) {                                         \
+        case 2: le16_to_cpus((__u16 *) v); break;                       \
+        case 4: le32_to_cpus((__u32 *) v); break;                       \
+        case 8: le64_to_cpus((__u64 *) v); break;                       \
+        }                                                               \
+} while(0)
 #endif /* __KERNEL__ */
 #endif /* _LINUX_VIRTIO_CONFIG_H */
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index ae469ae55d36..1ea3351df609 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -5,32 +5,32 @@
 /* The ID for virtio_net */
 #define VIRTIO_ID_NET   1
 
-/* The bitmap of config for virtio net */
-#define VIRTIO_CONFIG_NET_F     0x40
-#define VIRTIO_NET_F_NO_CSUM    0
-#define VIRTIO_NET_F_TSO4       1
-#define VIRTIO_NET_F_UFO        2
-#define VIRTIO_NET_F_TSO4_ECN   3
-#define VIRTIO_NET_F_TSO6       4
+/* The feature bitmap for virtio net */
+#define VIRTIO_NET_F_CSUM       0       /* Can handle pkts w/ partial csum */
+#define VIRTIO_NET_F_MAC        5       /* Host has given MAC address. */
+#define VIRTIO_NET_F_GSO        6       /* Can handle pkts w/ any GSO type */
 
-/* The config defining mac address. */
-#define VIRTIO_CONFIG_NET_MAC_F 0x41
+struct virtio_net_config
+{
+        /* The config defining mac address (if VIRTIO_NET_F_MAC) */
+        __u8 mac[6];
+} __attribute__((packed));
 
 /* This is the first element of the scatter-gather list.  If you don't
  * specify GSO or CSUM features, you can simply ignore the header. */
 struct virtio_net_hdr
 {
 #define VIRTIO_NET_HDR_F_NEEDS_CSUM     1       // Use csum_start, csum_offset
-      __u8 flags;
+        __u8 flags;
 #define VIRTIO_NET_HDR_GSO_NONE         0       // Not a GSO frame
 #define VIRTIO_NET_HDR_GSO_TCPV4        1       // GSO frame, IPv4 TCP (TSO)
-/* FIXME: Do we need this?  If they said they can handle ECN, do they care? */
-#define VIRTIO_NET_HDR_GSO_TCPV4_ECN    2       // GSO frame, IPv4 TCP w/ ECN
 #define VIRTIO_NET_HDR_GSO_UDP          3       // GSO frame, IPv4 UDP (UFO)
 #define VIRTIO_NET_HDR_GSO_TCPV6        4       // GSO frame, IPv6 TCP
-      __u8 gso_type;
-      __u16 gso_size;
-      __u16 csum_start;
-      __u16 csum_offset;
+#define VIRTIO_NET_HDR_GSO_ECN          0x80    // TCP has ECN set
+        __u8 gso_type;
+        __u16 hdr_len;          /* Ethernet + IP + tcp/udp hdrs */
+        __u16 gso_size;         /* Bytes to append to gso_hdr_len per frame */
+        __u16 csum_start;       /* Position to start checksumming from */
+        __u16 csum_offset;      /* Offset after that to place checksum */
 };
 #endif /* _LINUX_VIRTIO_NET_H */
diff --git a/include/linux/virtio_pci.h b/include/linux/virtio_pci.h
new file mode 100644
index 000000000000..b3151659cf49
--- /dev/null
+++ b/include/linux/virtio_pci.h
@@ -0,0 +1,57 @@
+/*
+ * Virtio PCI driver
+ *
+ * This module allows virtio devices to be used over a virtual PCI device.
+ * This can be used with QEMU based VMMs like KVM or Xen.
+ *
+ * Copyright IBM Corp. 2007
+ *
+ * Authors:
+ *  Anthony Liguori  <aliguori@us.ibm.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#ifndef _LINUX_VIRTIO_PCI_H
+#define _LINUX_VIRTIO_PCI_H
+
+#include <linux/virtio_config.h>
+
+/* A 32-bit r/o bitmask of the features supported by the host */
+#define VIRTIO_PCI_HOST_FEATURES        0
+
+/* A 32-bit r/w bitmask of features activated by the guest */
+#define VIRTIO_PCI_GUEST_FEATURES       4
+
+/* A 32-bit r/w PFN for the currently selected queue */
+#define VIRTIO_PCI_QUEUE_PFN            8
+
+/* A 16-bit r/o queue size for the currently selected queue */
+#define VIRTIO_PCI_QUEUE_NUM            12
+
+/* A 16-bit r/w queue selector */
+#define VIRTIO_PCI_QUEUE_SEL            14
+
+/* A 16-bit r/w queue notifier */
+#define VIRTIO_PCI_QUEUE_NOTIFY         16
+
+/* An 8-bit device status register.  */
+#define VIRTIO_PCI_STATUS               18
+
+/* An 8-bit r/o interrupt status register.  Reading the value will return the
+ * current contents of the ISR and will also clear it.  This is effectively
+ * a read-and-acknowledge. */
+#define VIRTIO_PCI_ISR                  19
+
+/* The bit of the ISR which indicates a device configuration change. */
+#define VIRTIO_PCI_ISR_CONFIG           0x2
+
+/* The remaining space is defined by each driver as the per-driver
+ * configuration space */
+#define VIRTIO_PCI_CONFIG               20
+
+/* Virtio ABI version, this must match exactly */
+#define VIRTIO_PCI_ABI_VERSION          0
+#endif
diff --git a/include/linux/virtio_ring.h b/include/linux/virtio_ring.h
index 1a4ed49f6478..abe481ed990e 100644
--- a/include/linux/virtio_ring.h
+++ b/include/linux/virtio_ring.h
@@ -15,9 +15,13 @@
 /* This marks a buffer as write-only (otherwise read-only). */
 #define VRING_DESC_F_WRITE      2
 
-/* This means don't notify other side when buffer added. */
+/* 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
+ * will still kick if it's out of buffers. */
 #define VRING_USED_F_NO_NOTIFY  1
-/* This means don't interrupt guest when buffer consumed. */
+/* The Guest uses this in avail->flags to advise the Host: don't interrupt me
+ * when you consume a buffer.  It's unreliable, so it's simply an
+ * optimization.  */
 #define VRING_AVAIL_F_NO_INTERRUPT      1
 
 /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
@@ -89,7 +93,7 @@ struct vring {
  * };
  */
 static inline void vring_init(struct vring *vr, unsigned int num, void *p,
-                              unsigned int pagesize)
+                              unsigned long pagesize)
 {
         vr->num = num;
         vr->desc = p;
@@ -98,7 +102,7 @@ static inline void vring_init(struct vring *vr, unsigned int num, void *p,
                             & ~(pagesize - 1));
 }
 
-static inline unsigned vring_size(unsigned int num, unsigned int pagesize)
+static inline unsigned vring_size(unsigned int num, unsigned long pagesize)
 {
         return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (2 + num)
                  + pagesize - 1) & ~(pagesize - 1))
@@ -114,7 +118,7 @@ struct virtqueue *vring_new_virtqueue(unsigned int num,
                                       struct virtio_device *vdev,
                                       void *pages,
                                       void (*notify)(struct virtqueue *vq),
-                                      bool (*callback)(struct virtqueue *vq));
+                                      void (*callback)(struct virtqueue *vq));
 void vring_del_virtqueue(struct virtqueue *vq);
 
 irqreturn_t vring_interrupt(int irq, void *_vq);