RaiseAsync.c 31.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
/* ---------------------------------------------------------------------------
 *
 * (c) The GHC Team, 1998-2006
 *
 * Asynchronous exceptions
 *
 * --------------------------------------------------------------------------*/

#include "PosixSource.h"
#include "Rts.h"
Simon Marlow's avatar
Simon Marlow committed
11
12

#include "sm/Storage.h"
13
14
15
#include "Threads.h"
#include "Trace.h"
#include "RaiseAsync.h"
16
#include "Schedule.h"
17
18
#include "Updates.h"
#include "STM.h"
Simon Marlow's avatar
Simon Marlow committed
19
#include "sm/Sanity.h"
20
#include "Profiling.h"
21
#include "Messages.h"
22
23
24
#if defined(mingw32_HOST_OS)
#include "win32/IOManager.h"
#endif
25

26
27
28
29
30
static StgTSO* raiseAsync (Capability *cap,
                           StgTSO *tso,
                           StgClosure *exception,
                           rtsBool stop_at_atomically,
                           StgUpdateFrame *stop_here);
31
32
33

static void removeFromQueues(Capability *cap, StgTSO *tso);

34
35
static void removeFromMVarBlockedQueue (StgTSO *tso);

36
37
static void blockedThrowTo (Capability *cap, 
                            StgTSO *target, MessageThrowTo *msg);
38

39
40
41
42
static void throwToSendMsg (Capability *cap USED_IF_THREADS,
                            Capability *target_cap USED_IF_THREADS, 
                            MessageThrowTo *msg USED_IF_THREADS);

43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
/* -----------------------------------------------------------------------------
   throwToSingleThreaded

   This version of throwTo is safe to use if and only if one of the
   following holds:
   
     - !THREADED_RTS

     - all the other threads in the system are stopped (eg. during GC).

     - we surely own the target TSO (eg. we just took it from the
       run queue of the current capability, or we are running it).

   It doesn't cater for blocking the source thread until the exception
   has been raised.
   -------------------------------------------------------------------------- */

