/* Copyright (C) 1995 Transarc Corporation - All rights reserved */ /* * (C) COPYRIGHT IBM CORPORATION 1987, 1988 * LICENSED MATERIALS - PROPERTY OF IBM */ #include #include #include #include #include #include #include #include #ifdef AFS_NT40_ENV #include #else #include #endif #include #include "vlserver.h" #include "afs/audit.h" #ifndef AFS_NT40_ENV #include #endif extern int smallMem; extern extent_mod; extern struct afsconf_dir *vldb_confdir; extern struct ubik_dbase *VL_dbase; struct vlheader cheader; /* kept in network byte order */ extern afs_uint32 HostAddress[]; /* host addresses kept in host byte order */ int maxnservers; struct extentaddr *ex_addr[VL_MAX_ADDREXTBLKS] = { 0, 0, 0, 0}; static char rxinfo_str[128]; /* Need rxinfo string to be non-local */ #define ABORT(c) { errorcode = (c); goto abort; } #undef END #define END(c) { errorcode = (c); goto end; } #define VLDBALLOCLIMIT 10000 #define VLDBALLOCINCR 2048 static int put_attributeentry(); static int put_nattributeentry(); static int RemoveEntry(); static ReleaseEntry(); static int check_vldbentry(); static int check_nvldbentry(); static int vldbentry_to_vlentry(); static int nvldbentry_to_vlentry(); static get_vldbupdateentry(); static int repsite_exists(); static repsite_compress(); static vlentry_to_vldbentry(); static vlentry_to_nvldbentry(); static vlentry_to_uvldbentry(); static int InvalidVolname(); static int InvalidVoltype(); static int InvalidOperation(); static int InvalidReleasetype(); static int IpAddrToRelAddr(); static int ChangeIPAddr(); char *rxinfo(rxcall) struct rx_call *rxcall; { int code; register struct rx_connection *tconn; char tname[64]; char tinst[64]; char tcell[64]; afs_uint32 exp; struct in_addr hostAddr; tconn = rx_ConnectionOf(rxcall); hostAddr.s_addr = rx_HostOf(rx_PeerOf(tconn)); code = rxkad_GetServerInfo(rxcall->conn, (afs_int32 *) 0, &exp, tname, tinst, tcell, (afs_int32 *) 0); if (!code) sprintf(rxinfo_str,"%s %s", inet_ntoa(hostAddr), tname); else sprintf(rxinfo_str,"%s noauth",inet_ntoa(hostAddr)); return(rxinfo_str); } /* This is called to initialize the database, set the appropriate locks and make sure that the vldb header is valid */ int Init_VLdbase (trans, locktype, this_op) struct ubik_trans **trans; int locktype; /* indicate read or write transaction */ int this_op; { int errorcode=0, pass, wl; for (pass=1; pass<=3; pass++) { if (pass == 2) { /* take write lock to rebuild the db */ errorcode = ubik_BeginTrans (VL_dbase, UBIK_WRITETRANS, trans); wl = 1; } else if (locktype == LOCKREAD) { errorcode = ubik_BeginTransReadAny (VL_dbase, UBIK_READTRANS, trans); wl = 0; } else { errorcode = ubik_BeginTrans (VL_dbase, UBIK_WRITETRANS, trans); wl = 1; } if (errorcode) return errorcode; errorcode = ubik_SetLock (*trans, 1, 1, locktype); if (errorcode) { COUNT_ABO; ubik_AbortTrans (*trans); return errorcode; } /* check that dbase is initialized and setup cheader */ /* 2nd pass we try to rebuild the header */ errorcode = CheckInit(*trans, ((pass==2)?1:0)); if (!errorcode && wl && extent_mod) errorcode = readExtents(*trans); /* Fix the mh extent blocks */ if (errorcode) { COUNT_ABO; ubik_AbortTrans(*trans); /* Only rebuld if the database is empty */ /* Exit if can't rebuild */ if ((pass == 1) && (errorcode != VL_EMPTY)) return errorcode; if (pass == 2) return errorcode; } else { /* No errorcode */ if (pass == 2) { ubik_EndTrans(*trans); /* Rebuilt db. End trans, then retake original lock */ } else { break; /* didn't rebuild and successful - exit */ } } } return errorcode; } /* Create a new vldb entry; both new volume id and name must be unique (non-existant in vldb). */ VL_CreateEntry(rxcall, newentry) struct rx_call *rxcall; struct vldbentry *newentry; { struct ubik_trans *trans; afs_int32 errorcode, blockindex; struct nvlentry tentry; COUNT_REQ (VLCREATEENTRY); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) { errorcode = VL_PERM; goto end; } /* Do some validity tests on new entry */ if ( (errorcode = check_vldbentry(newentry)) || (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op))) goto end; VLog(1, ("OCreate Volume %d %s\n", newentry->volumeId[RWVOL], rxinfo(rxcall))); /* XXX shouldn't we check to see if the r/o volume is duplicated? */ if (newentry->volumeId[RWVOL] && FindByID(trans, newentry->volumeId[RWVOL], RWVOL, &tentry, &errorcode)) { /* entry already exists, we fail */ errorcode = VL_IDEXIST; goto abort; } else if (errorcode) { goto abort; } /* Is this following check (by volume name) necessary?? */ /* If entry already exists, we fail */ if (FindByName(trans, newentry->name, &tentry, &errorcode)) { errorcode = VL_NAMEEXIST; goto abort; } else if (errorcode) { goto abort; } blockindex = AllocBlock(trans, &tentry); if (blockindex == 0) { errorcode = VL_CREATEFAIL; goto abort; } bzero(&tentry, sizeof(struct nvlentry)); /* Convert to its internal representation; both in host byte order */ if (errorcode = vldbentry_to_vlentry(trans, newentry, &tentry)) { FreeBlock(trans, blockindex); goto abort; } /* Actually insert the entry in vldb */ errorcode = ThreadVLentry(trans, blockindex, &tentry); if (errorcode) { FreeBlock(trans, blockindex); goto abort; } else { errorcode = ubik_EndTrans(trans); goto end; } abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLCreateEntryEvent, errorcode, AUD_STR, (newentry ? newentry->name : (char *)0), AUD_END); return errorcode; } VL_CreateEntryN(rxcall, newentry) struct rx_call *rxcall; struct nvldbentry *newentry; { struct ubik_trans *trans; afs_int32 errorcode, blockindex; struct nvlentry tentry; COUNT_REQ (VLCREATEENTRYN); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) { errorcode = VL_PERM; goto end; } /* Do some validity tests on new entry */ if ( (errorcode = check_nvldbentry(newentry)) || (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op))) goto end; VLog(1, ("Create Volume %d %s\n", newentry->volumeId[RWVOL], rxinfo(rxcall))); /* XXX shouldn't we check to see if the r/o volume is duplicated? */ if (newentry->volumeId[RWVOL] && FindByID(trans, newentry->volumeId[RWVOL], RWVOL, &tentry, &errorcode)) { /* entry already exists, we fail */ errorcode = VL_IDEXIST; goto abort; } else if (errorcode) { goto abort; } /* Is this following check (by volume name) necessary?? */ /* If entry already exists, we fail */ if (FindByName(trans, newentry->name, &tentry, &errorcode)) { errorcode = VL_NAMEEXIST; goto abort; } else if (errorcode) { goto abort; } blockindex = AllocBlock(trans, &tentry); if (blockindex == 0) { errorcode = VL_CREATEFAIL; goto abort; } bzero(&tentry, sizeof(struct nvlentry)); /* Convert to its internal representation; both in host byte order */ if (errorcode = nvldbentry_to_vlentry(trans, newentry, &tentry)) { FreeBlock(trans, blockindex); goto abort; } /* Actually insert the entry in vldb */ errorcode = ThreadVLentry(trans, blockindex, &tentry); if (errorcode) { FreeBlock(trans, blockindex); goto abort; } else { errorcode = ubik_EndTrans(trans); goto end; } abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLCreateEntryEvent, errorcode, AUD_STR, (newentry ? newentry->name : (char *)0), AUD_END); return errorcode; } VL_ChangeAddr(rxcall, ip1, ip2) struct rx_call *rxcall; afs_int32 ip1, ip2; { struct ubik_trans *trans; afs_int32 errorcode, blockindex; struct nvlentry tentry; COUNT_REQ (VLCHANGEADDR); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) { errorcode = VL_PERM; goto end; } if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; VLog(1, ("Change Addr %d -> %d %s\n", ip1, ip2, rxinfo(rxcall))); if (errorcode = ChangeIPAddr(ip1, ip2, trans)) goto abort; else { errorcode = ubik_EndTrans(trans); goto end; } abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLChangeAddrEvent, errorcode, AUD_LONG, ip1, AUD_LONG, ip2, AUD_END); return errorcode; } /* Delete a vldb entry given the volume id. */ VL_DeleteEntry(rxcall, volid, voltype) struct rx_call *rxcall; afs_int32 volid; afs_int32 voltype; { struct ubik_trans *trans; afs_int32 blockindex, errorcode; struct nvlentry tentry; COUNT_REQ (VLDELETEENTRY); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END(VL_PERM); if ((voltype != -1 ) && (InvalidVoltype(voltype))) END( VL_BADVOLTYPE ); if (errorcode = Init_VLdbase (&trans, LOCKWRITE, this_op)) goto end; VLog(1, ("Delete Volume %d %s\n", volid, rxinfo(rxcall))); blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode); if (blockindex == 0) { /* volid not found */ if (!errorcode) errorcode = VL_NOENT; goto abort; } if (tentry.flags & VLDELETED) { /* Already deleted; return */ ABORT( VL_ENTDELETED ); } if (errorcode = RemoveEntry(trans, blockindex, &tentry)) { goto abort; } errorcode = (ubik_EndTrans(trans)); goto end; abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLDeleteEntryEvent, errorcode, AUD_LONG, volid, AUD_END); return errorcode; } /* Get a vldb entry given its volume id; make sure it's not a deleted entry. */ GetEntryByID (rxcall, volid, voltype, aentry, new, this_op) struct rx_call *rxcall; afs_int32 volid; afs_int32 voltype, new, this_op; char *aentry; /* entry data copied here */ { struct ubik_trans *trans; afs_int32 blockindex, errorcode; struct nvlentry tentry; if ((voltype != -1 ) && (InvalidVoltype(voltype))) return VL_BADVOLTYPE; if (errorcode = Init_VLdbase (&trans, LOCKREAD, this_op)) return errorcode; VLog(5, ("GetVolumeByID %d (%d) %s\n", volid, new, rxinfo(rxcall))); blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode); if (blockindex == 0) { /* entry not found */ if (!errorcode) errorcode = VL_NOENT; COUNT_ABO; ubik_AbortTrans (trans); return errorcode; } if (tentry.flags & VLDELETED) { /* Entry is deleted! */ COUNT_ABO; ubik_AbortTrans (trans); return VL_ENTDELETED; } /* Convert from the internal to external form */ if (new == 1) vlentry_to_nvldbentry(&tentry, (struct nvldbentry *)aentry); else if (new == 2) vlentry_to_uvldbentry(&tentry, (struct uvldbentry *)aentry); else vlentry_to_vldbentry(&tentry, (struct vldbentry *)aentry); return(ubik_EndTrans(trans)); } VL_GetEntryByID (rxcall, volid, voltype, aentry) struct rx_call *rxcall; afs_int32 volid, voltype; vldbentry *aentry; /* entry data copied here */ { COUNT_REQ (VLGETENTRYBYID); return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 0, this_op)); } VL_GetEntryByIDN (rxcall, volid, voltype, aentry) struct rx_call *rxcall; afs_int32 volid, voltype; nvldbentry *aentry; /* entry data copied here */ { COUNT_REQ (VLGETENTRYBYIDN); return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 1, this_op)); } VL_GetEntryByIDU (rxcall, volid, voltype, aentry) struct rx_call *rxcall; afs_int32 volid, voltype; uvldbentry *aentry; /* entry data copied here */ { COUNT_REQ (VLGETENTRYBYIDU); return (GetEntryByID(rxcall, volid, voltype, (char *)aentry, 2, this_op)); } /* returns true if the id is a decimal integer, in which case we interpret it as an id. make the cache manager much simpler */ static int NameIsId(aname) register char *aname; { register int tc; while (tc = *aname++) { if (tc > '9' || tc < '0') return 0; } return 1; } /* Get a vldb entry given the volume's name; of course, very similar to VLGetEntryByID() above. */ GetEntryByName (rxcall, volname, aentry, new, this_op) struct rx_call *rxcall; char *volname; char *aentry; /* entry data copied here */ int new, this_op; { struct ubik_trans *trans; afs_int32 blockindex, errorcode; struct nvlentry tentry; if (NameIsId(volname)) { return GetEntryByID(rxcall, atoi(volname), -1, aentry, new, this_op); } if (InvalidVolname(volname)) return VL_BADNAME; if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; VLog(5, ("GetVolumeByName %s (%d) %s\n", volname, new, rxinfo(rxcall))); blockindex = FindByName(trans, volname, &tentry, &errorcode); if (blockindex == 0) { /* entry not found */ if (!errorcode) errorcode = VL_NOENT; COUNT_ABO; ubik_AbortTrans(trans); return errorcode; } if (tentry.flags & VLDELETED) { /* Entry is deleted */ COUNT_ABO; ubik_AbortTrans(trans); return VL_ENTDELETED; } /* Convert to external entry representation */ if (new == 1) vlentry_to_nvldbentry(&tentry, (struct nvldbentry *)aentry); else if (new == 2) vlentry_to_uvldbentry(&tentry, (struct uvldbentry *)aentry); else vlentry_to_vldbentry(&tentry, (struct vldbentry *)aentry); return(ubik_EndTrans(trans)); } VL_GetEntryByNameO (rxcall, volname, aentry) struct rx_call *rxcall; char *volname; struct vldbentry *aentry; /* entry data copied here */ { COUNT_REQ (VLGETENTRYBYNAME); return (GetEntryByName(rxcall, volname, (char *)aentry, 0, this_op)); } VL_GetEntryByNameN (rxcall, volname, aentry) struct rx_call *rxcall; char *volname; struct nvldbentry *aentry; /* entry data copied here */ { COUNT_REQ (VLGETENTRYBYNAMEN); return (GetEntryByName(rxcall, volname, (char *)aentry, 1, this_op)); } VL_GetEntryByNameU (rxcall, volname, aentry) struct rx_call *rxcall; char *volname; struct uvldbentry *aentry; /* entry data copied here */ { COUNT_REQ (VLGETENTRYBYNAMEU); return (GetEntryByName(rxcall, volname, (char *)aentry, 2, this_op)); } /* Get the current value of the maximum volume id and bump the volume id counter by Maxvolidbump. */ VL_GetNewVolumeId (rxcall, Maxvolidbump, newvolumeid) struct rx_call *rxcall; afs_int32 Maxvolidbump; afs_int32 *newvolumeid; { register afs_int32 errorcode, maxvolumeid; struct ubik_trans *trans; COUNT_REQ (VLGETNEWVOLUMEID); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END( VL_PERM ); if (Maxvolidbump < 0 || Maxvolidbump > MAXBUMPCOUNT) END ( VL_BADVOLIDBUMP ); if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; *newvolumeid = maxvolumeid = ntohl(cheader.vital_header.MaxVolumeId); maxvolumeid += Maxvolidbump; VLog(1, ("GetNewVolid newmax=%d %s\n", maxvolumeid, rxinfo(rxcall))); cheader.vital_header.MaxVolumeId = htonl(maxvolumeid); if (write_vital_vlheader(trans)) { ABORT( VL_IO ); } errorcode = (ubik_EndTrans(trans)); goto end; abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLGetNewVolumeIdEvent, errorcode, AUD_END); return errorcode; } /* Simple replace the contents of the vldb entry, volid, with * newentry. No individual checking/updating per field (alike * VLUpdateEntry) is done. */ VL_ReplaceEntry (rxcall, volid, voltype, newentry, releasetype) struct rx_call *rxcall; afs_int32 volid; afs_int32 voltype; struct vldbentry *newentry; afs_int32 releasetype; { struct ubik_trans *trans; afs_int32 blockindex, errorcode, typeindex; int hashnewname; int hashVol[MAXTYPES]; struct nvlentry tentry; COUNT_REQ (VLREPLACEENTRY); for(typeindex = 0; typeindex < MAXTYPES; typeindex++) hashVol[typeindex] = 0; hashnewname = 0; if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END ( VL_PERM ); if (errorcode = check_vldbentry(newentry)) goto end; if (voltype != -1 && InvalidVoltype(voltype)) END ( VL_BADVOLTYPE ); if (releasetype && InvalidReleasetype(releasetype)) END( VL_BADRELLOCKTYPE ); if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; VLog(1, ("OReplace Volume %d %s\n", volid, rxinfo(rxcall))); /* find vlentry we're changing */ blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode); if (blockindex == 0) { /* entry not found */ if (!errorcode) errorcode = VL_NOENT; goto abort; } /* check that we're not trying to change the RW vol ID */ if (newentry->volumeId[RWVOL] != tentry.volumeId[RWVOL]) { ABORT( VL_BADENTRY ); } /* unhash volid entries if they're disappearing or changing. * Remember if we need to hash in the new value (we don't have to * rehash if volid stays same */ for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) { if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) { if (tentry.volumeId[typeindex]) if (errorcode = UnhashVolid(trans, typeindex, blockindex, &tentry)) { goto abort; } /* we must rehash new id if the id is different and the ID is nonzero */ hashVol[typeindex] = 1; /* must rehash this guy if he exists */ } } /* Rehash volname if it changes */ if (strcmp(newentry->name, tentry.name)) { /* Name changes; redo hashing */ if (errorcode = UnhashVolname(trans, blockindex, &tentry)) { goto abort; } hashnewname = 1; } /* after this, tentry is new entry, not old one. vldbentry_to_vlentry doesn't touch hash chains */ if (errorcode = vldbentry_to_vlentry(trans, newentry, &tentry)) { goto abort; } for(typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) { if (hashVol[typeindex] && tentry.volumeId[typeindex]) { if (errorcode = HashVolid(trans, typeindex, blockindex, &tentry)) { goto abort; } } } if (hashnewname) HashVolname(trans, blockindex, &tentry); if (releasetype) ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */ if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) { ABORT( VL_IO ); } END (ubik_EndTrans(trans)); abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLReplaceVLEntryEvent, errorcode, AUD_LONG, volid, AUD_END); return errorcode; } VL_ReplaceEntryN (rxcall, volid, voltype, newentry, releasetype) struct rx_call *rxcall; afs_int32 volid; afs_int32 voltype; struct nvldbentry *newentry; afs_int32 releasetype; { struct ubik_trans *trans; afs_int32 blockindex, errorcode, typeindex; int hashnewname; int hashVol[MAXTYPES]; struct nvlentry tentry; COUNT_REQ (VLREPLACEENTRYN); for(typeindex = 0; typeindex < MAXTYPES; typeindex++) hashVol[typeindex] = 0; hashnewname = 0; if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END ( VL_PERM ); if (errorcode = check_nvldbentry(newentry)) goto end; if (voltype != -1 && InvalidVoltype(voltype)) END ( VL_BADVOLTYPE ); if (releasetype && InvalidReleasetype(releasetype)) END( VL_BADRELLOCKTYPE ); if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; VLog(1, ("Replace Volume %d %s\n", volid, rxinfo(rxcall))); /* find vlentry we're changing */ blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode); if (blockindex == 0) { /* entry not found */ if (!errorcode) errorcode = VL_NOENT; goto abort; } /* check that we're not trying to change the RW vol ID */ if (newentry->volumeId[RWVOL] != tentry.volumeId[RWVOL]) { ABORT( VL_BADENTRY ); } /* unhash volid entries if they're disappearing or changing. * Remember if we need to hash in the new value (we don't have to * rehash if volid stays same */ for (typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) { if (tentry.volumeId[typeindex] != newentry->volumeId[typeindex]) { if (tentry.volumeId[typeindex]) if (errorcode = UnhashVolid(trans, typeindex, blockindex, &tentry)) { goto abort; } /* we must rehash new id if the id is different and the ID is nonzero */ hashVol[typeindex] = 1; /* must rehash this guy if he exists */ } } /* Rehash volname if it changes */ if (strcmp(newentry->name, tentry.name)) { /* Name changes; redo hashing */ if (errorcode = UnhashVolname(trans, blockindex, &tentry)) { goto abort; } hashnewname = 1; } /* after this, tentry is new entry, not old one. vldbentry_to_vlentry doesn't touch hash chains */ if (errorcode = nvldbentry_to_vlentry(trans, newentry, &tentry)) { goto abort; } for(typeindex = ROVOL; typeindex <= BACKVOL; typeindex++) { if (hashVol[typeindex] && tentry.volumeId[typeindex]) { if (errorcode = HashVolid(trans, typeindex, blockindex, &tentry)) { goto abort; } } } if (hashnewname) HashVolname(trans, blockindex, &tentry); if (releasetype) ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */ if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) { ABORT( VL_IO ); } END (ubik_EndTrans(trans)); abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLReplaceVLEntryEvent, errorcode, AUD_LONG, volid, AUD_END); return errorcode; } /* Update a vldb entry (accessed thru its volume id). Almost all of the entry's fields can be modified in a single call by setting the appropriate bits in the Mask field in VldbUpdateentry. */ /* this routine may never have been tested; use replace entry instead unless you're brave */ VL_UpdateEntry (rxcall, volid, voltype, updateentry, releasetype) struct rx_call *rxcall; afs_int32 volid; afs_int32 voltype; afs_int32 releasetype; struct VldbUpdateEntry *updateentry; /* Update entry copied here */ { struct ubik_trans *trans; afs_int32 blockindex, errorcode; struct nvlentry tentry; COUNT_REQ (VLUPDATEENTRY); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END( VL_PERM ); if ((voltype != -1 ) && (InvalidVoltype(voltype))) END( VL_BADVOLTYPE ); if (releasetype && InvalidReleasetype(releasetype)) END( VL_BADRELLOCKTYPE ); if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; VLog(1, ("Update Volume %d %s\n", volid, rxinfo(rxcall))); blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode); if (blockindex == 0) { /* entry not found */ if (!errorcode) errorcode = VL_NOENT; goto abort; } /* Do the actual updating of the entry, tentry. */ if (errorcode = get_vldbupdateentry(trans, blockindex, updateentry, &tentry)) { goto abort; } if (releasetype) ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */ if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) { ABORT( VL_IO ); } END(ubik_EndTrans(trans)); abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLUpdateEntryEvent, errorcode, AUD_LONG, volid, AUD_END); return errorcode; } VL_UpdateEntryByName (rxcall, volname, updateentry, releasetype) struct rx_call *rxcall; char *volname; afs_int32 releasetype; struct VldbUpdateEntry *updateentry; /* Update entry copied here */ { struct ubik_trans *trans; afs_int32 blockindex, errorcode; struct nvlentry tentry; COUNT_REQ (VLUPDATEENTRYBYNAME); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END( VL_PERM ); if (releasetype && InvalidReleasetype(releasetype)) END( VL_BADRELLOCKTYPE ); if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; blockindex = FindByName(trans, volname, &tentry, &errorcode); if (blockindex == 0) { /* entry not found */ if (!errorcode) errorcode = VL_NOENT; goto abort; } /* Do the actual updating of the entry, tentry. */ if (errorcode = get_vldbupdateentry(trans, blockindex, updateentry, &tentry)) { goto abort; } if (releasetype) ReleaseEntry(&tentry, releasetype); /* Unlock entry if necessary */ if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) { ABORT( VL_IO ); } END(ubik_EndTrans(trans)); abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLUpdateEntryEvent, errorcode, AUD_LONG, -1, AUD_END); return errorcode; } /* Set a lock to the vldb entry for volid (of type voltype if not -1). */ VL_SetLock (rxcall, volid, voltype, voloper) struct rx_call *rxcall; afs_int32 volid; afs_int32 voltype; afs_int32 voloper; { afs_int32 timestamp, blockindex, errorcode; struct ubik_trans *trans; struct nvlentry tentry; COUNT_REQ(VLSETLOCK); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END( VL_PERM ); if ((voltype != -1 ) && (InvalidVoltype(voltype))) END( VL_BADVOLTYPE ); if (InvalidOperation(voloper)) END( VL_BADVOLOPER ); if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; VLog(1, ("SetLock Volume %d %s\n", volid, rxinfo(rxcall))); blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode); if (blockindex == NULLO) { if (!errorcode) errorcode = VL_NOENT; goto abort; } if (tentry.flags & VLDELETED) { ABORT( VL_ENTDELETED ); } timestamp = FT_ApproxTime(); /* Check if entry is already locked; note that we unlock any entry * locked more than MAXLOCKTIME seconds */ if ((tentry.LockTimestamp) && ((timestamp - tentry.LockTimestamp) < MAXLOCKTIME)) { ABORT( VL_ENTRYLOCKED ); } /* Consider it an unlocked entry: set current timestamp, caller * and active vol operation */ tentry.LockTimestamp = timestamp; tentry.LockAfsId = 0; /* Not implemented yet */ if (tentry.flags & VLOP_RELEASE) { ABORT( VL_RERELEASE ); } tentry.flags &= ~VLOP_ALLOPERS; /* Clear any possible older operation bit */ tentry.flags |= voloper; if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) { ABORT( VL_IO ); } END(ubik_EndTrans(trans)); abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLSetLockEvent, errorcode, AUD_LONG, volid, AUD_END); return errorcode; } /* Release an already locked vldb entry. Releasetype determines what * fields (afsid and/or volume operation) will be cleared along with * the lock time stamp. */ VL_ReleaseLock (rxcall, volid, voltype, releasetype) struct rx_call *rxcall; afs_int32 volid; afs_int32 voltype; afs_int32 releasetype; { afs_int32 blockindex, errorcode; struct ubik_trans *trans; struct nvlentry tentry; COUNT_REQ(VLRELEASELOCK); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) END( VL_PERM ); if ((voltype != -1 ) && (InvalidVoltype(voltype))) END( VL_BADVOLTYPE ); if (releasetype && InvalidReleasetype(releasetype)) END( VL_BADRELLOCKTYPE ); if (errorcode = Init_VLdbase(&trans, LOCKWRITE, this_op)) goto end; VLog(1, ("ReleaseLock Volume %d %s\n", volid, rxinfo(rxcall))); blockindex = FindByID(trans, volid, voltype, &tentry, &errorcode); if (blockindex == NULLO) { if (!errorcode) errorcode = VL_NOENT; goto abort; } if (tentry.flags & VLDELETED) { ABORT( VL_ENTDELETED ); } if (releasetype) ReleaseEntry(&tentry, releasetype); /* Unlock the appropriate fields */ if (vlentrywrite(trans, blockindex, &tentry, sizeof(tentry))) { ABORT( VL_IO ); } END(ubik_EndTrans(trans)); abort: COUNT_ABO; ubik_AbortTrans(trans); end: osi_auditU (rxcall, VLReleaseLockEvent, errorcode, AUD_LONG, volid, AUD_END); return errorcode; } /* ListEntry returns a single vldb entry, aentry, with offset previous_index; the remaining parameters (i.e. next_index) are used so that sequential calls to this routine will get the next (all) vldb entries. */ VL_ListEntry (rxcall, previous_index, count, next_index, aentry) struct rx_call *rxcall; afs_int32 previous_index; afs_int32 *count; afs_int32 *next_index; struct vldbentry *aentry; { int errorcode; struct ubik_trans *trans; struct nvlentry tentry; COUNT_REQ(VLLISTENTRY); if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; VLog(25, ("OListEntry index=%d %s\n", previous_index, rxinfo(rxcall))); *next_index = NextEntry(trans, previous_index, &tentry, count); if (*next_index) vlentry_to_vldbentry(&tentry, aentry); return(ubik_EndTrans(trans)); } /* ListEntry returns a single vldb entry, aentry, with offset previous_index; the remaining parameters (i.e. next_index) are used so that sequential calls to this routine will get the next (all) vldb entries. */ VL_ListEntryN (rxcall, previous_index, count, next_index, aentry) struct rx_call *rxcall; afs_int32 previous_index; afs_int32 *count; afs_int32 *next_index; struct nvldbentry *aentry; { int errorcode; struct ubik_trans *trans; struct nvlentry tentry; COUNT_REQ(VLLISTENTRYN); if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; VLog(25, ("ListEntry index=%d %s\n", previous_index, rxinfo(rxcall))); *next_index = NextEntry(trans, previous_index, &tentry, count); if (*next_index) vlentry_to_nvldbentry(&tentry, aentry); return(ubik_EndTrans(trans)); } /* Retrieves in vldbentries all vldb entries that match the specified attributes (by server number, partition, volume type, and flag); if volume id is specified then the associated list for that entry is returned. CAUTION: This could be a very expensive call since in most cases sequential search of all vldb entries is performed. */ VL_ListAttributes(rxcall, attributes, nentries, vldbentries) struct rx_call *rxcall; struct VldbListByAttributes *attributes; afs_int32 *nentries; bulkentries *vldbentries; { int errorcode, allocCount = 0; struct ubik_trans *trans; struct nvlentry tentry; struct vldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0; int pollcount = 0; COUNT_REQ (VLLISTATTRIBUTES); vldbentries->bulkentries_val = 0; vldbentries->bulkentries_len = *nentries = 0; if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; allocCount = VLDBALLOCCOUNT; Vldbentry = VldbentryFirst = vldbentries->bulkentries_val = (vldbentry *)malloc(allocCount * sizeof(vldbentry)); if (Vldbentry == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } VldbentryLast = VldbentryFirst + allocCount; /* Handle the attribute by volume id totally separate of the rest (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!) */ if (attributes->Mask & VLLIST_VOLUMEID) { afs_int32 blockindex, chain; struct nvlentry tempentry; blockindex = FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode); if (blockindex == 0) { if (!errorcode) errorcode = VL_NOENT; COUNT_ABO; ubik_AbortTrans(trans); if(vldbentries->bulkentries_val)free((char *)vldbentries->bulkentries_val); vldbentries->bulkentries_val = 0; vldbentries->bulkentries_len = 0; return errorcode; } if (errorcode = put_attributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast, vldbentries, &tentry, nentries, &allocCount)) { COUNT_ABO; ubik_AbortTrans(trans); if(vldbentries->bulkentries_val)free((char *)vldbentries->bulkentries_val); vldbentries->bulkentries_val = 0; vldbentries->bulkentries_len = 0; return VL_SIZEEXCEEDED; } } else { afs_int32 nextblockindex=0, count=0, k, match=0; while (nextblockindex = NextEntry(trans, nextblockindex, &tentry, &count)) { if (++pollcount > 50) { IOMGR_Poll(); pollcount = 0; } match = 0; if (attributes->Mask & VLLIST_SERVER) { int serverindex; if ((serverindex = IpAddrToRelAddr(attributes->server, (struct ubik_trans *) 0)) == -1) continue; for (k=0; kMask & VLLIST_PARTITION) { if (match) { if (tentry.serverPartition[k] != attributes->partition) continue; } else { for (k=0; kpartition) { match = 1; break; } } if (!match) continue; } } if (attributes->Mask & VLLIST_FLAG) { if (!(tentry.flags & attributes->flag)) continue; } if (errorcode = put_attributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast, vldbentries, &tentry, nentries, &allocCount)) { COUNT_ABO; ubik_AbortTrans(trans); if(vldbentries->bulkentries_val)free((char *)vldbentries->bulkentries_val); vldbentries->bulkentries_val = 0; vldbentries->bulkentries_len = 0; return errorcode; } } } if (vldbentries->bulkentries_len && (allocCount > vldbentries->bulkentries_len)) { vldbentries->bulkentries_val = (vldbentry *) realloc(vldbentries->bulkentries_val, vldbentries->bulkentries_len * sizeof(vldbentry)); if (vldbentries->bulkentries_val == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } } VLog(5, ("ListAttrs nentries=%d %s\n", vldbentries->bulkentries_len, rxinfo(rxcall))); return(ubik_EndTrans(trans)); } VL_ListAttributesN(rxcall, attributes, nentries, vldbentries) struct rx_call *rxcall; struct VldbListByAttributes *attributes; afs_int32 *nentries; nbulkentries *vldbentries; { int errorcode, allocCount = 0; struct ubik_trans *trans; struct nvlentry tentry; struct nvldbentry *Vldbentry = 0, *VldbentryFirst = 0, *VldbentryLast = 0; int pollcount = 0; COUNT_REQ (VLLISTATTRIBUTESN); vldbentries->nbulkentries_val = 0; vldbentries->nbulkentries_len = *nentries = 0; if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; allocCount = VLDBALLOCCOUNT; Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val = (nvldbentry *)malloc(allocCount * sizeof(nvldbentry)); if (Vldbentry == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } VldbentryLast = VldbentryFirst + allocCount; /* Handle the attribute by volume id totally separate of the rest (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!) */ if (attributes->Mask & VLLIST_VOLUMEID) { afs_int32 blockindex, chain; struct nvlentry tempentry; blockindex = FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode); if (blockindex == 0) { if (!errorcode) errorcode = VL_NOENT; COUNT_ABO; ubik_AbortTrans(trans); if(vldbentries->nbulkentries_val)free((char *)vldbentries->nbulkentries_val); vldbentries->nbulkentries_val = 0; vldbentries->nbulkentries_len = 0; return errorcode; } if (errorcode = put_nattributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast, vldbentries, &tentry, 0, 0, nentries, &allocCount)) { COUNT_ABO; ubik_AbortTrans(trans); if(vldbentries->nbulkentries_val)free((char *)vldbentries->nbulkentries_val); vldbentries->nbulkentries_val = 0; vldbentries->nbulkentries_len = 0; return VL_SIZEEXCEEDED; } } else { afs_int32 nextblockindex=0, count=0, k, match=0; while (nextblockindex = NextEntry(trans, nextblockindex, &tentry, &count)) { if (++pollcount > 50) { IOMGR_Poll(); pollcount = 0; } match = 0; if (attributes->Mask & VLLIST_SERVER) { int serverindex; if ((serverindex = IpAddrToRelAddr(attributes->server, (struct ubik_trans *) 0)) == -1) continue; for (k=0; kMask & VLLIST_PARTITION) { if (match) { if (tentry.serverPartition[k] != attributes->partition) continue; } else { for (k=0; kpartition) { match = 1; break; } } if (!match) continue; } } if (attributes->Mask & VLLIST_FLAG) { if (!(tentry.flags & attributes->flag)) continue; } if (errorcode = put_nattributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast, vldbentries, &tentry, 0, 0, nentries, &allocCount)) { COUNT_ABO; ubik_AbortTrans(trans); if(vldbentries->nbulkentries_val)free((char *)vldbentries->nbulkentries_val); vldbentries->nbulkentries_val = 0; vldbentries->nbulkentries_len = 0; return errorcode; } } } if (vldbentries->nbulkentries_len && (allocCount > vldbentries->nbulkentries_len)) { vldbentries->nbulkentries_val = (nvldbentry *) realloc(vldbentries->nbulkentries_val, vldbentries->nbulkentries_len * sizeof(nvldbentry)); if (vldbentries->nbulkentries_val == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } } VLog(5, ("NListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len, rxinfo(rxcall))); return(ubik_EndTrans(trans)); } VL_ListAttributesN2(rxcall, attributes, name, startindex, nentries, vldbentries, nextstartindex) struct rx_call *rxcall; struct VldbListByAttributes *attributes; char * name; /* Wildcarded volume name */ afs_int32 startindex; afs_int32 *nentries; nbulkentries *vldbentries; afs_int32 *nextstartindex; { int errorcode=0, maxCount=VLDBALLOCCOUNT; struct ubik_trans *trans; struct nvlentry tentry; struct nvldbentry *Vldbentry=0, *VldbentryFirst=0, *VldbentryLast=0, tVldbentry; afs_int32 blockindex=0, count=0, k, match, matchindex; int serverindex=-1; /* no server found */ int findserver=0, findpartition=0, findflag=0, findname=0; char *t; int pollcount=0; int namematchRWBK, namematchRO, thismatch, matchtype; char volumename[VL_MAXNAMELEN]; COUNT_REQ (VLLISTATTRIBUTESN2); vldbentries->nbulkentries_val = 0; vldbentries->nbulkentries_len = 0; *nentries = 0; *nextstartindex = -1; errorcode = Init_VLdbase(&trans, LOCKREAD, this_op); if (errorcode) return errorcode; Vldbentry = VldbentryFirst = vldbentries->nbulkentries_val = (nvldbentry *)malloc(maxCount * sizeof(nvldbentry)); if (Vldbentry == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } VldbentryLast = VldbentryFirst + maxCount; /* Handle the attribute by volume id totally separate of the rest * (thus additional Mask values are ignored if VLLIST_VOLUMEID is set!) */ if (attributes->Mask & VLLIST_VOLUMEID) { blockindex = FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode); if (blockindex == 0) { if (!errorcode) errorcode = VL_NOENT; } else { errorcode = put_nattributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast, vldbentries, &tentry, 0, 0, nentries, &maxCount); if (errorcode) goto done; } } /* Search each entry in the database and return all entries * that match the request. It checks volumename (with * wildcarding), entry flags, server, and partition. */ else { /* Get the server index for matching server address */ if (attributes->Mask & VLLIST_SERVER) { serverindex = IpAddrToRelAddr(attributes->server, (struct ubik_trans *)0); if (serverindex == -1) goto done; findserver = 1; } findpartition = ((attributes->Mask & VLLIST_PARTITION) ? 1 : 0); findflag = ((attributes->Mask & VLLIST_FLAG) ? 1 : 0); if (name && (strcmp(name,".*") != 0) && (strcmp(name,"") != 0)) { sprintf(volumename, "^%s$", name); t = (char *)re_comp(volumename); if (t) { errorcode = VL_BADNAME; goto done; } findname = 1; } /* Read each entry and see if it is the one we want */ blockindex = startindex; while (blockindex = NextEntry(trans, blockindex, &tentry, &count)) { if (++pollcount > 50) { IOMGR_Poll(); pollcount = 0; } /* Step through each server index searching for a match. * Match to an existing RW, BK, or RO volume name (preference * is in this order). Remember which index we matched against. */ namematchRWBK = namematchRO = 0; /* 0->notTried; 1->match; 2->noMatch */ match = 0; for (k=0; (kpartition)) thismatch = 0; /* Is there a flag match */ if (thismatch && findflag && !(tentry.flags & attributes->flag)) thismatch = 0; /* We found a match. Remember the index, and type */ if (thismatch) { match = 1; matchindex = k; matchtype = thismatch; } /* Since we prefer RW and BK volume matches over RO matches, * if we have already checked the RWBK name, then we already * found the best match and so end the search. * * If we tried matching against the RW, BK, and RO volume names * and both failed, then we end the search (none will match). */ if ( (match && namematchRWBK) || ((namematchRWBK==2) && (namematchRO==2)) ) break; } /* Passed all the tests. Take it */ if (match) { errorcode = put_nattributeentry(&Vldbentry, &VldbentryFirst, &VldbentryLast, vldbentries, &tentry, matchtype, matchindex, nentries, &maxCount); if (errorcode) goto done; if (*nentries >= maxCount) break; /* collected the max */ } } *nextstartindex = (blockindex ? blockindex : -1); } done: if (errorcode) { COUNT_ABO; ubik_AbortTrans(trans); if (vldbentries->nbulkentries_val) free((char *)vldbentries->nbulkentries_val); vldbentries->nbulkentries_val = 0; vldbentries->nbulkentries_len = 0; *nextstartindex = -1; return errorcode; } else { VLog(5, ("N2ListAttrs nentries=%d %s\n", vldbentries->nbulkentries_len, rxinfo(rxcall))); return(ubik_EndTrans(trans)); } } /* Retrieves in vldbentries all vldb entries that match the specified * attributes (by server number, partition, volume type, and flag); if * volume id is specified then the associated list for that entry is * returned. CAUTION: This could be a very expensive call since in most * cases sequential search of all vldb entries is performed. */ VL_LinkedList(rxcall, attributes, nentries, vldbentries) struct rx_call *rxcall; struct VldbListByAttributes *attributes; afs_int32 *nentries; vldb_list *vldbentries; { int errorcode; struct ubik_trans *trans; struct nvlentry tentry; vldblist vllist, *vllistptr; afs_int32 blockindex, count, k, match; int serverindex; int pollcount = 0; COUNT_REQ (VLLINKEDLIST); if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; *nentries = 0; vldbentries->node = NULL; vllistptr = &vldbentries->node; /* List by volumeid */ if (attributes->Mask & VLLIST_VOLUMEID) { blockindex = FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode); if (!blockindex) { COUNT_ABO; ubik_AbortTrans(trans); return (errorcode ? errorcode : VL_NOENT); } vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry)); if (vllist == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } vlentry_to_vldbentry(&tentry, &vllist->VldbEntry); vllist->next_vldb = NULL; *vllistptr = vllist; /* Thread onto list */ vllistptr = &vllist->next_vldb; (*nentries)++; } /* Search by server, partition, and flags */ else { for (blockindex = NextEntry(trans, 0, &tentry, &count); blockindex; blockindex = NextEntry(trans, blockindex, &tentry, &count)) { match = 0; if (++pollcount > 50) { IOMGR_Poll(); pollcount = 0; } /* Does this volume exist on the desired server */ if (attributes->Mask & VLLIST_SERVER) { serverindex = IpAddrToRelAddr(attributes->server, (struct ubik_trans *)0); if (serverindex == -1) continue; for (k=0; k < OMAXNSERVERS; k++) { if (tentry.serverNumber[k] == BADSERVERID) break; if (tentry.serverNumber[k] == serverindex) { match = 1; break; } } if (!match) continue; } /* Does this volume exist on the desired partition */ if (attributes->Mask & VLLIST_PARTITION) { if (match) { if (tentry.serverPartition[k] != attributes->partition) match = 0; } else { for (k=0; k < OMAXNSERVERS; k++) { if (tentry.serverNumber[k] == BADSERVERID) break; if (tentry.serverPartition[k] == attributes->partition) { match = 1; break; } } } if (!match) continue; } /* Does this volume have the desired flags */ if (attributes->Mask & VLLIST_FLAG) { if (!(tentry.flags & attributes->flag)) continue; } vllist = (single_vldbentry *) malloc(sizeof(single_vldbentry)); if (vllist == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } vlentry_to_vldbentry(&tentry, &vllist->VldbEntry); vllist->next_vldb = NULL; *vllistptr = vllist; /* Thread onto list */ vllistptr = &vllist->next_vldb; (*nentries)++; if (smallMem && (*nentries >= VLDBALLOCCOUNT)) { COUNT_ABO; ubik_AbortTrans(trans); return VL_SIZEEXCEEDED; } } } *vllistptr = NULL; return(ubik_EndTrans(trans)); } VL_LinkedListN(rxcall, attributes, nentries, vldbentries) struct rx_call *rxcall; struct VldbListByAttributes *attributes; afs_int32 *nentries; nvldb_list *vldbentries; { int errorcode; struct ubik_trans *trans; struct nvlentry tentry; nvldblist vllist, *vllistptr; afs_int32 blockindex, count, k, match; int serverindex; int pollcount = 0; COUNT_REQ (VLLINKEDLISTN); if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; *nentries = 0; vldbentries->node = NULL; vllistptr = &vldbentries->node; /* List by volumeid */ if (attributes->Mask & VLLIST_VOLUMEID) { blockindex = FindByID(trans, attributes->volumeid, -1, &tentry, &errorcode); if (!blockindex) { COUNT_ABO; ubik_AbortTrans(trans); return (errorcode ? errorcode : VL_NOENT); } vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry)); if (vllist == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } vlentry_to_nvldbentry(&tentry, &vllist->VldbEntry); vllist->next_vldb = NULL; *vllistptr = vllist; /* Thread onto list */ vllistptr = &vllist->next_vldb; (*nentries)++; } /* Search by server, partition, and flags */ else { for (blockindex = NextEntry(trans, 0, &tentry, &count); blockindex; blockindex = NextEntry(trans, blockindex, &tentry, &count)) { match = 0; if (++pollcount > 50) { IOMGR_Poll(); pollcount = 0; } /* Does this volume exist on the desired server */ if (attributes->Mask & VLLIST_SERVER) { serverindex = IpAddrToRelAddr(attributes->server, (struct ubik_trans *)0); if (serverindex == -1) continue; for (k=0; k < NMAXNSERVERS; k++) { if (tentry.serverNumber[k] == BADSERVERID) break; if (tentry.serverNumber[k] == serverindex) { match = 1; break; } } if (!match) continue; } /* Does this volume exist on the desired partition */ if (attributes->Mask & VLLIST_PARTITION) { if (match) { if (tentry.serverPartition[k] != attributes->partition) match = 0; } else { for (k=0; k < NMAXNSERVERS; k++) { if (tentry.serverNumber[k] == BADSERVERID) break; if (tentry.serverPartition[k] == attributes->partition) { match = 1; break; } } } if (!match) continue; } /* Does this volume have the desired flags */ if (attributes->Mask & VLLIST_FLAG) { if (!(tentry.flags & attributes->flag)) continue; } vllist = (single_nvldbentry *) malloc(sizeof(single_nvldbentry)); if (vllist == NULL) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } vlentry_to_nvldbentry(&tentry, &vllist->VldbEntry); vllist->next_vldb = NULL; *vllistptr = vllist; /* Thread onto list */ vllistptr = &vllist->next_vldb; (*nentries)++; if (smallMem && (*nentries >= VLDBALLOCCOUNT)) { COUNT_ABO; ubik_AbortTrans(trans); return VL_SIZEEXCEEDED; } } } *vllistptr = NULL; return(ubik_EndTrans(trans)); } /* Get back vldb header statistics (allocs, frees, maxvolumeid, totalentries, etc) and dynamic statistics (number of requests and/or aborts per remote procedure call, etc) */ VL_GetStats(rxcall, stats, vital_header) struct rx_call *rxcall; vldstats *stats; vital_vlheader *vital_header; { register afs_int32 errorcode; struct ubik_trans *trans; COUNT_REQ(VLGETSTATS); #ifdef notdef /* Allow users to get statistics freely */ if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) /* Must be in 'UserList' to use */ return VL_PERM; #endif if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; VLog(5, ("GetStats %\n", rxinfo(rxcall))); bcopy((char *)&cheader.vital_header, (char *) vital_header, sizeof(vital_vlheader)); bcopy((char *)&dynamic_statistics, (char *) stats, sizeof(vldstats)); return(ubik_EndTrans(trans)); } /* Get the list of file server addresses from the VLDB. Currently it's pretty * easy to do. In the future, it might require a little bit of grunging * through the VLDB, but that's life. */ VL_GetAddrs(rxcall, Handle, spare2, spare3, nentries, addrsp) struct rx_call *rxcall; afs_int32 Handle, spare2; struct VLCallBack *spare3; afs_int32 *nentries; bulkaddrs *addrsp; { register afs_int32 errorcode; struct ubik_trans *trans; int nservers, i; afs_uint32 *taddrp; COUNT_REQ(VLGETADDRS); addrsp->bulkaddrs_len = *nentries = 0; addrsp->bulkaddrs_val = 0; bzero (spare3, sizeof (struct VLCallBack)); if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; VLog(5, ("GetAddrs\n")); addrsp->bulkaddrs_val = taddrp = (afs_uint32 *)malloc(sizeof(afs_int32)*(MAXSERVERID+1)); nservers= *nentries = addrsp->bulkaddrs_len = 0; if (!taddrp) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } for (i=0; i <= MAXSERVERID; i++) { if (*taddrp = ntohl(cheader.IpMappedAddr[i])) { taddrp++; nservers++; } } addrsp->bulkaddrs_len = *nentries = nservers; return(ubik_EndTrans(trans)); } #define PADDR(addr) printf("%d.%d.%d.%d", (addr>>24)&0xff, (addr>>16)&0xff, (addr>>8) &0xff, addr&0xff); VL_RegisterAddrs(rxcall, uuidp, spare1, addrsp) struct rx_call *rxcall; afsUUID *uuidp; afs_int32 spare1; bulkaddrs *addrsp; { afs_int32 code; struct ubik_trans *trans; int cnt, h, i, j, k, m, hostslot, base, index; struct extentaddr *exp = 0, *tex; afsUUID tuuid; afs_uint32 addrs[VL_MAXIPADDRS_PERMH]; afs_int32 fbase, findex; int count, willChangeEntry, foundUuidEntry, willReplaceCnt; int WillReplaceEntry, WillChange[MAXSERVERID+1], FoundUuid, ReplaceEntry; int srvidx, mhidx; COUNT_REQ(VLREGADDR); if (!afsconf_SuperUser(vldb_confdir, rxcall, (char *)0)) return (VL_PERM); if (code = Init_VLdbase(&trans, LOCKWRITE, this_op)) return code; /* Eliminate duplicates from IP address list */ for (k=0, cnt=0; kbulkaddrs_len; k++) { if (addrsp->bulkaddrs_val[k] == 0) continue; for (m=0; m < cnt; m++) { if (addrs[m] == addrsp->bulkaddrs_val[k]) break; } if (m == cnt) { if (m == VL_MAXIPADDRS_PERMH) { VLog(0, ("Number of addresses exceeds %d. Cannot register IP addr 0x%x in VLDB\n", VL_MAXIPADDRS_PERMH, addrsp->bulkaddrs_val[k])); } else { addrs[m] = addrsp->bulkaddrs_val[k]; cnt++; } } } if (cnt <= 0) { ubik_AbortTrans(trans); return VL_INDEXERANGE; } count = 0; willReplaceCnt = 0; foundUuidEntry = 0; /* For each server registered within the VLDB */ for (srvidx=0; srvidx <= MAXSERVERID;srvidx++) { willChangeEntry = 0; WillReplaceEntry = 1; if ((HostAddress[srvidx] & 0xff000000) == 0xff000000) { /* The server is registered as a multihomed */ base = (HostAddress[srvidx] >> 16) & 0xff; index = HostAddress[srvidx] & 0x0000ffff; if (base >= VL_MAX_ADDREXTBLKS) { VLog(0, ("Internal error: Multihome extent base is too large. Base %d index %d\n", base, index)); continue; } if (index >= VL_MHSRV_PERBLK) { VLog(0, ("Internal error: Multihome extent index is too large. Base %d index %d\n", base, index)); continue; } if (!ex_addr[base]) { VLog(0, ("Internal error: Multihome extent does not exist. Base %d\n", base)); continue; } /* See if the addresses to register will change this server entry */ exp = &ex_addr[base][index]; tuuid = exp->ex_hostuuid; afs_ntohuuid(&tuuid); if (afs_uuid_equal(uuidp, &tuuid)) { foundUuidEntry = 1; FoundUuid = srvidx; } else { for (mhidx=0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) { if (!exp->ex_addrs[mhidx]) continue; for (k=0; kex_addrs[mhidx]) == addrs[k]) { willChangeEntry = 1; WillChange[count] = srvidx; break; } } if (k >= cnt) WillReplaceEntry = 0; } } } else { /* The server is not registered as a multihomed. * See if the addresses to register will replace this server entry. */ for (k=0; k 0)) || (!foundUuidEntry && (count > 1)) ) { VLog(0, ("The following fileserver is being registered in the VLDB:\n")); printf(" ["); for (k=0; k0) printf(" "); PADDR(addrs[k]); } printf("]\n"); if (foundUuidEntry) { printf(" It would have replaced the existing VLDB server entry:\n"); printf(" entry %d: [", FoundUuid); base = (HostAddress[FoundUuid] >> 16) & 0xff; index = HostAddress[FoundUuid] & 0x0000ffff; exp = &ex_addr[base][index]; for (mhidx=0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) { if (!exp->ex_addrs[mhidx]) continue; if (mhidx > 0) printf(" "); PADDR(ntohl(exp->ex_addrs[mhidx])); } printf("]\n"); } if (count == 1) printf(" Yet another VLDB server entry exists:\n"); else printf(" Yet other VLDB server entries exist:\n"); for (j=0; j> 16) & 0xff; index = HostAddress[srvidx] & 0x0000ffff; exp = &ex_addr[base][index]; for (mhidx=0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) { if (!exp->ex_addrs[mhidx]) continue; if (mhidx > 0) printf(" "); PADDR(ntohl(exp->ex_addrs[mhidx])); } printf("]"); } else { PADDR(HostAddress[srvidx]); } printf("\n"); } if (count == 1) printf(" You must 'vos changeaddr' this other server entry\n"); else printf(" You must 'vos changeaddr' these other server entries\n"); if (foundUuidEntry) printf(" and/or remove the sysid file from the registering fileserver\n"); printf(" before the fileserver can be registered in the VLDB.\n"); ubik_AbortTrans(trans); return VL_MULTIPADDR; } /* Passed the checks. Now find and update the existing mh entry, or create * a new mh entry. */ if (foundUuidEntry) { /* Found the entry with same uuid. See if we need to change it */ int change = 0; fbase = (HostAddress[FoundUuid] >> 16) & 0xff; index = HostAddress[FoundUuid] & 0x0000ffff; exp = &ex_addr[fbase][index]; /* Determine if the entry has changed */ for (k=0; ((k < cnt) && !change); k++) { if (ntohl(exp->ex_addrs[k]) != addrs[k]) change = 1; } for (; ((k < VL_MAXIPADDRS_PERMH) && !change); k++) { if (exp->ex_addrs[k] != 0) change = 1; } if (!change) { return(ubik_EndTrans(trans)); } } VLog(0, ("The following fileserver is being registered in the VLDB:\n")); printf(" ["); for (k=0; k0) printf(" "); PADDR(addrs[k]); } printf("]\n"); if (foundUuidEntry) { printf(" It will replace the following existing entry in the VLDB (same uuid):\n"); printf(" entry %d: [", FoundUuid); for (k=0; k < VL_MAXIPADDRS_PERMH; k++) { if (exp->ex_addrs[k] == 0) continue; if (k>0) printf(" "); PADDR(ntohl(exp->ex_addrs[k])); } printf("]\n"); } else if (willReplaceCnt || (count == 1)) { /* If we are not replacing an entry and there is only one entry to change, * then we will replace that entry. */ if (!willReplaceCnt) { ReplaceEntry = WillChange[0]; willReplaceCnt++; } /* Have an entry that needs to be replaced */ if ((HostAddress[ReplaceEntry] & 0xff000000) == 0xff000000) { fbase = (HostAddress[ReplaceEntry] >> 16) & 0xff; index = HostAddress[ReplaceEntry] & 0x0000ffff; exp = &ex_addr[fbase][index]; printf(" It will replace the following existing entry in the VLDB (new uuid):\n"); printf(" entry %d: [", ReplaceEntry); for (k=0; k < VL_MAXIPADDRS_PERMH; k++) { if (exp->ex_addrs[k] == 0) continue; if (k>0) printf(" "); PADDR(ntohl(exp->ex_addrs[k])); } printf("]\n"); } else { /* Not a mh entry. So we have to create a new mh entry and * put it on the ReplaceEntry slot of the HostAddress array. */ printf(" It will replace existing entry %d, ", ReplaceEntry); PADDR(HostAddress[ReplaceEntry]); printf(", in the VLDB (new uuid):\n"); code = FindExtentBlock(trans, uuidp, 1, ReplaceEntry, &exp, &fbase); if (code || !exp) { ubik_AbortTrans(trans); return (code ? code : VL_IO); } } } else { /* There is no entry for this server, must create a new mh entry as * well as use a new slot of the HostAddress array. */ printf(" It will create a new entry in the VLDB.\n"); code = FindExtentBlock(trans, uuidp, 1, -1, &exp, &fbase); if (code || !exp) { ubik_AbortTrans(trans); return (code ? code : VL_IO); } } /* Now we have a mh entry to fill in. Update the uuid, bump the * uniquifier, and fill in its IP addresses. */ tuuid = *uuidp; afs_htonuuid(&tuuid); exp->ex_hostuuid = tuuid; exp->ex_uniquifier = htonl(ntohl(exp->ex_uniquifier)+1); for (k=0; k < cnt; k++) { exp->ex_addrs[k] = htonl(addrs[k]); } for (; k < VL_MAXIPADDRS_PERMH; k++) { exp->ex_addrs[k] = 0; } /* Write the new mh entry out */ if (vlwrite(trans, DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[fbase]), (char *)ex_addr[fbase], (char *)exp), (char *)exp, sizeof(*exp))) { ubik_AbortTrans(trans); return VL_IO; } /* Remove any common addresses from other mh entres. We know these entries * are being changed and not replaced so they are mh entries. */ m = 0; for (i=0; i> 16) & 0xff; index = HostAddress[WillChange[i]] & 0x0000ffff; tex = &ex_addr[fbase][index]; if (++m == 1) printf(" The following existing entries in the VLDB will be updated:\n"); printf(" entry %d: [", WillChange[i]); for (h=j=0; j < VL_MAXIPADDRS_PERMH; j++) { if (tex->ex_addrs[j]) { if (j>0) printf(" "); PADDR(ntohl(tex->ex_addrs[j])); } for (k=0; kex_addrs[j]) == addrs[k]) break; } if (k >= cnt) { /* Not found, so we keep it */ tex->ex_addrs[h] = tex->ex_addrs[j]; h++; } } for (j=h; j < VL_MAXIPADDRS_PERMH; j++) { tex->ex_addrs[j] = 0; /* zero rest of mh entry */ } printf("]\n"); /* Write out the modified mh entry */ tex->ex_uniquifier = htonl(ntohl(tex->ex_uniquifier)+1); doff=DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[base]), (char *)ex_addr[base], (char *)tex); if (vlwrite(trans, doff, (char*)tex, sizeof(*tex))) { ubik_AbortTrans(trans); return VL_IO; } } return(ubik_EndTrans(trans)); } VL_GetAddrsU(rxcall, attributes, uuidpo, uniquifier, nentries, addrsp) struct rx_call *rxcall; struct ListAddrByAttributes *attributes; afsUUID *uuidpo; afs_int32 *uniquifier, *nentries; bulkaddrs *addrsp; { register afs_int32 errorcode, index=-1, op, offset; struct ubik_trans *trans; int nservers, i, j, k, base=0; struct extentaddr *exp=0; afsUUID tuuid; afs_uint32 *taddrp, taddr; COUNT_REQ(VLGETADDRSU); addrsp->bulkaddrs_len = *nentries = 0; addrsp->bulkaddrs_val = 0; VLog(5, ("GetAddrsU %s\n", rxinfo(rxcall))); if (errorcode = Init_VLdbase(&trans, LOCKREAD, this_op)) return errorcode; if (attributes->Mask & VLADDR_IPADDR) { if (attributes->Mask & (VLADDR_INDEX|VLADDR_UUID)) { ubik_AbortTrans(trans); return VL_BADMASK; } for (base = 0; base < VL_MAX_ADDREXTBLKS; base++) { if (!ex_addr[base]) break; for (i = 1; i < VL_MHSRV_PERBLK; i++) { exp = &ex_addr[base][i]; tuuid = exp->ex_hostuuid; afs_ntohuuid(&tuuid); if (afs_uuid_is_nil(&tuuid)) continue; for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) { if (exp->ex_addrs[j] && (ntohl(exp->ex_addrs[j]) == attributes->ipaddr)) { break; } } if (j < VL_MAXIPADDRS_PERMH) break; } if (i < VL_MHSRV_PERBLK) break; } if (base >= VL_MAX_ADDREXTBLKS) { ubik_AbortTrans(trans); return VL_NOENT; } } else if (attributes->Mask & VLADDR_INDEX) { if (attributes->Mask & (VLADDR_IPADDR|VLADDR_UUID)) { ubik_AbortTrans(trans); return VL_BADMASK; } index = attributes->index; if (index < 1 || index >= (VL_MAX_ADDREXTBLKS*VL_MHSRV_PERBLK)) { ubik_AbortTrans(trans); return VL_INDEXERANGE; } base = index / VL_MHSRV_PERBLK; offset = index % VL_MHSRV_PERBLK; if (offset == 0) { ubik_AbortTrans(trans); return VL_NOENT; } if (!ex_addr[base]) { ubik_AbortTrans(trans); return VL_INDEXERANGE; } exp = &ex_addr[base][offset]; } else if (attributes->Mask & VLADDR_UUID) { if (attributes->Mask & (VLADDR_IPADDR|VLADDR_INDEX)) { ubik_AbortTrans(trans); return VL_BADMASK; } if (!ex_addr[0]) { /* mh servers probably aren't setup on this vldb */ ubik_AbortTrans(trans); return VL_NOENT; } if (errorcode = FindExtentBlock(trans, &attributes->uuid, 0, -1, &exp, &base)) { ubik_AbortTrans(trans); return errorcode; } } else { ubik_AbortTrans(trans); return VL_BADMASK; } if (exp == (struct extentaddr *)0) { ubik_AbortTrans(trans); return VL_NOENT; } addrsp->bulkaddrs_val = taddrp = (afs_uint32 *)malloc(sizeof(afs_int32)*(MAXSERVERID+1)); nservers= *nentries = addrsp->bulkaddrs_len = 0; if (!taddrp) { COUNT_ABO; ubik_AbortTrans(trans); return VL_NOMEM; } tuuid = exp->ex_hostuuid; afs_ntohuuid(&tuuid); if (afs_uuid_is_nil(&tuuid)) { ubik_AbortTrans(trans); return VL_NOENT; } if (uuidpo) *uuidpo = tuuid; if (uniquifier) *uniquifier = ntohl(exp->ex_uniquifier); for (i = 0; i < VL_MAXIPADDRS_PERMH; i++) { if (exp->ex_addrs[i]) { taddr = ntohl(exp->ex_addrs[i]); /* Weed out duplicates */ for (j = 0; j < nservers; j++) { if (taddrp[j] == taddr) break; } if ((j == nservers) && (j <= MAXSERVERID)) { taddrp[nservers] = taddr; nservers++; } } } addrsp->bulkaddrs_len = *nentries = nservers; return(ubik_EndTrans(trans)); } /* ============> End of Exported vldb RPC functions <============= */ /* Routine that copies the given vldb entry to the output buffer, vldbentries. */ static int put_attributeentry(Vldbentry, VldbentryFirst, VldbentryLast, vldbentries, entry, nentries, alloccnt) struct vldbentry **Vldbentry, **VldbentryFirst, **VldbentryLast; bulkentries *vldbentries; struct nvlentry *entry; afs_int32 *nentries, *alloccnt; { vldbentry *reall; afs_int32 allo; if (*Vldbentry == *VldbentryLast) { if (smallMem) return VL_SIZEEXCEEDED; /* no growing if smallMem defined */ /* Allocate another set of memory; each time allocate twice as * many blocks as the last time. When we reach VLDBALLOCLIMIT, * then grow in increments of VLDBALLOCINCR. */ allo = (*alloccnt > VLDBALLOCLIMIT) ? VLDBALLOCINCR : *alloccnt; reall = (vldbentry *) realloc(*VldbentryFirst, (*alloccnt+allo)*sizeof(vldbentry)); if (reall == NULL) return VL_NOMEM; *VldbentryFirst = vldbentries->bulkentries_val = reall; *Vldbentry = *VldbentryFirst + *alloccnt; *VldbentryLast = *Vldbentry + allo; *alloccnt += allo; } vlentry_to_vldbentry(entry, *Vldbentry); (*Vldbentry)++; (*nentries)++; vldbentries->bulkentries_len++; return 0; } static int put_nattributeentry(Vldbentry, VldbentryFirst, VldbentryLast, vldbentries, entry, matchtype, matchindex, nentries, alloccnt) struct nvldbentry **Vldbentry, **VldbentryFirst, **VldbentryLast; nbulkentries *vldbentries; struct nvlentry *entry; afs_int32 matchtype, matchindex, *nentries, *alloccnt; { nvldbentry *reall; afs_int32 allo; if (*Vldbentry == *VldbentryLast) { if (smallMem) return VL_SIZEEXCEEDED; /* no growing if smallMem defined */ /* Allocate another set of memory; each time allocate twice as * many blocks as the last time. When we reach VLDBALLOCLIMIT, * then grow in increments of VLDBALLOCINCR. */ allo = (*alloccnt > VLDBALLOCLIMIT) ? VLDBALLOCINCR : *alloccnt; reall = (nvldbentry *)realloc(*VldbentryFirst, (*alloccnt+allo)*sizeof(nvldbentry)); if (reall == NULL) return VL_NOMEM; *VldbentryFirst = vldbentries->nbulkentries_val = reall; *Vldbentry = *VldbentryFirst + *alloccnt; *VldbentryLast = *Vldbentry + allo; *alloccnt += allo; } vlentry_to_nvldbentry(entry, *Vldbentry); (*Vldbentry)->matchindex = (matchtype << 16) + matchindex; (*Vldbentry)++; (*nentries)++; vldbentries->nbulkentries_len++; return 0; } /* Common code to actually remove a vldb entry from the database. */ static int RemoveEntry(trans, entryptr, tentry) struct ubik_trans *trans; afs_int32 entryptr; struct nvlentry *tentry; { register int errorcode; if (errorcode = UnthreadVLentry(trans, entryptr, tentry)) return errorcode; if (errorcode = FreeBlock(trans, entryptr)) return errorcode; return 0; } static ReleaseEntry(tentry, releasetype) struct nvlentry *tentry; afs_int32 releasetype; { if (releasetype & LOCKREL_TIMESTAMP) tentry->LockTimestamp = 0; if (releasetype & LOCKREL_OPCODE) tentry->flags &= ~VLOP_ALLOPERS; if (releasetype & LOCKREL_AFSID) tentry->LockAfsId = 0; } /* Verify that the incoming vldb entry is valid; multi type of error codes are returned. */ static int check_vldbentry(aentry) struct vldbentry *aentry; { afs_int32 i; if (InvalidVolname(aentry->name)) return VL_BADNAME; if (aentry->nServers <= 0 || aentry->nServers > OMAXNSERVERS) return VL_BADSERVER; for (i=0; i < aentry->nServers; i++) { /* if (aentry->serverNumber[i] < 0 || aentry->serverNumber[i] > MAXSERVERID) return VL_BADSERVER; */ if (aentry->serverPartition[i] < 0 || aentry->serverPartition[i] > MAXPARTITIONID) return VL_BADPARTITION; if (aentry->serverFlags[i] < 0 || aentry->serverFlags[i] > MAXSERVERFLAG) return VL_BADSERVERFLAG; } return 0; } static int check_nvldbentry(aentry) struct nvldbentry *aentry; { afs_int32 i; if (InvalidVolname(aentry->name)) return VL_BADNAME; if (aentry->nServers <= 0 || aentry->nServers > NMAXNSERVERS) return VL_BADSERVER; for (i=0; i < aentry->nServers; i++) { /* if (aentry->serverNumber[i] < 0 || aentry->serverNumber[i] > MAXSERVERID) return VL_BADSERVER; */ if (aentry->serverPartition[i] < 0 || aentry->serverPartition[i] > MAXPARTITIONID) return VL_BADPARTITION; if (aentry->serverFlags[i] < 0 || aentry->serverFlags[i] > MAXSERVERFLAG) return VL_BADSERVERFLAG; } return 0; } /* Convert from the external vldb entry representation to its internal (more compact) form. This call should not change the hash chains! */ static int vldbentry_to_vlentry(atrans, VldbEntry, VlEntry) struct ubik_trans *atrans; struct vldbentry *VldbEntry; struct nvlentry *VlEntry; { int i, serverindex; if (strcmp(VlEntry->name, VldbEntry->name)) strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name)); for (i=0; inServers; i++) { serverindex = IpAddrToRelAddr(VldbEntry->serverNumber[i], atrans); if (serverindex == -1) return VL_BADSERVER; VlEntry->serverNumber[i] = serverindex; VlEntry->serverPartition[i] = VldbEntry->serverPartition[i]; VlEntry->serverFlags[i] = VldbEntry->serverFlags[i]; } for (;i < OMAXNSERVERS; i++) VlEntry->serverNumber[i] = VlEntry->serverPartition[i] = VlEntry->serverFlags[i] = BADSERVERID; for (i=0; i < MAXTYPES; i++) VlEntry->volumeId[i] = VldbEntry->volumeId[i]; VlEntry->cloneId = VldbEntry->cloneId; VlEntry->flags = VldbEntry->flags; return 0; } static int nvldbentry_to_vlentry(atrans, VldbEntry, VlEntry) struct ubik_trans *atrans; struct nvldbentry *VldbEntry; struct nvlentry *VlEntry; { int i, serverindex; if (strcmp(VlEntry->name, VldbEntry->name)) strncpy(VlEntry->name, VldbEntry->name, sizeof(VlEntry->name)); for (i=0; inServers; i++) { serverindex = IpAddrToRelAddr(VldbEntry->serverNumber[i], atrans); if (serverindex == -1) return VL_BADSERVER; VlEntry->serverNumber[i] = serverindex; VlEntry->serverPartition[i] = VldbEntry->serverPartition[i]; VlEntry->serverFlags[i] = VldbEntry->serverFlags[i]; } for (;i < NMAXNSERVERS; i++) VlEntry->serverNumber[i] = VlEntry->serverPartition[i] = VlEntry->serverFlags[i] = BADSERVERID; for (i=0; i < MAXTYPES; i++) VlEntry->volumeId[i] = VldbEntry->volumeId[i]; VlEntry->cloneId = VldbEntry->cloneId; VlEntry->flags = VldbEntry->flags; return 0; } /* Update the vldb entry with the new fields as indicated by the value of the Mask entry in the updateentry structure. All necessary validation checks are performed. */ static get_vldbupdateentry(trans, blockindex, updateentry, VlEntry) struct ubik_trans *trans; afs_int32 blockindex; struct VldbUpdateEntry *updateentry; struct nvlentry *VlEntry; { int i, j, errorcode, serverindex; if (updateentry->Mask & VLUPDATE_VOLUMENAME) { if (InvalidVolname(updateentry->name)) return VL_BADNAME; if (errorcode = UnhashVolname(trans, blockindex, VlEntry)) return errorcode; strncpy(VlEntry->name, updateentry->name, sizeof(VlEntry->name)); HashVolname(trans, blockindex, VlEntry); } if (updateentry->Mask & VLUPDATE_VOLNAMEHASH) { if (errorcode = UnhashVolname(trans, blockindex, VlEntry)) { if (errorcode != VL_NOENT) return errorcode; } HashVolname(trans, blockindex, VlEntry); } if (updateentry->Mask & VLUPDATE_FLAGS) { VlEntry->flags = updateentry->flags; } if (updateentry->Mask & VLUPDATE_CLONEID) { VlEntry->cloneId = updateentry->cloneId; } if (updateentry->Mask & VLUPDATE_RWID) { if (errorcode = UnhashVolid(trans, RWVOL, blockindex, VlEntry)) { if (errorcode != VL_NOENT) return errorcode; } VlEntry->volumeId[RWVOL] = updateentry->spares3; /* rw id */ if (errorcode = HashVolid(trans, RWVOL, blockindex, VlEntry)) return errorcode; } if (updateentry->Mask & VLUPDATE_READONLYID) { if (errorcode = UnhashVolid(trans, ROVOL, blockindex, VlEntry)) { if (errorcode != VL_NOENT) return errorcode; } VlEntry->volumeId[ROVOL] = updateentry->ReadOnlyId; if (errorcode = HashVolid(trans, ROVOL, blockindex, VlEntry)) return errorcode; } if (updateentry->Mask & VLUPDATE_BACKUPID) { if (errorcode = UnhashVolid(trans, BACKVOL, blockindex, VlEntry)) { if (errorcode != VL_NOENT) return errorcode; } VlEntry->volumeId[BACKVOL] = updateentry->BackupId; if (errorcode = HashVolid(trans, BACKVOL, blockindex, VlEntry)) return errorcode; } if (updateentry->Mask & VLUPDATE_REPSITES) { if (updateentry->nModifiedRepsites <= 0 || updateentry->nModifiedRepsites > OMAXNSERVERS) return VL_BADSERVER; for (i=0; i < updateentry->nModifiedRepsites; i++) { /* if (updateentry->RepsitesTargetServer[i] < 0 || updateentry->RepsitesTargetServer[i] > MAXSERVERID) return VL_BADSERVER; */ if (updateentry->RepsitesTargetPart[i] < 0 || updateentry->RepsitesTargetPart[i] > MAXPARTITIONID) return VL_BADPARTITION; if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_DELETE) { if ((j = repsite_exists(VlEntry, IpAddrToRelAddr(updateentry->RepsitesTargetServer[i], trans), updateentry->RepsitesTargetPart[i])) != -1) repsite_compress(VlEntry, j); else return VL_NOREPSERVER; } if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_ADD) { /* if (updateentry->RepsitesNewServer[i] < 0 || updateentry->RepsitesNewServer[i] > MAXSERVERID) return VL_BADSERVER; */ if (updateentry->RepsitesNewPart[i] < 0 || updateentry->RepsitesNewPart[i] > MAXPARTITIONID) return VL_BADPARTITION; if (repsite_exists(VlEntry, IpAddrToRelAddr(updateentry->RepsitesNewServer[i], trans), updateentry->RepsitesNewPart[i]) != -1) return VL_DUPREPSERVER; for (j=0; VlEntry->serverNumber[j] != BADSERVERID && j < OMAXNSERVERS; j++); if (j >= OMAXNSERVERS) return VL_REPSFULL; if ((serverindex = IpAddrToRelAddr(updateentry->RepsitesNewServer[i], trans)) == -1) return VL_BADSERVER; VlEntry->serverNumber[j] = serverindex; VlEntry->serverPartition[j] = updateentry->RepsitesNewPart[i]; if (updateentry->RepsitesNewFlags[i] < 0 || updateentry->RepsitesNewFlags[i] > MAXSERVERFLAG) return VL_BADSERVERFLAG; VlEntry->serverFlags[j] = updateentry->RepsitesNewFlags[i]; } if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODSERV) { /*n if (updateentry->RepsitesNewServer[i] < 0 || updateentry->RepsitesNewServer[i] > MAXSERVERID) return VL_BADSERVER; */ if ((j = repsite_exists(VlEntry, IpAddrToRelAddr(updateentry->RepsitesTargetServer[i], trans), updateentry->RepsitesTargetPart[i])) != -1) { VlEntry->serverNumber[j] = IpAddrToRelAddr(updateentry->RepsitesNewServer[i], trans); } else return VL_NOREPSERVER; } if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODPART) { if (updateentry->RepsitesNewPart[i] < 0 || updateentry->RepsitesNewPart[i] > MAXPARTITIONID) return VL_BADPARTITION; if ((j = repsite_exists(VlEntry, IpAddrToRelAddr(updateentry->RepsitesTargetServer[i], trans), updateentry->RepsitesTargetPart[i])) != -1) VlEntry->serverPartition[j] = updateentry->RepsitesNewPart[i]; else return VL_NOREPSERVER; } if (updateentry->RepsitesMask[i] & VLUPDATE_REPS_MODFLAG) { if ((j = repsite_exists(VlEntry, IpAddrToRelAddr(updateentry->RepsitesTargetServer[i], trans), updateentry->RepsitesTargetPart[i])) != -1) { if (updateentry->RepsitesNewFlags[i] < 0 || updateentry->RepsitesNewFlags[i] > MAXSERVERFLAG) return VL_BADSERVERFLAG; VlEntry->serverFlags[j] = updateentry->RepsitesNewFlags[i]; } else return VL_NOREPSERVER; } } } return 0; } /* Check if the specified [server,partition] entry is found in the vldb entry's repsite table; it's offset in the table is returned, if it's present there. */ static int repsite_exists(VlEntry, server, partition) struct nvlentry *VlEntry; int server, partition; { int i; for (i=0; VlEntry->serverNumber[i] != BADSERVERID && i < OMAXNSERVERS; i++) { if ((VlEntry->serverNumber[i] == server) && (VlEntry->serverPartition[i] == partition)) return i; } return -1; } /* Repsite table compression: used when deleting a repsite entry so that all active repsite entries are on the top of the table. */ static repsite_compress(VlEntry, offset) struct nvlentry *VlEntry; int offset; { int repsite_offset = offset; for (; VlEntry->serverNumber[repsite_offset] != BADSERVERID && repsite_offset < OMAXNSERVERS-1; repsite_offset++) { VlEntry->serverNumber[repsite_offset] = VlEntry->serverNumber[repsite_offset+1]; VlEntry->serverPartition[repsite_offset] = VlEntry->serverPartition[repsite_offset+1]; VlEntry->serverFlags[repsite_offset] = VlEntry->serverFlags[repsite_offset+1]; } VlEntry->serverNumber[repsite_offset] = BADSERVERID; } /* Convert from the internal (compacted) vldb entry to the external representation used by the interface. */ static vlentry_to_vldbentry(VlEntry, VldbEntry) struct nvlentry *VlEntry; struct vldbentry *VldbEntry; { int i, j; bzero(VldbEntry, sizeof(struct vldbentry)); strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name)); for (i=0; i < OMAXNSERVERS; i++) { if (VlEntry->serverNumber[i] == BADSERVERID) break; if ((HostAddress[j = VlEntry->serverNumber[i]] & 0xff000000) == 0xff000000) { struct extentaddr *exp; int base, index; base = (HostAddress[j] >> 16) & 0xff; index = HostAddress[j] & 0x0000ffff; exp = &ex_addr[base][index]; /* For now return the first ip address back */ for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) { if (exp->ex_addrs[j]) { VldbEntry->serverNumber[i] = ntohl(exp->ex_addrs[j]); break; } } } else VldbEntry->serverNumber[i] = HostAddress[VlEntry->serverNumber[i]]; VldbEntry->serverPartition[i] = VlEntry->serverPartition[i]; VldbEntry->serverFlags[i] = VlEntry->serverFlags[i]; } VldbEntry->nServers = i; for (i=0; ivolumeId[i] = VlEntry->volumeId[i]; VldbEntry->cloneId = VlEntry->cloneId; VldbEntry->flags = VlEntry->flags; } /* Convert from the internal (compacted) vldb entry to the external representation used by the interface. */ static vlentry_to_nvldbentry(VlEntry, VldbEntry) struct nvlentry *VlEntry; struct nvldbentry *VldbEntry; { int i, j; bzero(VldbEntry, sizeof(struct vldbentry)); strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name)); for (i=0; i < NMAXNSERVERS; i++) { if (VlEntry->serverNumber[i] == BADSERVERID) break; if ((HostAddress[j = VlEntry->serverNumber[i]] & 0xff000000) == 0xff000000) { struct extentaddr *exp; int base, index; base = (HostAddress[j] >> 16) & 0xff; index = HostAddress[j] & 0x0000ffff; exp = &ex_addr[base][index]; /* For now return the first ip address back */ for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) { if (exp->ex_addrs[j]) { VldbEntry->serverNumber[i] = ntohl(exp->ex_addrs[j]); break; } } } else VldbEntry->serverNumber[i] = HostAddress[VlEntry->serverNumber[i]]; VldbEntry->serverPartition[i] = VlEntry->serverPartition[i]; VldbEntry->serverFlags[i] = VlEntry->serverFlags[i]; } VldbEntry->nServers = i; for (i=0; ivolumeId[i] = VlEntry->volumeId[i]; VldbEntry->cloneId = VlEntry->cloneId; VldbEntry->flags = VlEntry->flags; } static vlentry_to_uvldbentry(VlEntry, VldbEntry) struct nvlentry *VlEntry; struct uvldbentry *VldbEntry; { int i, j; bzero(VldbEntry, sizeof(struct vldbentry)); strncpy(VldbEntry->name, VlEntry->name, sizeof(VldbEntry->name)); for (i=0; i < NMAXNSERVERS; i++) { if (VlEntry->serverNumber[i] == BADSERVERID) break; VldbEntry->serverFlags[i] = VlEntry->serverFlags[i]; VldbEntry->serverUnique[i] = 0; if ((HostAddress[j = VlEntry->serverNumber[i]] & 0xff000000) == 0xff000000) { struct extentaddr *exp; int base, index; afsUUID tuuid; base = (HostAddress[j] >> 16) & 0xff; index = HostAddress[j] & 0x0000ffff; exp = &ex_addr[base][index]; tuuid = exp->ex_hostuuid; afs_ntohuuid(&tuuid); VldbEntry->serverFlags[i] |= VLSERVER_FLAG_UUID; VldbEntry->serverNumber[i] = tuuid; VldbEntry->serverUnique[i] = ntohl(exp->ex_uniquifier); } else { VldbEntry->serverNumber[i].time_low = HostAddress[VlEntry->serverNumber[i]]; } VldbEntry->serverPartition[i] = VlEntry->serverPartition[i]; } VldbEntry->nServers = i; for (i=0; ivolumeId[i] = VlEntry->volumeId[i]; VldbEntry->cloneId = VlEntry->cloneId; VldbEntry->flags = VlEntry->flags; } #define LEGALCHARS ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" /* Verify that the volname is a valid volume name. */ static int InvalidVolname(volname) char *volname; { char *map; int slen; map = LEGALCHARS; slen = strlen(volname); if (slen >= VL_MAXNAMELEN) return 1; return(slen != strspn(volname, map)); } /* Verify that the given volume type is valid. */ static int InvalidVoltype(voltype) afs_int32 voltype; { if (voltype != RWVOL && voltype != ROVOL && voltype != BACKVOL) return 1; return 0; } static int InvalidOperation(voloper) afs_int32 voloper; { if (voloper != VLOP_MOVE && voloper != VLOP_RELEASE && voloper != VLOP_BACKUP && voloper != VLOP_DELETE && voloper != VLOP_DUMP) return 1; return 0; } static int InvalidReleasetype(releasetype) afs_int32 releasetype; { if ((releasetype & LOCKREL_TIMESTAMP) || (releasetype & LOCKREL_OPCODE) || (releasetype & LOCKREL_AFSID)) return 0; return 1; } static int IpAddrToRelAddr(ipaddr, atrans) struct ubik_trans *atrans; register afs_uint32 ipaddr; { register int i, j; register afs_int32 code, base, index; struct extentaddr *exp; for (i = 0; i <= MAXSERVERID; i++) { if (HostAddress[i] == ipaddr) return i; if ((HostAddress[i] & 0xff000000) == 0xff000000) { base = (HostAddress[i] >> 16) & 0xff; index = HostAddress[i] & 0x0000ffff; if (base >= VL_MAX_ADDREXTBLKS) { VLog(0, ("Internal error: Multihome extent base is too large. Base %d index %d\n", base, index)); return -1; /* EINVAL */ } if (index >= VL_MHSRV_PERBLK) { VLog(0, ("Internal error: Multihome extent index is too large. Base %d index %d\n", base, index)); return -1; /* EINVAL */ } if (!ex_addr[base]) { VLog(0, ("Internal error: Multihome extent does not exist. Base %d\n", base)); return -1; /* EINVAL */ } exp = &ex_addr[base][index]; for (j = 0; j < VL_MAXIPADDRS_PERMH; j++) { if (exp->ex_addrs[j] && (ntohl(exp->ex_addrs[j]) == ipaddr)) { return i; } } } } /* allocate the new server a server id pronto */ if (atrans) { for(i=0;i <= MAXSERVERID;i++) { if (cheader.IpMappedAddr[i] == 0) { cheader.IpMappedAddr[i] = htonl(ipaddr); code = vlwrite(atrans, DOFFSET(0, &cheader, &cheader.IpMappedAddr[i]), (char *) &cheader.IpMappedAddr[i], sizeof(afs_int32)); HostAddress[i] = ipaddr; if (code) return -1; return i; } } } return -1; } static int ChangeIPAddr(ipaddr1, ipaddr2, atrans) struct ubik_trans *atrans; register afs_uint32 ipaddr1, ipaddr2; { int i, j; afs_int32 code; struct extentaddr *exp; int base, index, mhidx; afsUUID tuuid; afs_int32 blockindex, count; int pollcount; struct nvlentry tentry; if (!atrans) return VL_CREATEFAIL; /* Don't let addr change to 256.*.*.* : Causes internal error below */ if ((ipaddr2 & 0xff000000) == 0xff000000) return(VL_BADSERVER); /* If we are removing an address, ip1 will be -1 and ip2 will be * the original address. This prevents an older revision vlserver * from removing the IP address (won't find server 0xfffffff in * the VLDB). An older revision vlserver does not have the check * to see if any volumes exist on the server being removed. */ if (ipaddr1 == 0xffffffff) { ipaddr1 = ipaddr2; ipaddr2 = 0; } for (i = 0; i <= MAXSERVERID; i++) { if ((HostAddress[i] & 0xff000000) == 0xff000000) { base = (HostAddress[i] >> 16) & 0xff; index = HostAddress[i] & 0x0000ffff; if ((base >= VL_MAX_ADDREXTBLKS) || (index >= VL_MHSRV_PERBLK)) { VLog(0, ("Internal error: Multihome extent addr is too large. Base %d index %d\n", base, index)); return -1; /* EINVAL */ } exp = &ex_addr[base][index]; for (mhidx=0; mhidx < VL_MAXIPADDRS_PERMH; mhidx++) { if (!exp->ex_addrs[mhidx]) continue; if (ntohl(exp->ex_addrs[mhidx]) == ipaddr1) break; } if (mhidx < VL_MAXIPADDRS_PERMH) { break; } } else if (HostAddress[i] == ipaddr1) { exp = (struct extentaddr *)0; break; } } if (i >= MAXSERVERID) { return VL_NOENT; /* not found */ } /* If we are removing a server entry, a volume cannot * exist on the server. If one does, don't remove the * server entry: return error "volume entry exists". */ if (ipaddr2 == 0) { for (blockindex = NextEntry(atrans, 0, &tentry, &count); blockindex; blockindex = NextEntry(atrans, blockindex, &tentry, &count)) { if (++pollcount > 50) { IOMGR_Poll(); pollcount = 0; } for (j=0; jex_addrs[mhidx]) continue; if (mhidx>0) printf(" "); PADDR(ntohl(exp->ex_addrs[mhidx])); } printf("]"); } else { PADDR(ipaddr1); } if (ipaddr2) { printf(" -> "); PADDR(ipaddr2); } printf("\n"); /* Change the registered uuuid addresses */ if (exp) { bzero(&tuuid, sizeof(afsUUID)); afs_htonuuid(&tuuid); exp->ex_hostuuid = tuuid; code = vlwrite(atrans, DOFFSET(ntohl(ex_addr[0]->ex_contaddrs[base]), (char *)ex_addr[base], (char *)exp), (char *)&tuuid, sizeof(tuuid)); if (code) return VL_IO; } /* Now change the host address entry */ cheader.IpMappedAddr[i] = htonl(ipaddr2); code = vlwrite(atrans, DOFFSET(0, &cheader, &cheader.IpMappedAddr[i]), (char *) &cheader.IpMappedAddr[i], sizeof(afs_int32)); HostAddress[i] = ipaddr2; if (code) return VL_IO; return 0; } /* see if the vlserver is back yet */ VL_ProbeServer(rxcall) struct rx_call *rxcall; { return 0; }