| blob | 4760ceaef49f76853c17376429ef37da2bc2dfb3 |
1 This is a backport of the following sqlite changes:
3 1. http://sqlite.org/src/ci/9109128cb5
4 2. http://sqlite.org/src/ci/713b1b7dc1
5 3. http://sqlite.org/src/ci/8d1b5c3ac0
6 4. http://sqlite.org/src/ci/6b236069e1
7 5. http://sqlite.org/src/ci/880b51150a
9 which are needed for experiments with using unpatched sqlite.
10 If you hit a merge conflict on this file it is most likely
11 that you've upgraded to version of sqlite that includes those patches.
12 diff --git a/third_party/sqlite/amalgamation/sqlite3.c b/third_party/sqlite/amalgamation/sqlite3.c
13 index 3e794a9..73ff15f 100644
14 --- a/third_party/sqlite/amalgamation/sqlite3.c
15 +++ b/third_party/sqlite/amalgamation/sqlite3.c
16 @@ -24144,7 +24144,6 @@ struct unixFile {
17 sqlite3_io_methods const *pMethod; /* Always the first entry */
18 unixInodeInfo *pInode; /* Info about locks on this inode */
19 int h; /* The file descriptor */
20 - int dirfd; /* File descriptor for the directory */
21 unsigned char eFileLock; /* The type of lock held on this fd */
22 unsigned char ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */
23 int lastErrno; /* The unix errno from last I/O error */
24 @@ -24188,6 +24187,7 @@ struct unixFile {
25 */
26 #define UNIXFILE_EXCL 0x01 /* Connections from one process only */
27 #define UNIXFILE_RDONLY 0x02 /* Connection is read only */
28 +#define UNIXFILE_DIRSYNC 0x04 /* Directory sync needed */
30 /*
31 ** Include code that is common to all os_*.c files
32 @@ -24426,6 +24426,9 @@ SQLITE_API int sqlite3_open_file_count = 0;
33 #define threadid 0
34 #endif
36 +/* Forward reference */
37 +static int openDirectory(const char*, int*);
38 +
39 /*
40 ** Many system calls are accessed through pointer-to-functions so that
41 ** they may be overridden at runtime to facilitate fault injection during
42 @@ -24522,6 +24525,12 @@ static struct unix_syscall {
43 #endif
44 #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
46 + { "unlink", (sqlite3_syscall_ptr)unlink, 0 },
47 +#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)
48 +
49 + { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },
50 +#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)
51 +
52 }; /* End of the overrideable system calls */
54 /*
55 @@ -25876,10 +25885,6 @@ static int unixUnlock(sqlite3_file *id, int eFileLock){
56 */
57 static int closeUnixFile(sqlite3_file *id){
58 unixFile *pFile = (unixFile*)id;
59 - if( pFile->dirfd>=0 ){
60 - robust_close(pFile, pFile->dirfd, __LINE__);
61 - pFile->dirfd=-1;
62 - }
63 if( pFile->h>=0 ){
64 robust_close(pFile, pFile->h, __LINE__);
65 pFile->h = -1;
66 @@ -25887,7 +25892,7 @@ static int closeUnixFile(sqlite3_file *id){
67 #if OS_VXWORKS
68 if( pFile->pId ){
69 if( pFile->isDelete ){
70 - unlink(pFile->pId->zCanonicalName);
71 + osUnlink(pFile->pId->zCanonicalName);
72 }
73 vxworksReleaseFileId(pFile->pId);
74 pFile->pId = 0;
75 @@ -26134,7 +26139,7 @@ static int dotlockUnlock(sqlite3_file *id, int eFileLock) {
77 /* To fully unlock the database, delete the lock file */
78 assert( eFileLock==NO_LOCK );
79 - if( unlink(zLockFile) ){
80 + if( osUnlink(zLockFile) ){
81 int rc = 0;
82 int tErrno = errno;
83 if( ENOENT != tErrno ){
84 @@ -27371,6 +27376,50 @@ static int full_fsync(int fd, int fullSync, int dataOnly){
85 }
87 /*
88 +** Open a file descriptor to the directory containing file zFilename.
89 +** If successful, *pFd is set to the opened file descriptor and
90 +** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
91 +** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
92 +** value.
93 +**
94 +** The directory file descriptor is used for only one thing - to
95 +** fsync() a directory to make sure file creation and deletion events
96 +** are flushed to disk. Such fsyncs are not needed on newer
97 +** journaling filesystems, but are required on older filesystems.
98 +**
99 +** This routine can be overridden using the xSetSysCall interface.
100 +** The ability to override this routine was added in support of the
101 +** chromium sandbox. Opening a directory is a security risk (we are
102 +** told) so making it overrideable allows the chromium sandbox to
103 +** replace this routine with a harmless no-op. To make this routine
104 +** a no-op, replace it with a stub that returns SQLITE_OK but leaves
105 +** *pFd set to a negative number.
106 +**
107 +** If SQLITE_OK is returned, the caller is responsible for closing
108 +** the file descriptor *pFd using close().
109 +*/
110 +static int openDirectory(const char *zFilename, int *pFd){
111 + int ii;
112 + int fd = -1;
113 + char zDirname[MAX_PATHNAME+1];
114 +
115 + sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
116 + for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
117 + if( ii>0 ){
118 + zDirname[ii] = '\0';
119 + fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
120 + if( fd>=0 ){
121 +#ifdef FD_CLOEXEC
122 + osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
123 +#endif
124 + OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
125 + }
126 + }
127 + *pFd = fd;
128 + return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
129 +}
130 +
131 +/*
132 ** Make sure all writes to a particular file are committed to disk.
133 **
134 ** If dataOnly==0 then both the file itself and its metadata (file
135 @@ -27410,28 +27459,21 @@ static int unixSync(sqlite3_file *id, int flags){
136 pFile->lastErrno = errno;
137 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
138 }
139 - if( pFile->dirfd>=0 ){
140 - OSTRACE(("DIRSYNC %-3d (have_fullfsync=%d fullsync=%d)\n", pFile->dirfd,
141 +
142 + /* Also fsync the directory containing the file if the DIRSYNC flag
143 + ** is set. This is a one-time occurrance. Many systems (examples: AIX)
144 + ** are unable to fsync a directory, so ignore errors on the fsync.
145 + */
146 + if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
147 + int dirfd;
148 + OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
149 HAVE_FULLFSYNC, isFullsync));
150 -#ifndef SQLITE_DISABLE_DIRSYNC
151 - /* The directory sync is only attempted if full_fsync is
152 - ** turned off or unavailable. If a full_fsync occurred above,
153 - ** then the directory sync is superfluous.
154 - */
155 - if( (!HAVE_FULLFSYNC || !isFullsync) && full_fsync(pFile->dirfd,0,0) ){
156 - /*
157 - ** We have received multiple reports of fsync() returning
158 - ** errors when applied to directories on certain file systems.
159 - ** A failed directory sync is not a big deal. So it seems
160 - ** better to ignore the error. Ticket #1657
161 - */
162 - /* pFile->lastErrno = errno; */
163 - /* return SQLITE_IOERR; */
164 + rc = osOpenDirectory(pFile->zPath, &dirfd);
165 + if( rc==SQLITE_OK && dirfd>=0 ){
166 + full_fsync(dirfd, 0, 0);
167 + robust_close(pFile, dirfd, __LINE__);
168 }
169 -#endif
170 - /* Only need to sync once, so close the directory when we are done */
171 - robust_close(pFile, pFile->dirfd, __LINE__);
172 - pFile->dirfd = -1;
173 + pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
174 }
175 return rc;
176 }
177 @@ -28255,7 +28297,7 @@ static int unixShmUnmap(
178 assert( pShmNode->nRef>0 );
179 pShmNode->nRef--;
180 if( pShmNode->nRef==0 ){
181 - if( deleteFlag && pShmNode->h>=0 ) unlink(pShmNode->zFilename);
182 + if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
183 unixShmPurge(pDbFd);
184 }
185 unixLeaveMutex();
186 @@ -28575,7 +28617,7 @@ void initUnixFile(sqlite3_file* file) {
187 int fillInUnixFile(
188 sqlite3_vfs *pVfs, /* Pointer to vfs object */
189 int h, /* Open file descriptor of file being opened */
190 - int dirfd, /* Directory file descriptor */
191 + int syncDir, /* True to sync directory on first sync */
192 sqlite3_file *pId, /* Write to the unixFile structure here */
193 const char *zFilename, /* Name of the file being opened */
194 int noLock, /* Omit locking if true */
195 @@ -28606,7 +28648,6 @@ int fillInUnixFile(
197 OSTRACE(("OPEN %-3d %s\n", h, zFilename));
198 pNew->h = h;
199 - pNew->dirfd = dirfd;
200 pNew->zPath = zFilename;
201 if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
202 pNew->ctrlFlags = UNIXFILE_EXCL;
203 @@ -28616,6 +28657,9 @@ int fillInUnixFile(
204 if( isReadOnly ){
205 pNew->ctrlFlags |= UNIXFILE_RDONLY;
206 }
207 + if( syncDir ){
208 + pNew->ctrlFlags |= UNIXFILE_DIRSYNC;
209 + }
211 #if OS_VXWORKS
212 pNew->pId = vxworksFindFileId(zFilename);
213 @@ -28742,13 +28786,12 @@ int fillInUnixFile(
214 if( rc!=SQLITE_OK ){
215 if( h>=0 ) robust_close(pNew, h, __LINE__);
216 h = -1;
217 - unlink(zFilename);
218 + osUnlink(zFilename);
219 isDelete = 0;
220 }
221 pNew->isDelete = isDelete;
222 #endif
223 if( rc!=SQLITE_OK ){
224 - if( dirfd>=0 ) robust_close(pNew, dirfd, __LINE__);
225 if( h>=0 ) robust_close(pNew, h, __LINE__);
226 }else{
227 pNew->pMethod = pLockingStyle;
228 @@ -28758,37 +28801,6 @@ int fillInUnixFile(
229 }
231 /*
232 -** Open a file descriptor to the directory containing file zFilename.
233 -** If successful, *pFd is set to the opened file descriptor and
234 -** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
235 -** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
236 -** value.
237 -**
238 -** If SQLITE_OK is returned, the caller is responsible for closing
239 -** the file descriptor *pFd using close().
240 -*/
241 -static int openDirectory(const char *zFilename, int *pFd){
242 - int ii;
243 - int fd = -1;
244 - char zDirname[MAX_PATHNAME+1];
245 -
246 - sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
247 - for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
248 - if( ii>0 ){
249 - zDirname[ii] = '\0';
250 - fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
251 - if( fd>=0 ){
252 -#ifdef FD_CLOEXEC
253 - osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
254 -#endif
255 - OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
256 - }
257 - }
258 - *pFd = fd;
259 - return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
260 -}
261 -
262 -/*
263 ** Return the name of a directory in which to put temporary files.
264 ** If no suitable temporary file directory can be found, return NULL.
265 */
266 @@ -29083,7 +29095,6 @@ static int unixOpen(
267 ){
268 unixFile *p = (unixFile *)pFile;
269 int fd = -1; /* File descriptor returned by open() */
270 - int dirfd = -1; /* Directory file descriptor */
271 int openFlags = 0; /* Flags to pass to open() */
272 int eType = flags&0xFFFFFF00; /* Type of file to open */
273 int noLock; /* True to omit locking primitives */
274 @@ -29102,7 +29113,7 @@ static int unixOpen(
275 ** a file-descriptor on the directory too. The first time unixSync()
276 ** is called the directory file descriptor will be fsync()ed and close()d.
277 */
278 - int isOpenDirectory = (isCreate && (
279 + int syncDir = (isCreate && (
280 eType==SQLITE_OPEN_MASTER_JOURNAL
281 || eType==SQLITE_OPEN_MAIN_JOURNAL
282 || eType==SQLITE_OPEN_WAL
283 @@ -29149,7 +29160,7 @@ static int unixOpen(
284 }
285 }else if( !zName ){
286 /* If zName is NULL, the upper layer is requesting a temp file. */
287 - assert(isDelete && !isOpenDirectory);
288 + assert(isDelete && !syncDir);
289 rc = unixGetTempname(MAX_PATHNAME+1, zTmpname);
290 if( rc!=SQLITE_OK ){
291 return rc;
292 @@ -29202,7 +29213,7 @@ static int unixOpen(
293 #if OS_VXWORKS
294 zPath = zName;
295 #else
296 - unlink(zName);
297 + osUnlink(zName);
298 #endif
299 }
300 #if SQLITE_ENABLE_LOCKING_STYLE
301 @@ -29211,19 +29222,6 @@ static int unixOpen(
302 }
303 #endif
305 - if( isOpenDirectory ){
306 - rc = openDirectory(zPath, &dirfd);
307 - if( rc!=SQLITE_OK ){
308 - /* It is safe to close fd at this point, because it is guaranteed not
309 - ** to be open on a database file. If it were open on a database file,
310 - ** it would not be safe to close as this would release any locks held
311 - ** on the file by this process. */
312 - assert( eType!=SQLITE_OPEN_MAIN_DB );
313 - robust_close(p, fd, __LINE__);
314 - goto open_finished;
315 - }
316 - }
317 -
318 #ifdef FD_CLOEXEC
319 osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
320 #endif
321 @@ -29235,7 +29233,6 @@ static int unixOpen(
322 struct statfs fsInfo;
323 if( fstatfs(fd, &fsInfo) == -1 ){
324 ((unixFile*)pFile)->lastErrno = errno;
325 - if( dirfd>=0 ) robust_close(p, dirfd, __LINE__);
326 robust_close(p, fd, __LINE__);
327 return SQLITE_IOERR_ACCESS;
328 }
329 @@ -29267,9 +29264,6 @@ static int unixOpen(
330 ** not while other file descriptors opened by the same process on
331 ** the same file are working. */
332 p->lastErrno = errno;
333 - if( dirfd>=0 ){
334 - robust_close(p, dirfd, __LINE__);
335 - }
336 robust_close(p, fd, __LINE__);
337 rc = SQLITE_IOERR_ACCESS;
338 goto open_finished;
339 @@ -29277,7 +29271,7 @@ static int unixOpen(
340 useProxy = !(fsInfo.f_flags&MNT_LOCAL);
341 }
342 if( useProxy ){
343 - rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock,
344 + rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
345 isDelete, isReadonly);
346 if( rc==SQLITE_OK ){
347 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
348 @@ -29295,7 +29289,7 @@ static int unixOpen(
349 }
350 #endif
352 - rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock,
353 + rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
354 isDelete, isReadonly);
355 open_finished:
356 if( rc!=SQLITE_OK ){
357 @@ -29317,13 +29311,13 @@ static int unixDelete(
358 int rc = SQLITE_OK;
359 UNUSED_PARAMETER(NotUsed);
360 SimulateIOError(return SQLITE_IOERR_DELETE);
361 - if( unlink(zPath)==(-1) && errno!=ENOENT ){
362 + if( osUnlink(zPath)==(-1) && errno!=ENOENT ){
363 return unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
364 }
365 #ifndef SQLITE_DISABLE_DIRSYNC
366 if( dirSync ){
367 int fd;
368 - rc = openDirectory(zPath, &fd);
369 + rc = osOpenDirectory(zPath, &fd);
370 if( rc==SQLITE_OK ){
371 #if OS_VXWORKS
372 if( fsync(fd)==-1 )
373 @@ -29895,7 +29889,6 @@ static int proxyCreateUnixFile(
374 int islockfile /* if non zero missing dirs will be created */
375 ) {
376 int fd = -1;
377 - int dirfd = -1;
378 unixFile *pNew;
379 int rc = SQLITE_OK;
380 int openFlags = O_RDWR | O_CREAT;
381 @@ -29960,7 +29953,7 @@ static int proxyCreateUnixFile(
382 pUnused->flags = openFlags;
383 pNew->pUnused = pUnused;
385 - rc = fillInUnixFile(&dummyVfs, fd, dirfd, (sqlite3_file*)pNew, path, 0, 0, 0);
386 + rc = fillInUnixFile(&dummyVfs, fd, 0, (sqlite3_file*)pNew, path, 0, 0, 0);
387 if( rc==SQLITE_OK ){
388 *ppFile = pNew;
389 return SQLITE_OK;
390 @@ -30074,7 +30067,7 @@ static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
391 end_breaklock:
392 if( rc ){
393 if( fd>=0 ){
394 - unlink(tPath);
395 + osUnlink(tPath);
396 robust_close(pFile, fd, __LINE__);
397 }
398 fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg);
399 @@ -30897,7 +30890,7 @@ SQLITE_API int sqlite3_os_init(void){
401 /* Double-check that the aSyscall[] array has been constructed
402 ** correctly. See ticket [bb3a86e890c8e96ab] */
403 - assert( ArraySize(aSyscall)==16 );
404 + assert( ArraySize(aSyscall)==18 );
406 /* Register all VFSes defined in the aVfs[] array */
407 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
408 diff --git a/third_party/sqlite/src/src/os_unix.c b/third_party/sqlite/src/src/os_unix.c
409 index e5b2540..804c588 100644
410 --- a/third_party/sqlite/src/src/os_unix.c
411 +++ b/third_party/sqlite/src/src/os_unix.c
412 @@ -204,7 +204,6 @@ struct unixFile {
413 sqlite3_io_methods const *pMethod; /* Always the first entry */
414 unixInodeInfo *pInode; /* Info about locks on this inode */
415 int h; /* The file descriptor */
416 - int dirfd; /* File descriptor for the directory */
417 unsigned char eFileLock; /* The type of lock held on this fd */
418 unsigned char ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */
419 int lastErrno; /* The unix errno from last I/O error */
420 @@ -248,6 +247,7 @@ struct unixFile {
421 */
422 #define UNIXFILE_EXCL 0x01 /* Connections from one process only */
423 #define UNIXFILE_RDONLY 0x02 /* Connection is read only */
424 +#define UNIXFILE_DIRSYNC 0x04 /* Directory sync needed */
426 /*
427 ** Include code that is common to all os_*.c files
428 @@ -281,6 +281,9 @@ struct unixFile {
429 #define threadid 0
430 #endif
432 +/* Forward reference */
433 +static int openDirectory(const char*, int*);
434 +
435 /*
436 ** Many system calls are accessed through pointer-to-functions so that
437 ** they may be overridden at runtime to facilitate fault injection during
438 @@ -377,6 +380,12 @@ static struct unix_syscall {
439 #endif
440 #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
442 + { "unlink", (sqlite3_syscall_ptr)unlink, 0 },
443 +#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)
444 +
445 + { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },
446 +#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)
447 +
448 }; /* End of the overrideable system calls */
450 /*
451 @@ -1731,10 +1740,6 @@ static int unixUnlock(sqlite3_file *id, int eFileLock){
452 */
453 static int closeUnixFile(sqlite3_file *id){
454 unixFile *pFile = (unixFile*)id;
455 - if( pFile->dirfd>=0 ){
456 - robust_close(pFile, pFile->dirfd, __LINE__);
457 - pFile->dirfd=-1;
458 - }
459 if( pFile->h>=0 ){
460 robust_close(pFile, pFile->h, __LINE__);
461 pFile->h = -1;
462 @@ -1742,7 +1747,7 @@ static int closeUnixFile(sqlite3_file *id){
463 #if OS_VXWORKS
464 if( pFile->pId ){
465 if( pFile->isDelete ){
466 - unlink(pFile->pId->zCanonicalName);
467 + osUnlink(pFile->pId->zCanonicalName);
468 }
469 vxworksReleaseFileId(pFile->pId);
470 pFile->pId = 0;
471 @@ -1989,7 +1994,7 @@ static int dotlockUnlock(sqlite3_file *id, int eFileLock) {
473 /* To fully unlock the database, delete the lock file */
474 assert( eFileLock==NO_LOCK );
475 - if( unlink(zLockFile) ){
476 + if( osUnlink(zLockFile) ){
477 int rc = 0;
478 int tErrno = errno;
479 if( ENOENT != tErrno ){
480 @@ -3226,6 +3231,50 @@ static int full_fsync(int fd, int fullSync, int dataOnly){
481 }
483 /*
484 +** Open a file descriptor to the directory containing file zFilename.
485 +** If successful, *pFd is set to the opened file descriptor and
486 +** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
487 +** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
488 +** value.
489 +**
490 +** The directory file descriptor is used for only one thing - to
491 +** fsync() a directory to make sure file creation and deletion events
492 +** are flushed to disk. Such fsyncs are not needed on newer
493 +** journaling filesystems, but are required on older filesystems.
494 +**
495 +** This routine can be overridden using the xSetSysCall interface.
496 +** The ability to override this routine was added in support of the
497 +** chromium sandbox. Opening a directory is a security risk (we are
498 +** told) so making it overrideable allows the chromium sandbox to
499 +** replace this routine with a harmless no-op. To make this routine
500 +** a no-op, replace it with a stub that returns SQLITE_OK but leaves
501 +** *pFd set to a negative number.
502 +**
503 +** If SQLITE_OK is returned, the caller is responsible for closing
504 +** the file descriptor *pFd using close().
505 +*/
506 +static int openDirectory(const char *zFilename, int *pFd){
507 + int ii;
508 + int fd = -1;
509 + char zDirname[MAX_PATHNAME+1];
510 +
511 + sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
512 + for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
513 + if( ii>0 ){
514 + zDirname[ii] = '\0';
515 + fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
516 + if( fd>=0 ){
517 +#ifdef FD_CLOEXEC
518 + osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
519 +#endif
520 + OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
521 + }
522 + }
523 + *pFd = fd;
524 + return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
525 +}
526 +
527 +/*
528 ** Make sure all writes to a particular file are committed to disk.
529 **
530 ** If dataOnly==0 then both the file itself and its metadata (file
531 @@ -3265,28 +3314,23 @@ static int unixSync(sqlite3_file *id, int flags){
532 pFile->lastErrno = errno;
533 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
534 }
535 - if( pFile->dirfd>=0 ){
536 - OSTRACE(("DIRSYNC %-3d (have_fullfsync=%d fullsync=%d)\n", pFile->dirfd,
537 +
538 + /* Also fsync the directory containing the file if the DIRSYNC flag
539 + ** is set. This is a one-time occurrance. Many systems (examples: AIX)
540 + ** are unable to fsync a directory, so ignore errors on the fsync.
541 + */
542 + if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
543 + int dirfd;
544 + OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
545 HAVE_FULLFSYNC, isFullsync));
546 -#ifndef SQLITE_DISABLE_DIRSYNC
547 - /* The directory sync is only attempted if full_fsync is
548 - ** turned off or unavailable. If a full_fsync occurred above,
549 - ** then the directory sync is superfluous.
550 - */
551 - if( (!HAVE_FULLFSYNC || !isFullsync) && full_fsync(pFile->dirfd,0,0) ){
552 - /*
553 - ** We have received multiple reports of fsync() returning
554 - ** errors when applied to directories on certain file systems.
555 - ** A failed directory sync is not a big deal. So it seems
556 - ** better to ignore the error. Ticket #1657
557 - */
558 - /* pFile->lastErrno = errno; */
559 - /* return SQLITE_IOERR; */
560 + rc = osOpenDirectory(pFile->zPath, &dirfd);
561 + if( rc==SQLITE_OK && dirfd>=0 ){
562 + full_fsync(dirfd, 0, 0);
563 + robust_close(pFile, dirfd, __LINE__);
564 + }else if( rc==SQLITE_CANTOPEN ){
565 + rc = SQLITE_OK;
566 }
567 -#endif
568 - /* Only need to sync once, so close the directory when we are done */
569 - robust_close(pFile, pFile->dirfd, __LINE__);
570 - pFile->dirfd = -1;
571 + pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
572 }
573 return rc;
574 }
575 @@ -4110,7 +4154,7 @@ static int unixShmUnmap(
576 assert( pShmNode->nRef>0 );
577 pShmNode->nRef--;
578 if( pShmNode->nRef==0 ){
579 - if( deleteFlag && pShmNode->h>=0 ) unlink(pShmNode->zFilename);
580 + if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
581 unixShmPurge(pDbFd);
582 }
583 unixLeaveMutex();
584 @@ -4430,7 +4474,7 @@ void initUnixFile(sqlite3_file* file) {
585 int fillInUnixFile(
586 sqlite3_vfs *pVfs, /* Pointer to vfs object */
587 int h, /* Open file descriptor of file being opened */
588 - int dirfd, /* Directory file descriptor */
589 + int syncDir, /* True to sync directory on first sync */
590 sqlite3_file *pId, /* Write to the unixFile structure here */
591 const char *zFilename, /* Name of the file being opened */
592 int noLock, /* Omit locking if true */
593 @@ -4461,7 +4505,6 @@ int fillInUnixFile(
595 OSTRACE(("OPEN %-3d %s\n", h, zFilename));
596 pNew->h = h;
597 - pNew->dirfd = dirfd;
598 pNew->zPath = zFilename;
599 if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
600 pNew->ctrlFlags = UNIXFILE_EXCL;
601 @@ -4471,6 +4514,9 @@ int fillInUnixFile(
602 if( isReadOnly ){
603 pNew->ctrlFlags |= UNIXFILE_RDONLY;
604 }
605 + if( syncDir ){
606 + pNew->ctrlFlags |= UNIXFILE_DIRSYNC;
607 + }
609 #if OS_VXWORKS
610 pNew->pId = vxworksFindFileId(zFilename);
611 @@ -4597,13 +4643,12 @@ int fillInUnixFile(
612 if( rc!=SQLITE_OK ){
613 if( h>=0 ) robust_close(pNew, h, __LINE__);
614 h = -1;
615 - unlink(zFilename);
616 + osUnlink(zFilename);
617 isDelete = 0;
618 }
619 pNew->isDelete = isDelete;
620 #endif
621 if( rc!=SQLITE_OK ){
622 - if( dirfd>=0 ) robust_close(pNew, dirfd, __LINE__);
623 if( h>=0 ) robust_close(pNew, h, __LINE__);
624 }else{
625 pNew->pMethod = pLockingStyle;
626 @@ -4613,37 +4658,6 @@ int fillInUnixFile(
627 }
629 /*
630 -** Open a file descriptor to the directory containing file zFilename.
631 -** If successful, *pFd is set to the opened file descriptor and
632 -** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
633 -** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
634 -** value.
635 -**
636 -** If SQLITE_OK is returned, the caller is responsible for closing
637 -** the file descriptor *pFd using close().
638 -*/
639 -static int openDirectory(const char *zFilename, int *pFd){
640 - int ii;
641 - int fd = -1;
642 - char zDirname[MAX_PATHNAME+1];
643 -
644 - sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
645 - for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
646 - if( ii>0 ){
647 - zDirname[ii] = '\0';
648 - fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
649 - if( fd>=0 ){
650 -#ifdef FD_CLOEXEC
651 - osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
652 -#endif
653 - OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
654 - }
655 - }
656 - *pFd = fd;
657 - return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
658 -}
659 -
660 -/*
661 ** Return the name of a directory in which to put temporary files.
662 ** If no suitable temporary file directory can be found, return NULL.
663 */
664 @@ -4938,7 +4952,6 @@ static int unixOpen(
665 ){
666 unixFile *p = (unixFile *)pFile;
667 int fd = -1; /* File descriptor returned by open() */
668 - int dirfd = -1; /* Directory file descriptor */
669 int openFlags = 0; /* Flags to pass to open() */
670 int eType = flags&0xFFFFFF00; /* Type of file to open */
671 int noLock; /* True to omit locking primitives */
672 @@ -4957,7 +4970,7 @@ static int unixOpen(
673 ** a file-descriptor on the directory too. The first time unixSync()
674 ** is called the directory file descriptor will be fsync()ed and close()d.
675 */
676 - int isOpenDirectory = (isCreate && (
677 + int syncDir = (isCreate && (
678 eType==SQLITE_OPEN_MASTER_JOURNAL
679 || eType==SQLITE_OPEN_MAIN_JOURNAL
680 || eType==SQLITE_OPEN_WAL
681 @@ -5004,7 +5017,7 @@ static int unixOpen(
682 }
683 }else if( !zName ){
684 /* If zName is NULL, the upper layer is requesting a temp file. */
685 - assert(isDelete && !isOpenDirectory);
686 + assert(isDelete && !syncDir);
687 rc = unixGetTempname(MAX_PATHNAME+1, zTmpname);
688 if( rc!=SQLITE_OK ){
689 return rc;
690 @@ -5057,7 +5070,7 @@ static int unixOpen(
691 #if OS_VXWORKS
692 zPath = zName;
693 #else
694 - unlink(zName);
695 + osUnlink(zName);
696 #endif
697 }
698 #if SQLITE_ENABLE_LOCKING_STYLE
699 @@ -5066,19 +5079,6 @@ static int unixOpen(
700 }
701 #endif
703 - if( isOpenDirectory ){
704 - rc = openDirectory(zPath, &dirfd);
705 - if( rc!=SQLITE_OK ){
706 - /* It is safe to close fd at this point, because it is guaranteed not
707 - ** to be open on a database file. If it were open on a database file,
708 - ** it would not be safe to close as this would release any locks held
709 - ** on the file by this process. */
710 - assert( eType!=SQLITE_OPEN_MAIN_DB );
711 - robust_close(p, fd, __LINE__);
712 - goto open_finished;
713 - }
714 - }
715 -
716 #ifdef FD_CLOEXEC
717 osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
718 #endif
719 @@ -5090,7 +5090,6 @@ static int unixOpen(
720 struct statfs fsInfo;
721 if( fstatfs(fd, &fsInfo) == -1 ){
722 ((unixFile*)pFile)->lastErrno = errno;
723 - if( dirfd>=0 ) robust_close(p, dirfd, __LINE__);
724 robust_close(p, fd, __LINE__);
725 return SQLITE_IOERR_ACCESS;
726 }
727 @@ -5122,9 +5121,6 @@ static int unixOpen(
728 ** not while other file descriptors opened by the same process on
729 ** the same file are working. */
730 p->lastErrno = errno;
731 - if( dirfd>=0 ){
732 - robust_close(p, dirfd, __LINE__);
733 - }
734 robust_close(p, fd, __LINE__);
735 rc = SQLITE_IOERR_ACCESS;
736 goto open_finished;
737 @@ -5132,7 +5128,7 @@ static int unixOpen(
738 useProxy = !(fsInfo.f_flags&MNT_LOCAL);
739 }
740 if( useProxy ){
741 - rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock,
742 + rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
743 isDelete, isReadonly);
744 if( rc==SQLITE_OK ){
745 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
746 @@ -5150,7 +5146,7 @@ static int unixOpen(
747 }
748 #endif
750 - rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock,
751 + rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock,
752 isDelete, isReadonly);
753 open_finished:
754 if( rc!=SQLITE_OK ){
755 @@ -5172,13 +5168,13 @@ static int unixDelete(
756 int rc = SQLITE_OK;
757 UNUSED_PARAMETER(NotUsed);
758 SimulateIOError(return SQLITE_IOERR_DELETE);
759 - if( unlink(zPath)==(-1) && errno!=ENOENT ){
760 + if( osUnlink(zPath)==(-1) && errno!=ENOENT ){
761 return unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
762 }
763 #ifndef SQLITE_DISABLE_DIRSYNC
764 if( dirSync ){
765 int fd;
766 - rc = openDirectory(zPath, &fd);
767 + rc = osOpenDirectory(zPath, &fd);
768 if( rc==SQLITE_OK ){
769 #if OS_VXWORKS
770 if( fsync(fd)==-1 )
771 @@ -5189,6 +5185,8 @@ static int unixDelete(
772 rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
773 }
774 robust_close(0, fd, __LINE__);
775 + }else if( rc==SQLITE_CANTOPEN ){
776 + rc = SQLITE_OK;
777 }
778 }
779 #endif
780 @@ -5750,7 +5748,6 @@ static int proxyCreateUnixFile(
781 int islockfile /* if non zero missing dirs will be created */
782 ) {
783 int fd = -1;
784 - int dirfd = -1;
785 unixFile *pNew;
786 int rc = SQLITE_OK;
787 int openFlags = O_RDWR | O_CREAT;
788 @@ -5815,7 +5812,7 @@ static int proxyCreateUnixFile(
789 pUnused->flags = openFlags;
790 pNew->pUnused = pUnused;
792 - rc = fillInUnixFile(&dummyVfs, fd, dirfd, (sqlite3_file*)pNew, path, 0, 0, 0);
793 + rc = fillInUnixFile(&dummyVfs, fd, 0, (sqlite3_file*)pNew, path, 0, 0, 0);
794 if( rc==SQLITE_OK ){
795 *ppFile = pNew;
796 return SQLITE_OK;
797 @@ -5929,7 +5926,7 @@ static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
798 end_breaklock:
799 if( rc ){
800 if( fd>=0 ){
801 - unlink(tPath);
802 + osUnlink(tPath);
803 robust_close(pFile, fd, __LINE__);
804 }
805 fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg);
806 @@ -6752,7 +6749,7 @@ int sqlite3_os_init(void){
808 /* Double-check that the aSyscall[] array has been constructed
809 ** correctly. See ticket [bb3a86e890c8e96ab] */
810 - assert( ArraySize(aSyscall)==16 );
811 + assert( ArraySize(aSyscall)==18 );
813 /* Register all VFSes defined in the aVfs[] array */
814 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
815 diff --git a/third_party/sqlite/src/test/syscall.test b/third_party/sqlite/src/test/syscall.test
816 index 4442612..201bd63 100644
817 --- a/third_party/sqlite/src/test/syscall.test
818 +++ b/third_party/sqlite/src/test/syscall.test
819 @@ -59,7 +59,7 @@ do_test 2.1.2 { test_syscall exists nosuchcall } 0
820 foreach s {
821 open close access getcwd stat fstat ftruncate
822 fcntl read pread write pwrite fchmod fallocate
823 - pread64 pwrite64
824 + pread64 pwrite64 unlink openDirectory
825 } {
826 if {[test_syscall exists $s]} {lappend syscall_list $s}
827 }
828 diff --git a/third_party/sqlite/system-sqlite.patch b/third_party/sqlite/system-sqlite.patch
829 index f61f019..31d6b00 100644
830 --- a/third_party/sqlite/system-sqlite.patch
831 +++ b/third_party/sqlite/system-sqlite.patch
832 @@ -1,48 +0,0 @@
833 -This is a backport of http://sqlite.org/src/ci/9109128cb5,
834 -which is needed for experiments with using unpatched sqlite.
835 -If you hit a merge conflict on this file it is most likely
836 -that you've upgraded to version of sqlite that includes this patch.
837 -Index: src/os_unix.c
838 -===================================================================
839 ---- src/os_unix.c
840 -+++ src/os_unix.c
841 -@@ -4787,11 +4787,11 @@
842 - ** ignored and -1 is returned. The caller will try to open a new file
843 - ** descriptor on the same path, fail, and return an error to SQLite.
844 - **
845 - ** Even if a subsequent open() call does succeed, the consequences of
846 - ** not searching for a resusable file descriptor are not dire. */
847 -- if( 0==stat(zPath, &sStat) ){
848 -+ if( 0==osStat(zPath, &sStat) ){
849 - unixInodeInfo *pInode;
850 -
851 - unixEnterMutex();
852 - pInode = inodeList;
853 - while( pInode && (pInode->fileId.dev!=sStat.st_dev
854 -@@ -4863,11 +4863,11 @@
855 - while( nDb>0 && zPath[nDb]!='-' ) nDb--;
856 - if( nDb==0 ) return SQLITE_OK;
857 - memcpy(zDb, zPath, nDb);
858 - zDb[nDb] = '\0';
859 -
860 -- if( 0==stat(zDb, &sStat) ){
861 -+ if( 0==osStat(zDb, &sStat) ){
862 - *pMode = sStat.st_mode & 0777;
863 - }else{
864 - rc = SQLITE_IOERR_FSTAT;
865 - }
866 - }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
867 -@@ -5208,11 +5208,11 @@
868 - assert(!"Invalid flags argument");
869 - }
870 - *pResOut = (osAccess(zPath, amode)==0);
871 - if( flags==SQLITE_ACCESS_EXISTS && *pResOut ){
872 - struct stat buf;
873 -- if( 0==stat(zPath, &buf) && buf.st_size==0 ){
874 -+ if( 0==osStat(zPath, &buf) && buf.st_size==0 ){
875 - *pResOut = 0;
876 - }
877 - }
878 - return SQLITE_OK;
879 - }
880 -