Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'hpfs'
* hpfs:
HPFS: Remove unused variable
HPFS: Move declaration up, so that there are no out-of-scope pointers
HPFS: Fix some unaligned accesses
HPFS: Fix endianity. Make hpfs work on big-endian machines
HPFS: Implement fsync for hpfs
HPFS: Fix a bug that filesystem was not marked dirty when remounting it
HPFS: Restrict uid and gid to 16-bit values
HPFS: When marking or clearing the dirty bit, sync the filesystem
HPFS: Use types with defined width
HPFS: Remove mark_inode_dirty
HPFS: Remove CR/LF conversion option
HPFS: Remove remaining locks
HPFS: Introduce a global mutex and lock it on every callback from VFS.
HPFS: Make HPFS compile on preempt and SMP
+728
-791
-1
fs/hpfs/Kconfig
-1
fs/hpfs/Kconfig
+43
-75
fs/hpfs/alloc.c
+43
-75
fs/hpfs/alloc.c
···
8
8
9
9
#include "hpfs_fn.h"
10
10
11
-
static int hpfs_alloc_if_possible_nolock(struct super_block *s, secno sec);
12
-
13
11
/*
14
12
* Check if a sector is allocated in bitmap
15
13
* This is really slow. Turned on only if chk==2
···
16
18
static int chk_if_allocated(struct super_block *s, secno sec, char *msg)
17
19
{
18
20
struct quad_buffer_head qbh;
19
-
unsigned *bmp;
21
+
u32 *bmp;
20
22
if (!(bmp = hpfs_map_bitmap(s, sec >> 14, &qbh, "chk"))) goto fail;
21
-
if ((bmp[(sec & 0x3fff) >> 5] >> (sec & 0x1f)) & 1) {
23
+
if ((cpu_to_le32(bmp[(sec & 0x3fff) >> 5]) >> (sec & 0x1f)) & 1) {
22
24
hpfs_error(s, "sector '%s' - %08x not allocated in bitmap", msg, sec);
23
25
goto fail1;
24
26
}
···
26
28
if (sec >= hpfs_sb(s)->sb_dirband_start && sec < hpfs_sb(s)->sb_dirband_start + hpfs_sb(s)->sb_dirband_size) {
27
29
unsigned ssec = (sec - hpfs_sb(s)->sb_dirband_start) / 4;
28
30
if (!(bmp = hpfs_map_dnode_bitmap(s, &qbh))) goto fail;
29
-
if ((bmp[ssec >> 5] >> (ssec & 0x1f)) & 1) {
31
+
if ((le32_to_cpu(bmp[ssec >> 5]) >> (ssec & 0x1f)) & 1) {
30
32
hpfs_error(s, "sector '%s' - %08x not allocated in directory bitmap", msg, sec);
31
33
goto fail1;
32
34
}
···
73
75
hpfs_error(s, "Bad allocation size: %d", n);
74
76
return 0;
75
77
}
76
-
lock_super(s);
77
78
if (bs != ~0x3fff) {
78
79
if (!(bmp = hpfs_map_bitmap(s, near >> 14, &qbh, "aib"))) goto uls;
79
80
} else {
···
82
85
ret = bs + nr;
83
86
goto rt;
84
87
}
85
-
/*if (!tstbits(bmp, nr + n, n + forward)) {
86
-
ret = bs + nr + n;
87
-
goto rt;
88
-
}*/
89
88
q = nr + n; b = 0;
90
89
while ((a = tstbits(bmp, q, n + forward)) != 0) {
91
90
q += a;
···
98
105
goto rt;
99
106
}
100
107
nr >>= 5;
101
-
/*for (i = nr + 1; i != nr; i++, i &= 0x1ff) {*/
108
+
/*for (i = nr + 1; i != nr; i++, i &= 0x1ff) */
102
109
i = nr;
103
110
do {
104
-
if (!bmp[i]) goto cont;
105
-
if (n + forward >= 0x3f && bmp[i] != -1) goto cont;
111
+
if (!le32_to_cpu(bmp[i])) goto cont;
112
+
if (n + forward >= 0x3f && le32_to_cpu(bmp[i]) != 0xffffffff) goto cont;
106
113
q = i<<5;
107
114
if (i > 0) {
108
-
unsigned k = bmp[i-1];
115
+
unsigned k = le32_to_cpu(bmp[i-1]);
109
116
while (k & 0x80000000) {
110
117
q--; k <<= 1;
111
118
}
···
125
132
} while (i != nr);
126
133
rt:
127
134
if (ret) {
128
-
if (hpfs_sb(s)->sb_chk && ((ret >> 14) != (bs >> 14) || (bmp[(ret & 0x3fff) >> 5] | ~(((1 << n) - 1) << (ret & 0x1f))) != 0xffffffff)) {
135
+
if (hpfs_sb(s)->sb_chk && ((ret >> 14) != (bs >> 14) || (le32_to_cpu(bmp[(ret & 0x3fff) >> 5]) | ~(((1 << n) - 1) << (ret & 0x1f))) != 0xffffffff)) {
129
136
hpfs_error(s, "Allocation doesn't work! Wanted %d, allocated at %08x", n, ret);
130
137
ret = 0;
131
138
goto b;
132
139
}
133
-
bmp[(ret & 0x3fff) >> 5] &= ~(((1 << n) - 1) << (ret & 0x1f));
140
+
bmp[(ret & 0x3fff) >> 5] &= cpu_to_le32(~(((1 << n) - 1) << (ret & 0x1f)));
134
141
hpfs_mark_4buffers_dirty(&qbh);
135
142
}
136
143
b:
137
144
hpfs_brelse4(&qbh);
138
145
uls:
139
-
unlock_super(s);
140
146
return ret;
141
147
}
142
148
···
147
155
* sectors
148
156
*/
149
157
150
-
secno hpfs_alloc_sector(struct super_block *s, secno near, unsigned n, int forward, int lock)
158
+
secno hpfs_alloc_sector(struct super_block *s, secno near, unsigned n, int forward)
151
159
{
152
160
secno sec;
153
161
int i;
···
159
167
forward = -forward;
160
168
f_p = 1;
161
169
}
162
-
if (lock) hpfs_lock_creation(s);
163
170
n_bmps = (sbi->sb_fs_size + 0x4000 - 1) >> 14;
164
171
if (near && near < sbi->sb_fs_size) {
165
172
if ((sec = alloc_in_bmp(s, near, n, f_p ? forward : forward/4))) goto ret;
···
205
214
ret:
206
215
if (sec && f_p) {
207
216
for (i = 0; i < forward; i++) {
208
-
if (!hpfs_alloc_if_possible_nolock(s, sec + i + 1)) {
217
+
if (!hpfs_alloc_if_possible(s, sec + i + 1)) {
209
218
hpfs_error(s, "Prealloc doesn't work! Wanted %d, allocated at %08x, can't allocate %d", forward, sec, i);
210
219
sec = 0;
211
220
break;
212
221
}
213
222
}
214
223
}
215
-
if (lock) hpfs_unlock_creation(s);
216
224
return sec;
217
225
}
218
226
219
-
static secno alloc_in_dirband(struct super_block *s, secno near, int lock)
227
+
static secno alloc_in_dirband(struct super_block *s, secno near)
220
228
{
221
229
unsigned nr = near;
222
230
secno sec;
···
226
236
nr = sbi->sb_dirband_start + sbi->sb_dirband_size - 4;
227
237
nr -= sbi->sb_dirband_start;
228
238
nr >>= 2;
229
-
if (lock) hpfs_lock_creation(s);
230
239
sec = alloc_in_bmp(s, (~0x3fff) | nr, 1, 0);
231
-
if (lock) hpfs_unlock_creation(s);
232
240
if (!sec) return 0;
233
241
return ((sec & 0x3fff) << 2) + sbi->sb_dirband_start;
234
242
}
235
243
236
244
/* Alloc sector if it's free */
237
245
238
-
static int hpfs_alloc_if_possible_nolock(struct super_block *s, secno sec)
246
+
int hpfs_alloc_if_possible(struct super_block *s, secno sec)
239
247
{
240
248
struct quad_buffer_head qbh;
241
-
unsigned *bmp;
242
-
lock_super(s);
249
+
u32 *bmp;
243
250
if (!(bmp = hpfs_map_bitmap(s, sec >> 14, &qbh, "aip"))) goto end;
244
-
if (bmp[(sec & 0x3fff) >> 5] & (1 << (sec & 0x1f))) {
245
-
bmp[(sec & 0x3fff) >> 5] &= ~(1 << (sec & 0x1f));
251
+
if (le32_to_cpu(bmp[(sec & 0x3fff) >> 5]) & (1 << (sec & 0x1f))) {
252
+
bmp[(sec & 0x3fff) >> 5] &= cpu_to_le32(~(1 << (sec & 0x1f)));
246
253
hpfs_mark_4buffers_dirty(&qbh);
247
254
hpfs_brelse4(&qbh);
248
-
unlock_super(s);
249
255
return 1;
250
256
}
251
257
hpfs_brelse4(&qbh);
252
258
end:
253
-
unlock_super(s);
254
259
return 0;
255
-
}
256
-
257
-
int hpfs_alloc_if_possible(struct super_block *s, secno sec)
258
-
{
259
-
int r;
260
-
hpfs_lock_creation(s);
261
-
r = hpfs_alloc_if_possible_nolock(s, sec);
262
-
hpfs_unlock_creation(s);
263
-
return r;
264
260
}
265
261
266
262
/* Free sectors in bitmaps */
···
254
278
void hpfs_free_sectors(struct super_block *s, secno sec, unsigned n)
255
279
{
256
280
struct quad_buffer_head qbh;
257
-
unsigned *bmp;
281
+
u32 *bmp;
258
282
struct hpfs_sb_info *sbi = hpfs_sb(s);
259
283
/*printk("2 - ");*/
260
284
if (!n) return;
···
262
286
hpfs_error(s, "Trying to free reserved sector %08x", sec);
263
287
return;
264
288
}
265
-
lock_super(s);
266
289
sbi->sb_max_fwd_alloc += n > 0xffff ? 0xffff : n;
267
290
if (sbi->sb_max_fwd_alloc > 0xffffff) sbi->sb_max_fwd_alloc = 0xffffff;
268
291
new_map:
269
292
if (!(bmp = hpfs_map_bitmap(s, sec >> 14, &qbh, "free"))) {
270
-
unlock_super(s);
271
293
return;
272
294
}
273
295
new_tst:
274
-
if ((bmp[(sec & 0x3fff) >> 5] >> (sec & 0x1f) & 1)) {
296
+
if ((le32_to_cpu(bmp[(sec & 0x3fff) >> 5]) >> (sec & 0x1f) & 1)) {
275
297
hpfs_error(s, "sector %08x not allocated", sec);
276
298
hpfs_brelse4(&qbh);
277
-
unlock_super(s);
278
299
return;
279
300
}
280
-
bmp[(sec & 0x3fff) >> 5] |= 1 << (sec & 0x1f);
301
+
bmp[(sec & 0x3fff) >> 5] |= cpu_to_le32(1 << (sec & 0x1f));
281
302
if (!--n) {
282
303
hpfs_mark_4buffers_dirty(&qbh);
283
304
hpfs_brelse4(&qbh);
284
-
unlock_super(s);
285
305
return;
286
306
}
287
307
if (!(++sec & 0x3fff)) {
···
299
327
int n_bmps = (hpfs_sb(s)->sb_fs_size + 0x4000 - 1) >> 14;
300
328
int b = hpfs_sb(s)->sb_c_bitmap & 0x0fffffff;
301
329
int i, j;
302
-
unsigned *bmp;
330
+
u32 *bmp;
303
331
struct quad_buffer_head qbh;
304
332
if ((bmp = hpfs_map_dnode_bitmap(s, &qbh))) {
305
333
for (j = 0; j < 512; j++) {
306
334
unsigned k;
307
-
if (!bmp[j]) continue;
308
-
for (k = bmp[j]; k; k >>= 1) if (k & 1) if (!--n) {
335
+
if (!le32_to_cpu(bmp[j])) continue;
336
+
for (k = le32_to_cpu(bmp[j]); k; k >>= 1) if (k & 1) if (!--n) {
309
337
hpfs_brelse4(&qbh);
310
338
return 0;
311
339
}
···
324
352
chk_bmp:
325
353
if (bmp) {
326
354
for (j = 0; j < 512; j++) {
327
-
unsigned k;
328
-
if (!bmp[j]) continue;
355
+
u32 k;
356
+
if (!le32_to_cpu(bmp[j])) continue;
329
357
for (k = 0xf; k; k <<= 4)
330
-
if ((bmp[j] & k) == k) {
358
+
if ((le32_to_cpu(bmp[j]) & k) == k) {
331
359
if (!--n) {
332
360
hpfs_brelse4(&qbh);
333
361
return 0;
···
351
379
hpfs_free_sectors(s, dno, 4);
352
380
} else {
353
381
struct quad_buffer_head qbh;
354
-
unsigned *bmp;
382
+
u32 *bmp;
355
383
unsigned ssec = (dno - hpfs_sb(s)->sb_dirband_start) / 4;
356
-
lock_super(s);
357
384
if (!(bmp = hpfs_map_dnode_bitmap(s, &qbh))) {
358
-
unlock_super(s);
359
385
return;
360
386
}
361
-
bmp[ssec >> 5] |= 1 << (ssec & 0x1f);
387
+
bmp[ssec >> 5] |= cpu_to_le32(1 << (ssec & 0x1f));
362
388
hpfs_mark_4buffers_dirty(&qbh);
363
389
hpfs_brelse4(&qbh);
364
-
unlock_super(s);
365
390
}
366
391
}
367
392
368
393
struct dnode *hpfs_alloc_dnode(struct super_block *s, secno near,
369
-
dnode_secno *dno, struct quad_buffer_head *qbh,
370
-
int lock)
394
+
dnode_secno *dno, struct quad_buffer_head *qbh)
371
395
{
372
396
struct dnode *d;
373
397
if (hpfs_count_one_bitmap(s, hpfs_sb(s)->sb_dmap) > FREE_DNODES_ADD) {
374
-
if (!(*dno = alloc_in_dirband(s, near, lock)))
375
-
if (!(*dno = hpfs_alloc_sector(s, near, 4, 0, lock))) return NULL;
398
+
if (!(*dno = alloc_in_dirband(s, near)))
399
+
if (!(*dno = hpfs_alloc_sector(s, near, 4, 0))) return NULL;
376
400
} else {
377
-
if (!(*dno = hpfs_alloc_sector(s, near, 4, 0, lock)))
378
-
if (!(*dno = alloc_in_dirband(s, near, lock))) return NULL;
401
+
if (!(*dno = hpfs_alloc_sector(s, near, 4, 0)))
402
+
if (!(*dno = alloc_in_dirband(s, near))) return NULL;
379
403
}
380
404
if (!(d = hpfs_get_4sectors(s, *dno, qbh))) {
381
405
hpfs_free_dnode(s, *dno);
382
406
return NULL;
383
407
}
384
408
memset(d, 0, 2048);
385
-
d->magic = DNODE_MAGIC;
386
-
d->first_free = 52;
409
+
d->magic = cpu_to_le32(DNODE_MAGIC);
410
+
d->first_free = cpu_to_le32(52);
387
411
d->dirent[0] = 32;
388
412
d->dirent[2] = 8;
389
413
d->dirent[30] = 1;
390
414
d->dirent[31] = 255;
391
-
d->self = *dno;
415
+
d->self = cpu_to_le32(*dno);
392
416
return d;
393
417
}
394
418
···
392
424
struct buffer_head **bh)
393
425
{
394
426
struct fnode *f;
395
-
if (!(*fno = hpfs_alloc_sector(s, near, 1, FNODE_ALLOC_FWD, 1))) return NULL;
427
+
if (!(*fno = hpfs_alloc_sector(s, near, 1, FNODE_ALLOC_FWD))) return NULL;
396
428
if (!(f = hpfs_get_sector(s, *fno, bh))) {
397
429
hpfs_free_sectors(s, *fno, 1);
398
430
return NULL;
399
431
}
400
432
memset(f, 0, 512);
401
-
f->magic = FNODE_MAGIC;
402
-
f->ea_offs = 0xc4;
433
+
f->magic = cpu_to_le32(FNODE_MAGIC);
434
+
f->ea_offs = cpu_to_le16(0xc4);
403
435
f->btree.n_free_nodes = 8;
404
-
f->btree.first_free = 8;
436
+
f->btree.first_free = cpu_to_le16(8);
405
437
return f;
406
438
}
407
439
···
409
441
struct buffer_head **bh)
410
442
{
411
443
struct anode *a;
412
-
if (!(*ano = hpfs_alloc_sector(s, near, 1, ANODE_ALLOC_FWD, 1))) return NULL;
444
+
if (!(*ano = hpfs_alloc_sector(s, near, 1, ANODE_ALLOC_FWD))) return NULL;
413
445
if (!(a = hpfs_get_sector(s, *ano, bh))) {
414
446
hpfs_free_sectors(s, *ano, 1);
415
447
return NULL;
416
448
}
417
449
memset(a, 0, 512);
418
-
a->magic = ANODE_MAGIC;
419
-
a->self = *ano;
450
+
a->magic = cpu_to_le32(ANODE_MAGIC);
451
+
a->self = cpu_to_le32(*ano);
420
452
a->btree.n_free_nodes = 40;
421
453
a->btree.n_used_nodes = 0;
422
-
a->btree.first_free = 8;
454
+
a->btree.first_free = cpu_to_le16(8);
423
455
return a;
424
456
}
+69
-69
fs/hpfs/anode.c
+69
-69
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
}
+8
-16
fs/hpfs/buffer.c
+8
-16
fs/hpfs/buffer.c
···
9
9
#include <linux/slab.h>
10
10
#include "hpfs_fn.h"
11
11
12
-
void hpfs_lock_creation(struct super_block *s)
13
-
{
14
-
#ifdef DEBUG_LOCKS
15
-
printk("lock creation\n");
16
-
#endif
17
-
mutex_lock(&hpfs_sb(s)->hpfs_creation_de);
18
-
}
19
-
20
-
void hpfs_unlock_creation(struct super_block *s)
21
-
{
22
-
#ifdef DEBUG_LOCKS
23
-
printk("unlock creation\n");
24
-
#endif
25
-
mutex_unlock(&hpfs_sb(s)->hpfs_creation_de);
26
-
}
27
-
28
12
/* Map a sector into a buffer and return pointers to it and to the buffer. */
29
13
30
14
void *hpfs_map_sector(struct super_block *s, unsigned secno, struct buffer_head **bhp,
31
15
int ahead)
32
16
{
33
17
struct buffer_head *bh;
18
+
19
+
hpfs_lock_assert(s);
34
20
35
21
cond_resched();
36
22
···
35
49
{
36
50
struct buffer_head *bh;
37
51
/*return hpfs_map_sector(s, secno, bhp, 0);*/
52
+
53
+
hpfs_lock_assert(s);
38
54
39
55
cond_resched();
40
56
···
57
69
{
58
70
struct buffer_head *bh;
59
71
char *data;
72
+
73
+
hpfs_lock_assert(s);
60
74
61
75
cond_resched();
62
76
···
114
124
struct quad_buffer_head *qbh)
115
125
{
116
126
cond_resched();
127
+
128
+
hpfs_lock_assert(s);
117
129
118
130
if (secno & 3) {
119
131
printk("HPFS: hpfs_get_4sectors: unaligned read\n");
+10
-12
fs/hpfs/dir.c
+10
-12
fs/hpfs/dir.c
···
88
88
hpfs_error(inode->i_sb, "not a directory, fnode %08lx",
89
89
(unsigned long)inode->i_ino);
90
90
}
91
-
if (hpfs_inode->i_dno != fno->u.external[0].disk_secno) {
91
+
if (hpfs_inode->i_dno != le32_to_cpu(fno->u.external[0].disk_secno)) {
92
92
e = 1;
93
-
hpfs_error(inode->i_sb, "corrupted inode: i_dno == %08x, fnode -> dnode == %08x", hpfs_inode->i_dno, fno->u.external[0].disk_secno);
93
+
hpfs_error(inode->i_sb, "corrupted inode: i_dno == %08x, fnode -> dnode == %08x", hpfs_inode->i_dno, le32_to_cpu(fno->u.external[0].disk_secno));
94
94
}
95
95
brelse(bh);
96
96
if (e) {
···
156
156
goto again;
157
157
}
158
158
tempname = hpfs_translate_name(inode->i_sb, de->name, de->namelen, lc, de->not_8x3);
159
-
if (filldir(dirent, tempname, de->namelen, old_pos, de->fnode, DT_UNKNOWN) < 0) {
159
+
if (filldir(dirent, tempname, de->namelen, old_pos, le32_to_cpu(de->fnode), DT_UNKNOWN) < 0) {
160
160
filp->f_pos = old_pos;
161
161
if (tempname != de->name) kfree(tempname);
162
162
hpfs_brelse4(&qbh);
···
221
221
* Get inode number, what we're after.
222
222
*/
223
223
224
-
ino = de->fnode;
224
+
ino = le32_to_cpu(de->fnode);
225
225
226
226
/*
227
227
* Go find or make an inode.
···
236
236
hpfs_init_inode(result);
237
237
if (de->directory)
238
238
hpfs_read_inode(result);
239
-
else if (de->ea_size && hpfs_sb(dir->i_sb)->sb_eas)
239
+
else if (le32_to_cpu(de->ea_size) && hpfs_sb(dir->i_sb)->sb_eas)
240
240
hpfs_read_inode(result);
241
241
else {
242
242
result->i_mode |= S_IFREG;
···
250
250
hpfs_result = hpfs_i(result);
251
251
if (!de->directory) hpfs_result->i_parent_dir = dir->i_ino;
252
252
253
-
hpfs_decide_conv(result, name, len);
254
-
255
253
if (de->has_acl || de->has_xtd_perm) if (!(dir->i_sb->s_flags & MS_RDONLY)) {
256
254
hpfs_error(result->i_sb, "ACLs or XPERM found. This is probably HPFS386. This driver doesn't support it now. Send me some info on these structures");
257
255
goto bail1;
···
261
263
*/
262
264
263
265
if (!result->i_ctime.tv_sec) {
264
-
if (!(result->i_ctime.tv_sec = local_to_gmt(dir->i_sb, de->creation_date)))
266
+
if (!(result->i_ctime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->creation_date))))
265
267
result->i_ctime.tv_sec = 1;
266
268
result->i_ctime.tv_nsec = 0;
267
-
result->i_mtime.tv_sec = local_to_gmt(dir->i_sb, de->write_date);
269
+
result->i_mtime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->write_date));
268
270
result->i_mtime.tv_nsec = 0;
269
-
result->i_atime.tv_sec = local_to_gmt(dir->i_sb, de->read_date);
271
+
result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->read_date));
270
272
result->i_atime.tv_nsec = 0;
271
-
hpfs_result->i_ea_size = de->ea_size;
273
+
hpfs_result->i_ea_size = le32_to_cpu(de->ea_size);
272
274
if (!hpfs_result->i_ea_mode && de->read_only)
273
275
result->i_mode &= ~0222;
274
276
if (!de->directory) {
275
277
if (result->i_size == -1) {
276
-
result->i_size = de->file_size;
278
+
result->i_size = le32_to_cpu(de->file_size);
277
279
result->i_data.a_ops = &hpfs_aops;
278
280
hpfs_i(result)->mmu_private = result->i_size;
279
281
/*
+84
-90
fs/hpfs/dnode.c
+84
-90
fs/hpfs/dnode.c
···
14
14
struct hpfs_dirent *de_end = dnode_end_de(d);
15
15
int i = 1;
16
16
for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) {
17
-
if (de == fde) return ((loff_t) d->self << 4) | (loff_t)i;
17
+
if (de == fde) return ((loff_t) le32_to_cpu(d->self) << 4) | (loff_t)i;
18
18
i++;
19
19
}
20
20
printk("HPFS: get_pos: not_found\n");
21
-
return ((loff_t)d->self << 4) | (loff_t)1;
21
+
return ((loff_t)le32_to_cpu(d->self) << 4) | (loff_t)1;
22
22
}
23
23
24
24
void hpfs_add_pos(struct inode *inode, loff_t *pos)
···
130
130
{
131
131
struct hpfs_dirent *de;
132
132
if (!(de = dnode_last_de(d))) {
133
-
hpfs_error(s, "set_last_pointer: empty dnode %08x", d->self);
133
+
hpfs_error(s, "set_last_pointer: empty dnode %08x", le32_to_cpu(d->self));
134
134
return;
135
135
}
136
136
if (hpfs_sb(s)->sb_chk) {
137
137
if (de->down) {
138
138
hpfs_error(s, "set_last_pointer: dnode %08x has already last pointer %08x",
139
-
d->self, de_down_pointer(de));
139
+
le32_to_cpu(d->self), de_down_pointer(de));
140
140
return;
141
141
}
142
-
if (de->length != 32) {
143
-
hpfs_error(s, "set_last_pointer: bad last dirent in dnode %08x", d->self);
142
+
if (le16_to_cpu(de->length) != 32) {
143
+
hpfs_error(s, "set_last_pointer: bad last dirent in dnode %08x", le32_to_cpu(d->self));
144
144
return;
145
145
}
146
146
}
147
147
if (ptr) {
148
-
if ((d->first_free += 4) > 2048) {
149
-
hpfs_error(s,"set_last_pointer: too long dnode %08x", d->self);
150
-
d->first_free -= 4;
148
+
d->first_free = cpu_to_le32(le32_to_cpu(d->first_free) + 4);
149
+
if (le32_to_cpu(d->first_free) > 2048) {
150
+
hpfs_error(s, "set_last_pointer: too long dnode %08x", le32_to_cpu(d->self));
151
+
d->first_free = cpu_to_le32(le32_to_cpu(d->first_free) - 4);
151
152
return;
152
153
}
153
-
de->length = 36;
154
+
de->length = cpu_to_le16(36);
154
155
de->down = 1;
155
-
*(dnode_secno *)((char *)de + 32) = ptr;
156
+
*(dnode_secno *)((char *)de + 32) = cpu_to_le32(ptr);
156
157
}
157
158
}
158
159
···
169
168
for (de = dnode_first_de(d); de < de_end; de = de_next_de(de)) {
170
169
int c = hpfs_compare_names(s, name, namelen, de->name, de->namelen, de->last);
171
170
if (!c) {
172
-
hpfs_error(s, "name (%c,%d) already exists in dnode %08x", *name, namelen, d->self);
171
+
hpfs_error(s, "name (%c,%d) already exists in dnode %08x", *name, namelen, le32_to_cpu(d->self));
173
172
return NULL;
174
173
}
175
174
if (c < 0) break;
···
177
176
memmove((char *)de + d_size, de, (char *)de_end - (char *)de);
178
177
memset(de, 0, d_size);
179
178
if (down_ptr) {
180
-
*(int *)((char *)de + d_size - 4) = down_ptr;
179
+
*(dnode_secno *)((char *)de + d_size - 4) = cpu_to_le32(down_ptr);
181
180
de->down = 1;
182
181
}
183
-
de->length = d_size;
184
-
if (down_ptr) de->down = 1;
182
+
de->length = cpu_to_le16(d_size);
185
183
de->not_8x3 = hpfs_is_name_long(name, namelen);
186
184
de->namelen = namelen;
187
185
memcpy(de->name, name, namelen);
188
-
d->first_free += d_size;
186
+
d->first_free = cpu_to_le32(le32_to_cpu(d->first_free) + d_size);
189
187
return de;
190
188
}
191
189
···
194
194
struct hpfs_dirent *de)
195
195
{
196
196
if (de->last) {
197
-
hpfs_error(s, "attempt to delete last dirent in dnode %08x", d->self);
197
+
hpfs_error(s, "attempt to delete last dirent in dnode %08x", le32_to_cpu(d->self));
198
198
return;
199
199
}
200
-
d->first_free -= de->length;
201
-
memmove(de, de_next_de(de), d->first_free + (char *)d - (char *)de);
200
+
d->first_free = cpu_to_le32(le32_to_cpu(d->first_free) - le16_to_cpu(de->length));
201
+
memmove(de, de_next_de(de), le32_to_cpu(d->first_free) + (char *)d - (char *)de);
202
202
}
203
203
204
204
static void fix_up_ptrs(struct super_block *s, struct dnode *d)
205
205
{
206
206
struct hpfs_dirent *de;
207
207
struct hpfs_dirent *de_end = dnode_end_de(d);
208
-
dnode_secno dno = d->self;
208
+
dnode_secno dno = le32_to_cpu(d->self);
209
209
for (de = dnode_first_de(d); de < de_end; de = de_next_de(de))
210
210
if (de->down) {
211
211
struct quad_buffer_head qbh;
212
212
struct dnode *dd;
213
213
if ((dd = hpfs_map_dnode(s, de_down_pointer(de), &qbh))) {
214
-
if (dd->up != dno || dd->root_dnode) {
215
-
dd->up = dno;
214
+
if (le32_to_cpu(dd->up) != dno || dd->root_dnode) {
215
+
dd->up = cpu_to_le32(dno);
216
216
dd->root_dnode = 0;
217
217
hpfs_mark_4buffers_dirty(&qbh);
218
218
}
···
262
262
kfree(nname);
263
263
return 1;
264
264
}
265
-
if (d->first_free + de_size(namelen, down_ptr) <= 2048) {
265
+
if (le32_to_cpu(d->first_free) + de_size(namelen, down_ptr) <= 2048) {
266
266
loff_t t;
267
267
copy_de(de=hpfs_add_de(i->i_sb, d, name, namelen, down_ptr), new_de);
268
268
t = get_pos(d, de);
···
286
286
kfree(nname);
287
287
return 1;
288
288
}
289
-
memcpy(nd, d, d->first_free);
289
+
memcpy(nd, d, le32_to_cpu(d->first_free));
290
290
copy_de(de = hpfs_add_de(i->i_sb, nd, name, namelen, down_ptr), new_de);
291
291
for_all_poss(i, hpfs_pos_ins, get_pos(nd, de), 1);
292
292
h = ((char *)dnode_last_de(nd) - (char *)nd) / 2 + 10;
293
-
if (!(ad = hpfs_alloc_dnode(i->i_sb, d->up, &adno, &qbh1, 0))) {
293
+
if (!(ad = hpfs_alloc_dnode(i->i_sb, le32_to_cpu(d->up), &adno, &qbh1))) {
294
294
hpfs_error(i->i_sb, "unable to alloc dnode - dnode tree will be corrupted");
295
295
hpfs_brelse4(&qbh);
296
296
kfree(nd);
···
313
313
down_ptr = adno;
314
314
set_last_pointer(i->i_sb, ad, de->down ? de_down_pointer(de) : 0);
315
315
de = de_next_de(de);
316
-
memmove((char *)nd + 20, de, nd->first_free + (char *)nd - (char *)de);
317
-
nd->first_free -= (char *)de - (char *)nd - 20;
318
-
memcpy(d, nd, nd->first_free);
316
+
memmove((char *)nd + 20, de, le32_to_cpu(nd->first_free) + (char *)nd - (char *)de);
317
+
nd->first_free = cpu_to_le32(le32_to_cpu(nd->first_free) - ((char *)de - (char *)nd - 20));
318
+
memcpy(d, nd, le32_to_cpu(nd->first_free));
319
319
for_all_poss(i, hpfs_pos_del, (loff_t)dno << 4, pos);
320
320
fix_up_ptrs(i->i_sb, ad);
321
321
if (!d->root_dnode) {
322
-
dno = ad->up = d->up;
322
+
ad->up = d->up;
323
+
dno = le32_to_cpu(ad->up);
323
324
hpfs_mark_4buffers_dirty(&qbh);
324
325
hpfs_brelse4(&qbh);
325
326
hpfs_mark_4buffers_dirty(&qbh1);
326
327
hpfs_brelse4(&qbh1);
327
328
goto go_up;
328
329
}
329
-
if (!(rd = hpfs_alloc_dnode(i->i_sb, d->up, &rdno, &qbh2, 0))) {
330
+
if (!(rd = hpfs_alloc_dnode(i->i_sb, le32_to_cpu(d->up), &rdno, &qbh2))) {
330
331
hpfs_error(i->i_sb, "unable to alloc dnode - dnode tree will be corrupted");
331
332
hpfs_brelse4(&qbh);
332
333
hpfs_brelse4(&qbh1);
···
339
338
i->i_blocks += 4;
340
339
rd->root_dnode = 1;
341
340
rd->up = d->up;
342
-
if (!(fnode = hpfs_map_fnode(i->i_sb, d->up, &bh))) {
341
+
if (!(fnode = hpfs_map_fnode(i->i_sb, le32_to_cpu(d->up), &bh))) {
343
342
hpfs_free_dnode(i->i_sb, rdno);
344
343
hpfs_brelse4(&qbh);
345
344
hpfs_brelse4(&qbh1);
···
348
347
kfree(nname);
349
348
return 1;
350
349
}
351
-
fnode->u.external[0].disk_secno = rdno;
350
+
fnode->u.external[0].disk_secno = cpu_to_le32(rdno);
352
351
mark_buffer_dirty(bh);
353
352
brelse(bh);
354
-
d->up = ad->up = hpfs_i(i)->i_dno = rdno;
353
+
hpfs_i(i)->i_dno = rdno;
354
+
d->up = ad->up = cpu_to_le32(rdno);
355
355
d->root_dnode = ad->root_dnode = 0;
356
356
hpfs_mark_4buffers_dirty(&qbh);
357
357
hpfs_brelse4(&qbh);
···
375
373
376
374
int hpfs_add_dirent(struct inode *i,
377
375
const unsigned char *name, unsigned namelen,
378
-
struct hpfs_dirent *new_de, int cdepth)
376
+
struct hpfs_dirent *new_de)
379
377
{
380
378
struct hpfs_inode_info *hpfs_inode = hpfs_i(i);
381
379
struct dnode *d;
···
405
403
}
406
404
}
407
405
hpfs_brelse4(&qbh);
408
-
if (!cdepth) hpfs_lock_creation(i->i_sb);
409
406
if (hpfs_check_free_dnodes(i->i_sb, FREE_DNODES_ADD)) {
410
407
c = 1;
411
408
goto ret;
···
412
411
i->i_version++;
413
412
c = hpfs_add_to_dnode(i, dno, name, namelen, new_de, 0);
414
413
ret:
415
-
if (!cdepth) hpfs_unlock_creation(i->i_sb);
416
414
return c;
417
415
}
418
416
···
437
437
return 0;
438
438
if (!(dnode = hpfs_map_dnode(i->i_sb, dno, &qbh))) return 0;
439
439
if (hpfs_sb(i->i_sb)->sb_chk) {
440
-
if (dnode->up != chk_up) {
440
+
if (le32_to_cpu(dnode->up) != chk_up) {
441
441
hpfs_error(i->i_sb, "move_to_top: up pointer from %08x should be %08x, is %08x",
442
-
dno, chk_up, dnode->up);
442
+
dno, chk_up, le32_to_cpu(dnode->up));
443
443
hpfs_brelse4(&qbh);
444
444
return 0;
445
445
}
···
455
455
hpfs_brelse4(&qbh);
456
456
}
457
457
while (!(de = dnode_pre_last_de(dnode))) {
458
-
dnode_secno up = dnode->up;
458
+
dnode_secno up = le32_to_cpu(dnode->up);
459
459
hpfs_brelse4(&qbh);
460
460
hpfs_free_dnode(i->i_sb, dno);
461
461
i->i_size -= 2048;
···
474
474
hpfs_brelse4(&qbh);
475
475
return 0;
476
476
}
477
-
dnode->first_free -= 4;
478
-
de->length -= 4;
477
+
dnode->first_free = cpu_to_le32(le32_to_cpu(dnode->first_free) - 4);
478
+
de->length = cpu_to_le16(le16_to_cpu(de->length) - 4);
479
479
de->down = 0;
480
480
hpfs_mark_4buffers_dirty(&qbh);
481
481
dno = up;
···
483
483
t = get_pos(dnode, de);
484
484
for_all_poss(i, hpfs_pos_subst, t, 4);
485
485
for_all_poss(i, hpfs_pos_subst, t + 1, 5);
486
-
if (!(nde = kmalloc(de->length, GFP_NOFS))) {
486
+
if (!(nde = kmalloc(le16_to_cpu(de->length), GFP_NOFS))) {
487
487
hpfs_error(i->i_sb, "out of memory for dirent - directory will be corrupted");
488
488
hpfs_brelse4(&qbh);
489
489
return 0;
490
490
}
491
-
memcpy(nde, de, de->length);
491
+
memcpy(nde, de, le16_to_cpu(de->length));
492
492
ddno = de->down ? de_down_pointer(de) : 0;
493
493
hpfs_delete_de(i->i_sb, dnode, de);
494
494
set_last_pointer(i->i_sb, dnode, ddno);
···
517
517
try_it_again:
518
518
if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "delete_empty_dnode")) return;
519
519
if (!(dnode = hpfs_map_dnode(i->i_sb, dno, &qbh))) return;
520
-
if (dnode->first_free > 56) goto end;
521
-
if (dnode->first_free == 52 || dnode->first_free == 56) {
520
+
if (le32_to_cpu(dnode->first_free) > 56) goto end;
521
+
if (le32_to_cpu(dnode->first_free) == 52 || le32_to_cpu(dnode->first_free) == 56) {
522
522
struct hpfs_dirent *de_end;
523
523
int root = dnode->root_dnode;
524
-
up = dnode->up;
524
+
up = le32_to_cpu(dnode->up);
525
525
de = dnode_first_de(dnode);
526
526
down = de->down ? de_down_pointer(de) : 0;
527
527
if (hpfs_sb(i->i_sb)->sb_chk) if (root && !down) {
···
545
545
return;
546
546
}
547
547
if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) {
548
-
d1->up = up;
548
+
d1->up = cpu_to_le32(up);
549
549
d1->root_dnode = 1;
550
550
hpfs_mark_4buffers_dirty(&qbh1);
551
551
hpfs_brelse4(&qbh1);
552
552
}
553
553
if ((fnode = hpfs_map_fnode(i->i_sb, up, &bh))) {
554
-
fnode->u.external[0].disk_secno = down;
554
+
fnode->u.external[0].disk_secno = cpu_to_le32(down);
555
555
mark_buffer_dirty(bh);
556
556
brelse(bh);
557
557
}
···
570
570
for_all_poss(i, hpfs_pos_subst, ((loff_t)dno << 4) | 1, ((loff_t)up << 4) | p);
571
571
if (!down) {
572
572
de->down = 0;
573
-
de->length -= 4;
574
-
dnode->first_free -= 4;
573
+
de->length = cpu_to_le16(le16_to_cpu(de->length) - 4);
574
+
dnode->first_free = cpu_to_le32(le32_to_cpu(dnode->first_free) - 4);
575
575
memmove(de_next_de(de), (char *)de_next_de(de) + 4,
576
-
(char *)dnode + dnode->first_free - (char *)de_next_de(de));
576
+
(char *)dnode + le32_to_cpu(dnode->first_free) - (char *)de_next_de(de));
577
577
} else {
578
578
struct dnode *d1;
579
579
struct quad_buffer_head qbh1;
580
-
*(dnode_secno *) ((void *) de + de->length - 4) = down;
580
+
*(dnode_secno *) ((void *) de + le16_to_cpu(de->length) - 4) = down;
581
581
if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) {
582
-
d1->up = up;
582
+
d1->up = cpu_to_le32(up);
583
583
hpfs_mark_4buffers_dirty(&qbh1);
584
584
hpfs_brelse4(&qbh1);
585
585
}
586
586
}
587
587
} else {
588
-
hpfs_error(i->i_sb, "delete_empty_dnode: dnode %08x, first_free == %03x", dno, dnode->first_free);
588
+
hpfs_error(i->i_sb, "delete_empty_dnode: dnode %08x, first_free == %03x", dno, le32_to_cpu(dnode->first_free));
589
589
goto end;
590
590
}
591
591
···
596
596
struct quad_buffer_head qbh1;
597
597
if (!de_next->down) goto endm;
598
598
ndown = de_down_pointer(de_next);
599
-
if (!(de_cp = kmalloc(de->length, GFP_NOFS))) {
599
+
if (!(de_cp = kmalloc(le16_to_cpu(de->length), GFP_NOFS))) {
600
600
printk("HPFS: out of memory for dtree balancing\n");
601
601
goto endm;
602
602
}
603
-
memcpy(de_cp, de, de->length);
603
+
memcpy(de_cp, de, le16_to_cpu(de->length));
604
604
hpfs_delete_de(i->i_sb, dnode, de);
605
605
hpfs_mark_4buffers_dirty(&qbh);
606
606
hpfs_brelse4(&qbh);
607
607
for_all_poss(i, hpfs_pos_subst, ((loff_t)up << 4) | p, 4);
608
608
for_all_poss(i, hpfs_pos_del, ((loff_t)up << 4) | p, 1);
609
609
if (de_cp->down) if ((d1 = hpfs_map_dnode(i->i_sb, de_down_pointer(de_cp), &qbh1))) {
610
-
d1->up = ndown;
610
+
d1->up = cpu_to_le32(ndown);
611
611
hpfs_mark_4buffers_dirty(&qbh1);
612
612
hpfs_brelse4(&qbh1);
613
613
}
···
635
635
struct hpfs_dirent *del = dnode_last_de(d1);
636
636
dlp = del->down ? de_down_pointer(del) : 0;
637
637
if (!dlp && down) {
638
-
if (d1->first_free > 2044) {
638
+
if (le32_to_cpu(d1->first_free) > 2044) {
639
639
if (hpfs_sb(i->i_sb)->sb_chk >= 2) {
640
640
printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n");
641
641
printk("HPFS: warning: terminating balancing operation\n");
···
647
647
printk("HPFS: warning: unbalanced dnode tree, see hpfs.txt 4 more info\n");
648
648
printk("HPFS: warning: goin'on\n");
649
649
}
650
-
del->length += 4;
650
+
del->length = cpu_to_le16(le16_to_cpu(del->length) + 4);
651
651
del->down = 1;
652
-
d1->first_free += 4;
652
+
d1->first_free = cpu_to_le32(le32_to_cpu(d1->first_free) + 4);
653
653
}
654
654
if (dlp && !down) {
655
-
del->length -= 4;
655
+
del->length = cpu_to_le16(le16_to_cpu(del->length) - 4);
656
656
del->down = 0;
657
-
d1->first_free -= 4;
657
+
d1->first_free = cpu_to_le32(le32_to_cpu(d1->first_free) - 4);
658
658
} else if (down)
659
-
*(dnode_secno *) ((void *) del + del->length - 4) = down;
659
+
*(dnode_secno *) ((void *) del + le16_to_cpu(del->length) - 4) = cpu_to_le32(down);
660
660
} else goto endm;
661
-
if (!(de_cp = kmalloc(de_prev->length, GFP_NOFS))) {
661
+
if (!(de_cp = kmalloc(le16_to_cpu(de_prev->length), GFP_NOFS))) {
662
662
printk("HPFS: out of memory for dtree balancing\n");
663
663
hpfs_brelse4(&qbh1);
664
664
goto endm;
665
665
}
666
666
hpfs_mark_4buffers_dirty(&qbh1);
667
667
hpfs_brelse4(&qbh1);
668
-
memcpy(de_cp, de_prev, de_prev->length);
668
+
memcpy(de_cp, de_prev, le16_to_cpu(de_prev->length));
669
669
hpfs_delete_de(i->i_sb, dnode, de_prev);
670
670
if (!de_prev->down) {
671
-
de_prev->length += 4;
671
+
de_prev->length = cpu_to_le16(le16_to_cpu(de_prev->length) + 4);
672
672
de_prev->down = 1;
673
-
dnode->first_free += 4;
673
+
dnode->first_free = cpu_to_le32(le32_to_cpu(dnode->first_free) + 4);
674
674
}
675
-
*(dnode_secno *) ((void *) de_prev + de_prev->length - 4) = ndown;
675
+
*(dnode_secno *) ((void *) de_prev + le16_to_cpu(de_prev->length) - 4) = cpu_to_le32(ndown);
676
676
hpfs_mark_4buffers_dirty(&qbh);
677
677
hpfs_brelse4(&qbh);
678
678
for_all_poss(i, hpfs_pos_subst, ((loff_t)up << 4) | (p - 1), 4);
679
679
for_all_poss(i, hpfs_pos_subst, ((loff_t)up << 4) | p, ((loff_t)up << 4) | (p - 1));
680
680
if (down) if ((d1 = hpfs_map_dnode(i->i_sb, de_down_pointer(de), &qbh1))) {
681
-
d1->up = ndown;
681
+
d1->up = cpu_to_le32(ndown);
682
682
hpfs_mark_4buffers_dirty(&qbh1);
683
683
hpfs_brelse4(&qbh1);
684
684
}
···
701
701
{
702
702
struct dnode *dnode = qbh->data;
703
703
dnode_secno down = 0;
704
-
int lock = 0;
705
704
loff_t t;
706
705
if (de->first || de->last) {
707
706
hpfs_error(i->i_sb, "hpfs_remove_dirent: attempt to delete first or last dirent in dnode %08x", dno);
···
709
710
}
710
711
if (de->down) down = de_down_pointer(de);
711
712
if (depth && (de->down || (de == dnode_first_de(dnode) && de_next_de(de)->last))) {
712
-
lock = 1;
713
-
hpfs_lock_creation(i->i_sb);
714
713
if (hpfs_check_free_dnodes(i->i_sb, FREE_DNODES_DEL)) {
715
714
hpfs_brelse4(qbh);
716
-
hpfs_unlock_creation(i->i_sb);
717
715
return 2;
718
716
}
719
717
}
···
723
727
dnode_secno a = move_to_top(i, down, dno);
724
728
for_all_poss(i, hpfs_pos_subst, 5, t);
725
729
if (a) delete_empty_dnode(i, a);
726
-
if (lock) hpfs_unlock_creation(i->i_sb);
727
730
return !a;
728
731
}
729
732
delete_empty_dnode(i, dno);
730
-
if (lock) hpfs_unlock_creation(i->i_sb);
731
733
return 0;
732
734
}
733
735
···
745
751
ptr = 0;
746
752
go_up:
747
753
if (!(dnode = hpfs_map_dnode(s, dno, &qbh))) return;
748
-
if (hpfs_sb(s)->sb_chk) if (odno && odno != -1 && dnode->up != odno)
749
-
hpfs_error(s, "hpfs_count_dnodes: bad up pointer; dnode %08x, down %08x points to %08x", odno, dno, dnode->up);
754
+
if (hpfs_sb(s)->sb_chk) if (odno && odno != -1 && le32_to_cpu(dnode->up) != odno)
755
+
hpfs_error(s, "hpfs_count_dnodes: bad up pointer; dnode %08x, down %08x points to %08x", odno, dno, le32_to_cpu(dnode->up));
750
756
de = dnode_first_de(dnode);
751
757
if (ptr) while(1) {
752
758
if (de->down) if (de_down_pointer(de) == ptr) goto process_de;
···
770
776
if (!de->first && !de->last && n_items) (*n_items)++;
771
777
if ((de = de_next_de(de)) < dnode_end_de(dnode)) goto next_de;
772
778
ptr = dno;
773
-
dno = dnode->up;
779
+
dno = le32_to_cpu(dnode->up);
774
780
if (dnode->root_dnode) {
775
781
hpfs_brelse4(&qbh);
776
782
return;
···
818
824
return d;
819
825
if (!(de = map_nth_dirent(s, d, 1, &qbh, NULL))) return dno;
820
826
if (hpfs_sb(s)->sb_chk)
821
-
if (up && ((struct dnode *)qbh.data)->up != up)
822
-
hpfs_error(s, "hpfs_de_as_down_as_possible: bad up pointer; dnode %08x, down %08x points to %08x", up, d, ((struct dnode *)qbh.data)->up);
827
+
if (up && le32_to_cpu(((struct dnode *)qbh.data)->up) != up)
828
+
hpfs_error(s, "hpfs_de_as_down_as_possible: bad up pointer; dnode %08x, down %08x points to %08x", up, d, le32_to_cpu(((struct dnode *)qbh.data)->up));
823
829
if (!de->down) {
824
830
hpfs_brelse4(&qbh);
825
831
return d;
···
868
874
/* Going up */
869
875
if (dnode->root_dnode) goto bail;
870
876
871
-
if (!(up_dnode = hpfs_map_dnode(inode->i_sb, dnode->up, &qbh0)))
877
+
if (!(up_dnode = hpfs_map_dnode(inode->i_sb, le32_to_cpu(dnode->up), &qbh0)))
872
878
goto bail;
873
879
874
880
end_up_de = dnode_end_de(up_dnode);
···
876
882
for (up_de = dnode_first_de(up_dnode); up_de < end_up_de;
877
883
up_de = de_next_de(up_de)) {
878
884
if (!(++c & 077)) hpfs_error(inode->i_sb,
879
-
"map_pos_dirent: pos crossed dnode boundary; dnode = %08x", dnode->up);
885
+
"map_pos_dirent: pos crossed dnode boundary; dnode = %08x", le32_to_cpu(dnode->up));
880
886
if (up_de->down && de_down_pointer(up_de) == dno) {
881
-
*posp = ((loff_t) dnode->up << 4) + c;
887
+
*posp = ((loff_t) le32_to_cpu(dnode->up) << 4) + c;
882
888
hpfs_brelse4(&qbh0);
883
889
return de;
884
890
}
885
891
}
886
892
887
893
hpfs_error(inode->i_sb, "map_pos_dirent: pointer to dnode %08x not found in parent dnode %08x",
888
-
dno, dnode->up);
894
+
dno, le32_to_cpu(dnode->up));
889
895
hpfs_brelse4(&qbh0);
890
896
891
897
bail:
···
1011
1017
/*name2[15] = 0xff;*/
1012
1018
name1len = 15; name2len = 256;
1013
1019
}
1014
-
if (!(upf = hpfs_map_fnode(s, f->up, &bh))) {
1020
+
if (!(upf = hpfs_map_fnode(s, le32_to_cpu(f->up), &bh))) {
1015
1021
kfree(name2);
1016
1022
return NULL;
1017
1023
}
1018
1024
if (!upf->dirflag) {
1019
1025
brelse(bh);
1020
-
hpfs_error(s, "fnode %08x has non-directory parent %08x", fno, f->up);
1026
+
hpfs_error(s, "fnode %08x has non-directory parent %08x", fno, le32_to_cpu(f->up));
1021
1027
kfree(name2);
1022
1028
return NULL;
1023
1029
}
1024
-
dno = upf->u.external[0].disk_secno;
1030
+
dno = le32_to_cpu(upf->u.external[0].disk_secno);
1025
1031
brelse(bh);
1026
1032
go_down:
1027
1033
downd = 0;
···
1043
1049
return NULL;
1044
1050
}
1045
1051
next_de:
1046
-
if (de->fnode == fno) {
1052
+
if (le32_to_cpu(de->fnode) == fno) {
1047
1053
kfree(name2);
1048
1054
return de;
1049
1055
}
···
1059
1065
goto go_down;
1060
1066
}
1061
1067
f:
1062
-
if (de->fnode == fno) {
1068
+
if (le32_to_cpu(de->fnode) == fno) {
1063
1069
kfree(name2);
1064
1070
return de;
1065
1071
}
···
1068
1074
if ((de = de_next_de(de)) < de_end) goto next_de;
1069
1075
if (d->root_dnode) goto not_found;
1070
1076
downd = dno;
1071
-
dno = d->up;
1077
+
dno = le32_to_cpu(d->up);
1072
1078
hpfs_brelse4(qbh);
1073
1079
if (hpfs_sb(s)->sb_chk)
1074
1080
if (hpfs_stop_cycles(s, downd, &d1, &d2, "map_fnode_dirent #2")) {
+69
-67
fs/hpfs/ea.c
+69
-67
fs/hpfs/ea.c
···
24
24
}
25
25
if (hpfs_ea_read(s, a, ano, pos, 4, ex)) return;
26
26
if (ea->indirect) {
27
-
if (ea->valuelen != 8) {
27
+
if (ea_valuelen(ea) != 8) {
28
28
hpfs_error(s, "ea->indirect set while ea->valuelen!=8, %s %08x, pos %08x",
29
29
ano ? "anode" : "sectors", a, pos);
30
30
return;
···
33
33
return;
34
34
hpfs_ea_remove(s, ea_sec(ea), ea->anode, ea_len(ea));
35
35
}
36
-
pos += ea->namelen + ea->valuelen + 5;
36
+
pos += ea->namelen + ea_valuelen(ea) + 5;
37
37
}
38
38
if (!ano) hpfs_free_sectors(s, a, (len+511) >> 9);
39
39
else {
···
76
76
unsigned pos;
77
77
int ano, len;
78
78
secno a;
79
+
char ex[4 + 255 + 1 + 8];
79
80
struct extended_attribute *ea;
80
81
struct extended_attribute *ea_end = fnode_end_ea(fnode);
81
82
for (ea = fnode_ea(fnode); ea < ea_end; ea = next_ea(ea))
82
83
if (!strcmp(ea->name, key)) {
83
84
if (ea->indirect)
84
85
goto indirect;
85
-
if (ea->valuelen >= size)
86
+
if (ea_valuelen(ea) >= size)
86
87
return -EINVAL;
87
-
memcpy(buf, ea_data(ea), ea->valuelen);
88
-
buf[ea->valuelen] = 0;
88
+
memcpy(buf, ea_data(ea), ea_valuelen(ea));
89
+
buf[ea_valuelen(ea)] = 0;
89
90
return 0;
90
91
}
91
-
a = fnode->ea_secno;
92
-
len = fnode->ea_size_l;
92
+
a = le32_to_cpu(fnode->ea_secno);
93
+
len = le32_to_cpu(fnode->ea_size_l);
93
94
ano = fnode->ea_anode;
94
95
pos = 0;
95
96
while (pos < len) {
96
-
char ex[4 + 255 + 1 + 8];
97
97
ea = (struct extended_attribute *)ex;
98
98
if (pos + 4 > len) {
99
99
hpfs_error(s, "EAs don't end correctly, %s %08x, len %08x",
···
106
106
if (!strcmp(ea->name, key)) {
107
107
if (ea->indirect)
108
108
goto indirect;
109
-
if (ea->valuelen >= size)
109
+
if (ea_valuelen(ea) >= size)
110
110
return -EINVAL;
111
-
if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea->valuelen, buf))
111
+
if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea_valuelen(ea), buf))
112
112
return -EIO;
113
-
buf[ea->valuelen] = 0;
113
+
buf[ea_valuelen(ea)] = 0;
114
114
return 0;
115
115
}
116
-
pos += ea->namelen + ea->valuelen + 5;
116
+
pos += ea->namelen + ea_valuelen(ea) + 5;
117
117
}
118
118
return -ENOENT;
119
119
indirect:
···
138
138
if (!strcmp(ea->name, key)) {
139
139
if (ea->indirect)
140
140
return get_indirect_ea(s, ea->anode, ea_sec(ea), *size = ea_len(ea));
141
-
if (!(ret = kmalloc((*size = ea->valuelen) + 1, GFP_NOFS))) {
141
+
if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
142
142
printk("HPFS: out of memory for EA\n");
143
143
return NULL;
144
144
}
145
-
memcpy(ret, ea_data(ea), ea->valuelen);
146
-
ret[ea->valuelen] = 0;
145
+
memcpy(ret, ea_data(ea), ea_valuelen(ea));
146
+
ret[ea_valuelen(ea)] = 0;
147
147
return ret;
148
148
}
149
-
a = fnode->ea_secno;
150
-
len = fnode->ea_size_l;
149
+
a = le32_to_cpu(fnode->ea_secno);
150
+
len = le32_to_cpu(fnode->ea_size_l);
151
151
ano = fnode->ea_anode;
152
152
pos = 0;
153
153
while (pos < len) {
···
164
164
if (!strcmp(ea->name, key)) {
165
165
if (ea->indirect)
166
166
return get_indirect_ea(s, ea->anode, ea_sec(ea), *size = ea_len(ea));
167
-
if (!(ret = kmalloc((*size = ea->valuelen) + 1, GFP_NOFS))) {
167
+
if (!(ret = kmalloc((*size = ea_valuelen(ea)) + 1, GFP_NOFS))) {
168
168
printk("HPFS: out of memory for EA\n");
169
169
return NULL;
170
170
}
171
-
if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea->valuelen, ret)) {
171
+
if (hpfs_ea_read(s, a, ano, pos + 4 + ea->namelen + 1, ea_valuelen(ea), ret)) {
172
172
kfree(ret);
173
173
return NULL;
174
174
}
175
-
ret[ea->valuelen] = 0;
175
+
ret[ea_valuelen(ea)] = 0;
176
176
return ret;
177
177
}
178
-
pos += ea->namelen + ea->valuelen + 5;
178
+
pos += ea->namelen + ea_valuelen(ea) + 5;
179
179
}
180
180
return NULL;
181
181
}
···
202
202
if (ea->indirect) {
203
203
if (ea_len(ea) == size)
204
204
set_indirect_ea(s, ea->anode, ea_sec(ea), data, size);
205
-
} else if (ea->valuelen == size) {
205
+
} else if (ea_valuelen(ea) == size) {
206
206
memcpy(ea_data(ea), data, size);
207
207
}
208
208
return;
209
209
}
210
-
a = fnode->ea_secno;
211
-
len = fnode->ea_size_l;
210
+
a = le32_to_cpu(fnode->ea_secno);
211
+
len = le32_to_cpu(fnode->ea_size_l);
212
212
ano = fnode->ea_anode;
213
213
pos = 0;
214
214
while (pos < len) {
···
228
228
set_indirect_ea(s, ea->anode, ea_sec(ea), data, size);
229
229
}
230
230
else {
231
-
if (ea->valuelen == size)
231
+
if (ea_valuelen(ea) == size)
232
232
hpfs_ea_write(s, a, ano, pos + 4 + ea->namelen + 1, size, data);
233
233
}
234
234
return;
235
235
}
236
-
pos += ea->namelen + ea->valuelen + 5;
236
+
pos += ea->namelen + ea_valuelen(ea) + 5;
237
237
}
238
-
if (!fnode->ea_offs) {
239
-
/*if (fnode->ea_size_s) {
238
+
if (!le16_to_cpu(fnode->ea_offs)) {
239
+
/*if (le16_to_cpu(fnode->ea_size_s)) {
240
240
hpfs_error(s, "fnode %08x: ea_size_s == %03x, ea_offs == 0",
241
-
inode->i_ino, fnode->ea_size_s);
241
+
inode->i_ino, le16_to_cpu(fnode->ea_size_s));
242
242
return;
243
243
}*/
244
-
fnode->ea_offs = 0xc4;
244
+
fnode->ea_offs = cpu_to_le16(0xc4);
245
245
}
246
-
if (fnode->ea_offs < 0xc4 || fnode->ea_offs + fnode->acl_size_s + fnode->ea_size_s > 0x200) {
246
+
if (le16_to_cpu(fnode->ea_offs) < 0xc4 || le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s) > 0x200) {
247
247
hpfs_error(s, "fnode %08lx: ea_offs == %03x, ea_size_s == %03x",
248
248
(unsigned long)inode->i_ino,
249
-
fnode->ea_offs, fnode->ea_size_s);
249
+
le32_to_cpu(fnode->ea_offs), le16_to_cpu(fnode->ea_size_s));
250
250
return;
251
251
}
252
-
if ((fnode->ea_size_s || !fnode->ea_size_l) &&
253
-
fnode->ea_offs + fnode->acl_size_s + fnode->ea_size_s + strlen(key) + size + 5 <= 0x200) {
252
+
if ((le16_to_cpu(fnode->ea_size_s) || !le32_to_cpu(fnode->ea_size_l)) &&
253
+
le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s) + strlen(key) + size + 5 <= 0x200) {
254
254
ea = fnode_end_ea(fnode);
255
255
*(char *)ea = 0;
256
256
ea->namelen = strlen(key);
257
-
ea->valuelen = size;
257
+
ea->valuelen_lo = size;
258
+
ea->valuelen_hi = size >> 8;
258
259
strcpy(ea->name, key);
259
260
memcpy(ea_data(ea), data, size);
260
-
fnode->ea_size_s += strlen(key) + size + 5;
261
+
fnode->ea_size_s = cpu_to_le16(le16_to_cpu(fnode->ea_size_s) + strlen(key) + size + 5);
261
262
goto ret;
262
263
}
263
264
/* Most the code here is 99.9993422% unused. I hope there are no bugs.
264
265
But what .. HPFS.IFS has also bugs in ea management. */
265
-
if (fnode->ea_size_s && !fnode->ea_size_l) {
266
+
if (le16_to_cpu(fnode->ea_size_s) && !le32_to_cpu(fnode->ea_size_l)) {
266
267
secno n;
267
268
struct buffer_head *bh;
268
269
char *data;
269
-
if (!(n = hpfs_alloc_sector(s, fno, 1, 0, 1))) return;
270
+
if (!(n = hpfs_alloc_sector(s, fno, 1, 0))) return;
270
271
if (!(data = hpfs_get_sector(s, n, &bh))) {
271
272
hpfs_free_sectors(s, n, 1);
272
273
return;
273
274
}
274
-
memcpy(data, fnode_ea(fnode), fnode->ea_size_s);
275
-
fnode->ea_size_l = fnode->ea_size_s;
276
-
fnode->ea_size_s = 0;
277
-
fnode->ea_secno = n;
278
-
fnode->ea_anode = 0;
275
+
memcpy(data, fnode_ea(fnode), le16_to_cpu(fnode->ea_size_s));
276
+
fnode->ea_size_l = cpu_to_le32(le16_to_cpu(fnode->ea_size_s));
277
+
fnode->ea_size_s = cpu_to_le16(0);
278
+
fnode->ea_secno = cpu_to_le32(n);
279
+
fnode->ea_anode = cpu_to_le32(0);
279
280
mark_buffer_dirty(bh);
280
281
brelse(bh);
281
282
}
282
-
pos = fnode->ea_size_l + 5 + strlen(key) + size;
283
-
len = (fnode->ea_size_l + 511) >> 9;
283
+
pos = le32_to_cpu(fnode->ea_size_l) + 5 + strlen(key) + size;
284
+
len = (le32_to_cpu(fnode->ea_size_l) + 511) >> 9;
284
285
if (pos >= 30000) goto bail;
285
286
while (((pos + 511) >> 9) > len) {
286
287
if (!len) {
287
-
if (!(fnode->ea_secno = hpfs_alloc_sector(s, fno, 1, 0, 1)))
288
-
goto bail;
288
+
secno q = hpfs_alloc_sector(s, fno, 1, 0);
289
+
if (!q) goto bail;
290
+
fnode->ea_secno = cpu_to_le32(q);
289
291
fnode->ea_anode = 0;
290
292
len++;
291
293
} else if (!fnode->ea_anode) {
292
-
if (hpfs_alloc_if_possible(s, fnode->ea_secno + len)) {
294
+
if (hpfs_alloc_if_possible(s, le32_to_cpu(fnode->ea_secno) + len)) {
293
295
len++;
294
296
} else {
295
297
/* Aargh... don't know how to create ea anodes :-( */
···
300
298
anode_secno a_s;
301
299
if (!(anode = hpfs_alloc_anode(s, fno, &a_s, &bh)))
302
300
goto bail;
303
-
anode->up = fno;
301
+
anode->up = cpu_to_le32(fno);
304
302
anode->btree.fnode_parent = 1;
305
303
anode->btree.n_free_nodes--;
306
304
anode->btree.n_used_nodes++;
307
-
anode->btree.first_free += 12;
308
-
anode->u.external[0].disk_secno = fnode->ea_secno;
309
-
anode->u.external[0].file_secno = 0;
310
-
anode->u.external[0].length = len;
305
+
anode->btree.first_free = cpu_to_le16(le16_to_cpu(anode->btree.first_free) + 12);
306
+
anode->u.external[0].disk_secno = cpu_to_le32(le32_to_cpu(fnode->ea_secno));
307
+
anode->u.external[0].file_secno = cpu_to_le32(0);
308
+
anode->u.external[0].length = cpu_to_le32(len);
311
309
mark_buffer_dirty(bh);
312
310
brelse(bh);
313
311
fnode->ea_anode = 1;
314
-
fnode->ea_secno = a_s;*/
312
+
fnode->ea_secno = cpu_to_le32(a_s);*/
315
313
secno new_sec;
316
314
int i;
317
-
if (!(new_sec = hpfs_alloc_sector(s, fno, 1, 1 - ((pos + 511) >> 9), 1)))
315
+
if (!(new_sec = hpfs_alloc_sector(s, fno, 1, 1 - ((pos + 511) >> 9))))
318
316
goto bail;
319
317
for (i = 0; i < len; i++) {
320
318
struct buffer_head *bh1, *bh2;
321
319
void *b1, *b2;
322
-
if (!(b1 = hpfs_map_sector(s, fnode->ea_secno + i, &bh1, len - i - 1))) {
320
+
if (!(b1 = hpfs_map_sector(s, le32_to_cpu(fnode->ea_secno) + i, &bh1, len - i - 1))) {
323
321
hpfs_free_sectors(s, new_sec, (pos + 511) >> 9);
324
322
goto bail;
325
323
}
···
333
331
mark_buffer_dirty(bh2);
334
332
brelse(bh2);
335
333
}
336
-
hpfs_free_sectors(s, fnode->ea_secno, len);
337
-
fnode->ea_secno = new_sec;
334
+
hpfs_free_sectors(s, le32_to_cpu(fnode->ea_secno), len);
335
+
fnode->ea_secno = cpu_to_le32(new_sec);
338
336
len = (pos + 511) >> 9;
339
337
}
340
338
}
341
339
if (fnode->ea_anode) {
342
-
if (hpfs_add_sector_to_btree(s, fnode->ea_secno,
340
+
if (hpfs_add_sector_to_btree(s, le32_to_cpu(fnode->ea_secno),
343
341
0, len) != -1) {
344
342
len++;
345
343
} else {
···
351
349
h[1] = strlen(key);
352
350
h[2] = size & 0xff;
353
351
h[3] = size >> 8;
354
-
if (hpfs_ea_write(s, fnode->ea_secno, fnode->ea_anode, fnode->ea_size_l, 4, h)) goto bail;
355
-
if (hpfs_ea_write(s, fnode->ea_secno, fnode->ea_anode, fnode->ea_size_l + 4, h[1] + 1, key)) goto bail;
356
-
if (hpfs_ea_write(s, fnode->ea_secno, fnode->ea_anode, fnode->ea_size_l + 5 + h[1], size, data)) goto bail;
357
-
fnode->ea_size_l = pos;
352
+
if (hpfs_ea_write(s, le32_to_cpu(fnode->ea_secno), fnode->ea_anode, le32_to_cpu(fnode->ea_size_l), 4, h)) goto bail;
353
+
if (hpfs_ea_write(s, le32_to_cpu(fnode->ea_secno), fnode->ea_anode, le32_to_cpu(fnode->ea_size_l) + 4, h[1] + 1, key)) goto bail;
354
+
if (hpfs_ea_write(s, le32_to_cpu(fnode->ea_secno), fnode->ea_anode, le32_to_cpu(fnode->ea_size_l) + 5 + h[1], size, data)) goto bail;
355
+
fnode->ea_size_l = cpu_to_le32(pos);
358
356
ret:
359
357
hpfs_i(inode)->i_ea_size += 5 + strlen(key) + size;
360
358
return;
361
359
bail:
362
-
if (fnode->ea_secno)
363
-
if (fnode->ea_anode) hpfs_truncate_btree(s, fnode->ea_secno, 1, (fnode->ea_size_l + 511) >> 9);
364
-
else hpfs_free_sectors(s, fnode->ea_secno + ((fnode->ea_size_l + 511) >> 9), len - ((fnode->ea_size_l + 511) >> 9));
365
-
else fnode->ea_secno = fnode->ea_size_l = 0;
360
+
if (le32_to_cpu(fnode->ea_secno))
361
+
if (fnode->ea_anode) hpfs_truncate_btree(s, le32_to_cpu(fnode->ea_secno), 1, (le32_to_cpu(fnode->ea_size_l) + 511) >> 9);
362
+
else hpfs_free_sectors(s, le32_to_cpu(fnode->ea_secno) + ((le32_to_cpu(fnode->ea_size_l) + 511) >> 9), len - ((le32_to_cpu(fnode->ea_size_l) + 511) >> 9));
363
+
else fnode->ea_secno = fnode->ea_size_l = cpu_to_le32(0);
366
364
}
367
365
+21
-10
fs/hpfs/file.c
+21
-10
fs/hpfs/file.c
···
20
20
21
21
int hpfs_file_fsync(struct file *file, int datasync)
22
22
{
23
-
/*return file_fsync(file, datasync);*/
24
-
return 0; /* Don't fsync :-) */
23
+
struct inode *inode = file->f_mapping->host;
24
+
return sync_blockdev(inode->i_sb->s_bdev);
25
25
}
26
26
27
27
/*
···
48
48
static void hpfs_truncate(struct inode *i)
49
49
{
50
50
if (IS_IMMUTABLE(i)) return /*-EPERM*/;
51
-
hpfs_lock(i->i_sb);
51
+
hpfs_lock_assert(i->i_sb);
52
+
52
53
hpfs_i(i)->i_n_secs = 0;
53
54
i->i_blocks = 1 + ((i->i_size + 511) >> 9);
54
55
hpfs_i(i)->mmu_private = i->i_size;
55
56
hpfs_truncate_btree(i->i_sb, i->i_ino, 1, ((i->i_size + 511) >> 9));
56
57
hpfs_write_inode(i);
57
58
hpfs_i(i)->i_n_secs = 0;
58
-
hpfs_unlock(i->i_sb);
59
59
}
60
60
61
61
static int hpfs_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create)
62
62
{
63
+
int r;
63
64
secno s;
65
+
hpfs_lock(inode->i_sb);
64
66
s = hpfs_bmap(inode, iblock);
65
67
if (s) {
66
68
map_bh(bh_result, inode->i_sb, s);
67
-
return 0;
69
+
goto ret_0;
68
70
}
69
-
if (!create) return 0;
71
+
if (!create) goto ret_0;
70
72
if (iblock<<9 != hpfs_i(inode)->mmu_private) {
71
73
BUG();
72
-
return -EIO;
74
+
r = -EIO;
75
+
goto ret_r;
73
76
}
74
77
if ((s = hpfs_add_sector_to_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1)) == -1) {
75
78
hpfs_truncate_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1);
76
-
return -ENOSPC;
79
+
r = -ENOSPC;
80
+
goto ret_r;
77
81
}
78
82
inode->i_blocks++;
79
83
hpfs_i(inode)->mmu_private += 512;
80
84
set_buffer_new(bh_result);
81
85
map_bh(bh_result, inode->i_sb, s);
82
-
return 0;
86
+
ret_0:
87
+
r = 0;
88
+
ret_r:
89
+
hpfs_unlock(inode->i_sb);
90
+
return r;
83
91
}
84
92
85
93
static int hpfs_writepage(struct page *page, struct writeback_control *wbc)
···
138
130
ssize_t retval;
139
131
140
132
retval = do_sync_write(file, buf, count, ppos);
141
-
if (retval > 0)
133
+
if (retval > 0) {
134
+
hpfs_lock(file->f_path.dentry->d_sb);
142
135
hpfs_i(file->f_path.dentry->d_inode)->i_dirty = 1;
136
+
hpfs_unlock(file->f_path.dentry->d_sb);
137
+
}
143
138
return retval;
144
139
}
145
140
+255
-180
fs/hpfs/hpfs.h
+255
-180
fs/hpfs/hpfs.h
···
19
19
For definitive information on HPFS, ask somebody else -- this is guesswork.
20
20
There are certain to be many mistakes. */
21
21
22
+
#if !defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN)
23
+
#error unknown endian
24
+
#endif
25
+
22
26
/* Notation */
23
27
24
-
typedef unsigned secno; /* sector number, partition relative */
28
+
typedef u32 secno; /* sector number, partition relative */
25
29
26
30
typedef secno dnode_secno; /* sector number of a dnode */
27
31
typedef secno fnode_secno; /* sector number of an fnode */
···
42
38
43
39
struct hpfs_boot_block
44
40
{
45
-
unsigned char jmp[3];
46
-
unsigned char oem_id[8];
47
-
unsigned char bytes_per_sector[2]; /* 512 */
48
-
unsigned char sectors_per_cluster;
49
-
unsigned char n_reserved_sectors[2];
50
-
unsigned char n_fats;
51
-
unsigned char n_rootdir_entries[2];
52
-
unsigned char n_sectors_s[2];
53
-
unsigned char media_byte;
54
-
unsigned short sectors_per_fat;
55
-
unsigned short sectors_per_track;
56
-
unsigned short heads_per_cyl;
57
-
unsigned int n_hidden_sectors;
58
-
unsigned int n_sectors_l; /* size of partition */
59
-
unsigned char drive_number;
60
-
unsigned char mbz;
61
-
unsigned char sig_28h; /* 28h */
62
-
unsigned char vol_serno[4];
63
-
unsigned char vol_label[11];
64
-
unsigned char sig_hpfs[8]; /* "HPFS " */
65
-
unsigned char pad[448];
66
-
unsigned short magic; /* aa55 */
41
+
u8 jmp[3];
42
+
u8 oem_id[8];
43
+
u8 bytes_per_sector[2]; /* 512 */
44
+
u8 sectors_per_cluster;
45
+
u8 n_reserved_sectors[2];
46
+
u8 n_fats;
47
+
u8 n_rootdir_entries[2];
48
+
u8 n_sectors_s[2];
49
+
u8 media_byte;
50
+
u16 sectors_per_fat;
51
+
u16 sectors_per_track;
52
+
u16 heads_per_cyl;
53
+
u32 n_hidden_sectors;
54
+
u32 n_sectors_l; /* size of partition */
55
+
u8 drive_number;
56
+
u8 mbz;
57
+
u8 sig_28h; /* 28h */
58
+
u8 vol_serno[4];
59
+
u8 vol_label[11];
60
+
u8 sig_hpfs[8]; /* "HPFS " */
61
+
u8 pad[448];
62
+
u16 magic; /* aa55 */
67
63
};
68
64
69
65
···
75
71
76
72
struct hpfs_super_block
77
73
{
78
-
unsigned magic; /* f995 e849 */
79
-
unsigned magic1; /* fa53 e9c5, more magic? */
80
-
/*unsigned huh202;*/ /* ?? 202 = N. of B. in 1.00390625 S.*/
81
-
char version; /* version of a filesystem usually 2 */
82
-
char funcversion; /* functional version - oldest version
74
+
u32 magic; /* f995 e849 */
75
+
u32 magic1; /* fa53 e9c5, more magic? */
76
+
u8 version; /* version of a filesystem usually 2 */
77
+
u8 funcversion; /* functional version - oldest version
83
78
of filesystem that can understand
84
79
this disk */
85
-
unsigned short int zero; /* 0 */
80
+
u16 zero; /* 0 */
86
81
fnode_secno root; /* fnode of root directory */
87
82
secno n_sectors; /* size of filesystem */
88
-
unsigned n_badblocks; /* number of bad blocks */
83
+
u32 n_badblocks; /* number of bad blocks */
89
84
secno bitmaps; /* pointers to free space bit maps */
90
-
unsigned zero1; /* 0 */
85
+
u32 zero1; /* 0 */
91
86
secno badblocks; /* bad block list */
92
-
unsigned zero3; /* 0 */
87
+
u32 zero3; /* 0 */
93
88
time32_t last_chkdsk; /* date last checked, 0 if never */
94
-
/*unsigned zero4;*/ /* 0 */
95
-
time32_t last_optimize; /* date last optimized, 0 if never */
89
+
time32_t last_optimize; /* date last optimized, 0 if never */
96
90
secno n_dir_band; /* number of sectors in dir band */
97
91
secno dir_band_start; /* first sector in dir band */
98
92
secno dir_band_end; /* last sector in dir band */
99
93
secno dir_band_bitmap; /* free space map, 1 dnode per bit */
100
-
char volume_name[32]; /* not used */
94
+
u8 volume_name[32]; /* not used */
101
95
secno user_id_table; /* 8 preallocated sectors - user id */
102
-
unsigned zero6[103]; /* 0 */
96
+
u32 zero6[103]; /* 0 */
103
97
};
104
98
105
99
···
109
107
110
108
struct hpfs_spare_block
111
109
{
112
-
unsigned magic; /* f991 1849 */
113
-
unsigned magic1; /* fa52 29c5, more magic? */
110
+
u32 magic; /* f991 1849 */
111
+
u32 magic1; /* fa52 29c5, more magic? */
114
112
115
-
unsigned dirty: 1; /* 0 clean, 1 "improperly stopped" */
116
-
/*unsigned flag1234: 4;*/ /* unknown flags */
117
-
unsigned sparedir_used: 1; /* spare dirblks used */
118
-
unsigned hotfixes_used: 1; /* hotfixes used */
119
-
unsigned bad_sector: 1; /* bad sector, corrupted disk (???) */
120
-
unsigned bad_bitmap: 1; /* bad bitmap */
121
-
unsigned fast: 1; /* partition was fast formatted */
122
-
unsigned old_wrote: 1; /* old version wrote to partion */
123
-
unsigned old_wrote_1: 1; /* old version wrote to partion (?) */
124
-
unsigned install_dasd_limits: 1; /* HPFS386 flags */
125
-
unsigned resynch_dasd_limits: 1;
126
-
unsigned dasd_limits_operational: 1;
127
-
unsigned multimedia_active: 1;
128
-
unsigned dce_acls_active: 1;
129
-
unsigned dasd_limits_dirty: 1;
130
-
unsigned flag67: 2;
131
-
unsigned char mm_contlgulty;
132
-
unsigned char unused;
113
+
#ifdef __LITTLE_ENDIAN
114
+
u8 dirty: 1; /* 0 clean, 1 "improperly stopped" */
115
+
u8 sparedir_used: 1; /* spare dirblks used */
116
+
u8 hotfixes_used: 1; /* hotfixes used */
117
+
u8 bad_sector: 1; /* bad sector, corrupted disk (???) */
118
+
u8 bad_bitmap: 1; /* bad bitmap */
119
+
u8 fast: 1; /* partition was fast formatted */
120
+
u8 old_wrote: 1; /* old version wrote to partion */
121
+
u8 old_wrote_1: 1; /* old version wrote to partion (?) */
122
+
#else
123
+
u8 old_wrote_1: 1; /* old version wrote to partion (?) */
124
+
u8 old_wrote: 1; /* old version wrote to partion */
125
+
u8 fast: 1; /* partition was fast formatted */
126
+
u8 bad_bitmap: 1; /* bad bitmap */
127
+
u8 bad_sector: 1; /* bad sector, corrupted disk (???) */
128
+
u8 hotfixes_used: 1; /* hotfixes used */
129
+
u8 sparedir_used: 1; /* spare dirblks used */
130
+
u8 dirty: 1; /* 0 clean, 1 "improperly stopped" */
131
+
#endif
132
+
133
+
#ifdef __LITTLE_ENDIAN
134
+
u8 install_dasd_limits: 1; /* HPFS386 flags */
135
+
u8 resynch_dasd_limits: 1;
136
+
u8 dasd_limits_operational: 1;
137
+
u8 multimedia_active: 1;
138
+
u8 dce_acls_active: 1;
139
+
u8 dasd_limits_dirty: 1;
140
+
u8 flag67: 2;
141
+
#else
142
+
u8 flag67: 2;
143
+
u8 dasd_limits_dirty: 1;
144
+
u8 dce_acls_active: 1;
145
+
u8 multimedia_active: 1;
146
+
u8 dasd_limits_operational: 1;
147
+
u8 resynch_dasd_limits: 1;
148
+
u8 install_dasd_limits: 1; /* HPFS386 flags */
149
+
#endif
150
+
151
+
u8 mm_contlgulty;
152
+
u8 unused;
133
153
134
154
secno hotfix_map; /* info about remapped bad sectors */
135
-
unsigned n_spares_used; /* number of hotfixes */
136
-
unsigned n_spares; /* number of spares in hotfix map */
137
-
unsigned n_dnode_spares_free; /* spare dnodes unused */
138
-
unsigned n_dnode_spares; /* length of spare_dnodes[] list,
155
+
u32 n_spares_used; /* number of hotfixes */
156
+
u32 n_spares; /* number of spares in hotfix map */
157
+
u32 n_dnode_spares_free; /* spare dnodes unused */
158
+
u32 n_dnode_spares; /* length of spare_dnodes[] list,
139
159
follows in this block*/
140
160
secno code_page_dir; /* code page directory block */
141
-
unsigned n_code_pages; /* number of code pages */
142
-
/*unsigned large_numbers[2];*/ /* ?? */
143
-
unsigned super_crc; /* on HPFS386 and LAN Server this is
161
+
u32 n_code_pages; /* number of code pages */
162
+
u32 super_crc; /* on HPFS386 and LAN Server this is
144
163
checksum of superblock, on normal
145
164
OS/2 unused */
146
-
unsigned spare_crc; /* on HPFS386 checksum of spareblock */
147
-
unsigned zero1[15]; /* unused */
165
+
u32 spare_crc; /* on HPFS386 checksum of spareblock */
166
+
u32 zero1[15]; /* unused */
148
167
dnode_secno spare_dnodes[100]; /* emergency free dnode list */
149
-
unsigned zero2[1]; /* room for more? */
168
+
u32 zero2[1]; /* room for more? */
150
169
};
151
170
152
171
/* The bad block list is 4 sectors long. The first word must be zero,
···
202
179
203
180
struct code_page_directory
204
181
{
205
-
unsigned magic; /* 4945 21f7 */
206
-
unsigned n_code_pages; /* number of pointers following */
207
-
unsigned zero1[2];
182
+
u32 magic; /* 4945 21f7 */
183
+
u32 n_code_pages; /* number of pointers following */
184
+
u32 zero1[2];
208
185
struct {
209
-
unsigned short ix; /* index */
210
-
unsigned short code_page_number; /* code page number */
211
-
unsigned bounds; /* matches corresponding word
186
+
u16 ix; /* index */
187
+
u16 code_page_number; /* code page number */
188
+
u32 bounds; /* matches corresponding word
212
189
in data block */
213
190
secno code_page_data; /* sector number of a code_page_data
214
191
containing c.p. array */
215
-
unsigned short index; /* index in c.p. array in that sector*/
216
-
unsigned short unknown; /* some unknown value; usually 0;
192
+
u16 index; /* index in c.p. array in that sector*/
193
+
u16 unknown; /* some unknown value; usually 0;
217
194
2 in Japanese version */
218
195
} array[31]; /* unknown length */
219
196
};
···
224
201
225
202
struct code_page_data
226
203
{
227
-
unsigned magic; /* 8945 21f7 */
228
-
unsigned n_used; /* # elements used in c_p_data[] */
229
-
unsigned bounds[3]; /* looks a bit like
204
+
u32 magic; /* 8945 21f7 */
205
+
u32 n_used; /* # elements used in c_p_data[] */
206
+
u32 bounds[3]; /* looks a bit like
230
207
(beg1,end1), (beg2,end2)
231
208
one byte each */
232
-
unsigned short offs[3]; /* offsets from start of sector
209
+
u16 offs[3]; /* offsets from start of sector
233
210
to start of c_p_data[ix] */
234
211
struct {
235
-
unsigned short ix; /* index */
236
-
unsigned short code_page_number; /* code page number */
237
-
unsigned short unknown; /* the same as in cp directory */
238
-
unsigned char map[128]; /* upcase table for chars 80..ff */
239
-
unsigned short zero2;
212
+
u16 ix; /* index */
213
+
u16 code_page_number; /* code page number */
214
+
u16 unknown; /* the same as in cp directory */
215
+
u8 map[128]; /* upcase table for chars 80..ff */
216
+
u16 zero2;
240
217
} code_page[3];
241
-
unsigned char incognita[78];
218
+
u8 incognita[78];
242
219
};
243
220
244
221
···
278
255
#define DNODE_MAGIC 0x77e40aae
279
256
280
257
struct dnode {
281
-
unsigned magic; /* 77e4 0aae */
282
-
unsigned first_free; /* offset from start of dnode to
258
+
u32 magic; /* 77e4 0aae */
259
+
u32 first_free; /* offset from start of dnode to
283
260
first free dir entry */
284
-
unsigned root_dnode:1; /* Is it root dnode? */
285
-
unsigned increment_me:31; /* some kind of activity counter?
286
-
Neither HPFS.IFS nor CHKDSK cares
261
+
#ifdef __LITTLE_ENDIAN
262
+
u8 root_dnode: 1; /* Is it root dnode? */
263
+
u8 increment_me: 7; /* some kind of activity counter? */
264
+
/* Neither HPFS.IFS nor CHKDSK cares
287
265
if you change this word */
266
+
#else
267
+
u8 increment_me: 7; /* some kind of activity counter? */
268
+
/* Neither HPFS.IFS nor CHKDSK cares
269
+
if you change this word */
270
+
u8 root_dnode: 1; /* Is it root dnode? */
271
+
#endif
272
+
u8 increment_me2[3];
288
273
secno up; /* (root dnode) directory's fnode
289
274
(nonroot) parent dnode */
290
275
dnode_secno self; /* pointer to this dnode */
291
-
unsigned char dirent[2028]; /* one or more dirents */
276
+
u8 dirent[2028]; /* one or more dirents */
292
277
};
293
278
294
279
struct hpfs_dirent {
295
-
unsigned short length; /* offset to next dirent */
296
-
unsigned first: 1; /* set on phony ^A^A (".") entry */
297
-
unsigned has_acl: 1;
298
-
unsigned down: 1; /* down pointer present (after name) */
299
-
unsigned last: 1; /* set on phony \377 entry */
300
-
unsigned has_ea: 1; /* entry has EA */
301
-
unsigned has_xtd_perm: 1; /* has extended perm list (???) */
302
-
unsigned has_explicit_acl: 1;
303
-
unsigned has_needea: 1; /* ?? some EA has NEEDEA set
280
+
u16 length; /* offset to next dirent */
281
+
282
+
#ifdef __LITTLE_ENDIAN
283
+
u8 first: 1; /* set on phony ^A^A (".") entry */
284
+
u8 has_acl: 1;
285
+
u8 down: 1; /* down pointer present (after name) */
286
+
u8 last: 1; /* set on phony \377 entry */
287
+
u8 has_ea: 1; /* entry has EA */
288
+
u8 has_xtd_perm: 1; /* has extended perm list (???) */
289
+
u8 has_explicit_acl: 1;
290
+
u8 has_needea: 1; /* ?? some EA has NEEDEA set
304
291
I have no idea why this is
305
292
interesting in a dir entry */
306
-
unsigned read_only: 1; /* dos attrib */
307
-
unsigned hidden: 1; /* dos attrib */
308
-
unsigned system: 1; /* dos attrib */
309
-
unsigned flag11: 1; /* would be volume label dos attrib */
310
-
unsigned directory: 1; /* dos attrib */
311
-
unsigned archive: 1; /* dos attrib */
312
-
unsigned not_8x3: 1; /* name is not 8.3 */
313
-
unsigned flag15: 1;
293
+
#else
294
+
u8 has_needea: 1; /* ?? some EA has NEEDEA set
295
+
I have no idea why this is
296
+
interesting in a dir entry */
297
+
u8 has_explicit_acl: 1;
298
+
u8 has_xtd_perm: 1; /* has extended perm list (???) */
299
+
u8 has_ea: 1; /* entry has EA */
300
+
u8 last: 1; /* set on phony \377 entry */
301
+
u8 down: 1; /* down pointer present (after name) */
302
+
u8 has_acl: 1;
303
+
u8 first: 1; /* set on phony ^A^A (".") entry */
304
+
#endif
305
+
306
+
#ifdef __LITTLE_ENDIAN
307
+
u8 read_only: 1; /* dos attrib */
308
+
u8 hidden: 1; /* dos attrib */
309
+
u8 system: 1; /* dos attrib */
310
+
u8 flag11: 1; /* would be volume label dos attrib */
311
+
u8 directory: 1; /* dos attrib */
312
+
u8 archive: 1; /* dos attrib */
313
+
u8 not_8x3: 1; /* name is not 8.3 */
314
+
u8 flag15: 1;
315
+
#else
316
+
u8 flag15: 1;
317
+
u8 not_8x3: 1; /* name is not 8.3 */
318
+
u8 archive: 1; /* dos attrib */
319
+
u8 directory: 1; /* dos attrib */
320
+
u8 flag11: 1; /* would be volume label dos attrib */
321
+
u8 system: 1; /* dos attrib */
322
+
u8 hidden: 1; /* dos attrib */
323
+
u8 read_only: 1; /* dos attrib */
324
+
#endif
325
+
314
326
fnode_secno fnode; /* fnode giving allocation info */
315
327
time32_t write_date; /* mtime */
316
-
unsigned file_size; /* file length, bytes */
328
+
u32 file_size; /* file length, bytes */
317
329
time32_t read_date; /* atime */
318
330
time32_t creation_date; /* ctime */
319
-
unsigned ea_size; /* total EA length, bytes */
320
-
unsigned char no_of_acls : 3; /* number of ACL's */
321
-
unsigned char reserver : 5;
322
-
unsigned char ix; /* code page index (of filename), see
331
+
u32 ea_size; /* total EA length, bytes */
332
+
u8 no_of_acls; /* number of ACL's (low 3 bits) */
333
+
u8 ix; /* code page index (of filename), see
323
334
struct code_page_data */
324
-
unsigned char namelen, name[1]; /* file name */
335
+
u8 namelen, name[1]; /* file name */
325
336
/* dnode_secno down; btree down pointer, if present,
326
337
follows name on next word boundary, or maybe it
327
338
precedes next dirent, which is on a word boundary. */
···
375
318
376
319
struct bplus_leaf_node
377
320
{
378
-
unsigned file_secno; /* first file sector in extent */
379
-
unsigned length; /* length, sectors */
321
+
u32 file_secno; /* first file sector in extent */
322
+
u32 length; /* length, sectors */
380
323
secno disk_secno; /* first corresponding disk sector */
381
324
};
382
325
383
326
struct bplus_internal_node
384
327
{
385
-
unsigned file_secno; /* subtree maps sectors < this */
328
+
u32 file_secno; /* subtree maps sectors < this */
386
329
anode_secno down; /* pointer to subtree */
387
330
};
388
331
389
332
struct bplus_header
390
333
{
391
-
unsigned hbff: 1; /* high bit of first free entry offset */
392
-
unsigned flag1: 1;
393
-
unsigned flag2: 1;
394
-
unsigned flag3: 1;
395
-
unsigned flag4: 1;
396
-
unsigned fnode_parent: 1; /* ? we're pointed to by an fnode,
334
+
#ifdef __LITTLE_ENDIAN
335
+
u8 hbff: 1; /* high bit of first free entry offset */
336
+
u8 flag1234: 4;
337
+
u8 fnode_parent: 1; /* ? we're pointed to by an fnode,
397
338
the data btree or some ea or the
398
339
main ea bootage pointer ea_secno */
399
340
/* also can get set in fnodes, which
400
341
may be a chkdsk glitch or may mean
401
342
this bit is irrelevant in fnodes,
402
343
or this interpretation is all wet */
403
-
unsigned binary_search: 1; /* suggest binary search (unused) */
404
-
unsigned internal: 1; /* 1 -> (internal) tree of anodes
344
+
u8 binary_search: 1; /* suggest binary search (unused) */
345
+
u8 internal: 1; /* 1 -> (internal) tree of anodes
405
346
0 -> (leaf) list of extents */
406
-
unsigned char fill[3];
407
-
unsigned char n_free_nodes; /* free nodes in following array */
408
-
unsigned char n_used_nodes; /* used nodes in following array */
409
-
unsigned short first_free; /* offset from start of header to
347
+
#else
348
+
u8 internal: 1; /* 1 -> (internal) tree of anodes
349
+
0 -> (leaf) list of extents */
350
+
u8 binary_search: 1; /* suggest binary search (unused) */
351
+
u8 fnode_parent: 1; /* ? we're pointed to by an fnode,
352
+
the data btree or some ea or the
353
+
main ea bootage pointer ea_secno */
354
+
/* also can get set in fnodes, which
355
+
may be a chkdsk glitch or may mean
356
+
this bit is irrelevant in fnodes,
357
+
or this interpretation is all wet */
358
+
u8 flag1234: 4;
359
+
u8 hbff: 1; /* high bit of first free entry offset */
360
+
#endif
361
+
u8 fill[3];
362
+
u8 n_free_nodes; /* free nodes in following array */
363
+
u8 n_used_nodes; /* used nodes in following array */
364
+
u16 first_free; /* offset from start of header to
410
365
first free node in array */
411
366
union {
412
367
struct bplus_internal_node internal[0]; /* (internal) 2-word entries giving
···
438
369
439
370
struct fnode
440
371
{
441
-
unsigned magic; /* f7e4 0aae */
442
-
unsigned zero1[2]; /* read history */
443
-
unsigned char len, name[15]; /* true length, truncated name */
372
+
u32 magic; /* f7e4 0aae */
373
+
u32 zero1[2]; /* read history */
374
+
u8 len, name[15]; /* true length, truncated name */
444
375
fnode_secno up; /* pointer to file's directory fnode */
445
-
/*unsigned zero2[3];*/
446
376
secno acl_size_l;
447
377
secno acl_secno;
448
-
unsigned short acl_size_s;
449
-
char acl_anode;
450
-
char zero2; /* history bit count */
451
-
unsigned ea_size_l; /* length of disk-resident ea's */
378
+
u16 acl_size_s;
379
+
u8 acl_anode;
380
+
u8 zero2; /* history bit count */
381
+
u32 ea_size_l; /* length of disk-resident ea's */
452
382
secno ea_secno; /* first sector of disk-resident ea's*/
453
-
unsigned short ea_size_s; /* length of fnode-resident ea's */
383
+
u16 ea_size_s; /* length of fnode-resident ea's */
454
384
455
-
unsigned flag0: 1;
456
-
unsigned ea_anode: 1; /* 1 -> ea_secno is an anode */
457
-
unsigned flag2: 1;
458
-
unsigned flag3: 1;
459
-
unsigned flag4: 1;
460
-
unsigned flag5: 1;
461
-
unsigned flag6: 1;
462
-
unsigned flag7: 1;
463
-
unsigned dirflag: 1; /* 1 -> directory. first & only extent
385
+
#ifdef __LITTLE_ENDIAN
386
+
u8 flag0: 1;
387
+
u8 ea_anode: 1; /* 1 -> ea_secno is an anode */
388
+
u8 flag234567: 6;
389
+
#else
390
+
u8 flag234567: 6;
391
+
u8 ea_anode: 1; /* 1 -> ea_secno is an anode */
392
+
u8 flag0: 1;
393
+
#endif
394
+
395
+
#ifdef __LITTLE_ENDIAN
396
+
u8 dirflag: 1; /* 1 -> directory. first & only extent
464
397
points to dnode. */
465
-
unsigned flag9: 1;
466
-
unsigned flag10: 1;
467
-
unsigned flag11: 1;
468
-
unsigned flag12: 1;
469
-
unsigned flag13: 1;
470
-
unsigned flag14: 1;
471
-
unsigned flag15: 1;
398
+
u8 flag9012345: 7;
399
+
#else
400
+
u8 flag9012345: 7;
401
+
u8 dirflag: 1; /* 1 -> directory. first & only extent
402
+
points to dnode. */
403
+
#endif
472
404
473
405
struct bplus_header btree; /* b+ tree, 8 extents or 12 subtrees */
474
406
union {
···
477
407
struct bplus_internal_node internal[12];
478
408
} u;
479
409
480
-
unsigned file_size; /* file length, bytes */
481
-
unsigned n_needea; /* number of EA's with NEEDEA set */
482
-
char user_id[16]; /* unused */
483
-
unsigned short ea_offs; /* offset from start of fnode
410
+
u32 file_size; /* file length, bytes */
411
+
u32 n_needea; /* number of EA's with NEEDEA set */
412
+
u8 user_id[16]; /* unused */
413
+
u16 ea_offs; /* offset from start of fnode
484
414
to first fnode-resident ea */
485
-
char dasd_limit_treshhold;
486
-
char dasd_limit_delta;
487
-
unsigned dasd_limit;
488
-
unsigned dasd_usage;
489
-
/*unsigned zero5[2];*/
490
-
unsigned char ea[316]; /* zero or more EA's, packed together
415
+
u8 dasd_limit_treshhold;
416
+
u8 dasd_limit_delta;
417
+
u32 dasd_limit;
418
+
u32 dasd_usage;
419
+
u8 ea[316]; /* zero or more EA's, packed together
491
420
with no alignment padding.
492
421
(Do not use this name, get here
493
422
via fnode + ea_offs. I think.) */
···
499
430
500
431
struct anode
501
432
{
502
-
unsigned magic; /* 37e4 0aae */
433
+
u32 magic; /* 37e4 0aae */
503
434
anode_secno self; /* pointer to this anode */
504
435
secno up; /* parent anode or fnode */
505
436
···
509
440
struct bplus_internal_node internal[60];
510
441
} u;
511
442
512
-
unsigned fill[3]; /* unused */
443
+
u32 fill[3]; /* unused */
513
444
};
514
445
515
446
···
530
461
531
462
struct extended_attribute
532
463
{
533
-
unsigned indirect: 1; /* 1 -> value gives sector number
464
+
#ifdef __LITTLE_ENDIAN
465
+
u8 indirect: 1; /* 1 -> value gives sector number
534
466
where real value starts */
535
-
unsigned anode: 1; /* 1 -> sector is an anode
467
+
u8 anode: 1; /* 1 -> sector is an anode
536
468
that points to fragmented value */
537
-
unsigned flag2: 1;
538
-
unsigned flag3: 1;
539
-
unsigned flag4: 1;
540
-
unsigned flag5: 1;
541
-
unsigned flag6: 1;
542
-
unsigned needea: 1; /* required ea */
543
-
unsigned char namelen; /* length of name, bytes */
544
-
unsigned short valuelen; /* length of value, bytes */
545
-
unsigned char name[0];
469
+
u8 flag23456: 5;
470
+
u8 needea: 1; /* required ea */
471
+
#else
472
+
u8 needea: 1; /* required ea */
473
+
u8 flag23456: 5;
474
+
u8 anode: 1; /* 1 -> sector is an anode
475
+
that points to fragmented value */
476
+
u8 indirect: 1; /* 1 -> value gives sector number
477
+
where real value starts */
478
+
#endif
479
+
u8 namelen; /* length of name, bytes */
480
+
u8 valuelen_lo; /* length of value, bytes */
481
+
u8 valuelen_hi; /* length of value, bytes */
482
+
u8 name[0];
546
483
/*
547
-
unsigned char name[namelen]; ascii attrib name
548
-
unsigned char nul; terminating '\0', not counted
549
-
unsigned char value[valuelen]; value, arbitrary
484
+
u8 name[namelen]; ascii attrib name
485
+
u8 nul; terminating '\0', not counted
486
+
u8 value[valuelen]; value, arbitrary
550
487
if this.indirect, valuelen is 8 and the value is
551
-
unsigned length; real length of value, bytes
488
+
u32 length; real length of value, bytes
552
489
secno secno; sector address where it starts
553
490
if this.anode, the above sector number is the root of an anode tree
554
491
which points to the value.
+37
-43
fs/hpfs/hpfs_fn.h
+37
-43
fs/hpfs/hpfs_fn.h
···
13
13
#include <linux/pagemap.h>
14
14
#include <linux/buffer_head.h>
15
15
#include <linux/slab.h>
16
+
#include <asm/unaligned.h>
16
17
17
18
#include "hpfs.h"
18
19
···
52
51
unsigned i_disk_sec; /* (files) minimalist cache of alloc info */
53
52
unsigned i_n_secs; /* (files) minimalist cache of alloc info */
54
53
unsigned i_ea_size; /* size of extended attributes */
55
-
unsigned i_conv : 2; /* (files) crlf->newline hackery */
56
54
unsigned i_ea_mode : 1; /* file's permission is stored in ea */
57
55
unsigned i_ea_uid : 1; /* file's uid is stored in ea */
58
56
unsigned i_ea_gid : 1; /* file's gid is stored in ea */
59
57
unsigned i_dirty : 1;
60
-
struct mutex i_mutex;
61
-
struct mutex i_parent_mutex;
62
58
loff_t **i_rddir_off;
63
59
struct inode vfs_inode;
64
60
};
65
61
66
62
struct hpfs_sb_info {
63
+
struct mutex hpfs_mutex; /* global hpfs lock */
67
64
ino_t sb_root; /* inode number of root dir */
68
65
unsigned sb_fs_size; /* file system size, sectors */
69
66
unsigned sb_bitmaps; /* sector number of bitmap list */
···
73
74
uid_t sb_uid; /* uid from mount options */
74
75
gid_t sb_gid; /* gid from mount options */
75
76
umode_t sb_mode; /* mode from mount options */
76
-
unsigned sb_conv : 2; /* crlf->newline hackery */
77
77
unsigned sb_eas : 2; /* eas: 0-ignore, 1-ro, 2-rw */
78
78
unsigned sb_err : 2; /* on errs: 0-cont, 1-ro, 2-panic */
79
79
unsigned sb_chk : 2; /* checks: 0-no, 1-normal, 2-strict */
···
85
87
unsigned *sb_bmp_dir; /* main bitmap directory */
86
88
unsigned sb_c_bitmap; /* current bitmap */
87
89
unsigned sb_max_fwd_alloc; /* max forwad allocation */
88
-
struct mutex hpfs_creation_de; /* when creating dirents, nobody else
89
-
can alloc blocks */
90
-
/*unsigned sb_mounting : 1;*/
91
90
int sb_timeshift;
92
91
};
93
-
94
-
/*
95
-
* conv= options
96
-
*/
97
-
98
-
#define CONV_BINARY 0 /* no conversion */
99
-
#define CONV_TEXT 1 /* crlf->newline */
100
-
#define CONV_AUTO 2 /* decide based on file contents */
101
92
102
93
/* Four 512-byte buffers and the 2k block obtained by concatenating them */
103
94
···
100
113
static inline dnode_secno de_down_pointer (struct hpfs_dirent *de)
101
114
{
102
115
CHKCOND(de->down,("HPFS: de_down_pointer: !de->down\n"));
103
-
return *(dnode_secno *) ((void *) de + de->length - 4);
116
+
return le32_to_cpu(*(dnode_secno *) ((void *) de + le16_to_cpu(de->length) - 4));
104
117
}
105
118
106
119
/* The first dir entry in a dnode */
···
114
127
115
128
static inline struct hpfs_dirent *dnode_end_de (struct dnode *dnode)
116
129
{
117
-
CHKCOND(dnode->first_free>=0x14 && dnode->first_free<=0xa00,("HPFS: dnode_end_de: dnode->first_free = %d\n",(int)dnode->first_free));
118
-
return (void *) dnode + dnode->first_free;
130
+
CHKCOND(le32_to_cpu(dnode->first_free)>=0x14 && le32_to_cpu(dnode->first_free)<=0xa00,("HPFS: dnode_end_de: dnode->first_free = %x\n",(unsigned)le32_to_cpu(dnode->first_free)));
131
+
return (void *) dnode + le32_to_cpu(dnode->first_free);
119
132
}
120
133
121
134
/* The dir entry after dir entry de */
122
135
123
136
static inline struct hpfs_dirent *de_next_de (struct hpfs_dirent *de)
124
137
{
125
-
CHKCOND(de->length>=0x20 && de->length<0x800,("HPFS: de_next_de: de->length = %d\n",(int)de->length));
126
-
return (void *) de + de->length;
138
+
CHKCOND(le16_to_cpu(de->length)>=0x20 && le16_to_cpu(de->length)<0x800,("HPFS: de_next_de: de->length = %x\n",(unsigned)le16_to_cpu(de->length)));
139
+
return (void *) de + le16_to_cpu(de->length);
127
140
}
128
141
129
142
static inline struct extended_attribute *fnode_ea(struct fnode *fnode)
130
143
{
131
-
return (struct extended_attribute *)((char *)fnode + fnode->ea_offs + fnode->acl_size_s);
144
+
return (struct extended_attribute *)((char *)fnode + le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s));
132
145
}
133
146
134
147
static inline struct extended_attribute *fnode_end_ea(struct fnode *fnode)
135
148
{
136
-
return (struct extended_attribute *)((char *)fnode + fnode->ea_offs + fnode->acl_size_s + fnode->ea_size_s);
149
+
return (struct extended_attribute *)((char *)fnode + le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s));
150
+
}
151
+
152
+
static unsigned ea_valuelen(struct extended_attribute *ea)
153
+
{
154
+
return ea->valuelen_lo + 256 * ea->valuelen_hi;
137
155
}
138
156
139
157
static inline struct extended_attribute *next_ea(struct extended_attribute *ea)
140
158
{
141
-
return (struct extended_attribute *)((char *)ea + 5 + ea->namelen + ea->valuelen);
159
+
return (struct extended_attribute *)((char *)ea + 5 + ea->namelen + ea_valuelen(ea));
142
160
}
143
161
144
162
static inline secno ea_sec(struct extended_attribute *ea)
145
163
{
146
-
return *(secno *)((char *)ea + 9 + ea->namelen);
164
+
return le32_to_cpu(get_unaligned((secno *)((char *)ea + 9 + ea->namelen)));
147
165
}
148
166
149
167
static inline secno ea_len(struct extended_attribute *ea)
150
168
{
151
-
return *(secno *)((char *)ea + 5 + ea->namelen);
169
+
return le32_to_cpu(get_unaligned((secno *)((char *)ea + 5 + ea->namelen)));
152
170
}
153
171
154
172
static inline char *ea_data(struct extended_attribute *ea)
···
178
186
dst->not_8x3 = n;
179
187
}
180
188
181
-
static inline unsigned tstbits(unsigned *bmp, unsigned b, unsigned n)
189
+
static inline unsigned tstbits(u32 *bmp, unsigned b, unsigned n)
182
190
{
183
191
int i;
184
192
if ((b >= 0x4000) || (b + n - 1 >= 0x4000)) return n;
185
-
if (!((bmp[(b & 0x3fff) >> 5] >> (b & 0x1f)) & 1)) return 1;
193
+
if (!((le32_to_cpu(bmp[(b & 0x3fff) >> 5]) >> (b & 0x1f)) & 1)) return 1;
186
194
for (i = 1; i < n; i++)
187
-
if (/*b+i < 0x4000 &&*/ !((bmp[((b+i) & 0x3fff) >> 5] >> ((b+i) & 0x1f)) & 1))
195
+
if (!((le32_to_cpu(bmp[((b+i) & 0x3fff) >> 5]) >> ((b+i) & 0x1f)) & 1))
188
196
return i + 1;
189
197
return 0;
190
198
}
···
192
200
/* alloc.c */
193
201
194
202
int hpfs_chk_sectors(struct super_block *, secno, int, char *);
195
-
secno hpfs_alloc_sector(struct super_block *, secno, unsigned, int, int);
203
+
secno hpfs_alloc_sector(struct super_block *, secno, unsigned, int);
196
204
int hpfs_alloc_if_possible(struct super_block *, secno);
197
205
void hpfs_free_sectors(struct super_block *, secno, unsigned);
198
206
int hpfs_check_free_dnodes(struct super_block *, int);
199
207
void hpfs_free_dnode(struct super_block *, secno);
200
-
struct dnode *hpfs_alloc_dnode(struct super_block *, secno, dnode_secno *, struct quad_buffer_head *, int);
208
+
struct dnode *hpfs_alloc_dnode(struct super_block *, secno, dnode_secno *, struct quad_buffer_head *);
201
209
struct fnode *hpfs_alloc_fnode(struct super_block *, secno, fnode_secno *, struct buffer_head **);
202
210
struct anode *hpfs_alloc_anode(struct super_block *, secno, anode_secno *, struct buffer_head **);
203
211
···
214
222
215
223
/* buffer.c */
216
224
217
-
void hpfs_lock_creation(struct super_block *);
218
-
void hpfs_unlock_creation(struct super_block *);
219
225
void *hpfs_map_sector(struct super_block *, unsigned, struct buffer_head **, int);
220
226
void *hpfs_get_sector(struct super_block *, unsigned, struct buffer_head **);
221
227
void *hpfs_map_4sectors(struct super_block *, unsigned, struct quad_buffer_head *, int);
···
237
247
struct hpfs_dirent *hpfs_add_de(struct super_block *, struct dnode *,
238
248
const unsigned char *, unsigned, secno);
239
249
int hpfs_add_dirent(struct inode *, const unsigned char *, unsigned,
240
-
struct hpfs_dirent *, int);
250
+
struct hpfs_dirent *);
241
251
int hpfs_remove_dirent(struct inode *, dnode_secno, struct hpfs_dirent *, struct quad_buffer_head *, int);
242
252
void hpfs_count_dnodes(struct super_block *, dnode_secno, int *, int *, int *);
243
253
dnode_secno hpfs_de_as_down_as_possible(struct super_block *, dnode_secno dno);
···
293
303
const unsigned char *, unsigned, int);
294
304
int hpfs_is_name_long(const unsigned char *, unsigned);
295
305
void hpfs_adjust_length(const unsigned char *, unsigned *);
296
-
void hpfs_decide_conv(struct inode *, const unsigned char *, unsigned);
297
306
298
307
/* namei.c */
299
308
···
335
346
/*
336
347
* Locking:
337
348
*
338
-
* hpfs_lock() is a leftover from the big kernel lock.
339
-
* Right now, these functions are empty and only left
340
-
* for documentation purposes. The file system no longer
341
-
* works on SMP systems, so the lock is not needed
342
-
* any more.
349
+
* hpfs_lock() locks the whole filesystem. It must be taken
350
+
* on any method called by the VFS.
343
351
*
344
-
* If someone is interested in making it work again, this
345
-
* would be the place to start by adding a per-superblock
346
-
* mutex and fixing all the bugs and performance issues
347
-
* caused by that.
352
+
* We don't do any per-file locking anymore, it is hard to
353
+
* review and HPFS is not performance-sensitive anyway.
348
354
*/
349
355
static inline void hpfs_lock(struct super_block *s)
350
356
{
357
+
struct hpfs_sb_info *sbi = hpfs_sb(s);
358
+
mutex_lock(&sbi->hpfs_mutex);
351
359
}
352
360
353
361
static inline void hpfs_unlock(struct super_block *s)
354
362
{
363
+
struct hpfs_sb_info *sbi = hpfs_sb(s);
364
+
mutex_unlock(&sbi->hpfs_mutex);
365
+
}
366
+
367
+
static inline void hpfs_lock_assert(struct super_block *s)
368
+
{
369
+
struct hpfs_sb_info *sbi = hpfs_sb(s);
370
+
WARN_ON(!mutex_is_locked(&sbi->hpfs_mutex));
355
371
}
+21
-26
fs/hpfs/inode.c
+21
-26
fs/hpfs/inode.c
···
17
17
i->i_uid = hpfs_sb(sb)->sb_uid;
18
18
i->i_gid = hpfs_sb(sb)->sb_gid;
19
19
i->i_mode = hpfs_sb(sb)->sb_mode;
20
-
hpfs_inode->i_conv = hpfs_sb(sb)->sb_conv;
21
20
i->i_size = -1;
22
21
i->i_blocks = -1;
23
22
···
115
116
i->i_mode |= S_IFDIR;
116
117
i->i_op = &hpfs_dir_iops;
117
118
i->i_fop = &hpfs_dir_ops;
118
-
hpfs_inode->i_parent_dir = fnode->up;
119
-
hpfs_inode->i_dno = fnode->u.external[0].disk_secno;
119
+
hpfs_inode->i_parent_dir = le32_to_cpu(fnode->up);
120
+
hpfs_inode->i_dno = le32_to_cpu(fnode->u.external[0].disk_secno);
120
121
if (hpfs_sb(sb)->sb_chk >= 2) {
121
122
struct buffer_head *bh0;
122
123
if (hpfs_map_fnode(sb, hpfs_inode->i_parent_dir, &bh0)) brelse(bh0);
···
132
133
i->i_op = &hpfs_file_iops;
133
134
i->i_fop = &hpfs_file_ops;
134
135
i->i_nlink = 1;
135
-
i->i_size = fnode->file_size;
136
+
i->i_size = le32_to_cpu(fnode->file_size);
136
137
i->i_blocks = ((i->i_size + 511) >> 9) + 1;
137
138
i->i_data.a_ops = &hpfs_aops;
138
139
hpfs_i(i)->mmu_private = i->i_size;
···
143
144
static void hpfs_write_inode_ea(struct inode *i, struct fnode *fnode)
144
145
{
145
146
struct hpfs_inode_info *hpfs_inode = hpfs_i(i);
146
-
/*if (fnode->acl_size_l || fnode->acl_size_s) {
147
+
/*if (le32_to_cpu(fnode->acl_size_l) || le16_to_cpu(fnode->acl_size_s)) {
147
148
Some unknown structures like ACL may be in fnode,
148
149
we'd better not overwrite them
149
150
hpfs_error(i->i_sb, "fnode %08x has some unknown HPFS386 stuctures", i->i_ino);
···
186
187
kfree(hpfs_inode->i_rddir_off);
187
188
hpfs_inode->i_rddir_off = NULL;
188
189
}
189
-
mutex_lock(&hpfs_inode->i_parent_mutex);
190
190
if (!i->i_nlink) {
191
-
mutex_unlock(&hpfs_inode->i_parent_mutex);
192
191
return;
193
192
}
194
193
parent = iget_locked(i->i_sb, hpfs_inode->i_parent_dir);
···
197
200
hpfs_read_inode(parent);
198
201
unlock_new_inode(parent);
199
202
}
200
-
mutex_lock(&hpfs_inode->i_mutex);
201
203
hpfs_write_inode_nolock(i);
202
-
mutex_unlock(&hpfs_inode->i_mutex);
203
204
iput(parent);
204
-
} else {
205
-
mark_inode_dirty(i);
206
205
}
207
-
mutex_unlock(&hpfs_inode->i_parent_mutex);
208
206
}
209
207
210
208
void hpfs_write_inode_nolock(struct inode *i)
···
218
226
}
219
227
} else de = NULL;
220
228
if (S_ISREG(i->i_mode)) {
221
-
fnode->file_size = i->i_size;
222
-
if (de) de->file_size = i->i_size;
229
+
fnode->file_size = cpu_to_le32(i->i_size);
230
+
if (de) de->file_size = cpu_to_le32(i->i_size);
223
231
} else if (S_ISDIR(i->i_mode)) {
224
-
fnode->file_size = 0;
225
-
if (de) de->file_size = 0;
232
+
fnode->file_size = cpu_to_le32(0);
233
+
if (de) de->file_size = cpu_to_le32(0);
226
234
}
227
235
hpfs_write_inode_ea(i, fnode);
228
236
if (de) {
229
-
de->write_date = gmt_to_local(i->i_sb, i->i_mtime.tv_sec);
230
-
de->read_date = gmt_to_local(i->i_sb, i->i_atime.tv_sec);
231
-
de->creation_date = gmt_to_local(i->i_sb, i->i_ctime.tv_sec);
237
+
de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_mtime.tv_sec));
238
+
de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_atime.tv_sec));
239
+
de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_ctime.tv_sec));
232
240
de->read_only = !(i->i_mode & 0222);
233
-
de->ea_size = hpfs_inode->i_ea_size;
241
+
de->ea_size = cpu_to_le32(hpfs_inode->i_ea_size);
234
242
hpfs_mark_4buffers_dirty(&qbh);
235
243
hpfs_brelse4(&qbh);
236
244
}
237
245
if (S_ISDIR(i->i_mode)) {
238
246
if ((de = map_dirent(i, hpfs_inode->i_dno, "\001\001", 2, NULL, &qbh))) {
239
-
de->write_date = gmt_to_local(i->i_sb, i->i_mtime.tv_sec);
240
-
de->read_date = gmt_to_local(i->i_sb, i->i_atime.tv_sec);
241
-
de->creation_date = gmt_to_local(i->i_sb, i->i_ctime.tv_sec);
247
+
de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_mtime.tv_sec));
248
+
de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_atime.tv_sec));
249
+
de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_ctime.tv_sec));
242
250
de->read_only = !(i->i_mode & 0222);
243
-
de->ea_size = /*hpfs_inode->i_ea_size*/0;
244
-
de->file_size = 0;
251
+
de->ea_size = cpu_to_le32(/*hpfs_inode->i_ea_size*/0);
252
+
de->file_size = cpu_to_le32(0);
245
253
hpfs_mark_4buffers_dirty(&qbh);
246
254
hpfs_brelse4(&qbh);
247
255
} else
···
261
269
hpfs_lock(inode->i_sb);
262
270
if (inode->i_ino == hpfs_sb(inode->i_sb)->sb_root)
263
271
goto out_unlock;
272
+
if ((attr->ia_valid & ATTR_UID) && attr->ia_uid >= 0x10000)
273
+
goto out_unlock;
274
+
if ((attr->ia_valid & ATTR_GID) && attr->ia_gid >= 0x10000)
275
+
goto out_unlock;
264
276
if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size > inode->i_size)
265
277
goto out_unlock;
266
278
···
280
284
}
281
285
282
286
setattr_copy(inode, attr);
283
-
mark_inode_dirty(inode);
284
287
285
288
hpfs_write_inode(inode);
286
289
+30
-26
fs/hpfs/map.c
+30
-26
fs/hpfs/map.c
···
21
21
hpfs_error(s, "hpfs_map_bitmap called with bad parameter: %08x at %s", bmp_block, id);
22
22
return NULL;
23
23
}
24
-
sec = hpfs_sb(s)->sb_bmp_dir[bmp_block];
24
+
sec = le32_to_cpu(hpfs_sb(s)->sb_bmp_dir[bmp_block]);
25
25
if (!sec || sec > hpfs_sb(s)->sb_fs_size-4) {
26
26
hpfs_error(s, "invalid bitmap block pointer %08x -> %08x at %s", bmp_block, sec, id);
27
27
return NULL;
···
46
46
struct code_page_data *cpd;
47
47
struct code_page_directory *cp = hpfs_map_sector(s, cps, &bh, 0);
48
48
if (!cp) return NULL;
49
-
if (cp->magic != CP_DIR_MAGIC) {
50
-
printk("HPFS: Code page directory magic doesn't match (magic = %08x)\n", cp->magic);
49
+
if (le32_to_cpu(cp->magic) != CP_DIR_MAGIC) {
50
+
printk("HPFS: Code page directory magic doesn't match (magic = %08x)\n", le32_to_cpu(cp->magic));
51
51
brelse(bh);
52
52
return NULL;
53
53
}
54
-
if (!cp->n_code_pages) {
54
+
if (!le32_to_cpu(cp->n_code_pages)) {
55
55
printk("HPFS: n_code_pages == 0\n");
56
56
brelse(bh);
57
57
return NULL;
58
58
}
59
-
cpds = cp->array[0].code_page_data;
60
-
cpi = cp->array[0].index;
59
+
cpds = le32_to_cpu(cp->array[0].code_page_data);
60
+
cpi = le16_to_cpu(cp->array[0].index);
61
61
brelse(bh);
62
62
63
63
if (cpi >= 3) {
···
66
66
}
67
67
68
68
if (!(cpd = hpfs_map_sector(s, cpds, &bh, 0))) return NULL;
69
-
if ((unsigned)cpd->offs[cpi] > 0x178) {
69
+
if (le16_to_cpu(cpd->offs[cpi]) > 0x178) {
70
70
printk("HPFS: Code page index out of sector\n");
71
71
brelse(bh);
72
72
return NULL;
73
73
}
74
-
ptr = (unsigned char *)cpd + cpd->offs[cpi] + 6;
74
+
ptr = (unsigned char *)cpd + le16_to_cpu(cpd->offs[cpi]) + 6;
75
75
if (!(cp_table = kmalloc(256, GFP_KERNEL))) {
76
76
printk("HPFS: out of memory for code page table\n");
77
77
brelse(bh);
···
125
125
if (hpfs_sb(s)->sb_chk) {
126
126
struct extended_attribute *ea;
127
127
struct extended_attribute *ea_end;
128
-
if (fnode->magic != FNODE_MAGIC) {
128
+
if (le32_to_cpu(fnode->magic) != FNODE_MAGIC) {
129
129
hpfs_error(s, "bad magic on fnode %08lx",
130
130
(unsigned long)ino);
131
131
goto bail;
···
138
138
(unsigned long)ino);
139
139
goto bail;
140
140
}
141
-
if (fnode->btree.first_free !=
141
+
if (le16_to_cpu(fnode->btree.first_free) !=
142
142
8 + fnode->btree.n_used_nodes * (fnode->btree.internal ? 8 : 12)) {
143
143
hpfs_error(s,
144
144
"bad first_free pointer in fnode %08lx",
···
146
146
goto bail;
147
147
}
148
148
}
149
-
if (fnode->ea_size_s && ((signed int)fnode->ea_offs < 0xc4 ||
150
-
(signed int)fnode->ea_offs + fnode->acl_size_s + fnode->ea_size_s > 0x200)) {
149
+
if (le16_to_cpu(fnode->ea_size_s) && (le16_to_cpu(fnode->ea_offs) < 0xc4 ||
150
+
le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s) > 0x200)) {
151
151
hpfs_error(s,
152
152
"bad EA info in fnode %08lx: ea_offs == %04x ea_size_s == %04x",
153
153
(unsigned long)ino,
154
-
fnode->ea_offs, fnode->ea_size_s);
154
+
le16_to_cpu(fnode->ea_offs), le16_to_cpu(fnode->ea_size_s));
155
155
goto bail;
156
156
}
157
157
ea = fnode_ea(fnode);
···
178
178
if (hpfs_sb(s)->sb_chk) if (hpfs_chk_sectors(s, ano, 1, "anode")) return NULL;
179
179
if ((anode = hpfs_map_sector(s, ano, bhp, ANODE_RD_AHEAD)))
180
180
if (hpfs_sb(s)->sb_chk) {
181
-
if (anode->magic != ANODE_MAGIC || anode->self != ano) {
181
+
if (le32_to_cpu(anode->magic) != ANODE_MAGIC) {
182
182
hpfs_error(s, "bad magic on anode %08x", ano);
183
+
goto bail;
184
+
}
185
+
if (le32_to_cpu(anode->self) != ano) {
186
+
hpfs_error(s, "self pointer invalid on anode %08x", ano);
183
187
goto bail;
184
188
}
185
189
if ((unsigned)anode->btree.n_used_nodes + (unsigned)anode->btree.n_free_nodes !=
···
191
187
hpfs_error(s, "bad number of nodes in anode %08x", ano);
192
188
goto bail;
193
189
}
194
-
if (anode->btree.first_free !=
190
+
if (le16_to_cpu(anode->btree.first_free) !=
195
191
8 + anode->btree.n_used_nodes * (anode->btree.internal ? 8 : 12)) {
196
192
hpfs_error(s, "bad first_free pointer in anode %08x", ano);
197
193
goto bail;
···
223
219
unsigned p, pp = 0;
224
220
unsigned char *d = (unsigned char *)dnode;
225
221
int b = 0;
226
-
if (dnode->magic != DNODE_MAGIC) {
222
+
if (le32_to_cpu(dnode->magic) != DNODE_MAGIC) {
227
223
hpfs_error(s, "bad magic on dnode %08x", secno);
228
224
goto bail;
229
225
}
230
-
if (dnode->self != secno)
231
-
hpfs_error(s, "bad self pointer on dnode %08x self = %08x", secno, dnode->self);
226
+
if (le32_to_cpu(dnode->self) != secno)
227
+
hpfs_error(s, "bad self pointer on dnode %08x self = %08x", secno, le32_to_cpu(dnode->self));
232
228
/* Check dirents - bad dirents would cause infinite
233
229
loops or shooting to memory */
234
-
if (dnode->first_free > 2048/* || dnode->first_free < 84*/) {
235
-
hpfs_error(s, "dnode %08x has first_free == %08x", secno, dnode->first_free);
230
+
if (le32_to_cpu(dnode->first_free) > 2048) {
231
+
hpfs_error(s, "dnode %08x has first_free == %08x", secno, le32_to_cpu(dnode->first_free));
236
232
goto bail;
237
233
}
238
-
for (p = 20; p < dnode->first_free; p += d[p] + (d[p+1] << 8)) {
234
+
for (p = 20; p < le32_to_cpu(dnode->first_free); p += d[p] + (d[p+1] << 8)) {
239
235
struct hpfs_dirent *de = (struct hpfs_dirent *)((char *)dnode + p);
240
-
if (de->length > 292 || (de->length < 32) || (de->length & 3) || p + de->length > 2048) {
236
+
if (le16_to_cpu(de->length) > 292 || (le16_to_cpu(de->length) < 32) || (le16_to_cpu(de->length) & 3) || p + le16_to_cpu(de->length) > 2048) {
241
237
hpfs_error(s, "bad dirent size in dnode %08x, dirent %03x, last %03x", secno, p, pp);
242
238
goto bail;
243
239
}
244
-
if (((31 + de->namelen + de->down*4 + 3) & ~3) != de->length) {
245
-
if (((31 + de->namelen + de->down*4 + 3) & ~3) < de->length && s->s_flags & MS_RDONLY) goto ok;
240
+
if (((31 + de->namelen + de->down*4 + 3) & ~3) != le16_to_cpu(de->length)) {
241
+
if (((31 + de->namelen + de->down*4 + 3) & ~3) < le16_to_cpu(de->length) && s->s_flags & MS_RDONLY) goto ok;
246
242
hpfs_error(s, "namelen does not match dirent size in dnode %08x, dirent %03x, last %03x", secno, p, pp);
247
243
goto bail;
248
244
}
···
255
251
pp = p;
256
252
257
253
}
258
-
if (p != dnode->first_free) {
254
+
if (p != le32_to_cpu(dnode->first_free)) {
259
255
hpfs_error(s, "size on last dirent does not match first_free; dnode %08x", secno);
260
256
goto bail;
261
257
}
···
281
277
if (!fnode)
282
278
return 0;
283
279
284
-
dno = fnode->u.external[0].disk_secno;
280
+
dno = le32_to_cpu(fnode->u.external[0].disk_secno);
285
281
brelse(bh);
286
282
return dno;
287
283
}
-33
fs/hpfs/name.c
-33
fs/hpfs/name.c
···
8
8
9
9
#include "hpfs_fn.h"
10
10
11
-
static const char *text_postfix[]={
12
-
".ASM", ".BAS", ".BAT", ".C", ".CC", ".CFG", ".CMD", ".CON", ".CPP", ".DEF",
13
-
".DOC", ".DPR", ".ERX", ".H", ".HPP", ".HTM", ".HTML", ".JAVA", ".LOG", ".PAS",
14
-
".RC", ".TEX", ".TXT", ".Y", ""};
15
-
16
-
static const char *text_prefix[]={
17
-
"AUTOEXEC.", "CHANGES", "COPYING", "CONFIG.", "CREDITS", "FAQ", "FILE_ID.DIZ",
18
-
"MAKEFILE", "READ.ME", "README", "TERMCAP", ""};
19
-
20
-
void hpfs_decide_conv(struct inode *inode, const unsigned char *name, unsigned len)
21
-
{
22
-
struct hpfs_inode_info *hpfs_inode = hpfs_i(inode);
23
-
int i;
24
-
if (hpfs_inode->i_conv != CONV_AUTO) return;
25
-
for (i = 0; *text_postfix[i]; i++) {
26
-
int l = strlen(text_postfix[i]);
27
-
if (l <= len)
28
-
if (!hpfs_compare_names(inode->i_sb, text_postfix[i], l, name + len - l, l, 0))
29
-
goto text;
30
-
}
31
-
for (i = 0; *text_prefix[i]; i++) {
32
-
int l = strlen(text_prefix[i]);
33
-
if (l <= len)
34
-
if (!hpfs_compare_names(inode->i_sb, text_prefix[i], l, name, l, 0))
35
-
goto text;
36
-
}
37
-
hpfs_inode->i_conv = CONV_BINARY;
38
-
return;
39
-
text:
40
-
hpfs_inode->i_conv = CONV_TEXT;
41
-
return;
42
-
}
43
-
44
11
static inline int not_allowed_char(unsigned char c)
45
12
{
46
13
return c<' ' || c=='"' || c=='*' || c=='/' || c==':' || c=='<' ||
+30
-76
fs/hpfs/namei.c
+30
-76
fs/hpfs/namei.c
···
29
29
fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh);
30
30
if (!fnode)
31
31
goto bail;
32
-
dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1);
32
+
dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0);
33
33
if (!dnode)
34
34
goto bail1;
35
35
memset(&dee, 0, sizeof dee);
···
37
37
if (!(mode & 0222)) dee.read_only = 1;
38
38
/*dee.archive = 0;*/
39
39
dee.hidden = name[0] == '.';
40
-
dee.fnode = fno;
41
-
dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
40
+
dee.fnode = cpu_to_le32(fno);
41
+
dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
42
42
result = new_inode(dir->i_sb);
43
43
if (!result)
44
44
goto bail2;
···
46
46
result->i_ino = fno;
47
47
hpfs_i(result)->i_parent_dir = dir->i_ino;
48
48
hpfs_i(result)->i_dno = dno;
49
-
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
49
+
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
50
50
result->i_ctime.tv_nsec = 0;
51
51
result->i_mtime.tv_nsec = 0;
52
52
result->i_atime.tv_nsec = 0;
···
60
60
if (dee.read_only)
61
61
result->i_mode &= ~0222;
62
62
63
-
mutex_lock(&hpfs_i(dir)->i_mutex);
64
-
r = hpfs_add_dirent(dir, name, len, &dee, 0);
63
+
r = hpfs_add_dirent(dir, name, len, &dee);
65
64
if (r == 1)
66
65
goto bail3;
67
66
if (r == -1) {
···
69
70
}
70
71
fnode->len = len;
71
72
memcpy(fnode->name, name, len > 15 ? 15 : len);
72
-
fnode->up = dir->i_ino;
73
+
fnode->up = cpu_to_le32(dir->i_ino);
73
74
fnode->dirflag = 1;
74
75
fnode->btree.n_free_nodes = 7;
75
76
fnode->btree.n_used_nodes = 1;
76
-
fnode->btree.first_free = 0x14;
77
-
fnode->u.external[0].disk_secno = dno;
78
-
fnode->u.external[0].file_secno = -1;
77
+
fnode->btree.first_free = cpu_to_le16(0x14);
78
+
fnode->u.external[0].disk_secno = cpu_to_le32(dno);
79
+
fnode->u.external[0].file_secno = cpu_to_le32(-1);
79
80
dnode->root_dnode = 1;
80
-
dnode->up = fno;
81
+
dnode->up = cpu_to_le32(fno);
81
82
de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
82
-
de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, get_seconds());
83
+
de->creation_date = de->write_date = de->read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
83
84
if (!(mode & 0222)) de->read_only = 1;
84
85
de->first = de->directory = 1;
85
86
/*de->hidden = de->system = 0;*/
86
-
de->fnode = fno;
87
+
de->fnode = cpu_to_le32(fno);
87
88
mark_buffer_dirty(bh);
88
89
brelse(bh);
89
90
hpfs_mark_4buffers_dirty(&qbh0);
···
100
101
hpfs_write_inode_nolock(result);
101
102
}
102
103
d_instantiate(dentry, result);
103
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
104
104
hpfs_unlock(dir->i_sb);
105
105
return 0;
106
106
bail3:
107
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
108
107
iput(result);
109
108
bail2:
110
109
hpfs_brelse4(&qbh0);
···
137
140
if (!(mode & 0222)) dee.read_only = 1;
138
141
dee.archive = 1;
139
142
dee.hidden = name[0] == '.';
140
-
dee.fnode = fno;
141
-
dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
143
+
dee.fnode = cpu_to_le32(fno);
144
+
dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
142
145
143
146
result = new_inode(dir->i_sb);
144
147
if (!result)
···
151
154
result->i_op = &hpfs_file_iops;
152
155
result->i_fop = &hpfs_file_ops;
153
156
result->i_nlink = 1;
154
-
hpfs_decide_conv(result, name, len);
155
157
hpfs_i(result)->i_parent_dir = dir->i_ino;
156
-
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
158
+
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
157
159
result->i_ctime.tv_nsec = 0;
158
160
result->i_mtime.tv_nsec = 0;
159
161
result->i_atime.tv_nsec = 0;
···
164
168
result->i_data.a_ops = &hpfs_aops;
165
169
hpfs_i(result)->mmu_private = 0;
166
170
167
-
mutex_lock(&hpfs_i(dir)->i_mutex);
168
-
r = hpfs_add_dirent(dir, name, len, &dee, 0);
171
+
r = hpfs_add_dirent(dir, name, len, &dee);
169
172
if (r == 1)
170
173
goto bail2;
171
174
if (r == -1) {
···
173
178
}
174
179
fnode->len = len;
175
180
memcpy(fnode->name, name, len > 15 ? 15 : len);
176
-
fnode->up = dir->i_ino;
181
+
fnode->up = cpu_to_le32(dir->i_ino);
177
182
mark_buffer_dirty(bh);
178
183
brelse(bh);
179
184
···
188
193
hpfs_write_inode_nolock(result);
189
194
}
190
195
d_instantiate(dentry, result);
191
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
192
196
hpfs_unlock(dir->i_sb);
193
197
return 0;
194
198
195
199
bail2:
196
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
197
200
iput(result);
198
201
bail1:
199
202
brelse(bh);
···
225
232
if (!(mode & 0222)) dee.read_only = 1;
226
233
dee.archive = 1;
227
234
dee.hidden = name[0] == '.';
228
-
dee.fnode = fno;
229
-
dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
235
+
dee.fnode = cpu_to_le32(fno);
236
+
dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
230
237
231
238
result = new_inode(dir->i_sb);
232
239
if (!result)
···
235
242
hpfs_init_inode(result);
236
243
result->i_ino = fno;
237
244
hpfs_i(result)->i_parent_dir = dir->i_ino;
238
-
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
245
+
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
239
246
result->i_ctime.tv_nsec = 0;
240
247
result->i_mtime.tv_nsec = 0;
241
248
result->i_atime.tv_nsec = 0;
···
247
254
result->i_blocks = 1;
248
255
init_special_inode(result, mode, rdev);
249
256
250
-
mutex_lock(&hpfs_i(dir)->i_mutex);
251
-
r = hpfs_add_dirent(dir, name, len, &dee, 0);
257
+
r = hpfs_add_dirent(dir, name, len, &dee);
252
258
if (r == 1)
253
259
goto bail2;
254
260
if (r == -1) {
···
256
264
}
257
265
fnode->len = len;
258
266
memcpy(fnode->name, name, len > 15 ? 15 : len);
259
-
fnode->up = dir->i_ino;
267
+
fnode->up = cpu_to_le32(dir->i_ino);
260
268
mark_buffer_dirty(bh);
261
269
262
270
insert_inode_hash(result);
263
271
264
272
hpfs_write_inode_nolock(result);
265
273
d_instantiate(dentry, result);
266
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
267
274
brelse(bh);
268
275
hpfs_unlock(dir->i_sb);
269
276
return 0;
270
277
bail2:
271
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
272
278
iput(result);
273
279
bail1:
274
280
brelse(bh);
···
300
310
memset(&dee, 0, sizeof dee);
301
311
dee.archive = 1;
302
312
dee.hidden = name[0] == '.';
303
-
dee.fnode = fno;
304
-
dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, get_seconds());
313
+
dee.fnode = cpu_to_le32(fno);
314
+
dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds()));
305
315
306
316
result = new_inode(dir->i_sb);
307
317
if (!result)
···
309
319
result->i_ino = fno;
310
320
hpfs_init_inode(result);
311
321
hpfs_i(result)->i_parent_dir = dir->i_ino;
312
-
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, dee.creation_date);
322
+
result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date));
313
323
result->i_ctime.tv_nsec = 0;
314
324
result->i_mtime.tv_nsec = 0;
315
325
result->i_atime.tv_nsec = 0;
···
323
333
result->i_op = &page_symlink_inode_operations;
324
334
result->i_data.a_ops = &hpfs_symlink_aops;
325
335
326
-
mutex_lock(&hpfs_i(dir)->i_mutex);
327
-
r = hpfs_add_dirent(dir, name, len, &dee, 0);
336
+
r = hpfs_add_dirent(dir, name, len, &dee);
328
337
if (r == 1)
329
338
goto bail2;
330
339
if (r == -1) {
···
332
343
}
333
344
fnode->len = len;
334
345
memcpy(fnode->name, name, len > 15 ? 15 : len);
335
-
fnode->up = dir->i_ino;
346
+
fnode->up = cpu_to_le32(dir->i_ino);
336
347
hpfs_set_ea(result, fnode, "SYMLINK", symlink, strlen(symlink));
337
348
mark_buffer_dirty(bh);
338
349
brelse(bh);
···
341
352
342
353
hpfs_write_inode_nolock(result);
343
354
d_instantiate(dentry, result);
344
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
345
355
hpfs_unlock(dir->i_sb);
346
356
return 0;
347
357
bail2:
348
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
349
358
iput(result);
350
359
bail1:
351
360
brelse(bh);
···
361
374
struct hpfs_dirent *de;
362
375
struct inode *inode = dentry->d_inode;
363
376
dnode_secno dno;
364
-
fnode_secno fno;
365
377
int r;
366
378
int rep = 0;
367
379
int err;
···
368
382
hpfs_lock(dir->i_sb);
369
383
hpfs_adjust_length(name, &len);
370
384
again:
371
-
mutex_lock(&hpfs_i(inode)->i_parent_mutex);
372
-
mutex_lock(&hpfs_i(dir)->i_mutex);
373
385
err = -ENOENT;
374
386
de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
375
387
if (!de)
···
381
397
if (de->directory)
382
398
goto out1;
383
399
384
-
fno = de->fnode;
385
400
r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
386
401
switch (r) {
387
402
case 1:
···
393
410
if (rep++)
394
411
break;
395
412
396
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
397
-
mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
398
413
dentry_unhash(dentry);
399
414
if (!d_unhashed(dentry)) {
400
415
dput(dentry);
···
426
445
out1:
427
446
hpfs_brelse4(&qbh);
428
447
out:
429
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
430
-
mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
431
448
hpfs_unlock(dir->i_sb);
432
449
return err;
433
450
}
···
438
459
struct hpfs_dirent *de;
439
460
struct inode *inode = dentry->d_inode;
440
461
dnode_secno dno;
441
-
fnode_secno fno;
442
462
int n_items = 0;
443
463
int err;
444
464
int r;
445
465
446
466
hpfs_adjust_length(name, &len);
447
467
hpfs_lock(dir->i_sb);
448
-
mutex_lock(&hpfs_i(inode)->i_parent_mutex);
449
-
mutex_lock(&hpfs_i(dir)->i_mutex);
450
468
err = -ENOENT;
451
469
de = map_dirent(dir, hpfs_i(dir)->i_dno, name, len, &dno, &qbh);
452
470
if (!de)
···
462
486
if (n_items)
463
487
goto out1;
464
488
465
-
fno = de->fnode;
466
489
r = hpfs_remove_dirent(dir, dno, de, &qbh, 1);
467
490
switch (r) {
468
491
case 1:
···
480
505
out1:
481
506
hpfs_brelse4(&qbh);
482
507
out:
483
-
mutex_unlock(&hpfs_i(dir)->i_mutex);
484
-
mutex_unlock(&hpfs_i(inode)->i_parent_mutex);
485
508
hpfs_unlock(dir->i_sb);
486
509
return err;
487
510
}
···
541
568
542
569
hpfs_lock(i->i_sb);
543
570
/* order doesn't matter, due to VFS exclusion */
544
-
mutex_lock(&hpfs_i(i)->i_parent_mutex);
545
-
if (new_inode)
546
-
mutex_lock(&hpfs_i(new_inode)->i_parent_mutex);
547
-
mutex_lock(&hpfs_i(old_dir)->i_mutex);
548
-
if (new_dir != old_dir)
549
-
mutex_lock(&hpfs_i(new_dir)->i_mutex);
550
571
551
572
/* Erm? Moving over the empty non-busy directory is perfectly legal */
552
573
if (new_inode && S_ISDIR(new_inode->i_mode)) {
···
577
610
578
611
if (new_dir == old_dir) hpfs_brelse4(&qbh);
579
612
580
-
hpfs_lock_creation(i->i_sb);
581
-
if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
582
-
hpfs_unlock_creation(i->i_sb);
613
+
if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de))) {
583
614
if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
584
615
err = r == 1 ? -ENOSPC : -EFSERROR;
585
616
if (new_dir != old_dir) hpfs_brelse4(&qbh);
···
586
621
587
622
if (new_dir == old_dir)
588
623
if (!(dep = map_dirent(old_dir, hpfs_i(old_dir)->i_dno, old_name, old_len, &dno, &qbh))) {
589
-
hpfs_unlock_creation(i->i_sb);
590
624
hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
591
625
err = -ENOENT;
592
626
goto end1;
593
627
}
594
628
595
629
if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
596
-
hpfs_unlock_creation(i->i_sb);
597
630
hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
598
631
err = r == 2 ? -ENOSPC : -EFSERROR;
599
632
goto end1;
600
633
}
601
-
hpfs_unlock_creation(i->i_sb);
602
-
634
+
603
635
end:
604
636
hpfs_i(i)->i_parent_dir = new_dir->i_ino;
605
637
if (S_ISDIR(i->i_mode)) {
···
604
642
drop_nlink(old_dir);
605
643
}
606
644
if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
607
-
fnode->up = new_dir->i_ino;
645
+
fnode->up = cpu_to_le32(new_dir->i_ino);
608
646
fnode->len = new_len;
609
647
memcpy(fnode->name, new_name, new_len>15?15:new_len);
610
648
if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
611
649
mark_buffer_dirty(bh);
612
650
brelse(bh);
613
651
}
614
-
hpfs_i(i)->i_conv = hpfs_sb(i->i_sb)->sb_conv;
615
-
hpfs_decide_conv(i, new_name, new_len);
616
652
end1:
617
-
if (old_dir != new_dir)
618
-
mutex_unlock(&hpfs_i(new_dir)->i_mutex);
619
-
mutex_unlock(&hpfs_i(old_dir)->i_mutex);
620
-
mutex_unlock(&hpfs_i(i)->i_parent_mutex);
621
-
if (new_inode)
622
-
mutex_unlock(&hpfs_i(new_inode)->i_parent_mutex);
623
653
hpfs_unlock(i->i_sb);
624
654
return err;
625
655
}
+51
-67
fs/hpfs/super.c
+51
-67
fs/hpfs/super.c
···
18
18
19
19
/* Mark the filesystem dirty, so that chkdsk checks it when os/2 booted */
20
20
21
-
static void mark_dirty(struct super_block *s)
21
+
static void mark_dirty(struct super_block *s, int remount)
22
22
{
23
-
if (hpfs_sb(s)->sb_chkdsk && !(s->s_flags & MS_RDONLY)) {
23
+
if (hpfs_sb(s)->sb_chkdsk && (remount || !(s->s_flags & MS_RDONLY))) {
24
24
struct buffer_head *bh;
25
25
struct hpfs_spare_block *sb;
26
26
if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
27
27
sb->dirty = 1;
28
28
sb->old_wrote = 0;
29
29
mark_buffer_dirty(bh);
30
+
sync_dirty_buffer(bh);
30
31
brelse(bh);
31
32
}
32
33
}
···
41
40
struct buffer_head *bh;
42
41
struct hpfs_spare_block *sb;
43
42
if (s->s_flags & MS_RDONLY) return;
43
+
sync_blockdev(s->s_bdev);
44
44
if ((sb = hpfs_map_sector(s, 17, &bh, 0))) {
45
45
sb->dirty = hpfs_sb(s)->sb_chkdsk > 1 - hpfs_sb(s)->sb_was_error;
46
46
sb->old_wrote = hpfs_sb(s)->sb_chkdsk >= 2 && !hpfs_sb(s)->sb_was_error;
47
47
mark_buffer_dirty(bh);
48
+
sync_dirty_buffer(bh);
48
49
brelse(bh);
49
50
}
50
51
}
···
66
63
if (!hpfs_sb(s)->sb_was_error) {
67
64
if (hpfs_sb(s)->sb_err == 2) {
68
65
printk("; crashing the system because you wanted it\n");
69
-
mark_dirty(s);
66
+
mark_dirty(s, 0);
70
67
panic("HPFS panic");
71
68
} else if (hpfs_sb(s)->sb_err == 1) {
72
69
if (s->s_flags & MS_RDONLY) printk("; already mounted read-only\n");
73
70
else {
74
71
printk("; remounting read-only\n");
75
-
mark_dirty(s);
72
+
mark_dirty(s, 0);
76
73
s->s_flags |= MS_RDONLY;
77
74
}
78
75
} else if (s->s_flags & MS_RDONLY) printk("; going on - but anything won't be destroyed because it's read-only\n");
···
105
102
{
106
103
struct hpfs_sb_info *sbi = hpfs_sb(s);
107
104
105
+
hpfs_lock(s);
106
+
unmark_dirty(s);
107
+
hpfs_unlock(s);
108
+
108
109
kfree(sbi->sb_cp_table);
109
110
kfree(sbi->sb_bmp_dir);
110
-
unmark_dirty(s);
111
111
s->s_fs_info = NULL;
112
112
kfree(sbi);
113
113
}
···
135
129
n_bands = (hpfs_sb(s)->sb_fs_size + 0x3fff) >> 14;
136
130
count = 0;
137
131
for (n = 0; n < n_bands; n++)
138
-
count += hpfs_count_one_bitmap(s, hpfs_sb(s)->sb_bmp_dir[n]);
132
+
count += hpfs_count_one_bitmap(s, le32_to_cpu(hpfs_sb(s)->sb_bmp_dir[n]));
139
133
return count;
140
134
}
141
135
···
194
188
{
195
189
struct hpfs_inode_info *ei = (struct hpfs_inode_info *) foo;
196
190
197
-
mutex_init(&ei->i_mutex);
198
-
mutex_init(&ei->i_parent_mutex);
199
191
inode_init_once(&ei->vfs_inode);
200
192
}
201
193
···
222
218
223
219
enum {
224
220
Opt_help, Opt_uid, Opt_gid, Opt_umask, Opt_case_lower, Opt_case_asis,
225
-
Opt_conv_binary, Opt_conv_text, Opt_conv_auto,
226
221
Opt_check_none, Opt_check_normal, Opt_check_strict,
227
222
Opt_err_cont, Opt_err_ro, Opt_err_panic,
228
223
Opt_eas_no, Opt_eas_ro, Opt_eas_rw,
···
236
233
{Opt_umask, "umask=%o"},
237
234
{Opt_case_lower, "case=lower"},
238
235
{Opt_case_asis, "case=asis"},
239
-
{Opt_conv_binary, "conv=binary"},
240
-
{Opt_conv_text, "conv=text"},
241
-
{Opt_conv_auto, "conv=auto"},
242
236
{Opt_check_none, "check=none"},
243
237
{Opt_check_normal, "check=normal"},
244
238
{Opt_check_strict, "check=strict"},
···
253
253
};
254
254
255
255
static int parse_opts(char *opts, uid_t *uid, gid_t *gid, umode_t *umask,
256
-
int *lowercase, int *conv, int *eas, int *chk, int *errs,
256
+
int *lowercase, int *eas, int *chk, int *errs,
257
257
int *chkdsk, int *timeshift)
258
258
{
259
259
char *p;
···
294
294
break;
295
295
case Opt_case_asis:
296
296
*lowercase = 0;
297
-
break;
298
-
case Opt_conv_binary:
299
-
*conv = CONV_BINARY;
300
-
break;
301
-
case Opt_conv_text:
302
-
*conv = CONV_TEXT;
303
-
break;
304
-
case Opt_conv_auto:
305
-
*conv = CONV_AUTO;
306
297
break;
307
298
case Opt_check_none:
308
299
*chk = 0;
···
361
370
umask=xxx set mode of files that don't have mode specified in eas\n\
362
371
case=lower lowercase all files\n\
363
372
case=asis do not lowercase files (default)\n\
364
-
conv=binary do not convert CR/LF -> LF (default)\n\
365
-
conv=auto convert only files with known text extensions\n\
366
-
conv=text convert all files\n\
367
373
check=none no fs checks - kernel may crash on corrupted filesystem\n\
368
374
check=normal do some checks - it should not crash (default)\n\
369
375
check=strict do extra time-consuming checks, used for debugging\n\
···
382
394
uid_t uid;
383
395
gid_t gid;
384
396
umode_t umask;
385
-
int lowercase, conv, eas, chk, errs, chkdsk, timeshift;
397
+
int lowercase, eas, chk, errs, chkdsk, timeshift;
386
398
int o;
387
399
struct hpfs_sb_info *sbi = hpfs_sb(s);
388
400
char *new_opts = kstrdup(data, GFP_KERNEL);
···
393
405
lock_super(s);
394
406
uid = sbi->sb_uid; gid = sbi->sb_gid;
395
407
umask = 0777 & ~sbi->sb_mode;
396
-
lowercase = sbi->sb_lowercase; conv = sbi->sb_conv;
408
+
lowercase = sbi->sb_lowercase;
397
409
eas = sbi->sb_eas; chk = sbi->sb_chk; chkdsk = sbi->sb_chkdsk;
398
410
errs = sbi->sb_err; timeshift = sbi->sb_timeshift;
399
411
400
-
if (!(o = parse_opts(data, &uid, &gid, &umask, &lowercase, &conv,
412
+
if (!(o = parse_opts(data, &uid, &gid, &umask, &lowercase,
401
413
&eas, &chk, &errs, &chkdsk, ×hift))) {
402
414
printk("HPFS: bad mount options.\n");
403
415
goto out_err;
···
415
427
416
428
sbi->sb_uid = uid; sbi->sb_gid = gid;
417
429
sbi->sb_mode = 0777 & ~umask;
418
-
sbi->sb_lowercase = lowercase; sbi->sb_conv = conv;
430
+
sbi->sb_lowercase = lowercase;
419
431
sbi->sb_eas = eas; sbi->sb_chk = chk; sbi->sb_chkdsk = chkdsk;
420
432
sbi->sb_err = errs; sbi->sb_timeshift = timeshift;
421
433
422
-
if (!(*flags & MS_RDONLY)) mark_dirty(s);
434
+
if (!(*flags & MS_RDONLY)) mark_dirty(s, 1);
423
435
424
436
replace_mount_options(s, new_opts);
425
437
···
459
471
uid_t uid;
460
472
gid_t gid;
461
473
umode_t umask;
462
-
int lowercase, conv, eas, chk, errs, chkdsk, timeshift;
474
+
int lowercase, eas, chk, errs, chkdsk, timeshift;
463
475
464
476
dnode_secno root_dno;
465
477
struct hpfs_dirent *de = NULL;
466
478
struct quad_buffer_head qbh;
467
479
468
480
int o;
469
-
470
-
if (num_possible_cpus() > 1) {
471
-
printk(KERN_ERR "HPFS is not SMP safe\n");
472
-
return -EINVAL;
473
-
}
474
481
475
482
save_mount_options(s, options);
476
483
···
478
495
sbi->sb_bmp_dir = NULL;
479
496
sbi->sb_cp_table = NULL;
480
497
481
-
mutex_init(&sbi->hpfs_creation_de);
498
+
mutex_init(&sbi->hpfs_mutex);
499
+
hpfs_lock(s);
482
500
483
501
uid = current_uid();
484
502
gid = current_gid();
485
503
umask = current_umask();
486
504
lowercase = 0;
487
-
conv = CONV_BINARY;
488
505
eas = 2;
489
506
chk = 1;
490
507
errs = 1;
491
508
chkdsk = 1;
492
509
timeshift = 0;
493
510
494
-
if (!(o = parse_opts(options, &uid, &gid, &umask, &lowercase, &conv,
511
+
if (!(o = parse_opts(options, &uid, &gid, &umask, &lowercase,
495
512
&eas, &chk, &errs, &chkdsk, ×hift))) {
496
513
printk("HPFS: bad mount options.\n");
497
514
goto bail0;
···
509
526
if (!(spareblock = hpfs_map_sector(s, 17, &bh2, 0))) goto bail3;
510
527
511
528
/* Check magics */
512
-
if (/*bootblock->magic != BB_MAGIC
513
-
||*/ superblock->magic != SB_MAGIC
514
-
|| spareblock->magic != SP_MAGIC) {
529
+
if (/*le16_to_cpu(bootblock->magic) != BB_MAGIC
530
+
||*/ le32_to_cpu(superblock->magic) != SB_MAGIC
531
+
|| le32_to_cpu(spareblock->magic) != SP_MAGIC) {
515
532
if (!silent) printk("HPFS: Bad magic ... probably not HPFS\n");
516
533
goto bail4;
517
534
}
···
532
549
s->s_op = &hpfs_sops;
533
550
s->s_d_op = &hpfs_dentry_operations;
534
551
535
-
sbi->sb_root = superblock->root;
536
-
sbi->sb_fs_size = superblock->n_sectors;
537
-
sbi->sb_bitmaps = superblock->bitmaps;
538
-
sbi->sb_dirband_start = superblock->dir_band_start;
539
-
sbi->sb_dirband_size = superblock->n_dir_band;
540
-
sbi->sb_dmap = superblock->dir_band_bitmap;
552
+
sbi->sb_root = le32_to_cpu(superblock->root);
553
+
sbi->sb_fs_size = le32_to_cpu(superblock->n_sectors);
554
+
sbi->sb_bitmaps = le32_to_cpu(superblock->bitmaps);
555
+
sbi->sb_dirband_start = le32_to_cpu(superblock->dir_band_start);
556
+
sbi->sb_dirband_size = le32_to_cpu(superblock->n_dir_band);
557
+
sbi->sb_dmap = le32_to_cpu(superblock->dir_band_bitmap);
541
558
sbi->sb_uid = uid;
542
559
sbi->sb_gid = gid;
543
560
sbi->sb_mode = 0777 & ~umask;
544
561
sbi->sb_n_free = -1;
545
562
sbi->sb_n_free_dnodes = -1;
546
563
sbi->sb_lowercase = lowercase;
547
-
sbi->sb_conv = conv;
548
564
sbi->sb_eas = eas;
549
565
sbi->sb_chk = chk;
550
566
sbi->sb_chkdsk = chkdsk;
···
555
573
sbi->sb_max_fwd_alloc = 0xffffff;
556
574
557
575
/* Load bitmap directory */
558
-
if (!(sbi->sb_bmp_dir = hpfs_load_bitmap_directory(s, superblock->bitmaps)))
576
+
if (!(sbi->sb_bmp_dir = hpfs_load_bitmap_directory(s, le32_to_cpu(superblock->bitmaps))))
559
577
goto bail4;
560
578
561
579
/* Check for general fs errors*/
···
573
591
mark_buffer_dirty(bh2);
574
592
}
575
593
576
-
if (spareblock->hotfixes_used || spareblock->n_spares_used) {
594
+
if (le32_to_cpu(spareblock->hotfixes_used) || le32_to_cpu(spareblock->n_spares_used)) {
577
595
if (errs >= 2) {
578
596
printk("HPFS: Hotfixes not supported here, try chkdsk\n");
579
-
mark_dirty(s);
597
+
mark_dirty(s, 0);
580
598
goto bail4;
581
599
}
582
600
hpfs_error(s, "hotfixes not supported here, try chkdsk");
583
601
if (errs == 0) printk("HPFS: Proceeding, but your filesystem will be probably corrupted by this driver...\n");
584
602
else printk("HPFS: This driver may read bad files or crash when operating on disk with hotfixes.\n");
585
603
}
586
-
if (spareblock->n_dnode_spares != spareblock->n_dnode_spares_free) {
604
+
if (le32_to_cpu(spareblock->n_dnode_spares) != le32_to_cpu(spareblock->n_dnode_spares_free)) {
587
605
if (errs >= 2) {
588
606
printk("HPFS: Spare dnodes used, try chkdsk\n");
589
-
mark_dirty(s);
607
+
mark_dirty(s, 0);
590
608
goto bail4;
591
609
}
592
610
hpfs_error(s, "warning: spare dnodes used, try chkdsk");
···
594
612
}
595
613
if (chk) {
596
614
unsigned a;
597
-
if (superblock->dir_band_end - superblock->dir_band_start + 1 != superblock->n_dir_band ||
598
-
superblock->dir_band_end < superblock->dir_band_start || superblock->n_dir_band > 0x4000) {
615
+
if (le32_to_cpu(superblock->dir_band_end) - le32_to_cpu(superblock->dir_band_start) + 1 != le32_to_cpu(superblock->n_dir_band) ||
616
+
le32_to_cpu(superblock->dir_band_end) < le32_to_cpu(superblock->dir_band_start) || le32_to_cpu(superblock->n_dir_band) > 0x4000) {
599
617
hpfs_error(s, "dir band size mismatch: dir_band_start==%08x, dir_band_end==%08x, n_dir_band==%08x",
600
-
superblock->dir_band_start, superblock->dir_band_end, superblock->n_dir_band);
618
+
le32_to_cpu(superblock->dir_band_start), le32_to_cpu(superblock->dir_band_end), le32_to_cpu(superblock->n_dir_band));
601
619
goto bail4;
602
620
}
603
621
a = sbi->sb_dirband_size;
604
622
sbi->sb_dirband_size = 0;
605
-
if (hpfs_chk_sectors(s, superblock->dir_band_start, superblock->n_dir_band, "dir_band") ||
606
-
hpfs_chk_sectors(s, superblock->dir_band_bitmap, 4, "dir_band_bitmap") ||
607
-
hpfs_chk_sectors(s, superblock->bitmaps, 4, "bitmaps")) {
608
-
mark_dirty(s);
623
+
if (hpfs_chk_sectors(s, le32_to_cpu(superblock->dir_band_start), le32_to_cpu(superblock->n_dir_band), "dir_band") ||
624
+
hpfs_chk_sectors(s, le32_to_cpu(superblock->dir_band_bitmap), 4, "dir_band_bitmap") ||
625
+
hpfs_chk_sectors(s, le32_to_cpu(superblock->bitmaps), 4, "bitmaps")) {
626
+
mark_dirty(s, 0);
609
627
goto bail4;
610
628
}
611
629
sbi->sb_dirband_size = a;
612
630
} else printk("HPFS: You really don't want any checks? You are crazy...\n");
613
631
614
632
/* Load code page table */
615
-
if (spareblock->n_code_pages)
616
-
if (!(sbi->sb_cp_table = hpfs_load_code_page(s, spareblock->code_page_dir)))
633
+
if (le32_to_cpu(spareblock->n_code_pages))
634
+
if (!(sbi->sb_cp_table = hpfs_load_code_page(s, le32_to_cpu(spareblock->code_page_dir))))
617
635
printk("HPFS: Warning: code page support is disabled\n");
618
636
619
637
brelse(bh2);
···
642
660
if (!de)
643
661
hpfs_error(s, "unable to find root dir");
644
662
else {
645
-
root->i_atime.tv_sec = local_to_gmt(s, de->read_date);
663
+
root->i_atime.tv_sec = local_to_gmt(s, le32_to_cpu(de->read_date));
646
664
root->i_atime.tv_nsec = 0;
647
-
root->i_mtime.tv_sec = local_to_gmt(s, de->write_date);
665
+
root->i_mtime.tv_sec = local_to_gmt(s, le32_to_cpu(de->write_date));
648
666
root->i_mtime.tv_nsec = 0;
649
-
root->i_ctime.tv_sec = local_to_gmt(s, de->creation_date);
667
+
root->i_ctime.tv_sec = local_to_gmt(s, le32_to_cpu(de->creation_date));
650
668
root->i_ctime.tv_nsec = 0;
651
-
hpfs_i(root)->i_ea_size = de->ea_size;
669
+
hpfs_i(root)->i_ea_size = le16_to_cpu(de->ea_size);
652
670
hpfs_i(root)->i_parent_dir = root->i_ino;
653
671
if (root->i_size == -1)
654
672
root->i_size = 2048;
···
656
674
root->i_blocks = 5;
657
675
hpfs_brelse4(&qbh);
658
676
}
677
+
hpfs_unlock(s);
659
678
return 0;
660
679
661
680
bail4: brelse(bh2);
···
664
681
bail2: brelse(bh0);
665
682
bail1:
666
683
bail0:
684
+
hpfs_unlock(s);
667
685
kfree(sbi->sb_bmp_dir);
668
686
kfree(sbi->sb_cp_table);
669
687
s->s_fs_info = NULL;