daemon_debug.h File Reference

#include <stdlib.h>

Include dependency graph for daemon_debug.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DEFAULT_DEBUG_LEVEL   1

Functions
void	set_debug_level (int level)
void	dprintf (int level, LPCSTR format,...)
void	eprintf (LPCSTR format,...)
void	print_windows_access_mask (int on, ACCESS_MASK m)
void	print_nfs_access_mask (int on, int m)
void	print_hexbuf_no_asci (int on, unsigned char *title, unsigned char *buf, int len)
void	print_hexbuf (int level, unsigned char *title, unsigned char *buf, int len)
void	print_create_attributes (int level, DWORD create_opts)
void	print_disposition (int level, DWORD disposition)
void	print_access_mask (int level, DWORD access_mask)
void	print_share_mode (int level, DWORD mode)
void	print_file_id_both_dir_info (int level, FILE_ID_BOTH_DIR_INFO *p)
void	print_opcode (int level, DWORD opcode)
const char *	opcode2string (DWORD opcode)
const char *	nfs_opnum_to_string (int opnum)
const char *	nfs_error_string (int status)
const char *	rpc_error_string (int status)
const char *	gssauth_string (int type)
void	print_condwait_status (int level, int status)
void	print_sr_status_flags (int level, int flags)
void	open_log_files ()
void	close_log_files ()
const char *	secflavorop2name (DWORD sec_flavor)
const char *	pnfs_error_string (enum pnfs_status status)
const char *	pnfs_layout_type_string (enum pnfs_layout_type type)
const char *	pnfs_iomode_string (enum pnfs_iomode iomode)
void	dprint_deviceid (int level, const char *title, const unsigned char *deviceid)
void	dprint_layout (int level, const struct __pnfs_file_layout *layout)
void	dprint_device (int level, const struct __pnfs_file_device *device)

Macro Definition Documentation

DEFAULT_DEBUG_LEVEL

#define DEFAULT_DEBUG_LEVEL   1

Definition at line 34 of file daemon_debug.h.

Function Documentation

close_log_files()

void close_log_files

(

)

Definition at line 59 of file daemon_debug.c.

{
    if (dlog_file) fclose(dlog_file);
    if (elog_file) fclose(elog_file);
}

Referenced by ServiceStart().

dprint_device()

void dprint_device	(	int	level,
		const struct __pnfs_file_device *	device
	)

Referenced by pnfs_file_device_get().

dprint_deviceid()

void dprint_deviceid	(	int	level,
		const char *	title,
		const unsigned char *	deviceid
	)

dprint_layout()

void dprint_layout	(	int	level,
		const struct __pnfs_file_layout *	layout
	)

Referenced by layout_update_range().

dprintf()

void dprintf	(	int	level,
		LPCSTR	format,
			...
	)

Definition at line 72 of file daemon_debug.c.

{
    if (level <= g_debug_level) {
        va_list args;
        va_start(args, format);
        fprintf(dlog_file, "%04x: ", GetCurrentThreadId());
        vfprintf(dlog_file, format, args);
#ifndef STANDALONE_NFSD
        fflush(dlog_file);
#endif
        va_end(args);
    }
}

eprintf()

void eprintf	(	LPCSTR	format,
			...
	)

Definition at line 86 of file daemon_debug.c.

{
    va_list args;
    va_start(args, format);
    fprintf(elog_file, "%04x: ", GetCurrentThreadId());
    vfprintf(elog_file, format, args);
#ifndef STANDALONE_NFSD
    fflush(elog_file);
#endif
    va_end(args);
}

Referenced by abs_path_link(), check_execute_access(), check_for_files(), compound_encode_send_decode(), config_defaults(), config_init(), config_load(), config_parse_pair(), convert_nfs4acl_2_dacl(), create_new_rpc_auth(), create_rpcsec_auth_client(), create_silly_rename(), create_unknownsid(), decode_layout(), decode_op_want_delegation(), decode_open_res_ok(), decode_space_limit4(), delegation_return(), encode_file_attrs(), encode_op_layoutreturn(), encode_open_claim4(), file_layout_read_thread(), file_layout_return(), file_layout_write_thread(), get_dense_fh(), get_ea_value(), get_sparse_fh(), get_superblock_attrs(), get_volume_size_info(), getdomainname(), handle_cb_compound(), handle_cb_sequence(), handle_getacl(), handle_getattr(), handle_mount(), handle_open(), handle_setacl(), handle_setattr(), handle_symlink(), handle_volume(), hash_mac_addrs(), idmap_filter(), idmap_lookup_group(), idmap_lookup_user(), idmap_query_attrs(), layout_update(), map_dacl_2_nfs4acl(), map_name_2_sid(), map_nfs4ace_who(), map_user_to_ids(), marshall_getattr(), mds_commit(), nfs41_cached_getattr(), nfs41_client_create(), nfs41_client_owner(), nfs41_client_renew(), nfs41_create_session(), nfs41_delegation_recall(), nfs41_delegation_to_open(), nfs41_destroy_session(), nfs41_ea_set(), nfs41_handle_callback(), nfs41_idmap_create(), nfs41_idmap_gid_to_group(), nfs41_idmap_uid_to_name(), nfs41_lookup(), nfs41_read(), nfs41_recover_session(), nfs41_recover_stateid(), nfs41_root_create(), nfs41_root_mount_addrs(), nfs41_rpc_clnt_create(), nfs41_send_compound(), nfs41_session_bad_slot(), nfs41_session_create(), nfs41_session_free(), nfs41_session_set_lease(), nfs41_symlink_target(), nfs41_write(), nfs_decode_compound(), nfs_to_windows_error(), pattern_fork(), pnfs_file_device_get(), pnfs_layout_state_close(), pnfs_read(), pnfs_write(), readdir_copy_entry(), readdir_size_for_entry(), recover_delegation_open(), recover_delegation_want(), recover_open(), referral_resolve(), replay_cache_read(), root_client_create(), rpc_reconnect(), server_create(), ServiceStart(), session_get_lease(), set_ea_value(), superblock_create(), thread_main(), unexpected_op(), upcall_handle(), upcall_parse(), xdr_bitmap4(), xdr_channel_attrs4(), xdr_layout_types(), xdr_locker4(), xdr_state_protect4_a(), and xdr_state_protect4_r().

gssauth_string()

const char * gssauth_string

(

int

type

)

