yeahuh / rpms / qemu-kvm

Forked from rpms/qemu-kvm 2 years ago
Clone
ddf19c
From ff16b837e402de773581f77ca188f8806c0b500f Mon Sep 17 00:00:00 2001
ddf19c
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
ddf19c
Date: Mon, 27 Jan 2020 19:00:51 +0100
ddf19c
Subject: [PATCH 020/116] virtiofsd: Trim out compatibility code
ddf19c
MIME-Version: 1.0
ddf19c
Content-Type: text/plain; charset=UTF-8
ddf19c
Content-Transfer-Encoding: 8bit
ddf19c
ddf19c
RH-Author: Dr. David Alan Gilbert <dgilbert@redhat.com>
ddf19c
Message-id: <20200127190227.40942-17-dgilbert@redhat.com>
ddf19c
Patchwork-id: 93468
ddf19c
O-Subject: [RHEL-AV-8.2 qemu-kvm PATCH 016/112] virtiofsd: Trim out compatibility code
ddf19c
Bugzilla: 1694164
ddf19c
RH-Acked-by: Philippe Mathieu-Daudé <philmd@redhat.com>
ddf19c
RH-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
ddf19c
RH-Acked-by: Sergio Lopez Pascual <slp@redhat.com>
ddf19c
ddf19c
From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>
ddf19c
ddf19c
virtiofsd only supports major=7, minor>=31; trim out a lot of
ddf19c
old compatibility code.
ddf19c
ddf19c
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
ddf19c
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
ddf19c
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
ddf19c
(cherry picked from commit 72c42e2d65510e073cf78fdc924d121c77fa0080)
ddf19c
Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>
ddf19c
---
ddf19c
 tools/virtiofsd/fuse_lowlevel.c | 330 +++++++++++++++-------------------------
ddf19c
 1 file changed, 119 insertions(+), 211 deletions(-)
ddf19c
ddf19c
diff --git a/tools/virtiofsd/fuse_lowlevel.c b/tools/virtiofsd/fuse_lowlevel.c
ddf19c
index 07fb8a6..514d79c 100644
ddf19c
--- a/tools/virtiofsd/fuse_lowlevel.c
ddf19c
+++ b/tools/virtiofsd/fuse_lowlevel.c
ddf19c
@@ -387,16 +387,7 @@ static void fill_open(struct fuse_open_out *arg, const struct fuse_file_info *f)
ddf19c
 int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e)
ddf19c
 {
ddf19c
     struct fuse_entry_out arg;
ddf19c
-    size_t size = req->se->conn.proto_minor < 9 ? FUSE_COMPAT_ENTRY_OUT_SIZE :
ddf19c
-                                                  sizeof(arg);
ddf19c
-
ddf19c
-    /*
ddf19c
-     * before ABI 7.4 e->ino == 0 was invalid, only ENOENT meant
ddf19c
-     * negative entry
ddf19c
-     */
ddf19c
-    if (!e->ino && req->se->conn.proto_minor < 4) {
ddf19c
-        return fuse_reply_err(req, ENOENT);
ddf19c
-    }
ddf19c
+    size_t size = sizeof(arg);
ddf19c
 
ddf19c
     memset(&arg, 0, sizeof(arg));
ddf19c
     fill_entry(&arg, e);
ddf19c
@@ -407,9 +398,7 @@ int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
ddf19c
                       const struct fuse_file_info *f)
ddf19c
 {
ddf19c
     char buf[sizeof(struct fuse_entry_out) + sizeof(struct fuse_open_out)];
ddf19c
-    size_t entrysize = req->se->conn.proto_minor < 9 ?
ddf19c
-                           FUSE_COMPAT_ENTRY_OUT_SIZE :
ddf19c
-                           sizeof(struct fuse_entry_out);
ddf19c
+    size_t entrysize = sizeof(struct fuse_entry_out);
ddf19c
     struct fuse_entry_out *earg = (struct fuse_entry_out *)buf;
ddf19c
     struct fuse_open_out *oarg = (struct fuse_open_out *)(buf + entrysize);
ddf19c
 
ddf19c
@@ -423,8 +412,7 @@ int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
ddf19c
                     double attr_timeout)
