Branch data Line data Source code
1 : : /*
2 : : * Copyright (C) 2007 Oracle. 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 <linux/delay.h>
20 : : #include <linux/kthread.h>
21 : : #include <linux/pagemap.h>
22 : :
23 : : #include "ctree.h"
24 : : #include "disk-io.h"
25 : : #include "free-space-cache.h"
26 : : #include "inode-map.h"
27 : : #include "transaction.h"
28 : :
29 : 0 : static int caching_kthread(void *data)
30 : : {
31 : : struct btrfs_root *root = data;
32 : 0 : struct btrfs_fs_info *fs_info = root->fs_info;
33 : 0 : struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
34 : : struct btrfs_key key;
35 : : struct btrfs_path *path;
36 : 0 : struct extent_buffer *leaf;
37 : : u64 last = (u64)-1;
38 : : int slot;
39 : : int ret;
40 : :
41 [ # # ]: 0 : if (!btrfs_test_opt(root, INODE_MAP_CACHE))
42 : : return 0;
43 : :
44 : 0 : path = btrfs_alloc_path();
45 [ # # ]: 0 : if (!path)
46 : : return -ENOMEM;
47 : :
48 : : /* Since the commit root is read-only, we can safely skip locking. */
49 : 0 : path->skip_locking = 1;
50 : 0 : path->search_commit_root = 1;
51 : 0 : path->reada = 2;
52 : :
53 : 0 : key.objectid = BTRFS_FIRST_FREE_OBJECTID;
54 : 0 : key.offset = 0;
55 : 0 : key.type = BTRFS_INODE_ITEM_KEY;
56 : : again:
57 : : /* need to make sure the commit_root doesn't disappear */
58 : 0 : mutex_lock(&root->fs_commit_mutex);
59 : :
60 : 0 : ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
61 [ # # ]: 0 : if (ret < 0)
62 : : goto out;
63 : :
64 : : while (1) {
65 [ # # ]: 0 : if (btrfs_fs_closing(fs_info))
66 : : goto out;
67 : :
68 : 0 : leaf = path->nodes[0];
69 : 0 : slot = path->slots[0];
70 [ # # ]: 0 : if (slot >= btrfs_header_nritems(leaf)) {
71 : 0 : ret = btrfs_next_leaf(root, path);
72 [ # # ]: 0 : if (ret < 0)
73 : : goto out;
74 [ # # ]: 0 : else if (ret > 0)
75 : : break;
76 : :
77 [ # # # # ]: 0 : if (need_resched() ||
78 : 0 : btrfs_transaction_in_commit(fs_info)) {
79 : 0 : leaf = path->nodes[0];
80 : :
81 [ # # ][ # # ]: 0 : if (WARN_ON(btrfs_header_nritems(leaf) == 0))
82 : : break;
83 : :
84 : : /*
85 : : * Save the key so we can advances forward
86 : : * in the next search.
87 : : */
88 : : btrfs_item_key_to_cpu(leaf, &key, 0);
89 : 0 : btrfs_release_path(path);
90 : 0 : root->cache_progress = last;
91 : 0 : mutex_unlock(&root->fs_commit_mutex);
92 : 0 : schedule_timeout(1);
93 : 0 : goto again;
94 : : } else
95 : 0 : continue;
96 : : }
97 : :
98 : : btrfs_item_key_to_cpu(leaf, &key, slot);
99 : :
100 [ # # ]: 0 : if (key.type != BTRFS_INODE_ITEM_KEY)
101 : : goto next;
102 : :
103 [ # # ]: 0 : if (key.objectid >= root->highest_objectid)
104 : : break;
105 : :
106 [ # # ][ # # ]: 0 : if (last != (u64)-1 && last + 1 != key.objectid) {
107 : 0 : __btrfs_add_free_space(ctl, last + 1,
108 : 0 : key.objectid - last - 1);
109 : 0 : wake_up(&root->cache_wait);
110 : : }
111 : :
112 : 0 : last = key.objectid;
113 : : next:
114 : 0 : path->slots[0]++;
115 : : }
116 : :
117 [ # # ]: 0 : if (last < root->highest_objectid - 1) {
118 : 0 : __btrfs_add_free_space(ctl, last + 1,
119 : 0 : root->highest_objectid - last - 1);
120 : : }
121 : :
122 : : spin_lock(&root->cache_lock);
123 : 0 : root->cached = BTRFS_CACHE_FINISHED;
124 : : spin_unlock(&root->cache_lock);
125 : :
126 : 0 : root->cache_progress = (u64)-1;
127 : 0 : btrfs_unpin_free_ino(root);
128 : : out:
129 : 0 : wake_up(&root->cache_wait);
130 : 0 : mutex_unlock(&root->fs_commit_mutex);
131 : :
132 : 0 : btrfs_free_path(path);
133 : :
134 : 0 : return ret;
135 : : }
136 : :
137 : 0 : static void start_caching(struct btrfs_root *root)
138 : : {
139 : 0 : struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
140 : : struct task_struct *tsk;
141 : : int ret;
142 : : u64 objectid;
143 : :
144 [ # # ]: 0 : if (!btrfs_test_opt(root, INODE_MAP_CACHE))
145 : 0 : return;
146 : :
147 : : spin_lock(&root->cache_lock);
148 [ # # ]: 0 : if (root->cached != BTRFS_CACHE_NO) {
149 : : spin_unlock(&root->cache_lock);
150 : : return;
151 : : }
152 : :
153 : 0 : root->cached = BTRFS_CACHE_STARTED;
154 : : spin_unlock(&root->cache_lock);
155 : :
156 : 0 : ret = load_free_ino_cache(root->fs_info, root);
157 [ # # ]: 0 : if (ret == 1) {
158 : : spin_lock(&root->cache_lock);
159 : 0 : root->cached = BTRFS_CACHE_FINISHED;
160 : : spin_unlock(&root->cache_lock);
161 : : return;
162 : : }
163 : :
164 : : /*
165 : : * It can be quite time-consuming to fill the cache by searching
166 : : * through the extent tree, and this can keep ino allocation path
167 : : * waiting. Therefore at start we quickly find out the highest
168 : : * inode number and we know we can use inode numbers which fall in
169 : : * [highest_ino + 1, BTRFS_LAST_FREE_OBJECTID].
170 : : */
171 : 0 : ret = btrfs_find_free_objectid(root, &objectid);
172 [ # # ][ # # ]: 0 : if (!ret && objectid <= BTRFS_LAST_FREE_OBJECTID) {
173 : 0 : __btrfs_add_free_space(ctl, objectid,
174 : : BTRFS_LAST_FREE_OBJECTID - objectid + 1);
175 : : }
176 : :
177 [ # # ]: 0 : tsk = kthread_run(caching_kthread, root, "btrfs-ino-cache-%llu\n",
178 : : root->root_key.objectid);
179 [ # # ]: 0 : BUG_ON(IS_ERR(tsk)); /* -ENOMEM */
180 : : }
181 : :
182 : 0 : int btrfs_find_free_ino(struct btrfs_root *root, u64 *objectid)
183 : : {
184 [ # # ]: 0 : if (!btrfs_test_opt(root, INODE_MAP_CACHE))
185 : 0 : return btrfs_find_free_objectid(root, objectid);
186 : :
187 : : again:
188 : 0 : *objectid = btrfs_find_ino_for_alloc(root);
189 : :
190 [ # # ]: 0 : if (*objectid != 0)
191 : : return 0;
192 : :
193 : 0 : start_caching(root);
194 : :
195 [ # # ][ # # ]: 0 : wait_event(root->cache_wait,
[ # # ][ # # ]
196 : : root->cached == BTRFS_CACHE_FINISHED ||
197 : : root->free_ino_ctl->free_space > 0);
198 : :
199 [ # # ][ # # ]: 0 : if (root->cached == BTRFS_CACHE_FINISHED &&
200 : 0 : root->free_ino_ctl->free_space == 0)
201 : : return -ENOSPC;
202 : : else
203 : : goto again;
204 : : }
205 : :
206 : 0 : void btrfs_return_ino(struct btrfs_root *root, u64 objectid)
207 : : {
208 : 0 : struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
209 : 0 : struct btrfs_free_space_ctl *pinned = root->free_ino_pinned;
210 : :
211 [ # # ]: 0 : if (!btrfs_test_opt(root, INODE_MAP_CACHE))
212 : 0 : return;
213 : :
214 : : again:
215 [ # # ]: 0 : if (root->cached == BTRFS_CACHE_FINISHED) {
216 : 0 : __btrfs_add_free_space(ctl, objectid, 1);
217 : : } else {
218 : : /*
219 : : * If we are in the process of caching free ino chunks,
220 : : * to avoid adding the same inode number to the free_ino
221 : : * tree twice due to cross transaction, we'll leave it
222 : : * in the pinned tree until a transaction is committed
223 : : * or the caching work is done.
224 : : */
225 : :
226 : 0 : mutex_lock(&root->fs_commit_mutex);
227 : : spin_lock(&root->cache_lock);
228 [ # # ]: 0 : if (root->cached == BTRFS_CACHE_FINISHED) {
229 : : spin_unlock(&root->cache_lock);
230 : 0 : mutex_unlock(&root->fs_commit_mutex);
231 : 0 : goto again;
232 : : }
233 : : spin_unlock(&root->cache_lock);
234 : :
235 : 0 : start_caching(root);
236 : :
237 [ # # ][ # # ]: 0 : if (objectid <= root->cache_progress ||
238 : 0 : objectid >= root->highest_objectid)
239 : 0 : __btrfs_add_free_space(ctl, objectid, 1);
240 : : else
241 : 0 : __btrfs_add_free_space(pinned, objectid, 1);
242 : :
243 : 0 : mutex_unlock(&root->fs_commit_mutex);
244 : : }
245 : : }
246 : :
247 : : /*
248 : : * When a transaction is committed, we'll move those inode numbers which
249 : : * are smaller than root->cache_progress from pinned tree to free_ino tree,
250 : : * and others will just be dropped, because the commit root we were
251 : : * searching has changed.
252 : : *
253 : : * Must be called with root->fs_commit_mutex held
254 : : */
255 : 0 : void btrfs_unpin_free_ino(struct btrfs_root *root)
256 : : {
257 : 0 : struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
258 : 0 : struct rb_root *rbroot = &root->free_ino_pinned->free_space_offset;
259 : : struct btrfs_free_space *info;
260 : : struct rb_node *n;
261 : : u64 count;
262 : :
263 [ # # ]: 0 : if (!btrfs_test_opt(root, INODE_MAP_CACHE))
264 : 0 : return;
265 : :
266 : : while (1) {
267 : 0 : n = rb_first(rbroot);
268 [ # # ]: 0 : if (!n)
269 : : break;
270 : :
271 : : info = rb_entry(n, struct btrfs_free_space, offset_index);
272 [ # # ]: 0 : BUG_ON(info->bitmap); /* Logic error */
273 : :
274 [ # # ]: 0 : if (info->offset > root->cache_progress)
275 : : goto free;
276 [ # # ]: 0 : else if (info->offset + info->bytes > root->cache_progress)
277 : 0 : count = root->cache_progress - info->offset + 1;
278 : : else
279 : : count = info->bytes;
280 : :
281 : 0 : __btrfs_add_free_space(ctl, info->offset, count);
282 : : free:
283 : 0 : rb_erase(&info->offset_index, rbroot);
284 : 0 : kfree(info);
285 : 0 : }
286 : : }
287 : :
288 : : #define INIT_THRESHOLD (((1024 * 32) / 2) / sizeof(struct btrfs_free_space))
289 : : #define INODES_PER_BITMAP (PAGE_CACHE_SIZE * 8)
290 : :
291 : : /*
292 : : * The goal is to keep the memory used by the free_ino tree won't
293 : : * exceed the memory if we use bitmaps only.
294 : : */
295 : 0 : static void recalculate_thresholds(struct btrfs_free_space_ctl *ctl)
296 : : {
297 : : struct btrfs_free_space *info;
298 : : struct rb_node *n;
299 : : int max_ino;
300 : : int max_bitmaps;
301 : :
302 : 0 : n = rb_last(&ctl->free_space_offset);
303 [ # # ]: 0 : if (!n) {
304 : 0 : ctl->extents_thresh = INIT_THRESHOLD;
305 : 0 : return;
306 : : }
307 : : info = rb_entry(n, struct btrfs_free_space, offset_index);
308 : :
309 : : /*
310 : : * Find the maximum inode number in the filesystem. Note we
311 : : * ignore the fact that this can be a bitmap, because we are
312 : : * not doing precise calculation.
313 : : */
314 : 0 : max_ino = info->bytes - 1;
315 : :
316 : 0 : max_bitmaps = ALIGN(max_ino, INODES_PER_BITMAP) / INODES_PER_BITMAP;
317 [ # # ]: 0 : if (max_bitmaps <= ctl->total_bitmaps) {
318 : 0 : ctl->extents_thresh = 0;
319 : 0 : return;
320 : : }
321 : :
322 : 0 : ctl->extents_thresh = (max_bitmaps - ctl->total_bitmaps) *
323 : 0 : PAGE_CACHE_SIZE / sizeof(*info);
324 : : }
325 : :
326 : : /*
327 : : * We don't fall back to bitmap, if we are below the extents threshold
328 : : * or this chunk of inode numbers is a big one.
329 : : */
330 : 0 : static bool use_bitmap(struct btrfs_free_space_ctl *ctl,
331 : : struct btrfs_free_space *info)
332 : : {
333 [ # # ][ # # ]: 0 : if (ctl->free_extents < ctl->extents_thresh ||
334 : 0 : info->bytes > INODES_PER_BITMAP / 10)
335 : : return false;
336 : :
337 : 0 : return true;
338 : : }
339 : :
340 : : static struct btrfs_free_space_op free_ino_op = {
341 : : .recalc_thresholds = recalculate_thresholds,
342 : : .use_bitmap = use_bitmap,
343 : : };
344 : :
345 : 0 : static void pinned_recalc_thresholds(struct btrfs_free_space_ctl *ctl)
346 : : {
347 : 0 : }
348 : :
349 : 0 : static bool pinned_use_bitmap(struct btrfs_free_space_ctl *ctl,
350 : : struct btrfs_free_space *info)
351 : : {
352 : : /*
353 : : * We always use extents for two reasons:
354 : : *
355 : : * - The pinned tree is only used during the process of caching
356 : : * work.
357 : : * - Make code simpler. See btrfs_unpin_free_ino().
358 : : */
359 : 0 : return false;
360 : : }
361 : :
362 : : static struct btrfs_free_space_op pinned_free_ino_op = {
363 : : .recalc_thresholds = pinned_recalc_thresholds,
364 : : .use_bitmap = pinned_use_bitmap,
365 : : };
366 : :
367 : 0 : void btrfs_init_free_ino_ctl(struct btrfs_root *root)
368 : : {
369 : 0 : struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
370 : 0 : struct btrfs_free_space_ctl *pinned = root->free_ino_pinned;
371 : :
372 : 0 : spin_lock_init(&ctl->tree_lock);
373 : 0 : ctl->unit = 1;
374 : 0 : ctl->start = 0;
375 : 0 : ctl->private = NULL;
376 : 0 : ctl->op = &free_ino_op;
377 : :
378 : : /*
379 : : * Initially we allow to use 16K of ram to cache chunks of
380 : : * inode numbers before we resort to bitmaps. This is somewhat
381 : : * arbitrary, but it will be adjusted in runtime.
382 : : */
383 : 0 : ctl->extents_thresh = INIT_THRESHOLD;
384 : :
385 : 0 : spin_lock_init(&pinned->tree_lock);
386 : 0 : pinned->unit = 1;
387 : 0 : pinned->start = 0;
388 : 0 : pinned->private = NULL;
389 : 0 : pinned->extents_thresh = 0;
390 : 0 : pinned->op = &pinned_free_ino_op;
391 : 0 : }
392 : :
393 : 0 : int btrfs_save_ino_cache(struct btrfs_root *root,
394 : : struct btrfs_trans_handle *trans)
395 : : {
396 : 0 : struct btrfs_free_space_ctl *ctl = root->free_ino_ctl;
397 : : struct btrfs_path *path;
398 : : struct inode *inode;
399 : : struct btrfs_block_rsv *rsv;
400 : : u64 num_bytes;
401 : 0 : u64 alloc_hint = 0;
402 : : int ret;
403 : : int prealloc;
404 : : bool retry = false;
405 : :
406 : : /* only fs tree and subvol/snap needs ino cache */
407 [ # # ]: 0 : if (root->root_key.objectid != BTRFS_FS_TREE_OBJECTID &&
408 : : (root->root_key.objectid < BTRFS_FIRST_FREE_OBJECTID ||
409 : : root->root_key.objectid > BTRFS_LAST_FREE_OBJECTID))
410 : : return 0;
411 : :
412 : : /* Don't save inode cache if we are deleting this root */
413 [ # # ]: 0 : if (btrfs_root_refs(&root->root_item) == 0)
414 : : return 0;
415 : :
416 [ # # ]: 0 : if (!btrfs_test_opt(root, INODE_MAP_CACHE))
417 : : return 0;
418 : :
419 : 0 : path = btrfs_alloc_path();
420 [ # # ]: 0 : if (!path)
421 : : return -ENOMEM;
422 : :
423 : 0 : rsv = trans->block_rsv;
424 : 0 : trans->block_rsv = &root->fs_info->trans_block_rsv;
425 : :
426 : 0 : num_bytes = trans->bytes_reserved;
427 : : /*
428 : : * 1 item for inode item insertion if need
429 : : * 4 items for inode item update (in the worst case)
430 : : * 1 items for slack space if we need do truncation
431 : : * 1 item for free space object
432 : : * 3 items for pre-allocation
433 : : */
434 : 0 : trans->bytes_reserved = btrfs_calc_trans_metadata_size(root, 10);
435 : 0 : ret = btrfs_block_rsv_add(root, trans->block_rsv,
436 : : trans->bytes_reserved,
437 : : BTRFS_RESERVE_NO_FLUSH);
438 [ # # ]: 0 : if (ret)
439 : : goto out;
440 : 0 : trace_btrfs_space_reservation(root->fs_info, "ino_cache",
441 : : trans->transid, trans->bytes_reserved, 1);
442 : : again:
443 : 0 : inode = lookup_free_ino_inode(root, path);
444 [ # # ][ # # ]: 0 : if (IS_ERR(inode) && (PTR_ERR(inode) != -ENOENT || retry)) {
[ # # ]
445 : : ret = PTR_ERR(inode);
446 : : goto out_release;
447 : : }
448 : :
449 [ # # ]: 0 : if (IS_ERR(inode)) {
450 [ # # ]: 0 : BUG_ON(retry); /* Logic error */
451 : : retry = true;
452 : :
453 : 0 : ret = create_free_ino_inode(root, trans, path);
454 [ # # ]: 0 : if (ret)
455 : : goto out_release;
456 : : goto again;
457 : : }
458 : :
459 : 0 : BTRFS_I(inode)->generation = 0;
460 : 0 : ret = btrfs_update_inode(trans, root, inode);
461 [ # # ]: 0 : if (ret) {
462 : 0 : btrfs_abort_transaction(trans, root, ret);
463 : 0 : goto out_put;
464 : : }
465 : :
466 [ # # ]: 0 : if (i_size_read(inode) > 0) {
467 : 0 : ret = btrfs_truncate_free_space_cache(root, trans, inode);
468 [ # # ]: 0 : if (ret) {
469 [ # # ]: 0 : if (ret != -ENOSPC)
470 : 0 : btrfs_abort_transaction(trans, root, ret);
471 : : goto out_put;
472 : : }
473 : : }
474 : :
475 : : spin_lock(&root->cache_lock);
476 [ # # ]: 0 : if (root->cached != BTRFS_CACHE_FINISHED) {
477 : : ret = -1;
478 : : spin_unlock(&root->cache_lock);
479 : : goto out_put;
480 : : }
481 : : spin_unlock(&root->cache_lock);
482 : :
483 : : spin_lock(&ctl->tree_lock);
484 : 0 : prealloc = sizeof(struct btrfs_free_space) * ctl->free_extents;
485 : 0 : prealloc = ALIGN(prealloc, PAGE_CACHE_SIZE);
486 : 0 : prealloc += ctl->total_bitmaps * PAGE_CACHE_SIZE;
487 : : spin_unlock(&ctl->tree_lock);
488 : :
489 : : /* Just to make sure we have enough space */
490 : 0 : prealloc += 8 * PAGE_CACHE_SIZE;
491 : :
492 : 0 : ret = btrfs_delalloc_reserve_space(inode, prealloc);
493 [ # # ]: 0 : if (ret)
494 : : goto out_put;
495 : :
496 : 0 : ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, prealloc,
497 : : prealloc, prealloc, &alloc_hint);
498 [ # # ]: 0 : if (ret) {
499 : 0 : btrfs_delalloc_release_space(inode, prealloc);
500 : 0 : goto out_put;
501 : : }
502 : 0 : btrfs_free_reserved_data_space(inode, prealloc);
503 : :
504 : 0 : ret = btrfs_write_out_ino_cache(root, trans, path, inode);
505 : : out_put:
506 : 0 : iput(inode);
507 : : out_release:
508 : 0 : trace_btrfs_space_reservation(root->fs_info, "ino_cache",
509 : : trans->transid, trans->bytes_reserved, 0);
510 : 0 : btrfs_block_rsv_release(root, trans->block_rsv, trans->bytes_reserved);
511 : : out:
512 : 0 : trans->block_rsv = rsv;
513 : 0 : trans->bytes_reserved = num_bytes;
514 : :
515 : 0 : btrfs_free_path(path);
516 : 0 : return ret;
517 : : }
518 : :
519 : 0 : static int btrfs_find_highest_objectid(struct btrfs_root *root, u64 *objectid)
520 : : {
521 : : struct btrfs_path *path;
522 : : int ret;
523 : : struct extent_buffer *l;
524 : : struct btrfs_key search_key;
525 : : struct btrfs_key found_key;
526 : : int slot;
527 : :
528 : 0 : path = btrfs_alloc_path();
529 [ # # ]: 0 : if (!path)
530 : : return -ENOMEM;
531 : :
532 : 0 : search_key.objectid = BTRFS_LAST_FREE_OBJECTID;
533 : 0 : search_key.type = -1;
534 : 0 : search_key.offset = (u64)-1;
535 : 0 : ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0);
536 [ # # ]: 0 : if (ret < 0)
537 : : goto error;
538 [ # # ]: 0 : BUG_ON(ret == 0); /* Corruption */
539 [ # # ]: 0 : if (path->slots[0] > 0) {
540 : 0 : slot = path->slots[0] - 1;
541 : 0 : l = path->nodes[0];
542 : : btrfs_item_key_to_cpu(l, &found_key, slot);
543 : 0 : *objectid = max_t(u64, found_key.objectid,
544 : : BTRFS_FIRST_FREE_OBJECTID - 1);
545 : : } else {
546 : 0 : *objectid = BTRFS_FIRST_FREE_OBJECTID - 1;
547 : : }
548 : : ret = 0;
549 : : error:
550 : 0 : btrfs_free_path(path);
551 : 0 : return ret;
552 : : }
553 : :
554 : 0 : int btrfs_find_free_objectid(struct btrfs_root *root, u64 *objectid)
555 : : {
556 : : int ret;
557 : 0 : mutex_lock(&root->objectid_mutex);
558 : :
559 [ # # ]: 0 : if (unlikely(root->highest_objectid < BTRFS_FIRST_FREE_OBJECTID)) {
560 : 0 : ret = btrfs_find_highest_objectid(root,
561 : : &root->highest_objectid);
562 [ # # ]: 0 : if (ret)
563 : : goto out;
564 : : }
565 : :
566 [ # # ]: 0 : if (unlikely(root->highest_objectid >= BTRFS_LAST_FREE_OBJECTID)) {
567 : : ret = -ENOSPC;
568 : : goto out;
569 : : }
570 : :
571 : 0 : *objectid = ++root->highest_objectid;
572 : : ret = 0;
573 : : out:
574 : 0 : mutex_unlock(&root->objectid_mutex);
575 : 0 : return ret;
576 : : }
|
