1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 /*
  27  * vnode ops for the /dev/net directory
  28  *
  29  *      The lookup is based on the internal vanity naming node table.  We also
  30  *      override readdir in order to delete net nodes no longer in-use.
  31  */
  32 
  33 #include <sys/types.h>
  34 #include <sys/param.h>
  35 #include <sys/sysmacros.h>
  36 #include <sys/sunndi.h>
  37 #include <fs/fs_subr.h>
  38 #include <sys/fs/dv_node.h>
  39 #include <sys/fs/sdev_impl.h>
  40 #include <sys/policy.h>
  41 #include <sys/zone.h>
  42 #include <sys/dls.h>
  43 
  44 struct vnodeops         *devnet_vnodeops;
  45 
  46 /*
  47  * Check if a net sdev_node is still valid - i.e. it represents a current
  48  * network link.
  49  * This serves two purposes
  50  *      - only valid net nodes are returned during lookup() and readdir().
  51  *      - since net sdev_nodes are not actively destroyed when a network link
  52  *        goes away, we use the validator to do deferred cleanup i.e. when such
  53  *        nodes are encountered during subsequent lookup() and readdir().
  54  */
  55 int
  56 devnet_validate(struct sdev_node *dv)
  57 {
  58         datalink_id_t linkid;
  59         zoneid_t zoneid;
  60 
  61         ASSERT(dv->sdev_state == SDEV_READY);
  62 
  63         if (dls_mgmt_get_linkid(dv->sdev_name, &linkid) != 0)
  64                 return (SDEV_VTOR_INVALID);
  65         if (SDEV_IS_GLOBAL(dv))
  66                 return (SDEV_VTOR_VALID);
  67         zoneid = getzoneid();
  68         return (zone_check_datalink(&zoneid, linkid) == 0 ?
  69             SDEV_VTOR_VALID : SDEV_VTOR_INVALID);
  70 }
  71 
  72 /*
  73  * This callback is invoked from devname_lookup_func() to create
  74  * a net entry when the node is not found in the cache.
  75  */
  76 static int
  77 devnet_create_rvp(const char *nm, struct vattr *vap, dls_dl_handle_t *ddhp)
  78 {
  79         timestruc_t now;
  80         dev_t dev;
  81         int error;
  82 
  83         if ((error = dls_devnet_open(nm, ddhp, &dev)) != 0) {
  84                 sdcmn_err12(("devnet_create_rvp: not a valid vanity name "
  85                     "network node: %s\n", nm));
  86                 return (error);
  87         }
  88 
  89         /*
  90          * This is a valid network device (at least at this point in time).
  91          * Create the node by setting the attribute; the rest is taken care
  92          * of by devname_lookup_func().
  93          */
  94         *vap = sdev_vattr_chr;
  95         vap->va_mode |= 0666;
  96         vap->va_rdev = dev;
  97 
  98         gethrestime(&now);
  99         vap->va_atime = now;
 100         vap->va_mtime = now;
 101         vap->va_ctime = now;
 102         return (0);
 103 }
 104 
 105 /*
 106  * Lookup for /dev/net directory
 107  *      If the entry does not exist, the devnet_create_rvp() callback
 108  *      is invoked to create it.  Nodes do not persist across reboot.
 109  */
 110 /*ARGSUSED3*/
 111 static int
 112 devnet_lookup(struct vnode *dvp, char *nm, struct vnode **vpp,
 113     struct pathname *pnp, int flags, struct vnode *rdir, struct cred *cred,
 114     caller_context_t *ct, int *direntflags, pathname_t *realpnp)
 115 {
 116         struct sdev_node *ddv = VTOSDEV(dvp);
 117         struct sdev_node *dv = NULL;
 118         dls_dl_handle_t ddh = NULL;
 119         struct vattr vattr;
 120         int nmlen;
 121         int error = ENOENT;
 122 
 123         if (SDEVTOV(ddv)->v_type != VDIR)
 124                 return (ENOTDIR);
 125 
 126         /*
 127          * Empty name or ., return node itself.
 128          */
 129         nmlen = strlen(nm);
 130         if ((nmlen == 0) || ((nmlen == 1) && (nm[0] == '.'))) {
 131                 *vpp = SDEVTOV(ddv);
 132                 VN_HOLD(*vpp);
 133                 return (0);
 134         }
 135 
 136         /*
 137          * .., return the parent directory
 138          */
 139         if ((nmlen == 2) && (strcmp(nm, "..") == 0)) {
 140                 *vpp = SDEVTOV(ddv->sdev_dotdot);
 141                 VN_HOLD(*vpp);
 142                 return (0);
 143         }
 144 
 145         rw_enter(&ddv->sdev_contents, RW_WRITER);
 146 
 147         /*
 148          * directory cache lookup:
 149          */
 150         if ((dv = sdev_cache_lookup(ddv, nm)) != NULL) {
 151                 ASSERT(dv->sdev_state == SDEV_READY);
 152                 if (!(dv->sdev_flags & SDEV_ATTR_INVALID))
 153                         goto found;
 154         }
 155 
 156         /*
 157          * ZOMBIED parent does not allow new node creation, bail out early.
 158          */
 159         if (ddv->sdev_state == SDEV_ZOMBIE)
 160                 goto failed;
 161 
 162         error = devnet_create_rvp(nm, &vattr, &ddh);
 163         if (error != 0)
 164                 goto failed;
 165 
 166         error = sdev_mknode(ddv, nm, &dv, &vattr, NULL, NULL, cred, SDEV_READY);
 167         if (error != 0) {
 168                 dls_devnet_close(ddh);
 169                 goto failed;
 170         }
 171 
 172         ASSERT(dv != NULL);
 173 
 174         rw_enter(&dv->sdev_contents, RW_WRITER);
 175         if (dv->sdev_flags & SDEV_ATTR_INVALID) {
 176                 /*
 177                  * SDEV_ATTR_INVALID means that this device has been
 178                  * detached, and its dev_t might've been changed too.
 179                  * Therefore, sdev_node's 'vattr' needs to be updated.
 180                  */
 181                 SDEVTOV(dv)->v_rdev = vattr.va_rdev;
 182                 ASSERT(dv->sdev_attr != NULL);
 183                 dv->sdev_attr->va_rdev = vattr.va_rdev;
 184                 dv->sdev_flags &= ~SDEV_ATTR_INVALID;
 185         }
 186         ASSERT(dv->sdev_private == NULL);
 187         dv->sdev_private = ddh;
 188         rw_exit(&dv->sdev_contents);
 189 
 190 found:
 191         ASSERT(SDEV_HELD(dv));
 192         rw_exit(&ddv->sdev_contents);
 193         return (sdev_to_vp(dv, vpp));
 194 
 195 failed:
 196         rw_exit(&ddv->sdev_contents);
 197 
 198         if (dv != NULL)
 199                 SDEV_RELE(dv);
 200 
 201         *vpp = NULL;
 202         return (error);
 203 }
 204 
 205 static int
 206 devnet_filldir_datalink(datalink_id_t linkid, void *arg)
 207 {
 208         struct sdev_node        *ddv = arg;
 209         struct vattr            vattr;
 210         struct sdev_node        *dv;
 211         dls_dl_handle_t         ddh = NULL;
 212         char                    link[MAXLINKNAMELEN];
 213 
 214         ASSERT(RW_WRITE_HELD(&ddv->sdev_contents));
 215 
 216         if (dls_mgmt_get_linkinfo(linkid, link, NULL, NULL, NULL) != 0)
 217                 return (0);
 218 
 219         if ((dv = sdev_cache_lookup(ddv, (char *)link)) != NULL)
 220                 goto found;
 221 
 222         if (devnet_create_rvp(link, &vattr, &ddh) != 0)
 223                 return (0);
 224 
 225         ASSERT(ddh != NULL);
 226         dls_devnet_close(ddh);
 227 
 228         if (sdev_mknode(ddv, (char *)link, &dv, &vattr, NULL, NULL, kcred,
 229             SDEV_READY) != 0) {
 230                 return (0);
 231         }
 232 
 233         /*
 234          * As there is no reference holding the network device, it could be
 235          * detached. Set SDEV_ATTR_INVALID so that the 'vattr' will be updated
 236          * later.
 237          */
 238         rw_enter(&dv->sdev_contents, RW_WRITER);
 239         dv->sdev_flags |= SDEV_ATTR_INVALID;
 240         rw_exit(&dv->sdev_contents);
 241 
 242 found:
 243         SDEV_SIMPLE_RELE(dv);
 244         return (0);
 245 }
 246 
 247 static void
 248 devnet_filldir(struct sdev_node *ddv)
 249 {
 250         sdev_node_t     *dv, *next;
 251         datalink_id_t   linkid;
 252 
 253         ASSERT(RW_READ_HELD(&ddv->sdev_contents));
 254         if (rw_tryupgrade(&ddv->sdev_contents) == NULL) {
 255                 rw_exit(&ddv->sdev_contents);
 256                 rw_enter(&ddv->sdev_contents, RW_WRITER);
 257         }
 258 
 259         for (dv = SDEV_FIRST_ENTRY(ddv); dv; dv = next) {
 260                 next = SDEV_NEXT_ENTRY(ddv, dv);
 261 
 262                 /* validate and prune only ready nodes */
 263                 if (dv->sdev_state != SDEV_READY)
 264                         continue;
 265 
 266                 switch (devnet_validate(dv)) {
 267                 case SDEV_VTOR_VALID:
 268                 case SDEV_VTOR_SKIP:
 269                         continue;
 270                 case SDEV_VTOR_INVALID:
 271                 case SDEV_VTOR_STALE:
 272                         sdcmn_err12(("devnet_filldir: destroy invalid "
 273                             "node: %s(%p)\n", dv->sdev_name, (void *)dv));
 274                         break;
 275                 }
 276 
 277                 if (SDEVTOV(dv)->v_count > 0)
 278                         continue;
 279                 SDEV_HOLD(dv);
 280                 /* remove the cache node */
 281                 (void) sdev_cache_update(ddv, &dv, dv->sdev_name,
 282                     SDEV_CACHE_DELETE);
 283                 SDEV_RELE(dv);
 284         }
 285 
 286         if (((ddv->sdev_flags & SDEV_BUILD) == 0) && !dls_devnet_rebuild())
 287                 goto done;
 288 
 289         if (SDEV_IS_GLOBAL(ddv)) {
 290                 linkid = DATALINK_INVALID_LINKID;
 291                 do {
 292                         linkid = dls_mgmt_get_next(linkid, DATALINK_CLASS_ALL,
 293                             DATALINK_ANY_MEDIATYPE, DLMGMT_ACTIVE);
 294                         if (linkid != DATALINK_INVALID_LINKID)
 295                                 (void) devnet_filldir_datalink(linkid, ddv);
 296                 } while (linkid != DATALINK_INVALID_LINKID);
 297         } else {
 298                 (void) zone_datalink_walk(getzoneid(),
 299                     devnet_filldir_datalink, ddv);
 300         }
 301 
 302         ddv->sdev_flags &= ~SDEV_BUILD;
 303 
 304 done:
 305         rw_downgrade(&ddv->sdev_contents);
 306 }
 307 
 308 /*
 309  * Display all instantiated network datalink device nodes.
 310  * A /dev/net entry will be created only after the first lookup of
 311  * the network datalink device succeeds.
 312  */
 313 /*ARGSUSED4*/
 314 static int
 315 devnet_readdir(struct vnode *dvp, struct uio *uiop, struct cred *cred,
 316     int *eofp, caller_context_t *ct, int flags)
 317 {
 318         struct sdev_node *sdvp = VTOSDEV(dvp);
 319 
 320         ASSERT(sdvp);
 321 
 322         if (uiop->uio_offset == 0)
 323                 devnet_filldir(sdvp);
 324 
 325         return (devname_readdir_func(dvp, uiop, cred, eofp, 0));
 326 }
 327 
 328 /*
 329  * This callback is invoked from devname_inactive_func() to release
 330  * the net entry which was held in devnet_create_rvp().
 331  */
 332 static void
 333 devnet_inactive_callback(struct vnode *dvp)
 334 {
 335         struct sdev_node *sdvp = VTOSDEV(dvp);
 336         dls_dl_handle_t ddh;
 337 
 338         if (dvp->v_type == VDIR)
 339                 return;
 340 
 341         ASSERT(dvp->v_type == VCHR);
 342         rw_enter(&sdvp->sdev_contents, RW_WRITER);
 343         ddh = sdvp->sdev_private;
 344         sdvp->sdev_private = NULL;
 345         sdvp->sdev_flags |= SDEV_ATTR_INVALID;
 346         rw_exit(&sdvp->sdev_contents);
 347 
 348         /*
 349          * "ddh" (sdev_private) could be NULL if devnet_lookup fails.
 350          */
 351         if (ddh != NULL)
 352                 dls_devnet_close(ddh);
 353 }
 354 
 355 /*ARGSUSED*/
 356 static void
 357 devnet_inactive(struct vnode *dvp, struct cred *cred, caller_context_t *ct)
 358 {
 359         devname_inactive_func(dvp, cred, devnet_inactive_callback);
 360 }
 361 
 362 /*
 363  * We override lookup and readdir to build entries based on the
 364  * in kernel vanity naming node table.
 365  */
 366 const fs_operation_def_t devnet_vnodeops_tbl[] = {
 367         { VOPNAME_READDIR,      { .vop_readdir = devnet_readdir } },
 368         { VOPNAME_LOOKUP,       { .vop_lookup = devnet_lookup } },
 369         { VOPNAME_INACTIVE,     { .vop_inactive = devnet_inactive } },
 370         { VOPNAME_CREATE,       { .error = fs_nosys } },
 371         { VOPNAME_REMOVE,       { .error = fs_nosys } },
 372         { VOPNAME_MKDIR,        { .error = fs_nosys } },
 373         { VOPNAME_RMDIR,        { .error = fs_nosys } },
 374         { VOPNAME_SYMLINK,      { .error = fs_nosys } },
 375         { VOPNAME_SETSECATTR,   { .error = fs_nosys } },
 376         { NULL,                 { NULL } }
 377 };