sys/vfs/hammer2/hammer2_ioctl.c

   1 /*
   2  * Copyright (c) 2011-2015 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 static int hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data);
  46 static int hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data);
  47 static int hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data);
  48 static int hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data);
  49 static int hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data);
  50 static int hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data);
  51 static int hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data);
  52 static int hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data);
  53 static int hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data);
  54 static int hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data);
  55 static int hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data);
  56 static int hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data);
  57 static int hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data);
  58 static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data);
  59 static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data);
  60 static int hammer2_ioctl_debug_dump(hammer2_inode_t *ip);
  61 //static int hammer2_ioctl_inode_comp_set(hammer2_inode_t *ip, void *data);
  62 //static int hammer2_ioctl_inode_comp_rec_set(hammer2_inode_t *ip, void *data);
  63 //static int hammer2_ioctl_inode_comp_rec_set2(hammer2_inode_t *ip, void *data);
  64 static int hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data);
  65
  66 int
  67 hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
  68               struct ucred *cred)
  69 {
  70         int error;
  71
  72         /*
  73          * Standard root cred checks, will be selectively ignored below
  74          * for ioctls that do not require root creds.
  75          */
  76         error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
  77
  78         switch(com) {
  79         case HAMMER2IOC_VERSION_GET:
  80                 error = hammer2_ioctl_version_get(ip, data);
  81                 break;
  82         case HAMMER2IOC_RECLUSTER:
  83                 if (error == 0)
  84                         error = hammer2_ioctl_recluster(ip, data);
  85                 break;
  86         case HAMMER2IOC_REMOTE_SCAN:
  87                 if (error == 0)
  88                         error = hammer2_ioctl_remote_scan(ip, data);
  89                 break;
  90         case HAMMER2IOC_REMOTE_ADD:
  91                 if (error == 0)
  92                         error = hammer2_ioctl_remote_add(ip, data);
  93                 break;
  94         case HAMMER2IOC_REMOTE_DEL:
  95                 if (error == 0)
  96                         error = hammer2_ioctl_remote_del(ip, data);
  97                 break;
  98         case HAMMER2IOC_REMOTE_REP:
  99                 if (error == 0)
 100                         error = hammer2_ioctl_remote_rep(ip, data);
 101                 break;
 102         case HAMMER2IOC_SOCKET_GET:
 103                 if (error == 0)
 104                         error = hammer2_ioctl_socket_get(ip, data);
 105                 break;
 106         case HAMMER2IOC_SOCKET_SET:
 107                 if (error == 0)
 108                         error = hammer2_ioctl_socket_set(ip, data);
 109                 break;
 110         case HAMMER2IOC_PFS_GET:
 111                 if (error == 0)
 112                         error = hammer2_ioctl_pfs_get(ip, data);
 113                 break;
 114         case HAMMER2IOC_PFS_LOOKUP:
 115                 if (error == 0)
 116                         error = hammer2_ioctl_pfs_lookup(ip, data);
 117                 break;
 118         case HAMMER2IOC_PFS_CREATE:
 119                 if (error == 0)
 120                         error = hammer2_ioctl_pfs_create(ip, data);
 121                 break;
 122         case HAMMER2IOC_PFS_DELETE:
 123                 if (error == 0)
 124                         error = hammer2_ioctl_pfs_delete(ip, data);
 125                 break;
 126         case HAMMER2IOC_PFS_SNAPSHOT:
 127                 if (error == 0)
 128                         error = hammer2_ioctl_pfs_snapshot(ip, data);
 129                 break;
 130         case HAMMER2IOC_INODE_GET:
 131                 error = hammer2_ioctl_inode_get(ip, data);
 132                 break;
 133         case HAMMER2IOC_INODE_SET:
 134                 if (error == 0)
 135                         error = hammer2_ioctl_inode_set(ip, data);
 136                 break;
 137         case HAMMER2IOC_BULKFREE_SCAN:
 138                 error = hammer2_ioctl_bulkfree_scan(ip, data);
 139                 break;
 140         /*case HAMMER2IOC_INODE_COMP_SET:
 141                 error = hammer2_ioctl_inode_comp_set(ip, data);
 142                 break;
 143         case HAMMER2IOC_INODE_COMP_REC_SET:
 144                 error = hammer2_ioctl_inode_comp_rec_set(ip, data);
 145                 break;
 146         case HAMMER2IOC_INODE_COMP_REC_SET2:
 147                 error = hammer2_ioctl_inode_comp_rec_set2(ip, data);
 148                 break;*/
 149         case HAMMER2IOC_DEBUG_DUMP:
 150                 error = hammer2_ioctl_debug_dump(ip);
 151                 break;
 152         default:
 153                 error = EOPNOTSUPP;
 154                 break;
 155         }
 156         return (error);
 157 }
 158
 159 /*
 160  * Retrieve version and basic info
 161  */
 162 static int
 163 hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
 164 {
 165         hammer2_ioc_version_t *version = data;
 166         hammer2_dev_t *hmp;
 167
 168         hmp = ip->pmp->pfs_hmps[0];
 169         if (hmp)
 170                 version->version = hmp->voldata.version;
 171         else
 172                 version->version = -1;
 173         return 0;
 174 }
 175
 176 static int
 177 hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
 178 {
 179         hammer2_ioc_recluster_t *recl = data;
 180         struct file *fp;
 181         hammer2_cluster_t *cluster;
 182         int error;
 183
 184         fp = holdfp(curproc->p_fd, recl->fd, -1);
 185         if (fp) {
 186                 kprintf("reconnect to cluster: XXX ");
 187                 cluster = &ip->pmp->iroot->cluster;
 188                 if (cluster->nchains != 1 || cluster->focus == NULL) {
 189                         kprintf("not a local device mount\n");
 190                         error = EINVAL;
 191                 } else {
 192                         hammer2_cluster_reconnect(cluster->focus->hmp, fp);
 193                         kprintf("ok\n");
 194                         error = 0;
 195                 }
 196         } else {
 197                 error = EINVAL;
 198         }
 199         return error;
 200 }
 201
 202 /*
 203  * Retrieve information about a remote
 204  */
 205 static int
 206 hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
 207 {
 208         hammer2_dev_t *hmp;
 209         hammer2_ioc_remote_t *remote = data;
 210         int copyid = remote->copyid;
 211
 212         hmp = ip->pmp->pfs_hmps[0];
 213         if (hmp == NULL)
 214                 return (EINVAL);
 215
 216         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 217                 return (EINVAL);
 218
 219         hammer2_voldata_lock(hmp);
 220         remote->copy1 = hmp->voldata.copyinfo[copyid];
 221         hammer2_voldata_unlock(hmp);
 222
 223         /*
 224          * Adjust nextid (GET only)
 225          */
 226         while (++copyid < HAMMER2_COPYID_COUNT &&
 227                hmp->voldata.copyinfo[copyid].copyid == 0) {
 228                 ;
 229         }
 230         if (copyid == HAMMER2_COPYID_COUNT)
 231                 remote->nextid = -1;
 232         else
 233                 remote->nextid = copyid;
 234
 235         return(0);
 236 }
 237
 238 /*
 239  * Add new remote entry
 240  */
 241 static int
 242 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
 243 {
 244         hammer2_ioc_remote_t *remote = data;
 245         hammer2_pfs_t *pmp = ip->pmp;
 246         hammer2_dev_t *hmp;
 247         int copyid = remote->copyid;
 248         int error = 0;
 249
 250         hmp = pmp->pfs_hmps[0];
 251         if (hmp == NULL)
 252                 return (EINVAL);
 253         if (copyid >= HAMMER2_COPYID_COUNT)
 254                 return (EINVAL);
 255
 256         hammer2_voldata_lock(hmp);
 257         if (copyid < 0) {
 258                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
 259                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
 260                                 break;
 261                 }
 262                 if (copyid == HAMMER2_COPYID_COUNT) {
 263                         error = ENOSPC;
 264                         goto failed;
 265                 }
 266         }
 267         hammer2_voldata_modify(hmp);
 268         remote->copy1.copyid = copyid;
 269         hmp->voldata.copyinfo[copyid] = remote->copy1;
 270         hammer2_volconf_update(hmp, copyid);
 271 failed:
 272         hammer2_voldata_unlock(hmp);
 273         return (error);
 274 }
 275
 276 /*
 277  * Delete existing remote entry
 278  */
 279 static int
 280 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
 281 {
 282         hammer2_ioc_remote_t *remote = data;
 283         hammer2_pfs_t *pmp = ip->pmp;
 284         hammer2_dev_t *hmp;
 285         int copyid = remote->copyid;
 286         int error = 0;
 287
 288         hmp = pmp->pfs_hmps[0];
 289         if (hmp == NULL)
 290                 return (EINVAL);
 291         if (copyid >= HAMMER2_COPYID_COUNT)
 292                 return (EINVAL);
 293         remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
 294         hammer2_voldata_lock(hmp);
 295         if (copyid < 0) {
 296                 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
 297                         if (hmp->voldata.copyinfo[copyid].copyid == 0)
 298                                 continue;
 299                         if (strcmp(remote->copy1.path,
 300                             hmp->voldata.copyinfo[copyid].path) == 0) {
 301                                 break;
 302                         }
 303                 }
 304                 if (copyid == HAMMER2_COPYID_COUNT) {
 305                         error = ENOENT;
 306                         goto failed;
 307                 }
 308         }
 309         hammer2_voldata_modify(hmp);
 310         hmp->voldata.copyinfo[copyid].copyid = 0;
 311         hammer2_volconf_update(hmp, copyid);
 312 failed:
 313         hammer2_voldata_unlock(hmp);
 314         return (error);
 315 }
 316
 317 /*
 318  * Replace existing remote entry
 319  */
 320 static int
 321 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
 322 {
 323         hammer2_ioc_remote_t *remote = data;
 324         hammer2_dev_t *hmp;
 325         int copyid = remote->copyid;
 326
 327         hmp = ip->pmp->pfs_hmps[0];
 328         if (hmp == NULL)
 329                 return (EINVAL);
 330         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 331                 return (EINVAL);
 332
 333         hammer2_voldata_lock(hmp);
 334         hammer2_voldata_modify(hmp);
 335         /*hammer2_volconf_update(hmp, copyid);*/
 336         hammer2_voldata_unlock(hmp);
 337
 338         return(0);
 339 }
 340
 341 /*
 342  * Retrieve communications socket
 343  */
 344 static int
 345 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
 346 {
 347         return (EOPNOTSUPP);
 348 }
 349
 350 /*
 351  * Set communications socket for connection
 352  */
 353 static int
 354 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
 355 {
 356         hammer2_ioc_remote_t *remote = data;
 357         hammer2_dev_t *hmp;
 358         int copyid = remote->copyid;
 359
 360         hmp = ip->pmp->pfs_hmps[0];
 361         if (hmp == NULL)
 362                 return (EINVAL);
 363         if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
 364                 return (EINVAL);
 365
 366         hammer2_voldata_lock(hmp);
 367         hammer2_voldata_unlock(hmp);
 368
 369         return(0);
 370 }
 371
 372 /*
 373  * Used to scan and retrieve PFS information.  PFS's are directories under
 374  * the super-root.
 375  *
 376  * To scan PFSs pass name_key=0.  The function will scan for the next
 377  * PFS and set all fields, as well as set name_next to the next key.
 378  * When no PFSs remain, name_next is set to (hammer2_key_t)-1.
 379  *
 380  * To retrieve a particular PFS by key, specify the key but note that
 381  * the ioctl will return the lowest key >= specified_key, so the caller
 382  * must verify the key.
 383  *
 384  * To retrieve the PFS associated with the file descriptor, pass
 385  * name_key set to (hammer2_key_t)-1.
 386  */
 387 static int
 388 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
 389 {
 390         const hammer2_inode_data_t *ripdata;
 391         hammer2_dev_t *hmp;
 392         hammer2_ioc_pfs_t *pfs;
 393         hammer2_chain_t *parent;
 394         hammer2_chain_t *chain;
 395         hammer2_key_t key_next;
 396         hammer2_key_t save_key;
 397         int cache_index = -1;
 398         int error;
 399
 400         hmp = ip->pmp->pfs_hmps[0];
 401         if (hmp == NULL)
 402                 return (EINVAL);
 403
 404         pfs = data;
 405         save_key = pfs->name_key;
 406         error = 0;
 407
 408         /*
 409          * Setup
 410          */
 411         if (save_key == (hammer2_key_t)-1) {
 412                 hammer2_inode_lock(ip->pmp->iroot, 0);
 413                 parent = NULL;
 414                 chain = hammer2_inode_chain(hmp->spmp->iroot, 0,
 415                                             HAMMER2_RESOLVE_ALWAYS |
 416                                             HAMMER2_RESOLVE_SHARED);
 417         } else {
 418                 hammer2_inode_lock(hmp->spmp->iroot, 0);
 419                 parent = hammer2_inode_chain(hmp->spmp->iroot, 0,
 420                                             HAMMER2_RESOLVE_ALWAYS |
 421                                             HAMMER2_RESOLVE_SHARED);
 422                 chain = hammer2_chain_lookup(&parent, &key_next,
 423                                             pfs->name_key, HAMMER2_KEY_MAX,
 424                                             &cache_index,
 425                                             HAMMER2_LOOKUP_SHARED);
 426         }
 427
 428         /*
 429          * Locate next PFS
 430          */
 431         while (chain) {
 432                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE)
 433                         break;
 434                 if (parent == NULL) {
 435                         hammer2_chain_unlock(chain);
 436                         hammer2_chain_drop(chain);
 437                         chain = NULL;
 438                         break;
 439                 }
 440                 chain = hammer2_chain_next(&parent, chain, &key_next,
 441                                             key_next, HAMMER2_KEY_MAX,
 442                                             &cache_index,
 443                                             HAMMER2_LOOKUP_SHARED);
 444         }
 445
 446         /*
 447          * Load the data being returned by the ioctl.
 448          */
 449         if (chain) {
 450                 ripdata = &chain->data->ipdata;
 451                 pfs->name_key = ripdata->meta.name_key;
 452                 pfs->pfs_type = ripdata->meta.pfs_type;
 453                 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
 454                 pfs->pfs_clid = ripdata->meta.pfs_clid;
 455                 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
 456                 KKASSERT(ripdata->meta.name_len < sizeof(pfs->name));
 457                 bcopy(ripdata->filename, pfs->name, ripdata->meta.name_len);
 458                 pfs->name[ripdata->meta.name_len] = 0;
 459                 ripdata = NULL; /* safety */
 460
 461                 /*
 462                  * Calculate name_next, if any.
 463                  */
 464                 if (parent == NULL) {
 465                         pfs->name_next = (hammer2_key_t)-1;
 466                 } else {
 467                         chain = hammer2_chain_next(&parent, chain, &key_next,
 468                                                     key_next, HAMMER2_KEY_MAX,
 469                                                     &cache_index,
 470                                                     HAMMER2_LOOKUP_SHARED);
 471                         if (chain)
 472                                 pfs->name_next = chain->bref.key;
 473                         else
 474                                 pfs->name_next = (hammer2_key_t)-1;
 475                 }
 476         } else {
 477                 pfs->name_next = (hammer2_key_t)-1;
 478                 error = ENOENT;
 479         }
 480
 481         /*
 482          * Cleanup
 483          */
 484         if (chain) {
 485                 hammer2_chain_unlock(chain);
 486                 hammer2_chain_drop(chain);
 487         }
 488         if (parent) {
 489                 hammer2_chain_unlock(parent);
 490                 hammer2_chain_drop(parent);
 491         }
 492         if (save_key == (hammer2_key_t)-1) {
 493                 hammer2_inode_unlock(ip->pmp->iroot);
 494         } else {
 495                 hammer2_inode_unlock(hmp->spmp->iroot);
 496         }
 497
 498         return (error);
 499 }
 500
 501 /*
 502  * Find a specific PFS by name
 503  */
 504 static int
 505 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
 506 {
 507         const hammer2_inode_data_t *ripdata;
 508         hammer2_dev_t *hmp;
 509         hammer2_ioc_pfs_t *pfs;
 510         hammer2_chain_t *parent;
 511         hammer2_chain_t *chain;
 512         hammer2_key_t key_next;
 513         hammer2_key_t lhc;
 514         int cache_index = -1;
 515         int error;
 516         size_t len;
 517
 518         hmp = ip->pmp->pfs_hmps[0];
 519         if (hmp == NULL)
 520                 return (EINVAL);
 521
 522         pfs = data;
 523         error = 0;
 524
 525         hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_SHARED);
 526         parent = hammer2_inode_chain(hmp->spmp->iroot, 0,
 527                                      HAMMER2_RESOLVE_ALWAYS |
 528                                      HAMMER2_RESOLVE_SHARED);
 529
 530         pfs->name[sizeof(pfs->name) - 1] = 0;
 531         len = strlen(pfs->name);
 532         lhc = hammer2_dirhash(pfs->name, len);
 533
 534         chain = hammer2_chain_lookup(&parent, &key_next,
 535                                          lhc, lhc + HAMMER2_DIRHASH_LOMASK,
 536                                          &cache_index,
 537                                          HAMMER2_LOOKUP_SHARED);
 538         while (chain) {
 539                 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE) {
 540                         ripdata = &chain->data->ipdata;
 541                         if (ripdata->meta.name_len == len &&
 542                             bcmp(ripdata->filename, pfs->name, len) == 0) {
 543                                 break;
 544                         }
 545                         ripdata = NULL; /* safety */
 546                 }
 547                 chain = hammer2_chain_next(&parent, chain, &key_next,
 548                                            key_next,
 549                                            lhc + HAMMER2_DIRHASH_LOMASK,
 550                                            &cache_index,
 551                                            HAMMER2_LOOKUP_SHARED);
 552         }
 553
 554         /*
 555          * Load the data being returned by the ioctl.
 556          */
 557         if (chain) {
 558                 ripdata = &chain->data->ipdata;
 559                 pfs->name_key = ripdata->meta.name_key;
 560                 pfs->pfs_type = ripdata->meta.pfs_type;
 561                 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
 562                 pfs->pfs_clid = ripdata->meta.pfs_clid;
 563                 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
 564                 ripdata = NULL;
 565
 566                 hammer2_chain_unlock(chain);
 567                 hammer2_chain_drop(chain);
 568         } else {
 569                 error = ENOENT;
 570         }
 571         if (parent) {
 572                 hammer2_chain_unlock(parent);
 573                 hammer2_chain_drop(parent);
 574         }
 575         hammer2_inode_unlock(hmp->spmp->iroot);
 576
 577         return (error);
 578 }
 579
 580 /*
 581  * Create a new PFS under the super-root
 582  */
 583 static int
 584 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
 585 {
 586         hammer2_inode_data_t *nipdata;
 587         hammer2_chain_t *nchain;
 588         hammer2_dev_t *hmp;
 589         hammer2_ioc_pfs_t *pfs;
 590         hammer2_inode_t *nip;
 591         int error;
 592
 593         hmp = ip->pmp->pfs_hmps[0];
 594         if (hmp == NULL)
 595                 return (EINVAL);
 596
 597         pfs = data;
 598         nip = NULL;
 599
 600         if (pfs->name[0] == 0)
 601                 return(EINVAL);
 602         pfs->name[sizeof(pfs->name) - 1] = 0;   /* ensure 0-termination */
 603
 604         if (hammer2_ioctl_pfs_lookup(ip, pfs) == 0)
 605                 return(EEXIST);
 606
 607         hammer2_trans_init(hmp->spmp, 0);
 608         nip = hammer2_inode_create(hmp->spmp->iroot, NULL, NULL,
 609                                    pfs->name, strlen(pfs->name), 0,
 610                                    1, HAMMER2_OBJTYPE_DIRECTORY, 0,
 611                                    HAMMER2_INSERT_PFSROOT, &error);
 612         kprintf("E %p %d\n", nip, error);
 613         if (error == 0) {
 614                 hammer2_inode_modify(nip);
 615                 nchain = hammer2_inode_chain(nip, 0, HAMMER2_RESOLVE_ALWAYS);
 616                 hammer2_chain_modify(nchain, 0);
 617                 nipdata = &nchain->data->ipdata;
 618
 619                 nip->meta.pfs_type = pfs->pfs_type;
 620                 nip->meta.pfs_subtype = pfs->pfs_subtype;
 621                 nip->meta.pfs_clid = pfs->pfs_clid;
 622                 nip->meta.pfs_fsid = pfs->pfs_fsid;
 623                 nip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
 624
 625                 /*
 626                  * Set default compression and check algorithm.  This
 627                  * can be changed later.
 628                  *
 629                  * Do not allow compression on PFS's with the special name
 630                  * "boot", the boot loader can't decompress (yet).
 631                  */
 632                 nip->meta.comp_algo =
 633                         HAMMER2_ENC_ALGO(HAMMER2_COMP_NEWFS_DEFAULT);
 634                 nip->meta.check_algo =
 635                         HAMMER2_ENC_ALGO( HAMMER2_CHECK_ISCSI32);
 636
 637                 if (strcasecmp(pfs->name, "boot") == 0) {
 638                         nip->meta.comp_algo =
 639                                 HAMMER2_ENC_ALGO(HAMMER2_COMP_AUTOZERO);
 640                 }
 641
 642 #if 0
 643                 hammer2_blockref_t bref;
 644                 /* XXX new PFS needs to be rescanned / added */
 645                 bref = nchain->bref;
 646                 kprintf("ADD LOCAL PFS (IOCTL): %s\n", nipdata->filename);
 647                 hammer2_pfsalloc(nchain, nipdata, bref.modify_tid);
 648 #endif
 649                 /* XXX rescan */
 650                 hammer2_chain_unlock(nchain);
 651                 hammer2_chain_drop(nchain);
 652
 653                 /*
 654                  * Super-root isn't mounted, fsync it
 655                  */
 656                 hammer2_inode_ref(nip);
 657                 hammer2_inode_unlock(nip);
 658                 hammer2_inode_fsync(nip);
 659                 hammer2_inode_drop(nip);
 660         }
 661         hammer2_trans_done(hmp->spmp);
 662
 663         return (error);
 664 }
 665
 666 /*
 667  * Destroy an existing PFS under the super-root
 668  */
 669 static int
 670 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
 671 {
 672         hammer2_ioc_pfs_t *pfs = data;
 673         hammer2_dev_t   *hmp;
 674         hammer2_pfs_t   *spmp;
 675         hammer2_xop_unlink_t *xop;
 676         hammer2_inode_t *dip;
 677         int error;
 678
 679         pfs->name[sizeof(pfs->name) - 1] = 0;   /* ensure termination */
 680
 681         hmp = ip->pmp->pfs_hmps[0];
 682         if (hmp == NULL)
 683                 return (EINVAL);
 684
 685         spmp = hmp->spmp;
 686         dip = spmp->iroot;
 687         hammer2_trans_init(spmp, 0);
 688         hammer2_inode_lock(dip, 0);
 689
 690         xop = &hammer2_xop_alloc(dip)->xop_unlink;
 691         hammer2_xop_setname(&xop->head, pfs->name, strlen(pfs->name));
 692         xop->isdir = 2;
 693         xop->dopermanent = 1;
 694         hammer2_xop_start(&xop->head, hammer2_xop_unlink);
 695
 696         error = hammer2_xop_collect(&xop->head, 0);
 697
 698         hammer2_inode_unlock(dip);
 699         hammer2_trans_done(spmp);
 700
 701         return (error);
 702 }
 703
 704 static int
 705 hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
 706 {
 707         hammer2_ioc_pfs_t *pfs = data;
 708         hammer2_dev_t   *hmp;
 709         hammer2_chain_t *chain;
 710         int error;
 711
 712         if (pfs->name[0] == 0)
 713                 return(EINVAL);
 714         if (pfs->name[sizeof(pfs->name)-1] != 0)
 715                 return(EINVAL);
 716
 717         hmp = ip->pmp->pfs_hmps[0];
 718         if (hmp == NULL)
 719                 return (EINVAL);
 720
 721         hammer2_vfs_sync(ip->pmp->mp, MNT_WAIT);
 722
 723         hammer2_trans_init(ip->pmp, HAMMER2_TRANS_ISFLUSH);
 724         hammer2_inode_lock(ip, 0);
 725
 726         chain = hammer2_inode_chain(ip, 0, HAMMER2_RESOLVE_ALWAYS);
 727         error = hammer2_chain_snapshot(chain, pfs);
 728         hammer2_chain_unlock(chain);
 729         hammer2_chain_drop(chain);
 730
 731         hammer2_inode_unlock(ip);
 732         hammer2_trans_done(ip->pmp);
 733
 734         return (error);
 735 }
 736
 737 /*
 738  * Retrieve the raw inode structure, non-inclusive of node-specific data.
 739  */
 740 static int
 741 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
 742 {
 743         hammer2_ioc_inode_t *ino;
 744         hammer2_chain_t *chain;
 745         int error;
 746         int i;
 747
 748         ino = data;
 749         error = 0;
 750
 751         hammer2_inode_lock(ip, HAMMER2_RESOLVE_SHARED);
 752         ino->data_count = 0;
 753         ino->inode_count = 0;
 754         for (i = 0; i < ip->cluster.nchains; ++i) {
 755                 if ((chain = ip->cluster.array[i].chain) != NULL) {
 756                         if (ino->data_count < chain->bref.data_count)
 757                                 ino->data_count = chain->bref.data_count;
 758                         if (ino->inode_count < chain->bref.inode_count)
 759                                 ino->inode_count = chain->bref.inode_count;
 760                 }
 761         }
 762         bzero(&ino->ip_data, sizeof(ino->ip_data));
 763         ino->ip_data.meta = ip->meta;
 764         ino->kdata = ip;
 765         hammer2_inode_unlock(ip);
 766
 767         return error;
 768 }
 769
 770 /*
 771  * Set various parameters in an inode which cannot be set through
 772  * normal filesystem VNOPS.
 773  */
 774 static int
 775 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
 776 {
 777         hammer2_ioc_inode_t *ino = data;
 778         int error = 0;
 779
 780         hammer2_trans_init(ip->pmp, 0);
 781         hammer2_inode_lock(ip, 0);
 782
 783         if ((ino->flags & HAMMER2IOC_INODE_FLAG_CHECK) &&
 784             ip->meta.check_algo != ino->ip_data.meta.check_algo) {
 785                 hammer2_inode_modify(ip);
 786                 ip->meta.check_algo = ino->ip_data.meta.check_algo;
 787         }
 788         if ((ino->flags & HAMMER2IOC_INODE_FLAG_COMP) &&
 789             ip->meta.comp_algo != ino->ip_data.meta.comp_algo) {
 790                 hammer2_inode_modify(ip);
 791                 ip->meta.comp_algo = ino->ip_data.meta.comp_algo;
 792         }
 793         ino->kdata = ip;
 794
 795         /* Ignore these flags for now...*/
 796         if ((ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) &&
 797             ip->meta.inode_quota != ino->ip_data.meta.inode_quota) {
 798                 hammer2_inode_modify(ip);
 799                 ip->meta.inode_quota = ino->ip_data.meta.inode_quota;
 800         }
 801         if ((ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) &&
 802             ip->meta.data_quota != ino->ip_data.meta.data_quota) {
 803                 hammer2_inode_modify(ip);
 804                 ip->meta.data_quota = ino->ip_data.meta.data_quota;
 805         }
 806         if ((ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) &&
 807             ip->meta.ncopies != ino->ip_data.meta.ncopies) {
 808                 hammer2_inode_modify(ip);
 809                 ip->meta.ncopies = ino->ip_data.meta.ncopies;
 810         }
 811         hammer2_inode_unlock(ip);
 812         hammer2_trans_done(ip->pmp);
 813
 814         return (error);
 815 }
 816
 817 static
 818 int
 819 hammer2_ioctl_debug_dump(hammer2_inode_t *ip)
 820 {
 821         hammer2_chain_t *chain;
 822         int count = 1000;
 823         int i;
 824
 825         for (i = 0; i < ip->cluster.nchains; ++i) {
 826                 chain = ip->cluster.array[i].chain;
 827                 if (chain == NULL)
 828                         continue;
 829                 hammer2_dump_chain(chain, 0, &count, 'i');
 830         }
 831         return 0;
 832 }
 833
 834 static
 835 int
 836 hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data)
 837 {
 838         hammer2_ioc_bulkfree_t *bfi = data;
 839         hammer2_dev_t *hmp;
 840         int error;
 841
 842         hmp = ip->pmp->pfs_hmps[0];
 843         if (hmp == NULL)
 844                 return (EINVAL);
 845
 846         /* XXX run local cluster targets only */
 847         error = hammer2_bulkfree_pass(hmp, bfi);
 848
 849         return error;
 850 }