Main Page | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Search for 
tmp / linux-rsbac-1.2 / rsbac / help

debug.c File Reference

#include <asm/uaccess.h>
#include <rsbac/types.h>
#include <rsbac/aci.h>
#include <rsbac/aci_data_structures.h>
#include <rsbac/debug.h>
#include <rsbac/error.h>
#include <rsbac/proc_fs.h>
#include <rsbac/getname.h>
#include <rsbac/net_getname.h>
#include <rsbac/adf.h>
#include <rsbac/rkmem.h>
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <linux/config.h>
#include <linux/module.h>
#include <linux/console.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/moduleparam.h>
#include <linux/syscalls.h>

Go to the source code of this file.

Functions

void rsbac_adf_log_switch (rsbac_adf_request_int_t request, enum rsbac_target_t target, rsbac_enum_t value)
int rsbac_get_adf_log (rsbac_adf_request_int_t request, enum rsbac_target_t target, u_int *value_p)
static int R_INIT no_defaults_setup (char *line)
 __setup ("rsbac_no_defaults", no_defaults_setup)
 EXPORT_SYMBOL (rsbac_printk)
int rsbac_printk (const char *fmt,...)
static int ll_conv (void *old_desc, void *old_data, void *new_desc, void *new_data)
rsbac_list_conv_function_t * ll_get_conv (rsbac_version_t old_version)
void __init rsbac_init_debug (void)

Variables

int rsbac_debug_no_write = 0
static rsbac_boolean_t debug_initialized = FALSE
int rsbac_no_defaults = 0
static rsbac_list_handle_t log_levels_handle = NULL
static u_int log_seq = 0
int rsbac_debug_adf_default = 1
rsbac_log_entry_t rsbac_log_levels [R_NONE+1]
rsbac_boolean_t rsbac_debug_adf_dirty = FALSE

Function Documentation

__setup (  "rsbac_no_defaults"  ,
no_defaults_setup 
) 
 

EXPORT_SYMBOL (  rsbac_printk   ) 
 

static int ll_conv (  void *  old_desc,
void *  old_data,
void *  new_desc,
void *  new_data
)  [static]
 

Definition at line 4828 of file debug.c.

References LL_denied, and T_NONE.

Referenced by ll_get_conv().

04833   {
04834     rsbac_log_entry_t     * new_aci = new_data;
04835     rsbac_old_log_entry_t * old_aci = old_data;
04836     int i;
04837 
04838     memcpy(new_desc, old_desc, sizeof(rsbac_adf_request_int_t));
04839     for(i=0; i < T_NONE - 1; i++)
04840       (*new_aci)[i] = (*old_aci)[i];
04841     (*new_aci)[T_NONE - 1] = LL_denied;
04842     (*new_aci)[T_NONE] = (*old_aci)[T_NONE - 1];
04843     return 0;
04844   }

rsbac_list_conv_function_t* ll_get_conv (  rsbac_version_t  old_version  ) 
 

Definition at line 4846 of file debug.c.

References ll_conv(), NULL, and RSBAC_LOG_LEVEL_OLD_VERSION.

Referenced by rsbac_init_debug().

04847   {
04848     switch(old_version)
04849       {
04850         case RSBAC_LOG_LEVEL_OLD_VERSION:
04851           return ll_conv;
04852         default:
04853           return NULL;
04854       }
04855   }

static int R_INIT no_defaults_setup (  char *  line  )  [static]
 

Definition at line 942 of file debug.c.

References rsbac_no_defaults.

00943     {
00944       rsbac_no_defaults = 1;
00945       return 1;
00946     }

void rsbac_adf_log_switch (  rsbac_adf_request_int_t  request,
enum rsbac_target_t  target,
rsbac_enum_t  value
) 
 

Definition at line 276 of file debug.c.

Referenced by sys_rsbac_adf_log_switch().

00279   {
00280     if(   (request < R_NONE)
00281        && (target <= T_NONE)
00282        && (value <= LL_full)
00283       )
00284       {
00285         rsbac_log_levels[request][target] = value;
00286         if(log_levels_handle)
00287           rsbac_list_add(log_levels_handle, &request, rsbac_log_levels[request]);
00288       }
00289   };

int rsbac_get_adf_log (  rsbac_adf_request_int_t  request,
enum rsbac_target_t  target,
u_int *  value_p
) 
 

Definition at line 291 of file debug.c.

Referenced by sys_rsbac_get_adf_log().

00294   {
00295     if(   (request < R_NONE)
00296        && (target <= T_NONE)
00297       )
00298       {
00299         *value_p = rsbac_log_levels[request][target];
00300         return 0;
00301       }
00302     else
00303       return -RSBAC_EINVALIDVALUE;
00304   }

