packaging: Enable LTO and set visibility to hidden
[platform/upstream/btrfs-progs.git] / file.c
1 /*
2  * Copyright (C) 2014 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; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18
19 #include <sys/stat.h>
20 #include "ctree.h"
21 #include "utils.h"
22 #include "disk-io.h"
23 #include "transaction.h"
24 #include "kerncompat.h"
25
26 /*
27  * Get the first file extent that covers (part of) the given range
28  * Unlike kernel using extent_map to handle hole even no-hole is enabled,
29  * progs don't have such infrastructure, so caller should do extra care
30  * for no-hole.
31  *
32  * return 0 for found, and path points to the file extent.
33  * return >0 for not found, and path points to the insert position.
34  * return <0 for error.
35  */
36 int btrfs_get_extent(struct btrfs_trans_handle *trans,
37                      struct btrfs_root *root,
38                      struct btrfs_path *path,
39                      u64 ino, u64 offset, u64 len, int ins_len)
40 {
41         struct btrfs_key key;
42         struct btrfs_key found_key;
43         struct btrfs_file_extent_item *fi_item;
44         u64 end = 0;
45         int ret = 0;
46         int not_found = 1;
47
48         key.objectid = ino;
49         key.type = BTRFS_EXTENT_DATA_KEY;
50         key.offset = offset;
51
52         ret = btrfs_search_slot(trans, root, &key, path, ins_len,
53                                 ins_len ? 1 : 0);
54         if (ret <= 0)
55                 goto out;
56         if (ret > 0) {
57                 /* Check previous file extent */
58                 ret = btrfs_previous_item(root, path, ino,
59                                           BTRFS_EXTENT_DATA_KEY);
60                 if (ret < 0)
61                         goto out;
62                 if (ret > 0)
63                         goto check_next;
64         }
65         btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]);
66         if (found_key.objectid != ino ||
67             found_key.type != BTRFS_EXTENT_DATA_KEY)
68                 goto check_next;
69
70         fi_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
71                                  struct btrfs_file_extent_item);
72         end = found_key.offset +
73               btrfs_file_extent_ram_bytes(path->nodes[0], fi_item);
74         /*
75          * existing file extent
76          * |--------|     |----|
77          *      |-------|
78          *      offset + len
79          * OR
80          * |---------------|
81          *      |-------|
82          */
83         if (end > offset) {
84                 not_found = 0;
85                 goto out;
86         }
87 check_next:
88         ret = btrfs_next_item(root, path);
89         if (ret)
90                 goto out;
91
92         btrfs_item_key_to_cpu(path->nodes[0], &found_key, path->slots[0]);
93         if (found_key.objectid != ino ||
94             found_key.type != BTRFS_EXTENT_DATA_KEY) {
95                 ret = 1;
96                 goto out;
97         }
98         if (found_key.offset < offset + len)
99                 /*
100                  * existing file extent
101                  * |---|        |------|
102                  *      |-------|
103                  *      offset + len
104                  */
105                 not_found = 0;
106         else
107                 /*
108                  * existing file extent
109                  * |----|               |----|
110                  *              |----|
111                  *              offset + len
112                  */
113                 not_found = 1;
114
115         /*
116          * To keep the search behavior consistent with search_slot(),
117          * we need to go back to the prev leaf's nritem slot if
118          * we are at the first slot of the leaf.
119          */
120         if (path->slots[0] == 0) {
121                 ret = btrfs_prev_leaf(root, path);
122                 /* Not possible */
123                 if (ret)
124                         goto out;
125                 path->slots[0] = btrfs_header_nritems(path->nodes[0]);
126         }
127
128 out:
129         if (ret == 0)
130                 ret = not_found;
131         return ret;
132 }
133
134 /*
135  * Punch hole ranged [offset,len) for the file given by ino and root.
136  *
137  * Unlink kernel punch_hole, which will not zero/free existing extent,
138  * instead it will return -EEXIST if there is any extents in the hole
139  * range.
140  */
141 int btrfs_punch_hole(struct btrfs_trans_handle *trans,
142                      struct btrfs_root *root,
143                      u64 ino, u64 offset, u64 len)
144 {
145         struct btrfs_path *path;
146         int ret = 0;
147
148         path = btrfs_alloc_path();
149         if (!path)
150                 return -ENOMEM;
151
152         ret = btrfs_get_extent(NULL, root, path, ino, offset, len, 0);
153         if (ret < 0)
154                 goto out;
155         if (ret == 0) {
156                 ret = -EEXIST;
157                 goto out;
158         }
159
160         ret = btrfs_insert_file_extent(trans, root, ino, offset, 0, 0, len);
161 out:
162         btrfs_free_path(path);
163         return ret;
164 }
165
166 /*
167  * Read out content of one inode.
168  *
169  * @root:  fs/subvolume root containing the inode
170  * @ino:   inode number
171  * @start: offset inside the file, aligned to sectorsize
172  * @len:   length to read, aligned to sectorisize
173  * @dest:  where data will be stored
174  *
175  * NOTE:
176  * 1) compression data is not supported yet
177  * 2) @start and @len must be aligned to sectorsize
178  * 3) data read out is also aligned to sectorsize, not truncated to inode size
179  *
180  * Return < 0 for fatal error during read.
181  * Otherwise return the number of succesfully read data in bytes.
182  */
183 int btrfs_read_file(struct btrfs_root *root, u64 ino, u64 start, int len,
184                     char *dest)
185 {
186         struct btrfs_fs_info *fs_info = root->fs_info;
187         struct btrfs_key key;
188         struct btrfs_path path;
189         struct extent_buffer *leaf;
190         struct btrfs_inode_item *ii;
191         u64 isize;
192         int no_holes = btrfs_fs_incompat(fs_info, NO_HOLES);
193         int slot;
194         int read = 0;
195         int ret;
196
197         if (!IS_ALIGNED(start, fs_info->sectorsize) ||
198             !IS_ALIGNED(len, fs_info->sectorsize)) {
199                 warning("@start and @len must be aligned to %u for function %s",
200                         fs_info->sectorsize, __func__);
201                 return -EINVAL;
202         }
203
204         btrfs_init_path(&path);
205         key.objectid = ino;
206         key.offset = start;
207         key.type = BTRFS_EXTENT_DATA_KEY;
208
209         ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
210         if (ret < 0)
211                 goto out;
212
213         if (ret > 0) {
214                 ret = btrfs_previous_item(root, &path, ino, BTRFS_EXTENT_DATA_KEY);
215                 if (ret > 0) {
216                         ret = -ENOENT;
217                         goto out;
218                 }
219         }
220
221         /*
222          * Reset @dest to all 0, so we don't need to care about holes in
223          * no_hole mode, but focus on reading non-hole part.
224          */
225         memset(dest, 0, len);
226         while (1) {
227                 struct btrfs_file_extent_item *fi;
228                 u64 extent_start;
229                 u64 extent_len;
230                 u64 read_start;
231                 u64 read_len;
232                 u64 read_len_ret;
233                 u64 disk_bytenr;
234
235                 leaf = path.nodes[0];
236                 slot = path.slots[0];
237
238                 btrfs_item_key_to_cpu(leaf, &key, slot);
239                 if (key.objectid > ino)
240                         break;
241                 if (key.type != BTRFS_EXTENT_DATA_KEY || key.objectid != ino)
242                         goto next;
243
244                 extent_start = key.offset;
245                 if (extent_start >= start + len)
246                         break;
247
248                 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
249                 if (btrfs_file_extent_compression(leaf, fi) !=
250                     BTRFS_COMPRESS_NONE) {
251                         ret = -ENOTTY;
252                         break;
253                 }
254
255                 /* Inline extent, one inode should only one inline extent */
256                 if (btrfs_file_extent_type(leaf, fi) ==
257                     BTRFS_FILE_EXTENT_INLINE) {
258                         extent_len = btrfs_file_extent_inline_len(leaf, slot,
259                                                                   fi);
260                         if (extent_start + extent_len <= start)
261                                 goto next;
262                         read_extent_buffer(leaf, dest,
263                                 btrfs_file_extent_inline_start(fi), extent_len);
264                         read += round_up(extent_len, fs_info->sectorsize);
265                         break;
266                 }
267
268                 extent_len = btrfs_file_extent_num_bytes(leaf, fi);
269                 if (extent_start + extent_len <= start)
270                         goto next;
271
272                 read_start = max(start, extent_start);
273                 read_len = min(start + len, extent_start + extent_len) -
274                            read_start;
275
276                 /* We have already zeroed @dest, nothing to do */
277                 if (btrfs_file_extent_type(leaf, fi) ==
278                     BTRFS_FILE_EXTENT_PREALLOC ||
279                     btrfs_file_extent_disk_num_bytes(leaf, fi) == 0) {
280                         read += read_len;
281                         goto next;
282                 }
283
284                 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi) +
285                               btrfs_file_extent_offset(leaf, fi);
286                 read_len_ret = read_len;
287                 ret = read_extent_data(fs_info, dest + read_start - start, disk_bytenr,
288                                        &read_len_ret, 0);
289                 if (ret < 0)
290                         break;
291                 /* Short read, something went wrong */
292                 if (read_len_ret != read_len)
293                         return -EIO;
294                 read += read_len;
295 next:
296                 ret = btrfs_next_item(root, &path);
297                 if (ret > 0) {
298                         ret = 0;
299                         break;
300                 }
301         }
302
303         /*
304          * Special trick for no_holes, since for no_holes we don't have good
305          * method to account skipped and tailling holes, we used
306          * min(inode size, len) as return value
307          */
308         if (no_holes) {
309                 btrfs_release_path(&path);
310                 key.objectid = ino;
311                 key.offset = 0;
312                 key.type = BTRFS_INODE_ITEM_KEY;
313                 ret = btrfs_lookup_inode(NULL, root, &path, &key, 0);
314                 if (ret < 0)
315                         goto out;
316                 if (ret > 0) {
317                         ret = -ENOENT;
318                         goto out;
319                 }
320                 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
321                                     struct btrfs_inode_item);
322                 isize = round_up(btrfs_inode_size(path.nodes[0], ii),
323                                  fs_info->sectorsize);
324                 read = min_t(u64, isize - start, len);
325         }
326 out:
327         btrfs_release_path(&path);
328         if (!ret)
329                 ret = read;
330         return ret;
331 }