3055a5a4c494dde4e27dbc510c1ed36dd1932e30
[yaboot.git] / second / partition.c
1 /* File related stuff
2    
3    Copyright (C) 1999 Benjamin Herrenschmidt
4
5    Todo: Add disklabel (or let OF do it ?). Eventually think about
6          fixing CDROM handling by directly using the ATAPI layer.
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
21
22 #include "ctype.h"
23 #include "types.h"
24 #include "stddef.h"
25 #include "stdlib.h"
26 #include "mac-part.h"
27 #include "fdisk-part.h"
28 #include "partition.h"
29 #include "prom.h"
30 #include "string.h"
31 #include "linux/iso_fs.h"
32 #include "debug.h"
33 #include "errors.h"
34
35 /* We currently don't check the partition type, some users
36  * are putting crap there and still expect it to work...
37  */
38 #undef CHECK_FOR_VALID_MAC_PARTITION_TYPE
39
40 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
41 static const char *valid_mac_partition_types[] = {
42      "apple_unix_svr2",
43      "linux",
44      "apple_hfs",
45      "apple_boot",
46      "apple_bootstrap",
47      NULL
48 };
49 #endif
50     
51
52 /* Local functions */
53 static unsigned long swab32(unsigned long value);
54
55 #define MAX_BLOCK_SIZE  2048
56 static unsigned char block_buffer[MAX_BLOCK_SIZE];
57
58 static void
59 add_new_partition(struct partition_t**  list, int part_number, const char *part_type,
60                   const char *part_name, unsigned long part_start, unsigned long part_size,
61                   unsigned short part_blocksize)
62 {
63      struct partition_t*        part;
64      part = (struct partition_t*)malloc(sizeof(struct partition_t));
65         
66      part->part_number = part_number;
67      strncpy(part->part_type, part_type, MAX_PART_NAME);
68      strncpy(part->part_name, part_name, MAX_PART_NAME);
69      part->part_start = part_start;
70      part->part_size = part_size;
71      part->blocksize = part_blocksize;
72
73      /* Tack this entry onto the list */
74      part->next = *list;
75      *list = part;
76 }
77
78 /* Note, we rely on partitions being dev-block-size aligned,
79  * I have to check if it's true. If it's not, then things will get
80  * a bit more complicated
81  */
82 static void
83 partition_mac_lookup( const char *dev_name, prom_handle disk,
84                       unsigned int prom_blksize, struct partition_t** list )
85 {
86      int block, map_size;
87
88      /* block_buffer contains block 0 from the partitions_lookup() stage */
89      struct mac_partition* part = (struct mac_partition *)block_buffer;
90      unsigned short ptable_block_size =
91           ((struct mac_driver_desc *)block_buffer)->block_size;
92         
93      map_size = 1;
94      for (block=1; block < map_size + 1; block++)
95      {
96 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
97           int valid = 0;
98           const char *ptype;
99 #endif
100           if (prom_readblocks(disk, block, 1, block_buffer) != 1) {
101                prom_printf("Can't read partition %d\n", block);
102                break;
103           }
104           if (part->signature != MAC_PARTITION_MAGIC) {
105 #if 0
106                prom_printf("Wrong partition %d signature\n", block);
107 #endif
108                break;
109           }
110           if (block == 1)
111                map_size = part->map_count;
112                 
113 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
114           /* We don't bother looking at swap partitions of any type, 
115            * and the rest are the ones we know about */
116           for (ptype = valid_mac_partition_types; ptype; ptype++)
117                if (!strcmp (part->type, ptype))
118                {
119                     valid = 1;
120                     break;
121                }
122 #if DEBUG
123           if (!valid)
124                prom_printf( "MAC: Unsupported partition #%d; type=%s\n",
125                             block, part->type );
126 #endif
127 #endif
128
129
130 #ifdef CHECK_FOR_VALID_MAC_PARTITION_TYPE
131           if (valid)
132 #endif
133                /* We use the partition block size from the partition table.
134                 * The filesystem implmentations are responsible for mapping
135                 * to their own fs blocksize */
136                add_new_partition(
137                     list, /* partition list */
138                     block, /* partition number */
139                     part->type, /* type */
140                     part->name, /* name */
141                     part->start_block + part->data_start, /* start */
142                     part->data_count, /* size */
143                     ptable_block_size );
144      }
145 }
146
147 /* 
148  * Same function as partition_mac_lookup(), except for fdisk
149  * partitioned disks.
150  */
151 static void
152 partition_fdisk_lookup( const char *dev_name, prom_handle disk,
153                         unsigned int prom_blksize, struct partition_t** list )
154 {
155      int partition;
156
157      /* fdisk partition tables start at offset 0x1be
158       * from byte 0 of the boot drive.
159       */
160      struct fdisk_partition* part = 
161           (struct fdisk_partition *) (block_buffer + 0x1be);
162
163      for (partition=1; partition <= 4 ;partition++, part++) {
164           if (part->sys_ind == LINUX_NATIVE) {
165                add_new_partition(  list,
166                                    partition,
167                                    "Linux", /* type */
168                                    '\0', /* name */
169                                    swab32(*(unsigned int *)(part->start4)),
170                                    swab32(*(unsigned int *)(part->size4)),
171                                    512 /*blksize*/ );
172           }
173      }
174 }
175
176 /* I don't know if it's possible to handle multisession and other multitrack
177  * stuffs with the current OF disklabel package. This can still be implemented
178  * with direct calls to atapi stuffs.
179  * Currently, we enter this code for any device of block size 0x2048 who lacks
180  * a MacOS partition map signature.
181  */
182 static int
183 identify_iso_fs(ihandle device, unsigned int *iso_root_block)
184 {
185      int block;
186
187      for (block = 16; block < 100; block++) {
188           struct iso_volume_descriptor  * vdp;
189
190           if (prom_readblocks(device, block, 1, block_buffer) != 1) {
191                prom_printf("Can't read volume desc block %d\n", block);
192                break;
193           }
194                 
195           vdp = (struct iso_volume_descriptor *)block_buffer;
196             
197           /* Due to the overlapping physical location of the descriptors, 
198            * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure 
199            * proper identification in this case, we first check for ISO.
200            */
201           if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
202                *iso_root_block = block;
203                return 1;
204           }
205      }
206         
207      return 0;
208 }
209
210 struct partition_t*
211 partitions_lookup(const char *device)
212 {
213      ihandle    disk;
214      struct mac_driver_desc *desc = (struct mac_driver_desc *)block_buffer;
215      struct partition_t* list = NULL;
216      unsigned int prom_blksize, iso_root_block;
217         
218      strncpy(block_buffer, device, 2040);
219      strcat(block_buffer, ":0");
220         
221      /* Open device */
222      disk = prom_open(block_buffer);
223      if (disk == NULL) {
224           prom_printf("Can't open device <%s>\n", block_buffer);
225           goto bail;
226      }
227      prom_blksize = prom_getblksize(disk);
228      DEBUG_F("block size of device is %d\n", prom_blksize);
229
230      if (prom_blksize <= 1)
231           prom_blksize = 512;
232      if (prom_blksize > MAX_BLOCK_SIZE) {
233           prom_printf("block_size %d not supported !\n", prom_blksize);
234           goto bail;
235      }
236         
237      /* Read boot blocs */
238      if (prom_readblocks(disk, 0, 1, block_buffer) != 1) {
239           prom_printf("Can't read boot blocks\n");
240           goto bail;
241      }  
242      if (desc->signature == MAC_DRIVER_MAGIC) {
243           /* pdisk partition format */
244           partition_mac_lookup(device, disk, prom_blksize, &list);
245      } else if ((block_buffer[510] == 0x55) && (block_buffer[511] == 0xaa)) {
246           /* fdisk partition format */
247           partition_fdisk_lookup(device, disk, prom_blksize, &list);
248      } else if (prom_blksize == 2048 && identify_iso_fs(disk, &iso_root_block)) {
249           add_new_partition(&list,
250                             0,
251                             '\0',
252                             '\0',
253                             iso_root_block,
254                             0,
255                             prom_blksize);
256           prom_printf("ISO9660 disk\n");
257      } else {
258           prom_printf("No supported partition table detected\n");
259           goto bail;
260      }
261
262 bail:
263      prom_close(disk);
264         
265      return list;
266 }
267
268 char *
269 get_part_type(char *device, int partition)
270 {
271      struct partition_t*        parts;
272      struct partition_t*        p;
273      struct partition_t*        found;
274      char *type = NULL;
275
276      if (prom_get_devtype(device) != FILE_DEVICE_BLOCK)
277           return NULL;
278
279      parts = partitions_lookup(device);
280      found = NULL;
281
282      if (!parts)
283           return '\0';
284
285      for (p = parts; p && !found; p=p->next) {
286           DEBUG_F("number: %02d, start: 0x%08lx, length: 0x%08lx, type: %s, name: %s\n",
287                   p->part_number, p->part_start, p->part_size, p->part_type, p->part_name);
288           if ((partition >= 0) && (partition == p->part_number)) {
289                type = strdup(p->part_type);
290                break;
291           }       
292      }
293      if (parts)
294           partitions_free(parts);
295      return type;
296 }
297
298 /* Freed in reverse order of allocation to help malloc'ator */
299 void
300 partitions_free(struct partition_t* list)
301 {
302      struct partition_t*        next;
303         
304      while(list) {
305           next = list->next;
306           free(list);
307           list = next;
308      }
309 }
310 unsigned long
311 swab32(unsigned long value)
312 {
313      __u32 result;
314
315      __asm__("rlwimi %0,%1,24,16,23\n\t"
316              "rlwimi %0,%1,8,8,15\n\t"
317              "rlwimi %0,%1,24,0,7"
318              : "=r" (result)
319              : "r" (value), "0" (value >> 24));
320      return result;
321 }
322
323
324 /* 
325  * Local variables:
326  * c-file-style: "k&r"
327  * c-basic-offset: 5
328  * End:
329  */