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