HAMMER VFS - Limit recursion for long directory chains, update mtime/ctime
[dragonfly.git] / sys / vfs / hammer / hammer_object.c
CommitLineData
66325755 1/*
b84de5af 2 * Copyright (c) 2007-2008 The DragonFly Project. All rights reserved.
66325755
MD
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
35a49944 34 * $DragonFly: src/sys/vfs/hammer/hammer_object.c,v 1.97 2008/09/23 22:28:56 dillon Exp $
66325755
MD
35 */
36
37#include "hammer.h"
38
45a014dc 39static int hammer_mem_lookup(hammer_cursor_t cursor);
3214ade6 40static void hammer_mem_first(hammer_cursor_t cursor);
312de84d 41static int hammer_frontend_trunc_callback(hammer_record_t record,
0832c9bb 42 void *data __unused);
d7e278bb 43static int hammer_bulk_scan_callback(hammer_record_t record, void *data);
cb51be26 44static int hammer_record_needs_overwrite_delete(hammer_record_t record);
5fa5c92f
MD
45static int hammer_delete_general(hammer_cursor_t cursor, hammer_inode_t ip,
46 hammer_btree_leaf_elm_t leaf);
8cd0a023 47
47637bff
MD
48struct rec_trunc_info {
49 u_int16_t rec_type;
50 int64_t trunc_off;
51};
52
d7e278bb
MD
53struct hammer_bulk_info {
54 hammer_record_t record;
55 struct hammer_btree_leaf_elm leaf;
56};
57
66325755 58/*
0832c9bb 59 * Red-black tree support. Comparison code for insertion.
66325755 60 */
8cd0a023 61static int
a89aec1b 62hammer_rec_rb_compare(hammer_record_t rec1, hammer_record_t rec2)
8cd0a023 63{
11ad5ade 64 if (rec1->leaf.base.rec_type < rec2->leaf.base.rec_type)
8cd0a023 65 return(-1);
11ad5ade 66 if (rec1->leaf.base.rec_type > rec2->leaf.base.rec_type)
8cd0a023
MD
67 return(1);
68
11ad5ade 69 if (rec1->leaf.base.key < rec2->leaf.base.key)
8cd0a023 70 return(-1);
11ad5ade 71 if (rec1->leaf.base.key > rec2->leaf.base.key)
8cd0a023
MD
72 return(1);
73
ec4e8497 74 /*
3214ade6
MD
75 * For search & insertion purposes records deleted by the
76 * frontend or deleted/committed by the backend are silently
77 * ignored. Otherwise pipelined insertions will get messed
78 * up.
bf3b416b
MD
79 *
80 * rec1 is greater then rec2 if rec1 is marked deleted.
81 * rec1 is less then rec2 if rec2 is marked deleted.
82 *
83 * Multiple deleted records may be present, do not return 0
84 * if both are marked deleted.
ec4e8497 85 */
3214ade6
MD
86 if (rec1->flags & (HAMMER_RECF_DELETED_FE | HAMMER_RECF_DELETED_BE |
87 HAMMER_RECF_COMMITTED)) {
ec4e8497 88 return(1);
3214ade6
MD
89 }
90 if (rec2->flags & (HAMMER_RECF_DELETED_FE | HAMMER_RECF_DELETED_BE |
91 HAMMER_RECF_COMMITTED)) {
ec4e8497 92 return(-1);
3214ade6 93 }
ec4e8497 94
8cd0a023
MD
95 return(0);
96}
97
0832c9bb
MD
98/*
99 * Basic record comparison code similar to hammer_btree_cmp().
100 */
8cd0a023 101static int
0832c9bb 102hammer_rec_cmp(hammer_base_elm_t elm, hammer_record_t rec)
66325755 103{
0832c9bb 104 if (elm->rec_type < rec->leaf.base.rec_type)
d26d0ae9 105 return(-3);
0832c9bb 106 if (elm->rec_type > rec->leaf.base.rec_type)
d26d0ae9 107 return(3);
8cd0a023 108
0832c9bb 109 if (elm->key < rec->leaf.base.key)
8cd0a023 110 return(-2);
0832c9bb 111 if (elm->key > rec->leaf.base.key)
8cd0a023
MD
112 return(2);
113
cebe9493 114 /*
3214ade6
MD
115 * Never match against an item deleted by the frontend
116 * or backend, or committed by the backend.
117 *
bf3b416b 118 * elm is less then rec if rec is marked deleted.
cebe9493 119 */
3214ade6
MD
120 if (rec->flags & (HAMMER_RECF_DELETED_FE | HAMMER_RECF_DELETED_BE |
121 HAMMER_RECF_COMMITTED)) {
bf3b416b 122 return(-1);
3214ade6 123 }
0832c9bb
MD
124 return(0);
125}
126
127/*
d7e278bb
MD
128 * Ranged scan to locate overlapping record(s). This is used by
129 * hammer_ip_get_bulk() to locate an overlapping record. We have
130 * to use a ranged scan because the keys for data records with the
131 * same file base offset can be different due to differing data_len's.
0832c9bb
MD
132 *
133 * NOTE: The base file offset of a data record is (key - data_len), not (key).
134 */
135static int
d7e278bb 136hammer_rec_overlap_cmp(hammer_record_t rec, void *data)
0832c9bb 137{
d7e278bb
MD
138 struct hammer_bulk_info *info = data;
139 hammer_btree_leaf_elm_t leaf = &info->leaf;
140
141 if (rec->leaf.base.rec_type < leaf->base.rec_type)
0832c9bb 142 return(-3);
d7e278bb 143 if (rec->leaf.base.rec_type > leaf->base.rec_type)
0832c9bb
MD
144 return(3);
145
4a2796f3
MD
146 /*
147 * Overlap compare
148 */
0832c9bb 149 if (leaf->base.rec_type == HAMMER_RECTYPE_DATA) {
d7e278bb
MD
150 /* rec_beg >= leaf_end */
151 if (rec->leaf.base.key - rec->leaf.data_len >= leaf->base.key)
0832c9bb 152 return(2);
d7e278bb
MD
153 /* rec_end <= leaf_beg */
154 if (rec->leaf.base.key <= leaf->base.key - leaf->data_len)
155 return(-2);
0832c9bb 156 } else {
d7e278bb 157 if (rec->leaf.base.key < leaf->base.key)
0832c9bb 158 return(-2);
d7e278bb 159 if (rec->leaf.base.key > leaf->base.key)
0832c9bb
MD
160 return(2);
161 }
162
cebe9493 163 /*
d7e278bb
MD
164 * We have to return 0 at this point, even if DELETED_FE is set,
165 * because returning anything else will cause the scan to ignore
166 * one of the branches when we really want it to check both.
cebe9493 167 */
8cd0a023 168 return(0);
66325755
MD
169}
170
6b4f890b 171/*
7f7c1f84 172 * RB_SCAN comparison code for hammer_mem_first(). The argument order
6b4f890b 173 * is reversed so the comparison result has to be negated. key_beg and
7f7c1f84
MD
174 * key_end are both range-inclusive.
175 *
7f7c1f84 176 * Localized deletions are not cached in-memory.
6b4f890b
MD
177 */
178static
179int
180hammer_rec_scan_cmp(hammer_record_t rec, void *data)
181{
182 hammer_cursor_t cursor = data;
183 int r;
184
0832c9bb 185 r = hammer_rec_cmp(&cursor->key_beg, rec);
7f7c1f84 186 if (r > 1)
6b4f890b 187 return(-1);
0832c9bb 188 r = hammer_rec_cmp(&cursor->key_end, rec);
7f7c1f84 189 if (r < -1)
6b4f890b
MD
190 return(1);
191 return(0);
192}
193
2ae23e2e
MD
194/*
195 * This compare function is used when simply looking up key_beg.
196 */
197static
198int
199hammer_rec_find_cmp(hammer_record_t rec, void *data)
200{
201 hammer_cursor_t cursor = data;
202 int r;
203
0832c9bb 204 r = hammer_rec_cmp(&cursor->key_beg, rec);
2ae23e2e
MD
205 if (r > 1)
206 return(-1);
207 if (r < -1)
208 return(1);
209 return(0);
210}
211
47637bff
MD
212/*
213 * Locate blocks within the truncation range. Partial blocks do not count.
214 */
215static
216int
217hammer_rec_trunc_cmp(hammer_record_t rec, void *data)
218{
219 struct rec_trunc_info *info = data;
220
221 if (rec->leaf.base.rec_type < info->rec_type)
222 return(-1);
223 if (rec->leaf.base.rec_type > info->rec_type)
224 return(1);
225
226 switch(rec->leaf.base.rec_type) {
227 case HAMMER_RECTYPE_DB:
228 /*
229 * DB record key is not beyond the truncation point, retain.
230 */
231 if (rec->leaf.base.key < info->trunc_off)
232 return(-1);
233 break;
234 case HAMMER_RECTYPE_DATA:
235 /*
236 * DATA record offset start is not beyond the truncation point,
237 * retain.
238 */
239 if (rec->leaf.base.key - rec->leaf.data_len < info->trunc_off)
240 return(-1);
241 break;
242 default:
243 panic("hammer_rec_trunc_cmp: unexpected record type");
244 }
245
246 /*
247 * The record start is >= the truncation point, return match,
248 * the record should be destroyed.
249 */
250 return(0);
251}
252
8cd0a023 253RB_GENERATE(hammer_rec_rb_tree, hammer_record, rb_node, hammer_rec_rb_compare);
8cd0a023
MD
254
255/*
d26d0ae9 256 * Allocate a record for the caller to finish filling in. The record is
b3deaf57 257 * returned referenced.
a89aec1b
MD
258 */
259hammer_record_t
11ad5ade 260hammer_alloc_mem_record(hammer_inode_t ip, int data_len)
a89aec1b
MD
261{
262 hammer_record_t record;
bac808fe 263 hammer_mount_t hmp;
a89aec1b 264
bac808fe 265 hmp = ip->hmp;
b3deaf57 266 ++hammer_count_records;
bac808fe 267 record = kmalloc(sizeof(*record), hmp->m_misc,
df301614 268 M_WAITOK | M_ZERO | M_USE_RESERVE);
1f07f686 269 record->flush_state = HAMMER_FST_IDLE;
a89aec1b 270 record->ip = ip;
11ad5ade
MD
271 record->leaf.base.btype = HAMMER_BTREE_TYPE_RECORD;
272 record->leaf.data_len = data_len;
d26d0ae9 273 hammer_ref(&record->lock);
11ad5ade
MD
274
275 if (data_len) {
bac808fe 276 record->data = kmalloc(data_len, hmp->m_misc, M_WAITOK | M_ZERO);
11ad5ade
MD
277 record->flags |= HAMMER_RECF_ALLOCDATA;
278 ++hammer_count_record_datas;
279 }
280
a89aec1b
MD
281 return (record);
282}
283
b84de5af 284void
af209b0f 285hammer_wait_mem_record_ident(hammer_record_t record, const char *ident)
b84de5af 286{
1f07f686 287 while (record->flush_state == HAMMER_FST_FLUSH) {
b84de5af 288 record->flags |= HAMMER_RECF_WANTED;
af209b0f 289 tsleep(record, 0, ident, 0);
b84de5af
MD
290 }
291}
292
293/*
d36ec43b
MD
294 * Called from the backend, hammer_inode.c, after a record has been
295 * flushed to disk. The record has been exclusively locked by the
296 * caller and interlocked with BE.
b84de5af 297 *
d36ec43b
MD
298 * We clean up the state, unlock, and release the record (the record
299 * was referenced by the fact that it was in the HAMMER_FST_FLUSH state).
b84de5af
MD
300 */
301void
d36ec43b 302hammer_flush_record_done(hammer_record_t record, int error)
b84de5af 303{
1f07f686 304 hammer_inode_t target_ip;
1f07f686
MD
305
306 KKASSERT(record->flush_state == HAMMER_FST_FLUSH);
d36ec43b
MD
307 KKASSERT(record->flags & HAMMER_RECF_INTERLOCK_BE);
308
3214ade6
MD
309 /*
310 * If an error occured, the backend was unable to sync the
311 * record to its media. Leave the record intact.
312 */
d36ec43b 313 if (error) {
cdb6e4e6
MD
314 hammer_critical_error(record->ip->hmp, record->ip, error,
315 "while flushing record");
d36ec43b 316 }
4e17f465 317
7a61b85d
MD
318 --record->flush_group->refs;
319 record->flush_group = NULL;
320
3214ade6
MD
321 /*
322 * Adjust the flush state and dependancy based on success or
323 * failure.
324 */
325 if (record->flags & (HAMMER_RECF_DELETED_BE | HAMMER_RECF_COMMITTED)) {
1f07f686
MD
326 if ((target_ip = record->target_ip) != NULL) {
327 TAILQ_REMOVE(&target_ip->target_list, record,
328 target_entry);
329 record->target_ip = NULL;
330 hammer_test_inode(target_ip);
331 }
332 record->flush_state = HAMMER_FST_IDLE;
333 } else {
c4bae5fd 334 if (record->target_ip) {
1f07f686 335 record->flush_state = HAMMER_FST_SETUP;
c4bae5fd
MD
336 hammer_test_inode(record->ip);
337 hammer_test_inode(record->target_ip);
338 } else {
1f07f686 339 record->flush_state = HAMMER_FST_IDLE;
c4bae5fd 340 }
1f07f686 341 }
d36ec43b 342 record->flags &= ~HAMMER_RECF_INTERLOCK_BE;
3214ade6
MD
343
344 /*
345 * Cleanup
346 */
b84de5af
MD
347 if (record->flags & HAMMER_RECF_WANTED) {
348 record->flags &= ~HAMMER_RECF_WANTED;
349 wakeup(record);
350 }
351 hammer_rel_mem_record(record);
352}
353
ec4e8497 354/*
b3deaf57
MD
355 * Release a memory record. Records marked for deletion are immediately
356 * removed from the RB-Tree but otherwise left intact until the last ref
357 * goes away.
a89aec1b
MD
358 */
359void
b3deaf57 360hammer_rel_mem_record(struct hammer_record *record)
a89aec1b 361{
1b0ab2c3
MD
362 hammer_mount_t hmp;
363 hammer_reserve_t resv;
364 hammer_inode_t ip;
365 hammer_inode_t target_ip;
1f07f686 366
b3deaf57 367 hammer_unref(&record->lock);
b33e2cc0 368
0832c9bb
MD
369 if (record->lock.refs == 0) {
370 /*
371 * Upon release of the last reference wakeup any waiters.
372 * The record structure may get destroyed so callers will
373 * loop up and do a relookup.
bf3b416b
MD
374 *
375 * WARNING! Record must be removed from RB-TREE before we
376 * might possibly block. hammer_test_inode() can block!
0832c9bb
MD
377 */
378 ip = record->ip;
1b0ab2c3 379 hmp = ip->hmp;
0832c9bb
MD
380
381 /*
382 * Upon release of the last reference a record marked deleted
3214ade6 383 * by the front or backend, or committed by the backend,
0832c9bb
MD
384 * is destroyed.
385 */
3214ade6
MD
386 if (record->flags & (HAMMER_RECF_DELETED_FE |
387 HAMMER_RECF_DELETED_BE |
388 HAMMER_RECF_COMMITTED)) {
bf3b416b 389 KKASSERT(ip->lock.refs > 0);
1f07f686
MD
390 KKASSERT(record->flush_state != HAMMER_FST_FLUSH);
391
bf3b416b
MD
392 /*
393 * target_ip may have zero refs, we have to ref it
394 * to prevent it from being ripped out from under
395 * us.
396 */
1f07f686
MD
397 if ((target_ip = record->target_ip) != NULL) {
398 TAILQ_REMOVE(&target_ip->target_list,
399 record, target_entry);
400 record->target_ip = NULL;
bf3b416b 401 hammer_ref(&target_ip->lock);
1f07f686 402 }
d36ec43b 403
b84de5af
MD
404 if (record->flags & HAMMER_RECF_ONRBTREE) {
405 RB_REMOVE(hammer_rec_rb_tree,
406 &record->ip->rec_tree,
407 record);
47637bff 408 KKASSERT(ip->rsv_recs > 0);
1b0ab2c3 409 --hmp->rsv_recs;
47637bff 410 --ip->rsv_recs;
1b0ab2c3 411 hmp->rsv_databytes -= record->leaf.data_len;
b84de5af 412 record->flags &= ~HAMMER_RECF_ONRBTREE;
a99b9ea2 413
ae8bb789
MD
414 if (RB_EMPTY(&record->ip->rec_tree)) {
415 record->ip->flags &= ~HAMMER_INODE_XDIRTY;
0832c9bb 416 record->ip->sync_flags &= ~HAMMER_INODE_XDIRTY;
ae8bb789
MD
417 hammer_test_inode(record->ip);
418 }
b84de5af 419 }
bf3b416b
MD
420
421 /*
1b0ab2c3 422 * We must wait for any direct-IO to complete before
e469566b
MD
423 * we can destroy the record because the bio may
424 * have a reference to it.
1b0ab2c3 425 */
e469566b
MD
426 if (record->flags &
427 (HAMMER_RECF_DIRECT_IO | HAMMER_RECF_DIRECT_INVAL)) {
1b0ab2c3 428 hammer_io_direct_wait(record);
e469566b 429 }
1b0ab2c3
MD
430
431
432 /*
bf3b416b
MD
433 * Do this test after removing record from the B-Tree.
434 */
435 if (target_ip) {
436 hammer_test_inode(target_ip);
437 hammer_rel_inode(target_ip, 0);
438 }
439
b3deaf57
MD
440 if (record->flags & HAMMER_RECF_ALLOCDATA) {
441 --hammer_count_record_datas;
bac808fe 442 kfree(record->data, hmp->m_misc);
b3deaf57
MD
443 record->flags &= ~HAMMER_RECF_ALLOCDATA;
444 }
1b0ab2c3
MD
445
446 /*
3214ade6
MD
447 * Release the reservation.
448 *
449 * If the record was not committed we can theoretically
450 * undo the reservation. However, doing so might
451 * create weird edge cases with the ordering of
452 * direct writes because the related buffer cache
453 * elements are per-vnode. So we don't try.
1b0ab2c3
MD
454 */
455 if ((resv = record->resv) != NULL) {
3214ade6 456 /* XXX undo leaf.data_offset,leaf.data_len */
1b0ab2c3 457 hammer_blockmap_reserve_complete(hmp, resv);
0832c9bb
MD
458 record->resv = NULL;
459 }
b3deaf57
MD
460 record->data = NULL;
461 --hammer_count_records;
bac808fe 462 kfree(record, hmp->m_misc);
a89aec1b 463 }
a89aec1b 464 }
a89aec1b
MD
465}
466
467/*
a5fddc16 468 * Record visibility depends on whether the record is being accessed by
3214ade6
MD
469 * the backend or the frontend. Backend tests ignore the frontend delete
470 * flag. Frontend tests do NOT ignore the backend delete/commit flags and
471 * must also check for commit races.
a5fddc16
MD
472 *
473 * Return non-zero if the record is visible, zero if it isn't or if it is
3214ade6
MD
474 * deleted. Returns 0 if the record has been comitted (unless the special
475 * delete-visibility flag is set). A committed record must be located
476 * via the media B-Tree. Returns non-zero if the record is good.
5e435c92
MD
477 *
478 * If HAMMER_CURSOR_DELETE_VISIBILITY is set we allow deleted memory
479 * records to be returned. This is so pending deletions are detected
480 * when using an iterator to locate an unused hash key, or when we need
481 * to locate historical records on-disk to destroy.
b84de5af
MD
482 */
483static __inline
484int
a5fddc16 485hammer_ip_iterate_mem_good(hammer_cursor_t cursor, hammer_record_t record)
b84de5af 486{
5e435c92
MD
487 if (cursor->flags & HAMMER_CURSOR_DELETE_VISIBILITY)
488 return(1);
b84de5af 489 if (cursor->flags & HAMMER_CURSOR_BACKEND) {
3214ade6
MD
490 if (record->flags & (HAMMER_RECF_DELETED_BE |
491 HAMMER_RECF_COMMITTED)) {
a5fddc16 492 return(0);
3214ade6 493 }
b84de5af 494 } else {
3214ade6
MD
495 if (record->flags & (HAMMER_RECF_DELETED_FE |
496 HAMMER_RECF_DELETED_BE |
497 HAMMER_RECF_COMMITTED)) {
b84de5af 498 return(0);
3214ade6 499 }
b84de5af
MD
500 }
501 return(1);
502}
503
504/*
2ae23e2e
MD
505 * This callback is used as part of the RB_SCAN function for in-memory
506 * records. We terminate it (return -1) as soon as we get a match.
6b4f890b 507 *
b84de5af
MD
508 * This routine is used by frontend code.
509 *
2ae23e2e
MD
510 * The primary compare code does not account for ASOF lookups. This
511 * code handles that case as well as a few others.
6b4f890b
MD
512 */
513static
514int
515hammer_rec_scan_callback(hammer_record_t rec, void *data)
516{
517 hammer_cursor_t cursor = data;
518
7f7c1f84 519 /*
b33e2cc0
MD
520 * We terminate on success, so this should be NULL on entry.
521 */
522 KKASSERT(cursor->iprec == NULL);
523
524 /*
3214ade6 525 * Skip if the record was marked deleted or committed.
b33e2cc0 526 */
b84de5af 527 if (hammer_ip_iterate_mem_good(cursor, rec) == 0)
b33e2cc0
MD
528 return(0);
529
530 /*
7f7c1f84
MD
531 * Skip if not visible due to our as-of TID
532 */
d5530d22 533 if (cursor->flags & HAMMER_CURSOR_ASOF) {
11ad5ade 534 if (cursor->asof < rec->leaf.base.create_tid)
7f7c1f84 535 return(0);
11ad5ade
MD
536 if (rec->leaf.base.delete_tid &&
537 cursor->asof >= rec->leaf.base.delete_tid) {
7f7c1f84
MD
538 return(0);
539 }
540 }
541
542 /*
3f43fb33
MD
543 * ref the record. The record is protected from backend B-Tree
544 * interactions by virtue of the cursor's IP lock.
7f7c1f84 545 */
b33e2cc0 546 hammer_ref(&rec->lock);
b84de5af 547
b33e2cc0 548 /*
3214ade6
MD
549 * The record may have been deleted or committed while we
550 * were blocked. XXX remove?
b33e2cc0 551 */
b84de5af
MD
552 if (hammer_ip_iterate_mem_good(cursor, rec) == 0) {
553 hammer_rel_mem_record(rec);
b33e2cc0
MD
554 return(0);
555 }
556
557 /*
558 * Set the matching record and stop the scan.
559 */
560 cursor->iprec = rec;
561 return(-1);
6b4f890b
MD
562}
563
2ae23e2e
MD
564
565/*
566 * Lookup an in-memory record given the key specified in the cursor. Works
567 * just like hammer_btree_lookup() but operates on an inode's in-memory
568 * record list.
569 *
570 * The lookup must fail if the record is marked for deferred deletion.
3214ade6
MD
571 *
572 * The API for mem/btree_lookup() does not mess with the ATE/EOF bits.
2ae23e2e
MD
573 */
574static
575int
45a014dc 576hammer_mem_lookup(hammer_cursor_t cursor)
2ae23e2e 577{
45a014dc 578 KKASSERT(cursor->ip);
2ae23e2e
MD
579 if (cursor->iprec) {
580 hammer_rel_mem_record(cursor->iprec);
581 cursor->iprec = NULL;
582 }
45a014dc 583 hammer_rec_rb_tree_RB_SCAN(&cursor->ip->rec_tree, hammer_rec_find_cmp,
2ae23e2e
MD
584 hammer_rec_scan_callback, cursor);
585
3214ade6 586 return (cursor->iprec ? 0 : ENOENT);
2ae23e2e
MD
587}
588
589/*
590 * hammer_mem_first() - locate the first in-memory record matching the
591 * cursor within the bounds of the key range.
3214ade6
MD
592 *
593 * WARNING! API is slightly different from btree_first(). hammer_mem_first()
594 * will set ATEMEM the same as MEMEOF, and does not return any error.
2ae23e2e 595 */
6b4f890b 596static
3214ade6 597void
4e17f465 598hammer_mem_first(hammer_cursor_t cursor)
6b4f890b 599{
4e17f465
MD
600 hammer_inode_t ip;
601
602 ip = cursor->ip;
603 KKASSERT(ip != NULL);
604
b3deaf57
MD
605 if (cursor->iprec) {
606 hammer_rel_mem_record(cursor->iprec);
607 cursor->iprec = NULL;
608 }
6b4f890b
MD
609 hammer_rec_rb_tree_RB_SCAN(&ip->rec_tree, hammer_rec_scan_cmp,
610 hammer_rec_scan_callback, cursor);
7f7c1f84 611
4e17f465 612 if (cursor->iprec)
3214ade6
MD
613 cursor->flags &= ~(HAMMER_CURSOR_MEMEOF | HAMMER_CURSOR_ATEMEM);
614 else
615 cursor->flags |= HAMMER_CURSOR_MEMEOF | HAMMER_CURSOR_ATEMEM;
6b4f890b
MD
616}
617
a89aec1b
MD
618/************************************************************************
619 * HAMMER IN-MEMORY RECORD FUNCTIONS *
620 ************************************************************************
621 *
622 * These functions manipulate in-memory records. Such records typically
623 * exist prior to being committed to disk or indexed via the on-disk B-Tree.
624 */
625
626/*
8cd0a023
MD
627 * Add a directory entry (dip,ncp) which references inode (ip).
628 *
629 * Note that the low 32 bits of the namekey are set temporarily to create
630 * a unique in-memory record, and may be modified a second time when the
631 * record is synchronized to disk. In particular, the low 32 bits cannot be
632 * all 0's when synching to disk, which is not handled here.
5a930e66
MD
633 *
634 * NOTE: bytes does not include any terminating \0 on name, and name might
635 * not be terminated.
8cd0a023 636 */
66325755 637int
a89aec1b 638hammer_ip_add_directory(struct hammer_transaction *trans,
5a930e66 639 struct hammer_inode *dip, const char *name, int bytes,
66325755
MD
640 struct hammer_inode *ip)
641{
c82af904 642 struct hammer_cursor cursor;
a89aec1b 643 hammer_record_t record;
8cd0a023 644 int error;
5e435c92 645 u_int32_t max_iterations;
8cd0a023 646
11ad5ade 647 record = hammer_alloc_mem_record(dip, HAMMER_ENTRY_SIZE(bytes));
8cd0a023 648
1f07f686 649 record->type = HAMMER_MEM_RECORD_ADD;
5a930e66
MD
650 record->leaf.base.localization = dip->obj_localization +
651 HAMMER_LOCALIZE_MISC;
11ad5ade 652 record->leaf.base.obj_id = dip->obj_id;
5e435c92
MD
653 record->leaf.base.key = hammer_directory_namekey(dip, name, bytes,
654 &max_iterations);
11ad5ade
MD
655 record->leaf.base.rec_type = HAMMER_RECTYPE_DIRENTRY;
656 record->leaf.base.obj_type = ip->ino_leaf.base.obj_type;
657 record->data->entry.obj_id = ip->obj_id;
43c665ae 658 record->data->entry.localization = ip->obj_localization;
5a930e66 659 bcopy(name, record->data->entry.name, bytes);
11ad5ade
MD
660
661 ++ip->ino_data.nlinks;
cc0758d0 662 ip->ino_data.ctime = trans->time;
47637bff 663 hammer_modify_inode(ip, HAMMER_INODE_DDIRTY);
ec4e8497
MD
664
665 /*
c82af904 666 * Find an unused namekey. Both the in-memory record tree and
5e435c92
MD
667 * the B-Tree are checked. We do not want historically deleted
668 * names to create a collision as our iteration space may be limited,
669 * and since create_tid wouldn't match anyway an ASOF search
670 * must be used to locate collisions.
06ad81ff
MD
671 *
672 * delete-visibility is set so pending deletions do not give us
673 * a false-negative on our ability to use an iterator.
5e435c92
MD
674 *
675 * The iterator must not rollover the key. Directory keys only
676 * use the positive key space.
c82af904
MD
677 */
678 hammer_init_cursor(trans, &cursor, &dip->cache[1], dip);
679 cursor.key_beg = record->leaf.base;
680 cursor.flags |= HAMMER_CURSOR_ASOF;
06ad81ff 681 cursor.flags |= HAMMER_CURSOR_DELETE_VISIBILITY;
c82af904
MD
682 cursor.asof = ip->obj_asof;
683
c82af904 684 while (hammer_ip_lookup(&cursor) == 0) {
5e435c92
MD
685 ++record->leaf.base.key;
686 KKASSERT(record->leaf.base.key > 0);
c82af904 687 cursor.key_beg.key = record->leaf.base.key;
5e435c92 688 if (--max_iterations == 0) {
c82af904
MD
689 hammer_rel_mem_record(record);
690 error = ENOSPC;
691 goto failed;
692 }
693 }
694
695 /*
1f07f686
MD
696 * The target inode and the directory entry are bound together.
697 */
698 record->target_ip = ip;
699 record->flush_state = HAMMER_FST_SETUP;
700 TAILQ_INSERT_TAIL(&ip->target_list, record, target_entry);
701
702 /*
703 * The inode now has a dependancy and must be taken out of the idle
704 * state. An inode not in an idle state is given an extra reference.
f153644d
MD
705 *
706 * When transitioning to a SETUP state flag for an automatic reflush
707 * when the dependancies are disposed of if someone is waiting on
708 * the inode.
ec4e8497 709 */
1f07f686
MD
710 if (ip->flush_state == HAMMER_FST_IDLE) {
711 hammer_ref(&ip->lock);
712 ip->flush_state = HAMMER_FST_SETUP;
f153644d
MD
713 if (ip->flags & HAMMER_INODE_FLUSHW)
714 ip->flags |= HAMMER_INODE_REFLUSH;
1f07f686 715 }
47637bff 716 error = hammer_mem_add(record);
f437a2ab
MD
717 if (error == 0) {
718 dip->ino_data.mtime = trans->time;
719 hammer_modify_inode(dip, HAMMER_INODE_MTIME);
720 }
c82af904
MD
721failed:
722 hammer_done_cursor(&cursor);
8cd0a023
MD
723 return(error);
724}
725
726/*
a89aec1b
MD
727 * Delete the directory entry and update the inode link count. The
728 * cursor must be seeked to the directory entry record being deleted.
729 *
b84de5af 730 * The related inode should be share-locked by the caller. The caller is
4c286c36
MD
731 * on the frontend. It could also be NULL indicating that the directory
732 * entry being removed has no related inode.
6a37e7e4
MD
733 *
734 * This function can return EDEADLK requiring the caller to terminate
b84de5af 735 * the cursor, any locks, wait on the returned record, and retry.
8cd0a023 736 */
a89aec1b
MD
737int
738hammer_ip_del_directory(struct hammer_transaction *trans,
739 hammer_cursor_t cursor, struct hammer_inode *dip,
740 struct hammer_inode *ip)
8cd0a023 741{
b84de5af 742 hammer_record_t record;
a89aec1b 743 int error;
8cd0a023 744
47637bff 745 if (hammer_cursor_inmem(cursor)) {
b84de5af
MD
746 /*
747 * In-memory (unsynchronized) records can simply be freed.
3214ade6 748 *
b84de5af
MD
749 * Even though the HAMMER_RECF_DELETED_FE flag is ignored
750 * by the backend, we must still avoid races against the
3214ade6 751 * backend potentially syncing the record to the media.
b84de5af
MD
752 *
753 * We cannot call hammer_ip_delete_record(), that routine may
754 * only be called from the backend.
755 */
756 record = cursor->iprec;
3214ade6
MD
757 if (record->flags & (HAMMER_RECF_INTERLOCK_BE |
758 HAMMER_RECF_DELETED_BE |
759 HAMMER_RECF_COMMITTED)) {
b84de5af
MD
760 KKASSERT(cursor->deadlk_rec == NULL);
761 hammer_ref(&record->lock);
762 cursor->deadlk_rec = record;
763 error = EDEADLK;
764 } else {
1f07f686 765 KKASSERT(record->type == HAMMER_MEM_RECORD_ADD);
d36ec43b 766 record->flags |= HAMMER_RECF_DELETED_FE;
b84de5af
MD
767 error = 0;
768 }
769 } else {
770 /*
771 * If the record is on-disk we have to queue the deletion by
772 * the record's key. This also causes lookups to skip the
773 * record.
774 */
98f7132d
MD
775 KKASSERT(dip->flags &
776 (HAMMER_INODE_ONDISK | HAMMER_INODE_DONDISK));
11ad5ade 777 record = hammer_alloc_mem_record(dip, 0);
1f07f686 778 record->type = HAMMER_MEM_RECORD_DEL;
11ad5ade 779 record->leaf.base = cursor->leaf->base;
1f07f686 780
4c286c36
MD
781 /*
782 * ip may be NULL, indicating the deletion of a directory
783 * entry which has no related inode.
784 */
1f07f686 785 record->target_ip = ip;
4c286c36
MD
786 if (ip) {
787 record->flush_state = HAMMER_FST_SETUP;
788 TAILQ_INSERT_TAIL(&ip->target_list, record,
789 target_entry);
790 } else {
791 record->flush_state = HAMMER_FST_IDLE;
792 }
b84de5af 793
ec4e8497 794 /*
1f07f686
MD
795 * The inode now has a dependancy and must be taken out of
796 * the idle state. An inode not in an idle state is given
797 * an extra reference.
f153644d
MD
798 *
799 * When transitioning to a SETUP state flag for an automatic
800 * reflush when the dependancies are disposed of if someone
801 * is waiting on the inode.
ec4e8497 802 */
4c286c36 803 if (ip && ip->flush_state == HAMMER_FST_IDLE) {
1f07f686
MD
804 hammer_ref(&ip->lock);
805 ip->flush_state = HAMMER_FST_SETUP;
f153644d
MD
806 if (ip->flags & HAMMER_INODE_FLUSHW)
807 ip->flags |= HAMMER_INODE_REFLUSH;
1f07f686 808 }
ec4e8497 809
47637bff 810 error = hammer_mem_add(record);
b84de5af 811 }
a89aec1b
MD
812
813 /*
c0ade690 814 * One less link. The file may still be open in the OS even after
3bf2d80a 815 * all links have gone away.
6a37e7e4
MD
816 *
817 * We have to terminate the cursor before syncing the inode to
3bf2d80a
MD
818 * avoid deadlocking against ourselves. XXX this may no longer
819 * be true.
855942b6 820 *
3bf2d80a
MD
821 * If nlinks drops to zero and the vnode is inactive (or there is
822 * no vnode), call hammer_inode_unloadable_check() to zonk the
823 * inode. If we don't do this here the inode will not be destroyed
824 * on-media until we unmount.
a89aec1b
MD
825 */
826 if (error == 0) {
cc0758d0 827 if (ip) {
4c286c36 828 --ip->ino_data.nlinks; /* do before we might block */
cc0758d0
MD
829 ip->ino_data.ctime = trans->time;
830 }
35a49944
MD
831 dip->ino_data.mtime = trans->time;
832 hammer_modify_inode(dip, HAMMER_INODE_MTIME);
4c286c36
MD
833 if (ip) {
834 hammer_modify_inode(ip, HAMMER_INODE_DDIRTY);
835 if (ip->ino_data.nlinks == 0 &&
836 (ip->vp == NULL || (ip->vp->v_flag & VINACTIVE))) {
837 hammer_done_cursor(cursor);
838 hammer_inode_unloadable_check(ip, 1);
839 hammer_flush_inode(ip, 0);
840 }
d113fda1 841 }
76376933 842
a89aec1b
MD
843 }
844 return(error);
66325755
MD
845}
846
8cd0a023 847/*
7a04d74f
MD
848 * Add a record to an inode.
849 *
850 * The caller must allocate the record with hammer_alloc_mem_record(ip) and
851 * initialize the following additional fields:
852 *
b84de5af
MD
853 * The related inode should be share-locked by the caller. The caller is
854 * on the frontend.
855 *
7a04d74f
MD
856 * record->rec.entry.base.base.key
857 * record->rec.entry.base.base.rec_type
858 * record->rec.entry.base.base.data_len
47197d71 859 * record->data (a copy will be kmalloc'd if it cannot be embedded)
7a04d74f
MD
860 */
861int
862hammer_ip_add_record(struct hammer_transaction *trans, hammer_record_t record)
863{
864 hammer_inode_t ip = record->ip;
865 int error;
7a04d74f 866
2f85fa4d 867 KKASSERT(record->leaf.base.localization != 0);
11ad5ade
MD
868 record->leaf.base.obj_id = ip->obj_id;
869 record->leaf.base.obj_type = ip->ino_leaf.base.obj_type;
47637bff 870 error = hammer_mem_add(record);
7a04d74f
MD
871 return(error);
872}
873
874/*
47637bff
MD
875 * Locate a bulk record in-memory. Bulk records allow disk space to be
876 * reserved so the front-end can flush large data writes without having
877 * to queue the BIO to the flusher. Only the related record gets queued
878 * to the flusher.
879 */
d7e278bb 880
47637bff
MD
881static hammer_record_t
882hammer_ip_get_bulk(hammer_inode_t ip, off_t file_offset, int bytes)
883{
d7e278bb
MD
884 struct hammer_bulk_info info;
885
886 bzero(&info, sizeof(info));
887 info.leaf.base.obj_id = ip->obj_id;
888 info.leaf.base.key = file_offset + bytes;
889 info.leaf.base.create_tid = 0;
890 info.leaf.base.delete_tid = 0;
891 info.leaf.base.rec_type = HAMMER_RECTYPE_DATA;
892 info.leaf.base.obj_type = 0; /* unused */
893 info.leaf.base.btype = HAMMER_BTREE_TYPE_RECORD; /* unused */
894 info.leaf.base.localization = ip->obj_localization + /* unused */
895 HAMMER_LOCALIZE_MISC;
896 info.leaf.data_len = bytes;
897
898 hammer_rec_rb_tree_RB_SCAN(&ip->rec_tree, hammer_rec_overlap_cmp,
899 hammer_bulk_scan_callback, &info);
900
901 return(info.record); /* may be NULL */
902}
903
904/*
905 * Take records vetted by overlap_cmp. The first non-deleted record
906 * (if any) stops the scan.
907 */
908static int
909hammer_bulk_scan_callback(hammer_record_t record, void *data)
910{
911 struct hammer_bulk_info *info = data;
0832c9bb 912
3214ade6
MD
913 if (record->flags & (HAMMER_RECF_DELETED_FE | HAMMER_RECF_DELETED_BE |
914 HAMMER_RECF_COMMITTED)) {
d7e278bb 915 return(0);
3214ade6 916 }
d7e278bb
MD
917 hammer_ref(&record->lock);
918 info->record = record;
919 return(-1); /* stop scan */
47637bff
MD
920}
921
922/*
923 * Reserve blockmap space placemarked with an in-memory record.
924 *
bcac4bbb
MD
925 * This routine is called by the frontend in order to be able to directly
926 * flush a buffer cache buffer. The frontend has locked the related buffer
927 * cache buffers and we should be able to manipulate any overlapping
928 * in-memory records.
e469566b
MD
929 *
930 * The caller is responsible for adding the returned record.
47637bff
MD
931 */
932hammer_record_t
0832c9bb
MD
933hammer_ip_add_bulk(hammer_inode_t ip, off_t file_offset, void *data, int bytes,
934 int *errorp)
47637bff
MD
935{
936 hammer_record_t record;
937 hammer_record_t conflict;
0832c9bb 938 int zone;
47637bff
MD
939
940 /*
7bc5b8c2 941 * Deal with conflicting in-memory records. We cannot have multiple
d7e278bb
MD
942 * in-memory records for the same base offset without seriously
943 * confusing the backend, including but not limited to the backend
944 * issuing delete-create-delete or create-delete-create sequences
945 * and asserting on the delete_tid being the same as the create_tid.
47637bff 946 *
7bc5b8c2
MD
947 * If we encounter a record with the backend interlock set we cannot
948 * immediately delete it without confusing the backend.
47637bff 949 */
0832c9bb 950 while ((conflict = hammer_ip_get_bulk(ip, file_offset, bytes)) !=NULL) {
7bc5b8c2
MD
951 if (conflict->flags & HAMMER_RECF_INTERLOCK_BE) {
952 conflict->flags |= HAMMER_RECF_WANTED;
953 tsleep(conflict, 0, "hmrrc3", 0);
bf3b416b
MD
954 } else {
955 conflict->flags |= HAMMER_RECF_DELETED_FE;
47637bff 956 }
7bc5b8c2 957 hammer_rel_mem_record(conflict);
47637bff
MD
958 }
959
960 /*
0832c9bb
MD
961 * Create a record to cover the direct write. This is called with
962 * the related BIO locked so there should be no possible conflict.
963 *
964 * The backend is responsible for finalizing the space reserved in
965 * this record.
966 *
967 * XXX bytes not aligned, depend on the reservation code to
968 * align the reservation.
47637bff
MD
969 */
970 record = hammer_alloc_mem_record(ip, 0);
0832c9bb
MD
971 zone = (bytes >= HAMMER_BUFSIZE) ? HAMMER_ZONE_LARGE_DATA_INDEX :
972 HAMMER_ZONE_SMALL_DATA_INDEX;
973 record->resv = hammer_blockmap_reserve(ip->hmp, zone, bytes,
974 &record->leaf.data_offset,
975 errorp);
976 if (record->resv == NULL) {
cebe9493 977 kprintf("hammer_ip_add_bulk: reservation failed\n");
47637bff
MD
978 hammer_rel_mem_record(record);
979 return(NULL);
980 }
981 record->type = HAMMER_MEM_RECORD_DATA;
982 record->leaf.base.rec_type = HAMMER_RECTYPE_DATA;
983 record->leaf.base.obj_type = ip->ino_leaf.base.obj_type;
984 record->leaf.base.obj_id = ip->obj_id;
985 record->leaf.base.key = file_offset + bytes;
5a930e66
MD
986 record->leaf.base.localization = ip->obj_localization +
987 HAMMER_LOCALIZE_MISC;
47637bff 988 record->leaf.data_len = bytes;
ddfdf542 989 hammer_crc_set_leaf(data, &record->leaf);
cebe9493 990 KKASSERT(*errorp == 0);
e469566b 991 return(record);
47637bff
MD
992}
993
994/*
995 * Frontend truncation code. Scan in-memory records only. On-disk records
996 * and records in a flushing state are handled by the backend. The vnops
997 * setattr code will handle the block containing the truncation point.
998 *
999 * Partial blocks are not deleted.
1000 */
47637bff
MD
1001int
1002hammer_ip_frontend_trunc(struct hammer_inode *ip, off_t file_size)
1003{
1004 struct rec_trunc_info info;
1005
1006 switch(ip->ino_data.obj_type) {
1007 case HAMMER_OBJTYPE_REGFILE:
1008 info.rec_type = HAMMER_RECTYPE_DATA;
1009 break;
1010 case HAMMER_OBJTYPE_DBFILE:
1011 info.rec_type = HAMMER_RECTYPE_DB;
1012 break;
1013 default:
1014 return(EINVAL);
1015 }
1016 info.trunc_off = file_size;
1017 hammer_rec_rb_tree_RB_SCAN(&ip->rec_tree, hammer_rec_trunc_cmp,
312de84d 1018 hammer_frontend_trunc_callback, &info);
47637bff
MD
1019 return(0);
1020}
1021
0832c9bb 1022static int
312de84d 1023hammer_frontend_trunc_callback(hammer_record_t record, void *data __unused)
0832c9bb
MD
1024{
1025 if (record->flags & HAMMER_RECF_DELETED_FE)
1026 return(0);
1027 if (record->flush_state == HAMMER_FST_FLUSH)
1028 return(0);
1029 KKASSERT((record->flags & HAMMER_RECF_INTERLOCK_BE) == 0);
1030 hammer_ref(&record->lock);
1031 record->flags |= HAMMER_RECF_DELETED_FE;
1032 hammer_rel_mem_record(record);
1033 return(0);
1034}
1035
47637bff 1036/*
cb51be26
MD
1037 * Return 1 if the caller must check for and delete existing records
1038 * before writing out a new data record.
1039 *
1040 * Return 0 if the caller can just insert the record into the B-Tree without
1041 * checking.
1042 */
1043static int
1044hammer_record_needs_overwrite_delete(hammer_record_t record)
1045{
1046 hammer_inode_t ip = record->ip;
1047 int64_t file_offset;
1048 int r;
1049
1050 if (ip->ino_data.obj_type == HAMMER_OBJTYPE_DBFILE)
1051 file_offset = record->leaf.base.key;
1052 else
1053 file_offset = record->leaf.base.key - record->leaf.data_len;
a9d52b76 1054 r = (file_offset < ip->save_trunc_off);
cb51be26 1055 if (ip->ino_data.obj_type == HAMMER_OBJTYPE_DBFILE) {
a9d52b76
MD
1056 if (ip->save_trunc_off <= record->leaf.base.key)
1057 ip->save_trunc_off = record->leaf.base.key + 1;
cb51be26 1058 } else {
a9d52b76
MD
1059 if (ip->save_trunc_off < record->leaf.base.key)
1060 ip->save_trunc_off = record->leaf.base.key;
cb51be26
MD
1061 }
1062 return(r);
1063}
1064
1065/*
47637bff
MD
1066 * Backend code. Sync a record to the media.
1067 */
4e17f465
MD
1068int
1069hammer_ip_sync_record_cursor(hammer_cursor_t cursor, hammer_record_t record)
1070{
1071 hammer_transaction_t trans = cursor->trans;
cebe9493 1072 int64_t file_offset;
4a2796f3 1073 int bytes;
40043e7f 1074 void *bdata;
c0ade690 1075 int error;
602c6cb8 1076 int doprop;
c0ade690 1077
1f07f686 1078 KKASSERT(record->flush_state == HAMMER_FST_FLUSH);
d36ec43b 1079 KKASSERT(record->flags & HAMMER_RECF_INTERLOCK_BE);
2f85fa4d 1080 KKASSERT(record->leaf.base.localization != 0);
b33e2cc0 1081
47637bff 1082 /*
e469566b
MD
1083 * Any direct-write related to the record must complete before we
1084 * can sync the record to the on-disk media.
1085 */
1086 if (record->flags & (HAMMER_RECF_DIRECT_IO | HAMMER_RECF_DIRECT_INVAL))
1087 hammer_io_direct_wait(record);
1088
1089 /*
47637bff
MD
1090 * If this is a bulk-data record placemarker there may be an existing
1091 * record on-disk, indicating a data overwrite. If there is the
1092 * on-disk record must be deleted before we can insert our new record.
1093 *
1094 * We've synthesized this record and do not know what the create_tid
1095 * on-disk is, nor how much data it represents.
1096 *
1097 * Keep in mind that (key) for data records is (base_offset + len),
1098 * not (base_offset). Also, we only want to get rid of on-disk
1099 * records since we are trying to sync our in-memory record, call
1100 * hammer_ip_delete_range() with truncating set to 1 to make sure
1101 * it skips in-memory records.
1102 *
1103 * It is ok for the lookup to return ENOENT.
cb51be26
MD
1104 *
1105 * NOTE OPTIMIZATION: sync_trunc_off is used to determine if we have
1106 * to call hammer_ip_delete_range() or not. This also means we must
1107 * update sync_trunc_off() as we write.
47637bff 1108 */
cb51be26
MD
1109 if (record->type == HAMMER_MEM_RECORD_DATA &&
1110 hammer_record_needs_overwrite_delete(record)) {
cebe9493 1111 file_offset = record->leaf.base.key - record->leaf.data_len;
4a2796f3
MD
1112 bytes = (record->leaf.data_len + HAMMER_BUFMASK) &
1113 ~HAMMER_BUFMASK;
cebe9493 1114 KKASSERT((file_offset & HAMMER_BUFMASK) == 0);
47637bff
MD
1115 error = hammer_ip_delete_range(
1116 cursor, record->ip,
4a2796f3 1117 file_offset, file_offset + bytes - 1,
cebe9493 1118 1);
47637bff
MD
1119 if (error && error != ENOENT)
1120 goto done;
1121 }
1122
1123 /*
5fa5c92f
MD
1124 * If this is a general record there may be an on-disk version
1125 * that must be deleted before we can insert the new record.
1126 */
1127 if (record->type == HAMMER_MEM_RECORD_GENERAL) {
1128 error = hammer_delete_general(cursor, record->ip,
1129 &record->leaf);
1130 if (error && error != ENOENT)
1131 goto done;
1132 }
1133
1134 /*
47637bff
MD
1135 * Setup the cursor.
1136 */
4e17f465 1137 hammer_normalize_cursor(cursor);
11ad5ade 1138 cursor->key_beg = record->leaf.base;
4e17f465
MD
1139 cursor->flags &= ~HAMMER_CURSOR_INITMASK;
1140 cursor->flags |= HAMMER_CURSOR_BACKEND;
1141 cursor->flags &= ~HAMMER_CURSOR_INSERT;
c0ade690
MD
1142
1143 /*
98f7132d
MD
1144 * Records can wind up on-media before the inode itself is on-media.
1145 * Flag the case.
1146 */
1147 record->ip->flags |= HAMMER_INODE_DONDISK;
1148
1149 /*
47637bff
MD
1150 * If we are deleting a directory entry an exact match must be
1151 * found on-disk.
b84de5af 1152 */
1f07f686 1153 if (record->type == HAMMER_MEM_RECORD_DEL) {
4e17f465
MD
1154 error = hammer_btree_lookup(cursor);
1155 if (error == 0) {
5c8d05e2 1156 KKASSERT(cursor->iprec == NULL);
e63644f0
MD
1157 error = hammer_ip_delete_record(cursor, record->ip,
1158 trans->tid);
4e17f465 1159 if (error == 0) {
3214ade6
MD
1160 record->flags |= HAMMER_RECF_DELETED_BE |
1161 HAMMER_RECF_COMMITTED;
1162 ++record->ip->rec_generation;
4e17f465
MD
1163 }
1164 }
b84de5af
MD
1165 goto done;
1166 }
1167
1168 /*
1169 * We are inserting.
1170 *
d26d0ae9 1171 * Issue a lookup to position the cursor and locate the cluster. The
b3deaf57
MD
1172 * target key should not exist. If we are creating a directory entry
1173 * we may have to iterate the low 32 bits of the key to find an unused
1174 * key.
c0ade690 1175 */
98da6d8c 1176 hammer_sync_lock_sh(trans);
4e17f465 1177 cursor->flags |= HAMMER_CURSOR_INSERT;
c82af904
MD
1178 error = hammer_btree_lookup(cursor);
1179 if (hammer_debug_inode)
1180 kprintf("DOINSERT LOOKUP %d\n", error);
1181 if (error == 0) {
1182 kprintf("hammer_ip_sync_record: duplicate rec "
1183 "at (%016llx)\n", record->leaf.base.key);
1184 Debugger("duplicate record1");
1185 error = EIO;
c0ade690 1186 }
47637bff
MD
1187#if 0
1188 if (record->type == HAMMER_MEM_RECORD_DATA)
1189 kprintf("sync_record %016llx ---------------- %016llx %d\n",
1190 record->leaf.base.key - record->leaf.data_len,
1191 record->leaf.data_offset, error);
1192#endif
47637bff 1193
c0ade690 1194 if (error != ENOENT)
98da6d8c 1195 goto done_unlock;
c0ade690
MD
1196
1197 /*
47197d71
MD
1198 * Allocate the record and data. The result buffers will be
1199 * marked as being modified and further calls to
1200 * hammer_modify_buffer() will result in unneeded UNDO records.
1201 *
40043e7f 1202 * Support zero-fill records (data == NULL and data_len != 0)
c0ade690 1203 */
47637bff
MD
1204 if (record->type == HAMMER_MEM_RECORD_DATA) {
1205 /*
1206 * The data portion of a bulk-data record has already been
1207 * committed to disk, we need only adjust the layer2
1208 * statistics in the same transaction as our B-Tree insert.
1209 */
1210 KKASSERT(record->leaf.data_offset != 0);
cdb6e4e6 1211 error = hammer_blockmap_finalize(trans,
5e435c92 1212 record->resv,
cdb6e4e6
MD
1213 record->leaf.data_offset,
1214 record->leaf.data_len);
47637bff
MD
1215 } else if (record->data && record->leaf.data_len) {
1216 /*
1217 * Wholely cached record, with data. Allocate the data.
1218 */
11ad5ade 1219 bdata = hammer_alloc_data(trans, record->leaf.data_len,
bf3b416b 1220 record->leaf.base.rec_type,
11ad5ade 1221 &record->leaf.data_offset,
4e17f465 1222 &cursor->data_buffer, &error);
11ad5ade 1223 if (bdata == NULL)
98da6d8c 1224 goto done_unlock;
ddfdf542 1225 hammer_crc_set_leaf(record->data, &record->leaf);
4e17f465 1226 hammer_modify_buffer(trans, cursor->data_buffer, NULL, 0);
11ad5ade 1227 bcopy(record->data, bdata, record->leaf.data_len);
4e17f465 1228 hammer_modify_buffer_done(cursor->data_buffer);
47197d71 1229 } else {
47637bff
MD
1230 /*
1231 * Wholely cached record, without data.
1232 */
11ad5ade
MD
1233 record->leaf.data_offset = 0;
1234 record->leaf.data_crc = 0;
c0ade690 1235 }
c0ade690 1236
602c6cb8 1237 error = hammer_btree_insert(cursor, &record->leaf, &doprop);
47637bff
MD
1238 if (hammer_debug_inode && error)
1239 kprintf("BTREE INSERT error %d @ %016llx:%d key %016llx\n", error, cursor->node->node_offset, cursor->index, record->leaf.base.key);
b3deaf57
MD
1240
1241 /*
3214ade6
MD
1242 * Our record is on-disk and we normally mark the in-memory version
1243 * as having been committed (and not BE-deleted).
1244 *
1245 * If the record represented a directory deletion but we had to
1246 * sync a valid directory entry to disk due to dependancies,
1247 * we must convert the record to a covering delete so the
1248 * frontend does not have visibility on the synced entry.
b3deaf57 1249 */
4e17f465 1250 if (error == 0) {
602c6cb8 1251 if (doprop) {
4c038e17
MD
1252 hammer_btree_do_propagation(cursor,
1253 record->ip->pfsm,
602c6cb8
MD
1254 &record->leaf);
1255 }
4e17f465 1256 if (record->flags & HAMMER_RECF_CONVERT_DELETE) {
3214ade6
MD
1257 /*
1258 * Must convert deleted directory entry add
1259 * to a directory entry delete.
1260 */
4e17f465
MD
1261 KKASSERT(record->type == HAMMER_MEM_RECORD_ADD);
1262 record->flags &= ~HAMMER_RECF_DELETED_FE;
1263 record->type = HAMMER_MEM_RECORD_DEL;
c4bae5fd 1264 KKASSERT(record->flush_state == HAMMER_FST_FLUSH);
4e17f465 1265 record->flags &= ~HAMMER_RECF_CONVERT_DELETE;
3214ade6
MD
1266 KKASSERT((record->flags & (HAMMER_RECF_COMMITTED |
1267 HAMMER_RECF_DELETED_BE)) == 0);
1268 /* converted record is not yet committed */
c4bae5fd 1269 /* hammer_flush_record_done takes care of the rest */
4e17f465 1270 } else {
3214ade6
MD
1271 /*
1272 * Everything went fine and we are now done with
1273 * this record.
1274 */
1275 record->flags |= HAMMER_RECF_COMMITTED;
1276 ++record->ip->rec_generation;
1f07f686 1277 }
4e17f465 1278 } else {
11ad5ade
MD
1279 if (record->leaf.data_offset) {
1280 hammer_blockmap_free(trans, record->leaf.data_offset,
1281 record->leaf.data_len);
19619882 1282 }
4e17f465 1283 }
98da6d8c
MD
1284done_unlock:
1285 hammer_sync_unlock(trans);
47197d71 1286done:
c0ade690 1287 return(error);
8cd0a023 1288}
66325755 1289
d26d0ae9 1290/*
a89aec1b
MD
1291 * Add the record to the inode's rec_tree. The low 32 bits of a directory
1292 * entry's key is used to deal with hash collisions in the upper 32 bits.
1293 * A unique 64 bit key is generated in-memory and may be regenerated a
1294 * second time when the directory record is flushed to the on-disk B-Tree.
d26d0ae9 1295 *
b3deaf57
MD
1296 * A referenced record is passed to this function. This function
1297 * eats the reference. If an error occurs the record will be deleted.
47197d71
MD
1298 *
1299 * A copy of the temporary record->data pointer provided by the caller
1300 * will be made.
66325755
MD
1301 */
1302int
47637bff 1303hammer_mem_add(hammer_record_t record)
66325755 1304{
47637bff
MD
1305 hammer_mount_t hmp = record->ip->hmp;
1306
47197d71
MD
1307 /*
1308 * Make a private copy of record->data
1309 */
11ad5ade
MD
1310 if (record->data)
1311 KKASSERT(record->flags & HAMMER_RECF_ALLOCDATA);
47197d71
MD
1312
1313 /*
c82af904
MD
1314 * Insert into the RB tree. A unique key should have already
1315 * been selected if this is a directory entry.
47197d71 1316 */
c82af904
MD
1317 if (RB_INSERT(hammer_rec_rb_tree, &record->ip->rec_tree, record)) {
1318 record->flags |= HAMMER_RECF_DELETED_FE;
1319 hammer_rel_mem_record(record);
1320 return (EEXIST);
8cd0a023 1321 }
4a2796f3 1322 ++hmp->count_newrecords;
47637bff
MD
1323 ++hmp->rsv_recs;
1324 ++record->ip->rsv_recs;
e63644f0 1325 record->ip->hmp->rsv_databytes += record->leaf.data_len;
8cd0a023 1326 record->flags |= HAMMER_RECF_ONRBTREE;
47637bff 1327 hammer_modify_inode(record->ip, HAMMER_INODE_XDIRTY);
b3deaf57 1328 hammer_rel_mem_record(record);
8cd0a023 1329 return(0);
66325755
MD
1330}
1331
a89aec1b
MD
1332/************************************************************************
1333 * HAMMER INODE MERGED-RECORD FUNCTIONS *
1334 ************************************************************************
1335 *
1336 * These functions augment the B-Tree scanning functions in hammer_btree.c
1337 * by merging in-memory records with on-disk records.
1338 */
1339
1340/*
1341 * Locate a particular record either in-memory or on-disk.
1342 *
1343 * NOTE: This is basically a standalone routine, hammer_ip_next() may
1344 * NOT be called to iterate results.
1345 */
1346int
45a014dc 1347hammer_ip_lookup(hammer_cursor_t cursor)
a89aec1b
MD
1348{
1349 int error;
1350
1351 /*
1352 * If the element is in-memory return it without searching the
1353 * on-disk B-Tree
1354 */
45a014dc
MD
1355 KKASSERT(cursor->ip);
1356 error = hammer_mem_lookup(cursor);
a89aec1b 1357 if (error == 0) {
11ad5ade 1358 cursor->leaf = &cursor->iprec->leaf;
a89aec1b
MD
1359 return(error);
1360 }
1361 if (error != ENOENT)
1362 return(error);
1363
1364 /*
1365 * If the inode has on-disk components search the on-disk B-Tree.
1366 */
45a014dc 1367 if ((cursor->ip->flags & (HAMMER_INODE_ONDISK|HAMMER_INODE_DONDISK)) == 0)
a89aec1b
MD
1368 return(error);
1369 error = hammer_btree_lookup(cursor);
1370 if (error == 0)
11ad5ade 1371 error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_LEAF);
a89aec1b
MD
1372 return(error);
1373}
1374
1375/*
3214ade6
MD
1376 * Helper for hammer_ip_first()/hammer_ip_next()
1377 *
1378 * NOTE: Both ATEDISK and DISKEOF will be set the same. This sets up
1379 * hammer_ip_first() for calling hammer_ip_next(), and sets up the re-seek
1380 * state if hammer_ip_next() needs to re-seek.
1381 */
1382static __inline
1383int
1384_hammer_ip_seek_btree(hammer_cursor_t cursor)
1385{
1386 hammer_inode_t ip = cursor->ip;
1387 int error;
1388
1389 if (ip->flags & (HAMMER_INODE_ONDISK|HAMMER_INODE_DONDISK)) {
1390 error = hammer_btree_lookup(cursor);
1391 if (error == ENOENT || error == EDEADLK) {
1392 if (hammer_debug_general & 0x2000)
1393 kprintf("error %d node %p %016llx index %d\n", error, cursor->node, cursor->node->node_offset, cursor->index);
1394 cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
1395 error = hammer_btree_iterate(cursor);
1396 }
1397 if (error == 0) {
1398 cursor->flags &= ~(HAMMER_CURSOR_DISKEOF |
1399 HAMMER_CURSOR_ATEDISK);
1400 } else {
1401 cursor->flags |= HAMMER_CURSOR_DISKEOF |
1402 HAMMER_CURSOR_ATEDISK;
1403 if (error == ENOENT)
1404 error = 0;
1405 }
1406 } else {
1407 cursor->flags |= HAMMER_CURSOR_DISKEOF | HAMMER_CURSOR_ATEDISK;
1408 error = 0;
1409 }
1410 return(error);
1411}
1412
1413/*
1414 * Helper for hammer_ip_next()
1415 *
1416 * The caller has determined that the media cursor is further along than the
1417 * memory cursor and must be reseeked after a generation number change.
1418 */
1419static
1420int
1421_hammer_ip_reseek(hammer_cursor_t cursor)
1422{
1423 struct hammer_base_elm save;
1424 hammer_btree_elm_t elm;
1425 int error;
1426 int r;
1427 int again = 0;
1428
1429 /*
1430 * Do the re-seek.
1431 */
1432 kprintf("HAMMER: Debug: re-seeked during scan @ino=%016llx\n",
1433 (long long)cursor->ip->obj_id);
1434 save = cursor->key_beg;
1435 cursor->key_beg = cursor->iprec->leaf.base;
1436 error = _hammer_ip_seek_btree(cursor);
1437 KKASSERT(error == 0);
1438 cursor->key_beg = save;
1439
1440 /*
1441 * If the memory record was previous returned to
1442 * the caller and the media record matches
1443 * (-1/+1: only create_tid differs), then iterate
1444 * the media record to avoid a double result.
1445 */
1446 if ((cursor->flags & HAMMER_CURSOR_ATEDISK) == 0 &&
1447 (cursor->flags & HAMMER_CURSOR_LASTWASMEM)) {
1448 elm = &cursor->node->ondisk->elms[cursor->index];
1449 r = hammer_btree_cmp(&elm->base,
1450 &cursor->iprec->leaf.base);
1451 if (cursor->flags & HAMMER_CURSOR_ASOF) {
1452 if (r >= -1 && r <= 1) {
1453 kprintf("HAMMER: Debug: iterated after "
1454 "re-seek (asof r=%d)\n", r);
1455 cursor->flags |= HAMMER_CURSOR_ATEDISK;
1456 again = 1;
1457 }
1458 } else {
1459 if (r == 0) {
1460 kprintf("HAMMER: Debug: iterated after "
1461 "re-seek\n");
1462 cursor->flags |= HAMMER_CURSOR_ATEDISK;
1463 again = 1;
1464 }
1465 }
1466 }
1467 return(again);
1468}
1469
1470/*
a89aec1b
MD
1471 * Locate the first record within the cursor's key_beg/key_end range,
1472 * restricted to a particular inode. 0 is returned on success, ENOENT
1473 * if no records matched the requested range, or some other error.
1474 *
1475 * When 0 is returned hammer_ip_next() may be used to iterate additional
1476 * records within the requested range.
6a37e7e4
MD
1477 *
1478 * This function can return EDEADLK, requiring the caller to terminate
1479 * the cursor and try again.
a89aec1b 1480 */
3214ade6 1481
a89aec1b 1482int
4e17f465 1483hammer_ip_first(hammer_cursor_t cursor)
a89aec1b 1484{
4e17f465 1485 hammer_inode_t ip = cursor->ip;
a89aec1b
MD
1486 int error;
1487
4e17f465
MD
1488 KKASSERT(ip != NULL);
1489
a89aec1b
MD
1490 /*
1491 * Clean up fields and setup for merged scan
1492 */
5c8d05e2 1493 cursor->flags &= ~HAMMER_CURSOR_RETEST;
a89aec1b
MD
1494
1495 /*
3214ade6
MD
1496 * Search the in-memory record list (Red-Black tree). Unlike the
1497 * B-Tree search, mem_first checks for records in the range.
6a37e7e4 1498 *
3214ade6
MD
1499 * This function will setup both ATEMEM and MEMEOF properly for
1500 * the ip iteration. ATEMEM will be set if MEMEOF is set.
a89aec1b 1501 */
3214ade6 1502 hammer_mem_first(cursor);
a89aec1b
MD
1503
1504 /*
3214ade6
MD
1505 * Detect generation changes during blockages, including
1506 * blockages which occur on the initial btree search.
a89aec1b 1507 */
3214ade6 1508 cursor->rec_generation = cursor->ip->rec_generation;
a89aec1b
MD
1509
1510 /*
3214ade6 1511 * Initial search and result
a89aec1b 1512 */
3214ade6
MD
1513 error = _hammer_ip_seek_btree(cursor);
1514 if (error == 0)
1515 error = hammer_ip_next(cursor);
1516
1517 return (error);
a89aec1b
MD
1518}
1519
1520/*
1521 * Retrieve the next record in a merged iteration within the bounds of the
1522 * cursor. This call may be made multiple times after the cursor has been
1523 * initially searched with hammer_ip_first().
1524 *
3214ade6
MD
1525 * There are numerous special cases in this code to deal with races between
1526 * in-memory records and on-media records.
1527 *
a89aec1b
MD
1528 * 0 is returned on success, ENOENT if no further records match the
1529 * requested range, or some other error code is returned.
1530 */
1531int
1532hammer_ip_next(hammer_cursor_t cursor)
1533{
1534 hammer_btree_elm_t elm;
3214ade6
MD
1535 hammer_record_t rec;
1536 hammer_record_t tmprec;
a89aec1b
MD
1537 int error;
1538 int r;
1539
3214ade6 1540again:
a89aec1b 1541 /*
a89aec1b 1542 * Get the next on-disk record
3214ade6
MD
1543 *
1544 * NOTE: If we deleted the last on-disk record we had scanned
1545 * ATEDISK will be clear and RETEST will be set, forcing
1546 * a call to iterate. The fact that ATEDISK is clear causes
1547 * iterate to re-test the 'current' element. If ATEDISK is
1548 * set, iterate will skip the 'current' element.
a89aec1b 1549 */
3214ade6
MD
1550 error = 0;
1551 if ((cursor->flags & HAMMER_CURSOR_DISKEOF) == 0) {
1552 if (cursor->flags & (HAMMER_CURSOR_ATEDISK |
1553 HAMMER_CURSOR_RETEST)) {
a89aec1b 1554 error = hammer_btree_iterate(cursor);
5c8d05e2 1555 cursor->flags &= ~HAMMER_CURSOR_RETEST;
cb51be26 1556 if (error == 0) {
a89aec1b 1557 cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
bcac4bbb
MD
1558 hammer_cache_node(&cursor->ip->cache[1],
1559 cursor->node);
3214ade6 1560 } else if (error == ENOENT) {
195c19a1
MD
1561 cursor->flags |= HAMMER_CURSOR_DISKEOF |
1562 HAMMER_CURSOR_ATEDISK;
3214ade6 1563 error = 0;
cb51be26 1564 }
a89aec1b
MD
1565 }
1566 }
1567
1568 /*
3214ade6
MD
1569 * If the generation changed the backend has deleted or committed
1570 * one or more memory records since our last check.
1571 *
1572 * When this case occurs if the disk cursor is > current memory record
1573 * or the disk cursor is at EOF, we must re-seek the disk-cursor.
1574 * Since the cursor is ahead it must have not yet been eaten (if
1575 * not at eof anyway). (XXX data offset case?)
1576 *
1577 * NOTE: we are not doing a full check here. That will be handled
1578 * later on.
1579 *
1580 * If we have exhausted all memory records we do not have to do any
1581 * further seeks.
1582 */
1583 while (cursor->rec_generation != cursor->ip->rec_generation &&
1584 error == 0
1585 ) {
1586 kprintf("HAMMER: Debug: generation changed during scan @ino=%016llx\n", (long long)cursor->ip->obj_id);
1587 cursor->rec_generation = cursor->ip->rec_generation;
1588 if (cursor->flags & HAMMER_CURSOR_MEMEOF)
1589 break;
1590 if (cursor->flags & HAMMER_CURSOR_DISKEOF) {
1591 r = 1;
1592 } else {
1593 KKASSERT((cursor->flags & HAMMER_CURSOR_ATEDISK) == 0);
1594 elm = &cursor->node->ondisk->elms[cursor->index];
1595 r = hammer_btree_cmp(&elm->base,
1596 &cursor->iprec->leaf.base);
1597 }
1598
1599 /*
1600 * Do we re-seek the media cursor?
1601 */
1602 if (r > 0) {
1603 if (_hammer_ip_reseek(cursor))
1604 goto again;
1605 }
1606 }
1607
1608 /*
1609 * We can now safely get the next in-memory record. We cannot
1610 * block here.
7f7c1f84
MD
1611 *
1612 * hammer_rec_scan_cmp: Is the record still in our general range,
1613 * (non-inclusive of snapshot exclusions)?
1614 * hammer_rec_scan_callback: Is the record in our snapshot?
a89aec1b 1615 */
3214ade6
MD
1616 tmprec = NULL;
1617 if ((cursor->flags & HAMMER_CURSOR_MEMEOF) == 0) {
1618 /*
1619 * If the current memory record was eaten then get the next
1620 * one. Stale records are skipped.
1621 */
1622 if (cursor->flags & HAMMER_CURSOR_ATEMEM) {
1623 tmprec = cursor->iprec;
b84de5af 1624 cursor->iprec = NULL;
3214ade6 1625 rec = hammer_rec_rb_tree_RB_NEXT(tmprec);
7f7c1f84 1626 while (rec) {
ec4e8497
MD
1627 if (hammer_rec_scan_cmp(rec, cursor) != 0)
1628 break;
1629 if (hammer_rec_scan_callback(rec, cursor) != 0)
1630 break;
7f7c1f84
MD
1631 rec = hammer_rec_rb_tree_RB_NEXT(rec);
1632 }
1633 if (cursor->iprec) {
b3deaf57 1634 KKASSERT(cursor->iprec == rec);
a89aec1b 1635 cursor->flags &= ~HAMMER_CURSOR_ATEMEM;
a89aec1b
MD
1636 } else {
1637 cursor->flags |= HAMMER_CURSOR_MEMEOF;
1638 }
3214ade6 1639 cursor->flags &= ~HAMMER_CURSOR_LASTWASMEM;
a89aec1b
MD
1640 }
1641 }
1642
1643 /*
3214ade6
MD
1644 * MEMORY RECORD VALIDITY TEST
1645 *
1646 * (We still can't block, which is why tmprec is being held so
1647 * long).
1648 *
1649 * If the memory record is no longer valid we skip it. It may
1650 * have been deleted by the frontend. If it was deleted or
1651 * committed by the backend the generation change re-seeked the
1652 * disk cursor and the record will be present there.
4e17f465 1653 */
3214ade6
MD
1654 if (error == 0 && (cursor->flags & HAMMER_CURSOR_MEMEOF) == 0) {
1655 KKASSERT(cursor->iprec);
1656 KKASSERT((cursor->flags & HAMMER_CURSOR_ATEMEM) == 0);
1657 if (!hammer_ip_iterate_mem_good(cursor, cursor->iprec)) {
4e17f465 1658 cursor->flags |= HAMMER_CURSOR_ATEMEM;
3214ade6
MD
1659 if (tmprec)
1660 hammer_rel_mem_record(tmprec);
1661 goto again;
4e17f465
MD
1662 }
1663 }
3214ade6
MD
1664 if (tmprec)
1665 hammer_rel_mem_record(tmprec);
4e17f465
MD
1666
1667 /*
a89aec1b
MD
1668 * Extract either the disk or memory record depending on their
1669 * relative position.
1670 */
1671 error = 0;
6b4f890b 1672 switch(cursor->flags & (HAMMER_CURSOR_ATEDISK | HAMMER_CURSOR_ATEMEM)) {
a89aec1b
MD
1673 case 0:
1674 /*
9f5097dc
MD
1675 * Both entries valid. Compare the entries and nominally
1676 * return the first one in the sort order. Numerous cases
1677 * require special attention, however.
a89aec1b
MD
1678 */
1679 elm = &cursor->node->ondisk->elms[cursor->index];
11ad5ade 1680 r = hammer_btree_cmp(&elm->base, &cursor->iprec->leaf.base);
47637bff
MD
1681
1682 /*
9f5097dc
MD
1683 * If the two entries differ only by their key (-2/2) or
1684 * create_tid (-1/1), and are DATA records, we may have a
1685 * nominal match. We have to calculate the base file
1686 * offset of the data.
47637bff 1687 */
9f5097dc
MD
1688 if (r <= 2 && r >= -2 && r != 0 &&
1689 cursor->ip->ino_data.obj_type == HAMMER_OBJTYPE_REGFILE &&
1690 cursor->iprec->type == HAMMER_MEM_RECORD_DATA) {
1691 int64_t base1 = elm->leaf.base.key - elm->leaf.data_len;
1692 int64_t base2 = cursor->iprec->leaf.base.key -
1693 cursor->iprec->leaf.data_len;
bf3b416b 1694 if (base1 == base2)
9f5097dc 1695 r = 0;
9f5097dc
MD
1696 }
1697
a89aec1b
MD
1698 if (r < 0) {
1699 error = hammer_btree_extract(cursor,
11ad5ade 1700 HAMMER_CURSOR_GET_LEAF);
a89aec1b 1701 cursor->flags |= HAMMER_CURSOR_ATEDISK;
3214ade6 1702 cursor->flags &= ~HAMMER_CURSOR_LASTWASMEM;
a89aec1b
MD
1703 break;
1704 }
b84de5af
MD
1705
1706 /*
47637bff
MD
1707 * If the entries match exactly the memory entry is either
1708 * an on-disk directory entry deletion or a bulk data
1709 * overwrite. If it is a directory entry deletion we eat
1710 * both entries.
1711 *
1712 * For the bulk-data overwrite case it is possible to have
1713 * visibility into both, which simply means the syncer
1714 * hasn't gotten around to doing the delete+insert sequence
1715 * on the B-Tree. Use the memory entry and throw away the
1716 * on-disk entry.
1f07f686 1717 *
47637bff 1718 * If the in-memory record is not either of these we
1f07f686
MD
1719 * probably caught the syncer while it was syncing it to
1720 * the media. Since we hold a shared lock on the cursor,
1721 * the in-memory record had better be marked deleted at
1722 * this point.
b84de5af
MD
1723 */
1724 if (r == 0) {
1f07f686
MD
1725 if (cursor->iprec->type == HAMMER_MEM_RECORD_DEL) {
1726 if ((cursor->flags & HAMMER_CURSOR_DELETE_VISIBILITY) == 0) {
1727 cursor->flags |= HAMMER_CURSOR_ATEDISK;
1728 cursor->flags |= HAMMER_CURSOR_ATEMEM;
3214ade6 1729 goto again;
1f07f686 1730 }
47637bff
MD
1731 } else if (cursor->iprec->type == HAMMER_MEM_RECORD_DATA) {
1732 if ((cursor->flags & HAMMER_CURSOR_DELETE_VISIBILITY) == 0) {
1733 cursor->flags |= HAMMER_CURSOR_ATEDISK;
1734 }
1735 /* fall through to memory entry */
1f07f686 1736 } else {
3f43fb33 1737 panic("hammer_ip_next: duplicate mem/b-tree entry %p %d %08x", cursor->iprec, cursor->iprec->type, cursor->iprec->flags);
b84de5af 1738 cursor->flags |= HAMMER_CURSOR_ATEMEM;
3214ade6 1739 goto again;
b84de5af
MD
1740 }
1741 }
a89aec1b 1742 /* fall through to the memory entry */
6b4f890b 1743 case HAMMER_CURSOR_ATEDISK:
a89aec1b 1744 /*
4e17f465 1745 * Only the memory entry is valid.
a89aec1b 1746 */
11ad5ade 1747 cursor->leaf = &cursor->iprec->leaf;
a89aec1b 1748 cursor->flags |= HAMMER_CURSOR_ATEMEM;
3214ade6 1749 cursor->flags |= HAMMER_CURSOR_LASTWASMEM;
4e17f465
MD
1750
1751 /*
1752 * If the memory entry is an on-disk deletion we should have
1753 * also had found a B-Tree record. If the backend beat us
1754 * to it it would have interlocked the cursor and we should
1755 * have seen the in-memory record marked DELETED_FE.
1756 */
98f7132d
MD
1757 if (cursor->iprec->type == HAMMER_MEM_RECORD_DEL &&
1758 (cursor->flags & HAMMER_CURSOR_DELETE_VISIBILITY) == 0) {
3f43fb33 1759 panic("hammer_ip_next: del-on-disk with no b-tree entry iprec %p flags %08x", cursor->iprec, cursor->iprec->flags);
b84de5af 1760 }
a89aec1b 1761 break;
6b4f890b 1762 case HAMMER_CURSOR_ATEMEM:
a89aec1b
MD
1763 /*
1764 * Only the disk entry is valid
1765 */
11ad5ade 1766 error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_LEAF);
a89aec1b 1767 cursor->flags |= HAMMER_CURSOR_ATEDISK;
3214ade6 1768 cursor->flags &= ~HAMMER_CURSOR_LASTWASMEM;
a89aec1b
MD
1769 break;
1770 default:
1771 /*
1772 * Neither entry is valid
1773 *
1774 * XXX error not set properly
1775 */
3214ade6 1776 cursor->flags &= ~HAMMER_CURSOR_LASTWASMEM;
11ad5ade 1777 cursor->leaf = NULL;
a89aec1b
MD
1778 error = ENOENT;
1779 break;
1780 }
1781 return(error);
1782}
1783
1784/*
40043e7f 1785 * Resolve the cursor->data pointer for the current cursor position in
a89aec1b
MD
1786 * a merged iteration.
1787 */
1788int
1789hammer_ip_resolve_data(hammer_cursor_t cursor)
1790{
47637bff 1791 hammer_record_t record;
a89aec1b
MD
1792 int error;
1793
47637bff
MD
1794 if (hammer_cursor_inmem(cursor)) {
1795 /*
1796 * The data associated with an in-memory record is usually
1797 * kmalloced, but reserve-ahead data records will have an
1798 * on-disk reference.
1799 *
1800 * NOTE: Reserve-ahead data records must be handled in the
1801 * context of the related high level buffer cache buffer
1802 * to interlock against async writes.
1803 */
1804 record = cursor->iprec;
1805 cursor->data = record->data;
a89aec1b 1806 error = 0;
47637bff
MD
1807 if (cursor->data == NULL) {
1808 KKASSERT(record->leaf.base.rec_type ==
1809 HAMMER_RECTYPE_DATA);
4a2796f3 1810 cursor->data = hammer_bread_ext(cursor->trans->hmp,
47637bff 1811 record->leaf.data_offset,
4a2796f3 1812 record->leaf.data_len,
47637bff
MD
1813 &error,
1814 &cursor->data_buffer);
1815 }
a89aec1b 1816 } else {
11ad5ade 1817 cursor->leaf = &cursor->node->ondisk->elms[cursor->index].leaf;
a89aec1b
MD
1818 error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_DATA);
1819 }
1820 return(error);
1821}
1822
66325755 1823/*
47637bff
MD
1824 * Backend truncation / record replacement - delete records in range.
1825 *
1826 * Delete all records within the specified range for inode ip. In-memory
06ad81ff
MD
1827 * records still associated with the frontend are ignored.
1828 *
1829 * If truncating is non-zero in-memory records associated with the back-end
1830 * are ignored. If truncating is > 1 we can return EWOULDBLOCK.
a89aec1b 1831 *
a9d52b76 1832 * NOTES:
a89aec1b 1833 *
a9d52b76
MD
1834 * * An unaligned range will cause new records to be added to cover
1835 * the edge cases. (XXX not implemented yet).
47637bff 1836 *
a9d52b76
MD
1837 * * Replacement via reservations (see hammer_ip_sync_record_cursor())
1838 * also do not deal with unaligned ranges.
76376933 1839 *
a9d52b76
MD
1840 * * ran_end is inclusive (e.g. 0,1023 instead of 0,1024).
1841 *
1842 * * Record keys for regular file data have to be special-cased since
1843 * they indicate the end of the range (key = base + bytes).
1844 *
1845 * * This function may be asked to delete ridiculously huge ranges, for
1846 * example if someone truncates or removes a 1TB regular file. We
1847 * must be very careful on restarts and we may have to stop w/
1848 * EWOULDBLOCK to avoid blowing out the buffer cache.
66325755
MD
1849 */
1850int
4e17f465 1851hammer_ip_delete_range(hammer_cursor_t cursor, hammer_inode_t ip,
47637bff 1852 int64_t ran_beg, int64_t ran_end, int truncating)
66325755 1853{
4e17f465 1854 hammer_transaction_t trans = cursor->trans;
11ad5ade 1855 hammer_btree_leaf_elm_t leaf;
a89aec1b
MD
1856 int error;
1857 int64_t off;
a9d52b76 1858 int64_t tmp64;
a89aec1b 1859
b84de5af
MD
1860#if 0
1861 kprintf("delete_range %p %016llx-%016llx\n", ip, ran_beg, ran_end);
1862#endif
1863
1864 KKASSERT(trans->type == HAMMER_TRANS_FLS);
6a37e7e4 1865retry:
4e17f465 1866 hammer_normalize_cursor(cursor);
5a930e66
MD
1867 cursor->key_beg.localization = ip->obj_localization +
1868 HAMMER_LOCALIZE_MISC;
4e17f465
MD
1869 cursor->key_beg.obj_id = ip->obj_id;
1870 cursor->key_beg.create_tid = 0;
1871 cursor->key_beg.delete_tid = 0;
1872 cursor->key_beg.obj_type = 0;
4e17f465 1873
11ad5ade 1874 if (ip->ino_data.obj_type == HAMMER_OBJTYPE_DBFILE) {
4e17f465
MD
1875 cursor->key_beg.key = ran_beg;
1876 cursor->key_beg.rec_type = HAMMER_RECTYPE_DB;
a89aec1b 1877 } else {
195c19a1
MD
1878 /*
1879 * The key in the B-Tree is (base+bytes), so the first possible
1880 * matching key is ran_beg + 1.
1881 */
4e17f465
MD
1882 cursor->key_beg.key = ran_beg + 1;
1883 cursor->key_beg.rec_type = HAMMER_RECTYPE_DATA;
a9d52b76 1884 }
195c19a1 1885
a9d52b76
MD
1886 cursor->key_end = cursor->key_beg;
1887 if (ip->ino_data.obj_type == HAMMER_OBJTYPE_DBFILE) {
1888 cursor->key_end.key = ran_end;
1889 } else {
195c19a1
MD
1890 tmp64 = ran_end + MAXPHYS + 1; /* work around GCC-4 bug */
1891 if (tmp64 < ran_end)
4e17f465 1892 cursor->key_end.key = 0x7FFFFFFFFFFFFFFFLL;
a89aec1b 1893 else
4e17f465 1894 cursor->key_end.key = ran_end + MAXPHYS + 1;
a89aec1b 1895 }
a9d52b76
MD
1896
1897 cursor->asof = ip->obj_asof;
1898 cursor->flags &= ~HAMMER_CURSOR_INITMASK;
1899 cursor->flags |= HAMMER_CURSOR_ASOF;
1900 cursor->flags |= HAMMER_CURSOR_DELETE_VISIBILITY;
1901 cursor->flags |= HAMMER_CURSOR_BACKEND;
4e17f465 1902 cursor->flags |= HAMMER_CURSOR_END_INCLUSIVE;
a89aec1b 1903
4e17f465 1904 error = hammer_ip_first(cursor);
a89aec1b
MD
1905
1906 /*
1907 * Iterate through matching records and mark them as deleted.
1908 */
1909 while (error == 0) {
11ad5ade 1910 leaf = cursor->leaf;
a89aec1b 1911
11ad5ade 1912 KKASSERT(leaf->base.delete_tid == 0);
e4a5ff06 1913 KKASSERT(leaf->base.obj_id == ip->obj_id);
a89aec1b
MD
1914
1915 /*
1916 * There may be overlap cases for regular file data. Also
47637bff
MD
1917 * remember the key for a regular file record is (base + len),
1918 * NOT (base).
e4a5ff06
MD
1919 *
1920 * Note that do to duplicates (mem & media) allowed by
1921 * DELETE_VISIBILITY, off can wind up less then ran_beg.
a89aec1b 1922 */
11ad5ade 1923 if (leaf->base.rec_type == HAMMER_RECTYPE_DATA) {
11ad5ade 1924 off = leaf->base.key - leaf->data_len;
a89aec1b 1925 /*
76376933
MD
1926 * Check the left edge case. We currently do not
1927 * split existing records.
a89aec1b 1928 */
e4a5ff06 1929 if (off < ran_beg && leaf->base.key > ran_beg) {
76376933 1930 panic("hammer left edge case %016llx %d\n",
11ad5ade 1931 leaf->base.key, leaf->data_len);
a89aec1b
MD
1932 }
1933
1934 /*
1935 * Check the right edge case. Note that the
1936 * record can be completely out of bounds, which
1937 * terminates the search.
1938 *
76376933
MD
1939 * base->key is exclusive of the right edge while
1940 * ran_end is inclusive of the right edge. The
1941 * (key - data_len) left boundary is inclusive.
195c19a1
MD
1942 *
1943 * XXX theory-check this test at some point, are
1944 * we missing a + 1 somewhere? Note that ran_end
1945 * could overflow.
a89aec1b 1946 */
11ad5ade
MD
1947 if (leaf->base.key - 1 > ran_end) {
1948 if (leaf->base.key - leaf->data_len > ran_end)
a89aec1b 1949 break;
a89aec1b
MD
1950 panic("hammer right edge case\n");
1951 }
a9d52b76
MD
1952 } else {
1953 off = leaf->base.key;
a89aec1b
MD
1954 }
1955
1956 /*
47637bff
MD
1957 * Delete the record. When truncating we do not delete
1958 * in-memory (data) records because they represent data
1959 * written after the truncation.
1960 *
1961 * This will also physically destroy the B-Tree entry and
195c19a1 1962 * data if the retention policy dictates. The function
5c8d05e2
MD
1963 * will set HAMMER_CURSOR_RETEST to cause hammer_ip_next()
1964 * to retest the new 'current' element.
a89aec1b 1965 */
06ad81ff 1966 if (truncating == 0 || hammer_cursor_ondisk(cursor)) {
47637bff 1967 error = hammer_ip_delete_record(cursor, ip, trans->tid);
a9d52b76
MD
1968 /*
1969 * If we have built up too many meta-buffers we risk
1970 * deadlocking the kernel and must stop. This can
1971 * occur when deleting ridiculously huge files.
1972 * sync_trunc_off is updated so the next cycle does
1973 * not re-iterate records we have already deleted.
1974 *
1975 * This is only done with formal truncations.
1976 */
06ad81ff
MD
1977 if (truncating > 1 && error == 0 &&
1978 hammer_flusher_meta_limit(ip->hmp)) {
a9d52b76 1979 ip->sync_trunc_off = off;
06ad81ff
MD
1980 error = EWOULDBLOCK;
1981 }
1982 }
195c19a1
MD
1983 if (error)
1984 break;
a9d52b76 1985 ran_beg = off; /* for restart */
4e17f465
MD
1986 error = hammer_ip_next(cursor);
1987 }
cb51be26 1988 if (cursor->node)
bcac4bbb 1989 hammer_cache_node(&ip->cache[1], cursor->node);
cb51be26 1990
4e17f465
MD
1991 if (error == EDEADLK) {
1992 hammer_done_cursor(cursor);
bcac4bbb 1993 error = hammer_init_cursor(trans, cursor, &ip->cache[1], ip);
4e17f465
MD
1994 if (error == 0)
1995 goto retry;
a89aec1b 1996 }
a89aec1b
MD
1997 if (error == ENOENT)
1998 error = 0;
1999 return(error);
66325755
MD
2000}
2001
b3deaf57 2002/*
5fa5c92f
MD
2003 * This backend function deletes the specified record on-disk, similar to
2004 * delete_range but for a specific record. Unlike the exact deletions
2005 * used when deleting a directory entry this function uses an ASOF search
2006 * like delete_range.
2007 *
2008 * This function may be called with ip->obj_asof set for a slave snapshot,
2009 * so don't use it. We always delete non-historical records only.
2010 */
2011static int
2012hammer_delete_general(hammer_cursor_t cursor, hammer_inode_t ip,
2013 hammer_btree_leaf_elm_t leaf)
2014{
2015 hammer_transaction_t trans = cursor->trans;
2016 int error;
2017
2018 KKASSERT(trans->type == HAMMER_TRANS_FLS);
2019retry:
2020 hammer_normalize_cursor(cursor);
2021 cursor->key_beg = leaf->base;
2022 cursor->asof = HAMMER_MAX_TID;
2023 cursor->flags &= ~HAMMER_CURSOR_INITMASK;
2024 cursor->flags |= HAMMER_CURSOR_ASOF;
2025 cursor->flags |= HAMMER_CURSOR_BACKEND;
2026 cursor->flags &= ~HAMMER_CURSOR_INSERT;
2027
2028 error = hammer_btree_lookup(cursor);
2029 if (error == 0) {
2030 error = hammer_ip_delete_record(cursor, ip, trans->tid);
2031 }
2032 if (error == EDEADLK) {
2033 hammer_done_cursor(cursor);
2034 error = hammer_init_cursor(trans, cursor, &ip->cache[1], ip);
2035 if (error == 0)
2036 goto retry;
2037 }
2038 return(error);
2039}
2040
2041/*
a9d52b76
MD
2042 * This function deletes remaining auxillary records when an inode is
2043 * being deleted. This function explicitly does not delete the
2044 * inode record, directory entry, data, or db records. Those must be
2045 * properly disposed of prior to this call.
b3deaf57 2046 */
7a04d74f 2047int
a9d52b76 2048hammer_ip_delete_clean(hammer_cursor_t cursor, hammer_inode_t ip, int *countp)
7a04d74f 2049{
4e17f465 2050 hammer_transaction_t trans = cursor->trans;
11ad5ade 2051 hammer_btree_leaf_elm_t leaf;
7a04d74f
MD
2052 int error;
2053
b84de5af 2054 KKASSERT(trans->type == HAMMER_TRANS_FLS);
6a37e7e4 2055retry:
4e17f465 2056 hammer_normalize_cursor(cursor);
5a930e66
MD
2057 cursor->key_beg.localization = ip->obj_localization +
2058 HAMMER_LOCALIZE_MISC;
4e17f465
MD
2059 cursor->key_beg.obj_id = ip->obj_id;
2060 cursor->key_beg.create_tid = 0;
2061 cursor->key_beg.delete_tid = 0;
2062 cursor->key_beg.obj_type = 0;
a9d52b76 2063 cursor->key_beg.rec_type = HAMMER_RECTYPE_CLEAN_START;
4e17f465
MD
2064 cursor->key_beg.key = HAMMER_MIN_KEY;
2065
2066 cursor->key_end = cursor->key_beg;
a9d52b76 2067 cursor->key_end.rec_type = HAMMER_RECTYPE_MAX;
4e17f465
MD
2068 cursor->key_end.key = HAMMER_MAX_KEY;
2069
2070 cursor->asof = ip->obj_asof;
2071 cursor->flags &= ~HAMMER_CURSOR_INITMASK;
2072 cursor->flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
2073 cursor->flags |= HAMMER_CURSOR_DELETE_VISIBILITY;
2074 cursor->flags |= HAMMER_CURSOR_BACKEND;
2075
2076 error = hammer_ip_first(cursor);
7a04d74f
MD
2077
2078 /*
2079 * Iterate through matching records and mark them as deleted.
2080 */
2081 while (error == 0) {
11ad5ade 2082 leaf = cursor->leaf;
7a04d74f 2083
11ad5ade 2084 KKASSERT(leaf->base.delete_tid == 0);
7a04d74f
MD
2085
2086 /*
2087 * Mark the record and B-Tree entry as deleted. This will
2088 * also physically delete the B-Tree entry, record, and
2089 * data if the retention policy dictates. The function
5c8d05e2
MD
2090 * will set HAMMER_CURSOR_RETEST to cause hammer_ip_next()
2091 * to retest the new 'current' element.
1f07f686
MD
2092 *
2093 * Directory entries (and delete-on-disk directory entries)
2094 * must be synced and cannot be deleted.
7a04d74f 2095 */
a9d52b76
MD
2096 error = hammer_ip_delete_record(cursor, ip, trans->tid);
2097 ++*countp;
7a04d74f
MD
2098 if (error)
2099 break;
4e17f465
MD
2100 error = hammer_ip_next(cursor);
2101 }
cb51be26 2102 if (cursor->node)
bcac4bbb 2103 hammer_cache_node(&ip->cache[1], cursor->node);
4e17f465
MD
2104 if (error == EDEADLK) {
2105 hammer_done_cursor(cursor);
bcac4bbb 2106 error = hammer_init_cursor(trans, cursor, &ip->cache[1], ip);
4e17f465
MD
2107 if (error == 0)
2108 goto retry;
7a04d74f 2109 }
7a04d74f
MD
2110 if (error == ENOENT)
2111 error = 0;
2112 return(error);
2113}
2114
195c19a1 2115/*
46fe7ae1
MD
2116 * Delete the record at the current cursor. On success the cursor will
2117 * be positioned appropriately for an iteration but may no longer be at
2118 * a leaf node.
6a37e7e4 2119 *
b84de5af
MD
2120 * This routine is only called from the backend.
2121 *
6a37e7e4
MD
2122 * NOTE: This can return EDEADLK, requiring the caller to terminate the
2123 * cursor and retry.
195c19a1
MD
2124 */
2125int
e63644f0
MD
2126hammer_ip_delete_record(hammer_cursor_t cursor, hammer_inode_t ip,
2127 hammer_tid_t tid)
195c19a1 2128{
4a2796f3 2129 hammer_record_t iprec;
195c19a1
MD
2130 hammer_mount_t hmp;
2131 int error;
2132
d36ec43b 2133 KKASSERT(cursor->flags & HAMMER_CURSOR_BACKEND);
cebe9493 2134 KKASSERT(tid != 0);
4a2796f3 2135 hmp = cursor->node->hmp;
d36ec43b 2136
195c19a1 2137 /*
d36ec43b
MD
2138 * In-memory (unsynchronized) records can simply be freed. This
2139 * only occurs in range iterations since all other records are
2140 * individually synchronized. Thus there should be no confusion with
2141 * the interlock.
4a2796f3
MD
2142 *
2143 * An in-memory record may be deleted before being committed to disk,
1b0ab2c3
MD
2144 * but could have been accessed in the mean time. The reservation
2145 * code will deal with the case.
195c19a1 2146 */
47637bff 2147 if (hammer_cursor_inmem(cursor)) {
4a2796f3
MD
2148 iprec = cursor->iprec;
2149 KKASSERT((iprec->flags & HAMMER_RECF_INTERLOCK_BE) ==0);
2150 iprec->flags |= HAMMER_RECF_DELETED_FE;
2151 iprec->flags |= HAMMER_RECF_DELETED_BE;
3214ade6
MD
2152 KKASSERT(iprec->ip == ip);
2153 ++ip->rec_generation;
195c19a1
MD
2154 return(0);
2155 }
2156
2157 /*
2158 * On-disk records are marked as deleted by updating their delete_tid.
9582c7da
MD
2159 * This does not effect their position in the B-Tree (which is based
2160 * on their create_tid).
842e7a70
MD
2161 *
2162 * Frontend B-Tree operations track inodes so we tell
2163 * hammer_delete_at_cursor() not to.
195c19a1 2164 */
11ad5ade 2165 error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_LEAF);
195c19a1
MD
2166
2167 if (error == 0) {
602c6cb8
MD
2168 error = hammer_delete_at_cursor(
2169 cursor,
2170 HAMMER_DELETE_ADJUST | hammer_nohistory(ip),
842e7a70
MD
2171 cursor->trans->tid,
2172 cursor->trans->time32,
2173 0, NULL);
195c19a1
MD
2174 }
2175 return(error);
2176}
2177
602c6cb8
MD
2178/*
2179 * Delete the B-Tree element at the current cursor and do any necessary
2180 * mirror propagation.
2181 *
2182 * The cursor must be properly positioned for an iteration on return but
2183 * may be pointing at an internal element.
842e7a70
MD
2184 *
2185 * An element can be un-deleted by passing a delete_tid of 0 with
2186 * HAMMER_DELETE_ADJUST.
602c6cb8 2187 */
7dc57964 2188int
602c6cb8 2189hammer_delete_at_cursor(hammer_cursor_t cursor, int delete_flags,
842e7a70
MD
2190 hammer_tid_t delete_tid, u_int32_t delete_ts,
2191 int track, int64_t *stat_bytes)
7dc57964 2192{
602c6cb8 2193 struct hammer_btree_leaf_elm save_leaf;
842e7a70 2194 hammer_transaction_t trans;
602c6cb8
MD
2195 hammer_btree_leaf_elm_t leaf;
2196 hammer_node_t node;
7dc57964 2197 hammer_btree_elm_t elm;
47197d71 2198 hammer_off_t data_offset;
7dc57964 2199 int32_t data_len;
bf686dbe 2200 u_int16_t rec_type;
7dc57964 2201 int error;
842e7a70 2202 int icount;
602c6cb8 2203 int doprop;
7dc57964 2204
602c6cb8
MD
2205 error = hammer_cursor_upgrade(cursor);
2206 if (error)
2207 return(error);
2208
842e7a70 2209 trans = cursor->trans;
602c6cb8
MD
2210 node = cursor->node;
2211 elm = &node->ondisk->elms[cursor->index];
2212 leaf = &elm->leaf;
7dc57964
MD
2213 KKASSERT(elm->base.btype == HAMMER_BTREE_TYPE_RECORD);
2214
842e7a70
MD
2215 hammer_sync_lock_sh(trans);
2216 doprop = 0;
2217 icount = 0;
2218
602c6cb8
MD
2219 /*
2220 * Adjust the delete_tid. Update the mirror_tid propagation field
02325004 2221 * as well. delete_tid can be 0 (undelete -- used by mirroring).
602c6cb8 2222 */
602c6cb8 2223 if (delete_flags & HAMMER_DELETE_ADJUST) {
842e7a70
MD
2224 if (elm->base.rec_type == HAMMER_RECTYPE_INODE) {
2225 if (elm->leaf.base.delete_tid == 0 && delete_tid)
2226 icount = -1;
2227 if (elm->leaf.base.delete_tid && delete_tid == 0)
2228 icount = 1;
2229 }
2230
2231 hammer_modify_node(trans, node, elm, sizeof(*elm));
2232 elm->leaf.base.delete_tid = delete_tid;
2233 elm->leaf.delete_ts = delete_ts;
602c6cb8
MD
2234 hammer_modify_node_done(node);
2235
2236 if (elm->leaf.base.delete_tid > node->ondisk->mirror_tid) {
842e7a70 2237 hammer_modify_node_field(trans, node, mirror_tid);
602c6cb8
MD
2238 node->ondisk->mirror_tid = elm->leaf.base.delete_tid;
2239 hammer_modify_node_done(node);
2240 doprop = 1;
02325004
MD
2241 if (hammer_debug_general & 0x0002) {
2242 kprintf("delete_at_cursor: propagate %016llx"
2243 " @%016llx\n",
2244 elm->leaf.base.delete_tid,
2245 node->node_offset);
2246 }
602c6cb8 2247 }
7dc57964 2248
7dc57964 2249 /*
602c6cb8
MD
2250 * Adjust for the iteration. We have deleted the current
2251 * element and want to clear ATEDISK so the iteration does
2252 * not skip the element after, which now becomes the current
5c8d05e2
MD
2253 * element. This element must be re-tested if doing an
2254 * iteration, which is handled by the RETEST flag.
7dc57964
MD
2255 */
2256 if ((cursor->flags & HAMMER_CURSOR_DISKEOF) == 0) {
5c8d05e2 2257 cursor->flags |= HAMMER_CURSOR_RETEST;
7dc57964
MD
2258 cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
2259 }
602c6cb8
MD
2260
2261 /*
2262 * An on-disk record cannot have the same delete_tid
2263 * as its create_tid. In a chain of record updates
2264 * this could result in a duplicate record.
2265 */
2266 KKASSERT(elm->leaf.base.delete_tid !=
2267 elm->leaf.base.create_tid);
40043e7f 2268 }
602c6cb8
MD
2269
2270 /*
2271 * Destroy the B-Tree element if asked (typically if a nohistory
2272 * file or mount, or when called by the pruning code).
2273 *
2274 * Adjust the ATEDISK flag to properly support iterations.
2275 */
2276 if (delete_flags & HAMMER_DELETE_DESTROY) {
2277 data_offset = elm->leaf.data_offset;
2278 data_len = elm->leaf.data_len;
2279 rec_type = elm->leaf.base.rec_type;
2280 if (doprop) {
2281 save_leaf = elm->leaf;
2282 leaf = &save_leaf;
eb3f8f1f 2283 }
842e7a70
MD
2284 if (elm->base.rec_type == HAMMER_RECTYPE_INODE &&
2285 elm->leaf.base.delete_tid == 0) {
2286 icount = -1;
2287 }
602c6cb8
MD
2288
2289 error = hammer_btree_delete(cursor);
2290 if (error == 0) {
2291 /*
5c8d05e2
MD
2292 * The deletion moves the next element (if any) to
2293 * the current element position. We must clear
2294 * ATEDISK so this element is not skipped and we
2295 * must set RETEST to force any iteration to re-test
2296 * the element.
602c6cb8
MD
2297 */
2298 if ((cursor->flags & HAMMER_CURSOR_DISKEOF) == 0) {
5c8d05e2 2299 cursor->flags |= HAMMER_CURSOR_RETEST;
602c6cb8
MD
2300 cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
2301 }
2302 }
2303 if (error == 0) {
2304 switch(data_offset & HAMMER_OFF_ZONE_MASK) {
2305 case HAMMER_ZONE_LARGE_DATA:
2306 case HAMMER_ZONE_SMALL_DATA:
2307 case HAMMER_ZONE_META:
842e7a70 2308 hammer_blockmap_free(trans,
602c6cb8
MD
2309 data_offset, data_len);
2310 break;
2311 default:
2312 break;
2313 }
2314 }
2315 }
2316
2317 /*
842e7a70
MD
2318 * Track inode count and next_tid. This is used by the mirroring
2319 * and PFS code. icount can be negative, zero, or positive.
2320 */
2321 if (error == 0 && track) {
2322 if (icount) {
2323 hammer_modify_volume_field(trans, trans->rootvol,
2324 vol0_stat_inodes);
2325 trans->rootvol->ondisk->vol0_stat_inodes += icount;
2326 hammer_modify_volume_done(trans->rootvol);
2327 }
2328 if (trans->rootvol->ondisk->vol0_next_tid < delete_tid) {
2329 hammer_modify_volume(trans, trans->rootvol, NULL, 0);
2330 trans->rootvol->ondisk->vol0_next_tid = delete_tid;
2331 hammer_modify_volume_done(trans->rootvol);
2332 }
2333 }
2334
2335 /*
602c6cb8
MD
2336 * mirror_tid propagation occurs if the node's mirror_tid had to be
2337 * updated while adjusting the delete_tid.
2338 *
2339 * This occurs when deleting even in nohistory mode, but does not
2340 * occur when pruning an already-deleted node.
842e7a70
MD
2341 *
2342 * cursor->ip is NULL when called from the pruning, mirroring,
2343 * and pfs code. If non-NULL propagation will be conditionalized
2344 * on whether the PFS is in no-history mode or not.
602c6cb8
MD
2345 */
2346 if (doprop) {
842e7a70
MD
2347 if (cursor->ip)
2348 hammer_btree_do_propagation(cursor, cursor->ip->pfsm, leaf);
2349 else
2350 hammer_btree_do_propagation(cursor, NULL, leaf);
7dc57964 2351 }
842e7a70 2352 hammer_sync_unlock(trans);
7dc57964
MD
2353 return (error);
2354}
2355
b3deaf57 2356/*
1f07f686
MD
2357 * Determine whether we can remove a directory. This routine checks whether
2358 * a directory is empty or not and enforces flush connectivity.
2359 *
2360 * Flush connectivity requires that we block if the target directory is
2361 * currently flushing, otherwise it may not end up in the same flush group.
2362 *
2363 * Returns 0 on success, ENOTEMPTY or EDEADLK (or other errors) on failure.
b3deaf57
MD
2364 */
2365int
98f7132d 2366hammer_ip_check_directory_empty(hammer_transaction_t trans, hammer_inode_t ip)
b3deaf57
MD
2367{
2368 struct hammer_cursor cursor;
2369 int error;
2370
1f07f686
MD
2371 /*
2372 * Check directory empty
2373 */
bcac4bbb 2374 hammer_init_cursor(trans, &cursor, &ip->cache[1], ip);
b3deaf57 2375
5a930e66
MD
2376 cursor.key_beg.localization = ip->obj_localization +
2377 HAMMER_LOCALIZE_MISC;
b3deaf57 2378 cursor.key_beg.obj_id = ip->obj_id;
d5530d22 2379 cursor.key_beg.create_tid = 0;
b3deaf57
MD
2380 cursor.key_beg.delete_tid = 0;
2381 cursor.key_beg.obj_type = 0;
2382 cursor.key_beg.rec_type = HAMMER_RECTYPE_INODE + 1;
2383 cursor.key_beg.key = HAMMER_MIN_KEY;
2384
2385 cursor.key_end = cursor.key_beg;
2386 cursor.key_end.rec_type = 0xFFFF;
2387 cursor.key_end.key = HAMMER_MAX_KEY;
2388
d5530d22
MD
2389 cursor.asof = ip->obj_asof;
2390 cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE | HAMMER_CURSOR_ASOF;
b3deaf57 2391
4e17f465 2392 error = hammer_ip_first(&cursor);
b3deaf57
MD
2393 if (error == ENOENT)
2394 error = 0;
2395 else if (error == 0)
2396 error = ENOTEMPTY;
2397 hammer_done_cursor(&cursor);
2398 return(error);
2399}
2400