[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.122 and 1.143

version 1.122, 2006/06/23 14:59:40 version 1.143, 2010/07/21 09:06:38
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_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(void *);  int     kernfs_lookup(void *);
Line 296  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 316  kernfs_try_fileop(kfstype type, kfsfileo
Line 323  kernfs_try_fileop(kfstype type, kfsfileo
 }  }
   
 int  int
   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,  kernfs_try_xwrite(kfstype type, const struct kernfs_node *kfs, char *bf,
     size_t len, int error)      size_t len, int error)
 {  {
Line 359  kernfs_addentry(kernfs_parentdir_t *pkt,
Line 380  kernfs_addentry(kernfs_parentdir_t *pkt,
 }  }
   
 static int  static int
 kernfs_xread(kfs, off, bufp, len, wrlen)  kernfs_xread(struct kernfs_node *kfs, int off, char **bufp, size_t len, size_t *wrlen)
         struct kernfs_node *kfs;  
         int off;  
         char **bufp;  
         size_t len;  
         size_t *wrlen;  
 {  {
         const struct kern_target *kt;          const struct kern_target *kt;
 #ifdef IPSEC  #ifdef IPSEC
         struct mbuf *m;          struct mbuf *m;
 #endif  #endif
           int err;
   
         kt = kfs->kfs_kt;          kt = kfs->kfs_kt;
   
Line 378  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 395  kernfs_xread(kfs, off, bufp, len, wrlen)
                 struct timeval tv;                  struct timeval tv;
   
                 microtime(&tv);                  microtime(&tv);
                 snprintf(*bufp, len, "%ld %ld\n", tv.tv_sec, tv.tv_usec);                  snprintf(*bufp, len, "%lld %ld\n", (long long)tv.tv_sec,
                       (long)tv.tv_usec);
                 break;                  break;
         }          }
   
Line 432  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 450  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 440  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 458  kernfs_xread(kfs, off, bufp, len, wrlen)
                 memcpy(*bufp, cp, xlen);                  memcpy(*bufp, cp, xlen);
                 (*bufp)[xlen] = '\n';                  (*bufp)[xlen] = '\n';
                 (*bufp)[xlen+1] = '\0';                  (*bufp)[xlen+1] = '\0';
                 len = strlen(*bufp);  
                 break;                  break;
         }          }
   