Simon Marlow's avatar
Simon Marlow committed
60
61
62
static void
throwToSingleThreaded__ (Capability *cap, StgTSO *tso, StgClosure *exception, 
                         rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
63
64
65
{
    // Thread already dead?
    if (tso->what_next == ThreadComplete || tso->what_next == ThreadKilled) {
66
        return;
67
68
69
70
71
    }

    // Remove it from any blocking queues
    removeFromQueues(cap,tso);

Simon Marlow's avatar
Simon Marlow committed
72
    raiseAsync(cap, tso, exception, stop_at_atomically, stop_here);
73
74
75
}

void
Simon Marlow's avatar
Simon Marlow committed
76
throwToSingleThreaded (Capability *cap, StgTSO *tso, StgClosure *exception)
77
{
Simon Marlow's avatar
Simon Marlow committed
78
79
    throwToSingleThreaded__(cap, tso, exception, rtsFalse, NULL);
}
80

Simon Marlow's avatar
Simon Marlow committed
81
void
82
throwToSingleThreaded_ (Capability *cap, StgTSO *tso, StgClosure *exception,
Simon Marlow's avatar
Simon Marlow committed
83
84
85
86
                        rtsBool stop_at_atomically)
{
    throwToSingleThreaded__ (cap, tso, exception, stop_at_atomically, NULL);
}
87

88
void // cannot return a different TSO
Simon Marlow's avatar
Simon Marlow committed
89
90
91
suspendComputation (Capability *cap, StgTSO *tso, StgUpdateFrame *stop_here)
{
    throwToSingleThreaded__ (cap, tso, NULL, rtsFalse, stop_here);
92
93
94
95
96
97
98
99
100
101
102
}

/* -----------------------------------------------------------------------------
   throwTo

   This function may be used to throw an exception from one thread to
   another, during the course of normal execution.  This is a tricky
   task: the target thread might be running on another CPU, or it
   may be blocked and could be woken up at any point by another CPU.
   We have some delicate synchronisation to do.

103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
   The underlying scheme when multiple Capabilities are in use is
   message passing: when the target of a throwTo is on another
   Capability, we send a message (a MessageThrowTo closure) to that
   Capability.

   If the throwTo needs to block because the target TSO is masking
   exceptions (the TSO_BLOCKEX flag), then the message is placed on
   the blocked_exceptions queue attached to the target TSO.  When the
   target TSO enters the unmasked state again, it must check the
   queue.  The blocked_exceptions queue is not locked; only the
   Capability owning the TSO may modify it.

   To make things simpler for throwTo, we always create the message
   first before deciding what to do.  The message may get sent, or it
   may get attached to a TSO's blocked_exceptions queue, or the
   exception may get thrown immediately and the message dropped,
   depending on the current state of the target.

   Currently we send a message if the target belongs to another
   Capability, and it is

124
     - NotBlocked, BlockedOnMsgThrowTo,
125
       BlockedOnCCall_Interruptible
126
127
128
129
130
131
132
133
134

     - or it is masking exceptions (TSO_BLOCKEX)

   Currently, if the target is BlockedOnMVar, BlockedOnSTM, or
   BlockedOnBlackHole then we acquire ownership of the TSO by locking
   its parent container (e.g. the MVar) and then raise the exception.
   We might change these cases to be more message-passing-like in the
   future.
  
135
136
   Returns: 

137
   NULL               exception was raised, ok to continue
138

139
140
141
142
143
144
145
   MessageThrowTo *   exception was not raised; the source TSO
                      should now put itself in the state 
                      BlockedOnMsgThrowTo, and when it is ready
                      it should unlock the mssage using
                      unlockClosure(msg, &stg_MSG_THROWTO_info);
                      If it decides not to raise the exception after
                      all, it can revoke it safely with
146
                      unlockClosure(msg, &stg_MSG_NULL_info);
147
148
149

   -------------------------------------------------------------------------- */

150
MessageThrowTo *
151
throwTo (Capability *cap,	// the Capability we hold 
152
	 StgTSO *source,	// the TSO sending the exception (or NULL)
153
	 StgTSO *target,        // the TSO receiving the exception
154
155
156
157
158
159
160
	 StgClosure *exception) // the exception closure
{
    MessageThrowTo *msg;

    msg = (MessageThrowTo *) allocate(cap, sizeofW(MessageThrowTo));
    // message starts locked; the caller has to unlock it when it is
    // ready.
161
    SET_HDR(msg, &stg_WHITEHOLE_info, CCS_SYSTEM);
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
    msg->source      = source;
    msg->target      = target;
    msg->exception   = exception;

    switch (throwToMsg(cap, msg))
    {
    case THROWTO_SUCCESS:
        return NULL;
    case THROWTO_BLOCKED:
    default:
        return msg;
    }
}
    

nat
throwToMsg (Capability *cap, MessageThrowTo *msg)
179
180
{
    StgWord status;
181
    StgTSO *target = msg->target;
182
    Capability *target_cap;
183

184
185
186
187
188
189
190
    goto check_target;

retry:
    write_barrier();
    debugTrace(DEBUG_sched, "throwTo: retrying...");

check_target:
Simon Marlow's avatar
Simon Marlow committed
191
192
    ASSERT(target != END_TSO_QUEUE);

193
194
195
196
    // Thread already dead?
    if (target->what_next == ThreadComplete 
	|| target->what_next == ThreadKilled) {
	return THROWTO_SUCCESS;
197
198
    }

199
200
201
202
    debugTraceCap(DEBUG_sched, cap,
                  "throwTo: from thread %lu to thread %lu",
                  (unsigned long)msg->source->id, 
                  (unsigned long)msg->target->id);
203
204

#ifdef DEBUG
205
    traceThreadStatus(DEBUG_sched, target);
206
207
#endif

208
209
210
211
    target_cap = target->cap;
    if (target->cap != cap) {
        throwToSendMsg(cap, target_cap, msg);
        return THROWTO_BLOCKED;
212
213
214
215
216
217
218
    }

    status = target->why_blocked;
    
    switch (status) {
    case NotBlocked:
    {
219
220
221
222
        if ((target->flags & TSO_BLOCKEX) == 0) {
            // It's on our run queue and not blocking exceptions
            raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
            return THROWTO_SUCCESS;
223
        } else {
224
225
            blockedThrowTo(cap,target,msg);
            return THROWTO_BLOCKED;
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
        }
    }

    case BlockedOnMsgThrowTo:
    {
        const StgInfoTable *i;
        MessageThrowTo *m;

        m = target->block_info.throwto;

        // target is local to this cap, but has sent a throwto
        // message to another cap.
        //
        // The source message is locked.  We need to revoke the
        // target's message so that we can raise the exception, so
        // we attempt to lock it.

        // There's a possibility of a deadlock if two threads are both
        // trying to throwTo each other (or more generally, a cycle of
        // threads).  To break the symmetry we compare the addresses
        // of the MessageThrowTo objects, and the one for which m <
        // msg gets to spin, while the other can only try to lock
        // once, but must then back off and unlock both before trying
        // again.
        if (m < msg) {
            i = lockClosure((StgClosure *)m);
        } else {
            i = tryLockClosure((StgClosure *)m);
            if (i == NULL) {
//            debugBelch("collision\n");
                throwToSendMsg(cap, target->cap, msg);
                return THROWTO_BLOCKED;
            }
        }

261
262
263
264
265
        if (i == &stg_MSG_NULL_info) {
            // we know there's a MSG_TRY_WAKEUP on the way, so we
            // might as well just do it now.  The message will
            // be a no-op when it arrives.
            unlockClosure((StgClosure*)m, i);
266
            tryWakeupThread(cap, target);
267
268
269
            goto retry;
        }

270
        if (i != &stg_MSG_THROWTO_info) {
271
            // if it's a MSG_NULL, this TSO has been woken up by another Cap
272
273
274
275
276
277
278
279
280
281
282
283
            unlockClosure((StgClosure*)m, i);
            goto retry;
        }

	if ((target->flags & TSO_BLOCKEX) &&
	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
            unlockClosure((StgClosure*)m, i);
            blockedThrowTo(cap,target,msg);
            return THROWTO_BLOCKED;
        }

        // nobody else can wake up this TSO after we claim the message
284
        doneWithMsgThrowTo(m);
285
286
287

        raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
        return THROWTO_SUCCESS;
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
    }

    case BlockedOnMVar:
    {
	/*
	  To establish ownership of this TSO, we need to acquire a
	  lock on the MVar that it is blocked on.
	*/
	StgMVar *mvar;
	StgInfoTable *info USED_IF_THREADS;
	
	mvar = (StgMVar *)target->block_info.closure;

	// ASSUMPTION: tso->block_info must always point to a
	// closure.  In the threaded RTS it does.
303
304
305
306
307
308
309
        switch (get_itbl(mvar)->type) {
        case MVAR_CLEAN:
        case MVAR_DIRTY:
            break;
        default:
            goto retry;
        }
310
311
312

	info = lockClosure((StgClosure *)mvar);

313
        // we have the MVar, let's check whether the thread
314
315
316
317
318
319
320
	// is still blocked on the same MVar.
	if (target->why_blocked != BlockedOnMVar
	    || (StgMVar *)target->block_info.closure != mvar) {
	    unlockClosure((StgClosure *)mvar, info);
	    goto retry;
	}

321
322
323
324
325
326
        if (target->_link == END_TSO_QUEUE) {
            // the MVar operation has already completed.  There is a
            // MSG_TRY_WAKEUP on the way, but we can just wake up the
            // thread now anyway and ignore the message when it
            // arrives.
	    unlockClosure((StgClosure *)mvar, info);
327
            tryWakeupThread(cap, target);
328
329
330
            goto retry;
        }

331
332
	if ((target->flags & TSO_BLOCKEX) &&
	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
333
            blockedThrowTo(cap,target,msg);
334
	    unlockClosure((StgClosure *)mvar, info);
335
	    return THROWTO_BLOCKED;
336
	} else {
337
338
            // revoke the MVar operation
            removeFromMVarBlockedQueue(target);
339
	    raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
340
	    unlockClosure((StgClosure *)mvar, info);
341
342
343
344
345
346
	    return THROWTO_SUCCESS;
	}
    }

    case BlockedOnBlackHole:
    {
347
348
349
350
351
352
353
354
355
356
357
358
359
360
	if (target->flags & TSO_BLOCKEX) {
            // BlockedOnBlackHole is not interruptible.
            blockedThrowTo(cap,target,msg);
	    return THROWTO_BLOCKED;
	} else {
            // Revoke the message by replacing it with IND. We're not
            // locking anything here, so we might still get a TRY_WAKEUP
            // message from the owner of the blackhole some time in the
            // future, but that doesn't matter.
            ASSERT(target->block_info.bh->header.info == &stg_MSG_BLACKHOLE_info);
            OVERWRITE_INFO(target->block_info.bh, &stg_IND_info);
            raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
            return THROWTO_SUCCESS;
        }
361
362
363
    }

    case BlockedOnSTM:
364
365
366
367
	lockTSO(target);
	// Unblocking BlockedOnSTM threads requires the TSO to be
	// locked; see STM.c:unpark_tso().
	if (target->why_blocked != BlockedOnSTM) {
368
	    unlockTSO(target);
369
370
371
372
	    goto retry;
	}
	if ((target->flags & TSO_BLOCKEX) &&
	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
373
            blockedThrowTo(cap,target,msg);
374
	    unlockTSO(target);
375
376
	    return THROWTO_BLOCKED;
	} else {
377
	    raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
378
379
380
	    unlockTSO(target);
	    return THROWTO_SUCCESS;
	}
381

382
383
384
385
386
387
388
389
390
391
392
393
394
    case BlockedOnCCall_Interruptible:
#ifdef THREADED_RTS
    {
        Task *task = NULL;
        // walk suspended_ccalls to find the correct worker thread
        InCall *incall;
        for (incall = cap->suspended_ccalls; incall != NULL; incall = incall->next) {
            if (incall->suspended_tso == target) {
                task = incall->task;
                break;
            }
        }
        if (task != NULL) {
395
            blockedThrowTo(cap, target, msg);
Simon Marlow's avatar
Simon Marlow committed
396
397
            if (!((target->flags & TSO_BLOCKEX) &&
                  ((target->flags & TSO_INTERRUPTIBLE) == 0))) {
398
399
400
                interruptWorkerTask(task);
            }
            return THROWTO_BLOCKED;
401
402
403
404
405
406
        } else {
            debugTraceCap(DEBUG_sched, cap, "throwTo: could not find worker thread to kill");
        }
        // fall to next
    }
#endif
407
    case BlockedOnCCall:
408
	blockedThrowTo(cap,target,msg);
409
410
411
412
413
414
	return THROWTO_BLOCKED;

#ifndef THREADEDED_RTS
    case BlockedOnRead:
    case BlockedOnWrite:
    case BlockedOnDelay:
415
416
417
#if defined(mingw32_HOST_OS)
    case BlockedOnDoProc:
#endif
418
419
	if ((target->flags & TSO_BLOCKEX) &&
	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
420
	    blockedThrowTo(cap,target,msg);
421
422
423
	    return THROWTO_BLOCKED;
	} else {
	    removeFromQueues(cap,target);
424
	    raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
425
426
427
428
	    return THROWTO_SUCCESS;
	}
#endif

429
430
431
432
433
434
435
436
437
438
439
440
    case ThreadMigrating:
        // if is is ThreadMigrating and tso->cap is ours, then it
        // *must* be migrating *to* this capability.  If it were
        // migrating away from the capability, then tso->cap would
        // point to the destination.
        //
        // There is a MSG_WAKEUP in the message queue for this thread,
        // but we can just do it preemptively:
        tryWakeupThread(cap, target);
        // and now retry, the thread should be runnable.
        goto retry;

441
    default:
442
        barf("throwTo: unrecognised why_blocked (%d)", target->why_blocked);
443
444
445
446
447
    }
    barf("throwTo");
}

static void
448
449
450
451
throwToSendMsg (Capability *cap STG_UNUSED,
                Capability *target_cap USED_IF_THREADS, 
                MessageThrowTo *msg USED_IF_THREADS)
            
452
{
453
#ifdef THREADED_RTS
454
    debugTraceCap(DEBUG_sched, cap, "throwTo: sending a throwto message to cap %lu", (unsigned long)target_cap->no);
455

456
    sendMessage(cap, target_cap, (Message*)msg);
457
458
#endif
}
459

460
461
462
463
464
// Block a throwTo message on the target TSO's blocked_exceptions
// queue.  The current Capability must own the target TSO in order to
// modify the blocked_exceptions queue.
static void
blockedThrowTo (Capability *cap, StgTSO *target, MessageThrowTo *msg)
465
{
466
467
468
469
470
    debugTraceCap(DEBUG_sched, cap, "throwTo: blocking on thread %lu",
                  (unsigned long)target->id);

    ASSERT(target->cap == cap);

471
    msg->link = target->blocked_exceptions;
472
473
    target->blocked_exceptions = msg;
    dirty_TSO(cap,target); // we modified the blocked_exceptions queue
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
}

/* -----------------------------------------------------------------------------
   Waking up threads blocked in throwTo

   There are two ways to do this: maybePerformBlockedException() will
   perform the throwTo() for the thread at the head of the queue
   immediately, and leave the other threads on the queue.
   maybePerformBlockedException() also checks the TSO_BLOCKEX flag
   before raising an exception.

   awakenBlockedExceptionQueue() will wake up all the threads in the
   queue, but not perform any throwTo() immediately.  This might be
   more appropriate when the target thread is the one actually running
   (see Exception.cmm).
489
490

   Returns: non-zero if an exception was raised, zero otherwise.
491
492
   -------------------------------------------------------------------------- */

493
int
494
495
maybePerformBlockedException (Capability *cap, StgTSO *tso)
{
496
497
    MessageThrowTo *msg;
    const StgInfoTable *i;
498
499
    StgTSO *source;

500
    if (tso->what_next == ThreadComplete || tso->what_next == ThreadFinished) {
501
        if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE) {
502
503
504
505
506
507
508
            awakenBlockedExceptionQueue(cap,tso);
            return 1;
        } else {
            return 0;
        }
    }

509
    if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE && 
Simon Marlow's avatar
Simon Marlow committed
510
        (tso->flags & TSO_BLOCKEX) != 0) {
511
        debugTraceCap(DEBUG_sched, cap, "throwTo: thread %lu has blocked exceptions but is inside block", (unsigned long)tso->id);
Simon Marlow's avatar
Simon Marlow committed
512
513
    }

