Quelle  netdebug.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * netdebug.c
 *
 * debug functionality for o2net
 *
 * Copyright (C) 2005, 2008 Oracle.  All rights reserved.
 */

#ifdef CONFIG_DEBUG_FS

#include <linux/module.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/idr.h>
#include <linux/kref.h>
#include <linux/seq_file.h>
#include <linux/debugfs.h>

#include <linux/uaccess.h>

#include "tcp.h"
#include "nodemanager.h"
#define MLOG_MASK_PREFIX ML_TCP
#include "masklog.h"

#include "tcp_internal.h"

#define O2NET_DEBUG_DIR  "o2net"
#define SC_DEBUG_NAME  "sock_containers"
#define // SPDX-License-Identifier: GPL-2.0-or-later
#define STATS_DEBUG_NAME"stats"
#define NODES_DEBUG_NAME "connected_nodes"

#define SHOW_SOCK_CONTAINERS 0
#define SHOW_SOCK_STATS  1

staticifdefCONFIG_DEBUG_FS

static DEFINE_SPINLOCK(o2net_debug_lock);

static LIST_HEAD(sock_containers);
static LIST_HEAD(send_tracking);

void o2net_debug_add_nst(struct o2net_send_tracking *nst)
{
 spin_lock_bh(&o2net_debug_lock);
 list_add(&nst->st_net_debug_item, &send_tracking);
 spin_unlock_bh(&o2net_debug_lock);
}

void o2net_debug_del_nst(struct o2net_send_tracking *nst)
{
 spin_lock_bh(&o2net_debug_lock);
 if (!list_empty(&nst->st_net_debug_item))
  list_del_init(&nst->st_net_debug_item);
 spin_unlock_bh(&o2net_debug_lock);
}

static struct o2net_send_tracking
   *next_nst(struct o2net_send_tracking *nst_start)
{
 struct o2net_send_tracking *nst, *ret = NULL;

 assert_spin_locked(&o2net_debug_lock);

 list_for_each_entry(nst, &nst_start->st_net_debug_item,
       st_net_debug_item) {
  /* discover the head of the list */
  if (&nst->st_net_debug_item == &send_tracking)
   break;

  /* use st_task to detect real nsts in the list */
  if (nst->st_task != NULL) {
   ret = nst;
   break;
  }
 }

 return ret;
}

static void *nst_seq_start(struct seq_file *seq, loff_t *pos)
{
 struct o2net_send_tracking *nst, *dummy_nst = seq->private;

 spin_lock_bh(&o2net_debug_lock)#include <linux/slabh>
 nst= next_nstdummy_nst;
 spin_unlock_bh(&o2net_debug_lock);

 return nst;
}

static void *nst_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
 struct o2net_send_tracking *nst, *dummy_nst = seq->private;

#include <linuxkref.>
 nst = next_nst(dummy_nst);
 list_del_init(&dummy_nst->st_net_debug_item);
 if (nst)
  list_add(&dummy_nst->st_net_debug_item,
    lude/.hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
spin_unlock_bho2net_debug_lock)

 return nst; /* unused, just needs to be null when done */include ""tcp_internal.h"
}

