usr/src/uts/common/fs/sharefs/sharefs_vnops.c

   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 /*
  23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <fs/fs_subr.h>
  28
  29 #include <sys/errno.h>
  30 #include <sys/file.h>
  31 #include <sys/kmem.h>
  32 #include <sys/kobj.h>
  33 #include <sys/cmn_err.h>
  34 #include <sys/stat.h>
  35 #include <sys/systm.h>
  36 #include <sys/sysmacros.h>
  37 #include <sys/atomic.h>
  38 #include <sys/vfs.h>
  39 #include <sys/vfs_opreg.h>
  40
  41 #include <sharefs/sharefs.h>
  42
  43 /*
  44  * sharefs_snap_create: create a large character buffer with
  45  * the shares enumerated.
  46  */
  47 static int
  48 sharefs_snap_create(shnode_t *sft)
  49 {
  50         sharetab_t              *sht;
  51         share_t                 *sh;
  52         size_t                  sWritten = 0;
  53         int                     iCount = 0;
  54         char                    *buf;
  55
  56         rw_enter(&sharefs_lock, RW_WRITER);
  57         rw_enter(&sharetab_lock, RW_READER);
  58
  59         if (sft->sharefs_snap) {
  60                 /*
  61                  * Nothing has changed, so no need to grab a new copy!
  62                  */
  63                 if (sft->sharefs_generation == sharetab_generation) {
  64                         rw_exit(&sharetab_lock);
  65                         rw_exit(&sharefs_lock);
  66                         return (0);
  67                 }
  68
  69                 ASSERT(sft->sharefs_size != 0);
  70                 kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
  71                 sft->sharefs_snap = NULL;
  72         }
  73
  74         sft->sharefs_size = sharetab_size;
  75         sft->sharefs_count = sharetab_count;
  76
  77         if (sft->sharefs_size == 0) {
  78                 rw_exit(&sharetab_lock);
  79                 rw_exit(&sharefs_lock);
  80                 return (0);
  81         }
  82
  83         sft->sharefs_snap = kmem_zalloc(sft->sharefs_size + 1, KM_SLEEP);
  84
  85         buf = sft->sharefs_snap;
  86
  87         /*
  88          * Walk the Sharetab, dumping each entry.
  89          */
  90         for (sht = sharefs_sharetab; sht != NULL; sht = sht->s_next) {
  91                 int     i;
  92
  93                 for (i = 0; i < SHARETAB_HASHES; i++) {
  94                         for (sh = sht->s_buckets[i].ssh_sh;
  95                             sh != NULL;
  96                             sh = sh->sh_next) {
  97                                 int     n;
  98
  99                                 if ((sWritten + sh->sh_size) >
 100                                     sft->sharefs_size) {
 101                                         goto error_fault;
 102                                 }
 103
 104                                 /*
 105                                  * Note that sh->sh_size accounts
 106                                  * for the field seperators.
 107                                  * We need to add one for the EOL
 108                                  * marker. And we should note that
 109                                  * the space is accounted for in
 110                                  * each share by the EOS marker.
 111                                  */
 112                                 n = snprintf(&buf[sWritten],
 113                                     sh->sh_size + 1,
 114                                     "%s\t%s\t%s\t%s\t%s\n",
 115                                     sh->sh_path,
 116                                     sh->sh_res,
 117                                     sh->sh_fstype,
 118                                     sh->sh_opts,
 119                                     sh->sh_descr);
 120
 121                                 if (n != sh->sh_size) {
 122                                         goto error_fault;
 123                                 }
 124
 125                                 sWritten += n;
 126                                 iCount++;
 127                         }
 128                 }
 129         }
 130
 131         /*
 132          * We want to record the generation number and
 133          * mtime inside this snapshot.
 134          */
 135         gethrestime(&sharetab_snap_time);
 136         sft->sharefs_snap_time = sharetab_snap_time;
 137         sft->sharefs_generation = sharetab_generation;
 138
 139         ASSERT(iCount == sft->sharefs_count);
 140
 141         rw_exit(&sharetab_lock);
 142         rw_exit(&sharefs_lock);
 143         return (0);
 144
 145 error_fault:
 146
 147         kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
 148         sft->sharefs_size = 0;
 149         sft->sharefs_count = 0;
 150         sft->sharefs_snap = NULL;
 151         rw_exit(&sharetab_lock);
 152         rw_exit(&sharefs_lock);
 153
 154         return (EFAULT);
 155 }
 156
 157 /* ARGSUSED */
 158 static int
 159 sharefs_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
 160     caller_context_t *ct)
 161 {
 162         timestruc_t     now;
 163         shnode_t        *sft = VTOSH(vp);
 164
 165         vap->va_type = VREG;
 166         vap->va_mode = S_IRUSR | S_IRGRP | S_IROTH;
 167         vap->va_nodeid = SHAREFS_INO_FILE;
 168         vap->va_nlink = 1;
 169
 170         rw_enter(&sharefs_lock, RW_READER);
 171
 172         /*
 173          * If we get asked about a snapped vnode, then
 174          * we must report the data in that vnode.
 175          *
 176          * Else we report what is currently in the
 177          * sharetab.
 178          */
 179         if (sft->sharefs_real_vp) {
 180                 rw_enter(&sharetab_lock, RW_READER);
 181                 vap->va_size = sharetab_size;
 182                 vap->va_mtime = sharetab_mtime;
 183                 rw_exit(&sharetab_lock);
 184         } else {
 185                 vap->va_size = sft->sharefs_size;
 186                 vap->va_mtime = sft->sharefs_snap_time;
 187         }
 188         rw_exit(&sharefs_lock);
 189
 190         gethrestime(&now);
 191         vap->va_atime = vap->va_ctime = now;
 192
 193         vap->va_uid = 0;
 194         vap->va_gid = 0;
 195         vap->va_rdev = 0;
 196         vap->va_blksize = DEV_BSIZE;
 197         vap->va_nblocks = howmany(vap->va_size, vap->va_blksize);
 198         vap->va_seq = 0;
 199         vap->va_fsid = vp->v_vfsp->vfs_dev;
 200
 201         return (0);
 202 }
 203
 204 /* ARGSUSED */
 205 static int
 206 sharefs_access(vnode_t *vp, int mode, int flags, cred_t *cr,
 207     caller_context_t *ct)
 208 {
 209         if (mode & (VWRITE|VEXEC))
 210                 return (EROFS);
 211
 212         return (0);
 213 }
 214
 215 /* ARGSUSED */
 216 int
 217 sharefs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)
 218 {
 219         vnode_t         *vp;
 220         vnode_t         *ovp = *vpp;
 221         shnode_t        *sft;
 222         int             error = 0;
 223
 224         if (flag & FWRITE)
 225                 return (EINVAL);
 226
 227         /*
 228          * Create a new sharefs vnode for each operation. In order to
 229          * avoid locks, we create a snapshot which can not change during
 230          * reads.
 231          */
 232         vp = gfs_file_create(sizeof (shnode_t), NULL, sharefs_ops_data);
 233
 234         ((gfs_file_t *)vp->v_data)->gfs_ino = SHAREFS_INO_FILE;
 235
 236         /*
 237          * Hold the parent!
 238          */
 239         VFS_HOLD(ovp->v_vfsp);
 240
 241         VN_SET_VFS_TYPE_DEV(vp, ovp->v_vfsp, VREG, 0);
 242
 243         vp->v_flag |= VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT;
 244
 245         *vpp = vp;
 246         VN_RELE(ovp);
 247
 248         sft = VTOSH(vp);
 249
 250         /*
 251          * No need for the lock, no other thread can be accessing
 252          * this data structure.
 253          */
 254         atomic_inc_32(&sft->sharefs_refs);
 255         sft->sharefs_real_vp = 0;
 256
 257         /*
 258          * Since the sharetab could easily change on us whilst we
 259          * are dumping an extremely huge sharetab, we make a copy
 260          * of it here and use it to dump instead.
 261          */
 262         error = sharefs_snap_create(sft);
 263
 264         return (error);
 265 }
 266
 267 /* ARGSUSED */
 268 int
 269 sharefs_close(vnode_t *vp, int flag, int count,
 270     offset_t off, cred_t *cr, caller_context_t *ct)
 271 {
 272         shnode_t        *sft = VTOSH(vp);
 273
 274         if (count > 1)
 275                 return (0);
 276
 277         rw_enter(&sharefs_lock, RW_WRITER);
 278         if (vp->v_count == 1) {
 279                 if (sft->sharefs_snap != NULL) {
 280                         kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
 281                         sft->sharefs_size = 0;
 282                         sft->sharefs_snap = NULL;
 283                         sft->sharefs_generation = 0;
 284                 }
 285         }
 286         atomic_dec_32(&sft->sharefs_refs);
 287         rw_exit(&sharefs_lock);
 288
 289         return (0);
 290 }
 291
 292 /* ARGSUSED */
 293 static int
 294 sharefs_read(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cr,
 295                         caller_context_t *ct)
 296 {
 297         shnode_t        *sft = VTOSH(vp);
 298         off_t           off = uio->uio_offset;
 299         size_t          len = uio->uio_resid;
 300         int             error = 0;
 301
 302         rw_enter(&sharefs_lock, RW_READER);
 303
 304         /*
 305          * First check to see if we need to grab a new snapshot.
 306          */
 307         if (off == (off_t)0) {
 308                 rw_exit(&sharefs_lock);
 309                 error = sharefs_snap_create(sft);
 310                 if (error) {
 311                         return (EFAULT);
 312                 }
 313                 rw_enter(&sharefs_lock, RW_READER);
 314         }
 315
 316         /* LINTED */
 317         if (len <= 0 || off >= sft->sharefs_size) {
 318                 rw_exit(&sharefs_lock);
 319                 return (error);
 320         }
 321
 322         if ((size_t)(off + len) > sft->sharefs_size)
 323                 len = sft->sharefs_size - off;
 324
 325         if (off < 0 || len > sft->sharefs_size) {
 326                 rw_exit(&sharefs_lock);
 327                 return (EFAULT);
 328         }
 329
 330         if (len != 0) {
 331                 error = uiomove(sft->sharefs_snap + off,
 332                     len, UIO_READ, uio);
 333         }
 334
 335         rw_exit(&sharefs_lock);
 336         return (error);
 337 }
 338
 339 /* ARGSUSED */
 340 static void
 341 sharefs_inactive(vnode_t *vp, cred_t *cr, caller_context_t *tx)
 342 {
 343         gfs_file_t      *fp = vp->v_data;
 344         shnode_t        *sft;
 345
 346         sft = (shnode_t *)gfs_file_inactive(vp);
 347         if (sft) {
 348                 rw_enter(&sharefs_lock, RW_WRITER);
 349                 if (sft->sharefs_snap != NULL) {
 350                         kmem_free(sft->sharefs_snap, sft->sharefs_size + 1);
 351                 }
 352
 353                 kmem_free(sft, fp->gfs_size);
 354                 rw_exit(&sharefs_lock);
 355         }
 356 }
 357
 358 vnode_t *
 359 sharefs_create_root_file(vfs_t *vfsp)
 360 {
 361         vnode_t         *vp;
 362         shnode_t        *sft;
 363
 364         vp = gfs_root_create_file(sizeof (shnode_t),
 365             vfsp, sharefs_ops_data, SHAREFS_INO_FILE);
 366
 367         sft = VTOSH(vp);
 368
 369         sft->sharefs_real_vp = 1;
 370
 371         return (vp);
 372 }
 373
 374 const fs_operation_def_t sharefs_tops_data[] = {
 375         { VOPNAME_OPEN,         { .vop_open = sharefs_open } },
 376         { VOPNAME_CLOSE,        { .vop_close = sharefs_close } },
 377         { VOPNAME_IOCTL,        { .error = fs_inval } },
 378         { VOPNAME_GETATTR,      { .vop_getattr = sharefs_getattr } },
 379         { VOPNAME_ACCESS,       { .vop_access = sharefs_access } },
 380         { VOPNAME_INACTIVE,     { .vop_inactive = sharefs_inactive } },
 381         { VOPNAME_READ,         { .vop_read = sharefs_read } },
 382         { VOPNAME_SEEK,         { .vop_seek = fs_seek } },
 383         { NULL }
 384 };