ddf19c
 {
ddf19c
     struct fuse_attr_out arg;
ddf19c
-    size_t size =
ddf19c
-        req->se->conn.proto_minor < 9 ? FUSE_COMPAT_ATTR_OUT_SIZE : sizeof(arg);
ddf19c
+    size_t size = sizeof(arg);
ddf19c
 
ddf19c
     memset(&arg, 0, sizeof(arg));
ddf19c
     arg.attr_valid = calc_timeout_sec(attr_timeout);
ddf19c
@@ -519,8 +507,7 @@ int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv)
ddf19c
 int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
ddf19c
 {
ddf19c
     struct fuse_statfs_out arg;
ddf19c
-    size_t size =
ddf19c
-        req->se->conn.proto_minor < 4 ? FUSE_COMPAT_STATFS_SIZE : sizeof(arg);
ddf19c
+    size_t size = sizeof(arg);
ddf19c
 
ddf19c
     memset(&arg, 0, sizeof(arg));
ddf19c
     convert_statfs(stbuf, &arg.st);
ddf19c
@@ -604,45 +591,31 @@ int fuse_reply_ioctl_retry(fuse_req_t req, const struct iovec *in_iov,
ddf19c
     iov[count].iov_len = sizeof(arg);
ddf19c
     count++;
ddf19c
 
ddf19c
-    if (req->se->conn.proto_minor < 16) {
ddf19c
-        if (in_count) {
ddf19c
-            iov[count].iov_base = (void *)in_iov;
ddf19c
-            iov[count].iov_len = sizeof(in_iov[0]) * in_count;
ddf19c
-            count++;
ddf19c
-        }
ddf19c
+    /* Can't handle non-compat 64bit ioctls on 32bit */
ddf19c
+    if (sizeof(void *) == 4 && req->ioctl_64bit) {
ddf19c
+        res = fuse_reply_err(req, EINVAL);
ddf19c
+        goto out;
ddf19c
+    }
ddf19c
 
ddf19c
-        if (out_count) {
ddf19c
-            iov[count].iov_base = (void *)out_iov;
ddf19c
-            iov[count].iov_len = sizeof(out_iov[0]) * out_count;
ddf19c
-            count++;
ddf19c
+    if (in_count) {
ddf19c
+        in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
ddf19c
+        if (!in_fiov) {
ddf19c
+            goto enomem;
ddf19c
         }
ddf19c
-    } else {
ddf19c
-        /* Can't handle non-compat 64bit ioctls on 32bit */
ddf19c
-        if (sizeof(void *) == 4 && req->ioctl_64bit) {
ddf19c
-            res = fuse_reply_err(req, EINVAL);
ddf19c
-            goto out;
ddf19c
-        }
ddf19c
-
ddf19c
-        if (in_count) {
ddf19c
-            in_fiov = fuse_ioctl_iovec_copy(in_iov, in_count);
ddf19c
-            if (!in_fiov) {
ddf19c
-                goto enomem;
ddf19c
-            }
ddf19c
 
ddf19c
-            iov[count].iov_base = (void *)in_fiov;
ddf19c
-            iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
ddf19c
-            count++;
ddf19c
+        iov[count].iov_base = (void *)in_fiov;
ddf19c
+        iov[count].iov_len = sizeof(in_fiov[0]) * in_count;
ddf19c
+        count++;
ddf19c
+    }
ddf19c
+    if (out_count) {
ddf19c
+        out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
ddf19c
+        if (!out_fiov) {
ddf19c
+            goto enomem;
ddf19c
         }
ddf19c
-        if (out_count) {
ddf19c
-            out_fiov = fuse_ioctl_iovec_copy(out_iov, out_count);
ddf19c
-            if (!out_fiov) {
ddf19c
-                goto enomem;
ddf19c
-            }
ddf19c
 
ddf19c
-            iov[count].iov_base = (void *)out_fiov;
ddf19c
-            iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
ddf19c
-            count++;
ddf19c
-        }
ddf19c
+        iov[count].iov_base = (void *)out_fiov;
ddf19c
+        iov[count].iov_len = sizeof(out_fiov[0]) * out_count;
ddf19c
+        count++;
ddf19c
     }
ddf19c
 
ddf19c
     res = send_reply_iov(req, 0, iov, count);
ddf19c
@@ -784,14 +757,12 @@ static void do_getattr(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     struct fuse_file_info *fip = NULL;
ddf19c
     struct fuse_file_info fi;
ddf19c
 
ddf19c
-    if (req->se->conn.proto_minor >= 9) {
ddf19c
-        struct fuse_getattr_in *arg = (struct fuse_getattr_in *)inarg;
ddf19c
+    struct fuse_getattr_in *arg = (struct fuse_getattr_in *)inarg;
ddf19c
 
ddf19c
-        if (arg->getattr_flags & FUSE_GETATTR_FH) {
ddf19c
-            memset(&fi, 0, sizeof(fi));
ddf19c
-            fi.fh = arg->fh;
ddf19c
-            fip = &fi;
ddf19c
-        }
ddf19c
+    if (arg->getattr_flags & FUSE_GETATTR_FH) {
ddf19c
+        memset(&fi, 0, sizeof(fi));
ddf19c
+        fi.fh = arg->fh;
ddf19c
+        fip = &fi;
ddf19c
     }
ddf19c
 
ddf19c
     if (req->se->op.getattr) {
ddf19c
@@ -856,11 +827,7 @@ static void do_mknod(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     struct fuse_mknod_in *arg = (struct fuse_mknod_in *)inarg;
ddf19c
     char *name = PARAM(arg);
ddf19c
 
ddf19c
-    if (req->se->conn.proto_minor >= 12) {
ddf19c
-        req->ctx.umask = arg->umask;
ddf19c
-    } else {
ddf19c
-        name = (char *)inarg + FUSE_COMPAT_MKNOD_IN_SIZE;
ddf19c
-    }
ddf19c
+    req->ctx.umask = arg->umask;
ddf19c
 
ddf19c
     if (req->se->op.mknod) {
ddf19c
         req->se->op.mknod(req, nodeid, name, arg->mode, arg->rdev);
ddf19c
@@ -873,9 +840,7 @@ static void do_mkdir(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
 {
ddf19c
     struct fuse_mkdir_in *arg = (struct fuse_mkdir_in *)inarg;
ddf19c
 
ddf19c
-    if (req->se->conn.proto_minor >= 12) {
ddf19c
-        req->ctx.umask = arg->umask;
ddf19c
-    }
ddf19c
+    req->ctx.umask = arg->umask;
ddf19c
 
ddf19c
     if (req->se->op.mkdir) {
ddf19c
         req->se->op.mkdir(req, nodeid, PARAM(arg), arg->mode);
ddf19c
@@ -967,11 +932,7 @@ static void do_create(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
         memset(&fi, 0, sizeof(fi));
ddf19c
         fi.flags = arg->flags;
ddf19c
 
ddf19c
-        if (req->se->conn.proto_minor >= 12) {
ddf19c
-            req->ctx.umask = arg->umask;
ddf19c
-        } else {
ddf19c
-            name = (char *)inarg + sizeof(struct fuse_open_in);
ddf19c
-        }
ddf19c
+        req->ctx.umask = arg->umask;
ddf19c
 
ddf19c
         req->se->op.create(req, nodeid, name, arg->mode, &fi);
ddf19c
     } else {
ddf19c
@@ -1003,10 +964,8 @@ static void do_read(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
 
ddf19c
         memset(&fi, 0, sizeof(fi));
ddf19c
         fi.fh = arg->fh;
ddf19c
-        if (req->se->conn.proto_minor >= 9) {
ddf19c
-            fi.lock_owner = arg->lock_owner;
ddf19c
-            fi.flags = arg->flags;
ddf19c
-        }
ddf19c
+        fi.lock_owner = arg->lock_owner;
ddf19c
+        fi.flags = arg->flags;
ddf19c
         req->se->op.read(req, nodeid, arg->size, arg->offset, &fi);
ddf19c
     } else {
ddf19c
         fuse_reply_err(req, ENOSYS);
ddf19c
@@ -1023,13 +982,9 @@ static void do_write(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     fi.fh = arg->fh;
ddf19c
     fi.writepage = (arg->write_flags & FUSE_WRITE_CACHE) != 0;
ddf19c
 
ddf19c
-    if (req->se->conn.proto_minor < 9) {
ddf19c
-        param = ((char *)arg) + FUSE_COMPAT_WRITE_IN_SIZE;
ddf19c
-    } else {
ddf19c
-        fi.lock_owner = arg->lock_owner;
ddf19c
-        fi.flags = arg->flags;
ddf19c
-        param = PARAM(arg);
ddf19c
-    }
ddf19c
+    fi.lock_owner = arg->lock_owner;
ddf19c
+    fi.flags = arg->flags;
ddf19c
+    param = PARAM(arg);
ddf19c
 
ddf19c
     if (req->se->op.write) {
ddf19c
         req->se->op.write(req, nodeid, param, arg->size, arg->offset, &fi);
ddf19c
@@ -1053,21 +1008,14 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
ddf19c
     fi.fh = arg->fh;
ddf19c
     fi.writepage = arg->write_flags & FUSE_WRITE_CACHE;
ddf19c
 
ddf19c
-    if (se->conn.proto_minor < 9) {
ddf19c
-        bufv.buf[0].mem = ((char *)arg) + FUSE_COMPAT_WRITE_IN_SIZE;
ddf19c
-        bufv.buf[0].size -=
ddf19c
-            sizeof(struct fuse_in_header) + FUSE_COMPAT_WRITE_IN_SIZE;
ddf19c
-        assert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));
ddf19c
-    } else {
ddf19c
-        fi.lock_owner = arg->lock_owner;
ddf19c
-        fi.flags = arg->flags;
ddf19c
-        if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
ddf19c
-            bufv.buf[0].mem = PARAM(arg);
ddf19c
-        }
ddf19c
-
ddf19c
-        bufv.buf[0].size -=
ddf19c
-            sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
ddf19c
+    fi.lock_owner = arg->lock_owner;
ddf19c
+    fi.flags = arg->flags;
ddf19c
+    if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD)) {
ddf19c
+        bufv.buf[0].mem = PARAM(arg);
ddf19c
     }
ddf19c
+
ddf19c
+    bufv.buf[0].size -=
ddf19c
+        sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in);
ddf19c
     if (bufv.buf[0].size < arg->size) {
ddf19c
         fuse_log(FUSE_LOG_ERR, "fuse: do_write_buf: buffer size too small\n");
ddf19c
         fuse_reply_err(req, EIO);
ddf19c
@@ -1086,9 +1034,7 @@ static void do_flush(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     memset(&fi, 0, sizeof(fi));
ddf19c
     fi.fh = arg->fh;
ddf19c
     fi.flush = 1;
ddf19c
-    if (req->se->conn.proto_minor >= 7) {
ddf19c
-        fi.lock_owner = arg->lock_owner;
ddf19c
-    }
ddf19c
+    fi.lock_owner = arg->lock_owner;
ddf19c
 
ddf19c
     if (req->se->op.flush) {
ddf19c
         req->se->op.flush(req, nodeid, &fi);
ddf19c
@@ -1105,10 +1051,8 @@ static void do_release(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     memset(&fi, 0, sizeof(fi));
ddf19c
     fi.flags = arg->flags;
ddf19c
     fi.fh = arg->fh;
ddf19c
-    if (req->se->conn.proto_minor >= 8) {
ddf19c
-        fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
ddf19c
-        fi.lock_owner = arg->lock_owner;
ddf19c
-    }
ddf19c
+    fi.flush = (arg->release_flags & FUSE_RELEASE_FLUSH) ? 1 : 0;
ddf19c
+    fi.lock_owner = arg->lock_owner;
ddf19c
     if (arg->release_flags & FUSE_RELEASE_FLOCK_UNLOCK) {
ddf19c
         fi.flock_release = 1;
ddf19c
         fi.lock_owner = arg->lock_owner;
ddf19c
@@ -1477,8 +1421,7 @@ static void do_ioctl(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     memset(&fi, 0, sizeof(fi));
ddf19c
     fi.fh = arg->fh;
ddf19c
 
ddf19c
-    if (sizeof(void *) == 4 && req->se->conn.proto_minor >= 16 &&
ddf19c
-        !(flags & FUSE_IOCTL_32BIT)) {
ddf19c
+    if (sizeof(void *) == 4 && !(flags & FUSE_IOCTL_32BIT)) {
ddf19c
         req->ioctl_64bit = 1;
ddf19c
     }
ddf19c
 
ddf19c
@@ -1603,7 +1546,7 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     outarg.major = FUSE_KERNEL_VERSION;
ddf19c
     outarg.minor = FUSE_KERNEL_MINOR_VERSION;
ddf19c
 
ddf19c
-    if (arg->major < 7) {
ddf19c
+    if (arg->major < 7 || (arg->major == 7 && arg->minor < 31)) {
ddf19c
         fuse_log(FUSE_LOG_ERR, "fuse: unsupported protocol version: %u.%u\n",
ddf19c
                  arg->major, arg->minor);
ddf19c
         fuse_reply_err(req, EPROTO);
ddf19c
@@ -1616,81 +1559,71 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
         return;
ddf19c
     }
ddf19c
 
ddf19c
-    if (arg->minor >= 6) {
ddf19c
-        if (arg->max_readahead < se->conn.max_readahead) {
ddf19c
-            se->conn.max_readahead = arg->max_readahead;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_ASYNC_READ) {
ddf19c
-            se->conn.capable |= FUSE_CAP_ASYNC_READ;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_POSIX_LOCKS) {
ddf19c
-            se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_ATOMIC_O_TRUNC) {
ddf19c
-            se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_EXPORT_SUPPORT) {
ddf19c
-            se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_DONT_MASK) {
ddf19c
-            se->conn.capable |= FUSE_CAP_DONT_MASK;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_FLOCK_LOCKS) {
ddf19c
-            se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_AUTO_INVAL_DATA) {
ddf19c
-            se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_DO_READDIRPLUS) {
ddf19c
-            se->conn.capable |= FUSE_CAP_READDIRPLUS;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_READDIRPLUS_AUTO) {
ddf19c
-            se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_ASYNC_DIO) {
ddf19c
-            se->conn.capable |= FUSE_CAP_ASYNC_DIO;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_WRITEBACK_CACHE) {
ddf19c
-            se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_NO_OPEN_SUPPORT) {
ddf19c
-            se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_PARALLEL_DIROPS) {
ddf19c
-            se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_POSIX_ACL) {
ddf19c
-            se->conn.capable |= FUSE_CAP_POSIX_ACL;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_HANDLE_KILLPRIV) {
ddf19c
-            se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
ddf19c
-        }
ddf19c
-        if (arg->flags & FUSE_NO_OPENDIR_SUPPORT) {
ddf19c
-            se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
ddf19c
-        }
ddf19c
-        if (!(arg->flags & FUSE_MAX_PAGES)) {
ddf19c
-            size_t max_bufsize =
ddf19c
-                FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize() +
ddf19c
-                FUSE_BUFFER_HEADER_SIZE;
ddf19c
-            if (bufsize > max_bufsize) {
ddf19c
-                bufsize = max_bufsize;
ddf19c
-            }
ddf19c
+    if (arg->max_readahead < se->conn.max_readahead) {
ddf19c
+        se->conn.max_readahead = arg->max_readahead;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_ASYNC_READ) {
ddf19c
+        se->conn.capable |= FUSE_CAP_ASYNC_READ;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_POSIX_LOCKS) {
ddf19c
+        se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_ATOMIC_O_TRUNC) {
ddf19c
+        se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_EXPORT_SUPPORT) {
ddf19c
+        se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_DONT_MASK) {
ddf19c
+        se->conn.capable |= FUSE_CAP_DONT_MASK;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_FLOCK_LOCKS) {
ddf19c
+        se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_AUTO_INVAL_DATA) {
ddf19c
+        se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_DO_READDIRPLUS) {
ddf19c
+        se->conn.capable |= FUSE_CAP_READDIRPLUS;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_READDIRPLUS_AUTO) {
ddf19c
+        se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_ASYNC_DIO) {
ddf19c
+        se->conn.capable |= FUSE_CAP_ASYNC_DIO;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_WRITEBACK_CACHE) {
ddf19c
+        se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_NO_OPEN_SUPPORT) {
ddf19c
+        se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_PARALLEL_DIROPS) {
ddf19c
+        se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_POSIX_ACL) {
ddf19c
+        se->conn.capable |= FUSE_CAP_POSIX_ACL;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_HANDLE_KILLPRIV) {
ddf19c
+        se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
ddf19c
+    }
ddf19c
+    if (arg->flags & FUSE_NO_OPENDIR_SUPPORT) {
ddf19c
+        se->conn.capable |= FUSE_CAP_NO_OPENDIR_SUPPORT;
ddf19c
+    }
ddf19c
+    if (!(arg->flags & FUSE_MAX_PAGES)) {
ddf19c
+        size_t max_bufsize = FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize() +
ddf19c
+                             FUSE_BUFFER_HEADER_SIZE;
ddf19c
+        if (bufsize > max_bufsize) {
ddf19c
+            bufsize = max_bufsize;
ddf19c
         }
ddf19c
-    } else {
ddf19c
-        se->conn.max_readahead = 0;
ddf19c
     }
ddf19c
-
ddf19c
-    if (se->conn.proto_minor >= 14) {
ddf19c
 #ifdef HAVE_SPLICE
ddf19c
 #ifdef HAVE_VMSPLICE
ddf19c
-        se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
ddf19c
+    se->conn.capable |= FUSE_CAP_SPLICE_WRITE | FUSE_CAP_SPLICE_MOVE;
ddf19c
 #endif
ddf19c
-        se->conn.capable |= FUSE_CAP_SPLICE_READ;
ddf19c
+    se->conn.capable |= FUSE_CAP_SPLICE_READ;
ddf19c
 #endif
ddf19c
-    }
ddf19c
-    if (se->conn.proto_minor >= 18) {
ddf19c
-        se->conn.capable |= FUSE_CAP_IOCTL_DIR;
ddf19c
-    }
ddf19c
+    se->conn.capable |= FUSE_CAP_IOCTL_DIR;
ddf19c
 
ddf19c
     /*
ddf19c
      * Default settings for modern filesystems.
ddf19c
@@ -1797,24 +1730,20 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
     }
ddf19c
     outarg.max_readahead = se->conn.max_readahead;
ddf19c
     outarg.max_write = se->conn.max_write;
ddf19c
-    if (se->conn.proto_minor >= 13) {
ddf19c
-        if (se->conn.max_background >= (1 << 16)) {
ddf19c
-            se->conn.max_background = (1 << 16) - 1;
ddf19c
-        }
ddf19c
-        if (se->conn.congestion_threshold > se->conn.max_background) {
ddf19c
-            se->conn.congestion_threshold = se->conn.max_background;
ddf19c
-        }
ddf19c
-        if (!se->conn.congestion_threshold) {
ddf19c
-            se->conn.congestion_threshold = se->conn.max_background * 3 / 4;
ddf19c
-        }
ddf19c
-
ddf19c
-        outarg.max_background = se->conn.max_background;
ddf19c
-        outarg.congestion_threshold = se->conn.congestion_threshold;
ddf19c
+    if (se->conn.max_background >= (1 << 16)) {
ddf19c
+        se->conn.max_background = (1 << 16) - 1;
ddf19c
+    }
ddf19c
+    if (se->conn.congestion_threshold > se->conn.max_background) {
ddf19c
+        se->conn.congestion_threshold = se->conn.max_background;
ddf19c
     }
ddf19c
-    if (se->conn.proto_minor >= 23) {
ddf19c
-        outarg.time_gran = se->conn.time_gran;
ddf19c
+    if (!se->conn.congestion_threshold) {
ddf19c
+        se->conn.congestion_threshold = se->conn.max_background * 3 / 4;
ddf19c
     }
ddf19c
 
ddf19c
+    outarg.max_background = se->conn.max_background;
ddf19c
+    outarg.congestion_threshold = se->conn.congestion_threshold;
ddf19c
+    outarg.time_gran = se->conn.time_gran;
ddf19c
+
ddf19c
     if (se->debug) {
ddf19c
         fuse_log(FUSE_LOG_DEBUG, "   INIT: %u.%u\n", outarg.major,
ddf19c
                  outarg.minor);
ddf19c
@@ -1828,11 +1757,6 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
ddf19c
                  outarg.congestion_threshold);
ddf19c
         fuse_log(FUSE_LOG_DEBUG, "   time_gran=%u\n", outarg.time_gran);
ddf19c
     }
ddf19c
-    if (arg->minor < 5) {
ddf19c
-        outargsize = FUSE_COMPAT_INIT_OUT_SIZE;
ddf19c
-    } else if (arg->minor < 23) {
ddf19c
-        outargsize = FUSE_COMPAT_22_INIT_OUT_SIZE;
ddf19c
-    }
ddf19c
 
ddf19c
     send_reply_ok(req, &outarg, outargsize);
ddf19c
 }
ddf19c
@@ -1896,10 +1820,6 @@ int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
ddf19c
         return -EINVAL;
ddf19c
     }
ddf19c
 
ddf19c
-    if (se->conn.proto_major < 6 || se->conn.proto_minor < 12) {
ddf19c
-        return -ENOSYS;
ddf19c
-    }
ddf19c
-
ddf19c
     outarg.ino = ino;
ddf19c
     outarg.off = off;
ddf19c
     outarg.len = len;
ddf19c
@@ -1920,10 +1840,6 @@ int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
ddf19c
         return -EINVAL;
ddf19c
     }
ddf19c
 
ddf19c
-    if (se->conn.proto_major < 6 || se->conn.proto_minor < 12) {
ddf19c
-        return -ENOSYS;
ddf19c
-    }
ddf19c
-
ddf19c
     outarg.parent = parent;
ddf19c
     outarg.namelen = namelen;
ddf19c
     outarg.padding = 0;
ddf19c
@@ -1947,10 +1863,6 @@ int fuse_lowlevel_notify_delete(struct fuse_session *se, fuse_ino_t parent,
ddf19c
         return -EINVAL;
ddf19c
     }
ddf19c
 
ddf19c
-    if (se->conn.proto_major < 6 || se->conn.proto_minor < 18) {
ddf19c
-        return -ENOSYS;
ddf19c
-    }
ddf19c
-
ddf19c
     outarg.parent = parent;
ddf19c
     outarg.child = child;
ddf19c
     outarg.namelen = namelen;
ddf19c
@@ -1977,10 +1889,6 @@ int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino,
ddf19c
         return -EINVAL;
ddf19c
     }
ddf19c
 
ddf19c
-    if (se->conn.proto_major < 6 || se->conn.proto_minor < 15) {
ddf19c
-        return -ENOSYS;
ddf19c
-    }
ddf19c
-
ddf19c
     out.unique = 0;
ddf19c
     out.error = FUSE_NOTIFY_STORE;
ddf19c
 
ddf19c
-- 
ddf19c
1.8.3.1
ddf19c