1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #ifndef SPDK_BLOBSTORE_H 35 #define SPDK_BLOBSTORE_H 36 37 #include "spdk/assert.h" 38 #include "spdk/blob.h" 39 #include "spdk/queue.h" 40 #include "spdk/util.h" 41 42 #include "request.h" 43 44 /* In Memory Data Structures 45 * 46 * The following data structures exist only in memory. 47 */ 48 49 #define SPDK_BLOB_OPTS_CLUSTER_SZ (1024 * 1024) 50 #define SPDK_BLOB_OPTS_NUM_MD_PAGES UINT32_MAX 51 #define SPDK_BLOB_OPTS_MAX_MD_OPS 32 52 #define SPDK_BLOB_OPTS_DEFAULT_CHANNEL_OPS 512 53 #define SPDK_BLOB_BLOBID_HIGH_BIT (1ULL << 32) 54 55 struct spdk_xattr { 56 /* TODO: reorder for best packing */ 57 uint32_t index; 58 char *name; 59 void *value; 60 uint16_t value_len; 61 TAILQ_ENTRY(spdk_xattr) link; 62 }; 63 64 /* The mutable part of the blob data that is sync'd to 65 * disk. The data in here is both mutable and persistent. 66 */ 67 struct spdk_blob_mut_data { 68 /* Number of data clusters in the blob */ 69 uint64_t num_clusters; 70 71 /* Array LBAs that are the beginning of a cluster, in 72 * the order they appear in the blob. 73 */ 74 uint64_t *clusters; 75 76 /* The size of the clusters array. This is greater than or 77 * equal to 'num_clusters'. 78 */ 79 size_t cluster_array_size; 80 81 /* Number of metadata pages */ 82 uint32_t num_pages; 83 84 /* Array of page offsets into the metadata region, in 85 * the order of the metadata page sequence. 86 */ 87 uint32_t *pages; 88 }; 89 90 enum spdk_blob_state { 91 /* The blob in-memory version does not match the on-disk 92 * version. 93 */ 94 SPDK_BLOB_STATE_DIRTY, 95 96 /* The blob in memory version of the blob matches the on disk 97 * version. 98 */ 99 SPDK_BLOB_STATE_CLEAN, 100 101 /* The in-memory state being synchronized with the on-disk 102 * blob state. */ 103 SPDK_BLOB_STATE_LOADING, 104 }; 105 106 TAILQ_HEAD(spdk_xattr_tailq, spdk_xattr); 107 108 struct spdk_blob_list { 109 spdk_blob_id id; 110 size_t clone_count; 111 TAILQ_HEAD(, spdk_blob_list) clones; 112 TAILQ_ENTRY(spdk_blob_list) link; 113 }; 114 115 struct spdk_blob { 116 struct spdk_blob_store *bs; 117 118 uint32_t open_ref; 119 120 spdk_blob_id id; 121 spdk_blob_id parent_id; 122 123 enum spdk_blob_state state; 124 125 /* Two copies of the mutable data. One is a version 126 * that matches the last known data on disk (clean). 127 * The other (active) is the current data. Syncing 128 * a blob makes the clean match the active. 129 */ 130 struct spdk_blob_mut_data clean; 131 struct spdk_blob_mut_data active; 132 133 bool invalid; 134 bool data_ro; 135 bool md_ro; 136 137 uint64_t invalid_flags; 138 uint64_t data_ro_flags; 139 uint64_t md_ro_flags; 140 141 struct spdk_bs_dev *back_bs_dev; 142 143 /* TODO: The xattrs are mutable, but we don't want to be 144 * copying them unecessarily. Figure this out. 145 */ 146 struct spdk_xattr_tailq xattrs; 147 struct spdk_xattr_tailq xattrs_internal; 148 149 TAILQ_ENTRY(spdk_blob) link; 150 151 uint32_t frozen_refcnt; 152 bool resize_in_progress; 153 }; 154 155 struct spdk_blob_store { 156 uint64_t md_start; /* Offset from beginning of disk, in pages */ 157 uint32_t md_len; /* Count, in pages */ 158 159 struct spdk_io_channel *md_channel; 160 uint32_t max_channel_ops; 161 162 struct spdk_thread *md_thread; 163 164 struct spdk_bs_dev *dev; 165 166 struct spdk_bit_array *used_md_pages; 167 struct spdk_bit_array *used_clusters; 168 struct spdk_bit_array *used_blobids; 169 170 pthread_mutex_t used_clusters_mutex; 171 172 uint32_t cluster_sz; 173 uint64_t total_clusters; 174 uint64_t total_data_clusters; 175 uint64_t num_free_clusters; 176 uint64_t pages_per_cluster; 177 178 spdk_blob_id super_blob; 179 struct spdk_bs_type bstype; 180 181 struct spdk_bs_cpl unload_cpl; 182 int unload_err; 183 184 TAILQ_HEAD(, spdk_blob) blobs; 185 TAILQ_HEAD(, spdk_blob_list) snapshots; 186 187 bool clean; 188 }; 189 190 struct spdk_bs_channel { 191 struct spdk_bs_request_set *req_mem; 192 TAILQ_HEAD(, spdk_bs_request_set) reqs; 193 194 struct spdk_blob_store *bs; 195 196 struct spdk_bs_dev *dev; 197 struct spdk_io_channel *dev_channel; 198 199 TAILQ_HEAD(, spdk_bs_request_set) need_cluster_alloc; 200 TAILQ_HEAD(, spdk_bs_request_set) queued_io; 201 }; 202 203 /** operation type */ 204 enum spdk_blob_op_type { 205 SPDK_BLOB_WRITE, 206 SPDK_BLOB_READ, 207 SPDK_BLOB_UNMAP, 208 SPDK_BLOB_WRITE_ZEROES, 209 SPDK_BLOB_WRITEV, 210 SPDK_BLOB_READV, 211 }; 212 213 /* back bs_dev */ 214 215 #define BLOB_SNAPSHOT "SNAP" 216 #define SNAPSHOT_IN_PROGRESS "SNAPTMP" 217 218 struct spdk_blob_bs_dev { 219 struct spdk_bs_dev bs_dev; 220 struct spdk_blob *blob; 221 }; 222 223 /* On-Disk Data Structures 224 * 225 * The following data structures exist on disk. 226 */ 227 #define SPDK_BS_INITIAL_VERSION 1 228 #define SPDK_BS_VERSION 3 /* current version */ 229 230 #pragma pack(push, 1) 231 232 #define SPDK_MD_MASK_TYPE_USED_PAGES 0 233 #define SPDK_MD_MASK_TYPE_USED_CLUSTERS 1 234 #define SPDK_MD_MASK_TYPE_USED_BLOBIDS 2 235 236 struct spdk_bs_md_mask { 237 uint8_t type; 238 uint32_t length; /* In bits */ 239 uint8_t mask[0]; 240 }; 241 242 #define SPDK_MD_DESCRIPTOR_TYPE_PADDING 0 243 #define SPDK_MD_DESCRIPTOR_TYPE_EXTENT 1 244 #define SPDK_MD_DESCRIPTOR_TYPE_XATTR 2 245 #define SPDK_MD_DESCRIPTOR_TYPE_FLAGS 3 246 #define SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL 4 247 248 struct spdk_blob_md_descriptor_xattr { 249 uint8_t type; 250 uint32_t length; 251 252 uint16_t name_length; 253 uint16_t value_length; 254 255 char name[0]; 256 /* String name immediately followed by string value. */ 257 }; 258 259 struct spdk_blob_md_descriptor_extent { 260 uint8_t type; 261 uint32_t length; 262 263 struct { 264 uint32_t cluster_idx; 265 uint32_t length; /* In units of clusters */ 266 } extents[0]; 267 }; 268 269 #define SPDK_BLOB_THIN_PROV (1ULL << 0) 270 #define SPDK_BLOB_INTERNAL_XATTR (1ULL << 1) 271 #define SPDK_BLOB_INVALID_FLAGS_MASK (SPDK_BLOB_THIN_PROV | SPDK_BLOB_INTERNAL_XATTR) 272 273 #define SPDK_BLOB_READ_ONLY (1ULL << 0) 274 #define SPDK_BLOB_DATA_RO_FLAGS_MASK SPDK_BLOB_READ_ONLY 275 #define SPDK_BLOB_MD_RO_FLAGS_MASK 0 276 277 struct spdk_blob_md_descriptor_flags { 278 uint8_t type; 279 uint32_t length; 280 281 /* 282 * If a flag in invalid_flags is set that the application is not aware of, 283 * it will not allow the blob to be opened. 284 */ 285 uint64_t invalid_flags; 286 287 /* 288 * If a flag in data_ro_flags is set that the application is not aware of, 289 * allow the blob to be opened in data_read_only and md_read_only mode. 290 */ 291 uint64_t data_ro_flags; 292 293 /* 294 * If a flag in md_ro_flags is set the the application is not aware of, 295 * allow the blob to be opened in md_read_only mode. 296 */ 297 uint64_t md_ro_flags; 298 }; 299 300 struct spdk_blob_md_descriptor { 301 uint8_t type; 302 uint32_t length; 303 }; 304 305 #define SPDK_INVALID_MD_PAGE UINT32_MAX 306 307 struct spdk_blob_md_page { 308 spdk_blob_id id; 309 310 uint32_t sequence_num; 311 uint32_t reserved0; 312 313 /* Descriptors here */ 314 uint8_t descriptors[4072]; 315 316 uint32_t next; 317 uint32_t crc; 318 }; 319 #define SPDK_BS_PAGE_SIZE 0x1000 320 SPDK_STATIC_ASSERT(SPDK_BS_PAGE_SIZE == sizeof(struct spdk_blob_md_page), "Invalid md page size"); 321 322 #define SPDK_BS_SUPER_BLOCK_SIG "SPDKBLOB" 323 324 struct spdk_bs_super_block { 325 uint8_t signature[8]; 326 uint32_t version; 327 uint32_t length; 328 uint32_t clean; /* If there was a clean shutdown, this is 1. */ 329 spdk_blob_id super_blob; 330 331 uint32_t cluster_size; /* In bytes */ 332 333 uint32_t used_page_mask_start; /* Offset from beginning of disk, in pages */ 334 uint32_t used_page_mask_len; /* Count, in pages */ 335 336 uint32_t used_cluster_mask_start; /* Offset from beginning of disk, in pages */ 337 uint32_t used_cluster_mask_len; /* Count, in pages */ 338 339 uint32_t md_start; /* Offset from beginning of disk, in pages */ 340 uint32_t md_len; /* Count, in pages */ 341 342 struct spdk_bs_type bstype; /* blobstore type */ 343 344 uint32_t used_blobid_mask_start; /* Offset from beginning of disk, in pages */ 345 uint32_t used_blobid_mask_len; /* Count, in pages */ 346 347 uint64_t size; /* size of blobstore in bytes */ 348 349 uint8_t reserved[4004]; 350 uint32_t crc; 351 }; 352 SPDK_STATIC_ASSERT(sizeof(struct spdk_bs_super_block) == 0x1000, "Invalid super block size"); 353 354 #pragma pack(pop) 355 356 struct spdk_bs_dev *spdk_bs_create_zeroes_dev(void); 357 struct spdk_bs_dev *spdk_bs_create_blob_bs_dev(struct spdk_blob *blob); 358 359 /* Unit Conversions 360 * 361 * The blobstore works with several different units: 362 * - Byte: Self explanatory 363 * - LBA: The logical blocks on the backing storage device. 364 * - Page: The read/write units of blobs and metadata. This is 365 * an offset into a blob in units of 4KiB. 366 * - Cluster Index: The disk is broken into a sequential list of 367 * clusters. This is the offset from the beginning. 368 * 369 * NOTE: These conversions all act on simple magnitudes, not with any sort 370 * of knowledge about the blobs themselves. For instance, converting 371 * a page to an lba with the conversion function below simply converts 372 * a number of pages to an equivalent number of lbas, but that 373 * lba certainly isn't the right lba that corresponds to a page offset 374 * for a particular blob. 375 */ 376 static inline uint64_t 377 _spdk_bs_byte_to_lba(struct spdk_blob_store *bs, uint64_t length) 378 { 379 assert(length % bs->dev->blocklen == 0); 380 381 return length / bs->dev->blocklen; 382 } 383 384 static inline uint64_t 385 _spdk_bs_dev_byte_to_lba(struct spdk_bs_dev *bs_dev, uint64_t length) 386 { 387 assert(length % bs_dev->blocklen == 0); 388 389 return length / bs_dev->blocklen; 390 } 391 392 static inline uint64_t 393 _spdk_bs_lba_to_byte(struct spdk_blob_store *bs, uint64_t lba) 394 { 395 return lba * bs->dev->blocklen; 396 } 397 398 static inline uint64_t 399 _spdk_bs_page_to_lba(struct spdk_blob_store *bs, uint64_t page) 400 { 401 return page * SPDK_BS_PAGE_SIZE / bs->dev->blocklen; 402 } 403 404 static inline uint64_t 405 _spdk_bs_dev_page_to_lba(struct spdk_bs_dev *bs_dev, uint64_t page) 406 { 407 return page * SPDK_BS_PAGE_SIZE / bs_dev->blocklen; 408 } 409 410 static inline uint64_t 411 _spdk_bs_lba_to_page(struct spdk_blob_store *bs, uint64_t lba) 412 { 413 uint64_t lbas_per_page; 414 415 lbas_per_page = SPDK_BS_PAGE_SIZE / bs->dev->blocklen; 416 417 assert(lba % lbas_per_page == 0); 418 419 return lba / lbas_per_page; 420 } 421 422 static inline uint64_t 423 _spdk_bs_dev_lba_to_page(struct spdk_bs_dev *bs_dev, uint64_t lba) 424 { 425 uint64_t lbas_per_page; 426 427 lbas_per_page = SPDK_BS_PAGE_SIZE / bs_dev->blocklen; 428 429 assert(lba % lbas_per_page == 0); 430 431 return lba / lbas_per_page; 432 } 433 434 static inline uint64_t 435 _spdk_bs_cluster_to_page(struct spdk_blob_store *bs, uint32_t cluster) 436 { 437 return (uint64_t)cluster * bs->pages_per_cluster; 438 } 439 440 static inline uint32_t 441 _spdk_bs_page_to_cluster(struct spdk_blob_store *bs, uint64_t page) 442 { 443 assert(page % bs->pages_per_cluster == 0); 444 445 return page / bs->pages_per_cluster; 446 } 447 448 static inline uint64_t 449 _spdk_bs_cluster_to_lba(struct spdk_blob_store *bs, uint32_t cluster) 450 { 451 return (uint64_t)cluster * (bs->cluster_sz / bs->dev->blocklen); 452 } 453 454 static inline uint32_t 455 _spdk_bs_lba_to_cluster(struct spdk_blob_store *bs, uint64_t lba) 456 { 457 assert(lba % (bs->cluster_sz / bs->dev->blocklen) == 0); 458 459 return lba / (bs->cluster_sz / bs->dev->blocklen); 460 } 461 462 static inline uint64_t 463 _spdk_bs_blob_lba_to_back_dev_lba(struct spdk_blob *blob, uint64_t lba) 464 { 465 return lba * blob->bs->dev->blocklen / blob->back_bs_dev->blocklen; 466 } 467 468 static inline uint64_t 469 _spdk_bs_blob_lba_from_back_dev_lba(struct spdk_blob *blob, uint64_t lba) 470 { 471 return lba * blob->back_bs_dev->blocklen / blob->bs->dev->blocklen; 472 } 473 474 /* End basic conversions */ 475 476 static inline uint64_t 477 _spdk_bs_blobid_to_page(spdk_blob_id id) 478 { 479 return id & 0xFFFFFFFF; 480 } 481 482 /* The blob id is a 64 bit number. The lower 32 bits are the page_idx. The upper 483 * 32 bits are not currently used. Stick a 1 there just to catch bugs where the 484 * code assumes blob id == page_idx. 485 */ 486 static inline spdk_blob_id 487 _spdk_bs_page_to_blobid(uint64_t page_idx) 488 { 489 if (page_idx > UINT32_MAX) { 490 return SPDK_BLOBID_INVALID; 491 } 492 return SPDK_BLOB_BLOBID_HIGH_BIT | page_idx; 493 } 494 495 /* Given a page offset into a blob, look up the LBA for the 496 * start of that page. 497 */ 498 static inline uint64_t 499 _spdk_bs_blob_page_to_lba(struct spdk_blob *blob, uint64_t page) 500 { 501 uint64_t lba; 502 uint64_t pages_per_cluster; 503 504 pages_per_cluster = blob->bs->pages_per_cluster; 505 506 assert(page < blob->active.num_clusters * pages_per_cluster); 507 508 lba = blob->active.clusters[page / pages_per_cluster]; 509 lba += _spdk_bs_page_to_lba(blob->bs, page % pages_per_cluster); 510 511 return lba; 512 } 513 514 /* Given a page offset into a blob, look up the number of pages until the 515 * next cluster boundary. 516 */ 517 static inline uint32_t 518 _spdk_bs_num_pages_to_cluster_boundary(struct spdk_blob *blob, uint64_t page) 519 { 520 uint64_t pages_per_cluster; 521 522 pages_per_cluster = blob->bs->pages_per_cluster; 523 524 return pages_per_cluster - (page % pages_per_cluster); 525 } 526 527 /* Given a page offset into a blob, look up the number of pages into blob to beginning of current cluster */ 528 static inline uint32_t 529 _spdk_bs_page_to_cluster_start(struct spdk_blob *blob, uint64_t page) 530 { 531 uint64_t pages_per_cluster; 532 533 pages_per_cluster = blob->bs->pages_per_cluster; 534 535 return page - (page % pages_per_cluster); 536 } 537 538 /* Given a page offset into a blob, look up if it is from allocated cluster. */ 539 static inline bool 540 _spdk_bs_page_is_allocated(struct spdk_blob *blob, uint64_t page) 541 { 542 uint64_t lba; 543 uint64_t pages_per_cluster; 544 545 pages_per_cluster = blob->bs->pages_per_cluster; 546 547 assert(page < blob->active.num_clusters * pages_per_cluster); 548 549 lba = blob->active.clusters[page / pages_per_cluster]; 550 551 if (lba == 0) { 552 assert(spdk_blob_is_thin_provisioned(blob)); 553 return false; 554 } else { 555 return true; 556 } 557 } 558 559 #endif 560