Annotation of sys/xfs/xfs_syscalls-common.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_syscalls-common.c,v 1.72 2003/01/19 20:53:49 lha Exp $");
! 37:
! 38: /*
! 39: * NNPFS system calls.
! 40: */
! 41:
! 42: #include <xfs/xfs_syscalls.h>
! 43: #include <xfs/xfs_message.h>
! 44: #include <xfs/xfs_fs.h>
! 45: #include <xfs/xfs_dev.h>
! 46: #include <xfs/xfs_node.h>
! 47: #include <xfs/xfs_vfsops.h>
! 48: #include <xfs/xfs_deb.h>
! 49:
! 50: /* Misc syscalls */
! 51: #ifdef HAVE_SYS_IOCCOM_H
! 52: #include <sys/ioccom.h>
! 53: #elif defined(HAVE_SYS_IOCTL_H)
! 54: #include <sys/ioctl.h>
! 55: #endif
! 56: /*
! 57: * XXX - horrible kludge. If we are openbsd and not building an lkm,
! 58: * then use their headerfile.
! 59: */
! 60: #if (defined(__OpenBSD__) || defined(__NetBSD__)) && !defined(_LKM)
! 61: #define NNPFS_NOT_LKM 1
! 62: #elif defined(__FreeBSD__) && !defined(KLD_MODULE)
! 63: #define NNPFS_NOT_LKM 1
! 64: #endif
! 65:
! 66: #ifdef NNPFS_NOT_LKM
! 67: #include <xfs/xfs_pioctl.h>
! 68: #else
! 69: #include <kafs.h>
! 70: #endif
! 71:
! 72: int (*old_setgroups_func)(syscall_d_thread_t *p, void *v, register_t *retval);
! 73:
! 74: #if defined(__FreeBSD__) && __FreeBSD_version >= 500026
! 75: /*
! 76: * XXX This is wrong
! 77: */
! 78: static struct ucred *
! 79: xfs_crcopy(struct ucred *cr)
! 80: {
! 81: struct ucred *ncr;
! 82:
! 83: if (crshared(cr)) {
! 84: ncr = crdup(cr);
! 85: crfree(cr);
! 86: return ncr;
! 87: }
! 88: return cr;
! 89: }
! 90: #else
! 91: #define xfs_crcopy crcopy
! 92: #endif
! 93:
! 94:
! 95: /*
! 96: * the syscall entry point
! 97: */
! 98:
! 99: #ifdef NNPFS_NOT_LKM
! 100: int
! 101: sys_xfspioctl(syscall_d_thread_t *proc, void *varg, register_t *return_value)
! 102: #else
! 103: int
! 104: xfspioctl(syscall_d_thread_t *proc, void *varg, register_t *return_value)
! 105: #endif
! 106: {
! 107: #ifdef NNPFS_NOT_LKM
! 108: struct sys_xfspioctl_args *arg = (struct sys_xfspioctl_args *) varg;
! 109: #else
! 110: struct sys_pioctl_args *arg = (struct sys_pioctl_args *) varg;
! 111: #endif
! 112: int error = EINVAL;
! 113:
! 114: switch (SCARG(arg, operation)) {
! 115: case AFSCALL_PIOCTL:
! 116: error = xfs_pioctl_call(syscall_thread_to_thread(proc),
! 117: varg, return_value);
! 118: break;
! 119: case AFSCALL_SETPAG:
! 120: #ifdef HAVE_FREEBSD_THREAD
! 121: error = xfs_setpag_call(&xfs_thread_to_cred(proc));
! 122: #else
! 123: error = xfs_setpag_call(&xfs_proc_to_cred(syscall_thread_to_thread(proc)));
! 124: #endif
! 125: break;
! 126: default:
! 127: NNPFSDEB(XDEBSYS, ("Unimplemeted xfspioctl: %d\n",
! 128: SCARG(arg, operation)));
! 129: error = EINVAL;
! 130: break;
! 131: }
! 132:
! 133: return error;
! 134: }
! 135:
! 136: /*
! 137: * Def pag:
! 138: * 33536 <= g0 <= 34560
! 139: * 32512 <= g1 <= 48896
! 140: */
! 141:
! 142: #define NNPFS_PAG1_LLIM 33536
! 143: #define NNPFS_PAG1_ULIM 34560
! 144: #define NNPFS_PAG2_LLIM 32512
! 145: #define NNPFS_PAG2_ULIM 48896
! 146:
! 147: static gid_t pag_part_one = NNPFS_PAG1_LLIM;
! 148: static gid_t pag_part_two = NNPFS_PAG2_LLIM;
! 149:
! 150: /*
! 151: * Is `cred' member of a PAG?
! 152: */
! 153:
! 154: static int
! 155: xfs_is_pag(struct ucred *cred)
! 156: {
! 157: /* The first group is the gid of the user ? */
! 158:
! 159: if (cred->cr_ngroups >= 3 &&
! 160: cred->cr_groups[1] >= NNPFS_PAG1_LLIM &&
! 161: cred->cr_groups[1] <= NNPFS_PAG1_ULIM &&
! 162: cred->cr_groups[2] >= NNPFS_PAG2_LLIM &&
! 163: cred->cr_groups[2] <= NNPFS_PAG2_ULIM)
! 164: return 1;
! 165: else
! 166: return 0;
! 167: }
! 168:
! 169: /*
! 170: * Return the pag used by `cred'
! 171: */
! 172:
! 173: xfs_pag_t
! 174: xfs_get_pag(struct ucred *cred)
! 175: {
! 176: if (xfs_is_pag(cred)) {
! 177:
! 178: return (((cred->cr_groups[1] << 16) & 0xFFFF0000) |
! 179: ((cred->cr_groups[2] & 0x0000FFFF)));
! 180:
! 181: } else
! 182: return cred->cr_uid; /* XXX */
! 183: }
! 184:
! 185: /*
! 186: * Set the pag in `ret_cred' and return a new cred.
! 187: */
! 188:
! 189: static int
! 190: store_pag (struct ucred **ret_cred, gid_t part1, gid_t part2)
! 191: {
! 192: struct ucred *cred = *ret_cred;
! 193:
! 194: if (!xfs_is_pag (cred)) {
! 195: int i;
! 196:
! 197: if (cred->cr_ngroups + 2 >= NGROUPS)
! 198: return E2BIG;
! 199:
! 200: cred = xfs_crcopy (cred);
! 201:
! 202: for (i = cred->cr_ngroups - 1; i > 0; i--) {
! 203: cred->cr_groups[i + 2] = cred->cr_groups[i];
! 204: }
! 205: cred->cr_ngroups += 2;
! 206: } else {
! 207: cred = xfs_crcopy (cred);
! 208: }
! 209: cred->cr_groups[1] = part1;
! 210: cred->cr_groups[2] = part2;
! 211: *ret_cred = cred;
! 212:
! 213: return 0;
! 214: }
! 215:
! 216: /*
! 217: * Acquire a new pag in `ret_cred'
! 218: */
! 219:
! 220: int
! 221: xfs_setpag_call(struct ucred **ret_cred)
! 222: {
! 223: int ret;
! 224:
! 225: ret = store_pag (ret_cred, pag_part_one, pag_part_two++);
! 226: if (ret)
! 227: return ret;
! 228:
! 229: if (pag_part_two > NNPFS_PAG2_ULIM) {
! 230: pag_part_one++;
! 231: pag_part_two = NNPFS_PAG2_LLIM;
! 232: }
! 233: return 0;
! 234: }
! 235:
! 236: #ifndef NNPFS_NOT_LKM
! 237: /*
! 238: * remove a pag
! 239: */
! 240:
! 241: static int
! 242: xfs_unpag (struct ucred *cred)
! 243: {
! 244: while (xfs_is_pag (cred)) {
! 245: int i;
! 246:
! 247: for (i = 0; i < cred->cr_ngroups - 2; ++i)
! 248: cred->cr_groups[i] = cred->cr_groups[i+2];
! 249: cred->cr_ngroups -= 2;
! 250: }
! 251: return 0;
! 252: }
! 253:
! 254: /*
! 255: * A wrapper around setgroups that preserves the pag.
! 256: */
! 257:
! 258: int
! 259: xfs_setgroups (syscall_d_thread_t *p,
! 260: void *varg,
! 261: register_t *retval)
! 262: {
! 263: struct xfs_setgroups_args *uap = (struct xfs_setgroups_args *)varg;
! 264: #ifdef HAVE_FREEBSD_THREAD
! 265: struct ucred **cred = &xfs_thread_to_cred(p);
! 266: #else
! 267: struct ucred **cred = &xfs_proc_to_cred(syscall_thread_to_thread(p));
! 268: #endif
! 269:
! 270: if (xfs_is_pag (*cred)) {
! 271: gid_t part1, part2;
! 272: int ret;
! 273:
! 274: if (SCARG(uap,gidsetsize) + 2 > NGROUPS)
! 275: return EINVAL;
! 276:
! 277: part1 = (*cred)->cr_groups[1];
! 278: part2 = (*cred)->cr_groups[2];
! 279: ret = (*old_setgroups_func) (p, uap, retval);
! 280: if (ret)
! 281: return ret;
! 282: return store_pag (cred, part1, part2);
! 283: } else {
! 284: int ret;
! 285:
! 286: ret = (*old_setgroups_func) (p, uap, retval);
! 287: /* don't support setting a PAG */
! 288: if (xfs_is_pag (*cred)) {
! 289: xfs_unpag (*cred);
! 290: return EINVAL;
! 291: }
! 292: return ret;
! 293: }
! 294: }
! 295: #endif /* !NNPFS_NOT_LKM */
! 296:
! 297: /*
! 298: * Return the vnode corresponding to `pathptr'
! 299: */
! 300:
! 301: static int
! 302: lookup_node (const char *pathptr,
! 303: int follow_links_p,
! 304: struct vnode **res,
! 305: d_thread_t *proc)
! 306: {
! 307: int error;
! 308: char path[MAXPATHLEN];
! 309: #ifdef __osf__
! 310: struct nameidata *ndp = &u.u_nd;
! 311: #else
! 312: struct nameidata nd, *ndp = &nd;
! 313: #endif
! 314: struct vnode *vp;
! 315: size_t count;
! 316:
! 317: NNPFSDEB(XDEBSYS, ("xfs_syscall: looking up: %lx\n",
! 318: (unsigned long)pathptr));
! 319:
! 320: error = copyinstr((char *) pathptr, path, MAXPATHLEN, &count);
! 321:
! 322: NNPFSDEB(XDEBSYS, ("xfs_syscall: looking up: %s, error: %d\n", path, error));
! 323:
! 324: if (error)
! 325: return error;
! 326:
! 327: NDINIT(ndp, LOOKUP,
! 328: follow_links_p ? FOLLOW : 0,
! 329: UIO_SYSSPACE, path, proc);
! 330:
! 331: error = namei(ndp);
! 332:
! 333: if (error != 0) {
! 334: NNPFSDEB(XDEBSYS, ("xfs_syscall: error during namei: %d\n", error));
! 335: return EINVAL;
! 336: }
! 337:
! 338: vp = ndp->ni_vp;
! 339:
! 340: *res = vp;
! 341: return 0;
! 342: }
! 343:
! 344: /*
! 345: * implement xfs fhget in a way that should be compatible with the native
! 346: * getfh
! 347: */
! 348:
! 349: static int
! 350: getfh_compat (d_thread_t *p,
! 351: struct ViceIoctl *vice_ioctl,
! 352: struct vnode *vp)
! 353: {
! 354: /* This is to be same as getfh */
! 355: fhandle_t fh;
! 356: int error;
! 357:
! 358: bzero((caddr_t)&fh, sizeof(fh));
! 359: fh.fh_fsid = vp->v_mount->mnt_stat.f_fsid;
! 360: #if __osf__
! 361: VFS_VPTOFH(vp, &fh.fh_fid, error);
! 362: #else
! 363: error = VFS_VPTOFH(vp, &fh.fh_fid);
! 364: #endif
! 365: if (error)
! 366: return error;
! 367:
! 368: if (vice_ioctl->out_size < sizeof(fh))
! 369: return EINVAL;
! 370:
! 371: return copyout((caddr_t)&fh, vice_ioctl->out, sizeof (fh));
! 372: }
! 373:
! 374: /*
! 375: * implement xfs fhget by combining (dev, ino, generation)
! 376: */
! 377:
! 378: #ifndef __OpenBSD__
! 379: static int
! 380: trad_fhget (d_thread_t *p,
! 381: struct ViceIoctl *vice_ioctl,
! 382: struct vnode *vp)
! 383: {
! 384: int error;
! 385: struct mount *mnt;
! 386: struct vattr vattr;
! 387: size_t len;
! 388: struct xfs_fhandle_t xfs_handle;
! 389: struct xfs_fh_args fh_args;
! 390:
! 391: #ifdef HAVE_FREEBSD_THREAD
! 392: xfs_vop_getattr(vp, &vattr, xfs_thread_to_cred(p), p, error);
! 393: #else
! 394: xfs_vop_getattr(vp, &vattr, xfs_proc_to_cred(p), p, error);
! 395: #endif
! 396: if (error)
! 397: return error;
! 398:
! 399: mnt = vp->v_mount;
! 400:
! 401: SCARG(&fh_args, fsid) = mnt->mnt_stat.f_fsid;
! 402: SCARG(&fh_args, fileid) = vattr.va_fileid;
! 403: SCARG(&fh_args, gen) = vattr.va_gen;
! 404:
! 405: xfs_handle.len = sizeof(fh_args);
! 406: memcpy (xfs_handle.fhdata, &fh_args, sizeof(fh_args));
! 407: len = sizeof(xfs_handle);
! 408:
! 409: if (vice_ioctl->out_size < len)
! 410: return EINVAL;
! 411:
! 412: error = copyout (&xfs_handle, vice_ioctl->out, len);
! 413: if (error) {
! 414: NNPFSDEB(XDEBSYS, ("fhget_call: copyout failed: %d\n", error));
! 415: }
! 416: return error;
! 417: }
! 418: #endif /* ! __OpenBSD__ */
! 419:
! 420: /*
! 421: * return file handle of `vp' in vice_ioctl->out
! 422: * vp is vrele:d
! 423: */
! 424:
! 425: static int
! 426: fhget_call (d_thread_t *p,
! 427: struct ViceIoctl *vice_ioctl,
! 428: struct vnode *vp)
! 429: {
! 430: int error;
! 431:
! 432: NNPFSDEB(XDEBSYS, ("fhget_call\n"));
! 433:
! 434: if (vp == NULL)
! 435: return EBADF;
! 436:
! 437: #if defined(__APPLE__) || defined(__osf__)
! 438: error = EINVAL; /* XXX: Leaks vnodes if fhget/fhopen is used */
! 439: goto out;
! 440: #endif
! 441:
! 442: error = xfs_suser (p);
! 443: if (error)
! 444: goto out;
! 445:
! 446: #if (defined(HAVE_GETFH) && defined(HAVE_FHOPEN)) || defined(__osf__)
! 447: error = getfh_compat (p, vice_ioctl, vp);
! 448: #else
! 449: error = trad_fhget (p, vice_ioctl, vp);
! 450: #endif /* HAVE_GETFH && HAVE_FHOPEN */
! 451: out:
! 452: vrele(vp);
! 453: return error;
! 454: }
! 455:
! 456: /*
! 457: * open the file specified in `vice_ioctl->in'
! 458: */
! 459:
! 460: static int
! 461: fhopen_call (d_thread_t *p,
! 462: struct ViceIoctl *vice_ioctl,
! 463: struct vnode *vp,
! 464: int flags,
! 465: register_t *retval)
! 466: {
! 467:
! 468: NNPFSDEB(XDEBSYS, ("fhopen_call: flags = %d\n", flags));
! 469:
! 470: if (vp != NULL) {
! 471: vrele (vp);
! 472: return EINVAL;
! 473: }
! 474:
! 475: #if defined(__APPLE__) || defined(__osf__)
! 476: return EINVAL; /* XXX: Leaks vnodes if fhget/fhopen is used */
! 477: #endif
! 478:
! 479: return xfs_fhopen (p,
! 480: (struct xfs_fhandle_t *)vice_ioctl->in,
! 481: flags,
! 482: retval);
! 483: }
! 484:
! 485: /*
! 486: * Send the pioctl to arlad
! 487: */
! 488:
! 489: static int
! 490: remote_pioctl (d_thread_t *p,
! 491: struct sys_pioctl_args *arg,
! 492: struct ViceIoctl *vice_ioctl,
! 493: struct vnode *vp)
! 494: {
! 495: int error = 0;
! 496: struct xfs_message_pioctl *msg = NULL;
! 497: struct xfs_message_wakeup_data *msg2;
! 498:
! 499: msg = malloc(sizeof(struct xfs_message_symlink), M_TEMP, M_WAITOK);
! 500: if (msg == NULL) {
! 501: error = ENOMEM;
! 502: goto done;
! 503: }
! 504: memset(msg, 0, sizeof(*msg));
! 505:
! 506: if (vp != NULL) {
! 507: struct xfs_node *xn;
! 508:
! 509: if (vp->v_tag != VT_XFS) {
! 510: NNPFSDEB(XDEBSYS, ("xfs_syscall: file is not in afs\n"));
! 511: vrele(vp);
! 512: error = EINVAL;
! 513: goto done;
! 514: }
! 515:
! 516: xn = VNODE_TO_XNODE(vp);
! 517:
! 518: msg->handle = xn->handle;
! 519: vrele(vp);
! 520: }
! 521:
! 522: if (vice_ioctl->in_size < 0) {
! 523: printf("xfs: remote pioctl: got a negative data size: opcode: %d",
! 524: SCARG(arg, a_opcode));
! 525: error = EINVAL;
! 526: goto done;
! 527: }
! 528:
! 529: if (vice_ioctl->in_size > NNPFS_MSG_MAX_DATASIZE) {
! 530: printf("xfs_pioctl_call: got a humongous in packet: opcode: %d",
! 531: SCARG(arg, a_opcode));
! 532: error = EINVAL;
! 533: goto done;
! 534: }
! 535: if (vice_ioctl->in_size != 0) {
! 536: error = copyin(vice_ioctl->in, msg->msg, vice_ioctl->in_size);
! 537: if (error)
! 538: goto done;
! 539: }
! 540:
! 541: msg->header.opcode = NNPFS_MSG_PIOCTL;
! 542: msg->header.size = sizeof(*msg);
! 543: msg->opcode = SCARG(arg, a_opcode);
! 544:
! 545: msg->insize = vice_ioctl->in_size;
! 546: msg->outsize = vice_ioctl->out_size;
! 547: #ifdef HAVE_FREEBSD_THREAD
! 548: msg->cred.uid = xfs_thread_to_euid(p);
! 549: msg->cred.pag = xfs_get_pag(xfs_thread_to_cred(p));
! 550: #else
! 551: msg->cred.uid = xfs_proc_to_euid(p);
! 552: msg->cred.pag = xfs_get_pag(xfs_proc_to_cred(p));
! 553: #endif
! 554:
! 555: error = xfs_message_rpc(0, &(msg->header), sizeof(*msg), p); /* XXX */
! 556: msg2 = (struct xfs_message_wakeup_data *) msg;
! 557:
! 558: if (error == 0)
! 559: error = msg2->error;
! 560: if (error == ENODEV)
! 561: error = EINVAL;
! 562:
! 563: if (error == 0 && msg2->header.opcode == NNPFS_MSG_WAKEUP_DATA) {
! 564: int len;
! 565:
! 566: len = msg2->len;
! 567: if (len > vice_ioctl->out_size)
! 568: len = vice_ioctl->out_size;
! 569: if (len > NNPFS_MSG_MAX_DATASIZE)
! 570: len = NNPFS_MSG_MAX_DATASIZE;
! 571: if (len < 0)
! 572: len = 0;
! 573:
! 574: error = copyout(msg2->msg, vice_ioctl->out, len);
! 575: }
! 576: done:
! 577: free(msg, M_TEMP);
! 578: return error;
! 579: }
! 580:
! 581: static int
! 582: xfs_debug (d_thread_t *p,
! 583: struct ViceIoctl *vice_ioctl)
! 584: {
! 585: int32_t flags;
! 586: int error;
! 587:
! 588: if (vice_ioctl->in_size != 0) {
! 589: if (vice_ioctl->in_size < sizeof(int32_t))
! 590: return EINVAL;
! 591:
! 592: error = xfs_suser (p);
! 593: if (error)
! 594: return error;
! 595:
! 596: error = copyin (vice_ioctl->in,
! 597: &flags,
! 598: sizeof(flags));
! 599: if (error)
! 600: return error;
! 601:
! 602: xfsdeb = flags;
! 603: }
! 604:
! 605: if (vice_ioctl->out_size != 0) {
! 606: if (vice_ioctl->out_size < sizeof(int32_t))
! 607: return EINVAL;
! 608:
! 609: error = copyout (&xfsdeb,
! 610: vice_ioctl->out,
! 611: sizeof(int32_t));
! 612: if (error)
! 613: return error;
! 614: }
! 615:
! 616: return 0;
! 617: }
! 618:
! 619:
! 620: /*
! 621: * Handle `pioctl'
! 622: */
! 623:
! 624: int
! 625: xfs_pioctl_call(d_thread_t *proc,
! 626: struct sys_pioctl_args *arg,
! 627: register_t *return_value)
! 628: {
! 629: int error;
! 630: struct ViceIoctl vice_ioctl;
! 631: char *pathptr;
! 632: struct vnode *vp = NULL;
! 633:
! 634: NNPFSDEB(XDEBSYS, ("xfs_syscall(%d, %lx, %d, %lx, %d)\n",
! 635: SCARG(arg, operation),
! 636: (unsigned long)SCARG(arg, a_pathP),
! 637: SCARG(arg, a_opcode),
! 638: (unsigned long)SCARG(arg, a_paramsP),
! 639: SCARG(arg, a_followSymlinks)));
! 640:
! 641: /* Copy in the data structure for us */
! 642:
! 643: error = copyin(SCARG(arg, a_paramsP),
! 644: &vice_ioctl,
! 645: sizeof(vice_ioctl));
! 646:
! 647: if (error)
! 648: return error;
! 649:
! 650: pathptr = SCARG(arg, a_pathP);
! 651:
! 652: if (pathptr != NULL) {
! 653: error = lookup_node (pathptr, SCARG(arg, a_followSymlinks), &vp,
! 654: proc);
! 655: if(error)
! 656: return error;
! 657: }
! 658:
! 659: switch (SCARG(arg, a_opcode)) {
! 660: case VIOC_FHGET :
! 661: return fhget_call (proc, &vice_ioctl, vp);
! 662: case VIOC_FHOPEN :
! 663: return fhopen_call (proc, &vice_ioctl, vp,
! 664: SCARG(arg, a_followSymlinks), return_value);
! 665: case VIOC_XFSDEBUG :
! 666: if (vp != NULL)
! 667: vrele (vp);
! 668: return xfs_debug (proc, &vice_ioctl);
! 669: default :
! 670: NNPFSDEB(XDEBSYS, ("a_opcode = %x\n", SCARG(arg, a_opcode)));
! 671: return remote_pioctl (proc, arg, &vice_ioctl, vp);
! 672: }
! 673: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to xfs_syscalls-common.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / xfs