Version 1.10.6.
[libguestfs.git] / daemon / ext2.c
1 /* libguestfs - the guestfsd daemon
2  * Copyright (C) 2009 Red Hat Inc.
3  *
4  * This program 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 of the License, or
7  * (at your option) any later version.
8  *
9  * This program 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 this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 #include <config.h>
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <inttypes.h>
24 #include <string.h>
25 #include <unistd.h>
26
27 #include "guestfs_protocol.h"
28 #include "daemon.h"
29 #include "c-ctype.h"
30 #include "actions.h"
31
32 /* Confirmed this is true up to ext4 from the Linux sources. */
33 #define EXT2_LABEL_MAX 16
34
35 /* Choose which tools like mke2fs to use.  For RHEL 5 (only) there
36  * is a special set of tools which support ext2/3/4.  eg. On RHEL 5,
37  * mke2fs only supports ext2/3, but mke4fs supports ext2/3/4.
38  *
39  * We specify e4fsprogs in the package list to ensure it is loaded
40  * if it exists.
41  */
42 int
43 e2prog (char *name)
44 {
45   char *p = strstr (name, "e2");
46   if (!p) return 0;
47   p++;
48
49   *p = '4';
50   if (prog_exists (name))
51     return 0;
52
53   *p = '2';
54   if (prog_exists (name))
55     return 0;
56
57   reply_with_error ("cannot find required program %s", name);
58   return -1;
59 }
60
61 char **
62 do_tune2fs_l (const char *device)
63 {
64   int r;
65   char *out, *err;
66   char *p, *pend, *colon;
67   char **ret = NULL;
68   int size = 0, alloc = 0;
69
70   char prog[] = "tune2fs";
71   if (e2prog (prog) == -1)
72     return NULL;
73
74   r = command (&out, &err, prog, "-l", device, NULL);
75   if (r == -1) {
76     reply_with_error ("%s", err);
77     free (err);
78     free (out);
79     return NULL;
80   }
81   free (err);
82
83   p = out;
84
85   /* Discard the first line if it contains "tune2fs ...". */
86   if (STRPREFIX (p, "tune2fs ") || STRPREFIX (p, "tune4fs ")) {
87     p = strchr (p, '\n');
88     if (p) p++;
89     else {
90       reply_with_error ("truncated output");
91       free (out);
92       return NULL;
93     }
94   }
95
96   /* Read the lines and split into "key: value". */
97   while (*p) {
98     pend = strchrnul (p, '\n');
99     if (*pend == '\n') {
100       *pend = '\0';
101       pend++;
102     }
103
104     if (!*p) continue;
105
106     colon = strchr (p, ':');
107     if (colon) {
108       *colon = '\0';
109
110       do { colon++; } while (*colon && c_isspace (*colon));
111
112       if (add_string (&ret, &size, &alloc, p) == -1) {
113         free (out);
114         return NULL;
115       }
116       if (STREQ (colon, "<none>") ||
117           STREQ (colon, "<not available>") ||
118           STREQ (colon, "(none)")) {
119         if (add_string (&ret, &size, &alloc, "") == -1) {
120           free (out);
121           return NULL;
122         }
123       } else {
124         if (add_string (&ret, &size, &alloc, colon) == -1) {
125           free (out);
126           return NULL;
127         }
128       }
129     }
130     else {
131       if (add_string (&ret, &size, &alloc, p) == -1) {
132         free (out);
133         return NULL;
134       }
135       if (add_string (&ret, &size, &alloc, "") == -1) {
136         free (out);
137         return NULL;
138       }
139     }
140
141     p = pend;
142   }
143
144   free (out);
145
146   if (add_string (&ret, &size, &alloc, NULL) == -1)
147     return NULL;
148
149   return ret;
150 }
151
152 int
153 do_set_e2label (const char *device, const char *label)
154 {
155   int r;
156   char *err;
157
158   char prog[] = "e2label";
159   if (e2prog (prog) == -1)
160     return -1;
161
162   if (strlen (label) > EXT2_LABEL_MAX) {
163     reply_with_error ("%s: ext2 labels are limited to %d bytes",
164                       label, EXT2_LABEL_MAX);
165     return -1;
166   }
167
168   r = command (NULL, &err, prog, device, label, NULL);
169   if (r == -1) {
170     reply_with_error ("%s", err);
171     free (err);
172     return -1;
173   }
174
175   free (err);
176   return 0;
177 }
178
179 char *
180 do_get_e2label (const char *device)
181 {
182   return do_vfs_label (device);
183 }
184
185 int
186 do_set_e2uuid (const char *device, const char *uuid)
187 {
188   int r;
189   char *err;
190
191   char prog[] = "tune2fs";
192   if (e2prog (prog) == -1)
193     return -1;
194
195   r = command (NULL, &err, prog, "-U", uuid, device, NULL);
196   if (r == -1) {
197     reply_with_error ("%s", err);
198     free (err);
199     return -1;
200   }
201
202   free (err);
203   return 0;
204 }
205
206 char *
207 do_get_e2uuid (const char *device)
208 {
209   return do_vfs_uuid (device);
210 }
211
212 int
213 do_resize2fs (const char *device)
214 {
215   char *err;
216   int r;
217
218   char prog[] = "resize2fs";
219   if (e2prog (prog) == -1)
220     return -1;
221
222   r = command (NULL, &err, prog, device, NULL);
223   if (r == -1) {
224     reply_with_error ("%s", err);
225     free (err);
226     return -1;
227   }
228
229   free (err);
230   return 0;
231 }
232
233 int
234 do_resize2fs_size (const char *device, int64_t size)
235 {
236   char *err;
237   int r;
238
239   char prog[] = "resize2fs";
240   if (e2prog (prog) == -1)
241     return -1;
242
243   /* resize2fs itself may impose additional limits.  Since we are
244    * going to use the 'K' suffix however we can only work with whole
245    * kilobytes.
246    */
247   if (size & 1023) {
248     reply_with_error ("%" PRIi64 ": size must be a round number of kilobytes",
249                       size);
250     return -1;
251   }
252   size /= 1024;
253
254   char buf[32];
255   snprintf (buf, sizeof buf, "%" PRIi64 "K", size);
256
257   r = command (NULL, &err, prog, device, buf, NULL);
258   if (r == -1) {
259     reply_with_error ("%s", err);
260     free (err);
261     return -1;
262   }
263
264   free (err);
265   return 0;
266 }
267
268 int
269 do_resize2fs_M (const char *device)
270 {
271   char *err;
272   int r;
273
274   char prog[] = "resize2fs";
275   if (e2prog (prog) == -1)
276     return -1;
277
278   r = command (NULL, &err, prog, "-M" , device, NULL);
279   if (r == -1) {
280     reply_with_error ("%s", err);
281     free (err);
282     return -1;
283   }
284
285   free (err);
286   return 0;
287 }
288
289 int
290 do_e2fsck_f (const char *device)
291 {
292   char *err;
293   int r;
294
295   char prog[] = "e2fsck";
296   if (e2prog (prog) == -1)
297     return -1;
298
299   /* 0 = no errors, 1 = errors corrected.
300    *
301    * >= 4 means uncorrected or other errors.
302    *
303    * 2, 3 means errors were corrected and we require a reboot.  This is
304    * a difficult corner case.
305    */
306   r = commandr (NULL, &err, prog, "-p", "-f", device, NULL);
307   if (r == -1 || r >= 2) {
308     reply_with_error ("%s", err);
309     free (err);
310     return -1;
311   }
312
313   free (err);
314   return 0;
315 }
316
317 int
318 do_mke2journal (int blocksize, const char *device)
319 {
320   char *err;
321   int r;
322
323   char prog[] = "mke2fs";
324   if (e2prog (prog) == -1)
325     return -1;
326
327   char blocksize_s[32];
328   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
329
330   r = command (NULL, &err,
331                prog, "-O", "journal_dev", "-b", blocksize_s,
332                device, NULL);
333   if (r == -1) {
334     reply_with_error ("%s", err);
335     free (err);
336     return -1;
337   }
338
339   free (err);
340   return 0;
341 }
342
343 int
344 do_mke2journal_L (int blocksize, const char *label, const char *device)
345 {
346   char *err;
347   int r;
348
349   char prog[] = "mke2fs";
350   if (e2prog (prog) == -1)
351     return -1;
352
353   if (strlen (label) > EXT2_LABEL_MAX) {
354     reply_with_error ("%s: ext2 labels are limited to %d bytes",
355                       label, EXT2_LABEL_MAX);
356     return -1;
357   }
358
359   char blocksize_s[32];
360   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
361
362   r = command (NULL, &err,
363                prog, "-O", "journal_dev", "-b", blocksize_s,
364                "-L", label,
365                device, NULL);
366   if (r == -1) {
367     reply_with_error ("%s", err);
368     free (err);
369     return -1;
370   }
371
372   free (err);
373   return 0;
374 }
375
376 int
377 do_mke2journal_U (int blocksize, const char *uuid, const char *device)
378 {
379   char *err;
380   int r;
381
382   char prog[] = "mke2fs";
383   if (e2prog (prog) == -1)
384     return -1;
385
386   char blocksize_s[32];
387   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
388
389   r = command (NULL, &err,
390                prog, "-O", "journal_dev", "-b", blocksize_s,
391                "-U", uuid,
392                device, NULL);
393   if (r == -1) {
394     reply_with_error ("%s", err);
395     free (err);
396     return -1;
397   }
398
399   free (err);
400   return 0;
401 }
402
403 int
404 do_mke2fs_J (const char *fstype, int blocksize, const char *device,
405              const char *journal)
406 {
407   char *err;
408   int r;
409
410   char prog[] = "mke2fs";
411   if (e2prog (prog) == -1)
412     return -1;
413
414   char blocksize_s[32];
415   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
416
417   int len = strlen (journal);
418   char jdev[len+32];
419   snprintf (jdev, len+32, "device=%s", journal);
420
421   r = command (NULL, &err,
422                prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
423                device, NULL);
424   if (r == -1) {
425     reply_with_error ("%s", err);
426     free (err);
427     return -1;
428   }
429
430   free (err);
431   return 0;
432 }
433
434 int
435 do_mke2fs_JL (const char *fstype, int blocksize, const char *device,
436               const char *label)
437 {
438   char *err;
439   int r;
440
441   char prog[] = "mke2fs";
442   if (e2prog (prog) == -1)
443     return -1;
444
445   if (strlen (label) > EXT2_LABEL_MAX) {
446     reply_with_error ("%s: ext2 labels are limited to %d bytes",
447                       label, EXT2_LABEL_MAX);
448     return -1;
449   }
450
451   char blocksize_s[32];
452   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
453
454   int len = strlen (label);
455   char jdev[len+32];
456   snprintf (jdev, len+32, "device=LABEL=%s", label);
457
458   r = command (NULL, &err,
459                prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
460                device, NULL);
461   if (r == -1) {
462     reply_with_error ("%s", err);
463     free (err);
464     return -1;
465   }
466
467   free (err);
468   return 0;
469 }
470
471 int
472 do_mke2fs_JU (const char *fstype, int blocksize, const char *device,
473               const char *uuid)
474 {
475   char *err;
476   int r;
477
478   char prog[] = "mke2fs";
479   if (e2prog (prog) == -1)
480     return -1;
481
482   char blocksize_s[32];
483   snprintf (blocksize_s, sizeof blocksize_s, "%d", blocksize);
484
485   int len = strlen (uuid);
486   char jdev[len+32];
487   snprintf (jdev, len+32, "device=UUID=%s", uuid);
488
489   r = command (NULL, &err,
490                prog, "-t", fstype, "-J", jdev, "-b", blocksize_s,
491                device, NULL);
492   if (r == -1) {
493     reply_with_error ("%s", err);
494     free (err);
495     return -1;
496   }
497
498   free (err);
499   return 0;
500 }