sys/fs/fuse/fuse_ipc.h

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2007-2009 Google Inc. and Amit Singh
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are
   9  * met:
  10  *
  11  * * Redistributions of source code must retain the above copyright
  12  *   notice, this list of conditions and the following disclaimer.
  13  * * Redistributions in binary form must reproduce the above
  14  *   copyright notice, this list of conditions and the following disclaimer
  15  *   in the documentation and/or other materials provided with the
  16  *   distribution.
  17  * * Neither the name of Google Inc. nor the names of its
  18  *   contributors may be used to endorse or promote products derived from
  19  *   this software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * Copyright (C) 2005 Csaba Henk.
  34  * All rights reserved.
  35  *
  36  * Copyright (c) 2019 The FreeBSD Foundation
  37  *
  38  * Portions of this software were developed by BFF Storage Systems, LLC under
  39  * sponsorship from the FreeBSD Foundation.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  *
  50  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  51  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  52  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  53  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  54  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  57  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  58  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  59  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  60  * SUCH DAMAGE.
  61  *
  62  * $FreeBSD$
  63  */
  64
  65 #ifndef _FUSE_IPC_H_
  66 #define _FUSE_IPC_H_
  67
  68 #include <sys/param.h>
  69 #include <sys/refcount.h>
  70
  71 enum fuse_data_cache_mode {
  72         FUSE_CACHE_UC,
  73         FUSE_CACHE_WT,
  74         FUSE_CACHE_WB,
  75 };
  76
  77 struct fuse_iov {
  78         void   *base;
  79         size_t  len;
  80         size_t  allocated_size;
  81         int     credit;
  82 };
  83
  84 void fiov_init(struct fuse_iov *fiov, size_t size);
  85 void fiov_teardown(struct fuse_iov *fiov);
  86 void fiov_refresh(struct fuse_iov *fiov);
  87 void fiov_adjust(struct fuse_iov *fiov, size_t size);
  88
  89 #define FUSE_DIMALLOC(fiov, spc1, spc2, amnt) do {              \
  90         fiov_adjust(fiov, (sizeof(*(spc1)) + (amnt)));          \
  91         (spc1) = (fiov)->base;                                  \
  92         (spc2) = (char *)(fiov)->base + (sizeof(*(spc1)));      \
  93 } while (0)
  94
  95 #define FU_AT_LEAST(siz) max((siz), 160)
  96
  97 #define FUSE_ASSERT_AW_DONE(ftick)                                      \
  98         KASSERT((ftick)->tk_aw_link.tqe_next == NULL &&                 \
  99             (ftick)->tk_aw_link.tqe_prev == NULL,                       \
 100             ("FUSE: ticket still on answer delivery list %p", (ftick)))
 101
 102 #define FUSE_ASSERT_MS_DONE(ftick)                              \
 103         KASSERT((ftick)->tk_ms_link.stqe_next == NULL,          \
 104             ("FUSE: ticket still on message list %p", (ftick)))
 105
 106 struct fuse_ticket;
 107 struct fuse_data;
 108
 109 typedef int fuse_handler_t(struct fuse_ticket *ftick, struct uio *uio);
 110
 111 struct fuse_ticket {
 112         /* fields giving the identity of the ticket */
 113         uint64_t                        tk_unique;
 114         struct fuse_data                *tk_data;
 115         int                             tk_flag;
 116         u_int                           tk_refcount;
 117         /*
 118          * If this ticket's operation has been interrupted, this will hold the
 119          * unique value of the FUSE_INTERRUPT operation.  Otherwise, it will be
 120          * 0.
 121          */
 122         uint64_t                        irq_unique;
 123
 124         /* fields for initiating an upgoing message */
 125         struct fuse_iov                 tk_ms_fiov;
 126         void                            *tk_ms_bufdata;
 127         size_t                          tk_ms_bufsize;
 128         enum { FT_M_FIOV, FT_M_BUF }    tk_ms_type;
 129         STAILQ_ENTRY(fuse_ticket)       tk_ms_link;
 130
 131         /* fields for handling answers coming from userspace */
 132         struct fuse_iov                 tk_aw_fiov;
 133         void                            *tk_aw_bufdata;
 134         size_t                          tk_aw_bufsize;
 135         enum { FT_A_FIOV, FT_A_BUF }    tk_aw_type;
 136
 137         struct fuse_out_header          tk_aw_ohead;
 138         int                             tk_aw_errno;
 139         struct mtx                      tk_aw_mtx;
 140         fuse_handler_t                  *tk_aw_handler;
 141         TAILQ_ENTRY(fuse_ticket)        tk_aw_link;
 142 };
 143
 144 #define FT_ANSW  0x01  /* request of ticket has already been answered */
 145 #define FT_DIRTY 0x04  /* ticket has been used */
 146
 147 static inline struct fuse_iov *
 148 fticket_resp(struct fuse_ticket *ftick)
 149 {
 150         return (&ftick->tk_aw_fiov);
 151 }
 152
 153 static inline bool
 154 fticket_answered(struct fuse_ticket *ftick)
 155 {
 156         mtx_assert(&ftick->tk_aw_mtx, MA_OWNED);
 157         return (ftick->tk_flag & FT_ANSW);
 158 }
 159
 160 static inline void
 161 fticket_set_answered(struct fuse_ticket *ftick)
 162 {
 163         mtx_assert(&ftick->tk_aw_mtx, MA_OWNED);
 164         ftick->tk_flag |= FT_ANSW;
 165 }
 166
 167 static inline struct fuse_in_header*
 168 fticket_in_header(struct fuse_ticket *ftick)
 169 {
 170         return (struct fuse_in_header *)(ftick->tk_ms_fiov.base);
 171 }
 172
 173 static inline enum fuse_opcode
 174 fticket_opcode(struct fuse_ticket *ftick)
 175 {
 176         return fticket_in_header(ftick)->opcode;
 177 }
 178
 179 int fticket_pull(struct fuse_ticket *ftick, struct uio *uio);
 180
 181 /*
 182  * The data representing a FUSE session.
 183  */
 184 struct fuse_data {
 185         struct cdev                     *fdev;
 186         struct mount                    *mp;
 187         struct vnode                    *vroot;
 188         struct ucred                    *daemoncred;
 189         int                             dataflags;
 190         int                             ref;
 191
 192         struct mtx                      ms_mtx;
 193         STAILQ_HEAD(, fuse_ticket)      ms_head;
 194         int                             ms_count;
 195
 196         struct mtx                      aw_mtx;
 197         TAILQ_HEAD(, fuse_ticket)       aw_head;
 198
 199         /*
 200          * Holds the next value of the FUSE operation unique value.
 201          * Also, serves as a wakeup channel to prevent any operations from
 202          * being created before INIT completes.
 203          */
 204         u_long                          ticketer;
 205
 206         struct sx                       rename_lock;
 207
 208         uint32_t                        fuse_libabi_major;
 209         uint32_t                        fuse_libabi_minor;
 210
 211         uint32_t                        max_readahead_blocks;
 212         uint32_t                        max_write;
 213         uint32_t                        max_read;
 214         uint32_t                        subtype;
 215         char                            volname[MAXPATHLEN];
 216
 217         struct selinfo                  ks_rsel;
 218
 219         int                             daemon_timeout;
 220         unsigned                        time_gran;
 221         uint64_t                        notimpl;
 222         uint64_t                        mnt_flag;
 223         enum fuse_data_cache_mode       cache_mode;
 224 };
 225
 226 #define FSESS_DEAD                0x0001 /* session is to be closed */
 227 #define FSESS_INITED              0x0004 /* session has been inited */
 228 #define FSESS_DAEMON_CAN_SPY      0x0010 /* let non-owners access this fs */
 229                                          /* (and being observed by the daemon) */
 230 #define FSESS_PUSH_SYMLINKS_IN    0x0020 /* prefix absolute symlinks with mp */
 231 #define FSESS_DEFAULT_PERMISSIONS 0x0040 /* kernel does permission checking */
 232 #define FSESS_ASYNC_READ          0x1000 /* allow multiple reads of some file */
 233 #define FSESS_POSIX_LOCKS         0x2000 /* daemon supports POSIX locks */
 234 #define FSESS_EXPORT_SUPPORT      0x10000 /* daemon supports NFS-style lookups */
 235 #define FSESS_INTR                0x20000 /* interruptible mounts */
 236 #define FSESS_MNTOPTS_MASK      ( \
 237         FSESS_DAEMON_CAN_SPY | FSESS_PUSH_SYMLINKS_IN | \
 238         FSESS_DEFAULT_PERMISSIONS | FSESS_INTR)
 239
 240 extern int fuse_data_cache_mode;
 241
 242 static inline struct fuse_data *
 243 fuse_get_mpdata(struct mount *mp)
 244 {
 245         return mp->mnt_data;
 246 }
 247
 248 static inline bool
 249 fsess_isimpl(struct mount *mp, int opcode)
 250 {
 251         struct fuse_data *data = fuse_get_mpdata(mp);
 252
 253         return ((data->notimpl & (1ULL << opcode)) == 0);
 254
 255 }
 256 static inline void
 257 fsess_set_notimpl(struct mount *mp, int opcode)
 258 {
 259         struct fuse_data *data = fuse_get_mpdata(mp);
 260
 261         data->notimpl |= (1ULL << opcode);
 262 }
 263
 264 static inline bool
 265 fsess_opt_datacache(struct mount *mp)
 266 {
 267         struct fuse_data *data = fuse_get_mpdata(mp);
 268
 269         return (data->cache_mode != FUSE_CACHE_UC);
 270 }
 271
 272 static inline bool
 273 fsess_opt_mmap(struct mount *mp)
 274 {
 275         return (fsess_opt_datacache(mp));
 276 }
 277
 278 static inline bool
 279 fsess_opt_writeback(struct mount *mp)
 280 {
 281         struct fuse_data *data = fuse_get_mpdata(mp);
 282
 283         return (data->cache_mode == FUSE_CACHE_WB);
 284 }
 285
 286 /* Insert a new upgoing message */
 287 static inline void
 288 fuse_ms_push(struct fuse_ticket *ftick)
 289 {
 290         mtx_assert(&ftick->tk_data->ms_mtx, MA_OWNED);
 291         refcount_acquire(&ftick->tk_refcount);
 292         STAILQ_INSERT_TAIL(&ftick->tk_data->ms_head, ftick, tk_ms_link);
 293         ftick->tk_data->ms_count++;
 294 }
 295
 296 /* Insert a new upgoing message to the front of the queue */
 297 static inline void
 298 fuse_ms_push_head(struct fuse_ticket *ftick)
 299 {
 300         mtx_assert(&ftick->tk_data->ms_mtx, MA_OWNED);
 301         refcount_acquire(&ftick->tk_refcount);
 302         STAILQ_INSERT_HEAD(&ftick->tk_data->ms_head, ftick, tk_ms_link);
 303         ftick->tk_data->ms_count++;
 304 }
 305
 306 static inline struct fuse_ticket *
 307 fuse_ms_pop(struct fuse_data *data)
 308 {
 309         struct fuse_ticket *ftick = NULL;
 310
 311         mtx_assert(&data->ms_mtx, MA_OWNED);
 312
 313         if ((ftick = STAILQ_FIRST(&data->ms_head))) {
 314                 STAILQ_REMOVE_HEAD(&data->ms_head, tk_ms_link);
 315                 data->ms_count--;
 316 #ifdef INVARIANTS
 317                 MPASS(data->ms_count >= 0);
 318                 ftick->tk_ms_link.stqe_next = NULL;
 319 #endif
 320         }
 321
 322         return (ftick);
 323 }
 324
 325 static inline void
 326 fuse_aw_push(struct fuse_ticket *ftick)
 327 {
 328         mtx_assert(&ftick->tk_data->aw_mtx, MA_OWNED);
 329         refcount_acquire(&ftick->tk_refcount);
 330         TAILQ_INSERT_TAIL(&ftick->tk_data->aw_head, ftick, tk_aw_link);
 331 }
 332
 333 static inline void
 334 fuse_aw_remove(struct fuse_ticket *ftick)
 335 {
 336         mtx_assert(&ftick->tk_data->aw_mtx, MA_OWNED);
 337         TAILQ_REMOVE(&ftick->tk_data->aw_head, ftick, tk_aw_link);
 338 #ifdef INVARIANTS
 339         ftick->tk_aw_link.tqe_next = NULL;
 340         ftick->tk_aw_link.tqe_prev = NULL;
 341 #endif
 342 }
 343
 344 static inline struct fuse_ticket *
 345 fuse_aw_pop(struct fuse_data *data)
 346 {
 347         struct fuse_ticket *ftick;
 348
 349         mtx_assert(&data->aw_mtx, MA_OWNED);
 350
 351         if ((ftick = TAILQ_FIRST(&data->aw_head)) != NULL)
 352                 fuse_aw_remove(ftick);
 353
 354         return (ftick);
 355 }
 356
 357 struct fuse_ticket *fuse_ticket_fetch(struct fuse_data *data);
 358 int fuse_ticket_drop(struct fuse_ticket *ftick);
 359 void fuse_insert_callback(struct fuse_ticket *ftick, fuse_handler_t *handler);
 360 void fuse_insert_message(struct fuse_ticket *ftick, bool irq);
 361
 362 static inline bool
 363 fuse_libabi_geq(struct fuse_data *data, uint32_t abi_maj, uint32_t abi_min)
 364 {
 365         return (data->fuse_libabi_major > abi_maj ||
 366             (data->fuse_libabi_major == abi_maj &&
 367              data->fuse_libabi_minor >= abi_min));
 368 }
 369
 370 struct fuse_data *fdata_alloc(struct cdev *dev, struct ucred *cred);
 371 void fdata_trydestroy(struct fuse_data *data);
 372 void fdata_set_dead(struct fuse_data *data);
 373
 374 static inline bool
 375 fdata_get_dead(struct fuse_data *data)
 376 {
 377         return (data->dataflags & FSESS_DEAD);
 378 }
 379
 380 struct fuse_dispatcher {
 381         struct fuse_ticket    *tick;
 382         struct fuse_in_header *finh;
 383
 384         void    *indata;
 385         size_t   iosize;
 386         uint64_t nodeid;
 387         int      answ_stat;
 388         void    *answ;
 389 };
 390
 391 static inline void
 392 fdisp_init(struct fuse_dispatcher *fdisp, size_t iosize)
 393 {
 394         fdisp->iosize = iosize;
 395         fdisp->tick = NULL;
 396 }
 397
 398 static inline void
 399 fdisp_destroy(struct fuse_dispatcher *fdisp)
 400 {
 401         fuse_ticket_drop(fdisp->tick);
 402 #ifdef INVARIANTS
 403         fdisp->tick = NULL;
 404 #endif
 405 }
 406
 407 void fdisp_refresh(struct fuse_dispatcher *fdip);
 408
 409 void fdisp_make(struct fuse_dispatcher *fdip, enum fuse_opcode op,
 410     struct mount *mp, uint64_t nid, struct thread *td, struct ucred *cred);
 411
 412 void fdisp_make_vp(struct fuse_dispatcher *fdip, enum fuse_opcode op,
 413     struct vnode *vp, struct thread *td, struct ucred *cred);
 414
 415 void fdisp_refresh_vp(struct fuse_dispatcher *fdip, enum fuse_opcode op,
 416     struct vnode *vp, struct thread *td, struct ucred *cred);
 417
 418 int fdisp_wait_answ(struct fuse_dispatcher *fdip);
 419
 420 static inline int
 421 fdisp_simple_putget_vp(struct fuse_dispatcher *fdip, enum fuse_opcode op,
 422     struct vnode *vp, struct thread *td, struct ucred *cred)
 423 {
 424         fdisp_make_vp(fdip, op, vp, td, cred);
 425         return (fdisp_wait_answ(fdip));
 426 }
 427
 428 #endif /* _FUSE_IPC_H_ */