?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Update waf build to include missed dependancy on Lion.
[Samba/gebeck_regimport.git] / source3 / locking / posix.c
blobabedd5600dbb1cb8ff1c91d44e61b9535f5ccf39
1 /*
2 Unix SMB/CIFS implementation.
3 Locking functions
4 Copyright (C) Jeremy Allison 1992-2006
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18
19 Revision History:
20
21 POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
22 */
23
24 #include "includes.h"
25 #include "system/filesys.h"
26 #include "locking/proto.h"
27 #include "dbwrap/dbwrap.h"
28 #include "dbwrap/dbwrap_rbt.h"
29 #include "util_tdb.h"
30
31 #undef DBGC_CLASS
32 #define DBGC_CLASS DBGC_LOCKING
33
34 /*
35 * The pending close database handle.
36 */
37
38 static struct db_context *posix_pending_close_db;
39
40 /****************************************************************************
41 First - the functions that deal with the underlying system locks - these
42 functions are used no matter if we're mapping CIFS Windows locks or CIFS
43 POSIX locks onto POSIX.
44 ****************************************************************************/
45
46 /****************************************************************************
47 Utility function to map a lock type correctly depending on the open
48 mode of a file.
49 ****************************************************************************/
50
51 static int map_posix_lock_type( files_struct *fsp, enum brl_type lock_type)
52 {
53 if((lock_type == WRITE_LOCK) && !fsp->can_write) {
54 /*
55 * Many UNIX's cannot get a write lock on a file opened read-only.
56 * Win32 locking semantics allow this.
57 * Do the best we can and attempt a read-only lock.
58 */
59 DEBUG(10,("map_posix_lock_type: Downgrading write lock to read due to read-only file.\n"));
60 return F_RDLCK;
61 }
62
63 /*
64 * This return should be the most normal, as we attempt
65 * to always open files read/write.
66 */
67
68 return (lock_type == READ_LOCK) ? F_RDLCK : F_WRLCK;
69 }
70
71 /****************************************************************************
72 Debugging aid :-).
73 ****************************************************************************/
74
75 static const char *posix_lock_type_name(int lock_type)
76 {
77 return (lock_type == F_RDLCK) ? "READ" : "WRITE";
78 }
79
80 /****************************************************************************
81 Check to see if the given unsigned lock range is within the possible POSIX
82 range. Modifies the given args to be in range if possible, just returns
83 False if not.
84 ****************************************************************************/
85
86 static bool posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
87 uint64_t u_offset, uint64_t u_count)
88 {
89 SMB_OFF_T offset = (SMB_OFF_T)u_offset;
90 SMB_OFF_T count = (SMB_OFF_T)u_count;
91
92 /*
93 * For the type of system we are, attempt to
94 * find the maximum positive lock offset as an SMB_OFF_T.
95 */
96
97 #if defined(MAX_POSITIVE_LOCK_OFFSET) /* Some systems have arbitrary limits. */
98
99 SMB_OFF_T max_positive_lock_offset = (MAX_POSITIVE_LOCK_OFFSET);
100
101 #elif defined(LARGE_SMB_OFF_T) && !defined(HAVE_BROKEN_FCNTL64_LOCKS)
102
103 /*
104 * In this case SMB_OFF_T is 64 bits,
105 * and the underlying system can handle 64 bit signed locks.
106 */
107
108 SMB_OFF_T mask2 = ((SMB_OFF_T)0x4) << (SMB_OFF_T_BITS-4);
109 SMB_OFF_T mask = (mask2<<1);
110 SMB_OFF_T max_positive_lock_offset = ~mask;
111
112 #else /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
113
114 /*
115 * In this case either SMB_OFF_T is 32 bits,
116 * or the underlying system cannot handle 64 bit signed locks.
117 * All offsets & counts must be 2^31 or less.
118 */
119
120 SMB_OFF_T max_positive_lock_offset = 0x7FFFFFFF;
121
122 #endif /* !LARGE_SMB_OFF_T || HAVE_BROKEN_FCNTL64_LOCKS */
123
124 /*
125 * POSIX locks of length zero mean lock to end-of-file.
126 * Win32 locks of length zero are point probes. Ignore
127 * any Win32 locks of length zero. JRA.
128 */
129
130 if (count == (SMB_OFF_T)0) {
131 DEBUG(10,("posix_lock_in_range: count = 0, ignoring.\n"));
132 return False;
133 }
134
135 /*
136 * If the given offset was > max_positive_lock_offset then we cannot map this at all
137 * ignore this lock.
138 */
139
140 if (u_offset & ~((uint64_t)max_positive_lock_offset)) {
141 DEBUG(10,("posix_lock_in_range: (offset = %.0f) offset > %.0f and we cannot handle this. Ignoring lock.\n",
142 (double)u_offset, (double)((uint64_t)max_positive_lock_offset) ));
143 return False;
144 }
145
146 /*
147 * We must truncate the count to less than max_positive_lock_offset.
148 */
149
150 if (u_count & ~((uint64_t)max_positive_lock_offset)) {
151 count = max_positive_lock_offset;
152 }
153
154 /*
155 * Truncate count to end at max lock offset.
156 */
157
158 if (offset + count < 0 || offset + count > max_positive_lock_offset) {
159 count = max_positive_lock_offset - offset;
160 }
161
162 /*
163 * If we ate all the count, ignore this lock.
164 */
165
166 if (count == 0) {
167 DEBUG(10,("posix_lock_in_range: Count = 0. Ignoring lock u_offset = %.0f, u_count = %.0f\n",
168 (double)u_offset, (double)u_count ));
169 return False;
170 }
171
172 /*
173 * The mapping was successful.
174 */
175
176 DEBUG(10,("posix_lock_in_range: offset_out = %.0f, count_out = %.0f\n",
177 (double)offset, (double)count ));
178
179 *offset_out = offset;
180 *count_out = count;
181
182 return True;
183 }
184
185 bool smb_vfs_call_lock(struct vfs_handle_struct *handle,
186 struct files_struct *fsp, int op, SMB_OFF_T offset,
187 SMB_OFF_T count, int type)
188 {
189 VFS_FIND(lock);
190 return handle->fns->lock_fn(handle, fsp, op, offset, count, type);
191 }
192
193 /****************************************************************************
194 Actual function that does POSIX locks. Copes with 64 -> 32 bit cruft and
195 broken NFS implementations.
196 ****************************************************************************/
197
198 static bool posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
199 {
200 bool ret;
201
202 DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fh->fd,op,(double)offset,(double)count,type));
203
204 ret = SMB_VFS_LOCK(fsp, op, offset, count, type);
205
206 if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
207
208 DEBUG(0,("posix_fcntl_lock: WARNING: lock request at offset %.0f, length %.0f returned\n",
209 (double)offset,(double)count));
210 DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
211 DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
212
213 /*
214 * If the offset is > 0x7FFFFFFF then this will cause problems on
215 * 32 bit NFS mounted filesystems. Just ignore it.
216 */
217
218 if (offset & ~((SMB_OFF_T)0x7fffffff)) {
219 DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
220 return True;
221 }
222
223 if (count & ~((SMB_OFF_T)0x7fffffff)) {
224 /* 32 bit NFS file system, retry with smaller offset */
225 DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
226 errno = 0;
227 count &= 0x7fffffff;
228 ret = SMB_VFS_LOCK(fsp, op, offset, count, type);
229 }
230 }
231
232 DEBUG(8,("posix_fcntl_lock: Lock call %s\n", ret ? "successful" : "failed"));
233 return ret;
234 }
235
236 bool smb_vfs_call_getlock(struct vfs_handle_struct *handle,
237 struct files_struct *fsp, SMB_OFF_T *poffset,
238 SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
239 {
240 VFS_FIND(getlock);
241 return handle->fns->getlock_fn(handle, fsp, poffset, pcount, ptype,
242 ppid);
243 }
244
245 /****************************************************************************
246 Actual function that gets POSIX locks. Copes with 64 -> 32 bit cruft and
247 broken NFS implementations.
248 ****************************************************************************/
249
250 static bool posix_fcntl_getlock(files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype)
251 {
252 pid_t pid;
253 bool ret;
254
255 DEBUG(8,("posix_fcntl_getlock %d %.0f %.0f %d\n",
256 fsp->fh->fd,(double)*poffset,(double)*pcount,*ptype));
257
258 ret = SMB_VFS_GETLOCK(fsp, poffset, pcount, ptype, &pid);
259
260 if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno == EINVAL))) {
261
262 DEBUG(0,("posix_fcntl_getlock: WARNING: lock request at offset %.0f, length %.0f returned\n",
263 (double)*poffset,(double)*pcount));
264 DEBUGADD(0,("an %s error. This can happen when using 64 bit lock offsets\n", strerror(errno)));
265 DEBUGADD(0,("on 32 bit NFS mounted file systems.\n"));
266
267 /*
268 * If the offset is > 0x7FFFFFFF then this will cause problems on
269 * 32 bit NFS mounted filesystems. Just ignore it.
270 */
271
272 if (*poffset & ~((SMB_OFF_T)0x7fffffff)) {
273 DEBUG(0,("Offset greater than 31 bits. Returning success.\n"));
274 return True;
275 }
276
277 if (*pcount & ~((SMB_OFF_T)0x7fffffff)) {
278 /* 32 bit NFS file system, retry with smaller offset */
279 DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
280 errno = 0;
281 *pcount &= 0x7fffffff;
282 ret = SMB_VFS_GETLOCK(fsp,poffset,pcount,ptype,&pid);
283 }
284 }
285
286 DEBUG(8,("posix_fcntl_getlock: Lock query call %s\n", ret ? "successful" : "failed"));
287 return ret;
288 }
289
290 /****************************************************************************
291 POSIX function to see if a file region is locked. Returns True if the
292 region is locked, False otherwise.
293 ****************************************************************************/
294
295 bool is_posix_locked(files_struct *fsp,
296 uint64_t *pu_offset,
297 uint64_t *pu_count,
298 enum brl_type *plock_type,
299 enum brl_flavour lock_flav)
300 {
301 SMB_OFF_T offset;
302 SMB_OFF_T count;
303 int posix_lock_type = map_posix_lock_type(fsp,*plock_type);
304
305 DEBUG(10,("is_posix_locked: File %s, offset = %.0f, count = %.0f, "
306 "type = %s\n", fsp_str_dbg(fsp), (double)*pu_offset,
307 (double)*pu_count, posix_lock_type_name(*plock_type)));
308
309 /*
310 * If the requested lock won't fit in the POSIX range, we will
311 * never set it, so presume it is not locked.
312 */
313
314 if(!posix_lock_in_range(&offset, &count, *pu_offset, *pu_count)) {
315 return False;
316 }
317
318 if (!posix_fcntl_getlock(fsp,&offset,&count,&posix_lock_type)) {
319 return False;
320 }
321
322 if (posix_lock_type == F_UNLCK) {
323 return False;
324 }
325
326 if (lock_flav == POSIX_LOCK) {
327 /* Only POSIX lock queries need to know the details. */
328 *pu_offset = (uint64_t)offset;
329 *pu_count = (uint64_t)count;
330 *plock_type = (posix_lock_type == F_RDLCK) ? READ_LOCK : WRITE_LOCK;
331 }
332 return True;
333 }
334
335 /****************************************************************************
336 Next - the functions that deal with in memory database storing representations
337 of either Windows CIFS locks or POSIX CIFS locks.
338 ****************************************************************************/
339
340 /* The key used in the in-memory POSIX databases. */
341
342 struct lock_ref_count_key {
343 struct file_id id;
344 char r;
345 };
346
347 /*******************************************************************
348 Form a static locking key for a dev/inode pair for the lock ref count
349 ******************************************************************/
350
351 static TDB_DATA locking_ref_count_key_fsp(files_struct *fsp,
352 struct lock_ref_count_key *tmp)
353 {
354 ZERO_STRUCTP(tmp);
355 tmp->id = fsp->file_id;
356 tmp->r = 'r';
357 return make_tdb_data((uint8_t *)tmp, sizeof(*tmp));
358 }
359
360 /*******************************************************************
361 Convenience function to get an fd_array key from an fsp.
362 ******************************************************************/
363
364 static TDB_DATA fd_array_key_fsp(files_struct *fsp)
365 {
366 return make_tdb_data((uint8 *)&fsp->file_id, sizeof(fsp->file_id));
367 }
368
369 /*******************************************************************
370 Create the in-memory POSIX lock databases.
371 ********************************************************************/
372
373 bool posix_locking_init(bool read_only)
374 {
375 if (posix_pending_close_db != NULL) {
376 return true;
377 }
378
379 posix_pending_close_db = db_open_rbt(NULL);
380
381 if (posix_pending_close_db == NULL) {
382 DEBUG(0,("Failed to open POSIX pending close database.\n"));
383 return false;
384 }
385
386 return true;
387 }
388
389 /*******************************************************************
390 Delete the in-memory POSIX lock databases.
391 ********************************************************************/
392
393 bool posix_locking_end(void)
394 {
395 /*
396 * Shouldn't we close all fd's here?
397 */
398 TALLOC_FREE(posix_pending_close_db);
399 return true;
400 }
401
402 /****************************************************************************
403 Next - the functions that deal with storing fd's that have outstanding
404 POSIX locks when closed.
405 ****************************************************************************/
406
407 /****************************************************************************
408 The records in posix_pending_close_tdb are composed of an array of ints
409 keyed by dev/ino pair.
410 The first int is a reference count of the number of outstanding locks on
411 all open fd's on this dev/ino pair. Any subsequent ints are the fd's that
412 were open on this dev/ino pair that should have been closed, but can't as
413 the lock ref count is non zero.
414 ****************************************************************************/
415
416 /****************************************************************************
417 Keep a reference count of the number of Windows locks open on this dev/ino
418 pair. Creates entry if it doesn't exist.
419 ****************************************************************************/
420
421 static void increment_windows_lock_ref_count(files_struct *fsp)
422 {
423 struct lock_ref_count_key tmp;
424 struct db_record *rec;
425 int lock_ref_count = 0;
426 NTSTATUS status;
427 TDB_DATA value;
428
429 rec = dbwrap_fetch_locked(
430 posix_pending_close_db, talloc_tos(),
431 locking_ref_count_key_fsp(fsp, &tmp));
432
433 SMB_ASSERT(rec != NULL);
434
435 value = dbwrap_record_get_value(rec);
436
437 if (value.dptr != NULL) {
438 SMB_ASSERT(value.dsize == sizeof(lock_ref_count));
439 memcpy(&lock_ref_count, value.dptr,
440 sizeof(lock_ref_count));
441 }
442
443 lock_ref_count++;
444
445 status = dbwrap_record_store(rec,
446 make_tdb_data((uint8 *)&lock_ref_count,
447 sizeof(lock_ref_count)), 0);
448
449 SMB_ASSERT(NT_STATUS_IS_OK(status));
450
451 TALLOC_FREE(rec);
452
453 DEBUG(10,("increment_windows_lock_ref_count for file now %s = %d\n",
454 fsp_str_dbg(fsp), lock_ref_count));
455 }
456
457 /****************************************************************************
458 Bulk delete - subtract as many locks as we've just deleted.
459 ****************************************************************************/
460
461 void reduce_windows_lock_ref_count(files_struct *fsp, unsigned int dcount)
462 {
463 struct lock_ref_count_key tmp;
464 struct db_record *rec;
465 int lock_ref_count = 0;
466 NTSTATUS status;
467 TDB_DATA value;
468
469 rec = dbwrap_fetch_locked(
470 posix_pending_close_db, talloc_tos(),
471 locking_ref_count_key_fsp(fsp, &tmp));
472
473 value = dbwrap_record_get_value(rec);
474
475 SMB_ASSERT((rec != NULL)
476 && (value.dptr != NULL)
477 && (value.dsize == sizeof(lock_ref_count)));
478
479 memcpy(&lock_ref_count, value.dptr, sizeof(lock_ref_count));
480
481 SMB_ASSERT(lock_ref_count > 0);
482
483 lock_ref_count -= dcount;
484
485 status = dbwrap_record_store(rec,
486 make_tdb_data((uint8 *)&lock_ref_count,
487 sizeof(lock_ref_count)), 0);
488
489 SMB_ASSERT(NT_STATUS_IS_OK(status));
490
491 TALLOC_FREE(rec);
492
493 DEBUG(10,("reduce_windows_lock_ref_count for file now %s = %d\n",
494 fsp_str_dbg(fsp), lock_ref_count));
495 }
496
497 static void decrement_windows_lock_ref_count(files_struct *fsp)
498 {
499 reduce_windows_lock_ref_count(fsp, 1);
500 }
501
502 /****************************************************************************
503 Fetch the lock ref count.
504 ****************************************************************************/
505
506 static int get_windows_lock_ref_count(files_struct *fsp)
507 {
508 struct lock_ref_count_key tmp;
509 TDB_DATA dbuf;
510 NTSTATUS status;
511 int lock_ref_count = 0;
512
513 status = dbwrap_fetch(
514 posix_pending_close_db, talloc_tos(),
515 locking_ref_count_key_fsp(fsp, &tmp), &dbuf);
516
517 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
518 goto done;
519 }
520
521 if (!NT_STATUS_IS_OK(status)) {
522 DEBUG(0, ("get_windows_lock_ref_count: Error fetching "
523 "lock ref count for file %s: %s\n",
524 fsp_str_dbg(fsp), nt_errstr(status)));
525 goto done;
526 }
527
528 if (dbuf.dsize != sizeof(lock_ref_count)) {
529 DEBUG(0, ("get_windows_lock_ref_count: invalid entry "
530 "in lock ref count record for file %s: "
531 "(invalid data size %u)\n",
532 fsp_str_dbg(fsp), (unsigned int)dbuf.dsize));
533 goto done;
534 }
535
536 memcpy(&lock_ref_count, dbuf.dptr, sizeof(lock_ref_count));
537 TALLOC_FREE(dbuf.dptr);
538
539 done:
540 DEBUG(10,("get_windows_lock_count for file %s = %d\n",
541 fsp_str_dbg(fsp), lock_ref_count));
542
543 return lock_ref_count;
544 }
545
546 /****************************************************************************
547 Delete a lock_ref_count entry.
548 ****************************************************************************/
549
550 static void delete_windows_lock_ref_count(files_struct *fsp)
551 {
552 struct lock_ref_count_key tmp;
553 struct db_record *rec;
554
555 rec = dbwrap_fetch_locked(
556 posix_pending_close_db, talloc_tos(),
557 locking_ref_count_key_fsp(fsp, &tmp));
558
559 SMB_ASSERT(rec != NULL);
560
561 /* Not a bug if it doesn't exist - no locks were ever granted. */
562
563 dbwrap_record_delete(rec);
564 TALLOC_FREE(rec);
565
566 DEBUG(10,("delete_windows_lock_ref_count for file %s\n",
567 fsp_str_dbg(fsp)));
568 }
569
570 /****************************************************************************
571 Add an fd to the pending close tdb.
572 ****************************************************************************/
573
574 static void add_fd_to_close_entry(files_struct *fsp)
575 {
576 struct db_record *rec;
577 uint8_t *new_data;
578 NTSTATUS status;
579 TDB_DATA value;
580
581 rec = dbwrap_fetch_locked(
582 posix_pending_close_db, talloc_tos(),
583 fd_array_key_fsp(fsp));
584
585 SMB_ASSERT(rec != NULL);
586
587 value = dbwrap_record_get_value(rec);
588
589 new_data = talloc_array(rec, uint8_t,
590 value.dsize + sizeof(fsp->fh->fd));
591
592 SMB_ASSERT(new_data != NULL);
593
594 memcpy(new_data, value.dptr, value.dsize);
595 memcpy(new_data + value.dsize,
596 &fsp->fh->fd, sizeof(fsp->fh->fd));
597
598 status = dbwrap_record_store(
599 rec, make_tdb_data(new_data,
600 value.dsize + sizeof(fsp->fh->fd)), 0);
601
602 SMB_ASSERT(NT_STATUS_IS_OK(status));
603
604 TALLOC_FREE(rec);
605
606 DEBUG(10,("add_fd_to_close_entry: added fd %d file %s\n",
607 fsp->fh->fd, fsp_str_dbg(fsp)));
608 }
609
610 /****************************************************************************
611 Remove all fd entries for a specific dev/inode pair from the tdb.
612 ****************************************************************************/
613
614 static void delete_close_entries(files_struct *fsp)
615 {
616 struct db_record *rec;
617
618 rec = dbwrap_fetch_locked(
619 posix_pending_close_db, talloc_tos(),
620 fd_array_key_fsp(fsp));
621
622 SMB_ASSERT(rec != NULL);
623 dbwrap_record_delete(rec);
624 TALLOC_FREE(rec);
625 }
626
627 /****************************************************************************
628 Get the array of POSIX pending close records for an open fsp. Returns number
629 of entries.
630 ****************************************************************************/
631
632 static size_t get_posix_pending_close_entries(TALLOC_CTX *mem_ctx,
633 files_struct *fsp, int **entries)
634 {
635 TDB_DATA dbuf;
636 NTSTATUS status;
637
638 status = dbwrap_fetch(
639 posix_pending_close_db, mem_ctx, fd_array_key_fsp(fsp),
640 &dbuf);
641
642 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
643 *entries = NULL;
644 return 0;
645 }
646
647 SMB_ASSERT(NT_STATUS_IS_OK(status));
648
649 if (dbuf.dsize == 0) {
650 *entries = NULL;
651 return 0;
652 }
653
654 *entries = (int *)dbuf.dptr;
655 return (size_t)(dbuf.dsize / sizeof(int));
656 }
657
658 /****************************************************************************
659 Deal with pending closes needed by POSIX locking support.
660 Note that posix_locking_close_file() is expected to have been called
661 to delete all locks on this fsp before this function is called.
662 ****************************************************************************/
663
664 int fd_close_posix(struct files_struct *fsp)
665 {
666 int saved_errno = 0;
667 int ret;
668 int *fd_array = NULL;
669 size_t count, i;
670
671 if (!lp_locking(fsp->conn->params) ||
672 !lp_posix_locking(fsp->conn->params))
673 {
674 /*
675 * No locking or POSIX to worry about or we want POSIX semantics
676 * which will lose all locks on all fd's open on this dev/inode,
677 * just close.
678 */
679 return close(fsp->fh->fd);
680 }
681
682 if (get_windows_lock_ref_count(fsp)) {
683
684 /*
685 * There are outstanding locks on this dev/inode pair on
686 * other fds. Add our fd to the pending close tdb and set
687 * fsp->fh->fd to -1.
688 */
689
690 add_fd_to_close_entry(fsp);
691 return 0;
692 }
693
694 /*
695 * No outstanding locks. Get the pending close fd's
696 * from the tdb and close them all.
697 */
698
699 count = get_posix_pending_close_entries(talloc_tos(), fsp, &fd_array);
700
701 if (count) {
702 DEBUG(10,("fd_close_posix: doing close on %u fd's.\n",
703 (unsigned int)count));
704
705 for(i = 0; i < count; i++) {
706 if (close(fd_array[i]) == -1) {
707 saved_errno = errno;
708 }
709 }
710
711 /*
712 * Delete all fd's stored in the tdb
713 * for this dev/inode pair.
714 */
715
716 delete_close_entries(fsp);
717 }
718
719 TALLOC_FREE(fd_array);
720
721 /* Don't need a lock ref count on this dev/ino anymore. */
722 delete_windows_lock_ref_count(fsp);
723
724 /*
725 * Finally close the fd associated with this fsp.
726 */
727
728 ret = close(fsp->fh->fd);
729
730 if (ret == 0 && saved_errno != 0) {
731 errno = saved_errno;
732 ret = -1;
733 }
734
735 return ret;
736 }
737
738 /****************************************************************************
739 Next - the functions that deal with the mapping CIFS Windows locks onto
740 the underlying system POSIX locks.
741 ****************************************************************************/
742
743 /*
744 * Structure used when splitting a lock range
745 * into a POSIX lock range. Doubly linked list.
746 */
747
748 struct lock_list {
749 struct lock_list *next;
750 struct lock_list *prev;
751 SMB_OFF_T start;
752 SMB_OFF_T size;
753 };
754
755 /****************************************************************************
756 Create a list of lock ranges that don't overlap a given range. Used in calculating
757 POSIX locks and unlocks. This is a difficult function that requires ASCII art to
758 understand it :-).
759 ****************************************************************************/
760
761 static struct lock_list *posix_lock_list(TALLOC_CTX *ctx,
762 struct lock_list *lhead,
763 const struct lock_context *lock_ctx, /* Lock context lhead belongs to. */
764 files_struct *fsp,
765 const struct lock_struct *plocks,
766 int num_locks)
767 {
768 int i;
769
770 /*
771 * Check the current lock list on this dev/inode pair.
772 * Quit if the list is deleted.
773 */
774
775 DEBUG(10,("posix_lock_list: curr: start=%.0f,size=%.0f\n",
776 (double)lhead->start, (double)lhead->size ));
777
778 for (i=0; i<num_locks && lhead; i++) {
779 const struct lock_struct *lock = &plocks[i];
780 struct lock_list *l_curr;
781
782 /* Ignore all but read/write locks. */
783 if (lock->lock_type != READ_LOCK && lock->lock_type != WRITE_LOCK) {
784 continue;
785 }
786
787 /* Ignore locks not owned by this process. */
788 if (!procid_equal(&lock->context.pid, &lock_ctx->pid)) {
789 continue;
790 }
791
792 /*
793 * Walk the lock list, checking for overlaps. Note that
794 * the lock list can expand within this loop if the current
795 * range being examined needs to be split.
796 */
797
798 for (l_curr = lhead; l_curr;) {
799
800 DEBUG(10,("posix_lock_list: lock: fnum=%d: start=%.0f,size=%.0f:type=%s", lock->fnum,
801 (double)lock->start, (double)lock->size, posix_lock_type_name(lock->lock_type) ));
802
803 if ( (l_curr->start >= (lock->start + lock->size)) ||
804 (lock->start >= (l_curr->start + l_curr->size))) {
805
806 /* No overlap with existing lock - leave this range alone. */
807 /*********************************************
808 +---------+
809 | l_curr |
810 +---------+
811 +-------+
812 | lock |
813 +-------+
814 OR....
815 +---------+
816 | l_curr |
817 +---------+
818 **********************************************/
819
820 DEBUG(10,(" no overlap case.\n" ));
821
822 l_curr = l_curr->next;
823
824 } else if ( (l_curr->start >= lock->start) &&
825 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
826
827 /*
828 * This range is completely overlapped by this existing lock range
829 * and thus should have no effect. Delete it from the list.
830 */
831 /*********************************************
832 +---------+
833 | l_curr |
834 +---------+
835 +---------------------------+
836 | lock |
837 +---------------------------+
838 **********************************************/
839 /* Save the next pointer */
840 struct lock_list *ul_next = l_curr->next;
841
842 DEBUG(10,(" delete case.\n" ));
843
844 DLIST_REMOVE(lhead, l_curr);
845 if(lhead == NULL) {
846 break; /* No more list... */
847 }
848
849 l_curr = ul_next;
850
851 } else if ( (l_curr->start >= lock->start) &&
852 (l_curr->start < lock->start + lock->size) &&
853 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
854
855 /*
856 * This range overlaps the existing lock range at the high end.
857 * Truncate by moving start to existing range end and reducing size.
858 */
859 /*********************************************
860 +---------------+
861 | l_curr |
862 +---------------+
863 +---------------+
864 | lock |
865 +---------------+
866 BECOMES....
867 +-------+
868 | l_curr|
869 +-------+
870 **********************************************/
871
872 l_curr->size = (l_curr->start + l_curr->size) - (lock->start + lock->size);
873 l_curr->start = lock->start + lock->size;
874
875 DEBUG(10,(" truncate high case: start=%.0f,size=%.0f\n",
876 (double)l_curr->start, (double)l_curr->size ));
877
878 l_curr = l_curr->next;
879
880 } else if ( (l_curr->start < lock->start) &&
881 (l_curr->start + l_curr->size > lock->start) &&
882 (l_curr->start + l_curr->size <= lock->start + lock->size) ) {
883
884 /*
885 * This range overlaps the existing lock range at the low end.
886 * Truncate by reducing size.
887 */
888 /*********************************************
889 +---------------+
890 | l_curr |
891 +---------------+
892 +---------------+
893 | lock |
894 +---------------+
895 BECOMES....
896 +-------+
897 | l_curr|
898 +-------+
899 **********************************************/
900
901 l_curr->size = lock->start - l_curr->start;
902
903 DEBUG(10,(" truncate low case: start=%.0f,size=%.0f\n",
904 (double)l_curr->start, (double)l_curr->size ));
905
906 l_curr = l_curr->next;
907
908 } else if ( (l_curr->start < lock->start) &&
909 (l_curr->start + l_curr->size > lock->start + lock->size) ) {
910 /*
911 * Worst case scenario. Range completely overlaps an existing
912 * lock range. Split the request into two, push the new (upper) request
913 * into the dlink list, and continue with the entry after l_new (as we
914 * know that l_new will not overlap with this lock).
915 */
916 /*********************************************
917 +---------------------------+
918 | l_curr |
919 +---------------------------+
920 +---------+
921 | lock |
922 +---------+
923 BECOMES.....
924 +-------+ +---------+
925 | l_curr| | l_new |
926 +-------+ +---------+
927 **********************************************/
928 struct lock_list *l_new = talloc(ctx, struct lock_list);
929
930 if(l_new == NULL) {
931 DEBUG(0,("posix_lock_list: talloc fail.\n"));
932 return NULL; /* The talloc_destroy takes care of cleanup. */
933 }
934
935 ZERO_STRUCTP(l_new);
936 l_new->start = lock->start + lock->size;
937 l_new->size = l_curr->start + l_curr->size - l_new->start;
938
939 /* Truncate the l_curr. */
940 l_curr->size = lock->start - l_curr->start;
941
942 DEBUG(10,(" split case: curr: start=%.0f,size=%.0f \
943 new: start=%.0f,size=%.0f\n", (double)l_curr->start, (double)l_curr->size,
944 (double)l_new->start, (double)l_new->size ));
945
946 /*
947 * Add into the dlink list after the l_curr point - NOT at lhead.
948 */
949 DLIST_ADD_AFTER(lhead, l_new, l_curr);
950
951 /* And move after the link we added. */
952 l_curr = l_new->next;
953
954 } else {
955
956 /*
957 * This logic case should never happen. Ensure this is the
958 * case by forcing an abort.... Remove in production.
959 */
960 char *msg = NULL;
961
962 if (asprintf(&msg, "logic flaw in cases: l_curr: start = %.0f, size = %.0f : \
963 lock: start = %.0f, size = %.0f", (double)l_curr->start, (double)l_curr->size, (double)lock->start, (double)lock->size ) != -1) {
964 smb_panic(msg);
965 } else {
966 smb_panic("posix_lock_list");
967 }
968 }
969 } /* end for ( l_curr = lhead; l_curr;) */
970 } /* end for (i=0; i<num_locks && ul_head; i++) */
971
972 return lhead;
973 }
974
975 /****************************************************************************
976 POSIX function to acquire a lock. Returns True if the
977 lock could be granted, False if not.
978 ****************************************************************************/
979
980 bool set_posix_lock_windows_flavour(files_struct *fsp,
981 uint64_t u_offset,
982 uint64_t u_count,
983 enum brl_type lock_type,
984 const struct lock_context *lock_ctx,
985 const struct lock_struct *plocks,
986 int num_locks,
987 int *errno_ret)
988 {
989 SMB_OFF_T offset;
990 SMB_OFF_T count;
991 int posix_lock_type = map_posix_lock_type(fsp,lock_type);
992 bool ret = True;
993 size_t lock_count;
994 TALLOC_CTX *l_ctx = NULL;
995 struct lock_list *llist = NULL;
996 struct lock_list *ll = NULL;
997
998 DEBUG(5,("set_posix_lock_windows_flavour: File %s, offset = %.0f, "
999 "count = %.0f, type = %s\n", fsp_str_dbg(fsp),
1000 (double)u_offset, (double)u_count,
1001 posix_lock_type_name(lock_type)));
1002
1003 /*
1004 * If the requested lock won't fit in the POSIX range, we will
1005 * pretend it was successful.
1006 */
1007
1008 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1009 increment_windows_lock_ref_count(fsp);
1010 return True;
1011 }
1012
1013 /*
1014 * Windows is very strange. It allows read locks to be overlayed
1015 * (even over a write lock), but leaves the write lock in force until the first
1016 * unlock. It also reference counts the locks. This means the following sequence :
1017 *
1018 * process1 process2
1019 * ------------------------------------------------------------------------
1020 * WRITE LOCK : start = 2, len = 10
1021 * READ LOCK: start =0, len = 10 - FAIL
1022 * READ LOCK : start = 0, len = 14
1023 * READ LOCK: start =0, len = 10 - FAIL
1024 * UNLOCK : start = 2, len = 10
1025 * READ LOCK: start =0, len = 10 - OK
1026 *
1027 * Under POSIX, the same sequence in steps 1 and 2 would not be reference counted, but
1028 * would leave a single read lock over the 0-14 region.
1029 */
1030
1031 if ((l_ctx = talloc_init("set_posix_lock")) == NULL) {
1032 DEBUG(0,("set_posix_lock_windows_flavour: unable to init talloc context.\n"));
1033 return False;
1034 }
1035
1036 if ((ll = talloc(l_ctx, struct lock_list)) == NULL) {
1037 DEBUG(0,("set_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1038 talloc_destroy(l_ctx);
1039 return False;
1040 }
1041
1042 /*
1043 * Create the initial list entry containing the
1044 * lock we want to add.
1045 */
1046
1047 ZERO_STRUCTP(ll);
1048 ll->start = offset;
1049 ll->size = count;
1050
1051 DLIST_ADD(llist, ll);
1052
1053 /*
1054 * The following call calculates if there are any
1055 * overlapping locks held by this process on
1056 * fd's open on the same file and splits this list
1057 * into a list of lock ranges that do not overlap with existing
1058 * POSIX locks.
1059 */
1060
1061 llist = posix_lock_list(l_ctx,
1062 llist,
1063 lock_ctx, /* Lock context llist belongs to. */
1064 fsp,
1065 plocks,
1066 num_locks);
1067
1068 /*
1069 * Add the POSIX locks on the list of ranges returned.
1070 * As the lock is supposed to be added atomically, we need to
1071 * back out all the locks if any one of these calls fail.
1072 */
1073
1074 for (lock_count = 0, ll = llist; ll; ll = ll->next, lock_count++) {
1075 offset = ll->start;
1076 count = ll->size;
1077
1078 DEBUG(5,("set_posix_lock_windows_flavour: Real lock: Type = %s: offset = %.0f, count = %.0f\n",
1079 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1080
1081 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1082 *errno_ret = errno;
1083 DEBUG(5,("set_posix_lock_windows_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1084 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1085 ret = False;
1086 break;
1087 }
1088 }
1089
1090 if (!ret) {
1091
1092 /*
1093 * Back out all the POSIX locks we have on fail.
1094 */
1095
1096 for (ll = llist; lock_count; ll = ll->next, lock_count--) {
1097 offset = ll->start;
1098 count = ll->size;
1099
1100 DEBUG(5,("set_posix_lock_windows_flavour: Backing out locks: Type = %s: offset = %.0f, count = %.0f\n",
1101 posix_lock_type_name(posix_lock_type), (double)offset, (double)count ));
1102
1103 posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK);
1104 }
1105 } else {
1106 /* Remember the number of Windows locks we have on this dev/ino pair. */
1107 increment_windows_lock_ref_count(fsp);
1108 }
1109
1110 talloc_destroy(l_ctx);
1111 return ret;
1112 }
1113
1114 /****************************************************************************
1115 POSIX function to release a lock. Returns True if the
1116 lock could be released, False if not.
1117 ****************************************************************************/
1118
1119 bool release_posix_lock_windows_flavour(files_struct *fsp,
1120 uint64_t u_offset,
1121 uint64_t u_count,
1122 enum brl_type deleted_lock_type,
1123 const struct lock_context *lock_ctx,
1124 const struct lock_struct *plocks,
1125 int num_locks)
1126 {
1127 SMB_OFF_T offset;
1128 SMB_OFF_T count;
1129 bool ret = True;
1130 TALLOC_CTX *ul_ctx = NULL;
1131 struct lock_list *ulist = NULL;
1132 struct lock_list *ul = NULL;
1133
1134 DEBUG(5,("release_posix_lock_windows_flavour: File %s, offset = %.0f, "
1135 "count = %.0f\n", fsp_str_dbg(fsp),
1136 (double)u_offset, (double)u_count));
1137
1138 /* Remember the number of Windows locks we have on this dev/ino pair. */
1139 decrement_windows_lock_ref_count(fsp);
1140
1141 /*
1142 * If the requested lock won't fit in the POSIX range, we will
1143 * pretend it was successful.
1144 */
1145
1146 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1147 return True;
1148 }
1149
1150 if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1151 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1152 return False;
1153 }
1154
1155 if ((ul = talloc(ul_ctx, struct lock_list)) == NULL) {
1156 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1157 talloc_destroy(ul_ctx);
1158 return False;
1159 }
1160
1161 /*
1162 * Create the initial list entry containing the
1163 * lock we want to remove.
1164 */
1165
1166 ZERO_STRUCTP(ul);
1167 ul->start = offset;
1168 ul->size = count;
1169
1170 DLIST_ADD(ulist, ul);
1171
1172 /*
1173 * The following call calculates if there are any
1174 * overlapping locks held by this process on
1175 * fd's open on the same file and creates a
1176 * list of unlock ranges that will allow
1177 * POSIX lock ranges to remain on the file whilst the
1178 * unlocks are performed.
1179 */
1180
1181 ulist = posix_lock_list(ul_ctx,
1182 ulist,
1183 lock_ctx, /* Lock context ulist belongs to. */
1184 fsp,
1185 plocks,
1186 num_locks);
1187
1188 /*
1189 * If there were any overlapped entries (list is > 1 or size or start have changed),
1190 * and the lock_type we just deleted from
1191 * the upper layer tdb was a write lock, then before doing the unlock we need to downgrade
1192 * the POSIX lock to a read lock. This allows any overlapping read locks
1193 * to be atomically maintained.
1194 */
1195
1196 if (deleted_lock_type == WRITE_LOCK &&
1197 (!ulist || ulist->next != NULL || ulist->start != offset || ulist->size != count)) {
1198
1199 DEBUG(5,("release_posix_lock_windows_flavour: downgrading lock to READ: offset = %.0f, count = %.0f\n",
1200 (double)offset, (double)count ));
1201
1202 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_RDLCK)) {
1203 DEBUG(0,("release_posix_lock_windows_flavour: downgrade of lock failed with error %s !\n", strerror(errno) ));
1204 talloc_destroy(ul_ctx);
1205 return False;
1206 }
1207 }
1208
1209 /*
1210 * Release the POSIX locks on the list of ranges returned.
1211 */
1212
1213 for(; ulist; ulist = ulist->next) {
1214 offset = ulist->start;
1215 count = ulist->size;
1216
1217 DEBUG(5,("release_posix_lock_windows_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1218 (double)offset, (double)count ));
1219
1220 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1221 ret = False;
1222 }
1223 }
1224
1225 talloc_destroy(ul_ctx);
1226 return ret;
1227 }
1228
1229 /****************************************************************************
1230 Next - the functions that deal with mapping CIFS POSIX locks onto
1231 the underlying system POSIX locks.
1232 ****************************************************************************/
1233
1234 /****************************************************************************
1235 POSIX function to acquire a lock. Returns True if the
1236 lock could be granted, False if not.
1237 As POSIX locks don't stack or conflict (they just overwrite)
1238 we can map the requested lock directly onto a system one. We
1239 know it doesn't conflict with locks on other contexts as the
1240 upper layer would have refused it.
1241 ****************************************************************************/
1242
1243 bool set_posix_lock_posix_flavour(files_struct *fsp,
1244 uint64_t u_offset,
1245 uint64_t u_count,
1246 enum brl_type lock_type,
1247 int *errno_ret)
1248 {
1249 SMB_OFF_T offset;
1250 SMB_OFF_T count;
1251 int posix_lock_type = map_posix_lock_type(fsp,lock_type);
1252
1253 DEBUG(5,("set_posix_lock_posix_flavour: File %s, offset = %.0f, count "
1254 "= %.0f, type = %s\n", fsp_str_dbg(fsp),
1255 (double)u_offset, (double)u_count,
1256 posix_lock_type_name(lock_type)));
1257
1258 /*
1259 * If the requested lock won't fit in the POSIX range, we will
1260 * pretend it was successful.
1261 */
1262
1263 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1264 return True;
1265 }
1266
1267 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,posix_lock_type)) {
1268 *errno_ret = errno;
1269 DEBUG(5,("set_posix_lock_posix_flavour: Lock fail !: Type = %s: offset = %.0f, count = %.0f. Errno = %s\n",
1270 posix_lock_type_name(posix_lock_type), (double)offset, (double)count, strerror(errno) ));
1271 return False;
1272 }
1273 return True;
1274 }
1275
1276 /****************************************************************************
1277 POSIX function to release a lock. Returns True if the
1278 lock could be released, False if not.
1279 We are given a complete lock state from the upper layer which is what the lock
1280 state should be after the unlock has already been done, so what
1281 we do is punch out holes in the unlock range where locks owned by this process
1282 have a different lock context.
1283 ****************************************************************************/
1284
1285 bool release_posix_lock_posix_flavour(files_struct *fsp,
1286 uint64_t u_offset,
1287 uint64_t u_count,
1288 const struct lock_context *lock_ctx,
1289 const struct lock_struct *plocks,
1290 int num_locks)
1291 {
1292 bool ret = True;
1293 SMB_OFF_T offset;
1294 SMB_OFF_T count;
1295 TALLOC_CTX *ul_ctx = NULL;
1296 struct lock_list *ulist = NULL;
1297 struct lock_list *ul = NULL;
1298
1299 DEBUG(5,("release_posix_lock_posix_flavour: File %s, offset = %.0f, "
1300 "count = %.0f\n", fsp_str_dbg(fsp),
1301 (double)u_offset, (double)u_count));
1302
1303 /*
1304 * If the requested lock won't fit in the POSIX range, we will
1305 * pretend it was successful.
1306 */
1307
1308 if(!posix_lock_in_range(&offset, &count, u_offset, u_count)) {
1309 return True;
1310 }
1311
1312 if ((ul_ctx = talloc_init("release_posix_lock")) == NULL) {
1313 DEBUG(0,("release_posix_lock_windows_flavour: unable to init talloc context.\n"));
1314 return False;
1315 }
1316
1317 if ((ul = talloc(ul_ctx, struct lock_list)) == NULL) {
1318 DEBUG(0,("release_posix_lock_windows_flavour: unable to talloc unlock list.\n"));
1319 talloc_destroy(ul_ctx);
1320 return False;
1321 }
1322
1323 /*
1324 * Create the initial list entry containing the
1325 * lock we want to remove.
1326 */
1327
1328 ZERO_STRUCTP(ul);
1329 ul->start = offset;
1330 ul->size = count;
1331
1332 DLIST_ADD(ulist, ul);
1333
1334 /*
1335 * Walk the given array creating a linked list
1336 * of unlock requests.
1337 */
1338
1339 ulist = posix_lock_list(ul_ctx,
1340 ulist,
1341 lock_ctx, /* Lock context ulist belongs to. */
1342 fsp,
1343 plocks,
1344 num_locks);
1345
1346 /*
1347 * Release the POSIX locks on the list of ranges returned.
1348 */
1349
1350 for(; ulist; ulist = ulist->next) {
1351 offset = ulist->start;
1352 count = ulist->size;
1353
1354 DEBUG(5,("release_posix_lock_posix_flavour: Real unlock: offset = %.0f, count = %.0f\n",
1355 (double)offset, (double)count ));
1356
1357 if (!posix_fcntl_lock(fsp,SMB_F_SETLK,offset,count,F_UNLCK)) {
1358 ret = False;
1359 }
1360 }
1361
1362 talloc_destroy(ul_ctx);
1363 return ret;
1364 }
reg import