docs: public void fatalErrorNotification(ManagedConnectionFactory managedConnectionFactory, MCWrapper mcWrapper, Object affinity) {
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.entry(this, tc, "fatalErrorNotification");
          }
          requestingAccessToPool();
          if (mcWrapper != null) {
              mcWrapper.markStale();
          }
          if (gConfigProps.connectionPoolingEnabled) {
  
              if (gConfigProps.getPurgePolicy() != null) {
  
                  /*
                   * New with jdbc 4.1 support, if the connection was aborted, skip the entire pool connection purge.
                   */
                  boolean aborted = mcWrapper != null && mcWrapper.getManagedConnectionWithoutStateCheck() instanceof WSManagedConnection
                                    && ((WSManagedConnection) mcWrapper.getManagedConnectionWithoutStateCheck()).isAborted();
                  if (gConfigProps.getPurgePolicy() == PurgePolicy.EntirePool
                      && !aborted) {
  
                      // The remove parked connection code was delete here
                      // Reset fatalErrorNotificationTime and remove all free connections
                      ArrayList<MCWrapper> destroyMCWrappeList = new ArrayList<MCWrapper>();
                      synchronized (destroyMCWrapperListLock) {
  
                          for (int j = 0; j < gConfigProps.getMaxFreePoolHashSize(); ++j) {
  
                              //  ffdc uses this method ,,, and was locking freepool
                              // without locking
                              // waiter pool first, causing a deadlock.
                              synchronized (waiterFreePoolLock) {
                                  synchronized (freePool[j].freeConnectionLockObject) {
                                      /*
                                       * If a connection gets away, by setting
                                       * fatalErrorNotificationTime will guaranty when the
                                       * connection is returned to the free pool, it will be
                                       */
                                      freePool[j].incrementFatalErrorValue(j);
                                      /*
                                       * Move as many connections as we can in the free pool to
                                       * the destroy list
                                       */
                                      if (freePool[j].mcWrapperList.size() > 0) {
                                          // freePool[j].removeCleanupAndDestroyAllFreeConnections();
                                          int mcWrapperListIndex = freePool[j].mcWrapperList.size() - 1;
                                          for (int k = mcWrapperListIndex; k >= 0; --k) {
                                              MCWrapper mcw = (MCWrapper) freePool[j].mcWrapperList.remove(k);
                                              mcw.setPoolState(0);
                                              destroyMCWrappeList.add(mcw);
                                              --freePool[j].numberOfConnectionsAssignedToThisFreePool;
                                          }
  
                                      } // end if
  
                                  } // end free lock
                              } // end waiter lock
  
                          } // end for j
  
                      } // end syc for destroyMCWrapperListLock
                      /*
                       * we need to cleanup and destroy connections in the local
                       * destroy list.
                       */
                      for (int i = 0; i < destroyMCWrappeList.size(); ++i) {
  
                          MCWrapper mcw = destroyMCWrappeList.get(i);
                          freePool[0].cleanupAndDestroyMCWrapper(mcw);
                          this.totalConnectionCount.decrementAndGet();
  
                      }
  
                  } // end "EntirePool" purge policy
                  else {
                      /*
                       * We only need to check for the validating mcf support if purge
                       * policy is not "EntirePool" If the purge policy is "EntierPool" all
                       * of the connection will be destroyed. We will have no connection to
                       * validate.
                       *
                       * If ValidatingMCFSupported == true this code will attempt to cleanup
                       * and destroy the connections returned by the method
                       * getInvalidConnections().
                       *
                       * If the connection is active, the connections will be marked stale.
                       *
                       * New with jdbc 4.1 support, if the connection was aborted, skip the validate connections call.
                       */
                      if (gConfigProps.validatingMCFSupported
                          && !aborted) {
                          validateConnections(managedConnectionFactory, false);
                      }
                      /*
                       * Mark all connections to be pretested for
                       * purge policy = ValidateAllConnections. If pretest fails a new
                       * connection will be created. Moved to here and corrected to avoid
                       * marking empty wrappers --
                       *
                       */
                      if (gConfigProps.getPurgePolicy() == PurgePolicy.ValidateAllConnections) {
                          mcToMCWMapWrite.lock();
                          try {
                              Collection<MCWrapper> s = mcToMCWMap.values();
                              Iterator<MCWrapper> i = s.iterator();
                              while (i.hasNext()) {
                                  com.ibm.ejs.j2c.MCWrapper mcw = (com.ibm.ejs.j2c.MCWrapper) i.next();
                                  if (mcw.getState() != com.ibm.ejs.j2c.MCWrapper.STATE_INACTIVE) {
                                      mcw.setPretestThisConnection(true);
                                  }
                              }
                          } finally {
                              mcToMCWMapWrite.unlock();
                          }
                      }
                  } // end of PurgePolicy NOT EntirePool
              } // end of PurgePolicy not null
          } // end of connection pooling enabled
          else {
              /*
               *
               * Connection pooling in the free pool is disabled. No other proccessing
               * in this method is needed.
               */
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(this, tc, "Pooling disabled, fatal error processing completed.");
              }
          }
          activeRequest.decrementAndGet();
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(this, tc, "fatalErrorNotification");
          }
      }