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_dev_t *hmp = ip->pmp->iroot->cluster.focus->hmp;
166 hammer2_ioc_version_t *version = data;
168 version->version = hmp->voldata.version;
173 hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
175 hammer2_ioc_recluster_t *recl = data;
177 hammer2_cluster_t *cluster;
180 fp = holdfp(curproc->p_fd, recl->fd, -1);
182 kprintf("reconnect to cluster: XXX ");
183 cluster = &ip->pmp->iroot->cluster;
184 if (cluster->nchains != 1 || cluster->focus == NULL) {
185 kprintf("not a local device mount\n");
188 hammer2_cluster_reconnect(cluster->focus->hmp, fp);
199 * Retrieve information about a remote
202 hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
204 hammer2_dev_t *hmp = ip->pmp->iroot->cluster.focus->hmp;
205 hammer2_ioc_remote_t *remote = data;
206 int copyid = remote->copyid;
208 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
211 hammer2_voldata_lock(hmp);
212 remote->copy1 = hmp->voldata.copyinfo[copyid];
213 hammer2_voldata_unlock(hmp);
216 * Adjust nextid (GET only)
218 while (++copyid < HAMMER2_COPYID_COUNT &&
219 hmp->voldata.copyinfo[copyid].copyid == 0) {
222 if (copyid == HAMMER2_COPYID_COUNT)
225 remote->nextid = copyid;
231 * Add new remote entry
234 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
236 hammer2_ioc_remote_t *remote = data;
237 hammer2_pfs_t *pmp = ip->pmp;
239 int copyid = remote->copyid;
242 if (copyid >= HAMMER2_COPYID_COUNT)
245 hmp = pmp->iroot->cluster.focus->hmp; /* XXX */
246 hammer2_voldata_lock(hmp);
248 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
249 if (hmp->voldata.copyinfo[copyid].copyid == 0)
252 if (copyid == HAMMER2_COPYID_COUNT) {
257 hammer2_voldata_modify(hmp);
258 remote->copy1.copyid = copyid;
259 hmp->voldata.copyinfo[copyid] = remote->copy1;
260 hammer2_volconf_update(hmp, copyid);
262 hammer2_voldata_unlock(hmp);
267 * Delete existing remote entry
270 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
272 hammer2_ioc_remote_t *remote = data;
273 hammer2_pfs_t *pmp = ip->pmp;
275 int copyid = remote->copyid;
278 hmp = pmp->iroot->cluster.focus->hmp; /* XXX */
279 if (copyid >= HAMMER2_COPYID_COUNT)
281 remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
282 hammer2_voldata_lock(hmp);
284 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
285 if (hmp->voldata.copyinfo[copyid].copyid == 0)
287 if (strcmp(remote->copy1.path,
288 hmp->voldata.copyinfo[copyid].path) == 0) {
292 if (copyid == HAMMER2_COPYID_COUNT) {
297 hammer2_voldata_modify(hmp);
298 hmp->voldata.copyinfo[copyid].copyid = 0;
299 hammer2_volconf_update(hmp, copyid);
301 hammer2_voldata_unlock(hmp);
306 * Replace existing remote entry
309 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
311 hammer2_ioc_remote_t *remote = data;
313 int copyid = remote->copyid;
315 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
317 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
320 hammer2_voldata_lock(hmp);
321 hammer2_voldata_modify(hmp);
322 /*hammer2_volconf_update(hmp, copyid);*/
323 hammer2_voldata_unlock(hmp);
329 * Retrieve communications socket
332 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
338 * Set communications socket for connection
341 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
343 hammer2_ioc_remote_t *remote = data;
345 int copyid = remote->copyid;
347 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
348 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
351 hammer2_voldata_lock(hmp);
352 hammer2_voldata_unlock(hmp);
358 * Used to scan and retrieve PFS information. PFS's are directories under
361 * To scan PFSs pass name_key=0. The function will scan for the next
362 * PFS and set all fields, as well as set name_next to the next key.
363 * When no PFSs remain, name_next is set to (hammer2_key_t)-1.
365 * To retrieve the PFS associated with the file descriptor, pass
366 * name_key set to (hammer2_key_t)-1.
369 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
371 const hammer2_inode_data_t *ripdata;
373 hammer2_ioc_pfs_t *pfs;
374 hammer2_cluster_t *cparent;
375 hammer2_cluster_t *rcluster;
376 hammer2_cluster_t *cluster;
377 hammer2_key_t key_next;
381 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
383 hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_ALWAYS);
384 cparent = hammer2_inode_cluster(hmp->spmp->iroot,
385 HAMMER2_RESOLVE_ALWAYS);
386 hammer2_inode_lock(ip->pmp->iroot, HAMMER2_RESOLVE_ALWAYS);
387 rcluster = hammer2_inode_cluster(ip->pmp->iroot,
388 HAMMER2_RESOLVE_ALWAYS);
391 * Search for the first key or specific key. Remember that keys
392 * can be returned in any order.
394 if (pfs->name_key == 0) {
395 cluster = hammer2_cluster_lookup(cparent, &key_next,
396 0, (hammer2_key_t)-1,
398 } else if (pfs->name_key == (hammer2_key_t)-1) {
399 ripdata = &hammer2_cluster_rdata(rcluster)->ipdata;
400 cluster = hammer2_cluster_lookup(cparent, &key_next,
401 ripdata->meta.name_key,
402 ripdata->meta.name_key,
404 ripdata = NULL; /* safety */
406 cluster = hammer2_cluster_lookup(cparent, &key_next,
407 pfs->name_key, pfs->name_key,
410 hammer2_inode_unlock(ip->pmp->iroot, rcluster);
413 hammer2_cluster_type(cluster) != HAMMER2_BREF_TYPE_INODE) {
414 cluster = hammer2_cluster_next(cparent, cluster, &key_next,
415 key_next, (hammer2_key_t)-1,
420 * Load the data being returned by the ioctl.
422 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
423 pfs->name_key = ripdata->meta.name_key;
424 pfs->pfs_type = ripdata->meta.pfs_type;
425 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
426 pfs->pfs_clid = ripdata->meta.pfs_clid;
427 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
428 KKASSERT(ripdata->meta.name_len < sizeof(pfs->name));
429 bcopy(ripdata->filename, pfs->name, ripdata->meta.name_len);
430 pfs->name[ripdata->meta.name_len] = 0;
431 ripdata = NULL; /* safety */
434 * Calculate the next field
437 cluster = hammer2_cluster_next(cparent, cluster,
439 0, (hammer2_key_t)-1,
442 hammer2_cluster_type(cluster) !=
443 HAMMER2_BREF_TYPE_INODE);
445 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
446 pfs->name_next = ripdata->meta.name_key;
447 hammer2_cluster_unlock(cluster);
448 hammer2_cluster_drop(cluster);
450 pfs->name_next = (hammer2_key_t)-1;
453 pfs->name_next = (hammer2_key_t)-1;
456 hammer2_inode_unlock(hmp->spmp->iroot, cparent);
462 * Find a specific PFS by name
465 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
467 const hammer2_inode_data_t *ripdata;
469 hammer2_ioc_pfs_t *pfs;
470 hammer2_cluster_t *cparent;
471 hammer2_cluster_t *cluster;
472 hammer2_key_t key_next;
478 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
480 hammer2_inode_lock(hmp->spmp->iroot, HAMMER2_RESOLVE_ALWAYS |
481 HAMMER2_RESOLVE_SHARED);
482 cparent = hammer2_inode_cluster(hmp->spmp->iroot,
483 HAMMER2_RESOLVE_ALWAYS |
484 HAMMER2_RESOLVE_SHARED);
486 pfs->name[sizeof(pfs->name) - 1] = 0;
487 len = strlen(pfs->name);
488 lhc = hammer2_dirhash(pfs->name, len);
490 cluster = hammer2_cluster_lookup(cparent, &key_next,
491 lhc, lhc + HAMMER2_DIRHASH_LOMASK,
492 HAMMER2_LOOKUP_SHARED);
494 if (hammer2_cluster_type(cluster) == HAMMER2_BREF_TYPE_INODE) {
495 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
496 if (ripdata->meta.name_len == len &&
497 bcmp(ripdata->filename, pfs->name, len) == 0) {
500 ripdata = NULL; /* safety */
502 cluster = hammer2_cluster_next(cparent, cluster, &key_next,
504 lhc + HAMMER2_DIRHASH_LOMASK,
505 HAMMER2_LOOKUP_SHARED);
509 * Load the data being returned by the ioctl.
512 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
513 pfs->name_key = ripdata->meta.name_key;
514 pfs->pfs_type = ripdata->meta.pfs_type;
515 pfs->pfs_subtype = ripdata->meta.pfs_subtype;
516 pfs->pfs_clid = ripdata->meta.pfs_clid;
517 pfs->pfs_fsid = ripdata->meta.pfs_fsid;
520 hammer2_cluster_unlock(cluster);
521 hammer2_cluster_drop(cluster);
525 hammer2_inode_unlock(hmp->spmp->iroot, cparent);
531 * Create a new PFS under the super-root
534 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
536 hammer2_inode_data_t *nipdata;
537 hammer2_chain_t *nchain;
539 hammer2_ioc_pfs_t *pfs;
540 hammer2_inode_t *nip;
543 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
547 if (pfs->name[0] == 0)
549 pfs->name[sizeof(pfs->name) - 1] = 0; /* ensure 0-termination */
551 if (hammer2_ioctl_pfs_lookup(ip, pfs) == 0)
554 hammer2_trans_init(hmp->spmp, 0);
555 nip = hammer2_inode_create(hmp->spmp->iroot, NULL, NULL,
556 pfs->name, strlen(pfs->name),
557 HAMMER2_INSERT_PFSROOT, &error);
559 hammer2_inode_modify(nip);
560 nchain = hammer2_inode_chain(nip, 0, HAMMER2_RESOLVE_ALWAYS);
561 hammer2_chain_modify(nchain, 0);
562 nipdata = &nchain->data->ipdata;
564 nip->meta.pfs_type = pfs->pfs_type;
565 nip->meta.pfs_subtype = pfs->pfs_subtype;
566 nip->meta.pfs_clid = pfs->pfs_clid;
567 nip->meta.pfs_fsid = pfs->pfs_fsid;
568 nip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
571 * Set default compression and check algorithm. This
572 * can be changed later.
574 * Do not allow compression on PFS's with the special name
575 * "boot", the boot loader can't decompress (yet).
577 nip->meta.comp_algo =
578 HAMMER2_ENC_ALGO(HAMMER2_COMP_NEWFS_DEFAULT);
579 nip->meta.check_algo =
580 HAMMER2_ENC_ALGO( HAMMER2_CHECK_ISCSI32);
582 if (strcasecmp(pfs->name, "boot") == 0) {
583 nip->meta.comp_algo =
584 HAMMER2_ENC_ALGO(HAMMER2_COMP_AUTOZERO);
587 hammer2_blockref_t bref;
588 /* XXX new PFS needs to be rescanned / added */
590 kprintf("ADD LOCAL PFS (IOCTL): %s\n", nipdata->filename);
591 hammer2_pfsalloc(ncluster, nipdata, bref.modify_tid);
594 hammer2_chain_unlock(nchain);
595 hammer2_chain_drop(nchain);
597 hammer2_inode_unlock(nip, NULL);
599 hammer2_trans_done(hmp->spmp);
605 * Destroy an existing PFS under the super-root
608 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
611 hammer2_ioc_pfs_t *pfs = data;
614 hmp = ip->pmp->iroot->cluster.focus->hmp; /* XXX */
615 hammer2_trans_init(hmp->spmp, 0);
616 error = hammer2_unlink_file(hmp->spmp->iroot, NULL,
617 pfs->name, strlen(pfs->name),
619 hammer2_trans_done(hmp->spmp);
625 hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
627 hammer2_ioc_pfs_t *pfs = data;
628 hammer2_cluster_t *cparent;
631 if (pfs->name[0] == 0)
633 if (pfs->name[sizeof(pfs->name)-1] != 0)
636 hammer2_vfs_sync(ip->pmp->mp, MNT_WAIT);
638 hammer2_trans_init(ip->pmp, HAMMER2_TRANS_ISFLUSH);
639 hammer2_inode_lock(ip, HAMMER2_RESOLVE_ALWAYS);
640 cparent = hammer2_inode_cluster(ip, HAMMER2_RESOLVE_ALWAYS);
641 error = hammer2_cluster_snapshot(cparent, pfs);
642 hammer2_inode_unlock(ip, cparent);
643 hammer2_trans_done(ip->pmp);
649 * Retrieve the raw inode structure
652 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
654 const hammer2_inode_data_t *ripdata;
655 hammer2_ioc_inode_t *ino;
656 hammer2_cluster_t *cluster;
661 hammer2_inode_lock(ip, HAMMER2_RESOLVE_ALWAYS |
662 HAMMER2_RESOLVE_SHARED);
663 cluster = hammer2_inode_cluster(ip, HAMMER2_RESOLVE_ALWAYS |
664 HAMMER2_RESOLVE_SHARED);
665 if (cluster->error) {
668 ripdata = &hammer2_cluster_rdata(cluster)->ipdata;
669 ino->ip_data = *ripdata;
671 ino->data_count = cluster->focus->bref.data_count;
672 ino->inode_count = cluster->focus->bref.inode_count;
675 hammer2_inode_unlock(ip, cluster);
681 * Set various parameters in an inode which cannot be set through
682 * normal filesystem VNOPS.
685 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
687 const hammer2_inode_data_t *ripdata;
688 hammer2_inode_data_t *wipdata;
689 hammer2_ioc_inode_t *ino = data;
690 hammer2_cluster_t *cparent;
694 hammer2_trans_init(ip->pmp, 0);
695 hammer2_inode_lock(ip, HAMMER2_RESOLVE_ALWAYS);
696 cparent = hammer2_inode_cluster(ip, HAMMER2_RESOLVE_ALWAYS);
697 ripdata = &hammer2_cluster_rdata(cparent)->ipdata;
699 if (ino->ip_data.meta.check_algo != ripdata->meta.check_algo) {
700 wipdata = hammer2_cluster_modify_ip(ip, cparent, 0);
701 wipdata->meta.check_algo = ino->ip_data.meta.check_algo;
702 ripdata = wipdata; /* safety */
703 hammer2_cluster_setmethod_check(cparent,
704 wipdata->meta.check_algo);
707 if (ino->ip_data.meta.comp_algo != ripdata->meta.comp_algo) {
708 wipdata = hammer2_cluster_modify_ip(ip, cparent, 0);
709 wipdata->meta.comp_algo = ino->ip_data.meta.comp_algo;
710 ripdata = wipdata; /* safety */
715 /* Ignore these flags for now...*/
716 if (ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) {
718 if (ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) {
720 if (ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) {
723 hammer2_cluster_modsync(cparent);
724 hammer2_trans_done(ip->pmp);
725 hammer2_inode_unlock(ip, cparent);
732 hammer2_ioctl_debug_dump(hammer2_inode_t *ip)
734 hammer2_chain_t *chain;
738 for (i = 0; i < ip->cluster.nchains; ++i) {
739 chain = ip->cluster.array[i].chain;
742 hammer2_dump_chain(chain, 0, &count, 'i');
749 hammer2_ioctl_bulkfree_scan(hammer2_inode_t *ip, void *data)
751 hammer2_ioc_bulkfree_t *bfi = data;
752 hammer2_dev_t *hmp = ip->pmp->iroot->cluster.focus->hmp;
755 /* XXX run local cluster targets only */
756 error = hammer2_bulkfree_pass(hmp, bfi);