Re: (ITS#7996) Tighten race in ldap_int_initialize
by Armin.Tueting@tueting-online.com
Am Montag, den 17.06.2019, 15:40 -0700 schrieb Quanah Gibson-Mount:
> --On Monday, June 17, 2019 7:16 PM +0200 Armin T=C3=BCting=20
> <Armin.Tueting(a)tueting-online.com> wrote:
>=20
> > > I.e., it started and then got as far as reading your ldap.conf file.
> > > What is the contents of ldap.conf?
> > Attached 'ldap.conf'. Nothing unusual...
> >=20
> > > Have you run the test suite (make test)? Does it pass? fail?
> > Attached 'make_test.txt'. As far as I can see - it has been passed.
>=20
> Ok, so make test passes without issue, so it would appear there's somethi=
ng=20
> specific with your configuration that is triggering the problem. Would y=
ou=20
> be able to provide your slapd configuration (minus any passwords and the=
=20
> like)?
I'll privately send it to you in a seperate email.
>=20
> Additionally, if you could get a full gdb backtrace of the hung slapd=20
> process that would be useful as well. I.e.:
>=20
> start up slapd
> gdb /path/to/slapd <pid #>
(gdb) thr apply all bt full
Thread 1 (Thread 0x7ffa4ad71880 (LWP 9207)):
#0 0x00007ffa4918c4ed in __lll_lock_wait () from
/lib64/libpthread.so.0
No symbol table info available.
#1 0x00007ffa49187dcb in _L_lock_883 () from /lib64/libpthread.so.0
No symbol table info available.
#2 0x00007ffa49187c98 in pthread_mutex_lock () from
/lib64/libpthread.so.0
No symbol table info available.
#3 0x00007ffa4a92a135 in ldap_pvt_thread_mutex_lock (mutex=3D<optimized
out>) at thr_posix.c:296
No locals.
#4 0x00007ffa4a944e6e in ldap_set_option (ld=3Dld@entry=3D0x0,=20
option=3Doption@entry=3D20486, invalue=3Dinvalue@entry=3D0x7ffdceb7aeb4)
at options.c:465
lo =3D 0x7176c0 <ldap_int_global_options>
dbglvl =3D 0x0
rc =3D -1
__PRETTY_FUNCTION__ =3D "ldap_set_option"
#5 0x00007ffa4a943ed3 in openldap_ldap_init_w_conf (file=3Dfile@entry=3D0x
7ffa4a95a750 "/opt/openldap/etc/openldap/ldap.conf",=20
userconf=3Duserconf@entry=3D0) at init.c:270
p =3D <optimized out>
linebuf =3D
"URI\000ldap://localhost/\000\000tions\n\000ware/man.cgi?query=3Dldap.con
f\n\000ldapusingtlswithsshapasswords\n\000\000\377\377\000\000\177\003"
, '\000' <repeats 22 times>, "\200\037\000\000\377\377", '\000'
<repeats 152 times>...
fp =3D 0x8177b0
i =3D <optimized out>
opt =3D 0x7ffdceb7aeb4 "ldap://localhost/"
start =3D 0x7ffdceb7aeb4 "ldap://localhost/"
end =3D <optimized out>
gopts =3D 0x7ffa4ab67120 <ldap_int_global_options>
#6 0x00007ffa4a944318 in openldap_ldap_init_w_sysconf
(file=3D0x7ffa4a95a750 "/opt/openldap/etc/openldap/ldap.conf") at
init.c:316
No locals.
#7 ldap_int_initialize (gopts=3Dgopts@entry=3D0x7176c0
<ldap_int_global_options>, dbglvl=3Ddbglvl@entry=3D0x719050 <slap_debug>)
at init.c:684
No locals.
#8 0x00007ffa4a944e38 in ldap_set_option (ld=3D0x0, option=3D20481,
invalue=3D0x719050 <slap_debug>) at options.c:450
lo =3D <optimized out>
dbglvl =3D 0x719050 <slap_debug>
rc =3D -1
__PRETTY_FUNCTION__ =3D "ldap_set_option"
#9 0x0000000000413cd6 in main ()
No symbol table info available.
> at the gdb prompt:
>=20
> thr apply all bt full
>=20
> Thanks!
>=20
> --Quanah
>=20
>=20
>=20
> --
>=20
> Quanah Gibson-Mount
> Product Architect
> Symas Corporation
> Packaged, certified, and supported LDAP solutions powered by OpenLDAP:
> <http://www.symas.com>
>=20
4 years, 5 months
Re: (ITS#7996) Tighten race in ldap_int_initialize
by Armin.Tueting@tueting-online.com
Am Montag, den 17.06.2019, 15:40 -0700 schrieb Quanah Gibson-Mount:
> --On Monday, June 17, 2019 7:16 PM +0200 Armin T=C3=BCting=20
> <Armin.Tueting(a)tueting-online.com> wrote:
>=20
> > > I.e., it started and then got as far as reading your ldap.conf file.
> > > What is the contents of ldap.conf?
> > Attached 'ldap.conf'. Nothing unusual...
> >=20
> > > Have you run the test suite (make test)? Does it pass? fail?
> > Attached 'make_test.txt'. As far as I can see - it has been passed.
>=20
> Ok, so make test passes without issue, so it would appear there's somethi=
ng=20
> specific with your configuration that is triggering the problem. Would y=
ou=20
> be able to provide your slapd configuration (minus any passwords and the=
=20
> like)?
I'll privately send it to you in a seperate email.
>=20
> Additionally, if you could get a full gdb backtrace of the hung slapd=20
> process that would be useful as well. I.e.:
>=20
> start up slapd
> gdb /path/to/slapd <pid #>
(gdb) thr apply all bt full
Thread 1 (Thread 0x7ffa4ad71880 (LWP 9207)):
#0 0x00007ffa4918c4ed in __lll_lock_wait () from
/lib64/libpthread.so.0
No symbol table info available.
#1 0x00007ffa49187dcb in _L_lock_883 () from /lib64/libpthread.so.0
No symbol table info available.
#2 0x00007ffa49187c98 in pthread_mutex_lock () from
/lib64/libpthread.so.0
No symbol table info available.
#3 0x00007ffa4a92a135 in ldap_pvt_thread_mutex_lock (mutex=3D<optimized
out>) at thr_posix.c:296
No locals.
#4 0x00007ffa4a944e6e in ldap_set_option (ld=3Dld@entry=3D0x0,=20
option=3Doption@entry=3D20486, invalue=3Dinvalue@entry=3D0x7ffdceb7aeb4)
at options.c:465
lo =3D 0x7176c0 <ldap_int_global_options>
dbglvl =3D 0x0
rc =3D -1
__PRETTY_FUNCTION__ =3D "ldap_set_option"
#5 0x00007ffa4a943ed3 in openldap_ldap_init_w_conf (file=3Dfile@entry=3D0x
7ffa4a95a750 "/opt/openldap/etc/openldap/ldap.conf",=20
userconf=3Duserconf@entry=3D0) at init.c:270
p =3D <optimized out>
linebuf =3D
"URI\000ldap://localhost/\000\000tions\n\000ware/man.cgi?query=3Dldap.con
f\n\000ldapusingtlswithsshapasswords\n\000\000\377\377\000\000\177\003"
, '\000' <repeats 22 times>, "\200\037\000\000\377\377", '\000'
<repeats 152 times>...
fp =3D 0x8177b0
i =3D <optimized out>
opt =3D 0x7ffdceb7aeb4 "ldap://localhost/"
start =3D 0x7ffdceb7aeb4 "ldap://localhost/"
end =3D <optimized out>
gopts =3D 0x7ffa4ab67120 <ldap_int_global_options>
#6 0x00007ffa4a944318 in openldap_ldap_init_w_sysconf
(file=3D0x7ffa4a95a750 "/opt/openldap/etc/openldap/ldap.conf") at
init.c:316
No locals.
#7 ldap_int_initialize (gopts=3Dgopts@entry=3D0x7176c0
<ldap_int_global_options>, dbglvl=3Ddbglvl@entry=3D0x719050 <slap_debug>)
at init.c:684
No locals.
#8 0x00007ffa4a944e38 in ldap_set_option (ld=3D0x0, option=3D20481,
invalue=3D0x719050 <slap_debug>) at options.c:450
lo =3D <optimized out>
dbglvl =3D 0x719050 <slap_debug>
rc =3D -1
__PRETTY_FUNCTION__ =3D "ldap_set_option"
#9 0x0000000000413cd6 in main ()
No symbol table info available.
> at the gdb prompt:
>=20
> thr apply all bt full
>=20
> Thanks!
>=20
> --Quanah
>=20
>=20
>=20
> --
>=20
> Quanah Gibson-Mount
> Product Architect
> Symas Corporation
> Packaged, certified, and supported LDAP solutions powered by OpenLDAP:
> <http://www.symas.com>
>=20
4 years, 5 months
RE: (ITS#9037) observing crash in mdb_cursor_put()
by grobins@pulsesecure.net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4 years, 5 months
Re: (ITS#9037) observing crash in mdb_cursor_put()
by myk@mykzilla.org
hyc(a)symas.com wrote on 2019-06-17 05:25:
> grobins(a)pulsesecure.net wrote:
>> I am seeing LMDB crash, please find the stack trace.
>>
>> #0 0x009e362e in mdb_cursor_put (mc=0xffd59bb8, key=0xffd59d14,
>> data=0xffd59d0c, flags=0) at mdb.c:6688
>> #1 0x009e48ec in mdb_put (txn=0xd74d3008, dbi=2, key=0xffd59d14,
>> data=0xffd59d0c, flags=0) at mdb.c:8771
>> …
>>
>> Anybody has seen similar issue before?
> Doesn't sound familiar. But 0.9.18 is quite old. If you can reproduce this
> issue in 0.9.23 then we'll take a look. Test code to reproduce the problem
> would also be needed.
I'm seeing this in Firefox, which uses LMDB 0.9.23 (with minor changes).
Line 6688 in 0.9.18 occurs at line 6938 in 0.9.23 (line 6937 in Firefox
since we landed ITS#9030), and that's where we see crashes.
I haven't reported it here yet because I haven't been able to confirm
that it's a bug in LMDB as opposed to my own code. In fact I haven't
been able to reproduce it at all, I've only seen it in crash reports
submitted by Firefox installations (almost exclusively on Windows). So I
don't have test code to reproduce the problem.
Nevertheless, FWIW, here's the Firefox bug that tracks the issue:
https://bugzilla.mozilla.org/show_bug.cgi?id=1538541. And here are its
crash reports:
https://crash-stats.mozilla.org/signature/?signature=mdb_cursor_put
(only the last seven days of reports shown by default, but this has been
happening since we started using LMDB in Firefox nightly builds a couple
of months ago).
I've examined some of the dumps, and mc->mc_top is 0 when the crash
occurs, while mc->mc_pg[0] is a NULL pointer. So presumably the crash
occurs because IS_LEAF2 tries to dereference mc->mc_pg[mc->mc_top].
Further investigation shows that insert_data and insert_key are both
MDB_NOTFOUND, and flags is 0, so it isn't MDB_CURRENT, nor does it
contain MDB_APPEND. If I understand the code in mdb_cursor_put
correctly, this means that mdb_cursor_set was called on line 6614.
And mdb_cursor_set is in the stack of another crash I've been
investigating in mdb_page_search_root
(https://bugzilla.mozilla.org/show_bug.cgi?id=1550174,
https://crash-stats.mozilla.org/signature/?signature=mdb_page_search_root),
which happens on all of Firefox's primary platforms (Windows, macOS, Linux).
But I haven't been able to reproduce that one either, on any of those
platforms, so I have no idea if they're related (nor if mdb_cursor_set
is even implicated in this crash). And I still can't say that either is
an LMDB bug.
-myk
4 years, 5 months
Re: (ITS#7996) Tighten race in ldap_int_initialize
by quanah@symas.com
--On Monday, June 17, 2019 7:16 PM +0200 Armin T=C3=BCting=20
<Armin.Tueting(a)tueting-online.com> wrote:
>> I.e., it started and then got as far as reading your ldap.conf file.
>> What is the contents of ldap.conf?
> Attached 'ldap.conf'. Nothing unusual...
>
>> Have you run the test suite (make test)? Does it pass? fail?
> Attached 'make_test.txt'. As far as I can see - it has been passed.
Ok, so make test passes without issue, so it would appear there's something =
specific with your configuration that is triggering the problem. Would you =
be able to provide your slapd configuration (minus any passwords and the=20
like)?
Additionally, if you could get a full gdb backtrace of the hung slapd=20
process that would be useful as well. I.e.:
start up slapd
gdb /path/to/slapd <pid #>
at the gdb prompt:
thr apply all bt full
Thanks!
--Quanah
--
Quanah Gibson-Mount
Product Architect
Symas Corporation
Packaged, certified, and supported LDAP solutions powered by OpenLDAP:
<http://www.symas.com>
4 years, 5 months
Re: (ITS#9017) Improving performance of commit sync in Windows
by kriszyp@gmail.com
--000000000000db50ce058b89ac2f
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Is this still being considered/reviewed? Let me know if there are any other
changes you would like me to make. This patch has continued to yield
significant and reliable performance improvements for us, and seems like it
would be nice for this to be available for other Windows users.
On Fri, May 3, 2019 at 3:52 PM Kris Zyp <kriszyp(a)gmail.com> wrote:
> For the sake of putting this in the email thread (other code discussion i=
n
> GitHub), here is the latest squashed commit of the proposed patch (with t=
he
> on-demand, retained overlapped array to reduce re-malloc and opening even=
t
> handles):
> https://github.com/kriszyp/node-lmdb/commit/726a9156662c703bf3d453aab75ee=
222072b990f
>
>
>
> Thanks,
> Kris
>
>
>
> *From: *Kris Zyp <kriszyp(a)gmail.com>
> *Sent: *April 30, 2019 12:43 PM
> *To: *Howard Chu <hyc(a)symas.com>; openldap-its(a)OpenLDAP.org
> *Subject: *RE: (ITS#9017) Improving performance of commit sync in Windows
>
>
>
> > What is the point of using writemap mode if you still need to use
> WriteFile
>
> > on every individual page?
>
>
>
> As I understood from the documentation, and have observed, using writemap
> mode is faster (and uses less temporary memory) because it doesn=E2=80=99=
t require
> mallocs to allocate pages (docs: =E2=80=9CThis is faster and uses fewer m=
allocs=E2=80=9D).
> To be clear though, LMDB is so incredibly fast and efficient, that in
> sync-mode, it takes enormous transactions before the time spent allocatin=
g
> and creating the dirty pages with the updated b-tree is anywhere even
> remotely close to the time it takes to wait for disk flushing, even with =
an
> SSD. But the more pertinent question is efficiency, and measuring CPU
> cycles rather than time spent (efficiency is more important than just tim=
e
> spent). When I ran my tests this morning of 100 (sync) transactions with
> 100 puts per transaction, times varied quite a bit, but it seemed like
> running with writemap enabled typically averages about 500ms of CPU and
> with writemap disabled it typically averages around 600ms. Not a huge
> difference, but still definitely worthwhile, I think.
>
>
>
> Caveat emptor: Measuring LMDB performance with sync interactions on
> Windows is one of the most frustratingly erratic things to measure. It is
> sunny outside right now, times could be different when it starts raining
> later, but, this is what I saw this morning...
>
>
>
> > What is the performance difference between your patch using writemap,
> and just
>
> > not using writemap in the first place?
>
>
>
> Running 1000 sync transactions on 3GB db with a single put per
> transaction, without writemap map, without the patch took about 60 second=
s.
> And it took about 1 second with the patch with writemap mode enabled!
> (there is no significant difference in sync times with writemap enabled o=
r
> disabled with the patch.) So the difference was huge in my test. And not
> only that, without the patch, the CPU usage was actually _*higher*_
> during that 60 seconds (close to 100% of a core) than during the executio=
n
> with the patch for one second (close to 50%). Anyway, there are certainl=
y
> tests I have run where the differences are not as large (doing small
> commits on large dbs accentuates the differences), but the patch always
> seems to win. It could also be that my particular configuration causes
> bigger differences (on an SSD drive, and maybe a more fragmented file?).
>
>
>
> Anyway, I added error handling for the malloc, and fixed/changed the othe=
r
> things you suggested. Be happy to make any other changes you want. The
> updated patch is here:
>
>
> https://github.com/kriszyp/node-lmdb/commit/25366dea9453749cf6637f43ec17b=
9b62094acde
>
>
>
> > OVERLAPPED* ov =3D malloc((pagecount - keep) * sizeof(OVERLAPPED));
>
> > Probably this ought to just be pre-allocated based on the maximum
> number of dirty pages a txn allows.
>
>
>
> I wasn=E2=80=99t sure I understood this comment. Are you suggesting we ma=
lloc(MDB_IDL_UM_MAX
> * sizeof(OVERLAPPED)) for each environment, and retain it for the life of
> the environment? I think that is 4MB, if my math is right, which seems li=
ke
> a lot of memory to keep allocated (we usually have a lot of open
> environments). If the goal is to reduce the number of mallocs, how about =
we
> retain the OVERLAPPED array, and only free and re-malloc if the previous
> allocation wasn=E2=80=99t large enough? Then there isn=E2=80=99t unnecess=
ary allocation,
> and we only malloc when there is a bigger transaction than any previous. =
I
> put this together in a separate commit, as I wasn=E2=80=99t sure if this =
what you
> wanted (can squash if you prefer):
> https://github.com/kriszyp/node-lmdb/commit/2fe68fb5269c843e2e789746a17a4=
b2adefaac40
>
>
>
> Thank you for the review!
>
>
>
> Thanks,
> Kris
>
>
>
> *From: *Howard Chu <hyc(a)symas.com>
> *Sent: *April 30, 2019 7:12 AM
> *To: *kriszyp(a)gmail.com; openldap-its(a)OpenLDAP.org
> *Subject: *Re: (ITS#9017) Improving performance of commit sync in Windows
>
>
>
> kriszyp(a)gmail.com wrote:
>
> > Full_Name: Kristopher William Zyp
>
> > Version: LMDB 0.9.23
>
> > OS: Windows
>
> > URL:
> https://github.com/kriszyp/node-lmdb/commit/7ff525ae57684a163d32af74a0ab9=
332b7fc4ce9
>
> > Submission from: (NULL) (71.199.6.148)
>
> >
>
> >
>
> > We have seen very poor performance on the sync of commits on large
> databases in
>
> > Windows. On databases with 2GB of data, in writemap mode, the sync of
> even small
>
> > commits is consistently well over 100ms (without writemap it is faster,
> but
>
> > still slow). It is expected that a sync should take some time while
> waiting for
>
> > disk confirmation of the writes, but more concerning is that these sync
>
> > operations (in writemap mode) are instead dominated by nearly 100%
> system CPU
>
> > utilization, so operations that requires sub-millisecond b-tree update
>
> > operations are then dominated by very large amounts of system CPU cycle=
s
> during
>
> > the sync phase.
>
> >
>
> > I think that the fundamental problem is that FlushViewOfFile seems to b=
e
> an O(n)
>
> > operation where n is the size of the file (or map). I presume that
> Windows is
>
> > scanning the entire map/file for dirty pages to flush, I'm guessing
> because it
>
> > doesn't have an internal index of all the dirty pages for every
> file/map-view in
>
> > the OS disk cache. Therefore, the turns into an extremely expensive,
> CPU-bound
>
> > operation to find the dirty pages for (large file) and initiate their
> writes,
>
> > which, of course, is contrary to the whole goal of a scalable database
> system.
>
> > And FlushFileBuffers is also relatively slow as well. We have attempted
> to batch
>
> > as many operations into single transaction as possible, but this is
> still a very
>
> > large overhead.
>
> >
>
> > The Windows docs for FlushFileBuffers itself warns about the
> inefficiencies of
>
> > this function (
> https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-f=
lushfilebuffers
> ).
>
> > Which also points to the solution: it is much faster to write out the
> dirty
>
> > pages with WriteFile through a sync file handle
> (FILE_FLAG_WRITE_THROUGH).
>
> >
>
> > The associated patch
>
> > (
> https://github.com/kriszyp/node-lmdb/commit/7ff525ae57684a163d32af74a0ab9=
332b7fc4ce9
> )
>
> > is my attempt at implementing this solution, for Windows. Fortunately,
> with the
>
> > design of LMDB, this is relatively straightforward. LMDB already suppor=
ts
>
> > writing out dirty pages with WriteFile calls. I added a write-through
> handle for
>
> > sending these writes directly to disk. I then made that file-handle
>
> > overlapped/asynchronously, so all the writes for a commit could be
> started in
>
> > overlap mode, and (at least theoretically) transfer in parallel to the
> drive and
>
> > then used GetOverlappedResult to wait for the completion. So basically
>
> > mdb_page_flush becomes the sync. I extended the writing of dirty pages
> through
>
> > WriteFile to writemap mode as well (for writing meta too), so that
> WriteFile
>
> > with write-through can be used to flush the data without ever needing t=
o
> call
>
> > FlushViewOfFile or FlushFileBuffers. I also implemented support for wri=
te
>
> > gathering in writemap mode where contiguous file positions infers
> contiguous
>
> > memory (by tracking the starting position with wdp and writing
> contiguous pages
>
> > in single operations). Sorting of the dirty list is maintained even in
> writemap
>
> > mode for this purpose.
>
>
>
> What is the point of using writemap mode if you still need to use WriteFi=
le
>
> on every individual page?
>
>
>
> > The performance benefits of this patch, in my testing, are considerable=
.
> Writing
>
> > out/syncing transactions is typically over 5x faster in writemap mode,
> and 2x
>
> > faster in standard mode. And perhaps more importantly (especially in
> environment
>
> > with many threads/processes), the efficiency benefits are even larger,
>
> > particularly in writemap mode, where there can be a 50-100x reduction i=
n
> the
>
> > system CPU usage by using this patch. This brings windows performance
> with
>
> > sync'ed transactions in LMDB back into the range of "lightning"
> performance :).
>
>
>
> What is the performance difference between your patch using writemap, and
> just
>
> not using writemap in the first place?
>
>
>
> --
>
> -- Howard Chu
>
> CTO, Symas Corp. http://www.symas.com
>
> Director, Highland Sun http://highlandsun.com/hyc/
>
> Chief Architect, OpenLDAP http://www.openldap.org/project/
>
>
>
>
>
--000000000000db50ce058b89ac2f
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">Is this still being considered/reviewed? Let me know if th=
ere are any other changes you would like me to make. This patch has continu=
ed to yield significant and reliable performance improvements for us, and s=
eems like it would be nice for this to be available for other Windows users=
.</div><br><div class=3D"gmail_quote"><div dir=3D"ltr" class=3D"gmail_attr"=
>On Fri, May 3, 2019 at 3:52 PM Kris Zyp <<a href=3D"mailto:kriszyp@gmai=
l.com">kriszyp(a)gmail.com</a>> wrote:<br></div><blockquote class=3D"gmail=
_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204=
,204);padding-left:1ex"><div lang=3D"EN-CA"><div class=3D"gmail-m_524243755=
9147988140WordSection1"><p class=3D"MsoNormal">For the sake of putting this=
in the email thread (other code discussion in GitHub), here is the latest =
squashed commit of the proposed patch (with the on-demand, retained overlap=
ped array to reduce re-malloc and opening event handles): <a href=3D"https:=
//github.com/kriszyp/node-lmdb/commit/726a9156662c703bf3d453aab75ee222072b9=
90f" target=3D"_blank">https://github.com/kriszyp/node-lmdb/commit/726a9156=
662c703bf3d453aab75ee222072b990f</a></p><p class=3D"MsoNormal"><u></u>=C2=
=A0<u></u></p><p class=3D"MsoNormal">Thanks,<br>Kris</p><p class=3D"MsoNorm=
al"><u></u>=C2=A0<u></u></p><div style=3D"border-right:none;border-bottom:n=
one;border-left:none;border-top:1pt solid rgb(225,225,225);padding:3pt 0cm =
0cm"><p class=3D"MsoNormal" style=3D"border:none;padding:0cm"><b>From: </b>=
<a href=3D"mailto:kriszyp@gmail.com" target=3D"_blank">Kris Zyp</a><br><b>S=
ent: </b>April 30, 2019 12:43 PM<br><b>To: </b><a href=3D"mailto:hyc@symas.=
com" target=3D"_blank">Howard Chu</a>; <a href=3D"mailto:openldap-its@OpenL=
DAP.org" target=3D"_blank">openldap-its(a)OpenLDAP.org</a><br><b>Subject: </b=
>RE: (ITS#9017) Improving performance of commit sync in Windows</p></div><p=
class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">> Wh=
at is the point of using writemap mode if you still need to use WriteFile<u=
></u><u></u></p><p class=3D"MsoNormal">> on every individual page?<u></u=
><u></u></p><p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoN=
ormal">As I understood from the documentation, and have observed, using wri=
temap mode is faster (and uses less temporary memory) because it doesn=E2=
=80=99t require mallocs to allocate pages (docs: =E2=80=9CThis is faster an=
d uses fewer mallocs=E2=80=9D). To be clear though, LMDB is so incredibly f=
ast and efficient, that in sync-mode, it takes enormous transactions before=
the time spent allocating and creating the dirty pages with the updated b-=
tree is anywhere even remotely close to the time it takes to wait for disk =
flushing, even with an SSD. But the more pertinent question is efficiency, =
and measuring CPU cycles rather than time spent (efficiency is more importa=
nt than just time spent). When I ran my tests this morning of 100 (sync) tr=
ansactions with 100 puts per transaction, times varied quite a bit, but it =
seemed like running with writemap enabled typically averages about 500ms of=
CPU and with writemap disabled it typically averages around 600ms. Not a h=
uge difference, but still definitely worthwhile, I think.<u></u><u></u></p>=
<p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">Cavea=
t emptor: Measuring LMDB performance with sync interactions on Windows is o=
ne of the most frustratingly erratic things to measure. It is sunny outside=
right now, times could be different when it starts raining later, but, thi=
s is what I saw this morning...<u></u><u></u></p><p class=3D"MsoNormal"><u>=
</u>=C2=A0<u></u></p><p class=3D"MsoNormal">> What is the performance di=
fference between your patch using writemap, and just<u></u><u></u></p><p cl=
ass=3D"MsoNormal">> not using writemap in the first place?<u></u><u></u>=
</p><p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">R=
unning 1000 sync transactions on 3GB db with a single put per transaction, =
without writemap map, without the patch took about 60 seconds. And it took =
about 1 second with the patch with writemap mode enabled! (there is no sign=
ificant difference in sync times with writemap enabled or disabled with the=
patch.) So the difference was huge in my test. And not only that, without =
the patch, the CPU usage was actually _<i>higher</i>_ during that 60 second=
s (close to 100% of a core) than during the execution with the patch for on=
e second (close to 50%).=C2=A0 Anyway, there are certainly tests I have run=
where the differences are not as large (doing small commits on large dbs a=
ccentuates the differences), but the patch always seems to win. It could al=
so be that my particular configuration causes bigger differences (on an SSD=
drive, and maybe a more fragmented file?).<u></u><u></u></p><p class=3D"Ms=
oNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">Anyway, I added err=
or handling for the malloc, and fixed/changed the other things you suggeste=
d. Be happy to make any other changes you want. The updated patch is here:<=
u></u><u></u></p><p class=3D"MsoNormal"><a href=3D"https://github.com/krisz=
yp/node-lmdb/commit/25366dea9453749cf6637f43ec17b9b62094acde" target=3D"_bl=
ank">https://github.com/kriszyp/node-lmdb/commit/25366dea9453749cf6637f43ec=
17b9b62094acde</a><u></u><u></u></p><p class=3D"MsoNormal"><u></u>=C2=A0<u>=
</u></p><p class=3D"MsoNormal">><span class=3D"gmail-m_52424375591479881=
40blob-code-inner"><span style=3D"font-size:9pt;font-family:Consolas;color:=
rgb(36,41,46)"> OVERLAPPED* ov =3D </span></span><span class=3D"gmail-m_524=
2437559147988140pl-c1"><span style=3D"font-size:9pt;font-family:Consolas;co=
lor:rgb(0,92,197)">malloc</span></span><span class=3D"gmail-m_5242437559147=
988140blob-code-inner"><span style=3D"font-size:9pt;font-family:Consolas;co=
lor:rgb(36,41,46)">((pagecount - keep) * </span></span><span class=3D"gmail=
-m_5242437559147988140pl-k"><span style=3D"font-size:9pt;font-family:Consol=
as;color:rgb(215,58,73)">sizeof</span></span><span class=3D"gmail-m_5242437=
559147988140blob-code-inner"><span style=3D"font-size:9pt;font-family:Conso=
las;color:rgb(36,41,46)">(OVERLAPPED));</span></span><span class=3D"gmail-m=
_5242437559147988140blob-code-inner"><span style=3D"font-size:9pt;font-fami=
ly:Consolas;color:rgb(36,41,46)"><u></u><u></u></span></span></p><p class=
=3D"MsoNormal"><span class=3D"gmail-m_5242437559147988140blob-code-inner"><=
span style=3D"font-size:9pt;font-family:Consolas;color:rgb(36,41,46)">> =
</span></span><span style=3D"font-size:10.5pt;font-family:"Segoe UI&qu=
ot;,sans-serif;color:rgb(36,41,46);background:white">Probably this ought to=
just be pre-allocated based on the maximum number of dirty pages a txn all=
ows.</span><span style=3D"font-size:10.5pt;font-family:"Segoe UI"=
,sans-serif;background:white"><u></u><u></u></span></p><p class=3D"MsoNorma=
l"><span style=3D"font-size:10.5pt;font-family:"Segoe UI",sans-se=
rif;color:rgb(36,41,46);background:white"><u></u>=C2=A0<u></u></span></p><p=
class=3D"MsoNormal"><span style=3D"font-size:10.5pt;font-family:"Sego=
e UI",sans-serif;color:rgb(36,41,46);background:white">I wasn=E2=80=99=
t sure I understood this comment. Are you suggesting we </span>malloc(MDB_I=
DL_UM_MAX * sizeof(OVERLAPPED)) for each environment, and retain it for the=
life of the environment? I think that is 4MB, if my math is right, which s=
eems like a lot of memory to keep allocated (we usually have a lot of open =
environments). If the goal is to reduce the number of mallocs, how about we=
retain the OVERLAPPED array, and only free and re-malloc if the previous a=
llocation wasn=E2=80=99t large enough? Then there isn=E2=80=99t unnecessary=
allocation, and we only malloc when there is a bigger transaction than any=
previous. I put this together in a separate commit, as I wasn=E2=80=99t su=
re if this what you wanted (can squash if you prefer): <a href=3D"https://g=
ithub.com/kriszyp/node-lmdb/commit/2fe68fb5269c843e2e789746a17a4b2adefaac40=
" target=3D"_blank">https://github.com/kriszyp/node-lmdb/commit/2fe68fb5269=
c843e2e789746a17a4b2adefaac40</a><u></u><u></u></p><p class=3D"MsoNormal"><=
u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">Thank you for the review! <sp=
an style=3D"font-size:10.5pt;font-family:"Segoe UI",sans-serif;co=
lor:rgb(36,41,46);background:white"><u></u><u></u></span></p><p class=3D"Ms=
oNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">Thanks,<br>Kris<u><=
/u><u></u></p><p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><div style=3D"=
border-right:none;border-bottom:none;border-left:none;border-top:1pt solid =
rgb(225,225,225);padding:3pt 0cm 0cm"><p class=3D"MsoNormal"><b>From: </b><=
a href=3D"mailto:hyc@symas.com" target=3D"_blank">Howard Chu</a><br><b>Sent=
: </b>April 30, 2019 7:12 AM<br><b>To: </b><a href=3D"mailto:kriszyp@gmail.=
com" target=3D"_blank">kriszyp(a)gmail.com</a>; <a href=3D"mailto:openldap-it=
s(a)OpenLDAP.org" target=3D"_blank">openldap-its(a)OpenLDAP.org</a><br><b>Subje=
ct: </b>Re: (ITS#9017) Improving performance of commit sync in Windows<u></=
u><u></u></p></div><p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=
=3D"MsoNormal"><a href=3D"mailto:kriszyp@gmail.com" target=3D"_blank">krisz=
yp(a)gmail.com</a> wrote:<u></u><u></u></p><p class=3D"MsoNormal">> Full_N=
ame: Kristopher William Zyp<u></u><u></u></p><p class=3D"MsoNormal">> Ve=
rsion: LMDB 0.9.23<u></u><u></u></p><p class=3D"MsoNormal">> OS: Windows=
<u></u><u></u></p><p class=3D"MsoNormal">> URL: <a href=3D"https://githu=
b.com/kriszyp/node-lmdb/commit/7ff525ae57684a163d32af74a0ab9332b7fc4ce9" ta=
rget=3D"_blank">https://github.com/kriszyp/node-lmdb/commit/7ff525ae57684a1=
63d32af74a0ab9332b7fc4ce9</a><u></u><u></u></p><p class=3D"MsoNormal">> =
Submission from: (NULL) (71.199.6.148)<u></u><u></u></p><p class=3D"MsoNorm=
al">> <u></u><u></u></p><p class=3D"MsoNormal">> <u></u><u></u></p><p=
class=3D"MsoNormal">> We have seen very poor performance on the sync of=
commits on large databases in<u></u><u></u></p><p class=3D"MsoNormal">>=
Windows. On databases with 2GB of data, in writemap mode, the sync of even=
small<u></u><u></u></p><p class=3D"MsoNormal">> commits is consistently=
well over 100ms (without writemap it is faster, but<u></u><u></u></p><p cl=
ass=3D"MsoNormal">> still slow). It is expected that a sync should take =
some time while waiting for<u></u><u></u></p><p class=3D"MsoNormal">> di=
sk confirmation of the writes, but more concerning is that these sync<u></u=
><u></u></p><p class=3D"MsoNormal">> operations (in writemap mode) are i=
nstead dominated by nearly 100% system CPU<u></u><u></u></p><p class=3D"Mso=
Normal">> utilization, so operations that requires sub-millisecond b-tre=
e update<u></u><u></u></p><p class=3D"MsoNormal">> operations are then d=
ominated by very large amounts of system CPU cycles during<u></u><u></u></p=
><p class=3D"MsoNormal">> the sync phase.<u></u><u></u></p><p class=3D"M=
soNormal">> <u></u><u></u></p><p class=3D"MsoNormal">> I think that t=
he fundamental problem is that FlushViewOfFile seems to be an O(n)<u></u><u=
></u></p><p class=3D"MsoNormal">> operation where n is the size of the f=
ile (or map). I presume that Windows is<u></u><u></u></p><p class=3D"MsoNor=
mal">> scanning the entire map/file for dirty pages to flush, I'm gu=
essing because it<u></u><u></u></p><p class=3D"MsoNormal">> doesn't =
have an internal index of all the dirty pages for every file/map-view in<u>=
</u><u></u></p><p class=3D"MsoNormal">> the OS disk cache. Therefore, th=
e turns into an extremely expensive, CPU-bound<u></u><u></u></p><p class=3D=
"MsoNormal">> operation to find the dirty pages for (large file) and ini=
tiate their writes,<u></u><u></u></p><p class=3D"MsoNormal">> which, of =
course, is contrary to the whole goal of a scalable database system.<u></u>=
<u></u></p><p class=3D"MsoNormal">> And FlushFileBuffers is also relativ=
ely slow as well. We have attempted to batch<u></u><u></u></p><p class=3D"M=
soNormal">> as many operations into single transaction as possible, but =
this is still a very<u></u><u></u></p><p class=3D"MsoNormal">> large ove=
rhead.<u></u><u></u></p><p class=3D"MsoNormal">> <u></u><u></u></p><p cl=
ass=3D"MsoNormal">> The Windows docs for FlushFileBuffers itself warns a=
bout the inefficiencies of<u></u><u></u></p><p class=3D"MsoNormal">> thi=
s function (<a href=3D"https://docs.microsoft.com/en-us/windows/desktop/api=
/fileapi/nf-fileapi-flushfilebuffers" target=3D"_blank">https://docs.micros=
oft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-flushfilebuffers</a>).=
<u></u><u></u></p><p class=3D"MsoNormal">> Which also points to the solu=
tion: it is much faster to write out the dirty<u></u><u></u></p><p class=3D=
"MsoNormal">> pages with WriteFile through a sync file handle (FILE_FLAG=
_WRITE_THROUGH).<u></u><u></u></p><p class=3D"MsoNormal">> <u></u><u></u=
></p><p class=3D"MsoNormal">> The associated patch<u></u><u></u></p><p c=
lass=3D"MsoNormal">> (<a href=3D"https://github.com/kriszyp/node-lmdb/co=
mmit/7ff525ae57684a163d32af74a0ab9332b7fc4ce9" target=3D"_blank">https://gi=
thub.com/kriszyp/node-lmdb/commit/7ff525ae57684a163d32af74a0ab9332b7fc4ce9<=
/a>)<u></u><u></u></p><p class=3D"MsoNormal">> is my attempt at implemen=
ting this solution, for Windows. Fortunately, with the<u></u><u></u></p><p =
class=3D"MsoNormal">> design of LMDB, this is relatively straightforward=
. LMDB already supports<u></u><u></u></p><p class=3D"MsoNormal">> writin=
g out dirty pages with WriteFile calls. I added a write-through handle for<=
u></u><u></u></p><p class=3D"MsoNormal">> sending these writes directly =
to disk. I then made that file-handle<u></u><u></u></p><p class=3D"MsoNorma=
l">> overlapped/asynchronously, so all the writes for a commit could be =
started in<u></u><u></u></p><p class=3D"MsoNormal">> overlap mode, and (=
at least theoretically) transfer in parallel to the drive and<u></u><u></u>=
</p><p class=3D"MsoNormal">> then used GetOverlappedResult to wait for t=
he completion. So basically<u></u><u></u></p><p class=3D"MsoNormal">> md=
b_page_flush becomes the sync. I extended the writing of dirty pages throug=
h<u></u><u></u></p><p class=3D"MsoNormal">> WriteFile to writemap mode a=
s well (for writing meta too), so that WriteFile<u></u><u></u></p><p class=
=3D"MsoNormal">> with write-through can be used to flush the data withou=
t ever needing to call<u></u><u></u></p><p class=3D"MsoNormal">> FlushVi=
ewOfFile or FlushFileBuffers. I also implemented support for write<u></u><u=
></u></p><p class=3D"MsoNormal">> gathering in writemap mode where conti=
guous file positions infers contiguous<u></u><u></u></p><p class=3D"MsoNorm=
al">> memory (by tracking the starting position with wdp and writing con=
tiguous pages<u></u><u></u></p><p class=3D"MsoNormal">> in single operat=
ions). Sorting of the dirty list is maintained even in writemap<u></u><u></=
u></p><p class=3D"MsoNormal">> mode for this purpose.<u></u><u></u></p><=
p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">What i=
s the point of using writemap mode if you still need to use WriteFile<u></u=
><u></u></p><p class=3D"MsoNormal">on every individual page?<u></u><u></u><=
/p><p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=3D"MsoNormal">&g=
t; The performance benefits of this patch, in my testing, are considerable.=
Writing<u></u><u></u></p><p class=3D"MsoNormal">> out/syncing transacti=
ons is typically over 5x faster in writemap mode, and 2x<u></u><u></u></p><=
p class=3D"MsoNormal">> faster in standard mode. And perhaps more import=
antly (especially in environment<u></u><u></u></p><p class=3D"MsoNormal">&g=
t; with many threads/processes), the efficiency benefits are even larger,<u=
></u><u></u></p><p class=3D"MsoNormal">> particularly in writemap mode, =
where there can be a 50-100x reduction in the<u></u><u></u></p><p class=3D"=
MsoNormal">> system CPU usage by using this patch. This brings windows p=
erformance with<u></u><u></u></p><p class=3D"MsoNormal">> sync'ed tr=
ansactions in LMDB back into the range of "lightning" performance=
:).<u></u><u></u></p><p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p cla=
ss=3D"MsoNormal">What is the performance difference between your patch usin=
g writemap, and just<u></u><u></u></p><p class=3D"MsoNormal">not using writ=
emap in the first place?<u></u><u></u></p><p class=3D"MsoNormal"><u></u>=C2=
=A0<u></u></p><p class=3D"MsoNormal">-- <u></u><u></u></p><p class=3D"MsoNo=
rmal">=C2=A0=C2=A0-- Howard Chu<u></u><u></u></p><p class=3D"MsoNormal">=C2=
=A0 CTO, Symas Corp.=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=C2=A0=
=C2=A0 <a href=3D"http://www.symas.com" target=3D"_blank">http://www.symas.=
com</a><u></u><u></u></p><p class=3D"MsoNormal">=C2=A0 Director, Highland S=
un=C2=A0=C2=A0=C2=A0=C2=A0 <a href=3D"http://highlandsun.com/hyc/" target=
=3D"_blank">http://highlandsun.com/hyc/</a><u></u><u></u></p><p class=3D"Ms=
oNormal">=C2=A0 Chief Architect, OpenLDAP=C2=A0 <a href=3D"http://www.openl=
dap.org/project/" target=3D"_blank">http://www.openldap.org/project/</a><u>=
</u><u></u></p><p class=3D"MsoNormal"><u></u>=C2=A0<u></u></p><p class=3D"M=
soNormal"><u></u>=C2=A0<u></u></p></div></div></blockquote></div>
--000000000000db50ce058b89ac2f--
4 years, 5 months
Re: (ITS#7996) Tighten race in ldap_int_initialize
by Armin.Tueting@tueting-online.com
--=-8DPiL0uhzCLRgMdCXb4w
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Am Montag, den 17.06.2019, 07:41 -0700 schrieb Quanah Gibson-Mount:
> --On Monday, June 17, 2019 9:59 AM +0200 Armin T=C3=BCting=20
> <Armin.Tueting(a)tueting-online.com> wrote:
>=20
> > > > Hi,
> > > >=20
> > > > Thanks for the report. When reporting issues, please keep them on
> > > > the=3D20 OpenLDAP bug tracking list, rather than directly emailing
> > > > individuals.
> > > You will need to provide substantially more information about what
> > > you're seeing. I would start with starting slapd in full debug mode
> > > (add -d -1 to the startup flags to slapd) and see what issue(s) it
> > > reports.
> > Slapd won't even start at all! No log!
> > I'm attaching the redirected output from 'make test'. In addition the
> > 'config.log' and 'slapd_start.txt'.
>=20
> Hi Armin,
>=20
> Again, I will please ask you CC replies to the OpenLDAP ITS list=20
> (openldap-its(a)openldap.org) so they properly get entered into the issue=
=20
> tracker.
>=20
> Your slapd_start.txt attachment clearly shows slapd starting:
>=20
> time /opt/openldap/libexec/slapd -F /opt/openldap/etc/openldap/slapd.d -u=
=20
> ldap -h "ldapi:/// ldap:/// ldaps:///" -d -1=20
>=20
> ldap_url_parse_ext(ldap://localhost/)
> ldap_init: trying /opt/openldap/etc/openldap/ldap.conf
> ldap_init: using /opt/openldap/etc/openldap/ldap.conf
> ^C
>=20
>=20
> I.e., it started and then got as far as reading your ldap.conf file. Wha=
t=20
> is the contents of ldap.conf?
Attached 'ldap.conf'. Nothing unusual...
> Have you run the test suite (make test)? Does it pass? fail?
Attached 'make_test.txt'. As far as I can see - it has been passed.
> Thanks,
> Quanah
>=20
> --
>=20
> Quanah Gibson-Mount
> Product Architect
> Symas Corporation
> Packaged, certified, and supported LDAP solutions powered by OpenLDAP:
> <http://www.symas.com>
>=20
--=-8DPiL0uhzCLRgMdCXb4w
Content-Disposition: attachment; filename="ldap.conf"
Content-Type: text/plain; name="ldap.conf"; charset="UTF-8"
Content-Transfer-Encoding: base64
IyBodHRwczovL3NpdGVzLmdvb2dsZS5jb20vc2l0ZS9ndWVudGVyYmFydHNjaC9ibG9nL2NlbnRv
czU2bGRhcHVzaW5ndGxzd2l0aHNzaGFwYXNzd29yZHMKIyBodHRwOi8vd3d3Lm9wZW5sZGFwLm9y
Zy9zb2Z0d2FyZS9tYW4uY2dpP3F1ZXJ5PWxkYXAuY29uZgoKIyBHZW5lcmFsIGNvbm5lY3Rpb24g
b3B0aW9ucwpVUkkgbGRhcDovL2xvY2FsaG9zdC8KCiMgU2VhcmNoL21hcHBpbmcgb3B0aW9ucwpC
QVNFIGRjPWFybWluLXR1ZXRpbmcsZGM9bG9jYWwKCiMgVGltaW5nL3JlY29ubmVjdCBvcHRpb25z
ClRJTUVMSU1JVCAxMApUSU1FT1VUIDMwCgojIFNBU0wgb3B0aW9ucwpTQVNMX01FQ0ggRVhURVJO
QUwKCiMgU1NML1RMUyBvcHRpb25zClRMU19DQUNFUlQgL2V0Yy9zc2wvQ0FCdW5kbGUuY3J0ClRM
U19DSVBIRVJfU1VJVEUgSElHSDpNRURJVU0KVExTX1JFUUNFUlQgZGVtYW5kCg==
--=-8DPiL0uhzCLRgMdCXb4w
Content-Disposition: attachment; filename="make_test.txt"
Content-Transfer-Encoding: base64
Content-Type: text/plain; name="make_test.txt"; charset="UTF-8"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--=-8DPiL0uhzCLRgMdCXb4w--
4 years, 5 months
RE: (ITS#8970) bind fails when length value is multi-byte
by lit@CBORD.com
SSBzZXQgYWxsIHRoaXMgYXNpZGUgc29tZSB0aW1lIGFnbywgc28gaXQnbGwgdGFrZSBtZSBhIHdo
aWxlIHRvIGdldCBzZXQgdXAgYWdhaW4uICAgSSdsbCBsZXQgeW91IGtub3cuIA0KDQoNCi0tLS0t
T3JpZ2luYWwgTWVzc2FnZS0tLS0tDQpGcm9tOiBPbmTFmWVqIEt1em7DrWsgPG9uZHJhQG1pc3Rv
dGViZS5uZXQ+IA0KU2VudDogTW9uZGF5LCBKdW5lIDE3LCAyMDE5IDg6MjAgQU0NClRvOiBxdWFu
YWhAc3ltYXMuY29tOyBMZW8gVG9oaWxsIDxsaXRAQ0JPUkQuY29tPg0KQ2M6IG9wZW5sZGFwLWl0
c0BPcGVuTERBUC5vcmcNClN1YmplY3Q6IFJlOiAoSVRTIzg5NzApIGJpbmQgZmFpbHMgd2hlbiBs
ZW5ndGggdmFsdWUgaXMgbXVsdGktYnl0ZQ0KDQpIaSBMZW8sDQppbiBteSB0ZXN0cywgZXZlcnl0
aGluZyBpcyBoYW5kbGVkIGNvcnJlY3RseS4gSGF2ZSB5b3UgYmVlbiBhYmxlIHRvIHJlcHJvZHVj
ZSB0aGlzIHdpdGggYW4gdXAtdG8tZGF0ZSB2ZXJzaW9uIG9mIE9wZW5MREFQPw0KDQpJZiBzbywg
Y2FuIHlvdSBwcm92aWRlIHNsYXBkIG91dHB1dCAoc3RkZXJyKSB3aXRoIC1kIC0xPyBUaGlzIGlz
IGRpZmZlcmVudCBmcm9tIHNsYXBkIHN5c2xvZyBvdXRwdXQgaW4gdGhhdCBsaWJsZGFwL2xpYmxi
ZXIgbG9nZ2luZyBpcyBhbHNvIGluY2x1ZGVkLg0KDQpSZWdhcmRzLA0KDQotLQ0KT25kxZllaiBL
dXpuw61rDQpTZW5pb3IgU29mdHdhcmUgRW5naW5lZXINClN5bWFzIENvcnBvcmF0aW9uICAgICAg
ICAgICAgICAgICAgICAgICBodHRwOi8vd3d3LnN5bWFzLmNvbQ0KUGFja2FnZWQsIGNlcnRpZmll
ZCwgYW5kIHN1cHBvcnRlZCBMREFQIHNvbHV0aW9ucyBwb3dlcmVkIGJ5IE9wZW5MREFQDQo=
4 years, 5 months
Re: (ITS#7996) Tighten race in ldap_int_initialize
by quanah@symas.com
--On Monday, June 17, 2019 9:59 AM +0200 Armin T=C3=BCting=20
<Armin.Tueting(a)tueting-online.com> wrote:
>> > Hi,
>> >
>> > Thanks for the report. When reporting issues, please keep them on
>> > the=3D20 OpenLDAP bug tracking list, rather than directly emailing
>> > individuals.
>> You will need to provide substantially more information about what
>> you're seeing. I would start with starting slapd in full debug mode
>> (add -d -1 to the startup flags to slapd) and see what issue(s) it
>> reports.
> Slapd won't even start at all! No log!
> I'm attaching the redirected output from 'make test'. In addition the
> 'config.log' and 'slapd_start.txt'.
Hi Armin,
Again, I will please ask you CC replies to the OpenLDAP ITS list=20
(openldap-its(a)openldap.org) so they properly get entered into the issue=20
tracker.
Your slapd_start.txt attachment clearly shows slapd starting:
time /opt/openldap/libexec/slapd -F /opt/openldap/etc/openldap/slapd.d -u=20
ldap -h "ldapi:/// ldap:/// ldaps:///" -d -1=20
ldap_url_parse_ext(ldap://localhost/)
ldap_init: trying /opt/openldap/etc/openldap/ldap.conf
ldap_init: using /opt/openldap/etc/openldap/ldap.conf
^C
I.e., it started and then got as far as reading your ldap.conf file. What=20
is the contents of ldap.conf?
Have you run the test suite (make test)? Does it pass? fail?
Thanks,
Quanah
--
Quanah Gibson-Mount
Product Architect
Symas Corporation
Packaged, certified, and supported LDAP solutions powered by OpenLDAP:
<http://www.symas.com>
4 years, 5 months
Re: (ITS#9037) observing crash in mdb_cursor_put()
by hyc@symas.com
grobins(a)pulsesecure.net wrote:
> Full_Name: Robins George
> Version: 0.9.18
> OS: Centos
> URL: ftp://ftp.openldap.org/incoming/
> Submission from: (NULL) (121.244.154.134)
>
>
> I am seeing LMDB crash, please find the stack trace.
>
> #0 0x009e362e in mdb_cursor_put (mc=0xffd59bb8, key=0xffd59d14,
> data=0xffd59d0c, flags=0) at mdb.c:6688
> #1 0x009e48ec in mdb_put (txn=0xd74d3008, dbi=2, key=0xffd59d14,
> data=0xffd59d0c, flags=0) at mdb.c:8771
> #2 0x00f5cef8 in LMDB::LMDBContext::createSession (this=0x80cc610,
> sid=0x80cd0fc "sid1422419e5fd6cd224f278d74293c50f5ef96593700000000+") at
> lmdbint.cc:460
> #3 0x0805398e in updateLMDB (request=..., forward=@0xffd59fff) at
> sessionserver.cc:1154
> #4 processRequestWithoutResponse (request=..., forward=@0xffd59fff) at
> sessionserver.cc:1240
> #5 0x08056936 in ZSubHandler::ioReady (this=0xffd5aa1c, fd=20) at
> sessionserver.cc:1501
> #6 0x00f870d2 in runCoreDispatcher (default_t=<value optimized out>, flags=-1)
> at fds.cc:889
> #7 0x00f87b37 in DSEvntFds::runDispatcher () at fds.cc:945
> #8 0x08056248 in main () at sessionserver.cc:1820
>
> Anybody has seen similar issue before?
Doesn't sound familiar. But 0.9.18 is quite old. If you can reproduce this
issue in 0.9.23 then we'll take a look. Test code to reproduce the problem
would also be needed.
--
-- Howard Chu
CTO, Symas Corp. http://www.symas.com
Director, Highland Sun http://highlandsun.com/hyc/
Chief Architect, OpenLDAP http://www.openldap.org/project/
4 years, 5 months