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