Line 453  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 470  kernfs_xread(kfs, off, bufp, len, wrlen)
   
 #ifdef IPSEC  #ifdef IPSEC
         case KFSipsecsa:          case KFSipsecsa:
                   if (key_setdumpsa_spi == NULL)
                           return 0;
                 /*                  /*
                  * Note that SA configuration could be changed during the                   * Note that SA configuration could be changed during the
                  * read operation, resulting in garbled output.                   * read operation, resulting in garbled output.
Line 477  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 496  kernfs_xread(kfs, off, bufp, len, wrlen)
                  * Note that SP configuration could be changed during the                   * Note that SP configuration could be changed during the
                  * read operation, resulting in garbled output.                   * read operation, resulting in garbled output.
                  */                   */
                   if (key_getspbyid == NULL)
                           return 0;
                 if (!kfs->kfs_v) {                  if (!kfs->kfs_v) {
                         struct secpolicy *sp;                          struct secpolicy *sp;
   
Line 504  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 525  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 519  kernfs_xread(kfs, off, bufp, len, wrlen)
Line 542  kernfs_xread(kfs, off, bufp, len, wrlen)
 }  }
   
 static int  static int
 kernfs_xwrite(kfs, bf, len)  kernfs_xwrite(const struct kernfs_node *kfs, char *bf, size_t len)
         const struct kernfs_node *kfs;  
         char *bf;  
         size_t len;  
 {  {
   
         switch (kfs->kfs_type) {          switch (kfs->kfs_type) {
Line 545  kernfs_xwrite(kfs, bf, len)
Line 565  kernfs_xwrite(kfs, bf, len)
  * ndp is the name to locate in that directory...   * ndp is the name to locate in that directory...
  */   */
 int  int
 kernfs_lookup(v)  kernfs_lookup(void *v)
         void *v;  
 {  {
         struct vop_lookup_args /* {          struct vop_lookup_args /* {
                 struct vnode * a_dvp;                  struct vnode * a_dvp;
Line 561  kernfs_lookup(v)
Line 580  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);
   
         if (cnp->cn_namelen == 1 && *pname == '.') {          if (cnp->cn_namelen == 1 && *pname == '.') {
                 *vpp = dvp;                  *vpp = dvp;
                 VREF(dvp);                  vref(dvp);
                 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 606  kernfs_lookup(v)
Line 623  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 648  kernfs_lookup(v)
Line 661  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 673  kernfs_lookup(v)
Line 682  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 688  kernfs_lookup(v)
Line 693  kernfs_lookup(v)
 }  }
   
 int  int
 kernfs_open(v)  kernfs_open(void *v)
         void *v;  
 {  {
         struct vop_open_args /* {          struct vop_open_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 int a_mode;                  int a_mode;
                 kauth_cred_t a_cred;                  kauth_cred_t a_cred;
                 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 706  kernfs_open(v)
Line 709  kernfs_open(v)
         switch (kfs->kfs_type) {          switch (kfs->kfs_type) {
 #ifdef IPSEC  #ifdef IPSEC
         case KFSipsecsa:          case KFSipsecsa:
                   if (key_setdumpsa_spi == NULL)
                           return 0;
                 m = key_setdumpsa_spi(htonl(kfs->kfs_value));                  m = key_setdumpsa_spi(htonl(kfs->kfs_value));
                 if (m) {                  if (m) {
                         m_freem(m);                          m_freem(m);
Line 714  kernfs_open(v)
Line 719  kernfs_open(v)
                         return (ENOENT);                          return (ENOENT);
   
         case KFSipsecsp:          case KFSipsecsp:
                   if (key_getspbyid == NULL)
                           return 0;
                 sp = key_getspbyid(kfs->kfs_value);                  sp = key_getspbyid(kfs->kfs_value);
                 if (sp) {                  if (sp) {
                         kfs->kfs_v = sp;                          kfs->kfs_v = sp;
Line 729  kernfs_open(v)
Line 736  kernfs_open(v)
 }  }
   
 int  int
 kernfs_close(v)  kernfs_close(void *v)
         void *v;  
 {  {
         struct vop_close_args /* {          struct vop_close_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 int a_fflag;                  int a_fflag;
                 kauth_cred_t a_cred;                  kauth_cred_t a_cred;
                 struct lwp *a_l;  
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
   
         switch (kfs->kfs_type) {          switch (kfs->kfs_type) {
 #ifdef IPSEC  #ifdef IPSEC
         case KFSipsecsp:          case KFSipsecsp:
                   if (key_freesp == NULL)
                           return 0;
                 key_freesp((struct secpolicy *)kfs->kfs_v);                  key_freesp((struct secpolicy *)kfs->kfs_v);
                 break;                  break;
 #endif  #endif
Line 755  kernfs_close(v)
Line 762  kernfs_close(v)
         return (0);          return (0);
 }  }
   
   static int
   kernfs_check_possible(struct vnode *vp, mode_t mode)
   {
   
           return 0;
   }
   
   static int
   kernfs_check_permitted(struct vattr *va, mode_t mode, kauth_cred_t cred)
   {
   
           return genfs_can_access(va->va_type, va->va_mode, va->va_uid, va->va_gid,
               mode, cred);
   }
   
 int  int
 kernfs_access(v)  kernfs_access(void *v)
         void *v;  
 {  {
         struct vop_access_args /* {          struct vop_access_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 int a_mode;                  int a_mode;
                 kauth_cred_t a_cred;                  kauth_cred_t a_cred;
                 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_l)) != 0)          if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0)
                 return (error);                  return (error);
   
         return (vaccess(va.va_type, va.va_mode, va.va_uid, va.va_gid,          error = kernfs_check_possible(ap->a_vp, ap->a_mode);
             ap->a_mode, ap->a_cred));          if (error)
                   return error;
   
           error = kernfs_check_permitted(&va, ap->a_mode, ap->a_cred);
   
           return error;
 }  }
   
 static int  static int
 kernfs_default_fileop_getattr(v)  kernfs_default_fileop_getattr(void *v)
         void *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;
                 kauth_cred_t a_cred;                  kauth_cred_t a_cred;
                 struct lwp *a_l;  
         } */ *ap = v;          } */ *ap = v;
         struct vattr *vap = ap->a_vap;          struct vattr *vap = ap->a_vap;
   
Line 794  kernfs_default_fileop_getattr(v)
Line 817  kernfs_default_fileop_getattr(v)
 }  }
   
 int  int
 kernfs_getattr(v)  kernfs_getattr(void *v)
         void *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;
                 kauth_cred_t a_cred;                  kauth_cred_t a_cred;
                 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;
Line 810  kernfs_getattr(v)
Line 831  kernfs_getattr(v)
         char strbuf[KSTRING], *bf;          char strbuf[KSTRING], *bf;
         size_t nread, total;          size_t nread, total;
   
         VATTR_NULL(vap);          vattr_null(vap);
         vap->va_type = ap->a_vp->v_type;          vap->va_type = ap->a_vp->v_type;
         vap->va_uid = 0;          vap->va_uid = 0;
         vap->va_gid = 0;          vap->va_gid = 0;
Line 820  kernfs_getattr(v)
Line 841  kernfs_getattr(v)
         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 &&          if (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);                  vap->va_ctime = boottime;
         } else {          } else {
                 getnanotime(&vap->va_ctime);                  getnanotime(&vap->va_ctime);
         }          }
Line 891  kernfs_getattr(v)
Line 912  kernfs_getattr(v)
   
 /*ARGSUSED*/  /*ARGSUSED*/
 int  int
 kernfs_setattr(v)  kernfs_setattr(void *v)
         void *v;  
 {  {
   
         /*          /*
Line 905  kernfs_setattr(v)
Line 925  kernfs_setattr(v)
 }  }
   
 int  int
 kernfs_read(v)  kernfs_default_xread(void *v)
         void *v;  
 {  {
         struct vop_read_args /* {          struct vop_read_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
Line 935  kernfs_read(v)
Line 954  kernfs_read(v)
         return (error);          return (error);
 }  }
   
   int
   kernfs_read(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(void *v)
         void *v;  
 {  {
         struct vop_write_args /* {          struct vop_write_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
Line 947  kernfs_default_xwrite(v)
Line 984  kernfs_default_xwrite(v)
         } */ *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 966  kernfs_default_xwrite(v)
Line 1004  kernfs_default_xwrite(v)
 }  }
   
 int  int
 kernfs_write(v)  kernfs_write(void *v)
         void *v;  
 {  {
         struct vop_write_args /* {          struct vop_write_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
Line 977  kernfs_write(v)
Line 1014  kernfs_write(v)
         } */ *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
 kernfs_ioctl(v)  kernfs_ioctl(void *v)
         void *v;  
 {  {
         struct vop_ioctl_args /* {          struct vop_ioctl_args /* {
                 const struct vnodeop_desc *a_desc;                  const struct vnodeop_desc *a_desc;
Line 991  kernfs_ioctl(v)
Line 1032  kernfs_ioctl(v)
                 void *a_data;                  void *a_data;
                 int a_fflag;                  int a_fflag;
                 kauth_cred_t a_cred;                  kauth_cred_t a_cred;
                 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 1013  kernfs_setdirentfileno_kt(struct dirent 
Line 1053  kernfs_setdirentfileno_kt(struct dirent 
         if (kt->kt_tag == KFSdevice) {          if (kt->kt_tag == KFSdevice) {
                 struct vattr va;                  struct vattr va;
   
                 error = VOP_GETATTR(vp, &va, ap->a_cred, curlwp);                  error = VOP_GETATTR(vp, &va, ap->a_cred);
                 if (error != 0) {                  if (error != 0) {
                         return error;                          return error;
                 }                  }
Line 1054  kernfs_setdirentfileno(struct dirent *d,
Line 1094  kernfs_setdirentfileno(struct dirent *d,
 }  }
   
 int  int
 kernfs_readdir(v)  kernfs_readdir(void *v)
         void *v;  
 {  {
         struct vop_readdir_args /* {          struct vop_readdir_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
Line 1129  kernfs_readdir(v)
Line 1168  kernfs_readdir(v)
                                 if (*dp == NODEV ||                                  if (*dp == NODEV ||
                                     !vfinddev(*dp, kt->kt_vtype, &fvp))                                      !vfinddev(*dp, kt->kt_vtype, &fvp))
                                         continue;                                          continue;
                                   vrele(fvp);
                           }
                           if (kt->kt_tag == KFSmsgbuf) {
                                   if (!msgbufenabled
                                       || msgbufp->msg_magic != MSG_MAGIC) {
                                           continue;
                                   }
                         }                          }
                         d.d_namlen = kt->kt_namlen;                          d.d_namlen = kt->kt_namlen;
                         if ((error = kernfs_setdirentfileno(&d, i, kfs,                          if ((error = kernfs_setdirentfileno(&d, i, kfs,
Line 1205  kernfs_readdir(v)
Line 1251  kernfs_readdir(v)
                                 if (*dp == NODEV ||                                  if (*dp == NODEV ||
                                     !vfinddev(*dp, kt->kt_vtype, &fvp))                                      !vfinddev(*dp, kt->kt_vtype, &fvp))
                                         continue;                                          continue;
                                   vrele(fvp);
                         }                          }
                         d.d_namlen = kt->kt_namlen;                          d.d_namlen = kt->kt_namlen;
                         if ((error = kernfs_setdirentfileno(&d, i, kfs,                          if ((error = kernfs_setdirentfileno(&d, i, kfs,
Line 1225  kernfs_readdir(v)
Line 1272  kernfs_readdir(v)
         case KFSipsecsadir:          case KFSipsecsadir:
                 /* count SA in the system */                  /* count SA in the system */
                 n = 0;                  n = 0;
                   if (&satailq == NULL)
                           return 0;
                 TAILQ_FOREACH(sav, &satailq, tailq) {                  TAILQ_FOREACH(sav, &satailq, tailq) {
                         for (sav2 = TAILQ_FIRST(&satailq);                          for (sav2 = TAILQ_FIRST(&satailq);
                             sav2 != sav;                              sav2 != sav;
Line 1299  kernfs_readdir(v)
Line 1348  kernfs_readdir(v)
   
         case KFSipsecspdir:          case KFSipsecspdir:
                 /* count SP in the system */                  /* count SP in the system */
                   if (&sptailq == NULL)
                           return 0;
   
                 n = 0;                  n = 0;
                 TAILQ_FOREACH(sp, &sptailq, tailq)                  TAILQ_FOREACH(sp, &sptailq, tailq)
                         n++;                          n++;
Line 1373  kernfs_readdir(v)
Line 1425  kernfs_readdir(v)
 }  }
   
 int  int
 kernfs_inactive(v)  kernfs_inactive(void *v)
         void *v;  
 {  {
         struct vop_inactive_args /* {          struct vop_inactive_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
                 struct lwp *a_l;                  bool *a_recycle;
         } */ *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 1387  kernfs_inactive(v)
Line 1438  kernfs_inactive(v)
         struct secpolicy *sp;          struct secpolicy *sp;
 #endif  #endif
   
         VOP_UNLOCK(vp, 0);          *ap->a_recycle = false;
         switch (kfs->kfs_type) {          switch (kfs->kfs_type) {
 #ifdef IPSEC  #ifdef IPSEC
         case KFSipsecsa:          case KFSipsecsa:
                   if (key_setdumpsa_spi == NULL)
                           return 0;
                 m = key_setdumpsa_spi(htonl(kfs->kfs_value));                  m = key_setdumpsa_spi(htonl(kfs->kfs_value));
                 if (m)                  if (m)
                         m_freem(m);                          m_freem(m);
                 else                  else
                         vgone(vp);                          *ap->a_recycle = true;
                 break;                  break;
         case KFSipsecsp:          case KFSipsecsp:
                   if (key_getspbyid == NULL)
                           return 0;
                 sp = key_getspbyid(kfs->kfs_value);                  sp = key_getspbyid(kfs->kfs_value);
                 if (sp)                  if (sp)
                         key_freesp(sp);                          key_freesp(sp);
                 else {                  else {
                         /* should never happen as we hold a refcnt */                          *ap->a_recycle = true;
                         vgone(vp);  
                 }                  }
                 break;                  break;
 #endif  #endif
         default:          default:
                 break;                  break;
         }          }
           VOP_UNLOCK(vp);
         return (0);          return (0);
 }  }
   
 int  int
 kernfs_reclaim(v)  kernfs_reclaim(void *v)
         void *v;  
 {  {
         struct vop_reclaim_args /* {          struct vop_reclaim_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
Line 1428  kernfs_reclaim(v)
Line 1482  kernfs_reclaim(v)
  * Return POSIX pathconf information applicable to special devices.   * Return POSIX pathconf information applicable to special devices.
  */   */
 int  int
 kernfs_pathconf(v)  kernfs_pathconf(void *v)
         void *v;  
 {  {
         struct vop_pathconf_args /* {          struct vop_pathconf_args /* {
                 struct vnode *a_vp;                  struct vnode *a_vp;
Line 1470  kernfs_pathconf(v)
Line 1523  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 1479  kernfs_print(v)
Line 1531  kernfs_print(v)
 }  }
   
 int  int
 kernfs_link(v)  kernfs_link(void *v)
         void *v;  
 {  {
         struct vop_link_args /* {          struct vop_link_args /* {
                 struct vnode *a_dvp;                  struct vnode *a_dvp;
Line 1494  kernfs_link(v)
Line 1545  kernfs_link(v)
 }  }
   
 int  int
 kernfs_symlink(v)  kernfs_symlink(void *v)
         void *v;  
 {  {
         struct vop_symlink_args /* {          struct vop_symlink_args /* {
                 struct vnode *a_dvp;                  struct vnode *a_dvp;

Legend:
Removed from v.1.122  
changed lines
  Added in v.1.143

CVSweb <webmaster@jp.NetBSD.org>