b6e8b3f741b3c7e515fae09cf42796bfa77dd9e9
[openafs.git] / src / afs / afs_fetchstore.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include "afs/param.h"
12
13 #include "afs/sysincludes.h"    /* Standard vendor system headers */
14 #ifndef AFS_LINUX22_ENV
15 #include "rpc/types.h"
16 #endif
17 #ifdef  AFS_ALPHA_ENV
18 #undef kmem_alloc
19 #undef kmem_free
20 #undef mem_alloc
21 #undef mem_free
22 #undef register
23 #endif /* AFS_ALPHA_ENV */
24 #include "afsincludes.h"        /* Afs-based standard headers */
25 #include "afs/afs_stats.h"      /* statistics */
26 #include "afs_prototypes.h"
27
28 extern int cacheDiskType;
29
30
31 #ifndef AFS_NOSTATS
32 void
33 FillStoreStats(int code, int idx, osi_timeval_t *xferStartTime,
34                   afs_size_t bytesToXfer, afs_size_t bytesXferred)
35 {
36     struct afs_stats_xferData *xferP;
37     osi_timeval_t xferStopTime;
38     XSTATS_DECLS;
39
40     xferP = &(afs_stats_cmfullperf.rpc.fsXferTimes[idx]);
41     osi_GetuTime(&xferStopTime);
42     (xferP->numXfers)++;
43     if (!code) {
44         (xferP->numSuccesses)++;
45         afs_stats_XferSumBytes[idx] += bytesXferred;
46         (xferP->sumBytes) += (afs_stats_XferSumBytes[idx] >> 10);
47         afs_stats_XferSumBytes[idx] &= 0x3FF;
48         if (bytesXferred < xferP->minBytes)
49             xferP->minBytes = bytesXferred;
50         if (bytesXferred > xferP->maxBytes)
51             xferP->maxBytes = bytesXferred;
52
53         /*
54          * Tally the size of the object.  Note: we tally the actual size,
55          * NOT the number of bytes that made it out over the wire.
56          */
57         if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET0) (xferP->count[0])++;
58         else if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET1) (xferP->count[1])++;
59         else if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET2) (xferP->count[2])++;
60         else if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET3) (xferP->count[3])++;
61         else if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET4) (xferP->count[4])++;
62         else if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET5) (xferP->count[5])++;
63         else if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET6) (xferP->count[6])++;
64         else if (bytesToXfer <= AFS_STATS_MAXBYTES_BUCKET7) (xferP->count[7])++;
65         else
66             (xferP->count[8])++;
67
68         afs_stats_GetDiff(elapsedTime, (*xferStartTime), xferStopTime);
69         afs_stats_AddTo((xferP->sumTime), elapsedTime);
70         afs_stats_SquareAddTo((xferP->sqrTime), elapsedTime);
71         if (afs_stats_TimeLessThan(elapsedTime, (xferP->minTime))) {
72             afs_stats_TimeAssign((xferP->minTime), elapsedTime);
73         }
74         if (afs_stats_TimeGreaterThan(elapsedTime, (xferP->maxTime))) {
75             afs_stats_TimeAssign((xferP->maxTime), elapsedTime);
76         }
77     }
78 }
79 #endif /* AFS_NOSTATS */
80
81 /* rock and operations for RX_FILESERVER */
82
83 struct rxfs_storeVariables {
84     struct rx_call *call;
85     char *tbuffer;
86     struct iovec *tiov;
87     afs_uint32 tnio;
88     afs_int32 hasNo64bit;
89     struct AFSStoreStatus InStatus;
90 };
91
92 afs_int32
93 rxfs_storeUfsPrepare(void *r, afs_uint32 size, afs_uint32 *tlen)
94 {
95     *tlen = (size > AFS_LRALLOCSIZ ?  AFS_LRALLOCSIZ : size);
96     return 0;
97 }
98
99 afs_int32
100 rxfs_storeMemPrepare(void *r, afs_uint32 size, afs_uint32 *tlen)
101 {
102     afs_int32 code;
103     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *) r;
104
105     *tlen = (size > AFS_LRALLOCSIZ ?  AFS_LRALLOCSIZ : size);
106     RX_AFS_GUNLOCK();
107     code = rx_WritevAlloc(v->call, v->tiov, &v->tnio, RX_MAXIOVECS, *tlen);
108     RX_AFS_GLOCK();
109     if (code <= 0) {
110         code = rx_Error(v->call);
111         if ( !code )
112             code = -33;
113     }
114     else {
115         *tlen = code;
116         code = 0;
117     }
118     return code;
119 }
120
121 afs_int32
122 rxfs_storeUfsRead(void *r, struct osi_file *tfile, afs_uint32 offset,
123                   afs_uint32 tlen, afs_uint32 *bytesread)
124 {
125     afs_int32 code;
126     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)r;
127
128     *bytesread = 0;
129     code = afs_osi_Read(tfile, -1, v->tbuffer, tlen);
130     if (code < 0)
131         return EIO;
132     *bytesread = code;
133     if (code == tlen)
134         return 0;
135 #if defined(KERNEL_HAVE_UERROR)
136     if (getuerror())
137         return EIO;
138 #endif
139     return 0;
140 }
141
142 afs_int32
143 rxfs_storeMemRead(void *r, struct osi_file *tfile, afs_uint32 offset,
144                   afs_uint32 tlen, afs_uint32 *bytesread)
145 {
146     afs_int32 code;
147     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)r;
148     struct memCacheEntry *mceP = (struct memCacheEntry *)tfile;
149
150     *bytesread = 0;
151     code = afs_MemReadvBlk(mceP, offset, v->tiov, v->tnio, tlen);
152     if (code != tlen)
153         return -33;
154     *bytesread = code;
155     return 0;
156 }
157
158 afs_int32
159 rxfs_storeMemWrite(void *r, afs_uint32 l, afs_uint32 *byteswritten)
160 {
161     afs_int32 code;
162     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)r;
163
164     RX_AFS_GUNLOCK();
165     code = rx_Writev(v->call, v->tiov, v->tnio, l);
166     RX_AFS_GLOCK();
167     if (code != l) {
168         code = rx_Error(v->call);
169         return (code ? code : -33);
170     }
171     *byteswritten = code;
172     return 0;
173 }
174
175 afs_int32
176 rxfs_storeUfsWrite(void *r, afs_uint32 l, afs_uint32 *byteswritten)
177 {
178     afs_int32 code;
179     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)r;
180
181     RX_AFS_GUNLOCK();
182     code = rx_Write(v->call, v->tbuffer, l);
183         /* writing 0 bytes will
184          * push a short packet.  Is that really what we want, just because the
185          * data didn't come back from the disk yet?  Let's try it and see. */
186     RX_AFS_GLOCK();
187     if (code != l) {
188         code = rx_Error(v->call);
189         return (code ? code : -33);
190     }
191     *byteswritten = code;
192     return 0;
193 }
194
195 afs_int32
196 rxfs_storePadd(void *rock, afs_uint32 size)
197 {
198     afs_int32 code = 0;
199     int bsent, tlen;
200     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)rock;
201
202     if ( !v->tbuffer )
203         v->tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
204     memset(v->tbuffer, 0, AFS_LRALLOCSIZ);
205
206     while (size > 0) {
207         tlen = (size > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : size);
208         RX_AFS_GUNLOCK();
209         code = rx_Write(v->call, v->tbuffer, tlen);
210         RX_AFS_GLOCK();
211
212         if (code != tlen)
213             return -33; /* XXX */
214         size -= tlen;
215     }
216     return code;
217 }
218
219 afs_int32
220 rxfs_storeStatus(void *rock)
221 {
222     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)rock;
223
224     if (rx_GetRemoteStatus(v->call) & 1)
225         return 0;
226     return 1;
227 }
228
229 afs_int32
230 rxfs_storeClose(void *r, struct AFSFetchStatus *OutStatus, int *doProcessFS)
231 {
232     afs_int32 code;
233     struct AFSVolSync tsync;
234     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)r;
235
236     RX_AFS_GUNLOCK();
237     code = EndRXAFS_StoreData(v->call, OutStatus, &tsync);
238     RX_AFS_GLOCK();
239     if (!code)
240         *doProcessFS = 1;       /* Flag to run afs_ProcessFS() later on */
241
242     return code;
243 }
244
245 afs_int32
246 rxfs_storeDestroy(void **r, afs_int32 error)
247 {
248     afs_int32 code = error;
249     struct rxfs_storeVariables *v = (struct rxfs_storeVariables *)*r;
250
251     *r = NULL;
252     if (v->call) {
253         afs_int32 code2;
254         RX_AFS_GUNLOCK();
255         code2 = rx_EndCall(v->call, code);
256         RX_AFS_GLOCK();
257         if (code2)
258             code = code2;
259     }
260     if (v->tbuffer)
261         osi_FreeLargeSpace(v->tbuffer);
262     if (v->tiov)
263         osi_FreeSmallSpace(v->tiov);
264     osi_FreeSmallSpace(v);
265     return code;
266 }
267
268 static
269 struct storeOps rxfs_storeUfsOps = {
270     rxfs_storeUfsPrepare,
271     rxfs_storeUfsRead,
272     rxfs_storeUfsWrite,
273     rxfs_storeStatus,
274     rxfs_storePadd,
275     rxfs_storeClose,
276     rxfs_storeDestroy
277 };
278
279 static
280 struct storeOps rxfs_storeMemOps = {
281     rxfs_storeMemPrepare,
282     rxfs_storeMemRead,
283     rxfs_storeMemWrite,
284     rxfs_storeStatus,
285     rxfs_storePadd,
286     rxfs_storeClose,
287     rxfs_storeDestroy
288 };
289
290 afs_int32
291 rxfs_storeInit(struct vcache *avc, struct afs_conn *tc, afs_size_t tlen,
292                 afs_size_t bytes, afs_size_t base,
293                 int sync, struct storeOps **ops, void **rock)
294 {
295     afs_int32 code;
296     struct rxfs_storeVariables *v;
297
298     if ( !tc )
299         return -1;
300
301     v = (struct rxfs_storeVariables *) osi_AllocSmallSpace(sizeof(struct rxfs_storeVariables));
302     if (!v)
303         osi_Panic("rxfs_storeInit: osi_AllocSmallSpace returned NULL\n");
304     memset(v, 0, sizeof(struct rxfs_storeVariables));
305
306     v->InStatus.ClientModTime = avc->f.m.Date;
307     v->InStatus.Mask = AFS_SETMODTIME;
308     if (sync & AFS_SYNC)
309         v->InStatus.Mask |= AFS_FSYNC;
310     RX_AFS_GUNLOCK();
311     v->call = rx_NewCall(tc->id);
312     if (v->call) {
313 #ifdef AFS_64BIT_CLIENT
314         if (!afs_serverHasNo64Bit(tc))
315             code = StartRXAFS_StoreData64(v->call,(struct AFSFid*)&avc->f.fid.Fid,
316                                        &v->InStatus, base, bytes, tlen);
317         else
318             if (tlen > 0xFFFFFFFF)
319                 code = EFBIG;
320             else {
321                 afs_int32 t1 = base, t2 = bytes, t3 = tlen;
322                 code = StartRXAFS_StoreData(v->call,
323                                         (struct AFSFid *) &avc->f.fid.Fid,
324                                          &v->InStatus, t1, t2, t3);
325             }
326 #else /* AFS_64BIT_CLIENT */
327         code = StartRXAFS_StoreData(v->call, (struct AFSFid *)&avc->f.fid.Fid,
328                                     &v->InStatus, base, bytes, tlen);
329 #endif /* AFS_64BIT_CLIENT */
330     } else
331         code = -1;
332     RX_AFS_GLOCK();
333     if (code) {
334         osi_FreeSmallSpace(v);
335         return code;
336     }
337     if (cacheDiskType == AFS_FCACHE_TYPE_UFS) {
338         v->tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
339         if (!v->tbuffer)
340             osi_Panic
341             ("rxfs_storeInit: osi_AllocLargeSpace for iovecs returned NULL\n");
342         *ops = (struct storeOps *) &rxfs_storeUfsOps;
343     } else {
344         v->tiov = osi_AllocSmallSpace(sizeof(struct iovec) * RX_MAXIOVECS);
345         if (!v->tiov)
346             osi_Panic
347             ("rxfs_storeInit: osi_AllocSmallSpace for iovecs returned NULL\n");
348         *ops = (struct storeOps *) &rxfs_storeMemOps;
349 #ifdef notdef
350         /* do this at a higher level now -- it's a parameter */
351         /* for now, only do 'continue from close' code if file fits in one
352          * chunk.  Could clearly do better: if only one modified chunk
353          * then can still do this.  can do this on *last* modified chunk */
354         tlen = avc->f.m.Length - 1;     /* byte position of last byte we'll store */
355         if (shouldWake) {
356             if (AFS_CHUNK(tlen) != 0)
357                 *shouldWake = 0;
358             else
359                 *shouldWake = 1;
360         }
361 #endif /* notdef */
362     }
363
364     *rock = (void *)v;
365     return 0;
366 }
367
368 unsigned int storeallmissing = 0;
369 /*!
370  *      Called for each chunk upon store.
371  *
372  * \param avc Ptr to the vcache entry of the file being stored.
373  * \param dclist pointer to the list of dcaches
374  * \param bytes total number of bytes for the current operation
375  * \param anewDV Ptr to the dataversion after store
376  * \param doProcessFS pointer to the "do process FetchStatus" flag
377  * \param OutStatus pointer to the FetchStatus as returned by the fileserver
378  * \param nchunks number of dcaches to consider
379  * \param nomore copy of the "no more data" flag
380  * \param ops pointer to the block of storeOps to be used for this operation
381  * \param rock pointer to the opaque protocol-specific data of this operation
382  */
383 afs_int32
384 afs_CacheStoreDCaches(struct vcache *avc, struct dcache **dclist,
385                         afs_size_t bytes,
386                         afs_hyper_t *anewDV,
387                         int *doProcessFS,
388                         struct AFSFetchStatus *OutStatus,
389                         afs_uint32 nchunks,
390                         int nomore,
391                         struct storeOps *ops, void *rock)
392 {
393     int *shouldwake = NULL;
394     unsigned int i;
395     afs_int32 code = 0;
396
397 #ifndef AFS_NOSTATS
398     osi_timeval_t xferStartTime;        /*FS xfer start time */
399     afs_size_t bytesToXfer = 10000;     /* # bytes to xfer */
400     afs_size_t bytesXferred = 10000;    /* # bytes actually xferred */
401 #endif /* AFS_NOSTATS */
402     XSTATS_DECLS;
403
404     for (i = 0; i < nchunks && !code; i++) {
405         int stored = 0;
406         struct osi_file *fP;
407         int offset = 0;
408         struct dcache *tdc = dclist[i];
409         afs_int32 alen = tdc->f.chunkBytes;
410         if (!tdc) {
411             afs_warn("afs: missing dcache!\n");
412             storeallmissing++;
413             continue;   /* panic? */
414         }
415         afs_Trace4(afs_iclSetp, CM_TRACE_STOREALL2, ICL_TYPE_POINTER, avc,
416                     ICL_TYPE_INT32, tdc->f.chunk, ICL_TYPE_INT32, tdc->index,
417                     ICL_TYPE_INT32, afs_inode2trace(&tdc->f.inode));
418         shouldwake = 0;
419         if (nomore) {
420             if (avc->asynchrony == -1) {
421                 if (afs_defaultAsynchrony > (bytes - stored))
422                     shouldwake = &nomore;
423             }
424             else if ((afs_uint32) avc->asynchrony >= (bytes - stored))
425                 shouldwake = &nomore;
426         }
427         fP = afs_CFileOpen(&tdc->f.inode);
428
429         afs_Trace4(afs_iclSetp, CM_TRACE_STOREPROC, ICL_TYPE_POINTER, avc,
430                     ICL_TYPE_FID, &(avc->f.fid), ICL_TYPE_OFFSET,
431                     ICL_HANDLE_OFFSET(avc->f.m.Length), ICL_TYPE_INT32, alen);
432
433         AFS_STATCNT(CacheStoreProc);
434
435         XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STOREDATA);
436         avc->f.truncPos = AFS_NOTRUNC;
437 #ifndef AFS_NOSTATS
438         /*
439          * In this case, alen is *always* the amount of data we'll be trying
440          * to ship here.
441          */
442         bytesToXfer = alen;
443         bytesXferred = 0;
444
445 #endif /* AFS_NOSTATS */
446
447         while ( alen > 0 ) {
448             afs_uint32 tlen;
449             afs_int32 bytesread, byteswritten;
450             code = (*ops->prepare)(rock, alen, &tlen);
451             if ( code )
452                 break;
453
454             code = (*ops->read)(rock, fP, offset, tlen, &bytesread);
455             if (code)
456                 break;
457
458             tlen = bytesread;
459             code = (*ops->write)(rock, tlen, &byteswritten);
460             if (code)
461                 break;
462 #ifndef AFS_NOSTATS
463             bytesXferred += byteswritten;
464 #endif /* AFS_NOSTATS */
465
466             offset += tlen;
467             alen -= tlen;
468             /*
469              * if file has been locked on server, can allow
470              * store to continue
471              */
472             if (shouldwake && *shouldwake && ((*ops->status)(rock) == 0)) {
473                 *shouldwake = 0;        /* only do this once */
474                 afs_wakeup(avc);
475             }
476         }
477         afs_Trace4(afs_iclSetp, CM_TRACE_STOREPROC, ICL_TYPE_POINTER, avc,
478                     ICL_TYPE_FID, &(avc->f.fid), ICL_TYPE_OFFSET,
479                     ICL_HANDLE_OFFSET(avc->f.m.Length), ICL_TYPE_INT32, alen);
480
481 #ifndef AFS_NOSTATS
482         FillStoreStats(code, AFS_STATS_FS_XFERIDX_STOREDATA,
483                     &xferStartTime, bytesToXfer, bytesXferred);
484 #endif /* AFS_NOSTATS */
485
486         afs_CFileClose(fP);
487         if ((tdc->f.chunkBytes < afs_OtherCSize)
488                 && (i < (nchunks - 1)) && code == 0) {
489             int bsent, tlen, sbytes = afs_OtherCSize - tdc->f.chunkBytes;
490             char *tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
491
492             while (sbytes > 0) {
493                 tlen = (sbytes > AFS_LRALLOCSIZ ? AFS_LRALLOCSIZ : sbytes);
494                 memset(tbuffer, 0, tlen);
495                 RX_AFS_GUNLOCK();
496                 bsent = rx_Write(
497                         ((struct rxfs_storeVariables*)rock)->call, tbuffer, tlen);
498                 RX_AFS_GLOCK();
499
500                 if (bsent != tlen) {
501                     code = -33; /* XXX */
502                     break;
503                 }
504                 sbytes -= tlen;
505             }
506             osi_FreeLargeSpace(tbuffer);
507         }
508         stored += tdc->f.chunkBytes;
509         /* ideally, I'd like to unlock the dcache and turn
510          * off the writing bit here, but that would
511          * require being able to retry StoreAllSegments in
512          * the event of a failure. It only really matters
513          * if user can't read from a 'locked' dcache or
514          * one which has the writing bit turned on. */
515     }
516
517     if (!code) {
518         code = (*ops->close)(rock, OutStatus, doProcessFS);
519         if (*doProcessFS) {
520             hadd32(*anewDV, 1);
521         }
522         XSTATS_END_TIME;
523     }
524     code = (*ops->destroy)(&rock, code);
525     return code;
526 }
527
528 #define lmin(a,b) (((a) < (b)) ? (a) : (b))
529 /*!
530  *      Called upon store.
531  *
532  * \param dclist pointer to the list of dcaches
533  * \param avc Ptr to the vcache entry.
534  * \param areq Ptr to the request structure
535  * \param sync sync flag
536  * \param minj the chunk offset for this call
537  * \param high index of last dcache to store
538  * \param moredata the moredata flag
539  * \param anewDV Ptr to the dataversion after store
540  * \param amaxStoredLength Ptr to the amount of that is actually stored
541  *
542  * \note Environment: Nothing interesting.
543  */
544 int
545 afs_CacheStoreVCache(struct dcache **dcList, struct vcache *avc,
546                         struct vrequest *areq, int sync,
547                         unsigned int minj, unsigned int high,
548                         unsigned int moredata,
549                         afs_hyper_t *anewDV, afs_size_t *amaxStoredLength)
550 {
551     afs_int32 code = 0;
552     struct storeOps *ops;
553     void * rock = NULL;
554     unsigned int i, j;
555
556     struct AFSStoreStatus InStatus;
557     struct AFSFetchStatus OutStatus;
558     int doProcessFS = 0;
559     afs_size_t base, bytes, length;
560     afs_uint32 nchunks;
561     int nomore;
562     unsigned int first = 0;
563     struct afs_conn *tc;
564
565     for (bytes = 0, j = 0; !code && j <= high; j++) {
566         if (dcList[j]) {
567             ObtainSharedLock(&(dcList[j]->lock), 629);
568             if (!bytes)
569                 first = j;
570             bytes += dcList[j]->f.chunkBytes;
571             if ((dcList[j]->f.chunkBytes < afs_OtherCSize)
572                         && (dcList[j]->f.chunk - minj < high)
573                         && dcList[j + 1]) {
574                 int sbytes = afs_OtherCSize - dcList[j]->f.chunkBytes;
575                 bytes += sbytes;
576             }
577         }
578         if (bytes && (j == high || !dcList[j + 1])) {
579             struct dcache **dclist = &dcList[first];
580             /* base = AFS_CHUNKTOBASE(dcList[first]->f.chunk); */
581             base = AFS_CHUNKTOBASE(first + minj);
582             /*
583              *
584              * take a list of dcache structs and send them all off to the server
585              * the list must be in order, and the chunks contiguous.
586              * Note - there is no locking done by this code currently.  For
587              * safety's sake, xdcache could be locked over the entire call.
588              * However, that pretty well ties up all the threads.  Meantime, all
589              * the chunks _MUST_ have their refcounts bumped.
590              * The writes done before a store back will clear setuid-ness
591              * in cache file.
592              * We can permit CacheStoreProc to wake up the user process IFF we
593              * are doing the last RPC for this close, ie, storing back the last
594              * set of contiguous chunks of a file.
595              */
596
597             nchunks = 1 + j - first;
598             nomore = !(moredata || (j != high));
599             length = lmin(avc->f.m.Length, avc->f.truncPos);
600             afs_Trace4(afs_iclSetp, CM_TRACE_STOREDATA64,
601                        ICL_TYPE_FID, &avc->f.fid.Fid, ICL_TYPE_OFFSET,
602                        ICL_HANDLE_OFFSET(base), ICL_TYPE_OFFSET,
603                        ICL_HANDLE_OFFSET(bytes), ICL_TYPE_OFFSET,
604                        ICL_HANDLE_OFFSET(length));
605
606             do {
607                 tc = afs_Conn(&avc->f.fid, areq, 0);
608
609 #ifdef AFS_64BIT_CLIENT
610               restart:
611 #endif
612                 code = rxfs_storeInit(avc, tc, length, bytes, base,
613                                         sync, &ops, &rock);
614                 if ( code ) {
615                     osi_Panic(
616                     "afs_CacheStoreProc: rxfs_storeInit failed with %d", code);
617                 }
618
619                 code = afs_CacheStoreDCaches(avc, dclist, bytes, anewDV,
620                         &doProcessFS, &OutStatus, nchunks, nomore, ops, rock);
621
622 #ifdef AFS_64BIT_CLIENT
623                 if (code == RXGEN_OPCODE && !afs_serverHasNo64Bit(tc)) {
624                     afs_serverSetNo64Bit(tc);
625                     goto restart;
626                 }
627 #endif /* AFS_64BIT_CLIENT */
628             } while (afs_Analyze
629                      (tc, code, &avc->f.fid, areq,
630                       AFS_STATS_FS_RPCIDX_STOREDATA, SHARED_LOCK,
631                       NULL));
632
633             /* put back all remaining locked dcache entries */
634             for (i = 0; i < nchunks; i++) {
635                 struct dcache *tdc = dclist[i];
636                 if (!code) {
637                     if (afs_indexFlags[tdc->index] & IFDataMod) {
638                         /*
639                          * LOCKXXX -- should hold afs_xdcache(W) when
640                          * modifying afs_indexFlags.
641                          */
642                         afs_indexFlags[tdc->index] &= ~IFDataMod;
643                         afs_stats_cmperf.cacheCurrDirtyChunks--;
644                         afs_indexFlags[tdc->index] &= ~IFDirtyPages;
645                         if (sync & AFS_VMSYNC_INVAL) {
646                             /* since we have invalidated all the pages of this
647                              ** vnode by calling osi_VM_TryToSmush, we can
648                              ** safely mark this dcache entry as not having
649                              ** any pages. This vnode now becomes eligible for
650                              ** reclamation by getDownD.
651                              */
652                             afs_indexFlags[tdc->index] &= ~IFAnyPages;
653                         }
654                     }
655                 }
656                 UpgradeSToWLock(&tdc->lock, 628);
657                 tdc->f.states &= ~DWriting;     /* correct? */
658                 tdc->dflags |= DFEntryMod;
659                 ReleaseWriteLock(&tdc->lock);
660                 afs_PutDCache(tdc);
661                 /* Mark the entry as released */
662                 dclist[i] = NULL;
663             }
664
665             if (doProcessFS) {
666                 /* Now copy out return params */
667                 UpgradeSToWLock(&avc->lock, 28);        /* keep out others for a while */
668                 afs_ProcessFS(avc, &OutStatus, areq);
669                 /* Keep last (max) size of file on server to see if
670                  * we need to call afs_StoreMini to extend the file.
671                  */
672                 if (!moredata)
673                     *amaxStoredLength = OutStatus.Length;
674                 ConvertWToSLock(&avc->lock);
675                 doProcessFS = 0;
676             }
677
678             if (code) {
679                 for (j++; j <= high; j++) {
680                     if (dcList[j]) {
681                         ReleaseSharedLock(&(dcList[j]->lock));
682                         afs_PutDCache(dcList[j]);
683                         /* Releasing entry */
684                         dcList[j] = NULL;
685                     }
686                 }
687             }
688
689             afs_Trace2(afs_iclSetp, CM_TRACE_STOREALLDCDONE,
690                        ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code);
691             bytes = 0;
692         }
693     }
694
695     return code;
696 }
697
698 /* rock and operations for RX_FILESERVER */
699
700 struct rxfs_fetchVariables {
701     struct rx_call *call;
702     char *tbuffer;
703     struct iovec *iov;
704     afs_uint32 nio;
705     afs_int32 hasNo64bit;
706     afs_int32 iovno;
707     afs_int32 iovmax;
708 };
709
710 afs_int32
711 rxfs_fetchUfsRead(void *r, afs_uint32 size, afs_uint32 *bytesread)
712 {
713     afs_int32 code;
714     afs_uint32 tlen;
715     struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
716
717     *bytesread = 0;
718     tlen = (size > AFS_LRALLOCSIZ ?  AFS_LRALLOCSIZ : size);
719     RX_AFS_GUNLOCK();
720     code = rx_Read(v->call, v->tbuffer, tlen);
721     RX_AFS_GLOCK();
722     if (code <= 0)
723         return -34;
724     *bytesread = code;
725     return 0;
726 }
727
728 afs_int32
729 rxfs_fetchMemRead(void *r, afs_uint32 tlen, afs_uint32 *bytesread)
730 {
731     afs_int32 code;
732     struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
733
734     *bytesread = 0;
735     RX_AFS_GUNLOCK();
736     code = rx_Readv(v->call, v->iov, &v->nio, RX_MAXIOVECS, tlen);
737     RX_AFS_GLOCK();
738     if (code <= 0)
739         return -34;
740     *bytesread = code;
741     return 0;
742 }
743
744
745 afs_int32
746 rxfs_fetchMemWrite(void *r, struct osi_file *fP,
747                         afs_uint32 offset, afs_uint32 tlen,
748                         afs_uint32 *byteswritten)
749 {
750     afs_int32 code;
751     struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
752     struct memCacheEntry *mceP = (struct memCacheEntry *)fP;
753
754     code = afs_MemWritevBlk(mceP, offset, v->iov, v->nio, tlen);
755     if (code != tlen) {
756         return EIO;
757     }
758     *byteswritten = code;
759     return 0;
760 }
761
762 afs_int32
763 rxfs_fetchUfsWrite(void *r, struct osi_file *fP,
764                         afs_uint32 offset, afs_uint32 tlen,
765                         afs_uint32 *byteswritten)
766 {
767     afs_int32 code;
768     struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
769
770     code = afs_osi_Write(fP, -1, v->tbuffer, tlen);
771     if (code != tlen) {
772         return EIO;
773     }
774     *byteswritten = code;
775     return 0;
776 }
777
778
779 afs_int32
780 rxfs_fetchClose(void *r, struct vcache *avc, struct dcache * adc,
781                                         struct afs_FetchOutput *tsmall)
782 {
783     afs_int32 code, code1 = 0;
784     struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)r;
785
786     if (!v->call)
787         return -1;
788
789     RX_AFS_GUNLOCK();
790     code = EndRXAFS_FetchData(v->call, &tsmall->OutStatus,
791                               &tsmall->CallBack,
792                               &tsmall->tsync);
793     RX_AFS_GLOCK();
794
795     RX_AFS_GUNLOCK();
796     if (v->call)
797         code1 = rx_EndCall(v->call, code);
798     RX_AFS_GLOCK();
799     if (!code && code1)
800         code = code1;
801
802     v->call = NULL;
803
804     return code;
805 }
806
807 afs_int32
808 rxfs_fetchDestroy(void **r, afs_int32 error)
809 {
810     afs_int32 code = error;
811     struct rxfs_fetchVariables *v = (struct rxfs_fetchVariables *)*r;
812
813     *r = NULL;
814     if (v->tbuffer)
815         osi_FreeLargeSpace(v->tbuffer);
816     if (v->iov)
817         osi_FreeSmallSpace(v->iov);
818     osi_FreeSmallSpace(v);
819     return code;
820 }
821
822 afs_int32
823 rxfs_fetchMore(void *r, afs_uint32 *length, afs_uint32 *moredata)
824 {
825     afs_int32 code;
826     register struct rxfs_fetchVariables *v
827             = (struct rxfs_fetchVariables *)r;
828
829     RX_AFS_GUNLOCK();
830     code = rx_Read(v->call, (void *)length, sizeof(afs_int32));
831     *length = ntohl(*length);
832     RX_AFS_GLOCK();
833     if (code != sizeof(afs_int32)) {
834         code = rx_Error(v->call);
835         return (code ? code : -1);      /* try to return code, not -1 */
836     }
837     return 0;
838 }
839
840 static
841 struct fetchOps rxfs_fetchUfsOps = {
842     rxfs_fetchMore,
843     rxfs_fetchUfsRead,
844     rxfs_fetchUfsWrite,
845     rxfs_fetchClose,
846     rxfs_fetchDestroy
847 };
848
849 static
850 struct fetchOps rxfs_fetchMemOps = {
851     rxfs_fetchMore,
852     rxfs_fetchMemRead,
853     rxfs_fetchMemWrite,
854     rxfs_fetchClose,
855     rxfs_fetchDestroy
856 };
857
858 afs_int32
859 rxfs_fetchInit(register struct afs_conn *tc, struct vcache *avc,afs_offs_t base,
860                 afs_uint32 size, afs_uint32 *alength, struct dcache *adc,
861                 struct osi_file *fP, struct fetchOps **ops, void **rock)
862 {
863     struct rxfs_fetchVariables *v;
864     int code, code1;
865     afs_int32 length_hi, length, bytes;
866 #ifdef AFS_64BIT_CLIENT
867     afs_size_t tsize;
868     afs_size_t lengthFound;     /* as returned from server */
869 #endif /* AFS_64BIT_CLIENT */
870
871     v = (struct rxfs_fetchVariables *) osi_AllocSmallSpace(sizeof(struct rxfs_fetchVariables));
872     if (!v)
873         osi_Panic("rxfs_fetchInit: osi_AllocSmallSpace returned NULL\n");
874     memset(v, 0, sizeof(struct rxfs_fetchVariables));
875
876     RX_AFS_GUNLOCK();
877     v->call = rx_NewCall(tc->id);
878     RX_AFS_GLOCK();
879
880 #ifdef AFS_64BIT_CLIENT
881     length_hi = code = 0;
882     if (!afs_serverHasNo64Bit(tc)) {
883         tsize = size;
884         RX_AFS_GUNLOCK();
885         code = StartRXAFS_FetchData64(v->call, (struct AFSFid *)&avc->f.fid.Fid,
886                                         base, tsize);
887         if (code != 0) {
888             RX_AFS_GLOCK();
889             afs_Trace2(afs_iclSetp, CM_TRACE_FETCH64CODE,
890                            ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code);
891         } else {
892             bytes = rx_Read(v->call, (char *)&length_hi, sizeof(afs_int32));
893             RX_AFS_GLOCK();
894             if (bytes == sizeof(afs_int32)) {
895                 length_hi = ntohl(length_hi);
896             } else {
897                 length_hi = 0;
898                 code = rx_Error(v->call);
899                 RX_AFS_GUNLOCK();
900                 code1 = rx_EndCall(v->call, code);
901                 RX_AFS_GLOCK();
902                 v->call = NULL;
903             }
904         }
905     }
906     if (code == RXGEN_OPCODE || afs_serverHasNo64Bit(tc)) {
907         if (base > 0x7FFFFFFF) {
908             code = EFBIG;
909         } else {
910             afs_int32 pos;
911             pos = base;
912             RX_AFS_GUNLOCK();
913             if (!v->call)
914                 v->call = rx_NewCall(tc->id);
915             code =
916                 StartRXAFS_FetchData(v->call, (struct AFSFid *)&avc->f.fid.Fid,
917                                         pos, size);
918             RX_AFS_GLOCK();
919         }
920         afs_serverSetNo64Bit(tc);
921     }
922     if (!code) {
923         RX_AFS_GUNLOCK();
924         bytes = rx_Read(v->call, (char *)&length, sizeof(afs_int32));
925         RX_AFS_GLOCK();
926         if (bytes == sizeof(afs_int32))
927             length = ntohl(length);
928         else {
929             code = rx_Error(v->call);
930         }
931     }
932     FillInt64(lengthFound, length_hi, length);
933     afs_Trace3(afs_iclSetp, CM_TRACE_FETCH64LENG,
934                ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code,
935                ICL_TYPE_OFFSET,
936                ICL_HANDLE_OFFSET(lengthFound));
937 #else /* AFS_64BIT_CLIENT */
938     RX_AFS_GUNLOCK();
939     code = StartRXAFS_FetchData(v->call, (struct AFSFid *)&avc->f.fid.Fid,
940                                  base, size);
941     RX_AFS_GLOCK();
942     if (code == 0) {
943         RX_AFS_GUNLOCK();
944         bytes = rx_Read(v->call, (char *)&length, sizeof(afs_int32));
945         RX_AFS_GLOCK();
946         if (bytes == sizeof(afs_int32))
947             length = ntohl(length);
948         else
949             code = rx_Error(v->call);
950     }
951 #endif /* AFS_64BIT_CLIENT */
952     if (code) {
953         osi_FreeSmallSpace(v);
954         return code;
955     }
956
957     if (cacheDiskType == AFS_FCACHE_TYPE_UFS) {
958         v->tbuffer = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
959         if (!v->tbuffer)
960             osi_Panic("rxfs_fetchInit: osi_AllocLargeSpace for iovecs returned NULL\n");
961         osi_Assert(WriteLocked(&adc->lock));
962         fP->offset = 0;
963         *ops = (struct fetchOps *) &rxfs_fetchUfsOps;
964     }
965     else {
966         afs_Trace4(afs_iclSetp, CM_TRACE_MEMFETCH, ICL_TYPE_POINTER, avc,
967                    ICL_TYPE_POINTER, fP, ICL_TYPE_OFFSET,
968                    ICL_HANDLE_OFFSET(base), ICL_TYPE_INT32, length);
969         /*
970          * We need to alloc the iovecs on the heap so that they are "pinned"
971          * rather than declare them on the stack - defect 11272
972          */
973         v->iov = osi_AllocSmallSpace(sizeof(struct iovec) * RX_MAXIOVECS);
974         if (!v->iov)
975             osi_Panic("rxfs_fetchInit: osi_AllocSmallSpace for iovecs returned NULL\n");
976         *ops = (struct fetchOps *) &rxfs_fetchMemOps;
977     }
978     *rock = (void *)v;
979     *alength = length;
980     return 0;
981 }
982
983
984 /*!
985  * Routine called on fetch; also tells people waiting for data
986  *      that more has arrived.
987  *
988  * \param tc Ptr to the Rx connection structure.
989  * \param fP File descriptor for the cache file.
990  * \param abase Base offset to fetch.
991  * \param adc Ptr to the dcache entry for the file, write-locked.
992  * \param avc Ptr to the vcache entry for the file.
993  * \param size Amount of data that should be fetched.
994  * \param tsmall Ptr to the afs_FetchOutput structure.
995  *
996  * \note Environment: Nothing interesting.
997  */
998 int
999 afs_CacheFetchProc(register struct afs_conn *tc,
1000                     register struct osi_file *fP, afs_size_t abase,
1001                     struct dcache *adc, struct vcache *avc,
1002                     afs_int32 size,
1003                     struct afs_FetchOutput *tsmall)
1004 {
1005     register afs_int32 code;
1006     afs_uint32 length;
1007     afs_uint32 bytesread, byteswritten;
1008     struct fetchOps *ops = NULL;
1009     void *rock = NULL;
1010     int moredata = 0;
1011     register int offset = 0;
1012
1013     XSTATS_DECLS;
1014 #ifndef AFS_NOSTATS
1015     osi_timeval_t xferStartTime;        /*FS xfer start time */
1016     afs_size_t bytesToXfer = 0, bytesXferred = 0;
1017 #endif
1018
1019     AFS_STATCNT(CacheFetchProc);
1020
1021     XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHDATA);
1022
1023     code = rxfs_fetchInit(tc, avc, abase, size, &length, adc, fP, &ops, &rock);
1024
1025 #ifndef AFS_NOSTATS
1026     osi_GetuTime(&xferStartTime);
1027 #endif /* AFS_NOSTATS */
1028
1029     adc->validPos = abase;
1030
1031     if ( !code ) do {
1032         if (moredata) {
1033             code = (*ops->more)(rock, &length, &moredata);
1034             if ( code )
1035                 break;
1036         }
1037         /*
1038          * The fetch protocol is extended for the AFS/DFS translator
1039          * to allow multiple blocks of data, each with its own length,
1040          * to be returned. As long as the top bit is set, there are more
1041          * blocks expected.
1042          *
1043          * We do not do this for AFS file servers because they sometimes
1044          * return large negative numbers as the transfer size.
1045          */
1046         if (avc->f.states & CForeign) {
1047             moredata = length & 0x80000000;
1048             length &= ~0x80000000;
1049         } else {
1050             moredata = 0;
1051         }
1052 #ifndef AFS_NOSTATS
1053         bytesToXfer += length;
1054 #endif /* AFS_NOSTATS */
1055         while (length > 0) {
1056 #ifdef RX_KERNEL_TRACE
1057             afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
1058                        "before rx_Read");
1059 #endif
1060             code = (*ops->read)(rock, length, &bytesread);
1061 #ifdef RX_KERNEL_TRACE
1062             afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
1063                        "after rx_Read");
1064 #endif
1065 #ifndef AFS_NOSTATS
1066             bytesXferred += bytesread;
1067 #endif /* AFS_NOSTATS */
1068             if ( code ) {
1069                 afs_Trace3(afs_iclSetp, CM_TRACE_FETCH64READ,
1070                            ICL_TYPE_POINTER, avc, ICL_TYPE_INT32, code,
1071                            ICL_TYPE_INT32, length);
1072                 code = -34;
1073                 break;
1074             }
1075             code = (*ops->write)(rock, fP, offset, bytesread, &byteswritten);
1076             if ( code )
1077                 break;
1078             offset += bytesread;
1079             abase += bytesread;
1080             length -= bytesread;
1081             adc->validPos = abase;
1082             if (afs_osi_Wakeup(&adc->validPos) == 0)
1083                 afs_Trace4(afs_iclSetp, CM_TRACE_DCACHEWAKE, ICL_TYPE_STRING,
1084                            __FILE__, ICL_TYPE_INT32, __LINE__,
1085                            ICL_TYPE_POINTER, adc, ICL_TYPE_INT32,
1086                            adc->dflags);
1087         }
1088         code = 0;
1089     } while (moredata);
1090     if (!code)
1091         code = (*ops->close)(rock, avc, adc, tsmall);
1092     (*ops->destroy)(&rock, code);
1093
1094 #ifndef AFS_NOSTATS
1095     FillStoreStats(code, AFS_STATS_FS_XFERIDX_FETCHDATA,&xferStartTime,
1096                         bytesToXfer, bytesXferred);
1097 #endif
1098     XSTATS_END_TIME;
1099     return code;
1100 }