1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2000-2001 Boris Popov 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/fnv_hash.h> 33 #include <sys/kernel.h> 34 #include <sys/lock.h> 35 #include <sys/malloc.h> 36 #include <sys/mount.h> 37 #include <sys/proc.h> 38 #include <sys/queue.h> 39 #include <sys/stat.h> 40 #include <sys/sx.h> 41 #include <sys/sysctl.h> 42 #include <sys/time.h> 43 #include <sys/vnode.h> 44 45 #include <netsmb/smb.h> 46 #include <netsmb/smb_conn.h> 47 #include <netsmb/smb_subr.h> 48 49 #include <vm/vm.h> 50 #include <vm/vm_extern.h> 51 /*#include <vm/vm_page.h> 52 #include <vm/vm_object.h>*/ 53 54 #include <fs/smbfs/smbfs.h> 55 #include <fs/smbfs/smbfs_node.h> 56 #include <fs/smbfs/smbfs_subr.h> 57 58 extern struct vop_vector smbfs_vnodeops; /* XXX -> .h file */ 59 60 static MALLOC_DEFINE(M_SMBNODE, "smbufs_node", "SMBFS vnode private part"); 61 static MALLOC_DEFINE(M_SMBNODENAME, "smbufs_nname", "SMBFS node name"); 62 63 u_int32_t __inline 64 smbfs_hash(const u_char *name, int nmlen) 65 { 66 return (fnv_32_buf(name, nmlen, FNV1_32_INIT)); 67 } 68 69 static char * 70 smbfs_name_alloc(const u_char *name, int nmlen) 71 { 72 u_char *cp; 73 74 nmlen++; 75 cp = malloc(nmlen, M_SMBNODENAME, M_WAITOK); 76 bcopy(name, cp, nmlen - 1); 77 cp[nmlen - 1] = 0; 78 return cp; 79 } 80 81 static void 82 smbfs_name_free(u_char *name) 83 { 84 85 free(name, M_SMBNODENAME); 86 } 87 88 static int __inline 89 smbfs_vnode_cmp(struct vnode *vp, void *_sc) 90 { 91 struct smbnode *np; 92 struct smbcmp *sc; 93 94 np = (struct smbnode *) vp->v_data; 95 sc = (struct smbcmp *) _sc; 96 if (np->n_parent != sc->n_parent || np->n_nmlen != sc->n_nmlen || 97 bcmp(sc->n_name, np->n_name, sc->n_nmlen) != 0) 98 return 1; 99 return 0; 100 } 101 102 static int 103 smbfs_node_alloc(struct mount *mp, struct vnode *dvp, const char *dirnm, 104 int dirlen, const char *name, int nmlen, char sep, 105 struct smbfattr *fap, struct vnode **vpp) 106 { 107 struct vattr vattr; 108 struct thread *td = curthread; /* XXX */ 109 struct smbmount *smp = VFSTOSMBFS(mp); 110 struct smbnode *np, *dnp; 111 struct vnode *vp, *vp2; 112 struct smbcmp sc; 113 char *p, *rpath; 114 int error, rplen; 115 116 sc.n_parent = dvp; 117 sc.n_nmlen = nmlen; 118 sc.n_name = name; 119 if (smp->sm_root != NULL && dvp == NULL) { 120 SMBERROR("do not allocate root vnode twice!\n"); 121 return EINVAL; 122 } 123 if (nmlen == 2 && bcmp(name, "..", 2) == 0) { 124 if (dvp == NULL) 125 return EINVAL; 126 vp = VTOSMB(VTOSMB(dvp)->n_parent)->n_vnode; 127 error = vget(vp, LK_EXCLUSIVE); 128 if (error == 0) 129 *vpp = vp; 130 return error; 131 } else if (nmlen == 1 && name[0] == '.') { 132 SMBERROR("do not call me with dot!\n"); 133 return EINVAL; 134 } 135 dnp = dvp ? VTOSMB(dvp) : NULL; 136 if (dnp == NULL && dvp != NULL) { 137 vn_printf(dvp, "smbfs_node_alloc: dead parent vnode "); 138 return EINVAL; 139 } 140 error = vfs_hash_get(mp, smbfs_hash(name, nmlen), LK_EXCLUSIVE, td, 141 vpp, smbfs_vnode_cmp, &sc); 142 if (error) 143 return (error); 144 if (*vpp) { 145 np = VTOSMB(*vpp); 146 /* Force cached attributes to be refreshed if stale. */ 147 (void)VOP_GETATTR(*vpp, &vattr, td->td_ucred); 148 /* 149 * If the file type on the server is inconsistent with 150 * what it was when we created the vnode, kill the 151 * bogus vnode now and fall through to the code below 152 * to create a new one with the right type. 153 */ 154 if (((*vpp)->v_type == VDIR && 155 (np->n_dosattr & SMB_FA_DIR) == 0) || 156 ((*vpp)->v_type == VREG && 157 (np->n_dosattr & SMB_FA_DIR) != 0)) { 158 vgone(*vpp); 159 vput(*vpp); 160 } 161 else { 162 SMBVDEBUG("vnode taken from the hashtable\n"); 163 return (0); 164 } 165 } 166 /* 167 * If we don't have node attributes, then it is an explicit lookup 168 * for an existing vnode. 169 */ 170 if (fap == NULL) 171 return ENOENT; 172 173 error = getnewvnode("smbfs", mp, &smbfs_vnodeops, vpp); 174 if (error) 175 return (error); 176 vp = *vpp; 177 np = malloc(sizeof *np, M_SMBNODE, M_WAITOK | M_ZERO); 178 rplen = dirlen; 179 if (sep != '\0') 180 rplen++; 181 rplen += nmlen; 182 rpath = malloc(rplen + 1, M_SMBNODENAME, M_WAITOK); 183 p = rpath; 184 bcopy(dirnm, p, dirlen); 185 p += dirlen; 186 if (sep != '\0') 187 *p++ = sep; 188 if (name != NULL) { 189 bcopy(name, p, nmlen); 190 p += nmlen; 191 } 192 *p = '\0'; 193 MPASS(p == rpath + rplen); 194 lockmgr(vp->v_vnlock, LK_EXCLUSIVE, NULL); 195 /* Vnode initialization */ 196 vp->v_type = fap->fa_attr & SMB_FA_DIR ? VDIR : VREG; 197 vp->v_data = np; 198 np->n_vnode = vp; 199 np->n_mount = VFSTOSMBFS(mp); 200 np->n_rpath = rpath; 201 np->n_rplen = rplen; 202 np->n_nmlen = nmlen; 203 np->n_name = smbfs_name_alloc(name, nmlen); 204 np->n_ino = fap->fa_ino; 205 if (dvp) { 206 ASSERT_VOP_LOCKED(dvp, "smbfs_node_alloc"); 207 np->n_parent = dvp; 208 np->n_parentino = VTOSMB(dvp)->n_ino; 209 if (/*vp->v_type == VDIR &&*/ (dvp->v_vflag & VV_ROOT) == 0) { 210 vref(dvp); 211 np->n_flag |= NREFPARENT; 212 } 213 } else if (vp->v_type == VREG) 214 SMBERROR("new vnode '%s' born without parent ?\n", np->n_name); 215 error = insmntque(vp, mp); 216 if (error) { 217 free(np, M_SMBNODE); 218 return (error); 219 } 220 error = vfs_hash_insert(vp, smbfs_hash(name, nmlen), LK_EXCLUSIVE, 221 td, &vp2, smbfs_vnode_cmp, &sc); 222 if (error) 223 return (error); 224 if (vp2 != NULL) 225 *vpp = vp2; 226 return (0); 227 } 228 229 int 230 smbfs_nget(struct mount *mp, struct vnode *dvp, const char *name, int nmlen, 231 struct smbfattr *fap, struct vnode **vpp) 232 { 233 struct smbnode *dnp; 234 struct vnode *vp; 235 int error, sep; 236 237 dnp = (dvp) ? VTOSMB(dvp) : NULL; 238 sep = 0; 239 if (dnp != NULL) { 240 sep = SMBFS_DNP_SEP(dnp); 241 error = smbfs_node_alloc(mp, dvp, dnp->n_rpath, dnp->n_rplen, 242 name, nmlen, sep, fap, &vp); 243 } else 244 error = smbfs_node_alloc(mp, NULL, "\\", 1, name, nmlen, 245 sep, fap, &vp); 246 if (error) 247 return error; 248 MPASS(vp != NULL); 249 if (fap) 250 smbfs_attr_cacheenter(vp, fap); 251 *vpp = vp; 252 return 0; 253 } 254 255 /* 256 * Free smbnode, and give vnode back to system 257 */ 258 int 259 smbfs_reclaim(ap) 260 struct vop_reclaim_args /* { 261 struct vnode *a_vp; 262 } */ *ap; 263 { 264 struct vnode *vp = ap->a_vp; 265 struct vnode *dvp; 266 struct smbnode *np = VTOSMB(vp); 267 struct smbmount *smp = VTOSMBFS(vp); 268 269 SMBVDEBUG("%s,%d\n", np->n_name, vrefcnt(vp)); 270 271 KASSERT((np->n_flag & NOPEN) == 0, ("file not closed before reclaim")); 272 273 dvp = (np->n_parent && (np->n_flag & NREFPARENT)) ? 274 np->n_parent : NULL; 275 276 /* 277 * Remove the vnode from its hash chain. 278 */ 279 vfs_hash_remove(vp); 280 if (np->n_name) 281 smbfs_name_free(np->n_name); 282 if (np->n_rpath) 283 free(np->n_rpath, M_SMBNODENAME); 284 free(np, M_SMBNODE); 285 vp->v_data = NULL; 286 if (dvp != NULL) { 287 vrele(dvp); 288 /* 289 * Indicate that we released something; see comment 290 * in smbfs_unmount(). 291 */ 292 smp->sm_didrele = 1; 293 } 294 return 0; 295 } 296 297 int 298 smbfs_inactive(ap) 299 struct vop_inactive_args /* { 300 struct vnode *a_vp; 301 } */ *ap; 302 { 303 struct thread *td = curthread; 304 struct ucred *cred = td->td_ucred; 305 struct vnode *vp = ap->a_vp; 306 struct smbnode *np = VTOSMB(vp); 307 struct smb_cred *scred; 308 struct vattr va; 309 310 SMBVDEBUG("%s: %d\n", VTOSMB(vp)->n_name, vrefcnt(vp)); 311 if ((np->n_flag & NOPEN) != 0) { 312 scred = smbfs_malloc_scred(); 313 smb_makescred(scred, td, cred); 314 smbfs_vinvalbuf(vp, td); 315 if (vp->v_type == VREG) { 316 VOP_GETATTR(vp, &va, cred); 317 smbfs_smb_close(np->n_mount->sm_share, np->n_fid, 318 &np->n_mtime, scred); 319 } else if (vp->v_type == VDIR) { 320 if (np->n_dirseq != NULL) { 321 smbfs_findclose(np->n_dirseq, scred); 322 np->n_dirseq = NULL; 323 } 324 } 325 np->n_flag &= ~NOPEN; 326 smbfs_attr_cacheremove(vp); 327 smbfs_free_scred(scred); 328 } 329 if (np->n_flag & NGONE) 330 vrecycle(vp); 331 return (0); 332 } 333 /* 334 * routines to maintain vnode attributes cache 335 * smbfs_attr_cacheenter: unpack np.i to vattr structure 336 */ 337 void 338 smbfs_attr_cacheenter(struct vnode *vp, struct smbfattr *fap) 339 { 340 struct smbnode *np = VTOSMB(vp); 341 342 if (vp->v_type == VREG) { 343 if (np->n_size != fap->fa_size) { 344 np->n_size = fap->fa_size; 345 vnode_pager_setsize(vp, np->n_size); 346 } 347 } else if (vp->v_type == VDIR) { 348 np->n_size = 16384; /* should be a better way ... */ 349 } else 350 return; 351 np->n_mtime = fap->fa_mtime; 352 np->n_dosattr = fap->fa_attr; 353 np->n_attrage = time_second; 354 return; 355 } 356 357 int 358 smbfs_attr_cachelookup(struct vnode *vp, struct vattr *va) 359 { 360 struct smbnode *np = VTOSMB(vp); 361 struct smbmount *smp = VTOSMBFS(vp); 362 int diff; 363 364 diff = time_second - np->n_attrage; 365 if (diff > 2) /* XXX should be configurable */ 366 return ENOENT; 367 va->va_type = vp->v_type; /* vnode type (for create) */ 368 va->va_flags = 0; /* flags defined for file */ 369 if (vp->v_type == VREG) { 370 va->va_mode = smp->sm_file_mode; /* files access mode and type */ 371 if (np->n_dosattr & SMB_FA_RDONLY) { 372 va->va_mode &= ~(S_IWUSR|S_IWGRP|S_IWOTH); 373 va->va_flags |= UF_READONLY; 374 } 375 } else if (vp->v_type == VDIR) { 376 va->va_mode = smp->sm_dir_mode; /* files access mode and type */ 377 } else 378 return EINVAL; 379 va->va_size = np->n_size; 380 va->va_nlink = 1; /* number of references to file */ 381 va->va_uid = smp->sm_uid; /* owner user id */ 382 va->va_gid = smp->sm_gid; /* owner group id */ 383 va->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; 384 va->va_fileid = np->n_ino; /* file id */ 385 if (va->va_fileid == 0) 386 va->va_fileid = 2; 387 va->va_blocksize = SSTOVC(smp->sm_share)->vc_txmax; 388 va->va_mtime = np->n_mtime; 389 va->va_atime = va->va_ctime = va->va_mtime; /* time file changed */ 390 va->va_gen = VNOVAL; /* generation number of file */ 391 if (np->n_dosattr & SMB_FA_HIDDEN) 392 va->va_flags |= UF_HIDDEN; 393 if (np->n_dosattr & SMB_FA_SYSTEM) 394 va->va_flags |= UF_SYSTEM; 395 /* 396 * We don't set the archive bit for directories. 397 */ 398 if ((vp->v_type != VDIR) && (np->n_dosattr & SMB_FA_ARCHIVE)) 399 va->va_flags |= UF_ARCHIVE; 400 va->va_rdev = NODEV; /* device the special file represents */ 401 va->va_bytes = va->va_size; /* bytes of disk space held by file */ 402 va->va_filerev = 0; /* file modification number */ 403 va->va_vaflags = 0; /* operations flags */ 404 return 0; 405 } 406