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