/* * partitions - partition tables parsing * * Copyright (C) 2008-2009 Karel Zak * * This file may be redistributed under the terms of the * GNU Lesser General Public License. * */ #include #include #include #include #include #include #include #include #include #include #include #include "partitions.h" /** * SECTION:partitions * @title: Partitions probing * @short_description: partitions tables detection and parsing * * This chain supports binary and NAME=value interfaces, but complete PT * description is provided by binary interface only. * * NAME=value interface, supported tags: * * @PTTYPE: partition table type (dos, gpt, etc.). * * Example: * * * * blkid_probe pr; * const char *ptname; * * pr = blkid_new_probe_from_filename(devname); * if (!pr) * err("%s: faild to open device", devname); * * blkid_probe_enable_partitions(pr, TRUE); * blkid_do_fullprobe(pr); * * blkid_probe_lookup_value(pr, "PTTYPE", &ptname, NULL); * printf("%s partition type detected\n", pttype); * * blkid_free_probe(pr); * * // don't forget to check return codes in your code! * * * * Binary interface: * * * * blkid_probe pr; * blkid_partlist ls; * int nparts, i; * * pr = blkid_new_probe_from_filename(devname); * if (!pr) * err("%s: faild to open device", devname); * * ls = blkid_probe_get_partitions(pr); * nparts = blkid_partlist_numof_partitions(ls); * * for (i = 0; i < nparts; i++) { * blkid_partition par = blkid_partlist_get_partition(ls, i); * printf("#%d: %llu %llu 0x%x", * blkid_partition_get_partno(par), * blkid_partition_get_start(par), * blkid_partition_get_size(par), * blkid_partition_get_type(par)); * } * * blkid_free_probe(pr); * * // don't forget to check return codes in your code! * * */ /* * Chain driver function */ static int partitions_probe(blkid_probe pr, struct blkid_chain *chn); static void partitions_free_data(blkid_probe pr, void *data); /* * Partitions chain probing functions */ static const struct blkid_idinfo *idinfos[] = { &aix_pt_idinfo, &sgi_pt_idinfo, &sun_pt_idinfo, &dos_pt_idinfo, &gpt_pt_idinfo, &mac_pt_idinfo, &bsd_pt_idinfo, &unixware_pt_idinfo, &solaris_x86_pt_idinfo, &minix_pt_idinfo }; /* * Driver definition */ const struct blkid_chaindrv partitions_drv = { .id = BLKID_CHAIN_PARTS, .name = "partitions", .dflt_enabled = FALSE, .idinfos = idinfos, .nidinfos = ARRAY_SIZE(idinfos), .has_fltr = TRUE, .probe = partitions_probe, .safeprobe = partitions_probe, .free_data = partitions_free_data }; /* * For compatibility with the rest of libblkid API (with the old high-level * API) we use completely opaque typedefs for all structs. Don't forget that * the final blkid_* types are pointers! See blkid.h. * * [Just for the record, I hate typedef for pointers --kzak] */ /* exported as opaque type "blkid_parttable" */ struct blkid_struct_parttable { const char *type; /* partition table type */ blkid_loff_t offset; /* begin of the partition table */ int nparts; /* number of partitions */ blkid_partition parent; /* parent of nested partition table */ struct list_head t_tabs; /* all tables */ }; /* exported as opaque type "blkid_partition" */ struct blkid_struct_partition { blkid_loff_t start; /* begin of the partition */ blkid_loff_t size; /* size of the partitions */ int type; /* partition type */ char typestr[37]; /* partition type string (GPT and Mac) */ int partno; /* partition number */ char uuid[37]; /* UUID (when supported by PT), e.g GPT */ unsigned char name[128]; /* Partition in UTF8 name (when supporte by PT), e.g. Mac */ blkid_parttable tab; /* partition table */ }; /* exported as opaque type "blkid_partlist" */ struct blkid_struct_partlist { int next_partno; /* next partition number */ blkid_partition next_parent; /* next parent if parsing nested PT */ int nparts; /* number of partitions */ int nparts_max; /* max.number of partitions */ blkid_partition parts; /* array of partitions */ struct list_head l_tabs; /* list of partition tables */ }; /** * blkid_probe_enable_partitions: * @pr: probe * @enable: TRUE/FALSE * * Enables/disables the partitions probing for non-binary interface. * * Returns: 0 on success, or -1 in case of error. */ int blkid_probe_enable_partitions(blkid_probe pr, int enable) { if (!pr) return -1; pr->chains[BLKID_CHAIN_PARTS].enabled = enable; return 0; } /** * blkid_probe_set_partitions_flags: * @pr: prober * @flags: BLKID_PARTS_* flags * * Sets probing flags to the partitions prober. This function is optional. * * Returns: 0 on success, or -1 in case of error. */ int blkid_probe_set_partitions_flags(blkid_probe pr, int flags) { if (!pr) return -1; pr->chains[BLKID_CHAIN_PARTS].flags = flags; return 0; } /** * blkid_probe_reset_partitions_filter: * @pr: prober * * Resets partitions probing filter * * Returns: 0 on success, or -1 in case of error. */ int blkid_probe_reset_partitions_filter(blkid_probe pr) { return __blkid_probe_reset_filter(pr, BLKID_CHAIN_PARTS); } /** * blkid_probe_invert_partitions_filter: * @pr: prober * * Inverts partitions probing filter * * Returns: 0 on success, or -1 in case of error. */ int blkid_probe_invert_partitions_filter(blkid_probe pr) { return __blkid_probe_invert_filter(pr, BLKID_CHAIN_PARTS); } /** * blkid_probe_filter_partitions_type: * @pr: prober * @flag: filter BLKID_FLTR_{NOTIN,ONLYIN} flag * @names: NULL terminated array of probing function names (e.g. "vfat"). * * BLKID_FLTR_NOTIN - probe for all items which are NOT IN @names * BLKID_FLTR_ONLYIN - probe for items which are IN @names * * Returns: 0 on success, or -1 in case of error. */ int blkid_probe_filter_partitions_type(blkid_probe pr, int flag, char *names[]) { return __blkid_probe_filter_types(pr, BLKID_CHAIN_PARTS, flag, names); } /** * blkid_probe_get_partitions: * @pr: probe * * This is a binary interface for partitions. See also blkid_partlist_* * functions. * * This function is independent on blkid_do_[safe,full]probe() and * blkid_probe_enable_partitions() calls. * * WARNING: the returned object will be overwritten by the next * blkid_probe_get_partitions() call for the same @pr. If you want to * use more blkid_partlist objects in the same time you have to create * more blkid_probe handlers (see blkid_new_probe()). * * TODO: add blkid_ref() and blkid_unref() to allows to use blkid_partlist * independently on libblkid probing stuff. * * Returns: list of partitions, or NULL in case of error. */ blkid_partlist blkid_probe_get_partitions(blkid_probe pr) { return (blkid_partlist) blkid_probe_get_binary_data(pr, &pr->chains[BLKID_CHAIN_PARTS]); } /* for internal usage only */ blkid_partlist blkid_probe_get_partlist(blkid_probe pr) { return (blkid_partlist) pr->chains[BLKID_CHAIN_PARTS].data; } static void ref_parttable(blkid_parttable tab) { tab->nparts++; } static void unref_parttable(blkid_parttable tab) { tab->nparts--; if (tab->nparts <= 0) { list_del(&tab->t_tabs); free(tab); } } /* free all allocated parttables */ static void free_parttables(blkid_partlist ls) { if (!ls || !ls->l_tabs.next) return; /* remove unassigned partition tables */ while (!list_empty(&ls->l_tabs)) { blkid_parttable tab = list_entry(ls->l_tabs.next, struct blkid_struct_parttable, t_tabs); unref_parttable(tab); } } static void reset_partlist(blkid_probe pr, blkid_partlist ls) { if (!ls) return; free_parttables(ls); if (ls->next_partno) { /* already initialized - reset */ int tmp_nparts = ls->nparts_max; blkid_partition tmp_parts = ls->parts; memset(ls, 0, sizeof(struct blkid_struct_partlist)); ls->nparts_max = tmp_nparts; ls->parts = tmp_parts; } ls->nparts = 0; ls->next_partno = 1; INIT_LIST_HEAD(&ls->l_tabs); DBG(DEBUG_LOWPROBE, printf("partlist reseted\n")); } static blkid_partlist partitions_init_data(blkid_probe pr, struct blkid_chain *chn) { blkid_partlist ls; if (chn->data) ls = (blkid_partlist) chn->data; else { /* allocate the new list of partitions */ ls = calloc(1, sizeof(struct blkid_struct_partlist)); if (!ls) return NULL; chn->data = (void *) ls; } reset_partlist(pr, ls); DBG(DEBUG_LOWPROBE, printf("parts: initialized partitions list (%p, size=%d)\n", ls, ls->nparts_max)); return ls; } static void partitions_free_data(blkid_probe pr, void *data) { blkid_partlist ls = (blkid_partlist) data; if (!ls) return; free_parttables(ls); /* deallocate partitions and partlist */ free(ls->parts); free(ls); } blkid_parttable blkid_partlist_new_parttable(blkid_partlist ls, const char *type, blkid_loff_t offset) { blkid_parttable tab; tab = calloc(1, sizeof(struct blkid_struct_parttable)); if (!tab) return NULL; tab->type = type; tab->offset = offset; tab->parent = ls->next_parent; INIT_LIST_HEAD(&tab->t_tabs); list_add_tail(&tab->t_tabs, &ls->l_tabs); DBG(DEBUG_LOWPROBE, printf("parts: create a new partition table " "(%p, type=%s, offset=%llu)\n", tab, type, (unsigned long long) offset)); return tab; } static blkid_partition new_partition(blkid_partlist ls, blkid_parttable tab) { blkid_partition par; if (ls->nparts + 1 > ls->nparts_max) { /* Linux kernel has DISK_MAX_PARTS=256, but it's too much for * generic Linux machine -- let start with 32 partititions. */ ls->parts = realloc(ls->parts, (ls->nparts_max + 32) * sizeof(struct blkid_struct_partition)); if (!ls->parts) return NULL; ls->nparts_max += 32; } par = &ls->parts[ls->nparts++]; memset(par, 0, sizeof(struct blkid_struct_partition)); ref_parttable(tab); par->tab = tab; par->partno = ls->next_partno++; return par; } blkid_partition blkid_partlist_add_partition(blkid_partlist ls, blkid_parttable tab, int type, blkid_loff_t start, blkid_loff_t size) { blkid_partition par = new_partition(ls, tab); if (!par) return NULL; par->type = type; par->start = start; par->size = size; DBG(DEBUG_LOWPROBE, printf("parts: add partition (%p type=0x%x, " "start=%llu, size=%llu, table=%p)\n", par, par->type, (unsigned long long) par->start, (unsigned long long) par->size, tab)); return par; } /* allows to modify used partitions numbers (for example for logical partitions) */ int blkid_partlist_set_partno(blkid_partlist ls, int partno) { if (!ls) return -1; ls->next_partno = partno; return 0; } /* allows to set "parent" for the next nested partition */ int blkid_partlist_set_parent(blkid_partlist ls, blkid_partition par) { if (!ls) return -1; ls->next_parent = par; return 0; } blkid_partition blkid_partlist_get_parent(blkid_partlist ls) { if (!ls) return NULL; return ls->next_parent; } int blkid_partitions_need_typeonly(blkid_probe pr) { struct blkid_chain *chn = blkid_probe_get_chain(pr); return chn && chn->data && chn->binary ? FALSE : TRUE; } /* get private chain flags */ int blkid_partitions_get_flags(blkid_probe pr) { struct blkid_chain *chn = blkid_probe_get_chain(pr); return chn ? chn->flags : 0; } /* check if @start and @size are within @par partition */ int blkid_is_nested_dimension(blkid_partition par, blkid_loff_t start, blkid_loff_t size) { blkid_loff_t pstart; blkid_loff_t psize; if (!par) return 0; pstart = blkid_partition_get_start(par); psize = blkid_partition_get_size(par); if (start < pstart || start + size > pstart + psize) return 0; return 1; } static int idinfo_probe(blkid_probe pr, const struct blkid_idinfo *id) { const struct blkid_idmag *mag; int hasmag = 0; int rc = 1; /* = nothing detected */ if (pr->size <= 0 || (id->minsz && id->minsz > pr->size)) goto nothing; /* the device is too small */ mag = id->magics ? &id->magics[0] : NULL; /* try to detect by magic string */ while(mag && mag->magic) { int idx; unsigned char *buf; idx = mag->kboff + (mag->sboff >> 10); buf = blkid_probe_get_buffer(pr, idx << 10, 1024); if (buf && !memcmp(mag->magic, buf + (mag->sboff & 0x3ff), mag->len)) { DBG(DEBUG_LOWPROBE, printf( "%s: magic sboff=%u, kboff=%ld\n", id->name, mag->sboff, mag->kboff)); hasmag = 1; break; } mag++; } if (hasmag == 0 && id->magics && id->magics[0].magic) /* magic string(s) defined, but not found */ goto nothing; /* final check by probing function */ if (id->probefunc) { DBG(DEBUG_LOWPROBE, printf( "%s: ---> call probefunc()\n", id->name)); rc = id->probefunc(pr, mag); if (rc == -1) { /* reset after error */ reset_partlist(pr, blkid_probe_get_partlist(pr)); DBG(DEBUG_LOWPROBE, printf( "%s probefunc failed\n", id->name)); } DBG(DEBUG_LOWPROBE, printf( "%s: <--- (rc = %d)\n", id->name, rc)); } nothing: return rc; } /* * The blkid_do_probe() backend. */ static int partitions_probe(blkid_probe pr, struct blkid_chain *chn) { int i = 0; if (!pr || chn->idx < -1) return -1; blkid_probe_chain_reset_vals(pr, chn); if (chn->binary) partitions_init_data(pr, chn); DBG(DEBUG_LOWPROBE, printf("--> starting probing loop [PARTS idx=%d]\n", chn->idx)); i = chn->idx + 1; for ( ; i < ARRAY_SIZE(idinfos); i++) { const char *name; chn->idx = i; /* apply filter */ if (chn->fltr && blkid_bmp_get_item(chn->fltr, i)) continue; /* apply checks from idinfo */ if (idinfo_probe(pr, idinfos[i]) != 0) continue; name = idinfos[i]->name; /* all checks passed */ blkid_probe_set_value(pr, "PTTYPE", (unsigned char *) name, strlen(name) + 1); DBG(DEBUG_LOWPROBE, printf("<-- leaving probing loop (type=%s) [PARTS idx=%d]\n", name, chn->idx)); return 0; } DBG(DEBUG_LOWPROBE, printf("<-- leaving probing loop (failed) [PARTS idx=%d]\n", chn->idx)); return 1; } /* Probe for nested partition table within the parental partition */ int blkid_partitions_do_subprobe(blkid_probe pr, blkid_partition parent, const struct blkid_idinfo *id) { int rc = 1; blkid_partlist ls; blkid_loff_t saved_sz, saved_off, sz, off; DBG(DEBUG_LOWPROBE, printf( "parts: ----> %s subprobe requested (parent=%p)\n", id->name, parent)); if (!pr || !parent || !parent->size) return -1; ls = blkid_probe_get_partlist(pr); sz = ((blkid_loff_t) parent->size) << 9; off = ((blkid_loff_t) parent->start) << 9; /* get the current setting in bytes */ blkid_probe_get_dimension(pr, &saved_off, &saved_sz); /* check the requested range */ if (off < saved_off || saved_off + saved_sz < off + sz) { DBG(DEBUG_LOWPROBE, printf( "ERROR: parts: <---- '%s' sub-probe: overflow detected.\n", id->name)); return -1; } /* define sub-range with in device */ blkid_probe_set_dimension(pr, off, sz); blkid_partlist_set_parent(ls, parent); rc = idinfo_probe(pr, id); blkid_partlist_set_parent(ls, NULL); /* restore the original setting */ blkid_probe_set_dimension(pr, saved_off, saved_sz); DBG(DEBUG_LOWPROBE, printf( "parts: <---- %s subprobe done (parent=%p, rc=%d)\n", id->name, parent, rc)); return rc; } /** * blkid_known_pttype: * @pttype: partiton name * * Returns: 1 for known or 0 for unknown partition type. */ int blkid_known_pttype(const char *pttype) { int i; if (!pttype) return 0; for (i = 0; i < ARRAY_SIZE(idinfos); i++) { const struct blkid_idinfo *id = idinfos[i]; if (strcmp(id->name, pttype) == 0) return 1; } return 0; } /** * blkid_partlist_numof_partitions: * @ls: partitions list * * Returns: number of partitions in the list or -1 in case of error. */ int blkid_partlist_numof_partitions(blkid_partlist ls) { return ls ? ls->nparts : -1; } /** * blkid_partlist_get_partition: * @ls: partitions list * @n: partition number in range 0..N, where 'N' is blkid_partlist_numof_partitions(). * * It's possible that the list of partitions is *empty*, but there is a valid * partition table on the disk. This happen when on-disk details about * partitions are unknown, but we are able to detect partition table magic * string only. The nice example is AIX. If your question is: "Is there any * partition table?", use: * * blkid_probe_lookup_value(pr, "PTTYPE", &type, NULL); * * Returns: partition object or NULL in case or error. */ blkid_partition blkid_partlist_get_partition(blkid_partlist ls, int n) { if (!ls || n < 0 || n >= ls->nparts) return NULL; return &ls->parts[n]; } /** * blkid_parttable_get_type: * @tab: partition table * * Returns: partition table type (type name, e.g. "dos", "gpt", ...) */ const char *blkid_parttable_get_type(blkid_parttable tab) { return tab ? tab->type : NULL; } /** * blkid_parttable_get_parent: * @tab: partition table * * Returns: parent for nexted partitition tables or NULL. */ blkid_partition blkid_parttable_get_parent(blkid_parttable tab) { return tab ? tab->parent : NULL; } /** * blkid_parttable_get_offset: * @tab: partition table * * Returns: position (in bytes) of the partition table or -1 in case of error. * * Note the position is relative to begin of the device as defined by * blkid_probe_set_device() for primary partition table, and relative * to parental partition for nested patition tables. * * * * off_t offset; * blkid_partition parent = blkid_parttable_get_parent(tab); * * offset = blkid_parttable_get_offset(tab); * * if (parent) * / * 'tab' is nested partition table * / * offset += blkid_partition_get_start(parent); * * */ blkid_loff_t blkid_parttable_get_offset(blkid_parttable tab) { return tab ? tab->offset : -1; } /** * blkid_partition_get_table: * @par: partition * * The "parttable" describes partition table. The table is usually the same for * all partitions -- except nested partition tables. * * For example bsd, solaris, etc. use a nested partition table within * standard primary dos partition: * * * * * -- dos partition table * 0: sda1 dos primary partition * 1: sda2 dos primary partition * -- bsd partition table (with in sda2) * 2: sda5 bds partition * 3: sda6 bds partition * * * * * The library does not to use a separate partition table object for dos logical * partitions (partitions within extended partition). It's possible to * differentiate between logical, extended and primary partitions by * * blkid_partition_is_{extended,primary,logical}(). * * Returns: partition table object or NULL in case of error. */ blkid_parttable blkid_partition_get_table(blkid_partition par) { return par ? par->tab : NULL; } static int partition_get_logical_type(blkid_partition par) { blkid_parttable tab; if (!par) return -1; tab = blkid_partition_get_table(par); if (!tab || !tab->type) return -1; if (tab->parent) return 'L'; /* report nested partitions as logical */ if (!strcmp(tab->type, "dos")) { if (par->partno > 4) return 'L'; /* logical */ if(par->type == BLKID_DOS_EXTENDED_PARTITION || par->type == BLKID_W95_EXTENDED_PARTITION || par->type == BLKID_LINUX_EXTENDED_PARTITION) return 'E'; } return 'P'; } /** * blkid_partition_is_primary: * @par: partition * * Note, this function returns FALSE for DOS extended partitions and * all partitions in nested partition tables. * * Returns: 1 if the partitions is primary partition or 0 if not. */ int blkid_partition_is_primary(blkid_partition par) { return partition_get_logical_type(par) == 'P' ? TRUE : FALSE; } /** * blkid_partition_is_extended: * @par: partition * * Returns: 1 if the partitions is extended (dos, windows or linux) * partition or 0 if not. */ int blkid_partition_is_extended(blkid_partition par) { return partition_get_logical_type(par) == 'E' ? TRUE : FALSE; } /** * blkid_partition_is_logical: * @par: partition * * Note that this function returns TRUE for all partitions in all * nested partition tables (e.g. BSD labels). * * Returns: 1 if the partitions is logical partition or 0 if not. */ int blkid_partition_is_logical(blkid_partition par) { return partition_get_logical_type(par) == 'L' ? TRUE : FALSE; } static void set_string(unsigned char *item, size_t max, const unsigned char *data, size_t len) { if (len >= max) len = max - 1; memcpy(item, data, len); item[len] = '\0'; blkid_rtrim_whitespace(item); } int blkid_partition_set_name(blkid_partition par, const unsigned char *name, size_t len) { if (!par) return -1; set_string(par->name, sizeof(par->name), name, len); return 0; } int blkid_partition_set_utf8name(blkid_partition par, const unsigned char *name, size_t len, int enc) { if (!par) return -1; blkid_encode_to_utf8(enc, par->name, sizeof(par->name), name, len); blkid_rtrim_whitespace(par->name); return 0; } int blkid_partition_set_uuid(blkid_partition par, const unsigned char *uuid) { if (!par) return -1; blkid_unparse_uuid(uuid, par->uuid, sizeof(par->uuid)); return 0; } /** * blkid_partition_get_name: * @par: partition * * Returns: partition name string if supported by PT (e.g. Mac) or NULL. */ const char *blkid_partition_get_name(blkid_partition par) { return par && *par->name ? (char *) par->name : NULL; } /** * blkid_partition_get_uuid: * @par: partition * * Returns: partition UUID string if supported by PT (e.g. GPT) or NULL. */ const char *blkid_partition_get_uuid(blkid_partition par) { return par && *par->uuid ? par->uuid : NULL; } /** * blkid_partition_get_partno: * @par: partition * * Returns: proposed partitin number (e.g. 'N' from sda'N') or -1 in case of * error. Note that the number is generate by library independenly on your OS. */ int blkid_partition_get_partno(blkid_partition par) { return par ? par->partno : -1; } /** * blkid_partition_get_start: * @par: partition * * Be careful if you _not_ probe whole disk: * * 1) the offset is usully relative to begin of the disk -- but if you probe a * fragment of the disk only -- then the offset could be still relative to * the begin of the disk rather that relative to the fragment. * * 2) the offset for nested partitions could be releative to parent (e.g. Solaris) * _or_ relative to the begin of the whole disk (e.g. bsd). * * You don't have to care about such details if you proble whole disk. In such * a case libblkid always returns the offset relative to the begin of the disk. * * Returns: start of the partition (in 512-sectors). */ blkid_loff_t blkid_partition_get_start(blkid_partition par) { return par ? par->start : -1; } /** * blkid_partition_get_size: * @par: partition * * WARNING: be very careful when you work with MS-DOS extended partitions. The * library always returns full size of the partition. If you want add * the partition to the Linux system (BLKPG_ADD_PARTITION ioctl) you * need to reduce the size of the partition to 1 or 2 blocks. The * rest of the partition has to be unaccessible for mkfs or mkswap * programs, we need a small space for boot loaders only. * * For some unknown reason this (safe) practice is not to used for * nested BSD, Solaris, ..., partition tables in Linux kernel. * * Returns: size of the partition (in 512-sectors). */ blkid_loff_t blkid_partition_get_size(blkid_partition par) { return par ? par->size : -1; } /** * blkid_partition_get_type: * @par: partition * * Returns: partition type. */ int blkid_partition_get_type(blkid_partition par) { return par ? par->type : 0; } /* Sets partition 'type' for PT where the type is defined by string rather * than by number */ int blkid_partition_set_type_string(blkid_partition par, const unsigned char *type, size_t len) { if (!par) return -1; set_string((unsigned char *) par->typestr, sizeof(par->typestr), type, len); return 0; } /* Sets partition 'type' for PT where the type is defined by UUIDrather * than by number */ int blkid_partition_set_type_uuid(blkid_partition par, const unsigned char *uuid) { if (!par) return -1; blkid_unparse_uuid(uuid, par->typestr, sizeof(par->typestr)); return 0; } /** * blkid_partition_get_type_string: * @par: partition * * The type string is supported by a small subset of partition tables (e.g Mac * and EFI GPT). Note that GPT uses type UUID and this function returns this * UUID as string. * * Returns: partition type string or NULL. */ const char *blkid_partition_get_type_string(blkid_partition par) { return par && *par->typestr ? par->typestr : NULL; }