btrfs-progs: send-dump: add missing newlines
[platform/upstream/btrfs-progs.git] / send-dump.c
1 /*
2  * Copyright (C) 2016 Fujitsu.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program.
15  */
16
17 #include <unistd.h>
18 #include <stdint.h>
19 #include <dirent.h>
20 #include <pthread.h>
21 #include <math.h>
22 #include <sys/types.h>
23 #include <sys/stat.h>
24 #include <fcntl.h>
25 #include <sys/ioctl.h>
26 #include <libgen.h>
27 #include <mntent.h>
28 #include <limits.h>
29 #include <stdlib.h>
30 #include <time.h>
31 #include <ctype.h>
32 #include <asm/types.h>
33 #include <uuid/uuid.h>
34 #include "utils.h"
35 #include "commands.h"
36 #include "send-utils.h"
37 #include "send-stream.h"
38 #include "send-dump.h"
39
40 #define PATH_CAT_OR_RET(function_name, outpath, path1, path2, ret)      \
41 ({                                                                      \
42         ret = path_cat_out(outpath, path1, path2);                      \
43         if (ret < 0) {                                                  \
44                 error("%s: path invalid: %s\n", function_name, path2);  \
45                 return ret;                                             \
46         }                                                               \
47 })
48
49 /*
50  * Print path and escape chaacters (in a C way) that could break the line.
51  * Returns the length of the escaped characters. Unprintable characters are
52  * escaped as octals.
53  */
54 static int print_path_escaped(const char *path)
55 {
56         size_t i;
57         size_t path_len = strlen(path);
58         int len = 0;
59
60         for (i = 0; i < path_len; i++) {
61                 char c = path[i];
62
63                 len++;
64                 switch (c) {
65                 case '\a': putchar('\\'); putchar('a'); len++; break;
66                 case '\b': putchar('\\'); putchar('b'); len++; break;
67                 case '\e': putchar('\\'); putchar('e'); len++; break;
68                 case '\f': putchar('\\'); putchar('f'); len++; break;
69                 case '\n': putchar('\\'); putchar('n'); len++; break;
70                 case '\r': putchar('\\'); putchar('r'); len++; break;
71                 case '\t': putchar('\\'); putchar('t'); len++; break;
72                 case '\v': putchar('\\'); putchar('v'); len++; break;
73                 case ' ':  putchar('\\'); putchar(' '); len++; break;
74                 case '\\': putchar('\\'); putchar('\\'); len++; break;
75                 default:
76                           if (!isprint(c)) {
77                                   printf("\\%c%c%c",
78                                                   '0' + ((c & 0300) >> 6),
79                                                   '0' + ((c & 070) >> 3),
80                                                   '0' + (c & 07));
81                                   len += 3;
82                           } else {
83                                   putchar(c);
84                           }
85                 }
86         }
87         return len;
88 }
89
90 /*
91  * Underlying PRINT_DUMP, the only difference is how we handle
92  * the full path.
93  */
94 __attribute__ ((format (printf, 5, 6)))
95 static int __print_dump(int subvol, void *user, const char *path,
96                         const char *title, const char *fmt, ...)
97 {
98         struct btrfs_dump_send_args *r = user;
99         char full_path[PATH_MAX] = {0};
100         char *out_path;
101         va_list args;
102         int ret;
103
104         if (subvol) {
105                 PATH_CAT_OR_RET(title, r->full_subvol_path, r->root_path, path, ret);
106                 out_path = r->full_subvol_path;
107         } else {
108                 PATH_CAT_OR_RET(title, full_path, r->full_subvol_path, path, ret);
109                 out_path = full_path;
110         }
111
112         /* Unified header */
113         printf("%-16s", title);
114         ret = print_path_escaped(out_path);
115         if (!fmt) {
116                 putchar('\n');
117                 return 0;
118         }
119         /* Short paths ale aligned to 32 chars */
120         while (ret++ < 32)
121                 putchar(' ');
122         va_start(args, fmt);
123         /* Operation specified ones */
124         vprintf(fmt, args);
125         va_end(args);
126         putchar('\n');
127         return 0;
128 }
129
130 /* For subvolume/snapshot operation only */
131 #define PRINT_DUMP_SUBVOL(user, path, title, fmt, ...) \
132         __print_dump(1, user, path, title, fmt, ##__VA_ARGS__)
133
134 /* For other operations */
135 #define PRINT_DUMP(user, path, title, fmt, ...) \
136         __print_dump(0, user, path, title, fmt, ##__VA_ARGS__)
137
138 static int print_subvol(const char *path, const u8 *uuid, u64 ctransid,
139                         void *user)
140 {
141         char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
142
143         uuid_unparse(uuid, uuid_str);
144
145         return PRINT_DUMP_SUBVOL(user, path, "subvol", "uuid=%s transid=%llu",
146                                  uuid_str, ctransid);
147 }
148
149 static int print_snapshot(const char *path, const u8 *uuid, u64 ctransid,
150                           const u8 *parent_uuid, u64 parent_ctransid,
151                           void *user)
152 {
153         char uuid_str[BTRFS_UUID_UNPARSED_SIZE];
154         char parent_uuid_str[BTRFS_UUID_UNPARSED_SIZE];
155         int ret;
156
157         uuid_unparse(uuid, uuid_str);
158         uuid_unparse(parent_uuid, parent_uuid_str);
159
160         ret = PRINT_DUMP_SUBVOL(user, path, "snapshot",
161                 "uuid=%s transid=%llu parent_uuid=%s parent_transid=%llu",
162                                 uuid_str, ctransid, parent_uuid_str,
163                                 parent_ctransid);
164         return ret;
165 }
166
167 static int print_mkfile(const char *path, void *user)
168 {
169         return PRINT_DUMP(user, path, "mkfile", NULL);
170 }
171
172 static int print_mkdir(const char *path, void *user)
173 {
174         return PRINT_DUMP(user, path, "mkdir", NULL);
175 }
176
177 static int print_mknod(const char *path, u64 mode, u64 dev, void *user)
178 {
179         return PRINT_DUMP(user, path, "mknod", "mode=%llo dev=0x%llx", mode,
180                           dev);
181 }
182
183 static int print_mkfifo(const char *path, void *user)
184 {
185         return PRINT_DUMP(user, path, "mkfifo", NULL);
186 }
187
188 static int print_mksock(const char *path, void *user)
189 {
190         return PRINT_DUMP(user, path, "mksock", NULL);
191 }
192
193 static int print_symlink(const char *path, const char *lnk, void *user)
194 {
195         return PRINT_DUMP(user, path, "symlink", "dest=%s", lnk);
196 }
197
198 static int print_rename(const char *from, const char *to, void *user)
199 {
200         struct btrfs_dump_send_args *r = user;
201         char full_to[PATH_MAX];
202         int ret;
203
204         PATH_CAT_OR_RET("rename", full_to, r->full_subvol_path, to, ret);
205         return PRINT_DUMP(user, from, "rename", "dest=%s", full_to);
206 }
207
208 static int print_link(const char *path, const char *lnk, void *user)
209 {
210         return PRINT_DUMP(user, path, "link", "dest=%s", lnk);
211 }
212
213 static int print_unlink(const char *path, void *user)
214 {
215         return PRINT_DUMP(user, path, "unlink", NULL);
216 }
217
218 static int print_rmdir(const char *path, void *user)
219 {
220         return PRINT_DUMP(user, path, "rmdir", NULL);
221 }
222
223 static int print_write(const char *path, const void *data, u64 offset,
224                        u64 len, void *user)
225 {
226         return PRINT_DUMP(user, path, "write", "offset=%llu len=%llu",
227                           offset, len);
228 }
229
230 static int print_clone(const char *path, u64 offset, u64 len,
231                        const u8 *clone_uuid, u64 clone_ctransid,
232                        const char *clone_path, u64 clone_offset,
233                        void *user)
234 {
235         struct btrfs_dump_send_args *r = user;
236         char full_path[PATH_MAX];
237         int ret;
238
239         PATH_CAT_OR_RET("clone", full_path, r->full_subvol_path, clone_path,
240                         ret);
241         return PRINT_DUMP(user, path, "clone",
242                           "offset=%llu len=%llu from=%s clone_offset=%llu",
243                           offset, len, full_path, clone_offset);
244 }
245
246 static int print_set_xattr(const char *path, const char *name,
247                            const void *data, int len, void *user)
248 {
249         return PRINT_DUMP(user, path, "set_xattr", "name=%s data=%.*s len=%d",
250                           name, len, (char *)data, len);
251 }
252
253 static int print_remove_xattr(const char *path, const char *name, void *user)
254 {
255
256         return PRINT_DUMP(user, path, "remove_xattr", "name=%s", name);
257 }
258
259 static int print_truncate(const char *path, u64 size, void *user)
260 {
261         return PRINT_DUMP(user, path, "truncate", "size=%llu", size);
262 }
263
264 static int print_chmod(const char *path, u64 mode, void *user)
265 {
266         return PRINT_DUMP(user, path, "chmod", "mode=%llo", mode);
267 }
268
269 static int print_chown(const char *path, u64 uid, u64 gid, void *user)
270 {
271         return PRINT_DUMP(user, path, "chown", "gid=%llu uid=%llu", gid, uid);
272 }
273
274 static int sprintf_timespec(struct timespec *ts, char *dest, int max_size)
275 {
276         struct tm tm;
277         int ret;
278
279         if (!localtime_r(&ts->tv_sec, &tm)) {
280                 error("failed to convert time %lld.%.9ld to local time",
281                       (long long)ts->tv_sec, ts->tv_nsec);
282                 return -EINVAL;
283         }
284         ret = strftime(dest, max_size, "%FT%T%z", &tm);
285         if (ret == 0) {
286                 error(
287                 "time %lld.%ld is too long to convert into readable string",
288                       (long long)ts->tv_sec, ts->tv_nsec);
289                 return -EINVAL;
290         }
291         return 0;
292 }
293
294 #define TIME_STRING_MAX 64
295 static int print_utimes(const char *path, struct timespec *at,
296                         struct timespec *mt, struct timespec *ct,
297                         void *user)
298 {
299         char at_str[TIME_STRING_MAX];
300         char mt_str[TIME_STRING_MAX];
301         char ct_str[TIME_STRING_MAX];
302
303         if (sprintf_timespec(at, at_str, TIME_STRING_MAX - 1) < 0 ||
304             sprintf_timespec(mt, mt_str, TIME_STRING_MAX - 1) < 0 ||
305             sprintf_timespec(ct, ct_str, TIME_STRING_MAX - 1) < 0)
306                 return -EINVAL;
307         return PRINT_DUMP(user, path, "utimes", "atime=%s mtime=%s ctime=%s",
308                           at_str, mt_str, ct_str);
309 }
310
311 static int print_update_extent(const char *path, u64 offset, u64 len,
312                                void *user)
313 {
314         return PRINT_DUMP(user, path, "update_extent", "offset=%llu len=%llu",
315                           offset, len);
316 }
317
318 struct btrfs_send_ops btrfs_print_send_ops = {
319         .subvol = print_subvol,
320         .snapshot = print_snapshot,
321         .mkfile = print_mkfile,
322         .mkdir = print_mkdir,
323         .mknod = print_mknod,
324         .mkfifo = print_mkfifo,
325         .mksock = print_mksock,
326         .symlink = print_symlink,
327         .rename = print_rename,
328         .link = print_link,
329         .unlink = print_unlink,
330         .rmdir = print_rmdir,
331         .write = print_write,
332         .clone = print_clone,
333         .set_xattr = print_set_xattr,
334         .remove_xattr = print_remove_xattr,
335         .truncate = print_truncate,
336         .chmod = print_chmod,
337         .chown = print_chown,
338         .utimes = print_utimes,
339         .update_extent = print_update_extent
340 };