Definition at line 504 of file daemon_debug.c.

                                     {
    switch(type) {
    case RPCSEC_SSPI_SVC_NONE: return "RPCSEC_SSPI_SVC_NONE";
    case RPCSEC_SSPI_SVC_INTEGRITY: return "RPCSEC_SSPI_SVC_INTEGRITY";
    case RPCSEC_SSPI_SVC_PRIVACY: return "RPCSEC_SSPI_SVC_PRIVACY";
    default: return "invalid gss auth type";
    }
}

Referenced by create_new_rpc_auth().

nfs_error_string()

const char * nfs_error_string

(

int

status

)

Definition at line 370 of file daemon_debug.c.

{
    switch (status)
    {
    case NFS4_OK: return "NFS4_OK";
    case NFS4ERR_PERM: return "NFS4ERR_PERM";
    case NFS4ERR_NOENT: return "NFS4ERR_NOENT";
    case NFS4ERR_IO: return "NFS4ERR_IO";
    case NFS4ERR_NXIO: return "NFS4ERR_NXIO";
    case NFS4ERR_ACCESS: return "NFS4ERR_ACCESS";
    case NFS4ERR_EXIST: return "NFS4ERR_EXIST";
    case NFS4ERR_XDEV: return "NFS4ERR_XDEV";
    case NFS4ERR_NOTDIR: return "NFS4ERR_NOTDIR";
    case NFS4ERR_ISDIR: return "NFS4ERR_ISDIR";
    case NFS4ERR_INVAL: return "NFS4ERR_INVAL";
    case NFS4ERR_FBIG: return "NFS4ERR_FBIG";
    case NFS4ERR_NOSPC: return "NFS4ERR_NOSPC";
    case NFS4ERR_ROFS: return "NFS4ERR_ROFS";
    case NFS4ERR_MLINK: return "NFS4ERR_MLINK";
    case NFS4ERR_NAMETOOLONG: return "NFS4ERR_NAMETOOLONG";
    case NFS4ERR_NOTEMPTY: return "NFS4ERR_NOTEMPTY";
    case NFS4ERR_DQUOT: return "NFS4ERR_DQUOT";
    case NFS4ERR_STALE: return "NFS4ERR_STALE";
    case NFS4ERR_BADHANDLE: return "NFS4ERR_BADHANDLE";
    case NFS4ERR_BAD_COOKIE: return "NFS4ERR_BAD_COOKIE";
    case NFS4ERR_NOTSUPP: return "NFS4ERR_NOTSUPP";
    case NFS4ERR_TOOSMALL: return "NFS4ERR_TOOSMALL";
    case NFS4ERR_SERVERFAULT: return "NFS4ERR_SERVERFAULT";
    case NFS4ERR_BADTYPE: return "NFS4ERR_BADTYPE";
    case NFS4ERR_DELAY: return "NFS4ERR_DELAY";
    case NFS4ERR_SAME: return "NFS4ERR_SAME";
    case NFS4ERR_DENIED: return "NFS4ERR_DENIED";
    case NFS4ERR_EXPIRED: return "NFS4ERR_EXPIRED";
    case NFS4ERR_LOCKED: return "NFS4ERR_LOCKED";
    case NFS4ERR_GRACE: return "NFS4ERR_GRACE";
    case NFS4ERR_FHEXPIRED: return "NFS4ERR_FHEXPIRED";
    case NFS4ERR_SHARE_DENIED: return "NFS4ERR_SHARE_DENIED";
    case NFS4ERR_WRONGSEC: return "NFS4ERR_WRONGSEC";
    case NFS4ERR_CLID_INUSE: return "NFS4ERR_CLID_INUSE";
    case NFS4ERR_RESOURCE: return "NFS4ERR_RESOURCE";
    case NFS4ERR_MOVED: return "NFS4ERR_MOVED";
    case NFS4ERR_NOFILEHANDLE: return "NFS4ERR_NOFILEHANDLE";
    case NFS4ERR_MINOR_VERS_MISMATCH: return "NFS4ERR_MINOR_VERS_MISMATCH";
    case NFS4ERR_STALE_CLIENTID: return "NFS4ERR_STALE_CLIENTID";
    case NFS4ERR_STALE_STATEID: return "NFS4ERR_STALE_STATEID";
    case NFS4ERR_OLD_STATEID: return "NFS4ERR_OLD_STATEID";
    case NFS4ERR_BAD_STATEID: return "NFS4ERR_BAD_STATEID";
    case NFS4ERR_BAD_SEQID: return "NFS4ERR_BAD_SEQID";
    case NFS4ERR_NOT_SAME: return "NFS4ERR_NOT_SAME";
    case NFS4ERR_LOCK_RANGE: return "NFS4ERR_LOCK_RANGE";
    case NFS4ERR_SYMLINK: return "NFS4ERR_SYMLINK";
    case NFS4ERR_RESTOREFH: return "NFS4ERR_RESTOREFH";
    case NFS4ERR_LEASE_MOVED: return "NFS4ERR_LEASE_MOVED";
    case NFS4ERR_ATTRNOTSUPP: return "NFS4ERR_ATTRNOTSUPP";
    case NFS4ERR_NO_GRACE: return "NFS4ERR_NO_GRACE";
    case NFS4ERR_RECLAIM_BAD: return "NFS4ERR_RECLAIM_BAD";
    case NFS4ERR_RECLAIM_CONFLICT: return "NFS4ERR_RECLAIM_CONFLICT";
    case NFS4ERR_BADXDR: return "NFS4ERR_BADXDR";
    case NFS4ERR_LOCKS_HELD: return "NFS4ERR_LOCKS_HELD";
    case NFS4ERR_OPENMODE: return "NFS4ERR_OPENMODE";
    case NFS4ERR_BADOWNER: return "NFS4ERR_BADOWNER";
    case NFS4ERR_BADCHAR: return "NFS4ERR_BADCHAR";
    case NFS4ERR_BADNAME: return "NFS4ERR_BADNAME";
    case NFS4ERR_BAD_RANGE: return "NFS4ERR_BAD_RANGE";
    case NFS4ERR_LOCK_NOTSUPP: return "NFS4ERR_LOCK_NOTSUPP";
    case NFS4ERR_OP_ILLEGAL: return "NFS4ERR_OP_ILLEGAL";
    case NFS4ERR_DEADLOCK: return "NFS4ERR_DEADLOCK";
    case NFS4ERR_FILE_OPEN: return "NFS4ERR_FILE_OPEN";
    case NFS4ERR_ADMIN_REVOKED: return "NFS4ERR_ADMIN_REVOKED";
    case NFS4ERR_CB_PATH_DOWN: return "NFS4ERR_CB_PATH_DOWN";
    case NFS4ERR_BADIOMODE: return "NFS4ERR_BADIOMODE";
    case NFS4ERR_BADLAYOUT: return "NFS4ERR_BADLAYOUT";
    case NFS4ERR_BAD_SESSION_DIGEST: return "NFS4ERR_BAD_SESSION_DIGEST";
    case NFS4ERR_BADSESSION: return "NFS4ERR_BADSESSION";
    case NFS4ERR_BADSLOT: return "NFS4ERR_BADSLOT";
    case NFS4ERR_COMPLETE_ALREADY: return "NFS4ERR_COMPLETE_ALREADY";
    case NFS4ERR_CONN_NOT_BOUND_TO_SESSION: return "NFS4ERR_CONN_NOT_BOUND_TO_SESSION";
    case NFS4ERR_DELEG_ALREADY_WANTED: return "NFS4ERR_DELEG_ALREADY_WANTED";
    case NFS4ERR_BACK_CHAN_BUSY: return "NFS4ERR_BACK_CHAN_BUSY";
    case NFS4ERR_LAYOUTTRYLATER: return "NFS4ERR_LAYOUTTRYLATER";
    case NFS4ERR_LAYOUTUNAVAILABLE: return "NFS4ERR_LAYOUTUNAVAILABLE";
    case NFS4ERR_NOMATCHING_LAYOUT: return "NFS4ERR_NOMATCHING_LAYOUT";
    case NFS4ERR_RECALLCONFLICT: return "NFS4ERR_RECALLCONFLICT";
    case NFS4ERR_UNKNOWN_LAYOUTTYPE: return "NFS4ERR_UNKNOWN_LAYOUTTYPE";
    case NFS4ERR_SEQ_MISORDERED: return "NFS4ERR_SEQ_MISORDERED";
    case NFS4ERR_SEQUENCE_POS: return "NFS4ERR_SEQUENCE_POS";
    case NFS4ERR_REQ_TOO_BIG: return "NFS4ERR_REQ_TOO_BIG";
    case NFS4ERR_REP_TOO_BIG: return "NFS4ERR_REP_TOO_BIG";
    case NFS4ERR_REP_TOO_BIG_TO_CACHE: return "NFS4ERR_REP_TOO_BIG_TO_CACHE";
    case NFS4ERR_RETRY_UNCACHED_REP: return "NFS4ERR_RETRY_UNCACHED_REP";
    case NFS4ERR_UNSAFE_COMPOUND: return "NFS4ERR_UNSAFE_COMPOUND";
    case NFS4ERR_TOO_MANY_OPS: return "NFS4ERR_TOO_MANY_OPS";
    case NFS4ERR_OP_NOT_IN_SESSION: return "NFS4ERR_OP_NOT_IN_SESSION";
    case NFS4ERR_HASH_ALG_UNSUPP: return "NFS4ERR_HASH_ALG_UNSUPP";
    case NFS4ERR_CLIENTID_BUSY: return "NFS4ERR_CLIENTID_BUSY";
    case NFS4ERR_PNFS_IO_HOLE: return "NFS4ERR_PNFS_IO_HOLE";
    case NFS4ERR_SEQ_FALSE_RETRY: return "NFS4ERR_SEQ_FALSE_RETRY";
    case NFS4ERR_BAD_HIGH_SLOT: return "NFS4ERR_BAD_HIGH_SLOT";
    case NFS4ERR_DEADSESSION: return "NFS4ERR_DEADSESSION";
    case NFS4ERR_ENCR_ALG_UNSUPP: return "NFS4ERR_ENCR_ALG_UNSUPP";
    case NFS4ERR_PNFS_NO_LAYOUT: return "NFS4ERR_PNFS_NO_LAYOUT";
    case NFS4ERR_NOT_ONLY_OP: return "NFS4ERR_NOT_ONLY_OP";
    case NFS4ERR_WRONG_CRED: return "NFS4ERR_WRONG_CRED";
    case NFS4ERR_WRONG_TYPE: return "NFS4ERR_WRONG_TYPE";
    case NFS4ERR_DIRDELEG_UNAVAIL: return "NFS4ERR_DIRDELEG_UNAVAIL";
    case NFS4ERR_REJECT_DELEG: return "NFS4ERR_REJECT_DELEG";
    case NFS4ERR_RETURNCONFLICT: return "NFS4ERR_RETURNCONFLICT";
    case NFS4ERR_DELEG_REVOKED: return "NFS4ERR_DELEG_REVOKED";
    default: return "invalid nfs error code";
    }
}

