ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libeio/eio.c
(Generate patch)

Comparing libeio/eio.c (file contents):
Revision 1.93 by root, Mon Jul 18 01:27:03 2011 UTC vs.
Revision 1.95 by root, Tue Jul 19 04:56:43 2011 UTC

… …
71#endif 71#endif
72#ifndef ELOOP 72#ifndef ELOOP
73# define ELOOP EDOM 73# define ELOOP EDOM
74#endif 74#endif
75 75
76#if !defined(ENOTSOCK) && defined(WSAENOTSOCK)
77# define ENOTSOCK WSAENOTSOCK
78#endif
79
76static void eio_destroy (eio_req *req); 80static void eio_destroy (eio_req *req);
77 81
78#ifndef EIO_FINISH 82#ifndef EIO_FINISH
79# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0 83# define EIO_FINISH(req) ((req)->finish) && !EIO_CANCELLED (req) ? (req)->finish (req) : 0
80#endif 84#endif
… …
103 #undef PAGESIZE 107 #undef PAGESIZE
104 #define PAGESIZE 4096 /* GetSystemInfo? */ 108 #define PAGESIZE 4096 /* GetSystemInfo? */
105 109
106 #ifdef EIO_STRUCT_STATI64 110 #ifdef EIO_STRUCT_STATI64
107 #define stat(path,buf) _stati64 (path,buf) 111 #define stat(path,buf) _stati64 (path,buf)
108 #define fstat(fd,buf) _fstati64 (path,buf) 112 #define fstat(fd,buf) _fstati64 (fd,buf)
109 #endif 113 #endif
110 #define lstat(path,buf) stat (path,buf) 114 #define lstat(path,buf) stat (path,buf)
111 #define fsync(fd) (FlushFileBuffers ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1)) 115 #define fsync(fd) (FlushFileBuffers ((HANDLE)EIO_FD_TO_WIN32_HANDLE (fd)) ? 0 : EIO_ERRNO (EBADF, -1))
112 #define mkdir(path,mode) _mkdir (path) 116 #define mkdir(path,mode) _mkdir (path)
113 #define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1)) 117 #define link(old,neu) (CreateHardLink (neu, old, 0) ? 0 : EIO_ERRNO (ENOENT, -1))
… …
233 237
234/* buffer size for various temporary buffers */ 238/* buffer size for various temporary buffers */
235#define EIO_BUFSIZE 65536 239#define EIO_BUFSIZE 65536
236 240
237#define dBUF \ 241#define dBUF \
238 char *eio_buf; \
239 ETP_WORKER_LOCK (self); \
240 self->dbuf = eio_buf = malloc (EIO_BUFSIZE); \ 242 char *eio_buf = malloc (EIO_BUFSIZE); \
241 ETP_WORKER_UNLOCK (self); \
242 errno = ENOMEM; \ 243 errno = ENOMEM; \
243 if (!eio_buf) \ 244 if (!eio_buf) \
244 return -1; 245 return -1
246
247#define FUBd \
248 free (eio_buf)
245 249
246#define EIO_TICKS ((1000000 + 1023) >> 10) 250#define EIO_TICKS ((1000000 + 1023) >> 10)
247 251
248#define ETP_PRI_MIN EIO_PRI_MIN 252#define ETP_PRI_MIN EIO_PRI_MIN
249#define ETP_PRI_MAX EIO_PRI_MAX 253#define ETP_PRI_MAX EIO_PRI_MAX
… …
254#define ETP_DESTROY(req) eio_destroy (req) 258#define ETP_DESTROY(req) eio_destroy (req)
255static int eio_finish (eio_req *req); 259static int eio_finish (eio_req *req);
256#define ETP_FINISH(req) eio_finish (req) 260#define ETP_FINISH(req) eio_finish (req)
257static void eio_execute (struct etp_worker *self, eio_req *req); 261static void eio_execute (struct etp_worker *self, eio_req *req);
258#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req) 262#define ETP_EXECUTE(wrk,req) eio_execute (wrk,req)
259
260#define ETP_WORKER_CLEAR(req) \
261 if (wrk->dbuf) \
262 { \
263 free (wrk->dbuf); \
264 wrk->dbuf = 0; \
265 }
266
267#define ETP_WORKER_COMMON \
268 void *dbuf;
269 263
270/*****************************************************************************/ 264/*****************************************************************************/
271 265
272#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1) 266#define ETP_NUM_PRI (ETP_PRI_MAX - ETP_PRI_MIN + 1)
273 267
… …
315 xthread_t tid; 309 xthread_t tid;
316 310
317 /* locked by reslock, reqlock or wrklock */ 311 /* locked by reslock, reqlock or wrklock */
318 ETP_REQ *req; /* currently processed request */ 312 ETP_REQ *req; /* currently processed request */
319 313
314#ifdef ETP_WORKER_COMMON
320 ETP_WORKER_COMMON 315 ETP_WORKER_COMMON
316#endif
321} etp_worker; 317} etp_worker;
322 318
323static etp_worker wrk_first; /* NOT etp */ 319static etp_worker wrk_first; /* NOT etp */
324 320
325#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock) 321#define ETP_WORKER_LOCK(wrk) X_LOCK (wrklock)
… …
328/* worker threads management */ 324/* worker threads management */
329 325
330static void ecb_cold 326static void ecb_cold
331etp_worker_clear (etp_worker *wrk) 327etp_worker_clear (etp_worker *wrk)
332{ 328{
333 ETP_WORKER_CLEAR (wrk);
334} 329}
335 330
336static void ecb_cold 331static void ecb_cold
337etp_worker_free (etp_worker *wrk) 332etp_worker_free (etp_worker *wrk)
338{ 333{
… …
997 pread (fd, eio_buf, len, offset); 992 pread (fd, eio_buf, len, offset);
998 offset += len; 993 offset += len;
999 todo -= len; 994 todo -= len;
1000 } 995 }
1001 996
997 FUBd;
998
1002 errno = 0; 999 errno = 0;
1003 return count; 1000 return count;
1004} 1001}
1005 1002
1006#endif 1003#endif
1007 1004
1008/* sendfile always needs emulation */ 1005/* sendfile always needs emulation */
1009static eio_ssize_t 1006static eio_ssize_t
1010eio__sendfile (int ofd, int ifd, off_t offset, size_t count, etp_worker *self) 1007eio__sendfile (int ofd, int ifd, off_t offset, size_t count)
1011{ 1008{
1012 eio_ssize_t written = 0; 1009 eio_ssize_t written = 0;
1013 eio_ssize_t res; 1010 eio_ssize_t res;
1014 1011
1015 if (!count) 1012 if (!count)
… …
1151 1148
1152 offset += cnt; 1149 offset += cnt;
1153 res += cnt; 1150 res += cnt;
1154 count -= cnt; 1151 count -= cnt;
1155 } 1152 }
1153
1154 FUBd;
1156 } 1155 }
1157 1156
1158 return res; 1157 return res;
1159} 1158}
1160 1159
… …
2025 case EIO_WRITE: req->result = req->offs >= 0 2024 case EIO_WRITE: req->result = req->offs >= 0
2026 ? pwrite (req->int1, req->ptr2, req->size, req->offs) 2025 ? pwrite (req->int1, req->ptr2, req->size, req->offs)
2027 : write (req->int1, req->ptr2, req->size); break; 2026 : write (req->int1, req->ptr2, req->size); break;
2028 2027
2029 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break; 2028 case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
2030 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size, self); break; 2029 case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
2031 2030
2032 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2031 case EIO_STAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2033 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2032 req->result = stat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
2034 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT)); 2033 case EIO_LSTAT: ALLOC (sizeof (EIO_STRUCT_STAT));
2035 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break; 2034 req->result = lstat (req->ptr1, (EIO_STRUCT_STAT *)req->ptr2); break;
… …
2425/* misc garbage */ 2424/* misc garbage */
2426 2425
2427eio_ssize_t 2426eio_ssize_t
2428eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count) 2427eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)
2429{ 2428{
2430 etp_worker wrk;
2431 eio_ssize_t ret;
2432
2433 wrk.dbuf = 0;
2434
2435 ret = eio__sendfile (ofd, ifd, offset, count, &wrk); 2429 return eio__sendfile (ofd, ifd, offset, count);
2436
2437 if (wrk.dbuf)
2438 free (wrk.dbuf);
2439
2440 return ret;
2441} 2430}
2442 2431

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines