/linux-2.6.21.1-rsbac-1.3.4/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/module.h>
#include <linux/console.h>
#include <linux/net.h>
#include <linux/in.h>
#include <linux/moduleparam.h>
#include <linux/syscalls.h>
#include <linux/kthread.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 rsbac_flags_setup (char *line)
 __setup ("rsbac_flags=", rsbac_flags_setup)
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)
static int ll_old_conv (void *old_desc, void *old_data, void *new_desc, void *new_data)
rsbac_list_conv_function_tll_get_conv (rsbac_version_t old_version)
void __init rsbac_init_debug (void)

Variables

unsigned long int rsbac_flags
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   
)

__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 5186 of file debug.c.

References LL_denied, and T_NONE.

Referenced by ll_get_conv().

05191   {
05192     rsbac_log_entry_t     * new_aci = new_data;
05193     rsbac_old_log_entry_t * old_aci = old_data;
05194     int i;
05195 
05196     memcpy(new_desc, old_desc, sizeof(rsbac_adf_request_int_t));
05197     for(i=0; i < T_NONE - 1; i++)
05198       (*new_aci)[i] = (*old_aci)[i];
05199     (*new_aci)[T_NONE - 1] = LL_denied;
05200     (*new_aci)[T_NONE] = (*old_aci)[T_NONE - 1];
05201     return 0;
05202   }

rsbac_list_conv_function_t* ll_get_conv ( rsbac_version_t  old_version  ) 

Definition at line 5223 of file debug.c.

References ll_conv(), ll_old_conv(), NULL, RSBAC_LOG_LEVEL_OLD_OLD_VERSION, and RSBAC_LOG_LEVEL_OLD_VERSION.

Referenced by rsbac_init_debug().

05224   {
05225     switch(old_version)
05226       {
05227         case RSBAC_LOG_LEVEL_OLD_VERSION:
05228           return ll_conv;
05229         case RSBAC_LOG_LEVEL_OLD_OLD_VERSION:
05230           return ll_old_conv;
05231         default:
05232           return NULL;
05233       }
05234   }

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

Definition at line 5204 of file debug.c.

References LL_denied, and T_NONE.

Referenced by ll_get_conv().

05209   {
05210     rsbac_log_entry_t     * new_aci = new_data;
05211     rsbac_old_log_entry_t * old_aci = old_data;
05212     int i;
05213 
05214     memcpy(new_desc, old_desc, sizeof(rsbac_adf_request_int_t));
05215     for(i=0; i < T_NONE - 2; i++)
05216       (*new_aci)[i] = (*old_aci)[i];
05217     (*new_aci)[T_NONE - 1] = LL_denied;
05218     (*new_aci)[T_NONE - 2] = LL_denied;
05219     (*new_aci)[T_NONE] = (*old_aci)[T_NONE - 1];
05220     return 0;
05221   }

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

Definition at line 1006 of file debug.c.

References rsbac_no_defaults.

01007     {
01008       rsbac_no_defaults = 1;
01009       return 1;
01010     }

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

Definition at line 271 of file debug.c.

Referenced by sys_rsbac_adf_log_switch().

00274   {
00275     if(   (request < R_NONE)
00276        && (target <= T_NONE)
00277        && (value <= LL_full)
00278       )
00279       {
00280         rsbac_log_levels[request][target] = value;
00281         if(log_levels_handle)
00282           rsbac_list_add(log_levels_handle, &request, rsbac_log_levels[request]);
00283       }
00284   };

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

Definition at line 997 of file debug.c.

References NULL, rsbac_flags, and rsbac_flags_set().

00998 {
00999         rsbac_flags = simple_strtoul(line, NULL, 0);
01000         rsbac_flags_set(rsbac_flags);
01001         return 1;
01002 }

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

Definition at line 286 of file debug.c.

Referenced by sys_rsbac_get_adf_log().

00289   {
00290     if(   (request < R_NONE)
00291        && (target <= T_NONE)
00292       )
00293       {
00294         *value_p = rsbac_log_levels[request][target];
00295         return 0;
00296       }
00297     else
00298       return -RSBAC_EINVALIDVALUE;
00299   }

void __init rsbac_init_debug ( void   )  [inline]