Referenced by cancel_open(), check_execute_access(), compound_encode_send_decode(), do_nfs41_close(), file_layout_fetch(), file_layout_read_thread(), file_layout_return(), file_layout_write_thread(), get_ea_value(), get_superblock_attrs(), get_volume_size_info(), handle_cb_compound(), handle_cb_layoutrecall(), handle_cb_recall_slot(), handle_cb_sequence(), handle_close(), handle_lock(), handle_nfs41_remove(), handle_nfs41_set_size(), handle_open(), handle_readdir(), handle_setacl(), handle_setexattr(), handle_symlink(), layout_commit(), mds_commit(), nfs41_cached_getattr(), nfs41_delegation_getattr(), nfs41_delegation_recall(), nfs41_delegation_to_open(), nfs41_ea_set(), nfs41_read(), nfs41_root_mount_addrs(), nfs41_symlink_target(), nfs41_write(), nfs_to_windows_error(), pnfs_file_device_get(), referral_resolve(), root_client_create(), rpc_reconnect(), session_get_lease(), and set_ea_value().

nfs_opnum_to_string()

const char * nfs_opnum_to_string

(

int

opnum

)

Definition at line 305 of file daemon_debug.c.

{
    switch (opnum)
    {
    case OP_ACCESS: return "ACCESS";
    case OP_CLOSE: return "CLOSE";
    case OP_COMMIT: return "COMMIT";
    case OP_CREATE: return "CREATE";
    case OP_DELEGPURGE: return "DELEGPURGE";
    case OP_DELEGRETURN: return "DELEGRETURN";
    case OP_GETATTR: return "GETATTR";
    case OP_GETFH: return "GETFH";
    case OP_LINK: return "LINK";
    case OP_LOCK: return "LOCK";
    case OP_LOCKT: return "LOCKT";
    case OP_LOCKU: return "LOCKU";
    case OP_LOOKUP: return "LOOKUP";
    case OP_LOOKUPP: return "LOOKUPP";
    case OP_NVERIFY: return "NVERIFY";
    case OP_OPEN: return "OPEN";
    case OP_OPENATTR: return "OPENATTR";
    case OP_OPEN_CONFIRM: return "OPEN_CONFIRM";
    case OP_OPEN_DOWNGRADE: return "OPEN_DOWNGRADE";
    case OP_PUTFH: return "PUTFH";
    case OP_PUTPUBFH: return "PUTPUBFH";
    case OP_PUTROOTFH: return "PUTROOTFH";
    case OP_READ: return "READ";
    case OP_READDIR: return "READDIR";
    case OP_READLINK: return "READLINK";
    case OP_REMOVE: return "REMOVE";
    case OP_RENAME: return "RENAME";
    case OP_RENEW: return "RENEW";
    case OP_RESTOREFH: return "RESTOREFH";
    case OP_SAVEFH: return "SAVEFH";
    case OP_SECINFO: return "SECINFO";
    case OP_SETATTR: return "SETATTR";
    case OP_SETCLIENTID: return "SETCLIENTID";
    case OP_SETCLIENTID_CONFIRM: return "SETCLIENTID_CONFIRM";
    case OP_VERIFY: return "VERIFY";
    case OP_WRITE: return "WRITE";
    case OP_RELEASE_LOCKOWNER: return "RELEASE_LOCKOWNER";
    case OP_BACKCHANNEL_CTL: return "BACKCHANNEL_CTL";
    case OP_BIND_CONN_TO_SESSION: return "BIND_CONN_TO_SESSION";
    case OP_EXCHANGE_ID: return "EXCHANGE_ID";
    case OP_CREATE_SESSION: return "CREATE_SESSION";
    case OP_DESTROY_SESSION: return "DESTROY_SESSION";
    case OP_FREE_STATEID: return "FREE_STATEID";
    case OP_GET_DIR_DELEGATION: return "GET_DIR_DELEGATION";
    case OP_GETDEVICEINFO: return "GETDEVICEINFO";
    case OP_GETDEVICELIST: return "GETDEVICELIST";
    case OP_LAYOUTCOMMIT: return "LAYOUTCOMMIT";
    case OP_LAYOUTGET: return "LAYOUTGET";
    case OP_LAYOUTRETURN: return "LAYOUTRETURN";
    case OP_SECINFO_NO_NAME: return "SECINFO_NO_NAME";
    case OP_SEQUENCE: return "SEQUENCE";
    case OP_SET_SSV: return "SET_SSV";
    case OP_TEST_STATEID: return "TEST_STATEID";
    case OP_WANT_DELEGATION: return "WANT_DELEGATION";
    case OP_DESTROY_CLIENTID: return "DESTROY_CLIENTID";
    case OP_RECLAIM_COMPLETE: return "RECLAIM_COMPLETE";
    case OP_ILLEGAL: return "ILLEGAL";
    default: return "invalid nfs opnum";
    }
}

