[BACK]Return to kernfs_vnops.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / miscfs / kernfs

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

Diff for /src/sys/miscfs/kernfs/kernfs_vnops.c between version 1.56 and 1.57

version 1.56, 1998/02/12 20:38:45 version 1.57, 1998/03/01 02:21:04
Line 35 
Line 35 
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.   * SUCH DAMAGE.
  *   *
  *      @(#)kernfs_vnops.c      8.9 (Berkeley) 6/15/94   *      @(#)kernfs_vnops.c      8.15 (Berkeley) 5/21/95
  */   */
   
 /*  /*
Line 119  int kernfs_read __P((void *));
Line 119  int kernfs_read __P((void *));
 int     kernfs_write    __P((void *));  int     kernfs_write    __P((void *));
 #define kernfs_ioctl    genfs_eopnotsupp  #define kernfs_ioctl    genfs_eopnotsupp
 #define kernfs_poll     genfs_poll  #define kernfs_poll     genfs_poll
   #define kernfs_revoke   genfs_revoke
 #define kernfs_mmap     genfs_eopnotsupp  #define kernfs_mmap     genfs_eopnotsupp
 #define kernfs_fsync    genfs_nullop  #define kernfs_fsync    genfs_nullop
 #define kernfs_seek     genfs_nullop  #define kernfs_seek     genfs_nullop
Line 133  int kernfs_readdir __P((void *));
Line 134  int kernfs_readdir __P((void *));
 #define kernfs_abortop  genfs_abortop  #define kernfs_abortop  genfs_abortop
 int     kernfs_inactive __P((void *));  int     kernfs_inactive __P((void *));
 int     kernfs_reclaim  __P((void *));  int     kernfs_reclaim  __P((void *));
 #define kernfs_lock     genfs_nullop  #define kernfs_lock     genfs_nolock
 #define kernfs_unlock   genfs_nullop  #define kernfs_unlock   genfs_nounlock
 #define kernfs_bmap     genfs_badop  #define kernfs_bmap     genfs_badop
 #define kernfs_strategy genfs_badop  #define kernfs_strategy genfs_badop
 int     kernfs_print    __P((void *));  int     kernfs_print    __P((void *));
 #define kernfs_islocked genfs_nullop  #define kernfs_islocked genfs_noislocked
 int     kernfs_pathconf __P((void *));  int     kernfs_pathconf __P((void *));
 #define kernfs_advlock  genfs_eopnotsupp  #define kernfs_advlock  genfs_eopnotsupp
 #define kernfs_blkatoff genfs_eopnotsupp  #define kernfs_blkatoff genfs_eopnotsupp
Line 166  struct vnodeopv_entry_desc kernfs_vnodeo
Line 167  struct vnodeopv_entry_desc kernfs_vnodeo
         { &vop_write_desc, kernfs_write },              /* write */          { &vop_write_desc, kernfs_write },              /* write */
         { &vop_ioctl_desc, kernfs_ioctl },              /* ioctl */          { &vop_ioctl_desc, kernfs_ioctl },              /* ioctl */
         { &vop_poll_desc, kernfs_poll },                /* poll */          { &vop_poll_desc, kernfs_poll },                /* poll */
           { &vop_revoke_desc, kernfs_revoke },            /* revoke */
         { &vop_mmap_desc, kernfs_mmap },                /* mmap */          { &vop_mmap_desc, kernfs_mmap },                /* mmap */
         { &vop_fsync_desc, kernfs_fsync },              /* fsync */          { &vop_fsync_desc, kernfs_fsync },              /* fsync */
         { &vop_seek_desc, kernfs_seek },                /* seek */          { &vop_seek_desc, kernfs_seek },                /* seek */
Line 346  kernfs_lookup(v)
Line 348  kernfs_lookup(v)
         if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)          if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
                 return (EROFS);                  return (EROFS);
   
           VOP_UNLOCK(dvp, 0);
         if (cnp->cn_namelen == 1 && *pname == '.') {          if (cnp->cn_namelen == 1 && *pname == '.') {
                 *vpp = dvp;                  *vpp = dvp;
                 VREF(dvp);                  VREF(dvp);
                 /*VOP_LOCK(dvp);*/                  vn_lock(dvp, LK_SHARED | LK_RETRY);
                 return (0);                  return (0);
         }          }
   
Line 357  kernfs_lookup(v)
Line 360  kernfs_lookup(v)
         if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) {          if (cnp->cn_namelen == 4 && bcmp(pname, "root", 4) == 0) {
                 *vpp = rootdir;                  *vpp = rootdir;
                 VREF(rootdir);                  VREF(rootdir);
                 VOP_LOCK(rootdir);                  vn_lock(rootdir, LK_SHARED | LK_RETRY);
                 return (0);                  return (0);
         }          }
 #endif  #endif
Line 372  kernfs_lookup(v)
Line 375  kernfs_lookup(v)
         printf("kernfs_lookup: i = %d, failed", i);          printf("kernfs_lookup: i = %d, failed", i);
 #endif  #endif
   
           vn_lock(dvp, LK_SHARED | LK_RETRY);
         return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);          return (cnp->cn_nameiop == LOOKUP ? ENOENT : EROFS);
   
 found:  found:
         if (kt->kt_tag == KTT_DEVICE) {          if (kt->kt_tag == KTT_DEVICE) {
                 dev_t *dp = kt->kt_data;                  dev_t *dp = kt->kt_data;
         loop:          loop:
                 if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp))                  if (*dp == NODEV || !vfinddev(*dp, kt->kt_vtype, &fvp)) {
                           vn_lock(dvp, LK_SHARED | LK_RETRY);
                         return (ENOENT);                          return (ENOENT);
                   }
                 *vpp = fvp;                  *vpp = fvp;
                 if (vget(fvp, 1))                  if (vget(fvp, LK_EXCLUSIVE))
                         goto loop;                          goto loop;
                 return (0);                  return (0);
         }          }
