xref: /illumos-gate/usr/src/lib/madv/common/madv.c (revision df5cd018c34371890eeeb8c930245b9323e8aa25)
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 #include <stdio.h>
27 #include <stdlib.h>
28 #include <strings.h>
29 #include <sys/shm.h>
30 #include <sys/mman.h>
31 #include <fcntl.h>
32 #include <stdlib.h>
33 #include <unistd.h>
34 #include <errno.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/auxv.h>
38 #include <stdarg.h>
39 #include <syslog.h>
40 #include <sys/param.h>
41 #include <sys/sysmacros.h>
42 #include <procfs.h>
43 #include <dlfcn.h>
44 #include <assert.h>
45 #include <libintl.h>
46 #include <locale.h>
47 
48 extern int	gmatch(const char *s, const char *p);
49 
50 #pragma init(__madvmain)
51 
52 static FILE *errfp = NULL;
53 static const char *madvident = "madv.so.1";
54 static int pagesize;
55 static int advice_all = -1;
56 static int advice_heap = -1;
57 static int advice_shm = -1;
58 static int advice_ism = -1;
59 static int advice_dism = -1;
60 static int advice_map = -1;
61 static int advice_mapshared = -1;
62 static int advice_mapprivate = -1;
63 static int advice_mapanon = -1;
64 
65 /* environment variables */
66 
67 #define	ENV_MADV		"MADV"
68 #define	ENV_MADVCFGFILE		"MADVCFGFILE"
69 #define	ENV_MADVERRFILE		"MADVERRFILE"
70 
71 /* config file */
72 
73 #define	DEF_MADVCFGFILE		"/etc/madv.conf"
74 #define	MAXLINELEN	MAXPATHLEN + 64
75 #define	CFGDELIMITER	':'
76 #define	ARGDELIMITER	' '
77 
78 /*
79  * avoid malloc which causes certain applications to crash
80  */
81 static char		lbuf[MAXLINELEN];
82 static char		pbuf[MAXPATHLEN];
83 
84 #ifdef MADVDEBUG
85 #define	ENV_MADVDEBUG	"MADVDEBUG"
86 #define	MADVPRINT(x, y)	if (madvdebug & x) (void) fprintf y;
87 
88 static int madvdebug = 0;
89 #else
90 #define	MADVPRINT(x, y)
91 #endif
92 
93 /*
94  * advice options
95  */
96 static char *legal_optstr[] = {
97 	"madv",
98 	"heap",
99 	"shm",
100 	"ism",
101 	"dism",
102 	"map",
103 	"mapshared",
104 	"mapprivate",
105 	"mapanon",
106 	NULL
107 };
108 
109 enum optenum {
110 	OPT_MADV,
111 	OPT_HEAP,
112 	OPT_SHM,
113 	OPT_ISM,
114 	OPT_DISM,
115 	OPT_MAP,
116 	OPT_MAPSHARED,
117 	OPT_MAPPRIVATE,
118 	OPT_MAPANON
119 };
120 
121 /*
122  * Advice values
123  * These need to correspond to the order of the MADV_ flags in mman.h
124  * since the position infers the value for the flag.
125  */
126 static char *legal_madvice[] = {
127 	"normal",
128 	"random",
129 	"sequential",
130 	"willneed_NOT_SUPPORTED!",
131 	"dontneed_NOT_SUPPORTED!",
132 	"free_NOT_SUPPORTED!",
133 	"access_default",
134 	"access_lwp",
135 	"access_many",
136 	NULL
137 };
138 
139 #if !defined(TEXT_DOMAIN)
140 #define	TEXT_DOMAIN	"SYS_TEST"
141 #endif
142 
143 /*PRINTFLIKE2*/
144 static void
madverr(FILE * fp,char * fmt,...)145 madverr(FILE *fp, char *fmt, ...)
146 {
147 	va_list		ap;
148 	va_start(ap, fmt);
149 	if (fp)
150 		(void) vfprintf(fp, fmt, ap);
151 	else
152 		vsyslog(LOG_ERR, fmt, ap);
153 	va_end(ap);
154 }
155 
156 /*
157  * Return the pointer to the fully-resolved path name of the process's
158  * executable file obtained from the AT_SUN_EXECNAME aux vector entry.
159  */
160 static const char *
mygetexecname(void)161 mygetexecname(void)
162 {
163 	const char	*execname = NULL;
164 	static auxv_t	auxb;
165 
166 	/*
167 	 * The first time through, read the initial aux vector that was
168 	 * passed to the process at exec(2).  Only do this once.
169 	 */
170 	int fd = open("/proc/self/auxv", O_RDONLY);
171 
172 	if (fd >= 0) {
173 		while (read(fd, &auxb, sizeof (auxv_t)) == sizeof (auxv_t)) {
174 			if (auxb.a_type == AT_SUN_EXECNAME) {
175 				execname = auxb.a_un.a_ptr;
176 				break;
177 			}
178 		}
179 		(void) close(fd);
180 	}
181 	return (execname);
182 }
183 
184 /*
185  * Return the process's current brk base and size.
186  */
187 static int
mygetbrk(uintptr_t * base,size_t * size)188 mygetbrk(uintptr_t *base, size_t *size)
189 {
190 	int fd;
191 	pstatus_t ps;
192 	int rc;
193 
194 	fd = open("/proc/self/status", O_RDONLY);
195 
196 	if (fd >= 0) {
197 		if (read(fd, &ps, sizeof (ps)) == sizeof (ps)) {
198 			*base = ps.pr_brkbase;
199 			*size = ps.pr_brksize;
200 			rc = 0;
201 		} else {
202 			rc = errno;
203 		}
204 		(void) close(fd);
205 	} else {
206 		rc = errno;
207 	}
208 	return (rc);
209 }
210 
211 /*
212  * Check if exec name matches cfgname found in madv cfg file.
213  */
214 static int
fnmatch(const char * execname,char * cfgname,char * cwd)215 fnmatch(const char *execname, char *cfgname, char *cwd)
216 {
217 	const char	*ename;
218 	int		rc;
219 
220 	/* cfgname should not have a '/' unless it begins with one */
221 	if (cfgname[0] == '/') {
222 		/*
223 		 * if execname does not begin with a '/', prepend the
224 		 * current directory.
225 		 */
226 		if (execname[0] != '/') {
227 			ename = (const char *)strcat(cwd, execname);
228 		} else
229 			ename = execname;
230 	} else {	/* simple cfg name */
231 		if (ename = strrchr(execname, '/'))
232 			/* execname is a path name - get the base name */
233 			ename++;
234 		else
235 			ename = execname;
236 	}
237 	rc = gmatch(ename, cfgname);
238 	MADVPRINT(2, (stderr, "gmatch: %s %s %s %d\n",
239 	    cfgname, ename, execname, rc));
240 
241 	return (rc);
242 }
243 
244 /*
245  * Check if string matches any of exec arguments.
246  */
247 static int
argmatch(char * str)248 argmatch(char *str)
249 {
250 	int fd;
251 	psinfo_t pi;
252 	int rc = 0;
253 	int arg;
254 	char **argv;
255 
256 	fd = open("/proc/self/psinfo", O_RDONLY);
257 
258 	if (fd >= 0) {
259 		if (read(fd, &pi, sizeof (pi)) == sizeof (pi)) {
260 			argv = (char **)pi.pr_argv;
261 			argv++;
262 			MADVPRINT(2, (stderr, "argmatch: %s ", str));
263 			for (arg = 1; arg < pi.pr_argc; arg++, argv++) {
264 				if (rc = gmatch(*argv, str)) {
265 					MADVPRINT(2, (stderr, "%s ", *argv));
266 					break;
267 				}
268 			}
269 			MADVPRINT(2, (stderr, "%d\n", rc));
270 		} else {
271 			madverr(errfp, dgettext(TEXT_DOMAIN,
272 			    "%s: /proc/self/psinfo read failed [%s]\n"),
273 			    madvident, strerror(errno));
274 		}
275 		(void) close(fd);
276 	} else {
277 		madverr(errfp, dgettext(TEXT_DOMAIN,
278 		    "%s: /proc/self/psinfo open failed [%s]\n"),
279 		    madvident, strerror(errno));
280 	}
281 	return (rc);
282 }
283 
284 static int
empty(char * str)285 empty(char *str)
286 {
287 	char	c;
288 
289 	while ((c = *str) == '\n' || c == ' ' || c == '\t')
290 		str++;
291 	return (*str == '\0');
292 }
293 
294 static int
strtoadv(char * advstr)295 strtoadv(char *advstr)
296 {
297 	char *dummy, *locstr = advstr;
298 
299 	return (getsubopt(&locstr, legal_madvice, &dummy));
300 }
301 
302 static void
advice_opts(char * optstr,const char * execname,char * cfgfile,int lineno)303 advice_opts(char *optstr, const char *execname, char *cfgfile, int lineno)
304 {
305 	char *value;
306 	int opt;
307 	int advice = 0;
308 
309 	while (*optstr != '\0') {
310 		opt = getsubopt(&optstr, legal_optstr, &value);
311 		if (opt < 0) {
312 			madverr(errfp, dgettext(TEXT_DOMAIN,
313 			    "%s: invalid advice option (%s)"
314 			    " for %s - cfgfile: %s, line: %d\n"),
315 			    madvident, value, execname, cfgfile, lineno);
316 			break;
317 		} else if (!value) {
318 			madverr(errfp, dgettext(TEXT_DOMAIN,
319 			    "%s: option missing advice"
320 			    " for %s - cfgfile: %s, line: %d\n"),
321 			    madvident, execname, cfgfile, lineno);
322 			break;
323 		}
324 		advice = strtoadv(value);
325 		if (advice < 0) {
326 			madverr(errfp, dgettext(TEXT_DOMAIN,
327 			    "%s: invalid advice specified (%s)"
328 			    " for %s - cfgfile: %s, line: %d\n"),
329 			    madvident, value, execname, cfgfile, lineno);
330 			break;
331 		}
332 		switch (opt) {
333 		case OPT_MADV:
334 			advice_all = advice;
335 			break;
336 		case OPT_HEAP:
337 			if (advice_heap < 0) {
338 				advice_heap = advice;
339 			} else {
340 				madverr(errfp, dgettext(TEXT_DOMAIN,
341 				    "%s: duplicate advice specified "
342 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
343 				    madvident, value, execname, cfgfile,
344 				    lineno);
345 			}
346 			break;
347 		case OPT_SHM:
348 			if (advice_shm < 0) {
349 				advice_shm = advice;
350 			} else {
351 				madverr(errfp, dgettext(TEXT_DOMAIN,
352 				    "%s: duplicate advice specified "
353 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
354 				    madvident, value, execname, cfgfile,
355 				    lineno);
356 			}
357 			break;
358 		case OPT_ISM:
359 			if (advice_ism < 0) {
360 				advice_ism = advice;
361 			} else {
362 				madverr(errfp, dgettext(TEXT_DOMAIN,
363 				    "%s: duplicate advice specified "
364 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
365 				    madvident, value, execname, cfgfile,
366 				    lineno);
367 			}
368 			break;
369 		case OPT_DISM:
370 			if (advice_dism < 0) {
371 				advice_dism = advice;
372 			} else {
373 				madverr(errfp, dgettext(TEXT_DOMAIN,
374 				    "%s: duplicate advice specified "
375 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
376 				    madvident, value, execname, cfgfile,
377 				    lineno);
378 			}
379 			break;
380 		case OPT_MAP:
381 			if (advice_map < 0) {
382 				advice_map = advice;
383 			} else {
384 				madverr(errfp, dgettext(TEXT_DOMAIN,
385 				    "%s: duplicate advice specified "
386 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
387 				    madvident, value, execname, cfgfile,
388 				    lineno);
389 			}
390 			break;
391 		case OPT_MAPSHARED:
392 			if (advice_mapshared < 0) {
393 				advice_mapshared = advice;
394 			} else {
395 				madverr(errfp, dgettext(TEXT_DOMAIN,
396 				    "%s: duplicate advice specified "
397 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
398 				    madvident, value, execname, cfgfile,
399 				    lineno);
400 			}
401 			break;
402 		case OPT_MAPPRIVATE:
403 			if (advice_mapprivate < 0) {
404 				advice_mapprivate = advice;
405 			} else {
406 				madverr(errfp, dgettext(TEXT_DOMAIN,
407 				    "%s: duplicate advice specified "
408 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
409 				    madvident, value, execname, cfgfile,
410 				    lineno);
411 			}
412 			break;
413 		case OPT_MAPANON:
414 			if (advice_mapanon < 0) {
415 				advice_mapanon = advice;
416 			} else {
417 				madverr(errfp, dgettext(TEXT_DOMAIN,
418 				    "%s: duplicate advice specified "
419 				    "(%s) for %s - cfgfile: %s, line: %d\n"),
420 				    madvident, value, execname, cfgfile,
421 				    lineno);
422 			}
423 			break;
424 		default:
425 			madverr(errfp, dgettext(TEXT_DOMAIN,
426 			    "%s: invalid advice option (%s)"
427 			    " for %s - cfgfile: %s, line: %d\n"),
428 			    madvident, value, execname, cfgfile, lineno);
429 			break;
430 		}
431 	}
432 }
433 
434 static void
__madvmain()435 __madvmain()
436 {
437 	char		*cfgfile, *errfile;
438 	FILE		*fp = NULL;
439 	const char	*execname;
440 	char		*cwd;
441 	int		cwdlen;
442 	char		*tok, *tokadv, *tokarg;
443 	char		*str, *envadv;
444 	int		lineno = 0;
445 	int		advice;
446 	uintptr_t	brkbase, brkend;
447 	size_t		brksize;
448 	int		rc;
449 	char		*locale;
450 
451 	/*
452 	 * If a private error file is indicated then set the locale
453 	 * for error messages for the duration of this routine.
454 	 * Error messages destined for syslog should not be translated
455 	 * and thus come from the default C locale.
456 	 */
457 	if ((errfile = getenv(ENV_MADVERRFILE)) != NULL) {
458 		errfp = fopen(errfile, "aF");
459 		if (errfp) {
460 			locale = setlocale(LC_MESSAGES, "");
461 		} else {
462 			madverr(NULL, dgettext(TEXT_DOMAIN,
463 			    "%s: cannot open error file: %s [%s]\n"),
464 			    madvident, errfile, strerror(errno));
465 		}
466 	}
467 
468 #ifdef MADVDEBUG
469 	if (str = getenv(ENV_MADVDEBUG))
470 		madvdebug = atoi(str);
471 #endif
472 
473 	if (envadv = getenv(ENV_MADV)) {
474 		if ((advice = strtoadv(envadv)) >= 0)
475 			advice_all = advice;
476 		else
477 			madverr(errfp, dgettext(TEXT_DOMAIN,
478 			    "%s: invalid advice specified: MADV=%s\n"),
479 			    madvident, envadv);
480 	}
481 
482 	/*
483 	 * Open specified cfg file or default one.
484 	 */
485 	if (cfgfile = getenv(ENV_MADVCFGFILE)) {
486 		fp = fopen(cfgfile, "rF");
487 		if (!fp) {
488 			madverr(errfp, dgettext(TEXT_DOMAIN,
489 			    "%s: cannot open configuration file: %s [%s]\n"),
490 			    madvident, cfgfile, strerror(errno));
491 		}
492 	} else {
493 		cfgfile = DEF_MADVCFGFILE;
494 		fp = fopen(cfgfile, "rF");
495 	}
496 
497 	if (fp) {
498 		execname = mygetexecname();
499 
500 		cwd = getcwd(pbuf, MAXPATHLEN);
501 		if (!cwd)
502 			return;
503 
504 		cwd = strcat(cwd, "/");
505 		cwdlen = strlen(cwd);
506 
507 		while (fgets(lbuf, MAXLINELEN, fp)) {
508 			lineno++;
509 
510 			/*
511 			 * Make sure line wasn't truncated.
512 			 */
513 			if (strlen(lbuf) >= MAXLINELEN - 1) {
514 				madverr(errfp, dgettext(TEXT_DOMAIN,
515 				    "%s: invalid entry, "
516 				    "line too long - cfgfile:"
517 				    " %s, line: %d\n"),
518 				    madvident, cfgfile, lineno);
519 				continue;
520 			}
521 
522 			if (empty(lbuf))
523 				continue;
524 
525 			/*
526 			 * Get advice options.
527 			 * Parse right to left in case delimiter is in name.
528 			 */
529 			if (!(tokadv = strrchr(lbuf, CFGDELIMITER))) {
530 				madverr(errfp, dgettext(TEXT_DOMAIN,
531 				    "%s: no delimiter specified - cfgfile:"
532 				    " %s, line: %d\n"),
533 				    madvident, cfgfile, lineno);
534 				continue;
535 			}
536 			*tokadv++ = '\0';
537 
538 			/*
539 			 * Remove newline from end of advice options.
540 			 */
541 			if (str = strrchr(tokadv, '\n'))
542 				*str = '\0';
543 
544 			/*
545 			 * Get optional argument string.
546 			 */
547 			if (tokarg = strrchr(lbuf, ARGDELIMITER)) {
548 				*tokarg++ = '\0';
549 			}
550 
551 			/*
552 			 * Compare exec name.
553 			 */
554 			tok = lbuf;
555 			if (!fnmatch(execname, tok, cwd)) {
556 				tokadv = tokarg = NULL;
557 				cwd[cwdlen] = '\0';
558 				continue;
559 			}
560 
561 			/*
562 			 * Compare arguments if argument string specified.
563 			 */
564 			if (tokarg &&
565 			    !empty(tokarg) &&
566 			    !argmatch(tokarg)) {
567 				tokadv = tokarg = NULL;
568 				cwd[cwdlen] = '\0';
569 				continue;
570 			}
571 
572 			/*
573 			 * Parse advice options.
574 			 * If empty, any advice from ENV_MADV is reset.
575 			 */
576 			if (empty(tokadv)) {
577 				advice_all = -1;
578 			} else {
579 				advice_opts(tokadv, execname, cfgfile, lineno);
580 			}
581 			break;
582 		}
583 		(void) fclose(fp);
584 	}
585 
586 	/*
587 	 * Pagesize needed for proper aligning by brk interpose.
588 	 */
589 	pagesize = sysconf(_SC_PAGESIZE);
590 
591 	/*
592 	 * Apply global advice if set.
593 	 * Specific options in the cfgfile take precedence.
594 	 */
595 	if (advice_all >= 0) {
596 		if (advice_heap < 0)
597 			advice_heap = advice_all;
598 		if (advice_shm < 0)
599 			advice_shm = advice_all;
600 		if (advice_map < 0)
601 			advice_map = advice_all;
602 	}
603 
604 	MADVPRINT(2, (stderr, "advice_all %d\n", advice_all));
605 	MADVPRINT(2, (stderr, "advice_heap %d\n", advice_heap));
606 	MADVPRINT(2, (stderr, "advice_shm %d\n", advice_shm));
607 	MADVPRINT(2, (stderr, "advice_ism %d\n", advice_ism));
608 	MADVPRINT(2, (stderr, "advice_dism %d\n", advice_dism));
609 	MADVPRINT(2, (stderr, "advice_map %d\n", advice_map));
610 	MADVPRINT(2, (stderr, "advice_mapshared %d\n", advice_mapshared));
611 	MADVPRINT(2, (stderr, "advice_mapprivate %d\n", advice_mapprivate));
612 	MADVPRINT(2, (stderr, "advice_mapanon %d\n", advice_mapanon));
613 
614 	/*
615 	 * If heap advice is specified, apply it to the existing heap.
616 	 * As the heap grows the kernel applies the advice automatically
617 	 * to new portions of the heap.
618 	 */
619 	if (advice_heap >= 0) {
620 		if (rc = mygetbrk(&brkbase, &brksize)) {
621 			madverr(errfp, dgettext(TEXT_DOMAIN,
622 			    "%s: /proc/self/status read failed [%s]\n"),
623 			    madvident, strerror(rc));
624 		} else {
625 			MADVPRINT(4, (stderr, "brkbase 0x%x brksize 0x%x\n",
626 			    brkbase, brksize));
627 			/*
628 			 * Align start address for memcntl and apply advice
629 			 * on full pages of heap.  Create a page of heap if
630 			 * it does not already exist.
631 			 */
632 			brkend = roundup(brkbase+brksize, pagesize);
633 			brkbase = roundup(brkbase, pagesize);
634 			brksize = brkend - brkbase;
635 			if (brksize < pagesize) {
636 				if (sbrk(pagesize) == (void *)-1) {
637 					madverr(errfp, dgettext(TEXT_DOMAIN,
638 					    "%s: sbrk failed [%s]\n"),
639 					    madvident, strerror(errno));
640 					goto out;
641 				}
642 				brksize = pagesize;
643 			}
644 			MADVPRINT(1, (stderr, "heap advice: 0x%x 0x%x %d\n",
645 			    brkbase, brksize, advice_heap));
646 			if (memcntl((caddr_t)brkbase, brksize, MC_ADVISE,
647 			    (caddr_t)(intptr_t)advice_heap, 0, 0) < 0) {
648 				madverr(errfp, dgettext(TEXT_DOMAIN,
649 				    "%s: memcntl() failed [%s]: heap advice\n"),
650 				    madvident, strerror(errno));
651 			}
652 		}
653 	}
654 out:
655 	if (errfp) {
656 		(void) fclose(errfp);
657 		(void) setlocale(LC_MESSAGES, locale);
658 	} else {
659 		/* close log file: no-op if nothing logged to syslog */
660 		closelog();
661 	}
662 
663 }
664 
665 /*
666  * shmat interpose
667  */
668 void *
shmat(int shmid,const void * shmaddr,int shmflag)669 shmat(int shmid, const void *shmaddr, int shmflag)
670 {
671 	static caddr_t (*shmatfunc)() = NULL;
672 	void *result;
673 	int advice = -1;
674 	struct shmid_ds	mds;
675 #ifdef MADVDEBUG
676 	int rc;
677 #endif
678 
679 	if (!shmatfunc) {
680 		shmatfunc = (caddr_t (*)()) dlsym(RTLD_NEXT, "shmat");
681 		assert(shmatfunc);
682 	}
683 
684 	result = shmatfunc(shmid, shmaddr, shmflag);
685 
686 	/*
687 	 * Options ism, dism take precedence over option shm.
688 	 */
689 	if (advice_ism >= 0 && (shmflag & SHM_SHARE_MMU)) {
690 		advice = advice_ism;
691 	} else if (advice_dism >= 0 && (shmflag & SHM_PAGEABLE)) {
692 		advice = advice_dism;
693 	} else if (advice_shm >= 0) {
694 		advice = advice_shm;
695 	}
696 
697 	/*
698 	 * Apply advice if specified and shmat succeeded.
699 	 */
700 	if (advice >= 0 && result != (void *)-1) {
701 #ifdef MADVDEBUG
702 		/* First determine segment size */
703 		rc = shmctl(shmid, IPC_STAT, &mds);
704 		MADVPRINT(4, (stderr, "shmctl rc %d errno %d\n", rc, errno));
705 		rc = memcntl(result, mds.shm_segsz, MC_ADVISE,
706 		    (caddr_t)(intptr_t)advice, 0, 0);
707 		MADVPRINT(1, (stderr,
708 		    "shmat advice: 0x%x 0x%x %d, rc %d errno %d\n",
709 		    result, mds.shm_segsz, advice, rc, errno));
710 #else
711 		/* First determine segment size */
712 		(void) shmctl(shmid, IPC_STAT, &mds);
713 		(void) memcntl(result, mds.shm_segsz, MC_ADVISE,
714 		    (caddr_t)(intptr_t)advice, 0, 0);
715 #endif
716 	}
717 
718 	return (result);
719 }
720 
721 /*
722  * mmap interpose
723  */
724 void *
mmap(void * addr,size_t len,int prot,int flags,int fd,off_t pos)725 mmap(void *addr, size_t len, int prot, int flags, int fd, off_t pos)
726 {
727 	static caddr_t (*mmapfunc)() = NULL;
728 	caddr_t result;
729 	int advice = -1;
730 
731 	if (!mmapfunc) {
732 		mmapfunc = (caddr_t (*)()) dlsym(RTLD_NEXT, "mmap");
733 		assert(mmapfunc);
734 	}
735 
736 	result = mmapfunc(addr, len, prot, flags, fd, pos);
737 
738 	/*
739 	 * Option mapanon has highest precedence while option map
740 	 * has lowest precedence.
741 	 */
742 	if (advice_mapanon >= 0 && (flags & MAP_ANON)) {
743 		advice = advice_mapanon;
744 	} else if (advice_mapshared >= 0 && (flags & MAP_SHARED)) {
745 		advice = advice_mapshared;
746 	} else if (advice_mapprivate >= 0 && (flags & MAP_PRIVATE)) {
747 		advice = advice_mapprivate;
748 	} else if (advice_map >= 0) {
749 		advice = advice_map;
750 	}
751 
752 	/*
753 	 * Apply advice if specified and mmap succeeded.
754 	 */
755 	if (advice >= 0 && result != MAP_FAILED) {
756 #ifdef MADVDEBUG
757 		int rc;
758 
759 		rc = memcntl(result, len, MC_ADVISE,
760 		    (caddr_t)(intptr_t)advice, 0, 0);
761 		MADVPRINT(1, (stderr,
762 		    "mmap advice: 0x%x 0x%x %d, rc %d errno %d\n",
763 		    result, len, advice, rc, errno));
764 #else
765 		(void) memcntl(result, len, MC_ADVISE,
766 		    (caddr_t)(intptr_t)advice, 0, 0);
767 #endif
768 	}
769 
770 	return (result);
771 }
772 
773 #if !defined(_LP64)
774 /*
775  * mmap64 interpose
776  */
777 void *
mmap64(void * addr,size_t len,int prot,int flags,int fd,off64_t pos)778 mmap64(void *addr, size_t len, int prot, int flags, int fd, off64_t pos)
779 {
780 	static caddr_t (*mmap64func)();
781 	caddr_t result;
782 	int advice = -1;
783 
784 	if (!mmap64func) {
785 		mmap64func = (caddr_t (*)()) dlsym(RTLD_NEXT, "mmap64");
786 		assert(mmap64func);
787 	}
788 
789 	result = mmap64func(addr, len, prot, flags, fd, pos);
790 
791 	/*
792 	 * Option mapanon has highest precedence while option map
793 	 * has lowest precedence.
794 	 */
795 	if (advice_mapanon >= 0 && (flags & MAP_ANON)) {
796 		advice = advice_mapanon;
797 	} else if (advice_mapshared >= 0 && (flags & MAP_SHARED)) {
798 		advice = advice_mapshared;
799 	} else if (advice_mapprivate >= 0 && (flags & MAP_PRIVATE)) {
800 		advice = advice_mapprivate;
801 	} else if (advice_map >= 0) {
802 		advice = advice_map;
803 	}
804 
805 	/*
806 	 * Apply advice if specified and mmap succeeded.
807 	 */
808 	if (advice >= 0 && result != MAP_FAILED) {
809 #ifdef MADVDEBUG
810 		int rc;
811 
812 		rc = memcntl(result, len, MC_ADVISE, (caddr_t)advice, 0, 0);
813 		MADVPRINT(1, (stderr,
814 		    "mmap64 advice: 0x%x 0x%x %d, rc %d errno %d\n",
815 		    result, len, advice, rc, errno));
816 #else
817 		(void) memcntl(result, len, MC_ADVISE, (caddr_t)advice, 0, 0);
818 #endif
819 	}
820 
821 	return (result);
822 }
823 #endif	/* !_LP64 */
824