rx: Remove RX_CALL_BUSY
[openafs.git] / src / afs / afs_pag_call.c
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
14 #include "afs/sysincludes.h"    /* Standard vendor system headers */
15 #include "afsincludes.h"        /* Afs-based standard headers */
16 #include "afs/afs_stats.h"
17 #include "rx/rx_globals.h"
18 #include "rx/rxstat.h"
19 #if !defined(UKERNEL) && !defined(AFS_LINUX20_ENV)
20 #include "net/if.h"
21 #ifdef AFS_SGI62_ENV
22 #include "h/hashing.h"
23 #endif
24 #if !defined(AFS_HPUX110_ENV) && !defined(AFS_DARWIN_ENV)
25 #include "netinet/in_var.h"
26 #endif
27 #endif /* !defined(UKERNEL) */
28 #include "rmtsys.h"
29 #include "pagcb.h"
30
31
32 afs_int32 afs_termState = 0;
33 afs_int32 afs_gcpags = AFS_GCPAGS;
34 int afs_shuttingdown = 0;
35 int afs_cold_shutdown = 0;
36 int afs_resourceinit_flag = 0;
37 afs_int32 afs_nfs_server_addr;
38 struct interfaceAddr afs_cb_interface;
39 struct afs_osi_WaitHandle AFS_WaitHandler;
40 static struct rx_securityClass *srv_secobj;
41 static struct rx_securityClass *clt_secobj;
42 static struct rx_service *stats_svc;
43 static struct rx_service *pagcb_svc;
44 static struct rx_connection *rmtsys_conn;
45 char *afs_sysname = 0;
46 char *afs_sysnamelist[MAXNUMSYSNAMES];
47 int afs_sysnamecount = 0;
48 int afs_sysnamegen = 0;
49 afs_int32 afs_showflags = GAGUSER | GAGCONSOLE; /* show all messages */
50
51
52 void
53 afs_Daemon(void)
54 {
55     afs_int32 now, last10MinCheck, last60MinCheck;
56
57     last10MinCheck = 0;
58     last60MinCheck = 0;
59     while (1) {
60         rx_CheckPackets();
61         now = osi_Time();
62
63         if (last10MinCheck + 600 < now) {
64             afs_GCUserData();
65         }
66
67         if (last60MinCheck + 3600 < now) {
68             afs_int32 didany;
69             afs_GCPAGs(&didany);
70         }
71
72         now = 20000 - (osi_Time() - now);
73         afs_osi_Wait(now, &AFS_WaitHandler, 0);
74
75         if (afs_termState == AFSOP_STOP_AFS) {
76 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
77             afs_termState = AFSOP_STOP_RXEVENT;
78 #else
79             afs_termState = AFSOP_STOP_COMPLETE;
80 #endif
81             afs_osi_Wakeup(&afs_termState);
82             return;
83         }
84     }
85 }
86
87
88 void
89 afspag_Init(afs_int32 nfs_server_addr)
90 {
91     struct clientcred ccred;
92     struct rmtbulk idata, odata;
93     afs_int32 code, err, addr, obuf;
94     int i;
95
96     afs_uuid_create(&afs_cb_interface.uuid);
97
98     AFS_GLOCK();
99
100     afs_InitStats();
101     rx_Init(htons(7001));
102
103     AFS_STATCNT(afs_ResourceInit);
104     AFS_RWLOCK_INIT(&afs_xuser, "afs_xuser");
105     AFS_RWLOCK_INIT(&afs_xpagcell, "afs_xpagcell");
106     AFS_RWLOCK_INIT(&afs_xpagsys, "afs_xpagsys");
107     AFS_RWLOCK_INIT(&afs_icl_lock, "afs_icl_lock");
108
109     afs_resourceinit_flag = 1;
110     afs_nfs_server_addr = nfs_server_addr;
111     for (i = 0; i < MAXNUMSYSNAMES; i++) {
112         afs_sysnamelist[i] = afs_osi_Alloc(MAXSYSNAME);
113         osi_Assert(afs_sysnamelist[i] != NULL);
114     }
115     afs_sysname = afs_sysnamelist[0];
116     strcpy(afs_sysname, SYS_NAME);
117     afs_sysnamecount = 1;
118     afs_sysnamegen++;
119
120     srv_secobj = rxnull_NewServerSecurityObject();
121     stats_svc = rx_NewService(0, RX_STATS_SERVICE_ID, "rpcstats", &srv_secobj,
122                               1, RXSTATS_ExecuteRequest);
123     pagcb_svc = rx_NewService(0, PAGCB_SERVICEID, "pagcb", &srv_secobj,
124                               1, PAGCB_ExecuteRequest);
125     rx_StartServer(0);
126
127     clt_secobj = rxnull_NewClientSecurityObject();
128     rmtsys_conn = rx_NewConnection(nfs_server_addr, htons(7009),
129                                    RMTSYS_SERVICEID, clt_secobj, 0);
130
131 #ifdef RXK_LISTENER_ENV
132     afs_start_thread(rxk_Listener,       "Rx Listener");
133 #endif
134     afs_start_thread((void *)(void *)rx_ServerProc,      "Rx Server Thread");
135     afs_start_thread(afs_rxevent_daemon, "Rx Event Daemon");
136     afs_start_thread(afs_Daemon,         "AFS PAG Daemon");
137
138     afs_icl_InitLogs();
139
140     AFS_GUNLOCK();
141
142     /* If it's reachable, tell the translator to nuke our creds.
143      * We should be more agressive about making sure this gets done,
144      * even if the translator is unreachable when we boot.
145      */
146     addr = obuf = err = 0;
147     idata.rmtbulk_len = sizeof(addr);
148     idata.rmtbulk_val = (char *)&addr;
149     odata.rmtbulk_len = sizeof(obuf);
150     odata.rmtbulk_val = (char *)&obuf;
151     memset(&ccred, 0, sizeof(ccred));
152     code = RMTSYS_Pioctl(rmtsys_conn, &ccred, NIL_PATHP, 0x4F01, 0,
153                          &idata, &odata, &err);
154 }                               /*afs_ResourceInit */
155
156
157 /* called with the GLOCK held */
158 void
159 afspag_Shutdown(void)
160 {
161     if (afs_shuttingdown)
162         return;
163     afs_shuttingdown = 1;
164     afs_termState = AFSOP_STOP_RXCALLBACK;
165     rx_WakeupServerProcs();
166     while (afs_termState == AFSOP_STOP_RXCALLBACK)
167         afs_osi_Sleep(&afs_termState);
168     /* rx_ServerProc sets AFS_STOP_AFS */
169
170     while (afs_termState == AFSOP_STOP_AFS) {
171         afs_osi_CancelWait(&AFS_WaitHandler);
172         afs_osi_Sleep(&afs_termState);
173     }
174     /* afs_Daemon sets AFS_STOP_RXEVENT */
175
176 #if defined(AFS_SUN5_ENV) || defined(RXK_LISTENER_ENV)
177     while (afs_termState == AFSOP_STOP_RXEVENT)
178         afs_osi_Sleep(&afs_termState);
179     /* afs_rxevent_daemon sets AFSOP_STOP_RXK_LISTENER */
180
181 #if defined(RXK_LISTENER_ENV)
182     afs_osi_UnmaskRxkSignals();
183     osi_StopListener();
184     while (afs_termState == AFSOP_STOP_RXK_LISTENER)
185         afs_osi_Sleep(&afs_termState);
186     /* rxk_Listener sets AFSOP_STOP_COMPLETE */
187 #endif
188 #endif
189 }
190
191 static void
192 token_conversion(char *buffer, int buf_size, int in)
193 {
194     struct ClearToken *ticket;
195     afs_int32 *lptr, n;
196
197     /* secret ticket */
198     if (buf_size < 4) return;
199     lptr = (afs_int32 *)buffer;
200     buffer += 4; buf_size -= 4;
201     if (in) {
202         *lptr = ntohl(*lptr);
203         n = *lptr;
204     } else {
205         n = *lptr;
206         *lptr = htonl(*lptr);
207     }
208     if (n < 0 || buf_size < n) return;
209     buffer += n; buf_size -= n;
210
211     /* clear token */
212     if (buf_size < 4) return;
213     lptr = (afs_int32 *)buffer;
214     buffer += 4; buf_size -= 4;
215     if (in) {
216         *lptr = ntohl(*lptr);
217         n = *lptr;
218     } else {
219         n = *lptr;
220         *lptr = htonl(*lptr);
221     }
222     if (n < 0 || buf_size < n) return;
223     if (n >= sizeof(struct ClearToken)) {
224         ticket = (struct ClearToken *)buffer;
225         if (in) {
226             ticket->AuthHandle     = ntohl(ticket->AuthHandle);
227             ticket->ViceId         = ntohl(ticket->ViceId);
228             ticket->BeginTimestamp = ntohl(ticket->BeginTimestamp);
229             ticket->EndTimestamp   = ntohl(ticket->EndTimestamp);
230         } else {
231             ticket->AuthHandle     = htonl(ticket->AuthHandle);
232             ticket->ViceId         = htonl(ticket->ViceId);
233             ticket->BeginTimestamp = htonl(ticket->BeginTimestamp);
234             ticket->EndTimestamp   = htonl(ticket->EndTimestamp);
235         }
236     }
237     buffer += n; buf_size -= n;
238
239     /* primary flag */
240     if (buf_size < 4) return;
241     lptr = (afs_int32 *)buffer;
242     if (in) {
243         *lptr = ntohl(*lptr);
244     } else {
245         *lptr = htonl((*lptr) & ~0x8000);
246     }
247     return;
248 }
249
250 static void
251 FetchVolumeStatus_conversion(char *buffer, int buf_size, int in)
252 {
253     AFSFetchVolumeStatus *status = (AFSFetchVolumeStatus *)buffer;
254
255     if (buf_size < sizeof(AFSFetchVolumeStatus))
256         return;
257     if (in) {
258         status->Vid              = ntohl(status->Vid);
259         status->ParentId         = ntohl(status->ParentId);
260         status->Type             = ntohl(status->Type);
261         status->MinQuota         = ntohl(status->MinQuota);
262         status->MaxQuota         = ntohl(status->MaxQuota);
263         status->BlocksInUse      = ntohl(status->BlocksInUse);
264         status->PartBlocksAvail  = ntohl(status->PartBlocksAvail);
265         status->PartMaxBlocks    = ntohl(status->PartMaxBlocks);
266     } else {
267         status->Vid              = htonl(status->Vid);
268         status->ParentId         = htonl(status->ParentId);
269         status->Type             = htonl(status->Type);
270         status->MinQuota         = htonl(status->MinQuota);
271         status->MaxQuota         = htonl(status->MaxQuota);
272         status->BlocksInUse      = htonl(status->BlocksInUse);
273         status->PartBlocksAvail  = htonl(status->PartBlocksAvail);
274         status->PartMaxBlocks    = htonl(status->PartMaxBlocks);
275     }
276 }
277
278 static void
279 inparam_conversion(int cmd, char *buffer, int buf_size, int in)
280 {
281     afs_int32 *lptr = (afs_int32 *)buffer;
282
283     switch (cmd & 0xffff) {
284         case (0x5600 |  3): /* VIOCSETTOK */
285             token_conversion(buffer, buf_size, in);
286             return;
287
288         case (0x5600 |  5): /* VIOCSETVOLSTAT */
289             FetchVolumeStatus_conversion(buffer, buf_size, in);
290             return;
291
292         case (0x5600 |  8): /* VIOCGETTOK */
293         case (0x5600 | 10): /* VIOCCKSERV */
294         case (0x5600 | 20): /* VIOCACCESS */
295         case (0x5600 | 24): /* VIOCSETCACHESIZE */
296         case (0x5600 | 27): /* VIOCGETCELL */
297         case (0x5600 | 32): /* VIOC_AFS_MARINER_HOST */
298         case (0x5600 | 34): /* VIOC_VENUSLOG */
299         case (0x5600 | 38): /* VIOC_AFS_SYSNAME */
300         case (0x5600 | 39): /* VIOC_EXPORTAFS */
301             /* one 32-bit integer */
302             if (buf_size >= 4) {
303                 if (in) lptr[0] = ntohl(lptr[0]);
304                 else    lptr[0] = htonl(lptr[0]);
305             }
306             return;
307
308         case (0x5600 | 36): /* VIOCSETCELLSTATUS */
309             /* two 32-bit integers */
310             if (buf_size >= 4) {
311                 if (in) lptr[0] = ntohl(lptr[0]);
312                 else    lptr[0] = htonl(lptr[0]);
313             }
314             if (buf_size >= 8) {
315                 if (in) lptr[1] = ntohl(lptr[1]);
316                 else    lptr[1] = htonl(lptr[1]);
317             }
318             return;
319     }
320 }
321
322 static void
323 outparam_conversion(int cmd, char *buffer, int buf_size, int in)
324 {
325     afs_int32 *lptr = (afs_int32 *)buffer;
326     int i;
327
328     switch (cmd & 0xffff) {
329         case (0x5600 |  4): /* VIOCGETVOLSTAT */
330         case (0x5600 |  5): /* VIOCSETVOLSTAT */
331             FetchVolumeStatus_conversion(buffer, buf_size, in);
332             return;
333
334         case (0x5600 |  8): /* VIOCGETTOK */
335             token_conversion(buffer, buf_size, in);
336             return;
337
338         case (0x5600 | 12): /* VIOCCKCONN */
339         case (0x5600 | 32): /* VIOC_AFS_MARINER_HOST */
340         case (0x5600 | 34): /* VIOC_VENUSLOG */
341         case (0x5600 | 35): /* VIOC_GETCELLSTATUS */
342         case (0x5600 | 38): /* VIOC_AFS_SYSNAME */
343         case (0x5600 | 39): /* VIOC_EXPORTAFS */
344             /* one 32-bit integer */
345             if (buf_size >= 4) {
346                 if (in) lptr[0] = ntohl(lptr[0]);
347                 else    lptr[0] = htonl(lptr[0]);
348             }
349             return;
350
351         case (0x5600 | 40): /* VIOCGETCACHEPARMS */
352             /* sixteen 32-bit integers */
353             for (i = 0; i < 16 && buf_size >= 4; i++) {
354                 if (in) lptr[i] = ntohl(lptr[i]);
355                 else    lptr[i] = htonl(lptr[i]);
356                 buf_size -= 4;
357             }
358             return;
359     }
360 }
361
362
363 /* called with the GLOCK held */
364 int
365 #ifdef  AFS_SUN5_ENV
366 afs_syscall_pioctl(path, com, cmarg, follow, rvp, credp)
367      rval_t *rvp;
368      afs_ucred_t *credp;
369 #else
370 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
371 afs_syscall_pioctl(path, com, cmarg, follow, credp)
372      afs_ucred_t *credp;
373 #else
374 afs_syscall_pioctl(path, com, cmarg, follow)
375 #endif
376 #endif
377      char *path;
378      unsigned int com;
379      caddr_t cmarg;
380      int follow;
381 {
382 #ifdef  AFS_AIX41_ENV
383     struct ucred *credp = crref();      /* don't free until done! */
384 #endif
385 #ifdef AFS_LINUX22_ENV
386     cred_t *credp = crref();    /* don't free until done! */
387 #endif
388     struct afs_ioctl data;
389     struct clientcred ccred;
390     struct rmtbulk idata, odata;
391     short in_size, out_size;
392     afs_int32 code = 0, pag, err;
393     gid_t g0, g1;
394     char *abspath, *pathbuf = 0;
395
396     AFS_STATCNT(afs_syscall_pioctl);
397     if (follow)
398         follow = 1;             /* compat. with old venus */
399     code = copyin_afs_ioctl(cmarg, &data);
400     if (code) goto out;
401
402     if ((com & 0xff) == 90) {
403         /* PSetClientContext, in any space */
404         code = EINVAL;
405         goto out;
406     }
407
408     /* Special handling for a few pioctls */
409     switch (com & 0xffff) {
410         case (0x5600 |  3): /* VIOCSETTOK */
411             code = afspag_PSetTokens(data.in, data.in_size, &credp);
412             if (code) goto out;
413             break;
414
415         case (0x5600 |  9): /* VIOCUNLOG */
416         case (0x5600 | 21): /* VIOCUNPAG */
417             code = afspag_PUnlog(data.in, data.in_size, &credp);
418             if (code) goto out;
419             break;
420
421         case (0x5600 | 38): /* VIOC_AFS_SYSNAME */
422             code = afspag_PSetSysName(data.in, data.in_size, &credp);
423             if (code) goto out;
424             break;
425     }
426
427     /* Set up credentials */
428     memset(&ccred, 0, sizeof(ccred));
429     pag = PagInCred(credp);
430     ccred.uid = afs_cr_uid(credp);
431     if (pag != NOPAG) {
432          afs_get_groups_from_pag(pag, &g0, &g1);
433          ccred.group0 = g0;
434          ccred.group1 = g1;
435     }
436
437     /*
438      * Copy the path and convert to absolute, if one was given.
439      * NB: We can only use osI_AllocLargeSpace here as long as
440      * RMTSYS_MAXPATHLEN is less than AFS_LRALLOCSIZ.
441      */
442     if (path) {
443         pathbuf = osi_AllocLargeSpace(RMTSYS_MAXPATHLEN);
444         if (!pathbuf) {
445             code = ENOMEM;
446             goto out;
447         }
448         code = osi_abspath(path, pathbuf, RMTSYS_MAXPATHLEN, 0, &abspath);
449         if (code)
450             goto out_path;
451     } else {
452         abspath = NIL_PATHP;
453     }
454
455     /* Allocate, copy, and convert incoming data */
456     idata.rmtbulk_len = in_size = data.in_size;
457     if (in_size  < 0 || in_size  > MAXBUFFERLEN) {
458         code = EINVAL;
459         goto out_path;
460     }
461     if (in_size > AFS_LRALLOCSIZ)
462          idata.rmtbulk_val = osi_Alloc(in_size);
463     else
464          idata.rmtbulk_val = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
465     if (!idata.rmtbulk_val) {
466         code = ENOMEM;
467         goto out_path;
468     }
469     if (in_size) {
470         AFS_COPYIN(data.in, idata.rmtbulk_val, in_size, code);
471         if (code)
472             goto out_idata;
473         inparam_conversion(com, idata.rmtbulk_val, in_size, 0);
474     }
475
476     /* Allocate space for outgoing data */
477     odata.rmtbulk_len = out_size = data.out_size;
478     if (out_size < 0 || out_size > MAXBUFFERLEN) {
479         code = EINVAL;
480         goto out_idata;
481     }
482     if (out_size > AFS_LRALLOCSIZ)
483          odata.rmtbulk_val = osi_Alloc(out_size);
484     else
485          odata.rmtbulk_val = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
486     if (!odata.rmtbulk_val) {
487         code = ENOMEM;
488         goto out_idata;
489     }
490
491     AFS_GUNLOCK();
492     code = RMTSYS_Pioctl(rmtsys_conn, &ccred, abspath, com, follow,
493                          &idata, &odata, &err);
494     AFS_GLOCK();
495     if (code)
496         goto out_odata;
497
498     /* Convert and copy out the result */
499     if (odata.rmtbulk_len > out_size) {
500         code = E2BIG;
501         goto out_odata;
502     }
503     if (odata.rmtbulk_len) {
504         outparam_conversion(com, odata.rmtbulk_val, odata.rmtbulk_len, 1);
505         AFS_COPYOUT(odata.rmtbulk_val, data.out, odata.rmtbulk_len, code);
506     }
507     if (!code)
508         code = err;
509
510 out_odata:
511     if (out_size > AFS_LRALLOCSIZ)
512         osi_Free(odata.rmtbulk_val, out_size);
513     else
514         osi_FreeLargeSpace(odata.rmtbulk_val);
515
516 out_idata:
517     if (in_size > AFS_LRALLOCSIZ)
518         osi_Free(idata.rmtbulk_val, in_size);
519     else
520         osi_FreeLargeSpace(idata.rmtbulk_val);
521
522 out_path:
523     if (path)
524         osi_FreeLargeSpace(pathbuf);
525
526 out:
527 #if defined(AFS_LINUX22_ENV) || defined(AFS_AIX41_ENV)
528     crfree(credp);
529 #endif
530 #if defined(KERNEL_HAVE_UERROR)
531     if (!getuerror())
532         setuerror(code);
533     return (getuerror());
534 #else
535     return (code);
536 #endif
537 }
538
539
540 int
541 afs_syscall_call(parm, parm2, parm3, parm4, parm5, parm6)
542      long parm, parm2, parm3, parm4, parm5, parm6;
543 {
544     /* superusers may shut us down, as with afsd --shutdown */
545 #ifdef AFS_SUN5_ENV
546     if (parm == AFSOP_SHUTDOWN && afs_suser(CRED()))
547 #else
548     if (parm == AFSOP_SHUTDOWN && afs_suser(NULL))
549 #endif
550     {
551         AFS_GLOCK();
552         afspag_Shutdown();
553         AFS_GUNLOCK();
554         return 0;
555     }
556
557     /* otherwise, we don't support afs_syscall_call, period */
558 #if defined(KERNEL_HAVE_UERROR)
559     setuerror(EPERM);
560 #endif
561     return EPERM;
562 }