Definition at line 5244 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().

05246   {
05247     int i;
05248     #if defined(CONFIG_RSBAC_PROC)
05249     struct proc_dir_entry * tmp_entry_p;
05250     #endif
05251 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
05252 #if defined(CONFIG_RSBAC_LOG_REMOTE)
05253     struct task_struct * rsbaclogd_thread;
05254 #endif
05255 #endif
05256 
05257     if (!debug_initialized)
05258       {
05259         struct rsbac_list_info_t * info_p;
05260         int tmperr;
05261         rsbac_enum_t * def_data_p;
05262 
05263         rsbac_printk(KERN_INFO "rsbac_init_debug(): Initializing\n");
05264         info_p = rsbac_kmalloc(sizeof(*info_p));
05265         if(!info_p)
05266           {
05267             memset(rsbac_log_levels, LL_denied, sizeof(rsbac_log_levels));
05268             return;
05269           }
05270         def_data_p = rsbac_kmalloc(sizeof(rsbac_log_entry_t));
05271         if(!def_data_p)
05272           {
05273             memset(rsbac_log_levels, LL_denied, sizeof(rsbac_log_levels));
05274             rsbac_kfree(info_p);
05275             return;
05276           }
05277         /* register log_levels list */
05278         for(i=0; i<=T_NONE; i++)
05279           def_data_p[i] = LL_denied;
05280         info_p->version = RSBAC_LOG_LEVEL_VERSION;
05281         info_p->key = RSBAC_LOG_LEVEL_KEY;
05282         info_p->desc_size = sizeof(rsbac_adf_request_int_t);
05283         info_p->data_size = sizeof(rsbac_log_entry_t);
05284         info_p->max_age = 0;
05285         tmperr = rsbac_list_register(RSBAC_LIST_VERSION,
05286                                      &log_levels_handle,
05287                                      info_p,
05288                                      RSBAC_LIST_PERSIST | RSBAC_LIST_DEF_DATA,
05289                                      NULL,
05290                                      ll_get_conv,
05291                                      def_data_p,
05292                                      RSBAC_LOG_LEVEL_LIST_NAME,
05293                                      RSBAC_AUTO_DEV);
05294         if(tmperr)
05295           {
05296             char * tmp;
05297 
05298             tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
05299             if(tmp)
05300               {
05301                 rsbac_printk(KERN_WARNING
05302                        "rsbac_init_debug(): registering log levels list ll failed with error %s!\n",
05303                        get_error_name(tmp, tmperr));
05304                 rsbac_kfree(tmp);
05305               }
05306             memset(rsbac_log_levels, LL_denied, sizeof(rsbac_log_levels));
05307           }
05308         else
05309           {
05310             rsbac_adf_request_int_t req;
05311 
05312             for(req = 0; req < R_NONE; req++)
05313               rsbac_list_get_data(log_levels_handle, &req, rsbac_log_levels[req]);
05314           }
05315 
05316         #if defined(CONFIG_RSBAC_PROC)
05317         tmp_entry_p = create_proc_entry("log_levels",
05318                                         S_IFREG | S_IRUGO | S_IWUGO,
05319                                         proc_rsbac_root_p);
05320         if(tmp_entry_p)
05321           {
05322             tmp_entry_p->get_info = log_levels_proc_info;
05323             tmp_entry_p->write_proc = log_levels_proc_write;
05324           }
05325 
05326         tmp_entry_p = create_proc_entry("debug",
05327                                         S_IFREG | S_IRUGO | S_IWUGO,
05328                                         proc_rsbac_root_p);
05329         if(tmp_entry_p)
05330           {
05331             tmp_entry_p->get_info = debug_proc_info;
05332             tmp_entry_p->write_proc = debug_proc_write;
05333           }
05334 
05335         #if defined(CONFIG_RSBAC_RMSG)
05336         tmp_entry_p = create_proc_entry("rmsg",
05337                                         S_IFREG | S_IRUGO,
05338                                         proc_rsbac_root_p);
05339         if(tmp_entry_p)
05340           {
05341             tmp_entry_p->proc_fops = &proc_rmsg_operations;
05342           }
05343         #endif
05344         #endif
05345 
05346         #if defined(CONFIG_RSBAC_LOG_REMOTE)
05347         /* Start rsbac logging thread for auto write */
05348         if(!rsbac_log_remote_port)
05349           rsbac_log_remote_port = htons(CONFIG_RSBAC_LOG_REMOTE_PORT);
05350         tmperr = rsbac_net_str_to_inet(rsbac_log_remote_addr_string,
05351                                     &rsbac_log_remote_addr);
05352         if(tmperr < 0)
05353           {
05354             char * tmp = rsbac_kmalloc(RSBAC_MAXNAMELEN);
05355 
05356             if(tmp)
05357               {
05358                 get_error_name(tmp, tmperr);
05359                 rsbac_printk(KERN_WARNING
05360                              "rsbac_init_debug(): converting remote socket address %s failed with error %s, exiting!\n",
05361                              rsbac_log_remote_addr_string,
05362                              tmp);
05363                 rsbac_log_remote_addr = 0;
05364                 rsbac_kfree(tmp);
05365               }
05366           }
05367 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
05368         rsbaclogd_thread = kthread_create(rsbaclogd, NULL, "rsbaclogd");
05369         wake_up_process(rsbaclogd_thread);
05370 #else
05371         rsbaclogd_pid = kernel_thread(rsbaclogd, NULL, 0);
05372 #endif
05373         rsbac_printk(KERN_INFO "rsbac_init_debug(): Started rsbaclogd thread with pid %u\n",
05374                rsbaclogd_pid);
05375         #endif
05376 
05377         #ifdef CONFIG_RSBAC_SYSLOG_RATE
05378         init_timer(&rsbac_syslog_rate_timer);
05379         rsbac_syslog_rate_timer.function = syslog_rate_reset;
05380         rsbac_syslog_rate_timer.data = 0;
05381         rsbac_syslog_rate_timer.expires = jiffies + HZ;
05382         add_timer(&rsbac_syslog_rate_timer);
05383         #endif
05384 
05385         debug_initialized = TRUE;
05386       }
05387 
05388     #ifdef CONFIG_RSBAC_SOFTMODE
05389     if(rsbac_softmode)
05390       rsbac_printk(KERN_DEBUG "rsbac_softmode is set\n");
05391     if(rsbac_softmode_prohibit)
05392       rsbac_printk(KERN_DEBUG "rsbac_softmode_prohibit is set\n");
05393     #endif
05394     #ifdef CONFIG_RSBAC_FREEZE
05395     if(rsbac_freeze)
05396       rsbac_printk(KERN_DEBUG "rsbac_freeze is set\n");
05397     #endif
05398     #if defined(CONFIG_RSBAC_UM_EXCL)
05399     if(rsbac_um_no_excl)
05400       rsbac_printk(KERN_DEBUG "rsbac_um_no_excl is set\n");
05401     #endif
05402     #if defined(CONFIG_RSBAC_DAZ_CACHE)
05403     rsbac_printk(KERN_DEBUG "rsbac_daz_ttl is %u\n",
05404                  rsbac_daz_get_ttl());
05405     #endif
05406     #if defined(CONFIG_RSBAC_AUTH_LEARN)
05407     if(rsbac_auth_learn)
05408       rsbac_printk(KERN_DEBUG "rsbac_auth_learn is set\n");
05409     #endif
05410     #if defined(CONFIG_RSBAC_ACL_LEARN)
05411     if(rsbac_acl_learn_fd)
05412       rsbac_printk(KERN_DEBUG "rsbac_acl_learn_fd is set\n");
05413     #endif
05414     #ifdef CONFIG_RSBAC_CAP_PROC_HIDE
05415     if(rsbac_cap_process_hiding)
05416       rsbac_printk(KERN_DEBUG "rsbac_cap_process_hiding is set\n");
05417     #endif
05418     #ifdef CONFIG_RSBAC_CAP_LOG_MISSING
05419     if(rsbac_cap_log_missing)
05420       rsbac_printk(KERN_DEBUG "rsbac_cap_log_missing is set\n");
05421     #endif
05422     #ifdef CONFIG_RSBAC_JAIL_LOG_MISSING
05423     if(rsbac_jail_log_missing)
05424       rsbac_printk(KERN_DEBUG "rsbac_jail_log_missing is set\n");
05425     #endif
05426     #ifdef CONFIG_RSBAC_ALLOW_DAC_DISABLE_FULL
05427     if(rsbac_dac_disable)
05428       rsbac_printk(KERN_DEBUG "rsbac_dac_disable is set\n");
05429     #endif
05430     #ifdef CONFIG_RSBAC_RMSG_NOSYSLOG
05431     if(rsbac_nosyslog)
05432       rsbac_printk(KERN_DEBUG "rsbac_nosyslog is set\n");
05433     #endif
05434     #ifdef CONFIG_RSBAC_SYSLOG_RATE
05435     if(rsbac_syslog_rate != CONFIG_RSBAC_SYSLOG_RATE_DEF)
05436       rsbac_printk(KERN_DEBUG "rsbac_syslog_rate is %u\n",
05437                    rsbac_syslog_rate);
05438     #endif
05439 #ifdef CONFIG_RSBAC_FD_CACHE
05440     if(rsbac_fd_cache_disable) {
05441       rsbac_printk(KERN_DEBUG "rsbac_fd_cache_disable is %u\n",
05442                    rsbac_fd_cache_disable);
05443     } else {
05444       if(rsbac_fd_cache_ttl != CONFIG_RSBAC_FD_CACHE_TTL)
05445         rsbac_printk(KERN_DEBUG "rsbac_fd_cache_ttl is %u\n",
05446                      rsbac_fd_cache_ttl);
05447     }
05448 #endif
05449 #if defined(CONFIG_RSBAC_AUTO_WRITE) && (CONFIG_RSBAC_AUTO_WRITE > 0)
05450     if(rsbac_list_check_interval != CONFIG_RSBAC_LIST_CHECK_INTERVAL)
05451       rsbac_printk(KERN_DEBUG "rsbac_list_check_interval is %u\n",
05452                    rsbac_list_check_interval);
05453 #endif
05454     #ifdef CONFIG_RSBAC_INIT_DELAY
05455     if(rsbac_no_delay_init)
05456       rsbac_printk(KERN_DEBUG "rsbac_no_delay_init is set\n");
05457 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
05458     if(rsbac_delayed_root_str[0])
05459       rsbac_printk(KERN_DEBUG "rsbac_delayed_root is %s\n",
05460              rsbac_delayed_root_str);
05461 #else
05462     if(rsbac_delayed_root)
05463       rsbac_printk(KERN_DEBUG "rsbac_delayed_root is %02u:%02u\n",
05464              MAJOR(rsbac_delayed_root), MINOR(rsbac_delayed_root));
05465 #endif
05466     #endif
05467     if(rsbac_no_defaults)
05468       rsbac_printk(KERN_DEBUG "rsbac_no_defaults is set\n");
05469 
05470 #if defined(CONFIG_RSBAC_DEBUG)
05471     if(rsbac_debug_ds)
05472       rsbac_printk(KERN_DEBUG "rsbac_debug_ds is set\n");
05473     if(rsbac_debug_write)
05474       rsbac_printk(KERN_DEBUG "rsbac_debug_write is set\n");
05475     if(rsbac_debug_no_write)
05476       rsbac_printk(KERN_DEBUG "rsbac_debug_no_write is set\n");
05477     if(rsbac_debug_stack)
05478       rsbac_printk(KERN_DEBUG "rsbac_debug_stack is set\n");
05479     if(rsbac_debug_lists)
05480       rsbac_printk(KERN_DEBUG "rsbac_debug_lists is set\n");
05481     if(rsbac_debug_aef)
05482       rsbac_printk(KERN_DEBUG "rsbac_debug_aef is set\n");
05483     if(rsbac_debug_adf_default != 1)
05484       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_default is set to %i\n",
05485              rsbac_debug_adf_default);
05486 
05487     #if defined(CONFIG_RSBAC_REG)
05488     if(rsbac_debug_reg)
05489       rsbac_printk(KERN_DEBUG "rsbac_debug_reg is set\n");
05490     #endif
05491 
05492     #if defined(CONFIG_RSBAC_NET)
05493     if(rsbac_debug_ds_net)
05494       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_net is set\n");
05495     if(rsbac_debug_aef_net)
05496       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_net is set\n");
05497     if(rsbac_debug_adf_net)
05498       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_net is set\n");
05499     #endif
05500 
05501     #if defined(CONFIG_RSBAC_MAC)
05502     if(rsbac_debug_ds_mac)
05503       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_mac is set\n");
05504     if(rsbac_debug_aef_mac)
05505       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_mac is set\n");
05506     if(rsbac_debug_adf_mac)
05507       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_mac is set\n");
05508     #endif
05509 
05510     #if defined(CONFIG_RSBAC_PM)
05511     if(rsbac_debug_ds_pm)
05512       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_pm is set\n");
05513     if(rsbac_debug_aef_pm)
05514       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_pm is set\n");
05515     if(rsbac_debug_adf_pm)
05516       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_pm is set\n");
05517     #endif
05518 
05519     #if defined(CONFIG_RSBAC_DAZ)
05520     if(rsbac_debug_adf_daz)
05521       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_daz is set\n");
05522     #endif
05523 
05524     #if defined(CONFIG_RSBAC_RC)
05525     if(rsbac_debug_ds_rc)
05526       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_rc is set\n");
05527     if(rsbac_debug_aef_rc)
05528       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_rc is set\n");
05529     if(rsbac_debug_adf_rc)
05530       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_rc is set\n");
05531     #endif
05532 
05533     #if defined(CONFIG_RSBAC_AUTH)
05534     if(rsbac_debug_ds_auth)
05535       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_auth is set\n");
05536     if(rsbac_debug_aef_auth)
05537       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_auth is set\n");
05538     if(rsbac_debug_adf_auth)
05539       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_auth is set\n");
05540     #endif
05541 
05542     #if defined(CONFIG_RSBAC_ACL)
05543     if(rsbac_debug_ds_acl)
05544       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_acl is set\n");
05545     if(rsbac_debug_aef_acl)
05546       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_acl is set\n");
05547     if(rsbac_debug_adf_acl)
05548       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_acl is set\n");
05549     #endif
05550 
05551     #if defined(CONFIG_RSBAC_JAIL)
05552     if(rsbac_debug_aef_jail)
05553       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_jail is set\n");
05554     if(rsbac_debug_adf_jail)
05555       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_jail is set\n");
05556     #endif
05557 
05558     #if defined(CONFIG_RSBAC_PAX)
05559     if(rsbac_debug_adf_pax)
05560       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_pax is set\n");
05561     #endif
05562 
05563     #if defined(CONFIG_RSBAC_UM)
05564     if(rsbac_debug_ds_um)
05565       rsbac_printk(KERN_DEBUG "rsbac_debug_ds_um is set\n");
05566     if(rsbac_debug_aef_um)
05567       rsbac_printk(KERN_DEBUG "rsbac_debug_aef_um is set\n");
05568     if(rsbac_debug_adf_um)
05569       rsbac_printk(KERN_DEBUG "rsbac_debug_adf_um is set\n");
05570     #endif
05571 
05572     #if defined(CONFIG_RSBAC_AUTO_WRITE) && (CONFIG_RSBAC_AUTO_WRITE > 0)
05573     if(rsbac_debug_auto)
05574       rsbac_printk(KERN_DEBUG "rsbac_debug_auto is set\n");
05575     #endif
05576 #endif /* DEBUG */
05577 
05578   }

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

