udf_strat_rmw.c revision 1.4.2.3
1 /* $NetBSD: udf_strat_rmw.c,v 1.4.2.3 2008/09/18 04:36:56 wrstuden Exp $ */ 2 3 /* 4 * Copyright (c) 2006, 2008 Reinoud Zandijk 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 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 */ 28 29 #include <sys/cdefs.h> 30 #ifndef lint 31 __KERNEL_RCSID(0, "$NetBSD: udf_strat_rmw.c,v 1.4.2.3 2008/09/18 04:36:56 wrstuden Exp $"); 32 #endif /* not lint */ 33 34 35 #if defined(_KERNEL_OPT) 36 #include "opt_quota.h" 37 #include "opt_compat_netbsd.h" 38 #endif 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/sysctl.h> 43 #include <sys/namei.h> 44 #include <sys/proc.h> 45 #include <sys/kernel.h> 46 #include <sys/vnode.h> 47 #include <miscfs/genfs/genfs_node.h> 48 #include <sys/mount.h> 49 #include <sys/buf.h> 50 #include <sys/file.h> 51 #include <sys/device.h> 52 #include <sys/disklabel.h> 53 #include <sys/ioctl.h> 54 #include <sys/malloc.h> 55 #include <sys/dirent.h> 56 #include <sys/stat.h> 57 #include <sys/conf.h> 58 #include <sys/kauth.h> 59 #include <sys/kthread.h> 60 #include <dev/clock_subr.h> 61 62 #include <fs/udf/ecma167-udf.h> 63 #include <fs/udf/udf_mount.h> 64 65 #include "udf.h" 66 #include "udf_subr.h" 67 #include "udf_bswap.h" 68 69 70 #define VTOI(vnode) ((struct udf_node *) (vnode)->v_data) 71 #define PRIV(ump) ((struct strat_private *) (ump)->strategy_private) 72 #define BTOE(buf) ((struct udf_eccline *) ((buf)->b_private)) 73 74 /* --------------------------------------------------------------------- */ 75 76 #define UDF_MAX_PACKET_SIZE 64 /* DONT change this */ 77 78 /* sheduler states */ 79 #define UDF_SHED_MAX 6 80 #define UDF_SHED_READING 1 81 #define UDF_SHED_WRITING 2 82 #define UDF_SHED_SEQWRITING 3 83 #define UDF_SHED_IDLE 4 /* resting */ 84 #define UDF_SHED_FREE 5 /* recycleable */ 85 86 /* flags */ 87 #define ECC_LOCKED 0x01 /* prevent access */ 88 #define ECC_WANTED 0x02 /* trying access */ 89 #define ECC_SEQWRITING 0x04 /* sequential queue */ 90 #define ECC_FLOATING 0x08 /* not queued yet */ 91 92 93 TAILQ_HEAD(ecclineq, udf_eccline); 94 struct udf_eccline { 95 struct udf_mount *ump; 96 uint64_t present; /* preserve these */ 97 uint64_t readin; /* bitmap */ 98 uint64_t dirty; /* bitmap */ 99 uint64_t error; /* bitmap */ 100 uint32_t refcnt; 101 102 uint32_t flags; 103 uint32_t start_sector; /* physical */ 104 105 struct buf *buf; 106 void *blob; 107 108 struct buf *bufs[UDF_MAX_PACKET_SIZE]; 109 uint32_t bufs_bpos[UDF_MAX_PACKET_SIZE]; 110 int bufs_len[UDF_MAX_PACKET_SIZE]; 111 112 int queued_on; /* on which BUFQ list */ 113 LIST_ENTRY(udf_eccline) hashchain; /* on sector lookup */ 114 }; 115 116 117 struct strat_private { 118 lwp_t *queue_lwp; 119 kcondvar_t discstrat_cv; /* to wait on */ 120 kmutex_t discstrat_mutex; /* disc strategy */ 121 kmutex_t seqwrite_mutex; /* protect mappings */ 122 123 int run_thread; /* thread control */ 124 int thread_finished; /* thread control */ 125 int cur_queue; 126 127 int num_floating; 128 int num_queued[UDF_SHED_MAX]; 129 struct bufq_state *queues[UDF_SHED_MAX]; 130 struct timespec last_queued[UDF_SHED_MAX]; 131 struct disk_strategy old_strategy_setting; 132 133 struct pool eccline_pool; 134 struct pool ecclineblob_pool; 135 LIST_HEAD(, udf_eccline) eccline_hash[UDF_ECCBUF_HASHSIZE]; 136 }; 137 138 /* --------------------------------------------------------------------- */ 139 140 #define UDF_LOCK_ECCLINE(eccline) udf_lock_eccline(eccline) 141 #define UDF_UNLOCK_ECCLINE(eccline) udf_unlock_eccline(eccline) 142 143 /* can be called with or without discstrat lock */ 144 static void 145 udf_lock_eccline(struct udf_eccline *eccline) 146 { 147 struct strat_private *priv = PRIV(eccline->ump); 148 int waslocked, ret; 149 150 waslocked = mutex_owned(&priv->discstrat_mutex); 151 if (!waslocked) 152 mutex_enter(&priv->discstrat_mutex); 153 154 /* wait until its unlocked first */ 155 while (eccline->flags & ECC_LOCKED) { 156 eccline->flags |= ECC_WANTED; 157 ret = cv_timedwait(&priv->discstrat_cv, &priv->discstrat_mutex, 158 hz/8); 159 if (ret == EWOULDBLOCK) 160 DPRINTF(LOCKING, ("eccline lock helt, waiting for " 161 "release")); 162 } 163 eccline->flags |= ECC_LOCKED; 164 eccline->flags &= ~ECC_WANTED; 165 166 if (!waslocked) 167 mutex_exit(&priv->discstrat_mutex); 168 } 169 170 171 /* can be called with or without discstrat lock */ 172 static void 173 udf_unlock_eccline(struct udf_eccline *eccline) 174 { 175 struct strat_private *priv = PRIV(eccline->ump); 176 int waslocked; 177 178 KASSERT(mutex_owned(&priv->discstrat_mutex)); 179 180 waslocked = mutex_owned(&priv->discstrat_mutex); 181 if (!waslocked) 182 mutex_enter(&priv->discstrat_mutex); 183 184 eccline->flags &= ~ECC_LOCKED; 185 cv_broadcast(&priv->discstrat_cv); 186 187 if (!waslocked) 188 mutex_exit(&priv->discstrat_mutex); 189 } 190 191 192 /* NOTE discstrat_mutex should be held! */ 193 static void 194 udf_dispose_eccline(struct udf_eccline *eccline) 195 { 196 struct strat_private *priv = PRIV(eccline->ump); 197 struct buf *ret; 198 199 KASSERT(mutex_owned(&priv->discstrat_mutex)); 200 201 KASSERT(eccline->refcnt == 0); 202 KASSERT(eccline->dirty == 0); 203 204 DPRINTF(ECCLINE, ("dispose eccline with start sector %d, " 205 "present %0"PRIx64"\n", eccline->start_sector, 206 eccline->present)); 207 208 if (eccline->queued_on) { 209 ret = BUFQ_CANCEL(priv->queues[eccline->queued_on], eccline->buf); 210 KASSERT(ret == eccline->buf); 211 priv->num_queued[eccline->queued_on]--; 212 } 213 LIST_REMOVE(eccline, hashchain); 214 215 if (eccline->flags & ECC_FLOATING) { 216 eccline->flags &= ~ECC_FLOATING; 217 priv->num_floating--; 218 } 219 220 putiobuf(eccline->buf); 221 pool_put(&priv->ecclineblob_pool, eccline->blob); 222 pool_put(&priv->eccline_pool, eccline); 223 } 224 225 226 /* NOTE discstrat_mutex should be held! */ 227 static void 228 udf_push_eccline(struct udf_eccline *eccline, int newqueue) 229 { 230 struct strat_private *priv = PRIV(eccline->ump); 231 struct buf *ret; 232 int curqueue; 233 234 KASSERT(mutex_owned(&priv->discstrat_mutex)); 235 236 DPRINTF(PARANOIA, ("DEBUG: buf %p pushed on queue %d\n", eccline->buf, newqueue)); 237 238 /* requeue */ 239 curqueue = eccline->queued_on; 240 if (curqueue) { 241 ret = BUFQ_CANCEL(priv->queues[curqueue], eccline->buf); 242 243 DPRINTF(PARANOIA, ("push_eccline BUFQ_CANCEL returned %p when " 244 "requested to remove %p from queue %d\n", ret, 245 eccline->buf, curqueue)); 246 #ifdef DIAGNOSTIC 247 if (ret == NULL) { 248 int i; 249 250 printf("udf_push_eccline: bufq_cancel can't find " 251 "buffer; dumping queues\n"); 252 for (i = 1; i < UDF_SHED_MAX; i++) { 253 printf("queue %d\n\t", i); 254 ret = BUFQ_GET(priv->queues[i]); 255 while (ret) { 256 printf("%p ", ret); 257 if (ret == eccline->buf) 258 printf("[<-] "); 259 ret = BUFQ_GET(priv->queues[i]); 260 } 261 printf("\n"); 262 } 263 panic("fatal queue bug; exit"); 264 } 265 #endif 266 267 KASSERT(ret == eccline->buf); 268 priv->num_queued[curqueue]--; 269 } 270 271 BUFQ_PUT(priv->queues[newqueue], eccline->buf); 272 eccline->queued_on = newqueue; 273 priv->num_queued[newqueue]++; 274 vfs_timestamp(&priv->last_queued[newqueue]); 275 276 if (eccline->flags & ECC_FLOATING) { 277 eccline->flags &= ~ECC_FLOATING; 278 priv->num_floating--; 279 } 280 281 if ((newqueue != UDF_SHED_FREE) && (newqueue != UDF_SHED_IDLE)) 282 cv_signal(&priv->discstrat_cv); 283 } 284 285 286 static struct udf_eccline * 287 udf_pop_eccline(struct strat_private *priv, int queued_on) 288 { 289 struct udf_eccline *eccline; 290 struct buf *buf; 291 292 KASSERT(mutex_owned(&priv->discstrat_mutex)); 293 294 buf = BUFQ_GET(priv->queues[queued_on]); 295 if (!buf) { 296 KASSERT(priv->num_queued[queued_on] == 0); 297 return NULL; 298 } 299 300 eccline = BTOE(buf); 301 KASSERT(eccline->queued_on == queued_on); 302 eccline->queued_on = 0; 303 priv->num_queued[queued_on]--; 304 305 if (eccline->flags & ECC_FLOATING) 306 panic("popping already marked floating eccline"); 307 eccline->flags |= ECC_FLOATING; 308 priv->num_floating++; 309 310 DPRINTF(PARANOIA, ("DEBUG: buf %p popped from queue %d\n", 311 eccline->buf, queued_on)); 312 313 return eccline; 314 } 315 316 317 static struct udf_eccline * 318 udf_geteccline(struct udf_mount *ump, uint32_t sector, int flags) 319 { 320 struct strat_private *priv = PRIV(ump); 321 struct udf_eccline *eccline; 322 uint32_t start_sector, lb_size, blobsize; 323 uint8_t *eccline_blob; 324 int line, line_offset; 325 int num_busy, ret; 326 327 line_offset = sector % ump->packet_size; 328 start_sector = sector - line_offset; 329 line = (start_sector/ump->packet_size) & UDF_ECCBUF_HASHMASK; 330 331 mutex_enter(&priv->discstrat_mutex); 332 333 retry: 334 DPRINTF(ECCLINE, ("get line sector %d, line %d\n", sector, line)); 335 LIST_FOREACH(eccline, &priv->eccline_hash[line], hashchain) { 336 if (eccline->start_sector == start_sector) { 337 DPRINTF(ECCLINE, ("\tfound eccline, start_sector %d\n", 338 eccline->start_sector)); 339 340 UDF_LOCK_ECCLINE(eccline); 341 /* move from freelist (!) */ 342 if (eccline->queued_on == UDF_SHED_FREE) { 343 DPRINTF(ECCLINE, ("was on freelist\n")); 344 KASSERT(eccline->refcnt == 0); 345 udf_push_eccline(eccline, UDF_SHED_IDLE); 346 } 347 eccline->refcnt++; 348 mutex_exit(&priv->discstrat_mutex); 349 return eccline; 350 } 351 } 352 353 DPRINTF(ECCLINE, ("\tnot found in eccline cache\n")); 354 /* not found in eccline cache */ 355 356 lb_size = udf_rw32(ump->logical_vol->lb_size); 357 blobsize = ump->packet_size * lb_size; 358 359 /* dont allow too many pending requests */ 360 DPRINTF(ECCLINE, ("\tallocating new eccline\n")); 361 num_busy = (priv->num_queued[UDF_SHED_SEQWRITING] + priv->num_floating); 362 if ((flags & ECC_SEQWRITING) && (num_busy > UDF_ECCLINE_MAXBUSY)) { 363 ret = cv_timedwait(&priv->discstrat_cv, 364 &priv->discstrat_mutex, hz/8); 365 goto retry; 366 } 367 368 eccline_blob = pool_get(&priv->ecclineblob_pool, PR_NOWAIT); 369 eccline = pool_get(&priv->eccline_pool, PR_NOWAIT); 370 if ((eccline_blob == NULL) || (eccline == NULL)) { 371 if (eccline_blob) 372 pool_put(&priv->ecclineblob_pool, eccline_blob); 373 if (eccline) 374 pool_put(&priv->eccline_pool, eccline); 375 376 /* out of memory for now; canibalise freelist */ 377 eccline = udf_pop_eccline(priv, UDF_SHED_FREE); 378 if (eccline == NULL) { 379 /* serious trouble; wait and retry */ 380 cv_timedwait(&priv->discstrat_cv, 381 &priv->discstrat_mutex, hz/8); 382 goto retry; 383 } 384 /* push back line if we're waiting for it */ 385 if (eccline->flags & ECC_WANTED) { 386 udf_push_eccline(eccline, UDF_SHED_IDLE); 387 goto retry; 388 } 389 390 /* unlink this entry */ 391 LIST_REMOVE(eccline, hashchain); 392 393 KASSERT(eccline->flags & ECC_FLOATING); 394 395 eccline_blob = eccline->blob; 396 memset(eccline, 0, sizeof(struct udf_eccline)); 397 eccline->flags = ECC_FLOATING; 398 } else { 399 memset(eccline, 0, sizeof(struct udf_eccline)); 400 eccline->flags = ECC_FLOATING; 401 priv->num_floating++; 402 } 403 404 eccline->queued_on = 0; 405 eccline->blob = eccline_blob; 406 eccline->buf = getiobuf(NULL, true); 407 eccline->buf->b_private = eccline; /* IMPORTANT */ 408 409 /* initialise eccline blob */ 410 memset(eccline->blob, 0, blobsize); 411 412 eccline->ump = ump; 413 eccline->present = eccline->readin = eccline->dirty = 0; 414 eccline->error = 0; 415 eccline->refcnt = 0; 416 eccline->start_sector = start_sector; 417 418 LIST_INSERT_HEAD(&priv->eccline_hash[line], eccline, hashchain); 419 420 /* 421 * TODO possible optimalisation for checking overlap with partitions 422 * to get a clue on future eccline usage 423 */ 424 eccline->refcnt++; 425 UDF_LOCK_ECCLINE(eccline); 426 427 mutex_exit(&priv->discstrat_mutex); 428 429 return eccline; 430 } 431 432 433 static void 434 udf_puteccline(struct udf_eccline *eccline) 435 { 436 struct strat_private *priv = PRIV(eccline->ump); 437 struct udf_eccline *deccline; 438 struct udf_mount *ump = eccline->ump; 439 uint64_t allbits = ((uint64_t) 1 << ump->packet_size)-1; 440 int newqueue, tries; 441 442 mutex_enter(&priv->discstrat_mutex); 443 444 /* clear directly all readin requests from present ones */ 445 if (eccline->readin & eccline->present) { 446 /* clear all read bits that are already read in */ 447 eccline->readin &= (~eccline->present) & allbits; 448 wakeup(eccline); 449 } 450 451 DPRINTF(ECCLINE, ("put eccline start sector %d, refcnt %d\n", 452 eccline->start_sector, eccline->refcnt)); 453 454 /* requeue */ 455 newqueue = UDF_SHED_FREE; 456 if (eccline->refcnt > 1) 457 newqueue = UDF_SHED_IDLE; 458 if (eccline->flags & ECC_WANTED) 459 newqueue = UDF_SHED_IDLE; 460 if (eccline->dirty) { 461 newqueue = UDF_SHED_WRITING; 462 if (eccline->flags & ECC_SEQWRITING) 463 newqueue = UDF_SHED_SEQWRITING; 464 } 465 466 /* if we have active nodes */ 467 if (eccline->refcnt > 1) { 468 /* we dont set it on seqwriting */ 469 eccline->flags &= ~ECC_SEQWRITING; 470 } 471 472 /* if we need reading in or not all is yet present, queue reading */ 473 if ((eccline->readin) || (eccline->present != allbits)) 474 newqueue = UDF_SHED_READING; 475 476 /* reduce the number of kept free buffers */ 477 tries = priv->num_queued[UDF_SHED_FREE] - UDF_ECCLINE_MAXFREE; 478 while (tries > 0 /* priv->num_queued[UDF_SHED_FREE] > UDF_ECCLINE_MAXFREE */) { 479 deccline = udf_pop_eccline(priv, UDF_SHED_FREE); 480 KASSERT(deccline); 481 KASSERT(deccline->refcnt == 0); 482 if (deccline->flags & ECC_WANTED) { 483 udf_push_eccline(deccline, UDF_SHED_IDLE); 484 DPRINTF(ECCLINE, ("Tried removing, pushed back to free list\n")); 485 } else { 486 DPRINTF(ECCLINE, ("Removing entry from free list\n")); 487 udf_dispose_eccline(deccline); 488 } 489 tries--; 490 } 491 492 udf_push_eccline(eccline, newqueue); 493 494 KASSERT(eccline->refcnt >= 1); 495 eccline->refcnt--; 496 UDF_UNLOCK_ECCLINE(eccline); 497 498 mutex_exit(&priv->discstrat_mutex); 499 } 500 501 /* --------------------------------------------------------------------- */ 502 503 static int 504 udf_create_nodedscr_rmw(struct udf_strat_args *args) 505 { 506 union dscrptr **dscrptr = &args->dscr; 507 struct udf_mount *ump = args->ump; 508 struct long_ad *icb = args->icb; 509 struct udf_eccline *eccline; 510 uint64_t bit; 511 uint32_t sectornr, lb_size, dummy; 512 uint8_t *mem; 513 int error, eccsect; 514 515 error = udf_translate_vtop(ump, icb, §ornr, &dummy); 516 if (error) 517 return error; 518 519 lb_size = udf_rw32(ump->logical_vol->lb_size); 520 521 /* get our eccline */ 522 eccline = udf_geteccline(ump, sectornr, 0); 523 eccsect = sectornr - eccline->start_sector; 524 525 bit = (uint64_t) 1 << eccsect; 526 eccline->readin &= ~bit; /* just in case */ 527 eccline->present |= bit; 528 eccline->dirty &= ~bit; /* Err... euhm... clean? */ 529 530 eccline->refcnt++; 531 532 /* clear space */ 533 mem = ((uint8_t *) eccline->blob) + eccsect * lb_size; 534 memset(mem, 0, lb_size); 535 536 udf_puteccline(eccline); 537 538 *dscrptr = (union dscrptr *) mem; 539 return 0; 540 } 541 542 543 static void 544 udf_free_nodedscr_rmw(struct udf_strat_args *args) 545 { 546 struct udf_mount *ump = args->ump; 547 struct long_ad *icb = args->icb; 548 struct udf_eccline *eccline; 549 uint64_t bit; 550 uint32_t sectornr, dummy; 551 int error, eccsect; 552 553 error = udf_translate_vtop(ump, icb, §ornr, &dummy); 554 if (error) 555 return; 556 557 /* get our eccline */ 558 eccline = udf_geteccline(ump, sectornr, 0); 559 eccsect = sectornr - eccline->start_sector; 560 561 bit = (uint64_t) 1 << eccsect; 562 eccline->readin &= ~bit; /* just in case */ 563 564 KASSERT(eccline->refcnt >= 1); 565 eccline->refcnt--; 566 567 udf_puteccline(eccline); 568 } 569 570 571 static int 572 udf_read_nodedscr_rmw(struct udf_strat_args *args) 573 { 574 union dscrptr **dscrptr = &args->dscr; 575 struct udf_mount *ump = args->ump; 576 struct long_ad *icb = args->icb; 577 struct udf_eccline *eccline; 578 uint64_t bit; 579 uint32_t sectornr, dummy; 580 uint8_t *pos; 581 int sector_size = ump->discinfo.sector_size; 582 int lb_size = udf_rw32(ump->logical_vol->lb_size); 583 int i, error, dscrlen, eccsect; 584 585 lb_size = lb_size; 586 KASSERT(sector_size == lb_size); 587 error = udf_translate_vtop(ump, icb, §ornr, &dummy); 588 if (error) 589 return error; 590 591 /* get our eccline */ 592 eccline = udf_geteccline(ump, sectornr, 0); 593 eccsect = sectornr - eccline->start_sector; 594 595 bit = (uint64_t) 1 << eccsect; 596 if ((eccline->present & bit) == 0) { 597 /* mark bit for readin */ 598 eccline->readin |= bit; 599 eccline->refcnt++; /* prevent recycling */ 600 KASSERT(eccline->bufs[eccsect] == NULL); 601 udf_puteccline(eccline); 602 603 /* wait for completion; XXX remodel to lock bit code */ 604 error = 0; 605 while ((eccline->present & bit) == 0) { 606 tsleep(eccline, PRIBIO+1, "udflvdrd", hz/8); 607 if (eccline->error & bit) { 608 KASSERT(eccline->refcnt >= 1); 609 eccline->refcnt--; /* undo temp refcnt */ 610 *dscrptr = NULL; 611 return EIO; /* XXX error code */ 612 } 613 } 614 615 /* reget our line */ 616 eccline = udf_geteccline(ump, sectornr, 0); 617 KASSERT(eccline->refcnt >= 1); 618 eccline->refcnt--; /* undo refcnt */ 619 } 620 621 *dscrptr = (union dscrptr *) 622 (((uint8_t *) eccline->blob) + eccsect * sector_size); 623 624 /* code from read_phys_descr */ 625 /* check if its a valid tag */ 626 error = udf_check_tag(*dscrptr); 627 if (error) { 628 /* check if its an empty block */ 629 pos = (uint8_t *) *dscrptr; 630 for (i = 0; i < sector_size; i++, pos++) { 631 if (*pos) break; 632 } 633 if (i == sector_size) { 634 /* return no error but with no dscrptr */ 635 error = 0; 636 } 637 *dscrptr = NULL; 638 udf_puteccline(eccline); 639 return error; 640 } 641 642 /* calculate descriptor size */ 643 dscrlen = udf_tagsize(*dscrptr, sector_size); 644 error = udf_check_tag_payload(*dscrptr, dscrlen); 645 if (error) { 646 *dscrptr = NULL; 647 udf_puteccline(eccline); 648 return error; 649 } 650 651 eccline->refcnt++; 652 udf_puteccline(eccline); 653 654 return 0; 655 } 656 657 658 static int 659 udf_write_nodedscr_rmw(struct udf_strat_args *args) 660 { 661 union dscrptr *dscrptr = args->dscr; 662 struct udf_mount *ump = args->ump; 663 struct long_ad *icb = args->icb; 664 struct udf_node *udf_node = args->udf_node; 665 struct udf_eccline *eccline; 666 uint64_t bit; 667 uint32_t sectornr, logsectornr, dummy; 668 // int waitfor = args->waitfor; 669 int sector_size = ump->discinfo.sector_size; 670 int lb_size = udf_rw32(ump->logical_vol->lb_size); 671 int error, eccsect; 672 673 lb_size = lb_size; 674 KASSERT(sector_size == lb_size); 675 sectornr = 0; 676 error = udf_translate_vtop(ump, icb, §ornr, &dummy); 677 if (error) 678 return error; 679 680 /* add reference to the vnode to prevent recycling */ 681 vhold(udf_node->vnode); 682 683 /* get our eccline */ 684 eccline = udf_geteccline(ump, sectornr, 0); 685 eccsect = sectornr - eccline->start_sector; 686 687 bit = (uint64_t) 1 << eccsect; 688 689 /* old callback still pending? */ 690 if (eccline->bufs[eccsect]) { 691 DPRINTF(WRITE, ("udf_write_nodedscr_rmw: writing descriptor" 692 " over buffer?\n")); 693 nestiobuf_done(eccline->bufs[eccsect], 694 eccline->bufs_len[eccsect], 695 0); 696 eccline->bufs[eccsect] = NULL; 697 } 698 699 /* set sector number in the descriptor and validate */ 700 dscrptr = (union dscrptr *) 701 (((uint8_t *) eccline->blob) + eccsect * sector_size); 702 KASSERT(dscrptr == args->dscr); 703 704 logsectornr = udf_rw32(icb->loc.lb_num); 705 dscrptr->tag.tag_loc = udf_rw32(logsectornr); 706 udf_validate_tag_and_crc_sums(dscrptr); 707 708 udf_fixup_node_internals(ump, (uint8_t *) dscrptr, UDF_C_NODE); 709 710 /* set our flags */ 711 KASSERT(eccline->present & bit); 712 eccline->dirty |= bit; 713 714 KASSERT(udf_tagsize(dscrptr, sector_size) <= sector_size); 715 716 udf_puteccline(eccline); 717 718 holdrele(udf_node->vnode); 719 udf_node->outstanding_nodedscr--; 720 if (udf_node->outstanding_nodedscr == 0) { 721 UDF_UNLOCK_NODE(udf_node, udf_node->i_flags & IN_CALLBACK_ULK); 722 wakeup(&udf_node->outstanding_nodedscr); 723 } 724 725 /* XXX waitfor not used */ 726 return 0; 727 } 728 729 730 static void 731 udf_queuebuf_rmw(struct udf_strat_args *args) 732 { 733 struct udf_mount *ump = args->ump; 734 struct buf *buf = args->nestbuf; 735 struct desc_tag *tag; 736 struct strat_private *priv = PRIV(ump); 737 struct udf_eccline *eccline; 738 struct long_ad *node_ad_cpy; 739 uint64_t bit, *lmapping, *pmapping, *lmappos, *pmappos, blknr; 740 uint32_t buf_len, len, sectors, sectornr, our_sectornr; 741 uint32_t bpos; 742 uint16_t vpart_num; 743 uint8_t *fidblk, *src, *dst; 744 int sector_size = ump->discinfo.sector_size; 745 int blks = sector_size / DEV_BSIZE; 746 int eccsect, what, queue, error; 747 748 KASSERT(ump); 749 KASSERT(buf); 750 KASSERT(buf->b_iodone == nestiobuf_iodone); 751 752 blknr = buf->b_blkno; 753 our_sectornr = blknr / blks; 754 755 what = buf->b_udf_c_type; 756 queue = UDF_SHED_READING; 757 if ((buf->b_flags & B_READ) == 0) { 758 /* writing */ 759 queue = UDF_SHED_SEQWRITING; 760 if (what == UDF_C_DSCR) 761 queue = UDF_SHED_WRITING; 762 if (what == UDF_C_NODE) 763 queue = UDF_SHED_WRITING; 764 } 765 766 if (queue == UDF_SHED_READING) { 767 DPRINTF(SHEDULE, ("\nudf_queuebuf_rmw READ %p : sector %d type %d," 768 "b_resid %d, b_bcount %d, b_bufsize %d\n", 769 buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type, 770 buf->b_resid, buf->b_bcount, buf->b_bufsize)); 771 772 /* mark bits for reading */ 773 buf_len = buf->b_bcount; 774 sectornr = our_sectornr; 775 eccline = udf_geteccline(ump, sectornr, 0); 776 eccsect = sectornr - eccline->start_sector; 777 bpos = 0; 778 while (buf_len) { 779 len = MIN(buf_len, sector_size); 780 if (eccsect == ump->packet_size) { 781 udf_puteccline(eccline); 782 eccline = udf_geteccline(ump, sectornr, 0); 783 eccsect = sectornr - eccline->start_sector; 784 } 785 bit = (uint64_t) 1 << eccsect; 786 error = eccline->error & bit ? EIO : 0; 787 if (eccline->present & bit) { 788 src = (uint8_t *) eccline->blob + 789 eccsect * sector_size; 790 dst = (uint8_t *) buf->b_data + bpos; 791 if (!error) 792 memcpy(dst, src, len); 793 nestiobuf_done(buf, len, error); 794 } else { 795 eccline->readin |= bit; 796 KASSERT(eccline->bufs[eccsect] == NULL); 797 eccline->bufs[eccsect] = buf; 798 eccline->bufs_bpos[eccsect] = bpos; 799 eccline->bufs_len[eccsect] = len; 800 } 801 bpos += sector_size; 802 eccsect++; 803 sectornr++; 804 buf_len -= len; 805 } 806 udf_puteccline(eccline); 807 return; 808 } 809 810 if (queue == UDF_SHED_WRITING) { 811 DPRINTF(SHEDULE, ("\nudf_queuebuf_rmw WRITE %p : sector %d " 812 "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n", 813 buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type, 814 buf->b_resid, buf->b_bcount, buf->b_bufsize)); 815 /* if we have FIDs fixup using buffer's sector number(s) */ 816 if (buf->b_udf_c_type == UDF_C_FIDS) { 817 panic("UDF_C_FIDS in SHED_WRITING!\n"); 818 #if 0 819 buf_len = buf->b_bcount; 820 sectornr = our_sectornr; 821 bpos = 0; 822 while (buf_len) { 823 len = MIN(buf_len, sector_size); 824 fidblk = (uint8_t *) buf->b_data + bpos; 825 udf_fixup_fid_block(fidblk, sector_size, 826 0, len, sectornr); 827 sectornr++; 828 bpos += len; 829 buf_len -= len; 830 } 831 #endif 832 } 833 udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type); 834 835 /* copy parts into the bufs and set for writing */ 836 buf_len = buf->b_bcount; 837 sectornr = our_sectornr; 838 eccline = udf_geteccline(ump, sectornr, 0); 839 eccsect = sectornr - eccline->start_sector; 840 bpos = 0; 841 while (buf_len) { 842 len = MIN(buf_len, sector_size); 843 if (eccsect == ump->packet_size) { 844 udf_puteccline(eccline); 845 eccline = udf_geteccline(ump, sectornr, 0); 846 eccsect = sectornr - eccline->start_sector; 847 } 848 bit = (uint64_t) 1 << eccsect; 849 KASSERT((eccline->readin & bit) == 0); 850 eccline->present |= bit; 851 eccline->dirty |= bit; 852 if (eccline->bufs[eccsect]) { 853 /* old callback still pending */ 854 nestiobuf_done(eccline->bufs[eccsect], 855 eccline->bufs_len[eccsect], 856 0); 857 eccline->bufs[eccsect] = NULL; 858 } 859 860 src = (uint8_t *) buf->b_data + bpos; 861 dst = (uint8_t *) eccline->blob + eccsect * sector_size; 862 if (len != sector_size) 863 memset(dst, 0, sector_size); 864 memcpy(dst, src, len); 865 866 /* note that its finished for this extent */ 867 eccline->bufs[eccsect] = NULL; 868 nestiobuf_done(buf, len, 0); 869 870 bpos += sector_size; 871 eccsect++; 872 sectornr++; 873 buf_len -= len; 874 } 875 udf_puteccline(eccline); 876 return; 877 878 } 879 880 /* sequential writing */ 881 KASSERT(queue == UDF_SHED_SEQWRITING); 882 DPRINTF(SHEDULE, ("\nudf_queuebuf_rmw SEQWRITE %p : sector XXXX " 883 "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n", 884 buf, buf->b_udf_c_type, buf->b_resid, buf->b_bcount, 885 buf->b_bufsize)); 886 /* 887 * Buffers should not have been allocated to disc addresses yet on 888 * this queue. Note that a buffer can get multiple extents allocated. 889 * Note that it *looks* like the normal writing but its different in 890 * the details. 891 * 892 * lmapping contains lb_num relative to base partition. 893 * 894 * XXX should we try to claim/organize the allocated memory to 895 * block-aligned pieces? 896 */ 897 mutex_enter(&priv->seqwrite_mutex); 898 899 lmapping = ump->la_lmapping; 900 node_ad_cpy = ump->la_node_ad_cpy; 901 902 /* logically allocate buf and map it in the file */ 903 udf_late_allocate_buf(ump, buf, lmapping, node_ad_cpy, &vpart_num); 904 905 /* if we have FIDs, fixup using the new allocation table */ 906 if (buf->b_udf_c_type == UDF_C_FIDS) { 907 buf_len = buf->b_bcount; 908 bpos = 0; 909 lmappos = lmapping; 910 while (buf_len) { 911 sectornr = *lmappos++; 912 len = MIN(buf_len, sector_size); 913 fidblk = (uint8_t *) buf->b_data + bpos; 914 udf_fixup_fid_block(fidblk, sector_size, 915 0, len, sectornr); 916 bpos += len; 917 buf_len -= len; 918 } 919 } 920 if (buf->b_udf_c_type == UDF_C_METADATA_SBM) { 921 if (buf->b_lblkno == 0) { 922 /* update the tag location inside */ 923 tag = (struct desc_tag *) buf->b_data; 924 tag->tag_loc = udf_rw32(*lmapping); 925 udf_validate_tag_and_crc_sums(buf->b_data); 926 } 927 } 928 udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type); 929 930 /* 931 * Translate new mappings in lmapping to pmappings. 932 * pmapping to contain lb_nums as used for disc adressing. 933 */ 934 pmapping = ump->la_pmapping; 935 sectors = (buf->b_bcount + sector_size -1) / sector_size; 936 udf_translate_vtop_list(ump, sectors, vpart_num, lmapping, pmapping); 937 938 /* copy parts into the bufs and set for writing */ 939 pmappos = pmapping; 940 buf_len = buf->b_bcount; 941 sectornr = *pmappos++; 942 eccline = udf_geteccline(ump, sectornr, ECC_SEQWRITING); 943 eccsect = sectornr - eccline->start_sector; 944 bpos = 0; 945 while (buf_len) { 946 len = MIN(buf_len, sector_size); 947 eccsect = sectornr - eccline->start_sector; 948 if ((eccsect < 0) || (eccsect >= ump->packet_size)) { 949 eccline->flags |= ECC_SEQWRITING; 950 udf_puteccline(eccline); 951 eccline = udf_geteccline(ump, sectornr, ECC_SEQWRITING); 952 eccsect = sectornr - eccline->start_sector; 953 } 954 bit = (uint64_t) 1 << eccsect; 955 KASSERT((eccline->readin & bit) == 0); 956 eccline->present |= bit; 957 eccline->dirty |= bit; 958 eccline->bufs[eccsect] = NULL; 959 960 src = (uint8_t *) buf->b_data + bpos; 961 dst = (uint8_t *) 962 eccline->blob + eccsect * sector_size; 963 if (len != sector_size) 964 memset(dst, 0, sector_size); 965 memcpy(dst, src, len); 966 967 /* note that its finished for this extent */ 968 nestiobuf_done(buf, len, 0); 969 970 bpos += sector_size; 971 sectornr = *pmappos++; 972 buf_len -= len; 973 } 974 eccline->flags |= ECC_SEQWRITING; 975 udf_puteccline(eccline); 976 mutex_exit(&priv->seqwrite_mutex); 977 } 978 979 /* --------------------------------------------------------------------- */ 980 981 static void 982 udf_shedule_read_callback(struct buf *buf) 983 { 984 struct udf_eccline *eccline = BTOE(buf); 985 struct udf_mount *ump = eccline->ump; 986 uint64_t bit; 987 uint8_t *src, *dst; 988 int sector_size = ump->discinfo.sector_size; 989 int error, i, len; 990 991 DPRINTF(ECCLINE, ("read callback called\n")); 992 /* post process read action */ 993 error = buf->b_error; 994 for (i = 0; i < ump->packet_size; i++) { 995 bit = (uint64_t) 1 << i; 996 src = (uint8_t *) buf->b_data + i * sector_size; 997 dst = (uint8_t *) eccline->blob + i * sector_size; 998 if (eccline->present & bit) 999 continue; 1000 eccline->present |= bit; 1001 if (error) 1002 eccline->error |= bit; 1003 if (eccline->bufs[i]) { 1004 dst = (uint8_t *) eccline->bufs[i]->b_data + 1005 eccline->bufs_bpos[i]; 1006 len = eccline->bufs_len[i]; 1007 if (!error) 1008 memcpy(dst, src, len); 1009 nestiobuf_done(eccline->bufs[i], len, error); 1010 eccline->bufs[i] = NULL; 1011 } 1012 1013 } 1014 KASSERT(buf->b_data == eccline->blob); 1015 KASSERT(eccline->present == ((uint64_t) 1 << ump->packet_size)-1); 1016 1017 /* 1018 * XXX TODO what to do on read errors? read in all sectors 1019 * synchronously and allocate a sparable entry? 1020 */ 1021 1022 wakeup(eccline); 1023 udf_puteccline(eccline); 1024 DPRINTF(ECCLINE, ("read callback finished\n")); 1025 } 1026 1027 1028 static void 1029 udf_shedule_write_callback(struct buf *buf) 1030 { 1031 struct udf_eccline *eccline = BTOE(buf); 1032 struct udf_mount *ump = eccline->ump; 1033 uint64_t bit; 1034 int error, i, len; 1035 1036 DPRINTF(ECCLINE, ("write callback called\n")); 1037 /* post process write action */ 1038 error = buf->b_error; 1039 for (i = 0; i < ump->packet_size; i++) { 1040 bit = (uint64_t) 1 << i; 1041 if ((eccline->dirty & bit) == 0) 1042 continue; 1043 if (error) { 1044 eccline->error |= bit; 1045 } else { 1046 eccline->dirty &= ~bit; 1047 } 1048 if (eccline->bufs[i]) { 1049 len = eccline->bufs_len[i]; 1050 nestiobuf_done(eccline->bufs[i], len, error); 1051 eccline->bufs[i] = NULL; 1052 } 1053 } 1054 KASSERT(eccline->dirty == 0); 1055 1056 KASSERT(error == 0); 1057 /* 1058 * XXX TODO on write errors allocate a sparable entry 1059 */ 1060 1061 wakeup(eccline); 1062 udf_puteccline(eccline); 1063 } 1064 1065 1066 static void 1067 udf_issue_eccline(struct udf_eccline *eccline, int queued_on) 1068 { 1069 struct udf_mount *ump = eccline->ump; 1070 struct strat_private *priv = PRIV(ump); 1071 struct buf *buf, *nestbuf; 1072 uint64_t bit, allbits = ((uint64_t) 1 << ump->packet_size)-1; 1073 uint32_t start; 1074 int sector_size = ump->discinfo.sector_size; 1075 int blks = sector_size / DEV_BSIZE; 1076 int i; 1077 1078 if (queued_on == UDF_SHED_READING) { 1079 DPRINTF(SHEDULE, ("udf_issue_eccline reading : ")); 1080 /* read all bits that are not yet present */ 1081 eccline->readin = (~eccline->present) & allbits; 1082 KASSERT(eccline->readin); 1083 start = eccline->start_sector; 1084 buf = eccline->buf; 1085 buf_init(buf); 1086 buf->b_flags = B_READ | B_ASYNC; 1087 SET(buf->b_cflags, BC_BUSY); /* mark buffer busy */ 1088 buf->b_oflags = 0; 1089 buf->b_iodone = udf_shedule_read_callback; 1090 buf->b_data = eccline->blob; 1091 buf->b_bcount = ump->packet_size * sector_size; 1092 buf->b_resid = buf->b_bcount; 1093 buf->b_bufsize = buf->b_bcount; 1094 buf->b_private = eccline; 1095 BIO_SETPRIO(buf, BPRIO_DEFAULT); 1096 buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = start * blks; 1097 buf->b_proc = NULL; 1098 1099 if (eccline->present != 0) { 1100 for (i = 0; i < ump->packet_size; i++) { 1101 bit = (uint64_t) 1 << i; 1102 if (eccline->present & bit) { 1103 nestiobuf_done(buf, sector_size, 0); 1104 continue; 1105 } 1106 nestbuf = getiobuf(NULL, true); 1107 nestiobuf_setup(buf, nestbuf, i * sector_size, 1108 sector_size); 1109 /* adjust blocknumber to read */ 1110 nestbuf->b_blkno = buf->b_blkno + i*blks; 1111 nestbuf->b_rawblkno = buf->b_rawblkno + i*blks; 1112 1113 DPRINTF(SHEDULE, ("sector %d ", 1114 start + i)); 1115 /* call asynchronous */ 1116 VOP_STRATEGY(ump->devvp, nestbuf); 1117 } 1118 DPRINTF(SHEDULE, ("\n")); 1119 return; 1120 } 1121 } else { 1122 /* write or seqwrite */ 1123 DPRINTF(SHEDULE, ("udf_issue_eccline writing or seqwriting : ")); 1124 if (eccline->present != allbits) { 1125 /* requeue to read-only */ 1126 DPRINTF(SHEDULE, ("\n\t-> not complete, requeue to " 1127 "reading\n")); 1128 udf_push_eccline(eccline, UDF_SHED_READING); 1129 return; 1130 } 1131 start = eccline->start_sector; 1132 buf = eccline->buf; 1133 buf_init(buf); 1134 buf->b_flags = B_WRITE | B_ASYNC; 1135 SET(buf->b_cflags, BC_BUSY); /* mark buffer busy */ 1136 buf->b_oflags = 0; 1137 buf->b_iodone = udf_shedule_write_callback; 1138 buf->b_data = eccline->blob; 1139 buf->b_bcount = ump->packet_size * sector_size; 1140 buf->b_resid = buf->b_bcount; 1141 buf->b_bufsize = buf->b_bcount; 1142 buf->b_private = eccline; 1143 BIO_SETPRIO(buf, BPRIO_DEFAULT); 1144 buf->b_lblkno = buf->b_blkno = buf->b_rawblkno = start * blks; 1145 buf->b_proc = NULL; 1146 } 1147 1148 mutex_exit(&priv->discstrat_mutex); 1149 /* call asynchronous */ 1150 DPRINTF(SHEDULE, ("sector %d for %d\n", 1151 start, ump->packet_size)); 1152 VOP_STRATEGY(ump->devvp, buf); 1153 mutex_enter(&priv->discstrat_mutex); 1154 } 1155 1156 1157 static void 1158 udf_discstrat_thread(void *arg) 1159 { 1160 struct udf_mount *ump = (struct udf_mount *) arg; 1161 struct strat_private *priv = PRIV(ump); 1162 struct udf_eccline *eccline; 1163 struct timespec now, *last; 1164 int new_queue, wait, work; 1165 1166 work = 1; 1167 mutex_enter(&priv->discstrat_mutex); 1168 priv->num_floating = 0; 1169 while (priv->run_thread || work || priv->num_floating) { 1170 /* process the current selected queue */ 1171 /* maintenance: free exess ecclines */ 1172 while (priv->num_queued[UDF_SHED_FREE] > UDF_ECCLINE_MAXFREE) { 1173 eccline = udf_pop_eccline(priv, UDF_SHED_FREE); 1174 KASSERT(eccline); 1175 KASSERT(eccline->refcnt == 0); 1176 DPRINTF(ECCLINE, ("Removing entry from free list\n")); 1177 udf_dispose_eccline(eccline); 1178 } 1179 1180 /* get our time */ 1181 vfs_timestamp(&now); 1182 last = &priv->last_queued[priv->cur_queue]; 1183 1184 /* don't shedule too quickly when there is only one */ 1185 if (priv->cur_queue == UDF_SHED_WRITING) { 1186 if (priv->num_queued[priv->cur_queue] <= 2) { 1187 if (now.tv_sec - last->tv_sec < 2) { 1188 /* wait some time */ 1189 cv_timedwait(&priv->discstrat_cv, 1190 &priv->discstrat_mutex, hz); 1191 } 1192 } 1193 } 1194 1195 /* get our line */ 1196 eccline = udf_pop_eccline(priv, priv->cur_queue); 1197 if (eccline) { 1198 wait = 0; 1199 new_queue = priv->cur_queue; 1200 DPRINTF(ECCLINE, ("UDF_ISSUE_ECCLINE\n")); 1201 1202 /* complete the `get' by locking and refcounting it */ 1203 UDF_LOCK_ECCLINE(eccline); 1204 eccline->refcnt++; 1205 1206 udf_issue_eccline(eccline, priv->cur_queue); 1207 } else { 1208 wait = 1; 1209 /* check if we can/should switch */ 1210 new_queue = priv->cur_queue; 1211 if (BUFQ_PEEK(priv->queues[UDF_SHED_READING])) 1212 new_queue = UDF_SHED_READING; 1213 if (BUFQ_PEEK(priv->queues[UDF_SHED_WRITING])) 1214 new_queue = UDF_SHED_WRITING; 1215 if (BUFQ_PEEK(priv->queues[UDF_SHED_SEQWRITING])) 1216 new_queue = UDF_SHED_SEQWRITING; 1217 1218 /* dont switch seqwriting too fast */ 1219 if (priv->cur_queue == UDF_SHED_READING) { 1220 if (now.tv_sec - last->tv_sec < 1) 1221 new_queue = priv->cur_queue; 1222 } 1223 if (priv->cur_queue == UDF_SHED_WRITING) { 1224 if (now.tv_sec - last->tv_sec < 2) 1225 new_queue = priv->cur_queue; 1226 } 1227 if (priv->cur_queue == UDF_SHED_SEQWRITING) { 1228 if (now.tv_sec - last->tv_sec < 4) 1229 new_queue = priv->cur_queue; 1230 } 1231 } 1232 1233 /* give room */ 1234 mutex_exit(&priv->discstrat_mutex); 1235 1236 if (new_queue != priv->cur_queue) { 1237 wait = 0; 1238 DPRINTF(SHEDULE, ("switching from %d to %d\n", 1239 priv->cur_queue, new_queue)); 1240 priv->cur_queue = new_queue; 1241 } 1242 mutex_enter(&priv->discstrat_mutex); 1243 1244 /* wait for more if needed */ 1245 if (wait) 1246 cv_timedwait(&priv->discstrat_cv, 1247 &priv->discstrat_mutex, hz); /* /8 */ 1248 1249 work = (BUFQ_PEEK(priv->queues[UDF_SHED_READING]) != NULL); 1250 work |= (BUFQ_PEEK(priv->queues[UDF_SHED_WRITING]) != NULL); 1251 work |= (BUFQ_PEEK(priv->queues[UDF_SHED_SEQWRITING]) != NULL); 1252 1253 DPRINTF(PARANOIA, ("work : (%d, %d, %d) -> work %d, float %d\n", 1254 (BUFQ_PEEK(priv->queues[UDF_SHED_READING]) != NULL), 1255 (BUFQ_PEEK(priv->queues[UDF_SHED_WRITING]) != NULL), 1256 (BUFQ_PEEK(priv->queues[UDF_SHED_SEQWRITING]) != NULL), 1257 work, priv->num_floating)); 1258 } 1259 1260 mutex_exit(&priv->discstrat_mutex); 1261 1262 /* tear down remaining ecclines */ 1263 mutex_enter(&priv->discstrat_mutex); 1264 KASSERT(priv->num_queued[UDF_SHED_IDLE] == 0); 1265 KASSERT(priv->num_queued[UDF_SHED_READING] == 0); 1266 KASSERT(priv->num_queued[UDF_SHED_WRITING] == 0); 1267 KASSERT(priv->num_queued[UDF_SHED_SEQWRITING] == 0); 1268 1269 KASSERT(BUFQ_PEEK(priv->queues[UDF_SHED_IDLE]) == NULL); 1270 KASSERT(BUFQ_PEEK(priv->queues[UDF_SHED_READING]) == NULL); 1271 KASSERT(BUFQ_PEEK(priv->queues[UDF_SHED_WRITING]) == NULL); 1272 KASSERT(BUFQ_PEEK(priv->queues[UDF_SHED_SEQWRITING]) == NULL); 1273 eccline = udf_pop_eccline(priv, UDF_SHED_FREE); 1274 while (eccline) { 1275 udf_dispose_eccline(eccline); 1276 eccline = udf_pop_eccline(priv, UDF_SHED_FREE); 1277 } 1278 KASSERT(priv->num_queued[UDF_SHED_FREE] == 0); 1279 mutex_exit(&priv->discstrat_mutex); 1280 1281 priv->thread_finished = 1; 1282 wakeup(&priv->run_thread); 1283 kthread_exit(0); 1284 /* not reached */ 1285 } 1286 1287 /* --------------------------------------------------------------------- */ 1288 1289 /* 1290 * Buffer memory pool allocator. 1291 */ 1292 1293 static void * 1294 ecclinepool_page_alloc(struct pool *pp, int flags) 1295 { 1296 return (void *)uvm_km_alloc(kernel_map, 1297 MAXBSIZE, MAXBSIZE, 1298 ((flags & PR_WAITOK) ? 0 : UVM_KMF_NOWAIT | UVM_KMF_TRYLOCK) 1299 | UVM_KMF_WIRED /* UVM_KMF_PAGABLE? */); 1300 } 1301 1302 static void 1303 ecclinepool_page_free(struct pool *pp, void *v) 1304 { 1305 uvm_km_free(kernel_map, (vaddr_t)v, MAXBSIZE, UVM_KMF_WIRED); 1306 } 1307 1308 static struct pool_allocator ecclinepool_allocator = { 1309 .pa_alloc = ecclinepool_page_alloc, 1310 .pa_free = ecclinepool_page_free, 1311 .pa_pagesz = MAXBSIZE, 1312 }; 1313 1314 1315 static void 1316 udf_discstrat_init_rmw(struct udf_strat_args *args) 1317 { 1318 struct udf_mount *ump = args->ump; 1319 struct strat_private *priv = PRIV(ump); 1320 uint32_t lb_size, blobsize, hashline; 1321 int i; 1322 1323 KASSERT(ump); 1324 KASSERT(ump->logical_vol); 1325 KASSERT(priv == NULL); 1326 1327 lb_size = udf_rw32(ump->logical_vol->lb_size); 1328 blobsize = ump->packet_size * lb_size; 1329 KASSERT(lb_size > 0); 1330 KASSERT(ump->packet_size <= 64); 1331 1332 /* initialise our memory space */ 1333 ump->strategy_private = malloc(sizeof(struct strat_private), 1334 M_UDFTEMP, M_WAITOK); 1335 priv = ump->strategy_private; 1336 memset(priv, 0 , sizeof(struct strat_private)); 1337 1338 /* initialise locks */ 1339 cv_init(&priv->discstrat_cv, "udfstrat"); 1340 mutex_init(&priv->discstrat_mutex, MUTEX_DRIVER, IPL_BIO); 1341 mutex_init(&priv->seqwrite_mutex, MUTEX_DEFAULT, IPL_NONE); 1342 1343 /* initialise struct eccline pool */ 1344 pool_init(&priv->eccline_pool, sizeof(struct udf_eccline), 1345 0, 0, 0, "udf_eccline_pool", NULL, IPL_NONE); 1346 1347 /* initialise eccline blob pool */ 1348 pool_init(&priv->ecclineblob_pool, blobsize, 1349 0,0,0, "udf_eccline_blob", &ecclinepool_allocator, IPL_NONE); 1350 1351 /* initialise main queues */ 1352 for (i = 0; i < UDF_SHED_MAX; i++) { 1353 priv->num_queued[i] = 0; 1354 vfs_timestamp(&priv->last_queued[i]); 1355 } 1356 bufq_alloc(&priv->queues[UDF_SHED_READING], "disksort", 1357 BUFQ_SORT_RAWBLOCK); 1358 bufq_alloc(&priv->queues[UDF_SHED_WRITING], "disksort", 1359 BUFQ_SORT_RAWBLOCK); 1360 bufq_alloc(&priv->queues[UDF_SHED_SEQWRITING], "disksort", 0); 1361 1362 /* initialise administrative queues */ 1363 bufq_alloc(&priv->queues[UDF_SHED_IDLE], "fcfs", 0); 1364 bufq_alloc(&priv->queues[UDF_SHED_FREE], "fcfs", 0); 1365 1366 for (hashline = 0; hashline < UDF_ECCBUF_HASHSIZE; hashline++) { 1367 LIST_INIT(&priv->eccline_hash[hashline]); 1368 } 1369 1370 /* create our disk strategy thread */ 1371 priv->cur_queue = UDF_SHED_READING; 1372 priv->thread_finished = 0; 1373 priv->run_thread = 1; 1374 if (kthread_create(PRI_NONE, 0 /* KTHREAD_MPSAFE*/, NULL /* cpu_info*/, 1375 udf_discstrat_thread, ump, &priv->queue_lwp, 1376 "%s", "udf_rw")) { 1377 panic("fork udf_rw"); 1378 } 1379 } 1380 1381 1382 static void 1383 udf_discstrat_finish_rmw(struct udf_strat_args *args) 1384 { 1385 struct udf_mount *ump = args->ump; 1386 struct strat_private *priv = PRIV(ump); 1387 int error; 1388 1389 if (ump == NULL) 1390 return; 1391 1392 /* stop our sheduling thread */ 1393 KASSERT(priv->run_thread == 1); 1394 priv->run_thread = 0; 1395 wakeup(priv->queue_lwp); 1396 while (!priv->thread_finished) { 1397 error = tsleep(&priv->run_thread, PRIBIO+1, 1398 "udfshedfin", hz); 1399 } 1400 /* kthread should be finished now */ 1401 1402 /* cleanup our pools */ 1403 pool_destroy(&priv->eccline_pool); 1404 pool_destroy(&priv->ecclineblob_pool); 1405 1406 cv_destroy(&priv->discstrat_cv); 1407 mutex_destroy(&priv->discstrat_mutex); 1408 mutex_destroy(&priv->seqwrite_mutex); 1409 1410 /* free our private space */ 1411 free(ump->strategy_private, M_UDFTEMP); 1412 ump->strategy_private = NULL; 1413 } 1414 1415 /* --------------------------------------------------------------------- */ 1416 1417 struct udf_strategy udf_strat_rmw = 1418 { 1419 udf_create_nodedscr_rmw, 1420 udf_free_nodedscr_rmw, 1421 udf_read_nodedscr_rmw, 1422 udf_write_nodedscr_rmw, 1423 udf_queuebuf_rmw, 1424 udf_discstrat_init_rmw, 1425 udf_discstrat_finish_rmw 1426 }; 1427 1428
Indexes created Mon Oct 13 05:10:05 GMT 2025