Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *   S/390 debug facility
0004  *
0005  *    Copyright IBM Corp. 1999, 2020
0006  *
0007  *    Author(s): Michael Holzheu (holzheu@de.ibm.com),
0008  *       Holger Smolinski (Holger.Smolinski@de.ibm.com)
0009  *
0010  *    Bugreports to: <Linux390@de.ibm.com>
0011  */
0012 
0013 #define KMSG_COMPONENT "s390dbf"
0014 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
0015 
0016 #include <linux/stddef.h>
0017 #include <linux/kernel.h>
0018 #include <linux/errno.h>
0019 #include <linux/slab.h>
0020 #include <linux/ctype.h>
0021 #include <linux/string.h>
0022 #include <linux/sysctl.h>
0023 #include <linux/uaccess.h>
0024 #include <linux/export.h>
0025 #include <linux/init.h>
0026 #include <linux/fs.h>
0027 #include <linux/minmax.h>
0028 #include <linux/debugfs.h>
0029 
0030 #include <asm/debug.h>
0031 
0032 #define DEBUG_PROLOG_ENTRY -1
0033 
0034 #define ALL_AREAS 0 /* copy all debug areas */
0035 #define NO_AREAS  1 /* copy no debug areas */
0036 
0037 /* typedefs */
0038 
0039 typedef struct file_private_info {
0040     loff_t offset;          /* offset of last read in file */
0041     int    act_area;        /* number of last formated area */
0042     int    act_page;        /* act page in given area */
0043     int    act_entry;       /* last formated entry (offset */
0044                     /* relative to beginning of last */
0045                     /* formated page) */
0046     size_t act_entry_offset;    /* up to this offset we copied */
0047                     /* in last read the last formated */
0048                     /* entry to userland */
0049     char   temp_buf[2048];      /* buffer for output */
0050     debug_info_t *debug_info_org;   /* original debug information */
0051     debug_info_t *debug_info_snap;  /* snapshot of debug information */
0052     struct debug_view *view;    /* used view of debug info */
0053 } file_private_info_t;
0054 
0055 typedef struct {
0056     char *string;
0057     /*
0058      * This assumes that all args are converted into longs
0059      * on L/390 this is the case for all types of parameter
0060      * except of floats, and long long (32 bit)
0061      *
0062      */
0063     long args[0];
0064 } debug_sprintf_entry_t;
0065 
0066 /* internal function prototyes */
0067 
0068 static int debug_init(void);
0069 static ssize_t debug_output(struct file *file, char __user *user_buf,
0070                 size_t user_len, loff_t *offset);
0071 static ssize_t debug_input(struct file *file, const char __user *user_buf,
0072                size_t user_len, loff_t *offset);
0073 static int debug_open(struct inode *inode, struct file *file);
0074 static int debug_close(struct inode *inode, struct file *file);
0075 static debug_info_t *debug_info_create(const char *name, int pages_per_area,
0076                        int nr_areas, int buf_size, umode_t mode);
0077 static void debug_info_get(debug_info_t *);
0078 static void debug_info_put(debug_info_t *);
0079 static int debug_prolog_level_fn(debug_info_t *id,
0080                  struct debug_view *view, char *out_buf);
0081 static int debug_input_level_fn(debug_info_t *id, struct debug_view *view,
0082                 struct file *file, const char __user *user_buf,
0083                 size_t user_buf_size, loff_t *offset);
0084 static int debug_prolog_pages_fn(debug_info_t *id,
0085                  struct debug_view *view, char *out_buf);
0086 static int debug_input_pages_fn(debug_info_t *id, struct debug_view *view,
0087                 struct file *file, const char __user *user_buf,
0088                 size_t user_buf_size, loff_t *offset);
0089 static int debug_input_flush_fn(debug_info_t *id, struct debug_view *view,
0090                 struct file *file, const char __user *user_buf,
0091                 size_t user_buf_size, loff_t *offset);
0092 static int debug_hex_ascii_format_fn(debug_info_t *id, struct debug_view *view,
0093                      char *out_buf, const char *in_buf);
0094 static int debug_sprintf_format_fn(debug_info_t *id, struct debug_view *view,
0095                    char *out_buf, debug_sprintf_entry_t *curr_event);
0096 static void debug_areas_swap(debug_info_t *a, debug_info_t *b);
0097 static void debug_events_append(debug_info_t *dest, debug_info_t *src);
0098 
0099 /* globals */
0100 
0101 struct debug_view debug_hex_ascii_view = {
0102     "hex_ascii",
0103     NULL,
0104     &debug_dflt_header_fn,
0105     &debug_hex_ascii_format_fn,
0106     NULL,
0107     NULL
0108 };
0109 EXPORT_SYMBOL(debug_hex_ascii_view);
0110 
0111 static struct debug_view debug_level_view = {
0112     "level",
0113     &debug_prolog_level_fn,
0114     NULL,
0115     NULL,
0116     &debug_input_level_fn,
0117     NULL
0118 };
0119 
0120 static struct debug_view debug_pages_view = {
0121     "pages",
0122     &debug_prolog_pages_fn,
0123     NULL,
0124     NULL,
0125     &debug_input_pages_fn,
0126     NULL
0127 };
0128 
0129 static struct debug_view debug_flush_view = {
0130     "flush",
0131     NULL,
0132     NULL,
0133     NULL,
0134     &debug_input_flush_fn,
0135     NULL
0136 };
0137 
0138 struct debug_view debug_sprintf_view = {
0139     "sprintf",
0140     NULL,
0141     &debug_dflt_header_fn,
0142     (debug_format_proc_t *)&debug_sprintf_format_fn,
0143     NULL,
0144     NULL
0145 };
0146 EXPORT_SYMBOL(debug_sprintf_view);
0147 
0148 /* used by dump analysis tools to determine version of debug feature */
0149 static unsigned int __used debug_feature_version = __DEBUG_FEATURE_VERSION;
0150 
0151 /* static globals */
0152 
0153 static debug_info_t *debug_area_first;
0154 static debug_info_t *debug_area_last;
0155 static DEFINE_MUTEX(debug_mutex);
0156 
0157 static int initialized;
0158 static int debug_critical;
0159 
0160 static const struct file_operations debug_file_ops = {
0161     .owner   = THIS_MODULE,
0162     .read    = debug_output,
0163     .write   = debug_input,
0164     .open    = debug_open,
0165     .release = debug_close,
0166     .llseek  = no_llseek,
0167 };
0168 
0169 static struct dentry *debug_debugfs_root_entry;
0170 
0171 /* functions */
0172 
0173 /*
0174  * debug_areas_alloc
0175  * - Debug areas are implemented as a threedimensonal array:
0176  *   areas[areanumber][pagenumber][pageoffset]
0177  */
0178 
0179 static debug_entry_t ***debug_areas_alloc(int pages_per_area, int nr_areas)
0180 {
0181     debug_entry_t ***areas;
0182     int i, j;
0183 
0184     areas = kmalloc_array(nr_areas, sizeof(debug_entry_t **), GFP_KERNEL);
0185     if (!areas)
0186         goto fail_malloc_areas;
0187     for (i = 0; i < nr_areas; i++) {
0188         /* GFP_NOWARN to avoid user triggerable WARN, we handle fails */
0189         areas[i] = kmalloc_array(pages_per_area,
0190                      sizeof(debug_entry_t *),
0191                      GFP_KERNEL | __GFP_NOWARN);
0192         if (!areas[i])
0193             goto fail_malloc_areas2;
0194         for (j = 0; j < pages_per_area; j++) {
0195             areas[i][j] = kzalloc(PAGE_SIZE, GFP_KERNEL);
0196             if (!areas[i][j]) {
0197                 for (j--; j >= 0 ; j--)
0198                     kfree(areas[i][j]);
0199                 kfree(areas[i]);
0200                 goto fail_malloc_areas2;
0201             }
0202         }
0203     }
0204     return areas;
0205 
0206 fail_malloc_areas2:
0207     for (i--; i >= 0; i--) {
0208         for (j = 0; j < pages_per_area; j++)
0209             kfree(areas[i][j]);
0210         kfree(areas[i]);
0211     }
0212     kfree(areas);
0213 fail_malloc_areas:
0214     return NULL;
0215 }
0216 
0217 /*
0218  * debug_info_alloc
0219  * - alloc new debug-info
0220  */
0221 static debug_info_t *debug_info_alloc(const char *name, int pages_per_area,
0222                       int nr_areas, int buf_size, int level,
0223                       int mode)
0224 {
0225     debug_info_t *rc;
0226 
0227     /* alloc everything */
0228     rc = kmalloc(sizeof(debug_info_t), GFP_KERNEL);
0229     if (!rc)
0230         goto fail_malloc_rc;
0231     rc->active_entries = kcalloc(nr_areas, sizeof(int), GFP_KERNEL);
0232     if (!rc->active_entries)
0233         goto fail_malloc_active_entries;
0234     rc->active_pages = kcalloc(nr_areas, sizeof(int), GFP_KERNEL);
0235     if (!rc->active_pages)
0236         goto fail_malloc_active_pages;
0237     if ((mode == ALL_AREAS) && (pages_per_area != 0)) {
0238         rc->areas = debug_areas_alloc(pages_per_area, nr_areas);
0239         if (!rc->areas)
0240             goto fail_malloc_areas;
0241     } else {
0242         rc->areas = NULL;
0243     }
0244 
0245     /* initialize members */
0246     spin_lock_init(&rc->lock);
0247     rc->pages_per_area = pages_per_area;
0248     rc->nr_areas       = nr_areas;
0249     rc->active_area    = 0;
0250     rc->level      = level;
0251     rc->buf_size       = buf_size;
0252     rc->entry_size     = sizeof(debug_entry_t) + buf_size;
0253     strlcpy(rc->name, name, sizeof(rc->name));
0254     memset(rc->views, 0, DEBUG_MAX_VIEWS * sizeof(struct debug_view *));
0255     memset(rc->debugfs_entries, 0, DEBUG_MAX_VIEWS * sizeof(struct dentry *));
0256     refcount_set(&(rc->ref_count), 0);
0257 
0258     return rc;
0259 
0260 fail_malloc_areas:
0261     kfree(rc->active_pages);
0262 fail_malloc_active_pages:
0263     kfree(rc->active_entries);
0264 fail_malloc_active_entries:
0265     kfree(rc);
0266 fail_malloc_rc:
0267     return NULL;
0268 }
0269 
0270 /*
0271  * debug_areas_free
0272  * - free all debug areas
0273  */
0274 static void debug_areas_free(debug_info_t *db_info)
0275 {
0276     int i, j;
0277 
0278     if (!db_info->areas)
0279         return;
0280     for (i = 0; i < db_info->nr_areas; i++) {
0281         for (j = 0; j < db_info->pages_per_area; j++)
0282             kfree(db_info->areas[i][j]);
0283         kfree(db_info->areas[i]);
0284     }
0285     kfree(db_info->areas);
0286     db_info->areas = NULL;
0287 }
0288 
0289 /*
0290  * debug_info_free
0291  * - free memory debug-info
0292  */
0293 static void debug_info_free(debug_info_t *db_info)
0294 {
0295     debug_areas_free(db_info);
0296     kfree(db_info->active_entries);
0297     kfree(db_info->active_pages);
0298     kfree(db_info);
0299 }
0300 
0301 /*
0302  * debug_info_create
0303  * - create new debug-info
0304  */
0305 
0306 static debug_info_t *debug_info_create(const char *name, int pages_per_area,
0307                        int nr_areas, int buf_size, umode_t mode)
0308 {
0309     debug_info_t *rc;
0310 
0311     rc = debug_info_alloc(name, pages_per_area, nr_areas, buf_size,
0312                   DEBUG_DEFAULT_LEVEL, ALL_AREAS);
0313     if (!rc)
0314         goto out;
0315 
0316     rc->mode = mode & ~S_IFMT;
0317     refcount_set(&rc->ref_count, 1);
0318 out:
0319     return rc;
0320 }
0321 
0322 /*
0323  * debug_info_copy
0324  * - copy debug-info
0325  */
0326 static debug_info_t *debug_info_copy(debug_info_t *in, int mode)
0327 {
0328     unsigned long flags;
0329     debug_info_t *rc;
0330     int i, j;
0331 
0332     /* get a consistent copy of the debug areas */
0333     do {
0334         rc = debug_info_alloc(in->name, in->pages_per_area,
0335             in->nr_areas, in->buf_size, in->level, mode);
0336         spin_lock_irqsave(&in->lock, flags);
0337         if (!rc)
0338             goto out;
0339         /* has something changed in the meantime ? */
0340         if ((rc->pages_per_area == in->pages_per_area) &&
0341             (rc->nr_areas == in->nr_areas)) {
0342             break;
0343         }
0344         spin_unlock_irqrestore(&in->lock, flags);
0345         debug_info_free(rc);
0346     } while (1);
0347 
0348     if (mode == NO_AREAS)
0349         goto out;
0350 
0351     for (i = 0; i < in->nr_areas; i++) {
0352         for (j = 0; j < in->pages_per_area; j++)
0353             memcpy(rc->areas[i][j], in->areas[i][j], PAGE_SIZE);
0354     }
0355 out:
0356     spin_unlock_irqrestore(&in->lock, flags);
0357     return rc;
0358 }
0359 
0360 /*
0361  * debug_info_get
0362  * - increments reference count for debug-info
0363  */
0364 static void debug_info_get(debug_info_t *db_info)
0365 {
0366     if (db_info)
0367         refcount_inc(&db_info->ref_count);
0368 }
0369 
0370 /*
0371  * debug_info_put:
0372  * - decreases reference count for debug-info and frees it if necessary
0373  */
0374 static void debug_info_put(debug_info_t *db_info)
0375 {
0376     if (!db_info)
0377         return;
0378     if (refcount_dec_and_test(&db_info->ref_count))
0379         debug_info_free(db_info);
0380 }
0381 
0382 /*
0383  * debug_format_entry:
0384  * - format one debug entry and return size of formated data
0385  */
0386 static int debug_format_entry(file_private_info_t *p_info)
0387 {
0388     debug_info_t *id_snap   = p_info->debug_info_snap;
0389     struct debug_view *view = p_info->view;
0390     debug_entry_t *act_entry;
0391     size_t len = 0;
0392 
0393     if (p_info->act_entry == DEBUG_PROLOG_ENTRY) {
0394         /* print prolog */
0395         if (view->prolog_proc)
0396             len += view->prolog_proc(id_snap, view, p_info->temp_buf);
0397         goto out;
0398     }
0399     if (!id_snap->areas) /* this is true, if we have a prolog only view */
0400         goto out;    /* or if 'pages_per_area' is 0 */
0401     act_entry = (debug_entry_t *) ((char *)id_snap->areas[p_info->act_area]
0402                        [p_info->act_page] + p_info->act_entry);
0403 
0404     if (act_entry->clock == 0LL)
0405         goto out; /* empty entry */
0406     if (view->header_proc)
0407         len += view->header_proc(id_snap, view, p_info->act_area,
0408                      act_entry, p_info->temp_buf + len);
0409     if (view->format_proc)
0410         len += view->format_proc(id_snap, view, p_info->temp_buf + len,
0411                      DEBUG_DATA(act_entry));
0412 out:
0413     return len;
0414 }
0415 
0416 /*
0417  * debug_next_entry:
0418  * - goto next entry in p_info
0419  */
0420 static inline int debug_next_entry(file_private_info_t *p_info)
0421 {
0422     debug_info_t *id;
0423 
0424     id = p_info->debug_info_snap;
0425     if (p_info->act_entry == DEBUG_PROLOG_ENTRY) {
0426         p_info->act_entry = 0;
0427         p_info->act_page  = 0;
0428         goto out;
0429     }
0430     if (!id->areas)
0431         return 1;
0432     p_info->act_entry += id->entry_size;
0433     /* switch to next page, if we reached the end of the page  */
0434     if (p_info->act_entry > (PAGE_SIZE - id->entry_size)) {
0435         /* next page */
0436         p_info->act_entry = 0;
0437         p_info->act_page += 1;
0438         if ((p_info->act_page % id->pages_per_area) == 0) {
0439             /* next area */
0440             p_info->act_area++;
0441             p_info->act_page = 0;
0442         }
0443         if (p_info->act_area >= id->nr_areas)
0444             return 1;
0445     }
0446 out:
0447     return 0;
0448 }
0449 
0450 /*
0451  * debug_output:
0452  * - called for user read()
0453  * - copies formated debug entries to the user buffer
0454  */
0455 static ssize_t debug_output(struct file *file,      /* file descriptor */
0456                 char __user *user_buf,  /* user buffer */
0457                 size_t len,         /* length of buffer */
0458                 loff_t *offset)     /* offset in the file */
0459 {
0460     size_t count = 0;
0461     size_t entry_offset;
0462     file_private_info_t *p_info;
0463 
0464     p_info = (file_private_info_t *) file->private_data;
0465     if (*offset != p_info->offset)
0466         return -EPIPE;
0467     if (p_info->act_area >= p_info->debug_info_snap->nr_areas)
0468         return 0;
0469     entry_offset = p_info->act_entry_offset;
0470     while (count < len) {
0471         int formatted_line_residue;
0472         int formatted_line_size;
0473         int user_buf_residue;
0474         size_t copy_size;
0475 
0476         formatted_line_size = debug_format_entry(p_info);
0477         formatted_line_residue = formatted_line_size - entry_offset;
0478         user_buf_residue = len-count;
0479         copy_size = min(user_buf_residue, formatted_line_residue);
0480         if (copy_size) {
0481             if (copy_to_user(user_buf + count, p_info->temp_buf
0482                      + entry_offset, copy_size))
0483                 return -EFAULT;
0484             count += copy_size;
0485             entry_offset += copy_size;
0486         }
0487         if (copy_size == formatted_line_residue) {
0488             entry_offset = 0;
0489             if (debug_next_entry(p_info))
0490                 goto out;
0491         }
0492     }
0493 out:
0494     p_info->offset       = *offset + count;
0495     p_info->act_entry_offset = entry_offset;
0496     *offset = p_info->offset;
0497     return count;
0498 }
0499 
0500 /*
0501  * debug_input:
0502  * - called for user write()
0503  * - calls input function of view
0504  */
0505 static ssize_t debug_input(struct file *file, const char __user *user_buf,
0506                size_t length, loff_t *offset)
0507 {
0508     file_private_info_t *p_info;
0509     int rc = 0;
0510 
0511     mutex_lock(&debug_mutex);
0512     p_info = ((file_private_info_t *) file->private_data);
0513     if (p_info->view->input_proc) {
0514         rc = p_info->view->input_proc(p_info->debug_info_org,
0515                           p_info->view, file, user_buf,
0516                           length, offset);
0517     } else {
0518         rc = -EPERM;
0519     }
0520     mutex_unlock(&debug_mutex);
0521     return rc; /* number of input characters */
0522 }
0523 
0524 /*
0525  * debug_open:
0526  * - called for user open()
0527  * - copies formated output to private_data area of the file
0528  *   handle
0529  */
0530 static int debug_open(struct inode *inode, struct file *file)
0531 {
0532     debug_info_t *debug_info, *debug_info_snapshot;
0533     file_private_info_t *p_info;
0534     int i, rc = 0;
0535 
0536     mutex_lock(&debug_mutex);
0537     debug_info = file_inode(file)->i_private;
0538     /* find debug view */
0539     for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
0540         if (!debug_info->views[i])
0541             continue;
0542         else if (debug_info->debugfs_entries[i] == file->f_path.dentry)
0543             goto found; /* found view ! */
0544     }
0545     /* no entry found */
0546     rc = -EINVAL;
0547     goto out;
0548 
0549 found:
0550 
0551     /* Make snapshot of current debug areas to get it consistent.     */
0552     /* To copy all the areas is only needed, if we have a view which  */
0553     /* formats the debug areas. */
0554 
0555     if (!debug_info->views[i]->format_proc && !debug_info->views[i]->header_proc)
0556         debug_info_snapshot = debug_info_copy(debug_info, NO_AREAS);
0557     else
0558         debug_info_snapshot = debug_info_copy(debug_info, ALL_AREAS);
0559 
0560     if (!debug_info_snapshot) {
0561         rc = -ENOMEM;
0562         goto out;
0563     }
0564     p_info = kmalloc(sizeof(file_private_info_t), GFP_KERNEL);
0565     if (!p_info) {
0566         debug_info_free(debug_info_snapshot);
0567         rc = -ENOMEM;
0568         goto out;
0569     }
0570     p_info->offset = 0;
0571     p_info->debug_info_snap = debug_info_snapshot;
0572     p_info->debug_info_org  = debug_info;
0573     p_info->view = debug_info->views[i];
0574     p_info->act_area = 0;
0575     p_info->act_page = 0;
0576     p_info->act_entry = DEBUG_PROLOG_ENTRY;
0577     p_info->act_entry_offset = 0;
0578     file->private_data = p_info;
0579     debug_info_get(debug_info);
0580     nonseekable_open(inode, file);
0581 out:
0582     mutex_unlock(&debug_mutex);
0583     return rc;
0584 }
0585 
0586 /*
0587  * debug_close:
0588  * - called for user close()
0589  * - deletes  private_data area of the file handle
0590  */
0591 static int debug_close(struct inode *inode, struct file *file)
0592 {
0593     file_private_info_t *p_info;
0594 
0595     p_info = (file_private_info_t *) file->private_data;
0596     if (p_info->debug_info_snap)
0597         debug_info_free(p_info->debug_info_snap);
0598     debug_info_put(p_info->debug_info_org);
0599     kfree(file->private_data);
0600     return 0; /* success */
0601 }
0602 
0603 /* Create debugfs entries and add to internal list. */
0604 static void _debug_register(debug_info_t *id)
0605 {
0606     /* create root directory */
0607     id->debugfs_root_entry = debugfs_create_dir(id->name,
0608                             debug_debugfs_root_entry);
0609 
0610     /* append new element to linked list */
0611     if (!debug_area_first) {
0612         /* first element in list */
0613         debug_area_first = id;
0614         id->prev = NULL;
0615     } else {
0616         /* append element to end of list */
0617         debug_area_last->next = id;
0618         id->prev = debug_area_last;
0619     }
0620     debug_area_last = id;
0621     id->next = NULL;
0622 
0623     debug_register_view(id, &debug_level_view);
0624     debug_register_view(id, &debug_flush_view);
0625     debug_register_view(id, &debug_pages_view);
0626 }
0627 
0628 /**
0629  * debug_register_mode() - creates and initializes debug area.
0630  *
0631  * @name:   Name of debug log (e.g. used for debugfs entry)
0632  * @pages_per_area: Number of pages, which will be allocated per area
0633  * @nr_areas:   Number of debug areas
0634  * @buf_size:   Size of data area in each debug entry
0635  * @mode:   File mode for debugfs files. E.g. S_IRWXUGO
0636  * @uid:    User ID for debugfs files. Currently only 0 is supported.
0637  * @gid:    Group ID for debugfs files. Currently only 0 is supported.
0638  *
0639  * Return:
0640  * - Handle for generated debug area
0641  * - %NULL if register failed
0642  *
0643  * Allocates memory for a debug log.
0644  * Must not be called within an interrupt handler.
0645  */
0646 debug_info_t *debug_register_mode(const char *name, int pages_per_area,
0647                   int nr_areas, int buf_size, umode_t mode,
0648                   uid_t uid, gid_t gid)
0649 {
0650     debug_info_t *rc = NULL;
0651 
0652     /* Since debugfs currently does not support uid/gid other than root, */
0653     /* we do not allow gid/uid != 0 until we get support for that. */
0654     if ((uid != 0) || (gid != 0))
0655         pr_warn("Root becomes the owner of all s390dbf files in sysfs\n");
0656     BUG_ON(!initialized);
0657 
0658     /* create new debug_info */
0659     rc = debug_info_create(name, pages_per_area, nr_areas, buf_size, mode);
0660     if (rc) {
0661         mutex_lock(&debug_mutex);
0662         _debug_register(rc);
0663         mutex_unlock(&debug_mutex);
0664     } else {
0665         pr_err("Registering debug feature %s failed\n", name);
0666     }
0667     return rc;
0668 }
0669 EXPORT_SYMBOL(debug_register_mode);
0670 
0671 /**
0672  * debug_register() - creates and initializes debug area with default file mode.
0673  *
0674  * @name:   Name of debug log (e.g. used for debugfs entry)
0675  * @pages_per_area: Number of pages, which will be allocated per area
0676  * @nr_areas:   Number of debug areas
0677  * @buf_size:   Size of data area in each debug entry
0678  *
0679  * Return:
0680  * - Handle for generated debug area
0681  * - %NULL if register failed
0682  *
0683  * Allocates memory for a debug log.
0684  * The debugfs file mode access permissions are read and write for user.
0685  * Must not be called within an interrupt handler.
0686  */
0687 debug_info_t *debug_register(const char *name, int pages_per_area,
0688                  int nr_areas, int buf_size)
0689 {
0690     return debug_register_mode(name, pages_per_area, nr_areas, buf_size,
0691                    S_IRUSR | S_IWUSR, 0, 0);
0692 }
0693 EXPORT_SYMBOL(debug_register);
0694 
0695 /**
0696  * debug_register_static() - registers a static debug area
0697  *
0698  * @id: Handle for static debug area
0699  * @pages_per_area: Number of pages per area
0700  * @nr_areas: Number of debug areas
0701  *
0702  * Register debug_info_t defined using DEFINE_STATIC_DEBUG_INFO.
0703  *
0704  * Note: This function is called automatically via an initcall generated by
0705  *   DEFINE_STATIC_DEBUG_INFO.
0706  */
0707 void debug_register_static(debug_info_t *id, int pages_per_area, int nr_areas)
0708 {
0709     unsigned long flags;
0710     debug_info_t *copy;
0711 
0712     if (!initialized) {
0713         pr_err("Tried to register debug feature %s too early\n",
0714                id->name);
0715         return;
0716     }
0717 
0718     copy = debug_info_alloc("", pages_per_area, nr_areas, id->buf_size,
0719                 id->level, ALL_AREAS);
0720     if (!copy) {
0721         pr_err("Registering debug feature %s failed\n", id->name);
0722 
0723         /* Clear pointers to prevent tracing into released initdata. */
0724         spin_lock_irqsave(&id->lock, flags);
0725         id->areas = NULL;
0726         id->active_pages = NULL;
0727         id->active_entries = NULL;
0728         spin_unlock_irqrestore(&id->lock, flags);
0729 
0730         return;
0731     }
0732 
0733     /* Replace static trace area with dynamic copy. */
0734     spin_lock_irqsave(&id->lock, flags);
0735     debug_events_append(copy, id);
0736     debug_areas_swap(id, copy);
0737     spin_unlock_irqrestore(&id->lock, flags);
0738 
0739     /* Clear pointers to initdata and discard copy. */
0740     copy->areas = NULL;
0741     copy->active_pages = NULL;
0742     copy->active_entries = NULL;
0743     debug_info_free(copy);
0744 
0745     mutex_lock(&debug_mutex);
0746     _debug_register(id);
0747     mutex_unlock(&debug_mutex);
0748 }
0749 
0750 /* Remove debugfs entries and remove from internal list. */
0751 static void _debug_unregister(debug_info_t *id)
0752 {
0753     int i;
0754 
0755     for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
0756         if (!id->views[i])
0757             continue;
0758         debugfs_remove(id->debugfs_entries[i]);
0759     }
0760     debugfs_remove(id->debugfs_root_entry);
0761     if (id == debug_area_first)
0762         debug_area_first = id->next;
0763     if (id == debug_area_last)
0764         debug_area_last = id->prev;
0765     if (id->prev)
0766         id->prev->next = id->next;
0767     if (id->next)
0768         id->next->prev = id->prev;
0769 }
0770 
0771 /**
0772  * debug_unregister() - give back debug area.
0773  *
0774  * @id:     handle for debug log
0775  *
0776  * Return:
0777  *    none
0778  */
0779 void debug_unregister(debug_info_t *id)
0780 {
0781     if (!id)
0782         return;
0783     mutex_lock(&debug_mutex);
0784     _debug_unregister(id);
0785     mutex_unlock(&debug_mutex);
0786 
0787     debug_info_put(id);
0788 }
0789 EXPORT_SYMBOL(debug_unregister);
0790 
0791 /*
0792  * debug_set_size:
0793  * - set area size (number of pages) and number of areas
0794  */
0795 static int debug_set_size(debug_info_t *id, int nr_areas, int pages_per_area)
0796 {
0797     debug_info_t *new_id;
0798     unsigned long flags;
0799 
0800     if (!id || (nr_areas <= 0) || (pages_per_area < 0))
0801         return -EINVAL;
0802 
0803     new_id = debug_info_alloc("", pages_per_area, nr_areas, id->buf_size,
0804                   id->level, ALL_AREAS);
0805     if (!new_id) {
0806         pr_info("Allocating memory for %i pages failed\n",
0807             pages_per_area);
0808         return -ENOMEM;
0809     }
0810 
0811     spin_lock_irqsave(&id->lock, flags);
0812     debug_events_append(new_id, id);
0813     debug_areas_swap(new_id, id);
0814     debug_info_free(new_id);
0815     spin_unlock_irqrestore(&id->lock, flags);
0816     pr_info("%s: set new size (%i pages)\n", id->name, pages_per_area);
0817 
0818     return 0;
0819 }
0820 
0821 /**
0822  * debug_set_level() - Sets new actual debug level if new_level is valid.
0823  *
0824  * @id:     handle for debug log
0825  * @new_level:  new debug level
0826  *
0827  * Return:
0828  *    none
0829  */
0830 void debug_set_level(debug_info_t *id, int new_level)
0831 {
0832     unsigned long flags;
0833 
0834     if (!id)
0835         return;
0836 
0837     if (new_level == DEBUG_OFF_LEVEL) {
0838         pr_info("%s: switched off\n", id->name);
0839     } else if ((new_level > DEBUG_MAX_LEVEL) || (new_level < 0)) {
0840         pr_info("%s: level %i is out of range (%i - %i)\n",
0841             id->name, new_level, 0, DEBUG_MAX_LEVEL);
0842         return;
0843     }
0844 
0845     spin_lock_irqsave(&id->lock, flags);
0846     id->level = new_level;
0847     spin_unlock_irqrestore(&id->lock, flags);
0848 }
0849 EXPORT_SYMBOL(debug_set_level);
0850 
0851 /*
0852  * proceed_active_entry:
0853  * - set active entry to next in the ring buffer
0854  */
0855 static inline void proceed_active_entry(debug_info_t *id)
0856 {
0857     if ((id->active_entries[id->active_area] += id->entry_size)
0858         > (PAGE_SIZE - id->entry_size)) {
0859         id->active_entries[id->active_area] = 0;
0860         id->active_pages[id->active_area] =
0861             (id->active_pages[id->active_area] + 1) %
0862             id->pages_per_area;
0863     }
0864 }
0865 
0866 /*
0867  * proceed_active_area:
0868  * - set active area to next in the ring buffer
0869  */
0870 static inline void proceed_active_area(debug_info_t *id)
0871 {
0872     id->active_area++;
0873     id->active_area = id->active_area % id->nr_areas;
0874 }
0875 
0876 /*
0877  * get_active_entry:
0878  */
0879 static inline debug_entry_t *get_active_entry(debug_info_t *id)
0880 {
0881     return (debug_entry_t *) (((char *) id->areas[id->active_area]
0882                    [id->active_pages[id->active_area]]) +
0883                   id->active_entries[id->active_area]);
0884 }
0885 
0886 /* Swap debug areas of a and b. */
0887 static void debug_areas_swap(debug_info_t *a, debug_info_t *b)
0888 {
0889     swap(a->nr_areas, b->nr_areas);
0890     swap(a->pages_per_area, b->pages_per_area);
0891     swap(a->areas, b->areas);
0892     swap(a->active_area, b->active_area);
0893     swap(a->active_pages, b->active_pages);
0894     swap(a->active_entries, b->active_entries);
0895 }
0896 
0897 /* Append all debug events in active area from source to destination log. */
0898 static void debug_events_append(debug_info_t *dest, debug_info_t *src)
0899 {
0900     debug_entry_t *from, *to, *last;
0901 
0902     if (!src->areas || !dest->areas)
0903         return;
0904 
0905     /* Loop over all entries in src, starting with oldest. */
0906     from = get_active_entry(src);
0907     last = from;
0908     do {
0909         if (from->clock != 0LL) {
0910             to = get_active_entry(dest);
0911             memset(to, 0, dest->entry_size);
0912             memcpy(to, from, min(src->entry_size,
0913                          dest->entry_size));
0914             proceed_active_entry(dest);
0915         }
0916 
0917         proceed_active_entry(src);
0918         from = get_active_entry(src);
0919     } while (from != last);
0920 }
0921 
0922 /*
0923  * debug_finish_entry:
0924  * - set timestamp, caller address, cpu number etc.
0925  */
0926 
0927 static inline void debug_finish_entry(debug_info_t *id, debug_entry_t *active,
0928                       int level, int exception)
0929 {
0930     unsigned long timestamp;
0931     union tod_clock clk;
0932 
0933     store_tod_clock_ext(&clk);
0934     timestamp = clk.us;
0935     timestamp -= TOD_UNIX_EPOCH >> 12;
0936     active->clock = timestamp;
0937     active->cpu = smp_processor_id();
0938     active->caller = __builtin_return_address(0);
0939     active->exception = exception;
0940     active->level = level;
0941     proceed_active_entry(id);
0942     if (exception)
0943         proceed_active_area(id);
0944 }
0945 
0946 static int debug_stoppable = 1;
0947 static int debug_active = 1;
0948 
0949 #define CTL_S390DBF_STOPPABLE 5678
0950 #define CTL_S390DBF_ACTIVE 5679
0951 
0952 /*
0953  * proc handler for the running debug_active sysctl
0954  * always allow read, allow write only if debug_stoppable is set or
0955  * if debug_active is already off
0956  */
0957 static int s390dbf_procactive(struct ctl_table *table, int write,
0958                   void *buffer, size_t *lenp, loff_t *ppos)
0959 {
0960     if (!write || debug_stoppable || !debug_active)
0961         return proc_dointvec(table, write, buffer, lenp, ppos);
0962     else
0963         return 0;
0964 }
0965 
0966 static struct ctl_table s390dbf_table[] = {
0967     {
0968         .procname   = "debug_stoppable",
0969         .data       = &debug_stoppable,
0970         .maxlen     = sizeof(int),
0971         .mode       = S_IRUGO | S_IWUSR,
0972         .proc_handler   = proc_dointvec,
0973     },
0974     {
0975         .procname   = "debug_active",
0976         .data       = &debug_active,
0977         .maxlen     = sizeof(int),
0978         .mode       = S_IRUGO | S_IWUSR,
0979         .proc_handler   = s390dbf_procactive,
0980     },
0981     { }
0982 };
0983 
0984 static struct ctl_table s390dbf_dir_table[] = {
0985     {
0986         .procname   = "s390dbf",
0987         .maxlen     = 0,
0988         .mode       = S_IRUGO | S_IXUGO,
0989         .child      = s390dbf_table,
0990     },
0991     { }
0992 };
0993 
0994 static struct ctl_table_header *s390dbf_sysctl_header;
0995 
0996 /**
0997  * debug_stop_all() - stops the debug feature if stopping is allowed.
0998  *
0999  * Return:
1000  * -   none
1001  *
1002  * Currently used in case of a kernel oops.
1003  */
1004 void debug_stop_all(void)
1005 {
1006     if (debug_stoppable)
1007         debug_active = 0;
1008 }
1009 EXPORT_SYMBOL(debug_stop_all);
1010 
1011 /**
1012  * debug_set_critical() - event/exception functions try lock instead of spin.
1013  *
1014  * Return:
1015  * -   none
1016  *
1017  * Currently used in case of stopping all CPUs but the current one.
1018  * Once in this state, functions to write a debug entry for an
1019  * event or exception no longer spin on the debug area lock,
1020  * but only try to get it and fail if they do not get the lock.
1021  */
1022 void debug_set_critical(void)
1023 {
1024     debug_critical = 1;
1025 }
1026 
1027 /*
1028  * debug_event_common:
1029  * - write debug entry with given size
1030  */
1031 debug_entry_t *debug_event_common(debug_info_t *id, int level, const void *buf,
1032                   int len)
1033 {
1034     debug_entry_t *active;
1035     unsigned long flags;
1036 
1037     if (!debug_active || !id->areas)
1038         return NULL;
1039     if (debug_critical) {
1040         if (!spin_trylock_irqsave(&id->lock, flags))
1041             return NULL;
1042     } else {
1043         spin_lock_irqsave(&id->lock, flags);
1044     }
1045     do {
1046         active = get_active_entry(id);
1047         memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size));
1048         if (len < id->buf_size)
1049             memset((DEBUG_DATA(active)) + len, 0, id->buf_size - len);
1050         debug_finish_entry(id, active, level, 0);
1051         len -= id->buf_size;
1052         buf += id->buf_size;
1053     } while (len > 0);
1054 
1055     spin_unlock_irqrestore(&id->lock, flags);
1056     return active;
1057 }
1058 EXPORT_SYMBOL(debug_event_common);
1059 
1060 /*
1061  * debug_exception_common:
1062  * - write debug entry with given size and switch to next debug area
1063  */
1064 debug_entry_t *debug_exception_common(debug_info_t *id, int level,
1065                       const void *buf, int len)
1066 {
1067     debug_entry_t *active;
1068     unsigned long flags;
1069 
1070     if (!debug_active || !id->areas)
1071         return NULL;
1072     if (debug_critical) {
1073         if (!spin_trylock_irqsave(&id->lock, flags))
1074             return NULL;
1075     } else {
1076         spin_lock_irqsave(&id->lock, flags);
1077     }
1078     do {
1079         active = get_active_entry(id);
1080         memcpy(DEBUG_DATA(active), buf, min(len, id->buf_size));
1081         if (len < id->buf_size)
1082             memset((DEBUG_DATA(active)) + len, 0, id->buf_size - len);
1083         debug_finish_entry(id, active, level, len <= id->buf_size);
1084         len -= id->buf_size;
1085         buf += id->buf_size;
1086     } while (len > 0);
1087 
1088     spin_unlock_irqrestore(&id->lock, flags);
1089     return active;
1090 }
1091 EXPORT_SYMBOL(debug_exception_common);
1092 
1093 /*
1094  * counts arguments in format string for sprintf view
1095  */
1096 static inline int debug_count_numargs(char *string)
1097 {
1098     int numargs = 0;
1099 
1100     while (*string) {
1101         if (*string++ == '%')
1102             numargs++;
1103     }
1104     return numargs;
1105 }
1106 
1107 /*
1108  * debug_sprintf_event:
1109  */
1110 debug_entry_t *__debug_sprintf_event(debug_info_t *id, int level, char *string, ...)
1111 {
1112     debug_sprintf_entry_t *curr_event;
1113     debug_entry_t *active;
1114     unsigned long flags;
1115     int numargs, idx;
1116     va_list ap;
1117 
1118     if (!debug_active || !id->areas)
1119         return NULL;
1120     numargs = debug_count_numargs(string);
1121 
1122     if (debug_critical) {
1123         if (!spin_trylock_irqsave(&id->lock, flags))
1124             return NULL;
1125     } else {
1126         spin_lock_irqsave(&id->lock, flags);
1127     }
1128     active = get_active_entry(id);
1129     curr_event = (debug_sprintf_entry_t *) DEBUG_DATA(active);
1130     va_start(ap, string);
1131     curr_event->string = string;
1132     for (idx = 0; idx < min(numargs, (int)(id->buf_size / sizeof(long)) - 1); idx++)
1133         curr_event->args[idx] = va_arg(ap, long);
1134     va_end(ap);
1135     debug_finish_entry(id, active, level, 0);
1136     spin_unlock_irqrestore(&id->lock, flags);
1137 
1138     return active;
1139 }
1140 EXPORT_SYMBOL(__debug_sprintf_event);
1141 
1142 /*
1143  * debug_sprintf_exception:
1144  */
1145 debug_entry_t *__debug_sprintf_exception(debug_info_t *id, int level, char *string, ...)
1146 {
1147     debug_sprintf_entry_t *curr_event;
1148     debug_entry_t *active;
1149     unsigned long flags;
1150     int numargs, idx;
1151     va_list ap;
1152 
1153     if (!debug_active || !id->areas)
1154         return NULL;
1155 
1156     numargs = debug_count_numargs(string);
1157 
1158     if (debug_critical) {
1159         if (!spin_trylock_irqsave(&id->lock, flags))
1160             return NULL;
1161     } else {
1162         spin_lock_irqsave(&id->lock, flags);
1163     }
1164     active = get_active_entry(id);
1165     curr_event = (debug_sprintf_entry_t *)DEBUG_DATA(active);
1166     va_start(ap, string);
1167     curr_event->string = string;
1168     for (idx = 0; idx < min(numargs, (int)(id->buf_size / sizeof(long)) - 1); idx++)
1169         curr_event->args[idx] = va_arg(ap, long);
1170     va_end(ap);
1171     debug_finish_entry(id, active, level, 1);
1172     spin_unlock_irqrestore(&id->lock, flags);
1173 
1174     return active;
1175 }
1176 EXPORT_SYMBOL(__debug_sprintf_exception);
1177 
1178 /**
1179  * debug_register_view() - registers new debug view and creates debugfs
1180  *             dir entry
1181  *
1182  * @id:     handle for debug log
1183  * @view:   pointer to debug view struct
1184  *
1185  * Return:
1186  * -   0  : ok
1187  * -   < 0: Error
1188  */
1189 int debug_register_view(debug_info_t *id, struct debug_view *view)
1190 {
1191     unsigned long flags;
1192     struct dentry *pde;
1193     umode_t mode;
1194     int rc = 0;
1195     int i;
1196 
1197     if (!id)
1198         goto out;
1199     mode = (id->mode | S_IFREG) & ~S_IXUGO;
1200     if (!(view->prolog_proc || view->format_proc || view->header_proc))
1201         mode &= ~(S_IRUSR | S_IRGRP | S_IROTH);
1202     if (!view->input_proc)
1203         mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
1204     pde = debugfs_create_file(view->name, mode, id->debugfs_root_entry,
1205                   id, &debug_file_ops);
1206     spin_lock_irqsave(&id->lock, flags);
1207     for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
1208         if (!id->views[i])
1209             break;
1210     }
1211     if (i == DEBUG_MAX_VIEWS) {
1212         rc = -1;
1213     } else {
1214         id->views[i] = view;
1215         id->debugfs_entries[i] = pde;
1216     }
1217     spin_unlock_irqrestore(&id->lock, flags);
1218     if (rc) {
1219         pr_err("Registering view %s/%s would exceed the maximum "
1220                "number of views %i\n", id->name, view->name, i);
1221         debugfs_remove(pde);
1222     }
1223 out:
1224     return rc;
1225 }
1226 EXPORT_SYMBOL(debug_register_view);
1227 
1228 /**
1229  * debug_unregister_view() - unregisters debug view and removes debugfs
1230  *               dir entry
1231  *
1232  * @id:     handle for debug log
1233  * @view:   pointer to debug view struct
1234  *
1235  * Return:
1236  * -   0  : ok
1237  * -   < 0: Error
1238  */
1239 int debug_unregister_view(debug_info_t *id, struct debug_view *view)
1240 {
1241     struct dentry *dentry = NULL;
1242     unsigned long flags;
1243     int i, rc = 0;
1244 
1245     if (!id)
1246         goto out;
1247     spin_lock_irqsave(&id->lock, flags);
1248     for (i = 0; i < DEBUG_MAX_VIEWS; i++) {
1249         if (id->views[i] == view)
1250             break;
1251     }
1252     if (i == DEBUG_MAX_VIEWS) {
1253         rc = -1;
1254     } else {
1255         dentry = id->debugfs_entries[i];
1256         id->views[i] = NULL;
1257         id->debugfs_entries[i] = NULL;
1258     }
1259     spin_unlock_irqrestore(&id->lock, flags);
1260     debugfs_remove(dentry);
1261 out:
1262     return rc;
1263 }
1264 EXPORT_SYMBOL(debug_unregister_view);
1265 
1266 static inline char *debug_get_user_string(const char __user *user_buf,
1267                       size_t user_len)
1268 {
1269     char *buffer;
1270 
1271     buffer = kmalloc(user_len + 1, GFP_KERNEL);
1272     if (!buffer)
1273         return ERR_PTR(-ENOMEM);
1274     if (copy_from_user(buffer, user_buf, user_len) != 0) {
1275         kfree(buffer);
1276         return ERR_PTR(-EFAULT);
1277     }
1278     /* got the string, now strip linefeed. */
1279     if (buffer[user_len - 1] == '\n')
1280         buffer[user_len - 1] = 0;
1281     else
1282         buffer[user_len] = 0;
1283     return buffer;
1284 }
1285 
1286 static inline int debug_get_uint(char *buf)
1287 {
1288     int rc;
1289 
1290     buf = skip_spaces(buf);
1291     rc = simple_strtoul(buf, &buf, 10);
1292     if (*buf)
1293         rc = -EINVAL;
1294     return rc;
1295 }
1296 
1297 /*
1298  * functions for debug-views
1299  ***********************************
1300 */
1301 
1302 /*
1303  * prints out actual debug level
1304  */
1305 
1306 static int debug_prolog_pages_fn(debug_info_t *id, struct debug_view *view,
1307                  char *out_buf)
1308 {
1309     return sprintf(out_buf, "%i\n", id->pages_per_area);
1310 }
1311 
1312 /*
1313  * reads new size (number of pages per debug area)
1314  */
1315 
1316 static int debug_input_pages_fn(debug_info_t *id, struct debug_view *view,
1317                 struct file *file, const char __user *user_buf,
1318                 size_t user_len, loff_t *offset)
1319 {
1320     int rc, new_pages;
1321     char *str;
1322 
1323     if (user_len > 0x10000)
1324         user_len = 0x10000;
1325     if (*offset != 0) {
1326         rc = -EPIPE;
1327         goto out;
1328     }
1329     str = debug_get_user_string(user_buf, user_len);
1330     if (IS_ERR(str)) {
1331         rc = PTR_ERR(str);
1332         goto out;
1333     }
1334     new_pages = debug_get_uint(str);
1335     if (new_pages < 0) {
1336         rc = -EINVAL;
1337         goto free_str;
1338     }
1339     rc = debug_set_size(id, id->nr_areas, new_pages);
1340     if (rc != 0) {
1341         rc = -EINVAL;
1342         goto free_str;
1343     }
1344     rc = user_len;
1345 free_str:
1346     kfree(str);
1347 out:
1348     *offset += user_len;
1349     return rc;      /* number of input characters */
1350 }
1351 
1352 /*
1353  * prints out actual debug level
1354  */
1355 static int debug_prolog_level_fn(debug_info_t *id, struct debug_view *view,
1356                  char *out_buf)
1357 {
1358     int rc = 0;
1359 
1360     if (id->level == DEBUG_OFF_LEVEL)
1361         rc = sprintf(out_buf, "-\n");
1362     else
1363         rc = sprintf(out_buf, "%i\n", id->level);
1364     return rc;
1365 }
1366 
1367 /*
1368  * reads new debug level
1369  */
1370 static int debug_input_level_fn(debug_info_t *id, struct debug_view *view,
1371                 struct file *file, const char __user *user_buf,
1372                 size_t user_len, loff_t *offset)
1373 {
1374     int rc, new_level;
1375     char *str;
1376 
1377     if (user_len > 0x10000)
1378         user_len = 0x10000;
1379     if (*offset != 0) {
1380         rc = -EPIPE;
1381         goto out;
1382     }
1383     str = debug_get_user_string(user_buf, user_len);
1384     if (IS_ERR(str)) {
1385         rc = PTR_ERR(str);
1386         goto out;
1387     }
1388     if (str[0] == '-') {
1389         debug_set_level(id, DEBUG_OFF_LEVEL);
1390         rc = user_len;
1391         goto free_str;
1392     } else {
1393         new_level = debug_get_uint(str);
1394     }
1395     if (new_level < 0) {
1396         pr_warn("%s is not a valid level for a debug feature\n", str);
1397         rc = -EINVAL;
1398     } else {
1399         debug_set_level(id, new_level);
1400         rc = user_len;
1401     }
1402 free_str:
1403     kfree(str);
1404 out:
1405     *offset += user_len;
1406     return rc;      /* number of input characters */
1407 }
1408 
1409 /*
1410  * flushes debug areas
1411  */
1412 static void debug_flush(debug_info_t *id, int area)
1413 {
1414     unsigned long flags;
1415     int i, j;
1416 
1417     if (!id || !id->areas)
1418         return;
1419     spin_lock_irqsave(&id->lock, flags);
1420     if (area == DEBUG_FLUSH_ALL) {
1421         id->active_area = 0;
1422         memset(id->active_entries, 0, id->nr_areas * sizeof(int));
1423         for (i = 0; i < id->nr_areas; i++) {
1424             id->active_pages[i] = 0;
1425             for (j = 0; j < id->pages_per_area; j++)
1426                 memset(id->areas[i][j], 0, PAGE_SIZE);
1427         }
1428     } else if (area >= 0 && area < id->nr_areas) {
1429         id->active_entries[area] = 0;
1430         id->active_pages[area] = 0;
1431         for (i = 0; i < id->pages_per_area; i++)
1432             memset(id->areas[area][i], 0, PAGE_SIZE);
1433     }
1434     spin_unlock_irqrestore(&id->lock, flags);
1435 }
1436 
1437 /*
1438  * view function: flushes debug areas
1439  */
1440 static int debug_input_flush_fn(debug_info_t *id, struct debug_view *view,
1441                 struct file *file, const char __user *user_buf,
1442                 size_t user_len, loff_t *offset)
1443 {
1444     char input_buf[1];
1445     int rc = user_len;
1446 
1447     if (user_len > 0x10000)
1448         user_len = 0x10000;
1449     if (*offset != 0) {
1450         rc = -EPIPE;
1451         goto out;
1452     }
1453     if (copy_from_user(input_buf, user_buf, 1)) {
1454         rc = -EFAULT;
1455         goto out;
1456     }
1457     if (input_buf[0] == '-') {
1458         debug_flush(id, DEBUG_FLUSH_ALL);
1459         goto out;
1460     }
1461     if (isdigit(input_buf[0])) {
1462         int area = ((int) input_buf[0] - (int) '0');
1463 
1464         debug_flush(id, area);
1465         goto out;
1466     }
1467 
1468     pr_info("Flushing debug data failed because %c is not a valid "
1469          "area\n", input_buf[0]);
1470 
1471 out:
1472     *offset += user_len;
1473     return rc;      /* number of input characters */
1474 }
1475 
1476 /*
1477  * prints debug data in hex/ascii format
1478  */
1479 static int debug_hex_ascii_format_fn(debug_info_t *id, struct debug_view *view,
1480                      char *out_buf, const char *in_buf)
1481 {
1482     int i, rc = 0;
1483 
1484     for (i = 0; i < id->buf_size; i++)
1485         rc += sprintf(out_buf + rc, "%02x ", ((unsigned char *) in_buf)[i]);
1486     rc += sprintf(out_buf + rc, "| ");
1487     for (i = 0; i < id->buf_size; i++) {
1488         unsigned char c = in_buf[i];
1489 
1490         if (isascii(c) && isprint(c))
1491             rc += sprintf(out_buf + rc, "%c", c);
1492         else
1493             rc += sprintf(out_buf + rc, ".");
1494     }
1495     rc += sprintf(out_buf + rc, "\n");
1496     return rc;
1497 }
1498 
1499 /*
1500  * prints header for debug entry
1501  */
1502 int debug_dflt_header_fn(debug_info_t *id, struct debug_view *view,
1503              int area, debug_entry_t *entry, char *out_buf)
1504 {
1505     unsigned long sec, usec;
1506     unsigned long caller;
1507     unsigned int level;
1508     char *except_str;
1509     int rc = 0;
1510 
1511     level = entry->level;
1512     sec = entry->clock;
1513     usec = do_div(sec, USEC_PER_SEC);
1514 
1515     if (entry->exception)
1516         except_str = "*";
1517     else
1518         except_str = "-";
1519     caller = (unsigned long) entry->caller;
1520     rc += sprintf(out_buf, "%02i %011ld:%06lu %1u %1s %04u %px  ",
1521               area, sec, usec, level, except_str,
1522               entry->cpu, (void *)caller);
1523     return rc;
1524 }
1525 EXPORT_SYMBOL(debug_dflt_header_fn);
1526 
1527 /*
1528  * prints debug data sprintf-formated:
1529  * debug_sprinf_event/exception calls must be used together with this view
1530  */
1531 
1532 #define DEBUG_SPRINTF_MAX_ARGS 10
1533 
1534 static int debug_sprintf_format_fn(debug_info_t *id, struct debug_view *view,
1535                    char *out_buf, debug_sprintf_entry_t *curr_event)
1536 {
1537     int num_longs, num_used_args = 0, i, rc = 0;
1538     int index[DEBUG_SPRINTF_MAX_ARGS];
1539 
1540     /* count of longs fit into one entry */
1541     num_longs = id->buf_size / sizeof(long);
1542 
1543     if (num_longs < 1)
1544         goto out; /* bufsize of entry too small */
1545     if (num_longs == 1) {
1546         /* no args, we use only the string */
1547         strcpy(out_buf, curr_event->string);
1548         rc = strlen(curr_event->string);
1549         goto out;
1550     }
1551 
1552     /* number of arguments used for sprintf (without the format string) */
1553     num_used_args = min(DEBUG_SPRINTF_MAX_ARGS, (num_longs - 1));
1554 
1555     memset(index, 0, DEBUG_SPRINTF_MAX_ARGS * sizeof(int));
1556 
1557     for (i = 0; i < num_used_args; i++)
1558         index[i] = i;
1559 
1560     rc = sprintf(out_buf, curr_event->string, curr_event->args[index[0]],
1561              curr_event->args[index[1]], curr_event->args[index[2]],
1562              curr_event->args[index[3]], curr_event->args[index[4]],
1563              curr_event->args[index[5]], curr_event->args[index[6]],
1564              curr_event->args[index[7]], curr_event->args[index[8]],
1565              curr_event->args[index[9]]);
1566 out:
1567     return rc;
1568 }
1569 
1570 /*
1571  * debug_init:
1572  * - is called exactly once to initialize the debug feature
1573  */
1574 static int __init debug_init(void)
1575 {
1576     s390dbf_sysctl_header = register_sysctl_table(s390dbf_dir_table);
1577     mutex_lock(&debug_mutex);
1578     debug_debugfs_root_entry = debugfs_create_dir(DEBUG_DIR_ROOT, NULL);
1579     initialized = 1;
1580     mutex_unlock(&debug_mutex);
1581     return 0;
1582 }
1583 postcore_initcall(debug_init);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!