【Linux】一步一步学Linux——chage命令(92)

00. 目录

文章目录

01. 命令概述

chage - 更改用户密码过期信息

chage命令是用来修改帐号和密码的有效期限；这个信息由系统用于确定用户何时必须更改其密码。

02. 命令格式

用法：chage [选项] 登录名

  • 1

03. 常用选项

选项：
  -d, --lastday 最近日期        将最近一次密码设置时间设为“最近日期”
  -E, --expiredate 过期日期     将帐户过期时间设为“过期日期”
  -h, --help                    显示此帮助信息并推出
  -I, --inactive INACITVE       过期 INACTIVE 天数后，设定密码为失效状态
  -l, --list                    显示帐户年龄信息
  -m, --mindays 最小天数        将两次改变密码之间相距的最小天数设为“最小天数”
  -M, --maxdays 最大天数        将两次改变密码之间相距的最大天数设为“最大天数”
  -R, --root CHROOT_DIR         chroot 到的目录
  -W, --warndays 警告天数       将过期警告天数设为“警告天数”

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

04. 参考示例

4.1 显示帐户年龄信息

[root@redhat ~]# chage -l deng
最近一次密码修改时间                                    ：7月 31, 2019
密码过期时间                                    ：从不
密码失效时间                                    ：从不
帐户过期时间                                            ：从不
两次改变密码之间相距的最小天数          ：0
两次改变密码之间相距的最大天数          ：99999
在密码过期之前警告的天数        ：7
[root@redhat ~]# 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

4.2 设置两次改变密码之间相距的最大天数

[root@itcast ~]# chage  -M 90 tom
[root@itcast ~]# 

  • 1
  • 2

chage -M 5 tom如果今天是2013-2-18用户密码在2013-2-23之前使用都正常2013-2-24会提示用户需要修改密码。

4.3 设置两次改变密码之间相距的最小天数

[root@itcast ~]# chage -m 30 tom
[root@itcast ~]# chage -l tom
最近一次密码修改时间                                    ：8月 01, 2019
密码过期时间                                    ：10月 30, 2019
密码失效时间                                    ：从不
帐户过期时间                                            ：从不
两次改变密码之间相距的最小天数          ：30
两次改变密码之间相距的最大天数          ：90
在密码过期之前警告的天数        ：7
[root@itcast ~]# 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

chage -m 5 tom意思就是说如果今天是2013-2-18用户密码在2013-2-22之前无法修改2013-2-23可以修改密码。

4.4 强制用户登陆时修改口令

[root@itcast ~]# chage -d 0 tom
[root@itcast ~]# 

  • 1
  • 2

如果接数字的话是从1970年1月1日累加的如 chage -d 5 tom修改时间就变成1970年1月6日。也可以直接接日期如 chage -d 2013-02-18 tom密码修改时间就变成了2013年2月18日。如果

用命令 chage -d 0 tom则代表该用户需立即修改密码。

4.5 账号的有效期是2020-09-30

[root@itcast ~]# chage -E '2020-09-30' tom
[root@itcast ~]# chage -l tom
最近一次密码修改时间                                    ：密码必须更改
密码过期时间                                    ：密码必须更改
密码失效时间                                    ：密码必须更改
帐户过期时间                                            ：9月 30, 2020
两次改变密码之间相距的最小天数          ：30
两次改变密码之间相距的最大天数          ：90
在密码过期之前警告的天数        ：7
[root@itcast ~]# 

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

用法也是直接接数字或者日期如 chage -E 2013-02-18 tom表示tom用户在2013年2月19日这一天失效无法使用。
默认时间是永远有效如果想要让用户永远有效改成 chage -E -1 tom即可。

4.6 过期5天数后，设定密码为失效状态

[root@itcast ~]# chage -I 5 tom

  • 1

chage -M 5 -I 2 tom如果今天是2013-2-18用户密码在2013-2-23之前使用都正常2013-2-24和25号会提示用户需要修改密码如果这两天都没有修改密码账户会在2013-2-26号失效。
如果密码过使用期后永不禁用账户命令为chage -E -1 tom即可。

4.7 设置密码过期前的提醒时间

[root@itcast ~]# chage -W 7 tom
[root@itcast ~]# chage -l tom
最近一次密码修改时间                                    ：密码必须更改
密码过期时间                                    ：密码必须更改
密码失效时间                                    ：密码必须更改
帐户过期时间                                            ：从不
两次改变密码之间相距的最小天数          ：0
两次改变密码之间相距的最大天数          ：90
在密码过期之前警告的天数        ：7

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

