src/test/modules/injection_points/injection_points.c

   1 /*--------------------------------------------------------------------------
   2  *
   3  * injection_points.c
   4  *              Code for testing injection points.
   5  *
   6  * Injection points are able to trigger user-defined callbacks in pre-defined
   7  * code paths.
   8  *
   9  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  10  * Portions Copyright (c) 1994, Regents of the University of California
  11  *
  12  * IDENTIFICATION
  13  *              src/test/modules/injection_points/injection_points.c
  14  *
  15  * -------------------------------------------------------------------------
  16  */
  17
  18 #include "postgres.h"
  19
  20 #include "fmgr.h"
  21 #include "miscadmin.h"
  22 #include "storage/condition_variable.h"
  23 #include "storage/dsm_registry.h"
  24 #include "storage/ipc.h"
  25 #include "storage/lwlock.h"
  26 #include "storage/shmem.h"
  27 #include "utils/builtins.h"
  28 #include "utils/injection_point.h"
  29 #include "utils/wait_event.h"
  30
  31 PG_MODULE_MAGIC;
  32
  33 /* Maximum number of waits usable in injection points at once */
  34 #define INJ_MAX_WAIT    8
  35 #define INJ_NAME_MAXLEN 64
  36 #define INJ_MAX_CONDITION       4
  37
  38 /*
  39  * Conditions related to injection points.  This tracks in shared memory the
  40  * runtime conditions under which an injection point is allowed to run.
  41  *
  42  * If more types of runtime conditions need to be tracked, this structure
  43  * should be expanded.
  44  */
  45 typedef struct InjectionPointCondition
  46 {
  47         /* Name of the injection point related to this condition */
  48         char            name[INJ_NAME_MAXLEN];
  49
  50         /* ID of the process where the injection point is allowed to run */
  51         int                     pid;
  52 } InjectionPointCondition;
  53
  54 /* Shared state information for injection points. */
  55 typedef struct InjectionPointSharedState
  56 {
  57         /* Protects access to other fields */
  58         slock_t         lock;
  59
  60         /* Counters advancing when injection_points_wakeup() is called */
  61         uint32          wait_counts[INJ_MAX_WAIT];
  62
  63         /* Names of injection points attached to wait counters */
  64         char            name[INJ_MAX_WAIT][INJ_NAME_MAXLEN];
  65
  66         /* Condition variable used for waits and wakeups */
  67         ConditionVariable wait_point;
  68
  69         /* Conditions to run an injection point */
  70         InjectionPointCondition conditions[INJ_MAX_CONDITION];
  71 } InjectionPointSharedState;
  72
  73 /* Pointer to shared-memory state. */
  74 static InjectionPointSharedState *inj_state = NULL;
  75
  76 extern PGDLLEXPORT void injection_error(const char *name);
  77 extern PGDLLEXPORT void injection_notice(const char *name);
  78 extern PGDLLEXPORT void injection_wait(const char *name);
  79
  80 /* track if injection points attached in this process are linked to it */
  81 static bool injection_point_local = false;
  82
  83 /*
  84  * Callback for shared memory area initialization.
  85  */
  86 static void
  87 injection_point_init_state(void *ptr)
  88 {
  89         InjectionPointSharedState *state = (InjectionPointSharedState *) ptr;
  90
  91         SpinLockInit(&state->lock);
  92         memset(state->wait_counts, 0, sizeof(state->wait_counts));
  93         memset(state->name, 0, sizeof(state->name));
  94         memset(state->conditions, 0, sizeof(state->conditions));
  95         ConditionVariableInit(&state->wait_point);
  96 }
  97
  98 /*
  99  * Initialize shared memory area for this module.
 100  */
 101 static void
 102 injection_init_shmem(void)
 103 {
 104         bool            found;
 105
 106         if (inj_state != NULL)
 107                 return;
 108
 109         inj_state = GetNamedDSMSegment("injection_points",
 110                                                                    sizeof(InjectionPointSharedState),
 111                                                                    injection_point_init_state,
 112                                                                    &found);
 113 }
 114
 115 /*
 116  * Check runtime conditions associated to an injection point.
 117  *
 118  * Returns true if the named injection point is allowed to run, and false
 119  * otherwise.  Multiple conditions can be associated to a single injection
 120  * point, so check them all.
 121  */
 122 static bool
 123 injection_point_allowed(const char *name)
 124 {
 125         bool            result = true;
 126
 127         if (inj_state == NULL)
 128                 injection_init_shmem();
 129
 130         SpinLockAcquire(&inj_state->lock);
 131
 132         for (int i = 0; i < INJ_MAX_CONDITION; i++)
 133         {
 134                 InjectionPointCondition *condition = &inj_state->conditions[i];
 135
 136                 if (strcmp(condition->name, name) == 0)
 137                 {
 138                         /*
 139                          * Check if this injection point is allowed to run in this
 140                          * process.
 141                          */
 142                         if (MyProcPid != condition->pid)
 143                         {
 144                                 result = false;
 145                                 break;
 146                         }
 147                 }
 148         }
 149
 150         SpinLockRelease(&inj_state->lock);
 151
 152         return result;
 153 }
 154
 155 /*
 156  * before_shmem_exit callback to remove injection points linked to a
 157  * specific process.
 158  */
 159 static void
 160 injection_points_cleanup(int code, Datum arg)
 161 {
 162         char            names[INJ_MAX_CONDITION][INJ_NAME_MAXLEN] = {0};
 163         int                     count = 0;
 164
 165         /* Leave if nothing is tracked locally */
 166         if (!injection_point_local)
 167                 return;
 168
 169         /*
 170          * This is done in three steps: detect the points to detach, detach them
 171          * and release their conditions.
 172          */
 173         SpinLockAcquire(&inj_state->lock);
 174         for (int i = 0; i < INJ_MAX_CONDITION; i++)
 175         {
 176                 InjectionPointCondition *condition = &inj_state->conditions[i];
 177
 178                 if (condition->name[0] == '\0')
 179                         continue;
 180
 181                 if (condition->pid != MyProcPid)
 182                         continue;
 183
 184                 /* Extract the point name to detach */
 185                 strlcpy(names[count], condition->name, INJ_NAME_MAXLEN);
 186                 count++;
 187         }
 188         SpinLockRelease(&inj_state->lock);
 189
 190         /* Detach, without holding the spinlock */
 191         for (int i = 0; i < count; i++)
 192                 InjectionPointDetach(names[i]);
 193
 194         /* Clear all the conditions */
 195         SpinLockAcquire(&inj_state->lock);
 196         for (int i = 0; i < INJ_MAX_CONDITION; i++)
 197         {
 198                 InjectionPointCondition *condition = &inj_state->conditions[i];
 199
 200                 if (condition->name[0] == '\0')
 201                         continue;
 202
 203                 if (condition->pid != MyProcPid)
 204                         continue;
 205
 206                 condition->name[0] = '\0';
 207                 condition->pid = 0;
 208         }
 209         SpinLockRelease(&inj_state->lock);
 210 }
 211
 212 /* Set of callbacks available to be attached to an injection point. */
 213 void
 214 injection_error(const char *name)
 215 {
 216         if (!injection_point_allowed(name))
 217                 return;
 218
 219         elog(ERROR, "error triggered for injection point %s", name);
 220 }
 221
 222 void
 223 injection_notice(const char *name)
 224 {
 225         if (!injection_point_allowed(name))
 226                 return;
 227
 228         elog(NOTICE, "notice triggered for injection point %s", name);
 229 }
 230
 231 /* Wait on a condition variable, awaken by injection_points_wakeup() */
 232 void
 233 injection_wait(const char *name)
 234 {
 235         uint32          old_wait_counts = 0;
 236         int                     index = -1;
 237         uint32          injection_wait_event = 0;
 238
 239         if (inj_state == NULL)
 240                 injection_init_shmem();
 241
 242         if (!injection_point_allowed(name))
 243                 return;
 244
 245         /*
 246          * Use the injection point name for this custom wait event.  Note that
 247          * this custom wait event name is not released, but we don't care much for
 248          * testing as this should be short-lived.
 249          */
 250         injection_wait_event = WaitEventExtensionNew(name);
 251
 252         /*
 253          * Find a free slot to wait for, and register this injection point's name.
 254          */
 255         SpinLockAcquire(&inj_state->lock);
 256         for (int i = 0; i < INJ_MAX_WAIT; i++)
 257         {
 258                 if (inj_state->name[i][0] == '\0')
 259                 {
 260                         index = i;
 261                         strlcpy(inj_state->name[i], name, INJ_NAME_MAXLEN);
 262                         old_wait_counts = inj_state->wait_counts[i];
 263                         break;
 264                 }
 265         }
 266         SpinLockRelease(&inj_state->lock);
 267
 268         if (index < 0)
 269                 elog(ERROR, "could not find free slot for wait of injection point %s ",
 270                          name);
 271
 272         /* And sleep.. */
 273         ConditionVariablePrepareToSleep(&inj_state->wait_point);
 274         for (;;)
 275         {
 276                 uint32          new_wait_counts;
 277
 278                 SpinLockAcquire(&inj_state->lock);
 279                 new_wait_counts = inj_state->wait_counts[index];
 280                 SpinLockRelease(&inj_state->lock);
 281
 282                 if (old_wait_counts != new_wait_counts)
 283                         break;
 284                 ConditionVariableSleep(&inj_state->wait_point, injection_wait_event);
 285         }
 286         ConditionVariableCancelSleep();
 287
 288         /* Remove this injection point from the waiters. */
 289         SpinLockAcquire(&inj_state->lock);
 290         inj_state->name[index][0] = '\0';
 291         SpinLockRelease(&inj_state->lock);
 292 }
 293
 294 /*
 295  * SQL function for creating an injection point.
 296  */
 297 PG_FUNCTION_INFO_V1(injection_points_attach);
 298 Datum
 299 injection_points_attach(PG_FUNCTION_ARGS)
 300 {
 301         char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 302         char       *action = text_to_cstring(PG_GETARG_TEXT_PP(1));
 303         char       *function;
 304
 305         if (strcmp(action, "error") == 0)
 306                 function = "injection_error";
 307         else if (strcmp(action, "notice") == 0)
 308                 function = "injection_notice";
 309         else if (strcmp(action, "wait") == 0)
 310                 function = "injection_wait";
 311         else
 312                 elog(ERROR, "incorrect action \"%s\" for injection point creation", action);
 313
 314         InjectionPointAttach(name, "injection_points", function);
 315
 316         if (injection_point_local)
 317         {
 318                 int                     index = -1;
 319
 320                 /*
 321                  * Register runtime condition to link this injection point to the
 322                  * current process.
 323                  */
 324                 SpinLockAcquire(&inj_state->lock);
 325                 for (int i = 0; i < INJ_MAX_CONDITION; i++)
 326                 {
 327                         InjectionPointCondition *condition = &inj_state->conditions[i];
 328
 329                         if (condition->name[0] == '\0')
 330                         {
 331                                 index = i;
 332                                 strlcpy(condition->name, name, INJ_NAME_MAXLEN);
 333                                 condition->pid = MyProcPid;
 334                                 break;
 335                         }
 336                 }
 337                 SpinLockRelease(&inj_state->lock);
 338
 339                 if (index < 0)
 340                         elog(FATAL,
 341                                  "could not find free slot for condition of injection point %s",
 342                                  name);
 343         }
 344
 345         PG_RETURN_VOID();
 346 }
 347
 348 /*
 349  * SQL function for triggering an injection point.
 350  */
 351 PG_FUNCTION_INFO_V1(injection_points_run);
 352 Datum
 353 injection_points_run(PG_FUNCTION_ARGS)
 354 {
 355         char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 356
 357         INJECTION_POINT(name);
 358
 359         PG_RETURN_VOID();
 360 }
 361
 362 /*
 363  * SQL function for waking up an injection point waiting in injection_wait().
 364  */
 365 PG_FUNCTION_INFO_V1(injection_points_wakeup);
 366 Datum
 367 injection_points_wakeup(PG_FUNCTION_ARGS)
 368 {
 369         char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 370         int                     index = -1;
 371
 372         if (inj_state == NULL)
 373                 injection_init_shmem();
 374
 375         /* First bump the wait counter for the injection point to wake up */
 376         SpinLockAcquire(&inj_state->lock);
 377         for (int i = 0; i < INJ_MAX_WAIT; i++)
 378         {
 379                 if (strcmp(name, inj_state->name[i]) == 0)
 380                 {
 381                         index = i;
 382                         break;
 383                 }
 384         }
 385         if (index < 0)
 386         {
 387                 SpinLockRelease(&inj_state->lock);
 388                 elog(ERROR, "could not find injection point %s to wake up", name);
 389         }
 390         inj_state->wait_counts[index]++;
 391         SpinLockRelease(&inj_state->lock);
 392
 393         /* And broadcast the change to the waiters */
 394         ConditionVariableBroadcast(&inj_state->wait_point);
 395         PG_RETURN_VOID();
 396 }
 397
 398 /*
 399  * injection_points_set_local
 400  *
 401  * Track if any injection point created in this process ought to run only
 402  * in this process.  Such injection points are detached automatically when
 403  * this process exits.  This is useful to make test suites concurrent-safe.
 404  */
 405 PG_FUNCTION_INFO_V1(injection_points_set_local);
 406 Datum
 407 injection_points_set_local(PG_FUNCTION_ARGS)
 408 {
 409         /* Enable flag to add a runtime condition based on this process ID */
 410         injection_point_local = true;
 411
 412         if (inj_state == NULL)
 413                 injection_init_shmem();
 414
 415         /*
 416          * Register a before_shmem_exit callback to remove any injection points
 417          * linked to this process.
 418          */
 419         before_shmem_exit(injection_points_cleanup, (Datum) 0);
 420
 421         PG_RETURN_VOID();
 422 }
 423
 424 /*
 425  * SQL function for dropping an injection point.
 426  */
 427 PG_FUNCTION_INFO_V1(injection_points_detach);
 428 Datum
 429 injection_points_detach(PG_FUNCTION_ARGS)
 430 {
 431         char       *name = text_to_cstring(PG_GETARG_TEXT_PP(0));
 432
 433         InjectionPointDetach(name);
 434
 435         if (inj_state == NULL)
 436                 injection_init_shmem();
 437
 438         /* Clean up any conditions associated to this injection point */
 439         SpinLockAcquire(&inj_state->lock);
 440         for (int i = 0; i < INJ_MAX_CONDITION; i++)
 441         {
 442                 InjectionPointCondition *condition = &inj_state->conditions[i];
 443
 444                 if (strcmp(condition->name, name) == 0)
 445                 {
 446                         condition->pid = 0;
 447                         condition->name[0] = '\0';
 448                 }
 449         }
 450         SpinLockRelease(&inj_state->lock);
 451
 452         PG_RETURN_VOID();
 453 }