s3: Fix some error messages
[amitay/samba.git] / source3 / smbd / aio.c
1 /*
2    Unix SMB/Netbios implementation.
3    Version 3.0
4    async_io read handling using POSIX async io.
5    Copyright (C) Jeremy Allison 2005.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "smbd/globals.h"
23
24 #if defined(WITH_AIO)
25
26 /* The signal we'll use to signify aio done. */
27 #ifndef RT_SIGNAL_AIO
28 #define RT_SIGNAL_AIO   (SIGRTMIN+3)
29 #endif
30
31 #ifndef HAVE_STRUCT_SIGEVENT_SIGEV_VALUE_SIVAL_PTR
32 #ifdef HAVE_STRUCT_SIGEVENT_SIGEV_VALUE_SIGVAL_PTR
33 #define sival_int       sigval_int
34 #define sival_ptr       sigval_ptr
35 #endif
36 #endif
37
38 /****************************************************************************
39  The buffer we keep around whilst an aio request is in process.
40 *****************************************************************************/
41
42 struct aio_extra {
43         struct aio_extra *next, *prev;
44         SMB_STRUCT_AIOCB acb;
45         files_struct *fsp;
46         struct smb_request *smbreq;
47         DATA_BLOB outbuf;
48         struct lock_struct lock;
49         bool write_through;
50         int (*handle_completion)(struct aio_extra *ex, int errcode);
51 };
52
53 /****************************************************************************
54  Initialize the signal handler for aio read/write.
55 *****************************************************************************/
56
57 static void smbd_aio_signal_handler(struct tevent_context *ev_ctx,
58                                     struct tevent_signal *se,
59                                     int signum, int count,
60                                     void *_info, void *private_data)
61 {
62         siginfo_t *info = (siginfo_t *)_info;
63         struct aio_extra *aio_ex = (struct aio_extra *)
64                                 info->si_value.sival_ptr;
65
66         smbd_aio_complete_aio_ex(aio_ex);
67 }
68
69
70 static bool initialize_async_io_handler(void)
71 {
72         static bool tried_signal_setup = false;
73
74         if (aio_signal_event) {
75                 return true;
76         }
77         if (tried_signal_setup) {
78                 return false;
79         }
80         tried_signal_setup = true;
81
82         aio_signal_event = tevent_add_signal(smbd_event_context(),
83                                              smbd_event_context(),
84                                              RT_SIGNAL_AIO, SA_SIGINFO,
85                                              smbd_aio_signal_handler,
86                                              NULL);
87         if (!aio_signal_event) {
88                 DEBUG(10, ("Failed to setup RT_SIGNAL_AIO handler\n"));
89                 return false;
90         }
91
92         /* tevent supports 100 signal with SA_SIGINFO */
93         aio_pending_size = 100;
94         return true;
95 }
96
97 static int handle_aio_read_complete(struct aio_extra *aio_ex, int errcode);
98 static int handle_aio_write_complete(struct aio_extra *aio_ex, int errcode);
99 static int handle_aio_smb2_read_complete(struct aio_extra *aio_ex, int errcode);
100 static int handle_aio_smb2_write_complete(struct aio_extra *aio_ex, int errcode);
101
102 static int aio_extra_destructor(struct aio_extra *aio_ex)
103 {
104         DLIST_REMOVE(aio_list_head, aio_ex);
105         return 0;
106 }
107
108 /****************************************************************************
109  Create the extended aio struct we must keep around for the lifetime
110  of the aio call.
111 *****************************************************************************/
112
113 static struct aio_extra *create_aio_extra(TALLOC_CTX *mem_ctx,
114                                         files_struct *fsp,
115                                         size_t buflen)
116 {
117         struct aio_extra *aio_ex = TALLOC_ZERO_P(mem_ctx, struct aio_extra);
118
119         if (!aio_ex) {
120                 return NULL;
121         }
122
123         /* The output buffer stored in the aio_ex is the start of
124            the smb return buffer. The buffer used in the acb
125            is the start of the reply data portion of that buffer. */
126
127         if (buflen) {
128                 aio_ex->outbuf = data_blob_talloc(aio_ex, NULL, buflen);
129                 if (!aio_ex->outbuf.data) {
130                         TALLOC_FREE(aio_ex);
131                         return NULL;
132                 }
133         }
134         DLIST_ADD(aio_list_head, aio_ex);
135         talloc_set_destructor(aio_ex, aio_extra_destructor);
136         aio_ex->fsp = fsp;
137         return aio_ex;
138 }
139
140 /****************************************************************************
141  Set up an aio request from a SMBreadX call.
142 *****************************************************************************/
143
144 NTSTATUS schedule_aio_read_and_X(connection_struct *conn,
145                              struct smb_request *smbreq,
146                              files_struct *fsp, SMB_OFF_T startpos,
147                              size_t smb_maxcnt)
148 {
149         struct aio_extra *aio_ex;
150         SMB_STRUCT_AIOCB *a;
151         size_t bufsize;
152         size_t min_aio_read_size = lp_aio_read_size(SNUM(conn));
153         int ret;
154
155         /* Ensure aio is initialized. */
156         if (!initialize_async_io_handler()) {
157                 return NT_STATUS_RETRY;
158         }
159
160         if (fsp->base_fsp != NULL) {
161                 /* No AIO on streams yet */
162                 DEBUG(10, ("AIO on streams not yet supported\n"));
163                 return NT_STATUS_RETRY;
164         }
165
166         if ((!min_aio_read_size || (smb_maxcnt < min_aio_read_size))
167             && !SMB_VFS_AIO_FORCE(fsp)) {
168                 /* Too small a read for aio request. */
169                 DEBUG(10,("schedule_aio_read_and_X: read size (%u) too small "
170                           "for minimum aio_read of %u\n",
171                           (unsigned int)smb_maxcnt,
172                           (unsigned int)min_aio_read_size ));
173                 return NT_STATUS_RETRY;
174         }
175
176         /* Only do this on non-chained and non-chaining reads not using the
177          * write cache. */
178         if (req_is_in_chain(smbreq) || (lp_write_cache_size(SNUM(conn)) != 0)) {
179                 return NT_STATUS_RETRY;
180         }
181
182         if (outstanding_aio_calls >= aio_pending_size) {
183                 DEBUG(10,("schedule_aio_read_and_X: Already have %d aio "
184                           "activities outstanding.\n",
185                           outstanding_aio_calls ));
186                 return NT_STATUS_RETRY;
187         }
188
189         /* The following is safe from integer wrap as we've already checked
190            smb_maxcnt is 128k or less. Wct is 12 for read replies */
191
192         bufsize = smb_size + 12 * 2 + smb_maxcnt;
193
194         if ((aio_ex = create_aio_extra(NULL, fsp, bufsize)) == NULL) {
195                 DEBUG(10,("schedule_aio_read_and_X: malloc fail.\n"));
196                 return NT_STATUS_NO_MEMORY;
197         }
198         aio_ex->handle_completion = handle_aio_read_complete;
199
200         construct_reply_common_req(smbreq, (char *)aio_ex->outbuf.data);
201         srv_set_message((char *)aio_ex->outbuf.data, 12, 0, True);
202         SCVAL(aio_ex->outbuf.data,smb_vwv0,0xFF); /* Never a chained reply. */
203
204         init_strict_lock_struct(fsp, (uint64_t)smbreq->smbpid,
205                 (uint64_t)startpos, (uint64_t)smb_maxcnt, READ_LOCK,
206                 &aio_ex->lock);
207
208         /* Take the lock until the AIO completes. */
209         if (!SMB_VFS_STRICT_LOCK(conn, fsp, &aio_ex->lock)) {
210                 TALLOC_FREE(aio_ex);
211                 return NT_STATUS_FILE_LOCK_CONFLICT;
212         }
213
214         a = &aio_ex->acb;
215
216         /* Now set up the aio record for the read call. */
217
218         a->aio_fildes = fsp->fh->fd;
219         a->aio_buf = smb_buf(aio_ex->outbuf.data);
220         a->aio_nbytes = smb_maxcnt;
221         a->aio_offset = startpos;
222         a->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
223         a->aio_sigevent.sigev_signo  = RT_SIGNAL_AIO;
224         a->aio_sigevent.sigev_value.sival_ptr = aio_ex;
225
226         ret = SMB_VFS_AIO_READ(fsp, a);
227         if (ret == -1) {
228                 DEBUG(0,("schedule_aio_read_and_X: aio_read failed. "
229                          "Error %s\n", strerror(errno) ));
230                 SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
231                 TALLOC_FREE(aio_ex);
232                 return NT_STATUS_RETRY;
233         }
234
235         outstanding_aio_calls++;
236         aio_ex->smbreq = talloc_move(aio_ex, &smbreq);
237
238         DEBUG(10,("schedule_aio_read_and_X: scheduled aio_read for file %s, "
239                   "offset %.0f, len = %u (mid = %u)\n",
240                   fsp_str_dbg(fsp), (double)startpos, (unsigned int)smb_maxcnt,
241                   (unsigned int)aio_ex->smbreq->mid ));
242
243         return NT_STATUS_OK;
244 }
245
246 /****************************************************************************
247  Set up an aio request from a SMBwriteX call.
248 *****************************************************************************/
249
250 NTSTATUS schedule_aio_write_and_X(connection_struct *conn,
251                               struct smb_request *smbreq,
252                               files_struct *fsp, char *data,
253                               SMB_OFF_T startpos,
254                               size_t numtowrite)
255 {
256         struct aio_extra *aio_ex;
257         SMB_STRUCT_AIOCB *a;
258         size_t bufsize;
259         size_t min_aio_write_size = lp_aio_write_size(SNUM(conn));
260         int ret;
261
262         /* Ensure aio is initialized. */
263         if (!initialize_async_io_handler()) {
264                 return NT_STATUS_RETRY;
265         }
266
267         if (fsp->base_fsp != NULL) {
268                 /* No AIO on streams yet */
269                 DEBUG(10, ("AIO on streams not yet supported\n"));
270                 return NT_STATUS_RETRY;
271         }
272
273         if ((!min_aio_write_size || (numtowrite < min_aio_write_size))
274             && !SMB_VFS_AIO_FORCE(fsp)) {
275                 /* Too small a write for aio request. */
276                 DEBUG(10,("schedule_aio_write_and_X: write size (%u) too "
277                           "small for minimum aio_write of %u\n",
278                           (unsigned int)numtowrite,
279                           (unsigned int)min_aio_write_size ));
280                 return NT_STATUS_RETRY;
281         }
282
283         /* Only do this on non-chained and non-chaining writes not using the
284          * write cache. */
285         if (req_is_in_chain(smbreq) || (lp_write_cache_size(SNUM(conn)) != 0)) {
286                 return NT_STATUS_RETRY;
287         }
288
289         if (outstanding_aio_calls >= aio_pending_size) {
290                 DEBUG(3,("schedule_aio_write_and_X: Already have %d aio "
291                          "activities outstanding.\n",
292                           outstanding_aio_calls ));
293                 DEBUG(10,("schedule_aio_write_and_X: failed to schedule "
294                           "aio_write for file %s, offset %.0f, len = %u "
295                           "(mid = %u)\n",
296                           fsp_str_dbg(fsp), (double)startpos,
297                           (unsigned int)numtowrite,
298                           (unsigned int)smbreq->mid ));
299                 return NT_STATUS_RETRY;
300         }
301
302         bufsize = smb_size + 6*2;
303
304         if (!(aio_ex = create_aio_extra(NULL, fsp, bufsize))) {
305                 DEBUG(0,("schedule_aio_write_and_X: malloc fail.\n"));
306                 return NT_STATUS_NO_MEMORY;
307         }
308         aio_ex->handle_completion = handle_aio_write_complete;
309         aio_ex->write_through = BITSETW(smbreq->vwv+7,0);
310
311         construct_reply_common_req(smbreq, (char *)aio_ex->outbuf.data);
312         srv_set_message((char *)aio_ex->outbuf.data, 6, 0, True);
313         SCVAL(aio_ex->outbuf.data,smb_vwv0,0xFF); /* Never a chained reply. */
314
315         init_strict_lock_struct(fsp, (uint64_t)smbreq->smbpid,
316                 (uint64_t)startpos, (uint64_t)numtowrite, WRITE_LOCK,
317                 &aio_ex->lock);
318
319         /* Take the lock until the AIO completes. */
320         if (!SMB_VFS_STRICT_LOCK(conn, fsp, &aio_ex->lock)) {
321                 TALLOC_FREE(aio_ex);
322                 return NT_STATUS_FILE_LOCK_CONFLICT;
323         }
324
325         a = &aio_ex->acb;
326
327         /* Now set up the aio record for the write call. */
328
329         a->aio_fildes = fsp->fh->fd;
330         a->aio_buf = data;
331         a->aio_nbytes = numtowrite;
332         a->aio_offset = startpos;
333         a->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
334         a->aio_sigevent.sigev_signo  = RT_SIGNAL_AIO;
335         a->aio_sigevent.sigev_value.sival_ptr = aio_ex;
336
337         ret = SMB_VFS_AIO_WRITE(fsp, a);
338         if (ret == -1) {
339                 DEBUG(3,("schedule_aio_wrote_and_X: aio_write failed. "
340                          "Error %s\n", strerror(errno) ));
341                 SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
342                 TALLOC_FREE(aio_ex);
343                 return NT_STATUS_RETRY;
344         }
345
346         outstanding_aio_calls++;
347         aio_ex->smbreq = talloc_move(aio_ex, &smbreq);
348
349         /* This should actually be improved to span the write. */
350         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WRITE);
351         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WRITE);
352
353         if (!aio_ex->write_through && !lp_syncalways(SNUM(fsp->conn))
354             && fsp->aio_write_behind) {
355                 /* Lie to the client and immediately claim we finished the
356                  * write. */
357                 SSVAL(aio_ex->outbuf.data,smb_vwv2,numtowrite);
358                 SSVAL(aio_ex->outbuf.data,smb_vwv4,(numtowrite>>16)&1);
359                 show_msg((char *)aio_ex->outbuf.data);
360                 if (!srv_send_smb(smbd_server_fd(),(char *)aio_ex->outbuf.data,
361                                 true, aio_ex->smbreq->seqnum+1,
362                                 IS_CONN_ENCRYPTED(fsp->conn),
363                                 &aio_ex->smbreq->pcd)) {
364                         exit_server_cleanly("schedule_aio_write_and_X: "
365                                             "srv_send_smb failed.");
366                 }
367                 DEBUG(10,("schedule_aio_write_and_X: scheduled aio_write "
368                           "behind for file %s\n", fsp_str_dbg(fsp)));
369         }
370
371         DEBUG(10,("schedule_aio_write_and_X: scheduled aio_write for file "
372                   "%s, offset %.0f, len = %u (mid = %u) "
373                   "outstanding_aio_calls = %d\n",
374                   fsp_str_dbg(fsp), (double)startpos, (unsigned int)numtowrite,
375                   (unsigned int)aio_ex->smbreq->mid, outstanding_aio_calls ));
376
377         return NT_STATUS_OK;
378 }
379
380 /****************************************************************************
381  Set up an aio request from a SMB2 read call.
382 *****************************************************************************/
383
384 NTSTATUS schedule_smb2_aio_read(connection_struct *conn,
385                                 struct smb_request *smbreq,
386                                 files_struct *fsp,
387                                 char *inbuf,
388                                 SMB_OFF_T startpos,
389                                 size_t smb_maxcnt)
390 {
391         struct aio_extra *aio_ex;
392         SMB_STRUCT_AIOCB *a;
393         size_t min_aio_read_size = lp_aio_read_size(SNUM(conn));
394         int ret;
395
396         /* Ensure aio is initialized. */
397         if (!initialize_async_io_handler()) {
398                 return NT_STATUS_RETRY;
399         }
400
401         if (fsp->base_fsp != NULL) {
402                 /* No AIO on streams yet */
403                 DEBUG(10, ("AIO on streams not yet supported\n"));
404                 return NT_STATUS_RETRY;
405         }
406
407         if ((!min_aio_read_size || (smb_maxcnt < min_aio_read_size))
408             && !SMB_VFS_AIO_FORCE(fsp)) {
409                 /* Too small a read for aio request. */
410                 DEBUG(10,("smb2: read size (%u) too small "
411                         "for minimum aio_read of %u\n",
412                         (unsigned int)smb_maxcnt,
413                         (unsigned int)min_aio_read_size ));
414                 return NT_STATUS_RETRY;
415         }
416
417         /* Only do this on reads not using the write cache. */
418         if (lp_write_cache_size(SNUM(conn)) != 0) {
419                 return NT_STATUS_RETRY;
420         }
421
422         if (outstanding_aio_calls >= aio_pending_size) {
423                 DEBUG(10,("smb2: Already have %d aio "
424                         "activities outstanding.\n",
425                         outstanding_aio_calls ));
426                 return NT_STATUS_RETRY;
427         }
428
429         if (!(aio_ex = create_aio_extra(smbreq->smb2req, fsp, 0))) {
430                 return NT_STATUS_NO_MEMORY;
431         }
432         aio_ex->handle_completion = handle_aio_smb2_read_complete;
433
434         init_strict_lock_struct(fsp, (uint64_t)smbreq->smbpid,
435                 (uint64_t)startpos, (uint64_t)smb_maxcnt, READ_LOCK,
436                 &aio_ex->lock);
437
438         /* Take the lock until the AIO completes. */
439         if (!SMB_VFS_STRICT_LOCK(conn, fsp, &aio_ex->lock)) {
440                 TALLOC_FREE(aio_ex);
441                 return NT_STATUS_FILE_LOCK_CONFLICT;
442         }
443
444         a = &aio_ex->acb;
445
446         /* Now set up the aio record for the read call. */
447
448         a->aio_fildes = fsp->fh->fd;
449         a->aio_buf = inbuf;
450         a->aio_nbytes = smb_maxcnt;
451         a->aio_offset = startpos;
452         a->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
453         a->aio_sigevent.sigev_signo  = RT_SIGNAL_AIO;
454         a->aio_sigevent.sigev_value.sival_ptr = aio_ex;
455
456         ret = SMB_VFS_AIO_READ(fsp, a);
457         if (ret == -1) {
458                 DEBUG(0,("smb2: aio_read failed. "
459                         "Error %s\n", strerror(errno) ));
460                 SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
461                 TALLOC_FREE(aio_ex);
462                 return NT_STATUS_RETRY;
463         }
464
465         outstanding_aio_calls++;
466         /* We don't need talloc_move here as both aio_ex and
467          * smbreq are children of smbreq->smb2req. */
468         aio_ex->smbreq = smbreq;
469
470         DEBUG(10,("smb2: scheduled aio_read for file %s, "
471                 "offset %.0f, len = %u (mid = %u)\n",
472                 fsp_str_dbg(fsp), (double)startpos, (unsigned int)smb_maxcnt,
473                 (unsigned int)aio_ex->smbreq->mid ));
474
475         return NT_STATUS_OK;
476 }
477
478 /****************************************************************************
479  Set up an aio request from a SMB2write call.
480 *****************************************************************************/
481
482 NTSTATUS schedule_aio_smb2_write(connection_struct *conn,
483                                 struct smb_request *smbreq,
484                                 files_struct *fsp,
485                                 uint64_t in_offset,
486                                 DATA_BLOB in_data,
487                                 bool write_through)
488 {
489         struct aio_extra *aio_ex = NULL;
490         SMB_STRUCT_AIOCB *a = NULL;
491         size_t min_aio_write_size = lp_aio_write_size(SNUM(conn));
492         int ret;
493
494         /* Ensure aio is initialized. */
495         if (!initialize_async_io_handler()) {
496                 return NT_STATUS_RETRY;
497         }
498
499         if (fsp->base_fsp != NULL) {
500                 /* No AIO on streams yet */
501                 DEBUG(10, ("AIO on streams not yet supported\n"));
502                 return NT_STATUS_RETRY;
503         }
504
505         if ((!min_aio_write_size || (in_data.length < min_aio_write_size))
506             && !SMB_VFS_AIO_FORCE(fsp)) {
507                 /* Too small a write for aio request. */
508                 DEBUG(10,("smb2: write size (%u) too "
509                         "small for minimum aio_write of %u\n",
510                         (unsigned int)in_data.length,
511                         (unsigned int)min_aio_write_size ));
512                 return NT_STATUS_RETRY;
513         }
514
515         /* Only do this on writes not using the write cache. */
516         if (lp_write_cache_size(SNUM(conn)) != 0) {
517                 return NT_STATUS_RETRY;
518         }
519
520         if (outstanding_aio_calls >= aio_pending_size) {
521                 DEBUG(3,("smb2: Already have %d aio "
522                         "activities outstanding.\n",
523                         outstanding_aio_calls ));
524                 return NT_STATUS_RETRY;
525         }
526
527         if (!(aio_ex = create_aio_extra(smbreq->smb2req, fsp, 0))) {
528                 return NT_STATUS_NO_MEMORY;
529         }
530
531         aio_ex->handle_completion = handle_aio_smb2_write_complete;
532         aio_ex->write_through = write_through;
533
534         init_strict_lock_struct(fsp, (uint64_t)smbreq->smbpid,
535                 in_offset, (uint64_t)in_data.length, WRITE_LOCK,
536                 &aio_ex->lock);
537
538         /* Take the lock until the AIO completes. */
539         if (!SMB_VFS_STRICT_LOCK(conn, fsp, &aio_ex->lock)) {
540                 TALLOC_FREE(aio_ex);
541                 return NT_STATUS_FILE_LOCK_CONFLICT;
542         }
543
544         a = &aio_ex->acb;
545
546         /* Now set up the aio record for the write call. */
547
548         a->aio_fildes = fsp->fh->fd;
549         a->aio_buf = in_data.data;
550         a->aio_nbytes = in_data.length;
551         a->aio_offset = in_offset;
552         a->aio_sigevent.sigev_notify = SIGEV_SIGNAL;
553         a->aio_sigevent.sigev_signo  = RT_SIGNAL_AIO;
554         a->aio_sigevent.sigev_value.sival_ptr = aio_ex;
555
556         ret = SMB_VFS_AIO_WRITE(fsp, a);
557         if (ret == -1) {
558                 DEBUG(3,("smb2: aio_write failed. "
559                         "Error %s\n", strerror(errno) ));
560                 SMB_VFS_STRICT_UNLOCK(conn, fsp, &aio_ex->lock);
561                 TALLOC_FREE(aio_ex);
562                 return NT_STATUS_RETRY;
563         }
564
565         outstanding_aio_calls++;
566         /* We don't need talloc_move here as both aio_ex and
567         * smbreq are children of smbreq->smb2req. */
568         aio_ex->smbreq = smbreq;
569
570         /* This should actually be improved to span the write. */
571         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_WRITE);
572         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_WRITE);
573
574         /*
575          * We don't want to do write behind due to ownership
576          * issues of the request structs. Maybe add it if I
577          * figure those out. JRA.
578          */
579
580         DEBUG(10,("smb2: scheduled aio_write for file "
581                 "%s, offset %.0f, len = %u (mid = %u) "
582                 "outstanding_aio_calls = %d\n",
583                 fsp_str_dbg(fsp),
584                 (double)in_offset,
585                 (unsigned int)in_data.length,
586                 (unsigned int)aio_ex->smbreq->mid,
587                 outstanding_aio_calls ));
588
589         return NT_STATUS_OK;
590 }
591
592 /****************************************************************************
593  Complete the read and return the data or error back to the client.
594  Returns errno or zero if all ok.
595 *****************************************************************************/
596
597 static int handle_aio_read_complete(struct aio_extra *aio_ex, int errcode)
598 {
599         int outsize;
600         char *outbuf = (char *)aio_ex->outbuf.data;
601         char *data = smb_buf(outbuf);
602         ssize_t nread = SMB_VFS_AIO_RETURN(aio_ex->fsp,&aio_ex->acb);
603
604         if (nread < 0) {
605                 /* We're relying here on the fact that if the fd is
606                    closed then the aio will complete and aio_return
607                    will return an error. Hopefully this is
608                    true.... JRA. */
609
610                 DEBUG( 3,( "handle_aio_read_complete: file %s nread == %d. "
611                            "Error = %s\n",
612                            fsp_str_dbg(aio_ex->fsp), (int)nread, strerror(errcode)));
613
614                 ERROR_NT(map_nt_error_from_unix(errcode));
615                 outsize = srv_set_message(outbuf,0,0,true);
616         } else {
617                 outsize = srv_set_message(outbuf,12,nread,False);
618                 SSVAL(outbuf,smb_vwv2,0xFFFF); /* Remaining - must be * -1. */
619                 SSVAL(outbuf,smb_vwv5,nread);
620                 SSVAL(outbuf,smb_vwv6,smb_offset(data,outbuf));
621                 SSVAL(outbuf,smb_vwv7,((nread >> 16) & 1));
622                 SSVAL(smb_buf(outbuf),-2,nread);
623
624                 aio_ex->fsp->fh->pos = aio_ex->acb.aio_offset + nread;
625                 aio_ex->fsp->fh->position_information = aio_ex->fsp->fh->pos;
626
627                 DEBUG( 3, ( "handle_aio_read_complete file %s max=%d "
628                             "nread=%d\n",
629                             fsp_str_dbg(aio_ex->fsp),
630                             (int)aio_ex->acb.aio_nbytes, (int)nread ) );
631
632         }
633         smb_setlen(outbuf,outsize - 4);
634         show_msg(outbuf);
635         if (!srv_send_smb(smbd_server_fd(),outbuf,
636                         true, aio_ex->smbreq->seqnum+1,
637                         IS_CONN_ENCRYPTED(aio_ex->fsp->conn), NULL)) {
638                 exit_server_cleanly("handle_aio_read_complete: srv_send_smb "
639                                     "failed.");
640         }
641
642         DEBUG(10,("handle_aio_read_complete: scheduled aio_read completed "
643                   "for file %s, offset %.0f, len = %u\n",
644                   fsp_str_dbg(aio_ex->fsp), (double)aio_ex->acb.aio_offset,
645                   (unsigned int)nread ));
646
647         return errcode;
648 }
649
650 /****************************************************************************
651  Complete the write and return the data or error back to the client.
652  Returns error code or zero if all ok.
653 *****************************************************************************/
654
655 static int handle_aio_write_complete(struct aio_extra *aio_ex, int errcode)
656 {
657         files_struct *fsp = aio_ex->fsp;
658         char *outbuf = (char *)aio_ex->outbuf.data;
659         ssize_t numtowrite = aio_ex->acb.aio_nbytes;
660         ssize_t nwritten = SMB_VFS_AIO_RETURN(fsp,&aio_ex->acb);
661
662         if (fsp->aio_write_behind) {
663                 if (nwritten != numtowrite) {
664                         if (nwritten == -1) {
665                                 DEBUG(5,("handle_aio_write_complete: "
666                                          "aio_write_behind failed ! File %s "
667                                          "is corrupt ! Error %s\n",
668                                          fsp_str_dbg(fsp), strerror(errcode)));
669                         } else {
670                                 DEBUG(0,("handle_aio_write_complete: "
671                                          "aio_write_behind failed ! File %s "
672                                          "is corrupt ! Wanted %u bytes but "
673                                          "only wrote %d\n", fsp_str_dbg(fsp),
674                                          (unsigned int)numtowrite,
675                                          (int)nwritten ));
676                                 errcode = EIO;
677                         }
678                 } else {
679                         DEBUG(10,("handle_aio_write_complete: "
680                                   "aio_write_behind completed for file %s\n",
681                                   fsp_str_dbg(fsp)));
682                 }
683                 /* TODO: should no return 0 in case of an error !!! */
684                 return 0;
685         }
686
687         /* We don't need outsize or set_message here as we've already set the
688            fixed size length when we set up the aio call. */
689
690         if(nwritten == -1) {
691                 DEBUG( 3,( "handle_aio_write: file %s wanted %u bytes. "
692                            "nwritten == %d. Error = %s\n",
693                            fsp_str_dbg(fsp), (unsigned int)numtowrite,
694                            (int)nwritten, strerror(errcode) ));
695
696                 ERROR_NT(map_nt_error_from_unix(errcode));
697                 srv_set_message(outbuf,0,0,true);
698         } else {
699                 NTSTATUS status;
700
701                 SSVAL(outbuf,smb_vwv2,nwritten);
702                 SSVAL(outbuf,smb_vwv4,(nwritten>>16)&1);
703                 if (nwritten < (ssize_t)numtowrite) {
704                         SCVAL(outbuf,smb_rcls,ERRHRD);
705                         SSVAL(outbuf,smb_err,ERRdiskfull);
706                 }
707
708                 DEBUG(3,("handle_aio_write: fnum=%d num=%d wrote=%d\n",
709                          fsp->fnum, (int)numtowrite, (int)nwritten));
710                 status = sync_file(fsp->conn,fsp, aio_ex->write_through);
711                 if (!NT_STATUS_IS_OK(status)) {
712                         errcode = errno;
713                         ERROR_BOTH(map_nt_error_from_unix(errcode),
714                                    ERRHRD, ERRdiskfull);
715                         srv_set_message(outbuf,0,0,true);
716                         DEBUG(5,("handle_aio_write: sync_file for %s returned %s\n",
717                                  fsp_str_dbg(fsp), nt_errstr(status)));
718                 }
719
720                 aio_ex->fsp->fh->pos = aio_ex->acb.aio_offset + nwritten;
721         }
722
723         show_msg(outbuf);
724         if (!srv_send_smb(smbd_server_fd(),outbuf,
725                           true, aio_ex->smbreq->seqnum+1,
726                           IS_CONN_ENCRYPTED(fsp->conn),
727                           NULL)) {
728                 exit_server_cleanly("handle_aio_write_complete: "
729                                     "srv_send_smb failed.");
730         }
731
732         DEBUG(10,("handle_aio_write_complete: scheduled aio_write completed "
733                   "for file %s, offset %.0f, requested %u, written = %u\n",
734                   fsp_str_dbg(fsp), (double)aio_ex->acb.aio_offset,
735                   (unsigned int)numtowrite, (unsigned int)nwritten ));
736
737         return errcode;
738 }
739
740 /****************************************************************************
741  Complete the read and return the data or error back to the client.
742  Returns errno or zero if all ok.
743 *****************************************************************************/
744
745 static int handle_aio_smb2_read_complete(struct aio_extra *aio_ex, int errcode)
746 {
747         NTSTATUS status;
748         struct tevent_req *subreq = aio_ex->smbreq->smb2req->subreq;
749         ssize_t nread = SMB_VFS_AIO_RETURN(aio_ex->fsp,&aio_ex->acb);
750
751         /* Common error or success code processing for async or sync
752            read returns. */
753
754         status = smb2_read_complete(subreq, nread, errcode);
755
756         if (nread > 0) {
757                 aio_ex->fsp->fh->pos = aio_ex->acb.aio_offset + nread;
758                 aio_ex->fsp->fh->position_information = aio_ex->fsp->fh->pos;
759         }
760
761         DEBUG(10,("smb2: scheduled aio_read completed "
762                 "for file %s, offset %.0f, len = %u "
763                 "(errcode = %d, NTSTATUS = %s)\n",
764                 fsp_str_dbg(aio_ex->fsp),
765                 (double)aio_ex->acb.aio_offset,
766                 (unsigned int)nread,
767                 errcode,
768                 nt_errstr(status) ));
769
770         if (!NT_STATUS_IS_OK(status)) {
771                 tevent_req_nterror(subreq, status);
772         }
773
774         tevent_req_done(subreq);
775         return errcode;
776 }
777
778 /****************************************************************************
779  Complete the SMB2 write and return the data or error back to the client.
780  Returns error code or zero if all ok.
781 *****************************************************************************/
782
783 static int handle_aio_smb2_write_complete(struct aio_extra *aio_ex, int errcode)
784 {
785         files_struct *fsp = aio_ex->fsp;
786         ssize_t numtowrite = aio_ex->acb.aio_nbytes;
787         ssize_t nwritten = SMB_VFS_AIO_RETURN(fsp,&aio_ex->acb);
788         struct tevent_req *subreq = aio_ex->smbreq->smb2req->subreq;
789         NTSTATUS status;
790
791         status = smb2_write_complete(subreq, nwritten, errcode);
792
793         DEBUG(10,("smb2: scheduled aio_write completed "
794                 "for file %s, offset %.0f, requested %u, "
795                 "written = %u (errcode = %d, NTSTATUS = %s)\n",
796                 fsp_str_dbg(fsp),
797                 (double)aio_ex->acb.aio_offset,
798                 (unsigned int)numtowrite,
799                 (unsigned int)nwritten,
800                 errcode,
801                 nt_errstr(status) ));
802
803         if (!NT_STATUS_IS_OK(status)) {
804                 tevent_req_nterror(subreq, status);
805         }
806
807         tevent_req_done(subreq);
808         return errcode;
809 }
810
811 /****************************************************************************
812  Handle any aio completion. Returns True if finished (and sets *perr if err
813  was non-zero), False if not.
814 *****************************************************************************/
815
816 static bool handle_aio_completed(struct aio_extra *aio_ex, int *perr)
817 {
818         files_struct *fsp = NULL;
819         int err;
820
821         if(!aio_ex) {
822                 DEBUG(3, ("handle_aio_completed: Non-existing aio_ex passed\n"));
823                 return false;
824         }
825
826         fsp = aio_ex->fsp;
827
828         /* Ensure the operation has really completed. */
829         err = SMB_VFS_AIO_ERROR(fsp, &aio_ex->acb);
830         if (err == EINPROGRESS) {
831                 DEBUG(10,( "handle_aio_completed: operation mid %llu still in "
832                         "process for file %s\n",
833                         (unsigned long long)aio_ex->smbreq->mid,
834                         fsp_str_dbg(aio_ex->fsp)));
835                 return False;
836         }
837
838         /* Unlock now we're done. */
839         SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &aio_ex->lock);
840
841         if (err == ECANCELED) {
842                 /* If error is ECANCELED then don't return anything to the
843                  * client. */
844                 DEBUG(10,( "handle_aio_completed: operation mid %llu"
845                         " canceled\n",
846                         (unsigned long long)aio_ex->smbreq->mid));
847                 return True;
848         }
849
850         err = aio_ex->handle_completion(aio_ex, err);
851         if (err) {
852                 *perr = err; /* Only save non-zero errors. */
853         }
854
855         return True;
856 }
857
858 /****************************************************************************
859  Handle any aio completion inline.
860 *****************************************************************************/
861
862 void smbd_aio_complete_aio_ex(struct aio_extra *aio_ex)
863 {
864         files_struct *fsp = NULL;
865         int ret = 0;
866
867         outstanding_aio_calls--;
868
869         DEBUG(10,("smbd_aio_complete_mid: mid[%llu]\n",
870                 (unsigned long long)aio_ex->smbreq->mid));
871
872         fsp = aio_ex->fsp;
873         if (fsp == NULL) {
874                 /* file was closed whilst I/O was outstanding. Just
875                  * ignore. */
876                 DEBUG( 3,( "smbd_aio_complete_mid: file closed whilst "
877                         "aio outstanding (mid[%llu]).\n",
878                         (unsigned long long)aio_ex->smbreq->mid));
879                 return;
880         }
881
882         if (!handle_aio_completed(aio_ex, &ret)) {
883                 return;
884         }
885
886         TALLOC_FREE(aio_ex);
887 }
888
889 /****************************************************************************
890  We're doing write behind and the client closed the file. Wait up to 30
891  seconds (my arbitrary choice) for the aio to complete. Return 0 if all writes
892  completed, errno to return if not.
893 *****************************************************************************/
894
895 #define SMB_TIME_FOR_AIO_COMPLETE_WAIT 29
896
897 int wait_for_aio_completion(files_struct *fsp)
898 {
899         struct aio_extra *aio_ex;
900         const SMB_STRUCT_AIOCB **aiocb_list;
901         int aio_completion_count = 0;
902         time_t start_time = time(NULL);
903         int seconds_left;
904
905         for (seconds_left = SMB_TIME_FOR_AIO_COMPLETE_WAIT;
906              seconds_left >= 0;) {
907                 int err = 0;
908                 int i;
909                 struct timespec ts;
910
911                 aio_completion_count = 0;
912                 for( aio_ex = aio_list_head; aio_ex; aio_ex = aio_ex->next) {
913                         if (aio_ex->fsp == fsp) {
914                                 aio_completion_count++;
915                         }
916                 }
917
918                 if (!aio_completion_count) {
919                         return 0;
920                 }
921
922                 DEBUG(3,("wait_for_aio_completion: waiting for %d aio events "
923                          "to complete.\n", aio_completion_count ));
924
925                 aiocb_list = SMB_MALLOC_ARRAY(const SMB_STRUCT_AIOCB *,
926                                               aio_completion_count);
927                 if (!aiocb_list) {
928                         return ENOMEM;
929                 }
930
931                 for( i = 0, aio_ex = aio_list_head;
932                      aio_ex;
933                      aio_ex = aio_ex->next) {
934                         if (aio_ex->fsp == fsp) {
935                                 aiocb_list[i++] = &aio_ex->acb;
936                         }
937                 }
938
939                 /* Now wait up to seconds_left for completion. */
940                 ts.tv_sec = seconds_left;
941                 ts.tv_nsec = 0;
942
943                 DEBUG(10,("wait_for_aio_completion: %d events, doing a wait "
944                           "of %d seconds.\n",
945                           aio_completion_count, seconds_left ));
946
947                 err = SMB_VFS_AIO_SUSPEND(fsp, aiocb_list,
948                                           aio_completion_count, &ts);
949
950                 DEBUG(10,("wait_for_aio_completion: returned err = %d, "
951                           "errno = %s\n", err, strerror(errno) ));
952
953                 if (err == -1 && errno == EAGAIN) {
954                         DEBUG(0,("wait_for_aio_completion: aio_suspend timed "
955                                  "out waiting for %d events after a wait of "
956                                  "%d seconds\n", aio_completion_count,
957                                  seconds_left));
958                         /* Timeout. */
959                         cancel_aio_by_fsp(fsp);
960                         SAFE_FREE(aiocb_list);
961                         return EIO;
962                 }
963
964                 /* One or more events might have completed - process them if
965                  * so. */
966                 for( i = 0; i < aio_completion_count; i++) {
967                         aio_ex = (struct aio_extra *)aiocb_list[i]->aio_sigevent.sigev_value.sival_ptr;
968
969                         if (!handle_aio_completed(aio_ex, &err)) {
970                                 continue;
971                         }
972                         TALLOC_FREE(aio_ex);
973                 }
974
975                 SAFE_FREE(aiocb_list);
976                 seconds_left = SMB_TIME_FOR_AIO_COMPLETE_WAIT
977                         - (time(NULL) - start_time);
978         }
979
980         /* We timed out - we don't know why. Return ret if already an error,
981          * else EIO. */
982         DEBUG(10,("wait_for_aio_completion: aio_suspend timed out waiting "
983                   "for %d events\n",
984                   aio_completion_count));
985
986         return EIO;
987 }
988
989 /****************************************************************************
990  Cancel any outstanding aio requests. The client doesn't care about the reply.
991 *****************************************************************************/
992
993 void cancel_aio_by_fsp(files_struct *fsp)
994 {
995         struct aio_extra *aio_ex;
996
997         for( aio_ex = aio_list_head; aio_ex; aio_ex = aio_ex->next) {
998                 if (aio_ex->fsp == fsp) {
999                         /* Unlock now we're done. */
1000                         SMB_VFS_STRICT_UNLOCK(fsp->conn, fsp, &aio_ex->lock);
1001
1002                         /* Don't delete the aio_extra record as we may have
1003                            completed and don't yet know it. Just do the
1004                            aio_cancel call and return. */
1005                         SMB_VFS_AIO_CANCEL(fsp, &aio_ex->acb);
1006                         aio_ex->fsp = NULL; /* fsp will be closed when we
1007                                              * return. */
1008                 }
1009         }
1010 }
1011
1012 #else
1013 NTSTATUS schedule_aio_read_and_X(connection_struct *conn,
1014                              struct smb_request *smbreq,
1015                              files_struct *fsp, SMB_OFF_T startpos,
1016                              size_t smb_maxcnt)
1017 {
1018         return NT_STATUS_RETRY;
1019 }
1020
1021 NTSTATUS schedule_aio_write_and_X(connection_struct *conn,
1022                               struct smb_request *smbreq,
1023                               files_struct *fsp, char *data,
1024                               SMB_OFF_T startpos,
1025                               size_t numtowrite)
1026 {
1027         return NT_STATUS_RETRY;
1028 }
1029
1030 NTSTATUS schedule_smb2_aio_read(connection_struct *conn,
1031                                 struct smb_request *smbreq,
1032                                 files_struct *fsp,
1033                                 char *inbuf,
1034                                 SMB_OFF_T startpos,
1035                                 size_t smb_maxcnt)
1036 {
1037         return NT_STATUS_RETRY;
1038 }
1039
1040 NTSTATUS schedule_aio_smb2_write(connection_struct *conn,
1041                                 struct smb_request *smbreq,
1042                                 files_struct *fsp,
1043                                 uint64_t in_offset,
1044                                 DATA_BLOB in_data,
1045                                 bool write_through)
1046 {
1047         return NT_STATUS_RETRY;
1048 }
1049
1050 void cancel_aio_by_fsp(files_struct *fsp)
1051 {
1052 }
1053
1054 int wait_for_aio_completion(files_struct *fsp)
1055 {
1056         return 0;
1057 }
1058
1059 void smbd_aio_complete_mid(uint64_t mid);
1060
1061 #endif