![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys5.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.386|
Return to sys5.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.386 |
1.1 ! root 1: /* ! 2: * system calls introduced by the 386 port ! 3: * ! 4: * Copyright (c) Ciaran O'Donnell, Bievres (FRANCE), 1991 ! 5: */ ! 6: #include <sys/coherent.h> ! 7: #include <sys/buf.h> ! 8: #include <errno.h> ! 9: #include <canon.h> ! 10: #include <sys/con.h> ! 11: #include <fcntl.h> ! 12: #include <sys/fd.h> ! 13: #include <sys/filsys.h> ! 14: #include <sys/ino.h> ! 15: #include <sys/inode.h> ! 16: #include <sys/io.h> ! 17: #include <sys/mount.h> ! 18: #include <sys/stat.h> ! 19: #include <sys/dir.h> ! 20: #include <sys/dirent.h> ! 21: #include <sys/utsname.h> ! 22: #include <sys/mount.h> ! 23: #include <ustat.h> ! 24: #include <sys/statfs.h> ! 25: ! 26: utime(tp) ! 27: long *tp; ! 28: { ! 29: return timer.t_time; ! 30: } ! 31: ! 32: /* ! 33: * Return an unique number. ! 34: */ ! 35: usysi86(f, arg1, arg2, arg3) ! 36: { ! 37: register MOUNT *mp; ! 38: register struct filsys *fsp; ! 39: ! 40: switch (f) { ! 41: case SYI86UNEEK: ! 42: if ((mp=getment(rootdev, 1)) == NULL) ! 43: return; ! 44: fsp = &mp->m_super; ! 45: fsp->s_fmod = 1; ! 46: return (++fsp->s_unique); ! 47: case 40: ! 48: /* ! 49: * bit 2: floating point is present (80287/80387) ! 50: * bit 1: 80387 is present ! 51: */ ! 52: if (!useracc(arg1, sizeof(int))) { ! 53: SET_U_ERROR(EFAULT, "sysi386:40"); ! 54: return; ! 55: } ! 56: putuwd(arg1, 0); ! 57: break; ! 58: } ! 59: } ! 60: ! 61: ushmsys(func, arg1, arg2, arg3) ! 62: int func, arg1, arg2, arg3; ! 63: { ! 64: switch(func){ ! 65: ! 66: #if 0 ! 67: case 0: return ushmat(arg1, arg2, arg3); ! 68: case 1: return ushmdt(arg1); ! 69: #endif ! 70: case 2: return ushmctl(arg1, arg2, arg3); ! 71: case 3: return ushmget(arg1, arg2, arg3); ! 72: default: u.u_error = EINVAL; ! 73: } ! 74: } ! 75: ! 76: usemsys(func, arg1, arg2, arg3, arg4) ! 77: int func, arg1, arg2, arg3, arg4; ! 78: { ! 79: switch(func){ ! 80: case 0: return usemctl(arg1, arg2, arg3, arg4); ! 81: case 1: return usemget(arg1, arg2, arg3); ! 82: case 2: return usemop(arg1, arg2, arg3); ! 83: default: u.u_error = EINVAL; ! 84: } ! 85: } ! 86: ! 87: /* ! 88: * uname and ustat system calls. ! 89: * ! 90: * int uname(struct utsname *name) ! 91: * Before lcall instruction 4(%esp) contains name, 8(%esp) contains ! 92: * an unspecified value, and 12(%esp) contains the value 0. ! 93: * ! 94: * int ustat(int dev, struct ustat *buf) ! 95: * Before lcall instruction 4(%esp) contains buf (REVERSE order of argument) ! 96: * 8(%esp) contains dev, and 12(%esp) contains the value 0. ! 97: */ ! 98: ! 99: uutssys(arg1, arg2, func) ! 100: { ! 101: switch(func) { ! 102: case 0: return uname(arg1); ! 103: case 2: return u_ustat(arg2, arg1); ! 104: default:u.u_error = EINVAL; ! 105: } ! 106: } ! 107: ! 108: /* ! 109: * uname - get name of the current operating system. ! 110: */ ! 111: extern char version[]; /* Defined in main.c */ ! 112: extern char release[]; /* Defined in main.c */ ! 113: ! 114: uname(name) ! 115: struct utsname *name; ! 116: { ! 117: register char *rcp; /**/ ! 118: register int i; /* Counter, loop index */ ! 119: register INODE *ip; /* /etc/uucpname inode */ ! 120: BUF *bp; /* Read buffer */ ! 121: char namebuf[SYS_NMLN]; /* System name */ ! 122: int fl; /* File length*/ ! 123: ! 124: /* Check if *name is an available user area */ ! 125: if (!useracc((char *) name, sizeof(struct utsname))) { ! 126: u.u_error = EFAULT; ! 127: return(0); ! 128: } ! 129: /* Find the size of the version number */ ! 130: for (rcp = version, i = 0; *rcp != '\0' && i < SYS_NMLN; i++, rcp++) ! 131: ; ! 132: /* Write version number to user area */ ! 133: if (!kucopy(version, name->version, i)) ! 134: return(0); ! 135: /* Find the size of the release number */ ! 136: for (rcp = release, i = 0; *rcp != '\0' && i < SYS_NMLN; i++, rcp++) ! 137: ; ! 138: /* Write release number to user area */ ! 139: if (!kucopy(release, name->release, i)) ! 140: return; ! 141: /* Write "machine" to user area */ ! 142: if (!kucopy("i386", name->machine, 4)) ! 143: return; ! 144: /* We supposed that system name and nodename are in /etc/uucpname */ ! 145: if (ftoi("/etc/uucpname", 'r') != 0) ! 146: return(sys_unknown(name)); ! 147: ip = u.u_cdiri; ! 148: if ((fl = ip->i_size) == 0) { ! 149: idetach(ip); ! 150: return(sys_unknown(name)); ! 151: } ! 152: if (iaccess(ip, IPR) == 0) { ! 153: idetach(ip); ! 154: return; ! 155: } ! 156: if ((bp = vread(ip, (daddr_t) 0)) == NULL) { ! 157: brelease(bp); ! 158: idetach(ip); ! 159: return; ! 160: } ! 161: /* namebuf should be not more than SYS_NMLN - 1 characters long */ ! 162: fl = (fl > SYS_NMLN) ? SYS_NMLN : fl; ! 163: kkcopy(bp->b_vaddr, namebuf, fl); ! 164: brelease(bp); ! 165: idetach(ip); ! 166: ! 167: if (fl == 1 && namebuf[0] == '\n') ! 168: return(sys_unknown(name)); ! 169: for (rcp = namebuf, i = 0; i < fl; rcp++) { ! 170: i++; ! 171: if (*rcp == '\n') { ! 172: *rcp = '\0'; ! 173: break; ! 174: } ! 175: } ! 176: namebuf[i - 1] = '\0'; ! 177: /* Write system name to user area */ ! 178: if (!kucopy(namebuf, name->sysname, i)) ! 179: return(0); ! 180: ! 181: /* Write system name to user area */ ! 182: if (!kucopy(namebuf, name->nodename, i)) ! 183: return(0); ! 184: return 0; ! 185: } ! 186: ! 187: /* ! 188: * sys_unknown - write name unknown to utsname struct ! 189: */ ! 190: char unknown[] = "UNKNOWN"; ! 191: sys_unknown(name) ! 192: struct utsname *name; ! 193: { ! 194: if (!kucopy(unknown, name->sysname, sizeof(unknown))) ! 195: return; ! 196: if (!kucopy(unknown, name->nodename, sizeof(unknown))) ! 197: return; ! 198: } ! 199: ! 200: /* ! 201: * u_ustat - get file system statistics. (Name ustat in use for stat s.c.) ! 202: */ ! 203: u_ustat(dev, buf) ! 204: dev_t dev; ! 205: struct ustat *buf; ! 206: { ! 207: register MOUNT *mp; ! 208: ! 209: /* Check if buf is an available user area. */ ! 210: /* B_READ | B_WRITE is not implemented yet. */ ! 211: if (!useracc((char *) buf, sizeof(struct ustat))) { ! 212: u.u_error = EFAULT; ! 213: return; ! 214: } ! 215: ! 216: /* Take mount filesystem, check if dev is mounted device */ ! 217: for (mp = mountp; mp != NULL; mp = mp->m_next) ! 218: if (mp->m_dev == dev) ! 219: break; ! 220: if (mp == NULL) { ! 221: u.u_error = EINVAL; ! 222: return; ! 223: } ! 224: ! 225: /* Pickup information from superblock */ ! 226: /* Number of free blocks */ ! 227: if (!kucopy(&(mp->m_super.s_tfree), &(buf->f_tfree), ! 228: sizeof(mp->m_super.s_tfree))) ! 229: return; ! 230: /* Number of free inodes */ ! 231: if (!kucopy(&(mp->m_super.s_tinode), &(buf->f_tinode), ! 232: sizeof(mp->m_super.s_tinode))) ! 233: return; ! 234: /* File system name */ ! 235: if (!kucopy(mp->m_super.s_fname, buf->f_fname, ! 236: sizeof(mp->m_super.s_fname))) ! 237: return; ! 238: /* File system pack name */ ! 239: if (!kucopy(mp->m_super.s_fpack, buf->f_fpack, ! 240: sizeof(mp->m_super.s_fpack))) ! 241: return; ! 242: } ! 243: ! 244: umsgsys(func, arg1, arg2, arg3, arg4, arg5) ! 245: { ! 246: switch (func) { ! 247: case 0: return umsgget(arg1, arg2); ! 248: case 1: return umsgctl(arg1, arg2, arg3); ! 249: case 2: return umsgrcv(arg1, arg2, arg3, arg4, arg5); ! 250: case 3: return umsgsnd(arg1, arg2, arg3, arg4); ! 251: default:u.u_error = EINVAL; ! 252: } ! 253: } ! 254: ! 255: uulimit() ! 256: { ! 257: u.u_error = EINVAL; ! 258: } ! 259: ! 260: /* ! 261: * Remove a directory. ! 262: */ ! 263: urmdir(path) ! 264: char *path; ! 265: { ! 266: register INODE *ip; ! 267: int isdirempty(); ! 268: ! 269: if (ftoi(path, 'r') != 0) ! 270: return; ! 271: ip = u.u_cdiri; ! 272: ! 273: /* Check if path is a directory */ ! 274: if ((ip->i_mode & IFMT) != IFDIR) { ! 275: idetach(ip); ! 276: SET_U_ERROR(ENOTDIR, "rmdir: no such file or directory"); ! 277: return; ! 278: } ! 279: /* We have to check if directory is empty */ ! 280: if (!isdirempty(ip)) { ! 281: idetach(ip); ! 282: SET_U_ERROR(EEXIST, "rmdir: directory is not empty"); ! 283: return; ! 284: } ! 285: idetach(ip); ! 286: removedir(path); ! 287: return (u.u_error); ! 288: } ! 289: ! 290: /* ! 291: * remove a directory entry. ! 292: * path is a pointer to user area. ! 293: */ ! 294: removedir(path) ! 295: char *path; ! 296: { ! 297: char buf[512]; ! 298: char *cpbuf, /* to internal file_name buffer */ ! 299: *cppath; /* to user file_name buffer */ ! 300: ! 301: /* Write path to a kernel buffer buf */ ! 302: cpbuf = buf; ! 303: cppath = path; ! 304: ! 305: while ((*cpbuf = getubd(cppath)) != '\0') { ! 306: cppath++; ! 307: if (++cpbuf >= &buf[sizeof(buf) - 3]) { ! 308: SET_U_ERROR(ENOENT, "rmdir: path too long"); ! 309: return; ! 310: } ! 311: } ! 312: *cpbuf++ = '/'; ! 313: *cpbuf++ = '.'; ! 314: *cpbuf = '\0'; ! 315: u.u_io.io_seg = IOSYS; ! 316: dunlink(buf); ! 317: *cpbuf++ = '.'; ! 318: *cpbuf = '\0'; ! 319: dunlink(buf); ! 320: u.u_io.io_seg = IOUSR; ! 321: dunlink(path); ! 322: return; ! 323: } ! 324: ! 325: /* ! 326: * Unlink the given directory. ! 327: */ ! 328: dunlink(np) ! 329: char *np; ! 330: { ! 331: register INODE *ip; ! 332: register dev_t dev; ! 333: ! 334: if (ftoi(np, 'u') != 0) ! 335: return; ! 336: ! 337: ip = u.u_pdiri; ! 338: if (iaccess(ip, IPW) == 0) { ! 339: u.u_error = EACCES; ! 340: goto err; ! 341: } ! 342: ! 343: dev = ip->i_dev; ! 344: if (diucheck(dev, u.u_cdirn) == 0) ! 345: goto err; ! 346: idirent(0); ! 347: idetach(ip); ! 348: ! 349: if ((ip=iattach(dev, u.u_cdirn)) == NULL) ! 350: return; ! 351: ! 352: if (ip->i_nlink > 0) ! 353: --ip->i_nlink; ! 354: icrt(ip); /* unlink - ctime */ ! 355: ! 356: err: ! 357: idetach(ip); ! 358: return (0); ! 359: } ! 360: ! 361: /* ! 362: * This is a copy of iucheck. The only one difference is that that allows ! 363: * to remove a directory to a regular user. ! 364: */ ! 365: diucheck(dev, ino) ! 366: register dev_t dev; ! 367: register ino_t ino; ! 368: { ! 369: register INODE *ip; ! 370: INODE inode; ! 371: ! 372: for (ip=&inodep[NINODE-1]; ip>=inodep; --ip) { ! 373: if (ip->i_ino==ino && ip->i_dev==dev) ! 374: break; ! 375: } ! 376: if (ip < inodep) { ! 377: ip = &inode; ! 378: ip->i_dev = dev; ! 379: ip->i_ino = ino; ! 380: if (icopydm(ip) == 0) ! 381: return (0); ! 382: } ! 383: return (1); ! 384: } ! 385: ! 386: /* ! 387: * Check if directory is empty. ! 388: */ ! 389: int isdirempty(ip) ! 390: register INODE *ip; ! 391: { ! 392: register char *cp; ! 393: int count; ! 394: BUF *bp; ! 395: ! 396: for (count = 0; count < ip->i_size; count += 512) { ! 397: if ((bp = vread(ip, count)) == NULL) ! 398: break; ! 399: for (cp = (char *) bp->b_vaddr; ! 400: cp < (char *) bp->b_vaddr + BSIZE; cp += 16) { ! 401: if (*cp == '\0' && *(cp + 1) == '\0') ! 402: continue; ! 403: if (*(cp + 2) != '.') ! 404: goto bad; ! 405: if (*(cp + 3) == '\0') ! 406: continue; ! 407: if (*(cp + 3) != '.' || *(cp + 4) != '\0') ! 408: goto bad; ! 409: } ! 410: brelease(bp); ! 411: } ! 412: return 1; ! 413: bad: ! 414: brelease(bp); ! 415: return 0; ! 416: } ! 417: ! 418: /* ! 419: * SysV compatible mkdir() system call. ! 420: * ! 421: * Create a directory of the given "path" and "mode", if possible. ! 422: * Creating the directory is straight forward. Trying to clean ! 423: * up in case we run out of inodes or freee blocks in the process ! 424: * is not trivial. ! 425: * This system call was implemented in very press time. ! 426: * Vlad 6-04-92 ! 427: */ ! 428: umkdir(path, mode) ! 429: char *path; ! 430: int mode; ! 431: { ! 432: INODE *dmknod(); /* make directory node */ ! 433: register INODE *pip; /* parent inode pointer */ ! 434: register char *cp_path, ! 435: *cpb_path, ! 436: *cp_dot, ! 437: *cp_dotdot, ! 438: *cp_parent; ! 439: char bufpath[512], ! 440: bufdot[512], ! 441: bufdotdot[512], ! 442: bufparent[512]; ! 443: int uid; ! 444: int error; ! 445: /* ! 446: * Create a local copies of "path" which we can use to build up ! 447: * the required directory links: ! 448: * path/. -- bufdot ! 449: * path/..-- bufdotdot ! 450: * Verify that the given path is not too long. ! 451: */ ! 452: cp_path = path; ! 453: cpb_path = bufpath; ! 454: cp_dot = bufdot; ! 455: cp_dotdot = bufdotdot; ! 456: cp_parent = bufparent; ! 457: ! 458: while ((*cpb_path = getubd(cp_path)) != '\0') { ! 459: *cp_dot++ = *cp_dotdot++ = *cp_parent++ = *cpb_path; ! 460: ++cp_path; ! 461: if (++cpb_path >= &bufpath[sizeof(bufpath) - 3]) { ! 462: SET_U_ERROR(ENOENT, "sys5: mkdir: path too long"); ! 463: return; ! 464: } ! 465: } ! 466: while (--cp_parent >= bufparent) { ! 467: if (*cp_parent == '/') { ! 468: *++cp_parent = '\0'; ! 469: break; ! 470: } ! 471: } ! 472: if (cp_parent < bufparent) { ! 473: *++cp_parent = '.'; ! 474: *++cp_parent = '\0'; ! 475: } ! 476: ! 477: *cp_dotdot++ = *cp_dot++ = '/'; ! 478: *cp_dotdot++ = *cp_dot++ = '.'; ! 479: *cp_dotdot++ = '.'; ! 480: *cp_dotdot = *cp_dot = '\0'; ! 481: ! 482: u.u_io.io_seg = IOSYS; ! 483: ! 484: ! 485: u.u_io.io_seg = IOUSR; ! 486: if ((pip = dmknod(path, mode)) == NULL) { ! 487: return; ! 488: } ! 489: u.u_io.io_seg = IOSYS; ! 490: /* Now we can switch our id to root. It allows to use existing ! 491: * functions. ! 492: */ ! 493: uid = u.u_uid; ! 494: u.u_uid = 0; ! 495: ulink(bufpath, bufdot); ! 496: if (u.u_error) { ! 497: error = u.u_error; ! 498: u.u_error = 0; ! 499: uunlink(bufpath); ! 500: u.u_error = 0; ! 501: u.u_io.io_seg = IOUSR; ! 502: u.u_uid = uid; ! 503: u.u_error = error; ! 504: return; ! 505: } ! 506: ulink(bufparent, bufdotdot); ! 507: if (u.u_error) { ! 508: error = u.u_error; ! 509: u.u_error = 0; ! 510: uunlink(bufdot); ! 511: printf("unlink %s errno is %d\n", bufdot, u.u_error); ! 512: u.u_error = 0; ! 513: uunlink(bufpath); ! 514: printf("unlink %s errno is %d\n", bufpath, u.u_error); ! 515: u.u_uid = uid; ! 516: u.u_io.io_seg = IOUSR; ! 517: u.u_error = error; ! 518: return; ! 519: } ! 520: u.u_io.io_seg = IOUSR; ! 521: return(0); ! 522: } ! 523: ! 524: /* ! 525: * Create a directory. ! 526: * We cannot use original ulink because it makes the directories only for ! 527: * superuser. ! 528: */ ! 529: INODE *dmknod(np, mode) ! 530: char *np; /* Direcotory name */ ! 531: int mode; ! 532: { ! 533: register INODE *ip, *pip; ! 534: register int type; ! 535: ! 536: type = (mode & ~IFMT); ! 537: type |= S_IFDIR; ! 538: ! 539: if (ftoi(np, 'c') != 0) ! 540: return NULL; ! 541: ! 542: if ((ip=u.u_cdiri) != NULL) { ! 543: SET_U_ERROR(EEXIST, "sys5: path already exist") ! 544: idetach(ip); ! 545: return NULL; ! 546: } ! 547: if ((ip=imake(type, (dev_t) 0)) != NULL) ! 548: idetach(ip); ! 549: pip = u.u_pdiri; /* grab ptr to parent inode */ ! 550: return pip; ! 551: } ! 552: ! 553: /* ! 554: * Get directory entry in file system independent format. ! 555: */ ! 556: ugetdents(fd, bp, n) ! 557: int fd; /* File descriptor to an open directory */ ! 558: char *bp; /* Buffer where entries should be read */ ! 559: unsigned n; /* Number of bytes to be read */ ! 560: { ! 561: struct direct r_dir; ! 562: unsigned bytes; /* Number of bytes */ ! 563: struct dirent sd; ! 564: ino_t inode; /* Inode number */ ! 565: unsigned short ofnm; /* Offset to file name in dirent */ ! 566: char *cw, ! 567: *cr; ! 568: int minbuf; /* Minimum possible size of the bp */ ! 569: int i, mod; ! 570: int entry; ! 571: char ends[3] = ""; ! 572: int total = 0; ! 573: ! 574: cw = &bp[0]; ! 575: ! 576: ofnm = sizeof(sd.d_ino) + sizeof(sd.d_off) + sizeof(sd.d_reclen); ! 577: ! 578: /* Find minimum possible size of bp. It should be enough to contain the ! 579: * header of dirent, file name + '\0', and be on a sizeof(long) ! 580: * boundary. ! 581: */ ! 582: entry = ofnm + DIRSIZ + 1; ! 583: mod = entry % sizeof(long); ! 584: minbuf = entry + (mod ? sizeof(long) - mod : 0); ! 585: ! 586: /* Is user buffer available? */ ! 587: if (!useracc(bp, n) || n < minbuf) { ! 588: u.u_error = EFAULT; ! 589: return(0); ! 590: } ! 591: ! 592: while(n - (cw - bp) >= minbuf) { ! 593: /* Read next entry from the directory. ! 594: * inode == 0 for rm(ed) entries ! 595: */ ! 596: do { ! 597: if ((bytes = dirio(fd, &r_dir, sizeof(struct direct), ! 598: &sd.d_off)) == 0) { ! 599: return(total); ! 600: } ! 601: inode = r_dir.d_ino; ! 602: } while (!inode); ! 603: ! 604: /* Find the size of file name */ ! 605: for (cr = r_dir.d_name, i = 0; *cr != '\0' && i < DIRSIZ; ! 606: i++, cr++) ! 607: ; ! 608: ! 609: /* Copy file name */ ! 610: if (!kucopy(r_dir.d_name, cw + ofnm, i)) ! 611: return(0); ! 612: /* Write '\0' */ ! 613: putubd(cw + ofnm + i++, '\0'); ! 614: /* Round up to long boundary */ ! 615: if (mod = (ofnm + i) % sizeof(long)) ! 616: if (!kucopy(ends, cw + ofnm + i, sizeof(long) - mod)) ! 617: return(0); ! 618: sd.d_ino = r_dir.d_ino; ! 619: sd.d_reclen = ofnm + i; /* Size of directory entry */ ! 620: if (mod) ! 621: sd.d_reclen += sizeof(long) - mod; ! 622: if (!kucopy(&sd, cw, ofnm)) ! 623: return(0); ! 624: total += sd.d_reclen; ! 625: cw += sd.d_reclen; ! 626: } ! 627: return(total); ! 628: } ! 629: ! 630: /* ! 631: * Read `n' bytes from the directory `fd' using the buffer `bp'. ! 632: */ ! 633: dirio(fd, bp, n, offset) ! 634: struct direct *bp; ! 635: unsigned n; ! 636: off_t *offset; ! 637: { ! 638: register FD *fdp; ! 639: register INODE *ip; ! 640: ! 641: /* Check file descriptor */ ! 642: if ((fdp = fdget(fd)) == NULL) ! 643: return (0); ! 644: if (((fdp->f_flag & IPR)) == 0) { ! 645: u.u_error = EBADF; ! 646: return (0); ! 647: } ! 648: ip = fdp->f_ip; ! 649: if ((ip->i_mode & IFMT) != IFDIR) { ! 650: u.u_error = EBADF; ! 651: return(0); ! 652: } ! 653: ! 654: ilock(ip); /* We do not want file changes during the read */ ! 655: ! 656: u.u_io.io_seek = fdp->f_seek; ! 657: u.u_io.io.vbase = (vaddr_t) bp; ! 658: u.u_io.io_ioc = n; ! 659: u.u_io.io_flag = (fdp->f_flag & IPNDLY) ? IONDLY : 0; ! 660: ! 661: iread(ip, &u.u_io); ! 662: iacc(ip); /* read - atime */ ! 663: ! 664: n -= u.u_io.io_ioc; ! 665: *offset = fdp->f_seek; ! 666: fdp->f_seek += n; ! 667: ! 668: iunlock(ip); ! 669: ! 670: return (n); ! 671: } ! 672: ! 673: /* ! 674: * Get file system information by file name. ! 675: */ ! 676: ustatfs(path, stfs, len, fstyp) ! 677: char *path; /* File name */ ! 678: struct statfs *stfs; /* Pointer to a user structure */ ! 679: int len; /* Size of the structure */ ! 680: int fstyp; /* File system type */ ! 681: { ! 682: struct filsys *statmount(); /* Get mp for mounted device */ ! 683: struct filsys *statunmount(); /* Get mp for unmounted device */ ! 684: struct filsys *sb; /* Pointer to superblock */ ! 685: int count = 0; /* Number of copied bytes */ ! 686: short systype = 1; /* System type */ ! 687: long bsize = BSIZE; /* Block size */ ! 688: long frsize = 0; /* Fragment size */ ! 689: ! 690: /* Check if stfs is an available user area. */ ! 691: if (!useracc((char *) stfs, len)) { ! 692: u.u_error = EFAULT; ! 693: return; ! 694: } ! 695: ! 696: /* Filesystem type is 1 for 512 bytes blocks. */ ! 697: count += sizeof(systype); ! 698: if (count > len) ! 699: return; ! 700: if (!kucopy(&(systype), &(stfs->f_fstyp), sizeof(systype))) ! 701: return; ! 702: ! 703: /* Block size */ ! 704: count += sizeof(bsize); ! 705: if (count > len) ! 706: return; ! 707: if (!kucopy(&(bsize), &(stfs->f_bsize), sizeof(bsize))) ! 708: return; ! 709: ! 710: /* Fragment size. */ ! 711: count += sizeof(int); ! 712: if (count > len) ! 713: return; ! 714: if (!kucopy(&(frsize), &(stfs->f_frsize), sizeof(frsize))) ! 715: return; ! 716: ! 717: if (!fstyp) { ! 718: if ((sb = statmount(-1, path)) == NULL) ! 719: return; ! 720: devinfo(sb, stfs, len, &count); ! 721: } else { ! 722: if ((sb = statunmount(-1, path)) == NULL) ! 723: return; ! 724: devinfo(sb, stfs, len, &count); ! 725: kfree(sb); ! 726: } ! 727: return; ! 728: } ! 729: ! 730: /* ! 731: * statmount - get superblock for mounted file system. ! 732: * fd - file descriptor or -1, path - file name or NULL. ! 733: */ ! 734: struct filsys *statmount(fd, path) ! 735: int fd; ! 736: char *path; ! 737: { ! 738: register INODE *ip; /* Structure inode */ ! 739: register FD *fdp; ! 740: register MOUNT *mp; /* Pointer to device */ ! 741: dev_t device; /* Mounted device */ ! 742: ! 743: /* Find the device */ ! 744: if (path != NULL) { /* Find ip by file name */ ! 745: if (ftoi(path, 'r') != 0) ! 746: return NULL; ! 747: ip = u.u_cdiri; ! 748: device = ip->i_dev; ! 749: idetach(ip); ! 750: } else { /* Find ip by file descriptor */ ! 751: if ((fdp = fdget(fd)) == NULL) ! 752: return NULL; ! 753: if (((fdp->f_flag & IPR)) == 0) { ! 754: u.u_error = EBADF; ! 755: return NULL; ! 756: } ! 757: ip = fdp->f_ip; ! 758: device = ip->i_dev; ! 759: } ! 760: /* Take mount filesystem, check if dev is mounted device */ ! 761: for (mp = mountp; mp != NULL; mp = mp->m_next) ! 762: if (mp->m_dev == device) ! 763: break; ! 764: if (mp == NULL) { ! 765: u.u_error = EINVAL; ! 766: return NULL; ! 767: } ! 768: return &mp->m_super; ! 769: } ! 770: ! 771: /* ! 772: * devinfo() write system information to user area ! 773: */ ! 774: devinfo(sb, stfs, len, count) ! 775: struct filsys *sb; /* File name */ ! 776: struct statfs *stfs; /* Pointer to a user structure */ ! 777: int len; /* Size of the structure */ ! 778: int *count; ! 779: { ! 780: long inode; ! 781: ! 782: /* Total number of blocks */ ! 783: *count += sizeof(sb->s_fsize); ! 784: if (*count > len) ! 785: return; ! 786: if (!kucopy(&(sb->s_fsize), &(stfs->f_blocks), ! 787: sizeof(sb->s_fsize))) ! 788: return; ! 789: ! 790: /* Count of free blocks */ ! 791: *count += sizeof(sb->s_tfree); ! 792: if (*count > len) ! 793: return; ! 794: if (!kucopy(&(sb->s_tfree), &(stfs->f_bfree), ! 795: sizeof(sb->s_tfree))) ! 796: return; ! 797: ! 798: /* Total number of file inodes */ ! 799: *count += sizeof(inode); ! 800: if (*count > len) ! 801: return; ! 802: inode = (long) (sb->s_isize - INODEI) * INOPB; ! 803: if (!kucopy(&inode, &(stfs->f_files), sizeof(inode))) ! 804: return; ! 805: ! 806: /* Number of free inodes */ ! 807: *count += sizeof(inode); ! 808: if (*count > len) ! 809: return; ! 810: inode = sb->s_tinode; ! 811: if (!kucopy(&inode, &(stfs->f_ffree), sizeof(inode))) ! 812: return; ! 813: ! 814: /* Volume name */ ! 815: *count += sizeof(sb->s_fname); ! 816: if (*count > len) ! 817: return; ! 818: if (!kucopy(sb->s_fname, stfs->f_fname, ! 819: sizeof(sb->s_fpack))) ! 820: return; ! 821: ! 822: /* Pack name */ ! 823: *count += sizeof(sb->s_fpack); ! 824: if (*count > len) ! 825: return; ! 826: if (!kucopy(sb->s_fpack, stfs->f_fpack, ! 827: sizeof(sb->s_fpack))) ! 828: return; ! 829: } ! 830: ! 831: /* ! 832: * statunmount - get superblock for unmounted file system. ! 833: * fd - file descriptor or -1, path - file name or NULL. ! 834: */ ! 835: struct filsys *statunmount(fd, path) ! 836: int fd; /* File descriptor */ ! 837: char *path; /* File name */ ! 838: { ! 839: register INODE *ip; ! 840: register MOUNT *mp; ! 841: register dev_t rdev; ! 842: FD *fdp; ! 843: int mode; ! 844: BUF *bp; ! 845: struct filsys *sb; ! 846: ! 847: /* Find the device */ ! 848: if (path != NULL) { /* Find ip by file name */ ! 849: if (ftoi(path, 'r') != 0) ! 850: return NULL; ! 851: ip = u.u_cdiri; ! 852: mode = ip->i_mode; ! 853: rdev = ip->i_a.i_rdev; ! 854: idetach(ip); ! 855: } else { /* Find ip by file descriptor */ ! 856: if ((fdp = fdget(fd)) == NULL) ! 857: return NULL; ! 858: if (((fdp->f_flag & IPR)) == 0) { ! 859: u.u_error = EBADF; ! 860: return NULL; ! 861: } ! 862: ip = fdp->f_ip; ! 863: ilock(ip); ! 864: mode = ip->i_mode; ! 865: rdev = ip->i_a.i_rdev; ! 866: iunlock(ip); ! 867: } ! 868: ! 869: /* Check for block special device */ ! 870: if ((mode & IFMT) != IFBLK) { ! 871: u.u_error = ENOTBLK; ! 872: return NULL; ! 873: } ! 874: ! 875: /* Check if device is mounted device */ ! 876: for (mp = mountp; mp != NULL; mp = mp->m_next) { ! 877: if (mp->m_dev == rdev) { ! 878: u.u_error = EBUSY; ! 879: return NULL; ! 880: } ! 881: } ! 882: dopen(rdev, IPR, DFBLK); ! 883: if (u.u_error) ! 884: return NULL; ! 885: ! 886: if ((bp = bread(rdev, (daddr_t) SUPERI, 1)) == NULL) { ! 887: dclose(rdev); ! 888: return NULL; ! 889: } ! 890: dclose(rdev); ! 891: ! 892: if ((sb = kalloc(sizeof(struct filsys))) == NULL) ! 893: return (NULL); ! 894: ! 895: kkcopy(bp->b_vaddr, sb, sizeof(struct filsys)); ! 896: brelease(bp); ! 897: cansuper(sb); /* canonicalize supperblock */ ! 898: if (tstf(sb) == 0) { /* check for consistency */ ! 899: kfree(sb); ! 900: u.u_error = EINVAL; ! 901: return(NULL); ! 902: } ! 903: return(sb); ! 904: } ! 905: ! 906: /* ! 907: * Get file system information by file descriptor ! 908: */ ! 909: ufstatfs(fildes, stfs, len, fstyp) ! 910: int fildes; /* File descriptor */ ! 911: struct statfs *stfs; /* Pointer to a user structure */ ! 912: int len; /* Size of the structure */ ! 913: int fstyp; /* File system type */ ! 914: { ! 915: struct filsys *statmount(); /* Get mp for mounted device */ ! 916: struct filsys *statunmount(); /* Get mp for unmounted device */ ! 917: struct filsys *sb; /* Pointer to superblock */ ! 918: int count = 0; /* Number of copied bytes */ ! 919: short systype = 1; /* System type */ ! 920: long bsize = BSIZE; /* Block size */ ! 921: long frsize = 0; /* Fragment size */ ! 922: ! 923: /* Check if stfs is an available user area. */ ! 924: if (!useracc((char *) stfs, len)) { ! 925: u.u_error = EFAULT; ! 926: return; ! 927: } ! 928: ! 929: /* Filesystem type is 1 for 512 bytes blocks. */ ! 930: count += sizeof(systype); ! 931: if (count > len) ! 932: return; ! 933: if (!kucopy(&(systype), &(stfs->f_fstyp), sizeof(systype))) ! 934: return; ! 935: ! 936: /* Block size */ ! 937: count += sizeof(bsize); ! 938: if (count > len) ! 939: return; ! 940: if (!kucopy(&(bsize), &(stfs->f_bsize), sizeof(bsize))) ! 941: return; ! 942: ! 943: /* Fragment size. */ ! 944: count += sizeof(int); ! 945: if (count > len) ! 946: return; ! 947: if (!kucopy(&(frsize), &(stfs->f_frsize), sizeof(frsize))) ! 948: return; ! 949: ! 950: if (!fstyp) { ! 951: if ((sb = statmount(fildes, NULL)) == NULL) ! 952: return; ! 953: devinfo(sb, stfs, len, &count); ! 954: } else { ! 955: if ((sb = statunmount(fildes, NULL)) == NULL) ! 956: return; ! 957: devinfo(sb, stfs, len, &count); ! 958: kfree(sb); ! 959: } ! 960: return; ! 961: } ! 962: ! 963: /* ! 964: * Check superblock for consistency. ! 965: */ ! 966: tstf(fp) ! 967: register struct filsys *fp; ! 968: { ! 969: register daddr_t *dp; ! 970: register ino_t *ip; ! 971: register ino_t maxinode; ! 972: ! 973: maxinode = (fp->s_isize - INODEI) * INOPB + 1; ! 974: if (fp->s_isize >= fp->s_fsize) ! 975: return (0); ! 976: if (fp->s_tfree < fp->s_nfree ! 977: || fp->s_tfree >= fp->s_fsize - fp->s_isize + 1) ! 978: return (0); ! 979: if (fp->s_tinode < fp->s_ninode ! 980: || fp->s_tinode >= maxinode-1) ! 981: return (0); ! 982: for (dp = &fp->s_free[0]; dp < &fp->s_free[fp->s_nfree]; dp += 1) ! 983: if (*dp < fp->s_isize || *dp >= fp->s_fsize) ! 984: return (0); ! 985: for (ip = &fp->s_inode[0]; ip < &fp->s_inode[fp->s_ninode]; ip += 1) ! 986: if (*ip < 1 || *ip > maxinode) ! 987: return (0); ! 988: return (1); ! 989: } ! 990: ! 991: /* the following calls are not in the BCS */ ! 992: ! 993: uadmin() ! 994: { ! 995: u.u_error = EINVAL; ! 996: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.