Print this page
NEX-16818 Add fksmbcl development tool
NEX-17264 SMB client test tp_smbutil_013 fails after NEX-14666
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
and: (fix ref leaks)
NEX-5665 SMB2 oplock leases
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
NEX-5665 SMB2 oplock leases
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
SMB-50 User-mode SMB server
Includes work by these authors:
Thomas Keiser <thomas.keiser@nexenta.com>
Albert Lee <trisk@nexenta.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libfakekernel/common/rwlock.c
+++ new/usr/src/lib/libfakekernel/common/rwlock.c
1 1 /*
2 2 * This file and its contents are supplied under the terms of the
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
3 3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 4 * You may only use this file in accordance with the terms of version
5 5 * 1.0 of the CDDL.
6 6 *
7 7 * A full copy of the text of the CDDL should have accompanied this
8 8 * source. A copy of the CDDL is also available via the Internet at
9 9 * http://www.illumos.org/license/CDDL.
10 10 */
11 11
12 12 /*
13 - * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
13 + * Copyright 2017 Nexenta Systems, Inc. All rights reserved.
14 14 */
15 15
16 16 /*
17 17 * rwlock(9f)
18 18 */
19 19
20 20 /* This is the API we're emulating */
21 21 #include <sys/rwlock.h>
22 22
23 23 #include <sys/errno.h>
24 24 #include <sys/debug.h>
25 25 #include <sys/param.h>
26 -#include <sys/synch32.h>
27 26 #include <sys/thread.h>
28 27
29 28 /* avoiding synch.h */
30 29 int rwlock_init(lwp_rwlock_t *, int, void *);
31 30 int rwlock_destroy(lwp_rwlock_t *);
32 31 int rw_rdlock(lwp_rwlock_t *);
33 32 int rw_wrlock(lwp_rwlock_t *);
34 33 int rw_unlock(lwp_rwlock_t *);
35 34 int rw_tryrdlock(lwp_rwlock_t *);
36 35 int rw_trywrlock(lwp_rwlock_t *);
37 36 int _rw_read_held(void *);
38 37 int _rw_write_held(void *);
39 38
40 39 /*ARGSUSED*/
41 40 void
42 41 rw_init(krwlock_t *rwlp, char *name, krw_type_t type, void *arg)
43 42 {
44 43 (void) rwlock_init(&rwlp->rw_lock, USYNC_THREAD, NULL);
45 44 rwlp->rw_owner = _KTHREAD_INVALID;
46 45 }
47 46
48 47 void
49 48 rw_destroy(krwlock_t *rwlp)
50 49 {
51 50 (void) rwlock_destroy(&rwlp->rw_lock);
52 51 rwlp->rw_owner = _KTHREAD_INVALID;
53 52 }
54 53
55 54 void
56 55 rw_enter(krwlock_t *rwlp, krw_t rw)
57 56 {
58 57 int rc;
59 58
60 59 if (rw == RW_READER) {
61 60 rc = rw_rdlock(&rwlp->rw_lock);
62 61 } else {
63 62 rc = rw_wrlock(&rwlp->rw_lock);
64 63 rwlp->rw_owner = _curthread();
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
65 64 }
66 65 VERIFY(rc == 0);
67 66 }
68 67
69 68 void
70 69 rw_exit(krwlock_t *rwlp)
71 70 {
72 71 if (_rw_write_held(&rwlp->rw_lock)) {
73 72 ASSERT(rwlp->rw_owner == _curthread());
74 73 rwlp->rw_owner = _KTHREAD_INVALID;
74 + } else {
75 + ASSERT(_rw_read_held(&rwlp->rw_lock));
75 76 }
76 77 (void) rw_unlock(&rwlp->rw_lock);
77 78 }
78 79
79 80 int
80 81 rw_tryenter(krwlock_t *rwlp, krw_t rw)
81 82 {
82 83 int rv;
83 84
84 85 if (rw == RW_WRITER) {
85 86 rv = rw_trywrlock(&rwlp->rw_lock);
86 87 if (rv == 0)
87 88 rwlp->rw_owner = _curthread();
88 89 } else
89 90 rv = rw_tryrdlock(&rwlp->rw_lock);
90 91
91 92 return ((rv == 0) ? 1 : 0);
92 93 }
93 94
94 95 /*ARGSUSED*/
95 96 int
96 97 rw_tryupgrade(krwlock_t *rwlp)
97 98 {
98 99
99 100 return (0);
100 101 }
101 102
102 103 void
103 104 rw_downgrade(krwlock_t *rwlp)
104 105 {
105 106 ASSERT(rwlp->rw_owner == _curthread());
106 107 rwlp->rw_owner = _KTHREAD_INVALID;
107 108 VERIFY(rw_unlock(&rwlp->rw_lock) == 0);
108 109 VERIFY(rw_rdlock(&rwlp->rw_lock) == 0);
109 110 }
110 111
111 112 int
112 113 rw_read_held(krwlock_t *rwlp)
113 114 {
114 115 return (_rw_read_held(rwlp));
115 116 }
116 117
117 118 int
118 119 rw_write_held(krwlock_t *rwlp)
119 120 {
120 121 return (_rw_write_held(rwlp));
121 122 }
122 123
123 124 int
124 125 rw_lock_held(krwlock_t *rwlp)
125 126 {
126 127 return (rw_read_held(rwlp) || rw_write_held(rwlp));
127 128 }
128 129
129 130 /*
130 131 * Return the kthread_t * of the lock owner
131 132 */
132 133 void *
133 134 rw_owner(krwlock_t *rwlp)
134 135 {
135 136 return (rwlp->rw_owner);
136 137 }
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX