fs_probe.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* AFS fileserver probing
  3. *
  4. * Copyright (C) 2018, 2020 Red Hat, Inc. All Rights Reserved.
  5. * Written by David Howells (dhowells@redhat.com)
  6. */
  7. #include <linux/sched.h>
  8. #include <linux/slab.h>
  9. #include "afs_fs.h"
  10. #include "internal.h"
  11. #include "protocol_yfs.h"
  12. static unsigned int afs_fs_probe_fast_poll_interval = 30 * HZ;
  13. static unsigned int afs_fs_probe_slow_poll_interval = 5 * 60 * HZ;
  14. /*
  15. * Start the probe polling timer. We have to supply it with an inc on the
  16. * outstanding server count.
  17. */
  18. static void afs_schedule_fs_probe(struct afs_net *net,
  19. struct afs_server *server, bool fast)
  20. {
  21. unsigned long atj;
  22. if (!net->live)
  23. return;
  24. atj = server->probed_at;
  25. atj += fast ? afs_fs_probe_fast_poll_interval : afs_fs_probe_slow_poll_interval;
  26. afs_inc_servers_outstanding(net);
  27. if (timer_reduce(&net->fs_probe_timer, atj))
  28. afs_dec_servers_outstanding(net);
  29. }
  30. /*
  31. * Handle the completion of a set of probes.
  32. */
  33. static void afs_finished_fs_probe(struct afs_net *net, struct afs_server *server)
  34. {
  35. bool responded = server->probe.responded;
  36. write_seqlock(&net->fs_lock);
  37. if (responded) {
  38. list_add_tail(&server->probe_link, &net->fs_probe_slow);
  39. } else {
  40. server->rtt = UINT_MAX;
  41. clear_bit(AFS_SERVER_FL_RESPONDING, &server->flags);
  42. list_add_tail(&server->probe_link, &net->fs_probe_fast);
  43. }
  44. write_sequnlock(&net->fs_lock);
  45. afs_schedule_fs_probe(net, server, !responded);
  46. }
  47. /*
  48. * Handle the completion of a probe.
  49. */
  50. static void afs_done_one_fs_probe(struct afs_net *net, struct afs_server *server)
  51. {
  52. _enter("");
  53. if (atomic_dec_and_test(&server->probe_outstanding))
  54. afs_finished_fs_probe(net, server);
  55. wake_up_all(&server->probe_wq);
  56. }
  57. /*
  58. * Handle inability to send a probe due to ENOMEM when trying to allocate a
  59. * call struct.
  60. */
  61. static void afs_fs_probe_not_done(struct afs_net *net,
  62. struct afs_server *server,
  63. struct afs_addr_cursor *ac)
  64. {
  65. struct afs_addr_list *alist = ac->alist;
  66. unsigned int index = ac->index;
  67. _enter("");
  68. trace_afs_io_error(0, -ENOMEM, afs_io_error_fs_probe_fail);
  69. spin_lock(&server->probe_lock);
  70. server->probe.local_failure = true;
  71. if (server->probe.error == 0)
  72. server->probe.error = -ENOMEM;
  73. set_bit(index, &alist->failed);
  74. spin_unlock(&server->probe_lock);
  75. return afs_done_one_fs_probe(net, server);
  76. }
  77. /*
  78. * Process the result of probing a fileserver. This is called after successful
  79. * or failed delivery of an FS.GetCapabilities operation.
  80. */
  81. void afs_fileserver_probe_result(struct afs_call *call)
  82. {
  83. struct afs_addr_list *alist = call->alist;
  84. struct afs_server *server = call->server;
  85. unsigned int index = call->addr_ix;
  86. unsigned int rtt_us = 0;
  87. int ret = call->error;
  88. _enter("%pU,%u", &server->uuid, index);
  89. spin_lock(&server->probe_lock);
  90. switch (ret) {
  91. case 0:
  92. server->probe.error = 0;
  93. goto responded;
  94. case -ECONNABORTED:
  95. if (!server->probe.responded) {
  96. server->probe.abort_code = call->abort_code;
  97. server->probe.error = ret;
  98. }
  99. goto responded;
  100. case -ENOMEM:
  101. case -ENONET:
  102. clear_bit(index, &alist->responded);
  103. server->probe.local_failure = true;
  104. trace_afs_io_error(call->debug_id, ret, afs_io_error_fs_probe_fail);
  105. goto out;
  106. case -ECONNRESET: /* Responded, but call expired. */
  107. case -ERFKILL:
  108. case -EADDRNOTAVAIL:
  109. case -ENETUNREACH:
  110. case -EHOSTUNREACH:
  111. case -EHOSTDOWN:
  112. case -ECONNREFUSED:
  113. case -ETIMEDOUT:
  114. case -ETIME:
  115. default:
  116. clear_bit(index, &alist->responded);
  117. set_bit(index, &alist->failed);
  118. if (!server->probe.responded &&
  119. (server->probe.error == 0 ||
  120. server->probe.error == -ETIMEDOUT ||
  121. server->probe.error == -ETIME))
  122. server->probe.error = ret;
  123. trace_afs_io_error(call->debug_id, ret, afs_io_error_fs_probe_fail);
  124. goto out;
  125. }
  126. responded:
  127. clear_bit(index, &alist->failed);
  128. if (call->service_id == YFS_FS_SERVICE) {
  129. server->probe.is_yfs = true;
  130. set_bit(AFS_SERVER_FL_IS_YFS, &server->flags);
  131. alist->addrs[index].srx_service = call->service_id;
  132. } else {
  133. server->probe.not_yfs = true;
  134. if (!server->probe.is_yfs) {
  135. clear_bit(AFS_SERVER_FL_IS_YFS, &server->flags);
  136. alist->addrs[index].srx_service = call->service_id;
  137. }
  138. }
  139. if (rxrpc_kernel_get_srtt(call->net->socket, call->rxcall, &rtt_us) &&
  140. rtt_us < server->probe.rtt) {
  141. server->probe.rtt = rtt_us;
  142. server->rtt = rtt_us;
  143. alist->preferred = index;
  144. }
  145. smp_wmb(); /* Set rtt before responded. */
  146. server->probe.responded = true;
  147. set_bit(index, &alist->responded);
  148. set_bit(AFS_SERVER_FL_RESPONDING, &server->flags);
  149. out:
  150. spin_unlock(&server->probe_lock);
  151. _debug("probe %pU [%u] %pISpc rtt=%u ret=%d",
  152. &server->uuid, index, &alist->addrs[index].transport,
  153. rtt_us, ret);
  154. return afs_done_one_fs_probe(call->net, server);
  155. }
  156. /*
  157. * Probe one or all of a fileserver's addresses to find out the best route and
  158. * to query its capabilities.
  159. */
  160. void afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server,
  161. struct key *key, bool all)
  162. {
  163. struct afs_addr_cursor ac = {
  164. .index = 0,
  165. };
  166. _enter("%pU", &server->uuid);
  167. read_lock(&server->fs_lock);
  168. ac.alist = rcu_dereference_protected(server->addresses,
  169. lockdep_is_held(&server->fs_lock));
  170. afs_get_addrlist(ac.alist);
  171. read_unlock(&server->fs_lock);
  172. server->probed_at = jiffies;
  173. atomic_set(&server->probe_outstanding, all ? ac.alist->nr_addrs : 1);
  174. memset(&server->probe, 0, sizeof(server->probe));
  175. server->probe.rtt = UINT_MAX;
  176. ac.index = ac.alist->preferred;
  177. if (ac.index < 0 || ac.index >= ac.alist->nr_addrs)
  178. all = true;
  179. if (all) {
  180. for (ac.index = 0; ac.index < ac.alist->nr_addrs; ac.index++)
  181. if (!afs_fs_get_capabilities(net, server, &ac, key))
  182. afs_fs_probe_not_done(net, server, &ac);
  183. } else {
  184. if (!afs_fs_get_capabilities(net, server, &ac, key))
  185. afs_fs_probe_not_done(net, server, &ac);
  186. }
  187. afs_put_addrlist(ac.alist);
  188. }
  189. /*
  190. * Wait for the first as-yet untried fileserver to respond.
  191. */
  192. int afs_wait_for_fs_probes(struct afs_server_list *slist, unsigned long untried)
  193. {
  194. struct wait_queue_entry *waits;
  195. struct afs_server *server;
  196. unsigned int rtt = UINT_MAX, rtt_s;
  197. bool have_responders = false;
  198. int pref = -1, i;
  199. _enter("%u,%lx", slist->nr_servers, untried);
  200. /* Only wait for servers that have a probe outstanding. */
  201. for (i = 0; i < slist->nr_servers; i++) {
  202. if (test_bit(i, &untried)) {
  203. server = slist->servers[i].server;
  204. if (!atomic_read(&server->probe_outstanding))
  205. __clear_bit(i, &untried);
  206. if (server->probe.responded)
  207. have_responders = true;
  208. }
  209. }
  210. if (have_responders || !untried)
  211. return 0;
  212. waits = kmalloc(array_size(slist->nr_servers, sizeof(*waits)), GFP_KERNEL);
  213. if (!waits)
  214. return -ENOMEM;
  215. for (i = 0; i < slist->nr_servers; i++) {
  216. if (test_bit(i, &untried)) {
  217. server = slist->servers[i].server;
  218. init_waitqueue_entry(&waits[i], current);
  219. add_wait_queue(&server->probe_wq, &waits[i]);
  220. }
  221. }
  222. for (;;) {
  223. bool still_probing = false;
  224. set_current_state(TASK_INTERRUPTIBLE);
  225. for (i = 0; i < slist->nr_servers; i++) {
  226. if (test_bit(i, &untried)) {
  227. server = slist->servers[i].server;
  228. if (server->probe.responded)
  229. goto stop;
  230. if (atomic_read(&server->probe_outstanding))
  231. still_probing = true;
  232. }
  233. }
  234. if (!still_probing || signal_pending(current))
  235. goto stop;
  236. schedule();
  237. }
  238. stop:
  239. set_current_state(TASK_RUNNING);
  240. for (i = 0; i < slist->nr_servers; i++) {
  241. if (test_bit(i, &untried)) {
  242. server = slist->servers[i].server;
  243. rtt_s = READ_ONCE(server->rtt);
  244. if (test_bit(AFS_SERVER_FL_RESPONDING, &server->flags) &&
  245. rtt_s < rtt) {
  246. pref = i;
  247. rtt = rtt_s;
  248. }
  249. remove_wait_queue(&server->probe_wq, &waits[i]);
  250. }
  251. }
  252. kfree(waits);
  253. if (pref == -1 && signal_pending(current))
  254. return -ERESTARTSYS;
  255. if (pref >= 0)
  256. slist->preferred = pref;
  257. return 0;
  258. }
  259. /*
  260. * Probe timer. We have an increment on fs_outstanding that we need to pass
  261. * along to the work item.
  262. */
  263. void afs_fs_probe_timer(struct timer_list *timer)
  264. {
  265. struct afs_net *net = container_of(timer, struct afs_net, fs_probe_timer);
  266. if (!net->live || !queue_work(afs_wq, &net->fs_prober))
  267. afs_dec_servers_outstanding(net);
  268. }
  269. /*
  270. * Dispatch a probe to a server.
  271. */
  272. static void afs_dispatch_fs_probe(struct afs_net *net, struct afs_server *server, bool all)
  273. __releases(&net->fs_lock)
  274. {
  275. struct key *key = NULL;
  276. /* We remove it from the queues here - it will be added back to
  277. * one of the queues on the completion of the probe.
  278. */
  279. list_del_init(&server->probe_link);
  280. afs_get_server(server, afs_server_trace_get_probe);
  281. write_sequnlock(&net->fs_lock);
  282. afs_fs_probe_fileserver(net, server, key, all);
  283. afs_put_server(net, server, afs_server_trace_put_probe);
  284. }
  285. /*
  286. * Probe a server immediately without waiting for its due time to come
  287. * round. This is used when all of the addresses have been tried.
  288. */
  289. void afs_probe_fileserver(struct afs_net *net, struct afs_server *server)
  290. {
  291. write_seqlock(&net->fs_lock);
  292. if (!list_empty(&server->probe_link))
  293. return afs_dispatch_fs_probe(net, server, true);
  294. write_sequnlock(&net->fs_lock);
  295. }
  296. /*
  297. * Probe dispatcher to regularly dispatch probes to keep NAT alive.
  298. */
  299. void afs_fs_probe_dispatcher(struct work_struct *work)
  300. {
  301. struct afs_net *net = container_of(work, struct afs_net, fs_prober);
  302. struct afs_server *fast, *slow, *server;
  303. unsigned long nowj, timer_at, poll_at;
  304. bool first_pass = true, set_timer = false;
  305. if (!net->live)
  306. return;
  307. _enter("");
  308. if (list_empty(&net->fs_probe_fast) && list_empty(&net->fs_probe_slow)) {
  309. _leave(" [none]");
  310. return;
  311. }
  312. again:
  313. write_seqlock(&net->fs_lock);
  314. fast = slow = server = NULL;
  315. nowj = jiffies;
  316. timer_at = nowj + MAX_JIFFY_OFFSET;
  317. if (!list_empty(&net->fs_probe_fast)) {
  318. fast = list_first_entry(&net->fs_probe_fast, struct afs_server, probe_link);
  319. poll_at = fast->probed_at + afs_fs_probe_fast_poll_interval;
  320. if (time_before(nowj, poll_at)) {
  321. timer_at = poll_at;
  322. set_timer = true;
  323. fast = NULL;
  324. }
  325. }
  326. if (!list_empty(&net->fs_probe_slow)) {
  327. slow = list_first_entry(&net->fs_probe_slow, struct afs_server, probe_link);
  328. poll_at = slow->probed_at + afs_fs_probe_slow_poll_interval;
  329. if (time_before(nowj, poll_at)) {
  330. if (time_before(poll_at, timer_at))
  331. timer_at = poll_at;
  332. set_timer = true;
  333. slow = NULL;
  334. }
  335. }
  336. server = fast ?: slow;
  337. if (server)
  338. _debug("probe %pU", &server->uuid);
  339. if (server && (first_pass || !need_resched())) {
  340. afs_dispatch_fs_probe(net, server, server == fast);
  341. first_pass = false;
  342. goto again;
  343. }
  344. write_sequnlock(&net->fs_lock);
  345. if (server) {
  346. if (!queue_work(afs_wq, &net->fs_prober))
  347. afs_dec_servers_outstanding(net);
  348. _leave(" [requeue]");
  349. } else if (set_timer) {
  350. if (timer_reduce(&net->fs_probe_timer, timer_at))
  351. afs_dec_servers_outstanding(net);
  352. _leave(" [timer]");
  353. } else {
  354. afs_dec_servers_outstanding(net);
  355. _leave(" [quiesce]");
  356. }
  357. }
  358. /*
  359. * Wait for a probe on a particular fileserver to complete for 2s.
  360. */
  361. int afs_wait_for_one_fs_probe(struct afs_server *server, bool is_intr)
  362. {
  363. struct wait_queue_entry wait;
  364. unsigned long timo = 2 * HZ;
  365. if (atomic_read(&server->probe_outstanding) == 0)
  366. goto dont_wait;
  367. init_wait_entry(&wait, 0);
  368. for (;;) {
  369. prepare_to_wait_event(&server->probe_wq, &wait,
  370. is_intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
  371. if (timo == 0 ||
  372. server->probe.responded ||
  373. atomic_read(&server->probe_outstanding) == 0 ||
  374. (is_intr && signal_pending(current)))
  375. break;
  376. timo = schedule_timeout(timo);
  377. }
  378. finish_wait(&server->probe_wq, &wait);
  379. dont_wait:
  380. if (server->probe.responded)
  381. return 0;
  382. if (is_intr && signal_pending(current))
  383. return -ERESTARTSYS;
  384. if (timo == 0)
  385. return -ETIME;
  386. return -EDESTADDRREQ;
  387. }
  388. /*
  389. * Clean up the probing when the namespace is killed off.
  390. */
  391. void afs_fs_probe_cleanup(struct afs_net *net)
  392. {
  393. if (del_timer_sync(&net->fs_probe_timer))
  394. afs_dec_servers_outstanding(net);
  395. }