1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/modctl.h> 26 #include <sys/types.h> 27 #include <sys/param.h> 28 #include <sys/time.h> 29 #include <sys/cred.h> 30 #include <sys/vfs.h> 31 #include <sys/vfs_opreg.h> 32 #include <sys/gfs.h> 33 #include <sys/vnode.h> 34 #include <sys/systm.h> 35 #include <sys/cmn_err.h> 36 #include <sys/errno.h> 37 #include <sys/sysmacros.h> 38 #include <sys/policy.h> 39 #include <sys/mount.h> 40 #include <sys/pathname.h> 41 #include <sys/dirent.h> 42 #include <fs/fs_subr.h> 43 #include <sys/contract.h> 44 #include <sys/contract_impl.h> 45 #include <sys/ctfs.h> 46 #include <sys/ctfs_impl.h> 47 #include <sys/uio.h> 48 #include <sys/file.h> 49 #include <sys/atomic.h> 50 #include <sys/sunddi.h> 51 52 /* 53 * ctfs, the contract filesystem. 54 * 55 * Exposes the construct subsystem to userland. The structure of the 56 * filesytem is a public interface, but the behavior of the files is 57 * private and unstable. Contract consumers are expected to use 58 * libcontract(3lib) to operate on ctfs file descriptors. 59 * 60 * We're trying something a little different here. Rather than make 61 * each vnode op itself call into a vector of file type operations, we 62 * actually use different vnode types (gasp!), the implementations of 63 * which may call into routines providing common functionality. This 64 * design should hopefully make it easier to factor and maintain the 65 * code. For the most part, there is a separate file for each vnode 66 * type's implementation. The exceptions to this are the ctl/stat 67 * nodes, which are very similar, and the three event endpoint types. 68 * 69 * This file contains common routines used by some or all of the vnode 70 * types, the filesystem's module linkage and VFS operations, and the 71 * implementation of the root vnode. 72 */ 73 74 /* 75 * Ops vectors for all the vnode types; they have to be defined 76 * somewhere. See gfs_make_opsvec for thoughts on how this could be 77 * done differently. 78 */ 79 vnodeops_t *ctfs_ops_root; 80 vnodeops_t *ctfs_ops_adir; 81 vnodeops_t *ctfs_ops_sym; 82 vnodeops_t *ctfs_ops_tdir; 83 vnodeops_t *ctfs_ops_tmpl; 84 vnodeops_t *ctfs_ops_cdir; 85 vnodeops_t *ctfs_ops_ctl; 86 vnodeops_t *ctfs_ops_stat; 87 vnodeops_t *ctfs_ops_event; 88 vnodeops_t *ctfs_ops_bundle; 89 vnodeops_t *ctfs_ops_latest; 90 91 static const fs_operation_def_t ctfs_vfstops[]; 92 static gfs_opsvec_t ctfs_opsvec[]; 93 94 static int ctfs_init(int, char *); 95 96 static ino64_t ctfs_root_do_inode(vnode_t *, int); 97 98 99 /* 100 * File system module linkage 101 */ 102 static mntopts_t ctfs_mntopts = { 103 0, 104 NULL 105 }; 106 107 static vfsdef_t vfw = { 108 VFSDEF_VERSION, 109 "ctfs", 110 ctfs_init, 111 VSW_HASPROTO|VSW_ZMOUNT, 112 &ctfs_mntopts, 113 }; 114 115 extern struct mod_ops mod_fsops; 116 117 static struct modlfs modlfs = { 118 &mod_fsops, "contract filesystem", &vfw 119 }; 120 121 static struct modlinkage modlinkage = { 122 MODREV_1, (void *)&modlfs, NULL 123 }; 124 125 int 126 _init(void) 127 { 128 return (mod_install(&modlinkage)); 129 } 130 131 int 132 _info(struct modinfo *modinfop) 133 { 134 return (mod_info(&modlinkage, modinfop)); 135 } 136 137 int 138 _fini(void) 139 { 140 /* 141 * As unloading filesystem modules isn't completely safe, we 142 * don't allow it. 143 */ 144 return (EBUSY); 145 } 146 147 static int ctfs_fstype; 148 static major_t ctfs_major; 149 static minor_t ctfs_minor = 0; 150 151 /* 152 * The ops vector vector. 153 */ 154 static const fs_operation_def_t ctfs_tops_root[]; 155 extern const fs_operation_def_t ctfs_tops_tmpl[]; 156 extern const fs_operation_def_t ctfs_tops_ctl[]; 157 extern const fs_operation_def_t ctfs_tops_adir[]; 158 extern const fs_operation_def_t ctfs_tops_cdir[]; 159 extern const fs_operation_def_t ctfs_tops_tdir[]; 160 extern const fs_operation_def_t ctfs_tops_latest[]; 161 extern const fs_operation_def_t ctfs_tops_stat[]; 162 extern const fs_operation_def_t ctfs_tops_sym[]; 163 extern const fs_operation_def_t ctfs_tops_event[]; 164 extern const fs_operation_def_t ctfs_tops_bundle[]; 165 static gfs_opsvec_t ctfs_opsvec[] = { 166 { "ctfs root directory", ctfs_tops_root, &ctfs_ops_root }, 167 { "ctfs all directory", ctfs_tops_adir, &ctfs_ops_adir }, 168 { "ctfs all symlink", ctfs_tops_sym, &ctfs_ops_sym }, 169 { "ctfs template directory", ctfs_tops_tdir, &ctfs_ops_tdir }, 170 { "ctfs template file", ctfs_tops_tmpl, &ctfs_ops_tmpl }, 171 { "ctfs contract directory", ctfs_tops_cdir, &ctfs_ops_cdir }, 172 { "ctfs ctl file", ctfs_tops_ctl, &ctfs_ops_ctl }, 173 { "ctfs status file", ctfs_tops_stat, &ctfs_ops_stat }, 174 { "ctfs events file", ctfs_tops_event, &ctfs_ops_event }, 175 { "ctfs bundle file", ctfs_tops_bundle, &ctfs_ops_bundle }, 176 { "ctfs latest file", ctfs_tops_latest, &ctfs_ops_latest }, 177 { NULL } 178 }; 179 180 181 /* 182 * ctfs_init - the vfsdef_t init entry point 183 * 184 * Sets the VFS ops, builds all the vnode ops, and allocates a device 185 * number. 186 */ 187 /* ARGSUSED */ 188 static int 189 ctfs_init(int fstype, char *name) 190 { 191 vfsops_t *vfsops; 192 int error; 193 194 ctfs_fstype = fstype; 195 if (error = vfs_setfsops(fstype, ctfs_vfstops, &vfsops)) { 196 cmn_err(CE_WARN, "ctfs_init: bad vfs ops template"); 197 return (error); 198 } 199 200 if (error = gfs_make_opsvec(ctfs_opsvec)) { 201 (void) vfs_freevfsops(vfsops); 202 return (error); 203 } 204 205 if ((ctfs_major = getudev()) == (major_t)-1) { 206 cmn_err(CE_WARN, "ctfs_init: can't get unique device number"); 207 ctfs_major = 0; 208 } 209 210 return (0); 211 } 212 213 /* 214 * ctfs_mount - the VFS_MOUNT entry point 215 */ 216 static int 217 ctfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr) 218 { 219 ctfs_vfs_t *data; 220 dev_t dev; 221 gfs_dirent_t *dirent; 222 int i; 223 224 if (secpolicy_fs_mount(cr, mvp, vfsp) != 0) 225 return (EPERM); 226 227 if (mvp->v_type != VDIR) 228 return (ENOTDIR); 229 230 if ((uap->flags & MS_OVERLAY) == 0 && 231 (mvp->v_count > 1 || (mvp->v_flag & VROOT))) 232 return (EBUSY); 233 234 data = kmem_alloc(sizeof (ctfs_vfs_t), KM_SLEEP); 235 236 /* 237 * Initialize vfs fields not initialized by VFS_INIT/domount 238 */ 239 vfsp->vfs_bsize = DEV_BSIZE; 240 vfsp->vfs_fstype = ctfs_fstype; 241 do { 242 dev = makedevice(ctfs_major, 243 atomic_add_32_nv(&ctfs_minor, 1) & L_MAXMIN32); 244 } while (vfs_devismounted(dev)); 245 vfs_make_fsid(&vfsp->vfs_fsid, dev, ctfs_fstype); 246 vfsp->vfs_data = data; 247 vfsp->vfs_dev = dev; 248 249 /* 250 * Dynamically create gfs_dirent_t array for the root directory. 251 */ 252 dirent = kmem_zalloc((ct_ntypes + 2) * sizeof (gfs_dirent_t), KM_SLEEP); 253 for (i = 0; i < ct_ntypes; i++) { 254 dirent[i].gfse_name = (char *)ct_types[i]->ct_type_name; 255 dirent[i].gfse_ctor = ctfs_create_tdirnode; 256 dirent[i].gfse_flags = GFS_CACHE_VNODE; 257 } 258 dirent[i].gfse_name = "all"; 259 dirent[i].gfse_ctor = ctfs_create_adirnode; 260 dirent[i].gfse_flags = GFS_CACHE_VNODE; 261 dirent[i+1].gfse_name = NULL; 262 263 /* 264 * Create root vnode 265 */ 266 data->ctvfs_root = gfs_root_create(sizeof (ctfs_rootnode_t), 267 vfsp, ctfs_ops_root, CTFS_INO_ROOT, dirent, ctfs_root_do_inode, 268 CTFS_NAME_MAX, NULL, NULL); 269 270 kmem_free(dirent, (ct_ntypes + 2) * sizeof (gfs_dirent_t)); 271 272 return (0); 273 } 274 275 /* 276 * ctfs_unmount - the VFS_UNMOUNT entry point 277 */ 278 static int 279 ctfs_unmount(vfs_t *vfsp, int flag, struct cred *cr) 280 { 281 ctfs_vfs_t *data; 282 283 if (secpolicy_fs_unmount(cr, vfsp) != 0) 284 return (EPERM); 285 286 /* 287 * Supporting forced unmounts would be nice to do at some 288 * point. 289 */ 290 if (flag & MS_FORCE) 291 return (ENOTSUP); 292 293 /* 294 * We should never have a reference count less than 2: one for 295 * the caller, one for the root vnode. 296 */ 297 ASSERT(vfsp->vfs_count >= 2); 298 299 /* 300 * If we have any active vnodes, they will (transitively) have 301 * holds on the root vnode. 302 */ 303 data = vfsp->vfs_data; 304 if (data->ctvfs_root->v_count > 1) 305 return (EBUSY); 306 307 /* 308 * Release the last hold on the root vnode. It will, in turn, 309 * release its hold on us. 310 */ 311 VN_RELE(data->ctvfs_root); 312 313 /* 314 * Disappear. 315 */ 316 kmem_free(data, sizeof (ctfs_vfs_t)); 317 318 return (0); 319 } 320 321 /* 322 * ctfs_root - the VFS_ROOT entry point 323 */ 324 static int 325 ctfs_root(vfs_t *vfsp, vnode_t **vpp) 326 { 327 vnode_t *vp; 328 329 vp = ((ctfs_vfs_t *)vfsp->vfs_data)->ctvfs_root; 330 VN_HOLD(vp); 331 *vpp = vp; 332 333 return (0); 334 } 335 336 /* 337 * ctfs_statvfs - the VFS_STATVFS entry point 338 */ 339 static int 340 ctfs_statvfs(vfs_t *vfsp, statvfs64_t *sp) 341 { 342 dev32_t d32; 343 int total, i; 344 345 bzero(sp, sizeof (*sp)); 346 sp->f_bsize = DEV_BSIZE; 347 sp->f_frsize = DEV_BSIZE; 348 for (i = 0, total = 0; i < ct_ntypes; i++) 349 total += contract_type_count(ct_types[i]); 350 sp->f_files = total; 351 sp->f_favail = sp->f_ffree = INT_MAX - total; 352 (void) cmpldev(&d32, vfsp->vfs_dev); 353 sp->f_fsid = d32; 354 (void) strlcpy(sp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name, 355 sizeof (sp->f_basetype)); 356 sp->f_flag = vf_to_stf(vfsp->vfs_flag); 357 sp->f_namemax = CTFS_NAME_MAX; 358 (void) strlcpy(sp->f_fstr, "contract", sizeof (sp->f_fstr)); 359 360 return (0); 361 } 362 363 static const fs_operation_def_t ctfs_vfstops[] = { 364 { VFSNAME_MOUNT, { .vfs_mount = ctfs_mount } }, 365 { VFSNAME_UNMOUNT, { .vfs_unmount = ctfs_unmount } }, 366 { VFSNAME_ROOT, { .vfs_root = ctfs_root } }, 367 { VFSNAME_STATVFS, { .vfs_statvfs = ctfs_statvfs } }, 368 { NULL, NULL } 369 }; 370 371 /* 372 * ctfs_common_getattr 373 * 374 * Implements functionality common to all ctfs VOP_GETATTR entry 375 * points. It assumes vap->va_size is set. 376 */ 377 void 378 ctfs_common_getattr(vnode_t *vp, vattr_t *vap) 379 { 380 vap->va_uid = 0; 381 vap->va_gid = 0; 382 vap->va_rdev = 0; 383 vap->va_blksize = DEV_BSIZE; 384 vap->va_nblocks = howmany(vap->va_size, vap->va_blksize); 385 vap->va_seq = 0; 386 vap->va_fsid = vp->v_vfsp->vfs_dev; 387 vap->va_nodeid = gfs_file_inode(vp); 388 } 389 390 /* 391 * ctfs_open - common VOP_OPEN entry point 392 * 393 * Used by all ctfs directories; just verifies we are using large-file 394 * aware interfaces and we aren't trying to open the directories 395 * writable. 396 */ 397 /* ARGSUSED */ 398 int 399 ctfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct) 400 { 401 if ((flag & (FOFFMAX | FWRITE)) != FOFFMAX) 402 return (EINVAL); 403 404 return (0); 405 } 406 407 /* 408 * ctfs_close - common VOP_CLOSE entry point 409 * 410 * For all ctfs vnode types which have no close-time clean-up to do. 411 */ 412 /* ARGSUSED */ 413 int 414 ctfs_close( 415 vnode_t *vp, 416 int flag, 417 int count, 418 offset_t offset, 419 cred_t *cr, 420 caller_context_t *ct) 421 { 422 return (0); 423 } 424 425 /* 426 * ctfs_access_dir - common VOP_ACCESS entry point for directories 427 */ 428 /* ARGSUSED */ 429 int 430 ctfs_access_dir( 431 vnode_t *vp, 432 int mode, 433 int flags, 434 cred_t *cr, 435 caller_context_t *ct) 436 { 437 if (mode & VWRITE) 438 return (EACCES); 439 440 return (0); 441 } 442 443 /* 444 * ctfs_access_dir - common VOP_ACCESS entry point for read-only files 445 */ 446 /* ARGSUSED */ 447 int 448 ctfs_access_readonly( 449 vnode_t *vp, 450 int mode, 451 int flags, 452 cred_t *cr, 453 caller_context_t *ct) 454 { 455 if (mode & (VWRITE | VEXEC)) 456 return (EACCES); 457 458 return (0); 459 } 460 461 /* 462 * ctfs_access_dir - common VOP_ACCESS entry point for read-write files 463 */ 464 /* ARGSUSED */ 465 int 466 ctfs_access_readwrite( 467 vnode_t *vp, 468 int mode, 469 int flags, 470 cred_t *cr, 471 caller_context_t *ct) 472 { 473 if (mode & VEXEC) 474 return (EACCES); 475 476 return (0); 477 } 478 479 /* 480 * ctfs_root_getattr - VOP_GETATTR entry point 481 */ 482 /* ARGSUSED */ 483 static int 484 ctfs_root_getattr( 485 vnode_t *vp, 486 vattr_t *vap, 487 int flags, 488 cred_t *cr, 489 caller_context_t *ct) 490 { 491 vap->va_type = VDIR; 492 vap->va_mode = 0555; 493 vap->va_nlink = 2 + ct_ntypes + 1; 494 vap->va_size = vap->va_nlink; 495 vap->va_atime.tv_sec = vp->v_vfsp->vfs_mtime; 496 vap->va_atime.tv_nsec = 0; 497 vap->va_mtime = vap->va_ctime = vap->va_atime; 498 ctfs_common_getattr(vp, vap); 499 500 return (0); 501 } 502 503 /* ARGSUSED */ 504 static ino64_t 505 ctfs_root_do_inode(vnode_t *vp, int index) 506 { 507 return (CTFS_INO_TYPE_DIR(index)); 508 } 509 510 static const fs_operation_def_t ctfs_tops_root[] = { 511 { VOPNAME_OPEN, { .vop_open = ctfs_open } }, 512 { VOPNAME_CLOSE, { .vop_close = ctfs_close } }, 513 { VOPNAME_IOCTL, { .error = fs_inval } }, 514 { VOPNAME_GETATTR, { .vop_getattr = ctfs_root_getattr } }, 515 { VOPNAME_ACCESS, { .vop_access = ctfs_access_dir } }, 516 { VOPNAME_READDIR, { .vop_readdir = gfs_vop_readdir } }, 517 { VOPNAME_LOOKUP, { .vop_lookup = gfs_vop_lookup } }, 518 { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 519 { VOPNAME_INACTIVE, { .vop_inactive = gfs_vop_inactive } }, 520 { NULL, NULL } 521 }; 522