s3-vfs: Use the system. namespace for fake ACLs

[kai/samba.git] / source3 / modules / vfs_prealloc.c

diff --git a/source3/modules/vfs_prealloc.c b/source3/modules/vfs_prealloc.c
index 2d64bc0184ded75357642f30c1881eb52e983fe4..4ba27a6c8508cfb88c28622e8953e2e9c476bf02 100644 (file)
--- a/source3/modules/vfs_prealloc.c
+++ b/source3/modules/vfs_prealloc.c
@@ -18,6 +18,8 @@
  */
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 
 /* Extent preallocation module.
  *
@@ -47,13 +49,18 @@
 #define lock_type struct flock64
 #endif
 
+#ifdef HAVE_GPFS
+#include "gpfs_gpl.h"
+#endif
+
 #define MODULE "prealloc"
 static int module_debug;
 
-static int preallocate_space(int fd, SMB_OFF_T size)
+static int preallocate_space(int fd, off_t size)
 {
-       lock_type fl = {0};
        int err;
+#ifndef HAVE_GPFS
+       lock_type fl = {0};
 
        if (size <= 0) {
                return 0;
@@ -78,6 +85,9 @@ static int preallocate_space(int fd, SMB_OFF_T size)
        err = -1;
        errno = ENOSYS;
 #endif
+#else /* GPFS uses completely different interface */
+       err = gpfs_prealloc(fd, (gpfs_off64_t)0, (gpfs_off64_t)size);
+#endif
 
        if (err) {
                DEBUG(module_debug,
@@ -93,20 +103,26 @@ static int prealloc_connect(
                 const char *                service,
                 const char *                user)
 {
-           module_debug = lp_parm_int(SNUM(handle->conn),
+       int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
+
+       if (ret < 0) {
+               return ret;
+       }
+
+       module_debug = lp_parm_int(SNUM(handle->conn),
                                        MODULE, "debug", 100);
 
-           return SMB_VFS_NEXT_CONNECT(handle, service, user);
+       return 0;
 }
 
 static int prealloc_open(vfs_handle_struct* handle,
-                       const char *        fname,
+                       struct smb_filename *smb_fname,
                        files_struct *      fsp,
                        int                 flags,
                        mode_t              mode)
 {
        int fd;
-       off64_t size = 0;
+       off_t size = 0;
 
        const char * dot;
        char fext[10];
@@ -119,11 +135,13 @@ static int prealloc_open(vfs_handle_struct* handle,
        }
 
        *fext = '\0';
-       dot = strrchr(fname, '.');
+       dot = strrchr(smb_fname->base_name, '.');
        if (dot && *++dot) {
                if (strlen(dot) < sizeof(fext)) {
                        strncpy(fext, dot, sizeof(fext));
-                       strnorm(fext, CASE_LOWER);
+                       if (!strnorm(fext, CASE_LOWER)) {
+                               goto normal_open;
+                       }
                }
        }
 
@@ -144,7 +162,7 @@ static int prealloc_open(vfs_handle_struct* handle,
                goto normal_open;
        }
 
-       fd = SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
+       fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
        if (fd < 0) {
                return fd;
        }
@@ -154,16 +172,17 @@ static int prealloc_open(vfs_handle_struct* handle,
         * truncate calls specially.
         */
        if ((flags & O_CREAT) || (flags & O_TRUNC)) {
-               SMB_OFF_T * psize;
+               off_t * psize;
 
-               psize = VFS_ADD_FSP_EXTENSION(handle, fsp, SMB_OFF_T);
+               psize = VFS_ADD_FSP_EXTENSION(handle, fsp, off_t, NULL);
                if (psize == NULL || *psize == -1) {
                        return fd;
                }
 
                DEBUG(module_debug,
                        ("%s: preallocating %s (fd=%d) to %lld bytes\n",
-                       MODULE, fname, fd, (long long)size));
+                           MODULE, smb_fname_str_dbg(smb_fname), fd,
+                           (long long)size));
 
                *psize = size;
                if (preallocate_space(fd, *psize) < 0) {
@@ -178,36 +197,34 @@ normal_open:
         * preallocation.
         */
        DEBUG(module_debug, ("%s: skipping preallocation for %s\n",
-                   MODULE, fname));
-       return SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
+               MODULE, smb_fname_str_dbg(smb_fname)));
+       return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 }
 
 static int prealloc_ftruncate(vfs_handle_struct * handle,
                        files_struct *  fsp,
-                       SMB_OFF_T       offset)
+                       off_t   offset)
 {
-       SMB_OFF_T *psize;
+       off_t *psize;
        int ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
 
        /* Maintain the allocated space even in the face of truncates. */
        if ((psize = VFS_FETCH_FSP_EXTENSION(handle, fsp))) {
-               preallocate_space(fd, *psize);
+               preallocate_space(fsp->fh->fd, *psize);
        }
 
        return ret;
 }
 
-static vfs_op_tuple prealloc_op_tuples[] = {
-       {SMB_VFS_OP(prealloc_open), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT},
-       {SMB_VFS_OP(prealloc_ftruncate), SMB_VFS_OP_FTRUNCATE, SMB_VFS_LAYER_TRANSPARENT},
-       {SMB_VFS_OP(prealloc_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT},
-       {NULL,  SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP}
+static struct vfs_fn_pointers prealloc_fns = {
+       .open_fn = prealloc_open,
+       .ftruncate_fn = prealloc_ftruncate,
+       .connect_fn = prealloc_connect,
 };
 
 NTSTATUS vfs_prealloc_init(void);
 NTSTATUS vfs_prealloc_init(void)
 {
        return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
-               MODULE, prealloc_op_tuples);
+                               MODULE, &prealloc_fns);
 }
-