Bug Summary

File:afs/afs_syscall.c
Location:line 838, column 3
Description:Function call argument is an uninitialized 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#ifdef IGNORE_SOME_GCC_WARNINGS
14# pragma GCC diagnostic warning "-Wold-style-definition"
15# pragma GCC diagnostic warning "-Wstrict-prototypes"
16#endif
17
18#include "afs/sysincludes.h" /* Standard vendor system headers */
19#include "afsincludes.h" /* Afs-based standard headers */
20#include "afs/afs_stats.h"
21#include "rx/rx_globals.h"
22#if !defined(UKERNEL) && !defined(AFS_LINUX20_ENV)
23#include "net/if.h"
24#ifdef AFS_SGI62_ENV
25#include "h/hashing.h"
26#endif
27#if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
28#include "netinet/in_var.h"
29#endif
30#endif /* !defined(UKERNEL) */
31
32#if (defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)) || defined(AFS_HPUX_64BIT_ENV) || defined(AFS_SUN5_64BIT_ENV) || (defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64)) || defined(NEED_IOCTL32)
33static void
34afs_ioctl32_to_afs_ioctl(const struct afs_ioctl32 *src, struct afs_ioctl *dst)
35{
36#ifdef AFS_DARWIN100_ENV
37 dst->in = CAST_USER_ADDR_T(src->in);
38 dst->out = CAST_USER_ADDR_T(src->out);
39#else
40 dst->in = (char *)(unsigned long)src->in;
41 dst->out = (char *)(unsigned long)src->out;
42#endif
43 dst->in_size = src->in_size;
44 dst->out_size = src->out_size;
45}
46#endif
47
48/*
49 * If you need to change copyin_afs_ioctl(), you may also need to change
50 * copyin_iparam().
51 */
52
53int
54#ifdef AFS_DARWIN100_ENV
55copyin_afs_ioctl(user_addr_t cmarg, struct afs_ioctl *dst)
56#else
57copyin_afs_ioctl(caddr_t cmarg, struct afs_ioctl *dst)
58#endif
59{
60 int code;
61#if defined(AFS_DARWIN100_ENV)
62 struct afs_ioctl32 dst32;
63
64 if (!proc_is64bit(current_proc())) {
65 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 65); } while (0); code = copyin(((cmarg)),((caddr_t) & dst32
),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 65); (void)0; } while (0); } while(0);
66 if (!code)
67 afs_ioctl32_to_afs_ioctl(&dst32, dst);
68 return code;
69 }
70#endif
71#if defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL)
72 struct afs_ioctl32 dst32;
73
74 if (!(IS64U)) {
75 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 75); } while (0); code = copyin(((cmarg)),((caddr_t) & dst32
),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 75); (void)0; } while (0); } while(0);
76 if (!code)
77 afs_ioctl32_to_afs_ioctl(&dst32, dst);
78 return code;
79 }
80#endif /* defined(AFS_AIX51_ENV) && defined(AFS_64BIT_KERNEL) */
81
82
83#if defined(AFS_HPUX_64BIT_ENV)
84 struct afs_ioctl32 dst32;
85
86 if (is_32bit(u.u_procp)) { /* is_32bit() in proc_iface.h */
87 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 87); } while (0); code = copyin(((cmarg)),((caddr_t) & dst32
),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 87); (void)0; } while (0); } while(0);
88 if (!code)
89 afs_ioctl32_to_afs_ioctl(&dst32, dst);
90 return code;
91 }
92#endif /* defined(AFS_HPUX_64BIT_ENV) */
93
94#if defined(AFS_SUN5_64BIT_ENV)
95 struct afs_ioctl32 dst32;
96
97 if (get_udatamodel() == DATAMODEL_ILP32) {
98 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 98); } while (0); code = copyin(((cmarg)),((caddr_t) & dst32
),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 98); (void)0; } while (0); } while(0);
99 if (!code)
100 afs_ioctl32_to_afs_ioctl(&dst32, dst);
101 return code;
102 }
103#endif /* defined(AFS_SUN5_64BIT_ENV) */
104
105#if defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64)
106 struct afs_ioctl32 dst32;
107
108 if (!ABI_IS_64BIT(get_current_abi())) {
109 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 109); } while (0); code = copyin(((cmarg)),((caddr_t) &
dst32),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 109); (void)0; } while (0); } while(0);
110 if (!code)
111 afs_ioctl32_to_afs_ioctl(&dst32, dst);
112 return code;
113 }
114#endif /* defined(AFS_SGI_ENV) && (_MIPS_SZLONG==64) */
115
116#if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)
117 struct afs_ioctl32 dst32;
118
119#ifdef AFS_SPARC64_LINUX26_ENV
120 if (test_thread_flag(TIF_32BIT))
121#elif defined(AFS_SPARC64_LINUX24_ENV)
122 if (current->thread.flags & SPARC_FLAG_32BIT)
123#elif defined(AFS_SPARC64_LINUX20_ENV)
124 if (current->tss.flags & SPARC_FLAG_32BIT)
125
126#elif defined(AFS_AMD64_LINUX26_ENV)
127 if (test_thread_flag(TIF_IA32))
128#elif defined(AFS_AMD64_LINUX20_ENV)
129 if (current->thread.flags & THREAD_IA32)
130
131#elif defined(AFS_PPC64_LINUX26_ENV)
132#if defined(STRUCT_TASK_STRUCT_HAS_THREAD_INFO)
133 if (current->thread_info->flags & _TIF_32BIT)
134#else
135 if (task_thread_info(current)->flags & _TIF_32BIT)
136#endif
137#elif defined(AFS_PPC64_LINUX20_ENV)
138 if (current->thread.flags & PPC_FLAG_32BIT)
139
140#elif defined(AFS_S390X_LINUX26_ENV)
141 if (test_thread_flag(TIF_31BIT))
142#elif defined(AFS_S390X_LINUX20_ENV)
143 if (current->thread.flags & S390_FLAG_31BIT)
144
145#else
146#error pioctl32 not done for this linux
147#endif
148 {
149 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 149); } while (0); code = copyin(((cmarg)),((caddr_t) &
dst32),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 149); (void)0; } while (0); } while(0);
150 if (!code)
151 afs_ioctl32_to_afs_ioctl(&dst32, dst);
152 return code;
153 }
154#endif /* defined(AFS_LINUX_64BIT_KERNEL) */
155
156 AFS_COPYIN(cmarg, (caddr_t) dst, sizeof *dst, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 156); } while (0); code = copyin(((cmarg)),((caddr_t) dst),
(sizeof *dst)); if (haveGlock) do { (void)0; _mtx_lock_flags(
((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 156); (void)0; } while (0); } while(0);
157 return code;
158}
159
160
161#ifdef AFS_AIX32_ENV
162
163#include "sys/lockl.h"
164
165/*
166 * syscall - this is the VRMIX system call entry point.
167 *
168 * NOTE:
169 * THIS SHOULD BE CHANGED TO afs_syscall(), but requires
170 * all the user-level calls to `syscall' to change.
171 */
172syscall(syscall, p1, p2, p3, p4, p5, p6)
173{
174 int rval1 = 0, code;
175 int monster;
176 int retval = 0;
177#ifndef AFS_AIX41_ENV
178 extern lock_t kernel_lock;
179 monster = lockl(&kernel_lock, LOCK_SHORT);
180#endif /* !AFS_AIX41_ENV */
181
182 AFS_STATCNT(syscall)((afs_cmstats.callInfo.C_syscall)++);
183 setuerror(0)u.u_error = (0);
184 switch (syscall) {
185 case AFSCALL_CALL28:
186 rval1 = afs_syscall_call(p1, p2, p3, p4, p5, p6);
187 break;
188
189 case AFSCALL_SETPAG21:
190 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 190); (void)0; } while (0);
191 rval1 = afs_setpag();
192 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 192); } while
(0);
193 break;
194
195 case AFSCALL_PIOCTL20:
196 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 196); (void)0; } while (0);
197 rval1 = afs_syscall_pioctl(p1, p2, p3, p4);
198 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 198); } while
(0);
199 break;
200
201 case AFSCALL_ICREATE23:
202 rval1 = afs_syscall_icreate(p1, p2, p3, p4, p5, p6);
203 break;
204
205 case AFSCALL_IOPEN22:
206 rval1 = afs_syscall_iopen(p1, p2, p3);
207 break;
208
209 case AFSCALL_IDEC27:
210 rval1 = afs_syscall_iincdec(p1, p2, p3, -1);
211 break;
212
213 case AFSCALL_IINC26:
214 rval1 = afs_syscall_iincdec(p1, p2, p3, 1);
215 break;
216
217 case AFSCALL_ICL30:
218 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 218); (void)0; } while (0);
219 code = Afscall_icl(p1, p2, p3, p4, p5, &retval);
220 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 220); } while
(0);
221 if (!code)
222 rval1 = retval;
223 if (!rval1)
224 rval1 = code;
225 break;
226
227 default:
228 rval1 = EINVAL22;
229 setuerror(EINVAL)u.u_error = (22);
230 break;
231 }
232
233 out:
234#ifndef AFS_AIX41_ENV
235 if (monster != LOCK_NEST)
236 unlockl(&kernel_lock);
237#endif /* !AFS_AIX41_ENV */
238 return getuerror()u.u_error? -1 : rval1;
239}
240
241/*
242 * lsetpag - interface to afs_setpag().
243 */
244int
245lsetpag(void)
246{
247
248 AFS_STATCNT(lsetpag)((afs_cmstats.callInfo.C_lsetpag)++);
249 return syscall(AFSCALL_SETPAG21, 0, 0, 0, 0, 0);
250}
251
252/*
253 * lpioctl - interface to pioctl()
254 */
255int
256lpioctl(char *path, int cmd, void *cmarg, int follow)
257{
258
259 AFS_STATCNT(lpioctl)((afs_cmstats.callInfo.C_lpioctl)++);
260 return syscall(AFSCALL_PIOCTL20, path, cmd, cmarg, follow);
261}
262
263#else /* !AFS_AIX32_ENV */
264
265#if defined(AFS_SGI_ENV)
266struct afsargs {
267 sysarg_t syscall;
268 sysarg_t parm1;
269 sysarg_t parm2;
270 sysarg_t parm3;
271 sysarg_t parm4;
272 sysarg_t parm5;
273};
274
275
276int
277Afs_syscall(struct afsargs *uap, rval_t * rvp)
278{
279 int error;
280 long retval;
281
282 AFS_STATCNT(afs_syscall)((afs_cmstats.callInfo.C_afs_syscall)++);
283 switch (uap->syscall) {
284 case AFSCALL_ICL30:
285 retval = 0;
286 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 286); (void)0; } while (0);
287 error =
288 Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
289 uap->parm5, &retval);
290 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 290); } while
(0);
291 rvp->r_val1 = retval;
292 break;
293#ifdef AFS_SGI_XFS_IOPS_ENV
294 case AFSCALL_IDEC6444:
295 error =
296 afs_syscall_idec64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
297 uap->parm5);
298 break;
299 case AFSCALL_IINC6443:
300 error =
301 afs_syscall_iinc64(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
302 uap->parm5);
303 break;
304 case AFSCALL_ILISTINODE6445:
305 error =
306 afs_syscall_ilistinode64(uap->parm1, uap->parm2, uap->parm3,
307 uap->parm4, uap->parm5);
308 break;
309 case AFSCALL_ICREATENAME6446:
310 error =
311 afs_syscall_icreatename64(uap->parm1, uap->parm2, uap->parm3,
312 uap->parm4, uap->parm5);
313 break;
314#endif
315#ifdef AFS_SGI_VNODE_GLUE
316 case AFSCALL_INIT_KERNEL_CONFIG:
317 error = afs_init_kernel_config(uap->parm1);
318 break;
319#endif
320 default:
321 error =
322 afs_syscall_call(uap->syscall, uap->parm1, uap->parm2, uap->parm3,
323 uap->parm4, uap->parm5);
324 }
325 return error;
326}
327
328#else /* AFS_SGI_ENV */
329
330struct iparam {
331 iparmtype param1;
332 iparmtype param2;
333 iparmtype param3;
334 iparmtype param4;
335};
336
337struct iparam32 {
338 int param1;
339 int param2;
340 int param3;
341 int param4;
342};
343
344
345#if defined(AFS_HPUX_64BIT_ENV) || defined(AFS_SUN5_64BIT_ENV) || (defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)) || defined(NEED_IOCTL32)
346static void
347iparam32_to_iparam(const struct iparam32 *src, struct iparam *dst)
348{
349 dst->param1 = (iparmtype)(uintptrszunsigned int)src->param1;
350 dst->param2 = (iparmtype)(uintptrszunsigned int)src->param2;
351 dst->param3 = (iparmtype)(uintptrszunsigned int)src->param3;
352 dst->param4 = (iparmtype)(uintptrszunsigned int)src->param4;
353}
354#endif
355
356/*
357 * If you need to change copyin_iparam(), you may also need to change
358 * copyin_afs_ioctl().
359 *
360 * This function is needed only for icreate, meaning, only on platforms
361 * providing the inode fileserver.
362 */
363
364static int
365copyin_iparam(caddr_t cmarg, struct iparam *dst)
366{
367 int code;
368
369#if defined(AFS_HPUX_64BIT_ENV)
370 struct iparam32 dst32;
371
372 if (is_32bit(u.u_procp)) { /* is_32bit() in proc_iface.h */
373 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 373); } while (0); code = copyin(((cmarg)),((caddr_t) &
dst32),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 373); (void)0; } while (0); } while(0);
374 if (!code)
375 iparam32_to_iparam(&dst32, dst);
376 return code;
377 }
378#endif /* AFS_HPUX_64BIT_ENV */
379
380#if defined(AFS_SUN5_64BIT_ENV)
381 struct iparam32 dst32;
382
383 if (get_udatamodel() == DATAMODEL_ILP32) {
384 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 384); } while (0); code = copyin(((cmarg)),((caddr_t) &
dst32),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 384); (void)0; } while (0); } while(0);
385 if (!code)
386 iparam32_to_iparam(&dst32, dst);
387 return code;
388 }
389#endif /* AFS_SUN5_64BIT_ENV */
390
391#if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_ALPHA_LINUX20_ENV) && !defined(AFS_IA64_LINUX20_ENV)
392 struct iparam32 dst32;
393
394#ifdef AFS_SPARC64_LINUX26_ENV
395 if (test_thread_flag(TIF_32BIT))
396#elif defined(AFS_SPARC64_LINUX24_ENV)
397 if (current->thread.flags & SPARC_FLAG_32BIT)
398#elif defined(AFS_SPARC64_LINUX20_ENV)
399 if (current->tss.flags & SPARC_FLAG_32BIT)
400
401#elif defined(AFS_AMD64_LINUX26_ENV)
402 if (test_thread_flag(TIF_IA32))
403#elif defined(AFS_AMD64_LINUX20_ENV)
404 if (current->thread.flags & THREAD_IA32)
405
406#elif defined(AFS_PPC64_LINUX26_ENV)
407#if defined(STRUCT_TASK_STRUCT_HAS_THREAD_INFO)
408 if (current->thread_info->flags & _TIF_32BIT)
409#else
410 if (task_thread_info(current)->flags & _TIF_32BIT)
411#endif
412#elif defined(AFS_PPC64_LINUX20_ENV)
413 if (current->thread.flags & PPC_FLAG_32BIT)
414
415#elif defined(AFS_S390X_LINUX26_ENV)
416 if (test_thread_flag(TIF_31BIT))
417#elif defined(AFS_S390X_LINUX20_ENV)
418 if (current->thread.flags & S390_FLAG_31BIT)
419
420#else
421#error iparam32 not done for this linux platform
422#endif
423 {
424 AFS_COPYIN(cmarg, (caddr_t) & dst32, sizeof dst32, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 424); } while (0); code = copyin(((cmarg)),((caddr_t) &
dst32),(sizeof dst32)); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 424); (void)0; } while (0); } while(0);
425 if (!code)
426 iparam32_to_iparam(&dst32, dst);
427 return code;
428 }
429#endif /* AFS_LINUX_64BIT_KERNEL */
430
431 AFS_COPYIN(cmarg, (caddr_t) dst, sizeof *dst, code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 431); } while (0); code = copyin(((cmarg)),((caddr_t) dst),
(sizeof *dst)); if (haveGlock) do { (void)0; _mtx_lock_flags(
((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 431); (void)0; } while (0); } while(0);
432 return code;
433}
434
435/* Main entry of all afs system calls */
436#ifdef AFS_SUN5_ENV
437extern int afs_sinited;
438
439Afs_syscall(struct afssysa *uap, rval_t * rvp)
440{
441 int *retval = &rvp->r_val1;
442#elif defined(AFS_DARWIN100_ENV)
443struct afssysa {
444 afs_int32 syscall;
445 afs_int32 parm1;
446 afs_int32 parm2;
447 afs_int32 parm3;
448 afs_int32 parm4;
449 afs_int32 parm5;
450 afs_int32 parm6;
451};
452struct afssysa64 {
453 afs_int64 parm1;
454 afs_int64 parm2;
455 afs_int64 parm3;
456 afs_int64 parm4;
457 afs_int64 parm5;
458 afs_int64 parm6;
459 afs_int32 syscall;
460};
461int
462afs3_syscall(afs_proc_t *p, void *args, unsigned int *retval)
463{
464 struct afssysa64 *uap64 = NULL((void *)0);
465 struct afssysa *uap = NULL((void *)0);
466#elif defined(AFS_FBSD_ENV1)
467int
468afs3_syscall(struct thread *p, void *args)
469{
470 struct a {
471 long syscall;
472 long parm1;
473 long parm2;
474 long parm3;
475 long parm4;
476 long parm5;
477 long parm6;
478 } *uap = (struct a *)args;
479 long *retval;
480#elif defined(AFS_NBSD40_ENV)
481int
482afs3_syscall(struct lwp *p, const void *args, register_t *retval)
483{
484 /* see osi_machdep.h */
485 struct afs_sysargs *uap = (struct afs_sysargs *) args;
486#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
487int
488afs3_syscall(afs_proc_t *p, void *args, long *retval)
489{
490 struct a {
491 long syscall;
492 long parm1;
493 long parm2;
494 long parm3;
495 long parm4;
496 long parm5;
497 long parm6;
498 } *uap = (struct a *)args;
499#elif defined(AFS_LINUX20_ENV)
500struct afssysargs {
501 long syscall;
502 long parm1;
503 long parm2;
504 long parm3;
505 long parm4;
506 long parm5;
507 long parm6; /* not actually used - should be removed */
508};
509/* Linux system calls only set up for 5 arguments. */
510asmlinkage long
511afs_syscall(long syscall, long parm1, long parm2, long parm3, long parm4)
512{
513 struct afssysargs args, *uap = &args;
514 long linux_ret = 0;
515 long *retval = &linux_ret;
516 long eparm[4]; /* matches AFSCALL_ICL in fstrace.c */
517# ifdef AFS_SPARC64_LINUX24_ENV
518 afs_int32 eparm32[4];
519# endif
520 /* eparm is also used by AFSCALL_CALL in afsd.c */
521#else
522# if defined(UKERNEL)
523int
524Afs_syscall()
525{
526 struct a {
527 long syscall;
528 long parm1;
529 long parm2;
530 long parm3;
531 long parm4;
532 long parm5;
533 long parm6;
534 } *uap = (struct a *)get_user_struct()->u_ap;
535# else /* UKERNEL */
536int
537Afs_syscall()
538{
539 struct a {
540 long syscall;
541 long parm1;
542 long parm2;
543 long parm3;
544 long parm4;
545 long parm5;
546 long parm6;
547 } *uap = (struct a *)u.u_ap;
548# endif /* UKERNEL */
549# if defined(AFS_HPUX_ENV)
550 long *retval = &u.u_rval1;
551# elif defined(UKERNEL)
552 int *retval = &(get_user_struct()->u_rval1);
553# else
554 int *retval = &u.u_rval1;
555# endif
556#endif
557 int code = 0;
558
559 AFS_STATCNT(afs_syscall)((afs_cmstats.callInfo.C_afs_syscall)++);
560#ifdef AFS_SUN5_ENV
561 rvp->r_vals = 0;
562 if (!afs_sinited) {
563 return (ENODEV19);
564 }
565#endif
566#ifdef AFS_LINUX20_ENV
567 /* setup uap for use below - pull out the magic decoder ring to know
568 * which syscalls have folded argument lists.
569 */
570 uap->syscall = syscall;
571 uap->parm1 = parm1;
572 uap->parm2 = parm2;
573 uap->parm3 = parm3;
574 if (syscall == AFSCALL_ICL30 || syscall == AFSCALL_CALL28) {
575#ifdef AFS_SPARC64_LINUX24_ENV
576/* from arch/sparc64/kernel/sys_sparc32.c */
577#define AA(__x) \
578({ unsigned long __ret; \
579 __asm__ ("srl %0, 0, %0" \
580 : "=r" (__ret) \
581 : "0" (__x)); \
582 __ret; \
583})
584
585
586#ifdef AFS_SPARC64_LINUX26_ENV
587 if (test_thread_flag(TIF_32BIT))
588#else
589 if (current->thread.flags & SPARC_FLAG_32BIT)
590#endif
591 {
592 AFS_COPYIN((char *)parm4, (char *)eparm32, sizeof(eparm32), code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 592); } while (0); code = copyin((((char *)parm4)),((char *
)eparm32),(sizeof(eparm32))); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 592); (void)0; } while (0); } while(0);
593 eparm[0] = AA(eparm32[0]);
594 eparm[1] = AA(eparm32[1]);
595 eparm[2] = AA(eparm32[2]);
596#undef AA
597 } else
598#endif
599 AFS_COPYIN((char *)parm4, (char *)eparm, sizeof(eparm), code)do { int haveGlock = ((((&afs_global_mtx)->mtx_lock &
~(0x00000001 | 0x00000002 | 0x00000004)) == (uintptr_t)(__curthread
()))); if (haveGlock) do { (void)0; _mtx_unlock_flags(((&
afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 599); } while (0); code = copyin((((char *)parm4)),((char *
)eparm),(sizeof(eparm))); if (haveGlock) do { (void)0; _mtx_lock_flags
(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 599); (void)0; } while (0); } while(0);
600 uap->parm4 = eparm[0];
601 uap->parm5 = eparm[1];
602 uap->parm6 = eparm[2];
603 } else {
604 uap->parm4 = parm4;
605 uap->parm5 = 0;
606 uap->parm6 = 0;
607 }
608#endif
609#if defined(AFS_DARWIN80_ENV)
610 get_vfs_context();
611 osi_Assert(*retval == 0)(void)((*retval == 0) || (osi_AssertFailK( "*retval == 0" , "/home/wollman/openafs/src/afs/afs_syscall.c"
, 611), 0));
612#ifdef AFS_DARWIN100_ENV
613 if (proc_is64bit(p)) {
614 uap64 = (struct afssysa64 *)args;
615 if (uap64->syscall == AFSCALL_CALL28) {
616 code =
617 afs_syscall64_call(uap64->parm1, uap64->parm2, uap64->parm3,
618 uap64->parm4, uap64->parm5, uap64->parm6);
619 /* pass back the code as syscall retval */
620 if (code < 0) {
621 *retval = code;
622 code = 0;
623 }
624 } else if (uap64->syscall == AFSCALL_SETPAG21) {
625 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 625); (void)0; } while (0);
626 code = afs_setpag(p, args, retval);
627 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 627); } while
(0);
628 } else if (uap64->syscall == AFSCALL_PIOCTL20) {
629 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 629); (void)0; } while (0);
630 code =
631 afs_syscall64_pioctl(uap64->parm1, (unsigned int)uap64->parm2,
632 uap64->parm3, (int)uap64->parm4,
633 kauth_cred_get());
634 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 634); } while
(0);
635 } else if (uap64->syscall == AFSCALL_ICL30) {
636 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 636); (void)0; } while (0);
637 code =
638 Afscall64_icl(uap64->parm1, uap64->parm2, uap64->parm3,
639 uap64->parm4, uap64->parm5, retval);
640 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 640); } while
(0);
641 } else
642 code = EINVAL22;
643 if (uap64->syscall != AFSCALL_CALL28)
644 put_vfs_context();
645 } else { /* and the default case for 32 bit procs */
646#endif
647 uap = (struct afssysa *)args;
648#endif
649#if defined(AFS_HPUX_ENV)
650 /*
651 * There used to be code here (duplicated from osi_Init()) for
652 * initializing the semaphore used by AFS_GLOCK(). Was the
653 * duplication to handle the case of a dynamically loaded kernel
654 * module?
655 */
656 osi_InitGlock()do { mtx_init(&afs_global_mtx, "AFS global lock", ((void *
)0), 0x00000000); afs_global_owner = 0; } while (0);
657#endif
658
659#if defined(AFS_NBSD40_ENV)
660 if (SCARG(uap, syscall) == AFSCALL_CALL28) {
661 code =
662 afs_syscall_call(SCARG(uap, parm1), SCARG(uap, parm2),
663 SCARG(uap, parm3), SCARG(uap, parm4),
664 SCARG(uap, parm5), SCARG(uap, parm6));
665 } else if (SCARG(uap, syscall) == AFSCALL_SETPAG21) {
666#else
667 if (uap->syscall == AFSCALL_CALL28) {
1
Taking false branch
668 code =
669 afs_syscall_call(uap->parm1, uap->parm2, uap->parm3,
670 uap->parm4, uap->parm5, uap->parm6);
671#ifdef AFS_DARWIN_ENV
672 /* pass back the code as syscall retval */
673 if (code < 0) {
674 *retval = code;
675 code = 0;
676 }
677#endif
678 } else if (uap->syscall == AFSCALL_SETPAG21) {
2
Taking false branch
679#endif
680#ifdef AFS_SUN5_ENV
681 proc_t *procp;
682
683 procp = ttoproc(curthread(__curthread()));
684 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 684); (void)0; } while (0);
685 code = afs_setpag(&procp->p_cred);
686 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 686); } while
(0);
687#else
688 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 688); (void)0; } while (0);
689#if defined(AFS_FBSD_ENV1)
690 code = afs_setpag(p, args);
691#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
692 code = afs_setpag(p, args, retval);
693#else /* AFS_DARWIN_ENV || AFS_XBSD_ENV */
694 code = afs_setpag();
695#endif
696 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 696); } while
(0);
697#endif
698 } else if
3
Taking false branch
699#if defined(AFS_NBSD40_ENV)
700 (SCARG(uap, syscall) == AFSCALL_PIOCTL20) {
701#else
702 (uap->syscall == AFSCALL_PIOCTL20) {
703#endif
704 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 704); (void)0; } while (0);
705#if defined(AFS_SUN5_ENV)
706 code =
707 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
708 uap->parm4, rvp, CRED());
709#elif defined(AFS_FBSD_ENV1)
710 code =
711 afs_syscall_pioctl((void *)uap->parm1, uap->parm2, (void *)uap->parm3,
712 uap->parm4, p->td_ucred);
713#elif defined(AFS_DARWIN80_ENV)
714 code =
715 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
716 uap->parm4, kauth_cred_get());
717#elif defined(AFS_NBSD40_ENV)
718 code =
719 afs_syscall_pioctl((char *)SCARG(uap, parm1), SCARG(uap, parm2),
720 (void *)SCARG(uap, parm3), SCARG(uap, parm4),
721 kauth_cred_get());
722#elif defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
723 code =
724 afs_syscall_pioctl(uap->parm1, uap->parm2, uap->parm3,
725 uap->parm4, p->p_cred->pc_ucred);
726#else
727 code =
728 afs_syscall_pioctl((char *)uap->parm1,
729 (unsigned int)uap->parm2,
730 (caddr_t)uap->parm3,
731 (int) uap->parm4);
732#endif
733 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 733); } while
(0);
734
735#ifdef AFS_NBSD40_ENV
736 } else if (SCARG(uap, syscall) == AFSCALL_ICREATE23) {
737 struct iparam iparams;
738 code = copyin_iparam((char *) SCARG(uap, parm3), &iparams);
739#else
740 } else if (uap->syscall == AFSCALL_ICREATE23) {
4
Taking false branch
741 struct iparam iparams;
742
743 code = copyin_iparam((char *)uap->parm3, &iparams);
744#endif
745 if (code) {
746#if defined(KERNEL_HAVE_UERROR)
747 setuerror(code)u.u_error = (code);
748#endif
749 } else {
750#if defined(AFS_SUN5_ENV)
751 code =
752 afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
753 iparams.param2, iparams.param3,
754 iparams.param4, rvp, CRED());
755#elif defined(AFS_NBSD40_ENV)
756 code =
757 afs_syscall_icreate(SCARG(uap, parm1), SCARG(uap, parm2),
758 iparams.param1, iparams.param2, iparams.param3,
759 iparams.param4, retval
760 );
761#else
762 code =
763 afs_syscall_icreate(uap->parm1, uap->parm2, iparams.param1,
764 iparams.param2, iparams.param3,
765 iparams.param4
766#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
767 , retval
768#endif
769 );
770#endif /* AFS_SUN5_ENV */
771 }
772#if defined(AFS_NBSD40_ENV)
773 } else if (SCARG(uap, syscall) == AFSCALL_IOPEN22) {
774#else
775 } else if (uap->syscall == AFSCALL_IOPEN22) {
5
Taking false branch
776#endif /* !AFS_NBSD40_ENV */
777#if defined(AFS_SUN5_ENV)
778 code =
779 afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3, rvp,
780 CRED());
781#elif defined(AFS_NBSD40_ENV)
782 code = afs_syscall_iopen(SCARG(uap, parm1), SCARG(uap, parm2),
783 SCARG(uap, parm3), retval);
784#else
785 code = afs_syscall_iopen(uap->parm1, uap->parm2, uap->parm3
786#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV1)
787 , retval
788#endif
789 );
790#endif /* AFS_SUN5_ENV */
791#if defined(AFS_NBSD40_ENV)
792 } else if (SCARG(uap, syscall) == AFSCALL_IDEC27) {
793#else
794 } else if (uap->syscall == AFSCALL_IDEC27) {
6
Taking false branch
795#endif
796#if defined(AFS_NBSD40_ENV)
797 code = afs_syscall_iincdec(SCARG(uap, parm1), SCARG(uap, parm2),
798 SCARG(uap, parm3), -1);
799#else
800
801
802 code =
803 afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, -1
804#if defined(AFS_SUN5_ENV)
805 , rvp, CRED()
806#endif
807 );
808
809#endif /* !AFS_NBSD40_ENV */
810#if defined(AFS_NBSD40_ENV)
811 } else if (SCARG(uap, syscall) == AFSCALL_IINC26) {
812#else
813 } else if (uap->syscall == AFSCALL_IINC26) {
7
Taking false branch
814#endif
815#if defined(AFS_NBSD40_ENV)
816 code = afs_syscall_iincdec(SCARG(uap, parm1), SCARG(uap, parm2),
817 SCARG(uap, parm3), 1);
818#else
819 code =
820 afs_syscall_iincdec(uap->parm1, uap->parm2, uap->parm3, 1
821#ifdef AFS_SUN5_ENV
822 , rvp, CRED()
823#endif
824 );
825#endif /* !AFS_NBSD40_ENV */
826#if defined(AFS_NBSD40_ENV)
827 } else if (SCARG(uap, syscall) == AFSCALL_ICL30) {
828#else
829 } else if (uap->syscall == AFSCALL_ICL30) {
8
Taking true branch
830#endif
831 AFS_GLOCK()do { (void)0; _mtx_lock_flags(((&afs_global_mtx)), (0), "/home/wollman/openafs/src/afs/afs_syscall.c"
, 831); (void)0; } while (0);
832 code =
833#if defined(AFS_NBSD40_ENV)
834 Afscall_icl(SCARG(uap, parm1), SCARG(uap, parm2),
835 SCARG(uap, parm3), SCARG(uap, parm4),
836 SCARG(uap, parm5), retval);
837#else
838 Afscall_icl(uap->parm1, uap->parm2, uap->parm3, uap->parm4,
9
Function call argument is an uninitialized value
839 uap->parm5, (long *)retval);
840#endif /* !AFS_NBSD40_ENV */
841 AFS_GUNLOCK()do { (void)0; _mtx_unlock_flags(((&afs_global_mtx)), (0),
"/home/wollman/openafs/src/afs/afs_syscall.c", 841); } while
(0);
842#ifdef AFS_LINUX20_ENV
843 if (!code) {
844 /* ICL commands can return values. */
845 code = -linux_ret; /* Gets negated again at exit below */
846 }
847#else
848 if (code) {
849#if defined(KERNEL_HAVE_UERROR)
850 setuerror(code)u.u_error = (code);
851#endif
852 }
853#endif /* !AFS_LINUX20_ENV */
854 } else {
855#if defined(KERNEL_HAVE_UERROR)
856 setuerror(EINVAL)u.u_error = (22);
857#else
858 code = EINVAL22;
859#endif
860 }
861#if defined(AFS_DARWIN80_ENV)
862 if (uap->syscall != AFSCALL_CALL28)
863 put_vfs_context();
864#ifdef AFS_DARWIN100_ENV
865 } /* 32 bit procs */
866#endif
867#endif
868#ifdef AFS_LINUX20_ENV
869 code = -code;
870#endif
871 return code;
872}
873#endif /* AFS_SGI_ENV */
874#endif /* !AFS_AIX32_ENV */