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 "onefs.h"
  22
  23 #include <ifs/ifs_syscalls.h>
  24 #include <isi_acl/isi_acl_util.h>
  25
  26 /*
  27  * Initialize the sm_lock struct before passing it to ifs_createfile.
  28  */
  29 static void smlock_init(connection_struct *conn, struct sm_lock *sml,
  30     bool isexe, uint32_t access_mask, uint32_t share_access,
  31     uint32_t create_options)
  32 {
  33         sml->sm_type.doc = false;
  34         sml->sm_type.isexe = isexe;
  35         sml->sm_type.statonly = is_stat_open(access_mask);
  36         sml->sm_type.access_mask = access_mask;
  37         sml->sm_type.share_access = share_access;
  38
  39         /*
  40          * private_options was previously used for DENY_DOS/DENY_FCB checks in
  41          * the kernel, but are now properly handled by fcb_or_dos_open. In
  42          * these cases, ifs_createfile will return a sharing violation, which
  43          * gives fcb_or_dos_open the chance to open a duplicate file handle.
  44          */
  45         sml->sm_type.private_options = 0;
  46
  47         /* 1 second delay is handled in onefs_open.c by deferring the open */
  48         sml->sm_timeout = timeval_set(0, 0);
  49 }
  50
  51 static void smlock_dump(int debuglevel, const struct sm_lock *sml)
  52 {
  53         if (sml == NULL) {
  54                 DEBUG(debuglevel, ("sml == NULL\n"));
  55                 return;
  56         }
  57
  58         DEBUG(debuglevel,
  59               ("smlock: doc=%s, isexec=%s, statonly=%s, access_mask=0x%x, "
  60                "share_access=0x%x, private_options=0x%x timeout=%d/%d\n",
  61                sml->sm_type.doc ? "True" : "False",
  62                sml->sm_type.isexe ? "True" : "False",
  63                sml->sm_type.statonly ? "True" : "False",
  64                sml->sm_type.access_mask,
  65                sml->sm_type.share_access,
  66                sml->sm_type.private_options,
  67                (int)sml->sm_timeout.tv_sec,
  68                (int)sml->sm_timeout.tv_usec));
  69 }
  70
  71 /**
  72  * External interface to ifs_createfile
  73  */
  74 int onefs_sys_create_file(connection_struct *conn,
  75                           int base_fd,
  76                           const char *path,
  77                           uint32_t access_mask,
  78                           uint32_t open_access_mask,
  79                           uint32_t share_access,
  80                           uint32_t create_options,
  81                           int flags,
  82                           mode_t mode,
  83                           int oplock_request,
  84                           uint64_t id,
  85                           struct security_descriptor *sd,
  86                           uint32_t dos_flags,
  87                           int *granted_oplock)
  88 {
  89         struct sm_lock sml, *psml = NULL;
  90         enum oplock_type onefs_oplock;
  91         enum oplock_type onefs_granted_oplock = OPLOCK_NONE;
  92         struct ifs_security_descriptor ifs_sd = {}, *pifs_sd = NULL;
  93         int secinfo = 0;
  94         int ret_fd = -1;
  95         uint32_t onefs_dos_attributes;
  96         struct ifs_createfile_flags cf_flags = CF_FLAGS_NONE;
  97
  98         /* Setup security descriptor and get secinfo. */
  99         if (sd != NULL) {
 100                 NTSTATUS status;
 101
 102                 secinfo = (get_sec_info(sd) & IFS_SEC_INFO_KNOWN_MASK);
 103
 104                 status = onefs_samba_sd_to_sd(secinfo, sd, &ifs_sd, SNUM(conn));
 105
 106                 if (!NT_STATUS_IS_OK(status)) {
 107                         DEBUG(1, ("SD initialization failure: %s",
 108                                   nt_errstr(status)));
 109                         errno = EINVAL;
 110                         goto out;
 111                 }
 112
 113                 pifs_sd = &ifs_sd;
 114         }
 115
 116         /* Stripping off private bits will be done for us. */
 117         onefs_oplock = onefs_samba_oplock_to_oplock(oplock_request);
 118
 119         if (!lp_oplocks(SNUM(conn))) {
 120                 SMB_ASSERT(onefs_oplock == OPLOCK_NONE);
 121         }
 122
 123         /* Convert samba dos flags to UF_DOS_* attributes. */
 124         onefs_dos_attributes = dos_attributes_to_stat_dos_flags(dos_flags);
 125
 126         DEBUG(10,("onefs_sys_create_file: base_fd = %d, "
 127                   "open_access_mask = 0x%x, flags = 0x%x, mode = 0x%x, "
 128                   "desired_oplock = %s, id = 0x%x, secinfo = 0x%x, sd = %p, "
 129                   "dos_attributes = 0x%x, path = %s\n", base_fd,
 130                   (unsigned int)open_access_mask,
 131                   (unsigned int)flags,
 132                   (unsigned int)mode,
 133                   onefs_oplock_str(onefs_oplock),
 134                   (unsigned int)id,
 135                   (unsigned int)secinfo, sd,
 136                   (unsigned int)onefs_dos_attributes, path));
 137
 138         /* Initialize smlock struct for files/dirs but not internal opens */
 139         if (!(oplock_request & INTERNAL_OPEN_ONLY)) {
 140                 smlock_init(conn, &sml, is_executable(path), access_mask,
 141                     share_access, create_options);
 142                 psml = &sml;
 143         }
 144
 145         smlock_dump(10, psml);
 146
 147         /**
 148          * Deal with kernel creating Default ACLs. (Isilon bug 47447.)
 149          *
 150          * 1) "nt acl support = no", default_acl = no
 151          * 2) "inherit permissions = yes", default_acl = no
 152          */
 153         if (lp_nt_acl_support(SNUM(conn)) && !lp_inherit_perms(SNUM(conn)))
 154                 cf_flags = cf_flags_or(cf_flags, CF_FLAGS_DEFAULT_ACL);
 155
 156         ret_fd = ifs_createfile(base_fd, path,
 157             (enum ifs_ace_rights)open_access_mask, flags & ~O_ACCMODE, mode,
 158             onefs_oplock, id, psml, secinfo, pifs_sd, onefs_dos_attributes,
 159             cf_flags, &onefs_granted_oplock);
 160
 161         DEBUG(10,("onefs_sys_create_file(%s): ret_fd = %d, "
 162                   "onefs_granted_oplock = %s\n",
 163                   ret_fd < 0 ? strerror(errno) : "success", ret_fd,
 164                   onefs_oplock_str(onefs_granted_oplock)));
 165
 166         if (granted_oplock) {
 167                 *granted_oplock =
 168                     onefs_oplock_to_samba_oplock(onefs_granted_oplock);
 169         }
 170
 171  out:
 172         aclu_free_sd(pifs_sd, false);
 173
 174         return ret_fd;
 175 }
 176
 177 /**
 178  * Only talloc the spill buffer once (reallocing when necessary).
 179  */
 180 static char *get_spill_buffer(size_t new_count)
 181 {
 182         static int cur_count = 0;
 183         static char *spill_buffer = NULL;
 184
 185         /* If a sufficiently sized buffer exists, just return. */
 186         if (new_count <= cur_count) {
 187                 SMB_ASSERT(spill_buffer);
 188                 return spill_buffer;
 189         }
 190
 191         /* Allocate the first time. */
 192         if (cur_count == 0) {
 193                 SMB_ASSERT(!spill_buffer);
 194                 spill_buffer = talloc_array(NULL, char, new_count);
 195                 if (spill_buffer) {
 196                         cur_count = new_count;
 197                 }
 198                 return spill_buffer;
 199         }
 200
 201         /* A buffer exists, but it's not big enough, so realloc. */
 202         SMB_ASSERT(spill_buffer);
 203         spill_buffer = talloc_realloc(NULL, spill_buffer, char, new_count);
 204         if (spill_buffer) {
 205                 cur_count = new_count;
 206         }
 207         return spill_buffer;
 208 }
 209
 210 /**
 211  * recvfile does zero-copy writes given an fd to write to, and a socket with
 212  * some data to write.  If recvfile read more than it was able to write, it
 213  * spills the data into a buffer.  After first reading any additional data
 214  * from the socket into the buffer, the spill buffer is then written with a
 215  * standard pwrite.
 216  */
 217 ssize_t onefs_sys_recvfile(int fromfd, int tofd, SMB_OFF_T offset,
 218                            size_t count)
 219 {
 220         char *spill_buffer = NULL;
 221         bool socket_drained = false;
 222         int ret;
 223         off_t total_rbytes = 0;
 224         off_t total_wbytes = 0;
 225         off_t rbytes;
 226         off_t wbytes;
 227
 228         DEBUG(10,("onefs_recvfile: from = %d, to = %d, offset=%llu, count = "
 229                   "%lu\n", fromfd, tofd, offset, count));
 230
 231         if (count == 0) {
 232                 return 0;
 233         }
 234
 235         /*
 236          * Setup up a buffer for recvfile to spill data that has been read
 237          * from the socket but not written.
 238          */
 239         spill_buffer = get_spill_buffer(count);
 240         if (spill_buffer == NULL) {
 241                 ret = -1;
 242                 goto out;
 243         }
 244
 245         /*
 246          * Keep trying recvfile until:
 247          *  - There is no data left to read on the socket, or
 248          *  - bytes read != bytes written, or
 249          *  - An error is returned that isn't EINTR/EAGAIN
 250          */
 251         do {
 252                 /* Keep track of bytes read/written for recvfile */
 253                 rbytes = 0;
 254                 wbytes = 0;
 255
 256                 DEBUG(10, ("calling recvfile loop, offset + total_wbytes = "
 257                            "%llu, count - total_rbytes = %llu\n",
 258                            offset + total_wbytes, count - total_rbytes));
 259
 260                 ret = recvfile(tofd, fromfd, offset + total_wbytes,
 261                                count - total_wbytes, &rbytes, &wbytes, 0,
 262                                spill_buffer);
 263
 264                 DEBUG(10, ("recvfile ret = %d, errno = %d, rbytes = %llu, "
 265                            "wbytes = %llu\n", ret, ret >= 0 ? 0 : errno,
 266                            rbytes, wbytes));
 267
 268                 /* Update our progress so far */
 269                 total_rbytes += rbytes;
 270                 total_wbytes += wbytes;
 271
 272         } while ((count - total_rbytes) && (rbytes == wbytes) &&
 273                  (ret == -1 && (errno == EINTR || errno == EAGAIN)));
 274
 275         DEBUG(10, ("total_rbytes = %llu, total_wbytes = %llu\n",
 276                    total_rbytes, total_wbytes));
 277
 278         /* Log if recvfile didn't write everything it read. */
 279         if (total_rbytes != total_wbytes) {
 280                 DEBUG(0, ("partial recvfile: total_rbytes=%llu but "
 281                           "total_wbytes=%llu, diff = %llu\n", total_rbytes,
 282                           total_wbytes, total_rbytes - total_wbytes));
 283                 SMB_ASSERT(total_rbytes > total_wbytes);
 284         }
 285
 286         /*
 287          * If there is still data on the socket, read it off.
 288          */
 289         while (total_rbytes < count) {
 290
 291                 DEBUG(0, ("shallow recvfile, reading %llu\n",
 292                           count - total_rbytes));
 293
 294                 /*
 295                  * Read the remaining data into the spill buffer.  recvfile
 296                  * may already have some data in the spill buffer, so start
 297                  * filling the buffer at total_rbytes - total_wbytes.
 298                  */
 299                 ret = sys_read(fromfd,
 300                                spill_buffer + (total_rbytes - total_wbytes),
 301                                count - total_rbytes);
 302
 303                 if (ret == -1) {
 304                         DEBUG(0, ("shallow recvfile read failed: %s\n",
 305                                   strerror(errno)));
 306                         /* Socket is dead, so treat as if it were drained. */
 307                         socket_drained = true;
 308                         goto out;
 309                 }
 310
 311                 /* Data was read so update the rbytes */
 312                 total_rbytes += ret;
 313         }
 314
 315         if (total_rbytes != count) {
 316                 smb_panic("Unread recvfile data still on the socket!");
 317         }
 318
 319         /*
 320          * Now write any spilled data + the extra data read off the socket.
 321          */
 322         while (total_wbytes < count) {
 323
 324                 DEBUG(0, ("partial recvfile, writing %llu\n", count - total_wbytes));
 325
 326                 ret = sys_pwrite(tofd, spill_buffer, count - total_wbytes,
 327                                  offset + total_wbytes);
 328
 329                 if (ret == -1) {
 330                         DEBUG(0, ("partial recvfile write failed: %s\n",
 331                                   strerror(errno)));
 332                         goto out;
 333                 }
 334
 335                 /* Data was written so update the wbytes */
 336                 total_wbytes += ret;
 337         }
 338
 339         /* Success! */
 340         ret = total_wbytes;
 341
 342 out:
 343         /* Make sure we always try to drain the socket. */
 344         if (!socket_drained && count - total_rbytes) {
 345                 int saved_errno = errno;
 346
 347                 if (drain_socket(fromfd, count - total_rbytes) !=
 348                     count - total_rbytes) {
 349                         /* Socket is dead! */
 350                         DEBUG(0, ("drain socket failed: %d\n", errno));
 351                 }
 352                 errno = saved_errno;
 353         }
 354
 355         return ret;
 356 }