Stackless issue #300: correctly call audit hooks "sys.settrace" and "sys.setprofile"

- Don't call the audit hooks when switching tasklets.
- Add calls to tasklet_set_trace_function(),
  tasklet_set_profile_function() and tasklet_setstate().

Author: Anselm Kruis

Doc/library/stackless/tasklets.rst

@@ -444,6 +444,12 @@ The ``tasklet`` class
       the :class:`~contextvars.Context` object of the
       tasklet to the :class:`~contextvars.Context` object of the current tasklet.
 
+   .. versionchanged:: 3.8
+
+      If the state contains a trace- or profile-function :meth:`~__setstate__` now
+      raises an auditing event ``sys.settrace`` resp. ``sys.setprofile`` with
+      no arguments.
+
    :param state: the state as given by ``__reduce_ex__(...)[2]``
    :type state: :class:`tuple`
    :return: self
@@ -572,6 +578,11 @@ and thus may not be available in all |SLP| implementations.
    are the tasklet counterparts of the functions :func:`sys.settrace`,
    :func:`sys.gettrace`, :func:`sys.setprofile` and :func:`sys.getprofile`.
 
+   .. versionchanged:: 3.8
+
+      Assignments to these attributes now raise an auditing event
+      ``sys.settrace`` resp. ``sys.setprofile`` with no arguments.
+
 
 ^^^^^^^^^^^^^^^^^^
 Tasklet Life Cycle

Include/internal/pycore_stackless.h

@@ -736,9 +736,11 @@ PyObject * slp_async_gen_athrow_new(PyAsyncGenObject *gen);
 PyObject * slp_async_gen_athrow_setstate(PyObject *self, PyObject *args);
 
 /* debugging/monitoring */
-
 int slp_schedule_callback(PyTaskletObject *prev, PyTaskletObject *next);
+void slp_set_profile(Py_tracefunc func, PyObject *arg);
+void slp_set_trace(Py_tracefunc func, PyObject *arg);
 
+/* Stackless extension for types */
 int slp_prepare_slots(PyTypeObject*);
 
 Py_tracefunc slp_get_sys_profile_func(void);

Python/ceval.c

@@ -5253,7 +5253,14 @@ PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
     if (PySys_Audit("sys.setprofile", NULL) < 0) {
         return;
     }
+#ifdef STACKLESS
+    slp_set_profile(func, arg);
+}
 
+void
+slp_set_profile(Py_tracefunc func, PyObject *arg)
+{
+#endif
     PyThreadState *tstate = _PyThreadState_GET();
     PyObject *temp = tstate->c_profileobj;
     Py_XINCREF(arg);
@@ -5274,6 +5281,14 @@ PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
     if (PySys_Audit("sys.settrace", NULL) < 0) {
         return;
     }
+#ifdef STACKLESS
+    slp_set_trace(func, arg);
+}
+
+void
+slp_set_trace(Py_tracefunc func, PyObject *arg)
+{
+#endif
 
     _PyRuntimeState *runtime = &_PyRuntime;
     PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);

Stackless/changelog.txt

@@ -9,6 +9,12 @@ What's New in Stackless 3.X.X?
 
 *Release date: 20XX-XX-XX*
 
+- https://github.com/stackless-dev/stackless/issues/300
+  Assignments to 'tasklet.trace_function', 'tasklet.profile_function' now raise
+  an auditing event "sys.settrace" resp. "sys.setprofile" with no arguments.
+  Unpickling a tasklet with trace- or profile-function now raises an
+  auditing event "sys.settrace" resp. "sys.setprofile" with no arguments.
+
 - https://github.com/stackless-dev/stackless/issues/275
   Add limited support for the eval_frame-hook introduced by PEP-523.
   Stackless can't fully support all use-cases. Currently the hook can be used

Stackless/module/scheduling.c

