redis 集群搭建及相关命令

最新推荐文章于 2025-07-07 00:14:25 发布
原创 最新推荐文章于 2025-07-07 00:14:25 发布 · 511 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了Redis集群的安装步骤及配置过程，包括单节点安装、集群部署、节点管理及客户端连接方式等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

redis 集群安装


1、下载redis 安装包redis-3.0.7.tar.gz
2、tar -zxvf redis-3.0.7.tar.gz 解压安装包
3、进入根目录，make 编译
4、进入src，make install 安装
5、新建目录/usr/local/redis/bin   /usr/local/redis/etc
6、拷贝redis-server redis-cli 到bin下，拷贝redis.conf到etc下
7、修改redis.conf 包括端口号、后台启动等
8、启动 /usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf
9、客户端连接 /usr/local/redis/bin/redis-cli -p 8080      8080为定义的端口号
以上操作分别在10.202.15.193、10.202.15.195、10.202.15.198操作一遍

集群部署

10、新建文件夹

在机器10.202.15.193、10.202.15.195、10.202.15.198 分别建立以下文件夹

/usr/local/redis-cluster/7001
/usr/local/redis-cluster/7002

11、把/usr/local/redis/etc/redis.conf分别拷贝到 7001、7002下
12、分别修改配置文件
port 7001  
pidfile /var/run/redis-7001.pid  
dbfilename dump-7001.rdb  
appendfilename "appendonly-7001.aof"  
cluster-config-file nodes-7001.conf  
cluster-enabled yes  
cluster-node-timeout 5000  
appendonly yes 


13、启动

在10.202.15.193、10.202.15.195、10.202.15.198分别操作

/usr/local/redis/bin/redis-server /usr/local/redis-cluster/7001/redis.conf
/usr/local/redis/bin/redis-server /usr/local/redis-cluster/7002/redis.conf



14、安装ruby,rubygems
yum  install ruby
yum  install rubygems
换源
gem source --remove http://rubygems.org/
gem sources -a http://ruby.taobao.org/
gem install redis --version 3.0.0  //安装gem_redis 
如果因为网络的原因无法直接下载安装，则可以先找到下载到gem，然后安装。
gem install redis -a 地址
https://rubygems.org/downloads/redis-3.0.7.gem

15、src 下执行 
redis-trib.rb create --replicas 1 10.202.15.193:7001 
10.202.15.193:7002 
10.202.15.195:7001

10.202.15.195:7002

10.202.15.198:7001

10.202.15.198:7002


16、客户端连接

redis-cli  -h   10.202.15.193 -c -p 7001 其中一定不能少了-c，否则会报(error) moved 错误

17、查看节点信息
redis-cli -c -h 10.202.15.193 -p 7001 cluster nodes

18、新增节点
创建文件夹7003，cp redis.conf ，更改配置文件中的端口，同以上操作

先启动节点

redis-server /usr/local/redis/redis-cluster/7003/redis.conf

然后加入集群

./redis-trib.rb add-node 10.202.15.193:7003 10.202.15.193:7001

出现以下信息

>>> Adding node 10.202.15.193:7003 to cluster 10.202.15.193:7001
>>> Performing Cluster Check (using node 10.202.15.193:7001)
M: 150ddf914c03f4e64fb3b9b95b2dc6ca4a6fc1ee 10.202.15.193:7001
   slots:10923-16383 (5461 slots) master
   1 additional replica(s)
S: 276546e824881f9aea3a50d85eb4cf36164a8a41 10.202.15.193:7002
   slots: (0 slots) slave
   replicates 150ddf914c03f4e64fb3b9b95b2dc6ca4a6fc1ee
S: e6c5e58e39d3dd6fd8a71aa1d40ba5c69750e747 10.202.15.198:7002
   slots: (0 slots) slave
   replicates bbb013a6286c2c678d0fd9e51d1bc205d6cc4799
S: 2048ac316f682f7c6d2ab115e63bc1809cdca269 10.202.15.195:7002
   slots: (0 slots) slave
   replicates a8da385c311fe7b12073ae87858c8c70ff261077
