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