[BACK]Return to puffs_vfsops.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / fs / puffs

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

Diff for /src/sys/fs/puffs/puffs_vfsops.c between version 1.65.4.3 and 1.66

version 1.65.4.3, 2008/02/18 21:06:40 version 1.66, 2007/11/10 21:45:08
Line 43  __KERNEL_RCSID(0, "$NetBSD$");
Line 43  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/fstrans.h>  #include <sys/fstrans.h>
 #include <sys/proc.h>  #include <sys/proc.h>
   
 #include <dev/putter/putter_sys.h>  #include <dev/puttervar.h>
   
 #include <miscfs/genfs/genfs.h>  
   
 #include <fs/puffs/puffs_msgif.h>  #include <fs/puffs/puffs_msgif.h>
 #include <fs/puffs/puffs_sys.h>  #include <fs/puffs/puffs_sys.h>
Line 54  __KERNEL_RCSID(0, "$NetBSD$");
Line 52  __KERNEL_RCSID(0, "$NetBSD$");
   
 #include <nfs/nfsproto.h> /* for fh sizes */  #include <nfs/nfsproto.h> /* for fh sizes */
   
 VFS_PROTOS(puffs_vfsop);  VFS_PROTOS(puffs);
   
   MALLOC_JUSTDEFINE(M_PUFFS, "puffs", "Pass-to-Userspace Framework File System");
   
 #ifndef PUFFS_PNODEBUCKETS  #ifndef PUFFS_PNODEBUCKETS
 #define PUFFS_PNODEBUCKETS 256  #define PUFFS_PNODEBUCKETS 256
