1 /* 2 * Copyright (c) 2011-2012 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_delete(hammer2_inode_t *ip, void *data); 57 static int hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data); 58 static int hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data); 59 60 int 61 hammer2_ioctl(hammer2_inode_t *ip, u_long com, void *data, int fflag, 62 struct ucred *cred) 63 { 64 int error; 65 66 /* 67 * Standard root cred checks, will be selectively ignored below 68 * for ioctls that do not require root creds. 69 */ 70 error = priv_check_cred(cred, PRIV_HAMMER_IOCTL, 0); 71 72 switch(com) { 73 case HAMMER2IOC_VERSION_GET: 74 error = hammer2_ioctl_version_get(ip, data); 75 break; 76 case HAMMER2IOC_RECLUSTER: 77 if (error == 0) 78 error = hammer2_ioctl_recluster(ip, data); 79 break; 80 case HAMMER2IOC_REMOTE_SCAN: 81 if (error == 0) 82 error = hammer2_ioctl_remote_scan(ip, data); 83 break; 84 case HAMMER2IOC_REMOTE_ADD: 85 if (error == 0) 86 error = hammer2_ioctl_remote_add(ip, data); 87 break; 88 case HAMMER2IOC_REMOTE_DEL: 89 if (error == 0) 90 error = hammer2_ioctl_remote_del(ip, data); 91 break; 92 case HAMMER2IOC_REMOTE_REP: 93 if (error == 0) 94 error = hammer2_ioctl_remote_rep(ip, data); 95 break; 96 case HAMMER2IOC_SOCKET_GET: 97 if (error == 0) 98 error = hammer2_ioctl_socket_get(ip, data); 99 break; 100 case HAMMER2IOC_SOCKET_SET: 101 if (error == 0) 102 error = hammer2_ioctl_socket_set(ip, data); 103 break; 104 case HAMMER2IOC_PFS_GET: 105 if (error == 0) 106 error = hammer2_ioctl_pfs_get(ip, data); 107 break; 108 case HAMMER2IOC_PFS_LOOKUP: 109 if (error == 0) 110 error = hammer2_ioctl_pfs_lookup(ip, data); 111 break; 112 case HAMMER2IOC_PFS_CREATE: 113 if (error == 0) 114 error = hammer2_ioctl_pfs_create(ip, data); 115 break; 116 case HAMMER2IOC_PFS_DELETE: 117 if (error == 0) 118 error = hammer2_ioctl_pfs_delete(ip, data); 119 break; 120 case HAMMER2IOC_INODE_GET: 121 error = hammer2_ioctl_inode_get(ip, data); 122 break; 123 case HAMMER2IOC_INODE_SET: 124 if (error == 0) 125 error = hammer2_ioctl_inode_set(ip, data); 126 break; 127 default: 128 error = EOPNOTSUPP; 129 break; 130 } 131 return (error); 132 } 133 134 /* 135 * Retrieve version and basic info 136 */ 137 static int 138 hammer2_ioctl_version_get(hammer2_inode_t *ip, void *data) 139 { 140 hammer2_mount_t *hmp = ip->hmp; 141 hammer2_ioc_version_t *version = data; 142 143 version->version = hmp->voldata.version; 144 return 0; 145 } 146 147 static int 148 hammer2_ioctl_recluster(hammer2_inode_t *ip, void *data) 149 { 150 hammer2_ioc_recluster_t *recl = data; 151 struct file *fp; 152 153 fp = holdfp(curproc->p_fd, recl->fd, -1); 154 if (fp) { 155 kprintf("reconnect to cluster\n"); 156 hammer2_cluster_reconnect(ip->pmp, fp); 157 return 0; 158 } else { 159 return EINVAL; 160 } 161 } 162 163 /* 164 * Retrieve information about a remote 165 */ 166 static int 167 hammer2_ioctl_remote_scan(hammer2_inode_t *ip, void *data) 168 { 169 hammer2_mount_t *hmp = ip->hmp; 170 hammer2_ioc_remote_t *remote = data; 171 int copyid = remote->copyid; 172 173 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT) 174 return (EINVAL); 175 176 hammer2_voldata_lock(hmp); 177 remote->copy1 = hmp->voldata.copyinfo[copyid]; 178 hammer2_voldata_unlock(hmp); 179 180 /* 181 * Adjust nextid (GET only) 182 */ 183 while (++copyid < HAMMER2_COPYID_COUNT && 184 hmp->voldata.copyinfo[copyid].copyid == 0) { 185 ; 186 } 187 if (copyid == HAMMER2_COPYID_COUNT) 188 remote->nextid = -1; 189 else 190 remote->nextid = copyid; 191 192 return(0); 193 } 194 195 /* 196 * Add new remote entry 197 */ 198 static int 199 hammer2_ioctl_remote_add(hammer2_inode_t *ip, void *data) 200 { 201 hammer2_mount_t *hmp = ip->hmp; 202 hammer2_pfsmount_t *pmp = ip->pmp; 203 hammer2_ioc_remote_t *remote = data; 204 int copyid = remote->copyid; 205 int error = 0; 206 207 if (copyid >= HAMMER2_COPYID_COUNT) 208 return (EINVAL); 209 210 hammer2_voldata_lock(hmp); 211 if (copyid < 0) { 212 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) { 213 if (hmp->voldata.copyinfo[copyid].copyid == 0) 214 break; 215 } 216 if (copyid == HAMMER2_COPYID_COUNT) { 217 error = ENOSPC; 218 goto failed; 219 } 220 } 221 hammer2_modify_volume(hmp); 222 remote->copy1.copyid = copyid; 223 hmp->voldata.copyinfo[copyid] = remote->copy1; 224 hammer2_volconf_update(pmp, copyid); 225 failed: 226 hammer2_voldata_unlock(hmp); 227 return (error); 228 } 229 230 /* 231 * Delete existing remote entry 232 */ 233 static int 234 hammer2_ioctl_remote_del(hammer2_inode_t *ip, void *data) 235 { 236 hammer2_mount_t *hmp = ip->hmp; 237 hammer2_pfsmount_t *pmp = ip->pmp; 238 hammer2_ioc_remote_t *remote = data; 239 int copyid = remote->copyid; 240 int error = 0; 241 242 if (copyid >= HAMMER2_COPYID_COUNT) 243 return (EINVAL); 244 remote->copy1.path[sizeof(remote->copy1.path) - 1] = 0; 245 hammer2_voldata_lock(hmp); 246 if (copyid < 0) { 247 for (copyid = 1; copyid < HAMMER2_COPYID_COUNT; ++copyid) { 248 if (hmp->voldata.copyinfo[copyid].copyid == 0) 249 continue; 250 if (strcmp(remote->copy1.path, 251 hmp->voldata.copyinfo[copyid].path) == 0) { 252 break; 253 } 254 } 255 if (copyid == HAMMER2_COPYID_COUNT) { 256 error = ENOENT; 257 goto failed; 258 } 259 } 260 hammer2_modify_volume(hmp); 261 hmp->voldata.copyinfo[copyid].copyid = 0; 262 hammer2_volconf_update(pmp, copyid); 263 failed: 264 hammer2_voldata_unlock(hmp); 265 return (error); 266 } 267 268 /* 269 * Replace existing remote entry 270 */ 271 static int 272 hammer2_ioctl_remote_rep(hammer2_inode_t *ip, void *data) 273 { 274 hammer2_mount_t *hmp = ip->hmp; 275 hammer2_ioc_remote_t *remote = data; 276 int copyid = remote->copyid; 277 278 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT) 279 return (EINVAL); 280 281 hammer2_voldata_lock(hmp); 282 /*hammer2_volconf_update(pmp, copyid);*/ 283 hammer2_voldata_unlock(hmp); 284 285 return(0); 286 } 287 288 /* 289 * Retrieve communications socket 290 */ 291 static int 292 hammer2_ioctl_socket_get(hammer2_inode_t *ip, void *data) 293 { 294 return (EOPNOTSUPP); 295 } 296 297 /* 298 * Set communications socket for connection 299 */ 300 static int 301 hammer2_ioctl_socket_set(hammer2_inode_t *ip, void *data) 302 { 303 hammer2_mount_t *hmp = ip->hmp; 304 hammer2_ioc_remote_t *remote = data; 305 int copyid = remote->copyid; 306 307 if (copyid < 0 || copyid >= HAMMER2_COPYID_COUNT) 308 return (EINVAL); 309 310 hammer2_voldata_lock(hmp); 311 hammer2_voldata_unlock(hmp); 312 313 return(0); 314 } 315 316 /* 317 * Used to scan PFSs, which are directories under the super-root. 318 */ 319 static int 320 hammer2_ioctl_pfs_get(hammer2_inode_t *ip, void *data) 321 { 322 hammer2_inode_data_t *ipdata; 323 hammer2_mount_t *hmp; 324 hammer2_ioc_pfs_t *pfs; 325 hammer2_chain_t *parent; 326 hammer2_chain_t *chain; 327 int error; 328 329 error = 0; 330 hmp = ip->hmp; 331 pfs = data; 332 parent = hmp->schain; 333 error = hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS); 334 if (error) 335 goto done; 336 337 /* 338 * Search for the first key or specific key. Remember that keys 339 * can be returned in any order. 340 */ 341 if (pfs->name_key == 0) { 342 chain = hammer2_chain_lookup(hmp, &parent, 343 0, (hammer2_key_t)-1, 0); 344 } else { 345 chain = hammer2_chain_lookup(hmp, &parent, 346 pfs->name_key, pfs->name_key, 0); 347 } 348 while (chain && chain->bref.type != HAMMER2_BREF_TYPE_INODE) { 349 chain = hammer2_chain_next(hmp, &parent, chain, 350 0, (hammer2_key_t)-1, 0); 351 } 352 if (chain) { 353 /* 354 * Load the data being returned by the ioctl. 355 */ 356 ipdata = &chain->data->ipdata; 357 pfs->name_key = ipdata->name_key; 358 pfs->pfs_type = ipdata->pfs_type; 359 pfs->pfs_clid = ipdata->pfs_clid; 360 pfs->pfs_fsid = ipdata->pfs_fsid; 361 KKASSERT(ipdata->name_len < sizeof(pfs->name)); 362 bcopy(ipdata->filename, pfs->name, ipdata->name_len); 363 pfs->name[ipdata->name_len] = 0; 364 ipdata = NULL; /* safety */ 365 366 /* 367 * Calculate the next field 368 */ 369 do { 370 chain = hammer2_chain_next(hmp, &parent, chain, 371 0, (hammer2_key_t)-1, 0); 372 } while (chain && chain->bref.type != HAMMER2_BREF_TYPE_INODE); 373 if (chain) { 374 pfs->name_next = chain->data->ipdata.name_key; 375 hammer2_chain_unlock(hmp, chain); 376 } else { 377 pfs->name_next = (hammer2_key_t)-1; 378 } 379 } else { 380 pfs->name_next = (hammer2_key_t)-1; 381 error = ENOENT; 382 } 383 done: 384 hammer2_chain_unlock(hmp, parent); 385 return (error); 386 } 387 388 /* 389 * Find a specific PFS by name 390 */ 391 static int 392 hammer2_ioctl_pfs_lookup(hammer2_inode_t *ip, void *data) 393 { 394 hammer2_inode_data_t *ipdata; 395 hammer2_mount_t *hmp; 396 hammer2_ioc_pfs_t *pfs; 397 hammer2_chain_t *parent; 398 hammer2_chain_t *chain; 399 hammer2_key_t lhc; 400 int error; 401 size_t len; 402 403 error = 0; 404 hmp = ip->hmp; 405 pfs = data; 406 parent = hmp->schain; 407 error = hammer2_chain_lock(hmp, parent, HAMMER2_RESOLVE_ALWAYS | 408 HAMMER2_RESOLVE_SHARED); 409 if (error) 410 goto done; 411 412 pfs->name[sizeof(pfs->name) - 1] = 0; 413 len = strlen(pfs->name); 414 lhc = hammer2_dirhash(pfs->name, len); 415 416 chain = hammer2_chain_lookup(hmp, &parent, 417 lhc, lhc + HAMMER2_DIRHASH_LOMASK, 418 HAMMER2_LOOKUP_SHARED); 419 while (chain) { 420 if (chain->bref.type == HAMMER2_BREF_TYPE_INODE && 421 len == chain->data->ipdata.name_len && 422 bcmp(pfs->name, chain->data->ipdata.filename, len) == 0) { 423 break; 424 } 425 chain = hammer2_chain_next(hmp, &parent, chain, 426 lhc, lhc + HAMMER2_DIRHASH_LOMASK, 427 HAMMER2_LOOKUP_SHARED); 428 } 429 430 /* 431 * Load the data being returned by the ioctl. 432 */ 433 if (chain) { 434 ipdata = &chain->data->ipdata; 435 pfs->name_key = ipdata->name_key; 436 pfs->pfs_type = ipdata->pfs_type; 437 pfs->pfs_clid = ipdata->pfs_clid; 438 pfs->pfs_fsid = ipdata->pfs_fsid; 439 ipdata = NULL; 440 441 hammer2_chain_unlock(hmp, chain); 442 } else { 443 error = ENOENT; 444 } 445 done: 446 hammer2_chain_unlock(hmp, parent); 447 return (error); 448 } 449 450 /* 451 * Create a new PFS under the super-root 452 */ 453 static int 454 hammer2_ioctl_pfs_create(hammer2_inode_t *ip, void *data) 455 { 456 hammer2_inode_data_t *nipdata; 457 hammer2_chain_t *nchain; 458 hammer2_mount_t *hmp; 459 hammer2_ioc_pfs_t *pfs; 460 hammer2_inode_t *nip; 461 int error; 462 463 hmp = ip->hmp; 464 pfs = data; 465 nip = NULL; 466 467 pfs->name[sizeof(pfs->name) - 1] = 0; /* ensure 0-termination */ 468 469 error = hammer2_inode_create(hmp->sroot, NULL, NULL, 470 pfs->name, strlen(pfs->name), 471 &nip, &nchain); 472 if (error == 0) { 473 hammer2_chain_modify(hmp, nchain, 0); 474 nipdata = &nchain->data->ipdata; 475 nipdata->pfs_type = pfs->pfs_type; 476 nipdata->pfs_clid = pfs->pfs_clid; 477 nipdata->pfs_fsid = pfs->pfs_fsid; 478 hammer2_inode_unlock_ex(nip, nchain); 479 } 480 return (error); 481 } 482 483 /* 484 * Destroy an existing PFS under the super-root 485 */ 486 static int 487 hammer2_ioctl_pfs_delete(hammer2_inode_t *ip, void *data) 488 { 489 hammer2_mount_t *hmp = ip->hmp; 490 hammer2_ioc_pfs_t *pfs = data; 491 int error; 492 493 error = hammer2_unlink_file(hmp->sroot, 494 pfs->name, strlen(pfs->name), 495 0, NULL); 496 return (error); 497 } 498 499 /* 500 * Retrieve the raw inode structure 501 */ 502 static int 503 hammer2_ioctl_inode_get(hammer2_inode_t *ip, void *data) 504 { 505 hammer2_ioc_inode_t *ino = data; 506 hammer2_chain_t *chain; 507 508 chain = hammer2_inode_lock_sh(ip); 509 ino->ip_data = chain->data->ipdata; 510 ino->kdata = ip; 511 hammer2_inode_unlock_sh(ip, chain); 512 return (0); 513 } 514 515 static int 516 hammer2_ioctl_inode_set(hammer2_inode_t *ip, void *data) 517 { 518 hammer2_ioc_inode_t *ino = data; 519 hammer2_chain_t *chain; 520 int error = EINVAL; 521 522 chain = hammer2_inode_lock_ex(ip); 523 if (ino->flags & HAMMER2IOC_INODE_FLAG_IQUOTA) { 524 } 525 if (ino->flags & HAMMER2IOC_INODE_FLAG_DQUOTA) { 526 } 527 if (ino->flags & HAMMER2IOC_INODE_FLAG_COPIES) { 528 } 529 hammer2_inode_unlock_ex(ip, chain); 530 return (error); 531 } 532