Definition at line 1819 of file debug.c.

References log_seq, NULL, rsbac_is_initialized(), rsbac_kmalloc(), and RSBAC_LOG_MAXLINE.

Referenced by _dazuko_find_slot(), _dazuko_unregister_daemon(), aci_detach_fd_lists(), acl_create_def(), acl_create_def2(), acl_detach_fd_lists(), acl_register_fd_lists(), add_item(), add_lol_item(), add_lol_subitem(), adjust_in_out_pp(), adjust_in_out_pp_ipc(), auth_detach_fd_lists(), auth_register_fd_lists(), auto_read_attr(), auto_read_write_attr(), auto_write_attr(), call_xp_atomic_dec(), call_xp_atomic_inc(), call_xp_atomic_read(), call_xp_atomic_set(), call_xp_compare_file(), call_xp_copy_file(), call_xp_copyin(), call_xp_copyout(), call_xp_destroy_mutex(), call_xp_destroy_queue(), call_xp_destroy_rwlock(), call_xp_down(), call_xp_fill_file_struct(), call_xp_free(), call_xp_id_compare(), call_xp_id_copy(), call_xp_id_free(), call_xp_init_mutex(), call_xp_init_queue(), call_xp_init_rwlock(), call_xp_is_absolute_path(), call_xp_malloc(), call_xp_notify(), call_xp_read_lock(), call_xp_read_unlock(), call_xp_up(), call_xp_verify_user_readable(), call_xp_verify_user_writable(), call_xp_wait_until_condition(), call_xp_write_lock(), call_xp_write_unlock(), check_comp_rc(), check_flags_ff(), cleanup_module(), create_def_roles(), create_def_roles2(), daz_check_secoff(), daz_ignored(), dazuko_exit(), dazuko_get_an_access(), dazuko_handle_request(), dazuko_handle_user_request_compat12(), dazuko_init(), dazuko_is_selected(), dazuko_register_daemon(), dazuko_set_option(), dazuko_sys_pre(), do_read_list(), do_read_lol_list(), do_remove_lol_item(), get_attr_fd(), get_ipc_purpose(), init_module(), linux_dazuko_device_ioctl(), linux_dazuko_device_read(), linux_dazuko_device_write(), lookup_aci_path_dentry(), mac_detach_fd_lists(), mac_register_fd_lists(), na_and_pp_ipc(), na_and_pp_or_cs(), na_dev(), na_ipc(), pm_get_file(), read_info(), read_list(), read_lol_list(), register_fd_lists(), register_user_lists1(), register_user_lists2(), 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_pm(), 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_pm(), rsbac_adf_set_attr_rc(), 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_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_auto_rehash(), 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_max_items(), rsbac_list_lol_no_write(), rsbac_list_lol_register_hashed(), rsbac_list_max_items(), rsbac_list_no_write(), rsbac_list_register_hashed(), 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(), rsbac_pm_change_current_task(), rsbac_pm_create_file(), 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_select_fd_create_type(), 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_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_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_get_switch(), 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(), tp_check(), write_info(), xp_print(), xp_sys_hook(), and xp_sys_unhook().