514
    if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE
515
516
517
518
519
	&& ((tso->flags & TSO_BLOCKEX) == 0
	    || ((tso->flags & TSO_INTERRUPTIBLE) && interruptible(tso)))) {

	// We unblock just the first thread on the queue, and perform
	// its throw immediately.
520
521
522
523
524
    loop:
        msg = tso->blocked_exceptions;
        if (msg == END_BLOCKED_EXCEPTIONS_QUEUE) return 0;
        i = lockClosure((StgClosure*)msg);
        tso->blocked_exceptions = (MessageThrowTo*)msg->link;
525
        if (i == &stg_MSG_NULL_info) {
526
527
528
529
            unlockClosure((StgClosure*)msg,i);
            goto loop;
        }

530
        throwToSingleThreaded(cap, msg->target, msg->exception);
531
532
533
        source = msg->source;
        doneWithMsgThrowTo(msg);
        tryWakeupThread(cap, source);
534
        return 1;
535
    }
536
    return 0;
537
538
}

Simon Marlow's avatar
Simon Marlow committed
539
// awakenBlockedExceptionQueue(): Just wake up the whole queue of
540
// blocked exceptions.
Simon Marlow's avatar
Simon Marlow committed
541

542
543
544
void
awakenBlockedExceptionQueue (Capability *cap, StgTSO *tso)
{
545
546
    MessageThrowTo *msg;
    const StgInfoTable *i;
547
    StgTSO *source;
548
549
550
551

    for (msg = tso->blocked_exceptions; msg != END_BLOCKED_EXCEPTIONS_QUEUE;
         msg = (MessageThrowTo*)msg->link) {
        i = lockClosure((StgClosure *)msg);
552
        if (i != &stg_MSG_NULL_info) {
553
554
555
            source = msg->source;
            doneWithMsgThrowTo(msg);
            tryWakeupThread(cap, source);
556
557
        } else {
            unlockClosure((StgClosure *)msg,i);
558
559
560
        }
    }
    tso->blocked_exceptions = END_BLOCKED_EXCEPTIONS_QUEUE;
561
562
563
564
565
566
567
}    