void __init rsbac_init_debug (  void   )  [inline]
 

Definition at line 4865 of file debug.c.

References debug_initialized, get_error_name(), LL_denied, ll_get_conv(), log_levels_handle, NULL, proc_rsbac_root_p, rsbac_daz_get_ttl(), rsbac_debug_adf_default, rsbac_debug_no_write, rsbac_kfree(), rsbac_kmalloc(), RSBAC_LIST_DEF_DATA, rsbac_list_get_data(), RSBAC_LIST_PERSIST, rsbac_list_register(), RSBAC_LIST_VERSION, RSBAC_LOG_LEVEL_KEY, RSBAC_LOG_LEVEL_LIST_NAME, RSBAC_LOG_LEVEL_VERSION, rsbac_log_levels, RSBAC_MAXNAMELEN, rsbac_no_defaults, rsbac_printk(), T_NONE, and TRUE.

Referenced by rsbac_do_init().

04867   {
04868     int i;
04869     #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
04870     struct proc_dir_entry * tmp_entry_p;
04871     #endif
04872     
04873     if (!debug_initialized)
04874       {
04875         struct rsbac_list_info_t * info_p;
04876         int tmperr;
04877         rsbac_enum_t * def_data_p;
04878 
04879         rsbac_printk(KERN_INFO "rsbac_init_debug(): Initializing\n");
04880         info_p = rsbac_kmalloc(sizeof(*info_p));
04881         if(!info_p)
04882           {
04883             memset(rsbac_log_levels, LL_denied, sizeof(rsbac_log_levels));
04884             return;
04885           }
04886         def_data_p = rsbac_kmalloc(sizeof(rsbac_log_entry_t));
04887         if(!def_data_p)
04888           {
04889             memset(rsbac_log_levels, LL_denied, sizeof(rsbac_log_levels));
04890             rsbac_kfree(info_p);
04891             return;
04892           }
04893         /* register log_levels list */
04894         for(i=0; i<=T_NONE; i++)
04895           def_data_p[i] = LL_denied;
04896         info_p->version = RSBAC_LOG_LEVEL_VERSION;
04897         info_p->key = RSBAC_LOG_LEVEL_KEY;
04898         info_p->desc_size = sizeof(rsbac_adf_request_int_t);
04899         info_p->data_size = sizeof(rsbac_log_entry_t);
04900         info_p->max_age = 0;
04901         tmperr = rsbac_list_register(RSBAC_LIST_VERSION,
04902                                      &log_levels_handle,
04903                                      info_p,
04904                                      RSBAC_LIST_PERSIST | RSBAC_LIST_DEF_DATA,
04905                                      NULL,
04906                                      ll_get_conv,
04907                                      def_data_p,
04908                                      RSBAC_LOG_LEVEL_LIST_NAME,
04909                                      RSBAC_AUTO_DEV);
04910         if(tmperr)
04911           {
04912             char * tmp;
04913 
04914             tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
04915             if(tmp)
04916               {
04917                 rsbac_printk(KERN_WARNING
04918                        "rsbac_init_debug(): registering log levels list ll failed with error %s!\n",
04919                        get_error_name(tmp, tmperr));
04920                 rsbac_kfree(tmp);
04921               }
04922             memset(rsbac_log_levels, LL_denied, sizeof(rsbac_log_levels));
04923           }
04924         else
04925           {
04926             rsbac_adf_request_int_t req;
04927 
04928             for(req = 0; req < R_NONE; req++)
04929               rsbac_list_get_data(log_levels_handle, &req, rsbac_log_levels[req]);
04930           }
04931 
04932         #if defined(CONFIG_RSBAC_PROC) && defined(CONFIG_PROC_FS)
04933         tmp_entry_p = create_proc_entry("log_levels",
04934                                         S_IFREG | S_IRUGO | S_IWUGO,
04935                                         proc_rsbac_root_p);
04936         if(tmp_entry_p)
04937           {
04938             tmp_entry_p->get_info = log_levels_proc_info;
04939             tmp_entry_p->write_proc = log_levels_proc_write;
04940           }
04941 
04942         tmp_entry_p = create_proc_entry("debug",
04943                                         S_IFREG | S_IRUGO | S_IWUGO,
04944                                         proc_rsbac_root_p);
04945         if(tmp_entry_p)
04946           {
04947             tmp_entry_p->get_info = debug_proc_info;
04948             tmp_entry_p->write_proc = debug_proc_write;
04949           }
04950 
04951         #if defined(CONFIG_RSBAC_RMSG)
04952         tmp_entry_p = create_proc_entry("rmsg",
04953                                         S_IFREG | S_IRUGO,
04954                                         proc_rsbac_root_p);
04955         if(tmp_entry_p)
04956           {
04957             tmp_entry_p->proc_fops = &proc_rmsg_operations;
04958           }
04959         #endif
04960         #endif
04961 
04962         #if defined(CONFIG_RSBAC_LOG_REMOTE)
04963         /* Start rsbac logging thread for auto write */
04964         if(!rsbac_log_remote_port)
04965           rsbac_log_remote_port = htons(CONFIG_RSBAC_LOG_REMOTE_PORT);
04966         tmperr = rsbac_net_str_to_inet(rsbac_log_remote_addr_string,
04967                                     &rsbac_log_remote_addr);
04968         if(tmperr < 0)
04969           {
04970             char * tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
04971 
04972             if(tmp)
04973               {
04974                 get_error_name(tmp, tmperr);
04975                 rsbac_printk(KERN_WARNING
04976                              "rsbac_init_debug(): converting remote socket address %s failed with error %s, exiting!\n",
04977                              rsbac_log_remote_addr_string,
04978                              tmp);
04979                 rsbac_log_remote_addr = 0;
04980                 rsbac_kfree(tmp);
04981               }
04982           }
04983         rsbaclogd_pid = kernel_thread(rsbaclogd, NULL, 0);
04984         rsbac_printk(KERN_INFO "rsbac_init_debug(): Started rsbaclogd thread with pid %u\n",
04985                rsbaclogd_pid);
04986         #endif
04987 
04988         #ifdef CONFIG_RSBAC_SYSLOG_RATE
04989         init_timer(&rsbac_syslog_rate_timer);
04990         rsbac_syslog_rate_timer.function = syslog_rate_reset;
04991         rsbac_syslog_rate_timer.data = 0;
04992         rsbac_syslog_rate_timer.expires = jiffies + HZ;
04993         add_timer(&rsbac_syslog_rate_timer);
04994         #endif
04995 
04996         debug_initialized = TRUE;
04997       }
04998 
04999     #ifdef CONFIG_RSBAC_SOFTMODE
05000     if(rsbac_softmode)
05001       rsbac_printk(KERN_DEBUG "rsbac_softmode is set\n");
05002     if(rsbac_softmode_prohibit)
05003       rsbac_printk(KERN_DEBUG "rsbac_softmode_prohibit is set\n");
05004     #endif
05005     #ifdef CONFIG_RSBAC_FREEZE
05006     if(rsbac_freeze)
05007       rsbac_printk(KERN_DEBUG "rsbac_freeze is set\n");
05008     #endif
05009     #if defined(CONFIG_RSBAC_UM_EXCL)
05010     if(rsbac_um_no_excl)
05011       rsbac_printk(KERN_DEBUG "rsbac_um_no_excl is set\n");
05012     #endif
05013     #if defined(CONFIG_RSBAC_DAZ_CACHE)
05014     rsbac_printk(KERN_DEBUG "rsbac_daz_ttl is %u\n",
05015                  rsbac_daz_get_ttl());
05016     #endif
05017     #if defined(CONFIG_RSBAC_AUTH_LEARN)
05018     if(rsbac_auth_learn)
05019       rsbac_printk(KERN_DEBUG "rsbac_auth_learn is set\n");
05020     #endif
05021     #if defined(CONFIG_RSBAC_ACL_LEARN)
05022     if(rsbac_acl_learn_fd)
05023       rsbac_printk(KERN_DEBUG "rsbac_acl_learn_fd is set\n");
05024     #endif
05025     #ifdef CONFIG_RSBAC_CAP_PROC_HIDE
05026     if(rsbac_cap_process_hiding)
05027       rsbac_printk(KERN_DEBUG "rsbac_cap_process_hiding is set\n");
05028     #endif
05029     #ifdef CONFIG_RSBAC_CAP_LOG_MISSING
05030     if(rsbac_cap_log_missing)
05031       rsbac_printk(KERN_DEBUG "rsbac_cap_log_missing is set\n");
05032     #endif
05033     #ifdef CONFIG_RSBAC_JAIL_LOG_MISSING
05034     if(rsbac_jail_log_missing)
05035       rsbac_printk(KERN_DEBUG "rsbac_jail_log_missing is set\n");
05036     #endif
05037     #ifdef CONFIG_RSBAC_ALLOW_DAC_DISABLE_FULL
05038     if(rsbac_dac_disable)
05039       rsbac_printk(KERN_DEBUG "rsbac_dac_disable is set\n");
05040     #endif
05041     #ifdef CONFIG_RSBAC_RMSG_NOSYSLOG
05042     if(rsbac_nosyslog)
05043       rsbac_printk(KERN_DEBUG "rsbac_nosyslog is set\n");
05044     #endif
05045     #ifdef CONFIG_RSBAC_SYSLOG_RATE
05046     if(rsbac_syslog_rate != CONFIG_RSBAC_SYSLOG_RATE_DEF)
05047       rsbac_printk(KERN_DEBUG "rsbac_syslog_rate is %u\n",
05048                    rsbac_syslog_rate);
05049     #endif
05050     #ifdef CONFIG_RSBAC_INIT_DELAY
05051     if(rsbac_no_delay_init)
05052       rsbac_printk(KERN_DEBUG "rsbac_no_delay_init is set\n");
05053 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
05054     if(rsbac_delayed_root_str[0])
05055       rsbac_printk(KERN_DEBUG "rsbac_delayed_root is %s\n",
05056              rsbac_delayed_root_str);
05057 #else
05058     if(rsbac_delayed_root)
05059       rsbac_printk(KERN_DEBUG "rsbac_delayed_root is %02u:%02u\n",
05060              MAJOR(rsbac_delayed_root), MINOR(rsbac_delayed_root));
05061 #endif
05062     #endif
05063     if(rsbac_no_defaults)
05064       rsbac_printk(KERN_DEBUG "rsbac_no_defaults is set\n");
05065 
05066 #if defined(CONFIG_RSBAC_DEBUG)
05067     if(rsbac_debug_ds)
05068       rsbac_printk(KERN_DEBUG "rsbac_debug_ds is set\n");
05069     if(rsbac_debug_write)
05070       rsbac_printk(KERN_DEBUG "rsbac_debug_write is set\n");
05071     if(rsbac_debug_no_write)
05072       rsbac_printk(KERN_DEBUG "rsbac_debug_no_write is set\n");
05073     if(rsbac_debug_stack)
05074       rsbac_printk(KERN_DEBUG "rsbac_debug_stack is set\n");
05075     if(rsbac_debug_lists)
05076       rsbac_printk(KERN_DEBUG "rsbac_debug_lists is set\n");
05077     if(rsbac_debug_aef)
05078       rsbac_printk(KERN_DEBUG "rsbac_debug_aef is set\n");
05079     if(rsbac_debug_adf_default != 1)
05080       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_default is set to %i\n",
05081              rsbac_debug_adf_default);
05082 
05083     #if defined(CONFIG_RSBAC_REG)
05084     if(rsbac_debug_reg)
05085       rsbac_printk(KERN_DEBUG "rsbac_debug_reg is set\n");
05086     #endif
05087 
05088     #if defined(CONFIG_RSBAC_NET)
05089     if(rsbac_debug_ds_net)
05090       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_net is set\n");
05091     if(rsbac_debug_aef_net)
05092       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_net is set\n");
05093     if(rsbac_debug_adf_net)
05094       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_net is set\n");
05095     #endif
05096 
05097     #if defined(CONFIG_RSBAC_MAC)
05098     if(rsbac_debug_ds_mac)
05099       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_mac is set\n");
05100     if(rsbac_debug_aef_mac)
05101       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_mac is set\n");
05102     if(rsbac_debug_adf_mac)
05103       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_mac is set\n");
05104     #endif
05105 
05106     #if defined(CONFIG_RSBAC_PM)
05107     if(rsbac_debug_ds_pm)
05108       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_pm is set\n");
05109     if(rsbac_debug_aef_pm)
05110       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_pm is set\n");
05111     if(rsbac_debug_adf_pm)
05112       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_pm is set\n");
05113     #endif
05114 
05115     #if defined(CONFIG_RSBAC_DAZ)
05116     if(rsbac_debug_adf_daz)
05117       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_daz is set\n");
05118     #endif
05119 
05120     #if defined(CONFIG_RSBAC_RC)
05121     if(rsbac_debug_ds_rc)
05122       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_rc is set\n");
05123     if(rsbac_debug_aef_rc)
05124       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_rc is set\n");
05125     if(rsbac_debug_adf_rc)
05126       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_rc is set\n");
05127     #endif
05128 
05129     #if defined(CONFIG_RSBAC_AUTH)
05130     if(rsbac_debug_ds_auth)
05131       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_auth is set\n");
05132     if(rsbac_debug_aef_auth)
05133       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_auth is set\n");
05134     if(rsbac_debug_adf_auth)
05135       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_auth is set\n");
05136     #endif
05137 
05138     #if defined(CONFIG_RSBAC_ACL)
05139     if(rsbac_debug_ds_acl)
05140       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_acl is set\n");
05141     if(rsbac_debug_aef_acl)
05142       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_acl is set\n");
05143     if(rsbac_debug_adf_acl)
05144       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_acl is set\n");
05145     #endif
05146 
05147     #if defined(CONFIG_RSBAC_JAIL)
05148     if(rsbac_debug_aef_jail)
05149       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_jail is set\n");
05150     if(rsbac_debug_adf_jail)
05151       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_jail is set\n");
05152     #endif
05153 
05154     #if defined(CONFIG_RSBAC_PAX)
05155     if(rsbac_debug_adf_pax)
05156       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_pax is set\n");
05157     #endif
05158 
05159     #if defined(CONFIG_RSBAC_UM)
05160     if(rsbac_debug_ds_um)
05161       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_um is set\n");
05162     if(rsbac_debug_aef_um)
05163       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_um is set\n");
05164     if(rsbac_debug_adf_um)
05165       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_um is set\n");
05166     #endif
05167 
05168     #if defined(CONFIG_RSBAC_AUTO_WRITE) && (CONFIG_RSBAC_AUTO_WRITE > 0)
05169     if(rsbac_debug_auto)
05170       rsbac_printk(KERN_DEBUG "rsbac_debug_auto is set\n");
05171     #endif
05172 #endif /* DEBUG */
05173 
05174   }

