2 * Persistent reservation manager that talks to qemu-pr-helper
4 * Copyright (c) 2017 Red Hat, Inc.
6 * Author: Paolo Bonzini <pbonzini@redhat.com>
8 * This code is licensed under the LGPL v2.1 or later.
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"
24 #include "qom/object.h"
26 #define PR_MAX_RECONNECT_ATTEMPTS 5
28 #define TYPE_PR_MANAGER_HELPER "pr-manager-helper"
30 typedef struct PRManagerHelper PRManagerHelper
;
31 #define PR_MANAGER_HELPER(obj) \
32 OBJECT_CHECK(PRManagerHelper, (obj), \
33 TYPE_PR_MANAGER_HELPER)
35 struct PRManagerHelper
{
45 static void pr_manager_send_status_changed_event(PRManagerHelper
*pr_mgr
)
47 const char *id
= object_get_canonical_path_component(OBJECT(pr_mgr
));
50 qapi_event_send_pr_manager_status_changed(id
, !!pr_mgr
->ioc
);
54 /* Called with lock held. */
55 static int pr_manager_helper_read(PRManagerHelper
*pr_mgr
,
56 void *buf
, int sz
, Error
**errp
)
58 ssize_t r
= qio_channel_read_all(pr_mgr
->ioc
, buf
, sz
, errp
);
61 object_unref(OBJECT(pr_mgr
->ioc
));
63 pr_manager_send_status_changed_event(pr_mgr
);
70 /* Called with lock held. */
71 static int pr_manager_helper_write(PRManagerHelper
*pr_mgr
,
73 const void *buf
, int sz
, Error
**errp
)
75 size_t nfds
= (fd
!= -1);
80 iov
.iov_base
= (void *)buf
;
82 n_written
= qio_channel_writev_full(QIO_CHANNEL(pr_mgr
->ioc
), &iov
, 1,
83 nfds
? &fd
: NULL
, nfds
, errp
);
86 assert(n_written
!= QIO_CHANNEL_ERR_BLOCK
);
87 object_unref(OBJECT(pr_mgr
->ioc
));
89 pr_manager_send_status_changed_event(pr_mgr
);
90 return n_written
< 0 ? -EINVAL
: 0;
101 /* Called with lock held. */
102 static int pr_manager_helper_initialize(PRManagerHelper
*pr_mgr
,
105 char *path
= g_strdup(pr_mgr
->path
);
106 SocketAddress saddr
= {
107 .type
= SOCKET_ADDRESS_TYPE_UNIX
,
108 .u
.q_unix
.path
= path
110 QIOChannelSocket
*sioc
= qio_channel_socket_new();
111 Error
*local_err
= NULL
;
116 assert(!pr_mgr
->ioc
);
117 qio_channel_set_name(QIO_CHANNEL(sioc
), "pr-manager-helper");
118 qio_channel_socket_connect_sync(sioc
,
123 object_unref(OBJECT(sioc
));
124 error_propagate(errp
, local_err
);
128 qio_channel_set_delay(QIO_CHANNEL(sioc
), false);
129 pr_mgr
->ioc
= QIO_CHANNEL(sioc
);
131 /* A simple feature negotation protocol, even though there is
132 * no optional feature right now.
134 r
= pr_manager_helper_read(pr_mgr
, &flags
, sizeof(flags
), errp
);
140 r
= pr_manager_helper_write(pr_mgr
, -1, &flags
, sizeof(flags
), errp
);
145 pr_manager_send_status_changed_event(pr_mgr
);
149 object_unref(OBJECT(pr_mgr
->ioc
));
154 static int pr_manager_helper_run(PRManager
*p
,
155 int fd
, struct sg_io_hdr
*io_hdr
)
157 PRManagerHelper
*pr_mgr
= PR_MANAGER_HELPER(p
);
160 PRHelperResponse resp
;
164 uint8_t cdb
[PR_HELPER_CDB_SIZE
] = { 0 };
166 if (!io_hdr
->cmd_len
|| io_hdr
->cmd_len
> PR_HELPER_CDB_SIZE
) {
170 memcpy(cdb
, io_hdr
->cmdp
, io_hdr
->cmd_len
);
171 assert(cdb
[0] == PERSISTENT_RESERVE_OUT
|| cdb
[0] == PERSISTENT_RESERVE_IN
);
173 (cdb
[0] == PERSISTENT_RESERVE_OUT
? SG_DXFER_TO_DEV
: SG_DXFER_FROM_DEV
);
174 if (io_hdr
->dxfer_direction
!= expected_dir
) {
178 len
= scsi_cdb_xfer(cdb
);
179 if (io_hdr
->dxfer_len
< len
|| len
> PR_HELPER_DATA_SIZE
) {
183 qemu_mutex_lock(&pr_mgr
->lock
);
185 /* Try to reconnect while sending the CDB. */
186 for (attempts
= 0; attempts
< PR_MAX_RECONNECT_ATTEMPTS
; attempts
++) {
188 ret
= pr_manager_helper_initialize(pr_mgr
, NULL
);
190 qemu_mutex_unlock(&pr_mgr
->lock
);
191 g_usleep(G_USEC_PER_SEC
);
192 qemu_mutex_lock(&pr_mgr
->lock
);
197 ret
= pr_manager_helper_write(pr_mgr
, fd
, cdb
, ARRAY_SIZE(cdb
), NULL
);
206 /* After sending the CDB, any communications failure causes the
207 * command to fail. The failure is transient, retrying the command
208 * will invoke pr_manager_helper_initialize again.
210 if (expected_dir
== SG_DXFER_TO_DEV
) {
211 io_hdr
->resid
= io_hdr
->dxfer_len
- len
;
212 ret
= pr_manager_helper_write(pr_mgr
, -1, io_hdr
->dxferp
, len
, NULL
);
217 ret
= pr_manager_helper_read(pr_mgr
, &resp
, sizeof(resp
), NULL
);
222 resp
.result
= be32_to_cpu(resp
.result
);
223 resp
.sz
= be32_to_cpu(resp
.sz
);
224 if (io_hdr
->dxfer_direction
== SG_DXFER_FROM_DEV
) {
225 assert(resp
.sz
<= io_hdr
->dxfer_len
);
226 ret
= pr_manager_helper_read(pr_mgr
, io_hdr
->dxferp
, resp
.sz
, NULL
);
230 io_hdr
->resid
= io_hdr
->dxfer_len
- resp
.sz
;
232 assert(resp
.sz
== 0);
235 io_hdr
->status
= resp
.result
;
236 if (resp
.result
== CHECK_CONDITION
) {
237 io_hdr
->driver_status
= SG_ERR_DRIVER_SENSE
;
238 io_hdr
->sb_len_wr
= MIN(io_hdr
->mx_sb_len
, PR_HELPER_SENSE_SIZE
);
239 memcpy(io_hdr
->sbp
, resp
.sense
, io_hdr
->sb_len_wr
);
244 int sense_len
= scsi_build_sense(io_hdr
->sbp
,
245 SENSE_CODE(LUN_COMM_FAILURE
));
246 io_hdr
->driver_status
= SG_ERR_DRIVER_SENSE
;
247 io_hdr
->sb_len_wr
= MIN(io_hdr
->mx_sb_len
, sense_len
);
248 io_hdr
->status
= CHECK_CONDITION
;
250 qemu_mutex_unlock(&pr_mgr
->lock
);
254 static bool pr_manager_helper_is_connected(PRManager
*p
)
256 PRManagerHelper
*pr_mgr
= PR_MANAGER_HELPER(p
);
259 qemu_mutex_lock(&pr_mgr
->lock
);
260 result
= (pr_mgr
->ioc
!= NULL
);
261 qemu_mutex_unlock(&pr_mgr
->lock
);
266 static void pr_manager_helper_complete(UserCreatable
*uc
, Error
**errp
)
268 PRManagerHelper
*pr_mgr
= PR_MANAGER_HELPER(uc
);
270 qemu_mutex_lock(&pr_mgr
->lock
);
271 pr_manager_helper_initialize(pr_mgr
, errp
);
272 qemu_mutex_unlock(&pr_mgr
->lock
);
275 static char *get_path(Object
*obj
, Error
**errp
)
277 PRManagerHelper
*pr_mgr
= PR_MANAGER_HELPER(obj
);
279 return g_strdup(pr_mgr
->path
);
282 static void set_path(Object
*obj
, const char *str
, Error
**errp
)
284 PRManagerHelper
*pr_mgr
= PR_MANAGER_HELPER(obj
);
286 g_free(pr_mgr
->path
);
287 pr_mgr
->path
= g_strdup(str
);
290 static void pr_manager_helper_instance_finalize(Object
*obj
)
292 PRManagerHelper
*pr_mgr
= PR_MANAGER_HELPER(obj
);
294 object_unref(OBJECT(pr_mgr
->ioc
));
295 qemu_mutex_destroy(&pr_mgr
->lock
);
298 static void pr_manager_helper_instance_init(Object
*obj
)
300 PRManagerHelper
*pr_mgr
= PR_MANAGER_HELPER(obj
);
302 qemu_mutex_init(&pr_mgr
->lock
);
305 static void pr_manager_helper_class_init(ObjectClass
*klass
,
306 void *class_data G_GNUC_UNUSED
)
308 PRManagerClass
*prmgr_klass
= PR_MANAGER_CLASS(klass
);
309 UserCreatableClass
*uc_klass
= USER_CREATABLE_CLASS(klass
);
311 object_class_property_add_str(klass
, "path", get_path
, set_path
);
312 uc_klass
->complete
= pr_manager_helper_complete
;
313 prmgr_klass
->run
= pr_manager_helper_run
;
314 prmgr_klass
->is_connected
= pr_manager_helper_is_connected
;
317 static const TypeInfo pr_manager_helper_info
= {
318 .parent
= TYPE_PR_MANAGER
,
319 .name
= TYPE_PR_MANAGER_HELPER
,
320 .instance_size
= sizeof(PRManagerHelper
),
321 .instance_init
= pr_manager_helper_instance_init
,
322 .instance_finalize
= pr_manager_helper_instance_finalize
,
323 .class_init
= pr_manager_helper_class_init
,
326 static void pr_manager_helper_register_types(void)
328 type_register_static(&pr_manager_helper_info
);
331 type_init(pr_manager_helper_register_types
);