[BACK]Return to puffs.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libpuffs

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libpuffs/puffs.c between version 1.92 and 1.92.4.4

version 1.92, 2008/08/12 19:44:39 version 1.92.4.4, 2009/10/27 20:37:38
Line 99  fillvnopmask(struct puffs_ops *pops, uin
Line 99  fillvnopmask(struct puffs_ops *pops, uin
         FILLOP(print,    PRINT);          FILLOP(print,    PRINT);
         FILLOP(read,     READ);          FILLOP(read,     READ);
         FILLOP(write,    WRITE);          FILLOP(write,    WRITE);
           FILLOP(abortop,  ABORTOP);
 }  }
 #undef FILLOP  #undef FILLOP
   
Line 268  puffs_getspecific(struct puffs_usermount
Line 269  puffs_getspecific(struct puffs_usermount
         return pu->pu_privdata;          return pu->pu_privdata;
 }  }
   
   void
   puffs_setspecific(struct puffs_usermount *pu, void *privdata)
   {
   
           pu->pu_privdata = privdata;
   }
   
   void
   puffs_setmntinfo(struct puffs_usermount *pu,
           const char *mntfromname, const char *puffsname)
   {
           struct puffs_kargs *pargs = pu->pu_kargp;
   
           (void)strlcpy(pargs->pa_mntfromname, mntfromname,
               sizeof(pargs->pa_mntfromname));
           (void)strlcpy(pargs->pa_typename, puffsname,
               sizeof(pargs->pa_typename));
   }
   
 size_t  size_t
 puffs_getmaxreqlen(struct puffs_usermount *pu)  puffs_getmaxreqlen(struct puffs_usermount *pu)
 {  {
Line 456  puffs_daemon(struct puffs_usermount *pu,
Line 476  puffs_daemon(struct puffs_usermount *pu,
         return -1;          return -1;
 }  }
   
   static void
   shutdaemon(struct puffs_usermount *pu, int error)
   {
           ssize_t n;
   
           n = write(pu->pu_dpipe[1], &error, sizeof(int));
           assert(n == 4);
           close(pu->pu_dpipe[0]);
           close(pu->pu_dpipe[1]);
           pu->pu_state &= ~PU_PUFFSDAEMON;
   }
   
 int  int
 puffs_mount(struct puffs_usermount *pu, const char *dir, int mntflags,  puffs_mount(struct puffs_usermount *pu, const char *dir, int mntflags,
         puffs_cookie_t cookie)          puffs_cookie_t cookie)
 {  {
         char rp[MAXPATHLEN];          char rp[MAXPATHLEN];
         ssize_t n;  
         int rv, fd, sverrno;          int rv, fd, sverrno;
         char *comfd;          char *comfd;
   
Line 559  do {         \
Line 590  do {         \
         free(pu->pu_kargp);          free(pu->pu_kargp);
         pu->pu_kargp = NULL;          pu->pu_kargp = NULL;
   
         if (pu->pu_state & PU_PUFFSDAEMON) {          if (pu->pu_state & PU_PUFFSDAEMON)
                 n = write(pu->pu_dpipe[1], &sverrno, sizeof(int));                  shutdaemon(pu, sverrno);
                 assert(n == 4);  
                 close(pu->pu_dpipe[0]);  
                 close(pu->pu_dpipe[1]);  
         }  
   
         errno = sverrno;          errno = sverrno;
         return rv;          return rv;
 }  }
   
   /*ARGSUSED*/
 struct puffs_usermount *  struct puffs_usermount *
 _puffs_init(int develv, struct puffs_ops *pops, const char *mntfromname,  _puffs_init(int dummy, struct puffs_ops *pops, const char *mntfromname,
         const char *puffsname, void *priv, uint32_t pflags)          const char *puffsname, void *priv, uint32_t pflags)
 {  {
         struct puffs_usermount *pu;          struct puffs_usermount *pu;
         struct puffs_kargs *pargs;          struct puffs_kargs *pargs;
         int sverrno;          int sverrno;
   
         if (develv != PUFFS_DEVEL_LIBVERSION) {          if (puffsname == PUFFS_DEFER)
                 warnx("puffs_init: mounting with lib version %d, need %d",                  puffsname = "n/a";
                     develv, PUFFS_DEVEL_LIBVERSION);          if (mntfromname == PUFFS_DEFER)
                 errno = EINVAL;                  mntfromname = "n/a";
                 return NULL;          if (priv == PUFFS_DEFER)
         }                  priv = NULL;
   
         pu = malloc(sizeof(struct puffs_usermount));          pu = malloc(sizeof(struct puffs_usermount));
         if (pu == NULL)          if (pu == NULL)
Line 598  _puffs_init(int develv, struct puffs_ops
Line 626  _puffs_init(int develv, struct puffs_ops
         pargs->pa_vers = PUFFSDEVELVERS | PUFFSVERSION;          pargs->pa_vers = PUFFSDEVELVERS | PUFFSVERSION;
         pargs->pa_flags = PUFFS_FLAG_KERN(pflags);          pargs->pa_flags = PUFFS_FLAG_KERN(pflags);
         fillvnopmask(pops, pargs->pa_vnopmask);          fillvnopmask(pops, pargs->pa_vnopmask);
         (void)strlcpy(pargs->pa_typename, puffsname,          puffs_setmntinfo(pu, mntfromname, puffsname);
             sizeof(pargs->pa_typename));  
         (void)strlcpy(pargs->pa_mntfromname, mntfromname,  
             sizeof(pargs->pa_mntfromname));  
   
         puffs_zerostatvfs(&pargs->pa_svfsb);          puffs_zerostatvfs(&pargs->pa_svfsb);
         pargs->pa_root_cookie = NULL;          pargs->pa_root_cookie = NULL;
Line 651  _puffs_init(int develv, struct puffs_ops
Line 676  _puffs_init(int develv, struct puffs_ops
         return NULL;          return NULL;
 }  }
   
   void
   puffs_cancel(struct puffs_usermount *pu, int error)
   {
   
           assert(puffs_getstate(pu) < PUFFS_STATE_RUNNING);
           shutdaemon(pu, error);
           free(pu);
   }
   
 /*  /*
  * XXX: there's currently no clean way to request unmount from   * XXX: there's currently no clean way to request unmount from
  * within the user server, so be very brutal about it.   * within the user server, so be very brutal about it.
Line 662  puffs_exit(struct puffs_usermount *pu, i
Line 696  puffs_exit(struct puffs_usermount *pu, i
         struct puffs_node *pn;          struct puffs_node *pn;
   
         force = 1; /* currently */          force = 1; /* currently */
           assert((pu->pu_state & PU_PUFFSDAEMON) == 0);
   
         if (pu->pu_fd)          if (pu->pu_fd)
                 close(pu->pu_fd);                  close(pu->pu_fd);
Legend:
Removed from v.1.92  
changed lines
  Added in v.1.92.4.4
CVSweb <webmaster@jp.NetBSD.org>