usr/src/uts/common/fs/smbclnt/smbfs/smbfs_node.c

   1 /*
   2  * Copyright (c) 2000-2001 Boris Popov
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *    This product includes software developed by Boris Popov.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $Id: smbfs_node.c,v 1.54.52.1 2005/05/27 02:35:28 lindak Exp $
  33  */
  34
  35 /*
  36  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  37  * Use is subject to license terms.
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/cred.h>
  43 #include <sys/time.h>
  44 #include <sys/vfs.h>
  45 #include <sys/vnode.h>
  46 #include <sys/kmem.h>
  47 #include <sys/stat.h>
  48 #include <sys/atomic.h>
  49 #include <sys/cmn_err.h>
  50 #include <sys/sysmacros.h>
  51 #include <sys/bitmap.h>
  52
  53 #include <netsmb/smb_osdep.h>
  54
  55 #include <netsmb/smb.h>
  56 #include <netsmb/smb_conn.h>
  57 #include <netsmb/smb_subr.h>
  58
  59 #include <smbfs/smbfs.h>
  60 #include <smbfs/smbfs_node.h>
  61 #include <smbfs/smbfs_subr.h>
  62
  63 /*
  64  * Lack of inode numbers leads us to the problem of generating them.
  65  * Partially this problem can be solved by having a dir/file cache
  66  * with inode numbers generated from the incremented by one counter.
  67  * However this way will require too much kernel memory, gives all
  68  * sorts of locking and consistency problems, not to mentinon counter
  69  * overflows. So, I'm decided to use a hash function to generate
  70  * pseudo random (and [often?] unique) inode numbers.
  71  */
  72
  73 /* Magic constants for name hashing. */
  74 #define FNV_32_PRIME ((uint32_t)0x01000193UL)
  75 #define FNV1_32_INIT ((uint32_t)33554467UL)
  76
  77 static inline uint32_t
  78 smbfs_hash(uint32_t ival, const char *name, int nmlen)
  79 {
  80         uint32_t v;
  81
  82         for (v = ival; nmlen; name++, nmlen--) {
  83                 v *= FNV_32_PRIME;
  84                 v ^= (uint32_t)*name;
  85         }
  86         return (v);
  87 }
  88
  89 /*
  90  * Compute the hash of the full (remote) path name
  91  * using the three parts supplied separately.
  92  */
  93 uint32_t
  94 smbfs_gethash(const char *rpath, int rplen)
  95 {
  96         uint32_t v;
  97
  98         v = smbfs_hash(FNV1_32_INIT, rpath, rplen);
  99         return (v);
 100 }
 101
 102 /*
 103  * Like smbfs_gethash, but optimized a little by
 104  * starting with the directory hash.
 105  */
 106 uint32_t
 107 smbfs_getino(struct smbnode *dnp, const char *name, int nmlen)
 108 {
 109         uint32_t ino;
 110         char sep;
 111
 112         /* Start with directory hash */
 113         ino = (uint32_t)dnp->n_ino;
 114
 115         /* separator (maybe) */
 116         sep = SMBFS_DNP_SEP(dnp);
 117         if (sep)
 118                 ino = smbfs_hash(ino, &sep, 1);
 119
 120         /* Now hash this component. */
 121         ino = smbfs_hash(ino, name, nmlen);
 122
 123         return (ino);
 124 }
 125
 126 /*
 127  * Allocate and copy a string of passed length.
 128  * The passed length does NOT include the null.
 129  */
 130 char *
 131 smbfs_name_alloc(const char *name, int nmlen)
 132 {
 133         char *cp;
 134
 135         cp = kmem_alloc(nmlen + 1, KM_SLEEP);
 136         bcopy(name, cp, nmlen);
 137         cp[nmlen] = 0;
 138
 139         return (cp);
 140 }
 141
 142 /*
 143  * Free string from smbfs_name_alloc().  Again,
 144  * the passed length does NOT include the null.
 145  */
 146 void
 147 smbfs_name_free(const char *name, int nmlen)
 148 {
 149         kmem_free((char *)name, nmlen + 1);
 150 }
 151
 152 /*
 153  * smbfs_nget()
 154  *
 155  * Find or create a node under some directory node.
 156  */
 157 int
 158 smbfs_nget(vnode_t *dvp, const char *name, int nmlen,
 159         struct smbfattr *fap, vnode_t **vpp)
 160 {
 161         struct smbnode *dnp = VTOSMB(dvp);
 162         struct smbnode *np;
 163         vnode_t *vp;
 164         char sep;
 165
 166         ASSERT(fap != NULL);
 167         *vpp = NULL;
 168
 169         /* Don't expect "" or "." or ".." here anymore. */
 170         if (nmlen == 0 || (nmlen == 1 && name[0] == '.') ||
 171             (nmlen == 2 && name[0] == '.' && name[1] == '.')) {
 172                 return (EINVAL);
 173         }
 174         sep = SMBFS_DNP_SEP(dnp);
 175
 176         /* Find or create the node. */
 177         np = smbfs_node_findcreate(dnp->n_mount,
 178             dnp->n_rpath, dnp->n_rplen,
 179             name, nmlen, sep, fap);
 180
 181         /*
 182          * We should have np now, because we passed
 183          * fap != NULL to smbfs_node_findcreate.
 184          */
 185         ASSERT(np != NULL);
 186         vp = SMBTOV(np);
 187
 188         /*
 189          * Files in an XATTR dir are also XATTR.
 190          */
 191         if (dnp->n_flag & N_XATTR) {
 192                 mutex_enter(&np->r_statelock);
 193                 np->n_flag |= N_XATTR;
 194                 mutex_exit(&np->r_statelock);
 195         }
 196
 197         /* BSD symlink hack removed (smb_symmagic) */
 198
 199         *vpp = vp;
 200
 201         return (0);
 202 }
 203
 204 /*
 205  * Update the local notion of the mtime of some directory.
 206  * See comments re. r_mtime in smbfs_node.h
 207  */
 208 void
 209 smbfs_attr_touchdir(struct smbnode *dnp)
 210 {
 211
 212         mutex_enter(&dnp->r_statelock);
 213
 214         /*
 215          * Now that we keep the client's notion of mtime
 216          * separately from the server, this is easy.
 217          */
 218         dnp->r_mtime = gethrtime();
 219
 220         /*
 221          * Invalidate the cache, so that we go to the wire
 222          * to check that the server doesn't have a better
 223          * timestamp next time we care.
 224          */
 225         smbfs_attrcache_rm_locked(dnp);
 226         mutex_exit(&dnp->r_statelock);
 227 }
 228
 229 void
 230 smbfs_attrcache_remove(struct smbnode *np)
 231 {
 232         mutex_enter(&np->r_statelock);
 233         /* smbfs_attrcache_rm_locked(np); */
 234         np->r_attrtime = gethrtime();
 235         mutex_exit(&np->r_statelock);
 236 }
 237
 238 /* See smbfs_node.h */
 239 #undef smbfs_attrcache_rm_locked
 240 void
 241 smbfs_attrcache_rm_locked(struct smbnode *np)
 242 {
 243         ASSERT(MUTEX_HELD(&np->r_statelock));
 244         np->r_attrtime = gethrtime();
 245 }