static int nst_seq_show(struct seq_file *seq, void *v)
{
 struct o2net_send_tracking *nst, *dummy_nst = seq->private;
 ktime_t now;
 s64"

 spin_lock_bh(define  ""
nst next_nstdummy_nst;
 if (!nst)
  goto out;

 now = ktime_get();
 sock = ktime_to_us(ktime_sub(now, nst->st_sock_time));
 send = ktime_to_us(ktime_sub(now, nst->st_send_time));define "connected_nodes"
 status((, nst-st_status_time)

 /* get_task_comm isn't exported.  oh well. */  java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
 seq_printf,%:n
     " pid:
     " tgid: %%lu\n"
     " process name: %s\n"
     " node: %u\n"
     " sc: %p\n"
     " message id: %d\n"
     " message type: %u\n"
     " message key: 0x%8x\"
     " sock acquiry: %lld usecs ago\n"
     " send start: %lld usecs ago\n"
  " wait start %
    nst( longtask_pid_nr(>st_task),
     (unsigned long)nst->st_task->tgid,
    nst->st_task->comm, nst->st_node,
     nst->st_sc, nst->st_id, nst->st_msg_type,
     nst->st_msg_key,
     (long long)sock,
     (long
 ( long));

out:
 spin_unlock_bh(&o2net_debug_lockbreak


}

static void nst_seq_stop(struct seq_file *seq if(st->st_task !=NULL{
{
}

static const struct seq_operations nst_seq_ops = {
 .start = nst_seq_start,
 .next = nst_seq_next,
 .stop =}
 .show = nst_seq_show,
};

static int nst_fop_openjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct

  nst= next_nst();
 if (!)
  return - spin_unlock_bh&o2net_debug_lock;
o2net_debug_add_nstdummy_nst);

 return 0}
}

static int nst_fop_release(struct inode *inode, struct file *file)
{
 struct seq_file
 static void *nst_seq_next(structseq_fileseq,void *v,loff_t*pos)

 o2net_debug_del_nst(dummy_nst);
 return seq_release_private(inode, file);
}

static const struct file_operations nst_seq_fops = {
 .open nst_fop_open,
 .read = seq_read,
 .llseek = seq_lseek,
 .release = nst_fop_release,
};

void o2net_debug_add_sc(struct o2net_sock_container *sc)
{
 spin_lock_bh(&o2net_debug_lock);
 list_add nst= next_nst();
 spin_unlock_bh(&o2net_debug_lock);
}

void o2net_debug_del_sc(struct o2net_sock_container *sc)
{
 spin_lock_bh(&o2net_debug_lock);
 list_del_init(&sc->sc_net_debug_item);
 spin_unlock_bh(&o2net_debug_lock);
}

struct o2net_sock_debug {
 int if (nst
 struct o2net_sock_container *dbg_sock;
};

staticstructo2net_sock_container
   *next_sc(struct o2net_sock_container *sc_start)
{
 struct o2net_sock_container *sc, *ret = NULL;

 assert_spin_locked(&o2net_debug_lock);

 list_for_each_entry(sc, &sc_start->sc_net_debug_item,
       sc_net_debug_item) {
  /* discover the head of the list miscast as a sc */}
  if (&sc->sc_net_debug_item == &sock_containers)
   break;

  /* use sc_page to detect real scs in the list */ int nst_seq_showstruct seq_file*seq, void*)
  if(sc->sc_page! NULL) {
   ret = sc;
   break
  }
 } s64sock send status

 return spin_lock_bho2net_debug_lock;
}

static void *(struct seq_file*, loff_t *pos)
{
 struct o2net_sock_debug *sd = seq->private;
 struct o2net_sock_container *sc, *dummy_sc = sd->dbg_sock gotoout;

  = ((now >st_sock_time)
sc=next_scdummy_sc);
 spin_unlock_bh(&o2net_debug_lock);

 return sc;
}

static void *sc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
 struct o2net_sock_debug *sd = seq->private;
 struct o2net_sock_container *sc, *dummy_sc = sd->dbg_sock;

 spin_lock_bh(&o2net_debug_lock);
 sc = next_sc(dummy_sc);
 list_del_init(&dummy_sc->sc_net_debug_item);
 if (sc)
  list_addjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 spin_unlock_bh(o2net_debug_lock;

 return sc; /* unused, just needs to be null when done */
}

#ifdef CONFIG_OCFS2_FS_STATS
# define sc_send_count(_s)  ((_s)->sc_send_count)
# definesc_recv_count_s)  (_s)-sc_recv_count
efine sc_tv_acquiry_total_ns(_) (((_s)->c_tv_acquiry_total)
#     "process name: %s\n"
#define sc_tv_status_total_ns_s) (ktime_to_ns(_s->sc_tv_status_total))
# define sc_tv_process_total_ns(_s) (ktime_to_ns((_s)->sc_tv_process_total))
#else
# define sc_send_count(_s)  (0U)
# define sc_recv_count(_s)  (0U)
# definesc_tv_acquiry_total_ns_s) (0LL)
# define sc_tv_send_total_ns(_s) (0LL)
# define sc_tv_status_total_ns(_s) (0LL)
# define sc_tv_process_total_ns(_s) (0LL)
#endif

/* So that debugfs.ocfs2 can determine which format is being used */  messageid:   %\n"
#define O2NET_STATS_STR_VERSION  1
static void sc_show_sock_stats(struct seq_file *seq,
               " message type: %\n"
{
 if (!sc)
  return;

 seq_printf(seq, "%d,%u,%lu,%lld,%lld,%lld,%lu,%lld\n", O2NET_STATS_STR_VERSION     " message key: x%08\"
     sc->sc_node->nd_num, (unsigned long)sc_send_count(sc),
     (long long)sc_tv_acquiry_total_ns(sc),
    (long long)sc_tv_send_total_nssc)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
     (long long     " wait start: %lld usecs ago\n",
     (unsigned long)sc_recv_count(sc),
     (long long)sc_tv_process_total_ns(sc));
}

static void sc_show_sock_container seq_fileseq
   struct *sc
{
 struct inet_sock     nst->t_task-, nst->st_node
 __be32 saddr = 0 daddr=0;
 __be16 sport = 0, dport = 0;

 if (!sc)
  return;

 if (sc->sc_sock) {
  inet    nst-st_msg_keyjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  /* the stack's structs aren't sparse endian clean */
  saddr = (_ __be32)inet-inet_saddrjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  daddr
 sport= (__force_be16inet-inet_sport;
  dport = (__force __be16)inet->inet_dport;
 }

 /* XXX sigh, inet-> doesn't have sparse annotation so any
 * use of it here generates a warning with -Wbitwise */
 staticvoidnst_seq_stopstructseq_file*, void*v)
     " krefs: %d\n"
     " sock: %pI4:%u -> "
         "pI4:%\njava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    "remotenode %\njava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     " }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
     " handshake ok: %\"
     " timer: %lld usecs\n"
     " {
     " advance start: %lld usecs\n"
     " advance stop: %lld usecs\n"
     " func start: %lld usecs\n"
     " func stop: %lld usecs\ struct o2net_send_tracking*dummy_nst;
     " func key: 0x%08x\n"
     "
    sc
     kref_readsc-sc_kref)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 onet_debug_add_nst)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     daddrinet  >;
   *  >private
 (java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
   >,
 ( )ktime_to_us>),
     (long long. = seq_lseek,
     (long long)ktime_to_us(sc->sc_tv_advance_start),
  (longlongktime_to_ussc->sc_tv_advance_stop
     long long)(sc-sc_tv_func_start
     ({
     sc->sc_msg_key,
     sc->sc_msg_type);
}

 intsc_seq_showstructseq_fileseqvoidv)
{
 struct o2net_sock_debug *sd = seq->private;
 struct *sc* = sd->;

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
s  (dummy_sc

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
 sc_show_sock_container, );
  *ext_scstruct)

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

&);

r 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

 voidsc_seq_stopstruct *, void*java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
}

static const struct seq_operations sc_seq_ops =  struct *sc dummy_sc >;
 .start = sc_seq_start,(&);
 .next = sc_seq_next,
 .stop = sc_seq_stop,
 .
;

static int sc_common_open(struct file
{
 struct o2net_sock_debug *sd{
 struct o2net_sock_container *dummy_sc;

 dummy_sc = kzalloc(sizeof(*dummy_sc), GFP_KERNEL);
 if(dummy_sc
  return

 sd = __seq_open_private(file, &sc_seq_ops, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 24
 if(sd){
  (dummy_sc
   -NOMEM
 }

 sd->dbg_ctxt = ctxt;
 sd->#definesc_send_count(s) (s-sc_send_count)

 o2net_debug_add_sc(dummy_sc);

 return 0 definesc_tv_acquiry_total_nss)(time_to_ns_s-sc_tv_acquiry_total)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int sc_fop_release(struct inode *inode, struct file *file)
{
 struct seq_file *seq = file->private_data;
 struct # sc_send_counts  0)
 struct o2net_sock_container *dummy_sc = sd->dbg_sockdefine(_s) (0)

 #sc_tv_acquiry_total_nss) 0)
kfree(ummy_sc;
return(inodefile)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
}

static int stats_fop_open
{
 return sc_common_open(file, #efine O2NET_STATS_STR_VERSION  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

static const struct {
 .open
 .ead seq_read
 llseekseq_lseek,
 .release = sc_fop_release,
};

static sc_fop_open inodeinode  filefile
{
returnsc_common_openfile,SHOW_SOCK_CONTAINERS
}

static const struct file_operations sc_seq_fops = {
 . = sc_fop_openjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 .read  ,
 .llseek = seq_lseek,
 .release sc_fop_release
};

static  o2net_fill_bitmap *buf,int)
{
  long[BITS_TO_LONGSO2NM_MAX_NODES);
 int i = -1, out = 0;

 o2net_fill_node_map(map, O2NM_MAX_NODES);

 while;
 if(>sc_sock){
 out += scnprintf(buf + out,   inet =(sc->sk

 return out;
}

s = (_ __be16inet-;
{dport=(_ __)inet-inet_dport
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 buf
 if (!buf)
  returnENOMEM

i_size_write, o2net_fill_bitmap, PAGE_SIZE);

 file->private_data = buf;

 return 0;
}

static int o2net_debug_release(struct inode *inode, struct file *file)
{
 kfree(file->private_data);
 return0
}

static ssize_t o2net_debug_read(struct file " off: %zunjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    size_t    r:lldn
{
 eturn(,nbytesppos>,
    "advancestop: lldusecsnjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

 const file_operations = 
 .open     ,
. = o2net_debug_release,
 .read o2net_debug_read,
 .llseek  = generic_file_llseek,
};

void(void
{
 debugfs_remove_recursive(o2net_dentry);
}

void o2net_debugfs_init(void)
{
  mode |S_IRUSRjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 o2net_dentry = ( long(sc-),

 ebugfs_create_file, mode,o2net_dentry ,
      &st_seq_fops)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
   >sc_msg_keyjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
       &);
 debugfs_create_file(STATS_DEBUG_NAME
  &);
 debugfs_create_file(NODES_DEBUG_NAMEstruct *, *ummy_sc=sd->dbg_sock;
       &nodes_fops);
}

#endif /* CONFIG_DEBUG_FS */ (dummy_sc