int rsbac_printk (  const char *  fmt,
  ...
) 
 

Definition at line 1725 of file debug.c.

References log_seq, and RSBAC_DEF_MESS_LOGLEVEL.

Referenced by aci_detach_fd_lists(), acl_detach_fd_lists(), acl_register_fd_lists(), auth_detach_fd_lists(), auth_register_fd_lists(), auto_read_attr(), auto_read_write_attr(), auto_write_attr(), check_comp_rc(), check_comp_rc_scd(), check_flags_ff(), cleanup_module(), do_remove_lol_item(), get_attr_fd(), init_module(), lookup_aci_path_dentry(), lookup_lol_reg(), lookup_lol_reg_name(), lookup_reg(), lookup_reg_name(), mac_check_role(), mac_detach_fd_lists(), mac_register_fd_lists(), read_info(), read_list(), read_lol_list(), register_dev_lists(), register_fd_lists(), register_ipc_lists(), register_process_lists(), register_user_lists(), registration_error(), rsbac_acl_add_to_acl_entry(), rsbac_acl_check_forward(), rsbac_acl_check_right(), rsbac_acl_check_super(), rsbac_acl_get_mask(), rsbac_acl_get_rights(), rsbac_acl_get_single_right(), rsbac_acl_get_tlist(), rsbac_acl_remove_acl(), rsbac_acl_remove_acl_entry(), rsbac_acl_remove_from_acl_entry(), rsbac_acl_set_acl_entry(), rsbac_acl_set_mask(), rsbac_acl_sys_add_to_acl_entry(), rsbac_acl_sys_get_mask(), rsbac_acl_sys_get_rights(), rsbac_acl_sys_get_tlist(), rsbac_acl_sys_group(), rsbac_acl_sys_remove_acl(), rsbac_acl_sys_remove_acl_entry(), rsbac_acl_sys_remove_from_acl_entry(), rsbac_acl_sys_remove_user(), rsbac_acl_sys_set_acl_entry(), rsbac_acl_sys_set_mask(), rsbac_adf_request_auth(), rsbac_adf_request_daz(), rsbac_adf_request_ff(), rsbac_adf_request_int(), rsbac_adf_request_jail(), rsbac_adf_request_rc(), rsbac_adf_set_attr(), rsbac_adf_set_attr_auth(), rsbac_adf_set_attr_cap(), rsbac_adf_set_attr_daz(), rsbac_adf_set_attr_jail(), rsbac_adf_set_attr_mac(), rsbac_adf_set_attr_rc(), rsbac_auth_add_f_cap(), rsbac_auth_add_p_cap(), rsbac_auth_add_to_f_capset(), rsbac_auth_add_to_p_capset(), rsbac_auth_clear_f_capset(), rsbac_auth_clear_p_capset(), rsbac_auth_copy_fp_capset(), rsbac_auth_copy_pp_capset(), rsbac_auth_get_f_caplist(), rsbac_auth_get_p_caplist(), rsbac_auth_p_capset_member(), rsbac_auth_remove_from_f_capset(), rsbac_auth_remove_from_p_capset(), rsbac_auth_remove_p_cap(), rsbac_check_acl(), rsbac_check_inode(), rsbac_check_lists(), rsbac_do_init(), rsbac_free_dat_dentries(), rsbac_get_parent(), rsbac_get_super_block(), rsbac_init(), rsbac_init_acl(), rsbac_init_auth(), rsbac_init_daz(), rsbac_init_debug(), rsbac_init_mac(), rsbac_init_pm(), rsbac_init_rc(), rsbac_init_um(), rsbac_jail_sys_jail(), rsbac_kmalloc(), rsbac_kthread_notify(), rsbac_list_check(), rsbac_list_destroy(), rsbac_list_detach(), rsbac_list_init(), rsbac_list_lol_check(), rsbac_list_lol_destroy(), rsbac_list_lol_detach(), rsbac_list_lol_no_write(), rsbac_list_lol_register(), rsbac_list_no_write(), rsbac_list_register(), rsbac_list_write_buffers(), rsbac_list_write_lol_buffers(), rsbac_mac_add_f_tru(), rsbac_mac_add_p_tru(), rsbac_mac_add_to_f_truset(), rsbac_mac_add_to_p_truset(), rsbac_mac_clear_f_truset(), rsbac_mac_clear_p_truset(), rsbac_mac_copy_fp_truset(), rsbac_mac_copy_pp_truset(), rsbac_mac_get_f_trulist(), rsbac_mac_get_p_trulist(), rsbac_mac_p_truset_member(), rsbac_mac_remove_f_tru(), rsbac_mac_remove_from_f_truset(), rsbac_mac_remove_from_p_truset(), rsbac_mac_remove_p_tru(), rsbac_mac_set_curr_level(), rsbac_mount(), rsbac_mount_acl(), rsbac_mount_auth(), rsbac_mount_mac(), rsbac_pm_exists(), rsbac_rc_check_comp(), rsbac_rc_check_type_comp(), rsbac_rc_copy_role(), rsbac_rc_copy_type(), rsbac_rc_get_item(), rsbac_rc_get_list(), rsbac_rc_set_item(), rsbac_rc_sys_change_role(), rsbac_rc_sys_copy_role(), rsbac_rc_sys_copy_type(), rsbac_rc_sys_get_current_role(), rsbac_rc_sys_get_eff_rights(), rsbac_rc_sys_get_item(), rsbac_rc_sys_set_item(), rsbac_read_open(), rsbac_reg_init(), rsbac_reg_register(), rsbac_reg_register_syscall(), rsbac_reg_switch(), rsbac_reg_unregister(), rsbac_reg_unregister_syscall(), rsbac_replace_auth_cap(), rsbac_stats(), rsbac_stats_acl(), rsbac_stats_auth(), rsbac_stats_mac(), rsbac_stats_pm(), rsbac_stats_rc(), rsbac_stats_um(), rsbac_ta_get_attr(), rsbac_ta_remove_target(), rsbac_ta_set_attr(), rsbac_um_add_gm(), rsbac_um_add_group(), rsbac_um_add_user(), rsbac_um_check_account(), rsbac_um_check_pass(), rsbac_um_get_group_item(), rsbac_um_get_user_item(), rsbac_um_hash(), rsbac_um_mod_group(), rsbac_um_mod_user(), rsbac_um_remove_gm(), rsbac_um_set_group_pass(), rsbac_um_set_pass(), rsbac_umount(), rsbac_umount_acl(), rsbac_umount_auth(), rsbac_umount_mac(), rsbac_write_open(), set_attr_fd(), set_attr_process(), sys_rsbac_acl(), sys_rsbac_acl_get_mask_n(), sys_rsbac_acl_get_rights(), sys_rsbac_acl_get_rights_n(), sys_rsbac_acl_get_tlist_n(), sys_rsbac_acl_group(), sys_rsbac_acl_n(), sys_rsbac_adf_log_switch(), sys_rsbac_auth_add_f_cap(), sys_rsbac_auth_add_p_cap(), sys_rsbac_auth_get_f_caplist(), sys_rsbac_auth_get_p_caplist(), sys_rsbac_auth_remove_f_cap(), sys_rsbac_auth_remove_p_cap(), sys_rsbac_check(), sys_rsbac_daz_flush_cache(), sys_rsbac_get_adf_log(), sys_rsbac_get_attr(), sys_rsbac_get_attr_n(), sys_rsbac_mac_add_f_tru(), sys_rsbac_mac_add_p_tru(), sys_rsbac_mac_get_f_trulist(), sys_rsbac_mac_remove_f_tru(), sys_rsbac_mac_remove_p_tru(), sys_rsbac_net_template(), sys_rsbac_pm(), sys_rsbac_pm_change_current_task(), sys_rsbac_pm_create_file(), sys_rsbac_rc_change_role(), sys_rsbac_rc_copy_role(), sys_rsbac_rc_copy_type(), sys_rsbac_rc_get_eff_rights_n(), sys_rsbac_rc_get_item(), sys_rsbac_rc_set_item(), sys_rsbac_remove_target(), sys_rsbac_remove_target_n(), sys_rsbac_set_attr(), sys_rsbac_set_attr_n(), sys_rsbac_stats(), sys_rsbac_stats_pm(), sys_rsbac_switch(), sys_rsbac_um_add_gm(), sys_rsbac_um_add_group(), sys_rsbac_um_add_user(), sys_rsbac_um_auth_name(), sys_rsbac_um_auth_uid(), sys_rsbac_um_check_account(), sys_rsbac_um_check_account_name(), sys_rsbac_um_get_gid(), sys_rsbac_um_get_gm_list(), sys_rsbac_um_get_gm_user_list(), sys_rsbac_um_get_group_item(), sys_rsbac_um_get_group_list(), sys_rsbac_um_get_next_user(), sys_rsbac_um_get_uid(), sys_rsbac_um_get_user_item(), sys_rsbac_um_get_user_list(), sys_rsbac_um_group_exists(), sys_rsbac_um_mod_group(), sys_rsbac_um_mod_user(), sys_rsbac_um_remove_gm(), sys_rsbac_um_remove_group(), sys_rsbac_um_remove_user(), sys_rsbac_um_set_group_pass(), sys_rsbac_um_set_pass(), sys_rsbac_um_set_pass_name(), sys_rsbac_um_user_exists(), sys_rsbac_write(), write_info(), and xp_print().