Referenced by nfs41_destroy_session(), nfs41_recover_stateid(), nfs_decode_compound(), and unexpected_op().

opcode2string()

const char * opcode2string

(

DWORD

opcode

)

Definition at line 280 of file daemon_debug.c.

{
    switch(opcode) {
    case NFS41_SHUTDOWN:    return "NFS41_SHUTDOWN";
    case NFS41_MOUNT:       return "NFS41_MOUNT";
    case NFS41_UNMOUNT:     return "NFS41_UNMOUNT";
    case NFS41_OPEN:        return "NFS41_OPEN";
    case NFS41_CLOSE:       return "NFS41_CLOSE";
    case NFS41_READ:        return "NFS41_READ";
    case NFS41_WRITE:       return "NFS41_WRITE";
    case NFS41_LOCK:        return "NFS41_LOCK";
    case NFS41_UNLOCK:      return "NFS41_UNLOCK";
    case NFS41_DIR_QUERY:   return "NFS41_DIR_QUERY";
    case NFS41_FILE_QUERY:  return "NFS41_FILE_QUERY";
    case NFS41_FILE_SET:    return "NFS41_FILE_SET";
    case NFS41_EA_SET:      return "NFS41_EA_SET";
    case NFS41_EA_GET:      return "NFS41_EA_GET";
    case NFS41_SYMLINK:     return "NFS41_SYMLINK";
    case NFS41_VOLUME_QUERY: return "NFS41_VOLUME_QUERY";
    case NFS41_ACL_QUERY:   return "NFS41_ACL_QUERY";
    case NFS41_ACL_SET:     return "NFS41_ACL_SET";
    default:                return "UNKNOWN";
    }
}

Referenced by marshal_nfs41_header(), nfs41_UpcallWaitForReply(), parse_rw(), print_opcode(), thread_main(), unmarshal_nfs41_header(), upcall_handle(), and upcall_parse().

open_log_files()

void open_log_files

(

)

Definition at line 40 of file daemon_debug.c.

{
    const char dfile[] = "nfsddbg.log";
    const char efile[] = "nfsderr.log";
    const char mode[] = "w";
    if (g_debug_level > 0) {
        dlog_file = fopen(dfile, mode);
        if (dlog_file == NULL) {
            ReportStatusToSCMgr(SERVICE_STOPPED, GetLastError(), 0);
            exit (GetLastError());
        }
    }
    elog_file = fopen(efile, mode);
    if (elog_file == NULL) {
        ReportStatusToSCMgr(SERVICE_STOPPED, GetLastError(), 0);
        exit (GetLastError());
    }
}

Referenced by ServiceStart().

pnfs_error_string()

const char * pnfs_error_string

(

enum pnfs_status

status

)

Definition at line 28 of file pnfs_debug.c.

