be6eb5cbb535b9d3fd42c65e6297f5737cfe2fb7
[pve-common.git] / src / PVE / AbstractConfig.pm
1 package PVE::AbstractConfig;
2
3 use strict;
4 use warnings;
5
6 use PVE::Tools qw(lock_file lock_file_full);
7 use PVE::INotify;
8
9 my $nodename = PVE::INotify::nodename();
10
11 # Printable string, currently either "VM" or "CT"
12 sub guest_type {
13     my ($class) = @_;
14     die "abstract method - implement me ";
15 }
16
17 sub __config_max_unused_disks {
18     my ($class) = @_;
19
20     die "implement me - abstract method\n";
21 }
22
23 # Path to the flock file for this VM/CT
24 sub config_file_lock {
25     my ($class, $vmid) = @_;
26     die "abstract method - implement me";
27 }
28
29 # Relative config file path for this VM/CT in CFS
30 sub cfs_config_path {
31     my ($class, $vmid, $node) = @_;
32     die "abstract method - implement me";
33 }
34
35 # Absolute config file path for this VM/CT
36 sub config_file {
37     my ($class, $vmid, $node) = @_;
38
39     my $cfspath = $class->cfs_config_path($vmid, $node);
40     return "/etc/pve/$cfspath";
41 }
42
43 # Read and parse config file for this VM/CT
44 sub load_config {
45     my ($class, $vmid, $node) = @_;
46
47     $node = $nodename if !$node;
48     my $cfspath = $class->cfs_config_path($vmid, $node);
49
50     my $conf = PVE::Cluster::cfs_read_file($cfspath);
51     die "Configuration file '$cfspath' does not exist\n"
52         if !defined($conf);
53
54     return $conf;
55 }
56
57 # Generate and write config file for this VM/CT
58 sub write_config {
59     my ($class, $vmid, $conf) = @_;
60
61     my $cfspath = $class->cfs_config_path($vmid);
62
63     PVE::Cluster::cfs_write_file($cfspath, $conf);
64 }
65
66 # Lock config file using flock, run $code with @param, unlock config file.
67 # $timeout is the maximum time to aquire the flock
68 sub lock_config_full {
69     my ($class, $vmid, $timeout, $code, @param) = @_;
70
71     my $filename = $class->config_file_lock($vmid);
72
73     my $res = lock_file($filename, $timeout, $code, @param);
74
75     die $@ if $@;
76
77     return $res;
78 }
79
80 # Lock config file using flock, run $code with @param, unlock config file.
81 # $timeout is the maximum time to aquire the flock
82 # $shared eq 1 creates a non-exclusive ("read") flock
83 sub lock_config_mode {
84     my ($class, $vmid, $timeout, $shared, $code, @param) = @_;
85
86     my $filename = $class->config_file_lock($vmid);
87
88     my $res = lock_file_full($filename, $timeout, $shared, $code, @param);
89
90     die $@ if $@;
91
92     return $res;
93 }
94
95 # Lock config file using flock, run $code with @param, unlock config file.
96 sub lock_config {
97     my ($class, $vmid, $code, @param) = @_;
98
99     return $class->lock_config_full($vmid, 10, $code, @param);
100 }
101
102 # Checks whether the config is locked with the lock parameter
103 sub check_lock {
104     my ($class, $conf) = @_;
105
106     die $class->guest_type()." is locked ($conf->{lock})\n" if $conf->{lock};
107 }
108
109 # Returns whether the config is locked with the lock parameter, also checks
110 # whether the lock value is correct if the optional $lock is set.
111 sub has_lock {
112     my ($class, $conf, $lock) = @_;
113
114     return $conf->{lock} && (!defined($lock) || $lock eq $conf->{lock});
115 }
116
117 # Sets the lock parameter for this VM/CT's config to $lock.
118 sub set_lock {
119     my ($class, $vmid, $lock) = @_;
120
121     my $conf;
122     $class->lock_config($vmid, sub {
123         $conf = $class->load_config($vmid);
124         $class->check_lock($conf);
125         $conf->{lock} = $lock;
126         $class->write_config($vmid, $conf);
127     });
128     return $conf;
129 }
130
131 # Removes the lock parameter for this VM/CT's config, also checks whether
132 # the lock value is correct if the optional $lock is set.
133 sub remove_lock {
134     my ($class, $vmid, $lock) = @_;
135
136     $class->lock_config($vmid, sub {
137         my $conf = $class->load_config($vmid);
138         if (!$conf->{lock}) {
139             die "no lock found trying to remove lock '$lock'\n";
140         } elsif (defined($lock) && $conf->{lock} ne $lock) {
141             die "found lock '$conf->{lock}' trying to remove lock '$lock'\n";
142         }
143         delete $conf->{lock};
144         $class->write_config($vmid, $conf);
145     });
146 }
147
148 # Checks whether protection mode is enabled for this VM/CT.
149 sub check_protection {
150     my ($class, $conf, $err_msg) = @_;
151
152     if ($conf->{protection}) {
153         die "$err_msg - protection mode enabled\n";
154     }
155 }
156
157 # Adds an unused volume to $config, if possible.
158 sub add_unused_volume {
159     my ($class, $config, $volid) = @_;
160
161     my $key;
162     for (my $ind = $class->__config_max_unused_disks() - 1; $ind >= 0; $ind--) {
163         my $test = "unused$ind";
164         if (my $vid = $config->{$test}) {
165             return if $vid eq $volid; # do not add duplicates
166         } else {
167             $key = $test;
168         }
169     }
170
171     die "Too many unused volumes - please delete them first.\n" if !$key;
172
173     $config->{$key} = $volid;
174
175     return $key;
176 }
177
178 # Returns whether the template parameter is set in $conf.
179 sub is_template {
180     my ($class, $conf) = @_;
181
182     return 1 if defined $conf->{template} && $conf->{template} == 1;
183 }
184
185 # Checks whether $feature is availabe for the referenced volumes in $conf.
186 # Note: depending on the parameters, some volumes may be skipped!
187 sub has_feature {
188     my ($class, $feature, $conf, $storecfg, $snapname, $running, $backup_only) = @_;
189     die "implement me - abstract method\n";
190 }
191
192 # Internal snapshots
193
194 # NOTE: Snapshot create/delete involves several non-atomic
195 # actions, and can take a long time.
196 # So we try to avoid locking the file and use the 'lock' variable
197 # inside the config file instead.
198
199 # Save the vmstate (RAM).
200 sub __snapshot_save_vmstate {
201     my ($class, $vmid, $conf, $snapname, $storecfg) = @_;
202     die "implement me - abstract method\n";
203 }
204
205 # Check whether the VM/CT is running.
206 sub __snapshot_check_running {
207     my ($class, $vmid) = @_;
208     die "implement me - abstract method\n";
209 }
210
211 # Check whether we need to freeze the VM/CT
212 sub __snapshot_check_freeze_needed {
213     my ($sself, $vmid, $config, $save_vmstate) = @_;
214     die "implement me - abstract method\n";
215 }
216
217 # Freeze or unfreeze the VM/CT.
218 sub __snapshot_freeze {
219     my ($class, $vmid, $unfreeze) = @_;
220
221     die "abstract method - implement me\n";
222 }
223
224 # Create the volume snapshots for the VM/CT.
225 sub __snapshot_create_vol_snapshot {
226     my ($class, $vmid, $vs, $volume, $snapname) = @_;
227
228     die "abstract method - implement me\n";
229 }
230
231 # Remove a drive from the snapshot config.
232 sub __snapshot_delete_remove_drive {
233     my ($class, $snap, $remove_drive) = @_;
234
235     die "abstract method - implement me\n";
236 }
237
238 # Delete the vmstate file/drive
239 sub __snapshot_delete_vmstate_file {
240     my ($class, $snap, $force) = @_;
241
242     die "abstract method - implement me\n";
243 }
244
245 # Delete a volume snapshot
246 sub __snapshot_delete_vol_snapshot {
247     my ($class, $vmid, $vs, $volume, $snapname) = @_;
248
249     die "abstract method - implement me\n";
250 }
251
252 # Checks whether a volume snapshot is possible for this volume.
253 sub __snapshot_rollback_vol_possible {
254     my ($class, $volume, $snapname) = @_;
255
256     die "abstract method - implement me\n";
257 }
258
259 # Rolls back this volume.
260 sub __snapshot_rollback_vol_rollback {
261     my ($class, $volume, $snapname) = @_;
262
263     die "abstract method - implement me\n";
264 }
265
266 # Stops the VM/CT for a rollback.
267 sub __snapshot_rollback_vm_stop {
268     my ($class, $vmid) = @_;
269
270     die "abstract method - implement me\n";
271 }
272
273 # Start the VM/CT after a rollback with restored vmstate.
274 sub __snapshot_rollback_vm_start {
275     my ($class, $vmid, $vmstate, $forcemachine);
276
277     die "abstract method - implement me\n";
278 }
279
280 # Iterate over all configured volumes, calling $func for each key/value pair.
281 sub __snapshot_foreach_volume {
282     my ($class, $conf, $func) = @_;
283
284     die "abstract method - implement me\n";
285 }
286
287 # Copy the current config $source to the snapshot config $dest
288 sub __snapshot_copy_config {
289     my ($class, $source, $dest) = @_;
290
291     foreach my $k (keys %$source) {
292         next if $k eq 'snapshots';
293         next if $k eq 'snapstate';
294         next if $k eq 'snaptime';
295         next if $k eq 'vmstate';
296         next if $k eq 'lock';
297         next if $k eq 'digest';
298         next if $k eq 'description';
299         next if $k =~ m/^unused\d+$/;
300
301         $dest->{$k} = $source->{$k};
302     }
303 };
304
305 # Apply the snapshot config $snap to the config $conf (rollback)
306 sub __snapshot_apply_config {
307     my ($class, $conf, $snap) = @_;
308
309     # copy snapshot list
310     my $newconf = {
311         snapshots => $conf->{snapshots},
312     };
313
314     # keep description and list of unused disks
315     foreach my $k (keys %$conf) {
316         next if !($k =~ m/^unused\d+$/ || $k eq 'description');
317         $newconf->{$k} = $conf->{$k};
318     }
319
320     $class->__snapshot_copy_config($snap, $newconf);
321
322     return $newconf;
323 }
324
325 # Prepares the configuration for snapshotting.
326 sub __snapshot_prepare {
327     my ($class, $vmid, $snapname, $save_vmstate, $comment) = @_;
328
329     my $snap;
330
331     my $updatefn =  sub {
332
333         my $conf = $class->load_config($vmid);
334
335         die "you can't take a snapshot if it's a template\n"
336             if $class->is_template($conf);
337
338         $class->check_lock($conf);
339
340         $conf->{lock} = 'snapshot';
341
342         die "snapshot name '$snapname' already used\n"
343             if defined($conf->{snapshots}->{$snapname});
344
345         my $storecfg = PVE::Storage::config();
346         die "snapshot feature is not available\n"
347             if !$class->has_feature('snapshot', $conf, $storecfg, undef, undef, $snapname eq 'vzdump');
348
349         $snap = $conf->{snapshots}->{$snapname} = {};
350
351         if ($save_vmstate && $class->__snapshot_check_running($vmid)) {
352             $class->__snapshot_save_vmstate($vmid, $conf, $snapname, $storecfg);
353         }
354
355         $class->__snapshot_copy_config($conf, $snap);
356
357         $snap->{snapstate} = "prepare";
358         $snap->{snaptime} = time();
359         $snap->{description} = $comment if $comment;
360
361         $class->write_config($vmid, $conf);
362     };
363
364     $class->lock_config($vmid, $updatefn);
365
366     return $snap;
367 }
368
369 # Commits the configuration after snapshotting.
370 sub __snapshot_commit {
371     my ($class, $vmid, $snapname) = @_;
372
373     my $updatefn = sub {
374
375         my $conf = $class->load_config($vmid);
376
377         die "missing snapshot lock\n"
378             if !($conf->{lock} && $conf->{lock} eq 'snapshot');
379
380         my $snap = $conf->{snapshots}->{$snapname};
381         die "snapshot '$snapname' does not exist\n" if !defined($snap);
382
383         die "wrong snapshot state\n"
384             if !($snap->{snapstate} && $snap->{snapstate} eq "prepare");
385
386         delete $snap->{snapstate};
387         delete $conf->{lock};
388
389         $conf->{parent} = $snapname;
390
391         $class->write_config($vmid, $conf);
392     };
393
394     $class->lock_config($vmid, $updatefn);
395 }
396
397 # Creates a snapshot for the VM/CT.
398 sub snapshot_create {
399     my ($class, $vmid, $snapname, $save_vmstate, $comment) = @_;
400
401     my $snap = $class->__snapshot_prepare($vmid, $snapname, $save_vmstate, $comment);
402
403     $save_vmstate = 0 if !$snap->{vmstate};
404
405     my $conf = $class->load_config($vmid);
406
407     my ($running, $freezefs) = $class->__snapshot_check_freeze_needed($vmid, $conf, $snap->{vmstate});
408
409     my $drivehash = {};
410
411     eval {
412         if ($freezefs) {
413             $class->__snapshot_freeze($vmid, 0);
414         }
415
416         $class->__snapshot_foreach_volume($snap, sub {
417             my ($vs, $volume) = @_;
418
419             $class->__snapshot_create_vol_snapshot($vmid, $vs, $volume, $snapname);
420             $drivehash->{$vs} = 1;
421         });
422     };
423     my $err = $@;
424
425     if ($running) {
426         if ($freezefs) {
427             $class->__snapshot_freeze($vmid, 1);
428         }
429     }
430
431     if ($err) {
432         warn "snapshot create failed: starting cleanup\n";
433         eval { $class->snapshot_delete($vmid, $snapname, 1, $drivehash); };
434         warn "$@" if $@;
435         die "$err\n";
436     }
437
438     $class->__snapshot_commit($vmid, $snapname);
439 }
440
441 # Deletes a snapshot.
442 # Note: $drivehash is only set when called from snapshot_create.
443 sub snapshot_delete {
444     my ($class, $vmid, $snapname, $force, $drivehash) = @_;
445
446     my $prepare = 1;
447
448     my $snap;
449     my $unused = [];
450
451     my $unlink_parent = sub {
452         my ($confref, $new_parent) = @_;
453
454         if ($confref->{parent} && $confref->{parent} eq $snapname) {
455             if ($new_parent) {
456                 $confref->{parent} = $new_parent;
457             } else {
458                 delete $confref->{parent};
459             }
460         }
461     };
462
463     my $updatefn =  sub {
464         my ($remove_drive) = @_;
465
466         my $conf = $class->load_config($vmid);
467
468         if (!$drivehash) {
469             $class->check_lock($conf);
470             die "you can't delete a snapshot if vm is a template\n"
471                 if $class->is_template($conf);
472         }
473
474         $snap = $conf->{snapshots}->{$snapname};
475
476         die "snapshot '$snapname' does not exist\n" if !defined($snap);
477
478         # remove parent refs
479         if (!$prepare) {
480             &$unlink_parent($conf, $snap->{parent});
481             foreach my $sn (keys %{$conf->{snapshots}}) {
482                 next if $sn eq $snapname;
483                 &$unlink_parent($conf->{snapshots}->{$sn}, $snap->{parent});
484             }
485         }
486
487         if ($remove_drive) {
488             $class->__snapshot_delete_remove_drive($snap, $remove_drive);
489         }
490
491         if ($prepare) {
492             $snap->{snapstate} = 'delete';
493         } else {
494             delete $conf->{snapshots}->{$snapname};
495             delete $conf->{lock} if $drivehash;
496             foreach my $volid (@$unused) {
497                 $class->add_unused_volume($conf, $volid);
498             }
499         }
500
501         $class->write_config($vmid, $conf);
502     };
503
504     $class->lock_config($vmid, $updatefn);
505
506     # now remove vmstate file
507     if ($snap->{vmstate}) {
508         $class->__snapshot_delete_vmstate_file($snap, $force);
509
510         # save changes (remove vmstate from snapshot)
511         $class->lock_config($vmid, $updatefn, 'vmstate') if !$force;
512     };
513
514     # now remove all volume snapshots
515     $class->__snapshot_foreach_volume($snap, sub {
516         my ($vs, $volume) = @_;
517
518         return if $snapname eq 'vzdump' && $vs ne 'rootfs' && !$volume->{backup};
519         if (!$drivehash || $drivehash->{$vs}) {
520             eval { $class->__snapshot_delete_vol_snapshot($vmid, $vs, $volume, $snapname); };
521             if (my $err = $@) {
522                 die $err if !$force;
523                 warn $err;
524             }
525         }
526
527         # save changes (remove mp from snapshot)
528         $class->lock_config($vmid, $updatefn, $vs) if !$force;
529         push @$unused, $volume->{volume};
530     });
531
532     # now cleanup config
533     $prepare = 0;
534     $class->lock_config($vmid, $updatefn);
535 }
536
537 # Rolls back to a given snapshot.
538 sub snapshot_rollback {
539     my ($class, $vmid, $snapname) = @_;
540
541     my $prepare = 1;
542
543     my $storecfg = PVE::Storage::config();
544
545     my $conf = $class->load_config($vmid);
546
547     my $get_snapshot_config = sub {
548
549         die "you can't rollback if vm is a template\n" if $class->is_template($conf);
550
551         my $res = $conf->{snapshots}->{$snapname};
552
553         die "snapshot '$snapname' does not exist\n" if !defined($res);
554
555         return $res;
556     };
557
558     my $snap = &$get_snapshot_config();
559
560     $class->__snapshot_foreach_volume($snap, sub {
561         my ($vs, $volume) = @_;
562
563         $class->__snapshot_rollback_vol_possible($volume, $snapname);
564     });
565
566     my $updatefn = sub {
567
568         $conf = $class->load_config($vmid);
569
570         $snap = &$get_snapshot_config();
571
572         die "unable to rollback to incomplete snapshot (snapstate = $snap->{snapstate})\n"
573             if $snap->{snapstate};
574
575         if ($prepare) {
576             $class->check_lock($conf);
577             $class->__snapshot_rollback_vm_stop($vmid);
578         }
579
580         die "unable to rollback vm $vmid: vm is running\n"
581             if $class->__snapshot_check_running($vmid);
582
583         if ($prepare) {
584             $conf->{lock} = 'rollback';
585         } else {
586             die "got wrong lock\n" if !($conf->{lock} && $conf->{lock} eq 'rollback');
587             delete $conf->{lock};
588         }
589
590         # machine only relevant for Qemu
591         my $forcemachine;
592
593         if (!$prepare) {
594             my $has_machine_config = defined($conf->{machine});
595
596             # copy snapshot config to current config
597             $conf = $class->__snapshot_apply_config($conf, $snap);
598             $conf->{parent} = $snapname;
599
600             # Note: old code did not store 'machine', so we try to be smart
601             # and guess the snapshot was generated with kvm 1.4 (pc-i440fx-1.4).
602             $forcemachine = $conf->{machine} || 'pc-i440fx-1.4';
603             # we remove the 'machine' configuration if not explicitly specified
604             # in the original config.
605             delete $conf->{machine} if $snap->{vmstate} && !$has_machine_config;
606         }
607
608         $class->write_config($vmid, $conf);
609
610         if (!$prepare && $snap->{vmstate}) {
611             $class->__snapshot_rollback_vm_start($vmid, $snap->{vmstate}, $forcemachine);
612         }
613     };
614
615     $class->lock_config($vmid, $updatefn);
616
617     $class->__snapshot_foreach_volume($snap, sub {
618         my ($vs, $volume) = @_;
619
620         $class->__snapshot_rollback_vol_rollback($volume, $snapname);
621     });
622
623     $prepare = 0;
624     $class->lock_config($vmid, $updatefn);
625 }
626
627 1;