fuse_internal.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*
    2  * Copyright (c) 2007-2009 Google Inc. and Amit Singh
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions are
    7  * met:
    8  *
    9  * * Redistributions of source code must retain the above copyright
   10  *   notice, this list of conditions and the following disclaimer.
   11  * * Redistributions in binary form must reproduce the above
   12  *   copyright notice, this list of conditions and the following disclaimer
   13  *   in the documentation and/or other materials provided with the
   14  *   distribution.
   15  * * Neither the name of Google Inc. nor the names of its
   16  *   contributors may be used to endorse or promote products derived from
   17  *   this software without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   30  *
   31  * Copyright (C) 2005 Csaba Henk.
   32  * All rights reserved.
   33  *
   34  * Redistribution and use in source and binary forms, with or without
   35  * modification, are permitted provided that the following conditions
   36  * are met:
   37  * 1. Redistributions of source code must retain the above copyright
   38  *    notice, this list of conditions and the following disclaimer.
   39  * 2. Redistributions in binary form must reproduce the above copyright
   40  *    notice, this list of conditions and the following disclaimer in the
   41  *    documentation and/or other materials provided with the distribution.
   42  *
   43  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   46  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
   47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   53  * SUCH DAMAGE.
   54  */
   55 
   56 #include <sys/cdefs.h>
   57 __FBSDID("$FreeBSD$");
   58 
   59 #include <sys/types.h>
   60 #include <sys/module.h>
   61 #include <sys/systm.h>
   62 #include <sys/errno.h>
   63 #include <sys/param.h>
   64 #include <sys/kernel.h>
   65 #include <sys/conf.h>
   66 #include <sys/uio.h>
   67 #include <sys/malloc.h>
   68 #include <sys/queue.h>
   69 #include <sys/lock.h>
   70 #include <sys/mutex.h>
   71 #include <sys/sx.h>
   72 #include <sys/proc.h>
   73 #include <sys/mount.h>
   74 #include <sys/vnode.h>
   75 #include <sys/namei.h>
   76 #include <sys/stat.h>
   77 #include <sys/unistd.h>
   78 #include <sys/filedesc.h>
   79 #include <sys/file.h>
   80 #include <sys/fcntl.h>
   81 #include <sys/dirent.h>
   82 #include <sys/bio.h>
   83 #include <sys/buf.h>
   84 #include <sys/sysctl.h>
   85 #include <sys/priv.h>
   86 
   87 #include "fuse.h"
   88 #include "fuse_file.h"
   89 #include "fuse_internal.h"
   90 #include "fuse_ipc.h"
   91 #include "fuse_node.h"
   92 #include "fuse_file.h"
   93 #include "fuse_param.h"
   94 
   95 #define FUSE_DEBUG_MODULE INTERNAL
   96 #include "fuse_debug.h"
   97 
   98 #ifdef ZERO_PAD_INCOMPLETE_BUFS
   99 static int isbzero(void *buf, size_t len);
  100 
  101 #endif
  102 
  103 /* access */
  104 
  105 int
  106 fuse_internal_access(struct vnode *vp,
  107     mode_t mode,
  108     struct fuse_access_param *facp,
  109     struct thread *td,
  110     struct ucred *cred)
  111 {
  112         int err = 0;
  113         uint32_t mask = 0;
  114         int dataflags;
  115         int vtype;
  116         struct mount *mp;
  117         struct fuse_dispatcher fdi;
  118         struct fuse_access_in *fai;
  119         struct fuse_data *data;
  120 
  121         /* NOT YET DONE */
  122         /*
  123          * If this vnop gives you trouble, just return 0 here for a lazy
  124          * kludge.
  125          */
  126         /* return 0;*/
  127 
  128         fuse_trace_printf_func();
  129 
  130         mp = vnode_mount(vp);
  131         vtype = vnode_vtype(vp);
  132 
  133         data = fuse_get_mpdata(mp);
  134         dataflags = data->dataflags;
  135 
  136         if ((mode & VWRITE) && vfs_isrdonly(mp)) {
  137                 return EACCES;
  138         }
  139         /* Unless explicitly permitted, deny everyone except the fs owner. */
  140             if (vnode_isvroot(vp) && !(facp->facc_flags & FACCESS_NOCHECKSPY)) {
  141                 if (!(dataflags & FSESS_DAEMON_CAN_SPY)) {
  142                         int denied = fuse_match_cred(data->daemoncred,
  143                             cred);
  144 
  145                         if (denied) {
  146                                 return EPERM;
  147                         }
  148                 }
  149                 facp->facc_flags |= FACCESS_NOCHECKSPY;
  150         }
  151         if (!(facp->facc_flags & FACCESS_DO_ACCESS)) {
  152                 return 0;
  153         }
  154         if (((vtype == VREG) && (mode & VEXEC))) {
  155 #ifdef NEED_MOUNT_ARGUMENT_FOR_THIS
  156                 /* Let   the kernel handle this through open / close heuristics.*/
  157                     return ENOTSUP;
  158 #else
  159                     /*  Let the kernel handle this. */
  160                     return 0;
  161 #endif
  162         }
  163         if (!fsess_isimpl(mp, FUSE_ACCESS)) {
  164                 /* Let the kernel handle this. */
  165                     return 0;
  166         }
  167         if (dataflags & FSESS_DEFAULT_PERMISSIONS) {
  168                 /* Let the kernel handle this. */
  169                     return 0;
  170         }
  171         if ((mode & VADMIN) != 0) {
  172                 err = priv_check_cred(cred, PRIV_VFS_ADMIN, 0);
  173                 if (err) {
  174                         return err;
  175                 }
  176         }
  177         if ((mode & (VWRITE | VAPPEND | VADMIN)) != 0) {
  178                 mask |= W_OK;
  179         }
  180         if ((mode & VREAD) != 0) {
  181                 mask |= R_OK;
  182         }
  183         if ((mode & VEXEC) != 0) {
  184                 mask |= X_OK;
  185         }
  186         bzero(&fdi, sizeof(fdi));
  187 
  188         fdisp_init(&fdi, sizeof(*fai));
  189         fdisp_make_vp(&fdi, FUSE_ACCESS, vp, td, cred);
  190 
  191         fai = fdi.indata;
  192         fai->mask = F_OK;
  193         fai->mask |= mask;
  194 
  195         err = fdisp_wait_answ(&fdi);
  196         fdisp_destroy(&fdi);
  197 
  198         if (err == ENOSYS) {
  199                 fsess_set_notimpl(mp, FUSE_ACCESS);
  200                 err = 0;
  201         }
  202         return err;
  203 }
  204 
  205 /* fsync */
  206 
  207 int
  208 fuse_internal_fsync_callback(struct fuse_ticket *tick, struct uio *uio)
  209 {
  210         fuse_trace_printf_func();
  211 
  212         if (tick->tk_aw_ohead.error == ENOSYS) {
  213                 fsess_set_notimpl(tick->tk_data->mp, fticket_opcode(tick));
  214         }
  215         return 0;
  216 }
  217 
  218 int
  219 fuse_internal_fsync(struct vnode *vp,
  220     struct thread *td,
  221     struct ucred *cred,
  222     struct fuse_filehandle *fufh)
  223 {
  224         int op = FUSE_FSYNC;
  225         struct fuse_fsync_in *ffsi;
  226         struct fuse_dispatcher fdi;
  227 
  228         fuse_trace_printf_func();
  229 
  230         if (vnode_isdir(vp)) {
  231                 op = FUSE_FSYNCDIR;
  232         }
  233         fdisp_init(&fdi, sizeof(*ffsi));
  234         fdisp_make_vp(&fdi, op, vp, td, cred);
  235         ffsi = fdi.indata;
  236         ffsi->fh = fufh->fh_id;
  237 
  238         ffsi->fsync_flags = 1;          /* datasync */
  239 
  240         fuse_insert_callback(fdi.tick, fuse_internal_fsync_callback);
  241         fuse_insert_message(fdi.tick);
  242 
  243         fdisp_destroy(&fdi);
  244 
  245         return 0;
  246 
  247 }
  248 
  249 /* readdir */
  250 
  251 int
  252 fuse_internal_readdir(struct vnode *vp,
  253     struct uio *uio,
  254     struct fuse_filehandle *fufh,
  255     struct fuse_iov *cookediov)
  256 {
  257         int err = 0;
  258         struct fuse_dispatcher fdi;
  259         struct fuse_read_in *fri;
  260 
  261         if (uio_resid(uio) == 0) {
  262                 return 0;
  263         }
  264         fdisp_init(&fdi, 0);
  265 
  266         /*
  267          * Note that we DO NOT have a UIO_SYSSPACE here (so no need for p2p
  268          * I/O).
  269          */
  270 
  271         while (uio_resid(uio) > 0) {
  272 
  273                 fdi.iosize = sizeof(*fri);
  274                 fdisp_make_vp(&fdi, FUSE_READDIR, vp, NULL, NULL);
  275 
  276                 fri = fdi.indata;
  277                 fri->fh = fufh->fh_id;
  278                 fri->offset = uio_offset(uio);
  279                 fri->size = min(uio_resid(uio), FUSE_DEFAULT_IOSIZE);
  280                 /* mp->max_read */
  281 
  282                     if ((err = fdisp_wait_answ(&fdi))) {
  283                         break;
  284                 }
  285                 if ((err = fuse_internal_readdir_processdata(uio, fri->size, fdi.answ,
  286                     fdi.iosize, cookediov))) {
  287                         break;
  288                 }
  289         }
  290 
  291         fdisp_destroy(&fdi);
  292         return ((err == -1) ? 0 : err);
  293 }
  294 
  295 int
  296 fuse_internal_readdir_processdata(struct uio *uio,
  297     size_t reqsize,
  298     void *buf,
  299     size_t bufsize,
  300     void *param)
  301 {
  302         int err = 0;
  303         int cou = 0;
  304         int bytesavail;
  305         size_t freclen;
  306 
  307         struct dirent *de;
  308         struct fuse_dirent *fudge;
  309         struct fuse_iov *cookediov = param;
  310 
  311         if (bufsize < FUSE_NAME_OFFSET) {
  312                 return -1;
  313         }
  314         for (;;) {
  315 
  316                 if (bufsize < FUSE_NAME_OFFSET) {
  317                         err = -1;
  318                         break;
  319                 }
  320                 fudge = (struct fuse_dirent *)buf;
  321                 freclen = FUSE_DIRENT_SIZE(fudge);
  322 
  323                 cou++;
  324 
  325                 if (bufsize < freclen) {
  326                         err = ((cou == 1) ? -1 : 0);
  327                         break;
  328                 }
  329 #ifdef ZERO_PAD_INCOMPLETE_BUFS
  330                 if (isbzero(buf, FUSE_NAME_OFFSET)) {
  331                         err = -1;
  332                         break;
  333                 }
  334 #endif
  335 
  336                 if (!fudge->namelen || fudge->namelen > MAXNAMLEN) {
  337                         err = EINVAL;
  338                         break;
  339                 }
  340                 bytesavail = GENERIC_DIRSIZ((struct pseudo_dirent *)
  341                                             &fudge->namelen);
  342 
  343                 if (bytesavail > uio_resid(uio)) {
  344                         err = -1;
  345                         break;
  346                 }
  347                 fiov_refresh(cookediov);
  348                 fiov_adjust(cookediov, bytesavail);
  349 
  350                 de = (struct dirent *)cookediov->base;
  351                 de->d_fileno = fudge->ino;      /* XXX: truncation */
  352                 de->d_reclen = bytesavail;
  353                 de->d_type = fudge->type;
  354                 de->d_namlen = fudge->namelen;
  355                 memcpy((char *)cookediov->base + sizeof(struct dirent) - 
  356                        MAXNAMLEN - 1,
  357                        (char *)buf + FUSE_NAME_OFFSET, fudge->namelen);
  358                 dirent_terminate(de);
  359 
  360                 err = uiomove(cookediov->base, cookediov->len, uio);
  361                 if (err) {
  362                         break;
  363                 }
  364                 buf = (char *)buf + freclen;
  365                 bufsize -= freclen;
  366                 uio_setoffset(uio, fudge->off);
  367         }
  368 
  369         return err;
  370 }
  371 
  372 /* remove */
  373 
  374 #define INVALIDATE_CACHED_VATTRS_UPON_UNLINK 1
  375 int
  376 fuse_internal_remove(struct vnode *dvp,
  377     struct vnode *vp,
  378     struct componentname *cnp,
  379     enum fuse_opcode op)
  380 {
  381         struct fuse_dispatcher fdi;
  382 
  383         struct vattr *vap = VTOVA(vp);
  384 
  385 #if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
  386         int need_invalidate = 0;
  387         uint64_t target_nlink = 0;
  388 
  389 #endif
  390         int err = 0;
  391 
  392         debug_printf("dvp=%p, cnp=%p, op=%d\n", vp, cnp, op);
  393 
  394         fdisp_init(&fdi, cnp->cn_namelen + 1);
  395         fdisp_make_vp(&fdi, op, dvp, cnp->cn_thread, cnp->cn_cred);
  396 
  397         memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
  398         ((char *)fdi.indata)[cnp->cn_namelen] = '\0';
  399 
  400 #if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
  401         if (vap->va_nlink > 1) {
  402                 need_invalidate = 1;
  403                 target_nlink = vap->va_nlink;
  404         }
  405 #endif
  406 
  407         err = fdisp_wait_answ(&fdi);
  408         fdisp_destroy(&fdi);
  409         return err;
  410 }
  411 
  412 /* rename */
  413 
  414 int
  415 fuse_internal_rename(struct vnode *fdvp,
  416     struct componentname *fcnp,
  417     struct vnode *tdvp,
  418     struct componentname *tcnp)
  419 {
  420         struct fuse_dispatcher fdi;
  421         struct fuse_rename_in *fri;
  422         int err = 0;
  423 
  424         fdisp_init(&fdi, sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 2);
  425         fdisp_make_vp(&fdi, FUSE_RENAME, fdvp, tcnp->cn_thread, tcnp->cn_cred);
  426 
  427         fri = fdi.indata;
  428         fri->newdir = VTOI(tdvp);
  429         memcpy((char *)fdi.indata + sizeof(*fri), fcnp->cn_nameptr,
  430             fcnp->cn_namelen);
  431         ((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen] = '\0';
  432         memcpy((char *)fdi.indata + sizeof(*fri) + fcnp->cn_namelen + 1,
  433             tcnp->cn_nameptr, tcnp->cn_namelen);
  434         ((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen +
  435             tcnp->cn_namelen + 1] = '\0';
  436 
  437         err = fdisp_wait_answ(&fdi);
  438         fdisp_destroy(&fdi);
  439         return err;
  440 }
  441 
  442 /* strategy */
  443 
  444 /* entity creation */
  445 
  446 void
  447 fuse_internal_newentry_makerequest(struct mount *mp,
  448     uint64_t dnid,
  449     struct componentname *cnp,
  450     enum fuse_opcode op,
  451     void *buf,
  452     size_t bufsize,
  453     struct fuse_dispatcher *fdip)
  454 {
  455         debug_printf("fdip=%p\n", fdip);
  456 
  457         fdip->iosize = bufsize + cnp->cn_namelen + 1;
  458 
  459         fdisp_make(fdip, op, mp, dnid, cnp->cn_thread, cnp->cn_cred);
  460         memcpy(fdip->indata, buf, bufsize);
  461         memcpy((char *)fdip->indata + bufsize, cnp->cn_nameptr, cnp->cn_namelen);
  462         ((char *)fdip->indata)[bufsize + cnp->cn_namelen] = '\0';
  463 }
  464 
  465 int
  466 fuse_internal_newentry_core(struct vnode *dvp,
  467     struct vnode **vpp,
  468     struct componentname *cnp,
  469     enum vtype vtyp,
  470     struct fuse_dispatcher *fdip)
  471 {
  472         int err = 0;
  473         struct fuse_entry_out *feo;
  474         struct mount *mp = vnode_mount(dvp);
  475 
  476         if ((err = fdisp_wait_answ(fdip))) {
  477                 return err;
  478         }
  479         feo = fdip->answ;
  480 
  481         if ((err = fuse_internal_checkentry(feo, vtyp))) {
  482                 return err;
  483         }
  484         err = fuse_vnode_get(mp, feo->nodeid, dvp, vpp, cnp, vtyp);
  485         if (err) {
  486                 fuse_internal_forget_send(mp, cnp->cn_thread, cnp->cn_cred,
  487                     feo->nodeid, 1);
  488                 return err;
  489         }
  490         cache_attrs(*vpp, feo);
  491 
  492         return err;
  493 }
  494 
  495 int
  496 fuse_internal_newentry(struct vnode *dvp,
  497     struct vnode **vpp,
  498     struct componentname *cnp,
  499     enum fuse_opcode op,
  500     void *buf,
  501     size_t bufsize,
  502     enum vtype vtype)
  503 {
  504         int err;
  505         struct fuse_dispatcher fdi;
  506         struct mount *mp = vnode_mount(dvp);
  507 
  508         fdisp_init(&fdi, 0);
  509         fuse_internal_newentry_makerequest(mp, VTOI(dvp), cnp, op, buf,
  510             bufsize, &fdi);
  511         err = fuse_internal_newentry_core(dvp, vpp, cnp, vtype, &fdi);
  512         fdisp_destroy(&fdi);
  513 
  514         return err;
  515 }
  516 
  517 /* entity destruction */
  518 
  519 int
  520 fuse_internal_forget_callback(struct fuse_ticket *ftick, struct uio *uio)
  521 {
  522         fuse_internal_forget_send(ftick->tk_data->mp, curthread, NULL,
  523             ((struct fuse_in_header *)ftick->tk_ms_fiov.base)->nodeid, 1);
  524 
  525         return 0;
  526 }
  527 
  528 void
  529 fuse_internal_forget_send(struct mount *mp,
  530     struct thread *td,
  531     struct ucred *cred,
  532     uint64_t nodeid,
  533     uint64_t nlookup)
  534 {
  535 
  536         struct fuse_dispatcher fdi;
  537         struct fuse_forget_in *ffi;
  538 
  539         debug_printf("mp=%p, nodeid=%ju, nlookup=%ju\n",
  540             mp, (uintmax_t)nodeid, (uintmax_t)nlookup);
  541 
  542         /*
  543          * KASSERT(nlookup > 0, ("zero-times forget for vp #%llu",
  544          *         (long long unsigned) nodeid));
  545          */
  546 
  547         fdisp_init(&fdi, sizeof(*ffi));
  548         fdisp_make(&fdi, FUSE_FORGET, mp, nodeid, td, cred);
  549 
  550         ffi = fdi.indata;
  551         ffi->nlookup = nlookup;
  552 
  553         fuse_insert_message(fdi.tick);
  554         fdisp_destroy(&fdi);
  555 }
  556 
  557 void
  558 fuse_internal_vnode_disappear(struct vnode *vp)
  559 {
  560         struct fuse_vnode_data *fvdat = VTOFUD(vp);
  561 
  562         ASSERT_VOP_ELOCKED(vp, "fuse_internal_vnode_disappear");
  563         fvdat->flag |= FN_REVOKED;
  564         cache_purge(vp);
  565 }
  566 
  567 /* fuse start/stop */
  568 
  569 int
  570 fuse_internal_init_callback(struct fuse_ticket *tick, struct uio *uio)
  571 {
  572         int err = 0;
  573         struct fuse_data *data = tick->tk_data;
  574         struct fuse_init_out *fiio;
  575 
  576         if ((err = tick->tk_aw_ohead.error)) {
  577                 goto out;
  578         }
  579         if ((err = fticket_pull(tick, uio))) {
  580                 goto out;
  581         }
  582         fiio = fticket_resp(tick)->base;
  583 
  584         /* XXX: Do we want to check anything further besides this? */
  585         if (fiio->major < 7) {
  586                 debug_printf("userpace version too low\n");
  587                 err = EPROTONOSUPPORT;
  588                 goto out;
  589         }
  590         data->fuse_libabi_major = fiio->major;
  591         data->fuse_libabi_minor = fiio->minor;
  592 
  593         if (fuse_libabi_geq(data, 7, 5)) {
  594                 if (fticket_resp(tick)->len == sizeof(struct fuse_init_out)) {
  595                         data->max_write = fiio->max_write;
  596                 } else {
  597                         err = EINVAL;
  598                 }
  599         } else {
  600                 /* Old fix values */
  601                 data->max_write = 4096;
  602         }
  603 
  604 out:
  605         if (err) {
  606                 fdata_set_dead(data);
  607         }
  608         FUSE_LOCK();
  609         data->dataflags |= FSESS_INITED;
  610         wakeup(&data->ticketer);
  611         FUSE_UNLOCK();
  612 
  613         return 0;
  614 }
  615 
  616 void
  617 fuse_internal_send_init(struct fuse_data *data, struct thread *td)
  618 {
  619         struct fuse_init_in *fiii;
  620         struct fuse_dispatcher fdi;
  621 
  622         fdisp_init(&fdi, sizeof(*fiii));
  623         fdisp_make(&fdi, FUSE_INIT, data->mp, 0, td, NULL);
  624         fiii = fdi.indata;
  625         fiii->major = FUSE_KERNEL_VERSION;
  626         fiii->minor = FUSE_KERNEL_MINOR_VERSION;
  627         fiii->max_readahead = FUSE_DEFAULT_IOSIZE * 16;
  628         fiii->flags = 0;
  629 
  630         fuse_insert_callback(fdi.tick, fuse_internal_init_callback);
  631         fuse_insert_message(fdi.tick);
  632         fdisp_destroy(&fdi);
  633 }
  634 
  635 #ifdef ZERO_PAD_INCOMPLETE_BUFS
  636 static int
  637 isbzero(void *buf, size_t len)
  638 {
  639         int i;
  640 
  641         for (i = 0; i < len; i++) {
  642                 if (((char *)buf)[i])
  643                         return (0);
  644         }
  645 
  646         return (1);
  647 }
  648 
  649 #endif
Cache object: 0885b3bec92986d1087456715c622a6b
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/fuse/fuse_internal.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/fuse/fuse_internal.c