01726 {
01727         va_list args;
01728         int printed_len;
01729         char *p;
01730         static char buf[2048];
01731         static int log_level_unknown = 1;
01732         char *k;
01733 #if defined(CONFIG_RSBAC_LOG_REMOTE)
01734         static u_int remote_log_seq = 0;
01735         static int remote_log_level_unknown = 1;
01736 #endif
01737 
01738 #if defined(CONFIG_RSBAC_RMSG)
01739         if (oops_in_progress) {
01740                 /* If a crash is occurring, make sure we can't deadlock */
01741                 spin_lock_init(&rsbac_log_lock);
01742         }
01743 
01744         spin_lock(&rsbac_log_lock);
01745 #endif
01746 
01747         /* Emit the output into the temporary buffer */
01748         va_start(args, fmt);
01749         printed_len = vsnprintf(buf + 14, sizeof(buf) - 14, fmt, args);
01750         va_end(args);
01751         if(printed_len <= 0)
01752           {
01753 #if defined(CONFIG_RSBAC_RMSG)
01754             spin_unlock(&rsbac_log_lock);
01755 #endif
01756             return printed_len;
01757           }
01758 
01759         /*
01760          * Copy the output into log_buf.  If the caller didn't provide
01761          * appropriate log level tags, we insert them here
01762          */
01763         k = buf+14;
01764         for (p = buf + 14; *p; p++) {
01765                 if (log_level_unknown) {
01766                         if (p[0] != '<' || p[1] < '0' || p[1] > '7' || p[2] != '>') {
01767                                 p -= 14;
01768                                 p[0] = '<';
01769                                 p[1] = RSBAC_DEF_MESS_LOGLEVEL + '0';
01770                                 p[2] = '>';
01771                                 sprintf(p + 3, "%010u", log_seq++);
01772                                 p[13] = '|';
01773                         } else {
01774                                 p -= 11;
01775                                 p[0] = '<';
01776                                 p[1] = p[12];
01777                                 p[2] = '>';
01778                                 sprintf(p + 3, "%010u", log_seq++);
01779                                 p[13] = '|';
01780                         }
01781                         k = p;
01782                         log_level_unknown = 0;
01783                 }
01784                 #if defined(CONFIG_RSBAC_RMSG)
01785                 emit_log_char(*p);
01786                 #endif
01787                 if (*p == '\n')
01788                   {
01789                     #ifdef CONFIG_RSBAC_RMSG_NOSYSLOG
01790                     if (!rsbac_nosyslog)
01791                     #endif
01792                     {
01793                       #ifdef CONFIG_RSBAC_SYSLOG_RATE
01794                       syslog_count++;
01795                       if(syslog_count < rsbac_syslog_rate)
01796                       #endif
01797                         printk(k);
01798                       #ifdef CONFIG_RSBAC_SYSLOG_RATE
01799                       else
01800                         if(syslog_count == rsbac_syslog_rate)
01801                           printk(KERN_INFO "rsbac_printk: Applying syslog rate limit at count %u, message %u!\n",
01802                                  syslog_count, log_seq - 1);
01803                       #endif
01804                     }
01805 
01806                     log_level_unknown = 1;
01807                   }
01808         }
01809         /* if the line was incomplete, spit out the rest to printk */
01810         if(   !log_level_unknown
01811            #ifdef CONFIG_RSBAC_RMSG_NOSYSLOG
01812            && !rsbac_nosyslog
01813            #endif
01814           )
01815           printk(k);
01816 
01817 #if defined(CONFIG_RSBAC_RMSG)
01818         spin_unlock(&rsbac_log_lock);
01819         wake_up_interruptible(&rlog_wait);
01820 
01821 #if defined(CONFIG_RSBAC_LOG_REMOTE)
01822         if (oops_in_progress) {
01823                 /* If a crash is occurring, make sure we can't deadlock */
01824                 spin_lock_init(&rsbac_log_remote_lock);
01825         }
01826 
01827         /* This stops the holder of console_sem just where we want him */
01828         spin_lock(&rsbac_log_remote_lock);
01829 
01830         /* Emit the output into the temporary buffer */
01831         va_start(args, fmt);
01832         printed_len = vsnprintf(buf + 14, sizeof(buf) - 14, fmt, args);
01833         va_end(args);
01834 
01835         /*
01836          * Copy the output into log_buf.  If the caller didn't provide
01837          * appropriate log level tags, we insert them here
01838          */
01839         for (p = buf + 14; *p; p++) {
01840                 if (remote_log_level_unknown) {
01841                         if (p[0] != '<' || p[1] < '0' || p[1] > '7' || p[2] != '>') {
01842                                 p -= 14;
01843                                 p[0] = '<';
01844                                 p[1] = RSBAC_DEF_MESS_LOGLEVEL + '0';
01845                                 p[2] = '>';
01846                                 sprintf(p + 3, "%010u", remote_log_seq++);
01847                                 p[13] = '|';
01848                         } else {
01849                                 p -= 11;
01850                                 p[0] = '<';
01851                                 p[1] = p[12];
01852                                 p[2] = '>';
01853                                 sprintf(p + 3, "%010u", remote_log_seq++);
01854                                 p[13] = '|';
01855                         }
01856                         remote_log_level_unknown = 0;
01857                 }
01858                 emit_remote_log_char(*p);
01859                 if (*p == '\n')
01860                         remote_log_level_unknown = 1;
01861         }
01862         spin_unlock(&rsbac_log_remote_lock);
01863 #ifdef CONFIG_RSBAC_LOG_REMOTE_SYNC
01864         wake_up_interruptible(&rsbaclogd_wait);
01865 #endif
01866 #endif /* RMSG_LOG_REMOTE */
01867 #endif /* RMSG */
01868 
01869         return printed_len;
01870 }