01820 {
01821         va_list args;
01822         int printed_len;
01823         char * buf;
01824 #if defined(CONFIG_RSBAC_RMSG)
01825         struct rsbac_log_list_item_t * log_item;
01826 #endif
01827 
01828         if (rsbac_is_initialized())
01829                 buf = rsbac_kmalloc(RSBAC_LOG_MAXLINE);
01830         else
01831                 buf = kmalloc(RSBAC_LOG_MAXLINE, GFP_ATOMIC);
01832         if (!buf)
01833                 return -ENOMEM;
01834         /* Emit the output into the buffer */
01835         va_start(args, fmt);
01836         printed_len = vsnprintf(buf + 11, RSBAC_LOG_MAXLINE - 14, fmt, args);
01837         va_end(args);
01838         if(printed_len < 4) {
01839                 kfree(buf);
01840                 return printed_len;
01841         }
01842         buf[0] = '<';
01843         buf[1] = buf[12];
01844         buf[2] = '>';
01845         sprintf(buf + 3, "%010u", log_seq++);
01846         buf[13] = '|';
01847         /* Terminate string */
01848         buf[printed_len + 11] = 0;
01849 
01850         /* copy to printk */
01851 #ifdef CONFIG_RSBAC_RMSG_NOSYSLOG
01852         if (!rsbac_nosyslog)
01853 #endif
01854         {
01855 #ifdef CONFIG_RSBAC_SYSLOG_RATE
01856                 syslog_count++;
01857                 if(syslog_count < rsbac_syslog_rate)
01858 #endif
01859                         printk("%s", buf);
01860 #ifdef CONFIG_RSBAC_SYSLOG_RATE
01861                 else
01862                         if(syslog_count == rsbac_syslog_rate)
01863                                 printk(KERN_INFO "rsbac_printk: Applying syslog rate limit at count %u, message %u!\n",
01864                                         syslog_count, log_seq - 1);
01865 #endif
01866         }
01867         /* Buffer is ready, now link into log list */
01868 #if defined(CONFIG_RSBAC_RMSG)
01869         if (rsbac_is_initialized())
01870                 log_item = rsbac_kmalloc(sizeof(*log_item) + printed_len + 12);
01871         else
01872                 log_item = kmalloc(sizeof(*log_item) + printed_len + 12, GFP_ATOMIC);
01873         if(log_item) {
01874                 memcpy(log_item->buffer, buf, printed_len + 11);
01875                 log_item->size = printed_len + 11;
01876                 log_item->next = NULL;
01877                 spin_lock(&rsbac_log_lock);
01878                 if (log_list_head.tail) {
01879                         log_list_head.tail->next = log_item;
01880                 } else {
01881                         log_list_head.head = log_item;
01882                 }
01883                 log_list_head.tail = log_item;
01884                 log_list_head.count++;
01885                 while(log_list_head.count > rsbac_rmsg_maxentries) {
01886                         log_item = log_list_head.head;
01887                         log_list_head.head = log_item->next;
01888                         log_list_head.count--;
01889                         log_list_head.lost++;
01890                         kfree(log_item);
01891                 }
01892                 spin_unlock(&rsbac_log_lock);
01893                 wake_up_interruptible(&rlog_wait);
01894         }
01895 #endif
01896 
01897 #if defined(CONFIG_RSBAC_LOG_REMOTE)
01898         /* Link into remote log list */
01899         if (rsbac_is_initialized())
01900                 log_item = rsbac_kmalloc(sizeof(*log_item) + printed_len + 12);
01901         else
01902                 log_item = kmalloc(sizeof(*log_item) + printed_len + 12, GFP_ATOMIC);
01903         if(log_item) {
01904                 memcpy(log_item->buffer, buf, printed_len + 11);
01905                 log_item->size = printed_len + 11;
01906                 log_item->next = NULL;
01907                 spin_lock(&rsbac_log_remote_lock);
01908                 if (remote_log_list_head.tail) {
01909                         remote_log_list_head.tail->next = log_item;
01910                 } else {
01911                         remote_log_list_head.head = log_item;
01912                 }
01913                 remote_log_list_head.tail = log_item;
01914                 remote_log_list_head.count++;
01915                 while(remote_log_list_head.count > rsbac_log_remote_maxentries) {
01916                         log_item = remote_log_list_head.head;
01917                         remote_log_list_head.head = log_item->next;
01918                         remote_log_list_head.count--;
01919                         remote_log_list_head.lost++;
01920                         kfree(log_item);
01921                 }
01922                 spin_unlock(&rsbac_log_remote_lock);
01923 #ifdef CONFIG_RSBAC_LOG_REMOTE_SYNC
01924                 wake_up_interruptible(&rsbaclogd_wait);
01925 #endif
01926         }
01927 #endif
01928 
01929         kfree(buf);
01930         return printed_len;
01931 }