chage -M 5 -W 3 tom如果今天是2013-2-18在用户21 22 23号这三天登录系统时候得到距离密码最后使用时间的提示。

4.8 综合实例

[root@itcast ~]# chage -d 0 -m 0 -M 90 -W 15 tom  

  • 1

强制用户下次登陆时修改密码，并且设置密码最低有效期0和最高有限期90，提前15天发警报提示

05. 附录

参考：【Linux】一步一步学Linux系列教程汇总

id="article_content" class="article_content clearfix"> id="content_views" class="markdown_views prism-atom-one-light">

内存管理模块管理系统的内存资源，它是操作系统的核心模块之一，主要包括内存的初始化、分配以及释放。

在系统运行过程中，内存管理模块通过对内存的申请/释放来管理用户和OS对内存的使用，使内存的利用率和使用效率达到最优，同时最大限度地解决系统的内存碎片问题。

鸿蒙轻内核的内存管理分为静态内存管理和动态内存管理，提供内存初始化、分配、释放等功能。

  • 动态内存：在动态内存池中分配用户指定大小的内存块。

    • 优点：按需分配。
    • 缺点：内存池中可能出现碎片。

  • 静态内存：在静态内存池中分配用户初始化时预设（固定）大小的内存块。

    • 优点：分配和释放效率高，静态内存池中无碎片。
    • 缺点：只能申请到初始化预设大小的内存块，不能按需申请。

本文主要分析鸿蒙轻内核静态内存（Memory Box），后续系列会继续分析动态内存。静态内存实质上是一个静态数组，静态内存池内的块大小在初始化时设定，初始化后块大小不可变更。静态内存池由一个控制块和若干相同大小的内存块构成。控制块位于内存池头部，用于内存块管理。内存块的申请和释放以块大小为粒度。

本文通过分析静态内存模块的源码，帮助读者掌握静态内存的使用。本文中所涉及的源码，以OpenHarmony LiteOS-M内核为例，均可以在开源站点 https://gitee.com/openharmony/kernel_liteos_m 获取。

接下来，我们看下静态内存的结构体，静态内存初始化，静态内存常用操作的源代码。

1、静态内存结构体定义和常用宏定义

1.1 静态内存结构体定义

静态内存结构体在文件kernel\include\los_membox.h中定义。源代码如下，⑴处定义的是静态内存节点LOS_MEMBOX_NODE结构体，⑵处定义的静态内存的结构体池信息结构体为LOS_MEMBOX_INFO，，结构体成员的解释见注释部分。

⑴  typedef struct tagMEMBOX_NODE {
        struct tagMEMBOX_NODE *pstNext; /**< 静态内存池中空闲节点指针，指向下一个空闲节点 */
    } LOS_MEMBOX_NODE;

⑵  typedef struct LOS_MEMBOX_INFO {
        UINT32 uwBlkSize;               /**< 静态内存池中空闲节点指针，指向下一个空闲节点 */
        UINT32 uwBlkNum;                /**< 静态内存池的内存块总数量 */
        UINT32 uwBlkCnt;                /**< 静态内存池的已分配的内存块总数量 */
    #if (LOSCFG_PLATFORM_EXC == 1)
        struct LOS_MEMBOX_INFO *nextMemBox; /**< 指向下一个静态内存池 */
    #endif
        LOS_MEMBOX_NODE stFreeList;     /**< 静态内存池的空闲内存块单向链表 */
    } LOS_MEMBOX_INFO;
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

对静态内存使用如下示意图进行说明，对一块静态内存区域，头部是LOS_MEMBOX_INFO信息，接着是各个内存块，每块内存块大小是uwBlkSize，包含内存块节点LOS_MEMBOX_NODE和内存块数据区。空闲内存块节点指向下一块空闲内存块节点。

1.2 静态内存常用宏定义

静态内存头文件中还提供了一些重要的宏定义。⑴处的LOS_MEMBOX_ALIGNED(memAddr)用于对齐内存地址，⑵处OS_MEMBOX_NEXT(addr, blkSize)根据当前节点内存地址addr和内存块大小blkSize获取下一个内存块的内存地址。⑶处OS_MEMBOX_NODE_HEAD_SIZE表示内存块中节点头大小，每个内存块包含内存节点LOS_MEMBOX_NODE和存放业务的数据区。⑷处表示静态内存的总大小，包含内存池信息结构体占用的大小，和各个内存块占用的大小。

