sys/vfs/hammer/hammer_ioctl.c

   1 /*
   2  * Copyright (c) 2008 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_ioctl.c,v 1.32 2008/11/13 02:23:29 dillon Exp $
  35  */
  36
  37 #include "hammer.h"
  38
  39 static int hammer_ioc_gethistory(hammer_transaction_t trans, hammer_inode_t ip,
  40                                 struct hammer_ioc_history *hist);
  41 static int hammer_ioc_synctid(hammer_transaction_t trans, hammer_inode_t ip,
  42                                 struct hammer_ioc_synctid *std);
  43 static int hammer_ioc_get_version(hammer_transaction_t trans,
  44                                 hammer_inode_t ip,
  45                                 struct hammer_ioc_version *ver);
  46 static int hammer_ioc_set_version(hammer_transaction_t trans,
  47                                 hammer_inode_t ip,
  48                                 struct hammer_ioc_version *ver);
  49 static int hammer_ioc_get_info(hammer_transaction_t trans,
  50                                 struct hammer_ioc_info *info);
  51 static int hammer_ioc_add_snapshot(hammer_transaction_t trans, hammer_inode_t ip,
  52                                 struct hammer_ioc_snapshot *snap);
  53 static int hammer_ioc_del_snapshot(hammer_transaction_t trans, hammer_inode_t ip,
  54                                 struct hammer_ioc_snapshot *snap);
  55 static int hammer_ioc_get_snapshot(hammer_transaction_t trans, hammer_inode_t ip,
  56                                 struct hammer_ioc_snapshot *snap);
  57 static int hammer_ioc_get_config(hammer_transaction_t trans, hammer_inode_t ip,
  58                                 struct hammer_ioc_config *snap);
  59 static int hammer_ioc_set_config(hammer_transaction_t trans, hammer_inode_t ip,
  60                                 struct hammer_ioc_config *snap);
  61 static int hammer_ioc_get_data(hammer_transaction_t trans, hammer_inode_t ip,
  62                                 struct hammer_ioc_data *data);
  63
  64 int
  65 hammer_ioctl(hammer_inode_t ip, u_long com, caddr_t data, int fflag,
  66              struct ucred *cred)
  67 {
  68         struct hammer_transaction trans;
  69         int error;
  70
  71         error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
  72
  73         hammer_start_transaction(&trans, ip->hmp);
  74
  75         switch(com) {
  76         case HAMMERIOC_PRUNE:
  77                 if (error == 0) {
  78                         error = hammer_ioc_prune(&trans, ip,
  79                                         (struct hammer_ioc_prune *)data);
  80                 }
  81                 break;
  82         case HAMMERIOC_GETHISTORY:
  83                 error = hammer_ioc_gethistory(&trans, ip,
  84                                         (struct hammer_ioc_history *)data);
  85                 break;
  86         case HAMMERIOC_REBLOCK:
  87                 if (error == 0) {
  88                         error = hammer_ioc_reblock(&trans, ip,
  89                                         (struct hammer_ioc_reblock *)data);
  90                 }
  91                 break;
  92         case HAMMERIOC_REBALANCE:
  93                 /*
  94                  * Rebalancing needs to lock a lot of B-Tree nodes.  The
  95                  * children and children's children.  Systems with very
  96                  * little memory will not be able to do it.
  97                  */
  98                 if (error == 0 && nbuf < HAMMER_REBALANCE_MIN_BUFS) {
  99                         kprintf("hammer: System has insufficient buffers "
 100                                 "to rebalance the tree.  nbuf < %d\n",
 101                                 HAMMER_REBALANCE_MIN_BUFS);
 102                         error = ENOSPC;
 103                 }
 104                 if (error == 0) {
 105                         error = hammer_ioc_rebalance(&trans, ip,
 106                                         (struct hammer_ioc_rebalance *)data);
 107                 }
 108                 break;
 109         case HAMMERIOC_SYNCTID:
 110                 error = hammer_ioc_synctid(&trans, ip,
 111                                         (struct hammer_ioc_synctid *)data);
 112                 break;
 113         case HAMMERIOC_GET_PSEUDOFS:
 114                 error = hammer_ioc_get_pseudofs(&trans, ip,
 115                                     (struct hammer_ioc_pseudofs_rw *)data);
 116                 break;
 117         case HAMMERIOC_SET_PSEUDOFS:
 118                 if (error == 0) {
 119                         error = hammer_ioc_set_pseudofs(&trans, ip, cred,
 120                                     (struct hammer_ioc_pseudofs_rw *)data);
 121                 }
 122                 break;
 123         case HAMMERIOC_UPG_PSEUDOFS:
 124                 if (error == 0) {
 125                         error = hammer_ioc_upgrade_pseudofs(&trans, ip,
 126                                     (struct hammer_ioc_pseudofs_rw *)data);
 127                 }
 128                 break;
 129         case HAMMERIOC_DGD_PSEUDOFS:
 130                 if (error == 0) {
 131                         error = hammer_ioc_downgrade_pseudofs(&trans, ip,
 132                                     (struct hammer_ioc_pseudofs_rw *)data);
 133                 }
 134                 break;
 135         case HAMMERIOC_RMR_PSEUDOFS:
 136                 if (error == 0) {
 137                         error = hammer_ioc_destroy_pseudofs(&trans, ip,
 138                                     (struct hammer_ioc_pseudofs_rw *)data);
 139                 }
 140                 break;
 141         case HAMMERIOC_WAI_PSEUDOFS:
 142                 if (error == 0) {
 143                         error = hammer_ioc_wait_pseudofs(&trans, ip,
 144                                     (struct hammer_ioc_pseudofs_rw *)data);
 145                 }
 146                 break;
 147         case HAMMERIOC_MIRROR_READ:
 148                 if (error == 0) {
 149                         error = hammer_ioc_mirror_read(&trans, ip,
 150                                     (struct hammer_ioc_mirror_rw *)data);
 151                 }
 152                 break;
 153         case HAMMERIOC_MIRROR_WRITE:
 154                 if (error == 0) {
 155                         error = hammer_ioc_mirror_write(&trans, ip,
 156                                     (struct hammer_ioc_mirror_rw *)data);
 157                 }
 158                 break;
 159         case HAMMERIOC_GET_VERSION:
 160                 error = hammer_ioc_get_version(&trans, ip,
 161                                     (struct hammer_ioc_version *)data);
 162                 break;
 163         case HAMMERIOC_GET_INFO:
 164                 error = hammer_ioc_get_info(&trans,
 165                                     (struct hammer_ioc_info *)data);
 166                 break;
 167         case HAMMERIOC_SET_VERSION:
 168                 if (error == 0) {
 169                         error = hammer_ioc_set_version(&trans, ip,
 170                                             (struct hammer_ioc_version *)data);
 171                 }
 172                 break;
 173         case HAMMERIOC_ADD_VOLUME:
 174                 if (error == 0) {
 175                         error = priv_check_cred(cred, PRIV_HAMMER_VOLUME, 0);
 176                         if (error == 0)
 177                                 error = hammer_ioc_volume_add(&trans, ip,
 178                                             (struct hammer_ioc_volume *)data);
 179                 }
 180                 break;
 181         case HAMMERIOC_DEL_VOLUME:
 182                 if (error == 0) {
 183                         error = priv_check_cred(cred, PRIV_HAMMER_VOLUME, 0);
 184                         if (error == 0)
 185                                 error = hammer_ioc_volume_del(&trans, ip,
 186                                             (struct hammer_ioc_volume *)data);
 187                 }
 188                 break;
 189         case HAMMERIOC_LIST_VOLUMES:
 190                 error = hammer_ioc_volume_list(&trans, ip,
 191                     (struct hammer_ioc_volume_list *)data);
 192                 break;
 193         case HAMMERIOC_ADD_SNAPSHOT:
 194                 if (error == 0) {
 195                         error = hammer_ioc_add_snapshot(
 196                                         &trans, ip, (struct hammer_ioc_snapshot *)data);
 197                 }
 198                 break;
 199         case HAMMERIOC_DEL_SNAPSHOT:
 200                 if (error == 0) {
 201                         error = hammer_ioc_del_snapshot(
 202                                         &trans, ip, (struct hammer_ioc_snapshot *)data);
 203                 }
 204                 break;
 205         case HAMMERIOC_GET_SNAPSHOT:
 206                 error = hammer_ioc_get_snapshot(
 207                                         &trans, ip, (struct hammer_ioc_snapshot *)data);
 208                 break;
 209         case HAMMERIOC_GET_CONFIG:
 210                 error = hammer_ioc_get_config(
 211                                         &trans, ip, (struct hammer_ioc_config *)data);
 212                 break;
 213         case HAMMERIOC_SET_CONFIG:
 214                 if (error == 0) {
 215                         error = hammer_ioc_set_config(
 216                                         &trans, ip, (struct hammer_ioc_config *)data);
 217                 }
 218                 break;
 219         case HAMMERIOC_DEDUP:
 220                 if (error == 0) {
 221                         error = hammer_ioc_dedup(
 222                                         &trans, ip, (struct hammer_ioc_dedup *)data);
 223                 }
 224                 break;
 225         case HAMMERIOC_GET_DATA:
 226                 if (error == 0) {
 227                         error = hammer_ioc_get_data(
 228                                         &trans, ip, (struct hammer_ioc_data *)data);
 229                 }
 230                 break;
 231         case HAMMERIOC_PFS_ITERATE:
 232                 error = hammer_ioc_iterate_pseudofs(
 233                                 &trans, ip, (struct hammer_ioc_pfs_iterate *)data);
 234                 break;
 235         default:
 236                 error = EOPNOTSUPP;
 237                 break;
 238         }
 239         hammer_done_transaction(&trans);
 240         return (error);
 241 }
 242
 243 /*
 244  * Iterate through an object's inode or an object's records and record
 245  * modification TIDs.
 246  */
 247 static void add_history(hammer_inode_t ip, struct hammer_ioc_history *hist,
 248                         hammer_btree_elm_t elm);
 249
 250 static
 251 int
 252 hammer_ioc_gethistory(hammer_transaction_t trans, hammer_inode_t ip,
 253                       struct hammer_ioc_history *hist)
 254 {
 255         struct hammer_cursor cursor;
 256         hammer_btree_elm_t elm;
 257         int error;
 258
 259         /*
 260          * Validate the structure and initialize for return.
 261          */
 262         if (hist->beg_tid > hist->end_tid)
 263                 return(EINVAL);
 264         if (hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) {
 265                 if (hist->key > hist->nxt_key)
 266                         return(EINVAL);
 267         }
 268
 269         hist->obj_id = ip->obj_id;
 270         hist->count = 0;
 271         hist->nxt_tid = hist->end_tid;
 272         hist->head.flags &= ~HAMMER_IOC_HISTORY_NEXT_TID;
 273         hist->head.flags &= ~HAMMER_IOC_HISTORY_NEXT_KEY;
 274         hist->head.flags &= ~HAMMER_IOC_HISTORY_EOF;
 275         hist->head.flags &= ~HAMMER_IOC_HISTORY_UNSYNCED;
 276         if ((ip->flags & HAMMER_INODE_MODMASK) &
 277             ~(HAMMER_INODE_ATIME | HAMMER_INODE_MTIME)) {
 278                 hist->head.flags |= HAMMER_IOC_HISTORY_UNSYNCED;
 279         }
 280
 281         /*
 282          * Setup the cursor.  We can't handle undeletable records
 283          * (create_tid of 0) at the moment.  A create_tid of 0 has
 284          * a special meaning and cannot be specified in the cursor.
 285          */
 286         error = hammer_init_cursor(trans, &cursor, &ip->cache[0], NULL);
 287         if (error) {
 288                 hammer_done_cursor(&cursor);
 289                 return(error);
 290         }
 291
 292         cursor.key_beg.obj_id = hist->obj_id;
 293         cursor.key_beg.create_tid = hist->beg_tid;
 294         cursor.key_beg.delete_tid = 0;
 295         cursor.key_beg.obj_type = 0;
 296         if (cursor.key_beg.create_tid == HAMMER_MIN_TID)
 297                 cursor.key_beg.create_tid = 1;
 298
 299         cursor.key_end.obj_id = hist->obj_id;
 300         cursor.key_end.create_tid = hist->end_tid;
 301         cursor.key_end.delete_tid = 0;
 302         cursor.key_end.obj_type = 0;
 303
 304         cursor.flags |= HAMMER_CURSOR_END_EXCLUSIVE;
 305
 306         if (hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) {
 307                 /*
 308                  * key-range within the file.  For a regular file the
 309                  * on-disk key represents BASE+LEN, not BASE, so the
 310                  * first possible record containing the offset 'key'
 311                  * has an on-disk key of (key + 1).
 312                  */
 313                 cursor.key_beg.key = hist->key;
 314                 cursor.key_end.key = HAMMER_MAX_KEY;
 315                 cursor.key_beg.localization = ip->obj_localization +
 316                                               HAMMER_LOCALIZE_MISC;
 317                 cursor.key_end.localization = ip->obj_localization +
 318                                               HAMMER_LOCALIZE_MISC;
 319
 320                 switch(ip->ino_data.obj_type) {
 321                 case HAMMER_OBJTYPE_REGFILE:
 322                         ++cursor.key_beg.key;
 323                         cursor.key_beg.rec_type = HAMMER_RECTYPE_DATA;
 324                         break;
 325                 case HAMMER_OBJTYPE_DIRECTORY:
 326                         cursor.key_beg.rec_type = HAMMER_RECTYPE_DIRENTRY;
 327                         cursor.key_beg.localization = ip->obj_localization +
 328                                                 hammer_dir_localization(ip);
 329                         cursor.key_end.localization = ip->obj_localization +
 330                                                 hammer_dir_localization(ip);
 331                         break;
 332                 case HAMMER_OBJTYPE_DBFILE:
 333                         cursor.key_beg.rec_type = HAMMER_RECTYPE_DB;
 334                         break;
 335                 default:
 336                         error = EINVAL;
 337                         break;
 338                 }
 339                 cursor.key_end.rec_type = cursor.key_beg.rec_type;
 340         } else {
 341                 /*
 342                  * The inode itself.
 343                  */
 344                 cursor.key_beg.key = 0;
 345                 cursor.key_end.key = 0;
 346                 cursor.key_beg.rec_type = HAMMER_RECTYPE_INODE;
 347                 cursor.key_end.rec_type = HAMMER_RECTYPE_INODE;
 348                 cursor.key_beg.localization = ip->obj_localization +
 349                                               HAMMER_LOCALIZE_INODE;
 350                 cursor.key_end.localization = ip->obj_localization +
 351                                               HAMMER_LOCALIZE_INODE;
 352         }
 353
 354         error = hammer_btree_first(&cursor);
 355         while (error == 0) {
 356                 elm = &cursor.node->ondisk->elms[cursor.index];
 357
 358                 add_history(ip, hist, elm);
 359                 if (hist->head.flags & (HAMMER_IOC_HISTORY_NEXT_TID |
 360                                         HAMMER_IOC_HISTORY_NEXT_KEY |
 361                                         HAMMER_IOC_HISTORY_EOF)) {
 362                         break;
 363                 }
 364                 error = hammer_btree_iterate(&cursor);
 365         }
 366         if (error == ENOENT) {
 367                 hist->head.flags |= HAMMER_IOC_HISTORY_EOF;
 368                 error = 0;
 369         }
 370         hammer_done_cursor(&cursor);
 371         return(error);
 372 }
 373
 374 /*
 375  * Add the scanned element to the ioctl return structure.  Some special
 376  * casing is required for regular files to accomodate how data ranges are
 377  * stored on-disk.
 378  */
 379 static void
 380 add_history(hammer_inode_t ip, struct hammer_ioc_history *hist,
 381             hammer_btree_elm_t elm)
 382 {
 383         int i;
 384
 385         if (elm->base.btype != HAMMER_BTREE_TYPE_RECORD)
 386                 return;
 387         if ((hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) &&
 388             ip->ino_data.obj_type == HAMMER_OBJTYPE_REGFILE) {
 389                 /*
 390                  * Adjust nxt_key
 391                  */
 392                 if (hist->nxt_key > elm->leaf.base.key - elm->leaf.data_len &&
 393                     hist->key < elm->leaf.base.key - elm->leaf.data_len) {
 394                         hist->nxt_key = elm->leaf.base.key - elm->leaf.data_len;
 395                 }
 396                 if (hist->nxt_key > elm->leaf.base.key)
 397                         hist->nxt_key = elm->leaf.base.key;
 398
 399                 /*
 400                  * Record is beyond MAXPHYS, there won't be any more records
 401                  * in the iteration covering the requested offset (key).
 402                  */
 403                 if (elm->leaf.base.key >= MAXPHYS &&
 404                     elm->leaf.base.key - MAXPHYS > hist->key) {
 405                         hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_KEY;
 406                 }
 407
 408                 /*
 409                  * Data-range of record does not cover the key.
 410                  */
 411                 if (elm->leaf.base.key - elm->leaf.data_len > hist->key)
 412                         return;
 413
 414         } else if (hist->head.flags & HAMMER_IOC_HISTORY_ATKEY) {
 415                 /*
 416                  * Adjust nxt_key
 417                  */
 418                 if (hist->nxt_key > elm->leaf.base.key &&
 419                     hist->key < elm->leaf.base.key) {
 420                         hist->nxt_key = elm->leaf.base.key;
 421                 }
 422
 423                 /*
 424                  * Record is beyond the requested key.
 425                  */
 426                 if (elm->leaf.base.key > hist->key)
 427                         hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_KEY;
 428         }
 429
 430         /*
 431          * Add create_tid if it is in-bounds.
 432          */
 433         i = hist->count;
 434         if ((i == 0 ||
 435              elm->leaf.base.create_tid != hist->hist_ary[i - 1].tid) &&
 436             elm->leaf.base.create_tid >= hist->beg_tid &&
 437             elm->leaf.base.create_tid < hist->end_tid) {
 438                 if (hist->count == HAMMER_MAX_HISTORY_ELMS) {
 439                         hist->nxt_tid = elm->leaf.base.create_tid;
 440                         hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_TID;
 441                         return;
 442                 }
 443                 hist->hist_ary[i].tid = elm->leaf.base.create_tid;
 444                 hist->hist_ary[i].time32 = elm->leaf.create_ts;
 445                 ++hist->count;
 446         }
 447
 448         /*
 449          * Add delete_tid if it is in-bounds.  Note that different portions
 450          * of the history may have overlapping data ranges with different
 451          * delete_tid's.  If this case occurs the delete_tid may match the
 452          * create_tid of a following record.  XXX
 453          *
 454          *      [        ]
 455          *            [     ]
 456          */
 457         i = hist->count;
 458         if (elm->leaf.base.delete_tid &&
 459             elm->leaf.base.delete_tid >= hist->beg_tid &&
 460             elm->leaf.base.delete_tid < hist->end_tid) {
 461                 if (i == HAMMER_MAX_HISTORY_ELMS) {
 462                         hist->nxt_tid = elm->leaf.base.delete_tid;
 463                         hist->head.flags |= HAMMER_IOC_HISTORY_NEXT_TID;
 464                         return;
 465                 }
 466                 hist->hist_ary[i].tid = elm->leaf.base.delete_tid;
 467                 hist->hist_ary[i].time32 = elm->leaf.delete_ts;
 468                 ++hist->count;
 469         }
 470 }
 471
 472 /*
 473  * Acquire synchronization TID
 474  */
 475 static
 476 int
 477 hammer_ioc_synctid(hammer_transaction_t trans, hammer_inode_t ip,
 478                    struct hammer_ioc_synctid *std)
 479 {
 480         hammer_mount_t hmp = ip->hmp;
 481         int error = 0;
 482
 483         switch(std->op) {
 484         case HAMMER_SYNCTID_NONE:
 485                 std->tid = hmp->flusher.tid;    /* inaccurate */
 486                 break;
 487         case HAMMER_SYNCTID_ASYNC:
 488                 hammer_queue_inodes_flusher(hmp, MNT_NOWAIT);
 489                 hammer_flusher_async(hmp, NULL);
 490                 std->tid = hmp->flusher.tid;    /* inaccurate */
 491                 break;
 492         case HAMMER_SYNCTID_SYNC1:
 493                 hammer_queue_inodes_flusher(hmp, MNT_WAIT);
 494                 hammer_flusher_sync(hmp);
 495                 std->tid = hmp->flusher.tid;
 496                 break;
 497         case HAMMER_SYNCTID_SYNC2:
 498                 hammer_queue_inodes_flusher(hmp, MNT_WAIT);
 499                 hammer_flusher_sync(hmp);
 500                 std->tid = hmp->flusher.tid;
 501                 hammer_flusher_sync(hmp);
 502                 break;
 503         default:
 504                 error = EOPNOTSUPP;
 505                 break;
 506         }
 507         return(error);
 508 }
 509
 510 /*
 511  * Retrieve version info.
 512  *
 513  * Load min_version, wip_version, and max_versino.  If cur_version is passed
 514  * as 0 then load the current version into cur_version.  Load the description
 515  * for cur_version into the description array.
 516  *
 517  * Returns 0 on success, EINVAL if cur_version is non-zero and set to an
 518  * unsupported value.
 519  */
 520 static
 521 int
 522 hammer_ioc_get_version(hammer_transaction_t trans, hammer_inode_t ip,
 523                    struct hammer_ioc_version *ver)
 524 {
 525         int error = 0;
 526
 527         ver->min_version = HAMMER_VOL_VERSION_MIN;
 528         ver->wip_version = HAMMER_VOL_VERSION_WIP;
 529         ver->max_version = HAMMER_VOL_VERSION_MAX;
 530         if (ver->cur_version == 0)
 531                 ver->cur_version = trans->hmp->version;
 532         switch(ver->cur_version) {
 533         case 1:
 534                 ksnprintf(ver->description, sizeof(ver->description),
 535                          "First HAMMER release (DragonFly 2.0+)");
 536                 break;
 537         case 2:
 538                 ksnprintf(ver->description, sizeof(ver->description),
 539                          "New directory entry layout (DragonFly 2.3+)");
 540                 break;
 541         case 3:
 542                 ksnprintf(ver->description, sizeof(ver->description),
 543                          "New snapshot management (DragonFly 2.5+)");
 544                 break;
 545         case 4:
 546                 ksnprintf(ver->description, sizeof(ver->description),
 547                          "New undo/flush, faster flush/sync (DragonFly 2.5+)");
 548                 break;
 549         case 5:
 550                 ksnprintf(ver->description, sizeof(ver->description),
 551                          "Adjustments for dedup support (DragonFly 2.9+)");
 552                 break;
 553         case 6:
 554                 ksnprintf(ver->description, sizeof(ver->description),
 555                           "Directory Hash ALG1 (tmp/rename resistance)");
 556                 break;
 557         default:
 558                 ksnprintf(ver->description, sizeof(ver->description),
 559                          "Unknown");
 560                 error = EINVAL;
 561                 break;
 562         }
 563         return(error);
 564 };
 565
 566 /*
 567  * Set version info
 568  */
 569 static
 570 int
 571 hammer_ioc_set_version(hammer_transaction_t trans, hammer_inode_t ip,
 572                    struct hammer_ioc_version *ver)
 573 {
 574         hammer_mount_t hmp = trans->hmp;
 575         struct hammer_cursor cursor;
 576         hammer_volume_t volume;
 577         int error;
 578         int over = hmp->version;
 579
 580         /*
 581          * Generally do not allow downgrades.  However, version 4 can
 582          * be downgraded to version 3.
 583          */
 584         if (ver->cur_version < hmp->version) {
 585                 if (!(ver->cur_version == 3 && hmp->version == 4))
 586                         return(EINVAL);
 587         }
 588         if (ver->cur_version == hmp->version)
 589                 return(0);
 590         if (ver->cur_version > HAMMER_VOL_VERSION_MAX)
 591                 return(EINVAL);
 592         if (hmp->ronly)
 593                 return(EROFS);
 594
 595         /*
 596          * Update the root volume header and the version cached in
 597          * the hammer_mount structure.
 598          */
 599         error = hammer_init_cursor(trans, &cursor, NULL, NULL);
 600         if (error)
 601                 goto failed;
 602         hammer_lock_ex(&hmp->flusher.finalize_lock);
 603         hammer_sync_lock_ex(trans);
 604         hmp->version = ver->cur_version;
 605
 606         /*
 607          * If upgrading from version < 4 to version >= 4 the UNDO FIFO
 608          * must be reinitialized.
 609          */
 610         if (over < HAMMER_VOL_VERSION_FOUR &&
 611             ver->cur_version >= HAMMER_VOL_VERSION_FOUR) {
 612                 kprintf("upgrade undo to version 4\n");
 613                 error = hammer_upgrade_undo_4(trans);
 614                 if (error)
 615                         goto failed;
 616         }
 617
 618         /*
 619          * Adjust the version in the volume header
 620          */
 621         volume = hammer_get_root_volume(hmp, &error);
 622         KKASSERT(error == 0);
 623         hammer_modify_volume_field(cursor.trans, volume, vol_version);
 624         volume->ondisk->vol_version = ver->cur_version;
 625         hammer_modify_volume_done(volume);
 626         hammer_rel_volume(volume, 0);
 627
 628         hammer_sync_unlock(trans);
 629         hammer_unlock(&hmp->flusher.finalize_lock);
 630 failed:
 631         ver->head.error = error;
 632         hammer_done_cursor(&cursor);
 633         return(0);
 634 }
 635
 636 /*
 637  * Get information
 638  */
 639 static
 640 int
 641 hammer_ioc_get_info(hammer_transaction_t trans, struct hammer_ioc_info *info)
 642 {
 643         struct hammer_volume_ondisk     *od = trans->hmp->rootvol->ondisk;
 644         struct hammer_mount             *hm = trans->hmp;
 645
 646         /* Fill the structure with the necessary information */
 647         _hammer_checkspace(hm, HAMMER_CHKSPC_WRITE, &info->rsvbigblocks);
 648         info->rsvbigblocks = info->rsvbigblocks >> HAMMER_BIGBLOCK_BITS;
 649         strlcpy(info->vol_name, od->vol_name, sizeof(od->vol_name));
 650
 651         info->vol_fsid = hm->fsid;
 652         info->vol_fstype = od->vol_fstype;
 653         info->version = hm->version;
 654
 655         info->inodes = od->vol0_stat_inodes;
 656         info->bigblocks = od->vol0_stat_bigblocks;
 657         info->freebigblocks = od->vol0_stat_freebigblocks;
 658         info->nvolumes = hm->nvolumes;
 659
 660         return 0;
 661 }
 662
 663 /*
 664  * Add a snapshot transction id(s) to the list of snapshots.
 665  *
 666  * NOTE: Records are created with an allocated TID.  If a flush cycle
 667  *       is in progress the record may be synced in the current flush
 668  *       cycle and the volume header will reflect the allocation of the
 669  *       TID, but the synchronization point may not catch up to the
 670  *       TID until the next flush cycle.
 671  */
 672 static
 673 int
 674 hammer_ioc_add_snapshot(hammer_transaction_t trans, hammer_inode_t ip,
 675                         struct hammer_ioc_snapshot *snap)
 676 {
 677         hammer_mount_t hmp = ip->hmp;
 678         struct hammer_btree_leaf_elm leaf;
 679         struct hammer_cursor cursor;
 680         int error;
 681
 682         /*
 683          * Validate structure
 684          */
 685         if (snap->count > HAMMER_SNAPS_PER_IOCTL)
 686                 return (EINVAL);
 687         if (snap->index >= snap->count)
 688                 return (EINVAL);
 689
 690         hammer_lock_ex(&hmp->snapshot_lock);
 691 again:
 692         /*
 693          * Look for keys starting after the previous iteration, or at
 694          * the beginning if snap->count is 0.
 695          */
 696         error = hammer_init_cursor(trans, &cursor, &ip->cache[0], NULL);
 697         if (error) {
 698                 hammer_done_cursor(&cursor);
 699                 return(error);
 700         }
 701
 702         cursor.asof = HAMMER_MAX_TID;
 703         cursor.flags |= HAMMER_CURSOR_BACKEND | HAMMER_CURSOR_ASOF;
 704
 705         bzero(&leaf, sizeof(leaf));
 706         leaf.base.obj_id = HAMMER_OBJID_ROOT;
 707         leaf.base.rec_type = HAMMER_RECTYPE_SNAPSHOT;
 708         leaf.base.create_tid = hammer_alloc_tid(hmp, 1);
 709         leaf.base.btype = HAMMER_BTREE_TYPE_RECORD;
 710         leaf.base.localization = ip->obj_localization + HAMMER_LOCALIZE_INODE;
 711         leaf.data_len = sizeof(struct hammer_snapshot_data);
 712
 713         while (snap->index < snap->count) {
 714                 leaf.base.key = (int64_t)snap->snaps[snap->index].tid;
 715                 cursor.key_beg = leaf.base;
 716                 error = hammer_btree_lookup(&cursor);
 717                 if (error == 0) {
 718                         error = EEXIST;
 719                         break;
 720                 }
 721
 722                 /*
 723                  * NOTE: Must reload key_beg after an ASOF search because
 724                  *       the create_tid may have been modified during the
 725                  *       search.
 726                  */
 727                 cursor.flags &= ~HAMMER_CURSOR_ASOF;
 728                 cursor.key_beg = leaf.base;
 729                 error = hammer_create_at_cursor(&cursor, &leaf,
 730                                                 &snap->snaps[snap->index],
 731                                                 HAMMER_CREATE_MODE_SYS);
 732                 if (error == EDEADLK) {
 733                         hammer_done_cursor(&cursor);
 734                         goto again;
 735                 }
 736                 cursor.flags |= HAMMER_CURSOR_ASOF;
 737                 if (error)
 738                         break;
 739                 ++snap->index;
 740         }
 741         snap->head.error = error;
 742         hammer_done_cursor(&cursor);
 743         hammer_unlock(&hmp->snapshot_lock);
 744         return(0);
 745 }
 746
 747 /*
 748  * Delete snapshot transaction id(s) from the list of snapshots.
 749  */
 750 static
 751 int
 752 hammer_ioc_del_snapshot(hammer_transaction_t trans, hammer_inode_t ip,
 753                         struct hammer_ioc_snapshot *snap)
 754 {
 755         hammer_mount_t hmp = ip->hmp;
 756         struct hammer_cursor cursor;
 757         int error;
 758
 759         /*
 760          * Validate structure
 761          */
 762         if (snap->count > HAMMER_SNAPS_PER_IOCTL)
 763                 return (EINVAL);
 764         if (snap->index >= snap->count)
 765                 return (EINVAL);
 766
 767         hammer_lock_ex(&hmp->snapshot_lock);
 768 again:
 769         /*
 770          * Look for keys starting after the previous iteration, or at
 771          * the beginning if snap->count is 0.
 772          */
 773         error = hammer_init_cursor(trans, &cursor, &ip->cache[0], NULL);
 774         if (error) {
 775                 hammer_done_cursor(&cursor);
 776                 return(error);
 777         }
 778
 779         cursor.key_beg.obj_id = HAMMER_OBJID_ROOT;
 780         cursor.key_beg.create_tid = 0;
 781         cursor.key_beg.delete_tid = 0;
 782         cursor.key_beg.obj_type = 0;
 783         cursor.key_beg.rec_type = HAMMER_RECTYPE_SNAPSHOT;
 784         cursor.key_beg.localization = ip->obj_localization + HAMMER_LOCALIZE_INODE;
 785         cursor.asof = HAMMER_MAX_TID;
 786         cursor.flags |= HAMMER_CURSOR_ASOF;
 787
 788         while (snap->index < snap->count) {
 789                 cursor.key_beg.key = (int64_t)snap->snaps[snap->index].tid;
 790                 error = hammer_btree_lookup(&cursor);
 791                 if (error)
 792                         break;
 793                 error = hammer_btree_extract(&cursor, HAMMER_CURSOR_GET_LEAF);
 794                 if (error)
 795                         break;
 796                 error = hammer_delete_at_cursor(&cursor, HAMMER_DELETE_DESTROY,
 797                                                 0, 0, 0, NULL);
 798                 if (error == EDEADLK) {
 799                         hammer_done_cursor(&cursor);
 800                         goto again;
 801                 }
 802                 if (error)
 803                         break;
 804                 ++snap->index;
 805         }
 806         snap->head.error = error;
 807         hammer_done_cursor(&cursor);
 808         hammer_unlock(&hmp->snapshot_lock);
 809         return(0);
 810 }
 811
 812 /*
 813  * Retrieve as many snapshot ids as possible or until the array is
 814  * full, starting after the last transction id passed in.  If count
 815  * is 0 we retrieve starting at the beginning.
 816  *
 817  * NOTE: Because the b-tree key field is signed but transaction ids
 818  *       are unsigned the returned list will be signed-sorted instead
 819  *       of unsigned sorted.  The Caller must still sort the aggregate
 820  *       results.
 821  */
 822 static
 823 int
 824 hammer_ioc_get_snapshot(hammer_transaction_t trans, hammer_inode_t ip,
 825                         struct hammer_ioc_snapshot *snap)
 826 {
 827         struct hammer_cursor cursor;
 828         int error;
 829
 830         /*
 831          * Validate structure
 832          */
 833         if (snap->index != 0)
 834                 return (EINVAL);
 835         if (snap->count > HAMMER_SNAPS_PER_IOCTL)
 836                 return (EINVAL);
 837
 838         /*
 839          * Look for keys starting after the previous iteration, or at
 840          * the beginning if snap->count is 0.
 841          */
 842         error = hammer_init_cursor(trans, &cursor, &ip->cache[0], NULL);
 843         if (error) {
 844                 hammer_done_cursor(&cursor);
 845                 return(error);
 846         }
 847
 848         cursor.key_beg.obj_id = HAMMER_OBJID_ROOT;
 849         cursor.key_beg.create_tid = 0;
 850         cursor.key_beg.delete_tid = 0;
 851         cursor.key_beg.obj_type = 0;
 852         cursor.key_beg.rec_type = HAMMER_RECTYPE_SNAPSHOT;
 853         cursor.key_beg.localization = ip->obj_localization + HAMMER_LOCALIZE_INODE;
 854         if (snap->count == 0)
 855                 cursor.key_beg.key = HAMMER_MIN_KEY;
 856         else
 857                 cursor.key_beg.key = (int64_t)snap->snaps[snap->count - 1].tid + 1;
 858
 859         cursor.key_end = cursor.key_beg;
 860         cursor.key_end.key = HAMMER_MAX_KEY;
 861         cursor.asof = HAMMER_MAX_TID;
 862         cursor.flags |= HAMMER_CURSOR_END_EXCLUSIVE | HAMMER_CURSOR_ASOF;
 863
 864         snap->count = 0;
 865
 866         error = hammer_btree_first(&cursor);
 867         while (error == 0 && snap->count < HAMMER_SNAPS_PER_IOCTL) {
 868                 error = hammer_btree_extract(&cursor, HAMMER_CURSOR_GET_LEAF);
 869                 if (error)
 870                         break;
 871                 if (cursor.leaf->base.rec_type == HAMMER_RECTYPE_SNAPSHOT) {
 872                         error = hammer_btree_extract(
 873                                              &cursor, HAMMER_CURSOR_GET_LEAF |
 874                                                       HAMMER_CURSOR_GET_DATA);
 875                         snap->snaps[snap->count] = cursor.data->snap;
 876
 877                         /*
 878                          * The snap data tid should match the key but might
 879                          * not due to a bug in the HAMMER v3 conversion code.
 880                          *
 881                          * This error will work itself out over time but we
 882                          * have to force a match or the snapshot will not
 883                          * be deletable.
 884                          */
 885                         if (cursor.data->snap.tid !=
 886                             (hammer_tid_t)cursor.leaf->base.key) {
 887                                 kprintf("HAMMER: lo=%08x snapshot key "
 888                                         "0x%016jx data mismatch 0x%016jx\n",
 889                                         cursor.key_beg.localization,
 890                                         (uintmax_t)cursor.data->snap.tid,
 891                                         cursor.leaf->base.key);
 892                                 kprintf("HAMMER: Probably left over from the "
 893                                         "original v3 conversion, hammer "
 894                                         "cleanup should get it eventually\n");
 895                                 snap->snaps[snap->count].tid =
 896                                         cursor.leaf->base.key;
 897                         }
 898                         ++snap->count;
 899                 }
 900                 error = hammer_btree_iterate(&cursor);
 901         }
 902
 903         if (error == ENOENT) {
 904                 snap->head.flags |= HAMMER_IOC_SNAPSHOT_EOF;
 905                 error = 0;
 906         }
 907         snap->head.error = error;
 908         hammer_done_cursor(&cursor);
 909         return(0);
 910 }
 911
 912 /*
 913  * Retrieve the PFS hammer cleanup utility config record.  This is
 914  * different (newer than) the PFS config.
 915  */
 916 static
 917 int
 918 hammer_ioc_get_config(hammer_transaction_t trans, hammer_inode_t ip,
 919                         struct hammer_ioc_config *config)
 920 {
 921         struct hammer_cursor cursor;
 922         int error;
 923
 924         error = hammer_init_cursor(trans, &cursor, &ip->cache[0], NULL);
 925         if (error) {
 926                 hammer_done_cursor(&cursor);
 927                 return(error);
 928         }
 929
 930         cursor.key_beg.obj_id = HAMMER_OBJID_ROOT;
 931         cursor.key_beg.create_tid = 0;
 932         cursor.key_beg.delete_tid = 0;
 933         cursor.key_beg.obj_type = 0;
 934         cursor.key_beg.rec_type = HAMMER_RECTYPE_CONFIG;
 935         cursor.key_beg.localization = ip->obj_localization + HAMMER_LOCALIZE_INODE;
 936         cursor.key_beg.key = 0;         /* config space page 0 */
 937
 938         cursor.asof = HAMMER_MAX_TID;
 939         cursor.flags |= HAMMER_CURSOR_ASOF;
 940
 941         error = hammer_btree_lookup(&cursor);
 942         if (error == 0) {
 943                 error = hammer_btree_extract(&cursor, HAMMER_CURSOR_GET_LEAF |
 944                                                       HAMMER_CURSOR_GET_DATA);
 945                 if (error == 0)
 946                         config->config = cursor.data->config;
 947         }
 948         /* error can be ENOENT */
 949         config->head.error = error;
 950         hammer_done_cursor(&cursor);
 951         return(0);
 952 }
 953
 954 /*
 955  * Retrieve the PFS hammer cleanup utility config record.  This is
 956  * different (newer than) the PFS config.
 957  *
 958  * This is kinda a hack.
 959  */
 960 static
 961 int
 962 hammer_ioc_set_config(hammer_transaction_t trans, hammer_inode_t ip,
 963                         struct hammer_ioc_config *config)
 964 {
 965         struct hammer_btree_leaf_elm leaf;
 966         struct hammer_cursor cursor;
 967         hammer_mount_t hmp = ip->hmp;
 968         int error;
 969
 970 again:
 971         error = hammer_init_cursor(trans, &cursor, &ip->cache[0], NULL);
 972         if (error) {
 973                 hammer_done_cursor(&cursor);
 974                 return(error);
 975         }
 976
 977         bzero(&leaf, sizeof(leaf));
 978         leaf.base.obj_id = HAMMER_OBJID_ROOT;
 979         leaf.base.rec_type = HAMMER_RECTYPE_CONFIG;
 980         leaf.base.create_tid = hammer_alloc_tid(hmp, 1);
 981         leaf.base.btype = HAMMER_BTREE_TYPE_RECORD;
 982         leaf.base.localization = ip->obj_localization + HAMMER_LOCALIZE_INODE;
 983         leaf.base.key = 0;      /* page 0 */
 984         leaf.data_len = sizeof(struct hammer_config_data);
 985
 986         cursor.key_beg = leaf.base;
 987
 988         cursor.asof = HAMMER_MAX_TID;
 989         cursor.flags |= HAMMER_CURSOR_BACKEND | HAMMER_CURSOR_ASOF;
 990
 991         error = hammer_btree_lookup(&cursor);
 992         if (error == 0) {
 993                 error = hammer_btree_extract(&cursor, HAMMER_CURSOR_GET_LEAF |
 994                                                       HAMMER_CURSOR_GET_DATA);
 995                 error = hammer_delete_at_cursor(&cursor, HAMMER_DELETE_DESTROY,
 996                                                 0, 0, 0, NULL);
 997                 if (error == EDEADLK) {
 998                         hammer_done_cursor(&cursor);
 999                         goto again;
1000                 }
1001         }
1002         if (error == ENOENT)
1003                 error = 0;
1004         if (error == 0) {
1005                 /*
1006                  * NOTE: Must reload key_beg after an ASOF search because
1007                  *       the create_tid may have been modified during the
1008                  *       search.
1009                  */
1010                 cursor.flags &= ~HAMMER_CURSOR_ASOF;
1011                 cursor.key_beg = leaf.base;
1012                 error = hammer_create_at_cursor(&cursor, &leaf,
1013                                                 &config->config,
1014                                                 HAMMER_CREATE_MODE_SYS);
1015                 if (error == EDEADLK) {
1016                         hammer_done_cursor(&cursor);
1017                         goto again;
1018                 }
1019         }
1020         config->head.error = error;
1021         hammer_done_cursor(&cursor);
1022         return(0);
1023 }
1024
1025 static
1026 int
1027 hammer_ioc_get_data(hammer_transaction_t trans, hammer_inode_t ip,
1028                         struct hammer_ioc_data *data)
1029 {
1030         struct hammer_cursor cursor;
1031         int bytes;
1032         int error;
1033
1034         /* XXX cached inode ? */
1035         error = hammer_init_cursor(trans, &cursor, NULL, NULL);
1036         if (error)
1037                 goto failed;
1038
1039         cursor.key_beg = data->elm;
1040         cursor.flags |= HAMMER_CURSOR_BACKEND;
1041
1042         error = hammer_btree_lookup(&cursor);
1043         if (error == 0) {
1044                 error = hammer_btree_extract(&cursor, HAMMER_CURSOR_GET_LEAF |
1045                                                       HAMMER_CURSOR_GET_DATA);
1046                 if (error == 0) {
1047                         data->leaf = *cursor.leaf;
1048                         bytes = cursor.leaf->data_len;
1049                         if (bytes > data->size)
1050                                 bytes = data->size;
1051                         error = copyout(cursor.data, data->ubuf, bytes);
1052                 }
1053         }
1054
1055 failed:
1056         hammer_done_cursor(&cursor);
1057         return (error);
1058 }