/* -----------------------------------------------------------------------------
   Remove a thread from blocking queues.

   This is for use when we raise an exception in another thread, which
   may be blocked.
568

569
570
   Precondition: we have exclusive access to the TSO, via the same set
   of conditions as throwToSingleThreaded() (c.f.).
571
572
   -------------------------------------------------------------------------- */

573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
static void
removeFromMVarBlockedQueue (StgTSO *tso)
{
    StgMVar *mvar = (StgMVar*)tso->block_info.closure;
    StgMVarTSOQueue *q = (StgMVarTSOQueue*)tso->_link;

    if (q == (StgMVarTSOQueue*)END_TSO_QUEUE) {
        // already removed from this MVar
        return;
    }

    // Assume the MVar is locked. (not assertable; sometimes it isn't
    // actually WHITEHOLE'd).

    // We want to remove the MVAR_TSO_QUEUE object from the queue.  It
    // isn't doubly-linked so we can't actually remove it; instead we
    // just overwrite it with an IND if possible and let the GC short
    // it out.  However, we have to be careful to maintain the deque
    // structure:

    if (mvar->head == q) {
        mvar->head = q->link;
Simon Marlow's avatar
Simon Marlow committed
595
        OVERWRITE_INFO(q, &stg_IND_info);
596
597
598
599
600
601
602
603
604
        if (mvar->tail == q) {
            mvar->tail = (StgMVarTSOQueue*)END_TSO_QUEUE;
        }
    }
    else if (mvar->tail == q) {
        // we can't replace it with an IND in this case, because then
        // we lose the tail pointer when the GC shorts out the IND.
        // So we use MSG_NULL as a kind of non-dupable indirection;
        // these are ignored by takeMVar/putMVar.
Simon Marlow's avatar
Simon Marlow committed
605
        OVERWRITE_INFO(q, &stg_MSG_NULL_info);
606
607
    }
    else {
Simon Marlow's avatar
Simon Marlow committed
608
        OVERWRITE_INFO(q, &stg_IND_info);
609
610
611
612
613
614
    }

    // revoke the MVar operation
    tso->_link = END_TSO_QUEUE;
}

