| OLD | NEW |
|---|
| (Empty) | |
| 1 From 82b8b2c69979f0e1d93577f40597c826d8f8c2ee Mon Sep 17 00:00:00 2001 |
| 2 From: =?UTF-8?q?Pawe=C5=82=20Hajdan=20Jr?= <phajdan.jr@chromium.org> |
| 3 Date: Fri, 5 Aug 2011 16:17:40 +0000 |
| 4 Subject: [PATCH 07/23] [backport] SQLite os-intercept changes. |
| 5 |
| 6 This is a backport of the following SQLite changes to experiment with |
| 7 implementing WebDatabase with an unpatched SQLite: |
| 8 |
| 9 1. http://sqlite.org/src/ci/9109128cb5 |
| 10 2. http://sqlite.org/src/ci/713b1b7dc1 |
| 11 3. http://sqlite.org/src/ci/8d1b5c3ac0 |
| 12 4. http://sqlite.org/src/ci/6b236069e1 |
| 13 5. http://sqlite.org/src/ci/880b51150a |
| 14 |
| 15 BUG=22208 |
| 16 |
| 17 Original review URLs: |
| 18 http://codereview.chromium.org/7575027 |
| 19 http://codereview.chromium.org/7629003 |
| 20 [Possibly more] |
| 21 --- |
| 22 third_party/sqlite/src/src/os_unix.c | 187 +++++++++++++++---------------- |
| 23 third_party/sqlite/src/test/syscall.test | 2 +- |
| 24 2 files changed, 93 insertions(+), 96 deletions(-) |
| 25 |
| 26 diff --git a/third_party/sqlite/src/src/os_unix.c b/third_party/sqlite/src/src/o
s_unix.c |
| 27 index 766b52a..77ffd8a 100644 |
| 28 --- a/third_party/sqlite/src/src/os_unix.c |
| 29 +++ b/third_party/sqlite/src/src/os_unix.c |
| 30 @@ -204,7 +204,6 @@ struct unixFile { |
| 31 sqlite3_io_methods const *pMethod; /* Always the first entry */ |
| 32 unixInodeInfo *pInode; /* Info about locks on this inode */ |
| 33 int h; /* The file descriptor */ |
| 34 - int dirfd; /* File descriptor for the directory */ |
| 35 unsigned char eFileLock; /* The type of lock held on this fd */ |
| 36 unsigned char ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */ |
| 37 int lastErrno; /* The unix errno from last I/O error */ |
| 38 @@ -248,6 +247,7 @@ struct unixFile { |
| 39 */ |
| 40 #define UNIXFILE_EXCL 0x01 /* Connections from one process only */ |
| 41 #define UNIXFILE_RDONLY 0x02 /* Connection is read only */ |
| 42 +#define UNIXFILE_DIRSYNC 0x04 /* Directory sync needed */ |
| 43 |
| 44 /* |
| 45 ** Include code that is common to all os_*.c files |
| 46 @@ -281,6 +281,9 @@ struct unixFile { |
| 47 #define threadid 0 |
| 48 #endif |
| 49 |
| 50 +/* Forward reference */ |
| 51 +static int openDirectory(const char*, int*); |
| 52 + |
| 53 /* |
| 54 ** Many system calls are accessed through pointer-to-functions so that |
| 55 ** they may be overridden at runtime to facilitate fault injection during |
| 56 @@ -377,6 +380,12 @@ static struct unix_syscall { |
| 57 #endif |
| 58 #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent) |
| 59 |
| 60 + { "unlink", (sqlite3_syscall_ptr)unlink, 0 }, |
| 61 +#define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent) |
| 62 + |
| 63 + { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 }, |
| 64 +#define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent) |
| 65 + |
| 66 }; /* End of the overrideable system calls */ |
| 67 |
| 68 /* |
| 69 @@ -1731,10 +1740,6 @@ static int unixUnlock(sqlite3_file *id, int eFileLock){ |
| 70 */ |
| 71 static int closeUnixFile(sqlite3_file *id){ |
| 72 unixFile *pFile = (unixFile*)id; |
| 73 - if( pFile->dirfd>=0 ){ |
| 74 - robust_close(pFile, pFile->dirfd, __LINE__); |
| 75 - pFile->dirfd=-1; |
| 76 - } |
| 77 if( pFile->h>=0 ){ |
| 78 robust_close(pFile, pFile->h, __LINE__); |
| 79 pFile->h = -1; |
| 80 @@ -1742,7 +1747,7 @@ static int closeUnixFile(sqlite3_file *id){ |
| 81 #if OS_VXWORKS |
| 82 if( pFile->pId ){ |
| 83 if( pFile->isDelete ){ |
| 84 - unlink(pFile->pId->zCanonicalName); |
| 85 + osUnlink(pFile->pId->zCanonicalName); |
| 86 } |
| 87 vxworksReleaseFileId(pFile->pId); |
| 88 pFile->pId = 0; |
| 89 @@ -1989,7 +1994,7 @@ static int dotlockUnlock(sqlite3_file *id, int eFileLock)
{ |
| 90 |
| 91 /* To fully unlock the database, delete the lock file */ |
| 92 assert( eFileLock==NO_LOCK ); |
| 93 - if( unlink(zLockFile) ){ |
| 94 + if( osUnlink(zLockFile) ){ |
| 95 int rc = 0; |
| 96 int tErrno = errno; |
| 97 if( ENOENT != tErrno ){ |
| 98 @@ -3226,6 +3231,50 @@ static int full_fsync(int fd, int fullSync, int dataOnly)
{ |
| 99 } |
| 100 |
| 101 /* |
| 102 +** Open a file descriptor to the directory containing file zFilename. |
| 103 +** If successful, *pFd is set to the opened file descriptor and |
| 104 +** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM |
| 105 +** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined |
| 106 +** value. |
| 107 +** |
| 108 +** The directory file descriptor is used for only one thing - to |
| 109 +** fsync() a directory to make sure file creation and deletion events |
| 110 +** are flushed to disk. Such fsyncs are not needed on newer |
| 111 +** journaling filesystems, but are required on older filesystems. |
| 112 +** |
| 113 +** This routine can be overridden using the xSetSysCall interface. |
| 114 +** The ability to override this routine was added in support of the |
| 115 +** chromium sandbox. Opening a directory is a security risk (we are |
| 116 +** told) so making it overrideable allows the chromium sandbox to |
| 117 +** replace this routine with a harmless no-op. To make this routine |
| 118 +** a no-op, replace it with a stub that returns SQLITE_OK but leaves |
| 119 +** *pFd set to a negative number. |
| 120 +** |
| 121 +** If SQLITE_OK is returned, the caller is responsible for closing |
| 122 +** the file descriptor *pFd using close(). |
| 123 +*/ |
| 124 +static int openDirectory(const char *zFilename, int *pFd){ |
| 125 + int ii; |
| 126 + int fd = -1; |
| 127 + char zDirname[MAX_PATHNAME+1]; |
| 128 + |
| 129 + sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename); |
| 130 + for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--); |
| 131 + if( ii>0 ){ |
| 132 + zDirname[ii] = '\0'; |
| 133 + fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0); |
| 134 + if( fd>=0 ){ |
| 135 +#ifdef FD_CLOEXEC |
| 136 + osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC); |
| 137 +#endif |
| 138 + OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname)); |
| 139 + } |
| 140 + } |
| 141 + *pFd = fd; |
| 142 + return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname))
; |
| 143 +} |
| 144 + |
| 145 +/* |
| 146 ** Make sure all writes to a particular file are committed to disk. |
| 147 ** |
| 148 ** If dataOnly==0 then both the file itself and its metadata (file |
| 149 @@ -3265,28 +3314,23 @@ static int unixSync(sqlite3_file *id, int flags){ |
| 150 pFile->lastErrno = errno; |
| 151 return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath); |
| 152 } |
| 153 - if( pFile->dirfd>=0 ){ |
| 154 - OSTRACE(("DIRSYNC %-3d (have_fullfsync=%d fullsync=%d)\n", pFile->dirfd, |
| 155 + |
| 156 + /* Also fsync the directory containing the file if the DIRSYNC flag |
| 157 + ** is set. This is a one-time occurrance. Many systems (examples: AIX) |
| 158 + ** are unable to fsync a directory, so ignore errors on the fsync. |
| 159 + */ |
| 160 + if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){ |
| 161 + int dirfd; |
| 162 + OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath, |
| 163 HAVE_FULLFSYNC, isFullsync)); |
| 164 -#ifndef SQLITE_DISABLE_DIRSYNC |
| 165 - /* The directory sync is only attempted if full_fsync is |
| 166 - ** turned off or unavailable. If a full_fsync occurred above, |
| 167 - ** then the directory sync is superfluous. |
| 168 - */ |
| 169 - if( (!HAVE_FULLFSYNC || !isFullsync) && full_fsync(pFile->dirfd,0,0) ){ |
| 170 - /* |
| 171 - ** We have received multiple reports of fsync() returning |
| 172 - ** errors when applied to directories on certain file systems. |
| 173 - ** A failed directory sync is not a big deal. So it seems |
| 174 - ** better to ignore the error. Ticket #1657 |
| 175 - */ |
| 176 - /* pFile->lastErrno = errno; */ |
| 177 - /* return SQLITE_IOERR; */ |
| 178 + rc = osOpenDirectory(pFile->zPath, &dirfd); |
| 179 + if( rc==SQLITE_OK && dirfd>=0 ){ |
| 180 + full_fsync(dirfd, 0, 0); |
| 181 + robust_close(pFile, dirfd, __LINE__); |
| 182 + }else if( rc==SQLITE_CANTOPEN ){ |
| 183 + rc = SQLITE_OK; |
| 184 } |
| 185 -#endif |
| 186 - /* Only need to sync once, so close the directory when we are done */ |
| 187 - robust_close(pFile, pFile->dirfd, __LINE__); |
| 188 - pFile->dirfd = -1; |
| 189 + pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC; |
| 190 } |
| 191 return rc; |
| 192 } |
| 193 @@ -4110,7 +4154,7 @@ static int unixShmUnmap( |
| 194 assert( pShmNode->nRef>0 ); |
| 195 pShmNode->nRef--; |
| 196 if( pShmNode->nRef==0 ){ |
| 197 - if( deleteFlag && pShmNode->h>=0 ) unlink(pShmNode->zFilename); |
| 198 + if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename); |
| 199 unixShmPurge(pDbFd); |
| 200 } |
| 201 unixLeaveMutex(); |
| 202 @@ -4430,7 +4474,7 @@ void initUnixFile(sqlite3_file* file) { |
| 203 int fillInUnixFile( |
| 204 sqlite3_vfs *pVfs, /* Pointer to vfs object */ |
| 205 int h, /* Open file descriptor of file being opened */ |
| 206 - int dirfd, /* Directory file descriptor */ |
| 207 + int syncDir, /* True to sync directory on first sync */ |
| 208 sqlite3_file *pId, /* Write to the unixFile structure here */ |
| 209 const char *zFilename, /* Name of the file being opened */ |
| 210 int noLock, /* Omit locking if true */ |
| 211 @@ -4461,7 +4505,6 @@ int fillInUnixFile( |
| 212 |
| 213 OSTRACE(("OPEN %-3d %s\n", h, zFilename)); |
| 214 pNew->h = h; |
| 215 - pNew->dirfd = dirfd; |
| 216 pNew->zPath = zFilename; |
| 217 if( strcmp(pVfs->zName,"unix-excl")==0 ){ |
| 218 pNew->ctrlFlags = UNIXFILE_EXCL; |
| 219 @@ -4471,6 +4514,9 @@ int fillInUnixFile( |
| 220 if( isReadOnly ){ |
| 221 pNew->ctrlFlags |= UNIXFILE_RDONLY; |
| 222 } |
| 223 + if( syncDir ){ |
| 224 + pNew->ctrlFlags |= UNIXFILE_DIRSYNC; |
| 225 + } |
| 226 |
| 227 #if OS_VXWORKS |
| 228 pNew->pId = vxworksFindFileId(zFilename); |
| 229 @@ -4597,13 +4643,12 @@ int fillInUnixFile( |
| 230 if( rc!=SQLITE_OK ){ |
| 231 if( h>=0 ) robust_close(pNew, h, __LINE__); |
| 232 h = -1; |
| 233 - unlink(zFilename); |
| 234 + osUnlink(zFilename); |
| 235 isDelete = 0; |
| 236 } |
| 237 pNew->isDelete = isDelete; |
| 238 #endif |
| 239 if( rc!=SQLITE_OK ){ |
| 240 - if( dirfd>=0 ) robust_close(pNew, dirfd, __LINE__); |
| 241 if( h>=0 ) robust_close(pNew, h, __LINE__); |
| 242 }else{ |
| 243 pNew->pMethod = pLockingStyle; |
| 244 @@ -4613,37 +4658,6 @@ int fillInUnixFile( |
| 245 } |
| 246 |
| 247 /* |
| 248 -** Open a file descriptor to the directory containing file zFilename. |
| 249 -** If successful, *pFd is set to the opened file descriptor and |
| 250 -** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM |
| 251 -** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined |
| 252 -** value. |
| 253 -** |
| 254 -** If SQLITE_OK is returned, the caller is responsible for closing |
| 255 -** the file descriptor *pFd using close(). |
| 256 -*/ |
| 257 -static int openDirectory(const char *zFilename, int *pFd){ |
| 258 - int ii; |
| 259 - int fd = -1; |
| 260 - char zDirname[MAX_PATHNAME+1]; |
| 261 - |
| 262 - sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename); |
| 263 - for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--); |
| 264 - if( ii>0 ){ |
| 265 - zDirname[ii] = '\0'; |
| 266 - fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0); |
| 267 - if( fd>=0 ){ |
| 268 -#ifdef FD_CLOEXEC |
| 269 - osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC); |
| 270 -#endif |
| 271 - OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname)); |
| 272 - } |
| 273 - } |
| 274 - *pFd = fd; |
| 275 - return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname))
; |
| 276 -} |
| 277 - |
| 278 -/* |
| 279 ** Return the name of a directory in which to put temporary files. |
| 280 ** If no suitable temporary file directory can be found, return NULL. |
| 281 */ |
| 282 @@ -4757,7 +4771,7 @@ static UnixUnusedFd *findReusableFd(const char *zPath, int
flags){ |
| 283 ** |
| 284 ** Even if a subsequent open() call does succeed, the consequences of |
| 285 ** not searching for a resusable file descriptor are not dire. */ |
| 286 - if( 0==stat(zPath, &sStat) ){ |
| 287 + if( 0==osStat(zPath, &sStat) ){ |
| 288 unixInodeInfo *pInode; |
| 289 |
| 290 unixEnterMutex(); |
| 291 @@ -4827,7 +4841,7 @@ static int findCreateFileMode( |
| 292 memcpy(zDb, zPath, nDb); |
| 293 zDb[nDb] = '\0'; |
| 294 |
| 295 - if( 0==stat(zDb, &sStat) ){ |
| 296 + if( 0==osStat(zDb, &sStat) ){ |
| 297 *pMode = sStat.st_mode & 0777; |
| 298 }else{ |
| 299 rc = SQLITE_IOERR_FSTAT; |
| 300 @@ -4938,7 +4952,6 @@ static int unixOpen( |
| 301 ){ |
| 302 unixFile *p = (unixFile *)pFile; |
| 303 int fd = -1; /* File descriptor returned by open() */ |
| 304 - int dirfd = -1; /* Directory file descriptor */ |
| 305 int openFlags = 0; /* Flags to pass to open() */ |
| 306 int eType = flags&0xFFFFFF00; /* Type of file to open */ |
| 307 int noLock; /* True to omit locking primitives */ |
| 308 @@ -4957,7 +4970,7 @@ static int unixOpen( |
| 309 ** a file-descriptor on the directory too. The first time unixSync() |
| 310 ** is called the directory file descriptor will be fsync()ed and close()d. |
| 311 */ |
| 312 - int isOpenDirectory = (isCreate && ( |
| 313 + int syncDir = (isCreate && ( |
| 314 eType==SQLITE_OPEN_MASTER_JOURNAL |
| 315 || eType==SQLITE_OPEN_MAIN_JOURNAL |
| 316 || eType==SQLITE_OPEN_WAL |
| 317 @@ -5004,7 +5017,7 @@ static int unixOpen( |
| 318 } |
| 319 }else if( !zName ){ |
| 320 /* If zName is NULL, the upper layer is requesting a temp file. */ |
| 321 - assert(isDelete && !isOpenDirectory); |
| 322 + assert(isDelete && !syncDir); |
| 323 rc = unixGetTempname(MAX_PATHNAME+1, zTmpname); |
| 324 if( rc!=SQLITE_OK ){ |
| 325 return rc; |
| 326 @@ -5057,7 +5070,7 @@ static int unixOpen( |
| 327 #if OS_VXWORKS |
| 328 zPath = zName; |
| 329 #else |
| 330 - unlink(zName); |
| 331 + osUnlink(zName); |
| 332 #endif |
| 333 } |
| 334 #if SQLITE_ENABLE_LOCKING_STYLE |
| 335 @@ -5066,19 +5079,6 @@ static int unixOpen( |
| 336 } |
| 337 #endif |
| 338 |
| 339 - if( isOpenDirectory ){ |
| 340 - rc = openDirectory(zPath, &dirfd); |
| 341 - if( rc!=SQLITE_OK ){ |
| 342 - /* It is safe to close fd at this point, because it is guaranteed not |
| 343 - ** to be open on a database file. If it were open on a database file, |
| 344 - ** it would not be safe to close as this would release any locks held |
| 345 - ** on the file by this process. */ |
| 346 - assert( eType!=SQLITE_OPEN_MAIN_DB ); |
| 347 - robust_close(p, fd, __LINE__); |
| 348 - goto open_finished; |
| 349 - } |
| 350 - } |
| 351 - |
| 352 #ifdef FD_CLOEXEC |
| 353 osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC); |
| 354 #endif |
| 355 @@ -5090,7 +5090,6 @@ static int unixOpen( |
| 356 struct statfs fsInfo; |
| 357 if( fstatfs(fd, &fsInfo) == -1 ){ |
| 358 ((unixFile*)pFile)->lastErrno = errno; |
| 359 - if( dirfd>=0 ) robust_close(p, dirfd, __LINE__); |
| 360 robust_close(p, fd, __LINE__); |
| 361 return SQLITE_IOERR_ACCESS; |
| 362 } |
| 363 @@ -5122,9 +5121,6 @@ static int unixOpen( |
| 364 ** not while other file descriptors opened by the same process on |
| 365 ** the same file are working. */ |
| 366 p->lastErrno = errno; |
| 367 - if( dirfd>=0 ){ |
| 368 - robust_close(p, dirfd, __LINE__); |
| 369 - } |
| 370 robust_close(p, fd, __LINE__); |
| 371 rc = SQLITE_IOERR_ACCESS; |
| 372 goto open_finished; |
| 373 @@ -5132,7 +5128,7 @@ static int unixOpen( |
| 374 useProxy = !(fsInfo.f_flags&MNT_LOCAL); |
| 375 } |
| 376 if( useProxy ){ |
| 377 - rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock, |
| 378 + rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock, |
| 379 isDelete, isReadonly); |
| 380 if( rc==SQLITE_OK ){ |
| 381 rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:"); |
| 382 @@ -5150,7 +5146,7 @@ static int unixOpen( |
| 383 } |
| 384 #endif |
| 385 |
| 386 - rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock, |
| 387 + rc = fillInUnixFile(pVfs, fd, syncDir, pFile, zPath, noLock, |
| 388 isDelete, isReadonly); |
| 389 open_finished: |
| 390 if( rc!=SQLITE_OK ){ |
| 391 @@ -5172,13 +5168,13 @@ static int unixDelete( |
| 392 int rc = SQLITE_OK; |
| 393 UNUSED_PARAMETER(NotUsed); |
| 394 SimulateIOError(return SQLITE_IOERR_DELETE); |
| 395 - if( unlink(zPath)==(-1) && errno!=ENOENT ){ |
| 396 + if( osUnlink(zPath)==(-1) && errno!=ENOENT ){ |
| 397 return unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath); |
| 398 } |
| 399 #ifndef SQLITE_DISABLE_DIRSYNC |
| 400 if( dirSync ){ |
| 401 int fd; |
| 402 - rc = openDirectory(zPath, &fd); |
| 403 + rc = osOpenDirectory(zPath, &fd); |
| 404 if( rc==SQLITE_OK ){ |
| 405 #if OS_VXWORKS |
| 406 if( fsync(fd)==-1 ) |
| 407 @@ -5189,6 +5185,8 @@ static int unixDelete( |
| 408 rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath); |
| 409 } |
| 410 robust_close(0, fd, __LINE__); |
| 411 + }else if( rc==SQLITE_CANTOPEN ){ |
| 412 + rc = SQLITE_OK; |
| 413 } |
| 414 } |
| 415 #endif |
| 416 @@ -5231,7 +5229,7 @@ static int unixAccess( |
| 417 *pResOut = (osAccess(zPath, amode)==0); |
| 418 if( flags==SQLITE_ACCESS_EXISTS && *pResOut ){ |
| 419 struct stat buf; |
| 420 - if( 0==stat(zPath, &buf) && buf.st_size==0 ){ |
| 421 + if( 0==osStat(zPath, &buf) && buf.st_size==0 ){ |
| 422 *pResOut = 0; |
| 423 } |
| 424 } |
| 425 @@ -5750,7 +5748,6 @@ static int proxyCreateUnixFile( |
| 426 int islockfile /* if non zero missing dirs will be created */ |
| 427 ) { |
| 428 int fd = -1; |
| 429 - int dirfd = -1; |
| 430 unixFile *pNew; |
| 431 int rc = SQLITE_OK; |
| 432 int openFlags = O_RDWR | O_CREAT; |
| 433 @@ -5815,7 +5812,7 @@ static int proxyCreateUnixFile( |
| 434 pUnused->flags = openFlags; |
| 435 pNew->pUnused = pUnused; |
| 436 |
| 437 - rc = fillInUnixFile(&dummyVfs, fd, dirfd, (sqlite3_file*)pNew, path, 0, 0, 0)
; |
| 438 + rc = fillInUnixFile(&dummyVfs, fd, 0, (sqlite3_file*)pNew, path, 0, 0, 0); |
| 439 if( rc==SQLITE_OK ){ |
| 440 *ppFile = pNew; |
| 441 return SQLITE_OK; |
| 442 @@ -5929,7 +5926,7 @@ static int proxyBreakConchLock(unixFile *pFile, uuid_t myH
ostID){ |
| 443 end_breaklock: |
| 444 if( rc ){ |
| 445 if( fd>=0 ){ |
| 446 - unlink(tPath); |
| 447 + osUnlink(tPath); |
| 448 robust_close(pFile, fd, __LINE__); |
| 449 } |
| 450 fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg); |
| 451 @@ -6752,7 +6749,7 @@ int sqlite3_os_init(void){ |
| 452 |
| 453 /* Double-check that the aSyscall[] array has been constructed |
| 454 ** correctly. See ticket [bb3a86e890c8e96ab] */ |
| 455 - assert( ArraySize(aSyscall)==16 ); |
| 456 + assert( ArraySize(aSyscall)==18 ); |
| 457 |
| 458 /* Register all VFSes defined in the aVfs[] array */ |
| 459 for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){ |
| 460 diff --git a/third_party/sqlite/src/test/syscall.test b/third_party/sqlite/src/t
est/syscall.test |
| 461 index 4442612..201bd63 100644 |
| 462 --- a/third_party/sqlite/src/test/syscall.test |
| 463 +++ b/third_party/sqlite/src/test/syscall.test |
| 464 @@ -59,7 +59,7 @@ do_test 2.1.2 { test_syscall exists nosuchcall } 0 |
| 465 foreach s { |
| 466 open close access getcwd stat fstat ftruncate |
| 467 fcntl read pread write pwrite fchmod fallocate |
| 468 - pread64 pwrite64 |
| 469 + pread64 pwrite64 unlink openDirectory |
| 470 } { |
| 471 if {[test_syscall exists $s]} {lappend syscall_list $s} |
| 472 } |
| 473 -- |
| 474 2.2.1 |
| 475 |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 885473002:
[sql] Rewrite sqlite patching "system". (Closed)
Base URL: http://chromium.googlesource.com/chromium/src.git@master