Annotation of sys/xfs/xfs_vfsops-bsd.c, Revision 1.1
1.1 ! nbrk 1: /*
! 2: * Copyright (c) 1995 - 2002 Kungliga Tekniska Högskolan
! 3: * (Royal Institute of Technology, Stockholm, Sweden).
! 4: * All rights reserved.
! 5: *
! 6: * Redistribution and use in source and binary forms, with or without
! 7: * modification, are permitted provided that the following conditions
! 8: * are met:
! 9: *
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: *
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: *
! 17: * 3. Neither the name of the Institute nor the names of its contributors
! 18: * may be used to endorse or promote products derived from this software
! 19: * without specific prior written permission.
! 20: *
! 21: * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 31: * SUCH DAMAGE.
! 32: */
! 33:
! 34: #include <xfs/xfs_locl.h>
! 35:
! 36: RCSID("$arla: xfs_vfsops-bsd.c,v 1.72 2002/12/19 10:30:17 lha Exp $");
! 37:
! 38: /*
! 39: * NNPFS vfs operations.
! 40: */
! 41:
! 42: #include <xfs/xfs_common.h>
! 43: #include <xfs/xfs_message.h>
! 44: #include <xfs/xfs_fs.h>
! 45: #include <xfs/xfs_dev.h>
! 46: #include <xfs/xfs_deb.h>
! 47: #include <xfs/xfs_vfsops.h>
! 48: #include <xfs/xfs_vfsops-bsd.h>
! 49: #include <xfs/xfs_vnodeops.h>
! 50:
! 51: int
! 52: xfs_mount_caddr(struct mount *mp,
! 53: const char *user_path,
! 54: caddr_t user_data,
! 55: struct nameidata *ndp,
! 56: d_thread_t *p)
! 57: {
! 58: return xfs_mount_common(mp, user_path, user_data, ndp, p);
! 59: }
! 60:
! 61: int
! 62: xfs_start(struct mount * mp, int flags, d_thread_t * p)
! 63: {
! 64: NNPFSDEB(XDEBVFOPS, ("xfs_start mp = %lx, flags = %d, proc = %lx\n",
! 65: (unsigned long)mp, flags, (unsigned long)p));
! 66: return 0;
! 67: }
! 68:
! 69:
! 70: int
! 71: xfs_unmount(struct mount * mp, int mntflags, d_thread_t *p)
! 72: {
! 73: NNPFSDEB(XDEBVFOPS, ("xfs_umount: mp = %lx, mntflags = %d, proc = %lx\n",
! 74: (unsigned long)mp, mntflags, (unsigned long)p));
! 75: return xfs_unmount_common(mp, mntflags);
! 76: }
! 77:
! 78: int
! 79: xfs_root(struct mount *mp, struct vnode **vpp)
! 80: {
! 81: NNPFSDEB(XDEBVFOPS, ("xfs_root mp = %lx\n", (unsigned long)mp));
! 82: #ifdef HAVE_FREEBSD_THREAD
! 83: return xfs_root_common(mp, vpp, xfs_curthread(), xfs_curthread()->td_proc->p_ucred);
! 84: #else
! 85: return xfs_root_common(mp, vpp, xfs_curproc(), xfs_curproc()->p_ucred);
! 86: #endif
! 87: }
! 88:
! 89: int
! 90: xfs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg, d_thread_t *p)
! 91: {
! 92: NNPFSDEB(XDEBVFOPS, ("xfs_quotactl: mp = %lx, cmd = %d, uid = %u, "
! 93: "arg = %lx, proc = %lx\n",
! 94: (unsigned long)mp, cmd, uid,
! 95: (unsigned long)arg, (unsigned long)p));
! 96: return EOPNOTSUPP;
! 97: }
! 98:
! 99: int
! 100: xfs_statfs(struct mount *mp, struct statfs *sbp, d_thread_t *p)
! 101: {
! 102: NNPFSDEB(XDEBVFOPS, ("xfs_statfs: mp = %lx, sbp = %lx, proc = %lx\n",
! 103: (unsigned long)mp,
! 104: (unsigned long)sbp,
! 105: (unsigned long)p));
! 106: bcopy(&mp->mnt_stat, sbp, sizeof(*sbp));
! 107: return 0;
! 108: }
! 109:
! 110: int
! 111: xfs_sync(struct mount *mp, int waitfor, struct ucred *cred, d_thread_t *p)
! 112: {
! 113: NNPFSDEB(XDEBVFOPS, ("xfs_sync: mp = %lx, waitfor = %d, "
! 114: "cred = %lx, proc = %lx\n",
! 115: (unsigned long)mp,
! 116: waitfor,
! 117: (unsigned long)cred,
! 118: (unsigned long)p));
! 119: return 0;
! 120: }
! 121:
! 122: int
! 123: xfs_vget(struct mount * mp,
! 124: #ifdef __APPLE__
! 125: void *ino,
! 126: #else
! 127: ino_t ino,
! 128: #endif
! 129: struct vnode ** vpp)
! 130: {
! 131: NNPFSDEB(XDEBVFOPS, ("xfs_vget\n"));
! 132: return EOPNOTSUPP;
! 133: }
! 134:
! 135: static int
! 136: common_fhtovp(struct mount * mp,
! 137: struct fid * fhp,
! 138: struct vnode ** vpp)
! 139: {
! 140: #ifdef ARLA_KNFS
! 141: struct netcred *np = NULL;
! 142: struct xfs_node *xn;
! 143: struct vnode *vp;
! 144: xfs_handle handle;
! 145: int error;
! 146:
! 147: NNPFSDEB(XDEBVFOPS, ("xfs_fhtovp\n"));
! 148:
! 149: if (fhp->fid_len != 16) {
! 150: printf("xfs_fhtovp: *PANIC* got a invalid length of a fid\n");
! 151: return EINVAL;
! 152: }
! 153:
! 154: memcpy(&handle, fhp->fid_data, sizeof(handle));
! 155: NNPFSDEB(XDEBVFOPS, ("xfs_fhtovp: fid: %d.%d.%d.%d\n",
! 156: handle.a, handle.d, handle.c, handle.d));
! 157:
! 158: NNPFSDEB(XDEBVFOPS, ("xfs_fhtovp: xfs_vnode_find\n"));
! 159: xn = xfs_node_find(&xfs[0].nodehead, &handle);
! 160:
! 161: if (xn == NULL) {
! 162: struct xfs_message_getattr msg;
! 163:
! 164: error = xfs_getnewvnode(xfs[0].mp, &vp, &handle);
! 165: if (error)
! 166: return error;
! 167:
! 168: xfs_do_vget(vp, 0, curproc);
! 169:
! 170: } else {
! 171: /* XXX access ? */
! 172: vp = XNODE_TO_VNODE(xn);
! 173:
! 174: /* XXX wrong ? (we tell arla below) */
! 175: if (vp->v_usecount <= 0)
! 176: xfs_do_vget(vp, 0, curproc);
! 177: else
! 178: VREF(vp);
! 179: error = 0;
! 180: }
! 181:
! 182: *vpp = vp;
! 183:
! 184: if (error == 0) {
! 185: NNPFSDEB(XDEBVFOPS, ("xfs_fhtovp done\n"));
! 186:
! 187: /*
! 188: * XXX tell arla about this node is hold by nfsd.
! 189: * There need to be code in xfs_write too.
! 190: */
! 191: } else
! 192: NNPFSDEB(XDEBVFOPS, ("xfs_fhtovp failed (%d)\n", error));
! 193:
! 194: return error;
! 195: #else /* !ARLA_KNFS */
! 196: return EOPNOTSUPP;
! 197: #endif /* !ARLA_KNFS */
! 198: }
! 199:
! 200: /* new style fhtovp */
! 201:
! 202: #ifdef HAVE_STRUCT_VFSOPS_VFS_CHECKEXP
! 203: int
! 204: xfs_fhtovp(struct mount * mp,
! 205: struct fid * fhp,
! 206: struct vnode ** vpp)
! 207: {
! 208: return common_fhtovp (mp, fhp, vpp);
! 209: }
! 210:
! 211: #else /* !HAVE_STRUCT_VFSOPS_VFS_CHECKEXP */
! 212:
! 213: /* old style fhtovp */
! 214:
! 215: int
! 216: xfs_fhtovp(struct mount * mp,
! 217: struct fid * fhp,
! 218: struct mbuf * nam,
! 219: struct vnode ** vpp,
! 220: int *exflagsp,
! 221: struct ucred ** credanonp)
! 222: {
! 223: static struct ucred fhtovpcred;
! 224: int error;
! 225:
! 226: /* XXX: Should see if we is exported to this client */
! 227: #if 0
! 228: np = vfs_export_lookup(mp, &ump->um_export, nam);
! 229: if (np == NULL)
! 230: return EACCES;
! 231: #endif
! 232: error = common_fhtovp(mp, fhp, vpp);
! 233: if (error == 0) {
! 234: fhtovpcred.cr_uid = 0;
! 235: fhtovpcred.cr_gid = 0;
! 236: fhtovpcred.cr_ngroups = 0;
! 237:
! 238: #ifdef MNT_EXPUBLIC
! 239: *exflagsp = MNT_EXPUBLIC;
! 240: #else
! 241: *exflagsp = 0;
! 242: #endif
! 243: *credanonp = &fhtovpcred;
! 244: }
! 245: return error;
! 246: }
! 247: #endif /* !HAVE_STRUCT_VFSOPS_VFS_CHECKEXP */
! 248:
! 249: int
! 250: xfs_checkexp (struct mount *mp,
! 251: #ifdef __FreeBSD__
! 252: struct sockaddr *nam,
! 253: #else
! 254: struct mbuf *nam,
! 255: #endif
! 256: int *exflagsp,
! 257: struct ucred **credanonp)
! 258: {
! 259: NNPFSDEB(XDEBVFOPS, ("xfs_checkexp\n"));
! 260:
! 261: #if 0
! 262: np = vfs_export_lookup(mp, &ump->um_export, nam);
! 263: if (np == NULL)
! 264: return EACCES;
! 265: #endif
! 266: return 0;
! 267: }
! 268:
! 269: int
! 270: xfs_vptofh(struct vnode * vp,
! 271: struct fid * fhp)
! 272: {
! 273: #ifdef ARLA_KNFS
! 274: struct xfs_node *xn;
! 275: NNPFSDEB(XDEBVFOPS, ("xfs_vptofh\n"));
! 276:
! 277: if (MAXFIDSZ < 16)
! 278: return EOPNOTSUPP;
! 279:
! 280: xn = VNODE_TO_XNODE(vp);
! 281:
! 282: if (xn == NULL)
! 283: return EINVAL;
! 284:
! 285: fhp->fid_len = 16;
! 286: memcpy(fhp->fid_data, &xn->handle, 16);
! 287:
! 288: return 0;
! 289: #else
! 290: NNPFSDEB(XDEBVFOPS, ("xfs_vptofh\n"));
! 291: return EOPNOTSUPP;
! 292: #endif
! 293: }
! 294:
! 295: /*
! 296: * xfs complete dead vnodes implementation.
! 297: *
! 298: * this is because the dead_vnodeops_p is _not_ filesystem, but rather
! 299: * a part of the vfs-layer.
! 300: */
! 301:
! 302: int
! 303: xfs_dead_lookup(struct vop_lookup_args * ap)
! 304: /* struct vop_lookup_args {
! 305: struct vnodeop_desc *a_desc;
! 306: struct vnode *a_dvp;
! 307: struct vnode **a_vpp;
! 308: struct componentname *a_cnp;
! 309: }; */
! 310: {
! 311: *ap->a_vpp = NULL;
! 312: return ENOTDIR;
! 313: }
! 314:
! 315: /*
! 316: * Given `fsid', `fileid', and `gen', return in `vpp' a locked and
! 317: * ref'ed vnode from that file system with that id and generation.
! 318: * All is done in the context of `proc'. Returns 0 if successful, and
! 319: * error otherwise.
! 320: */
! 321:
! 322: int
! 323: xfs_fhlookup (d_thread_t *proc,
! 324: struct xfs_fhandle_t *fhp,
! 325: struct vnode **vpp)
! 326: {
! 327: int error;
! 328: struct mount *mp;
! 329: #if !(defined(HAVE_GETFH) && defined(HAVE_FHOPEN))
! 330: struct ucred *cred = proc->p_ucred;
! 331: struct vattr vattr;
! 332: fsid_t fsid;
! 333: struct xfs_fh_args *fh_args = (struct xfs_fh_args *)fhp->fhdata;
! 334:
! 335: NNPFSDEB(XDEBVFOPS, ("xfs_fhlookup (xfs)\n"));
! 336:
! 337: error = xfs_suser (proc);
! 338: if (error)
! 339: return EPERM;
! 340:
! 341: if (fhp->len < sizeof(struct xfs_fh_args))
! 342: return EINVAL;
! 343:
! 344: fsid = SCARG(fh_args, fsid);
! 345:
! 346: mp = xfs_vfs_getvfs (&fsid);
! 347: if (mp == NULL)
! 348: return ENXIO;
! 349:
! 350: #ifdef __APPLE__
! 351: {
! 352: uint32_t ino = SCARG(fh_args, fileid);
! 353: error = VFS_VGET(mp, &ino, vpp);
! 354: }
! 355: #else
! 356: error = VFS_VGET(mp, SCARG(fh_args, fileid), vpp);
! 357: #endif
! 358:
! 359: if (error)
! 360: return error;
! 361:
! 362: if (*vpp == NULL)
! 363: return ENOENT;
! 364:
! 365: error = VOP_GETATTR(*vpp, &vattr, cred, proc);
! 366: if (error) {
! 367: vput(*vpp);
! 368: return error;
! 369: }
! 370:
! 371: if (vattr.va_gen != SCARG(fh_args, gen)) {
! 372: vput(*vpp);
! 373: return ENOENT;
! 374: }
! 375: #else /* HAVE_GETFH && HAVE_FHOPEN */
! 376: {
! 377: fhandle_t *fh = (fhandle_t *) fhp;
! 378:
! 379: NNPFSDEB(XDEBVFOPS, ("xfs_fhlookup (native)\n"));
! 380:
! 381: mp = xfs_vfs_getvfs (&fh->fh_fsid);
! 382: if (mp == NULL)
! 383: return ESTALE;
! 384:
! 385: if ((error = VFS_FHTOVP(mp, &fh->fh_fid, vpp)) != 0) {
! 386: *vpp = NULL;
! 387: return error;
! 388: }
! 389: }
! 390: #endif /* HAVE_GETFH && HAVE_FHOPEN */
! 391:
! 392: #ifdef HAVE_KERNEL_VFS_OBJECT_CREATE
! 393: if ((*vpp)->v_type == VREG && (*vpp)->v_object == NULL)
! 394: #ifdef HAVE_FREEBSD_THREAD
! 395: xfs_vfs_object_create (*vpp, proc, proc->td_proc->p_ucred);
! 396: #else
! 397: xfs_vfs_object_create (*vpp, proc, proc->p_ucred);
! 398: #endif
! 399: #elif __APPLE__
! 400: if ((*vpp)->v_type == VREG && (!UBCINFOEXISTS(*vpp))) {
! 401: ubc_info_init(*vpp);
! 402: }
! 403: ubc_hold(*vpp);
! 404: #endif
! 405: return 0;
! 406: }
! 407:
! 408:
! 409:
! 410: /*
! 411: * Perform an open operation on the vnode identified by a `xfs_fhandle_t'
! 412: * (see xfs_fhlookup) with flags `user_flags'. Returns 0 or
! 413: * error. If successful, the file descriptor is returned in `retval'.
! 414: */
! 415:
! 416: extern struct fileops vnops; /* sometimes declared in <file.h> */
! 417:
! 418: int
! 419: xfs_fhopen (d_thread_t *proc,
! 420: struct xfs_fhandle_t *fhp,
! 421: int user_flags,
! 422: register_t *retval)
! 423: {
! 424: int error;
! 425: struct vnode *vp;
! 426: #ifdef HAVE_FREEBSD_THREAD
! 427: struct ucred *cred = proc->td_proc->p_ucred;
! 428: #else
! 429: struct ucred *cred = proc->p_ucred;
! 430: #endif
! 431: int flags = FFLAGS(user_flags);
! 432: int index;
! 433: struct file *fp;
! 434: int mode;
! 435: struct xfs_fhandle_t fh;
! 436:
! 437: NNPFSDEB(XDEBVFOPS, ("xfs_fhopen: flags = %d\n", user_flags));
! 438:
! 439: error = copyin (fhp, &fh, sizeof(fh));
! 440: if (error)
! 441: return error;
! 442:
! 443: error = xfs_fhlookup (proc, &fh, &vp);
! 444: NNPFSDEB(XDEBVFOPS, ("xfs_fhlookup returned %d\n", error));
! 445: if (error)
! 446: return error;
! 447:
! 448: switch (vp->v_type) {
! 449: case VDIR :
! 450: case VREG :
! 451: break;
! 452: case VLNK :
! 453: error = EMLINK;
! 454: goto out;
! 455: default :
! 456: error = EOPNOTSUPP;
! 457: goto out;
! 458: }
! 459:
! 460: mode = 0;
! 461: if (flags & FWRITE) {
! 462: switch (vp->v_type) {
! 463: case VREG :
! 464: break;
! 465: case VDIR :
! 466: error = EISDIR;
! 467: goto out;
! 468: default :
! 469: error = EOPNOTSUPP;
! 470: goto out;
! 471: }
! 472:
! 473: error = vn_writechk (vp);
! 474: if (error)
! 475: goto out;
! 476:
! 477: mode |= VWRITE;
! 478: }
! 479: if (flags & FREAD)
! 480: mode |= VREAD;
! 481:
! 482: if (mode) {
! 483: error = VOP_ACCESS(vp, mode, cred, proc);
! 484: if (error)
! 485: goto out;
! 486: }
! 487:
! 488: error = VOP_OPEN(vp, flags, cred, proc);
! 489: if (error)
! 490: goto out;
! 491:
! 492: error = falloc(proc, &fp, &index);
! 493: if (error)
! 494: goto out;
! 495:
! 496: if (flags & FWRITE)
! 497: vp->v_writecount++;
! 498:
! 499: #if defined(__FreeBSD_version) && __FreeBSD_version >= 300000
! 500: if (vp->v_type == VREG) {
! 501: #ifdef HAVE_FREEBSD_THREAD
! 502: error = xfs_vfs_object_create(vp, proc, proc->td_proc->p_ucred);
! 503: #else
! 504: error = xfs_vfs_object_create(vp, proc, proc->p_ucred);
! 505: #endif
! 506: if (error)
! 507: goto out;
! 508: }
! 509: #endif
! 510:
! 511: fp->f_flag = flags & FMASK;
! 512: fp->f_type = DTYPE_VNODE;
! 513: fp->f_ops = &vnops;
! 514: fp->f_data = (caddr_t)vp;
! 515: xfs_vfs_unlock(vp, proc);
! 516: *retval = index;
! 517: #ifdef FILE_UNUSE
! 518: FILE_UNUSE(fp, proc);
! 519: #endif
! 520: #ifdef __APPLE__
! 521: *fdflags(proc, index) &= ~UF_RESERVED;
! 522: #endif
! 523: return 0;
! 524: out:
! 525: NNPFSDEB(XDEBVFOPS, ("xfs_fhopen: error = %d\n", error));
! 526: vput(vp);
! 527: return error;
! 528: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xfs_vfsops-bsd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / xfs