/*      $NetBSD: write.c,v 1.6 2009/03/14 21:04:06 dsl Exp $    */

/*
* Copyright (c) 1999 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Julian Coleman, Waldi Ravens and Leo Weppelman.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include "privahdi.h"
#include <fcntl.h>
#ifdef DEBUG
#include <stdio.h>
#endif
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <sys/dkio.h>
#include <sys/ioctl.h>

#define BSL_MAGIC       0xa5
#define BSL_OFFSET      1
#define BSL_SIZE        1

/*
* Write AHDI partitions to disk
*/

int
ahdi_writelabel (struct ahdi_ptable *ptable, char *diskname, int flags)
{
       int                      fd, i, j, k, firstxgm, keep, cksum_ok;
       struct ahdi_root        *root;
       u_int                    rsec;
       u_int32_t                xgmsec, nbdsec;

       if (!(fd = openraw (diskname, O_RDWR)))
               return (-1);

       if ((i = ahdi_checklabel (ptable)) < 0) {
               close (fd);
               return (i);
       }

       if (flags & AHDI_KEEP_BOOT) {
               if ((root = disk_read (fd, AHDI_BBLOCK, 1)) == NULL) {
                       return (-1);
               }
               cksum_ok = ahdi_cksum (root) == root->ar_checksum;
#ifdef DEBUG
               printf ("Previous root sector checksum was ");
               cksum_ok ? printf (" correct\n") : printf (" incorrect\n");
#endif
               bzero ((void *) root->ar_parts,
                   sizeof (struct ahdi_part) * AHDI_MAXRPD);
       } else {
               if ((root = malloc (sizeof (struct ahdi_root))) == NULL) {
                       close (fd);
                       return (-1);
               }
               bzero ((void *) root, sizeof (struct ahdi_root));
               cksum_ok = 0;
#ifdef DEBUG
               printf ("Clearing root sector - forcing incorrect checksum\n");
#endif
       }

       nbdsec = 0;
#ifdef DEBUG
       printf ("Writing root sector\n");
#endif

       /* All partitions in root sector (including first XGM) */
       j = 0;
       firstxgm = 0;
       xgmsec = 0;
       for (i = 0; i < ptable->nparts; i++) {
               if (ptable->parts[i].root == 0) {
#ifdef DEBUG
                       printf ("  Partition %d - ", j);
#endif
                       root->ar_parts[j].ap_flg = 0x01;
                       for (k = 0; k < 3; k++) {
                               root->ar_parts[j].ap_id[k] =
                                   ptable->parts[i].id[k];
#ifdef DEBUG
                               printf ("%c", root->ar_parts[j].ap_id[k]);
#endif
                       }
                       root->ar_parts[j].ap_st = ptable->parts[i].start;
                       root->ar_parts[j].ap_size = ptable->parts[i].size;
#ifdef DEBUG
                       printf ("/%u/%u\n", root->ar_parts[j].ap_st,
                           root->ar_parts[j].ap_size);
#endif

                       j++;
               } else if (!firstxgm) {
                       root->ar_parts[j].ap_flg = 0x01;
                       root->ar_parts[j].ap_id[0] = 'X';
                       root->ar_parts[j].ap_id[1] = 'G';
                       root->ar_parts[j].ap_id[2] = 'M';
                       root->ar_parts[j].ap_st = ptable->parts[i].root;
                       root->ar_parts[j].ap_size = ptable->parts[i].size + 1;
                       firstxgm = i;
                       xgmsec = ptable->parts[i].root;
#ifdef DEBUG
                       printf ("  Partition %d - XGM/%u/%u\n", j,
                           root->ar_parts[j].ap_st,
                           root->ar_parts[j].ap_size);
#endif
                       j++;
               }
               /*
                * Note first netbsd partition for invalidate_netbsd_label().
                */
               if (!nbdsec && AHDI_MKPID (ptable->parts[i].id[0],
                   ptable->parts[i].id[1], ptable->parts[i].id[2])
                   == AHDI_PID_NBD) {
                       nbdsec = ptable->parts[i].start;
               }
       }

       root->ar_hdsize = ptable->secperunit;
       if (!(flags & AHDI_KEEP_BSL)) {
               root->ar_bslst = (u_int32_t) BSL_OFFSET;
               root->ar_bslsize = (u_int32_t) BSL_SIZE;
       }

       /* Write correct checksum? */
       root->ar_checksum = ahdi_cksum (root);
       if (!cksum_ok) {
               root->ar_checksum ^= 0x5555;
#ifdef DEBUG
               printf ("Setting incorrect checksum\n");
       } else {
               printf ("Setting correct checksum\n");
#endif
       }

       if (!disk_write (fd, AHDI_BBLOCK, 1, root)) {
               free (root);
               close (fd);
               return (-1);
       }

       /* Auxiliary roots */
       for (i = firstxgm; i < ptable->nparts; i++) {
               j = 0;
               if (ptable->parts[i].root == 0)
                       continue;
#ifdef DEBUG
       printf ("Writing auxiliary root at sector %u\n",
           ptable->parts[i].root);
#endif
               bzero ((void *) root, sizeof (struct ahdi_root));
               rsec = ptable->parts[i].root;
#ifdef DEBUG
                       printf ("  Partition %d - ", j);
#endif
               root->ar_parts[j].ap_flg = 0x01;
               for (k = 0; k < 3; k++) {
                       root->ar_parts[j].ap_id[k] =
                           ptable->parts[i].id[k];
#ifdef DEBUG
                       printf ("%c", root->ar_parts[j].ap_id[k]);
#endif
               }
               root->ar_parts[j].ap_st = ptable->parts[i].start -
                   rsec;
               root->ar_parts[j].ap_size = ptable->parts[i].size;
#ifdef DEBUG
               printf ("/%u/%u\n", root->ar_parts[j].ap_st,
                   root->ar_parts[j].ap_size);
#endif
               j++;
               if (i < ptable->nparts - 1) {
                       /* Need an XGM? */
                       if (ptable->parts[i].root != ptable->parts[i+1].root &&
                           ptable->parts[i+1].root != 0) {
                               root->ar_parts[j].ap_flg = 0x01;
                               root->ar_parts[j].ap_id[0] = 'X';
                               root->ar_parts[j].ap_id[1] = 'G';
                               root->ar_parts[j].ap_id[2] = 'M';
                               root->ar_parts[j].ap_st =
                                       ptable->parts[i+1].root - xgmsec;
                               root->ar_parts[j].ap_size =
                                       ptable->parts[i+1].size + 1;
#ifdef DEBUG
                               printf ("  Partition %d - XGM/%u/%u\n", j,
                                   root->ar_parts[j].ap_st,
                                   root->ar_parts[j].ap_size);
#endif
                       }
                       if (ptable->parts[i].root == ptable->parts[i+1].root) {
                               /* Next partition has same auxiliary root */
#ifdef DEBUG
                               printf ("  Partition %d - ", j);
#endif
                               root->ar_parts[j].ap_flg = 0x01;
                               for (k = 0; k < 3; k++) {
                                       root->ar_parts[j].ap_id[k] =
                                       ptable->parts[i+1].id[k];
#ifdef DEBUG
                               printf ("%c", root->ar_parts[j].ap_id[k]);
#endif
                               }
                               root->ar_parts[j].ap_st =
                                   ptable->parts[i+1].start - rsec;
                               root->ar_parts[j].ap_size =
                                   ptable->parts[i+1].size;
#ifdef DEBUG
                               printf ("/%u/%u\n", root->ar_parts[j].ap_st,
                                   root->ar_parts[j].ap_size);
#endif
                               i++;
                       }
                       j++;
               }

               if (!disk_write (fd, rsec, 1, root)) {
                       close (fd);
                       free (root);
                       return (-1);
               }

               /*
                * Note first netbsd partition for invalidate_netbsd_label().
                */
               if (!nbdsec && AHDI_MKPID (ptable->parts[i].id[0],
                   ptable->parts[i].id[1], ptable->parts[i].id[2])
                   == AHDI_PID_NBD) {
                       nbdsec = ptable->parts[i].start;
               }
       }

       free (root);

       if (!(flags & AHDI_KEEP_BSL) && !write_bsl (fd)) {
               close (fd);
               return (-1);
       }

       if (!(flags & AHDI_KEEP_NBDA) && !invalidate_netbsd_label(fd, nbdsec)) {
               close (fd);
               return (-1);
       }

#ifdef DEBUG
       printf ("Forcing disk label re-read\n");
#endif
       keep = 0;
       if (ioctl (fd, DIOCKLABEL, &keep) < 0) {
               close (fd);
               return (-1);
       }

       close (fd);
       return (1);
}

