← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to fs/hpfs/anode.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
fs/hpfs/anode.c
22
22
        if (hpfs_sb(s)->sb_chk) if (hpfs_stop_cycles(s, a, &c1, &c2, "hpfs_bplus_lookup")) return -1;
23
23
        if (btree->internal) {
24
24
                for (i = 0; i < btree->n_used_nodes; i++)
25
 
                        if (btree->u.internal[i].file_secno > sec) {
26
 
                                a = btree->u.internal[i].down;
 
25
                        if (le32_to_cpu(btree->u.internal[i].file_secno) > sec) {
 
26
                                a = le32_to_cpu(btree->u.internal[i].down);
27
27
                                brelse(bh);
28
28
                                if (!(anode = hpfs_map_anode(s, a, &bh))) return -1;
29
29
                                btree = &anode->btree;
34
34
                return -1;
35
35
        }
36
36
        for (i = 0; i < btree->n_used_nodes; i++)
37
 
                if (btree->u.external[i].file_secno <= sec &&
38
 
                    btree->u.external[i].file_secno + btree->u.external[i].length > sec) {
39
 
                        a = btree->u.external[i].disk_secno + sec - btree->u.external[i].file_secno;
 
37
                if (le32_to_cpu(btree->u.external[i].file_secno) <= sec &&
 
38
                    le32_to_cpu(btree->u.external[i].file_secno) + le32_to_cpu(btree->u.external[i].length) > sec) {
 
39
                        a = le32_to_cpu(btree->u.external[i].disk_secno) + sec - le32_to_cpu(btree->u.external[i].file_secno);
40
40
                        if (hpfs_sb(s)->sb_chk) if (hpfs_chk_sectors(s, a, 1, "data")) {
41
41
                                brelse(bh);
42
42
                                return -1;
43
43
                        }
44
44
                        if (inode) {
45
45
                                struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);
46
 
                                hpfs_inode->i_file_sec = btree->u.external[i].file_secno;
47
 
                                hpfs_inode->i_disk_sec = btree->u.external[i].disk_secno;
48
 
                                hpfs_inode->i_n_secs = btree->u.external[i].length;
 
46
                                hpfs_inode->i_file_sec = le32_to_cpu(btree->u.external[i].file_secno);
 
47
                                hpfs_inode->i_disk_sec = le32_to_cpu(btree->u.external[i].disk_secno);
 
48
                                hpfs_inode->i_n_secs = le32_to_cpu(btree->u.external[i].length);
49
49
                        }
50
50
                        brelse(bh);
51
51
                        return a;
83
83
                return -1;
84
84
        }
85
85
        if (btree->internal) {
86
 
                a = btree->u.internal[n].down;
87
 
                btree->u.internal[n].file_secno = -1;
 
86
                a = le32_to_cpu(btree->u.internal[n].down);
 
87
                btree->u.internal[n].file_secno = cpu_to_le32(-1);
88
88
                mark_buffer_dirty(bh);
89
89
                brelse(bh);
90
90
                if (hpfs_sb(s)->sb_chk)
94
94
                goto go_down;
95
95
        }
96
96
        if (n >= 0) {
97
 
                if (btree->u.external[n].file_secno + btree->u.external[n].length != fsecno) {
 
97
                if (le32_to_cpu(btree->u.external[n].file_secno) + le32_to_cpu(btree->u.external[n].length) != fsecno) {
98
98
                        hpfs_error(s, "allocated size %08x, trying to add sector %08x, %cnode %08x",
99
 
                                btree->u.external[n].file_secno + btree->u.external[n].length, fsecno,
 
99
                                le32_to_cpu(btree->u.external[n].file_secno) + le32_to_cpu(btree->u.external[n].length), fsecno,
100
100
                                fnod?'f':'a', node);
101
101
                        brelse(bh);
102
102
                        return -1;
103
103
                }
104
 
                if (hpfs_alloc_if_possible(s, se = btree->u.external[n].disk_secno + btree->u.external[n].length)) {
105
 
                        btree->u.external[n].length++;
 
104
                if (hpfs_alloc_if_possible(s, se = le32_to_cpu(btree->u.external[n].disk_secno) + le32_to_cpu(btree->u.external[n].length))) {
 
105
                        btree->u.external[n].length = cpu_to_le32(le32_to_cpu(btree->u.external[n].length) + 1);
106
106
                        mark_buffer_dirty(bh);
107
107
                        brelse(bh);
108
108
                        return se;
115
115
                }
116
116
                se = !fnod ? node : (node + 16384) & ~16383;
117
117
        }       
118
 
        if (!(se = hpfs_alloc_sector(s, se, 1, fsecno*ALLOC_M>ALLOC_FWD_MAX ? ALLOC_FWD_MAX : fsecno*ALLOC_M<ALLOC_FWD_MIN ? ALLOC_FWD_MIN : fsecno*ALLOC_M, 1))) {
 
118
        if (!(se = hpfs_alloc_sector(s, se, 1, fsecno*ALLOC_M>ALLOC_FWD_MAX ? ALLOC_FWD_MAX : fsecno*ALLOC_M<ALLOC_FWD_MIN ? ALLOC_FWD_MIN : fsecno*ALLOC_M))) {
119
119
                brelse(bh);
120
120
                return -1;
121
121
        }
122
 
        fs = n < 0 ? 0 : btree->u.external[n].file_secno + btree->u.external[n].length;
 
122
        fs = n < 0 ? 0 : le32_to_cpu(btree->u.external[n].file_secno) + le32_to_cpu(btree->u.external[n].length);
123
123
        if (!btree->n_free_nodes) {
124
 
                up = a != node ? anode->up : -1;
 
124
                up = a != node ? le32_to_cpu(anode->up) : -1;
125
125
                if (!(anode = hpfs_alloc_anode(s, a, &na, &bh1))) {
126
126
                        brelse(bh);
127
127
                        hpfs_free_sectors(s, se, 1);
128
128
                        return -1;
129
129
                }
130
130
                if (a == node && fnod) {
131
 
                        anode->up = node;
 
131
                        anode->up = cpu_to_le32(node);
132
132
                        anode->btree.fnode_parent = 1;
133
133
                        anode->btree.n_used_nodes = btree->n_used_nodes;
134
134
                        anode->btree.first_free = btree->first_free;
137
137
                        btree->internal = 1;
138
138
                        btree->n_free_nodes = 11;
139
139
                        btree->n_used_nodes = 1;
140
 
                        btree->first_free = (char *)&(btree->u.internal[1]) - (char *)btree;
141
 
                        btree->u.internal[0].file_secno = -1;
142
 
                        btree->u.internal[0].down = na;
 
140
                        btree->first_free = cpu_to_le16((char *)&(btree->u.internal[1]) - (char *)btree);
 
141
                        btree->u.internal[0].file_secno = cpu_to_le32(-1);
 
142
                        btree->u.internal[0].down = cpu_to_le32(na);
143
143
                        mark_buffer_dirty(bh);
144
144
                } else if (!(ranode = hpfs_alloc_anode(s, /*a*/0, &ra, &bh2))) {
145
145
                        brelse(bh);
153
153
                btree = &anode->btree;
154
154
        }
155
155
        btree->n_free_nodes--; n = btree->n_used_nodes++;
156
 
        btree->first_free += 12;
157
 
        btree->u.external[n].disk_secno = se;
158
 
        btree->u.external[n].file_secno = fs;
159
 
        btree->u.external[n].length = 1;
 
156
        btree->first_free = cpu_to_le16(le16_to_cpu(btree->first_free) + 12);
 
157
        btree->u.external[n].disk_secno = cpu_to_le32(se);
 
158
        btree->u.external[n].file_secno = cpu_to_le32(fs);
 
159
        btree->u.external[n].length = cpu_to_le32(1);
160
160
        mark_buffer_dirty(bh);
161
161
        brelse(bh);
162
162
        if ((a == node && fnod) || na == -1) return se;
163
163
        c2 = 0;
164
 
        while (up != -1) {
 
164
        while (up != (anode_secno)-1) {
165
165
                struct anode *new_anode;
166
166
                if (hpfs_sb(s)->sb_chk)
167
167
                        if (hpfs_stop_cycles(s, up, &c1, &c2, "hpfs_add_sector_to_btree #2")) return -1;
174
174
                }
175
175
                if (btree->n_free_nodes) {
176
176
                        btree->n_free_nodes--; n = btree->n_used_nodes++;
177
 
                        btree->first_free += 8;
178
 
                        btree->u.internal[n].file_secno = -1;
179
 
                        btree->u.internal[n].down = na;
180
 
                        btree->u.internal[n-1].file_secno = fs;
 
177
                        btree->first_free = cpu_to_le16(le16_to_cpu(btree->first_free) + 8);
 
178
                        btree->u.internal[n].file_secno = cpu_to_le32(-1);
 
179
                        btree->u.internal[n].down = cpu_to_le32(na);
 
180
                        btree->u.internal[n-1].file_secno = cpu_to_le32(fs);
181
181
                        mark_buffer_dirty(bh);
182
182
                        brelse(bh);
183
183
                        brelse(bh2);
184
184
                        hpfs_free_sectors(s, ra, 1);
185
185
                        if ((anode = hpfs_map_anode(s, na, &bh))) {
186
 
                                anode->up = up;
 
186
                                anode->up = cpu_to_le32(up);
187
187
                                anode->btree.fnode_parent = up == node && fnod;
188
188
                                mark_buffer_dirty(bh);
189
189
                                brelse(bh);
190
190
                        }
191
191
                        return se;
192
192
                }
193
 
                up = up != node ? anode->up : -1;
194
 
                btree->u.internal[btree->n_used_nodes - 1].file_secno = /*fs*/-1;
 
193
                up = up != node ? le32_to_cpu(anode->up) : -1;
 
194
                btree->u.internal[btree->n_used_nodes - 1].file_secno = cpu_to_le32(/*fs*/-1);
195
195
                mark_buffer_dirty(bh);
196
196
                brelse(bh);
197
197
                a = na;
198
198
                if ((new_anode = hpfs_alloc_anode(s, a, &na, &bh))) {
199
199
                        anode = new_anode;
200
 
                        /*anode->up = up != -1 ? up : ra;*/
 
200
                        /*anode->up = cpu_to_le32(up != -1 ? up : ra);*/
201
201
                        anode->btree.internal = 1;
202
202
                        anode->btree.n_used_nodes = 1;
203
203
                        anode->btree.n_free_nodes = 59;
204
 
                        anode->btree.first_free = 16;
205
 
                        anode->btree.u.internal[0].down = a;
206
 
                        anode->btree.u.internal[0].file_secno = -1;
 
204
                        anode->btree.first_free = cpu_to_le16(16);
 
205
                        anode->btree.u.internal[0].down = cpu_to_le32(a);
 
206
                        anode->btree.u.internal[0].file_secno = cpu_to_le32(-1);
207
207
                        mark_buffer_dirty(bh);
208
208
                        brelse(bh);
209
209
                        if ((anode = hpfs_map_anode(s, a, &bh))) {
210
 
                                anode->up = na;
 
210
                                anode->up = cpu_to_le32(na);
211
211
                                mark_buffer_dirty(bh);
212
212
                                brelse(bh);
213
213
                        }
214
214
                } else na = a;
215
215
        }
216
216
        if ((anode = hpfs_map_anode(s, na, &bh))) {
217
 
                anode->up = node;
 
217
                anode->up = cpu_to_le32(node);
218
218
                if (fnod) anode->btree.fnode_parent = 1;
219
219
                mark_buffer_dirty(bh);
220
220
                brelse(bh);
232
232
                }
233
233
                btree = &fnode->btree;
234
234
        }
235
 
        ranode->up = node;
236
 
        memcpy(&ranode->btree, btree, btree->first_free);
 
235
        ranode->up = cpu_to_le32(node);
 
236
        memcpy(&ranode->btree, btree, le16_to_cpu(btree->first_free));
237
237
        if (fnod) ranode->btree.fnode_parent = 1;
238
238
        ranode->btree.n_free_nodes = (ranode->btree.internal ? 60 : 40) - ranode->btree.n_used_nodes;
239
239
        if (ranode->btree.internal) for (n = 0; n < ranode->btree.n_used_nodes; n++) {
240
240
                struct anode *unode;
241
 
                if ((unode = hpfs_map_anode(s, ranode->u.internal[n].down, &bh1))) {
242
 
                        unode->up = ra;
 
241
                if ((unode = hpfs_map_anode(s, le32_to_cpu(ranode->u.internal[n].down), &bh1))) {
 
242
                        unode->up = cpu_to_le32(ra);
243
243
                        unode->btree.fnode_parent = 0;
244
244
                        mark_buffer_dirty(bh1);
245
245
                        brelse(bh1);
248
248
        btree->internal = 1;
249
249
        btree->n_free_nodes = fnod ? 10 : 58;
250
250
        btree->n_used_nodes = 2;
251
 
        btree->first_free = (char *)&btree->u.internal[2] - (char *)btree;
252
 
        btree->u.internal[0].file_secno = fs;
253
 
        btree->u.internal[0].down = ra;
254
 
        btree->u.internal[1].file_secno = -1;
255
 
        btree->u.internal[1].down = na;
 
251
        btree->first_free = cpu_to_le16((char *)&btree->u.internal[2] - (char *)btree);
 
252
        btree->u.internal[0].file_secno = cpu_to_le32(fs);
 
253
        btree->u.internal[0].down = cpu_to_le32(ra);
 
254
        btree->u.internal[1].file_secno = cpu_to_le32(-1);
 
255
        btree->u.internal[1].down = cpu_to_le32(na);
256
256
        mark_buffer_dirty(bh);
257
257
        brelse(bh);
258
258
        mark_buffer_dirty(bh2);
279
279
        go_down:
280
280
        d2 = 0;
281
281
        while (btree1->internal) {
282
 
                ano = btree1->u.internal[pos].down;
 
282
                ano = le32_to_cpu(btree1->u.internal[pos].down);
283
283
                if (level) brelse(bh);
284
284
                if (hpfs_sb(s)->sb_chk)
285
285
                        if (hpfs_stop_cycles(s, ano, &d1, &d2, "hpfs_remove_btree #1"))
290
290
                pos = 0;
291
291
        }
292
292
        for (i = 0; i < btree1->n_used_nodes; i++)
293
 
                hpfs_free_sectors(s, btree1->u.external[i].disk_secno, btree1->u.external[i].length);
 
293
                hpfs_free_sectors(s, le32_to_cpu(btree1->u.external[i].disk_secno), le32_to_cpu(btree1->u.external[i].length));
294
294
        go_up:
295
295
        if (!level) return;
296
296
        brelse(bh);
298
298
                if (hpfs_stop_cycles(s, ano, &c1, &c2, "hpfs_remove_btree #2")) return;
299
299
        hpfs_free_sectors(s, ano, 1);
300
300
        oano = ano;
301
 
        ano = anode->up;
 
301
        ano = le32_to_cpu(anode->up);
302
302
        if (--level) {
303
303
                if (!(anode = hpfs_map_anode(s, ano, &bh))) return;
304
304
                btree1 = &anode->btree;
305
305
        } else btree1 = btree;
306
306
        for (i = 0; i < btree1->n_used_nodes; i++) {
307
 
                if (btree1->u.internal[i].down == oano) {
 
307
                if (le32_to_cpu(btree1->u.internal[i].down) == oano) {
308
308
                        if ((pos = i + 1) < btree1->n_used_nodes)
309
309
                                goto go_down;
310
310
                        else
411
411
                if (fno) {
412
412
                        btree->n_free_nodes = 8;
413
413
                        btree->n_used_nodes = 0;
414
 
                        btree->first_free = 8;
 
414
                        btree->first_free = cpu_to_le16(8);
415
415
                        btree->internal = 0;
416
416
                        mark_buffer_dirty(bh);
417
417
                } else hpfs_free_sectors(s, f, 1);
421
421
        while (btree->internal) {
422
422
                nodes = btree->n_used_nodes + btree->n_free_nodes;
423
423
                for (i = 0; i < btree->n_used_nodes; i++)
424
 
                        if (btree->u.internal[i].file_secno >= secs) goto f;
 
424
                        if (le32_to_cpu(btree->u.internal[i].file_secno) >= secs) goto f;
425
425
                brelse(bh);
426
426
                hpfs_error(s, "internal btree %08x doesn't end with -1", node);
427
427
                return;
428
428
                f:
429
429
                for (j = i + 1; j < btree->n_used_nodes; j++)
430
 
                        hpfs_ea_remove(s, btree->u.internal[j].down, 1, 0);
 
430
                        hpfs_ea_remove(s, le32_to_cpu(btree->u.internal[j].down), 1, 0);
431
431
                btree->n_used_nodes = i + 1;
432
432
                btree->n_free_nodes = nodes - btree->n_used_nodes;
433
 
                btree->first_free = 8 + 8 * btree->n_used_nodes;
 
433
                btree->first_free = cpu_to_le16(8 + 8 * btree->n_used_nodes);
434
434
                mark_buffer_dirty(bh);
435
 
                if (btree->u.internal[i].file_secno == secs) {
 
435
                if (btree->u.internal[i].file_secno == cpu_to_le32(secs)) {
436
436
                        brelse(bh);
437
437
                        return;
438
438
                }
439
 
                node = btree->u.internal[i].down;
 
439
                node = le32_to_cpu(btree->u.internal[i].down);
440
440
                brelse(bh);
441
441
                if (hpfs_sb(s)->sb_chk)
442
442
                        if (hpfs_stop_cycles(s, node, &c1, &c2, "hpfs_truncate_btree"))
446
446
        }       
447
447
        nodes = btree->n_used_nodes + btree->n_free_nodes;
448
448
        for (i = 0; i < btree->n_used_nodes; i++)
449
 
                if (btree->u.external[i].file_secno + btree->u.external[i].length >= secs) goto ff;
 
449
                if (le32_to_cpu(btree->u.external[i].file_secno) + le32_to_cpu(btree->u.external[i].length) >= secs) goto ff;
450
450
        brelse(bh);
451
451
        return;
452
452
        ff:
453
 
        if (secs <= btree->u.external[i].file_secno) {
 
453
        if (secs <= le32_to_cpu(btree->u.external[i].file_secno)) {
454
454
                hpfs_error(s, "there is an allocation error in file %08x, sector %08x", f, secs);
455
455
                if (i) i--;
456
456
        }
457
 
        else if (btree->u.external[i].file_secno + btree->u.external[i].length > secs) {
458
 
                hpfs_free_sectors(s, btree->u.external[i].disk_secno + secs -
459
 
                        btree->u.external[i].file_secno, btree->u.external[i].length
460
 
                        - secs + btree->u.external[i].file_secno); /* I hope gcc optimizes this :-) */
461
 
                btree->u.external[i].length = secs - btree->u.external[i].file_secno;
 
457
        else if (le32_to_cpu(btree->u.external[i].file_secno) + le32_to_cpu(btree->u.external[i].length) > secs) {
 
458
                hpfs_free_sectors(s, le32_to_cpu(btree->u.external[i].disk_secno) + secs -
 
459
                        le32_to_cpu(btree->u.external[i].file_secno), le32_to_cpu(btree->u.external[i].length)
 
460
                        - secs + le32_to_cpu(btree->u.external[i].file_secno)); /* I hope gcc optimizes this :-) */
 
461
                btree->u.external[i].length = cpu_to_le32(secs - le32_to_cpu(btree->u.external[i].file_secno));
462
462
        }
463
463
        for (j = i + 1; j < btree->n_used_nodes; j++)
464
 
                hpfs_free_sectors(s, btree->u.external[j].disk_secno, btree->u.external[j].length);
 
464
                hpfs_free_sectors(s, le32_to_cpu(btree->u.external[j].disk_secno), le32_to_cpu(btree->u.external[j].length));
465
465
        btree->n_used_nodes = i + 1;
466
466
        btree->n_free_nodes = nodes - btree->n_used_nodes;
467
 
        btree->first_free = 8 + 12 * btree->n_used_nodes;
 
467
        btree->first_free = cpu_to_le16(8 + 12 * btree->n_used_nodes);
468
468
        mark_buffer_dirty(bh);
469
469
        brelse(bh);
470
470
}
480
480
        struct extended_attribute *ea_end;
481
481
        if (!(fnode = hpfs_map_fnode(s, fno, &bh))) return;
482
482
        if (!fnode->dirflag) hpfs_remove_btree(s, &fnode->btree);
483
 
        else hpfs_remove_dtree(s, fnode->u.external[0].disk_secno);
 
483
        else hpfs_remove_dtree(s, le32_to_cpu(fnode->u.external[0].disk_secno));
484
484
        ea_end = fnode_end_ea(fnode);
485
485
        for (ea = fnode_ea(fnode); ea < ea_end; ea = next_ea(ea))
486
486
                if (ea->indirect)
487
487
                        hpfs_ea_remove(s, ea_sec(ea), ea->anode, ea_len(ea));
488
 
        hpfs_ea_ext_remove(s, fnode->ea_secno, fnode->ea_anode, fnode->ea_size_l);
 
488
        hpfs_ea_ext_remove(s, le32_to_cpu(fnode->ea_secno), fnode->ea_anode, le32_to_cpu(fnode->ea_size_l));
489
489
        brelse(bh);
490
490
        hpfs_free_sectors(s, fno, 1);
491
491
}