Print this page
use NULL dump segop as a shorthand for no-op
Instead of forcing every segment driver to implement a dummy function that
does nothing, handle NULL dump segop function pointer as a no-op shorthand.
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/sparc/v9/vm/seg_nf.c
+++ new/usr/src/uts/sparc/v9/vm/seg_nf.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
27 27 /* All Rights Reserved */
28 28
29 29 /*
30 30 * Portions of this source code were derived from Berkeley 4.3 BSD
31 31 * under license from the Regents of the University of California.
32 32 */
33 33
34 34 /*
35 35 * VM - segment for non-faulting loads.
36 36 */
37 37
38 38 #include <sys/types.h>
39 39 #include <sys/t_lock.h>
40 40 #include <sys/param.h>
41 41 #include <sys/mman.h>
42 42 #include <sys/errno.h>
43 43 #include <sys/kmem.h>
44 44 #include <sys/cmn_err.h>
45 45 #include <sys/vnode.h>
46 46 #include <sys/proc.h>
47 47 #include <sys/conf.h>
48 48 #include <sys/debug.h>
49 49 #include <sys/archsystm.h>
50 50 #include <sys/lgrp.h>
51 51
52 52 #include <vm/page.h>
53 53 #include <vm/hat.h>
54 54 #include <vm/as.h>
55 55 #include <vm/seg.h>
56 56 #include <vm/vpage.h>
57 57
58 58 /*
59 59 * Private seg op routines.
60 60 */
61 61 static int segnf_dup(struct seg *seg, struct seg *newseg);
62 62 static int segnf_unmap(struct seg *seg, caddr_t addr, size_t len);
63 63 static void segnf_free(struct seg *seg);
64 64 static faultcode_t segnf_nomap(void);
|
↓ open down ↓ |
64 lines elided |
↑ open up ↑ |
65 65 static int segnf_setprot(struct seg *seg, caddr_t addr,
66 66 size_t len, uint_t prot);
67 67 static int segnf_checkprot(struct seg *seg, caddr_t addr,
68 68 size_t len, uint_t prot);
69 69 static int segnf_nop(void);
70 70 static int segnf_getprot(struct seg *seg, caddr_t addr,
71 71 size_t len, uint_t *protv);
72 72 static u_offset_t segnf_getoffset(struct seg *seg, caddr_t addr);
73 73 static int segnf_gettype(struct seg *seg, caddr_t addr);
74 74 static int segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp);
75 -static void segnf_dump(struct seg *seg);
76 75 static int segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
77 76 struct page ***ppp, enum lock_type type, enum seg_rw rw);
78 77
79 78
80 79 const struct seg_ops segnf_ops = {
81 80 .dup = segnf_dup,
82 81 .unmap = segnf_unmap,
83 82 .free = segnf_free,
84 83 .fault = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
85 84 size_t, enum fault_type, enum seg_rw))segnf_nomap,
86 85 .faulta = (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
87 86 .setprot = segnf_setprot,
88 87 .checkprot = segnf_checkprot,
89 88 .sync = (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
90 89 segnf_nop,
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
91 90 .incore = (size_t (*)(struct seg *, caddr_t, size_t, char *))
92 91 segnf_nop,
93 92 .lockop = (int (*)(struct seg *, caddr_t, size_t, int, int,
94 93 ulong_t *, size_t))segnf_nop,
95 94 .getprot = segnf_getprot,
96 95 .getoffset = segnf_getoffset,
97 96 .gettype = segnf_gettype,
98 97 .getvp = segnf_getvp,
99 98 .advise = (int (*)(struct seg *, caddr_t, size_t, uint_t))
100 99 segnf_nop,
101 - .dump = segnf_dump,
102 100 .pagelock = segnf_pagelock,
103 101 };
104 102
105 103 /*
106 104 * vnode and page for the page of zeros we use for the nf mappings.
107 105 */
108 106 static kmutex_t segnf_lock;
109 107 static struct vnode nfvp;
110 108 static struct page **nfpp;
111 109
112 110 #define addr_to_vcolor(addr) \
113 111 (shm_alignment) ? \
114 112 ((int)(((uintptr_t)(addr) & (shm_alignment - 1)) >> PAGESHIFT)) : 0
115 113
116 114 /*
117 115 * We try to limit the number of Non-fault segments created.
118 116 * Non fault segments are created to optimize sparc V9 code which uses
119 117 * the sparc nonfaulting load ASI (ASI_PRIMARY_NOFAULT).
120 118 *
121 119 * There are several reasons why creating too many non-fault segments
122 120 * could cause problems.
123 121 *
124 122 * First, excessive allocation of kernel resources for the seg
125 123 * structures and the HAT data to map the zero pages.
126 124 *
127 125 * Secondly, creating nofault segments actually uses up user virtual
128 126 * address space. This makes it unavailable for subsequent mmap(0, ...)
129 127 * calls which use as_gap() to find empty va regions. Creation of too
130 128 * many nofault segments could thus interfere with the ability of the
131 129 * runtime linker to load a shared object.
132 130 */
133 131 #define MAXSEGFORNF (10000)
134 132 #define MAXNFSEARCH (5)
135 133
136 134
137 135 /*
138 136 * Must be called from startup()
139 137 */
140 138 void
141 139 segnf_init()
142 140 {
143 141 mutex_init(&segnf_lock, NULL, MUTEX_DEFAULT, NULL);
144 142 }
145 143
146 144
147 145 /*
148 146 * Create a no-fault segment.
149 147 *
150 148 * The no-fault segment is not technically necessary, as the code in
151 149 * nfload() in trap.c will emulate the SPARC instruction and load
152 150 * a value of zero in the destination register.
153 151 *
154 152 * However, this code tries to put a page of zero's at the nofault address
155 153 * so that subsequent non-faulting loads to the same page will not
156 154 * trap with a tlb miss.
157 155 *
158 156 * In order to help limit the number of segments we merge adjacent nofault
159 157 * segments into a single segment. If we get a large number of segments
160 158 * we'll also try to delete a random other nf segment.
161 159 */
162 160 /* ARGSUSED */
163 161 int
164 162 segnf_create(struct seg *seg, void *argsp)
165 163 {
166 164 uint_t prot;
167 165 pgcnt_t vacpgs;
168 166 u_offset_t off = 0;
169 167 caddr_t vaddr = NULL;
170 168 int i, color;
171 169 struct seg *s1;
172 170 struct seg *s2;
173 171 size_t size;
174 172 struct as *as = seg->s_as;
175 173
176 174 ASSERT(as && AS_WRITE_HELD(as, &as->a_lock));
177 175
178 176 /*
179 177 * Need a page per virtual color or just 1 if no vac.
180 178 */
181 179 mutex_enter(&segnf_lock);
182 180 if (nfpp == NULL) {
183 181 struct seg kseg;
184 182
185 183 vacpgs = 1;
186 184 if (shm_alignment > PAGESIZE) {
187 185 vacpgs = shm_alignment >> PAGESHIFT;
188 186 }
189 187
190 188 nfpp = kmem_alloc(sizeof (*nfpp) * vacpgs, KM_SLEEP);
191 189
192 190 kseg.s_as = &kas;
193 191 for (i = 0; i < vacpgs; i++, off += PAGESIZE,
194 192 vaddr += PAGESIZE) {
195 193 nfpp[i] = page_create_va(&nfvp, off, PAGESIZE,
196 194 PG_WAIT | PG_NORELOC, &kseg, vaddr);
197 195 page_io_unlock(nfpp[i]);
198 196 page_downgrade(nfpp[i]);
199 197 pagezero(nfpp[i], 0, PAGESIZE);
200 198 }
201 199 }
202 200 mutex_exit(&segnf_lock);
203 201
204 202 hat_map(as->a_hat, seg->s_base, seg->s_size, HAT_MAP);
205 203
206 204 /*
207 205 * s_data can't be NULL because of ASSERTS in the common vm code.
208 206 */
209 207 seg->s_ops = &segnf_ops;
210 208 seg->s_data = seg;
211 209 seg->s_flags |= S_PURGE;
212 210
213 211 mutex_enter(&as->a_contents);
214 212 as->a_flags |= AS_NEEDSPURGE;
215 213 mutex_exit(&as->a_contents);
216 214
217 215 prot = PROT_READ;
218 216 color = addr_to_vcolor(seg->s_base);
219 217 if (as != &kas)
220 218 prot |= PROT_USER;
221 219 hat_memload(as->a_hat, seg->s_base, nfpp[color],
222 220 prot | HAT_NOFAULT, HAT_LOAD);
223 221
224 222 /*
225 223 * At this point see if we can concatenate a segment to
226 224 * a non-fault segment immediately before and/or after it.
227 225 */
228 226 if ((s1 = AS_SEGPREV(as, seg)) != NULL &&
229 227 s1->s_ops == &segnf_ops &&
230 228 s1->s_base + s1->s_size == seg->s_base) {
231 229 size = s1->s_size;
232 230 seg_free(s1);
233 231 seg->s_base -= size;
234 232 seg->s_size += size;
235 233 }
236 234
237 235 if ((s2 = AS_SEGNEXT(as, seg)) != NULL &&
238 236 s2->s_ops == &segnf_ops &&
239 237 seg->s_base + seg->s_size == s2->s_base) {
240 238 size = s2->s_size;
241 239 seg_free(s2);
242 240 seg->s_size += size;
243 241 }
244 242
245 243 /*
246 244 * if we already have a lot of segments, try to delete some other
247 245 * nofault segment to reduce the probability of uncontrolled segment
248 246 * creation.
249 247 *
250 248 * the code looks around quickly (no more than MAXNFSEARCH segments
251 249 * each way) for another NF segment and then deletes it.
252 250 */
253 251 if (avl_numnodes(&as->a_segtree) > MAXSEGFORNF) {
254 252 size = 0;
255 253 s2 = NULL;
256 254 s1 = AS_SEGPREV(as, seg);
257 255 while (size++ < MAXNFSEARCH && s1 != NULL) {
258 256 if (s1->s_ops == &segnf_ops)
259 257 s2 = s1;
260 258 s1 = AS_SEGPREV(s1->s_as, seg);
261 259 }
262 260 if (s2 == NULL) {
263 261 s1 = AS_SEGNEXT(as, seg);
264 262 while (size-- > 0 && s1 != NULL) {
265 263 if (s1->s_ops == &segnf_ops)
266 264 s2 = s1;
267 265 s1 = AS_SEGNEXT(as, seg);
268 266 }
269 267 }
270 268 if (s2 != NULL)
271 269 seg_unmap(s2);
272 270 }
273 271
274 272 return (0);
275 273 }
276 274
277 275 /*
278 276 * Never really need "No fault" segments, so they aren't dup'd.
279 277 */
280 278 /* ARGSUSED */
281 279 static int
282 280 segnf_dup(struct seg *seg, struct seg *newseg)
283 281 {
284 282 panic("segnf_dup");
285 283 return (0);
286 284 }
287 285
288 286 /*
289 287 * Split a segment at addr for length len.
290 288 */
291 289 static int
292 290 segnf_unmap(struct seg *seg, caddr_t addr, size_t len)
293 291 {
294 292 ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as, &seg->s_as->a_lock));
295 293
296 294 /*
297 295 * Check for bad sizes.
298 296 */
299 297 if (addr < seg->s_base || addr + len > seg->s_base + seg->s_size ||
300 298 (len & PAGEOFFSET) || ((uintptr_t)addr & PAGEOFFSET)) {
301 299 cmn_err(CE_PANIC, "segnf_unmap: bad unmap size");
302 300 }
303 301
304 302 /*
305 303 * Unload any hardware translations in the range to be taken out.
306 304 */
307 305 hat_unload(seg->s_as->a_hat, addr, len, HAT_UNLOAD_UNMAP);
308 306
309 307 if (addr == seg->s_base && len == seg->s_size) {
310 308 /*
311 309 * Freeing entire segment.
312 310 */
313 311 seg_free(seg);
314 312 } else if (addr == seg->s_base) {
315 313 /*
316 314 * Freeing the beginning of the segment.
317 315 */
318 316 seg->s_base += len;
319 317 seg->s_size -= len;
320 318 } else if (addr + len == seg->s_base + seg->s_size) {
321 319 /*
322 320 * Freeing the end of the segment.
323 321 */
324 322 seg->s_size -= len;
325 323 } else {
326 324 /*
327 325 * The section to go is in the middle of the segment, so we
328 326 * have to cut it into two segments. We shrink the existing
329 327 * "seg" at the low end, and create "nseg" for the high end.
330 328 */
331 329 caddr_t nbase = addr + len;
332 330 size_t nsize = (seg->s_base + seg->s_size) - nbase;
333 331 struct seg *nseg;
334 332
335 333 /*
336 334 * Trim down "seg" before trying to stick "nseg" into the as.
337 335 */
338 336 seg->s_size = addr - seg->s_base;
339 337 nseg = seg_alloc(seg->s_as, nbase, nsize);
340 338 if (nseg == NULL)
341 339 cmn_err(CE_PANIC, "segnf_unmap: seg_alloc failed");
342 340
343 341 /*
344 342 * s_data can't be NULL because of ASSERTs in common VM code.
345 343 */
346 344 nseg->s_ops = seg->s_ops;
347 345 nseg->s_data = nseg;
348 346 nseg->s_flags |= S_PURGE;
349 347 mutex_enter(&seg->s_as->a_contents);
350 348 seg->s_as->a_flags |= AS_NEEDSPURGE;
351 349 mutex_exit(&seg->s_as->a_contents);
352 350 }
353 351
354 352 return (0);
355 353 }
356 354
357 355 /*
358 356 * Free a segment.
359 357 */
360 358 static void
361 359 segnf_free(struct seg *seg)
362 360 {
363 361 ASSERT(seg->s_as && AS_WRITE_HELD(seg->s_as, &seg->s_as->a_lock));
364 362 }
365 363
366 364 /*
367 365 * No faults allowed on segnf.
368 366 */
369 367 static faultcode_t
370 368 segnf_nomap(void)
371 369 {
372 370 return (FC_NOMAP);
373 371 }
374 372
375 373 /* ARGSUSED */
376 374 static int
377 375 segnf_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
378 376 {
379 377 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
380 378 return (EACCES);
381 379 }
382 380
383 381 /* ARGSUSED */
384 382 static int
385 383 segnf_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
386 384 {
387 385 uint_t sprot;
388 386 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
389 387
390 388 sprot = seg->s_as == &kas ? PROT_READ : PROT_READ|PROT_USER;
391 389 return ((prot & sprot) == prot ? 0 : EACCES);
392 390 }
393 391
394 392 static int
395 393 segnf_nop(void)
396 394 {
397 395 return (0);
398 396 }
399 397
400 398 static int
401 399 segnf_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
402 400 {
403 401 size_t pgno = seg_page(seg, addr + len) - seg_page(seg, addr) + 1;
404 402 size_t p;
405 403 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
406 404
407 405 for (p = 0; p < pgno; ++p)
408 406 protv[p] = PROT_READ;
409 407 return (0);
410 408 }
411 409
412 410 /* ARGSUSED */
413 411 static u_offset_t
414 412 segnf_getoffset(struct seg *seg, caddr_t addr)
415 413 {
416 414 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
417 415
418 416 return ((u_offset_t)0);
419 417 }
420 418
421 419 /* ARGSUSED */
422 420 static int
423 421 segnf_gettype(struct seg *seg, caddr_t addr)
424 422 {
425 423 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
426 424
427 425 return (MAP_SHARED);
428 426 }
|
↓ open down ↓ |
317 lines elided |
↑ open up ↑ |
429 427
430 428 /* ARGSUSED */
431 429 static int
432 430 segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
433 431 {
434 432 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
435 433
436 434 *vpp = &nfvp;
437 435 return (0);
438 436 }
439 -
440 -/*
441 - * segnf pages are not dumped, so we just return
442 - */
443 -/* ARGSUSED */
444 -static void
445 -segnf_dump(struct seg *seg)
446 -{}
447 437
448 438 /*ARGSUSED*/
449 439 static int
450 440 segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
451 441 struct page ***ppp, enum lock_type type, enum seg_rw rw)
452 442 {
453 443 return (ENOTSUP);
454 444 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX