[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.106 and 1.129

version 1.106, 2004/10/27 06:55:53 version 1.129, 2006/12/09 16:11:52
Line 90  const struct kern_target kern_targets[] 
Line 90  const struct kern_target kern_targets[] 
      { DT_DIR, N("."),         0,            KFSkern,        VDIR, DIR_MODE   },       { DT_DIR, N("."),         0,            KFSkern,        VDIR, DIR_MODE   },
      { DT_DIR, N(".."),        0,            KFSroot,        VDIR, DIR_MODE   },       { DT_DIR, N(".."),        0,            KFSroot,        VDIR, DIR_MODE   },
      { DT_REG, N("boottime"),  &boottime.tv_sec, KFSint,     VREG, READ_MODE  },       { DT_REG, N("boottime"),  &boottime.tv_sec, KFSint,     VREG, READ_MODE  },
                         /* XXX cast away const */                          /* XXXUNCONST */
      { DT_REG, N("copyright"), (void *)copyright,       { DT_REG, N("copyright"), __UNCONST(copyright),
                                              KFSstring,      VREG, READ_MODE  },                                               KFSstring,      VREG, READ_MODE  },
      { DT_REG, N("hostname"),  0,            KFShostname,    VREG, WRITE_MODE },       { DT_REG, N("hostname"),  0,            KFShostname,    VREG, WRITE_MODE },
      { DT_REG, N("hz"),        &hz,          KFSint,         VREG, READ_MODE  },       { DT_REG, N("hz"),        &hz,          KFSint,         VREG, READ_MODE  },
Line 109  const struct kern_target kern_targets[] 
Line 109  const struct kern_target kern_targets[] 
      { DT_BLK, N("rootdev"),   &rootdev,     KFSdevice,      VBLK, READ_MODE  },       { DT_BLK, N("rootdev"),   &rootdev,     KFSdevice,      VBLK, READ_MODE  },
      { DT_CHR, N("rrootdev"),  &rrootdev,    KFSdevice,      VCHR, READ_MODE  },       { DT_CHR, N("rrootdev"),  &rrootdev,    KFSdevice,      VCHR, READ_MODE  },
      { DT_REG, N("time"),      0,            KFStime,        VREG, READ_MODE  },       { DT_REG, N("time"),      0,            KFStime,        VREG, READ_MODE  },
                         /* XXX cast away const */                          /* XXXUNCONST */
      { DT_REG, N("version"),   (void *)version,       { DT_REG, N("version"),   __UNCONST(version),
                                              KFSstring,      VREG, READ_MODE  },                                               KFSstring,      VREG, READ_MODE  },
 };  };
 const struct kern_target subdir_targets[] = {  const struct kern_target subdir_targets[] = {
Line 151  int nkern_dirs = 2;
Line 151  int nkern_dirs = 2;
 #endif  #endif
   
 int kernfs_try_fileop(kfstype, kfsfileop, void *, int);  int kernfs_try_fileop(kfstype, kfsfileop, void *, int);
   int kernfs_try_xread(kfstype, const struct kernfs_node *, char **,
       size_t, int);
 int kernfs_try_xwrite(kfstype, const struct kernfs_node *, char *,  int kernfs_try_xwrite(kfstype, const struct kernfs_node *, char *,
     size_t, int);      size_t, int);
   
   static int kernfs_default_xread(void *v);
 static int kernfs_default_xwrite(void *v);  static int kernfs_default_xwrite(void *v);
 static int kernfs_default_fileop_getattr(void *);  static int kernfs_default_fileop_getattr(void *);
   
 /* must include all fileop's */  /* must include all fileop's */
 const struct kernfs_fileop kernfs_default_fileops[] = {  const struct kernfs_fileop kernfs_default_fileops[] = {
     { .kf_fileop = KERNFS_XREAD },
   { .kf_fileop = KERNFS_XWRITE },    { .kf_fileop = KERNFS_XWRITE },
   { .kf_fileop = KERNFS_FILEOP_OPEN },    { .kf_fileop = KERNFS_FILEOP_OPEN },
   { .kf_fileop = KERNFS_FILEOP_GETATTR,    { .kf_fileop = KERNFS_FILEOP_GETATTR,
     .kf_genop = {kernfs_default_fileop_getattr} },      .kf_vop = kernfs_default_fileop_getattr },
   { .kf_fileop = KERNFS_FILEOP_IOCTL },    { .kf_fileop = KERNFS_FILEOP_IOCTL },
   { .kf_fileop = KERNFS_FILEOP_MMAP },  
   { .kf_fileop = KERNFS_FILEOP_CLOSE },    { .kf_fileop = KERNFS_FILEOP_CLOSE },
   { .kf_fileop = KERNFS_FILEOP_WRITE, .kf_genop = {kernfs_default_xwrite} },    { .kf_fileop = KERNFS_FILEOP_READ,
       .kf_vop = kernfs_default_xread },
     { .kf_fileop = KERNFS_FILEOP_WRITE,
       .kf_vop = kernfs_default_xwrite },
 };  };
   
 int     kernfs_lookup   __P((void *));  int     kernfs_lookup(void *);
 #define kernfs_create   genfs_eopnotsupp  #define kernfs_create   genfs_eopnotsupp
 #define kernfs_mknod    genfs_eopnotsupp  #define kernfs_mknod    genfs_eopnotsupp
 int     kernfs_open     __P((void *));  int     kernfs_open(void *);
 int     kernfs_close    __P((void *));  int     kernfs_close(void *);
 int     kernfs_access   __P((void *));  int     kernfs_access(void *);
 int     kernfs_getattr  __P((void *));  int     kernfs_getattr(void *);
 int     kernfs_setattr  __P((void *));  int     kernfs_setattr(void *);
 int     kernfs_read     __P((void *));  int     kernfs_read(void *);
 int     kernfs_write    __P((void *));  int     kernfs_write(void *);
 #define kernfs_fcntl    genfs_fcntl  #define kernfs_fcntl    genfs_fcntl
 int     kernfs_ioctl    __P((void *));  int     kernfs_ioctl(void *);
 #define kernfs_poll     genfs_poll  #define kernfs_poll     genfs_poll
 #define kernfs_revoke   genfs_revoke  #define kernfs_revoke   genfs_revoke
 int     kernfs_mmap     __P((void *));  
 #define kernfs_fsync    genfs_nullop  #define kernfs_fsync    genfs_nullop
 #define kernfs_seek     genfs_nullop  #define kernfs_seek     genfs_nullop
 #define kernfs_remove   genfs_eopnotsupp  #define kernfs_remove   genfs_eopnotsupp
 int     kernfs_link     __P((void *));  int     kernfs_link(void *);
 #define kernfs_rename   genfs_eopnotsupp  #define kernfs_rename   genfs_eopnotsupp
 #define kernfs_mkdir    genfs_eopnotsupp  #define kernfs_mkdir    genfs_eopnotsupp
 #define kernfs_rmdir    genfs_eopnotsupp  #define kernfs_rmdir    genfs_eopnotsupp
 int     kernfs_symlink  __P((void *));  int     kernfs_symlink(void *);
 int     kernfs_readdir  __P((void *));  int     kernfs_readdir(void *);
 #define kernfs_readlink genfs_eopnotsupp  #define kernfs_readlink genfs_eopnotsupp
 #define kernfs_abortop  genfs_abortop  #define kernfs_abortop  genfs_abortop
 int     kernfs_inactive __P((void *));  int     kernfs_inactive(void *);
 int     kernfs_reclaim  __P((void *));  int     kernfs_reclaim(void *);
 #define kernfs_lock     genfs_lock  #define kernfs_lock     genfs_lock
 #define kernfs_unlock   genfs_unlock  #define kernfs_unlock   genfs_unlock
 #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(void *);
 #define kernfs_islocked genfs_islocked  #define kernfs_islocked genfs_islocked
 int     kernfs_pathconf __P((void *));  int     kernfs_pathconf(void *);
 #define kernfs_advlock  genfs_einval  #define kernfs_advlock  genfs_einval
 #define kernfs_blkatoff genfs_eopnotsupp  
 #define kernfs_valloc   genfs_eopnotsupp  
 #define kernfs_vfree    genfs_nullop  
 #define kernfs_truncate genfs_eopnotsupp  
 #define kernfs_update   genfs_nullop  
 #define kernfs_bwrite   genfs_eopnotsupp  #define kernfs_bwrite   genfs_eopnotsupp
 #define kernfs_putpages genfs_putpages  #define kernfs_putpages genfs_putpages
   
 static int      kernfs_xread __P((struct kernfs_node *, int, char **, size_t, size_t *));  static int      kernfs_xread(struct kernfs_node *, int, char **,
 static int      kernfs_xwrite __P((const struct kernfs_node *, char *, size_t));                                  size_t, size_t *);
   static int      kernfs_xwrite(const struct kernfs_node *, char *, size_t);
   
 int (**kernfs_vnodeop_p) __P((void *));  int (**kernfs_vnodeop_p)(void *);
 const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = {  const struct vnodeopv_entry_desc kernfs_vnodeop_entries[] = {
         { &vop_default_desc, vn_default_error },          { &vop_default_desc, vn_default_error },
         { &vop_lookup_desc, kernfs_lookup },            /* lookup */          { &vop_lookup_desc, kernfs_lookup },            /* lookup */
Line 233  const struct vnodeopv_entry_desc kernfs_
Line 234  const struct vnodeopv_entry_desc kernfs_
         { &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_revoke_desc, kernfs_revoke },            /* revoke */
         { &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 */
         { &vop_remove_desc, kernfs_remove },            /* remove */          { &vop_remove_desc, kernfs_remove },            /* remove */
Line 255  const struct vnodeopv_entry_desc kernfs_
Line 255  const struct vnodeopv_entry_desc kernfs_
         { &vop_islocked_desc, kernfs_islocked },        /* islocked */          { &vop_islocked_desc, kernfs_islocked },        /* islocked */
         { &vop_pathconf_desc, kernfs_pathconf },        /* pathconf */          { &vop_pathconf_desc, kernfs_pathconf },        /* pathconf */
         { &vop_advlock_desc, kernfs_advlock },          /* advlock */          { &vop_advlock_desc, kernfs_advlock },          /* advlock */
         { &vop_blkatoff_desc, kernfs_blkatoff },        /* blkatoff */  
         { &vop_valloc_desc, kernfs_valloc },            /* valloc */  
         { &vop_vfree_desc, kernfs_vfree },              /* vfree */  
         { &vop_truncate_desc, kernfs_truncate },        /* truncate */  
         { &vop_update_desc, kernfs_update },            /* update */  
         { &vop_bwrite_desc, kernfs_bwrite },            /* bwrite */          { &vop_bwrite_desc, kernfs_bwrite },            /* bwrite */
         { &vop_putpages_desc, kernfs_putpages },        /* putpages */          { &vop_putpages_desc, kernfs_putpages },        /* putpages */
         { NULL, NULL }          { NULL, NULL }
Line 267  const struct vnodeopv_entry_desc kernfs_
Line 262  const struct vnodeopv_entry_desc kernfs_
 const struct vnodeopv_desc kernfs_vnodeop_opv_desc =  const struct vnodeopv_desc kernfs_vnodeop_opv_desc =
         { &kernfs_vnodeop_p, kernfs_vnodeop_entries };          { &kernfs_vnodeop_p, kernfs_vnodeop_entries };
   
 static __inline int  static inline int
 kernfs_fileop_compare(struct kernfs_fileop *a, struct kernfs_fileop *b)  kernfs_fileop_compare(struct kernfs_fileop *a, struct kernfs_fileop *b)
 {  {
         if (a->kf_type < b->kf_type)          if (a->kf_type < b->kf_type)
Line 308  kernfs_alloctype(int nkf, const struct k
Line 303  kernfs_alloctype(int nkf, const struct k
                 skf.kf_type = nextfreetype;                  skf.kf_type = nextfreetype;
                 skf.kf_fileop = kf[i].kf_fileop;                  skf.kf_fileop = kf[i].kf_fileop;
                 if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))                  if ((fkf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
                         fkf->kf_genop = kf[i].kf_genop;                          fkf->kf_vop = kf[i].kf_vop;
         }          }
   
         return nextfreetype++;          return nextfreetype++;
Line 328  kernfs_try_fileop(kfstype type, kfsfileo
Line 323  kernfs_try_fileop(kfstype type, kfsfileo
 }  }
   
 int  int
 kernfs_try_xwrite(kfstype type, const struct kernfs_node *kfs, char *buf,  kernfs_try_xread(kfstype type, const struct kernfs_node *kfs, char **bfp,
       size_t len, int error)
   {
           struct kernfs_fileop *kf, skf;
   
           skf.kf_type = type;
           skf.kf_fileop = KERNFS_XREAD;
           if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
                   if (kf->kf_xread)
                           return kf->kf_xread(kfs, bfp, len);
           return error;
   }
   
   int
   kernfs_try_xwrite(kfstype type, const struct kernfs_node *kfs, char *bf,
     size_t len, int error)      size_t len, int error)
 {  {
         struct kernfs_fileop *kf, skf;          struct kernfs_fileop *kf, skf;
Line 337  kernfs_try_xwrite(kfstype type, const st
Line 346  kernfs_try_xwrite(kfstype type, const st
         skf.kf_fileop = KERNFS_XWRITE;          skf.kf_fileop = KERNFS_XWRITE;
         if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))          if ((kf = SPLAY_FIND(kfsfileoptree, &kfsfileoptree, &skf)))
                 if (kf->kf_xwrite)                  if (kf->kf_xwrite)
                         return kf->kf_xwrite(kfs, buf, len);                          return kf->kf_xwrite(kfs, bf, len);
         return error;          return error;
 }  }
   
Line 382  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 391  kernfs_xread(kfs, off, bufp, len, wrlen)
 #ifdef IPSEC  #ifdef IPSEC
         struct mbuf *m;          struct mbuf *m;
 #endif  #endif
           int err;
   
         kt = kfs->kfs_kt;          kt = kfs->kfs_kt;
   
Line 444  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 454  kernfs_xread(kfs, off, bufp, len, wrlen)
   
         case KFShostname: {          case KFShostname: {
                 char *cp = hostname;                  char *cp = hostname;
                 int xlen = hostnamelen;                  size_t xlen = hostnamelen;
   
                 if (xlen >= (len - 2))                  if (xlen >= (len - 2))
                         return (EINVAL);                          return (EINVAL);
Line 516  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 526  kernfs_xread(kfs, off, bufp, len, wrlen)
 #endif  #endif
   
         default:          default:
                 *wrlen = 0;                  err = kernfs_try_xread(kfs->kfs_type, kfs, bufp, len,
                 return (0);                      EOPNOTSUPP);
                   if (err)
                           return err;
         }          }
   
         len = strlen(*bufp);          len = strlen(*bufp);
Line 531  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 543  kernfs_xread(kfs, off, bufp, len, wrlen)
 }  }
   
 static int  static int
 kernfs_xwrite(kfs, buf, len)  kernfs_xwrite(kfs, bf, len)
         const struct kernfs_node *kfs;          const struct kernfs_node *kfs;
         char *buf;          char *bf;
         size_t len;          size_t len;
 {  {
   
         switch (kfs->kfs_type) {          switch (kfs->kfs_type) {
         case KFShostname:          case KFShostname:
                 if (buf[len-1] == '\n')                  if (bf[len-1] == '\n')
                         --len;                          --len;
                 memcpy(hostname, buf, len);                  memcpy(hostname, bf, len);
                 hostname[len] = '\0';                  hostname[len] = '\0';
                 hostnamelen = (size_t) len;                  hostnamelen = (size_t) len;
                 return (0);                  return (0);
   
         default:          default:
                 return kernfs_try_xwrite(kfs->kfs_type, kfs, buf, len, EIO);                  return kernfs_try_xwrite(kfs->kfs_type, kfs, bf, len, EIO);
         }          }
 }  }
   
Line 573  kernfs_lookup(v)
Line 585  kernfs_lookup(v)
         const struct kern_target *kt;          const struct kern_target *kt;
         const struct dyn_kern_target *dkt;          const struct dyn_kern_target *dkt;
         const struct kernfs_subdir *ks;          const struct kernfs_subdir *ks;
         int error, i, wantpunlock;          int error, i;
 #ifdef IPSEC  #ifdef IPSEC
         char *ep;          char *ep;
         u_int32_t id;          u_int32_t id;
 #endif  #endif
   
         *vpp = NULLVP;          *vpp = NULLVP;
         cnp->cn_flags &= ~PDIRUNLOCK;  
   
         if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)          if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
                 return (EROFS);                  return (EROFS);
Line 591  kernfs_lookup(v)
Line 602  kernfs_lookup(v)
                 return (0);                  return (0);
         }          }
   
         wantpunlock = (~cnp->cn_flags & (LOCKPARENT | ISLASTCN));  
         kfs = VTOKERN(dvp);          kfs = VTOKERN(dvp);
         switch (kfs->kfs_type) {          switch (kfs->kfs_type) {
         case KFSkern:          case KFSkern:
Line 618  kernfs_lookup(v)
Line 628  kernfs_lookup(v)
   
         found:          found:
                 error = kernfs_allocvp(dvp->v_mount, vpp, kt->kt_tag, kt, 0);                  error = kernfs_allocvp(dvp->v_mount, vpp, kt->kt_tag, kt, 0);
                 if ((error == 0) && wantpunlock) {  
                         VOP_UNLOCK(dvp, 0);  
                         cnp->cn_flags |= PDIRUNLOCK;  
                 }  
                 return (error);                  return (error);
   
         case KFSsubdir:          case KFSsubdir:
Line 660  kernfs_lookup(v)
Line 666  kernfs_lookup(v)
                         break;                          break;
   
                 error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsa, &ipsecsa_kt, id);                  error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsa, &ipsecsa_kt, id);
                 if ((error == 0) && wantpunlock) {  
                         VOP_UNLOCK(dvp, 0);  
                         cnp->cn_flags |= PDIRUNLOCK;  
                 }  
                 return (error);                  return (error);
   
         case KFSipsecspdir:          case KFSipsecspdir:
Line 685  kernfs_lookup(v)
Line 687  kernfs_lookup(v)
                         break;                          break;
   
                 error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsp, &ipsecsp_kt, id);                  error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsp, &ipsecsp_kt, id);
                 if ((error == 0) && wantpunlock) {  
                         VOP_UNLOCK(dvp, 0);  
                         cnp->cn_flags |= PDIRUNLOCK;  
                 }  
                 return (error);                  return (error);
 #endif  #endif
   
