2
0

xen_backend.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619
  1. /*
  2. * xen backend driver infrastructure
  3. * (c) 2008 Gerd Hoffmann <kraxel@redhat.com>
  4. *
  5. * This program is free software; you can redistribute it and/or modify
  6. * it under the terms of the GNU General Public License as published by
  7. * the Free Software Foundation; under version 2 of the License.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License along
  15. * with this program; if not, see <http://www.gnu.org/licenses/>.
  16. *
  17. * Contributions after 2012-01-13 are licensed under the terms of the
  18. * GNU GPL, version 2 or (at your option) any later version.
  19. */
  20. /*
  21. * TODO: add some xenbus / xenstore concepts overview here.
  22. */
  23. #include "qemu/osdep.h"
  24. #include <sys/signal.h>
  25. #include "hw/hw.h"
  26. #include "hw/sysbus.h"
  27. #include "sysemu/char.h"
  28. #include "qemu/log.h"
  29. #include "hw/xen/xen_backend.h"
  30. #include "hw/xen/xen_pvdev.h"
  31. #include <xen/grant_table.h>
  32. #define TYPE_XENSYSDEV "xensysdev"
  33. DeviceState *xen_sysdev;
  34. /* ------------------------------------------------------------- */
  35. /* public */
  36. xc_interface *xen_xc = NULL;
  37. xenforeignmemory_handle *xen_fmem = NULL;
  38. struct xs_handle *xenstore = NULL;
  39. const char *xen_protocol;
  40. /* private */
  41. static int debug;
  42. int xenstore_write_be_str(struct XenDevice *xendev, const char *node, const char *val)
  43. {
  44. return xenstore_write_str(xendev->be, node, val);
  45. }
  46. int xenstore_write_be_int(struct XenDevice *xendev, const char *node, int ival)
  47. {
  48. return xenstore_write_int(xendev->be, node, ival);
  49. }
  50. int xenstore_write_be_int64(struct XenDevice *xendev, const char *node, int64_t ival)
  51. {
  52. return xenstore_write_int64(xendev->be, node, ival);
  53. }
  54. char *xenstore_read_be_str(struct XenDevice *xendev, const char *node)
  55. {
  56. return xenstore_read_str(xendev->be, node);
  57. }
  58. int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival)
  59. {
  60. return xenstore_read_int(xendev->be, node, ival);
  61. }
  62. char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node)
  63. {
  64. return xenstore_read_str(xendev->fe, node);
  65. }
  66. int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival)
  67. {
  68. return xenstore_read_int(xendev->fe, node, ival);
  69. }
  70. int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node,
  71. uint64_t *uval)
  72. {
  73. return xenstore_read_uint64(xendev->fe, node, uval);
  74. }
  75. /* ------------------------------------------------------------- */
  76. int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state)
  77. {
  78. int rc;
  79. rc = xenstore_write_be_int(xendev, "state", state);
  80. if (rc < 0) {
  81. return rc;
  82. }
  83. xen_pv_printf(xendev, 1, "backend state: %s -> %s\n",
  84. xenbus_strstate(xendev->be_state), xenbus_strstate(state));
  85. xendev->be_state = state;
  86. return 0;
  87. }
  88. /*
  89. * get xen backend device, allocate a new one if it doesn't exist.
  90. */
  91. static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev,
  92. struct XenDevOps *ops)
  93. {
  94. struct XenDevice *xendev;
  95. xendev = xen_be_find_xendev(type, dom, dev);
  96. if (xendev) {
  97. return xendev;
  98. }
  99. /* init new xendev */
  100. xendev = g_malloc0(ops->size);
  101. xendev->type = type;
  102. xendev->dom = dom;
  103. xendev->dev = dev;
  104. xendev->ops = ops;
  105. snprintf(xendev->be, sizeof(xendev->be), "backend/%s/%d/%d",
  106. xendev->type, xendev->dom, xendev->dev);
  107. snprintf(xendev->name, sizeof(xendev->name), "%s-%d",
  108. xendev->type, xendev->dev);
  109. xendev->debug = debug;
  110. xendev->local_port = -1;
  111. xendev->evtchndev = xenevtchn_open(NULL, 0);
  112. if (xendev->evtchndev == NULL) {
  113. xen_pv_printf(NULL, 0, "can't open evtchn device\n");
  114. g_free(xendev);
  115. return NULL;
  116. }
  117. fcntl(xenevtchn_fd(xendev->evtchndev), F_SETFD, FD_CLOEXEC);
  118. if (ops->flags & DEVOPS_FLAG_NEED_GNTDEV) {
  119. xendev->gnttabdev = xengnttab_open(NULL, 0);
  120. if (xendev->gnttabdev == NULL) {
  121. xen_pv_printf(NULL, 0, "can't open gnttab device\n");
  122. xenevtchn_close(xendev->evtchndev);
  123. g_free(xendev);
  124. return NULL;
  125. }
  126. } else {
  127. xendev->gnttabdev = NULL;
  128. }
  129. xen_pv_insert_xendev(xendev);
  130. if (xendev->ops->alloc) {
  131. xendev->ops->alloc(xendev);
  132. }
  133. return xendev;
  134. }
  135. /*
  136. * Sync internal data structures on xenstore updates.
  137. * Node specifies the changed field. node = NULL means
  138. * update all fields (used for initialization).
  139. */
  140. static void xen_be_backend_changed(struct XenDevice *xendev, const char *node)
  141. {
  142. if (node == NULL || strcmp(node, "online") == 0) {
  143. if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1) {
  144. xendev->online = 0;
  145. }
  146. }
  147. if (node) {
  148. xen_pv_printf(xendev, 2, "backend update: %s\n", node);
  149. if (xendev->ops->backend_changed) {
  150. xendev->ops->backend_changed(xendev, node);
  151. }
  152. }
  153. }
  154. static void xen_be_frontend_changed(struct XenDevice *xendev, const char *node)
  155. {
  156. int fe_state;
  157. if (node == NULL || strcmp(node, "state") == 0) {
  158. if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) {
  159. fe_state = XenbusStateUnknown;
  160. }
  161. if (xendev->fe_state != fe_state) {
  162. xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n",
  163. xenbus_strstate(xendev->fe_state),
  164. xenbus_strstate(fe_state));
  165. }
  166. xendev->fe_state = fe_state;
  167. }
  168. if (node == NULL || strcmp(node, "protocol") == 0) {
  169. g_free(xendev->protocol);
  170. xendev->protocol = xenstore_read_fe_str(xendev, "protocol");
  171. if (xendev->protocol) {
  172. xen_pv_printf(xendev, 1, "frontend protocol: %s\n",
  173. xendev->protocol);
  174. }
  175. }
  176. if (node) {
  177. xen_pv_printf(xendev, 2, "frontend update: %s\n", node);
  178. if (xendev->ops->frontend_changed) {
  179. xendev->ops->frontend_changed(xendev, node);
  180. }
  181. }
  182. }
  183. /* ------------------------------------------------------------- */
  184. /* Check for possible state transitions and perform them. */
  185. /*
  186. * Initial xendev setup. Read frontend path, register watch for it.
  187. * Should succeed once xend finished setting up the backend device.
  188. *
  189. * Also sets initial state (-> Initializing) when done. Which
  190. * only affects the xendev->be_state variable as xenbus should
  191. * already be put into that state by xend.
  192. */
  193. static int xen_be_try_setup(struct XenDevice *xendev)
  194. {
  195. char token[XEN_BUFSIZE];
  196. int be_state;
  197. if (xenstore_read_be_int(xendev, "state", &be_state) == -1) {
  198. xen_pv_printf(xendev, 0, "reading backend state failed\n");
  199. return -1;
  200. }
  201. if (be_state != XenbusStateInitialising) {
  202. xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n",
  203. xenbus_strstate(be_state));
  204. return -1;
  205. }
  206. xendev->fe = xenstore_read_be_str(xendev, "frontend");
  207. if (xendev->fe == NULL) {
  208. xen_pv_printf(xendev, 0, "reading frontend path failed\n");
  209. return -1;
  210. }
  211. /* setup frontend watch */
  212. snprintf(token, sizeof(token), "fe:%p", xendev);
  213. if (!xs_watch(xenstore, xendev->fe, token)) {
  214. xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n",
  215. xendev->fe);
  216. return -1;
  217. }
  218. xen_be_set_state(xendev, XenbusStateInitialising);
  219. xen_be_backend_changed(xendev, NULL);
  220. xen_be_frontend_changed(xendev, NULL);
  221. return 0;
  222. }
  223. /*
  224. * Try initialize xendev. Prepare everything the backend can do
  225. * without synchronizing with the frontend. Fakes hotplug-status. No
  226. * hotplug involved here because this is about userspace drivers, thus
  227. * there are kernel backend devices which could invoke hotplug.
  228. *
  229. * Goes to InitWait on success.
  230. */
  231. static int xen_be_try_init(struct XenDevice *xendev)
  232. {
  233. int rc = 0;
  234. if (!xendev->online) {
  235. xen_pv_printf(xendev, 1, "not online\n");
  236. return -1;
  237. }
  238. if (xendev->ops->init) {
  239. rc = xendev->ops->init(xendev);
  240. }
  241. if (rc != 0) {
  242. xen_pv_printf(xendev, 1, "init() failed\n");
  243. return rc;
  244. }
  245. xenstore_write_be_str(xendev, "hotplug-status", "connected");
  246. xen_be_set_state(xendev, XenbusStateInitWait);
  247. return 0;
  248. }
  249. /*
  250. * Try to initialise xendev. Depends on the frontend being ready
  251. * for it (shared ring and evtchn info in xenstore, state being
  252. * Initialised or Connected).
  253. *
  254. * Goes to Connected on success.
  255. */
  256. static int xen_be_try_initialise(struct XenDevice *xendev)
  257. {
  258. int rc = 0;
  259. if (xendev->fe_state != XenbusStateInitialised &&
  260. xendev->fe_state != XenbusStateConnected) {
  261. if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
  262. xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
  263. } else {
  264. xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
  265. return -1;
  266. }
  267. }
  268. if (xendev->ops->initialise) {
  269. rc = xendev->ops->initialise(xendev);
  270. }
  271. if (rc != 0) {
  272. xen_pv_printf(xendev, 0, "initialise() failed\n");
  273. return rc;
  274. }
  275. xen_be_set_state(xendev, XenbusStateConnected);
  276. return 0;
  277. }
  278. /*
  279. * Try to let xendev know that it is connected. Depends on the
  280. * frontend being Connected. Note that this may be called more
  281. * than once since the backend state is not modified.
  282. */
  283. static void xen_be_try_connected(struct XenDevice *xendev)
  284. {
  285. if (!xendev->ops->connected) {
  286. return;
  287. }
  288. if (xendev->fe_state != XenbusStateConnected) {
  289. if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) {
  290. xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n");
  291. } else {
  292. xen_pv_printf(xendev, 2, "frontend not ready (yet)\n");
  293. return;
  294. }
  295. }
  296. xendev->ops->connected(xendev);
  297. }
  298. /*
  299. * Teardown connection.
  300. *
  301. * Goes to Closed when done.
  302. */
  303. static void xen_be_disconnect(struct XenDevice *xendev, enum xenbus_state state)
  304. {
  305. if (xendev->be_state != XenbusStateClosing &&
  306. xendev->be_state != XenbusStateClosed &&
  307. xendev->ops->disconnect) {
  308. xendev->ops->disconnect(xendev);
  309. }
  310. if (xendev->be_state != state) {
  311. xen_be_set_state(xendev, state);
  312. }
  313. }
  314. /*
  315. * Try to reset xendev, for reconnection by another frontend instance.
  316. */
  317. static int xen_be_try_reset(struct XenDevice *xendev)
  318. {
  319. if (xendev->fe_state != XenbusStateInitialising) {
  320. return -1;
  321. }
  322. xen_pv_printf(xendev, 1, "device reset (for re-connect)\n");
  323. xen_be_set_state(xendev, XenbusStateInitialising);
  324. return 0;
  325. }
  326. /*
  327. * state change dispatcher function
  328. */
  329. void xen_be_check_state(struct XenDevice *xendev)
  330. {
  331. int rc = 0;
  332. /* frontend may request shutdown from almost anywhere */
  333. if (xendev->fe_state == XenbusStateClosing ||
  334. xendev->fe_state == XenbusStateClosed) {
  335. xen_be_disconnect(xendev, xendev->fe_state);
  336. return;
  337. }
  338. /* check for possible backend state transitions */
  339. for (;;) {
  340. switch (xendev->be_state) {
  341. case XenbusStateUnknown:
  342. rc = xen_be_try_setup(xendev);
  343. break;
  344. case XenbusStateInitialising:
  345. rc = xen_be_try_init(xendev);
  346. break;
  347. case XenbusStateInitWait:
  348. rc = xen_be_try_initialise(xendev);
  349. break;
  350. case XenbusStateConnected:
  351. /* xendev->be_state doesn't change */
  352. xen_be_try_connected(xendev);
  353. rc = -1;
  354. break;
  355. case XenbusStateClosed:
  356. rc = xen_be_try_reset(xendev);
  357. break;
  358. default:
  359. rc = -1;
  360. }
  361. if (rc != 0) {
  362. break;
  363. }
  364. }
  365. }
  366. /* ------------------------------------------------------------- */
  367. static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops)
  368. {
  369. struct XenDevice *xendev;
  370. char path[XEN_BUFSIZE], token[XEN_BUFSIZE];
  371. char **dev = NULL;
  372. unsigned int cdev, j;
  373. /* setup watch */
  374. snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops);
  375. snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
  376. if (!xs_watch(xenstore, path, token)) {
  377. xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n",
  378. path);
  379. return -1;
  380. }
  381. /* look for backends */
  382. dev = xs_directory(xenstore, 0, path, &cdev);
  383. if (!dev) {
  384. return 0;
  385. }
  386. for (j = 0; j < cdev; j++) {
  387. xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops);
  388. if (xendev == NULL) {
  389. continue;
  390. }
  391. xen_be_check_state(xendev);
  392. }
  393. free(dev);
  394. return 0;
  395. }
  396. void xenstore_update_be(char *watch, char *type, int dom,
  397. struct XenDevOps *ops)
  398. {
  399. struct XenDevice *xendev;
  400. char path[XEN_BUFSIZE], *bepath;
  401. unsigned int len, dev;
  402. len = snprintf(path, sizeof(path), "backend/%s/%d", type, dom);
  403. if (strncmp(path, watch, len) != 0) {
  404. return;
  405. }
  406. if (sscanf(watch+len, "/%u/%255s", &dev, path) != 2) {
  407. strcpy(path, "");
  408. if (sscanf(watch+len, "/%u", &dev) != 1) {
  409. dev = -1;
  410. }
  411. }
  412. if (dev == -1) {
  413. return;
  414. }
  415. xendev = xen_be_get_xendev(type, dom, dev, ops);
  416. if (xendev != NULL) {
  417. bepath = xs_read(xenstore, 0, xendev->be, &len);
  418. if (bepath == NULL) {
  419. xen_be_del_xendev(xendev);
  420. } else {
  421. free(bepath);
  422. xen_be_backend_changed(xendev, path);
  423. xen_be_check_state(xendev);
  424. }
  425. }
  426. }
  427. void xenstore_update_fe(char *watch, struct XenDevice *xendev)
  428. {
  429. char *node;
  430. unsigned int len;
  431. len = strlen(xendev->fe);
  432. if (strncmp(xendev->fe, watch, len) != 0) {
  433. return;
  434. }
  435. if (watch[len] != '/') {
  436. return;
  437. }
  438. node = watch + len + 1;
  439. xen_be_frontend_changed(xendev, node);
  440. xen_be_check_state(xendev);
  441. }
  442. /* -------------------------------------------------------------------- */
  443. int xen_be_init(void)
  444. {
  445. xenstore = xs_daemon_open();
  446. if (!xenstore) {
  447. xen_pv_printf(NULL, 0, "can't connect to xenstored\n");
  448. return -1;
  449. }
  450. qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL);
  451. if (xen_xc == NULL || xen_fmem == NULL) {
  452. /* Check if xen_init() have been called */
  453. goto err;
  454. }
  455. xen_sysdev = qdev_create(NULL, TYPE_XENSYSDEV);
  456. qdev_init_nofail(xen_sysdev);
  457. return 0;
  458. err:
  459. qemu_set_fd_handler(xs_fileno(xenstore), NULL, NULL, NULL);
  460. xs_daemon_close(xenstore);
  461. xenstore = NULL;
  462. return -1;
  463. }
  464. int xen_be_register(const char *type, struct XenDevOps *ops)
  465. {
  466. char path[50];
  467. int rc;
  468. if (ops->backend_register) {
  469. rc = ops->backend_register();
  470. if (rc) {
  471. return rc;
  472. }
  473. }
  474. snprintf(path, sizeof(path), "device-model/%u/backends/%s", xen_domid,
  475. type);
  476. xenstore_mkdir(path, XS_PERM_NONE);
  477. return xenstore_scan(type, xen_domid, ops);
  478. }
  479. void xen_be_register_common(void)
  480. {
  481. xen_be_register("console", &xen_console_ops);
  482. xen_be_register("vkbd", &xen_kbdmouse_ops);
  483. xen_be_register("qdisk", &xen_blkdev_ops);
  484. #ifdef CONFIG_USB_LIBUSB
  485. xen_be_register("qusb", &xen_usb_ops);
  486. #endif
  487. }
  488. int xen_be_bind_evtchn(struct XenDevice *xendev)
  489. {
  490. if (xendev->local_port != -1) {
  491. return 0;
  492. }
  493. xendev->local_port = xenevtchn_bind_interdomain
  494. (xendev->evtchndev, xendev->dom, xendev->remote_port);
  495. if (xendev->local_port == -1) {
  496. xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n");
  497. return -1;
  498. }
  499. xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port);
  500. qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev),
  501. xen_be_evtchn_event, NULL, xendev);
  502. return 0;
  503. }
  504. static int xen_sysdev_init(SysBusDevice *dev)
  505. {
  506. return 0;
  507. }
  508. static Property xen_sysdev_properties[] = {
  509. {/* end of property list */},
  510. };
  511. static void xen_sysdev_class_init(ObjectClass *klass, void *data)
  512. {
  513. DeviceClass *dc = DEVICE_CLASS(klass);
  514. SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
  515. k->init = xen_sysdev_init;
  516. dc->props = xen_sysdev_properties;
  517. }
  518. static const TypeInfo xensysdev_info = {
  519. .name = TYPE_XENSYSDEV,
  520. .parent = TYPE_SYS_BUS_DEVICE,
  521. .instance_size = sizeof(SysBusDevice),
  522. .class_init = xen_sysdev_class_init,
  523. };
  524. static void xenbe_register_types(void)
  525. {
  526. type_register_static(&xensysdev_info);
  527. }
  528. type_init(xenbe_register_types);