{
    switch (status) {
    case PNFS_SUCCESS:          return "PNFS_SUCCESS";
    case PNFS_PENDING:          return "PNFS_PENDING";
    case PNFS_READ_EOF:         return "PNFS_READ_EOF";
    case PNFSERR_NOT_SUPPORTED: return "PNFSERR_NOT_SUPPORTED";
    case PNFSERR_NOT_CONNECTED: return "PNFSERR_NOT_CONNECTED";
    case PNFSERR_IO:            return "PNFSERR_IO";
    case PNFSERR_NO_DEVICE:     return "PNFSERR_NO_DEVICE";
    case PNFSERR_NO_LAYOUT:     return "PNFSERR_NO_LAYOUT";
    case PNFSERR_INVALID_FH_LIST: return "PNFSERR_INVALID_FH_LIST";
    case PNFSERR_INVALID_DS_INDEX: return "PNFSERR_INVALID_DS_INDEX";
    case PNFSERR_RESOURCES:     return "PNFSERR_RESOURCES";
    case PNFSERR_LAYOUT_RECALLED: return "PNFSERR_LAYOUT_RECALLED";
    case PNFSERR_LAYOUT_CHANGED: return "PNFSERR_LAYOUT_CHANGED";
    default:                    return "Invalid pnfs status";
    }
}

Referenced by file_device_find_or_create(), file_layout_fetch(), file_layout_read_thread(), file_layout_recall_all(), file_layout_recall_file(), file_layout_recall_fsid(), file_layout_return(), file_layout_write_thread(), layout_state_find_and_delete(), layout_state_find_or_create(), pattern_fork(), pnfs_file_device_get(), pnfs_file_device_notify(), pnfs_file_layout_recall(), pnfs_layout_state_close(), pnfs_layout_state_open(), pnfs_read(), and pnfs_write().

pnfs_iomode_string()

const char * pnfs_iomode_string

(

enum pnfs_iomode

iomode

)

Definition at line 58 of file pnfs_debug.c.

{
    switch (iomode) {
    case PNFS_IOMODE_READ:      return "PNFS_IOMODE_READ";
    case PNFS_IOMODE_RW:        return "PNFS_IOMODE_RW";
    case PNFS_IOMODE_ANY:       return "PNFS_IOMODE_ANY";
    default:                    return "Invalid io mode";
    }
}

Referenced by dprint_layout(), file_layout_fetch(), handle_cb_layoutrecall(), and pnfs_file_layout_recall().

pnfs_layout_type_string()

const char * pnfs_layout_type_string

(

enum pnfs_layout_type

type

)

Definition at line 48 of file pnfs_debug.c.

{
    switch (type) {
    case PNFS_LAYOUTTYPE_FILE:  return "PNFS_LAYOUTTYPE_FILE";
    case PNFS_LAYOUTTYPE_OBJECT: return "PNFS_LAYOUTTYPE_OBJECT";
    case PNFS_LAYOUTTYPE_BLOCK: return "PNFS_LAYOUTTYPE_BLOCK";
    default:                    return "Invalid layout type";
    }
}

Referenced by dprint_device(), dprint_layout(), handle_cb_layoutrecall(), and pnfs_file_layout_recall().

print_access_mask()

void print_access_mask	(	int	level,
		DWORD	access_mask
	)

Definition at line 181 of file daemon_debug.c.

                                                     {
    if (level > g_debug_level) return;
    fprintf(dlog_file, "access mask: ");
    if (access_mask & FILE_READ_DATA)
        fprintf(dlog_file, "READ ");
    if (access_mask & STANDARD_RIGHTS_READ)
        fprintf(dlog_file, "READ_ACL ");
    if (access_mask & FILE_READ_ATTRIBUTES)
        fprintf(dlog_file, "READ_ATTR ");
    if (access_mask & FILE_READ_EA)
        fprintf(dlog_file, "READ_EA ");
    if (access_mask & FILE_WRITE_DATA)
        fprintf(dlog_file, "WRITE ");
    if (access_mask & STANDARD_RIGHTS_WRITE)
        fprintf(dlog_file, "WRITE_ACL ");
    if (access_mask & FILE_WRITE_ATTRIBUTES)
        fprintf(dlog_file, "WRITE_ATTR ");
    if (access_mask & FILE_WRITE_EA)
        fprintf(dlog_file, "WRITE_EA ");
    if (access_mask & FILE_APPEND_DATA)
        fprintf(dlog_file, "APPEND ");
    if (access_mask & FILE_EXECUTE)
        fprintf(dlog_file, "EXECUTE ");
    if (access_mask & FILE_LIST_DIRECTORY)
        fprintf(dlog_file, "LIST ");
    if (access_mask & FILE_TRAVERSE)
        fprintf(dlog_file, "TRAVERSE ");
    if (access_mask & SYNCHRONIZE)
        fprintf(dlog_file, "SYNC ");
    if (access_mask & FILE_DELETE_CHILD)
        fprintf(dlog_file, "DELETE_CHILD");
    fprintf(dlog_file, "\n");
}

Referenced by parse_open().

print_condwait_status()

void print_condwait_status	(	int	level,
		int	status
	)

Definition at line 513 of file daemon_debug.c.

{
    if (level > g_debug_level) return;
    switch(status) {
        case WAIT_ABANDONED: fprintf(dlog_file, "WAIT_ABANDONED\n"); break;
        case WAIT_OBJECT_0: fprintf(dlog_file, "WAIT_OBJECT_0\n"); break;
        case WAIT_TIMEOUT: fprintf(dlog_file, "WAIT_TIMEOUT\n"); break;
        case WAIT_FAILED: fprintf(dlog_file, "WAIT_FAILED %d\n", GetLastError());
        default: fprintf(dlog_file, "unknown status =%d\n", status);
    }
}

Referenced by nfs41_send_compound().

print_create_attributes()

void print_create_attributes	(	int	level,
		DWORD	create_opts
	)