Line 65  VFS_PROTOS(puffs_vfsop);
Line 65  VFS_PROTOS(puffs_vfsop);
 int puffs_pnodebuckets_default = PUFFS_PNODEBUCKETS;  int puffs_pnodebuckets_default = PUFFS_PNODEBUCKETS;
 int puffs_maxpnodebuckets = PUFFS_MAXPNODEBUCKETS;  int puffs_maxpnodebuckets = PUFFS_MAXPNODEBUCKETS;
   
 #define BUCKETALLOC(a) (sizeof(struct puffs_pnode_hashlist *) * (a))  
   
 static struct putter_ops puffs_putter = {  static struct putter_ops puffs_putter = {
         .pop_getout     = puffs_msgif_getout,          .pop_getout     = puffs_msgif_getout,
         .pop_releaseout = puffs_msgif_releaseout,          .pop_releaseout = puffs_msgif_releaseout,
Line 76  static struct putter_ops puffs_putter = 
Line 74  static struct putter_ops puffs_putter = 
 };  };
   
 int  int
 puffs_vfsop_mount(struct mount *mp, const char *path, void *data,  puffs_mount(struct mount *mp, const char *path, void *data, size_t *data_len,
         size_t *data_len)              struct lwp *l)
 {  {
         struct puffs_mount *pmp = NULL;          struct puffs_mount *pmp = NULL;
         struct puffs_kargs *args;          struct puffs_kargs *args;
         char fstype[_VFS_NAMELEN];          char fstype[_VFS_NAMELEN];
         char *p;          char *p;
         int error = 0, i;          int error = 0, i;
         pid_t mntpid = curlwp->l_proc->p_pid;          pid_t mntpid = l->l_proc->p_pid;
   
         if (*data_len < sizeof *args)          if (*data_len < sizeof *args)
                 return EINVAL;                  return EINVAL;
Line 106  puffs_vfsop_mount(struct mount *mp, cons
Line 104  puffs_vfsop_mount(struct mount *mp, cons
         if (!data)          if (!data)
                 return EINVAL;                  return EINVAL;
   
         error = fstrans_mount(mp);          MALLOC(args, struct puffs_kargs *, sizeof(struct puffs_kargs),
         if (error)              M_PUFFS, M_WAITOK);
                 return error;  
         args = (struct puffs_kargs *)data;          *args = *(struct puffs_kargs *)data;
   
         /* devel phase */          /* devel phase */
         if (args->pa_vers != (PUFFSVERSION | PUFFSDEVELVERS)) {          if (args->pa_vers != (PUFFSVERSION | PUFFSDEVELVERS)) {
Line 202  puffs_vfsop_mount(struct mount *mp, cons
Line 200  puffs_vfsop_mount(struct mount *mp, cons
         }          }
   
         error = set_statvfs_info(path, UIO_USERSPACE, args->pa_mntfromname,          error = set_statvfs_info(path, UIO_USERSPACE, args->pa_mntfromname,
             UIO_SYSSPACE, fstype, mp, curlwp);              UIO_SYSSPACE, fstype, mp, l);
         if (error)          if (error)
                 goto out;                  goto out;
         mp->mnt_stat.f_iosize = DEV_BSIZE;          mp->mnt_stat.f_iosize = DEV_BSIZE;
Line 215  puffs_vfsop_mount(struct mount *mp, cons
Line 213  puffs_vfsop_mount(struct mount *mp, cons
         copy_statvfs_info(&args->pa_svfsb, mp);          copy_statvfs_info(&args->pa_svfsb, mp);
         (void)memcpy(&mp->mnt_stat, &args->pa_svfsb, sizeof(mp->mnt_stat));          (void)memcpy(&mp->mnt_stat, &args->pa_svfsb, sizeof(mp->mnt_stat));
   
         pmp = kmem_zalloc(sizeof(struct puffs_mount), KM_SLEEP);          MALLOC(pmp, struct puffs_mount *, sizeof(struct puffs_mount),
               M_PUFFS, M_WAITOK | M_ZERO);
   
         mp->mnt_fs_bshift = DEV_BSHIFT;          mp->mnt_fs_bshift = DEV_BSHIFT;
         mp->mnt_dev_bshift = DEV_BSHIFT;          mp->mnt_dev_bshift = DEV_BSHIFT;
Line 229  puffs_vfsop_mount(struct mount *mp, cons
Line 228  puffs_vfsop_mount(struct mount *mp, cons
         pmp->pmp_args = *args;          pmp->pmp_args = *args;
   
         pmp->pmp_npnodehash = args->pa_nhashbuckets;          pmp->pmp_npnodehash = args->pa_nhashbuckets;
         pmp->pmp_pnodehash = kmem_alloc(BUCKETALLOC(pmp->pmp_npnodehash), KM_SLEEP);          pmp->pmp_pnodehash = malloc
               (sizeof(struct puffs_pnode_hashlist *) * pmp->pmp_npnodehash,
               M_PUFFS, M_WAITOK);
         for (i = 0; i < pmp->pmp_npnodehash; i++)          for (i = 0; i < pmp->pmp_npnodehash; i++)
                 LIST_INIT(&pmp->pmp_pnodehash[i]);                  LIST_INIT(&pmp->pmp_pnodehash[i]);
         LIST_INIT(&pmp->pmp_newcookie);          LIST_INIT(&pmp->pmp_newcookie);
Line 264  puffs_vfsop_mount(struct mount *mp, cons
Line 265  puffs_vfsop_mount(struct mount *mp, cons
         vfs_getnewfsid(mp);          vfs_getnewfsid(mp);
   
  out:   out:
         if (error)  
                 fstrans_unmount(mp);  
         if (error && pmp && pmp->pmp_pnodehash)          if (error && pmp && pmp->pmp_pnodehash)
                 kmem_free(pmp->pmp_pnodehash, BUCKETALLOC(pmp->pmp_npnodehash));                  free(pmp->pmp_pnodehash, M_PUFFS);
         if (error && pmp)          if (error && pmp)
                 kmem_free(pmp, sizeof(struct puffs_mount));                  FREE(pmp, M_PUFFS);
           FREE(args, M_PUFFS);
         return error;          return error;
 }  }
   
 int  int
 puffs_vfsop_start(struct mount *mp, int flags)  puffs_start(struct mount *mp, int flags, struct lwp *l)
 {  {
         struct puffs_mount *pmp = MPTOPUFFSMP(mp);          struct puffs_mount *pmp = MPTOPUFFSMP(mp);
   
Line 285  puffs_vfsop_start(struct mount *mp, int 
Line 285  puffs_vfsop_start(struct mount *mp, int 
 }  }
   
 int  int
 puffs_vfsop_unmount(struct mount *mp, int mntflags)  puffs_unmount(struct mount *mp, int mntflags, struct lwp *l)
 {  {
         PUFFS_MSG_VARS(vfs, unmount);          PUFFS_MSG_VARS(vfs, unmount);
         struct puffs_mount *pmp;          struct puffs_mount *pmp;
Line 320  puffs_vfsop_unmount(struct mount *mp, in
Line 320  puffs_vfsop_unmount(struct mount *mp, in
                 mutex_exit(&pmp->pmp_lock);                  mutex_exit(&pmp->pmp_lock);
   
                 PUFFS_MSG_ALLOC(vfs, unmount);                  PUFFS_MSG_ALLOC(vfs, unmount);
                 puffs_msg_setinfo(park_unmount,  
                     PUFFSOP_VFS, PUFFS_VFS_UNMOUNT, NULL);  
                 unmount_msg->pvfsr_flags = mntflags;                  unmount_msg->pvfsr_flags = mntflags;
                   puffs_cidcvt(&unmount_msg->pvfsr_cid, l);
   
                 PUFFS_MSG_ENQUEUEWAIT(pmp, park_unmount, error);                  error = puffs_msg_vfs(pmp, park_unmount, PUFFS_VFS_UNMOUNT);
                 PUFFS_MSG_RELEASE(unmount);                  PUFFS_MSG_RELEASE(unmount);
   
                 error = checkerr(pmp, error, __func__);                  error = checkerr(pmp, error, __func__);
Line 362  puffs_vfsop_unmount(struct mount *mp, in
Line 361  puffs_vfsop_unmount(struct mount *mp, in
                 cv_destroy(&pmp->pmp_msg_waiter_cv);                  cv_destroy(&pmp->pmp_msg_waiter_cv);
                 mutex_destroy(&pmp->pmp_lock);                  mutex_destroy(&pmp->pmp_lock);
   
                 fstrans_unmount(mp);                  free(pmp->pmp_pnodehash, M_PUFFS);
                 kmem_free(pmp->pmp_pnodehash, BUCKETALLOC(pmp->pmp_npnodehash));                  FREE(pmp, M_PUFFS);
                 kmem_free(pmp, sizeof(struct puffs_mount));  
                 error = 0;                  error = 0;
         } else {          } else {
                 mutex_exit(&pmp->pmp_lock);                  mutex_exit(&pmp->pmp_lock);
Line 379  puffs_vfsop_unmount(struct mount *mp, in
Line 377  puffs_vfsop_unmount(struct mount *mp, in
  * This doesn't need to travel to userspace   * This doesn't need to travel to userspace
  */   */
 int  int
 puffs_vfsop_root(struct mount *mp, struct vnode **vpp)  puffs_root(struct mount *mp, struct vnode **vpp)
 {  {
         struct puffs_mount *pmp = MPTOPUFFSMP(mp);          struct puffs_mount *pmp = MPTOPUFFSMP(mp);
         int rv;          int rv;
Line 390  puffs_vfsop_root(struct mount *mp, struc
Line 388  puffs_vfsop_root(struct mount *mp, struc
 }  }
   
 int  int
 puffs_vfsop_statvfs(struct mount *mp, struct statvfs *sbp)  puffs_statvfs(struct mount *mp, struct statvfs *sbp, struct lwp *l)
 {  {
         PUFFS_MSG_VARS(vfs, statvfs);          PUFFS_MSG_VARS(vfs, statvfs);
         struct puffs_mount *pmp;          struct puffs_mount *pmp;
Line 408  puffs_vfsop_statvfs(struct mount *mp, st
Line 406  puffs_vfsop_statvfs(struct mount *mp, st
                 return EINPROGRESS;                  return EINPROGRESS;
   
         PUFFS_MSG_ALLOC(vfs, statvfs);          PUFFS_MSG_ALLOC(vfs, statvfs);
         puffs_msg_setinfo(park_statvfs, PUFFSOP_VFS, PUFFS_VFS_STATVFS, NULL);          puffs_cidcvt(&statvfs_msg->pvfsr_cid, l);
   
         PUFFS_MSG_ENQUEUEWAIT(pmp, park_statvfs, error);          error = puffs_msg_vfs(pmp, park_statvfs, PUFFS_VFS_STATVFS);
         error = checkerr(pmp, error, __func__);          error = checkerr(pmp, error, __func__);
         statvfs_msg->pvfsr_sb.f_iosize = DEV_BSIZE;          statvfs_msg->pvfsr_sb.f_iosize = DEV_BSIZE;
   
Line 433  puffs_vfsop_statvfs(struct mount *mp, st
Line 431  puffs_vfsop_statvfs(struct mount *mp, st
 }  }
   
 static int  static int
 pageflush(struct mount *mp, kauth_cred_t cred, int waitfor, int suspending)  pageflush(struct mount *mp, kauth_cred_t cred,
           int waitfor, int suspending, struct lwp *l)
 {  {
         struct puffs_node *pn;          struct puffs_node *pn;
         struct vnode *vp, *mvp;          struct vnode *vp, *nvp;
         int error, rv;          int error, rv;
   
         KASSERT(((waitfor == MNT_WAIT) && suspending) == 0);          KASSERT(((waitfor == MNT_WAIT) && suspending) == 0);
Line 446  pageflush(struct mount *mp, kauth_cred_t
Line 445  pageflush(struct mount *mp, kauth_cred_t
   
         error = 0;          error = 0;
   
         /* Allocate a marker vnode. */  
         if ((mvp = vnalloc(mp)) == NULL)  
                 return ENOMEM;  
   
         /*          /*
          * Sync all cached data from regular vnodes (which are not           * Sync all cached data from regular vnodes (which are not
          * currently locked, see below).  After this we call VFS_SYNC           * currently locked, see below).  After this we call VFS_SYNC
          * for the fs server, which should handle data and metadata for           * for the fs server, which should handle data and metadata for
          * all the nodes it knows to exist.           * all the nodes it knows to exist.
          */           */
         mutex_enter(&mntvnode_lock);          simple_lock(&mntvnode_slock);
  loop:   loop:
         for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = vunmark(mvp)) {          for (vp = TAILQ_FIRST(&mp->mnt_vnodelist); vp; vp = nvp) {
                 vmark(mvp, vp);                  /* check if we're on the right list */
                 if (vp->v_mount != mp || vismarker(vp))                  if (vp->v_mount != mp)
                         continue;                          goto loop;
   
                 mutex_enter(&vp->v_interlock);                  simple_lock(&vp->v_interlock);
                 pn = VPTOPP(vp);                  pn = VPTOPP(vp);
                   nvp = TAILQ_NEXT(vp, v_mntvnodes);
   
                 if (vp->v_type != VREG || UVM_OBJ_IS_CLEAN(&vp->v_uobj)) {                  if (vp->v_type != VREG || UVM_OBJ_IS_CLEAN(&vp->v_uobj)) {
                         mutex_exit(&vp->v_interlock);                          simple_unlock(&vp->v_interlock);
                         continue;                          continue;
                 }                  }
   
                 mutex_exit(&mntvnode_lock);                  simple_unlock(&mntvnode_slock);
   
                 /*                  /*
                  * Here we try to get a reference to the vnode and to                   * Here we try to get a reference to the vnode and to
Line 492  pageflush(struct mount *mp, kauth_cred_t
Line 489  pageflush(struct mount *mp, kauth_cred_t
                  */                   */
                 rv = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);                  rv = vget(vp, LK_EXCLUSIVE | LK_NOWAIT | LK_INTERLOCK);
                 if (rv) {                  if (rv) {
                         mutex_enter(&mntvnode_lock);                          simple_lock(&mntvnode_slock);
                         if (rv == ENOENT) {                          if (rv == ENOENT)
                                 (void)vunmark(mvp);  
                                 goto loop;                                  goto loop;
                         }  
                         continue;                          continue;
                 }                  }
   
Line 522  pageflush(struct mount *mp, kauth_cred_t
Line 517  pageflush(struct mount *mp, kauth_cred_t
                  * TODO: Maybe also hint the user server of this twist?                   * TODO: Maybe also hint the user server of this twist?
                  */                   */
                 if (suspending || waitfor == MNT_LAZY) {                  if (suspending || waitfor == MNT_LAZY) {
                         mutex_enter(&vp->v_interlock);                          simple_lock(&vp->v_interlock);
                         pn->pn_stat |= PNODE_SUSPEND;                          pn->pn_stat |= PNODE_SUSPEND;
                         mutex_exit(&vp->v_interlock);                          simple_unlock(&vp->v_interlock);
                 }                  }
                 rv = VOP_FSYNC(vp, cred, waitfor, 0, 0);                  rv = VOP_FSYNC(vp, cred, waitfor, 0, 0, l);
                 if (suspending || waitfor == MNT_LAZY) {                  if (suspending || waitfor == MNT_LAZY) {
                         mutex_enter(&vp->v_interlock);                          simple_lock(&vp->v_interlock);
                         pn->pn_stat &= ~PNODE_SUSPEND;                          pn->pn_stat &= ~PNODE_SUSPEND;
                         mutex_exit(&vp->v_interlock);                          simple_unlock(&vp->v_interlock);
                 }                  }
                 if (rv)                  if (rv)
                         error = rv;                          error = rv;
                 vput(vp);                  vput(vp);
                 mutex_enter(&mntvnode_lock);                  simple_lock(&mntvnode_slock);
         }          }
         mutex_exit(&mntvnode_lock);          simple_unlock(&mntvnode_slock);
         vnfree(mvp);  
   
         return error;          return error;
 }  }
   
 int  int
 puffs_vfsop_sync(struct mount *mp, int waitfor, struct kauth_cred *cred)  puffs_sync(struct mount *mp, int waitfor, struct kauth_cred *cred,
           struct lwp *l)
 {  {
         PUFFS_MSG_VARS(vfs, sync);          PUFFS_MSG_VARS(vfs, sync);
         struct puffs_mount *pmp = MPTOPUFFSMP(mp);          struct puffs_mount *pmp = MPTOPUFFSMP(mp);
         int error, rv;          int error, rv;
   
         error = pageflush(mp, cred, waitfor, 0);          error = pageflush(mp, cred, waitfor, 0, l);
   
         /* sync fs */          /* sync fs */
         PUFFS_MSG_ALLOC(vfs, sync);          PUFFS_MSG_ALLOC(vfs, sync);
         sync_msg->pvfsr_waitfor = waitfor;          sync_msg->pvfsr_waitfor = waitfor;
         puffs_credcvt(&sync_msg->pvfsr_cred, cred);          puffs_credcvt(&sync_msg->pvfsr_cred, cred);
         puffs_msg_setinfo(park_sync, PUFFSOP_VFS, PUFFS_VFS_SYNC, NULL);          puffs_cidcvt(&sync_msg->pvfsr_cid, l);
   
         PUFFS_MSG_ENQUEUEWAIT(pmp, park_sync, rv);          rv = puffs_msg_vfs(pmp, park_sync, PUFFS_VFS_SYNC);
         rv = checkerr(pmp, rv, __func__);          rv = checkerr(pmp, rv, __func__);
         if (rv)          if (rv)
                 error = rv;                  error = rv;
Line 568  puffs_vfsop_sync(struct mount *mp, int w
Line 563  puffs_vfsop_sync(struct mount *mp, int w
 }  }
   
 int  int
 puffs_vfsop_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)  puffs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
 {  {
         PUFFS_MSG_VARS(vfs, fhtonode);          PUFFS_MSG_VARS(vfs, fhtonode);
         struct puffs_mount *pmp = MPTOPUFFSMP(mp);          struct puffs_mount *pmp = MPTOPUFFSMP(mp);
Line 597  puffs_vfsop_fhtovp(struct mount *mp, str
Line 592  puffs_vfsop_fhtovp(struct mount *mp, str
         }          }
   
         argsize = sizeof(struct puffs_vfsmsg_fhtonode) + fhlen;          argsize = sizeof(struct puffs_vfsmsg_fhtonode) + fhlen;
         puffs_msgmem_alloc(argsize, &park_fhtonode, (void *)&fhtonode_msg, 1);          puffs_msgmem_alloc(argsize, &park_fhtonode, (void **)&fhtonode_msg, 1);
         fhtonode_msg->pvfsr_dsize = fhlen;          fhtonode_msg->pvfsr_dsize = fhlen;
         memcpy(fhtonode_msg->pvfsr_data, fhdata, fhlen);          memcpy(fhtonode_msg->pvfsr_data, fhdata, fhlen);
         puffs_msg_setinfo(park_fhtonode, PUFFSOP_VFS, PUFFS_VFS_FHTOVP, NULL);  
   
         PUFFS_MSG_ENQUEUEWAIT(pmp, park_fhtonode, error);          error = puffs_msg_vfs(pmp, park_fhtonode, PUFFS_VFS_FHTOVP);
         error = checkerr(pmp, error, __func__);          error = checkerr(pmp, error, __func__);
         if (error)          if (error)
                 goto out;                  goto out;
Line 628  puffs_vfsop_fhtovp(struct mount *mp, str
Line 622  puffs_vfsop_fhtovp(struct mount *mp, str
 }  }
   
 int  int
 puffs_vfsop_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)  puffs_vptofh(struct vnode *vp, struct fid *fhp, size_t *fh_size)
 {  {
         PUFFS_MSG_VARS(vfs, nodetofh);          PUFFS_MSG_VARS(vfs, nodetofh);
         struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);          struct puffs_mount *pmp = MPTOPUFFSMP(vp->v_mount);
Line 652  puffs_vfsop_vptofh(struct vnode *vp, str
Line 646  puffs_vfsop_vptofh(struct vnode *vp, str
                 fhlen = PUFFS_FROMFHSIZE(*fh_size);                  fhlen = PUFFS_FROMFHSIZE(*fh_size);
   
         argsize = sizeof(struct puffs_vfsmsg_nodetofh) + fhlen;          argsize = sizeof(struct puffs_vfsmsg_nodetofh) + fhlen;
         puffs_msgmem_alloc(argsize, &park_nodetofh, (void *)&nodetofh_msg, 1);          puffs_msgmem_alloc(argsize, &park_nodetofh, (void **)&nodetofh_msg, 1);
         nodetofh_msg->pvfsr_fhcookie = VPTOPNC(vp);          nodetofh_msg->pvfsr_fhcookie = VPTOPNC(vp);
         nodetofh_msg->pvfsr_dsize = fhlen;          nodetofh_msg->pvfsr_dsize = fhlen;
         puffs_msg_setinfo(park_nodetofh, PUFFSOP_VFS, PUFFS_VFS_VPTOFH, NULL);  
   
         PUFFS_MSG_ENQUEUEWAIT(pmp, park_nodetofh, error);          error = puffs_msg_vfs(pmp, park_nodetofh, PUFFS_VFS_VPTOFH);
         error = checkerr(pmp, error, __func__);          error = checkerr(pmp, error, __func__);
   
         if (pmp->pmp_args.pa_fhflags & PUFFS_FHFLAG_PASSTHROUGH)          if (pmp->pmp_args.pa_fhflags & PUFFS_FHFLAG_PASSTHROUGH)
Line 674  puffs_vfsop_vptofh(struct vnode *vp, str
Line 667  puffs_vfsop_vptofh(struct vnode *vp, str
         }          }
   
         if (fhlen > FHANDLE_SIZE_MAX) {          if (fhlen > FHANDLE_SIZE_MAX) {
                 puffs_senderr(pmp, PUFFS_ERR_VPTOFH, E2BIG,                  puffs_msg_errnotify(pmp, PUFFS_ERR_VPTOFH, E2BIG,
                     "file handle too big", VPTOPNC(vp));                      "file handle too big", VPTOPNC(vp));
                 error = EPROTO;                  error = EPROTO;
                 goto out;                  goto out;
Line 703  puffs_vfsop_vptofh(struct vnode *vp, str
Line 696  puffs_vfsop_vptofh(struct vnode *vp, str
 }  }
   
 void  void
 puffs_vfsop_init()  puffs_init()
 {  {
   
         /* some checks depend on this */          /* some checks depend on this */
         KASSERT(VNOVAL == VSIZENOTSET);          KASSERT(VNOVAL == VSIZENOTSET);
   
           malloc_type_attach(M_PUFFS);
   
         pool_init(&puffs_pnpool, sizeof(struct puffs_node), 0, 0, 0,          pool_init(&puffs_pnpool, sizeof(struct puffs_node), 0, 0, 0,
             "puffpnpl", &pool_allocator_nointr, IPL_NONE);              "puffpnpl", &pool_allocator_nointr, IPL_NONE);
         puffs_msgif_init();          puffs_msgif_init();
 }  }
   
 void  void
 puffs_vfsop_done()  puffs_done()
 {  {
   
         puffs_msgif_destroy();          puffs_msgif_destroy();
         pool_destroy(&puffs_pnpool);          pool_destroy(&puffs_pnpool);
   
           malloc_type_detach(M_PUFFS);
 }  }
   
 int  int
 puffs_vfsop_snapshot(struct mount *mp, struct vnode *vp, struct timespec *ts)  puffs_snapshot(struct mount *mp, struct vnode *vp, struct timespec *ts)
 {  {
   
         return EOPNOTSUPP;          return EOPNOTSUPP;
 }  }
   
 int  int
 puffs_vfsop_suspendctl(struct mount *mp, int cmd)  puffs_suspendctl(struct mount *mp, int cmd)
 {  {
         PUFFS_MSG_VARS(vfs, suspend);          PUFFS_MSG_VARS(vfs, suspend);
         struct puffs_mount *pmp;          struct puffs_mount *pmp;
Line 745  puffs_vfsop_suspendctl(struct mount *mp,
Line 742  puffs_vfsop_suspendctl(struct mount *mp,
                 PUFFS_MSG_ALLOC(vfs, suspend);                  PUFFS_MSG_ALLOC(vfs, suspend);
                 puffs_msg_setfaf(park_suspend);                  puffs_msg_setfaf(park_suspend);
                 suspend_msg->pvfsr_status = PUFFS_SUSPEND_START;                  suspend_msg->pvfsr_status = PUFFS_SUSPEND_START;
                 puffs_msg_setinfo(park_suspend, PUFFSOP_VFS,                  puffs_msg_vfs(pmp, park_suspend, PUFFS_VFS_SUSPEND);
                     PUFFS_VFS_SUSPEND, NULL);  
   
                 puffs_msg_enqueue(pmp, park_suspend);  
                 PUFFS_MSG_RELEASE(suspend);                  PUFFS_MSG_RELEASE(suspend);
   
                 error = pageflush(mp, FSCRED, 0, 1);                  error = pageflush(mp, FSCRED, 0, 1, curlwp);
                 if (error == 0)                  if (error == 0)
                         error = fstrans_setstate(mp, FSTRANS_SUSPENDED);                          error = fstrans_setstate(mp, FSTRANS_SUSPENDED);
   
Line 759  puffs_vfsop_suspendctl(struct mount *mp,
Line 753  puffs_vfsop_suspendctl(struct mount *mp,
                         PUFFS_MSG_ALLOC(vfs, suspend);                          PUFFS_MSG_ALLOC(vfs, suspend);
                         puffs_msg_setfaf(park_suspend);                          puffs_msg_setfaf(park_suspend);
                         suspend_msg->pvfsr_status = PUFFS_SUSPEND_ERROR;                          suspend_msg->pvfsr_status = PUFFS_SUSPEND_ERROR;
                         puffs_msg_setinfo(park_suspend, PUFFSOP_VFS,                          puffs_msg_vfs(pmp, park_suspend, PUFFS_VFS_SUSPEND);
                             PUFFS_VFS_SUSPEND, NULL);  
   
                         puffs_msg_enqueue(pmp, park_suspend);  
                         PUFFS_MSG_RELEASE(suspend);                          PUFFS_MSG_RELEASE(suspend);
                         (void) fstrans_setstate(mp, FSTRANS_NORMAL);                          (void) fstrans_setstate(mp, FSTRANS_NORMAL);
                         break;                          break;
Line 771  puffs_vfsop_suspendctl(struct mount *mp,
Line 762  puffs_vfsop_suspendctl(struct mount *mp,
                 PUFFS_MSG_ALLOC(vfs, suspend);                  PUFFS_MSG_ALLOC(vfs, suspend);
                 puffs_msg_setfaf(park_suspend);                  puffs_msg_setfaf(park_suspend);
                 suspend_msg->pvfsr_status = PUFFS_SUSPEND_SUSPENDED;                  suspend_msg->pvfsr_status = PUFFS_SUSPEND_SUSPENDED;
                 puffs_msg_setinfo(park_suspend, PUFFSOP_VFS,                  puffs_msg_vfs(pmp, park_suspend, PUFFS_VFS_SUSPEND);
                     PUFFS_VFS_SUSPEND, NULL);  
   
                 puffs_msg_enqueue(pmp, park_suspend);  
                 PUFFS_MSG_RELEASE(suspend);                  PUFFS_MSG_RELEASE(suspend);
   
                 break;                  break;
Line 786  puffs_vfsop_suspendctl(struct mount *mp,
Line 774  puffs_vfsop_suspendctl(struct mount *mp,
                 PUFFS_MSG_ALLOC(vfs, suspend);                  PUFFS_MSG_ALLOC(vfs, suspend);
                 puffs_msg_setfaf(park_suspend);                  puffs_msg_setfaf(park_suspend);
                 suspend_msg->pvfsr_status = PUFFS_SUSPEND_RESUME;                  suspend_msg->pvfsr_status = PUFFS_SUSPEND_RESUME;
                 puffs_msg_setinfo(park_suspend, PUFFSOP_VFS,                  puffs_msg_vfs(pmp, park_suspend, PUFFS_VFS_SUSPEND);
                     PUFFS_VFS_SUSPEND, NULL);  
   
                 puffs_msg_enqueue(pmp, park_suspend);  
                 PUFFS_MSG_RELEASE(suspend);                  PUFFS_MSG_RELEASE(suspend);
                 break;                  break;
   
Line 813  const struct vnodeopv_desc * const puffs
Line 798  const struct vnodeopv_desc * const puffs
 struct vfsops puffs_vfsops = {  struct vfsops puffs_vfsops = {
         MOUNT_PUFFS,          MOUNT_PUFFS,
         sizeof (struct puffs_kargs),          sizeof (struct puffs_kargs),
         puffs_vfsop_mount,              /* mount        */          puffs_mount,            /* mount        */
         puffs_vfsop_start,              /* start        */          puffs_start,            /* start        */
         puffs_vfsop_unmount,            /* unmount      */          puffs_unmount,          /* unmount      */
         puffs_vfsop_root,               /* root         */          puffs_root,             /* root         */
         (void *)eopnotsupp,             /* quotactl     */          (void *)eopnotsupp,     /* quotactl     */
         puffs_vfsop_statvfs,            /* statvfs      */          puffs_statvfs,          /* statvfs      */
         puffs_vfsop_sync,               /* sync         */          puffs_sync,             /* sync         */
         (void *)eopnotsupp,             /* vget         */          (void *)eopnotsupp,     /* vget         */
         puffs_vfsop_fhtovp,             /* fhtovp       */          puffs_fhtovp,           /* fhtovp       */
         puffs_vfsop_vptofh,             /* vptofh       */          puffs_vptofh,           /* vptofh       */
         puffs_vfsop_init,               /* init         */          puffs_init,             /* init         */
         NULL,                           /* reinit       */          NULL,                   /* reinit       */
         puffs_vfsop_done,               /* done         */          puffs_done,             /* done         */
         NULL,                           /* mountroot    */          NULL,                   /* mountroot    */
         puffs_vfsop_snapshot,           /* snapshot     */          puffs_snapshot,         /* snapshot     */
         vfs_stdextattrctl,              /* extattrctl   */          vfs_stdextattrctl,      /* extattrctl   */
         puffs_vfsop_suspendctl,         /* suspendctl   */          puffs_suspendctl,       /* suspendctl   */
         genfs_renamelock_enter,          puffs_vnodeopv_descs,   /* vnodeops     */
         genfs_renamelock_exit,          0,                      /* refcount     */
         puffs_vnodeopv_descs,           /* vnodeops     */  
         0,                              /* refcount     */  
         { NULL, NULL }          { NULL, NULL }
 };  };
 VFS_ATTACH(puffs_vfsops);  VFS_ATTACH(puffs_vfsops);
Legend:
Removed from v.1.65.4.3  
changed lines
  Added in v.1.66
CVSweb <webmaster@jp.NetBSD.org>