Date: Fri, 9 Jan 2009 13:18:13 +0000 (UTC) From: Alexander Leidinger <netchild@FreeBSD.org> To: src-committers@freebsd.org, svn-src-user@freebsd.org Subject: svn commit: r186949 - user/netchild/linuxulator-dtrace/src/sys/compat/linux Message-ID: <200901091318.n09DIDHa057784@svn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: netchild Date: Fri Jan 9 13:18:13 2009 New Revision: 186949 URL: http://svn.freebsd.org/changeset/base/186949 Log: - Add more dtrace probes. - Add corresponding *_error probes to the dtrace script. - Remove 'register': This is there since cvs rev 1.1. This is not speed critical code, so remove this and let the compiler do his job. In other similar places this was removed already. - Staticize functions which are not used somewhere else, move the corresponding prototypes from the header to the code file. - Add a comment to the debug part which is not dtrace-ified about the constraints which prevent the removal ATM (remove this code when ldebug() is not used anywhere anymore, AKA when the dtrace-ification is finished). Modified: user/netchild/linuxulator-dtrace/src/sys/compat/linux/check_error.d user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.c user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.h Modified: user/netchild/linuxulator-dtrace/src/sys/compat/linux/check_error.d ============================================================================== --- user/netchild/linuxulator-dtrace/src/sys/compat/linux/check_error.d Fri Jan 9 13:06:56 2009 (r186948) +++ user/netchild/linuxulator-dtrace/src/sys/compat/linux/check_error.d Fri Jan 9 13:18:13 2009 (r186949) @@ -56,7 +56,10 @@ linuxulator*:time:linux_clock_nanosleep: linuxulator*:time:linux_clock_nanosleep:copyout_error, linuxulator*:time:linux_clock_nanosleep:nanosleep_error, linuxulator*:sysctl:handle_string:copyout_error, -linuxulator*:sysctl:linux_sysctl:copyin_error +linuxulator*:sysctl:linux_sysctl:copyin_error, +linuxulator*:mib:linux_sysctl_osname:sysctl_string_error, +linuxulator*:mib:linux_sysctl_osversion:sysctl_string_error, +linuxulator*:mib:linux_sysctl_oss_version:sysctl_string_error { printf("ERROR: %s in %s:%s:%s\n", probename, probeprov, probemod, probefunc); stack(); Modified: user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.c ============================================================================== --- user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.c Fri Jan 9 13:06:56 2009 (r186948) +++ user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.c Fri Jan 9 13:18:13 2009 (r186949) @@ -29,8 +29,12 @@ #include <sys/cdefs.h> __FBSDID("$FreeBSD$"); +#include "opt_compat.h" +#include "opt_kdtrace.h" + #include <sys/param.h> #include <sys/kernel.h> +#include <sys/sdt.h> #include <sys/systm.h> #include <sys/sysctl.h> #include <sys/proc.h> @@ -46,7 +50,85 @@ __FBSDID("$FreeBSD$"); #else #include <machine/../linux/linux.h> #endif + #include <compat/linux/linux_mib.h> +#include <compat/linux/linux_dtrace.h> + +LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_osname, entry); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_osname, sysctl_string_error); +LIN_SDT_PROBE_ARGTYPE(mib, linux_sysctl_osname, sysctl_string_error, 0, "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_osname, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_sysctl_osname, return, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_osrelease, entry); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_osrelease, sysctl_string_error); +LIN_SDT_PROBE_ARGTYPE(mib, linux_sysctl_osrelease, sysctl_string_error, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_osrelease, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_sysctl_osrelease, return, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_oss_version, entry); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_oss_version, sysctl_string_error); +LIN_SDT_PROBE_ARGTYPE(mib, linux_sysctl_oss_version, sysctl_string_error, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_sysctl_oss_version, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_sysctl_oss_version, return, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_prison, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_prison, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_prison, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_prison, return, 0, + "static struct prison *"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_osname, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_osname, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_osname, entry, 1, + "char *"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_osname, return); +LIN_SDT_PROBE_DEFINE(mib, linux_set_osname, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_osname, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_osname, entry, 1, + "char *"); +LIN_SDT_PROBE_DEFINE(mib, linux_set_osname, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_osname, return, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_osrelease, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_osrelease, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_osrelease, entry, 1, + "char *"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_osrelease, return); +LIN_SDT_PROBE_DEFINE(mib, linux_use26, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_use26, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_DEFINE(mib, linux_use26, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_use26, return, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_set_osrelease, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_osrelease, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_osrelease, entry, 1, + "char *"); +LIN_SDT_PROBE_DEFINE(mib, linux_set_osrelease, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_osrelease, return, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_oss_version, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_oss_version, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_DEFINE(mib, linux_get_oss_version, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_get_oss_version, return, 0, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_set_oss_version, entry); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_oss_version, entry, 0, + "struct thread *"); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_oss_version, entry, 1, + "int"); +LIN_SDT_PROBE_DEFINE(mib, linux_set_oss_version, return); +LIN_SDT_PROBE_ARGTYPE(mib, linux_set_oss_version, return, 0, + "int"); struct linux_prison { char pr_osname[LINUX_MAX_UTSNAME]; @@ -63,17 +145,30 @@ MTX_SYSINIT(linux_osname, &osname_lock, static char linux_osname[LINUX_MAX_UTSNAME] = "Linux"; +static int linux_set_osname(struct thread *td, char *osname); +static int linux_set_osrelease(struct thread *td, char *osrelease); +static int linux_set_oss_version(struct thread *td, int oss_version); + static int linux_sysctl_osname(SYSCTL_HANDLER_ARGS) { char osname[LINUX_MAX_UTSNAME]; int error; + LIN_SDT_PROBE(mib, linux_sysctl_osname, entry, 0, 0, 0, 0, 0); + linux_get_osname(req->td, osname); error = sysctl_handle_string(oidp, osname, LINUX_MAX_UTSNAME, req); - if (error || req->newptr == NULL) + if (error || req->newptr == NULL) { + LIN_SDT_PROBE(mib, linux_sysctl_osname, sysctl_string_error, + error, 0, 0, 0, 0); + LIN_SDT_PROBE(mib, linux_sysctl_osname, return, error, 0, 0, + 0, 0); return (error); + } error = linux_set_osname(req->td, osname); + + LIN_SDT_PROBE(mib, linux_sysctl_osname, return, error, 0, 0, 0, 0); return (error); } @@ -91,11 +186,20 @@ linux_sysctl_osrelease(SYSCTL_HANDLER_AR char osrelease[LINUX_MAX_UTSNAME]; int error; + LIN_SDT_PROBE(mib, linux_sysctl_osrelease, entry, 0, 0, 0, 0, 0); + linux_get_osrelease(req->td, osrelease); error = sysctl_handle_string(oidp, osrelease, LINUX_MAX_UTSNAME, req); - if (error || req->newptr == NULL) + if (error || req->newptr == NULL) { + LIN_SDT_PROBE(mib, linux_sysctl_osrelease, sysctl_string_error, + error, 0, 0, 0, 0); + LIN_SDT_PROBE(mib, linux_sysctl_osrelease, return, error, 0, 0, + 0, 0); return (error); + } error = linux_set_osrelease(req->td, osrelease); + + LIN_SDT_PROBE(mib, linux_sysctl_osrelease, return, error, 0, 0, 0, 0); return (error); } @@ -112,11 +216,20 @@ linux_sysctl_oss_version(SYSCTL_HANDLER_ int oss_version; int error; + LIN_SDT_PROBE(mib, linux_sysctl_oss_version, entry, 0, 0, 0, 0, 0); + oss_version = linux_get_oss_version(req->td); error = sysctl_handle_int(oidp, &oss_version, 0, req); - if (error || req->newptr == NULL) + if (error || req->newptr == NULL) { + LIN_SDT_PROBE(mib, linux_sysctl_oss_version, + sysctl_string_error, error, 0, 0, 0, 0); + LIN_SDT_PROBE(mib, linux_sysctl_oss_version, return, error, 0, + 0, 0, 0); return (error); + } error = linux_set_oss_version(req->td, oss_version); + + LIN_SDT_PROBE(mib, linux_sysctl_oss_version, return, error, 0, 0, 0, 0); return (error); } @@ -131,12 +244,16 @@ SYSCTL_PROC(_compat_linux, OID_AUTO, oss static struct prison * linux_get_prison(struct thread *td) { - register struct prison *pr; - register struct linux_prison *lpr; + struct prison *pr; + struct linux_prison *lpr; + + LIN_SDT_PROBE(mib, linux_get_prison, entry, td, 0, 0, 0, 0); KASSERT(td == curthread, ("linux_get_prison() called on !curthread")); - if (!jailed(td->td_ucred)) + if (!jailed(td->td_ucred)) { + LIN_SDT_PROBE(mib, linux_get_prison, return, NULL, 0, 0, 0, 0); return (NULL); + } pr = td->td_ucred->cr_prison; mtx_lock(&pr->pr_mtx); if (pr->pr_linux == NULL) { @@ -154,14 +271,18 @@ linux_get_prison(struct thread *td) else free(lpr, M_PRISON); } + + LIN_SDT_PROBE(mib, linux_get_prison, return, pr, 0, 0, 0, 0); return (pr); } void linux_get_osname(struct thread *td, char *dst) { - register struct prison *pr; - register struct linux_prison *lpr; + struct prison *pr; + struct linux_prison *lpr; + + LIN_SDT_PROBE(mib, linux_get_osname, entry, td, dst, 0, 0, 0); pr = td->td_ucred->cr_prison; if (pr != NULL) { @@ -171,6 +292,8 @@ linux_get_osname(struct thread *td, char if (lpr->pr_osname[0]) { bcopy(lpr->pr_osname, dst, LINUX_MAX_UTSNAME); mtx_unlock(&pr->pr_mtx); + LIN_SDT_PROBE(mib, linux_get_osname, return, 0, + 0, 0, 0, 0); return; } } @@ -180,14 +303,18 @@ linux_get_osname(struct thread *td, char mtx_lock(&osname_lock); bcopy(linux_osname, dst, LINUX_MAX_UTSNAME); mtx_unlock(&osname_lock); + + LIN_SDT_PROBE(mib, linux_get_osname, return, 0, 0, 0, 0, 0); } -int +static int linux_set_osname(struct thread *td, char *osname) { struct prison *pr; struct linux_prison *lpr; + LIN_SDT_PROBE(mib, linux_set_osname, entry, td, osname, 0, 0, 0); + pr = linux_get_prison(td); if (pr != NULL) { lpr = (struct linux_prison *)pr->pr_linux; @@ -199,15 +326,18 @@ linux_set_osname(struct thread *td, char mtx_unlock(&osname_lock); } + LIN_SDT_PROBE(mib, linux_set_osname, return, 0, 0, 0, 0, 0); return (0); } void linux_get_osrelease(struct thread *td, char *dst) { - register struct prison *pr; + struct prison *pr; struct linux_prison *lpr; + LIN_SDT_PROBE(mib, linux_get_osrelease, entry, td, dst, 0, 0, 0); + pr = td->td_ucred->cr_prison; if (pr != NULL) { mtx_lock(&pr->pr_mtx); @@ -217,6 +347,8 @@ linux_get_osrelease(struct thread *td, c bcopy(lpr->pr_osrelease, dst, LINUX_MAX_UTSNAME); mtx_unlock(&pr->pr_mtx); + LIN_SDT_PROBE(mib, linux_get_osrelease, return, + 0, 0, 0, 0, 0); return; } } @@ -226,6 +358,8 @@ linux_get_osrelease(struct thread *td, c mtx_lock(&osname_lock); bcopy(linux_osrelease, dst, LINUX_MAX_UTSNAME); mtx_unlock(&osname_lock); + + LIN_SDT_PROBE(mib, linux_get_osrelease, return, 0, 0, 0, 0, 0); } int @@ -235,6 +369,8 @@ linux_use26(struct thread *td) struct linux_prison *lpr; int use26 = linux_use_linux26; + LIN_SDT_PROBE(mib, linux_use26, entry, td, 0, 0, 0, 0); + pr = td->td_ucred->cr_prison; if (pr != NULL) { if (pr->pr_linux != NULL) { @@ -242,17 +378,20 @@ linux_use26(struct thread *td) use26 = lpr->pr_use_linux26; } } - + + LIN_SDT_PROBE(mib, linux_use26, return, use26, 0, 0, 0, 0); return (use26); } -int +static int linux_set_osrelease(struct thread *td, char *osrelease) { struct prison *pr; struct linux_prison *lpr; int use26; + LIN_SDT_PROBE(mib, linux_set_osrelease, entry, td, osrelease, 0, 0, 0); + use26 = (strlen(osrelease) >= 3 && osrelease[2] == '6'); pr = linux_get_prison(td); @@ -268,16 +407,19 @@ linux_set_osrelease(struct thread *td, c mtx_unlock(&osname_lock); } + LIN_SDT_PROBE(mib, linux_set_osrelease, return, 0, 0, 0, 0, 0); return (0); } int linux_get_oss_version(struct thread *td) { - register struct prison *pr; - register struct linux_prison *lpr; + struct prison *pr; + struct linux_prison *lpr; int version; + LIN_SDT_PROBE(mib, linux_get_oss_version, entry, td, 0, 0, 0, 0); + pr = td->td_ucred->cr_prison; if (pr != NULL) { mtx_lock(&pr->pr_mtx); @@ -286,6 +428,8 @@ linux_get_oss_version(struct thread *td) if (lpr->pr_oss_version) { version = lpr->pr_oss_version; mtx_unlock(&pr->pr_mtx); + LIN_SDT_PROBE(mib, linux_get_oss_version, + return, version, 0, 0, 0, 0); return (version); } } @@ -295,15 +439,19 @@ linux_get_oss_version(struct thread *td) mtx_lock(&osname_lock); version = linux_oss_version; mtx_unlock(&osname_lock); + + LIN_SDT_PROBE(mib, linux_get_oss_version, return, version, 0, 0, 0, 0); return (version); } -int +static int linux_set_oss_version(struct thread *td, int oss_version) { struct prison *pr; struct linux_prison *lpr; + LIN_SDT_PROBE(mib, linux_set_oss_version, entry, td, oss_version, 0, 0, + 0); pr = linux_get_prison(td); if (pr != NULL) { lpr = (struct linux_prison *)pr->pr_linux; @@ -315,10 +463,12 @@ linux_set_oss_version(struct thread *td, mtx_unlock(&osname_lock); } + LIN_SDT_PROBE(mib, linux_set_oss_version, return, 0, 0, 0, 0, 0); return (0); } #ifdef DEBUG +/* XXX: can be removed when every ldebug(...) is removed. */ u_char linux_debug_map[howmany(LINUX_SYS_MAXSYSCALL, sizeof(u_char))]; Modified: user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.h ============================================================================== --- user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.h Fri Jan 9 13:06:56 2009 (r186948) +++ user/netchild/linuxulator-dtrace/src/sys/compat/linux/linux_mib.h Fri Jan 9 13:18:13 2009 (r186949) @@ -32,14 +32,8 @@ #define _LINUX_MIB_H_ void linux_get_osname(struct thread *td, char *dst); -int linux_set_osname(struct thread *td, char *osname); - void linux_get_osrelease(struct thread *td, char *dst); -int linux_set_osrelease(struct thread *td, char *osrelease); - int linux_get_oss_version(struct thread *td); -int linux_set_oss_version(struct thread *td, int oss_version); - int linux_use26(struct thread *td); #endif /* _LINUX_MIB_H_ */
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200901091318.n09DIDHa057784>