/*
* Write a bad sector list (empty).
*/
int
write_bsl (int fd)
{
       u_int8_t        *bsl;

       if ((bsl = malloc (sizeof (u_int8_t) * BSL_SIZE * DEV_BSIZE)) == NULL)
               return (0);
       bzero ((void *) bsl, sizeof (u_int8_t) * DEV_BSIZE);

#ifdef DEBUG
       printf ("Writing bad sector list\n");
#endif
       bsl[3] = BSL_MAGIC;
       if (!disk_write (fd, (u_int) BSL_OFFSET, (u_int) BSL_SIZE, bsl)) {
               free (bsl);
               return (0);
       }
       free (bsl);
       return (1);
}

/*
* Invalidate any previous AHDI/NBDA disklabel.
* Otherwise this make take precedence when we next open the disk.
*/
int
invalidate_netbsd_label (int fd, u_int32_t nbdsec)
{
       struct bootblock        *bb;
       u_int                    nsec;

       nsec = (BBMINSIZE + (DEV_BSIZE - 1)) / DEV_BSIZE;

       if ((bb = disk_read (fd, nbdsec, nsec)) == NULL) {
               return (0);
       }

       if (bb->bb_magic == NBDAMAGIC || bb->bb_magic == AHDIMAGIC) {
               bb->bb_magic = bb->bb_magic & 0xffffff00;
               bb->bb_magic = bb->bb_magic | 0x5f;

#ifdef DEBUG
               printf ("Invalidating old NBDA/AHDI label (sector %u)\n",
                   nbdsec);
#endif
               if (!disk_write (fd, nbdsec, nsec, bb)) {
                       free (bb);
                       return (0);
               }
       }

       free (bb);
       return (1);
}

int
disk_write (fd, start, count, buf)
       int      fd;
       u_int    start,
                count;
       void    *buf;
{
       off_t    offset;
       size_t   size;

       size   = count * DEV_BSIZE;
       offset = start * DEV_BSIZE;

       if (lseek (fd, offset, SEEK_SET) != offset)
               return (0);
       if (write (fd, buf, size) != size)
               return (0);
       return (1);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.