[BACK]Return to udf_allocation.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / fs / udf

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/fs/udf/udf_allocation.c between version 1.32.2.1 and 1.33

version 1.32.2.1, 2014/05/22 11:41:02 version 1.33, 2013/07/03 11:50:59
Line 342  udf_node_sanity_check(struct udf_node *u
Line 342  udf_node_sanity_check(struct udf_node *u
                 uint64_t *cnt_inflen, uint64_t *cnt_logblksrec) {                  uint64_t *cnt_inflen, uint64_t *cnt_logblksrec) {
         struct file_entry    *fe;          struct file_entry    *fe;
         struct extfile_entry *efe;          struct extfile_entry *efe;
           struct icb_tag *icbtag;
         uint64_t inflen, logblksrec;          uint64_t inflen, logblksrec;
           int dscr_size, lb_size;
   
           lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
   
         fe  = udf_node->fe;          fe  = udf_node->fe;
         efe = udf_node->efe;          efe = udf_node->efe;
         if (fe) {          if (fe) {
                   icbtag = &fe->icbtag;
                 inflen = udf_rw64(fe->inf_len);                  inflen = udf_rw64(fe->inf_len);
                   dscr_size  = sizeof(struct file_entry) -1;
                 logblksrec = udf_rw64(fe->logblks_rec);                  logblksrec = udf_rw64(fe->logblks_rec);
         } else {          } else {
                   icbtag = &efe->icbtag;
                 inflen = udf_rw64(efe->inf_len);                  inflen = udf_rw64(efe->inf_len);
                   dscr_size  = sizeof(struct extfile_entry) -1;
                 logblksrec = udf_rw64(efe->logblks_rec);                  logblksrec = udf_rw64(efe->logblks_rec);
         }          }
         *cnt_logblksrec = logblksrec;          *cnt_logblksrec = logblksrec;
Line 578  translate_again:
Line 586  translate_again:
   
                         end_foffset = foffset + len;                          end_foffset = foffset + len;
   
                         if (end_foffset > (uint64_t) lb_num * lb_size)                          if (end_foffset > lb_num * lb_size)
                                 break;  /* found */                                  break;  /* found */
                         foffset = end_foffset;                          foffset = end_foffset;
                         slot++;                          slot++;
Line 716  udf_translate_file_extent(struct udf_nod
Line 724  udf_translate_file_extent(struct udf_nod
   
                 end_foffset = foffset + len;                  end_foffset = foffset + len;
   
                 if (end_foffset > (uint64_t) from * lb_size)                  if (end_foffset > from * lb_size)
                         break;  /* found */                          break;  /* found */
                 foffset = end_foffset;                  foffset = end_foffset;
                 slot++;                  slot++;
         }          }
         /* found overlapping slot */          /* found overlapping slot */
         ext_offset = (uint64_t) from * lb_size - foffset;          ext_offset = from * lb_size - foffset;
   
         for (;;) {          for (;;) {
                 udf_get_adslot(udf_node, slot, &s_ad, &eof);                  udf_get_adslot(udf_node, slot, &s_ad, &eof);
Line 1157  udf_allocate_space(struct udf_mount *ump
Line 1165  udf_allocate_space(struct udf_mount *ump
         struct logvol_int_desc *lvid;          struct logvol_int_desc *lvid;
         uint64_t *lmappos;          uint64_t *lmappos;
         uint32_t ptov, lb_num, *freepos, free_lbs;          uint32_t ptov, lb_num, *freepos, free_lbs;
         int lb_size __diagused, alloc_num_lb;          int lb_size, alloc_num_lb;
         int alloc_type, error;          int alloc_type, error;
         int is_node;          int is_node;
   
Line 1303  udf_free_allocated_space(struct udf_moun
Line 1311  udf_free_allocated_space(struct udf_moun
         uint16_t vpart_num, uint32_t num_lb)          uint16_t vpart_num, uint32_t num_lb)
 {  {
         struct udf_bitmap *bitmap;          struct udf_bitmap *bitmap;
           struct part_desc *pdesc;
         struct logvol_int_desc *lvid;          struct logvol_int_desc *lvid;
         uint32_t lb_map, udf_rw32_lbmap;          uint32_t ptov, lb_map, udf_rw32_lbmap;
         uint32_t *freepos, free_lbs;          uint32_t *freepos, free_lbs;
         int phys_part;          int phys_part;
         int error __diagused;          int error;
   
         DPRINTF(ALLOC, ("udf_free_allocated_space: freeing virt lbnum %d "          DPRINTF(ALLOC, ("udf_free_allocated_space: freeing virt lbnum %d "
                           "part %d + %d sect\n", lb_num, vpart_num, num_lb));                            "part %d + %d sect\n", lb_num, vpart_num, num_lb));
Line 1318  udf_free_allocated_space(struct udf_moun
Line 1327  udf_free_allocated_space(struct udf_moun
   
         mutex_enter(&ump->allocate_mutex);          mutex_enter(&ump->allocate_mutex);
   
           /* get partition backing up this vpart_num */
           pdesc = ump->partitions[ump->vtop[vpart_num]];
   
         switch (ump->vtop_tp[vpart_num]) {          switch (ump->vtop_tp[vpart_num]) {
         case UDF_VTOP_TYPE_PHYS :          case UDF_VTOP_TYPE_PHYS :
         case UDF_VTOP_TYPE_SPARABLE :          case UDF_VTOP_TYPE_SPARABLE :
                 /* free space to freed or unallocated space bitmap */                  /* free space to freed or unallocated space bitmap */
                   ptov      = udf_rw32(pdesc->start_loc);
                 phys_part = ump->vtop[vpart_num];                  phys_part = ump->vtop[vpart_num];
   
                 /* first try freed space bitmap */                  /* first try freed space bitmap */
Line 1473  udf_trunc_metadatapart(struct udf_mount 
Line 1486  udf_trunc_metadatapart(struct udf_mount 
         uint32_t *freepos, *sizepos;          uint32_t *freepos, *sizepos;
         uint32_t unit, lb_size;          uint32_t unit, lb_size;
         uint16_t meta_vpart_num, data_vpart_num, num_vpart;          uint16_t meta_vpart_num, data_vpart_num, num_vpart;
         int err __diagused;          int err;
   
         unit = ump->metadata_alloc_unit_size;          unit = ump->metadata_alloc_unit_size;
         lb_size = udf_rw32(ump->logical_vol->lb_size);          lb_size = udf_rw32(ump->logical_vol->lb_size);
Line 1640  udf_late_allocate_buf(struct udf_mount *
Line 1653  udf_late_allocate_buf(struct udf_mount *
         uint64_t *lmapping, struct long_ad *node_ad_cpy, uint16_t *vpart_nump)          uint64_t *lmapping, struct long_ad *node_ad_cpy, uint16_t *vpart_nump)
 {  {
         struct udf_node  *udf_node = VTOI(buf->b_vp);          struct udf_node  *udf_node = VTOI(buf->b_vp);
         int lb_size, udf_c_type;          int lb_size, blks, udf_c_type;
         int vpart_num, num_lb;          int vpart_num, num_lb;
         int error, s;          int error, s;
   
Line 1653  udf_late_allocate_buf(struct udf_mount *
Line 1666  udf_late_allocate_buf(struct udf_mount *
   
         lb_size    = udf_rw32(ump->logical_vol->lb_size);          lb_size    = udf_rw32(ump->logical_vol->lb_size);
         num_lb     = (buf->b_bcount + lb_size -1) / lb_size;          num_lb     = (buf->b_bcount + lb_size -1) / lb_size;
           blks       = lb_size / DEV_BSIZE;
         udf_c_type = buf->b_udf_c_type;          udf_c_type = buf->b_udf_c_type;
   
         KASSERT(lb_size == ump->discinfo.sector_size);          KASSERT(lb_size == ump->discinfo.sector_size);
Line 1760  udf_wipe_adslots(struct udf_node *udf_no
Line 1774  udf_wipe_adslots(struct udf_node *udf_no
         struct file_entry      *fe;          struct file_entry      *fe;
         struct extfile_entry   *efe;          struct extfile_entry   *efe;
         struct alloc_ext_entry *ext;          struct alloc_ext_entry *ext;
         uint32_t lb_size, dscr_size, l_ea, max_l_ad, crclen;          uint64_t inflen, objsize;
           uint32_t lb_size, dscr_size, l_ea, l_ad, max_l_ad, crclen;
         uint8_t *data_pos;          uint8_t *data_pos;
         int extnr;          int extnr;
   
Line 1769  udf_wipe_adslots(struct udf_node *udf_no
Line 1784  udf_wipe_adslots(struct udf_node *udf_no
         fe  = udf_node->fe;          fe  = udf_node->fe;
         efe = udf_node->efe;          efe = udf_node->efe;
         if (fe) {          if (fe) {
                   inflen  = udf_rw64(fe->inf_len);
                   objsize = inflen;
                 dscr_size  = sizeof(struct file_entry) -1;                  dscr_size  = sizeof(struct file_entry) -1;
                 l_ea       = udf_rw32(fe->l_ea);                  l_ea       = udf_rw32(fe->l_ea);
                   l_ad       = udf_rw32(fe->l_ad);
                 data_pos = (uint8_t *) fe + dscr_size + l_ea;                  data_pos = (uint8_t *) fe + dscr_size + l_ea;
         } else {          } else {
                   inflen  = udf_rw64(efe->inf_len);
                   objsize = udf_rw64(efe->obj_size);
                 dscr_size  = sizeof(struct extfile_entry) -1;                  dscr_size  = sizeof(struct extfile_entry) -1;
                 l_ea       = udf_rw32(efe->l_ea);                  l_ea       = udf_rw32(efe->l_ea);
                   l_ad       = udf_rw32(efe->l_ad);
                 data_pos = (uint8_t *) efe + dscr_size + l_ea;                  data_pos = (uint8_t *) efe + dscr_size + l_ea;
         }          }
         max_l_ad = lb_size - dscr_size - l_ea;          max_l_ad = lb_size - dscr_size - l_ea;
Line 1819  udf_get_adslot(struct udf_node *udf_node
Line 1840  udf_get_adslot(struct udf_node *udf_node
         struct short_ad *short_ad;          struct short_ad *short_ad;
         struct long_ad *long_ad, l_icb;          struct long_ad *long_ad, l_icb;
         uint32_t offset;          uint32_t offset;
         uint32_t dscr_size, l_ea, l_ad, flags;          uint32_t lb_size, dscr_size, l_ea, l_ad, flags;
         uint8_t *data_pos;          uint8_t *data_pos;
         int icbflags, addr_type, adlen, extnr;          int icbflags, addr_type, adlen, extnr;
   
           /* determine what descriptor we are in */
           lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
   
         fe  = udf_node->fe;          fe  = udf_node->fe;
         efe = udf_node->efe;          efe = udf_node->efe;
         if (fe) {          if (fe) {
Line 2172  udf_count_alloc_exts(struct udf_node *ud
Line 2196  udf_count_alloc_exts(struct udf_node *ud
         uint16_t vpart_num;          uint16_t vpart_num;
         int slot, eof;          int slot, eof;
         int num_extents, extnr;          int num_extents, extnr;
           int lb_size;
   
         if (udf_node->num_extensions == 0)          if (udf_node->num_extensions == 0)
                 return;                  return;
   
           lb_size = udf_rw32(udf_node->ump->logical_vol->lb_size);
         /* count number of allocation extents in use */          /* count number of allocation extents in use */
         num_extents = 0;          num_extents = 0;
         slot = 0;          slot = 0;
Line 2597  out:
Line 2623  out:
 int  int
 udf_grow_node(struct udf_node *udf_node, uint64_t new_size)  udf_grow_node(struct udf_node *udf_node, uint64_t new_size)
 {  {
           union dscrptr *dscr;
         struct vnode *vp = udf_node->vnode;          struct vnode *vp = udf_node->vnode;
         struct udf_mount *ump = udf_node->ump;          struct udf_mount *ump = udf_node->ump;
         struct file_entry    *fe;          struct file_entry    *fe;
Line 2610  udf_grow_node(struct udf_node *udf_node,
Line 2637  udf_grow_node(struct udf_node *udf_node,
         uint32_t icbflags, len, flags, max_len;          uint32_t icbflags, len, flags, max_len;
         uint32_t max_l_ad, l_ad, l_ea;          uint32_t max_l_ad, l_ad, l_ea;
         uint16_t my_part, dst_part;          uint16_t my_part, dst_part;
         uint8_t *evacuated_data;          uint8_t *data_pos, *evacuated_data;
         int addr_type;          int addr_type;
         int slot;          int slot, cpy_slot;
         int eof, error;          int eof, error;
   
         DPRINTF(ALLOC, ("udf_grow_node\n"));          DPRINTF(ALLOC, ("udf_grow_node\n"));
Line 2631  udf_grow_node(struct udf_node *udf_node,
Line 2658  udf_grow_node(struct udf_node *udf_node,
         fe  = udf_node->fe;          fe  = udf_node->fe;
         efe = udf_node->efe;          efe = udf_node->efe;
         if (fe) {          if (fe) {
                   dscr       = (union dscrptr *) fe;
                 icbtag  = &fe->icbtag;                  icbtag  = &fe->icbtag;
                 inflen  = udf_rw64(fe->inf_len);                  inflen  = udf_rw64(fe->inf_len);
                 objsize = inflen;                  objsize = inflen;
Line 2638  udf_grow_node(struct udf_node *udf_node,
Line 2666  udf_grow_node(struct udf_node *udf_node,
                 l_ea       = udf_rw32(fe->l_ea);                  l_ea       = udf_rw32(fe->l_ea);
                 l_ad       = udf_rw32(fe->l_ad);                  l_ad       = udf_rw32(fe->l_ad);
         } else {          } else {
                   dscr       = (union dscrptr *) efe;
                 icbtag  = &efe->icbtag;                  icbtag  = &efe->icbtag;
                 inflen  = udf_rw64(efe->inf_len);                  inflen  = udf_rw64(efe->inf_len);
                 objsize = udf_rw64(efe->obj_size);                  objsize = udf_rw64(efe->obj_size);
Line 2645  udf_grow_node(struct udf_node *udf_node,
Line 2674  udf_grow_node(struct udf_node *udf_node,
                 l_ea       = udf_rw32(efe->l_ea);                  l_ea       = udf_rw32(efe->l_ea);
                 l_ad       = udf_rw32(efe->l_ad);                  l_ad       = udf_rw32(efe->l_ad);
         }          }
           data_pos  = (uint8_t *) dscr + dscr_size + l_ea;
         max_l_ad = lb_size - dscr_size - l_ea;          max_l_ad = lb_size - dscr_size - l_ea;
   
         icbflags   = udf_rw16(icbtag->flags);          icbflags   = udf_rw16(icbtag->flags);
Line 2739  udf_grow_node(struct udf_node *udf_node,
Line 2769  udf_grow_node(struct udf_node *udf_node,
         } else {          } else {
                 /* goto the last entry (if any) */                  /* goto the last entry (if any) */
                 slot     = 0;                  slot     = 0;
                   cpy_slot = 0;
                 foffset  = 0;                  foffset  = 0;
                 memset(&c_ad, 0, sizeof(struct long_ad));                  memset(&c_ad, 0, sizeof(struct long_ad));
                 for (;;) {                  for (;;) {

Legend:
Removed from v.1.32.2.1  
changed lines
  Added in v.1.33

CVSweb <webmaster@jp.NetBSD.org>