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