Recently I realized that my changes to /etc/resolve.conf always got overwritten upon system reboot, after searching the web for a while I found the solution from StackExchange: Ubuntu 16.04 IfContinue reading
In this post I’ll go through the disassembly (commented inline) of the following C++ snippet:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | #include <concepts> #include <coroutine> class task { public: class promise_type { public: class always_suspend { public: bool await_ready() const noexcept; bool await_suspend( std::coroutine_handle<promise_type> handle) noexcept; void await_resume() noexcept; }; promise_type(); always_suspend initial_suspend(); always_suspend final_suspend() noexcept; void unhandled_exception(); always_suspend yield_value(std::integral auto&& v); task get_return_object(); private: std::coroutine_handle<promise_type> handle_; }; }; bool task::promise_type::always_suspend::await_ready() const noexcept { return false; } bool task::promise_type::always_suspend::await_suspend( std::coroutine_handle<promise_type> handle) noexcept { return true; } void task::promise_type::always_suspend::await_resume() noexcept {} task::promise_type::promise_type() { handle_ = std::coroutine_handle<promise_type>::from_promise(*this); } task::promise_type::always_suspend task::promise_type::initial_suspend() { return {}; } task::promise_type::always_suspend task::promise_type::final_suspend() noexcept { return {}; } void task::promise_type::unhandled_exception() {} template <std::integral T> task::promise_type::always_suspend task::promise_type::yield_value(T&& v) { return {}; } task task::promise_type::get_return_object() { return {}; } task fancy_task(int x) { for (int i = 0; i != 100; ++i) { co_yield i + x; } } int main() { auto task = fancy_task(5); } |
Disassembly:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | task::promise_type::always_suspend::await_ready() const: mov eax, 0 ret task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>): mov eax, 1 ret fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor]: push rbp push rbx sub rsp, 8 mov rbx, rdi ; `rbx` holds `coroutine_handle<>`. movzx ecx, WORD PTR [rdi+36] ; Loads current state (of the state machine the coroutine represents). test cl, 1 ; Not destroying the coroutine?. je .L4 cmp cx, 7 ; State > 3? Note that 3 comes from `7 >> 1`. ja .L5 ; Unexpected then. mov eax, 170 ; ??? shr rax, cl test al, 1 jne .L6 .L5: ; Unexpected state. ud2 .L4: cmp cx, 4 ; State 2. je .L7 ja .L8 test cx, cx je .L9 ; State 0. cmp cx, 2 jne .L11 ; Not state 1, either. Unexpected. .L10: mov BYTE PTR [rbx+39], 1 ; ??? state 0 finishes (i.e., `initial_suspend` called)? mov DWORD PTR [rbx+44], 0 ; Initialize `i`. jmp .L14 .L8: cmp cx, 6 ; State 3. jne .L11 .L6: ; Epilogue. State 3. ; ??? Coroutine alive? ; ; Note that this is not necessarily the same as `coroutine_handle<>.done()`, ; the latter returns `true` as soon as `final_suspend()` is reached, while ; this flag is set only after `final_suspend()` has been resumed. cmp BYTE PTR [rbx+38], 0 jne .L17 .L3: ; Return control to the caller. add rsp, 8 pop rbx pop rbp ret .L11: ; Unexpected state. ud2 .L9: ; Prologue. State 0, runs before `initial_suspend()`. mov QWORD PTR [rbx+24], rdi ; Stores `coroutine_handle<>` in ... `coroutine_handle<>`? mov BYTE PTR [rdi+39], 0 ; ??? state 0 finishes? lea rbp, [rdi+40] ; Space allocated for `always_suspend` returned by `initial_suspend()` in coroutine state. mov rdi, rbp call task::promise_type::always_suspend::await_ready() const test al, al jne .L10 ; No need to suspend. mov WORD PTR [rbx+36], 2 ; Next state (of FSM this coroutine represents) will be state 1. mov rsi, rbx mov rdi, rbp call task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>) ; See if we really need to suspend. test al, al jne .L3 ; Yes, returning to the caller. jmp .L10 ; Jump ahead to state 1 then. .L7: ; State 2. Also the beginning of the `for` loop. mov eax, DWORD PTR [rbx+44] ; Loads `i`. add eax, 1 mov DWORD PTR [rbx+44], eax .L14: mov eax, DWORD PTR [rbx+44] cmp eax, 100 ; `for` loop ends? je .L18 add eax, DWORD PTR [rbx+32] ; Loads `x` and adds it to `i`. mov DWORD PTR [rbx+52], eax ; Keep the result. lea rbp, [rbx+48] ; `always_suspend` object (returned by `yield_value(integral auto&&)`) allocated in coroutine state? mov rdi, rbp call task::promise_type::always_suspend::await_ready() const ; See if we need to suspend. test al, al jne .L7 ; No need to suspend. mov WORD PTR [rbx+36], 4 mov rsi, QWORD PTR [rbx+24] ; `coroutine_handle<>`. mov rdi, rbp call task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>) test al, al ; Needs to suspend? jne .L3 ; Yes, leaving. jmp .L7 ; Otherwise keep looping. .L18: ; `for` loop ends. ; Clear pointer to FSM represented by this coroutine. ; ; Indicates `coroutine_handle::done()`? ; ; As a reminder, resuming a coroutine suspended on its `final_suspend()` is U.B, ; therefore setting FSM to `nullptr` prior to calling `final_suspend()` won't ; hurt well-formed programs. mov QWORD PTR [rbx], 0 lea rbp, [rbx+56] ; `always_suspend` for `final_suspend()`. mov rdi, rbp call task::promise_type::always_suspend::await_ready() const test al, al jne .L6 ; Don't suspend, falling through to state 3. mov WORD PTR [rbx+36], 6 ; Next state is 3. mov rsi, QWORD PTR [rbx+24] ; `coroutine_handle<>`. mov rdi, rbp call task::promise_type::always_suspend::await_suspend(std::__n4861::coroutine_handle<task::promise_type>) test al, al jne .L3 ; Suspend, returning to the caller. jmp .L6 ; No need to suspend, continuing state 3. .L17: ; Destroyes the coroutine. mov rdi, rbx call operator delete(void*) jmp .L3 fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .destroy]: sub rsp, 8 or WORD PTR [rdi+36], 1 # LSB set to 1 indicates leaving? call fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor] add rsp, 8 ret task::promise_type::always_suspend::await_resume(): ret task::promise_type::promise_type() [base object constructor]: mov QWORD PTR [rdi], 0 lea rax, [rdi-16] ; `coroutine_handle`. mov QWORD PTR [rdi], rax ret task::promise_type::initial_suspend(): ret task::promise_type::final_suspend(): ret task::promise_type::unhandled_exception(): ret task::promise_type::get_return_object(): ret fancy_task(int): push rbp push rbx sub rsp, 8 mov ebp, edi mov edi, 64 ; Allocates coroutine state (stack frame, actually). The `coroutine_handle<>` ; also holds this value (at least on GCC). call operator new(unsigned long) mov rbx, rax mov BYTE PTR [rax+38], 1 ; ??? Coroutine alive? ; State machine? Seemingly reset to `nullptr` on coroutine completion (i.e., ; `coroutine_handle<>.done()`) mov QWORD PTR [rax], OFFSET FLAT:fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor] mov QWORD PTR [rax+8], OFFSET FLAT:fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .destroy] ; `coroutine_handle.destroy` mov DWORD PTR [rax+32], ebp ; Saves stack pointer lea rdi, [rax+16] ; Pointer to promise object contained by coroutine state. call task::promise_type::promise_type() [complete object constructor] mov WORD PTR [rbx+36], 0 ; Current state? mov rdi, rbx call fancy_task(fancy_task(int)::_Z10fancy_taski.Frame*) [clone .actor] ; Enter the state machine. add rsp, 8 pop rbx pop rbp ret main: sub rsp, 8 mov edi, 5 ; Our argument to `fancy_task` call fancy_task(int) mov eax, 0 add rsp, 8 ret |
Today my server experienced an outage and restarted automatically. However, my blog didn’t go online after that. With a little invesitgation it immediately got obvious that the nginx failed toContinue reading
FP32 can be converted to BFloat16 simply by truncating the lower 16 bits. So we can do this with some bit operations. Internally two sets of FP32s (i.e., elements inContinue reading
Recently I built Linux 5.10 LTS for my N1 box. Below are the patches I needed during the building process. TEXT_OFFSET Obsolete: See comments from justin below, it’s no longerContinue reading
I wrote a blog about blocking Thunder in tranmission-daemon 2.94. The patch does not apply cleanly on Transmission 3.00, so I update it here:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 | --- a/libtransmission/peer-mgr.c 2021-08-31 03:10:20.435836776 +0800 +++ b/libtransmission/peer-mgr.c 2021-08-31 03:14:31.268153266 +0800 @@ -2007,6 +2007,21 @@ tr_peerMsgsUpdateActive(msgs, TR_DOWN); } +static bool isUserAgentBad(const char* ua) +{ + static const char* blacklist[] = {"Thunder", "Xunlei"}; + int i; + + for (i = 0; i != sizeof(blacklist) / sizeof(blacklist[0]); ++i) { + // Performs bad, honestly. + if (!strncmp(blacklist[i], ua, strlen(blacklist[i]))) { + return true; + } + } + return false; +} + + /* FIXME: this is kind of a mess. */ static bool myHandshakeDoneCB(tr_handshake* handshake, tr_peerIo* io, bool readAnythingFromPeer, bool isConnected, uint8_t const* peer_id, void* vmanager) @@ -2100,21 +2115,29 @@ tr_quark client; tr_peerIo* io; char buf[128]; + const char* ua = ""; if (peer_id != NULL) { - client = tr_quark_new(tr_clientForId(buf, sizeof(buf), peer_id), TR_BAD_SIZE); + client = tr_quark_new((ua = tr_clientForId(buf, sizeof(buf), peer_id)), TR_BAD_SIZE); } else { client = TR_KEY_NONE; } - io = tr_handshakeStealIO(handshake); /* this steals its refcount too, which is balanced by our unref in peerDelete() */ - tr_peerIoSetParent(io, &s->tor->bandwidth); - createBitTorrentPeer(s->tor, io, atom, client); + if (!isUserAgentBad(ua)) + { + io = tr_handshakeStealIO(handshake); /* this steals its refcount too, which is balanced by our unref in peerDelete() */ + tr_peerIoSetParent(io, &s->tor->bandwidth); + createBitTorrentPeer(s->tor, io, atom, client); - success = true; + success = true; + } + else + { + tr_logAddDebug("Bad user agent \"%s\" (peer %s) tried to connect to us", ua, tr_atomAddrStr(atom)); + } } } } |
The rest instructions are theContinue reading
By default transmission-web-control forces a default reload interval of 5 seconds, and a minimum of 3 seconds. As I’m not that into reducing bandwidth, I overrode the default behavior. DefaultContinue reading
This seems to relate to a kernel change in 3.15. To workaround it I have to prevent UAS driver from binding to my HDD drive by setting usb-storage.quirks. Unfortunately, solutionContinue reading
Sort of an excersise.. The four LUTs for converting numeric values to ASCII chars is ugly. Besides, since both _mm256_shuffle_epi8 and _mm256_blendv_epi8 suffers from low throughput (1 CPI / 2Continue reading
By default Linux (randomly?) chooses “Client IPv6 Address” (given by HE.net) as source address for outbound connections. This can be inconvenient sometimes tough. To override this, it’s possible to addContinue reading