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 }