M: bbb013a6286c2c678d0fd9e51d1bc205d6cc4799 10.202.15.195:7001
   slots:5461-10922 (5462 slots) master
   1 additional replica(s)
M: a8da385c311fe7b12073ae87858c8c70ff261077 10.202.15.198:7001
   slots:0-5460 (5461 slots) master
   1 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
>>> Send CLUSTER MEET to node 10.202.15.193:7003 to make it join the cluster.
[OK] New node added correctly.


加入后有可能是master节点，也有可能是slave节点。

19、移动槽

执行一下命令移动槽

./redis-trib.rb reshard 10.202.15.193:7001

提示移动多少个槽，输入1000，即移动1000个

然后指定移到哪个节点上，输入刚创建的节点ID ，查看节点ID可以用redis-cli -c -h 10.202.15.193 -p 7001 cluster nodes

95df1ee020021a5ca6fe6961431ded660b304229

然后提示需要移动哪几个节点的槽到新的节点上，可以输入all，表示从主节点中随机取一些槽到新的节点，也可以输入节点ID，指定从哪几个节点移，最后输入done结束

输入all后，会显示执行计划，输入yes，执行计划，移动槽

20、把这个节点变成从节点

把新的节点变成slave，新的节点中必须没有槽，并且对于的master也没有槽，有的话需要移动到其他的master，否则会报

ERR To set a master the node must be empty and without assigned slots 错误，移动槽参照上面步骤

新节点和对应的master上没有槽后，执行一下命令

./redis-cli -c -h 10.202.15.193 -p 7003 cluster replicate 150ddf914c03f4e64fb3b9b95b2dc6ca4a6fc1ee

150ddf914c03f4e64fb3b9b95b2dc6ca4a6fc1ee是对应的master节点ID


redis-cli -h 10.202.15.193 -p 7001 cluster nodes | grep slave | grep 150ddf914c03f4e64fb3b9b95b2dc6ca4a6fc1ee 查看master下对应的slave


276546e824881f9aea3a50d85eb4cf36164a8a41 10.202.15.193:7002 slave 150ddf914c03f4e64fb3b9b95b2dc6ca4a6fc1ee 0 1503403543612 9 connected
95df1ee020021a5ca6fe6961431ded660b304229 10.202.15.193:7003 slave 150ddf914c03f4e64fb3b9b95b2dc6ca4a6fc1ee 0 1503403540607 7 connected

21、查看节点信息

进入客户端

./redis-cli -c -h 10.202.15.198 -p 7001

输入 info replication 输出当前节点的信息，包括节点是master还是slave



Replication
role:master
connected_slaves:3
slave0:ip=10.202.15.198,port=7002,state=online,offset=1710,lag=1
slave1:ip=10.202.15.198,port=7003,state=online,offset=1724,lag=1
slave2:ip=10.202.15.195,port=7003,state=online,offset=1710,lag=1
master_repl_offset:1724
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:2
repl_backlog_histlen:1723




