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