615
616
617
618
619
620
static void
removeFromQueues(Capability *cap, StgTSO *tso)
{
  switch (tso->why_blocked) {

  case NotBlocked:
621
  case ThreadMigrating:
622
623
624
625
626
627
628
629
630
631
632
633
      return;

  case BlockedOnSTM:
    // Be careful: nothing to do here!  We tell the scheduler that the
    // thread is runnable and we leave it to the stack-walking code to
    // abort the transaction while unwinding the stack.  We should
    // perhaps have a debugging test to make sure that this really
    // happens and that the 'zombie' transaction does not get
    // committed.
    goto done;

  case BlockedOnMVar:
634
      removeFromMVarBlockedQueue(tso);
635
636
637
      goto done;

  case BlockedOnBlackHole:
638
      // nothing to do
639
640
      goto done;

641
642
643
644
645
646
647
648
649
  case BlockedOnMsgThrowTo:
  {
      MessageThrowTo *m = tso->block_info.throwto;
      // The message is locked by us, unless we got here via
      // deleteAllThreads(), in which case we own all the
      // capabilities.
      // ASSERT(m->header.info == &stg_WHITEHOLE_info);

      // unlock and revoke it at the same time
650
      doneWithMsgThrowTo(m);
651
652
      break;
  }
653
654
655
656
657
658
659

#if !defined(THREADED_RTS)
  case BlockedOnRead:
  case BlockedOnWrite:
#if defined(mingw32_HOST_OS)
  case BlockedOnDoProc:
#endif
660
      removeThreadFromDeQueue(cap, &blocked_queue_hd, &blocked_queue_tl, tso);
661
662
663
664
665
666
667
668
669
#if defined(mingw32_HOST_OS)
      /* (Cooperatively) signal that the worker thread should abort
       * the request.
       */
      abandonWorkRequest(tso->block_info.async_result->reqID);
#endif
      goto done;

  case BlockedOnDelay:
670
        removeThreadFromQueue(cap, &sleeping_queue, tso);
671
672
673
674
	goto done;
#endif

  default:
675
      barf("removeFromQueues: %d", tso->why_blocked);
676
677
678
  }

 done:
679
680
  tso->why_blocked = NotBlocked;
  appendToRunQueue(cap, tso);
681
682
683
684
685
686
687
688
689
}

