← Back to branch summary

~rdoering/ubuntu/intrepid/erlang/fix-535090

« back to all changes in this revision

Viewing changes to lib/mnesia/src/mnesia_recover.erl

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2007-05-01 16:57:10 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20070501165710-2sapk0hp2gf3o0ip
Tags: 1:11.b.4-2ubuntu1
* Merge with Debian Unstable. Remaining changes:
  - Add -fno-stack-protector to fix broken crypto_drv.
* DebianMaintainerField update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/mnesia/src/mnesia_recover.erl
129
129
disconnect(Node) ->
130
130
    call({disconnect, Node}).
131
131
 
 
132
log_decision(D) ->
 
133
    cast({log_decision, D}).
 
134
 
132
135
val(Var) ->
133
136
    case ?catch_val(Var) of
134
137
        {'EXIT', Reason} -> mnesia_lib:other_val(Var, Reason); 
191
194
%%    ?DBG("~w: note_decision: ~w~n", [node(), D]),
192
195
    ?ets_insert(mnesia_decision, D).
193
196
 
194
 
log_decision(D) when D#decision.outcome /= unclear ->
 
197
do_log_decision(D) when D#decision.outcome /= unclear ->
195
198
    OldD = decision(D#decision.tid),
196
199
    MergedD = merge_decisions(node(), OldD, D),
197
 
    do_log_decision(MergedD, true);
198
 
log_decision(D) ->
199
 
    do_log_decision(D, false).
 
200
    do_log_decision(MergedD, true, D);
 
201
do_log_decision(D) ->
 
202
    do_log_decision(D, false, undefined).
200
203
 
201
 
do_log_decision(D, DoTell) ->
202
 
    RamNs = D#decision.ram_nodes,
 
204
do_log_decision(D, DoTell, NodeD) ->
203
205
    DiscNs = D#decision.disc_nodes -- [node()],
204
206
    Outcome = D#decision.outcome,
205
207
    D2 =
214
216
            mnesia_log:append(latest_log, D2),
215
217
            if
216
218
                DoTell == true, Outcome /= unclear ->
217
 
                    tell_im_certain(DiscNs, D2),
218
 
                    tell_im_certain(RamNs, D2);
 
219
                    tell_im_certain(NodeD#decision.disc_nodes--[node()],D2),
 
220
                    tell_im_certain(NodeD#decision.ram_nodes--[node()], D2);
219
221
                true ->
220
222
                    ignore
221
223
            end;
227
229
    ignore;
228
230
tell_im_certain(Nodes, D) ->
229
231
    Msg = {im_certain, node(), D},
230
 
%%    ?DBG("~w: ~w: tell: ~w~n", [node(), Msg, Nodes]),
 
232
  %%  mnesia_lib:verbose("~w: tell: ~w~n", [Msg, Nodes]), 
231
233
    abcast(Nodes, Msg).
232
234
 
233
235
log_mnesia_up(Node) ->
487
489
note_log_decision(NewD, _InitBy) when record(NewD, decision) ->
488
490
    Tid = NewD#decision.tid,
489
491
    sync_trans_tid_serial(Tid),
490
 
    OldD = decision(Tid),
491
 
    MergedD = merge_decisions(node(), OldD, NewD),
492
 
    note_outcome(MergedD);
493
 
 
 
492
    note_outcome(NewD);
494
493
note_log_decision({trans_tid, serial, _Serial}, startup) ->
495
494
    ignore;
496
 
 
497
495
note_log_decision({trans_tid, serial, Serial}, _InitBy) ->
498
496
    sync_trans_tid_serial(Serial);
499
 
 
500
497
note_log_decision({mnesia_up, Node, Date, Time}, _InitBy) ->
501
498
    note_up(Node, Date, Time);
502
 
 
503
499
note_log_decision({mnesia_down, Node, Date, Time}, _InitBy) ->
504
500
    note_down(Node, Date, Time);
505
 
 
506
501
note_log_decision({master_nodes, Tab, Nodes}, _InitBy) ->
507
502
    note_master_nodes(Tab, Nodes);
508
 
 
509
503
note_log_decision(H, _InitBy) when H#log_header.log_kind == decision_log ->
510
504
    V = mnesia_log:decision_log_version(),
511
505
    if
518
512
        true ->
519
513
            fatal("Bad version of decision log: ~p~n", [H])
520
514
    end;
521
 
 
522
515
note_log_decision(H, _InitBy) when H#log_header.log_kind == decision_tab ->
523
516
    V = mnesia_log:decision_tab_version(),
524
517
    if
752
745
handle_cast({im_certain, Node, NewD}, State) ->
753
746
    OldD = decision(NewD#decision.tid),
754
747
    MergedD = merge_decisions(Node, OldD, NewD),    
755
 
    do_log_decision(MergedD, false),
 
748
    do_log_decision(MergedD, false, undefined),
 
749
    {noreply, State};
 
750
 
 
751
handle_cast({log_decision, D}, State) ->
 
752
    do_log_decision(D),
756
753
    {noreply, State};
757
754
 
758
755
handle_cast(allow_garb, State) ->
897
894
do_handle_early_msgs([Msg | Msgs], State) ->
898
895
    %% The messages are in reverted order
899
896
    case do_handle_early_msgs(Msgs, State) of
900
 
        {stop, Reason, Reply, State2} ->
901
 
            {stop, Reason, Reply, State2};
 
897
%%         {stop, Reason, Reply, State2} ->
 
898
%%          {stop, Reason, Reply, State2};
902
899
        {stop, Reason, State2} ->
903
900
            {stop, Reason, State2};
904
901
        {noreply, State2} ->
1072
1069
    Tid = NewD#decision.tid,
1073
1070
    OldD = decision(Tid),
1074
1071
    D = merge_decisions(Node, OldD, NewD),
1075
 
    do_log_decision(D, false),
 
1072
    do_log_decision(D, false, undefined),
1076
1073
    Outcome = D#decision.outcome,
1077
1074
    if
1078
1075
        OldD == no_decision ->
1100
1097
                                          ram_nodes = []},
1101
1098
                    tell_im_certain(D#decision.disc_nodes, CertainD),
1102
1099
                    tell_im_certain(D#decision.ram_nodes, CertainD),
1103
 
                    do_log_decision(CertainD, false),
 
1100
                    do_log_decision(CertainD, false, undefined),
1104
1101
                    verbose("Decided to abort transaction ~p "
1105
1102
                            "since everybody are uncertain ~p~n",
1106
1103
                            [Tid, CertainD]),
1153
1150
            arrange(ToNodes, D, Acc, ForceSend)
1154
1151
    end;
1155
1152
 
1156
 
arrange([To | ToNodes], C, Acc, ForceSend) when record(C, transient_decision) ->
1157
 
    Acc2 = add_decision(To, C, Acc),
1158
 
    arrange(ToNodes, C, Acc2, ForceSend);
1159
 
 
1160
 
arrange([_To | _ToNodes], {mnesia_down, _Node, _Date, _Time}, Acc, _ForceSend) ->
1161
 
    %% The others have their own info about this
1162
 
    Acc;
1163
 
 
1164
 
arrange([_To | _ToNodes], {master_nodes, _Tab, _Nodes}, Acc, _ForceSend) ->
1165
 
    %% The others have their own info about this
1166
 
    Acc;
1167
 
 
1168
1153
arrange([To | ToNodes], {trans_tid, serial, Serial}, Acc, ForceSend) ->
1169
1154
    %% Do the lamport thing plus release the others
1170
1155
    %% from uncertainity.