Lines Matching refs:ump
122 udf_dump_discinfo(struct udf_mount *ump)
125 struct mmc_discinfo *di = &ump->discinfo;
188 udf_update_discinfo(struct udf_mount *ump)
190 struct vnode *devvp = ump->devvp;
197 di = &ump->discinfo;
203 udf_dump_discinfo(ump);
235 udf_dump_discinfo(ump);
241 udf_update_trackinfo(struct udf_mount *ump, struct mmc_trackinfo *ti)
243 struct vnode *devvp = ump->devvp;
244 struct mmc_discinfo *di = &ump->discinfo;
281 udf_setup_writeparams(struct udf_mount *ump)
286 if (ump->discinfo.mmc_class == MMC_CLASS_DISC)
298 mmc_writeparams.mmc_class = ump->discinfo.mmc_class;
299 mmc_writeparams.mmc_cur = ump->discinfo.mmc_cur;
311 error = VOP_IOCTL(ump->devvp, MMCSETUPWRITEPARAMS, &mmc_writeparams,
315 error = VOP_IOCTL(ump->devvp, MMCSETUPWRITEPARAMS,
323 udf_synchronise_caches(struct udf_mount *ump)
329 if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
333 if (ump->discinfo.mmc_class == MMC_CLASS_DISC)
340 (void) VOP_IOCTL(ump->devvp, MMCOP, &mmc_op, FKIOCTL, NOCRED);
349 udf_search_tracks(struct udf_mount *ump, struct udf_args *args,
358 args->sessionnr += ump->discinfo.num_sessions;
364 if (args->sessionnr > ump->discinfo.num_sessions)
365 args->sessionnr = ump->discinfo.num_sessions;
369 args->sessionnr = ump->discinfo.num_sessions;
370 if (ump->discinfo.last_session_state == MMC_STATE_EMPTY)
378 num_tracks = ump->discinfo.num_tracks;
379 start_track = ump->discinfo.first_track;
385 error = udf_update_trackinfo(ump, &trackinfo);
398 error = udf_update_trackinfo(ump, &trackinfo);
429 udf_check_track_metadata_overlap(struct udf_mount *ump,
448 KASSERT(ump->node_part == ump->fids_part);
449 part = ump->partitions[ump->vtop[ump->node_part]];
462 sector_size = ump->discinfo.sector_size;
466 fe = ump->metadata_node->fe;
467 efe = ump->metadata_node->efe;
503 ump->metadata_track = *trackinfo;
514 udf_search_writing_tracks(struct udf_mount *ump)
516 struct vnode *devvp = ump->devvp;
534 error = udf_update_discinfo(ump);
538 num_tracks = ump->discinfo.num_tracks;
539 start_track = ump->discinfo.first_track;
543 error = udf_update_trackinfo(ump, &trackinfo);
548 ump->data_track = trackinfo;
549 ump->metadata_track = trackinfo;
558 error = udf_update_trackinfo(ump, &trackinfo);
569 mmc_op.mmc_profile = ump->discinfo.mmc_profile;
578 error = udf_update_trackinfo(ump, &trackinfo);
589 part = ump->partitions[ump->data_part];
593 ump->data_track = trackinfo;
598 node_alloc = ump->vtop_alloc[ump->node_part];
601 udf_check_track_metadata_overlap(ump, &trackinfo);
603 ump->metadata_track = trackinfo;
607 if ((ump->data_track.flags & MMC_TRACKINFO_NWA_VALID) == 0)
610 if ((ump->metadata_track.flags & MMC_TRACKINFO_NWA_VALID) == 0)
842 udf_read_anchor(struct udf_mount *ump, uint32_t sector, struct anchor_vdp **dst)
846 error = udf_read_phys_dscr(ump, sector, M_UDFVOLD,
865 udf_read_anchors(struct udf_mount *ump)
867 struct udf_args *args = &ump->mount_args;
879 error = udf_search_tracks(ump, args, &first_tracknr, &last_tracknr);
882 error = udf_update_trackinfo(ump, &first_track);
886 error = udf_update_trackinfo(ump, &last_track);
890 error = udf_update_trackinfo(ump, &second_track);
903 if (ump->discinfo.mmc_cur & MMC_CAP_SEQUENTIAL) {
909 - ump->discinfo.link_block_penalty;
918 ump->packet_size = first_track.packet_size;
920 ump->packet_size = second_track.packet_size;
922 if (ump->packet_size <= 1) {
924 ump->packet_size = MAXPHYS / ump->discinfo.sector_size;
925 ump->packet_size = MIN(ump->packet_size, 64);
927 KASSERT(ump->packet_size >= 1);
937 anchorsp = ump->anchors;
941 error = udf_read_anchor(ump, positions[anch], anchorsp);
949 ump->first_possible_vat_location = track_start + 2;
950 ump->last_possible_vat_location = track_end + last_track.packet_size;
965 if (udf_node->ump)
966 if (udf_node == udf_node->ump->metadatabitmap_node)
974 udf_get_record_vpart(struct udf_mount *ump, int udf_c_type)
978 vpart_num = ump->data_part;
980 vpart_num = ump->node_part;
982 vpart_num = ump->fids_part;
994 udf_find_raw_phys(struct udf_mount *ump, uint16_t raw_phys_part)
1000 part = ump->partitions[phys_part];
1018 udf_process_vds_descriptor(struct udf_mount *ump, union dscrptr *dscr)
1026 UDF_UPDATE_DSCR(ump->primary_vol, &dscr->pvd);
1029 UDF_UPDATE_DSCR(ump->logical_vol, &dscr->lvd);
1032 UDF_UPDATE_DSCR(ump->unallocated, &dscr->usd);
1036 UDF_UPDATE_DSCR(ump->implementation, &dscr->ivd);
1051 phys_part = udf_find_raw_phys(ump, raw_phys_part);
1058 UDF_UPDATE_DSCR(ump->partitions[phys_part], &dscr->pd);
1077 udf_read_vds_extent(struct udf_mount *ump, uint32_t loc, uint32_t len)
1083 sector_size = ump->discinfo.sector_size;
1088 error = udf_read_phys_dscr(ump, loc, M_UDFVOLD, &dscr);
1104 error = udf_process_vds_descriptor(ump, dscr);
1120 udf_read_vds_space(struct udf_mount *ump)
1122 /* struct udf_args *args = &ump->mount_args; */
1138 anchor = ump->anchors[0];
1139 anchor2 = ump->anchors[1];
1155 error = udf_read_vds_extent(ump, main_loc, main_len);
1158 error = udf_read_vds_extent(ump, reserve_loc, reserve_len);
1177 udf_retrieve_lvint(struct udf_mount *ump)
1185 lb_size = udf_rw32(ump->logical_vol->lb_size);
1186 len = udf_rw32(ump->logical_vol->integrity_seq_loc.len);
1187 lbnum = udf_rw32(ump->logical_vol->integrity_seq_loc.loc);
1190 memset(ump->lvint_trace, 0,
1194 trace = ump->lvint_trace;
1208 error = udf_read_phys_dscr(ump, lbnum, M_UDFVOLD, &dscr);
1270 ump->logvol_integrity = lvint;
1276 udf_loose_lvint_history(struct udf_mount *ump)
1291 lb_size = udf_rw32(ump->logical_vol->lb_size);
1292 packet_size = ump->data_track.packet_size; /* XXX data track */
1295 trace = &ump->lvint_trace[0];
1298 trace = &ump->lvint_trace[ext];
1316 in_trace = &ump->lvint_trace[in_ext];
1320 out_trace = &ump->lvint_trace[out_ext];
1330 in_trace = &ump->lvint_trace[in_ext];
1336 out_trace = &ump->lvint_trace[out_ext];
1350 error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD,
1399 trace = &ump->lvint_trace[out_ext+1];
1407 error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
1433 udf_writeout_lvint(struct udf_mount *ump, int lvflag)
1446 trace = ump->lvint_trace;
1461 logvol_integrity = udf_rw32(ump->logvol_integrity->integrity_type);
1473 error = udf_loose_lvint_history(ump);
1483 udf_timespec_to_timestamp(&now_s, &ump->logvol_integrity->time);
1484 udf_set_regid(&ump->logvol_info->impl_id, IMPL_NAME);
1485 udf_add_impl_regid(ump, &ump->logvol_info->impl_id);
1489 error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
1490 (union dscrptr *) ump->logvol_integrity,
1501 error = udf_write_terminator(ump, sector);
1519 udf_read_physical_partition_spacetables(struct udf_mount *ump)
1522 /* struct udf_args *args = &ump->mount_args; */
1532 partd = ump->partitions[phys_part];
1544 error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
1550 ump->part_unalloc_dscr[phys_part] = &dscr->sbd;
1552 /* fill in ump->part_unalloc_bits */
1553 bitmap = &ump->part_unalloc_bits[phys_part];
1576 partd = ump->partitions[phys_part];
1590 partd = ump->partitions[phys_part];
1603 error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
1609 ump->part_freed_dscr[phys_part] = &dscr->sbd;
1611 /* fill in ump->part_freed_bits */
1612 bitmap = &ump->part_unalloc_bits[phys_part];
1635 partd = ump->partitions[phys_part];
1653 udf_write_physical_partition_spacetables(struct udf_mount *ump, int waitfor)
1656 /* struct udf_args *args = &ump->mount_args; */
1666 partd = ump->partitions[phys_part];
1679 dscr = (union dscrptr *) ump->part_unalloc_dscr[phys_part];
1680 error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
1691 partd = ump->partitions[phys_part];
1705 dscr = (union dscrptr *) ump->part_freed_dscr[phys_part];
1706 error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
1720 udf_read_metadata_partition_spacetable(struct udf_mount *ump)
1728 bitmap_node = ump->metadatabitmap_node;
1768 ump->metadata_unalloc_dscr = &dscr->sbd;
1771 bitmap = &ump->metadata_unalloc_bits;
1794 udf_write_metadata_partition_spacetable(struct udf_mount *ump, int waitfor)
1801 bitmap_node = ump->metadatabitmap_node;
1815 dscr = (union dscrptr *) ump->metadata_unalloc_dscr;
1849 * Checks if ump's vds information is correct and complete
1853 udf_process_vds(struct udf_mount *ump) {
1855 /* struct udf_args *args = &ump->mount_args; */
1868 if (ump == NULL)
1872 if (ump->anchors[0] == NULL)
1876 if ((ump->primary_vol == NULL) || (ump->logical_vol) == NULL)
1880 if (ump->partitions[0] == NULL)
1884 if (udf_rw32(ump->logical_vol->lb_size) != ump->discinfo.sector_size) {
1890 domain_name = ump->logical_vol->domain_id.id;
1897 error = udf_retrieve_lvint(ump);
1904 if (ump->logvol_integrity == NULL)
1908 n_pm = udf_rw32(ump->logical_vol->n_pm); /* num partmaps */
1909 lvint = ump->logvol_integrity;
1911 ump->logvol_info = lvinfo;
1921 n_pm = udf_rw32(ump->logical_vol->n_pm); /* num partmaps */
1922 mt_l = udf_rw32(ump->logical_vol->mt_l); /* partmaps data length */
1923 pmap_pos = ump->logical_vol->maps;
1931 ump->data_part = ump->node_part = ump->fids_part = 0;
1943 ump->data_part = log_part;
1944 ump->node_part = log_part;
1945 ump->fids_part = log_part;
1958 ump->node_part = log_part;
1965 ump->data_part = log_part;
1966 ump->node_part = log_part;
1967 ump->fids_part = log_part;
1974 ump->node_part = log_part;
1975 ump->fids_part = log_part;
1988 phys_part = udf_find_raw_phys(ump, raw_phys_part);
1998 ump->vtop [log_part] = phys_part;
1999 ump->vtop_tp[log_part] = pmap_type;
2004 ump->vtop_tp[UDF_VTOP_RAWPART] = UDF_VTOP_TYPE_RAW;
2019 maps_on = ump->vtop[log_part];
2020 switch (ump->vtop_tp[log_part]) {
2023 ump->vtop_alloc[log_part] = UDF_ALLOC_SPACEMAP;
2026 ump->vtop_alloc[log_part] = UDF_ALLOC_VAT;
2027 ump->vtop_alloc[maps_on] = UDF_ALLOC_SEQUENTIAL;
2031 ump->vtop_alloc[log_part] = UDF_ALLOC_SPACEMAP;
2034 ump->vtop_alloc[log_part] = UDF_ALLOC_METABITMAP;
2035 if (ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE) {
2037 ump->vtop_alloc[log_part] = UDF_ALLOC_METASEQUENTIAL;
2038 ump->vtop_alloc[maps_on] = UDF_ALLOC_SEQUENTIAL;
2042 panic("bad alloction type in udf's ump->vtop\n");
2048 ump->lvopen = 0;
2049 if (ump->discinfo.last_session_state == MMC_STATE_EMPTY)
2050 ump->lvopen |= UDF_OPEN_SESSION ;
2051 ump->lvclose = UDF_WRITE_VAT;
2052 if (ump->mount_args.udfmflags & UDFMNT_CLOSESESSION)
2053 ump->lvclose |= UDF_CLOSE_SESSION;
2056 ump->lvopen = UDF_WRITE_LVINT;
2057 ump->lvclose = UDF_WRITE_LVINT;
2058 if ((ump->discinfo.mmc_cur & MMC_CAP_REWRITABLE) == 0)
2059 ump->lvopen |= UDF_APPENDONLY_LVINT;
2060 if ((ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE))
2061 ump->lvopen &= ~UDF_APPENDONLY_LVINT;
2069 ump->lvreadwrite = 0;
2071 ump->lvreadwrite = UDF_UPDATE_TRACKINFO;
2073 ump->lvreadwrite = UDF_REMAP_BLOCK;
2078 ump->strategy = &udf_strat_rmw;
2079 if (n_virt || (ump->discinfo.mmc_cur & MMC_CAP_PSEUDOOVERWRITE))
2080 ump->strategy = &udf_strat_sequential;
2081 if ((ump->discinfo.mmc_class == MMC_CLASS_DISC) ||
2082 (ump->discinfo.mmc_class == MMC_CLASS_UNKN))
2083 ump->strategy = &udf_strat_direct;
2085 ump->strategy = &udf_strat_rmw;
2089 if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
2090 ump->strategy = &udf_strat_direct;
2094 DPRINTF(VOLUMES, ("\tdata partition %d\n", ump->data_part));
2095 DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->data_part]));
2096 DPRINTF(VOLUMES, ("\tnode partition %d\n", ump->node_part));
2097 DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->node_part]));
2098 DPRINTF(VOLUMES, ("\tfids partition %d\n", ump->fids_part));
2099 DPRINTF(VOLUMES, ("\t\talloc scheme %d\n", ump->vtop_alloc[ump->fids_part]));
2101 snprintb(bits, sizeof(bits), UDFLOGVOL_BITS, ump->lvopen);
2103 snprintb(bits, sizeof(bits), UDFLOGVOL_BITS, ump->lvclose);
2105 snprintb(bits, sizeof(bits), UDFONERROR_BITS, ump->lvreadwrite);
2109 (ump->strategy == &udf_strat_direct) ? "Direct" :
2110 (ump->strategy == &udf_strat_sequential) ? "Sequential" :
2111 (ump->strategy == &udf_strat_rmw) ? "RMW" : "UNKNOWN!"));
2127 udf_update_logvolname(struct udf_mount *ump, char *logvol_id)
2134 lvd = ump->logical_vol;
2135 fsd = ump->fileset_desc;
2136 if (ump->implementation)
2137 lvi = &ump->implementation->_impl_use.lv_info;
2150 udf_inittag(struct udf_mount *ump, struct desc_tag *tag, int tagid,
2153 assert(ump->logical_vol);
2156 tag->descriptor_ver = ump->logical_vol->tag.descriptor_ver;
2159 tag->serial_num = ump->logical_vol->tag.serial_num;
2165 udf_advance_uniqueid(struct udf_mount *ump)
2169 mutex_enter(&ump->logvol_mutex);
2170 unique_id = udf_rw64(ump->logvol_integrity->lvint_next_unique_id);
2173 ump->logvol_integrity->lvint_next_unique_id = udf_rw64(unique_id + 1);
2174 mutex_exit(&ump->logvol_mutex);
2183 struct udf_mount *ump = udf_node->ump;
2195 mutex_enter(&ump->allocate_mutex);
2197 num_dirs = udf_rw32(ump->logvol_info->num_directories);
2198 ump->logvol_info->num_directories =
2201 num_files = udf_rw32(ump->logvol_info->num_files);
2202 ump->logvol_info->num_files =
2205 mutex_exit(&ump->allocate_mutex);
2229 udf_add_domain_regid(struct udf_mount *ump, struct regid *regid)
2234 *ver = ump->logvol_info->min_udf_readver;
2239 udf_add_udf_regid(struct udf_mount *ump, struct regid *regid)
2244 *ver = ump->logvol_info->min_udf_readver;
2252 udf_add_impl_regid(struct udf_mount *ump, struct regid *regid)
2260 udf_add_app_regid(struct udf_mount *ump, struct regid *regid)
2267 udf_create_parentfid(struct udf_mount *ump, struct fileid_desc *fid,
2273 udf_inittag(ump, &fid->tag, TAGID_FID, udf_rw32(parent->loc.lb_num));
2351 sector_size = node->ump->discinfo.sector_size;
2454 udf_extattr_insert_internal(struct udf_mount *ump, union dscrptr *dscr,
2490 udf_inittag(ump, &extattrhdr->tag, TAGID_EXTATTR_HDR,
2549 if (udf_rw16(ump->logical_vol->tag.descriptor_ver) != 2) {
2567 struct udf_mount *ump;
2578 ump = vat_node->ump;
2579 lvinfo = ump->logvol_info;
2618 udf_update_logvolname(ump, lvext.logvol_id);
2634 struct udf_mount *ump;
2645 ump = vat_node->ump;
2646 lvinfo = ump->logvol_info;
2682 memmove(lvext.logvol_id, ump->logical_vol->logvol_id, 128);
2694 struct udf_mount *ump = vat_node->ump;
2696 if (offset + size > ump->vat_offset + ump->vat_entries * 4)
2699 memcpy(blob, ump->vat_table + offset, size);
2706 struct udf_mount *ump = vat_node->ump;
2712 if (offset_high >= ump->vat_table_alloc_len) {
2714 new_vat_table = realloc(ump->vat_table,
2715 ump->vat_table_alloc_len + UDF_VAT_CHUNKSIZE,
2721 ump->vat_table = new_vat_table;
2722 ump->vat_table_alloc_len += UDF_VAT_CHUNKSIZE;
2724 ump->vat_table_len = MAX(ump->vat_table_len, offset_high);
2726 memcpy(ump->vat_table + offset, blob, size);
2734 udf_update_vat_descriptor(struct udf_mount *ump)
2736 struct udf_node *vat_node = ump->vat_node;
2737 struct udf_logvol_info *lvinfo = ump->logvol_info;
2748 lb_size = udf_rw32(ump->logical_vol->lb_size);
2751 unique_id = udf_advance_uniqueid(ump);
2781 udf_add_udf_regid(ump, &oldvat_tl->id);
2786 sizeof(struct udf_oldvat_tail), ump->vat_entries * 4);
2794 memmove(vat->logvol_id, ump->logical_vol->logvol_id, 128);
2812 udf_writeout_vat(struct udf_mount *ump)
2814 struct udf_node *vat_node = ump->vat_node;
2822 // mutex_enter(&ump->allocate_mutex);
2823 udf_update_vat_descriptor(ump);
2826 vat_length = ump->vat_table_len;
2828 ump->vat_table, ump->vat_table_len, 0,
2835 // mutex_exit(&ump->allocate_mutex);
2837 error = vflushbuf(ump->vat_node->vnode, FSYNC_WAIT);
2840 error = VOP_FSYNC(ump->vat_node->vnode,
2859 struct udf_mount *ump;
2882 ump = vat_node->ump;
2883 sector_size = udf_rw32(ump->logical_vol->lb_size);
2887 assert(ump->logvol_integrity);
2933 lvinfo = ump->logvol_info;
2987 udf_update_logvolname(ump, vat->logvol_id);
3003 ump->logvol_integrity->lvint_next_unique_id = udf_rw64(unique_id);
3004 ump->logvol_integrity->integrity_type = udf_rw32(UDF_INTEGRITY_CLOSED);
3005 ump->logvol_integrity->time = *mtime;
3007 ump->vat_table_len = vat_length;
3008 ump->vat_table_alloc_len = vat_table_alloc_len;
3009 ump->vat_table = vat_table;
3010 ump->vat_offset = vat_offset;
3011 ump->vat_entries = vat_entries;
3012 ump->vat_last_free_lb = 0; /* start at beginning */
3027 udf_search_vat(struct udf_mount *ump, union udf_pmap *mapping)
3037 vat_loc = ump->last_possible_vat_location;
3042 early_vat_loc = MAX(early_vat_loc, ump->first_possible_vat_location);
3054 error = udf_get_node(ump, &icb_loc, &vat_node);
3072 ump->vat_node = vat_node;
3081 udf_read_sparables(struct udf_mount *ump, union udf_pmap *mapping)
3095 ump->sparable_packet_size = udf_rw16(pms->packet_len);
3096 KASSERT(ump->sparable_packet_size >= ump->packet_size); /* XXX */
3101 error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
3104 if (ump->sparing_table)
3105 free(ump->sparing_table, M_UDFVOLD);
3106 ump->sparing_table = &dscr->spt;
3110 udf_rw16(ump->sparing_table->rt_l)));
3118 if (ump->sparing_table)
3127 udf_read_metadata_nodes(struct udf_mount *ump, union udf_pmap *mapping)
3142 ump->metadata_alloc_unit_size = udf_rw32(mapping->pmm.alloc_unit_size);
3143 ump->metadata_alignment_unit_size = udf_rw16(mapping->pmm.alignment_unit_size);
3144 ump->metadata_flags = mapping->pmm.flags;
3148 phys_part = udf_find_raw_phys(ump, raw_phys_part);
3154 error = udf_get_node(ump, &icb_loc, &ump->metadata_node);
3155 if (ump->metadata_node) {
3156 vp = ump->metadata_node->vnode;
3163 error = udf_get_node(ump, &icb_loc, &ump->metadatamirror_node);
3164 if (ump->metadatamirror_node) {
3165 vp = ump->metadatamirror_node->vnode;
3173 error = udf_get_node(ump, &icb_loc, &ump->metadatabitmap_node);
3174 if (ump->metadatabitmap_node) {
3175 vp = ump->metadatabitmap_node->vnode;
3181 if (ump->vfs_mountp->mnt_flag & MNT_RDONLY) {
3183 if (ump->metadata_node)
3185 if ((ump->metadata_node == NULL) && (ump->metadatamirror_node)) {
3188 ump->metadata_node = ump->metadatamirror_node;
3189 ump->metadatamirror_node = NULL;
3206 udf_read_vds_tables(struct udf_mount *ump)
3209 /* struct udf_args *args = &ump->mount_args; */
3217 n_pm = udf_rw32(ump->logical_vol->n_pm); /* num partmaps */
3218 mt_l = udf_rw32(ump->logical_vol->mt_l); /* partmaps data length */
3219 pmap_pos = ump->logical_vol->maps;
3223 switch (ump->vtop_tp[log_part]) {
3229 error = udf_search_vat(ump, mapping);
3235 error = udf_read_sparables(ump, mapping);
3241 error = udf_read_metadata_nodes(ump, mapping);
3253 if ((ump->vfs_mountp->mnt_flag & MNT_RDONLY) == 0) {
3254 error = udf_read_physical_partition_spacetables(ump);
3259 error = udf_read_metadata_partition_spacetable(ump);
3269 udf_read_rootdirs(struct udf_mount *ump)
3272 /* struct udf_args *args = &ump->mount_args; */
3282 fsd_loc = ump->logical_vol->lv_fsd_loc;
3290 error = udf_translate_vtop(ump, &fsd_loc, &lb_num, &dummy);
3294 error = udf_read_phys_dscr(ump, lb_num, M_UDFVOLD, &dscr);
3315 if (ump->fileset_desc) {
3316 free(ump->fileset_desc, M_UDFVOLD);
3318 ump->fileset_desc = &dscr->fsd;
3322 fsd_len -= ump->discinfo.sector_size;
3326 if (udf_rw32(ump->fileset_desc->next_ex.len)) {
3328 fsd_loc = ump->fileset_desc->next_ex;
3329 fsd_len = udf_rw32(ump->fileset_desc->next_ex.len);
3336 if (ump->fileset_desc == NULL)
3341 udf_update_logvolname(ump, ump->logical_vol->logvol_id);
3354 dir_loc = &ump->fileset_desc->rootdir_icb;
3355 error = udf_get_node(ump, dir_loc, &rootdir_node);
3365 dir_loc = &ump->fileset_desc->streamdir_icb;
3368 error = udf_get_node(ump, dir_loc, &streamdir_node);
3451 udf_init_nodes_tree(struct udf_mount *ump)
3454 rb_tree_init(&ump->udf_node_tree, &udf_node_rbtree_ops);
3459 udf_node_lookup(struct udf_mount *ump, struct long_ad *icbptr)
3465 mutex_enter(&ump->ihash_lock);
3467 udf_node = rb_tree_find_node(&ump->udf_node_tree, icbptr);
3472 mutex_exit(&ump->ihash_lock);
3477 mutex_exit(&ump->ihash_lock);
3486 struct udf_mount *ump = udf_node->ump;
3489 mutex_enter(&ump->ihash_lock);
3490 rb_tree_insert_node(&ump->udf_node_tree, udf_node);
3491 mutex_exit(&ump->ihash_lock);
3498 struct udf_mount *ump = udf_node->ump;
3501 mutex_enter(&ump->ihash_lock);
3502 rb_tree_remove_node(&ump->udf_node_tree, udf_node);
3503 mutex_exit(&ump->ihash_lock);
3509 udf_validate_session_start(struct udf_mount *ump)
3520 if (ump->discinfo.disc_state == MMC_STATE_FULL)
3524 if (ump->discinfo.last_session_state == MMC_STATE_INCOMPLETE)
3532 tracknr = ump->discinfo.first_track_last_session;
3535 error = udf_update_trackinfo(ump, &trackinfo);
3551 sessionnr = ump->mount_args.sessionnr;
3554 tracknr = ump->discinfo.first_track;
3555 while (tracknr <= ump->discinfo.num_tracks) {
3557 error = udf_update_trackinfo(ump, &trackinfo);
3578 sector_size = ump->discinfo.sector_size;
3589 error = udf_read_phys_sectors(ump, UDF_C_DSCR, pos,
3626 if (udf_rw16(ump->logical_vol->tag.descriptor_ver) == 2) {
3646 sector_size = ump->discinfo.sector_size;
3655 error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE,
3663 error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE, buffer,
3670 error = udf_write_phys_sectors(ump, UDF_C_ABSOLUTE,
3678 error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_ABSOLUTE,
3679 (union dscrptr *) ump->anchors[0], sector, sector);
3692 (void) udf_synchronise_caches(ump);
3699 udf_open_logvol(struct udf_mount *ump)
3705 logvol_integrity = udf_rw32(ump->logvol_integrity->integrity_type);
3710 if (ump->vfs_mountp->mnt_flag & MNT_RDONLY)
3715 if ((error = udf_setup_writeparams(ump)) != 0)
3719 error = udf_search_writing_tracks(ump);
3728 if (ump->lvopen & UDF_OPEN_SESSION) {
3730 error = udf_validate_session_start(ump);
3735 error = udf_search_writing_tracks(ump);
3739 ump->logvol_integrity->integrity_type = udf_rw32(UDF_INTEGRITY_OPEN);
3742 if (ump->lvopen & UDF_WRITE_LVINT) {
3743 error = udf_writeout_lvint(ump, ump->lvopen);
3746 ump->logvol_integrity->integrity_type =
3757 udf_close_logvol(struct udf_mount *ump, int mntflags)
3759 struct vnode *devvp = ump->devvp;
3767 logvol_integrity = udf_rw32(ump->logvol_integrity->integrity_type);
3774 if (ump->lvclose & UDF_CLOSE_SESSION)
3775 KASSERT(ump->lvclose & UDF_WRITE_VAT);
3778 if (ump->lvclose & UDF_WRITE_VAT) {
3783 udf_writeout_vat(ump);
3784 (void) vflushbuf(ump->vat_node->vnode, FSYNC_WAIT);
3786 (void) VOP_FSYNC(ump->vat_node->vnode,
3789 if (ump->lvclose & UDF_CLOSE_SESSION) {
3804 if (ump->lvclose & UDF_FINALISE_DISC) {
3805 error = udf_write_phys_dscr_sync(ump, NULL,
3807 (union dscrptr *) ump->anchors[0],
3821 ump->vat_node->i_flags |= IN_MODIFIED;
3822 error = VOP_FSYNC(ump->vat_node->vnode,
3837 if (ump->lvclose & UDF_CLOSE_SESSION) {
3838 error = udf_validate_session_start(ump);
3842 (void) udf_synchronise_caches(ump);
3845 tracknr = ump->discinfo.first_track_last_session;
3847 while (tracknr <= ump->discinfo.last_track_last_session) {
3852 mmc_op.mmc_profile = ump->discinfo.mmc_profile;
3865 mmc_op.mmc_profile = ump->discinfo.mmc_profile;
3866 mmc_op.sessionnr = ump->discinfo.num_sessions;
3874 ump->lvopen |= UDF_OPEN_SESSION;
3877 ump->lvclose &= ~UDF_FINALISE_DISC;
3881 if (ump->lvclose & UDF_FINALISE_DISC) {
3884 mmc_op.mmc_profile = ump->discinfo.mmc_profile;
3885 mmc_op.sessionnr = ump->discinfo.num_sessions;
3894 if (ump->lvclose & UDF_WRITE_PART_BITMAPS) {
3896 error1 = udf_write_metadata_partition_spacetable(ump, true);
3902 error2 = udf_write_physical_partition_spacetables(ump, true);
3910 ump->lvclose &= ~UDF_WRITE_PART_BITMAPS;
3914 if (ump->lvclose & UDF_WRITE_METAPART_NODES) {
3916 error1 = udf_writeout_node(ump->metadata_node, FSYNC_WAIT);
3922 udf_synchronise_metadatamirror_node(ump);
3925 error2 = udf_writeout_node(ump->metadatamirror_node, FSYNC_WAIT);
3933 ump->lvclose &= ~UDF_WRITE_METAPART_NODES;
3937 ump->logvol_integrity->integrity_type = udf_rw32(UDF_INTEGRITY_CLOSED);
3940 if (ump->lvclose & UDF_WRITE_LVINT)
3941 error = udf_writeout_lvint(ump, ump->lvopen);
3944 ump->logvol_integrity->integrity_type =
3949 (void) udf_synchronise_caches(ump);
3985 struct udf_mount *ump = udf_node->ump;
3998 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
4004 vpart_num = udf_get_record_vpart(ump, udf_c_type);
4017 error = udf_reserve_space(ump, udf_node, udf_c_type,
4063 udf_write_terminator(struct udf_mount *ump, uint32_t sector)
4068 dscr = malloc(ump->discinfo.sector_size, M_TEMP, M_WAITOK|M_ZERO);
4069 udf_inittag(ump, &dscr->tag, TAGID_TERM, sector);
4075 error = udf_write_phys_dscr_sync(ump, NULL, UDF_C_DSCR,
4240 udf_timestamp_to_timespec(struct udf_mount *ump,
4278 secs -= ump->mount_args.gmtoff;
4398 struct udf_mount *ump = udf_node->ump;
4416 uid = ump->mount_args.anon_uid;
4418 gid = ump->mount_args.anon_gid;
4430 struct udf_mount *ump = udf_node->ump;
4439 nobody_uid = ump->mount_args.nobody_uid;
4440 nobody_gid = ump->mount_args.nobody_gid;
4496 lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
4567 lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
4621 udf_create_new_fe(struct udf_mount *ump, struct file_entry *fe, int file_type,
4634 udf_inittag(ump, &fe->tag, TAGID_FENTRY, lb_num);
4657 udf_add_impl_regid(ump, &fe->imp_id);
4659 unique_id = udf_advance_uniqueid(ump);
4674 udf_extattr_insert_internal(ump, (union dscrptr *) fe,
4682 fidsize = udf_create_parentfid(ump,
4704 udf_create_new_efe(struct udf_mount *ump, struct extfile_entry *efe,
4716 udf_inittag(ump, &efe->tag, TAGID_EXTFENTRY, lb_num);
4740 udf_add_impl_regid(ump, &efe->imp_id);
4742 unique_id = udf_advance_uniqueid(ump);
4750 fidsize = udf_create_parentfid(ump,
4773 udf_dir_detach(struct udf_mount *ump, struct udf_node *dir_node,
4808 lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
4921 udf_dir_update_rootentry(struct udf_mount *ump, struct udf_node *dir_node,
4969 lb_size = udf_rw32(dir_node->ump->logical_vol->lb_size);
5046 udf_dir_attach(struct udf_mount *ump, struct udf_node *dir_node,
5072 lb_size = udf_rw32(ump->logical_vol->lb_size);
5095 unique_id = udf_advance_uniqueid(ump);
5199 udf_inittag(ump, &fid->tag, TAGID_FID, 0);
5212 udf_add_impl_regid(ump, (struct regid *) fid->data);
5301 udf_get_node(struct udf_mount *ump, struct long_ad *node_icb_loc,
5318 mutex_enter(&ump->get_node_lock);
5322 assert(ump);
5324 udf_node = udf_node_lookup(ump, node_icb_loc);
5329 mutex_exit(&ump->get_node_lock);
5334 error = udf_translate_vtop(ump, node_icb_loc, §or, &dummy);
5338 mutex_exit(&ump->get_node_lock);
5348 error = getnewvnode(VT_UDF, ump->vfs_mountp, udf_vnodeop_p, NULL, &nvp);
5351 mutex_exit(&ump->get_node_lock);
5359 mutex_exit(&ump->get_node_lock);
5364 udf_node->ump = ump;
5377 if (ump->fileset_desc)
5378 if (memcmp(&udf_node->loc, &ump->fileset_desc->rootdir_icb,
5386 mutex_exit(&ump->get_node_lock);
5394 lb_size = udf_rw32(ump->logical_vol->lb_size);
5399 error = udf_read_logvol_dscr(ump, &icb_loc, &dscr);
5416 udf_free_logvol_dscr(ump, &icb_loc, dscr);
5424 udf_free_logvol_dscr(ump, &icb_loc, dscr);
5438 udf_free_logvol_dscr(ump, &last_fe_icb_loc,
5447 udf_free_logvol_dscr(ump, &last_fe_icb_loc,
5560 error = udf_read_logvol_dscr(ump, &icb_loc, &dscr);
5568 udf_free_logvol_dscr(ump, &icb_loc, dscr);
5756 udf_free_logvol_dscr(udf_node->ump, &udf_node->ext_loc[extnr],
5762 udf_free_logvol_dscr(udf_node->ump, &udf_node->loc,
5765 udf_free_logvol_dscr(udf_node->ump, &udf_node->loc,
5770 udf_node->ump = (void *) 0xdeadbeef;
5790 struct udf_mount *ump = dir_node->ump;
5801 lb_size = udf_rw32(ump->logical_vol->lb_size);
5805 error = getnewvnode(VT_UDF, ump->vfs_mountp, vnodeops, NULL, &nvp);
5815 vpart_num = ump->node_part;
5816 error = udf_reserve_space(ump, NULL, UDF_C_NODE,
5822 error = udf_allocate_space(ump, NULL, UDF_C_NODE,
5840 udf_node->ump = ump;
5868 udf_create_logvol_dscr(ump, udf_node, &node_icb_loc, &dscr);
5871 if (udf_rw16(ump->logical_vol->tag.descriptor_ver) == 2) {
5873 fid_size = udf_create_new_fe(ump, udf_node->fe,
5879 fid_size = udf_create_new_efe(ump, udf_node->efe,
5897 error = udf_dir_attach(ump, dir_node, udf_node, vap, cnp);
5900 udf_free_allocated_space(ump, lb_num, vpart_num, 1);
5919 udf_do_unreserve_space(ump, NULL, vpart_num, 1);
5993 struct udf_mount *ump = udf_node->ump;
6006 lb_size = udf_rw32(ump->logical_vol->lb_size);
6009 udf_free_allocated_space(ump, lb_num, vpart_num, num_lb);
6016 struct udf_mount *ump;
6020 ump = udf_node->ump;
6023 lvint = udf_rw32(udf_node->ump->logvol_integrity->integrity_type);
6162 udf_timestamp_to_timespec(udf_node->ump, ctime, &cur_birth);
6198 struct udf_mount *ump = udf_node->ump;
6226 udf_add_impl_regid(ump, impl_id);
6272 struct udf_mount *ump = dir_node->ump;
6298 lb_size = udf_rw32(ump->logical_vol->lb_size);
6364 fid_name, fid->l_fi, &ump->logical_vol->desc_charset);
6394 udf_sync_pass(struct udf_mount *ump, kauth_cred_t cred, int waitfor,
6406 udf_node = RB_TREE_MIN(&ump->udf_node_tree);
6414 n_udf_node = rb_tree_iterate(&ump->udf_node_tree,
6478 udf_do_sync(struct udf_mount *ump, kauth_cred_t cred, int waitfor)
6487 udf_sync_pass(ump, cred, waitfor, 1, &dummy);
6491 udf_sync_pass(ump, cred, waitfor, 2, &dummy);
6494 ndirty = ump->devvp->v_numoutput;
6497 udf_sync_pass(ump, cred, waitfor, 3, &ndirty);
6503 cv_timedwait(&ump->dirtynodes_cv, &mntvnode_lock,
6526 struct udf_mount *ump;
6535 ump = node->ump;
6536 sector_size = ump->discinfo.sector_size;
6564 struct udf_mount *ump;
6573 ump = node->ump;
6574 sector_size = ump->discinfo.sector_size;
6603 struct udf_mount *ump = udf_node->ump;
6613 sector_size = udf_node->ump->discinfo.sector_size;
6714 udf_discstrat_queuebuf(ump, nestbuf);
6732 struct udf_mount *ump = udf_node->ump;
6741 lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
6833 udf_discstrat_queuebuf(ump, nestbuf);