自学教程：C++ AFS_STATCNT函数代码示例

intDRead(struct dcache *adc, int page, struct DirBuffer *entry){    /* Read a page from the disk. */    struct buffer *tb, *tb2;    struct osi_file *tfile;    int code;    AFS_STATCNT(DRead);    memset(entry, 0, sizeof(struct DirBuffer));    ObtainWriteLock(&afs_bufferLock, 256);#define bufmatch(tb) (tb->page == page && tb->fid == adc->index)#define buf_Front(head,parent,p) {(parent)->hashNext = (p)->hashNext; (p)->hashNext= *(head);*(head)=(p);}    /* this apparently-complicated-looking code is simply an example of     * a little bit of loop unrolling, and is a standard linked-list     * traversal trick. It saves a few assignments at the the expense     * of larger code size.  This could be simplified by better use of     * macros.     */    if ((tb = phTable[pHash(adc->index, page)])) {	if (bufmatch(tb)) {	    ObtainWriteLock(&tb->lock, 257);	    tb->lockers++;	    ReleaseWriteLock(&afs_bufferLock);	    tb->accesstime = timecounter++;	    AFS_STATS(afs_stats_cmperf.bufHits++);	    ReleaseWriteLock(&tb->lock);	    entry->buffer = tb;	    entry->data = tb->data;	    return 0;	} else {	    struct buffer **bufhead;	    bufhead = &(phTable[pHash(adc->index, page)]);	    while ((tb2 = tb->hashNext)) {		if (bufmatch(tb2)) {		    buf_Front(bufhead, tb, tb2);		    ObtainWriteLock(&tb2->lock, 258);		    tb2->lockers++;		    ReleaseWriteLock(&afs_bufferLock);		    tb2->accesstime = timecounter++;		    AFS_STATS(afs_stats_cmperf.bufHits++);		    ReleaseWriteLock(&tb2->lock);		    entry->buffer = tb2;		    entry->data = tb2->data;		    return 0;		}		if ((tb = tb2->hashNext)) {		    if (bufmatch(tb)) {			buf_Front(bufhead, tb2, tb);			ObtainWriteLock(&tb->lock, 259);			tb->lockers++;			ReleaseWriteLock(&afs_bufferLock);			tb->accesstime = timecounter++;			AFS_STATS(afs_stats_cmperf.bufHits++);			ReleaseWriteLock(&tb->lock);			entry->buffer = tb;			entry->data = tb->data;			return 0;		    }		} else		    break;	    }	}    } else	tb2 = NULL;    AFS_STATS(afs_stats_cmperf.bufMisses++);    /* can't find it */    /* The last thing we looked at was either tb or tb2 (or nothing). That     * is at least the oldest buffer on one particular hash chain, so it's     * a pretty good place to start looking for the truly oldest buffer.     */    tb = afs_newslot(adc, page, (tb ? tb : tb2));    if (!tb) {	ReleaseWriteLock(&afs_bufferLock);	return EIO;    }    ObtainWriteLock(&tb->lock, 260);    tb->lockers++;    ReleaseWriteLock(&afs_bufferLock);    if (page * AFS_BUFFER_PAGESIZE >= adc->f.chunkBytes) {	tb->fid = NULLIDX;	afs_reset_inode(&tb->inode);	tb->lockers--;	ReleaseWriteLock(&tb->lock);	return EIO;    }    tfile = afs_CFileOpen(&adc->f.inode);    code =	afs_CFileRead(tfile, tb->page * AFS_BUFFER_PAGESIZE, tb->data,		      AFS_BUFFER_PAGESIZE);    afs_CFileClose(tfile);    if (code < AFS_BUFFER_PAGESIZE) {	tb->fid = NULLIDX;	afs_reset_inode(&tb->inode);	tb->lockers--;//.........这里部分代码省略.........

/* * afs_TruncateAllSegments * * Description: *	Truncate a cache file. * * Parameters: *	avc  : Ptr to vcache entry to truncate. *	alen : Number of bytes to make the file. *	areq : Ptr to request structure. * * Environment: *	Called with avc write-locked; in VFS40 systems, pvnLock is also *	held. */intafs_TruncateAllSegments(struct vcache *avc, afs_size_t alen,			struct vrequest *areq, afs_ucred_t *acred){    struct dcache *tdc;    afs_int32 code;    afs_int32 index;    afs_size_t newSize;    int dcCount, dcPos;    struct dcache **tdcArray = NULL;    AFS_STATCNT(afs_TruncateAllSegments);    avc->f.m.Date = osi_Time();    afs_Trace3(afs_iclSetp, CM_TRACE_TRUNCALL, ICL_TYPE_POINTER, avc,	       ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length),	       ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(alen));    if (alen >= avc->f.m.Length) {	/*	 * Special speedup since Sun's vm extends the file this way;	 * we've never written to the file thus we can just set the new	 * length and avoid the needless calls below.	 * Also used for ftruncate calls which can extend the file.	 * To completely minimize the possible extra StoreMini RPC, we really	 * should keep the ExtendedPos as well and clear this flag if we	 * truncate below that value before we store the file back.	 */	avc->f.states |= CExtendedFile;	avc->f.m.Length = alen;	return 0;    }#if	(defined(AFS_SUN5_ENV))    /* Zero unused portion of last page */    osi_VM_PreTruncate(avc, alen, acred);#endif#if	(defined(AFS_SUN5_ENV))    ObtainWriteLock(&avc->vlock, 546);    avc->activeV++;		/* Block new getpages */    ReleaseWriteLock(&avc->vlock);#endif    ReleaseWriteLock(&avc->lock);    AFS_GUNLOCK();    /* Flush pages beyond end-of-file. */    osi_VM_Truncate(avc, alen, acred);    AFS_GLOCK();    ObtainWriteLock(&avc->lock, 79);    avc->f.m.Length = alen;    if (alen < avc->f.truncPos)	avc->f.truncPos = alen;    code = DVHash(&avc->f.fid);    /* block out others from screwing with this table */    ObtainWriteLock(&afs_xdcache, 287);    dcCount = 0;    for (index = afs_dvhashTbl[code]; index != NULLIDX;) {	if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {	    tdc = afs_GetValidDSlot(index);	    if (!tdc) {		ReleaseWriteLock(&afs_xdcache);		code = EIO;		goto done;	    }	    ReleaseReadLock(&tdc->tlock);	    if (!FidCmp(&tdc->f.fid, &avc->f.fid))		dcCount++;	    afs_PutDCache(tdc);	}	index = afs_dvnextTbl[index];    }    /* Now allocate space where we can save those dcache entries, and     * do a second pass over them..  Since we're holding xdcache, it     * shouldn't be changing.     */    tdcArray = osi_Alloc(dcCount * sizeof(struct dcache *));    dcPos = 0;//.........这里部分代码省略.........

void *osi_UFSOpen(afs_dcache_id_t *ainode){    struct vnode *vp;    struct vattr va;    struct osi_file *afile = NULL;    extern int cacheDiskType;    afs_int32 code = 0;    int dummy;    char fname[1024];    struct osi_stat tstat;    AFS_STATCNT(osi_UFSOpen);    if (cacheDiskType != AFS_FCACHE_TYPE_UFS) {	osi_Panic("UFSOpen called for non-UFS cache/n");    }    if (!afs_osicred_initialized) {	/* valid for alpha_osf, SunOS, Ultrix */	memset(&afs_osi_cred, 0, sizeof(afs_ucred_t));	afs_osi_cred.cr_ref++;#ifndef AFS_DARWIN110_ENV	afs_osi_cred.cr_ngroups = 1;#endif	afs_osicred_initialized = 1;    }    afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));    AFS_GUNLOCK();#ifdef AFS_CACHE_VNODE_PATH    if (!ainode->ufs) {	osi_Panic("No cache inode/n");    }    code = vnode_open(ainode->ufs, O_RDWR, 0, 0, &vp, afs_osi_ctxtp);#else#ifndef AFS_DARWIN80_ENV    if (afs_CacheFSType == AFS_APPL_HFS_CACHE)	code = igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, &ainode->ufs, &vp, &va, &dummy);	/* XXX hfs is broken */    else if (afs_CacheFSType == AFS_APPL_UFS_CACHE)#endif	code =	    igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t) ainode->ufs,		      &vp, &va, &dummy);#ifndef AFS_DARWIN80_ENV    else	panic("osi_UFSOpen called before cacheops initialized/n");#endif#endif    AFS_GLOCK();    if (code) {	osi_FreeSmallSpace(afile);	osi_Panic("UFSOpen: igetinode failed");    }    afile->vnode = vp;    afile->offset = 0;    afile->proc = (int (*)())0;#ifndef AFS_CACHE_VNODE_PATH    afile->size = va.va_size;#else    code = afs_osi_Stat(afile, &tstat);    afile->size = tstat.size;#endif    return (void *)afile;}

/* free socket allocated by osi_NetSocket */intrxk_FreeSocket(struct socket *asocket){    AFS_STATCNT(osi_FreeSocket);    return 0;}

static intafs_StoreMini(struct vcache *avc, struct vrequest *areq){    struct afs_conn *tc;    struct AFSStoreStatus InStatus;    struct AFSFetchStatus OutStatus;    struct AFSVolSync tsync;    afs_int32 code;    struct rx_call *tcall;    struct rx_connection *rxconn;    afs_size_t tlen, xlen = 0;    XSTATS_DECLS;    AFS_STATCNT(afs_StoreMini);    afs_Trace2(afs_iclSetp, CM_TRACE_STOREMINI, ICL_TYPE_POINTER, avc,	       ICL_TYPE_INT32, avc->f.m.Length);    tlen = avc->f.m.Length;    if (avc->f.truncPos < tlen)	tlen = avc->f.truncPos;    avc->f.truncPos = AFS_NOTRUNC;    avc->f.states &= ~CExtendedFile;    do {	tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);	if (tc) {#ifdef AFS_64BIT_CLIENT	  retry:#endif	    RX_AFS_GUNLOCK();	    tcall = rx_NewCall(rxconn);	    RX_AFS_GLOCK();	    /* Set the client mod time since we always want the file	     * to have the client's mod time and not the server's one	     * (to avoid problems with make, etc.) It almost always	     * works fine with standard afs because them server/client	     * times are in sync and more importantly this storemini	     * it's a special call that would typically be followed by	     * the proper store-data or store-status calls.	     */	    InStatus.Mask = AFS_SETMODTIME;	    InStatus.ClientModTime = avc->f.m.Date;	    XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STOREDATA);	    afs_Trace4(afs_iclSetp, CM_TRACE_STOREDATA64, ICL_TYPE_FID,		       &avc->f.fid.Fid, ICL_TYPE_OFFSET,		       ICL_HANDLE_OFFSET(avc->f.m.Length), ICL_TYPE_OFFSET,		       ICL_HANDLE_OFFSET(xlen), ICL_TYPE_OFFSET,		       ICL_HANDLE_OFFSET(tlen));	    RX_AFS_GUNLOCK();#ifdef AFS_64BIT_CLIENT	    if (!afs_serverHasNo64Bit(tc)) {		code =		    StartRXAFS_StoreData64(tcall,					   (struct AFSFid *)&avc->f.fid.Fid,					   &InStatus, avc->f.m.Length,					   (afs_size_t) 0, tlen);	    } else {		afs_int32 l1, l2;		l1 = avc->f.m.Length;		l2 = tlen;		if ((avc->f.m.Length > 0x7fffffff) ||		    (tlen > 0x7fffffff) ||		    ((0x7fffffff - tlen) < avc->f.m.Length)) {		    code = EFBIG;		    goto error;		}		code =		    StartRXAFS_StoreData(tcall,					 (struct AFSFid *)&avc->f.fid.Fid,					 &InStatus, l1, 0, l2);	    }#else /* AFS_64BIT_CLIENT */	    code =		StartRXAFS_StoreData(tcall, (struct AFSFid *)&avc->f.fid.Fid,				     &InStatus, avc->f.m.Length, 0, tlen);#endif /* AFS_64BIT_CLIENT */	    if (code == 0) {		code = EndRXAFS_StoreData(tcall, &OutStatus, &tsync);	    }#ifdef AFS_64BIT_CLIENT	error:#endif	    code = rx_EndCall(tcall, code);	    RX_AFS_GLOCK();	    XSTATS_END_TIME;#ifdef AFS_64BIT_CLIENT	    if (code == RXGEN_OPCODE && !afs_serverHasNo64Bit(tc)) {		afs_serverSetNo64Bit(tc);		goto retry;	    }#endif /* AFS_64BIT_CLIENT */	} else	    code = -1;    } while (afs_Analyze	     (tc, rxconn, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_STOREDATA,	      SHARED_LOCK, NULL));    if (code == 0)	afs_ProcessFS(avc, &OutStatus, areq);    return code;}				/*afs_StoreMini */

intafs_sync(struct vfs *afsp){    AFS_STATCNT(afs_sync);    return 0;}

afs_open(struct vcache **avcp, afs_int32 aflags, afs_ucred_t *acred)#endif{    afs_int32 code;    struct vrequest treq;    struct vcache *tvc;    int writing;    struct afs_fakestat_state fakestate;    AFS_STATCNT(afs_open);    if ((code = afs_InitReq(&treq, acred)))	return code;#ifdef AFS_SGI64_ENV    /* avcpp can be, but is not necesarily, bhp's vnode. */    tvc = VTOAFS(BHV_TO_VNODE(bhv));#else    tvc = *avcp;#endif    afs_Trace2(afs_iclSetp, CM_TRACE_OPEN, ICL_TYPE_POINTER, tvc,	       ICL_TYPE_INT32, aflags);    afs_InitFakeStat(&fakestate);    AFS_DISCON_LOCK();    code = afs_EvalFakeStat(&tvc, &fakestate, &treq);    if (code)	goto done;    code = afs_VerifyVCache(tvc, &treq);    if (code)	goto done;    ObtainReadLock(&tvc->lock);    if (AFS_IS_DISCONNECTED && (afs_DCacheMissingChunks(tvc) != 0)) {       ReleaseReadLock(&tvc->lock);       /* printf("Network is down in afs_open: missing chunks/n"); */       code = ENETDOWN;       goto done;    }    ReleaseReadLock(&tvc->lock);    if (aflags & (FWRITE | FTRUNC))	writing = 1;    else	writing = 0;    if (vType(tvc) == VDIR) {	/* directory */	if (writing) {	    code = EISDIR;	    goto done;	} else {	    if (!afs_AccessOK		(tvc, ((tvc->f.states & CForeign) ? PRSFS_READ : PRSFS_LOOKUP),		 &treq, CHECK_MODE_BITS)) {		code = EACCES;		/* printf("afs_Open: no access for dir/n"); */		goto done;	    }	}    } else {#ifdef	AFS_SUN5_ENV	if (AFS_NFSXLATORREQ(acred) && (aflags & FREAD)) {	    if (!afs_AccessOK		(tvc, PRSFS_READ, &treq,		 CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {		code = EACCES;		goto done;	    }	}#endif#ifdef	AFS_AIX41_ENV	if (aflags & FRSHARE) {	    /*	     * Hack for AIX 4.1:	     *  Apparently it is possible for a file to get mapped without	     *  either VNOP_MAP or VNOP_RDWR being called, if (1) it is a	     *  sharable library, and (2) it has already been loaded.  We must	     *  ensure that the credp is up to date.  We detect the situation	     *  by checking for O_RSHARE at open time.	     */	    /*	     * We keep the caller's credentials since an async daemon will	     * handle the request at some point. We assume that the same	     * credentials will be used.	     */	    ObtainWriteLock(&tvc->lock, 140);	    if (!tvc->credp || (tvc->credp != acred)) {		crhold(acred);		if (tvc->credp) {		    struct ucred *crp = tvc->credp;		    tvc->credp = NULL;		    crfree(crp);		}		tvc->credp = acred;	    }	    ReleaseWriteLock(&tvc->lock);	}#endif	/* normal file or symlink *///.........这里部分代码省略.........

int afspag_PSetTokens(char *ain, afs_int32 ainSize, struct AFS_UCRED **acred){    afs_int32 i;    register struct unixuser *tu;    struct afspag_cell *tcell;    struct ClearToken clear;    char *stp;    int stLen;    afs_int32 flag, set_parent_pag = 0;    afs_int32 pag, uid;    AFS_STATCNT(PSetTokens);    if (!afs_resourceinit_flag) {	return EIO;    }    memcpy((char *)&i, ain, sizeof(afs_int32));    ain += sizeof(afs_int32);    stp = ain;			/* remember where the ticket is */    if (i < 0 || i > MAXKTCTICKETLEN)	return EINVAL;		/* malloc may fail */    stLen = i;    ain += i;			/* skip over ticket */    memcpy((char *)&i, ain, sizeof(afs_int32));    ain += sizeof(afs_int32);    if (i != sizeof(struct ClearToken)) {	return EINVAL;    }    memcpy((char *)&clear, ain, sizeof(struct ClearToken));    if (clear.AuthHandle == -1)	clear.AuthHandle = 999;	/* more rxvab compat stuff */    ain += sizeof(struct ClearToken);    if (ainSize != 2 * sizeof(afs_int32) + stLen + sizeof(struct ClearToken)) {	/* still stuff left?  we've got primary flag and cell name.  Set these */	memcpy((char *)&flag, ain, sizeof(afs_int32));	/* primary id flag */	ain += sizeof(afs_int32);	/* skip id field */	/* rest is cell name, look it up */	/* some versions of gcc appear to need != 0 in order to get this right */	if ((flag & 0x8000) != 0) {	/* XXX Use Constant XXX */	    flag &= ~0x8000;	    set_parent_pag = 1;	}	tcell = afspag_GetCell(ain);    } else {	/* default to primary cell, primary id */	flag = 1;		/* primary id */	tcell = afspag_GetPrimaryCell();    }    if (!tcell) return ESRCH;    if (set_parent_pag) {#if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)#if defined(AFS_DARWIN_ENV)	struct proc *p = current_proc();	/* XXX */#else	struct proc *p = curproc;	/* XXX */#endif#ifndef AFS_DARWIN80_ENV	uprintf("Process %d (%s) tried to change pags in PSetTokens/n",		p->p_pid, p->p_comm);#endif	setpag(p, acred, -1, &pag, 1);#else#ifdef	AFS_OSF_ENV	setpag(u.u_procp, acred, -1, &pag, 1);	/* XXX u.u_procp is a no-op XXX */#else	setpag(acred, -1, &pag, 1);#endif#endif    }    pag = PagInCred(*acred);    uid = (pag == NOPAG) ? (*acred)->cr_uid : pag;    /* now we just set the tokens */    tu = afs_GetUser(uid, tcell->cellnum, WRITE_LOCK);    if (!tu->cellinfo)	tu->cellinfo = (void *)tcell;    tu->vid = clear.ViceId;    if (tu->stp != NULL) {	afs_osi_Free(tu->stp, tu->stLen);    }    tu->stp = (char *)afs_osi_Alloc(stLen);    tu->stLen = stLen;    memcpy(tu->stp, stp, stLen);    tu->ct = clear;#ifndef AFS_NOSTATS    afs_stats_cmfullperf.authent.TicketUpdates++;    afs_ComputePAGStats();#endif /* AFS_NOSTATS */    tu->states |= UHasTokens;    tu->states &= ~UTokensBad;    afs_SetPrimary(tu, flag);    tu->tokenTime = osi_Time();    afs_PutUser(tu, WRITE_LOCK);    return 0;}

/*------------------------------------------------------------------------ * EXPORTED afs_Analyze * * Description: *	Analyze the outcome of an RPC operation, taking whatever support *	actions are necessary. * * Arguments: *	aconn : Ptr to the relevant connection on which the call was made. *	acode : The return code experienced by the RPC. *	afid  : The FID of the file involved in the action.  This argument *		may be null if none was involved. *	areq  : The request record associated with this operation. *      op    : which RPC we are analyzing. *      cellp : pointer to a cell struct.  Must provide either fid or cell. * * Returns: *	Non-zero value if the related RPC operation should be retried, *	zero otherwise. * * Environment: *	This routine is typically called in a do-while loop, causing the *	embedded RPC operation to be called repeatedly if appropriate *	until whatever error condition (if any) is intolerable. * * Side Effects: *	As advertised. * * NOTE: *	The retry return value is used by afs_StoreAllSegments to determine *	if this is a temporary or permanent error. *------------------------------------------------------------------------*/intafs_Analyze(register struct afs_conn *aconn, afs_int32 acode,	    struct VenusFid *afid, register struct vrequest *areq, int op,	    afs_int32 locktype, struct cell *cellp){    afs_int32 i;    struct srvAddr *sa;    struct server *tsp;    struct volume *tvp;    afs_int32 shouldRetry = 0;    afs_int32 serversleft = 1;    struct afs_stats_RPCErrors *aerrP;    afs_int32 markeddown;      if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {	/* On reconnection, act as connected. XXX: for now.... */        /* SXW - This may get very tired after a while. We should try and	 *       intercept all RPCs before they get here ... */	/*printf("afs_Analyze: disconnected/n");*/	afs_FinalizeReq(areq);	if (aconn) {	    /* SXW - I suspect that this will _never_ happen - we shouldn't	     *       get a connection because we're disconnected !!!*/	    afs_PutConn(aconn, locktype);	}	return 0;    }        AFS_STATCNT(afs_Analyze);    afs_Trace4(afs_iclSetp, CM_TRACE_ANALYZE, ICL_TYPE_INT32, op,	       ICL_TYPE_POINTER, aconn, ICL_TYPE_INT32, acode, ICL_TYPE_LONG,	       areq->uid);    aerrP = (struct afs_stats_RPCErrors *)0;    if ((op >= 0) && (op < AFS_STATS_NUM_FS_RPC_OPS))	aerrP = &(afs_stats_cmfullperf.rpc.fsRPCErrors[op]);    afs_FinalizeReq(areq);    if (!aconn && areq->busyCount) {	/* one RPC or more got VBUSY/VRESTARTING */	tvp = afs_FindVolume(afid, READ_LOCK);	if (tvp) {	    afs_warnuser("afs: Waiting for busy volume %u (%s) in cell %s/n",			 (afid ? afid->Fid.Volume : 0),			 (tvp->name ? tvp->name : ""),			 ((tvp->serverHost[0]			   && tvp->serverHost[0]->cell) ? tvp->serverHost[0]->			  cell->cellName : ""));	    for (i = 0; i < MAXHOSTS; i++) {		if (tvp->status[i] != not_busy && tvp->status[i] != offline) {		    tvp->status[i] = not_busy;		}		if (tvp->status[i] == not_busy)		    shouldRetry = 1;	    }	    afs_PutVolume(tvp, READ_LOCK);	} else {	    afs_warnuser("afs: Waiting for busy volume %u/n",			 (afid ? afid->Fid.Volume : 0));	}	if (areq->busyCount > 100) {	    if (aerrP)		(aerrP->err_Volume)++;//.........这里部分代码省略.........

static intVLDB_Same(struct VenusFid *afid, struct vrequest *areq){    struct vrequest treq;    struct afs_conn *tconn;    int i, type = 0;    union {	struct vldbentry tve;	struct nvldbentry ntve;	struct uvldbentry utve;    } *v;    struct volume *tvp;    struct cell *tcell;    char *bp, tbuf[CVBS];	/* biggest volume id is 2^32, ~ 4*10^9 */    unsigned int changed;    struct server *(oldhosts[NMAXNSERVERS]);    AFS_STATCNT(CheckVLDB);    afs_FinalizeReq(areq);    if ((i = afs_InitReq(&treq, afs_osi_credp)))	return DUNNO;    v = afs_osi_Alloc(sizeof(*v));    tcell = afs_GetCell(afid->Cell, READ_LOCK);    bp = afs_cv2string(&tbuf[CVBS], afid->Fid.Volume);    do {	VSleep(2);		/* Better safe than sorry. */	tconn =	    afs_ConnByMHosts(tcell->cellHosts, tcell->vlport, tcell->cellNum,			     &treq, SHARED_LOCK);	if (tconn) {	    if (tconn->srvr->server->flags & SNO_LHOSTS) {		type = 0;		RX_AFS_GUNLOCK();		i = VL_GetEntryByNameO(tconn->id, bp, &v->tve);		RX_AFS_GLOCK();	    } else if (tconn->srvr->server->flags & SYES_LHOSTS) {		type = 1;		RX_AFS_GUNLOCK();		i = VL_GetEntryByNameN(tconn->id, bp, &v->ntve);		RX_AFS_GLOCK();	    } else {		type = 2;		RX_AFS_GUNLOCK();		i = VL_GetEntryByNameU(tconn->id, bp, &v->utve);		RX_AFS_GLOCK();		if (!(tconn->srvr->server->flags & SVLSRV_UUID)) {		    if (i == RXGEN_OPCODE) {			type = 1;			RX_AFS_GUNLOCK();			i = VL_GetEntryByNameN(tconn->id, bp, &v->ntve);			RX_AFS_GLOCK();			if (i == RXGEN_OPCODE) {			    type = 0;			    tconn->srvr->server->flags |= SNO_LHOSTS;			    RX_AFS_GUNLOCK();			    i = VL_GetEntryByNameO(tconn->id, bp, &v->tve);			    RX_AFS_GLOCK();			} else if (!i)			    tconn->srvr->server->flags |= SYES_LHOSTS;		    } else if (!i)			tconn->srvr->server->flags |= SVLSRV_UUID;		}		lastcode = i;	    }	} else	    i = -1;    } while (afs_Analyze(tconn, i, NULL, &treq, -1,	/* no op code for this */			 SHARED_LOCK, tcell));    afs_PutCell(tcell, READ_LOCK);    afs_Trace2(afs_iclSetp, CM_TRACE_CHECKVLDB, ICL_TYPE_FID, &afid,	       ICL_TYPE_INT32, i);    if (i) {	afs_osi_Free(v, sizeof(*v));	return DUNNO;    }    /* have info, copy into serverHost array */    changed = 0;    tvp = afs_FindVolume(afid, WRITE_LOCK);    if (tvp) {	ObtainWriteLock(&tvp->lock, 107);	for (i = 0; i < NMAXNSERVERS && tvp->serverHost[i]; i++) {	    oldhosts[i] = tvp->serverHost[i];	}	if (type == 2) {	    InstallUVolumeEntry(tvp, &v->utve, afid->Cell, tcell, &treq);	} else if (type == 1) {	    InstallNVolumeEntry(tvp, &v->ntve, afid->Cell);	} else {	    InstallVolumeEntry(tvp, &v->tve, afid->Cell);	}	if (i < NMAXNSERVERS && tvp->serverHost[i]) {	    changed = 1;	}	for (--i; !changed && i >= 0; i--) {	    if (tvp->serverHost[i] != oldhosts[i]) {//.........这里部分代码省略.........

/* lp is pointer to a fairly-old buffer */static struct buffer *afs_newslot(struct dcache *adc, afs_int32 apage, struct buffer *lp){    /* Find a usable buffer slot */    afs_int32 i;    afs_int32 lt = 0;    struct buffer *tp;    struct osi_file *tfile;    AFS_STATCNT(afs_newslot);    /* we take a pointer here to a buffer which was at the end of an     * LRU hash chain.  Odds are, it's one of the older buffers, not     * one of the newer.  Having an older buffer to start with may     * permit us to avoid a few of the assignments in the "typical     * case" for loop below.     */    if (lp && (lp->lockers == 0)) {	lt = lp->accesstime;    } else {	lp = NULL;    }    /* timecounter might have wrapped, if machine is very very busy     * and stays up for a long time.  Timecounter mustn't wrap twice     * (positive->negative->positive) before calling newslot, but that     * would require 2 billion consecutive cache hits... Anyway, the     * penalty is only that the cache replacement policy will be     * almost MRU for the next ~2 billion DReads...  newslot doesn't     * get called nearly as often as DRead, so in order to avoid the     * performance penalty of using the hypers, it's worth doing the     * extra check here every time.  It's probably cheaper than doing     * hcmp, anyway.  There is a little performance hit resulting from     * resetting all the access times to 0, but it only happens once     * every month or so, and the access times will rapidly sort     * themselves back out after just a few more DReads.     */    if (timecounter < 0) {	timecounter = 1;	tp = Buffers;	for (i = 0; i < nbuffers; i++, tp++) {	    tp->accesstime = 0;	    if (!lp && !tp->lockers)	/* one is as good as the rest, I guess */		lp = tp;	}    } else {	/* this is the typical case */	tp = Buffers;	for (i = 0; i < nbuffers; i++, tp++) {	    if (tp->lockers == 0) {		if (!lp || tp->accesstime < lt) {		    lp = tp;		    lt = tp->accesstime;		}	    }	}    }    if (lp == 0) {	/* No unlocked buffers. If still possible, allocate a new increment */	if (nbuffers + NPB > afs_max_buffers) {	    /* There are no unlocked buffers -- this used to panic, but that	     * seems extreme.  To the best of my knowledge, all the callers	     * of DRead are prepared to handle a zero return.  Some of them	     * just panic directly, but not all of them. */	    afs_warn("afs: all buffers locked/n");	    return 0;	}	BufferData = afs_osi_Alloc(AFS_BUFFER_PAGESIZE * NPB);	osi_Assert(BufferData != NULL);	for (i = 0; i< NPB; i++) {	    /* Fill in each buffer with an empty indication. */	    tp = &Buffers[i + nbuffers];	    tp->fid = NULLIDX;	    afs_reset_inode(&tp->inode);	    tp->accesstime = 0;	    tp->lockers = 0;	    tp->data = &BufferData[AFS_BUFFER_PAGESIZE * i];	    tp->hashIndex = 0;	    tp->dirty = 0;	    AFS_RWLOCK_INIT(&tp->lock, "buffer lock");	}	lp = &Buffers[nbuffers];	nbuffers += NPB;    }    if (lp->dirty) {	/* see DFlush for rationale for not getting and locking the dcache */        tfile = afs_CFileOpen(&lp->inode);	afs_CFileWrite(tfile, lp->page * AFS_BUFFER_PAGESIZE, lp->data,		       AFS_BUFFER_PAGESIZE);	lp->dirty = 0;	afs_CFileClose(tfile);	AFS_STATS(afs_stats_cmperf.bufFlushDirty++);    }    /* Now fill in the header. */    lp->fid = adc->index;    afs_copy_inode(&lp->inode, &adc->f.inode);//.........这里部分代码省略.........

intafs_mountroot(void){    AFS_STATCNT(afs_mountroot);    return (EINVAL);}

afs_fid(OSI_VC_DECL(avc), struct fid **fidpp)#endif				/* AFS_AIX41_ENV */{    struct SmallFid Sfid;    long addr[2];    register struct cell *tcell;    extern struct vcache *afs_globalVp;    int SizeOfSmallFid = SIZEOF_SMALLFID;    int rootvp = 0;    OSI_VC_CONVERT(avc);    AFS_STATCNT(afs_fid);    if (afs_shuttingdown)	return EIO;    if (afs_NFSRootOnly && (avc == afs_globalVp))	rootvp = 1;    if (!afs_NFSRootOnly || rootvp#ifdef AFS_AIX41_ENV	|| USE_SMALLFID(credp)#endif	) {	tcell = afs_GetCell(avc->f.fid.Cell, READ_LOCK);	Sfid.Volume = avc->f.fid.Fid.Volume;	Sfid.Vnode = avc->f.fid.Fid.Vnode;	Sfid.CellAndUnique =	    ((tcell->cellIndex << 24) + (avc->f.fid.Fid.Unique & 0xffffff));	afs_PutCell(tcell, READ_LOCK);	if (avc->f.fid.Fid.Vnode > 0xffff)	    afs_fid_vnodeoverflow++;	if (avc->f.fid.Fid.Unique > 0xffffff)	    afs_fid_uniqueoverflow++;    } else {#if defined(AFS_SUN57_64BIT_ENV) || (defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64))	addr[1] = (long)AFS_XLATOR_MAGIC << 48;#else /* defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64) */	addr[1] = AFS_XLATOR_MAGIC;	SizeOfSmallFid = sizeof(addr);#endif /* defined(AFS_SGI61_ENV) && (_MIPS_SZPTR == 64) */	addr[0] = (long)avc;#ifndef AFS_AIX41_ENV	/* No post processing, so don't hold ref count. */	AFS_FAST_HOLD(avc);#endif    }#if	defined(AFS_AIX_ENV) || defined(AFS_SUN54_ENV)    /* Use the fid pointer passed to us. */    fidpp->fid_len = SizeOfSmallFid;    if (afs_NFSRootOnly) {	if (rootvp#ifdef AFS_AIX41_ENV	    || USE_SMALLFID(credp)#endif	    ) {	    memcpy(fidpp->fid_data, (caddr_t) & Sfid, SizeOfSmallFid);	} else {	    memcpy(fidpp->fid_data, (caddr_t) addr, SizeOfSmallFid);	}    } else {	memcpy(fidpp->fid_data, (caddr_t) & Sfid, SizeOfSmallFid);    }#else    /* malloc a fid pointer ourselves. */    *fidpp = (struct fid *)AFS_KALLOC(SizeOfSmallFid + 2);    (*fidpp)->fid_len = SizeOfSmallFid;    if (afs_NFSRootOnly) {	if (rootvp) {	    memcpy((*fidpp)->fid_data, (char *)&Sfid, SizeOfSmallFid);	} else {	    memcpy((*fidpp)->fid_data, (char *)addr, SizeOfSmallFid);	}    } else {	memcpy((*fidpp)->fid_data, (char *)&Sfid, SizeOfSmallFid);    }#endif    return (0);}

intafs_swapvp(void){    AFS_STATCNT(afs_swapvp);    return (EINVAL);}

/*! * Create or update a cell entry. * /param acellName Name of cell. * /param acellHosts Array of hosts that this cell has. * /param aflags Cell flags. * /param linkedcname * /param fsport File server port. * /param vlport Volume server port. * /param timeout Cell timeout value, 0 means static AFSDB entry. * /return */afs_int32afs_NewCell(char *acellName, afs_int32 * acellHosts, int aflags,	    char *linkedcname, u_short fsport, u_short vlport, int timeout){    struct cell *tc, *tcl = 0;    afs_int32 i, newc = 0, code = 0;    AFS_STATCNT(afs_NewCell);    ObtainWriteLock(&afs_xcell, 103);    tc = afs_FindCellByName_nl(acellName, READ_LOCK);    if (tc) {	aflags &= ~CNoSUID;    } else {	tc = afs_osi_Alloc(sizeof(struct cell));	osi_Assert(tc != NULL);	memset(tc, 0, sizeof(*tc));	tc->cellName = afs_strdup(acellName);	tc->fsport = AFS_FSPORT;	tc->vlport = AFS_VLPORT;	AFS_MD5_String(tc->cellHandle, tc->cellName, strlen(tc->cellName));	AFS_RWLOCK_INIT(&tc->lock, "cell lock");	newc = 1;	aflags |= CNoSUID;    }    ObtainWriteLock(&tc->lock, 688);    /* If the cell we've found has the correct name but no timeout,     * and we're called with a non-zero timeout, bail out:  never     * override static configuration entries with AFSDB ones.     * One exception: if the original cell entry had no servers,     * it must get servers from AFSDB.     */    if (timeout && !tc->timeout && tc->cellHosts[0]) {	code = EEXIST;		/* This code is checked for in afs_LookupAFSDB */	goto bad;    }    /* we don't want to keep pinging old vlservers which were down,     * since they don't matter any more.  It's easier to do this than     * to remove the server from its various hash tables. */    for (i = 0; i < AFS_MAXCELLHOSTS; i++) {	if (!tc->cellHosts[i])	    break;	tc->cellHosts[i]->flags &= ~SRVR_ISDOWN;	tc->cellHosts[i]->flags |= SRVR_ISGONE;    }    if (fsport)	tc->fsport = fsport;    if (vlport)	tc->vlport = vlport;    if (aflags & CLinkedCell) {	if (!linkedcname) {	    code = EINVAL;	    goto bad;	}	tcl = afs_FindCellByName_nl(linkedcname, READ_LOCK);	if (!tcl) {	    code = ENOENT;	    goto bad;	}	if (tcl->lcellp) {	/* XXX Overwriting if one existed before! XXX */	    tcl->lcellp->lcellp = (struct cell *)0;	    tcl->lcellp->states &= ~CLinkedCell;	}	tc->lcellp = tcl;	tcl->lcellp = tc;    }    tc->states |= aflags;    tc->timeout = timeout;    memset(tc->cellHosts, 0, sizeof(tc->cellHosts));    for (i = 0; i < AFS_MAXCELLHOSTS; i++) {	/* Get server for each host and link this cell in.*/	struct server *ts;	afs_uint32 temp = acellHosts[i];	if (!temp)	    break;	ts = afs_GetServer(&temp, 1, 0, tc->vlport, WRITE_LOCK, NULL, 0);	ts->cell = tc;	ts->flags &= ~SRVR_ISGONE;	/* Set the server as a host of the new cell. */	tc->cellHosts[i] = ts;	afs_PutServer(ts, WRITE_LOCK);    }    afs_SortServers(tc->cellHosts, AFS_MAXCELLHOSTS);	/* randomize servers *///.........这里部分代码省略.........

afs_root(struct mount *mp, struct vnode **vpp)#endif{    int error;    struct vrequest treq;    register struct vcache *tvp = 0;#ifdef AFS_FBSD50_ENV#ifndef AFS_FBSD53_ENV    struct thread *td = curthread;#endif    struct ucred *cr = td->td_ucred;#else    struct proc *p = curproc;    struct ucred *cr = p->p_cred->pc_ucred;#endif    AFS_GLOCK();    AFS_STATCNT(afs_root);    crhold(cr);    if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {	tvp = afs_globalVp;	error = 0;    } else {tryagain:#ifndef AFS_FBSD80_ENV	if (afs_globalVp) {	    afs_PutVCache(afs_globalVp);	    /* vrele() needed here or not? */	    afs_globalVp = NULL;	}#endif	if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {	    tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);	    /* we really want this to stay around */	    if (tvp)		afs_globalVp = tvp;	    else		error = ENOENT;	}    }    if (tvp) {	struct vnode *vp = AFSTOV(tvp);#ifdef AFS_FBSD50_ENV	ASSERT_VI_UNLOCKED(vp, "afs_root");#endif	AFS_GUNLOCK();	/*	 * I'm uncomfortable about this.  Shouldn't this happen at a	 * higher level, and shouldn't we busy the top-level directory	 * to prevent recycling?	 */#ifdef AFS_FBSD50_ENV	error = vget(vp, LK_EXCLUSIVE | LK_RETRY, td);	vp->v_vflag |= VV_ROOT;#else	error = vget(vp, LK_EXCLUSIVE | LK_RETRY, p);	vp->v_flag |= VROOT;#endif	AFS_GLOCK();	if (error != 0)		goto tryagain;	afs_globalVFS = mp;	*vpp = vp;    }    afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, tvp ? AFSTOV(tvp) : NULL,	       ICL_TYPE_INT32, error);    AFS_GUNLOCK();    crfree(cr);    return error;}

intafs_MemRead(struct vcache *avc, struct uio *auio,	    afs_ucred_t *acred, daddr_t albn, struct buf **abpp,	    int noLock){    afs_size_t totalLength;    afs_size_t transferLength;    afs_size_t filePos;    afs_size_t offset, tlen;    afs_size_t len = 0;    afs_int32 trimlen;    struct dcache *tdc = 0;    afs_int32 error, trybusy = 1;    afs_int32 code;    struct vrequest *treq = NULL;#ifdef AFS_DARWIN80_ENV    uio_t tuiop = NULL;#else    struct uio tuio;    struct uio *tuiop = &tuio;    struct iovec *tvec;    memset(&tuio, 0, sizeof(tuio));#endif    AFS_STATCNT(afs_MemRead);    if (avc->vc_error)	return EIO;    /* check that we have the latest status info in the vnode cache */    if ((code = afs_CreateReq(&treq, acred)))	return code;    if (!noLock) {	code = afs_VerifyVCache(avc, treq);	if (code) {	    code = afs_CheckCode(code, treq, 8);	/* failed to get it */	    afs_DestroyReq(treq);	    return code;	}    }#ifndef	AFS_VM_RDWR_ENV    if (AFS_NFSXLATORREQ(acred)) {	if (!afs_AccessOK	    (avc, PRSFS_READ, treq,	     CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {	    code = afs_CheckCode(EACCES, treq, 9);	    afs_DestroyReq(treq);	    return code;	}    }#endif#ifndef AFS_DARWIN80_ENV    tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));    memset(tvec, 0, sizeof(struct iovec));#endif    totalLength = AFS_UIO_RESID(auio);    filePos = AFS_UIO_OFFSET(auio);    afs_Trace4(afs_iclSetp, CM_TRACE_READ, ICL_TYPE_POINTER, avc,	       ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_INT32,	       totalLength, ICL_TYPE_OFFSET,	       ICL_HANDLE_OFFSET(avc->f.m.Length));    error = 0;    transferLength = 0;    if (!noLock)	ObtainReadLock(&avc->lock);#if	defined(AFS_TEXT_ENV) && !defined(AFS_VM_RDWR_ENV)    if (avc->flushDV.high == AFS_MAXDV && avc->flushDV.low == AFS_MAXDV) {	hset(avc->flushDV, avc->f.m.DataVersion);    }#endif    /*     * Locks held:     * avc->lock(R)     */    /* This bit is bogus. We're checking to see if the read goes past the     * end of the file. If so, we should be zeroing out all of the buffers     * that the client has passed into us (there is a danger that we may leak     * kernel memory if we do not). However, this behaviour is disabled by     * not setting len before this segment runs, and by setting len to 0     * immediately we enter it. In addition, we also need to check for a read     * which partially goes off the end of the file in the while loop below.     */    if (filePos >= avc->f.m.Length) {	if (len > AFS_ZEROS)	    len = sizeof(afs_zeros);	/* and in 0 buffer */	len = 0;#ifdef AFS_DARWIN80_ENV	trimlen = len;	tuiop = afsio_darwin_partialcopy(auio, trimlen);#else	afsio_copy(auio, &tuio, tvec);	trimlen = len;	afsio_trim(&tuio, trimlen);#endif	AFS_UIOMOVE(afs_zeros, trimlen, UIO_READ, tuiop, code);    }//.........这里部分代码省略.........

/* question: does afs_create need to set CDirty in the adp or the avc? * I think we can get away without it, but I'm not sure.  Note that * afs_setattr is called in here for truncation. */#ifdef AFS_SGI64_ENVintafs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs, int flags,	   int amode, struct vcache **avcp, afs_ucred_t *acred)#else /* AFS_SGI64_ENV */intafs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,	   enum vcexcl aexcl, int amode, struct vcache **avcp,	   afs_ucred_t *acred)#endif				/* AFS_SGI64_ENV */{    afs_int32 origCBs, origZaps, finalZaps;    struct vrequest *treq = NULL;    afs_int32 code;    struct afs_conn *tc;    struct VenusFid newFid;    struct AFSStoreStatus InStatus;    struct AFSFetchStatus *OutFidStatus, *OutDirStatus;    struct AFSVolSync tsync;    struct AFSCallBack CallBack;    afs_int32 now;    struct dcache *tdc;    afs_size_t offset, len;    struct server *hostp = 0;    struct vcache *tvc;    struct volume *volp = 0;    struct afs_fakestat_state fakestate;    struct rx_connection *rxconn;    XSTATS_DECLS;    OSI_VC_CONVERT(adp);    AFS_STATCNT(afs_create);    OutFidStatus = osi_AllocSmallSpace(sizeof(struct AFSFetchStatus));    OutDirStatus = osi_AllocSmallSpace(sizeof(struct AFSFetchStatus));    memset(&InStatus, 0, sizeof(InStatus));    if ((code = afs_CreateReq(&treq, acred)))	goto done2;    afs_Trace3(afs_iclSetp, CM_TRACE_CREATE, ICL_TYPE_POINTER, adp,	       ICL_TYPE_STRING, aname, ICL_TYPE_INT32, amode);    afs_InitFakeStat(&fakestate);#ifdef AFS_SGI65_ENV    /* If avcp is passed not null, it's the old reference to this file.     * We can use this to avoid create races. For now, just decrement     * the reference count on it.     */    if (*avcp) {	AFS_RELE(AFSTOV(*avcp));	*avcp = NULL;    }#endif    if (strlen(aname) > AFSNAMEMAX) {	code = ENAMETOOLONG;	goto done3;    }    if (!afs_ENameOK(aname)) {	code = EINVAL;	goto done3;    }    switch (attrs->va_type) {    case VBLK:    case VCHR:#if	!defined(AFS_SUN5_ENV)    case VSOCK:#endif    case VFIFO:	/* We don't support special devices or FIFOs */	code = EINVAL;	goto done3;    default:	;    }    AFS_DISCON_LOCK();    code = afs_EvalFakeStat(&adp, &fakestate, treq);    if (code)	goto done;  tagain:    code = afs_VerifyVCache(adp, treq);    if (code)	goto done;    /** If the volume is read-only, return error without making an RPC to the      * fileserver      */    if (adp->f.states & CRO) {	code = EROFS;	goto done;    }//.........这里部分代码省略.........

intafs_StoreAllSegments(struct vcache *avc, struct vrequest *areq,		     int sync){    struct dcache *tdc;    afs_int32 code = 0;    afs_int32 index;    afs_int32 origCBs, foreign = 0;    int hash;    afs_hyper_t newDV, oldDV;	/* DV when we start, and finish, respectively */    struct dcache **dcList;    unsigned int i, j, minj, moredata, high, off;    afs_size_t maxStoredLength;	/* highest offset we've written to server. */    int safety, marineronce = 0;    AFS_STATCNT(afs_StoreAllSegments);    hset(oldDV, avc->f.m.DataVersion);    hset(newDV, avc->f.m.DataVersion);    hash = DVHash(&avc->f.fid);    foreign = (avc->f.states & CForeign);    dcList = osi_AllocLargeSpace(AFS_LRALLOCSIZ);    afs_Trace2(afs_iclSetp, CM_TRACE_STOREALL, ICL_TYPE_POINTER, avc,	       ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));#if !defined(AFS_AIX32_ENV) && !defined(AFS_SGI65_ENV)    /* In the aix vm implementation we need to do the vm_writep even     * on the memcache case since that's we adjust the file's size     * and finish flushing partial vm pages.     */    if ((cacheDiskType != AFS_FCACHE_TYPE_MEM) ||	(sync & AFS_VMSYNC_INVAL) || (sync & AFS_VMSYNC) ||	(sync & AFS_LASTSTORE))#endif /* !AFS_AIX32_ENV && !AFS_SGI65_ENV */    {	/* If we're not diskless, reading a file may stress the VM	 * system enough to cause a pageout, and this vnode would be	 * locked when the pageout occurs.  We can prevent this problem	 * by making sure all dirty pages are already flushed.  We don't	 * do this when diskless because reading a diskless (i.e.	 * memory-resident) chunk doesn't require using new VM, and we	 * also don't want to dump more dirty data into a diskless cache,	 * since they're smaller, and we might exceed its available	 * space.	 */#if	defined(AFS_SUN5_ENV)	if (sync & AFS_VMSYNC_INVAL)	/* invalidate VM pages */	    osi_VM_TryToSmush(avc, CRED(), 1);	else#endif	    osi_VM_StoreAllSegments(avc);    }    if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {	/* This will probably make someone sad ... */	/*printf("Net down in afs_StoreSegments/n");*/	return ENETDOWN;    }    ConvertWToSLock(&avc->lock);    /*     * Subsequent code expects a sorted list, and it expects all the     * chunks in the list to be contiguous, so we need a sort and a     * while loop in here, too - but this will work for a first pass...     * 92.10.05 - OK, there's a sort in here now.  It's kind of a modified     *            bin sort, I guess.  Chunk numbers start with 0     *     * - Have to get a write lock on xdcache because GetDSlot might need it (if     *   the chunk doesn't have a dcache struct).     *   This seems like overkill in most cases.     * - I'm not sure that it's safe to do "index = .hvNextp", then unlock     *   xdcache, then relock xdcache and try to use index.  It is done     *   a lot elsewhere in the CM, but I'm not buying that argument.     * - should be able to check IFDataMod without doing the GetDSlot (just     *   hold afs_xdcache).  That way, it's easy to do this without the     *   writelock on afs_xdcache, and we save unneccessary disk     *   operations. I don't think that works, 'cuz the next pointers     *   are still on disk.     */    origCBs = afs_allCBs;    maxStoredLength = 0;    minj = 0;    do {	memset(dcList, 0, NCHUNKSATONCE * sizeof(struct dcache *));	high = 0;	moredata = FALSE;	/* lock and start over from beginning of hash chain	 * in order to avoid a race condition. */	ObtainWriteLock(&afs_xdcache, 284);	index = afs_dvhashTbl[hash];	for (j = 0; index != NULLIDX;) {	    if ((afs_indexFlags[index] & IFDataMod)		&& (afs_indexUnique[index] == avc->f.fid.Fid.Unique)) {		tdc = afs_GetValidDSlot(index);	/* refcount+1. */		if (!tdc) {		    ReleaseWriteLock(&afs_xdcache);		    code = EIO;		    goto done;//.........这里部分代码省略.........

/* set the real time */voidafs_osi_SetTime(osi_timeval_t * atv){#if defined(AFS_AIX32_ENV)    struct timestruc_t t;    t.tv_sec = atv->tv_sec;    t.tv_nsec = atv->tv_usec * 1000;    ksettimer(&t);		/*  Was -> settimer(TIMEOFDAY, &t); */#elif defined(AFS_SUN5_ENV)    stime(atv->tv_sec);#elif defined(AFS_SGI_ENV)    struct stimea {	sysarg_t time;    } sta;    AFS_GUNLOCK();    sta.time = atv->tv_sec;    stime(&sta);    AFS_GLOCK();#elif defined(AFS_DARWIN_ENV)#ifndef AFS_DARWIN80_ENV    AFS_GUNLOCK();    setthetime(atv);    AFS_GLOCK();#endif#else    /* stolen from kern_time.c */#ifndef	AFS_AUX_ENV    boottime.tv_sec += atv->tv_sec - time.tv_sec;#endif#ifdef AFS_HPUX_ENV    {#if !defined(AFS_HPUX1122_ENV)	/* drop the setting of the clock for now. spl7 is not	 * known on hpux11.22	 */	ulong_t s;	struct timeval t;	t.tv_sec = atv->tv_sec;	t.tv_usec = atv->tv_usec;	s = spl7();	time = t;	(void)splx(s);	resettodr(atv);#endif    }#else    {	int s;	s = splclock();	time = *atv;	(void)splx(s);    }    resettodr();#endif#ifdef	AFS_AUX_ENV    logtchg(atv->tv_sec);#endif#endif /* AFS_DARWIN_ENV */    AFS_STATCNT(osi_SetTime);}

intafs_InvalidateAllSegments(struct vcache *avc){    struct dcache *tdc;    afs_int32 hash;    afs_int32 index;    struct dcache **dcList;    int i, dcListMax, dcListCount;    AFS_STATCNT(afs_InvalidateAllSegments);    afs_Trace2(afs_iclSetp, CM_TRACE_INVALL, ICL_TYPE_POINTER, avc,	       ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));    hash = DVHash(&avc->f.fid);    avc->f.truncPos = AFS_NOTRUNC;	/* don't truncate later */    avc->f.states &= ~CExtendedFile;	/* not any more */    ObtainWriteLock(&afs_xcbhash, 459);    afs_DequeueCallback(avc);    avc->f.states &= ~(CStatd | CDirty);	/* mark status information as bad, too */    ReleaseWriteLock(&afs_xcbhash);    if (avc->f.fid.Fid.Vnode & 1 || (vType(avc) == VDIR))	osi_dnlc_purgedp(avc);    /* Blow away pages; for now, only for Solaris */#if	(defined(AFS_SUN5_ENV))    if (WriteLocked(&avc->lock))	osi_ReleaseVM(avc, (afs_ucred_t *)0);#endif    /*     * Block out others from screwing with this table; is a read lock     * sufficient?     */    ObtainWriteLock(&afs_xdcache, 286);    dcListMax = 0;    for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {	if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {	    tdc = afs_GetValidDSlot(index);	    if (!tdc) {		/* In the case of fatal errors during stores, we MUST		 * invalidate all of the relevant chunks. Otherwise, the chunks		 * will be left with the 'new' data that was never successfully		 * written to the server, but the DV in the dcache is still the		 * old DV. So, we may indefinitely serve data to applications		 * that is not actually in the file on the fileserver. If we		 * cannot afs_GetValidDSlot the appropriate entries, currently		 * there is no way to ensure the dcache is invalidated. So for		 * now, to avoid risking serving bad data from the cache, panic		 * instead. */		osi_Panic("afs_InvalidateAllSegments tdc count");	    }	    ReleaseReadLock(&tdc->tlock);	    if (!FidCmp(&tdc->f.fid, &avc->f.fid))		dcListMax++;	    afs_PutDCache(tdc);	}	index = afs_dvnextTbl[index];    }    dcList = osi_Alloc(dcListMax * sizeof(struct dcache *));    dcListCount = 0;    for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {	if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {	    tdc = afs_GetValidDSlot(index);	    if (!tdc) {		/* We cannot proceed after getting this error; we risk serving		 * incorrect data to applications. So panic instead. See the		 * above comment next to the previous afs_GetValidDSlot call		 * for details. */		osi_Panic("afs_InvalidateAllSegments tdc store");	    }	    ReleaseReadLock(&tdc->tlock);	    if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {		/* same file? we'll zap it */		if (afs_indexFlags[index] & IFDataMod) {		    afs_stats_cmperf.cacheCurrDirtyChunks--;		    /* don't write it back */		    afs_indexFlags[index] &= ~IFDataMod;		}		afs_indexFlags[index] &= ~IFAnyPages;		if (dcListCount < dcListMax)		    dcList[dcListCount++] = tdc;		else		    afs_PutDCache(tdc);	    } else {		afs_PutDCache(tdc);	    }	}	index = afs_dvnextTbl[index];    }    ReleaseWriteLock(&afs_xdcache);    for (i = 0; i < dcListCount; i++) {	tdc = dcList[i];	ObtainWriteLock(&tdc->lock, 679);	ZapDCE(tdc);	if (vType(avc) == VDIR)	    DZap(tdc);	ReleaseWriteLock(&tdc->lock);	afs_PutDCache(tdc);//.........这里部分代码省略.........

/* Note that we don't set CDirty here, this is OK because the unlink * RPC is called synchronously */intafs_remove(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred){    struct vrequest treq;    register struct dcache *tdc;    struct VenusFid unlinkFid;    register afs_int32 code;    register struct vcache *tvc;    afs_size_t offset, len;    struct afs_fakestat_state fakestate;    OSI_VC_CONVERT(adp);    AFS_STATCNT(afs_remove);    afs_Trace2(afs_iclSetp, CM_TRACE_REMOVE, ICL_TYPE_POINTER, adp,	       ICL_TYPE_STRING, aname);    if ((code = afs_InitReq(&treq, acred))) {	return code;    }    afs_InitFakeStat(&fakestate);    AFS_DISCON_LOCK();    code = afs_EvalFakeStat(&adp, &fakestate, &treq);    if (code)	goto done;    /* Check if this is dynroot */    if (afs_IsDynroot(adp)) {	code = afs_DynrootVOPRemove(adp, acred, aname);	goto done;    }    if (afs_IsDynrootMount(adp)) {	code = ENOENT;	goto done;    }    if (strlen(aname) > AFSNAMEMAX) {	code = ENAMETOOLONG;	goto done;    }  tagain:    code = afs_VerifyVCache(adp, &treq);    tvc = NULL;    if (code) {	code = afs_CheckCode(code, &treq, 23);	goto done;    }    /** If the volume is read-only, return error without making an RPC to the      * fileserver      */    if (adp->f.states & CRO) {	code = EROFS;	goto done;    }    /* If we're running disconnected without logging, go no further... */    if (AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW) {        code = ENETDOWN;	goto done;    }        tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1);	/* test for error below */    ObtainWriteLock(&adp->lock, 142);    if (tdc)	ObtainSharedLock(&tdc->lock, 638);    /*     * Make sure that the data in the cache is current. We may have     * received a callback while we were waiting for the write lock.     */    if (!(adp->f.states & CStatd)	|| (tdc && !hsame(adp->f.m.DataVersion, tdc->f.versionNo))) {	ReleaseWriteLock(&adp->lock);	if (tdc) {	    ReleaseSharedLock(&tdc->lock);	    afs_PutDCache(tdc);	}	goto tagain;    }    unlinkFid.Fid.Vnode = 0;    if (!tvc) {	tvc = osi_dnlc_lookup(adp, aname, WRITE_LOCK);    }    /* This should not be necessary since afs_lookup() has already     * done the work.     */    if (!tvc)	if (tdc) {	    code = afs_dir_Lookup(tdc, aname, &unlinkFid.Fid);	    if (code == 0) {		afs_int32 cached = 0;		unlinkFid.Cell = adp->f.fid.Cell;		unlinkFid.Fid.Volume = adp->f.fid.Fid.Volume;		if (unlinkFid.Fid.Unique == 0) {//.........这里部分代码省略.........

voidafs_osi_InitWaitHandle(struct afs_osi_WaitHandle *achandle){    AFS_STATCNT(osi_InitWaitHandle);    achandle->proc = (caddr_t) 0;}

intafsrename(struct vcache *aodp, char *aname1, struct vcache *andp,	  char *aname2, struct AFS_UCRED *acred, struct vrequest *areq){    register struct afs_conn *tc;    register afs_int32 code = 0;    afs_int32 returnCode;    int oneDir, doLocally;    afs_size_t offset, len;    struct VenusFid unlinkFid, fileFid;    struct vcache *tvc;    struct dcache *tdc1, *tdc2;    struct AFSFetchStatus OutOldDirStatus, OutNewDirStatus;    struct AFSVolSync tsync;    XSTATS_DECLS;    AFS_STATCNT(afs_rename);    afs_Trace4(afs_iclSetp, CM_TRACE_RENAME, ICL_TYPE_POINTER, aodp,	       ICL_TYPE_STRING, aname1, ICL_TYPE_POINTER, andp,	       ICL_TYPE_STRING, aname2);    if (strlen(aname1) > AFSNAMEMAX || strlen(aname2) > AFSNAMEMAX) {	code = ENAMETOOLONG;	goto done;    }    /* verify the latest versions of the stat cache entries */  tagain:    code = afs_VerifyVCache(aodp, areq);    if (code)	goto done;    code = afs_VerifyVCache(andp, areq);    if (code)	goto done;    /* lock in appropriate order, after some checks */    if (aodp->f.fid.Cell != andp->f.fid.Cell	|| aodp->f.fid.Fid.Volume != andp->f.fid.Fid.Volume) {	code = EXDEV;	goto done;    }    oneDir = 0;    code = 0;    if (andp->f.fid.Fid.Vnode == aodp->f.fid.Fid.Vnode) {	if (!strcmp(aname1, aname2)) {	    /* Same directory and same name; this is a noop and just return success	     * to save cycles and follow posix standards */	    code = 0;	    goto done;	}		if (AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW) {	    code = ENETDOWN;	    goto done;	}		ObtainWriteLock(&andp->lock, 147);	tdc1 = afs_GetDCache(aodp, (afs_size_t) 0, areq, &offset, &len, 0);	if (!tdc1) {	    code = ENOENT;	} else {	    ObtainWriteLock(&tdc1->lock, 643);	}	tdc2 = tdc1;	oneDir = 1;		/* only one dude locked */    } else if ((andp->f.states & CRO) || (aodp->f.states & CRO)) {	code = EROFS;	goto done;    } else if (andp->f.fid.Fid.Vnode < aodp->f.fid.Fid.Vnode) {	ObtainWriteLock(&andp->lock, 148);	/* lock smaller one first */	ObtainWriteLock(&aodp->lock, 149);	tdc2 = afs_FindDCache(andp, (afs_size_t) 0);	if (tdc2)	    ObtainWriteLock(&tdc2->lock, 644);	tdc1 = afs_GetDCache(aodp, (afs_size_t) 0, areq, &offset, &len, 0);	if (tdc1)	    ObtainWriteLock(&tdc1->lock, 645);	else	    code = ENOENT;    } else {	ObtainWriteLock(&aodp->lock, 150);	/* lock smaller one first */	ObtainWriteLock(&andp->lock, 557);	tdc1 = afs_GetDCache(aodp, (afs_size_t) 0, areq, &offset, &len, 0);	if (tdc1)	    ObtainWriteLock(&tdc1->lock, 646);	else	    code = ENOENT;	tdc2 = afs_FindDCache(andp, (afs_size_t) 0);	if (tdc2)	    ObtainWriteLock(&tdc2->lock, 647);    }    osi_dnlc_remove(aodp, aname1, 0);    osi_dnlc_remove(andp, aname2, 0);    /*     * Make sure that the data in the cache is current. We may have     * received a callback while we were waiting for the write lock.     */    if (tdc1) {//.........这里部分代码省略.........

voidLockAndInstallUVolumeEntry(struct volume *av, struct uvldbentry *ve, int acell,			   struct cell *tcell, struct vrequest *areq){    struct server *ts;    struct afs_conn *tconn;    struct cell *cellp;    int i, j;    afs_uint32 serverid;    afs_int32 mask;    int k;    char type = 0;    struct server *serverHost[AFS_MAXHOSTS];    AFS_STATCNT(InstallVolumeEntry);    memset(serverHost, 0, sizeof(serverHost));    /* Determine type of volume we want */    if ((ve->flags & VLF_RWEXISTS) && (av->volume == ve->volumeId[RWVOL])) {	mask = VLSF_RWVOL;    } else if ((ve->flags & VLF_ROEXISTS)	       && av->volume == ve->volumeId[ROVOL]) {	mask = VLSF_ROVOL;	type |= VRO;    } else if ((ve->flags & VLF_BACKEXISTS)	       && (av->volume == ve->volumeId[BACKVOL])) {	/* backup always is on the same volume as parent */	mask = VLSF_RWVOL;	type |= (VRO | VBackup);    } else {	mask = 0;		/* Can't find volume in vldb entry */    }    cellp = afs_GetCell(acell, 0);    /* Gather the list of servers the VLDB says the volume is on     * and initialize the ve->serverHost[] array. If a server struct     * is not found, then get the list of addresses for the     * server, VL_GetAddrsU(), and create a server struct, afs_GetServer().     */    for (i = 0, j = 0; i < ve->nServers; i++) {	if (((ve->serverFlags[i] & mask) == 0)	    || (ve->serverFlags[i] & VLSF_DONTUSE)) {	    continue;		/* wrong volume don't use this volume */	}	if (!(ve->serverFlags[i] & VLSERVER_FLAG_UUID)) {	    /* The server has no uuid */	    serverid = htonl(ve->serverNumber[i].time_low);	    ts = afs_GetServer(&serverid, 1, acell, cellp->fsport,			       WRITE_LOCK, (afsUUID *) 0, 0, av);	} else {	    ts = afs_FindServer(0, cellp->fsport, &ve->serverNumber[i], 0);	    if (ts && (ts->sr_addr_uniquifier == ve->serverUnique[i])		&& ts->addr) {		/* uuid, uniquifier, and portal are the same */	    } else {		afs_uint32 *addrp, code;		afs_int32 nentries, unique;		bulkaddrs addrs;		ListAddrByAttributes attrs;		afsUUID uuid;		struct rx_connection *rxconn;		memset(&attrs, 0, sizeof(attrs));		attrs.Mask = VLADDR_UUID;		attrs.uuid = ve->serverNumber[i];		memset(&uuid, 0, sizeof(uuid));		memset(&addrs, 0, sizeof(addrs));		do {		    tconn =			afs_ConnByMHosts(tcell->cellHosts, tcell->vlport,					 tcell->cellNum, areq, SHARED_LOCK,					 0, &rxconn);		    if (tconn) {			RX_AFS_GUNLOCK();			code =			    VL_GetAddrsU(rxconn, &attrs, &uuid, &unique,					 &nentries, &addrs);			RX_AFS_GLOCK();		    } else {			code = -1;		    }		    /* Handle corrupt VLDB (defect 7393) */		    if (code == 0 && nentries == 0)			code = VL_NOENT;		} while (afs_Analyze			 (tconn, rxconn, code, NULL, areq, -1, SHARED_LOCK, tcell));		if (code) {		    /* Better handing of such failures; for now we'll simply retry this call */		    areq->volumeError = 1;		    return;		}		addrp = addrs.bulkaddrs_val;		for (k = 0; k < nentries; k++) {		    addrp[k] = htonl(addrp[k]);//.........这里部分代码省略.........

/** * Decrement reference count to this connection. * @param ac * @param locktype */voidafs_PutConn(register struct afs_conn *ac, afs_int32 locktype){    AFS_STATCNT(afs_PutConn);    ac->refCount--;}				/*afs_PutConn */