¿Cómo puedo matar un pthread que está en un bucle infinito, desde fuera de ese bucle?

Como @sarnold señaló, por defecto su hilo no se puede cancelar con pthread_cancel() sin llamar a ninguna función que sea puntos de cancelación... pero esto se puede cambiar usando pthread_setcanceltype() para establecer el tipo de cancelación del hilo en asíncrono en lugar de diferido. Para hacer eso, agregarías algo como pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL); cerca del inicio de tu función de subproceso, antes de iniciar el bucle. Entonces podrías terminar el hilo llamando a pthread_cancel(th) desde main().

Tenga en cuenta, sin embargo, que la cancelación hilos de esta manera (ya sea asíncrono o no) no limpia los recursos asignados en la función de hilo (como señaló Kevin en un comentario). Para hacer esto limpiamente, usted puede:

• Asegúrese de que el subproceso no haga nada que necesite limpiar antes de salir (por ejemplo, usando malloc() para asignar un búfer)
• Asegúrese de que tiene alguna forma de limpiar después del hilo en otro lugar, después de que el hilo salga
• Use pthread_cleanup_push() y pthread_cleanup_pop() para agregar controladores de limpieza para limpiar recursos cuando se cancela el hilo. Tenga en cuenta que esto sigue siendo arriesgado si el tipo de cancelación es asíncrono, porque el subproceso podría cancelarse entre la asignación de un recurso y la adición del controlador de limpieza.
• Evite usar pthread_cancel() y haga que el subproceso verifique alguna condición para determinar cuándo terminar (lo que se verificaría en bucles de larga duración). Dado que su hilo comprueba la terminación en sí, puede hacer cualquier limpieza que necesite después de la comprobación.

Uno la forma de implementar la última opción es usar un mutex como indicador, y probarlo con pthread_mutex_trylock() envuelto en una función para usar en las pruebas de bucle:

#include <pthread.h>
#include <unistd.h>
#include <errno.h>

/* Returns 1 (true) if the mutex is unlocked, which is the
 * thread's signal to terminate. 
 */
int needQuit(pthread_mutex_t *mtx)
{
  switch(pthread_mutex_trylock(mtx)) {
    case 0: /* if we got the lock, unlock and return 1 (true) */
      pthread_mutex_unlock(mtx);
      return 1;
    case EBUSY: /* return 0 (false) if the mutex was locked */
      return 0;
  }
  return 1;
}

/* Thread function, containing a loop that's infinite except that it checks for
 * termination with needQuit() 
 */
void *thread_do(void *arg)
{
  pthread_mutex_t *mx = arg;
  while( !needQuit(mx) ) {}
  return NULL;
}

int main(int argc, char *argv[])
{
  pthread_t th;
  pthread_mutex_t mxq; /* mutex used as quit flag */

  /* init and lock the mutex before creating the thread.  As long as the
     mutex stays locked, the thread should keep running.  A pointer to the
     mutex is passed as the argument to the thread function. */
  pthread_mutex_init(&mxq,NULL);
  pthread_mutex_lock(&mxq);
  pthread_create(&th,NULL,thread_do,&mxq);

  sleep(2);

  /* unlock mxq to tell the thread to terminate, then join the thread */
  pthread_mutex_unlock(&mxq); 
  pthread_join(th,NULL);

  sleep(2);
  return 0;
}

Si el subproceso no está separado (generalmente no lo está por defecto), debe llamar a pthread_join() después de detener el subproceso. Si el hilo está separado, no necesitas unirlo, pero no sabrás exactamente cuándo termina (o incluso aproximadamente, a menos que agregues otra forma de indicar su salida).