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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <sys/types.h> 30 #include <sys/param.h> 31 #include <sys/time.h> 32 #include <sys/cred.h> 33 #include <sys/vfs.h> 34 #include <sys/gfs.h> 35 #include <sys/vnode.h> 36 #include <sys/systm.h> 37 #include <sys/errno.h> 38 #include <sys/sysmacros.h> 39 #include <fs/fs_subr.h> 40 #include <sys/contract.h> 41 #include <sys/contract_impl.h> 42 #include <sys/ctfs.h> 43 #include <sys/ctfs_impl.h> 44 #include <sys/file.h> 45 #include <sys/policy.h> 46 47 /* 48 * CTFS routines for the /system/contract/<type>/bundle vnode. 49 * CTFS routines for the /system/contract/<type>/pbundle vnode. 50 * CTFS routines for the /system/contract/<type>/<ctid>/events vnode. 51 */ 52 53 /* 54 * ctfs_endpoint_open 55 * 56 * Called by the VOP_OPEN entry points to perform some common checks 57 * and set up the endpoint listener, if not already done. 58 */ 59 static int 60 ctfs_endpoint_open(ctfs_endpoint_t *endpt, ct_equeue_t *q, int flag) 61 { 62 if ((flag & ~FNONBLOCK) != (FREAD | FOFFMAX)) 63 return (EINVAL); 64 65 mutex_enter(&endpt->ctfs_endpt_lock); 66 if ((endpt->ctfs_endpt_flags & CTFS_ENDPT_SETUP) == 0) { 67 endpt->ctfs_endpt_flags |= CTFS_ENDPT_SETUP; 68 if (flag & FNONBLOCK) 69 endpt->ctfs_endpt_flags |= CTFS_ENDPT_NBLOCK; 70 cte_add_listener(q, &endpt->ctfs_endpt_listener); 71 } 72 mutex_exit(&endpt->ctfs_endpt_lock); 73 74 return (0); 75 } 76 77 /* 78 * ctfs_endpoint inactive 79 * 80 * Called by the VOP_INACTIVE entry points to perform common listener 81 * cleanup. 82 */ 83 static void 84 ctfs_endpoint_inactive(ctfs_endpoint_t *endpt) 85 { 86 mutex_enter(&endpt->ctfs_endpt_lock); 87 if (endpt->ctfs_endpt_flags & CTFS_ENDPT_SETUP) { 88 endpt->ctfs_endpt_flags = 0; 89 cte_remove_listener(&endpt->ctfs_endpt_listener); 90 } 91 mutex_exit(&endpt->ctfs_endpt_lock); 92 } 93 94 /* 95 * ctfs_endpoint_ioctl 96 * 97 * Implements the common VOP_IOCTL handling for the event endpoints. 98 * rprivchk, if true, indicates that event receive requests should 99 * check the provided credentials. This distinction exists because 100 * contract endpoints perform their privilege checks at open-time, and 101 * process bundle queue listeners by definition may view all events 102 * their queues contain. 103 */ 104 static int 105 ctfs_endpoint_ioctl(ctfs_endpoint_t *endpt, int cmd, intptr_t arg, cred_t *cr, 106 zone_t *zone, int rprivchk) 107 { 108 uint64_t id, zuniqid; 109 110 zuniqid = zone->zone_uniqid; 111 112 switch (cmd) { 113 case CT_ERESET: 114 cte_reset_listener(&endpt->ctfs_endpt_listener); 115 break; 116 case CT_ERECV: 117 /* 118 * We pass in NULL for the cred when reading from 119 * process bundle queues and contract queues because 120 * the privilege check was performed at open time. 121 */ 122 return (cte_get_event(&endpt->ctfs_endpt_listener, 123 endpt->ctfs_endpt_flags & CTFS_ENDPT_NBLOCK, 124 (void *)arg, rprivchk ? cr : NULL, zuniqid, 0)); 125 case CT_ECRECV: 126 return (cte_get_event(&endpt->ctfs_endpt_listener, 127 endpt->ctfs_endpt_flags & CTFS_ENDPT_NBLOCK, 128 (void *)arg, rprivchk ? cr : NULL, zuniqid, 1)); 129 case CT_ENEXT: 130 if (copyin((void *)arg, &id, sizeof (uint64_t))) 131 return (EFAULT); 132 return (cte_next_event(&endpt->ctfs_endpt_listener, id)); 133 case CT_ERELIABLE: 134 return (cte_set_reliable(&endpt->ctfs_endpt_listener, cr)); 135 default: 136 return (EINVAL); 137 } 138 139 return (0); 140 } 141 142 /* 143 * ctfs_endpoint_poll 144 * 145 * Called by the VOP_POLL entry points. 146 */ 147 static int 148 ctfs_endpoint_poll(ctfs_endpoint_t *endpt, short events, int anyyet, 149 short *reventsp, pollhead_t **php) 150 { 151 if ((events & POLLIN) && endpt->ctfs_endpt_listener.ctl_position) { 152 *reventsp = POLLIN; 153 } else { 154 *reventsp = 0; 155 if (!anyyet) 156 *php = &endpt->ctfs_endpt_listener.ctl_pollhead; 157 } 158 159 return (0); 160 } 161 162 /* 163 * ctfs_create_evnode 164 * 165 * Creates and returns a new evnode. 166 */ 167 vnode_t * 168 ctfs_create_evnode(vnode_t *pvp) 169 { 170 vnode_t *vp; 171 ctfs_evnode_t *evnode; 172 ctfs_cdirnode_t *cdirnode = pvp->v_data; 173 174 vp = gfs_file_create(sizeof (ctfs_evnode_t), pvp, ctfs_ops_event); 175 evnode = vp->v_data; 176 177 /* 178 * We transitively have a hold on the contract through our 179 * parent directory. 180 */ 181 evnode->ctfs_ev_contract = cdirnode->ctfs_cn_contract; 182 183 return (vp); 184 } 185 186 /* 187 * ctfs_ev_access - VOP_ACCESS entry point 188 * 189 * You only get to access event files for contracts you or your 190 * effective user id owns, unless you have a privilege. 191 */ 192 /*ARGSUSED*/ 193 static int 194 ctfs_ev_access(vnode_t *vp, int mode, int flags, cred_t *cr) 195 { 196 ctfs_evnode_t *evnode = vp->v_data; 197 contract_t *ct = evnode->ctfs_ev_contract; 198 int error; 199 200 if (mode & (VWRITE | VEXEC)) 201 return (EACCES); 202 203 if (error = secpolicy_contract_observer(cr, ct)) 204 return (error); 205 206 return (0); 207 } 208 209 /* 210 * ctfs_ev_open - VOP_OPEN entry point 211 * 212 * Performs the same privilege checks as ctfs_ev_access, and then calls 213 * ctfs_endpoint_open to perform the common endpoint initialization. 214 */ 215 /* ARGSUSED */ 216 static int 217 ctfs_ev_open(vnode_t **vpp, int flag, cred_t *cr) 218 { 219 ctfs_evnode_t *evnode = (*vpp)->v_data; 220 contract_t *ct = evnode->ctfs_ev_contract; 221 int error; 222 223 if (error = secpolicy_contract_observer(cr, ct)) 224 return (error); 225 226 /* 227 * See comment in ctfs_bu_open. 228 */ 229 return (ctfs_endpoint_open(&evnode->ctfs_ev_listener, 230 &evnode->ctfs_ev_contract->ct_events, flag)); 231 } 232 233 /* 234 * ctfs_ev_inactive - VOP_INACTIVE entry point 235 */ 236 /* ARGSUSED */ 237 static void 238 ctfs_ev_inactive(vnode_t *vp, cred_t *cr) 239 { 240 ctfs_evnode_t *evnode; 241 vnode_t *pvp = gfs_file_parent(vp); 242 243 /* 244 * We must destroy the endpoint before releasing the parent; otherwise 245 * we will try to destroy a contract with active listeners. To prevent 246 * this, we grab an extra hold on the parent. 247 */ 248 VN_HOLD(pvp); 249 if ((evnode = gfs_file_inactive(vp)) != NULL) { 250 ctfs_endpoint_inactive(&evnode->ctfs_ev_listener); 251 kmem_free(evnode, sizeof (ctfs_evnode_t)); 252 } 253 VN_RELE(pvp); 254 } 255 256 /* 257 * ctfs_ev_getattr - VOP_GETATTR entry point 258 */ 259 /* ARGSUSED */ 260 static int 261 ctfs_ev_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr) 262 { 263 ctfs_evnode_t *evnode = vp->v_data; 264 265 vap->va_type = VREG; 266 vap->va_mode = 0444; 267 vap->va_nlink = 1; 268 vap->va_size = 0; 269 vap->va_ctime = evnode->ctfs_ev_contract->ct_ctime; 270 mutex_enter(&evnode->ctfs_ev_contract->ct_events.ctq_lock); 271 vap->va_atime = vap->va_mtime = 272 evnode->ctfs_ev_contract->ct_events.ctq_atime; 273 mutex_exit(&evnode->ctfs_ev_contract->ct_events.ctq_lock); 274 ctfs_common_getattr(vp, vap); 275 276 return (0); 277 } 278 279 /* 280 * ctfs_ev_ioctl - VOP_IOCTL entry point 281 */ 282 /* ARGSUSED */ 283 static int 284 ctfs_ev_ioctl(vnode_t *vp, int cmd, intptr_t arg, int flag, cred_t *cr, 285 int *rvalp) 286 { 287 ctfs_evnode_t *evnode = vp->v_data; 288 289 return (ctfs_endpoint_ioctl(&evnode->ctfs_ev_listener, cmd, arg, cr, 290 VTOZONE(vp), 0)); 291 } 292 293 /* 294 * ctfs_ev_poll - VOP_POLL entry point 295 */ 296 static int 297 ctfs_ev_poll(vnode_t *vp, short events, int anyyet, short *reventsp, 298 pollhead_t **php) 299 { 300 ctfs_evnode_t *evnode = vp->v_data; 301 302 return (ctfs_endpoint_poll(&evnode->ctfs_ev_listener, events, anyyet, 303 reventsp, php)); 304 } 305 306 const fs_operation_def_t ctfs_tops_event[] = { 307 { VOPNAME_OPEN, ctfs_ev_open }, 308 { VOPNAME_CLOSE, ctfs_close }, 309 { VOPNAME_IOCTL, ctfs_ev_ioctl }, 310 { VOPNAME_GETATTR, ctfs_ev_getattr }, 311 { VOPNAME_ACCESS, ctfs_ev_access }, 312 { VOPNAME_READDIR, fs_notdir }, 313 { VOPNAME_LOOKUP, fs_notdir }, 314 { VOPNAME_INACTIVE, (fs_generic_func_p) ctfs_ev_inactive }, 315 { VOPNAME_POLL, (fs_generic_func_p) ctfs_ev_poll }, 316 { NULL, NULL } 317 }; 318 319 /* 320 * ctfs_create_pbundle 321 * 322 * Creates and returns a bunode for a /system/contract/<type>/pbundle 323 * file. 324 */ 325 vnode_t * 326 ctfs_create_pbundle(vnode_t *pvp) 327 { 328 vnode_t *vp; 329 ctfs_bunode_t *bundle; 330 331 vp = gfs_file_create(sizeof (ctfs_bunode_t), pvp, ctfs_ops_bundle); 332 bundle = vp->v_data; 333 bundle->ctfs_bu_queue = 334 contract_type_pbundle(ct_types[gfs_file_index(pvp)], curproc); 335 336 return (vp); 337 } 338 339 /* 340 * ctfs_create_bundle 341 * 342 * Creates and returns a bunode for a /system/contract/<type>/bundle 343 * file. 344 */ 345 vnode_t * 346 ctfs_create_bundle(vnode_t *pvp) 347 { 348 vnode_t *vp; 349 ctfs_bunode_t *bundle; 350 351 vp = gfs_file_create(sizeof (ctfs_bunode_t), pvp, ctfs_ops_bundle); 352 bundle = vp->v_data; 353 bundle->ctfs_bu_queue = 354 contract_type_bundle(ct_types[gfs_file_index(pvp)]); 355 356 return (vp); 357 } 358 359 /* 360 * ctfs_bu_open - VOP_OPEN entry point 361 */ 362 /* ARGSUSED */ 363 static int 364 ctfs_bu_open(vnode_t **vpp, int flag, cred_t *cr) 365 { 366 ctfs_bunode_t *bunode = (*vpp)->v_data; 367 368 /* 369 * This assumes we are only ever called immediately after a 370 * VOP_LOOKUP. We could clone ourselves here, but doing so 371 * would make /proc/pid/fd accesses less useful. 372 */ 373 return (ctfs_endpoint_open(&bunode->ctfs_bu_listener, 374 bunode->ctfs_bu_queue, flag)); 375 } 376 377 /* 378 * ctfs_bu_inactive - VOP_INACTIVE entry point 379 */ 380 /* ARGSUSED */ 381 static void 382 ctfs_bu_inactive(vnode_t *vp, cred_t *cr) 383 { 384 ctfs_bunode_t *bunode; 385 vnode_t *pvp = gfs_file_parent(vp); 386 387 /* 388 * See comments in ctfs_ev_inactive() above. 389 */ 390 VN_HOLD(pvp); 391 if ((bunode = gfs_file_inactive(vp)) != NULL) { 392 ctfs_endpoint_inactive(&bunode->ctfs_bu_listener); 393 kmem_free(bunode, sizeof (ctfs_bunode_t)); 394 } 395 VN_RELE(pvp); 396 } 397 398 /* 399 * ctfs_bu_getattr - VOP_GETATTR entry point 400 */ 401 /* ARGSUSED */ 402 static int 403 ctfs_bu_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr) 404 { 405 ctfs_bunode_t *bunode = vp->v_data; 406 407 vap->va_type = VREG; 408 vap->va_mode = 0444; 409 vap->va_nodeid = gfs_file_index(vp); 410 vap->va_nlink = 1; 411 vap->va_size = 0; 412 vap->va_ctime.tv_sec = vp->v_vfsp->vfs_mtime; 413 vap->va_ctime.tv_nsec = 0; 414 mutex_enter(&bunode->ctfs_bu_queue->ctq_lock); 415 vap->va_mtime = vap->va_atime = bunode->ctfs_bu_queue->ctq_atime; 416 mutex_exit(&bunode->ctfs_bu_queue->ctq_lock); 417 ctfs_common_getattr(vp, vap); 418 419 return (0); 420 } 421 422 /* 423 * ctfs_bu_ioctl - VOP_IOCTL entry point 424 */ 425 /* ARGSUSED */ 426 static int 427 ctfs_bu_ioctl(vnode_t *vp, int cmd, intptr_t arg, int flag, cred_t *cr, 428 int *rvalp) 429 { 430 ctfs_bunode_t *bunode = vp->v_data; 431 432 return (ctfs_endpoint_ioctl(&bunode->ctfs_bu_listener, cmd, arg, cr, 433 VTOZONE(vp), bunode->ctfs_bu_queue->ctq_listno == CTEL_BUNDLE)); 434 } 435 436 /* 437 * ctfs_bu_poll - VOP_POLL entry point 438 */ 439 static int 440 ctfs_bu_poll(vnode_t *vp, short events, int anyyet, short *reventsp, 441 pollhead_t **php) 442 { 443 ctfs_bunode_t *bunode = vp->v_data; 444 445 return (ctfs_endpoint_poll(&bunode->ctfs_bu_listener, events, anyyet, 446 reventsp, php)); 447 } 448 449 const fs_operation_def_t ctfs_tops_bundle[] = { 450 { VOPNAME_OPEN, ctfs_bu_open }, 451 { VOPNAME_CLOSE, ctfs_close }, 452 { VOPNAME_IOCTL, ctfs_bu_ioctl }, 453 { VOPNAME_GETATTR, ctfs_bu_getattr }, 454 { VOPNAME_ACCESS, ctfs_access_readonly }, 455 { VOPNAME_READDIR, fs_notdir }, 456 { VOPNAME_LOOKUP, fs_notdir }, 457 { VOPNAME_INACTIVE, (fs_generic_func_p) ctfs_bu_inactive }, 458 { VOPNAME_POLL, (fs_generic_func_p) ctfs_bu_poll }, 459 { NULL, NULL } 460 }; 461