---

bank.c File Reference

#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/bank.h>
#include <asm/bug.h>

Go to the source code of this file.

Defines
#define	dprintk(format)
#define	ELSACCT_MIN_PID   1024
Functions
elsa_bank *	elsa_bank_alloc (void)
void	elsa_bank_free (struct elsa_bank *b)
int	elsa_bank_add (struct bank_root *br, struct elsa_bank *b, int(*fn)(int, struct elsa_bank *, struct elsa_data *), void *info)
int	elsa_bank_remove (struct elsa_bank *b)
elsa_data *	elsa_data_alloc (void)
void	elsa_data_free (struct elsa_data *d)
int	elsa_data_add (struct elsa_bank *b, struct elsa_data *d)
int	elsa_data_remove (struct elsa_bank *b, struct elsa_data *d)
elsa_bank *	elsa_get_bank (struct bank_root *br, __u32 bid)
elsa_data *	elsa_get_data (pid_t pid, __u32 bid)
	EXPORT_SYMBOL (elsa_bank_alloc)

---

Define Documentation

#define dprintk (  format    )

Definition at line 31 of file bank.c. Referenced by elsa_bank_add(), elsa_bank_free(), elsa_bank_remove(), elsa_data_add(), elsa_data_free(), and elsacct_ioctl().

#define ELSACCT_MIN_PID   1024

Definition at line 34 of file bank.c. Referenced by elsa_data_add(), and elsa_data_remove().

---

Function Documentation

int elsa_bank_add (  struct bank_root *    br, struct elsa_bank *    b, int(*    fn)(int, struct elsa_bank *, struct elsa_data *), void *    info )

elsa_bank_add - Add a new bank to a bank's root @br: a pointer to bank's root @b: a pointer to a bank @fn: pointer to a callback called when bank or data are destroyed @info: pointer that can be used to store information Description: Add a new bank in the bank_root. It associates a callback to a bank. The callback will be called each time a bank or a data will be removed. pointer @info can be used to store usefull informations at bank level. Definition at line 102 of file bank.c. References dprintk. Referenced by elsacct_ioctl(). { /* * give it an id. As it must be unique. As this function is only * called from ioctl (drivers/erlsacct/elsacct.c) which is protected * by a spinlock, we know that only one instance will be execute. * Currently we only used next_bid field but this mechnism * can give problems if we use many banks and the bid go through * its maximum */ b->bid = br->next_bid++; if (b->bid <= 0) { printk("elsa_bank_alloc: can not find bank identifier\n"); return 0; } /* Initialize fields */ b->info = info; b->callback = fn; /* * add the new bank to the list of banks */ list_add(&(b->bank_list), &(br->bank_head)); dprintk("elsa_bank_alloc: bank #%d created\n", b->bid); return b->bid; }

struct elsa_bank* elsa_bank_alloc (  void    )

elsa_bank_alloc - Allocates a new bank Description: allocates a new bank and returns the new created bank. Definition at line 48 of file bank.c. References elsa_bank_alloc(). Referenced by elsa_bank_alloc(), and elsacct_ioctl(). { struct elsa_bank *b; /* allocate space for the new bank */ b = (struct elsa_bank *)kmalloc(sizeof(struct elsa_bank), GFP_KERNEL); if (!b) { printk("elsa_bank_alloc: cannot allocate space\n"); return NULL; } /* Initialize fields */ b->info = NULL; b->callback = NULL; INIT_LIST_HEAD(&(b->data_head)); return b; }

void elsa_bank_free (  struct elsa_bank *    b )

elsa_bank_free - Frees space occupied by a bank. @bank: a pointer to the bank to delete Description: Free space used by bank Definition at line 73 of file bank.c. References dprintk. Referenced by elsacct_ioctl(), and elsacct_process_remove(). { /* * Before releasing kernel memory occupied by the bank * we can do some action. We do it here instead of * elsa_bank_remove() because elsa_bank_remove() is * called in a spinlock and the callback write records into * a file (and so cannot be done in a spinlock) */ if (b->callback) { (b->callback) (ELSA_BANK_CALLBACK, b, NULL); } dprintk("elsa_bank_free: bank released\n"); kfree(b); }

int elsa_bank_remove (  struct elsa_bank *    b )

elsa_bank_remove - remove a bank from the list of banks @b: a pointer to a bank Description: remove a bank from a bank_root and returns the identifier of the removed bank. When this function is called bank _MUST_ be empty. Here are different steps of the operation: 1) Write accounting information 2) Remove it from the list of banks Definition at line 147 of file bank.c. References dprintk. Referenced by elsacct_ioctl(), and elsacct_process_remove(). { BUG_ON(b == NULL); BUG_ON(!list_empty(&b->data_head)); /* * remove bank from the bank's list */ list_del(&(b->bank_list)); dprintk("elsa_bank_remove: bank #%d removed\n", b->bid); return b->bid; }

int elsa_data_add (  struct elsa_bank *    b, struct elsa_data *    d )

