svn commit: r186949 -
user/netchild/linuxulator-dtrace/src/sys/compat/linux
Alexander Leidinger
netchild at FreeBSD.org
Fri Jan 9 05:18:13 PST 2009
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_ */
More information about the svn-src-user
mailing list