@@ -622,7 +622,7 @@ Py_LOCAL_INLINE(void) SLP_UPDATE_TSTATE_ON_SWITCH(PyThreadState *tstate, PyTaskl
         Py_XINCREF(prev->profileobj);
         if (prev->profileobj)
             assert(Py_REFCNT(prev->profileobj) >= 2);  /* won't drop to zero in PyEval_SetProfile */
-        PyEval_SetProfile(next->profilefunc, next->profileobj);
+        slp_set_profile(next->profilefunc, next->profileobj);
         next->profilefunc = NULL;
         if (next->profileobj)
             assert(Py_REFCNT(next->profileobj) >= 2);  /* won't drop to zero */
@@ -642,7 +642,7 @@ Py_LOCAL_INLINE(void) SLP_UPDATE_TSTATE_ON_SWITCH(PyThreadState *tstate, PyTaskl
             assert(Py_REFCNT(prev->traceobj) >= 2);  /* won't drop to zero in PyEval_SetTrace */
         prev->tracing = tstate->tracing;
         tstate->tracing = next->tracing;
-        PyEval_SetTrace(next->tracefunc, next->traceobj);
+        slp_set_trace(next->tracefunc, next->traceobj);
         next->tracefunc = NULL;
         if (next->traceobj)
             assert(Py_REFCNT(next->traceobj) >= 2);  /* won't drop to zero */
@@ -682,7 +682,7 @@ Py_LOCAL_INLINE(void) SLP_UPDATE_TSTATE_ON_SWITCH(PyThreadState *tstate, PyTaskl
             Py_XINCREF(prev__->profileobj); \
             if (prev__->profileobj) \
                 assert(Py_REFCNT(prev__->profileobj) >= 2);  /* won't drop to zero in PyEval_SetProfile */ \
-            PyEval_SetProfile(next__->profilefunc, next__->profileobj); \
+            slp_set_profile(next__->profilefunc, next__->profileobj); \
             next__->profilefunc = NULL; \
             if (next__->profileobj) \
                 assert(Py_REFCNT(next__->profileobj) >= 2);  /* won't drop to zero */ \
@@ -701,7 +701,7 @@ Py_LOCAL_INLINE(void) SLP_UPDATE_TSTATE_ON_SWITCH(PyThreadState *tstate, PyTaskl
                 assert(Py_REFCNT(prev__->traceobj) >= 2);  /* won't drop to zero in PyEval_SetTrace */ \
             prev__->tracing = ts__->tracing; \
             ts__->tracing = next__->tracing; \
-            PyEval_SetTrace(next__->tracefunc, next__->traceobj); \
+            slp_set_trace(next__->tracefunc, next__->traceobj); \
             next__->tracefunc = NULL; \
             if (next__->traceobj) \
                 assert(Py_REFCNT(next__->traceobj) >= 2);  /* won't drop to zero */ \

Stackless/module/taskletobject.c

@@ -853,6 +853,20 @@ tasklet_setstate(PyObject *self, PyObject *args)
     }
 
     /* profile and tracing */
+    if ((c_functions & 1) || (Py_None != traceobj)) {
+        /* trace setting requested */
+        if (PySys_Audit("sys.settrace", NULL)) {
+            return NULL;
+        }
+    }
+
+    if ((c_functions & 2) || (Py_None != profileobj)) {
+        /* profile setting requested */
+        if (PySys_Audit("sys.setprofile", NULL)) {
+            return NULL;
+        }
+    }
+
     if (c_functions & 1) {
         Py_tracefunc func = slp_get_sys_trace_func();
         if (NULL == func)
@@ -2141,6 +2155,9 @@ tasklet_set_trace_function(PyTaskletObject *task, PyObject *value, void *closure
     PyThreadState *ts = task->cstate->tstate;
     Py_tracefunc tf = NULL;
 
+    if (PySys_Audit("sys.settrace", NULL)) {
+        return -1;
+    }
     if (Py_None == value)
         value = NULL;
     if (value) {
@@ -2152,7 +2169,7 @@ tasklet_set_trace_function(PyTaskletObject *task, PyObject *value, void *closure
         /* current tasklet */
         if (_PyThreadState_GET() != ts)
             RUNTIME_ERROR("You cannot set the trace function of the current tasklet of another thread", -1);
-        PyEval_SetTrace(tf, value);
+        slp_set_trace(tf, value);
         return 0;
     }
 
@@ -2182,6 +2199,9 @@ tasklet_set_profile_function(PyTaskletObject *task, PyObject *value, void *closu
     PyThreadState *ts = task->cstate->tstate;
     Py_tracefunc tf = NULL;
 
+    if (PySys_Audit("sys.setprofile", NULL)) {
+        return -1;
+    }
     if (Py_None == value)
         value = NULL;
     if (value) {
@@ -2193,7 +2213,7 @@ tasklet_set_profile_function(PyTaskletObject *task, PyObject *value, void *closu
         /* current tasklet */
         if (_PyThreadState_GET() != ts)
             RUNTIME_ERROR("You cannot set the profile function of the current tasklet of another thread", -1);
-        PyEval_SetProfile(tf, value);
+        slp_set_profile(tf, value);
         return 0;
     }