⑴  #define LOS_MEMBOX_ALIGNED(memAddr) (((UINTPTR)(memAddr) + sizeof(UINTPTR) - 1) & (~(sizeof(UINTPTR) - 1)))

⑵  #define OS_MEMBOX_NEXT(addr, blkSize) (LOS_MEMBOX_NODE *)(VOID *)((UINT8 *)(addr) + (blkSize))

⑶  #define OS_MEMBOX_NODE_HEAD_SIZE sizeof(LOS_MEMBOX_NODE)

⑷  #define LOS_MEMBOX_SIZE(blkSize, blkNum) \
    (sizeof(LOS_MEMBOX_INFO) + (LOS_MEMBOX_ALIGNED((blkSize) + OS_MEMBOX_NODE_HEAD_SIZE) * (blkNum)))
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

在文件kernel\src\mm\los_membox.c中也定义了一些宏和内联函数。⑴处定义OS_MEMBOX_MAGIC魔术字，这个32位的魔术字的后8位维护任务编号信息，任务编号位由⑵处的宏定义。⑶处宏定义任务编号的最大值，⑷处的宏从魔术字中提取任务编号信息。

⑸处内联函数设置魔术字，在内存块节点从静态内存池中分配出来后，节点指针.pstNext不再指向下一个空闲内存块节点，而是设置为魔术字。⑹处的内联函数用于校验魔术字。⑺处的宏根据内存块的节点地址获取内存块的数据区地址，⑻处的宏根据内存块的数据区地址获取内存块的节点地址。

⑴  #define OS_MEMBOX_MAGIC         0xa55a5a00

⑵  #define OS_MEMBOX_TASKID_BITS   8

⑶  #define OS_MEMBOX_MAX_TASKID    ((1 << OS_MEMBOX_TASKID_BITS) - 1)

⑷  #define OS_MEMBOX_TASKID_GET(addr) (((UINTPTR)(addr)) & OS_MEMBOX_MAX_TASKID)

⑸  STATIC INLINE VOID OsMemBoxSetMagic(LOS_MEMBOX_NODE *node)
    {
        UINT8 taskID = (UINT8)LOS_CurTaskIDGet();
        node->pstNext = (LOS_MEMBOX_NODE *)(OS_MEMBOX_MAGIC | taskID);
    }

⑹  STATIC INLINE UINT32 OsMemBoxCheckMagic(LOS_MEMBOX_NODE *node)
    {
        UINT32 taskID = OS_MEMBOX_TASKID_GET(node->pstNext);
        if (taskID > (LOSCFG_BASE_CORE_TSK_LIMIT + 1)) {
            return LOS_NOK;
        } else {
            return (node->pstNext == (LOS_MEMBOX_NODE *)(OS_MEMBOX_MAGIC | taskID)) ? LOS_OK : LOS_NOK;
        }
    }

⑺  #define OS_MEMBOX_USER_ADDR(addr) \
        ((VOID *)((UINT8 *)(addr) + OS_MEMBOX_NODE_HEAD_SIZE))

⑻  #define OS_MEMBOX_NODE_ADDR(addr) \
        ((LOS_MEMBOX_NODE *)(VOID *)((UINT8 *)(addr) - OS_MEMBOX_NODE_HEAD_SIZE))
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">

2、静态内存常用操作

当用户需要使用固定长度的内存时，可以通过静态内存分配的方式获取内存，一旦使用完毕，通过静态内存释放函数归还所占用内存，使之可以重复使用。

2.1 初始化静态内存池

我们分析下初始化静态内存池函数UINT32 LOS_MemboxInit(VOID *pool, UINT32 poolSize, UINT32 blkSize)的代码。我们先看看函数参数，VOID *pool是静态内存池的起始地址，UINT32 poolSize是初始化的静态内存池的总大小，poolSize需要小于等于*pool开始的内存区域的大小，否则会影响后面的内存区域。还需要大于静态内存的头部大小sizeof(LOS_MEMBOX_INFO)。长度UINT32 blkSize是静态内存池中的每个内存块的块大小。

我们看下代码，⑴处对传入参数进行校验。⑵处设置静态内存池中每个内存块的实际大小，已内存对齐，也算上内存块中节点信息。⑶处计算内存池中内存块的总数量，然后设置已用内存块数量.uwBlkCnt为0。
⑷处如果可用的内存块为0，返回初始化失败。⑸处获取内存池中的第一个空闲内存块节点。⑹处把空闲内存块挂载在静态内存池信息结构体空闲内存块链表stFreeList.pstNext上，然后执行⑺每个空闲内存块依次指向下一个空闲内存块，链接起来。

