![[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 / b / STREAMS / coh.386|
Return to sys5.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 ! root 1: /* ! 2: * coh.386/sys5.c ! 3: * ! 4: * System calls introduced when going from COH 286 to COH 386. ! 5: * ! 6: * Revised: Mon Jul 12 12:27:55 1993 CDT ! 7: */ ! 8: #include <sys/coherent.h> ! 9: #include <sys/buf.h> ! 10: #include <sys/errno.h> ! 11: #include <canon.h> ! 12: #include <sys/con.h> ! 13: #include <fcntl.h> ! 14: #include <sys/fd.h> ! 15: #include <sys/filsys.h> ! 16: #include <sys/ino.h> ! 17: #include <sys/inode.h> ! 18: #include <sys/io.h> ! 19: #include <sys/mount.h> ! 20: #include <sys/stat.h> ! 21: #include <dirent.h> ! 22: #include <sys/utsname.h> ! 23: #include <sys/mount.h> ! 24: #include <ustat.h> ! 25: #include <sys/statfs.h> ! 26: #include <sys/sysi86.h> ! 27: #include <sys/file.h> ! 28: #include <ulimit.h> ! 29: ! 30: ! 31: utime(tp) ! 32: long *tp; ! 33: { ! 34: return timer.t_time; ! 35: } ! 36: ! 37: /* ! 38: * Return an unique number. ! 39: */ ! 40: usysi86(f, arg1) ! 41: { ! 42: register MOUNT *mp; ! 43: register struct filsys *fsp; ! 44: extern void (*ndpEmFn)(); ! 45: int fpval; ! 46: extern short ndpType; ! 47: ! 48: switch (f) { ! 49: case SYI86UNEEK: ! 50: if ((mp = getment (rootdev, 1)) == NULL) ! 51: return; ! 52: fsp = & mp->m_super; ! 53: fsp->s_fmod = 1; ! 54: return ++ fsp->s_unique; ! 55: ! 56: case SI86FPHW: ! 57: /* ! 58: * 2's bit: floating point ndp is present (80287/80387/80486dx) ! 59: * 1's bit (when 2's bit = 1): 80387/486dx is present ! 60: */ ! 61: ! 62: if (! useracc (arg1, sizeof (int), 1)) { ! 63: SET_U_ERROR (EFAULT, "sysi386:SI86FPHW"); ! 64: return; ! 65: } ! 66: if (ndpType <= 1) { /* no ndp */ ! 67: fpval = (ndpEmFn) ? FP_SW : FP_NO; ! 68: } else ! 69: fpval = (ndpType > 2) ? FP_387 : FP_287; ! 70: ! 71: putuwd (arg1, fpval); ! 72: return 0; ! 73: ! 74: } ! 75: } ! 76: ! 77: ushmsys(func, arg1, arg2, arg3) ! 78: int func, arg1, arg2, arg3; ! 79: { ! 80: switch(func){ ! 81: case 0: return ushmat(arg1, arg2, arg3); ! 82: case 1: return ushmctl(arg1, arg2, arg3); ! 83: case 2: return ushmdt(arg1); ! 84: case 3: return ushmget(arg1, arg2, arg3); ! 85: default: u.u_error = EINVAL; ! 86: } ! 87: } ! 88: ! 89: usemsys(func, arg1, arg2, arg3, arg4) ! 90: int func, arg1, arg2, arg3, arg4; ! 91: { ! 92: switch(func){ ! 93: case 0: return usemctl(arg1, arg2, arg3, arg4); ! 94: case 1: return usemget(arg1, arg2, arg3); ! 95: case 2: return usemop(arg1, arg2, arg3); ! 96: default: u.u_error = EINVAL; ! 97: } ! 98: } ! 99: ! 100: /* ! 101: * uname and ustat system calls. ! 102: * ! 103: * int uname(struct utsname *name) ! 104: * Before lcall instruction 4(%esp) contains name, 8(%esp) contains ! 105: * an unspecified value, and 12(%esp) contains the value 0. ! 106: * ! 107: * int ustat(int dev, struct ustat *buf) ! 108: * Before lcall instruction 4(%esp) contains buf (REVERSE order of argument) ! 109: * 8(%esp) contains dev, and 12(%esp) contains the value 2. ! 110: */ ! 111: ! 112: uutssys(arg1, arg2, func) ! 113: { ! 114: switch(func) { ! 115: case 0: return uname(arg1); ! 116: case 2: return u_ustat(arg2, arg1); ! 117: default:u.u_error = EINVAL; ! 118: } ! 119: } ! 120: ! 121: /* ! 122: * uname - get name of the current operating system. ! 123: */ ! 124: extern char version[]; /* Defined in main.c */ ! 125: extern char release[]; /* Defined in main.c */ ! 126: ! 127: uname(name) ! 128: struct utsname *name; ! 129: { ! 130: register char *rcp; /**/ ! 131: register int i; /* Counter, loop index */ ! 132: register INODE *ip; /* /etc/uucpname inode */ ! 133: BUF *bp; /* Read buffer */ ! 134: char namebuf[SYS_NMLN]; /* System name */ ! 135: int fl; /* File length*/ ! 136: ! 137: /* Check if *name is an available user area */ ! 138: if (! useracc ((char *) name, sizeof (struct utsname), 1)) { ! 139: u.u_error = EFAULT; ! 140: return 0; ! 141: } ! 142: /* Find the size of the version number */ ! 143: for (rcp = version, i = 0; *rcp != '\0' && i < SYS_NMLN; i++, rcp++) ! 144: /* DO NOTHING */ ; ! 145: ! 146: /* Write version number to user area */ ! 147: if (! kucopy (version, name->version, i)) ! 148: return 0; ! 149: ! 150: /* Find the size of the release number */ ! 151: for (rcp = release, i = 0 ; * rcp != '\0' && i < SYS_NMLN ; ! 152: i ++, rcp ++) ! 153: /* DO NOTHING */ ; ! 154: ! 155: /* Write release number to user area */ ! 156: if (! kucopy (release, name->release, i)) ! 157: return; ! 158: ! 159: /* Write "machine" to user area */ ! 160: if (! kucopy ("i386", name->machine, 4)) ! 161: return; ! 162: /* ! 163: * We supposed that system name and nodename are in /etc/uucpname ! 164: * NIGEL: Set the global io segment to IOSYS so that ftoi () will use ! 165: * the right method of getting at the argument passed to it. ! 166: */ ! 167: ! 168: { ! 169: IO io; ! 170: struct direct dir; ! 171: ! 172: io.io_seg = IOSYS; ! 173: if (ftoi ("/etc/uucpname", 'r', & io, & dir) != 0) ! 174: return sys_unknown (name); ! 175: } ! 176: ! 177: ip = u.u_cdiri; ! 178: if ((fl = ip->i_size) == 0) { ! 179: idetach (ip); ! 180: return sys_unknown (name); ! 181: } ! 182: ! 183: if (iaccess (ip, IPR) == 0) { ! 184: idetach (ip); ! 185: return; ! 186: } ! 187: if ((bp = vread (ip, (daddr_t) 0)) == NULL) { ! 188: brelease (bp); ! 189: idetach (ip); ! 190: return; ! 191: } ! 192: ! 193: /* namebuf should be not more than SYS_NMLN - 1 characters long */ ! 194: fl = fl > SYS_NMLN ? SYS_NMLN : fl; ! 195: memcpy (namebuf, bp->b_vaddr, fl); ! 196: ! 197: brelease (bp); ! 198: idetach (ip); ! 199: ! 200: if (fl == 1 && namebuf [0] == '\n') ! 201: return sys_unknown (name); ! 202: ! 203: for (rcp = namebuf, i = 0 ; i < fl ; rcp ++) { ! 204: i ++; ! 205: if (* rcp == '\n') { ! 206: * rcp = '\0'; ! 207: break; ! 208: } ! 209: } ! 210: namebuf[i - 1] = '\0'; ! 211: ! 212: /* Write system name to user area */ ! 213: if (! kucopy (namebuf, name->sysname, i)) ! 214: return 0; ! 215: ! 216: /* Write system name to user area */ ! 217: if (! kucopy (namebuf, name->nodename, i)) ! 218: return 0; ! 219: return 0; ! 220: } ! 221: ! 222: /* ! 223: * sys_unknown - write name unknown to utsname struct ! 224: */ ! 225: char unknown[] = "UNKNOWN"; ! 226: sys_unknown(name) ! 227: struct utsname *name; ! 228: { ! 229: if (! kucopy (unknown, name->sysname, sizeof (unknown))) ! 230: return; ! 231: if (! kucopy (unknown, name->nodename, sizeof (unknown))) ! 232: return; ! 233: } ! 234: ! 235: /* ! 236: * u_ustat - get file system statistics. (Name ustat in use for stat s.c.) ! 237: */ ! 238: ! 239: u_ustat(dev, buf) ! 240: dev_t dev; ! 241: struct ustat *buf; ! 242: { ! 243: register MOUNT *mp; ! 244: ! 245: /* Check if buf is an available user area. */ ! 246: /* B_READ | B_WRITE is not implemented yet. */ ! 247: if (! useracc ((char *) buf, sizeof (struct ustat), 1)) { ! 248: u.u_error = EFAULT; ! 249: return; ! 250: } ! 251: ! 252: /* Take mount filesystem, check if dev is mounted device */ ! 253: for (mp = mountp ; mp != NULL ; mp = mp->m_next) ! 254: if (mp->m_dev == dev) ! 255: break; ! 256: ! 257: if (mp == NULL) { ! 258: u.u_error = EINVAL; ! 259: return; ! 260: } ! 261: ! 262: /* Pickup information from superblock */ ! 263: /* Number of free blocks */ ! 264: if (! kucopy (& mp->m_super.s_tfree, & buf->f_tfree, ! 265: sizeof (mp->m_super.s_tfree))) ! 266: return; ! 267: ! 268: /* Number of free inodes */ ! 269: if (! kucopy (& mp->m_super.s_tinode, & buf->f_tinode, ! 270: sizeof (mp->m_super.s_tinode))) ! 271: return; ! 272: ! 273: /* File system name */ ! 274: if (! kucopy (mp->m_super.s_fname, buf->f_fname, ! 275: sizeof (mp->m_super.s_fname))) ! 276: return; ! 277: ! 278: /* File system pack name */ ! 279: if (! kucopy (mp->m_super.s_fpack, buf->f_fpack, ! 280: sizeof (mp->m_super.s_fpack))) ! 281: return; ! 282: } ! 283: ! 284: umsgsys(func, arg1, arg2, arg3, arg4, arg5) ! 285: { ! 286: switch (func) { ! 287: case 0: return umsgget (arg1, arg2); ! 288: case 1: return umsgctl (arg1, arg2, arg3); ! 289: case 2: return umsgrcv (arg1, arg2, arg3, arg4, arg5); ! 290: case 3: return umsgsnd (arg1, arg2, arg3, arg4); ! 291: default:u.u_error = EINVAL; ! 292: } ! 293: } ! 294: ! 295: /* Don't tell user process about last remaining 64k of RAM */ ! 296: #define BRK_CUSHION 16 ! 297: ! 298: uulimit(cmd, newlimit) ! 299: { ! 300: int freeClicks; ! 301: ! 302: switch (cmd) { ! 303: case UL_GETFSIZE: /* Get max # of 512-byte blocks per file. */ ! 304: return u.u_bpfmax; ! 305: break; ! 306: ! 307: case UL_SETFSIZE: /* Set max # of 512-byte blocks per file. */ ! 308: /* (only superuser may increase this) */ ! 309: if (newlimit <= u.u_bpfmax || super ()) { ! 310: u.u_bpfmax = newlimit; ! 311: return 0; ! 312: } ! 313: /* else super() will have set u.u_error to EPERM */ ! 314: break; ! 315: ! 316: case UL_GMEMLIM: /* Get max break value. */ ! 317: /* return (current brk value) + (amount of free space) */ ! 318: /* Don't report all free clicks - leave a cushion. */ ! 319: freeClicks = allocno () - BRK_CUSHION; ! 320: if (freeClicks < 0) ! 321: freeClicks = 0; ! 322: return u.u_segl [SIPDATA].sr_base + ! 323: SELF->p_segp [SIPDATA]->s_size + NBPC * freeClicks; ! 324: ! 325: case UL_GDESLIM: ! 326: /* Return configured number of open files per process. */ ! 327: return NOFILE; ! 328: break; ! 329: ! 330: default: ! 331: u.u_error = EINVAL; ! 332: } ! 333: } ! 334: ! 335: /* ! 336: * Change the size of a file. ! 337: */ ! 338: uchsize(fd, size) ! 339: int fd; ! 340: register long size; ! 341: { ! 342: FD *fdp; ! 343: register INODE *ip; ! 344: ! 345: if (size < 0) { ! 346: u.u_error = EINVAL; ! 347: return -1; ! 348: } ! 349: if ((fdp = fdget (fd))==NULL || (fdp->f_flag & IPW) == 0) { ! 350: u.u_error = EBADF; ! 351: return -1; ! 352: } ! 353: ! 354: ip = fdp->f_ip; ! 355: switch (ip->i_mode & IFMT) { ! 356: case IFREG: ! 357: if (size > (long) u.u_bpfmax * BSIZE) { ! 358: u.u_error = EFBIG; ! 359: return -1; ! 360: } ! 361: if (size == ip->i_size) ! 362: break; ! 363: ilock (ip); ! 364: if (size < ip->i_size) ! 365: blclear (ip, __DIVIDE_ROUNDUP (ip->i_size, BSIZE)); ! 366: ip->i_size = size; ! 367: imod (ip); ! 368: icrt (ip); ! 369: iunlock (ip); ! 370: break; ! 371: ! 372: case IFPIPE: ! 373: if (size > PIPSIZE) { ! 374: u.u_error = EFBIG; ! 375: return -1; ! 376: } ! 377: ! 378: ilock(ip); ! 379: ! 380: if (! ip->i_par && ! ip->i_psr) { ! 381: u.u_error = EPIPE; ! 382: sendsig (SIGPIPE, SELF); ! 383: iunlock (ip); ! 384: return -1; ! 385: } ! 386: ip->i_pwx += (size - ip->i_pnc); ! 387: if (size > ip->i_pnc) { ! 388: if (ip->i_pwx >= PIPSIZE) ! 389: ip->i_pwx -= PIPSIZE; ! 390: } else if (size < ip->i_pnc) { ! 391: if (ip->i_pwx < 0) ! 392: ip->i_pwx += PIPSIZE; ! 393: } ! 394: ! 395: ip->i_pnc = size; ! 396: imod (ip); ! 397: icrt (ip); ! 398: ! 399: if (size > 0) ! 400: pwake (ip, 2); /* 2==IFWFW, see pipe.c */ ! 401: if (size < PIPSIZE) ! 402: pwake (ip, 1); /* 1==IFWFR, see pipe.c */ ! 403: iunlock (ip); ! 404: break; ! 405: ! 406: default: ! 407: u.u_error = EBADF; ! 408: return -1; ! 409: } ! 410: return 0; ! 411: } ! 412: ! 413: /* ! 414: * Remove a directory. ! 415: */ ! 416: ! 417: urmdir(path) ! 418: char *path; ! 419: { ! 420: register INODE *ip; ! 421: int iPathLen; /* Size of the string */ ! 422: int isdirempty(); ! 423: extern int strUserAcc(); ! 424: IO io; ! 425: struct direct dir; ! 426: ! 427: /* Check if path points to a valid user buffer.*/ ! 428: if ((iPathLen = strUserAcc (path, 0)) < 0) { ! 429: u.u_error = EFAULT; ! 430: return; ! 431: } ! 432: ! 433: io.io_seg = IOUSR; ! 434: if (ftoi (path, 'r', & io, & dir) != 0) ! 435: return; ! 436: ! 437: ip = u.u_cdiri; ! 438: ! 439: /* Check if path is a directory */ ! 440: if ((ip->i_mode & IFMT) != IFDIR) { ! 441: SET_U_ERROR(ENOTDIR, "rmdir: no such directory"); ! 442: idetach (ip); ! 443: return; ! 444: } ! 445: ! 446: /* We have to check if directory is empty */ ! 447: if (! isdirempty (ip)) { ! 448: SET_U_ERROR (EEXIST, "rmdir: directory is not empty"); ! 449: idetach (ip); ! 450: return; ! 451: } ! 452: idetach (ip); ! 453: removedir (path, iPathLen); ! 454: return 0; ! 455: } ! 456: ! 457: /* ! 458: * Remove a directory. ! 459: * path is a pointer to user area. ! 460: */ ! 461: ! 462: removedir(path, iPathLen) ! 463: char *path; /* Directory name */ ! 464: int iPathLen; /* Path length */ ! 465: { ! 466: char *buf; ! 467: char *cpbuf, /* internal file_name buffer */ ! 468: *cppath; /* user file_name buffer */ ! 469: ! 470: /* ! 471: * Allocate kernel buffer. We need extra space for '/', '.', '..' ! 472: * and '\0' ! 473: */ ! 474: ! 475: if ((buf = kalloc (iPathLen + 4)) == NULL) { ! 476: SET_U_ERROR (ENOSPC, "rmdir: out of kernel space"); ! 477: return; ! 478: } ! 479: cpbuf = buf; ! 480: cppath = path; ! 481: ! 482: /* Copy path to the kernel buffer. */ ! 483: while ((* cpbuf = getubd (cppath)) != '\0') { ! 484: cppath ++; ! 485: cpbuf ++; ! 486: } ! 487: * cpbuf++ = '/'; ! 488: * cpbuf++ = '.'; ! 489: * cpbuf = '\0'; ! 490: ! 491: dunlink (buf); ! 492: if (u.u_error) { ! 493: kfree (buf); ! 494: return; ! 495: } ! 496: ! 497: * cpbuf ++ = '.'; ! 498: * cpbuf = '\0'; ! 499: ! 500: dunlink (buf); ! 501: if (u.u_error) { ! 502: /* We have to link '.' back here. */ ! 503: kfree (buf); ! 504: return; ! 505: } ! 506: ! 507: buf [iPathLen] = '\0'; ! 508: ! 509: dunlink (buf); ! 510: if (u.u_error) { ! 511: /* We have to link '.' and '..' back here. */ ! 512: kfree (buf); ! 513: return; ! 514: } ! 515: kfree(buf); ! 516: return; ! 517: } ! 518: ! 519: ! 520: /* ! 521: * Unlink the given directory. ! 522: */ ! 523: ! 524: dunlink (np) ! 525: char *np; ! 526: { ! 527: register INODE *ip; ! 528: register dev_t dev; ! 529: IO io; ! 530: struct direct dir; ! 531: ! 532: io.io_seg = IOSYS; ! 533: if (file_to_inode (np, 'u', 1, & io, & dir) != 0) ! 534: return; ! 535: ! 536: ip = u.u_pdiri; ! 537: if (iaccess (ip, IPW) == 0) ! 538: goto err; ! 539: ! 540: dev = ip->i_dev; ! 541: if (diucheck (dev, u.u_cdirn) == 0) ! 542: goto err; ! 543: ! 544: idirent (0, & io, & dir); ! 545: idetach (ip); ! 546: ! 547: if ((ip = iattach (dev, u.u_cdirn)) == NULL) ! 548: return; ! 549: ! 550: if (ip->i_nlink > 0) ! 551: -- ip->i_nlink; ! 552: icrt (ip); /* unlink - ctime */ ! 553: ! 554: err: ! 555: idetach (ip); ! 556: return; ! 557: } ! 558: ! 559: /* ! 560: * This is a copy of iucheck. The only one difference is that that allows ! 561: * to remove a directory to a regular user. ! 562: */ ! 563: ! 564: diucheck (dev, ino) ! 565: register dev_t dev; ! 566: register ino_t ino; ! 567: { ! 568: register INODE *ip; ! 569: INODE inode; ! 570: ! 571: for (ip = & inodep [NINODE - 1] ; ip >= inodep ; -- ip) { ! 572: if (ip->i_ino == ino && ip->i_dev == dev) ! 573: break; ! 574: } ! 575: ! 576: if (ip < inodep) { ! 577: ip = & inode; ! 578: ip->i_dev = dev; ! 579: ip->i_ino = ino; ! 580: if (icopydm (ip) == 0) ! 581: return 0; ! 582: } ! 583: return 1; ! 584: } ! 585: ! 586: /* ! 587: * Check if directory is empty. ! 588: */ ! 589: int isdirempty (ip) ! 590: register INODE *ip; ! 591: { ! 592: register char *cp; ! 593: int count; ! 594: BUF *bp; ! 595: ! 596: for (count = 0 ; count < ip->i_size ; count += 512) { ! 597: if ((bp = vread (ip, count)) == NULL) ! 598: break; ! 599: ! 600: for (cp = (char *) bp->b_vaddr ; ! 601: cp < (char *) bp->b_vaddr + BSIZE ; cp += 16) { ! 602: ! 603: if (cp == '\0' && cp [1] == '\0') ! 604: continue; ! 605: if (cp [2] != '.') ! 606: goto bad; ! 607: if (cp [3] == '\0') ! 608: continue; ! 609: if (cp [3] != '.' || cp [4] != '\0') ! 610: goto bad; ! 611: } ! 612: ! 613: brelease (bp); ! 614: } ! 615: return 1; ! 616: ! 617: bad: ! 618: brelease (bp); ! 619: return 0; ! 620: } ! 621: ! 622: /* ! 623: * SysV compatible mkdir() system call. ! 624: * ! 625: * Create a directory of the given "path" and "mode", if possible. ! 626: * Creating the directory is straight forward. Trying to clean ! 627: * up in case we run out of inodes or freee blocks in the process ! 628: * is not trivial. ! 629: * This system call was implemented in very press time. ! 630: * Vlad 6-04-92 ! 631: */ ! 632: ! 633: umkdir(path, mode) ! 634: char *path; ! 635: int mode; ! 636: { ! 637: INODE *dmknod(); /* make directory node */ ! 638: register INODE *pip; /* parent inode pointer */ ! 639: register char *cp_path, ! 640: *cpb_path, ! 641: *cp_dot, ! 642: *cp_dotdot, ! 643: *cp_parent; ! 644: char bufpath[512], ! 645: bufdot[512], ! 646: bufdotdot[512], ! 647: bufparent[512]; ! 648: int uid; ! 649: ! 650: /* Check if path points to a valid user buffer.*/ ! 651: if (strUserAcc (path, 0) < 0) { ! 652: u.u_error = EFAULT; ! 653: return; ! 654: } ! 655: ! 656: /* ! 657: * Create a local copies of "path" which we can use to build up ! 658: * the required directory links: ! 659: * path/. -- bufdot ! 660: * path/..-- bufdotdot ! 661: * Verify that the given path is not too long. ! 662: */ ! 663: cp_path = path; ! 664: cpb_path = bufpath; ! 665: cp_dot = bufdot; ! 666: cp_dotdot = bufdotdot; ! 667: cp_parent = bufparent; ! 668: ! 669: while ((* cpb_path = getubd (cp_path)) != '\0') { ! 670: * cp_dot ++ = * cp_dotdot ++ = * cp_parent ++ = * cpb_path; ! 671: ++ cp_path; ! 672: if (++ cpb_path >= & bufpath [sizeof (bufpath) - 3]) { ! 673: SET_U_ERROR (ENOENT, "sys5: mkdir: path too long"); ! 674: return; ! 675: } ! 676: } ! 677: ! 678: while (-- cp_parent >= bufparent) { ! 679: if (* cp_parent == '/') { ! 680: * ++ cp_parent = '\0'; ! 681: break; ! 682: } ! 683: } ! 684: ! 685: if (cp_parent < bufparent) { ! 686: * ++ cp_parent = '.'; ! 687: * ++ cp_parent = '\0'; ! 688: } ! 689: ! 690: * cp_dotdot ++ = * cp_dot++ = '/'; ! 691: * cp_dotdot ++ = * cp_dot++ = '.'; ! 692: * cp_dotdot ++ = '.'; ! 693: * cp_dotdot = * cp_dot = '\0'; ! 694: ! 695: if ((pip = dmknod (path, mode, IOUSR)) == NULL) ! 696: return; ! 697: ! 698: /* ! 699: * Now we can switch our id to root. It allows to use existing ! 700: * functions. ! 701: */ ! 702: ! 703: uid = u.u_uid; ! 704: u.u_uid = 0; ! 705: ! 706: do_link (bufpath, bufdot, IOSYS); ! 707: ! 708: if (u.u_error) { ! 709: u.u_error = do_unlink (bufpath, IOSYS); ! 710: ! 711: u.u_uid = uid; ! 712: return; ! 713: } ! 714: ! 715: do_link (bufparent, bufdotdot, IOSYS); ! 716: ! 717: if (u.u_error) { ! 718: u.u_error = do_unlink (bufdot, IOSYS); ! 719: u.u_error = do_unlink (bufpath, IOSYS); ! 720: } ! 721: ! 722: u.u_uid = uid; ! 723: return 0; ! 724: } ! 725: ! 726: ! 727: /* ! 728: * Create a directory. ! 729: * ! 730: * We cannot use original ulink because it makes the directories only ! 731: * for superuser. ! 732: */ ! 733: ! 734: INODE * ! 735: dmknod (np, mode, space) ! 736: char *np; /* Direcotory name */ ! 737: int mode; ! 738: int space; ! 739: { ! 740: register INODE *ip, *pip; ! 741: register int type; ! 742: IO io; ! 743: struct direct dir; ! 744: ! 745: type = (mode & ~IFMT); ! 746: type |= S_IFDIR; ! 747: ! 748: /* If ftoi returns nonzero, u.u_error has been set. */ ! 749: io.io_seg = space; ! 750: if (ftoi (np, 'c', & io, & dir) != 0) ! 751: return NULL; ! 752: ! 753: if ((ip = u.u_cdiri) != NULL) { ! 754: SET_U_ERROR (EEXIST, "dmknod: path already exists"); ! 755: idetach (ip); ! 756: return NULL; ! 757: } ! 758: if ((ip = imake (type, (dev_t) 0, & io, & dir)) != NULL) ! 759: idetach (ip); ! 760: pip = u.u_pdiri; /* grab ptr to parent inode */ ! 761: return pip; ! 762: } ! 763: ! 764: ! 765: /* ! 766: * Get directory entry in file system independent format. ! 767: */ ! 768: ! 769: ugetdents(fd, bp, n) ! 770: int fd; /* File descriptor to an open directory */ ! 771: char *bp; /* Buffer where entries should be read */ ! 772: unsigned n; /* Number of bytes to be read */ ! 773: { ! 774: struct direct r_dir; ! 775: unsigned bytes; /* Number of bytes */ ! 776: struct dirent sd; ! 777: ino_t inode; /* Inode number */ ! 778: unsigned short ofnm; /* Offset to file name in dirent */ ! 779: char *cw, ! 780: *cr; ! 781: int minbuf; /* Minimum possible size of the bp */ ! 782: int i, mod; ! 783: int entry; ! 784: char ends[3] = ""; ! 785: int total = 0; ! 786: ! 787: cw = bp; ! 788: ! 789: ofnm = sizeof (sd.d_ino) + sizeof (sd.d_off) + sizeof (sd.d_reclen); ! 790: ! 791: /* ! 792: * Find minimum possible size of bp. It should be enough to contain ! 793: * the header of dirent, file name + '\0', and be on a sizeof(long) ! 794: * boundary. ! 795: */ ! 796: ! 797: entry = ofnm + DIRSIZ + 1; ! 798: mod = entry % sizeof(long); ! 799: minbuf = entry + (mod ? sizeof(long) - mod : 0); ! 800: ! 801: /* Is user buffer available? */ ! 802: if (! useracc (bp, n, 1) || n < minbuf) { ! 803: u.u_error = EFAULT; ! 804: return 0; ! 805: } ! 806: ! 807: while(n - (cw - bp) >= minbuf) { ! 808: /* ! 809: * Read next entry from the directory. ! 810: * inode == 0 for rm(ed) entries ! 811: */ ! 812: ! 813: do { ! 814: if ((bytes = dirio (fd, & r_dir, ! 815: sizeof (struct direct), ! 816: & sd.d_off)) == 0) ! 817: return total; ! 818: ! 819: inode = r_dir.d_ino; ! 820: } while (! inode); ! 821: ! 822: /* Find the size of file name */ ! 823: for (cr = r_dir.d_name, i = 0 ; * cr != '\0' && i < DIRSIZ ; ! 824: i ++, cr ++) ! 825: /* DO NOTHING */ ; ! 826: ! 827: /* Copy file name */ ! 828: if (! kucopy (r_dir.d_name, cw + ofnm, i)) ! 829: return 0; ! 830: ! 831: /* Write '\0' */ ! 832: putubd (cw + ofnm + i ++, '\0'); ! 833: ! 834: /* Round up to long boundary */ ! 835: if (mod = (ofnm + i) % sizeof(long)) ! 836: if (! kucopy (ends, cw + ofnm + i, sizeof ! 837: (long) - mod)) ! 838: return 0; ! 839: ! 840: sd.d_ino = r_dir.d_ino; ! 841: sd.d_reclen = ofnm + i; /* Size of directory entry */ ! 842: if (mod) ! 843: sd.d_reclen += sizeof (long) - mod; ! 844: ! 845: if (! kucopy(& sd, cw, ofnm)) ! 846: return 0; ! 847: ! 848: total += sd.d_reclen; ! 849: cw += sd.d_reclen; ! 850: } ! 851: return total; ! 852: } ! 853: ! 854: /* ! 855: * Read `n' bytes from the directory `fd' using the buffer `bp'. ! 856: */ ! 857: ! 858: dirio(fd, bp, n, offset) ! 859: struct direct *bp; ! 860: unsigned n; ! 861: off_t *offset; ! 862: { ! 863: register FD *fdp; ! 864: register INODE *ip; ! 865: IO io; ! 866: ! 867: /* Check file descriptor */ ! 868: if ((fdp = fdget (fd)) == NULL) ! 869: return 0; ! 870: ! 871: if ((fdp->f_flag & IPR) == 0) { ! 872: u.u_error = EBADF; ! 873: return 0; ! 874: } ! 875: ! 876: ip = fdp->f_ip; ! 877: if ((ip->i_mode & IFMT) != IFDIR) { ! 878: u.u_error = EBADF; ! 879: return 0; ! 880: } ! 881: ! 882: ilock (ip); /* We do not want file changes during the read */ ! 883: ! 884: io.io_seg = IOSYS; ! 885: io.io_seek = fdp->f_seek; ! 886: io.io.vbase = bp; ! 887: io.io_ioc = n; ! 888: io.io_flag = 0; ! 889: ! 890: if ((fdp->f_flag & IPNDLY) != 0) ! 891: io.io_flag |= IONDLY; ! 892: ! 893: if ((fdp->f_flag & IPNONBLOCK) != 0) ! 894: io.io_flag |= IONONBLOCK; ! 895: ! 896: iread (ip, & io); ! 897: iacc (ip); /* read - atime */ ! 898: ! 899: n -= io.io_ioc; ! 900: * offset = fdp->f_seek; ! 901: fdp->f_seek += n; ! 902: ! 903: iunlock (ip); ! 904: return n; ! 905: } ! 906: ! 907: /* ! 908: * Get file system information by file name. ! 909: */ ! 910: ustatfs(path, stfs, len, fstyp) ! 911: char *path; /* File name */ ! 912: struct statfs *stfs; /* Pointer to a user structure */ ! 913: int len; /* Size of the structure */ ! 914: int fstyp; /* File system type */ ! 915: { ! 916: struct filsys *statmount(); /* Get mp for mounted device */ ! 917: struct filsys *statunmount(); /* Get mp for unmounted device */ ! 918: struct filsys *sb; /* Pointer to superblock */ ! 919: int count = 0; /* Number of copied bytes */ ! 920: short systype = 1; /* System type */ ! 921: long bsize = BSIZE; /* Block size */ ! 922: long frsize = 0; /* Fragment size */ ! 923: ! 924: /* Check if stfs is an available user area. */ ! 925: if (! useracc ((char *) stfs, len, 1)) { ! 926: SET_U_ERROR (EFAULT, "ustatfs 0"); ! 927: return; ! 928: } ! 929: ! 930: /* Filesystem type is 1 for 512 bytes blocks. */ ! 931: count += sizeof (systype); ! 932: if (count > len) { ! 933: SET_U_ERROR (EFAULT, "ustatfs 1"); ! 934: return; ! 935: } ! 936: if (! kucopy (& systype, & stfs->f_fstyp, sizeof (systype))) ! 937: return; ! 938: ! 939: /* Block size */ ! 940: count += sizeof (bsize); ! 941: if (count > len) { ! 942: SET_U_ERROR (EFAULT, "ustatfs 2"); ! 943: return; ! 944: } ! 945: if (! kucopy (& bsize, & stfs->f_bsize, sizeof (bsize))) ! 946: return; ! 947: ! 948: /* Fragment size. */ ! 949: count += sizeof (int); ! 950: if (count > len) { ! 951: SET_U_ERROR (EFAULT, "ustatfs 3"); ! 952: return; ! 953: } ! 954: if (! kucopy (& frsize, & stfs->f_frsize, sizeof (frsize))) ! 955: return; ! 956: ! 957: if (! fstyp) { ! 958: if ((sb = statmount (-1, path)) == NULL) ! 959: return; ! 960: devinfo (sb, stfs, len, & count); ! 961: } else { ! 962: if ((sb = statunmount (-1, path)) == NULL) ! 963: return; ! 964: devinfo (sb, stfs, len, & count); ! 965: kfree (sb); ! 966: } ! 967: return 0; ! 968: } ! 969: ! 970: /* ! 971: * statmount - get superblock for mounted file system. ! 972: * fd - file descriptor or -1, path - file name or NULL. ! 973: */ ! 974: struct filsys *statmount(fd, path) ! 975: int fd; ! 976: char *path; ! 977: { ! 978: register INODE *ip; /* Structure inode */ ! 979: register FD *fdp; ! 980: register MOUNT *mp; /* Pointer to device */ ! 981: dev_t device; /* Mounted device */ ! 982: ! 983: /* Find the device */ ! 984: if (path) { /* Find ip by file name */ ! 985: IO io; ! 986: struct direct dir; ! 987: ! 988: io.io_seg = IOUSR; ! 989: if (ftoi (path, 'r', & io, & dir)) { ! 990: /* If ftoi returned nonzero, it also set u.u_error. */ ! 991: return NULL; ! 992: } ! 993: ip = u.u_cdiri; ! 994: device = ip->i_dev; ! 995: idetach(ip); ! 996: } else { /* Find ip by file descriptor */ ! 997: if ((fdp = fdget (fd)) == NULL) ! 998: return NULL; ! 999: if ((fdp->f_flag & IPR) == 0) { ! 1000: SET_U_ERROR (EBADF, "statmount 1"); ! 1001: return NULL; ! 1002: } ! 1003: ip = fdp->f_ip; ! 1004: device = ip->i_dev; ! 1005: } ! 1006: ! 1007: /* Take mount filesystem, check if dev is mounted device */ ! 1008: for (mp = mountp; mp != NULL; mp = mp->m_next) ! 1009: if (mp->m_dev == device) ! 1010: break; ! 1011: ! 1012: if (mp == NULL) { ! 1013: u.u_error = EINVAL; ! 1014: return NULL; ! 1015: } ! 1016: return & mp->m_super; ! 1017: } ! 1018: ! 1019: /* ! 1020: * devinfo() write system information to user area ! 1021: */ ! 1022: devinfo(sb, stfs, len, count) ! 1023: struct filsys *sb; /* File name */ ! 1024: struct statfs *stfs; /* Pointer to a user structure */ ! 1025: int len; /* Size of the structure */ ! 1026: int *count; ! 1027: { ! 1028: long inode; ! 1029: ! 1030: /* Total number of blocks */ ! 1031: * count += sizeof (sb->s_fsize); ! 1032: if (* count > len) ! 1033: return; ! 1034: ! 1035: if (! kucopy (& sb->s_fsize, & stfs->f_blocks, sizeof (sb->s_fsize))) ! 1036: return; ! 1037: ! 1038: /* Count of free blocks */ ! 1039: * count += sizeof (sb->s_tfree); ! 1040: if (* count > len) ! 1041: return; ! 1042: if (! kucopy (& sb->s_tfree, & stfs->f_bfree, sizeof (sb->s_tfree))) ! 1043: return; ! 1044: ! 1045: /* Total number of file inodes */ ! 1046: * count += sizeof (inode); ! 1047: if (* count > len) ! 1048: return; ! 1049: ! 1050: inode = (long) (sb->s_isize - INODEI) * INOPB; ! 1051: if (! kucopy (& inode, & stfs->f_files, sizeof (inode))) ! 1052: return; ! 1053: ! 1054: /* Number of free inodes */ ! 1055: * count += sizeof(inode); ! 1056: if (* count > len) ! 1057: return; ! 1058: inode = sb->s_tinode; ! 1059: if (! kucopy (& inode, & stfs->f_ffree, sizeof (inode))) ! 1060: return; ! 1061: ! 1062: /* Volume name */ ! 1063: * count += sizeof (sb->s_fname); ! 1064: if (* count > len) ! 1065: return; ! 1066: if (! kucopy (sb->s_fname, stfs->f_fname, sizeof (sb->s_fpack))) ! 1067: return; ! 1068: ! 1069: /* Pack name */ ! 1070: * count += sizeof(sb->s_fpack); ! 1071: if (* count > len) ! 1072: return; ! 1073: if (! kucopy (sb->s_fpack, stfs->f_fpack, sizeof (sb->s_fpack))) ! 1074: return; ! 1075: } ! 1076: ! 1077: /* ! 1078: * statunmount - get superblock for unmounted file system. ! 1079: * fd - file descriptor or -1, path - file name or NULL. ! 1080: */ ! 1081: struct filsys *statunmount(fd, path) ! 1082: int fd; /* File descriptor */ ! 1083: char *path; /* File name */ ! 1084: { ! 1085: register INODE *ip; ! 1086: register MOUNT *mp; ! 1087: register dev_t rdev; ! 1088: FD *fdp; ! 1089: int mode; ! 1090: BUF *bp; ! 1091: struct filsys *sb; ! 1092: ! 1093: /* Find the device */ ! 1094: if (path) { /* Find ip by file name */ ! 1095: IO io; ! 1096: struct direct dir; ! 1097: ! 1098: if (ftoi (path, 'r', & io, & dir)) ! 1099: return NULL; ! 1100: ip = u.u_cdiri; ! 1101: mode = ip->i_mode; ! 1102: rdev = ip->i_a.i_rdev; ! 1103: idetach (ip); ! 1104: } else { /* Find ip by file descriptor */ ! 1105: if ((fdp = fdget(fd)) == NULL) ! 1106: return NULL; ! 1107: if ((fdp->f_flag & IPR) == 0) { ! 1108: u.u_error = EBADF; ! 1109: return NULL; ! 1110: } ! 1111: ip = fdp->f_ip; ! 1112: ilock (ip); ! 1113: mode = ip->i_mode; ! 1114: rdev = ip->i_a.i_rdev; ! 1115: iunlock (ip); ! 1116: } ! 1117: ! 1118: /* Check for block special device */ ! 1119: if ((mode & IFMT) != IFBLK) { ! 1120: u.u_error = ENOTBLK; ! 1121: return NULL; ! 1122: } ! 1123: ! 1124: /* Check if device is mounted device */ ! 1125: for (mp = mountp; mp != NULL; mp = mp->m_next) { ! 1126: if (mp->m_dev == rdev) { ! 1127: u.u_error = EBUSY; ! 1128: return NULL; ! 1129: } ! 1130: } ! 1131: ! 1132: dopen (rdev, IPR, DFBLK); ! 1133: if (u.u_error) ! 1134: return NULL; ! 1135: ! 1136: /* ! 1137: * NIGEL: Modified for new dclose (). ! 1138: */ ! 1139: ! 1140: bp = bread (rdev, (daddr_t) SUPERI, BUF_SYNC); ! 1141: dclose (rdev, IPR, DFBLK); ! 1142: ! 1143: if (bp == NULL) ! 1144: return NULL; ! 1145: ! 1146: if ((sb = kalloc (sizeof (struct filsys))) == NULL) ! 1147: return NULL; ! 1148: ! 1149: memcpy (sb, bp->b_vaddr, sizeof (struct filsys)); ! 1150: brelease (bp); ! 1151: ! 1152: cansuper (sb); /* canonicalize superblock */ ! 1153: if (tstf (sb) == 0) { /* check for consistency */ ! 1154: kfree (sb); ! 1155: u.u_error = EINVAL; ! 1156: return NULL; ! 1157: } ! 1158: return sb; ! 1159: } ! 1160: ! 1161: /* ! 1162: * Get file system information by file descriptor ! 1163: */ ! 1164: ufstatfs(fildes, stfs, len, fstyp) ! 1165: int fildes; /* File descriptor */ ! 1166: struct statfs *stfs; /* Pointer to a user structure */ ! 1167: int len; /* Size of the structure */ ! 1168: int fstyp; /* File system type */ ! 1169: { ! 1170: struct filsys *statmount(); /* Get mp for mounted device */ ! 1171: struct filsys *statunmount(); /* Get mp for unmounted device */ ! 1172: struct filsys *sb; /* Pointer to superblock */ ! 1173: int count = 0; /* Number of copied bytes */ ! 1174: short systype = 1; /* System type */ ! 1175: long bsize = BSIZE; /* Block size */ ! 1176: long frsize = 0; /* Fragment size */ ! 1177: ! 1178: /* Check if stfs is an available user area. */ ! 1179: if (! useracc ((char *) stfs, len)) { ! 1180: u.u_error = EFAULT; ! 1181: return; ! 1182: } ! 1183: ! 1184: /* Filesystem type is 1 for 512 bytes blocks. */ ! 1185: count += sizeof (systype); ! 1186: if (count > len) { ! 1187: SET_U_ERROR (EFAULT, "ufstatfs 0"); ! 1188: return; ! 1189: } ! 1190: if (! kucopy (& systype, & stfs->f_fstyp, sizeof (systype))) ! 1191: return; ! 1192: ! 1193: /* Block size */ ! 1194: count += sizeof (bsize); ! 1195: if (count > len) { ! 1196: SET_U_ERROR (EFAULT, "ufstatfs 1"); ! 1197: return; ! 1198: } ! 1199: if (! kucopy (& bsize, & stfs->f_bsize, sizeof (bsize))) ! 1200: return; ! 1201: ! 1202: /* Fragment size. */ ! 1203: count += sizeof (int); ! 1204: if (count > len) { ! 1205: SET_U_ERROR (EFAULT, "ufstatfs 2"); ! 1206: return; ! 1207: } ! 1208: if (! kucopy (& frsize, & stfs->f_frsize, sizeof (frsize))) ! 1209: return; ! 1210: ! 1211: if (! fstyp) { ! 1212: if ((sb = statmount (fildes, NULL)) == NULL) ! 1213: return; ! 1214: devinfo (sb, stfs, len, & count); ! 1215: } else { ! 1216: if ((sb = statunmount (fildes, NULL)) == NULL) ! 1217: return; ! 1218: devinfo (sb, stfs, len, & count); ! 1219: kfree (sb); ! 1220: } ! 1221: return 0; ! 1222: } ! 1223: ! 1224: /* ! 1225: * Check superblock for consistency. ! 1226: */ ! 1227: ! 1228: tstf(fp) ! 1229: register struct filsys *fp; ! 1230: { ! 1231: register daddr_t *dp; ! 1232: register ino_t *ip; ! 1233: register ino_t maxinode; ! 1234: ! 1235: maxinode = (fp->s_isize - INODEI) * INOPB + 1; ! 1236: if (fp->s_isize >= fp->s_fsize) ! 1237: return 0; ! 1238: if (fp->s_tfree < fp->s_nfree || ! 1239: fp->s_tfree >= fp->s_fsize - fp->s_isize + 1) ! 1240: return 0; ! 1241: if (fp->s_tinode < fp->s_ninode || fp->s_tinode >= maxinode - 1) ! 1242: return 0; ! 1243: ! 1244: for (dp = fp->s_free ; dp < fp->s_free + fp->s_nfree ; dp += 1) ! 1245: if (* dp < fp->s_isize || * dp >= fp->s_fsize) ! 1246: return 0; ! 1247: ! 1248: for (ip = fp->s_inode ; ip < fp->s_inode + fp->s_ninode ; ip += 1) ! 1249: if (* ip < 1 || * ip > maxinode) ! 1250: return 0; ! 1251: return 1; ! 1252: } ! 1253: ! 1254: /* the following calls are not in the BCS */ ! 1255: ! 1256: uadmin() ! 1257: { ! 1258: u.u_error = EINVAL; ! 1259: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.