Redis集群的创建
crazy2098的博客
06-13 850
注意，启动时出现的所有出错信息，均采取批量注释的方式处理（由于不合适的配置比较多，这个过程可能要耗费比较多的时间哦）；由于我们采取的是一主一从的集群结构，所以同时增加两个节点，从而保持一主一从的集群结构不变。9、将8001目录下的redis.conf分别复制到8002-8006；8、在集群目录redisCluster下创建8002-8006子目录；6、复制解压目录中的redis.conf到8001目录；7、编辑8001目录中的redis.conf配置文件；3、批量修改redis.conf的端口号；
Redis集群搭建及原理详解
core815的专栏
06-18 1836
在redis3.0以前的版本要实现集群一般是借助哨兵sentinel工具来监控master节点的状态，如果master节点异常，则会做主从切换，将某一台slave作为master，哨兵的配置略微复杂，并且性能和高可用性等各方面表现一般，特别是在主从切换的瞬间存在访问瞬断的情况，而且哨兵模式只有一个主节点对外提供服务，没法支持很高的并发，且单个主节点内存也不宜设置得过大，否则会导致持久化文件过大，影响数据恢复或主从同步的效率。
redis 集群创建命令行
bzqgo的博客
06-12 1309
./redis-trib.rb  create --replicas 1 192.168.85.128:6379 192.168.85.129:6379 192.168.85.130:6379 192.168.85.128:6380 192.168.85.129:6380 192.168.85.130:6380   ./redis-trib.rb  create --replicas 1 192.
Redis三种集群模式搭建
qq_62221574的博客
07-07 1117
主从模式是三种模式中最简单的，在主从复制中，数据库分为两类：主数据库(Master)和从数据库(Slave)。其中，主从复制有如下特点：1、主数据库可以进行读写操作，当读写操作导致数据变化时会自动将数据同步给从数据库；2、从数据库一般是只读的，用于接收主数据库同步过来的数据；3、一个Master可以拥有多个Slave，但是一个Slave只能对应一个Master；4、Slave故障不影响其他Slave的读和Master的读和写，重新启动后会将数据从Master同步过来；
redis集群搭建的命令手册
m0_53465512的博客
09-30 481
【代码】redis集群搭建的命令手册。
redis集群的原生命令搭建
wx145的博客
09-17 730
背景知识： 生产环境中集群的搭建一般不会使用原生命令，而是使用redis官方提供的ruby工具 原生命令的安装只是帮助你更好的理解redis集群这个架构 一般集群都是搭建在不同的主机上，案例为了演示就直接在单机上部署，用端口区分 本篇文章的测试环境是阿里云主机CentOS Linux release 7.3.1611 1.配置开启redis(其实和开启普通redis节点一样，只是多增加了几...
Redis高级之——Redis集群搭建过程和基本命令
weixin_45417821的博客
07-31 316
问题：我们已经部署好了redis，并且能启动一个redis，实现数据的读写，为什么还要学习redis集群？ 答： （1）单个redis存在不稳定性。当redis服务宕机了，就没有可用的服务了。 （2）单个redis的读写能力是有限的。 总结：redis集群是为了强化redis的读写能力。 如何学习redis集群 说明： （1）redis集群中，每一个redis称之为一个节点。 （2）redis集群中，有两种类型的节点：主节点(master)、从节点(slave) （3）redis集群，是基于redis
Redis集群搭建及维护文档.docx
03-31
以下是一份简化的Redis集群搭建步骤： 1. **环境准备**： - 确保你有一个兼容的Linux环境，例如CentOS 7（64位）。 - 下载Redis的源代码包，如redis-4.0.6.tar.gz。 2. **安装Redis单节点**： - 解压Redis源...
docker 实现redis集群搭建
08-19
"docker 实现redis集群搭建" 一、Redis Cluster 概念 Redis Cluster 是 Redis 的分布式解决方案，旨在解决 Redis 单机中心化的问题。它将整个数据集按照分区规则映射到多个节点上，使得 Redis 能够水平扩展以应对...
阿里云公网redis集群搭建以及java访问redis集群
04-20
阿里云公网Redis集群搭建及Java访问教程 在云计算日益普及的今天，阿里云提供了便捷的公共服务，如Redis缓存服务，帮助企业或个人快速构建高效、可靠的分布式应用。本教程将详细讲解如何在阿里云上搭建公网Redis...
redis集群搭建手册.docx
02-18
**Redis集群搭建手册** Redis，全称Remote Dictionary Server，是一种高性能的键值对数据库，以其丰富的数据类型、高效的内存管理以及支持持久化等特性，在分布式系统中被广泛应用于缓存、消息中间件以及数据存储等...
redis集群搭建
weixin_45999801的博客
02-23 940
redis集群搭建
redis集群搭建及管理命令
谢白羽
08-04 1138
文章目录1.集群的搭建1.1 快速搭建集群1） 首先，我们可以通过执行start命令来创建出6个节点，这6个节点的IP地址都为本机，而端口号则为30001～30006：2）接着，我们需要使用create命令，把上述6个节点组合成一个集群，其中包含3个主节点和3个从节点：3）在成功构建起集群之后，我们就可以使用客户端来连接并使用集群了.4）转向5）最后，在使用完这个测试集群之后，我们可以通过以下命令关闭集群并清理各个集群节点的相关信息：1.2 手动搭建集群1.2.1 自动和手动搭建集群的优缺点1.2.2 手动
【redis】创建集群
不想睡觉的橘子君的博客
08-02 744
这里介绍的是创建redis集群的方式，这里的集群指的是一个以上的具有写能力的单体redis或者master。
redis集群命令
weixin_30596165的博客
05-06 212
三、集群客户端命令（redis-cli -c -p port）可以设置后台启动 daemonize yes 集群 cluster info：打印集群的信息 cluster nodes：列出集群当前已知的所有节点（ node），以及这些节点的相关信息。 节点 cluster meet <ip> <port>：将 ip 和 port 所指定的节点添加到集...
Redis搭建集群
百木成林
05-11 1036
前言 redis是一个分布式的key-value的缓存数据库，单机版的搭建是很简单，这里来搭建redis的集群，实现高可用的服务。 步骤 请提前安装好并测试单机版Redis无问题后进行以下操作 1. 创建redis-cluster目录，并在其下创建7001–7006目录 2. 复制单机版redis.conf文件依次至7001–7006目录下，并修改该配置文件 6个配置文件修改类似如下 port 7000 //节点端口 daemonize yes //配置redis作为守护进程运行，默认情况下，redi
redis启动命令及集群创建
weixin_45611186的博客
01-18 2300
启动步骤 1、cmd 2、redis-server redis.windows.conf
创建和使用Redis集群
weixin_45793065的博客
06-25 375
官网教程https://redis.io/topics/cluster-tutorial 创建和使用Redis集群 现在我们有许多实例正在运行，我们需要通过向节点写入一些有意义的配置来创建集群。 如果您使用的是Redis 5，这很容易完成，这是因为嵌入到中的Redis Cluster命令行实用程序为我们提供了帮助，该实用程序redis-cli可用于创建新集群，检查或重新分片现有集群等。 对于Redis版本3或4，有一个称为的旧工具redis-trib.rb，它非常相似。您可以src在Redis源代码分发的目
Redis集群搭建
hsg_happyLearning的博客
04-05 1344
Redis集群搭建 搭建redis集群的场景方式有： 客户端分区，在客户端根据hash计算将数据保存到那个redis节点，该方案的代表有redis sharding。优点是不使用第三方中间件，分区逻辑可控，配置简单，节点之间无关联，容易线性扩展，灵活性高；缺点是客户端无法动态增删节点，需要自行维护分发逻辑，节点之间无连接共享，会造成连接浪费(需要连接多个redis)，而且一旦有节点宕机，会导致服务不可用。 代理分区，类似于mysql使用sharding-proxy，客户端连接redis代理，由代理实现分区
int OTG_CURR = 0; int oplus_wired_set_otg_boost_curr_limit(int curr_ma) { int rc = 0; struct oplus_mms_wired *chip = g_mms_wired; if (chip == NULL) { chg_err("chip is NULL"); return -ENODEV; } rc = oplus_chg_ic_func(chip->buck_ic, OPLUS_IC_FUNC_SET_OTG_BOOST_CURR_LIMIT, curr_ma); if (rc < 0) chg_err("can't set otg boost curr limit to %d, rc=%d\n", curr_ma, rc); chg_info("set otg boost curr limit to %d\n", curr_ma); OTG_CURR = curr_ma; return rc; } #define PE_SRC_READY 6 static int update_pdo_source_cap(int ui_soc) { int rc = 0; struct tcpc_device *tcpc = NULL; tcpc = tcpc_dev_get_by_name("type_c_port0"); struct tcpm_power_cap cap = { 1, {0x00019082} }; if (tcpc == NULL) { chg_err("Invalid tcpc pointer\n"); return -EINVAL; } chg_err("Source ready : %d\n", tcpc->pd_port.pe_pd_state); if (tcpc->pd_port.pe_pd_state == PE_SRC_READY) { if (ui_soc <= OPCHG_OTG_CC_LIMIT_LOW_SOC){ cap.cnt = 1; cap.pdos[0] = 0x00019082; } else if (ui_soc >= OPCHG_OTG_CC_LIMIT_HIGH_SOC){ cap.cnt = 1; cap.pdos[0] = 0x000190C8; } else { cap.cnt = 1; cap.pdos[0] = 0x000190B4; } rc = tcpm_set_pd_local_source_cap(tcpc, &cap); if (rc < 0) { chg_err("tcpm_set_pd_local_source_cap error: %d\n", rc); return rc; } rc = tcpm_dpm_pd_source_cap(tcpc, NULL); if (rc < 0) { chg_err("tcpm_dpm_pd_source_cap error: %d\n", rc); return rc; } } return 0; } static void oplus_wired_otg_cc_limit_by_soc_work(struct work_struct *work) { struct oplus_mms_wired *chip = container_of(work, struct oplus_mms_wired, otg_cc_limit_by_soc_work); struct oplus_usbtemp_spec_config *spec; int rc = 0; int otg_online = 0; union mms_msg_data data = { 0 }; spec = &chip->usbtemp_spec; rc = oplus_mms_get_item_data(chip->comm_topic, COMM_ITEM_UI_SOC, &data, false); if (!rc) { chip->ui_soc = data.intval; if (!chip->update_pdo_called) { rc = update_pdo_source_cap(chip->ui_soc); // if (rc < 0) { chg_err("update_pdo_source_cap error\n"); return; } chip->update_pdo_called = true; // 设置标志位为已调用 } otg_online = oplus_wired_get_otg_online_status(chip->wired_topic); if (otg_online) { if (chip->ui_soc <= OPCHG_OTG_CC_LIMIT_LOW_SOC && !(OTG_CURR == OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_LIMIT)){ chg_err("ui_soc is below 20, limit otg_cc to default 1.3A\n"); rc = oplus_wired_set_otg_boost_curr_limit(OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_LIMIT); if (rc < 0) { chg_err("oplus_wired_set_otg_boost_curr_limit error\n"); return; } rc = update_pdo_source_cap(chip->ui_soc); }else if (chip->ui_soc >= OPCHG_OTG_CC_LIMIT_HIGH_SOC && !(OTG_CURR == OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_HIGH_LIMIT)){ chg_err("ui_soc is up 80, limit otg_cc to high 2.1A\n"); rc = oplus_wired_set_otg_boost_curr_limit(OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_HIGH_LIMIT); if (rc < 0) { chg_err("oplus_wired_set_otg_boost_curr_limit error\n"); return; } rc = update_pdo_source_cap(chip->ui_soc); }else { if (OTG_CURR == OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_MIU_LIMIT) return; chg_err("ui_soc is 20-80, limit otg_cc to high 1.8A\n"); rc = oplus_wired_set_otg_boost_curr_limit(OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_MIU_LIMIT); if (rc < 0) { chg_err("oplus_wired_set_otg_boost_curr_limit error\n"); return; } rc = update_pdo_source_cap(chip->ui_soc); } } } } 为这些代码写一个测试程序
最新发布
07-12
<think>我们需要为提供的代码编写一个测试程序。由于代码涉及硬件操作和内核模块，我们无法在用户空间直接测试，因此测试程序需要以内核模块的形式编写，模拟调用这些函数并检查其行为。 但是，请注意：原始代码是内核的一部分，依赖于特定的硬件和内核环境。因此，测试程序需要模拟一些数据结构（如tcpc_device, oplus_mms_wired等）和函数（如oplus_chg_ic_func, tcpm_set_pd_local_source_cap等），以便在测试中运行。 由于实际环境复杂，这里我们只能提供一个概念性的测试框架，使用printk代替实际的操作，并模拟部分数据结构。 测试目标： 1. 测试函数`oplus_wired_set_otg_boost_curr_limit`，模拟设置OTG电流限制。 2. 测试函数`update_pdo_source_cap`，根据SOC更新PDO电源能力。 3. 测试工作队列函数`oplus_wired_otg_cc_limit_by_soc_work`，模拟根据SOC调整OTG电流限制和PDO。 我们将创建一个内核模块，在该模块中： - 模拟`struct oplus_mms_wired`结构体，并初始化必要的成员。 - 模拟`struct tcpc_device`，并设置`pd_port.pe_pd_state`为`PE_SRC_READY`。 - 创建一个模拟的`work_struct`，并手动调度它（通过`schedule_work`）来测试工作队列函数。 注意：由于实际代码中使用了全局变量`g_mms_wired`和`OTG_CURR`，我们也需要在测试模块中模拟它们。 步骤： 1. 定义模拟的结构体和全局变量。 2. 实现模拟的`oplus_chg_ic_func`、`tcpm_set_pd_local_source_cap`、`tcpm_dpm_pd_source_cap`等函数（打印日志并返回成功）。 3. 在测试模块的初始化函数中： a. 分配并初始化模拟的`struct oplus_mms_wired`。 b. 设置`g_mms_wired`指向这个模拟的结构体。 c. 初始化工作队列（在原始代码中，工作队列是结构体的一部分，我们也要初始化它）。 d. 设置一些初始状态（如`ui_soc`，`otg_online`等）。 e. 调度工作队列（或直接调用工作队列函数进行测试）。 4. 在退出函数中清理资源。 但是，由于原始代码中`update_pdo_source_cap`函数依赖于从`tcpc_dev_get_by_name`获取到的`tcpc`设备，我们需要模拟这个函数返回我们模拟的`tcpc_device`。 考虑到复杂性，我们只写一个简单的测试模块框架，用printk输出关键步骤，并手动检查日志。 以下是一个测试模块的示例代码。注意：这只是一个框架，不能直接运行在真实设备上，需要在模拟环境中测试（如使用QEMU测试内核模块，或者在内核中已有这些模拟接口的情况下运行）。 由于代码较长，我们分块写： 注意：以下代码仅为示例，需要根据实际内核模块编程规范编写，并且需要模拟的环境支持。</think>以下是为提供的代码编写的测试程序框架（基于Linux内核模块环境）。这个测试程序模拟了不同SOC条件下的OTG电流限制和PDO更新逻辑： ```c #include <linux/module.h> #include <linux/kernel.h> #include <linux/workqueue.h> // 模拟常量定义 #define OPCHG_OTG_CC_LIMIT_LOW_SOC 20 #define OPCHG_OTG_CC_LIMIT_HIGH_SOC 80 #define OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_LIMIT 1300 #define OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_MIU_LIMIT 1800 #define OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_HIGH_LIMIT 2100 #define PE_SRC_READY 6 // 模拟全局变量 int OTG_CURR = 0; struct oplus_mms_wired *g_mms_wired; // 模拟结构体 struct oplus_mms_wired { struct work_struct otg_cc_limit_by_soc_work; int ui_soc; bool update_pdo_called; }; struct tcpc_device { struct pd_port pd_port; }; struct pd_port { int pe_pd_state; }; // 模拟函数实现 int oplus_chg_ic_func(void *buck_ic, int func, int curr_ma) { printk("Simulate set OTG current: %dmA\n", curr_ma); return 0; } int tcpm_set_pd_local_source_cap(struct tcpc_device *tcpc, void *cap) { printk("Simulate set PD source cap\n"); return 0; } int tcpm_dpm_pd_source_cap(struct tcpc_device *tcpc, void *null) { printk("Simulate PD source cap DPM\n"); return 0; } struct tcpc_device *tcpc_dev_get_by_name(const char *name) { static struct tcpc_device dev = { .pd_port.pe_pd_state = PE_SRC_READY }; return &dev; } int oplus_wired_get_otg_online_status(void *topic) { return 1; // 模拟OTG在线状态 } // 需要测试的函数 int oplus_wired_set_otg_boost_curr_limit(int curr_ma) { printk("Setting OTG current: %dmA\n", curr_ma); OTG_CURR = curr_ma; return 0; } int update_pdo_source_cap(int ui_soc) { struct tcpc_device *tcpc = tcpc_dev_get_by_name("type_c_port0"); printk("Updating PDO for SOC: %d%%, PD state: %d\n", ui_soc, tcpc->pd_port.pe_pd_state); return 0; } static void oplus_wired_otg_cc_limit_by_soc_work(struct work_struct *work) { struct oplus_mms_wired *chip = container_of(work, struct oplus_mms_wired, otg_cc_limit_by_soc_work); int rc = 0; int otg_online = oplus_wired_get_otg_online_status(NULL); printk("\n--- Workqueue Start: SOC=%d%%, OTG=%s, Current=%dmA ---\n", chip->ui_soc, otg_online ? "Online" : "Offline", OTG_CURR); if (!chip->update_pdo_called) { rc = update_pdo_source_cap(chip->ui_soc); chip->update_pdo_called = true; } if (otg_online) { if (chip->ui_soc <= OPCHG_OTG_CC_LIMIT_LOW_SOC && OTG_CURR != OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_LIMIT) { printk("LOW SOC DETECTED! Setting 1.3A limit\n"); oplus_wired_set_otg_boost_curr_limit(OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_LIMIT); update_pdo_source_cap(chip->ui_soc); } else if (chip->ui_soc >= OPCHG_OTG_CC_LIMIT_HIGH_SOC && OTG_CURR != OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_HIGH_LIMIT) { printk("HIGH SOC DETECTED! Setting 2.1A limit\n"); oplus_wired_set_otg_boost_curr_limit(OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_HIGH_LIMIT); update_pdo_source_cap(chip->ui_soc); } else if (OTG_CURR != OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_MIU_LIMIT) { printk("MID SOC RANGE! Setting 1.8A limit\n"); oplus_wired_set_otg_boost_curr_limit(OPCHG_USBTEMP_OTG_CC_BOOT_CURRENT_MIU_LIMIT); update_pdo_source_cap(chip->ui_soc); } } printk("--- Workqueue End ---\n\n"); } // 测试用例 static void run_test_case(int soc) { struct oplus_mms_wired *chip = kzalloc(sizeof(*chip), GFP_KERNEL); INIT_WORK(&chip->otg_cc_limit_by_soc_work, oplus_wired_otg_cc_limit_by_soc_work); chip->ui_soc = soc; chip->update_pdo_called = false; g_mms_wired = chip; printk("======== TEST CASE: SOC=%d%% ========\n", soc); schedule_work(&chip->otg_cc_limit_by_soc_work); flush_work(&chip->otg_cc_limit_by_soc_work); kfree(chip); } // 模块初始化 static int __init test_module_init(void) { printk("===== OTG Current Limit Test Module Start =====\n"); // 运行不同SOC的测试用例 run_test_case(10); // 低于20% run_test_case(20); // 边界值 run_test_case(50); // 中间值 run_test_case(80); // 边界值 run_test_case(90); // 高于80% printk("===== All Tests Completed =====\n"); return 0; } // 模块退出 static void __exit test_module_exit(void) { printk("Test module unloaded\n"); } module_init(test_module_init); module_exit(test_module_exit); MODULE_LICENSE("GPL"); ``` ### 测试说明： 1. **测试场景**： - 模拟5种SOC状态：10%(低)、20%(边界)、50%(中)、80%(边界)、90%(高) - 验证OTG电流限制逻辑（1.3A/1.8A/2.1A） - 检查PDO更新触发条件 2. **关键验证点**： - `update_pdo_called`标志位确保PDO只更新一次 - SOC边界值处理（20%和80%） - 电流限制值切换逻辑 - OTG在线状态检测 3. **使用方法**： - 编译为内核模块并插入 - 通过`dmesg`查看测试输出 - 输出将显示每个SOC条件下的电流设置和PDO更新操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值