Bug Summary

File:tbudb/./../budb/db_lock.c
Location:line 209, column 2
Description:Assigned value is always the same as the existing value

Annotated Source Code

1/*
2 * Copyright 2000, International Business Machines Corporation and others.
3 * All Rights Reserved.
4 *
5 * This software has been released under the terms of the IBM Public
6 * License. For details, see the LICENSE file in the top-level source
7 * directory or online at http://www.openafs.org/dl/license10.html
8 */
9
10#include <afsconfig.h>
11#include <afs/param.h>
12
13#include <roken.h>
14
15#include <ubik.h>
16#include <afs/afsutil.h>
17#include <afs/audit.h>
18#include <afs/bubasics.h>
19
20#include "budb_errs.h"
21#include "database.h"
22#include "budb_internal.h"
23#include "error_macros.h"
24
25#define DBH_POS(ptr)( (char *) (ptr) - (char *) &db.h ) ( (char *) (ptr) - (char *) &db.h )
26
27afs_int32 FreeAllLocks(struct rx_call *, afs_uint32);
28afs_int32 FreeLock(struct rx_call *, afs_uint32);
29afs_int32 GetInstanceId(struct rx_call *, afs_uint32 *);
30afs_int32 GetLock(struct rx_call *, afs_uint32, afs_int32, afs_int32,
31 afs_uint32 *);
32
33afs_int32
34SBUDB_FreeAllLocks(struct rx_call *call, afs_uint32 instanceId)
35{
36 afs_int32 code;
37
38 code = FreeAllLocks(call, instanceId);
39 osi_auditU(call, BUDB_FrALckEvent"AFS_BUDB_FrALck", code, AUD_END0);
40 return code;
41}
42
43afs_int32
44FreeAllLocks(struct rx_call *call, afs_uint32 instanceId)
45{
46 db_lockP startPtr, endPtr;
47 struct ubik_trans *ut;
48 afs_int32 code;
49
50 if (callPermitted(call) == 0)
51 return (BUDB_NOTPERMITTED(156303880L));
52
53 code = InitRPC(&ut, LOCKWRITE2, 1);
54 if (code)
55 return (code);
56
57 startPtr = &db.h.textLocks[0];
58 endPtr = &db.h.textLocks[TB_NUM3 - 1];
59 while (startPtr <= endPtr) {
60 if ((ntohl(startPtr->lockState)(__builtin_constant_p(startPtr->lockState) ? ((((__uint32_t
)(startPtr->lockState)) >> 24) | ((((__uint32_t)(startPtr
->lockState)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(startPtr->lockState)) & (0xff << 8))
<< 8) | (((__uint32_t)(startPtr->lockState)) <<
24)) : __bswap32_var(startPtr->lockState)) == 1)
61 && (ntohl(startPtr->instanceId)(__builtin_constant_p(startPtr->instanceId) ? ((((__uint32_t
)(startPtr->instanceId)) >> 24) | ((((__uint32_t)(startPtr
->instanceId)) & (0xff << 16)) >> 8) | (((
(__uint32_t)(startPtr->instanceId)) & (0xff << 8
)) << 8) | (((__uint32_t)(startPtr->instanceId)) <<
24)) : __bswap32_var(startPtr->instanceId)) == instanceId)
62 ) {
63 /* release the lock */
64 startPtr->lockState = 0; /* unlock it */
65 startPtr->lockTime = 0;
66 startPtr->expires = 0;
67 startPtr->instanceId = 0;
68 dbwrite(ut, DBH_POS(startPtr)( (char *) (startPtr) - (char *) &db.h ), (char *)startPtr,
69 sizeof(db_lockT));
70 }
71 startPtr++;
72 }
73 code = ubik_EndTrans(ut);
74 return (code);
75}
76
77afs_int32
78SBUDB_FreeLock(struct rx_call *call, afs_uint32 lockHandle)
79{
80 afs_int32 code;
81
82 code = FreeLock(call, lockHandle);
83 osi_auditU(call, BUDB_FreLckEvent"AFS_BUDB_FreLck", code, AUD_END0);
84 return code;
85}
86
87afs_int32
88FreeLock(struct rx_call *call, afs_uint32 lockHandle)
89{
90 db_lockP lockPtr = 0;
91 struct ubik_trans *ut;
92 afs_int32 code;
93
94 if (callPermitted(call) == 0)
95 return (BUDB_NOTPERMITTED(156303880L));
96
97 code = InitRPC(&ut, LOCKWRITE2, 1);
98 if (code)
99 return (code);
100
101 if (checkLockHandle(ut, lockHandle) == 0)
102 ABORT(BUDB_BADARGUMENT)do { code = (156303882L); goto abort_exit; } while (0);
103
104 lockPtr = &db.h.textLocks[lockHandle - 1];
105
106 lockPtr->lockState = 0; /* unlock it */
107 lockPtr->lockTime = 0;
108 lockPtr->expires = 0;
109 lockPtr->instanceId = 0;
110 dbwrite(ut, DBH_POS(lockPtr)( (char *) (lockPtr) - (char *) &db.h ), (char *)lockPtr, sizeof(db_lockT));
111
112 code = ubik_EndTrans(ut);
113 return (code);
114
115 abort_exit:
116 ubik_AbortTrans(ut);
117 return (code);
118}
119
120afs_int32
121SBUDB_GetInstanceId(struct rx_call *call, afs_uint32 *instanceId)
122{
123 afs_int32 code;
124
125 code = GetInstanceId(call, instanceId);
126 osi_auditU(call, BUDB_GetIIdEvent"AFS_BUDB_GetIId", code, AUD_END0);
127 return code;
128}
129
130afs_int32
131GetInstanceId(struct rx_call *call, afs_uint32 *instanceId)
132{
133 struct ubik_trans *ut;
134 afs_int32 code;
135 afs_int32 instanceValue;
136
137 LogDebug(4, "GetInstanceId:\n");
138
139 /* *** Allow anyone to get the instance id ***
140 * if ( callPermitted(call) == 0 )
141 * return(BUDB_NOTPERMITTED);
142 */
143
144 code = InitRPC(&ut, LOCKWRITE2, 1);
145 if (code)
146 return (code);
147
148 instanceValue = ntohl(db.h.lastInstanceId)(__builtin_constant_p(db.h.lastInstanceId) ? ((((__uint32_t)(
db.h.lastInstanceId)) >> 24) | ((((__uint32_t)(db.h.lastInstanceId
)) & (0xff << 16)) >> 8) | ((((__uint32_t)(db
.h.lastInstanceId)) & (0xff << 8)) << 8) | ((
(__uint32_t)(db.h.lastInstanceId)) << 24)) : __bswap32_var
(db.h.lastInstanceId)) + 1;
149
150 set_header_word(ut, lastInstanceId, htonl(instanceValue))dbwrite ((ut), ((char *)&(db.h.lastInstanceId) - (char *)
&db.h), ((db.h.lastInstanceId = ((__builtin_constant_p(instanceValue
) ? ((((__uint32_t)(instanceValue)) >> 24) | ((((__uint32_t
)(instanceValue)) & (0xff << 16)) >> 8) | (((
(__uint32_t)(instanceValue)) & (0xff << 8)) <<
8) | (((__uint32_t)(instanceValue)) << 24)) : __bswap32_var
(instanceValue)))), (char *)&(db.h.lastInstanceId)), sizeof
(afs_int32));
151
152 code = ubik_EndTrans(ut);
153 return (code);
154}
155
156
157afs_int32
158SBUDB_GetLock(struct rx_call *call, afs_uint32 instanceId, afs_int32 lockName,
159 afs_int32 expiration, afs_uint32 *lockHandle)
160{
161 afs_int32 code;
162
163 code = GetLock(call, instanceId, lockName, expiration, lockHandle);
164 osi_auditU(call, BUDB_GetLckEvent"AFS_BUDB_GetLck", code, AUD_END0);
165 return code;
166}
167
168afs_int32
169GetLock(struct rx_call *call, afs_uint32 instanceId, afs_int32 lockName,
170 afs_int32 expiration, afs_uint32 *lockHandle)
171{
172 struct timeval tv;
173 db_lockP lockPtr;
174 struct ubik_trans *ut;
175
176 afs_int32 code;
177
178 if (callPermitted(call) == 0)
1
Taking false branch
179 return (BUDB_NOTPERMITTED(156303880L));
180
181 if ((lockName < 0) || (lockName >= TB_NUM3))
2
Taking false branch
182 return (BUDB_BADARGUMENT(156303882L));
183
184 /* get the current time */
185 gettimeofday(&tv, 0);
186
187 code = InitRPC(&ut, LOCKWRITE2, 1);
188 if (code)
3
Taking false branch
189 return (code);
190
191 lockPtr = &db.h.textLocks[lockName];
192
193 if ((ntohl(lockPtr->lockState)(__builtin_constant_p(lockPtr->lockState) ? ((((__uint32_t
)(lockPtr->lockState)) >> 24) | ((((__uint32_t)(lockPtr
->lockState)) & (0xff << 16)) >> 8) | ((((
__uint32_t)(lockPtr->lockState)) & (0xff << 8)) <<
8) | (((__uint32_t)(lockPtr->lockState)) << 24)) : __bswap32_var
(lockPtr->lockState)) != 0) /* lock set */
4
Taking false branch
194 &&(ntohl(lockPtr->expires)(__builtin_constant_p(lockPtr->expires) ? ((((__uint32_t)(
lockPtr->expires)) >> 24) | ((((__uint32_t)(lockPtr->
expires)) & (0xff << 16)) >> 8) | ((((__uint32_t
)(lockPtr->expires)) & (0xff << 8)) << 8) |
(((__uint32_t)(lockPtr->expires)) << 24)) : __bswap32_var
(lockPtr->expires)) > tv.tv_sec) /* not expired */
195 ) {
196 if (ntohl(lockPtr->instanceId)(__builtin_constant_p(lockPtr->instanceId) ? ((((__uint32_t
)(lockPtr->instanceId)) >> 24) | ((((__uint32_t)(lockPtr
->instanceId)) & (0xff << 16)) >> 8) | (((
(__uint32_t)(lockPtr->instanceId)) & (0xff << 8)
) << 8) | (((__uint32_t)(lockPtr->instanceId)) <<
24)) : __bswap32_var(lockPtr->instanceId)) == instanceId)
197 code = BUDB_SELFLOCKED(156303890L);
198 else
199 code = BUDB_LOCKED(156303889L);
200 goto abort_exit;
201 }
202
203 lockPtr->lockState = htonl(1)(__builtin_constant_p(1) ? ((((__uint32_t)(1)) >> 24) |
((((__uint32_t)(1)) & (0xff << 16)) >> 8) | (
(((__uint32_t)(1)) & (0xff << 8)) << 8) | (((
__uint32_t)(1)) << 24)) : __bswap32_var(1)); /* lock it */
204 lockPtr->lockTime = htonl(tv.tv_sec)(__builtin_constant_p(tv.tv_sec) ? ((((__uint32_t)(tv.tv_sec)
) >> 24) | ((((__uint32_t)(tv.tv_sec)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(tv.tv_sec)) & (0xff <<
8)) << 8) | (((__uint32_t)(tv.tv_sec)) << 24)) :
__bswap32_var(tv.tv_sec)); /* when locked */
205 lockPtr->expires = htonl(tv.tv_sec + expiration)(__builtin_constant_p(tv.tv_sec + expiration) ? ((((__uint32_t
)(tv.tv_sec + expiration)) >> 24) | ((((__uint32_t)(tv.
tv_sec + expiration)) & (0xff << 16)) >> 8) |
((((__uint32_t)(tv.tv_sec + expiration)) & (0xff <<
8)) << 8) | (((__uint32_t)(tv.tv_sec + expiration)) <<
24)) : __bswap32_var(tv.tv_sec + expiration));
206 lockPtr->instanceId = htonl(instanceId)(__builtin_constant_p(instanceId) ? ((((__uint32_t)(instanceId
)) >> 24) | ((((__uint32_t)(instanceId)) & (0xff <<
16)) >> 8) | ((((__uint32_t)(instanceId)) & (0xff <<
8)) << 8) | (((__uint32_t)(instanceId)) << 24)) :
__bswap32_var(instanceId));
207 code = dbwrite(ut, DBH_POS(lockPtr)( (char *) (lockPtr) - (char *) &db.h ), (char *)lockPtr, sizeof(db_lockT));
208 if (code)
5
Taking true branch
209 ABORT(code)do { code = code; goto abort_exit; } while (0);
6
Within the expansion of the macro 'ABORT':
a
Assigned value is always the same as the existing value
210
211 *lockHandle = (afs_uint32) (lockName + 1);
212 code = ubik_EndTrans(ut);
213 return (code);
214
215 abort_exit:
216 ubik_AbortTrans(ut);
217 return (code);
218}
219
220
221/* checkLockHandle
222 * exit:
223 * 0 - if invalid handle
224 * 1 - if handle is valid
225 */
226int
227checkLockHandle(struct ubik_trans *ut, afs_uint32 lockHandle)
228{
229 return (((lockHandle > 0) && (lockHandle <= TB_NUM3)) ? 1 : 0);
230}