2 * Copyright (c) 2011-2015 The DragonFly Project. All rights reserved.
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>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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
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.
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
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.
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);
67 hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
73 * Standard root cred checks, will be selectively ignored below
74 * for ioctls that do not require root creds.
76 error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
79 case HAMMER2IOC_VERSION_GET:
80 error = hammer2_ioctl_version_get(ip, data);
82 case HAMMER2IOC_RECLUSTER:
84 error = hammer2_ioctl_recluster(ip, data);
86 case HAMMER2IOC_REMOTE_SCAN:
88 error = hammer2_ioctl_remote_scan(ip, data);
90 case HAMMER2IOC_REMOTE_ADD:
92 error = hammer2_ioctl_remote_add(ip, data);
94 case HAMMER2IOC_REMOTE_DEL:
96 error = hammer2_ioctl_remote_del(ip, data);
98 case HAMMER2IOC_REMOTE_REP:
100 error = hammer2_ioctl_remote_rep(ip, data);
102 case HAMMER2IOC_SOCKET_GET:
104 error = hammer2_ioctl_socket_get(ip, data);
106 case HAMMER2IOC_SOCKET_SET:
108 error = hammer2_ioctl_socket_set(ip, data);
110 case HAMMER2IOC_PFS_GET:
112 error = hammer2_ioctl_pfs_get(ip, data);
114 case HAMMER2IOC_PFS_LOOKUP:
116 error = hammer2_ioctl_pfs_lookup(ip, data);
118 case HAMMER2IOC_PFS_CREATE:
120 error = hammer2_ioctl_pfs_create(ip, data);
122 case HAMMER2IOC_PFS_DELETE:
124 error = hammer2_ioctl_pfs_delete(ip, data);
126 case HAMMER2IOC_PFS_SNAPSHOT:
128 error = hammer2_ioctl_pfs_snapshot(ip, data);
130 case HAMMER2IOC_INODE_GET:
131 error = hammer2_ioctl_inode_get(ip, data);
133 case HAMMER2IOC_INODE_SET:
135 error = hammer2_ioctl_inode_set(ip, data);
137 case HAMMER2IOC_BULKFREE_SCAN:
138 error = hammer2_ioctl_bulkfree_scan(ip, data);
140 /*case HAMMER2IOC_INODE_COMP_SET:
141 error = hammer2_ioctl_inode_comp_set(ip, data);
143 case HAMMER2IOC_INODE_COMP_REC_SET:
144 error = hammer2_ioctl_inode_comp_rec_set(ip, data);
146 case HAMMER2IOC_INODE_COMP_REC_SET2:
147 error = hammer2_ioctl_inode_comp_rec_set2(ip, data);
149 case HAMMER2IOC_DEBUG_DUMP:
150 error = hammer2_ioctl_debug_dump(ip);
160 * Retrieve version and basic info
163 hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
165 hammer2_ioc_version_t *version = data;
168 hmp = ip->pmp->pfs_hmps[0];
170 version->version = hmp->voldata.version;
172 version->version = -1;
177 hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
179 hammer2_ioc_recluster_t *recl = data;
181 hammer2_cluster_t *cluster;
184 fp = holdfp(curproc->p_fd, recl->fd, -1);
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");
192 hammer2_cluster_reconnect(cluster->focus->hmp, fp);
203 * Retrieve information about a remote
206 hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
209 hammer2_ioc_remote_t *remote = data;
210 int copyid = remote->copyid;
212 hmp = ip->pmp->pfs_hmps[0];
216 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
219 hammer2_voldata_lock(hmp);
220 remote->copy1 = hmp->voldata.copyinfo[copyid];
221 hammer2_voldata_unlock(hmp);
224 * Adjust nextid (GET only)
226 while (++copyid < HAMMER2_COPYID_COUNT &&
227 hmp->voldata.copyinfo[copyid].copyid == 0) {
230 if (copyid == HAMMER2_COPYID_COUNT)
233 remote->nextid = copyid;
239 * Add new remote entry
242 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
244 hammer2_ioc_remote_t *remote = data;
245 hammer2_pfs_t *pmp = ip->pmp;
247 int copyid = remote->copyid;
250 hmp = pmp->pfs_hmps[0];
253 if (copyid >= HAMMER2_COPYID_COUNT)
256 hammer2_voldata_lock(hmp);
258 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
259 if (hmp->voldata.copyinfo[copyid].copyid == 0)
262 if (copyid == HAMMER2_COPYID_COUNT) {
267 hammer2_voldata_modify(hmp);
268 remote->copy1.copyid = copyid;
269 hmp->voldata.copyinfo[copyid] = remote->copy1;
270 hammer2_volconf_update(hmp, copyid);
272 hammer2_voldata_unlock(hmp);
277 * Delete existing remote entry
280 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
282 hammer2_ioc_remote_t *remote = data;
283 hammer2_pfs_t *pmp = ip->pmp;
285 int copyid = remote->copyid;
288 hmp = pmp->pfs_hmps[0];
291 if (copyid >= HAMMER2_COPYID_COUNT)
293 remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
294 hammer2_voldata_lock(hmp);
296 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
297 if (hmp->voldata.copyinfo[copyid].copyid == 0)
299 if (strcmp(remote->copy1.path,
300 hmp->voldata.copyinfo[copyid].path) == 0) {
304 if (copyid == HAMMER2_COPYID_COUNT) {
309 hammer2_voldata_modify(hmp);
310 hmp->voldata.copyinfo[copyid].copyid = 0;
311 hammer2_volconf_update(hmp, copyid);
313 hammer2_voldata_unlock(hmp);
318 * Replace existing remote entry
321 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
323 hammer2_ioc_remote_t *remote = data;
325 int copyid = remote->copyid;
327 hmp = ip->pmp->pfs_hmps[0];
330 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
333 hammer2_voldata_lock(hmp);
334 hammer2_voldata_modify(hmp);
335 /*hammer2_volconf_update(hmp, copyid);*/
336 hammer2_voldata_unlock(hmp);
342 * Retrieve communications socket
345 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
351 * Set communications socket for connection
354 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
356 hammer2_ioc_remote_t *remote = data;
358 int copyid = remote->copyid;
360 hmp = ip->pmp->pfs_hmps[0];
363 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
366 hammer2_voldata_lock(hmp);
367 hammer2_voldata_unlock(hmp);
373 * Used to scan and retrieve PFS information. PFS's are directories under
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.
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.
384 * To retrieve the PFS associated with the file descriptor, pass
385 * name_key set to (hammer2_key_t)-1.
388 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
390 const hammer2_inode_data_t *ripdata;
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;
400 hmp = ip->pmp->pfs_hmps[0];
405 save_key = pfs->name_key;
411 if (save_key == (hammer2_key_t)-1) {
412 hammer2_inode_lock(ip->pmp->iroot, 0);
414 chain = hammer2_inode_chain(hmp->spmp->iroot, 0,
415 HAMMER2_RESOLVE_ALWAYS |
416 HAMMER2_RESOLVE_SHARED);
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,
425 HAMMER2_LOOKUP_SHARED);
432 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE)
434 if (parent == NULL) {
435 hammer2_chain_unlock(chain);
436 hammer2_chain_drop(chain);
440 chain = hammer2_chain_next(&parent, chain, &key_next,
441 key_next, HAMMER2_KEY_MAX,
443 HAMMER2_LOOKUP_SHARED);
447 * Load the data being returned by the ioctl.
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 */
462 * Calculate name_next, if any.
464 if (parent == NULL) {
465 pfs->name_next = (hammer2_key_t)-1;
467 chain = hammer2_chain_next(&parent, chain, &key_next,
468 key_next, HAMMER2_KEY_MAX,
470 HAMMER2_LOOKUP_SHARED);
472 pfs->name_next = chain->bref.key;
474 pfs->name_next = (hammer2_key_t)-1;
477 pfs->name_next = (hammer2_key_t)-1;
485 hammer2_chain_unlock(chain);
486 hammer2_chain_drop(chain);
489 hammer2_chain_unlock(parent);
490 hammer2_chain_drop(parent);
492 if (save_key == (hammer2_key_t)-1) {
493 hammer2_inode_unlock(ip->pmp->iroot);
495 hammer2_inode_unlock(hmp->spmp->iroot);
502 * Find a specific PFS by name
505 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
507 const hammer2_inode_data_t *ripdata;
509 hammer2_ioc_pfs_t *pfs;
510 hammer2_chain_t *parent;
511 hammer2_chain_t *chain;
512 hammer2_key_t key_next;
514 int cache_index = -1;
518 hmp = ip->pmp->pfs_hmps[0];
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);
530 pfs->name[sizeof(pfs->name) - 1] = 0;
531 len = strlen(pfs->name);
532 lhc = hammer2_dirhash(pfs->name, len);
534 chain = hammer2_chain_lookup(&parent, &key_next,
535 lhc, lhc + HAMMER2_DIRHASH_LOMASK,
537 HAMMER2_LOOKUP_SHARED);
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) {
545 ripdata = NULL; /* safety */
547 chain = hammer2_chain_next(&parent, chain, &key_next,
549 lhc + HAMMER2_DIRHASH_LOMASK,
551 HAMMER2_LOOKUP_SHARED);
555 * Load the data being returned by the ioctl.
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;
566 hammer2_chain_unlock(chain);
567 hammer2_chain_drop(chain);
572 hammer2_chain_unlock(parent);
573 hammer2_chain_drop(parent);
575 hammer2_inode_unlock(hmp->spmp->iroot);
581 * Create a new PFS under the super-root
584 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
586 hammer2_inode_data_t *nipdata;
587 hammer2_chain_t *nchain;
589 hammer2_ioc_pfs_t *pfs;
590 hammer2_inode_t *nip;
593 hmp = ip->pmp->pfs_hmps[0];
600 if (pfs->name[0] == 0)
602 pfs->name[sizeof(pfs->name) - 1] = 0; /* ensure 0-termination */
604 if (hammer2_ioctl_pfs_lookup(ip, pfs) == 0)
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);
613 hammer2_inode_modify(nip);
614 nchain = hammer2_inode_chain(nip, 0, HAMMER2_RESOLVE_ALWAYS);
615 hammer2_chain_modify(nchain, 0);
616 nipdata = &nchain->data->ipdata;
618 nip->meta.pfs_type = pfs->pfs_type;
619 nip->meta.pfs_subtype = pfs->pfs_subtype;
620 nip->meta.pfs_clid = pfs->pfs_clid;
621 nip->meta.pfs_fsid = pfs->pfs_fsid;
622 nip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
625 * Set default compression and check algorithm. This
626 * can be changed later.
628 * Do not allow compression on PFS's with the special name
629 * "boot", the boot loader can't decompress (yet).
631 nip->meta.comp_algo =
632 HAMMER2_ENC_ALGO(HAMMER2_COMP_NEWFS_DEFAULT);
633 nip->meta.check_algo =
634 HAMMER2_ENC_ALGO( HAMMER2_CHECK_ISCSI32);
636 if (strcasecmp(pfs->name, "boot") == 0) {
637 nip->meta.comp_algo =
638 HAMMER2_ENC_ALGO(HAMMER2_COMP_AUTOZERO);
641 hammer2_blockref_t bref;
642 /* XXX new PFS needs to be rescanned / added */
644 kprintf("ADD LOCAL PFS (IOCTL): %s\n", nipdata->filename);
645 hammer2_pfsalloc(nchain, nipdata, bref.modify_tid);
648 hammer2_chain_unlock(nchain);
649 hammer2_chain_drop(nchain);
651 hammer2_inode_unlock(nip);
653 hammer2_trans_done(hmp->spmp);
659 * Destroy an existing PFS under the super-root
662 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
664 hammer2_ioc_pfs_t *pfs = data;
667 hammer2_xop_unlink_t *xop;
668 hammer2_inode_t *dip;
671 pfs->name[sizeof(pfs->name) - 1] = 0; /* ensure termination */
673 hmp = ip->pmp->pfs_hmps[0];
679 hammer2_trans_init(spmp, 0);
680 hammer2_inode_lock(dip, 0);
682 xop = &hammer2_xop_alloc(dip)->xop_unlink;
683 hammer2_xop_setname(&xop->head, pfs->name, strlen(pfs->name));
685 xop->dopermanent = 1;
686 hammer2_xop_start(&xop->head, hammer2_xop_unlink);
688 error = hammer2_xop_collect(&xop->head, 0);
690 hammer2_inode_unlock(dip);
691 hammer2_trans_done(spmp);
697 hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
699 hammer2_ioc_pfs_t *pfs = data;
701 hammer2_chain_t *chain;
704 if (pfs->name[0] == 0)
706 if (pfs->name[sizeof(pfs->name)-1] != 0)
709 hmp = ip->pmp->pfs_hmps[0];
713 hammer2_vfs_sync(ip->pmp->mp, MNT_WAIT);
715 hammer2_trans_init(ip->pmp, HAMMER2_TRANS_ISFLUSH);
716 hammer2_inode_lock(ip, 0);
718 chain = hammer2_inode_chain(ip, 0, HAMMER2_RESOLVE_ALWAYS);
719 error = hammer2_chain_snapshot(chain, pfs);
720 hammer2_chain_unlock(chain);
721 hammer2_chain_drop(chain);
723 hammer2_inode_unlock(ip);
724 hammer2_trans_done(ip->pmp);
730 * Retrieve the raw inode structure, non-inclusive of node-specific data.
733 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
735 hammer2_ioc_inode_t *ino;
736 hammer2_chain_t *chain;
743 hammer2_inode_lock(ip, HAMMER2_RESOLVE_SHARED);
745 ino->inode_count = 0;
746 for (i = 0; i < ip->cluster.nchains; ++i) {
747 if ((chain = ip->cluster.array[i].chain) != NULL) {
748 if (ino->data_count < chain->bref.data_count)
749 ino->data_count = chain->bref.data_count;
750 if (ino->inode_count < chain->bref.inode_count)
751 ino->inode_count = chain->bref.inode_count;
754 bzero(&ino->ip_data, sizeof(ino->ip_data));
755 ino->ip_data.meta = ip->meta;
757 hammer2_inode_unlock(ip);
763 * Set various parameters in an inode which cannot be set through
764 * normal filesystem VNOPS.
767 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
769 hammer2_ioc_inode_t *ino = data;
772 hammer2_trans_init(ip->pmp, 0);
773 hammer2_inode_lock(ip, 0);
775 if ((ino->flags & HAMMER2IOC_INODE_FLAG_CHECK) &&
776 ip->meta.check_algo != ino->ip_data.meta.check_algo) {
777 hammer2_inode_modify(ip);
778 ip->meta.check_algo = ino->ip_data.meta.check_algo;
780 if ((ino->flags & HAMMER2IOC_INODE_FLAG_COMP) &&
781 ip->meta.comp_algo != ino->ip_data.meta.comp_algo) {
782 hammer2_inode_modify(ip);
783 ip->meta.comp_algo = ino->ip_data.meta.comp_algo;
787 /* Ignore these flags for now...*/
788 if ((ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) &&
789 ip->meta.inode_quota != ino->ip_data.meta.inode_quota) {
790 hammer2_inode_modify(ip);
791 ip->meta.inode_quota = ino->ip_data.meta.inode_quota;
793 if ((ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) &&
794 ip->meta.data_quota != ino->ip_data.meta.data_quota) {
795 hammer2_inode_modify(ip);
796 ip->meta.data_quota = ino->ip_data.meta.data_quota;
798 if ((ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) &&
799 ip->meta.ncopies != ino->ip_data.meta.ncopies) {
800 hammer2_inode_modify(ip);
801 ip->meta.ncopies = ino->ip_data.meta.ncopies;
803 hammer2_inode_unlock(ip);
804 hammer2_trans_done(ip->pmp);
811 hammer2_ioctl_debug_dump(hammer2_inode_t *ip)
813 hammer2_chain_t *chain;
817 for (i = 0; i < ip->cluster.nchains; ++i) {
818 chain = ip->cluster.array[i].chain;
821 hammer2_dump_chain(chain, 0, &count, 'i');
828 hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data)
830 hammer2_ioc_bulkfree_t *bfi = data;
834 hmp = ip->pmp->pfs_hmps[0];
838 /* XXX run local cluster targets only */
839 error = hammer2_bulkfree_pass(hmp, bfi);