Line 706  kernfs_open(v)
Line 704  kernfs_open(v)
         struct vop_open_args /* {          struct vop_open_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 int a_mode;                  int a_mode;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
 #ifdef IPSEC  #ifdef IPSEC
Line 747  kernfs_close(v)
Line 745  kernfs_close(v)
         struct vop_close_args /* {          struct vop_close_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 int a_fflag;                  int a_fflag;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
   
Line 774  kernfs_access(v)
Line 772  kernfs_access(v)
         struct vop_access_args /* {          struct vop_access_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 int a_mode;                  int a_mode;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct vattr va;          struct vattr va;
         int error;          int error;
   
         if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_p)) != 0)          if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred, ap->a_l)) != 0)
                 return (error);                  return (error);
   
         return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid,          return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid,
Line 794  kernfs_default_fileop_getattr(v)
Line 792  kernfs_default_fileop_getattr(v)
         struct vop_getattr_args /* {          struct vop_getattr_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct vattr *a_vap;                  struct vattr *a_vap;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct vattr *vap = ap->a_vap;          struct vattr *vap = ap->a_vap;
   
Line 812  kernfs_getattr(v)
Line 810  kernfs_getattr(v)
         struct vop_getattr_args /* {          struct vop_getattr_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct vattr *a_vap;                  struct vattr *a_vap;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
         struct kernfs_subdir *ks;          struct kernfs_subdir *ks;
         struct vattr *vap = ap->a_vap;          struct vattr *vap = ap->a_vap;
         int error = 0;          int error = 0;
         char strbuf[KSTRING], *buf;          char strbuf[KSTRING], *bf;
         size_t nread, total;          size_t nread, total;
   
         VATTR_NULL(vap);          VATTR_NULL(vap);
Line 831  kernfs_getattr(v)
Line 829  kernfs_getattr(v)
         vap->va_flags = 0;          vap->va_flags = 0;
         vap->va_size = 0;          vap->va_size = 0;
         vap->va_blocksize = DEV_BSIZE;          vap->va_blocksize = DEV_BSIZE;
         /*          /* Make all times be current TOD, except for the "boottime" node. */
          * Make all times be current TOD, except for the "boottime" node.          if (kfs->kfs_kt && kfs->kfs_kt->kt_namlen == 8 &&
          * Avoid microtime(9), it's slow.  
          * We don't guard the read from time(9) with splclock(9) since we  
          * don't actually need to be THAT sure the access is atomic.  
          */  
         if (kfs->kfs_kt && kfs->kfs_kt->kt_namlen == 8 &&  
             !memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) {              !memcmp(kfs->kfs_kt->kt_name, "boottime", 8)) {
                 TIMEVAL_TO_TIMESPEC(&boottime, &vap->va_ctime);                  TIMEVAL_TO_TIMESPEC(&boottime, &vap->va_ctime);
         } else {          } else {
                 TIMEVAL_TO_TIMESPEC(&time, &vap->va_ctime);                  getnanotime(&vap->va_ctime);
         }          }
         vap->va_atime = vap->va_mtime = vap->va_ctime;          vap->va_atime = vap->va_mtime = vap->va_ctime;
         vap->va_gen = 0;          vap->va_gen = 0;