Definition at line 126 of file daemon_debug.c.

                                                           {
    if (level > g_debug_level) return;
    fprintf(dlog_file, "create attributes: ");
    if (create_opts & FILE_DIRECTORY_FILE)
        fprintf(dlog_file, "DIRECTORY_FILE ");
    if (create_opts & FILE_NON_DIRECTORY_FILE)
        fprintf(dlog_file, "NON_DIRECTORY_FILE ");
    if (create_opts & FILE_WRITE_THROUGH)
        fprintf(dlog_file, "WRITE_THROUGH ");
    if (create_opts & FILE_SEQUENTIAL_ONLY)
        fprintf(dlog_file, "SEQUENTIAL_ONLY ");
    if (create_opts & FILE_RANDOM_ACCESS)
        fprintf(dlog_file, "RANDOM_ACCESS ");
    if (create_opts & FILE_NO_INTERMEDIATE_BUFFERING)
        fprintf(dlog_file, "NO_INTERMEDIATE_BUFFERING ");
    if (create_opts & FILE_SYNCHRONOUS_IO_ALERT)
        fprintf(dlog_file, "SYNCHRONOUS_IO_ALERT ");
    if (create_opts & FILE_SYNCHRONOUS_IO_NONALERT)
        fprintf(dlog_file, "SYNCHRONOUS_IO_NONALERT ");
    if (create_opts & FILE_CREATE_TREE_CONNECTION)
        fprintf(dlog_file, "CREATE_TREE_CONNECTION ");
    if (create_opts & FILE_COMPLETE_IF_OPLOCKED)
        fprintf(dlog_file, "COMPLETE_IF_OPLOCKED ");
    if (create_opts & FILE_NO_EA_KNOWLEDGE)
        fprintf(dlog_file, "NO_EA_KNOWLEDGE ");
    if (create_opts & FILE_OPEN_REPARSE_POINT)
        fprintf(dlog_file, "OPEN_REPARSE_POINT ");
    if (create_opts & FILE_DELETE_ON_CLOSE)
        fprintf(dlog_file, "DELETE_ON_CLOSE ");
    if (create_opts & FILE_OPEN_BY_FILE_ID)
        fprintf(dlog_file, "OPEN_BY_FILE_ID ");
    if (create_opts & FILE_OPEN_FOR_BACKUP_INTENT)
        fprintf(dlog_file, "OPEN_FOR_BACKUP_INTENT ");
    if (create_opts & FILE_RESERVE_OPFILTER)
        fprintf(dlog_file, "RESERVE_OPFILTER");
    fprintf(dlog_file, "\n");
}

Referenced by parse_open().

print_disposition()

void print_disposition	(	int	level,
		DWORD	disposition
	)

Definition at line 164 of file daemon_debug.c.

                                                     {
    if (level > g_debug_level) return;
    fprintf(dlog_file, "userland disposition = ");
    if (disposition == FILE_SUPERSEDE)
        fprintf(dlog_file, "FILE_SUPERSEDE\n");
    else if (disposition == FILE_CREATE)
        fprintf(dlog_file, "FILE_CREATE\n");
    else if (disposition == FILE_OPEN)
        fprintf(dlog_file, "FILE_OPEN\n");
    else if (disposition == FILE_OPEN_IF)
        fprintf(dlog_file, "FILE_OPEN_IF\n");
    else if (disposition == FILE_OVERWRITE)
        fprintf(dlog_file, "FILE_OVERWRITE\n");
    else if (disposition == FILE_OVERWRITE_IF)
        fprintf(dlog_file, "FILE_OVERWRITE_IF\n");
}

Referenced by parse_open().

print_file_id_both_dir_info()

void print_file_id_both_dir_info	(	int	level,
		FILE_ID_BOTH_DIR_INFO *	p
	)

Definition at line 228 of file daemon_debug.c.

{
    if (level > g_debug_level) return;
    fprintf(dlog_file, "FILE_ID_BOTH_DIR_INFO %p %d\n", 
       pboth_dir_info, sizeof(unsigned char *));
    fprintf(dlog_file, "\tNextEntryOffset=%ld %d %d\n", 
        pboth_dir_info->NextEntryOffset, 
        sizeof(pboth_dir_info->NextEntryOffset), sizeof(DWORD));
    fprintf(dlog_file, "\tFileIndex=%ld  %d\n", pboth_dir_info->FileIndex, 
        sizeof(pboth_dir_info->FileIndex));
    fprintf(dlog_file, "\tCreationTime=0x%x %d\n", 
        pboth_dir_info->CreationTime.QuadPart, 
        sizeof(pboth_dir_info->CreationTime));
    fprintf(dlog_file, "\tLastAccessTime=0x%x %d\n", 
        pboth_dir_info->LastAccessTime.QuadPart, 
        sizeof(pboth_dir_info->LastAccessTime));
    fprintf(dlog_file, "\tLastWriteTime=0x%x %d\n", 
        pboth_dir_info->LastWriteTime.QuadPart, 
        sizeof(pboth_dir_info->LastWriteTime));
    fprintf(dlog_file, "\tChangeTime=0x%x %d\n", 
        pboth_dir_info->ChangeTime.QuadPart, 
        sizeof(pboth_dir_info->ChangeTime));
    fprintf(dlog_file, "\tEndOfFile=0x%x %d\n", 
        pboth_dir_info->EndOfFile.QuadPart, 
        sizeof(pboth_dir_info->EndOfFile));
    fprintf(dlog_file, "\tAllocationSize=0x%x %d\n", 
        pboth_dir_info->AllocationSize.QuadPart, 
        sizeof(pboth_dir_info->AllocationSize));
    fprintf(dlog_file, "\tFileAttributes=%ld %d\n", 
        pboth_dir_info->FileAttributes, 
        sizeof(pboth_dir_info->FileAttributes));
    fprintf(dlog_file, "\tFileNameLength=%ld %d\n", 
        pboth_dir_info->FileNameLength, 
        sizeof(pboth_dir_info->FileNameLength));
    fprintf(dlog_file, "\tEaSize=%ld %d\n", 
        pboth_dir_info->EaSize, sizeof(pboth_dir_info->EaSize));
    fprintf(dlog_file, "\tShortNameLength=%d %d\n", 
        pboth_dir_info->ShortNameLength, 
        sizeof(pboth_dir_info->ShortNameLength));
    fprintf(dlog_file, "\tShortName='%S' %d\n", pboth_dir_info->ShortName, 
        sizeof(pboth_dir_info->ShortName));
    fprintf(dlog_file, "\tFileId=0x%x %d\n", pboth_dir_info->FileId.QuadPart, 
        sizeof(pboth_dir_info->FileId));
    fprintf(dlog_file, "\tFileName='%S' %p\n", pboth_dir_info->FileName, 
        pboth_dir_info->FileName);
}

print_hexbuf()

void print_hexbuf	(	int	level,
		unsigned char *	title,
		unsigned char *	buf,
		int	len
	)

Definition at line 98 of file daemon_debug.c.

{
    int j, k;
    if (level > g_debug_level) return;
    fprintf(dlog_file, "%s", title);
    for(j = 0, k = 0; j < len; j++, k++) {
        fprintf(dlog_file, "%02x '%c' ", buf[j], isascii(buf[j])? buf[j]:' ');
        if (((k+1) % 10 == 0 && k > 0)) {
            fprintf(dlog_file, "\n");
        }
    }
    fprintf(dlog_file, "\n");
}

