Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Serving QEMU block devices via NBD |
| 3 | * |
| 4 | * Copyright (c) 2012 Red Hat, Inc. |
| 5 | * |
| 6 | * Author: Paolo Bonzini <pbonzini@redhat.com> |
| 7 | * |
| 8 | * This work is licensed under the terms of the GNU GPL, version 2 or |
| 9 | * later. See the COPYING file in the top-level directory. |
| 10 | */ |
| 11 | |
Peter Maydell | d38ea87 | 2016-01-29 17:50:05 +0000 | [diff] [blame] | 12 | #include "qemu/osdep.h" |
Paolo Bonzini | 9c17d61 | 2012-12-17 18:20:04 +0100 | [diff] [blame] | 13 | #include "sysemu/blockdev.h" |
Max Reitz | e140177 | 2014-11-18 12:21:17 +0100 | [diff] [blame] | 14 | #include "sysemu/block-backend.h" |
Paolo Bonzini | 0d09e41 | 2013-02-05 17:06:20 +0100 | [diff] [blame] | 15 | #include "hw/block/block.h" |
Markus Armbruster | e688df6 | 2018-02-01 12:18:31 +0100 | [diff] [blame] | 16 | #include "qapi/error.h" |
Eric Blake | 8675cbd | 2020-10-27 00:05:48 -0500 | [diff] [blame] | 17 | #include "qapi/clone-visitor.h" |
| 18 | #include "qapi/qapi-visit-block-export.h" |
Kevin Wolf | 5daa6bf | 2020-09-24 17:26:48 +0200 | [diff] [blame] | 19 | #include "qapi/qapi-commands-block-export.h" |
Paolo Bonzini | 737e150 | 2012-12-17 18:19:44 +0100 | [diff] [blame] | 20 | #include "block/nbd.h" |
Daniel P. Berrange | ae39827 | 2016-02-10 18:41:03 +0000 | [diff] [blame] | 21 | #include "io/channel-socket.h" |
Daniel P. Berrange | 862172f | 2017-12-18 10:16:42 +0000 | [diff] [blame] | 22 | #include "io/net-listener.h" |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 23 | |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 24 | typedef struct NBDServerData { |
Daniel P. Berrange | 862172f | 2017-12-18 10:16:42 +0000 | [diff] [blame] | 25 | QIONetListener *listener; |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 26 | QCryptoTLSCreds *tlscreds; |
Daniel P. Berrange | 0001945 | 2019-02-27 16:20:34 +0000 | [diff] [blame] | 27 | char *tlsauthz; |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 28 | uint32_t max_connections; |
| 29 | uint32_t connections; |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 30 | } NBDServerData; |
| 31 | |
| 32 | static NBDServerData *nbd_server; |
Eric Blake | a5fced4 | 2022-05-11 19:49:23 -0500 | [diff] [blame] | 33 | static int qemu_nbd_connections = -1; /* Non-negative if this is qemu-nbd */ |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 34 | |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 35 | static void nbd_update_server_watch(NBDServerData *s); |
| 36 | |
Eric Blake | a5fced4 | 2022-05-11 19:49:23 -0500 | [diff] [blame] | 37 | void nbd_server_is_qemu_nbd(int max_connections) |
Kevin Wolf | 0091717 | 2020-09-24 17:26:57 +0200 | [diff] [blame] | 38 | { |
Eric Blake | a5fced4 | 2022-05-11 19:49:23 -0500 | [diff] [blame] | 39 | qemu_nbd_connections = max_connections; |
Kevin Wolf | 0091717 | 2020-09-24 17:26:57 +0200 | [diff] [blame] | 40 | } |
| 41 | |
Kevin Wolf | 5b1cb49 | 2020-09-24 17:27:12 +0200 | [diff] [blame] | 42 | bool nbd_server_is_running(void) |
| 43 | { |
Eric Blake | a5fced4 | 2022-05-11 19:49:23 -0500 | [diff] [blame] | 44 | return nbd_server || qemu_nbd_connections >= 0; |
Kevin Wolf | 5b1cb49 | 2020-09-24 17:27:12 +0200 | [diff] [blame] | 45 | } |
| 46 | |
Eric Blake | 58a6fdc | 2022-05-11 19:49:24 -0500 | [diff] [blame] | 47 | int nbd_server_max_connections(void) |
| 48 | { |
| 49 | return nbd_server ? nbd_server->max_connections : qemu_nbd_connections; |
| 50 | } |
| 51 | |
Eric Blake | 0c9390d | 2017-06-08 17:26:17 -0500 | [diff] [blame] | 52 | static void nbd_blockdev_client_closed(NBDClient *client, bool ignored) |
| 53 | { |
| 54 | nbd_client_put(client); |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 55 | assert(nbd_server->connections > 0); |
| 56 | nbd_server->connections--; |
| 57 | nbd_update_server_watch(nbd_server); |
Eric Blake | 0c9390d | 2017-06-08 17:26:17 -0500 | [diff] [blame] | 58 | } |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 59 | |
Daniel P. Berrange | 862172f | 2017-12-18 10:16:42 +0000 | [diff] [blame] | 60 | static void nbd_accept(QIONetListener *listener, QIOChannelSocket *cioc, |
| 61 | gpointer opaque) |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 62 | { |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 63 | nbd_server->connections++; |
| 64 | nbd_update_server_watch(nbd_server); |
| 65 | |
Daniel P. Berrange | 0d73f72 | 2016-09-30 11:57:14 +0100 | [diff] [blame] | 66 | qio_channel_set_name(QIO_CHANNEL(cioc), "nbd-server"); |
Daniel P. Berrange | 0001945 | 2019-02-27 16:20:34 +0000 | [diff] [blame] | 67 | nbd_client_new(cioc, nbd_server->tlscreds, nbd_server->tlsauthz, |
Eric Blake | 0c9390d | 2017-06-08 17:26:17 -0500 | [diff] [blame] | 68 | nbd_blockdev_client_closed); |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 69 | } |
| 70 | |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 71 | static void nbd_update_server_watch(NBDServerData *s) |
| 72 | { |
| 73 | if (!s->max_connections || s->connections < s->max_connections) { |
| 74 | qio_net_listener_set_client_func(s->listener, nbd_accept, NULL, NULL); |
| 75 | } else { |
| 76 | qio_net_listener_set_client_func(s->listener, NULL, NULL, NULL); |
| 77 | } |
| 78 | } |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 79 | |
| 80 | static void nbd_server_free(NBDServerData *server) |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 81 | { |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 82 | if (!server) { |
| 83 | return; |
| 84 | } |
| 85 | |
Daniel P. Berrange | 862172f | 2017-12-18 10:16:42 +0000 | [diff] [blame] | 86 | qio_net_listener_disconnect(server->listener); |
| 87 | object_unref(OBJECT(server->listener)); |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 88 | if (server->tlscreds) { |
| 89 | object_unref(OBJECT(server->tlscreds)); |
| 90 | } |
Daniel P. Berrange | 0001945 | 2019-02-27 16:20:34 +0000 | [diff] [blame] | 91 | g_free(server->tlsauthz); |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 92 | |
| 93 | g_free(server); |
| 94 | } |
| 95 | |
| 96 | static QCryptoTLSCreds *nbd_get_tls_creds(const char *id, Error **errp) |
| 97 | { |
| 98 | Object *obj; |
| 99 | QCryptoTLSCreds *creds; |
| 100 | |
| 101 | obj = object_resolve_path_component( |
| 102 | object_get_objects_root(), id); |
| 103 | if (!obj) { |
| 104 | error_setg(errp, "No TLS credentials with id '%s'", |
| 105 | id); |
| 106 | return NULL; |
| 107 | } |
| 108 | creds = (QCryptoTLSCreds *) |
| 109 | object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS); |
| 110 | if (!creds) { |
| 111 | error_setg(errp, "Object with id '%s' is not TLS credentials", |
| 112 | id); |
| 113 | return NULL; |
| 114 | } |
| 115 | |
Philippe Mathieu-Daudé | 7b3b616 | 2021-06-28 18:09:09 +0200 | [diff] [blame] | 116 | if (!qcrypto_tls_creds_check_endpoint(creds, |
| 117 | QCRYPTO_TLS_CREDS_ENDPOINT_SERVER, |
| 118 | errp)) { |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 119 | return NULL; |
| 120 | } |
| 121 | object_ref(obj); |
| 122 | return creds; |
| 123 | } |
| 124 | |
| 125 | |
Markus Armbruster | bd269eb | 2017-04-26 09:36:41 +0200 | [diff] [blame] | 126 | void nbd_server_start(SocketAddress *addr, const char *tls_creds, |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 127 | const char *tls_authz, uint32_t max_connections, |
| 128 | Error **errp) |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 129 | { |
| 130 | if (nbd_server) { |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 131 | error_setg(errp, "NBD server already running"); |
| 132 | return; |
| 133 | } |
| 134 | |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 135 | nbd_server = g_new0(NBDServerData, 1); |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 136 | nbd_server->max_connections = max_connections; |
Daniel P. Berrange | 862172f | 2017-12-18 10:16:42 +0000 | [diff] [blame] | 137 | nbd_server->listener = qio_net_listener_new(); |
| 138 | |
| 139 | qio_net_listener_set_name(nbd_server->listener, |
| 140 | "nbd-listener"); |
| 141 | |
Eric Blake | 582d421 | 2021-02-09 09:27:58 -0600 | [diff] [blame] | 142 | /* |
| 143 | * Because this server is persistent, a backlog of SOMAXCONN is |
| 144 | * better than trying to size it to max_connections. |
| 145 | */ |
| 146 | if (qio_net_listener_open_sync(nbd_server->listener, addr, SOMAXCONN, |
| 147 | errp) < 0) { |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 148 | goto error; |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 149 | } |
Daniel P. Berrange | ae39827 | 2016-02-10 18:41:03 +0000 | [diff] [blame] | 150 | |
Markus Armbruster | bd269eb | 2017-04-26 09:36:41 +0200 | [diff] [blame] | 151 | if (tls_creds) { |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 152 | nbd_server->tlscreds = nbd_get_tls_creds(tls_creds, errp); |
| 153 | if (!nbd_server->tlscreds) { |
| 154 | goto error; |
| 155 | } |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 156 | } |
| 157 | |
Daniel P. Berrange | 0001945 | 2019-02-27 16:20:34 +0000 | [diff] [blame] | 158 | nbd_server->tlsauthz = g_strdup(tls_authz); |
| 159 | |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 160 | nbd_update_server_watch(nbd_server); |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 161 | |
| 162 | return; |
| 163 | |
| 164 | error: |
| 165 | nbd_server_free(nbd_server); |
| 166 | nbd_server = NULL; |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 167 | } |
| 168 | |
Kevin Wolf | eed8b69 | 2020-02-24 15:29:57 +0100 | [diff] [blame] | 169 | void nbd_server_start_options(NbdServerOptions *arg, Error **errp) |
| 170 | { |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 171 | nbd_server_start(arg->addr, arg->tls_creds, arg->tls_authz, |
| 172 | arg->max_connections, errp); |
Kevin Wolf | eed8b69 | 2020-02-24 15:29:57 +0100 | [diff] [blame] | 173 | } |
| 174 | |
Markus Armbruster | bd269eb | 2017-04-26 09:36:41 +0200 | [diff] [blame] | 175 | void qmp_nbd_server_start(SocketAddressLegacy *addr, |
Markus Armbruster | 54fde4f | 2022-11-04 17:06:52 +0100 | [diff] [blame] | 176 | const char *tls_creds, |
| 177 | const char *tls_authz, |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 178 | bool has_max_connections, uint32_t max_connections, |
Markus Armbruster | bd269eb | 2017-04-26 09:36:41 +0200 | [diff] [blame] | 179 | Error **errp) |
| 180 | { |
| 181 | SocketAddress *addr_flat = socket_address_flatten(addr); |
| 182 | |
Kevin Wolf | 1c8222b | 2020-09-24 17:26:54 +0200 | [diff] [blame] | 183 | nbd_server_start(addr_flat, tls_creds, tls_authz, max_connections, errp); |
Markus Armbruster | bd269eb | 2017-04-26 09:36:41 +0200 | [diff] [blame] | 184 | qapi_free_SocketAddress(addr_flat); |
| 185 | } |
| 186 | |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 187 | void qmp_nbd_server_add(NbdServerAddOptions *arg, Error **errp) |
Kevin Wolf | 56ee862 | 2020-09-24 17:26:50 +0200 | [diff] [blame] | 188 | { |
Kevin Wolf | 9b562c6 | 2020-09-24 17:26:53 +0200 | [diff] [blame] | 189 | BlockExport *export; |
| 190 | BlockDriverState *bs; |
| 191 | BlockBackend *on_eject_blk; |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 192 | BlockExportOptions *export_opts; |
Kevin Wolf | 9b562c6 | 2020-09-24 17:26:53 +0200 | [diff] [blame] | 193 | |
| 194 | bs = bdrv_lookup_bs(arg->device, arg->device, errp); |
| 195 | if (!bs) { |
| 196 | return; |
| 197 | } |
| 198 | |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 199 | /* |
| 200 | * block-export-add would default to the node-name, but we may have to use |
| 201 | * the device name as a default here for compatibility. |
| 202 | */ |
Markus Armbruster | 54fde4f | 2022-11-04 17:06:52 +0100 | [diff] [blame] | 203 | if (!arg->name) { |
Eric Blake | 8675cbd | 2020-10-27 00:05:48 -0500 | [diff] [blame] | 204 | arg->name = g_strdup(arg->device); |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | export_opts = g_new(BlockExportOptions, 1); |
| 208 | *export_opts = (BlockExportOptions) { |
| 209 | .type = BLOCK_EXPORT_TYPE_NBD, |
Kevin Wolf | d53be9c | 2020-09-24 17:27:04 +0200 | [diff] [blame] | 210 | .id = g_strdup(arg->name), |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 211 | .node_name = g_strdup(bdrv_get_node_name(bs)), |
Kevin Wolf | 30dbc81 | 2020-09-24 17:27:11 +0200 | [diff] [blame] | 212 | .has_writable = arg->has_writable, |
| 213 | .writable = arg->writable, |
Kevin Wolf | 56ee862 | 2020-09-24 17:26:50 +0200 | [diff] [blame] | 214 | }; |
Eric Blake | cbad81c | 2020-10-27 00:05:49 -0500 | [diff] [blame] | 215 | QAPI_CLONE_MEMBERS(BlockExportOptionsNbdBase, &export_opts->u.nbd, |
Eric Blake | 8675cbd | 2020-10-27 00:05:48 -0500 | [diff] [blame] | 216 | qapi_NbdServerAddOptions_base(arg)); |
Markus Armbruster | 54fde4f | 2022-11-04 17:06:52 +0100 | [diff] [blame] | 217 | if (arg->bitmap) { |
Vladimir Sementsov-Ogievskiy | e5fb29d | 2022-03-15 00:32:25 +0300 | [diff] [blame] | 218 | BlockDirtyBitmapOrStr *el = g_new(BlockDirtyBitmapOrStr, 1); |
| 219 | |
| 220 | *el = (BlockDirtyBitmapOrStr) { |
| 221 | .type = QTYPE_QSTRING, |
| 222 | .u.local = g_strdup(arg->bitmap), |
| 223 | }; |
Eric Blake | cbad81c | 2020-10-27 00:05:49 -0500 | [diff] [blame] | 224 | export_opts->u.nbd.has_bitmaps = true; |
Vladimir Sementsov-Ogievskiy | e5fb29d | 2022-03-15 00:32:25 +0300 | [diff] [blame] | 225 | QAPI_LIST_PREPEND(export_opts->u.nbd.bitmaps, el); |
Eric Blake | cbad81c | 2020-10-27 00:05:49 -0500 | [diff] [blame] | 226 | } |
Kevin Wolf | 9b562c6 | 2020-09-24 17:26:53 +0200 | [diff] [blame] | 227 | |
| 228 | /* |
| 229 | * nbd-server-add doesn't complain when a read-only device should be |
| 230 | * exported as writable, but simply downgrades it. This is an error with |
| 231 | * block-export-add. |
| 232 | */ |
| 233 | if (bdrv_is_read_only(bs)) { |
Kevin Wolf | 30dbc81 | 2020-09-24 17:27:11 +0200 | [diff] [blame] | 234 | export_opts->has_writable = true; |
| 235 | export_opts->writable = false; |
Kevin Wolf | 9b562c6 | 2020-09-24 17:26:53 +0200 | [diff] [blame] | 236 | } |
| 237 | |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 238 | export = blk_exp_add(export_opts, errp); |
Kevin Wolf | 9b562c6 | 2020-09-24 17:26:53 +0200 | [diff] [blame] | 239 | if (!export) { |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 240 | goto fail; |
Kevin Wolf | 9b562c6 | 2020-09-24 17:26:53 +0200 | [diff] [blame] | 241 | } |
| 242 | |
| 243 | /* |
| 244 | * nbd-server-add removes the export when the named BlockBackend used for |
| 245 | * @device goes away. |
| 246 | */ |
| 247 | on_eject_blk = blk_by_name(arg->device); |
| 248 | if (on_eject_blk) { |
| 249 | nbd_export_set_on_eject_blk(export, on_eject_blk); |
| 250 | } |
Kevin Wolf | b6076af | 2020-09-24 17:27:01 +0200 | [diff] [blame] | 251 | |
| 252 | fail: |
| 253 | qapi_free_BlockExportOptions(export_opts); |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 254 | } |
| 255 | |
Vladimir Sementsov-Ogievskiy | a3b0dc7 | 2018-01-19 16:57:16 +0300 | [diff] [blame] | 256 | void qmp_nbd_server_remove(const char *name, |
Kevin Wolf | 3c3bc46 | 2020-09-24 17:27:06 +0200 | [diff] [blame] | 257 | bool has_mode, BlockExportRemoveMode mode, |
Vladimir Sementsov-Ogievskiy | a3b0dc7 | 2018-01-19 16:57:16 +0300 | [diff] [blame] | 258 | Error **errp) |
| 259 | { |
Kevin Wolf | 3c3bc46 | 2020-09-24 17:27:06 +0200 | [diff] [blame] | 260 | BlockExport *exp; |
Vladimir Sementsov-Ogievskiy | a3b0dc7 | 2018-01-19 16:57:16 +0300 | [diff] [blame] | 261 | |
Kevin Wolf | 3c3bc46 | 2020-09-24 17:27:06 +0200 | [diff] [blame] | 262 | exp = blk_exp_find(name); |
| 263 | if (exp && exp->drv->type != BLOCK_EXPORT_TYPE_NBD) { |
| 264 | error_setg(errp, "Block export '%s' is not an NBD export", name); |
Vladimir Sementsov-Ogievskiy | a3b0dc7 | 2018-01-19 16:57:16 +0300 | [diff] [blame] | 265 | return; |
| 266 | } |
| 267 | |
Kevin Wolf | 3c3bc46 | 2020-09-24 17:27:06 +0200 | [diff] [blame] | 268 | qmp_block_export_del(name, has_mode, mode, errp); |
Vladimir Sementsov-Ogievskiy | a3b0dc7 | 2018-01-19 16:57:16 +0300 | [diff] [blame] | 269 | } |
| 270 | |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 271 | void qmp_nbd_server_stop(Error **errp) |
| 272 | { |
Eric Blake | 7801c3a | 2019-01-11 13:47:14 -0600 | [diff] [blame] | 273 | if (!nbd_server) { |
| 274 | error_setg(errp, "NBD server not running"); |
| 275 | return; |
| 276 | } |
| 277 | |
Kevin Wolf | bc4ee65 | 2020-09-24 17:27:03 +0200 | [diff] [blame] | 278 | blk_exp_close_all_type(BLOCK_EXPORT_TYPE_NBD); |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 279 | |
Daniel P. Berrange | ddffee3 | 2016-02-10 18:41:14 +0000 | [diff] [blame] | 280 | nbd_server_free(nbd_server); |
| 281 | nbd_server = NULL; |
Paolo Bonzini | 6dd844d | 2012-08-22 16:43:07 +0200 | [diff] [blame] | 282 | } |