Line 881  kernfs_getattr(v)
Line 874  kernfs_getattr(v)
                 vap->va_nlink = 1;                  vap->va_nlink = 1;
                 total = 0;                  total = 0;
                 do {                  do {
                         buf = strbuf;                          bf = strbuf;
                         error = kernfs_xread(kfs, total, &buf,                          error = kernfs_xread(kfs, total, &bf,
                             sizeof(strbuf), &nread);                              sizeof(strbuf), &nread);
                         total += nread;                          total += nread;
                 } while (error == 0 && nread != 0);                  } while (error == 0 && nread != 0);
Line 908  kernfs_getattr(v)
Line 901  kernfs_getattr(v)
   
 /*ARGSUSED*/  /*ARGSUSED*/
 int  int
 kernfs_setattr(v)  kernfs_setattr(void *v)
         void *v;  
 {  {
   
         /*          /*
Line 922  kernfs_setattr(v)
Line 914  kernfs_setattr(v)
 }  }
   
 int  int
 kernfs_read(v)  kernfs_default_xread(v)
         void *v;          void *v;
 {  {
         struct vop_read_args /* {          struct vop_read_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct uio *a_uio;                  struct uio *a_uio;
                 int  a_ioflag;                  int  a_ioflag;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
         } */ *ap = v;          } */ *ap = v;
         struct uio *uio = ap->a_uio;          struct uio *uio = ap->a_uio;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
         char strbuf[KSTRING], *buf;          char strbuf[KSTRING], *bf;
         off_t off;          int off;
         size_t len;          size_t len;
         int error;          int error;
   
         if (ap->a_vp->v_type == VDIR)          if (ap->a_vp->v_type == VDIR)
                 return (EOPNOTSUPP);                  return (EOPNOTSUPP);
   
         off = uio->uio_offset;          off = (int)uio->uio_offset;
         buf = strbuf;          /* Don't allow negative offsets */
         if ((error = kernfs_xread(kfs, off, &buf, sizeof(strbuf), &len)) == 0)          if (off < 0)
                 error = uiomove(buf, len, uio);                  return EINVAL;
   
           bf = strbuf;
           if ((error = kernfs_xread(kfs, off, &bf, sizeof(strbuf), &len)) == 0)
                   error = uiomove(bf, len, uio);
         return (error);          return (error);
 }  }
   
   int
   kernfs_read(v)
           void *v;
   {
           struct vop_read_args /* {
                   struct vnode *a_vp;
                   struct uio *a_uio;
                   int  a_ioflag;
                   struct ucred *a_cred;
           } */ *ap = v;
           struct kernfs_node *kfs = VTOKERN(ap->a_vp);
   
           if (kfs->kfs_type < KFSlasttype) {
                   /* use default function */
                   return kernfs_default_xread(v);
           }
           return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_READ, v,
              EOPNOTSUPP);
   }
   
 static int  static int
 kernfs_default_xwrite(v)  kernfs_default_xwrite(v)
         void *v;          void *v;
