1/* libs/diskconfig/diskconfig.c
2 *
3 * Copyright 2008, The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18#define LOG_TAG "config_mbr"
19#include <stdint.h>
20#include <stdlib.h>
21#include <string.h>
22#include <stdio.h>
23
24#include <cutils/log.h>
25
26#include <diskconfig/diskconfig.h>
27
28
29/* start and len are in LBA units */
30static void
31cfg_pentry(struct pc_partition *pentry, uint8_t status, uint8_t type,
32           uint32_t start, uint32_t len)
33{
34    if (len > 0) {
35        /* seems that somes BIOSens can get wedged on boot while verifying
36         * the mbr if these are 0 */
37        memset(&pentry->start, 0xff, sizeof(struct chs));
38        memset(&pentry->end, 0xff, sizeof(struct chs));
39    } else {
40        /* zero out the c/h/s entries.. they are not used */
41        memset(&pentry->start, 0, sizeof(struct chs));
42        memset(&pentry->end, 0, sizeof(struct chs));
43    }
44
45    pentry->status = status;
46    pentry->type = type;
47    pentry->start_lba = start;
48    pentry->len_lba = len;
49
50    ALOGI("Configuring pentry. status=0x%x type=0x%x start_lba=%u len_lba=%u",
51         pentry->status, pentry->type, pentry->start_lba, pentry->len_lba);
52}
53
54
55static inline uint32_t
56kb_to_lba(uint32_t len_kb, uint32_t sect_size)
57{
58    uint64_t lba;
59
60    lba = (uint64_t)len_kb * 1024;
61    /* bump it up to the next LBA boundary just in case  */
62    lba = (lba + (uint64_t)sect_size - 1) & ~((uint64_t)sect_size - 1);
63    lba /= (uint64_t)sect_size;
64    if (lba >= 0xffffffffULL)
65        ALOGE("Error converting kb -> lba. 32bit overflow, expect weirdness");
66    return (uint32_t)(lba & 0xffffffffULL);
67}
68
69
70static struct write_list *
71mk_pri_pentry(struct disk_info *dinfo, struct part_info *pinfo, int pnum,
72              uint32_t *lba)
73{
74    struct write_list *item;
75    struct pc_partition *pentry;
76
77    if (pnum >= PC_NUM_BOOT_RECORD_PARTS) {
78        ALOGE("Maximum number of primary partition exceeded.");
79        return NULL;
80    }
81
82    if (!(item = alloc_wl(sizeof(struct pc_partition)))) {
83        ALOGE("Unable to allocate memory for partition entry.");
84        return NULL;
85    }
86
87    {
88        /* DO NOT DEREFERENCE */
89        struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET;
90        /* grab the offset in mbr where to write this partition entry. */
91        item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->ptable[pnum])));
92    }
93
94    pentry = (struct pc_partition *) &item->data;
95
96    /* need a standard primary partition entry */
97    if (pinfo) {
98        /* need this to be 64 bit in case len_kb is large */
99        uint64_t len_lba;
100
101        if (pinfo->len_kb != (uint32_t)-1) {
102            /* bump it up to the next LBA boundary just in case */
103            len_lba = ((uint64_t)pinfo->len_kb * 1024);
104            len_lba += ((uint64_t)dinfo->sect_size - 1);
105            len_lba &= ~((uint64_t)dinfo->sect_size - 1);
106            len_lba /= (uint64_t)dinfo->sect_size;
107        } else {
108            /* make it fill the rest of disk */
109            len_lba = dinfo->num_lba - *lba;
110        }
111
112        cfg_pentry(pentry, ((pinfo->flags & PART_ACTIVE_FLAG) ?
113                            PC_PART_ACTIVE : PC_PART_NORMAL),
114                   pinfo->type, *lba, (uint32_t)len_lba);
115
116        pinfo->start_lba = *lba;
117        *lba += (uint32_t)len_lba;
118    } else {
119        /* this should be made an extended partition, and should take
120         * up the rest of the disk as a primary partition */
121        cfg_pentry(pentry, PC_PART_NORMAL, PC_PART_TYPE_EXTENDED,
122                   *lba, dinfo->num_lba - *lba);
123
124        /* note that we do not update the *lba because we now have to
125         * create a chain of extended partition tables, and first one is at
126         * *lba */
127    }
128
129    return item;
130}
131
132
133/* This function configures an extended boot record at the beginning of an
134 * extended partition. This creates a logical partition and a pointer to
135 * the next EBR.
136 *
137 * ext_lba == The start of the toplevel extended partition (pointed to by the
138 * entry in the MBR).
139 */
140static struct write_list *
141mk_ext_pentry(struct disk_info *dinfo, struct part_info *pinfo, uint32_t *lba,
142              uint32_t ext_lba, struct part_info *pnext)
143{
144    struct write_list *item;
145    struct pc_boot_record *ebr;
146    uint32_t len; /* in lba units */
147
148    if (!(item = alloc_wl(sizeof(struct pc_boot_record)))) {
149        ALOGE("Unable to allocate memory for EBR.");
150        return NULL;
151    }
152
153    /* we are going to write the ebr at the current LBA, and then bump the
154     * lba counter since that is where the logical data partition will start */
155    item->offset = ((loff_t)(*lba)) * dinfo->sect_size;
156    (*lba)++;
157
158    ebr = (struct pc_boot_record *) &item->data;
159    memset(ebr, 0, sizeof(struct pc_boot_record));
160    ebr->mbr_sig = PC_BIOS_BOOT_SIG;
161
162    if (pinfo->len_kb != (uint32_t)-1)
163        len = kb_to_lba(pinfo->len_kb, dinfo->sect_size);
164    else {
165        if (pnext) {
166            ALOGE("Only the last partition can be specified to fill the disk "
167                 "(name = '%s')", pinfo->name);
168            goto fail;
169        }
170        len = dinfo->num_lba - *lba;
171        /* update the pinfo structure to reflect the new size, for
172         * bookkeeping */
173        pinfo->len_kb =
174            (uint32_t)(((uint64_t)len * (uint64_t)dinfo->sect_size) /
175                       ((uint64_t)1024));
176    }
177
178    cfg_pentry(&ebr->ptable[PC_EBR_LOGICAL_PART], PC_PART_NORMAL,
179               pinfo->type, 1, len);
180
181    pinfo->start_lba = *lba;
182    *lba += len;
183
184    /* If this is not the last partition, we have to create a link to the
185     * next extended partition.
186     *
187     * Otherwise, there's nothing to do since the "pointer entry" is
188     * already zero-filled.
189     */
190    if (pnext) {
191        /* The start lba for next partition is an offset from the beginning
192         * of the top-level extended partition */
193        uint32_t next_start_lba = *lba - ext_lba;
194        uint32_t next_len_lba;
195        if (pnext->len_kb != (uint32_t)-1)
196            next_len_lba = 1 + kb_to_lba(pnext->len_kb, dinfo->sect_size);
197        else
198            next_len_lba = dinfo->num_lba - *lba;
199        cfg_pentry(&ebr->ptable[PC_EBR_NEXT_PTR_PART], PC_PART_NORMAL,
200                   PC_PART_TYPE_EXTENDED, next_start_lba, next_len_lba);
201    }
202
203    return item;
204
205fail:
206    free_wl(item);
207    return NULL;
208}
209
210
211static struct write_list *
212mk_mbr_sig()
213{
214    struct write_list *item;
215    if (!(item = alloc_wl(sizeof(uint16_t)))) {
216        ALOGE("Unable to allocate memory for MBR signature.");
217        return NULL;
218    }
219
220    {
221        /* DO NOT DEREFERENCE */
222        struct pc_boot_record *mbr = (void *)PC_MBR_DISK_OFFSET;
223        /* grab the offset in mbr where to write mbr signature. */
224        item->offset = (loff_t)((uintptr_t)((uint8_t *)(&mbr->mbr_sig)));
225    }
226
227    *((uint16_t*)item->data) = PC_BIOS_BOOT_SIG;
228    return item;
229}
230
231struct write_list *
232config_mbr(struct disk_info *dinfo)
233{
234    struct part_info *pinfo;
235    uint32_t cur_lba = dinfo->skip_lba;
236    uint32_t ext_lba = 0;
237    struct write_list *wr_list = NULL;
238    struct write_list *temp_wr = NULL;
239    int cnt = 0;
240    int extended = 0;
241
242    if (!dinfo->part_lst)
243        return NULL;
244
245    for (cnt = 0; cnt < dinfo->num_parts; ++cnt) {
246        pinfo = &dinfo->part_lst[cnt];
247
248        /* Should we create an extedned partition? */
249        if (cnt == (PC_NUM_BOOT_RECORD_PARTS - 1)) {
250            if (cnt + 1 < dinfo->num_parts) {
251                extended = 1;
252                ext_lba = cur_lba;
253                if ((temp_wr = mk_pri_pentry(dinfo, NULL, cnt, &cur_lba)))
254                    wlist_add(&wr_list, temp_wr);
255                else {
256                    ALOGE("Cannot create primary extended partition.");
257                    goto fail;
258                }
259            }
260        }
261
262        /* if extended, need 1 lba for ebr */
263        if ((cur_lba + extended) >= dinfo->num_lba)
264            goto nospace;
265        else if (pinfo->len_kb != (uint32_t)-1) {
266            uint32_t sz_lba = (pinfo->len_kb / dinfo->sect_size) * 1024;
267            if ((cur_lba + sz_lba + extended) > dinfo->num_lba)
268                goto nospace;
269        }
270
271        if (!extended)
272            temp_wr = mk_pri_pentry(dinfo, pinfo, cnt, &cur_lba);
273        else {
274            struct part_info *pnext;
275            pnext = cnt + 1 < dinfo->num_parts ? &dinfo->part_lst[cnt+1] : NULL;
276            temp_wr = mk_ext_pentry(dinfo, pinfo, &cur_lba, ext_lba, pnext);
277        }
278
279        if (temp_wr)
280            wlist_add(&wr_list, temp_wr);
281        else {
282            ALOGE("Cannot create partition %d (%s).", cnt, pinfo->name);
283            goto fail;
284        }
285    }
286
287    /* fill in the rest of the MBR with empty parts (if needed). */
288    for (; cnt < PC_NUM_BOOT_RECORD_PARTS; ++cnt) {
289        struct part_info blank;
290        cur_lba = 0;
291        memset(&blank, 0, sizeof(struct part_info));
292        if (!(temp_wr = mk_pri_pentry(dinfo, &blank, cnt, &cur_lba))) {
293            ALOGE("Cannot create blank partition %d.", cnt);
294            goto fail;
295        }
296        wlist_add(&wr_list, temp_wr);
297    }
298
299    if ((temp_wr = mk_mbr_sig()))
300        wlist_add(&wr_list, temp_wr);
301    else {
302        ALOGE("Cannot set MBR signature");
303        goto fail;
304    }
305
306    return wr_list;
307
308nospace:
309    ALOGE("Not enough space to add parttion '%s'.", pinfo->name);
310
311fail:
312    wlist_free(wr_list);
313    return NULL;
314}
315
316
317/* Returns the device path of the partition referred to by 'name'
318 * Must be freed by the caller.
319 */
320char *
321find_mbr_part(struct disk_info *dinfo, const char *name)
322{
323    struct part_info *plist = dinfo->part_lst;
324    int num = 0;
325    char *dev_name = NULL;
326    int has_extended = (dinfo->num_parts > PC_NUM_BOOT_RECORD_PARTS);
327
328    for(num = 1; num <= dinfo->num_parts; ++num) {
329        if (!strcmp(plist[num-1].name, name))
330            break;
331    }
332
333    if (num > dinfo->num_parts)
334        return NULL;
335
336    if (has_extended && (num >= PC_NUM_BOOT_RECORD_PARTS))
337        num++;
338
339    if (!(dev_name = malloc(MAX_NAME_LEN))) {
340        ALOGE("Cannot allocate memory.");
341        return NULL;
342    }
343
344    num = snprintf(dev_name, MAX_NAME_LEN, "%s%d", dinfo->device, num);
345    if (num >= MAX_NAME_LEN) {
346        ALOGE("Device name is too long?!");
347        free(dev_name);
348        return NULL;
349    }
350
351    return dev_name;
352}
353