Windows: restructure daemon state tracking
[openafs.git] / src / WINNT / afsd / rawops.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 #include <roken.h>
13
14 #include <osi.h>
15 #include "afsd.h"
16
17 /*
18  * called with scp->rw lock held exclusive
19  */
20 afs_int32
21 raw_ReadData( cm_scache_t *scp, osi_hyper_t *offsetp,
22               afs_uint32 length, char *bufferp, afs_uint32 *readp,
23               cm_user_t *userp, cm_req_t *reqp)
24 {
25     long code;
26     cm_buf_t *bufp = NULL;
27     osi_hyper_t fileLength;
28     osi_hyper_t thyper;
29     osi_hyper_t lastByte;
30     osi_hyper_t bufferOffset;
31     long bufIndex, nbytes;
32     int sequential = 0;
33
34     /* start by looking up the file's end */
35     code = cm_SyncOp(scp, NULL, userp, reqp, 0,
36                       CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
37     if (code)
38         goto done;
39
40     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
41
42     /* now we have the entry locked, look up the length */
43     fileLength = scp->length;
44
45     /* adjust length down so that it won't go past EOF */
46     thyper.LowPart = length;
47     thyper.HighPart = 0;
48     thyper = LargeIntegerAdd(*offsetp, thyper); /* where read should end */
49     lastByte = thyper;
50     if (LargeIntegerGreaterThan(thyper, fileLength)) {
51         /* we'd read past EOF, so just stop at fileLength bytes.
52         * Start by computing how many bytes remain in the file.
53         */
54         thyper = LargeIntegerSubtract(fileLength, *offsetp);
55
56         /* if we are past EOF, read 0 bytes */
57         if (LargeIntegerLessThanZero(thyper))
58             length = 0;
59         else
60             length = thyper.LowPart;
61     }
62
63     *readp = length;
64
65     /* now, copy the data one buffer at a time,
66      * until we've filled the request packet
67      */
68     while (1) {
69         /* if we've copied all the data requested, we're done */
70         if (length <= 0) break;
71
72         /* otherwise, load up a buffer of data */
73         thyper.HighPart = offsetp->HighPart;
74         thyper.LowPart = offsetp->LowPart & ~(cm_data.blockSize-1);
75         if (!bufp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
76             /* wrong buffer */
77             if (bufp) {
78                 buf_Release(bufp);
79                 bufp = NULL;
80             }
81             lock_ReleaseWrite(&scp->rw);
82
83             code = buf_Get(scp, &thyper, reqp, &bufp);
84
85             lock_ObtainWrite(&scp->rw);
86             if (code) goto done;
87             bufferOffset = thyper;
88
89             /* now get the data in the cache */
90             while (1) {
91                 code = cm_SyncOp(scp, bufp, userp, reqp, 0,
92                                  CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
93                 if (code)
94                     goto done;
95
96                 cm_SyncOpDone(scp, bufp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
97
98                 if (cm_HaveBuffer(scp, bufp, 0)) break;
99
100                 /* otherwise, load the buffer and try again */
101                 code = cm_GetBuffer(scp, bufp, NULL, userp, reqp);
102                 if (code) break;
103             }
104             if (code) {
105                 buf_Release(bufp);
106                 bufp = NULL;
107                 goto done;
108             }
109         }       /* if (wrong buffer) ... */
110
111         /* now we have the right buffer loaded.  Copy out the
112          * data from here to the user's buffer.
113          */
114         bufIndex = offsetp->LowPart & (cm_data.blockSize - 1);
115
116         /* and figure out how many bytes we want from this buffer */
117         nbytes = cm_data.blockSize - bufIndex;  /* what remains in buffer */
118         if (nbytes > length) nbytes = length;   /* don't go past EOF */
119
120         /* now copy the data */
121         memcpy(bufferp, bufp->datap + bufIndex, nbytes);
122
123         /* adjust lengthers, pointers, etc. */
124         bufferp += nbytes;
125         length -= nbytes;
126         thyper.LowPart = nbytes;
127         thyper.HighPart = 0;
128         *offsetp = LargeIntegerAdd(thyper, *offsetp);
129     } /* while 1 */
130
131   done:
132     if (bufp)
133         buf_Release(bufp);
134
135     if (code == 0 && sequential)
136         cm_ConsiderPrefetch(scp, &lastByte, *readp, userp, reqp);
137
138     return code;
139 }
140
141
142 /*
143  * called with scp->rw lock held exclusive
144  */
145
146 afs_uint32
147 raw_WriteData( cm_scache_t *scp, osi_hyper_t *offsetp, afs_uint32 length, char *bufferp,
148                cm_user_t *userp, cm_req_t *reqp, afs_uint32 *writtenp)
149 {
150     long code = 0;
151     long written = 0;
152     osi_hyper_t fileLength;     /* file's length at start of write */
153     osi_hyper_t minLength;      /* don't read past this */
154     afs_uint32 nbytes;          /* # of bytes to transfer this iteration */
155     cm_buf_t *bufp = NULL;
156     osi_hyper_t thyper;         /* hyper tmp variable */
157     osi_hyper_t bufferOffset;
158     afs_uint32 bufIndex;        /* index in buffer where our data is */
159     int doWriteBack = 0;
160     osi_hyper_t writeBackOffset;/* offset of region to write back when I/O is done */
161     afs_uint32 writeBackLength;
162     DWORD filter = 0;
163
164     /* start by looking up the file's end */
165     code = cm_SyncOp(scp, NULL, userp, reqp, 0,
166                      CM_SCACHESYNC_NEEDCALLBACK
167                       | CM_SCACHESYNC_SETSTATUS
168                       | CM_SCACHESYNC_GETSTATUS);
169     if (code)
170         goto done;
171
172     cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_GETSTATUS);
173
174     /* now we have the entry locked, look up the length */
175     fileLength = scp->length;
176     minLength = fileLength;
177     if (LargeIntegerGreaterThan(minLength, scp->serverLength))
178         minLength = scp->serverLength;
179
180     /* adjust file length if we extend past EOF */
181     thyper.LowPart = length;
182     thyper.HighPart = 0;
183     thyper = LargeIntegerAdd(*offsetp, thyper); /* where write should end */
184     if (LargeIntegerGreaterThan(thyper, fileLength)) {
185         /* we'd write past EOF, so extend the file */
186         scp->mask |= CM_SCACHEMASK_LENGTH;
187         scp->length = thyper;
188         filter |= (FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_SIZE);
189     } else
190         filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
191
192     doWriteBack = 1;
193     writeBackOffset = *offsetp;
194     writeBackLength = length;
195
196     /* now, copy the data one buffer at a time, until we've filled the
197      * request packet */
198     while (1) {
199         /* if we've copied all the data requested, we're done */
200         if (length <= 0) break;
201
202         /* otherwise, load up a buffer of data */
203         thyper.HighPart = offsetp->HighPart;
204         thyper.LowPart = offsetp->LowPart & ~(cm_data.blockSize-1);
205         if (!bufp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
206             /* wrong buffer */
207             if (bufp) {
208                 lock_ReleaseMutex(&bufp->mx);
209                 buf_Release(bufp);
210                 bufp = NULL;
211             }
212             lock_ReleaseWrite(&scp->rw);
213
214             code = buf_Get(scp, &thyper, reqp, &bufp);
215             if (bufp)
216                 lock_ObtainMutex(&bufp->mx);
217
218             lock_ObtainWrite(&scp->rw);
219             if (code)
220                 goto done;
221
222             bufferOffset = thyper;
223
224             /* now get the data in the cache */
225             while (1) {
226                 code = cm_SyncOp(scp, bufp, userp, reqp, 0,
227                                   CM_SCACHESYNC_NEEDCALLBACK
228                                   | CM_SCACHESYNC_WRITE
229                                   | CM_SCACHESYNC_BUFLOCKED);
230                 if (code)
231                     goto done;
232
233                 cm_SyncOpDone(scp, bufp,
234                                CM_SCACHESYNC_NEEDCALLBACK
235                                | CM_SCACHESYNC_WRITE
236                                | CM_SCACHESYNC_BUFLOCKED);
237
238                 /* If we're overwriting the entire buffer, or
239                  * if we're writing at or past EOF, mark the
240                  * buffer as current so we don't call
241                  * cm_GetBuffer.  This skips the fetch from the
242                  * server in those cases where we're going to
243                  * obliterate all the data in the buffer anyway,
244                  * or in those cases where there is no useful
245                  * data at the server to start with.
246                  *
247                  * Use minLength instead of scp->length, since
248                  * the latter has already been updated by this
249                  * call.
250                  */
251                 if (LargeIntegerGreaterThanOrEqualTo(bufp->offset, minLength) ||
252                      LargeIntegerEqualTo(*offsetp, bufp->offset) &&
253                      (length >= cm_data.blockSize ||
254                        LargeIntegerGreaterThanOrEqualTo(LargeIntegerAdd(*offsetp, ConvertLongToLargeInteger(length)), minLength))) {
255                     if (length < cm_data.blockSize
256                          && bufp->dataVersion == CM_BUF_VERSION_BAD)
257                         memset(bufp->datap, 0,
258                                 cm_data.blockSize);
259                     bufp->dataVersion = scp->dataVersion;
260                 }
261
262                 if (cm_HaveBuffer(scp, bufp, 1)) break;
263
264                 /* otherwise, load the buffer and try again */
265                 lock_ReleaseMutex(&bufp->mx);
266                 code = cm_GetBuffer(scp, bufp, NULL, userp, reqp);
267                 lock_ReleaseWrite(&scp->rw);
268                 lock_ObtainMutex(&bufp->mx);
269                 lock_ObtainWrite(&scp->rw);
270                 if (code)
271                     break;
272             }
273             if (code) {
274                 lock_ReleaseMutex(&bufp->mx);
275                 buf_Release(bufp);
276                 bufp = NULL;
277                 goto done;
278             }
279         }       /* if (wrong buffer) ... */
280
281         /* now we have the right buffer loaded.  Copy out the
282          * data from here to the user's buffer.
283          */
284         bufIndex = offsetp->LowPart & (cm_data.blockSize - 1);
285
286         /* and figure out how many bytes we want from this buffer */
287         nbytes = cm_data.blockSize - bufIndex;  /* what remains in buffer */
288         if (nbytes > length)
289             nbytes = length;    /* don't go past end of request */
290
291         /* now copy the data */
292         memcpy(bufp->datap + bufIndex, bufferp, nbytes);
293         buf_SetDirty(bufp, reqp, bufIndex, nbytes, userp);
294
295         /* adjust lengthers, pointers, etc. */
296         bufferp += nbytes;
297         length -= nbytes;
298         written += nbytes;
299         thyper.LowPart = nbytes;
300         thyper.HighPart = 0;
301         *offsetp = LargeIntegerAdd(thyper, *offsetp);
302     } /* while 1 */
303
304   done:
305     if (writtenp)
306         *writtenp = written;
307
308     if (bufp) {
309         lock_ReleaseMutex(&bufp->mx);
310         buf_Release(bufp);
311     }
312
313     if (code == 0 && doWriteBack) {
314         rock_BkgStore_t *rockp = malloc(sizeof(*rockp));
315
316         if (rockp) {
317             code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_ASYNCSTORE);
318             if (code == 0) {
319                 rockp->length = writeBackLength;
320                 rockp->offset = writeBackOffset;
321
322                 lock_ReleaseWrite(&scp->rw);
323                 cm_QueueBKGRequest(scp, cm_BkgStore, rockp, userp, reqp);
324                 lock_ObtainWrite(&scp->rw);
325
326                 /* rock is freed by cm_BkgDaemon */
327             } else {
328                 free(rockp);
329             }
330         }
331     }
332
333     /* cm_SyncOpDone is called when cm_BkgStore completes */
334     return code;
335 }
336
337