Line 956  kernfs_default_xwrite(v)
Line 972  kernfs_default_xwrite(v)
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct uio *a_uio;                  struct uio *a_uio;
                 int  a_ioflag;                  int  a_ioflag;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
         struct uio *uio = ap->a_uio;          struct uio *uio = ap->a_uio;
         int error, xlen;          int error;
           size_t xlen;
         char strbuf[KSTRING];          char strbuf[KSTRING];
   
         if (uio->uio_offset != 0)          if (uio->uio_offset != 0)
Line 986  kernfs_write(v)
Line 1003  kernfs_write(v)
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct uio *a_uio;                  struct uio *a_uio;
                 int  a_ioflag;                  int  a_ioflag;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
   
         return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_WRITE, v, 0);          if (kfs->kfs_type < KFSlasttype) {
                   /* use default function */
                   return kernfs_default_xwrite(v);
           }
           return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_WRITE, v,
               EOPNOTSUPP);
 }  }
   
 int  int
Line 1003  kernfs_ioctl(v)
Line 1025  kernfs_ioctl(v)
                 u_long a_command;                  u_long a_command;
                 void *a_data;                  void *a_data;
                 int a_fflag;                  int a_fflag;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
   
Line 1012  kernfs_ioctl(v)
Line 1034  kernfs_ioctl(v)
             EPASSTHROUGH);              EPASSTHROUGH);
 }  }
   
 int  
 kernfs_mmap(v)  
         void *v;  
 {  
         struct vop_mmap_args /* {  
                 const struct vnodeop_desc *a_desc;  
                 struct vnode *a_vp;  
                 int a_fflags;  
                 struct ucred *a_cred;  
                 struct proc *a_p;  
         } */ *ap = v;  
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);  
   
         return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_MMAP, v, 0);  
 }  
   
 static int  static int
 kernfs_setdirentfileno_kt(struct dirent *d, const struct kern_target *kt,  kernfs_setdirentfileno_kt(struct dirent *d, const struct kern_target *kt,
     u_int32_t value, struct vop_readdir_args *ap)      u_int32_t value, struct vop_readdir_args *ap)
