1 /* $NetBSD: udf_allocation.c,v 1.47 2022/05/22 11:27:36 andvar 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_allocation.c,v 1.47 2022/05/22 11:27:36 andvar Exp $");
32 #endif /* not lint */
33
34
35 #if defined(_KERNEL_OPT)
36 #include "opt_compat_netbsd.h"
37 #endif
38
39 /* TODO strip */
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
72 static void udf_record_allocation_in_node(struct udf_mount *ump,
73 struct buf *buf, uint16_t vpart_num, uint64_t *mapping,
74 struct long_ad *node_ad_cpy);
75
76 static void udf_collect_free_space_for_vpart(struct udf_mount *ump,
77 uint16_t vpart_num, uint32_t num_lb);
78
79 static int udf_ads_merge(uint32_t max_len, uint32_t lb_size, struct long_ad *a1, struct long_ad *a2);
80 static void udf_wipe_adslots(struct udf_node *udf_node);
81 static void udf_count_alloc_exts(struct udf_node *udf_node);
82
83
84 /* --------------------------------------------------------------------- */
85
86 #if 0
87 #if 1
88 static void
89 udf_node_dump(struct udf_node *udf_node) {
90 struct file_entry *fe;
91 struct extfile_entry *efe;
92 struct icb_tag *icbtag;
93 struct long_ad s_ad;
94 uint64_t inflen;
95 uint32_t icbflags, addr_type;
96 uint32_t len, lb_num;
97 uint32_t flags;
98 int part_num;
99 int lb_size, eof, slot;
100
101 if ((udf_verbose & UDF_DEBUG_NODEDUMP) == 0)
102 return;
103
104 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
105
106 fe = udf_node->fe;
107 efe = udf_node->efe;
108 if (fe) {
109 icbtag = &fe->icbtag;
110 inflen = udf_rw64(fe->inf_len);
111 } else {
112 icbtag = &efe->icbtag;
113 inflen = udf_rw64(efe->inf_len);
114 }
115
116 icbflags = udf_rw16(icbtag->flags);
117 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
118
119 printf("udf_node_dump %p :\n", udf_node);
120
121 if (addr_type == UDF_ICB_INTERN_ALLOC) {
122 printf("\tIntern alloc, len = %"PRIu64"\n", inflen);
123 return;
124 }
125
126 printf("\tInflen = %"PRIu64"\n", inflen);
127 printf("\t\t");
128
129 slot = 0;
130 for (;;) {
131 udf_get_adslot(udf_node, slot, &s_ad, &eof);
132 if (eof)
133 break;
134 part_num = udf_rw16(s_ad.loc.part_num);
135 lb_num = udf_rw32(s_ad.loc.lb_num);
136 len = udf_rw32(s_ad.len);
137 flags = UDF_EXT_FLAGS(len);
138 len = UDF_EXT_LEN(len);
139
140 printf("[");
141 if (part_num >= 0)
142 printf("part %d, ", part_num);
143 printf("lb_num %d, len %d", lb_num, len);
144 if (flags)
145 printf(", flags %d", flags>>30);
146 printf("] ");
147
148 if (flags == UDF_EXT_REDIRECT) {
149 printf("\n\textent END\n\tallocation extent\n\t\t");
150 }
151
152 slot++;
153 }
154 printf("\n\tl_ad END\n\n");
155 }
156 #else
157 #define udf_node_dump(a)
158 #endif
159
160
161 static void
162 udf_assert_allocated(struct udf_mount *ump, uint16_t vpart_num,
163 uint32_t lb_num, uint32_t num_lb)
164 {
165 struct udf_bitmap *bitmap;
166 struct part_desc *pdesc;
167 uint32_t ptov;
168 uint32_t bitval;
169 uint8_t *bpos;
170 int bit;
171 int phys_part;
172 int ok;
173
174 DPRINTF(PARANOIA, ("udf_assert_allocated: check virt lbnum %d "
175 "part %d + %d sect\n", lb_num, vpart_num, num_lb));
176
177 /* get partition backing up this vpart_num */
178 pdesc = ump->partitions[ump->vtop[vpart_num]];
179
180 switch (ump->vtop_tp[vpart_num]) {
181 case UDF_VTOP_TYPE_PHYS :
182 case UDF_VTOP_TYPE_SPARABLE :
183 /* free space to freed or unallocated space bitmap */
184 ptov = udf_rw32(pdesc->start_loc);
185 phys_part = ump->vtop[vpart_num];
186
187 /* use unallocated bitmap */
188 bitmap = &ump->part_unalloc_bits[phys_part];
189
190 /* if no bitmaps are defined, bail out */
191 if (bitmap->bits == NULL)
192 break;
193
194 /* check bits */
195 KASSERT(bitmap->bits);
196 ok = 1;
197 bpos = bitmap->bits + lb_num/8;
198 bit = lb_num % 8;
199 while (num_lb > 0) {
200 bitval = (1 << bit);
201 DPRINTF(PARANOIA, ("XXX : check %d, %p, bit %d\n",
202 lb_num, bpos, bit));
203 KASSERT(bitmap->bits + lb_num/8 == bpos);
204 if (*bpos & bitval) {
205 printf("\tlb_num %d is NOT marked busy\n",
206 lb_num);
207 ok = 0;
208 }
209 lb_num++; num_lb--;
210 bit = (bit + 1) % 8;
211 if (bit == 0)
212 bpos++;
213 }
214 if (!ok) {
215 /* KASSERT(0); */
216 }
217
218 break;
219 case UDF_VTOP_TYPE_VIRT :
220 /* TODO check space */
221 KASSERT(num_lb == 1);
222 break;
223 case UDF_VTOP_TYPE_META :
224 /* TODO check space in the metadata bitmap */
225 default:
226 /* not implemented */
227 break;
228 }
229 }
230
231
232 static void
233 udf_node_sanity_check(struct udf_node *udf_node,
234 uint64_t *cnt_inflen, uint64_t *cnt_logblksrec)
235 {
236 union dscrptr *dscr;
237 struct file_entry *fe;
238 struct extfile_entry *efe;
239 struct icb_tag *icbtag;
240 struct long_ad s_ad;
241 uint64_t inflen, logblksrec;
242 uint32_t icbflags, addr_type;
243 uint32_t len, lb_num, l_ea, l_ad, max_l_ad;
244 uint16_t part_num;
245 uint8_t *data_pos;
246 int dscr_size, lb_size, flags, whole_lb;
247 int i, slot, eof;
248
249 // KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
250
251 if (1)
252 udf_node_dump(udf_node);
253
254 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
255
256 fe = udf_node->fe;
257 efe = udf_node->efe;
258 if (fe) {
259 dscr = (union dscrptr *) fe;
260 icbtag = &fe->icbtag;
261 inflen = udf_rw64(fe->inf_len);
262 dscr_size = sizeof(struct file_entry) -1;
263 logblksrec = udf_rw64(fe->logblks_rec);
264 l_ad = udf_rw32(fe->l_ad);
265 l_ea = udf_rw32(fe->l_ea);
266 } else {
267 dscr = (union dscrptr *) efe;
268 icbtag = &efe->icbtag;
269 inflen = udf_rw64(efe->inf_len);
270 dscr_size = sizeof(struct extfile_entry) -1;
271 logblksrec = udf_rw64(efe->logblks_rec);
272 l_ad = udf_rw32(efe->l_ad);
273 l_ea = udf_rw32(efe->l_ea);
274 }
275 data_pos = (uint8_t *) dscr + dscr_size + l_ea;
276 max_l_ad = lb_size - dscr_size - l_ea;
277 icbflags = udf_rw16(icbtag->flags);
278 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
279
280 /* check if tail is zero */
281 DPRINTF(PARANOIA, ("Sanity check blank tail\n"));
282 for (i = l_ad; i < max_l_ad; i++) {
283 if (data_pos[i] != 0)
284 printf( "sanity_check: violation: node byte %d "
285 "has value %d\n", i, data_pos[i]);
286 }
287
288 /* reset counters */
289 *cnt_inflen = 0;
290 *cnt_logblksrec = 0;
291
292 if (addr_type == UDF_ICB_INTERN_ALLOC) {
293 KASSERT(l_ad <= max_l_ad);
294 KASSERT(l_ad == inflen);
295 *cnt_inflen = inflen;
296 return;
297 }
298
299 /* start counting */
300 whole_lb = 1;
301 slot = 0;
302 for (;;) {
303 udf_get_adslot(udf_node, slot, &s_ad, &eof);
304 if (eof)
305 break;
306 KASSERT(whole_lb == 1);
307
308 part_num = udf_rw16(s_ad.loc.part_num);
309 lb_num = udf_rw32(s_ad.loc.lb_num);
310 len = udf_rw32(s_ad.len);
311 flags = UDF_EXT_FLAGS(len);
312 len = UDF_EXT_LEN(len);
313
314 if (flags != UDF_EXT_REDIRECT) {
315 *cnt_inflen += len;
316 if (flags == UDF_EXT_ALLOCATED) {
317 *cnt_logblksrec += (len + lb_size -1) / lb_size;
318 }
319 } else {
320 KASSERT(len == lb_size);
321 }
322 /* check allocation */
323 if (flags == UDF_EXT_ALLOCATED)
324 udf_assert_allocated(udf_node->ump, part_num, lb_num,
325 (len + lb_size - 1) / lb_size);
326
327 /* check whole lb */
328 whole_lb = ((len % lb_size) == 0);
329
330 slot++;
331 }
332 /* rest should be zero (ad_off > l_ad < max_l_ad - adlen) */
333
334 KASSERT(*cnt_inflen == inflen);
335 KASSERT(*cnt_logblksrec == logblksrec);
336
337 // KASSERT(mutex_owned(&udf_node->ump->allocate_mutex));
338 }
339 #else
340 static void
udf_node_sanity_check(struct udf_node * udf_node,uint64_t * cnt_inflen,uint64_t * cnt_logblksrec)341 udf_node_sanity_check(struct udf_node *udf_node,
342 uint64_t *cnt_inflen, uint64_t *cnt_logblksrec) {
343 struct file_entry *fe;
344 struct extfile_entry *efe;
345 uint64_t inflen, logblksrec;
346
347 fe = udf_node->fe;
348 efe = udf_node->efe;
349 if (fe) {
350 inflen = udf_rw64(fe->inf_len);
351 logblksrec = udf_rw64(fe->logblks_rec);
352 } else {
353 inflen = udf_rw64(efe->inf_len);
354 logblksrec = udf_rw64(efe->logblks_rec);
355 }
356 *cnt_logblksrec = logblksrec;
357 *cnt_inflen = inflen;
358 }
359 #endif
360
361 /* --------------------------------------------------------------------- */
362
363 void
udf_calc_freespace(struct udf_mount * ump,uint64_t * sizeblks,uint64_t * freeblks)364 udf_calc_freespace(struct udf_mount *ump, uint64_t *sizeblks, uint64_t *freeblks)
365 {
366 struct logvol_int_desc *lvid;
367 uint32_t *pos1, *pos2;
368 int vpart, num_vpart;
369
370 lvid = ump->logvol_integrity;
371 *freeblks = *sizeblks = 0;
372
373 /*
374 * Sequential media reports free space directly (CD/DVD/BD-R), for the
375 * other media we need the logical volume integrity.
376 *
377 * We sum all free space up here regardless of type.
378 */
379
380 KASSERT(lvid);
381 num_vpart = udf_rw32(lvid->num_part);
382
383 if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
384 /* use track info directly summing if there are 2 open */
385 /* XXX assumption at most two tracks open */
386 *freeblks = ump->data_track.free_blocks;
387 if (ump->data_track.tracknr != ump->metadata_track.tracknr)
388 *freeblks += ump->metadata_track.free_blocks;
389 *sizeblks = ump->discinfo.last_possible_lba;
390 } else {
391 /* free and used space for mountpoint based on logvol integrity */
392 for (vpart = 0; vpart < num_vpart; vpart++) {
393 pos1 = &lvid->tables[0] + vpart;
394 pos2 = &lvid->tables[0] + num_vpart + vpart;
395 if (udf_rw32(*pos1) != (uint32_t) -1) {
396 *freeblks += udf_rw32(*pos1);
397 *sizeblks += udf_rw32(*pos2);
398 }
399 }
400 }
401 /* adjust for accounted uncommitted blocks */
402 for (vpart = 0; vpart < num_vpart; vpart++)
403 *freeblks -= ump->uncommitted_lbs[vpart];
404
405 if (*freeblks > UDF_DISC_SLACK) {
406 *freeblks -= UDF_DISC_SLACK;
407 } else {
408 *freeblks = 0;
409 }
410 }
411
412
413 static void
udf_calc_vpart_freespace(struct udf_mount * ump,uint16_t vpart_num,uint64_t * freeblks)414 udf_calc_vpart_freespace(struct udf_mount *ump, uint16_t vpart_num, uint64_t *freeblks)
415 {
416 struct logvol_int_desc *lvid;
417 uint32_t *pos1;
418
419 lvid = ump->logvol_integrity;
420 *freeblks = 0;
421
422 /*
423 * Sequential media reports free space directly (CD/DVD/BD-R), for the
424 * other media we need the logical volume integrity.
425 *
426 * We sum all free space up here regardless of type.
427 */
428
429 KASSERT(lvid);
430 if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
431 /* XXX assumption at most two tracks open */
432 if (vpart_num == ump->data_part) {
433 *freeblks = ump->data_track.free_blocks;
434 } else {
435 *freeblks = ump->metadata_track.free_blocks;
436 }
437 } else {
438 /* free and used space for mountpoint based on logvol integrity */
439 pos1 = &lvid->tables[0] + vpart_num;
440 if (udf_rw32(*pos1) != (uint32_t) -1)
441 *freeblks += udf_rw32(*pos1);
442 }
443
444 /* adjust for accounted uncommitted blocks */
445 if (*freeblks > ump->uncommitted_lbs[vpart_num]) {
446 *freeblks -= ump->uncommitted_lbs[vpart_num];
447 } else {
448 *freeblks = 0;
449 }
450 }
451
452 /* --------------------------------------------------------------------- */
453
454 int
udf_translate_vtop(struct udf_mount * ump,struct long_ad * icb_loc,uint32_t * lb_numres,uint32_t * extres)455 udf_translate_vtop(struct udf_mount *ump, struct long_ad *icb_loc,
456 uint32_t *lb_numres, uint32_t *extres)
457 {
458 struct part_desc *pdesc;
459 struct spare_map_entry *sme;
460 struct long_ad s_icb_loc;
461 uint64_t foffset, end_foffset;
462 uint32_t lb_size, len;
463 uint32_t lb_num, lb_rel, lb_packet;
464 uint32_t udf_rw32_lbmap, ext_offset;
465 uint16_t vpart;
466 int rel, part, error, eof, slot, flags;
467
468 assert(ump && icb_loc && lb_numres);
469
470 vpart = udf_rw16(icb_loc->loc.part_num);
471 lb_num = udf_rw32(icb_loc->loc.lb_num);
472 if (vpart > UDF_VTOP_RAWPART)
473 return EINVAL;
474
475 translate_again:
476 part = ump->vtop[vpart];
477 pdesc = ump->partitions[part];
478
479 switch (ump->vtop_tp[vpart]) {
480 case UDF_VTOP_TYPE_RAW :
481 /* 1:1 to the end of the device */
482 *lb_numres = lb_num;
483 *extres = INT_MAX;
484 return 0;
485 case UDF_VTOP_TYPE_PHYS :
486 /* transform into its disc logical block */
487 if (lb_num > udf_rw32(pdesc->part_len))
488 return EINVAL;
489 *lb_numres = lb_num + udf_rw32(pdesc->start_loc);
490
491 /* extent from here to the end of the partition */
492 *extres = udf_rw32(pdesc->part_len) - lb_num;
493 return 0;
494 case UDF_VTOP_TYPE_VIRT :
495 /* only maps one logical block, lookup in VAT */
496 if (lb_num >= ump->vat_entries) /* XXX > or >= ? */
497 return EINVAL;
498
499 /* lookup in virtual allocation table file */
500 mutex_enter(&ump->allocate_mutex);
501 error = udf_vat_read(ump->vat_node,
502 (uint8_t *) &udf_rw32_lbmap, 4,
503 ump->vat_offset + lb_num * 4);
504 mutex_exit(&ump->allocate_mutex);
505
506 if (error)
507 return error;
508
509 lb_num = udf_rw32(udf_rw32_lbmap);
510
511 /* transform into its disc logical block */
512 if (lb_num > udf_rw32(pdesc->part_len))
513 return EINVAL;
514 *lb_numres = lb_num + udf_rw32(pdesc->start_loc);
515
516 /* just one logical block */
517 *extres = 1;
518 return 0;
519 case UDF_VTOP_TYPE_SPARABLE :
520 /* check if the packet containing the lb_num is remapped */
521 lb_packet = lb_num / ump->sparable_packet_size;
522 lb_rel = lb_num % ump->sparable_packet_size;
523
524 for (rel = 0; rel < udf_rw16(ump->sparing_table->rt_l); rel++) {
525 sme = &ump->sparing_table->entries[rel];
526 if (lb_packet == udf_rw32(sme->org)) {
527 /* NOTE maps to absolute disc logical block! */
528 *lb_numres = udf_rw32(sme->map) + lb_rel;
529 *extres = ump->sparable_packet_size - lb_rel;
530 return 0;
531 }
532 }
533
534 /* transform into its disc logical block */
535 if (lb_num > udf_rw32(pdesc->part_len))
536 return EINVAL;
537 *lb_numres = lb_num + udf_rw32(pdesc->start_loc);
538
539 /* rest of block */
540 *extres = ump->sparable_packet_size - lb_rel;
541 return 0;
542 case UDF_VTOP_TYPE_META :
543 /* we have to look into the file's allocation descriptors */
544
545 /* use metadatafile allocation mutex */
546 lb_size = udf_rw32(ump->logical_vol->lb_size);
547
548 UDF_LOCK_NODE(ump->metadata_node, 0);
549
550 /* get first overlapping extent */
551 foffset = 0;
552 slot = 0;
553 for (;;) {
554 udf_get_adslot(ump->metadata_node,
555 slot, &s_icb_loc, &eof);
556 DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, "
557 "len = %d, lb_num = %d, part = %d\n",
558 slot, eof,
559 UDF_EXT_FLAGS(udf_rw32(s_icb_loc.len)),
560 UDF_EXT_LEN(udf_rw32(s_icb_loc.len)),
561 udf_rw32(s_icb_loc.loc.lb_num),
562 udf_rw16(s_icb_loc.loc.part_num)));
563 if (eof) {
564 DPRINTF(TRANSLATE,
565 ("Meta partition translation "
566 "failed: can't seek location\n"));
567 UDF_UNLOCK_NODE(ump->metadata_node, 0);
568 return EINVAL;
569 }
570 len = udf_rw32(s_icb_loc.len);
571 flags = UDF_EXT_FLAGS(len);
572 len = UDF_EXT_LEN(len);
573
574 if (flags == UDF_EXT_REDIRECT) {
575 slot++;
576 continue;
577 }
578
579 end_foffset = foffset + len;
580
581 if (end_foffset > (uint64_t) lb_num * lb_size)
582 break; /* found */
583 foffset = end_foffset;
584 slot++;
585 }
586 /* found overlapping slot */
587 ext_offset = lb_num * lb_size - foffset;
588
589 /* process extent offset */
590 lb_num = udf_rw32(s_icb_loc.loc.lb_num);
591 vpart = udf_rw16(s_icb_loc.loc.part_num);
592 lb_num += (ext_offset + lb_size -1) / lb_size;
593 ext_offset = 0;
594
595 UDF_UNLOCK_NODE(ump->metadata_node, 0);
596 if (flags != UDF_EXT_ALLOCATED) {
597 DPRINTF(TRANSLATE, ("Metadata partition translation "
598 "failed: not allocated\n"));
599 return EINVAL;
600 }
601
602 /*
603 * vpart and lb_num are updated, translate again since we
604 * might be mapped on sparable media
605 */
606 goto translate_again;
607 default:
608 printf("UDF vtop translation scheme %d unimplemented yet\n",
609 ump->vtop_tp[vpart]);
610 }
611
612 return EINVAL;
613 }
614
615
616 /* XXX provisional primitive braindead version */
617 /* TODO use ext_res */
618 void
udf_translate_vtop_list(struct udf_mount * ump,uint32_t sectors,uint16_t vpart_num,uint64_t * lmapping,uint64_t * pmapping)619 udf_translate_vtop_list(struct udf_mount *ump, uint32_t sectors,
620 uint16_t vpart_num, uint64_t *lmapping, uint64_t *pmapping)
621 {
622 struct long_ad loc;
623 uint32_t lb_numres, ext_res;
624 int sector;
625
626 for (sector = 0; sector < sectors; sector++) {
627 memset(&loc, 0, sizeof(struct long_ad));
628 loc.loc.part_num = udf_rw16(vpart_num);
629 loc.loc.lb_num = udf_rw32(*lmapping);
630 udf_translate_vtop(ump, &loc, &lb_numres, &ext_res);
631 *pmapping = lb_numres;
632 lmapping++; pmapping++;
633 }
634 }
635
636
637 /* --------------------------------------------------------------------- */
638
639 /*
640 * Translate an extent (in logical_blocks) into logical block numbers; used
641 * for read and write operations. DOESN'T check extents.
642 */
643
644 int
udf_translate_file_extent(struct udf_node * udf_node,uint32_t from,uint32_t num_lb,uint64_t * map)645 udf_translate_file_extent(struct udf_node *udf_node,
646 uint32_t from, uint32_t num_lb,
647 uint64_t *map)
648 {
649 struct udf_mount *ump;
650 struct icb_tag *icbtag;
651 struct long_ad t_ad, s_ad;
652 uint64_t transsec;
653 uint64_t foffset, end_foffset;
654 uint32_t transsec32;
655 uint32_t lb_size;
656 uint32_t ext_offset;
657 uint32_t lb_num, len;
658 uint32_t overlap, translen;
659 uint16_t vpart_num;
660 int eof, error, flags;
661 int slot, addr_type, icbflags;
662
663 if (!udf_node)
664 return ENOENT;
665
666 KASSERT(num_lb > 0);
667
668 UDF_LOCK_NODE(udf_node, 0);
669
670 /* initialise derivative vars */
671 ump = udf_node->ump;
672 lb_size = udf_rw32(ump->logical_vol->lb_size);
673
674 if (udf_node->fe) {
675 icbtag = &udf_node->fe->icbtag;
676 } else {
677 icbtag = &udf_node->efe->icbtag;
678 }
679 icbflags = udf_rw16(icbtag->flags);
680 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
681
682 /* do the work */
683 if (addr_type == UDF_ICB_INTERN_ALLOC) {
684 *map = UDF_TRANS_INTERN;
685 UDF_UNLOCK_NODE(udf_node, 0);
686 return 0;
687 }
688
689 /* find first overlapping extent */
690 foffset = 0;
691 slot = 0;
692 for (;;) {
693 udf_get_adslot(udf_node, slot, &s_ad, &eof);
694 DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
695 "lb_num = %d, part = %d\n", slot, eof,
696 UDF_EXT_FLAGS(udf_rw32(s_ad.len)),
697 UDF_EXT_LEN(udf_rw32(s_ad.len)),
698 udf_rw32(s_ad.loc.lb_num),
699 udf_rw16(s_ad.loc.part_num)));
700 if (eof) {
701 DPRINTF(TRANSLATE,
702 ("Translate file extent "
703 "failed: can't seek location\n"));
704 UDF_UNLOCK_NODE(udf_node, 0);
705 return EINVAL;
706 }
707 len = udf_rw32(s_ad.len);
708 flags = UDF_EXT_FLAGS(len);
709 len = UDF_EXT_LEN(len);
710 lb_num = udf_rw32(s_ad.loc.lb_num);
711
712 if (flags == UDF_EXT_REDIRECT) {
713 slot++;
714 continue;
715 }
716
717 end_foffset = foffset + len;
718
719 if (end_foffset > (uint64_t) from * lb_size)
720 break; /* found */
721 foffset = end_foffset;
722 slot++;
723 }
724 /* found overlapping slot */
725 ext_offset = (uint64_t) from * lb_size - foffset;
726
727 for (;;) {
728 udf_get_adslot(udf_node, slot, &s_ad, &eof);
729 DPRINTF(ADWLK, ("slot %d, eof = %d, flags = %d, len = %d, "
730 "lb_num = %d, part = %d\n", slot, eof,
731 UDF_EXT_FLAGS(udf_rw32(s_ad.len)),
732 UDF_EXT_LEN(udf_rw32(s_ad.len)),
733 udf_rw32(s_ad.loc.lb_num),
734 udf_rw16(s_ad.loc.part_num)));
735 if (eof) {
736 DPRINTF(TRANSLATE,
737 ("Translate file extent "
738 "failed: past eof\n"));
739 UDF_UNLOCK_NODE(udf_node, 0);
740 return EINVAL;
741 }
742
743 len = udf_rw32(s_ad.len);
744 flags = UDF_EXT_FLAGS(len);
745 len = UDF_EXT_LEN(len);
746
747 lb_num = udf_rw32(s_ad.loc.lb_num);
748 vpart_num = udf_rw16(s_ad.loc.part_num);
749
750 end_foffset = foffset + len;
751
752 /* process extent, don't forget to advance on ext_offset! */
753 lb_num += (ext_offset + lb_size -1) / lb_size;
754 overlap = (len - ext_offset + lb_size -1) / lb_size;
755 ext_offset = 0;
756
757 /*
758 * note that the while(){} is necessary for the extent that
759 * the udf_translate_vtop() returns doesn't have to span the
760 * whole extent.
761 */
762
763 overlap = MIN(overlap, num_lb);
764 while (overlap && (flags != UDF_EXT_REDIRECT)) {
765 switch (flags) {
766 case UDF_EXT_FREE :
767 case UDF_EXT_ALLOCATED_BUT_NOT_USED :
768 transsec = UDF_TRANS_ZERO;
769 translen = overlap;
770 while (overlap && num_lb && translen) {
771 *map++ = transsec;
772 lb_num++;
773 overlap--; num_lb--; translen--;
774 }
775 break;
776 case UDF_EXT_ALLOCATED :
777 t_ad.loc.lb_num = udf_rw32(lb_num);
778 t_ad.loc.part_num = udf_rw16(vpart_num);
779 error = udf_translate_vtop(ump,
780 &t_ad, &transsec32, &translen);
781 transsec = transsec32;
782 if (error) {
783 UDF_UNLOCK_NODE(udf_node, 0);
784 return error;
785 }
786 while (overlap && num_lb && translen) {
787 *map++ = transsec;
788 lb_num++; transsec++;
789 overlap--; num_lb--; translen--;
790 }
791 break;
792 default:
793 DPRINTF(TRANSLATE,
794 ("Translate file extent "
795 "failed: bad flags %x\n", flags));
796 UDF_UNLOCK_NODE(udf_node, 0);
797 return EINVAL;
798 }
799 }
800 if (num_lb == 0)
801 break;
802
803 if (flags != UDF_EXT_REDIRECT)
804 foffset = end_foffset;
805 slot++;
806 }
807 UDF_UNLOCK_NODE(udf_node, 0);
808
809 return 0;
810 }
811
812 /* --------------------------------------------------------------------- */
813
814 static int
udf_search_free_vatloc(struct udf_mount * ump,uint32_t * lbnumres)815 udf_search_free_vatloc(struct udf_mount *ump, uint32_t *lbnumres)
816 {
817 uint32_t lb_size, lb_num, lb_map, udf_rw32_lbmap;
818 uint8_t *blob;
819 int entry, chunk, found, error;
820
821 KASSERT(ump);
822 KASSERT(ump->logical_vol);
823
824 lb_size = udf_rw32(ump->logical_vol->lb_size);
825 blob = malloc(lb_size, M_UDFTEMP, M_WAITOK);
826
827 /* TODO static allocation of search chunk */
828
829 lb_num = MIN(ump->vat_entries, ump->vat_last_free_lb);
830 found = 0;
831 error = 0;
832 entry = 0;
833 do {
834 chunk = MIN(lb_size, (ump->vat_entries - lb_num) * 4);
835 if (chunk <= 0)
836 break;
837 /* load in chunk */
838 error = udf_vat_read(ump->vat_node, blob, chunk,
839 ump->vat_offset + lb_num * 4);
840
841 if (error)
842 break;
843
844 /* search this chunk */
845 for (entry=0; entry < chunk /4; entry++, lb_num++) {
846 udf_rw32_lbmap = *((uint32_t *) (blob + entry * 4));
847 lb_map = udf_rw32(udf_rw32_lbmap);
848 if (lb_map == 0xffffffff) {
849 found = 1;
850 break;
851 }
852 }
853 } while (!found);
854 if (error) {
855 printf("udf_search_free_vatloc: error reading in vat chunk "
856 "(lb %d, size %d)\n", lb_num, chunk);
857 }
858
859 if (!found) {
860 /* extend VAT */
861 DPRINTF(WRITE, ("udf_search_free_vatloc: extending\n"));
862 lb_num = ump->vat_entries;
863 ump->vat_entries++;
864 }
865
866 /* mark entry with non free-space initialiser just in case */
867 lb_map = udf_rw32(0xfffffffe);
868 udf_vat_write(ump->vat_node, (uint8_t *) &lb_map, 4,
869 ump->vat_offset + lb_num *4);
870 ump->vat_last_free_lb = lb_num;
871
872 free(blob, M_UDFTEMP);
873 *lbnumres = lb_num;
874 return 0;
875 }
876
877
878 static void
udf_bitmap_allocate(struct udf_bitmap * bitmap,int ismetadata,uint32_t * num_lb,uint64_t * lmappos)879 udf_bitmap_allocate(struct udf_bitmap *bitmap, int ismetadata,
880 uint32_t *num_lb, uint64_t *lmappos)
881 {
882 uint32_t offset, lb_num, bit;
883 int32_t diff;
884 uint8_t *bpos;
885 int pass;
886
887 if (!ismetadata) {
888 /* heuristic to keep the two pointers not too close */
889 diff = bitmap->data_pos - bitmap->metadata_pos;
890 if ((diff >= 0) && (diff < 1024))
891 bitmap->data_pos = bitmap->metadata_pos + 1024;
892 }
893 offset = ismetadata ? bitmap->metadata_pos : bitmap->data_pos;
894 offset &= ~7;
895 for (pass = 0; pass < 2; pass++) {
896 if (offset >= bitmap->max_offset)
897 offset = 0;
898
899 while (offset < bitmap->max_offset) {
900 if (*num_lb == 0)
901 break;
902
903 /* use first bit not set */
904 bpos = bitmap->bits + offset/8;
905 bit = ffs(*bpos); /* returns 0 or 1..8 */
906 if (bit == 0) {
907 offset += 8;
908 continue;
909 }
910
911 /* check for ffs overshoot */
912 if (offset + bit-1 >= bitmap->max_offset) {
913 offset = bitmap->max_offset;
914 break;
915 }
916
917 DPRINTF(PARANOIA, ("XXX : allocate %d, %p, bit %d\n",
918 offset + bit -1, bpos, bit-1));
919 *bpos &= ~(1 << (bit-1));
920 lb_num = offset + bit-1;
921 *lmappos++ = lb_num;
922 *num_lb = *num_lb - 1;
923 // offset = (offset & ~7);
924 }
925 }
926
927 if (ismetadata) {
928 bitmap->metadata_pos = offset;
929 } else {
930 bitmap->data_pos = offset;
931 }
932 }
933
934
935 static void
udf_bitmap_free(struct udf_bitmap * bitmap,uint32_t lb_num,uint32_t num_lb)936 udf_bitmap_free(struct udf_bitmap *bitmap, uint32_t lb_num, uint32_t num_lb)
937 {
938 uint32_t offset;
939 uint32_t bit, bitval;
940 uint8_t *bpos;
941
942 offset = lb_num;
943
944 /* starter bits */
945 bpos = bitmap->bits + offset/8;
946 bit = offset % 8;
947 while ((bit != 0) && (num_lb > 0)) {
948 bitval = (1 << bit);
949 KASSERT((*bpos & bitval) == 0);
950 DPRINTF(PARANOIA, ("XXX : free %d, %p, %d\n",
951 offset, bpos, bit));
952 *bpos |= bitval;
953 offset++; num_lb--;
954 bit = (bit + 1) % 8;
955 }
956 if (num_lb == 0)
957 return;
958
959 /* whole bytes */
960 KASSERT(bit == 0);
961 bpos = bitmap->bits + offset / 8;
962 while (num_lb >= 8) {
963 KASSERT((*bpos == 0));
964 DPRINTF(PARANOIA, ("XXX : free %d + 8, %p\n", offset, bpos));
965 *bpos = 255;
966 offset += 8; num_lb -= 8;
967 bpos++;
968 }
969
970 /* stop bits */
971 KASSERT(num_lb < 8);
972 bit = 0;
973 while (num_lb > 0) {
974 bitval = (1 << bit);
975 KASSERT((*bpos & bitval) == 0);
976 DPRINTF(PARANOIA, ("XXX : free %d, %p, %d\n",
977 offset, bpos, bit));
978 *bpos |= bitval;
979 offset++; num_lb--;
980 bit = (bit + 1) % 8;
981 }
982 }
983
984
985 static uint32_t
udf_bitmap_check_trunc_free(struct udf_bitmap * bitmap,uint32_t to_trunc)986 udf_bitmap_check_trunc_free(struct udf_bitmap *bitmap, uint32_t to_trunc)
987 {
988 uint32_t seq_free, offset;
989 uint8_t *bpos;
990 uint8_t bit, bitval;
991
992 DPRINTF(RESERVE, ("\ttrying to trunc %d bits from bitmap\n", to_trunc));
993 offset = bitmap->max_offset - to_trunc;
994
995 /* starter bits (if any) */
996 bpos = bitmap->bits + offset/8;
997 bit = offset % 8;
998 seq_free = 0;
999 while (to_trunc > 0) {
1000 seq_free++;
1001 bitval = (1 << bit);
1002 if (!(*bpos & bitval))
1003 seq_free = 0;
1004 to_trunc--;
1005 bit++;
1006 if (bit == 8) {
1007 bpos++;
1008 bit = 0;
1009 }
1010 }
1011
1012 DPRINTF(RESERVE, ("\tfound %d sequential free bits in bitmap\n", seq_free));
1013 return seq_free;
1014 }
1015
1016 /* --------------------------------------------------------------------- */
1017
1018 /*
1019 * We check for overall disc space with a margin to prevent critical
1020 * conditions. If disc space is low we try to force a sync() to improve our
1021 * estimates. When confronted with meta-data partition size shortage we know
1022 * we have to check if it can be extended and we need to extend it when
1023 * needed.
1024 *
1025 * A 2nd strategy we could use when disc space is getting low on a disc
1026 * formatted with a meta-data partition is to see if there are sparse areas in
1027 * the meta-data partition and free blocks there for extra data.
1028 */
1029
1030 void
udf_do_reserve_space(struct udf_mount * ump,struct udf_node * udf_node,uint16_t vpart_num,uint32_t num_lb)1031 udf_do_reserve_space(struct udf_mount *ump, struct udf_node *udf_node,
1032 uint16_t vpart_num, uint32_t num_lb)
1033 {
1034 ump->uncommitted_lbs[vpart_num] += num_lb;
1035 if (udf_node)
1036 udf_node->uncommitted_lbs += num_lb;
1037 }
1038
1039
1040 void
udf_do_unreserve_space(struct udf_mount * ump,struct udf_node * udf_node,uint16_t vpart_num,uint32_t num_lb)1041 udf_do_unreserve_space(struct udf_mount *ump, struct udf_node *udf_node,
1042 uint16_t vpart_num, uint32_t num_lb)
1043 {
1044 ump->uncommitted_lbs[vpart_num] -= num_lb;
1045 if (ump->uncommitted_lbs[vpart_num] < 0) {
1046 DPRINTF(RESERVE, ("UDF: underflow on partition reservation, "
1047 "part %d: %d\n", vpart_num,
1048 ump->uncommitted_lbs[vpart_num]));
1049 ump->uncommitted_lbs[vpart_num] = 0;
1050 }
1051 if (udf_node) {
1052 udf_node->uncommitted_lbs -= num_lb;
1053 if (udf_node->uncommitted_lbs < 0) {
1054 DPRINTF(RESERVE, ("UDF: underflow of node "
1055 "reservation : %d\n",
1056 udf_node->uncommitted_lbs));
1057 udf_node->uncommitted_lbs = 0;
1058 }
1059 }
1060 }
1061
1062
1063 int
udf_reserve_space(struct udf_mount * ump,struct udf_node * udf_node,int udf_c_type,uint16_t vpart_num,uint32_t num_lb,int can_fail)1064 udf_reserve_space(struct udf_mount *ump, struct udf_node *udf_node,
1065 int udf_c_type, uint16_t vpart_num, uint32_t num_lb, int can_fail)
1066 {
1067 uint64_t freeblks;
1068 uint64_t slack;
1069 int i, error;
1070
1071 slack = 0;
1072 if (can_fail)
1073 slack = UDF_DISC_SLACK;
1074
1075 error = 0;
1076 mutex_enter(&ump->allocate_mutex);
1077
1078 /* check if there is enough space available */
1079 for (i = 0; i < 3; i++) { /* XXX arbitrary number */
1080 udf_calc_vpart_freespace(ump, vpart_num, &freeblks);
1081 if (num_lb + slack < freeblks)
1082 break;
1083 /* issue SYNC */
1084 DPRINTF(RESERVE, ("udf_reserve_space: issuing sync\n"));
1085 mutex_exit(&ump->allocate_mutex);
1086 udf_do_sync(ump, FSCRED, 0);
1087 /* 1/8 second wait */
1088 kpause("udfsync2", false, hz/8, NULL);
1089 mutex_enter(&ump->allocate_mutex);
1090 }
1091
1092 /* check if there is enough space available now */
1093 udf_calc_vpart_freespace(ump, vpart_num, &freeblks);
1094 if (num_lb + slack >= freeblks) {
1095 DPRINTF(RESERVE, ("udf_reserve_space: try to redistribute "
1096 "partition space\n"));
1097 DPRINTF(RESERVE, ("\tvpart %d, type %d is full\n",
1098 vpart_num, ump->vtop_alloc[vpart_num]));
1099 /* Try to redistribute space if possible */
1100 udf_collect_free_space_for_vpart(ump, vpart_num, num_lb + slack);
1101 }
1102
1103 /* check if there is enough space available now */
1104 udf_calc_vpart_freespace(ump, vpart_num, &freeblks);
1105 if (num_lb + slack <= freeblks) {
1106 udf_do_reserve_space(ump, udf_node, vpart_num, num_lb);
1107 } else {
1108 DPRINTF(RESERVE, ("udf_reserve_space: out of disc space\n"));
1109 error = ENOSPC;
1110 }
1111
1112 mutex_exit(&ump->allocate_mutex);
1113 return error;
1114 }
1115
1116
1117 void
udf_cleanup_reservation(struct udf_node * udf_node)1118 udf_cleanup_reservation(struct udf_node *udf_node)
1119 {
1120 struct udf_mount *ump = udf_node->ump;
1121 int vpart_num;
1122
1123 mutex_enter(&ump->allocate_mutex);
1124
1125 /* compensate for overlapping blocks */
1126 DPRINTF(RESERVE, ("UDF: overlapped %d blocks in count\n", udf_node->uncommitted_lbs));
1127
1128 vpart_num = udf_get_record_vpart(ump, udf_get_c_type(udf_node));
1129 udf_do_unreserve_space(ump, udf_node, vpart_num, udf_node->uncommitted_lbs);
1130
1131 DPRINTF(RESERVE, ("\ttotal now %d\n", ump->uncommitted_lbs[vpart_num]));
1132
1133 /* sanity */
1134 if (ump->uncommitted_lbs[vpart_num] < 0)
1135 ump->uncommitted_lbs[vpart_num] = 0;
1136
1137 mutex_exit(&ump->allocate_mutex);
1138 }
1139
1140 /* --------------------------------------------------------------------- */
1141
1142 /*
1143 * Allocate an extent of given length on given virt. partition. It doesn't
1144 * have to be one stretch.
1145 */
1146
1147 int
udf_allocate_space(struct udf_mount * ump,struct udf_node * udf_node,int udf_c_type,uint16_t vpart_num,uint32_t num_lb,uint64_t * lmapping)1148 udf_allocate_space(struct udf_mount *ump, struct udf_node *udf_node,
1149 int udf_c_type, uint16_t vpart_num, uint32_t num_lb, uint64_t *lmapping)
1150 {
1151 struct mmc_trackinfo *alloc_track, *other_track;
1152 struct udf_bitmap *bitmap;
1153 struct part_desc *pdesc;
1154 struct logvol_int_desc *lvid;
1155 uint64_t *lmappos;
1156 uint32_t ptov, lb_num, *freepos, free_lbs;
1157 int lb_size __diagused, alloc_num_lb;
1158 int alloc_type, error;
1159 int is_node;
1160
1161 DPRINTF(CALL, ("udf_allocate_space(ctype %d, vpart %d, num_lb %d\n",
1162 udf_c_type, vpart_num, num_lb));
1163 mutex_enter(&ump->allocate_mutex);
1164
1165 lb_size = udf_rw32(ump->logical_vol->lb_size);
1166 KASSERT(lb_size == ump->discinfo.sector_size);
1167
1168 alloc_type = ump->vtop_alloc[vpart_num];
1169 is_node = (udf_c_type == UDF_C_NODE);
1170
1171 lmappos = lmapping;
1172 error = 0;
1173 switch (alloc_type) {
1174 case UDF_ALLOC_VAT :
1175 /* search empty slot in VAT file */
1176 KASSERT(num_lb == 1);
1177 error = udf_search_free_vatloc(ump, &lb_num);
1178 if (!error) {
1179 *lmappos = lb_num;
1180
1181 /* reserve on the backing sequential partition since
1182 * that partition is credited back later */
1183 udf_do_reserve_space(ump, udf_node,
1184 ump->vtop[vpart_num], num_lb);
1185 }
1186 break;
1187 case UDF_ALLOC_SEQUENTIAL :
1188 /* sequential allocation on recordable media */
1189 /* get partition backing up this vpart_num_num */
1190 pdesc = ump->partitions[ump->vtop[vpart_num]];
1191
1192 /* calculate offset from physical base partition */
1193 ptov = udf_rw32(pdesc->start_loc);
1194
1195 /* get our track descriptors */
1196 if (vpart_num == ump->node_part) {
1197 alloc_track = &ump->metadata_track;
1198 other_track = &ump->data_track;
1199 } else {
1200 alloc_track = &ump->data_track;
1201 other_track = &ump->metadata_track;
1202 }
1203
1204 /* allocate */
1205 for (lb_num = 0; lb_num < num_lb; lb_num++) {
1206 *lmappos++ = alloc_track->next_writable - ptov;
1207 alloc_track->next_writable++;
1208 alloc_track->free_blocks--;
1209 }
1210
1211 /* keep other track up-to-date */
1212 if (alloc_track->tracknr == other_track->tracknr)
1213 memcpy(other_track, alloc_track,
1214 sizeof(struct mmc_trackinfo));
1215 break;
1216 case UDF_ALLOC_SPACEMAP :
1217 /* try to allocate on unallocated bits */
1218 alloc_num_lb = num_lb;
1219 bitmap = &ump->part_unalloc_bits[vpart_num];
1220 udf_bitmap_allocate(bitmap, is_node, &alloc_num_lb, lmappos);
1221 ump->lvclose |= UDF_WRITE_PART_BITMAPS;
1222
1223 /* have we allocated all? */
1224 if (alloc_num_lb) {
1225 /* TODO convert freed to unalloc and try again */
1226 /* free allocated piece for now */
1227 lmappos = lmapping;
1228 for (lb_num=0; lb_num < num_lb-alloc_num_lb; lb_num++) {
1229 udf_bitmap_free(bitmap, *lmappos++, 1);
1230 }
1231 error = ENOSPC;
1232 }
1233 if (!error) {
1234 /* adjust freecount */
1235 lvid = ump->logvol_integrity;
1236 freepos = &lvid->tables[0] + vpart_num;
1237 free_lbs = udf_rw32(*freepos);
1238 *freepos = udf_rw32(free_lbs - num_lb);
1239 }
1240 break;
1241 case UDF_ALLOC_METABITMAP : /* UDF 2.50, 2.60 BluRay-RE */
1242 /* allocate on metadata unallocated bits */
1243 alloc_num_lb = num_lb;
1244 bitmap = &ump->metadata_unalloc_bits;
1245 udf_bitmap_allocate(bitmap, is_node, &alloc_num_lb, lmappos);
1246 ump->lvclose |= UDF_WRITE_PART_BITMAPS;
1247
1248 /* have we allocated all? */
1249 if (alloc_num_lb) {
1250 /* YIKES! TODO we need to extend the metadata partition */
1251 /* free allocated piece for now */
1252 lmappos = lmapping;
1253 for (lb_num=0; lb_num < num_lb-alloc_num_lb; lb_num++) {
1254 udf_bitmap_free(bitmap, *lmappos++, 1);
1255 }
1256 error = ENOSPC;
1257 }
1258 if (!error) {
1259 /* adjust freecount */
1260 lvid = ump->logvol_integrity;
1261 freepos = &lvid->tables[0] + vpart_num;
1262 free_lbs = udf_rw32(*freepos);
1263 *freepos = udf_rw32(free_lbs - num_lb);
1264 }
1265 break;
1266 case UDF_ALLOC_METASEQUENTIAL : /* UDF 2.60 BluRay-R */
1267 case UDF_ALLOC_RELAXEDSEQUENTIAL : /* UDF 2.50/~meta BluRay-R */
1268 printf("ALERT: udf_allocate_space : allocation %d "
1269 "not implemented yet!\n", alloc_type);
1270 /* TODO implement, doesn't have to be contiguous */
1271 error = ENOSPC;
1272 break;
1273 }
1274
1275 if (!error) {
1276 /* credit our partition since we have committed the space */
1277 udf_do_unreserve_space(ump, udf_node, vpart_num, num_lb);
1278 }
1279
1280 #ifdef DEBUG
1281 if (udf_verbose & UDF_DEBUG_ALLOC) {
1282 lmappos = lmapping;
1283 printf("udf_allocate_space, allocated logical lba :\n");
1284 for (lb_num = 0; lb_num < num_lb; lb_num++) {
1285 printf("%s %"PRIu64, (lb_num > 0)?",":"",
1286 *lmappos++);
1287 }
1288 printf("\n");
1289 }
1290 #endif
1291 mutex_exit(&ump->allocate_mutex);
1292
1293 return error;
1294 }
1295
1296 /* --------------------------------------------------------------------- */
1297
1298 void
udf_free_allocated_space(struct udf_mount * ump,uint32_t lb_num,uint16_t vpart_num,uint32_t num_lb)1299 udf_free_allocated_space(struct udf_mount *ump, uint32_t lb_num,
1300 uint16_t vpart_num, uint32_t num_lb)
1301 {
1302 struct udf_bitmap *bitmap;
1303 struct logvol_int_desc *lvid;
1304 uint32_t lb_map, udf_rw32_lbmap;
1305 uint32_t *freepos, free_lbs;
1306 int phys_part;
1307 int error __diagused;
1308
1309 DPRINTF(ALLOC, ("udf_free_allocated_space: freeing virt lbnum %d "
1310 "part %d + %d sect\n", lb_num, vpart_num, num_lb));
1311
1312 /* no use freeing zero length */
1313 if (num_lb == 0)
1314 return;
1315
1316 mutex_enter(&ump->allocate_mutex);
1317
1318 switch (ump->vtop_tp[vpart_num]) {
1319 case UDF_VTOP_TYPE_PHYS :
1320 case UDF_VTOP_TYPE_SPARABLE :
1321 /* free space to freed or unallocated space bitmap */
1322 phys_part = ump->vtop[vpart_num];
1323
1324 /* first try freed space bitmap */
1325 bitmap = &ump->part_freed_bits[phys_part];
1326
1327 /* if not defined, use unallocated bitmap */
1328 if (bitmap->bits == NULL)
1329 bitmap = &ump->part_unalloc_bits[phys_part];
1330
1331 /* if no bitmaps are defined, bail out; XXX OK? */
1332 if (bitmap->bits == NULL)
1333 break;
1334
1335 /* free bits if its defined */
1336 KASSERT(bitmap->bits);
1337 ump->lvclose |= UDF_WRITE_PART_BITMAPS;
1338 udf_bitmap_free(bitmap, lb_num, num_lb);
1339
1340 /* adjust freecount */
1341 lvid = ump->logvol_integrity;
1342 freepos = &lvid->tables[0] + vpart_num;
1343 free_lbs = udf_rw32(*freepos);
1344 *freepos = udf_rw32(free_lbs + num_lb);
1345 break;
1346 case UDF_VTOP_TYPE_VIRT :
1347 /* free this VAT entry */
1348 KASSERT(num_lb == 1);
1349
1350 lb_map = 0xffffffff;
1351 udf_rw32_lbmap = udf_rw32(lb_map);
1352 error = udf_vat_write(ump->vat_node,
1353 (uint8_t *) &udf_rw32_lbmap, 4,
1354 ump->vat_offset + lb_num * 4);
1355 KASSERT(error == 0);
1356 ump->vat_last_free_lb = MIN(ump->vat_last_free_lb, lb_num);
1357 break;
1358 case UDF_VTOP_TYPE_META :
1359 /* free space in the metadata bitmap */
1360 bitmap = &ump->metadata_unalloc_bits;
1361 KASSERT(bitmap->bits);
1362
1363 ump->lvclose |= UDF_WRITE_PART_BITMAPS;
1364 udf_bitmap_free(bitmap, lb_num, num_lb);
1365
1366 /* adjust freecount */
1367 lvid = ump->logvol_integrity;
1368 freepos = &lvid->tables[0] + vpart_num;
1369 free_lbs = udf_rw32(*freepos);
1370 *freepos = udf_rw32(free_lbs + num_lb);
1371 break;
1372 default:
1373 printf("ALERT: udf_free_allocated_space : allocation %d "
1374 "not implemented yet!\n", ump->vtop_tp[vpart_num]);
1375 break;
1376 }
1377
1378 mutex_exit(&ump->allocate_mutex);
1379 }
1380
1381 /* --------------------------------------------------------------------- */
1382
1383 /*
1384 * Special function to synchronise the metadatamirror file when they change on
1385 * resizing. When the metadatafile is actually duplicated, this action is a
1386 * no-op since they describe different extents on the disc.
1387 */
1388
1389 void
udf_synchronise_metadatamirror_node(struct udf_mount * ump)1390 udf_synchronise_metadatamirror_node(struct udf_mount *ump)
1391 {
1392 struct udf_node *meta_node, *metamirror_node;
1393 struct long_ad s_ad;
1394 uint32_t len, flags;
1395 int slot, cpy_slot;
1396 int error, eof;
1397
1398 if (ump->metadata_flags & METADATA_DUPLICATED)
1399 return;
1400
1401 meta_node = ump->metadata_node;
1402 metamirror_node = ump->metadatamirror_node;
1403
1404 /* 1) wipe mirror node */
1405 udf_wipe_adslots(metamirror_node);
1406
1407 /* 2) copy all node descriptors from the meta_node */
1408 slot = 0;
1409 cpy_slot = 0;
1410 for (;;) {
1411 udf_get_adslot(meta_node, slot, &s_ad, &eof);
1412 if (eof)
1413 break;
1414 len = udf_rw32(s_ad.len);
1415 flags = UDF_EXT_FLAGS(len);
1416 len = UDF_EXT_LEN(len);
1417
1418 if (flags == UDF_EXT_REDIRECT) {
1419 slot++;
1420 continue;
1421 }
1422
1423 error = udf_append_adslot(metamirror_node, &cpy_slot, &s_ad);
1424 if (error) {
1425 /* WTF, this shouldn't happen, what to do now? */
1426 panic("udf_synchronise_metadatamirror_node failed!");
1427 }
1428 cpy_slot++;
1429 slot++;
1430 }
1431
1432 /* 3) adjust metamirror_node size */
1433 if (meta_node->fe) {
1434 KASSERT(metamirror_node->fe);
1435 metamirror_node->fe->inf_len = meta_node->fe->inf_len;
1436 } else {
1437 KASSERT(meta_node->efe);
1438 KASSERT(metamirror_node->efe);
1439 metamirror_node->efe->inf_len = meta_node->efe->inf_len;
1440 metamirror_node->efe->obj_size = meta_node->efe->obj_size;
1441 }
1442
1443 /* for sanity */
1444 udf_count_alloc_exts(metamirror_node);
1445 }
1446
1447 /* --------------------------------------------------------------------- */
1448
1449 /*
1450 * When faced with an out of space but there is still space available on other
1451 * partitions, try to redistribute the space. This is only defined for media
1452 * using Metadata partitions.
1453 *
1454 * There are two formats to deal with. Either its a `normal' metadata
1455 * partition and we can move blocks between a metadata bitmap and its
1456 * companion data spacemap OR its a UDF 2.60 formatted BluRay-R disc with POW
1457 * and a metadata partition.
1458 */
1459
1460 /* implementation limit: ump->datapart is the companion partition */
1461 static uint32_t
udf_trunc_metadatapart(struct udf_mount * ump,uint32_t num_lb)1462 udf_trunc_metadatapart(struct udf_mount *ump, uint32_t num_lb)
1463 {
1464 struct udf_node *bitmap_node;
1465 struct udf_bitmap *bitmap;
1466 struct space_bitmap_desc *sbd, *new_sbd;
1467 struct logvol_int_desc *lvid;
1468 uint64_t inf_len;
1469 uint64_t meta_free_lbs, data_free_lbs, to_trunc;
1470 uint32_t *freepos, *sizepos;
1471 uint32_t unit, lb_size;
1472 uint16_t meta_vpart_num, data_vpart_num, num_vpart;
1473 int err __diagused;
1474
1475 unit = ump->metadata_alloc_unit_size;
1476 lb_size = udf_rw32(ump->logical_vol->lb_size);
1477 lvid = ump->logvol_integrity;
1478
1479 /* XXX
1480 *
1481 * the following checks will fail for BD-R UDF 2.60! but they are
1482 * read-only for now anyway! Its even doubtful if it is to be allowed
1483 * for these discs.
1484 */
1485
1486 /* lookup vpart for metadata partition */
1487 meta_vpart_num = ump->node_part;
1488 KASSERT(ump->vtop_alloc[meta_vpart_num] == UDF_ALLOC_METABITMAP);
1489
1490 /* lookup vpart for data partition */
1491 data_vpart_num = ump->data_part;
1492 KASSERT(ump->vtop_alloc[data_vpart_num] == UDF_ALLOC_SPACEMAP);
1493
1494 udf_calc_vpart_freespace(ump, data_vpart_num, &data_free_lbs);
1495 udf_calc_vpart_freespace(ump, meta_vpart_num, &meta_free_lbs);
1496
1497 DPRINTF(RESERVE, ("\tfree space on data partition %"PRIu64" blks\n", data_free_lbs));
1498 DPRINTF(RESERVE, ("\tfree space on metadata partition %"PRIu64" blks\n", meta_free_lbs));
1499
1500 /* give away some of the free meta space, in unit block sizes */
1501 to_trunc = meta_free_lbs/4; /* give out a quarter */
1502 to_trunc = MAX(to_trunc, num_lb);
1503 to_trunc = unit * ((to_trunc + unit-1) / unit); /* round up */
1504
1505 /* scale down if needed and bail out when out of space */
1506 if (to_trunc >= meta_free_lbs)
1507 return num_lb;
1508
1509 /* check extent of bits marked free at the end of the map */
1510 bitmap = &ump->metadata_unalloc_bits;
1511 to_trunc = udf_bitmap_check_trunc_free(bitmap, to_trunc);
1512 to_trunc = unit * (to_trunc / unit); /* round down again */
1513 if (to_trunc == 0)
1514 return num_lb;
1515
1516 DPRINTF(RESERVE, ("\ttruncating %"PRIu64" lbs from the metadata bitmap\n",
1517 to_trunc));
1518
1519 /* get length of the metadata bitmap node file */
1520 bitmap_node = ump->metadatabitmap_node;
1521 if (bitmap_node->fe) {
1522 inf_len = udf_rw64(bitmap_node->fe->inf_len);
1523 } else {
1524 KASSERT(bitmap_node->efe);
1525 inf_len = udf_rw64(bitmap_node->efe->inf_len);
1526 }
1527 inf_len -= to_trunc/8;
1528
1529 /* as per [UDF 2.60/2.2.13.6] : */
1530 /* 1) update the SBD in the metadata bitmap file */
1531 sbd = (struct space_bitmap_desc *) bitmap->blob;
1532 sbd->num_bits = udf_rw32(udf_rw32(sbd->num_bits) - to_trunc);
1533 sbd->num_bytes = udf_rw32(udf_rw32(sbd->num_bytes) - to_trunc/8);
1534 bitmap->max_offset = udf_rw32(sbd->num_bits);
1535
1536 num_vpart = udf_rw32(lvid->num_part);
1537 freepos = &lvid->tables[0] + meta_vpart_num;
1538 sizepos = &lvid->tables[0] + num_vpart + meta_vpart_num;
1539 *freepos = udf_rw32(*freepos) - to_trunc;
1540 *sizepos = udf_rw32(*sizepos) - to_trunc;
1541
1542 /* realloc bitmap for better memory usage */
1543 new_sbd = realloc(sbd, inf_len, M_UDFVOLD, M_WAITOK);
1544 if (new_sbd) {
1545 /* update pointers */
1546 ump->metadata_unalloc_dscr = new_sbd;
1547 bitmap->blob = (uint8_t *) new_sbd;
1548 }
1549 ump->lvclose |= UDF_WRITE_PART_BITMAPS;
1550
1551 /*
1552 * The truncated space is secured now and can't be allocated anymore.
1553 * Release the allocated mutex so we can shrink the nodes the normal
1554 * way.
1555 */
1556 mutex_exit(&ump->allocate_mutex);
1557
1558 /* 2) trunc the metadata bitmap information file, freeing blocks */
1559 err = udf_shrink_node(bitmap_node, inf_len);
1560 KASSERT(err == 0);
1561
1562 /* 3) trunc the metadata file and mirror file, freeing blocks */
1563 inf_len = (uint64_t) udf_rw32(sbd->num_bits) * lb_size; /* [4/14.12.4] */
1564 err = udf_shrink_node(ump->metadata_node, inf_len);
1565 KASSERT(err == 0);
1566 if (ump->metadatamirror_node) {
1567 if (ump->metadata_flags & METADATA_DUPLICATED) {
1568 err = udf_shrink_node(ump->metadatamirror_node, inf_len);
1569 } else {
1570 /* extents will be copied on writeout */
1571 }
1572 KASSERT(err == 0);
1573 }
1574 ump->lvclose |= UDF_WRITE_METAPART_NODES;
1575
1576 /* relock before exit */
1577 mutex_enter(&ump->allocate_mutex);
1578
1579 if (to_trunc > num_lb)
1580 return 0;
1581 return num_lb - to_trunc;
1582 }
1583
1584
1585 static void
udf_sparsify_metadatapart(struct udf_mount * ump,uint32_t num_lb)1586 udf_sparsify_metadatapart(struct udf_mount *ump, uint32_t num_lb)
1587 {
1588 /* NOT IMPLEMENTED, fail */
1589 }
1590
1591
1592 static void
udf_collect_free_space_for_vpart(struct udf_mount * ump,uint16_t vpart_num,uint32_t num_lb)1593 udf_collect_free_space_for_vpart(struct udf_mount *ump,
1594 uint16_t vpart_num, uint32_t num_lb)
1595 {
1596 /* allocated mutex is held */
1597
1598 /* only defined for metadata partitions */
1599 if (ump->vtop_tp[ump->node_part] != UDF_VTOP_TYPE_META) {
1600 DPRINTF(RESERVE, ("\tcan't grow/shrink; no metadata partitioning\n"));
1601 return;
1602 }
1603
1604 /* UDF 2.60 BD-R+POW? */
1605 if (ump->vtop_alloc[ump->node_part] == UDF_ALLOC_METASEQUENTIAL) {
1606 DPRINTF(RESERVE, ("\tUDF 2.60 BD-R+POW track grow not implemented yet\n"));
1607 return;
1608 }
1609
1610 if (ump->vtop_tp[vpart_num] == UDF_VTOP_TYPE_META) {
1611 /* try to grow the meta partition */
1612 DPRINTF(RESERVE, ("\ttrying to grow the meta partition\n"));
1613 /* as per [UDF 2.60/2.2.13.5] : extend bitmap and metadata file(s) */
1614 DPRINTF(NOTIMPL, ("\tgrowing meta partition not implemented yet\n"));
1615 } else {
1616 /* try to shrink the metadata partition */
1617 DPRINTF(RESERVE, ("\ttrying to shrink the meta partition\n"));
1618 /* as per [UDF 2.60/2.2.13.6] : either trunc or make sparse */
1619 num_lb = udf_trunc_metadatapart(ump, num_lb);
1620 if (num_lb)
1621 udf_sparsify_metadatapart(ump, num_lb);
1622 }
1623
1624 /* allocated mutex should still be held */
1625 }
1626
1627 /* --------------------------------------------------------------------- */
1628
1629 /*
1630 * Allocate a buf on disc for direct write out. The space doesn't have to be
1631 * contiguous as the caller takes care of this.
1632 */
1633
1634 void
udf_late_allocate_buf(struct udf_mount * ump,struct buf * buf,uint64_t * lmapping,struct long_ad * node_ad_cpy,uint16_t * vpart_nump)1635 udf_late_allocate_buf(struct udf_mount *ump, struct buf *buf,
1636 uint64_t *lmapping, struct long_ad *node_ad_cpy, uint16_t *vpart_nump)
1637 {
1638 struct udf_node *udf_node = VTOI(buf->b_vp);
1639 int lb_size, udf_c_type;
1640 int vpart_num, num_lb;
1641 int error, s;
1642
1643 /*
1644 * for each sector in the buf, allocate a sector on disc and record
1645 * its position in the provided mapping array.
1646 *
1647 * If its userdata or FIDs, record its location in its node.
1648 */
1649
1650 lb_size = udf_rw32(ump->logical_vol->lb_size);
1651 num_lb = (buf->b_bcount + lb_size -1) / lb_size;
1652 udf_c_type = buf->b_udf_c_type;
1653
1654 KASSERT(lb_size == ump->discinfo.sector_size);
1655
1656 /* select partition to record the buffer on */
1657 vpart_num = *vpart_nump = udf_get_record_vpart(ump, udf_c_type);
1658
1659 if (udf_c_type == UDF_C_NODE) {
1660 /* if not VAT, its already allocated */
1661 if (ump->vtop_alloc[ump->node_part] != UDF_ALLOC_VAT)
1662 return;
1663
1664 /* allocate on its backing sequential partition */
1665 vpart_num = ump->data_part;
1666 }
1667
1668 /* XXX can this still happen? */
1669 /* do allocation on the selected partition */
1670 error = udf_allocate_space(ump, udf_node, udf_c_type,
1671 vpart_num, num_lb, lmapping);
1672 if (error) {
1673 /*
1674 * ARGH! we haven't done our accounting right! it should
1675 * always succeed.
1676 */
1677 panic("UDF disc allocation accounting gone wrong");
1678 }
1679
1680 /* If its userdata or FIDs, record its allocation in its node. */
1681 if ((udf_c_type == UDF_C_USERDATA) ||
1682 (udf_c_type == UDF_C_FIDS) ||
1683 (udf_c_type == UDF_C_METADATA_SBM))
1684 {
1685 udf_record_allocation_in_node(ump, buf, vpart_num, lmapping,
1686 node_ad_cpy);
1687 /* decrement our outstanding bufs counter */
1688 s = splbio();
1689 udf_node->outstanding_bufs--;
1690 splx(s);
1691 }
1692 }
1693
1694 /* --------------------------------------------------------------------- */
1695
1696 /*
1697 * Try to merge a1 with the new piece a2. udf_ads_merge returns error when not
1698 * possible (anymore); a2 returns the rest piece.
1699 */
1700
1701 static int
udf_ads_merge(uint32_t max_len,uint32_t lb_size,struct long_ad * a1,struct long_ad * a2)1702 udf_ads_merge(uint32_t max_len, uint32_t lb_size, struct long_ad *a1, struct long_ad *a2)
1703 {
1704 uint32_t merge_len;
1705 uint32_t a1_len, a2_len;
1706 uint32_t a1_flags, a2_flags;
1707 uint32_t a1_lbnum, a2_lbnum;
1708 uint16_t a1_part, a2_part;
1709
1710 a1_flags = UDF_EXT_FLAGS(udf_rw32(a1->len));
1711 a1_len = UDF_EXT_LEN(udf_rw32(a1->len));
1712 a1_lbnum = udf_rw32(a1->loc.lb_num);
1713 a1_part = udf_rw16(a1->loc.part_num);
1714
1715 a2_flags = UDF_EXT_FLAGS(udf_rw32(a2->len));
1716 a2_len = UDF_EXT_LEN(udf_rw32(a2->len));
1717 a2_lbnum = udf_rw32(a2->loc.lb_num);
1718 a2_part = udf_rw16(a2->loc.part_num);
1719
1720 /* defines same space */
1721 if (a1_flags != a2_flags)
1722 return 1;
1723
1724 if (a1_flags != UDF_EXT_FREE) {
1725 /* the same partition */
1726 if (a1_part != a2_part)
1727 return 1;
1728
1729 /* a2 is successor of a1 */
1730 if (a1_lbnum * lb_size + a1_len != a2_lbnum * lb_size)
1731 return 1;
1732 }
1733
1734 /* merge as most from a2 if possible */
1735 merge_len = MIN(a2_len, max_len - a1_len);
1736 a1_len += merge_len;
1737 a2_len -= merge_len;
1738 a2_lbnum += merge_len/lb_size;
1739
1740 a1->len = udf_rw32(a1_len | a1_flags);
1741 a2->len = udf_rw32(a2_len | a2_flags);
1742 a2->loc.lb_num = udf_rw32(a2_lbnum);
1743
1744 if (a2_len > 0)
1745 return 1;
1746
1747 /* there is space over to merge */
1748 return 0;
1749 }
1750
1751 /* --------------------------------------------------------------------- */
1752
1753 static void
udf_wipe_adslots(struct udf_node * udf_node)1754 udf_wipe_adslots(struct udf_node *udf_node)
1755 {
1756 struct file_entry *fe;
1757 struct extfile_entry *efe;
1758 struct alloc_ext_entry *ext;
1759 uint32_t lb_size, dscr_size, l_ea, max_l_ad, crclen;
1760 uint8_t *data_pos;
1761 int extnr;
1762
1763 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
1764
1765 fe = udf_node->fe;
1766 efe = udf_node->efe;
1767 if (fe) {
1768 dscr_size = sizeof(struct file_entry) -1;
1769 l_ea = udf_rw32(fe->l_ea);
1770 data_pos = (uint8_t *) fe + dscr_size + l_ea;
1771 } else {
1772 dscr_size = sizeof(struct extfile_entry) -1;
1773 l_ea = udf_rw32(efe->l_ea);
1774 data_pos = (uint8_t *) efe + dscr_size + l_ea;
1775 }
1776 max_l_ad = lb_size - dscr_size - l_ea;
1777
1778 /* wipe fe/efe */
1779 memset(data_pos, 0, max_l_ad);
1780 crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea;
1781 if (fe) {
1782 fe->l_ad = udf_rw32(0);
1783 fe->logblks_rec = udf_rw64(0);
1784 fe->tag.desc_crc_len = udf_rw16(crclen);
1785 } else {
1786 efe->l_ad = udf_rw32(0);
1787 efe->logblks_rec = udf_rw64(0);
1788 efe->tag.desc_crc_len = udf_rw16(crclen);
1789 }
1790
1791 /* wipe all allocation extent entries */
1792 for (extnr = 0; extnr < udf_node->num_extensions; extnr++) {
1793 ext = udf_node->ext[extnr];
1794 dscr_size = sizeof(struct alloc_ext_entry) -1;
1795 data_pos = (uint8_t *) ext->data;
1796 max_l_ad = lb_size - dscr_size;
1797 memset(data_pos, 0, max_l_ad);
1798 ext->l_ad = udf_rw32(0);
1799
1800 crclen = dscr_size - UDF_DESC_TAG_LENGTH;
1801 ext->tag.desc_crc_len = udf_rw16(crclen);
1802 }
1803 udf_node->i_flags |= IN_NODE_REBUILD;
1804 }
1805
1806 /* --------------------------------------------------------------------- */
1807
1808 void
udf_get_adslot(struct udf_node * udf_node,int slot,struct long_ad * icb,int * eof)1809 udf_get_adslot(struct udf_node *udf_node, int slot, struct long_ad *icb,
1810 int *eof) {
1811 struct file_entry *fe;
1812 struct extfile_entry *efe;
1813 struct alloc_ext_entry *ext;
1814 struct icb_tag *icbtag;
1815 struct short_ad *short_ad;
1816 struct long_ad *long_ad, l_icb;
1817 uint32_t offset;
1818 uint32_t dscr_size, l_ea, l_ad, flags;
1819 uint8_t *data_pos;
1820 int icbflags, addr_type, adlen, extnr;
1821
1822 fe = udf_node->fe;
1823 efe = udf_node->efe;
1824 if (fe) {
1825 icbtag = &fe->icbtag;
1826 dscr_size = sizeof(struct file_entry) -1;
1827 l_ea = udf_rw32(fe->l_ea);
1828 l_ad = udf_rw32(fe->l_ad);
1829 data_pos = (uint8_t *) fe + dscr_size + l_ea;
1830 } else {
1831 icbtag = &efe->icbtag;
1832 dscr_size = sizeof(struct extfile_entry) -1;
1833 l_ea = udf_rw32(efe->l_ea);
1834 l_ad = udf_rw32(efe->l_ad);
1835 data_pos = (uint8_t *) efe + dscr_size + l_ea;
1836 }
1837
1838 icbflags = udf_rw16(icbtag->flags);
1839 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
1840
1841 /* just in case we're called on an intern, its EOF */
1842 if (addr_type == UDF_ICB_INTERN_ALLOC) {
1843 memset(icb, 0, sizeof(struct long_ad));
1844 *eof = 1;
1845 return;
1846 }
1847
1848 adlen = 0;
1849 if (addr_type == UDF_ICB_SHORT_ALLOC) {
1850 adlen = sizeof(struct short_ad);
1851 } else if (addr_type == UDF_ICB_LONG_ALLOC) {
1852 adlen = sizeof(struct long_ad);
1853 }
1854
1855 /* if offset too big, we go to the allocation extensions */
1856 offset = slot * adlen;
1857 extnr = -1;
1858 while (offset >= l_ad) {
1859 /* check if our last entry is a redirect */
1860 if (addr_type == UDF_ICB_SHORT_ALLOC) {
1861 short_ad = (struct short_ad *) (data_pos + l_ad-adlen);
1862 l_icb.len = short_ad->len;
1863 l_icb.loc.part_num = udf_node->loc.loc.part_num;
1864 l_icb.loc.lb_num = short_ad->lb_num;
1865 } else {
1866 KASSERT(addr_type == UDF_ICB_LONG_ALLOC);
1867 long_ad = (struct long_ad *) (data_pos + l_ad-adlen);
1868 l_icb = *long_ad;
1869 }
1870 flags = UDF_EXT_FLAGS(udf_rw32(l_icb.len));
1871 if (flags != UDF_EXT_REDIRECT) {
1872 l_ad = 0; /* force EOF */
1873 break;
1874 }
1875
1876 /* advance to next extent */
1877 extnr++;
1878 if (extnr >= udf_node->num_extensions) {
1879 l_ad = 0; /* force EOF */
1880 break;
1881 }
1882 offset = offset - l_ad;
1883 ext = udf_node->ext[extnr];
1884 dscr_size = sizeof(struct alloc_ext_entry) -1;
1885 l_ad = udf_rw32(ext->l_ad);
1886 data_pos = (uint8_t *) ext + dscr_size;
1887 }
1888
1889 /* XXX l_ad == 0 should be enough to check */
1890 *eof = (offset >= l_ad) || (l_ad == 0);
1891 if (*eof) {
1892 DPRINTF(PARANOIDADWLK, ("returning EOF, extnr %d, offset %d, "
1893 "l_ad %d\n", extnr, offset, l_ad));
1894 memset(icb, 0, sizeof(struct long_ad));
1895 return;
1896 }
1897
1898 /* get the element */
1899 if (addr_type == UDF_ICB_SHORT_ALLOC) {
1900 short_ad = (struct short_ad *) (data_pos + offset);
1901 icb->len = short_ad->len;
1902 icb->loc.part_num = udf_node->loc.loc.part_num;
1903 icb->loc.lb_num = short_ad->lb_num;
1904 } else if (addr_type == UDF_ICB_LONG_ALLOC) {
1905 long_ad = (struct long_ad *) (data_pos + offset);
1906 *icb = *long_ad;
1907 }
1908 DPRINTF(PARANOIDADWLK, ("returning element : v %d, lb %d, len %d, "
1909 "flags %d\n", icb->loc.part_num, icb->loc.lb_num,
1910 UDF_EXT_LEN(icb->len), UDF_EXT_FLAGS(icb->len)));
1911 }
1912
1913 /* --------------------------------------------------------------------- */
1914
1915 int
udf_append_adslot(struct udf_node * udf_node,int * slot,struct long_ad * icb)1916 udf_append_adslot(struct udf_node *udf_node, int *slot, struct long_ad *icb) {
1917 struct udf_mount *ump = udf_node->ump;
1918 union dscrptr *dscr, *extdscr;
1919 struct file_entry *fe;
1920 struct extfile_entry *efe;
1921 struct alloc_ext_entry *ext;
1922 struct icb_tag *icbtag;
1923 struct short_ad *short_ad;
1924 struct long_ad *long_ad, o_icb, l_icb;
1925 uint64_t logblks_rec, *logblks_rec_p;
1926 uint64_t lmapping;
1927 uint32_t offset, rest, len, lb_num;
1928 uint32_t lb_size, dscr_size, l_ea, l_ad, *l_ad_p, max_l_ad, crclen;
1929 uint32_t flags;
1930 uint16_t vpart_num;
1931 uint8_t *data_pos;
1932 int icbflags, addr_type, adlen, extnr;
1933 int error;
1934
1935 lb_size = udf_rw32(ump->logical_vol->lb_size);
1936 vpart_num = udf_rw16(udf_node->loc.loc.part_num);
1937
1938 /* determine what descriptor we are in */
1939 fe = udf_node->fe;
1940 efe = udf_node->efe;
1941 if (fe) {
1942 icbtag = &fe->icbtag;
1943 dscr = (union dscrptr *) fe;
1944 dscr_size = sizeof(struct file_entry) -1;
1945
1946 l_ea = udf_rw32(fe->l_ea);
1947 l_ad_p = &fe->l_ad;
1948 logblks_rec_p = &fe->logblks_rec;
1949 } else {
1950 icbtag = &efe->icbtag;
1951 dscr = (union dscrptr *) efe;
1952 dscr_size = sizeof(struct extfile_entry) -1;
1953
1954 l_ea = udf_rw32(efe->l_ea);
1955 l_ad_p = &efe->l_ad;
1956 logblks_rec_p = &efe->logblks_rec;
1957 }
1958 data_pos = (uint8_t *) dscr + dscr_size + l_ea;
1959 max_l_ad = lb_size - dscr_size - l_ea;
1960
1961 icbflags = udf_rw16(icbtag->flags);
1962 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
1963
1964 /* just in case we're called on an intern, its EOF */
1965 if (addr_type == UDF_ICB_INTERN_ALLOC) {
1966 panic("udf_append_adslot on UDF_ICB_INTERN_ALLOC\n");
1967 }
1968
1969 adlen = 0;
1970 if (addr_type == UDF_ICB_SHORT_ALLOC) {
1971 adlen = sizeof(struct short_ad);
1972 } else if (addr_type == UDF_ICB_LONG_ALLOC) {
1973 adlen = sizeof(struct long_ad);
1974 }
1975
1976 /* clean up given long_ad since it can be a synthesized one */
1977 flags = UDF_EXT_FLAGS(udf_rw32(icb->len));
1978 if (flags == UDF_EXT_FREE) {
1979 icb->loc.part_num = udf_rw16(0);
1980 icb->loc.lb_num = udf_rw32(0);
1981 }
1982
1983 /* if offset too big, we go to the allocation extensions */
1984 l_ad = udf_rw32(*l_ad_p);
1985 offset = (*slot) * adlen;
1986 extnr = -1;
1987 while (offset >= l_ad) {
1988 /* check if our last entry is a redirect */
1989 if (addr_type == UDF_ICB_SHORT_ALLOC) {
1990 short_ad = (struct short_ad *) (data_pos + l_ad-adlen);
1991 l_icb.len = short_ad->len;
1992 l_icb.loc.part_num = udf_node->loc.loc.part_num;
1993 l_icb.loc.lb_num = short_ad->lb_num;
1994 } else {
1995 KASSERT(addr_type == UDF_ICB_LONG_ALLOC);
1996 long_ad = (struct long_ad *) (data_pos + l_ad-adlen);
1997 l_icb = *long_ad;
1998 }
1999 flags = UDF_EXT_FLAGS(udf_rw32(l_icb.len));
2000 if (flags != UDF_EXT_REDIRECT) {
2001 /* only one past the last one is adressable */
2002 break;
2003 }
2004
2005 /* advance to next extent */
2006 extnr++;
2007 KASSERT(extnr < udf_node->num_extensions);
2008 offset = offset - l_ad;
2009
2010 ext = udf_node->ext[extnr];
2011 dscr = (union dscrptr *) ext;
2012 dscr_size = sizeof(struct alloc_ext_entry) -1;
2013 max_l_ad = lb_size - dscr_size;
2014 l_ad_p = &ext->l_ad;
2015 l_ad = udf_rw32(*l_ad_p);
2016 data_pos = (uint8_t *) ext + dscr_size;
2017 }
2018 DPRINTF(PARANOIDADWLK, ("append, ext %d, offset %d, l_ad %d\n",
2019 extnr, offset, udf_rw32(*l_ad_p)));
2020 KASSERT(l_ad == udf_rw32(*l_ad_p));
2021
2022 /* offset is offset within the current (E)FE/AED */
2023 l_ad = udf_rw32(*l_ad_p);
2024 crclen = udf_rw16(dscr->tag.desc_crc_len);
2025 logblks_rec = udf_rw64(*logblks_rec_p);
2026
2027 /* overwriting old piece? */
2028 if (offset < l_ad) {
2029 /* overwrite entry; compensate for the old element */
2030 if (addr_type == UDF_ICB_SHORT_ALLOC) {
2031 short_ad = (struct short_ad *) (data_pos + offset);
2032 o_icb.len = short_ad->len;
2033 o_icb.loc.part_num = udf_rw16(0); /* ignore */
2034 o_icb.loc.lb_num = short_ad->lb_num;
2035 } else if (addr_type == UDF_ICB_LONG_ALLOC) {
2036 long_ad = (struct long_ad *) (data_pos + offset);
2037 o_icb = *long_ad;
2038 } else {
2039 panic("Invalid address type in udf_append_adslot\n");
2040 }
2041
2042 len = udf_rw32(o_icb.len);
2043 if (UDF_EXT_FLAGS(len) == UDF_EXT_ALLOCATED) {
2044 /* adjust counts */
2045 len = UDF_EXT_LEN(len);
2046 logblks_rec -= (len + lb_size -1) / lb_size;
2047 }
2048 }
2049
2050 /* check if we're not appending a redirection */
2051 flags = UDF_EXT_FLAGS(udf_rw32(icb->len));
2052 KASSERT(flags != UDF_EXT_REDIRECT);
2053
2054 /* round down available space */
2055 rest = adlen * ((max_l_ad - offset) / adlen);
2056 if (rest <= adlen) {
2057 /* have to append aed, see if we already have a spare one */
2058 extnr++;
2059 ext = udf_node->ext[extnr];
2060 l_icb = udf_node->ext_loc[extnr];
2061 if (ext == NULL) {
2062 DPRINTF(ALLOC,("adding allocation extent %d\n", extnr));
2063
2064 error = udf_reserve_space(ump, NULL, UDF_C_NODE,
2065 vpart_num, 1, /* can fail */ false);
2066 if (error) {
2067 printf("UDF: couldn't reserve space for AED!\n");
2068 return error;
2069 }
2070 error = udf_allocate_space(ump, NULL, UDF_C_NODE,
2071 vpart_num, 1, &lmapping);
2072 lb_num = lmapping;
2073 if (error)
2074 panic("UDF: couldn't allocate AED!\n");
2075
2076 /* initialise pointer to location */
2077 memset(&l_icb, 0, sizeof(struct long_ad));
2078 l_icb.len = udf_rw32(lb_size | UDF_EXT_REDIRECT);
2079 l_icb.loc.lb_num = udf_rw32(lb_num);
2080 l_icb.loc.part_num = udf_rw16(vpart_num);
2081
2082 /* create new aed descriptor */
2083 udf_create_logvol_dscr(ump, udf_node, &l_icb, &extdscr);
2084 ext = &extdscr->aee;
2085
2086 udf_inittag(ump, &ext->tag, TAGID_ALLOCEXTENT, lb_num);
2087 dscr_size = sizeof(struct alloc_ext_entry) -1;
2088 max_l_ad = lb_size - dscr_size;
2089 memset(ext->data, 0, max_l_ad);
2090 ext->l_ad = udf_rw32(0);
2091 ext->tag.desc_crc_len =
2092 udf_rw16(dscr_size - UDF_DESC_TAG_LENGTH);
2093
2094 /* declare aed */
2095 udf_node->num_extensions++;
2096 udf_node->ext_loc[extnr] = l_icb;
2097 udf_node->ext[extnr] = ext;
2098 }
2099 /* add redirect and adjust l_ad and crclen for old descr */
2100 if (addr_type == UDF_ICB_SHORT_ALLOC) {
2101 short_ad = (struct short_ad *) (data_pos + offset);
2102 short_ad->len = l_icb.len;
2103 short_ad->lb_num = l_icb.loc.lb_num;
2104 } else if (addr_type == UDF_ICB_LONG_ALLOC) {
2105 long_ad = (struct long_ad *) (data_pos + offset);
2106 *long_ad = l_icb;
2107 }
2108 l_ad += adlen;
2109 crclen += adlen;
2110 dscr->tag.desc_crc_len = udf_rw16(crclen);
2111 *l_ad_p = udf_rw32(l_ad);
2112
2113 /* advance to the new extension */
2114 KASSERT(ext != NULL);
2115 dscr = (union dscrptr *) ext;
2116 dscr_size = sizeof(struct alloc_ext_entry) -1;
2117 max_l_ad = lb_size - dscr_size;
2118 data_pos = (uint8_t *) dscr + dscr_size;
2119
2120 l_ad_p = &ext->l_ad;
2121 l_ad = udf_rw32(*l_ad_p);
2122 crclen = udf_rw16(dscr->tag.desc_crc_len);
2123 offset = 0;
2124
2125 /* adjust callees slot count for link insert */
2126 *slot += 1;
2127 }
2128
2129 /* write out the element */
2130 DPRINTF(PARANOIDADWLK, ("adding element : %p : v %d, lb %d, "
2131 "len %d, flags %d\n", data_pos + offset,
2132 icb->loc.part_num, icb->loc.lb_num,
2133 UDF_EXT_LEN(icb->len), UDF_EXT_FLAGS(icb->len)));
2134 if (addr_type == UDF_ICB_SHORT_ALLOC) {
2135 short_ad = (struct short_ad *) (data_pos + offset);
2136 short_ad->len = icb->len;
2137 short_ad->lb_num = icb->loc.lb_num;
2138 } else if (addr_type == UDF_ICB_LONG_ALLOC) {
2139 long_ad = (struct long_ad *) (data_pos + offset);
2140 *long_ad = *icb;
2141 }
2142
2143 /* adjust logblks recorded count */
2144 len = udf_rw32(icb->len);
2145 flags = UDF_EXT_FLAGS(len);
2146 if (flags == UDF_EXT_ALLOCATED)
2147 logblks_rec += (UDF_EXT_LEN(len) + lb_size -1) / lb_size;
2148 *logblks_rec_p = udf_rw64(logblks_rec);
2149
2150 /* adjust l_ad and crclen when needed */
2151 if (offset >= l_ad) {
2152 l_ad += adlen;
2153 crclen += adlen;
2154 dscr->tag.desc_crc_len = udf_rw16(crclen);
2155 *l_ad_p = udf_rw32(l_ad);
2156 }
2157
2158 return 0;
2159 }
2160
2161 /* --------------------------------------------------------------------- */
2162
2163 static void
udf_count_alloc_exts(struct udf_node * udf_node)2164 udf_count_alloc_exts(struct udf_node *udf_node)
2165 {
2166 struct long_ad s_ad;
2167 uint32_t lb_num, len, flags;
2168 uint16_t vpart_num;
2169 int slot, eof;
2170 int num_extents, extnr;
2171
2172 if (udf_node->num_extensions == 0)
2173 return;
2174
2175 /* count number of allocation extents in use */
2176 num_extents = 0;
2177 slot = 0;
2178 for (;;) {
2179 udf_get_adslot(udf_node, slot, &s_ad, &eof);
2180 if (eof)
2181 break;
2182 len = udf_rw32(s_ad.len);
2183 flags = UDF_EXT_FLAGS(len);
2184
2185 if (flags == UDF_EXT_REDIRECT)
2186 num_extents++;
2187
2188 slot++;
2189 }
2190
2191 DPRINTF(ALLOC, ("udf_count_alloc_ext counted %d live extents\n",
2192 num_extents));
2193
2194 /* XXX choice: we could delay freeing them on node writeout */
2195 /* free excess entries */
2196 extnr = num_extents;
2197 for (;extnr < udf_node->num_extensions; extnr++) {
2198 DPRINTF(ALLOC, ("freeing alloc ext %d\n", extnr));
2199 /* free dscriptor */
2200 s_ad = udf_node->ext_loc[extnr];
2201 udf_free_logvol_dscr(udf_node->ump, &s_ad,
2202 udf_node->ext[extnr]);
2203 udf_node->ext[extnr] = NULL;
2204
2205 /* free disc space */
2206 lb_num = udf_rw32(s_ad.loc.lb_num);
2207 vpart_num = udf_rw16(s_ad.loc.part_num);
2208 udf_free_allocated_space(udf_node->ump, lb_num, vpart_num, 1);
2209
2210 memset(&udf_node->ext_loc[extnr], 0, sizeof(struct long_ad));
2211 }
2212
2213 /* set our new number of allocation extents */
2214 udf_node->num_extensions = num_extents;
2215 }
2216
2217
2218 /* --------------------------------------------------------------------- */
2219
2220 /*
2221 * Adjust the node's allocation descriptors to reflect the new mapping; do
2222 * take note that we might glue to existing allocation descriptors.
2223 *
2224 * XXX Note there can only be one allocation being recorded/mount; maybe
2225 * explicit allocation in schedule thread?
2226 */
2227
2228 static void
udf_record_allocation_in_node(struct udf_mount * ump,struct buf * buf,uint16_t vpart_num,uint64_t * mapping,struct long_ad * node_ad_cpy)2229 udf_record_allocation_in_node(struct udf_mount *ump, struct buf *buf,
2230 uint16_t vpart_num, uint64_t *mapping, struct long_ad *node_ad_cpy)
2231 {
2232 struct vnode *vp = buf->b_vp;
2233 struct udf_node *udf_node = VTOI(vp);
2234 struct file_entry *fe;
2235 struct extfile_entry *efe;
2236 struct icb_tag *icbtag;
2237 struct long_ad s_ad, c_ad;
2238 uint64_t inflen, from, till;
2239 uint64_t foffset, end_foffset, restart_foffset;
2240 uint64_t orig_inflen, orig_lbrec, new_inflen, new_lbrec;
2241 uint32_t max_len;
2242 uint32_t num_lb, len, flags, lb_num;
2243 uint32_t run_start;
2244 uint32_t slot_offset, replace_len, replace;
2245 int addr_type, icbflags;
2246 // int udf_c_type = buf->b_udf_c_type;
2247 int lb_size, run_length, eof;
2248 int slot, cpy_slot, cpy_slots, restart_slot;
2249 int error;
2250
2251 DPRINTF(ALLOC, ("udf_record_allocation_in_node\n"));
2252
2253 #if 0
2254 /* XXX disable sanity check for now */
2255 /* sanity check ... should be panic ? */
2256 if ((udf_c_type != UDF_C_USERDATA) && (udf_c_type != UDF_C_FIDS))
2257 return;
2258 #endif
2259
2260 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
2261 max_len = ((UDF_EXT_MAXLEN / lb_size) * lb_size);
2262
2263 /* do the job */
2264 UDF_LOCK_NODE(udf_node, 0); /* XXX can deadlock ? */
2265 udf_node_sanity_check(udf_node, &orig_inflen, &orig_lbrec);
2266
2267 fe = udf_node->fe;
2268 efe = udf_node->efe;
2269 if (fe) {
2270 icbtag = &fe->icbtag;
2271 inflen = udf_rw64(fe->inf_len);
2272 } else {
2273 icbtag = &efe->icbtag;
2274 inflen = udf_rw64(efe->inf_len);
2275 }
2276
2277 /* do check if `till' is not past file information length */
2278 from = buf->b_lblkno * lb_size;
2279 till = MIN(inflen, from + buf->b_resid);
2280
2281 num_lb = (till - from + lb_size -1) / lb_size;
2282
2283 DPRINTF(ALLOC, ("record allocation from %"PRIu64" + %d\n", from, buf->b_bcount));
2284
2285 icbflags = udf_rw16(icbtag->flags);
2286 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
2287
2288 if (addr_type == UDF_ICB_INTERN_ALLOC) {
2289 /* nothing to do */
2290 /* XXX clean up rest of node? just in case? */
2291 UDF_UNLOCK_NODE(udf_node, 0);
2292 return;
2293 }
2294
2295 slot = 0;
2296 cpy_slot = 0;
2297 foffset = 0;
2298
2299 /* 1) copy till first overlap piece to the rewrite buffer */
2300 for (;;) {
2301 udf_get_adslot(udf_node, slot, &s_ad, &eof);
2302 if (eof) {
2303 DPRINTF(WRITE,
2304 ("Record allocation in node "
2305 "failed: encountered EOF\n"));
2306 UDF_UNLOCK_NODE(udf_node, 0);
2307 buf->b_error = EINVAL;
2308 return;
2309 }
2310 len = udf_rw32(s_ad.len);
2311 flags = UDF_EXT_FLAGS(len);
2312 len = UDF_EXT_LEN(len);
2313
2314 if (flags == UDF_EXT_REDIRECT) {
2315 slot++;
2316 continue;
2317 }
2318
2319 end_foffset = foffset + len;
2320 if (end_foffset > from)
2321 break; /* found */
2322
2323 node_ad_cpy[cpy_slot++] = s_ad;
2324
2325 DPRINTF(ALLOC, ("\t1: vp %d, lb %d, len %d, flags %d "
2326 "-> stack\n",
2327 udf_rw16(s_ad.loc.part_num),
2328 udf_rw32(s_ad.loc.lb_num),
2329 UDF_EXT_LEN(udf_rw32(s_ad.len)),
2330 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
2331
2332 foffset = end_foffset;
2333 slot++;
2334 }
2335 restart_slot = slot;
2336 restart_foffset = foffset;
2337
2338 /* 2) trunc overlapping slot at overlap and copy it */
2339 slot_offset = from - foffset;
2340 if (slot_offset > 0) {
2341 DPRINTF(ALLOC, ("\tslot_offset = %d, flags = %d (%d)\n",
2342 slot_offset, flags >> 30, flags));
2343
2344 s_ad.len = udf_rw32(slot_offset | flags);
2345 node_ad_cpy[cpy_slot++] = s_ad;
2346
2347 DPRINTF(ALLOC, ("\t2: vp %d, lb %d, len %d, flags %d "
2348 "-> stack\n",
2349 udf_rw16(s_ad.loc.part_num),
2350 udf_rw32(s_ad.loc.lb_num),
2351 UDF_EXT_LEN(udf_rw32(s_ad.len)),
2352 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
2353 }
2354 foffset += slot_offset;
2355
2356 /* 3) insert new mappings */
2357 memset(&s_ad, 0, sizeof(struct long_ad));
2358 lb_num = 0;
2359 for (lb_num = 0; lb_num < num_lb; lb_num++) {
2360 run_start = mapping[lb_num];
2361 run_length = 1;
2362 while (lb_num < num_lb-1) {
2363 if (mapping[lb_num+1] != mapping[lb_num]+1)
2364 if (mapping[lb_num+1] != mapping[lb_num])
2365 break;
2366 run_length++;
2367 lb_num++;
2368 }
2369 /* insert slot for this mapping */
2370 len = run_length * lb_size;
2371
2372 /* bounds checking */
2373 if (foffset + len > till)
2374 len = till - foffset;
2375 KASSERT(foffset + len <= inflen);
2376
2377 s_ad.len = udf_rw32(len | UDF_EXT_ALLOCATED);
2378 s_ad.loc.part_num = udf_rw16(vpart_num);
2379 s_ad.loc.lb_num = udf_rw32(run_start);
2380
2381 foffset += len;
2382
2383 /* paranoia */
2384 if (len == 0) {
2385 DPRINTF(WRITE,
2386 ("Record allocation in node "
2387 "failed: insert failed\n"));
2388 UDF_UNLOCK_NODE(udf_node, 0);
2389 buf->b_error = EINVAL;
2390 return;
2391 }
2392 node_ad_cpy[cpy_slot++] = s_ad;
2393
2394 DPRINTF(ALLOC, ("\t3: insert new mapping vp %d lb %d, len %d, "
2395 "flags %d -> stack\n",
2396 udf_rw16(s_ad.loc.part_num), udf_rw32(s_ad.loc.lb_num),
2397 UDF_EXT_LEN(udf_rw32(s_ad.len)),
2398 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
2399 }
2400
2401 /* 4) pop replaced length */
2402 slot = restart_slot;
2403 foffset = restart_foffset;
2404
2405 replace_len = till - foffset; /* total amount of bytes to pop */
2406 slot_offset = from - foffset; /* offset in first encounted slot */
2407 KASSERT((slot_offset % lb_size) == 0);
2408
2409 for (;;) {
2410 udf_get_adslot(udf_node, slot, &s_ad, &eof);
2411 if (eof)
2412 break;
2413
2414 len = udf_rw32(s_ad.len);
2415 flags = UDF_EXT_FLAGS(len);
2416 len = UDF_EXT_LEN(len);
2417 lb_num = udf_rw32(s_ad.loc.lb_num);
2418
2419 if (flags == UDF_EXT_REDIRECT) {
2420 slot++;
2421 continue;
2422 }
2423
2424 DPRINTF(ALLOC, ("\t4i: got slot %d, slot_offset %d, "
2425 "replace_len %d, "
2426 "vp %d, lb %d, len %d, flags %d\n",
2427 slot, slot_offset, replace_len,
2428 udf_rw16(s_ad.loc.part_num),
2429 udf_rw32(s_ad.loc.lb_num),
2430 UDF_EXT_LEN(udf_rw32(s_ad.len)),
2431 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
2432
2433 /* adjust for slot offset */
2434 if (slot_offset) {
2435 DPRINTF(ALLOC, ("\t4s: skipping %d\n", slot_offset));
2436 lb_num += slot_offset / lb_size;
2437 len -= slot_offset;
2438 foffset += slot_offset;
2439 replace_len -= slot_offset;
2440
2441 /* mark adjusted */
2442 slot_offset = 0;
2443 }
2444
2445 /* advance for (the rest of) this slot */
2446 replace = MIN(len, replace_len);
2447 DPRINTF(ALLOC, ("\t4d: replacing %d\n", replace));
2448
2449 /* advance for this slot */
2450 if (replace) {
2451 /* note: dont round DOWN on num_lb since we then
2452 * forget the last partial one */
2453 num_lb = (replace + lb_size - 1) / lb_size;
2454 if (flags != UDF_EXT_FREE) {
2455 udf_free_allocated_space(ump, lb_num,
2456 udf_rw16(s_ad.loc.part_num), num_lb);
2457 }
2458 lb_num += num_lb;
2459 len -= replace;
2460 foffset += replace;
2461 replace_len -= replace;
2462 }
2463
2464 /* do we have a slot tail ? */
2465 if (len) {
2466 KASSERT(foffset % lb_size == 0);
2467
2468 /* we arrived at our point, push remainder */
2469 s_ad.len = udf_rw32(len | flags);
2470 s_ad.loc.lb_num = udf_rw32(lb_num);
2471 if (flags == UDF_EXT_FREE)
2472 s_ad.loc.lb_num = udf_rw32(0);
2473 node_ad_cpy[cpy_slot++] = s_ad;
2474 foffset += len;
2475 slot++;
2476
2477 DPRINTF(ALLOC, ("\t4: vp %d, lb %d, len %d, flags %d "
2478 "-> stack\n",
2479 udf_rw16(s_ad.loc.part_num),
2480 udf_rw32(s_ad.loc.lb_num),
2481 UDF_EXT_LEN(udf_rw32(s_ad.len)),
2482 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
2483 break;
2484 }
2485
2486 slot++;
2487 }
2488
2489 /* 5) copy remainder */
2490 for (;;) {
2491 udf_get_adslot(udf_node, slot, &s_ad, &eof);
2492 if (eof)
2493 break;
2494
2495 len = udf_rw32(s_ad.len);
2496 flags = UDF_EXT_FLAGS(len);
2497 len = UDF_EXT_LEN(len);
2498
2499 if (flags == UDF_EXT_REDIRECT) {
2500 slot++;
2501 continue;
2502 }
2503
2504 node_ad_cpy[cpy_slot++] = s_ad;
2505
2506 DPRINTF(ALLOC, ("\t5: insert new mapping "
2507 "vp %d lb %d, len %d, flags %d "
2508 "-> stack\n",
2509 udf_rw16(s_ad.loc.part_num),
2510 udf_rw32(s_ad.loc.lb_num),
2511 UDF_EXT_LEN(udf_rw32(s_ad.len)),
2512 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
2513
2514 slot++;
2515 }
2516
2517 /* 6) reset node descriptors */
2518 udf_wipe_adslots(udf_node);
2519
2520 /* 7) copy back extents; merge when possible. Recounting on the fly */
2521 cpy_slots = cpy_slot;
2522
2523 c_ad = node_ad_cpy[0];
2524 slot = 0;
2525 DPRINTF(ALLOC, ("\t7s: stack -> got mapping vp %d "
2526 "lb %d, len %d, flags %d\n",
2527 udf_rw16(c_ad.loc.part_num),
2528 udf_rw32(c_ad.loc.lb_num),
2529 UDF_EXT_LEN(udf_rw32(c_ad.len)),
2530 UDF_EXT_FLAGS(udf_rw32(c_ad.len)) >> 30));
2531
2532 for (cpy_slot = 1; cpy_slot < cpy_slots; cpy_slot++) {
2533 s_ad = node_ad_cpy[cpy_slot];
2534
2535 DPRINTF(ALLOC, ("\t7i: stack -> got mapping vp %d "
2536 "lb %d, len %d, flags %d\n",
2537 udf_rw16(s_ad.loc.part_num),
2538 udf_rw32(s_ad.loc.lb_num),
2539 UDF_EXT_LEN(udf_rw32(s_ad.len)),
2540 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
2541
2542 /* see if we can merge */
2543 if (udf_ads_merge(max_len, lb_size, &c_ad, &s_ad)) {
2544 /* not mergable (anymore) */
2545 DPRINTF(ALLOC, ("\t7: appending vp %d lb %d, "
2546 "len %d, flags %d\n",
2547 udf_rw16(c_ad.loc.part_num),
2548 udf_rw32(c_ad.loc.lb_num),
2549 UDF_EXT_LEN(udf_rw32(c_ad.len)),
2550 UDF_EXT_FLAGS(udf_rw32(c_ad.len)) >> 30));
2551
2552 error = udf_append_adslot(udf_node, &slot, &c_ad);
2553 if (error) {
2554 buf->b_error = error;
2555 goto out;
2556 }
2557 c_ad = s_ad;
2558 slot++;
2559 }
2560 }
2561
2562 /* 8) push rest slot (if any) */
2563 if (UDF_EXT_LEN(c_ad.len) > 0) {
2564 DPRINTF(ALLOC, ("\t8: last append vp %d lb %d, "
2565 "len %d, flags %d\n",
2566 udf_rw16(c_ad.loc.part_num),
2567 udf_rw32(c_ad.loc.lb_num),
2568 UDF_EXT_LEN(udf_rw32(c_ad.len)),
2569 UDF_EXT_FLAGS(udf_rw32(c_ad.len)) >> 30));
2570
2571 error = udf_append_adslot(udf_node, &slot, &c_ad);
2572 if (error) {
2573 buf->b_error = error;
2574 goto out;
2575 }
2576 }
2577
2578 out:
2579 udf_count_alloc_exts(udf_node);
2580
2581 /* the node's descriptors should now be sane */
2582 udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
2583 UDF_UNLOCK_NODE(udf_node, 0);
2584
2585 KASSERT(orig_inflen == new_inflen);
2586 KASSERT(new_lbrec >= orig_lbrec);
2587
2588 return;
2589 }
2590
2591 /* --------------------------------------------------------------------- */
2592
2593 int
udf_grow_node(struct udf_node * udf_node,uint64_t new_size)2594 udf_grow_node(struct udf_node *udf_node, uint64_t new_size)
2595 {
2596 struct vnode *vp = udf_node->vnode;
2597 struct udf_mount *ump = udf_node->ump;
2598 struct file_entry *fe;
2599 struct extfile_entry *efe;
2600 struct icb_tag *icbtag;
2601 struct long_ad c_ad, s_ad;
2602 uint64_t size_diff, old_size, inflen, objsize, chunk, append_len;
2603 uint64_t foffset, end_foffset;
2604 uint64_t orig_inflen, orig_lbrec, new_inflen, new_lbrec;
2605 uint32_t lb_size, unit_size, dscr_size, crclen, lastblock_grow;
2606 uint32_t icbflags, len, flags, max_len;
2607 uint32_t max_l_ad, l_ad, l_ea;
2608 uint16_t my_part, dst_part;
2609 uint8_t *evacuated_data;
2610 int addr_type;
2611 int slot;
2612 int eof, error;
2613
2614 DPRINTF(ALLOC, ("udf_grow_node\n"));
2615
2616 UDF_LOCK_NODE(udf_node, 0);
2617 udf_node_sanity_check(udf_node, &orig_inflen, &orig_lbrec);
2618
2619 lb_size = udf_rw32(ump->logical_vol->lb_size);
2620
2621 /* max_len in unit's IFF its a metadata node or metadata mirror node */
2622 unit_size = lb_size;
2623 if ((udf_node == ump->metadata_node) || (udf_node == ump->metadatamirror_node))
2624 unit_size = ump->metadata_alloc_unit_size * lb_size;
2625 max_len = ((UDF_EXT_MAXLEN / unit_size) * unit_size);
2626
2627 fe = udf_node->fe;
2628 efe = udf_node->efe;
2629 if (fe) {
2630 icbtag = &fe->icbtag;
2631 inflen = udf_rw64(fe->inf_len);
2632 objsize = inflen;
2633 dscr_size = sizeof(struct file_entry) -1;
2634 l_ea = udf_rw32(fe->l_ea);
2635 l_ad = udf_rw32(fe->l_ad);
2636 } else {
2637 icbtag = &efe->icbtag;
2638 inflen = udf_rw64(efe->inf_len);
2639 objsize = udf_rw64(efe->obj_size);
2640 dscr_size = sizeof(struct extfile_entry) -1;
2641 l_ea = udf_rw32(efe->l_ea);
2642 l_ad = udf_rw32(efe->l_ad);
2643 }
2644 max_l_ad = lb_size - dscr_size - l_ea;
2645
2646 icbflags = udf_rw16(icbtag->flags);
2647 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
2648
2649 old_size = inflen;
2650 size_diff = new_size - old_size;
2651
2652 DPRINTF(ALLOC, ("\tfrom %"PRIu64" to %"PRIu64"\n", old_size, new_size));
2653
2654 evacuated_data = NULL;
2655 if (addr_type == UDF_ICB_INTERN_ALLOC) {
2656 if (l_ad + size_diff <= max_l_ad) {
2657 /* only reflect size change directly in the node */
2658 inflen += size_diff;
2659 objsize += size_diff;
2660 l_ad += size_diff;
2661 crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea + l_ad;
2662 if (fe) {
2663 fe->inf_len = udf_rw64(inflen);
2664 fe->l_ad = udf_rw32(l_ad);
2665 fe->tag.desc_crc_len = udf_rw16(crclen);
2666 } else {
2667 efe->inf_len = udf_rw64(inflen);
2668 efe->obj_size = udf_rw64(objsize);
2669 efe->l_ad = udf_rw32(l_ad);
2670 efe->tag.desc_crc_len = udf_rw16(crclen);
2671 }
2672 error = 0;
2673
2674 /* set new size for uvm */
2675 uvm_vnp_setwritesize(vp, new_size);
2676 uvm_vnp_setsize(vp, new_size);
2677
2678 #if 0
2679 /* zero append space in buffer */
2680 ubc_zerorange(&vp->v_uobj, old_size,
2681 new_size - old_size, UBC_VNODE_FLAGS(vp));
2682 #endif
2683
2684 udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
2685
2686 /* unlock */
2687 UDF_UNLOCK_NODE(udf_node, 0);
2688
2689 KASSERT(new_inflen == orig_inflen + size_diff);
2690 KASSERT(new_lbrec == orig_lbrec);
2691 KASSERT(new_lbrec == 0);
2692 return 0;
2693 }
2694
2695 DPRINTF(ALLOC, ("\tCONVERT from internal\n"));
2696
2697 if (old_size > 0) {
2698 /* allocate some space and copy in the stuff to keep */
2699 evacuated_data = malloc(lb_size, M_UDFTEMP, M_WAITOK);
2700 memset(evacuated_data, 0, lb_size);
2701
2702 /* node is locked, so safe to exit mutex */
2703 UDF_UNLOCK_NODE(udf_node, 0);
2704
2705 /* read in using the `normal' vn_rdwr() */
2706 error = vn_rdwr(UIO_READ, udf_node->vnode,
2707 evacuated_data, old_size, 0,
2708 UIO_SYSSPACE, IO_ALTSEMANTICS | IO_NODELOCKED,
2709 FSCRED, NULL, NULL);
2710
2711 /* enter again */
2712 UDF_LOCK_NODE(udf_node, 0);
2713 }
2714
2715 /* convert to a normal alloc and select type */
2716 my_part = udf_rw16(udf_node->loc.loc.part_num);
2717 dst_part = udf_get_record_vpart(ump, udf_get_c_type(udf_node));
2718 addr_type = UDF_ICB_SHORT_ALLOC;
2719 if (dst_part != my_part)
2720 addr_type = UDF_ICB_LONG_ALLOC;
2721
2722 icbflags &= ~UDF_ICB_TAG_FLAGS_ALLOC_MASK;
2723 icbflags |= addr_type;
2724 icbtag->flags = udf_rw16(icbflags);
2725
2726 /* wipe old descriptor space */
2727 udf_wipe_adslots(udf_node);
2728
2729 memset(&c_ad, 0, sizeof(struct long_ad));
2730 c_ad.len = udf_rw32(old_size | UDF_EXT_FREE);
2731 c_ad.loc.part_num = udf_rw16(0); /* not relevant */
2732 c_ad.loc.lb_num = udf_rw32(0); /* not relevant */
2733
2734 slot = 0;
2735 } else {
2736 /* goto the last entry (if any) */
2737 slot = 0;
2738 foffset = 0;
2739 memset(&c_ad, 0, sizeof(struct long_ad));
2740 for (;;) {
2741 udf_get_adslot(udf_node, slot, &c_ad, &eof);
2742 if (eof)
2743 break;
2744
2745 len = udf_rw32(c_ad.len);
2746 flags = UDF_EXT_FLAGS(len);
2747 len = UDF_EXT_LEN(len);
2748
2749 end_foffset = foffset + len;
2750 if (flags != UDF_EXT_REDIRECT)
2751 foffset = end_foffset;
2752
2753 slot++;
2754 }
2755 /* at end of adslots */
2756
2757 /* special case if the old size was zero, then there is no last slot */
2758 if (old_size == 0) {
2759 c_ad.len = udf_rw32(0 | UDF_EXT_FREE);
2760 c_ad.loc.part_num = udf_rw16(0); /* not relevant */
2761 c_ad.loc.lb_num = udf_rw32(0); /* not relevant */
2762 } else {
2763 /* refetch last slot */
2764 slot--;
2765 udf_get_adslot(udf_node, slot, &c_ad, &eof);
2766 }
2767 }
2768
2769 /*
2770 * If the length of the last slot is not a multiple of lb_size, adjust
2771 * length so that it is; don't forget to adjust `append_len'! relevant for
2772 * extending existing files
2773 */
2774 len = udf_rw32(c_ad.len);
2775 flags = UDF_EXT_FLAGS(len);
2776 len = UDF_EXT_LEN(len);
2777
2778 lastblock_grow = 0;
2779 if (len % lb_size > 0) {
2780 lastblock_grow = lb_size - (len % lb_size);
2781 lastblock_grow = MIN(size_diff, lastblock_grow);
2782 len += lastblock_grow;
2783 c_ad.len = udf_rw32(len | flags);
2784
2785 /* TODO zero appended space in buffer! */
2786 /* using ubc_zerorange(&vp->v_uobj, old_size, */
2787 /* new_size - old_size, UBC_VNODE_FLAGS(vp)); ? */
2788 }
2789 memset(&s_ad, 0, sizeof(struct long_ad));
2790
2791 /* size_diff can be bigger than allowed, so grow in chunks */
2792 append_len = size_diff - lastblock_grow;
2793 while (append_len > 0) {
2794 chunk = MIN(append_len, max_len);
2795 s_ad.len = udf_rw32(chunk | UDF_EXT_FREE);
2796 s_ad.loc.part_num = udf_rw16(0);
2797 s_ad.loc.lb_num = udf_rw32(0);
2798
2799 if (udf_ads_merge(max_len, lb_size, &c_ad, &s_ad)) {
2800 /* not mergable (anymore) */
2801 error = udf_append_adslot(udf_node, &slot, &c_ad);
2802 if (error)
2803 goto errorout;
2804 slot++;
2805 c_ad = s_ad;
2806 memset(&s_ad, 0, sizeof(struct long_ad));
2807 }
2808 append_len -= chunk;
2809 }
2810
2811 /* if there is a rest piece in the accumulator, append it */
2812 if (UDF_EXT_LEN(udf_rw32(c_ad.len)) > 0) {
2813 error = udf_append_adslot(udf_node, &slot, &c_ad);
2814 if (error)
2815 goto errorout;
2816 slot++;
2817 }
2818
2819 /* if there is a rest piece that didn't fit, append it */
2820 if (UDF_EXT_LEN(udf_rw32(s_ad.len)) > 0) {
2821 error = udf_append_adslot(udf_node, &slot, &s_ad);
2822 if (error)
2823 goto errorout;
2824 slot++;
2825 }
2826
2827 inflen += size_diff;
2828 objsize += size_diff;
2829 if (fe) {
2830 fe->inf_len = udf_rw64(inflen);
2831 } else {
2832 efe->inf_len = udf_rw64(inflen);
2833 efe->obj_size = udf_rw64(objsize);
2834 }
2835 error = 0;
2836
2837 if (evacuated_data) {
2838 /* set new write size for uvm */
2839 uvm_vnp_setwritesize(vp, old_size);
2840
2841 /* write out evacuated data */
2842 error = vn_rdwr(UIO_WRITE, udf_node->vnode,
2843 evacuated_data, old_size, 0,
2844 UIO_SYSSPACE, IO_ALTSEMANTICS | IO_NODELOCKED,
2845 FSCRED, NULL, NULL);
2846 uvm_vnp_setsize(vp, old_size);
2847 }
2848
2849 errorout:
2850 if (evacuated_data)
2851 free(evacuated_data, M_UDFTEMP);
2852
2853 udf_count_alloc_exts(udf_node);
2854
2855 udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
2856 UDF_UNLOCK_NODE(udf_node, 0);
2857
2858 KASSERT(new_inflen == orig_inflen + size_diff);
2859 KASSERT(new_lbrec == orig_lbrec);
2860
2861 return error;
2862 }
2863
2864 /* --------------------------------------------------------------------- */
2865
2866 int
udf_shrink_node(struct udf_node * udf_node,uint64_t new_size)2867 udf_shrink_node(struct udf_node *udf_node, uint64_t new_size)
2868 {
2869 struct vnode *vp = udf_node->vnode;
2870 struct udf_mount *ump = udf_node->ump;
2871 struct file_entry *fe;
2872 struct extfile_entry *efe;
2873 struct icb_tag *icbtag;
2874 struct long_ad c_ad, s_ad, *node_ad_cpy;
2875 uint64_t size_diff, old_size, inflen, objsize;
2876 uint64_t foffset, end_foffset;
2877 uint64_t orig_inflen, orig_lbrec, new_inflen, new_lbrec;
2878 uint32_t lb_size, unit_size, dscr_size, crclen;
2879 uint32_t slot_offset, slot_offset_lb;
2880 uint32_t len, flags, max_len;
2881 uint32_t num_lb, lb_num;
2882 uint32_t max_l_ad, l_ad, l_ea;
2883 uint16_t vpart_num;
2884 uint8_t *data_pos;
2885 int icbflags, addr_type;
2886 int slot, cpy_slot, cpy_slots;
2887 int eof, error;
2888
2889 DPRINTF(ALLOC, ("udf_shrink_node\n"));
2890
2891 UDF_LOCK_NODE(udf_node, 0);
2892 udf_node_sanity_check(udf_node, &orig_inflen, &orig_lbrec);
2893
2894 lb_size = udf_rw32(ump->logical_vol->lb_size);
2895
2896 /* max_len in unit's IFF its a metadata node or metadata mirror node */
2897 unit_size = lb_size;
2898 if ((udf_node == ump->metadata_node) || (udf_node == ump->metadatamirror_node))
2899 unit_size = ump->metadata_alloc_unit_size * lb_size;
2900 max_len = ((UDF_EXT_MAXLEN / unit_size) * unit_size);
2901
2902 /* do the work */
2903 fe = udf_node->fe;
2904 efe = udf_node->efe;
2905 if (fe) {
2906 icbtag = &fe->icbtag;
2907 inflen = udf_rw64(fe->inf_len);
2908 objsize = inflen;
2909 dscr_size = sizeof(struct file_entry) -1;
2910 l_ea = udf_rw32(fe->l_ea);
2911 l_ad = udf_rw32(fe->l_ad);
2912 data_pos = (uint8_t *) fe + dscr_size + l_ea;
2913 } else {
2914 icbtag = &efe->icbtag;
2915 inflen = udf_rw64(efe->inf_len);
2916 objsize = udf_rw64(efe->obj_size);
2917 dscr_size = sizeof(struct extfile_entry) -1;
2918 l_ea = udf_rw32(efe->l_ea);
2919 l_ad = udf_rw32(efe->l_ad);
2920 data_pos = (uint8_t *) efe + dscr_size + l_ea;
2921 }
2922 max_l_ad = lb_size - dscr_size - l_ea;
2923
2924 icbflags = udf_rw16(icbtag->flags);
2925 addr_type = icbflags & UDF_ICB_TAG_FLAGS_ALLOC_MASK;
2926
2927 old_size = inflen;
2928 size_diff = old_size - new_size;
2929
2930 DPRINTF(ALLOC, ("\tfrom %"PRIu64" to %"PRIu64"\n", old_size, new_size));
2931
2932 /* shrink the node to its new size */
2933 if (addr_type == UDF_ICB_INTERN_ALLOC) {
2934 /* only reflect size change directly in the node */
2935 KASSERT(new_size <= max_l_ad);
2936 inflen -= size_diff;
2937 objsize -= size_diff;
2938 l_ad -= size_diff;
2939 crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea + l_ad;
2940 if (fe) {
2941 fe->inf_len = udf_rw64(inflen);
2942 fe->l_ad = udf_rw32(l_ad);
2943 fe->tag.desc_crc_len = udf_rw16(crclen);
2944 } else {
2945 efe->inf_len = udf_rw64(inflen);
2946 efe->obj_size = udf_rw64(objsize);
2947 efe->l_ad = udf_rw32(l_ad);
2948 efe->tag.desc_crc_len = udf_rw16(crclen);
2949 }
2950 error = 0;
2951
2952 /* clear the space in the descriptor */
2953 KASSERT(old_size >= new_size);
2954 memset(data_pos + new_size, 0, old_size - new_size);
2955
2956 /* TODO zero appended space in buffer! */
2957 /* using ubc_zerorange(&vp->v_uobj, old_size, */
2958 /* old_size - new_size, UBC_VNODE_FLAGS(vp)); ? */
2959
2960 /* set new size for uvm */
2961 uvm_vnp_setsize(vp, new_size);
2962
2963 udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
2964 UDF_UNLOCK_NODE(udf_node, 0);
2965
2966 KASSERT(new_inflen == orig_inflen - size_diff);
2967 KASSERT(new_lbrec == orig_lbrec);
2968 KASSERT(new_lbrec == 0);
2969
2970 return 0;
2971 }
2972
2973 /* setup node cleanup extents copy space */
2974 node_ad_cpy = malloc(lb_size * UDF_MAX_ALLOC_EXTENTS,
2975 M_UDFMNT, M_WAITOK);
2976 memset(node_ad_cpy, 0, lb_size * UDF_MAX_ALLOC_EXTENTS);
2977
2978 /*
2979 * Shrink the node by releasing the allocations and truncate the last
2980 * allocation to the new size. If the new size fits into the
2981 * allocation descriptor itself, transform it into an
2982 * UDF_ICB_INTERN_ALLOC.
2983 */
2984 slot = 0;
2985 cpy_slot = 0;
2986 foffset = 0;
2987
2988 /* 1) copy till first overlap piece to the rewrite buffer */
2989 for (;;) {
2990 udf_get_adslot(udf_node, slot, &s_ad, &eof);
2991 if (eof) {
2992 DPRINTF(WRITE,
2993 ("Shrink node failed: "
2994 "encountered EOF\n"));
2995 error = EINVAL;
2996 goto errorout; /* panic? */
2997 }
2998 len = udf_rw32(s_ad.len);
2999 flags = UDF_EXT_FLAGS(len);
3000 len = UDF_EXT_LEN(len);
3001
3002 if (flags == UDF_EXT_REDIRECT) {
3003 slot++;
3004 continue;
3005 }
3006
3007 end_foffset = foffset + len;
3008 if (end_foffset > new_size)
3009 break; /* found */
3010
3011 node_ad_cpy[cpy_slot++] = s_ad;
3012
3013 DPRINTF(ALLOC, ("\t1: vp %d, lb %d, len %d, flags %d "
3014 "-> stack\n",
3015 udf_rw16(s_ad.loc.part_num),
3016 udf_rw32(s_ad.loc.lb_num),
3017 UDF_EXT_LEN(udf_rw32(s_ad.len)),
3018 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
3019
3020 foffset = end_foffset;
3021 slot++;
3022 }
3023 slot_offset = new_size - foffset;
3024
3025 /* 2) trunc overlapping slot at overlap and copy it */
3026 if (slot_offset > 0) {
3027 lb_num = udf_rw32(s_ad.loc.lb_num);
3028 vpart_num = udf_rw16(s_ad.loc.part_num);
3029
3030 if (flags == UDF_EXT_ALLOCATED) {
3031 /* calculate extent in lb, and offset in lb */
3032 num_lb = (len + lb_size -1) / lb_size;
3033 slot_offset_lb = (slot_offset + lb_size -1) / lb_size;
3034
3035 /* adjust our slot */
3036 lb_num += slot_offset_lb;
3037 num_lb -= slot_offset_lb;
3038
3039 udf_free_allocated_space(ump, lb_num, vpart_num, num_lb);
3040 }
3041
3042 s_ad.len = udf_rw32(slot_offset | flags);
3043 node_ad_cpy[cpy_slot++] = s_ad;
3044 slot++;
3045
3046 DPRINTF(ALLOC, ("\t2: vp %d, lb %d, len %d, flags %d "
3047 "-> stack\n",
3048 udf_rw16(s_ad.loc.part_num),
3049 udf_rw32(s_ad.loc.lb_num),
3050 UDF_EXT_LEN(udf_rw32(s_ad.len)),
3051 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
3052 }
3053
3054 /* 3) delete remainder */
3055 for (;;) {
3056 udf_get_adslot(udf_node, slot, &s_ad, &eof);
3057 if (eof)
3058 break;
3059
3060 len = udf_rw32(s_ad.len);
3061 flags = UDF_EXT_FLAGS(len);
3062 len = UDF_EXT_LEN(len);
3063
3064 if (flags == UDF_EXT_REDIRECT) {
3065 slot++;
3066 continue;
3067 }
3068
3069 DPRINTF(ALLOC, ("\t3: delete remainder "
3070 "vp %d lb %d, len %d, flags %d\n",
3071 udf_rw16(s_ad.loc.part_num),
3072 udf_rw32(s_ad.loc.lb_num),
3073 UDF_EXT_LEN(udf_rw32(s_ad.len)),
3074 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
3075
3076 if (flags == UDF_EXT_ALLOCATED) {
3077 lb_num = udf_rw32(s_ad.loc.lb_num);
3078 vpart_num = udf_rw16(s_ad.loc.part_num);
3079 num_lb = (len + lb_size - 1) / lb_size;
3080
3081 udf_free_allocated_space(ump, lb_num, vpart_num,
3082 num_lb);
3083 }
3084
3085 slot++;
3086 }
3087
3088 /* 4) if it will fit into the descriptor then convert */
3089 if (new_size < max_l_ad) {
3090 /*
3091 * rescue/evacuate old piece by reading it in, and convert it
3092 * to internal alloc.
3093 */
3094 if (new_size == 0) {
3095 /* XXX/TODO only for zero sizing now */
3096 udf_wipe_adslots(udf_node);
3097
3098 icbflags &= ~UDF_ICB_TAG_FLAGS_ALLOC_MASK;
3099 icbflags |= UDF_ICB_INTERN_ALLOC;
3100 icbtag->flags = udf_rw16(icbflags);
3101
3102 inflen -= size_diff; KASSERT(inflen == 0);
3103 objsize -= size_diff;
3104 l_ad = new_size;
3105 crclen = dscr_size - UDF_DESC_TAG_LENGTH + l_ea + l_ad;
3106 if (fe) {
3107 fe->inf_len = udf_rw64(inflen);
3108 fe->l_ad = udf_rw32(l_ad);
3109 fe->tag.desc_crc_len = udf_rw16(crclen);
3110 } else {
3111 efe->inf_len = udf_rw64(inflen);
3112 efe->obj_size = udf_rw64(objsize);
3113 efe->l_ad = udf_rw32(l_ad);
3114 efe->tag.desc_crc_len = udf_rw16(crclen);
3115 }
3116 /* eventually copy in evacuated piece */
3117 /* set new size for uvm */
3118 uvm_vnp_setsize(vp, new_size);
3119
3120 free(node_ad_cpy, M_UDFMNT);
3121 udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
3122
3123 UDF_UNLOCK_NODE(udf_node, 0);
3124
3125 KASSERT(new_inflen == orig_inflen - size_diff);
3126 KASSERT(new_inflen == 0);
3127 KASSERT(new_lbrec == 0);
3128
3129 return 0;
3130 }
3131
3132 printf("UDF_SHRINK_NODE: could convert to internal alloc!\n");
3133 }
3134
3135 /* 5) reset node descriptors */
3136 udf_wipe_adslots(udf_node);
3137
3138 /* 6) copy back extents; merge when possible. Recounting on the fly */
3139 cpy_slots = cpy_slot;
3140
3141 c_ad = node_ad_cpy[0];
3142 slot = 0;
3143 for (cpy_slot = 1; cpy_slot < cpy_slots; cpy_slot++) {
3144 s_ad = node_ad_cpy[cpy_slot];
3145
3146 DPRINTF(ALLOC, ("\t6: stack -> got mapping vp %d "
3147 "lb %d, len %d, flags %d\n",
3148 udf_rw16(s_ad.loc.part_num),
3149 udf_rw32(s_ad.loc.lb_num),
3150 UDF_EXT_LEN(udf_rw32(s_ad.len)),
3151 UDF_EXT_FLAGS(udf_rw32(s_ad.len)) >> 30));
3152
3153 /* see if we can merge */
3154 if (udf_ads_merge(max_len, lb_size, &c_ad, &s_ad)) {
3155 /* not mergable (anymore) */
3156 DPRINTF(ALLOC, ("\t6: appending vp %d lb %d, "
3157 "len %d, flags %d\n",
3158 udf_rw16(c_ad.loc.part_num),
3159 udf_rw32(c_ad.loc.lb_num),
3160 UDF_EXT_LEN(udf_rw32(c_ad.len)),
3161 UDF_EXT_FLAGS(udf_rw32(c_ad.len)) >> 30));
3162
3163 error = udf_append_adslot(udf_node, &slot, &c_ad);
3164 if (error)
3165 goto errorout; /* panic? */
3166 c_ad = s_ad;
3167 slot++;
3168 }
3169 }
3170
3171 /* 7) push rest slot (if any) */
3172 if (UDF_EXT_LEN(c_ad.len) > 0) {
3173 DPRINTF(ALLOC, ("\t7: last append vp %d lb %d, "
3174 "len %d, flags %d\n",
3175 udf_rw16(c_ad.loc.part_num),
3176 udf_rw32(c_ad.loc.lb_num),
3177 UDF_EXT_LEN(udf_rw32(c_ad.len)),
3178 UDF_EXT_FLAGS(udf_rw32(c_ad.len)) >> 30));
3179
3180 error = udf_append_adslot(udf_node, &slot, &c_ad);
3181 if (error)
3182 goto errorout; /* panic? */
3183 ;
3184 }
3185
3186 inflen -= size_diff;
3187 objsize -= size_diff;
3188 if (fe) {
3189 fe->inf_len = udf_rw64(inflen);
3190 } else {
3191 efe->inf_len = udf_rw64(inflen);
3192 efe->obj_size = udf_rw64(objsize);
3193 }
3194 error = 0;
3195
3196 /* set new size for uvm */
3197 uvm_vnp_setsize(vp, new_size);
3198
3199 errorout:
3200 free(node_ad_cpy, M_UDFMNT);
3201
3202 udf_count_alloc_exts(udf_node);
3203
3204 udf_node_sanity_check(udf_node, &new_inflen, &new_lbrec);
3205 UDF_UNLOCK_NODE(udf_node, 0);
3206
3207 KASSERT(new_inflen == orig_inflen - size_diff);
3208
3209 return error;
3210 }
3211
3212