static int parse_fstab(void) { FILE *f; int r = 0; struct mntent *me; errno = 0; f = setmntent("/etc/fstab", "r"); if (!f) { if (errno == ENOENT) return 0; log_error("Failed to open /etc/fstab: %m"); return -errno; } while ((me = getmntent(f))) { char _cleanup_free_ *where = NULL, *what = NULL; int k; what = fstab_node_to_udev_node(me->mnt_fsname); where = strdup(me->mnt_dir); if (!what || !where) { r = log_oom(); goto finish; } if (is_path(where)) path_kill_slashes(where); log_debug("Found entry what=%s where=%s type=%s", what, where, me->mnt_type); if (streq(me->mnt_type, "swap")) k = add_swap(what, me); else { bool noauto, nofail, automount, isbind, isnetwork; noauto = !!hasmntopt(me, "noauto"); nofail = !!hasmntopt(me, "nofail"); automount = hasmntopt(me, "comment=systemd.automount") || hasmntopt(me, "x-systemd.automount"); isbind = mount_is_bind(me); isnetwork = mount_is_network(me); k = add_mount(what, where, me->mnt_type, me->mnt_opts, me->mnt_passno, false, noauto, nofail, automount, isbind, isnetwork, "/etc/fstab"); } if (k < 0) r = k; } finish: endmntent(f); return r; }
static int parse_fstab(void) { FILE *f; int r = 0; struct mntent *me; errno = 0; f = setmntent("/etc/fstab", "r"); if (!f) { if (errno == ENOENT) return 0; log_error("Failed to open /etc/fstab: %m"); return -errno; } while ((me = getmntent(f))) { char *where, *what; int k; what = fstab_node_to_udev_node(me->mnt_fsname); if (!what) { r = log_oom(); goto finish; } where = strdup(me->mnt_dir); if (!where) { r = log_oom(); free(what); goto finish; } if (is_path(where)) path_kill_slashes(where); log_debug("Found entry what=%s where=%s type=%s", what, where, me->mnt_type); if (streq(me->mnt_type, "swap")) k = add_swap(what, me); else k = add_mount(what, where, me); free(what); free(where); if (k < 0) r = k; } finish: endmntent(f); return r; }
/* * swapon_command: emulate the old swapon(8) program. */ int swapon_command(int argc, char **argv) { int ch, fiztab = 0; while ((ch = getopt(argc, argv, "at:")) != -1) { switch (ch) { case 'a': fiztab = 1; break; case 't': if (tflag != NULL) usage(); tflag = optarg; break; default: goto swapon_usage; } } argc -= optind; argv += optind; if (fiztab) { if (argc) goto swapon_usage; /* Sanity-check -t */ if (tflag != NULL) { if (strcmp(tflag, "blk") != 0 && strcmp(tflag, "noblk") != 0) usage(); } do_fstab(); return (0); } else if (argc == 0 || tflag != NULL) goto swapon_usage; while (argc) { add_swap(argv[0]); argc--; argv++; } return (0); swapon_usage: fprintf(stderr, "usage: %s -a | path\n", __progname); return (1); }
static int parse_fstab(const char *prefix, bool initrd) { _cleanup_free_ char *fstab_path = NULL; FILE *f; int r = 0; struct mntent *me; fstab_path = strjoin(strempty(prefix), "/etc/fstab", NULL); if (!fstab_path) return log_oom(); f = setmntent(fstab_path, "r"); if (!f) { if (errno == ENOENT) return 0; log_error("Failed to open %s/etc/fstab: %m", strempty(prefix)); return -errno; } while ((me = getmntent(f))) { _cleanup_free_ char *where = NULL, *what = NULL; int k; if (initrd && !mount_in_initrd(me)) continue; what = fstab_node_to_udev_node(me->mnt_fsname); where = strjoin(strempty(prefix), me->mnt_dir, NULL); if (!what || !where) { r = log_oom(); goto finish; } if (is_path(where)) path_kill_slashes(where); log_debug("Found entry what=%s where=%s type=%s", what, where, me->mnt_type); if (streq(me->mnt_type, "swap")) k = add_swap(what, me); else { bool noauto, nofail, automount, isbind; const char *pre, *pre2, *post, *online; noauto = !!hasmntopt(me, "noauto"); nofail = !!hasmntopt(me, "nofail"); automount = hasmntopt(me, "comment=systemd.automount") || hasmntopt(me, "x-systemd.automount"); isbind = mount_is_bind(me); if (initrd) { pre = pre2 = online = NULL; post = SPECIAL_INITRD_FS_TARGET; } else if (mount_in_initrd(me)) { pre = pre2 = online = NULL; post = SPECIAL_INITRD_ROOT_FS_TARGET; } else if (mount_is_network(me)) { pre = SPECIAL_REMOTE_FS_PRE_TARGET; pre2 = SPECIAL_NETWORK_TARGET; online = SPECIAL_NETWORK_ONLINE_TARGET; post = SPECIAL_REMOTE_FS_TARGET; } else { pre = SPECIAL_LOCAL_FS_PRE_TARGET; pre2 = online = NULL; post = SPECIAL_LOCAL_FS_TARGET; } k = add_mount(what, where, me->mnt_type, me->mnt_opts, me->mnt_passno, noauto, nofail, automount, isbind, pre, pre2, online, post, fstab_path); } if (k < 0) r = k; } finish: endmntent(f); return r; }
struct Node* connected_double_edge_swap(struct Node* G, int node_count, int nswap, int windows_threhold){ // this version implement the windows size. srand((unsigned int)time(NULL)); int i; struct Node* node1; struct Node* node2; struct Node* n1_rel; struct Node* n2_rel; int max_id = 0; // copy G // directly copy may be dingerous for (int i = 0; i < node_count; i++) { struct Node * n = malloc(sizeof(struct Node)); n->node_id = G[i].node_id; if (n->node_id > max_id) { max_id = n->node_id; } n->neighbour_count = G[i].neighbour_count; n->neighbours = (int *)malloc(sizeof(int) * n->neighbour_count); for (int j = 0; j < n->neighbour_count; j ++) { n->neighbours[j] = G[i].neighbours[j]; } G[i] = *n; } struct Node ** id2Node = malloc(sizeof(struct Node) * (max_id + 1)); for (int i = 0; i < max_id + 1; i ++) { id2Node[i] = NULL; } for (int i = 0; i < node_count; i ++) { id2Node[G[i].node_id] = G + i; } i = 0; struct CDF * cdf = generate_cdf(G, node_count); windows_threhold = 3; int windows = 1; // printf("\nStArT\n"); while (i < nswap) { int wcount = 0; init_heap(); if (windows < windows_threhold) { // do check every time // printf("low windows count\n"); int fail = 0; while (wcount < windows && i < nswap) { // if (i % 100000 == 0) { // printf("done: %i\n", i); // } // printf("Low: i: %i, wcount: %i, windows: %i\n", i, wcount, windows); int * picked = choose_node_from_cdf(cdf, (float)(rand()) / (float)(RAND_MAX), (float)(rand()) / (float)(RAND_MAX)); int n1 = picked[0]; int n2 = picked[1]; if (n1 == n2) { continue; } // the node may be empty? node1 = get_node_from_graph(G, node_count, n1); node2 = get_node_from_graph(G, node_count, n2); if (node1 == NULL || node2 == NULL) { printf("Oops node empty %i, %i\n", n1, n2); continue; } int ri, rj; int n_id_1 = pick_neighbour(node1, &ri); int n_id_2 = pick_neighbour(node2, &rj); n1_rel = get_node_from_graph(G, node_count, n_id_1); n2_rel = get_node_from_graph(G, node_count, n_id_2); // any NULL error and continue if (node1 == NULL || node2 == NULL || n1_rel == NULL || n2_rel == NULL) { // printf("node1 %llx, node2 %llx, n1_rel %llx n2_rel %llx\n", node1, node2, n1_rel, n2_rel); continue; } if (node1->node_id == n2_rel->node_id || node2->node_id == n1_rel->node_id || n1_rel->node_id == n2_rel->node_id) { continue; } if (is_two_node_connected(node1, node2) || is_two_node_connected(n1_rel, n2_rel)) { continue; } // now let us do the exchage // before: node1 -- n1_rel after: node1 n1_rel // | | // node2 -- n2_rel node2 n2_rel // delete edge delete_edge(node1, n1_rel); delete_edge(node2, n2_rel); // add edge add_edge(node1, node2); add_edge(n1_rel, n2_rel); i += 1; add_swap(node1->node_id, node2->node_id, n1_rel->node_id, n2_rel->node_id); // if (! is_graph_connected(G, node_count, id2Node, max_id)) { if (! is_2_node_connected(id2Node, max_id, node1->node_id, n1_rel->node_id)) { // oops let us redo // printf("Oops not connected, retry~\n"); add_edge(node1, n1_rel); add_edge(node2, n2_rel); // add edge delete_edge(node1, node2); delete_edge(n1_rel, n2_rel); fail = 1; } else{ wcount += 1; } } if (fail == 1){ windows = ceilf((float)windows / 2); }else{ windows += 1; } }else{ // printf("high windows count\n"); // do check at end while (wcount < windows && i < nswap) { // if (i % 100000 == 0) { // printf("done: %i\n", i); // } // printf("High: i: %i, wcount: %i, window: %i\n", i, wcount, windows); int * picked = choose_node_from_cdf(cdf, (float)(rand()) / (float)(RAND_MAX), (float)(rand()) / (float)(RAND_MAX)); int n1 = picked[0]; int n2 = picked[1]; if (n1 == n2) { continue; } // the node may be empty? node1 = get_node_from_graph(G, node_count, n1); node2 = get_node_from_graph(G, node_count, n2); if (node1 == NULL || node2 == NULL) { // printf("Oops node empty %i, %i\n", n1, n2); continue; } int ri, rj; int n_id_1 = pick_neighbour(node1, &ri); int n_id_2 = pick_neighbour(node2, &rj); n1_rel = get_node_from_graph(G, node_count, n_id_1); n2_rel = get_node_from_graph(G, node_count, n_id_2); // any NULL error and continue if (node1 == NULL || node2 == NULL || n1_rel == NULL || n2_rel == NULL) { // printf("node1 %llx, node2 %llx, n1_rel %llx n2_rel %llx\n", node1, node2, n1_rel, n2_rel); continue; } if (node1->node_id == n2_rel->node_id || node2->node_id == n1_rel->node_id || n1_rel->node_id == n2_rel->node_id) { continue; } if (is_two_node_connected(node1, node2) || is_two_node_connected(n1_rel, n2_rel)) { continue; } // now let us do the exchage // before: node1 -- n1_rel after: node1 n1_rel // | | // node2 -- n2_rel node2 n2_rel // delete edge delete_edge(node1, n1_rel); delete_edge(node2, n2_rel); // add edge add_edge(node1, node2); add_edge(n1_rel, n2_rel); i += 1; add_swap(node1->node_id, node2->node_id, n1_rel->node_id, n2_rel->node_id); wcount += 1; } if (is_graph_connected(G, node_count, id2Node, max_id)) { windows += 1; }else{ // then redo all // printf("Oops not connected, retry~\n"); while (1) { // printf("redo\n"); struct Swap* s = get_swap(); if (s == NULL) { break; } struct Node * reN1 = get_node_from_graph(G, node_count, s->node1); struct Node * reN2 = get_node_from_graph(G, node_count, s->node2); struct Node * reN1_rel = get_node_from_graph(G, node_count, s->node3); struct Node * reN2_rel = get_node_from_graph(G, node_count, s->node4); add_edge(reN1, reN1_rel); add_edge(reN2, reN2_rel); // add edge delete_edge(reN1, reN2); delete_edge(reN1_rel, reN2_rel); } windows = ceilf((float)windows / 2.0); } } } return G; }
static int parse_fstab(bool initrd) { _cleanup_endmntent_ FILE *f = NULL; const char *fstab_path; struct mntent *me; int r = 0; fstab_path = initrd ? "/sysroot/etc/fstab" : "/etc/fstab"; f = setmntent(fstab_path, "re"); if (!f) { if (errno == ENOENT) return 0; log_error_errno(errno, "Failed to open %s: %m", fstab_path); return -errno; } while ((me = getmntent(f))) { _cleanup_free_ char *where = NULL, *what = NULL; bool noauto, nofail; int k; if (initrd && !mount_in_initrd(me)) continue; what = fstab_node_to_udev_node(me->mnt_fsname); if (!what) return log_oom(); if (is_device_path(what) && path_is_read_only_fs("sys") > 0) { log_info("Running in a container, ignoring fstab device entry for %s.", what); continue; } where = initrd ? strappend("/sysroot/", me->mnt_dir) : strdup(me->mnt_dir); if (!where) return log_oom(); if (is_path(where)) path_kill_slashes(where); noauto = fstab_test_yes_no_option(me->mnt_opts, "noauto\0" "auto\0"); nofail = fstab_test_yes_no_option(me->mnt_opts, "nofail\0" "fail\0"); log_debug("Found entry what=%s where=%s type=%s nofail=%s noauto=%s", what, where, me->mnt_type, yes_no(noauto), yes_no(nofail)); if (streq(me->mnt_type, "swap")) k = add_swap(what, me, noauto, nofail); else { bool automount; const char *post; automount = fstab_test_option(me->mnt_opts, "comment=systemd.automount\0" "x-systemd.automount\0"); if (initrd) post = SPECIAL_INITRD_FS_TARGET; else if (mount_in_initrd(me)) post = SPECIAL_INITRD_ROOT_FS_TARGET; else if (mount_is_network(me)) post = SPECIAL_REMOTE_FS_TARGET; else post = SPECIAL_LOCAL_FS_TARGET; k = add_mount(what, where, me->mnt_type, me->mnt_opts, me->mnt_passno, noauto, nofail, automount, post, fstab_path); } if (k < 0) r = k; } return r; }
static int enumerate_partitions(dev_t devnum) { _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL; _cleanup_udev_device_unref_ struct udev_device *d = NULL; _cleanup_blkid_free_probe_ blkid_probe b = NULL; _cleanup_udev_unref_ struct udev *udev = NULL; _cleanup_free_ char *boot = NULL, *home = NULL, *srv = NULL; struct udev_list_entry *first, *item; struct udev_device *parent = NULL; const char *name, *node, *pttype, *devtype; int boot_nr = -1, home_nr = -1, srv_nr = -1; bool home_rw = true, srv_rw = true; blkid_partlist pl; int r, k; dev_t pn; udev = udev_new(); if (!udev) return log_oom(); d = udev_device_new_from_devnum(udev, 'b', devnum); if (!d) return log_oom(); name = udev_device_get_devnode(d); if (!name) name = udev_device_get_syspath(d); if (!name) { log_debug("Device %u:%u does not have a name, ignoring.", major(devnum), minor(devnum)); return 0; } parent = udev_device_get_parent(d); if (!parent) { log_debug("%s: not a partitioned device, ignoring.", name); return 0; } /* Does it have a devtype? */ devtype = udev_device_get_devtype(parent); if (!devtype) { log_debug("%s: parent doesn't have a device type, ignoring.", name); return 0; } /* Is this a disk or a partition? We only care for disks... */ if (!streq(devtype, "disk")) { log_debug("%s: parent isn't a raw disk, ignoring.", name); return 0; } /* Does it have a device node? */ node = udev_device_get_devnode(parent); if (!node) { log_debug("%s: parent device does not have device node, ignoring.", name); return 0; } log_debug("%s: root device %s.", name, node); pn = udev_device_get_devnum(parent); if (major(pn) == 0) return 0; errno = 0; b = blkid_new_probe_from_filename(node); if (!b) { if (errno == 0) return log_oom(); return log_error_errno(errno, "%s: failed to allocate prober: %m", node); } blkid_probe_enable_partitions(b, 1); blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS); errno = 0; r = blkid_do_safeprobe(b); if (r == 1) return 0; /* no results */ else if (r == -2) { log_warning("%s: probe gave ambiguous results, ignoring", node); return 0; } else if (r != 0) return log_error_errno(errno ?: EIO, "%s: failed to probe: %m", node); errno = 0; r = blkid_probe_lookup_value(b, "PTTYPE", &pttype, NULL); if (r != 0) return log_error_errno(errno ?: EIO, "%s: failed to determine partition table type: %m", node); /* We only do this all for GPT... */ if (!streq_ptr(pttype, "gpt")) { log_debug("%s: not a GPT partition table, ignoring.", node); return 0; } errno = 0; pl = blkid_probe_get_partitions(b); if (!pl) { if (errno == 0) return log_oom(); return log_error_errno(errno, "%s: failed to list partitions: %m", node); } e = udev_enumerate_new(udev); if (!e) return log_oom(); r = udev_enumerate_add_match_parent(e, parent); if (r < 0) return log_oom(); r = udev_enumerate_add_match_subsystem(e, "block"); if (r < 0) return log_oom(); r = udev_enumerate_scan_devices(e); if (r < 0) return log_error_errno(r, "%s: failed to enumerate partitions: %m", node); first = udev_enumerate_get_list_entry(e); udev_list_entry_foreach(item, first) { _cleanup_udev_device_unref_ struct udev_device *q; unsigned long long flags; const char *stype, *subnode; sd_id128_t type_id; blkid_partition pp; dev_t qn; int nr; q = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item)); if (!q) continue; qn = udev_device_get_devnum(q); if (major(qn) == 0) continue; if (qn == devnum) continue; if (qn == pn) continue; subnode = udev_device_get_devnode(q); if (!subnode) continue; pp = blkid_partlist_devno_to_partition(pl, qn); if (!pp) continue; nr = blkid_partition_get_partno(pp); if (nr < 0) continue; stype = blkid_partition_get_type_string(pp); if (!stype) continue; if (sd_id128_from_string(stype, &type_id) < 0) continue; flags = blkid_partition_get_flags(pp); if (sd_id128_equal(type_id, GPT_SWAP)) { if (flags & GPT_FLAG_NO_AUTO) continue; if (flags & GPT_FLAG_READ_ONLY) { log_debug("%s marked as read-only swap partition, which is bogus. Ignoring.", subnode); continue; } k = add_swap(subnode); if (k < 0) r = k; } else if (sd_id128_equal(type_id, GPT_ESP)) { /* We only care for the first /boot partition */ if (boot && nr >= boot_nr) continue; /* Note that we do not honour the "no-auto" * flag for the ESP, as it is often unset, to * hide it from Windows. */ boot_nr = nr; r = free_and_strdup(&boot, subnode); if (r < 0) return log_oom(); } else if (sd_id128_equal(type_id, GPT_HOME)) { if (flags & GPT_FLAG_NO_AUTO) continue; /* We only care for the first /home partition */ if (home && nr >= home_nr) continue; home_nr = nr; home_rw = !(flags & GPT_FLAG_READ_ONLY), r = free_and_strdup(&home, subnode); if (r < 0) return log_oom(); } else if (sd_id128_equal(type_id, GPT_SRV)) { if (flags & GPT_FLAG_NO_AUTO) continue; /* We only care for the first /srv partition */ if (srv && nr >= srv_nr) continue; srv_nr = nr; srv_rw = !(flags & GPT_FLAG_READ_ONLY), r = free_and_strdup(&srv, subnode); if (r < 0) return log_oom(); } }
int run(void) { xmlDocPtr doc; xmlNodePtr node; int ct = STACKCT_OPT(OUTPUT); char **output = (char **) &STACKLST_OPT(OUTPUT); GString *log; int i; int color; int highest_color = STAT_GREEN; char buf[24]; extern int forever; uw_setproctitle("sleeping"); for (i=0; i < OPT_VALUE_INTERVAL; i++) { // wait some minutes sleep(1); if (!forever) { return(0); } } uw_setproctitle("getting system statistics"); get_stats(); doc = UpwatchXmlDoc("result", NULL); xmlSetDocCompressMode(doc, OPT_VALUE_COMPRESS); // do the sysstat node = (xmlNodePtr) newnode(doc, "sysstat"); add_loadavg(node); add_cpu(node); add_paging(node); add_blockio(node); add_swap(node); add_memory(node); add_systemp(node); add_sysstat_info(node); color = xmlGetPropInt(node, "color"); if (color > highest_color) highest_color = color; #if USE_XMBMON|| defined (__OpenBSD__) if (OPT_VALUE_HWSTATS ) { // do the hwstat get_hwstats(); node = (xmlNodePtr) newnode(doc, "hwstat"); add_hwstat(node); color = xmlGetPropInt(node, "color"); if (color > highest_color) highest_color = color; } #endif if (OPT_VALUE_LOCALCHECKS ) { // do the local checks color = do_local((xmlNodePtr) doc); if (color > highest_color) highest_color = color; } #if HAVE_LIBPCRE // do the errlog node = (xmlNodePtr) newnode(doc, "errlog"); log = check_logs(&color); if (color > highest_color) highest_color = color; sprintf(buf, "%u", color); xmlSetProp(node, "color", buf); if (log) { if (log->str && strlen(log->str) > 0) { xmlNewTextChild(node, NULL, "info", log->str); } g_string_free(log, TRUE); } #endif // do the diskfree uw_setproctitle("checking diskspace"); node = (xmlNodePtr) newnode(doc, "diskfree"); add_diskfree_info(node); color = xmlGetPropInt(node, "color"); if (color > highest_color) highest_color = color; if (HAVE_OPT(HPQUEUE) && (highest_color != prv_highest_color)) { // if status changed, it needs to be sent immediately. So drop into // the high priority queue. Else just drop in the normal queue where // uw_send in batched mode will pick it up later spool_result(OPT_ARG(SPOOLDIR), OPT_ARG(HPQUEUE), doc, NULL); } else { for (i=0; i < ct; i++) { spool_result(OPT_ARG(SPOOLDIR), output[i], doc, NULL); } } prv_highest_color = highest_color; // remember for next time xmlFreeDoc(doc); return 0; }
static int enumerate_partitions(dev_t devnum) { _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL; _cleanup_udev_device_unref_ struct udev_device *d = NULL; _cleanup_blkid_free_probe_ blkid_probe b = NULL; _cleanup_udev_unref_ struct udev *udev = NULL; _cleanup_free_ char *home = NULL, *srv = NULL; struct udev_list_entry *first, *item; struct udev_device *parent = NULL; const char *node, *pttype, *devtype; int home_nr = -1, srv_nr = -1; blkid_partlist pl; int r, k; dev_t pn; udev = udev_new(); if (!udev) return log_oom(); d = udev_device_new_from_devnum(udev, 'b', devnum); if (!d) return log_oom(); parent = udev_device_get_parent(d); if (!parent) return log_oom(); /* Does it have a devtype? */ devtype = udev_device_get_devtype(parent); if (!devtype) return 0; /* Is this a disk or a partition? We only care for disks... */ if (!streq(devtype, "disk")) return 0; /* Does it have a device node? */ node = udev_device_get_devnode(parent); if (!node) return 0; log_debug("Root device %s.", node); pn = udev_device_get_devnum(parent); if (major(pn) == 0) return 0; errno = 0; b = blkid_new_probe_from_filename(node); if (!b) { if (errno == 0) return log_oom(); log_error("Failed allocate prober: %m"); return -errno; } blkid_probe_enable_superblocks(b, 1); blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE); blkid_probe_enable_partitions(b, 1); blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS); errno = 0; r = blkid_do_safeprobe(b); if (r == -2 || r == 1) /* no result or uncertain */ return 0; else if (r != 0) { if (errno == 0) errno = EIO; log_error("Failed to probe %s: %m", node); return -errno; } errno = 0; r = blkid_probe_lookup_value(b, "PTTYPE", &pttype, NULL); if (r != 0) { if (errno == 0) errno = EIO; log_error("Failed to determine partition table type of %s: %m", node); return -errno; } /* We only do this all for GPT... */ if (!streq_ptr(pttype, "gpt")) return 0; errno = 0; pl = blkid_probe_get_partitions(b); if (!pl) { if (errno == 0) return log_oom(); log_error("Failed to list partitions of %s: %m", node); return -errno; } e = udev_enumerate_new(udev); if (!e) return log_oom(); r = udev_enumerate_add_match_parent(e, parent); if (r < 0) return log_oom(); r = udev_enumerate_add_match_subsystem(e, "block"); if (r < 0) return log_oom(); r = udev_enumerate_scan_devices(e); if (r < 0) { log_error("Failed to enumerate partitions on %s: %s", node, strerror(-r)); return r; } first = udev_enumerate_get_list_entry(e); udev_list_entry_foreach(item, first) { _cleanup_udev_device_unref_ struct udev_device *q; const char *stype, *subnode; sd_id128_t type_id; blkid_partition pp; dev_t qn; int nr; q = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item)); if (!q) continue; qn = udev_device_get_devnum(q); if (major(qn) == 0) continue; if (qn == devnum) continue; if (qn == pn) continue; subnode = udev_device_get_devnode(q); if (!subnode) continue; pp = blkid_partlist_devno_to_partition(pl, qn); if (!pp) continue; nr = blkid_partition_get_partno(pp); if (nr < 0) continue; stype = blkid_partition_get_type_string(pp); if (!stype) continue; if (sd_id128_from_string(stype, &type_id) < 0) continue; if (sd_id128_equal(type_id, GPT_SWAP)) { k = add_swap(subnode); if (k < 0) r = k; } else if (sd_id128_equal(type_id, GPT_HOME)) { /* We only care for the first /home partition */ if (home && nr >= home_nr) continue; home_nr = nr; free(home); home = strdup(subnode); if (!home) return log_oom(); } else if (sd_id128_equal(type_id, GPT_SRV)) { /* We only care for the first /srv partition */ if (srv && nr >= srv_nr) continue; srv_nr = nr; free(srv); srv = strdup(node); if (!srv) return log_oom(); } }
int main(int argc, char *argv[]) { int c; if (strcmp(__progname, "swapon") == 0) return swapon_command(argc, argv); while ((c = getopt(argc, argv, "Aacdlkp:st:")) != -1) { switch (c) { case 'A': SET_COMMAND(CMD_A); break; case 'a': SET_COMMAND(CMD_a); break; case 'c': SET_COMMAND(CMD_c); break; case 'd': SET_COMMAND(CMD_d); break; case 'l': SET_COMMAND(CMD_l); break; case 'k': kflag = 1; break; case 'p': pflag = 1; /* XXX strtol() */ pri = atoi(optarg); break; case 's': SET_COMMAND(CMD_s); break; case 't': if (tflag != NULL) usage(); tflag = optarg; break; default: usage(); /* NOTREACHED */ } } argv += optind; argc -= optind; /* Did the user specify a command? */ if (command == 0) { if (argc == 0) SET_COMMAND(CMD_l); else usage(); } switch (argc) { case 0: if (command & REQUIRE_PATH) usage(); break; case 1: if (command & REQUIRE_NOPATH) usage(); break; default: usage(); } /* To change priority, you have to specify one. */ if ((command == CMD_c) && pflag == 0) usage(); /* Sanity-check -t */ if (tflag != NULL) { if (command != CMD_A) usage(); if (strcmp(tflag, "blk") != 0 && strcmp(tflag, "noblk") != 0) usage(); } /* Dispatch the command. */ switch (command) { case CMD_l: list_swap(pri, kflag, pflag, 1); break; case CMD_s: list_swap(pri, kflag, pflag, 0); break; case CMD_c: change_priority(argv[0]); break; case CMD_a: add_swap(argv[0]); break; case CMD_d: del_swap(argv[0]); break; case CMD_A: do_fstab(); break; } return (0); }