elsa_data_add - Add a process to a given bank : pointer to a bank : pointer to a process Description: add a data to a bank by setting lists. Other fields are unchanged If an error is encountered, a negative value is returned. It can not return 0. Here are steps to perform: 1) Check arguments 2) Check if process is already in the bank 3) Initialize its fields 4) Return BID Definition at line 216 of file bank.c. References dprintk, and ELSACCT_MIN_PID. Referenced by elsacct_ioctl(), and elsacct_process_copy(). { static int present; if (!b || !d || !(d->process)) { dprintk("elsa_data_add: Wrong parameters\n"); return -EINVAL; } /* Bank ID cannot be equal to 0 */ BUG_ON(b->bid == 0); if (d->process->pid < ELSACCT_MIN_PID) { dprintk("elsa_data_add: PID < %d\n", ELSACCT_MIN_PID); return -EINVAL; } /* check if process is already present */ present = elsa_process_present(d->process, b); if (present) { /* Process already in the bank, so we can not add it */ return -EPERM; } /* Set BID */ d->bid = b->bid; /* Add data in the list of bank's data */ list_add(&(d->data_list), &(b->data_head)); /* * Add data in the list of process's bank. We modify task struct so we * need to protect that. */ write_lock_irq(&tasklist_lock); list_add(&(d->bank_list), &(d->process->bank_head)); write_unlock_irq(&tasklist_lock); dprintk("elsa_data_add: Add process #%d to bank #%d\n", d->process->pid, b->bid); return b->bid; }

struct elsa_data* elsa_data_alloc (  void    )

elsa_data_alloc - Allocates a new data Description: allocates a new data and returns the new created item. If an error is encountered NULL is returned. Here are different steps of the operation: 1) Allocate space for the new data 2) Initialize different fields Definition at line 171 of file bank.c. References elsa_data_alloc(). Referenced by elsa_data_alloc(), elsacct_ioctl(), and elsacct_process_copy(). { static struct elsa_data *d; /* allocate space for the new data */ d = (struct elsa_data *)kmalloc(sizeof(struct elsa_data), GFP_KERNEL); if (!d) { printk("elsa_data_alloc: cannot allocate space\n"); return NULL; } /* Initialize fields */ d->bid = 0; d->process = NULL; INIT_LIST_HEAD(&(d->data_list)); INIT_LIST_HEAD(&(d->bank_list)); return d; }

void elsa_data_free (  struct elsa_data *    d )

elsa_data_free - Free data @d: pointer to data to be removed Description: releases memory used by data. Definition at line 197 of file bank.c. References dprintk. Referenced by elsacct_ioctl(), elsacct_process_copy(), and elsacct_process_remove(). { dprintk("elsa_data_free: data released\n"); kfree(d); }

int elsa_data_remove (  struct elsa_bank *    b, struct elsa_data *    d )

elsa_data_remove - Remove a process to a given bank @b: pointer to the bank @d: pointer to the process Description: removes a given process from a given bank. Return 0 if succedeed, BID of the bank if it is empty and negative value otherwise Definition at line 269 of file bank.c. References ELSACCT_MIN_PID. Referenced by elsacct_ioctl(), and elsacct_process_remove(). { if (!d) return -EINVAL; BUG_ON(d->process->pid < ELSACCT_MIN_PID); /* callback, we are in the child so callback code */ if (b && b->callback) { (b->callback) (ELSA_DATA_CALLBACK, b, d); } /* remove data from the list of data */ list_del(&d->data_list); /* Need access to head_list in task_struct */ /* We are in a spin_lock */ write_lock_irq(&tasklist_lock); list_del(&d->bank_list); write_unlock_irq(&tasklist_lock); if (list_empty(&(b->data_head))) /* bank is empty so we return its BID */ return b->bid; return 0; /* sucess and bank isn't empty */ }

struct elsa_bank* elsa_get_bank (  struct bank_root *    br, __u32    bid )

elsa_get_bank - Returns a pointer to a bank @br: pointer to the root of banks @bid: the identifier of a bank Description: finds the bank with given ID in the list of banks Definition at line 305 of file bank.c. Referenced by elsacct_ioctl(), elsacct_process_copy(), and elsacct_process_remove(). { static struct list_head *entry; static struct elsa_bank *b; if (bid == 0) return NULL; /* * We traverse the list searching for entries without changing * the list itself, so we use read_lock_irqsave */ list_for_each(entry, &(br->bank_head)) { b = list_entry(entry, struct elsa_bank, bank_list); if (b->bid == bid) { return b; } } /* We don't find the bank with corresponding BID */ return NULL; }

struct elsa_data* elsa_get_data (  pid_t    pid, __u32    bid )

elsa_get_data - Returns a pointer to an &elsa_data @pid: The identifier of the process @bid: The identifier of a bank Description: returns a pointer to the container of a given pid in a given bank. If the data isn't found, NULL is returned. Definition at line 336 of file bank.c. Referenced by elsacct_ioctl(). { static struct list_head *entry; /* entry == NULL */ static struct task_struct *p; /* p == NULL */ static struct elsa_data *d; /* d == NULL */ read_lock(&tasklist_lock); p = find_task_by_pid(pid); read_unlock(&tasklist_lock); if ((p == NULL) || (bid == 0)) return NULL; list_for_each(entry, &(p->bank_head)) { d = list_entry(entry, struct elsa_data, bank_list); /* bank can not be empty */ BUG_ON(d == NULL); if (d->bid == bid) { /* Got it */ return d; } } return NULL; }

EXPORT_SYMBOL (  elsa_bank_alloc    )

elsa_get_first - Returns a pointer to the first element of a list @head: a pointer to the head of a list Description: returns a pointer to the first data in a list. If list is empty, NULL is returned.

---