c3427251336c3f8c36d0fdee4d7909b1f859dcd5
[openafs.git] / src / viced / afsfileprocs.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*  afs_fileprocs.c - Complete File Server request routines              */
11 /*                                                                       */
12 /*  Information Technology Center                                        */
13 /*  Carnegie Mellon University                                           */
14 /*                                                                       */
15 /*  Date: 8/10/88                                                        */
16 /*                                                                       */
17 /*  Function    - A set of routines to handle the various file Server    */
18 /*                  requests; these routines are invoked by rxgen.       */
19 /*                                                                       */
20 /* ********************************************************************** */
21
22 /* 
23  * in Check_PermissionRights, certain privileges are afforded to the owner 
24  * of the volume, or the owner of a file.  Are these considered "use of 
25  * privilege"? 
26  */
27
28 #include <afsconfig.h>
29 #include <afs/param.h>
30
31 RCSID("$Header$");
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <errno.h>
36 #ifdef  AFS_SGI_ENV
37 #undef SHARED           /* XXX */
38 #endif
39 #ifdef AFS_NT40_ENV
40 #include <fcntl.h>
41 #else
42 #include <sys/param.h>
43 #include <sys/file.h>
44 #include <netinet/in.h>
45 #include <netdb.h>
46 #include <sys/ioctl.h>
47 #include <sys/socket.h>
48 #ifndef AFS_LINUX20_ENV
49 #include <net/if.h>
50 #include <netinet/if_ether.h>
51 #endif
52 #ifdef notdef
53 #include <nlist.h>
54 #endif
55 #endif
56 #ifdef AFS_HPUX_ENV
57 /* included early because of name conflict on IOPEN */
58 #include <sys/inode.h>
59 #ifdef IOPEN
60 #undef IOPEN
61 #endif
62 #endif /* AFS_HPUX_ENV */
63 #include <afs/stds.h>
64 #include <rx/xdr.h>
65 #include <afs/nfs.h>
66 #include <afs/assert.h>
67 #include <lwp.h>
68 #include <lock.h>
69 #include <afs/afsint.h>
70 #include <afs/vldbint.h>
71 #include <afs/errors.h>
72 #include <afs/ihandle.h>
73 #include <afs/vnode.h>
74 #include <afs/volume.h>
75 #include <afs/acl.h>
76 #include <afs/ptclient.h>
77 #include <afs/prs_fs.h>
78 #include <rx/rx.h>
79 #include <rx/rx_globals.h>
80 #include <sys/stat.h>
81 #if ! defined(AFS_SGI_ENV) && ! defined(AFS_AIX32_ENV) && ! defined(AFS_NT40_ENV) && ! defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
82 #include <sys/map.h>
83 #endif
84 #if !defined(AFS_NT40_ENV)
85 #include <unistd.h>
86 #endif
87 #if !defined(AFS_SGI_ENV) && !defined(AFS_NT40_ENV)
88 #ifdef  AFS_AIX_ENV
89 #include <sys/statfs.h>
90 #include <sys/lockf.h>
91 #else
92 #if !defined(AFS_SUN5_ENV) && !defined(AFS_LINUX20_ENV) && !defined(AFS_DARWIN_ENV) && !defined(AFS_FBSD_ENV)
93 #include <sys/dk.h>
94 #endif
95 #endif
96 #endif
97 #include <afs/cellconfig.h>
98 #include <afs/keys.h>
99
100 #include <afs/auth.h>
101 #include <signal.h>
102 #include <afs/partition.h>
103 #include "viced.h"
104 #include "host.h"
105 #include <afs/audit.h>
106 #include <afs/afsutil.h>
107
108 #ifdef AFS_PTHREAD_ENV
109 pthread_mutex_t fileproc_glock_mutex;
110 #endif /* AFS_PTHREAD_ENV */
111
112
113 /* Useful local defines used by this module */
114
115 #define DONTCHECK       0
116 #define MustNOTBeDIR    1
117 #define MustBeDIR       2
118
119 #define TVS_SDATA       1
120 #define TVS_SSTATUS     2
121 #define TVS_CFILE       4
122 #define TVS_SLINK       8
123 #define TVS_MKDIR       0x10
124
125 #define CHK_FETCH       0x10
126 #define CHK_FETCHDATA   0x10
127 #define CHK_FETCHACL    0x11
128 #define CHK_FETCHSTATUS 0x12
129 #define CHK_STOREDATA   0x00
130 #define CHK_STOREACL    0x01
131 #define CHK_STORESTATUS 0x02
132
133 #define OWNERREAD       0400
134 #define OWNERWRITE      0200
135 #define OWNEREXEC       0100
136 #ifdef USE_GROUP_PERMS
137 #define GROUPREAD       0040
138 #define GROUPWRITE      0020
139 #define GROUPREXEC      0010
140 #endif
141
142 /* The following errors were not defined in NT. They are given unique
143  * names here to avoid any potential collision.
144  */
145 #define FSERR_ELOOP              90
146 #define FSERR_EOPNOTSUPP        122
147 #define FSERR_ECONNREFUSED      130
148
149 #define NOTACTIVECALL   0
150 #define ACTIVECALL      1
151
152 extern struct afsconf_dir *confDir;
153 extern afs_int32 dataVersionHigh;
154
155 extern  int         SystemId;
156 extern  struct AFSCallStatistics AFSCallStats;
157 struct AFSCallStatistics AFSCallStats;
158 #if FS_STATS_DETAILED
159 struct fs_stats_FullPerfStats afs_FullPerfStats;
160 extern int AnonymousID;
161 #endif /* FS_STATS_DETAILED */
162 #if TRANSARC_VOL_STATS
163 static const char nullString[] = "";
164 #endif /* TRANSARC_VOL_STATS */
165
166 struct afs_FSStats {
167     afs_int32 NothingYet;
168 };
169
170 struct afs_FSStats afs_fsstats;
171
172 void    ResetDebug(), SetDebug(), GetStatus(), Terminate();
173 int     CopyOnWrite();          /* returns 0 on success */
174
175
176 void SetSystemStats(), SetAFSStats(), SetVolumeStats();
177 int     LogLevel = 0;
178 int     supported = 1;
179 int     Console = 0;
180 afs_int32 BlocksSpare = 1024;   /* allow 1 MB overruns */
181 afs_int32 PctSpare;
182 extern afs_int32 implicitAdminRights;
183
184 static TryLocalVLServer();
185
186 /*
187  * Externals used by the xstat code.
188  */
189 extern int VolumeCacheSize, VolumeGets, VolumeReplacements;
190 extern int CEs, CEBlocks;
191
192 extern int HTs, HTBlocks;
193
194 #ifdef AFS_SGI_XFS_IOPS_ENV
195 #include <afs/xfsattrs.h>
196 static int GetLinkCount(avp, astat)
197      Volume *avp;
198      struct stat *astat;
199 {
200     if (!strcmp("xfs", astat->st_fstype)) {
201         return (astat->st_mode & AFS_XFS_MODE_LINK_MASK);
202     }
203     else
204         return astat->st_nlink;
205 }
206 #else
207 #define GetLinkCount(V, S) (S)->st_nlink
208 #endif
209
210 afs_int32 SpareComp(avolp)
211     Volume *avolp;
212
213 {
214     register afs_int32 temp;
215
216     FS_LOCK
217     if (PctSpare) {
218         temp = V_maxquota(avolp);
219         if (temp == 0) {
220             /* no matter; doesn't check in this case */
221             FS_UNLOCK
222             return 0;
223         }
224         temp = (temp * PctSpare) / 100;
225         FS_UNLOCK
226         return temp;
227     }
228     else {
229         FS_UNLOCK
230         return BlocksSpare;
231     }
232
233 } /*SpareComp*/
234
235
236 /*
237  * Set the volume synchronization parameter for this volume.  If it changes,
238  * the Cache Manager knows that the volume must be purged from the stat cache.
239  */
240 static SetVolumeSync(async, avol)
241     register struct AFSVolSync *async;
242     register Volume *avol;
243
244 {
245     FS_LOCK
246     /* date volume instance was created */
247     if (async) {
248         if (avol)
249             async->spare1 = avol->header->diskstuff.creationDate;
250         else
251             async->spare1 = 0;
252         async->spare2 = 0;
253         async->spare3 = 0;
254         async->spare4 = 0;
255         async->spare5 = 0;
256         async->spare6 = 0;
257     }
258     FS_UNLOCK
259 } /*SetVolumeSync*/
260
261 /*
262  * This call overwrites the pointed-to rx_call with an rx_connection.  This
263  * is really bogus.  Note that this function always returns a held host, so
264  * that CallPostamble can block without the host's disappearing.
265  */
266 static CallPreamble(acall, activecall)
267     register struct rx_call **acall;
268     int activecall;
269
270 {
271     struct host *thost;
272     struct rx_connection *tconn;
273     struct client *tclient;
274     int retry_flag=1;
275     int code = 0;
276     tconn = rx_ConnectionOf(*acall);
277     *acall = (struct rx_call *)tconn;       /* change it! */
278
279     H_LOCK
280 retry:
281     tclient = h_FindClient_r(tconn);
282     if (tclient->prfail == 1) { /* couldn't get the CPS */
283        if (!retry_flag) {
284           h_ReleaseClient_r(tclient);
285           ViceLog(0, ("CallPreamble: Couldn't get CPS. Fail\n"));
286           H_UNLOCK
287           return -1001;
288        }
289        retry_flag=0;    /* Retry once */
290
291        /* Take down the old connection and re-read the key file */
292        ViceLog(0, ("CallPreamble: Couldn't get CPS. Reconnect to ptserver\n"));
293        H_UNLOCK
294        code = pr_Initialize(2, AFSDIR_SERVER_ETC_DIRPATH, 0);
295        H_LOCK
296        if (code) {
297           h_ReleaseClient_r(tclient);
298           H_UNLOCK
299           ViceLog(0,("CallPreamble: couldn't reconnect to ptserver\n"));
300           return -1001;
301        }
302
303        tclient->prfail = 2;      /* Means re-eval client's cps */
304        h_ReleaseClient_r(tclient);
305        goto retry;
306     }
307
308     thost = tclient->host;
309     tclient->LastCall = thost->LastCall = FT_ApproxTime();
310     if (activecall) /* For all but "GetTime" calls */
311         thost->ActiveCall = thost->LastCall;
312
313     h_Lock_r(thost);
314     if (thost->hostFlags & HOSTDELETED) {
315       ViceLog(3,("Discarded a packet for deleted host %08x\n",thost->host));
316       code = VBUSY; /* raced, so retry */
317     }
318     else if (thost->hostFlags & VENUSDOWN) {
319       if (BreakDelayedCallBacks_r(thost)) {
320         ViceLog(0,("BreakDelayedCallbacks FAILED for host %08x which IS UP.  Possible network or routing failure.\n",thost->host));
321         if ( MultiProbeAlternateAddress_r (thost) ) {
322             ViceLog(0, ("MultiProbe failed to find new address for host %x.%d\n",
323                         thost->host, thost->port));
324             code = -1;
325         } else {
326             ViceLog(0, ("MultiProbe found new address for host %x.%d\n",
327                         thost->host, thost->port));
328             if (BreakDelayedCallBacks_r(thost)) {
329                 ViceLog(0,("BreakDelayedCallbacks FAILED AGAIN for host %08x which IS UP.  Possible network or routing failure.\n",thost->host));
330                 code = -1;
331             }
332         }
333       }
334     } else {
335        code =  0;
336     }
337
338     h_ReleaseClient_r(tclient);
339     h_Unlock_r(thost);
340     H_UNLOCK
341     return code;      
342
343 } /*CallPreamble*/
344
345
346 static CallPostamble(aconn)
347     register struct rx_connection *aconn;
348
349 {
350     struct host *thost;
351     struct client *tclient;
352
353     H_LOCK
354     tclient = h_FindClient_r(aconn);
355     thost = tclient->host;
356     h_ReleaseClient_r(tclient);
357     h_Release_r(thost);
358     H_UNLOCK
359
360 } /*CallPostamble*/
361
362
363 #define AFSV_BUFFERSIZE 16384 
364
365 static struct afs_buffer {
366     struct afs_buffer *next;
367 } *freeBufferList = 0;
368 static int afs_buffersAlloced = 0;
369
370
371 static FreeSendBuffer(adata)
372     register struct afs_buffer *adata;
373
374 {
375     FS_LOCK
376     afs_buffersAlloced--;
377     adata->next = freeBufferList;
378     freeBufferList = adata;
379     FS_UNLOCK
380     return 0;
381
382 } /*FreeSendBuffer*/
383
384
385 /* allocate space for sender */
386 static char *AllocSendBuffer()
387
388 {
389     register struct afs_buffer *tp;
390
391     FS_LOCK
392     afs_buffersAlloced++;
393     if (!freeBufferList) {
394         FS_UNLOCK
395         return malloc(AFSV_BUFFERSIZE);
396     }
397     tp = freeBufferList;
398     freeBufferList = tp->next;
399     FS_UNLOCK
400     return (char *) tp;
401
402 } /*AllocSendBuffer*/
403
404
405 static int VolumeOwner (client, targetptr)
406     register struct client *client;
407     register Vnode *targetptr;
408
409 {
410     afs_int32 owner = V_owner(targetptr->volumePtr);    /* get volume owner */
411
412     if (owner >= 0)
413         return (client->ViceId == owner);
414     else {
415         /* 
416          * We don't have to check for host's cps since only regular
417          * viceid are volume owners.
418          */
419         return (acl_IsAMember(owner, &client->CPS));
420     }
421
422 } /*VolumeOwner*/
423
424
425 static int VolumeRootVnode (targetptr)
426     Vnode *targetptr;
427
428 {
429     return ((targetptr->vnodeNumber == ROOTVNODE) &&
430             (targetptr->disk.uniquifier == 1));
431
432 } /*VolumeRootVnode*/
433
434
435 SRXAFS_FetchData (tcon, Fid, Pos, Len, OutStatus, CallBack, Sync)
436     struct rx_connection *tcon;         /* Rx connection handle */
437     struct AFSFid *Fid;                 /* Fid of file to fetch */
438     afs_int32 Pos, Len;                 /* Not implemented yet */
439     struct AFSFetchStatus *OutStatus;   /* Returned status for Fid */
440     struct AFSCallBack *CallBack;       /* If r/w return CB for Fid */
441     struct AFSVolSync *Sync;            /* synchronization info */
442
443 {
444     Vnode * targetptr = 0;                  /* pointer to vnode to fetch */
445     Vnode * parentwhentargetnotdir = 0;     /* parent vnode if vptr is a file */
446     Vnode   tparentwhentargetnotdir;        /* parent vnode for GetStatus */
447     int     errorCode = 0;                  /* return code to caller */
448     int     fileCode =  0;                  /* return code from vol package */
449     Volume * volptr = 0;                    /* pointer to the volume */
450     struct client *client;                  /* pointer to the client data */
451     struct rx_call *tcall;                  /* the call we're a part of */
452     afs_int32 rights, anyrights;                    /* rights for this and any user */
453     struct client *t_client;                /* tmp ptr to client data */
454     struct in_addr logHostAddr;             /* host ip holder for inet_ntoa */
455 #if FS_STATS_DETAILED
456     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
457     struct fs_stats_xferData *xferP;        /* Ptr to this op's byte size struct */
458     struct timeval opStartTime,
459                    opStopTime;              /* Start/stop times for RPC op*/
460     struct timeval xferStartTime,
461                    xferStopTime;            /* Start/stop times for xfer portion*/
462     struct timeval elapsedTime;             /* Transfer time */
463     afs_int32 bytesToXfer;                          /* # bytes to xfer*/
464     afs_int32 bytesXferred;                         /* # bytes actually xferred*/
465     int readIdx;                            /* Index of read stats array to bump*/
466     static afs_int32 tot_bytesXferred; /* shared access protected by FS_LOCK */
467
468     /*
469      * Set our stats pointers, remember when the RPC operation started, and
470      * tally the operation.
471      */
472     opP   = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_FETCHDATA]);
473     xferP = &(afs_FullPerfStats.det.xferOpTimes[FS_STATS_XFERIDX_FETCHDATA]);
474     FS_LOCK
475     (opP->numOps)++;
476     FS_UNLOCK
477     TM_GetTimeOfDay(&opStartTime, 0);
478 #endif /* FS_STATS_DETAILED */
479
480     ViceLog(1,("SRXAFS_FetchData, Fid = %u.%d.%d\n",
481             Fid->Volume, Fid->Vnode, Fid->Unique));     
482     FS_LOCK
483     AFSCallStats.FetchData++, AFSCallStats.TotalCalls++;
484     FS_UNLOCK
485
486     /* CallPreamble changes tcon from a call to a conn */
487     tcall = (struct rx_call *) tcon;
488     if (errorCode = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
489         goto Bad_FetchData;
490
491     /* Get ptr to client data for user Id for logging */
492     t_client = (struct client *)  rx_GetSpecific(tcon, rxcon_client_key);
493     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
494     ViceLog(5,("SRXAFS_FetchData, Fid = %u.%d.%d, Host %s, Id %d\n",
495             Fid->Volume, Fid->Vnode, Fid->Unique,
496             inet_ntoa(logHostAddr), t_client->ViceId)); 
497     /*
498      * Get volume/vnode for the fetched file; caller's access rights to
499      * it are also returned
500      */
501     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
502                                      DONTCHECK, &parentwhentargetnotdir,
503                                      &client, READ_LOCK, &rights, &anyrights))
504         goto Bad_FetchData;
505
506     SetVolumeSync(Sync, volptr);
507
508 #if FS_STATS_DETAILED
509     /*
510      * Remember that another read operation was performed.
511      */
512     FS_LOCK
513     if (client->InSameNetwork)
514         readIdx = VOL_STATS_SAME_NET;
515     else
516         readIdx = VOL_STATS_DIFF_NET;
517     V_stat_reads(volptr, readIdx)++;
518     if (client->ViceId != AnonymousID) {
519         V_stat_reads(volptr, readIdx+1)++;
520     }
521     FS_UNLOCK
522 #endif /* FS_STATS_DETAILED */
523
524     /* Check whether the caller has permission access to fetch the data */
525     if (errorCode = Check_PermissionRights(targetptr, client, rights,
526                                            CHK_FETCHDATA, 0))
527         goto Bad_FetchData;
528
529     /*
530      * Drop the read lock on the parent directory after saving the parent
531      * vnode information we need to pass to GetStatus
532      */
533     if (parentwhentargetnotdir != NULL) {
534         tparentwhentargetnotdir = *parentwhentargetnotdir;
535         VPutVnode(&fileCode, parentwhentargetnotdir);
536         assert(!fileCode || (fileCode == VSALVAGE));
537         parentwhentargetnotdir = NULL;
538     }
539
540 #if FS_STATS_DETAILED
541     /*
542      * Remember when the data transfer started.
543      */
544     TM_GetTimeOfDay(&xferStartTime, 0);
545 #endif /* FS_STATS_DETAILED */
546
547     /* actually do the data transfer */
548 #if FS_STATS_DETAILED
549     errorCode = FetchData_RXStyle(volptr, targetptr, tcall, Pos, Len,
550                                   &bytesToXfer, &bytesXferred);
551 #else
552     if (errorCode = FetchData_RXStyle(volptr, targetptr, tcall, Pos, Len))
553         goto Bad_FetchData;
554 #endif /* FS_STATS_DETAILED */
555
556 #if FS_STATS_DETAILED
557     /*
558      * At this point, the data transfer is done, for good or ill.  Remember
559      * when the transfer ended, bump the number of successes/failures, and
560      * integrate the transfer size and elapsed time into the stats.  If the
561      * operation failed, we jump to the appropriate point.
562      */
563     TM_GetTimeOfDay(&xferStopTime, 0);
564     FS_LOCK
565     (xferP->numXfers)++;
566     if (!errorCode) {
567         (xferP->numSuccesses)++;
568
569         /*
570          * Bump the xfer sum by the number of bytes actually sent, NOT the
571          * target number.
572          */
573         tot_bytesXferred += bytesXferred;
574         (xferP->sumBytes) += (tot_bytesXferred >> 10);
575         tot_bytesXferred &= 0x3FF;
576         if (bytesXferred < xferP->minBytes)
577             xferP->minBytes = bytesXferred;
578         if (bytesXferred > xferP->maxBytes)
579             xferP->maxBytes = bytesXferred;
580
581         /*
582          * Tally the size of the object.  Note: we tally the actual size,
583          * NOT the number of bytes that made it out over the wire.
584          */
585         if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET0)
586             (xferP->count[0])++;
587         else
588             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET1)
589                 (xferP->count[1])++;
590         else
591             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET2)
592                 (xferP->count[2])++;
593         else
594             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET3)
595                 (xferP->count[3])++;
596         else
597             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET4)
598                 (xferP->count[4])++;
599         else
600             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET5)
601                 (xferP->count[5])++;
602         else
603             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET6)
604                 (xferP->count[6])++;
605         else
606             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET7)
607                 (xferP->count[7])++;
608         else
609             (xferP->count[8])++;
610
611         fs_stats_GetDiff(elapsedTime, xferStartTime, xferStopTime);
612         fs_stats_AddTo((xferP->sumTime), elapsedTime);
613         fs_stats_SquareAddTo((xferP->sqrTime), elapsedTime);
614         if (fs_stats_TimeLessThan(elapsedTime, (xferP->minTime))) {
615             fs_stats_TimeAssign((xferP->minTime), elapsedTime);
616         }
617         if (fs_stats_TimeGreaterThan(elapsedTime, (xferP->maxTime))) {
618             fs_stats_TimeAssign((xferP->maxTime), elapsedTime);
619         }
620       }
621     FS_UNLOCK
622     /*
623      * Finally, go off to tell our caller the bad news in case the
624      * fetch failed.
625      */
626     if (errorCode)
627         goto Bad_FetchData;
628 #endif /* FS_STATS_DETAILED */
629
630     /* write back  the OutStatus from the target vnode  */
631     GetStatus(targetptr, OutStatus, rights, anyrights, &tparentwhentargetnotdir);
632
633     /* if a r/w volume, promise a callback to the caller */
634     if (VolumeWriteable(volptr))
635         SetCallBackStruct(AddCallBack(client->host, Fid), CallBack);
636     else {
637       struct AFSFid myFid;              
638       bzero(&myFid, sizeof(struct AFSFid));
639       myFid.Volume = Fid->Volume;
640       SetCallBackStruct(AddVolCallBack(client->host, &myFid), CallBack);
641       }
642
643 Bad_FetchData: 
644     /* Update and store volume/vnode and parent vnodes back */
645     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
646     ViceLog(2, ("SRXAFS_FetchData returns %d\n", errorCode)); 
647     CallPostamble(tcon);
648
649 #if FS_STATS_DETAILED
650     TM_GetTimeOfDay(&opStopTime, 0);
651     if (errorCode == 0) {
652         FS_LOCK
653         (opP->numSuccesses)++;
654         fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
655         fs_stats_AddTo((opP->sumTime), elapsedTime);
656         fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
657         if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
658             fs_stats_TimeAssign((opP->minTime), elapsedTime);
659         }
660         if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
661             fs_stats_TimeAssign((opP->maxTime), elapsedTime);
662         }
663         FS_UNLOCK
664       }
665
666 #endif /* FS_STATS_DETAILED */
667
668     osi_auditU (tcall, FetchDataEvent, errorCode, AUD_FID, Fid, AUD_END);
669     return(errorCode);
670
671 } /*SRXAFS_FetchData*/
672
673
674 SRXAFS_FetchACL (tcon, Fid, AccessList, OutStatus, Sync)
675     struct AFSVolSync *Sync;
676     struct rx_connection *tcon;         /* Rx connection handle */
677     struct AFSFid *Fid;                 /* Fid of target dir */
678     struct AFSOpaque *AccessList;       /* Returned contents of dir's ACL */
679     struct AFSFetchStatus *OutStatus;   /* Returned status for the dir */
680
681 {
682     Vnode * targetptr = 0;              /* pointer to vnode to fetch */
683     Vnode * parentwhentargetnotdir = 0; /* parent vnode if targetptr is a file */
684     int     errorCode = 0;              /* return error code to caller */
685     Volume * volptr = 0;                /* pointer to the volume */
686     struct client *client;              /* pointer to the client data */
687     afs_int32 rights, anyrights;                /* rights for this and any user */
688     struct rx_call *tcall = (struct rx_call *) tcon; 
689     struct client *t_client;                /* tmp ptr to client data */
690     struct in_addr logHostAddr;             /* host ip holder for inet_ntoa */
691 #if FS_STATS_DETAILED
692     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
693     struct timeval opStartTime,
694                    opStopTime;              /* Start/stop times for RPC op*/
695     struct timeval elapsedTime;             /* Transfer time */
696
697     /*
698      * Set our stats pointer, remember when the RPC operation started, and
699      * tally the operation.
700      */
701     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_FETCHACL]);
702     FS_LOCK
703     (opP->numOps)++;
704     FS_UNLOCK
705     TM_GetTimeOfDay(&opStartTime, 0);
706 #endif /* FS_STATS_DETAILED */
707
708     ViceLog(1, ("SAFS_FetchACL, Fid = %u.%d.%d\n",
709             Fid->Volume, Fid->Vnode, Fid->Unique));
710     FS_LOCK
711     AFSCallStats.FetchACL++, AFSCallStats.TotalCalls++;
712     FS_UNLOCK
713     if (errorCode = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
714         goto Bad_FetchACL;
715
716     /* Get ptr to client data for user Id for logging */
717     t_client = (struct client *)  rx_GetSpecific(tcon, rxcon_client_key);
718     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
719     ViceLog(5, ("SAFS_FetchACL, Fid = %u.%d.%d, Host %s, Id %d\n",
720             Fid->Volume, Fid->Vnode, Fid->Unique,
721             inet_ntoa(logHostAddr), t_client->ViceId));
722
723     AccessList->AFSOpaque_len = 0;
724     AccessList->AFSOpaque_val = malloc(AFSOPAQUEMAX);
725
726     /*
727      * Get volume/vnode for the fetched file; caller's access rights to it
728      * are also returned
729      */
730     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
731                                      DONTCHECK, &parentwhentargetnotdir,
732                                      &client, READ_LOCK, &rights, &anyrights))
733         goto Bad_FetchACL;
734
735     SetVolumeSync(Sync, volptr);
736
737     /* Check whether we have permission to fetch the ACL */
738     if (errorCode = Check_PermissionRights(targetptr, client, rights,
739                                            CHK_FETCHACL, 0))
740         goto Bad_FetchACL;
741
742     /* Get the Access List from the dir's vnode */
743     if (errorCode = RXFetch_AccessList(targetptr, parentwhentargetnotdir,
744                                        AccessList))
745         goto Bad_FetchACL;
746
747     /* Get OutStatus back From the target Vnode  */
748     GetStatus(targetptr, OutStatus, rights, anyrights, parentwhentargetnotdir);
749
750 Bad_FetchACL: 
751     /* Update and store volume/vnode and parent vnodes back */
752     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
753     ViceLog(2, ("SAFS_FetchACL returns %d (ACL=%s)\n",
754             errorCode, AccessList->AFSOpaque_val));
755     CallPostamble(tcon);
756
757 #if FS_STATS_DETAILED
758     TM_GetTimeOfDay(&opStopTime, 0);
759     if (errorCode == 0) {
760         FS_LOCK
761         (opP->numSuccesses)++;
762         fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
763         fs_stats_AddTo((opP->sumTime), elapsedTime);
764         fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
765         if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
766             fs_stats_TimeAssign((opP->minTime), elapsedTime);
767         }
768         if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
769             fs_stats_TimeAssign((opP->maxTime), elapsedTime);
770         }
771         FS_UNLOCK
772       }
773
774 #endif /* FS_STATS_DETAILED */
775
776     osi_auditU (tcall, FetchACLEvent, errorCode, AUD_FID, Fid, AUD_END);
777     return errorCode;
778
779 } /*SRXAFS_FetchACL*/
780
781
782 /*
783  * This routine is called exclusively by SRXAFS_FetchStatus(), and should be
784  * merged into it when possible.
785  */
786 SAFSS_FetchStatus (tcon, Fid, OutStatus, CallBack, Sync)
787     struct rx_connection *tcon;         /* Rx connection handle */
788     struct AFSFid *Fid;                 /* Fid of target file */
789     struct AFSFetchStatus *OutStatus;   /* Returned status for the fid */
790     struct AFSCallBack *CallBack;       /* if r/w, callback promise for Fid */
791     struct AFSVolSync *Sync;            /* volume synchronization parm */
792
793 {
794     Vnode * targetptr = 0;              /* pointer to vnode to fetch */
795     Vnode * parentwhentargetnotdir = 0; /* parent vnode if targetptr is a file */
796     int     errorCode = 0;              /* return code to caller */
797     Volume * volptr = 0;                /* pointer to the volume */
798     struct client *client;              /* pointer to the client data */
799     afs_int32 rights, anyrights;                /* rights for this and any user */
800     struct client *t_client;            /* tmp ptr to client data */
801     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
802
803     /* Get ptr to client data for user Id for logging */
804     t_client = (struct client *)  rx_GetSpecific(tcon, rxcon_client_key);
805     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
806     ViceLog(1, ("SAFS_FetchStatus,  Fid = %u.%d.%d, Host %s, Id %d\n",
807             Fid->Volume, Fid->Vnode, Fid->Unique,
808             inet_ntoa(logHostAddr), t_client->ViceId));
809     FS_LOCK
810     AFSCallStats.FetchStatus++, AFSCallStats.TotalCalls++;
811     FS_UNLOCK
812     /*
813      * Get volume/vnode for the fetched file; caller's rights to it are
814      * also returned
815      */
816     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
817                                      DONTCHECK, &parentwhentargetnotdir,
818                                      &client, READ_LOCK, &rights, &anyrights))
819         goto Bad_FetchStatus;
820
821     /* set volume synchronization information */
822     SetVolumeSync(Sync, volptr);
823
824     /* Are we allowed to fetch Fid's status? */
825     if (targetptr->disk.type != vDirectory) {
826       if (errorCode = Check_PermissionRights(targetptr, client, rights,
827                                              CHK_FETCHSTATUS, 0))
828         goto Bad_FetchStatus;
829     }
830
831     /* set OutStatus From the Fid  */
832     GetStatus(targetptr, OutStatus, rights, anyrights, parentwhentargetnotdir);
833
834     /* If a r/w volume, also set the CallBack state */
835     if (VolumeWriteable(volptr))
836         SetCallBackStruct(AddCallBack(client->host, Fid), CallBack);
837     else {
838       struct AFSFid myFid;              
839       bzero(&myFid, sizeof(struct AFSFid));
840       myFid.Volume = Fid->Volume;
841       SetCallBackStruct(AddVolCallBack(client->host, &myFid), CallBack);
842       }
843
844 Bad_FetchStatus: 
845     /* Update and store volume/vnode and parent vnodes back */
846     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
847     ViceLog(2, ("SAFS_FetchStatus returns %d\n", errorCode)); 
848     return errorCode;
849
850 } /*SAFSS_FetchStatus*/
851
852
853 SRXAFS_BulkStatus(tcon, Fids, OutStats, CallBacks, Sync)
854     struct rx_connection *tcon;
855     struct AFSCBFids *Fids;
856     struct AFSBulkStats *OutStats;
857     struct AFSCBs *CallBacks;
858     struct AFSVolSync *Sync;
859
860 {
861     register int i;
862     afs_int32 nfiles;
863     Vnode * targetptr = 0;              /* pointer to vnode to fetch */
864     Vnode * parentwhentargetnotdir = 0; /* parent vnode if targetptr is a file */
865     int     errorCode = 0;              /* return code to caller */
866     Volume * volptr = 0;                /* pointer to the volume */
867     struct client *client;              /* pointer to the client data */
868     afs_int32 rights, anyrights;                /* rights for this and any user */
869     register struct AFSFid *tfid;       /* file id we're dealing with now */
870     struct rx_call *tcall = (struct rx_call *) tcon; 
871 #if FS_STATS_DETAILED
872     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
873     struct timeval opStartTime,
874                    opStopTime;              /* Start/stop times for RPC op*/
875     struct timeval elapsedTime;             /* Transfer time */
876
877     /*
878      * Set our stats pointer, remember when the RPC operation started, and
879      * tally the operation.
880      */
881     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_BULKSTATUS]);
882     FS_LOCK
883     (opP->numOps)++;
884     FS_UNLOCK
885     TM_GetTimeOfDay(&opStartTime, 0);
886 #endif /* FS_STATS_DETAILED */
887
888     ViceLog(1, ("SAFS_BulkStatus\n"));
889     FS_LOCK
890     AFSCallStats.TotalCalls++;
891     FS_UNLOCK
892
893     nfiles = Fids->AFSCBFids_len;       /* # of files in here */
894     if (nfiles <= 0) {                  /* Sanity check */
895         errorCode = EINVAL;
896         goto Audit_and_Return;
897     }
898
899     /* allocate space for return output parameters */
900     OutStats->AFSBulkStats_val = (struct AFSFetchStatus *)
901         malloc(nfiles * sizeof(struct AFSFetchStatus));
902     OutStats->AFSBulkStats_len = nfiles;
903     CallBacks->AFSCBs_val = (struct AFSCallBack *)
904         malloc(nfiles * sizeof(struct AFSCallBack));
905     CallBacks->AFSCBs_len = nfiles;
906
907     if (errorCode = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
908         goto Bad_BulkStatus;
909
910     tfid = Fids->AFSCBFids_val;
911     for (i=0; i<nfiles; i++, tfid++) {
912         /*
913          * Get volume/vnode for the fetched file; caller's rights to it
914          * are also returned
915          */
916         if (errorCode =
917             GetVolumePackage(tcon, tfid, &volptr, &targetptr,
918                              DONTCHECK, &parentwhentargetnotdir, &client,
919                              READ_LOCK, &rights, &anyrights))
920                 goto Bad_BulkStatus;
921         /* set volume synchronization information, but only once per call */
922         if (i == nfiles)
923             SetVolumeSync(Sync, volptr);
924
925         /* Are we allowed to fetch Fid's status? */
926         if (targetptr->disk.type != vDirectory) {
927           if (errorCode = Check_PermissionRights(targetptr, client, rights,
928                                                CHK_FETCHSTATUS, 0))
929                 goto Bad_BulkStatus;
930         }
931
932         /* set OutStatus From the Fid  */
933         GetStatus(targetptr, &OutStats->AFSBulkStats_val[i],
934                   rights, anyrights, parentwhentargetnotdir);
935
936         /* If a r/w volume, also set the CallBack state */
937         if (VolumeWriteable(volptr))
938             SetCallBackStruct(AddBulkCallBack(client->host, tfid),
939                               &CallBacks->AFSCBs_val[i]);
940         else {
941           struct AFSFid myFid;          
942           bzero(&myFid, sizeof(struct AFSFid));
943           myFid.Volume = tfid->Volume;
944           SetCallBackStruct(AddVolCallBack(client->host, &myFid),
945                               &CallBacks->AFSCBs_val[i]);
946         }
947
948         /* put back the file ID and volume */
949         PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *) 0, volptr);
950         parentwhentargetnotdir = (Vnode *) 0;
951         targetptr = (Vnode *) 0;
952         volptr = (Volume *) 0;
953     }
954
955 Bad_BulkStatus: 
956     /* Update and store volume/vnode and parent vnodes back */
957     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
958     CallPostamble(tcon);
959
960 #if FS_STATS_DETAILED
961     TM_GetTimeOfDay(&opStopTime, 0);
962     if (errorCode == 0) {
963         FS_LOCK
964         (opP->numSuccesses)++;
965         fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
966         fs_stats_AddTo((opP->sumTime), elapsedTime);
967         fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
968         if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
969             fs_stats_TimeAssign((opP->minTime), elapsedTime);
970         }
971         if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
972             fs_stats_TimeAssign((opP->maxTime), elapsedTime);
973         }
974         FS_UNLOCK
975     }   
976
977 #endif /* FS_STATS_DETAILED */
978
979 Audit_and_Return:
980     ViceLog(2, ("SAFS_BulkStatus        returns %d\n", errorCode)); 
981     osi_auditU (tcall, BulkFetchStatusEvent, errorCode, AUD_FIDS, Fids, AUD_END);
982     return errorCode;
983
984 } /*SRXAFS_BulkStatus*/
985
986
987 SRXAFS_FetchStatus (tcon, Fid, OutStatus, CallBack, Sync)
988     struct AFSVolSync *Sync;
989     struct rx_connection *tcon;         /* Rx connection handle */
990     struct AFSFid *Fid;                 /* Fid of target file */
991     struct AFSFetchStatus *OutStatus;   /* Returned status for the fid */
992     struct AFSCallBack *CallBack;       /* if r/w, callback promise for Fid */
993
994 {
995     afs_int32 code;
996     struct rx_call *tcall = (struct rx_call *) tcon; 
997 #if FS_STATS_DETAILED
998     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
999     struct timeval opStartTime,
1000                    opStopTime;              /* Start/stop times for RPC op*/
1001     struct timeval elapsedTime;             /* Transfer time */
1002
1003     /*
1004      * Set our stats pointer, remember when the RPC operation started, and
1005      * tally the operation.
1006      */
1007     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_FETCHSTATUS]);
1008     FS_LOCK
1009     (opP->numOps)++;
1010     FS_UNLOCK
1011     TM_GetTimeOfDay(&opStartTime, 0);
1012 #endif /* FS_STATS_DETAILED */
1013
1014     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
1015         goto Bad_FetchStatus;
1016
1017     code = SAFSS_FetchStatus (tcon, Fid, OutStatus, CallBack, Sync);
1018
1019 Bad_FetchStatus:    
1020     CallPostamble(tcon);
1021
1022 #if FS_STATS_DETAILED
1023     TM_GetTimeOfDay(&opStopTime, 0);
1024     if (code == 0) {
1025         FS_LOCK
1026         (opP->numSuccesses)++;
1027         fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
1028         fs_stats_AddTo((opP->sumTime), elapsedTime);
1029         fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
1030         if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
1031             fs_stats_TimeAssign((opP->minTime), elapsedTime);
1032         }
1033         if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
1034             fs_stats_TimeAssign((opP->maxTime), elapsedTime);
1035         }
1036         FS_UNLOCK
1037       }
1038
1039 #endif /* FS_STATS_DETAILED */
1040
1041     osi_auditU (tcall, FetchStatusEvent, code, AUD_FID, Fid, AUD_END);
1042     return code;
1043
1044 } /*SRXAFS_FetchStatus*/
1045
1046
1047 SRXAFS_StoreData (tcon, Fid, InStatus, Pos, Length, FileLength, OutStatus, Sync)
1048     struct AFSVolSync *Sync;
1049     struct rx_connection *tcon;         /* Rx connection Handle */
1050     struct AFSFid *Fid;                 /* Fid of taret file */
1051     struct AFSStoreStatus *InStatus;    /* Input Status for Fid */
1052     afs_int32 Pos;                              /* Not implemented yet */
1053     afs_int32 Length;                   /* Length of data to store */
1054     afs_int32 FileLength;                       /* Length of file after store */
1055     struct AFSFetchStatus *OutStatus;   /* Returned status for target fid */
1056
1057 {
1058     Vnode * targetptr = 0;              /* pointer to input fid */
1059     Vnode * parentwhentargetnotdir = 0; /* parent of Fid to get ACL */
1060     Vnode   tparentwhentargetnotdir;    /* parent vnode for GetStatus */
1061     int     errorCode = 0;              /* return code for caller */
1062     int     fileCode =  0;              /* return code from vol package */
1063     Volume * volptr = 0;                /* pointer to the volume header */
1064     struct client * client;             /* pointer to client structure */
1065     struct rx_call *tcall;              /* remember the call structure for ftp */
1066     afs_int32 rights, anyrights;                /* rights for this and any user */
1067     struct client *t_client;            /* tmp ptr to client data */
1068     struct in_addr logHostAddr;             /* host ip holder for inet_ntoa */
1069 #if FS_STATS_DETAILED
1070     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
1071     struct fs_stats_xferData *xferP;        /* Ptr to this op's byte size struct */
1072     struct timeval opStartTime,
1073                    opStopTime;              /* Start/stop times for RPC op*/
1074     struct timeval xferStartTime,
1075                    xferStopTime;            /* Start/stop times for xfer portion*/
1076     struct timeval elapsedTime;             /* Transfer time */
1077     afs_int32 bytesToXfer;                          /* # bytes to xfer */
1078     afs_int32 bytesXferred;                         /* # bytes actually xfer */
1079     static afs_int32 tot_bytesXferred; /* shared access protected by FS_LOCK */
1080
1081     /*
1082      * Set our stats pointers, remember when the RPC operation started, and
1083      * tally the operation.
1084      */
1085     opP   = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_STOREDATA]);
1086     xferP = &(afs_FullPerfStats.det.xferOpTimes[FS_STATS_XFERIDX_STOREDATA]);
1087     FS_LOCK
1088     (opP->numOps)++;
1089     FS_UNLOCK
1090
1091     ViceLog(1, ("StoreData: Fid = %u.%d.%d\n",
1092             Fid->Volume, Fid->Vnode, Fid->Unique));
1093     TM_GetTimeOfDay(&opStartTime, 0);
1094 #endif /* FS_STATS_DETAILED */
1095
1096     FS_LOCK
1097     AFSCallStats.StoreData++, AFSCallStats.TotalCalls++;
1098     FS_UNLOCK
1099     /* CallPreamble changes tcon from a call to a conn */
1100     tcall = (struct rx_call *) tcon;
1101     if (errorCode = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
1102         goto Bad_StoreData;
1103
1104     /* Get ptr to client data for user Id for logging */
1105     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
1106     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
1107     ViceLog(5, ("StoreData: Fid = %u.%d.%d, Host %s, Id %d\n",
1108             Fid->Volume, Fid->Vnode, Fid->Unique,
1109             inet_ntoa(logHostAddr), t_client->ViceId));
1110
1111     /*
1112      * Get associated volume/vnode for the stored file; caller's rights
1113      * are also returned
1114      */
1115     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
1116                                      MustNOTBeDIR, &parentwhentargetnotdir,
1117                                      &client, WRITE_LOCK, &rights, &anyrights)) {
1118         goto Bad_StoreData;
1119     }
1120
1121     /* set volume synchronization information */
1122     SetVolumeSync(Sync, volptr);
1123
1124     if ((targetptr->disk.type == vSymlink)) {
1125         /* Should we return a better error code here??? */
1126         errorCode = EISDIR;
1127         goto Bad_StoreData;
1128     }
1129
1130     /* Check if we're allowed to store the data */
1131     if (errorCode = Check_PermissionRights(targetptr, client, rights,
1132                                            CHK_STOREDATA, InStatus)) {
1133         goto Bad_StoreData;
1134     }
1135
1136     /*
1137      * Drop the read lock on the parent directory after saving the parent
1138      * vnode information we need to pass to GetStatus
1139      */
1140     if (parentwhentargetnotdir != NULL) {
1141         tparentwhentargetnotdir = *parentwhentargetnotdir;
1142         VPutVnode(&fileCode, parentwhentargetnotdir);
1143         assert(!fileCode || (fileCode == VSALVAGE));
1144         parentwhentargetnotdir = NULL;
1145     }
1146
1147
1148
1149 #if FS_STATS_DETAILED
1150     /*
1151      * Remember when the data transfer started.
1152      */
1153     TM_GetTimeOfDay(&xferStartTime, 0);
1154 #endif /* FS_STATS_DETAILED */
1155
1156     /* Do the actual storing of the data */
1157 #if FS_STATS_DETAILED
1158     errorCode = StoreData_RXStyle(volptr, targetptr, Fid, client, tcall,
1159                                   Pos, Length, FileLength,
1160                                   (InStatus->Mask & AFS_FSYNC),
1161                                   &bytesToXfer, &bytesXferred);
1162 #else
1163     errorCode = StoreData_RXStyle(volptr, targetptr, Fid, client,
1164                                       tcall, Pos, Length, FileLength,
1165                                       (InStatus->Mask & AFS_FSYNC));
1166     if (errorCode && (!targetptr->changed_newTime))
1167             goto Bad_StoreData;
1168 #endif /* FS_STATS_DETAILED */
1169 #if FS_STATS_DETAILED
1170     /*
1171      * At this point, the data transfer is done, for good or ill.  Remember
1172      * when the transfer ended, bump the number of successes/failures, and
1173      * integrate the transfer size and elapsed time into the stats.  If the
1174      * operation failed, we jump to the appropriate point.
1175      */
1176     TM_GetTimeOfDay(&xferStopTime, 0);
1177     FS_LOCK
1178     (xferP->numXfers)++;
1179     if (!errorCode) {
1180         (xferP->numSuccesses)++;
1181
1182         /*
1183          * Bump the xfer sum by the number of bytes actually sent, NOT the
1184          * target number.
1185          */
1186         tot_bytesXferred += bytesXferred;
1187         (xferP->sumBytes) += (tot_bytesXferred >> 10);
1188         tot_bytesXferred &= 0x3FF;
1189         if (bytesXferred < xferP->minBytes)
1190             xferP->minBytes = bytesXferred;
1191         if (bytesXferred > xferP->maxBytes)
1192             xferP->maxBytes = bytesXferred;
1193       
1194         /*
1195          * Tally the size of the object.  Note: we tally the actual size,
1196          * NOT the number of bytes that made it out over the wire.
1197          */
1198         if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET0)
1199             (xferP->count[0])++;
1200         else
1201             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET1)
1202                 (xferP->count[1])++;
1203         else
1204             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET2)
1205                 (xferP->count[2])++;
1206         else
1207             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET3)
1208                 (xferP->count[3])++;
1209         else
1210             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET4)
1211                 (xferP->count[4])++;
1212         else
1213             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET5)
1214                 (xferP->count[5])++;
1215         else
1216             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET6)
1217                 (xferP->count[6])++;
1218         else
1219             if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET7)
1220                 (xferP->count[7])++;
1221         else
1222             (xferP->count[8])++;
1223       
1224         fs_stats_GetDiff(elapsedTime, xferStartTime, xferStopTime);
1225         fs_stats_AddTo((xferP->sumTime), elapsedTime);
1226         fs_stats_SquareAddTo((xferP->sqrTime), elapsedTime);
1227         if (fs_stats_TimeLessThan(elapsedTime, (xferP->minTime))) {
1228             fs_stats_TimeAssign((xferP->minTime), elapsedTime);
1229         }
1230         if (fs_stats_TimeGreaterThan(elapsedTime, (xferP->maxTime))) {
1231             fs_stats_TimeAssign((xferP->maxTime), elapsedTime);
1232         }
1233     }
1234     FS_UNLOCK
1235
1236     /*
1237      * Finally, go off to tell our caller the bad news in case the
1238      * store failed.
1239      */
1240     if (errorCode && (!targetptr->changed_newTime))
1241             goto Bad_StoreData;
1242 #endif /* FS_STATS_DETAILED */
1243
1244     /* Update the status of the target's vnode */
1245     Update_TargetVnodeStatus(targetptr, TVS_SDATA, client, InStatus, targetptr,
1246                              volptr, 0);
1247
1248     /* Get the updated File's status back to the caller */
1249     GetStatus(targetptr, OutStatus, rights, anyrights, &tparentwhentargetnotdir);
1250
1251 Bad_StoreData: 
1252     /* Update and store volume/vnode and parent vnodes back */
1253     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
1254     ViceLog(2, ("SAFS_StoreData returns %d\n", errorCode));
1255
1256     CallPostamble(tcon);
1257
1258 #if FS_STATS_DETAILED
1259     TM_GetTimeOfDay(&opStopTime, 0);
1260     if (errorCode == 0) {
1261         FS_LOCK
1262         (opP->numSuccesses)++;
1263         fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
1264         fs_stats_AddTo((opP->sumTime), elapsedTime);
1265         fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
1266         if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
1267             fs_stats_TimeAssign((opP->minTime), elapsedTime);
1268         }
1269         if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
1270             fs_stats_TimeAssign((opP->maxTime), elapsedTime);
1271         }
1272         FS_UNLOCK
1273       }
1274 #endif /* FS_STATS_DETAILED */
1275
1276     osi_auditU (tcall, StoreDataEvent, errorCode, AUD_FID, Fid, AUD_END);
1277     return(errorCode);
1278
1279 } /*SRXAFS_StoreData*/
1280
1281
1282 SRXAFS_StoreACL (tcon, Fid, AccessList, OutStatus, Sync)
1283     struct AFSVolSync *Sync;
1284     struct rx_connection *tcon;         /* Rx connection handle */
1285     struct AFSFid *Fid;                 /* Target dir's fid */
1286     struct AFSOpaque *AccessList;       /* Access List's contents */
1287     struct AFSFetchStatus *OutStatus;   /* Returned status of fid */
1288
1289 {
1290     Vnode * targetptr = 0;              /* pointer to input fid */
1291     Vnode * parentwhentargetnotdir = 0; /* parent of Fid to get ACL */
1292     int     errorCode = 0;              /* return code for caller */
1293     struct AFSStoreStatus InStatus;     /* Input status for fid */
1294     Volume * volptr = 0;                /* pointer to the volume header */
1295     struct client * client;             /* pointer to client structure */
1296     afs_int32 rights, anyrights;                /* rights for this and any user */
1297     struct rx_call *tcall = (struct rx_call *) tcon; 
1298     struct client *t_client;            /* tmp ptr to client data */
1299     struct in_addr logHostAddr;             /* host ip holder for inet_ntoa */
1300 #if FS_STATS_DETAILED
1301     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
1302     struct timeval opStartTime,
1303                    opStopTime;              /* Start/stop times for RPC op*/
1304     struct timeval elapsedTime;             /* Transfer time */
1305
1306     /*
1307      * Set our stats pointer, remember when the RPC operation started, and
1308      * tally the operation.
1309      */
1310     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_STOREACL]);
1311     FS_LOCK
1312     (opP->numOps)++;
1313     FS_UNLOCK
1314     TM_GetTimeOfDay(&opStartTime, 0);
1315 #endif /* FS_STATS_DETAILED */
1316     if (errorCode = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
1317         goto Bad_StoreACL;
1318
1319     /* Get ptr to client data for user Id for logging */
1320     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
1321     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
1322     ViceLog(1, ("SAFS_StoreACL, Fid = %u.%d.%d, ACL=%s, Host %s, Id %d\n",
1323             Fid->Volume, Fid->Vnode, Fid->Unique, AccessList->AFSOpaque_val,
1324             inet_ntoa(logHostAddr), t_client->ViceId));
1325     FS_LOCK
1326     AFSCallStats.StoreACL++, AFSCallStats.TotalCalls++;
1327     FS_UNLOCK
1328
1329     InStatus.Mask = 0;      /* not storing any status */
1330
1331     /*
1332      * Get associated volume/vnode for the target dir; caller's rights
1333      * are also returned.
1334      */
1335     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
1336                                      MustBeDIR, &parentwhentargetnotdir,
1337                                      &client, WRITE_LOCK, &rights, &anyrights)) {
1338         goto Bad_StoreACL;
1339     }
1340
1341     /* set volume synchronization information */
1342     SetVolumeSync(Sync, volptr);
1343
1344     /* Check if we have permission to change the dir's ACL */
1345     if (errorCode = Check_PermissionRights(targetptr, client, rights,
1346                                            CHK_STOREACL, &InStatus)) {
1347         goto Bad_StoreACL;
1348     }
1349
1350     /* Build and store the new Access List for the dir */
1351     if (errorCode = RXStore_AccessList(targetptr, AccessList)) {
1352         goto Bad_StoreACL;
1353     }
1354     
1355     targetptr->changed_newTime = 1; /* status change of directory */
1356
1357     /* convert the write lock to a read lock before breaking callbacks */
1358     VVnodeWriteToRead(&errorCode, targetptr);
1359     assert(!errorCode || errorCode == VSALVAGE);
1360
1361     /* break call backs on the directory  */
1362     BreakCallBack(client->host, Fid, 0);
1363
1364     /* Get the updated dir's status back to the caller */
1365     GetStatus(targetptr, OutStatus, rights, anyrights, (struct vnode *)0);
1366
1367 Bad_StoreACL: 
1368     /* Update and store volume/vnode and parent vnodes back */
1369     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
1370     ViceLog(2, ("SAFS_StoreACL returns %d\n", errorCode)); 
1371     CallPostamble(tcon);
1372
1373 #if FS_STATS_DETAILED
1374     TM_GetTimeOfDay(&opStopTime, 0);
1375     if (errorCode == 0) {
1376       FS_LOCK
1377       (opP->numSuccesses)++;
1378       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
1379       fs_stats_AddTo((opP->sumTime), elapsedTime);
1380       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
1381       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
1382         fs_stats_TimeAssign((opP->minTime), elapsedTime);
1383       }
1384       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
1385         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
1386       }
1387       FS_UNLOCK
1388     }
1389 #endif /* FS_STATS_DETAILED */
1390
1391     osi_auditU (tcall, StoreACLEvent, errorCode, AUD_FID, Fid, AUD_END);
1392     return errorCode;
1393
1394 } /*SRXAFS_StoreACL*/
1395
1396
1397 /*
1398  * Note: This routine is called exclusively from SRXAFS_StoreStatus(), and
1399  * should be merged when possible.
1400  */
1401 SAFSS_StoreStatus (tcon, Fid, InStatus, OutStatus, Sync)
1402     struct rx_connection *tcon;         /* Rx connection Handle */
1403     struct AFSFid *Fid;                 /* Target file's fid */
1404     struct AFSStoreStatus *InStatus;    /* Input status for Fid */
1405     struct AFSFetchStatus *OutStatus;   /* Output status for fid */
1406     struct AFSVolSync *Sync;
1407
1408 {
1409     Vnode * targetptr = 0;              /* pointer to input fid */
1410     Vnode * parentwhentargetnotdir = 0; /* parent of Fid to get ACL */
1411     int     errorCode = 0;              /* return code for caller */
1412     Volume * volptr = 0;                /* pointer to the volume header */
1413     struct client * client;             /* pointer to client structure */
1414     afs_int32 rights, anyrights;                /* rights for this and any user */
1415     struct client *t_client;            /* tmp ptr to client data */
1416     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
1417
1418     /* Get ptr to client data for user Id for logging */
1419     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
1420     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
1421     ViceLog(1, ("SAFS_StoreStatus,  Fid = %u.%d.%d, Host %s, Id %d\n",
1422             Fid->Volume, Fid->Vnode,    Fid->Unique,
1423             inet_ntoa(logHostAddr), t_client->ViceId));
1424     FS_LOCK
1425     AFSCallStats.StoreStatus++, AFSCallStats.TotalCalls++;
1426     FS_UNLOCK
1427     /*
1428      * Get volume/vnode for the target file; caller's rights to it are
1429      * also returned
1430      */
1431     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
1432                                      DONTCHECK, &parentwhentargetnotdir,
1433                                      &client, WRITE_LOCK, &rights, &anyrights)) {
1434         goto Bad_StoreStatus;
1435     }
1436
1437     /* set volume synchronization information */
1438     SetVolumeSync(Sync, volptr);
1439
1440     /* Check if the caller has proper permissions to store status to Fid */
1441     if (errorCode = Check_PermissionRights(targetptr, client, rights,
1442                                            CHK_STORESTATUS, InStatus)) {
1443         goto Bad_StoreStatus;
1444     }
1445     /*
1446      * Check for a symbolic link; we can't chmod these (otherwise could
1447      * change a symlink to a mt pt or vice versa)
1448      */
1449     if (targetptr->disk.type == vSymlink && (InStatus->Mask & AFS_SETMODE)) {
1450         errorCode = EINVAL;
1451         goto Bad_StoreStatus;
1452     }
1453
1454     /* Update the status of the target's vnode */
1455     Update_TargetVnodeStatus(targetptr, TVS_SSTATUS, client, InStatus,
1456                              (parentwhentargetnotdir ?
1457                               parentwhentargetnotdir : targetptr), volptr, 0);
1458
1459     /* convert the write lock to a read lock before breaking callbacks */
1460     VVnodeWriteToRead(&errorCode, targetptr);
1461     assert(!errorCode || errorCode == VSALVAGE);
1462
1463     /* Break call backs on Fid */
1464     BreakCallBack(client->host, Fid, 0);
1465
1466     /* Return the updated status back to caller */
1467     GetStatus(targetptr, OutStatus, rights, anyrights, parentwhentargetnotdir);
1468
1469 Bad_StoreStatus: 
1470     /* Update and store volume/vnode and parent vnodes back */
1471     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
1472     ViceLog(2, ("SAFS_StoreStatus returns %d\n", errorCode));
1473     return errorCode;
1474
1475 } /*SAFSS_StoreStatus*/
1476
1477
1478 SRXAFS_StoreStatus (tcon, Fid, InStatus, OutStatus, Sync)
1479     struct AFSVolSync *Sync;
1480     struct rx_connection *tcon;         /* Rx connection Handle */
1481     struct AFSFid *Fid;                 /* Target file's fid */
1482     struct AFSStoreStatus *InStatus;    /* Input status for Fid */
1483     struct AFSFetchStatus *OutStatus;   /* Output status for fid */
1484
1485 {
1486     afs_int32 code;
1487     struct rx_call *tcall = (struct rx_call *) tcon; 
1488 #if FS_STATS_DETAILED
1489     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
1490     struct timeval opStartTime,
1491                    opStopTime;              /* Start/stop times for RPC op*/
1492     struct timeval elapsedTime;             /* Transfer time */
1493
1494     /*
1495      * Set our stats pointer, remember when the RPC operation started, and
1496      * tally the operation.
1497      */
1498     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_STORESTATUS]);
1499     FS_LOCK
1500     (opP->numOps)++;
1501     FS_UNLOCK
1502     TM_GetTimeOfDay(&opStartTime, 0);
1503 #endif /* FS_STATS_DETAILED */
1504
1505     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
1506         goto Bad_StoreStatus;
1507
1508     code = SAFSS_StoreStatus (tcon, Fid, InStatus, OutStatus, Sync);
1509
1510 Bad_StoreStatus:
1511     CallPostamble(tcon);
1512
1513 #if FS_STATS_DETAILED
1514     TM_GetTimeOfDay(&opStopTime, 0);
1515     if (code == 0) {
1516       FS_LOCK
1517       (opP->numSuccesses)++;
1518       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
1519       fs_stats_AddTo((opP->sumTime), elapsedTime);
1520       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
1521       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
1522         fs_stats_TimeAssign((opP->minTime), elapsedTime);
1523       }
1524       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
1525         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
1526       }
1527       FS_UNLOCK
1528     }
1529
1530 #endif /* FS_STATS_DETAILED */
1531
1532     osi_auditU (tcall, StoreStatusEvent, code, AUD_FID, Fid, AUD_END);
1533     return code;
1534
1535 } /*SRXAFS_StoreStatus*/
1536
1537
1538 /*
1539  * This routine is called exclusively by SRXAFS_RemoveFile(), and should be
1540  * merged in when possible.
1541  */
1542 SAFSS_RemoveFile (tcon, DirFid, Name, OutDirStatus, Sync)
1543     struct rx_connection *tcon;          /* Rx connection handle */
1544     struct AFSFid *DirFid;               /* Dir fid for file to remove */
1545     char *Name;                          /* File name to remove */
1546     struct AFSFetchStatus *OutDirStatus; /* Output status for dir fid's */
1547     struct AFSVolSync *Sync;
1548
1549 {
1550     Vnode * parentptr = 0;              /* vnode of input Directory */
1551     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
1552     Vnode * targetptr = 0;              /* file to be deleted */
1553     Volume * volptr = 0;                /* pointer to the volume header */
1554     AFSFid fileFid;                     /* area for Fid from the directory */
1555     int     errorCode = 0;              /* error code */
1556     DirHandle dir;                      /* Handle for dir package I/O */
1557     struct client * client;             /* pointer to client structure */
1558     afs_int32 rights, anyrights;                /* rights for this and any user */
1559     struct client *t_client;            /* tmp ptr to client data */
1560     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
1561
1562     /* Get ptr to client data for user Id for logging */
1563     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
1564     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
1565     ViceLog(1, ("SAFS_RemoveFile %s,  Did = %u.%d.%d, Host %s, Id %d\n",
1566             Name, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
1567             inet_ntoa(logHostAddr), t_client->ViceId));
1568     FS_LOCK
1569     AFSCallStats.RemoveFile++, AFSCallStats.TotalCalls++;
1570     FS_UNLOCK
1571     /*
1572      * Get volume/vnode for the parent dir; caller's access rights are
1573      * also returned
1574      */
1575     if (errorCode = GetVolumePackage(tcon, DirFid, &volptr, &parentptr,
1576                                      MustBeDIR, &parentwhentargetnotdir,
1577                                      &client, WRITE_LOCK, &rights, &anyrights)) {
1578         goto Bad_RemoveFile;
1579     }
1580     /* set volume synchronization information */
1581     SetVolumeSync(Sync, volptr);
1582
1583     /* Does the caller has delete (& write) access to the parent directory? */
1584     if (errorCode = CheckWriteMode(parentptr, rights, PRSFS_DELETE)) {
1585         goto Bad_RemoveFile;
1586     }
1587
1588     /* Actually delete the desired file */
1589     if (errorCode = DeleteTarget(parentptr, volptr, &targetptr, &dir,
1590                                  &fileFid, Name, MustNOTBeDIR)) {
1591         goto Bad_RemoveFile;
1592     }
1593
1594     /* Update the vnode status of the parent dir */
1595 #if FS_STATS_DETAILED
1596     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
1597                              parentptr->disk.linkCount, client->InSameNetwork);
1598 #else
1599     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
1600                              parentptr->disk.linkCount);
1601 #endif /* FS_STATS_DETAILED */
1602
1603     /* Return the updated parent dir's status back to caller */
1604     GetStatus(parentptr, OutDirStatus, rights, anyrights, (struct vnode *)0);
1605
1606     /* Handle internal callback state for the parent and the deleted file */
1607     if (targetptr->disk.linkCount == 0) {
1608         /* no references left, discard entry */
1609         DeleteFileCallBacks(&fileFid);
1610         /* convert the parent lock to a read lock before breaking callbacks */
1611         VVnodeWriteToRead(&errorCode, parentptr);
1612         assert(!errorCode || errorCode == VSALVAGE);
1613     } else {
1614         /* convert the parent lock to a read lock before breaking callbacks */
1615         VVnodeWriteToRead(&errorCode, parentptr);
1616         assert(!errorCode || errorCode == VSALVAGE);
1617         /* convert the target lock to a read lock before breaking callbacks */
1618         VVnodeWriteToRead(&errorCode, targetptr);
1619         assert(!errorCode || errorCode == VSALVAGE);
1620         /* tell all the file has changed */
1621         BreakCallBack(client->host, &fileFid, 1);
1622     }
1623
1624     /* break call back on the directory */
1625     BreakCallBack(client->host, DirFid, 0);
1626
1627 Bad_RemoveFile: 
1628     /* Update and store volume/vnode and parent vnodes back */
1629     PutVolumePackage(parentwhentargetnotdir, targetptr, parentptr, volptr);
1630     ViceLog(2, ("SAFS_RemoveFile returns %d\n", errorCode)); 
1631     return errorCode;
1632
1633 } /*SAFSS_RemoveFile*/
1634
1635
1636 SRXAFS_RemoveFile (tcon, DirFid, Name, OutDirStatus, Sync)
1637     struct AFSVolSync *Sync;
1638     struct rx_connection *tcon;          /* Rx connection handle */
1639     struct AFSFid *DirFid;               /* Dir fid for file to remove */
1640     char *Name;                          /* File name to remove */
1641     struct AFSFetchStatus *OutDirStatus; /* Output status for dir fid's */
1642
1643 {
1644     afs_int32 code;
1645     struct rx_call *tcall = (struct rx_call *) tcon; 
1646 #if FS_STATS_DETAILED
1647     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
1648     struct timeval opStartTime,
1649                    opStopTime;              /* Start/stop times for RPC op*/
1650     struct timeval elapsedTime;             /* Transfer time */
1651
1652     /*
1653      * Set our stats pointer, remember when the RPC operation started, and
1654      * tally the operation.
1655      */
1656     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_REMOVEFILE]);
1657     FS_LOCK
1658     (opP->numOps)++;
1659     FS_UNLOCK
1660     TM_GetTimeOfDay(&opStartTime, 0);
1661 #endif /* FS_STATS_DETAILED */
1662
1663     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
1664         goto Bad_RemoveFile;
1665
1666     code = SAFSS_RemoveFile (tcon, DirFid, Name, OutDirStatus, Sync);
1667
1668 Bad_RemoveFile:    
1669     CallPostamble(tcon);
1670
1671 #if FS_STATS_DETAILED
1672     TM_GetTimeOfDay(&opStopTime, 0);
1673     if (code == 0) {
1674       FS_LOCK
1675       (opP->numSuccesses)++;
1676       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
1677       fs_stats_AddTo((opP->sumTime), elapsedTime);
1678       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
1679       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
1680         fs_stats_TimeAssign((opP->minTime), elapsedTime);
1681       }
1682       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
1683         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
1684       }
1685       FS_UNLOCK
1686     }
1687
1688 #endif /* FS_STATS_DETAILED */
1689
1690     osi_auditU (tcall, RemoveFileEvent, code, AUD_FID, DirFid, AUD_STR, Name, AUD_END);
1691     return code;
1692
1693 } /*SRXAFS_RemoveFile*/
1694
1695
1696 /*
1697  * This routine is called exclusively from SRXAFS_CreateFile(), and should
1698  * be merged in when possible.
1699  */
1700 SAFSS_CreateFile (tcon, DirFid, Name, InStatus, OutFid, OutFidStatus,
1701                  OutDirStatus, CallBack, Sync)
1702     struct rx_connection *tcon;          /* Rx connection handle */
1703     struct AFSFid *DirFid;               /* Parent Dir fid */
1704     char *Name;                          /* File name to be created */
1705     struct AFSStoreStatus *InStatus;     /* Input status for newly created file */
1706     struct AFSFid *OutFid;               /* Fid for newly created file */
1707     struct AFSFetchStatus *OutFidStatus; /* Output status for new file */
1708     struct AFSFetchStatus *OutDirStatus; /* Ouput status for the parent dir */
1709     struct AFSCallBack *CallBack;        /* Return callback promise for new file */
1710     struct AFSVolSync *Sync;
1711
1712 {
1713     Vnode * parentptr = 0;              /* vnode of input Directory */
1714     Vnode * targetptr = 0;              /* vnode of the new file */
1715     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
1716     Volume * volptr = 0;                /* pointer to the volume header */
1717     int     errorCode = 0;              /* error code */
1718     DirHandle dir;                      /* Handle for dir package I/O */
1719     struct client * client;             /* pointer to client structure */
1720     afs_int32 rights, anyrights;                /* rights for this and any user */
1721     struct client *t_client;            /* tmp ptr to client data */
1722     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
1723
1724     /* Get ptr to client data for user Id for logging */
1725     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
1726     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
1727     ViceLog(1, ("SAFS_CreateFile %s,  Did = %u.%d.%d, Host %s, Id %d\n",
1728             Name, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
1729             inet_ntoa(logHostAddr), t_client->ViceId));
1730     FS_LOCK
1731     AFSCallStats.CreateFile++, AFSCallStats.TotalCalls++;
1732     FS_UNLOCK
1733     if (!FileNameOK(Name)) {
1734       errorCode = EINVAL;
1735       goto Bad_CreateFile;
1736     }
1737
1738     /*
1739      * Get associated volume/vnode for the parent dir; caller long are
1740      * also returned
1741      */
1742     if (errorCode = GetVolumePackage(tcon, DirFid, &volptr, &parentptr,
1743                                      MustBeDIR, &parentwhentargetnotdir,
1744                                      &client, WRITE_LOCK, &rights, &anyrights)) {
1745         goto Bad_CreateFile;
1746     }
1747
1748     /* set volume synchronization information */
1749     SetVolumeSync(Sync, volptr);
1750
1751     /* Can we write (and insert) onto the parent directory? */
1752     if (errorCode = CheckWriteMode(parentptr, rights, PRSFS_INSERT)) {
1753         goto Bad_CreateFile;
1754     }
1755     /* get a new vnode for the file to be created and set it up */
1756     if (errorCode = Alloc_NewVnode(parentptr, &dir, volptr, &targetptr,
1757                                    Name, OutFid, vFile, nBlocks(0))) {
1758         goto Bad_CreateFile;
1759     }
1760
1761     /* update the status of the parent vnode */
1762 #if FS_STATS_DETAILED
1763     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
1764                              parentptr->disk.linkCount, client->InSameNetwork);
1765 #else
1766     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
1767                              parentptr->disk.linkCount);
1768 #endif /* FS_STATS_DETAILED */
1769
1770     /* update the status of the new file's vnode */
1771     Update_TargetVnodeStatus(targetptr, TVS_CFILE, client, InStatus,
1772                              parentptr, volptr, 0);
1773
1774     /* set up the return status for the parent dir and the newly created file */
1775     GetStatus(targetptr, OutFidStatus, rights, anyrights, parentptr);
1776     GetStatus(parentptr, OutDirStatus, rights, anyrights, (struct vnode *)0);
1777
1778     /* convert the write lock to a read lock before breaking callbacks */
1779     VVnodeWriteToRead(&errorCode, parentptr);
1780     assert(!errorCode || errorCode == VSALVAGE);
1781     
1782     /* break call back on parent dir */
1783     BreakCallBack(client->host, DirFid, 0);
1784
1785     /* Return a callback promise for the newly created file to the caller */
1786     SetCallBackStruct(AddCallBack(client->host, OutFid), CallBack);
1787
1788 Bad_CreateFile:
1789     /* Update and store volume/vnode and parent vnodes back */
1790     PutVolumePackage(parentwhentargetnotdir, targetptr, parentptr, volptr);
1791     ViceLog(2, ("SAFS_CreateFile returns %d\n", errorCode)); 
1792     return errorCode;
1793
1794 } /*SAFSS_CreateFile*/
1795
1796
1797 SRXAFS_CreateFile (tcon, DirFid, Name, InStatus, OutFid, OutFidStatus, OutDirStatus, CallBack, Sync)
1798     struct AFSVolSync *Sync;
1799     struct rx_connection *tcon;          /* Rx connection handle */
1800     struct AFSFid *DirFid;               /* Parent Dir fid */
1801     char *Name;                          /* File name to be created */
1802     struct AFSStoreStatus *InStatus;     /* Input status for newly created file */
1803     struct AFSFid *OutFid;               /* Fid for newly created file */
1804     struct AFSFetchStatus *OutFidStatus; /* Output status for new file */
1805     struct AFSFetchStatus *OutDirStatus; /* Ouput status for the parent dir */
1806     struct AFSCallBack *CallBack;        /* Return callback promise for new file */
1807
1808 {
1809     afs_int32 code;
1810     struct rx_call *tcall = (struct rx_call *) tcon; 
1811 #if FS_STATS_DETAILED
1812     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
1813     struct timeval opStartTime,
1814                    opStopTime;              /* Start/stop times for RPC op*/
1815     struct timeval elapsedTime;             /* Transfer time */
1816
1817     /*
1818      * Set our stats pointer, remember when the RPC operation started, and
1819      * tally the operation.
1820      */
1821     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_CREATEFILE]);
1822     FS_LOCK
1823     (opP->numOps)++;
1824     FS_UNLOCK
1825     TM_GetTimeOfDay(&opStartTime, 0);
1826 #endif /* FS_STATS_DETAILED */
1827
1828     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
1829         goto Bad_CreateFile;
1830
1831     code = SAFSS_CreateFile (tcon, DirFid, Name, InStatus, OutFid,
1832                             OutFidStatus, OutDirStatus, CallBack, Sync);
1833
1834 Bad_CreateFile:    
1835     CallPostamble(tcon);
1836
1837 #if FS_STATS_DETAILED
1838     TM_GetTimeOfDay(&opStopTime, 0);
1839     if (code == 0) {
1840       FS_LOCK
1841       (opP->numSuccesses)++;
1842       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
1843       fs_stats_AddTo((opP->sumTime), elapsedTime);
1844       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
1845       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
1846         fs_stats_TimeAssign((opP->minTime), elapsedTime);
1847       }
1848       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
1849         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
1850       }
1851       FS_UNLOCK
1852     }
1853 #endif /* FS_STATS_DETAILED */
1854
1855     osi_auditU (tcall, CreateFileEvent, code, AUD_FID, DirFid, AUD_STR, Name, AUD_END);
1856     return code;
1857
1858 } /*SRXAFS_CreateFile*/
1859
1860
1861 /*
1862  * This routine is called exclusively from SRXAFS_Rename(), and should be
1863  * merged in when possible.
1864  */
1865 SAFSS_Rename (tcon, OldDirFid, OldName, NewDirFid, NewName, OutOldDirStatus,
1866              OutNewDirStatus, Sync)
1867     struct rx_connection *tcon;             /* Rx connection handle */
1868     struct AFSFid *OldDirFid;               /* From parent dir's fid */
1869     char *OldName;                          /* From file name */
1870     struct AFSFid *NewDirFid;               /* To parent dir's fid */
1871     char *NewName;                          /* To new file name */
1872     struct AFSFetchStatus *OutOldDirStatus; /* Output status for From parent dir */
1873     struct AFSFetchStatus *OutNewDirStatus; /* Output status for To parent dir */
1874     struct AFSVolSync *Sync;
1875
1876 {
1877     Vnode * oldvptr = 0;        /* vnode of the old Directory */
1878     Vnode * newvptr = 0;        /* vnode of the new Directory */
1879     Vnode * fileptr = 0;        /* vnode of the file to move */
1880     Vnode * newfileptr = 0;     /* vnode of the file to delete */
1881     Vnode * testvptr = 0;       /* used in directory tree walk */
1882     Vnode * parent = 0;         /* parent for use in SetAccessList */
1883     int     errorCode = 0;      /* error code */
1884     int     fileCode = 0;       /* used when writing Vnodes */
1885     VnodeId testnode;           /* used in directory tree walk */
1886     AFSFid fileFid;             /* Fid of file to move */
1887     AFSFid newFileFid;          /* Fid of new file */
1888     DirHandle olddir;           /* Handle for dir package I/O */
1889     DirHandle newdir;           /* Handle for dir package I/O */
1890     DirHandle filedir;          /* Handle for dir package I/O */
1891     DirHandle newfiledir;       /* Handle for dir package I/O */
1892     Volume * volptr = 0;        /* pointer to the volume header */
1893     struct client * client;     /* pointer to client structure */
1894     afs_int32 rights, anyrights;        /* rights for this and any user */
1895     afs_int32 newrights;                /* rights for this user */
1896     afs_int32 newanyrights;             /* rights for any user */
1897     int doDelete;               /* deleted the rename target (ref count now 0) */
1898     int code;
1899     struct client *t_client;            /* tmp ptr to client data */
1900     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
1901
1902     /* Get ptr to client data for user Id for logging */
1903     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
1904     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
1905     ViceLog(1, ("SAFS_Rename %s to %s,  Fid = %u.%d.%d to %u.%d.%d, Host %s, Id %d\n",
1906             OldName, NewName, OldDirFid->Volume, OldDirFid->Vnode,
1907             OldDirFid->Unique, NewDirFid->Volume, NewDirFid->Vnode,
1908             NewDirFid->Unique,
1909             inet_ntoa(logHostAddr), t_client->ViceId));
1910     FS_LOCK
1911     AFSCallStats.Rename++, AFSCallStats.TotalCalls++;
1912     FS_UNLOCK
1913     if (!FileNameOK(NewName)) {
1914         errorCode = EINVAL;
1915         goto Bad_Rename;
1916     }
1917     if (OldDirFid->Volume != NewDirFid->Volume) {
1918         DFlush();
1919         errorCode = EXDEV;
1920         goto Bad_Rename;
1921     }
1922     if ( (strcmp(OldName, ".") == 0) || (strcmp(OldName, "..") == 0) ||
1923          (strcmp(NewName, ".") == 0) || (strcmp(NewName, "..") == 0) || 
1924          (strlen(NewName) == 0) || (strlen(OldName) == 0)  ) {
1925         DFlush();
1926         errorCode = EINVAL;
1927         goto Bad_Rename;
1928     }
1929
1930     if (OldDirFid->Vnode <= NewDirFid->Vnode) {
1931         if  (errorCode = GetVolumePackage(tcon, OldDirFid, &volptr,
1932                                           &oldvptr, MustBeDIR, &parent,
1933                                           &client, WRITE_LOCK, &rights,
1934                                           &anyrights)) {
1935             DFlush();
1936             goto Bad_Rename;
1937         }
1938         if (OldDirFid->Vnode == NewDirFid->Vnode) {
1939             newvptr = oldvptr;
1940             newrights = rights, newanyrights = anyrights;
1941         }
1942         else
1943             if (errorCode = GetVolumePackage(tcon, NewDirFid, &volptr,
1944                                              &newvptr, MustBeDIR, &parent,
1945                                              &client, WRITE_LOCK, &newrights,
1946                                              &newanyrights)) {
1947                 DFlush();
1948                 goto Bad_Rename;
1949             }
1950     }
1951     else {
1952         if (errorCode = GetVolumePackage(tcon, NewDirFid, &volptr,
1953                                          &newvptr, MustBeDIR, &parent,
1954                                          &client, WRITE_LOCK, &newrights,
1955                                          &newanyrights)) {
1956             DFlush();
1957             goto Bad_Rename;
1958         }
1959         if (errorCode = GetVolumePackage(tcon, OldDirFid, &volptr, &oldvptr,
1960                                          MustBeDIR, &parent, &client, WRITE_LOCK,
1961                                          &rights, &anyrights)) {
1962             DFlush();
1963             goto Bad_Rename;
1964         }
1965     }
1966
1967     /* set volume synchronization information */
1968     SetVolumeSync(Sync, volptr);
1969
1970     if (errorCode = CheckWriteMode(oldvptr, rights, PRSFS_DELETE)) {
1971         goto Bad_Rename;
1972     }
1973     if (errorCode = CheckWriteMode(newvptr, newrights, PRSFS_INSERT)) {
1974         goto Bad_Rename;
1975     }
1976
1977     /* The CopyOnWrite might return ENOSPC ( disk full). Even if the second
1978     *  call to CopyOnWrite returns error, it is not necessary to revert back
1979     *  the effects of the first call because the contents of the volume is 
1980     *  not modified, it is only replicated.
1981     */
1982     if (oldvptr->disk.cloned)
1983     {
1984         ViceLog(25, ("Rename : calling CopyOnWrite on  old dir\n"));
1985          if ( errorCode = CopyOnWrite(oldvptr, volptr) )
1986                 goto Bad_Rename;
1987     }
1988     SetDirHandle(&olddir, oldvptr);
1989     if (newvptr->disk.cloned)
1990     {
1991         ViceLog(25, ("Rename : calling CopyOnWrite on  new dir\n"));
1992         if ( errorCode = CopyOnWrite(newvptr, volptr) )
1993                 goto Bad_Rename;        
1994     }
1995
1996     SetDirHandle(&newdir, newvptr);
1997
1998     /* Lookup the file to delete its vnode */
1999     if (Lookup(&olddir, OldName, &fileFid)) {
2000         errorCode = ENOENT;
2001         goto Bad_Rename;
2002     }
2003     if (fileFid.Vnode == oldvptr->vnodeNumber ||
2004         fileFid.Vnode == newvptr->vnodeNumber) {
2005         errorCode = FSERR_ELOOP;
2006         goto Bad_Rename;
2007     }
2008     fileFid.Volume = V_id(volptr);
2009     fileptr = VGetVnode(&errorCode, volptr, fileFid.Vnode, WRITE_LOCK);
2010     if (errorCode != 0) {
2011         ViceLog (0, ("SAFSS_Rename(): Error in VGetVnode() for old file %s, code %d\n", OldName, errorCode));
2012         VTakeOffline (volptr);
2013         goto Bad_Rename;
2014     }
2015     if (fileptr->disk.uniquifier != fileFid.Unique) {
2016         ViceLog (0, ("SAFSS_Rename(): Old file %s uniquifier mismatch\n", OldName));
2017         VTakeOffline (volptr);
2018         errorCode = EIO;
2019         goto Bad_Rename;
2020     }
2021
2022     if (fileptr->disk.type != vDirectory &&
2023         oldvptr != newvptr &&
2024         fileptr->disk.linkCount != 1) {
2025         /*
2026          * Hard links exist to this file - cannot move one of the links to
2027          * a new directory because of AFS restrictions (this is the same
2028          * reason that links cannot be made across directories, i.e.
2029          * access lists)
2030          */
2031         errorCode = EXDEV;
2032         goto Bad_Rename;
2033     }
2034
2035     /* Lookup the new file  */
2036     if (!(Lookup(&newdir, NewName, &newFileFid))) {
2037         if (!(newrights & PRSFS_DELETE)) {
2038             errorCode = EACCES;
2039             goto Bad_Rename;
2040         }
2041         if (newFileFid.Vnode == oldvptr->vnodeNumber ||
2042                 newFileFid.Vnode == newvptr->vnodeNumber ||
2043                 newFileFid.Vnode == fileFid.Vnode) {
2044             errorCode = EINVAL;
2045             goto Bad_Rename;
2046         }
2047         newFileFid.Volume = V_id(volptr);
2048         newfileptr = VGetVnode(&errorCode, volptr, newFileFid.Vnode, WRITE_LOCK);
2049         if (errorCode != 0) {
2050             ViceLog (0, ("SAFSS_Rename(): Error in VGetVnode() for new file %s, code %d\n", NewName, errorCode));
2051             VTakeOffline (volptr);
2052             goto Bad_Rename;
2053         }
2054         if (fileptr->disk.uniquifier != fileFid.Unique) {
2055             ViceLog (0, ("SAFSS_Rename(): New file %s uniquifier mismatch\n", NewName));
2056             VTakeOffline (volptr);
2057             errorCode = EIO;
2058             goto Bad_Rename;
2059         }
2060         SetDirHandle(&newfiledir, newfileptr);
2061         /* Now check that we're moving directories over directories properly, etc.
2062          * return proper POSIX error codes:
2063          * if fileptr is a file and new is a dir: EISDIR.
2064          * if fileptr is a dir and new is a file: ENOTDIR.
2065          * Also, dir to be removed must be empty, of course.
2066          */
2067         if (newfileptr->disk.type == vDirectory) {
2068             if (fileptr->disk.type != vDirectory) {
2069                 errorCode = EISDIR;
2070                 goto Bad_Rename;
2071             }
2072             if ((IsEmpty(&newfiledir))) {
2073                 errorCode = EEXIST;
2074                 goto Bad_Rename;
2075             }
2076         }
2077         else {
2078             if (fileptr->disk.type == vDirectory) {
2079                 errorCode = ENOTDIR;
2080                 goto Bad_Rename;
2081             }
2082         }
2083     }
2084
2085     /*
2086      * ok - now we check that the old name is not above new name in the
2087      * directory structure.  This is to prevent removing a subtree alltogether
2088      */
2089     if ((oldvptr != newvptr) && (fileptr->disk.type == vDirectory)) {
2090         for (testnode = newvptr->disk.parent; testnode != 0;) {
2091             if (testnode == oldvptr->vnodeNumber) {
2092                 testnode = oldvptr->disk.parent;
2093                 continue;
2094             }
2095             if ((testnode == fileptr->vnodeNumber) ||
2096                 (testnode == newvptr->vnodeNumber)) {
2097                 errorCode = FSERR_ELOOP;
2098                 goto Bad_Rename;
2099             }
2100             if ((newfileptr) && (testnode == newfileptr->vnodeNumber)) {
2101                 errorCode = FSERR_ELOOP;
2102                 goto Bad_Rename;
2103             }
2104             testvptr = VGetVnode(&errorCode, volptr, testnode, READ_LOCK);
2105             assert(errorCode == 0);
2106             testnode = testvptr->disk.parent;
2107             VPutVnode(&errorCode, testvptr);
2108             assert(errorCode == 0);
2109         }
2110     }
2111     /* Do the CopyonWrite first before modifying anything else. Copying is
2112      *  required because we may have to change entries for .. 
2113      */
2114     if ((fileptr->disk.type == vDirectory ) && (fileptr->disk.cloned) )
2115     {
2116         ViceLog(25, ("Rename : calling CopyOnWrite on  target dir\n"));
2117         if ( errorCode = CopyOnWrite(fileptr, volptr) )
2118                 goto Bad_Rename;
2119     }
2120
2121     /* If the new name exists already, delete it and the file it points to */
2122     doDelete = 0;
2123     if (newfileptr) {
2124         /* Delete NewName from its directory */
2125         code = Delete(&newdir, NewName);
2126         assert(code == 0);
2127
2128         /* Drop the link count */
2129         newfileptr->disk.linkCount--;
2130         if (newfileptr->disk.linkCount == 0) {      /* Link count 0 - delete */
2131             VAdjustDiskUsage(&errorCode, volptr,
2132                              -(int)nBlocks(newfileptr->disk.length), 0);
2133             if (VN_GET_INO(newfileptr)) {
2134                 IH_REALLYCLOSE(newfileptr->handle);
2135                 errorCode = IH_DEC(V_linkHandle(volptr),
2136                                  VN_GET_INO(newfileptr),
2137                                  V_parentId(volptr));
2138                 IH_RELEASE(newfileptr->handle);
2139                 if (errorCode == -1) {
2140                     ViceLog(0, ("Del: inode=%d, name=%s, errno=%d\n",
2141                                 PrintInode(NULL, VN_GET_INO(newfileptr)),
2142                                 NewName, errno));
2143                     if ((errno != ENOENT) && (errno != EIO) && (errno != ENXIO))
2144                         ViceLog(0, ("Do we need to fsck?"));
2145                 } 
2146             }
2147             VN_SET_INO(newfileptr, (Inode)0);
2148             newfileptr->delete = 1;         /* Mark NewName vnode to delete */
2149             doDelete = 1;
2150         } else {
2151             /* Link count did not drop to zero.
2152              * Mark NewName vnode as changed - updates stime.
2153              */
2154             newfileptr->changed_newTime = 1;
2155         }
2156     }
2157     
2158     /*
2159      * If the create below fails, and the delete above worked, we have
2160      * removed the new name and not replaced it.  This is not very likely,
2161      * but possible.  We could try to put the old file back, but it is
2162      * highly unlikely that it would work since it would involve issuing
2163      * another create.
2164      */
2165     if (errorCode = Create(&newdir,(char *) NewName, &fileFid))
2166         goto Bad_Rename;
2167
2168     /* Delete the old name */
2169     assert(Delete(&olddir,(char *) OldName) == 0);
2170
2171     /* if the directory length changes, reflect it in the statistics */
2172 #if FS_STATS_DETAILED
2173     Update_ParentVnodeStatus(oldvptr, volptr, &olddir, client->ViceId,
2174                              oldvptr->disk.linkCount, client->InSameNetwork);
2175     Update_ParentVnodeStatus(newvptr, volptr, &newdir, client->ViceId,
2176                              newvptr->disk.linkCount, client->InSameNetwork);
2177 #else
2178     Update_ParentVnodeStatus(oldvptr, volptr, &olddir, client->ViceId,
2179                              oldvptr->disk.linkCount);
2180     Update_ParentVnodeStatus(newvptr, volptr, &newdir, client->ViceId,
2181                              newvptr->disk.linkCount);
2182 #endif /* FS_STATS_DETAILED */
2183
2184     if (oldvptr == newvptr)
2185         oldvptr->disk.dataVersion--;    /* Since it was bumped by 2! */
2186
2187     fileptr->disk.parent = newvptr->vnodeNumber;
2188     fileptr->changed_newTime = 1;       /* status change of moved file */
2189
2190     /* if we are dealing with a rename of a directory */
2191     if (fileptr->disk.type == vDirectory) {
2192         assert(!fileptr->disk.cloned);          
2193         SetDirHandle(&filedir, fileptr);
2194         /* fix .. to point to the correct place */
2195         Delete(&filedir, ".."); /* No assert--some directories may be bad */
2196         assert(Create(&filedir, "..", NewDirFid) == 0);
2197         fileptr->disk.dataVersion++;
2198         /* if the parent directories are different the link counts have to be   */
2199         /* changed due to .. in the renamed directory */
2200         if (oldvptr != newvptr) {
2201             oldvptr->disk.linkCount--;
2202             newvptr->disk.linkCount++;
2203         }
2204     }
2205
2206     /* set up return status */
2207     GetStatus(oldvptr, OutOldDirStatus, rights, anyrights, (struct vnode *)0);
2208     GetStatus(newvptr, OutNewDirStatus, newrights, newanyrights, (struct vnode *)0);
2209     if (newfileptr && doDelete) {
2210         DeleteFileCallBacks(&newFileFid);       /* no other references */
2211     }
2212
2213     DFlush();
2214
2215     /* convert the write locks to a read locks before breaking callbacks */
2216     VVnodeWriteToRead(&errorCode, newvptr);
2217     assert(!errorCode || errorCode == VSALVAGE);
2218     if (oldvptr != newvptr) {
2219         VVnodeWriteToRead(&errorCode, oldvptr);
2220         assert(!errorCode || errorCode == VSALVAGE);
2221     }
2222     if (newfileptr && !doDelete) {
2223         /* convert the write lock to a read lock before breaking callbacks */
2224         VVnodeWriteToRead(&errorCode, newfileptr);
2225         assert(!errorCode || errorCode == VSALVAGE);
2226     }
2227
2228     /* break call back on NewDirFid, OldDirFid, NewDirFid and newFileFid  */
2229     BreakCallBack(client->host, NewDirFid, 0);
2230     if (oldvptr != newvptr) {
2231         BreakCallBack(client->host, OldDirFid, 0);
2232         if (fileptr->disk.type == vDirectory) /* if a dir moved, .. changed */
2233             BreakCallBack(client->host, &fileFid, 0);
2234     }
2235     if (newfileptr) {
2236         /* Note:  it is not necessary to break the callback */
2237         if (doDelete)
2238             DeleteFileCallBacks(&newFileFid);   /* no other references */
2239         else
2240             /* other's still exist (with wrong link count) */
2241             BreakCallBack(client->host, &newFileFid, 1);
2242     }
2243
2244 Bad_Rename: 
2245     if (newfileptr) {
2246         VPutVnode(&fileCode, newfileptr);
2247         assert(fileCode == 0);
2248     }
2249     PutVolumePackage(fileptr, (newvptr && newvptr != oldvptr? newvptr : 0),
2250                      oldvptr, volptr);
2251     ViceLog(2, ("SAFS_Rename returns %d\n", errorCode));
2252     return errorCode;
2253
2254 } /*SAFSS_Rename*/
2255
2256
2257 SRXAFS_Rename (tcon, OldDirFid, OldName, NewDirFid, NewName, OutOldDirStatus, OutNewDirStatus, Sync)
2258     struct AFSVolSync *Sync;
2259     struct rx_connection *tcon;              /* Rx connection handle */
2260     struct AFSFid *OldDirFid;                /* From parent dir's fid */
2261     char *OldName;                           /* From file name */
2262     struct AFSFid *NewDirFid;                /* To parent dir's fid */
2263     char *NewName;                           /* To new file name */
2264     struct AFSFetchStatus *OutOldDirStatus;  /* Output status for From parent dir */
2265     struct AFSFetchStatus *OutNewDirStatus;  /* Output status for To parent dir */
2266
2267 {
2268     afs_int32 code;
2269     struct rx_call *tcall = (struct rx_call *) tcon; 
2270 #if FS_STATS_DETAILED
2271     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
2272     struct timeval opStartTime,
2273                    opStopTime;              /* Start/stop times for RPC op*/
2274     struct timeval elapsedTime;             /* Transfer time */
2275
2276     /*
2277      * Set our stats pointer, remember when the RPC operation started, and
2278      * tally the operation.
2279      */
2280     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_RENAME]);
2281     FS_LOCK
2282     (opP->numOps)++;
2283     FS_UNLOCK
2284     TM_GetTimeOfDay(&opStartTime, 0);
2285 #endif /* FS_STATS_DETAILED */
2286
2287     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
2288         goto Bad_Rename;
2289
2290     code = SAFSS_Rename (tcon, OldDirFid, OldName, NewDirFid, NewName,
2291                          OutOldDirStatus, OutNewDirStatus, Sync);
2292
2293 Bad_Rename:    
2294     CallPostamble(tcon);
2295
2296 #if FS_STATS_DETAILED
2297     TM_GetTimeOfDay(&opStopTime, 0);
2298     if (code == 0) {
2299       FS_LOCK
2300       (opP->numSuccesses)++;
2301       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
2302       fs_stats_AddTo((opP->sumTime), elapsedTime);
2303       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
2304       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
2305         fs_stats_TimeAssign((opP->minTime), elapsedTime);
2306       }
2307       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
2308         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
2309       }
2310       FS_UNLOCK
2311     }
2312
2313 #endif /* FS_STATS_DETAILED */
2314
2315     osi_auditU (tcall, RenameFileEvent, code, AUD_FID, OldDirFid, AUD_STR, OldName, AUD_FID, NewDirFid, AUD_STR, NewName, AUD_END);
2316     return code;
2317
2318 } /*SRXAFS_Rename*/
2319
2320
2321 /*
2322  * This routine is called exclusively by SRXAFS_Symlink(), and should be
2323  * merged into it when possible.
2324  */
2325 SAFSS_Symlink (tcon, DirFid, Name, LinkContents, InStatus, OutFid, OutFidStatus, OutDirStatus, Sync)
2326     struct rx_connection *tcon;          /* Rx connection handle */
2327     struct AFSFid *DirFid;               /* Parent dir's fid */
2328     char *Name;                          /* File name to create */
2329     char *LinkContents;                  /* Contents of the new created file */
2330     struct AFSStoreStatus *InStatus;     /* Input status for the new symbolic link */
2331     struct AFSFid *OutFid;               /* Fid for newly created symbolic link */
2332     struct AFSFetchStatus *OutFidStatus; /* Output status for new symbolic link */
2333     struct AFSFetchStatus *OutDirStatus; /* Output status for parent dir */
2334     struct AFSVolSync *Sync;             /* volume synchronization information */
2335
2336 {
2337     Vnode * parentptr = 0;              /* vnode of input Directory */
2338     Vnode * targetptr = 0;              /* vnode of the new link */
2339     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
2340     int     errorCode = 0;              /* error code */
2341     int code = 0;
2342     DirHandle dir;                      /* Handle for dir package I/O */
2343     Volume * volptr = 0;                /* pointer to the volume header */
2344     struct client * client;             /* pointer to client structure */
2345     afs_int32 rights, anyrights, fd;    /* rights for this and any user */
2346     struct client *t_client;            /* tmp ptr to client data */
2347     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
2348     FdHandle_t *fdP;
2349
2350     /* Get ptr to client data for user Id for logging */
2351     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
2352     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
2353     ViceLog(1, ("SAFS_Symlink %s to %s,  Did = %u.%d.%d, Host %s, Id %d\n", Name,
2354             LinkContents, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
2355             inet_ntoa(logHostAddr), t_client->ViceId));
2356     FS_LOCK
2357     AFSCallStats.Symlink++, AFSCallStats.TotalCalls++;
2358     FS_UNLOCK
2359     if (!FileNameOK(Name)) {
2360         errorCode = EINVAL;
2361         goto Bad_SymLink;
2362     }
2363
2364     /*
2365      * Get the vnode and volume for the parent dir along with the caller's
2366      * rights to it
2367      */
2368     if (errorCode = GetVolumePackage(tcon, DirFid, &volptr, &parentptr,
2369                                      MustBeDIR, &parentwhentargetnotdir,
2370                                      &client, WRITE_LOCK, &rights, &anyrights)) {
2371         goto Bad_SymLink;
2372     }
2373
2374     /* set volume synchronization information */
2375     SetVolumeSync(Sync, volptr);
2376
2377     /* Does the caller has insert (and write) access to the parent directory? */
2378     if (errorCode = CheckWriteMode(parentptr, rights, PRSFS_INSERT)) {
2379         goto Bad_SymLink;
2380     }
2381
2382     /*
2383      * If we're creating a mount point (owner mode bits sans x bit), we must
2384      * have administer access to the directory, too.  Always allow sysadmins
2385      * to do this.
2386      */
2387     if ((InStatus->Mask & AFS_SETMODE) && !(InStatus->UnixModeBits & 0100)) {
2388         /*
2389          * We have a symlink, 'cause we're trying to set the Unix mode bits
2390          * to something without the owner x bits (default mode bits if
2391          * AFS_SETMODE is false is 0777)
2392          */
2393         if (VanillaUser(client) && !(rights & PRSFS_ADMINISTER)) {
2394             errorCode = EACCES;
2395             goto Bad_SymLink;
2396         }
2397     }
2398  
2399     /* get a new vnode for the symlink and set it up */
2400     if (errorCode = Alloc_NewVnode(parentptr, &dir, volptr, &targetptr,
2401                                    Name, OutFid, vSymlink,
2402                                    nBlocks(strlen((char *) LinkContents)))) {
2403         goto Bad_SymLink;
2404     }
2405
2406     /* update the status of the parent vnode */
2407 #if FS_STATS_DETAILED
2408     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
2409                              parentptr->disk.linkCount, client->InSameNetwork);
2410 #else
2411     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
2412                              parentptr->disk.linkCount);
2413 #endif /* FS_STATS_DETAILED */
2414
2415     /* update the status of the new symbolic link file vnode */
2416     Update_TargetVnodeStatus(targetptr, TVS_SLINK, client, InStatus, parentptr,
2417                              volptr, strlen((char *)LinkContents));
2418
2419     /* Write the contents of the symbolic link name into the target inode */
2420     fdP = IH_OPEN(targetptr->handle);
2421     assert(fdP != NULL);
2422     assert(FDH_WRITE(fdP, (char *) LinkContents, strlen((char *) LinkContents)) == strlen((char *) LinkContents));
2423     FDH_CLOSE(fdP);
2424     /*
2425      * Set up and return modified status for the parent dir and new symlink
2426      * to caller.
2427      */
2428     GetStatus(targetptr, OutFidStatus, rights, anyrights, parentptr);
2429     GetStatus(parentptr, OutDirStatus, rights, anyrights, (struct vnode *)0);
2430
2431     /* convert the write lock to a read lock before breaking callbacks */
2432     VVnodeWriteToRead(&errorCode, parentptr);
2433     assert(!errorCode || errorCode == VSALVAGE);
2434
2435     /* break call back on the parent dir */
2436     BreakCallBack(client->host, DirFid, 0);
2437
2438 Bad_SymLink: 
2439     /* Write the all modified vnodes (parent, new files) and volume back */
2440     PutVolumePackage(parentwhentargetnotdir, targetptr, parentptr, volptr);
2441     ViceLog(2, ("SAFS_Symlink returns %d\n", errorCode));
2442     return errorCode;
2443
2444 } /*SAFSS_Symlink*/
2445
2446
2447 SRXAFS_Symlink (tcon, DirFid, Name, LinkContents, InStatus, OutFid, OutFidStatus, OutDirStatus, Sync)
2448     struct AFSVolSync *Sync;
2449     struct rx_connection *tcon;          /* Rx connection handle */
2450     struct AFSFid *DirFid;               /* Parent dir's fid */
2451     char *Name;                          /* File name to create */
2452     char *LinkContents;                  /* Contents of the new created file */
2453     struct AFSStoreStatus *InStatus;     /* Input status for the new symbolic link */
2454     struct AFSFid *OutFid;               /* Fid for newly created symbolic link */
2455     struct AFSFetchStatus *OutFidStatus; /* Output status for new symbolic link */
2456     struct AFSFetchStatus *OutDirStatus; /* Output status for parent dir */
2457
2458 {
2459     afs_int32 code;
2460     struct rx_call *tcall = (struct rx_call *) tcon; 
2461 #if FS_STATS_DETAILED
2462     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
2463     struct timeval opStartTime,
2464                    opStopTime;              /* Start/stop times for RPC op*/
2465     struct timeval elapsedTime;             /* Transfer time */
2466
2467     /*
2468      * Set our stats pointer, remember when the RPC operation started, and
2469      * tally the operation.
2470      */
2471     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_SYMLINK]);
2472     FS_LOCK
2473     (opP->numOps)++;
2474     FS_UNLOCK
2475     TM_GetTimeOfDay(&opStartTime, 0);
2476 #endif /* FS_STATS_DETAILED */
2477
2478     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
2479         goto Bad_Symlink;
2480
2481     code = SAFSS_Symlink (tcon, DirFid, Name, LinkContents, InStatus, OutFid,
2482                          OutFidStatus, OutDirStatus, Sync);
2483
2484 Bad_Symlink:    
2485     CallPostamble(tcon);
2486
2487 #if FS_STATS_DETAILED
2488     TM_GetTimeOfDay(&opStopTime, 0);
2489     if (code == 0) {
2490       FS_LOCK
2491       (opP->numSuccesses)++;
2492       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
2493       fs_stats_AddTo((opP->sumTime), elapsedTime);
2494       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
2495       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
2496         fs_stats_TimeAssign((opP->minTime), elapsedTime);
2497       }
2498       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
2499         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
2500       }
2501       FS_UNLOCK
2502     }
2503
2504 #endif /* FS_STATS_DETAILED */
2505
2506     osi_auditU (tcall, SymlinkEvent, code, AUD_FID, DirFid, AUD_STR, Name, AUD_END);
2507     return code;
2508
2509 } /*SRXAFS_Symlink*/
2510
2511
2512 /*
2513  * This routine is called exclusively by SRXAFS_Link(), and should be
2514  * merged into it when possible.
2515  */
2516 SAFSS_Link (tcon, DirFid, Name, ExistingFid, OutFidStatus, OutDirStatus, Sync)
2517     struct rx_connection *tcon;          /* Rx connection handle */
2518     struct AFSFid *DirFid;               /* Parent dir's fid */
2519     char *Name;                          /* File name to create */
2520     struct AFSFid *ExistingFid;          /* Fid of existing fid we'll make link to */
2521     struct AFSFetchStatus *OutFidStatus; /* Output status for newly created file */
2522     struct AFSFetchStatus *OutDirStatus; /* Outpout status for parent dir */
2523     struct AFSVolSync *Sync;
2524
2525 {
2526     Vnode * parentptr = 0;              /* vnode of input Directory */
2527     Vnode * targetptr = 0;              /* vnode of the new file */
2528     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
2529     Volume * volptr = 0;                /* pointer to the volume header */
2530     int     errorCode = 0;              /* error code */
2531     DirHandle dir;                      /* Handle for dir package I/O */
2532     struct client * client;             /* pointer to client structure */
2533     afs_int32 rights, anyrights;                /* rights for this and any user */
2534     struct client *t_client;            /* tmp ptr to client data */
2535     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
2536
2537     /* Get ptr to client data for user Id for logging */
2538     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
2539     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
2540     ViceLog(1, ("SAFS_Link %s,  Did = %u.%d.%d, Fid = %u.%d.%d, Host %s, Id %d\n",
2541             Name, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
2542             ExistingFid->Volume, ExistingFid->Vnode, ExistingFid->Unique,
2543             inet_ntoa(logHostAddr), t_client->ViceId));
2544     FS_LOCK
2545     AFSCallStats.Link++, AFSCallStats.TotalCalls++;
2546     FS_UNLOCK
2547     if (DirFid->Volume != ExistingFid->Volume) {
2548         errorCode = EXDEV;
2549         goto Bad_Link;
2550     }
2551     if (!FileNameOK(Name)) {
2552         errorCode = EINVAL;
2553         goto Bad_Link;
2554     }
2555
2556     /*
2557      * Get the vnode and volume for the parent dir along with the caller's
2558      * rights to it
2559      */
2560     if (errorCode = GetVolumePackage(tcon, DirFid, &volptr, &parentptr,
2561                                      MustBeDIR, &parentwhentargetnotdir,
2562                                      &client, WRITE_LOCK, &rights, &anyrights)) {
2563         goto Bad_Link;
2564     }
2565
2566     /* set volume synchronization information */
2567     SetVolumeSync(Sync, volptr);
2568
2569     /* Can the caller insert into the parent directory? */
2570     if (errorCode = CheckWriteMode(parentptr, rights, PRSFS_INSERT)) {
2571         goto Bad_Link;
2572     }
2573
2574     if (((DirFid->Vnode & 1) && (ExistingFid->Vnode & 1)) ||
2575         (DirFid->Vnode == ExistingFid->Vnode)) {  /* at present, */
2576       /* AFS fileservers always have directory vnodes that are odd.   */
2577       errorCode = EISDIR;
2578       goto Bad_Link;
2579     }
2580
2581     /* get the file vnode  */
2582     if (errorCode = CheckVnode(ExistingFid, &volptr, &targetptr, WRITE_LOCK)) {
2583         goto Bad_Link;
2584     }
2585     if (targetptr->disk.type != vFile) {
2586         errorCode = EISDIR;
2587         goto Bad_Link;
2588     }
2589     if (targetptr->disk.parent != DirFid->Vnode) {
2590         errorCode = EXDEV;
2591         goto Bad_Link;
2592     }
2593     if (parentptr->disk.cloned) 
2594     {
2595         ViceLog(25, ("Link : calling CopyOnWrite on  target dir\n"));
2596         if ( errorCode = CopyOnWrite(parentptr, volptr))
2597                 goto Bad_Link;          /* disk full error */
2598     }
2599
2600     /* add the name to the directory */
2601     SetDirHandle(&dir, parentptr);
2602     if (errorCode = Create(&dir, (char *)Name, ExistingFid))
2603         goto Bad_Link;
2604     DFlush();
2605
2606     /* update the status in the parent vnode */
2607     /**WARNING** --> disk.author SHOULDN'T be modified???? */
2608 #if FS_STATS_DETAILED
2609     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
2610                              parentptr->disk.linkCount, client->InSameNetwork);
2611 #else
2612     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
2613                              parentptr->disk.linkCount);
2614 #endif /* FS_STATS_DETAILED */
2615
2616     targetptr->disk.linkCount++;
2617     targetptr->disk.author = client->ViceId;
2618     targetptr->changed_newTime = 1; /* Status change of linked-to file */
2619
2620     /* set up return status */
2621     GetStatus(targetptr, OutFidStatus, rights, anyrights, parentptr);
2622     GetStatus(parentptr, OutDirStatus, rights, anyrights, (struct vnode *)0);
2623
2624     /* convert the write locks to read locks before breaking callbacks */
2625     VVnodeWriteToRead(&errorCode, targetptr);
2626     assert(!errorCode || errorCode == VSALVAGE);
2627     VVnodeWriteToRead(&errorCode, parentptr);
2628     assert(!errorCode || errorCode == VSALVAGE);
2629     
2630     /* break call back on DirFid */
2631     BreakCallBack(client->host, DirFid, 0);
2632     /*
2633      * We also need to break the callback for the file that is hard-linked since part 
2634      * of its status (like linkcount) is changed
2635      */
2636     BreakCallBack(client->host, ExistingFid, 0);
2637
2638 Bad_Link:
2639     /* Write the all modified vnodes (parent, new files) and volume back */
2640     PutVolumePackage(parentwhentargetnotdir, targetptr, parentptr, volptr);
2641     ViceLog(2, ("SAFS_Link returns %d\n", errorCode));
2642     return errorCode;
2643
2644 } /*SAFSS_Link*/
2645
2646
2647 SRXAFS_Link (tcon, DirFid, Name, ExistingFid, OutFidStatus, OutDirStatus, Sync)
2648     struct AFSVolSync *Sync;
2649     struct rx_connection *tcon;          /* Rx connection handle */
2650     struct AFSFid *DirFid;               /* Parent dir's fid */
2651     char *Name;                          /* File name to create */
2652     struct AFSFid *ExistingFid;          /* Fid of existing fid we'll make link to */
2653     struct AFSFetchStatus *OutFidStatus; /* Output status for newly created file */
2654     struct AFSFetchStatus *OutDirStatus; /* Outpout status for parent dir */
2655
2656 {
2657     afs_int32 code;
2658     struct rx_call *tcall = (struct rx_call *) tcon; 
2659 #if FS_STATS_DETAILED
2660     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
2661     struct timeval opStartTime,
2662                    opStopTime;              /* Start/stop times for RPC op*/
2663     struct timeval elapsedTime;             /* Transfer time */
2664
2665     /*
2666      * Set our stats pointer, remember when the RPC operation started, and
2667      * tally the operation.
2668      */
2669     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_LINK]);
2670     FS_LOCK
2671     (opP->numOps)++;
2672     FS_UNLOCK
2673     TM_GetTimeOfDay(&opStartTime, 0);
2674 #endif /* FS_STATS_DETAILED */
2675
2676     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
2677         goto Bad_Link;
2678
2679     code = SAFSS_Link (tcon, DirFid, Name, ExistingFid, OutFidStatus,
2680                       OutDirStatus, Sync);
2681     
2682 Bad_Link:
2683     CallPostamble(tcon);
2684
2685 #if FS_STATS_DETAILED
2686     TM_GetTimeOfDay(&opStopTime, 0);
2687     if (code == 0) {
2688       FS_LOCK
2689       (opP->numSuccesses)++;
2690       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
2691       fs_stats_AddTo((opP->sumTime), elapsedTime);
2692       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
2693       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
2694         fs_stats_TimeAssign((opP->minTime), elapsedTime);
2695       }
2696       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
2697         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
2698       }
2699       FS_UNLOCK
2700     }
2701
2702 #endif /* FS_STATS_DETAILED */
2703
2704     osi_auditU (tcall, LinkEvent, code, AUD_FID, DirFid, AUD_STR, Name, AUD_FID, ExistingFid, AUD_END);
2705     return code;
2706
2707 } /*SRXAFS_Link*/
2708
2709
2710 /*
2711  * This routine is called exclusively by SRXAFS_MakeDir(), and should be
2712  * merged into it when possible.
2713  */
2714 SAFSS_MakeDir (tcon, DirFid, Name, InStatus, OutFid, OutFidStatus,
2715               OutDirStatus, CallBack, Sync)
2716     struct rx_connection *tcon;          /* Rx connection handle */
2717     struct AFSFid *DirFid;               /* Parent dir's fid */
2718     char *Name;                          /* Name of dir to be created */
2719     struct AFSStoreStatus *InStatus;     /* Input status for new dir */
2720     struct AFSFid *OutFid;               /* Fid of new dir */
2721     struct AFSFetchStatus *OutFidStatus; /* Output status for new directory */
2722     struct AFSFetchStatus *OutDirStatus; /* Output status for parent dir */
2723     struct AFSCallBack *CallBack;        /* Returned callback promise for new dir */
2724     struct AFSVolSync *Sync;
2725
2726 {
2727     Vnode * parentptr = 0;              /* vnode of input Directory */
2728     Vnode * targetptr = 0;              /* vnode of the new file */
2729     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
2730     Volume * volptr = 0;                /* pointer to the volume header */
2731     int     errorCode = 0;              /* error code */
2732     struct acl_accessList * newACL;     /* Access list */
2733     int     newACLSize;                 /* Size of access list */
2734     DirHandle dir;                      /* Handle for dir package I/O */
2735     DirHandle parentdir;                /* Handle for dir package I/O */
2736     struct client * client;             /* pointer to client structure */
2737     afs_int32 rights, anyrights;                /* rights for this and any user */
2738     struct client *t_client;            /* tmp ptr to client data */
2739     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
2740
2741     /* Get ptr to client data for user Id for logging */
2742     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
2743     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
2744     ViceLog(1, ("SAFS_MakeDir %s,  Did = %u.%d.%d, Host %s, Id %d\n",
2745             Name, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
2746             inet_ntoa(logHostAddr), t_client->ViceId));
2747     FS_LOCK
2748     AFSCallStats.MakeDir++, AFSCallStats.TotalCalls++;    
2749     FS_UNLOCK
2750     if (!FileNameOK(Name)) {
2751         errorCode = EINVAL;
2752         goto Bad_MakeDir;
2753     }
2754
2755     /*
2756      * Get the vnode and volume for the parent dir along with the caller's
2757      * rights to it.
2758      */
2759     if (errorCode = GetVolumePackage(tcon, DirFid, &volptr, &parentptr,
2760                                      MustBeDIR, &parentwhentargetnotdir,
2761                                      &client, WRITE_LOCK, &rights, &anyrights)) {
2762         goto Bad_MakeDir;
2763     }
2764  
2765     /* set volume synchronization information */
2766     SetVolumeSync(Sync, volptr);
2767
2768     /* Write access to the parent directory? */
2769 #ifdef DIRCREATE_NEED_WRITE
2770     /*
2771      * requires w access for the user to create a directory. this
2772      * closes a loophole in the current security arrangement, since a
2773      * user with i access only can create a directory and get the
2774      * implcit a access that goes with dir ownership, and proceed to 
2775      * subvert quota in the volume.
2776      */
2777     if ((errorCode = CheckWriteMode(parentptr, rights, PRSFS_INSERT)) ||
2778         (errorCode = CheckWriteMode(parentptr, rights, PRSFS_WRITE))) {
2779 #else 
2780     if (errorCode = CheckWriteMode(parentptr, rights, PRSFS_INSERT)) {
2781 #endif /* DIRCREATE_NEED_WRITE */ 
2782         goto Bad_MakeDir;
2783     }
2784
2785 #define EMPTYDIRBLOCKS 2
2786     /* get a new vnode and set it up */
2787     if (errorCode = Alloc_NewVnode(parentptr, &parentdir, volptr, &targetptr,
2788                                    Name, OutFid, vDirectory, EMPTYDIRBLOCKS)) {
2789         goto Bad_MakeDir;
2790     }
2791
2792     /* Update the status for the parent dir */
2793 #if FS_STATS_DETAILED
2794     Update_ParentVnodeStatus(parentptr, volptr, &parentdir, client->ViceId,
2795                              parentptr->disk.linkCount+1, client->InSameNetwork);
2796 #else
2797     Update_ParentVnodeStatus(parentptr, volptr, &parentdir, client->ViceId,
2798                              parentptr->disk.linkCount+1);
2799 #endif /* FS_STATS_DETAILED */
2800
2801     /* Point to target's ACL buffer and copy the parent's ACL contents to it */
2802     assert((SetAccessList(&targetptr, &volptr, &newACL, &newACLSize,
2803                           &parentwhentargetnotdir, (AFSFid *)0, 0)) == 0);
2804     assert(parentwhentargetnotdir == 0);
2805     bcopy((char *)VVnodeACL(parentptr), (char *)newACL, VAclSize(parentptr));
2806
2807     /* update the status for the target vnode */
2808     Update_TargetVnodeStatus(targetptr, TVS_MKDIR, client, InStatus,
2809                              parentptr, volptr, 0);
2810
2811     /* Actually create the New directory in the directory package */
2812     SetDirHandle(&dir, targetptr);
2813     assert(!(MakeDir(&dir, OutFid, DirFid)));
2814     DFlush();
2815     targetptr->disk.length = Length(&dir);
2816
2817     /* set up return status */
2818     GetStatus(targetptr, OutFidStatus, rights, anyrights, parentptr);
2819     GetStatus(parentptr, OutDirStatus, rights, anyrights, (struct Vnode *)0);
2820
2821     /* convert the write lock to a read lock before breaking callbacks */
2822     VVnodeWriteToRead(&errorCode, parentptr);
2823     assert(!errorCode || errorCode == VSALVAGE);
2824
2825     /* break call back on DirFid */
2826     BreakCallBack(client->host, DirFid, 0);
2827
2828     /* Return a callback promise to caller */
2829     SetCallBackStruct(AddCallBack(client->host, OutFid), CallBack);
2830
2831 Bad_MakeDir: 
2832     /* Write the all modified vnodes (parent, new files) and volume back */
2833     PutVolumePackage(parentwhentargetnotdir, targetptr, parentptr, volptr);
2834     ViceLog(2, ("SAFS_MakeDir returns %d\n", errorCode)); 
2835     return errorCode;
2836
2837 } /*SAFSS_MakeDir*/
2838
2839
2840 SRXAFS_MakeDir (tcon, DirFid, Name, InStatus, OutFid, OutFidStatus, OutDirStatus, CallBack, Sync)
2841     struct AFSVolSync *Sync;
2842     struct rx_connection *tcon;          /* Rx connection handle */
2843     struct AFSFid *DirFid;               /* Parent dir's fid */
2844     char *Name;                          /* Name of dir to be created */
2845     struct AFSStoreStatus *InStatus;     /* Input status for new dir */
2846     struct AFSFid *OutFid;               /* Fid of new dir */
2847     struct AFSFetchStatus *OutFidStatus; /* Output status for new directory */
2848     struct AFSFetchStatus *OutDirStatus; /* Output status for parent dir */
2849     struct AFSCallBack *CallBack;        /* Returned callback promise for new dir */
2850
2851 {
2852     afs_int32 code;
2853     struct rx_call *tcall = (struct rx_call *) tcon; 
2854 #if FS_STATS_DETAILED
2855     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
2856     struct timeval opStartTime,
2857                    opStopTime;              /* Start/stop times for RPC op*/
2858     struct timeval elapsedTime;             /* Transfer time */
2859
2860     /*
2861      * Set our stats pointer, remember when the RPC operation started, and
2862      * tally the operation.
2863      */
2864     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_MAKEDIR]);
2865     FS_LOCK
2866     (opP->numOps)++;
2867     FS_UNLOCK
2868     TM_GetTimeOfDay(&opStartTime, 0);
2869 #endif /* FS_STATS_DETAILED */
2870     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
2871         goto Bad_MakeDir;
2872
2873     code = SAFSS_MakeDir (tcon, DirFid, Name, InStatus, OutFid,
2874                          OutFidStatus, OutDirStatus, CallBack, Sync);
2875     
2876 Bad_MakeDir:
2877     CallPostamble(tcon);
2878
2879 #if FS_STATS_DETAILED
2880     TM_GetTimeOfDay(&opStopTime, 0);
2881     if (code == 0) {
2882       FS_LOCK
2883       (opP->numSuccesses)++;
2884       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
2885       fs_stats_AddTo((opP->sumTime), elapsedTime);
2886       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
2887       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
2888         fs_stats_TimeAssign((opP->minTime), elapsedTime);
2889       }
2890       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
2891         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
2892       }
2893       FS_UNLOCK
2894     }
2895
2896 #endif /* FS_STATS_DETAILED */
2897
2898     osi_auditU (tcall, MakeDirEvent, code, AUD_FID, DirFid, AUD_STR, Name, AUD_END);
2899     return code;
2900
2901 } /*SRXAFS_MakeDir*/
2902
2903
2904 /*
2905  * This routine is called exclusively by SRXAFS_RemoveDir(), and should be
2906  * merged into it when possible.
2907  */
2908 SAFSS_RemoveDir (tcon, DirFid, Name, OutDirStatus, Sync)
2909     struct rx_connection *tcon;          /* Rx connection handle */
2910     struct AFSFid *DirFid;               /* Parent dir's fid */
2911     char *Name;                          /* (Empty) dir's name to be removed */
2912     struct AFSFetchStatus *OutDirStatus; /* Output status for the parent dir */
2913     struct AFSVolSync *Sync;
2914
2915 {
2916     Vnode * parentptr = 0;              /* vnode of input Directory */
2917     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
2918     Vnode * targetptr = 0;              /* file to be deleted */
2919     AFSFid fileFid;                     /* area for Fid from the directory */
2920     int     errorCode = 0;              /* error code */
2921     DirHandle dir;                      /* Handle for dir package I/O */
2922     Volume * volptr = 0;                /* pointer to the volume header */
2923     struct client * client;             /* pointer to client structure */
2924     afs_int32 rights, anyrights;                /* rights for this and any user */
2925     Vnode debugvnode1, debugvnode2;
2926     struct client *t_client;            /* tmp ptr to client data */
2927     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
2928
2929     /* Get ptr to client data for user Id for logging */
2930     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
2931     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
2932     ViceLog(1, ("SAFS_RemoveDir %s,  Did = %u.%d.%d, Host %s, Id %d\n",
2933             Name, DirFid->Volume, DirFid->Vnode, DirFid->Unique,
2934             inet_ntoa(logHostAddr), t_client->ViceId));
2935     FS_LOCK
2936     AFSCallStats.RemoveDir++, AFSCallStats.TotalCalls++;
2937     FS_UNLOCK
2938     /*
2939      * Get the vnode and volume for the parent dir along with the caller's
2940      * rights to it
2941      */
2942     if (errorCode = GetVolumePackage(tcon, DirFid, &volptr, &parentptr,
2943                                      MustBeDIR, &parentwhentargetnotdir,
2944                                      &client, WRITE_LOCK, &rights, &anyrights)) {
2945         goto Bad_RemoveDir;
2946     }
2947     debugvnode1 = *parentptr;
2948
2949     /* set volume synchronization information */
2950     SetVolumeSync(Sync, volptr);
2951
2952     /* Does the caller has delete (&write) access to the parent dir? */
2953     if (errorCode = CheckWriteMode(parentptr, rights, PRSFS_DELETE)) {
2954         goto Bad_RemoveDir;
2955     }
2956
2957     debugvnode2 = *parentptr;
2958     /* Do the actual delete of the desired (empty) directory, Name */
2959     if (errorCode = DeleteTarget(parentptr, volptr, &targetptr, &dir, &fileFid,
2960                                  Name, MustBeDIR)) {
2961         goto Bad_RemoveDir;
2962     }
2963
2964     /* Update the status for the parent dir; link count is also adjusted */
2965 #if FS_STATS_DETAILED
2966     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
2967                              parentptr->disk.linkCount-1, client->InSameNetwork);
2968 #else
2969     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
2970                              parentptr->disk.linkCount-1);
2971 #endif /* FS_STATS_DETAILED */
2972
2973     /* Return to the caller the updated parent dir status */
2974     GetStatus(parentptr, OutDirStatus, rights, anyrights, (struct Vnode *)0);
2975
2976     /*
2977      * Note: it is not necessary to break the callback on fileFid, since
2978      * refcount is now 0, so no one should be able to refer to the dir
2979      * any longer
2980      */
2981     DeleteFileCallBacks(&fileFid);
2982
2983     /* convert the write lock to a read lock before breaking callbacks */
2984     VVnodeWriteToRead(&errorCode, parentptr);
2985     assert(!errorCode || errorCode == VSALVAGE);
2986
2987     /* break call back on DirFid and fileFid */
2988     BreakCallBack(client->host, DirFid, 0);
2989
2990 Bad_RemoveDir: 
2991     /* Write the all modified vnodes (parent, new files) and volume back */
2992     PutVolumePackage(parentwhentargetnotdir, targetptr, parentptr, volptr);
2993     ViceLog(2, ("SAFS_RemoveDir returns %d\n", errorCode));
2994     return errorCode;
2995
2996 } /*SAFSS_RemoveDir*/
2997
2998
2999 SRXAFS_RemoveDir (tcon, DirFid, Name, OutDirStatus, Sync)
3000     struct AFSVolSync *Sync;
3001     struct rx_connection *tcon;          /* Rx connection handle */
3002     struct AFSFid *DirFid;               /* Parent dir's fid */
3003     char *Name;                          /* (Empty) dir's name to be removed */
3004     struct AFSFetchStatus *OutDirStatus; /* Output status for the parent dir */
3005
3006 {
3007     afs_int32 code;
3008     struct rx_call *tcall = (struct rx_call *) tcon; 
3009 #if FS_STATS_DETAILED
3010     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
3011     struct timeval opStartTime,
3012                    opStopTime;              /* Start/stop times for RPC op*/
3013     struct timeval elapsedTime;             /* Transfer time */
3014
3015     /*
3016      * Set our stats pointer, remember when the RPC operation started, and
3017      * tally the operation.
3018      */
3019     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_REMOVEDIR]);
3020     FS_LOCK
3021     (opP->numOps)++;
3022     FS_UNLOCK
3023     TM_GetTimeOfDay(&opStartTime, 0);
3024 #endif /* FS_STATS_DETAILED */
3025
3026     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
3027         goto Bad_RemoveDir;
3028
3029     code = SAFSS_RemoveDir (tcon, DirFid, Name, OutDirStatus, Sync);
3030     
3031 Bad_RemoveDir:
3032     CallPostamble(tcon);
3033
3034 #if FS_STATS_DETAILED
3035     TM_GetTimeOfDay(&opStopTime, 0);
3036     if (code == 0) {
3037       FS_LOCK
3038       (opP->numSuccesses)++;
3039       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
3040       fs_stats_AddTo((opP->sumTime), elapsedTime);
3041       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
3042       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
3043         fs_stats_TimeAssign((opP->minTime), elapsedTime);
3044       }
3045       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
3046         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
3047       }
3048       FS_UNLOCK
3049     }
3050
3051 #endif /* FS_STATS_DETAILED */
3052
3053     osi_auditU (tcall, RemoveDirEvent, code, AUD_FID, DirFid, AUD_STR, Name, AUD_END);
3054     return code;
3055
3056 } /*SRXAFS_RemoveDir*/
3057
3058
3059 /*
3060  * This routine is called exclusively by SRXAFS_SetLock(), and should be
3061  * merged into it when possible.
3062  */
3063 SAFSS_SetLock (tcon, Fid, type, Sync)
3064     struct rx_connection *tcon; /* Rx connection handle */
3065     struct AFSFid *Fid;         /* Fid of file to lock */
3066     ViceLockType type;          /* Type of lock (Read or write) */
3067     struct AFSVolSync *Sync;
3068
3069 {
3070     Vnode * targetptr = 0;              /* vnode of input file */
3071     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
3072     int     errorCode = 0;              /* error code */
3073     Volume * volptr = 0;                /* pointer to the volume header */
3074     struct client * client;             /* pointer to client structure */
3075     afs_int32 rights, anyrights;                /* rights for this and any user */
3076     struct client *t_client;            /* tmp ptr to client data */
3077     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
3078     static char * locktype[2] = {"LockRead","LockWrite"};
3079
3080     if (type != LockRead && type != LockWrite) {
3081         errorCode = EINVAL;
3082         goto Bad_SetLock;
3083     }
3084     /* Get ptr to client data for user Id for logging */
3085     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
3086     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
3087     ViceLog(1,("SAFS_SetLock type = %s Fid = %u.%d.%d, Host %s, Id %d\n",
3088             locktype[(int)type], Fid->Volume, Fid->Vnode, Fid->Unique,
3089             inet_ntoa(logHostAddr), t_client->ViceId));
3090     FS_LOCK
3091     AFSCallStats.SetLock++, AFSCallStats.TotalCalls++;
3092     FS_UNLOCK
3093
3094     /*
3095      * Get the vnode and volume for the desired file along with the caller's
3096      * rights to it
3097      */
3098     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
3099                                      DONTCHECK, &parentwhentargetnotdir,
3100                                      &client, WRITE_LOCK, &rights, &anyrights)) {
3101         goto Bad_SetLock;
3102     }
3103
3104     /* set volume synchronization information */
3105     SetVolumeSync(Sync, volptr);
3106
3107     /* Handle the particular type of set locking, type */
3108     errorCode = HandleLocking(targetptr, rights, type);
3109
3110 Bad_SetLock: 
3111     /* Write the all modified vnodes (parent, new files) and volume back */
3112     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
3113
3114     if ((errorCode == VREADONLY) && (type == LockRead))
3115        errorCode = 0;  /* allow read locks on RO volumes without saving state */
3116
3117     ViceLog(2,("SAFS_SetLock returns %d\n", errorCode));
3118     return(errorCode);
3119
3120 }  /*SAFSS_SetLock*/
3121
3122
3123 SRXAFS_OldSetLock(tcon, Fid, type, Sync)
3124     struct AFSVolSync *Sync;
3125     struct rx_connection *tcon; /* Rx connection handle */
3126     struct AFSFid *Fid;         /* Fid of file to lock */
3127     ViceLockType type;          /* Type of lock (Read or write) */
3128
3129 {
3130     return SRXAFS_SetLock(tcon, Fid, type, Sync);
3131
3132 } /*SRXAFS_OldSetLock*/
3133
3134
3135 SRXAFS_SetLock (tcon, Fid, type, Sync)
3136     struct AFSVolSync *Sync;
3137     struct rx_connection *tcon; /* Rx connection handle */
3138     struct AFSFid *Fid;         /* Fid of file to lock */
3139     ViceLockType type;          /* Type of lock (Read or write) */
3140
3141 {
3142     afs_int32 code;
3143     struct rx_call *tcall = (struct rx_call *) tcon; 
3144 #if FS_STATS_DETAILED
3145     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
3146     struct timeval opStartTime,
3147                    opStopTime;              /* Start/stop times for RPC op*/
3148     struct timeval elapsedTime;             /* Transfer time */
3149
3150     /*
3151      * Set our stats pointer, remember when the RPC operation started, and
3152      * tally the operation.
3153      */
3154     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_SETLOCK]);
3155     FS_LOCK
3156     (opP->numOps)++;
3157     FS_UNLOCK
3158     TM_GetTimeOfDay(&opStartTime, 0);
3159 #endif /* FS_STATS_DETAILED */
3160
3161     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
3162         goto Bad_SetLock;
3163
3164     code = SAFSS_SetLock (tcon, Fid, type, Sync);
3165     
3166 Bad_SetLock:
3167     CallPostamble(tcon);
3168
3169 #if FS_STATS_DETAILED
3170     TM_GetTimeOfDay(&opStopTime, 0); 
3171     if (code == 0) {
3172       FS_LOCK
3173       (opP->numSuccesses)++;
3174       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
3175       fs_stats_AddTo((opP->sumTime), elapsedTime);
3176       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
3177       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
3178         fs_stats_TimeAssign((opP->minTime), elapsedTime);
3179       }
3180       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
3181         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
3182       }
3183       FS_UNLOCK
3184     }
3185 #endif /* FS_STATS_DETAILED */
3186
3187     osi_auditU (tcall, SetLockEvent, code, AUD_FID, Fid, AUD_LONG, type, AUD_END);
3188     return code;
3189
3190 } /*SRXAFS_SetLock*/
3191
3192
3193 /*
3194  * This routine is called exclusively by SRXAFS_ExtendLock(), and should be
3195  * merged into it when possible.
3196  */
3197 SAFSS_ExtendLock (tcon, Fid, Sync)
3198     struct rx_connection *tcon; /* Rx connection handle */
3199     struct AFSFid *Fid;         /* Fid of file whose lock we extend */
3200     struct AFSVolSync *Sync;
3201
3202 {
3203     Vnode * targetptr = 0;              /* vnode of input file */
3204     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
3205     int     errorCode = 0;              /* error code */
3206     Volume * volptr = 0;                /* pointer to the volume header */
3207     struct client * client;             /* pointer to client structure */
3208     afs_int32 rights, anyrights;                /* rights for this and any user */
3209     struct client *t_client;            /* tmp ptr to client data */
3210     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
3211
3212     /* Get ptr to client data for user Id for logging */
3213     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
3214     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
3215     ViceLog(1,("SAFS_ExtendLock Fid = %u.%d.%d, Host %s, Id %d\n", 
3216                Fid->Volume, Fid->Vnode, Fid->Unique, 
3217                inet_ntoa(logHostAddr), t_client->ViceId));
3218     FS_LOCK
3219     AFSCallStats.ExtendLock++, AFSCallStats.TotalCalls++;    
3220     FS_UNLOCK
3221     /*
3222      * Get the vnode and volume for the desired file along with the caller's
3223      * rights to it
3224      */
3225     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
3226                                      DONTCHECK, &parentwhentargetnotdir,
3227                                      &client, WRITE_LOCK, &rights, &anyrights)) {
3228         goto Bad_ExtendLock;
3229     }
3230
3231     /* set volume synchronization information */
3232     SetVolumeSync(Sync, volptr);
3233
3234     /* Handle the actual lock extension */
3235     errorCode = HandleLocking(targetptr, rights, LockExtend);
3236
3237 Bad_ExtendLock: 
3238     /* Put back file's vnode and volume */
3239     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
3240
3241     if ((errorCode == VREADONLY))  /* presumably, we already granted this lock */
3242        errorCode = 0;              /* under our generous policy re RO vols */
3243
3244     ViceLog(2,("SAFS_ExtendLock returns %d\n", errorCode));
3245     return(errorCode);
3246
3247 } /*SAFSS_ExtendLock*/
3248
3249
3250 SRXAFS_OldExtendLock (tcon, Fid, Sync)
3251     struct AFSVolSync *Sync;
3252     struct rx_connection *tcon; /* Rx connection handle */
3253     struct AFSFid *Fid;         /* Fid of file whose lock we extend */
3254
3255 {
3256     return SRXAFS_ExtendLock(tcon, Fid, Sync);
3257
3258 } /*SRXAFS_OldExtendLock*/
3259
3260
3261 SRXAFS_ExtendLock (tcon, Fid, Sync)
3262     struct AFSVolSync *Sync;
3263     struct rx_connection *tcon; /* Rx connection handle */
3264     struct AFSFid *Fid;         /* Fid of file whose lock we extend */
3265
3266 {
3267     afs_int32 code;
3268     struct rx_call *tcall = (struct rx_call *) tcon; 
3269 #if FS_STATS_DETAILED
3270     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
3271     struct timeval opStartTime,
3272                    opStopTime;              /* Start/stop times for RPC op*/
3273     struct timeval elapsedTime;             /* Transfer time */
3274
3275     /*
3276      * Set our stats pointer, remember when the RPC operation started, and
3277      * tally the operation.
3278      */
3279     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_EXTENDLOCK]);
3280     FS_LOCK
3281     (opP->numOps)++;
3282     FS_UNLOCK
3283     TM_GetTimeOfDay(&opStartTime, 0);
3284 #endif /* FS_STATS_DETAILED */
3285
3286     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
3287         goto Bad_ExtendLock;
3288
3289     code = SAFSS_ExtendLock (tcon, Fid, Sync);
3290
3291 Bad_ExtendLock:
3292     CallPostamble(tcon);
3293
3294 #if FS_STATS_DETAILED
3295     TM_GetTimeOfDay(&opStopTime, 0);
3296     if (code == 0) {
3297       FS_LOCK
3298       (opP->numSuccesses)++;
3299       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
3300       fs_stats_AddTo((opP->sumTime), elapsedTime);
3301       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
3302       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
3303         fs_stats_TimeAssign((opP->minTime), elapsedTime);
3304       }
3305       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
3306         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
3307       }
3308       FS_UNLOCK
3309     }
3310
3311 #endif /* FS_STATS_DETAILED */
3312
3313     osi_auditU (tcall, ExtendLockEvent, code, AUD_FID, Fid , AUD_END);
3314     return code;
3315
3316 } /*SRXAFS_ExtendLock*/
3317
3318
3319 /*
3320  * This routine is called exclusively by SRXAFS_ReleaseLock(), and should be
3321  * merged into it when possible.
3322  */
3323 SAFSS_ReleaseLock (tcon, Fid, Sync)
3324     struct rx_connection *tcon; /* Rx connection handle */
3325     struct AFSFid *Fid;         /* Fid of file to release lock */
3326     struct AFSVolSync *Sync;
3327
3328 {
3329     Vnode * targetptr = 0;              /* vnode of input file */
3330     Vnode * parentwhentargetnotdir = 0; /* parent for use in SetAccessList */
3331     int     errorCode = 0;              /* error code */
3332     Volume * volptr = 0;                /* pointer to the volume header */
3333     struct client * client;             /* pointer to client structure */
3334     afs_int32 rights, anyrights;                /* rights for this and any user */
3335     struct client *t_client;            /* tmp ptr to client data */
3336     struct in_addr logHostAddr;         /* host ip holder for inet_ntoa */
3337
3338     /* Get ptr to client data for user Id for logging */
3339     t_client = (struct client *) rx_GetSpecific(tcon, rxcon_client_key); 
3340     logHostAddr.s_addr =  rx_HostOf(rx_PeerOf(tcon));
3341     ViceLog(1,("SAFS_ReleaseLock Fid = %u.%d.%d, Host %s, Id %d\n",
3342             Fid->Volume, Fid->Vnode, Fid->Unique,
3343             inet_ntoa(logHostAddr), t_client->ViceId));
3344     FS_LOCK
3345     AFSCallStats.ReleaseLock++, AFSCallStats.TotalCalls++;
3346     FS_UNLOCK
3347     /*
3348      * Get the vnode and volume for the desired file along with the caller's
3349      * rights to it
3350      */
3351     if (errorCode = GetVolumePackage(tcon, Fid, &volptr, &targetptr,
3352                                      DONTCHECK, &parentwhentargetnotdir,
3353                                      &client, WRITE_LOCK, &rights, &anyrights)) {
3354         goto Bad_ReleaseLock;
3355     }
3356
3357     /* set volume synchronization information */
3358     SetVolumeSync(Sync, volptr);
3359
3360     /* Handle the actual lock release */
3361     if (errorCode = HandleLocking(targetptr, rights, LockRelease))
3362         goto Bad_ReleaseLock;
3363
3364     /* if no more locks left, a callback would be triggered here */
3365     if (targetptr->disk.lock.lockCount <= 0) {
3366         /* convert the write lock to a read lock before breaking callbacks */
3367         VVnodeWriteToRead(&errorCode, targetptr);
3368         assert(!errorCode || errorCode == VSALVAGE);
3369         BreakCallBack(client->host, Fid, 0);
3370     }
3371
3372 Bad_ReleaseLock: 
3373     /* Put back file's vnode and volume */
3374     PutVolumePackage(parentwhentargetnotdir, targetptr, (Vnode *)0, volptr);
3375
3376     if ((errorCode == VREADONLY))  /* presumably, we already granted this lock */
3377        errorCode = 0;              /* under our generous policy re RO vols */
3378
3379     ViceLog(2,("SAFS_ReleaseLock returns %d\n", errorCode));
3380     return(errorCode);
3381
3382 } /*SAFSS_ReleaseLock*/
3383
3384
3385 SRXAFS_OldReleaseLock (tcon, Fid, Sync)
3386     struct AFSVolSync *Sync;
3387     struct rx_connection *tcon; /* Rx connection handle */
3388     struct AFSFid *Fid;         /* Fid of file to release lock */
3389
3390 {
3391     return SRXAFS_ReleaseLock(tcon, Fid, Sync);
3392
3393 } /*SRXAFS_OldReleaseLock*/
3394
3395
3396 SRXAFS_ReleaseLock (tcon, Fid, Sync)
3397     struct AFSVolSync *Sync;
3398     struct rx_connection *tcon; /* Rx connection handle */
3399     struct AFSFid *Fid;         /* Fid of file to release lock */
3400
3401 {
3402     afs_int32 code;
3403     struct rx_call *tcall = (struct rx_call *) tcon; 
3404 #if FS_STATS_DETAILED
3405     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
3406     struct timeval opStartTime,
3407                    opStopTime;              /* Start/stop times for RPC op*/
3408     struct timeval elapsedTime;             /* Transfer time */
3409
3410     /*
3411      * Set our stats pointer, remember when the RPC operation started, and
3412      * tally the operation.
3413      */
3414     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_RELEASELOCK]);
3415     FS_LOCK
3416     (opP->numOps)++;
3417     FS_UNLOCK
3418     TM_GetTimeOfDay(&opStartTime, 0);
3419 #endif /* FS_STATS_DETAILED */
3420
3421     if (code = CallPreamble((struct rx_call **) &tcon, ACTIVECALL))
3422         goto Bad_ReleaseLock;
3423
3424     code = SAFSS_ReleaseLock (tcon, Fid, Sync);
3425     
3426 Bad_ReleaseLock:
3427     CallPostamble(tcon);
3428
3429 #if FS_STATS_DETAILED
3430     TM_GetTimeOfDay(&opStopTime, 0);
3431     if (code == 0) {
3432       FS_LOCK
3433       (opP->numSuccesses)++;
3434       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
3435       fs_stats_AddTo((opP->sumTime), elapsedTime);
3436       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
3437       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
3438         fs_stats_TimeAssign((opP->minTime), elapsedTime);
3439       }
3440       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
3441         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
3442       }
3443       FS_UNLOCK
3444     }
3445
3446 #endif /* FS_STATS_DETAILED */
3447
3448     osi_auditU (tcall, ReleaseLockEvent, code, AUD_FID, Fid , AUD_END);
3449     return code;
3450
3451 } /*SRXAFS_ReleaseLock*/
3452
3453
3454 /*
3455  * This routine is called exclusively by SRXAFS_GetStatistics(), and should be
3456  * merged into it when possible.
3457  */
3458 static GetStatistics (tcon, Statistics)
3459     struct rx_connection *tcon;       /* Rx connection handle */
3460     struct AFSStatistics *Statistics; /* Placeholder for returned AFS statistics */
3461 {
3462     ViceLog(1, ("SAFS_GetStatistics Received\n"));
3463     FS_LOCK
3464     AFSCallStats.GetStatistics++, AFSCallStats.TotalCalls++;
3465     FS_UNLOCK
3466     bzero(Statistics, sizeof(*Statistics));
3467     SetAFSStats(Statistics);
3468     SetVolumeStats(Statistics);
3469     SetSystemStats(Statistics);
3470
3471     return(0);
3472
3473 } /*GetStatistics*/
3474
3475
3476 SRXAFS_GetStatistics (tcon, Statistics)
3477     struct rx_connection *tcon;       /* Rx connection handle */
3478     struct AFSStatistics *Statistics; /* Placeholder for returned AFS statistics */
3479
3480 {
3481     afs_int32 code;
3482 #if FS_STATS_DETAILED
3483     struct fs_stats_opTimingData *opP;      /* Ptr to this op's timing struct */
3484     struct timeval opStartTime,
3485                    opStopTime;              /* Start/stop times for RPC op*/
3486     struct timeval elapsedTime;             /* Transfer time */
3487
3488     /*
3489      * Set our stats pointer, remember when the RPC operation started, and
3490      * tally the operation.
3491      */
3492     opP = &(afs_FullPerfStats.det.rpcOpTimes[FS_STATS_RPCIDX_GETSTATISTICS]);
3493     FS_LOCK
3494     (opP->numOps)++;
3495     FS_UNLOCK
3496     TM_GetTimeOfDay(&opStartTime, 0);
3497 #endif /* FS_STATS_DETAILED */
3498
3499     if (code = CallPreamble((struct rx_call **) &tcon, NOTACTIVECALL))
3500         goto Bad_GetStatistics;
3501
3502     code = GetStatistics (tcon, Statistics);
3503     
3504 Bad_GetStatistics:
3505     CallPostamble(tcon);
3506
3507 #if FS_STATS_DETAILED
3508     TM_GetTimeOfDay(&opStopTime, 0);
3509     if (code == 0) {
3510       FS_LOCK
3511       (opP->numSuccesses)++;
3512       fs_stats_GetDiff(elapsedTime, opStartTime, opStopTime);
3513       fs_stats_AddTo((opP->sumTime), elapsedTime);
3514       fs_stats_SquareAddTo((opP->sqrTime), elapsedTime);
3515       if (fs_stats_TimeLessThan(elapsedTime, (opP->minTime))) {
3516         fs_stats_TimeAssign((opP->minTime), elapsedTime);
3517       }
3518       if (fs_stats_TimeGreaterThan(elapsedTime, (opP->maxTime))) {
3519         fs_stats_TimeAssign((opP->maxTime), elapsedTime);
3520       }
3521       FS_UNLOCK
3522     }
3523 #endif /* FS_STATS_DETAILED */
3524
3525     return code;
3526
3527 } /*SRXAFS_GetStatistics*/