ia64/xen-unstable

view tools/blktap/drivers/block-sync.c @ 15783:c93e2a822d6f

[xen, xencomm] xencomm multiple page support
Current implementation doesn't allow struct xencomm_desc::address
array to be more than single page. On IA64 it causes 64GB+ domain
creation failure. This patch generalizes xencomm to allow multipage

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author kfraser@localhost.localdomain
date Tue Aug 28 15:32:27 2007 +0100 (2007-08-28)
parents 8407279d3751
children b6cc74f275fd
line source
1 /* block-sync.c
2 *
3 * simple slow synchronous raw disk implementation.
4 *
5 * (c) 2006 Andrew Warfield and Julian Chesterfield
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version 2
9 * as published by the Free Software Foundation; or, when distributed
10 * separately from the Linux kernel or incorporated into other
11 * software packages, subject to the following license:
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a copy
14 * of this source file (the "Software"), to deal in the Software without
15 * restriction, including without limitation the rights to use, copy, modify,
16 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
17 * and to permit persons to whom the Software is furnished to do so, subject to
18 * the following conditions:
19 *
20 * The above copyright notice and this permission notice shall be included in
21 * all copies or substantial portions of the Software.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
26 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
29 * IN THE SOFTWARE.
30 */
32 #include <errno.h>
33 #include <fcntl.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <sys/statvfs.h>
38 #include <sys/stat.h>
39 #include <sys/ioctl.h>
40 #include <linux/fs.h>
41 #include "tapdisk.h"
43 struct tdsync_state {
44 int fd;
45 int poll_pipe[2]; /* dummy fd for polling on */
46 };
48 /*Get Image size, secsize*/
49 static int get_image_info(struct td_state *s, int fd)
50 {
51 int ret;
52 long size;
53 unsigned long total_size;
54 struct statvfs statBuf;
55 struct stat stat;
57 ret = fstat(fd, &stat);
58 if (ret != 0) {
59 DPRINTF("ERROR: fstat failed, Couldn't stat image");
60 return -EINVAL;
61 }
63 if (S_ISBLK(stat.st_mode)) {
64 /*Accessing block device directly*/
65 s->size = 0;
66 if (ioctl(fd,BLKGETSIZE,&s->size)!=0) {
67 DPRINTF("ERR: BLKGETSIZE failed, couldn't stat image");
68 return -EINVAL;
69 }
71 DPRINTF("Image size: \n\tpre sector_shift [%llu]\n\tpost "
72 "sector_shift [%llu]\n",
73 (long long unsigned)(s->size << SECTOR_SHIFT),
74 (long long unsigned)s->size);
76 /*Get the sector size*/
77 #if defined(BLKSSZGET)
78 {
79 int arg;
80 s->sector_size = DEFAULT_SECTOR_SIZE;
81 ioctl(fd, BLKSSZGET, &s->sector_size);
83 if (s->sector_size != DEFAULT_SECTOR_SIZE)
84 DPRINTF("Note: sector size is %ld (not %d)\n",
85 s->sector_size, DEFAULT_SECTOR_SIZE);
86 }
87 #else
88 s->sector_size = DEFAULT_SECTOR_SIZE;
89 #endif
91 } else {
92 /*Local file? try fstat instead*/
93 s->size = (stat.st_size >> SECTOR_SHIFT);
94 s->sector_size = DEFAULT_SECTOR_SIZE;
95 DPRINTF("Image size: \n\tpre sector_shift [%lluu]\n\tpost "
96 "sector_shift [%lluu]\n",
97 (long long unsigned)(s->size << SECTOR_SHIFT),
98 (long long unsigned)s->size);
99 }
101 if (s->size == 0)
102 return -EINVAL;
104 s->info = 0;
106 return 0;
107 }
109 static inline void init_fds(struct disk_driver *dd)
110 {
111 int i;
112 struct tdsync_state *prv = (struct tdsync_state *)dd->private;
114 for(i = 0; i < MAX_IOFD; i++)
115 dd->io_fd[i] = 0;
117 dd->io_fd[0] = prv->poll_pipe[0];
118 }
120 /* Open the disk file and initialize aio state. */
121 int tdsync_open (struct disk_driver *dd, const char *name, td_flag_t flags)
122 {
123 int i, fd, ret = 0, o_flags;
124 struct td_state *s = dd->td_state;
125 struct tdsync_state *prv = (struct tdsync_state *)dd->private;
127 /* set up a pipe so that we can hand back a poll fd that won't fire.*/
128 ret = pipe(prv->poll_pipe);
129 if (ret != 0)
130 return (0 - errno);
132 /* Open the file */
133 o_flags = O_DIRECT | O_LARGEFILE |
134 ((flags == TD_RDONLY) ? O_RDONLY : O_RDWR);
135 fd = open(name, o_flags);
137 if ( (fd == -1) && (errno == EINVAL) ) {
139 /* Maybe O_DIRECT isn't supported. */
140 o_flags &= ~O_DIRECT;
141 fd = open(name, O_RDWR | O_LARGEFILE);
142 if (fd != -1) DPRINTF("WARNING: Accessing image without"
143 "O_DIRECT! (%s)\n", name);
145 } else if (fd != -1) DPRINTF("open(%s) with O_DIRECT\n", name);
147 if (fd == -1) {
148 DPRINTF("Unable to open [%s]!\n",name);
149 ret = 0 - errno;
150 goto done;
151 }
153 prv->fd = fd;
155 init_fds(dd);
156 ret = get_image_info(s, fd);
157 done:
158 return ret;
159 }
161 int tdsync_queue_read(struct disk_driver *dd, uint64_t sector,
162 int nb_sectors, char *buf, td_callback_t cb,
163 int id, void *private)
164 {
165 struct td_state *s = dd->td_state;
166 struct tdsync_state *prv = (struct tdsync_state *)dd->private;
167 int size = nb_sectors * s->sector_size;
168 uint64_t offset = sector * (uint64_t)s->sector_size;
169 int ret;
171 ret = lseek(prv->fd, offset, SEEK_SET);
172 if (ret != (off_t)-1) {
173 ret = read(prv->fd, buf, size);
174 if (ret != size) {
175 ret = 0 - errno;
176 } else {
177 ret = 1;
178 }
179 } else ret = 0 - errno;
181 return cb(dd, (ret < 0) ? ret: 0, sector, nb_sectors, id, private);
182 }
184 int tdsync_queue_write(struct disk_driver *dd, uint64_t sector,
185 int nb_sectors, char *buf, td_callback_t cb,
186 int id, void *private)
187 {
188 struct td_state *s = dd->td_state;
189 struct tdsync_state *prv = (struct tdsync_state *)dd->private;
190 int size = nb_sectors * s->sector_size;
191 uint64_t offset = sector * (uint64_t)s->sector_size;
192 int ret = 0;
194 ret = lseek(prv->fd, offset, SEEK_SET);
195 if (ret != (off_t)-1) {
196 ret = write(prv->fd, buf, size);
197 if (ret != size) {
198 ret = 0 - errno;
199 } else {
200 ret = 1;
201 }
202 } else ret = 0 - errno;
204 return cb(dd, (ret < 0) ? ret : 0, sector, nb_sectors, id, private);
205 }
207 int tdsync_submit(struct disk_driver *dd)
208 {
209 return 0;
210 }
212 int tdsync_close(struct disk_driver *dd)
213 {
214 struct tdsync_state *prv = (struct tdsync_state *)dd->private;
216 close(prv->fd);
217 close(prv->poll_pipe[0]);
218 close(prv->poll_pipe[1]);
220 return 0;
221 }
223 int tdsync_do_callbacks(struct disk_driver *dd, int sid)
224 {
225 /* always ask for a kick */
226 return 1;
227 }
229 int tdsync_get_parent_id(struct disk_driver *dd, struct disk_id *id)
230 {
231 return TD_NO_PARENT;
232 }
234 int tdsync_validate_parent(struct disk_driver *dd,
235 struct disk_driver *parent, td_flag_t flags)
236 {
237 return -EINVAL;
238 }
240 struct tap_disk tapdisk_sync = {
241 .disk_type = "tapdisk_sync",
242 .private_data_size = sizeof(struct tdsync_state),
243 .td_open = tdsync_open,
244 .td_queue_read = tdsync_queue_read,
245 .td_queue_write = tdsync_queue_write,
246 .td_submit = tdsync_submit,
247 .td_close = tdsync_close,
248 .td_do_callbacks = tdsync_do_callbacks,
249 .td_get_parent_id = tdsync_get_parent_id,
250 .td_validate_parent = tdsync_validate_parent
251 };