1/*
2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * The Mach Operating System project at Carnegie-Mellon University.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * from: @(#)vm_page.h 8.2 (Berkeley) 12/13/93
37 *
38 *
39 * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40 * All rights reserved.
41 *
42 * Authors: Avadis Tevanian, Jr., Michael Wayne Young
43 *
44 * Permission to use, copy, modify and distribute this software and
45 * its documentation is hereby granted, provided that both the copyright
46 * notice and this permission notice appear in all copies of the
47 * software, derivative works or modified versions, and any portions
48 * thereof, and that both notices appear in supporting documentation.
49 *
50 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
51 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
52 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
53 *
54 * Carnegie Mellon requests users of this software to return to
55 *
56 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
57 * School of Computer Science
58 * Carnegie Mellon University
59 * Pittsburgh PA 15213-3890
60 *
61 * any improvements or extensions that they make and grant Carnegie the
62 * rights to redistribute these changes.
63 *
| 1/*
2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * The Mach Operating System project at Carnegie-Mellon University.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * from: @(#)vm_page.h 8.2 (Berkeley) 12/13/93
37 *
38 *
39 * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40 * All rights reserved.
41 *
42 * Authors: Avadis Tevanian, Jr., Michael Wayne Young
43 *
44 * Permission to use, copy, modify and distribute this software and
45 * its documentation is hereby granted, provided that both the copyright
46 * notice and this permission notice appear in all copies of the
47 * software, derivative works or modified versions, and any portions
48 * thereof, and that both notices appear in supporting documentation.
49 *
50 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
51 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
52 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
53 *
54 * Carnegie Mellon requests users of this software to return to
55 *
56 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
57 * School of Computer Science
58 * Carnegie Mellon University
59 * Pittsburgh PA 15213-3890
60 *
61 * any improvements or extensions that they make and grant Carnegie the
62 * rights to redistribute these changes.
63 *
|
64 * $Id: vm_page.h,v 1.17 1995/03/26 23:33:14 davidg Exp $
| 64 * $Id: vm_page.h,v 1.18 1995/04/23 08:05:49 bde Exp $
|
65 */
66
67/*
68 * Resident memory system definitions.
69 */
70
71#ifndef _VM_PAGE_
72#define _VM_PAGE_
73
74#include <vm/pmap.h>
75/*
76 * Management of resident (logical) pages.
77 *
78 * A small structure is kept for each resident
79 * page, indexed by page number. Each structure
80 * is an element of several lists:
81 *
82 * A hash table bucket used to quickly
83 * perform object/offset lookups
84 *
85 * A list of all pages for a given object,
86 * so they can be quickly deactivated at
87 * time of deallocation.
88 *
89 * An ordered list of pages due for pageout.
90 *
91 * In addition, the structure contains the object
92 * and offset to which this page belongs (for pageout),
93 * and sundry status bits.
94 *
95 * Fields in this structure are locked either by the lock on the
96 * object that the page belongs to (O) or by the lock on the page
97 * queues (P).
98 */
99
100TAILQ_HEAD(pglist, vm_page);
101
102struct vm_page {
103 TAILQ_ENTRY(vm_page) pageq; /* queue info for FIFO queue or free list (P) */
104 TAILQ_ENTRY(vm_page) hashq; /* hash table links (O) */
105 TAILQ_ENTRY(vm_page) listq; /* pages in same object (O) */
106
107 vm_object_t object; /* which object am I in (O,P) */
108 vm_offset_t offset; /* offset into object (O,P) */
109 vm_offset_t phys_addr; /* physical address of page */
110
111 u_short wire_count; /* wired down maps refs (P) */
112 u_short flags; /* see below */
113 short hold_count; /* page hold count */
114 u_short act_count; /* page usage count */
115 u_short bmapped; /* number of buffers mapped */
116 u_short busy; /* page busy count */
117 u_short valid; /* map of valid DEV_BSIZE chunks */
118 u_short dirty; /* map of dirty DEV_BSIZE chunks */
119};
120
121/*
122 * These are the flags defined for vm_page.
123 *
124 * Note: PG_FILLED and PG_DIRTY are added for the filesystems.
125 */
126#define PG_INACTIVE 0x0001 /* page is in inactive list (P) */
127#define PG_ACTIVE 0x0002 /* page is in active list (P) */
128#define PG_BUSY 0x0010 /* page is in transit (O) */
129#define PG_WANTED 0x0020 /* someone is waiting for page (O) */
130#define PG_TABLED 0x0040 /* page is in VP table (O) */
131#define PG_COPYONWRITE 0x0080 /* must copy page before changing (O) */
132#define PG_FICTITIOUS 0x0100 /* physical page doesn't exist (O) */
133#define PG_WRITEABLE 0x0200 /* page is mapped writeable */
134#define PG_MAPPED 0x0400 /* page is mapped */
135#define PG_REFERENCED 0x1000 /* page has been referenced */
136#define PG_CACHE 0x4000 /* On VMIO cache */
137#define PG_FREE 0x8000 /* page is in free list */
138
| 65 */
66
67/*
68 * Resident memory system definitions.
69 */
70
71#ifndef _VM_PAGE_
72#define _VM_PAGE_
73
74#include <vm/pmap.h>
75/*
76 * Management of resident (logical) pages.
77 *
78 * A small structure is kept for each resident
79 * page, indexed by page number. Each structure
80 * is an element of several lists:
81 *
82 * A hash table bucket used to quickly
83 * perform object/offset lookups
84 *
85 * A list of all pages for a given object,
86 * so they can be quickly deactivated at
87 * time of deallocation.
88 *
89 * An ordered list of pages due for pageout.
90 *
91 * In addition, the structure contains the object
92 * and offset to which this page belongs (for pageout),
93 * and sundry status bits.
94 *
95 * Fields in this structure are locked either by the lock on the
96 * object that the page belongs to (O) or by the lock on the page
97 * queues (P).
98 */
99
100TAILQ_HEAD(pglist, vm_page);
101
102struct vm_page {
103 TAILQ_ENTRY(vm_page) pageq; /* queue info for FIFO queue or free list (P) */
104 TAILQ_ENTRY(vm_page) hashq; /* hash table links (O) */
105 TAILQ_ENTRY(vm_page) listq; /* pages in same object (O) */
106
107 vm_object_t object; /* which object am I in (O,P) */
108 vm_offset_t offset; /* offset into object (O,P) */
109 vm_offset_t phys_addr; /* physical address of page */
110
111 u_short wire_count; /* wired down maps refs (P) */
112 u_short flags; /* see below */
113 short hold_count; /* page hold count */
114 u_short act_count; /* page usage count */
115 u_short bmapped; /* number of buffers mapped */
116 u_short busy; /* page busy count */
117 u_short valid; /* map of valid DEV_BSIZE chunks */
118 u_short dirty; /* map of dirty DEV_BSIZE chunks */
119};
120
121/*
122 * These are the flags defined for vm_page.
123 *
124 * Note: PG_FILLED and PG_DIRTY are added for the filesystems.
125 */
126#define PG_INACTIVE 0x0001 /* page is in inactive list (P) */
127#define PG_ACTIVE 0x0002 /* page is in active list (P) */
128#define PG_BUSY 0x0010 /* page is in transit (O) */
129#define PG_WANTED 0x0020 /* someone is waiting for page (O) */
130#define PG_TABLED 0x0040 /* page is in VP table (O) */
131#define PG_COPYONWRITE 0x0080 /* must copy page before changing (O) */
132#define PG_FICTITIOUS 0x0100 /* physical page doesn't exist (O) */
133#define PG_WRITEABLE 0x0200 /* page is mapped writeable */
134#define PG_MAPPED 0x0400 /* page is mapped */
135#define PG_REFERENCED 0x1000 /* page has been referenced */
136#define PG_CACHE 0x4000 /* On VMIO cache */
137#define PG_FREE 0x8000 /* page is in free list */
138
|
139#if VM_PAGE_DEBUG
140#define VM_PAGE_CHECK(mem) { \
141 if ((((unsigned int) mem) < ((unsigned int) &vm_page_array[0])) || \
142 (((unsigned int) mem) > \
143 ((unsigned int) &vm_page_array[last_page-first_page])) || \
144 ((mem->flags & (PG_ACTIVE | PG_INACTIVE)) == \
145 (PG_ACTIVE | PG_INACTIVE))) \
146 panic("vm_page_check: not valid!"); \
147}
148#else /* VM_PAGE_DEBUG */
149#define VM_PAGE_CHECK(mem)
150#endif /* VM_PAGE_DEBUG */
| 139/*
140 * Misc constants.
141 */
|
151
| 142
|
| 143#define ACT_DECLINE 1
144#define ACT_ADVANCE 3
145#define ACT_MAX 100
146#define PFCLUSTER_BEHIND 3
147#define PFCLUSTER_AHEAD 3
148
|
152#ifdef KERNEL
153/*
| 149#ifdef KERNEL
150/*
|
154 * Each pageable resident page falls into one of three lists:
| 151 * Each pageable resident page falls into one of four lists:
|
155 *
156 * free
157 * Available for allocation now.
| 152 *
153 * free
154 * Available for allocation now.
|
| 155 *
156 * The following are all LRU sorted:
157 *
158 * cache
159 * Almost available for allocation. Still in an
160 * object, but clean and immediately freeable at
161 * non-interrupt times.
162 *
|
158 * inactive
| 163 * inactive
|
159 * Not referenced in any map, but still has an
160 * object/offset-page mapping, and may be dirty.
| 164 * Low activity, candidates for reclaimation.
|
161 * This is the list of pages that should be
162 * paged out next.
| 165 * This is the list of pages that should be
166 * paged out next.
|
| 167 *
|
163 * active
| 168 * active
|
164 * A list of pages which have been placed in
165 * at least one physical map. This list is
166 * ordered, in LRU-like fashion.
| 169 * Pages that are "active" i.e. they have been
170 * recently referenced.
|
167 */
168
169extern struct pglist vm_page_queue_free; /* memory free queue */
170extern struct pglist vm_page_queue_active; /* active memory queue */
171extern struct pglist vm_page_queue_inactive; /* inactive memory queue */
172extern struct pglist vm_page_queue_cache; /* cache memory queue */
173
174extern vm_page_t vm_page_array; /* First resident page in table */
175extern long first_page; /* first physical page number */
176
177 /* ... represented in vm_page_array */
178extern long last_page; /* last physical page number */
179
180 /* ... represented in vm_page_array */
181 /* [INCLUSIVE] */
182extern vm_offset_t first_phys_addr; /* physical address for first_page */
183extern vm_offset_t last_phys_addr; /* physical address for last_page */
184
185#define VM_PAGE_TO_PHYS(entry) ((entry)->phys_addr)
186
187#define IS_VM_PHYSADDR(pa) \
188 ((pa) >= first_phys_addr && (pa) <= last_phys_addr)
189
190#define PHYS_TO_VM_PAGE(pa) \
191 (&vm_page_array[atop(pa) - first_page ])
192
| 171 */
172
173extern struct pglist vm_page_queue_free; /* memory free queue */
174extern struct pglist vm_page_queue_active; /* active memory queue */
175extern struct pglist vm_page_queue_inactive; /* inactive memory queue */
176extern struct pglist vm_page_queue_cache; /* cache memory queue */
177
178extern vm_page_t vm_page_array; /* First resident page in table */
179extern long first_page; /* first physical page number */
180
181 /* ... represented in vm_page_array */
182extern long last_page; /* last physical page number */
183
184 /* ... represented in vm_page_array */
185 /* [INCLUSIVE] */
186extern vm_offset_t first_phys_addr; /* physical address for first_page */
187extern vm_offset_t last_phys_addr; /* physical address for last_page */
188
189#define VM_PAGE_TO_PHYS(entry) ((entry)->phys_addr)
190
191#define IS_VM_PHYSADDR(pa) \
192 ((pa) >= first_phys_addr && (pa) <= last_phys_addr)
193
194#define PHYS_TO_VM_PAGE(pa) \
195 (&vm_page_array[atop(pa) - first_page ])
196
|
193extern simple_lock_data_t vm_page_queue_lock; /* lock on active and inactive page queues */
194extern simple_lock_data_t vm_page_queue_free_lock; /* lock on free page queue */
195
| |
196/*
197 * Functions implemented as macros
198 */
199
200#define PAGE_ASSERT_WAIT(m, interruptible) { \
201 (m)->flags |= PG_WANTED; \
202 assert_wait((int) (m), (interruptible)); \
203 }
204
205#define PAGE_WAKEUP(m) { \
206 (m)->flags &= ~PG_BUSY; \
207 if ((m)->flags & PG_WANTED) { \
208 (m)->flags &= ~PG_WANTED; \
209 wakeup((caddr_t) (m)); \
210 } \
211 }
212
| 197/*
198 * Functions implemented as macros
199 */
200
201#define PAGE_ASSERT_WAIT(m, interruptible) { \
202 (m)->flags |= PG_WANTED; \
203 assert_wait((int) (m), (interruptible)); \
204 }
205
206#define PAGE_WAKEUP(m) { \
207 (m)->flags &= ~PG_BUSY; \
208 if ((m)->flags & PG_WANTED) { \
209 (m)->flags &= ~PG_WANTED; \
210 wakeup((caddr_t) (m)); \
211 } \
212 }
213
|
213#define vm_page_lock_queues() simple_lock(&vm_page_queue_lock)
214#define vm_page_unlock_queues() simple_unlock(&vm_page_queue_lock)
215
| |
216#if PAGE_SIZE == 4096
217#define VM_PAGE_BITS_ALL 0xff
218#endif
219
220#if PAGE_SIZE == 8192
221#define VM_PAGE_BITS_ALL 0xffff
222#endif
223
224#define VM_ALLOC_NORMAL 0
225#define VM_ALLOC_INTERRUPT 1
226#define VM_ALLOC_SYSTEM 2
227
228void vm_page_activate __P((vm_page_t));
229vm_page_t vm_page_alloc __P((vm_object_t, vm_offset_t, int));
230void vm_page_cache __P((register vm_page_t));
231void vm_page_copy __P((vm_page_t, vm_page_t));
232void vm_page_deactivate __P((vm_page_t));
233void vm_page_free __P((vm_page_t));
234void vm_page_insert __P((vm_page_t, vm_object_t, vm_offset_t));
235vm_page_t vm_page_lookup __P((vm_object_t, vm_offset_t));
236void vm_page_remove __P((vm_page_t));
237void vm_page_rename __P((vm_page_t, vm_object_t, vm_offset_t));
238vm_offset_t vm_page_startup __P((vm_offset_t, vm_offset_t, vm_offset_t));
239void vm_page_unwire __P((vm_page_t));
240void vm_page_wire __P((vm_page_t));
241boolean_t vm_page_zero_fill __P((vm_page_t));
242void vm_page_set_dirty __P((vm_page_t, int, int));
243void vm_page_set_clean __P((vm_page_t, int, int));
244int vm_page_is_clean __P((vm_page_t, int, int));
245void vm_page_set_valid __P((vm_page_t, int, int));
246void vm_page_set_invalid __P((vm_page_t, int, int));
247int vm_page_is_valid __P((vm_page_t, int, int));
248void vm_page_test_dirty __P((vm_page_t));
249void vm_page_unqueue __P((vm_page_t ));
250int vm_page_bits __P((int, int));
251
252
253/*
254 * Keep page from being freed by the page daemon
255 * much of the same effect as wiring, except much lower
256 * overhead and should be used only for *very* temporary
257 * holding ("wiring").
258 */
259static __inline void
260vm_page_hold(vm_page_t mem)
261{
262 mem->hold_count++;
263}
264
265#ifdef DIAGNOSTIC
266#include <sys/systm.h> /* make GCC shut up */
267#endif
268
269static __inline void
270vm_page_unhold(vm_page_t mem)
271{
272#ifdef DIAGNOSTIC
273 if (--mem->hold_count < 0)
274 panic("vm_page_unhold: hold count < 0!!!");
275#else
276 --mem->hold_count;
277#endif
278}
279
280static __inline void
281vm_page_protect(vm_page_t mem, int prot)
282{
283 if (prot == VM_PROT_NONE) {
284 if (mem->flags & (PG_WRITEABLE|PG_MAPPED)) {
285 pmap_page_protect(VM_PAGE_TO_PHYS(mem), prot);
286 mem->flags &= ~(PG_WRITEABLE|PG_MAPPED);
287 }
288 } else if ((prot == VM_PROT_READ) && (mem->flags & PG_WRITEABLE)) {
289 pmap_page_protect(VM_PAGE_TO_PHYS(mem), prot);
290 mem->flags &= ~PG_WRITEABLE;
291 }
292}
293
294
295#endif /* KERNEL */
| 214#if PAGE_SIZE == 4096
215#define VM_PAGE_BITS_ALL 0xff
216#endif
217
218#if PAGE_SIZE == 8192
219#define VM_PAGE_BITS_ALL 0xffff
220#endif
221
222#define VM_ALLOC_NORMAL 0
223#define VM_ALLOC_INTERRUPT 1
224#define VM_ALLOC_SYSTEM 2
225
226void vm_page_activate __P((vm_page_t));
227vm_page_t vm_page_alloc __P((vm_object_t, vm_offset_t, int));
228void vm_page_cache __P((register vm_page_t));
229void vm_page_copy __P((vm_page_t, vm_page_t));
230void vm_page_deactivate __P((vm_page_t));
231void vm_page_free __P((vm_page_t));
232void vm_page_insert __P((vm_page_t, vm_object_t, vm_offset_t));
233vm_page_t vm_page_lookup __P((vm_object_t, vm_offset_t));
234void vm_page_remove __P((vm_page_t));
235void vm_page_rename __P((vm_page_t, vm_object_t, vm_offset_t));
236vm_offset_t vm_page_startup __P((vm_offset_t, vm_offset_t, vm_offset_t));
237void vm_page_unwire __P((vm_page_t));
238void vm_page_wire __P((vm_page_t));
239boolean_t vm_page_zero_fill __P((vm_page_t));
240void vm_page_set_dirty __P((vm_page_t, int, int));
241void vm_page_set_clean __P((vm_page_t, int, int));
242int vm_page_is_clean __P((vm_page_t, int, int));
243void vm_page_set_valid __P((vm_page_t, int, int));
244void vm_page_set_invalid __P((vm_page_t, int, int));
245int vm_page_is_valid __P((vm_page_t, int, int));
246void vm_page_test_dirty __P((vm_page_t));
247void vm_page_unqueue __P((vm_page_t ));
248int vm_page_bits __P((int, int));
249
250
251/*
252 * Keep page from being freed by the page daemon
253 * much of the same effect as wiring, except much lower
254 * overhead and should be used only for *very* temporary
255 * holding ("wiring").
256 */
257static __inline void
258vm_page_hold(vm_page_t mem)
259{
260 mem->hold_count++;
261}
262
263#ifdef DIAGNOSTIC
264#include <sys/systm.h> /* make GCC shut up */
265#endif
266
267static __inline void
268vm_page_unhold(vm_page_t mem)
269{
270#ifdef DIAGNOSTIC
271 if (--mem->hold_count < 0)
272 panic("vm_page_unhold: hold count < 0!!!");
273#else
274 --mem->hold_count;
275#endif
276}
277
278static __inline void
279vm_page_protect(vm_page_t mem, int prot)
280{
281 if (prot == VM_PROT_NONE) {
282 if (mem->flags & (PG_WRITEABLE|PG_MAPPED)) {
283 pmap_page_protect(VM_PAGE_TO_PHYS(mem), prot);
284 mem->flags &= ~(PG_WRITEABLE|PG_MAPPED);
285 }
286 } else if ((prot == VM_PROT_READ) && (mem->flags & PG_WRITEABLE)) {
287 pmap_page_protect(VM_PAGE_TO_PHYS(mem), prot);
288 mem->flags &= ~PG_WRITEABLE;
289 }
290}
291
292
293#endif /* KERNEL */
|
296
297#define ACT_DECLINE 1
298#define ACT_ADVANCE 3
299#define ACT_MAX 100
300
| |
301#endif /* !_VM_PAGE_ */
| 294#endif /* !_VM_PAGE_ */
|