]> git.sur5r.net Git - openldap/blob - servers/slapd/alock.c
Merge remote-tracking branch 'origin/mdb.master' into OPENLDAP_REL_ENG_2_5
[openldap] / servers / slapd / alock.c
1 /* alock.c - access lock library */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 2005-2014 The OpenLDAP Foundation.
6  * Portions Copyright 2004-2005 Symas Corporation.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted only as authorized by the OpenLDAP
11  * Public License.
12  *
13  * A copy of this license is available in the file LICENSE in the
14  * top-level directory of the distribution or, alternatively, at
15  * <http://www.OpenLDAP.org/license.html>.
16  */
17 /* ACKNOWLEDGEMENTS:
18  * This work was initially developed by Emily Backes at Symas
19  * Corporation for inclusion in OpenLDAP Software.
20  */
21
22 #include "portable.h"
23
24 #if SLAPD_BDB || SLAPD_HDB
25
26 #include <lber.h>
27 #include "alock.h"
28 #include "lutil.h"
29
30 #include <ac/stdlib.h>
31 #include <ac/string.h>
32 #include <ac/unistd.h>
33 #include <ac/errno.h>
34 #include <ac/assert.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #ifdef HAVE_SYS_FILE_H
38 #include <sys/file.h>
39 #endif
40 #include <fcntl.h>
41
42 #ifdef _WIN32
43 #include <windows.h>
44 #include <stdio.h>
45 #include <io.h>
46 #endif
47
48
49 static int
50 alock_grab_lock ( int fd, int slot )
51 {
52         int res;
53         
54 #if defined( HAVE_LOCKF )
55         res = lseek (fd, (off_t) (ALOCK_SLOT_SIZE * slot), SEEK_SET);
56         if (res == -1) return -1;
57         res = lockf (fd, F_LOCK, (off_t) ALOCK_SLOT_SIZE);
58 #elif defined( HAVE_FCNTL )
59         struct flock lock_info;
60         (void) memset ((void *) &lock_info, 0, sizeof (struct flock));
61
62         lock_info.l_type = F_WRLCK;
63         lock_info.l_whence = SEEK_SET;
64         lock_info.l_start = (off_t) (ALOCK_SLOT_SIZE * slot);
65         lock_info.l_len = (off_t) ALOCK_SLOT_SIZE;
66
67         res = fcntl (fd, F_SETLKW, &lock_info);
68 #elif defined( _WIN32 )
69         OVERLAPPED ov;
70         HANDLE hh = _get_osfhandle ( fd );
71         ov.hEvent = 0;
72         ov.Offset = ALOCK_SLOT_SIZE*slot;
73         ov.OffsetHigh = 0;
74         res = LockFileEx( hh, LOCKFILE_EXCLUSIVE_LOCK, 0,
75                 ALOCK_SLOT_SIZE, 0, &ov ) ? 0 : -1;
76 #else
77 #   error alock needs lockf, fcntl, or LockFile[Ex]
78 #endif
79         if (res == -1) {
80                 assert (errno != EDEADLK);
81                 return -1;
82         }
83         return 0;
84 }
85
86 static int
87 alock_release_lock ( int fd, int slot )
88 {
89         int res;
90         
91 #if defined( HAVE_LOCKF )
92         res = lseek (fd, (off_t) (ALOCK_SLOT_SIZE * slot), SEEK_SET);
93         if (res == -1) return -1;
94         res = lockf (fd, F_ULOCK, (off_t) ALOCK_SLOT_SIZE);
95         if (res == -1) return -1;
96 #elif defined ( HAVE_FCNTL )
97         struct flock lock_info;
98         (void) memset ((void *) &lock_info, 0, sizeof (struct flock));
99
100         lock_info.l_type = F_UNLCK;
101         lock_info.l_whence = SEEK_SET;
102         lock_info.l_start = (off_t) (ALOCK_SLOT_SIZE * slot);
103         lock_info.l_len = (off_t) ALOCK_SLOT_SIZE;
104
105         res = fcntl (fd, F_SETLKW, &lock_info);
106         if (res == -1) return -1;
107 #elif defined( _WIN32 )
108         HANDLE hh = _get_osfhandle ( fd );
109         if ( !UnlockFile ( hh, ALOCK_SLOT_SIZE*slot, 0,
110                 ALOCK_SLOT_SIZE, 0 ))
111                 return -1;
112 #else
113 #   error alock needs lockf, fcntl, or LockFile[Ex]
114 #endif
115
116         return 0;
117 }
118
119 static int
120 alock_share_lock ( int fd, int slot )
121 {
122         int res;
123
124 #if defined( HAVE_LOCKF )
125         res = 0;        /* lockf has no shared locks */
126 #elif defined ( HAVE_FCNTL )
127         struct flock lock_info;
128         (void) memset ((void *) &lock_info, 0, sizeof (struct flock));
129
130         /* The shared lock replaces the existing lock */
131         lock_info.l_type = F_RDLCK;
132         lock_info.l_whence = SEEK_SET;
133         lock_info.l_start = (off_t) (ALOCK_SLOT_SIZE * slot);
134         lock_info.l_len = (off_t) ALOCK_SLOT_SIZE;
135
136         res = fcntl (fd, F_SETLK, &lock_info);
137         if (res == -1) return -1;
138 #elif defined( _WIN32 )
139         OVERLAPPED ov;
140         HANDLE hh = _get_osfhandle ( fd );
141
142         /* Windows locks are mandatory, not advisory.
143          * We must downgrade the lock to allow future
144          * callers to read the slot data.
145          *
146          * First acquire a shared lock. Unlock will
147          * release the existing exclusive lock.
148          */
149         ov.hEvent = 0;
150         ov.Offset = ALOCK_SLOT_SIZE*slot;
151         ov.OffsetHigh = 0;
152         LockFileEx (hh, 0, 0, ALOCK_SLOT_SIZE, 0, &ov);
153         UnlockFile (hh, ALOCK_SLOT_SIZE*slot, 0, ALOCK_SLOT_SIZE, 0);
154 #else
155 #   error alock needs lockf, fcntl, or LockFile[Ex]
156 #endif
157
158         return 0;
159 }
160
161 static int
162 alock_test_lock ( int fd, int slot )
163 {
164         int res;
165
166 #if defined( HAVE_LOCKF )
167         res = lseek (fd, (off_t) (ALOCK_SLOT_SIZE * slot), SEEK_SET);
168         if (res == -1) return -1;
169
170         res = lockf (fd, F_TEST, (off_t) ALOCK_SLOT_SIZE);
171         if (res == -1) {
172                 if (errno == EACCES || errno == EAGAIN) { 
173                         return ALOCK_LOCKED;
174                 } else {
175                         return -1;
176                 }
177         }
178 #elif defined( HAVE_FCNTL )
179         struct flock lock_info;
180         (void) memset ((void *) &lock_info, 0, sizeof (struct flock));
181
182         lock_info.l_type = F_WRLCK;
183         lock_info.l_whence = SEEK_SET;
184         lock_info.l_start = (off_t) (ALOCK_SLOT_SIZE * slot);
185         lock_info.l_len = (off_t) ALOCK_SLOT_SIZE;
186
187         res = fcntl (fd, F_GETLK, &lock_info);
188         if (res == -1) return -1;
189
190         if (lock_info.l_type != F_UNLCK) return ALOCK_LOCKED;
191 #elif defined( _WIN32 )
192         OVERLAPPED ov;
193         HANDLE hh = _get_osfhandle ( fd );
194         ov.hEvent = 0;
195         ov.Offset = ALOCK_SLOT_SIZE*slot;
196         ov.OffsetHigh = 0;
197         if( !LockFileEx( hh,
198                 LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY, 0,
199                 ALOCK_SLOT_SIZE, 0, &ov )) {
200                 int err = GetLastError();
201                 if ( err == ERROR_LOCK_VIOLATION )
202                         return ALOCK_LOCKED;
203                 else
204                         return -1;
205         }
206 #else
207 #   error alock needs lockf, fcntl, or LockFile
208 #endif
209         
210         return 0;
211 }
212
213 /* Read a 64bit LE value */
214 static unsigned long int
215 alock_read_iattr ( unsigned char * bufptr )
216 {
217         unsigned long int val = 0;
218         int count;
219
220         assert (bufptr != NULL);
221
222         bufptr += sizeof (unsigned long int);
223         for (count=0; count <= (int) sizeof (unsigned long int); ++count) {
224                 val <<= 8;
225                 val += (unsigned long int) *bufptr--;
226         }
227
228         return val;
229 }
230
231 /* Write a 64bit LE value */
232 static void
233 alock_write_iattr ( unsigned char * bufptr,
234                     unsigned long int val )
235 {
236         int count;
237
238         assert (bufptr != NULL);
239
240         for (count=0; count < 8; ++count) {
241                 *bufptr++ = (unsigned char) (val & 0xff);
242                 val >>= 8;
243         }
244 }
245
246 static int
247 alock_read_slot ( alock_info_t * info,
248                   alock_slot_t * slot_data )
249 {
250         unsigned char slotbuf [ALOCK_SLOT_SIZE];
251         int res, size, size_total, err;
252
253         assert (info != NULL);
254         assert (slot_data != NULL);
255         assert (info->al_slot > 0);
256
257         res = lseek (info->al_fd, 
258                      (off_t) (ALOCK_SLOT_SIZE * info->al_slot), 
259                      SEEK_SET);
260         if (res == -1) return -1;
261
262         size_total = 0;
263         while (size_total < ALOCK_SLOT_SIZE) {
264                 size = read (info->al_fd, 
265                              slotbuf + size_total, 
266                              ALOCK_SLOT_SIZE - size_total);
267                 if (size == 0) return -1;
268                 if (size < 0) {
269                         err = errno;
270                         if (err != EINTR && err != EAGAIN) return -1;
271                 } else {
272                         size_total += size;
273                 }
274         }
275         
276         if (alock_read_iattr (slotbuf) != ALOCK_MAGIC) {
277                 return -1;
278         }
279         slot_data->al_lock  = alock_read_iattr (slotbuf+8);
280         slot_data->al_stamp = alock_read_iattr (slotbuf+16);
281         slot_data->al_pid   = alock_read_iattr (slotbuf+24);
282
283         if (slot_data->al_appname) ber_memfree (slot_data->al_appname);
284         slot_data->al_appname = ber_memcalloc (1, ALOCK_MAX_APPNAME);
285         if (slot_data->al_appname == NULL) {
286                 return -1;
287         }
288         strncpy (slot_data->al_appname, (char *)slotbuf+32, ALOCK_MAX_APPNAME-1);
289         (slot_data->al_appname) [ALOCK_MAX_APPNAME-1] = '\0';
290
291         return 0;
292 }
293
294 static int
295 alock_write_slot ( alock_info_t * info,
296                    alock_slot_t * slot_data )
297 {
298         unsigned char slotbuf [ALOCK_SLOT_SIZE];
299         int res, size, size_total, err;
300
301         assert (info != NULL);
302         assert (slot_data != NULL);
303         assert (info->al_slot > 0);
304
305         (void) memset ((void *) slotbuf, 0, ALOCK_SLOT_SIZE);
306         
307         alock_write_iattr (slotbuf,    ALOCK_MAGIC);
308         assert (alock_read_iattr (slotbuf) == ALOCK_MAGIC);
309         alock_write_iattr (slotbuf+8,  slot_data->al_lock);
310         alock_write_iattr (slotbuf+16, slot_data->al_stamp);
311         alock_write_iattr (slotbuf+24, slot_data->al_pid);
312
313         if (slot_data->al_appname)
314                 strncpy ((char *)slotbuf+32, slot_data->al_appname, ALOCK_MAX_APPNAME-1);
315         slotbuf[ALOCK_SLOT_SIZE-1] = '\0';
316
317         res = lseek (info->al_fd, 
318                      (off_t) (ALOCK_SLOT_SIZE * info->al_slot),
319                      SEEK_SET);
320         if (res == -1) return -1;
321
322         size_total = 0;
323         while (size_total < ALOCK_SLOT_SIZE) {
324                 size = write (info->al_fd, 
325                               slotbuf + size_total, 
326                               ALOCK_SLOT_SIZE - size_total);
327                 if (size == 0) return -1;
328                 if (size < 0) {
329                         err = errno;
330                         if (err != EINTR && err != EAGAIN) return -1;
331                 } else {
332                         size_total += size;
333                 }
334         }
335         
336         return 0;
337 }
338
339 static int
340 alock_query_slot ( alock_info_t * info )
341 {
342         int res, nosave;
343         alock_slot_t slot_data;
344
345         assert (info != NULL);
346         assert (info->al_slot > 0);
347         
348         (void) memset ((void *) &slot_data, 0, sizeof (alock_slot_t));
349         alock_read_slot (info, &slot_data);
350
351         if (slot_data.al_appname != NULL) ber_memfree (slot_data.al_appname);
352         slot_data.al_appname = NULL;
353
354         nosave = slot_data.al_lock & ALOCK_NOSAVE;
355
356         if ((slot_data.al_lock & ALOCK_SMASK) == ALOCK_UNLOCKED)
357                 return slot_data.al_lock;
358
359         res = alock_test_lock (info->al_fd, info->al_slot);
360         if (res < 0) return -1;
361         if (res > 0) {
362                 if ((slot_data.al_lock & ALOCK_SMASK) == ALOCK_UNIQUE) {
363                         return slot_data.al_lock;
364                 } else {
365                         return ALOCK_LOCKED | nosave;
366                 }
367         }
368         
369         return ALOCK_DIRTY | nosave;
370 }
371
372 int 
373 alock_open ( alock_info_t * info,
374              const char * appname,
375              const char * envdir,
376              int locktype )
377 {
378         struct stat statbuf;
379         alock_info_t scan_info;
380         alock_slot_t slot_data;
381         char * filename;
382         int res, max_slot;
383         int dirty_count, live_count, nosave;
384         char *ptr;
385
386         assert (info != NULL);
387         assert (appname != NULL);
388         assert (envdir != NULL);
389         assert ((locktype & ALOCK_SMASK) >= 1 && (locktype & ALOCK_SMASK) <= 2);
390
391         slot_data.al_lock = locktype;
392         slot_data.al_stamp = time(NULL);
393         slot_data.al_pid = getpid();
394         slot_data.al_appname = ber_memcalloc (1, ALOCK_MAX_APPNAME);
395         if (slot_data.al_appname == NULL) {
396                 return ALOCK_UNSTABLE;
397         }
398         strncpy (slot_data.al_appname, appname, ALOCK_MAX_APPNAME-1);
399         slot_data.al_appname [ALOCK_MAX_APPNAME-1] = '\0';
400
401         filename = ber_memcalloc (1, strlen (envdir) + strlen ("/alock") + 1);
402         if (filename == NULL ) {
403                 ber_memfree (slot_data.al_appname);
404                 return ALOCK_UNSTABLE;
405         }
406         ptr = lutil_strcopy(filename, envdir);
407         lutil_strcopy(ptr, "/alock");
408 #ifdef _WIN32
409         { HANDLE handle = CreateFile (filename, GENERIC_READ|GENERIC_WRITE,
410                 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
411                 FILE_ATTRIBUTE_NORMAL, NULL);
412                 info->al_fd = _open_osfhandle (handle, 0);
413         }
414 #else
415         info->al_fd = open (filename, O_CREAT|O_RDWR, 0666);
416 #endif
417         ber_memfree (filename);
418         if (info->al_fd < 0) {
419                 ber_memfree (slot_data.al_appname);
420                 return ALOCK_UNSTABLE;
421         }
422         info->al_slot = 0;
423
424         res = alock_grab_lock (info->al_fd, 0);
425         if (res == -1) { 
426                 close (info->al_fd);
427                 ber_memfree (slot_data.al_appname);
428                 return ALOCK_UNSTABLE;
429         }
430
431         res = fstat (info->al_fd, &statbuf);
432         if (res == -1) { 
433                 close (info->al_fd);
434                 ber_memfree (slot_data.al_appname);
435                 return ALOCK_UNSTABLE;
436         }
437
438         max_slot = (statbuf.st_size + ALOCK_SLOT_SIZE - 1) / ALOCK_SLOT_SIZE;
439         dirty_count = 0;
440         live_count = 0;
441         nosave = 0;
442         scan_info.al_fd = info->al_fd;
443         for (scan_info.al_slot = 1; 
444              scan_info.al_slot < max_slot;
445              ++ scan_info.al_slot) {
446                 if (scan_info.al_slot != info->al_slot) {
447                         res = alock_query_slot (&scan_info);
448
449                         if (res & ALOCK_NOSAVE) {
450                                 nosave = ALOCK_NOSAVE;
451                                 res ^= ALOCK_NOSAVE;
452                         }
453                         if (res == ALOCK_UNLOCKED
454                             && info->al_slot == 0) {
455                                 info->al_slot = scan_info.al_slot;
456
457                         } else if (res == ALOCK_LOCKED) {
458                                 ++live_count;
459
460                         } else if (res == ALOCK_UNIQUE
461                                 && (( locktype & ALOCK_SMASK ) == ALOCK_UNIQUE
462                                 || nosave )) {
463                                 close (info->al_fd);
464                                 ber_memfree (slot_data.al_appname);
465                                 return ALOCK_BUSY;
466
467                         } else if (res == ALOCK_DIRTY) {
468                                 ++dirty_count;
469
470                         } else if (res == -1) {
471                                 close (info->al_fd);
472                                 ber_memfree (slot_data.al_appname);
473                                 return ALOCK_UNSTABLE;
474
475                         }
476                 }
477         }
478
479         if (dirty_count && live_count) {
480                 close (info->al_fd);
481                 ber_memfree (slot_data.al_appname);
482                 return ALOCK_UNSTABLE;
483         }
484         
485         if (info->al_slot == 0) info->al_slot = max_slot + 1;
486         res = alock_grab_lock (info->al_fd,
487                                info->al_slot);
488         if (res == -1) { 
489                 close (info->al_fd);
490                 ber_memfree (slot_data.al_appname);
491                 return ALOCK_UNSTABLE;
492         }
493         res = alock_write_slot (info, &slot_data);
494         ber_memfree (slot_data.al_appname);
495         if (res == -1) { 
496                 close (info->al_fd);
497                 return ALOCK_UNSTABLE;
498         }
499         alock_share_lock (info->al_fd, info->al_slot);
500
501         res = alock_release_lock (info->al_fd, 0);
502         if (res == -1) { 
503                 close (info->al_fd);
504                 return ALOCK_UNSTABLE;
505         }
506         
507         if (dirty_count) return ALOCK_RECOVER | nosave;
508         return ALOCK_CLEAN | nosave;
509 }
510
511 int 
512 alock_scan ( alock_info_t * info )
513 {
514         struct stat statbuf;
515         alock_info_t scan_info;
516         int res, max_slot;
517         int dirty_count, live_count, nosave;
518
519         assert (info != NULL);
520
521         scan_info.al_fd = info->al_fd;
522
523         res = alock_grab_lock (info->al_fd, 0);
524         if (res == -1) {
525                 close (info->al_fd);
526                 return ALOCK_UNSTABLE;
527         }
528
529         res = fstat (info->al_fd, &statbuf);
530         if (res == -1) {
531                 close (info->al_fd);
532                 return ALOCK_UNSTABLE;
533         }
534
535         max_slot = (statbuf.st_size + ALOCK_SLOT_SIZE - 1) / ALOCK_SLOT_SIZE;
536         dirty_count = 0;
537         live_count = 0;
538         nosave = 0;
539         for (scan_info.al_slot = 1; 
540              scan_info.al_slot < max_slot;
541              ++ scan_info.al_slot) {
542                 if (scan_info.al_slot != info->al_slot) {
543                         res = alock_query_slot (&scan_info);
544
545                         if (res & ALOCK_NOSAVE) {
546                                 nosave = ALOCK_NOSAVE;
547                                 res ^= ALOCK_NOSAVE;
548                         }
549
550                         if (res == ALOCK_LOCKED) {
551                                 ++live_count;
552                                 
553                         } else if (res == ALOCK_DIRTY) {
554                                 ++dirty_count;
555
556                         } else if (res == -1) {
557                                 close (info->al_fd);
558                                 return ALOCK_UNSTABLE;
559
560                         }
561                 }
562         }
563
564         res = alock_release_lock (info->al_fd, 0);
565         if (res == -1) {
566                 close (info->al_fd);
567                 return ALOCK_UNSTABLE;
568         }
569
570         if (dirty_count) {
571                 if (live_count) {
572                         close (info->al_fd);
573                         return ALOCK_UNSTABLE;
574                 } else {
575                         return ALOCK_RECOVER | nosave;
576                 }
577         }
578         
579         return ALOCK_CLEAN | nosave;
580 }
581
582 int
583 alock_close ( alock_info_t * info, int nosave )
584 {
585         alock_slot_t slot_data;
586         int res;
587
588         if ( !info->al_slot )
589                 return ALOCK_CLEAN;
590
591         (void) memset ((void *) &slot_data, 0, sizeof(alock_slot_t));
592
593         res = alock_grab_lock (info->al_fd, 0);
594         if (res == -1) {
595 fail:
596                 /* Windows doesn't clean up locks immediately when a process exits.
597                  * Make sure we release our locks, to prevent stale locks from
598                  * hanging around.
599                  */
600                 alock_release_lock (info->al_fd, 0);
601                 close (info->al_fd);
602                 return ALOCK_UNSTABLE;
603         }
604
605         /* mark our slot as clean */
606         res = alock_read_slot (info, &slot_data);
607         if (res == -1) {
608                 if (slot_data.al_appname != NULL) 
609                         ber_memfree (slot_data.al_appname);
610                 goto fail;
611         }
612         slot_data.al_lock = ALOCK_UNLOCKED;
613         if ( nosave )
614                 slot_data.al_lock |= ALOCK_NOSAVE;
615         /* since we have slot 0 locked, we don't need our slot lock */
616         res = alock_release_lock (info->al_fd, info->al_slot);
617         if (res == -1) {
618                 goto fail;
619         }
620         res = alock_write_slot (info, &slot_data);
621         if (res == -1) {
622                 if (slot_data.al_appname != NULL) 
623                         ber_memfree (slot_data.al_appname);
624                 goto fail;
625         }
626         if (slot_data.al_appname != NULL) {
627                 ber_memfree (slot_data.al_appname);
628                 slot_data.al_appname = NULL;
629         }
630
631         res = alock_release_lock (info->al_fd, 0);
632         if (res == -1) {
633                 close (info->al_fd);
634                 return ALOCK_UNSTABLE;
635         }
636
637         res = close (info->al_fd);
638         if (res == -1) return ALOCK_UNSTABLE;
639         
640         return ALOCK_CLEAN;
641 }
642
643 int 
644 alock_recover ( alock_info_t * info )
645 {
646         struct stat statbuf;
647         alock_slot_t slot_data;
648         alock_info_t scan_info;
649         int res, max_slot;
650
651         assert (info != NULL);
652
653         scan_info.al_fd = info->al_fd;
654
655         (void) memset ((void *) &slot_data, 0, sizeof(alock_slot_t));
656
657         res = alock_grab_lock (info->al_fd, 0);
658         if (res == -1) {
659                 goto fail;
660         }
661
662         res = fstat (info->al_fd, &statbuf);
663         if (res == -1) {
664                 goto fail;
665         }
666
667         max_slot = (statbuf.st_size + ALOCK_SLOT_SIZE - 1) / ALOCK_SLOT_SIZE;
668         for (scan_info.al_slot = 1; 
669              scan_info.al_slot < max_slot;
670              ++ scan_info.al_slot) {
671                 if (scan_info.al_slot != info->al_slot) {
672                         res = alock_query_slot (&scan_info) & ~ALOCK_NOSAVE;
673
674                         if (res == ALOCK_LOCKED
675                             || res == ALOCK_UNIQUE) {
676                                 /* recovery attempt on an active db? */
677                                 goto fail;
678                                 
679                         } else if (res == ALOCK_DIRTY) {
680                                 /* mark it clean */
681                                 res = alock_read_slot (&scan_info, &slot_data);
682                                 if (res == -1) {
683                                         goto fail;
684                                 }
685                                 slot_data.al_lock = ALOCK_UNLOCKED;
686                                 res = alock_write_slot (&scan_info, &slot_data);
687                                 if (res == -1) {
688                                         if (slot_data.al_appname != NULL) 
689                                                 ber_memfree (slot_data.al_appname);
690                                         goto fail;
691                                 }
692                                 if (slot_data.al_appname != NULL) {
693                                         ber_memfree (slot_data.al_appname);
694                                         slot_data.al_appname = NULL;
695                                 }
696                                 
697                         } else if (res == -1) {
698                                 goto fail;
699
700                         }
701                 }
702         }
703
704         res = alock_release_lock (info->al_fd, 0);
705         if (res == -1) {
706                 close (info->al_fd);
707                 return ALOCK_UNSTABLE;
708         }
709
710         return ALOCK_CLEAN;
711
712 fail:
713         alock_release_lock (info->al_fd, 0);
714         close (info->al_fd);
715         return ALOCK_UNSTABLE;
716 }
717
718 #endif /* SLAPD_BDB || SLAPD_HDB */