![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 9.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to 9.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 root 1: /* vmmem.c */
2: typedef unsigned char u_char;
3: typedef unsigned short u_short;
4: typedef unsigned int u_int;
5: typedef unsigned long u_long;
6: typedef struct _physadr { int r[1]; } *physadr;
7: typedef int daddr_t;
8: typedef char * caddr_t;
9: typedef u_short ino_t;
10: typedef int swblk_t;
11: typedef int size_t;
12: typedef int time_t;
13: typedef int label_t[14];
14: typedef short dev_t;
15: typedef int off_t;
16: typedef long portid_t;
17: typedef struct fd_set { int fds_bits[1]; } fd_set;
18: int hz;
19: int timezone;
20: int dstflag;
21: char canonb[256 ];
22: extern char version[];
23: int lbolt;
24: time_t time;
25: time_t bootime;
26: long trannum;
27: int hand;
28: int nblkdev;
29: int nchrdev;
30: int nstream;
31: int nswdev;
32: int mpid;
33: char runin;
34: char runout;
35: int runrun;
36: char kmapwnt;
37: char curpri;
38: int maxmem;
39: int physmem;
40: int nswap;
41: int updlock;
42: daddr_t rablock;
43: extern int intstack[];
44: dev_t rootdev;
45: dev_t dumpdev;
46: long dumplo;
47: dev_t swapdev;
48: dev_t argdev;
49: dev_t pipedev;
50: extern int icode[];
51: extern int szicode;
52: dev_t getmdev();
53: daddr_t bmap();
54: caddr_t calloc();
55: unsigned max();
56: unsigned min();
57: int memall();
58: int uchar(), schar();
59: int vmemall();
60: char *wmemall();
61: swblk_t vtod();
62: extern struct sysent
63: {
64: int sy_narg;
65: int (*sy_call)();
66: } sysent[];
67: extern char vmmap[];
68: int umbabeg,umbaend;
69: int noproc;
70: extern int catcher[256];
71: char *panicstr;
72: int wantin;
73: int boothowto;
74: struct pte
75: {
76: unsigned int pg_pfnum:21,
77: :2,
78: pg_vreadm:1,
79: pg_swapm:1,
80: pg_fod:1,
81: pg_m:1,
82: pg_prot:4,
83: pg_v:1;
84: };
85: struct hpte
86: {
87: unsigned int pg_pfnum:21,
88: :2,
89: pg_high:9;
90: };
91: struct fpte
92: {
93: unsigned int pg_blkno:20,
94: pg_fileno:5,
95: pg_fod:1,
96: :1,
97: pg_prot:4,
98: pg_v:1;
99: };
100: struct pte *vtopte();
101: extern struct pte Sysmap[];
102: extern struct pte Usrptmap[];
103: extern struct pte usrpt[];
104: extern struct pte Swapmap[];
105: extern struct pte Forkmap[];
106: extern struct pte Xswapmap[];
107: extern struct pte Xswap2map[];
108: extern struct pte Pushmap[];
109: extern struct pte Vfmap[];
110: extern struct pte mmap[];
111: extern struct pte msgbufmap[];
112: extern struct pte camap[];
113: extern struct pte Nexmap[][16];
114: extern struct pte Prusrmap[];
115: struct cmap
116: {
117: unsigned int c_next:13,
118: c_prev:13,
119: c_lock:1,
120: c_want:1,
121: c_page:16,
122: c_hlink:13,
123: c_intrans:1,
124: c_free:1,
125: c_gone:1,
126: c_type:2,
127: c_blkno:20,
128: c_ndx:10,
129: c_mdev:6;
130: };
131: struct cmap *cmap;
132: struct cmap *ecmap;
133: int ncmap;
134: struct cmap *mfind();
135: int firstfree, maxfree;
136: int ecmx;
137: short cmhash[512 ];
138: struct direct
139: {
140: ino_t d_ino;
141: char d_name[14 ];
142: };
143: struct pcb
144: {
145: int pcb_ksp;
146: int pcb_esp;
147: int pcb_ssp;
148: int pcb_usp;
149: int pcb_r0;
150: int pcb_r1;
151: int pcb_r2;
152: int pcb_r3;
153: int pcb_r4;
154: int pcb_r5;
155: int pcb_r6;
156: int pcb_r7;
157: int pcb_r8;
158: int pcb_r9;
159: int pcb_r10;
160: int pcb_r11;
161: int pcb_r12;
162: int pcb_r13;
163: int pcb_pc;
164: int pcb_psl;
165: struct pte *pcb_p0br;
166: int pcb_p0lr;
167: struct pte *pcb_p1br;
168: int pcb_p1lr;
169: int pcb_szpt;
170: int pcb_cmap2;
171: int *pcb_sswap;
172: int pcb_sigc[3];
173: };
174: struct dmap
175: {
176: swblk_t dm_size;
177: swblk_t dm_alloc;
178: swblk_t dm_map[ 32 ];
179: };
180: struct dmap zdmap;
181: struct dblock
182: {
183: swblk_t db_base;
184: swblk_t db_size;
185: };
186: struct vtimes {
187: int vm_utime;
188: int vm_stime;
189:
190: unsigned vm_idsrss;
191: unsigned vm_ixrss;
192: int vm_maxrss;
193: int vm_majflt;
194: int vm_minflt;
195: int vm_nswap;
196: int vm_inblk;
197: int vm_oublk;
198: };
199: struct vtimes zvms;
200:
201:
202: struct user
203: {
204: struct pcb u_pcb;
205: int u_arg[5];
206: label_t u_qsav;
207: char u_segflg;
208: char u_error;
209: short u_uid;
210: short u_gid;
211: short u_ruid;
212: short u_rgid;
213: struct proc *u_procp;
214: int *u_ap;
215: union {
216: struct {
217: int R_val1;
218: int R_val2;
219: } u_rv;
220: off_t r_off;
221: time_t r_time;
222: } u_r;
223: caddr_t u_base;
224: unsigned int u_count;
225: off_t u_offset;
226: struct inode *u_cdir;
227: struct inode *u_rdir;
228: char u_dbuf[14 ];
229: caddr_t u_dirp;
230: struct direct u_dent;
231: struct inode *u_pdir;
232: struct file *u_ofile[20 ];
233: char u_pofile[20 ];
234: label_t u_ssav;
235: int (*u_signal[32])();
236: int u_code;
237: int *u_ar0;
238: struct uprof {
239: short *pr_base;
240: unsigned pr_size;
241: unsigned pr_off;
242: unsigned pr_scale;
243: } u_prof;
244: char u_eosys;
245: char u_sep;
246: dev_t u_ttydev;
247: ino_t u_ttyino;
248: union {
249: struct {
250: int Ux_mag;
251: unsigned Ux_tsize;
252: unsigned Ux_dsize;
253: unsigned Ux_bsize;
254: unsigned Ux_ssize;
255: unsigned Ux_entloc;
256: unsigned Ux_unused;
257: unsigned Ux_relflg;
258: } Ux_A;
259: char ux_shell[32];
260: } u_exdata;
261: char u_comm[14 ];
262: time_t u_start;
263: char u_acflag;
264: short u_fpflag;
265: short u_cmask;
266: size_t u_tsize;
267: size_t u_dsize;
268: size_t u_ssize;
269: struct vtimes u_vm;
270: struct vtimes u_cvm;
271: struct dmap u_dmap;
272: struct dmap u_smap;
273: struct dmap u_cdmap, u_csmap;
274: time_t u_outime;
275: size_t u_odsize, u_ossize;
276: size_t u_vrpages[20 ];
277: int u_limit[8];
278: int u_stack[1];
279:
280: };
281: extern struct user u;
282: extern struct user swaputl;
283: extern struct user forkutl;
284: extern struct user xswaputl;
285: extern struct user xswap2utl;
286: extern struct user pushutl;
287: extern struct user vfutl;
288: extern struct user prusrutl;
289: struct proc
290: {
291: struct proc *p_link;
292: struct proc *p_rlink;
293: struct pte *p_addr;
294: char p_usrpri;
295: char p_pri;
296: char p_cpu;
297: char p_stat;
298: char p_time;
299: char p_nice;
300: char p_slptime;
301: char p_cursig;
302: long p_sig;
303: long p_siga0;
304: long p_siga1;
305: int p_flag;
306: short p_uid;
307: short p_pgrp;
308: short p_pid;
309: short p_ppid;
310: short p_poip;
311: short p_szpt;
312: size_t p_tsize;
313: size_t p_dsize;
314: size_t p_ssize;
315: size_t p_rssize;
316: size_t p_maxrss;
317: size_t p_swrss;
318: swblk_t p_swaddr;
319: caddr_t p_wchan;
320: struct text *p_textp;
321: u_short p_clktim;
322: u_short p_tsleep;
323: struct pte *p_p0br;
324: struct proc *p_xlink;
325: short p_cpticks;
326: float p_pctcpu;
327: short p_ndx;
328: short p_idhash;
329: struct proc *p_pptr;
330: struct inode *p_trace;
331: };
332: short pidhash[ 63];
333: struct proc *pfind();
334: struct proc *proc, *procNPROC;
335: int nproc;
336: struct prochd {
337: struct proc *ph_link;
338: struct proc *ph_rlink;
339: } qs[32 ];
340: int whichqs;
341: struct xproc
342: {
343: struct proc *xp_link;
344: struct proc *xp_rlink;
345: struct pte *xp_addr;
346: char xp_usrpri;
347: char xp_pri;
348: char xp_cpu;
349: char xp_stat;
350: char xp_time;
351: char xp_nice;
352: char xp_slptime;
353: char p_cursig;
354: int xp_sig;
355: int xp_siga0;
356: int xp_siga1;
357: int xp_flag;
358: short xp_uid;
359: short xp_pgrp;
360: short xp_pid;
361: short xp_ppid;
362: short xp_xstat;
363: struct vtimes xp_vm;
364: };
365: struct text
366: {
367: swblk_t x_daddr[12 ];
368: swblk_t x_ptdaddr;
369: size_t x_size;
370: struct proc *x_caddr;
371: struct inode *x_iptr;
372: short x_rssize;
373: short x_swrss;
374: char x_count;
375: char x_ccount;
376: char x_flag;
377: char x_slptime;
378: short x_poip;
379: };
380: struct text *text, *textNTEXT;
381: int ntext;
382:
383:
384: int klseql;
385: int klsdist;
386: int klin;
387: int kltxt;
388: int klout;
389: struct vmmeter
390: {
391: unsigned v_swtch;
392: unsigned v_trap;
393: unsigned v_syscall;
394: unsigned v_intr;
395: unsigned v_pdma;
396: unsigned v_pswpin;
397: unsigned v_pswpout;
398: unsigned v_pgin;
399: unsigned v_pgout;
400: unsigned v_pgpgin;
401: unsigned v_pgpgout;
402: unsigned v_intrans;
403: unsigned v_pgrec;
404: unsigned v_xsfrec;
405: unsigned v_xifrec;
406: unsigned v_exfod;
407: unsigned v_zfod;
408: unsigned v_vrfod;
409: unsigned v_nexfod;
410: unsigned v_nzfod;
411: unsigned v_nvrfod;
412: unsigned v_pgfrec;
413: unsigned v_faults;
414: unsigned v_scan;
415: unsigned v_rev;
416: unsigned v_seqfree;
417: unsigned v_dfree;
418: unsigned v_swpin;
419: unsigned v_swpout;
420: };
421: struct vmmeter cnt, rate, sum;
422: struct vmtotal
423: {
424: short t_rq;
425: short t_dw;
426: short t_pw;
427: short t_sl;
428: short t_sw;
429: int t_vm;
430: int t_avm;
431: short t_rm;
432: short t_arm;
433: int t_vmtxt;
434: int t_avmtxt;
435: short t_rmtxt;
436: short t_armtxt;
437: short t_free;
438: };
439: struct vmtotal total;
440: int freemem;
441: int avefree;
442: int avefree30;
443: int deficit;
444: int nscan;
445: int multprog;
446: int desscan;
447: int maxpgio;
448: int maxslp;
449: int lotsfree;
450: int minfree;
451: int desfree;
452: int saferss;
453: struct forkstat
454: {
455: int cntfork;
456: int cntvfork;
457: int sizfork;
458: int sizvfork;
459: };
460: struct forkstat forkstat;
461: struct swptstat
462: {
463: int pteasy;
464: int ptexpand;
465: int ptshrink;
466: int ptpack;
467: };
468: struct swptstat swptstat;
469: struct file
470: {
471: short f_flag;
472: short f_count;
473: struct inode *f_inode;
474: off_t f_offset;
475: };
476: struct file *file, *fileNFILE;
477: int nfile;
478: struct file *getf();
479: struct file *falloc();
480: struct inode
481: {
482: short i_flag;
483: u_char i_count;
484: char i_fstyp;
485: dev_t i_dev;
486: long i_number;
487: unsigned short i_mode;
488: short i_nlink;
489: short i_uid;
490: short i_gid;
491: off_t i_size;
492: struct stdata *i_sptr;
493: union {
494: struct {
495: daddr_t I_addr[13];
496: daddr_t I_lastr;
497: } i_f;
498: struct {
499: daddr_t I_rdev;
500: long I_key;
501: } i_d;
502: struct {
503: long I_tag;
504: struct inode *I_cip;
505: } i_a;
506: struct {
507: struct proc *I_proc;
508: int I_sigmask;
509: } i_p;
510: } i_un;
511: short i_hlink;
512: };
513: struct inode *inode, *inodeNINODE;
514: int ninode;
515: struct inode *rootdir;
516: struct inode *ialloc();
517: struct inode *ifind();
518: struct inode *iget();
519: struct inode *owner();
520: struct inode *maknode();
521: struct inode *namei();
522: struct argnamei {
523: short flag;
524: ino_t ino;
525: dev_t idev;
526: short mode;
527: };
528: struct nx {
529: struct inode *dp;
530: char *cp;
531: struct buf *nbp;
532: int nlink;
533: };
534: struct bufhd
535: {
536: long b_flags;
537: struct buf *b_forw, *b_back;
538: };
539: struct buf
540: {
541: long b_flags;
542: struct buf *b_forw, *b_back;
543: struct buf *av_forw, *av_back;
544: long b_bcount;
545: short b_error;
546: dev_t b_dev;
547: union {
548: caddr_t b_addr;
549: int *b_words;
550: struct filsys *b_filsys;
551: struct dinode *b_dino;
552: daddr_t *b_daddr;
553: } b_un;
554: daddr_t b_blkno;
555: long b_resid;
556: struct proc *b_proc;
557: };
558: struct buf *buf;
559: char *buffers;
560: int nbuf;
561: struct buf *swbuf;
562: int nswbuf;
563: short *swsize;
564: int *swpf;
565: struct buf bfreelist[ 3 ];
566: struct buf bswlist;
567: struct buf *bclnlist;
568: struct buf *alloc();
569: struct buf *baddr();
570: struct buf *getblk();
571: struct buf *geteblk();
572: struct buf *bread();
573: struct buf *breada();
574: unsigned minphys();
575: struct mount
576: {
577: dev_t m_dev;
578: struct buf *m_bufp;
579: struct inode *m_inodp;
580: struct inode *m_idev;
581: int m_fstyp;
582: };
583: struct mount mount[62 ];
584:
585: struct map {
586: struct mapent *m_limit;
587: char *m_name;
588: };
589: struct mapent
590: {
591: int m_size;
592: int m_addr;
593: };
594: struct map *swapmap;
595: int nswapmap;
596: struct map *argmap;
597: struct map *kernelmap;
598: vmemall(pte, size, p, type)
599: register struct pte *pte;
600: int size;
601: struct proc *p;
602: {
603: register int m;
604: if (size <= 0 || size > maxmem)
605: panic("vmemall size");
606: while (size > 0) {
607: if (freemem < desfree)
608: wakeup((caddr_t)&proc[2]);
609: while (freemem == 0)
610: sleep((caddr_t)&freemem, 0+2);
611: m = imin(size, freemem);
612: (void) memall(pte, m, p, type);
613: size -= m;
614: pte += m;
615: }
616: if (freemem < desfree)
617: wakeup((caddr_t)&proc[2]);
618:
619: return (1);
620: }
621: vmemfree(pte, count)
622: register struct pte *pte;
623: register int count;
624: {
625: register struct cmap *c;
626: register struct pte *spte;
627: register int j;
628: int size, pcnt, fileno;
629: if (count % 2)
630: panic("vmemfree");
631: for (size = 0, pcnt = 0; count > 0; pte += 2, count -= 2) {
632: if (pte->pg_fod == 0 && pte->pg_pfnum) {
633: c = &cmap[ ((((pte->pg_pfnum)-firstfree) / 2) + 1)];
634: pcnt += 2;
635: if (c->c_lock && c->c_type != 0 ) {
636: for (j = 0; j < 2; j++)
637: *(int *)(pte+j) &= ( 0x78000000|0x00800000);
638: c->c_gone = 1;
639: goto free;
640: }
641: if (c->c_free) {
642: pcnt -= 2;
643: for (j = 0; j < 2; j++)
644: *(int *)(pte+j) &= ( 0x78000000|0x00800000);
645: if (c->c_type == 1 )
646: distpte(&text[c->c_ndx], (int)c->c_page, pte);
647: c->c_gone = 1;
648: goto free;
649: }
650: if (size == 0)
651: spte = pte;
652: size += 2;
653: continue;
654: }
655: if (pte->pg_fod) {
656: fileno = ((struct fpte *)pte)->pg_fileno;
657: if (fileno < 20 )
658: if ((u.u_vrpages[fileno] -= 2) <= 0)
659: if (u.u_vrpages[fileno] < 0)
660: panic("vmemfree vrpages");
661: for (j = 0; j < 2; j++)
662: *(int *)(pte+j) &= ( 0x78000000|0x00800000);
663: }
664: free:
665: if (size) {
666: memfree(spte, size, 1);
667: size = 0;
668: }
669: }
670: if (size)
671: memfree(spte, size, 1);
672: return (pcnt);
673: }
674: munlink(pf)
675: unsigned pf;
676: {
677: register int next, prev;
678: next = cmap[ ((((pf)-firstfree) / 2) + 1)].c_next;
679: prev = cmap[ ((((pf)-firstfree) / 2) + 1)].c_prev;
680: cmap[prev].c_next = next;
681: cmap[next].c_prev = prev;
682: cmap[ ((((pf)-firstfree) / 2) + 1)].c_free = 0;
683: if (freemem < minfree)
684: wakeup((caddr_t)&proc[2]);
685: freemem -= 2;
686: }
687: memall(pte, size, p, type)
688: register struct pte *pte;
689: int size;
690: struct proc *p;
691: {
692: register struct cmap *c;
693: register struct pte *rpte;
694: register struct proc *rp;
695: int i, j, next, curpos;
696: unsigned pf;
697: struct cmap *c1, *c2;
698: if (size % 2)
699: panic("memall");
700: if (size > freemem)
701: return (0);
702: ;
703: for (i = size; i > 0; i -= 2) {
704: curpos = cmap[0].c_next;
705: c = &cmap[curpos];
706: if (c->c_free == 0)
707: panic("dup mem alloc");
708: if ( ((((curpos)-1) * 2) + firstfree) > maxfree)
709: panic("bad mem alloc");
710: if (c->c_gone == 0 && c->c_type != 0 ) {
711: if (c->c_type == 1 )
712: rp = text[c->c_ndx].x_caddr;
713: else
714: rp = &proc[c->c_ndx];
715: while (rp->p_flag & 0x00004000 )
716: rp = rp->p_xlink;
717: switch (c->c_type) {
718: case 1 :
719: rpte = ((rp)->p_p0br + ( c->c_page));
720: break;
721: case 2 :
722: rpte = ((rp)->p_p0br + (rp)->p_tsize + ( c->c_page));
723: break;
724: case 3 :
725: rpte = (((rp)->p_p0br + (rp)->p_szpt* ( 512/(sizeof (struct pte))) - 8 - 1) - ( c->c_page));
726: break;
727: }
728: (rpte)[1]. pg_pfnum = (rpte)[0]. pg_pfnum = 0;
729: if (c->c_type == 1 )
730: distpte(&text[c->c_ndx], (int)c->c_page, rpte);
731: }
732: switch (type) {
733: case 0 :
734: c->c_ndx = p->p_ndx;
735: break;
736: case 1 :
737: c->c_page = ((int)( ptetov(p, pte)));
738: c->c_ndx = p->p_textp - &text[0];
739: break;
740: case 2 :
741: c->c_page = ((int)(( ptetov(p, pte)) - (p)->p_tsize));
742: c->c_ndx = p->p_ndx;
743: break;
744: case 3 :
745: c->c_page = ((int)( (((unsigned)((0x80000000-8 * 512))) >> 9 ) - 1 - ( ptetov(p, pte))));
746: c->c_ndx = p->p_ndx;
747: break;
748: }
749: if (c->c_blkno) {
750:
751: j = ((c->c_blkno)&(512 -1));
752: c1 = &cmap[cmhash[j]];
753: if (c1 == c)
754: cmhash[j] = c1->c_hlink;
755: else {
756: for (;;) {
757: if (c1 == ecmap)
758: panic("memall ecmap");
759: c2 = c1;
760: c1 = &cmap[c2->c_hlink];
761: if (c1 == c)
762: break;
763: }
764: c2->c_hlink = c1->c_hlink;
765: }
766: if (mfind(c->c_mdev == 15 ?
767: swapdev : mount[c->c_mdev].m_dev,
768: (daddr_t)c->c_blkno))
769: panic("memall mfind");
770: c1->c_mdev = 0;
771: c1->c_blkno = 0;
772: c1->c_hlink = 0;
773: }
774: pf = ((((curpos)-1) * 2) + firstfree);
775: for (j = 0; j < 2; j++)
776: *(int *)pte++ = pf++;
777: c->c_free = 0;
778: c->c_gone = 0;
779: if (c->c_intrans || c->c_want)
780: panic("memall intrans|want");
781: c->c_lock = 1;
782: c->c_type = type;
783: freemem -= 2;
784: next = c->c_next;
785: cmap[0].c_next = next;
786: cmap[next].c_prev = 0;
787: }
788: return (size);
789: }
790: memfree(pte, size, detach)
791: register struct pte *pte;
792: register int size;
793: {
794: register int i, j, prev, next;
795: register struct cmap *c;
796:
797: if (size % 2)
798: panic("memfree");
799: if (freemem < 2 * (32/2))
800: wakeup((caddr_t)&freemem);
801: while (size > 0) {
802: size -= 2;
803: i = pte->pg_pfnum;
804: if (i < firstfree || i > maxfree)
805: panic("bad mem free");
806: i = ((((i)-firstfree) / 2) + 1);
807: c = &cmap[i];
808: if (c->c_free)
809: panic("dup mem free");
810: if (detach && c->c_type != 0 ) {
811: for (j = 0; j < 2; j++)
812: *(int *)(pte+j) &= ( 0x78000000|0x00800000);
813: c->c_gone = 1;
814: }
815: if (detach && c->c_blkno == 0) {
816: next = cmap[0].c_next;
817: cmap[next].c_prev = i;
818: c->c_prev = 0;
819: c->c_next = next;
820: cmap[0].c_next = i;
821: } else {
822: prev = cmap[0].c_prev;
823: cmap[prev].c_next = i;
824: c->c_next = 0;
825: c->c_prev = prev;
826: cmap[0].c_prev = i;
827: }
828: c->c_free = 1;
829: freemem += 2;
830: pte += 2;
831: }
832: }
833: caddr_t
834: wmemall(pmemall, n)
835: int (*pmemall)(), n;
836: {
837: int npg;
838: caddr_t va;
839: register int a;
840: npg = ((((unsigned)(n)+511)>>9));
841: a = rmalloc(kernelmap, npg);
842: if (a == 0)
843: return (0);
844: if ((*pmemall)(&Usrptmap[a], npg, &proc[0], 0 ) == 0) {
845: rmfree(kernelmap, npg, a);
846: return (0);
847: }
848: va = (caddr_t) (usrpt + (a) * ( 512/(sizeof (struct pte))));
849: vmaccess(&Usrptmap[a], va, npg);
850: return (va);
851: }
852: wmemfree(va, n)
853: caddr_t va;
854: int n;
855: {
856: register int a;
857: int npg;
858: a = ((((struct pte *) va) - usrpt) / ( 512/(sizeof (struct pte))));
859: npg = ((((unsigned)(n)+511)>>9));
860: (void) memfree(&Usrptmap[a], npg, 0);
861: rmfree(kernelmap, npg, a);
862: }
863: mhash(c, dev, bn)
864: register struct cmap *c;
865: dev_t dev;
866: daddr_t bn;
867: {
868: register int i = ((bn)&(512 -1));
869: c->c_hlink = cmhash[i];
870: cmhash[i] = c - cmap;
871: c->c_blkno = bn;
872: i = getfsx(dev);
873: if (i == -1)
874: panic("mhash");
875: c->c_mdev = i;
876: }
877: munhash(dev, bn)
878: dev_t dev;
879: daddr_t bn;
880: {
881: register int i = ((bn)&(512 -1));
882: register struct cmap *c1, *c2;
883: c1 = &cmap[cmhash[i]];
884: if (c1 == ecmap)
885: panic("munhash");
886: if (c1->c_blkno == bn && getfsx(dev) == c1->c_mdev)
887: cmhash[i] = c1->c_hlink;
888: else {
889: for (;;) {
890: c2 = c1;
891: c1 = &cmap[c2->c_hlink];
892: if (c1 == ecmap)
893: panic("munhash");
894: if (c1->c_blkno == bn && getfsx(dev) == c1->c_mdev)
895: break;
896: }
897: c2->c_hlink = c1->c_hlink;
898: }
899: if (mfind(dev, bn))
900: panic("munhash mfind");
901: c1->c_mdev = 0;
902: c1->c_blkno = 0;
903: c1->c_hlink = 0;
904: }
905: struct cmap *
906: mfind(dev, bn)
907: dev_t dev;
908: daddr_t bn;
909: {
910: register struct cmap *c1 = &cmap[cmhash[ ((bn)&(512 -1))]];
911: while (c1 != ecmap) {
912: if (c1->c_blkno == bn && c1->c_mdev == getfsx(dev))
913: return (c1);
914: c1 = &cmap[c1->c_hlink];
915: }
916: return ((struct cmap *)0);
917: }
918: mpurge(mdev)
919: int mdev;
920: {
921: register struct cmap *c1, *c2;
922: register int i;
923: for (i = 0; i < 512 ; i++) {
924: more:
925: c1 = &cmap[cmhash[i]];
926: if (c1 == ecmap)
927: continue;
928: if (c1->c_mdev == mdev)
929: cmhash[i] = c1->c_hlink;
930: else {
931: for (;;) {
932: c2 = c1;
933: c1 = &cmap[c1->c_hlink];
934: if (c1 == ecmap)
935: goto cont;
936: if (c1->c_mdev == mdev)
937: break;
938: }
939: c2->c_hlink = c1->c_hlink;
940: }
941: c1->c_mdev = 0;
942: c1->c_blkno = 0;
943: c1->c_hlink = 0;
944: goto more;
945: cont:
946: ;
947: }
948: }
949: meminit(first, last)
950: int first, last;
951: {
952: register int i;
953: register struct cmap *c;
954: firstfree = (((first) + (2-1)) &~ (2-1));
955: maxfree = (((last - (2 - 1)) + (2-1)) &~ (2-1));
956: freemem = maxfree - firstfree;
957: ecmx = ecmap - cmap;
958: if (ecmx < freemem / 2)
959: freemem = ecmx * 2;
960: for (i = 1; i <= freemem / 2; i++) {
961: cmap[i-1].c_next = i;
962: c = &cmap[i];
963: c->c_prev = i-1;
964: c->c_free = 1;
965: c->c_gone = 1;
966: c->c_type = 0 ;
967: c->c_mdev = 0;
968: c->c_blkno = 0;
969: }
970: cmap[freemem / 2].c_next = 0;
971: for (i = 0; i < 512 ; i++)
972: cmhash[i] = ecmx;
973: cmap[0].c_prev = freemem / 2;
974: cmap[0].c_type = 0 ;
975: avefree = freemem;
976: hand = 0;
977: }
978: mwait(pf)
979: unsigned pf;
980: {
981: mlock(pf);
982: munlock(pf);
983: }
984: mlock(pf)
985: unsigned pf;
986: {
987: register struct cmap *c = &cmap[ ((((pf)-firstfree) / 2) + 1)];
988: while (c->c_lock) {
989: c->c_want = 1;
990: sleep((caddr_t)c, 0+1);
991: }
992: c->c_lock = 1;
993: }
994: munlock(pf)
995: unsigned pf;
996: {
997: register struct cmap *c = &cmap[ ((((pf)-firstfree) / 2) + 1)];
998: if (c->c_lock == 0)
999: panic("dup page unlock");
1000: if (c->c_want)
1001: wakeup((caddr_t)c);
1002: c->c_lock = 0;
1003: c->c_want = 0;
1004: }
1005: vslock(base, count)
1006: caddr_t base;
1007: {
1008: register unsigned v;
1009: register int npf;
1010: register struct pte *pte;
1011: u.u_procp->p_flag |= 0x00000200 ;
1012: v = (((unsigned)(base)) >> 9 );
1013: pte = vtopte(u.u_procp, v);
1014: npf = ((((unsigned)(count + ((int)base & (2* 512-1) ))+511)>>9));
1015: while (npf > 0) {
1016: if (pte->pg_v)
1017: mlock(pte->pg_pfnum);
1018: else
1019: if (fubyte((caddr_t) ((v)<<9)) < 0)
1020: panic("vslock");
1021: pte += 2;
1022: v += 2;
1023: npf -= 2;
1024: }
1025: u.u_procp->p_flag &= ~0x00000200 ;
1026: }
1027: vsunlock(base, count, rw)
1028: caddr_t base;
1029: {
1030: register struct pte *pte;
1031: register int npf;
1032: pte = vtopte(u.u_procp, (((unsigned)(base)) >> 9 ));
1033: npf = ((((unsigned)(count + ((int)base & (2* 512-1) ))+511)>>9));
1034: while (npf > 0) {
1035: munlock(pte->pg_pfnum);
1036: if (rw == 0x000001 )
1037: pte->pg_m = 1;
1038: pte += 2;
1039: npf -= 2;
1040: }
1041: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.