]>
Commit | Line | Data |
---|---|---|
9e300c84 AK |
1 | /* |
2 | * Copyright (C) 2001 Sistina Software | |
3 | * | |
4 | * LVM is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License as published by | |
6 | * the Free Software Foundation; either version 2, or (at your option) | |
7 | * any later version. | |
8 | * | |
9 | * LVM is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with LVM; see the file COPYING. If not, write to | |
16 | * the Free Software Foundation, 59 Temple Place - Suite 330, | |
17 | * Boston, MA 02111-1307, USA. | |
18 | * | |
19 | */ | |
20 | ||
21 | #include "tools.h" | |
22 | ||
23 | void pvscan_display_single(struct physical_volume *pv); | |
24 | ||
25 | int pv_max_name_len = 0; | |
26 | int vg_max_name_len = 0; | |
27 | ||
28 | int pvscan(int argc, char **argv) | |
29 | { | |
30 | int new_pvs_found = 0; | |
31 | int pvs_found = 0; | |
32 | char *s1, *s2, *s3; | |
33 | ||
b6c041d7 | 34 | struct list_head *pvs; |
9e300c84 | 35 | struct list_head *pvh; |
b6c041d7 | 36 | struct pv_list *pvl; |
9e300c84 AK |
37 | struct physical_volume *pv; |
38 | ||
ee1f91bf AK |
39 | uint64_t size_total = 0; |
40 | uint64_t size_new = 0; | |
9e300c84 AK |
41 | |
42 | int len = 0; | |
43 | pv_max_name_len = 0; | |
44 | vg_max_name_len = 0; | |
45 | ||
46 | if (arg_count(novolumegroup_ARG) && arg_count(exported_ARG)) { | |
b6c041d7 | 47 | log_error("Options -e and -n are incompatible"); |
ee1f91bf | 48 | return EINVALID_CMD_LINE; |
9e300c84 AK |
49 | } |
50 | ||
51 | if (arg_count(exported_ARG) || arg_count(novolumegroup_ARG)) | |
52 | log_print("WARNING: only considering physical volumes %s", | |
53 | arg_count(exported_ARG) ? | |
54 | "of exported volume group(s)" : "in no volume group"); | |
55 | ||
d2393d23 AK |
56 | log_verbose("Wiping cache of LVM-capable devices"); |
57 | persistent_filter_wipe(ios->filter); | |
9e300c84 | 58 | |
d2393d23 | 59 | log_verbose("Walking through all physical volumes"); |
b6c041d7 | 60 | if (!(pvs = ios->get_pvs(ios))) |
ee1f91bf | 61 | return ECMD_FAILED; |
9e300c84 AK |
62 | |
63 | /* eliminate exported/new if required */ | |
b6c041d7 | 64 | list_for_each(pvh, pvs) { |
9e300c84 AK |
65 | pvl = list_entry(pvh, struct pv_list, list); |
66 | pv = &pvl->pv; | |
67 | ||
b6c041d7 AK |
68 | if ((arg_count(exported_ARG) && !(pv->status & EXPORTED_VG)) |
69 | || (arg_count(novolumegroup_ARG) && (*pv->vg_name))) { | |
70 | list_del(&pvl->list); | |
9e300c84 AK |
71 | continue; |
72 | } | |
73 | ||
74 | /* Also check for MD use? */ | |
75 | /******* | |
76 | if (MAJOR(pv_create_kdev_t(pv[p]->pv_name)) != MD_MAJOR) { | |
77 | log_print | |
78 | ("WARNING: physical volume \"%s\" belongs to a meta device", | |
79 | pv[p]->pv_name); | |
80 | } | |
81 | if (MAJOR(pv[p]->pv_dev) != MD_MAJOR) | |
82 | continue; | |
83 | ********/ | |
84 | pvs_found++; | |
25d42d50 | 85 | |
9e300c84 | 86 | |
b6c041d7 | 87 | if (!*pv->vg_name) { |
9e300c84 | 88 | new_pvs_found++; |
b6c041d7 AK |
89 | size_new += pv->size; |
90 | size_total += pv->size; | |
91 | } else | |
92 | size_total += (pv->pe_count - pv->pe_allocated) | |
93 | * pv->pe_size; | |
9e300c84 AK |
94 | } |
95 | ||
96 | /* find maximum pv name length */ | |
97 | pv_max_name_len = vg_max_name_len = 0; | |
b6c041d7 AK |
98 | list_for_each(pvh, pvs) { |
99 | pv = &list_entry(pvh, struct pv_list, list)->pv; | |
c7f0b573 | 100 | len = strlen(dev_name(pv->dev)); |
9e300c84 AK |
101 | if (pv_max_name_len < len) |
102 | pv_max_name_len = len; | |
103 | len = strlen(pv->vg_name); | |
104 | if (vg_max_name_len < len) | |
105 | vg_max_name_len = len; | |
106 | } | |
107 | pv_max_name_len += 2; | |
108 | vg_max_name_len += 2; | |
109 | ||
b6c041d7 AK |
110 | list_for_each(pvh, pvs) |
111 | pvscan_display_single(&list_entry(pvh, struct pv_list, list)->pv); | |
9e300c84 AK |
112 | |
113 | if (!pvs_found) { | |
114 | log_print("No matching physical volumes found"); | |
115 | return 0; | |
116 | } | |
117 | ||
b6c041d7 | 118 | log_print("Total: %d [%s] / in use: %d [%s] / in no VG: %d [%s]", |
9e300c84 AK |
119 | pvs_found, |
120 | (s1 = display_size(size_total / 2, SIZE_SHORT)), | |
121 | pvs_found - new_pvs_found, | |
122 | (s2 = | |
123 | display_size((size_total - size_new) / 2, SIZE_SHORT)), | |
25d42d50 | 124 | new_pvs_found, (s3 = display_size(size_new / 2, SIZE_SHORT))); |
9e300c84 AK |
125 | dbg_free(s1); |
126 | dbg_free(s2); | |
127 | dbg_free(s3); | |
128 | ||
129 | return 0; | |
130 | } | |
131 | ||
132 | void pvscan_display_single(struct physical_volume *pv) | |
133 | { | |
134 | ||
135 | int vg_name_len = 0; | |
136 | const char *active_str; | |
137 | ||
138 | char *s1, *s2; | |
139 | ||
140 | char pv_tmp_name[NAME_LEN] = { 0, }; | |
141 | char vg_tmp_name[NAME_LEN] = { 0, }; | |
142 | char vg_name_this[NAME_LEN] = { 0, }; | |
143 | ||
144 | /* short listing? */ | |
145 | if (arg_count(short_ARG) > 0) { | |
c7f0b573 | 146 | log_print("%s", dev_name(pv->dev)); |
9e300c84 AK |
147 | return; |
148 | } | |
149 | ||
150 | if (arg_count(verbose_ARG) > 1) { | |
b6c041d7 AK |
151 | /* FIXME As per pv_display! Drop through for now. */ |
152 | /* pv_show(pv); */ | |
153 | ||
9e300c84 | 154 | log_print("System Id %s", pv->exported); |
b6c041d7 AK |
155 | |
156 | /* log_print(" "); */ | |
157 | /* return; */ | |
9e300c84 AK |
158 | } |
159 | ||
160 | memset(pv_tmp_name, 0, sizeof (pv_tmp_name)); | |
161 | ||
b6c041d7 | 162 | active_str = (pv->status & ACTIVE) ? "ACTIVE " : "Inactive"; |
9e300c84 | 163 | |
b6c041d7 | 164 | vg_name_len = strlen(pv->vg_name) - sizeof (EXPORTED_TAG) + 1; |
9e300c84 AK |
165 | |
166 | if (arg_count(uuid_ARG)) { | |
167 | sprintf(pv_tmp_name, | |
168 | "%-*s with UUID %s", | |
169 | pv_max_name_len - 2, | |
c7f0b573 | 170 | dev_name(pv->dev), display_uuid(pv->id.uuid)); |
9e300c84 | 171 | } else { |
c7f0b573 | 172 | sprintf(pv_tmp_name, "%s", dev_name(pv->dev)); |
9e300c84 AK |
173 | } |
174 | ||
b6c041d7 AK |
175 | if (!*pv->vg_name) { |
176 | log_print("%s PV %-*s is in no VG %-*s [%s]", active_str, | |
9e300c84 | 177 | pv_max_name_len, pv_tmp_name, |
b6c041d7 | 178 | vg_max_name_len - 6, " ", |
9e300c84 AK |
179 | (s1 = display_size(pv->size / 2, SIZE_SHORT))); |
180 | dbg_free(s1); | |
181 | return; | |
182 | } | |
183 | ||
9e300c84 AK |
184 | if (strcmp(&pv->vg_name[vg_name_len], EXPORTED_TAG) == 0) { |
185 | strncpy(vg_name_this, pv->vg_name, vg_name_len); | |
b6c041d7 | 186 | log_print("%s PV %-*s is in EXPORTED VG %s [%s / %s free]", |
9e300c84 AK |
187 | active_str, pv_max_name_len, pv_tmp_name, |
188 | vg_name_this, (s1 = | |
b6c041d7 | 189 | display_size(pv->pe_count * |
9e300c84 AK |
190 | pv->pe_size / 2, |
191 | SIZE_SHORT)), | |
b6c041d7 | 192 | (s2 = display_size((pv->pe_count - pv->pe_allocated) |
9e300c84 AK |
193 | * pv->pe_size / 2, SIZE_SHORT))); |
194 | dbg_free(s1); | |
195 | dbg_free(s2); | |
196 | return; | |
197 | } | |
198 | ||
9e300c84 AK |
199 | sprintf(vg_tmp_name, "%s", pv->vg_name); |
200 | log_print | |
b6c041d7 | 201 | ("%s PV %-*s of VG %-*s [%s / %s free]", active_str, pv_max_name_len, |
9e300c84 | 202 | pv_tmp_name, vg_max_name_len, vg_tmp_name, |
b6c041d7 | 203 | (s1 = display_size(pv->pe_count * pv->pe_size / 2, SIZE_SHORT)), |
9e300c84 | 204 | (s2 = |
b6c041d7 | 205 | display_size((pv->pe_count - pv->pe_allocated) * pv->pe_size / 2, |
9e300c84 AK |
206 | SIZE_SHORT))); |
207 | dbg_free(s1); | |
208 | dbg_free(s2); | |
209 | ||
210 | return; | |
211 | } |