UINT32 LOS_MemboxInit(VOID *pool, UINT32 poolSize, UINT32 blkSize)
{
    LOS_MEMBOX_INFO *boxInfo = (LOS_MEMBOX_INFO *)pool;
    LOS_MEMBOX_NODE *node = NULL;
    UINT32 index;
    UINT32 intSave;

⑴  if (pool == NULL) {
        return LOS_NOK;
    }

    if (blkSize == 0) {
        return LOS_NOK;
    }

    if (poolSize < sizeof(LOS_MEMBOX_INFO)) {
        return LOS_NOK;
    }

    MEMBOX_LOCK(intSave);
⑵  boxInfo->uwBlkSize = LOS_MEMBOX_ALIGNED(blkSize + OS_MEMBOX_NODE_HEAD_SIZE);
    if (boxInfo->uwBlkSize == 0) {
        MEMBOX_UNLOCK(intSave);
        return LOS_NOK;
    }
⑶  boxInfo->uwBlkNum = (poolSize - sizeof(LOS_MEMBOX_INFO)) / boxInfo->uwBlkSize;
    boxInfo->uwBlkCnt = 0;
⑷  if (boxInfo->uwBlkNum == 0) {
        MEMBOX_UNLOCK(intSave);
        return LOS_NOK;
    }

⑸  node = (LOS_MEMBOX_NODE *)(boxInfo + 1);

⑹  boxInfo->stFreeList.pstNext = node;

⑺  for (index = 0; index < boxInfo->uwBlkNum - 1; ++index) {
        node->pstNext = OS_MEMBOX_NEXT(node, boxInfo->uwBlkSize);
        node = node->pstNext;
    }

    node->pstNext = NULL;

#if (LOSCFG_PLATFORM_EXC == 1)
    OsMemBoxAdd(pool);
#endif

    MEMBOX_UNLOCK(intSave);

    return LOS_OK;
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
class="hide-preCode-box">

2.2 清除静态内存块内容

我们可以使用函数VOID LOS_MemboxClr(VOID *pool, VOID *box)来清除静态内存块中的数据区内容，需要2个参数，VOID *pool是初始化过的静态内存池地址。VOID *box是需要清除内容的静态内存块的数据区的起始地址，注意这个不是内存块的节点地址，每个内存块的节点区不能清除。下面分析下源码。

⑴处对参数进行校验，⑵处调用memset_s()函数把内存块的数据区写入0。写入的开始地址是内存块的数据区的起始地址VOID *box，写入长度是数据区的长度boxInfo->uwBlkSize - OS_MEMBOX_NODE_HEAD_SIZE。

VOID LOS_MemboxClr(VOID *pool, VOID *box)
{
    LOS_MEMBOX_INFO *boxInfo = (LOS_MEMBOX_INFO *)pool;

⑴  if ((pool == NULL) || (box == NULL)) {
        return;
    }

⑵  (VOID)memset_s(box, (boxInfo->uwBlkSize - OS_MEMBOX_NODE_HEAD_SIZE), 0,
                   (boxInfo->uwBlkSize - OS_MEMBOX_NODE_HEAD_SIZE));
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

2.3 申请、释放静态内存

初始化静态内存池后，我们可以使用函数VOID *LOS_MemboxAlloc(VOID *pool)来申请静态内存，下面分析下源码。

⑴处获取静态内存池空闲内存块链表头结点，如果链表不为空，执行⑵，把下一个可用节点赋值给nodeTmp。⑶处把链表头结点执行下一个的下一个链表节点，然后执行⑷把分配出来的内存块设置魔术字，接着把内存池已用内存块数量加1。⑸处返回时调用宏OS_MEMBOX_USER_ADDR()计算出内存块的数据区域地质。

VOID *LOS_MemboxAlloc(VOID *pool)
{
    LOS_MEMBOX_INFO *boxInfo = (LOS_MEMBOX_INFO *)pool;
    LOS_MEMBOX_NODE *node = NULL;
    LOS_MEMBOX_NODE *nodeTmp = NULL;
    UINT32 intSave;

    if (pool == NULL) {
        return NULL;
    }

    MEMBOX_LOCK(intSave);
⑴  node = &(boxInfo->stFreeList);
    if (node->pstNext != NULL) {
⑵      nodeTmp = node->pstNext;
⑶      node->pstNext = nodeTmp->pstNext;
⑷      OsMemBoxSetMagic(nodeTmp);
        boxInfo->uwBlkCnt++;
    }
    MEMBOX_UNLOCK(intSave);

⑸  return (nodeTmp == NULL) ? NULL : OS_MEMBOX_USER_ADDR(nodeTmp);
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

对申请的内存块使用完毕，我们可以使用函数UINT32 LOS_MemboxFree(VOID *pool, VOID *box)来释放静态内存，需要2个参数，VOID *pool是初始化过的静态内存池地址。VOID *box是需要释放的静态内存块的数据区的起始地址，注意这个不是内存块的节点地址。下面分析下源码。

⑴处根据待释放的内存块的数据区域地址获取节点地址node，⑵对要释放的内存块先进行校验。⑶处把要释放的内存块挂在内存池空闲内存块链表上，然后执行⑷把已用数量减1。

LITE_OS_SEC_TEXT UINT32 LOS_MemboxFree(VOID *pool, VOID *box)
{
    LOS_MEMBOX_INFO *boxInfo = (LOS_MEMBOX_INFO *)pool;
    UINT32 ret = LOS_NOK;
    UINT32 intSave;

    if ((pool == NULL) || (box == NULL)) {
        return LOS_NOK;
    }

    MEMBOX_LOCK(intSave);
    do {
⑴      LOS_MEMBOX_NODE *node = OS_MEMBOX_NODE_ADDR(box);
⑵      if (OsCheckBoxMem(boxInfo, node) != LOS_OK) {
            break;
        }

⑶      node->pstNext = boxInfo->stFreeList.pstNext;
        boxInfo->stFreeList.pstNext = node;
⑷      boxInfo->uwBlkCnt--;
        ret = LOS_OK;
    } while (0);
    MEMBOX_UNLOCK(intSave);

    return ret;
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

接下来，我们再看看校验函数OsCheckBoxMem()。⑴如果内存池的块大小为0，返回校验失败。⑵处计算出要释放的内存快节点相对第一个内存块节点的偏移量offset。⑶如果偏移量除以内存块数量余数不为0，返回校验失败。⑷如果偏移量除以内存块数量的商大于等于内存块的数量，返回校验失败。⑸调用宏OsMemBoxCheckMagic校验魔术字。

STATIC INLINE UINT32 OsCheckBoxMem(const LOS_MEMBOX_INFO *boxInfo, const VOID *node)
{
    UINT32 offset;

⑴  if (boxInfo->uwBlkSize == 0) {
        return LOS_NOK;
    }

⑵  offset = (UINT32)((UINTPTR)node - (UINTPTR)(boxInfo + 1));
⑶  if ((offset % boxInfo->uwBlkSize) != 0) {
        return LOS_NOK;
    }

⑷  if ((offset / boxInfo->uwBlkSize) >= boxInfo->uwBlkNum) {
        return LOS_NOK;
    }

⑸   return OsMemBoxCheckMagic((LOS_MEMBOX_NODE *)node);
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

小结

本文带领大家一起剖析了鸿蒙轻内核的静态内存模块的源代码，包含静态内存的结构体、静态内存池初始化、静态内存申请、释放、清除内容等。

如果大家想更加深入的学习 OpenHarmony 开发的内容，不妨可以参考以下相关学习文档进行学习，助你快速提升自己：

OpenHarmony 开发环境搭建：https://qr18.cn/CgxrRy

《OpenHarmony源码解析》：https://qr18.cn/CgxrRy

系统架构分析：https://qr18.cn/CgxrRy

OpenHarmony 设备开发学习手册：https://qr18.cn/CgxrRy

在这里插入图片描述

OpenHarmony面试题（内含参考答案）：https://qr18.cn/CgxrRy

data-report-view="{"mod":"1585297308_001","spm":"1001.2101.3001.6548","dest":"https://blog.csdn.net/maniuT/article/details/139499668","extend1":"pc","ab":"new"}">> id="blogExtensionBox" style="width:400px;margin:auto;margin-top:12px" class="blog-extension-box"> class="blog_extension blog_extension_type2" id="blog_extension"> class="extension_official" data-report-click="{"spm":"1001.2101.3001.6471"}" data-report-view="{"spm":"1001.2101.3001.6471"}"> class="blog_extension_card_left"> class="blog_extension_card_cont"> 鸿蒙开发学习资料领取！！！ class="blog_extension_card_cont_r"> 微信名片
注：本文转载自blog.csdn.net的沧海一笑-dj的文章"https://blog.csdn.net/dengjin20104042056/article/details/98110141"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！