sys/vfs/hammer2/hammer2_ioctl.c

   1 /*
   2  * Copyright (c) 2011-2020 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@dragonflybsd.org>
   6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 /*
  36  * Ioctl Functions.
  37  *
  38  * WARNING! The ioctl functions which manipulate the connection state need
  39  *          to be able to run without deadlock on the volume's chain lock.
  40  *          Most of these functions use a separate lock.
  41  */
  42
  43 #include "hammer2.h"
  44
  45 #include <sys/kern_syscall.h>
  46
  47 static int hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data);
  48 static int hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data);
  49 static int hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data);
  50 static int hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data);
  51 static int hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data);
  52 static int hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data);
  53 static int hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data);
  54 static int hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data);
  55 static int hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data);
  56 static int hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data);
  57 static int hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data);
  58 static int hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data);
  59 static int hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data);
  60 static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data);
  61 static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data);
  62 static int hammer2_ioctl_debug_dump(hammer2_inode_t *ip, u_int flags);
  63 static int hammer2_ioctl_emerg_mode(hammer2_inode_t *ip, u_int mode);
  64 static int hammer2_ioctl_growfs(hammer2_inode_t *ip, void *data,
  65                         struct ucred *cred);
  66 //static int hammer2_ioctl_inode_comp_set(hammer2_inode_t *ip, void *data);
  67 //static int hammer2_ioctl_inode_comp_rec_set(hammer2_inode_t *ip, void *data);
  68 //static int hammer2_ioctl_inode_comp_rec_set2(hammer2_inode_t *ip, void *data);
  69 static int hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data);
  70 static int hammer2_ioctl_destroy(hammer2_inode_t *ip, void *data);
  71 static int hammer2_ioctl_volume_list(hammer2_inode_t *ip, void *data);
  72
  73 int
  74 hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
  75               struct ucred *cred)
  76 {
  77         int error;
  78
  79         /*
  80          * Standard root cred checks, will be selectively ignored below
  81          * for ioctls that do not require root creds.
  82          */
  83         error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
  84
  85         switch(com) {
  86         case HAMMER2IOC_VERSION_GET:
  87                 error = hammer2_ioctl_version_get(ip, data);
  88                 break;
  89         case HAMMER2IOC_RECLUSTER:
  90                 if (error == 0)
  91                         error = hammer2_ioctl_recluster(ip, data);
  92                 break;
  93         case HAMMER2IOC_REMOTE_SCAN:
  94                 if (error == 0)
  95                         error = hammer2_ioctl_remote_scan(ip, data);
  96                 break;
  97         case HAMMER2IOC_REMOTE_ADD:
  98                 if (error == 0)
  99                         error = hammer2_ioctl_remote_add(ip, data);
 100                 break;
 101         case HAMMER2IOC_REMOTE_DEL:
 102                 if (error == 0)
 103                         error = hammer2_ioctl_remote_del(ip, data);
 104                 break;
 105         case HAMMER2IOC_REMOTE_REP:
 106                 if (error == 0)
 107                         error = hammer2_ioctl_remote_rep(ip, data);
 108                 break;
 109         case HAMMER2IOC_SOCKET_GET:
 110                 if (error == 0)
 111                         error = hammer2_ioctl_socket_get(ip, data);
 112                 break;
 113         case HAMMER2IOC_SOCKET_SET:
 114                 if (error == 0)
 115                         error = hammer2_ioctl_socket_set(ip, data);
 116                 break;
 117         case HAMMER2IOC_PFS_GET:
 118                 if (error == 0)
 119                         error = hammer2_ioctl_pfs_get(ip, data);
 120                 break;
 121         case HAMMER2IOC_PFS_LOOKUP:
 122                 if (error == 0)
 123                         error = hammer2_ioctl_pfs_lookup(ip, data);
 124                 break;
 125         case HAMMER2IOC_PFS_CREATE:
 126                 if (error == 0)
 127                         error = hammer2_ioctl_pfs_create(ip, data);
 128                 break;
 129         case HAMMER2IOC_PFS_DELETE:
 130                 if (error == 0)
 131                         error = hammer2_ioctl_pfs_delete(ip, data);
 132                 break;
 133         case HAMMER2IOC_PFS_SNAPSHOT:
 134                 if (error == 0)
 135                         error = hammer2_ioctl_pfs_snapshot(ip, data);
 136                 break;
 137         case HAMMER2IOC_INODE_GET:
 138                 error = hammer2_ioctl_inode_get(ip, data);
 139                 break;
 140         case HAMMER2IOC_INODE_SET:
 141                 if (error == 0)
 142                         error = hammer2_ioctl_inode_set(ip, data);
 143                 break;
 144         case HAMMER2IOC_BULKFREE_SCAN:
 145                 error = hammer2_ioctl_bulkfree_scan(ip, data);
 146                 break;
 147         case HAMMER2IOC_BULKFREE_ASYNC:
 148                 error = hammer2_ioctl_bulkfree_scan(ip, NULL);
 149                 break;
 150         case HAMMER2IOC_DESTROY:
 151                 if (error == 0)
 152                         error = hammer2_ioctl_destroy(ip, data);
 153                 break;
 154         case HAMMER2IOC_DEBUG_DUMP:
 155                 error = hammer2_ioctl_debug_dump(ip, *(u_int *)data);
 156                 break;
 157         case HAMMER2IOC_EMERG_MODE:
 158                 if (error == 0)
 159                         error = hammer2_ioctl_emerg_mode(ip, *(u_int *)data);
 160                 break;
 161         case HAMMER2IOC_GROWFS:
 162                 if (error == 0)
 163                         error = hammer2_ioctl_growfs(ip, data, cred);
 164                 break;
 165         case HAMMER2IOC_VOLUME_LIST:
 166                 if (error == 0)
 167                         error = hammer2_ioctl_volume_list(ip, data);
 168                 break;
 169         default:
 170                 error = EOPNOTSUPP;
 171                 break;
 172         }
 173         return (error);
 174 }
 175
 176 /*
 177  * Retrieve version and basic info
 178  */
 179 static int
 180 hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
 181 {
 182         hammer2_ioc_version_t *version = data;
 183         hammer2_dev_t *hmp;
 184
 185         hmp = ip->pmp->pfs_hmps[0];
 186         if (hmp)
 187                 version->version = hmp->voldata.version;
 188         else
 189                 version->version = -1;
 190         return 0;
 191 }
 192
 193 static int
 194 hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
 195 {
 196         hammer2_ioc_recluster_t *recl = data;
 197         struct vnode *vproot;
 198         struct file *fp;
 199         hammer2_cluster_t *cluster;
 200         int error;
 201
 202         fp = holdfp(curthread, recl->fd, -1);
 203         if (fp) {
 204                 error = VFS_ROOT(ip->pmp->mp, &vproot);
 205                 if (error == 0) {
 206                         cluster = &ip->pmp->iroot->cluster;
 207                         kprintf("reconnect to cluster: nc=%d focus=%p\n",
 208                                 cluster->nchains, cluster->focus);
 209                         if (cluster->nchains != 1 || cluster->focus == NULL) {
 210                                 kprintf("not a local device mount\n");
 211                                 error = EINVAL;
 212                         } else {
 213                                 hammer2_cluster_reconnect(cluster->focus->hmp,
 214                                                           fp);
 215                                 kprintf("ok\n");
 216                                 error = 0;
 217                         }
 218                         vput(vproot);
 219                 }
 220         } else {
 221                 error = EINVAL;
 222         }
 223         return error;
 224 }
 225
 226 /*
 227  * Retrieve information about a remote
 228  */
 229 static int
 230 hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
 231 {
 232         hammer2_dev_t *hmp;
 233         hammer2_ioc_remote_t *remote = data;
 234         int copyid = remote->copyid;
 235
 236         hmp = ip->pmp->pfs_hmps[0];
 237         if (hmp == NULL)
 238                 return (EINVAL);
 239
 240         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 241                 return (EINVAL);
 242
 243         hammer2_voldata_lock(hmp);
 244         remote->copy1 = hmp->voldata.copyinfo[copyid];
 245         hammer2_voldata_unlock(hmp);
 246
 247         /*
 248          * Adjust nextid (GET only)
 249          */
 250         while (++copyid < HAMMER2_COPYID_COUNT &&
 251                hmp->voldata.copyinfo[copyid].copyid == 0) {
 252                 ;
 253         }
 254         if (copyid == HAMMER2_COPYID_COUNT)
 255                 remote->nextid = -1;
 256         else
 257                 remote->nextid = copyid;
 258
 259         return(0);
 260 }
 261
 262 /*
 263  * Add new remote entry
 264  */
 265 static int
 266 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
 267 {
 268         hammer2_ioc_remote_t *remote = data;
 269         hammer2_pfs_t *pmp = ip->pmp;
 270         hammer2_dev_t *hmp;
 271         int copyid = remote->copyid;
 272         int error = 0;
 273
 274         hmp = pmp->pfs_hmps[0];
 275         if (hmp == NULL)
 276                 return (EINVAL);
 277         if (copyid >= HAMMER2_COPYID_COUNT)
 278                 return (EINVAL);
 279
 280         hammer2_voldata_lock(hmp);
 281         if (copyid < 0) {
 282                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
 283                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
 284                                 break;
 285                 }
 286                 if (copyid == HAMMER2_COPYID_COUNT) {
 287                         error = ENOSPC;
 288                         goto failed;
 289                 }
 290         }
 291         hammer2_voldata_modify(hmp);
 292         remote->copy1.copyid = copyid;
 293         hmp->voldata.copyinfo[copyid] = remote->copy1;
 294         hammer2_volconf_update(hmp, copyid);
 295 failed:
 296         hammer2_voldata_unlock(hmp);
 297         return (error);
 298 }
 299
 300 /*
 301  * Delete existing remote entry
 302  */
 303 static int
 304 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
 305 {
 306         hammer2_ioc_remote_t *remote = data;
 307         hammer2_pfs_t *pmp = ip->pmp;
 308         hammer2_dev_t *hmp;
 309         int copyid = remote->copyid;
 310         int error = 0;
 311
 312         hmp = pmp->pfs_hmps[0];
 313         if (hmp == NULL)
 314                 return (EINVAL);
 315         if (copyid >= HAMMER2_COPYID_COUNT)
 316                 return (EINVAL);
 317         remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
 318         hammer2_voldata_lock(hmp);
 319         if (copyid < 0) {
 320                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
 321                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
 322                                 continue;
 323                         if (strcmp(remote->copy1.path,
 324                             hmp->voldata.copyinfo[copyid].path) == 0) {
 325                                 break;
 326                         }
 327                 }
 328                 if (copyid == HAMMER2_COPYID_COUNT) {
 329                         error = ENOENT;
 330                         goto failed;
 331                 }
 332         }
 333         hammer2_voldata_modify(hmp);
 334         hmp->voldata.copyinfo[copyid].copyid = 0;
 335         hammer2_volconf_update(hmp, copyid);
 336 failed:
 337         hammer2_voldata_unlock(hmp);
 338         return (error);
 339 }
 340
 341 /*
 342  * Replace existing remote entry
 343  */
 344 static int
 345 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
 346 {
 347         hammer2_ioc_remote_t *remote = data;
 348         hammer2_dev_t *hmp;
 349         int copyid = remote->copyid;
 350
 351         hmp = ip->pmp->pfs_hmps[0];
 352         if (hmp == NULL)
 353                 return (EINVAL);
 354         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 355                 return (EINVAL);
 356
 357         hammer2_voldata_lock(hmp);
 358         hammer2_voldata_modify(hmp);
 359         /*hammer2_volconf_update(hmp, copyid);*/
 360         hammer2_voldata_unlock(hmp);
 361
 362         return(0);
 363 }
 364
 365 /*
 366  * Retrieve communications socket
 367  */
 368 static int
 369 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
 370 {
 371         return (EOPNOTSUPP);
 372 }
 373
 374 /*
 375  * Set communications socket for connection
 376  */
 377 static int
 378 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
 379 {
 380         hammer2_ioc_remote_t *remote = data;
 381         hammer2_dev_t *hmp;
 382         int copyid = remote->copyid;
 383
 384         hmp = ip->pmp->pfs_hmps[0];
 385         if (hmp == NULL)
 386                 return (EINVAL);
 387         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 388                 return (EINVAL);
 389
 390         hammer2_voldata_lock(hmp);
 391         hammer2_voldata_unlock(hmp);
 392
 393         return(0);
 394 }
 395
 396 /*
 397  * Used to scan and retrieve PFS information.  PFS's are directories under
 398  * the super-root.
 399  *
 400  * To scan PFSs pass name_key=0.  The function will scan for the next
 401  * PFS and set all fields, as well as set name_next to the next key.
 402  * When no PFSs remain, name_next is set to (hammer2_key_t)-1.
 403  *
 404  * To retrieve a particular PFS by key, specify the key but note that
 405  * the ioctl will return the lowest key >= specified_key, so the caller
 406  * must verify the key.
 407  *
 408  * To retrieve the PFS associated with the file descriptor, pass
 409  * name_key set to (hammer2_key_t)-1.
 410  */
 411 static int
 412 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
 413 {
 414         const hammer2_inode_data_t *ripdata;
 415         hammer2_dev_t *hmp;
 416         hammer2_ioc_pfs_t *pfs;
 417         hammer2_chain_t *parent;
 418         hammer2_chain_t *chain;
 419         hammer2_key_t key_next;
 420         hammer2_key_t save_key;
 421         int error;
 422
 423         hmp = ip->pmp->pfs_hmps[0];
 424         if (hmp == NULL)
 425                 return (EINVAL);
 426
 427         pfs = data;
 428         save_key = pfs->name_key;
 429         error = 0;
 430
 431         /*
 432          * Setup
 433          */
 434         if (save_key == (hammer2_key_t)-1) {
 435                 hammer2_inode_lock(ip->pmp->iroot, 0);
 436                 parent = NULL;
 437                 chain = hammer2_inode_chain(ip->pmp->iroot, 0,
 438                                             HAMMER2_RESOLVE_ALWAYS |
 439                                             HAMMER2_RESOLVE_SHARED);
 440         } else {
 441                 hammer2_inode_lock(hmp->spmp->iroot, 0);
 442                 parent = hammer2_inode_chain(hmp->spmp->iroot, 0,
 443                                             HAMMER2_RESOLVE_ALWAYS |
 444                                             HAMMER2_RESOLVE_SHARED);
 445                 chain = hammer2_chain_lookup(&parent, &key_next,
 446                                             pfs->name_key, HAMMER2_KEY_MAX,
 447                                             &error,
 448                                             HAMMER2_LOOKUP_SHARED);
 449         }
 450
 451         /*
 452          * Locate next PFS
 453          */
 454         while (chain) {
 455                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE)
 456                         break;
 457                 if (parent == NULL) {
 458                         hammer2_chain_unlock(chain);
 459                         hammer2_chain_drop(chain);
 460                         chain = NULL;
 461                         break;
 462                 }
 463                 chain = hammer2_chain_next(&parent, chain, &key_next,
 464                                             key_next, HAMMER2_KEY_MAX,
 465                                             &error,
 466                                             HAMMER2_LOOKUP_SHARED);
 467         }
 468         error = hammer2_error_to_errno(error);
 469
 470         /*
 471          * Load the data being returned by the ioctl.
 472          */
 473         if (chain && chain->error == 0) {
 474                 ripdata = &chain->data->ipdata;
 475                 pfs->name_key = ripdata->meta.name_key;
 476                 pfs->pfs_type = ripdata->meta.pfs_type;
 477                 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
 478                 pfs->pfs_clid = ripdata->meta.pfs_clid;
 479                 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
 480                 KKASSERT(ripdata->meta.name_len < sizeof(pfs->name));
 481                 bcopy(ripdata->filename, pfs->name, ripdata->meta.name_len);
 482                 pfs->name[ripdata->meta.name_len] = 0;
 483                 ripdata = NULL; /* safety */
 484
 485                 /*
 486                  * Calculate name_next, if any.  We are only accessing
 487                  * chain->bref so we can ignore chain->error (if the key
 488                  * is used later it will error then).
 489                  */
 490                 if (parent == NULL) {
 491                         pfs->name_next = (hammer2_key_t)-1;
 492                 } else {
 493                         chain = hammer2_chain_next(&parent, chain, &key_next,
 494                                                     key_next, HAMMER2_KEY_MAX,
 495                                                     &error,
 496                                                     HAMMER2_LOOKUP_SHARED);
 497                         if (chain)
 498                                 pfs->name_next = chain->bref.key;
 499                         else
 500                                 pfs->name_next = (hammer2_key_t)-1;
 501                 }
 502         } else {
 503                 pfs->name_next = (hammer2_key_t)-1;
 504                 error = ENOENT;
 505         }
 506
 507         /*
 508          * Cleanup
 509          */
 510         if (chain) {
 511                 hammer2_chain_unlock(chain);
 512                 hammer2_chain_drop(chain);
 513         }
 514         if (parent) {
 515                 hammer2_chain_unlock(parent);
 516                 hammer2_chain_drop(parent);
 517         }
 518         if (save_key == (hammer2_key_t)-1) {
 519                 hammer2_inode_unlock(ip->pmp->iroot);
 520         } else {
 521                 hammer2_inode_unlock(hmp->spmp->iroot);
 522         }
 523
 524         return (error);
 525 }
 526
 527 /*
 528  * Find a specific PFS by name
 529  */
 530 static int
 531 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
 532 {
 533         const hammer2_inode_data_t *ripdata;
 534         hammer2_dev_t *hmp;
 535         hammer2_ioc_pfs_t *pfs;
 536         hammer2_chain_t *parent;
 537         hammer2_chain_t *chain;
 538         hammer2_key_t key_next;
 539         hammer2_key_t lhc;
 540         int error;
 541         size_t len;
 542
 543         hmp = ip->pmp->pfs_hmps[0];
 544         if (hmp == NULL)
 545                 return (EINVAL);
 546
 547         pfs = data;
 548         error = 0;
 549
 550         hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_SHARED);
 551         parent = hammer2_inode_chain(hmp->spmp->iroot, 0,
 552                                      HAMMER2_RESOLVE_ALWAYS |
 553                                      HAMMER2_RESOLVE_SHARED);
 554
 555         pfs->name[sizeof(pfs->name) - 1] = 0;
 556         len = strlen(pfs->name);
 557         lhc = hammer2_dirhash(pfs->name, len);
 558
 559         chain = hammer2_chain_lookup(&parent, &key_next,
 560                                          lhc, lhc + HAMMER2_DIRHASH_LOMASK,
 561                                          &error, HAMMER2_LOOKUP_SHARED);
 562         while (chain) {
 563                 if (hammer2_chain_dirent_test(chain, pfs->name, len))
 564                         break;
 565                 chain = hammer2_chain_next(&parent, chain, &key_next,
 566                                            key_next,
 567                                            lhc + HAMMER2_DIRHASH_LOMASK,
 568                                            &error, HAMMER2_LOOKUP_SHARED);
 569         }
 570         error = hammer2_error_to_errno(error);
 571
 572         /*
 573          * Load the data being returned by the ioctl.
 574          */
 575         if (chain && chain->error == 0) {
 576                 KKASSERT(chain->bref.type == HAMMER2_BREF_TYPE_INODE);
 577                 ripdata = &chain->data->ipdata;
 578                 pfs->name_key = ripdata->meta.name_key;
 579                 pfs->pfs_type = ripdata->meta.pfs_type;
 580                 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
 581                 pfs->pfs_clid = ripdata->meta.pfs_clid;
 582                 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
 583                 ripdata = NULL;
 584
 585                 hammer2_chain_unlock(chain);
 586                 hammer2_chain_drop(chain);
 587         } else if (error == 0) {
 588                 error = ENOENT;
 589         }
 590         if (parent) {
 591                 hammer2_chain_unlock(parent);
 592                 hammer2_chain_drop(parent);
 593         }
 594         hammer2_inode_unlock(hmp->spmp->iroot);
 595
 596         return (error);
 597 }
 598
 599 /*
 600  * Create a new PFS under the super-root
 601  */
 602 static int
 603 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
 604 {
 605         hammer2_inode_data_t *nipdata;
 606         hammer2_chain_t *nchain;
 607         hammer2_dev_t *hmp;
 608         hammer2_dev_t *force_local;
 609         hammer2_ioc_pfs_t *pfs;
 610         hammer2_inode_t *nip;
 611         hammer2_tid_t mtid;
 612         int error;
 613
 614         hmp = ip->pmp->pfs_hmps[0];     /* XXX */
 615         if (hmp == NULL)
 616                 return (EINVAL);
 617
 618         pfs = data;
 619         nip = NULL;
 620
 621         if (pfs->name[0] == 0)
 622                 return(EINVAL);
 623         pfs->name[sizeof(pfs->name) - 1] = 0;   /* ensure 0-termination */
 624
 625         if (hammer2_ioctl_pfs_lookup(ip, pfs) == 0)
 626                 return(EEXIST);
 627
 628         hammer2_trans_init(hmp->spmp, HAMMER2_TRANS_ISFLUSH);
 629         mtid = hammer2_trans_sub(hmp->spmp);
 630         nip = hammer2_inode_create_pfs(hmp->spmp, pfs->name, strlen(pfs->name),
 631                                        &error);
 632         if (error == 0) {
 633                 atomic_set_int(&nip->flags, HAMMER2_INODE_NOSIDEQ);
 634                 hammer2_inode_modify(nip);
 635                 nchain = hammer2_inode_chain(nip, 0, HAMMER2_RESOLVE_ALWAYS);
 636                 error = hammer2_chain_modify(nchain, mtid, 0, 0);
 637                 KKASSERT(error == 0);
 638                 nipdata = &nchain->data->ipdata;
 639
 640                 nip->meta.pfs_type = pfs->pfs_type;
 641                 nip->meta.pfs_subtype = pfs->pfs_subtype;
 642                 nip->meta.pfs_clid = pfs->pfs_clid;
 643                 nip->meta.pfs_fsid = pfs->pfs_fsid;
 644                 nip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
 645
 646                 /*
 647                  * Set default compression and check algorithm.  This
 648                  * can be changed later.
 649                  *
 650                  * Do not allow compression on PFS's with the special name
 651                  * "boot", the boot loader can't decompress (yet).
 652                  */
 653                 nip->meta.comp_algo =
 654                         HAMMER2_ENC_ALGO(HAMMER2_COMP_NEWFS_DEFAULT);
 655                 nip->meta.check_algo =
 656                         HAMMER2_ENC_ALGO( HAMMER2_CHECK_XXHASH64);
 657
 658                 if (strcasecmp(pfs->name, "boot") == 0) {
 659                         nip->meta.comp_algo =
 660                                 HAMMER2_ENC_ALGO(HAMMER2_COMP_AUTOZERO);
 661                 }
 662
 663                 /*
 664                  * Super-root isn't mounted, fsync it
 665                  */
 666                 hammer2_chain_unlock(nchain);
 667                 hammer2_inode_ref(nip);
 668                 hammer2_inode_unlock(nip);
 669                 hammer2_inode_chain_sync(nip);
 670                 hammer2_inode_chain_flush(nip, HAMMER2_XOP_INODE_STOP |
 671                                                HAMMER2_XOP_FSSYNC);
 672                 hammer2_inode_drop(nip);
 673                 /* nip is dead */
 674
 675                 /*
 676                  * We still have a ref on the chain, relock and associate
 677                  * with an appropriate PFS.
 678                  */
 679                 force_local = (hmp->hflags & HMNT2_LOCAL) ? hmp : NULL;
 680
 681                 hammer2_chain_lock(nchain, HAMMER2_RESOLVE_ALWAYS);
 682                 nipdata = &nchain->data->ipdata;
 683                 kprintf("ADD LOCAL PFS (IOCTL): %s\n", nipdata->filename);
 684                 hammer2_pfsalloc(nchain, nipdata, force_local);
 685
 686                 hammer2_chain_unlock(nchain);
 687                 hammer2_chain_drop(nchain);
 688         }
 689         hammer2_trans_done(hmp->spmp, HAMMER2_TRANS_ISFLUSH |
 690                                       HAMMER2_TRANS_SIDEQ);
 691
 692         return (error);
 693 }
 694
 695 /*
 696  * Destroy an existing PFS under the super-root
 697  */
 698 static int
 699 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
 700 {
 701         hammer2_ioc_pfs_t *pfs = data;
 702         hammer2_dev_t   *hmp;
 703         hammer2_pfs_t   *spmp;
 704         hammer2_pfs_t   *pmp;
 705         hammer2_xop_unlink_t *xop;
 706         hammer2_inode_t *dip;
 707         hammer2_inode_t *iroot;
 708         int error;
 709         int i;
 710
 711         /*
 712          * The PFS should be probed, so we should be able to
 713          * locate it.  We only delete the PFS from the
 714          * specific H2 block device (hmp), not all of
 715          * them.  We must remove the PFS from the cluster
 716          * before we can destroy it.
 717          */
 718         hmp = ip->pmp->pfs_hmps[0];
 719         if (hmp == NULL)
 720                 return (EINVAL);
 721
 722         pfs->name[sizeof(pfs->name) - 1] = 0;   /* ensure termination */
 723
 724         lockmgr(&hammer2_mntlk, LK_EXCLUSIVE);
 725
 726         TAILQ_FOREACH(pmp, &hammer2_pfslist, mntentry) {
 727                 for (i = 0; i < HAMMER2_MAXCLUSTER; ++i) {
 728                         if (pmp->pfs_hmps[i] != hmp)
 729                                 continue;
 730                         if (pmp->pfs_names[i] &&
 731                             strcmp(pmp->pfs_names[i], pfs->name) == 0) {
 732                                 break;
 733                         }
 734                 }
 735                 if (i != HAMMER2_MAXCLUSTER)
 736                         break;
 737         }
 738
 739         if (pmp == NULL) {
 740                 lockmgr(&hammer2_mntlk, LK_RELEASE);
 741                 return ENOENT;
 742         }
 743         if (pmp->mp) {
 744                 lockmgr(&hammer2_mntlk, LK_RELEASE);
 745                 return EBUSY;
 746         }
 747
 748         /*
 749          * Ok, we found the pmp and we have the index.  Permanently remove
 750          * the PFS from the cluster
 751          */
 752         iroot = pmp->iroot;
 753         kprintf("FOUND PFS %s CLINDEX %d\n", pfs->name, i);
 754         hammer2_pfsdealloc(pmp, i, 1);
 755
 756         lockmgr(&hammer2_mntlk, LK_RELEASE);
 757
 758         /*
 759          * Now destroy the PFS under its device using the per-device
 760          * super-root.
 761          */
 762         spmp = hmp->spmp;
 763         dip = spmp->iroot;
 764         hammer2_trans_init(spmp, 0);
 765         hammer2_inode_lock(dip, 0);
 766
 767         xop = hammer2_xop_alloc(dip, HAMMER2_XOP_MODIFYING);
 768         hammer2_xop_setname(&xop->head, pfs->name, strlen(pfs->name));
 769         xop->isdir = 2;
 770         xop->dopermanent = H2DOPERM_PERMANENT | H2DOPERM_FORCE;
 771         hammer2_xop_start(&xop->head, &hammer2_unlink_desc);
 772
 773         error = hammer2_xop_collect(&xop->head, 0);
 774
 775         hammer2_inode_unlock(dip);
 776
 777 #if 0
 778         if (error == 0) {
 779                 ip = hammer2_inode_get(dip->pmp, &xop->head, -1, -1);
 780                 hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
 781                 if (ip) {
 782                         hammer2_inode_unlink_finisher(ip, NULL);
 783                         hammer2_inode_unlock(ip);
 784                 }
 785         } else {
 786                 hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
 787         }
 788 #endif
 789         hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
 790
 791         hammer2_trans_done(spmp, HAMMER2_TRANS_SIDEQ);
 792
 793         return (hammer2_error_to_errno(error));
 794 }
 795
 796 static int
 797 hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
 798 {
 799         hammer2_ioc_pfs_t *pfs = data;
 800         hammer2_dev_t   *hmp;
 801         hammer2_pfs_t   *pmp;
 802         hammer2_chain_t *chain;
 803         hammer2_inode_t *nip;
 804         hammer2_tid_t   mtid;
 805         size_t name_len;
 806         hammer2_key_t lhc;
 807         int error;
 808 #if 0
 809         uuid_t opfs_clid;
 810 #endif
 811
 812         if (pfs->name[0] == 0)
 813                 return(EINVAL);
 814         if (pfs->name[sizeof(pfs->name)-1] != 0)
 815                 return(EINVAL);
 816
 817         pmp = ip->pmp;
 818         ip = pmp->iroot;
 819
 820         hmp = pmp->pfs_hmps[0];
 821         if (hmp == NULL)
 822                 return (EINVAL);
 823
 824         lockmgr(&hmp->bulklk, LK_EXCLUSIVE);
 825
 826         /*
 827          * NOSYNC is for debugging.  We skip the filesystem sync and use
 828          * a normal transaction (which is less likely to stall).  used for
 829          * testing filesystem consistency.
 830          *
 831          * In normal mode we sync the filesystem and use a flush transaction.
 832          */
 833         if (pfs->pfs_flags & HAMMER2_PFSFLAGS_NOSYNC) {
 834                 hammer2_trans_init(pmp, 0);
 835         } else {
 836                 hammer2_vfs_sync(pmp->mp, MNT_WAIT);
 837                 hammer2_trans_init(pmp, HAMMER2_TRANS_ISFLUSH);
 838         }
 839         mtid = hammer2_trans_sub(pmp);
 840         hammer2_inode_lock(ip, 0);
 841         hammer2_inode_modify(ip);
 842         ip->meta.pfs_lsnap_tid = mtid;
 843
 844         /* XXX cluster it! */
 845         chain = hammer2_inode_chain(ip, 0, HAMMER2_RESOLVE_ALWAYS);
 846
 847         name_len = strlen(pfs->name);
 848         lhc = hammer2_dirhash(pfs->name, name_len);
 849
 850         /*
 851          * Get the clid
 852          */
 853         hmp = chain->hmp;
 854
 855         /*
 856          * Create the snapshot directory under the super-root
 857          *
 858          * Set PFS type, generate a unique filesystem id, and generate
 859          * a cluster id.  Use the same clid when snapshotting a PFS root,
 860          * which theoretically allows the snapshot to be used as part of
 861          * the same cluster (perhaps as a cache).
 862          *
 863          * Note that pfs_lsnap_tid must be set in the snapshot as well,
 864          * ensuring that any nocrc/nocomp file data modifications force
 865          * a copy-on-write.
 866          *
 867          * Copy the (flushed) blockref array.  Theoretically we could use
 868          * chain_duplicate() but it becomes difficult to disentangle
 869          * the shared core so for now just brute-force it.
 870          */
 871         hammer2_chain_unlock(chain);
 872         nip = hammer2_inode_create_pfs(hmp->spmp, pfs->name, name_len, &error);
 873         hammer2_chain_lock(chain, HAMMER2_RESOLVE_ALWAYS);
 874
 875         if (nip) {
 876                 hammer2_dev_t *force_local;
 877                 hammer2_chain_t *nchain;
 878                 hammer2_inode_data_t *wipdata;
 879                 hammer2_tid_t starting_inum;
 880
 881                 atomic_set_int(&nip->flags, HAMMER2_INODE_NOSIDEQ);
 882                 hammer2_inode_modify(nip);
 883                 nchain = hammer2_inode_chain(nip, 0, HAMMER2_RESOLVE_ALWAYS);
 884                 error = hammer2_chain_modify(nchain, mtid, 0, 0);
 885                 KKASSERT(error == 0);
 886                 wipdata = &nchain->data->ipdata;
 887
 888                 starting_inum = ip->pmp->inode_tid + 1;
 889                 nip->meta.pfs_inum = starting_inum;
 890                 nip->meta.pfs_type = HAMMER2_PFSTYPE_MASTER;
 891                 nip->meta.pfs_subtype = HAMMER2_PFSSUBTYPE_SNAPSHOT;
 892                 nip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
 893                 nip->meta.pfs_lsnap_tid = mtid;
 894                 nchain->bref.embed.stats = chain->bref.embed.stats;
 895
 896                 kern_uuidgen(&nip->meta.pfs_fsid, 1);
 897
 898 #if 0
 899                 /*
 900                  * Give the snapshot its own private cluster id.  As a
 901                  * snapshot no further synchronization with the original
 902                  * cluster will be done.
 903                  */
 904                 if (chain->flags & HAMMER2_CHAIN_PFSBOUNDARY)
 905                         nip->meta.pfs_clid = opfs_clid;
 906                 else
 907                         kern_uuidgen(&nip->meta.pfs_clid, 1);
 908 #endif
 909                 kern_uuidgen(&nip->meta.pfs_clid, 1);
 910                 nchain->bref.flags |= HAMMER2_BREF_FLAG_PFSROOT;
 911
 912                 /* XXX hack blockset copy */
 913                 /* XXX doesn't work with real cluster */
 914                 wipdata->meta = nip->meta;
 915                 hammer2_spin_ex(&pmp->inum_spin);
 916                 wipdata->u.blockset = pmp->pfs_iroot_blocksets[0];
 917                 hammer2_spin_unex(&pmp->inum_spin);
 918
 919                 KKASSERT(wipdata == &nchain->data->ipdata);
 920
 921                 hammer2_chain_unlock(nchain);
 922                 hammer2_inode_ref(nip);
 923                 hammer2_inode_unlock(nip);
 924                 hammer2_inode_chain_sync(nip);
 925                 hammer2_inode_chain_flush(nip, HAMMER2_XOP_INODE_STOP |
 926                                                HAMMER2_XOP_FSSYNC);
 927                                                /* XXX | HAMMER2_XOP_VOLHDR */
 928                 hammer2_inode_drop(nip);
 929                 /* nip is dead */
 930
 931                 force_local = (hmp->hflags & HMNT2_LOCAL) ? hmp : NULL;
 932
 933                 hammer2_chain_lock(nchain, HAMMER2_RESOLVE_ALWAYS);
 934                 wipdata = &nchain->data->ipdata;
 935                 kprintf("SNAPSHOT LOCAL PFS (IOCTL): %s\n", wipdata->filename);
 936                 hammer2_pfsalloc(nchain, wipdata, force_local);
 937                 nchain->pmp->inode_tid = starting_inum;
 938
 939                 hammer2_chain_unlock(nchain);
 940                 hammer2_chain_drop(nchain);
 941         }
 942
 943         hammer2_chain_unlock(chain);
 944         hammer2_chain_drop(chain);
 945
 946         hammer2_inode_unlock(ip);
 947         if (pfs->pfs_flags & HAMMER2_PFSFLAGS_NOSYNC) {
 948                 hammer2_trans_done(pmp, 0);
 949         } else {
 950                 hammer2_trans_done(pmp, HAMMER2_TRANS_ISFLUSH |
 951                                         HAMMER2_TRANS_SIDEQ);
 952         }
 953
 954         lockmgr(&hmp->bulklk, LK_RELEASE);
 955
 956         return (hammer2_error_to_errno(error));
 957 }
 958
 959 /*
 960  * Retrieve the raw inode structure, non-inclusive of node-specific data.
 961  */
 962 static int
 963 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
 964 {
 965         hammer2_ioc_inode_t *ino = data;
 966
 967         hammer2_inode_lock(ip, HAMMER2_RESOLVE_SHARED);
 968         ino->data_count = hammer2_inode_data_count(ip);
 969         ino->inode_count = hammer2_inode_inode_count(ip);
 970
 971         bzero(&ino->ip_data, sizeof(ino->ip_data));
 972         ino->ip_data.meta = ip->meta;
 973         hammer2_inode_unlock(ip);
 974
 975         return 0;
 976 }
 977
 978 /*
 979  * Set various parameters in an inode which cannot be set through
 980  * normal filesystem VNOPS.
 981  */
 982 static int
 983 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
 984 {
 985         hammer2_ioc_inode_t *ino = data;
 986
 987         hammer2_trans_init(ip->pmp, 0);
 988         hammer2_inode_lock(ip, 0);
 989
 990         if ((ino->flags & HAMMER2IOC_INODE_FLAG_CHECK) &&
 991             ip->meta.check_algo != ino->ip_data.meta.check_algo) {
 992                 hammer2_inode_modify(ip);
 993                 ip->meta.check_algo = ino->ip_data.meta.check_algo;
 994         }
 995         if ((ino->flags & HAMMER2IOC_INODE_FLAG_COMP) &&
 996             ip->meta.comp_algo != ino->ip_data.meta.comp_algo) {
 997                 hammer2_inode_modify(ip);
 998                 ip->meta.comp_algo = ino->ip_data.meta.comp_algo;
 999         }
1000
1001         /* Ignore these flags for now...*/
1002         if ((ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) &&
1003             ip->meta.inode_quota != ino->ip_data.meta.inode_quota) {
1004                 hammer2_inode_modify(ip);
1005                 ip->meta.inode_quota = ino->ip_data.meta.inode_quota;
1006         }
1007         if ((ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) &&
1008             ip->meta.data_quota != ino->ip_data.meta.data_quota) {
1009                 hammer2_inode_modify(ip);
1010                 ip->meta.data_quota = ino->ip_data.meta.data_quota;
1011         }
1012         if ((ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) &&
1013             ip->meta.ncopies != ino->ip_data.meta.ncopies) {
1014                 hammer2_inode_modify(ip);
1015                 ip->meta.ncopies = ino->ip_data.meta.ncopies;
1016         }
1017         hammer2_inode_unlock(ip);
1018         hammer2_trans_done(ip->pmp, HAMMER2_TRANS_SIDEQ);
1019
1020         return (0);
1021 }
1022
1023 static
1024 int
1025 hammer2_ioctl_debug_dump(hammer2_inode_t *ip, u_int flags)
1026 {
1027         hammer2_chain_t *chain;
1028         int count = 100000;
1029         int i;
1030
1031         for (i = 0; i < ip->cluster.nchains; ++i) {
1032                 chain = ip->cluster.array[i].chain;
1033                 if (chain == NULL)
1034                         continue;
1035                 kprintf("cluster #%d\n", i);
1036                 hammer2_dump_chain(chain, 0, 0, &count, 'i', flags);
1037         }
1038         return 0;
1039 }
1040
1041 /*
1042  * Turn on or off emergency mode on a filesystem.
1043  */
1044 static
1045 int
1046 hammer2_ioctl_emerg_mode(hammer2_inode_t *ip, u_int mode)
1047 {
1048         hammer2_pfs_t *pmp;
1049         hammer2_dev_t *hmp;
1050         int i;
1051
1052         pmp = ip->pmp;
1053         if (mode) {
1054                 kprintf("hammer2: WARNING: Emergency mode enabled\n");
1055                 atomic_set_int(&pmp->flags, HAMMER2_PMPF_EMERG);
1056         } else {
1057                 kprintf("hammer2: WARNING: Emergency mode disabled\n");
1058                 atomic_clear_int(&pmp->flags, HAMMER2_PMPF_EMERG);
1059         }
1060         for (i = 0; i < HAMMER2_MAXCLUSTER; ++i) {
1061                 hmp = pmp->pfs_hmps[i];
1062                 if (hmp == NULL)
1063                         continue;
1064                 if (mode)
1065                         atomic_set_int(&hmp->hflags, HMNT2_EMERG);
1066                 else
1067                         atomic_clear_int(&hmp->hflags, HMNT2_EMERG);
1068         }
1069         return 0;
1070 }
1071
1072 /*
1073  * Do a bulkfree scan on media related to the PFS.  This routine will
1074  * flush all PFSs associated with the media before doing the bulkfree
1075  * scan.
1076  *
1077  * This version can only run on non-clustered media.  A new ioctl or a
1078  * temporary mount of @LOCAL will be needed to run on clustered media.
1079  */
1080 static
1081 int
1082 hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data)
1083 {
1084         hammer2_ioc_bulkfree_t *bfi = data;
1085         hammer2_dev_t   *hmp;
1086         hammer2_pfs_t   *pmp;
1087         hammer2_chain_t *vchain;
1088         int error;
1089         int didsnap;
1090
1091         pmp = ip->pmp;
1092         ip = pmp->iroot;
1093
1094         hmp = pmp->pfs_hmps[0];
1095         if (hmp == NULL)
1096                 return (EINVAL);
1097         if (bfi == NULL)
1098                 return (EINVAL);
1099
1100         /*
1101          * Bulkfree has to be serialized to guarantee at least one sync
1102          * inbetween bulkfrees.
1103          */
1104         error = lockmgr(&hmp->bflock, LK_EXCLUSIVE | LK_PCATCH);
1105         if (error)
1106                 return error;
1107
1108         /*
1109          * Sync all mounts related to the media
1110          */
1111         lockmgr(&hammer2_mntlk, LK_EXCLUSIVE);
1112         TAILQ_FOREACH(pmp, &hammer2_pfslist, mntentry) {
1113                 int etmp;
1114                 int i;
1115
1116                 for (i = 0; i < HAMMER2_MAXCLUSTER; ++i) {
1117                         if (pmp->pfs_hmps[i] != hmp)
1118                                 continue;
1119                         etmp = hammer2_vfs_sync_pmp(pmp, MNT_WAIT);
1120                         if (etmp && (error == 0 || error == ENOSPC))
1121                                 error = etmp;
1122                         break;
1123                 }
1124         }
1125         lockmgr(&hammer2_mntlk, LK_RELEASE);
1126
1127         if (error && error != ENOSPC)
1128                 goto failed;
1129
1130         /*
1131          * If we have an ENOSPC error we have to bulkfree on the live
1132          * topology.  Otherwise we can bulkfree on a snapshot.
1133          */
1134         if (error) {
1135                 kprintf("hammer2: WARNING! Bulkfree forced to use live "
1136                         "topology due to ENOSPC\n");
1137                 vchain = &hmp->vchain;
1138                 hammer2_chain_ref(vchain);
1139                 didsnap = 0;
1140         } else {
1141                 vchain = hammer2_chain_bulksnap(hmp);
1142                 didsnap = 1;
1143         }
1144
1145         /*
1146          * Normal bulkfree operations do not require a transaction because
1147          * they operate on a snapshot, and so can run concurrently with
1148          * any operation except another bulkfree.
1149          *
1150          * If we are running bulkfree on the live topology we have to be
1151          * in a FLUSH transaction.
1152          */
1153         if (didsnap == 0)
1154                 hammer2_trans_init(hmp->spmp, HAMMER2_TRANS_ISFLUSH);
1155
1156         if (bfi) {
1157                 hammer2_thr_freeze(&hmp->bfthr);
1158                 error = hammer2_bulkfree_pass(hmp, vchain, bfi);
1159                 hammer2_thr_unfreeze(&hmp->bfthr);
1160         }
1161         if (didsnap) {
1162                 hammer2_chain_bulkdrop(vchain);
1163         } else {
1164                 hammer2_chain_drop(vchain);
1165                 hammer2_trans_done(hmp->spmp, HAMMER2_TRANS_ISFLUSH |
1166                                         HAMMER2_TRANS_SIDEQ);
1167         }
1168         error = hammer2_error_to_errno(error);
1169
1170 failed:
1171         lockmgr(&hmp->bflock, LK_RELEASE);
1172         return error;
1173 }
1174
1175 /*
1176  * Unconditionally delete meta-data in a hammer2 filesystem
1177  */
1178 static
1179 int
1180 hammer2_ioctl_destroy(hammer2_inode_t *ip, void *data)
1181 {
1182         hammer2_ioc_destroy_t *iocd = data;
1183         hammer2_pfs_t *pmp = ip->pmp;
1184         int error;
1185
1186         if (pmp->ronly) {
1187                 error = EROFS;
1188                 return error;
1189         }
1190
1191         switch(iocd->cmd) {
1192         case HAMMER2_DELETE_FILE:
1193                 /*
1194                  * Destroy a bad directory entry by name.  Caller must
1195                  * pass the directory as fd.
1196                  */
1197                 {
1198                 hammer2_xop_unlink_t *xop;
1199
1200                 if (iocd->path[sizeof(iocd->path)-1]) {
1201                         error = EINVAL;
1202                         break;
1203                 }
1204                 if (ip->meta.type != HAMMER2_OBJTYPE_DIRECTORY) {
1205                         error = EINVAL;
1206                         break;
1207                 }
1208                 hammer2_pfs_memory_wait(pmp);
1209                 hammer2_trans_init(pmp, 0);
1210                 hammer2_inode_lock(ip, 0);
1211
1212                 xop = hammer2_xop_alloc(ip, HAMMER2_XOP_MODIFYING);
1213                 hammer2_xop_setname(&xop->head, iocd->path, strlen(iocd->path));
1214                 xop->isdir = -1;
1215                 xop->dopermanent = H2DOPERM_PERMANENT |
1216                                    H2DOPERM_FORCE |
1217                                    H2DOPERM_IGNINO;
1218                 hammer2_xop_start(&xop->head, &hammer2_unlink_desc);
1219
1220                 error = hammer2_xop_collect(&xop->head, 0);
1221                 error = hammer2_error_to_errno(error);
1222                 hammer2_inode_unlock(ip);
1223                 hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
1224                 hammer2_trans_done(pmp, HAMMER2_TRANS_SIDEQ);
1225                 }
1226                 break;
1227         case HAMMER2_DELETE_INUM:
1228                 /*
1229                  * Destroy a bad inode by inode number.
1230                  */
1231                 {
1232                 hammer2_xop_lookup_t *xop;
1233
1234                 if (iocd->inum < 1) {
1235                         error = EINVAL;
1236                         break;
1237                 }
1238                 hammer2_pfs_memory_wait(pmp);
1239                 hammer2_trans_init(pmp, 0);
1240
1241                 xop = hammer2_xop_alloc(pmp->iroot, HAMMER2_XOP_MODIFYING);
1242                 xop->lhc = iocd->inum;
1243                 hammer2_xop_start(&xop->head, &hammer2_delete_desc);
1244                 error = hammer2_xop_collect(&xop->head, 0);
1245                 error = hammer2_error_to_errno(error);
1246                 hammer2_xop_retire(&xop->head, HAMMER2_XOPMASK_VOP);
1247                 hammer2_trans_done(pmp, HAMMER2_TRANS_SIDEQ);
1248                 }
1249                 break;
1250         default:
1251                 error = EINVAL;
1252                 break;
1253         }
1254         return error;
1255 }
1256
1257 /*
1258  * Grow a filesystem into its partition size
1259  */
1260 static int
1261 hammer2_ioctl_growfs(hammer2_inode_t *ip, void *data, struct ucred *cred)
1262 {
1263         hammer2_ioc_growfs_t *grow = data;
1264         hammer2_dev_t *hmp;
1265         hammer2_off_t delta;
1266         hammer2_tid_t mtid;
1267         struct buf *bp;
1268         int error;
1269         int i;
1270
1271         hmp = ip->pmp->pfs_hmps[0];
1272
1273         if (hmp->nvolumes > 1) {
1274                 kprintf("hammer2: growfs currently unsupported "
1275                         "with multiple volumes\n");
1276                 return EOPNOTSUPP;
1277         }
1278
1279         /*
1280          * Extract from disklabel
1281          */
1282         grow->modified = 0;
1283         if (grow->size == 0) {
1284                 struct partinfo part;
1285                 struct vattr_lite va;
1286
1287                 if (VOP_IOCTL(hmp->devvp, DIOCGPART, (void *)&part,
1288                               0, cred, NULL) == 0) {
1289                         grow->size = part.media_size;
1290                         kprintf("hammer2: growfs partition-auto to %016jx\n",
1291                                 (intmax_t)grow->size);
1292                 } else if (VOP_GETATTR_LITE(hmp->devvp, &va) == 0) {
1293                         grow->size = va.va_size;
1294                         kprintf("hammer2: growfs fstat-auto to %016jx\n",
1295                                 (intmax_t)grow->size);
1296                 } else {
1297                         return EINVAL;
1298                 }
1299         }
1300
1301         /*
1302          * This is typically ~8MB alignment to avoid edge cases accessing
1303          * reserved blocks at the base of each 2GB zone.
1304          */
1305         grow->size &= ~HAMMER2_VOLUME_ALIGNMASK64;
1306         delta = grow->size - hmp->voldata.volu_size;
1307
1308         /*
1309          * Maximum allowed size is 2^63
1310          */
1311         if (grow->size > 0x7FFFFFFFFFFFFFFFLU) {
1312                 kprintf("hammer2: growfs failure, limit is 2^63 - 1 bytes\n");
1313                 return EINVAL;
1314         }
1315
1316         /*
1317          * We can't shrink a filesystem
1318          */
1319         if (grow->size < hmp->voldata.volu_size) {
1320                 kprintf("hammer2: growfs failure, "
1321                         "would shrink from %016jx to %016jx\n",
1322                         (intmax_t)hmp->voldata.volu_size,
1323                         (intmax_t)grow->size);
1324                 return EINVAL;
1325         }
1326
1327         if (delta == 0) {
1328                 kprintf("hammer2: growfs - size did not change\n");
1329                 return 0;
1330         }
1331
1332         /*
1333          * Clear any new volume header backups that we extend into.
1334          * Skip volume headers that are already part of the filesystem.
1335          */
1336         for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
1337                 if (i * HAMMER2_ZONE_BYTES64 < hmp->voldata.volu_size)
1338                         continue;
1339                 if (i * HAMMER2_ZONE_BYTES64 >= grow->size)
1340                         break;
1341                 kprintf("hammer2: growfs - clear volhdr %d ", i);
1342                 error = bread(hmp->devvp, i * HAMMER2_ZONE_BYTES64,
1343                               HAMMER2_VOLUME_BYTES, &bp);
1344                 if (error) {
1345                         brelse(bp);
1346                         kprintf("I/O error %d\n", error);
1347                         return EINVAL;
1348                 }
1349                 bzero(bp->b_data, HAMMER2_VOLUME_BYTES);
1350                 error = bwrite(bp);
1351                 if (error) {
1352                         kprintf("I/O error %d\n", error);
1353                         return EINVAL;
1354                 }
1355                 kprintf("\n");
1356         }
1357
1358         hammer2_trans_init(hmp->spmp, HAMMER2_TRANS_ISFLUSH);
1359         mtid = hammer2_trans_sub(hmp->spmp);
1360
1361         kprintf("hammer2: growfs - expand by %016jx to %016jx mtid %016jx\n",
1362                 (intmax_t)delta, (intmax_t)grow->size, (intmax_t)mtid);
1363
1364
1365         hammer2_voldata_lock(hmp);
1366         hammer2_voldata_modify(hmp);
1367
1368         /*
1369          * NOTE: Just adjusting total_size for a single-volume filesystem
1370          *       or for the last volume in a multi-volume filesystem, is
1371          *       fine.  But we can't grow any other partition in a multi-volume
1372          *       filesystem.  For now we just punt (at the top) on any
1373          *       multi-volume filesystem.
1374          */
1375         hmp->voldata.volu_size = grow->size;
1376         hmp->voldata.total_size += delta;
1377         hmp->voldata.allocator_size += delta;
1378         hmp->voldata.allocator_free += delta;
1379         hmp->total_size += delta;
1380         hmp->volumes[0].size += delta;  /* note: indexes first (only) volume */
1381
1382         hammer2_voldata_unlock(hmp);
1383
1384         hammer2_trans_done(hmp->spmp, HAMMER2_TRANS_ISFLUSH |
1385                                       HAMMER2_TRANS_SIDEQ);
1386         grow->modified = 1;
1387
1388         /*
1389          * Flush the mess right here and now.  We could just let the
1390          * filesystem syncer do it, but this was a sensitive operation
1391          * so don't take any chances.
1392          */
1393         hammer2_vfs_sync(ip->pmp->mp, MNT_WAIT);
1394
1395         return 0;
1396 }
1397
1398 /*
1399  * Get a list of volumes.
1400  */
1401 static int
1402 hammer2_ioctl_volume_list(hammer2_inode_t *ip, void *data)
1403 {
1404         hammer2_ioc_volume_list_t *vollist = data;
1405         hammer2_ioc_volume_t entry;
1406         hammer2_volume_t *vol;
1407         hammer2_dev_t *hmp;
1408         hammer2_pfs_t *pmp;
1409         int i, error = 0, cnt = 0;
1410
1411         pmp = ip->pmp;
1412         hmp = pmp->pfs_hmps[0];
1413         if (hmp == NULL)
1414                 return (EINVAL);
1415
1416         hammer2_voldata_lock(hmp);
1417         for (i = 0; i < hmp->nvolumes; ++i) {
1418                 if (cnt >= vollist->nvolumes)
1419                         break;
1420                 vol = &hmp->volumes[i];
1421                 bzero(&entry, sizeof(entry));
1422                 /* copy hammer2_volume_t fields */
1423                 entry.id = vol->id;
1424                 bcopy(vol->dev->path, entry.path, sizeof(entry.path));
1425                 entry.offset = vol->offset;
1426                 entry.size = vol->size;
1427                 error = copyout(&entry, &vollist->volumes[cnt], sizeof(entry));
1428                 if (error)
1429                         goto failed;
1430                 cnt++;
1431         }
1432         vollist->nvolumes = cnt;
1433         vollist->version = hmp->voldata.version;
1434         bcopy(pmp->pfs_names[0], vollist->pfs_name, sizeof(vollist->pfs_name));
1435 failed:
1436         hammer2_voldata_unlock(hmp);
1437
1438         return error;
1439 }