1 0 stevel /* 2 0 stevel * CDDL HEADER START 3 0 stevel * 4 0 stevel * The contents of this file are subject to the terms of the 5 3608 an207044 * Common Development and Distribution License (the "License"). 6 3608 an207044 * You may not use this file except in compliance with the License. 7 0 stevel * 8 0 stevel * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 0 stevel * or http://www.opensolaris.org/os/licensing. 10 0 stevel * See the License for the specific language governing permissions 11 0 stevel * and limitations under the License. 12 0 stevel * 13 0 stevel * When distributing Covered Code, include this CDDL HEADER in each 14 0 stevel * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 0 stevel * If applicable, add the following below this CDDL HEADER, with the 16 0 stevel * fields enclosed by brackets "[]" replaced with your own identifying 17 0 stevel * information: Portions Copyright [yyyy] [name of copyright owner] 18 0 stevel * 19 0 stevel * CDDL HEADER END 20 0 stevel */ 21 0 stevel /* 22 3608 an207044 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23 0 stevel * Use is subject to license terms. 24 0 stevel */ 25 0 stevel 26 0 stevel #pragma ident "%Z%%M% %I% %E% SMI" 27 0 stevel 28 0 stevel 29 0 stevel #include <ctype.h> 30 0 stevel #include <string.h> 31 0 stevel #include <strings.h> 32 0 stevel #include <stdlib.h> 33 0 stevel #include <sys/types.h> 34 0 stevel #include <sys/errno.h> 35 0 stevel #include <sys/tiuser.h> 36 0 stevel #include <setjmp.h> 37 0 stevel 38 0 stevel #include <rpc/types.h> 39 0 stevel #include <rpc/xdr.h> 40 0 stevel #include <rpc/auth.h> 41 0 stevel #include <rpc/clnt.h> 42 0 stevel #include <rpc/rpc_msg.h> 43 0 stevel #include "snoop.h" 44 0 stevel 45 0 stevel #include <sys/stat.h> 46 0 stevel #include <sys/param.h> 47 0 stevel #include <rpcsvc/nfs_prot.h> 48 0 stevel /* use the same nfs4_prot.h as the xdr code */ 49 0 stevel #include "rpcsvc/nfs4_prot.h" 50 0 stevel 51 0 stevel /* 52 0 stevel * XXX With NFS v2 and v3, we only need to xdr the pieces that we care 53 0 stevel * about. Anything else we can ignore and just skip to the next packet. 54 0 stevel * So all the stuff that deals directly with XDR lives in snoop_display.c 55 0 stevel * With v4, we need to XDR entire structures so that we can skip over 56 0 stevel * uninteresting bits in a compound array, so we call XDR directly from 57 0 stevel * here. We need to rethink how we're going to structure XDR access. Do 58 0 stevel * we continue to hide it all in snoop_display.c, or do we expose it to all 59 0 stevel * the protocol modules? 60 0 stevel */ 61 0 stevel extern XDR xdrm; 62 0 stevel 63 0 stevel #ifndef MIN 64 0 stevel #define MIN(a, b) ((a) < (b) ? (a) : (b)) 65 0 stevel #endif 66 0 stevel 67 0 stevel /* 68 0 stevel * Maximum number of characters to display in compound4 summary line. 69 0 stevel */ 70 0 stevel #define SUM_COMPND_MAX 100 71 0 stevel 72 0 stevel /* 73 0 stevel * Maximum number of recognized attributes. 74 0 stevel */ 75 0 stevel #define MAX_ATTRIBUTES 56 76 0 stevel 77 0 stevel /* 78 0 stevel * This data structure provides a more convenient way to access an 79 0 stevel * attribute bitmask. map[N] = value of bit N in a bitmap4. 80 0 stevel * It's defined as a struct so as to step around all the weird rules in C 81 0 stevel * about arrays, pointers, passing them as arguments, etc. 82 0 stevel */ 83 0 stevel 84 0 stevel typedef struct { 85 0 stevel char map[MAX_ATTRIBUTES]; 86 0 stevel } unpkd_attrmap_t; 87 0 stevel 88 0 stevel 89 0 stevel static void sumarg_cb_getattr(char *buf, size_t buflen, void *obj); 90 0 stevel static void dtlarg_cb_getattr(void *obj); 91 0 stevel static void sumarg_cb_recall(char *buf, size_t buflen, void *obj); 92 0 stevel static void dtlarg_cb_recall(void *obj); 93 0 stevel 94 0 stevel 95 0 stevel static void sumarg_access(char *buf, size_t buflen, void *obj); 96 0 stevel static void dtlarg_access(void *obj); 97 0 stevel static void sumarg_close(char *buf, size_t buflen, void *obj); 98 0 stevel static void dtlarg_close(void *obj); 99 0 stevel static void sumarg_commit(char *buf, size_t buflen, void *obj); 100 0 stevel static void dtlarg_commit(void *obj); 101 0 stevel static void sumarg_compnt(char *buf, size_t buflen, void *obj); 102 0 stevel static void dtlarg_compnt(void *obj); 103 0 stevel static void sumarg_create(char *buf, size_t buflen, void *obj); 104 0 stevel static void dtlarg_create(void *obj); 105 0 stevel static void sumarg_delprge(char *buf, size_t buflen, void *obj); 106 0 stevel static void dtlarg_delprge(void *obj); 107 0 stevel static void sumarg_delret(char *buf, size_t buflen, void *obj); 108 0 stevel static void dtlarg_delret(void *obj); 109 0 stevel static void sumarg_getattr(char *buf, size_t buflen, void *obj); 110 0 stevel static void dtlarg_getattr(void *obj); 111 0 stevel static void sumarg_link(char *buf, size_t buflen, void *obj); 112 0 stevel static void dtlarg_link(void *obj); 113 0 stevel static void sum_open_to_lock_owner(char *buf, int buflen, 114 0 stevel open_to_lock_owner4 *own); 115 0 stevel static void sum_exist_lock_owner(char *buf, int buflen, 116 0 stevel exist_lock_owner4 *own); 117 0 stevel static void sum_locker(char *buf, size_t buflen, locker4 *lk); 118 0 stevel static void sumarg_lock(char *buf, size_t buflen, void *obj); 119 0 stevel static void detail_open_to_lock_owner(open_to_lock_owner4 *own); 120 0 stevel static void detail_exist_lock_owner(exist_lock_owner4 *own); 121 0 stevel static void detail_locker(locker4 *lk); 122 0 stevel static void dtlarg_lock(void *obj); 123 0 stevel static void sumarg_lockt(char *buf, size_t buflen, void *obj); 124 0 stevel static void dtlarg_lockt(void *obj); 125 0 stevel static void sumarg_locku(char *buf, size_t buflen, void *obj); 126 0 stevel static void dtlarg_locku(void *obj); 127 0 stevel static void sumarg_lookup(char *buf, size_t buflen, void *obj); 128 0 stevel static void dtlarg_lookup(void *obj); 129 0 stevel static void sumarg_open(char *buf, size_t buflen, void *obj); 130 0 stevel static void dtlarg_open(void *obj); 131 0 stevel static void sumarg_openattr(char *buf, size_t buflen, void *obj); 132 0 stevel static void dtlarg_openattr(void *obj); 133 0 stevel static void sumarg_open_confirm(char *buf, size_t buflen, void *obj); 134 0 stevel static void dtlarg_open_confirm(void *obj); 135 0 stevel static void sumarg_open_downgrd(char *buf, size_t buflen, void *obj); 136 0 stevel static void dtlarg_open_downgrd(void *obj); 137 0 stevel static void sumarg_putfh(char *buf, size_t buflen, void *obj); 138 0 stevel static void dtlarg_putfh(void *obj); 139 0 stevel static void sumarg_read(char *buf, size_t buflen, void *obj); 140 0 stevel static void dtlarg_read(void *obj); 141 0 stevel static void sumarg_readdir(char *buf, size_t buflen, void *obj); 142 0 stevel static void dtlarg_readdir(void *obj); 143 0 stevel static void sumarg_release_lkown(char *buf, size_t buflen, void *obj); 144 0 stevel static void dtlarg_release_lkown(void *obj); 145 0 stevel static void sumarg_rename(char *buf, size_t buflen, void *obj); 146 0 stevel static void dtlarg_rename(void *obj); 147 0 stevel static void sumarg_renew(char *buf, size_t buflen, void *obj); 148 0 stevel static void dtlarg_renew(void *buf); 149 0 stevel static void sumarg_secinfo(char *buf, size_t buflen, void *obj); 150 0 stevel static void dtlarg_secinfo(void *obj); 151 0 stevel static void sumarg_setattr(char *buf, size_t buflen, void *obj); 152 0 stevel static void dtlarg_setattr(void *obj); 153 0 stevel static void sumarg_setclid(char *buf, size_t buflen, void *obj); 154 0 stevel static void dtlarg_setclid(void *obj); 155 0 stevel static void sumarg_setclid_cfm(char *buf, size_t buflen, void *obj); 156 0 stevel static void dtlarg_setclid_cfm(void *obj); 157 0 stevel static void dtlarg_verify(void *obj); 158 0 stevel static void sumarg_write(char *buf, size_t buflen, void *obj); 159 0 stevel static void dtlarg_write(void *obj); 160 0 stevel 161 0 stevel static void sumres_cb_getattr(char *buf, size_t buflen, void *obj); 162 0 stevel static void dtlres_cb_getattr(void *obj); 163 0 stevel 164 0 stevel static void sumres_access(char *buf, size_t buflen, void *obj); 165 0 stevel static void dtlres_access(void *obj); 166 0 stevel static void sumres_close(char *buf, size_t buflen, void *obj); 167 0 stevel static void dtlres_close(void *obj); 168 0 stevel static void sumres_commit(char *buf, size_t buflen, void *obj); 169 0 stevel static void dtlres_commit(void *obj); 170 0 stevel static void dtlres_create(void *obj); 171 0 stevel static void sumres_getattr(char *buf, size_t buflen, void *obj); 172 0 stevel static void dtlres_getattr(void *obj); 173 0 stevel static void sumres_getfh(char *buf, size_t buflen, void *obj); 174 0 stevel static void dtlres_getfh(void *obj); 175 0 stevel static void dtlres_link(void *obj); 176 0 stevel static void sumres_lock(char *buf, size_t buflen, void *obj); 177 0 stevel static void dtlres_lock(void *obj); 178 0 stevel static void sumres_lockt(char *buf, size_t buflen, void *obj); 179 0 stevel static void dtlres_lockt(void *obj); 180 0 stevel static void sumres_locku(char *buf, size_t buflen, void *obj); 181 0 stevel static void dtlres_locku(void *obj); 182 0 stevel static void sumres_open(char *buf, size_t buflen, void *obj); 183 0 stevel static void dtlres_open(void *obj); 184 0 stevel static void sumres_open_confirm(char *buf, size_t buflen, void *obj); 185 0 stevel static void dtlres_open_confirm(void *obj); 186 0 stevel static void sumres_open_downgrd(char *buf, size_t buflen, void *obj); 187 0 stevel static void dtlres_open_downgrd(void *obj); 188 0 stevel static void sumres_read(char *buf, size_t buflen, void *obj); 189 0 stevel static void dtlres_read(void *obj); 190 0 stevel static void sumres_readdir(char *buf, size_t buflen, void *obj); 191 0 stevel static void dtlres_readdir(void *obj); 192 0 stevel static void sumres_readlnk(char *buf, size_t buflen, void *obj); 193 0 stevel static void dtlres_readlnk(void *obj); 194 0 stevel static void dtlres_remove(void *obj); 195 0 stevel static void dtlres_rename(void *obj); 196 0 stevel static void sumres_secinfo(char *buf, size_t buflen, void *obj); 197 0 stevel static void dtlres_secinfo(void *obj); 198 0 stevel static void sumres_setattr(char *buf, size_t buflen, void *obj); 199 0 stevel static void dtlres_setattr(void *obj); 200 0 stevel static void sumres_setclid(char *buf, size_t buflen, void *obj); 201 0 stevel static void dtlres_setclid(void *obj); 202 0 stevel static void sumres_write(char *buf, size_t buflen, void *obj); 203 0 stevel static void dtlres_write(void *obj); 204 0 stevel static void sum_nfsstat4(char *buf, size_t buflen, void *obj); 205 0 stevel static void dtl_nfsstat4(void *obj); 206 0 stevel static uint32_t adler16(void *, int); 207 0 stevel static void nfs4_xdr_skip(int nbytes); 208 0 stevel static char *sum_lock_type_name(enum nfs_lock_type4 type); 209 0 stevel 210 0 stevel int nfs4_pkt_start; 211 0 stevel int nfs4_pkt_len; 212 0 stevel int nfs4_skip_bytes; 213 0 stevel int nfs4_fragged_rpc; 214 0 stevel char *nfs4err_fragrpc = "<Fragmented RPC>"; 215 0 stevel char *nfs4err_xdrfrag = "<XDR Error or Fragmented RPC>"; 216 0 stevel 217 0 stevel /* 218 0 stevel * need a way to enable this if current testcases are parsing snoop 219 0 stevel * error text. -- maybe an env var would do as temp workaround until 220 0 stevel * testcases changed to grep for new error text. 221 0 stevel */ 222 0 stevel int nfs4_use_old_error_text = 0; 223 0 stevel 224 0 stevel /* 225 0 stevel * Information about each operation that can appear in a compound call. 226 0 stevel * The function pointers are to formatting functions for summary arguments 227 0 stevel * and results, and detail arguments & results. 228 0 stevel */ 229 0 stevel 230 0 stevel typedef struct { 231 0 stevel char *name; 232 0 stevel void (*sumarg)(char *, size_t, void *); 233 0 stevel void (*sumres)(char *, size_t, void *); 234 0 stevel void (*dtlarg)(void *); 235 0 stevel void (*dtlres)(void *); 236 0 stevel } op_info_t; 237 0 stevel 238 0 stevel static op_info_t cb_opcode_info[] = { 239 0 stevel {"OP_ZERO", NULL, NULL, NULL, NULL}, /* 0 */ 240 0 stevel {"OP_ONE", NULL, NULL, NULL, NULL}, 241 0 stevel {"OP_TWO", NULL, NULL, NULL, NULL}, /* minor vers */ 242 0 stevel {"CB_GETATTR", 243 0 stevel sumarg_cb_getattr, sumres_cb_getattr, 244 0 stevel dtlarg_cb_getattr, dtlres_cb_getattr}, 245 0 stevel {"CB_RECALL", 246 0 stevel sumarg_cb_recall, sum_nfsstat4, 247 0 stevel dtlarg_cb_recall, dtl_nfsstat4}, 248 0 stevel }; 249 0 stevel static uint_t cb_num_opcodes = sizeof (cb_opcode_info) / sizeof (op_info_t *); 250 0 stevel 251 0 stevel static op_info_t opcode_info[] = { 252 0 stevel {"OP_ZERO", NULL, NULL, NULL, NULL}, /* 0 */ 253 0 stevel {"OP_ONE", NULL, NULL, NULL, NULL}, 254 0 stevel {"OP_TWO", NULL, NULL, NULL, NULL}, /* minor vers */ 255 0 stevel {"ACCESS", 256 0 stevel sumarg_access, sumres_access, dtlarg_access, dtlres_access}, 257 0 stevel {"CLOSE", 258 0 stevel sumarg_close, sumres_close, dtlarg_close, dtlres_close}, 259 0 stevel {"COMMIT", 260 0 stevel sumarg_commit, sumres_commit, dtlarg_commit, dtlres_commit}, 261 0 stevel {"CREATE", /* 5 */ 262 0 stevel sumarg_create, sum_nfsstat4, dtlarg_create, dtlres_create}, 263 0 stevel {"DELEGPURGE", 264 0 stevel sumarg_delprge, sum_nfsstat4, dtlarg_delprge, dtl_nfsstat4}, 265 0 stevel {"DELEGRETURN", 266 0 stevel sumarg_delret, sum_nfsstat4, dtlarg_delret, dtl_nfsstat4}, 267 0 stevel {"GETATTR", 268 0 stevel sumarg_getattr, sumres_getattr, dtlarg_getattr, dtlres_getattr}, 269 0 stevel {"GETFH", 270 0 stevel NULL, sumres_getfh, NULL, dtlres_getfh}, 271 0 stevel {"LINK", /* 10 */ 272 0 stevel sumarg_link, sum_nfsstat4, dtlarg_link, dtlres_link}, 273 0 stevel {"LOCK", 274 0 stevel sumarg_lock, sumres_lock, dtlarg_lock, dtlres_lock}, 275 0 stevel {"LOCKT", 276 0 stevel sumarg_lockt, sumres_lockt, dtlarg_lockt, dtlres_lockt}, 277 0 stevel {"LOCKU", 278 0 stevel sumarg_locku, sumres_locku, dtlarg_locku, dtlres_locku}, 279 0 stevel {"LOOKUP", 280 0 stevel sumarg_lookup, sum_nfsstat4, dtlarg_lookup, dtl_nfsstat4}, 281 0 stevel {"LOOKUPP", /* 15 */ 282 0 stevel NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, 283 0 stevel {"NVERIFY", 284 0 stevel NULL, sum_nfsstat4, dtlarg_verify, dtl_nfsstat4}, 285 0 stevel {"OPEN", 286 0 stevel sumarg_open, sumres_open, dtlarg_open, dtlres_open}, 287 0 stevel {"OPENATTR", 288 0 stevel sumarg_openattr, sum_nfsstat4, dtlarg_openattr, dtl_nfsstat4}, 289 0 stevel {"OPEN_CONFIRM", 290 0 stevel sumarg_open_confirm, 291 0 stevel sumres_open_confirm, 292 0 stevel dtlarg_open_confirm, 293 0 stevel dtlres_open_confirm}, 294 0 stevel {"OPEN_DOWNGRADE", 295 0 stevel sumarg_open_downgrd, 296 0 stevel sumres_open_downgrd, 297 0 stevel dtlarg_open_downgrd, 298 0 stevel dtlres_open_downgrd}, 299 0 stevel {"PUTFH", 300 0 stevel sumarg_putfh, sum_nfsstat4, dtlarg_putfh, dtl_nfsstat4}, 301 0 stevel {"PUTPUBFH", /* 20 */ 302 0 stevel NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, 303 0 stevel {"PUTROOTFH", 304 0 stevel NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, 305 0 stevel {"READ", 306 0 stevel sumarg_read, sumres_read, dtlarg_read, dtlres_read}, 307 0 stevel {"READDIR", 308 0 stevel sumarg_readdir, sumres_readdir, dtlarg_readdir, dtlres_readdir}, 309 0 stevel {"READLINK", 310 0 stevel NULL, sumres_readlnk, NULL, dtlres_readlnk}, 311 0 stevel {"REMOVE", /* 25 */ 312 0 stevel sumarg_compnt, sum_nfsstat4, dtlarg_compnt, dtlres_remove}, 313 0 stevel {"RENAME", 314 0 stevel sumarg_rename, sum_nfsstat4, dtlarg_rename, dtlres_rename}, 315 0 stevel {"RENEW", 316 0 stevel sumarg_renew, sum_nfsstat4, dtlarg_renew, dtl_nfsstat4}, 317 0 stevel {"RESTOREFH", 318 0 stevel NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, 319 0 stevel {"SAVEFH", 320 0 stevel NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, 321 0 stevel {"SECINFO", /* 30 */ 322 0 stevel sumarg_secinfo, sumres_secinfo, dtlarg_secinfo, dtlres_secinfo}, 323 0 stevel {"SETATTR", 324 0 stevel sumarg_setattr, sumres_setattr, dtlarg_setattr, dtlres_setattr}, 325 0 stevel {"SETCLIENTID", 326 0 stevel sumarg_setclid, sumres_setclid, dtlarg_setclid, dtlres_setclid}, 327 0 stevel {"SETCLIENTID_CONFIRM", 328 0 stevel sumarg_setclid_cfm, 329 0 stevel sum_nfsstat4, 330 0 stevel dtlarg_setclid_cfm, 331 0 stevel dtl_nfsstat4}, 332 0 stevel {"VERIFY", 333 0 stevel NULL, sum_nfsstat4, dtlarg_verify, dtl_nfsstat4}, 334 0 stevel {"WRITE", 335 0 stevel sumarg_write, sumres_write, dtlarg_write, dtlres_write}, 336 0 stevel {"RELEASE_LOCKOWNER", 337 0 stevel sumarg_release_lkown, sum_nfsstat4, 338 0 stevel dtlarg_release_lkown, dtl_nfsstat4}, 339 0 stevel }; 340 0 stevel static uint_t num_opcodes = sizeof (opcode_info) / sizeof (op_info_t *); 341 0 stevel 342 0 stevel /* 343 0 stevel * File types. 344 0 stevel */ 345 0 stevel 346 0 stevel typedef struct { 347 0 stevel char *short_name; /* for summary output */ 348 0 stevel char *long_name; /* for detail output */ 349 0 stevel } ftype_names_t; 350 0 stevel 351 0 stevel static ftype_names_t ftype_names[] = { 352 0 stevel {"Type 0", "Type 0"}, 353 0 stevel {"REG", "Regular File"}, 354 0 stevel {"DIR", "Directory"}, 355 0 stevel {"BLK", "Block Device"}, 356 0 stevel {"CHR", "Character Device"}, 357 0 stevel {"LNK", "Symbolic Link"}, /* 5 */ 358 0 stevel {"SOCK", "Socket"}, 359 0 stevel {"FIFO", "FIFO"}, 360 0 stevel {"ATTRDIR", "Attribute Directory"}, 361 0 stevel {"NAMEDATTR", "Named Attribute"}, 362 0 stevel }; 363 0 stevel static uint_t num_ftypes = sizeof (ftype_names) / sizeof (ftype_names_t); 364 0 stevel 365 0 stevel static ftype_names_t open_rflags[] = { 366 0 stevel {"?", "UNKNOWN"}, /* 0 */ 367 0 stevel {"CF", "CONFIRM"}, /* 1 */ 368 0 stevel {"PL", "POSIX LOCK"}, /* 2 */ 369 0 stevel {"?", "UNKNOWN"}, 370 0 stevel }; 371 0 stevel static uint_t num_open_rflags = 372 0 stevel sizeof (open_rflags) / sizeof (ftype_names_t) - 1; 373 0 stevel 374 0 stevel static char *get_flags(uint_t, ftype_names_t *, uint_t, int, char *); 375 0 stevel 376 0 stevel #define sum_open_rflags(flag) \ 377 0 stevel get_flags((flag), open_rflags, num_open_rflags, 1, " RF=") 378 0 stevel 379 0 stevel #define detail_open_rflags(flag) \ 380 0 stevel get_flags((flag), open_rflags, num_open_rflags, 0, NULL) 381 0 stevel 382 0 stevel static void prt_supported_attrs(XDR *); 383 0 stevel static void prt_type(XDR *); 384 0 stevel static void prt_fh_expire_type(XDR *); 385 0 stevel static void prt_change(XDR *); 386 0 stevel static void prt_size(XDR *); 387 0 stevel static void prt_link_support(XDR *); 388 0 stevel static void prt_symlink_support(XDR *); 389 0 stevel static void prt_named_attr(XDR *); 390 0 stevel static void prt_fsid(XDR *); 391 0 stevel static void prt_unique_handles(XDR *); 392 0 stevel static void prt_lease_time(XDR *); 393 0 stevel static void prt_rdattr_error(XDR *); 394 0 stevel static void prt_acl(XDR *); 395 0 stevel static void prt_aclsupport(XDR *); 396 0 stevel static void prt_archive(XDR *); 397 0 stevel static void prt_cansettime(XDR *); 398 0 stevel static void prt_case_insensitive(XDR *); 399 0 stevel static void prt_case_preserving(XDR *); 400 0 stevel static void prt_chown_restricted(XDR *); 401 0 stevel static void prt_filehandle(XDR *); 402 0 stevel static void prt_fileid(XDR *); 403 0 stevel static void prt_mounted_on_fileid(XDR *); 404 0 stevel static void prt_files_avail(XDR *); 405 0 stevel static void prt_files_free(XDR *); 406 0 stevel static void prt_files_total(XDR *); 407 0 stevel static void prt_fs_locations(XDR *); 408 0 stevel static void prt_hidden(XDR *); 409 0 stevel static void prt_homogeneous(XDR *); 410 0 stevel static void prt_maxfilesize(XDR *); 411 0 stevel static void prt_maxlink(XDR *); 412 0 stevel static void prt_maxname(XDR *); 413 0 stevel static void prt_maxread(XDR *); 414 0 stevel static void prt_maxwrite(XDR *); 415 0 stevel static void prt_mimetype(XDR *); 416 0 stevel static void prt_mode(XDR *); 417 0 stevel static void prt_no_trunc(XDR *); 418 0 stevel static void prt_numlinks(XDR *); 419 0 stevel static void prt_owner(XDR *); 420 0 stevel static void prt_owner_group(XDR *); 421 0 stevel static void prt_quota_avail_hard(XDR *); 422 0 stevel static void prt_quota_avail_soft(XDR *); 423 0 stevel static void prt_quota_used(XDR *); 424 0 stevel static void prt_rawdev(XDR *); 425 0 stevel static void prt_space_avail(XDR *); 426 0 stevel static void prt_space_free(XDR *); 427 0 stevel static void prt_space_total(XDR *); 428 0 stevel static void prt_space_used(XDR *); 429 0 stevel static void prt_system(XDR *); 430 0 stevel static void prt_time_access(XDR *); 431 0 stevel static void prt_time_access_set(XDR *); 432 0 stevel static void prt_time_backup(XDR *); 433 0 stevel static void prt_time_create(XDR *); 434 0 stevel static void prt_time_delta(XDR *); 435 0 stevel static void prt_time_metadata(XDR *); 436 0 stevel static void prt_time_modify(XDR *); 437 0 stevel static void prt_time_modify_set(XDR *); 438 0 stevel 439 0 stevel 440 0 stevel 441 0 stevel /* 442 0 stevel * Information for attributes. 443 0 stevel * name name of the attribute. 444 0 stevel * prt_details function to XDR decode the attribute and print it. 445 0 stevel * 446 0 stevel * XXX If this table ever gets extensively changed (including 447 0 stevel * reorganization to track changes to the spec), it would probably be a 448 0 stevel * good idea to change to a scheme where the table is mechanically 449 0 stevel * generated. Look at $SRC/uts/common/rpcsvc for how this is done in the 450 0 stevel * kernel. 451 0 stevel */ 452 0 stevel 453 0 stevel typedef struct { 454 0 stevel char *name; 455 0 stevel void (*prt_details)(XDR *); 456 0 stevel } attr_info_t; 457 0 stevel 458 0 stevel static attr_info_t attr_info[MAX_ATTRIBUTES] = { 459 0 stevel {"SUPPORTED_ATTRS", prt_supported_attrs}, 460 0 stevel {"TYPE", prt_type}, 461 0 stevel {"FH_EXPIRE_TYPE", prt_fh_expire_type}, 462 0 stevel {"CHANGE", prt_change}, 463 0 stevel {"SIZE", prt_size}, 464 0 stevel {"LINK_SUPPORT", prt_link_support}, /* 5 */ 465 0 stevel {"SYMLINK_SUPPORT", prt_symlink_support}, 466 0 stevel {"NAMED_ATTR", prt_named_attr}, 467 0 stevel {"FSID", prt_fsid}, 468 0 stevel {"UNIQUE_HANDLES", prt_unique_handles}, 469 0 stevel {"LEASE_TIME", prt_lease_time}, /* 10 */ 470 0 stevel {"RDATTR_ERROR", prt_rdattr_error}, 471 0 stevel {"ACL", prt_acl}, 472 0 stevel {"ACLSUPPORT", prt_aclsupport}, 473 0 stevel {"ARCHIVE", prt_archive}, 474 0 stevel {"CANSETTIME", prt_cansettime}, /* 15 */ 475 0 stevel {"CASE_INSENSITIVE", prt_case_insensitive}, 476 0 stevel {"CASE_PRESERVING", prt_case_preserving}, 477 0 stevel {"CHOWN_RESTRICTED", prt_chown_restricted}, 478 0 stevel {"FILEHANDLE", prt_filehandle}, 479 0 stevel {"FILEID", prt_fileid}, /* 20 */ 480 0 stevel {"FILES_AVAIL", prt_files_avail}, 481 0 stevel {"FILES_FREE", prt_files_free}, 482 0 stevel {"FILES_TOTAL", prt_files_total}, 483 0 stevel {"FS_LOCATIONS", prt_fs_locations}, 484 0 stevel {"HIDDEN", prt_hidden}, /* 25 */ 485 0 stevel {"HOMOGENEOUS", prt_homogeneous}, 486 0 stevel {"MAXFILESIZE", prt_maxfilesize}, 487 0 stevel {"MAXLINK", prt_maxlink}, 488 0 stevel {"MAXNAME", prt_maxname}, 489 0 stevel {"MAXREAD", prt_maxread}, /* 30 */ 490 0 stevel {"MAXWRITE", prt_maxwrite}, 491 0 stevel {"MIMETYPE", prt_mimetype}, 492 0 stevel {"MODE", prt_mode}, 493 0 stevel {"NO_TRUNC", prt_no_trunc}, 494 0 stevel {"NUMLINKS", prt_numlinks}, /* 35 */ 495 0 stevel {"OWNER", prt_owner}, 496 0 stevel {"OWNER_GROUP", prt_owner_group}, 497 0 stevel {"QUOTA_AVAIL_HARD", prt_quota_avail_hard}, 498 0 stevel {"QUOTA_AVAIL_SOFT", prt_quota_avail_soft}, 499 0 stevel {"QUOTA_USED", prt_quota_used}, /* 40 */ 500 0 stevel {"RAWDEV", prt_rawdev}, 501 0 stevel {"SPACE_AVAIL", prt_space_avail}, 502 0 stevel {"SPACE_FREE", prt_space_free}, 503 0 stevel {"SPACE_TOTAL", prt_space_total}, 504 0 stevel {"SPACE_USED", prt_space_used}, /* 45 */ 505 0 stevel {"SYSTEM", prt_system}, 506 0 stevel {"TIME_ACCESS", prt_time_access}, 507 0 stevel {"TIME_ACCESS_SET", prt_time_access_set}, 508 0 stevel {"TIME_BACKUP", prt_time_backup}, 509 0 stevel {"TIME_CREATE", prt_time_create}, /* 50 */ 510 0 stevel {"TIME_DELTA", prt_time_delta}, 511 0 stevel {"TIME_METADATA", prt_time_metadata}, 512 0 stevel {"TIME_MODIFY", prt_time_modify}, 513 0 stevel {"TIME_MODIFY_SET", prt_time_modify_set}, 514 0 stevel {"MOUNTED_ON_FILEID", prt_mounted_on_fileid}, 515 0 stevel }; 516 0 stevel 517 0 stevel extern char *get_sum_line(); 518 0 stevel 519 0 stevel extern jmp_buf xdr_err; 520 0 stevel 521 0 stevel static void sum_comp4res(char *, char *(*)(void)); 522 0 stevel static char *sum_compound4args(void); 523 0 stevel static char *sum_compound4res(void); 524 0 stevel static char *sum_operand(nfs_argop4 *opp); 525 0 stevel static char *sum_result(nfs_resop4 *resp); 526 0 stevel 527 0 stevel static char *sum_cb_compound4args(void); 528 0 stevel static char *sum_cb_compound4res(void); 529 0 stevel static char *sum_cb_operand(nfs_cb_argop4 *opp); 530 0 stevel static char *sum_cb_result(nfs_cb_resop4 *resp); 531 0 stevel 532 0 stevel static void detail_acetype4(acetype4); 533 0 stevel static void detail_uint32_bitmap(uint32_t, char *[], int); 534 0 stevel static void detail_aceflag4(aceflag4); 535 0 stevel static void detail_acemask4(acemask4); 536 0 stevel static void detail_nfs_argop4(void); 537 0 stevel static void detail_nfs_resop4(void); 538 0 stevel static void detail_cb_argop4(void); 539 0 stevel static void detail_cb_resop4(void); 540 0 stevel 541 0 stevel static char *attr_name(uint_t); 542 0 stevel static char *claim_name(enum open_claim_type4 claim_type); 543 0 stevel static char *delegation_type_name(enum open_delegation_type4 type); 544 0 stevel static char *flavor_name(uint_t flavor); 545 0 stevel static char *gss_svc_name(rpc_gss_svc_t svc); 546 0 stevel static char *limitby_name(enum limit_by4 limitby); 547 0 stevel static char *lock_type_name(enum nfs_lock_type4); 548 0 stevel static char *opcode_name(uint_t); 549 0 stevel static char *cb_opcode_name(uint_t opnum); 550 0 stevel static char *status_name(int); 551 0 stevel static char *status_name_compat(int); 552 0 stevel static char *status_name_pcol(int); 553 0 stevel static char *sum_type_name(nfs_ftype4); 554 0 stevel static void sum_access4(char *buf, size_t buflen, uint32_t bits); 555 0 stevel static void detail_access4(char *, uint32_t); 556 0 stevel static void sum_claim(char *buf, size_t buflen, open_claim4 *claim); 557 0 stevel static void detail_claim(open_claim4 *claim); 558 0 stevel static char *sum_clientid(clientid4 client); 559 0 stevel static void detail_clientid(clientid4 client); 560 0 stevel static char *_sum_stateid(stateid4 *, char *prefix); 561 0 stevel static void sum_delegation(char *buf, size_t buflen, open_delegation4 *delp); 562 0 stevel static void detail_delegation(open_delegation4 *delp); 563 0 stevel static void detail_lock_owner(lock_owner4 *owner); 564 0 stevel static void detail_open_owner(open_owner4 *owner); 565 0 stevel static void sum_openflag(char *bufp, int buflen, openflag4 *flagp); 566 0 stevel static char *get_deleg_typestr(open_delegation_type4 dt); 567 0 stevel static void detail_openflag(openflag4 *flagp); 568 0 stevel static void sum_name(char *buf, size_t buflen, open_claim4 *claim); 569 0 stevel static void detail_rpcsec_gss(rpcsec_gss_info *); 570 0 stevel static void detail_secinfo4(secinfo4 *infop); 571 0 stevel static char *sum_space_limit(nfs_space_limit4 *limitp); 572 0 stevel static void detail_space_limit(nfs_space_limit4 *limitp); 573 0 stevel static char *detail_type_name(nfs_ftype4); 574 0 stevel static char *createhow4_name(createhow4 *crtp); 575 0 stevel 576 0 stevel 577 0 stevel static void showxdr_utf8string(char *); 578 0 stevel static char *utf8localize(utf8string *); 579 0 stevel static void utf8free(void); 580 0 stevel static void sum_pathname4(char *, size_t, pathname4 *); 581 0 stevel static void detail_pathname4(pathname4 *pathp); 582 0 stevel static void sum_compname4(char *buf, size_t buflen, component4 *comp); 583 0 stevel static void detail_compname4(component4 *comp); 584 0 stevel 585 0 stevel static void detail_fattr4(fattr4 *attrp); 586 0 stevel static void detail_attr_bitmap(char *, bitmap4 *, unpkd_attrmap_t *); 587 0 stevel static void sum_attr_bitmap(char *buf, size_t buflen, bitmap4 *mapp); 588 0 stevel static void detail_fattr4_change(char *msg, fattr4_change chg); 589 0 stevel static char *sum_fh4(nfs_fh4 *fhp); 590 0 stevel static void detail_fh4(nfs_fh4 *fh); 591 0 stevel 592 0 stevel #define fh4_hash(fh) adler16((fh)->nfs_fh4_val, (fh)->nfs_fh4_len) 593 0 stevel #define stateid_hash(st) adler16((st)->other, sizeof ((st)->other)) 594 0 stevel #define owner_hash(own) adler16((own)->owner_val, (own)->owner_len) 595 0 stevel 596 0 stevel #define sum_deleg_stateid(st) _sum_stateid((st), "DST=") 597 0 stevel #define sum_open_stateid(st) _sum_stateid((st), "OST=") 598 0 stevel #define sum_lock_stateid(st) _sum_stateid((st), "LST=") 599 0 stevel #define sum_stateid(st) _sum_stateid((st), "ST=") 600 0 stevel 601 0 stevel #define detail_deleg_stateid(st) _detail_stateid((st), "Delegation ") 602 0 stevel #define detail_open_stateid(st) _detail_stateid((st), "Open ") 603 0 stevel #define detail_lock_stateid(st) _detail_stateid((st), "Lock ") 604 0 stevel #define detail_stateid(st) _detail_stateid((st), "") 605 0 stevel 606 0 stevel #define SPECIAL_STATEID0 "SPC0" 607 0 stevel #define SPECIAL_STATEID1 "SPC1" 608 0 stevel 609 0 stevel #define DONT_CHANGE 0 610 0 stevel #define SET_TO_SERVER_TIME 1 611 0 stevel #define SET_TO_CLIENT_TIME 2 612 0 stevel 613 0 stevel static stateid4 spec_stateid_0 = 614 0 stevel {0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}; 615 0 stevel static stateid4 spec_stateid_1 = 616 0 stevel {0xFFFFFFFF, {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}; 617 0 stevel 618 0 stevel static char *procnames_short[] = { 619 0 stevel "NULL4", /* 0 */ 620 0 stevel "COMPOUND4" /* 1 */ 621 0 stevel }; 622 0 stevel 623 0 stevel static char *procnames_long[] = { 624 0 stevel "Null procedure", /* 0 */ 625 0 stevel "Compound", /* 1 */ 626 0 stevel }; 627 0 stevel 628 0 stevel static char *cb_procnames_short[] = { 629 0 stevel "CB_NULL", /* 0 */ 630 0 stevel "CB_COMPOUND" /* 1 */ 631 0 stevel }; 632 0 stevel 633 0 stevel static char *cb_procnames_long[] = { 634 0 stevel "Null CallBack procedure", /* 0 */ 635 0 stevel "CallBack compound", /* 1 */ 636 0 stevel }; 637 0 stevel 638 0 stevel static char *acetype4_names[] = { 639 0 stevel "ACE4_ACCESS_ALLOWED_ACE_TYPE", 640 0 stevel "ACE4_ACCESS_DENIED_ACE_TYPE", 641 0 stevel "ACE4_SYSTEM_AUDIT_ACE_TYPE", 642 0 stevel "ACE4_SYSTEM_ALARM_ACE_TYPE" 643 0 stevel }; 644 0 stevel #define ACETYPE4_NAMES_MAX (sizeof (acetype4_names) / sizeof (char *)) 645 0 stevel 646 0 stevel static char *aceflag4_names[] = { 647 0 stevel "ACE4_FILE_INHERIT_ACE", 648 0 stevel "ACE4_DIRECTORY_INHERIT_ACE", 649 0 stevel "ACE4_NO_PROPAGATE_INHERIT_ACE", 650 0 stevel "ACE4_INHERIT_ONLY_ACE", 651 0 stevel "ACE4_SUCCESSFUL_ACCESS_ACE_FLAG", 652 0 stevel "ACE4_FAILED_ACCESS_ACE_FLAG", 653 0 stevel "ACE4_IDENTIFIER_GROUP" 654 0 stevel }; 655 0 stevel #define ACEFLAG4_NAMES_MAX (sizeof (aceflag4_names) / sizeof (char *)) 656 0 stevel 657 0 stevel static char *acemask4_names[] = { 658 0 stevel "ACE4_READ_DATA/ACE4_LIST_DIRECTORY", 659 0 stevel "ACE4_WRITE_DATA/ACE4_ADD_FILE", 660 0 stevel "ACE4_APPEND_DATA/ACE4_ADD_SUBDIRECTORY", 661 0 stevel "ACE4_READ_NAMED_ATTRS", 662 0 stevel "ACE4_WRITE_NAMED_ATTRS", 663 0 stevel "ACE4_EXECUTE", 664 0 stevel "ACE4_DELETE_CHILD", 665 0 stevel "ACE4_READ_ATTRIBUTES", 666 0 stevel "ACE4_WRITE_ATTRIBUTES", 667 0 stevel "UNDEFINED", /* 0x00000200 */ 668 0 stevel "UNDEFINED", /* 0x00000400 */ 669 0 stevel "UNDEFINED", /* 0x00000800 */ 670 0 stevel "UNDEFINED", /* 0x00001000 */ 671 0 stevel "UNDEFINED", /* 0x00002000 */ 672 0 stevel "UNDEFINED", /* 0x00004000 */ 673 0 stevel "UNDEFINED", /* 0x00008000 */ 674 0 stevel "ACE4_DELETE", 675 0 stevel "ACE4_READ_ACL", 676 0 stevel "ACE4_WRITE_ACL", 677 0 stevel "ACE4_WRITE_OWNER", 678 0 stevel "ACE4_SYNCHRONIZE" 679 0 stevel }; 680 0 stevel #define ACEMASK4_NAMES_MAX (sizeof (acemask4_names) / sizeof (char *)) 681 0 stevel 682 0 stevel #define MAXPROC 1 683 0 stevel 684 0 stevel /*ARGSUSED*/ 685 0 stevel void 686 0 stevel interpret_nfs4_cb(int flags, int type, int xid, int vers, int proc, 687 0 stevel char *data, int len) 688 0 stevel { 689 0 stevel char *line = NULL; 690 0 stevel 691 0 stevel if (proc < 0 || proc > MAXPROC) 692 0 stevel return; 693 0 stevel 694 0 stevel if (flags & F_SUM) { 695 0 stevel line = get_sum_line(); 696 0 stevel 697 0 stevel if (type == CALL) { 698 0 stevel (void) sprintf(line, "NFS C %s", 699 0 stevel proc == CB_COMPOUND ? "CB4" : 700 0 stevel cb_procnames_short[proc]); 701 0 stevel line += strlen(line); 702 0 stevel 703 0 stevel if (proc == CB_COMPOUND) { 704 0 stevel static utf8string tag; 705 0 stevel 706 0 stevel if (!xdr_utf8string(&xdrm, &tag)) 707 0 stevel longjmp(xdr_err, 1); 708 0 stevel sprintf(line, " (%.20s) %s", 709 0 stevel utf8localize(&tag), 710 0 stevel sum_cb_compound4args()); 711 0 stevel xdr_free(xdr_utf8string, (char *)&tag); 712 0 stevel } 713 0 stevel check_retransmit(line, xid); 714 0 stevel } else { 715 0 stevel (void) sprintf(line, "NFS R %s ", 716 0 stevel proc == CB_COMPOUND ? "CB4" : 717 0 stevel cb_procnames_short[proc]); 718 0 stevel line += strlen(line); 719 0 stevel if (proc == CB_COMPOUND) 720 0 stevel sum_comp4res(line, sum_cb_compound4res); 721 0 stevel } 722 0 stevel } 723 0 stevel 724 0 stevel if (flags & F_DTAIL) { 725 0 stevel show_header("NFS: ", "Sun NFS4 CallBack", len); 726 0 stevel show_space(); 727 0 stevel (void) sprintf(get_line(0, 0), "Proc = %d (%s)", 728 0 stevel proc, cb_procnames_long[proc]); 729 0 stevel if (proc == CB_COMPOUND) { 730 0 stevel if (type == CALL) { 731 0 stevel showxdr_utf8string("Tag = %s"); 732 0 stevel detail_cb_argop4(); 733 0 stevel } else { 734 0 stevel nfsstat4 status; 735 0 stevel 736 0 stevel status = getxdr_long(); 737 0 stevel showxdr_utf8string("Tag = %s"); 738 0 stevel sprintf(get_line(0, 0), "Status = %d (%s)", 739 0 stevel status, status_name(status)); 740 0 stevel detail_cb_resop4(); 741 0 stevel } 742 0 stevel } 743 0 stevel show_trailer(); 744 0 stevel } 745 0 stevel 746 0 stevel utf8free(); /* cf. utf8localize() */ 747 0 stevel } 748 0 stevel 749 0 stevel 750 0 stevel /*ARGSUSED*/ 751 0 stevel void 752 0 stevel interpret_nfs4(int flags, int type, int xid, int vers, int proc, 753 0 stevel char *data, int len) 754 0 stevel { 755 0 stevel char *line = NULL; 756 0 stevel 757 0 stevel if (proc < 0 || proc > MAXPROC) 758 0 stevel return; 759 0 stevel 760 0 stevel nfs4_fragged_rpc = 0; 761 0 stevel nfs4_pkt_len = len; 762 0 stevel nfs4_pkt_start = xdr_getpos(&xdrm); 763 0 stevel 764 0 stevel if (flags & F_SUM) { 765 0 stevel line = get_sum_line(); 766 0 stevel 767 0 stevel if (type == CALL) { 768 0 stevel (void) sprintf(line, "NFS C %s", 769 0 stevel proc == NFSPROC4_COMPOUND ? "4" : 770 0 stevel procnames_short[proc]); 771 0 stevel line += strlen(line); 772 0 stevel 773 0 stevel if (proc == NFSPROC4_COMPOUND) { 774 0 stevel static utf8string tag; 775 0 stevel 776 0 stevel if (!xdr_utf8string(&xdrm, &tag)) 777 0 stevel longjmp(xdr_err, 1); 778 0 stevel sprintf(line, " (%.20s) %s", 779 0 stevel utf8localize(&tag), 780 0 stevel sum_compound4args()); 781 0 stevel xdr_free(xdr_utf8string, (char *)&tag); 782 0 stevel } 783 0 stevel check_retransmit(line, xid); 784 0 stevel } else { 785 0 stevel (void) sprintf(line, "NFS R %s ", 786 0 stevel proc == NFSPROC4_COMPOUND ? "4" : 787 0 stevel procnames_short[proc]); 788 0 stevel line += strlen(line); 789 0 stevel 790 0 stevel if (proc == NFSPROC4_COMPOUND) 791 0 stevel sum_comp4res(line, sum_compound4res); 792 0 stevel } 793 0 stevel } 794 0 stevel 795 0 stevel if (flags & F_DTAIL) { 796 0 stevel show_header("NFS: ", "Sun NFS", len); 797 0 stevel show_space(); 798 0 stevel (void) sprintf(get_line(0, 0), "Proc = %d (%s)", 799 0 stevel proc, procnames_long[proc]); 800 0 stevel if (proc == NFSPROC4_COMPOUND) { 801 0 stevel if (type == CALL) { 802 0 stevel showxdr_utf8string("Tag = %s"); 803 0 stevel detail_nfs_argop4(); 804 0 stevel } else { 805 0 stevel nfsstat4 status; 806 0 stevel 807 0 stevel status = getxdr_long(); 808 0 stevel showxdr_utf8string("Tag = %s"); 809 0 stevel sprintf(get_line(0, 0), "Status = %d (%s)", 810 0 stevel status, status_name(status)); 811 0 stevel detail_nfs_resop4(); 812 0 stevel } 813 0 stevel } 814 0 stevel show_trailer(); 815 0 stevel } 816 0 stevel 817 0 stevel utf8free(); /* cf. utf8localize() */ 818 0 stevel } 819 0 stevel 820 0 stevel 821 0 stevel 822 0 stevel /* 823 0 stevel * Return the names and arguments of the oplist elements, up to 824 0 stevel * SUM_COMPND_MAX characters. If the elements don't fit, include a "..." 825 0 stevel * at the end of the string. 826 0 stevel */ 827 0 stevel 828 0 stevel static char * 829 0 stevel sum_compound4args(void) 830 0 stevel { 831 0 stevel static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ 832 0 stevel int numops; 833 0 stevel const size_t buflen = sizeof (buf); 834 0 stevel char *bp; 835 0 stevel nfs_argop4 one_op; 836 0 stevel uint32_t minor_version; 837 0 stevel 838 0 stevel buf[0] = '\0'; 839 0 stevel 840 0 stevel if (setjmp(xdr_err)) { 841 0 stevel bp = buf + strlen(buf); 842 0 stevel snprintf(bp, buflen - (bp - buf), 843 0 stevel nfs4_fragged_rpc ? nfs4err_fragrpc : nfs4err_xdrfrag); 844 0 stevel return (buf); 845 0 stevel } 846 0 stevel 847 0 stevel /* 848 0 stevel * might be nice to print minor version, but doesn't 849 0 stevel * seem like very useful info for summary mode 850 0 stevel */ 851 0 stevel if (!xdr_uint32_t(&xdrm, &minor_version)) 852 0 stevel longjmp(xdr_err, 1); 853 0 stevel 854 0 stevel numops = getxdr_long(); 855 0 stevel bp = buf; 856 0 stevel while (numops-- > 0) { 857 0 stevel char *operand; 858 0 stevel 859 0 stevel bzero(&one_op, sizeof (one_op)); 860 0 stevel 861 0 stevel if (!xdr_nfs_argop4(&xdrm, &one_op)) { 862 0 stevel xdr_free(xdr_nfs_argop4, (char *)&one_op); 863 0 stevel longjmp(xdr_err, 1); 864 0 stevel } 865 0 stevel snprintf(bp, buflen - (bp - buf), "%s ", 866 0 stevel opcode_name(one_op.argop)); 867 0 stevel bp += strlen(bp); 868 0 stevel 869 0 stevel operand = sum_operand(&one_op); 870 0 stevel if (strlen(operand) > 0) { 871 0 stevel snprintf(bp, buflen - (bp - buf), "%s ", operand); 872 0 stevel bp += strlen(bp); 873 0 stevel } 874 0 stevel 875 0 stevel /* nfs4_skip_bytes set by xdr_nfs4_argop4 */ 876 0 stevel if (nfs4_skip_bytes != 0) 877 0 stevel nfs4_xdr_skip(nfs4_skip_bytes); 878 0 stevel 879 0 stevel xdr_free(xdr_nfs_argop4, (char *)&one_op); 880 0 stevel 881 0 stevel /* add "..." if past the "end" of the buffer */ 882 0 stevel if (bp - buf > SUM_COMPND_MAX) { 883 0 stevel strcpy(buf + SUM_COMPND_MAX - strlen("..."), 884 0 stevel "..."); 885 0 stevel break; 886 0 stevel } 887 0 stevel } 888 0 stevel 889 0 stevel return (buf); 890 0 stevel } 891 0 stevel 892 0 stevel static void 893 0 stevel nfs4_xdr_skip(int nbytes) 894 0 stevel { 895 0 stevel int resid, off, len, cur_pos, new_pos; 896 0 stevel 897 0 stevel len = RNDUP(nbytes); 898 0 stevel cur_pos = xdr_getpos(&xdrm); 899 0 stevel 900 0 stevel /* 901 0 stevel * Time to skip over the rd/wr data. If the 902 0 stevel * rd/wr data is completely contained in the first 903 0 stevel * frag, we must skip over it to process the rest of 904 0 stevel * the packet. 905 0 stevel * 906 0 stevel * nfs4_pkt_start: XDR position of start of NFS4 compound 907 0 stevel * nfs4_pkt_len: number of bytes in pkt relative to 908 0 stevel * nfs4_pkt_start 909 0 stevel * 910 0 stevel * cur_pos: current XDR position 911 0 stevel * off: current XDR position relative to nfs4_pkt_start 912 0 stevel * resid: number of unprocessed bytes in current pkt 913 0 stevel * (relative to cur_pos/off) 914 0 stevel * 915 0 stevel * If nbytes <= resid, then we must skip over the rd/wr 916 0 stevel * bytes so we can read the next op/compound in this 917 0 stevel * packet. Otherwise, set the fragged flag so we can 918 0 stevel * display the fragged_rpc message. 919 0 stevel */ 920 0 stevel off = cur_pos - nfs4_pkt_start; 921 0 stevel resid = nfs4_pkt_len - off; 922 0 stevel 923 0 stevel /* 924 0 stevel * set nfs4_fragged_rpc if the requested number of "skip" 925 0 stevel * bytes is larger than the bytes remaining in the XDR 926 0 stevel * stream/current packet. The global is reset to 0 at 927 0 stevel * start of interpret_nfs4. 928 0 stevel */ 929 0 stevel new_pos = cur_pos + ((nfs4_fragged_rpc = len > resid) ? resid : len); 930 0 stevel 931 0 stevel /* there's nothing to do for error case (if it fails pkt is doomed) */ 932 0 stevel xdr_setpos(&xdrm, new_pos); 933 0 stevel } 934 0 stevel 935 0 stevel 936 0 stevel /* 937 0 stevel * Return the names and arguments of the oplist elements, up to 938 0 stevel * SUM_COMPND_MAX characters. If the elements don't fit, include a "..." 939 0 stevel * at the end of the string. 940 0 stevel */ 941 0 stevel static char * 942 0 stevel sum_cb_compound4args(void) 943 0 stevel { 944 0 stevel static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ 945 0 stevel int numops; 946 0 stevel const size_t buflen = sizeof (buf); 947 0 stevel char *bp; 948 0 stevel nfs_cb_argop4 one_op; 949 0 stevel uint32_t minor_version, callback_ident; 950 0 stevel 951 0 stevel buf[0] = '\0'; 952 0 stevel if (setjmp(xdr_err)) { 953 0 stevel bp = buf + strlen(buf); 954 0 stevel snprintf(bp, buflen - (bp - buf), "<XDR Error or Fragmented" 955 0 stevel " RPC>"); 956 0 stevel return (buf); 957 0 stevel } 958 0 stevel 959 0 stevel /* 960 0 stevel * might be nice to print minor version, but doesn't 961 0 stevel * seem like very useful info for summary mode 962 0 stevel */ 963 0 stevel if (!xdr_uint32_t(&xdrm, &minor_version)) 964 0 stevel longjmp(xdr_err, 1); 965 0 stevel 966 0 stevel /* print callback_ident */ 967 0 stevel if (!xdr_uint32_t(&xdrm, &callback_ident)) 968 0 stevel longjmp(xdr_err, 1); 969 0 stevel snprintf(buf, buflen, "CBID=%u ", callback_ident); 970 0 stevel 971 0 stevel bp = buf + strlen(buf); 972 0 stevel numops = getxdr_long(); 973 0 stevel 974 0 stevel while (numops-- > 0) { 975 0 stevel char *operand; 976 0 stevel 977 0 stevel bzero(&one_op, sizeof (one_op)); 978 0 stevel if (!xdr_nfs_cb_argop4(&xdrm, &one_op)) { 979 0 stevel xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); 980 0 stevel longjmp(xdr_err, 1); 981 0 stevel } 982 0 stevel 983 0 stevel snprintf(bp, buflen - (bp - buf), "%s ", 984 0 stevel cb_opcode_name(one_op.argop)); 985 0 stevel bp += strlen(bp); 986 0 stevel operand = sum_cb_operand(&one_op); 987 0 stevel if (strlen(operand) > 0) { 988 0 stevel snprintf(bp, buflen - (bp - buf), "%s ", operand); 989 0 stevel bp += strlen(bp); 990 0 stevel } 991 0 stevel 992 0 stevel xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); 993 0 stevel 994 0 stevel /* add "..." if past the "end" of the buffer */ 995 0 stevel if (bp - buf > SUM_COMPND_MAX) { 996 0 stevel strcpy(buf + SUM_COMPND_MAX - strlen("..."), 997 0 stevel "..."); 998 0 stevel break; 999 0 stevel } 1000 0 stevel } 1001 0 stevel 1002 0 stevel return (buf); 1003 0 stevel } 1004 0 stevel 1005 0 stevel /* 1006 0 stevel * Return the summarized argument list for the given nfs_argop4. 1007 0 stevel */ 1008 0 stevel 1009 0 stevel static char * 1010 0 stevel sum_operand(nfs_argop4 *opp) 1011 0 stevel { 1012 0 stevel static char buf[1024]; 1013 0 stevel void (*fmtproc)(char *, size_t, void *); 1014 0 stevel 1015 0 stevel buf[0] = '\0'; 1016 0 stevel if (opp->argop < num_opcodes) { 1017 0 stevel fmtproc = opcode_info[opp->argop].sumarg; 1018 0 stevel if (fmtproc != NULL) 1019 0 stevel fmtproc(buf, sizeof (buf), &opp->nfs_argop4_u); 1020 0 stevel } 1021 0 stevel 1022 0 stevel return (buf); 1023 0 stevel } 1024 0 stevel 1025 0 stevel /* 1026 0 stevel * Return the summarized argument list for the given nfs_argop4. 1027 0 stevel */ 1028 0 stevel 1029 0 stevel static char * 1030 0 stevel sum_cb_operand(nfs_cb_argop4 *opp) 1031 0 stevel { 1032 0 stevel static char buf[1024]; 1033 0 stevel void (*fmtproc)(char *, size_t, void *); 1034 0 stevel 1035 0 stevel buf[0] = '\0'; 1036 0 stevel if (opp->argop < cb_num_opcodes) { 1037 0 stevel fmtproc = cb_opcode_info[opp->argop].sumarg; 1038 0 stevel if (fmtproc != NULL) 1039 0 stevel fmtproc(buf, sizeof (buf), &opp->nfs_cb_argop4_u); 1040 0 stevel } 1041 0 stevel 1042 0 stevel return (buf); 1043 0 stevel } 1044 0 stevel 1045 0 stevel /* 1046 0 stevel * Print details about the nfs_argop4 that is next in the XDR stream. 1047 0 stevel */ 1048 0 stevel 1049 0 stevel static void 1050 0 stevel detail_nfs_argop4(void) 1051 0 stevel { 1052 0 stevel int numops; 1053 0 stevel nfs_argop4 one_op; 1054 0 stevel void (*fmtproc)(void *); 1055 0 stevel uint32_t minor_version; 1056 0 stevel 1057 0 stevel if (!xdr_uint32_t(&xdrm, &minor_version)) 1058 0 stevel longjmp(xdr_err, 1); 1059 0 stevel 1060 0 stevel (void) sprintf(get_line(0, 0), "Minor version = %u", 1061 0 stevel minor_version); 1062 0 stevel 1063 0 stevel numops = getxdr_long(); 1064 0 stevel (void) sprintf(get_line(0, 0), "Number of operations = %d", 1065 0 stevel numops); 1066 0 stevel 1067 0 stevel while (numops-- > 0) { 1068 0 stevel bzero(&one_op, sizeof (one_op)); 1069 0 stevel 1070 0 stevel if (!xdr_nfs_argop4(&xdrm, &one_op)) { 1071 0 stevel xdr_free(xdr_nfs_argop4, (char *)&one_op); 1072 0 stevel longjmp(xdr_err, 1); 1073 0 stevel } 1074 0 stevel 1075 0 stevel get_line(0, 0); /* blank line to separate ops */ 1076 0 stevel sprintf(get_line(0, 0), "Op = %d (%s)", 1077 0 stevel one_op.argop, opcode_name(one_op.argop)); 1078 0 stevel if (one_op.argop < num_opcodes) { 1079 0 stevel fmtproc = opcode_info[one_op.argop].dtlarg; 1080 0 stevel if (fmtproc != NULL) 1081 0 stevel fmtproc(&one_op.nfs_argop4_u); 1082 0 stevel } 1083 0 stevel 1084 0 stevel /* nfs4_skip_bytes set by xdr_nfs_argop4() */ 1085 0 stevel if (nfs4_skip_bytes) 1086 0 stevel nfs4_xdr_skip(nfs4_skip_bytes); 1087 0 stevel 1088 0 stevel xdr_free(xdr_nfs_argop4, (char *)&one_op); 1089 0 stevel } 1090 0 stevel } 1091 0 stevel 1092 0 stevel 1093 0 stevel /* 1094 0 stevel * Print details about the nfs_argop4 that is next in the XDR stream. 1095 0 stevel */ 1096 0 stevel static void 1097 0 stevel detail_cb_argop4(void) 1098 0 stevel { 1099 0 stevel int numops; 1100 0 stevel nfs_cb_argop4 one_op; 1101 0 stevel void (*fmtproc)(void *); 1102 0 stevel uint32_t minor_version, callback_ident; 1103 0 stevel 1104 0 stevel if (!xdr_uint32_t(&xdrm, &minor_version)) 1105 0 stevel longjmp(xdr_err, 1); 1106 0 stevel (void) sprintf(get_line(0, 0), "Minor version = %u", 1107 0 stevel minor_version); 1108 0 stevel 1109 0 stevel if (!xdr_uint32_t(&xdrm, &callback_ident)) 1110 0 stevel longjmp(xdr_err, 1); 1111 0 stevel (void) sprintf(get_line(0, 0), "Callback Ident = %u", 1112 0 stevel callback_ident); 1113 0 stevel 1114 0 stevel numops = getxdr_long(); 1115 0 stevel (void) sprintf(get_line(0, 0), "Number of operations = %d", 1116 0 stevel numops); 1117 0 stevel 1118 0 stevel while (numops-- > 0) { 1119 0 stevel bzero(&one_op, sizeof (one_op)); 1120 0 stevel if (!xdr_nfs_cb_argop4(&xdrm, &one_op)) { 1121 0 stevel xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); 1122 0 stevel longjmp(xdr_err, 1); 1123 0 stevel } 1124 0 stevel 1125 0 stevel get_line(0, 0); /* blank line to separate ops */ 1126 0 stevel sprintf(get_line(0, 0), "Op = %d (%s)", 1127 0 stevel one_op.argop, cb_opcode_name(one_op.argop)); 1128 0 stevel if (one_op.argop < cb_num_opcodes) { 1129 0 stevel fmtproc = cb_opcode_info[one_op.argop].dtlarg; 1130 0 stevel if (fmtproc != NULL) 1131 0 stevel fmtproc(&one_op.nfs_cb_argop4_u); 1132 0 stevel } 1133 0 stevel 1134 0 stevel xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); 1135 0 stevel } 1136 0 stevel } 1137 0 stevel 1138 0 stevel /* 1139 0 stevel * component_name: return a printable string for the given component4. I'm 1140 0 stevel * leaving this as a separate function (as opposed to having the callers 1141 0 stevel * call utf8localize() directly) in case the definition of component4 1142 0 stevel * changes. 1143 0 stevel */ 1144 0 stevel 1145 0 stevel static char * 1146 0 stevel component_name(component4 *cp) 1147 0 stevel { 1148 0 stevel return (utf8localize(cp)); 1149 0 stevel } 1150 0 stevel 1151 0 stevel /* 1152 0 stevel * linktext_name. cf. component_name(). 1153 0 stevel */ 1154 0 stevel 1155 0 stevel static char * 1156 0 stevel linktext_name(linktext4 *lp) 1157 0 stevel { 1158 0 stevel return (utf8localize(lp)); 1159 0 stevel } 1160 0 stevel 1161 0 stevel /* 1162 0 stevel * stable_how4_name: return a string for "how". 1163 0 stevel */ 1164 0 stevel 1165 0 stevel static char * 1166 0 stevel stable_how4_name(stable_how4 how) 1167 0 stevel { 1168 0 stevel char *result; 1169 0 stevel 1170 0 stevel switch (how) { 1171 0 stevel case UNSTABLE4: 1172 0 stevel result = "ASYNC"; 1173 0 stevel break; 1174 0 stevel case DATA_SYNC4: 1175 0 stevel result = "DSYNC"; 1176 0 stevel break; 1177 0 stevel case FILE_SYNC4: 1178 0 stevel result = "FSYNC"; 1179 0 stevel break; 1180 0 stevel default: 1181 0 stevel result = "?"; 1182 0 stevel break; 1183 0 stevel } 1184 0 stevel 1185 0 stevel return (result); 1186 0 stevel } 1187 0 stevel 1188 0 stevel /* 1189 0 stevel * sum_open_share_access: return a string corresponding to the 1190 0 stevel * given OPEN share access bitmask. 1191 0 stevel */ 1192 0 stevel 1193 0 stevel static char * 1194 0 stevel sum_open_share_access(int32_t mask) 1195 0 stevel { 1196 0 stevel char *result; 1197 0 stevel 1198 0 stevel switch (mask) { 1199 0 stevel case 0: 1200 0 stevel result = "N"; 1201 0 stevel break; 1202 0 stevel case OPEN4_SHARE_ACCESS_READ: 1203 0 stevel result = "R"; 1204 0 stevel break; 1205 0 stevel case OPEN4_SHARE_ACCESS_WRITE: 1206 0 stevel result = "W"; 1207 0 stevel break; 1208 0 stevel case OPEN4_SHARE_ACCESS_BOTH: 1209 0 stevel result = "RW"; 1210 0 stevel break; 1211 0 stevel default: 1212 0 stevel result = "?"; 1213 0 stevel break; 1214 0 stevel } 1215 0 stevel 1216 0 stevel return (result); 1217 0 stevel } 1218 0 stevel 1219 0 stevel /* 1220 0 stevel * sum_open_share_deny: return a string corresponding to the 1221 0 stevel * given OPEN share deny bitmask. 1222 0 stevel */ 1223 0 stevel 1224 0 stevel static char * 1225 0 stevel sum_open_share_deny(int32_t mask) 1226 0 stevel { 1227 0 stevel char *result; 1228 0 stevel 1229 0 stevel switch (mask) { 1230 0 stevel case OPEN4_SHARE_DENY_NONE: 1231 0 stevel result = "N"; 1232 0 stevel break; 1233 0 stevel case OPEN4_SHARE_DENY_READ: 1234 0 stevel result = "R"; 1235 0 stevel break; 1236 0 stevel case OPEN4_SHARE_DENY_WRITE: 1237 0 stevel result = "W"; 1238 0 stevel break; 1239 0 stevel case OPEN4_SHARE_DENY_BOTH: 1240 0 stevel result = "RW"; 1241 0 stevel break; 1242 0 stevel default: 1243 0 stevel result = "?"; 1244 0 stevel break; 1245 0 stevel } 1246 0 stevel 1247 0 stevel return (result); 1248 0 stevel } 1249 0 stevel 1250 0 stevel static int 1251 0 stevel special_stateid(stateid4 *stateid) 1252 0 stevel { 1253 0 stevel 1254 0 stevel if (! memcmp(stateid, &spec_stateid_0, sizeof (*stateid))) 1255 0 stevel return (0); 1256 0 stevel 1257 0 stevel if (! memcmp(stateid, &spec_stateid_1, sizeof (*stateid))) 1258 0 stevel return (1); 1259 0 stevel 1260 0 stevel return (-1); 1261 0 stevel } 1262 0 stevel 1263 0 stevel static char * 1264 0 stevel _sum_stateid(stateid4 *stateid, char *prefix) 1265 0 stevel { 1266 0 stevel static char buf[32]; 1267 0 stevel int spec; 1268 0 stevel 1269 0 stevel if ((spec = special_stateid(stateid)) < 0) 1270 0 stevel snprintf(buf, sizeof (buf), "%s%04X:%u", prefix, 1271 0 stevel stateid_hash(stateid), stateid->seqid); 1272 0 stevel else 1273 0 stevel snprintf(buf, sizeof (buf), "%s%s", prefix, 1274 0 stevel spec == 0 ? "SPC0" : (spec == 1 ? "SPC1" : "SPC?")); 1275 0 stevel return (buf); 1276 0 stevel } 1277 0 stevel 1278 0 stevel static void 1279 0 stevel _detail_stateid(stateid4 *stateid, char *prefix) 1280 0 stevel { 1281 0 stevel int spec; 1282 0 stevel char seqstr[32] = {0}; 1283 0 stevel 1284 0 stevel spec = special_stateid(stateid); 1285 0 stevel 1286 0 stevel if (spec < 0) 1287 0 stevel sprintf(get_line(0, 0), "%sState ID hash = %04X", 1288 0 stevel prefix, stateid_hash(stateid)); 1289 0 stevel else 1290 0 stevel sprintf(get_line(0, 0), "%sState ID hash = %s", prefix, 1291 0 stevel spec == 0 ? "SPECIAL_0" : 1292 0 stevel (spec == 1 ? "SPECIAL_1" : "SPECIAL_?")); 1293 0 stevel 1294 0 stevel sprintf(get_line(0, 0), " len = %u val = %s", 1295 0 stevel sizeof (stateid->other), 1296 0 stevel tohex(stateid->other, sizeof (stateid->other))); 1297 0 stevel 1298 0 stevel /* 1299 0 stevel * If spec 0/1 stateid, print seqid in hex; otherwise, 1300 0 stevel * use decimal. This makes it more clear how spec stateids 1301 0 stevel * are constructed [obvious that either all bits are 0, or all 1302 0 stevel * bits are 1]. 1303 0 stevel */ 1304 0 stevel if (spec == -1) 1305 0 stevel sprintf(seqstr, "%d", stateid->seqid); 1306 0 stevel else 1307 0 stevel sprintf(seqstr, "%08X", stateid->seqid); 1308 0 stevel 1309 0 stevel sprintf(get_line(0, 0), " %sState ID Sequence ID = %s", 1310 0 stevel prefix, seqstr); 1311 0 stevel } 1312 0 stevel 1313 0 stevel 1314 0 stevel static char * 1315 0 stevel sum_lock_denied(LOCK4denied *denied) 1316 0 stevel { 1317 0 stevel static char buf[64]; 1318 0 stevel 1319 0 stevel sprintf(buf, "%s %llu %llu LO=%04X", 1320 0 stevel sum_lock_type_name(denied->locktype), 1321 0 stevel denied->offset, denied->length, 1322 0 stevel owner_hash(&denied->owner.owner)); 1323 0 stevel 1324 0 stevel return (buf); 1325 0 stevel } 1326 0 stevel 1327 0 stevel static void 1328 0 stevel detail_lock_denied(LOCK4denied *denied) 1329 0 stevel { 1330 0 stevel sprintf(get_line(0, 0), "Type = %s", lock_type_name(denied->locktype)); 1331 0 stevel detail_lock_owner(&denied->owner); 1332 0 stevel sprintf(get_line(0, 0), "Offset = %llu", denied->offset); 1333 0 stevel sprintf(get_line(0, 0), "Length = %llu", denied->length); 1334 0 stevel } 1335 0 stevel 1336 0 stevel /* 1337 0 stevel * sum_createhow4: return the string name of "how". 1338 0 stevel */ 1339 0 stevel 1340 0 stevel static char * 1341 0 stevel createhow4_name(createhow4 *crtp) 1342 0 stevel { 1343 0 stevel char *result; 1344 0 stevel 1345 0 stevel switch (crtp->mode) { 1346 0 stevel case UNCHECKED4: 1347 0 stevel result = "UNCHECKED"; 1348 0 stevel break; 1349 0 stevel case GUARDED4: 1350 0 stevel result = "GUARDED"; 1351 0 stevel break; 1352 0 stevel case EXCLUSIVE4: 1353 0 stevel result = "EXCLUSIVE"; 1354 0 stevel break; 1355 0 stevel default: 1356 0 stevel result = "?"; 1357 0 stevel break; 1358 0 stevel } 1359 0 stevel 1360 0 stevel return (result); 1361 0 stevel } 1362 0 stevel 1363 0 stevel /* 1364 0 stevel * detail_createhow4: print detail information about "how". 1365 0 stevel */ 1366 0 stevel 1367 0 stevel static void 1368 0 stevel detail_createhow4(createhow4 *crtp) 1369 0 stevel { 1370 0 stevel sprintf(get_line(0, 0), "Method = %s", 1371 0 stevel createhow4_name(crtp)); 1372 0 stevel 1373 0 stevel switch (crtp->mode) { 1374 0 stevel case UNCHECKED4: 1375 0 stevel case GUARDED4: 1376 0 stevel detail_fattr4(&crtp->createhow4_u.createattrs); 1377 0 stevel break; 1378 0 stevel case EXCLUSIVE4: 1379 0 stevel sprintf(get_line(0, 0), " Verifier = %s", 1380 0 stevel tohex(crtp->createhow4_u.createverf, 1381 0 stevel NFS4_VERIFIER_SIZE)); 1382 0 stevel break; 1383 0 stevel } 1384 0 stevel } 1385 0 stevel 1386 0 stevel static void 1387 0 stevel detail_createtype4(createtype4 *crtp) 1388 0 stevel { 1389 0 stevel sprintf(get_line(0, 0), "Type = %s", 1390 0 stevel detail_type_name(crtp->type)); 1391 0 stevel switch (crtp->type) { 1392 0 stevel case NF4LNK: 1393 0 stevel sprintf(get_line(0, 0), "Linkdata = %s", 1394 0 stevel utf8localize(&crtp->createtype4_u.linkdata)); 1395 0 stevel break; 1396 0 stevel case NF4BLK: 1397 0 stevel case NF4CHR: 1398 0 stevel sprintf(get_line(0, 0), "Specdata1 = %04x Specdata2 = %04x", 1399 0 stevel crtp->createtype4_u.devdata.specdata1, 1400 0 stevel crtp->createtype4_u.devdata.specdata2); 1401 0 stevel break; 1402 0 stevel default: 1403 0 stevel break; 1404 0 stevel } 1405 0 stevel } 1406 0 stevel 1407 0 stevel static void 1408 0 stevel sumarg_access(char *buf, size_t buflen, void *obj) 1409 0 stevel { 1410 0 stevel ACCESS4args *args = (ACCESS4args *)obj; 1411 0 stevel 1412 0 stevel sum_access4(buf, buflen, args->access); 1413 0 stevel } 1414 0 stevel 1415 0 stevel static void 1416 0 stevel dtlarg_access(void *obj) 1417 0 stevel { 1418 0 stevel ACCESS4args *args = (ACCESS4args *)obj; 1419 0 stevel 1420 0 stevel detail_access4("Access bits", args->access); 1421 0 stevel } 1422 0 stevel 1423 0 stevel static void 1424 0 stevel sumarg_close(char *buf, size_t buflen, void *obj) 1425 0 stevel { 1426 0 stevel CLOSE4args *args = (CLOSE4args *)obj; 1427 0 stevel 1428 0 stevel snprintf(buf, buflen, "SQ=%u %s", 1429 0 stevel args->seqid, sum_open_stateid(&args->open_stateid)); 1430 0 stevel } 1431 0 stevel 1432 0 stevel static void 1433 0 stevel dtlarg_close(void *obj) 1434 0 stevel { 1435 0 stevel CLOSE4args *args = (CLOSE4args *)obj; 1436 0 stevel 1437 0 stevel detail_open_stateid(&args->open_stateid); 1438 0 stevel sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); 1439 0 stevel } 1440 0 stevel 1441 0 stevel static void 1442 0 stevel sumarg_commit(char *buf, size_t buflen, void *obj) 1443 0 stevel { 1444 0 stevel COMMIT4args *args = (COMMIT4args *)obj; 1445 0 stevel 1446 0 stevel snprintf(buf, buflen, "at %llu for %u ", args->offset, 1447 0 stevel args->count); 1448 0 stevel } 1449 0 stevel 1450 0 stevel static void 1451 0 stevel dtlarg_commit(void *obj) 1452 0 stevel { 1453 0 stevel COMMIT4args *args = (COMMIT4args *)obj; 1454 0 stevel 1455 0 stevel sprintf(get_line(0, 0), "Offset = %llu", args->offset); 1456 0 stevel sprintf(get_line(0, 0), "Count = %u", args->count); 1457 0 stevel } 1458 0 stevel 1459 0 stevel static void 1460 0 stevel sumarg_compnt(char *buf, size_t buflen, void *obj) 1461 0 stevel { 1462 0 stevel component4 *comp = (component4 *)obj; 1463 0 stevel 1464 0 stevel snprintf(buf, buflen, "%s", component_name(comp)); 1465 0 stevel } 1466 0 stevel 1467 0 stevel static void 1468 0 stevel dtlarg_compnt(void *obj) 1469 0 stevel { 1470 0 stevel component4 *comp = (component4 *)obj; 1471 0 stevel 1472 0 stevel sprintf(get_line(0, 0), "Name = %s", component_name(comp)); 1473 0 stevel } 1474 0 stevel 1475 0 stevel static void 1476 0 stevel sumarg_create(char *buf, size_t buflen, void *obj) 1477 0 stevel { 1478 0 stevel CREATE4args *args = (CREATE4args *)obj; 1479 0 stevel 1480 0 stevel snprintf(buf, buflen, "%s %s ", component_name(&args->objname), 1481 0 stevel sum_type_name(args->objtype.type)); 1482 0 stevel } 1483 0 stevel 1484 0 stevel static void 1485 0 stevel dtlarg_create(void *obj) 1486 0 stevel { 1487 0 stevel CREATE4args *args = (CREATE4args *)obj; 1488 0 stevel 1489 0 stevel sprintf(get_line(0, 0), "Name = %s", component_name(&args->objname)); 1490 0 stevel detail_createtype4(&args->objtype); 1491 0 stevel detail_fattr4(&args->createattrs); 1492 0 stevel } 1493 0 stevel 1494 0 stevel static void 1495 0 stevel sumarg_delprge(char *buf, size_t buflen, void *obj) 1496 0 stevel { 1497 0 stevel DELEGPURGE4args *args = (DELEGPURGE4args *)obj; 1498 0 stevel 1499 0 stevel snprintf(buf, buflen, "%s", sum_clientid(args->clientid)); 1500 0 stevel } 1501 0 stevel 1502 0 stevel static void 1503 0 stevel dtlarg_delprge(void *obj) 1504 0 stevel { 1505 0 stevel DELEGPURGE4args *args = (DELEGPURGE4args *)obj; 1506 0 stevel 1507 0 stevel detail_clientid(args->clientid); 1508 0 stevel } 1509 0 stevel 1510 0 stevel static void 1511 0 stevel sumarg_delret(char *buf, size_t buflen, void *obj) 1512 0 stevel { 1513 0 stevel DELEGRETURN4args *args = (DELEGRETURN4args *)obj; 1514 0 stevel 1515 0 stevel snprintf(buf, buflen, "%s", sum_deleg_stateid(&args->deleg_stateid)); 1516 0 stevel } 1517 0 stevel 1518 0 stevel static void 1519 0 stevel dtlarg_delret(void *obj) 1520 0 stevel { 1521 0 stevel DELEGRETURN4args *args = (DELEGRETURN4args *)obj; 1522 0 stevel 1523 0 stevel detail_deleg_stateid(&args->deleg_stateid); 1524 0 stevel } 1525 0 stevel 1526 0 stevel static void 1527 0 stevel sumarg_getattr(char *buf, size_t buflen, void *obj) 1528 0 stevel { 1529 0 stevel GETATTR4args *args = (GETATTR4args *)obj; 1530 0 stevel 1531 0 stevel sum_attr_bitmap(buf, buflen, &args->attr_request); 1532 0 stevel } 1533 0 stevel 1534 0 stevel static void 1535 0 stevel dtlarg_getattr(void *obj) 1536 0 stevel { 1537 0 stevel GETATTR4args *args = (GETATTR4args *)obj; 1538 0 stevel 1539 0 stevel detail_attr_bitmap("", &args->attr_request, NULL); 1540 0 stevel } 1541 0 stevel 1542 0 stevel static void 1543 0 stevel sumarg_cb_getattr(char *buf, size_t buflen, void *obj) 1544 0 stevel { 1545 0 stevel CB_GETATTR4args *args = (CB_GETATTR4args *)obj; 1546 0 stevel char *bp = buf; 1547 0 stevel 1548 0 stevel snprintf(bp, buflen, "%s ", sum_fh4(&args->fh)); 1549 0 stevel bp += strlen(bp); 1550 0 stevel sum_attr_bitmap(bp, buflen - (bp - buf), &args->attr_request); 1551 0 stevel } 1552 0 stevel 1553 0 stevel static void 1554 0 stevel dtlarg_cb_getattr(void *obj) 1555 0 stevel { 1556 0 stevel CB_GETATTR4args *args = (CB_GETATTR4args *)obj; 1557 0 stevel 1558 0 stevel detail_fh4(&args->fh); 1559 0 stevel detail_attr_bitmap("", &args->attr_request, NULL); 1560 0 stevel } 1561 0 stevel 1562 0 stevel static void 1563 0 stevel sumarg_cb_recall(char *buf, size_t buflen, void *obj) 1564 0 stevel { 1565 0 stevel CB_RECALL4args *args = (CB_RECALL4args *)obj; 1566 0 stevel char *bp = buf; 1567 0 stevel 1568 0 stevel snprintf(bp, buflen, "%s %s TR=%s", sum_fh4(&args->fh), 1569 0 stevel sum_stateid(&args->stateid), args->truncate ? "T" : "F"); 1570 0 stevel } 1571 0 stevel 1572 0 stevel static void 1573 0 stevel dtlarg_cb_recall(void *obj) 1574 0 stevel { 1575 0 stevel CB_RECALL4args *args = (CB_RECALL4args *)obj; 1576 0 stevel 1577 0 stevel detail_fh4(&args->fh); 1578 0 stevel detail_stateid(&args->stateid); 1579 0 stevel sprintf(get_line(0, 0), "Truncate = %s", 1580 0 stevel args->truncate ? "True" : "False"); 1581 0 stevel } 1582 0 stevel 1583 0 stevel 1584 0 stevel /* 1585 0 stevel * name openhow seqid claim access deny owner 1586 0 stevel */ 1587 0 stevel static void 1588 0 stevel sumarg_open(char *buf, size_t buflen, void *obj) 1589 0 stevel { 1590 0 stevel OPEN4args *args = (OPEN4args *)obj; 1591 0 stevel char *bp = buf; 1592 0 stevel int blen = buflen, len; 1593 0 stevel 1594 0 stevel sum_name(bp, buflen, &args->claim); 1595 0 stevel bp += (len = strlen(bp)); 1596 0 stevel blen -= len; 1597 0 stevel 1598 0 stevel sum_openflag(bp, blen, &args->openhow); 1599 0 stevel bp += (len = strlen(bp)); 1600 0 stevel blen -= len; 1601 0 stevel 1602 0 stevel snprintf(bp, blen, " SQ=%u", args->seqid); 1603 0 stevel bp += (len = strlen(bp)); 1604 0 stevel blen -= len; 1605 0 stevel 1606 0 stevel sum_claim(bp, blen, &args->claim); 1607 0 stevel bp += (len = strlen(bp)); 1608 0 stevel blen -= len; 1609 0 stevel 1610 0 stevel snprintf(bp, blen, " AC=%s DN=%s OO=%04X", 1611 0 stevel sum_open_share_access(args->share_access), 1612 0 stevel sum_open_share_deny(args->share_deny), 1613 0 stevel owner_hash(&args->owner.owner)); 1614 0 stevel } 1615 0 stevel 1616 0 stevel static void 1617 0 stevel dtlarg_open(void *obj) 1618 0 stevel { 1619 0 stevel OPEN4args *args = (OPEN4args *)obj; 1620 0 stevel 1621 0 stevel detail_claim(&args->claim); 1622 0 stevel detail_openflag(&args->openhow); 1623 0 stevel detail_open_owner(&args->owner); 1624 0 stevel sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); 1625 0 stevel sprintf(get_line(0, 0), "Access = 0x%x (%s)", 1626 0 stevel args->share_access, sum_open_share_access(args->share_access)); 1627 0 stevel sprintf(get_line(0, 0), "Deny = 0x%x (%s)", 1628 0 stevel args->share_deny, sum_open_share_access(args->share_deny)); 1629 0 stevel } 1630 0 stevel 1631 0 stevel static void 1632 0 stevel sumarg_openattr(char *buf, size_t buflen, void *obj) 1633 0 stevel { 1634 0 stevel OPENATTR4args *args = (OPENATTR4args *)obj; 1635 0 stevel 1636 0 stevel snprintf(buf, buflen, "CD=%s", 1637 0 stevel args->createdir ? "T" : "F"); 1638 0 stevel } 1639 0 stevel 1640 0 stevel static void 1641 0 stevel dtlarg_openattr(void *obj) 1642 0 stevel { 1643 0 stevel OPENATTR4args *args = (OPENATTR4args *)obj; 1644 0 stevel 1645 0 stevel sprintf(get_line(0, 0), "CreateDir = %s", 1646 0 stevel args->createdir ? "True" : "False"); 1647 0 stevel } 1648 0 stevel 1649 0 stevel static void 1650 0 stevel sumarg_open_confirm(char *buf, size_t buflen, void *obj) 1651 0 stevel { 1652 0 stevel char *bp = buf; 1653 0 stevel OPEN_CONFIRM4args *args = (OPEN_CONFIRM4args *)obj; 1654 0 stevel 1655 0 stevel snprintf(bp, buflen, "SQ=%u %s", args->seqid, 1656 0 stevel sum_open_stateid(&args->open_stateid)); 1657 0 stevel } 1658 0 stevel 1659 0 stevel static void 1660 0 stevel dtlarg_open_confirm(void *obj) 1661 0 stevel { 1662 0 stevel OPEN_CONFIRM4args *args = (OPEN_CONFIRM4args *)obj; 1663 0 stevel 1664 0 stevel sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); 1665 0 stevel detail_open_stateid(&args->open_stateid); 1666 0 stevel } 1667 0 stevel 1668 0 stevel static void 1669 0 stevel sumarg_open_downgrd(char *buf, size_t buflen, void *obj) 1670 0 stevel { 1671 0 stevel OPEN_DOWNGRADE4args *args = (OPEN_DOWNGRADE4args *)obj; 1672 0 stevel 1673 0 stevel snprintf(buf, buflen, "SQ=%u %s AC=%s DN=%s", 1674 0 stevel args->seqid, sum_open_stateid(&args->open_stateid), 1675 0 stevel sum_open_share_access(args->share_access), 1676 0 stevel sum_open_share_deny(args->share_deny)); 1677 0 stevel } 1678 0 stevel 1679 0 stevel static void 1680 0 stevel dtlarg_open_downgrd(void *obj) 1681 0 stevel { 1682 0 stevel OPEN_DOWNGRADE4args *args = (OPEN_DOWNGRADE4args *)obj; 1683 0 stevel 1684 0 stevel sprintf(get_line(0, 0), "Open Sequence ID = %u", args->seqid); 1685 0 stevel detail_open_stateid(&args->open_stateid); 1686 0 stevel sprintf(get_line(0, 0), "Access = 0x%x (%s)", 1687 0 stevel args->share_access, sum_open_share_access(args->share_access)); 1688 0 stevel sprintf(get_line(0, 0), "Deny = 0x%x (%s)", 1689 0 stevel args->share_deny, sum_open_share_access(args->share_deny)); 1690 0 stevel } 1691 0 stevel 1692 0 stevel static void 1693 0 stevel sumarg_putfh(char *buf, size_t buflen, void *obj) 1694 0 stevel { 1695 0 stevel PUTFH4args *args = (PUTFH4args *)obj; 1696 0 stevel 1697 0 stevel snprintf(buf, buflen, "%s", sum_fh4(&args->object)); 1698 0 stevel } 1699 0 stevel 1700 0 stevel static void 1701 0 stevel dtlarg_putfh(void *obj) 1702 0 stevel { 1703 0 stevel PUTFH4args *args = (PUTFH4args *)obj; 1704 0 stevel 1705 0 stevel detail_fh4(&args->object); 1706 0 stevel } 1707 0 stevel 1708 0 stevel static void 1709 0 stevel sumarg_link(char *buf, size_t buflen, void *obj) 1710 0 stevel { 1711 0 stevel LINK4args *args = (LINK4args *)obj; 1712 0 stevel 1713 0 stevel snprintf(buf, buflen, "%s", component_name(&args->newname)); 1714 0 stevel } 1715 0 stevel 1716 0 stevel static void 1717 0 stevel dtlarg_link(void *obj) 1718 0 stevel { 1719 0 stevel LINK4args *args = (LINK4args *)obj; 1720 0 stevel 1721 0 stevel sprintf(get_line(0, 0), "New name = %s", 1722 0 stevel component_name(&args->newname)); 1723 0 stevel } 1724 0 stevel 1725 0 stevel static void 1726 0 stevel sum_open_to_lock_owner(char *buf, int buflen, open_to_lock_owner4 *own) 1727 0 stevel { 1728 0 stevel snprintf(buf, buflen, " OSQ=%u %s LSQ=%u LO=%04X", own->open_seqid, 1729 0 stevel sum_open_stateid(&own->open_stateid), own->lock_seqid, 1730 0 stevel owner_hash(&own->lock_owner.owner)); 1731 0 stevel } 1732 0 stevel 1733 0 stevel static void 1734 0 stevel sum_exist_lock_owner(char *buf, int buflen, exist_lock_owner4 *own) 1735 0 stevel { 1736 0 stevel snprintf(buf, buflen, " LSQ=%u %s", own->lock_seqid, 1737 0 stevel sum_lock_stateid(&own->lock_stateid)); 1738 0 stevel } 1739 0 stevel 1740 0 stevel static void 1741 0 stevel sum_locker(char *buf, size_t len, locker4 *lk) 1742 0 stevel { 1743 0 stevel if (lk->new_lock_owner == TRUE) 1744 0 stevel sum_open_to_lock_owner(buf, len, &lk->locker4_u.open_owner); 1745 0 stevel else 1746 0 stevel sum_exist_lock_owner(buf, len, &lk->locker4_u.lock_owner); 1747 0 stevel } 1748 0 stevel 1749 0 stevel static char * 1750 0 stevel sum_lock_type_name(enum nfs_lock_type4 type) 1751 0 stevel { 1752 0 stevel char *result; 1753 0 stevel 1754 0 stevel switch (type) { 1755 0 stevel case READ_LT: 1756 0 stevel result = "RD"; 1757 0 stevel break; 1758 0 stevel case WRITE_LT: 1759 0 stevel result = "WR"; 1760 0 stevel break; 1761 0 stevel case READW_LT: 1762 0 stevel result = "RDW"; 1763 0 stevel break; 1764 0 stevel case WRITEW_LT: 1765 0 stevel result = "WRW"; 1766 0 stevel break; 1767 0 stevel default: 1768 0 stevel result = "?"; 1769 0 stevel break; 1770 0 stevel } 1771 0 stevel 1772 0 stevel return (result); 1773 0 stevel } 1774 0 stevel 1775 0 stevel static void 1776 0 stevel sumarg_lock(char *buf, size_t buflen, void *obj) 1777 0 stevel { 1778 0 stevel LOCK4args *args = (LOCK4args *)obj; 1779 0 stevel char *bp = buf; 1780 0 stevel 1781 0 stevel snprintf(buf, buflen, "%s%s%llu:%llu", 1782 0 stevel sum_lock_type_name(args->locktype), 1783 0 stevel args->reclaim ? " reclaim " : " ", 1784 0 stevel args->offset, args->length); 1785 0 stevel 1786 0 stevel bp += strlen(buf); 1787 0 stevel sum_locker(bp, buflen - (bp - buf), &args->locker); 1788 0 stevel } 1789 0 stevel 1790 0 stevel static void 1791 0 stevel detail_open_to_lock_owner(open_to_lock_owner4 *own) 1792 0 stevel { 1793 0 stevel sprintf(get_line(0, 0), "Open Sequence ID = %u", own->open_seqid); 1794 0 stevel detail_open_stateid(&own->open_stateid); 1795 0 stevel sprintf(get_line(0, 0), "Lock Sequence ID = %u", own->lock_seqid); 1796 0 stevel detail_lock_owner(&own->lock_owner); 1797 0 stevel } 1798 0 stevel 1799 0 stevel static void 1800 0 stevel detail_exist_lock_owner(exist_lock_owner4 *own) 1801 0 stevel { 1802 0 stevel detail_lock_stateid(&own->lock_stateid); 1803 0 stevel sprintf(get_line(0, 0), "Lock Sequence ID = %u", own->lock_seqid); 1804 0 stevel } 1805 0 stevel 1806 0 stevel static void 1807 0 stevel detail_locker(locker4 *lk) 1808 0 stevel { 1809 0 stevel if (lk->new_lock_owner == TRUE) 1810 0 stevel detail_open_to_lock_owner(&lk->locker4_u.open_owner); 1811 0 stevel else 1812 0 stevel detail_exist_lock_owner(&lk->locker4_u.lock_owner); 1813 0 stevel } 1814 0 stevel 1815 0 stevel static void 1816 0 stevel dtlarg_lock(void *obj) 1817 0 stevel { 1818 0 stevel LOCK4args *args = (LOCK4args *)obj; 1819 0 stevel 1820 0 stevel sprintf(get_line(0, 0), "Type = %s", lock_type_name(args->locktype)); 1821 0 stevel sprintf(get_line(0, 0), "Reclaim = %s", 1822 0 stevel args->reclaim ? "TRUE" : "FALSE"); 1823 0 stevel sprintf(get_line(0, 0), "Offset = %llu", args->offset); 1824 0 stevel sprintf(get_line(0, 0), "Length = %llu", args->length); 1825 0 stevel detail_locker(&args->locker); 1826 0 stevel } 1827 0 stevel 1828 0 stevel static void 1829 0 stevel sumarg_lockt(char *buf, size_t buflen, void *obj) 1830 0 stevel { 1831 0 stevel LOCKT4args *args = (LOCKT4args *)obj; 1832 0 stevel 1833 0 stevel snprintf(buf, buflen, "R=%llu:%llu", 1834 0 stevel args->offset, args->length); 1835 0 stevel } 1836 0 stevel 1837 0 stevel static void 1838 0 stevel dtlarg_lockt(void *obj) 1839 0 stevel { 1840 0 stevel LOCKT4args *args = (LOCKT4args *)obj; 1841 0 stevel 1842 0 stevel sprintf(get_line(0, 0), "Type = %s", lock_type_name(args->locktype)); 1843 0 stevel detail_lock_owner(&args->owner); 1844 0 stevel sprintf(get_line(0, 0), "Offset = %llu", args->offset); 1845 0 stevel sprintf(get_line(0, 0), "Length = %llu", args->length); 1846 0 stevel } 1847 0 stevel 1848 0 stevel static void 1849 0 stevel sumarg_locku(char *buf, size_t buflen, void *obj) 1850 0 stevel { 1851 0 stevel LOCKU4args *args = (LOCKU4args *)obj; 1852 0 stevel 1853 0 stevel snprintf(buf, buflen, "R=%llu:%llu LSQ=%u %s", 1854 0 stevel args->offset, args->length, args->seqid, 1855 0 stevel sum_lock_stateid(&args->lock_stateid)); 1856 0 stevel } 1857 0 stevel 1858 0 stevel 1859 0 stevel static void 1860 0 stevel dtlarg_locku(void *obj) 1861 0 stevel { 1862 0 stevel LOCKU4args *args = (LOCKU4args *)obj; 1863 0 stevel 1864 0 stevel sprintf(get_line(0, 0), "Type = %s", lock_type_name(args->locktype)); 1865 0 stevel sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); 1866 0 stevel detail_lock_stateid(&args->lock_stateid); 1867 0 stevel sprintf(get_line(0, 0), "Offset = %llu", args->offset); 1868 0 stevel sprintf(get_line(0, 0), "Length = %llu", args->length); 1869 0 stevel } 1870 0 stevel 1871 0 stevel static void 1872 0 stevel sumarg_lookup(char *buf, size_t buflen, void *obj) 1873 0 stevel { 1874 0 stevel LOOKUP4args *args = (LOOKUP4args *)obj; 1875 0 stevel 1876 0 stevel sum_compname4(buf, buflen, &args->objname); 1877 0 stevel } 1878 0 stevel 1879 0 stevel static void 1880 0 stevel dtlarg_lookup(void *obj) 1881 0 stevel { 1882 0 stevel LOOKUP4args *args = (LOOKUP4args *)obj; 1883 0 stevel 1884 0 stevel detail_compname4(&args->objname); 1885 0 stevel } 1886 0 stevel 1887 0 stevel static void 1888 0 stevel sumarg_read(char *buf, size_t buflen, void *obj) 1889 0 stevel { 1890 0 stevel READ4args *args = (READ4args *)obj; 1891 0 stevel 1892 0 stevel snprintf(buf, buflen, "%s at %llu for %u", 1893 0 stevel sum_stateid(&args->stateid), args->offset, args->count); 1894 0 stevel } 1895 0 stevel 1896 0 stevel static void 1897 0 stevel dtlarg_read(void *obj) 1898 0 stevel { 1899 0 stevel READ4args *args = (READ4args *)obj; 1900 0 stevel 1901 0 stevel sprintf(get_line(0, 0), "Offset = %llu", args->offset); 1902 0 stevel sprintf(get_line(0, 0), "Count = %u", args->count); 1903 0 stevel detail_stateid(&args->stateid); 1904 0 stevel } 1905 0 stevel 1906 0 stevel static void 1907 0 stevel sumarg_readdir(char *buf, size_t buflen, void *obj) 1908 0 stevel { 1909 0 stevel READDIR4args *args = (READDIR4args *)obj; 1910 0 stevel 1911 0 stevel snprintf(buf, buflen, "Cookie=%llu (%s) for %u/%u", 1912 0 stevel args->cookie, tohex(args->cookieverf, NFS4_VERIFIER_SIZE), 1913 0 stevel args->dircount, args->maxcount); 1914 0 stevel } 1915 0 stevel 1916 0 stevel static void 1917 0 stevel dtlarg_readdir(void *obj) 1918 0 stevel { 1919 0 stevel READDIR4args *args = (READDIR4args *)obj; 1920 0 stevel 1921 0 stevel sprintf(get_line(0, 0), "Cookie = %llu", args->cookie); 1922 0 stevel sprintf(get_line(0, 0), "Verifier = %s", 1923 0 stevel tohex(args->cookieverf, NFS4_VERIFIER_SIZE)); 1924 0 stevel sprintf(get_line(0, 0), "Dircount = %u", args->dircount); 1925 0 stevel sprintf(get_line(0, 0), "Maxcount = %u", args->maxcount); 1926 0 stevel detail_attr_bitmap("", &args->attr_request, NULL); 1927 0 stevel } 1928 0 stevel 1929 0 stevel static void 1930 0 stevel dtlarg_release_lkown(void *obj) 1931 0 stevel { 1932 0 stevel RELEASE_LOCKOWNER4args *args = (RELEASE_LOCKOWNER4args *)obj; 1933 0 stevel 1934 0 stevel detail_lock_owner(&args->lock_owner); 1935 0 stevel } 1936 0 stevel 1937 0 stevel static void 1938 0 stevel sumarg_release_lkown(char *buf, size_t buflen, void *obj) 1939 0 stevel 1940 0 stevel { 1941 0 stevel RELEASE_LOCKOWNER4args *args = (RELEASE_LOCKOWNER4args *)obj; 1942 0 stevel 1943 0 stevel snprintf(buf, buflen, "LO=%04X", owner_hash(&args->lock_owner.owner)); 1944 0 stevel } 1945 0 stevel 1946 0 stevel static void 1947 0 stevel sumarg_rename(char *buf, size_t buflen, void *obj) 1948 0 stevel { 1949 0 stevel RENAME4args *args = (RENAME4args *)obj; 1950 0 stevel 1951 0 stevel snprintf(buf, buflen, "%s to %s", 1952 0 stevel component_name(&args->oldname), 1953 0 stevel component_name(&args->newname)); 1954 0 stevel } 1955 0 stevel 1956 0 stevel static void 1957 0 stevel dtlarg_rename(void *obj) 1958 0 stevel { 1959 0 stevel RENAME4args *args = (RENAME4args *)obj; 1960 0 stevel 1961 0 stevel sprintf(get_line(0, 0), "Old name = %s", 1962 0 stevel component_name(&args->oldname)); 1963 0 stevel sprintf(get_line(0, 0), "New name = %s", 1964 0 stevel component_name(&args->newname)); 1965 0 stevel } 1966 0 stevel 1967 0 stevel static void 1968 0 stevel sumarg_renew(char *buf, size_t buflen, void *obj) 1969 0 stevel { 1970 0 stevel RENEW4args *args = (RENEW4args *)obj; 1971 0 stevel 1972 0 stevel snprintf(buf, buflen, "%s", sum_clientid(args->clientid)); 1973 0 stevel } 1974 0 stevel static void 1975 0 stevel dtlarg_renew(void *obj) 1976 0 stevel { 1977 0 stevel RENEW4args *args = (RENEW4args *)obj; 1978 0 stevel 1979 0 stevel detail_clientid(args->clientid); 1980 0 stevel } 1981 0 stevel 1982 0 stevel static void 1983 0 stevel sumarg_secinfo(char *buf, size_t buflen, void *obj) 1984 0 stevel { 1985 0 stevel SECINFO4args *args = (SECINFO4args *)obj; 1986 0 stevel 1987 0 stevel snprintf(buf, buflen, "%s", 1988 0 stevel component_name(&args->name)); 1989 0 stevel } 1990 0 stevel 1991 0 stevel static void 1992 0 stevel dtlarg_secinfo(void *obj) 1993 0 stevel { 1994 0 stevel SECINFO4args *args = (SECINFO4args *)obj; 1995 0 stevel 1996 0 stevel sprintf(get_line(0, 0), "Name = %s", 1997 0 stevel component_name(&args->name)); 1998 0 stevel } 1999 0 stevel 2000 0 stevel static void 2001 0 stevel sumarg_setattr(char *buf, size_t buflen, void *obj) 2002 0 stevel { 2003 0 stevel SETATTR4args *args = (SETATTR4args *)obj; 2004 0 stevel 2005 0 stevel snprintf(buf, buflen, "%s", sum_stateid(&args->stateid)); 2006 0 stevel } 2007 0 stevel 2008 0 stevel static void 2009 0 stevel dtlarg_setattr(void *obj) 2010 0 stevel { 2011 0 stevel SETATTR4args *args = (SETATTR4args *)obj; 2012 0 stevel 2013 0 stevel detail_stateid(&args->stateid); 2014 0 stevel detail_fattr4(&args->obj_attributes); 2015 0 stevel } 2016 0 stevel 2017 0 stevel static void 2018 0 stevel sumarg_setclid(char *buf, size_t buflen, void *obj) 2019 0 stevel { 2020 0 stevel SETCLIENTID4args *args = (SETCLIENTID4args *)obj; 2021 0 stevel 2022 0 stevel snprintf(buf, buflen, "Prog=%u ID=%s Addr=%s CBID=%u", 2023 0 stevel args->callback.cb_program, 2024 0 stevel args->callback.cb_location.r_netid, 2025 0 stevel args->callback.cb_location.r_addr, args->callback_ident); 2026 0 stevel } 2027 0 stevel 2028 0 stevel static void 2029 0 stevel dtlarg_setclid(void *obj) 2030 0 stevel { 2031 0 stevel SETCLIENTID4args *args = (SETCLIENTID4args *)obj; 2032 0 stevel 2033 0 stevel sprintf(get_line(0, 0), "Verifier=%s", 2034 0 stevel tohex(args->client.verifier, NFS4_VERIFIER_SIZE)); 2035 0 stevel sprintf(get_line(0, 0), "ID = (%d) %s", 2036 0 stevel args->client.id.id_len, 2037 0 stevel tohex(args->client.id.id_val, args->client.id.id_len)); 2038 0 stevel 2039 0 stevel sprintf(get_line(0, 0), "Callback Program = %u", 2040 0 stevel args->callback.cb_program); 2041 0 stevel sprintf(get_line(0, 0), "Callback Net ID = %s", 2042 0 stevel args->callback.cb_location.r_netid); 2043 0 stevel sprintf(get_line(0, 0), "Callback Addr = %s", 2044 0 stevel args->callback.cb_location.r_addr); 2045 0 stevel sprintf(get_line(0, 0), "Callback Ident = %u", args->callback_ident); 2046 0 stevel } 2047 0 stevel 2048 0 stevel static void 2049 0 stevel sumarg_setclid_cfm(char *buf, size_t buflen, void *obj) 2050 0 stevel { 2051 0 stevel SETCLIENTID_CONFIRM4args *args = (SETCLIENTID_CONFIRM4args *)obj; 2052 0 stevel 2053 0 stevel snprintf(buf, buflen, "%s CFV=%s", sum_clientid(args->clientid), 2054 0 stevel tohex(args->setclientid_confirm, NFS4_VERIFIER_SIZE)); 2055 0 stevel } 2056 0 stevel 2057 0 stevel static void 2058 0 stevel dtlarg_setclid_cfm(void *obj) 2059 0 stevel { 2060 0 stevel SETCLIENTID_CONFIRM4args *args = (SETCLIENTID_CONFIRM4args *)obj; 2061 0 stevel 2062 0 stevel detail_clientid(args->clientid); 2063 0 stevel sprintf(get_line(0, 0), "Set Client ID Confirm Verifier = %s", 2064 0 stevel tohex(args->setclientid_confirm, NFS4_VERIFIER_SIZE)); 2065 0 stevel } 2066 0 stevel 2067 0 stevel 2068 0 stevel static void 2069 0 stevel dtlarg_verify(void *obj) 2070 0 stevel { 2071 0 stevel NVERIFY4args *args = (NVERIFY4args *)obj; 2072 0 stevel 2073 0 stevel detail_fattr4(&args->obj_attributes); 2074 0 stevel } 2075 0 stevel 2076 0 stevel static void 2077 0 stevel sumarg_write(char *buf, size_t buflen, void *obj) 2078 0 stevel { 2079 0 stevel WRITE4args *args = (WRITE4args *)obj; 2080 0 stevel 2081 0 stevel snprintf(buf, buflen, "%s at %llu for %u", 2082 0 stevel sum_stateid(&args->stateid), args->offset, args->data.data_len); 2083 0 stevel } 2084 0 stevel 2085 0 stevel static void 2086 0 stevel dtlarg_write(void *obj) 2087 0 stevel { 2088 0 stevel WRITE4args *args = (WRITE4args *)obj; 2089 0 stevel 2090 0 stevel sprintf(get_line(0, 0), "Offset = %llu", args->offset); 2091 0 stevel sprintf(get_line(0, 0), "Count = %u", args->data.data_len); 2092 0 stevel sprintf(get_line(0, 0), "Stable = %s", stable_how4_name(args->stable)); 2093 0 stevel detail_stateid(&args->stateid); 2094 0 stevel } 2095 0 stevel 2096 0 stevel static char * 2097 0 stevel sum_fh4(nfs_fh4 *fh) 2098 0 stevel { 2099 0 stevel static char buf[20]; 2100 0 stevel 2101 0 stevel sprintf(buf, "FH=%04X", fh4_hash(fh)); 2102 0 stevel 2103 0 stevel return (buf); 2104 0 stevel } 2105 0 stevel 2106 0 stevel static void 2107 0 stevel detail_fh4(nfs_fh4 *fh) 2108 0 stevel { 2109 0 stevel int i; 2110 0 stevel uchar_t *cp; 2111 0 stevel char *bufp; 2112 0 stevel 2113 0 stevel sprintf(get_line(0, 0), "File handle = [%04X]", fh4_hash(fh)); 2114 0 stevel bufp = get_line(0, 0); 2115 0 stevel sprintf(bufp, "(%d) ", fh->nfs_fh4_len); 2116 0 stevel bufp += strlen(bufp); 2117 0 stevel /* XXX use tohex()? */ 2118 0 stevel for (i = 0, cp = (uchar_t *)fh->nfs_fh4_val; 2119 0 stevel i < fh->nfs_fh4_len; 2120 0 stevel i++, cp++) { 2121 0 stevel if (i != 0 && i % 32 == 0) 2122 0 stevel bufp = get_line(0, 0); 2123 0 stevel sprintf(bufp, "%02x", *cp); 2124 0 stevel bufp += strlen(bufp); 2125 0 stevel } 2126 0 stevel } 2127 0 stevel 2128 0 stevel static void 2129 0 stevel detail_fattr4(fattr4 *attrp) 2130 0 stevel { 2131 0 stevel unpkd_attrmap_t provided; 2132 0 stevel uint_t attrnum; 2133 0 stevel XDR attrxdr; 2134 0 stevel jmp_buf old_errbuf; 2135 0 stevel 2136 0 stevel xdrmem_create(&attrxdr, attrp->attr_vals.attrlist4_val, 2137 0 stevel attrp->attr_vals.attrlist4_len, XDR_DECODE); 2138 0 stevel 2139 0 stevel bcopy(xdr_err, old_errbuf, sizeof (old_errbuf)); 2140 0 stevel if (setjmp(xdr_err)) { 2141 0 stevel sprintf(get_line(0, 0), "<attr_vals too short>"); 2142 0 stevel goto done; 2143 0 stevel } 2144 0 stevel 2145 0 stevel detail_attr_bitmap("", &attrp->attrmask, &provided); 2146 0 stevel for (attrnum = 0; attrnum < MAX_ATTRIBUTES; attrnum++) { 2147 0 stevel if (provided.map[attrnum]) { 2148 0 stevel attr_info[attrnum].prt_details(&attrxdr); 2149 0 stevel } 2150 0 stevel } 2151 0 stevel 2152 0 stevel done: 2153 0 stevel bcopy(old_errbuf, xdr_err, sizeof (old_errbuf)); 2154 0 stevel } 2155 0 stevel 2156 0 stevel static void 2157 0 stevel sum_attr_bitmap(char *buf, size_t buflen, bitmap4 *mapp) 2158 0 stevel { 2159 0 stevel uint_t num_words; 2160 0 stevel char *bp; 2161 0 stevel size_t curlen, remaining; 2162 0 stevel 2163 0 stevel buf[0] = '\0'; 2164 0 stevel for (num_words = 0; num_words < mapp->bitmap4_len; num_words++) { 2165 0 stevel curlen = strlen(buf); 2166 0 stevel if (curlen + sizeof ("<Too Long>") >= buflen) { 2167 0 stevel strcpy(buf + buflen - sizeof ("<Too Long>"), 2168 0 stevel "<Too Long>"); 2169 0 stevel return; 2170 0 stevel } 2171 0 stevel bp = buf + curlen; 2172 0 stevel remaining = buflen - curlen; 2173 0 stevel snprintf(bp, remaining, 2174 0 stevel num_words == 0 ? "%x" : " %x", 2175 0 stevel mapp->bitmap4_val[num_words]); 2176 0 stevel } 2177 0 stevel } 2178 0 stevel 2179 0 stevel /* 2180 0 stevel * Print detail information for the given attribute bitmap, and fill in the 2181 0 stevel * unpacked version of the map if "unpacked" is non-null. Returns the 2182 0 stevel * number of bytes in the bitmap. "prefix" is an initial string that is 2183 0 stevel * printed at the front of each line. 2184 0 stevel */ 2185 0 stevel 2186 0 stevel static void 2187 0 stevel detail_attr_bitmap(char *prefix, bitmap4 *bitp, unpkd_attrmap_t *unpacked) 2188 0 stevel { 2189 0 stevel uint_t num_words; 2190 0 stevel uint32_t *wp; 2191 0 stevel uint_t byte_num; 2192 0 stevel 2193 0 stevel if (unpacked != NULL) 2194 0 stevel memset(unpacked, 0, sizeof (unpkd_attrmap_t)); 2195 0 stevel 2196 0 stevel /* 2197 0 stevel * Break the bitmap into octets, then print in hex and 2198 0 stevel * symbolically. 2199 0 stevel */ 2200 0 stevel 2201 0 stevel for (num_words = 0, wp = bitp->bitmap4_val; 2202 0 stevel num_words < bitp->bitmap4_len; 2203 0 stevel num_words++, wp++) { 2204 0 stevel for (byte_num = 0; byte_num < 4; byte_num++) { 2205 0 stevel uchar_t val = (*wp) >> (byte_num * 8); 2206 0 stevel char *buf = get_line(0, 0); 2207 0 stevel uint_t attrnum; 2208 0 stevel int bit; 2209 0 stevel 2210 0 stevel sprintf(buf, "%s 0x%02x ", prefix, val); 2211 0 stevel attrnum = num_words * 32 + byte_num * 8; 2212 0 stevel for (bit = 7; bit >= 0; bit--) { 2213 0 stevel if (val & (1 << bit)) { 2214 0 stevel strcat(buf, " "); 2215 0 stevel strcat(buf, 2216 0 stevel attr_name(attrnum + bit)); 2217 0 stevel if (unpacked != NULL) 2218 0 stevel unpacked->map[attrnum + bit] = 2219 0 stevel 1; 2220 0 stevel } 2221 0 stevel } 2222 0 stevel } 2223 0 stevel } 2224 0 stevel } 2225 0 stevel 2226 0 stevel /* 2227 0 stevel * Format the summary line results from a COMPOUND4 call. 2228 0 stevel */ 2229 0 stevel 2230 0 stevel static void 2231 0 stevel sum_comp4res(char *line, char *(*sumres_fn)(void)) 2232 0 stevel { 2233 0 stevel nfsstat4 status; 2234 0 stevel static utf8string tag; 2235 0 stevel 2236 0 stevel status = getxdr_long(); 2237 0 stevel if (!xdr_utf8string(&xdrm, &tag)) 2238 0 stevel longjmp(xdr_err, 1); 2239 0 stevel 2240 0 stevel sprintf(line, "(%.20s) %s %s", utf8localize(&tag), 2241 0 stevel status_name(status), sumres_fn()); 2242 0 stevel 2243 0 stevel xdr_free(xdr_utf8string, (char *)&tag); 2244 0 stevel } 2245 0 stevel 2246 0 stevel 2247 0 stevel /* 2248 0 stevel * Return a set of summary strings for the result data that's next in the 2249 0 stevel * XDR stream, up to SUM_COMPND_MAX characters. If the strings don't fit, 2250 0 stevel * include a "..." at the end of the string. 2251 0 stevel */ 2252 0 stevel 2253 0 stevel static char * 2254 0 stevel sum_compound4res(void) 2255 0 stevel { 2256 0 stevel static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ 2257 0 stevel int numres; 2258 0 stevel const size_t buflen = sizeof (buf); 2259 0 stevel char *bp; 2260 0 stevel nfs_resop4 one_res; 2261 0 stevel 2262 0 stevel buf[0] = '\0'; 2263 0 stevel if (setjmp(xdr_err)) { 2264 0 stevel bp = buf + strlen(buf); 2265 0 stevel snprintf(bp, buflen - (bp - buf), 2266 0 stevel nfs4_fragged_rpc ? nfs4err_fragrpc : nfs4err_xdrfrag); 2267 0 stevel return (buf); 2268 0 stevel } 2269 0 stevel 2270 0 stevel numres = getxdr_long(); 2271 0 stevel bp = buf; 2272 0 stevel while (numres-- > 0) { 2273 0 stevel char *result; 2274 0 stevel 2275 0 stevel bzero(&one_res, sizeof (one_res)); 2276 0 stevel 2277 0 stevel if (!xdr_nfs_resop4(&xdrm, &one_res)) { 2278 0 stevel xdr_free(xdr_nfs_resop4, (char *)&one_res); 2279 0 stevel longjmp(xdr_err, 1); 2280 0 stevel } 2281 0 stevel 2282 0 stevel snprintf(bp, buflen - (bp - buf), "%s ", 2283 0 stevel opcode_name(one_res.resop)); 2284 0 stevel bp += strlen(bp); 2285 0 stevel 2286 0 stevel result = sum_result(&one_res); 2287 0 stevel if (strlen(result) > 0) { 2288 0 stevel snprintf(bp, buflen - (bp - buf), "%s ", result); 2289 0 stevel bp += strlen(bp); 2290 0 stevel } 2291 0 stevel 2292 0 stevel /* nfs4_skip_bytes set by xdr_nfs4_argop4() */ 2293 0 stevel if (nfs4_skip_bytes != 0) 2294 0 stevel nfs4_xdr_skip(nfs4_skip_bytes); 2295 0 stevel 2296 0 stevel xdr_free(xdr_nfs_resop4, (char *)&one_res); 2297 0 stevel /* add "..." if past the "end" of the buffer */ 2298 0 stevel if (bp - buf > SUM_COMPND_MAX) { 2299 0 stevel strcpy(buf + SUM_COMPND_MAX - strlen("..."), 2300 0 stevel "..."); 2301 0 stevel break; 2302 0 stevel } 2303 0 stevel } 2304 0 stevel 2305 0 stevel return (buf); 2306 0 stevel } 2307 0 stevel 2308 0 stevel 2309 0 stevel /* 2310 0 stevel * Return a set of summary strings for the result data that's next in the 2311 0 stevel * XDR stream, up to SUM_COMPND_MAX characters. If the strings don't fit, 2312 0 stevel * include a "..." at the end of the string. 2313 0 stevel */ 2314 0 stevel 2315 0 stevel static char * 2316 0 stevel sum_cb_compound4res(void) 2317 0 stevel { 2318 0 stevel static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ 2319 0 stevel int numres; 2320 0 stevel const size_t buflen = sizeof (buf); 2321 0 stevel char *bp; 2322 0 stevel nfs_cb_resop4 one_res; 2323 0 stevel 2324 0 stevel buf[0] = '\0'; 2325 0 stevel if (setjmp(xdr_err)) { 2326 0 stevel bp = buf + strlen(buf); 2327 0 stevel snprintf(bp, buflen - (bp - buf), "<XDR Error or Fragmented" 2328 0 stevel " RPC>"); 2329 0 stevel return (buf); 2330 0 stevel } 2331 0 stevel 2332 0 stevel numres = getxdr_long(); 2333 0 stevel bp = buf; 2334 0 stevel while (numres-- > 0) { 2335 0 stevel bzero(&one_res, sizeof (one_res)); 2336 0 stevel if (!xdr_nfs_cb_resop4(&xdrm, &one_res)) { 2337 0 stevel xdr_free(xdr_nfs_cb_resop4, (char *)&one_res); 2338 0 stevel longjmp(xdr_err, 1); 2339 0 stevel } 2340 0 stevel snprintf(bp, buflen - (bp - buf), "%s %s ", 2341 0 stevel cb_opcode_name(one_res.resop), 2342 0 stevel sum_cb_result(&one_res)); 2343 0 stevel bp += strlen(bp); 2344 0 stevel 2345 0 stevel xdr_free(xdr_nfs_cb_resop4, (char *)&one_res); 2346 0 stevel 2347 0 stevel /* add "..." if past the "end" of the buffer */ 2348 0 stevel if (bp - buf > SUM_COMPND_MAX) { 2349 0 stevel strcpy(buf + SUM_COMPND_MAX - strlen("..."), 2350 0 stevel "..."); 2351 0 stevel break; 2352 0 stevel } 2353 0 stevel } 2354 0 stevel 2355 0 stevel return (buf); 2356 0 stevel } 2357 0 stevel 2358 0 stevel 2359 0 stevel /* 2360 0 stevel * Return the summarized results for the given resultdata. 2361 0 stevel */ 2362 0 stevel 2363 0 stevel static char * 2364 0 stevel sum_result(nfs_resop4 *resp) 2365 0 stevel { 2366 0 stevel static char buf[1024]; 2367 0 stevel void (*fmtproc)(char *, size_t, void *); 2368 0 stevel 2369 0 stevel buf[0] = '\0'; 2370 0 stevel if (resp->resop < num_opcodes) 2371 0 stevel fmtproc = opcode_info[resp->resop].sumres; 2372 0 stevel else if (resp->resop == OP_ILLEGAL) 2373 0 stevel fmtproc = sum_nfsstat4; 2374 0 stevel else 2375 0 stevel fmtproc = NULL; 2376 0 stevel 2377 0 stevel if (fmtproc != NULL) 2378 0 stevel fmtproc(buf, sizeof (buf), &resp->nfs_resop4_u); 2379 0 stevel 2380 0 stevel return (buf); 2381 0 stevel } 2382 0 stevel 2383 0 stevel /* 2384 0 stevel * Return the summarized results for the given resultdata. 2385 0 stevel */ 2386 0 stevel 2387 0 stevel static char * 2388 0 stevel sum_cb_result(nfs_cb_resop4 *resp) 2389 0 stevel { 2390 0 stevel static char buf[1024]; 2391 0 stevel void (*fmtproc)(char *, size_t, void *); 2392 0 stevel 2393 0 stevel buf[0] = '\0'; 2394 0 stevel if (resp->resop < cb_num_opcodes) 2395 0 stevel fmtproc = cb_opcode_info[resp->resop].sumres; 2396 0 stevel else if (resp->resop == OP_CB_ILLEGAL) 2397 0 stevel fmtproc = sum_nfsstat4; 2398 0 stevel else 2399 0 stevel fmtproc = NULL; 2400 0 stevel 2401 0 stevel if (fmtproc != NULL) 2402 0 stevel fmtproc(buf, sizeof (buf), &resp->nfs_cb_resop4_u); 2403 0 stevel 2404 0 stevel return (buf); 2405 0 stevel } 2406 0 stevel 2407 0 stevel 2408 0 stevel static void 2409 0 stevel dtl_change_info(char *msg, change_info4 *infop) 2410 0 stevel { 2411 0 stevel sprintf(get_line(0, 0), "%s:", msg); 2412 0 stevel sprintf(get_line(0, 0), " Atomic = %s", 2413 0 stevel infop->atomic ? "TRUE" : "FALSE"); 2414 0 stevel detail_fattr4_change(" Before", infop->before); 2415 0 stevel detail_fattr4_change(" After", infop->after); 2416 0 stevel } 2417 0 stevel 2418 0 stevel static void 2419 0 stevel detail_fattr4_change(char *msg, fattr4_change chg) 2420 0 stevel { 2421 0 stevel sprintf(get_line(0, 0), "%s: 0x%llx", msg, chg); 2422 0 stevel /* XXX print as time_t, too? */ 2423 0 stevel } 2424 0 stevel 2425 0 stevel static void 2426 0 stevel sum_nfsstat4(char *buf, size_t buflen, void *obj) 2427 0 stevel { 2428 0 stevel nfsstat4 status = *(nfsstat4 *)obj; 2429 0 stevel 2430 0 stevel strncpy(buf, status_name(status), buflen); 2431 0 stevel } 2432 0 stevel 2433 0 stevel static void 2434 0 stevel dtl_nfsstat4(void *obj) 2435 0 stevel { 2436 0 stevel nfsstat4 status = *(nfsstat4 *)obj; 2437 0 stevel 2438 0 stevel sprintf(get_line(0, 0), "Status = %d (%s)", status, 2439 0 stevel status_name(status)); 2440 0 stevel } 2441 0 stevel 2442 0 stevel static void 2443 0 stevel sumres_access(char *buf, size_t buflen, void *obj) 2444 0 stevel { 2445 0 stevel ACCESS4res *res = (ACCESS4res *)obj; 2446 0 stevel char *bp = buf; 2447 0 stevel int len, blen = buflen; 2448 0 stevel 2449 0 stevel strcpy(bp, status_name(res->status)); 2450 0 stevel if (res->status == NFS4_OK) { 2451 0 stevel bp += (len = strlen(bp)); 2452 0 stevel blen -= len; 2453 0 stevel 2454 0 stevel snprintf(bp, blen, " Supp="); 2455 0 stevel bp += (len = strlen(bp)); 2456 0 stevel blen -= len; 2457 0 stevel 2458 0 stevel sum_access4(bp, blen, res->ACCESS4res_u.resok4.supported); 2459 0 stevel bp += (len = strlen(bp)); 2460 0 stevel blen -= len; 2461 0 stevel 2462 0 stevel snprintf(bp, blen, " Allow="); 2463 0 stevel bp += (len = strlen(bp)); 2464 0 stevel blen -= len; 2465 0 stevel 2466 0 stevel sum_access4(bp, blen, res->ACCESS4res_u.resok4.access); 2467 0 stevel } 2468 0 stevel } 2469 0 stevel 2470 0 stevel static void 2471 0 stevel dtlres_access(void *obj) 2472 0 stevel { 2473 0 stevel ACCESS4res *res = (ACCESS4res *)obj; 2474 0 stevel 2475 0 stevel dtl_nfsstat4(obj); 2476 0 stevel if (res->status == NFS4_OK) { 2477 0 stevel detail_access4("Supported Attributes", 2478 0 stevel res->ACCESS4res_u.resok4.supported); 2479 0 stevel detail_access4("Allowed Attributes", 2480 0 stevel res->ACCESS4res_u.resok4.access); 2481 0 stevel } 2482 0 stevel } 2483 0 stevel 2484 0 stevel static void 2485 0 stevel sumres_close(char *buf, size_t buflen, void *obj) 2486 0 stevel { 2487 0 stevel CLOSE4res *res = (CLOSE4res *)obj; 2488 0 stevel 2489 0 stevel if (res->status == NFS4_OK) 2490 0 stevel snprintf(buf, buflen, "%s", 2491 0 stevel sum_open_stateid(&res->CLOSE4res_u.open_stateid)); 2492 0 stevel } 2493 0 stevel 2494 0 stevel static void 2495 0 stevel dtlres_close(void *obj) 2496 0 stevel { 2497 0 stevel CLOSE4res *res = (CLOSE4res *)obj; 2498 0 stevel 2499 0 stevel dtl_nfsstat4(obj); 2500 0 stevel if (res->status == NFS4_OK) { 2501 0 stevel detail_open_stateid(&res->CLOSE4res_u.open_stateid); 2502 0 stevel } 2503 0 stevel } 2504 0 stevel 2505 0 stevel static void 2506 0 stevel sumres_commit(char *buf, size_t buflen, void *obj) 2507 0 stevel { 2508 0 stevel COMMIT4res *res = (COMMIT4res *)obj; 2509 0 stevel 2510 0 stevel if (res->status == NFS4_OK) 2511 0 stevel snprintf(buf, buflen, "Verf=%s", 2512 0 stevel tohex(res->COMMIT4res_u.resok4.writeverf, 2513 0 stevel NFS4_VERIFIER_SIZE)); 2514 0 stevel } 2515 0 stevel 2516 0 stevel static void 2517 0 stevel dtlres_commit(void *obj) 2518 0 stevel { 2519 0 stevel COMMIT4res *res = (COMMIT4res *)obj; 2520 0 stevel 2521 0 stevel dtl_nfsstat4(obj); 2522 0 stevel if (res->status == NFS4_OK) { 2523 0 stevel sprintf(get_line(0, 0), "Verifier = %s", 2524 0 stevel tohex(res->COMMIT4res_u.resok4.writeverf, 2525 0 stevel NFS4_VERIFIER_SIZE)); 2526 0 stevel } 2527 0 stevel } 2528 0 stevel 2529 0 stevel static void 2530 0 stevel dtlres_create(void *obj) 2531 0 stevel { 2532 0 stevel CREATE4res *res = (CREATE4res *)obj; 2533 0 stevel 2534 0 stevel dtl_nfsstat4(obj); 2535 0 stevel if (res->status == NFS4_OK) { 2536 0 stevel dtl_change_info("Change Information", 2537 0 stevel &res->CREATE4res_u.resok4.cinfo); 2538 0 stevel detail_attr_bitmap("", &res->CREATE4res_u.resok4.attrset, 2539 0 stevel NULL); 2540 0 stevel } 2541 0 stevel } 2542 0 stevel 2543 0 stevel static void 2544 0 stevel sumres_getattr(char *buf, size_t buflen, void *obj) 2545 0 stevel { 2546 0 stevel GETATTR4res *res = (GETATTR4res *)obj; 2547 0 stevel 2548 0 stevel strncpy(buf, status_name(res->status), buflen); 2549 0 stevel } 2550 0 stevel 2551 0 stevel static void 2552 0 stevel dtlres_getattr(void *obj) 2553 0 stevel { 2554 0 stevel GETATTR4res *res = (GETATTR4res *)obj; 2555 0 stevel 2556 0 stevel dtl_nfsstat4(obj); 2557 0 stevel if (res->status == NFS4_OK) { 2558 0 stevel detail_fattr4(&res->GETATTR4res_u.resok4.obj_attributes); 2559 0 stevel } 2560 0 stevel } 2561 0 stevel 2562 0 stevel static void 2563 0 stevel sumres_cb_getattr(char *buf, size_t buflen, void *obj) 2564 0 stevel { 2565 0 stevel CB_GETATTR4res *res = (CB_GETATTR4res *)obj; 2566 0 stevel 2567 0 stevel strncpy(buf, status_name(res->status), buflen); 2568 0 stevel } 2569 0 stevel 2570 0 stevel static void 2571 0 stevel dtlres_cb_getattr(void *obj) 2572 0 stevel { 2573 0 stevel CB_GETATTR4res *res = (CB_GETATTR4res *)obj; 2574 0 stevel 2575 0 stevel dtl_nfsstat4(obj); 2576 0 stevel if (res->status == NFS4_OK) { 2577 0 stevel detail_fattr4(&res->CB_GETATTR4res_u.resok4.obj_attributes); 2578 0 stevel } 2579 0 stevel } 2580 0 stevel 2581 0 stevel 2582 0 stevel static void 2583 0 stevel sumres_getfh(char *buf, size_t buflen, void *obj) 2584 0 stevel { 2585 0 stevel char *bp; 2586 0 stevel GETFH4res *res = (GETFH4res *)obj; 2587 0 stevel 2588 0 stevel strncpy(buf, status_name(res->status), buflen); 2589 0 stevel if (res->status == NFS4_OK) { 2590 0 stevel bp = buf + strlen(buf); 2591 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2592 0 stevel sum_fh4(&res->GETFH4res_u.resok4.object)); 2593 0 stevel } 2594 0 stevel } 2595 0 stevel 2596 0 stevel static void 2597 0 stevel dtlres_getfh(void *obj) 2598 0 stevel { 2599 0 stevel GETFH4res *res = (GETFH4res *)obj; 2600 0 stevel 2601 0 stevel dtl_nfsstat4(obj); 2602 0 stevel if (res->status == NFS4_OK) { 2603 0 stevel detail_fh4(&res->GETFH4res_u.resok4.object); 2604 0 stevel } 2605 0 stevel } 2606 0 stevel 2607 0 stevel static void 2608 0 stevel dtlres_link(void *obj) 2609 0 stevel { 2610 0 stevel LINK4res *res = (LINK4res *)obj; 2611 0 stevel 2612 0 stevel dtl_nfsstat4(obj); 2613 0 stevel if (res->status == NFS4_OK) { 2614 0 stevel dtl_change_info("Change Information", 2615 0 stevel &res->LINK4res_u.resok4.cinfo); 2616 0 stevel } 2617 0 stevel } 2618 0 stevel 2619 0 stevel static void 2620 0 stevel sumres_lock(char *buf, size_t buflen, void *obj) 2621 0 stevel { 2622 0 stevel char *bp; 2623 0 stevel LOCK4res *res = (LOCK4res *)obj; 2624 0 stevel 2625 0 stevel strncpy(buf, status_name(res->status), buflen); 2626 0 stevel if (res->status == NFS4_OK) { 2627 0 stevel bp = buf + strlen(buf); 2628 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2629 0 stevel sum_lock_stateid(&res->LOCK4res_u.resok4.lock_stateid)); 2630 0 stevel } 2631 0 stevel if (res->status == NFS4ERR_DENIED) { 2632 0 stevel bp = buf + strlen(buf); 2633 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2634 0 stevel sum_lock_denied(&res->LOCK4res_u.denied)); 2635 0 stevel } 2636 0 stevel } 2637 0 stevel 2638 0 stevel static void 2639 0 stevel dtlres_lock(void *obj) 2640 0 stevel { 2641 0 stevel LOCK4res *res = (LOCK4res *)obj; 2642 0 stevel 2643 0 stevel dtl_nfsstat4(obj); 2644 0 stevel if (res->status == NFS4_OK) { 2645 0 stevel detail_lock_stateid(&res->LOCK4res_u.resok4.lock_stateid); 2646 0 stevel } 2647 0 stevel if (res->status == NFS4ERR_DENIED) { 2648 0 stevel detail_lock_denied(&res->LOCK4res_u.denied); 2649 0 stevel } 2650 0 stevel } 2651 0 stevel 2652 0 stevel static void 2653 0 stevel sumres_lockt(char *buf, size_t buflen, void *obj) 2654 0 stevel { 2655 0 stevel char *bp; 2656 0 stevel LOCKT4res *res = (LOCKT4res *)obj; 2657 0 stevel 2658 0 stevel strcpy(buf, status_name(res->status)); 2659 0 stevel if (res->status == NFS4ERR_DENIED) { 2660 0 stevel bp = buf + strlen(buf); 2661 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2662 0 stevel sum_lock_denied(&res->LOCKT4res_u.denied)); 2663 0 stevel } 2664 0 stevel } 2665 0 stevel 2666 0 stevel static void 2667 0 stevel dtlres_lockt(void *obj) 2668 0 stevel { 2669 0 stevel LOCKT4res *res = (LOCKT4res *)obj; 2670 0 stevel 2671 0 stevel dtl_nfsstat4(obj); 2672 0 stevel if (res->status == NFS4ERR_DENIED) { 2673 0 stevel detail_lock_denied(&res->LOCKT4res_u.denied); 2674 0 stevel } 2675 0 stevel } 2676 0 stevel 2677 0 stevel static void 2678 0 stevel sumres_locku(char *buf, size_t buflen, void *obj) 2679 0 stevel { 2680 0 stevel char *bp; 2681 0 stevel LOCKU4res *res = (LOCKU4res *)obj; 2682 0 stevel 2683 0 stevel strncpy(buf, status_name(res->status), buflen); 2684 0 stevel bp = buf + strlen(buf); 2685 0 stevel if (res->status == NFS4_OK) 2686 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2687 0 stevel sum_lock_stateid(&res->LOCKU4res_u.lock_stateid)); 2688 0 stevel } 2689 0 stevel 2690 0 stevel static void 2691 0 stevel dtlres_locku(void *obj) 2692 0 stevel { 2693 0 stevel LOCKU4res *res = (LOCKU4res *)obj; 2694 0 stevel 2695 0 stevel dtl_nfsstat4(obj); 2696 0 stevel if (res->status == NFS4_OK) 2697 0 stevel detail_lock_stateid(&res->LOCKU4res_u.lock_stateid); 2698 0 stevel } 2699 0 stevel 2700 0 stevel static void 2701 0 stevel sumres_open(char *buf, size_t buflen, void *obj) 2702 0 stevel { 2703 0 stevel char *bp = buf; 2704 0 stevel OPEN4res *res = (OPEN4res *)obj; 2705 0 stevel uint_t rflags; 2706 0 stevel int len, blen = buflen; 2707 0 stevel 2708 0 stevel strncpy(bp, status_name(res->status), blen); 2709 0 stevel 2710 0 stevel if (res->status == NFS4_OK) { 2711 0 stevel bp += (len = strlen(bp)); 2712 0 stevel blen -= len; 2713 0 stevel 2714 0 stevel snprintf(bp, blen, " %s", 2715 0 stevel sum_stateid(&res->OPEN4res_u.resok4.stateid)); 2716 0 stevel bp += (len = strlen(bp)); 2717 0 stevel blen -= len; 2718 0 stevel 2719 0 stevel if ((rflags = res->OPEN4res_u.resok4.rflags) != 0) { 2720 0 stevel snprintf(bp, blen, "%s", sum_open_rflags(rflags)); 2721 0 stevel bp += (len = strlen(bp)); 2722 0 stevel blen -= len; 2723 0 stevel } 2724 0 stevel 2725 0 stevel sum_delegation(bp, blen, &res->OPEN4res_u.resok4.delegation); 2726 0 stevel } 2727 0 stevel } 2728 0 stevel 2729 0 stevel static void 2730 0 stevel dtlres_open(void *obj) 2731 0 stevel { 2732 0 stevel OPEN4res *res = (OPEN4res *)obj; 2733 0 stevel 2734 0 stevel dtl_nfsstat4(obj); 2735 0 stevel if (res->status == NFS4_OK) { 2736 0 stevel detail_stateid(&res->OPEN4res_u.resok4.stateid); 2737 0 stevel dtl_change_info("Change Information", 2738 0 stevel &res->OPEN4res_u.resok4.cinfo); 2739 0 stevel sprintf(get_line(0, 0), "Flags = 0x%x (%s)", 2740 0 stevel res->OPEN4res_u.resok4.rflags, 2741 0 stevel detail_open_rflags(res->OPEN4res_u.resok4.rflags)); 2742 0 stevel detail_attr_bitmap("", &res->OPEN4res_u.resok4.attrset, 2743 0 stevel NULL); 2744 0 stevel detail_delegation(&res->OPEN4res_u.resok4.delegation); 2745 0 stevel } 2746 0 stevel } 2747 0 stevel 2748 0 stevel static void 2749 0 stevel sumres_open_confirm(char *buf, size_t buflen, void *obj) 2750 0 stevel { 2751 0 stevel char *bp; 2752 0 stevel OPEN_CONFIRM4res *res = (OPEN_CONFIRM4res *)obj; 2753 0 stevel 2754 0 stevel strncpy(buf, status_name(res->status), buflen); 2755 0 stevel if (res->status == NFS4_OK) { 2756 0 stevel bp = buf + strlen(buf); 2757 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2758 0 stevel sum_open_stateid(&res->OPEN_CONFIRM4res_u.resok4. 2759 0 stevel open_stateid)); 2760 0 stevel } 2761 0 stevel } 2762 0 stevel 2763 0 stevel static void 2764 0 stevel dtlres_open_confirm(void *obj) 2765 0 stevel { 2766 0 stevel OPEN_CONFIRM4res *res = (OPEN_CONFIRM4res *)obj; 2767 0 stevel 2768 0 stevel dtl_nfsstat4(obj); 2769 0 stevel if (res->status == NFS4_OK) { 2770 0 stevel detail_open_stateid(&res->OPEN_CONFIRM4res_u.resok4. 2771 0 stevel open_stateid); 2772 0 stevel } 2773 0 stevel } 2774 0 stevel 2775 0 stevel static void 2776 0 stevel sumres_open_downgrd(char *buf, size_t buflen, void *obj) 2777 0 stevel { 2778 0 stevel char *bp; 2779 0 stevel OPEN_DOWNGRADE4res *res = (OPEN_DOWNGRADE4res *)obj; 2780 0 stevel 2781 0 stevel strncpy(buf, status_name(res->status), buflen); 2782 0 stevel if (res->status == NFS4_OK) { 2783 0 stevel bp = buf + strlen(buf); 2784 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2785 0 stevel sum_open_stateid(&res->OPEN_DOWNGRADE4res_u.resok4. 2786 0 stevel open_stateid)); 2787 0 stevel } 2788 0 stevel } 2789 0 stevel 2790 0 stevel static void 2791 0 stevel dtlres_open_downgrd(void *obj) 2792 0 stevel { 2793 0 stevel OPEN_DOWNGRADE4res *res = (OPEN_DOWNGRADE4res *)obj; 2794 0 stevel 2795 0 stevel dtl_nfsstat4(obj); 2796 0 stevel if (res->status == NFS4_OK) { 2797 0 stevel detail_open_stateid(&res->OPEN_DOWNGRADE4res_u.resok4. 2798 0 stevel open_stateid); 2799 0 stevel } 2800 0 stevel } 2801 0 stevel 2802 0 stevel static void 2803 0 stevel sumres_read(char *buf, size_t buflen, void *obj) 2804 0 stevel { 2805 0 stevel char *bp; 2806 0 stevel READ4res *res = (READ4res *)obj; 2807 0 stevel 2808 0 stevel strncpy(buf, status_name(res->status), buflen); 2809 0 stevel if (res->status == NFS4_OK) { 2810 0 stevel bp = buf + strlen(buf); 2811 0 stevel snprintf(bp, buflen - (bp - buf), " (%u bytes) %s", 2812 0 stevel res->READ4res_u.resok4.data.data_len, 2813 0 stevel res->READ4res_u.resok4.eof ? "EOF" : ""); 2814 0 stevel } 2815 0 stevel } 2816 0 stevel 2817 0 stevel static void 2818 0 stevel dtlres_read(void *obj) 2819 0 stevel { 2820 0 stevel READ4res *res = (READ4res *)obj; 2821 0 stevel 2822 0 stevel dtl_nfsstat4(obj); 2823 0 stevel if (res->status == NFS4_OK) { 2824 0 stevel sprintf(get_line(0, 0), "Count = %u bytes read", 2825 0 stevel res->READ4res_u.resok4.data.data_len); 2826 0 stevel sprintf(get_line(0, 0), "End of file = %s", 2827 0 stevel res->READ4res_u.resok4.eof ? "TRUE" : "FALSE"); 2828 0 stevel } 2829 0 stevel } 2830 0 stevel 2831 0 stevel static void 2832 0 stevel sumres_readdir(char *buf, size_t buflen, void *obj) 2833 0 stevel { 2834 0 stevel char *bp; 2835 0 stevel READDIR4res *res = (READDIR4res *)obj; 2836 0 stevel int num_entries = 0; 2837 0 stevel entry4 *ep; 2838 0 stevel 2839 0 stevel strncpy(buf, status_name(res->status), buflen); 2840 0 stevel if (res->status == NFS4_OK) { 2841 0 stevel for (ep = res->READDIR4res_u.resok4.reply.entries; 2842 0 stevel ep != NULL; 2843 0 stevel ep = ep->nextentry) 2844 0 stevel num_entries++; 2845 0 stevel bp = buf + strlen(buf); 2846 0 stevel snprintf(bp, buflen - (bp - buf), " %d entries (%s)", 2847 0 stevel num_entries, 2848 0 stevel res->READDIR4res_u.resok4.reply.eof 2849 0 stevel ? "No more" : "More"); 2850 0 stevel } 2851 0 stevel } 2852 0 stevel 2853 0 stevel static void 2854 0 stevel dtlres_readdir(void *obj) 2855 0 stevel { 2856 0 stevel READDIR4res *res = (READDIR4res *)obj; 2857 0 stevel int num_entries = 0; 2858 0 stevel entry4 *ep; 2859 0 stevel 2860 0 stevel dtl_nfsstat4(obj); 2861 0 stevel if (res->status == NFS4_OK) { 2862 0 stevel for (ep = res->READDIR4res_u.resok4.reply.entries; 2863 0 stevel ep != NULL; 2864 0 stevel ep = ep->nextentry) { 2865 0 stevel num_entries++; 2866 0 stevel sprintf(get_line(0, 0), 2867 0 stevel "------------------ entry #%d", 2868 0 stevel num_entries); 2869 0 stevel sprintf(get_line(0, 0), "Cookie = %llu", 2870 0 stevel ep->cookie); 2871 0 stevel sprintf(get_line(0, 0), "Name = %s", 2872 0 stevel component_name(&ep->name)); 2873 0 stevel detail_fattr4(&ep->attrs); 2874 0 stevel } 2875 0 stevel if (num_entries == 0) 2876 0 stevel sprintf(get_line(0, 0), "(No entries)"); 2877 0 stevel sprintf(get_line(0, 0), "EOF = %s", 2878 0 stevel res->READDIR4res_u.resok4.reply.eof ? "TRUE" : "FALSE"); 2879 0 stevel sprintf(get_line(0, 0), "Verifer = %s", 2880 0 stevel tohex(res->READDIR4res_u.resok4.cookieverf, 2881 0 stevel NFS4_VERIFIER_SIZE)); 2882 0 stevel } 2883 0 stevel } 2884 0 stevel 2885 0 stevel static void 2886 0 stevel sumres_readlnk(char *buf, size_t buflen, void *obj) 2887 0 stevel { 2888 0 stevel char *bp; 2889 0 stevel READLINK4res *res = (READLINK4res *)obj; 2890 0 stevel 2891 0 stevel strncpy(buf, status_name(res->status), buflen); 2892 0 stevel if (res->status == NFS4_OK) { 2893 0 stevel bp = buf + strlen(buf); 2894 0 stevel snprintf(bp, buflen - (bp - buf), " %s", 2895 0 stevel linktext_name(&res->READLINK4res_u.resok4.link)); 2896 0 stevel } 2897 0 stevel } 2898 0 stevel 2899 0 stevel static void 2900 0 stevel dtlres_readlnk(void *obj) 2901 0 stevel { 2902 0 stevel READLINK4res *res = (READLINK4res *)obj; 2903 0 stevel 2904 0 stevel dtl_nfsstat4(obj); 2905 0 stevel if (res->status == NFS4_OK) { 2906 0 stevel sprintf(get_line(0, 0), "Link = %s", 2907 0 stevel linktext_name(&res->READLINK4res_u.resok4.link)); 2908 0 stevel } 2909 0 stevel } 2910 0 stevel 2911 0 stevel static void 2912 0 stevel dtlres_remove(void *obj) 2913 0 stevel { 2914 0 stevel REMOVE4res *res = (REMOVE4res *)obj; 2915 0 stevel 2916 0 stevel dtl_nfsstat4(obj); 2917 0 stevel if (res->status == NFS4_OK) { 2918 0 stevel dtl_change_info("Change Information", 2919 0 stevel &res->REMOVE4res_u.resok4.cinfo); 2920 0 stevel } 2921 0 stevel } 2922 0 stevel 2923 0 stevel static void 2924 0 stevel dtlres_rename(void *obj) 2925 0 stevel { 2926 0 stevel RENAME4res *res = (RENAME4res *)obj; 2927 0 stevel 2928 0 stevel dtl_nfsstat4(obj); 2929 0 stevel if (res->status == NFS4_OK) { 2930 0 stevel dtl_change_info("Source Change Information", 2931 0 stevel &res->RENAME4res_u.resok4.source_cinfo); 2932 0 stevel dtl_change_info("Target Change Information", 2933 0 stevel &res->RENAME4res_u.resok4.target_cinfo); 2934 0 stevel } 2935 0 stevel } 2936 0 stevel 2937 0 stevel static void 2938 0 stevel sumres_secinfo(char *buf, size_t buflen, void *obj) 2939 0 stevel { 2940 0 stevel char *bp; 2941 0 stevel SECINFO4res *res = (SECINFO4res *)obj; 2942 0 stevel 2943 0 stevel strncpy(buf, status_name(res->status), buflen); 2944 0 stevel bp = buf + strlen(buf); 2945 0 stevel if (res->status == NFS4_OK) { 2946 0 stevel uint_t numinfo = res->SECINFO4res_u.resok4.SECINFO4resok_len; 2947 0 stevel secinfo4 *infop; 2948 0 stevel 2949 0 stevel for (infop = res->SECINFO4res_u.resok4.SECINFO4resok_val; 2950 0 stevel numinfo != 0; 2951 0