btrfs-progs: Use fs_info instead of root for BTRFS_LEAF_DATA_SIZE
[platform/upstream/btrfs-progs.git] / convert / source-reiserfs.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public
4  * License v2 as published by the Free Software Foundation.
5  *
6  * This program is distributed in the hope that it will be useful,
7  * but WITHOUT ANY WARRANTY; without even the implied warranty of
8  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
9  * General Public License for more details.
10  *
11  * You should have received a copy of the GNU General Public
12  * License along with this program; if not, write to the
13  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
14  * Boston, MA 021110-1307, USA.
15  */
16
17 #if BTRFSCONVERT_REISERFS
18
19 #include "kerncompat.h"
20 #include <linux/limits.h>
21 #include <linux/fs.h>
22 #include <limits.h>
23 #include <sys/stat.h>
24 #include <stdbool.h>
25 #include "disk-io.h"
26 #include "transaction.h"
27 #include "utils.h"
28 #include "bitops.h"
29 #include "convert/common.h"
30 #include "convert/source-reiserfs.h"
31
32 static inline u8 mode_to_file_type(u32 mode)
33 {
34         switch (mode & S_IFMT) {
35         case S_IFREG:   return BTRFS_FT_REG_FILE;
36         case S_IFDIR:   return BTRFS_FT_DIR;
37         case S_IFCHR:   return BTRFS_FT_CHRDEV;
38         case S_IFBLK:   return BTRFS_FT_BLKDEV;
39         case S_IFIFO:   return BTRFS_FT_FIFO;
40         case S_IFSOCK:  return BTRFS_FT_SOCK;
41         case S_IFLNK:   return BTRFS_FT_SYMLINK;
42         };
43
44         return BTRFS_FT_UNKNOWN;
45 }
46
47 static u32 reiserfs_count_objectids(reiserfs_filsys_t fs)
48 {
49         struct reiserfs_super_block *sb = fs->fs_ondisk_sb;
50         u32 count = 0;
51         u32 *map;
52         int i;
53
54         if (fs->fs_format == REISERFS_FORMAT_3_6)
55                 map = (u32 *) (sb + 1);
56         else
57                 map = (u32 *)((struct reiserfs_super_block_v1 *)sb + 1);
58
59         for (i = 0; i < get_sb_oid_cursize(sb); i += 2)
60                 count += le32_to_cpu(map[i + 1]) - (le32_to_cpu(map[i]) + 1);
61
62         return count;
63 }
64
65
66 static int reiserfs_open_fs(struct btrfs_convert_context *cxt, const char *name)
67 {
68         struct reiserfs_convert_info *info;
69         reiserfs_filsys_t fs;
70         long error;
71
72         fs = reiserfs_open(name, O_RDONLY, &error, NULL, 0);
73         if (!fs)
74                 return -1;
75
76         error = reiserfs_open_ondisk_bitmap(fs);
77         if (error) {
78                 reiserfs_close(fs);
79                 return -1;
80         }
81
82         cxt->fs_data = fs;
83         cxt->blocksize = fs->fs_blocksize;
84         cxt->block_count = get_sb_block_count(fs->fs_ondisk_sb);
85         cxt->total_bytes = cxt->blocksize * cxt->block_count;
86         cxt->volume_name = strndup(fs->fs_ondisk_sb->s_label, 16);
87         cxt->first_data_block = 0;
88         cxt->inodes_count = reiserfs_count_objectids(fs);
89         cxt->free_inodes_count = 0;
90         info = calloc(1, sizeof(*info));
91         if (!info) {
92                 reiserfs_close(fs);
93                 return -1;
94         }
95
96         /*
97          * Inode attributes are somewhat of a hack on reiserfs and it was
98          * once possible to have garbage in the flags field.  A superblock
99          * field now indicates that the field has been cleared and can
100          * be considered valid, but only on v3.6 format file systems.
101          */
102         if (fs->fs_format == REISERFS_FORMAT_3_6 &&
103             get_sb_v2_flag(fs->fs_ondisk_sb, reiserfs_attrs_cleared))
104                 info->copy_attrs = true;
105
106         fs->fs_vp = info;
107         return 0;
108 }
109
110 static void reiserfs_close_fs(struct btrfs_convert_context *cxt)
111 {
112         reiserfs_filsys_t fs = cxt->fs_data;
113         struct reiserfs_convert_info *info = fs->fs_vp;
114
115         if (info) {
116                 if (info->objectids)
117                         free(info->objectids);
118                 free(info);
119                 fs->fs_vp = NULL;
120         }
121
122         /* We don't want changes to be persistent */
123         fs->fs_bitmap2->bm_dirty = 0;
124
125         reiserfs_close(fs);
126 }
127
128 static int compare_objectids(const void *p1, const void *p2)
129 {
130         u64 v1 = *(u64 *)p1;
131         u64 v2 = *(u64 *)p2;
132
133         if (v1 > v2)
134                 return 1;
135         else if (v1 < v2)
136                 return -1;
137         return 0;
138 }
139
140 static int lookup_cached_objectid(reiserfs_filsys_t fs, u64 objectid)
141 {
142         struct reiserfs_convert_info *info = fs->fs_vp;
143         u64 *result;
144
145         if (!info->objectids)
146                 return 0;
147         result = bsearch(&objectid, info->objectids, info->used_slots,
148                          sizeof(u64), compare_objectids);
149         return result != NULL;
150 }
151
152 static int insert_cached_objectid(reiserfs_filsys_t fs, u64 objectid)
153 {
154         struct reiserfs_convert_info *info = fs->fs_vp;
155
156         if (info->used_slots + 1 >= info->alloced_slots) {
157                 u64 *objectids = realloc(info->objectids,
158                                     (info->alloced_slots + 1000) * sizeof(u64));
159
160                 if (!objectids)
161                         return -ENOMEM;
162                 info->objectids = objectids;
163                 info->alloced_slots += 1000;
164         }
165         info->objectids[info->used_slots++] = objectid;
166
167         qsort(info->objectids, info->used_slots, sizeof(u64), compare_objectids);
168         return 0;
169 }
170
171 static int reiserfs_locate_privroot(reiserfs_filsys_t fs)
172 {
173         int err;
174         unsigned generation;
175         struct reiserfs_convert_info *info = fs->fs_vp;
176         struct reiserfs_key key = root_dir_key;
177
178         err = reiserfs_find_entry(fs, &key, ".reiserfs_priv",
179                                   &generation, &info->privroot_key);
180         if (err == 1) {
181                 err = reiserfs_find_entry(fs, &info->privroot_key, "xattrs",
182                                           &generation, &info->xattr_key);
183                 if (err != 1)
184                         memset(&info->xattr_key, 0, sizeof(info->xattr_key));
185         }
186
187         return 0;
188 }
189
190 static void reiserfs_convert_inode_flags(struct btrfs_inode_item *inode,
191                                          const struct stat_data *sd)
192 {
193         u16 attrs = sd_v2_sd_attrs(sd);
194         u64 new_flags = 0;
195
196         if (attrs & FS_IMMUTABLE_FL)
197                 new_flags |= BTRFS_INODE_IMMUTABLE;
198
199         if (attrs & FS_APPEND_FL)
200                 new_flags |= BTRFS_INODE_APPEND;
201
202         if (attrs & FS_SYNC_FL)
203                 new_flags |= BTRFS_INODE_SYNC;
204
205         if (attrs & FS_NOATIME_FL)
206                 new_flags |= BTRFS_INODE_NOATIME;
207
208         if (attrs & FS_NODUMP_FL)
209                 new_flags |= BTRFS_INODE_NODUMP;
210
211         if (attrs & FS_NODUMP_FL)
212                 new_flags |= BTRFS_INODE_NODUMP;
213
214         btrfs_set_stack_inode_flags(inode, new_flags);
215
216 }
217
218 static void reiserfs_copy_inode_item(struct btrfs_inode_item *inode,
219                                      struct item_head *ih, void *stat_data,
220                                      bool copy_inode_flags)
221 {
222         u32 mode;
223         u32 rdev = 0;
224
225         memset(inode, 0, sizeof(*inode));
226         btrfs_set_stack_inode_generation(inode, 1);
227         if (get_ih_key_format(ih) == KEY_FORMAT_1) {
228                 struct stat_data_v1 *sd = stat_data;
229
230                 mode = sd_v1_mode(sd);
231                 btrfs_set_stack_inode_size(inode, sd_v1_size(sd));
232                 btrfs_set_stack_inode_nlink(inode, sd_v1_nlink(sd));
233                 btrfs_set_stack_inode_uid(inode, sd_v1_uid(sd));
234                 btrfs_set_stack_inode_gid(inode, sd_v1_gid(sd));
235                 btrfs_set_stack_timespec_sec(&inode->atime, sd_v1_atime(sd));
236                 btrfs_set_stack_timespec_sec(&inode->ctime, sd_v1_ctime(sd));
237                 btrfs_set_stack_timespec_sec(&inode->mtime, sd_v1_mtime(sd));
238
239                 if (!S_ISREG(mode) && !S_ISDIR(mode) && !S_ISLNK(mode))
240                         rdev = decode_dev(sd_v1_rdev(sd));
241         } else {
242                 struct stat_data *sd = stat_data;
243
244                 mode = sd_v2_mode(sd);
245                 btrfs_set_stack_inode_size(inode, sd_v2_size(sd));
246                 btrfs_set_stack_inode_nlink(inode, sd_v2_nlink(sd));
247                 btrfs_set_stack_inode_uid(inode, sd_v2_uid(sd));
248                 btrfs_set_stack_inode_gid(inode, sd_v2_gid(sd));
249                 btrfs_set_stack_timespec_sec(&inode->atime, sd_v2_atime(sd));
250                 btrfs_set_stack_timespec_sec(&inode->ctime, sd_v2_ctime(sd));
251                 btrfs_set_stack_timespec_sec(&inode->mtime, sd_v2_mtime(sd));
252
253                 if (!S_ISREG(mode) && !S_ISDIR(mode) && !S_ISLNK(mode))
254                         rdev = decode_dev(sd_v2_rdev(sd));
255
256                 if (copy_inode_flags)
257                         reiserfs_convert_inode_flags(inode, sd);
258
259         }
260         if (S_ISDIR(mode)) {
261                 btrfs_set_stack_inode_size(inode, 0);
262                 btrfs_set_stack_inode_nlink(inode, 1);
263         }
264         btrfs_set_stack_inode_mode(inode, mode);
265         btrfs_set_stack_inode_rdev(inode, rdev);
266 }
267
268 static void init_reiserfs_blk_iterate_data(
269                                 struct reiserfs_blk_iterate_data *data,
270                                 struct btrfs_trans_handle *trans,
271                                 struct btrfs_root *root,
272                                 struct btrfs_inode_item *inode,
273                                 u64 objectid, u32 convert_flags)
274 {
275         init_blk_iterate_data(&data->blk_data, trans, root, inode, objectid,
276                               convert_flags & CONVERT_FLAG_DATACSUM);
277         data->inline_data = NULL;
278         data->inline_offset = (u64)-1;
279         data->inline_length = 0;
280 }
281
282 static int reiserfs_record_indirect_extent(reiserfs_filsys_t fs, u64 position,
283                                            u64 size, int num_ptrs,
284                                            u32 *ptrs, void *data)
285 {
286         struct reiserfs_blk_iterate_data *bdata = data;
287         u32 file_block = position / fs->fs_blocksize;
288         int i;
289         int ret = 0;
290
291         for (i = 0; i < num_ptrs; i++, file_block++) {
292                 u32 block = d32_get(ptrs, i);
293
294                 ret = block_iterate_proc(block, file_block, &bdata->blk_data);
295                 if (ret)
296                         break;
297         }
298
299         return ret;
300 }
301
302 /*
303  * Unlike btrfs inline extents, reiserfs can have multiple inline extents.
304  * This handles concatanating multiple tails into one inline extent
305  * for insertion.
306  */
307 static int reiserfs_record_direct_extent(reiserfs_filsys_t fs, __u64 position,
308                                          __u64 size, const char *body,
309                                          size_t len, void *data)
310 {
311         struct reiserfs_blk_iterate_data *bdata = data;
312         char *inline_data;
313
314         if (bdata->inline_offset == (u64)-1)
315                 bdata->inline_offset = position;
316         else if (bdata->inline_offset + bdata->inline_length != position) {
317                 /*
318                  * This condition shouldn't actually happen, but better to
319                  * catch it than break silently.
320                  */
321                 error(
322 "source fs contains file with multiple tails but they are not contiguous");
323                 return -EINVAL;
324         }
325
326         inline_data = realloc(bdata->inline_data, bdata->inline_length + len);
327         if (!inline_data)
328                 return -ENOMEM;
329
330         bdata->inline_data = inline_data;
331         memcpy(bdata->inline_data + bdata->inline_length, body, len);
332         bdata->inline_length += len;
333
334         return 0;
335 }
336
337 static int convert_direct(struct btrfs_trans_handle *trans,
338                           struct btrfs_root *root, u64 objectid,
339                           struct btrfs_inode_item *inode, const char *body,
340                           u32 length, u64 offset, u32 convert_flags)
341 {
342         struct btrfs_key key;
343         u32 sectorsize = root->fs_info->sectorsize;
344         int ret;
345         struct extent_buffer *eb;
346
347         BUG_ON(length > sectorsize);
348         ret = btrfs_reserve_extent(trans, root, sectorsize,
349                                    0, 0, -1ULL, &key, 1);
350         if (ret)
351                 return ret;
352
353         eb = alloc_extent_buffer(&root->fs_info->extent_cache, key.objectid,
354                                  sectorsize);
355
356         if (!eb)
357                 return -ENOMEM;
358
359         write_extent_buffer(eb, body, 0, length);
360         ret = write_and_map_eb(root->fs_info, eb);
361         free_extent_buffer(eb);
362         if (ret)
363                 return ret;
364
365         return btrfs_record_file_extent(trans, root, objectid, inode, offset,
366                                         key.objectid, sectorsize);
367 }
368
369 static int reiserfs_convert_tail(struct btrfs_trans_handle *trans,
370                                  struct btrfs_root *root,
371                                  struct btrfs_inode_item *inode,
372                                  u64 objectid, u64 offset,
373                                  const void *body, unsigned length,
374                                  u32 convert_flags)
375 {
376         u64 isize;
377         int ret;
378
379         if (length >= BTRFS_MAX_INLINE_DATA_SIZE(root))
380                 return convert_direct(trans, root, objectid, inode, body,
381                                       length, offset, convert_flags);
382
383         ret = btrfs_insert_inline_extent(trans, root, objectid,
384                                          offset, body, length);
385         if (ret)
386                 return ret;
387
388         isize = btrfs_stack_inode_nbytes(inode);
389         btrfs_set_stack_inode_nbytes(inode, isize + length);
390
391         return 0;
392 }
393
394 static inline u32 block_count(u64 size, u32 blocksize)
395 {
396         return round_up(size, blocksize) / blocksize;
397 }
398
399 static int reiserfs_record_file_extents(reiserfs_filsys_t fs,
400                                         struct btrfs_trans_handle *trans,
401                                         struct btrfs_root *root,
402                                         u64 objectid,
403                                         struct btrfs_inode_item *inode,
404                                         struct reiserfs_key *sd_key,
405                                         u32 convert_flags)
406
407 {
408         int ret;
409         u32 blocksize = fs->fs_blocksize;
410         u64 inode_size = btrfs_stack_inode_size(inode);
411         u32 last_block;
412         struct reiserfs_blk_iterate_data data;
413
414         init_reiserfs_blk_iterate_data(&data, trans, root, inode,
415                                        objectid, convert_flags);
416
417         ret = reiserfs_iterate_file_data(fs, sd_key,
418                                          reiserfs_record_indirect_extent,
419                                          reiserfs_record_direct_extent, &data);
420         if (ret)
421                 return ret;
422
423         /*
424          * blk_iterate_block has no idea that we're done iterating, so record
425          * the final range if any.  This range can end and still have a tail
426          * after it.
427          */
428         if (data.blk_data.num_blocks) {
429                 ret = record_file_blocks(&data.blk_data,
430                                          data.blk_data.first_block,
431                                          data.blk_data.disk_block,
432                                          data.blk_data.num_blocks);
433                 if (ret)
434                         goto fail;
435                 data.blk_data.first_block += data.blk_data.num_blocks;
436                 data.blk_data.num_blocks = 0;
437         }
438
439         /*
440          * Handle a hole at the end of the file.  ReiserFS will
441          * not write a tail followed by a hole but it will write a hole
442          * followed by a tail.
443          */
444         last_block = block_count(inode_size - data.inline_length, blocksize);
445         if (last_block > data.blk_data.first_block) {
446                 ret = record_file_blocks(&data.blk_data,
447                                          data.blk_data.first_block, 0,
448                                          last_block - data.blk_data.first_block);
449                 if (ret)
450                         goto fail;
451         }
452
453         if (data.inline_length) {
454                 ret = reiserfs_convert_tail(trans, root, inode, objectid,
455                                             data.inline_offset,
456                                             data.inline_data,
457                                             data.inline_length, convert_flags);
458                 if (ret)
459                         goto fail;
460         }
461
462         ret = 0;
463 fail:
464         return ret;
465 }
466
467 static int reiserfs_copy_meta(reiserfs_filsys_t fs, struct btrfs_root *root,
468                               u32 convert_flags, u32 deh_dirid,
469                               u32 deh_objectid, u8 *type);
470
471 static int reiserfs_copy_dirent(reiserfs_filsys_t fs,
472                                 const struct reiserfs_key *dir_short_key,
473                                 const char *name, size_t len,
474                                 __u32 deh_dirid, __u32 deh_objectid,
475                                 void *cb_data)
476 {
477         int ret;
478         u8 type;
479         struct btrfs_trans_handle *trans;
480         u64 objectid = deh_objectid + OID_OFFSET;
481         struct reiserfs_convert_info *info = fs->fs_vp;
482         struct reiserfs_dirent_data *dirent_data = cb_data;
483         struct btrfs_root *root = dirent_data->root;
484         __u32 dir_objectid = get_key_objectid(dir_short_key) + OID_OFFSET;
485
486         /*
487          * These are the extended attributes and shouldn't appear as files
488          * in the converted file systems.
489          */
490         if (deh_objectid == get_key_objectid(&info->privroot_key))
491                 return 0;
492
493         ret = reiserfs_copy_meta(fs, root, dirent_data->convert_flags,
494                                  deh_dirid, deh_objectid, &type);
495         if (ret) {
496                 error(
497         "an error occured while converting \"%.*s\", reiserfs key [%u %u]: %s",
498                         (int)len, name, deh_dirid, deh_objectid,
499                         strerror(-ret));
500                 return ret;
501         }
502         trans = btrfs_start_transaction(root, 1);
503         if (IS_ERR(trans))
504                 return PTR_ERR(trans);
505
506         ret = convert_insert_dirent(trans, root, name, len, dir_objectid,
507                                     objectid, type, dirent_data->index++,
508                                     dirent_data->inode);
509         return btrfs_commit_transaction(trans, root);
510 }
511
512 static int reiserfs_copy_symlink(struct btrfs_trans_handle *trans,
513                                  struct btrfs_root *root, u64 objectid,
514                                  struct btrfs_inode_item *btrfs_inode,
515                                  reiserfs_filsys_t fs,
516                                  struct reiserfs_path *sd_path)
517 {
518         INITIALIZE_REISERFS_PATH(path);
519         struct item_head *ih = tp_item_head(sd_path);
520         struct reiserfs_key key = ih->ih_key;
521         int ret;
522         char *symlink;
523         int len;
524
525         set_key_uniqueness(&key, type2uniqueness(TYPE_DIRECT));
526         set_key_offset_v1(&key, 1);
527
528         ret = reiserfs_search_by_key_3(fs, &key, &path);
529         if (ret != ITEM_FOUND) {
530                 ret = -ENOENT;
531                 goto fail;
532         }
533
534         symlink = tp_item_body(&path);
535         len = get_ih_item_len(tp_item_head(&path));
536
537         ret = btrfs_insert_inline_extent(trans, root, objectid, 0,
538                                          symlink, len + 1);
539         btrfs_set_stack_inode_nbytes(btrfs_inode, len + 1);
540 fail:
541         pathrelse(&path);
542         return ret;
543 }
544
545 static int reiserfs_copy_meta(reiserfs_filsys_t fs, struct btrfs_root *root,
546                               u32 convert_flags, u32 deh_dirid,
547                               u32 deh_objectid, u8 *type)
548 {
549         INITIALIZE_REISERFS_PATH(path);
550         int ret = 0;
551         struct item_head *ih;
552         struct reiserfs_key key;
553         struct btrfs_inode_item btrfs_inode;
554         struct btrfs_trans_handle *trans = NULL;
555         struct reiserfs_convert_info *info = fs->fs_vp;
556         u32 mode;
557         u64 objectid = deh_objectid + OID_OFFSET;
558         u64 parent = deh_dirid + OID_OFFSET;
559         struct reiserfs_dirent_data dirent_data = {
560                 .index = 2,
561                 .convert_flags = convert_flags,
562                 .inode = &btrfs_inode,
563                 .root = root,
564         };
565
566         /* The root directory's dirid in reiserfs points to an object
567          * that does't exist.  In btrfs it's self-referential.
568          */
569         if (deh_dirid == REISERFS_ROOT_PARENT_OBJECTID)
570                 parent = objectid;
571
572         set_key_dirid(&key, deh_dirid);
573         set_key_objectid(&key, deh_objectid);
574         set_key_offset_v2(&key, 0);
575         set_key_type_v2(&key, TYPE_STAT_DATA);
576
577         ret = reiserfs_search_by_key_3(fs, &key, &path);
578         if (ret != ITEM_FOUND) {
579                 ret = -ENOENT;
580                 goto fail;
581         }
582
583         ih = tp_item_head(&path);
584         if (!is_stat_data_ih(ih)) {
585                 ret = -EINVAL;
586                 goto fail;
587         }
588
589         reiserfs_copy_inode_item(&btrfs_inode, ih, tp_item_body(&path),
590                                  info->copy_attrs);
591         mode = btrfs_stack_inode_mode(&btrfs_inode);
592         *type = mode_to_file_type(mode);
593
594         if (S_ISREG(mode)) {
595                 /* Inodes with hardlinks should only be inserted once */
596                 if (btrfs_stack_inode_nlink(&btrfs_inode) > 1) {
597                         if (lookup_cached_objectid(fs, deh_objectid)) {
598                                 ret = 0;
599                                 goto fail; /* Not a failure */
600                         }
601                         ret = insert_cached_objectid(fs, deh_objectid);
602                         if (ret)
603                                 goto fail;
604                 }
605         }
606
607         if (!(convert_flags & CONVERT_FLAG_DATACSUM)) {
608                 u32 flags = btrfs_stack_inode_flags(&btrfs_inode) |
609                             BTRFS_INODE_NODATASUM;
610                 btrfs_set_stack_inode_flags(&btrfs_inode, flags);
611         }
612
613         switch (mode & S_IFMT) {
614         case S_IFREG:
615                 trans = btrfs_start_transaction(root, 1);
616                 if (IS_ERR(trans)) {
617                         ret = PTR_ERR(trans);
618                         goto fail;
619                 }
620                 ret = reiserfs_record_file_extents(fs, trans, root, objectid,
621                                                    &btrfs_inode, &ih->ih_key,
622                                                    convert_flags);
623                 if (ret)
624                         goto fail;
625                 break;
626         case S_IFDIR:
627                 ret = reiserfs_iterate_dir(fs, &ih->ih_key,
628                                            reiserfs_copy_dirent, &dirent_data);
629                 if (ret)
630                         goto fail;
631                 trans = btrfs_start_transaction(root, 1);
632                 if (IS_ERR(trans)) {
633                         ret = PTR_ERR(trans);
634                         goto fail;
635                 }
636
637                 ret = btrfs_insert_inode_ref(trans, root, "..", 2, parent,
638                                              objectid, 0);
639                 break;
640         case S_IFLNK:
641                 trans = btrfs_start_transaction(root, 1);
642                 if (IS_ERR(trans)) {
643                         ret = PTR_ERR(trans);
644                         goto fail;
645                 }
646                 ret = reiserfs_copy_symlink(trans, root, objectid,
647                                             &btrfs_inode, fs, &path);
648                 if (ret)
649                         goto fail;
650                 break;
651         default:
652                 trans = btrfs_start_transaction(root, 1);
653                 if (IS_ERR(trans)) {
654                         ret = PTR_ERR(trans);
655                         goto fail;
656                 }
657         }
658
659         ret = btrfs_insert_inode(trans, root, objectid, &btrfs_inode);
660         if (ret)
661                 goto fail;
662         ret = btrfs_commit_transaction(trans, root);
663         info->progress->cur_copy_inodes++;
664
665 fail:
666         pathrelse(&path);
667         return ret;
668 }
669
670 static int reiserfs_xattr_indirect_fn(reiserfs_filsys_t fs, u64 position,
671                                       u64 size, int num_blocks,
672                                       u32 *blocks, void *data)
673 {
674         int i;
675         struct reiserfs_xattr_data *xa_data = data;
676         size_t alloc = min(position + num_blocks * fs->fs_blocksize, size);
677         char *body;
678
679         if (size > BTRFS_LEAF_DATA_SIZE(xa_data->root->fs_info) -
680             sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
681                 fprintf(stderr, "skip large xattr on objectid %llu name %.*s\n",
682                         xa_data->target_oid, (int)xa_data->namelen,
683                         xa_data->name);
684                 return -E2BIG;
685         }
686
687         body = realloc(xa_data->body, alloc);
688         if (!body)
689                 return -ENOMEM;
690
691         xa_data->body = body;
692         xa_data->len = alloc;
693
694         for (i = 0; i < num_blocks; i++) {
695                 int ret;
696                 u32 block = d32_get(blocks, i);
697                 u64 offset = (u64)block * fs->fs_blocksize;
698                 size_t chunk = min_t(u64, size - position, fs->fs_blocksize);
699                 char *buffer = xa_data->body + position;
700
701                 ret = read_disk_extent(xa_data->root, offset, chunk, buffer);
702                 if (ret)
703                         return ret;
704                 position += chunk;
705         }
706
707         return 0;
708 }
709
710 static int reiserfs_xattr_direct_fn(reiserfs_filsys_t fs, __u64 position,
711                                     __u64 size, const char *body, size_t len,
712                                     void *data)
713 {
714         struct reiserfs_xattr_data *xa_data = data;
715         char *newbody;
716
717         if (size > BTRFS_LEAF_DATA_SIZE(xa_data->root->fs_info) -
718             sizeof(struct btrfs_item) - sizeof(struct btrfs_dir_item)) {
719                 fprintf(stderr, "skip large xattr on objectid %llu name %.*s\n",
720                         xa_data->target_oid, (int)xa_data->namelen,
721                         xa_data->name);
722                 return -E2BIG;
723         }
724
725         newbody = realloc(xa_data->body, position + len);
726         if (!newbody)
727                 return -ENOMEM;
728         xa_data->body = newbody;
729         xa_data->len = position + len;
730         memcpy(xa_data->body + position, body, len);
731         return 0;
732 }
733
734 static int reiserfs_acl_to_xattr(void *dst, const void *src,
735                                  size_t dst_size, size_t src_size)
736 {
737         int i, count;
738         const void *end = src + src_size;
739         acl_ea_header *ext_acl = (acl_ea_header *)dst;
740         acl_ea_entry *dst_entry = ext_acl->a_entries;
741         struct reiserfs_acl_entry *src_entry;
742
743         if (src_size < sizeof(struct reiserfs_acl_header))
744                 goto fail;
745         if (((struct reiserfs_acl_header *)src)->a_version !=
746             cpu_to_le32(REISERFS_ACL_VERSION))
747                 goto fail;
748         src += sizeof(struct reiserfs_acl_header);
749         count = reiserfs_acl_count(src_size);
750         if (count <= 0)
751                 goto fail;
752
753         BUG_ON(dst_size < acl_ea_size(count));
754         ext_acl->a_version = cpu_to_le32(ACL_EA_VERSION);
755         for (i = 0; i < count; i++, dst_entry++) {
756                 src_entry = (struct reiserfs_acl_entry *)src;
757                 if (src + sizeof(struct reiserfs_acl_entry_short) > end)
758                         goto fail;
759                 dst_entry->e_tag = src_entry->e_tag;
760                 dst_entry->e_perm = src_entry->e_perm;
761                 switch (le16_to_cpu(src_entry->e_tag)) {
762                 case ACL_USER_OBJ:
763                 case ACL_GROUP_OBJ:
764                 case ACL_MASK:
765                 case ACL_OTHER:
766                         src += sizeof(struct reiserfs_acl_entry_short);
767                         dst_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
768                         break;
769                 case ACL_USER:
770                 case ACL_GROUP:
771                         src += sizeof(struct reiserfs_acl_entry);
772                         if (src > end)
773                                 goto fail;
774                         dst_entry->e_id = src_entry->e_id;
775                         break;
776                 default:
777                         goto fail;
778                 }
779         }
780         if (src != end)
781                 goto fail;
782         return 0;
783 fail:
784         return -EINVAL;
785 }
786
787 static int reiserfs_copy_one_xattr(reiserfs_filsys_t fs,
788                                    const struct reiserfs_key *dir_short_key,
789                                    const char *name, size_t namelen,
790                                    __u32 deh_dirid,
791                                    __u32 deh_objectid, void *cb_data)
792 {
793         struct reiserfs_convert_info *info = fs->fs_vp;
794         struct reiserfs_xattr_data *xa_data = cb_data;
795         struct reiserfs_key key = {
796                 .k2_dir_id = deh_dirid,
797                 .k2_objectid = deh_objectid,
798         };
799         void *body = NULL;
800         int len;
801         int ret;
802
803         xa_data->name = name;
804         xa_data->namelen = namelen;
805
806         ret = reiserfs_iterate_file_data(fs, &key, reiserfs_xattr_indirect_fn,
807                                          reiserfs_xattr_direct_fn, cb_data);
808         if (ret)
809                 goto out;
810
811         if (!reiserfs_check_xattr(xa_data->body, xa_data->len)) {
812                 fprintf(stderr,
813                         "skip corrupted xattr on objectid %u name %.*s\n",
814                         deh_objectid, (int)xa_data->namelen,
815                         xa_data->name);
816                 goto out;
817         }
818
819         body = xa_data->body + sizeof(struct reiserfs_xattr_header);
820         len = xa_data->len - sizeof(struct reiserfs_xattr_header);
821
822         if (!strncmp("system.posix_acl_default", name, namelen) ||
823             !strncmp("system.posix_acl_access", name, namelen)) {
824                 size_t bufsize = acl_ea_size(ext2_acl_count(len));
825                 char *databuf = malloc(bufsize);
826
827                 if (!databuf)
828                         goto out;
829                 ret = reiserfs_acl_to_xattr(databuf, body, bufsize, len);
830                 if (ret)
831                         goto out;
832                 body = databuf;
833                 len = bufsize;
834         }
835
836         ret = btrfs_insert_xattr_item(xa_data->trans, xa_data->root,
837                                       name, namelen, body, len,
838                                       xa_data->target_oid);
839
840         info->progress->cur_copy_inodes++;
841 out:
842         if (body &&
843             body != xa_data->body + sizeof(struct reiserfs_xattr_header))
844                 free(body);
845         if (xa_data->body)
846                 free(xa_data->body);
847         xa_data->body = NULL;
848         xa_data->len = 0;
849
850         return ret;
851 }
852
853 static int reiserfs_copy_xattr_dir(reiserfs_filsys_t fs,
854                                    const struct reiserfs_key *dir_short_key,
855                                    const char *name, size_t len,
856                                    __u32 deh_dirid, __u32 deh_objectid,
857                                    void *cb_data)
858 {
859         struct reiserfs_convert_info *info = fs->fs_vp;
860         struct reiserfs_xattr_data *xa_data = cb_data;
861         struct reiserfs_key dir_key = {
862                 .k2_dir_id = deh_dirid,
863                 .k2_objectid = deh_objectid,
864         };
865         int ret, err;
866
867         errno = 0;
868         xa_data->target_oid = strtoull(name, NULL, 16);
869         if (xa_data->target_oid == ULLONG_MAX && errno)
870                 return -errno;
871
872         xa_data->target_oid += OID_OFFSET;
873
874         xa_data->trans = btrfs_start_transaction(xa_data->root, 1);
875         if (IS_ERR(xa_data->trans))
876                 return PTR_ERR(xa_data->trans);
877
878         ret = reiserfs_iterate_dir(fs, &dir_key,
879                                     reiserfs_copy_one_xattr, xa_data);
880
881         err = btrfs_commit_transaction(xa_data->trans, xa_data->root);
882         info->progress->cur_copy_inodes++;
883         xa_data->trans = NULL;
884         return ret ?: err;
885 }
886
887 static int reiserfs_copy_xattrs(reiserfs_filsys_t fs, struct btrfs_root *root)
888 {
889         struct reiserfs_convert_info *info = fs->fs_vp;
890         struct reiserfs_xattr_data data = {
891                 .root = root,
892         };
893
894         if (get_key_objectid(&info->xattr_key) == 0)
895                 return 0;
896
897         return reiserfs_iterate_dir(fs, &info->xattr_key,
898                                     reiserfs_copy_xattr_dir, &data);
899 }
900
901 static int reiserfs_copy_inodes(struct btrfs_convert_context *cxt,
902                                 struct btrfs_root *root,
903                                 u32 convert_flags,
904                                 struct task_ctx *p)
905 {
906         reiserfs_filsys_t fs = cxt->fs_data;
907         struct reiserfs_convert_info *info = fs->fs_vp;
908         int ret;
909         u8 type;
910
911         info->progress = p;
912
913         ret = reiserfs_locate_privroot(fs);
914         if (ret)
915                 goto out;
916
917         ret = reiserfs_copy_meta(fs, root, convert_flags,
918                                  REISERFS_ROOT_PARENT_OBJECTID,
919                                  REISERFS_ROOT_OBJECTID, &type);
920         if (ret)
921                 goto out;
922
923         if (convert_flags & CONVERT_FLAG_XATTR)
924                 ret = reiserfs_copy_xattrs(fs, root);
925
926 out:
927         info->progress = NULL;
928         return ret;
929 }
930
931 static int reiserfs_read_used_space(struct btrfs_convert_context *cxt)
932 {
933         reiserfs_filsys_t fs = cxt->fs_data;
934         u64 start, end = 0;
935         unsigned int size = get_sb_block_count(fs->fs_ondisk_sb);
936         unsigned long *bitmap = (unsigned long *)fs->fs_bitmap2->bm_map;
937         int ret = 0;
938
939         /*
940          * We have the entire bitmap loaded so we can just ping pong with
941          * ffz and ffs
942          */
943         while (end < size) {
944                 u64 offset, length;
945
946                 start = find_next_bit(bitmap, size, end);
947                 if (start >= size)
948                         break;
949                 end = find_next_zero_bit(bitmap, size, start);
950                 if (end > size)
951                         end = size;
952                 offset = start * fs->fs_blocksize;
953                 length = (end - start) * fs->fs_blocksize;
954                 ret = add_merge_cache_extent(&cxt->used_space, offset, length);
955                 if (ret < 0)
956                         break;
957         }
958
959         return ret;
960 }
961
962 static int reiserfs_check_state(struct btrfs_convert_context *cxt)
963 {
964         return 0;
965 }
966
967 const struct btrfs_convert_operations reiserfs_convert_ops = {
968         .name           = "reiserfs",
969         .open_fs        = reiserfs_open_fs,
970         .read_used_space = reiserfs_read_used_space,
971         .copy_inodes    = reiserfs_copy_inodes,
972         .close_fs       = reiserfs_close_fs,
973         .check_state    = reiserfs_check_state,
974 };
975
976 #endif /* BTRFSCONVERT_REISERFS */