![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to text.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / os|
Return to text.c CVS log | Up to [Research Unix] / researchv10no / sys / os |
1.1 root 1: #include "sys/param.h"
2: #include "sys/systm.h"
3: #include "sys/user.h"
4: #include "sys/proc.h"
5: #include "sys/text.h"
6: #include "sys/inode.h"
7: #include "sys/buf.h"
8: #include "sys/pte.h"
9: #include "sys/vm.h"
10: #include "sys/cmap.h"
11:
12: /*
13: * relinquish use of the shared text segment
14: * of a process.
15: */
16: xfree()
17: {
18: register struct text *xp, *xp1;
19: register struct inode *ip;
20:
21: if((xp=u.u_procp->p_textp) == NULL)
22: return;
23: xlock(xp);
24: ip = xp->x_iptr;
25: if(--xp->x_count==0) {
26: xunlink(u.u_procp);
27: xp->x_rssize -= vmemfree(tptopte(u.u_procp, 0), u.u_tsize);
28: if (xp->x_rssize != 0)
29: panic("xfree rssize");
30: for (xp1 = text; xp1 < textNTEXT; xp1++)
31: if (xp1->x_iptr == ip && xp1 != xp)
32: break;
33: if (xp1 >= textNTEXT)
34: ip->i_flag &= ~ITEXT;
35: if (ip->i_flag&ILOCK)
36: ip->i_count--;
37: else
38: iput(ip);
39: while (xp->x_poip)
40: sleep((caddr_t)&xp->x_poip, PSWP+1);
41: vsxfree(xp, xp->x_size);
42: xp->x_flag &= ~XLOCK;
43: xp->x_iptr = NULL;
44: } else {
45: xp->x_flag &= ~XLOCK;
46: xccdec(xp, u.u_procp);
47: }
48: u.u_procp->p_textp = NULL;
49: }
50:
51: /*
52: * Attach to a shared text segment.
53: * If there is no shared text, just return.
54: * If there is, hook up to it:
55: * if it is not currently being used, it has to be read
56: * in from the inode (ip); the written bit is set to force it
57: * to be written out as appropriate.
58: * If it is being used, but is not currently in core,
59: * a swap has to be done to get it back.
60: */
61: xalloc(ip, pagi)
62: register struct inode *ip;
63: {
64: register struct text *xp;
65: register clicks_t ts;
66: register struct text *xp1;
67: register struct proc *p = u.u_procp;
68:
69: if(u.u_exdata.ux_tsize == 0)
70: return;
71: again:
72: xp1 = NULL;
73: for (xp = text; xp < textNTEXT; xp++) {
74: if(xp->x_iptr == NULL) {
75: if (xp1 == NULL) {
76: xp1 = xp;
77: if (PTRACED(p))
78: break;
79: }
80: continue;
81: }
82: /* don't attach if proc is traced */
83: if (PTRACED(p))
84: continue;
85: if (xp->x_iptr==ip && (xp->x_flag&XTRC)==0 && xp->x_count!=0) {
86: if (xp->x_flag&XLOCK) {
87: xwait(xp);
88: goto again;
89: }
90: xlock(xp);
91: xp->x_count++;
92: p->p_textp = xp;
93: xlink(p);
94: xunlock(xp);
95: return;
96: }
97: }
98: if((xp=xp1) == NULL) {
99: tablefull("text");
100: psignal(p, SIGKILL);
101: return;
102: }
103: xp->x_flag = XLOAD|XLOCK;
104: if (PTRACED(p))
105: xp->x_flag |= XTRC; /* if proc is traced, so is text */
106: if (pagi)
107: xp->x_flag |= XPAGI;
108: ts = clrnd(btoc(u.u_exdata.ux_tsize));
109: xp->x_size = ts;
110: if (vsxalloc(xp) == NULL) {
111: swkill(p, "xalloc");
112: return;
113: }
114: xp->x_count = 1;
115: xp->x_ccount = 0;
116: xp->x_rssize = 0;
117: xp->x_iptr = ip;
118: ip->i_flag |= ITEXT;
119: ip->i_count++;
120: p->p_textp = xp;
121: xlink(p);
122: if (pagi == 0) {
123: u.u_count = u.u_exdata.ux_tsize;
124: if(u.u_exdata.ux_mag == 0413) /* 0413 on 4k file sys */
125: u.u_offset = ltoL(BSIZE(0));
126: else
127: u.u_offset = ltoL(sizeof(u.u_exdata));
128: u.u_base = 0;
129: u.u_segflg = SEGUINST;
130: settprot(1);
131: p->p_flag |= SKEEP;
132: readi(ip);
133: p->p_flag &= ~SKEEP;
134: }
135: settprot(0);
136: u.u_segflg = SEGUDATA;
137: xp->x_flag |= XWRIT;
138: xp->x_flag &= ~XLOAD;
139: xunlock(xp);
140: }
141:
142: /*
143: * Lock and unlock a text segment from swapping
144: */
145: xlock(xp)
146: register struct text *xp;
147: {
148:
149: while(xp->x_flag&XLOCK) {
150: xp->x_flag |= XWANT;
151: sleep((caddr_t)xp, PSWP);
152: }
153: xp->x_flag |= XLOCK;
154: }
155:
156: /*
157: * Wait for xp to be unlocked if it is currently locked.
158: */
159: xwait(xp)
160: register struct text *xp;
161: {
162:
163: xlock(xp);
164: xunlock(xp);
165: }
166:
167: xunlock(xp)
168: register struct text *xp;
169: {
170:
171: if (xp->x_flag&XWANT)
172: wakeup((caddr_t)xp);
173: xp->x_flag &= ~(XLOCK|XWANT);
174: }
175:
176: /*
177: * Decrement the in-core usage count of a shared text segment.
178: * When it drops to zero, free the core space.
179: */
180: xccdec(xp, p)
181: register struct text *xp;
182: register struct proc *p;
183: {
184:
185: if (xp==NULL || xp->x_ccount==0)
186: return;
187: xlock(xp);
188: if (--xp->x_ccount == 0) {
189: if (xp->x_flag & XWRIT) {
190: vsswap(p, tptopte(p, 0), CTEXT, 0, xp->x_size, (struct dmap *)0);
191: if (xp->x_flag & XPAGI)
192: swap(p, xp->x_ptdaddr, (caddr_t)tptopte(p, 0),
193: xp->x_size * sizeof (struct pte),
194: B_WRITE, B_PAGET, swapdev, 0);
195: xp->x_flag &= ~XWRIT;
196: } else
197: xp->x_rssize -= vmemfree(tptopte(p, 0), xp->x_size);
198: if (xp->x_rssize != 0)
199: panic("text rssize");
200: }
201: xunlink(p);
202: xunlock(xp);
203: }
204:
205: /*
206: * free the swap image of all unused saved-text text segments
207: * which are in the same filesystem as ip
208: * called when unmounting
209: */
210: xumount(ip)
211: register struct inode *ip;
212: {
213: register struct text *xp;
214:
215: for (xp = text; xp < textNTEXT; xp++)
216: if (xp->x_iptr!=NULL && ip->i_mpoint==xp->x_iptr->i_mpoint)
217: xuntext(xp);
218: }
219:
220: /*
221: * remove a shared text segment from the text table, if possible.
222: */
223: xrele(ip)
224: register struct inode *ip;
225: {
226: register struct text *xp;
227:
228: if ((ip->i_flag&ITEXT)==0)
229: return;
230: for (xp = text; xp < textNTEXT; xp++)
231: if (ip==xp->x_iptr)
232: xuntext(xp);
233: }
234:
235: /*
236: * remove text image from the text table.
237: * the use count must be zero.
238: */
239: xuntext(xp)
240: register struct text *xp;
241: {
242: register struct inode *ip;
243:
244: xlock(xp);
245: if (xp->x_count) {
246: xunlock(xp);
247: return;
248: }
249: ip = xp->x_iptr;
250: xp->x_flag &= ~XLOCK;
251: xp->x_iptr = NULL;
252: vsxfree(xp, xp->x_size);
253: ip->i_flag &= ~ITEXT;
254: if (ip->i_flag&ILOCK)
255: ip->i_count--;
256: else
257: iput(ip);
258: }
259:
260: /*
261: * Add a process to those sharing a text segment by
262: * getting the page tables and then linking to x_caddr.
263: */
264: xlink(p)
265: register struct proc *p;
266: {
267: register struct text *xp = p->p_textp;
268:
269: if (xp == 0)
270: return;
271: vinitpt(p);
272: p->p_xlink = xp->x_caddr;
273: xp->x_caddr = p;
274: xp->x_ccount++;
275: }
276:
277: xunlink(p)
278: register struct proc *p;
279: {
280: register struct text *xp = p->p_textp;
281: register struct proc *q;
282:
283: if (xp == 0)
284: return;
285: if (xp->x_caddr == p) {
286: xp->x_caddr = p->p_xlink;
287: p->p_xlink = 0;
288: return;
289: }
290: for (q = xp->x_caddr; q->p_xlink; q = q->p_xlink)
291: if (q->p_xlink == p) {
292: q->p_xlink = p->p_xlink;
293: p->p_xlink = 0;
294: return;
295: }
296: panic("lost text");
297: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.