![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vm_text.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to vm_text.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)vm_text.c 7.9 (Berkeley) 6/28/90
21: */
22:
23: #include "param.h"
24: #include "systm.h"
25: #include "user.h"
26: #include "proc.h"
27: #include "text.h"
28: #include "vnode.h"
29: #include "buf.h"
30: #include "seg.h"
31: #include "cmap.h"
32: #include "uio.h"
33: #include "exec.h"
34: #include "vm.h"
35:
36: #include "machine/pte.h"
37: #include "machine/cpu.h"
38:
39: #define X_LOCK(xp) { \
40: while ((xp)->x_flag & XLOCK) { \
41: (xp)->x_flag |= XWANT; \
42: sleep((caddr_t)(xp), PSWP); \
43: } \
44: (xp)->x_flag |= XLOCK; \
45: }
46: #define XUNLOCK(xp) { \
47: if ((xp)->x_flag & XWANT) \
48: wakeup((caddr_t)(xp)); \
49: (xp)->x_flag &= ~(XLOCK|XWANT); \
50: }
51: #define FREE_AT_HEAD(xp) { \
52: (xp)->x_forw = xhead; \
53: xhead = (xp); \
54: (xp)->x_back = &xhead; \
55: if (xtail == &xhead) \
56: xtail = &(xp)->x_forw; \
57: else \
58: (xp)->x_forw->x_back = &(xp)->x_forw; \
59: }
60: #define FREE_AT_TAIL(xp) { \
61: (xp)->x_back = xtail; \
62: *xtail = (xp); \
63: xtail = &(xp)->x_forw; \
64: /* x_forw is NULL */ \
65: }
66: #define ALLOC(xp) { \
67: *((xp)->x_back) = (xp)->x_forw; \
68: if ((xp)->x_forw) \
69: (xp)->x_forw->x_back = (xp)->x_back; \
70: else \
71: xtail = (xp)->x_back; \
72: (xp)->x_forw = NULL; \
73: (xp)->x_back = NULL; \
74: }
75:
76: /*
77: * The text-cache:
78: *
79: * We place up to ``maxtextcache'' free text table entries on a free list
80: * to form an LRU cache. This causes the swap (but not RAM) resources to
81: * be saved. These text images are treated as "sticky", and are placed on
82: * the free list when unused. They may be reclaimed from the free list
83: * until reused. The cache changes to MRU once the maximum limit is
84: * reached since we just cease caching new texts rather than replacing
85: * the LRU one (should be fixed). All cached text resources may be
86: * reclaimed by calling xpurge(). Currently, swpexpand() and xalloc() do
87: * this if an attempted swap allocation fails.
88: *
89: * Note that although true "sticky" texts are handling in the same way,
90: * they are not considered part of the cache; i.e. they are not subject
91: * to the maximum limit nor are they purged with xpurge(). They are in
92: * a sense "locked down" cache entries.
93: */
94: struct text *xhead, **xtail; /* text table free list */
95: int xcache; /* number of "sticky" texts retained */
96: int maxtextcache = -1; /* maximum number of "sticky" texts */
97: struct xstats xstats; /* cache statistics */
98:
99: /*
100: * initialize text table
101: */
102: xinit()
103: {
104: register struct text *xp;
105:
106: xtail = &xhead;
107: for (xp = text; xp < textNTEXT; xp++)
108: FREE_AT_TAIL(xp);
109: if (maxtextcache == -1)
110: maxtextcache = ntext;
111: }
112:
113: /*
114: * relinquish use of the shared text segment
115: * of a process.
116: */
117: xfree()
118: {
119: register struct text *xp;
120: register struct vnode *vp;
121: struct vattr vattr;
122:
123: if ((xp = u.u_procp->p_textp) == NULL)
124: return;
125: xstats.free++;
126: X_LOCK(xp);
127: vp = xp->x_vptr;
128: if (--xp->x_count == 0 &&
129: (VOP_GETATTR(vp, &vattr, u.u_cred) != 0 ||
130: (vattr.va_mode & VSVTX) == 0)) {
131: if (xcache >= maxtextcache || xp->x_flag & XTRC ||
132: vattr.va_nlink == 0) { /* XXX */
133: xp->x_rssize -= vmemfree(tptopte(u.u_procp, 0),
134: (int)u.u_tsize);
135: if (xp->x_rssize != 0)
136: panic("xfree rssize");
137: while (xp->x_poip)
138: sleep((caddr_t)&xp->x_poip, PSWP+1);
139: xp->x_flag &= ~XLOCK;
140: xuntext(xp);
141: FREE_AT_HEAD(xp);
142: } else {
143: if (xp->x_flag & XWRIT) {
144: xstats.free_cacheswap++;
145: xp->x_flag |= XUNUSED;
146: }
147: xcache++;
148: xstats.free_cache++;
149: xp->x_flag |= XCACHED;
150: xccdec(xp, u.u_procp);
151: #if defined(tahoe)
152: xp->x_ckey = 0;
153: #endif
154: FREE_AT_TAIL(xp);
155: }
156: } else {
157: #if defined(tahoe)
158: if (xp->x_count == 0)
159: xp->x_ckey = 0;
160: #endif
161: xccdec(xp, u.u_procp);
162: xstats.free_inuse++;
163: }
164: xunlink(u.u_procp);
165: XUNLOCK(xp);
166: u.u_procp->p_textp = NULL;
167: }
168:
169: /*
170: * Attach to a shared text segment.
171: * If there is no shared text, just return.
172: * If there is, hook up to it:
173: * if it is not currently being used, it has to be read
174: * in from the vnode (vp); the written bit is set to force it
175: * to be written out as appropriate.
176: * If it is being used, but is not currently in core,
177: * a swap has to be done to get it back.
178: */
179: xalloc(vp, ep, toff, cred)
180: register struct vnode *vp;
181: struct exec *ep;
182: off_t toff;
183: struct ucred *cred;
184: {
185: register struct text *xp;
186: register struct proc *p;
187:
188: if (ep->a_text == 0)
189: return;
190: xstats.alloc++;
191: p = u.u_procp;
192: while ((xp = vp->v_text) != NULL) {
193: if (xp->x_flag&XLOCK) {
194: /*
195: * Wait for text to be unlocked,
196: * then start over (may have changed state).
197: */
198: xwait(xp);
199: continue;
200: }
201: X_LOCK(xp);
202: if (xp->x_flag & XCACHED) {
203: xstats.alloc_cachehit++;
204: ALLOC(xp);
205: xp->x_flag &= ~(XCACHED|XUNUSED);
206: xcache--;
207: } else
208: xstats.alloc_inuse++;
209: xp->x_count++;
210: p->p_textp = xp;
211: xlink(p);
212: XUNLOCK(xp);
213: #if defined(tahoe)
214: ckeyrelease(p->p_ckey);
215: if (ckey_cnt[xp->x_ckey])
216: ckey_cnt[xp->x_ckey]++;
217: else /* dead key */
218: xp->x_ckey = getcodekey();
219: p->p_ckey = xp->x_ckey;
220: #endif
221: return;
222: }
223: xp = xhead;
224: if (xp == NULL) {
225: tablefull("text");
226: psignal(p, SIGKILL);
227: return;
228: }
229: ALLOC(xp);
230: if (xp->x_vptr)
231: xuntext(xp);
232: xp->x_flag = XLOAD|XLOCK;
233: if (p->p_flag & SPAGV)
234: xp->x_flag |= XPAGV;
235: xp->x_size = clrnd(btoc(ep->a_text));
236: if (vsxalloc(xp) == NULL) {
237: /* flush text cache and try again */
238: if (xpurge() == 0 || vsxalloc(xp) == NULL) {
239: swkill(p, "xalloc: no swap space");
240: return;
241: }
242: }
243: xp->x_count = 1;
244: xp->x_ccount = 0;
245: xp->x_rssize = 0;
246: xp->x_mtime = 0;
247: xp->x_vptr = vp;
248: vp->v_flag |= VTEXT;
249: vp->v_text = xp;
250: VREF(vp);
251: p->p_textp = xp;
252: xlink(p);
253: if ((p->p_flag & SPAGV) == 0) {
254: settprot(RW);
255: p->p_flag |= SKEEP;
256: (void) vn_rdwr(UIO_READ, vp,
257: (caddr_t)ctob(tptov(p, 0)),
258: (int)ep->a_text, toff,
259: UIO_USERSPACE, (IO_UNIT|IO_NODELOCKED), cred, (int *)0);
260: p->p_flag &= ~SKEEP;
261: }
262: settprot(RO);
263: #if defined(tahoe)
264: ckeyrelease(p->p_ckey);
265: xp->x_ckey = getcodekey();
266: p->p_ckey = xp->x_ckey;
267: #endif
268: xp->x_flag |= XWRIT;
269: xp->x_flag &= ~XLOAD;
270: XUNLOCK(xp);
271: }
272:
273: /*
274: * Lock and unlock a text segment from swapping
275: */
276: xlock(xp)
277: register struct text *xp;
278: {
279:
280: X_LOCK(xp);
281: }
282:
283: /*
284: * Wait for xp to be unlocked if it is currently locked.
285: */
286: xwait(xp)
287: register struct text *xp;
288: {
289:
290: X_LOCK(xp);
291: XUNLOCK(xp);
292: }
293:
294: xunlock(xp)
295: register struct text *xp;
296: {
297:
298: XUNLOCK(xp);
299: }
300:
301: /*
302: * Decrement the in-core usage count of a shared text segment,
303: * which must be locked. When the count drops to zero,
304: * free the core space.
305: */
306: xccdec(xp, p)
307: register struct text *xp;
308: register struct proc *p;
309: {
310:
311: if (--xp->x_ccount == 0) {
312: if (xp->x_flag & XWRIT) {
313: vsswap(p, tptopte(p, 0), CTEXT, 0, (int)xp->x_size,
314: (struct dmap *)0);
315: if (xp->x_flag & XPAGV)
316: (void) swap(p, xp->x_ptdaddr,
317: (caddr_t)tptopte(p, 0),
318: (int)xp->x_size * sizeof (struct pte),
319: B_WRITE, B_PAGET, swapdev_vp, 0);
320: xp->x_flag &= ~XWRIT;
321: } else
322: xp->x_rssize -= vmemfree(tptopte(p, 0),
323: (int)xp->x_size);
324: if (xp->x_rssize != 0)
325: panic("text rssize");
326: }
327: }
328:
329: /*
330: * Detach a process from the in-core text.
331: * External interface to xccdec, used when swapping out a process.
332: */
333: xdetach(xp, p)
334: register struct text *xp;
335: struct proc *p;
336: {
337:
338: if (xp && xp->x_ccount != 0) {
339: X_LOCK(xp);
340: xccdec(xp, p);
341: xunlink(p);
342: XUNLOCK(xp);
343: }
344: }
345:
346: /*
347: * Free the swap image of all unused saved-text text segments
348: * which are from file system mp (used by umount system call).
349: */
350: xumount(mp)
351: struct mount *mp;
352: {
353: register struct text *xp;
354:
355: for (xp = text; xp < textNTEXT; xp++)
356: if (xp->x_vptr != NULL &&
357: (mp == NULL || (xp->x_vptr->v_mount == mp)) &&
358: (xp->x_flag & XLOCK) == 0)
359: xuntext(xp);
360: mpurgemp(mp);
361: }
362:
363: /*
364: * Flush all cached text segments to reclaim swap space.
365: * Used during swap allocation when out of swap space.
366: */
367: xpurge()
368: {
369: register struct text *xp;
370: int found = 0;
371:
372: xstats.purge++;
373: for (xp = text; xp < textNTEXT; xp++)
374: if (xp->x_vptr && (xp->x_flag & (XLOCK|XCACHED)) == XCACHED) {
375: xuntext(xp);
376: /* really gone? */
377: if (xp->x_vptr == NULL)
378: found++;
379: }
380: return(found);
381: }
382:
383: /*
384: * remove a shared text segment from the text table, if possible.
385: */
386: xrele(vp)
387: register struct vnode *vp;
388: {
389:
390: if (vp->v_flag & VTEXT)
391: xuntext(vp->v_text);
392: }
393:
394: /*
395: * remove text image from the text table.
396: * the use count must be zero.
397: */
398: xuntext(xp)
399: register struct text *xp;
400: {
401: register struct vnode *vp;
402:
403: X_LOCK(xp);
404: if (xp->x_count == 0) {
405: vp = xp->x_vptr;
406: xp->x_vptr = NULL;
407: vsxfree(xp, (long)xp->x_size);
408: vp->v_flag &= ~VTEXT;
409: vp->v_text = NULL;
410: mpurge(vp);
411: vrele(vp);
412: /*
413: * Take care of text cache statistics
414: */
415: if (xp->x_flag & XCACHED) {
416: if (xp->x_flag & XUNUSED)
417: xstats.alloc_unused++;
418: xp->x_flag &= ~(XCACHED|XUNUSED);
419: xstats.alloc_cacheflush++;
420: xcache--;
421: }
422: }
423: XUNLOCK(xp);
424: }
425:
426: /*
427: * Add a process to those sharing a text segment by
428: * getting the page tables and then linking to x_caddr.
429: */
430: xlink(p)
431: register struct proc *p;
432: {
433: register struct text *xp = p->p_textp;
434:
435: if (xp == 0)
436: return;
437: vinitpt(p);
438: p->p_xlink = xp->x_caddr;
439: xp->x_caddr = p;
440: xp->x_ccount++;
441: }
442:
443: xunlink(p)
444: register struct proc *p;
445: {
446: register struct text *xp = p->p_textp;
447: register struct proc *q;
448:
449: if (xp == 0)
450: return;
451: if (xp->x_caddr == p) {
452: xp->x_caddr = p->p_xlink;
453: p->p_xlink = 0;
454: return;
455: }
456: for (q = xp->x_caddr; q->p_xlink; q = q->p_xlink)
457: if (q->p_xlink == p) {
458: q->p_xlink = p->p_xlink;
459: p->p_xlink = 0;
460: return;
461: }
462: panic("lost text");
463: }
464:
465: /*
466: * Replace p by q in a text incore linked list.
467: * Used by vfork(), internally.
468: */
469: xrepl(p, q)
470: struct proc *p, *q;
471: {
472: register struct text *xp = q->p_textp;
473:
474: if (xp == 0)
475: return;
476: xunlink(p);
477: q->p_xlink = xp->x_caddr;
478: xp->x_caddr = q;
479: }
480:
481: int xkillcnt = 0;
482:
483: /*
484: * Invalidate the text associated with vp.
485: * Purge in core cache of pages associated with vp and kill all active
486: * processes.
487: */
488: xinval(vp)
489: struct vnode *vp;
490: {
491: register struct text *xp;
492: register struct proc *p;
493: int found = 0;
494:
495: mpurge(vp);
496: xp = vp->v_text;
497: if (xp->x_flag & XPAGV) {
498: for (p = xp->x_caddr; p; p = p->p_xlink) {
499: /*
500: * swkill without uprintf
501: */
502: printf("pid %d killed due to text modification\n",
503: p->p_pid);
504: psignal(p, SIGKILL);
505: p->p_flag |= SULOCK;
506: xkillcnt++;
507: found++;
508: }
509: /*
510: * Take care of the text cache.
511: * If there was a process still using the text just mark
512: * the text as XTRC so it won't be cached. If no one was
513: * using it then it is in the cache and we need to flush
514: * it with xuntext.
515: */
516: if (found)
517: xp->x_flag |= XTRC;
518: else
519: xuntext(xp);
520: }
521: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.