build: ensure compiler flags are properly detected
[samba.git] / source3 / modules / onefs_system.c
1 /*
2  * Unix SMB/CIFS implementation.
3  * Support for OneFS system interfaces.
4  *
5  * Copyright (C) Tim Prouty, 2008
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 "onefs.h"
23 #include "onefs_config.h"
24 #include "oplock_onefs.h"
25
26 #include <ifs/ifs_syscalls.h>
27 #include <isi_acl/isi_acl_util.h>
28 #include <sys/isi_acl.h>
29
30 /*
31  * Initialize the sm_lock struct before passing it to ifs_createfile.
32  */
33 static void smlock_init(connection_struct *conn, struct sm_lock *sml,
34     bool isexe, uint32_t access_mask, uint32_t share_access,
35     uint32_t create_options)
36 {
37         sml->sm_type.doc = false;
38         sml->sm_type.isexe = isexe;
39         sml->sm_type.statonly = is_stat_open(access_mask);
40         sml->sm_type.access_mask = access_mask;
41         sml->sm_type.share_access = share_access;
42
43         /*
44          * private_options was previously used for DENY_DOS/DENY_FCB checks in
45          * the kernel, but are now properly handled by fcb_or_dos_open. In
46          * these cases, ifs_createfile will return a sharing violation, which
47          * gives fcb_or_dos_open the chance to open a duplicate file handle.
48          */
49         sml->sm_type.private_options = 0;
50
51         /* 1 second delay is handled in onefs_open.c by deferring the open */
52         sml->sm_timeout = timeval_set(0, 0);
53 }
54
55 static void smlock_dump(int debuglevel, const struct sm_lock *sml)
56 {
57         if (sml == NULL) {
58                 DEBUG(debuglevel, ("sml == NULL\n"));
59                 return;
60         }
61
62         DEBUG(debuglevel,
63               ("smlock: doc=%s, isexec=%s, statonly=%s, access_mask=0x%x, "
64                "share_access=0x%x, private_options=0x%x timeout=%d/%d\n",
65                sml->sm_type.doc ? "True" : "False",
66                sml->sm_type.isexe ? "True" : "False",
67                sml->sm_type.statonly ? "True" : "False",
68                sml->sm_type.access_mask,
69                sml->sm_type.share_access,
70                sml->sm_type.private_options,
71                (int)sml->sm_timeout.tv_sec,
72                (int)sml->sm_timeout.tv_usec));
73 }
74
75 /**
76  * External interface to ifs_createfile
77  */
78 int onefs_sys_create_file(connection_struct *conn,
79                           int base_fd,
80                           const char *path,
81                           uint32_t access_mask,
82                           uint32_t open_access_mask,
83                           uint32_t share_access,
84                           uint32_t create_options,
85                           int flags,
86                           mode_t mode,
87                           int oplock_request,
88                           uint64_t id,
89                           struct security_descriptor *sd,
90                           uint32_t dos_flags,
91                           int *granted_oplock)
92 {
93         struct sm_lock sml, *psml = NULL;
94         enum oplock_type onefs_oplock;
95         enum oplock_type onefs_granted_oplock = OPLOCK_NONE;
96         struct ifs_security_descriptor ifs_sd = {}, *pifs_sd = NULL;
97         uint32_t sec_info_effective = 0;
98         int ret_fd = -1;
99         uint32_t onefs_dos_attributes;
100         struct ifs_createfile_flags cf_flags = CF_FLAGS_NONE;
101         char *mapped_name = NULL;
102         NTSTATUS result;
103
104         START_PROFILE(syscall_createfile);
105
106         /* Translate the name to UNIX before calling ifs_createfile */
107         mapped_name = talloc_strdup(talloc_tos(), path);
108         if (mapped_name == NULL) {
109                 errno = ENOMEM;
110                 goto out;
111         }
112         result = SMB_VFS_TRANSLATE_NAME(conn, &mapped_name,
113                                         vfs_translate_to_unix);
114         if (!NT_STATUS_IS_OK(result)) {
115                 goto out;
116         }
117
118         /* Setup security descriptor and get secinfo. */
119         if (sd != NULL) {
120                 NTSTATUS status;
121                 uint32_t sec_info_sent = 0;
122
123                 sec_info_sent = (get_sec_info(sd) & IFS_SEC_INFO_KNOWN_MASK);
124
125                 status = onefs_samba_sd_to_sd(sec_info_sent, sd, &ifs_sd,
126                                               SNUM(conn), &sec_info_effective);
127
128                 if (!NT_STATUS_IS_OK(status)) {
129                         DEBUG(1, ("SD initialization failure: %s\n",
130                                   nt_errstr(status)));
131                         errno = EINVAL;
132                         goto out;
133                 }
134
135                 pifs_sd = &ifs_sd;
136         }
137
138         /* Stripping off private bits will be done for us. */
139         onefs_oplock = onefs_samba_oplock_to_oplock(oplock_request);
140
141         if (!lp_oplocks(SNUM(conn))) {
142                 SMB_ASSERT(onefs_oplock == OPLOCK_NONE);
143         }
144
145         /* Convert samba dos flags to UF_DOS_* attributes. */
146         onefs_dos_attributes = dos_attributes_to_stat_dos_flags(dos_flags);
147
148         /**
149          * Deal with kernel creating Default ACLs. (Isilon bug 47447.)
150          *
151          * 1) "nt acl support = no", default_acl = no
152          * 2) "inherit permissions = yes", default_acl = no
153          */
154         if (lp_nt_acl_support(SNUM(conn)) && !lp_inherit_perms(SNUM(conn)))
155                 cf_flags = cf_flags_or(cf_flags, CF_FLAGS_DEFAULT_ACL);
156
157         /*
158          * Some customer workflows require the execute bit to be ignored.
159          */
160         if (lp_parm_bool(SNUM(conn), PARM_ONEFS_TYPE,
161                          PARM_ALLOW_EXECUTE_ALWAYS,
162                          PARM_ALLOW_EXECUTE_ALWAYS_DEFAULT) &&
163             (open_access_mask & FILE_EXECUTE)) {
164
165                 DEBUG(3, ("Stripping execute bit from %s: (0x%x)\n", mapped_name,
166                           open_access_mask));
167
168                 /* Strip execute. */
169                 open_access_mask &= ~FILE_EXECUTE;
170
171                 /*
172                  * Add READ_DATA, so we're not left with desired_access=0. An
173                  * execute call should imply the client will read the data.
174                  */
175                 open_access_mask |= FILE_READ_DATA;
176
177                 DEBUGADD(3, ("New stripped access mask: 0x%x\n",
178                              open_access_mask));
179         }
180
181         DEBUG(10,("onefs_sys_create_file: base_fd = %d, fname = %s "
182                   "open_access_mask = 0x%x, flags = 0x%x, mode = 0%o, "
183                   "desired_oplock = %s, id = 0x%x, secinfo = 0x%x, sd = %p, "
184                   "dos_attributes = 0x%x, path = %s, "
185                   "default_acl=%s\n", base_fd, mapped_name,
186                   (unsigned int)open_access_mask,
187                   (unsigned int)flags,
188                   (unsigned int)mode,
189                   onefs_oplock_str(onefs_oplock),
190                   (unsigned int)id,
191                   sec_info_effective, sd,
192                   (unsigned int)onefs_dos_attributes, mapped_name,
193                   cf_flags_and_bool(cf_flags, CF_FLAGS_DEFAULT_ACL) ?
194                       "true" : "false"));
195
196         /* Initialize smlock struct for files/dirs but not internal opens */
197         if (!(oplock_request & INTERNAL_OPEN_ONLY)) {
198                 smlock_init(conn, &sml, is_executable(mapped_name), access_mask,
199                     share_access, create_options);
200                 psml = &sml;
201         }
202
203         smlock_dump(10, psml);
204
205         ret_fd = ifs_createfile(base_fd, mapped_name,
206             (enum ifs_ace_rights)open_access_mask, flags & ~O_ACCMODE, mode,
207             onefs_oplock, id, psml, sec_info_effective, pifs_sd,
208             onefs_dos_attributes, cf_flags, &onefs_granted_oplock);
209
210         DEBUG(10,("onefs_sys_create_file(%s): ret_fd = %d, "
211                   "onefs_granted_oplock = %s\n",
212                   ret_fd < 0 ? strerror(errno) : "success", ret_fd,
213                   onefs_oplock_str(onefs_granted_oplock)));
214
215         if (granted_oplock) {
216                 *granted_oplock =
217                     onefs_oplock_to_samba_oplock(onefs_granted_oplock);
218         }
219
220  out:
221         END_PROFILE(syscall_createfile);
222         aclu_free_sd(pifs_sd, false);
223         TALLOC_FREE(mapped_name);
224
225         return ret_fd;
226 }
227
228 /**
229  * FreeBSD based sendfile implementation that allows for atomic semantics.
230  */
231 static ssize_t onefs_sys_do_sendfile(int tofd, int fromfd,
232     const DATA_BLOB *header, SMB_OFF_T offset, size_t count, bool atomic)
233 {
234         size_t total=0;
235         struct sf_hdtr hdr;
236         struct iovec hdtrl;
237         size_t hdr_len = 0;
238         int flags = 0;
239
240         if (atomic) {
241                 flags = SF_ATOMIC;
242         }
243
244         hdr.headers = &hdtrl;
245         hdr.hdr_cnt = 1;
246         hdr.trailers = NULL;
247         hdr.trl_cnt = 0;
248
249         /* Set up the header iovec. */
250         if (header) {
251                 hdtrl.iov_base = (void *)header->data;
252                 hdtrl.iov_len = hdr_len = header->length;
253         } else {
254                 hdtrl.iov_base = NULL;
255                 hdtrl.iov_len = 0;
256         }
257
258         total = count;
259         while (total + hdtrl.iov_len) {
260                 SMB_OFF_T nwritten;
261                 int ret;
262
263                 /*
264                  * FreeBSD sendfile returns 0 on success, -1 on error.
265                  * Remember, the tofd and fromfd are reversed..... :-).
266                  * nwritten includes the header data sent.
267                  */
268
269                 do {
270                         ret = sendfile(fromfd, tofd, offset, total, &hdr,
271                                        &nwritten, flags);
272 #if defined(EWOULDBLOCK)
273                 } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
274 #else
275                 } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
276 #endif
277
278                 /* On error we're done. */
279                 if (ret == -1) {
280                         return -1;
281                 }
282
283                 /*
284                  * If this was an ATOMIC sendfile, nwritten doesn't
285                  * necessarily indicate an error.  It could mean count > than
286                  * what sendfile can handle atomically (usually 64K) or that
287                  * there was a short read due to the file being truncated.
288                  */
289                 if (nwritten == 0) {
290                         return atomic ? 0 : -1;
291                 }
292
293                 /*
294                  * An atomic sendfile should never send partial data!
295                  */
296                 if (atomic && nwritten != total + hdtrl.iov_len) {
297                         DEBUG(0,("Atomic sendfile() sent partial data: "
298                                  "%llu of %d\n", nwritten,
299                                  total + hdtrl.iov_len));
300                         return -1;
301                 }
302
303                 /*
304                  * If this was a short (signal interrupted) write we may need
305                  * to subtract it from the header data, or null out the header
306                  * data altogether if we wrote more than hdtrl.iov_len bytes.
307                  * We change nwritten to be the number of file bytes written.
308                  */
309
310                 if (hdtrl.iov_base && hdtrl.iov_len) {
311                         if (nwritten >= hdtrl.iov_len) {
312                                 nwritten -= hdtrl.iov_len;
313                                 hdtrl.iov_base = NULL;
314                                 hdtrl.iov_len = 0;
315                         } else {
316                                 hdtrl.iov_base =
317                                     (void *)((caddr_t)hdtrl.iov_base + nwritten);
318                                 hdtrl.iov_len -= nwritten;
319                                 nwritten = 0;
320                         }
321                 }
322                 total -= nwritten;
323                 offset += nwritten;
324         }
325         return count + hdr_len;
326 }
327
328 /**
329  * Handles the subtleties of using sendfile with CIFS.
330  */
331 ssize_t onefs_sys_sendfile(connection_struct *conn, int tofd, int fromfd,
332                            const DATA_BLOB *header, SMB_OFF_T offset,
333                            size_t count)
334 {
335         bool atomic = false;
336         ssize_t ret = 0;
337
338         START_PROFILE_BYTES(syscall_sendfile, count);
339
340         if (lp_parm_bool(SNUM(conn), PARM_ONEFS_TYPE,
341                          PARM_ATOMIC_SENDFILE,
342                          PARM_ATOMIC_SENDFILE_DEFAULT)) {
343                 atomic = true;
344         }
345
346         /* Try the sendfile */
347         ret = onefs_sys_do_sendfile(tofd, fromfd, header, offset, count,
348                                     atomic);
349
350         /* If the sendfile wasn't atomic, we're done. */
351         if (!atomic) {
352                 DEBUG(10, ("non-atomic sendfile read %ul bytes\n", ret));
353                 END_PROFILE(syscall_sendfile);
354                 return ret;
355         }
356
357         /*
358          * Atomic sendfile takes care to not write anything to the socket
359          * until all of the requested bytes have been read from the file.
360          * There are two atomic cases that need to be handled.
361          *
362          *  1. The file was truncated causing less data to be read than was
363          *     requested.  In this case, we return back to the caller to
364          *     indicate 0 bytes were written to the socket.  This should
365          *     prompt the caller to fallback to the standard read path: read
366          *     the data, create a header that indicates how many bytes were
367          *     actually read, and send the header/data back to the client.
368          *
369          *     This saves us from standard sendfile behavior of sending a
370          *     header promising more data then will actually be sent.  The
371          *     only two options are to close the socket and kill the client
372          *     connection, or write a bunch of 0s.  Closing the client
373          *     connection is bad because there could actually be multiple
374          *     sessions multiplexed from the same client that are all dropped
375          *     because of a truncate.  Writing the remaining data as 0s also
376          *     isn't good, because the client will have an incorrect version
377          *     of the file.  If the file is written back to the server, the 0s
378          *     will be written back.  Fortunately, atomic sendfile allows us
379          *     to avoid making this choice in most cases.
380          *
381          *  2. One downside of atomic sendfile, is that there is a limit on
382          *     the number of bytes that can be sent atomically.  The kernel
383          *     has a limited amount of mbuf space that it can read file data
384          *     into without exhausting the system's mbufs, so a buffer of
385          *     length xfsize is used.  The xfsize at the time of writing this
386          *     is 64K.  xfsize bytes are read from the file, and subsequently
387          *     written to the socket.  This makes it impossible to do the
388          *     sendfile atomically for a byte count > xfsize.
389          *
390          *     To cope with large requests, atomic sendfile returns -1 with
391          *     errno set to E2BIG.  Since windows maxes out at 64K writes,
392          *     this is currently only a concern with non-windows clients.
393          *     Posix extensions allow the full 24bit bytecount field to be
394          *     used in ReadAndX, and clients such as smbclient and the linux
395          *     cifs client can request up to 16MB reads!  There are a few
396          *     options for handling large sendfile requests.
397          *
398          *      a. Fall back to the standard read path.  This is unacceptable
399          *         because it would require prohibitively large mallocs.
400          *
401          *      b. Fall back to using samba's fake_send_file which emulates
402          *         the kernel sendfile in userspace.  This still has the same
403          *         problem of sending the header before all of the data has
404          *         been read, so it doesn't buy us anything, and has worse
405          *         performance than the kernel's zero-copy sendfile.
406          *
407          *      c. Use non-atomic sendfile syscall to attempt a zero copy
408          *         read, and hope that there isn't a short read due to
409          *         truncation.  In the case of a short read, there are two
410          *         options:
411          *
412          *          1. Kill the client connection
413          *
414          *          2. Write zeros to the socket for the remaining bytes
415          *             promised in the header.
416          *
417          *         It is safer from a data corruption perspective to kill the
418          *         client connection, so this is our default behavior, but if
419          *         this causes problems this can be configured to write zeros
420          *         via smb.conf.
421          */
422
423         /* Handle case 1: short read -> truncated file. */
424         if (ret == 0) {
425                 END_PROFILE(syscall_sendfile);
426                 return ret;
427         }
428
429         /* Handle case 2: large read. */
430         if (ret == -1 && errno == E2BIG) {
431
432                 if (!lp_parm_bool(SNUM(conn), PARM_ONEFS_TYPE,
433                                  PARM_SENDFILE_LARGE_READS,
434                                  PARM_SENDFILE_LARGE_READS_DEFAULT)) {
435                         DEBUG(3, ("Not attempting non-atomic large sendfile: "
436                                   "%lu bytes\n", count));
437                         END_PROFILE(syscall_sendfile);
438                         return 0;
439                 }
440
441                 if (count < 0x10000) {
442                         DEBUG(0, ("Count < 2^16 and E2BIG was returned! %lu\n",
443                                   count));
444                 }
445
446                 DEBUG(10, ("attempting non-atomic large sendfile: %lu bytes\n",
447                            count));
448
449                 /* Try a non-atomic sendfile. */
450                 ret = onefs_sys_do_sendfile(tofd, fromfd, header, offset,
451                                             count, false);
452                 /* Real error: kill the client connection. */
453                 if (ret == -1) {
454                         DEBUG(1, ("error on non-atomic large sendfile "
455                                   "(%lu bytes): %s\n", count,
456                                   strerror(errno)));
457                         END_PROFILE(syscall_sendfile);
458                         return ret;
459                 }
460
461                 /* Short read: kill the client connection. */
462                 if (ret != count + header->length) {
463                         DEBUG(1, ("short read on non-atomic large sendfile "
464                                   "(%lu of %lu bytes): %s\n", ret, count,
465                                   strerror(errno)));
466
467                         /*
468                          * Returning ret here would cause us to drop into the
469                          * codepath that calls sendfile_short_send, which
470                          * sends the client a bunch of zeros instead.
471                          * Returning -1 kills the connection.
472                          */
473                         if (lp_parm_bool(SNUM(conn), PARM_ONEFS_TYPE,
474                                 PARM_SENDFILE_SAFE,
475                                 PARM_SENDFILE_SAFE_DEFAULT)) {
476                                 END_PROFILE(syscall_sendfile);
477                                 return -1;
478                         }
479
480                         END_PROFILE(syscall_sendfile);
481                         return ret;
482                 }
483
484                 DEBUG(10, ("non-atomic large sendfile successful\n"));
485         }
486
487         /* There was error in the atomic sendfile. */
488         if (ret == -1) {
489                 DEBUG(1, ("error on %s sendfile (%lu bytes): %s\n",
490                           atomic ? "atomic" : "non-atomic",
491                           count, strerror(errno)));
492         }
493
494         END_PROFILE(syscall_sendfile);
495         return ret;
496 }
497
498 /**
499  * Only talloc the spill buffer once (reallocing when necessary).
500  */
501 static char *get_spill_buffer(size_t new_count)
502 {
503         static int cur_count = 0;
504         static char *spill_buffer = NULL;
505
506         /* If a sufficiently sized buffer exists, just return. */
507         if (new_count <= cur_count) {
508                 SMB_ASSERT(spill_buffer);
509                 return spill_buffer;
510         }
511
512         /* Allocate the first time. */
513         if (cur_count == 0) {
514                 SMB_ASSERT(!spill_buffer);
515                 spill_buffer = talloc_array(NULL, char, new_count);
516                 if (spill_buffer) {
517                         cur_count = new_count;
518                 }
519                 return spill_buffer;
520         }
521
522         /* A buffer exists, but it's not big enough, so realloc. */
523         SMB_ASSERT(spill_buffer);
524         spill_buffer = talloc_realloc(NULL, spill_buffer, char, new_count);
525         if (spill_buffer) {
526                 cur_count = new_count;
527         }
528         return spill_buffer;
529 }
530
531 /**
532  * recvfile does zero-copy writes given an fd to write to, and a socket with
533  * some data to write.  If recvfile read more than it was able to write, it
534  * spills the data into a buffer.  After first reading any additional data
535  * from the socket into the buffer, the spill buffer is then written with a
536  * standard pwrite.
537  */
538 ssize_t onefs_sys_recvfile(int fromfd, int tofd, SMB_OFF_T offset,
539                            size_t count)
540 {
541         char *spill_buffer = NULL;
542         bool socket_drained = false;
543         int ret;
544         off_t total_rbytes = 0;
545         off_t total_wbytes = 0;
546         off_t rbytes;
547         off_t wbytes;
548
549         START_PROFILE_BYTES(syscall_recvfile, count);
550
551         DEBUG(10,("onefs_recvfile: from = %d, to = %d, offset=%llu, count = "
552                   "%lu\n", fromfd, tofd, offset, count));
553
554         if (count == 0) {
555                 END_PROFILE(syscall_recvfile);
556                 return 0;
557         }
558
559         /*
560          * Setup up a buffer for recvfile to spill data that has been read
561          * from the socket but not written.
562          */
563         spill_buffer = get_spill_buffer(count);
564         if (spill_buffer == NULL) {
565                 ret = -1;
566                 goto out;
567         }
568
569         /*
570          * Keep trying recvfile until:
571          *  - There is no data left to read on the socket, or
572          *  - bytes read != bytes written, or
573          *  - An error is returned that isn't EINTR/EAGAIN
574          */
575         do {
576                 /* Keep track of bytes read/written for recvfile */
577                 rbytes = 0;
578                 wbytes = 0;
579
580                 DEBUG(10, ("calling recvfile loop, offset + total_wbytes = "
581                            "%llu, count - total_rbytes = %llu\n",
582                            offset + total_wbytes, count - total_rbytes));
583
584                 ret = recvfile(tofd, fromfd, offset + total_wbytes,
585                                count - total_wbytes, &rbytes, &wbytes, 0,
586                                spill_buffer);
587
588                 DEBUG(10, ("recvfile ret = %d, errno = %d, rbytes = %llu, "
589                            "wbytes = %llu\n", ret, ret >= 0 ? 0 : errno,
590                            rbytes, wbytes));
591
592                 /* Update our progress so far */
593                 total_rbytes += rbytes;
594                 total_wbytes += wbytes;
595
596         } while ((count - total_rbytes) && (rbytes == wbytes) &&
597                  (ret == -1 && (errno == EINTR || errno == EAGAIN)));
598
599         DEBUG(10, ("total_rbytes = %llu, total_wbytes = %llu\n",
600                    total_rbytes, total_wbytes));
601
602         /* Log if recvfile didn't write everything it read. */
603         if (total_rbytes != total_wbytes) {
604                 DEBUG(3, ("partial recvfile: total_rbytes=%llu but "
605                           "total_wbytes=%llu, diff = %llu\n", total_rbytes,
606                           total_wbytes, total_rbytes - total_wbytes));
607                 SMB_ASSERT(total_rbytes > total_wbytes);
608         }
609
610         /*
611          * If there is still data on the socket, read it off.
612          */
613         while (total_rbytes < count) {
614
615                 DEBUG(3, ("shallow recvfile (%s), reading %llu\n",
616                           strerror(errno), count - total_rbytes));
617
618                 /*
619                  * Read the remaining data into the spill buffer.  recvfile
620                  * may already have some data in the spill buffer, so start
621                  * filling the buffer at total_rbytes - total_wbytes.
622                  */
623                 ret = sys_read(fromfd,
624                                spill_buffer + (total_rbytes - total_wbytes),
625                                count - total_rbytes);
626
627                 if (ret <= 0) {
628                         if (ret == 0) {
629                                 DEBUG(0, ("shallow recvfile read: EOF\n"));
630                         } else {
631                                 DEBUG(0, ("shallow recvfile read failed: %s\n",
632                                           strerror(errno)));
633                         }
634                         /* Socket is dead, so treat as if it were drained. */
635                         socket_drained = true;
636                         goto out;
637                 }
638
639                 /* Data was read so update the rbytes */
640                 total_rbytes += ret;
641         }
642
643         if (total_rbytes != count) {
644                 smb_panic("Unread recvfile data still on the socket!");
645         }
646
647         /*
648          * Now write any spilled data + the extra data read off the socket.
649          */
650         while (total_wbytes < count) {
651
652                 DEBUG(3, ("partial recvfile, writing %llu\n", count - total_wbytes));
653
654                 ret = sys_pwrite(tofd, spill_buffer, count - total_wbytes,
655                                  offset + total_wbytes);
656
657                 if (ret == -1) {
658                         DEBUG(0, ("partial recvfile write failed: %s\n",
659                                   strerror(errno)));
660                         goto out;
661                 }
662
663                 /* Data was written so update the wbytes */
664                 total_wbytes += ret;
665         }
666
667         /* Success! */
668         ret = total_wbytes;
669
670 out:
671
672         END_PROFILE(syscall_recvfile);
673
674         /* Make sure we always try to drain the socket. */
675         if (!socket_drained && count - total_rbytes) {
676                 int saved_errno = errno;
677
678                 if (drain_socket(fromfd, count - total_rbytes) !=
679                     count - total_rbytes) {
680                         /* Socket is dead! */
681                         DEBUG(0, ("drain socket failed: %d\n", errno));
682                 }
683                 errno = saved_errno;
684         }
685
686         return ret;
687 }
688
689 void init_stat_ex_from_onefs_stat(struct stat_ex *dst, const struct stat *src)
690 {
691         ZERO_STRUCT(*dst);
692
693         dst->st_ex_dev = src->st_dev;
694         dst->st_ex_ino = src->st_ino;
695         dst->st_ex_mode = src->st_mode;
696         dst->st_ex_nlink = src->st_nlink;
697         dst->st_ex_uid = src->st_uid;
698         dst->st_ex_gid = src->st_gid;
699         dst->st_ex_rdev = src->st_rdev;
700         dst->st_ex_size = src->st_size;
701         dst->st_ex_atime = src->st_atimespec;
702         dst->st_ex_mtime = src->st_mtimespec;
703         dst->st_ex_ctime = src->st_ctimespec;
704         dst->st_ex_btime = src->st_birthtimespec;
705         dst->st_ex_blksize = src->st_blksize;
706         dst->st_ex_blocks = src->st_blocks;
707
708         dst->st_ex_flags = src->st_flags;
709
710         dst->vfs_private = src->st_snapid;
711 }
712
713 int onefs_sys_stat(const char *fname, SMB_STRUCT_STAT *sbuf)
714 {
715         int ret;
716         struct stat onefs_sbuf;
717
718         ret = stat(fname, &onefs_sbuf);
719
720         if (ret == 0) {
721                 /* we always want directories to appear zero size */
722                 if (S_ISDIR(onefs_sbuf.st_mode)) {
723                         onefs_sbuf.st_size = 0;
724                 }
725                 init_stat_ex_from_onefs_stat(sbuf, &onefs_sbuf);
726         }
727         return ret;
728 }
729
730 int onefs_sys_fstat(int fd, SMB_STRUCT_STAT *sbuf)
731 {
732         int ret;
733         struct stat onefs_sbuf;
734
735         ret = fstat(fd, &onefs_sbuf);
736
737         if (ret == 0) {
738                 /* we always want directories to appear zero size */
739                 if (S_ISDIR(onefs_sbuf.st_mode)) {
740                         onefs_sbuf.st_size = 0;
741                 }
742                 init_stat_ex_from_onefs_stat(sbuf, &onefs_sbuf);
743         }
744         return ret;
745 }
746
747 int onefs_sys_fstat_at(int base_fd, const char *fname, SMB_STRUCT_STAT *sbuf,
748                        int flags)
749 {
750         int ret;
751         struct stat onefs_sbuf;
752
753         ret = enc_fstatat(base_fd, fname, ENC_DEFAULT, &onefs_sbuf, flags);
754
755         if (ret == 0) {
756                 /* we always want directories to appear zero size */
757                 if (S_ISDIR(onefs_sbuf.st_mode)) {
758                         onefs_sbuf.st_size = 0;
759                 }
760                 init_stat_ex_from_onefs_stat(sbuf, &onefs_sbuf);
761         }
762         return ret;
763 }
764
765 int onefs_sys_lstat(const char *fname, SMB_STRUCT_STAT *sbuf)
766 {
767         int ret;
768         struct stat onefs_sbuf;
769
770         ret = lstat(fname, &onefs_sbuf);
771
772         if (ret == 0) {
773                 /* we always want directories to appear zero size */
774                 if (S_ISDIR(onefs_sbuf.st_mode)) {
775                         onefs_sbuf.st_size = 0;
776                 }
777                 init_stat_ex_from_onefs_stat(sbuf, &onefs_sbuf);
778         }
779         return ret;
780 }
781