Variable Documentation

rsbac_boolean_t debug_initialized = FALSE [static]
 

Definition at line 41 of file debug.c.

Referenced by rsbac_init_debug().

rsbac_list_handle_t log_levels_handle = NULL [static]
 

Definition at line 167 of file debug.c.

Referenced by rsbac_adf_log_switch(), and rsbac_init_debug().

u_int log_seq = 0 [static]
 

Definition at line 213 of file debug.c.

Referenced by rsbac_printk().

int rsbac_debug_adf_default = 1
 

Definition at line 232 of file debug.c.

Referenced by rsbac_init_debug().

rsbac_boolean_t rsbac_debug_adf_dirty = FALSE
 

Definition at line 235 of file debug.c.

int rsbac_debug_no_write = 0
 

Definition at line 39 of file debug.c.

Referenced by rsbac_init_debug(), rsbac_mount(), rsbac_umount(), and writable().

rsbac_log_entry_t rsbac_log_levels[R_NONE+1]
 

Definition at line 233 of file debug.c.

Referenced by rsbac_adf_log_switch(), rsbac_adf_request_int(), rsbac_adf_set_attr(), rsbac_get_adf_log(), and rsbac_init_debug().

int rsbac_no_defaults = 0
 

Definition at line 165 of file debug.c.

Referenced by no_defaults_setup(), register_user_lists(), rsbac_init_acl(), rsbac_init_debug(), and rsbac_init_rc().

Generated on Thu Sep 22 16:42:31 2005 for RSBAC by  doxygen 1.4.2