1 /*
2  * qemu_block.h: helper functions for QEMU block subsystem
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library 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 GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library.  If not, see
16  * <http://www.gnu.org/licenses/>.
17  */
18 
19 #pragma once
20 
21 #include "internal.h"
22 
23 #include "qemu_conf.h"
24 #include "qemu_domain.h"
25 
26 #include "virhash.h"
27 #include "virjson.h"
28 #include "viruri.h"
29 
30 typedef struct qemuBlockNodeNameBackingChainData qemuBlockNodeNameBackingChainData;
31 struct qemuBlockNodeNameBackingChainData {
32     char *qemufilename; /* name of the image from qemu */
33     char *nodeformat;   /* node name of the format layer */
34     char *nodestorage;  /* node name of the storage backing the format node */
35 
36     qemuBlockNodeNameBackingChainData *backing;
37 
38     /* for testing purposes */
39     char *drvformat;
40     char *drvstorage;
41 };
42 
43 GHashTable *
44 qemuBlockNodeNameGetBackingChain(virJSONValue *namednodesdata,
45                                  virJSONValue *blockstats);
46 
47 int
48 qemuBlockNodeNamesDetect(virQEMUDriver *driver,
49                          virDomainObj *vm,
50                          qemuDomainAsyncJob asyncJob);
51 
52 GHashTable *
53 qemuBlockGetNodeData(virJSONValue *data);
54 
55 bool
56 qemuBlockStorageSourceSupportsConcurrentAccess(virStorageSource *src);
57 
58 typedef enum {
59     QEMU_BLOCK_STORAGE_SOURCE_BACKEND_PROPS_LEGACY = 1 << 0,
60     QEMU_BLOCK_STORAGE_SOURCE_BACKEND_PROPS_TARGET_ONLY = 1 << 1,
61     QEMU_BLOCK_STORAGE_SOURCE_BACKEND_PROPS_AUTO_READONLY = 1 << 2,
62     QEMU_BLOCK_STORAGE_SOURCE_BACKEND_PROPS_SKIP_UNMAP = 1 << 3,
63 } qemuBlockStorageSourceBackendPropsFlags;
64 
65 virJSONValue *
66 qemuBlockStorageSourceGetBackendProps(virStorageSource *src,
67                                       unsigned int flags);
68 
69 virURI *
70 qemuBlockStorageSourceGetURI(virStorageSource *src);
71 
72 virJSONValue *
73 qemuBlockStorageSourceGetBlockdevProps(virStorageSource *src,
74                                        virStorageSource *backingStore);
75 
76 virJSONValue *
77 qemuBlockStorageGetCopyOnReadProps(virDomainDiskDef *disk);
78 
79 typedef struct qemuBlockStorageSourceAttachData qemuBlockStorageSourceAttachData;
80 struct qemuBlockStorageSourceAttachData {
81     virJSONValue *prmgrProps;
82     char *prmgrAlias;
83 
84     virJSONValue *storageProps;
85     const char *storageNodeName;
86     bool storageAttached;
87 
88     virJSONValue *storageSliceProps;
89     const char *storageSliceNodeName;
90     bool storageSliceAttached;
91 
92     virJSONValue *formatProps;
93     const char *formatNodeName;
94     bool formatAttached;
95 
96     char *driveCmd;
97     char *driveAlias;
98     bool driveAdded;
99 
100     virDomainChrSourceDef *chardevDef;
101     char *chardevAlias;
102     char *chardevCmd;
103     bool chardevAdded;
104 
105     virJSONValue *authsecretProps;
106     char *authsecretAlias;
107 
108     virJSONValue *encryptsecretProps;
109     char *encryptsecretAlias;
110 
111     virJSONValue *httpcookiesecretProps;
112     char *httpcookiesecretAlias;
113 
114     virJSONValue *tlsProps;
115     char *tlsAlias;
116     virJSONValue *tlsKeySecretProps;
117     char *tlsKeySecretAlias;
118 };
119 
120 
121 void
122 qemuBlockStorageSourceAttachDataFree(qemuBlockStorageSourceAttachData *data);
123 
124 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuBlockStorageSourceAttachData,
125                         qemuBlockStorageSourceAttachDataFree);
126 
127 qemuBlockStorageSourceAttachData *
128 qemuBlockStorageSourceAttachPrepareBlockdev(virStorageSource *src,
129                                             virStorageSource *backingStore,
130                                             bool autoreadonly);
131 
132 qemuBlockStorageSourceAttachData *
133 qemuBlockStorageSourceDetachPrepare(virStorageSource *src,
134                                     char *driveAlias);
135 
136 int
137 qemuBlockStorageSourceAttachApply(qemuMonitor *mon,
138                                   qemuBlockStorageSourceAttachData *data);
139 
140 void
141 qemuBlockStorageSourceAttachRollback(qemuMonitor *mon,
142                                      qemuBlockStorageSourceAttachData *data);
143 
144 int
145 qemuBlockStorageSourceDetachOneBlockdev(virQEMUDriver *driver,
146                                         virDomainObj *vm,
147                                         qemuDomainAsyncJob asyncJob,
148                                         virStorageSource *src);
149 
150 struct _qemuBlockStorageSourceChainData {
151     qemuBlockStorageSourceAttachData **srcdata;
152     size_t nsrcdata;
153 
154     virJSONValue *copyOnReadProps;
155     char *copyOnReadNodename;
156     bool copyOnReadAttached;
157 };
158 
159 typedef struct _qemuBlockStorageSourceChainData qemuBlockStorageSourceChainData;
160 
161 void
162 qemuBlockStorageSourceChainDataFree(qemuBlockStorageSourceChainData *data);
163 
164 qemuBlockStorageSourceChainData *
165 qemuBlockStorageSourceChainDetachPrepareBlockdev(virStorageSource *src);
166 qemuBlockStorageSourceChainData *
167 qemuBlockStorageSourceChainDetachPrepareDrive(virStorageSource *src,
168                                               char *driveAlias);
169 qemuBlockStorageSourceChainData *
170 qemuBlockStorageSourceChainDetachPrepareChardev(char *chardevAlias);
171 
172 int
173 qemuBlockStorageSourceChainAttach(qemuMonitor *mon,
174                                   qemuBlockStorageSourceChainData *data);
175 
176 void
177 qemuBlockStorageSourceChainDetach(qemuMonitor *mon,
178                                   qemuBlockStorageSourceChainData *data);
179 
180 
181 G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuBlockStorageSourceChainData,
182                         qemuBlockStorageSourceChainDataFree);
183 
184 int
185 qemuBlockSnapshotAddLegacy(virJSONValue *actions,
186                            virDomainDiskDef *disk,
187                            virStorageSource *newsrc,
188                            bool reuse);
189 
190 int
191 qemuBlockSnapshotAddBlockdev(virJSONValue *actions,
192                              virDomainDiskDef *disk,
193                              virStorageSource *newsrc);
194 
195 char *
196 qemuBlockGetBackingStoreString(virStorageSource *src,
197                                bool pretty)
198     ATTRIBUTE_NONNULL(1);
199 
200 int
201 qemuBlockStorageSourceCreateGetFormatProps(virStorageSource *src,
202                                            virStorageSource *backing,
203                                            virJSONValue **props)
204     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) G_GNUC_WARN_UNUSED_RESULT;
205 
206 int
207 qemuBlockStorageSourceCreateGetStorageProps(virStorageSource *src,
208                                             virJSONValue **props)
209     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
210 
211 int
212 qemuBlockStorageSourceCreate(virDomainObj *vm,
213                              virStorageSource *src,
214                              virStorageSource *backingStore,
215                              virStorageSource *chain,
216                              qemuBlockStorageSourceAttachData *data,
217                              qemuDomainAsyncJob asyncJob);
218 
219 int
220 qemuBlockStorageSourceCreateDetectSize(GHashTable *blockNamedNodeData,
221                                        virStorageSource *src,
222                                        virStorageSource *templ);
223 
224 int
225 qemuBlockRemoveImageMetadata(virQEMUDriver *driver,
226                              virDomainObj *vm,
227                              const char *diskTarget,
228                              virStorageSource *src);
229 
230 qemuBlockNamedNodeDataBitmap *
231 qemuBlockNamedNodeDataGetBitmapByName(GHashTable *blockNamedNodeData,
232                                       virStorageSource *src,
233                                       const char *bitmap);
234 
235 GHashTable *
236 qemuBlockGetNamedNodeData(virDomainObj *vm,
237                           qemuDomainAsyncJob asyncJob);
238 
239 int
240 qemuBlockGetBitmapMergeActions(virStorageSource *topsrc,
241                                virStorageSource *basesrc,
242                                virStorageSource *target,
243                                const char *bitmapname,
244                                const char *dstbitmapname,
245                                virStorageSource *writebitmapsrc,
246                                virJSONValue **actions,
247                                GHashTable *blockNamedNodeData);
248 
249 bool
250 qemuBlockBitmapChainIsValid(virStorageSource *src,
251                             const char *bitmapname,
252                             GHashTable *blockNamedNodeData);
253 
254 int
255 qemuBlockBitmapsHandleBlockcopy(virStorageSource *src,
256                                 virStorageSource *mirror,
257                                 GHashTable *blockNamedNodeData,
258                                 bool shallow,
259                                 virJSONValue **actions);
260 
261 int
262 qemuBlockBitmapsHandleCommitFinish(virStorageSource *topsrc,
263                                    virStorageSource *basesrc,
264                                    bool active,
265                                    GHashTable *blockNamedNodeData,
266                                    virJSONValue **actions);
267 
268 /* only for use in qemumonitorjsontest */
269 int
270 qemuBlockReopenFormatMon(qemuMonitor *mon,
271                          virStorageSource *src);
272 
273 int
274 qemuBlockReopenReadWrite(virDomainObj *vm,
275                          virStorageSource *src,
276                          qemuDomainAsyncJob asyncJob);
277 int
278 qemuBlockReopenReadOnly(virDomainObj *vm,
279                         virStorageSource *src,
280                         qemuDomainAsyncJob asyncJob);
281 
282 bool
283 qemuBlockStorageSourceNeedsStorageSliceLayer(const virStorageSource *src);
284 
285 char *
286 qemuBlockStorageSourceGetCookieString(virStorageSource *src);
287 
288 int
289 qemuBlockUpdateRelativeBacking(virDomainObj *vm,
290                                virStorageSource *src,
291                                virStorageSource *topsrc);
292 
293 virJSONValue *
294 qemuBlockExportGetNBDProps(const char *nodename,
295                            const char *exportname,
296                            bool writable,
297                            const char **bitmaps);
298 
299 
300 int
301 qemuBlockExportAddNBD(virDomainObj *vm,
302                       const char *drivealias,
303                       virStorageSource *src,
304                       const char *exportname,
305                       bool writable,
306                       const char *bitmap);
307