Line 390  found:
Line 396  found:
         printf("kernfs_lookup: allocate new vnode\n");          printf("kernfs_lookup: allocate new vnode\n");
 #endif  #endif
         error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, &fvp);          error = getnewvnode(VT_KERNFS, dvp->v_mount, kernfs_vnodeop_p, &fvp);
         if (error)          if (error) {
                   vn_lock(dvp, LK_SHARED | LK_RETRY);
                 return (error);                  return (error);
           }
   
         MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP,          MALLOC(fvp->v_data, void *, sizeof(struct kernfs_node), M_TEMP,
             M_WAITOK);              M_WAITOK);
         VTOKERN(fvp)->kf_kt = kt;          VTOKERN(fvp)->kf_kt = kt;
         fvp->v_type = kt->kt_vtype;          fvp->v_type = kt->kt_vtype;
           vn_lock(fvp, LK_SHARED | LK_RETRY);
         *vpp = fvp;          *vpp = fvp;
   
 #ifdef KERNFS_DIAGNOSTIC  #ifdef KERNFS_DIAGNOSTIC
Line 479  kernfs_getattr(v)
Line 488  kernfs_getattr(v)
                 vap->va_type = kt->kt_vtype;                  vap->va_type = kt->kt_vtype;
                 vap->va_mode = kt->kt_mode;                  vap->va_mode = kt->kt_mode;
                 vap->va_nlink = 1;                  vap->va_nlink = 1;
                 vap->va_fileid = 3 + (kt - kern_targets);                  vap->va_fileid = 1 + (kt - kern_targets);
                 total = 0;                  total = 0;
                 while (buf = strbuf,                  while (buf = strbuf,
                        nbytes = kernfs_xread(kt, total, &buf, sizeof(strbuf)))                         nbytes = kernfs_xread(kt, total, &buf, sizeof(strbuf)))
Line 592  kernfs_readdir(v)
Line 601  kernfs_readdir(v)
                 struct uio *a_uio;                  struct uio *a_uio;
                 struct ucred *a_cred;                  struct ucred *a_cred;
                 int *a_eofflag;                  int *a_eofflag;
                 off_t *a_cookies;                  off_t **a_cookies;
                 int a_ncookies;                  int a_*ncookies;
         } */ *ap = v;          } */ *ap = v;
         struct uio *uio = ap->a_uio;          struct uio *uio = ap->a_uio;
         struct dirent d;          struct dirent d;
         struct kern_target *kt;          struct kern_target *kt;
         int i;          int i;
         int error;          int error;
         off_t *cookies = ap->a_cookies;          off_t *cookies = NULL;
         int ncookies = ap->a_ncookies;          int ncookies = 0, nc = 0;
   
         if (ap->a_vp->v_type != VDIR)          if (ap->a_vp->v_type != VDIR)
                 return (ENOTDIR);                  return (ENOTDIR);
Line 616  kernfs_readdir(v)
Line 625  kernfs_readdir(v)
         bzero((caddr_t)&d, UIO_MX);          bzero((caddr_t)&d, UIO_MX);
         d.d_reclen = UIO_MX;          d.d_reclen = UIO_MX;
   
           if (ap->a_ncookies) {
                   nc = uio->uio_resid / UIO_MX;
                   nc = min(nc, (nkern_targets - i));
                   MALLOC(cookies, off_t *, nc * sizeof(off_t), M_TEMP,
                       M_WAITOK);
                   *ap->a_cookies = cookies;
           }
   
         for (kt = &kern_targets[i];          for (kt = &kern_targets[i];
              uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) {               uio->uio_resid >= UIO_MX && i < nkern_targets; kt++, i++) {
 #ifdef KERNFS_DIAGNOSTIC  #ifdef KERNFS_DIAGNOSTIC
Line 637  kernfs_readdir(v)
Line 654  kernfs_readdir(v)
   
                 if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0)                  if ((error = uiomove((caddr_t)&d, UIO_MX, uio)) != 0)
                         break;                          break;
                 if (ncookies-- > 0)                  if (cookies) {
                         *cookies++ = i + 1;                          *cookies++ = i + 1;
                           ncookies++;
                   }
           }
   
           if (ap->a_ncookies) {
                   if (error) {
                           FREE(*ap->a_cookies, M_TEMP);
                           *ap->a_ncookies = 0;
                           *ap->a_cookies = NULL;
                   } else
                           *ap->a_ncookies = ncookies;
         }          }
   
         uio->uio_offset = i;          uio->uio_offset = i;
Line 651  kernfs_inactive(v)
Line 679  kernfs_inactive(v)
 {  {
         struct vop_inactive_args /* {          struct vop_inactive_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                   struct proc *a_p;
         } */ *ap = v;          } */ *ap = v;
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
   
Line 661  kernfs_inactive(v)
Line 690  kernfs_inactive(v)
          * Clear out the v_type field to avoid           * Clear out the v_type field to avoid
          * nasty things happening in vgone().           * nasty things happening in vgone().
          */           */
           VOP_UNLOCK(vp, 0);
         vp->v_type = VNON;          vp->v_type = VNON;
         return (0);          return (0);
 }  }
Legend:
Removed from v.1.56  
changed lines
  Added in v.1.57
CVSweb <webmaster@jp.NetBSD.org>