← Back to branch summary

~csurbhi/ubuntu/maverick/e2fsprogs/e2fsprogs.fix-505719

« back to all changes in this revision

Viewing changes to lib/ext2fs/irel_ma.c

  • Committer: Bazaar Package Importer
  • Author(s): Matt Zimmerman
  • Date: 2004-09-19 09:43:14 UTC
  • mto: (8.1.1 lenny) (1.2.3 upstream)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20040919094314-2tafd19i76fhu6ei
Tags: upstream-1.35
Import upstream version 1.35

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ext2fs/irel_ma.c
73
73
         * Allocate memory structures
74
74
         */
75
75
        retval = ext2fs_get_mem(sizeof(struct ext2_inode_relocation_table),
76
 
                  (void **) &irel);
 
76
                                &irel);
77
77
        if (retval)
78
78
                goto errout;
79
79
        memset(irel, 0, sizeof(struct ext2_inode_relocation_table));
80
80
        
81
 
        retval = ext2fs_get_mem(strlen(name)+1, (void **) &irel->name);
 
81
        retval = ext2fs_get_mem(strlen(name)+1, &irel->name);
82
82
        if (retval)
83
83
                goto errout;
84
84
        strcpy(irel->name, name);
85
85
        
86
 
        retval = ext2fs_get_mem(sizeof(struct irel_ma), (void **) &ma);
 
86
        retval = ext2fs_get_mem(sizeof(struct irel_ma), &ma);
87
87
        if (retval)
88
88
                goto errout;
89
89
        memset(ma, 0, sizeof(struct irel_ma));
90
90
        irel->priv_data = ma;
91
91
        
92
92
        size = (size_t) (sizeof(ext2_ino_t) * (max_inode+1));
93
 
        retval = ext2fs_get_mem(size, (void **) &ma->orig_map);
 
93
        retval = ext2fs_get_mem(size, &ma->orig_map);
94
94
        if (retval)
95
95
                goto errout;
96
96
        memset(ma->orig_map, 0, size);
97
97
 
98
98
        size = (size_t) (sizeof(struct ext2_inode_relocate_entry) *
99
99
                         (max_inode+1));
100
 
        retval = ext2fs_get_mem(size, (void **) &ma->entries);
 
100
        retval = ext2fs_get_mem(size, &ma->entries);
101
101
        if (retval)
102
102
                goto errout;
103
103
        memset(ma->entries, 0, size);
104
104
 
105
105
        size = (size_t) (sizeof(struct inode_reference_entry) *
106
106
                         (max_inode+1));
107
 
        retval = ext2fs_get_mem(size, (void **) &ma->ref_entries);
 
107
        retval = ext2fs_get_mem(size, &ma->ref_entries);
108
108
        if (retval)
109
109
                goto errout;
110
110
        memset(ma->ref_entries, 0, size);
163
163
                size = (sizeof(struct ext2_inode_reference) * ent->max_refs);
164
164
                old_size = (sizeof(struct ext2_inode_reference) *
165
165
                            ma->entries[(unsigned) old].max_refs);
166
 
                retval = ext2fs_resize_mem(old_size, size,
167
 
                                           (void **) &ref_ent->refs);
 
166
                retval = ext2fs_resize_mem(old_size, size, &ref_ent->refs);
168
167
                if (retval)
169
168
                        return retval;
170
169
        }
250
249
        if (ref_ent->refs == 0) {
251
250
                size = (size_t) ((sizeof(struct ext2_inode_reference) * 
252
251
                                  ent->max_refs));
253
 
                retval = ext2fs_get_mem(size, (void **) &ref_ent->refs);
 
252
                retval = ext2fs_get_mem(size, &ref_ent->refs);
254
253
                if (retval)
255
254
                        return retval;
256
255
                memset(ref_ent->refs, 0, size);
311
310
        
312
311
        ma->entries[(unsigned) new] = ma->entries[(unsigned) old];
313
312
        if (ma->ref_entries[(unsigned) new].refs)
314
 
                ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) new].refs);
 
313
                ext2fs_free_mem(&ma->ref_entries[(unsigned) new].refs);
315
314
        ma->ref_entries[(unsigned) new] = ma->ref_entries[(unsigned) old];
316
315
        
317
316
        ma->entries[(unsigned) old].new = 0;
334
333
        
335
334
        ma->entries[old].new = 0;
336
335
        if (ma->ref_entries[(unsigned) old].refs)
337
 
                ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) old].refs);
 
336
                ext2fs_free_mem(&ma->ref_entries[(unsigned) old].refs);
338
337
        ma->orig_map[ma->entries[(unsigned) old].orig] = 0;
339
338
        
340
339
        ma->ref_entries[(unsigned) old].num = 0;
354
353
 
355
354
        if (ma) {
356
355
                if (ma->orig_map)
357
 
                        ext2fs_free_mem((void **) &ma->orig_map);
 
356
                        ext2fs_free_mem(&ma->orig_map);
358
357
                if (ma->entries)
359
 
                        ext2fs_free_mem((void **) &ma->entries);
 
358
                        ext2fs_free_mem(&ma->entries);
360
359
                if (ma->ref_entries) {
361
360
                        for (ino = 0; ino <= ma->max_inode; ino++) {
362
361
                                if (ma->ref_entries[(unsigned) ino].refs)
363
 
                                        ext2fs_free_mem((void **) &ma->ref_entries[(unsigned) ino].refs);
 
362
                                        ext2fs_free_mem(&ma->ref_entries[(unsigned) ino].refs);
364
363
                        }
365
 
                        ext2fs_free_mem((void **) &ma->ref_entries);
 
364
                        ext2fs_free_mem(&ma->ref_entries);
366
365
                }
367
 
                ext2fs_free_mem((void **) &ma);
 
366
                ext2fs_free_mem(&ma);
368
367
        }
369
368
        if (irel->name)
370
 
                ext2fs_free_mem((void **) &irel->name);
371
 
        ext2fs_free_mem((void **) &irel);
 
369
                ext2fs_free_mem(&irel->name);
 
370
        ext2fs_free_mem(&irel);
372
371
        return 0;
373
372
}