usb4bsd: FWIW, port usb_template and hook it into the build.
[dragonfly.git] / sys / vfs / hammer2 / hammer2_ioctl.c
CommitLineData
2910a90c 1/*
8138a154 2 * Copyright (c) 2011-2014 The DragonFly Project. All rights reserved.
2910a90c
MD
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
ae183399 45static int hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data);
1a34728c
MD
46static int hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data);
47static int hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data);
ae183399
MD
48static int hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data);
49static int hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data);
50static int hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data);
51static int hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data);
52static int hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data);
53static int hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data);
458ecb1b 54static int hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data);
ae183399 55static int hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data);
a864c5d9 56static int hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data);
ae183399 57static int hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data);
344d4f82
MD
58static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data);
59static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data);
355d67fc
MD
60//static int hammer2_ioctl_inode_comp_set(hammer2_inode_t *ip, void *data);
61//static int hammer2_ioctl_inode_comp_rec_set(hammer2_inode_t *ip, void *data);
62//static int hammer2_ioctl_inode_comp_rec_set2(hammer2_inode_t *ip, void *data);
2910a90c
MD
63
64int
65hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag,
66 struct ucred *cred)
67{
68 int error;
69
70 /*
71 * Standard root cred checks, will be selectively ignored below
72 * for ioctls that do not require root creds.
73 */
74 error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0);
75
76 switch(com) {
ae183399
MD
77 case HAMMER2IOC_VERSION_GET:
78 error = hammer2_ioctl_version_get(ip, data);
2910a90c 79 break;
1a34728c 80 case HAMMER2IOC_RECLUSTER:
2910a90c 81 if (error == 0)
1a34728c
MD
82 error = hammer2_ioctl_recluster(ip, data);
83 break;
84 case HAMMER2IOC_REMOTE_SCAN:
85 if (error == 0)
86 error = hammer2_ioctl_remote_scan(ip, data);
2910a90c 87 break;
ae183399 88 case HAMMER2IOC_REMOTE_ADD:
2910a90c 89 if (error == 0)
ae183399 90 error = hammer2_ioctl_remote_add(ip, data);
2910a90c 91 break;
ae183399 92 case HAMMER2IOC_REMOTE_DEL:
2910a90c 93 if (error == 0)
ae183399 94 error = hammer2_ioctl_remote_del(ip, data);
2910a90c 95 break;
ae183399 96 case HAMMER2IOC_REMOTE_REP:
2910a90c 97 if (error == 0)
ae183399 98 error = hammer2_ioctl_remote_rep(ip, data);
2910a90c 99 break;
ae183399 100 case HAMMER2IOC_SOCKET_GET:
2910a90c 101 if (error == 0)
ae183399 102 error = hammer2_ioctl_socket_get(ip, data);
2910a90c 103 break;
ae183399
MD
104 case HAMMER2IOC_SOCKET_SET:
105 if (error == 0)
106 error = hammer2_ioctl_socket_set(ip, data);
107 break;
108 case HAMMER2IOC_PFS_GET:
2910a90c 109 if (error == 0)
ae183399
MD
110 error = hammer2_ioctl_pfs_get(ip, data);
111 break;
458ecb1b
MD
112 case HAMMER2IOC_PFS_LOOKUP:
113 if (error == 0)
114 error = hammer2_ioctl_pfs_lookup(ip, data);
115 break;
ae183399
MD
116 case HAMMER2IOC_PFS_CREATE:
117 if (error == 0)
118 error = hammer2_ioctl_pfs_create(ip, data);
119 break;
120 case HAMMER2IOC_PFS_DELETE:
121 if (error == 0)
122 error = hammer2_ioctl_pfs_delete(ip, data);
2910a90c 123 break;
a864c5d9
MD
124 case HAMMER2IOC_PFS_SNAPSHOT:
125 if (error == 0)
126 error = hammer2_ioctl_pfs_snapshot(ip, data);
127 break;
344d4f82
MD
128 case HAMMER2IOC_INODE_GET:
129 error = hammer2_ioctl_inode_get(ip, data);
130 break;
131 case HAMMER2IOC_INODE_SET:
132 if (error == 0)
133 error = hammer2_ioctl_inode_set(ip, data);
134 break;
355d67fc
MD
135 /*case HAMMER2IOC_INODE_COMP_SET:
136 error = hammer2_ioctl_inode_comp_set(ip, data);
137 break;
138 case HAMMER2IOC_INODE_COMP_REC_SET:
139 error = hammer2_ioctl_inode_comp_rec_set(ip, data);
140 break;
141 case HAMMER2IOC_INODE_COMP_REC_SET2:
142 error = hammer2_ioctl_inode_comp_rec_set2(ip, data);
143 break;*/
2910a90c
MD
144 default:
145 error = EOPNOTSUPP;
146 break;
147 }
148 return (error);
149}
150
151/*
152 * Retrieve version and basic info
153 */
154static int
ae183399 155hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data)
2910a90c 156{
7bed8d7e 157 hammer2_mount_t *hmp = ip->pmp->cluster.chains[0]->hmp;
2910a90c
MD
158 hammer2_ioc_version_t *version = data;
159
160 version->version = hmp->voldata.version;
161 return 0;
162}
163
1a34728c
MD
164static int
165hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data)
166{
167 hammer2_ioc_recluster_t *recl = data;
168 struct file *fp;
169
170 fp = holdfp(curproc->p_fd, recl->fd, -1);
171 if (fp) {
172 kprintf("reconnect to cluster\n");
173 hammer2_cluster_reconnect(ip->pmp, fp);
174 return 0;
175 } else {
176 return EINVAL;
177 }
178}
179
2910a90c
MD
180/*
181 * Retrieve information about a remote
182 */
183static int
1a34728c 184hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data)
2910a90c 185{
7bed8d7e 186 hammer2_mount_t *hmp = ip->pmp->cluster.chains[0]->hmp;
2910a90c
MD
187 hammer2_ioc_remote_t *remote = data;
188 int copyid = remote->copyid;
189
190 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
191 return (EINVAL);
192
193 hammer2_voldata_lock(hmp);
194 remote->copy1 = hmp->voldata.copyinfo[copyid];
0dea3156 195 hammer2_voldata_unlock(hmp, 0);
2910a90c
MD
196
197 /*
198 * Adjust nextid (GET only)
199 */
200 while (++copyid < HAMMER2_COPYID_COUNT &&
201 hmp->voldata.copyinfo[copyid].copyid == 0) {
1a34728c 202 ;
2910a90c
MD
203 }
204 if (copyid == HAMMER2_COPYID_COUNT)
205 remote->nextid = -1;
206 else
207 remote->nextid = copyid;
208
209 return(0);
210}
211
212/*
213 * Add new remote entry
214 */
215static int
ae183399 216hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data)
2910a90c 217{
2910a90c 218 hammer2_ioc_remote_t *remote = data;
a5913bdf
MD
219 hammer2_pfsmount_t *pmp = ip->pmp;
220 hammer2_mount_t *hmp;
2910a90c
MD
221 int copyid = remote->copyid;
222 int error = 0;
223
224 if (copyid >= HAMMER2_COPYID_COUNT)
225 return (EINVAL);
226
7bed8d7e 227 hmp = pmp->cluster.chains[0]->hmp; /* XXX */
2910a90c
MD
228 hammer2_voldata_lock(hmp);
229 if (copyid < 0) {
230 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
231 if (hmp->voldata.copyinfo[copyid].copyid == 0)
232 break;
233 }
234 if (copyid == HAMMER2_COPYID_COUNT) {
235 error = ENOSPC;
236 goto failed;
237 }
238 }
239 hammer2_modify_volume(hmp);
2910a90c
MD
240 remote->copy1.copyid = copyid;
241 hmp->voldata.copyinfo[copyid] = remote->copy1;
1a34728c 242 hammer2_volconf_update(pmp, copyid);
2910a90c 243failed:
0dea3156 244 hammer2_voldata_unlock(hmp, 1);
2910a90c
MD
245 return (error);
246}
247
248/*
249 * Delete existing remote entry
250 */
251static int
ae183399 252hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data)
2910a90c 253{
2910a90c 254 hammer2_ioc_remote_t *remote = data;
a5913bdf
MD
255 hammer2_pfsmount_t *pmp = ip->pmp;
256 hammer2_mount_t *hmp;
2910a90c
MD
257 int copyid = remote->copyid;
258 int error = 0;
259
7bed8d7e 260 hmp = pmp->cluster.chains[0]->hmp; /* XXX */
2910a90c
MD
261 if (copyid >= HAMMER2_COPYID_COUNT)
262 return (EINVAL);
263 remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0;
264 hammer2_voldata_lock(hmp);
265 if (copyid < 0) {
266 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) {
267 if (hmp->voldata.copyinfo[copyid].copyid == 0)
268 continue;
269 if (strcmp(remote->copy1.path,
270 hmp->voldata.copyinfo[copyid].path) == 0) {
271 break;
272 }
273 }
274 if (copyid == HAMMER2_COPYID_COUNT) {
275 error = ENOENT;
276 goto failed;
277 }
278 }
279 hammer2_modify_volume(hmp);
280 hmp->voldata.copyinfo[copyid].copyid = 0;
1a34728c 281 hammer2_volconf_update(pmp, copyid);
2910a90c 282failed:
0dea3156 283 hammer2_voldata_unlock(hmp, 1);
2910a90c
MD
284 return (error);
285}
286
287/*
288 * Replace existing remote entry
289 */
290static int
ae183399 291hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data)
2910a90c 292{
2910a90c 293 hammer2_ioc_remote_t *remote = data;
a5913bdf 294 hammer2_mount_t *hmp;
2910a90c
MD
295 int copyid = remote->copyid;
296
7bed8d7e 297 hmp = ip->pmp->cluster.chains[0]->hmp; /* XXX */
a5913bdf 298
2910a90c
MD
299 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
300 return (EINVAL);
301
302 hammer2_voldata_lock(hmp);
1a34728c 303 /*hammer2_volconf_update(pmp, copyid);*/
0dea3156 304 hammer2_voldata_unlock(hmp, 1);
2910a90c
MD
305
306 return(0);
307}
308
309/*
310 * Retrieve communications socket
311 */
312static int
ae183399 313hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data)
2910a90c
MD
314{
315 return (EOPNOTSUPP);
316}
317
318/*
319 * Set communications socket for connection
320 */
321static int
ae183399 322hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data)
2910a90c 323{
2910a90c 324 hammer2_ioc_remote_t *remote = data;
a5913bdf 325 hammer2_mount_t *hmp;
2910a90c
MD
326 int copyid = remote->copyid;
327
7bed8d7e 328 hmp = ip->pmp->cluster.chains[0]->hmp; /* XXX */
2910a90c
MD
329 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT)
330 return (EINVAL);
331
332 hammer2_voldata_lock(hmp);
0dea3156 333 hammer2_voldata_unlock(hmp, 0);
2910a90c
MD
334
335 return(0);
336}
ae183399
MD
337
338/*
a864c5d9
MD
339 * Used to scan and retrieve PFS information. PFS's are directories under
340 * the super-root.
341 *
342 * To scan PFSs pass name_key=0. The function will scan for the next
343 * PFS and set all fields, as well as set name_next to the next key.
344 * When no PFSs remain, name_next is set to (hammer2_key_t)-1.
345 *
346 * To retrieve the PFS associated with the file descriptor, pass
347 * name_key set to (hammer2_key_t)-1.
ae183399
MD
348 */
349static int
350hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data)
351{
476d2aad
MD
352 hammer2_inode_data_t *ipdata;
353 hammer2_mount_t *hmp;
354 hammer2_ioc_pfs_t *pfs;
ae183399
MD
355 hammer2_chain_t *parent;
356 hammer2_chain_t *chain;
a864c5d9 357 hammer2_chain_t *rchain;
1897c66e 358 hammer2_key_t key_next;
476d2aad 359 int error;
1897c66e 360 int cache_index = -1;
ae183399 361
476d2aad 362 error = 0;
7bed8d7e 363 hmp = ip->pmp->cluster.chains[0]->hmp; /* XXX */
476d2aad 364 pfs = data;
7bed8d7e 365 parent = hammer2_inode_lock_ex(hmp->sroot);
9b6b3df4 366 rchain = hammer2_inode_lock_ex(ip->pmp->iroot);
ae183399
MD
367
368 /*
369 * Search for the first key or specific key. Remember that keys
370 * can be returned in any order.
371 */
372 if (pfs->name_key == 0) {
1897c66e
MD
373 chain = hammer2_chain_lookup(&parent, &key_next,
374 0, (hammer2_key_t)-1,
375 &cache_index, 0);
a864c5d9 376 } else if (pfs->name_key == (hammer2_key_t)-1) {
1897c66e 377 chain = hammer2_chain_lookup(&parent, &key_next,
a864c5d9
MD
378 rchain->data->ipdata.name_key,
379 rchain->data->ipdata.name_key,
1897c66e 380 &cache_index, 0);
ae183399 381 } else {
1897c66e
MD
382 chain = hammer2_chain_lookup(&parent, &key_next,
383 pfs->name_key, pfs->name_key,
384 &cache_index, 0);
ae183399 385 }
9b6b3df4
MD
386 hammer2_inode_unlock_ex(ip->pmp->iroot, rchain);
387
ae183399 388 while (chain && chain->bref.type != HAMMER2_BREF_TYPE_INODE) {
1897c66e
MD
389 chain = hammer2_chain_next(&parent, chain, &key_next,
390 key_next, (hammer2_key_t)-1,
391 &cache_index, 0);
ae183399
MD
392 }
393 if (chain) {
394 /*
395 * Load the data being returned by the ioctl.
396 */
476d2aad
MD
397 ipdata = &chain->data->ipdata;
398 pfs->name_key = ipdata->name_key;
399 pfs->pfs_type = ipdata->pfs_type;
400 pfs->pfs_clid = ipdata->pfs_clid;
401 pfs->pfs_fsid = ipdata->pfs_fsid;
402 KKASSERT(ipdata->name_len < sizeof(pfs->name));
403 bcopy(ipdata->filename, pfs->name, ipdata->name_len);
404 pfs->name[ipdata->name_len] = 0;
405 ipdata = NULL; /* safety */
ae183399
MD
406
407 /*
408 * Calculate the next field
409 */
410 do {
1897c66e
MD
411 chain = hammer2_chain_next(&parent, chain, &key_next,
412 0, (hammer2_key_t)-1,
413 &cache_index, 0);
ae183399
MD
414 } while (chain && chain->bref.type != HAMMER2_BREF_TYPE_INODE);
415 if (chain) {
476d2aad 416 pfs->name_next = chain->data->ipdata.name_key;
0dea3156 417 hammer2_chain_unlock(chain);
ae183399
MD
418 } else {
419 pfs->name_next = (hammer2_key_t)-1;
420 }
421 } else {
422 pfs->name_next = (hammer2_key_t)-1;
423 error = ENOENT;
424 }
7bed8d7e 425 hammer2_inode_unlock_ex(hmp->sroot, parent);
0dea3156 426
ae183399
MD
427 return (error);
428}
429
458ecb1b
MD
430/*
431 * Find a specific PFS by name
432 */
433static int
434hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data)
435{
476d2aad
MD
436 hammer2_inode_data_t *ipdata;
437 hammer2_mount_t *hmp;
438 hammer2_ioc_pfs_t *pfs;
458ecb1b
MD
439 hammer2_chain_t *parent;
440 hammer2_chain_t *chain;
1897c66e 441 hammer2_key_t key_next;
458ecb1b 442 hammer2_key_t lhc;
476d2aad 443 int error;
1897c66e 444 int cache_index = -1;
458ecb1b
MD
445 size_t len;
446
476d2aad 447 error = 0;
7bed8d7e 448 hmp = ip->pmp->cluster.chains[0]->hmp; /* XXX */
476d2aad 449 pfs = data;
7bed8d7e 450 parent = hammer2_inode_lock_sh(hmp->sroot);
458ecb1b
MD
451
452 pfs->name[sizeof(pfs->name) - 1] = 0;
453 len = strlen(pfs->name);
454 lhc = hammer2_dirhash(pfs->name, len);
455
1897c66e 456 chain = hammer2_chain_lookup(&parent, &key_next,
458ecb1b 457 lhc, lhc + HAMMER2_DIRHASH_LOMASK,
1897c66e 458 &cache_index, HAMMER2_LOOKUP_SHARED);
458ecb1b
MD
459 while (chain) {
460 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE &&
458ecb1b
MD
461 len == chain->data->ipdata.name_len &&
462 bcmp(pfs->name, chain->data->ipdata.filename, len) == 0) {
463 break;
464 }
1897c66e
MD
465 chain = hammer2_chain_next(&parent, chain, &key_next,
466 key_next,
467 lhc + HAMMER2_DIRHASH_LOMASK,
468 &cache_index, HAMMER2_LOOKUP_SHARED);
458ecb1b
MD
469 }
470
471 /*
472 * Load the data being returned by the ioctl.
473 */
474 if (chain) {
476d2aad
MD
475 ipdata = &chain->data->ipdata;
476 pfs->name_key = ipdata->name_key;
477 pfs->pfs_type = ipdata->pfs_type;
478 pfs->pfs_clid = ipdata->pfs_clid;
479 pfs->pfs_fsid = ipdata->pfs_fsid;
480 ipdata = NULL;
458ecb1b 481
0dea3156 482 hammer2_chain_unlock(chain);
458ecb1b
MD
483 } else {
484 error = ENOENT;
485 }
7bed8d7e
MD
486 hammer2_inode_unlock_sh(hmp->sroot, parent);
487
458ecb1b
MD
488 return (error);
489}
490
ae183399
MD
491/*
492 * Create a new PFS under the super-root
493 */
494static int
495hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data)
496{
476d2aad
MD
497 hammer2_inode_data_t *nipdata;
498 hammer2_mount_t *hmp;
499 hammer2_ioc_pfs_t *pfs;
500 hammer2_inode_t *nip;
9596b8c4 501 hammer2_chain_t *nchain;
0dea3156 502 hammer2_trans_t trans;
ae183399
MD
503 int error;
504
7bed8d7e 505 hmp = ip->pmp->cluster.chains[0]->hmp; /* XXX */
476d2aad
MD
506 pfs = data;
507 nip = NULL;
508
a864c5d9
MD
509 if (pfs->name[0] == 0)
510 return(EINVAL);
ae183399 511 pfs->name[sizeof(pfs->name) - 1] = 0; /* ensure 0-termination */
10252dc7 512
10136ab6 513 hammer2_trans_init(&trans, ip->pmp, NULL, HAMMER2_TRANS_NEWINODE);
0dea3156 514 nip = hammer2_inode_create(&trans, hmp->sroot, NULL, NULL,
ae183399 515 pfs->name, strlen(pfs->name),
9596b8c4 516 &nchain, &error);
ae183399 517 if (error == 0) {
9596b8c4 518 nipdata = hammer2_chain_modify_ip(&trans, nip, &nchain,
4a59bd3e 519 HAMMER2_MODIFY_ASSERTNOCOPY);
476d2aad
MD
520 nipdata->pfs_type = pfs->pfs_type;
521 nipdata->pfs_clid = pfs->pfs_clid;
522 nipdata->pfs_fsid = pfs->pfs_fsid;
cdfd0a3e
MD
523
524 /*
525 * Do not allow compression on PFS's with the special name
526 * "boot", the boot loader can't decompress (yet).
527 */
528 if (strcmp(pfs->name, "boot") == 0)
529 nipdata->comp_algo = HAMMER2_COMP_AUTOZERO;
9596b8c4 530 hammer2_inode_unlock_ex(nip, nchain);
ae183399 531 }
0dea3156 532 hammer2_trans_done(&trans);
ae183399
MD
533 return (error);
534}
535
536/*
537 * Destroy an existing PFS under the super-root
538 */
539static int
540hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data)
541{
a5913bdf 542 hammer2_mount_t *hmp;
ae183399 543 hammer2_ioc_pfs_t *pfs = data;
0dea3156 544 hammer2_trans_t trans;
ae183399
MD
545 int error;
546
7bed8d7e 547 hmp = ip->pmp->cluster.chains[0]->hmp; /* XXX */
10136ab6 548 hammer2_trans_init(&trans, ip->pmp, NULL, 0);
0dea3156 549 error = hammer2_unlink_file(&trans, hmp->sroot,
9797e933 550 pfs->name, strlen(pfs->name),
044541cd 551 2, NULL, NULL);
a864c5d9
MD
552 hammer2_trans_done(&trans);
553
554 return (error);
555}
556
557static int
558hammer2_ioctl_pfs_snapshot(hammer2_inode_t *ip, void *data)
559{
a864c5d9
MD
560 hammer2_ioc_pfs_t *pfs = data;
561 hammer2_trans_t trans;
9596b8c4 562 hammer2_chain_t *parent;
a864c5d9
MD
563 int error;
564
565 if (pfs->name[0] == 0)
566 return(EINVAL);
567 if (pfs->name[sizeof(pfs->name)-1] != 0)
568 return(EINVAL);
569
a7720be7
MD
570 hammer2_vfs_sync(ip->pmp->mp, MNT_WAIT);
571
10136ab6 572 hammer2_trans_init(&trans, ip->pmp, NULL, HAMMER2_TRANS_NEWINODE);
9596b8c4 573 parent = hammer2_inode_lock_ex(ip);
a7720be7 574 error = hammer2_chain_snapshot(&trans, &parent, pfs);
9596b8c4 575 hammer2_inode_unlock_ex(ip, parent);
0dea3156
MD
576 hammer2_trans_done(&trans);
577
ae183399
MD
578 return (error);
579}
344d4f82
MD
580
581/*
582 * Retrieve the raw inode structure
583 */
584static int
585hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data)
586{
587 hammer2_ioc_inode_t *ino = data;
9596b8c4 588 hammer2_chain_t *parent;
344d4f82 589
9596b8c4 590 parent = hammer2_inode_lock_sh(ip);
0dea3156 591 ino->ip_data = ip->chain->data->ipdata;
26b047fa 592 ino->kdata = ip;
9596b8c4 593 hammer2_inode_unlock_sh(ip, parent);
0dea3156 594
344d4f82
MD
595 return (0);
596}
597
f481450f
MD
598/*
599 * Set various parameters in an inode which cannot be set through
600 * normal filesystem VNOPS.
601 */
344d4f82
MD
602static int
603hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data)
604{
355d67fc 605 hammer2_inode_data_t *ipdata;
344d4f82 606 hammer2_ioc_inode_t *ino = data;
f481450f 607 hammer2_chain_t *chain;
355d67fc 608 hammer2_trans_t trans;
f481450f 609 int error = 0;
344d4f82 610
10136ab6 611 hammer2_trans_init(&trans, ip->pmp, NULL, 0);
f481450f
MD
612 chain = hammer2_inode_lock_ex(ip);
613
614 if (ino->ip_data.comp_algo != chain->data->ipdata.comp_algo) {
615 ipdata = hammer2_chain_modify_ip(&trans, ip, &chain, 0);
616 ipdata->comp_algo = ino->ip_data.comp_algo;
617 }
355d67fc
MD
618 ino->kdata = ip;
619
f481450f 620 /* Ignore these flags for now...*/
344d4f82
MD
621 if (ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) {
622 }
623 if (ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) {
624 }
625 if (ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) {
626 }
355d67fc 627 hammer2_trans_done(&trans);
f481450f 628 hammer2_inode_unlock_ex(ip, chain);
0dea3156 629
344d4f82
MD
630 return (error);
631}