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

Comparing libeio/eio.c (file contents):
Revision 1.29 by root, Wed Apr 22 11:04:49 2009 UTC vs.
Revision 1.37 by root, Fri Jun 12 16:48:08 2009 UTC

1/* 1/*
2 * libeio implementation 2 * libeio implementation
3 * 3 *
4 * Copyright (c) 2007,2008 Marc Alexander Lehmann <libeio@schmorp.de> 4 * Copyright (c) 2007,2008,2009 Marc Alexander Lehmann <libeio@schmorp.de>
5 * All rights reserved. 5 * All rights reserved.
6 * 6 *
7 * Redistribution and use in source and binary forms, with or without modifica- 7 * Redistribution and use in source and binary forms, with or without modifica-
8 * tion, are permitted provided that the following conditions are met: 8 * tion, are permitted provided that the following conditions are met:
9 * 9 *
68#endif 68#endif
69 69
70#ifdef _WIN32 70#ifdef _WIN32
71 71
72 /*doh*/ 72 /*doh*/
73
74#else 73#else
75 74
76# include "config.h" 75# include "config.h"
77# include <sys/time.h> 76# include <sys/time.h>
78# include <sys/select.h> 77# include <sys/select.h>
78# include <sys/mman.h>
79# include <unistd.h> 79# include <unistd.h>
80# include <utime.h> 80# include <utime.h>
81# include <signal.h> 81# include <signal.h>
82# include <dirent.h> 82# include <dirent.h>
83
84/* POSIX_SOURCE is useless on bsd's, and XOPEN_SOURCE is unreliable there, too */
85# if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
86# define _DIRENT_HAVE_D_TYPE /* sigh */
87# define D_INO(de) (de)->d_fileno
88# define D_NAMLEN(de) (de)->d_namlen
89# elif defined(__linux) || defined(d_ino) || _XOPEN_SOURCE >= 600
90# define D_INO(de) (de)->d_ino
91# endif
92
93#ifdef _D_EXACT_NAMLEN
94# undef D_NAMLEN
95# define D_NAMLEN(de) _D_EXACT_NAMLEN (de)
96#endif
97
98# ifdef _DIRENT_HAVE_D_TYPE
99# define D_TYPE(de) (de)->d_type
100# endif
83 101
84# ifndef EIO_STRUCT_DIRENT 102# ifndef EIO_STRUCT_DIRENT
85# define EIO_STRUCT_DIRENT struct dirent 103# define EIO_STRUCT_DIRENT struct dirent
86# endif 104# endif
87 105
100# else 118# else
101# error sendfile support requested but not available 119# error sendfile support requested but not available
102# endif 120# endif
103#endif 121#endif
104 122
123#ifndef D_TYPE
124# define D_TYPE(de) 0
125#endif
126#ifndef D_INO
127# define D_INO(de) 0
128#endif
129#ifndef D_NAMLEN
130# define D_NAMLEN(de) strlen ((de)->d_name)
131#endif
132
105/* number of seconds after which an idle threads exit */ 133/* number of seconds after which an idle threads exit */
106#define IDLE_TIMEOUT 10 134#define IDLE_TIMEOUT 10
107 135
108/* used for struct dirent, AIX doesn't provide it */ 136/* used for struct dirent, AIX doesn't provide it */
109#ifndef NAME_MAX 137#ifndef NAME_MAX
159 if (wrk->dirp) \ 187 if (wrk->dirp) \
160 { \ 188 { \
161 closedir (wrk->dirp); \ 189 closedir (wrk->dirp); \
162 wrk->dirp = 0; \ 190 wrk->dirp = 0; \
163 } 191 }
192
164#define ETP_WORKER_COMMON \ 193#define ETP_WORKER_COMMON \
165 void *dbuf; \ 194 void *dbuf; \
166 DIR *dirp; 195 DIR *dirp;
167 196
168/*****************************************************************************/ 197/*****************************************************************************/
771 800
772 X_LOCK (preadwritelock); 801 X_LOCK (preadwritelock);
773 ooffset = lseek (fd, 0, SEEK_CUR); 802 ooffset = lseek (fd, 0, SEEK_CUR);
774 lseek (fd, offset, SEEK_SET); 803 lseek (fd, offset, SEEK_SET);
775 res = write (fd, buf, count); 804 res = write (fd, buf, count);
776 lseek (fd, offset, SEEK_SET); 805 lseek (fd, ooffset, SEEK_SET);
777 X_UNLOCK (preadwritelock); 806 X_UNLOCK (preadwritelock);
778 807
779 return res; 808 return res;
780} 809}
781#endif 810#endif
961 } 990 }
962 991
963 return res; 992 return res;
964} 993}
965 994
995static signed char
996eio_dent_cmp (const eio_dirent *a, const eio_dirent *b)
997{
998 return b->score - a->score ? b->score - a->score /* works because our signed char is always 0..100 */
999 : a->inode < b->inode ? -1 : a->inode > b->inode ? 1 : 0;
1000}
1001
1002#define EIO_QSORT_CUTOFF 20 /* quite high, but performs well on many filesystems */
1003
1004static void
1005eio_dent_sort (eio_dirent *dents, int size)
1006{
1007 /* should be good for 2**31 entries */
1008 struct rng { int l, r; } rng [32];
1009 int i, j;
1010
1011 i = 0;
1012 rng[0].l = 0;
1013 rng[0].r = size;
1014
1015 while (expect_true (i >= 0))
1016 {
1017 int L = rng [i].l;
1018 int R = rng [i].r - 1;
1019
1020 if (expect_false (L + EIO_QSORT_CUTOFF < R))
1021 {
1022 eio_dirent piv = dents [L];
1023
1024 while (L < R)
1025 {
1026 while (eio_dent_cmp (&dents [R], &piv) >= 0 && L < R)
1027 --R;
1028
1029 if (L < R)
1030 dents [L++] = dents [R];
1031
1032 while (eio_dent_cmp (&dents [L], &piv) <= 0 && L < R)
1033 ++L;
1034
1035 if (L < R)
1036 dents [R--] = dents [L];
1037 }
1038
1039 dents [L] = piv;
1040
1041 ++i;
1042 rng [i].l = L + 1;
1043 rng [i].r = rng [i - 1].r;
1044 rng [i - 1].r = L;
1045
1046 if (rng [i].r - rng [i].l > rng [i - 1].r - rng [i - 1].l)
1047 {
1048 struct rng t;
1049
1050 t = rng [i]; rng [i] = rng [i - 1]; rng [i - 1] = t;
1051 }
1052 }
1053 else
1054 --i;
1055 }
1056
1057 /* use a simple insertion sort at the end */
1058 for (i = 1; i < size; ++i)
1059 {
1060 eio_dirent value = dents [i];
1061
1062 for (j = i - 1; j >= 0 && eio_dent_cmp (&dents [j], &value) > 0; --j)
1063 dents [j + 1] = dents [j];
1064
1065 dents [j + 1] = value;
1066 }
1067}
1068
966/* read a full directory */ 1069/* read a full directory */
967static void 1070static void
968eio__scandir (eio_req *req, etp_worker *self) 1071eio__scandir (eio_req *req, etp_worker *self)
969{ 1072{
970 DIR *dirp; 1073 DIR *dirp;
971 EIO_STRUCT_DIRENT *entp; 1074 EIO_STRUCT_DIRENT *entp;
972 char *name, *names; 1075 char *name, *names;
973 int memlen = 4096; 1076 int namesalloc = 4096;
974 int memofs = 0; 1077 int namesoffs = 0;
1078 int flags = req->int1;
1079 eio_dirent *dents = 0;
1080 int dentalloc = 128;
975 int res = 0; 1081 int dentoffs = 0;
1082
1083 req->result = -1;
1084
1085 if (!(flags & EIO_READDIR_DENTS))
1086 flags &= ~(EIO_READDIR_DIRS_FIRST | EIO_READDIR_STAT_ORDER);
976 1087
977 X_LOCK (wrklock); 1088 X_LOCK (wrklock);
978 /* the corresponding closedir is in ETP_WORKER_CLEAR */ 1089 /* the corresponding closedir is in ETP_WORKER_CLEAR */
979 self->dirp = dirp = opendir (req->ptr1); 1090 self->dirp = dirp = opendir (req->ptr1);
980 req->flags |= EIO_FLAG_PTR2_FREE; 1091 req->flags |= EIO_FLAG_PTR1_FREE | EIO_FLAG_PTR2_FREE;
981 req->ptr2 = names = malloc (memlen); 1092 req->ptr1 = names = malloc (namesalloc);
1093 req->ptr2 = dents = flags ? malloc (dentalloc * sizeof (eio_dirent)) : 0;
982 X_UNLOCK (wrklock); 1094 X_UNLOCK (wrklock);
983 1095
984 if (dirp && names) 1096 if (dirp && names && (!flags || dents))
985 for (;;) 1097 for (;;)
986 { 1098 {
987 errno = 0; 1099 errno = 0;
988 entp = readdir (dirp); 1100 entp = readdir (dirp);
989 1101
990 if (!entp) 1102 if (!entp)
1103 {
1104 if (errno)
1105 break;
1106
1107 /* sort etc. */
1108 req->int1 = flags;
1109 req->result = dentoffs;
1110
1111 if (dents)
1112 {
1113 eio_dirent *ent = dents + dentoffs;
1114
1115 while (ent > dents)
1116 (--ent)->name = names + (size_t)ent->name;
1117 }
1118
1119 if (flags & EIO_READDIR_STAT_ORDER
1120 || !(~flags & (EIO_READDIR_DIRS_FIRST | EIO_READDIR_FOUND_UNKNOWN)))
1121 eio_dent_sort (dents, dentoffs); /* score depends of DIRS_FIRST */
1122 else if (flags & EIO_READDIR_DIRS_FIRST)
1123 {
1124 /* in this case, all is known, and we just put dirs first and sort them */
1125 eio_dirent *ent = dents + dentoffs;
1126 eio_dirent *dir = dents;
1127
1128 /* now move dirs to the front, and non-dirs to the back */
1129 /* by walking from both sides and swapping if necessary */
1130 while (ent > dir)
1131 {
1132 if (dir->type == DT_DIR)
1133 ++dir;
1134 else
1135 {
1136 --ent;
1137
1138 if (ent->type == DT_DIR)
1139 {
1140 eio_dirent tmp = *dir;
1141 *dir = *ent;
1142 *ent = tmp;
1143
1144 ++dir;
1145 }
1146 }
1147 }
1148
1149 /* now sort the dirs only */
1150 eio_dent_sort (dents, dir - dents);
1151 }
1152
1153 /* only provide the names array unless DENTS is specified */
1154 if (!(flags & EIO_READDIR_DENTS))
1155 {
1156 X_LOCK (wrklock);
1157 assert (!dents);
1158 req->ptr1 = 0;
1159 req->ptr2 = names;
1160 X_UNLOCK (wrklock);
1161 }
1162
991 break; 1163 break;
1164 }
992 1165
1166 /* now add the entry to our list(s) */
993 name = entp->d_name; 1167 name = entp->d_name;
994 1168
1169 /* skip . and .. entries */
995 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2]))) 1170 if (name [0] != '.' || (name [1] && (name [1] != '.' || name [2])))
996 { 1171 {
997 int len = strlen (name) + 1; 1172 int len = D_NAMLEN (entp) + 1;
998 1173
999 res++; 1174 while (expect_false (namesoffs + len > namesalloc))
1000
1001 while (memofs + len > memlen)
1002 { 1175 {
1003 memlen *= 2; 1176 namesalloc *= 2;
1004 X_LOCK (wrklock); 1177 X_LOCK (wrklock);
1005 req->ptr2 = names = realloc (names, memlen); 1178 req->ptr1 = names = realloc (names, namesalloc);
1006 X_UNLOCK (wrklock); 1179 X_UNLOCK (wrklock);
1007 1180
1008 if (!names) 1181 if (!names)
1009 break; 1182 break;
1010 } 1183 }
1011 1184
1012 memcpy (names + memofs, name, len); 1185 memcpy (names + namesoffs, name, len);
1186
1187 if (dents)
1188 {
1189 struct eio_dirent *ent;
1190
1191 if (expect_false (dentoffs == dentalloc))
1192 {
1193 dentalloc *= 2;
1194 X_LOCK (wrklock);
1195 req->ptr2 = dents = realloc (dents, dentalloc * sizeof (eio_dirent));
1196 X_UNLOCK (wrklock);
1197
1198 if (!dents)
1199 break;
1200 }
1201
1202 ent = dents + dentoffs;
1203
1204 ent->name = (char *)(size_t)namesoffs; /* rather dirtily we store the offset in the pointer */
1205 ent->namelen = len - 1;
1206 ent->inode = D_INO (entp);
1207
1208 switch (D_TYPE (entp))
1209 {
1210 default:
1211 ent->type = EIO_DT_UNKNOWN;
1212 flags |= EIO_READDIR_FOUND_UNKNOWN;
1213 break;
1214
1215 #ifdef DT_FIFO
1216 case DT_FIFO: ent->type = EIO_DT_FIFO; break;
1217 #endif
1218 #ifdef DT_CHR
1219 case DT_CHR: ent->type = EIO_DT_CHR; break;
1220 #endif
1221 #ifdef DT_MPC
1222 case DT_MPC: ent->type = EIO_DT_MPC; break;
1223 #endif
1224 #ifdef DT_DIR
1225 case DT_DIR: ent->type = EIO_DT_DIR; break;
1226 #endif
1227 #ifdef DT_NAM
1228 case DT_NAM: ent->type = EIO_DT_NAM; break;
1229 #endif
1230 #ifdef DT_BLK
1231 case DT_BLK: ent->type = EIO_DT_BLK; break;
1232 #endif
1233 #ifdef DT_MPB
1234 case DT_MPB: ent->type = EIO_DT_MPB; break;
1235 #endif
1236 #ifdef DT_REG
1237 case DT_REG: ent->type = EIO_DT_REG; break;
1238 #endif
1239 #ifdef DT_NWK
1240 case DT_NWK: ent->type = EIO_DT_NWK; break;
1241 #endif
1242 #ifdef DT_CMP
1243 case DT_CMP: ent->type = EIO_DT_CMP; break;
1244 #endif
1245 #ifdef DT_LNK
1246 case DT_LNK: ent->type = EIO_DT_LNK; break;
1247 #endif
1248 #ifdef DT_SOCK
1249 case DT_SOCK: ent->type = EIO_DT_SOCK; break;
1250 #endif
1251 #ifdef DT_DOOR
1252 case DT_DOOR: ent->type = EIO_DT_DOOR; break;
1253 #endif
1254 #ifdef DT_WHT
1255 case DT_WHT: ent->type = EIO_DT_WHT; break;
1256 #endif
1257 }
1258
1259 ent->score = 0;
1260
1261 if (flags & EIO_READDIR_DIRS_FIRST)
1262 {
1263 if (ent->type == EIO_DT_UNKNOWN)
1264 {
1265 if (*name == '.') /* leading dots are likely directories, and, in any case, rare */
1266 ent->score = 98;
1267 else if (!strchr (name, '.')) /* absense of dots indicate likely dirs */
1268 ent->score = len <= 2 ? len + 6 : len <= 4 ? 5 : len <= 7 ? 4 : 1; /* shorter == more likely dir, but avoid too many classes */
1269 }
1270 else if (ent->type == EIO_DT_DIR)
1271 ent->score = 100;
1272 }
1273 }
1274
1013 memofs += len; 1275 namesoffs += len;
1276 ++dentoffs;
1277 }
1278
1279 if (EIO_CANCELLED (req))
1280 {
1281 errno = ECANCELED;
1282 break;
1014 } 1283 }
1015 } 1284 }
1016
1017 if (errno)
1018 res = -1;
1019
1020 req->result = res;
1021} 1285}
1022 1286
1023#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO) 1287#if !(_POSIX_MAPPED_FILES && _POSIX_SYNCHRONIZED_IO)
1024# undef msync 1288# undef msync
1025# define msync(a,b,c) ((errno = ENOSYS), -1) 1289# define msync(a,b,c) ((errno = ENOSYS), -1)
1445eio_req *eio_rmdir (const char *path, int pri, eio_cb cb, void *data) 1709eio_req *eio_rmdir (const char *path, int pri, eio_cb cb, void *data)
1446{ 1710{
1447 return eio__1path (EIO_RMDIR, path, pri, cb, data); 1711 return eio__1path (EIO_RMDIR, path, pri, cb, data);
1448} 1712}
1449 1713
1450eio_req *eio_readdir (const char *path, int pri, eio_cb cb, void *data) 1714eio_req *eio_readdir (const char *path, int flags, int pri, eio_cb cb, void *data)
1451{ 1715{
1452 return eio__1path (EIO_READDIR, path, pri, cb, data); 1716 REQ (EIO_READDIR); PATH; req->int1 = flags; SEND;
1453} 1717}
1454 1718
1455eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data) 1719eio_req *eio_mknod (const char *path, mode_t mode, dev_t dev, int pri, eio_cb cb, void *data)
1456{ 1720{
1457 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND; 1721 REQ (EIO_MKNOD); PATH; req->int2 = (long)mode; req->int3 = (long)dev; SEND;
1546/* misc garbage */ 1810/* misc garbage */
1547 1811
1548ssize_t eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count) 1812ssize_t eio_sendfile_sync (int ofd, int ifd, off_t offset, size_t count)
1549{ 1813{
1550 etp_worker wrk; 1814 etp_worker wrk;
1815 ssize_t ret;
1551 1816
1552 wrk.dbuf = 0; 1817 wrk.dbuf = 0;
1553 1818
1554 eio__sendfile (ofd, ifd, offset, count, &wrk); 1819 ret = eio__sendfile (ofd, ifd, offset, count, &wrk);
1555 1820
1556 if (wrk.dbuf) 1821 if (wrk.dbuf)
1557 free (wrk.dbuf); 1822 free (wrk.dbuf);
1558}
1559 1823
1824 return ret;
1825}
1826

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines