![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to block.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / xen|
Return to block.c CVS log | Up to [GnuMach] / Gnu-Mach / xen |
1.1 root 1: /*
2: * Copyright (C) 2006-2009, 2011 Free Software Foundation
3: *
4: * This program is free software ; you can redistribute it and/or modify
5: * it under the terms of the GNU General Public License as published by
6: * the Free Software Foundation ; either version 2 of the License, or
7: * (at your option) any later version.
8: *
9: * This program is distributed in the hope that it will be useful,
10: * but WITHOUT ANY WARRANTY ; without even the implied warranty of
11: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12: * GNU General Public License for more details.
13: *
14: * You should have received a copy of the GNU General Public License
15: * along with the program ; if not, write to the Free Software
16: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17: */
18:
19: #include <sys/types.h>
20: #include <mach/mig_errors.h>
21: #include <kern/kalloc.h>
22: #include <ipc/ipc_port.h>
23: #include <ipc/ipc_space.h>
24: #include <vm/vm_kern.h>
25: #include <vm/vm_user.h>
26: #include <device/device_types.h>
27: #include <device/device_port.h>
28: #include <device/disk_status.h>
29: #include <device/device_reply.user.h>
30: #include <device/device_emul.h>
31: #include <device/ds_routines.h>
32: #include <xen/public/io/blkif.h>
33: #include <xen/evt.h>
34: #include <string.h>
35: #include <util/atoi.h>
36: #include "store.h"
37: #include "block.h"
38: #include "grant.h"
39: #include "ring.h"
40: #include "xen.h"
41:
42: /* Hypervisor part */
43:
44: struct block_data {
45: struct device device;
46: char *name;
47: int open_count;
48: char *backend;
49: domid_t domid;
50: char *vbd;
51: int handle;
52: unsigned info;
53: dev_mode_t mode;
54: unsigned sector_size;
55: unsigned long nr_sectors;
56: ipc_port_t port;
57: blkif_front_ring_t ring;
58: evtchn_port_t evt;
59: simple_lock_data_t lock;
60: simple_lock_data_t pushlock;
61: };
62:
63: static int n_vbds;
64: static struct block_data *vbd_data;
65:
66: struct device_emulation_ops hyp_block_emulation_ops;
67:
68: static void hyp_block_intr(int unit) {
69: struct block_data *bd = &vbd_data[unit];
70: blkif_response_t *rsp;
71: int more;
72: io_return_t *err;
73:
74: simple_lock(&bd->lock);
75: more = RING_HAS_UNCONSUMED_RESPONSES(&bd->ring);
76: while (more) {
77: rmb(); /* make sure we see responses */
78: rsp = RING_GET_RESPONSE(&bd->ring, bd->ring.rsp_cons++);
79: err = (void *) (unsigned long) rsp->id;
80: switch (rsp->status) {
81: case BLKIF_RSP_ERROR:
82: *err = D_IO_ERROR;
83: break;
84: case BLKIF_RSP_OKAY:
85: break;
86: default:
87: printf("Unrecognized blkif status %d\n", rsp->status);
88: goto drop;
89: }
90: thread_wakeup(err);
91: drop:
92: thread_wakeup_one(bd);
93: RING_FINAL_CHECK_FOR_RESPONSES(&bd->ring, more);
94: }
95: simple_unlock(&bd->lock);
96: }
97:
98: #define VBD_PATH "device/vbd"
99: void hyp_block_init(void) {
100: char **vbds, **vbd;
101: char *c;
102: int i, disk, partition;
103: int n;
104: int grant;
105: char port_name[10];
106: char *prefix;
107: char device_name[32];
108: domid_t domid;
109: evtchn_port_t evt;
110: hyp_store_transaction_t t;
111: vm_offset_t addr;
112: struct block_data *bd;
113: blkif_sring_t *ring;
114:
115: vbds = hyp_store_ls(0, 1, VBD_PATH);
116: if (!vbds) {
117: printf("hd: No block device (%s). Hoping you don't need any\n", hyp_store_error);
118: n_vbds = 0;
119: return;
120: }
121:
122: n = 0;
123: for (vbd = vbds; *vbd; vbd++)
124: n++;
125:
126: vbd_data = (void*) kalloc(n * sizeof(*vbd_data));
127: if (!vbd_data) {
128: printf("hd: No memory room for VBD\n");
129: n_vbds = 0;
130: return;
131: }
132: n_vbds = n;
133:
134: for (n = 0; n < n_vbds; n++) {
135: bd = &vbd_data[n];
136: mach_atoi((u_char *) vbds[n], &bd->handle);
137: if (bd->handle == MACH_ATOI_DEFAULT)
138: continue;
139:
140: bd->open_count = -2;
141: bd->vbd = vbds[n];
142:
143: /* Get virtual number. */
144: i = hyp_store_read_int(0, 5, VBD_PATH, "/", vbds[n], "/", "virtual-device");
145: if (i == -1)
146: panic("hd: couldn't virtual device of VBD %s\n",vbds[n]);
147: if ((i >> 28) == 1) {
148: /* xvd, new format */
149: prefix = "xvd";
150: disk = (i >> 8) & ((1 << 20) - 1);
151: partition = i & ((1 << 8) - 1);
152: } else if ((i >> 8) == 202) {
153: /* xvd, old format */
154: prefix = "xvd";
155: disk = (i >> 4) & ((1 << 4) - 1);
156: partition = i & ((1 << 4) - 1);
157: } else if ((i >> 8) == 8) {
158: /* SCSI */
159: prefix = "sd";
160: disk = (i >> 4) & ((1 << 4) - 1);
161: partition = i & ((1 << 4) - 1);
162: } else if ((i >> 8) == 3) {
163: /* IDE primary */
164: prefix = "hd";
165: disk = (i >> 6) & ((1 << 2) - 1);
166: partition = i & ((1 << 6) - 1);
167: } else if ((i >> 8) == 22) {
168: /* IDE secondary */
169: prefix = "hd";
170: disk = ((i >> 6) & ((1 << 2) - 1)) + 2;
171: partition = i & ((1 << 6) - 1);
172: } else if ((i >> 8) == 33) {
173: /* IDE 3 */
174: prefix = "hd";
175: disk = ((i >> 6) & ((1 << 2) - 1)) + 4;
176: partition = i & ((1 << 6) - 1);
177: } else if ((i >> 8) == 34) {
178: /* IDE 4 */
179: prefix = "hd";
180: disk = ((i >> 6) & ((1 << 2) - 1)) + 6;
181: partition = i & ((1 << 6) - 1);
182: } else if ((i >> 8) == 56) {
183: /* IDE 5 */
184: prefix = "hd";
185: disk = ((i >> 6) & ((1 << 2) - 1)) + 8;
186: partition = i & ((1 << 6) - 1);
187: } else if ((i >> 8) == 57) {
188: /* IDE 6 */
189: prefix = "hd";
190: disk = ((i >> 6) & ((1 << 2) - 1)) + 10;
191: partition = i & ((1 << 6) - 1);
192: } else if ((i >> 8) == 88) {
193: /* IDE 7 */
194: prefix = "hd";
195: disk = ((i >> 6) & ((1 << 2) - 1)) + 12;
196: partition = i & ((1 << 6) - 1);
197: } else if ((i >> 8) == 89) {
198: /* IDE 8 */
199: prefix = "hd";
200: disk = ((i >> 6) & ((1 << 2) - 1)) + 14;
201: partition = i & ((1 << 6) - 1);
202: } else if ((i >> 8) == 90) {
203: /* IDE 9 */
204: prefix = "hd";
205: disk = ((i >> 6) & ((1 << 2) - 1)) + 16;
206: partition = i & ((1 << 6) - 1);
207: } else if ((i >> 8) == 91) {
208: /* IDE 10 */
209: prefix = "hd";
210: disk = ((i >> 6) & ((1 << 2) - 1)) + 18;
211: partition = i & ((1 << 6) - 1);
212: } else {
213: printf("unsupported VBD number %d\n", i);
214: continue;
215: }
216: if (partition)
217: sprintf(device_name, "%s%ds%d", prefix, disk, partition);
218: else
219: sprintf(device_name, "%s%d", prefix, disk);
220: bd->name = (char*) kalloc(strlen(device_name));
221: strcpy(bd->name, device_name);
222:
223: /* Get domain id of backend driver. */
224: i = hyp_store_read_int(0, 5, VBD_PATH, "/", vbds[n], "/", "backend-id");
225: if (i == -1)
226: panic("%s: couldn't read backend domid (%s)", device_name, hyp_store_error);
227: bd->domid = domid = i;
228:
229: do {
230: t = hyp_store_transaction_start();
231:
232: /* Get a page for ring */
233: if ((addr = vm_page_grab_phys_addr()) == -1)
234: panic("%s: couldn't allocate space for store ring\n", device_name);
235: ring = (void*) phystokv(addr);
236: SHARED_RING_INIT(ring);
237: FRONT_RING_INIT(&bd->ring, ring, PAGE_SIZE);
238: grant = hyp_grant_give(domid, atop(addr), 0);
239:
240: /* and give it to backend. */
241: i = sprintf(port_name, "%d", grant);
242: c = hyp_store_write(t, port_name, 5, VBD_PATH, "/", vbds[n], "/", "ring-ref");
243: if (!c)
244: panic("%s: couldn't store ring reference (%s)", device_name, hyp_store_error);
245: kfree((vm_offset_t) c, strlen(c)+1);
246:
247: /* Allocate an event channel and give it to backend. */
248: bd->evt = evt = hyp_event_channel_alloc(domid);
249: hyp_evt_handler(evt, hyp_block_intr, n, SPL7);
250: i = sprintf(port_name, "%lu", evt);
251: c = hyp_store_write(t, port_name, 5, VBD_PATH, "/", vbds[n], "/", "event-channel");
252: if (!c)
253: panic("%s: couldn't store event channel (%s)", device_name, hyp_store_error);
254: kfree((vm_offset_t) c, strlen(c)+1);
255: c = hyp_store_write(t, hyp_store_state_initialized, 5, VBD_PATH, "/", vbds[n], "/", "state");
256: if (!c)
257: panic("%s: couldn't store state (%s)", device_name, hyp_store_error);
258: kfree((vm_offset_t) c, strlen(c)+1);
259: } while (!hyp_store_transaction_stop(t));
260: /* TODO randomly wait? */
261:
262: c = hyp_store_read(0, 5, VBD_PATH, "/", vbds[n], "/", "backend");
263: if (!c)
264: panic("%s: couldn't get path to backend (%s)", device_name, hyp_store_error);
265: bd->backend = c;
266:
267: while(1) {
268: i = hyp_store_read_int(0, 3, bd->backend, "/", "state");
269: if (i == MACH_ATOI_DEFAULT)
270: panic("can't read state from %s", bd->backend);
271: if (i == XenbusStateConnected)
272: break;
273: hyp_yield();
274: }
275:
276: i = hyp_store_read_int(0, 3, bd->backend, "/", "sectors");
277: if (i == -1)
278: panic("%s: couldn't get number of sectors (%s)", device_name, hyp_store_error);
279: bd->nr_sectors = i;
280:
281: i = hyp_store_read_int(0, 3, bd->backend, "/", "sector-size");
282: if (i == -1)
283: panic("%s: couldn't get sector size (%s)", device_name, hyp_store_error);
284: if (i & ~(2*(i-1)+1))
285: panic("sector size %d is not a power of 2\n", i);
286: if (i > PAGE_SIZE || PAGE_SIZE % i != 0)
287: panic("%s: couldn't handle sector size %d with pages of size %d\n", device_name, i, PAGE_SIZE);
288: bd->sector_size = i;
289:
290: i = hyp_store_read_int(0, 3, bd->backend, "/", "info");
291: if (i == -1)
292: panic("%s: couldn't get info (%s)", device_name, hyp_store_error);
293: bd->info = i;
294:
295: c = hyp_store_read(0, 3, bd->backend, "/", "mode");
296: if (!c)
297: panic("%s: couldn't get backend's mode (%s)", device_name, hyp_store_error);
298: if ((c[0] == 'w') && !(bd->info & VDISK_READONLY))
299: bd->mode = D_READ|D_WRITE;
300: else
301: bd->mode = D_READ;
302:
303: c = hyp_store_read(0, 3, bd->backend, "/", "params");
304: if (!c)
305: panic("%s: couldn't get backend's real device (%s)", device_name, hyp_store_error);
306:
307: /* TODO: change suffix */
308: printf("%s: dom%d's VBD %s (%s,%c%s) %ldMB\n", device_name, domid,
309: vbds[n], c, bd->mode & D_WRITE ? 'w' : 'r',
310: bd->info & VDISK_CDROM ? ", cdrom" : "",
311: bd->nr_sectors / ((1<<20) / 512));
312: kfree((vm_offset_t) c, strlen(c)+1);
313:
314: c = hyp_store_write(0, hyp_store_state_connected, 5, VBD_PATH, "/", bd->vbd, "/", "state");
315: if (!c)
316: panic("couldn't store state for %s (%s)", device_name, hyp_store_error);
317: kfree((vm_offset_t) c, strlen(c)+1);
318:
319: bd->open_count = -1;
320: bd->device.emul_ops = &hyp_block_emulation_ops;
321: bd->device.emul_data = bd;
322: simple_lock_init(&bd->lock);
323: simple_lock_init(&bd->pushlock);
324: }
325: }
326:
327: static ipc_port_t
328: dev_to_port(void *d)
329: {
330: struct block_data *b = d;
331: if (!d)
332: return IP_NULL;
333: return ipc_port_make_send(b->port);
334: }
335:
336: static int
337: device_close(void *devp)
338: {
339: struct block_data *bd = devp;
340: if (--bd->open_count < 0)
341: panic("too many closes on %s", bd->name);
342: printf("close, %s count %d\n", bd->name, bd->open_count);
343: if (bd->open_count)
344: return 0;
345: ipc_kobject_set(bd->port, IKO_NULL, IKOT_NONE);
346: ipc_port_dealloc_kernel(bd->port);
347: return 0;
348: }
349:
350: static io_return_t
351: device_open (ipc_port_t reply_port, mach_msg_type_name_t reply_port_type,
352: dev_mode_t mode, char *name, device_t *devp /* out */)
353: {
354: int i, err = 0;
355: ipc_port_t port, notify;
356: struct block_data *bd;
357:
358: for (i = 0; i < n_vbds; i++)
359: if (!strcmp(name, vbd_data[i].name))
360: break;
361:
362: if (i == n_vbds)
363: return D_NO_SUCH_DEVICE;
364:
365: bd = &vbd_data[i];
366: if (bd->open_count == -2)
367: /* couldn't be initialized */
368: return D_NO_SUCH_DEVICE;
369:
370: if ((mode & D_WRITE) && !(bd->mode & D_WRITE))
371: return D_READ_ONLY;
372:
373: if (bd->open_count >= 0) {
374: *devp = &bd->device ;
375: bd->open_count++ ;
376: printf("re-open, %s count %d\n", bd->name, bd->open_count);
377: return D_SUCCESS;
378: }
379:
380: bd->open_count = 1;
381: printf("%s count %d\n", bd->name, bd->open_count);
382:
383: port = ipc_port_alloc_kernel();
384: if (port == IP_NULL) {
385: err = KERN_RESOURCE_SHORTAGE;
386: goto out;
387: }
388: bd->port = port;
389:
390: *devp = &bd->device;
391:
392: ipc_kobject_set (port, (ipc_kobject_t) &bd->device, IKOT_DEVICE);
393:
394: notify = ipc_port_make_sonce (bd->port);
395: ip_lock (bd->port);
396: ipc_port_nsrequest (bd->port, 1, notify, ¬ify);
397: assert (notify == IP_NULL);
398:
399: out:
400: if (IP_VALID (reply_port))
401: ds_device_open_reply (reply_port, reply_port_type, D_SUCCESS, port);
402: else
403: device_close(bd);
404: return MIG_NO_REPLY;
405: }
406:
407: static io_return_t
408: device_read (void *d, ipc_port_t reply_port,
409: mach_msg_type_name_t reply_port_type, dev_mode_t mode,
410: recnum_t bn, int count, io_buf_ptr_t *data,
411: unsigned *bytes_read)
412: {
413: int resid, amt;
414: io_return_t err = 0;
415: vm_page_t pages[BLKIF_MAX_SEGMENTS_PER_REQUEST];
416: grant_ref_t gref[BLKIF_MAX_SEGMENTS_PER_REQUEST];
417: int nbpages;
418: vm_map_copy_t copy;
419: vm_offset_t offset, alloc_offset, o;
420: vm_object_t object;
421: vm_page_t m;
422: vm_size_t len, size;
423: struct block_data *bd = d;
424: struct blkif_request *req;
425:
426: *data = 0;
427: *bytes_read = 0;
428:
429: if (count < 0)
430: return D_INVALID_SIZE;
431: if (count == 0)
432: return 0;
433:
434: /* Allocate an object to hold the data. */
435: size = round_page (count);
436: object = vm_object_allocate (size);
437: if (! object)
438: {
439: err = D_NO_MEMORY;
440: goto out;
441: }
442: alloc_offset = offset = 0;
443: resid = count;
444:
445: while (resid && !err)
446: {
447: unsigned reqn;
448: int i;
449: int last_sect;
450:
451: nbpages = 0;
452:
453: /* Determine size of I/O this time around. */
454: len = round_page(offset + resid) - offset;
455: if (len > PAGE_SIZE * BLKIF_MAX_SEGMENTS_PER_REQUEST)
456: len = PAGE_SIZE * BLKIF_MAX_SEGMENTS_PER_REQUEST;
457:
458: /* Allocate pages. */
459: while (alloc_offset < offset + len)
460: {
461: while ((m = vm_page_grab (FALSE)) == 0)
462: VM_PAGE_WAIT (0);
463: assert (! m->active && ! m->inactive);
464: m->busy = TRUE;
465: assert(nbpages < BLKIF_MAX_SEGMENTS_PER_REQUEST);
466: pages[nbpages++] = m;
467: alloc_offset += PAGE_SIZE;
468: }
469:
470: /* Do the read. */
471: amt = len;
472: if (amt > resid)
473: amt = resid;
474:
475: /* allocate a request */
476: spl_t spl = splsched();
477: while(1) {
478: simple_lock(&bd->lock);
479: if (!RING_FULL(&bd->ring))
480: break;
481: thread_sleep(bd, &bd->lock, FALSE);
482: }
483: mb();
484: reqn = bd->ring.req_prod_pvt++;;
485: simple_lock(&bd->pushlock);
486: simple_unlock(&bd->lock);
487: (void) splx(spl);
488:
489: req = RING_GET_REQUEST(&bd->ring, reqn);
490: req->operation = BLKIF_OP_READ;
491: req->nr_segments = nbpages;
492: req->handle = bd->handle;
493: req->id = (unsigned64_t) (unsigned long) &err; /* pointer on the stack */
494: req->sector_number = bn + offset / 512;
495: for (i = 0; i < nbpages; i++) {
496: req->seg[i].gref = gref[i] = hyp_grant_give(bd->domid, atop(pages[i]->phys_addr), 0);
497: req->seg[i].first_sect = 0;
498: req->seg[i].last_sect = PAGE_SIZE/512 - 1;
499: }
500: last_sect = ((amt - 1) & PAGE_MASK) / 512;
501: req->seg[nbpages-1].last_sect = last_sect;
502:
503: memset((void*) phystokv(pages[nbpages-1]->phys_addr
504: + (last_sect + 1) * 512),
505: 0, PAGE_SIZE - (last_sect + 1) * 512);
506:
507: /* no need for a lock: as long as the request is not pushed, the event won't be triggered */
508: assert_wait((event_t) &err, FALSE);
509:
510: int notify;
511: wmb(); /* make sure it sees requests */
512: RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&bd->ring, notify);
513: if (notify)
514: hyp_event_channel_send(bd->evt);
515: simple_unlock(&bd->pushlock);
516:
517: thread_block(NULL);
518:
519: if (err)
520: printf("error reading %d bytes at sector %ld\n", amt,
521: bn + offset / 512);
522:
523: for (i = 0; i < nbpages; i++)
524: hyp_grant_takeback(gref[i]);
525:
526: /* Compute number of pages to insert in object. */
527: o = offset;
528:
529: resid -= amt;
530: if (resid == 0)
531: offset = o + len;
532: else
533: offset += amt;
534:
535: /* Add pages to the object. */
536: vm_object_lock (object);
537: for (i = 0; i < nbpages; i++)
538: {
539: m = pages[i];
540: assert (m->busy);
541: vm_page_lock_queues ();
542: PAGE_WAKEUP_DONE (m);
543: m->dirty = TRUE;
544: vm_page_insert (m, object, o);
545: vm_page_unlock_queues ();
546: o += PAGE_SIZE;
547: }
548: vm_object_unlock (object);
549: }
550:
551: out:
552: if (! err)
553: err = vm_map_copyin_object (object, 0, round_page (count), ©);
554: if (! err)
555: {
556: *data = (io_buf_ptr_t) copy;
557: *bytes_read = count - resid;
558: }
559: else
560: vm_object_deallocate (object);
561: return err;
562: }
563:
564: static io_return_t
565: device_write(void *d, ipc_port_t reply_port,
566: mach_msg_type_name_t reply_port_type, dev_mode_t mode,
567: recnum_t bn, io_buf_ptr_t data, unsigned int count,
568: int *bytes_written)
569: {
570: io_return_t err = 0;
571: vm_map_copy_t copy = (vm_map_copy_t) data;
572: vm_offset_t aligned_buffer = 0;
573: int copy_npages = atop(round_page(count));
574: vm_offset_t phys_addrs[copy_npages];
575: struct block_data *bd = d;
576: blkif_request_t *req;
577: grant_ref_t gref[BLKIF_MAX_SEGMENTS_PER_REQUEST];
578: unsigned reqn, size;
579: int i, nbpages, j;
580:
581: if (!(bd->mode & D_WRITE))
582: return D_READ_ONLY;
583:
584: if (count == 0) {
585: vm_map_copy_discard(copy);
586: return 0;
587: }
588:
589: if (count % bd->sector_size)
590: return D_INVALID_SIZE;
591:
592: if (count > copy->size)
593: return D_INVALID_SIZE;
594:
595: if (copy->type != VM_MAP_COPY_PAGE_LIST || copy->offset & PAGE_MASK) {
596: /* Unaligned write. Has to copy data before passing it to the backend. */
597: kern_return_t kr;
598: vm_offset_t buffer;
599:
600: kr = kmem_alloc(device_io_map, &aligned_buffer, count);
601: if (kr != KERN_SUCCESS)
602: return kr;
603:
604: kr = vm_map_copyout(device_io_map, &buffer, vm_map_copy_copy(copy));
605: if (kr != KERN_SUCCESS) {
606: kmem_free(device_io_map, aligned_buffer, count);
607: return kr;
608: }
609:
610: memcpy((void*) aligned_buffer, (void*) buffer, count);
611:
612: vm_deallocate (device_io_map, buffer, count);
613:
614: for (i = 0; i < copy_npages; i++)
615: phys_addrs[i] = kvtophys(aligned_buffer + ptoa(i));
616: } else {
617: for (i = 0; i < copy_npages; i++)
618: phys_addrs[i] = copy->cpy_page_list[i]->phys_addr;
619: }
620:
621: for (i=0; i<copy_npages; i+=nbpages) {
622:
623: nbpages = BLKIF_MAX_SEGMENTS_PER_REQUEST;
624: if (nbpages > copy_npages-i)
625: nbpages = copy_npages-i;
626:
627: /* allocate a request */
628: spl_t spl = splsched();
629: while(1) {
630: simple_lock(&bd->lock);
631: if (!RING_FULL(&bd->ring))
632: break;
633: thread_sleep(bd, &bd->lock, FALSE);
634: }
635: mb();
636: reqn = bd->ring.req_prod_pvt++;;
637: simple_lock(&bd->pushlock);
638: simple_unlock(&bd->lock);
639: (void) splx(spl);
640:
641: req = RING_GET_REQUEST(&bd->ring, reqn);
642: req->operation = BLKIF_OP_WRITE;
643: req->nr_segments = nbpages;
644: req->handle = bd->handle;
645: req->id = (unsigned64_t) (unsigned long) &err; /* pointer on the stack */
646: req->sector_number = bn + i*PAGE_SIZE / 512;
647:
648: for (j = 0; j < nbpages; j++) {
649: req->seg[j].gref = gref[j] = hyp_grant_give(bd->domid, atop(phys_addrs[i + j]), 1);
650: req->seg[j].first_sect = 0;
651: size = PAGE_SIZE;
652: if ((i + j + 1) * PAGE_SIZE > count)
653: size = count - (i + j) * PAGE_SIZE;
654: req->seg[j].last_sect = size/512 - 1;
655: }
656:
657: /* no need for a lock: as long as the request is not pushed, the event won't be triggered */
658: assert_wait((event_t) &err, FALSE);
659:
660: int notify;
661: wmb(); /* make sure it sees requests */
662: RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&bd->ring, notify);
663: if (notify)
664: hyp_event_channel_send(bd->evt);
665: simple_unlock(&bd->pushlock);
666:
667: thread_block(NULL);
668:
669: for (j = 0; j < nbpages; j++)
670: hyp_grant_takeback(gref[j]);
671:
672: if (err) {
673: printf("error writing %u bytes at sector %d\n", count, bn);
674: break;
675: }
676: }
677:
678: if (aligned_buffer)
679: kmem_free(device_io_map, aligned_buffer, count);
680:
681: vm_map_copy_discard (copy);
682:
683: if (!err)
684: *bytes_written = count;
685:
686: if (IP_VALID(reply_port))
687: ds_device_write_reply (reply_port, reply_port_type, err, count);
688:
689: return MIG_NO_REPLY;
690: }
691:
692: static io_return_t
693: device_get_status(void *d, dev_flavor_t flavor, dev_status_t status,
694: mach_msg_type_number_t *status_count)
695: {
696: struct block_data *bd = d;
697:
698: switch (flavor)
699: {
700: case DEV_GET_SIZE:
701: status[DEV_GET_SIZE_DEVICE_SIZE] = (unsigned long long) bd->nr_sectors * 512;
702: status[DEV_GET_SIZE_RECORD_SIZE] = bd->sector_size;
703: *status_count = DEV_GET_SIZE_COUNT;
704: break;
705: case DEV_GET_RECORDS:
706: status[DEV_GET_RECORDS_DEVICE_RECORDS] = ((unsigned long long) bd->nr_sectors * 512) / bd->sector_size;
707: status[DEV_GET_RECORDS_RECORD_SIZE] = bd->sector_size;
708: *status_count = DEV_GET_RECORDS_COUNT;
709: break;
710: default:
711: printf("TODO: block_%s(%d)\n", __func__, flavor);
712: return D_INVALID_OPERATION;
713: }
714: return D_SUCCESS;
715: }
716:
717: struct device_emulation_ops hyp_block_emulation_ops = {
718: NULL, /* dereference */
719: NULL, /* deallocate */
720: dev_to_port,
721: device_open,
722: device_close,
723: device_write,
724: NULL, /* write_inband */
725: device_read,
726: NULL, /* read_inband */
727: NULL, /* set_status */
728: device_get_status,
729: NULL, /* set_filter */
730: NULL, /* map */
731: NULL, /* no_senders */
732: NULL, /* write_trap */
733: NULL, /* writev_trap */
734: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.