Variable Documentation

rsbac_boolean_t debug_initialized = FALSE [static]

Definition at line 46 of file debug.c.

Referenced by rsbac_init_debug().

rsbac_list_handle_t log_levels_handle = NULL [static]

Definition at line 181 of file debug.c.

Referenced by rsbac_adf_log_switch(), and rsbac_init_debug().

u_int log_seq = 0 [static]

Definition at line 219 of file debug.c.

Referenced by rsbac_printk().

int rsbac_debug_adf_default = 1

Definition at line 238 of file debug.c.

Referenced by rsbac_init_debug().

rsbac_boolean_t rsbac_debug_adf_dirty = FALSE

Definition at line 241 of file debug.c.

int rsbac_debug_no_write = 0

Definition at line 44 of file debug.c.

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

unsigned long int rsbac_flags

Definition at line 41 of file debug.c.

Referenced by rsbac_flags_setup().

rsbac_log_entry_t rsbac_log_levels[R_NONE+1]

Definition at line 239 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 179 of file debug.c.

Referenced by acl_create_def2(), no_defaults_setup(), register_user_lists1(), register_user_lists2(), rsbac_flags_set(), rsbac_init_acl(), rsbac_init_debug(), and rsbac_init_rc().


Generated on Wed May 16 11:54:31 2007 for RSBAC by  doxygen 1.5.1