選択できるのは25トピックまでです。 トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。

worker_util.c 68KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558
  1. /*
  2. * Copyright 2024 Vsevolod Stakhov
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. * http://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */
  16. #include "config.h"
  17. #include "rspamd.h"
  18. #include "lua/lua_common.h"
  19. #include "worker_util.h"
  20. #include "unix-std.h"
  21. #include "utlist.h"
  22. #include "ottery.h"
  23. #include "rspamd_control.h"
  24. #include "libserver/maps/map.h"
  25. #include "libserver/maps/map_private.h"
  26. #include "libserver/http/http_private.h"
  27. #include "libserver/http/http_router.h"
  28. #include "libutil/rrd.h"
  29. /* sys/resource.h */
  30. #ifdef HAVE_SYS_RESOURCE_H
  31. #include <sys/resource.h>
  32. #endif
  33. /* pwd and grp */
  34. #ifdef HAVE_PWD_H
  35. #include <pwd.h>
  36. #endif
  37. #ifdef HAVE_GRP_H
  38. #include <grp.h>
  39. #endif
  40. #ifdef HAVE_LIBUTIL_H
  41. #include <libutil.h>
  42. #endif
  43. #include "zlib.h"
  44. #ifdef HAVE_UCONTEXT_H
  45. #include <ucontext.h>
  46. #elif defined(HAVE_SYS_UCONTEXT_H)
  47. #include <sys/ucontext.h>
  48. #endif
  49. #ifdef HAVE_SYS_WAIT_H
  50. #include <sys/wait.h>
  51. #include <math.h>
  52. #endif
  53. #include "contrib/libev/ev.h"
  54. #include "libstat/stat_api.h"
  55. struct rspamd_worker *rspamd_current_worker = NULL;
  56. /* Forward declaration */
  57. static void rspamd_worker_heartbeat_start(struct rspamd_worker *,
  58. struct ev_loop *);
  59. static void rspamd_worker_ignore_signal(struct rspamd_worker_signal_handler *);
  60. /**
  61. * Return worker's control structure by its type
  62. * @param type
  63. * @return worker's control structure or NULL
  64. */
  65. worker_t *
  66. rspamd_get_worker_by_type(struct rspamd_config *cfg, GQuark type)
  67. {
  68. worker_t **pwrk;
  69. pwrk = cfg->compiled_workers;
  70. while (pwrk && *pwrk) {
  71. if (rspamd_check_worker(cfg, *pwrk)) {
  72. if (g_quark_from_string((*pwrk)->name) == type) {
  73. return *pwrk;
  74. }
  75. }
  76. pwrk++;
  77. }
  78. return NULL;
  79. }
  80. static void
  81. rspamd_worker_check_finished(EV_P_ ev_timer *w, int revents)
  82. {
  83. int *pnchecks = (int *) w->data;
  84. if (*pnchecks > SOFT_SHUTDOWN_TIME * 10) {
  85. msg_warn("terminating worker before finishing of terminate handlers");
  86. ev_break(EV_A_ EVBREAK_ONE);
  87. }
  88. else {
  89. int refcount = ev_active_cnt(EV_A);
  90. if (refcount == 1) {
  91. ev_break(EV_A_ EVBREAK_ONE);
  92. }
  93. else {
  94. ev_timer_again(EV_A_ w);
  95. }
  96. }
  97. }
  98. static gboolean
  99. rspamd_worker_finalize(gpointer user_data)
  100. {
  101. struct rspamd_task *task = user_data;
  102. if (!(task->flags & RSPAMD_TASK_FLAG_PROCESSING)) {
  103. msg_info_task("finishing actions has been processed, terminating");
  104. /* ev_break (task->event_loop, EVBREAK_ALL); */
  105. task->worker->state = rspamd_worker_wanna_die;
  106. rspamd_session_destroy(task->s);
  107. return TRUE;
  108. }
  109. return FALSE;
  110. }
  111. gboolean
  112. rspamd_worker_call_finish_handlers(struct rspamd_worker *worker)
  113. {
  114. struct rspamd_task *task;
  115. struct rspamd_config *cfg = worker->srv->cfg;
  116. struct rspamd_abstract_worker_ctx *ctx;
  117. struct rspamd_config_cfg_lua_script *sc;
  118. if (cfg->on_term_scripts) {
  119. ctx = (struct rspamd_abstract_worker_ctx *) worker->ctx;
  120. /* Create a fake task object for async events */
  121. task = rspamd_task_new(worker, cfg, NULL, NULL, ctx->event_loop, FALSE);
  122. task->resolver = ctx->resolver;
  123. task->flags |= RSPAMD_TASK_FLAG_PROCESSING;
  124. task->s = rspamd_session_create(task->task_pool,
  125. rspamd_worker_finalize,
  126. NULL,
  127. (event_finalizer_t) rspamd_task_free,
  128. task);
  129. DL_FOREACH(cfg->on_term_scripts, sc)
  130. {
  131. lua_call_finish_script(sc, task);
  132. }
  133. task->flags &= ~RSPAMD_TASK_FLAG_PROCESSING;
  134. if (rspamd_session_pending(task->s)) {
  135. return TRUE;
  136. }
  137. }
  138. return FALSE;
  139. }
  140. static void
  141. rspamd_worker_terminate_handlers(struct rspamd_worker *w)
  142. {
  143. if (w->nconns == 0 &&
  144. (!(w->flags & RSPAMD_WORKER_SCANNER) || w->srv->cfg->on_term_scripts == NULL)) {
  145. /*
  146. * We are here either:
  147. * - No active connections are represented
  148. * - No term scripts are registered
  149. * - Worker is not a scanner, so it can die safely
  150. */
  151. w->state = rspamd_worker_wanna_die;
  152. }
  153. else {
  154. if (w->nconns > 0) {
  155. /*
  156. * Wait until all connections are terminated
  157. */
  158. w->state = rspamd_worker_wait_connections;
  159. }
  160. else {
  161. /*
  162. * Start finish scripts
  163. */
  164. if (w->state != rspamd_worker_wait_final_scripts) {
  165. w->state = rspamd_worker_wait_final_scripts;
  166. if ((w->flags & RSPAMD_WORKER_SCANNER) &&
  167. rspamd_worker_call_finish_handlers(w)) {
  168. msg_info("performing async finishing actions");
  169. w->state = rspamd_worker_wait_final_scripts;
  170. }
  171. else {
  172. /*
  173. * We are done now
  174. */
  175. msg_info("no async finishing actions, terminating");
  176. w->state = rspamd_worker_wanna_die;
  177. }
  178. }
  179. }
  180. }
  181. }
  182. static void
  183. rspamd_worker_on_delayed_shutdown(EV_P_ ev_timer *w, int revents)
  184. {
  185. struct rspamd_worker *worker = (struct rspamd_worker *) w->data;
  186. worker->state = rspamd_worker_wanna_die;
  187. ev_timer_stop(EV_A_ w);
  188. ev_break(loop, EVBREAK_ALL);
  189. }
  190. static void
  191. rspamd_worker_shutdown_check(EV_P_ ev_timer *w, int revents)
  192. {
  193. struct rspamd_worker *worker = (struct rspamd_worker *) w->data;
  194. if (worker->state != rspamd_worker_wanna_die) {
  195. rspamd_worker_terminate_handlers(worker);
  196. if (worker->state == rspamd_worker_wanna_die) {
  197. /* We are done, kill event loop */
  198. ev_timer_stop(EV_A_ w);
  199. ev_break(EV_A_ EVBREAK_ALL);
  200. }
  201. else {
  202. /* Try again later */
  203. ev_timer_again(EV_A_ w);
  204. }
  205. }
  206. else {
  207. ev_timer_stop(EV_A_ w);
  208. ev_break(EV_A_ EVBREAK_ALL);
  209. }
  210. }
  211. static void
  212. rspamd_worker_shutdown_check_nconns(EV_P_ ev_timer *w, int revents)
  213. {
  214. struct rspamd_worker *worker = (struct rspamd_worker *) w->data;
  215. if (worker->state != rspamd_worker_wanna_die) {
  216. if (worker->state != rspamd_worker_wait_connections) {
  217. rspamd_worker_terminate_handlers(worker);
  218. }
  219. /* Check again, as rspamd_worker_terminate_handlers could change the worker's state */
  220. if (worker->state == rspamd_worker_wanna_die) {
  221. /* We are done, kill event loop */
  222. ev_timer_stop(EV_A_ w);
  223. ev_break(EV_A_ EVBREAK_ALL);
  224. }
  225. else {
  226. /* Try again later */
  227. if (worker->nconns > 0) {
  228. ev_timer_again(EV_A_ w);
  229. }
  230. else {
  231. /* No connections left, can close everything */
  232. ev_timer_stop(EV_A_ w);
  233. ev_break(EV_A_ EVBREAK_ALL);
  234. }
  235. }
  236. }
  237. else {
  238. ev_timer_stop(EV_A_ w);
  239. ev_break(EV_A_ EVBREAK_ALL);
  240. }
  241. }
  242. /*
  243. * Config reload is designed by sending sigusr2 to active workers and pending shutdown of them
  244. */
  245. static gboolean
  246. rspamd_worker_usr2_handler(struct rspamd_worker_signal_handler *sigh, void *arg)
  247. {
  248. /* Do not accept new connections, preparing to end worker's process */
  249. if (sigh->worker->state == rspamd_worker_state_running) {
  250. static ev_timer shutdown_ev, shutdown_check_ev;
  251. ev_tstamp shutdown_ts;
  252. if (sigh->worker->flags & RSPAMD_WORKER_NO_TERMINATE_DELAY) {
  253. shutdown_ts = 0.0;
  254. }
  255. else {
  256. shutdown_ts = MAX(SOFT_SHUTDOWN_TIME,
  257. sigh->worker->srv->cfg->task_timeout * 2.0);
  258. }
  259. rspamd_worker_ignore_signal(sigh);
  260. sigh->worker->state = rspamd_worker_state_terminating;
  261. rspamd_default_log_function(G_LOG_LEVEL_INFO,
  262. sigh->worker->srv->server_pool->tag.tagname,
  263. sigh->worker->srv->server_pool->tag.uid,
  264. G_STRFUNC,
  265. "worker's shutdown is pending in %.2f sec",
  266. shutdown_ts);
  267. /* Soft shutdown timer */
  268. shutdown_ev.data = sigh->worker;
  269. ev_timer_init(&shutdown_ev, rspamd_worker_on_delayed_shutdown,
  270. shutdown_ts, 0.0);
  271. ev_timer_start(sigh->event_loop, &shutdown_ev);
  272. if (!(sigh->worker->flags & RSPAMD_WORKER_NO_TERMINATE_DELAY)) {
  273. /* This timer checks if we are ready to die and is called frequently */
  274. shutdown_check_ev.data = sigh->worker;
  275. ev_timer_init(&shutdown_check_ev, rspamd_worker_shutdown_check,
  276. 0.5, 0.5);
  277. ev_timer_start(sigh->event_loop, &shutdown_check_ev);
  278. }
  279. rspamd_worker_stop_accept(sigh->worker);
  280. }
  281. /* No more signals */
  282. return FALSE;
  283. }
  284. /*
  285. * Reopen log is designed by sending sigusr1 to active workers and pending shutdown of them
  286. */
  287. static gboolean
  288. rspamd_worker_usr1_handler(struct rspamd_worker_signal_handler *sigh, void *arg)
  289. {
  290. struct rspamd_main *rspamd_main = sigh->worker->srv;
  291. rspamd_log_reopen(sigh->worker->srv->logger, rspamd_main->cfg, -1, -1);
  292. msg_info_main("logging reinitialised");
  293. /* Get more signals */
  294. return TRUE;
  295. }
  296. static gboolean
  297. rspamd_worker_term_handler(struct rspamd_worker_signal_handler *sigh, void *arg)
  298. {
  299. if (sigh->worker->state == rspamd_worker_state_running) {
  300. static ev_timer shutdown_ev, shutdown_check_ev;
  301. ev_tstamp shutdown_ts;
  302. if (sigh->worker->flags & RSPAMD_WORKER_NO_TERMINATE_DELAY) {
  303. shutdown_ts = 0.0;
  304. }
  305. else {
  306. shutdown_ts = MAX(SOFT_SHUTDOWN_TIME,
  307. sigh->worker->srv->cfg->task_timeout * 2.0);
  308. }
  309. rspamd_worker_ignore_signal(sigh);
  310. sigh->worker->state = rspamd_worker_state_terminating;
  311. rspamd_default_log_function(G_LOG_LEVEL_INFO,
  312. sigh->worker->srv->server_pool->tag.tagname,
  313. sigh->worker->srv->server_pool->tag.uid,
  314. G_STRFUNC,
  315. "terminating in up to %.0f second after receiving signal %s",
  316. shutdown_ts,
  317. g_strsignal(sigh->signo));
  318. rspamd_worker_stop_accept(sigh->worker);
  319. rspamd_worker_terminate_handlers(sigh->worker);
  320. /* Check if we are ready to die */
  321. if (sigh->worker->state != rspamd_worker_wanna_die) {
  322. /* This timer is called when we have no choices but to die */
  323. shutdown_ev.data = sigh->worker;
  324. ev_timer_init(&shutdown_ev, rspamd_worker_on_delayed_shutdown,
  325. shutdown_ts, 0.0);
  326. ev_timer_start(sigh->event_loop, &shutdown_ev);
  327. if (!(sigh->worker->flags & RSPAMD_WORKER_NO_TERMINATE_DELAY)) {
  328. /* This timer checks if we are ready to die and is called frequently */
  329. shutdown_check_ev.data = sigh->worker;
  330. ev_timer_init(&shutdown_check_ev, rspamd_worker_shutdown_check,
  331. 0.5, 0.5);
  332. ev_timer_start(sigh->event_loop, &shutdown_check_ev);
  333. }
  334. else {
  335. /* This timer checks if we have no active connections pending and terminates once all conns are done */
  336. shutdown_check_ev.data = sigh->worker;
  337. ev_timer_init(&shutdown_check_ev, rspamd_worker_shutdown_check_nconns,
  338. 0.5, 0.5);
  339. ev_timer_start(sigh->event_loop, &shutdown_check_ev);
  340. }
  341. }
  342. else {
  343. /* Flag to die has been already set */
  344. ev_break(sigh->event_loop, EVBREAK_ALL);
  345. }
  346. }
  347. /* Stop reacting on signals */
  348. return FALSE;
  349. }
  350. static void
  351. rspamd_worker_signal_handle(EV_P_ ev_signal *w, int revents)
  352. {
  353. struct rspamd_worker_signal_handler *sigh =
  354. (struct rspamd_worker_signal_handler *) w->data;
  355. struct rspamd_worker_signal_handler_elt *cb, *cbtmp;
  356. /* Call all signal handlers registered */
  357. DL_FOREACH_SAFE(sigh->cb, cb, cbtmp)
  358. {
  359. if (!cb->handler(sigh, cb->handler_data)) {
  360. DL_DELETE(sigh->cb, cb);
  361. g_free(cb);
  362. }
  363. }
  364. }
  365. static void
  366. rspamd_worker_ignore_signal(struct rspamd_worker_signal_handler *sigh)
  367. {
  368. sigset_t set;
  369. ev_signal_stop(sigh->event_loop, &sigh->ev_sig);
  370. sigemptyset(&set);
  371. sigaddset(&set, sigh->signo);
  372. sigprocmask(SIG_BLOCK, &set, NULL);
  373. }
  374. static void
  375. rspamd_worker_default_signal(int signo)
  376. {
  377. struct sigaction sig;
  378. sigemptyset(&sig.sa_mask);
  379. sigaddset(&sig.sa_mask, signo);
  380. sig.sa_handler = SIG_DFL;
  381. sig.sa_flags = 0;
  382. sigaction(signo, &sig, NULL);
  383. }
  384. static void
  385. rspamd_sigh_free(void *p)
  386. {
  387. struct rspamd_worker_signal_handler *sigh = p;
  388. struct rspamd_worker_signal_handler_elt *cb, *tmp;
  389. DL_FOREACH_SAFE(sigh->cb, cb, tmp)
  390. {
  391. DL_DELETE(sigh->cb, cb);
  392. g_free(cb);
  393. }
  394. ev_signal_stop(sigh->event_loop, &sigh->ev_sig);
  395. rspamd_worker_default_signal(sigh->signo);
  396. g_free(sigh);
  397. }
  398. void rspamd_worker_set_signal_handler(int signo, struct rspamd_worker *worker,
  399. struct ev_loop *event_loop,
  400. rspamd_worker_signal_cb_t handler,
  401. void *handler_data)
  402. {
  403. struct rspamd_worker_signal_handler *sigh;
  404. struct rspamd_worker_signal_handler_elt *cb;
  405. sigh = g_hash_table_lookup(worker->signal_events, GINT_TO_POINTER(signo));
  406. if (sigh == NULL) {
  407. sigh = g_malloc0(sizeof(*sigh));
  408. sigh->signo = signo;
  409. sigh->worker = worker;
  410. sigh->event_loop = event_loop;
  411. sigh->enabled = TRUE;
  412. sigh->ev_sig.data = sigh;
  413. ev_signal_init(&sigh->ev_sig, rspamd_worker_signal_handle, signo);
  414. ev_signal_start(event_loop, &sigh->ev_sig);
  415. g_hash_table_insert(worker->signal_events,
  416. GINT_TO_POINTER(signo),
  417. sigh);
  418. }
  419. cb = g_malloc0(sizeof(*cb));
  420. cb->handler = handler;
  421. cb->handler_data = handler_data;
  422. DL_APPEND(sigh->cb, cb);
  423. }
  424. void rspamd_worker_init_signals(struct rspamd_worker *worker,
  425. struct ev_loop *event_loop)
  426. {
  427. /* A set of terminating signals */
  428. rspamd_worker_set_signal_handler(SIGTERM, worker, event_loop,
  429. rspamd_worker_term_handler, NULL);
  430. rspamd_worker_set_signal_handler(SIGINT, worker, event_loop,
  431. rspamd_worker_term_handler, NULL);
  432. rspamd_worker_set_signal_handler(SIGHUP, worker, event_loop,
  433. rspamd_worker_term_handler, NULL);
  434. /* Special purpose signals */
  435. rspamd_worker_set_signal_handler(SIGUSR1, worker, event_loop,
  436. rspamd_worker_usr1_handler, NULL);
  437. rspamd_worker_set_signal_handler(SIGUSR2, worker, event_loop,
  438. rspamd_worker_usr2_handler, NULL);
  439. }
  440. struct ev_loop *
  441. rspamd_prepare_worker(struct rspamd_worker *worker, const char *name,
  442. rspamd_accept_handler hdl)
  443. {
  444. struct ev_loop *event_loop;
  445. GList *cur;
  446. struct rspamd_worker_listen_socket *ls;
  447. struct rspamd_worker_accept_event *accept_ev;
  448. worker->signal_events = g_hash_table_new_full(g_direct_hash, g_direct_equal,
  449. NULL, rspamd_sigh_free);
  450. event_loop = ev_loop_new(rspamd_config_ev_backend_get(worker->srv->cfg));
  451. worker->srv->event_loop = event_loop;
  452. rspamd_worker_init_signals(worker, event_loop);
  453. rspamd_control_worker_add_default_cmd_handlers(worker, event_loop);
  454. rspamd_worker_heartbeat_start(worker, event_loop);
  455. rspamd_redis_pool_config(worker->srv->cfg->redis_pool,
  456. worker->srv->cfg, event_loop);
  457. /* Accept all sockets */
  458. if (hdl) {
  459. cur = worker->cf->listen_socks;
  460. while (cur) {
  461. ls = cur->data;
  462. if (ls->fd != -1) {
  463. accept_ev = g_malloc0(sizeof(*accept_ev));
  464. accept_ev->event_loop = event_loop;
  465. accept_ev->accept_ev.data = worker;
  466. ev_io_init(&accept_ev->accept_ev, hdl, ls->fd, EV_READ);
  467. ev_io_start(event_loop, &accept_ev->accept_ev);
  468. DL_APPEND(worker->accept_events, accept_ev);
  469. }
  470. cur = g_list_next(cur);
  471. }
  472. }
  473. return event_loop;
  474. }
  475. void rspamd_worker_stop_accept(struct rspamd_worker *worker)
  476. {
  477. struct rspamd_worker_accept_event *cur, *tmp;
  478. /* Remove all events */
  479. DL_FOREACH_SAFE(worker->accept_events, cur, tmp)
  480. {
  481. if (ev_can_stop(&cur->accept_ev)) {
  482. ev_io_stop(cur->event_loop, &cur->accept_ev);
  483. }
  484. if (ev_can_stop(&cur->throttling_ev)) {
  485. ev_timer_stop(cur->event_loop, &cur->throttling_ev);
  486. }
  487. g_free(cur);
  488. }
  489. /* XXX: we need to do it much later */
  490. #if 0
  491. g_hash_table_iter_init (&it, worker->signal_events);
  492. while (g_hash_table_iter_next (&it, &k, &v)) {
  493. sigh = (struct rspamd_worker_signal_handler *)v;
  494. g_hash_table_iter_steal (&it);
  495. if (sigh->enabled) {
  496. event_del (&sigh->ev);
  497. }
  498. g_free (sigh);
  499. }
  500. g_hash_table_unref (worker->signal_events);
  501. #endif
  502. }
  503. static rspamd_fstring_t *
  504. rspamd_controller_maybe_compress(struct rspamd_http_connection_entry *entry,
  505. rspamd_fstring_t *buf, struct rspamd_http_message *msg)
  506. {
  507. if (entry->support_gzip) {
  508. if (rspamd_fstring_gzip(&buf)) {
  509. rspamd_http_message_add_header(msg, "Content-Encoding", "gzip");
  510. }
  511. }
  512. return buf;
  513. }
  514. void rspamd_controller_send_error(struct rspamd_http_connection_entry *entry,
  515. int code, const char *error_msg, ...)
  516. {
  517. struct rspamd_http_message *msg;
  518. va_list args;
  519. rspamd_fstring_t *reply;
  520. msg = rspamd_http_new_message(HTTP_RESPONSE);
  521. va_start(args, error_msg);
  522. msg->status = rspamd_fstring_new();
  523. rspamd_vprintf_fstring(&msg->status, error_msg, args);
  524. va_end(args);
  525. msg->date = time(NULL);
  526. msg->code = code;
  527. reply = rspamd_fstring_sized_new(msg->status->len + 16);
  528. rspamd_printf_fstring(&reply, "{\"error\":\"%V\"}", msg->status);
  529. rspamd_http_message_set_body_from_fstring_steal(msg,
  530. rspamd_controller_maybe_compress(entry, reply, msg));
  531. rspamd_http_connection_reset(entry->conn);
  532. rspamd_http_router_insert_headers(entry->rt, msg);
  533. rspamd_http_connection_write_message(entry->conn,
  534. msg,
  535. NULL,
  536. "application/json",
  537. entry,
  538. entry->rt->timeout);
  539. entry->is_reply = TRUE;
  540. }
  541. void rspamd_controller_send_openmetrics(struct rspamd_http_connection_entry *entry,
  542. rspamd_fstring_t *str)
  543. {
  544. struct rspamd_http_message *msg;
  545. msg = rspamd_http_new_message(HTTP_RESPONSE);
  546. msg->date = time(NULL);
  547. msg->code = 200;
  548. msg->status = rspamd_fstring_new_init("OK", 2);
  549. rspamd_http_message_set_body_from_fstring_steal(msg,
  550. rspamd_controller_maybe_compress(entry, str, msg));
  551. rspamd_http_connection_reset(entry->conn);
  552. rspamd_http_router_insert_headers(entry->rt, msg);
  553. rspamd_http_connection_write_message(entry->conn,
  554. msg,
  555. NULL,
  556. "application/openmetrics-text; version=1.0.0; charset=utf-8",
  557. entry,
  558. entry->rt->timeout);
  559. entry->is_reply = TRUE;
  560. }
  561. void rspamd_controller_send_string(struct rspamd_http_connection_entry *entry,
  562. const char *str)
  563. {
  564. struct rspamd_http_message *msg;
  565. rspamd_fstring_t *reply;
  566. msg = rspamd_http_new_message(HTTP_RESPONSE);
  567. msg->date = time(NULL);
  568. msg->code = 200;
  569. msg->status = rspamd_fstring_new_init("OK", 2);
  570. if (str) {
  571. reply = rspamd_fstring_new_init(str, strlen(str));
  572. }
  573. else {
  574. reply = rspamd_fstring_new_init("null", 4);
  575. }
  576. rspamd_http_message_set_body_from_fstring_steal(msg,
  577. rspamd_controller_maybe_compress(entry, reply, msg));
  578. rspamd_http_connection_reset(entry->conn);
  579. rspamd_http_router_insert_headers(entry->rt, msg);
  580. rspamd_http_connection_write_message(entry->conn,
  581. msg,
  582. NULL,
  583. "application/json",
  584. entry,
  585. entry->rt->timeout);
  586. entry->is_reply = TRUE;
  587. }
  588. void rspamd_controller_send_ucl(struct rspamd_http_connection_entry *entry,
  589. ucl_object_t *obj)
  590. {
  591. struct rspamd_http_message *msg;
  592. rspamd_fstring_t *reply;
  593. msg = rspamd_http_new_message(HTTP_RESPONSE);
  594. msg->date = time(NULL);
  595. msg->code = 200;
  596. msg->status = rspamd_fstring_new_init("OK", 2);
  597. reply = rspamd_fstring_sized_new(BUFSIZ);
  598. rspamd_ucl_emit_fstring(obj, UCL_EMIT_JSON_COMPACT, &reply);
  599. rspamd_http_message_set_body_from_fstring_steal(msg,
  600. rspamd_controller_maybe_compress(entry, reply, msg));
  601. rspamd_http_connection_reset(entry->conn);
  602. rspamd_http_router_insert_headers(entry->rt, msg);
  603. rspamd_http_connection_write_message(entry->conn,
  604. msg,
  605. NULL,
  606. "application/json",
  607. entry,
  608. entry->rt->timeout);
  609. entry->is_reply = TRUE;
  610. }
  611. static void
  612. rspamd_worker_drop_priv(struct rspamd_main *rspamd_main)
  613. {
  614. if (rspamd_main->is_privileged) {
  615. if (setgid(rspamd_main->workers_gid) == -1) {
  616. msg_err_main("cannot setgid to %d (%s), aborting",
  617. (int) rspamd_main->workers_gid,
  618. strerror(errno));
  619. exit(-errno);
  620. }
  621. if (rspamd_main->cfg->rspamd_user &&
  622. initgroups(rspamd_main->cfg->rspamd_user,
  623. rspamd_main->workers_gid) == -1) {
  624. msg_err_main("initgroups failed (%s), aborting", strerror(errno));
  625. exit(-errno);
  626. }
  627. if (setuid(rspamd_main->workers_uid) == -1) {
  628. msg_err_main("cannot setuid to %d (%s), aborting",
  629. (int) rspamd_main->workers_uid,
  630. strerror(errno));
  631. exit(-errno);
  632. }
  633. }
  634. }
  635. static void
  636. rspamd_worker_set_limits(struct rspamd_main *rspamd_main,
  637. struct rspamd_worker_conf *cf)
  638. {
  639. struct rlimit rlmt;
  640. if (cf->rlimit_nofile != 0) {
  641. rlmt.rlim_cur = (rlim_t) cf->rlimit_nofile;
  642. rlmt.rlim_max = (rlim_t) cf->rlimit_nofile;
  643. if (setrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  644. msg_warn_main("cannot set files rlimit: %L, %s",
  645. cf->rlimit_nofile,
  646. strerror(errno));
  647. }
  648. memset(&rlmt, 0, sizeof(rlmt));
  649. if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  650. msg_warn_main("cannot get max files rlimit: %HL, %s",
  651. cf->rlimit_maxcore,
  652. strerror(errno));
  653. }
  654. else {
  655. msg_info_main("set max file descriptors limit: %HL cur and %HL max",
  656. (uint64_t) rlmt.rlim_cur,
  657. (uint64_t) rlmt.rlim_max);
  658. }
  659. }
  660. else {
  661. /* Just report */
  662. if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
  663. msg_warn_main("cannot get max files rlimit: %HL, %s",
  664. cf->rlimit_maxcore,
  665. strerror(errno));
  666. }
  667. else {
  668. msg_info_main("use system max file descriptors limit: %HL cur and %HL max",
  669. (uint64_t) rlmt.rlim_cur,
  670. (uint64_t) rlmt.rlim_max);
  671. }
  672. }
  673. if (rspamd_main->cores_throttling) {
  674. msg_info_main("disable core files for the new worker as limits are reached");
  675. rlmt.rlim_cur = 0;
  676. rlmt.rlim_max = 0;
  677. if (setrlimit(RLIMIT_CORE, &rlmt) == -1) {
  678. msg_warn_main("cannot disable core dumps: error when setting limits: %s",
  679. strerror(errno));
  680. }
  681. }
  682. else {
  683. if (cf->rlimit_maxcore != 0) {
  684. rlmt.rlim_cur = (rlim_t) cf->rlimit_maxcore;
  685. rlmt.rlim_max = (rlim_t) cf->rlimit_maxcore;
  686. if (setrlimit(RLIMIT_CORE, &rlmt) == -1) {
  687. msg_warn_main("cannot set max core size limit: %HL, %s",
  688. cf->rlimit_maxcore,
  689. strerror(errno));
  690. }
  691. /* Ensure that we did it */
  692. memset(&rlmt, 0, sizeof(rlmt));
  693. if (getrlimit(RLIMIT_CORE, &rlmt) == -1) {
  694. msg_warn_main("cannot get max core size rlimit: %HL, %s",
  695. cf->rlimit_maxcore,
  696. strerror(errno));
  697. }
  698. else {
  699. if (rlmt.rlim_cur != cf->rlimit_maxcore ||
  700. rlmt.rlim_max != cf->rlimit_maxcore) {
  701. msg_warn_main("setting of core file limits was unsuccessful: "
  702. "%HL was wanted, "
  703. "but we have %HL cur and %HL max",
  704. cf->rlimit_maxcore,
  705. (uint64_t) rlmt.rlim_cur,
  706. (uint64_t) rlmt.rlim_max);
  707. }
  708. else {
  709. msg_info_main("set max core size limit: %HL cur and %HL max",
  710. (uint64_t) rlmt.rlim_cur,
  711. (uint64_t) rlmt.rlim_max);
  712. }
  713. }
  714. }
  715. else {
  716. /* Just report */
  717. if (getrlimit(RLIMIT_CORE, &rlmt) == -1) {
  718. msg_warn_main("cannot get max core size limit: %HL, %s",
  719. cf->rlimit_maxcore,
  720. strerror(errno));
  721. }
  722. else {
  723. msg_info_main("use system max core size limit: %HL cur and %HL max",
  724. (uint64_t) rlmt.rlim_cur,
  725. (uint64_t) rlmt.rlim_max);
  726. }
  727. }
  728. }
  729. }
  730. static void
  731. rspamd_worker_on_term(EV_P_ ev_child *w, int revents)
  732. {
  733. struct rspamd_worker *wrk = (struct rspamd_worker *) w->data;
  734. if (wrk->ppid == getpid()) {
  735. if (wrk->term_handler) {
  736. wrk->term_handler(EV_A_ w, wrk->srv, wrk);
  737. }
  738. else {
  739. rspamd_check_termination_clause(wrk->srv, wrk, w->rstatus);
  740. }
  741. }
  742. else {
  743. /* Ignore SIGCHLD for not our children... */
  744. }
  745. }
  746. static void
  747. rspamd_worker_heartbeat_cb(EV_P_ ev_timer *w, int revents)
  748. {
  749. struct rspamd_worker *wrk = (struct rspamd_worker *) w->data;
  750. struct rspamd_srv_command cmd;
  751. memset(&cmd, 0, sizeof(cmd));
  752. cmd.type = RSPAMD_SRV_HEARTBEAT;
  753. rspamd_srv_send_command(wrk, EV_A, &cmd, -1, NULL, NULL);
  754. }
  755. static void
  756. rspamd_worker_heartbeat_start(struct rspamd_worker *wrk, struct ev_loop *event_loop)
  757. {
  758. wrk->hb.heartbeat_ev.data = (void *) wrk;
  759. ev_timer_init(&wrk->hb.heartbeat_ev, rspamd_worker_heartbeat_cb,
  760. 0.0, wrk->srv->cfg->heartbeat_interval);
  761. ev_timer_start(event_loop, &wrk->hb.heartbeat_ev);
  762. }
  763. static void
  764. rspamd_main_heartbeat_cb(EV_P_ ev_timer *w, int revents)
  765. {
  766. struct rspamd_worker *wrk = (struct rspamd_worker *) w->data;
  767. double time_from_last = ev_time();
  768. struct rspamd_main *rspamd_main;
  769. static struct rspamd_control_command cmd;
  770. struct tm tm;
  771. char timebuf[64];
  772. char usec_buf[16];
  773. int r;
  774. time_from_last -= wrk->hb.last_event;
  775. rspamd_main = wrk->srv;
  776. if (wrk->hb.last_event > 0 &&
  777. time_from_last > 0 &&
  778. time_from_last >= rspamd_main->cfg->heartbeat_interval * 2) {
  779. rspamd_localtime(wrk->hb.last_event, &tm);
  780. r = strftime(timebuf, sizeof(timebuf), "%F %H:%M:%S", &tm);
  781. rspamd_snprintf(usec_buf, sizeof(usec_buf), "%.5f",
  782. wrk->hb.last_event - (double) (time_t) wrk->hb.last_event);
  783. rspamd_snprintf(timebuf + r, sizeof(timebuf) - r,
  784. "%s", usec_buf + 1);
  785. if (wrk->hb.nbeats > 0) {
  786. /* First time lost event */
  787. cmd.type = RSPAMD_CONTROL_CHILD_CHANGE;
  788. cmd.cmd.child_change.what = rspamd_child_offline;
  789. cmd.cmd.child_change.pid = wrk->pid;
  790. rspamd_control_broadcast_srv_cmd(rspamd_main, &cmd, wrk->pid);
  791. msg_warn_main("lost heartbeat from worker type %s with pid %P, "
  792. "last beat on: %s (%L beats received previously)",
  793. g_quark_to_string(wrk->type), wrk->pid,
  794. timebuf,
  795. wrk->hb.nbeats);
  796. wrk->hb.nbeats = -1;
  797. /* TODO: send notify about worker problem */
  798. }
  799. else {
  800. wrk->hb.nbeats--;
  801. msg_warn_main("lost %L heartbeat from worker type %s with pid %P, "
  802. "last beat on: %s",
  803. -(wrk->hb.nbeats),
  804. g_quark_to_string(wrk->type),
  805. wrk->pid,
  806. timebuf);
  807. if (rspamd_main->cfg->heartbeats_loss_max > 0 &&
  808. -(wrk->hb.nbeats) >= rspamd_main->cfg->heartbeats_loss_max) {
  809. if (-(wrk->hb.nbeats) > rspamd_main->cfg->heartbeats_loss_max + 1) {
  810. msg_err_main("force kill worker type %s with pid %P, "
  811. "last beat on: %s; %L heartbeat lost",
  812. g_quark_to_string(wrk->type),
  813. wrk->pid,
  814. timebuf,
  815. -(wrk->hb.nbeats));
  816. kill(wrk->pid, SIGKILL);
  817. }
  818. else {
  819. msg_err_main("terminate worker type %s with pid %P, "
  820. "last beat on: %s; %L heartbeat lost",
  821. g_quark_to_string(wrk->type),
  822. wrk->pid,
  823. timebuf,
  824. -(wrk->hb.nbeats));
  825. kill(wrk->pid, SIGTERM);
  826. }
  827. }
  828. }
  829. }
  830. else if (wrk->hb.nbeats < 0) {
  831. rspamd_localtime(wrk->hb.last_event, &tm);
  832. r = strftime(timebuf, sizeof(timebuf), "%F %H:%M:%S", &tm);
  833. rspamd_snprintf(usec_buf, sizeof(usec_buf), "%.5f",
  834. wrk->hb.last_event - (double) (time_t) wrk->hb.last_event);
  835. rspamd_snprintf(timebuf + r, sizeof(timebuf) - r,
  836. "%s", usec_buf + 1);
  837. cmd.type = RSPAMD_CONTROL_CHILD_CHANGE;
  838. cmd.cmd.child_change.what = rspamd_child_online;
  839. cmd.cmd.child_change.pid = wrk->pid;
  840. rspamd_control_broadcast_srv_cmd(rspamd_main, &cmd, wrk->pid);
  841. msg_info_main("received heartbeat from worker type %s with pid %P, "
  842. "last beat on: %s (%L beats lost previously)",
  843. g_quark_to_string(wrk->type), wrk->pid,
  844. timebuf,
  845. -(wrk->hb.nbeats));
  846. wrk->hb.nbeats = 1;
  847. /* TODO: send notify about worker restoration */
  848. }
  849. }
  850. static void
  851. rspamd_main_heartbeat_start(struct rspamd_worker *wrk, struct ev_loop *event_loop)
  852. {
  853. wrk->hb.heartbeat_ev.data = (void *) wrk;
  854. ev_timer_init(&wrk->hb.heartbeat_ev, rspamd_main_heartbeat_cb,
  855. 0.0, wrk->srv->cfg->heartbeat_interval * 2);
  856. ev_timer_start(event_loop, &wrk->hb.heartbeat_ev);
  857. }
  858. static bool
  859. rspamd_maybe_reuseport_socket(struct rspamd_worker_listen_socket *ls)
  860. {
  861. if (ls->is_systemd) {
  862. /* No need to reuseport */
  863. return true;
  864. }
  865. if (ls->fd != -1 && rspamd_inet_address_get_af(ls->addr) == AF_UNIX) {
  866. /* Just try listen */
  867. if (listen(ls->fd, -1) == -1) {
  868. return false;
  869. }
  870. return true;
  871. }
  872. #if defined(SO_REUSEPORT) && defined(SO_REUSEADDR) && defined(LINUX)
  873. int nfd = -1;
  874. if (ls->type == RSPAMD_WORKER_SOCKET_UDP) {
  875. nfd = rspamd_inet_address_listen(ls->addr,
  876. (ls->type == RSPAMD_WORKER_SOCKET_UDP ? SOCK_DGRAM : SOCK_STREAM),
  877. RSPAMD_INET_ADDRESS_LISTEN_ASYNC | RSPAMD_INET_ADDRESS_LISTEN_REUSEPORT,
  878. -1);
  879. if (nfd == -1) {
  880. msg_warn("cannot create reuseport listen socket for %d: %s",
  881. ls->fd, strerror(errno));
  882. nfd = ls->fd;
  883. }
  884. else {
  885. if (ls->fd != -1) {
  886. close(ls->fd);
  887. }
  888. ls->fd = nfd;
  889. nfd = -1;
  890. }
  891. }
  892. else {
  893. /*
  894. * Reuseport is broken with the current architecture, so it is easier not
  895. * to use it at all
  896. */
  897. nfd = ls->fd;
  898. }
  899. #endif
  900. #if 0
  901. /* This needed merely if we have reuseport for tcp, but for now it is disabled */
  902. /* This means that we have an fd with no listening enabled */
  903. if (nfd != -1) {
  904. if (ls->type == RSPAMD_WORKER_SOCKET_TCP) {
  905. if (listen (nfd, -1) == -1) {
  906. return false;
  907. }
  908. }
  909. }
  910. #endif
  911. return true;
  912. }
  913. /**
  914. * Handles worker after fork returned zero
  915. * @param wrk
  916. * @param rspamd_main
  917. * @param cf
  918. * @param listen_sockets
  919. */
  920. static void __attribute__((noreturn))
  921. rspamd_handle_child_fork(struct rspamd_worker *wrk,
  922. struct rspamd_main *rspamd_main,
  923. struct rspamd_worker_conf *cf,
  924. GHashTable *listen_sockets)
  925. {
  926. int rc;
  927. struct rlimit rlim;
  928. /* Update pid for logging */
  929. rspamd_log_on_fork(cf->type, rspamd_main->cfg, rspamd_main->logger);
  930. wrk->pid = getpid();
  931. /* Init PRNG after fork */
  932. rc = ottery_init(rspamd_main->cfg->libs_ctx->ottery_cfg);
  933. if (rc != OTTERY_ERR_NONE) {
  934. msg_err_main("cannot initialize PRNG: %d", rc);
  935. abort();
  936. }
  937. rspamd_random_seed_fast();
  938. #ifdef HAVE_EVUTIL_RNG_INIT
  939. evutil_secure_rng_init();
  940. #endif
  941. /*
  942. * Libev stores all signals in a global table, so
  943. * previous handlers must be explicitly detached and forgotten
  944. * before starting a new loop
  945. */
  946. ev_signal_stop(rspamd_main->event_loop, &rspamd_main->int_ev);
  947. ev_signal_stop(rspamd_main->event_loop, &rspamd_main->term_ev);
  948. ev_signal_stop(rspamd_main->event_loop, &rspamd_main->hup_ev);
  949. ev_signal_stop(rspamd_main->event_loop, &rspamd_main->usr1_ev);
  950. /* Remove the inherited event base */
  951. ev_loop_destroy(rspamd_main->event_loop);
  952. rspamd_main->event_loop = NULL;
  953. /* Close unused sockets */
  954. GHashTableIter it;
  955. gpointer k, v;
  956. g_hash_table_iter_init(&it, listen_sockets);
  957. /*
  958. * Close listen sockets of not our process (inherited from other forks)
  959. */
  960. while (g_hash_table_iter_next(&it, &k, &v)) {
  961. GList *elt = (GList *) v;
  962. GList *our = cf->listen_socks;
  963. if (g_list_position(our, elt) == -1) {
  964. GList *cur = elt;
  965. while (cur) {
  966. struct rspamd_worker_listen_socket *ls =
  967. (struct rspamd_worker_listen_socket *) cur->data;
  968. if (ls->fd != -1 && close(ls->fd) == -1) {
  969. msg_err("cannot close fd %d (addr = %s): %s",
  970. ls->fd,
  971. rspamd_inet_address_to_string_pretty(ls->addr),
  972. strerror(errno));
  973. }
  974. ls->fd = -1;
  975. cur = g_list_next(cur);
  976. }
  977. }
  978. }
  979. /* Reuseport before dropping privs */
  980. GList *cur = cf->listen_socks;
  981. while (cur) {
  982. struct rspamd_worker_listen_socket *ls =
  983. (struct rspamd_worker_listen_socket *) cur->data;
  984. if (!rspamd_maybe_reuseport_socket(ls)) {
  985. msg_err("cannot listen on socket %s: %s",
  986. rspamd_inet_address_to_string_pretty(ls->addr),
  987. strerror(errno));
  988. }
  989. cur = g_list_next(cur);
  990. }
  991. /* Drop privileges */
  992. rspamd_worker_drop_priv(rspamd_main);
  993. /* Set limits */
  994. rspamd_worker_set_limits(rspamd_main, cf);
  995. /* Re-set stack limit */
  996. getrlimit(RLIMIT_STACK, &rlim);
  997. rlim.rlim_cur = 100 * 1024 * 1024;
  998. rlim.rlim_max = rlim.rlim_cur;
  999. setrlimit(RLIMIT_STACK, &rlim);
  1000. if (cf->bind_conf) {
  1001. rspamd_setproctitle("%s process (%s)", cf->worker->name,
  1002. cf->bind_conf->bind_line);
  1003. }
  1004. else {
  1005. rspamd_setproctitle("%s process", cf->worker->name);
  1006. }
  1007. if (rspamd_main->pfh) {
  1008. rspamd_pidfile_close(rspamd_main->pfh);
  1009. }
  1010. if (rspamd_main->cfg->log_silent_workers) {
  1011. rspamd_log_set_log_level(rspamd_main->logger, G_LOG_LEVEL_MESSAGE);
  1012. }
  1013. wrk->start_time = rspamd_get_calendar_ticks();
  1014. if (cf->bind_conf) {
  1015. GString *listen_conf_stringified = g_string_new(NULL);
  1016. struct rspamd_worker_bind_conf *cur_conf;
  1017. LL_FOREACH(cf->bind_conf, cur_conf)
  1018. {
  1019. if (cur_conf->next) {
  1020. rspamd_printf_gstring(listen_conf_stringified, "%s, ",
  1021. cur_conf->bind_line);
  1022. }
  1023. else {
  1024. rspamd_printf_gstring(listen_conf_stringified, "%s",
  1025. cur_conf->bind_line);
  1026. }
  1027. }
  1028. msg_info_main("starting %s process %P (%d); listen on: %v",
  1029. cf->worker->name,
  1030. getpid(), wrk->index, listen_conf_stringified);
  1031. g_string_free(listen_conf_stringified, TRUE);
  1032. }
  1033. else {
  1034. msg_info_main("starting %s process %P (%d); no listen",
  1035. cf->worker->name,
  1036. getpid(), wrk->index);
  1037. }
  1038. /* Close parent part of socketpair */
  1039. close(wrk->control_pipe[0]);
  1040. close(wrk->srv_pipe[0]);
  1041. /*
  1042. * Read comments in `rspamd_handle_main_fork` for details why these channel
  1043. * is blocking.
  1044. */
  1045. rspamd_socket_nonblocking(wrk->control_pipe[1]);
  1046. #if 0
  1047. rspamd_socket_nonblocking (wrk->srv_pipe[1]);
  1048. #endif
  1049. rspamd_main->cfg->cur_worker = wrk;
  1050. /* Execute worker (this function should not return normally!) */
  1051. cf->worker->worker_start_func(wrk);
  1052. /* To distinguish from normal termination */
  1053. exit(EXIT_FAILURE);
  1054. }
  1055. static void
  1056. rspamd_handle_main_fork(struct rspamd_worker *wrk,
  1057. struct rspamd_main *rspamd_main,
  1058. struct rspamd_worker_conf *cf,
  1059. struct ev_loop *ev_base)
  1060. {
  1061. /* Close worker part of socketpair */
  1062. close(wrk->control_pipe[1]);
  1063. close(wrk->srv_pipe[1]);
  1064. /*
  1065. * There are no reasons why control pipes are blocking: the messages
  1066. * there are rare and are strictly bounded by command sizes, so if we block
  1067. * on some pipe, it is ok, as we still poll that for all operations.
  1068. * It is also impossible to block on writing in normal conditions.
  1069. * And if the conditions are not normal, e.g. a worker is unresponsive, then
  1070. * we can safely think that the non-blocking behaviour as it is implemented
  1071. * currently will not make things better, as it would lead to incomplete
  1072. * reads/writes that are not handled anyhow and are totally broken from the
  1073. * beginning.
  1074. */
  1075. #if 0
  1076. rspamd_socket_nonblocking (wrk->srv_pipe[0]);
  1077. #endif
  1078. rspamd_socket_nonblocking(wrk->control_pipe[0]);
  1079. rspamd_srv_start_watching(rspamd_main, wrk, ev_base);
  1080. /* Child event */
  1081. wrk->cld_ev.data = wrk;
  1082. ev_child_init(&wrk->cld_ev, rspamd_worker_on_term, wrk->pid, 0);
  1083. ev_child_start(rspamd_main->event_loop, &wrk->cld_ev);
  1084. /* Heartbeats */
  1085. rspamd_main_heartbeat_start(wrk, rspamd_main->event_loop);
  1086. /* Insert worker into worker's table, pid is index */
  1087. g_hash_table_insert(rspamd_main->workers,
  1088. GSIZE_TO_POINTER(wrk->pid), wrk);
  1089. #if defined(SO_REUSEPORT) && defined(SO_REUSEADDR) && defined(LINUX)
  1090. /*
  1091. * Close listen sockets in the main process once a child is handling them,
  1092. * if we have reuseport
  1093. */
  1094. GList *cur = cf->listen_socks;
  1095. while (cur) {
  1096. struct rspamd_worker_listen_socket *ls =
  1097. (struct rspamd_worker_listen_socket *) cur->data;
  1098. if (ls->fd != -1 && ls->type == RSPAMD_WORKER_SOCKET_UDP) {
  1099. close(ls->fd);
  1100. ls->fd = -1;
  1101. }
  1102. cur = g_list_next(cur);
  1103. }
  1104. #endif
  1105. }
  1106. #ifndef SOCK_SEQPACKET
  1107. #define SOCK_SEQPACKET SOCK_DGRAM
  1108. #endif
  1109. struct rspamd_worker *
  1110. rspamd_fork_worker(struct rspamd_main *rspamd_main,
  1111. struct rspamd_worker_conf *cf,
  1112. unsigned int index,
  1113. struct ev_loop *ev_base,
  1114. rspamd_worker_term_cb term_handler,
  1115. GHashTable *listen_sockets)
  1116. {
  1117. struct rspamd_worker *wrk;
  1118. /* Starting worker process */
  1119. wrk = (struct rspamd_worker *) g_malloc0(sizeof(struct rspamd_worker));
  1120. if (!rspamd_socketpair(wrk->control_pipe, SOCK_SEQPACKET)) {
  1121. msg_err("socketpair failure: %s", strerror(errno));
  1122. rspamd_hard_terminate(rspamd_main);
  1123. }
  1124. if (!rspamd_socketpair(wrk->srv_pipe, SOCK_SEQPACKET)) {
  1125. msg_err("socketpair failure: %s", strerror(errno));
  1126. rspamd_hard_terminate(rspamd_main);
  1127. }
  1128. if (cf->bind_conf) {
  1129. msg_info_main("prepare to fork process %s (%d); listen on: %s",
  1130. cf->worker->name,
  1131. index, cf->bind_conf->name);
  1132. }
  1133. else {
  1134. msg_info_main("prepare to fork process %s (%d), no bind socket",
  1135. cf->worker->name,
  1136. index);
  1137. }
  1138. wrk->srv = rspamd_main;
  1139. wrk->type = cf->type;
  1140. wrk->cf = cf;
  1141. wrk->flags = cf->worker->flags;
  1142. REF_RETAIN(cf);
  1143. wrk->index = index;
  1144. wrk->ctx = cf->ctx;
  1145. wrk->ppid = getpid();
  1146. wrk->pid = fork();
  1147. wrk->cores_throttled = rspamd_main->cores_throttling;
  1148. wrk->term_handler = term_handler;
  1149. wrk->control_events_pending = g_hash_table_new_full(g_direct_hash, g_direct_equal,
  1150. NULL, rspamd_pending_control_free);
  1151. switch (wrk->pid) {
  1152. case 0:
  1153. rspamd_current_worker = wrk;
  1154. rspamd_handle_child_fork(wrk, rspamd_main, cf, listen_sockets);
  1155. break;
  1156. case -1:
  1157. msg_err_main("cannot fork main process: %s", strerror(errno));
  1158. if (rspamd_main->pfh) {
  1159. rspamd_pidfile_remove(rspamd_main->pfh);
  1160. }
  1161. rspamd_hard_terminate(rspamd_main);
  1162. break;
  1163. default:
  1164. rspamd_handle_main_fork(wrk, rspamd_main, cf, ev_base);
  1165. break;
  1166. }
  1167. return wrk;
  1168. }
  1169. void rspamd_worker_block_signals(void)
  1170. {
  1171. sigset_t set;
  1172. sigemptyset(&set);
  1173. sigaddset(&set, SIGTERM);
  1174. sigaddset(&set, SIGINT);
  1175. sigaddset(&set, SIGHUP);
  1176. sigaddset(&set, SIGUSR1);
  1177. sigaddset(&set, SIGUSR2);
  1178. sigprocmask(SIG_BLOCK, &set, NULL);
  1179. }
  1180. void rspamd_worker_unblock_signals(void)
  1181. {
  1182. sigset_t set;
  1183. sigemptyset(&set);
  1184. sigaddset(&set, SIGTERM);
  1185. sigaddset(&set, SIGINT);
  1186. sigaddset(&set, SIGHUP);
  1187. sigaddset(&set, SIGUSR1);
  1188. sigaddset(&set, SIGUSR2);
  1189. sigprocmask(SIG_UNBLOCK, &set, NULL);
  1190. }
  1191. void rspamd_hard_terminate(struct rspamd_main *rspamd_main)
  1192. {
  1193. GHashTableIter it;
  1194. gpointer k, v;
  1195. struct rspamd_worker *w;
  1196. sigset_t set;
  1197. /* Block all signals */
  1198. sigemptyset(&set);
  1199. sigaddset(&set, SIGTERM);
  1200. sigaddset(&set, SIGINT);
  1201. sigaddset(&set, SIGHUP);
  1202. sigaddset(&set, SIGUSR1);
  1203. sigaddset(&set, SIGUSR2);
  1204. sigaddset(&set, SIGCHLD);
  1205. sigprocmask(SIG_BLOCK, &set, NULL);
  1206. /* We need to terminate all workers that might be already spawned */
  1207. rspamd_worker_block_signals();
  1208. g_hash_table_iter_init(&it, rspamd_main->workers);
  1209. while (g_hash_table_iter_next(&it, &k, &v)) {
  1210. w = v;
  1211. msg_err_main("kill worker %P as Rspamd is terminating due to "
  1212. "an unrecoverable error",
  1213. w->pid);
  1214. kill(w->pid, SIGKILL);
  1215. }
  1216. msg_err_main("shutting down Rspamd due to fatal error");
  1217. rspamd_log_close(rspamd_main->logger);
  1218. exit(EXIT_FAILURE);
  1219. }
  1220. gboolean
  1221. rspamd_worker_is_scanner(struct rspamd_worker *w)
  1222. {
  1223. if (w) {
  1224. return !!(w->flags & RSPAMD_WORKER_SCANNER);
  1225. }
  1226. return FALSE;
  1227. }
  1228. gboolean
  1229. rspamd_worker_is_primary_controller(struct rspamd_worker *w)
  1230. {
  1231. if (w) {
  1232. return !!(w->flags & RSPAMD_WORKER_CONTROLLER) && w->index == 0;
  1233. }
  1234. return FALSE;
  1235. }
  1236. gboolean
  1237. rspamd_worker_check_controller_presence(struct rspamd_worker *w)
  1238. {
  1239. if (w->index == 0) {
  1240. GQuark our_type = w->type;
  1241. gboolean controller_seen = FALSE;
  1242. GList *cur;
  1243. enum {
  1244. low_priority_worker,
  1245. high_priority_worker
  1246. } our_priority;
  1247. if (our_type == g_quark_from_static_string("rspamd_proxy")) {
  1248. our_priority = low_priority_worker;
  1249. }
  1250. else if (our_type == g_quark_from_static_string("normal")) {
  1251. our_priority = high_priority_worker;
  1252. }
  1253. else {
  1254. msg_err("function is called for a wrong worker type: %s", g_quark_to_string(our_type));
  1255. return FALSE;
  1256. }
  1257. cur = w->srv->cfg->workers;
  1258. while (cur) {
  1259. struct rspamd_worker_conf *cf;
  1260. cf = (struct rspamd_worker_conf *) cur->data;
  1261. if (our_priority == low_priority_worker) {
  1262. if ((cf->type == g_quark_from_static_string("controller")) ||
  1263. (cf->type == g_quark_from_static_string("normal"))) {
  1264. if (cf->enabled && cf->count >= 0) {
  1265. controller_seen = TRUE;
  1266. break;
  1267. }
  1268. }
  1269. }
  1270. else {
  1271. if (cf->type == g_quark_from_static_string("controller")) {
  1272. if (cf->enabled && cf->count >= 0) {
  1273. controller_seen = TRUE;
  1274. break;
  1275. }
  1276. }
  1277. }
  1278. cur = g_list_next(cur);
  1279. }
  1280. if (!controller_seen) {
  1281. msg_info("no controller or normal workers defined, execute "
  1282. "controller periodics in this worker");
  1283. w->flags |= RSPAMD_WORKER_CONTROLLER;
  1284. return TRUE;
  1285. }
  1286. }
  1287. return FALSE;
  1288. }
  1289. struct rspamd_worker_session_elt {
  1290. void *ptr;
  1291. unsigned int *pref;
  1292. const char *tag;
  1293. time_t when;
  1294. };
  1295. struct rspamd_worker_session_cache {
  1296. struct ev_loop *ev_base;
  1297. GHashTable *cache;
  1298. struct rspamd_config *cfg;
  1299. struct ev_timer periodic;
  1300. };
  1301. static int
  1302. rspamd_session_cache_sort_cmp(gconstpointer pa, gconstpointer pb)
  1303. {
  1304. const struct rspamd_worker_session_elt
  1305. *e1 = *(const struct rspamd_worker_session_elt **) pa,
  1306. *e2 = *(const struct rspamd_worker_session_elt **) pb;
  1307. return e2->when < e1->when;
  1308. }
  1309. static void
  1310. rspamd_sessions_cache_periodic(EV_P_ ev_timer *w, int revents)
  1311. {
  1312. struct rspamd_worker_session_cache *c =
  1313. (struct rspamd_worker_session_cache *) w->data;
  1314. GHashTableIter it;
  1315. char timebuf[32];
  1316. gpointer k, v;
  1317. struct rspamd_worker_session_elt *elt;
  1318. struct tm tms;
  1319. GPtrArray *res;
  1320. unsigned int i;
  1321. if (g_hash_table_size(c->cache) > c->cfg->max_sessions_cache) {
  1322. res = g_ptr_array_sized_new(g_hash_table_size(c->cache));
  1323. g_hash_table_iter_init(&it, c->cache);
  1324. while (g_hash_table_iter_next(&it, &k, &v)) {
  1325. g_ptr_array_add(res, v);
  1326. }
  1327. msg_err("sessions cache is overflowed %d elements where %d is limit",
  1328. (int) res->len, (int) c->cfg->max_sessions_cache);
  1329. g_ptr_array_sort(res, rspamd_session_cache_sort_cmp);
  1330. PTR_ARRAY_FOREACH(res, i, elt)
  1331. {
  1332. rspamd_localtime(elt->when, &tms);
  1333. strftime(timebuf, sizeof(timebuf), "%F %H:%M:%S", &tms);
  1334. msg_warn("redundant session; ptr: %p, "
  1335. "tag: %s, refcount: %d, time: %s",
  1336. elt->ptr, elt->tag ? elt->tag : "unknown",
  1337. elt->pref ? *elt->pref : 0,
  1338. timebuf);
  1339. }
  1340. }
  1341. ev_timer_again(EV_A_ w);
  1342. }
  1343. void *
  1344. rspamd_worker_session_cache_new(struct rspamd_worker *w,
  1345. struct ev_loop *ev_base)
  1346. {
  1347. struct rspamd_worker_session_cache *c;
  1348. static const double periodic_interval = 60.0;
  1349. c = g_malloc0(sizeof(*c));
  1350. c->ev_base = ev_base;
  1351. c->cache = g_hash_table_new_full(g_direct_hash, g_direct_equal,
  1352. NULL, g_free);
  1353. c->cfg = w->srv->cfg;
  1354. c->periodic.data = c;
  1355. ev_timer_init(&c->periodic, rspamd_sessions_cache_periodic, periodic_interval,
  1356. periodic_interval);
  1357. ev_timer_start(ev_base, &c->periodic);
  1358. return c;
  1359. }
  1360. void rspamd_worker_session_cache_add(void *cache, const char *tag,
  1361. unsigned int *pref, void *ptr)
  1362. {
  1363. struct rspamd_worker_session_cache *c = cache;
  1364. struct rspamd_worker_session_elt *elt;
  1365. elt = g_malloc0(sizeof(*elt));
  1366. elt->pref = pref;
  1367. elt->ptr = ptr;
  1368. elt->tag = tag;
  1369. elt->when = time(NULL);
  1370. g_hash_table_insert(c->cache, elt->ptr, elt);
  1371. }
  1372. void rspamd_worker_session_cache_remove(void *cache, void *ptr)
  1373. {
  1374. struct rspamd_worker_session_cache *c = cache;
  1375. g_hash_table_remove(c->cache, ptr);
  1376. }
  1377. static void
  1378. rspamd_worker_monitored_on_change(struct rspamd_monitored_ctx *ctx,
  1379. struct rspamd_monitored *m, gboolean alive,
  1380. void *ud)
  1381. {
  1382. struct rspamd_worker *worker = ud;
  1383. struct rspamd_config *cfg = worker->srv->cfg;
  1384. struct ev_loop *ev_base;
  1385. unsigned char tag[RSPAMD_MONITORED_TAG_LEN];
  1386. static struct rspamd_srv_command srv_cmd;
  1387. rspamd_monitored_get_tag(m, tag);
  1388. ev_base = rspamd_monitored_ctx_get_ev_base(ctx);
  1389. memset(&srv_cmd, 0, sizeof(srv_cmd));
  1390. srv_cmd.type = RSPAMD_SRV_MONITORED_CHANGE;
  1391. rspamd_strlcpy(srv_cmd.cmd.monitored_change.tag, tag,
  1392. sizeof(srv_cmd.cmd.monitored_change.tag));
  1393. srv_cmd.cmd.monitored_change.alive = alive;
  1394. srv_cmd.cmd.monitored_change.sender = getpid();
  1395. msg_info_config("broadcast monitored update for %s: %s",
  1396. srv_cmd.cmd.monitored_change.tag, alive ? "alive" : "dead");
  1397. rspamd_srv_send_command(worker, ev_base, &srv_cmd, -1, NULL, NULL);
  1398. }
  1399. void rspamd_worker_init_monitored(struct rspamd_worker *worker,
  1400. struct ev_loop *ev_base,
  1401. struct rspamd_dns_resolver *resolver)
  1402. {
  1403. rspamd_monitored_ctx_config(worker->srv->cfg->monitored_ctx,
  1404. worker->srv->cfg, ev_base, resolver->r,
  1405. rspamd_worker_monitored_on_change, worker);
  1406. }
  1407. #ifdef HAVE_SA_SIGINFO
  1408. static struct rspamd_main *saved_main = NULL;
  1409. static gboolean
  1410. rspamd_crash_propagate(gpointer key, gpointer value, gpointer unused)
  1411. {
  1412. struct rspamd_worker *w = value;
  1413. /* Kill children softly */
  1414. kill(w->pid, SIGTERM);
  1415. return TRUE;
  1416. }
  1417. #ifdef BACKWARD_ENABLE
  1418. /* See backtrace.cxx */
  1419. extern void rspamd_print_crash(void);
  1420. #endif
  1421. static void
  1422. rspamd_crash_sig_handler(int sig, siginfo_t *info, void *ctx)
  1423. {
  1424. struct sigaction sa;
  1425. ucontext_t *uap = ctx;
  1426. pid_t pid;
  1427. pid = getpid();
  1428. msg_err("caught fatal signal %d(%s), "
  1429. "pid: %P, trace: ",
  1430. sig, strsignal(sig), pid);
  1431. (void) uap;
  1432. #ifdef BACKWARD_ENABLE
  1433. rspamd_print_crash();
  1434. #endif
  1435. msg_err("please see Rspamd FAQ to learn how to dump core files and how to "
  1436. "fill a bug report");
  1437. if (saved_main) {
  1438. if (pid == saved_main->pid) {
  1439. /*
  1440. * Main process has crashed, propagate crash further to trigger
  1441. * monitoring alerts and mass panic
  1442. */
  1443. g_hash_table_foreach_remove(saved_main->workers,
  1444. rspamd_crash_propagate, NULL);
  1445. }
  1446. }
  1447. /*
  1448. * Invoke signal with the default handler
  1449. */
  1450. sigemptyset(&sa.sa_mask);
  1451. sa.sa_handler = SIG_DFL;
  1452. sa.sa_flags = 0;
  1453. sigaction(sig, &sa, NULL);
  1454. kill(pid, sig);
  1455. }
  1456. #endif
  1457. RSPAMD_NO_SANITIZE void
  1458. rspamd_set_crash_handler(struct rspamd_main *rspamd_main)
  1459. {
  1460. #ifdef HAVE_SA_SIGINFO
  1461. struct sigaction sa;
  1462. #ifdef HAVE_SIGALTSTACK
  1463. void *stack_mem;
  1464. stack_t ss;
  1465. memset(&ss, 0, sizeof ss);
  1466. ss.ss_size = MAX(SIGSTKSZ, 8192 * 4);
  1467. stack_mem = g_malloc0(ss.ss_size);
  1468. ss.ss_sp = stack_mem;
  1469. sigaltstack(&ss, NULL);
  1470. #endif
  1471. saved_main = rspamd_main;
  1472. sigemptyset(&sa.sa_mask);
  1473. sa.sa_sigaction = &rspamd_crash_sig_handler;
  1474. sa.sa_flags = SA_RESTART | SA_SIGINFO | SA_ONSTACK;
  1475. sigaction(SIGSEGV, &sa, NULL);
  1476. sigaction(SIGBUS, &sa, NULL);
  1477. sigaction(SIGABRT, &sa, NULL);
  1478. sigaction(SIGFPE, &sa, NULL);
  1479. sigaction(SIGSYS, &sa, NULL);
  1480. #endif
  1481. }
  1482. RSPAMD_NO_SANITIZE void rspamd_unset_crash_handler(struct rspamd_main *unused_)
  1483. {
  1484. #ifdef HAVE_SIGALTSTACK
  1485. int ret;
  1486. stack_t ss;
  1487. ret = sigaltstack(NULL, &ss);
  1488. if (ret != -1) {
  1489. if (ss.ss_size > 0 && ss.ss_sp) {
  1490. g_free(ss.ss_sp);
  1491. }
  1492. ss.ss_size = 0;
  1493. ss.ss_sp = NULL;
  1494. #ifdef SS_DISABLE
  1495. ss.ss_flags |= SS_DISABLE;
  1496. #endif
  1497. sigaltstack(&ss, NULL);
  1498. }
  1499. #endif
  1500. }
  1501. static void
  1502. rspamd_enable_accept_event(EV_P_ ev_timer *w, int revents)
  1503. {
  1504. struct rspamd_worker_accept_event *ac_ev =
  1505. (struct rspamd_worker_accept_event *) w->data;
  1506. ev_timer_stop(EV_A_ w);
  1507. ev_io_start(EV_A_ & ac_ev->accept_ev);
  1508. }
  1509. void rspamd_worker_throttle_accept_events(int sock, void *data)
  1510. {
  1511. struct rspamd_worker_accept_event *head, *cur;
  1512. const double throttling = 0.5;
  1513. head = (struct rspamd_worker_accept_event *) data;
  1514. DL_FOREACH(head, cur)
  1515. {
  1516. ev_io_stop(cur->event_loop, &cur->accept_ev);
  1517. cur->throttling_ev.data = cur;
  1518. ev_timer_init(&cur->throttling_ev, rspamd_enable_accept_event,
  1519. throttling, 0.0);
  1520. ev_timer_start(cur->event_loop, &cur->throttling_ev);
  1521. }
  1522. }
  1523. gboolean
  1524. rspamd_check_termination_clause(struct rspamd_main *rspamd_main,
  1525. struct rspamd_worker *wrk,
  1526. int res)
  1527. {
  1528. gboolean need_refork = TRUE;
  1529. if (wrk->state != rspamd_worker_state_running || rspamd_main->wanna_die ||
  1530. (wrk->flags & RSPAMD_WORKER_OLD_CONFIG)) {
  1531. /* Do not refork workers that are intended to be terminated */
  1532. need_refork = FALSE;
  1533. }
  1534. if (WIFEXITED(res) && WEXITSTATUS(res) == 0) {
  1535. /* Normal worker termination, do not fork one more */
  1536. if (wrk->flags & RSPAMD_WORKER_OLD_CONFIG) {
  1537. /* Never re-fork old workers */
  1538. msg_info_main("%s process %P terminated normally",
  1539. g_quark_to_string(wrk->type),
  1540. wrk->pid);
  1541. need_refork = FALSE;
  1542. }
  1543. else {
  1544. if (wrk->hb.nbeats < 0 && rspamd_main->cfg->heartbeats_loss_max > 0 &&
  1545. -(wrk->hb.nbeats) >= rspamd_main->cfg->heartbeats_loss_max) {
  1546. msg_info_main("%s process %P terminated normally, but lost %L "
  1547. "heartbeats, refork it",
  1548. g_quark_to_string(wrk->type),
  1549. wrk->pid,
  1550. -(wrk->hb.nbeats));
  1551. need_refork = TRUE;
  1552. }
  1553. else {
  1554. msg_info_main("%s process %P terminated normally",
  1555. g_quark_to_string(wrk->type),
  1556. wrk->pid);
  1557. need_refork = FALSE;
  1558. }
  1559. }
  1560. }
  1561. else {
  1562. if (WIFSIGNALED(res)) {
  1563. #ifdef WCOREDUMP
  1564. if (WCOREDUMP(res)) {
  1565. msg_warn_main(
  1566. "%s process %P terminated abnormally by signal: %s"
  1567. " and created core file; please see Rspamd FAQ "
  1568. "to learn how to extract data from core file and "
  1569. "fill a bug report",
  1570. g_quark_to_string(wrk->type),
  1571. wrk->pid,
  1572. g_strsignal(WTERMSIG(res)));
  1573. }
  1574. else {
  1575. #ifdef HAVE_SYS_RESOURCE_H
  1576. struct rlimit rlmt;
  1577. (void) getrlimit(RLIMIT_CORE, &rlmt);
  1578. msg_warn_main(
  1579. "%s process %P terminated abnormally with exit code %d by "
  1580. "signal: %s"
  1581. " but NOT created core file (throttled=%s); "
  1582. "core file limits: %L current, %L max",
  1583. g_quark_to_string(wrk->type),
  1584. wrk->pid,
  1585. WEXITSTATUS(res),
  1586. g_strsignal(WTERMSIG(res)),
  1587. wrk->cores_throttled ? "yes" : "no",
  1588. (int64_t) rlmt.rlim_cur,
  1589. (int64_t) rlmt.rlim_max);
  1590. #else
  1591. msg_warn_main(
  1592. "%s process %P terminated abnormally with exit code %d by signal: %s"
  1593. " but NOT created core file (throttled=%s); ",
  1594. g_quark_to_string(wrk->type),
  1595. wrk->pid, WEXITSTATUS(res),
  1596. g_strsignal(WTERMSIG(res)),
  1597. wrk->cores_throttled ? "yes" : "no");
  1598. #endif
  1599. }
  1600. #else
  1601. msg_warn_main(
  1602. "%s process %P terminated abnormally with exit code %d by signal: %s",
  1603. g_quark_to_string(wrk->type),
  1604. wrk->pid, WEXITSTATUS(res),
  1605. g_strsignal(WTERMSIG(res)));
  1606. #endif
  1607. if (WTERMSIG(res) == SIGUSR2) {
  1608. /*
  1609. * It is actually race condition when not started process
  1610. * has been requested to be reloaded.
  1611. *
  1612. * We shouldn't refork on this
  1613. */
  1614. need_refork = FALSE;
  1615. }
  1616. }
  1617. else {
  1618. msg_warn_main("%s process %P terminated abnormally "
  1619. "(but it was not killed by a signal) "
  1620. "with exit code %d",
  1621. g_quark_to_string(wrk->type),
  1622. wrk->pid,
  1623. WEXITSTATUS(res));
  1624. }
  1625. }
  1626. return need_refork;
  1627. }
  1628. #ifdef WITH_HYPERSCAN
  1629. gboolean
  1630. rspamd_worker_hyperscan_ready(struct rspamd_main *rspamd_main,
  1631. struct rspamd_worker *worker, int fd,
  1632. int attached_fd,
  1633. struct rspamd_control_command *cmd,
  1634. gpointer ud)
  1635. {
  1636. struct rspamd_control_reply rep;
  1637. struct rspamd_re_cache *cache = worker->srv->cfg->re_cache;
  1638. memset(&rep, 0, sizeof(rep));
  1639. rep.type = RSPAMD_CONTROL_HYPERSCAN_LOADED;
  1640. if (rspamd_re_cache_is_hs_loaded(cache) != RSPAMD_HYPERSCAN_LOADED_FULL ||
  1641. cmd->cmd.hs_loaded.forced) {
  1642. msg_info("loading hyperscan expressions after receiving compilation "
  1643. "notice: %s",
  1644. (rspamd_re_cache_is_hs_loaded(cache) != RSPAMD_HYPERSCAN_LOADED_FULL) ? "new db" : "forced update");
  1645. rep.reply.hs_loaded.status = rspamd_re_cache_load_hyperscan(
  1646. worker->srv->cfg->re_cache, cmd->cmd.hs_loaded.cache_dir, false);
  1647. }
  1648. if (write(fd, &rep, sizeof(rep)) != sizeof(rep)) {
  1649. msg_err("cannot write reply to the control socket: %s",
  1650. strerror(errno));
  1651. }
  1652. return TRUE;
  1653. }
  1654. #endif /* With Hyperscan */
  1655. gboolean
  1656. rspamd_worker_check_context(gpointer ctx, uint64_t magic)
  1657. {
  1658. struct rspamd_abstract_worker_ctx *actx = (struct rspamd_abstract_worker_ctx *) ctx;
  1659. return actx->magic == magic;
  1660. }
  1661. static gboolean
  1662. rspamd_worker_log_pipe_handler(struct rspamd_main *rspamd_main,
  1663. struct rspamd_worker *worker, int fd,
  1664. int attached_fd,
  1665. struct rspamd_control_command *cmd,
  1666. gpointer ud)
  1667. {
  1668. struct rspamd_config *cfg = ud;
  1669. struct rspamd_worker_log_pipe *lp;
  1670. struct rspamd_control_reply rep;
  1671. memset(&rep, 0, sizeof(rep));
  1672. rep.type = RSPAMD_CONTROL_LOG_PIPE;
  1673. if (attached_fd != -1) {
  1674. lp = g_malloc0(sizeof(*lp));
  1675. lp->fd = attached_fd;
  1676. lp->type = cmd->cmd.log_pipe.type;
  1677. DL_APPEND(cfg->log_pipes, lp);
  1678. msg_info("added new log pipe");
  1679. }
  1680. else {
  1681. rep.reply.log_pipe.status = ENOENT;
  1682. msg_err("cannot attach log pipe: invalid fd");
  1683. }
  1684. if (write(fd, &rep, sizeof(rep)) != sizeof(rep)) {
  1685. msg_err("cannot write reply to the control socket: %s",
  1686. strerror(errno));
  1687. }
  1688. return TRUE;
  1689. }
  1690. static gboolean
  1691. rspamd_worker_monitored_handler(struct rspamd_main *rspamd_main,
  1692. struct rspamd_worker *worker, int fd,
  1693. int attached_fd,
  1694. struct rspamd_control_command *cmd,
  1695. gpointer ud)
  1696. {
  1697. struct rspamd_control_reply rep;
  1698. struct rspamd_monitored *m;
  1699. struct rspamd_monitored_ctx *mctx = worker->srv->cfg->monitored_ctx;
  1700. struct rspamd_config *cfg = ud;
  1701. memset(&rep, 0, sizeof(rep));
  1702. rep.type = RSPAMD_CONTROL_MONITORED_CHANGE;
  1703. if (cmd->cmd.monitored_change.sender != getpid()) {
  1704. m = rspamd_monitored_by_tag(mctx, cmd->cmd.monitored_change.tag);
  1705. if (m != NULL) {
  1706. rspamd_monitored_set_alive(m, cmd->cmd.monitored_change.alive);
  1707. rep.reply.monitored_change.status = 1;
  1708. msg_info_config("updated monitored status for %s: %s",
  1709. cmd->cmd.monitored_change.tag,
  1710. cmd->cmd.monitored_change.alive ? "alive" : "dead");
  1711. }
  1712. else {
  1713. msg_err("cannot find monitored by tag: %*s", 32,
  1714. cmd->cmd.monitored_change.tag);
  1715. rep.reply.monitored_change.status = 0;
  1716. }
  1717. }
  1718. if (write(fd, &rep, sizeof(rep)) != sizeof(rep)) {
  1719. msg_err("cannot write reply to the control socket: %s",
  1720. strerror(errno));
  1721. }
  1722. return TRUE;
  1723. }
  1724. void rspamd_worker_init_scanner(struct rspamd_worker *worker,
  1725. struct ev_loop *ev_base,
  1726. struct rspamd_dns_resolver *resolver,
  1727. struct rspamd_lang_detector **plang_det)
  1728. {
  1729. rspamd_stat_init(worker->srv->cfg, ev_base);
  1730. #ifdef WITH_HYPERSCAN
  1731. rspamd_control_worker_add_cmd_handler(worker,
  1732. RSPAMD_CONTROL_HYPERSCAN_LOADED,
  1733. rspamd_worker_hyperscan_ready,
  1734. NULL);
  1735. #endif
  1736. rspamd_control_worker_add_cmd_handler(worker,
  1737. RSPAMD_CONTROL_LOG_PIPE,
  1738. rspamd_worker_log_pipe_handler,
  1739. worker->srv->cfg);
  1740. rspamd_control_worker_add_cmd_handler(worker,
  1741. RSPAMD_CONTROL_MONITORED_CHANGE,
  1742. rspamd_worker_monitored_handler,
  1743. worker->srv->cfg);
  1744. *plang_det = worker->srv->cfg->lang_det;
  1745. }
  1746. void rspamd_controller_store_saved_stats(struct rspamd_main *rspamd_main,
  1747. struct rspamd_config *cfg)
  1748. {
  1749. struct rspamd_stat *stat;
  1750. ucl_object_t *top, *sub;
  1751. struct ucl_emitter_functions *efuncs;
  1752. int i, fd;
  1753. FILE *fp;
  1754. char fpath[PATH_MAX];
  1755. if (cfg->stats_file == NULL) {
  1756. return;
  1757. }
  1758. rspamd_snprintf(fpath, sizeof(fpath), "%s.XXXXXXXX", cfg->stats_file);
  1759. fd = g_mkstemp_full(fpath, O_WRONLY | O_TRUNC, 00644);
  1760. if (fd == -1) {
  1761. msg_err_config("cannot open for writing controller stats from %s: %s",
  1762. fpath, strerror(errno));
  1763. return;
  1764. }
  1765. fp = fdopen(fd, "w");
  1766. stat = rspamd_main->stat;
  1767. top = ucl_object_typed_new(UCL_OBJECT);
  1768. ucl_object_insert_key(top, ucl_object_fromint(stat->messages_scanned), "scanned", 0, false);
  1769. ucl_object_insert_key(top, ucl_object_fromint(stat->messages_learned), "learned", 0, false);
  1770. if (stat->messages_scanned > 0) {
  1771. sub = ucl_object_typed_new(UCL_OBJECT);
  1772. for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
  1773. ucl_object_insert_key(sub,
  1774. ucl_object_fromint(stat->actions_stat[i]),
  1775. rspamd_action_to_str(i), 0, false);
  1776. }
  1777. ucl_object_insert_key(top, sub, "actions", 0, false);
  1778. }
  1779. ucl_object_insert_key(top,
  1780. ucl_object_fromint(stat->connections_count),
  1781. "connections", 0, false);
  1782. ucl_object_insert_key(top,
  1783. ucl_object_fromint(stat->control_connections_count),
  1784. "control_connections", 0, false);
  1785. efuncs = ucl_object_emit_file_funcs(fp);
  1786. if (!ucl_object_emit_full(top, UCL_EMIT_JSON_COMPACT,
  1787. efuncs, NULL)) {
  1788. msg_err_config("cannot write stats to %s: %s",
  1789. fpath, strerror(errno));
  1790. unlink(fpath);
  1791. }
  1792. else {
  1793. if (rename(fpath, cfg->stats_file) == -1) {
  1794. msg_err_config("cannot rename stats from %s to %s: %s",
  1795. fpath, cfg->stats_file, strerror(errno));
  1796. }
  1797. }
  1798. ucl_object_unref(top);
  1799. fclose(fp);
  1800. ucl_object_emit_funcs_free(efuncs);
  1801. }
  1802. static ev_timer rrd_timer;
  1803. void rspamd_controller_on_terminate(struct rspamd_worker *worker,
  1804. struct rspamd_rrd_file *rrd)
  1805. {
  1806. struct rspamd_abstract_worker_ctx *ctx;
  1807. ctx = (struct rspamd_abstract_worker_ctx *) worker->ctx;
  1808. rspamd_controller_store_saved_stats(worker->srv, worker->srv->cfg);
  1809. if (rrd) {
  1810. ev_timer_stop(ctx->event_loop, &rrd_timer);
  1811. msg_info("closing rrd file: %s", rrd->filename);
  1812. rspamd_rrd_close(rrd);
  1813. }
  1814. }
  1815. static void
  1816. rspamd_controller_load_saved_stats(struct rspamd_main *rspamd_main,
  1817. struct rspamd_config *cfg)
  1818. {
  1819. struct ucl_parser *parser;
  1820. ucl_object_t *obj;
  1821. const ucl_object_t *elt, *subelt;
  1822. struct rspamd_stat *stat, stat_copy;
  1823. int i;
  1824. if (cfg->stats_file == NULL) {
  1825. return;
  1826. }
  1827. if (access(cfg->stats_file, R_OK) == -1) {
  1828. msg_err_config("cannot load controller stats from %s: %s",
  1829. cfg->stats_file, strerror(errno));
  1830. return;
  1831. }
  1832. parser = ucl_parser_new(0);
  1833. if (!ucl_parser_add_file(parser, cfg->stats_file)) {
  1834. msg_err_config("cannot parse controller stats from %s: %s",
  1835. cfg->stats_file, ucl_parser_get_error(parser));
  1836. ucl_parser_free(parser);
  1837. return;
  1838. }
  1839. obj = ucl_parser_get_object(parser);
  1840. ucl_parser_free(parser);
  1841. stat = rspamd_main->stat;
  1842. memcpy(&stat_copy, stat, sizeof(stat_copy));
  1843. elt = ucl_object_lookup(obj, "scanned");
  1844. if (elt != NULL && ucl_object_type(elt) == UCL_INT) {
  1845. stat_copy.messages_scanned = ucl_object_toint(elt);
  1846. }
  1847. elt = ucl_object_lookup(obj, "learned");
  1848. if (elt != NULL && ucl_object_type(elt) == UCL_INT) {
  1849. stat_copy.messages_learned = ucl_object_toint(elt);
  1850. }
  1851. elt = ucl_object_lookup(obj, "actions");
  1852. if (elt != NULL) {
  1853. for (i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
  1854. subelt = ucl_object_lookup(elt, rspamd_action_to_str(i));
  1855. if (subelt && ucl_object_type(subelt) == UCL_INT) {
  1856. stat_copy.actions_stat[i] = ucl_object_toint(subelt);
  1857. }
  1858. }
  1859. }
  1860. elt = ucl_object_lookup(obj, "connections_count");
  1861. if (elt != NULL && ucl_object_type(elt) == UCL_INT) {
  1862. stat_copy.connections_count = ucl_object_toint(elt);
  1863. }
  1864. elt = ucl_object_lookup(obj, "control_connections_count");
  1865. if (elt != NULL && ucl_object_type(elt) == UCL_INT) {
  1866. stat_copy.control_connections_count = ucl_object_toint(elt);
  1867. }
  1868. ucl_object_unref(obj);
  1869. memcpy(stat, &stat_copy, sizeof(stat_copy));
  1870. }
  1871. struct rspamd_controller_periodics_cbdata {
  1872. struct rspamd_worker *worker;
  1873. struct rspamd_rrd_file *rrd;
  1874. struct rspamd_stat *stat;
  1875. ev_timer save_stats_event;
  1876. };
  1877. static void
  1878. rspamd_controller_rrd_update(EV_P_ ev_timer *w, int revents)
  1879. {
  1880. struct rspamd_controller_periodics_cbdata *cbd =
  1881. (struct rspamd_controller_periodics_cbdata *) w->data;
  1882. struct rspamd_stat *stat;
  1883. GArray ar;
  1884. double points[METRIC_ACTION_MAX];
  1885. GError *err = NULL;
  1886. unsigned int i;
  1887. g_assert(cbd->rrd != NULL);
  1888. stat = cbd->stat;
  1889. for (i = METRIC_ACTION_REJECT; i < METRIC_ACTION_MAX; i++) {
  1890. points[i] = stat->actions_stat[i];
  1891. }
  1892. ar.data = (char *) points;
  1893. ar.len = sizeof(points);
  1894. if (!rspamd_rrd_add_record(cbd->rrd, &ar, rspamd_get_calendar_ticks(),
  1895. &err)) {
  1896. msg_err("cannot update rrd file: %e", err);
  1897. g_error_free(err);
  1898. }
  1899. /* Plan new event */
  1900. ev_timer_again(EV_A_ w);
  1901. }
  1902. static void
  1903. rspamd_controller_stats_save_periodic(EV_P_ ev_timer *w, int revents)
  1904. {
  1905. struct rspamd_controller_periodics_cbdata *cbd =
  1906. (struct rspamd_controller_periodics_cbdata *) w->data;
  1907. rspamd_controller_store_saved_stats(cbd->worker->srv, cbd->worker->srv->cfg);
  1908. ev_timer_again(EV_A_ w);
  1909. }
  1910. void rspamd_worker_init_controller(struct rspamd_worker *worker,
  1911. struct rspamd_rrd_file **prrd)
  1912. {
  1913. struct rspamd_abstract_worker_ctx *ctx;
  1914. static const ev_tstamp rrd_update_time = 1.0;
  1915. ctx = (struct rspamd_abstract_worker_ctx *) worker->ctx;
  1916. rspamd_controller_load_saved_stats(worker->srv, worker->srv->cfg);
  1917. if (worker->index == 0) {
  1918. /* Enable periodics and other stuff */
  1919. static struct rspamd_controller_periodics_cbdata cbd;
  1920. const ev_tstamp save_stats_interval = 60; /* 1 minute */
  1921. memset(&cbd, 0, sizeof(cbd));
  1922. cbd.save_stats_event.data = &cbd;
  1923. cbd.worker = worker;
  1924. cbd.stat = worker->srv->stat;
  1925. ev_timer_init(&cbd.save_stats_event,
  1926. rspamd_controller_stats_save_periodic,
  1927. save_stats_interval, save_stats_interval);
  1928. ev_timer_start(ctx->event_loop, &cbd.save_stats_event);
  1929. rspamd_map_watch(worker->srv->cfg, ctx->event_loop,
  1930. ctx->resolver, worker,
  1931. RSPAMD_MAP_WATCH_PRIMARY_CONTROLLER);
  1932. if (prrd != NULL) {
  1933. if (ctx->cfg->rrd_file && worker->index == 0) {
  1934. GError *rrd_err = NULL;
  1935. *prrd = rspamd_rrd_file_default(ctx->cfg->rrd_file, &rrd_err);
  1936. if (*prrd) {
  1937. cbd.rrd = *prrd;
  1938. rrd_timer.data = &cbd;
  1939. ev_timer_init(&rrd_timer, rspamd_controller_rrd_update,
  1940. rrd_update_time, rrd_update_time);
  1941. ev_timer_start(ctx->event_loop, &rrd_timer);
  1942. }
  1943. else if (rrd_err) {
  1944. msg_err("cannot load rrd from %s: %e", ctx->cfg->rrd_file,
  1945. rrd_err);
  1946. g_error_free(rrd_err);
  1947. }
  1948. else {
  1949. msg_err("cannot load rrd from %s: unknown error",
  1950. ctx->cfg->rrd_file);
  1951. }
  1952. }
  1953. else {
  1954. *prrd = NULL;
  1955. }
  1956. }
  1957. if (!ctx->cfg->disable_monitored) {
  1958. rspamd_worker_init_monitored(worker,
  1959. ctx->event_loop, ctx->resolver);
  1960. }
  1961. }
  1962. else {
  1963. rspamd_map_watch(worker->srv->cfg, ctx->event_loop,
  1964. ctx->resolver, worker, RSPAMD_MAP_WATCH_SCANNER);
  1965. }
  1966. }
  1967. double
  1968. rspamd_worker_check_and_adjust_timeout(struct rspamd_config *cfg, double timeout)
  1969. {
  1970. if (isnan(timeout)) {
  1971. /* Use implicit timeout from cfg->task_timeout */
  1972. timeout = cfg->task_timeout;
  1973. }
  1974. if (isnan(timeout)) {
  1975. return timeout;
  1976. }
  1977. struct rspamd_symcache_timeout_result *tres = rspamd_symcache_get_max_timeout(cfg->cache);
  1978. g_assert(tres != 0);
  1979. if (tres->max_timeout > timeout) {
  1980. msg_info_config("configured task_timeout %.2f is less than maximum symbols cache timeout %.2f; "
  1981. "some symbols can be terminated before checks",
  1982. timeout, tres->max_timeout);
  1983. GString *buf = g_string_sized_new(512);
  1984. static const int max_displayed_items = 12;
  1985. for (int i = 0; i < MIN(tres->nitems, max_displayed_items); i++) {
  1986. if (i == 0) {
  1987. rspamd_printf_gstring(buf, "%s(%.2f)",
  1988. rspamd_symcache_item_name((struct rspamd_symcache_item *) tres->items[i].item),
  1989. tres->items[i].timeout);
  1990. }
  1991. else {
  1992. rspamd_printf_gstring(buf, "; %s(%.2f)",
  1993. rspamd_symcache_item_name((struct rspamd_symcache_item *) tres->items[i].item),
  1994. tres->items[i].timeout);
  1995. }
  1996. }
  1997. msg_info_config("list of top %d symbols by execution time: %v",
  1998. (int) MIN(tres->nitems, max_displayed_items),
  1999. buf);
  2000. g_string_free(buf, TRUE);
  2001. }
  2002. rspamd_symcache_timeout_result_free(tres);
  2003. /* TODO: maybe adjust timeout */
  2004. return timeout;
  2005. }
  2006. ucl_object_t *
  2007. rspamd_worker_metrics_object(struct rspamd_config *cfg, struct rspamd_stat *stat, ev_tstamp uptime)
  2008. {
  2009. rspamd_mempool_stat_t mem_st;
  2010. memset(&mem_st, 0, sizeof(mem_st));
  2011. rspamd_mempool_stat(&mem_st);
  2012. ucl_object_t *top = ucl_object_typed_new(UCL_OBJECT);
  2013. ucl_object_insert_key(top, ucl_object_fromstring(RVERSION), "version", 0, false);
  2014. ucl_object_insert_key(top, ucl_object_fromstring(cfg->checksum), "config_id", 0, false);
  2015. ucl_object_insert_key(top, ucl_object_fromdouble(uptime), "uptime", 0, false);
  2016. ucl_object_insert_key(top, ucl_object_fromint(stat->messages_scanned), "scanned", 0, false);
  2017. ucl_object_insert_key(top, ucl_object_fromint(stat->messages_learned), "learned", 0, false);
  2018. gsize cnt = MAX_AVG_TIME_SLOTS;
  2019. float sum = rspamd_sum_floats(stat->avg_time.avg_time, &cnt);
  2020. ucl_object_insert_key(top,
  2021. ucl_object_fromdouble(cnt > 0 ? (double) sum / cnt : 0.0), "avg_scan_time", 0, false);
  2022. unsigned spam = 0, ham = 0;
  2023. if (stat->messages_scanned > 0) {
  2024. ucl_object_t *sub = ucl_object_typed_new(UCL_OBJECT);
  2025. for (int i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
  2026. ucl_object_insert_key(sub,
  2027. ucl_object_fromint(stat->actions_stat[i]),
  2028. rspamd_action_to_str(i), 0, false);
  2029. if (i < METRIC_ACTION_GREYLIST) {
  2030. spam += stat->actions_stat[i];
  2031. }
  2032. else {
  2033. ham += stat->actions_stat[i];
  2034. }
  2035. }
  2036. ucl_object_insert_key(top, sub, "actions", 0, false);
  2037. }
  2038. ucl_object_insert_key(top, ucl_object_fromint(spam), "spam_count", 0, false);
  2039. ucl_object_insert_key(top, ucl_object_fromint(ham), "ham_count", 0, false);
  2040. ucl_object_insert_key(top,
  2041. ucl_object_fromint(stat->connections_count), "connections", 0, false);
  2042. ucl_object_insert_key(top,
  2043. ucl_object_fromint(stat->control_connections_count),
  2044. "control_connections", 0, false);
  2045. ucl_object_insert_key(top,
  2046. ucl_object_fromint(mem_st.pools_allocated), "pools_allocated", 0,
  2047. false);
  2048. ucl_object_insert_key(top,
  2049. ucl_object_fromint(mem_st.pools_freed), "pools_freed", 0, false);
  2050. ucl_object_insert_key(top,
  2051. ucl_object_fromint(mem_st.bytes_allocated), "bytes_allocated", 0,
  2052. false);
  2053. ucl_object_insert_key(top,
  2054. ucl_object_fromint(
  2055. mem_st.chunks_allocated),
  2056. "chunks_allocated", 0, false);
  2057. ucl_object_insert_key(top,
  2058. ucl_object_fromint(mem_st.shared_chunks_allocated),
  2059. "shared_chunks_allocated", 0, false);
  2060. ucl_object_insert_key(top,
  2061. ucl_object_fromint(mem_st.chunks_freed), "chunks_freed", 0, false);
  2062. ucl_object_insert_key(top,
  2063. ucl_object_fromint(
  2064. mem_st.oversized_chunks),
  2065. "chunks_oversized", 0, false);
  2066. ucl_object_insert_key(top,
  2067. ucl_object_fromint(mem_st.fragmented_size), "fragmented", 0, false);
  2068. return top;
  2069. }
  2070. rspamd_fstring_t *
  2071. rspamd_metrics_to_prometheus_string(const ucl_object_t *top)
  2072. {
  2073. rspamd_fstring_t *output = rspamd_fstring_sized_new(1024);
  2074. rspamd_printf_fstring(&output, "# HELP rspamd_build_info A metric with a constant '1' value "
  2075. "labeled by version from which rspamd was built.\n");
  2076. rspamd_printf_fstring(&output, "# TYPE rspamd_build_info gauge\n");
  2077. rspamd_printf_fstring(&output, "rspamd_build_info{version=\"%s\"} 1\n",
  2078. ucl_object_tostring(ucl_object_lookup(top, "version")));
  2079. rspamd_printf_fstring(&output, "# HELP rspamd_config A metric with a constant '1' value "
  2080. "labeled by id of the current config.\n");
  2081. rspamd_printf_fstring(&output, "# TYPE rspamd_config gauge\n");
  2082. rspamd_printf_fstring(&output, "rspamd_config{id=\"%s\"} 1\n",
  2083. ucl_object_tostring(ucl_object_lookup(top, "config_id")));
  2084. rspamd_metrics_add_integer(&output, top,
  2085. "rspamd_scan_time_average",
  2086. "gauge",
  2087. "Average messages scan time.",
  2088. "avg_scan_time");
  2089. rspamd_metrics_add_integer(&output, top,
  2090. "process_start_time_seconds",
  2091. "gauge",
  2092. "Start time of the process since unix epoch in seconds.",
  2093. "start_time");
  2094. rspamd_metrics_add_integer(&output, top,
  2095. "rspamd_read_only",
  2096. "gauge",
  2097. "Whether the rspamd instance is read-only.",
  2098. "read_only");
  2099. rspamd_metrics_add_integer(&output, top,
  2100. "rspamd_scanned_total",
  2101. "counter",
  2102. "Scanned messages.",
  2103. "scanned");
  2104. rspamd_metrics_add_integer(&output, top,
  2105. "rspamd_learned_total",
  2106. "counter",
  2107. "Learned messages.",
  2108. "learned");
  2109. rspamd_metrics_add_integer(&output, top,
  2110. "rspamd_spam_total",
  2111. "counter",
  2112. "Messages classified as spam.",
  2113. "spam_count");
  2114. rspamd_metrics_add_integer(&output, top,
  2115. "rspamd_ham_total",
  2116. "counter",
  2117. "Messages classified as ham.",
  2118. "ham_count");
  2119. rspamd_metrics_add_integer(&output, top,
  2120. "rspamd_connections",
  2121. "gauge",
  2122. "Active connections.",
  2123. "connections");
  2124. rspamd_metrics_add_integer(&output, top,
  2125. "rspamd_control_connections_total",
  2126. "gauge",
  2127. "Control connections.",
  2128. "control_connections");
  2129. rspamd_metrics_add_integer(&output, top,
  2130. "rspamd_pools_allocated",
  2131. "gauge",
  2132. "Pools allocated.",
  2133. "pools_allocated");
  2134. rspamd_metrics_add_integer(&output, top,
  2135. "rspamd_pools_freed",
  2136. "gauge",
  2137. "Pools freed.",
  2138. "pools_freed");
  2139. rspamd_metrics_add_integer(&output, top,
  2140. "rspamd_allocated_bytes",
  2141. "gauge",
  2142. "Bytes allocated.",
  2143. "bytes_allocated");
  2144. rspamd_metrics_add_integer(&output, top,
  2145. "rspamd_chunks_allocated",
  2146. "gauge",
  2147. "Memory pools: current chunks allocated.",
  2148. "chunks_allocated");
  2149. rspamd_metrics_add_integer(&output, top,
  2150. "rspamd_shared_chunks_allocated",
  2151. "gauge",
  2152. "Memory pools: current shared chunks allocated.",
  2153. "shared_chunks_allocated");
  2154. rspamd_metrics_add_integer(&output, top,
  2155. "rspamd_chunks_freed",
  2156. "gauge",
  2157. "Memory pools: current chunks freed.",
  2158. "chunks_freed");
  2159. rspamd_metrics_add_integer(&output, top,
  2160. "rspamd_chunks_oversized",
  2161. "gauge",
  2162. "Memory pools: current chunks oversized (needs extra allocation/fragmentation).",
  2163. "chunks_oversized");
  2164. rspamd_metrics_add_integer(&output, top,
  2165. "rspamd_fragmented",
  2166. "gauge",
  2167. "Memory pools: fragmented memory waste.",
  2168. "fragmented");
  2169. const ucl_object_t *acts_obj = ucl_object_lookup(top, "actions");
  2170. if (acts_obj) {
  2171. rspamd_printf_fstring(&output, "# HELP rspamd_actions_total Actions labelled by action type.\n");
  2172. rspamd_printf_fstring(&output, "# TYPE rspamd_actions_total counter\n");
  2173. for (int i = METRIC_ACTION_REJECT; i <= METRIC_ACTION_NOACTION; i++) {
  2174. const char *str_act = rspamd_action_to_str(i);
  2175. const ucl_object_t *act = ucl_object_lookup(acts_obj, str_act);
  2176. if (act) {
  2177. rspamd_printf_fstring(&output, "rspamd_actions_total{type=\"%s\"} %L\n",
  2178. str_act,
  2179. ucl_object_toint(act));
  2180. }
  2181. else {
  2182. rspamd_printf_fstring(&output, "rspamd_actions_total{type=\"%s\"} 0\n",
  2183. str_act);
  2184. }
  2185. }
  2186. }
  2187. /* Must be finalized and freed by caller */
  2188. return output;
  2189. }