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