1 /* $NetBSD: udf_strat_sequential.c,v 1.11 2011/01/03 13:12:40 drochner 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_sequential.c,v 1.11 2011/01/03 13:12:40 drochner Exp $"); 32 #endif /* not lint */ 33 34 35 #if defined(_KERNEL_OPT) 36 #include "opt_compat_netbsd.h" 37 #endif 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/sysctl.h> 42 #include <sys/namei.h> 43 #include <sys/proc.h> 44 #include <sys/kernel.h> 45 #include <sys/vnode.h> 46 #include <miscfs/genfs/genfs_node.h> 47 #include <sys/mount.h> 48 #include <sys/buf.h> 49 #include <sys/file.h> 50 #include <sys/device.h> 51 #include <sys/disklabel.h> 52 #include <sys/ioctl.h> 53 #include <sys/malloc.h> 54 #include <sys/dirent.h> 55 #include <sys/stat.h> 56 #include <sys/conf.h> 57 #include <sys/kauth.h> 58 #include <sys/kthread.h> 59 #include <dev/clock_subr.h> 60 61 #include <fs/udf/ecma167-udf.h> 62 #include <fs/udf/udf_mount.h> 63 64 #include "udf.h" 65 #include "udf_subr.h" 66 #include "udf_bswap.h" 67 68 69 #define VTOI(vnode) ((struct udf_node *) vnode->v_data) 70 #define PRIV(ump) ((struct strat_private *) ump->strategy_private) 71 72 /* --------------------------------------------------------------------- */ 73 74 /* BUFQ's */ 75 #define UDF_SHED_MAX 3 76 77 #define UDF_SHED_READING 0 78 #define UDF_SHED_WRITING 1 79 #define UDF_SHED_SEQWRITING 2 80 81 struct strat_private { 82 struct pool desc_pool; /* node descriptors */ 83 84 lwp_t *queue_lwp; 85 kcondvar_t discstrat_cv; /* to wait on */ 86 kmutex_t discstrat_mutex; /* disc strategy */ 87 88 int run_thread; /* thread control */ 89 int cur_queue; 90 91 struct disk_strategy old_strategy_setting; 92 struct bufq_state *queues[UDF_SHED_MAX]; 93 struct timespec last_queued[UDF_SHED_MAX]; 94 }; 95 96 97 /* --------------------------------------------------------------------- */ 98 99 static void 100 udf_wr_nodedscr_callback(struct buf *buf) 101 { 102 struct udf_node *udf_node; 103 104 KASSERT(buf); 105 KASSERT(buf->b_data); 106 107 /* called when write action is done */ 108 DPRINTF(WRITE, ("udf_wr_nodedscr_callback(): node written out\n")); 109 110 udf_node = VTOI(buf->b_vp); 111 if (udf_node == NULL) { 112 putiobuf(buf); 113 printf("udf_wr_node_callback: NULL node?\n"); 114 return; 115 } 116 117 /* XXX right flags to mark dirty again on error? */ 118 if (buf->b_error) { 119 udf_node->i_flags |= IN_MODIFIED | IN_ACCESSED; 120 /* XXX TODO reshedule on error */ 121 } 122 123 /* decrement outstanding_nodedscr */ 124 KASSERT(udf_node->outstanding_nodedscr >= 1); 125 udf_node->outstanding_nodedscr--; 126 if (udf_node->outstanding_nodedscr == 0) { 127 /* first unlock the node */ 128 UDF_UNLOCK_NODE(udf_node, 0); 129 wakeup(&udf_node->outstanding_nodedscr); 130 } 131 132 /* unreference the vnode so it can be recycled */ 133 holdrele(udf_node->vnode); 134 135 putiobuf(buf); 136 } 137 138 /* --------------------------------------------------------------------- */ 139 140 static int 141 udf_create_logvol_dscr_seq(struct udf_strat_args *args) 142 { 143 union dscrptr **dscrptr = &args->dscr; 144 struct udf_mount *ump = args->ump; 145 struct strat_private *priv = PRIV(ump); 146 uint32_t lb_size; 147 148 lb_size = udf_rw32(ump->logical_vol->lb_size); 149 *dscrptr = pool_get(&priv->desc_pool, PR_WAITOK); 150 memset(*dscrptr, 0, lb_size); 151 152 return 0; 153 } 154 155 156 static void 157 udf_free_logvol_dscr_seq(struct udf_strat_args *args) 158 { 159 union dscrptr *dscr = args->dscr; 160 struct udf_mount *ump = args->ump; 161 struct strat_private *priv = PRIV(ump); 162 163 pool_put(&priv->desc_pool, dscr); 164 } 165 166 167 static int 168 udf_read_logvol_dscr_seq(struct udf_strat_args *args) 169 { 170 union dscrptr **dscrptr = &args->dscr; 171 union dscrptr *tmpdscr; 172 struct udf_mount *ump = args->ump; 173 struct long_ad *icb = args->icb; 174 struct strat_private *priv = PRIV(ump); 175 uint32_t lb_size; 176 uint32_t sector, dummy; 177 int error; 178 179 lb_size = udf_rw32(ump->logical_vol->lb_size); 180 181 error = udf_translate_vtop(ump, icb, §or, &dummy); 182 if (error) 183 return error; 184 185 /* try to read in fe/efe */ 186 error = udf_read_phys_dscr(ump, sector, M_UDFTEMP, &tmpdscr); 187 if (error) 188 return error; 189 190 *dscrptr = pool_get(&priv->desc_pool, PR_WAITOK); 191 memcpy(*dscrptr, tmpdscr, lb_size); 192 free(tmpdscr, M_UDFTEMP); 193 194 return 0; 195 } 196 197 198 static int 199 udf_write_logvol_dscr_seq(struct udf_strat_args *args) 200 { 201 union dscrptr *dscr = args->dscr; 202 struct udf_mount *ump = args->ump; 203 struct udf_node *udf_node = args->udf_node; 204 struct long_ad *icb = args->icb; 205 int waitfor = args->waitfor; 206 uint32_t logsectornr, sectornr, dummy; 207 int error, vpart; 208 209 /* 210 * we have to decide if we write it out sequential or at its fixed 211 * position by examining the partition its (to be) written on. 212 */ 213 vpart = udf_rw16(udf_node->loc.loc.part_num); 214 logsectornr = udf_rw32(icb->loc.lb_num); 215 sectornr = 0; 216 if (ump->vtop_tp[vpart] != UDF_VTOP_TYPE_VIRT) { 217 error = udf_translate_vtop(ump, icb, §ornr, &dummy); 218 if (error) 219 goto out; 220 } 221 222 /* add reference to the vnode to prevent recycling */ 223 vhold(udf_node->vnode); 224 225 if (waitfor) { 226 DPRINTF(WRITE, ("udf_write_logvol_dscr: sync write\n")); 227 228 error = udf_write_phys_dscr_sync(ump, udf_node, UDF_C_NODE, 229 dscr, sectornr, logsectornr); 230 } else { 231 DPRINTF(WRITE, ("udf_write_logvol_dscr: no wait, async write\n")); 232 233 error = udf_write_phys_dscr_async(ump, udf_node, UDF_C_NODE, 234 dscr, sectornr, logsectornr, udf_wr_nodedscr_callback); 235 /* will be UNLOCKED in call back */ 236 return error; 237 } 238 239 holdrele(udf_node->vnode); 240 out: 241 udf_node->outstanding_nodedscr--; 242 if (udf_node->outstanding_nodedscr == 0) { 243 UDF_UNLOCK_NODE(udf_node, 0); 244 wakeup(&udf_node->outstanding_nodedscr); 245 } 246 247 return error; 248 } 249 250 /* --------------------------------------------------------------------- */ 251 252 /* 253 * Main file-system specific sheduler. Due to the nature of optical media 254 * sheduling can't be performed in the traditional way. Most OS 255 * implementations i've seen thus read or write a file atomically giving all 256 * kinds of side effects. 257 * 258 * This implementation uses a kernel thread to shedule the queued requests in 259 * such a way that is semi-optimal for optical media; this means aproximately 260 * (R*|(Wr*|Ws*))* since switching between reading and writing is expensive in 261 * time. 262 */ 263 264 static void 265 udf_queuebuf_seq(struct udf_strat_args *args) 266 { 267 struct udf_mount *ump = args->ump; 268 struct buf *nestbuf = args->nestbuf; 269 struct strat_private *priv = PRIV(ump); 270 int queue; 271 int what; 272 273 KASSERT(ump); 274 KASSERT(nestbuf); 275 KASSERT(nestbuf->b_iodone == nestiobuf_iodone); 276 277 what = nestbuf->b_udf_c_type; 278 queue = UDF_SHED_READING; 279 if ((nestbuf->b_flags & B_READ) == 0) { 280 /* writing */ 281 queue = UDF_SHED_SEQWRITING; 282 if (what == UDF_C_ABSOLUTE) 283 queue = UDF_SHED_WRITING; 284 } 285 286 /* use our own sheduler lists for more complex sheduling */ 287 mutex_enter(&priv->discstrat_mutex); 288 bufq_put(priv->queues[queue], nestbuf); 289 vfs_timestamp(&priv->last_queued[queue]); 290 mutex_exit(&priv->discstrat_mutex); 291 292 /* signal our thread that there might be something to do */ 293 cv_signal(&priv->discstrat_cv); 294 } 295 296 /* --------------------------------------------------------------------- */ 297 298 /* TODO convert to lb_size */ 299 static void 300 udf_VAT_mapping_update(struct udf_mount *ump, struct buf *buf, uint32_t lb_map) 301 { 302 union dscrptr *fdscr = (union dscrptr *) buf->b_data; 303 struct vnode *vp = buf->b_vp; 304 struct udf_node *udf_node = VTOI(vp); 305 uint32_t lb_size, blks; 306 uint32_t lb_num; 307 uint32_t udf_rw32_lbmap; 308 int c_type = buf->b_udf_c_type; 309 int error; 310 311 /* only interested when we're using a VAT */ 312 KASSERT(ump->vat_node); 313 KASSERT(ump->vtop_alloc[ump->node_part] == UDF_ALLOC_VAT); 314 315 /* only nodes are recorded in the VAT */ 316 /* NOTE: and the fileset descriptor (FIXME ?) */ 317 if (c_type != UDF_C_NODE) 318 return; 319 320 /* we now have an UDF FE/EFE node on media with VAT (or VAT itself) */ 321 lb_size = udf_rw32(ump->logical_vol->lb_size); 322 blks = lb_size / DEV_BSIZE; 323 324 udf_rw32_lbmap = udf_rw32(lb_map); 325 326 /* if we're the VAT itself, only update our assigned sector number */ 327 if (udf_node == ump->vat_node) { 328 fdscr->tag.tag_loc = udf_rw32_lbmap; 329 udf_validate_tag_sum(fdscr); 330 DPRINTF(TRANSLATE, ("VAT assigned to sector %u\n", 331 udf_rw32(udf_rw32_lbmap))); 332 /* no use mapping the VAT node in the VAT */ 333 return; 334 } 335 336 /* record new position in VAT file */ 337 lb_num = udf_rw32(fdscr->tag.tag_loc); 338 339 /* lb_num = udf_rw32(udf_node->write_loc.loc.lb_num); */ 340 341 DPRINTF(TRANSLATE, ("VAT entry change (log %u -> phys %u)\n", 342 lb_num, lb_map)); 343 344 /* VAT should be the longer than this write, can't go wrong */ 345 KASSERT(lb_num <= ump->vat_entries); 346 347 mutex_enter(&ump->allocate_mutex); 348 error = udf_vat_write(ump->vat_node, 349 (uint8_t *) &udf_rw32_lbmap, 4, 350 ump->vat_offset + lb_num * 4); 351 mutex_exit(&ump->allocate_mutex); 352 353 if (error) 354 panic( "udf_VAT_mapping_update: HELP! i couldn't " 355 "write in the VAT file ?\n"); 356 } 357 358 359 static void 360 udf_issue_buf(struct udf_mount *ump, int queue, struct buf *buf) 361 { 362 union dscrptr *dscr; 363 struct long_ad *node_ad_cpy; 364 struct part_desc *pdesc; 365 uint64_t *lmapping, *lmappos, blknr; 366 uint32_t our_sectornr, sectornr, bpos; 367 uint32_t ptov; 368 uint16_t vpart_num; 369 uint8_t *fidblk; 370 int sector_size = ump->discinfo.sector_size; 371 int blks = sector_size / DEV_BSIZE; 372 int len, buf_len; 373 374 /* if reading, just pass to the device's STRATEGY */ 375 if (queue == UDF_SHED_READING) { 376 DPRINTF(SHEDULE, ("\nudf_issue_buf READ %p : sector %d type %d," 377 "b_resid %d, b_bcount %d, b_bufsize %d\n", 378 buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type, 379 buf->b_resid, buf->b_bcount, buf->b_bufsize)); 380 VOP_STRATEGY(ump->devvp, buf); 381 return; 382 } 383 384 blknr = buf->b_blkno; 385 our_sectornr = blknr / blks; 386 387 if (queue == UDF_SHED_WRITING) { 388 DPRINTF(SHEDULE, ("\nudf_issue_buf WRITE %p : sector %d " 389 "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n", 390 buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type, 391 buf->b_resid, buf->b_bcount, buf->b_bufsize)); 392 KASSERT(buf->b_udf_c_type == UDF_C_ABSOLUTE); 393 394 // udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type); 395 VOP_STRATEGY(ump->devvp, buf); 396 return; 397 } 398 399 KASSERT(queue == UDF_SHED_SEQWRITING); 400 DPRINTF(SHEDULE, ("\nudf_issue_buf SEQWRITE %p : sector XXXX " 401 "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n", 402 buf, buf->b_udf_c_type, buf->b_resid, buf->b_bcount, 403 buf->b_bufsize)); 404 405 /* 406 * Buffers should not have been allocated to disc addresses yet on 407 * this queue. Note that a buffer can get multiple extents allocated. 408 * 409 * lmapping contains lb_num relative to base partition. 410 */ 411 lmapping = ump->la_lmapping; 412 node_ad_cpy = ump->la_node_ad_cpy; 413 414 /* logically allocate buf and map it in the file */ 415 udf_late_allocate_buf(ump, buf, lmapping, node_ad_cpy, &vpart_num); 416 417 /* 418 * NOTE We are using the knowledge here that sequential media will 419 * always be mapped linearly. Thus no use to explicitly translate the 420 * lmapping list. 421 */ 422 423 /* calculate offset from physical base partition */ 424 pdesc = ump->partitions[ump->vtop[vpart_num]]; 425 ptov = udf_rw32(pdesc->start_loc); 426 427 /* set buffers blkno to the physical block number */ 428 buf->b_blkno = (*lmapping + ptov) * blks; 429 430 /* fixate floating descriptors */ 431 if (buf->b_udf_c_type == UDF_C_FLOAT_DSCR) { 432 /* set our tag location to the absolute position */ 433 dscr = (union dscrptr *) buf->b_data; 434 dscr->tag.tag_loc = udf_rw32(*lmapping + ptov); 435 udf_validate_tag_and_crc_sums(dscr); 436 } 437 438 /* update mapping in the VAT */ 439 if (buf->b_udf_c_type == UDF_C_NODE) { 440 udf_VAT_mapping_update(ump, buf, *lmapping); 441 udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type); 442 } 443 444 /* if we have FIDs, fixup using the new allocation table */ 445 if (buf->b_udf_c_type == UDF_C_FIDS) { 446 buf_len = buf->b_bcount; 447 bpos = 0; 448 lmappos = lmapping; 449 while (buf_len) { 450 sectornr = *lmappos++; 451 len = MIN(buf_len, sector_size); 452 fidblk = (uint8_t *) buf->b_data + bpos; 453 udf_fixup_fid_block(fidblk, sector_size, 454 0, len, sectornr); 455 bpos += len; 456 buf_len -= len; 457 } 458 } 459 460 VOP_STRATEGY(ump->devvp, buf); 461 } 462 463 464 static void 465 udf_doshedule(struct udf_mount *ump) 466 { 467 struct buf *buf; 468 struct timespec now, *last; 469 struct strat_private *priv = PRIV(ump); 470 void (*b_callback)(struct buf *); 471 int new_queue; 472 int error; 473 474 buf = bufq_get(priv->queues[priv->cur_queue]); 475 if (buf) { 476 /* transfer from the current queue to the device queue */ 477 mutex_exit(&priv->discstrat_mutex); 478 479 /* transform buffer to synchronous; XXX needed? */ 480 b_callback = buf->b_iodone; 481 buf->b_iodone = NULL; 482 CLR(buf->b_flags, B_ASYNC); 483 484 /* issue and wait on completion */ 485 udf_issue_buf(ump, priv->cur_queue, buf); 486 biowait(buf); 487 488 mutex_enter(&priv->discstrat_mutex); 489 490 /* if there is an error, repair this error, otherwise propagate */ 491 if (buf->b_error && ((buf->b_flags & B_READ) == 0)) { 492 /* check what we need to do */ 493 panic("UDF write error, can't handle yet!\n"); 494 } 495 496 /* propagate result to higher layers */ 497 if (b_callback) { 498 buf->b_iodone = b_callback; 499 (*buf->b_iodone)(buf); 500 } 501 502 return; 503 } 504 505 /* Check if we're idling in this state */ 506 vfs_timestamp(&now); 507 last = &priv->last_queued[priv->cur_queue]; 508 if (ump->discinfo.mmc_class == MMC_CLASS_CD) { 509 /* dont switch too fast for CD media; its expensive in time */ 510 if (now.tv_sec - last->tv_sec < 3) 511 return; 512 } 513 514 /* check if we can/should switch */ 515 new_queue = priv->cur_queue; 516 517 if (bufq_peek(priv->queues[UDF_SHED_READING])) 518 new_queue = UDF_SHED_READING; 519 if (bufq_peek(priv->queues[UDF_SHED_WRITING])) /* only for unmount */ 520 new_queue = UDF_SHED_WRITING; 521 if (bufq_peek(priv->queues[UDF_SHED_SEQWRITING])) 522 new_queue = UDF_SHED_SEQWRITING; 523 if (priv->cur_queue == UDF_SHED_READING) { 524 if (new_queue == UDF_SHED_SEQWRITING) { 525 /* TODO use flag to signal if this is needed */ 526 mutex_exit(&priv->discstrat_mutex); 527 528 /* update trackinfo for data and metadata */ 529 error = udf_update_trackinfo(ump, 530 &ump->data_track); 531 assert(error == 0); 532 error = udf_update_trackinfo(ump, 533 &ump->metadata_track); 534 assert(error == 0); 535 mutex_enter(&priv->discstrat_mutex); 536 } 537 } 538 539 if (new_queue != priv->cur_queue) { 540 DPRINTF(SHEDULE, ("switching from %d to %d\n", 541 priv->cur_queue, new_queue)); 542 } 543 544 priv->cur_queue = new_queue; 545 } 546 547 548 static void 549 udf_discstrat_thread(void *arg) 550 { 551 struct udf_mount *ump = (struct udf_mount *) arg; 552 struct strat_private *priv = PRIV(ump); 553 int empty; 554 555 empty = 1; 556 mutex_enter(&priv->discstrat_mutex); 557 while (priv->run_thread || !empty) { 558 /* process the current selected queue */ 559 udf_doshedule(ump); 560 empty = (bufq_peek(priv->queues[UDF_SHED_READING]) == NULL); 561 empty &= (bufq_peek(priv->queues[UDF_SHED_WRITING]) == NULL); 562 empty &= (bufq_peek(priv->queues[UDF_SHED_SEQWRITING]) == NULL); 563 564 /* wait for more if needed */ 565 if (empty) 566 cv_timedwait(&priv->discstrat_cv, 567 &priv->discstrat_mutex, hz/8); 568 } 569 mutex_exit(&priv->discstrat_mutex); 570 571 wakeup(&priv->run_thread); 572 kthread_exit(0); 573 /* not reached */ 574 } 575 576 /* --------------------------------------------------------------------- */ 577 578 static void 579 udf_discstrat_init_seq(struct udf_strat_args *args) 580 { 581 struct udf_mount *ump = args->ump; 582 struct strat_private *priv = PRIV(ump); 583 struct disk_strategy dkstrat; 584 uint32_t lb_size; 585 586 KASSERT(ump); 587 KASSERT(ump->logical_vol); 588 KASSERT(priv == NULL); 589 590 lb_size = udf_rw32(ump->logical_vol->lb_size); 591 KASSERT(lb_size > 0); 592 593 /* initialise our memory space */ 594 ump->strategy_private = malloc(sizeof(struct strat_private), 595 M_UDFTEMP, M_WAITOK); 596 priv = ump->strategy_private; 597 memset(priv, 0 , sizeof(struct strat_private)); 598 599 /* initialise locks */ 600 cv_init(&priv->discstrat_cv, "udfstrat"); 601 mutex_init(&priv->discstrat_mutex, MUTEX_DEFAULT, IPL_NONE); 602 603 /* 604 * Initialise pool for descriptors associated with nodes. This is done 605 * in lb_size units though currently lb_size is dictated to be 606 * sector_size. 607 */ 608 pool_init(&priv->desc_pool, lb_size, 0, 0, 0, "udf_desc_pool", NULL, 609 IPL_NONE); 610 611 /* 612 * remember old device strategy method and explicit set method 613 * `discsort' since we have our own more complex strategy that is not 614 * implementable on the CD device and other strategies will get in the 615 * way. 616 */ 617 memset(&priv->old_strategy_setting, 0, 618 sizeof(struct disk_strategy)); 619 VOP_IOCTL(ump->devvp, DIOCGSTRATEGY, &priv->old_strategy_setting, 620 FREAD | FKIOCTL, NOCRED); 621 memset(&dkstrat, 0, sizeof(struct disk_strategy)); 622 strcpy(dkstrat.dks_name, "discsort"); 623 VOP_IOCTL(ump->devvp, DIOCSSTRATEGY, &dkstrat, FWRITE | FKIOCTL, 624 NOCRED); 625 626 /* initialise our internal sheduler */ 627 priv->cur_queue = UDF_SHED_READING; 628 bufq_alloc(&priv->queues[UDF_SHED_READING], "disksort", 629 BUFQ_SORT_RAWBLOCK); 630 bufq_alloc(&priv->queues[UDF_SHED_WRITING], "disksort", 631 BUFQ_SORT_RAWBLOCK); 632 bufq_alloc(&priv->queues[UDF_SHED_SEQWRITING], "fcfs", 0); 633 vfs_timestamp(&priv->last_queued[UDF_SHED_READING]); 634 vfs_timestamp(&priv->last_queued[UDF_SHED_WRITING]); 635 vfs_timestamp(&priv->last_queued[UDF_SHED_SEQWRITING]); 636 637 /* create our disk strategy thread */ 638 priv->run_thread = 1; 639 if (kthread_create(PRI_NONE, 0 /* KTHREAD_MPSAFE*/, NULL /* cpu_info*/, 640 udf_discstrat_thread, ump, &priv->queue_lwp, 641 "%s", "udf_rw")) { 642 panic("fork udf_rw"); 643 } 644 } 645 646 647 static void 648 udf_discstrat_finish_seq(struct udf_strat_args *args) 649 { 650 struct udf_mount *ump = args->ump; 651 struct strat_private *priv = PRIV(ump); 652 int error; 653 654 if (ump == NULL) 655 return; 656 657 /* stop our sheduling thread */ 658 KASSERT(priv->run_thread == 1); 659 priv->run_thread = 0; 660 wakeup(priv->queue_lwp); 661 do { 662 error = tsleep(&priv->run_thread, PRIBIO+1, 663 "udfshedfin", hz); 664 } while (error); 665 /* kthread should be finished now */ 666 667 /* set back old device strategy method */ 668 VOP_IOCTL(ump->devvp, DIOCSSTRATEGY, &priv->old_strategy_setting, 669 FWRITE, NOCRED); 670 671 /* destroy our pool */ 672 pool_destroy(&priv->desc_pool); 673 674 mutex_destroy(&priv->discstrat_mutex); 675 cv_destroy(&priv->discstrat_cv); 676 677 /* free our private space */ 678 free(ump->strategy_private, M_UDFTEMP); 679 ump->strategy_private = NULL; 680 } 681 682 /* --------------------------------------------------------------------- */ 683 684 struct udf_strategy udf_strat_sequential = 685 { 686 udf_create_logvol_dscr_seq, 687 udf_free_logvol_dscr_seq, 688 udf_read_logvol_dscr_seq, 689 udf_write_logvol_dscr_seq, 690 udf_queuebuf_seq, 691 udf_discstrat_init_seq, 692 udf_discstrat_finish_seq 693 }; 694 695 696