![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to posix-disk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / host / posix|
Return to posix-disk.c CVS log | Up to [The Machine Emulator] / tme / host / posix |
1.1 root 1: /* $Id: posix-disk.c,v 1.3 2003/10/16 03:02:11 fredette Exp $ */
2:
3: /* host/posix/posix-disk.c - implementation of disks on a POSIX system: */
4:
5: /*
6: * Copyright (c) 2003 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: posix-disk.c,v 1.3 2003/10/16 03:02:11 fredette Exp $");
38:
39: /* includes: */
40: #include <tme/generic/disk.h>
41: #include <tme/generic/bus.h>
42: #include <fcntl.h>
43: #include <stdlib.h>
44: #include <strings.h>
45: #include <sys/stat.h>
46: #include <sys/uio.h>
47: #ifdef HAVE_MMAP
48: #include <sys/types.h>
49: #include <sys/mman.h>
50: #endif /* HAVE_MMAP */
51: #ifdef HAVE_STDARG_H
52: #include <stdarg.h>
53: #else /* HAVE_STDARG_H */
54: #include <varargs.h>
55: #endif /* HAVE_STDARG_H */
56:
57: /* macros: */
58:
59: /* the maximum block size: */
60: #define TME_POSIX_DISK_BLOCK_SIZE_MAX (16384)
61:
62: /* disk flags: */
63: #define TME_POSIX_DISK_FLAG_RO TME_BIT(0)
64:
65: /* buffer flags: */
66: #define TME_POSIX_DISK_BUFFER_READABLE TME_BIT(0)
67: #define TME_POSIX_DISK_BUFFER_DIRTY TME_BIT(1)
68: #define TME_POSIX_DISK_BUFFER_MMAPPED TME_BIT(2)
69:
70: /* default buffer parameters: */
71: #define TME_POSIX_DISK_BUFFER_DEFAULT_COUNT (16)
72: #define TME_POSIX_DISK_BUFFER_DEFAULT_AGG_PRE (128UL * 1024UL)
73: #define TME_POSIX_DISK_BUFFER_DEFAULT_AGG_POST (1UL * 1024UL * 1024UL)
74:
75: /* types: */
76:
77: /* a posix disk buffer: */
78: struct tme_posix_disk_buffer {
79:
80: /* buffers are kept on a doubly linked list: */
81: struct tme_posix_disk_buffer *tme_posix_disk_buffer_next;
82: struct tme_posix_disk_buffer **tme_posix_disk_buffer_prev;
83:
84: /* buffer flags: */
85: int tme_posix_disk_buffer_flags;
86:
87: /* the file position, size, and data of this buffer. a size of zero
88: means this buffer is free: */
89:
90: /* we're paranoid about autoconf's ability to actually determine if
91: off_t and size_t are available, and it's possible that a system
92: that predates off_t and size_t may use other types to achieve
93: large file support anyways, that autoconf's default off_t = long
94: and size_t = unsigned definitions may not match. the bizarre
95: solution is to declare structs with appropriately-typed members,
96: and then use those members: */
97: struct stat _tme_posix_disk_buffer_stat;
98: struct iovec _tme_posix_disk_buffer_iov;
99: #define tme_posix_disk_buffer_pos _tme_posix_disk_buffer_stat.st_size
100: #define tme_posix_disk_buffer_size _tme_posix_disk_buffer_iov.iov_len
101: #define tme_posix_disk_buffer_data _tme_posix_disk_buffer_iov.iov_base
102: };
103:
104: /* a posix disk: */
105: struct tme_posix_disk {
106:
107: /* backpointer to our element: */
108: struct tme_element *tme_posix_disk_element;
109:
110: /* our mutex: */
111: tme_mutex_t tme_posix_disk_mutex;
112:
113: /* our flags: */
114: int tme_posix_disk_flags;
115:
116: /* the file descriptor: */
117: int tme_posix_disk_fd;
118:
119: /* the stat buffer: */
120: struct stat tme_posix_disk_stat;
121:
122: /* our connection: */
123: struct tme_disk_connection *tme_posix_disk_connection;
124:
125: /* our disk buffers. the most-recently-used buffer
126: is at the front of the list: */
127: struct tme_posix_disk_buffer *tme_posix_disk_buffers;
128:
129: /* how much we aggregate behind and ahead when we will
130: a new buffer: */
131: struct stat _tme_posix_disk_stat0;
132: struct stat _tme_posix_disk_stat1;
133: #define tme_posix_disk_buffer_agg_pre _tme_posix_disk_stat0.st_size
134: #define tme_posix_disk_buffer_agg_post _tme_posix_disk_stat1.st_size
135: };
136:
137: /* this gets a buffer: */
138: static int
139: _tme_posix_disk_buffer_get(struct tme_posix_disk *posix_disk,
140: const union tme_value64 *_pos,
141: unsigned long _size,
142: int readable,
143: tme_uint8_t **_buffer)
144: {
145: struct stat statbufs[3];
146: #define pos_least statbufs[0].st_size
147: #define pos_most statbufs[1].st_size
148: #define pos_last statbufs[2].st_size
149: struct iovec iovecs[3];
150: #define data iovecs[0].iov_base
151: #define size iovecs[0].iov_len
152: #define size_agg iovecs[1].iov_len
153: #define ssize iovecs[2].iov_len
154: unsigned long agg_pre, agg_post;
155: struct tme_posix_disk_buffer *buffer;
156: struct tme_posix_disk_buffer *buffer_free_nosize;
157: struct tme_posix_disk_buffer *buffer_free_sized;
158: int have_least, have_most;
159: int rc;
160:
161: /* form the size, and least and most positions: */
162: size = _size;
163: assert (size > 0);
164: #ifdef TME_HAVE_INT64_T
165: pos_least = _pos->tme_value64_int;
166: #else /* !TME_HAVE_INT64_T */
167: pos_least = _pos->tme_value64_int32_hi;
168: pos_least
169: = ((pos_least << 32)
170: | _pos->tme_value64_int32_lo);
171: #endif /* !TME_HAVE_INT64_T */
172: pos_most = (pos_least + size) - 1;
173:
174: /* if we have to fill a new buffer, decide from where and how much
175: we are going to fill: */
176: agg_pre
177: = TME_MIN(pos_least,
178: posix_disk->tme_posix_disk_buffer_agg_pre);
179: agg_pre
180: += ((pos_least - agg_pre)
181: & (posix_disk->tme_posix_disk_stat.st_blksize - 1));
182: agg_post
183: = posix_disk->tme_posix_disk_buffer_agg_post;
184: size_agg
185: = (((agg_pre + size) + agg_post
186: + (posix_disk->tme_posix_disk_stat.st_blksize - 1))
187: & ~(posix_disk->tme_posix_disk_stat.st_blksize - 1));
188: agg_post = (size_agg - (agg_pre + size));
189:
190: /* start with no best free buffers: */
191: buffer_free_nosize = NULL;
192: buffer_free_sized = NULL;
193:
194: /* walk all of the buffers: */
195: for (buffer = posix_disk->tme_posix_disk_buffers;
196: buffer != NULL; ) {
197:
198: /* a buffer with no size is free: */
199: if (buffer->tme_posix_disk_buffer_size == 0) {
200:
201: /* remember this nosize free buffer and continue: */
202: buffer_free_nosize = buffer;
203: buffer = buffer->tme_posix_disk_buffer_next;
204: continue;
205: }
206:
207: /* a buffer with some size, but no flags, is also free: */
208: else if (buffer->tme_posix_disk_buffer_flags == 0) {
209:
210: /* take this buffer as our best sized free buffer, */
211:
212: /* if we have no best sized free buffer yet: */
213: if (buffer_free_sized == NULL
214:
215: || ((buffer->tme_posix_disk_buffer_size
216: >= buffer_free_sized->tme_posix_disk_buffer_size)
217:
218: /* if this buffer is bigger than our best sized free
219: buffer, and the best sized free buffer is smaller
220: than the new-fill aggregate buffer size: */
221: ? (buffer_free_sized->tme_posix_disk_buffer_size
222: < size_agg)
223:
224: /* if this buffer is smaller than our best sized
225: free buffer, but it is still at least as big as
226: the new-fill aggregate buffer size: */
227: : (buffer->tme_posix_disk_buffer_size
228: >= size_agg))) {
229: buffer_free_sized = buffer;
230: }
231:
232: /* continue: */
233: buffer = buffer->tme_posix_disk_buffer_next;
234: continue;
235: }
236:
237: /* calculate the last position in this buffer: */
238: pos_last = ((buffer->tme_posix_disk_buffer_pos
239: + buffer->tme_posix_disk_buffer_size)
240: - 1);
241:
242: /* see if this buffer contains the least position we want: */
243: have_least
244: = (buffer->tme_posix_disk_buffer_pos <= pos_least
245: && pos_least <= pos_last);
246:
247: /* see if this buffer contains the most position we want: */
248: have_most
249: = (buffer->tme_posix_disk_buffer_pos <= pos_most
250: && pos_most <= pos_last);
251:
252: /* if this buffer covers all of the positions we want, and
253: is readable or we don't need a readable buffer, stop: */
254: if (have_least
255: && have_most
256: && ((buffer->tme_posix_disk_buffer_flags
257: & TME_POSIX_DISK_BUFFER_READABLE)
258: || !readable)) {
259: break;
260: }
261:
262: /* otherwise, if this buffer covers any of the positions we want,
263: or if this is the last buffer on the list and we don't have any
264: best free buffer, we need to free this buffer: */
265: else if (have_least
266: || have_most
267: || (buffer->tme_posix_disk_buffer_next == NULL
268: && buffer_free_nosize == NULL
269: && buffer_free_sized == NULL)) {
270:
271: #ifdef HAVE_MMAP
272: /* if this buffer is mmapped: */
273: if (buffer->tme_posix_disk_buffer_flags
274: & TME_POSIX_DISK_BUFFER_MMAPPED) {
275:
276: /* munmap the buffer: */
277: rc = munmap(buffer->tme_posix_disk_buffer_data,
278: buffer->tme_posix_disk_buffer_size);
279: assert (rc == 0);
280:
281: /* free this buffer: */
282: buffer->tme_posix_disk_buffer_size = 0;
283: }
284:
285: else
286: #endif /* HAVE_MMAP */
287: {
288:
289: /* if this buffer is dirty, we need to write it out: */
290: if (buffer->tme_posix_disk_buffer_flags
291: & TME_POSIX_DISK_BUFFER_DIRTY) {
292:
293: /* seek to the buffer's position: */
294: rc = (lseek(posix_disk->tme_posix_disk_fd,
295: buffer->tme_posix_disk_buffer_pos,
296: SEEK_SET) < 0);
297: assert (rc == 0);
298:
299: /* write out the buffer: */
300: ssize = write(posix_disk->tme_posix_disk_fd,
301: buffer->tme_posix_disk_buffer_data,
302: buffer->tme_posix_disk_buffer_size);
303: assert (ssize == buffer->tme_posix_disk_buffer_size);
304: }
305:
306: /* free this buffer: */
307: buffer->tme_posix_disk_buffer_flags = 0;
308: }
309:
310: /* continue without updating buffer, so that this now-free
311: buffer is revisited, to possibly become a best free buffer: */
312: }
313:
314: /* otherwise, this is a non-free buffer that doesn't
315: cover any of the positions we want. just continue: */
316: else {
317: buffer = buffer->tme_posix_disk_buffer_next;
318: }
319: }
320:
321: /* if we didn't find an applicable buffer: */
322: if (buffer == NULL) {
323:
324: /* we must have some free buffer: */
325: assert (buffer_free_nosize != NULL
326: || buffer_free_sized != NULL);
327:
328: #ifdef HAVE_MMAP
329:
330: /* try to mmap this region. if the map fails with more read-ahead
331: than is needed to meet the block size, try the map one more
332: time with just that needed read-ahead: */
333: data = mmap(NULL,
334: size_agg,
335: PROT_READ
336: | ((posix_disk->tme_posix_disk_flags
337: & TME_POSIX_DISK_FLAG_RO)
338: ? 0
339: : PROT_WRITE),
340: MAP_SHARED,
341: posix_disk->tme_posix_disk_fd,
342: (pos_least
343: - agg_pre));
344: if (data == MAP_FAILED) {
345: size_agg
346: = (((agg_pre + size)
347: + (posix_disk->tme_posix_disk_stat.st_blksize - 1))
348: & ~(posix_disk->tme_posix_disk_stat.st_blksize - 1));
349: data = mmap(NULL,
350: size_agg,
351: PROT_READ
352: | ((posix_disk->tme_posix_disk_flags
353: & TME_POSIX_DISK_FLAG_RO)
354: ? 0
355: : PROT_WRITE),
356: MAP_SHARED,
357: posix_disk->tme_posix_disk_fd,
358: (pos_least
359: - agg_pre));
360: if (data == MAP_FAILED) {
361: size_agg = (agg_pre + size) + agg_post;
362: }
363: else {
364: agg_post = size_agg - (agg_pre + size);
365: }
366: }
367:
368: /* if we were able to mmap this region: */
369: if (data != MAP_FAILED) {
370:
371: /* if we have a free nosize buffer, reuse it, else free the
372: free sized buffer's data and reuse that: */
373: if (buffer_free_nosize != NULL) {
374: buffer = buffer_free_nosize;
375: }
376: else {
377: tme_free(buffer_free_sized->tme_posix_disk_buffer_data);
378: buffer = buffer_free_sized;
379: }
380:
381: /* do the mmapped-specific initialization of this buffer: */
382: buffer->tme_posix_disk_buffer_flags
383: = (TME_POSIX_DISK_BUFFER_READABLE
384: | TME_POSIX_DISK_BUFFER_MMAPPED);
385: }
386:
387: /* otherwise, we were unable to map this region: */
388: else
389: #endif /* HAVE_MMAP */
390: {
391:
392: /* if we have a free sized buffer, resize it, else malloc
393: data for the free nosize buffer: */
394: if (buffer_free_sized != NULL) {
395: data = buffer_free_sized->tme_posix_disk_buffer_data;
396: if (buffer_free_sized->tme_posix_disk_buffer_size
397: != size_agg) {
398: data = tme_realloc(data, size_agg);
399: }
400: buffer = buffer_free_sized;
401: }
402: else {
403: data = tme_malloc(size_agg);
404: buffer = buffer_free_nosize;
405: }
406:
407: /* do the malloced-specific initialization of this buffer: */
408: buffer->tme_posix_disk_buffer_flags = 0;
409: if (readable) {
410: buffer->tme_posix_disk_buffer_flags
411: = TME_POSIX_DISK_BUFFER_READABLE;
412:
413: /* seek to the buffer's position: */
414: rc = (lseek(posix_disk->tme_posix_disk_fd,
415: (pos_least
416: - agg_pre),
417: SEEK_SET) < 0);
418: assert (rc == 0);
419:
420: /* read in the buffer. if the read fails with more
421: read-ahead than is needed to meet the block size, try the
422: read one more time with just that needed read-ahead: */
423: for (;;) {
424: ssize = read(posix_disk->tme_posix_disk_fd,
425: data,
426: size_agg);
427: if (ssize == size_agg) {
428: break;
429: }
430: size_agg
431: = (((agg_pre + size)
432: + (posix_disk->tme_posix_disk_stat.st_blksize - 1))
433: & ~(posix_disk->tme_posix_disk_stat.st_blksize - 1));
434: assert (agg_post > (size_agg - (agg_pre + size)));
435: agg_post = (size_agg - (agg_pre + size));
436: }
437: }
438: }
439:
440: /* do the common initialization of this buffer: */
441: buffer->tme_posix_disk_buffer_pos
442: = (pos_least
443: - agg_pre);
444: buffer->tme_posix_disk_buffer_size
445: = size_agg;
446: buffer->tme_posix_disk_buffer_data
447: = data;
448: }
449:
450: /* if this buffer doesn't need to be readable, that means that it's
451: being written to, so mark it dirty: */
452: if (!readable) {
453: buffer->tme_posix_disk_buffer_flags
454: |= TME_POSIX_DISK_BUFFER_DIRTY;
455: }
456:
457: /* remove this buffer from the list: */
458: *buffer->tme_posix_disk_buffer_prev
459: = buffer->tme_posix_disk_buffer_next;
460: if (buffer->tme_posix_disk_buffer_next != NULL) {
461: buffer->tme_posix_disk_buffer_next->tme_posix_disk_buffer_prev
462: = buffer->tme_posix_disk_buffer_prev;
463: }
464:
465: /* add this buffer to the front of the list: */
466: buffer->tme_posix_disk_buffer_prev
467: = &posix_disk->tme_posix_disk_buffers;
468: buffer->tme_posix_disk_buffer_next
469: = posix_disk->tme_posix_disk_buffers;
470: if (buffer->tme_posix_disk_buffer_next != NULL) {
471: buffer->tme_posix_disk_buffer_next->tme_posix_disk_buffer_prev
472: = &buffer->tme_posix_disk_buffer_next;
473: }
474: *buffer->tme_posix_disk_buffer_prev
475: = buffer;
476:
477: /* return the desired pointer into the buffer: */
478: *_buffer
479: = (buffer->tme_posix_disk_buffer_data
480: + (pos_least
481: - buffer->tme_posix_disk_buffer_pos));
482:
483: return (TME_OK);
484: #undef pos_least
485: #undef pos_most
486: #undef data
487: #undef size
488: #undef size_agg
489: }
490:
491: /* this returns a read buffer: */
492: static int
493: _tme_posix_disk_read(struct tme_disk_connection *conn_disk,
494: const union tme_value64 *pos,
495: unsigned long size,
496: const tme_uint8_t **_buffer)
497: {
498: struct tme_posix_disk *posix_disk;
499: tme_uint8_t *buffer;
500: int rc;
501:
502: /* recover our data structure: */
503: posix_disk = (struct tme_posix_disk *) conn_disk->tme_disk_connection.tme_connection_element->tme_element_private;
504:
505: /* lock the mutex: */
506: tme_mutex_lock(&posix_disk->tme_posix_disk_mutex);
507:
508: /* get the buffer: */
509: rc = _tme_posix_disk_buffer_get(posix_disk,
510: pos,
511: size,
512: TRUE,
513: &buffer);
514: assert (rc == TME_OK);
515:
516: /* unlock the mutex: */
517: tme_mutex_unlock(&posix_disk->tme_posix_disk_mutex);
518:
519: /* return the buffer: */
520: *_buffer = buffer;
521: return (TME_OK);
522: }
523:
524: /* this returns a write buffer: */
525: static int
526: _tme_posix_disk_write(struct tme_disk_connection *conn_disk,
527: const union tme_value64 *pos,
528: unsigned long size,
529: tme_uint8_t **_buffer)
530: {
531: struct tme_posix_disk *posix_disk;
532: int rc;
533:
534: /* recover our data structure: */
535: posix_disk = (struct tme_posix_disk *) conn_disk->tme_disk_connection.tme_connection_element->tme_element_private;
536:
537: /* lock the mutex: */
538: tme_mutex_lock(&posix_disk->tme_posix_disk_mutex);
539:
540: /* get the buffer: */
541: rc = _tme_posix_disk_buffer_get(posix_disk,
542: pos,
543: size,
544: FALSE,
545: _buffer);
546: assert (rc == TME_OK);
547:
548: /* unlock the mutex: */
549: tme_mutex_unlock(&posix_disk->tme_posix_disk_mutex);
550:
551: return (TME_OK);
552: }
553:
554: /* the disk control handler: */
555: #ifdef HAVE_STDARG_H
556: static int _tme_posix_disk_control(struct tme_disk_connection *conn_disk,
557: unsigned int control,
558: ...)
559: #else /* HAVE_STDARG_H */
560: static int _tme_posix_disk_control(conn_disk, control, va_alist)
561: struct tme_disk_connection *conn_disk;
562: unsigned int control;
563: va_dcl
564: #endif /* HAVE_STDARG_H */
565: {
566: struct tme_posix_disk *posix_disk;
567:
568: /* recover our data structure: */
569: posix_disk = (struct tme_posix_disk *) conn_disk->tme_disk_connection.tme_connection_element->tme_element_private;
570:
571: /* lock the mutex: */
572: tme_mutex_lock(&posix_disk->tme_posix_disk_mutex);
573:
574: /* unlock the mutex: */
575: tme_mutex_unlock(&posix_disk->tme_posix_disk_mutex);
576:
577: return (TME_OK);
578: }
579:
580: /* this breaks a posix disk connection: */
581: static int
582: _tme_posix_disk_connection_break(struct tme_connection *conn,
583: unsigned int state)
584: {
585: abort();
586: }
587:
588: /* this makes a posix disk connection: */
589: static int
590: _tme_posix_disk_connection_make(struct tme_connection *conn,
591: unsigned int state)
592: {
593: struct tme_posix_disk *posix_disk;
594: struct tme_disk_connection *conn_disk;
595:
596: /* recover our data structure: */
597: posix_disk = (struct tme_posix_disk *) conn->tme_connection_element->tme_element_private;
598:
599: /* both sides must be disk connections: */
600: assert(conn->tme_connection_type == TME_CONNECTION_DISK);
601: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_DISK);
602:
603: /* we're always set up to answer calls across the connection,
604: so we only have to do work when the connection has gone full,
605: namely taking the other side of the connection: */
606: if (state == TME_CONNECTION_FULL) {
607:
608: /* lock the mutex: */
609: tme_mutex_lock(&posix_disk->tme_posix_disk_mutex);
610:
611: /* save this connection to our list of connections: */
612: conn_disk = (struct tme_disk_connection *) conn->tme_connection_other;
613: posix_disk->tme_posix_disk_connection = conn_disk;
614:
615: /* unlock the mutex: */
616: tme_mutex_unlock(&posix_disk->tme_posix_disk_mutex);
617: }
618:
619: return (TME_OK);
620: }
621:
622: /* this makes a new connection side for a posix disk: */
623: static int
624: _tme_posix_disk_connections_new(struct tme_element *element,
625: const char * const *args,
626: struct tme_connection **_conns,
627: char **_output)
628: {
629: struct tme_posix_disk *posix_disk;
630: struct tme_disk_connection *conn_disk;
631: struct tme_connection *conn;
632:
633: /* recover our data structure: */
634: posix_disk = (struct tme_posix_disk *) element->tme_element_private;
635:
636: /* if we already have a connection, there's nothing to do: */
637: if (posix_disk->tme_posix_disk_connection != NULL) {
638: return (TME_OK);
639: }
640:
641: /* create our side of a disk connection: */
642: conn_disk = tme_new0(struct tme_disk_connection, 1);
643: conn = &conn_disk->tme_disk_connection;
644:
645: /* fill in the generic connection: */
646: conn->tme_connection_next = *_conns;
647: conn->tme_connection_type = TME_CONNECTION_DISK;
648: conn->tme_connection_score = tme_disk_connection_score;
649: conn->tme_connection_make = _tme_posix_disk_connection_make;
650: conn->tme_connection_break = _tme_posix_disk_connection_break;
651:
652: /* fill in the disk connection: */
653: (void) tme_value64_set(&conn_disk->tme_disk_connection_size,
654: posix_disk->tme_posix_disk_stat.st_size);
655: conn_disk->tme_disk_connection_read
656: = _tme_posix_disk_read;
657: if (!(posix_disk->tme_posix_disk_flags
658: & TME_POSIX_DISK_FLAG_RO)) {
659: conn_disk->tme_disk_connection_write
660: = _tme_posix_disk_write;
661: }
662: conn_disk->tme_disk_connection_release
663: = NULL;
664: conn_disk->tme_disk_connection_control
665: = _tme_posix_disk_control;
666:
667: /* return the connection side possibility: */
668: *_conns = conn;
669: return (TME_OK);
670: }
671:
672: /* the new posix disk function: */
673: TME_ELEMENT_SUB_NEW_DECL(tme_host_posix,disk) {
674: const char *filename;
675: int flags;
676: int fd;
677: unsigned long agg_pre;
678: unsigned long agg_post;
679: int buffers;
680: struct stat statbuf;
681: tme_uint8_t *block;
682: struct tme_posix_disk *posix_disk;
683: struct tme_posix_disk_buffer *buffer, **_prev;
684: int arg_i;
685: int usage;
686:
687: /* check our arguments: */
688: filename = NULL;
689: flags = 0;
690: arg_i = 1;
691: buffers = TME_POSIX_DISK_BUFFER_DEFAULT_COUNT;
692: agg_pre = TME_POSIX_DISK_BUFFER_DEFAULT_AGG_PRE;
693: agg_post = TME_POSIX_DISK_BUFFER_DEFAULT_AGG_POST;
694: usage = FALSE;
695:
696: /* loop reading our arguments: */
697: for (;;) {
698:
699: /* the filename: */
700: if (TME_ARG_IS(args[arg_i], "file")
701: && args[arg_i + 1] != NULL
702: && filename == NULL) {
703: filename = args[arg_i + 1];
704: arg_i += 2;
705: }
706:
707: /* the read-only flag: */
708: else if (TME_ARG_IS(args[arg_i], "read-only")) {
709: flags |= TME_POSIX_DISK_FLAG_RO;
710: arg_i++;
711: }
712:
713: /* the buffers count: */
714: else if (TME_ARG_IS(args[arg_i + 0], "buffers")
715: && args[arg_i + 1] != NULL
716: && (buffers = atoi(args[arg_i + 1])) > 0) {
717: arg_i += 2;
718: }
719:
720: /* the read-behind value, also called the aggregate-pre: */
721: else if (TME_ARG_IS(args[arg_i + 0], "read-behind")) {
722: agg_pre = tme_bus_addr_parse_any(args[arg_i + 1], &usage);
723: if (usage) {
724: break;
725: }
726: arg_i += 2;
727: }
728:
729: /* the read-ahead value, also called the aggregate-post: */
730: else if (TME_ARG_IS(args[arg_i + 0], "read-ahead")) {
731: agg_post = tme_bus_addr_parse_any(args[arg_i + 1], &usage);
732: if (usage) {
733: break;
734: }
735: arg_i += 2;
736: }
737:
738: /* if we've run out of arguments: */
739: else if (args[arg_i + 0] == NULL) {
740:
741: /* we must have been given a filename: */
742: if (filename == NULL) {
743: usage = TRUE;
744: }
745: break;
746: }
747:
748: /* this is a bad argument: */
749: else {
750: tme_output_append_error(_output,
751: "%s %s",
752: args[arg_i],
753: _("unexpected"));
754: usage = TRUE;
755: break;
756: }
757: }
758:
759: if (usage) {
760: tme_output_append_error(_output,
761: "%s %s file %s [read-only] [buffers %s] [read-behind %s] [read-ahead %s]",
762: _("usage:"),
763: args[0],
764: _("FILENAME"),
765: _("BUFFER-COUNT"),
766: _("BYTE-COUNT"),
767: _("BYTE-COUNT"));
768: return (EINVAL);
769: }
770:
771: /* open the file: */
772: fd = open(filename, ((flags
773: & TME_POSIX_DISK_FLAG_RO)
774: ? O_RDONLY
775: : O_RDWR));
776: if (fd < 0) {
777: tme_output_append_error(_output,
778: "%s",
779: filename);
780: return (errno);
781: }
782:
783: /* stat the file: */
784: if (fstat(fd, &statbuf) < 0) {
785: tme_output_append_error(_output,
786: "%s",
787: filename);
788: close(fd);
789: return (errno);
790: }
791:
792: /* we will handle a character device, but not a block device: */
793: if (S_ISBLK(statbuf.st_mode)) {
794: tme_output_append_error(_output,
795: "%s",
796: filename);
797: close(fd);
798: return (EINVAL);
799: }
800:
801: /* if this is a character device, determine its block size: */
802: statbuf.st_blksize = 1;
803: if (S_ISCHR(statbuf.st_mode)) {
804:
805: /* allocate space for the block: */
806: block = tme_new(tme_uint8_t, statbuf.st_blksize);
807:
808: /* loop trying to read a block at offset zero, doubling the block
809: size until we succeed: */
810: for (; statbuf.st_blksize <= TME_POSIX_DISK_BLOCK_SIZE_MAX; ) {
811:
812: /* do the read: */
813: if (read(fd, block, statbuf.st_blksize) >= 0) {
814: break;
815: }
816:
817: /* seek back to the beginning: */
818: if (lseek(fd, 0, SEEK_SET) < 0) {
819: tme_free(block);
820: tme_output_append_error(_output,
821: "%s",
822: filename);
823: close(fd);
824: return (errno);
825: }
826:
827: /* resize the block: */
828: statbuf.st_blksize <<= 1;
829: block = tme_renew(tme_uint8_t, block, statbuf.st_blksize);
830: }
831:
832: /* free the block: */
833: tme_free(block);
834:
835: /* if we failed: */
836: if (statbuf.st_blksize > TME_POSIX_DISK_BLOCK_SIZE_MAX) {
837: tme_output_append_error(_output,
838: "%s",
839: filename);
840: close(fd);
841: return (EINVAL);
842: }
843: }
844:
845: /* start the disk structure: */
846: posix_disk = tme_new0(struct tme_posix_disk, 1);
847: posix_disk->tme_posix_disk_element = element;
848: tme_mutex_init(&posix_disk->tme_posix_disk_mutex);
849: posix_disk->tme_posix_disk_flags = flags;
850: posix_disk->tme_posix_disk_fd = fd;
851: posix_disk->tme_posix_disk_stat = statbuf;
852: posix_disk->tme_posix_disk_buffer_agg_pre = agg_pre;
853: posix_disk->tme_posix_disk_buffer_agg_post = agg_post;
854:
855: /* allocate the buffers: */
856: for (_prev = &posix_disk->tme_posix_disk_buffers;
857: buffers-- > 0;
858: _prev = &buffer->tme_posix_disk_buffer_next) {
859: buffer = tme_new0(struct tme_posix_disk_buffer, 1);
860: buffer->tme_posix_disk_buffer_prev = _prev;
861: *buffer->tme_posix_disk_buffer_prev = buffer;
862: }
863: *_prev = NULL;
864:
865: /* fill the element: */
866: element->tme_element_private = posix_disk;
867: element->tme_element_connections_new = _tme_posix_disk_connections_new;
868:
869: return (TME_OK);
870: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.