forked from harbour/core
-
Notifications
You must be signed in to change notification settings - Fork 0
/
locks.txt
176 lines (134 loc) · 6.16 KB
/
locks.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
Locking schemes used with DBF files.
Przemyslaw Czerpak (druzus/at/poczta.onet.pl)
Exclusive/shared modes (DENY READ, DENY WRITE) in POSIX systems.
================================================================
Exclusive modes (DENY READ, DENY WRITE) do not exist in POSIX systems.
They can be emulated by fcntl() or flock() locks. Harbour uses flock()
in systems where it does not create conflicts with fcntl() locks used
to synchronize file access by different processes in shared mode.
Currently it's enabled by default only in Linux (tests with *BSD systems
and macOS showed that it interacts with fcntl locks causing deadlocks).
On other POSIX systems Harbour uses fcntl() read and write locks at
address 0x7fffffff (size 1) to simulate shared and exclusive mode.
CLIP and FlagShip use fcntl() locks to simulate shared/exclusive modes.
CLIP shared/exclusive flag: 0x7fffffff : 1 (the same as Harbour)
FlagShip shared/exclusive flag: 0x7ffffbfc : 1
File access synchronization (record and file locking) in shared mode.
=====================================================================
FlagShip uses different record and index locking schemes
(i.e. for RLOCK it locks record area) and it is not described
here.
In documentation CLIP can use Clipper like or FoxPro like locking
schemes and it can be controlled by SET LOCKSTYLE [TO] ... command
or Set( _SET_LOCKSTYLE, 0 | 1 ) function.
This switch only changes the RLOCK/FLOCK offset.
For:
SET LOCKSTYLE [TO] CLIPPER | CLIPPER50 | CLIPPER53
or:
Set( _SET_LOCKSTYLE, 0 )
this offset is set to 1'000'000'000. This is header lock address
and records are locked at above address + record number.
This is compatible with standard Clipper locking.
Commands:
SET LOCKSTYLE [TO] CLIPPER52 | FOXPRO | SIX
or:
Set( _SET_LOCKSTYLE, 1 )
set this offset to 0x10000000 keeping the same algorithm
for record locking what is incompatible with any other locking
schemes known by me. For sure it's not compatible with [V]FP
locking (see details about this locking scheme below).
For more information look at CLIP source code.
(*) In Harbour index read locks are shared on platforms which support
shared (read) locks.
Clipper DBFNTX locking:
=======================
all locks are exclusive (*)
DBF HEADER LOCK: @1000000000 : 1 (exclusive)
DBF RECORD LOCK: @1000000000 + recNO : 1 (exclusive)
DBF FLOCK SIZE: 1000000000
=> maximum records: 3'294'967'295
maximum file size in non POSIX systems: 1'000'000'000
NTX READ LOCK: @1000000000 : 1 (exclusive)
NTX WRITE LOCK: @1000000000 : 1 (exclusive)
In Harbour it's DB_DBFLOCK_CLIPPER.
Clipper new DBFNTX locking (ntxlock2.obj):
==========================================
all locks are exclusive (*)
DBF HEADER LOCK: @4000000000 : 1 (exclusive)
DBF RECORD LOCK: @4000000000 + recNO : 1 (exclusive)
DBF FLOCK SIZE: 294967295
=> maximum records: 294'967'295
maximum file size in non POSIX systems: 4'000'000'000
NTX READ LOCK: @1000000000 : 1 (exclusive)
NTX WRITE LOCK: @1000000000 : 1 (exclusive)
In Harbour it's DB_DBFLOCK_CLIPPER2.
CL52 DBFCDX, SIX3 SIXCDX, SIX3 SIXNSX, [V]FP CDX
================================================
all locks are exclusive (*)
when there is no structural index:
DBF HEADER LOCK: @0x40000000 : 1
DBF RECORD LOCK: @0x40000000 + record offset : 1 (some implementations
locks whole record)
DBF FLOCK SIZE: 0x3ffffffd
=> maximum file size: 1'073'741'823
when structural index is open:
DBF HEADER LOCK: @0x7ffffffe : 1
DBF RECORD LOCK: @0x7ffffffe - recNO : 1
DBF FLOCK SIZE: 0x07ffffff
=> maximum records: 134'217'727
maximum file size in non POSIX systems: 2'013'265'919
index file locking is the same for production and normal indexes:
CDX READ LOCK: @0x7ffffffe : 1
CDX WRITE LOCK: @0x7ffffffe : 1
In Harbour it's DB_DBFLOCK_VFP.
CL53 DBFCDX, COMIX (hyper locking)
==================================
all locks are exclusive (*), in index shared locks are emulated
DBF HEADER LOCK: @1000000000 : 1
DBF RECORD LOCK: @1000000000 + recNO : 1
DBF FLOCK SIZE: 1000000000
=> maximum records: 1'000'000'000
maximum file size in non POSIX systems: 1'000'000'000
CDX READ LOCK: @0xffff0000 + random value from 0x0 to 0xffff : 1
CDX WRITE LOCK: @0xfffeffff : 0x10001
if fail then @0xfffeffff : 1
prepare the index modification in memory and before writing to
index file lock @0xffff0000 : 0x10000
to eliminate starvation effect caused by many readers
on each 16th read lock reading process tries to lock write
area @0xfffeffff : 1 instead and then sets normal read lock
In Harbour it's DB_DBFLOCK_COMIX.
Harbour 32-bit locking
======================
all locks are exclusive (*), in index shared locks are emulated
DBF HEADER LOCK: @4000000000 : 1 (exclusive)
DBF RECORD LOCK: @4000000000 + recNO : 1 (exclusive)
DBF FLOCK SIZE: 294967295
=> maximum records: 294'967'295
maximum file size in non POSIX systems: 4'000'000'000
CDX READ LOCK: @0xffff0000 + random value from 0x0 to 0xffff : 1
CDX WRITE LOCK: @0xfffeffff : 0x10001
if fail then @0xfffeffff : 1
prepare the index modification in memory and before writing to
index file lock @0xffff0000 : 0x10000
to eliminate starvation effect caused by many readers
on each 16th read lock reading process tries to lock write
area @0xfffeffff : 1 instead and then sets normal read lock
In Harbour it's DB_DBFLOCK_HB32.
Harbour 64-bit locking
======================
all locks are exclusive (*), in index shared locks are emulated
DBF HEADER LOCK: @0x7fffffff00000001 : 1
DBF RECORD LOCK: @0x7fffffff00000001 + recNO : 1
DBF FLOCK SIZE: 0xfffffffeUL
=> maximum records: 4'294'967'294
maximum file size: no limits created by locks
CDX READ LOCK: @0x7fffffff00000000 + random value from 0x1 to 0xffff : 1
CDX WRITE LOCK: @0x7fffffff00000000 : 0x10001
if fail then @0x7fffffff00000000 : 1
prepare the index modification in memory and before writing to
index file lock @0x7fffffff00000001 : 0x10000
to eliminate starvation effect caused by many readers
on each 16th read lock reading process tries to lock write
area @0x7fffffff00000000 : 1 instead and then sets normal read lock
In Harbour it's DB_DBFLOCK_HB64.