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