sys/vfs/hammer/hammer_object.c

   1 /*
   2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
   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  *
  34  * $DragonFly: src/sys/vfs/hammer/hammer_object.c,v 1.18 2008/01/10 07:41:03 dillon Exp $
  35  */
  36
  37 #include "hammer.h"
  38
  39 static int hammer_mem_add(hammer_transaction_t trans,
  40                              hammer_record_t record);
  41 static int hammer_mem_lookup(hammer_cursor_t cursor, hammer_inode_t ip);
  42 static int hammer_mem_first(hammer_cursor_t cursor, hammer_inode_t ip);
  43
  44 /*
  45  * Red-black tree support.
  46  */
  47 static int
  48 hammer_rec_rb_compare(hammer_record_t rec1, hammer_record_t rec2)
  49 {
  50         if (rec1->rec.base.base.rec_type < rec2->rec.base.base.rec_type)
  51                 return(-1);
  52         if (rec1->rec.base.base.rec_type > rec2->rec.base.base.rec_type)
  53                 return(1);
  54
  55         if (rec1->rec.base.base.key < rec2->rec.base.base.key)
  56                 return(-1);
  57         if (rec1->rec.base.base.key > rec2->rec.base.base.key)
  58                 return(1);
  59
  60         if (rec1->rec.base.base.create_tid < rec2->rec.base.base.create_tid)
  61                 return(-1);
  62         if (rec1->rec.base.base.create_tid > rec2->rec.base.base.create_tid)
  63                 return(1);
  64         return(0);
  65 }
  66
  67 static int
  68 hammer_rec_compare(hammer_base_elm_t info, hammer_record_t rec)
  69 {
  70         if (info->rec_type < rec->rec.base.base.rec_type)
  71                 return(-3);
  72         if (info->rec_type > rec->rec.base.base.rec_type)
  73                 return(3);
  74
  75         if (info->key < rec->rec.base.base.key)
  76                 return(-2);
  77         if (info->key > rec->rec.base.base.key)
  78                 return(2);
  79
  80         /*
  81          * This test has a number of special cases.  create_tid in key1 is
  82          * the as-of transction id, and delete_tid in key1 is NOT USED.
  83          *
  84          * A key1->create_tid of 0 matches any record regardles of when
  85          * it was created or destroyed.  0xFFFFFFFFFFFFFFFFULL should be
  86          * used to search for the most current state of the object.
  87          *
  88          * key2->create_tid is a HAMMER record and will never be
  89          * 0.   key2->delete_tid is the deletion transaction id or 0 if
  90          * the record has not yet been deleted.
  91          */
  92         if (info->create_tid) {
  93                 if (info->create_tid < rec->rec.base.base.create_tid)
  94                         return(-1);
  95                 if (rec->rec.base.base.delete_tid &&
  96                     info->create_tid >= rec->rec.base.base.delete_tid) {
  97                         return(1);
  98                 }
  99         }
 100         return(0);
 101 }
 102
 103 /*
 104  * RB_SCAN comparison code for hammer_mem_first().  The argument order
 105  * is reversed so the comparison result has to be negated.  key_beg and
 106  * key_end are both range-inclusive.
 107  *
 108  * The creation timestamp can cause hammer_rec_compare() to return -1 or +1.
 109  * These do not stop the scan.
 110  *
 111  * Localized deletions are not cached in-memory.
 112  */
 113 static
 114 int
 115 hammer_rec_scan_cmp(hammer_record_t rec, void *data)
 116 {
 117         hammer_cursor_t cursor = data;
 118         int r;
 119
 120         r = hammer_rec_compare(&cursor->key_beg, rec);
 121         if (r > 1)
 122                 return(-1);
 123         if (r == 0)
 124                 return(0);
 125         r = hammer_rec_compare(&cursor->key_end, rec);
 126         if (r < -1)
 127                 return(1);
 128         return(0);
 129 }
 130
 131 RB_GENERATE(hammer_rec_rb_tree, hammer_record, rb_node, hammer_rec_rb_compare);
 132 RB_GENERATE_XLOOKUP(hammer_rec_rb_tree, INFO, hammer_record, rb_node,
 133                     hammer_rec_compare, hammer_base_elm_t);
 134
 135 /*
 136  * Allocate a record for the caller to finish filling in.  The record is
 137  * returned referenced.
 138  */
 139 hammer_record_t
 140 hammer_alloc_mem_record(hammer_inode_t ip)
 141 {
 142         hammer_record_t record;
 143
 144         ++hammer_count_records;
 145         record = kmalloc(sizeof(*record), M_HAMMER, M_WAITOK|M_ZERO);
 146         record->ip = ip;
 147         hammer_ref(&record->lock);
 148         return (record);
 149 }
 150
 151 /*
 152  * Release a memory record.  Records marked for deletion are immediately
 153  * removed from the RB-Tree but otherwise left intact until the last ref
 154  * goes away.
 155  */
 156 void
 157 hammer_rel_mem_record(struct hammer_record *record)
 158 {
 159         hammer_unref(&record->lock);
 160         if (record->flags & HAMMER_RECF_DELETED) {
 161                 if (record->flags & HAMMER_RECF_ONRBTREE) {
 162                         RB_REMOVE(hammer_rec_rb_tree, &record->ip->rec_tree,
 163                                   record);
 164                         record->flags &= ~HAMMER_RECF_ONRBTREE;
 165                 }
 166                 if (record->lock.refs == 0) {
 167                         if (record->flags & HAMMER_RECF_ALLOCDATA) {
 168                                 --hammer_count_record_datas;
 169                                 kfree(record->data, M_HAMMER);
 170                                 record->flags &= ~HAMMER_RECF_ALLOCDATA;
 171                         }
 172                         record->data = NULL;
 173                         --hammer_count_records;
 174                         kfree(record, M_HAMMER);
 175                 }
 176         }
 177 }
 178
 179 /*
 180  * Lookup an in-memory record given the key specified in the cursor.  Works
 181  * just like hammer_btree_lookup() but operates on an inode's in-memory
 182  * record list.
 183  *
 184  * The lookup must fail if the record is marked for deferred deletion.
 185  */
 186 static
 187 int
 188 hammer_mem_lookup(hammer_cursor_t cursor, hammer_inode_t ip)
 189 {
 190         int error;
 191
 192         if (cursor->iprec) {
 193                 hammer_rel_mem_record(cursor->iprec);
 194                 cursor->iprec = NULL;
 195         }
 196         if (cursor->ip) {
 197                 hammer_rec_rb_tree_scan_info_done(&cursor->scan,
 198                                                   &cursor->ip->rec_tree);
 199         }
 200         cursor->ip = ip;
 201         hammer_rec_rb_tree_scan_info_link(&cursor->scan, &ip->rec_tree);
 202         cursor->scan.node = NULL;
 203         cursor->iprec = hammer_rec_rb_tree_RB_LOOKUP_INFO(
 204                                 &ip->rec_tree, &cursor->key_beg);
 205         if (cursor->iprec == NULL) {
 206                 error = ENOENT;
 207         } else {
 208                 hammer_ref(&cursor->iprec->lock);
 209                 error = 0;
 210         }
 211         return(error);
 212 }
 213
 214 /*
 215  * hammer_mem_first() - locate the first in-memory record matching the
 216  * cursor.
 217  *
 218  * The RB_SCAN function we use is designed as a callback.  We terminate it
 219  * (return -1) as soon as we get a match.
 220  */
 221 static
 222 int
 223 hammer_rec_scan_callback(hammer_record_t rec, void *data)
 224 {
 225         hammer_cursor_t cursor = data;
 226
 227         /*
 228          * Skip if not visible due to our as-of TID
 229          */
 230         if (cursor->key_beg.create_tid) {
 231                 if (cursor->key_beg.create_tid < rec->rec.base.base.create_tid)
 232                         return(0);
 233                 if (rec->rec.base.base.delete_tid &&
 234                     cursor->key_beg.create_tid >=
 235                      rec->rec.base.base.delete_tid) {
 236                         return(0);
 237                 }
 238         }
 239
 240         /*
 241          * Return the first matching record and stop the scan
 242          */
 243         if (cursor->iprec == NULL) {
 244                 cursor->iprec = rec;
 245                 hammer_ref(&rec->lock);
 246                 return(-1);
 247         }
 248         return(0);
 249 }
 250
 251 static
 252 int
 253 hammer_mem_first(hammer_cursor_t cursor, hammer_inode_t ip)
 254 {
 255         if (cursor->iprec) {
 256                 hammer_rel_mem_record(cursor->iprec);
 257                 cursor->iprec = NULL;
 258         }
 259         if (cursor->ip) {
 260                 hammer_rec_rb_tree_scan_info_done(&cursor->scan,
 261                                                   &cursor->ip->rec_tree);
 262         }
 263         cursor->ip = ip;
 264         hammer_rec_rb_tree_scan_info_link(&cursor->scan, &ip->rec_tree);
 265
 266         cursor->scan.node = NULL;
 267         hammer_rec_rb_tree_RB_SCAN(&ip->rec_tree, hammer_rec_scan_cmp,
 268                                    hammer_rec_scan_callback, cursor);
 269
 270         /*
 271          * Adjust scan.node and keep it linked into the RB-tree so we can
 272          * hold the cursor through third party modifications of the RB-tree.
 273          */
 274         if (cursor->iprec) {
 275                 cursor->scan.node = hammer_rec_rb_tree_RB_NEXT(cursor->iprec);
 276                 return(0);
 277         }
 278         return(ENOENT);
 279 }
 280
 281 void
 282 hammer_mem_done(hammer_cursor_t cursor)
 283 {
 284         if (cursor->ip) {
 285                 hammer_rec_rb_tree_scan_info_done(&cursor->scan,
 286                                                   &cursor->ip->rec_tree);
 287                 cursor->ip = NULL;
 288         }
 289         if (cursor->iprec) {
 290                 hammer_rel_mem_record(cursor->iprec);
 291                 cursor->iprec = NULL;
 292         }
 293 }
 294
 295 /************************************************************************
 296  *                   HAMMER IN-MEMORY RECORD FUNCTIONS                  *
 297  ************************************************************************
 298  *
 299  * These functions manipulate in-memory records.  Such records typically
 300  * exist prior to being committed to disk or indexed via the on-disk B-Tree.
 301  */
 302
 303 /*
 304  * Add a directory entry (dip,ncp) which references inode (ip).
 305  *
 306  * Note that the low 32 bits of the namekey are set temporarily to create
 307  * a unique in-memory record, and may be modified a second time when the
 308  * record is synchronized to disk.  In particular, the low 32 bits cannot be
 309  * all 0's when synching to disk, which is not handled here.
 310  */
 311 int
 312 hammer_ip_add_directory(struct hammer_transaction *trans,
 313                      struct hammer_inode *dip, struct namecache *ncp,
 314                      struct hammer_inode *ip)
 315 {
 316         hammer_record_t record;
 317         int error;
 318         int bytes;
 319
 320         record = hammer_alloc_mem_record(dip);
 321
 322         bytes = ncp->nc_nlen;   /* NOTE: terminating \0 is NOT included */
 323         if (++trans->hmp->namekey_iterator == 0)
 324                 ++trans->hmp->namekey_iterator;
 325
 326         record->rec.entry.base.base.obj_id = dip->obj_id;
 327         record->rec.entry.base.base.key =
 328                 hammer_directory_namekey(ncp->nc_name, bytes);
 329         record->rec.entry.base.base.key += trans->hmp->namekey_iterator;
 330         record->rec.entry.base.base.create_tid = trans->tid;
 331         record->rec.entry.base.base.rec_type = HAMMER_RECTYPE_DIRENTRY;
 332         record->rec.entry.base.base.obj_type = ip->ino_rec.base.base.obj_type;
 333         record->rec.entry.obj_id = ip->obj_id;
 334         if (bytes <= sizeof(record->rec.entry.den_name)) {
 335                 record->data = (void *)record->rec.entry.den_name;
 336                 record->flags |= HAMMER_RECF_EMBEDDED_DATA;
 337         } else {
 338                 ++hammer_count_record_datas;
 339                 record->data = kmalloc(bytes, M_HAMMER, M_WAITOK);
 340                 record->flags |= HAMMER_RECF_ALLOCDATA;
 341         }
 342         bcopy(ncp->nc_name, record->data, bytes);
 343         record->rec.entry.base.data_len = bytes;
 344         ++ip->ino_rec.ino_nlinks;
 345         hammer_modify_inode(trans, ip, HAMMER_INODE_RDIRTY);
 346         error = hammer_mem_add(trans, record);
 347         return(error);
 348 }
 349
 350 /*
 351  * Delete the directory entry and update the inode link count.  The
 352  * cursor must be seeked to the directory entry record being deleted.
 353  *
 354  * NOTE: HAMMER_CURSOR_DELETE may not have been set.  XXX remove flag.
 355  */
 356 int
 357 hammer_ip_del_directory(struct hammer_transaction *trans,
 358                      hammer_cursor_t cursor, struct hammer_inode *dip,
 359                      struct hammer_inode *ip)
 360 {
 361         int error;
 362
 363         error = hammer_ip_delete_record(cursor, trans->tid);
 364
 365         /*
 366          * One less link.  The file may still be open in the OS even after
 367          * all links have gone away so we only try to sync if the OS has
 368          * no references and nlinks falls to 0.
 369          */
 370         if (error == 0) {
 371                 --ip->ino_rec.ino_nlinks;
 372                 hammer_modify_inode(trans, ip, HAMMER_INODE_RDIRTY);
 373                 if (ip->ino_rec.ino_nlinks == 0 &&
 374                     (ip->vp == NULL || (ip->vp->v_flag & VINACTIVE))) {
 375                         hammer_sync_inode(ip, MNT_NOWAIT, 1);
 376                 }
 377
 378         }
 379         return(error);
 380 }
 381
 382 /*
 383  * Add a record to an inode.
 384  *
 385  * The caller must allocate the record with hammer_alloc_mem_record(ip) and
 386  * initialize the following additional fields:
 387  *
 388  * record->rec.entry.base.base.key
 389  * record->rec.entry.base.base.rec_type
 390  * record->rec.entry.base.base.data_len
 391  * record->data         (a copy will be kmalloc'd if not embedded)
 392  */
 393 int
 394 hammer_ip_add_record(struct hammer_transaction *trans, hammer_record_t record)
 395 {
 396         hammer_inode_t ip = record->ip;
 397         int error;
 398         int bytes;
 399         void *data;
 400
 401         record->rec.base.base.obj_id = ip->obj_id;
 402         record->rec.base.base.create_tid = trans->tid;
 403         record->rec.base.base.obj_type = ip->ino_rec.base.base.obj_type;
 404         bytes = record->rec.base.data_len;
 405
 406         if (record->data) {
 407                 if ((char *)record->data < (char *)&record->rec ||
 408                     (char *)record->data >= (char *)(&record->rec + 1)) {
 409                         ++hammer_count_record_datas;
 410                         data = kmalloc(bytes, M_HAMMER, M_WAITOK);
 411                         record->flags |= HAMMER_RECF_ALLOCDATA;
 412                         bcopy(record->data, data, bytes);
 413                         record->data = data;
 414                 } else {
 415                         record->flags |= HAMMER_RECF_EMBEDDED_DATA;
 416                 }
 417         }
 418         hammer_modify_inode(trans, ip, HAMMER_INODE_RDIRTY);
 419         error = hammer_mem_add(trans, record);
 420         return(error);
 421 }
 422
 423 /*
 424  * Sync data from a buffer cache buffer (typically) to the filesystem.  This
 425  * is called via the strategy called from a cached data source.  This code
 426  * is responsible for actually writing a data record out to the disk.
 427  */
 428 int
 429 hammer_ip_sync_data(hammer_transaction_t trans, hammer_inode_t ip,
 430                        int64_t offset, void *data, int bytes,
 431                        struct hammer_cursor **spike)
 432 {
 433         struct hammer_cursor cursor;
 434         hammer_record_ondisk_t rec;
 435         union hammer_btree_elm elm;
 436         void *bdata;
 437         int error;
 438
 439         error = hammer_init_cursor_hmp(&cursor, &ip->cache[0], ip->hmp);
 440         if (error)
 441                 return(error);
 442         cursor.key_beg.obj_id = ip->obj_id;
 443         cursor.key_beg.key = offset + bytes;
 444         cursor.key_beg.create_tid = trans->tid;
 445         cursor.key_beg.delete_tid = 0;
 446         cursor.key_beg.rec_type = HAMMER_RECTYPE_DATA;
 447         cursor.flags = HAMMER_CURSOR_INSERT;
 448
 449         /*
 450          * Issue a lookup to position the cursor and locate the cluster
 451          */
 452         error = hammer_btree_lookup(&cursor);
 453         if (error == 0) {
 454                 kprintf("hammer_ip_sync_data: duplicate data at (%lld,%d)\n",
 455                         offset, bytes);
 456                 hammer_print_btree_elm(&cursor.node->ondisk->elms[cursor.index],
 457                                        HAMMER_BTREE_TYPE_LEAF, cursor.index);
 458                 error = EIO;
 459         }
 460         if (error != ENOENT)
 461                 goto done;
 462
 463         /*
 464          * Allocate record and data space now that we know which cluster
 465          * the B-Tree node ended up in.
 466          */
 467         bdata = hammer_alloc_data(cursor.node->cluster, bytes, &error,
 468                                   &cursor.data_buffer);
 469         if (bdata == NULL)
 470                 goto done;
 471         rec = hammer_alloc_record(cursor.node->cluster, &error,
 472                                   &cursor.record_buffer);
 473         if (rec == NULL)
 474                 goto fail1;
 475
 476         /*
 477          * Fill everything in and insert our B-Tree node.
 478          */
 479         hammer_modify_buffer(cursor.record_buffer);
 480         rec->base.base = cursor.key_beg;
 481         rec->base.data_crc = crc32(data, bytes);
 482         rec->base.rec_id = 0;   /* XXX */
 483         rec->base.data_offset = hammer_bclu_offset(cursor.data_buffer, bdata);
 484         rec->base.data_len = bytes;
 485
 486         hammer_modify_buffer(cursor.data_buffer);
 487         bcopy(data, bdata, bytes);
 488
 489         elm.leaf.base = cursor.key_beg;
 490         elm.leaf.rec_offset = hammer_bclu_offset(cursor.record_buffer, rec);
 491         elm.leaf.data_offset = rec->base.data_offset;
 492         elm.leaf.data_len = bytes;
 493         elm.leaf.data_crc = rec->base.data_crc;
 494
 495         /*
 496          * Data records can wind up on-disk before the inode itself is
 497          * on-disk.  One must assume data records may be on-disk if either
 498          * HAMMER_INODE_DONDISK or HAMMER_INODE_ONDISK is set
 499          */
 500         ip->flags |= HAMMER_INODE_DONDISK;
 501
 502         error = hammer_btree_insert(&cursor, &elm);
 503         if (error == 0) {
 504                 hammer_update_syncid(cursor.record_buffer->cluster, trans->tid);
 505                 goto done;
 506         }
 507
 508         hammer_free_record_ptr(cursor.record_buffer, rec);
 509 fail1:
 510         hammer_free_data_ptr(cursor.data_buffer, bdata, bytes);
 511 done:
 512         /*
 513          * If ENOSPC in cluster fill in the spike structure and return
 514          * ENOSPC.
 515          */
 516         if (error == ENOSPC)
 517                 hammer_load_spike(&cursor, spike);
 518         hammer_done_cursor(&cursor);
 519         return(error);
 520 }
 521
 522 /*
 523  * Sync an in-memory record to the disk.  this is typically called via fsync
 524  * from a cached record source.  This code is responsible for actually
 525  * writing a record out to the disk.
 526  */
 527 int
 528 hammer_ip_sync_record(hammer_record_t record, struct hammer_cursor **spike)
 529 {
 530         struct hammer_cursor cursor;
 531         hammer_record_ondisk_t rec;
 532         hammer_mount_t hmp;
 533         union hammer_btree_elm elm;
 534         void *bdata;
 535         int error;
 536
 537         error = hammer_init_cursor_hmp(&cursor, &record->ip->cache[0],
 538                                        record->ip->hmp);
 539         if (error)
 540                 return(error);
 541         cursor.key_beg = record->rec.base.base;
 542         cursor.flags = HAMMER_CURSOR_INSERT;
 543
 544         /*
 545          * Issue a lookup to position the cursor and locate the cluster.  The
 546          * target key should not exist.  If we are creating a directory entry
 547          * we may have to iterate the low 32 bits of the key to find an unused
 548          * key.
 549          *
 550          * If we run out of space trying to adjust the B-Tree for the
 551          * insert, re-lookup without the insert flag so the cursor
 552          * is properly positioned for the spike.
 553          */
 554 again:
 555         error = hammer_btree_lookup(&cursor);
 556         if (error == 0) {
 557                 if (record->rec.base.base.rec_type == HAMMER_RECTYPE_DIRENTRY) {
 558                         hmp = cursor.node->cluster->volume->hmp;
 559                         if (++hmp->namekey_iterator == 0)
 560                                 ++hmp->namekey_iterator;
 561                         record->rec.base.base.key &= ~(0xFFFFFFFFLL);
 562                         record->rec.base.base.key |= hmp->namekey_iterator;
 563                         goto again;
 564                 }
 565                 kprintf("hammer_ip_sync_record: duplicate rec at (%016llx)\n",
 566                         record->rec.base.base.key);
 567                 Debugger("duplicate record1");
 568                 error = EIO;
 569         }
 570         if (error != ENOENT)
 571                 goto done;
 572
 573         /*
 574          * Mark the record as undergoing synchronization.  Our cursor is
 575          * holding a locked B-Tree node for the insertion which interlocks
 576          * anyone trying to access this record.
 577          *
 578          * XXX There is still a race present related to iterations.  An
 579          * iteration may process the record, a sync may occur, and then
 580          * later process the B-Tree element for the same record.
 581          *
 582          * We do not try to synchronize a deleted record.
 583          */
 584         if (record->flags & (HAMMER_RECF_DELETED | HAMMER_RECF_SYNCING)) {
 585                 error = 0;
 586                 goto done;
 587         }
 588         record->flags |= HAMMER_RECF_SYNCING;
 589
 590         /*
 591          * Allocate record and data space now that we know which cluster
 592          * the B-Tree node ended up in.
 593          */
 594         if (record->data == NULL ||
 595             (record->flags & HAMMER_RECF_EMBEDDED_DATA)) {
 596                 bdata = record->data;
 597         } else {
 598                 bdata = hammer_alloc_data(cursor.node->cluster,
 599                                           record->rec.base.data_len, &error,
 600                                           &cursor.data_buffer);
 601                 if (bdata == NULL)
 602                         goto fail2;
 603         }
 604         rec = hammer_alloc_record(cursor.node->cluster, &error,
 605                                   &cursor.record_buffer);
 606         if (rec == NULL)
 607                 goto fail1;
 608
 609         /*
 610          * Fill everything in and insert our B-Tree node.
 611          *
 612          * XXX assign rec_id here
 613          */
 614         hammer_modify_buffer(cursor.record_buffer);
 615         *rec = record->rec;
 616         if (bdata) {
 617                 rec->base.data_crc = crc32(record->data,
 618                                            record->rec.base.data_len);
 619                 if (record->flags & HAMMER_RECF_EMBEDDED_DATA) {
 620                         /*
 621                          * Data embedded in record
 622                          */
 623                         rec->base.data_offset = ((char *)bdata -
 624                                                  (char *)&record->rec);
 625                         KKASSERT(rec->base.data_offset >= 0 &&
 626                                  rec->base.data_offset + rec->base.data_len <=
 627                                   sizeof(*rec));
 628                         rec->base.data_offset += hammer_bclu_offset(cursor.record_buffer, rec);
 629                 } else {
 630                         /*
 631                          * Data separate from record
 632                          */
 633                         rec->base.data_offset = hammer_bclu_offset(cursor.data_buffer,bdata);
 634                         hammer_modify_buffer(cursor.data_buffer);
 635                         bcopy(record->data, bdata, rec->base.data_len);
 636                 }
 637         }
 638         rec->base.rec_id = 0;   /* XXX */
 639
 640         elm.leaf.base = cursor.key_beg;
 641         elm.leaf.rec_offset = hammer_bclu_offset(cursor.record_buffer, rec);
 642         elm.leaf.data_offset = rec->base.data_offset;
 643         elm.leaf.data_len = rec->base.data_len;
 644         elm.leaf.data_crc = rec->base.data_crc;
 645
 646         error = hammer_btree_insert(&cursor, &elm);
 647
 648         /*
 649          * Clean up on success, or fall through on error.
 650          */
 651         if (error == 0) {
 652                 record->flags |= HAMMER_RECF_DELETED;
 653                 record->flags &= ~HAMMER_RECF_SYNCING;
 654                 hammer_update_syncid(cursor.record_buffer->cluster,
 655                                      record->rec.base.base.create_tid);
 656                 goto done;
 657         }
 658
 659         hammer_free_record_ptr(cursor.record_buffer, rec);
 660 fail1:
 661         if (record->data && (record->flags & HAMMER_RECF_EMBEDDED_DATA) == 0) {
 662                 hammer_free_data_ptr(cursor.data_buffer, bdata,
 663                                      record->rec.base.data_len);
 664         }
 665 fail2:
 666         record->flags &= ~HAMMER_RECF_SYNCING;
 667 done:
 668         /*
 669          * If ENOSPC in cluster fill in the spike structure and return
 670          * ENOSPC.
 671          */
 672         if (error == ENOSPC)
 673                 hammer_load_spike(&cursor, spike);
 674         hammer_done_cursor(&cursor);
 675         return(error);
 676 }
 677
 678 /*
 679  * Write out a record using the specified cursor.  The caller does not have
 680  * to seek the cursor.  The flags are used to determine whether the data
 681  * (if any) is embedded in the record or not.
 682  *
 683  * The target cursor will be modified by this call.  Note in particular
 684  * that HAMMER_CURSOR_INSERT is set.
 685  */
 686 int
 687 hammer_write_record(hammer_cursor_t cursor, hammer_record_ondisk_t orec,
 688                     void *data, int cursor_flags)
 689 {
 690         union hammer_btree_elm elm;
 691         hammer_record_ondisk_t nrec;
 692         void *bdata;
 693         int error;
 694
 695         cursor->key_beg = orec->base.base;
 696         cursor->flags |= HAMMER_CURSOR_INSERT;
 697
 698         /*
 699          * Issue a lookup to position the cursor and locate the cluster.  The
 700          * target key should not exist.
 701          *
 702          * If we run out of space trying to adjust the B-Tree for the
 703          * insert, re-lookup without the insert flag so the cursor
 704          * is properly positioned for the spike.
 705          */
 706         error = hammer_btree_lookup(cursor);
 707         if (error == 0) {
 708                 kprintf("hammer_ip_sync_record: duplicate rec at (%016llx)\n",
 709                         orec->base.base.key);
 710                 Debugger("duplicate record2");
 711                 error = EIO;
 712         }
 713         if (error != ENOENT)
 714                 goto done;
 715
 716         /*
 717          * Allocate record and data space now that we know which cluster
 718          * the B-Tree node ended up in.
 719          */
 720         if (data == NULL ||
 721             (cursor_flags & HAMMER_RECF_EMBEDDED_DATA)) {
 722                 bdata = data;
 723         } else {
 724                 bdata = hammer_alloc_data(cursor->node->cluster,
 725                                           orec->base.data_len, &error,
 726                                           &cursor->data_buffer);
 727                 if (bdata == NULL)
 728                         goto done;
 729         }
 730         nrec = hammer_alloc_record(cursor->node->cluster, &error,
 731                                   &cursor->record_buffer);
 732         if (nrec == NULL)
 733                 goto fail1;
 734
 735         /*
 736          * Fill everything in and insert our B-Tree node.
 737          *
 738          * XXX assign rec_id here
 739          */
 740         hammer_modify_buffer(cursor->record_buffer);
 741         *nrec = *orec;
 742         nrec->base.data_offset = 0;
 743         if (bdata) {
 744                 nrec->base.data_crc = crc32(bdata, nrec->base.data_len);
 745                 if (cursor_flags & HAMMER_RECF_EMBEDDED_DATA) {
 746                         /*
 747                          * Data embedded in record
 748                          */
 749                         nrec->base.data_offset = ((char *)bdata - (char *)orec);
 750                         KKASSERT(nrec->base.data_offset >= 0 &&
 751                                  nrec->base.data_offset + nrec->base.data_len <
 752                                   sizeof(*nrec));
 753                         nrec->base.data_offset += hammer_bclu_offset(cursor->record_buffer, nrec);
 754                 } else {
 755                         /*
 756                          * Data separate from record
 757                          */
 758                         nrec->base.data_offset = hammer_bclu_offset(cursor->data_buffer, bdata);
 759                         hammer_modify_buffer(cursor->data_buffer);
 760                         bcopy(data, bdata, nrec->base.data_len);
 761                 }
 762         }
 763         nrec->base.rec_id = 0;  /* XXX */
 764
 765         elm.leaf.base = nrec->base.base;
 766         elm.leaf.rec_offset = hammer_bclu_offset(cursor->record_buffer, nrec);
 767         elm.leaf.data_offset = nrec->base.data_offset;
 768         elm.leaf.data_len = nrec->base.data_len;
 769         elm.leaf.data_crc = nrec->base.data_crc;
 770
 771         error = hammer_btree_insert(cursor, &elm);
 772         if (error == 0) {
 773                 hammer_update_syncid(cursor->record_buffer->cluster,
 774                                      nrec->base.base.create_tid);
 775                 goto done;
 776         }
 777
 778         hammer_free_record_ptr(cursor->record_buffer, nrec);
 779 fail1:
 780         if (data && (cursor_flags & HAMMER_RECF_EMBEDDED_DATA) == 0) {
 781                 hammer_free_data_ptr(cursor->data_buffer, bdata,
 782                                      orec->base.data_len);
 783         }
 784 done:
 785         /* leave cursor intact */
 786         return(error);
 787 }
 788
 789 /*
 790  * Add the record to the inode's rec_tree.  The low 32 bits of a directory
 791  * entry's key is used to deal with hash collisions in the upper 32 bits.
 792  * A unique 64 bit key is generated in-memory and may be regenerated a
 793  * second time when the directory record is flushed to the on-disk B-Tree.
 794  *
 795  * A referenced record is passed to this function.  This function
 796  * eats the reference.  If an error occurs the record will be deleted.
 797  */
 798 static
 799 int
 800 hammer_mem_add(struct hammer_transaction *trans, hammer_record_t record)
 801 {
 802         while (RB_INSERT(hammer_rec_rb_tree, &record->ip->rec_tree, record)) {
 803                 if (record->rec.base.base.rec_type != HAMMER_RECTYPE_DIRENTRY){
 804                         record->flags |= HAMMER_RECF_DELETED;
 805                         hammer_rel_mem_record(record);
 806                         return (EEXIST);
 807                 }
 808                 if (++trans->hmp->namekey_iterator == 0)
 809                         ++trans->hmp->namekey_iterator;
 810                 record->rec.base.base.key &= ~(0xFFFFFFFFLL);
 811                 record->rec.base.base.key |= trans->hmp->namekey_iterator;
 812         }
 813         record->flags |= HAMMER_RECF_ONRBTREE;
 814         hammer_modify_inode(trans, record->ip, HAMMER_INODE_XDIRTY);
 815         hammer_rel_mem_record(record);
 816         return(0);
 817 }
 818
 819 /************************************************************************
 820  *                   HAMMER INODE MERGED-RECORD FUNCTIONS               *
 821  ************************************************************************
 822  *
 823  * These functions augment the B-Tree scanning functions in hammer_btree.c
 824  * by merging in-memory records with on-disk records.
 825  */
 826
 827 /*
 828  * Locate a particular record either in-memory or on-disk.
 829  *
 830  * NOTE: This is basically a standalone routine, hammer_ip_next() may
 831  * NOT be called to iterate results.
 832  */
 833 int
 834 hammer_ip_lookup(hammer_cursor_t cursor, struct hammer_inode *ip)
 835 {
 836         int error;
 837
 838         /*
 839          * If the element is in-memory return it without searching the
 840          * on-disk B-Tree
 841          */
 842         error = hammer_mem_lookup(cursor, ip);
 843         if (error == 0) {
 844                 cursor->record = &cursor->iprec->rec;
 845                 return(error);
 846         }
 847         if (error != ENOENT)
 848                 return(error);
 849
 850         /*
 851          * If the inode has on-disk components search the on-disk B-Tree.
 852          */
 853         if ((ip->flags & (HAMMER_INODE_ONDISK|HAMMER_INODE_DONDISK)) == 0)
 854                 return(error);
 855         error = hammer_btree_lookup(cursor);
 856         if (error == 0)
 857                 error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_RECORD);
 858         return(error);
 859 }
 860
 861 /*
 862  * Locate the first record within the cursor's key_beg/key_end range,
 863  * restricted to a particular inode.  0 is returned on success, ENOENT
 864  * if no records matched the requested range, or some other error.
 865  *
 866  * When 0 is returned hammer_ip_next() may be used to iterate additional
 867  * records within the requested range.
 868  */
 869 int
 870 hammer_ip_first(hammer_cursor_t cursor, struct hammer_inode *ip)
 871 {
 872         int error;
 873
 874         /*
 875          * Clean up fields and setup for merged scan
 876          */
 877         cursor->flags &= ~HAMMER_CURSOR_DELBTREE;
 878         cursor->flags |= HAMMER_CURSOR_ATEDISK | HAMMER_CURSOR_ATEMEM;
 879         cursor->flags |= HAMMER_CURSOR_DISKEOF | HAMMER_CURSOR_MEMEOF;
 880         if (cursor->iprec) {
 881                 hammer_rel_mem_record(cursor->iprec);
 882                 cursor->iprec = NULL;
 883         }
 884
 885         /*
 886          * Search the on-disk B-Tree.  hammer_btree_lookup() only does an
 887          * exact lookup so if we get ENOENT we have to call the iterate
 888          * function to validate the first record after the begin key.
 889          *
 890          * The ATEDISK flag is used by hammer_btree_iterate to determine
 891          * whether it must index forwards or not.  It is also used here
 892          * to select the next record from in-memory or on-disk.
 893          */
 894         if (ip->flags & (HAMMER_INODE_ONDISK|HAMMER_INODE_DONDISK)) {
 895                 error = hammer_btree_lookup(cursor);
 896                 if (error == ENOENT) {
 897                         cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
 898                         error = hammer_btree_iterate(cursor);
 899                 }
 900                 if (error && error != ENOENT)
 901                         return(error);
 902                 if (error == 0) {
 903                         cursor->flags &= ~HAMMER_CURSOR_DISKEOF;
 904                         cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
 905                 } else {
 906                         cursor->flags |= HAMMER_CURSOR_ATEDISK;
 907                 }
 908         }
 909
 910         /*
 911          * Search the in-memory record list (Red-Black tree).  Unlike the
 912          * B-Tree search, mem_first checks for records in the range.
 913          */
 914         error = hammer_mem_first(cursor, ip);
 915         if (error && error != ENOENT)
 916                 return(error);
 917         if (error == 0) {
 918                 cursor->flags &= ~HAMMER_CURSOR_MEMEOF;
 919                 cursor->flags &= ~HAMMER_CURSOR_ATEMEM;
 920         }
 921
 922         /*
 923          * This will return the first matching record.
 924          */
 925         return(hammer_ip_next(cursor));
 926 }
 927
 928 /*
 929  * Retrieve the next record in a merged iteration within the bounds of the
 930  * cursor.  This call may be made multiple times after the cursor has been
 931  * initially searched with hammer_ip_first().
 932  *
 933  * 0 is returned on success, ENOENT if no further records match the
 934  * requested range, or some other error code is returned.
 935  */
 936 int
 937 hammer_ip_next(hammer_cursor_t cursor)
 938 {
 939         hammer_btree_elm_t elm;
 940         hammer_record_t rec;
 941         int error;
 942         int r;
 943
 944         /*
 945          * Load the current on-disk and in-memory record.  If we ate any
 946          * records we have to get the next one.
 947          *
 948          * If we deleted the last on-disk record we had scanned ATEDISK will
 949          * be clear and DELBTREE will be set, forcing a call to iterate. The
 950          * fact that ATEDISK is clear causes iterate to re-test the 'current'
 951          * element.  If ATEDISK is set, iterate will skip the 'current'
 952          * element.
 953          *
 954          * Get the next on-disk record
 955          */
 956         if (cursor->flags & (HAMMER_CURSOR_ATEDISK|HAMMER_CURSOR_DELBTREE)) {
 957                 if ((cursor->flags & HAMMER_CURSOR_DISKEOF) == 0) {
 958                         error = hammer_btree_iterate(cursor);
 959                         cursor->flags &= ~HAMMER_CURSOR_DELBTREE;
 960                         if (error == 0)
 961                                 cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
 962                         else
 963                                 cursor->flags |= HAMMER_CURSOR_DISKEOF |
 964                                                  HAMMER_CURSOR_ATEDISK;
 965                 }
 966         }
 967
 968         /*
 969          * Get the next in-memory record.  The record can be ripped out
 970          * of the RB tree so we maintain a scan_info structure to track
 971          * the next node.
 972          *
 973          * hammer_rec_scan_cmp:  Is the record still in our general range,
 974          *                       (non-inclusive of snapshot exclusions)?
 975          * hammer_rec_scan_callback: Is the record in our snapshot?
 976          */
 977         if (cursor->flags & HAMMER_CURSOR_ATEMEM) {
 978                 if ((cursor->flags & HAMMER_CURSOR_MEMEOF) == 0) {
 979                         if (cursor->iprec) {
 980                                 hammer_rel_mem_record(cursor->iprec);
 981                                 cursor->iprec = NULL;
 982                         }
 983                         rec = cursor->scan.node;        /* next node */
 984                         while (rec) {
 985                                 if (hammer_rec_scan_cmp(rec, cursor) != 0)
 986                                         break;
 987                                 if (hammer_rec_scan_callback(rec, cursor) != 0)
 988                                         break;
 989                                 rec = hammer_rec_rb_tree_RB_NEXT(rec);
 990                         }
 991                         if (cursor->iprec) {
 992                                 KKASSERT(cursor->iprec == rec);
 993                                 cursor->flags &= ~HAMMER_CURSOR_ATEMEM;
 994                                 cursor->scan.node =
 995                                         hammer_rec_rb_tree_RB_NEXT(rec);
 996                         } else {
 997                                 cursor->flags |= HAMMER_CURSOR_MEMEOF;
 998                         }
 999                 }
1000         }
1001
1002         /*
1003          * Extract either the disk or memory record depending on their
1004          * relative position.
1005          */
1006         error = 0;
1007         switch(cursor->flags & (HAMMER_CURSOR_ATEDISK | HAMMER_CURSOR_ATEMEM)) {
1008         case 0:
1009                 /*
1010                  * Both entries valid
1011                  */
1012                 elm = &cursor->node->ondisk->elms[cursor->index];
1013                 r = hammer_btree_cmp(&elm->base, &cursor->iprec->rec.base.base);
1014                 if (r < 0) {
1015                         error = hammer_btree_extract(cursor,
1016                                                      HAMMER_CURSOR_GET_RECORD);
1017                         cursor->flags |= HAMMER_CURSOR_ATEDISK;
1018                         break;
1019                 }
1020                 /* fall through to the memory entry */
1021         case HAMMER_CURSOR_ATEDISK:
1022                 /*
1023                  * Only the memory entry is valid
1024                  */
1025                 cursor->record = &cursor->iprec->rec;
1026                 cursor->flags |= HAMMER_CURSOR_ATEMEM;
1027                 break;
1028         case HAMMER_CURSOR_ATEMEM:
1029                 /*
1030                  * Only the disk entry is valid
1031                  */
1032                 error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_RECORD);
1033                 cursor->flags |= HAMMER_CURSOR_ATEDISK;
1034                 break;
1035         default:
1036                 /*
1037                  * Neither entry is valid
1038                  *
1039                  * XXX error not set properly
1040                  */
1041                 cursor->record = NULL;
1042                 error = ENOENT;
1043                 break;
1044         }
1045         return(error);
1046 }
1047
1048 /*
1049  * Resolve the cursor->data pointer for the current cursor position in
1050  * a merged iteration.
1051  */
1052 int
1053 hammer_ip_resolve_data(hammer_cursor_t cursor)
1054 {
1055         int error;
1056
1057         if (cursor->iprec && cursor->record == &cursor->iprec->rec) {
1058                 cursor->data = cursor->iprec->data;
1059                 error = 0;
1060         } else {
1061                 error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_DATA);
1062         }
1063         return(error);
1064 }
1065
1066 /*
1067  * Delete all records within the specified range for inode ip.
1068  *
1069  * NOTE: An unaligned range will cause new records to be added to cover
1070  * the edge cases. (XXX not implemented yet).
1071  *
1072  * NOTE: ran_end is inclusive (e.g. 0,1023 instead of 0,1024).
1073  *
1074  * NOTE: Record keys for regular file data have to be special-cased since
1075  * they indicate the end of the range (key = base + bytes).
1076  *
1077  * NOTE: The spike structure must be filled in if we return ENOSPC.
1078  */
1079 int
1080 hammer_ip_delete_range(hammer_transaction_t trans, hammer_inode_t ip,
1081                        int64_t ran_beg, int64_t ran_end,
1082                        struct hammer_cursor **spike)
1083 {
1084         struct hammer_cursor cursor;
1085         hammer_record_ondisk_t rec;
1086         hammer_base_elm_t base;
1087         int error;
1088         int64_t off;
1089
1090         hammer_init_cursor_hmp(&cursor, &ip->cache[0], ip->hmp);
1091
1092         cursor.key_beg.obj_id = ip->obj_id;
1093         cursor.key_beg.create_tid = ip->obj_asof;
1094         cursor.key_beg.delete_tid = 0;
1095         cursor.key_beg.obj_type = 0;
1096
1097         cursor.key_end = cursor.key_beg;
1098         if (ip->ino_rec.base.base.obj_type == HAMMER_OBJTYPE_DBFILE) {
1099                 cursor.key_beg.key = ran_beg;
1100                 cursor.key_beg.rec_type = HAMMER_RECTYPE_DB;
1101                 cursor.key_end.rec_type = HAMMER_RECTYPE_DB;
1102                 cursor.key_end.key = ran_end;
1103         } else {
1104                 /*
1105                  * The key in the B-Tree is (base+bytes), so the first possible
1106                  * matching key is ran_beg + 1.
1107                  */
1108                 int64_t tmp64;
1109
1110                 cursor.key_beg.key = ran_beg + 1;
1111                 cursor.key_beg.rec_type = HAMMER_RECTYPE_DATA;
1112                 cursor.key_end.rec_type = HAMMER_RECTYPE_DATA;
1113
1114                 tmp64 = ran_end + MAXPHYS + 1;  /* work around GCC-4 bug */
1115                 if (tmp64 < ran_end)
1116                         cursor.key_end.key = 0x7FFFFFFFFFFFFFFFLL;
1117                 else
1118                         cursor.key_end.key = ran_end + MAXPHYS + 1;
1119         }
1120         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE;
1121
1122         error = hammer_ip_first(&cursor, ip);
1123
1124         /*
1125          * Iterate through matching records and mark them as deleted.
1126          */
1127         while (error == 0) {
1128                 rec = cursor.record;
1129                 base = &rec->base.base;
1130
1131                 KKASSERT(base->delete_tid == 0);
1132
1133                 /*
1134                  * There may be overlap cases for regular file data.  Also
1135                  * remember the key for a regular file record is the offset
1136                  * of the last byte of the record (base + len - 1), NOT the
1137                  * base offset.
1138                  */
1139 #if 0
1140                 kprintf("delete_range rec_type %02x\n", base->rec_type);
1141 #endif
1142                 if (base->rec_type == HAMMER_RECTYPE_DATA) {
1143 #if 0
1144                         kprintf("delete_range loop key %016llx\n",
1145                                 base->key - rec->base.data_len);
1146 #endif
1147                         off = base->key - rec->base.data_len;
1148                         /*
1149                          * Check the left edge case.  We currently do not
1150                          * split existing records.
1151                          */
1152                         if (off < ran_beg) {
1153                                 panic("hammer left edge case %016llx %d\n",
1154                                         base->key, rec->base.data_len);
1155                         }
1156
1157                         /*
1158                          * Check the right edge case.  Note that the
1159                          * record can be completely out of bounds, which
1160                          * terminates the search.
1161                          *
1162                          * base->key is exclusive of the right edge while
1163                          * ran_end is inclusive of the right edge.  The
1164                          * (key - data_len) left boundary is inclusive.
1165                          *
1166                          * XXX theory-check this test at some point, are
1167                          * we missing a + 1 somewhere?  Note that ran_end
1168                          * could overflow.
1169                          */
1170                         if (base->key - 1 > ran_end) {
1171                                 if (base->key - rec->base.data_len > ran_end)
1172                                         break;
1173                                 panic("hammer right edge case\n");
1174                         }
1175                 }
1176
1177                 /*
1178                  * Mark the record and B-Tree entry as deleted.  This will
1179                  * also physically delete the B-Tree entry, record, and
1180                  * data if the retention policy dictates.  The function
1181                  * will set HAMMER_CURSOR_DELBTREE which hammer_ip_next()
1182                  * uses to perform a fixup.
1183                  */
1184                 error = hammer_ip_delete_record(&cursor, trans->tid);
1185                 if (error)
1186                         break;
1187                 error = hammer_ip_next(&cursor);
1188         }
1189         hammer_done_cursor(&cursor);
1190         if (error == ENOENT)
1191                 error = 0;
1192         return(error);
1193 }
1194
1195 /*
1196  * Delete all records associated with an inode except the inode record
1197  * itself.
1198  */
1199 int
1200 hammer_ip_delete_range_all(hammer_transaction_t trans, hammer_inode_t ip)
1201 {
1202         struct hammer_cursor cursor;
1203         hammer_record_ondisk_t rec;
1204         hammer_base_elm_t base;
1205         int error;
1206
1207         hammer_init_cursor_hmp(&cursor, &ip->cache[0], ip->hmp);
1208
1209         cursor.key_beg.obj_id = ip->obj_id;
1210         cursor.key_beg.create_tid = ip->obj_asof;
1211         cursor.key_beg.delete_tid = 0;
1212         cursor.key_beg.obj_type = 0;
1213         cursor.key_beg.rec_type = HAMMER_RECTYPE_INODE + 1;
1214         cursor.key_beg.key = HAMMER_MIN_KEY;
1215
1216         cursor.key_end = cursor.key_beg;
1217         cursor.key_end.rec_type = 0xFFFF;
1218         cursor.key_end.key = HAMMER_MAX_KEY;
1219
1220         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE;
1221
1222         error = hammer_ip_first(&cursor, ip);
1223
1224         /*
1225          * Iterate through matching records and mark them as deleted.
1226          */
1227         while (error == 0) {
1228                 rec = cursor.record;
1229                 base = &rec->base.base;
1230
1231                 KKASSERT(base->delete_tid == 0);
1232
1233                 /*
1234                  * Mark the record and B-Tree entry as deleted.  This will
1235                  * also physically delete the B-Tree entry, record, and
1236                  * data if the retention policy dictates.  The function
1237                  * will set HAMMER_CURSOR_DELBTREE which hammer_ip_next()
1238                  * uses to perform a fixup.
1239                  */
1240                 error = hammer_ip_delete_record(&cursor, trans->tid);
1241                 if (error)
1242                         break;
1243                 error = hammer_ip_next(&cursor);
1244         }
1245         hammer_done_cursor(&cursor);
1246         if (error == ENOENT)
1247                 error = 0;
1248         return(error);
1249 }
1250
1251 /*
1252  * Delete the record at the current cursor
1253  */
1254 int
1255 hammer_ip_delete_record(hammer_cursor_t cursor, hammer_tid_t tid)
1256 {
1257         hammer_btree_elm_t elm;
1258         hammer_mount_t hmp;
1259         int error;
1260
1261         /*
1262          * In-memory (unsynchronized) records can simply be freed.
1263          */
1264         if (cursor->record == &cursor->iprec->rec) {
1265                 cursor->iprec->flags |= HAMMER_RECF_DELETED;
1266                 return(0);
1267         }
1268
1269         /*
1270          * On-disk records are marked as deleted by updating their delete_tid.
1271          */
1272         error = hammer_btree_extract(cursor, HAMMER_CURSOR_GET_RECORD);
1273         elm = NULL;
1274         hmp = cursor->node->cluster->volume->hmp;
1275
1276         if (error == 0) {
1277                 hammer_modify_buffer(cursor->record_buffer);
1278                 cursor->record->base.base.delete_tid = tid;
1279
1280                 hammer_modify_node(cursor->node);
1281                 elm = &cursor->node->ondisk->elms[cursor->index];
1282                 elm->leaf.base.delete_tid = tid;
1283                 hammer_update_syncid(cursor->record_buffer->cluster, tid);
1284         }
1285
1286         /*
1287          * If we were mounted with the nohistory option, we physically
1288          * delete the record.
1289          */
1290         if (error == 0 && (hmp->hflags & HMNT_NOHISTORY)) {
1291                 int32_t rec_offset;
1292                 int32_t data_offset;
1293                 int32_t data_len;
1294                 hammer_cluster_t cluster;
1295
1296                 rec_offset = elm->leaf.rec_offset;
1297                 data_offset = elm->leaf.data_offset;
1298                 data_len = elm->leaf.data_len;
1299 #if 0
1300                 kprintf("hammer_ip_delete_record: %08x %08x/%d\n",
1301                         rec_offset, data_offset, data_len);
1302 #endif
1303                 cluster = cursor->node->cluster;
1304                 hammer_ref_cluster(cluster);
1305
1306                 error = hammer_btree_delete(cursor);
1307                 if (error == 0) {
1308                         /*
1309                          * This forces a fixup for the iteration because
1310                          * the cursor is now either sitting at the 'next'
1311                          * element or sitting at the end of a leaf.
1312                          */
1313                         if ((cursor->flags & HAMMER_CURSOR_DISKEOF) == 0) {
1314                                 cursor->flags |= HAMMER_CURSOR_DELBTREE;
1315                                 cursor->flags &= ~HAMMER_CURSOR_ATEDISK;
1316                         }
1317                         hammer_free_record(cluster, rec_offset);
1318                         if (data_offset && (data_offset - rec_offset < 0 ||
1319                             data_offset - rec_offset >= HAMMER_RECORD_SIZE)) {
1320                                 hammer_free_data(cluster, data_offset,data_len);
1321                         }
1322                 }
1323                 hammer_rel_cluster(cluster, 0);
1324                 if (error) {
1325                         panic("hammer_ip_delete_record: unable to physically delete the record!\n");
1326                         error = 0;
1327                 }
1328         }
1329         return(error);
1330 }
1331
1332 /*
1333  * Determine whether a directory is empty or not.  Returns 0 if the directory
1334  * is empty, ENOTEMPTY if it isn't, plus other possible errors.
1335  */
1336 int
1337 hammer_ip_check_directory_empty(hammer_transaction_t trans, hammer_inode_t ip)
1338 {
1339         struct hammer_cursor cursor;
1340         int error;
1341
1342         hammer_init_cursor_hmp(&cursor, &ip->cache[0], ip->hmp);
1343
1344         cursor.key_beg.obj_id = ip->obj_id;
1345         cursor.key_beg.create_tid = ip->obj_asof;
1346         cursor.key_beg.delete_tid = 0;
1347         cursor.key_beg.obj_type = 0;
1348         cursor.key_beg.rec_type = HAMMER_RECTYPE_INODE + 1;
1349         cursor.key_beg.key = HAMMER_MIN_KEY;
1350
1351         cursor.key_end = cursor.key_beg;
1352         cursor.key_end.rec_type = 0xFFFF;
1353         cursor.key_end.key = HAMMER_MAX_KEY;
1354
1355         cursor.flags |= HAMMER_CURSOR_END_INCLUSIVE;
1356
1357         error = hammer_ip_first(&cursor, ip);
1358         if (error == ENOENT)
1359                 error = 0;
1360         else if (error == 0)
1361                 error = ENOTEMPTY;
1362         hammer_done_cursor(&cursor);
1363         return(error);
1364 }
1365