mirror of
https://github.com/torvalds/linux.git
synced 2024-11-05 19:41:54 +00:00
33be96e47c
In the existing code, we only stop queue when the ringbuffer is full, so the current packet has to be dropped or retried from upper layer. This patch stops the tx queue when available ringbuffer is below the low watermark. So the ringbuffer still has small amount of space available for the current packet. This will reduce the overhead of retries on sending. Signed-off-by: Haiyang Zhang <haiyangz@microsoft.com> Reviewed-by: K. Y. Srinivasan <kys@microsoft.com> Signed-off-by: David S. Miller <davem@davemloft.net>
466 lines
10 KiB
C
466 lines
10 KiB
C
/*
|
|
*
|
|
* Copyright (c) 2009, Microsoft Corporation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|
* Place - Suite 330, Boston, MA 02111-1307 USA.
|
|
*
|
|
* Authors:
|
|
* Haiyang Zhang <haiyangz@microsoft.com>
|
|
* Hank Janssen <hjanssen@microsoft.com>
|
|
* K. Y. Srinivasan <kys@microsoft.com>
|
|
*
|
|
*/
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/hyperv.h>
|
|
|
|
#include "hyperv_vmbus.h"
|
|
|
|
|
|
/*
|
|
* hv_get_next_write_location()
|
|
*
|
|
* Get the next write location for the specified ring buffer
|
|
*
|
|
*/
|
|
static inline u32
|
|
hv_get_next_write_location(struct hv_ring_buffer_info *ring_info)
|
|
{
|
|
u32 next = ring_info->ring_buffer->write_index;
|
|
|
|
return next;
|
|
}
|
|
|
|
/*
|
|
* hv_set_next_write_location()
|
|
*
|
|
* Set the next write location for the specified ring buffer
|
|
*
|
|
*/
|
|
static inline void
|
|
hv_set_next_write_location(struct hv_ring_buffer_info *ring_info,
|
|
u32 next_write_location)
|
|
{
|
|
ring_info->ring_buffer->write_index = next_write_location;
|
|
}
|
|
|
|
/*
|
|
* hv_get_next_read_location()
|
|
*
|
|
* Get the next read location for the specified ring buffer
|
|
*/
|
|
static inline u32
|
|
hv_get_next_read_location(struct hv_ring_buffer_info *ring_info)
|
|
{
|
|
u32 next = ring_info->ring_buffer->read_index;
|
|
|
|
return next;
|
|
}
|
|
|
|
/*
|
|
* hv_get_next_readlocation_withoffset()
|
|
*
|
|
* Get the next read location + offset for the specified ring buffer.
|
|
* This allows the caller to skip
|
|
*/
|
|
static inline u32
|
|
hv_get_next_readlocation_withoffset(struct hv_ring_buffer_info *ring_info,
|
|
u32 offset)
|
|
{
|
|
u32 next = ring_info->ring_buffer->read_index;
|
|
|
|
next += offset;
|
|
next %= ring_info->ring_datasize;
|
|
|
|
return next;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* hv_set_next_read_location()
|
|
*
|
|
* Set the next read location for the specified ring buffer
|
|
*
|
|
*/
|
|
static inline void
|
|
hv_set_next_read_location(struct hv_ring_buffer_info *ring_info,
|
|
u32 next_read_location)
|
|
{
|
|
ring_info->ring_buffer->read_index = next_read_location;
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* hv_get_ring_buffer()
|
|
*
|
|
* Get the start of the ring buffer
|
|
*/
|
|
static inline void *
|
|
hv_get_ring_buffer(struct hv_ring_buffer_info *ring_info)
|
|
{
|
|
return (void *)ring_info->ring_buffer->buffer;
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* hv_get_ring_buffersize()
|
|
*
|
|
* Get the size of the ring buffer
|
|
*/
|
|
static inline u32
|
|
hv_get_ring_buffersize(struct hv_ring_buffer_info *ring_info)
|
|
{
|
|
return ring_info->ring_datasize;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* hv_get_ring_bufferindices()
|
|
*
|
|
* Get the read and write indices as u64 of the specified ring buffer
|
|
*
|
|
*/
|
|
static inline u64
|
|
hv_get_ring_bufferindices(struct hv_ring_buffer_info *ring_info)
|
|
{
|
|
return (u64)ring_info->ring_buffer->write_index << 32;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* hv_copyfrom_ringbuffer()
|
|
*
|
|
* Helper routine to copy to source from ring buffer.
|
|
* Assume there is enough room. Handles wrap-around in src case only!!
|
|
*
|
|
*/
|
|
static u32 hv_copyfrom_ringbuffer(
|
|
struct hv_ring_buffer_info *ring_info,
|
|
void *dest,
|
|
u32 destlen,
|
|
u32 start_read_offset)
|
|
{
|
|
void *ring_buffer = hv_get_ring_buffer(ring_info);
|
|
u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
|
|
|
|
u32 frag_len;
|
|
|
|
/* wrap-around detected at the src */
|
|
if (destlen > ring_buffer_size - start_read_offset) {
|
|
frag_len = ring_buffer_size - start_read_offset;
|
|
|
|
memcpy(dest, ring_buffer + start_read_offset, frag_len);
|
|
memcpy(dest + frag_len, ring_buffer, destlen - frag_len);
|
|
} else
|
|
|
|
memcpy(dest, ring_buffer + start_read_offset, destlen);
|
|
|
|
|
|
start_read_offset += destlen;
|
|
start_read_offset %= ring_buffer_size;
|
|
|
|
return start_read_offset;
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* hv_copyto_ringbuffer()
|
|
*
|
|
* Helper routine to copy from source to ring buffer.
|
|
* Assume there is enough room. Handles wrap-around in dest case only!!
|
|
*
|
|
*/
|
|
static u32 hv_copyto_ringbuffer(
|
|
struct hv_ring_buffer_info *ring_info,
|
|
u32 start_write_offset,
|
|
void *src,
|
|
u32 srclen)
|
|
{
|
|
void *ring_buffer = hv_get_ring_buffer(ring_info);
|
|
u32 ring_buffer_size = hv_get_ring_buffersize(ring_info);
|
|
u32 frag_len;
|
|
|
|
/* wrap-around detected! */
|
|
if (srclen > ring_buffer_size - start_write_offset) {
|
|
frag_len = ring_buffer_size - start_write_offset;
|
|
memcpy(ring_buffer + start_write_offset, src, frag_len);
|
|
memcpy(ring_buffer, src + frag_len, srclen - frag_len);
|
|
} else
|
|
memcpy(ring_buffer + start_write_offset, src, srclen);
|
|
|
|
start_write_offset += srclen;
|
|
start_write_offset %= ring_buffer_size;
|
|
|
|
return start_write_offset;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* hv_ringbuffer_get_debuginfo()
|
|
*
|
|
* Get various debug metrics for the specified ring buffer
|
|
*
|
|
*/
|
|
void hv_ringbuffer_get_debuginfo(struct hv_ring_buffer_info *ring_info,
|
|
struct hv_ring_buffer_debug_info *debug_info)
|
|
{
|
|
u32 bytes_avail_towrite;
|
|
u32 bytes_avail_toread;
|
|
|
|
if (ring_info->ring_buffer) {
|
|
hv_get_ringbuffer_availbytes(ring_info,
|
|
&bytes_avail_toread,
|
|
&bytes_avail_towrite);
|
|
|
|
debug_info->bytes_avail_toread = bytes_avail_toread;
|
|
debug_info->bytes_avail_towrite = bytes_avail_towrite;
|
|
debug_info->current_read_index =
|
|
ring_info->ring_buffer->read_index;
|
|
debug_info->current_write_index =
|
|
ring_info->ring_buffer->write_index;
|
|
debug_info->current_interrupt_mask =
|
|
ring_info->ring_buffer->interrupt_mask;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* hv_get_ringbuffer_interrupt_mask()
|
|
*
|
|
* Get the interrupt mask for the specified ring buffer
|
|
*
|
|
*/
|
|
u32 hv_get_ringbuffer_interrupt_mask(struct hv_ring_buffer_info *rbi)
|
|
{
|
|
return rbi->ring_buffer->interrupt_mask;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* hv_ringbuffer_init()
|
|
*
|
|
*Initialize the ring buffer
|
|
*
|
|
*/
|
|
int hv_ringbuffer_init(struct hv_ring_buffer_info *ring_info,
|
|
void *buffer, u32 buflen)
|
|
{
|
|
if (sizeof(struct hv_ring_buffer) != PAGE_SIZE)
|
|
return -EINVAL;
|
|
|
|
memset(ring_info, 0, sizeof(struct hv_ring_buffer_info));
|
|
|
|
ring_info->ring_buffer = (struct hv_ring_buffer *)buffer;
|
|
ring_info->ring_buffer->read_index =
|
|
ring_info->ring_buffer->write_index = 0;
|
|
|
|
ring_info->ring_size = buflen;
|
|
ring_info->ring_datasize = buflen - sizeof(struct hv_ring_buffer);
|
|
|
|
spin_lock_init(&ring_info->ring_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* hv_ringbuffer_cleanup()
|
|
*
|
|
* Cleanup the ring buffer
|
|
*
|
|
*/
|
|
void hv_ringbuffer_cleanup(struct hv_ring_buffer_info *ring_info)
|
|
{
|
|
}
|
|
|
|
/*
|
|
*
|
|
* hv_ringbuffer_write()
|
|
*
|
|
* Write to the ring buffer
|
|
*
|
|
*/
|
|
int hv_ringbuffer_write(struct hv_ring_buffer_info *outring_info,
|
|
struct scatterlist *sglist, u32 sgcount)
|
|
{
|
|
int i = 0;
|
|
u32 bytes_avail_towrite;
|
|
u32 bytes_avail_toread;
|
|
u32 totalbytes_towrite = 0;
|
|
|
|
struct scatterlist *sg;
|
|
u32 next_write_location;
|
|
u64 prev_indices = 0;
|
|
unsigned long flags;
|
|
|
|
for_each_sg(sglist, sg, sgcount, i)
|
|
{
|
|
totalbytes_towrite += sg->length;
|
|
}
|
|
|
|
totalbytes_towrite += sizeof(u64);
|
|
|
|
spin_lock_irqsave(&outring_info->ring_lock, flags);
|
|
|
|
hv_get_ringbuffer_availbytes(outring_info,
|
|
&bytes_avail_toread,
|
|
&bytes_avail_towrite);
|
|
|
|
|
|
/* If there is only room for the packet, assume it is full. */
|
|
/* Otherwise, the next time around, we think the ring buffer */
|
|
/* is empty since the read index == write index */
|
|
if (bytes_avail_towrite <= totalbytes_towrite) {
|
|
spin_unlock_irqrestore(&outring_info->ring_lock, flags);
|
|
return -EAGAIN;
|
|
}
|
|
|
|
/* Write to the ring buffer */
|
|
next_write_location = hv_get_next_write_location(outring_info);
|
|
|
|
for_each_sg(sglist, sg, sgcount, i)
|
|
{
|
|
next_write_location = hv_copyto_ringbuffer(outring_info,
|
|
next_write_location,
|
|
sg_virt(sg),
|
|
sg->length);
|
|
}
|
|
|
|
/* Set previous packet start */
|
|
prev_indices = hv_get_ring_bufferindices(outring_info);
|
|
|
|
next_write_location = hv_copyto_ringbuffer(outring_info,
|
|
next_write_location,
|
|
&prev_indices,
|
|
sizeof(u64));
|
|
|
|
/* Make sure we flush all writes before updating the writeIndex */
|
|
smp_wmb();
|
|
|
|
/* Now, update the write location */
|
|
hv_set_next_write_location(outring_info, next_write_location);
|
|
|
|
|
|
spin_unlock_irqrestore(&outring_info->ring_lock, flags);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* hv_ringbuffer_peek()
|
|
*
|
|
* Read without advancing the read index
|
|
*
|
|
*/
|
|
int hv_ringbuffer_peek(struct hv_ring_buffer_info *Inring_info,
|
|
void *Buffer, u32 buflen)
|
|
{
|
|
u32 bytes_avail_towrite;
|
|
u32 bytes_avail_toread;
|
|
u32 next_read_location = 0;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&Inring_info->ring_lock, flags);
|
|
|
|
hv_get_ringbuffer_availbytes(Inring_info,
|
|
&bytes_avail_toread,
|
|
&bytes_avail_towrite);
|
|
|
|
/* Make sure there is something to read */
|
|
if (bytes_avail_toread < buflen) {
|
|
|
|
spin_unlock_irqrestore(&Inring_info->ring_lock, flags);
|
|
|
|
return -EAGAIN;
|
|
}
|
|
|
|
/* Convert to byte offset */
|
|
next_read_location = hv_get_next_read_location(Inring_info);
|
|
|
|
next_read_location = hv_copyfrom_ringbuffer(Inring_info,
|
|
Buffer,
|
|
buflen,
|
|
next_read_location);
|
|
|
|
spin_unlock_irqrestore(&Inring_info->ring_lock, flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
*
|
|
* hv_ringbuffer_read()
|
|
*
|
|
* Read and advance the read index
|
|
*
|
|
*/
|
|
int hv_ringbuffer_read(struct hv_ring_buffer_info *inring_info, void *buffer,
|
|
u32 buflen, u32 offset)
|
|
{
|
|
u32 bytes_avail_towrite;
|
|
u32 bytes_avail_toread;
|
|
u32 next_read_location = 0;
|
|
u64 prev_indices = 0;
|
|
unsigned long flags;
|
|
|
|
if (buflen <= 0)
|
|
return -EINVAL;
|
|
|
|
spin_lock_irqsave(&inring_info->ring_lock, flags);
|
|
|
|
hv_get_ringbuffer_availbytes(inring_info,
|
|
&bytes_avail_toread,
|
|
&bytes_avail_towrite);
|
|
|
|
/* Make sure there is something to read */
|
|
if (bytes_avail_toread < buflen) {
|
|
spin_unlock_irqrestore(&inring_info->ring_lock, flags);
|
|
|
|
return -EAGAIN;
|
|
}
|
|
|
|
next_read_location =
|
|
hv_get_next_readlocation_withoffset(inring_info, offset);
|
|
|
|
next_read_location = hv_copyfrom_ringbuffer(inring_info,
|
|
buffer,
|
|
buflen,
|
|
next_read_location);
|
|
|
|
next_read_location = hv_copyfrom_ringbuffer(inring_info,
|
|
&prev_indices,
|
|
sizeof(u64),
|
|
next_read_location);
|
|
|
|
/* Make sure all reads are done before we update the read index since */
|
|
/* the writer may start writing to the read area once the read index */
|
|
/*is updated */
|
|
smp_mb();
|
|
|
|
/* Update the read index */
|
|
hv_set_next_read_location(inring_info, next_read_location);
|
|
|
|
spin_unlock_irqrestore(&inring_info->ring_lock, flags);
|
|
|
|
return 0;
|
|
}
|