1 /* $NetBSD: chfs_vnode.c,v 1.20 2021/12/07 22:13:56 andvar Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 Department of Software Engineering, 5 * University of Szeged, Hungary 6 * Copyright (C) 2010 Tamas Toth <ttoth (at) inf.u-szeged.hu> 7 * Copyright (C) 2010 Adam Hoka <ahoka (at) NetBSD.org> 8 * All rights reserved. 9 * 10 * This code is derived from software contributed to The NetBSD Foundation 11 * by the Department of Software Engineering, University of Szeged, Hungary 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include "chfs.h" 36 #include "chfs_inode.h" 37 #include <sys/kauth.h> 38 #include <sys/namei.h> 39 #include <sys/uio.h> 40 #include <sys/buf.h> 41 42 #include <miscfs/genfs/genfs.h> 43 44 /* chfs_vnode_lookup - lookup for a vnode */ 45 static bool 46 chfs_vnode_lookup_selector(void *ctx, struct vnode *vp) 47 { 48 ino_t *ino = ctx; 49 50 KASSERT(mutex_owned(vp->v_interlock)); 51 52 return (VTOI(vp) != NULL && VTOI(vp)->ino == *ino); 53 } 54 struct vnode * 55 chfs_vnode_lookup(struct chfs_mount *chmp, ino_t vno) 56 { 57 struct vnode_iterator *marker; 58 struct vnode *vp; 59 60 vfs_vnode_iterator_init(chmp->chm_fsmp, &marker); 61 vp = vfs_vnode_iterator_next(marker, chfs_vnode_lookup_selector, &vno); 62 vfs_vnode_iterator_destroy(marker); 63 64 return vp; 65 } 66 67 /* chfs_readvnode - reads a vnode from the flash and setups its inode */ 68 int 69 chfs_readvnode(struct mount *mp, ino_t ino, struct vnode **vpp) 70 { 71 struct ufsmount* ump = VFSTOUFS(mp); 72 struct chfs_mount *chmp = ump->um_chfs; 73 struct chfs_vnode_cache *chvc; 74 struct chfs_flash_vnode *chfvn; 75 struct chfs_inode *ip; 76 int err; 77 char* buf; 78 size_t retlen, len; 79 struct vnode* vp = NULL; 80 dbg("readvnode | ino: %llu\n", (unsigned long long)ino); 81 82 len = sizeof(struct chfs_flash_vnode); 83 84 KASSERT(vpp != NULL); 85 86 if (vpp != NULL) { 87 vp = *vpp; 88 } 89 90 ip = VTOI(vp); 91 chvc = ip->chvc; 92 93 /* root node is in-memory only */ 94 if (chvc && ino != CHFS_ROOTINO) { 95 dbg("offset: %" PRIu32 ", lnr: %d\n", 96 CHFS_GET_OFS(chvc->v->nref_offset), chvc->v->nref_lnr); 97 98 KASSERT((void *)chvc != (void *)chvc->v); 99 100 /* reading */ 101 buf = kmem_alloc(len, KM_SLEEP); 102 err = chfs_read_leb(chmp, chvc->v->nref_lnr, buf, 103 CHFS_GET_OFS(chvc->v->nref_offset), len, &retlen); 104 if (err) { 105 kmem_free(buf, len); 106 return err; 107 } 108 if (retlen != len) { 109 chfs_err("Error reading vnode: read: %zu instead of: %zu\n", 110 len, retlen); 111 kmem_free(buf, len); 112 return EIO; 113 } 114 chfvn = (struct chfs_flash_vnode*)buf; 115 116 /* setup inode fields */ 117 chfs_set_vnode_size(vp, chfvn->dn_size); 118 ip->mode = chfvn->mode; 119 ip->ch_type = IFTOCHT(ip->mode); 120 vp->v_type = CHTTOVT(ip->ch_type); 121 ip->version = chfvn->version; 122 ip->uid = chfvn->uid; 123 ip->gid = chfvn->gid; 124 ip->atime = chfvn->atime; 125 ip->mtime = chfvn->mtime; 126 ip->ctime = chfvn->ctime; 127 128 kmem_free(buf, len); 129 } 130 131 132 *vpp = vp; 133 return 0; 134 } 135 136 /* 137 * chfs_readddirent - 138 * reads a directory entry from flash and adds it to its inode 139 */ 140 int 141 chfs_readdirent(struct mount *mp, struct chfs_node_ref *chnr, struct chfs_inode *pdir) 142 { 143 struct ufsmount *ump = VFSTOUFS(mp); 144 struct chfs_mount *chmp = ump->um_chfs; 145 struct chfs_flash_dirent_node chfdn; 146 struct chfs_dirent *fd; 147 size_t len = sizeof(struct chfs_flash_dirent_node); 148 size_t retlen; 149 int err = 0; 150 151 /* read flash_dirent_node */ 152 err = chfs_read_leb(chmp, chnr->nref_lnr, (char *)&chfdn, 153 CHFS_GET_OFS(chnr->nref_offset), len, &retlen); 154 if (err) { 155 return err; 156 } 157 if (retlen != len) { 158 chfs_err("Error reading vnode: read: %zu instead of: %zu\n", 159 retlen, len); 160 return EIO; 161 } 162 163 /* set fields of dirent */ 164 fd = chfs_alloc_dirent(chfdn.nsize + 1); 165 fd->version = chfdn.version; 166 fd->vno = chfdn.vno; 167 fd->type = chfdn.dtype; 168 fd->nsize = chfdn.nsize; 169 170 /* read the name of the dirent */ 171 err = chfs_read_leb(chmp, chnr->nref_lnr, fd->name, 172 CHFS_GET_OFS(chnr->nref_offset) + len, chfdn.nsize, &retlen); 173 if (err) { 174 return err; 175 } 176 177 if (retlen != chfdn.nsize) { 178 chfs_err("Error reading vnode: read: %zu instead of: %zu\n", 179 len, retlen); 180 return EIO; 181 } 182 183 fd->name[fd->nsize] = 0; 184 fd->nref = chnr; 185 186 /* add to inode */ 187 chfs_add_fd_to_inode(chmp, pdir, fd); 188 return 0; 189 } 190 191 /* chfs_makeinode - makes a new file and initializes its structures */ 192 int 193 chfs_makeinode(int mode, struct vnode *dvp, struct vnode **vpp, 194 struct componentname *cnp, enum vtype type) 195 { 196 struct chfs_inode *ip, *pdir; 197 struct vnode *vp; 198 struct ufsmount* ump = VFSTOUFS(dvp->v_mount); 199 struct chfs_mount* chmp = ump->um_chfs; 200 struct chfs_vnode_cache* chvc; 201 int error; 202 ino_t vno; 203 struct chfs_dirent *nfd; 204 205 dbg("makeinode\n"); 206 pdir = VTOI(dvp); 207 208 *vpp = NULL; 209 210 /* number of vnode will be the new maximum */ 211 vno = ++(chmp->chm_max_vno); 212 213 error = VFS_VGET(dvp->v_mount, vno, LK_EXCLUSIVE, &vp); 214 if (error) 215 return (error); 216 217 /* setup vnode cache */ 218 mutex_enter(&chmp->chm_lock_vnocache); 219 chvc = chfs_vnode_cache_get(chmp, vno); 220 221 chvc->pvno = pdir->ino; 222 chvc->vno_version = kmem_alloc(sizeof(uint64_t), KM_SLEEP); 223 *(chvc->vno_version) = 1; 224 if (type != VDIR) 225 chvc->nlink = 1; 226 else 227 chvc->nlink = 2; 228 chvc->state = VNO_STATE_CHECKEDABSENT; 229 mutex_exit(&chmp->chm_lock_vnocache); 230 231 /* setup inode */ 232 ip = VTOI(vp); 233 ip->ino = vno; 234 235 if (type == VDIR) 236 chfs_set_vnode_size(vp, 512); 237 else 238 chfs_set_vnode_size(vp, 0); 239 240 ip->uid = kauth_cred_geteuid(cnp->cn_cred); 241 ip->gid = kauth_cred_getegid(cnp->cn_cred); 242 ip->version = 1; 243 ip->iflag |= (IN_ACCESS | IN_CHANGE | IN_UPDATE); 244 245 ip->chvc = chvc; 246 ip->target = NULL; 247 248 ip->mode = mode; 249 vp->v_type = type; /* Rest init'd in chfs_loadvnode(). */ 250 ip->ch_type = VTTOCHT(vp->v_type); 251 252 /* authorize setting SGID if needed */ 253 if (ip->mode & ISGID) { 254 error = kauth_authorize_vnode(cnp->cn_cred, 255 KAUTH_VNODE_WRITE_SECURITY, vp, NULL, genfs_can_chmod(vp, 256 cnp->cn_cred, ip->uid, ip->gid, mode)); 257 if (error) 258 ip->mode &= ~ISGID; 259 } 260 261 /* write vnode information to the flash */ 262 chfs_update(vp, NULL, NULL, UPDATE_WAIT); 263 264 mutex_enter(&chmp->chm_lock_mountfields); 265 266 error = chfs_write_flash_vnode(chmp, ip, ALLOC_NORMAL); 267 if (error) { 268 mutex_exit(&chmp->chm_lock_mountfields); 269 vput(vp); 270 return error; 271 } 272 273 /* update parent's vnode information and write it to the flash */ 274 pdir->iflag |= (IN_ACCESS | IN_CHANGE | IN_MODIFY | IN_UPDATE); 275 chfs_update(dvp, NULL, NULL, UPDATE_WAIT); 276 277 error = chfs_write_flash_vnode(chmp, pdir, ALLOC_NORMAL); 278 if (error) { 279 mutex_exit(&chmp->chm_lock_mountfields); 280 vput(vp); 281 return error; 282 } 283 284 /* setup directory entry */ 285 nfd = chfs_alloc_dirent(cnp->cn_namelen + 1); 286 nfd->vno = ip->ino; 287 nfd->version = (++pdir->chvc->highest_version); 288 nfd->type = ip->ch_type; 289 nfd->nsize = cnp->cn_namelen; 290 memcpy(&(nfd->name), cnp->cn_nameptr, cnp->cn_namelen); 291 nfd->name[nfd->nsize] = 0; 292 nfd->nhash = hash32_buf(nfd->name, cnp->cn_namelen, HASH32_BUF_INIT); 293 294 /* write out */ 295 error = chfs_write_flash_dirent(chmp, pdir, ip, nfd, ip->ino, ALLOC_NORMAL); 296 if (error) { 297 mutex_exit(&chmp->chm_lock_mountfields); 298 vput(vp); 299 return error; 300 } 301 302 //TODO set parent's dir times 303 304 /* add dirent to parent */ 305 chfs_add_fd_to_inode(chmp, pdir, nfd); 306 307 pdir->chvc->nlink++; 308 309 mutex_exit(&chmp->chm_lock_mountfields); 310 311 VOP_UNLOCK(vp); 312 *vpp = vp; 313 cache_enter(dvp, *vpp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_flags); 314 return (0); 315 } 316 317 /* chfs_set_vnode_size - updates size of vnode and also inode */ 318 void 319 chfs_set_vnode_size(struct vnode *vp, size_t size) 320 { 321 struct chfs_inode *ip; 322 323 KASSERT(vp != NULL); 324 325 ip = VTOI(vp); 326 KASSERT(ip != NULL); 327 328 ip->size = size; 329 vp->v_size = vp->v_writesize = size; 330 return; 331 } 332 333 /* 334 * chfs_change_size_free - updates free size 335 * "change" parameter is positive if we have to increase the size 336 * and negative if we have to decrease it 337 */ 338 void 339 chfs_change_size_free(struct chfs_mount *chmp, 340 struct chfs_eraseblock *cheb, int change) 341 { 342 KASSERT(mutex_owned(&chmp->chm_lock_sizes)); 343 KASSERT((int)(chmp->chm_free_size + change) >= 0); 344 KASSERT((int)(cheb->free_size + change) >= 0); 345 KASSERT((int)(cheb->free_size + change) <= chmp->chm_ebh->eb_size); 346 chmp->chm_free_size += change; 347 cheb->free_size += change; 348 return; 349 } 350 351 /* 352 * chfs_change_size_dirty - updates dirty size 353 * "change" parameter is positive if we have to increase the size 354 * and negative if we have to decrease it 355 */ 356 void 357 chfs_change_size_dirty(struct chfs_mount *chmp, 358 struct chfs_eraseblock *cheb, int change) 359 { 360 KASSERT(mutex_owned(&chmp->chm_lock_sizes)); 361 KASSERT((int)(chmp->chm_dirty_size + change) >= 0); 362 KASSERT((int)(cheb->dirty_size + change) >= 0); 363 KASSERT((int)(cheb->dirty_size + change) <= chmp->chm_ebh->eb_size); 364 chmp->chm_dirty_size += change; 365 cheb->dirty_size += change; 366 return; 367 } 368 369 /* 370 * chfs_change_size_unchecked - updates unchecked size 371 * "change" parameter is positive if we have to increase the size 372 * and negative if we have to decrease it 373 */ 374 void 375 chfs_change_size_unchecked(struct chfs_mount *chmp, 376 struct chfs_eraseblock *cheb, int change) 377 { 378 KASSERT(mutex_owned(&chmp->chm_lock_sizes)); 379 KASSERT((int)(chmp->chm_unchecked_size + change) >= 0); 380 KASSERT((int)(cheb->unchecked_size + change) >= 0); 381 KASSERT((int)(cheb->unchecked_size + change) <= chmp->chm_ebh->eb_size); 382 chmp->chm_unchecked_size += change; 383 cheb->unchecked_size += change; 384 return; 385 } 386 387 /* 388 * chfs_change_size_used - updates used size 389 * "change" parameter is positive if we have to increase the size 390 * and negative if we have to decrease it 391 */ 392 void 393 chfs_change_size_used(struct chfs_mount *chmp, 394 struct chfs_eraseblock *cheb, int change) 395 { 396 KASSERT(mutex_owned(&chmp->chm_lock_sizes)); 397 KASSERT((int)(chmp->chm_used_size + change) >= 0); 398 KASSERT((int)(cheb->used_size + change) >= 0); 399 KASSERT((int)(cheb->used_size + change) <= chmp->chm_ebh->eb_size); 400 chmp->chm_used_size += change; 401 cheb->used_size += change; 402 return; 403 } 404 405 /* 406 * chfs_change_size_wasted - updates wasted size 407 * "change" parameter is positive if we have to increase the size 408 * and negative if we have to decrease it 409 */ 410 void 411 chfs_change_size_wasted(struct chfs_mount *chmp, 412 struct chfs_eraseblock *cheb, int change) 413 { 414 KASSERT(mutex_owned(&chmp->chm_lock_sizes)); 415 KASSERT((int)(chmp->chm_wasted_size + change) >= 0); 416 KASSERT((int)(cheb->wasted_size + change) >= 0); 417 KASSERT((int)(cheb->wasted_size + change) <= chmp->chm_ebh->eb_size); 418 chmp->chm_wasted_size += change; 419 cheb->wasted_size += change; 420 return; 421 } 422 423
Indexes created Mon Sep 22 05:09:51 GMT 2025