[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.139 and 1.150

version 1.139, 2010/01/08 11:35:11 version 1.150, 2014/02/07 15:29:22
Line 41 
Line 41 
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
 #ifdef _KERNEL_OPT  
 #include "opt_ipsec.h"  
 #endif  
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/kernel.h>  #include <sys/kernel.h>
Line 64  __KERNEL_RCSID(0, "$NetBSD$");
Line 60  __KERNEL_RCSID(0, "$NetBSD$");
 #include <miscfs/genfs/genfs.h>  #include <miscfs/genfs/genfs.h>
 #include <miscfs/kernfs/kernfs.h>  #include <miscfs/kernfs/kernfs.h>
   
 #ifdef IPSEC  
 #include <sys/mbuf.h>  
 #include <net/route.h>  
 #include <netinet/in.h>  
 #include <netinet6/ipsec.h>  
 #include <netkey/key.h>  
 #endif  
   
 #include <uvm/uvm_extern.h>  #include <uvm/uvm_extern.h>
   
 #define KSTRING 256             /* Largest I/O available via this filesystem */  #define KSTRING 256             /* Largest I/O available via this filesystem */
Line 95  const struct kern_target kern_targets[] 
Line 83  const struct kern_target kern_targets[] 
                                              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  },
 #ifdef IPSEC  
      { DT_DIR, N("ipsecsa"),   0,            KFSipsecsadir,  VDIR, UDIR_MODE  },  
      { DT_DIR, N("ipsecsp"),   0,            KFSipsecspdir,  VDIR, UDIR_MODE  },  
 #endif  
      { DT_REG, N("loadavg"),   0,            KFSavenrun,     VREG, READ_MODE  },       { DT_REG, N("loadavg"),   0,            KFSavenrun,     VREG, READ_MODE  },
      { DT_REG, N("msgbuf"),    0,            KFSmsgbuf,      VREG, READ_MODE  },       { DT_REG, N("msgbuf"),    0,            KFSmsgbuf,      VREG, READ_MODE  },
      { DT_REG, N("pagesize"),  &uvmexp.pagesize, KFSint,     VREG, READ_MODE  },       { DT_REG, N("pagesize"),  &uvmexp.pagesize, KFSint,     VREG, READ_MODE  },
Line 119  const struct kern_target subdir_targets[
Line 103  const struct kern_target subdir_targets[
      { DT_DIR, N("."),         0,            KFSsubdir,      VDIR, DIR_MODE   },       { DT_DIR, N("."),         0,            KFSsubdir,      VDIR, DIR_MODE   },
      { DT_DIR, N(".."),        0,            KFSkern,        VDIR, DIR_MODE   },       { DT_DIR, N(".."),        0,            KFSkern,        VDIR, DIR_MODE   },
 };  };
 #ifdef IPSEC  
 const struct kern_target ipsecsa_targets[] = {  
 /* NOTE: The name must be less than UIO_MX-16 chars in length */  
      /*        name            data          tag           type  ro/rw */  
      { DT_DIR, N("."),         0,            KFSipsecsadir,  VDIR, DIR_MODE   },  
      { DT_DIR, N(".."),        0,            KFSkern,        VDIR, DIR_MODE   },  
 };  
 const struct kern_target ipsecsp_targets[] = {  
 /* NOTE: The name must be less than UIO_MX-16 chars in length */  
      /*        name            data          tag           type  ro/rw */  
      { DT_DIR, N("."),         0,            KFSipsecspdir,  VDIR, DIR_MODE   },  
      { DT_DIR, N(".."),        0,            KFSkern,        VDIR, DIR_MODE   },  
 };  
 const struct kern_target ipsecsa_kt =  
      { DT_DIR, N(""),          0,            KFSipsecsa,     VREG, UREAD_MODE };  
 const struct kern_target ipsecsp_kt =  
      { DT_DIR, N(""),          0,            KFSipsecsp,     VREG, UREAD_MODE };  
 #endif  
 #undef N  #undef N
 SIMPLEQ_HEAD(,dyn_kern_target) dyn_kern_targets =  SIMPLEQ_HEAD(,dyn_kern_target) dyn_kern_targets =
         SIMPLEQ_HEAD_INITIALIZER(dyn_kern_targets);          SIMPLEQ_HEAD_INITIALIZER(dyn_kern_targets);
 int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);  int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);
 const int static_nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);  const int static_nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]);
 #ifdef IPSEC  
 int nipsecsa_targets = sizeof(ipsecsa_targets) / sizeof(ipsecsa_targets[0]);  
 int nipsecsp_targets = sizeof(ipsecsp_targets) / sizeof(ipsecsp_targets[0]);  
 int nkern_dirs = 4; /* 2 extra subdirs */  
 #else  
 int nkern_dirs = 2;  int nkern_dirs = 2;
 #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 **,  int kernfs_try_xread(kfstype, const struct kernfs_node *, char **,