Line 1041  kernfs_setdirentfileno_kt(struct dirent 
Line 1047  kernfs_setdirentfileno_kt(struct dirent 
                 return error;                  return error;
         if (kt->kt_tag == KFSdevice) {          if (kt->kt_tag == KFSdevice) {
                 struct vattr va;                  struct vattr va;
                 if ((error = VOP_GETATTR(vp, &va, ap->a_cred,  
                     ap->a_uio->uio_segflg == UIO_USERSPACE ?                  error = VOP_GETATTR(vp, &va, ap->a_cred, curlwp);
                     ap->a_uio->uio_procp : &proc0)) != 0)                  if (error != 0) {
                         return (error);                          return error;
                   }
                 d->d_fileno = va.va_fileid;                  d->d_fileno = va.va_fileid;
         } else {          } else {
                 kfs = VTOKERN(vp);                  kfs = VTOKERN(vp);
Line 1088  kernfs_readdir(v)
Line 1095  kernfs_readdir(v)
         struct vop_readdir_args /* {          struct vop_readdir_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct uio *a_uio;                  struct uio *a_uio;
                 struct ucred *a_cred;                  kauth_cred_t a_cred;
                 int *a_eofflag;                  int *a_eofflag;
                 off_t **a_cookies;                  off_t **a_cookies;
                 int a_*ncookies;                  int a_*ncookies;
Line 1145  kernfs_readdir(v)
Line 1152  kernfs_readdir(v)
                                                 break;                                                  break;
                                 } else {                                  } else {
                                         dkt = SIMPLEQ_NEXT(dkt, dkt_queue);                                          dkt = SIMPLEQ_NEXT(dkt, dkt_queue);
                                         if (dkt == NULL)  
                                                 break;  
                                 }                                  }
                                   if (dkt == NULL)
                                           break;
                                 kt = &dkt->dkt_kt;                                  kt = &dkt->dkt_kt;
                         }                          }
                         if (kt->kt_tag == KFSdevice) {                          if (kt->kt_tag == KFSdevice) {
Line 1406  kernfs_inactive(v)
Line 1413  kernfs_inactive(v)
 {  {
         struct vop_inactive_args /* {          struct vop_inactive_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct proc *a_p;                  struct lwp *a_l;
         } */ *ap = v;          } */ *ap = v;
         struct vnode *vp = ap->a_vp;          struct vnode *vp = ap->a_vp;
         const struct kernfs_node *kfs = VTOKERN(ap->a_vp);          const struct kernfs_node *kfs = VTOKERN(ap->a_vp);
Line 1498  kernfs_pathconf(v)
Line 1505  kernfs_pathconf(v)
  */   */
 /* ARGSUSED */  /* ARGSUSED */
 int  int
 kernfs_print(v)  kernfs_print(void *v)
         void *v;  
 {  {
   
         printf("tag VT_KERNFS, kernfs vnode\n");          printf("tag VT_KERNFS, kernfs vnode\n");
Line 1507  kernfs_print(v)
Line 1513  kernfs_print(v)
 }  }
   
 int  int
 kernfs_link(v)  kernfs_link(v)
         void *v;          void *v;
 {  {
         struct vop_link_args /* {          struct vop_link_args /* {
                 struct vnode *a_dvp;                  struct vnode *a_dvp;
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct componentname *a_cnp;                  struct componentname *a_cnp;
         } */ *ap = v;          } */ *ap = v;
   
         VOP_ABORTOP(ap->a_dvp, ap->a_cnp);          VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
         vput(ap->a_dvp);          vput(ap->a_dvp);
         return (EROFS);          return (EROFS);
Line 1532  kernfs_symlink(v)
Line 1538  kernfs_symlink(v)
                 struct vattr *a_vap;                  struct vattr *a_vap;
                 char *a_target;                  char *a_target;
         } */ *ap = v;          } */ *ap = v;
   
         VOP_ABORTOP(ap->a_dvp, ap->a_cnp);          VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
         vput(ap->a_dvp);          vput(ap->a_dvp);
         return (EROFS);          return (EROFS);

Legend:
Removed from v.1.106  
changed lines
  Added in v.1.129

CVSweb <webmaster@jp.NetBSD.org>