]>
Commit | Line | Data |
---|---|---|
9bad2a6b PB |
1 | /* |
2 | * Persistent reservation manager that talks to qemu-pr-helper | |
3 | * | |
4 | * Copyright (c) 2017 Red Hat, Inc. | |
5 | * | |
6 | * Author: Paolo Bonzini <pbonzini@redhat.com> | |
7 | * | |
8 | * This code is licensed under the LGPL v2.1 or later. | |
9 | * | |
10 | */ | |
11 | ||
12 | #include "qemu/osdep.h" | |
13 | #include "qapi/error.h" | |
14 | #include "scsi/constants.h" | |
15 | #include "scsi/pr-manager.h" | |
16 | #include "scsi/utils.h" | |
17 | #include "io/channel.h" | |
18 | #include "io/channel-socket.h" | |
19 | #include "pr-helper.h" | |
e2c81a45 | 20 | #include "qapi/qapi-events-block.h" |
0b8fa32f | 21 | #include "qemu/module.h" |
9bad2a6b PB |
22 | |
23 | #include <scsi/sg.h> | |
db1015e9 | 24 | #include "qom/object.h" |
9bad2a6b PB |
25 | |
26 | #define PR_MAX_RECONNECT_ATTEMPTS 5 | |
27 | ||
28 | #define TYPE_PR_MANAGER_HELPER "pr-manager-helper" | |
29 | ||
8063396b | 30 | OBJECT_DECLARE_SIMPLE_TYPE(PRManagerHelper, PR_MANAGER_HELPER) |
9bad2a6b | 31 | |
db1015e9 | 32 | struct PRManagerHelper { |
9bad2a6b PB |
33 | /* <private> */ |
34 | PRManager parent; | |
35 | ||
36 | char *path; | |
37 | ||
38 | QemuMutex lock; | |
39 | QIOChannel *ioc; | |
db1015e9 | 40 | }; |
9bad2a6b | 41 | |
e2c81a45 PB |
42 | static void pr_manager_send_status_changed_event(PRManagerHelper *pr_mgr) |
43 | { | |
7a309cc9 | 44 | const char *id = object_get_canonical_path_component(OBJECT(pr_mgr)); |
e2c81a45 PB |
45 | |
46 | if (id) { | |
3ab72385 | 47 | qapi_event_send_pr_manager_status_changed(id, !!pr_mgr->ioc); |
e2c81a45 PB |
48 | } |
49 | } | |
50 | ||
9bad2a6b PB |
51 | /* Called with lock held. */ |
52 | static int pr_manager_helper_read(PRManagerHelper *pr_mgr, | |
53 | void *buf, int sz, Error **errp) | |
54 | { | |
55 | ssize_t r = qio_channel_read_all(pr_mgr->ioc, buf, sz, errp); | |
56 | ||
57 | if (r < 0) { | |
58 | object_unref(OBJECT(pr_mgr->ioc)); | |
59 | pr_mgr->ioc = NULL; | |
e2c81a45 | 60 | pr_manager_send_status_changed_event(pr_mgr); |
9bad2a6b PB |
61 | return -EINVAL; |
62 | } | |
63 | ||
64 | return 0; | |
65 | } | |
66 | ||
67 | /* Called with lock held. */ | |
68 | static int pr_manager_helper_write(PRManagerHelper *pr_mgr, | |
69 | int fd, | |
70 | const void *buf, int sz, Error **errp) | |
71 | { | |
72 | size_t nfds = (fd != -1); | |
73 | while (sz > 0) { | |
74 | struct iovec iov; | |
75 | ssize_t n_written; | |
76 | ||
77 | iov.iov_base = (void *)buf; | |
78 | iov.iov_len = sz; | |
79 | n_written = qio_channel_writev_full(QIO_CHANNEL(pr_mgr->ioc), &iov, 1, | |
80 | nfds ? &fd : NULL, nfds, errp); | |
81 | ||
82 | if (n_written <= 0) { | |
83 | assert(n_written != QIO_CHANNEL_ERR_BLOCK); | |
84 | object_unref(OBJECT(pr_mgr->ioc)); | |
aad10040 | 85 | pr_mgr->ioc = NULL; |
e2c81a45 | 86 | pr_manager_send_status_changed_event(pr_mgr); |
9bad2a6b PB |
87 | return n_written < 0 ? -EINVAL : 0; |
88 | } | |
89 | ||
90 | nfds = 0; | |
91 | buf += n_written; | |
92 | sz -= n_written; | |
93 | } | |
94 | ||
95 | return 0; | |
96 | } | |
97 | ||
98 | /* Called with lock held. */ | |
99 | static int pr_manager_helper_initialize(PRManagerHelper *pr_mgr, | |
100 | Error **errp) | |
101 | { | |
102 | char *path = g_strdup(pr_mgr->path); | |
103 | SocketAddress saddr = { | |
104 | .type = SOCKET_ADDRESS_TYPE_UNIX, | |
105 | .u.q_unix.path = path | |
106 | }; | |
107 | QIOChannelSocket *sioc = qio_channel_socket_new(); | |
108 | Error *local_err = NULL; | |
109 | ||
110 | uint32_t flags; | |
111 | int r; | |
112 | ||
113 | assert(!pr_mgr->ioc); | |
114 | qio_channel_set_name(QIO_CHANNEL(sioc), "pr-manager-helper"); | |
115 | qio_channel_socket_connect_sync(sioc, | |
116 | &saddr, | |
117 | &local_err); | |
118 | g_free(path); | |
119 | if (local_err) { | |
120 | object_unref(OBJECT(sioc)); | |
121 | error_propagate(errp, local_err); | |
122 | return -ENOTCONN; | |
123 | } | |
124 | ||
125 | qio_channel_set_delay(QIO_CHANNEL(sioc), false); | |
126 | pr_mgr->ioc = QIO_CHANNEL(sioc); | |
127 | ||
e3a6e0da | 128 | /* A simple feature negotiation protocol, even though there is |
9bad2a6b PB |
129 | * no optional feature right now. |
130 | */ | |
131 | r = pr_manager_helper_read(pr_mgr, &flags, sizeof(flags), errp); | |
132 | if (r < 0) { | |
133 | goto out_close; | |
134 | } | |
135 | ||
136 | flags = 0; | |
137 | r = pr_manager_helper_write(pr_mgr, -1, &flags, sizeof(flags), errp); | |
138 | if (r < 0) { | |
139 | goto out_close; | |
140 | } | |
141 | ||
e2c81a45 | 142 | pr_manager_send_status_changed_event(pr_mgr); |
9bad2a6b PB |
143 | return 0; |
144 | ||
145 | out_close: | |
146 | object_unref(OBJECT(pr_mgr->ioc)); | |
147 | pr_mgr->ioc = NULL; | |
148 | return r; | |
149 | } | |
150 | ||
151 | static int pr_manager_helper_run(PRManager *p, | |
152 | int fd, struct sg_io_hdr *io_hdr) | |
153 | { | |
154 | PRManagerHelper *pr_mgr = PR_MANAGER_HELPER(p); | |
155 | ||
156 | uint32_t len; | |
157 | PRHelperResponse resp; | |
158 | int ret; | |
159 | int expected_dir; | |
160 | int attempts; | |
161 | uint8_t cdb[PR_HELPER_CDB_SIZE] = { 0 }; | |
162 | ||
163 | if (!io_hdr->cmd_len || io_hdr->cmd_len > PR_HELPER_CDB_SIZE) { | |
164 | return -EINVAL; | |
165 | } | |
166 | ||
167 | memcpy(cdb, io_hdr->cmdp, io_hdr->cmd_len); | |
168 | assert(cdb[0] == PERSISTENT_RESERVE_OUT || cdb[0] == PERSISTENT_RESERVE_IN); | |
169 | expected_dir = | |
170 | (cdb[0] == PERSISTENT_RESERVE_OUT ? SG_DXFER_TO_DEV : SG_DXFER_FROM_DEV); | |
171 | if (io_hdr->dxfer_direction != expected_dir) { | |
172 | return -EINVAL; | |
173 | } | |
174 | ||
175 | len = scsi_cdb_xfer(cdb); | |
176 | if (io_hdr->dxfer_len < len || len > PR_HELPER_DATA_SIZE) { | |
177 | return -EINVAL; | |
178 | } | |
179 | ||
180 | qemu_mutex_lock(&pr_mgr->lock); | |
181 | ||
182 | /* Try to reconnect while sending the CDB. */ | |
183 | for (attempts = 0; attempts < PR_MAX_RECONNECT_ATTEMPTS; attempts++) { | |
184 | if (!pr_mgr->ioc) { | |
185 | ret = pr_manager_helper_initialize(pr_mgr, NULL); | |
186 | if (ret < 0) { | |
187 | qemu_mutex_unlock(&pr_mgr->lock); | |
188 | g_usleep(G_USEC_PER_SEC); | |
189 | qemu_mutex_lock(&pr_mgr->lock); | |
190 | continue; | |
191 | } | |
192 | } | |
193 | ||
194 | ret = pr_manager_helper_write(pr_mgr, fd, cdb, ARRAY_SIZE(cdb), NULL); | |
195 | if (ret >= 0) { | |
196 | break; | |
197 | } | |
198 | } | |
199 | if (ret < 0) { | |
200 | goto out; | |
201 | } | |
202 | ||
203 | /* After sending the CDB, any communications failure causes the | |
204 | * command to fail. The failure is transient, retrying the command | |
205 | * will invoke pr_manager_helper_initialize again. | |
206 | */ | |
207 | if (expected_dir == SG_DXFER_TO_DEV) { | |
208 | io_hdr->resid = io_hdr->dxfer_len - len; | |
209 | ret = pr_manager_helper_write(pr_mgr, -1, io_hdr->dxferp, len, NULL); | |
210 | if (ret < 0) { | |
211 | goto out; | |
212 | } | |
213 | } | |
214 | ret = pr_manager_helper_read(pr_mgr, &resp, sizeof(resp), NULL); | |
215 | if (ret < 0) { | |
216 | goto out; | |
217 | } | |
218 | ||
219 | resp.result = be32_to_cpu(resp.result); | |
220 | resp.sz = be32_to_cpu(resp.sz); | |
221 | if (io_hdr->dxfer_direction == SG_DXFER_FROM_DEV) { | |
222 | assert(resp.sz <= io_hdr->dxfer_len); | |
223 | ret = pr_manager_helper_read(pr_mgr, io_hdr->dxferp, resp.sz, NULL); | |
224 | if (ret < 0) { | |
225 | goto out; | |
226 | } | |
227 | io_hdr->resid = io_hdr->dxfer_len - resp.sz; | |
228 | } else { | |
229 | assert(resp.sz == 0); | |
230 | } | |
231 | ||
232 | io_hdr->status = resp.result; | |
233 | if (resp.result == CHECK_CONDITION) { | |
234 | io_hdr->driver_status = SG_ERR_DRIVER_SENSE; | |
235 | io_hdr->sb_len_wr = MIN(io_hdr->mx_sb_len, PR_HELPER_SENSE_SIZE); | |
236 | memcpy(io_hdr->sbp, resp.sense, io_hdr->sb_len_wr); | |
237 | } | |
238 | ||
239 | out: | |
240 | if (ret < 0) { | |
241 | int sense_len = scsi_build_sense(io_hdr->sbp, | |
242 | SENSE_CODE(LUN_COMM_FAILURE)); | |
243 | io_hdr->driver_status = SG_ERR_DRIVER_SENSE; | |
244 | io_hdr->sb_len_wr = MIN(io_hdr->mx_sb_len, sense_len); | |
245 | io_hdr->status = CHECK_CONDITION; | |
246 | } | |
247 | qemu_mutex_unlock(&pr_mgr->lock); | |
248 | return ret; | |
249 | } | |
250 | ||
5f640894 PB |
251 | static bool pr_manager_helper_is_connected(PRManager *p) |
252 | { | |
253 | PRManagerHelper *pr_mgr = PR_MANAGER_HELPER(p); | |
254 | bool result; | |
255 | ||
256 | qemu_mutex_lock(&pr_mgr->lock); | |
257 | result = (pr_mgr->ioc != NULL); | |
258 | qemu_mutex_unlock(&pr_mgr->lock); | |
259 | ||
260 | return result; | |
261 | } | |
262 | ||
9bad2a6b PB |
263 | static void pr_manager_helper_complete(UserCreatable *uc, Error **errp) |
264 | { | |
265 | PRManagerHelper *pr_mgr = PR_MANAGER_HELPER(uc); | |
266 | ||
267 | qemu_mutex_lock(&pr_mgr->lock); | |
268 | pr_manager_helper_initialize(pr_mgr, errp); | |
269 | qemu_mutex_unlock(&pr_mgr->lock); | |
270 | } | |
271 | ||
272 | static char *get_path(Object *obj, Error **errp) | |
273 | { | |
274 | PRManagerHelper *pr_mgr = PR_MANAGER_HELPER(obj); | |
275 | ||
276 | return g_strdup(pr_mgr->path); | |
277 | } | |
278 | ||
279 | static void set_path(Object *obj, const char *str, Error **errp) | |
280 | { | |
281 | PRManagerHelper *pr_mgr = PR_MANAGER_HELPER(obj); | |
282 | ||
283 | g_free(pr_mgr->path); | |
284 | pr_mgr->path = g_strdup(str); | |
285 | } | |
286 | ||
287 | static void pr_manager_helper_instance_finalize(Object *obj) | |
288 | { | |
289 | PRManagerHelper *pr_mgr = PR_MANAGER_HELPER(obj); | |
290 | ||
291 | object_unref(OBJECT(pr_mgr->ioc)); | |
292 | qemu_mutex_destroy(&pr_mgr->lock); | |
293 | } | |
294 | ||
295 | static void pr_manager_helper_instance_init(Object *obj) | |
296 | { | |
297 | PRManagerHelper *pr_mgr = PR_MANAGER_HELPER(obj); | |
298 | ||
299 | qemu_mutex_init(&pr_mgr->lock); | |
300 | } | |
301 | ||
302 | static void pr_manager_helper_class_init(ObjectClass *klass, | |
303 | void *class_data G_GNUC_UNUSED) | |
304 | { | |
305 | PRManagerClass *prmgr_klass = PR_MANAGER_CLASS(klass); | |
306 | UserCreatableClass *uc_klass = USER_CREATABLE_CLASS(klass); | |
307 | ||
d2623129 | 308 | object_class_property_add_str(klass, "path", get_path, set_path); |
9bad2a6b PB |
309 | uc_klass->complete = pr_manager_helper_complete; |
310 | prmgr_klass->run = pr_manager_helper_run; | |
5f640894 | 311 | prmgr_klass->is_connected = pr_manager_helper_is_connected; |
9bad2a6b PB |
312 | } |
313 | ||
314 | static const TypeInfo pr_manager_helper_info = { | |
315 | .parent = TYPE_PR_MANAGER, | |
316 | .name = TYPE_PR_MANAGER_HELPER, | |
317 | .instance_size = sizeof(PRManagerHelper), | |
318 | .instance_init = pr_manager_helper_instance_init, | |
319 | .instance_finalize = pr_manager_helper_instance_finalize, | |
320 | .class_init = pr_manager_helper_class_init, | |
321 | }; | |
322 | ||
323 | static void pr_manager_helper_register_types(void) | |
324 | { | |
325 | type_register_static(&pr_manager_helper_info); | |
326 | } | |
327 | ||
328 | type_init(pr_manager_helper_register_types); |