print_hexbuf_no_asci()

void print_hexbuf_no_asci	(	int	on,
		unsigned char *	title,
		unsigned char *	buf,
		int	len
	)

Definition at line 112 of file daemon_debug.c.

{
    int j, k;
    if (level > g_debug_level) return;
    fprintf(dlog_file, "%s", title);
    for(j = 0, k = 0; j < len; j++, k++) {
        fprintf(dlog_file, "%02x ", buf[j]);
        if (((k+1) % 10 == 0 && k > 0)) {
            fprintf(dlog_file, "\n");
        }
    }
    fprintf(dlog_file, "\n");
}

Referenced by map_dacl_2_nfs4acl().

print_nfs_access_mask()

void print_nfs_access_mask	(	int	on,
		int	m
	)

Definition at line 640 of file daemon_debug.c.

{
    if (!on) return;
    dprintf(1, "--> print_nfs_access_mask: %x\n", m);
    if (m & ACE4_READ_DATA)
        dprintf(1, "\tACE4_READ_DATA\n");
    if (m & ACE4_LIST_DIRECTORY)
        dprintf(1, "\tACE4_LIST_DIRECTORY\n");
    if (m & ACE4_WRITE_DATA)
        dprintf(1, "\tACE4_WRITE_DATA\n");
    if (m & ACE4_ADD_FILE)
        dprintf(1, "\tACE4_ADD_FILE\n");
    if (m & ACE4_APPEND_DATA)
        dprintf(1, "\tACE4_APPEND_DATA\n");
    if (m & ACE4_ADD_SUBDIRECTORY)
        dprintf(1, "\tACE4_ADD_SUBDIRECTORY\n");
    if (m & ACE4_READ_NAMED_ATTRS)
        dprintf(1, "\tACE4_READ_NAMED_ATTRS\n");
    if (m & ACE4_WRITE_NAMED_ATTRS)
        dprintf(1, "\tACE4_WRITE_NAMED_ATTRS\n");
    if (m & ACE4_EXECUTE)
        dprintf(1, "\tACE4_EXECUTE\n");
    if (m & ACE4_DELETE_CHILD)
        dprintf(1, "\tACE4_DELETE_CHILD\n");
    if (m & ACE4_READ_ATTRIBUTES)
        dprintf(1, "\tACE4_READ_ATTRIBUTES\n");
    if (m & ACE4_WRITE_ATTRIBUTES)
        dprintf(1, "\tACE4_WRITE_ATTRIBUTES\n");
    if (m & ACE4_DELETE)
        dprintf(1, "\tACE4_DELETE\n");
    if (m & ACE4_READ_ACL)
        dprintf(1, "\tACE4_READ_ACL\n");
    if (m & ACE4_WRITE_ACL)
        dprintf(1, "\tACE4_WRITE_ACL\n");
    if (m & ACE4_WRITE_OWNER)
        dprintf(1, "\tACE4_WRITE_OWNER\n");
    if (m & ACE4_SYNCHRONIZE)
        dprintf(1, "\tACE4_SYNCHRONIZE\n");
}

Referenced by map_acemask().

print_opcode()

void print_opcode	(	int	level,
		DWORD	opcode
	)

Definition at line 275 of file daemon_debug.c.

{
    dprintf(level, (LPCSTR)opcode2string(opcode));
}

print_share_mode()

void print_share_mode	(	int	level,
		DWORD	mode
	)

Definition at line 215 of file daemon_debug.c.

{
    if (level > g_debug_level) return;
    fprintf(dlog_file, "share mode: ");
    if (mode & FILE_SHARE_READ)
        fprintf(dlog_file, "READ ");
    if (mode & FILE_SHARE_WRITE)
        fprintf(dlog_file, "WRITE ");
    if (mode & FILE_SHARE_DELETE)
        fprintf(dlog_file, "DELETE");
    fprintf(dlog_file, "\n");
}

Referenced by parse_open().

print_sr_status_flags()

void print_sr_status_flags	(	int	level,
		int	flags
	)

Definition at line 525 of file daemon_debug.c.

{
    if (level > g_debug_level) return;
    fprintf(dlog_file, "%04x: sr_status_flags: ", GetCurrentThreadId());
    if (flags & SEQ4_STATUS_CB_PATH_DOWN) 
        fprintf(dlog_file, "SEQ4_STATUS_CB_PATH_DOWN ");
    if (flags & SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING) 
        fprintf(dlog_file, "SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRING ");
    if (flags & SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED) 
        fprintf(dlog_file, "SEQ4_STATUS_CB_GSS_CONTEXTS_EXPIRED ");
    if (flags & SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED) 
        fprintf(dlog_file, "SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED ");
    if (flags & SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED) 
        fprintf(dlog_file, "SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED ");
    if (flags & SEQ4_STATUS_ADMIN_STATE_REVOKED) 
        fprintf(dlog_file, "SEQ4_STATUS_ADMIN_STATE_REVOKED ");
    if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED) 
        fprintf(dlog_file, "SEQ4_STATUS_RECALLABLE_STATE_REVOKED ");
    if (flags & SEQ4_STATUS_LEASE_MOVED) 
        fprintf(dlog_file, "SEQ4_STATUS_LEASE_MOVED ");
    if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED) 
        fprintf(dlog_file, "SEQ4_STATUS_RESTART_RECLAIM_NEEDED ");
    if (flags & SEQ4_STATUS_CB_PATH_DOWN_SESSION) 
        fprintf(dlog_file, "SEQ4_STATUS_CB_PATH_DOWN_SESSION ");
    if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT) 
        fprintf(dlog_file, "SEQ4_STATUS_BACKCHANNEL_FAULT ");
    if (flags & SEQ4_STATUS_DEVID_CHANGED) 
        fprintf(dlog_file, "SEQ4_STATUS_DEVID_CHANGED ");
    if (flags & SEQ4_STATUS_DEVID_DELETED) 
        fprintf(dlog_file, "SEQ4_STATUS_DEVID_DELETED ");
    fprintf(dlog_file, "\n");
}

Referenced by compound_encode_send_decode().

print_windows_access_mask()

void print_windows_access_mask	(	int	on,
		ACCESS_MASK	m
	)

Definition at line 570 of file daemon_debug.c.

