1//go:build !sqlite3_dotlk
2
3package vfs
4
5import (
6 "os"
7 "time"
8
9 "golang.org/x/sys/windows"
10)
11
12func osReadAt(file *os.File, p []byte, off int64) (int, error) {
13 return file.ReadAt(p, off)
14}
15
16func osWriteAt(file *os.File, p []byte, off int64) (int, error) {
17 n, err := file.WriteAt(p, off)
18 if errno, ok := err.(windows.Errno); ok {
19 switch errno {
20 case
21 windows.ERROR_HANDLE_DISK_FULL,
22 windows.ERROR_DISK_FULL:
23 return n, _FULL
24 }
25 }
26 return n, err
27}
28
29func osGetSharedLock(file *os.File) _ErrorCode {
30 // Acquire the PENDING lock temporarily before acquiring a new SHARED lock.
31 rc := osReadLock(file, _PENDING_BYTE, 1, 0)
32 if rc == _OK {
33 // Acquire the SHARED lock.
34 rc = osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0)
35
36 // Release the PENDING lock.
37 osUnlock(file, _PENDING_BYTE, 1)
38 }
39 return rc
40}
41
42func osGetReservedLock(file *os.File) _ErrorCode {
43 // Acquire the RESERVED lock.
44 return osWriteLock(file, _RESERVED_BYTE, 1, 0)
45}
46
47func osGetExclusiveLock(file *os.File, state *LockLevel) _ErrorCode {
48 // A PENDING lock is needed before releasing the SHARED lock.
49 if *state < LOCK_PENDING {
50 // If we were RESERVED, we can block indefinitely.
51 var timeout time.Duration
52 if *state == LOCK_RESERVED {
53 timeout = -1
54 }
55 if rc := osWriteLock(file, _PENDING_BYTE, 1, timeout); rc != _OK {
56 return rc
57 }
58 *state = LOCK_PENDING
59 }
60
61 // Release the SHARED lock.
62 osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
63
64 // Acquire the EXCLUSIVE lock.
65 // Can't wait here, because the file is not OVERLAPPED.
66 rc := osWriteLock(file, _SHARED_FIRST, _SHARED_SIZE, 0)
67
68 if rc != _OK {
69 // Reacquire the SHARED lock.
70 if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK {
71 // notest // this should never happen
72 return _IOERR_RDLOCK
73 }
74 }
75 return rc
76}
77
78func osDowngradeLock(file *os.File, state LockLevel) _ErrorCode {
79 if state >= LOCK_EXCLUSIVE {
80 // Release the EXCLUSIVE lock while holding the PENDING lock.
81 osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
82
83 // Reacquire the SHARED lock.
84 if rc := osReadLock(file, _SHARED_FIRST, _SHARED_SIZE, 0); rc != _OK {
85 // notest // this should never happen
86 return _IOERR_RDLOCK
87 }
88 }
89
90 // Release the PENDING and RESERVED locks.
91 if state >= LOCK_RESERVED {
92 osUnlock(file, _RESERVED_BYTE, 1)
93 }
94 if state >= LOCK_PENDING {
95 osUnlock(file, _PENDING_BYTE, 1)
96 }
97 return _OK
98}
99
100func osReleaseLock(file *os.File, state LockLevel) _ErrorCode {
101 // Release all locks, PENDING must be last.
102 if state >= LOCK_RESERVED {
103 osUnlock(file, _RESERVED_BYTE, 1)
104 }
105 if state >= LOCK_SHARED {
106 osUnlock(file, _SHARED_FIRST, _SHARED_SIZE)
107 }
108 if state >= LOCK_PENDING {
109 osUnlock(file, _PENDING_BYTE, 1)
110 }
111 return _OK
112}
113
114func osCheckReservedLock(file *os.File) (bool, _ErrorCode) {
115 // Test the RESERVED lock.
116 rc := osLock(file, 0, _RESERVED_BYTE, 1, 0, _IOERR_CHECKRESERVEDLOCK)
117 if rc == _BUSY {
118 return true, _OK
119 }
120 if rc == _OK {
121 // Release the RESERVED lock.
122 osUnlock(file, _RESERVED_BYTE, 1)
123 }
124 return false, rc
125}
126
127func osReadLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode {
128 return osLock(file, 0, start, len, timeout, _IOERR_RDLOCK)
129}
130
131func osWriteLock(file *os.File, start, len uint32, timeout time.Duration) _ErrorCode {
132 return osLock(file, windows.LOCKFILE_EXCLUSIVE_LOCK, start, len, timeout, _IOERR_LOCK)
133}
134
135func osLock(file *os.File, flags, start, len uint32, timeout time.Duration, def _ErrorCode) _ErrorCode {
136 var err error
137 switch {
138 default:
139 err = osLockEx(file, flags|windows.LOCKFILE_FAIL_IMMEDIATELY, start, len)
140 case timeout < 0:
141 err = osLockEx(file, flags, start, len)
142 }
143 return osLockErrorCode(err, def)
144}
145
146func osUnlock(file *os.File, start, len uint32) _ErrorCode {
147 err := windows.UnlockFileEx(windows.Handle(file.Fd()),
148 0, len, 0, &windows.Overlapped{Offset: start})
149 if err == windows.ERROR_NOT_LOCKED {
150 return _OK
151 }
152 if err != nil {
153 return _IOERR_UNLOCK
154 }
155 return _OK
156}
157
158func osLockEx(file *os.File, flags, start, len uint32) error {
159 return windows.LockFileEx(windows.Handle(file.Fd()), flags,
160 0, len, 0, &windows.Overlapped{Offset: start})
161}
162
163func osLockErrorCode(err error, def _ErrorCode) _ErrorCode {
164 if err == nil {
165 return _OK
166 }
167 if errno, ok := err.(windows.Errno); ok {
168 // https://devblogs.microsoft.com/oldnewthing/20140905-00/?p=63
169 switch errno {
170 case
171 windows.ERROR_LOCK_VIOLATION,
172 windows.ERROR_OPERATION_ABORTED,
173 windows.ERROR_IO_PENDING,
174 windows.WAIT_TIMEOUT:
175 return _BUSY
176 }
177 }
178 return def
179}