Annotation of sys/ufs/ext2fs/ext2fs_vnops.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ext2fs_vnops.c,v 1.48 2007/06/17 20:15:25 jasper Exp $ */
! 2: /* $NetBSD: ext2fs_vnops.c,v 1.1 1997/06/11 09:34:09 bouyer Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1997 Manuel Bouyer.
! 6: * Copyright (c) 1982, 1986, 1989, 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: * (c) UNIX System Laboratories, Inc.
! 9: * All or some portions of this file are derived from material licensed
! 10: * to the University of California by American Telephone and Telegraph
! 11: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
! 12: * the permission of UNIX System Laboratories, Inc.
! 13: *
! 14: * Redistribution and use in source and binary forms, with or without
! 15: * modification, are permitted provided that the following conditions
! 16: * are met:
! 17: * 1. Redistributions of source code must retain the above copyright
! 18: * notice, this list of conditions and the following disclaimer.
! 19: * 2. Redistributions in binary form must reproduce the above copyright
! 20: * notice, this list of conditions and the following disclaimer in the
! 21: * documentation and/or other materials provided with the distribution.
! 22: * 3. Neither the name of the University nor the names of its contributors
! 23: * may be used to endorse or promote products derived from this software
! 24: * without specific prior written permission.
! 25: *
! 26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 36: * SUCH DAMAGE.
! 37: *
! 38: * @(#)ufs_vnops.c 8.14 (Berkeley) 10/26/94
! 39: * Modified for ext2fs by Manuel Bouyer.
! 40: */
! 41:
! 42: #include <sys/param.h>
! 43: #include <sys/systm.h>
! 44: #include <sys/resourcevar.h>
! 45: #include <sys/kernel.h>
! 46: #include <sys/file.h>
! 47: #include <sys/stat.h>
! 48: #include <sys/buf.h>
! 49: #include <sys/proc.h>
! 50: #include <sys/conf.h>
! 51: #include <sys/mount.h>
! 52: #include <sys/namei.h>
! 53: #include <sys/vnode.h>
! 54: #include <sys/lockf.h>
! 55: #include <sys/malloc.h>
! 56: #include <sys/pool.h>
! 57: #include <sys/signalvar.h>
! 58:
! 59: #include <uvm/uvm_extern.h>
! 60:
! 61: #include <miscfs/fifofs/fifo.h>
! 62: #include <miscfs/specfs/specdev.h>
! 63:
! 64: #include <ufs/ufs/quota.h>
! 65: #include <ufs/ufs/inode.h>
! 66: #include <ufs/ufs/ufs_extern.h>
! 67: #include <ufs/ufs/ufsmount.h>
! 68:
! 69: #include <ufs/ext2fs/ext2fs.h>
! 70: #include <ufs/ext2fs/ext2fs_extern.h>
! 71: #include <ufs/ext2fs/ext2fs_dir.h>
! 72:
! 73: static int ext2fs_chmod(struct vnode *, mode_t, struct ucred *, struct proc *);
! 74: static int ext2fs_chown(struct vnode *, uid_t, gid_t, struct ucred *, struct proc *);
! 75:
! 76: /*
! 77: * Create a regular file
! 78: */
! 79: int
! 80: ext2fs_create(void *v)
! 81: {
! 82: struct vop_create_args *ap = v;
! 83: return ext2fs_makeinode(MAKEIMODE(ap->a_vap->va_type,
! 84: ap->a_vap->va_mode),
! 85: ap->a_dvp, ap->a_vpp, ap->a_cnp);
! 86: }
! 87:
! 88: /*
! 89: * Mknod vnode call
! 90: */
! 91: /* ARGSUSED */
! 92: int
! 93: ext2fs_mknod(void *v)
! 94: {
! 95: struct vop_mknod_args *ap = v;
! 96: struct vattr *vap = ap->a_vap;
! 97: struct vnode **vpp = ap->a_vpp;
! 98: struct inode *ip;
! 99: int error;
! 100:
! 101: if ((error =
! 102: ext2fs_makeinode(MAKEIMODE(vap->va_type, vap->va_mode),
! 103: ap->a_dvp, vpp, ap->a_cnp)) != 0)
! 104: return (error);
! 105: ip = VTOI(*vpp);
! 106: ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
! 107: if (vap->va_rdev != VNOVAL) {
! 108: /*
! 109: * Want to be able to use this to make badblock
! 110: * inodes, so don't truncate the dev number.
! 111: */
! 112: ip->i_e2din->e2di_rdev = h2fs32(vap->va_rdev);
! 113: }
! 114: /*
! 115: * Remove inode so that it will be reloaded by VFS_VGET and
! 116: * checked to see if it is an alias of an existing entry in
! 117: * the inode cache.
! 118: */
! 119: vput(*vpp);
! 120: (*vpp)->v_type = VNON;
! 121: vgone(*vpp);
! 122: *vpp = 0;
! 123: return (0);
! 124: }
! 125:
! 126: /*
! 127: * Open called.
! 128: *
! 129: * Just check the APPEND flag.
! 130: */
! 131: /* ARGSUSED */
! 132: int
! 133: ext2fs_open(void *v)
! 134: {
! 135: struct vop_open_args *ap = v;
! 136:
! 137: /*
! 138: * Files marked append-only must be opened for appending.
! 139: */
! 140: if ((VTOI(ap->a_vp)->i_e2fs_flags & EXT2_APPEND) &&
! 141: (ap->a_mode & (FWRITE | O_APPEND)) == FWRITE)
! 142: return (EPERM);
! 143: return (0);
! 144: }
! 145:
! 146: int
! 147: ext2fs_access(void *v)
! 148: {
! 149: struct vop_access_args *ap = v;
! 150: struct vnode *vp = ap->a_vp;
! 151: struct inode *ip = VTOI(vp);
! 152: mode_t mode = ap->a_mode;
! 153:
! 154: /* If immutable bit set, nobody gets to write it. */
! 155: if ((mode & VWRITE) && (ip->i_e2fs_flags & EXT2_IMMUTABLE))
! 156: return (EPERM);
! 157:
! 158: return (vaccess(ip->i_e2fs_mode, ip->i_e2fs_uid, ip->i_e2fs_gid, mode,
! 159: ap->a_cred));
! 160: }
! 161:
! 162: /* ARGSUSED */
! 163: int
! 164: ext2fs_getattr(void *v)
! 165: {
! 166: struct vop_getattr_args *ap = v;
! 167: struct vnode *vp = ap->a_vp;
! 168: struct inode *ip = VTOI(vp);
! 169: struct vattr *vap = ap->a_vap;
! 170: struct timeval tv;
! 171:
! 172: getmicrotime(&tv);
! 173: EXT2FS_ITIMES(ip, &tv, &tv);
! 174: /*
! 175: * Copy from inode table
! 176: */
! 177: vap->va_fsid = ip->i_dev;
! 178: vap->va_fileid = ip->i_number;
! 179: vap->va_mode = ip->i_e2fs_mode & ALLPERMS;
! 180: vap->va_nlink = ip->i_e2fs_nlink;
! 181: vap->va_uid = ip->i_e2fs_uid;
! 182: vap->va_gid = ip->i_e2fs_gid;
! 183: vap->va_rdev = (dev_t)fs2h32(ip->i_e2din->e2di_rdev);
! 184: vap->va_size = ext2fs_size(ip);
! 185: vap->va_atime.tv_sec = ip->i_e2fs_atime;
! 186: vap->va_atime.tv_nsec = 0;
! 187: vap->va_mtime.tv_sec = ip->i_e2fs_mtime;
! 188: vap->va_mtime.tv_nsec = 0;
! 189: vap->va_ctime.tv_sec = ip->i_e2fs_ctime;
! 190: vap->va_ctime.tv_nsec = 0;
! 191: #ifdef EXT2FS_SYSTEM_FLAGS
! 192: vap->va_flags = (ip->i_e2fs_flags & EXT2_APPEND) ? SF_APPEND : 0;
! 193: vap->va_flags |= (ip->i_e2fs_flags & EXT2_IMMUTABLE) ? SF_IMMUTABLE : 0;
! 194: #else
! 195: vap->va_flags = (ip->i_e2fs_flags & EXT2_APPEND) ? UF_APPEND : 0;
! 196: vap->va_flags |= (ip->i_e2fs_flags & EXT2_IMMUTABLE) ? UF_IMMUTABLE : 0;
! 197: #endif
! 198: vap->va_gen = ip->i_e2fs_gen;
! 199: /* this doesn't belong here */
! 200: if (vp->v_type == VBLK)
! 201: vap->va_blocksize = BLKDEV_IOSIZE;
! 202: else if (vp->v_type == VCHR)
! 203: vap->va_blocksize = MAXBSIZE;
! 204: else
! 205: vap->va_blocksize = vp->v_mount->mnt_stat.f_iosize;
! 206: vap->va_bytes = dbtob((u_quad_t)ip->i_e2fs_nblock);
! 207: vap->va_type = vp->v_type;
! 208: vap->va_filerev = ip->i_modrev;
! 209: return (0);
! 210: }
! 211:
! 212: /*
! 213: * Set attribute vnode op. called from several syscalls
! 214: */
! 215: int
! 216: ext2fs_setattr(void *v)
! 217: {
! 218: struct vop_setattr_args *ap = v;
! 219: struct vattr *vap = ap->a_vap;
! 220: struct vnode *vp = ap->a_vp;
! 221: struct inode *ip = VTOI(vp);
! 222: struct ucred *cred = ap->a_cred;
! 223: struct proc *p = ap->a_p;
! 224: int error;
! 225:
! 226: /*
! 227: * Check for unsettable attributes.
! 228: */
! 229: if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) ||
! 230: (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) ||
! 231: (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) ||
! 232: ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) {
! 233: return (EINVAL);
! 234: }
! 235: if (vap->va_flags != VNOVAL) {
! 236: if (vp->v_mount->mnt_flag & MNT_RDONLY)
! 237: return (EROFS);
! 238: if (cred->cr_uid != ip->i_e2fs_uid &&
! 239: (error = suser_ucred(cred)))
! 240: return (error);
! 241: #ifdef EXT2FS_SYSTEM_FLAGS
! 242: if (cred->cr_uid == 0) {
! 243: if ((ip->i_e2fs_flags &
! 244: (EXT2_APPEND | EXT2_IMMUTABLE)) && securelevel > 0)
! 245: return (EPERM);
! 246: ip->i_e2fs_flags &= ~(EXT2_APPEND | EXT2_IMMUTABLE);
! 247: ip->i_e2fs_flags |=
! 248: (vap->va_flags & SF_APPEND) ? EXT2_APPEND : 0 |
! 249: (vap->va_flags & SF_IMMUTABLE) ? EXT2_IMMUTABLE: 0;
! 250: } else {
! 251: return (EPERM);
! 252: }
! 253: #else
! 254: ip->i_e2fs_flags &= ~(EXT2_APPEND | EXT2_IMMUTABLE);
! 255: ip->i_e2fs_flags |=
! 256: (vap->va_flags & UF_APPEND) ? EXT2_APPEND : 0 |
! 257: (vap->va_flags & UF_IMMUTABLE) ? EXT2_IMMUTABLE: 0;
! 258: #endif
! 259: ip->i_flag |= IN_CHANGE;
! 260: if (vap->va_flags & (IMMUTABLE | APPEND))
! 261: return (0);
! 262: }
! 263: if (ip->i_e2fs_flags & (EXT2_APPEND | EXT2_IMMUTABLE))
! 264: return (EPERM);
! 265: /*
! 266: * Go through the fields and update iff not VNOVAL.
! 267: */
! 268: if (vap->va_uid != (uid_t)VNOVAL || vap->va_gid != (gid_t)VNOVAL) {
! 269: if (vp->v_mount->mnt_flag & MNT_RDONLY)
! 270: return (EROFS);
! 271: error = ext2fs_chown(vp, vap->va_uid, vap->va_gid, cred, p);
! 272: if (error)
! 273: return (error);
! 274: }
! 275: if (vap->va_size != VNOVAL) {
! 276: /*
! 277: * Disallow write attempts on read-only file systems;
! 278: * unless the file is a socket, fifo, or a block or
! 279: * character device resident on the file system.
! 280: */
! 281: switch (vp->v_type) {
! 282: case VDIR:
! 283: return (EISDIR);
! 284: case VLNK:
! 285: case VREG:
! 286: if (vp->v_mount->mnt_flag & MNT_RDONLY)
! 287: return (EROFS);
! 288: default:
! 289: break;
! 290: }
! 291: error = ext2fs_truncate(ip, vap->va_size, 0, cred);
! 292: if (error)
! 293: return (error);
! 294: }
! 295: if (vap->va_atime.tv_sec != VNOVAL || vap->va_mtime.tv_sec != VNOVAL) {
! 296: if (vp->v_mount->mnt_flag & MNT_RDONLY)
! 297: return (EROFS);
! 298: if (cred->cr_uid != ip->i_e2fs_uid &&
! 299: (error = suser_ucred(cred)) &&
! 300: ((vap->va_vaflags & VA_UTIMES_NULL) == 0 ||
! 301: (error = VOP_ACCESS(vp, VWRITE, cred, p))))
! 302: return (error);
! 303: if (vap->va_atime.tv_sec != VNOVAL)
! 304: if (!(vp->v_mount->mnt_flag & MNT_NOATIME))
! 305: ip->i_flag |= IN_ACCESS;
! 306: if (vap->va_mtime.tv_sec != VNOVAL)
! 307: ip->i_flag |= IN_CHANGE | IN_UPDATE;
! 308: error = ext2fs_update(ip, &vap->va_atime, &vap->va_mtime, 1);
! 309: if (error)
! 310: return (error);
! 311: }
! 312: error = 0;
! 313: if (vap->va_mode != (mode_t)VNOVAL) {
! 314: if (vp->v_mount->mnt_flag & MNT_RDONLY)
! 315: return (EROFS);
! 316: error = ext2fs_chmod(vp, (int)vap->va_mode, cred, p);
! 317: }
! 318: return (error);
! 319: }
! 320:
! 321: /*
! 322: * Change the mode on a file.
! 323: * Inode must be locked before calling.
! 324: */
! 325: static int
! 326: ext2fs_chmod(struct vnode *vp, mode_t mode, struct ucred *cred, struct proc *p)
! 327: {
! 328: struct inode *ip = VTOI(vp);
! 329: int error;
! 330:
! 331: if (cred->cr_uid != ip->i_e2fs_uid && (error = suser_ucred(cred)))
! 332: return (error);
! 333: if (cred->cr_uid) {
! 334: if (vp->v_type != VDIR && (mode & S_ISTXT))
! 335: return (EFTYPE);
! 336: if (!groupmember(ip->i_e2fs_gid, cred) && (mode & ISGID))
! 337: return (EPERM);
! 338: }
! 339: ip->i_e2fs_mode &= ~ALLPERMS;
! 340: ip->i_e2fs_mode |= (mode & ALLPERMS);
! 341: ip->i_flag |= IN_CHANGE;
! 342: if ((vp->v_flag & VTEXT) && (ip->i_e2fs_mode & S_ISTXT) == 0)
! 343: (void) uvm_vnp_uncache(vp);
! 344: return (0);
! 345: }
! 346:
! 347: /*
! 348: * Perform chown operation on inode ip;
! 349: * inode must be locked prior to call.
! 350: */
! 351: static int
! 352: ext2fs_chown(struct vnode *vp, uid_t uid, gid_t gid, struct ucred *cred, struct proc *p)
! 353: {
! 354: struct inode *ip = VTOI(vp);
! 355: uid_t ouid;
! 356: gid_t ogid;
! 357: int error = 0;
! 358:
! 359: if (uid == (uid_t)VNOVAL)
! 360: uid = ip->i_e2fs_uid;
! 361: if (gid == (gid_t)VNOVAL)
! 362: gid = ip->i_e2fs_gid;
! 363: /*
! 364: * If we don't own the file, are trying to change the owner
! 365: * of the file, or are not a member of the target group,
! 366: * the caller must be superuser or the call fails.
! 367: */
! 368: if ((cred->cr_uid != ip->i_e2fs_uid || uid != ip->i_e2fs_uid ||
! 369: (gid != ip->i_e2fs_gid && !groupmember((gid_t)gid, cred))) &&
! 370: (error = suser_ucred(cred)))
! 371: return (error);
! 372: ogid = ip->i_e2fs_gid;
! 373: ouid = ip->i_e2fs_uid;
! 374:
! 375: ip->i_e2fs_gid = gid;
! 376: ip->i_e2fs_uid = uid;
! 377: if (ouid != uid || ogid != gid)
! 378: ip->i_flag |= IN_CHANGE;
! 379: if (ouid != uid && cred->cr_uid != 0)
! 380: ip->i_e2fs_mode &= ~ISUID;
! 381: if (ogid != gid && cred->cr_uid != 0)
! 382: ip->i_e2fs_mode &= ~ISGID;
! 383: return (0);
! 384: }
! 385:
! 386: int
! 387: ext2fs_remove(void *v)
! 388: {
! 389: struct vop_remove_args *ap = v;
! 390: struct inode *ip;
! 391: struct vnode *vp = ap->a_vp;
! 392: struct vnode *dvp = ap->a_dvp;
! 393: int error;
! 394:
! 395: ip = VTOI(vp);
! 396: if (vp->v_type == VDIR ||
! 397: (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
! 398: (VTOI(dvp)->i_e2fs_flags & EXT2_APPEND)) {
! 399: error = EPERM;
! 400: goto out;
! 401: }
! 402: error = ext2fs_dirremove(dvp, ap->a_cnp);
! 403: if (error == 0) {
! 404: ip->i_e2fs_nlink--;
! 405: ip->i_flag |= IN_CHANGE;
! 406: }
! 407: out:
! 408: if (dvp == vp)
! 409: vrele(vp);
! 410: else
! 411: vput(vp);
! 412: vput(dvp);
! 413: return (error);
! 414: }
! 415:
! 416: /*
! 417: * link vnode call
! 418: */
! 419: int
! 420: ext2fs_link(void *v)
! 421: {
! 422: struct vop_link_args *ap = v;
! 423: struct vnode *dvp = ap->a_dvp;
! 424: struct vnode *vp = ap->a_vp;
! 425: struct componentname *cnp = ap->a_cnp;
! 426: struct proc *p = cnp->cn_proc;
! 427: struct inode *ip;
! 428: int error;
! 429:
! 430: #ifdef DIAGNOSTIC
! 431: if ((cnp->cn_flags & HASBUF) == 0)
! 432: panic("ext2fs_link: no name");
! 433: #endif
! 434: if (vp->v_type == VDIR) {
! 435: VOP_ABORTOP(dvp, cnp);
! 436: error = EISDIR;
! 437: goto out2;
! 438: }
! 439: if (dvp->v_mount != vp->v_mount) {
! 440: VOP_ABORTOP(dvp, cnp);
! 441: error = EXDEV;
! 442: goto out2;
! 443: }
! 444: if (dvp != vp && (error = vn_lock(vp, LK_EXCLUSIVE, p))) {
! 445: VOP_ABORTOP(dvp, cnp);
! 446: goto out2;
! 447: }
! 448: ip = VTOI(vp);
! 449: if ((nlink_t)ip->i_e2fs_nlink >= LINK_MAX) {
! 450: VOP_ABORTOP(dvp, cnp);
! 451: error = EMLINK;
! 452: goto out1;
! 453: }
! 454: if (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) {
! 455: VOP_ABORTOP(dvp, cnp);
! 456: error = EPERM;
! 457: goto out1;
! 458: }
! 459: ip->i_e2fs_nlink++;
! 460: ip->i_flag |= IN_CHANGE;
! 461: error = ext2fs_update(ip, NULL, NULL, 1);
! 462: if (!error)
! 463: error = ext2fs_direnter(ip, dvp, cnp);
! 464: if (error) {
! 465: ip->i_e2fs_nlink--;
! 466: ip->i_flag |= IN_CHANGE;
! 467: }
! 468: pool_put(&namei_pool, cnp->cn_pnbuf);
! 469: out1:
! 470: if (dvp != vp)
! 471: VOP_UNLOCK(vp, 0, p);
! 472: out2:
! 473: vput(dvp);
! 474: return (error);
! 475: }
! 476:
! 477: /*
! 478: * Rename system call.
! 479: * rename("foo", "bar");
! 480: * is essentially
! 481: * unlink("bar");
! 482: * link("foo", "bar");
! 483: * unlink("foo");
! 484: * but ``atomically''. Can't do full commit without saving state in the
! 485: * inode on disk which isn't feasible at this time. Best we can do is
! 486: * always guarantee the target exists.
! 487: *
! 488: * Basic algorithm is:
! 489: *
! 490: * 1) Bump link count on source while we're linking it to the
! 491: * target. This also ensure the inode won't be deleted out
! 492: * from underneath us while we work (it may be truncated by
! 493: * a concurrent `trunc' or `open' for creation).
! 494: * 2) Link source to destination. If destination already exists,
! 495: * delete it first.
! 496: * 3) Unlink source reference to inode if still around. If a
! 497: * directory was moved and the parent of the destination
! 498: * is different from the source, patch the ".." entry in the
! 499: * directory.
! 500: */
! 501: int
! 502: ext2fs_rename(void *v)
! 503: {
! 504: struct vop_rename_args *ap = v;
! 505: struct vnode *tvp = ap->a_tvp;
! 506: struct vnode *tdvp = ap->a_tdvp;
! 507: struct vnode *fvp = ap->a_fvp;
! 508: struct vnode *fdvp = ap->a_fdvp;
! 509: struct componentname *tcnp = ap->a_tcnp;
! 510: struct componentname *fcnp = ap->a_fcnp;
! 511: struct inode *ip, *xp, *dp;
! 512: struct proc *p = fcnp->cn_proc;
! 513: struct ext2fs_dirtemplate dirbuf;
! 514: /* struct timespec ts; */
! 515: int doingdirectory = 0, oldparent = 0, newparent = 0;
! 516: int error = 0;
! 517: u_char namlen;
! 518:
! 519: #ifdef DIAGNOSTIC
! 520: if ((tcnp->cn_flags & HASBUF) == 0 ||
! 521: (fcnp->cn_flags & HASBUF) == 0)
! 522: panic("ext2fs_rename: no name");
! 523: #endif
! 524: /*
! 525: * Check for cross-device rename.
! 526: */
! 527: if ((fvp->v_mount != tdvp->v_mount) ||
! 528: (tvp && (fvp->v_mount != tvp->v_mount))) {
! 529: error = EXDEV;
! 530: abortit:
! 531: VOP_ABORTOP(tdvp, tcnp); /* XXX, why not in NFS? */
! 532: if (tdvp == tvp)
! 533: vrele(tdvp);
! 534: else
! 535: vput(tdvp);
! 536: if (tvp)
! 537: vput(tvp);
! 538: VOP_ABORTOP(fdvp, fcnp); /* XXX, why not in NFS? */
! 539: vrele(fdvp);
! 540: vrele(fvp);
! 541: return (error);
! 542: }
! 543:
! 544: /*
! 545: * Check if just deleting a link name.
! 546: */
! 547: if (tvp && ((VTOI(tvp)->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
! 548: (VTOI(tdvp)->i_e2fs_flags & EXT2_APPEND))) {
! 549: error = EPERM;
! 550: goto abortit;
! 551: }
! 552: if (fvp == tvp) {
! 553: if (fvp->v_type == VDIR) {
! 554: error = EINVAL;
! 555: goto abortit;
! 556: }
! 557:
! 558: /* Release destination completely. */
! 559: VOP_ABORTOP(tdvp, tcnp);
! 560: vput(tdvp);
! 561: vput(tvp);
! 562:
! 563: /* Delete source. */
! 564: vrele(fdvp);
! 565: vrele(fvp);
! 566: fcnp->cn_flags &= ~MODMASK;
! 567: fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
! 568: if ((fcnp->cn_flags & SAVESTART) == 0)
! 569: panic("ext2fs_rename: lost from startdir");
! 570: fcnp->cn_nameiop = DELETE;
! 571: (void) relookup(fdvp, &fvp, fcnp);
! 572: return (VOP_REMOVE(fdvp, fvp, fcnp));
! 573: }
! 574: if ((error = vn_lock(fvp, LK_EXCLUSIVE, p)) != 0)
! 575: goto abortit;
! 576: dp = VTOI(fdvp);
! 577: ip = VTOI(fvp);
! 578: if ((nlink_t)ip->i_e2fs_nlink >= LINK_MAX) {
! 579: VOP_UNLOCK(fvp, 0, p);
! 580: error = EMLINK;
! 581: goto abortit;
! 582: }
! 583: if ((ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND)) ||
! 584: (dp->i_e2fs_flags & EXT2_APPEND)) {
! 585: VOP_UNLOCK(fvp, 0, p);
! 586: error = EPERM;
! 587: goto abortit;
! 588: }
! 589: if ((ip->i_e2fs_mode & IFMT) == IFDIR) {
! 590: error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc);
! 591: if (!error && tvp)
! 592: error = VOP_ACCESS(tvp, VWRITE, tcnp->cn_cred,
! 593: tcnp->cn_proc);
! 594: if (error) {
! 595: VOP_UNLOCK(fvp, 0, p);
! 596: error = EACCES;
! 597: goto abortit;
! 598: }
! 599: /*
! 600: * Avoid ".", "..", and aliases of "." for obvious reasons.
! 601: */
! 602: if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') ||
! 603: dp == ip ||
! 604: (fcnp->cn_flags&ISDOTDOT) ||
! 605: (tcnp->cn_flags & ISDOTDOT) ||
! 606: (ip->i_flag & IN_RENAME)) {
! 607: VOP_UNLOCK(fvp, 0, p);
! 608: error = EINVAL;
! 609: goto abortit;
! 610: }
! 611: ip->i_flag |= IN_RENAME;
! 612: oldparent = dp->i_number;
! 613: doingdirectory++;
! 614: }
! 615: vrele(fdvp);
! 616:
! 617: /*
! 618: * When the target exists, both the directory
! 619: * and target vnodes are returned locked.
! 620: */
! 621: dp = VTOI(tdvp);
! 622: xp = NULL;
! 623: if (tvp)
! 624: xp = VTOI(tvp);
! 625:
! 626: /*
! 627: * 1) Bump link count while we're moving stuff
! 628: * around. If we crash somewhere before
! 629: * completing our work, the link count
! 630: * may be wrong, but correctable.
! 631: */
! 632: ip->i_e2fs_nlink++;
! 633: ip->i_flag |= IN_CHANGE;
! 634: if ((error = ext2fs_update(ip, NULL, NULL, 1)) != 0) {
! 635: VOP_UNLOCK(fvp, 0, p);
! 636: goto bad;
! 637: }
! 638:
! 639: /*
! 640: * If ".." must be changed (ie the directory gets a new
! 641: * parent) then the source directory must not be in the
! 642: * directory hierarchy above the target, as this would
! 643: * orphan everything below the source directory. Also
! 644: * the user must have write permission in the source so
! 645: * as to be able to change "..". We must repeat the call
! 646: * to namei, as the parent directory is unlocked by the
! 647: * call to checkpath().
! 648: */
! 649: error = VOP_ACCESS(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_proc);
! 650: VOP_UNLOCK(fvp, 0, p);
! 651: if (oldparent != dp->i_number)
! 652: newparent = dp->i_number;
! 653: if (doingdirectory && newparent) {
! 654: if (error) /* write access check above */
! 655: goto bad;
! 656: if (xp != NULL)
! 657: vput(tvp);
! 658: error = ext2fs_checkpath(ip, dp, tcnp->cn_cred);
! 659: if (error != 0)
! 660: goto out;
! 661: if ((tcnp->cn_flags & SAVESTART) == 0)
! 662: panic("ext2fs_rename: lost to startdir");
! 663: if ((error = relookup(tdvp, &tvp, tcnp)) != 0)
! 664: goto out;
! 665: dp = VTOI(tdvp);
! 666: xp = NULL;
! 667: if (tvp)
! 668: xp = VTOI(tvp);
! 669: }
! 670: /*
! 671: * 2) If target doesn't exist, link the target
! 672: * to the source and unlink the source.
! 673: * Otherwise, rewrite the target directory
! 674: * entry to reference the source inode and
! 675: * expunge the original entry's existence.
! 676: */
! 677: if (xp == NULL) {
! 678: if (dp->i_dev != ip->i_dev)
! 679: panic("rename: EXDEV");
! 680: /*
! 681: * Account for ".." in new directory.
! 682: * When source and destination have the same
! 683: * parent we don't fool with the link count.
! 684: */
! 685: if (doingdirectory && newparent) {
! 686: if ((nlink_t)dp->i_e2fs_nlink >= LINK_MAX) {
! 687: error = EMLINK;
! 688: goto bad;
! 689: }
! 690: dp->i_e2fs_nlink++;
! 691: dp->i_flag |= IN_CHANGE;
! 692: if ((error = ext2fs_update(dp, NULL, NULL, 1)) != 0)
! 693: goto bad;
! 694: }
! 695: error = ext2fs_direnter(ip, tdvp, tcnp);
! 696: if (error != 0) {
! 697: if (doingdirectory && newparent) {
! 698: dp->i_e2fs_nlink--;
! 699: dp->i_flag |= IN_CHANGE;
! 700: (void)ext2fs_update(dp, NULL, NULL, 1);
! 701: }
! 702: goto bad;
! 703: }
! 704: vput(tdvp);
! 705: } else {
! 706: if (xp->i_dev != dp->i_dev || xp->i_dev != ip->i_dev)
! 707: panic("rename: EXDEV");
! 708: /*
! 709: * Short circuit rename(foo, foo).
! 710: */
! 711: if (xp->i_number == ip->i_number)
! 712: panic("rename: same file");
! 713: /*
! 714: * If the parent directory is "sticky", then the user must
! 715: * own the parent directory, or the destination of the rename,
! 716: * otherwise the destination may not be changed (except by
! 717: * root). This implements append-only directories.
! 718: */
! 719: if ((dp->i_e2fs_mode & S_ISTXT) && tcnp->cn_cred->cr_uid != 0 &&
! 720: tcnp->cn_cred->cr_uid != dp->i_e2fs_uid &&
! 721: xp->i_e2fs_uid != tcnp->cn_cred->cr_uid) {
! 722: error = EPERM;
! 723: goto bad;
! 724: }
! 725: /*
! 726: * Target must be empty if a directory and have no links
! 727: * to it. Also, ensure source and target are compatible
! 728: * (both directories, or both not directories).
! 729: */
! 730: if ((xp->i_e2fs_mode & IFMT) == IFDIR) {
! 731: if (!ext2fs_dirempty(xp, dp->i_number, tcnp->cn_cred) ||
! 732: xp->i_e2fs_nlink > 2) {
! 733: error = ENOTEMPTY;
! 734: goto bad;
! 735: }
! 736: if (!doingdirectory) {
! 737: error = ENOTDIR;
! 738: goto bad;
! 739: }
! 740: cache_purge(tdvp);
! 741: } else if (doingdirectory) {
! 742: error = EISDIR;
! 743: goto bad;
! 744: }
! 745: error = ext2fs_dirrewrite(dp, ip, tcnp);
! 746: if (error != 0)
! 747: goto bad;
! 748: /*
! 749: * If the target directory is in the same
! 750: * directory as the source directory,
! 751: * decrement the link count on the parent
! 752: * of the target directory.
! 753: */
! 754: if (doingdirectory && !newparent) {
! 755: dp->i_e2fs_nlink--;
! 756: dp->i_flag |= IN_CHANGE;
! 757: }
! 758: vput(tdvp);
! 759: /*
! 760: * Adjust the link count of the target to
! 761: * reflect the dirrewrite above. If this is
! 762: * a directory it is empty and there are
! 763: * no links to it, so we can squash the inode and
! 764: * any space associated with it. We disallowed
! 765: * renaming over top of a directory with links to
! 766: * it above, as the remaining link would point to
! 767: * a directory without "." or ".." entries.
! 768: */
! 769: xp->i_e2fs_nlink--;
! 770: if (doingdirectory) {
! 771: if (--xp->i_e2fs_nlink != 0)
! 772: panic("rename: linked directory");
! 773: error = ext2fs_truncate(xp, (off_t)0, IO_SYNC,
! 774: tcnp->cn_cred);
! 775: }
! 776: xp->i_flag |= IN_CHANGE;
! 777: vput(tvp);
! 778: xp = NULL;
! 779: }
! 780:
! 781: /*
! 782: * 3) Unlink the source.
! 783: */
! 784: fcnp->cn_flags &= ~MODMASK;
! 785: fcnp->cn_flags |= LOCKPARENT | LOCKLEAF;
! 786: if ((fcnp->cn_flags & SAVESTART) == 0)
! 787: panic("ext2fs_rename: lost from startdir");
! 788: (void) relookup(fdvp, &fvp, fcnp);
! 789: if (fvp != NULL) {
! 790: xp = VTOI(fvp);
! 791: dp = VTOI(fdvp);
! 792: } else {
! 793: /*
! 794: * From name has disappeared.
! 795: */
! 796: if (doingdirectory)
! 797: panic("ext2fs_rename: lost dir entry");
! 798: vrele(ap->a_fvp);
! 799: return (0);
! 800: }
! 801: /*
! 802: * Ensure that the directory entry still exists and has not
! 803: * changed while the new name has been entered. If the source is
! 804: * a file then the entry may have been unlinked or renamed. In
! 805: * either case there is no further work to be done. If the source
! 806: * is a directory then it cannot have been rmdir'ed; its link
! 807: * count of three would cause a rmdir to fail with ENOTEMPTY.
! 808: * The IRENAME flag ensures that it cannot be moved by another
! 809: * rename.
! 810: */
! 811: if (xp != ip) {
! 812: if (doingdirectory)
! 813: panic("ext2fs_rename: lost dir entry");
! 814: } else {
! 815: /*
! 816: * If the source is a directory with a
! 817: * new parent, the link count of the old
! 818: * parent directory must be decremented
! 819: * and ".." set to point to the new parent.
! 820: */
! 821: if (doingdirectory && newparent) {
! 822: dp->i_e2fs_nlink--;
! 823: dp->i_flag |= IN_CHANGE;
! 824: error = vn_rdwr(UIO_READ, fvp, (caddr_t)&dirbuf,
! 825: sizeof (struct ext2fs_dirtemplate), (off_t)0,
! 826: UIO_SYSSPACE, IO_NODELOCKED,
! 827: tcnp->cn_cred, (size_t *)0, (struct proc *)0);
! 828: if (error == 0) {
! 829: namlen = dirbuf.dotdot_namlen;
! 830: if (namlen != 2 ||
! 831: dirbuf.dotdot_name[0] != '.' ||
! 832: dirbuf.dotdot_name[1] != '.') {
! 833: ufs_dirbad(xp, (doff_t)12,
! 834: "ext2fs_rename: mangled dir");
! 835: } else {
! 836: dirbuf.dotdot_ino = h2fs32(newparent);
! 837: (void) vn_rdwr(UIO_WRITE, fvp,
! 838: (caddr_t)&dirbuf,
! 839: sizeof (struct dirtemplate),
! 840: (off_t)0, UIO_SYSSPACE,
! 841: IO_NODELOCKED|IO_SYNC,
! 842: tcnp->cn_cred, (size_t *)0,
! 843: (struct proc *)0);
! 844: cache_purge(fdvp);
! 845: }
! 846: }
! 847: }
! 848: error = ext2fs_dirremove(fdvp, fcnp);
! 849: if (!error) {
! 850: xp->i_e2fs_nlink--;
! 851: xp->i_flag |= IN_CHANGE;
! 852: }
! 853: xp->i_flag &= ~IN_RENAME;
! 854: }
! 855: if (dp)
! 856: vput(fdvp);
! 857: if (xp)
! 858: vput(fvp);
! 859: vrele(ap->a_fvp);
! 860: return (error);
! 861:
! 862: bad:
! 863: if (xp)
! 864: vput(ITOV(xp));
! 865: vput(ITOV(dp));
! 866: out:
! 867: if (doingdirectory)
! 868: ip->i_flag &= ~IN_RENAME;
! 869: if (vn_lock(fvp, LK_EXCLUSIVE, p) == 0) {
! 870: ip->i_e2fs_nlink--;
! 871: ip->i_flag |= IN_CHANGE;
! 872: vput(fvp);
! 873: } else
! 874: vrele(fvp);
! 875: return (error);
! 876: }
! 877:
! 878: /*
! 879: * Mkdir system call
! 880: */
! 881: int
! 882: ext2fs_mkdir(void *v)
! 883: {
! 884: struct vop_mkdir_args *ap = v;
! 885: struct vnode *dvp = ap->a_dvp;
! 886: struct vattr *vap = ap->a_vap;
! 887: struct componentname *cnp = ap->a_cnp;
! 888: struct inode *ip, *dp;
! 889: struct vnode *tvp;
! 890: struct ext2fs_dirtemplate dirtemplate;
! 891: mode_t dmode;
! 892: int error;
! 893:
! 894: #ifdef DIAGNOSTIC
! 895: if ((cnp->cn_flags & HASBUF) == 0)
! 896: panic("ext2fs_mkdir: no name");
! 897: #endif
! 898: dp = VTOI(dvp);
! 899: if ((nlink_t)dp->i_e2fs_nlink >= LINK_MAX) {
! 900: error = EMLINK;
! 901: goto out;
! 902: }
! 903: dmode = vap->va_mode & ACCESSPERMS;
! 904: dmode |= IFDIR;
! 905: /*
! 906: * Must simulate part of ext2fs_makeinode here to acquire the inode,
! 907: * but not have it entered in the parent directory. The entry is
! 908: * made later after writing "." and ".." entries.
! 909: */
! 910: if ((error = ext2fs_inode_alloc(dp, dmode, cnp->cn_cred, &tvp)) != 0)
! 911: goto out;
! 912: ip = VTOI(tvp);
! 913: ip->i_e2fs_uid = cnp->cn_cred->cr_uid;
! 914: ip->i_e2fs_gid = dp->i_e2fs_gid;
! 915: ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
! 916: ip->i_e2fs_mode = dmode;
! 917: tvp->v_type = VDIR; /* Rest init'd in getnewvnode(). */
! 918: ip->i_e2fs_nlink = 2;
! 919: error = ext2fs_update(ip, NULL, NULL, 1);
! 920:
! 921: /*
! 922: * Bump link count in parent directory
! 923: * to reflect work done below. Should
! 924: * be done before reference is created
! 925: * so reparation is possible if we crash.
! 926: */
! 927: dp->i_e2fs_nlink++;
! 928: dp->i_flag |= IN_CHANGE;
! 929: if ((error = ext2fs_update(dp, NULL, NULL, 1)) != 0)
! 930: goto bad;
! 931:
! 932: /* Initialize directory with "." and ".." from static template. */
! 933: bzero(&dirtemplate, sizeof(dirtemplate));
! 934: dirtemplate.dot_ino = h2fs32(ip->i_number);
! 935: dirtemplate.dot_reclen = h2fs16(12);
! 936: dirtemplate.dot_namlen = 1;
! 937: if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
! 938: (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
! 939: dirtemplate.dot_type = EXT2_FT_DIR;
! 940: }
! 941: dirtemplate.dot_name[0] = '.';
! 942: dirtemplate.dotdot_ino = h2fs32(dp->i_number);
! 943: dirtemplate.dotdot_reclen = h2fs16(VTOI(dvp)->i_e2fs->e2fs_bsize - 12);
! 944: dirtemplate.dotdot_namlen = 2;
! 945: if (ip->i_e2fs->e2fs.e2fs_rev > E2FS_REV0 &&
! 946: (ip->i_e2fs->e2fs.e2fs_features_incompat & EXT2F_INCOMPAT_FTYPE)) {
! 947: dirtemplate.dotdot_type = EXT2_FT_DIR;
! 948: }
! 949: dirtemplate.dotdot_name[0] = dirtemplate.dotdot_name[1] = '.';
! 950: error = vn_rdwr(UIO_WRITE, tvp, (caddr_t)&dirtemplate,
! 951: sizeof (dirtemplate), (off_t)0, UIO_SYSSPACE,
! 952: IO_NODELOCKED|IO_SYNC, cnp->cn_cred, (size_t *)0, (struct proc *)0);
! 953: if (error) {
! 954: dp->i_e2fs_nlink--;
! 955: dp->i_flag |= IN_CHANGE;
! 956: goto bad;
! 957: }
! 958: if (VTOI(dvp)->i_e2fs->e2fs_bsize >
! 959: VFSTOUFS(dvp->v_mount)->um_mountp->mnt_stat.f_bsize)
! 960: panic("ext2fs_mkdir: blksize"); /* XXX should grow with balloc() */
! 961: else {
! 962: error = ext2fs_setsize(ip, VTOI(dvp)->i_e2fs->e2fs_bsize);
! 963: if (error) {
! 964: dp->i_e2fs_nlink--;
! 965: dp->i_flag |= IN_CHANGE;
! 966: goto bad;
! 967: }
! 968: ip->i_flag |= IN_CHANGE;
! 969: }
! 970:
! 971: /* Directory set up, now install its entry in the parent directory. */
! 972: error = ext2fs_direnter(ip, dvp, cnp);
! 973: if (error != 0) {
! 974: dp->i_e2fs_nlink--;
! 975: dp->i_flag |= IN_CHANGE;
! 976: }
! 977: bad:
! 978: /*
! 979: * No need to do an explicit VOP_TRUNCATE here, vrele will do this
! 980: * for us because we set the link count to 0.
! 981: */
! 982: if (error) {
! 983: ip->i_e2fs_nlink = 0;
! 984: ip->i_flag |= IN_CHANGE;
! 985: vput(tvp);
! 986: } else
! 987: *ap->a_vpp = tvp;
! 988: out:
! 989: pool_put(&namei_pool, cnp->cn_pnbuf);
! 990: vput(dvp);
! 991: return (error);
! 992: }
! 993:
! 994: /*
! 995: * Rmdir system call.
! 996: */
! 997: int
! 998: ext2fs_rmdir(void *v)
! 999: {
! 1000: struct vop_rmdir_args *ap = v;
! 1001: struct vnode *vp = ap->a_vp;
! 1002: struct vnode *dvp = ap->a_dvp;
! 1003: struct componentname *cnp = ap->a_cnp;
! 1004: struct inode *ip, *dp;
! 1005: int error;
! 1006:
! 1007: ip = VTOI(vp);
! 1008: dp = VTOI(dvp);
! 1009: /*
! 1010: * No rmdir "." please.
! 1011: */
! 1012: if (dp == ip) {
! 1013: vrele(dvp);
! 1014: vput(vp);
! 1015: return (EINVAL);
! 1016: }
! 1017: /*
! 1018: * Verify the directory is empty (and valid).
! 1019: * (Rmdir ".." won't be valid since
! 1020: * ".." will contain a reference to
! 1021: * the current directory and thus be
! 1022: * non-empty.)
! 1023: */
! 1024: error = 0;
! 1025: if (ip->i_e2fs_nlink != 2 ||
! 1026: !ext2fs_dirempty(ip, dp->i_number, cnp->cn_cred)) {
! 1027: error = ENOTEMPTY;
! 1028: goto out;
! 1029: }
! 1030: if ((dp->i_e2fs_flags & EXT2_APPEND) ||
! 1031: (ip->i_e2fs_flags & (EXT2_IMMUTABLE | EXT2_APPEND))) {
! 1032: error = EPERM;
! 1033: goto out;
! 1034: }
! 1035: /*
! 1036: * Delete reference to directory before purging
! 1037: * inode. If we crash in between, the directory
! 1038: * will be reattached to lost+found,
! 1039: */
! 1040: error = ext2fs_dirremove(dvp, cnp);
! 1041: if (error != 0)
! 1042: goto out;
! 1043: dp->i_e2fs_nlink--;
! 1044: dp->i_flag |= IN_CHANGE;
! 1045: cache_purge(dvp);
! 1046: vput(dvp);
! 1047: dvp = NULL;
! 1048: /*
! 1049: * Truncate inode. The only stuff left
! 1050: * in the directory is "." and "..". The
! 1051: * "." reference is inconsequential since
! 1052: * we're quashing it. The ".." reference
! 1053: * has already been adjusted above. We've
! 1054: * removed the "." reference and the reference
! 1055: * in the parent directory, but there may be
! 1056: * other hard links so decrement by 2 and
! 1057: * worry about them later.
! 1058: */
! 1059: ip->i_e2fs_nlink -= 2;
! 1060: error = ext2fs_truncate(ip, (off_t)0, IO_SYNC, cnp->cn_cred);
! 1061: cache_purge(ITOV(ip));
! 1062: out:
! 1063: if (dvp)
! 1064: vput(dvp);
! 1065: vput(vp);
! 1066: return (error);
! 1067: }
! 1068:
! 1069: /*
! 1070: * symlink -- make a symbolic link
! 1071: */
! 1072: int
! 1073: ext2fs_symlink(void *v)
! 1074: {
! 1075: struct vop_symlink_args *ap = v;
! 1076: struct vnode *vp, **vpp = ap->a_vpp;
! 1077: struct inode *ip;
! 1078: int len, error;
! 1079:
! 1080: error = ext2fs_makeinode(IFLNK | ap->a_vap->va_mode, ap->a_dvp,
! 1081: vpp, ap->a_cnp);
! 1082: if (error)
! 1083: return (error);
! 1084: vp = *vpp;
! 1085: len = strlen(ap->a_target);
! 1086: if (len < vp->v_mount->mnt_maxsymlinklen) {
! 1087: ip = VTOI(vp);
! 1088: bcopy(ap->a_target, (char *)ip->i_e2din->e2di_shortlink, len);
! 1089: error = ext2fs_setsize(ip, len);
! 1090: if (error)
! 1091: goto bad;
! 1092: ip->i_flag |= IN_CHANGE | IN_UPDATE;
! 1093: } else
! 1094: error = vn_rdwr(UIO_WRITE, vp, ap->a_target, len, (off_t)0,
! 1095: UIO_SYSSPACE, IO_NODELOCKED, ap->a_cnp->cn_cred, NULL,
! 1096: (struct proc *)0);
! 1097: bad:
! 1098: vput(vp);
! 1099: return (error);
! 1100: }
! 1101:
! 1102: /*
! 1103: * Return target name of a symbolic link
! 1104: */
! 1105: int
! 1106: ext2fs_readlink(void *v)
! 1107: {
! 1108: struct vop_readlink_args *ap = v;
! 1109: struct vnode *vp = ap->a_vp;
! 1110: struct inode *ip = VTOI(vp);
! 1111: int isize;
! 1112:
! 1113: isize = ext2fs_size(ip);
! 1114: if (isize < vp->v_mount->mnt_maxsymlinklen ||
! 1115: (vp->v_mount->mnt_maxsymlinklen == 0 && ip->i_e2fs_nblock == 0)) {
! 1116: uiomove((char *)ip->i_e2din->e2di_shortlink, isize, ap->a_uio);
! 1117: return (0);
! 1118: }
! 1119: return (VOP_READ(vp, ap->a_uio, 0, ap->a_cred));
! 1120: }
! 1121:
! 1122: /*
! 1123: * Advisory record locking support
! 1124: */
! 1125: int
! 1126: ext2fs_advlock(void *v)
! 1127: {
! 1128: struct vop_advlock_args *ap = v;
! 1129: struct inode *ip = VTOI(ap->a_vp);
! 1130:
! 1131: return (lf_advlock(&ip->i_lockf, ext2fs_size(ip), ap->a_id, ap->a_op,
! 1132: ap->a_fl, ap->a_flags));
! 1133: }
! 1134:
! 1135: /*
! 1136: * Allocate a new inode.
! 1137: */
! 1138: int
! 1139: ext2fs_makeinode(int mode, struct vnode *dvp, struct vnode **vpp,
! 1140: struct componentname *cnp)
! 1141: {
! 1142: struct inode *ip, *pdir;
! 1143: struct vnode *tvp;
! 1144: int error;
! 1145:
! 1146: pdir = VTOI(dvp);
! 1147: #ifdef DIAGNOSTIC
! 1148: if ((cnp->cn_flags & HASBUF) == 0)
! 1149: panic("ext2fs_makeinode: no name");
! 1150: #endif
! 1151: *vpp = NULL;
! 1152: if ((mode & IFMT) == 0)
! 1153: mode |= IFREG;
! 1154:
! 1155: if ((error = ext2fs_inode_alloc(pdir, mode, cnp->cn_cred, &tvp))
! 1156: != 0) {
! 1157: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1158: vput(dvp);
! 1159: return (error);
! 1160: }
! 1161: ip = VTOI(tvp);
! 1162: ip->i_e2fs_gid = pdir->i_e2fs_gid;
! 1163: ip->i_e2fs_uid = cnp->cn_cred->cr_uid;
! 1164: ip->i_flag |= IN_ACCESS | IN_CHANGE | IN_UPDATE;
! 1165: ip->i_e2fs_mode = mode;
! 1166: tvp->v_type = IFTOVT(mode); /* Rest init'd in getnewvnode(). */
! 1167: ip->i_e2fs_nlink = 1;
! 1168: if ((ip->i_e2fs_mode & ISGID) &&
! 1169: !groupmember(ip->i_e2fs_gid, cnp->cn_cred) &&
! 1170: suser_ucred(cnp->cn_cred))
! 1171: ip->i_e2fs_mode &= ~ISGID;
! 1172:
! 1173: /*
! 1174: * Make sure inode goes to disk before directory entry.
! 1175: */
! 1176: if ((error = ext2fs_update(ip, NULL, NULL, 1)) != 0)
! 1177: goto bad;
! 1178: error = ext2fs_direnter(ip, dvp, cnp);
! 1179: if (error != 0)
! 1180: goto bad;
! 1181: if ((cnp->cn_flags & SAVESTART) == 0)
! 1182: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1183: vput(dvp);
! 1184: *vpp = tvp;
! 1185: return (0);
! 1186:
! 1187: bad:
! 1188: /*
! 1189: * Write error occurred trying to update the inode
! 1190: * or the directory so must deallocate the inode.
! 1191: */
! 1192: pool_put(&namei_pool, cnp->cn_pnbuf);
! 1193: vput(dvp);
! 1194: ip->i_e2fs_nlink = 0;
! 1195: ip->i_flag |= IN_CHANGE;
! 1196: tvp->v_type = VNON;
! 1197: vput(tvp);
! 1198: return (error);
! 1199: }
! 1200:
! 1201: /*
! 1202: * Synch an open file.
! 1203: */
! 1204: /* ARGSUSED */
! 1205: int
! 1206: ext2fs_fsync(void *v)
! 1207: {
! 1208: struct vop_fsync_args *ap = v;
! 1209: struct vnode *vp = ap->a_vp;
! 1210:
! 1211: vflushbuf(vp, ap->a_waitfor == MNT_WAIT);
! 1212: return (ext2fs_update(VTOI(ap->a_vp), NULL, NULL,
! 1213: ap->a_waitfor == MNT_WAIT));
! 1214: }
! 1215:
! 1216: /*
! 1217: * Reclaim an inode so that it can be used for other purposes.
! 1218: */
! 1219: int
! 1220: ext2fs_reclaim(void *v)
! 1221: {
! 1222: struct vop_reclaim_args *ap = v;
! 1223: struct vnode *vp = ap->a_vp;
! 1224: struct inode *ip;
! 1225: #ifdef DIAGNOSTIC
! 1226: extern int prtactive;
! 1227:
! 1228: if (prtactive && vp->v_usecount != 0)
! 1229: vprint("ext2fs_reclaim: pushing active", vp);
! 1230: #endif
! 1231:
! 1232: /*
! 1233: * Remove the inode from its hash chain.
! 1234: */
! 1235: ip = VTOI(vp);
! 1236: ufs_ihashrem(ip);
! 1237:
! 1238: /*
! 1239: * Purge old data structures associated with the inode.
! 1240: */
! 1241: cache_purge(vp);
! 1242: if (ip->i_devvp)
! 1243: vrele(ip->i_devvp);
! 1244:
! 1245: if (ip->i_e2din != NULL)
! 1246: pool_put(&ext2fs_dinode_pool, ip->i_e2din);
! 1247:
! 1248: pool_put(&ext2fs_inode_pool, ip);
! 1249:
! 1250: vp->v_data = NULL;
! 1251:
! 1252: return (0);
! 1253: }
! 1254:
! 1255: /* Global vfs data structures for ext2fs. */
! 1256: int (**ext2fs_vnodeop_p)(void *);
! 1257: struct vnodeopv_entry_desc ext2fs_vnodeop_entries[] = {
! 1258: { &vop_default_desc, vn_default_error },
! 1259: { &vop_lookup_desc, ext2fs_lookup }, /* lookup */
! 1260: { &vop_create_desc, ext2fs_create }, /* create */
! 1261: { &vop_mknod_desc, ext2fs_mknod }, /* mknod */
! 1262: { &vop_open_desc, ext2fs_open }, /* open */
! 1263: { &vop_close_desc, ufs_close }, /* close */
! 1264: { &vop_access_desc, ext2fs_access }, /* access */
! 1265: { &vop_getattr_desc, ext2fs_getattr }, /* getattr */
! 1266: { &vop_setattr_desc, ext2fs_setattr }, /* setattr */
! 1267: { &vop_read_desc, ext2fs_read }, /* read */
! 1268: { &vop_write_desc, ext2fs_write }, /* write */
! 1269: { &vop_ioctl_desc, ufs_ioctl }, /* ioctl */
! 1270: { &vop_poll_desc, ufs_poll }, /* poll */
! 1271: { &vop_kqfilter_desc, vop_generic_kqfilter }, /* kqfilter */
! 1272: { &vop_fsync_desc, ext2fs_fsync }, /* fsync */
! 1273: { &vop_remove_desc, ext2fs_remove }, /* remove */
! 1274: { &vop_link_desc, ext2fs_link }, /* link */
! 1275: { &vop_rename_desc, ext2fs_rename }, /* rename */
! 1276: { &vop_mkdir_desc, ext2fs_mkdir }, /* mkdir */
! 1277: { &vop_rmdir_desc, ext2fs_rmdir }, /* rmdir */
! 1278: { &vop_symlink_desc, ext2fs_symlink }, /* symlink */
! 1279: { &vop_readdir_desc, ext2fs_readdir }, /* readdir */
! 1280: { &vop_readlink_desc, ext2fs_readlink },/* readlink */
! 1281: { &vop_abortop_desc, vop_generic_abortop }, /* abortop */
! 1282: { &vop_inactive_desc, ext2fs_inactive },/* inactive */
! 1283: { &vop_reclaim_desc, ext2fs_reclaim }, /* reclaim */
! 1284: { &vop_lock_desc, ufs_lock }, /* lock */
! 1285: { &vop_unlock_desc, ufs_unlock }, /* unlock */
! 1286: { &vop_bmap_desc, ext2fs_bmap }, /* bmap */
! 1287: { &vop_strategy_desc, ufs_strategy }, /* strategy */
! 1288: { &vop_print_desc, ufs_print }, /* print */
! 1289: { &vop_islocked_desc, ufs_islocked }, /* islocked */
! 1290: { &vop_pathconf_desc, ufs_pathconf }, /* pathconf */
! 1291: { &vop_advlock_desc, ext2fs_advlock }, /* advlock */
! 1292: { &vop_bwrite_desc, vop_generic_bwrite }, /* bwrite */
! 1293: { NULL, NULL }
! 1294: };
! 1295: struct vnodeopv_desc ext2fs_vnodeop_opv_desc =
! 1296: { &ext2fs_vnodeop_p, ext2fs_vnodeop_entries };
! 1297:
! 1298: int (**ext2fs_specop_p)(void *);
! 1299: struct vnodeopv_entry_desc ext2fs_specop_entries[] = {
! 1300: { &vop_default_desc, spec_vnoperate },
! 1301: { &vop_close_desc, ufsspec_close }, /* close */
! 1302: { &vop_access_desc, ext2fs_access }, /* access */
! 1303: { &vop_getattr_desc, ext2fs_getattr }, /* getattr */
! 1304: { &vop_setattr_desc, ext2fs_setattr }, /* setattr */
! 1305: { &vop_read_desc, ufsspec_read }, /* read */
! 1306: { &vop_write_desc, ufsspec_write }, /* write */
! 1307: { &vop_fsync_desc, ext2fs_fsync }, /* fsync */
! 1308: { &vop_inactive_desc, ext2fs_inactive },/* inactive */
! 1309: { &vop_reclaim_desc, ext2fs_reclaim }, /* reclaim */
! 1310: { &vop_lock_desc, ufs_lock }, /* lock */
! 1311: { &vop_unlock_desc, ufs_unlock }, /* unlock */
! 1312: { &vop_print_desc, ufs_print }, /* print */
! 1313: { &vop_islocked_desc, ufs_islocked }, /* islocked */
! 1314: { NULL, NULL }
! 1315: };
! 1316: struct vnodeopv_desc ext2fs_specop_opv_desc =
! 1317: { &ext2fs_specop_p, ext2fs_specop_entries };
! 1318:
! 1319: #ifdef FIFO
! 1320: int (**ext2fs_fifoop_p)(void *);
! 1321: struct vnodeopv_entry_desc ext2fs_fifoop_entries[] = {
! 1322: { &vop_default_desc, fifo_vnoperate },
! 1323: { &vop_close_desc, ufsfifo_close }, /* close */
! 1324: { &vop_access_desc, ext2fs_access }, /* access */
! 1325: { &vop_getattr_desc, ext2fs_getattr }, /* getattr */
! 1326: { &vop_setattr_desc, ext2fs_setattr }, /* setattr */
! 1327: { &vop_read_desc, ufsfifo_read }, /* read */
! 1328: { &vop_write_desc, ufsfifo_write }, /* write */
! 1329: { &vop_fsync_desc, ext2fs_fsync }, /* fsync */
! 1330: { &vop_inactive_desc, ext2fs_inactive },/* inactive */
! 1331: { &vop_reclaim_desc, ext2fsfifo_reclaim }, /* reclaim */
! 1332: { &vop_lock_desc, ufs_lock }, /* lock */
! 1333: { &vop_unlock_desc, ufs_unlock }, /* unlock */
! 1334: { &vop_print_desc, ufs_print }, /* print */
! 1335: { &vop_islocked_desc, ufs_islocked }, /* islocked */
! 1336: { &vop_bwrite_desc, vop_generic_bwrite }, /* bwrite */
! 1337: { NULL, NULL }
! 1338: };
! 1339: struct vnodeopv_desc ext2fs_fifoop_opv_desc =
! 1340: { &ext2fs_fifoop_p, ext2fs_fifoop_entries };
! 1341:
! 1342: int
! 1343: ext2fsfifo_reclaim(void *v)
! 1344: {
! 1345: fifo_reclaim(v);
! 1346: return (ext2fs_reclaim(v));
! 1347: }
! 1348: #endif /* FIFO */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ext2fs_vnops.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ufs / ext2fs