1 /*-
2 * Copyright (c) 1998, 1999 Semen Ustimenko (semenu@FreeBSD.org)
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD$
27 */
28
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/kernel.h>
32 #include <sys/proc.h>
33 #include <sys/time.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <sys/vnode.h>
37 #include <sys/mount.h>
38 #include <sys/namei.h>
39 #include <sys/malloc.h>
40 #include <sys/bio.h>
41 #include <sys/buf.h>
42
43 #include <fs/hpfs/hpfs.h>
44 #include <fs/hpfs/hpfsmount.h>
45 #include <fs/hpfs/hpfs_subr.h>
46
47 u_long
48 hpfs_checksum(
49 u_int8_t *object,
50 int size)
51 {
52 register int i;
53 u_long csum=0L;
54 for (i=0; i < size; i++) {
55 csum += (u_long) *object++;
56 csum = (csum << 7) + (csum >> (25));
57 }
58 return (csum);
59 }
60
61 void
62 hpfs_bmdeinit(
63 struct hpfsmount *hpmp)
64 {
65 struct buf *bp;
66 int i;
67
68 dprintf(("hpmp_bmdeinit: "));
69
70 if (!(hpmp->hpm_mp->mnt_flag & MNT_RDONLY)) {
71 /*
72 * Write down BitMap.
73 */
74 for (i=0; i<hpmp->hpm_dbnum; i++) {
75 dprintf(("[%d: 0x%x] ", i, hpmp->hpm_bmind[i]));
76
77 bp = getblk(hpmp->hpm_devvp, hpmp->hpm_bmind[i],
78 BMSIZE, 0, 0, 0);
79 clrbuf(bp);
80
81 bcopy(hpmp->hpm_bitmap + BMSIZE * i, bp->b_data,
82 BMSIZE);
83
84 bwrite(bp);
85 }
86 }
87
88 free(hpmp->hpm_bitmap,M_HPFSMNT);
89 free(hpmp->hpm_bmind,M_HPFSMNT);
90
91 dprintf(("\n"));
92 }
93
94 /*
95 * Initialize BitMap management, includes calculation of
96 * available blocks number.
97 */
98 int
99 hpfs_bminit(
100 struct hpfsmount *hpmp)
101 {
102 struct buf *bp;
103 int error, i, k;
104 u_long dbavail;
105
106 dprintf(("hpfs_bminit: "));
107
108 hpmp->hpm_dbnum = (hpmp->hpm_su.su_btotal + 0x3FFF) / 0x4000;
109
110 dprintf(("0x%lx data bands, ", hpmp->hpm_dbnum));
111
112 hpmp->hpm_bmind = malloc(hpmp->hpm_dbnum * sizeof(lsn_t),
113 M_HPFSMNT, M_WAITOK);
114
115 hpmp->hpm_bitmap = malloc(hpmp->hpm_dbnum * BMSIZE,
116 M_HPFSMNT, M_WAITOK);
117
118 error = bread(hpmp->hpm_devvp, hpmp->hpm_su.su_bitmap.lsn1,
119 ((hpmp->hpm_dbnum + 0x7F) & ~(0x7F)) << 2, NOCRED, &bp);
120 if (error) {
121 brelse(bp);
122 free(hpmp->hpm_bitmap, M_HPFSMNT);
123 free(hpmp->hpm_bmind, M_HPFSMNT);
124 dprintf((" error %d\n", error));
125 return (error);
126 }
127 bcopy(bp->b_data, hpmp->hpm_bmind, hpmp->hpm_dbnum * sizeof(lsn_t));
128
129 brelse(bp);
130
131 /*
132 * Read in all BitMap
133 */
134 for (i=0; i<hpmp->hpm_dbnum; i++) {
135 dprintf(("[%d: 0x%x] ", i, hpmp->hpm_bmind[i]));
136
137 error = bread(hpmp->hpm_devvp, hpmp->hpm_bmind[i],
138 BMSIZE, NOCRED, &bp);
139 if (error) {
140 brelse(bp);
141 free(hpmp->hpm_bitmap, M_HPFSMNT);
142 free(hpmp->hpm_bmind, M_HPFSMNT);
143 dprintf((" error %d\n", error));
144 return (error);
145 }
146 bcopy(bp->b_data, hpmp->hpm_bitmap + BMSIZE * i, BMSIZE);
147
148 brelse(bp);
149 }
150
151 /*
152 * Look througth BitMap and count free bits
153 */
154 dbavail = 0;
155 for (i=0; i < hpmp->hpm_su.su_btotal >> 5; i++) {
156 register u_int32_t mask;
157 for (k=0, mask=1; k < 32; k++, mask<<=1)
158 if(((u_int32_t *)hpmp->hpm_bitmap)[i] & mask)
159 dbavail ++;
160
161 }
162 hpmp->hpm_bavail = dbavail;
163
164 return (0);
165 }
166
167 int
168 hpfs_cmpfname (
169 struct hpfsmount *hpmp,
170 char * uname,
171 int ulen,
172 char * dname,
173 int dlen,
174 u_int16_t cp)
175 {
176 register int i, res;
177
178 for (i = 0; i < ulen && i < dlen; i++) {
179 res = hpfs_toupper(hpmp, hpfs_u2d(hpmp, uname[i]), cp) -
180 hpfs_toupper(hpmp, dname[i], cp);
181 if (res)
182 return res;
183 }
184 return (ulen - dlen);
185 }
186
187 int
188 hpfs_cpstrnnicmp (
189 struct hpfsmount *hpmp,
190 char * str1,
191 int str1len,
192 u_int16_t str1cp,
193 char * str2,
194 int str2len,
195 u_int16_t str2cp)
196 {
197 int i, res;
198
199 for (i = 0; i < str1len && i < str2len; i++) {
200 res = (int)hpfs_toupper(hpmp, ((u_char *)str1)[i], str1cp) -
201 (int)hpfs_toupper(hpmp, ((u_char *)str2)[i], str2cp);
202 if (res)
203 return res;
204 }
205 return (str1len - str2len);
206 }
207
208
209 int
210 hpfs_cpload (
211 struct hpfsmount *hpmp,
212 struct cpiblk *cpibp,
213 struct cpdblk *cpdbp)
214 {
215 struct buf *bp;
216 struct cpdsec * cpdsp;
217 int error, i;
218
219 error = bread(hpmp->hpm_devvp, cpibp->b_cpdsec, DEV_BSIZE, NOCRED, &bp);
220 if (error) {
221 brelse(bp);
222 return (error);
223 }
224
225 cpdsp = (struct cpdsec *)bp->b_data;
226
227 for (i=cpdsp->d_cpfirst; i<cpdsp->d_cpcnt; i++) {
228 if (cpdsp->d_cpdblk[i].b_cpid == cpibp->b_cpid) {
229 bcopy(cpdsp->d_cpdblk + i, cpdbp,
230 sizeof(struct cpdblk));
231
232 brelse(bp);
233
234 return (0);
235 }
236 }
237
238 brelse(bp);
239
240 return (ENOENT);
241 }
242
243
244 /*
245 * Initialize Code Page information management.
246 * Load all copdepages in memory.
247 */
248 int
249 hpfs_cpinit (
250 struct mount *mp,
251 struct hpfsmount *hpmp)
252 {
253 struct buf *bp;
254 int error, i;
255 lsn_t lsn;
256 int cpicnt;
257 struct cpisec * cpisp;
258 struct cpiblk * cpibp;
259 struct cpdblk * cpdbp;
260
261 dprintf(("hpfs_cpinit: \n"));
262
263 error = vfs_copyopt(mp->mnt_optnew, "d2u", hpmp->hpm_d2u,
264 sizeof hpmp->hpm_d2u);
265 if (error == ENOENT)
266 for (i=0x0; i<0x80;i++)
267 hpmp->hpm_d2u[i] = i + 0x80;
268 else if (error)
269 return (error);
270
271 error = vfs_copyopt(mp->mnt_optnew, "u2d", hpmp->hpm_u2d,
272 sizeof hpmp->hpm_u2d);
273 if (error == ENOENT)
274 for (i=0x0; i<0x80;i++)
275 hpmp->hpm_u2d[i] = i + 0x80;
276 else if (error)
277 return (error);
278
279 cpicnt = hpmp->hpm_sp.sp_cpinum;
280
281 hpmp->hpm_cpdblk = malloc(cpicnt * sizeof(struct cpdblk),
282 M_HPFSMNT, M_WAITOK);
283
284 cpdbp = hpmp->hpm_cpdblk;
285 lsn = hpmp->hpm_sp.sp_cpi;
286
287 while (cpicnt > 0) {
288 error = bread(hpmp->hpm_devvp, lsn, DEV_BSIZE, NOCRED, &bp);
289 if (error) {
290 brelse(bp);
291 return (error);
292 }
293
294 cpisp = (struct cpisec *)bp->b_data;
295
296 cpibp = cpisp->s_cpi;
297 for (i=0; i<cpisp->s_cpicnt; i++, cpicnt --, cpdbp++, cpibp++) {
298 dprintf(("hpfs_cpinit: Country: %d, CP: %d (%d)\n",
299 cpibp->b_country, cpibp->b_cpid,
300 cpibp->b_vcpid));
301
302 error = hpfs_cpload(hpmp, cpibp, cpdbp);
303 if (error) {
304 brelse(bp);
305 return (error);
306 }
307 }
308 lsn = cpisp->s_next;
309 brelse(bp);
310 }
311
312 return (0);
313 }
314
315 int
316 hpfs_cpdeinit (
317 struct hpfsmount *hpmp)
318 {
319 dprintf(("hpmp_cpdeinit: "));
320 free(hpmp->hpm_cpdblk,M_HPFSMNT);
321 return (0);
322 }
323
324 /*
325 * Lookup for a run of blocks.
326 */
327 int
328 hpfs_bmlookup (
329 struct hpfsmount *hpmp,
330 u_long flags, /* 1 means we want right len blocks in run, not less */
331 lsn_t lsn, /* We want near this one */
332 u_long len, /* We want such long */
333 lsn_t *lsnp, /* We got here */
334 u_long *lenp) /* We got this long */
335 {
336 u_int32_t * bitmap;
337 register u_int32_t mask;
338 int i,k;
339 int cband, vcband;
340 u_int bandsz;
341 int count;
342
343 dprintf(("hpfs_bmlookup: lsn: 0x%x, len 0x%lx | Step1\n", lsn, len));
344
345 if (lsn > hpmp->hpm_su.su_btotal) {
346 printf("hpfs_bmlookup: OUT OF VOLUME\n");
347 return ENOSPC;
348 }
349 if (len > hpmp->hpm_bavail) {
350 printf("hpfs_bmlookup: OUT OF SPACE\n");
351 return ENOSPC;
352 }
353 i = lsn >> 5;
354 k = lsn & 0x1F;
355 mask = 1 << k;
356 bitmap = (u_int32_t *)hpmp->hpm_bitmap + i;
357
358 if (*bitmap & mask) {
359 *lsnp = lsn;
360 *lenp = 0;
361 for (; k < 32; k++, mask<<=1) {
362 if (*bitmap & mask)
363 (*lenp) ++;
364 else {
365 if (flags & 1)
366 goto step2;
367 else
368 return (0);
369 }
370
371 if (*lenp == len)
372 return (0);
373 }
374
375 bitmap++;
376 i++;
377 for (; i < hpmp->hpm_su.su_btotal >> 5; i++, bitmap++) {
378 for (k=0, mask=1; k < 32; k++, mask<<=1) {
379 if (*bitmap & mask)
380 (*lenp) ++;
381 else {
382 if (flags & 1)
383 goto step2;
384 else
385 return (0);
386 }
387
388 if (*lenp == len)
389 return (0);
390 }
391 }
392 return (0);
393 }
394
395 step2:
396 /*
397 * Lookup all bands begining from cband, lookup for first block
398 */
399 cband = (lsn >> 14);
400 dprintf(("hpfs_bmlookup: Step2: band 0x%x (0x%lx)\n",
401 cband, hpmp->hpm_dbnum));
402 for (vcband = 0; vcband < hpmp->hpm_dbnum; vcband ++, cband++) {
403 cband = cband % hpmp->hpm_dbnum;
404 bandsz = min (hpmp->hpm_su.su_btotal - (cband << 14), 0x4000);
405 dprintf(("hpfs_bmlookup: band: %d, sz: 0x%x\n", cband, bandsz));
406
407 bitmap = (u_int32_t *)hpmp->hpm_bitmap + (cband << 9);
408 *lsnp = cband << 14;
409 *lenp = 0;
410 count = 0;
411 for (i=0; i < bandsz >> 5; i++, bitmap++) {
412 for (k=0, mask=1; k < 32; k++, mask<<=1) {
413 if (*bitmap & mask) {
414 if (count) {
415 (*lenp) ++;
416 } else {
417 count = 1;
418 *lsnp = (cband << 14) + (i << 5) + k;
419 *lenp = 1;
420 }
421 } else {
422 if ((*lenp) && !(flags & 1)) {
423 return (0);
424 } else {
425 count = 0;
426 }
427 }
428
429 if (*lenp == len)
430 return (0);
431 }
432 }
433 if (cband == hpmp->hpm_dbnum - 1) {
434 if ((*lenp) && !(flags & 1)) {
435 return (0);
436 } else {
437 count = 0;
438 }
439 }
440 }
441
442 return (ENOSPC);
443 }
444
445 /*
446 * Lookup a single free block. XXX Need locking on BitMap operations
447 * VERY STUPID ROUTINE!!!
448 */
449 int
450 hpfs_bmfblookup (
451 struct hpfsmount *hpmp,
452 lsn_t *lp)
453 {
454 u_int32_t * bitmap;
455 int i,k;
456
457 dprintf(("hpfs_bmfblookup: "));
458
459 bitmap = (u_int32_t *)hpmp->hpm_bitmap;
460 for (i=0; i < hpmp->hpm_su.su_btotal >> 5; i++, bitmap++) {
461 k = ffs(*bitmap);
462 if (k) {
463 *lp = (i << 5) + k - 1;
464 dprintf((" found: 0x%x\n",*lp));
465 return (0);
466 }
467 }
468
469 return (ENOSPC);
470 }
471
472 /*
473 * Mark contignous block of blocks.
474 */
475 int
476 hpfs_bmmark (
477 struct hpfsmount *hpmp,
478 lsn_t bn,
479 u_long bl,
480 int state)
481 {
482 u_int32_t * bitmap;
483 int i, didprint = 0;
484
485 dprintf(("hpfs_bmmark(0x%x, 0x%lx, %d): \n",bn,bl, state));
486
487 if ((bn > hpmp->hpm_su.su_btotal) || (bn+bl > hpmp->hpm_su.su_btotal)) {
488 printf("hpfs_bmmark: MARKING OUT OF VOLUME\n");
489 return 0;
490 }
491 bitmap = (u_int32_t *)hpmp->hpm_bitmap;
492 bitmap += bn >> 5;
493
494 while (bl > 0) {
495 for (i = bn & 0x1F; (i < 0x20) && (bl > 0) ; i++, bl--) {
496 if (state) {
497 if ( *bitmap & (1 << i)) {
498 if (!didprint) {
499 printf("hpfs_bmmark: ALREADY FREE\n");
500 didprint = 1;
501 }
502 } else
503 hpmp->hpm_bavail++;
504
505 *bitmap |= (1 << i);
506 } else {
507 if ((~(*bitmap)) & (1 << i)) {
508 if (!didprint) {
509 printf("hpfs_bmmark: ALREADY BUSY\n");
510 didprint = 1;
511 }
512 } else
513 hpmp->hpm_bavail--;
514
515 *bitmap &= ~(1 << i);
516 }
517 }
518 bn = 0;
519 bitmap++;
520 }
521
522 return (0);
523 }
524
525
526 int
527 hpfs_validateparent (
528 struct hpfsnode *hp)
529 {
530 struct hpfsnode *dhp;
531 struct vnode *dvp;
532 struct hpfsmount *hpmp = hp->h_hpmp;
533 struct buf *bp;
534 struct dirblk *dp;
535 struct hpfsdirent *dep;
536 lsn_t lsn, olsn;
537 int level, error;
538
539 dprintf(("hpfs_validatetimes(0x%x): [parent: 0x%x] ",
540 hp->h_no, hp->h_fn.fn_parent));
541
542 if (hp->h_no == hp->h_fn.fn_parent) {
543 dhp = hp;
544 } else {
545 error = VFS_VGET(hpmp->hpm_mp, hp->h_fn.fn_parent,
546 LK_EXCLUSIVE, &dvp);
547 if (error)
548 return (error);
549 dhp = VTOHP(dvp);
550 }
551
552 lsn = ((alleaf_t *)dhp->h_fn.fn_abd)->al_lsn;
553
554 olsn = 0;
555 level = 1;
556 bp = NULL;
557
558 dive:
559 dprintf(("[dive 0x%x] ", lsn));
560 if (bp != NULL)
561 brelse(bp);
562 error = bread(dhp->h_devvp, lsn, D_BSIZE, NOCRED, &bp);
563 if (error)
564 goto failed;
565
566 dp = (struct dirblk *) bp->b_data;
567 if (dp->d_magic != D_MAGIC) {
568 printf("hpfs_validatetimes: magic doesn't match\n");
569 error = EINVAL;
570 goto failed;
571 }
572
573 dep = D_DIRENT(dp);
574
575 if (olsn) {
576 dprintf(("[restore 0x%x] ", olsn));
577
578 while(!(dep->de_flag & DE_END) ) {
579 if((dep->de_flag & DE_DOWN) &&
580 (olsn == DE_DOWNLSN(dep)))
581 break;
582 dep = (hpfsdirent_t *)((caddr_t)dep + dep->de_reclen);
583 }
584
585 if((dep->de_flag & DE_DOWN) && (olsn == DE_DOWNLSN(dep))) {
586 if (dep->de_flag & DE_END)
587 goto blockdone;
588
589 if (hp->h_no == dep->de_fnode) {
590 dprintf(("[found] "));
591 goto readdone;
592 }
593
594 dep = (hpfsdirent_t *)((caddr_t)dep + dep->de_reclen);
595 } else {
596 printf("hpfs_validatetimes: ERROR! oLSN not found\n");
597 error = EINVAL;
598 goto failed;
599 }
600 }
601
602 olsn = 0;
603
604 while(!(dep->de_flag & DE_END)) {
605 if(dep->de_flag & DE_DOWN) {
606 lsn = DE_DOWNLSN(dep);
607 level++;
608 goto dive;
609 }
610
611 if (hp->h_no == dep->de_fnode) {
612 dprintf(("[found] "));
613 goto readdone;
614 }
615
616 dep = (hpfsdirent_t *)((caddr_t)dep + dep->de_reclen);
617 }
618
619 if(dep->de_flag & DE_DOWN) {
620 dprintf(("[enddive] "));
621 lsn = DE_DOWNLSN(dep);
622 level++;
623 goto dive;
624 }
625
626 blockdone:
627 dprintf(("[EOB] "));
628 olsn = lsn;
629 lsn = dp->d_parent;
630 level--;
631 dprintf(("[level %d] ", level));
632 if (level > 0)
633 goto dive; /* undive really */
634
635 goto failed;
636
637 readdone:
638 bcopy(dep->de_name,hp->h_name,dep->de_namelen);
639 hp->h_name[dep->de_namelen] = '\0';
640 hp->h_namelen = dep->de_namelen;
641 hp->h_ctime = dep->de_ctime;
642 hp->h_atime = dep->de_atime;
643 hp->h_mtime = dep->de_mtime;
644 hp->h_flag |= H_PARVALID;
645
646 dprintf(("[readdone]"));
647
648 failed:
649 dprintf(("\n"));
650 if (bp != NULL)
651 brelse(bp);
652 if (hp != dhp)
653 vput(dvp);
654
655 return (error);
656 }
657
658 struct timespec
659 hpfstimetounix (
660 u_long hptime)
661 {
662 struct timespec t;
663
664 t.tv_nsec = 0;
665 t.tv_sec = hptime;
666
667 return t;
668 }
669
670 /*
671 * Write down changes done to parent dir, these are only times for now.
672 * hpfsnode have to be locked.
673 */
674 int
675 hpfs_updateparent (
676 struct hpfsnode *hp)
677 {
678 struct hpfsnode *dhp;
679 struct vnode *dvp;
680 struct hpfsdirent *dep;
681 struct buf * bp;
682 int error;
683
684 dprintf(("hpfs_updateparent(0x%x): \n", hp->h_no));
685
686 if (!(hp->h_flag & H_PARCHANGE))
687 return (0);
688
689 if (!(hp->h_flag & H_PARVALID)) {
690 error = hpfs_validateparent (hp);
691 if (error)
692 return (error);
693 }
694
695 if (hp->h_no == hp->h_fn.fn_parent) {
696 dhp = hp;
697 } else {
698 error = VFS_VGET(hp->h_hpmp->hpm_mp, hp->h_fn.fn_parent,
699 LK_EXCLUSIVE, &dvp);
700 if (error)
701 return (error);
702 dhp = VTOHP(dvp);
703 }
704
705 error = hpfs_genlookupbyname (dhp, hp->h_name, hp->h_namelen,
706 &bp, &dep);
707 if (error) {
708 goto failed;
709 }
710
711 dep->de_atime = hp->h_atime;
712 dep->de_mtime = hp->h_mtime;
713 dep->de_size = hp->h_fn.fn_size;
714
715 bdwrite (bp);
716
717 hp->h_flag &= ~H_PARCHANGE;
718
719 error = 0;
720 failed:
721 if (hp != dhp)
722 vput(dvp);
723
724 return (0);
725 }
726
727 /*
728 * Write down on disk changes done to fnode. hpfsnode have to be locked.
729 */
730 int
731 hpfs_update (
732 struct hpfsnode *hp)
733 {
734 struct buf * bp;
735
736 dprintf(("hpfs_update(0x%x): \n", hp->h_no));
737
738 if (!(hp->h_flag & H_CHANGE))
739 return (0);
740
741 bp = getblk(hp->h_devvp, hp->h_no, FNODESIZE, 0, 0, 0);
742 clrbuf(bp);
743
744 bcopy (&hp->h_fn, bp->b_data, sizeof(struct fnode));
745 bdwrite (bp);
746
747 hp->h_flag &= ~H_CHANGE;
748
749 if (hp->h_flag & H_PARCHANGE)
750 return (hpfs_updateparent(hp));
751
752 return (0);
753 }
754
755 /*
756 * Truncate file to specifed size. hpfsnode have to be locked.
757 */
758 int
759 hpfs_truncate (
760 struct hpfsnode *hp,
761 u_long size)
762 {
763 struct hpfsmount *hpmp = hp->h_hpmp;
764 lsn_t newblen, oldblen;
765 int error, pf;
766
767 dprintf(("hpfs_truncate(0x%x, 0x%x -> 0x%lx): ",
768 hp->h_no, hp->h_fn.fn_size, size));
769
770 newblen = (size + DEV_BSIZE - 1) >> DEV_BSHIFT;
771 oldblen = (hp->h_fn.fn_size + DEV_BSIZE - 1) >> DEV_BSHIFT;
772
773 dprintf(("blen: 0x%x -> 0x%x\n", oldblen, newblen));
774
775 error = hpfs_truncatealblk (hpmp, &hp->h_fn.fn_ab, newblen, &pf);
776 if (error)
777 return (error);
778 if (pf) {
779 hp->h_fn.fn_ab.ab_flag = 0;
780 hp->h_fn.fn_ab.ab_freecnt = 0x8;
781 hp->h_fn.fn_ab.ab_busycnt = 0x0;
782 hp->h_fn.fn_ab.ab_freeoff = sizeof(alblk_t);
783 }
784
785 hp->h_fn.fn_size = size;
786
787 hp->h_flag |= (H_CHANGE | H_PARCHANGE);
788
789 dprintf(("hpfs_truncate: successful\n"));
790
791 return (0);
792 }
793
794 /*
795 * Enlarge file to specifed size. hpfsnode have to be locked.
796 */
797 int
798 hpfs_extend (
799 struct hpfsnode *hp,
800 u_long size)
801 {
802 struct hpfsmount *hpmp = hp->h_hpmp;
803 lsn_t newblen, oldblen;
804 int error;
805
806 dprintf(("hpfs_extend(0x%x, 0x%x -> 0x%lx): ",
807 hp->h_no, hp->h_fn.fn_size, size));
808
809 if (hpmp->hpm_bavail < 0x10)
810 return (ENOSPC);
811
812 newblen = (size + DEV_BSIZE - 1) >> DEV_BSHIFT;
813 oldblen = (hp->h_fn.fn_size + DEV_BSIZE - 1) >> DEV_BSHIFT;
814
815 dprintf(("blen: 0x%x -> 0x%x\n", oldblen, newblen));
816
817 error = hpfs_addextent(hpmp, hp, newblen - oldblen);
818 if (error) {
819 printf("hpfs_extend: FAILED TO ADD EXTENT %d\n", error);
820 return (error);
821 }
822
823 hp->h_fn.fn_size = size;
824
825 hp->h_flag |= (H_CHANGE | H_PARCHANGE);
826
827 dprintf(("hpfs_extend: successful\n"));
828
829 return (0);
830 }
831
832 /*
833 * Read AlSec structure, and check if magic is valid.
834 * You don't need to brelse buf on error.
835 */
836 int
837 hpfs_breadstruct (
838 struct hpfsmount *hpmp,
839 lsn_t lsn,
840 u_int len,
841 u_int32_t magic,
842 struct buf **bpp)
843 {
844 struct buf *bp;
845 u_int32_t *mp;
846 int error;
847
848 dprintf(("hpfs_breadstruct: reading at 0x%x\n", lsn));
849
850 *bpp = NULL;
851
852 error = bread(hpmp->hpm_devvp, lsn, len, NOCRED, &bp);
853 if (error) {
854 brelse(bp);
855 return (error);
856 }
857 mp = (u_int32_t *) bp->b_data;
858 if (*mp != magic) {
859 brelse(bp);
860 printf("hpfs_breadstruct: MAGIC DOESN'T MATCH (0x%08x != 0x%08x)\n",
861 *mp, magic);
862 return (EINVAL);
863 }
864
865 *bpp = bp;
866
867 return (0);
868 }
869
Cache object: 8fb410889159603f7f5f7153e2ee951d
|