Palacios Public Git Repository

To checkout Palacios execute

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.


bug fix to check for illegal memory ranges
[palacios.git] / palacios / src / palacios / vmm_ringbuffer.c
1 /*
2  * This file is part of the Palacios Virtual Machine Monitor developed
3  * by the V3VEE Project with funding from the United States National 
4  * Science Foundation and the Department of Energy.  
5  *
6  * The V3VEE Project is a joint project between Northwestern University
7  * and the University of New Mexico.  You can find out more at 
8  * http://www.v3vee.org
9  *
10  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu> 
11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org> 
12  * All rights reserved.
13  *
14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
15  *
16  * This is free software.  You are permitted to use,
17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
18  */
19
20 #include <palacios/vmm_ringbuffer.h>
21 #include <palacios/vmm.h>
22
23
24
25
26 void NO_INST v3_init_ringbuf(struct v3_ringbuf * ring, uint_t size) {
27     ring->buf = V3_Malloc(size);
28     ring->size = size;
29   
30     ring->start = 0;
31     ring->end = 0;
32     ring->current_len = 0;
33 }
34
35 NO_INST 
36 struct v3_ringbuf * v3_create_ringbuf(uint_t size) {
37     struct v3_ringbuf * ring = (struct v3_ringbuf *)V3_Malloc(sizeof(struct v3_ringbuf));
38
39     v3_init_ringbuf(ring, size);
40
41     return ring;
42 }
43
44 NO_INST 
45 void v3_free_ringbuf(struct v3_ringbuf * ring) {
46     V3_Free(ring->buf);
47     V3_Free(ring);
48 }
49
50
51 NO_INST 
52 static inline uchar_t * get_read_ptr(struct v3_ringbuf * ring) {
53     return (uchar_t *)(ring->buf + ring->start);
54 }
55
56 NO_INST 
57 static inline uchar_t * get_write_ptr(struct v3_ringbuf * ring) {
58     return (uchar_t *)(ring->buf + ring->end);
59 }
60
61 NO_INST 
62 static inline int get_read_section_size(struct v3_ringbuf * ring) {
63     return ring->size - ring->start;
64 }
65
66 NO_INST 
67 static inline int get_write_section_size(struct v3_ringbuf * ring) {
68     return ring->size - ring->end;
69 }
70
71 NO_INST 
72 static inline int is_read_loop(struct v3_ringbuf * ring, uint_t len) {
73     if ((ring->start >= ring->end) && (ring->current_len > 0)) {
74         // end is past the end of the buffer
75         if (get_read_section_size(ring) < len) {
76             return 1;
77         }
78     }
79     return 0;
80 }
81
82 NO_INST 
83 static inline int is_write_loop(struct v3_ringbuf * ring, uint_t len) {
84     if ((ring->end >= ring->start) && (ring->current_len < ring->size)) {
85         // end is past the end of the buffer
86         if (get_write_section_size(ring) < len) {
87             return 1;
88         }
89     }
90     return 0;
91 }
92
93 NO_INST 
94 int v3_ringbuf_avail_space(struct v3_ringbuf * ring) {
95     return ring->size - ring->current_len;
96 }
97
98 NO_INST 
99 int v3_ringbuf_data_len(struct v3_ringbuf * ring) {
100     return ring->current_len;
101 }
102
103 NO_INST 
104 int v3_ringbuf_capacity(struct v3_ringbuf * ring) {
105     return ring->size;
106 }
107
108 NO_INST 
109 int v3_ringbuf_read(struct v3_ringbuf * ring, uchar_t * dst, uint_t len) {
110     int read_len = 0;
111     int ring_data_len = ring->current_len;
112
113     read_len = (len > ring_data_len) ? ring_data_len : len;
114
115     if (is_read_loop(ring, read_len)) {
116         int section_len = get_read_section_size(ring);
117
118         memcpy(dst, get_read_ptr(ring), section_len);
119         memcpy(dst + section_len, ring->buf, read_len - section_len);
120     
121         ring->start = read_len - section_len;
122     } else {
123         memcpy(dst, get_read_ptr(ring), read_len);
124     
125         ring->start += read_len;
126     }
127
128     ring->current_len -= read_len;
129
130     return read_len;
131 }
132
133
134 NO_INST 
135 int v3_ringbuf_peek(struct v3_ringbuf * ring, uchar_t * dst, uint_t len) {
136     int read_len = 0;
137     int ring_data_len = ring->current_len;
138
139     read_len = (len > ring_data_len) ? ring_data_len : len;
140
141     if (is_read_loop(ring, read_len)) {
142         int section_len = get_read_section_size(ring);
143
144         memcpy(dst, get_read_ptr(ring), section_len);
145         memcpy(dst + section_len, ring->buf, read_len - section_len);
146     } else {
147         memcpy(dst, get_read_ptr(ring), read_len);
148     }
149
150     return read_len;
151 }
152
153
154 NO_INST 
155 int v3_ringbuf_delete(struct v3_ringbuf * ring, uint_t len) {
156     int del_len = 0;
157     int ring_data_len = ring->current_len;
158
159     del_len = (len > ring_data_len) ? ring_data_len : len;
160
161     if (is_read_loop(ring, del_len)) {
162         int section_len = get_read_section_size(ring);
163         ring->start = del_len - section_len;
164     } else {
165         ring->start += del_len;
166     }
167
168     ring->current_len -= del_len;
169     return del_len;
170 }
171
172
173 NO_INST 
174 int v3_ringbuf_write(struct v3_ringbuf * ring, uchar_t * src, uint_t len) {
175     int write_len = 0;
176     int ring_avail_space = ring->size - ring->current_len;
177   
178     write_len = (len > ring_avail_space) ? ring_avail_space : len;
179
180
181     if (is_write_loop(ring, write_len)) {
182         int section_len = get_write_section_size(ring);
183
184         //  PrintDebug("Write loop: write_ptr=%p, src=%p, sec_len=%d\n", 
185         //             (void *)get_write_ptr(ring),(void*)src, section_len);
186     
187         memcpy(get_write_ptr(ring), src, section_len);
188         ring->end = 0;
189
190         memcpy(get_write_ptr(ring), src + section_len, write_len - section_len);
191
192         ring->end += write_len - section_len;
193     } else {
194         //    PrintDebug("Writing: write_ptr=%p, src=%p, write_len=%d\n", 
195         //             (void *)get_write_ptr(ring),(void*)src, write_len);
196
197         memcpy(get_write_ptr(ring), src, write_len);
198
199         ring->end += write_len;
200     }
201
202     ring->current_len += write_len;
203
204     return write_len;
205 }
206
207
208 NO_INST 
209 void v3_print_ringbuf(struct v3_ringbuf * ring) {
210     int ctr = 0;
211   
212     for (ctr = 0; ctr < ring->current_len; ctr++) {
213         int index = (ctr + ring->start) % ring->size;
214
215         PrintDebug("Entry %d (index=%d): %c\n", ctr, index, ring->buf[index]);
216     }
217 }