udf_strat_direct.c revision 1.1
1 /* $NetBSD: udf_strat_direct.c,v 1.1 2008/05/14 16:49:48 reinoud 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_direct.c,v 1.1 2008/05/14 16:49:48 reinoud 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 #if defined(_KERNEL_OPT) 66 #include "opt_udf.h" 67 #endif 68 69 #include "udf.h" 70 #include "udf_subr.h" 71 #include "udf_bswap.h" 72 73 74 #define VTOI(vnode) ((struct udf_node *) vnode->v_data) 75 #define PRIV(ump) ((struct strat_private *) ump->strategy_private) 76 77 /* --------------------------------------------------------------------- */ 78 79 /* BUFQ's */ 80 #define UDF_SHED_MAX 3 81 82 #define UDF_SHED_READING 0 83 #define UDF_SHED_WRITING 1 84 #define UDF_SHED_SEQWRITING 2 85 86 87 struct strat_private { 88 struct pool desc_pool; /* node descriptors */ 89 }; 90 91 /* --------------------------------------------------------------------- */ 92 93 static void 94 udf_wr_nodedscr_callback(struct buf *buf) 95 { 96 struct udf_node *udf_node; 97 98 KASSERT(buf); 99 KASSERT(buf->b_data); 100 101 /* called when write action is done */ 102 DPRINTF(WRITE, ("udf_wr_nodedscr_callback(): node written out\n")); 103 104 udf_node = VTOI(buf->b_vp); 105 if (udf_node == NULL) { 106 putiobuf(buf); 107 printf("udf_wr_node_callback: NULL node?\n"); 108 return; 109 } 110 111 /* XXX noone is waiting on this outstanding_nodedscr */ 112 udf_node->outstanding_nodedscr--; 113 if (udf_node->outstanding_nodedscr == 0) 114 wakeup(&udf_node->outstanding_nodedscr); 115 116 /* XXX right flags to mark dirty again on error? */ 117 if (buf->b_error) { 118 /* write error on `defect free' media??? how to solve? */ 119 /* XXX lookup UDF standard for unallocatable space */ 120 udf_node->i_flags |= IN_MODIFIED | IN_ACCESSED; 121 } 122 123 /* first unlock the node */ 124 KASSERT(udf_node->i_flags & IN_CALLBACK_ULK); 125 UDF_UNLOCK_NODE(udf_node, IN_CALLBACK_ULK); 126 127 /* unreference the vnode so it can be recycled */ 128 holdrele(udf_node->vnode); 129 130 putiobuf(buf); 131 } 132 133 /* --------------------------------------------------------------------- */ 134 135 static int 136 udf_getblank_nodedscr_direct(struct udf_strat_args *args) 137 { 138 union dscrptr **dscrptr = &args->dscr; 139 struct udf_mount *ump = args->ump; 140 struct strat_private *priv = PRIV(ump); 141 uint32_t lb_size; 142 143 lb_size = udf_rw32(ump->logical_vol->lb_size); 144 *dscrptr = pool_get(&priv->desc_pool, PR_WAITOK); 145 memset(*dscrptr, 0, lb_size); 146 147 return 0; 148 } 149 150 151 static void 152 udf_free_nodedscr_direct(struct udf_strat_args *args) 153 { 154 union dscrptr *dscr = args->dscr; 155 struct udf_mount *ump = args->ump; 156 struct strat_private *priv = PRIV(ump); 157 158 pool_put(&priv->desc_pool, dscr); 159 } 160 161 162 static int 163 udf_read_nodedscr_direct(struct udf_strat_args *args) 164 { 165 union dscrptr **dscrptr = &args->dscr; 166 union dscrptr *tmpdscr; 167 struct udf_mount *ump = args->ump; 168 struct long_ad *icb = args->icb; 169 struct strat_private *priv = PRIV(ump); 170 uint32_t lb_size; 171 uint32_t sector, dummy; 172 int error; 173 174 lb_size = udf_rw32(ump->logical_vol->lb_size); 175 176 error = udf_translate_vtop(ump, icb, §or, &dummy); 177 if (error) 178 return error; 179 180 /* try to read in fe/efe */ 181 error = udf_read_phys_dscr(ump, sector, M_UDFTEMP, &tmpdscr); 182 if (error) 183 return error; 184 185 *dscrptr = pool_get(&priv->desc_pool, PR_WAITOK); 186 memcpy(*dscrptr, tmpdscr, lb_size); 187 free(tmpdscr, M_UDFTEMP); 188 189 return 0; 190 } 191 192 193 static int 194 udf_write_nodedscr_direct(struct udf_strat_args *args) 195 { 196 struct udf_mount *ump = args->ump; 197 struct udf_node *udf_node = args->udf_node; 198 union dscrptr *dscr = args->dscr; 199 struct long_ad *icb = args->icb; 200 int waitfor = args->waitfor; 201 uint32_t logsector, sector, dummy; 202 int error, vpart; 203 204 /* 205 * we have to decide if we write it out sequential or at its fixed 206 * position by examining the partition its (to be) written on. 207 */ 208 vpart = udf_rw16(udf_node->loc.loc.part_num); 209 logsector = udf_rw32(icb->loc.lb_num); 210 KASSERT(ump->vtop_tp[vpart] != UDF_VTOP_TYPE_VIRT); 211 212 sector = 0; 213 error = udf_translate_vtop(ump, icb, §or, &dummy); 214 if (error) 215 return error; 216 217 UDF_LOCK_NODE(udf_node, IN_CALLBACK_ULK); 218 219 if (waitfor) { 220 DPRINTF(WRITE, ("udf_write_nodedscr: sync write\n")); 221 222 error = udf_write_phys_dscr_sync(ump, udf_node, UDF_C_NODE, 223 dscr, sector, logsector); 224 UDF_UNLOCK_NODE(udf_node, IN_CALLBACK_ULK); 225 } else { 226 DPRINTF(WRITE, ("udf_write_nodedscr: no wait, async write\n")); 227 228 /* add reference to the vnode to prevent recycling */ 229 vhold(udf_node->vnode); 230 231 udf_node->outstanding_nodedscr++; 232 233 error = udf_write_phys_dscr_async(ump, udf_node, UDF_C_NODE, 234 dscr, sector, logsector, udf_wr_nodedscr_callback); 235 /* will be UNLOCKED in call back */ 236 } 237 return error; 238 } 239 240 /* --------------------------------------------------------------------- */ 241 242 static void 243 udf_queue_buf_direct(struct udf_strat_args *args) 244 { 245 struct udf_mount *ump = args->ump; 246 struct buf *buf = args->nestbuf; 247 struct buf *nestbuf; 248 struct long_ad *node_ad_cpy; 249 uint64_t *lmapping, *pmapping, *lmappos, blknr, run_start; 250 uint32_t our_sectornr, sectornr; 251 uint32_t lb_size, buf_offset, rbuflen, bpos; 252 uint8_t *fidblk; 253 off_t rblk; 254 int sector_size = ump->discinfo.sector_size; 255 int blks = sector_size / DEV_BSIZE; 256 int len, buf_len, sector, sectors, run_length; 257 int what, class, queue; 258 259 KASSERT(ump); 260 KASSERT(buf); 261 KASSERT(buf->b_iodone == nestiobuf_iodone); 262 263 what = buf->b_udf_c_type; 264 queue = UDF_SHED_READING; 265 if ((buf->b_flags & B_READ) == 0) { 266 /* writing */ 267 queue = UDF_SHED_SEQWRITING; 268 if (what == UDF_C_DSCR) 269 queue = UDF_SHED_WRITING; 270 if (what == UDF_C_NODE) 271 queue = UDF_SHED_WRITING; 272 } 273 274 /* use disc sheduler */ 275 class = ump->discinfo.mmc_class; 276 KASSERT((class == MMC_CLASS_UNKN) || (class == MMC_CLASS_DISC) || 277 (ump->discinfo.mmc_cur & MMC_CAP_HW_DEFECTFREE)); 278 279 if (queue == UDF_SHED_READING) { 280 DPRINTF(SHEDULE, ("\nudf_issue_buf READ %p : sector %d type %d," 281 "b_resid %d, b_bcount %d, b_bufsize %d\n", 282 buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type, 283 buf->b_resid, buf->b_bcount, buf->b_bufsize)); 284 VOP_STRATEGY(ump->devvp, buf); 285 return; 286 } 287 288 /* (sectorsize == lb_size) for UDF */ 289 lb_size = udf_rw32(ump->logical_vol->lb_size); 290 blknr = buf->b_blkno; 291 our_sectornr = blknr / blks; 292 293 if (queue == UDF_SHED_WRITING) { 294 DPRINTF(SHEDULE, ("\nudf_issue_buf WRITE %p : sector %d " 295 "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n", 296 buf, (uint32_t) buf->b_blkno / blks, buf->b_udf_c_type, 297 buf->b_resid, buf->b_bcount, buf->b_bufsize)); 298 /* if we have FIDs fixup using buffer's sector number(s) */ 299 if (buf->b_udf_c_type == UDF_C_FIDS) { 300 panic("UDF_C_FIDS in SHED_WRITING!\n"); 301 buf_len = buf->b_bcount; 302 sectornr = our_sectornr; 303 bpos = 0; 304 while (buf_len) { 305 len = MIN(buf_len, sector_size); 306 fidblk = (uint8_t *) buf->b_data + bpos; 307 udf_fixup_fid_block(fidblk, sector_size, 308 0, len, sectornr); 309 sectornr++; 310 bpos += len; 311 buf_len -= len; 312 } 313 } 314 udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type); 315 VOP_STRATEGY(ump->devvp, buf); 316 return; 317 } 318 319 /* UDF_SHED_SEQWRITING */ 320 KASSERT(queue == UDF_SHED_SEQWRITING); 321 DPRINTF(SHEDULE, ("\nudf_issue_buf SEQWRITE %p : sector XXXX " 322 "type %d, b_resid %d, b_bcount %d, b_bufsize %d\n", 323 buf, buf->b_udf_c_type, buf->b_resid, buf->b_bcount, 324 buf->b_bufsize)); 325 326 /* 327 * Buffers should not have been allocated to disc addresses yet on 328 * this queue. Note that a buffer can get multiple extents allocated. 329 * 330 * lmapping contains lb_num relative to base partition. 331 * pmapping contains lb_num as used for disc adressing. 332 */ 333 lmapping = ump->la_lmapping; 334 pmapping = ump->la_pmapping; 335 node_ad_cpy = ump->la_node_ad_cpy; 336 337 /* write physical blocknr in buf and get its mappings */ 338 udf_late_allocate_buf(ump, buf, lmapping, pmapping, node_ad_cpy); 339 340 /* if we have FIDs, fixup using the new allocation table */ 341 if (buf->b_udf_c_type == UDF_C_FIDS) { 342 buf_len = buf->b_bcount; 343 bpos = 0; 344 lmappos = lmapping; 345 while (buf_len) { 346 sectornr = *lmappos++; 347 len = MIN(buf_len, sector_size); 348 fidblk = (uint8_t *) buf->b_data + bpos; 349 udf_fixup_fid_block(fidblk, sector_size, 350 0, len, sectornr); 351 bpos += len; 352 buf_len -= len; 353 } 354 } 355 udf_fixup_node_internals(ump, buf->b_data, buf->b_udf_c_type); 356 357 /* speed up : try to conglomerate as many writes in one go */ 358 sectors = (buf->b_bcount + sector_size -1) / sector_size; 359 for (sector = 0; sector < sectors; sector++) { 360 buf_offset = sector * sector_size; 361 DPRINTF(WRITE, ("\tprocessing rel sector %d\n", sector)); 362 363 DPRINTF(WRITE, ("\tissue write sector %"PRIu64"\n", 364 pmapping[sector])); 365 366 run_start = pmapping[sector]; 367 run_length = 1; 368 while (sector < sectors-1) { 369 if (pmapping[sector+1] != pmapping[sector]+1) 370 break; 371 run_length++; 372 sector++; 373 } 374 375 /* nest an iobuf for the extent */ 376 rbuflen = run_length * sector_size; 377 rblk = run_start * (sector_size/DEV_BSIZE); 378 379 nestbuf = getiobuf(NULL, true); 380 nestiobuf_setup(buf, nestbuf, buf_offset, rbuflen); 381 /* nestbuf is B_ASYNC */ 382 383 /* identify this nestbuf */ 384 nestbuf->b_lblkno = sector; 385 assert(nestbuf->b_vp == buf->b_vp); 386 387 /* CD shedules on raw blkno */ 388 nestbuf->b_blkno = rblk; 389 nestbuf->b_proc = NULL; 390 nestbuf->b_rawblkno = rblk; 391 nestbuf->b_udf_c_type = UDF_C_PROCESSED; 392 393 VOP_STRATEGY(ump->devvp, nestbuf); 394 } 395 } 396 397 398 static void 399 udf_discstrat_init_direct(struct udf_strat_args *args) 400 { 401 struct udf_mount *ump = args->ump; 402 struct strat_private *priv = PRIV(ump); 403 uint32_t lb_size; 404 405 KASSERT(priv == NULL); 406 ump->strategy_private = malloc(sizeof(struct strat_private), 407 M_UDFTEMP, M_WAITOK); 408 priv = ump->strategy_private; 409 memset(priv, 0 , sizeof(struct strat_private)); 410 411 /* 412 * Initialise pool for descriptors associated with nodes. This is done 413 * in lb_size units though currently lb_size is dictated to be 414 * sector_size. 415 */ 416 memset(&priv->desc_pool, 0, sizeof(struct pool)); 417 418 lb_size = udf_rw32(ump->logical_vol->lb_size); 419 pool_init(&priv->desc_pool, lb_size, 0, 0, 0, "udf_desc_pool", NULL, 420 IPL_NONE); 421 } 422 423 424 static void 425 udf_discstrat_finish_direct(struct udf_strat_args *args) 426 { 427 struct udf_mount *ump = args->ump; 428 struct strat_private *priv = PRIV(ump); 429 430 /* destroy our pool */ 431 pool_destroy(&priv->desc_pool); 432 433 /* free our private space */ 434 free(ump->strategy_private, M_UDFTEMP); 435 ump->strategy_private = NULL; 436 } 437 438 /* --------------------------------------------------------------------- */ 439 440 struct udf_strategy udf_strat_direct = 441 { 442 udf_getblank_nodedscr_direct, 443 udf_free_nodedscr_direct, 444 udf_read_nodedscr_direct, 445 udf_write_nodedscr_direct, 446 udf_queue_buf_direct, 447 udf_discstrat_init_direct, 448 udf_discstrat_finish_direct 449 }; 450 451
Indexes created Tue Sep 23 22:09:46 GMT 2025