/* -----------------------------------------------------------------------------
 * raiseAsync()
 *
 * The following function implements the magic for raising an
 * asynchronous exception in an existing thread.
 *
 * We first remove the thread from any queue on which it might be
690
691
 * blocked.  The possible blockages are MVARs, BLOCKING_QUEUESs, and
 * TSO blocked_exception queues.
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
 *
 * We strip the stack down to the innermost CATCH_FRAME, building
 * thunks in the heap for all the active computations, so they can 
 * be restarted if necessary.  When we reach a CATCH_FRAME, we build
 * an application of the handler to the exception, and push it on
 * the top of the stack.
 * 
 * How exactly do we save all the active computations?  We create an
 * AP_STACK for every UpdateFrame on the stack.  Entering one of these
 * AP_STACKs pushes everything from the corresponding update frame
 * upwards onto the stack.  (Actually, it pushes everything up to the
 * next update frame plus a pointer to the next AP_STACK object.
 * Entering the next AP_STACK object pushes more onto the stack until we
 * reach the last AP_STACK object - at which point the stack should look
 * exactly as it did when we killed the TSO and we can continue
 * execution by entering the closure on top of the stack.
 *
 * We can also kill a thread entirely - this happens if either (a) the 
 * exception passed to raiseAsync is NULL, or (b) there's no
 * CATCH_FRAME on the stack.  In either case, we strip the entire
 * stack and replace the thread with a zombie.
 *
 * ToDo: in THREADED_RTS mode, this function is only safe if either
 * (a) we hold all the Capabilities (eg. in GC, or if there is only
 * one Capability), or (b) we own the Capability that the TSO is
 * currently blocked on or on the run queue of.
 *
 * -------------------------------------------------------------------------- */

721
static StgTSO *
722
raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception, 
723
	   rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
