1 #include <sys/mode.h> 2 #include <sys/zfs_znode.h> 3 #include <sys/fs/zfs.h> 4 #include <sys/fs/zev.h> 5 #include <sys/zfs_events.h> 6 #include <sys/zev_checksums.h> 7 #include <sys/dmu_tx.h> 8 #include <sys/mntent.h> 9 10 #define ZEV_FILL_INODE_INFO(name, znode) \ 11 do { \ 12 uint64_t mtime[2], ctime[2]; \ 13 sa_bulk_attr_t bulk[2]; \ 14 int count = 0; \ 15 timestruc_t mtime_s, ctime_s; \ 16 SA_ADD_BULK_ATTR(bulk, count, \ 17 SA_ZPL_MTIME(znode->z_zfsvfs), \ 18 NULL, &mtime, 16); \ 19 SA_ADD_BULK_ATTR(bulk, count, \ 20 SA_ZPL_CTIME(znode->z_zfsvfs), \ 21 NULL, &ctime, 16); \ 22 if ((sa_bulk_lookup(znode->z_sa_hdl, bulk, count)) != 0) { \ 23 zev_queue_error(op, "znode write: " \ 24 "mtime/ctime unavailable"); \ 25 /* continue anyway, use fake data */ \ 26 mtime_s.tv_sec = ctime_s.tv_sec = 0; \ 27 } \ 28 ZFS_TIME_DECODE(&mtime_s, mtime); \ 29 ZFS_TIME_DECODE(&ctime_s, ctime); \ 30 rec->name.ino = znode->z_id; \ 31 rec->name.gen = znode->z_gen; \ 32 rec->name.mtime = mtime_s.tv_sec; \ 33 rec->name.ctime = ctime_s.tv_sec; \ 34 rec->name.size = znode->z_size; \ 35 rec->name.type = znode->z_vnode->v_type; \ 36 rec->name.mode = \ 37 znode->z_mode | VTTOIF(znode->z_vnode->v_type); \ 38 rec->name.links = znode->z_links; \ 39 rec->name.flags = znode->z_pflags & ZFS_XATTR ? \ 40 ZEV_FL_XATTR : 0; \ 41 } while(0) 42 43 void 44 zev_zfs_mount_cb(vfs_t *vfs, vnode_t *mpt, char *dataset, boolean_t remount) 45 { 46 int op = ZEV_OP_ZFS_MOUNT; 47 char mountpoint[MAXPATHLEN+1]; 48 int mountpoint_len; 49 int dataset_len; 50 zev_zfs_mount_t *rec; 51 zev_msg_t *msg = NULL; 52 int msg_size; 53 znode_t *zp_root; 54 55 zfsvfs_t *zfsvfs = (zfsvfs_t *)vfs->vfs_data; 56 if (zfsvfs->z_os->os_dsl_dataset->ds_is_snapshot) 57 return; 58 if (zev_skip_pool(zfsvfs->z_os)) 59 return; 60 /* expensive, but we don't have many mount ops. */ 61 if ((vnodetopath(NULL, mpt, mountpoint, sizeof(mountpoint), 62 kcred)) != 0) { 63 zev_queue_error(op, "unresolvable mountpoint, dataset=%s", 64 dataset); 65 return; 66 } 67 if (zfs_zget(zfsvfs, zfsvfs->z_root, &zp_root) != 0) { 68 zev_queue_error(op, "can't get root znode, dataset=%s", 69 dataset); 70 return; 71 } 72 73 dataset_len = strlen(dataset); 74 mountpoint_len = strlen(mountpoint); 75 msg_size = sizeof(*rec) + dataset_len + 1 + mountpoint_len + 1; 76 msg = zev_alloc(sizeof(*msg) + msg_size); 77 msg->size = msg_size; 78 rec = (zev_zfs_mount_t *)(msg + 1); 79 rec->record_len = msg_size; 80 rec->op = op; 81 rec->op_time = ddi_get_time(); 82 rec->guid = dsl_dataset_phys(zfsvfs->z_os->os_dsl_dataset)->ds_guid; 83 rec->remount = remount; 84 rec->dataset_len = dataset_len; 85 rec->mountpoint_len = mountpoint_len; 86 ZEV_FILL_INODE_INFO(root, zp_root); 87 VN_RELE(ZTOV(zp_root)); 88 (void) memcpy(ZEV_DATASET(rec), dataset, dataset_len + 1); 89 (void) memcpy(ZEV_MOUNTPOINT(rec), mountpoint, mountpoint_len + 1); 90 zev_queue_message(op, msg); 91 } 92 93 void 94 zev_zfs_umount_cb(vfs_t *vfs) 95 { 96 int op = ZEV_OP_ZFS_UMOUNT; 97 zev_zfs_umount_t *rec; 98 zev_msg_t *msg = NULL; 99 int msg_size; 100 struct vnode *vp; 101 znode_t *zp; 102 103 zfsvfs_t *zfsvfs = (zfsvfs_t *)vfs->vfs_data; 104 if (zfsvfs->z_os->os_dsl_dataset->ds_is_snapshot) 105 return; 106 if (zev_skip_pool(zfsvfs->z_os)) 107 return; 108 109 msg_size = sizeof(*rec); 110 msg = zev_alloc(sizeof(*msg) + msg_size); 111 msg->size = msg_size; 112 rec = (zev_zfs_umount_t *)(msg + 1); 113 rec->record_len = msg_size; 114 rec->op = op; 115 rec->op_time = ddi_get_time(); 116 rec->guid = dsl_dataset_phys(zfsvfs->z_os->os_dsl_dataset)->ds_guid; 117 118 vp = vfs->vfs_vnodecovered; 119 if (strcmp(vfssw[vp->v_vfsp->vfs_fstype].vsw_name, MNTTYPE_ZFS)) { 120 cmn_err(CE_WARN, "covered inode not on zfs filesystem, " 121 "reporting all-zero inode struct."); 122 memset(&rec->covered, 0, sizeof(rec->covered)); 123 } else { 124 zp = VTOZ(vfs->vfs_vnodecovered); 125 ZEV_FILL_INODE_INFO(covered, zp); 126 } 127 128 zev_queue_message(op, msg); 129 } 130 131 void 132 zev_zvol_truncate_cb(char *dataset, 133 objset_t *os, 134 dmu_tx_t *tx, 135 uint64_t off, 136 uint64_t len) 137 { 138 int op = ZEV_OP_ZVOL_TRUNCATE; 139 zev_zvol_truncate_t *rec; 140 zev_msg_t *msg = NULL; 141 int msg_size; 142 int dataset_len; 143 144 if (zev_skip_pool(os)) 145 return; 146 147 dataset_len = strlen(dataset); 148 msg_size = sizeof(*rec) + dataset_len + 1; 149 msg = zev_alloc(sizeof(*msg) + msg_size); 150 msg->size = msg_size; 151 rec = (zev_zvol_truncate_t *)(msg + 1); 152 rec->record_len = msg_size; 153 rec->op = op; 154 rec->op_time = ddi_get_time(); 155 rec->guid = dsl_dataset_phys(os->os_dsl_dataset)->ds_guid; 156 rec->txg = tx->tx_txg; 157 rec->offset = off; 158 rec->length = len; 159 rec->dataset_len = dataset_len; 160 (void) memcpy(ZEV_DATASET(rec), dataset, dataset_len + 1); 161 zev_queue_message(op, msg); 162 } 163 164 void 165 zev_zvol_write_cb(char *dataset, 166 objset_t *os, 167 dmu_tx_t *tx, 168 uint64_t off, 169 uint64_t len) 170 { 171 int op = ZEV_OP_ZVOL_WRITE; 172 zev_zvol_write_t *rec; 173 zev_msg_t *msg = NULL; 174 int msg_size; 175 int dataset_len; 176 177 if (zev_skip_pool(os)) 178 return; 179 180 dataset_len = strlen(dataset); 181 msg_size = sizeof(*rec) + dataset_len + 1; 182 msg = zev_alloc(sizeof(*msg) + msg_size); 183 msg->size = msg_size; 184 rec = (zev_zvol_write_t *)(msg + 1); 185 rec->record_len = msg_size; 186 rec->op = op; 187 rec->op_time = ddi_get_time(); 188 rec->guid = dsl_dataset_phys(os->os_dsl_dataset)->ds_guid; 189 rec->txg = tx->tx_txg; 190 rec->offset = off; 191 rec->length = len; 192 rec->dataset_len = dataset_len; 193 (void) memcpy(ZEV_DATASET(rec), dataset, dataset_len + 1); 194 zev_queue_message(op, msg); 195 } 196 197 void 198 zev_znode_close_after_update_cb(znode_t *zp) 199 { 200 int op = ZEV_OP_ZNODE_CLOSE_AFTER_UPDATE; 201 zev_znode_close_after_update_t *rec; 202 zev_msg_t *msg = NULL; 203 int msg_size; 204 205 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 206 return; 207 208 msg_size = sizeof(*rec); 209 msg = zev_alloc(sizeof(*msg) + msg_size); 210 msg->size = msg_size; 211 rec = (zev_znode_close_after_update_t *)(msg + 1); 212 rec->record_len = msg_size; 213 rec->op = op; 214 rec->op_time = ddi_get_time(); 215 rec->guid = 216 dsl_dataset_phys(zp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 217 ZEV_FILL_INODE_INFO(file, zp); 218 zev_queue_message(op, msg); 219 } 220 221 void 222 zev_znode_create_cb(znode_t *dzp, 223 znode_t *zp, 224 dmu_tx_t *tx, 225 char *name, 226 uint64_t txtype) 227 { 228 int op = ZEV_OP_ZNODE_CREATE; 229 zev_znode_create_t *rec; 230 zev_msg_t *msg = NULL; 231 int msg_size; 232 int name_len; 233 234 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 235 return; 236 237 int type = (int)txtype; 238 switch(type) { 239 case TX_CREATE: 240 case TX_CREATE_ACL: 241 case TX_CREATE_ATTR: 242 case TX_CREATE_ACL_ATTR: 243 op = ZEV_OP_ZNODE_CREATE; 244 break; 245 case TX_MKDIR: 246 case TX_MKDIR_ACL: 247 case TX_MKDIR_ATTR: 248 case TX_MKDIR_ACL_ATTR: 249 op = ZEV_OP_ZNODE_MKDIR; 250 break; 251 case TX_MKXATTR: 252 op = ZEV_OP_ZNODE_MAKE_XATTR_DIR; 253 break; 254 default: 255 zev_queue_error(ZEV_OP_ZNODE_CREATE, 256 "ERROR: ZNODE_CREATE: unknown txtype %d " 257 "(dir_inode=%d:%d inode=%d:%d name='%s')\n", 258 type, 259 dzp->z_gen, 260 dzp->z_id, 261 zp->z_gen, 262 zp->z_id, 263 name); 264 return; 265 } 266 267 /* all three types use the same struct, so this works for all types: */ 268 name_len = strlen(name); 269 msg_size = sizeof(*rec) + name_len + 1; 270 msg = zev_alloc(sizeof(*msg) + msg_size); 271 msg->size = msg_size; 272 rec = (zev_znode_create_t *)(msg + 1); 273 rec->record_len = msg_size; 274 rec->op = op; 275 rec->op_time = ddi_get_time(); 276 rec->guid = 277 dsl_dataset_phys(zp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 278 rec->txg = tx->tx_txg; 279 ZEV_FILL_INODE_INFO(parent, dzp); 280 ZEV_FILL_INODE_INFO(file, zp); 281 rec->name_len = name_len; 282 (void) memcpy(ZEV_NAME(rec), name, name_len + 1); 283 zev_create_checksum(rec, zp); 284 zev_queue_message(op, msg); 285 } 286 287 void 288 zev_znode_remove_cb(znode_t *dzp, 289 znode_t *zp, 290 dmu_tx_t *tx, 291 char *name, 292 uint64_t txtype) 293 { 294 int op = ZEV_OP_ZNODE_REMOVE; 295 zev_znode_remove_t *rec; 296 zev_msg_t *msg = NULL; 297 int msg_size; 298 int name_len; 299 300 if (zev_skip_pool(dzp->z_zfsvfs->z_os)) 301 return; 302 303 int type = (int)txtype; 304 switch(type) { 305 case TX_REMOVE: 306 op = ZEV_OP_ZNODE_REMOVE; 307 break; 308 case TX_RMDIR: 309 op = ZEV_OP_ZNODE_RMDIR; 310 break; 311 default: 312 zev_queue_error(ZEV_OP_ZNODE_REMOVE, 313 "ERROR: ZNODE_REMOVE: unknown txtype %d " 314 "(dir_inode=%d:%d name='%s')\n", 315 type, 316 dzp->z_gen, 317 dzp->z_id, 318 name); 319 return; 320 } 321 322 /* both types use the same struct, so this works for all types: */ 323 name_len = strlen(name); 324 msg_size = sizeof(*rec) + name_len + 1; 325 msg = zev_alloc(sizeof(*msg) + msg_size); 326 msg->size = msg_size; 327 rec = (zev_znode_remove_t *)(msg + 1); 328 rec->record_len = msg_size; 329 rec->op = op; 330 rec->op_time = ddi_get_time(); 331 rec->guid = 332 dsl_dataset_phys(dzp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 333 rec->txg = tx->tx_txg; 334 ZEV_FILL_INODE_INFO(file, zp); 335 ZEV_FILL_INODE_INFO(parent, dzp); 336 rec->name_len = name_len; 337 (void) memcpy(ZEV_NAME(rec), name, name_len + 1); 338 zev_queue_message(op, msg); 339 } 340 341 void 342 zev_znode_link_cb(znode_t *dzp, znode_t *zp, dmu_tx_t *tx, char *name) 343 { 344 int op = ZEV_OP_ZNODE_LINK; 345 zev_znode_link_t *rec; 346 zev_msg_t *msg = NULL; 347 int msg_size; 348 int name_len; 349 350 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 351 return; 352 353 name_len = strlen(name); 354 msg_size = sizeof(*rec) + name_len + 1; 355 msg = zev_alloc(sizeof(*msg) + msg_size); 356 msg->size = msg_size; 357 rec = (zev_znode_link_t *)(msg + 1); 358 rec->record_len = msg_size; 359 rec->op = op; 360 rec->op_time = ddi_get_time(); 361 rec->guid = 362 dsl_dataset_phys(zp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 363 rec->txg = tx->tx_txg; 364 ZEV_FILL_INODE_INFO(parent, dzp); 365 ZEV_FILL_INODE_INFO(file, zp); 366 rec->name_len = name_len; 367 (void) memcpy(ZEV_NAME(rec), name, name_len + 1); 368 zev_queue_message(op, msg); 369 } 370 371 void 372 zev_znode_symlink_cb(znode_t *dzp, 373 znode_t *zp, 374 dmu_tx_t *tx, 375 char *name, 376 char *link) 377 { 378 int op = ZEV_OP_ZNODE_SYMLINK; 379 zev_znode_symlink_t *rec; 380 zev_msg_t *msg = NULL; 381 int msg_size; 382 int name_len; 383 int link_len; 384 385 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 386 return; 387 388 name_len = strlen(name); 389 link_len = strlen(link); 390 msg_size = sizeof(*rec) + name_len + 1 + link_len + 1; 391 msg = zev_alloc(sizeof(*msg) + msg_size); 392 msg->size = msg_size; 393 rec = (zev_znode_symlink_t *)(msg + 1); 394 rec->record_len = msg_size; 395 rec->op = op; 396 rec->op_time = ddi_get_time(); 397 rec->guid = 398 dsl_dataset_phys(dzp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 399 rec->txg = tx->tx_txg; 400 ZEV_FILL_INODE_INFO(parent, dzp); 401 ZEV_FILL_INODE_INFO(file, zp); 402 rec->name_len = name_len; 403 rec->link_len = link_len; 404 (void) memcpy(ZEV_NAME(rec), name, name_len + 1); 405 (void) memcpy(ZEV_LINK(rec), link, link_len + 1); 406 zev_symlink_checksum(rec, link); 407 zev_queue_message(op, msg); 408 } 409 410 void 411 zev_znode_rename_cb(znode_t *sdzp, 412 char *sname, 413 znode_t *tdzp, 414 char *tname, 415 znode_t *szp, 416 znode_t *tzp, 417 dmu_tx_t *tx) 418 { 419 int op = ZEV_OP_ZNODE_RENAME; 420 zev_znode_rename_t *rec; 421 zev_msg_t *msg = NULL; 422 int msg_size; 423 int srcname_len; 424 int dstname_len; 425 426 if (zev_skip_pool(szp->z_zfsvfs->z_os)) 427 return; 428 429 srcname_len = strlen(sname); 430 dstname_len = strlen(tname); 431 msg_size = sizeof(*rec) + srcname_len + 1 + dstname_len + 1; 432 msg = zev_alloc(sizeof(*msg) + msg_size); 433 msg->size = msg_size; 434 rec = (zev_znode_rename_t *)(msg + 1); 435 rec->record_len = msg_size; 436 rec->op = op; 437 rec->op_time = ddi_get_time(); 438 rec->guid = 439 dsl_dataset_phys(szp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 440 rec->txg = tx->tx_txg; 441 ZEV_FILL_INODE_INFO(srcdir, sdzp); 442 ZEV_FILL_INODE_INFO(dstdir, tdzp); 443 ZEV_FILL_INODE_INFO(file, szp); 444 if (tzp) { 445 ZEV_FILL_INODE_INFO(clobbered_file, tzp); 446 } else { 447 memset(&rec->clobbered_file, 0, sizeof(rec->clobbered_file)); 448 } 449 rec->srcname_len = srcname_len; 450 rec->dstname_len = dstname_len; 451 (void) memcpy(ZEV_SRCNAME(rec), sname, srcname_len + 1); 452 (void) memcpy(ZEV_DSTNAME(rec), tname, dstname_len + 1); 453 zev_queue_message(op, msg); 454 } 455 456 void 457 zev_znode_write_cb(znode_t *zp, dmu_tx_t *tx, uint64_t off, uint64_t len) 458 { 459 int op = ZEV_OP_ZNODE_WRITE; 460 zev_znode_write_t *rec; 461 zev_msg_t *msg = NULL; 462 int msg_size; 463 zev_sig_t *sig_buf; 464 uint64_t sig_buf_len; 465 uint64_t sig_len; 466 uint64_t sig_cnt; 467 int ret; 468 469 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 470 return; 471 472 ret = zev_get_checksums(&sig_buf, &sig_buf_len, &sig_cnt, 0, 473 zp, off, len, zev_write); 474 if (ret) { 475 zev_queue_error(op, 476 "ERROR: ZNODE_WRITE: can't get checksum (inode=%d:%d)\n", 477 zp->z_gen, 478 zp->z_id); 479 return; 480 } 481 sig_len = sig_cnt * sizeof(zev_sig_t); 482 483 msg_size = sizeof(*rec) + sig_len; 484 msg = zev_alloc(sizeof(*msg) + msg_size); 485 msg->size = msg_size; 486 rec = (zev_znode_write_t *)(msg + 1); 487 rec->record_len = msg_size; 488 rec->op = op; 489 rec->op_time = ddi_get_time(); 490 rec->guid = 491 dsl_dataset_phys(zp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 492 rec->txg = tx->tx_txg; 493 ZEV_FILL_INODE_INFO(file, zp); 494 rec->offset = off; 495 rec->length = len; 496 rec->signature_cnt = sig_cnt; 497 if (sig_cnt && sig_buf) 498 memcpy(ZEV_SIGNATURES(rec), sig_buf, sig_len); 499 if (sig_buf) 500 zev_free(sig_buf, sig_buf_len); 501 zev_queue_message(op, msg); 502 } 503 504 void 505 zev_znode_truncate_cb(znode_t *zp, dmu_tx_t *tx, uint64_t off, uint64_t len) 506 { 507 int op = ZEV_OP_ZNODE_TRUNCATE; 508 zev_znode_truncate_t *rec; 509 zev_msg_t *msg = NULL; 510 int msg_size; 511 zev_sig_t *sig_buf; 512 uint64_t sig_buf_len; 513 uint64_t sig_len; 514 uint64_t sig_cnt; 515 int ret; 516 517 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 518 return; 519 520 ret = zev_get_checksums(&sig_buf, &sig_buf_len, &sig_cnt, 0, 521 zp, off, len, zev_truncate); 522 if (ret) { 523 zev_queue_error(op, 524 "ERROR: ZNODE_TRUNCATE: can't get checksum (inode=%d:%d)\n", 525 zp->z_gen, 526 zp->z_id); 527 return; 528 } 529 sig_len = sig_cnt * sizeof(zev_sig_t); 530 531 msg_size = sizeof(*rec) + sig_len; 532 msg = zev_alloc(sizeof(*msg) + msg_size); 533 msg->size = msg_size; 534 rec = (zev_znode_truncate_t *)(msg + 1); 535 rec->record_len = msg_size; 536 rec->op = op; 537 rec->op_time = ddi_get_time(); 538 rec->guid = 539 dsl_dataset_phys(zp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 540 rec->txg = tx->tx_txg; 541 ZEV_FILL_INODE_INFO(file, zp); 542 rec->offset = off; 543 rec->length = len; 544 rec->signature_cnt = sig_cnt; 545 if (sig_cnt && sig_buf) 546 memcpy(ZEV_SIGNATURES(rec), sig_buf, sig_len); 547 if (sig_buf) 548 zev_free(sig_buf, sig_buf_len); 549 zev_queue_message(op, msg); 550 } 551 552 void 553 zev_znode_setattr_cb(znode_t *zp, dmu_tx_t *tx) 554 { 555 int op = ZEV_OP_ZNODE_SETATTR; 556 zev_znode_setattr_t *rec; 557 zev_msg_t *msg = NULL; 558 int msg_size; 559 560 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 561 return; 562 563 msg_size = sizeof(*rec); 564 msg = zev_alloc(sizeof(*msg) + msg_size); 565 msg->size = msg_size; 566 rec = (zev_znode_setattr_t *)(msg + 1); 567 rec->record_len = msg_size; 568 rec->op = op; 569 rec->op_time = ddi_get_time(); 570 rec->guid = 571 dsl_dataset_phys(zp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 572 rec->txg = tx->tx_txg; 573 ZEV_FILL_INODE_INFO(file, zp); 574 zev_queue_message(op, msg); 575 } 576 577 void 578 zev_znode_acl_cb(znode_t *zp, dmu_tx_t *tx) 579 { 580 int op = ZEV_OP_ZNODE_ACL; 581 zev_znode_acl_t *rec; 582 zev_msg_t *msg = NULL; 583 int msg_size; 584 585 if (zev_skip_pool(zp->z_zfsvfs->z_os)) 586 return; 587 588 msg_size = sizeof(*rec); 589 msg = zev_alloc(sizeof(*msg) + msg_size); 590 msg->size = msg_size; 591 rec = (zev_znode_acl_t *)(msg + 1); 592 rec->record_len = msg_size; 593 rec->op = op; 594 rec->op_time = ddi_get_time(); 595 rec->guid = 596 dsl_dataset_phys(zp->z_zfsvfs->z_os->os_dsl_dataset)->ds_guid; 597 rec->txg = tx->tx_txg; 598 ZEV_FILL_INODE_INFO(file, zp); 599 zev_queue_message(op, msg); 600 } 601 602 rz_zev_callbacks_t zev_callbacks = { 603 /* zfsvfs events */ 604 .rz_zev_zfs_mount = zev_zfs_mount_cb, 605 .rz_zev_zfs_umount = zev_zfs_umount_cb, 606 607 /* zvol zil events */ 608 .rz_zev_zvol_truncate = zev_zvol_truncate_cb, 609 .rz_zev_zvol_write = zev_zvol_write_cb, 610 611 /* znode zil events */ 612 .rz_zev_znode_close_after_update = zev_znode_close_after_update_cb, 613 .rz_zev_znode_create = zev_znode_create_cb, 614 .rz_zev_znode_remove = zev_znode_remove_cb, 615 .rz_zev_znode_link = zev_znode_link_cb, 616 .rz_zev_znode_symlink = zev_znode_symlink_cb, 617 .rz_zev_znode_rename = zev_znode_rename_cb, 618 .rz_zev_znode_write = zev_znode_write_cb, 619 .rz_zev_znode_truncate = zev_znode_truncate_cb, 620 .rz_zev_znode_setattr = zev_znode_setattr_cb, 621 .rz_zev_znode_acl = zev_znode_acl_cb, 622 }; 623 624