{
    if (!on) return;
    dprintf(1, "--> print_windows_access_mask: %x\n", m);
    if (m & GENERIC_READ)
        dprintf(1, "\tGENERIC_READ\n");
    if (m & GENERIC_WRITE)
        dprintf(1, "\tGENERIC_WRITE\n");
    if (m & GENERIC_EXECUTE)
        dprintf(1, "\tGENERIC_EXECUTE\n");
    if (m & GENERIC_ALL)
        dprintf(1, "\tGENERIC_ALL\n");
    if (m & MAXIMUM_ALLOWED)
        dprintf(1, "\tMAXIMUM_ALLOWED\n");
    if (m & ACCESS_SYSTEM_SECURITY)
        dprintf(1, "\tACCESS_SYSTEM_SECURITY\n");
    if ((m & SPECIFIC_RIGHTS_ALL) == SPECIFIC_RIGHTS_ALL)
        dprintf(1, "\tSPECIFIC_RIGHTS_ALL\n");
    if ((m & STANDARD_RIGHTS_ALL) == STANDARD_RIGHTS_ALL)
        dprintf(1, "\tSTANDARD_RIGHTS_ALL\n");
    if ((m & STANDARD_RIGHTS_REQUIRED) == STANDARD_RIGHTS_REQUIRED)
        dprintf(1, "\tSTANDARD_RIGHTS_REQUIRED\n");
    if (m & SYNCHRONIZE)
        dprintf(1, "\tSYNCHRONIZE\n");
    if (m & WRITE_OWNER)
        dprintf(1, "\tWRITE_OWNER\n");
    if (m & WRITE_DAC)
        dprintf(1, "\tWRITE_DAC\n");
    if (m & READ_CONTROL)
        dprintf(1, "\tREAD_CONTROL\n");
    if (m & DELETE)
        dprintf(1, "\tDELETE\n");
    if (m & FILE_READ_DATA)
        dprintf(1, "\tFILE_READ_DATA\n");
    if (m & FILE_LIST_DIRECTORY)
        dprintf(1, "\tFILE_LIST_DIRECTORY\n");
    if (m & FILE_WRITE_DATA)
        dprintf(1, "\tFILE_WRITE_DATA\n");
    if (m & FILE_ADD_FILE)
        dprintf(1, "\tFILE_ADD_FILE\n");
    if (m & FILE_APPEND_DATA)
        dprintf(1, "\tFILE_APPEND_DATA\n");
    if (m & FILE_ADD_SUBDIRECTORY)
        dprintf(1, "\tFILE_ADD_SUBDIRECTORY\n");
    if (m & FILE_CREATE_PIPE_INSTANCE)
        dprintf(1, "\tFILE_CREATE_PIPE_INSTANCE\n");
    if (m & FILE_READ_EA)
        dprintf(1, "\tFILE_READ_EA\n");
    if (m & FILE_WRITE_EA)
        dprintf(1, "\tFILE_WRITE_EA\n");
    if (m & FILE_EXECUTE)
        dprintf(1, "\tFILE_EXECUTE\n");
    if (m & FILE_TRAVERSE)
        dprintf(1, "\tFILE_TRAVERSE\n");
    if (m & FILE_DELETE_CHILD)
        dprintf(1, "\tFILE_DELETE_CHILD\n");
    if (m & FILE_READ_ATTRIBUTES)
        dprintf(1, "\tFILE_READ_ATTRIBUTES\n");
    if (m & FILE_WRITE_ATTRIBUTES)
        dprintf(1, "\tFILE_WRITE_ATTRIBUTES\n");
    if ((m & FILE_ALL_ACCESS) == FILE_ALL_ACCESS)
        dprintf(1, "\tFILE_ALL_ACCESS\n");
    if ((m & FILE_GENERIC_READ) == FILE_GENERIC_READ)
        dprintf(1, "\tFILE_GENERIC_READ\n");
    if ((m & FILE_GENERIC_WRITE) == FILE_GENERIC_WRITE)
        dprintf(1, "\tFILE_GENERIC_WRITE\n");
    if ((m & FILE_GENERIC_EXECUTE) == FILE_GENERIC_EXECUTE)
        dprintf(1, "\tFILE_GENERIC_EXECUTE\n");
}

Referenced by map_acemask().

rpc_error_string()

const char * rpc_error_string

(

int

status

)

Definition at line 482 of file daemon_debug.c.

{
    switch (status)
    {
    case RPC_CANTENCODEARGS: return "RPC_CANTENCODEARGS";
    case RPC_CANTDECODERES: return "RPC_CANTDECODERES";
    case RPC_CANTSEND: return "RPC_CANTSEND";
    case RPC_CANTRECV: return "RPC_CANTRECV";
    case RPC_TIMEDOUT: return "RPC_TIMEDOUT";
    case RPC_INTR: return "RPC_INTR";
    case RPC_UDERROR: return "RPC_UDERROR";
    case RPC_VERSMISMATCH: return "RPC_VERSMISMATCH";
    case RPC_AUTHERROR: return "RPC_AUTHERROR";
    case RPC_PROGUNAVAIL: return "RPC_PROGUNAVAIL";
    case RPC_PROGVERSMISMATCH: return "RPC_PROGVERSMISMATCH";
    case RPC_PROCUNAVAIL: return "RPC_PROCUNAVAIL";
    case RPC_CANTDECODEARGS: return "RPC_CANTDECODEARGS";
    case RPC_SYSTEMERROR: return "RPC_SYSTEMERROR";
    default: return "invalid rpc error code";
    }
}

Referenced by nfs41_send_compound().

secflavorop2name()

const char * secflavorop2name

(

DWORD

sec_flavor

)

Definition at line 558 of file daemon_debug.c.

{
    switch(sec_flavor) {
    case RPCSEC_AUTH_SYS:      return "AUTH_SYS";
    case RPCSEC_AUTHGSS_KRB5:  return "AUTHGSS_KRB5";
    case RPCSEC_AUTHGSS_KRB5I: return "AUTHGSS_KRB5I";
    case RPCSEC_AUTHGSS_KRB5P: return "AUTHGSS_KRB5P";
    }
 
    return "UNKNOWN FLAVOR";
}

Referenced by create_rpcsec_auth_client(), marshal_nfs41_mount(), nfs41_rpc_clnt_create(), and parse_mount().

set_debug_level()

void set_debug_level

(

int

level

)

Definition at line 35 of file daemon_debug.c.

{ g_debug_level = level; }

Referenced by ServiceStart().