724
725
726
{
    StgRetInfoTable *info;
    StgPtr sp, frame;
727
    StgClosure *updatee;
728
    nat i;
729
    StgStack *stack;
730

731
732
    debugTraceCap(DEBUG_sched, cap,
                  "raising exception in thread %ld.", (long)tso->id);
733
    
734
735
736
#if defined(PROFILING)
    /* 
     * Debugging tool: on raising an  exception, show where we are.
737
     * See also Exception.cmm:stg_raisezh.
738
739
     * This wasn't done for asynchronous exceptions originally; see #1450 
     */
740
    if (RtsFlags.ProfFlags.showCCSOnException && exception != NULL)
741
    {
742
        fprintCCS_stderr(tso->prof.cccs,exception,tso);
743
744
    }
#endif
745
746
    // ASSUMES: the thread is not already complete or dead
    // Upper layers should deal with that.
747
    ASSERT(tso->what_next != ThreadComplete && 
748
           tso->what_next != ThreadKilled);
749

750
751
752
    // only if we own this TSO (except that deleteThread() calls this 
    ASSERT(tso->cap == cap);

753
    stack = tso->stackobj;
754

755
    // mark it dirty; we're about to change its stack.
756
    dirty_TSO(cap, tso);
757
    dirty_STACK(cap, stack);
758

759
    sp = stack->sp;
760
    
761
762
763
764
765
766
    if (stop_here != NULL) {
        updatee = stop_here->updatee;
    } else {
        updatee = NULL;
    }

767
768
769
770
771
772
773
774
775
776
777
    // The stack freezing code assumes there's a closure pointer on
    // the top of the stack, so we have to arrange that this is the case...
    //
    if (sp[0] == (W_)&stg_enter_info) {
	sp++;
    } else {
	sp--;
	sp[0] = (W_)&stg_dummy_ret_closure;
    }

    frame = sp + 1;
778
    while (stop_here == NULL || frame < (StgPtr)stop_here) {
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794

	// 1. Let the top of the stack be the "current closure"
	//
	// 2. Walk up the stack until we find either an UPDATE_FRAME or a
	// CATCH_FRAME.
	//
	// 3. If it's an UPDATE_FRAME, then make an AP_STACK containing the
	// current closure applied to the chunk of stack up to (but not
	// including) the update frame.  This closure becomes the "current
	// closure".  Go back to step 2.
	//
	// 4. If it's a CATCH_FRAME, then leave the exception handler on
	// top of the stack applied to the exception.
	// 
	// 5. If it's a STOP_FRAME, then kill the thread.
        // 
795
796
797
798
        // 6. If it's an UNDERFLOW_FRAME, then continue with the next
        //    stack chunk.
        //
        // NB: if we pass an ATOMICALLY_FRAME then abort the associated
799
800
        // transaction
       
801
        info = get_ret_itbl((StgClosure *)frame);
802
803
804
805
806
807
808
809
810
811
812
813
814

	switch (info->i.type) {

	case UPDATE_FRAME:
	{
	    StgAP_STACK * ap;
	    nat words;
	    
	    // First build an AP_STACK consisting of the stack chunk above the
	    // current update frame, with the top word on the stack as the
	    // fun field.
	    //
	    words = frame - sp - 1;
815
	    ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
	    
	    ap->size = words;
	    ap->fun  = (StgClosure *)sp[0];
	    sp++;
	    for(i=0; i < (nat)words; ++i) {
		ap->payload[i] = (StgClosure *)*sp++;
	    }
	    
	    SET_HDR(ap,&stg_AP_STACK_info,
		    ((StgClosure *)frame)->header.prof.ccs /* ToDo */); 
	    TICK_ALLOC_UP_THK(words+1,0);
	    
	    //IF_DEBUG(scheduler,
	    //	     debugBelch("sched: Updating ");
	    //	     printPtr((P_)((StgUpdateFrame *)frame)->updatee); 
	    //	     debugBelch(" with ");
	    //	     printObj((StgClosure *)ap);
	    //	);

835
836
837
838
839
840
841
842
843
844
845
            if (((StgUpdateFrame *)frame)->updatee == updatee) {
                // If this update frame points to the same closure as
                // the update frame further down the stack
                // (stop_here), then don't perform the update.  We
                // want to keep the blackhole in this case, so we can
                // detect and report the loop (#2783).
                ap = (StgAP_STACK*)updatee;
            } else {
                // Perform the update
                // TODO: this may waste some work, if the thunk has
                // already been updated by another thread.
846
847
                updateThunk(cap, tso, 
                            ((StgUpdateFrame *)frame)->updatee, (StgClosure *)ap);
848
            }
849

850
851
852
853
854
855
	    sp += sizeofW(StgUpdateFrame) - 1;
	    sp[0] = (W_)ap; // push onto stack
	    frame = sp + 1;
	    continue; //no need to bump frame
	}

856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
        case UNDERFLOW_FRAME:
        {
	    StgAP_STACK * ap;
	    nat words;
	    
	    // First build an AP_STACK consisting of the stack chunk above the
	    // current update frame, with the top word on the stack as the
	    // fun field.
	    //
	    words = frame - sp - 1;
	    ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
	    
	    ap->size = words;
	    ap->fun  = (StgClosure *)sp[0];
	    sp++;
	    for(i=0; i < (nat)words; ++i) {
		ap->payload[i] = (StgClosure *)*sp++;
	    }
	    
            SET_HDR(ap,&stg_AP_STACK_NOUPD_info,
		    ((StgClosure *)frame)->header.prof.ccs /* ToDo */); 
            TICK_ALLOC_SE_THK(words+1,0);

            stack->sp = sp;
            threadStackUnderflow(cap,tso);
            stack = tso->stackobj;
            sp = stack->sp;

            sp--;
            sp[0] = (W_)ap;
            frame = sp + 1;
            continue;
        }

        case STOP_FRAME:
891
	{
892
893
	    // We've stripped the entire stack, the thread is now dead.
	    tso->what_next = ThreadKilled;
894
895
            stack->sp = frame + sizeofW(StgStopFrame);
            goto done;
896
	}
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911

	case CATCH_FRAME:
	    // If we find a CATCH_FRAME, and we've got an exception to raise,
	    // then build the THUNK raise(exception), and leave it on
	    // top of the CATCH_FRAME ready to enter.
	    //
	{
	    StgCatchFrame *cf = (StgCatchFrame *)frame;
	    StgThunk *raise;
	    
	    if (exception == NULL) break;

	    // we've got an exception to raise, so let's pass it to the
	    // handler in this frame.
	    //
912
	    raise = (StgThunk *)allocate(cap,sizeofW(StgThunk)+1);
913
914
915
916
917
918
919
920
921
922
923
924
	    TICK_ALLOC_SE_THK(1,0);
	    SET_HDR(raise,&stg_raise_info,cf->header.prof.ccs);
	    raise->payload[0] = exception;
	    
	    // throw away the stack from Sp up to the CATCH_FRAME.
	    //
	    sp = frame - 1;
	    
	    /* Ensure that async excpetions are blocked now, so we don't get
	     * a surprise exception before we get around to executing the
	     * handler.
	     */
925
926
927
928
929
930
            tso->flags |= TSO_BLOCKEX;
            if ((cf->exceptions_blocked & TSO_INTERRUPTIBLE) == 0) {
                tso->flags &= ~TSO_INTERRUPTIBLE;
            } else {
                tso->flags |= TSO_INTERRUPTIBLE;
            }
931
932
933
934
935
936

	    /* Put the newly-built THUNK on top of the stack, ready to execute
	     * when the thread restarts.
	     */
	    sp[0] = (W_)raise;
	    sp[-1] = (W_)&stg_enter_info;
937
            stack->sp = sp-1;
938
	    tso->what_next = ThreadRunGHC;
939
            goto done;
940
941
942
943
	}
	    
	case ATOMICALLY_FRAME:
	    if (stop_at_atomically) {
944
		ASSERT(tso->trec->enclosing_trec == NO_TREC);
945
		stmCondemnTransaction(cap, tso -> trec);
946
                stack->sp = frame - 2;
947
948
949
950
951
952
953
954
                // The ATOMICALLY_FRAME expects to be returned a
                // result from the transaction, which it stores in the
                // stack frame.  Hence we arrange to return a dummy
                // result, so that the GC doesn't get upset (#3578).
                // Perhaps a better way would be to have a different
                // ATOMICALLY_FRAME instance for condemned
                // transactions, but I don't fully understand the
                // interaction with STM invariants.
955
956
957
958
                stack->sp[1] = (W_)&stg_NO_TREC_closure;
                stack->sp[0] = (W_)&stg_gc_unpt_r1_info;
                tso->what_next = ThreadRunGHC;
                goto done;
959
960
961
962
	    }
	    // Not stop_at_atomically... fall through and abort the
	    // transaction.
	    
963
	case CATCH_STM_FRAME:
964
965
966
967
968
969
970
971
	case CATCH_RETRY_FRAME:
	    // IF we find an ATOMICALLY_FRAME then we abort the
	    // current transaction and propagate the exception.  In
	    // this case (unlike ordinary exceptions) we do not care
	    // whether the transaction is valid or not because its
	    // possible validity cannot have caused the exception
	    // and will not be visible after the abort.

972
		{
973
            StgTRecHeader *trec = tso -> trec;
974
            StgTRecHeader *outer = trec -> enclosing_trec;
975
976
	    debugTraceCap(DEBUG_stm, cap,
                          "found atomically block delivering async exception");
977
            stmAbortTransaction(cap, trec);
tharris@microsoft.com's avatar
tharris@microsoft.com committed
978
	    stmFreeAbortedTRec(cap, trec);
979
            tso -> trec = outer;
980
            break;
981
	    };
982
983
984
985
986
987
988
989
990
	    
	default:
	    break;
	}

	// move on to the next stack frame
	frame += stack_frame_sizeW((StgClosure *)frame);
    }

991
992
993
994
995
996
997
998
999
1000
done:
    IF_DEBUG(sanity, checkTSO(tso));

    // wake it up
    if (tso->why_blocked != NotBlocked) {
        tso->why_blocked = NotBlocked;
        appendToRunQueue(cap,tso);
    }        

    return tso;
1001
1002
1003
}