2011-01-21 Adam Klein <adamk@chromium.org>
[WebKit-https.git] / Source / WebCore / platform / sql / chromium / SQLiteFileSystemChromiumPosix.cpp
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "SQLiteFileSystem.h"
33
34 #include "PlatformBridge.h"
35 #include <sqlite3.h>
36
37 #include <errno.h>
38 #include <fcntl.h>
39 #include <string.h>
40 #include <sys/stat.h>
41 #include <sys/time.h>
42 #include <sys/types.h>
43 #include <unistd.h>
44
45 using namespace WebCore;
46
47 // Chromium's Posix implementation of SQLite VFS.
48 // This is heavily based on SQLite's os_unix.c,
49 // without parts we don't need.
50
51 // Identifies a file by its device number and inode.
52 struct ChromiumFileId {
53     dev_t dev; // Device number.
54     ino_t ino; // Inode number.
55 };
56
57 // Information about file locks (one per open inode). Note that many open
58 // file descriptors may refer to the same inode.
59 struct ChromiumLockInfo {
60     ChromiumFileId lockKey; // File identifier.
61     int cnt; // Number of shared locks held.
62     int locktype; // Type of the lock.
63     int nRef; // Reference count.
64
65     // Double-linked list pointers.
66     ChromiumLockInfo* pNext; 
67     ChromiumLockInfo* pPrev;
68 };
69
70 // Information about a file descriptor that cannot be closed immediately.
71 struct ChromiumUnusedFd {
72     int fd; // File descriptor.
73     int flags; // Flags this file descriptor was opened with.
74     ChromiumUnusedFd* pNext; // Next unused file descriptor on the same file.
75 };
76
77 // Information about an open inode. When we want to close an inode
78 // that still has locks, we defer the close until all locks are cleared.
79 struct ChromiumOpenInfo {
80     ChromiumFileId fileId; // The lookup key.
81     int nRef; // Reference count.
82     int nLock; // Number of outstanding locks.
83     ChromiumUnusedFd* pUnused; // List of file descriptors to close.
84
85     // Double-linked list pointers.
86     ChromiumOpenInfo* pNext;
87     ChromiumOpenInfo* pPrev;
88 };
89
90 // Keep track of locks and inodes in double-linked lists.
91 static struct ChromiumLockInfo* lockList = 0;
92 static struct ChromiumOpenInfo* openList = 0;
93
94 // Extension of sqlite3_file specific to the chromium VFS.
95 struct ChromiumFile {
96     sqlite3_io_methods const* pMethod; // Implementation of sqlite3_file.
97     ChromiumOpenInfo* pOpen; // Information about all open file descriptors for this file.
98     ChromiumLockInfo* pLock; // Information about all locks for this file.
99     int h; // File descriptor.
100     int dirfd; // File descriptor for the file directory.
101     unsigned char locktype; // Type of the lock used for this file.
102     int lastErrno; // Value of errno for last operation on this file.
103     ChromiumUnusedFd* pUnused; // Information about unused file descriptors for this file.
104 };
105
106 // The following constants specify the range of bytes used for locking.
107 // SQLiteSharedSize is the number of bytes available in the pool from which
108 // a random byte is selected for a shared lock.  The pool of bytes for
109 // shared locks begins at SQLiteSharedFirstByte. 
110 // The values are the same as used by SQLite for compatibility.
111 static const off_t SQLitePendingByte = 0x40000000;
112 static const off_t SQLiteReservedByte = SQLitePendingByte + 1;
113 static const off_t SQLiteSharedFirstByte = SQLitePendingByte + 2;
114 static const off_t SQLiteSharedSize = 510;
115
116 // Maps a POSIX error code to an SQLite error code.
117 static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr)
118 {
119     switch (posixError) {
120     case 0: 
121         return SQLITE_OK;
122     case EAGAIN:
123     case ETIMEDOUT:
124     case EBUSY:
125     case EINTR:
126     case ENOLCK:  
127         return SQLITE_BUSY;
128     case EACCES: 
129         // EACCES is like EAGAIN during locking operations.
130         if ((sqliteIOErr == SQLITE_IOERR_LOCK) ||
131             (sqliteIOErr == SQLITE_IOERR_UNLOCK) ||
132             (sqliteIOErr == SQLITE_IOERR_RDLOCK) ||
133             (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK))
134             return SQLITE_BUSY;
135         return SQLITE_PERM;
136     case EPERM: 
137         return SQLITE_PERM;
138     case EDEADLK:
139         return SQLITE_IOERR_BLOCKED;
140     default: 
141         return sqliteIOErr;
142     }
143 }
144
145 // Releases a ChromiumLockInfo structure previously allocated by findLockInfo().
146 static void releaseLockInfo(ChromiumLockInfo* pLock)
147 {
148     if (!pLock)
149         return;
150
151     pLock->nRef--;
152     if (pLock->nRef > 0)
153         return;
154
155     if (pLock->pPrev) {
156         ASSERT(pLock->pPrev->pNext == pLock);
157         pLock->pPrev->pNext = pLock->pNext;
158     } else {
159         ASSERT(lockList == pLock);
160         lockList = pLock->pNext;
161     }
162     if (pLock->pNext) {
163         ASSERT(pLock->pNext->pPrev == pLock);
164         pLock->pNext->pPrev = pLock->pPrev;
165     }
166
167     sqlite3_free(pLock);
168 }
169
170 // Releases a ChromiumOpenInfo structure previously allocated by findLockInfo().
171 static void releaseOpenInfo(ChromiumOpenInfo* pOpen)
172 {
173     if (!pOpen)
174         return;
175
176     pOpen->nRef--;
177     if (pOpen->nRef > 0)
178         return;
179
180     if (pOpen->pPrev) {
181         ASSERT(pOpen->pPrev->pNext == pOpen);
182         pOpen->pPrev->pNext = pOpen->pNext;
183     } else {
184         ASSERT(openList == pOpen);
185         openList = pOpen->pNext;
186     }
187     if (pOpen->pNext) {
188         ASSERT(pOpen->pNext->pPrev == pOpen);
189         pOpen->pNext->pPrev = pOpen->pPrev;
190     }
191
192     ASSERT(!pOpen->pUnused); // Make sure we're not leaking memory and file descriptors.
193
194     sqlite3_free(pOpen);
195 }
196
197 // Locates ChromiumLockInfo and ChromiumOpenInfo for given file descriptor (creating new ones if needed).
198 // Returns a SQLite error code.
199 static int findLockInfo(ChromiumFile* pFile, ChromiumLockInfo** ppLock, ChromiumOpenInfo** ppOpen)
200 {
201     int fd = pFile->h;
202     struct stat statbuf;
203     int rc = fstat(fd, &statbuf);
204     if (rc) {
205         pFile->lastErrno = errno;
206 #ifdef EOVERFLOW
207         if (pFile->lastErrno == EOVERFLOW)
208             return SQLITE_NOLFS;
209 #endif
210         return SQLITE_IOERR;
211     }
212
213 #if OS(DARWIN)
214     // On OS X on an msdos/fat filesystems, the inode number is reported
215     // incorrectly for zero-size files. See http://www.sqlite.org/cvstrac/tktview?tn=3260.
216     // To work around this problem we always increase the file size to 1 by writing a single byte
217     // prior to accessing the inode number. The one byte written is an ASCII 'S' character which
218     // also happens to be the first byte in the header of every SQLite database.  In this way,
219     // if there is a race condition such that another thread has already populated the first page
220     // of the database, no damage is done.
221     if (!statbuf.st_size) {
222         rc = write(fd, "S", 1);
223         if (rc != 1)
224             return SQLITE_IOERR;
225         rc = fstat(fd, &statbuf);
226         if (rc) {
227             pFile->lastErrno = errno;
228             return SQLITE_IOERR;
229         }
230     }
231 #endif
232
233     ChromiumFileId fileId;
234     memset(&fileId, 0, sizeof(fileId));
235     fileId.dev = statbuf.st_dev;
236     fileId.ino = statbuf.st_ino;
237
238     ChromiumLockInfo* pLock = 0;
239
240     if (ppLock) {
241         pLock = lockList;
242         while (pLock && memcmp(&fileId, &pLock->lockKey, sizeof(fileId)))
243             pLock = pLock->pNext;
244         if (pLock)
245             pLock->nRef++;
246         else {
247             pLock = static_cast<ChromiumLockInfo*>(sqlite3_malloc(sizeof(*pLock)));
248             if (!pLock)
249                 return SQLITE_NOMEM;
250             pLock->lockKey = fileId;
251             pLock->nRef = 1;
252             pLock->cnt = 0;
253             pLock->locktype = 0;
254             pLock->pNext = lockList;
255             pLock->pPrev = 0;
256             if (lockList)
257                 lockList->pPrev = pLock;
258             lockList = pLock;
259         }
260         *ppLock = pLock;
261     }
262
263     if (ppOpen) {
264         ChromiumOpenInfo* pOpen = openList;
265         while (pOpen && memcmp(&fileId, &pOpen->fileId, sizeof(fileId)))
266             pOpen = pOpen->pNext;
267         if (pOpen)
268             pOpen->nRef++;
269         else {
270             pOpen = static_cast<ChromiumOpenInfo*>(sqlite3_malloc(sizeof(*pOpen)));
271             if (!pOpen) {
272                 releaseLockInfo(pLock);
273                 return SQLITE_NOMEM;
274             }
275             memset(pOpen, 0, sizeof(*pOpen));
276             pOpen->fileId = fileId;
277             pOpen->nRef = 1;
278             pOpen->pNext = openList;
279             if (openList)
280                 openList->pPrev = pOpen;
281             openList = pOpen;
282         }
283         *ppOpen = pOpen;
284     }
285
286     return rc;
287 }
288
289 // Checks if there is a RESERVED lock held on the specified file by this or any other process.
290 // If the lock is held, sets pResOut to a non-zero value. Returns a SQLite error code.
291 static int chromiumCheckReservedLock(sqlite3_file* id, int* pResOut)
292 {
293     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
294     ASSERT(pFile);
295
296     // Look for locks held by this process.
297     int reserved = 0;
298     if (pFile->pLock->locktype > SQLITE_LOCK_SHARED)
299         reserved = 1;
300
301     // Look for locks held by other processes.
302     int rc = SQLITE_OK;
303     if (!reserved) {
304         struct flock lock;
305         lock.l_whence = SEEK_SET;
306         lock.l_start = SQLiteReservedByte;
307         lock.l_len = 1;
308         lock.l_type = F_WRLCK;
309         if (-1 == fcntl(pFile->h, F_GETLK, &lock)) {
310             int tErrno = errno;
311             rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK);
312             pFile->lastErrno = tErrno;
313         } else if (lock.l_type != F_UNLCK)
314             reserved = 1;
315     }
316
317     *pResOut = reserved;
318     return rc;
319 }
320
321 // Performs a file locking operation on a range of bytes in a file.
322 // The |op| parameter should be one of F_RFLCK, F_WRLCK or F_UNLCK.
323 // Returns a Unix error code, and also writes it to pErrcode.
324 static int rangeLock(ChromiumFile* pFile, int op, int* pErrcode)
325 {
326     struct flock lock;
327     lock.l_type = op;
328     lock.l_start = SQLiteSharedFirstByte;
329     lock.l_whence = SEEK_SET;
330     lock.l_len = SQLiteSharedSize;
331     int rc = fcntl(pFile->h, F_SETLK, &lock);
332     *pErrcode = errno;
333     return rc;
334 }
335
336 // Locks the file with the lock specified by parameter locktype - one
337 // of the following:
338 //
339 //     (1) SQLITE_LOCK_SHARED
340 //     (2) SQLITE_LOCK_RESERVED
341 //     (3) SQLITE_LOCK_PENDING
342 //     (4) SQLITE_LOCK_EXCLUSIVE
343 //
344 // Sometimes when requesting one lock state, additional lock states
345 // are inserted in between.  The locking might fail on one of the later
346 // transitions leaving the lock state different from what it started but
347 // still short of its goal.  The following chart shows the allowed
348 // transitions and the inserted intermediate states:
349 //
350 //    UNLOCKED -> SHARED
351 //    SHARED -> RESERVED
352 //    SHARED -> (PENDING) -> EXCLUSIVE
353 //    RESERVED -> (PENDING) -> EXCLUSIVE
354 //    PENDING -> EXCLUSIVE
355 static int chromiumLock(sqlite3_file* id, int locktype)
356 {
357     // To obtain a SHARED lock, a read-lock is obtained on the 'pending
358     // byte'.  If this is successful, a random byte from the 'shared byte
359     // range' is read-locked and the lock on the 'pending byte' released.
360     //
361     // A process may only obtain a RESERVED lock after it has a SHARED lock.
362     // A RESERVED lock is implemented by grabbing a write-lock on the
363     // 'reserved byte'. 
364     //
365     // A process may only obtain a PENDING lock after it has obtained a
366     // SHARED lock. A PENDING lock is implemented by obtaining a write-lock
367     // on the 'pending byte'. This ensures that no new SHARED locks can be
368     // obtained, but existing SHARED locks are allowed to persist. A process
369     // does not have to obtain a RESERVED lock on the way to a PENDING lock.
370     // This property is used by the algorithm for rolling back a journal file
371     // after a crash.
372     //
373     // An EXCLUSIVE lock, obtained after a PENDING lock is held, is
374     // implemented by obtaining a write-lock on the entire 'shared byte
375     // range'. Since all other locks require a read-lock on one of the bytes
376     // within this range, this ensures that no other locks are held on the
377     // database. 
378
379     int rc = SQLITE_OK;
380     struct flock lock;
381     int s = 0;
382     int tErrno;
383
384     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
385     ASSERT(pFile);
386
387     ChromiumLockInfo* pLock = pFile->pLock;
388
389     // If there is already a lock of this type or more restrictive, do nothing.
390     if (pFile->locktype >= locktype)
391         return SQLITE_OK;
392
393     // Make sure we never move from unlocked to anything higher than shared lock.
394     ASSERT(pFile->locktype != SQLITE_LOCK_NONE || locktype == SQLITE_LOCK_SHARED);
395
396     // Make sure we never request a pending lock.
397     ASSERT(locktype != SQLITE_LOCK_PENDING);
398
399     // Make sure a shared lock is always held when a RESERVED lock is requested.
400     ASSERT(locktype != SQLITE_LOCK_RESERVED || pFile->locktype == SQLITE_LOCK_SHARED);
401
402     // If some thread using this PID has a lock via a different ChromiumFile
403     // handle that precludes the requested lock, return BUSY.
404     if (pFile->locktype != pLock->locktype &&
405         (pLock->locktype >= SQLITE_LOCK_PENDING || locktype > SQLITE_LOCK_SHARED))
406         return SQLITE_BUSY;
407
408     // If a SHARED lock is requested, and some thread using this PID already
409     // has a SHARED or RESERVED lock, then just increment reference counts.
410     if (locktype == SQLITE_LOCK_SHARED &&
411         (pLock->locktype == SQLITE_LOCK_SHARED || pLock->locktype == SQLITE_LOCK_RESERVED)) {
412         ASSERT(!pFile->locktype);
413         ASSERT(pLock->cnt > 0);
414         pFile->locktype = SQLITE_LOCK_SHARED;
415         pLock->cnt++;
416         pFile->pOpen->nLock++;
417         return SQLITE_OK;
418     }
419
420     // A PENDING lock is needed before acquiring a SHARED lock and before
421     // acquiring an EXCLUSIVE lock.  For the SHARED lock, the PENDING will
422     // be released.
423     lock.l_len = 1;
424     lock.l_whence = SEEK_SET;
425     if (locktype == SQLITE_LOCK_SHARED ||
426         (locktype == SQLITE_LOCK_EXCLUSIVE && pFile->locktype < SQLITE_LOCK_PENDING)) {
427         lock.l_type = (locktype == SQLITE_LOCK_SHARED ? F_RDLCK : F_WRLCK);
428         lock.l_start = SQLitePendingByte;
429         s = fcntl(pFile->h, F_SETLK, &lock);
430         if (s == -1) {
431             tErrno = errno;
432             rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
433             if ((rc != SQLITE_OK) && (rc != SQLITE_BUSY))
434                 pFile->lastErrno = tErrno;
435             return rc;
436         }
437     }
438
439     if (locktype == SQLITE_LOCK_SHARED) {
440         ASSERT(!pLock->cnt);
441         ASSERT(!pLock->locktype);
442
443         s = rangeLock(pFile, F_RDLCK, &tErrno);
444
445         // Drop the temporary PENDING lock.
446         lock.l_start = SQLitePendingByte;
447         lock.l_len = 1;
448         lock.l_type = F_UNLCK;
449         if (fcntl(pFile->h, F_SETLK, &lock)) {
450             if (s != -1) {
451                 tErrno = errno; 
452                 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK); 
453                 if ((rc != SQLITE_OK) && (rc != SQLITE_BUSY))
454                     pFile->lastErrno = tErrno;
455                 return rc;
456             }
457         }
458         if (s == -1) {
459             rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
460             if ((rc != SQLITE_OK) && (rc != SQLITE_BUSY))
461                 pFile->lastErrno = tErrno;
462         } else {
463             pFile->locktype = SQLITE_LOCK_SHARED;
464             pFile->pOpen->nLock++;
465             pLock->cnt = 1;
466         }
467     } else if (locktype == SQLITE_LOCK_EXCLUSIVE && pLock->cnt > 1) {
468         // We are trying for an exclusive lock but another thread in the
469         // same process is still holding a shared lock.
470         rc = SQLITE_BUSY;
471     }  else {
472         // The request was for a RESERVED or EXCLUSIVE lock.  It is
473         // assumed that there is a SHARED or greater lock on the file
474         // already.
475         ASSERT(pFile->locktype);
476         lock.l_type = F_WRLCK;
477         switch (locktype) {
478         case SQLITE_LOCK_RESERVED:
479             lock.l_start = SQLiteReservedByte;
480             s = fcntl(pFile->h, F_SETLK, &lock);
481             tErrno = errno;
482             break;
483         case SQLITE_LOCK_EXCLUSIVE:
484             s = rangeLock(pFile, F_WRLCK, &tErrno);
485             break;
486         default:
487             ASSERT_NOT_REACHED();
488         }
489         if (s == -1) {
490             rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
491             if ((rc != SQLITE_OK) && (rc != SQLITE_BUSY))
492                 pFile->lastErrno = tErrno;
493         }
494     }
495   
496     if (rc == SQLITE_OK) {
497         pFile->locktype = locktype;
498         pLock->locktype = locktype;
499     } else if (locktype == SQLITE_LOCK_EXCLUSIVE) {
500         pFile->locktype = SQLITE_LOCK_PENDING;
501         pLock->locktype = SQLITE_LOCK_PENDING;
502     }
503
504     return rc;
505 }
506
507 // Closes all file descriptors for given ChromiumFile for which the close has been deferred.
508 // Returns a SQLite error code.
509 static int closePendingFds(ChromiumFile* pFile)
510 {
511     int rc = SQLITE_OK;
512     ChromiumOpenInfo* pOpen = pFile->pOpen;
513     ChromiumUnusedFd* pError = 0;
514     ChromiumUnusedFd* pNext;
515     for (ChromiumUnusedFd* p = pOpen->pUnused; p; p = pNext) {
516         pNext = p->pNext;
517         if (close(p->fd)) {
518             pFile->lastErrno = errno;
519             rc = SQLITE_IOERR_CLOSE;
520             p->pNext = pError;
521             pError = p;
522         } else
523             sqlite3_free(p);
524     }
525     pOpen->pUnused = pError;
526     return rc;
527 }
528
529 // Lowers the locking level on file descriptor.
530 // locktype must be either SQLITE_LOCK_NONE or SQLITE_LOCK_SHARED.
531 static int chromiumUnlock(sqlite3_file* id, int locktype)
532 {
533     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
534     ASSERT(pFile);
535     ASSERT(locktype <= SQLITE_LOCK_SHARED);
536
537     if (pFile->locktype <= locktype)
538         return SQLITE_OK;
539
540     ChromiumLockInfo* pLock = pFile->pLock;
541     ASSERT(pLock->cnt);
542
543     struct flock lock;
544     int rc = SQLITE_OK;
545     int h = pFile->h;
546     int tErrno;
547
548     if (pFile->locktype > SQLITE_LOCK_SHARED) {
549         ASSERT(pLock->locktype == pFile->locktype);
550
551         if (locktype == SQLITE_LOCK_SHARED && rangeLock(pFile, F_RDLCK, &tErrno) == -1) {
552             rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
553             if ((rc != SQLITE_OK) && (rc != SQLITE_BUSY))
554                 pFile->lastErrno = tErrno;
555             if (rc == SQLITE_OK)
556                 pFile->locktype = locktype;
557             return rc;
558         }
559         lock.l_type = F_UNLCK;
560         lock.l_whence = SEEK_SET;
561         lock.l_start = SQLitePendingByte;
562         lock.l_len = 2;
563         if (fcntl(h, F_SETLK, &lock) != -1)
564             pLock->locktype = SQLITE_LOCK_SHARED;
565         else {
566             tErrno = errno;
567             rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
568             if ((rc != SQLITE_OK) && (rc != SQLITE_BUSY))
569                 pFile->lastErrno = tErrno;
570             if (rc == SQLITE_OK)
571                 pFile->locktype = locktype;
572             return rc;
573         }
574     }
575     if (locktype == SQLITE_LOCK_NONE) {
576         struct ChromiumOpenInfo *pOpen;
577
578         pLock->cnt--;
579
580         // Release the lock using an OS call only when all threads in this same process have released the lock.
581         if (!pLock->cnt) {
582             lock.l_type = F_UNLCK;
583             lock.l_whence = SEEK_SET;
584             lock.l_start = lock.l_len = 0L;
585             if (fcntl(h, F_SETLK, &lock) != -1)
586                 pLock->locktype = SQLITE_LOCK_NONE;
587             else {
588                 tErrno = errno;
589                 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
590                 if ((rc != SQLITE_OK) && (rc != SQLITE_BUSY))
591                     pFile->lastErrno = tErrno;
592                 pLock->locktype = SQLITE_LOCK_NONE;
593                 pFile->locktype = SQLITE_LOCK_NONE;
594             }
595         }
596
597         pOpen = pFile->pOpen;
598         pOpen->nLock--;
599         ASSERT(pOpen->nLock >= 0);
600         if (!pOpen->nLock) {
601             int rc2 = closePendingFds(pFile);
602             if (rc == SQLITE_OK)
603                 rc = rc2;
604         }
605     }
606
607     if (rc == SQLITE_OK)
608         pFile->locktype = locktype;
609     return rc;
610 }
611
612 // Closes all file handles for given ChromiumFile and sets all its fields to 0.
613 // Returns a SQLite error code.
614 static int chromiumCloseNoLock(sqlite3_file* id)
615 {
616     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
617     if (!pFile)
618         return SQLITE_OK;
619     if (pFile->dirfd >= 0) {
620         if (close(pFile->dirfd)) {
621             pFile->lastErrno = errno;
622             return SQLITE_IOERR_DIR_CLOSE;
623         }
624         pFile->dirfd = -1;
625     }
626     if (pFile->h >= 0 && close(pFile->h)) {
627         pFile->lastErrno = errno;
628         return SQLITE_IOERR_CLOSE;
629     }
630     sqlite3_free(pFile->pUnused);
631     memset(pFile, 0, sizeof(ChromiumFile));
632     return SQLITE_OK;
633 }
634
635 // Closes a ChromiumFile, including locking operations. Returns a SQLite error code.
636 static int chromiumClose(sqlite3_file* id)
637 {
638     if (!id)
639         return SQLITE_OK;
640
641     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
642     chromiumUnlock(id, SQLITE_LOCK_NONE);
643     if (pFile->pOpen && pFile->pOpen->nLock) {
644         // If there are outstanding locks, do not actually close the file just
645         // yet because that would clear those locks.
646         ChromiumOpenInfo* pOpen = pFile->pOpen;
647         ChromiumUnusedFd* p = pFile->pUnused;
648         p->pNext = pOpen->pUnused;
649         pOpen->pUnused = p;
650         pFile->h = -1;
651         pFile->pUnused = 0;
652     }
653     releaseLockInfo(pFile->pLock);
654     releaseOpenInfo(pFile->pOpen);
655     return chromiumCloseNoLock(id);
656 }
657
658 static int chromiumCheckReservedLockNoop(sqlite3_file*, int* pResOut)
659 {
660     *pResOut = 0;
661     return SQLITE_OK;
662 }
663
664 static int chromiumLockNoop(sqlite3_file*, int)
665 {
666     return SQLITE_OK;
667 }
668
669 static int chromiumUnlockNoop(sqlite3_file*, int)
670 {
671     return SQLITE_OK;
672 }
673
674 // Seeks to the requested offset and reads up to |cnt| bytes into |pBuf|. Returns number of bytes actually read.
675 static int seekAndRead(ChromiumFile* id, sqlite3_int64 offset, void* pBuf, int cnt)
676 {
677     sqlite_int64 newOffset = lseek(id->h, offset, SEEK_SET);
678     if (newOffset != offset) {
679         id->lastErrno = (newOffset == -1) ? errno : 0;
680         return -1;
681     }
682     int got = read(id->h, pBuf, cnt);
683     if (got < 0)
684         id->lastErrno = errno;
685     return got;
686 }
687
688 // Reads data from file into a buffer. Returns a SQLite error code.
689 static int chromiumRead(sqlite3_file* id, void* pBuf, int amt, sqlite3_int64 offset)
690 {
691     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
692     ASSERT(pFile);
693
694     // The bytes in the locking range should never be read.
695     ASSERT(!pFile->pUnused || offset >= SQLitePendingByte + 512 || offset + amt <= SQLitePendingByte);
696
697     int got = seekAndRead(pFile, offset, pBuf, amt);
698     if (got == amt)
699         return SQLITE_OK;
700
701     if (got < 0)
702         return SQLITE_IOERR_READ;
703
704     // Unread parts of the buffer must be zero-filled.
705     memset(&(reinterpret_cast<char*>(pBuf))[got], 0, amt - got);
706     pFile->lastErrno = 0;
707     return SQLITE_IOERR_SHORT_READ;
708 }
709
710 // Seeks to the requested offset and writes up to |cnt| bytes. Returns number of bytes actually written.
711 static int seekAndWrite(ChromiumFile* id, sqlite_int64 offset, const void* pBuf, int cnt)
712 {
713     sqlite_int64 newOffset = lseek(id->h, offset, SEEK_SET);
714     if (newOffset != offset) {
715         id->lastErrno = (newOffset == -1) ? errno : 0;
716         return -1;
717     }
718     int got = write(id->h, pBuf, cnt);
719     if (got < 0)
720         id->lastErrno = errno;
721     return got;
722 }
723
724 // Writes data from buffer into a file. Returns a SQLite error code.
725 static int chromiumWrite(sqlite3_file* id, const void* pBuf, int amt, sqlite3_int64 offset)
726 {
727     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
728     ASSERT(pFile);
729     ASSERT(amt > 0);
730
731     // The bytes in the locking range should never be written.
732     ASSERT(!pFile->pUnused || offset >= SQLitePendingByte + 512 || offset + amt <= SQLitePendingByte);
733
734     int wrote = 0;
735     while (amt > 0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt)) > 0) {
736         amt -= wrote;
737         offset += wrote;
738         pBuf = &(reinterpret_cast<const char*>(pBuf))[wrote];
739     }
740     if (amt > 0) {
741         if (wrote < 0)
742             return SQLITE_IOERR_WRITE;
743         pFile->lastErrno = 0;
744         return SQLITE_FULL;
745     }
746     return SQLITE_OK;
747 }
748
749 static bool syncWrapper(int fd, bool fullSync)
750 {
751 #if OS(DARWIN)
752     bool success = false;
753     if (fullSync)
754         success = !fcntl(fd, F_FULLFSYNC, 0);
755     if (!success)
756         success = !fsync(fd);
757     return success;
758 #else
759     return !fdatasync(fd);
760 #endif
761 }
762
763 // Makes sure all writes to a particular file are committed to disk. Returns a SQLite error code.
764 static int chromiumSync(sqlite3_file* id, int flags)
765 {
766     ASSERT((flags & 0x0F) == SQLITE_SYNC_NORMAL || (flags & 0x0F) == SQLITE_SYNC_FULL);
767
768     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
769     ASSERT(pFile);
770
771     bool isFullSync = ((flags & 0x0F) == SQLITE_SYNC_FULL);
772
773     if (!syncWrapper(pFile->h, isFullSync)) {
774         pFile->lastErrno = errno;
775         return SQLITE_IOERR_FSYNC;
776     }
777
778     if (pFile->dirfd >= 0) {
779 #if !OS(DARWIN)
780         if (!isFullSync) {
781             // Ignore directory sync failures, see http://www.sqlite.org/cvstrac/tktview?tn=1657.
782             syncWrapper(pFile->dirfd, false);
783         }
784 #endif
785         if (!close(pFile->dirfd))
786             pFile->dirfd = -1;
787         else {
788             pFile->lastErrno = errno;
789             return SQLITE_IOERR_DIR_CLOSE;
790         }
791     }
792
793     return SQLITE_OK;
794 }
795
796 // Truncates an open file to the specified size. Returns a SQLite error code.
797 static int chromiumTruncate(sqlite3_file* id, sqlite_int64 nByte)
798 {
799     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
800     ASSERT(pFile);
801
802     if (ftruncate(pFile->h, nByte)) {
803         pFile->lastErrno = errno;
804         return SQLITE_IOERR_TRUNCATE;
805     }
806
807     return SQLITE_OK;
808 }
809
810 // Determines the size of a file in bytes. Returns a SQLite error code.
811 static int chromiumFileSize(sqlite3_file* id, sqlite_int64* pSize)
812 {
813     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
814     ASSERT(pFile);
815
816     struct stat buf;
817     if (fstat(pFile->h, &buf)) {
818         pFile->lastErrno = errno;
819         return SQLITE_IOERR_FSTAT;
820     }
821     *pSize = buf.st_size;
822
823     // When opening a zero-size database, findLockInfo writes a single byte into that file
824     // in order to work around a bug in the OS X msdos filesystem. In order to avoid problems
825     // with upper layers, we need to report this file size as zero even though it is really 1.
826     // See http://www.sqlite.org/cvstrac/tktview?tn=3260.
827     if (*pSize == 1)
828         *pSize = 0;
829
830     return SQLITE_OK;
831 }
832
833 static int chromiumFileControl(sqlite3_file* id, int op, void* pArg)
834 {
835     ChromiumFile* pFile = reinterpret_cast<ChromiumFile*>(id);
836     ASSERT(pFile);
837
838     switch (op) {
839     case SQLITE_FCNTL_LOCKSTATE:
840         *reinterpret_cast<int*>(pArg) = pFile->locktype;
841         return SQLITE_OK;
842     case SQLITE_LAST_ERRNO:
843         *reinterpret_cast<int*>(pArg) = pFile->lastErrno;
844         return SQLITE_OK;
845     }
846     return SQLITE_ERROR;
847 }
848
849 // Same as SQLITE_DEFAULT_SECTOR_SIZE from sqlite's os.h.
850 static const int SQLiteDefaultSectorSize = 512;
851
852 static int chromiumSectorSize(sqlite3_file*)
853 {
854     return SQLiteDefaultSectorSize;
855 }
856
857 static int chromiumDeviceCharacteristics(sqlite3_file*)
858 {
859     return 0;
860 }
861
862 static const sqlite3_io_methods posixIoMethods = {
863     1,
864     chromiumClose,
865     chromiumRead,
866     chromiumWrite,
867     chromiumTruncate,
868     chromiumSync,
869     chromiumFileSize,
870     chromiumLock,
871     chromiumUnlock,
872     chromiumCheckReservedLock,
873     chromiumFileControl,
874     chromiumSectorSize,
875     chromiumDeviceCharacteristics
876 };
877
878 static const sqlite3_io_methods nolockIoMethods = {
879     1,
880     chromiumCloseNoLock,
881     chromiumRead,
882     chromiumWrite,
883     chromiumTruncate,
884     chromiumSync,
885     chromiumFileSize,
886     chromiumLockNoop,
887     chromiumUnlockNoop,
888     chromiumCheckReservedLockNoop,
889     chromiumFileControl,
890     chromiumSectorSize,
891     chromiumDeviceCharacteristics
892 };
893
894 // Initializes a ChromiumFile. Returns a SQLite error code.
895 static int fillInChromiumFile(sqlite3_vfs* pVfs, int h, int dirfd, sqlite3_file* pId, const char* zFilename, int noLock)
896 {
897     ChromiumFile* pNew = reinterpret_cast<ChromiumFile*>(pId);
898
899     ASSERT(!pNew->pLock);
900     ASSERT(!pNew->pOpen);
901
902     pNew->h = h;
903     pNew->dirfd = dirfd;
904
905     int rc = SQLITE_OK;
906     const sqlite3_io_methods* pLockingStyle;
907     if (noLock)
908         pLockingStyle = &nolockIoMethods;
909     else {
910         pLockingStyle = &posixIoMethods;
911         rc = findLockInfo(pNew, &pNew->pLock, &pNew->pOpen);
912         if (rc != SQLITE_OK) {
913             // If an error occured in findLockInfo(), close the file descriptor
914             // immediately. This can happen in two scenarios:
915             //
916             //   (a) A call to fstat() failed.
917             //   (b) A malloc failed.
918             //
919             // Scenario (b) may only occur if the process is holding no other
920             // file descriptors open on the same file. If there were other file
921             // descriptors on this file, then no malloc would be required by
922             // findLockInfo(). If this is the case, it is quite safe to close
923             // handle h - as it is guaranteed that no posix locks will be released
924             // by doing so.
925             //
926             // If scenario (a) caused the error then things are not so safe. The
927             // implicit assumption here is that if fstat() fails, things are in
928             // such bad shape that dropping a lock or two doesn't matter much.
929             close(h);
930             h = -1;
931         }
932     }
933
934     pNew->lastErrno = 0;
935     if (rc != SQLITE_OK) {
936         if (dirfd >= 0)
937             close(dirfd);
938         if (h >= 0)
939             close(h);
940     } else
941         pNew->pMethod = pLockingStyle;
942     return rc;
943 }
944
945 // Searches for an unused file descriptor that was opened on the database 
946 // file identified by zPath with matching flags. Returns 0 if not found.
947 static ChromiumUnusedFd* findReusableFd(const char* zPath, int flags)
948 {
949     ChromiumUnusedFd* pUnused = 0;
950
951     struct stat sStat;
952     if (!stat(zPath, &sStat)) {
953         ChromiumFileId id;
954         id.dev = sStat.st_dev;
955         id.ino = sStat.st_ino;
956
957         ChromiumOpenInfo* pO = 0;
958         for (pO = openList; pO && memcmp(&id, &pO->fileId, sizeof(id)); pO = pO->pNext) { }
959         if (pO) {
960             ChromiumUnusedFd** pp;
961             for (pp = &pO->pUnused; *pp && (*pp)->flags != flags; pp = &((*pp)->pNext)) { }
962             pUnused = *pp;
963             if (pUnused)
964                 *pp = pUnused->pNext;
965         }
966     }
967     return pUnused;
968 }
969
970 // Opens a file.
971 //
972 // vfs - pointer to the sqlite3_vfs object.
973 // fileName - the name of the file.
974 // id - the structure that will manipulate the newly opened file.
975 // desiredFlags - the desired open mode flags.
976 // usedFlags - the actual open mode flags that were used.
977 static int chromiumOpen(sqlite3_vfs* vfs, const char* fileName,
978                         sqlite3_file* id, int desiredFlags, int* usedFlags)
979 {
980     // The mask 0x00007F00 gives us the 7 bits that determine the type of the file SQLite is trying to open.
981     int fileType = desiredFlags & 0x00007F00;
982
983     memset(id, 0, sizeof(ChromiumFile));
984     ChromiumFile* chromiumFile = reinterpret_cast<ChromiumFile*>(id);
985     int fd = -1;
986     if (fileType == SQLITE_OPEN_MAIN_DB) {
987         ChromiumUnusedFd* unusedFd = findReusableFd(fileName, desiredFlags);
988         if (unusedFd)
989             fd = unusedFd->fd;
990         else {
991             unusedFd = static_cast<ChromiumUnusedFd*>(sqlite3_malloc(sizeof(*unusedFd)));
992             if (!unusedFd)
993                 return SQLITE_NOMEM;
994         }
995         chromiumFile->pUnused = unusedFd;
996     }
997
998     if (fd < 0) {
999         fd = PlatformBridge::databaseOpenFile(fileName, desiredFlags);
1000         if ((fd < 0) && (desiredFlags & SQLITE_OPEN_READWRITE)) {
1001             int newFlags = (desiredFlags & ~(SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE)) | SQLITE_OPEN_READONLY;
1002             fd = PlatformBridge::databaseOpenFile(fileName, newFlags);
1003         }
1004     }
1005     if (fd < 0) {
1006         sqlite3_free(chromiumFile->pUnused);
1007         return SQLITE_CANTOPEN;
1008     }
1009
1010     if (usedFlags)
1011         *usedFlags = desiredFlags;
1012     if (chromiumFile->pUnused) {
1013         chromiumFile->pUnused->fd = fd;
1014         chromiumFile->pUnused->flags = desiredFlags;
1015     }
1016
1017     fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
1018
1019     int noLock = (fileType != SQLITE_OPEN_MAIN_DB);
1020     int rc = fillInChromiumFile(vfs, fd, -1, id, fileName, noLock);
1021     if (rc != SQLITE_OK)
1022         sqlite3_free(chromiumFile->pUnused);
1023     return rc;
1024 }
1025
1026 // Deletes the given file.
1027 //
1028 // vfs - pointer to the sqlite3_vfs object.
1029 // fileName - the name of the file.
1030 // syncDir - determines if the directory to which this file belongs
1031 //           should be synched after the file is deleted.
1032 static int chromiumDelete(sqlite3_vfs*, const char* fileName, int syncDir)
1033 {
1034     return PlatformBridge::databaseDeleteFile(fileName, syncDir);
1035 }
1036
1037 // Check the existance and status of the given file.
1038 //
1039 // vfs - pointer to the sqlite3_vfs object.
1040 // fileName - the name of the file.
1041 // flag - the type of test to make on this file.
1042 // res - the result.
1043 static int chromiumAccess(sqlite3_vfs*, const char* fileName, int flag, int* res)
1044 {
1045     int attr = static_cast<int>(PlatformBridge::databaseGetFileAttributes(fileName));
1046     if (attr < 0) {
1047         *res = 0;
1048         return SQLITE_OK;
1049     }
1050
1051     switch (flag) {
1052     case SQLITE_ACCESS_EXISTS:
1053         *res = 1; // if the file doesn't exist, attr < 0
1054         break;
1055     case SQLITE_ACCESS_READWRITE:
1056         *res = (attr & W_OK) && (attr & R_OK);
1057         break;
1058     case SQLITE_ACCESS_READ:
1059         *res = (attr & R_OK);
1060         break;
1061     default:
1062         return SQLITE_ERROR;
1063     }
1064
1065     return SQLITE_OK;
1066 }
1067
1068 // Turns a relative pathname into a full pathname.
1069 //
1070 // vfs - pointer to the sqlite3_vfs object.
1071 // relativePath - the relative path.
1072 // bufSize - the size of the output buffer in bytes.
1073 // absolutePath - the output buffer where the absolute path will be stored.
1074 static int chromiumFullPathname(sqlite3_vfs* vfs, const char* relativePath,
1075                                 int, char* absolutePath)
1076 {
1077     // The renderer process doesn't need to know the absolute path of the file
1078     sqlite3_snprintf(vfs->mxPathname, absolutePath, "%s", relativePath);
1079     return SQLITE_OK;
1080 }
1081
1082 #ifndef SQLITE_OMIT_LOAD_EXTENSION
1083 // We disallow loading DSOs inside the renderer process, so the following procedures are no-op.
1084 static void* chromiumDlOpen(sqlite3_vfs*, const char*)
1085 {
1086     return 0;
1087 }
1088
1089 static void chromiumDlError(sqlite3_vfs*, int, char*)
1090 {
1091 }
1092
1093 static void (*chromiumDlSym(sqlite3_vfs*, void*, const char*))()
1094 {
1095     return 0;
1096 }
1097
1098 static void chromiumDlClose(sqlite3_vfs*, void*)
1099 {
1100 }
1101 #else
1102 #define chromiumDlOpen 0
1103 #define chromiumDlError 0
1104 #define chromiumDlSym 0
1105 #define chromiumDlClose 0
1106 #endif // SQLITE_OMIT_LOAD_EXTENSION
1107
1108 // Generates a seed for SQLite's PRNG.
1109 static int chromiumRandomness(sqlite3_vfs*, int nBuf, char *zBuf)
1110 {
1111     ASSERT(static_cast<size_t>(nBuf) >= (sizeof(time_t) + sizeof(int)));
1112
1113     memset(zBuf, 0, nBuf);
1114     int fd = open("/dev/urandom", O_RDONLY);
1115     if (fd < 0) {
1116         time_t t;
1117         time(&t);
1118         memcpy(zBuf, &t, sizeof(t));
1119         int pid = getpid();
1120         memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
1121         return sizeof(t) + sizeof(pid);
1122     }
1123     nBuf = read(fd, zBuf, nBuf);
1124     close(fd);
1125     return nBuf;
1126 }
1127
1128 // Sleeps for at least |microseconds|, and returns the actual
1129 // amount of time spent sleeping (in microseconds).
1130 static int chromiumSleep(sqlite3_vfs*, int microseconds)
1131 {
1132 #if OS(DARWIN)
1133     usleep(microseconds);
1134     return microseconds;
1135 #else
1136     // Round to the nearest second.
1137     int seconds = (microseconds + 999999) / 1000000;
1138     sleep(seconds);
1139     return seconds * 1000000;
1140 #endif
1141 }
1142
1143 // Retrieves the current system time (UTC).
1144 static int chromiumCurrentTime(sqlite3_vfs*, double* now)
1145 {
1146     struct timeval timeval;
1147     gettimeofday(&timeval, 0);
1148     *now = 2440587.5 + timeval.tv_sec / 86400.0 + timeval.tv_usec / 86400000000.0;
1149     return 0;
1150 }
1151
1152 // This is not yet implemented in SQLite core.
1153 static int chromiumGetLastError(sqlite3_vfs*, int, char*)
1154 {
1155     return 0;
1156 }
1157
1158 // Same as MAX_PATHNAME from sqlite's os_unix.c.
1159 static const int chromiumMaxPathname = 512;
1160
1161 namespace WebCore {
1162
1163 void SQLiteFileSystem::registerSQLiteVFS()
1164 {
1165     static sqlite3_vfs chromium_vfs = {
1166         1,
1167         sizeof(ChromiumFile),
1168         chromiumMaxPathname,
1169         0,
1170         "chromium_vfs",
1171         0,
1172         chromiumOpen,
1173         chromiumDelete,
1174         chromiumAccess,
1175         chromiumFullPathname,
1176         chromiumDlOpen,
1177         chromiumDlError,
1178         chromiumDlSym,
1179         chromiumDlClose,
1180         chromiumRandomness,
1181         chromiumSleep,
1182         chromiumCurrentTime,
1183         chromiumGetLastError
1184     };
1185     sqlite3_vfs_register(&chromium_vfs, 0);
1186 }
1187
1188 } // namespace WebCore