#include <linux/module.h>#include <linux/config.h>#include <linux/init.h>#include <linux/errno.h>#include <linux/fs.h>#include <linux/proc_fs.h>#include <linux/seq_file.h>#include <linux/slab.h>#include <linux/string.h>#include <linux/blkdev.h>#include <linux/times.h>#include <linux/elsacct.h>#include <linux/bank.h>#include <asm/uaccess.h>Go to the source code of this file.
Defines | |
| #define | dprintk(format...) |
| #define | ELSACCT_FILE "/var/log/bank" |
| #define | MANTSIZE 13 |
| #define | EXPSIZE 3 |
| #define | MAXFRACT ((1 << MANTSIZE) - 1) |
Typedefs | |
| typedef __u16 | comp_t |
Functions | |
| int | do_elsacct (int opcode, struct elsa_bank *b, struct elsa_data *d) |
| void | elsacct_process_copy (struct task_struct *from, struct task_struct *to) |
| void | elsacct_process_remove (struct task_struct *p) |
| int | elsacct_ioctl (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) |
| module_init (elsacct_init_module) | |
| module_exit (elsacct_cleanup_module) | |
| MODULE_DESCRIPTION ("Enhanced Linux System Accounting.") | |
| MODULE_AUTHOR ("Guillaume Thouvenin< guillaume.thouvenin @bull.net >") | |
| MODULE_LICENSE ("GPL") | |
Variables | |
| file_operations | elsa_fops |
|
|
Definition at line 35 of file elsacct.c. Referenced by elsacct_ioctl(). |
|
|
|
|
|
|
|
|
encode_comp_t - encode an unsigned long into a comp_t @value: value to encode Description: This routine has been adopted from the encode_comp_t() function in the kern_acct.c file of the FreeBSD operating system. The encoding is a 13-bit fraction with a 3-bit (base 8) exponent. This routine is taken from kernel/acct.c |
|
|
|
|
|
|
|
||||||||||||||||
|
do_elsacct - choose the write accounting treatment @opcode: operation to perform @b: pointer to a bank @d: pointer to a data Description: it allows to choose to update accounting information when a data is removed from a bank or to dump information if a bank is removed. Definition at line 201 of file elsacct.c. Referenced by elsacct_ioctl().
00202 {
00203 int retval = 0;
00204
00205 switch (opcode) {
00206 case ELSA_BANK_CALLBACK:
00207 BUG_ON(b == NULL);
00208 retval = do_elsacct_bank(b);
00209 break;
00210 case ELSA_DATA_CALLBACK:
00211 BUG_ON(b == NULL);
00212 BUG_ON(d == NULL);
00213 retval = do_elsacct_data(b, d);
00214 break;
00215 default:
00216 printk("do_elsacct: unknown opcode\n");
00217 retval = -ENOIOCTLCMD;
00218 break;
00219 }
00220
00221 return retval;
00222 }
|
|
||||||||||||||||||||
|
elsacct_ioctl - issue a device specific command @inode: pointer to inode structure @filp : file pointer @cmd : specific command to perform.
Definition at line 332 of file elsacct.c. References do_elsacct(), dprintk, elsa_bank_add(), elsa_bank_alloc(), elsa_bank_free(), elsa_bank_remove(), elsa_data_add(), elsa_data_alloc(), elsa_data_free(), elsa_data_remove(), elsa_get_bank(), and elsa_get_data().
00334 {
00335 static int retval; /* retval == 0 */
00336 static struct elsa_ioctl_args iarg;
00337 static struct task_struct *p;
00338 static struct elsa_bank *b;
00339 static struct elsa_data *d;
00340
00341 /* We can make some checks */
00342 if (_IOC_TYPE(cmd) != ELSACCT_MAGIC)
00343 return -ENOTTY;
00344 if (_IOC_NR(cmd) > ELSACCT_MAXNR)
00345 return -ENOTTY;
00346 if ((cmd != ELSACCT_PROCESS_ADD) && (cmd != ELSACCT_PROCESS_REMOVE) &&
00347 (cmd != ELSACCT_PROCESS_REMOVE_ALL) && (cmd != ELSACCT_BANK_CLEAN))
00348 return -ENOTTY;
00349
00350 if (!access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd)))
00351 return -EFAULT;
00352
00353 /* Recover ioctl parameters */
00354 if (copy_from_user(&iarg, (struct elsa_ioctl_args *)arg,
00355 sizeof(struct elsa_ioctl_args))) {
00356 return -EFAULT;
00357 }
00358
00359 dprintk("ELSAIOCTL: iarg = {bid#%d - pid#%d}\n", iarg.bid, iarg.pid);
00360
00361 switch (cmd) {
00362 case ELSACCT_PROCESS_ADD:
00363 /*
00364 * To add a process to a bank we need to perform
00365 * following actions:
00366 * 1) Allocate memory space to data (container)
00367 * 2) Allocate memory space to a bank or get a
00368 * pointer to an existing bank if BID != 0
00369 * 3) Update process in data field
00370 * 4) Add the container to the bank
00371 */
00372 /*
00373 * We need the pointer to task_struct. We catch it now so if
00374 * it fails we will not allocate memory for new data
00375 */
00376 read_lock(&tasklist_lock);
00377 p = find_task_by_pid(iarg.pid);
00378 read_unlock(&tasklist_lock);
00379 if (!p) {
00380 dprintk("elsacct_ioct: PID#%d not found\n", iarg.pid);
00381 return -EAGAIN;
00382 }
00383
00384 d = elsa_data_alloc();
00385 if (!d) {
00386 return -ENOMEM;
00387 }
00388
00389 if (iarg.bid == 0) {
00390 struct elsa_acct *acctinfo;
00391 int bid;
00392
00393 acctinfo = (struct elsa_acct *)
00394 kmalloc(sizeof(struct elsa_acct), GFP_KERNEL);
00395 if (!acctinfo) {
00396 printk
00397 ("ELSA: cannot allocate space for accounting \n");
00398 return -ENOMEM;
00399 }
00400
00401 b = elsa_bank_alloc();
00402 if (!b) {
00403 dprintk("elsacct_ioct: cannot create BID\n");
00404 /* release memory */
00405 elsa_data_free(d);
00406 kfree(acctinfo);
00407 return -ENOMEM;
00408 }
00409
00410 /* Macro to initialize accounting informations */
00411 elsa_acct_init(acctinfo);
00412
00413 spin_lock_irq(&elsa_lock);
00414 bid = elsa_bank_add(&elsa_br, b, &do_elsacct, acctinfo);
00415 spin_unlock_irq(&elsa_lock);
00416
00417 if (!bid) {
00418 dprintk
00419 ("elsacct_ioct: error during bank creation\n");
00420 /* release memory */
00421 elsa_data_free(d);
00422 elsa_bank_free(b);
00423 kfree(acctinfo);
00424 return -EFAULT;
00425 }
00426 } else {
00427 b = elsa_get_bank(&elsa_br, iarg.bid);
00428 if (!b) {
00429 dprintk("elsacct_ioct: BID#%d not found\n",
00430 iarg.bid);
00431 /* release memory */
00432 elsa_data_free(d);
00433 return -EINVAL;
00434 }
00435 }
00436
00437 /* At this point, b cannot be NULL */
00438
00439 d->process = p;
00440
00441 spin_lock_irq(&elsa_lock);
00442 retval = elsa_data_add(b, d);
00443 spin_unlock_irq(&elsa_lock);
00444 break;
00445
00446 case ELSACCT_PROCESS_REMOVE:
00447 /*
00448 * We want to remove a process from one given bank
00449 * Steps are:
00450 * 1) get a pointer to the given bank
00451 * 2) get a pointer to the container of the process
00452 * 3) remove the process
00453 * 4) free memory used by it
00454 * 5) release bank if empty
00455 */
00456 spin_lock_irq(&elsa_lock);
00457
00458 b = elsa_get_bank(&elsa_br, iarg.bid);
00459 if (!b) {
00460 spin_unlock_irq(&elsa_lock);
00461 dprintk("EBR: bank not found\n");
00462 return -EINVAL;
00463 }
00464
00465 d = elsa_get_data(iarg.pid, iarg.bid);
00466 if (!d) {
00467 spin_unlock_irq(&elsa_lock);
00468 dprintk("EBR: data not found\n");
00469 return -EINVAL;
00470 }
00471
00472 retval = elsa_data_remove(b, d);
00473
00474 elsa_data_free(d);
00475
00476 if (retval) {
00477 dprintk("EBR: Bank is now empty\n");
00478
00479 elsa_bank_remove(b);
00480
00481 dprintk("EBR: bank release\n");
00482
00483 spin_unlock_irq(&elsa_lock);
00484 kfree(b->info);
00485 elsa_bank_free(b);
00486 } else {
00487 spin_unlock_irq(&elsa_lock);
00488 }
00489
00490 retval = 0;
00491 break;
00492
00493 case ELSACCT_PROCESS_REMOVE_ALL:
00494 /*
00495 * remove a process from all banks that it
00496 * belongs. To achieve this we need to:
00497 * 1) get a pointer to the process
00498 * 2) get the first data
00499 * 3) remove it from the bank
00500 * 4) release the data
00501 * 5) if necessary, remove and release bank
00502 *
00503 */
00504 read_lock(&tasklist_lock);
00505 p = find_task_by_pid(iarg.pid);
00506 read_unlock(&tasklist_lock);
00507 if (!p) {
00508 dprintk("elsacct_ioct: PID#%d not found\n", iarg.pid);
00509 return -EAGAIN;
00510 }
00511
00512 retval = 1;
00513 while (retval) {
00514 int bid;
00515
00516 spin_lock_irq(&elsa_lock);
00517
00518 read_lock(&tasklist_lock);
00519 if (list_empty(&p->bank_head)) {
00520 d = NULL;
00521 } else {
00522 d = list_entry((p->bank_head).next,
00523 struct elsa_data, bank_list);
00524 dprintk("EPRA: remove ...");
00525 BUG_ON(d == NULL);
00526 dprintk(" from bank #%d ...", d->bid);
00527 dprintk(" pid #%d\n", d->process->pid);
00528 }
00529 read_unlock(&tasklist_lock);
00530
00531 if (d != NULL) {
00532 /* We don't need to check the return value */
00533 b = elsa_get_bank(&elsa_br, d->bid);
00534 bid = elsa_data_remove(b, d);
00535
00536 elsa_data_free(d);
00537
00538 if (bid) {
00539 /* bank is empty */
00540 elsa_bank_remove(b);
00541 /*
00542 * unlock before releasing memory
00543 * occupied by the bank
00544 */
00545 spin_unlock_irq(&elsa_lock);
00546 kfree(b->info);
00547 elsa_bank_free(b);
00548 }
00549 } else {
00550 dprintk
00551 ("EPRA: Process removed from all banks\n");
00552 retval = 0;
00553 spin_unlock_irq(&elsa_lock);
00554 }
00555
00556 }
00557 break;
00558
00559 case ELSACCT_BANK_CLEAN:
00560 /*
00561 * remove all process from one given bank
00562 * Steps are:
00563 * 1) get a pointer to the given bank
00564 * 2) while there is data in the bank
00565 * -> remove the data
00566 * 3) release bank
00567 */
00568 spin_lock_irq(&elsa_lock);
00569 b = elsa_get_bank(&elsa_br, iarg.bid);
00570
00571 if (!b) {
00572 spin_unlock_irq(&elsa_lock);
00573 dprintk("EBC: bank not found\n");
00574 return -EINVAL;
00575 }
00576
00577 retval = 1;
00578 while (retval) {
00579
00580 if (list_empty(&b->data_head)) {
00581 d = NULL;
00582 } else {
00583 d = list_entry((b->data_head).next,
00584 struct elsa_data, data_list);
00585 }
00586
00587 if (d) {
00588 dprintk("EBC: Remove pid#%d from bank#%d\n",
00589 d->process->pid, b->bid);
00590 /* We don't need to check the return value */
00591 elsa_data_remove(b, d);
00592 elsa_data_free(d);
00593 } else {
00594 retval = 0;
00595 dprintk("EBC: Bank#%d is now empty\n", b->bid);
00596 }
00597 }
00598
00599 /* bank is empty */
00600 elsa_bank_remove(b);
00601
00602 spin_unlock_irq(&elsa_lock);
00603 kfree(b->info);
00604 elsa_bank_free(b);
00605
00606 break;
00607
00608 default:
00609 /*
00610 * The POSIX standard, states that if an inappropriate ioctl command
00611 * has been issued, then -ENOTTY should be returned.
00612 */
00613 retval = -ENOTTY;
00614 };
00615
00616 return retval;
00617 }
|
|
||||||||||||
|
Definition at line 225 of file elsacct.c. References elsa_data_add(), elsa_data_alloc(), elsa_data_free(), and elsa_get_bank().
00226 {
00227 static struct list_head *entry; /* entry == NULL */
00228 static struct elsa_bank *b; /* b == NULL */
00229 static struct elsa_data *d; /* d == NULL */
00230 static struct elsa_data *new_d; /* d == NULL */
00231
00232 /*
00233 * First, initialize to->bank_head otherwise, if
00234 * from->bank_head is NULL it won't be initialize
00235 */
00236 write_lock_irq(&tasklist_lock);
00237 INIT_LIST_HEAD(&(to->bank_head));
00238 write_unlock_irq(&tasklist_lock);
00239
00240 list_for_each(entry, &from->bank_head) {
00241 read_lock_irq(&tasklist_lock);
00242 d = list_entry(entry, struct elsa_data, bank_list);
00243 read_unlock_irq(&tasklist_lock);
00244
00245 new_d = elsa_data_alloc();
00246 if (new_d) {
00247 spin_lock_irq(&elsa_lock);
00248 b = elsa_get_bank(&elsa_br, d->bid);
00249 if (!b) {
00250 /* release memory */
00251 elsa_data_free(new_d);
00252 } else {
00253 new_d->process = to;
00254 if (!elsa_data_add(b, new_d))
00255 elsa_data_free(new_d);
00256 }
00257 spin_unlock_irq(&elsa_lock);
00258 }
00259 }
00260 }
|
|
|
Definition at line 263 of file elsacct.c. References elsa_bank_free(), elsa_bank_remove(), elsa_data_free(), elsa_data_remove(), and elsa_get_bank().
00264 {
00265 static struct elsa_data *d; /* d == NULL */
00266 static struct elsa_bank *b; /* b == NULL */
00267 int empty = 0;
00268
00269 while (!empty) {
00270 int bid;
00271
00272 spin_lock_irq(&elsa_lock);
00273
00274 read_lock(&tasklist_lock);
00275 if (list_empty(&p->bank_head)) {
00276 d = NULL;
00277 } else {
00278 d = list_entry((p->bank_head).next,
00279 struct elsa_data, bank_list);
00280 }
00281 read_unlock(&tasklist_lock);
00282
00283 if (d != NULL) {
00284 /* We don't need to check the return value */
00285 b = elsa_get_bank(&elsa_br, d->bid);
00286 bid = elsa_data_remove(b, d);
00287
00288 elsa_data_free(d);
00289
00290 if (bid) {
00291 /* bank is empty */
00292 elsa_bank_remove(b);
00293 /*
00294 * unlock before releasing memory used by
00295 * the bank
00296 */
00297 spin_unlock_irq(&elsa_lock);
00298 kfree(b->info);
00299 elsa_bank_free(b);
00300 }
00301 } else {
00302 empty = 1;
00303 spin_unlock_irq(&elsa_lock);
00304 }
00305
00306 }
00307 }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Initial value: {
.owner = THIS_MODULE,
.ioctl = elsacct_ioctl,
} |
1.2.18