Line 383  static int
Line 343  static int
 kernfs_xread(struct kernfs_node *kfs, int off, char **bufp, size_t len, size_t *wrlen)  kernfs_xread(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  
         struct mbuf *m;  
 #endif  
         int err;          int err;
   
         kt = kfs->kfs_kt;          kt = kfs->kfs_kt;
Line 458  kernfs_xread(struct kernfs_node *kfs, in
Line 415  kernfs_xread(struct kernfs_node *kfs, in
                 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 469  kernfs_xread(struct kernfs_node *kfs, in
Line 425  kernfs_xread(struct kernfs_node *kfs, in
                     averunnable.ldavg[2], averunnable.fscale);                      averunnable.ldavg[2], averunnable.fscale);
                 break;                  break;
   
 #ifdef IPSEC  
         case KFSipsecsa:  
                 if (key_setdumpsa_spi == NULL)  
                         return 0;  
                 /*  
                  * Note that SA configuration could be changed during the  
                  * read operation, resulting in garbled output.  
                  */  
                 m = key_setdumpsa_spi(htonl(kfs->kfs_value));  
                 if (!m)  
                         return (ENOBUFS);  
                 if (off >= m->m_pkthdr.len) {  
                         *wrlen = 0;  
                         m_freem(m);  
                         return (0);  
                 }  
                 if (len > m->m_pkthdr.len - off)  
                         len = m->m_pkthdr.len - off;  
                 m_copydata(m, off, len, *bufp);  
                 *wrlen = len;  
                 m_freem(m);  
                 return (0);  
   
         case KFSipsecsp:  
                 /*  
                  * Note that SP configuration could be changed during the  
                  * read operation, resulting in garbled output.  
                  */  
                 if (key_getspbyid == NULL)  
                         return 0;  
                 if (!kfs->kfs_v) {  
                         struct secpolicy *sp;  
   
                         sp = key_getspbyid(kfs->kfs_value);  
                         if (sp)  
                                 kfs->kfs_v = sp;  
                         else  
                                 return (ENOENT);  
                 }  
                 m = key_setdumpsp((struct secpolicy *)kfs->kfs_v,  
                     SADB_X_SPDGET, 0, 0);  
                 if (!m)  
                         return (ENOBUFS);  
                 if (off >= m->m_pkthdr.len) {  
                         *wrlen = 0;  
                         m_freem(m);  
                         return (0);  
                 }  
                 if (len > m->m_pkthdr.len - off)  
                         len = m->m_pkthdr.len - off;  
                 m_copydata(m, off, len, *bufp);  
                 *wrlen = len;  
                 m_freem(m);  
                 return (0);  
 #endif  
   
         default:          default:
                 err = kernfs_try_xread(kfs->kfs_type, kfs, bufp, len,                  err = kernfs_try_xread(kfs->kfs_type, kfs, bufp, len,
                     EOPNOTSUPP);                      EOPNOTSUPP);
Line 568  kernfs_xwrite(const struct kernfs_node *
Line 468  kernfs_xwrite(const struct kernfs_node *
 int  int
 kernfs_lookup(void *v)  kernfs_lookup(void *v)
 {  {
         struct vop_lookup_args /* {          struct vop_lookup_v2_args /* {
                 struct vnode * a_dvp;                  struct vnode * a_dvp;
                 struct vnode ** a_vpp;                  struct vnode ** a_vpp;
                 struct componentname * a_cnp;                  struct componentname * a_cnp;
Line 582  kernfs_lookup(void *v)
Line 482  kernfs_lookup(void *v)
         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;          int error, i;
 #ifdef IPSEC  
         char *ep;  
         u_int32_t id;  
 #endif  
   
         *vpp = NULLVP;          *vpp = NULLVP;
   
Line 624  kernfs_lookup(void *v)
Line 520  kernfs_lookup(void *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);
                 return (error);                  if (error)
                           return error;
                   VOP_UNLOCK(*vpp);
                   return 0;
   
         case KFSsubdir:          case KFSsubdir:
                 ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;                  ks = (struct kernfs_subdir *)kfs->kfs_kt->kt_data;
Line 642  kernfs_lookup(void *v)
Line 541  kernfs_lookup(void *v)
                 }                  }
                 break;                  break;
   
 #ifdef IPSEC  
         case KFSipsecsadir:  
                 if (cnp->cn_flags & ISDOTDOT) {  
                         kt = &kern_targets[0];  
                         goto found;  
                 }  
   
                 for (i = 2; i < nipsecsa_targets; i++) {  
                         kt = &ipsecsa_targets[i];  
                         if (cnp->cn_namelen == kt->kt_namlen &&  
                             memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0)  
                                 goto found;  
                 }  
   
                 ep = NULL;  
                 id = strtoul(pname, &ep, 10);  
                 if (!ep || *ep || ep == pname)  
                         break;  
   
                 error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsa, &ipsecsa_kt, id);  
                 return (error);  
   
         case KFSipsecspdir:  
                 if (cnp->cn_flags & ISDOTDOT) {  
                         kt = &kern_targets[0];  
                         goto found;  
                 }  
   
                 for (i = 2; i < nipsecsp_targets; i++) {  
                         kt = &ipsecsp_targets[i];  
                         if (cnp->cn_namelen == kt->kt_namlen &&  
                             memcmp(kt->kt_name, pname, cnp->cn_namelen) == 0)  
                                 goto found;  
                 }  
   
                 ep = NULL;  
                 id = strtoul(pname, &ep, 10);  
                 if (!ep || *ep || ep == pname)  
                         break;  
   
                 error = kernfs_allocvp(dvp->v_mount, vpp, KFSipsecsp, &ipsecsp_kt, id);  
                 return (error);  
 #endif  
   
         default:          default:
                 return (ENOTDIR);                  return (ENOTDIR);
         }          }
Line 702  kernfs_open(void *v)
Line 557  kernfs_open(void *v)
                 kauth_cred_t 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);
 #ifdef IPSEC  
         struct mbuf *m;  
         struct secpolicy *sp;  
 #endif  
   
         switch (kfs->kfs_type) {          return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_OPEN, v, 0);
 #ifdef IPSEC  
         case KFSipsecsa:  
                 if (key_setdumpsa_spi == NULL)  
                         return 0;  
                 m = key_setdumpsa_spi(htonl(kfs->kfs_value));  
                 if (m) {  
                         m_freem(m);  
                         return (0);  
                 } else  
                         return (ENOENT);  
   
         case KFSipsecsp:  
                 if (key_getspbyid == NULL)  
                         return 0;  
                 sp = key_getspbyid(kfs->kfs_value);  
                 if (sp) {  
                         kfs->kfs_v = sp;  
                         return (0);  
                 } else  
                         return (ENOENT);  
 #endif  
   
         default:  
                 return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_OPEN,  
                     v, 0);  
         }  
 }  }
   
 int  int
Line 746  kernfs_close(void *v)
Line 571  kernfs_close(void *v)
         } */ *ap = v;          } */ *ap = v;
         struct kernfs_node *kfs = VTOKERN(ap->a_vp);          struct kernfs_node *kfs = VTOKERN(ap->a_vp);
   
         switch (kfs->kfs_type) {          return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_CLOSE, v, 0);
 #ifdef IPSEC  
         case KFSipsecsp:  
                 if (key_freesp == NULL)  
                         return 0;  
                 key_freesp((struct secpolicy *)kfs->kfs_v);  
                 break;  
 #endif  
   
         default:  
                 return kernfs_try_fileop(kfs->kfs_type, KERNFS_FILEOP_CLOSE,  
                     v, 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
Line 792  kernfs_access(void *v)
Line 588  kernfs_access(void *v)
         if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0)          if ((error = VOP_GETATTR(ap->a_vp, &va, ap->a_cred)) != 0)
                 return (error);                  return (error);
   
         error = kernfs_check_possible(ap->a_vp, ap->a_mode);          return kauth_authorize_vnode(ap->a_cred,
         if (error)              KAUTH_ACCESS_ACTION(ap->a_mode, ap->a_vp->v_type, va.va_mode),
                 return error;              ap->a_vp, NULL, genfs_can_access(va.va_type, va.va_mode,
               va.va_uid, va.va_gid, ap->a_mode, ap->a_cred));
         error = kernfs_check_permitted(&va, ap->a_mode, ap->a_cred);  
   
         return error;  
 }  }
   
 static int  static int
Line 879  kernfs_getattr(void *v)
Line 672  kernfs_getattr(void *v)
         case KFSavenrun:          case KFSavenrun:
         case KFSdevice:          case KFSdevice:
         case KFSmsgbuf:          case KFSmsgbuf:
 #ifdef IPSEC  
         case KFSipsecsa:  
         case KFSipsecsp:  
 #endif  
                 vap->va_nlink = 1;                  vap->va_nlink = 1;
                 total = 0;                  total = 0;
                 do {                  do {
Line 894  kernfs_getattr(void *v)
Line 683  kernfs_getattr(void *v)
                 vap->va_bytes = vap->va_size = total;                  vap->va_bytes = vap->va_size = total;
                 break;                  break;
   
 #ifdef IPSEC  
         case KFSipsecsadir:  
         case KFSipsecspdir:  
                 vap->va_nlink = 2;  
                 vap->va_bytes = vap->va_size = DEV_BSIZE;  
                 break;  
 #endif  
   
         default:          default:
                 error = kernfs_try_fileop(kfs->kfs_type,                  error = kernfs_try_fileop(kfs->kfs_type,
                     KERNFS_FILEOP_GETATTR, v, EINVAL);                      KERNFS_FILEOP_GETATTR, v, EINVAL);
Line 942  kernfs_default_xread(void *v)
Line 723  kernfs_default_xread(void *v)
         int error;          int error;
   
         if (ap->a_vp->v_type == VDIR)          if (ap->a_vp->v_type == VDIR)
                 return (EOPNOTSUPP);                  return EISDIR;
   
         off = (int)uio->uio_offset;          off = (int)uio->uio_offset;
         /* Don't allow negative offsets */          /* Don't allow negative offsets */
Line 1115  kernfs_readdir(void *v)
Line 896  kernfs_readdir(void *v)
         int error;          int error;
         off_t *cookies = NULL;          off_t *cookies = NULL;
         int ncookies = 0, n;          int ncookies = 0, n;
 #ifdef IPSEC  
         struct secasvar *sav, *sav2;  
         struct secpolicy *sp;  
 #endif  
   
         if (uio->uio_resid < UIO_MX)          if (uio->uio_resid < UIO_MX)
                 return (EINVAL);                  return (EINVAL);
Line 1169  kernfs_readdir(void *v)
Line 946  kernfs_readdir(void *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 1245  kernfs_readdir(void *v)
Line 1029  kernfs_readdir(void *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 1261  kernfs_readdir(void *v)
Line 1046  kernfs_readdir(void *v)
                 ncookies = n;                  ncookies = n;
                 break;                  break;
   
 #ifdef IPSEC  
         case KFSipsecsadir:  
                 /* count SA in the system */  
                 n = 0;  
                 if (&satailq == NULL)  
                         return 0;  
                 TAILQ_FOREACH(sav, &satailq, tailq) {  
                         for (sav2 = TAILQ_FIRST(&satailq);  
                             sav2 != sav;  
                             sav2 = TAILQ_NEXT(sav2, tailq)) {  
                                 if (sav->spi == sav2->spi) {  
                                         /* multiple SA with same SPI */  
                                         break;  
                                 }  
                         }  
                         if (sav == sav2 || sav->spi != sav2->spi)  
                                 n++;  
                 }  
   
                 if (i >= nipsecsa_targets + n)  
                         return (0);  
   
                 if (ap->a_ncookies) {  
                         ncookies = min(ncookies, (n - i));  
                         cookies = malloc(ncookies * sizeof(off_t), M_TEMP,  
                             M_WAITOK);  
                         *ap->a_cookies = cookies;  
                 }  
   
                 n = 0;  
                 for (; i < nipsecsa_targets && uio->uio_resid >= UIO_MX; i++) {  
                         kt = &ipsecsa_targets[i];  
                         d.d_namlen = kt->kt_namlen;  
                         if ((error = kernfs_setdirentfileno(&d, i, kfs,  
                             &kern_targets[0], kt, ap)) != 0)  
                                 break;  
                         memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);  
                         d.d_type = kt->kt_type;  
                         if ((error = uiomove(&d, UIO_MX, uio)) != 0)  
                                 break;  
                         if (cookies)  
                                 *cookies++ = i + 1;  
                         n++;  
                 }  
                 if (error) {  
                         ncookies = n;  
                         break;  
                 }  
   
                 TAILQ_FOREACH(sav, &satailq, tailq) {  
                         for (sav2 = TAILQ_FIRST(&satailq);  
                             sav2 != sav;  
                             sav2 = TAILQ_NEXT(sav2, tailq)) {  
                                 if (sav->spi == sav2->spi) {  
                                         /* multiple SA with same SPI */  
                                         break;  
                                 }  
                         }  
                         if (sav != sav2 && sav->spi == sav2->spi)  
                                 continue;  
                         if (uio->uio_resid < UIO_MX)  
                                 break;  
                         if ((error = kernfs_setdirentfileno_kt(&d, &ipsecsa_kt,  
                             sav->spi, ap)) != 0)  
                                 break;  
                         d.d_namlen = snprintf(d.d_name, sizeof(d.d_name),  
                             "%u", ntohl(sav->spi));  
                         d.d_type = DT_REG;  
                         if ((error = uiomove(&d, UIO_MX, uio)) != 0)  
                                 break;  
                         if (cookies)  
                                 *cookies++ = i + 1;  
                         n++;  
                         i++;  
                 }  
                 ncookies = n;  
                 break;  
   
         case KFSipsecspdir:  
                 /* count SP in the system */  
                 if (&sptailq == NULL)  
                         return 0;  
   
                 n = 0;  
                 TAILQ_FOREACH(sp, &sptailq, tailq)  
                         n++;  
   
                 if (i >= nipsecsp_targets + n)  
                         return (0);  
   
                 if (ap->a_ncookies) {  
                         ncookies = min(ncookies, (n - i));  
                         cookies = malloc(ncookies * sizeof(off_t), M_TEMP,  
                             M_WAITOK);  
                         *ap->a_cookies = cookies;  
                 }  
   
                 n = 0;  
                 for (; i < nipsecsp_targets && uio->uio_resid >= UIO_MX; i++) {  
                         kt = &ipsecsp_targets[i];  
                         d.d_namlen = kt->kt_namlen;  
                         if ((error = kernfs_setdirentfileno(&d, i, kfs,  
                             &kern_targets[0], kt, ap)) != 0)  
                                 break;  
                         memcpy(d.d_name, kt->kt_name, kt->kt_namlen + 1);  
                         d.d_type = kt->kt_type;  
                         if ((error = uiomove(&d, UIO_MX, uio)) != 0)  
                                 break;  
                         if (cookies)  
                                 *cookies++ = i + 1;  
                         n++;  
                 }  
                 if (error) {  
                         ncookies = n;  
                         break;  
                 }  
   
                 TAILQ_FOREACH(sp, &sptailq, tailq) {  
                         if (uio->uio_resid < UIO_MX)  
                                 break;  
                         if ((error = kernfs_setdirentfileno_kt(&d, &ipsecsp_kt,  
                             sp->id, ap)) != 0)  
                                 break;  
                         d.d_namlen = snprintf(d.d_name, sizeof(d.d_name),  
                             "%u", sp->id);  
                         d.d_type = DT_REG;  
                         if ((error = uiomove(&d, UIO_MX, uio)) != 0)  
                                 break;  
                         if (cookies)  
                                 *cookies++ = i + 1;  
                         n++;  
                         i++;  
                 }  
                 ncookies = n;  
                 break;  
 #endif  
   
         default:          default:
                 error = ENOTDIR;                  error = ENOTDIR;
                 break;                  break;
Line 1425  kernfs_inactive(void *v)
Line 1073  kernfs_inactive(void *v)
                 bool *a_recycle;                  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);  
 #ifdef IPSEC  
         struct mbuf *m;  
         struct secpolicy *sp;  
 #endif  
   
         *ap->a_recycle = false;          *ap->a_recycle = false;
         switch (kfs->kfs_type) {          VOP_UNLOCK(vp);
 #ifdef IPSEC  
         case KFSipsecsa:  
                 if (key_setdumpsa_spi == NULL)  
                         return 0;  
                 m = key_setdumpsa_spi(htonl(kfs->kfs_value));  
                 if (m)  
                         m_freem(m);  
                 else  
                         *ap->a_recycle = true;  
                 break;  
         case KFSipsecsp:  
                 if (key_getspbyid == NULL)  
                         return 0;  
                 sp = key_getspbyid(kfs->kfs_value);  
                 if (sp)  
                         key_freesp(sp);  
                 else {  
                         *ap->a_recycle = true;  
                 }  
                 break;  
 #endif  
         default:  
                 break;  
         }  
         VOP_UNLOCK(vp, 0);  
         return (0);          return (0);
 }  }
   
Line 1540  kernfs_link(void *v)
Line 1158  kernfs_link(void *v)
 int  int
 kernfs_symlink(void *v)  kernfs_symlink(void *v)
 {  {
         struct vop_symlink_args /* {          struct vop_symlink_v3_args /* {
                 struct vnode *a_dvp;                  struct vnode *a_dvp;
                 struct vnode **a_vpp;                  struct vnode **a_vpp;
                 struct componentname *a_cnp;                  struct componentname *a_cnp;
Line 1549  kernfs_symlink(void *v)
Line 1167  kernfs_symlink(void *v)
         } */ *ap = v;          } */ *ap = v;
   
         VOP_ABORTOP(ap->a_dvp, ap->a_cnp);          VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
         vput(ap->a_dvp);  
         return (EROFS);          return (EROFS);
 }  }

Legend:
Removed from v.1.139  
changed lines
  Added in v.1.150

CVSweb <webmaster@jp.NetBSD.org>