【问题标题】:Determining Whether Pointer is Valid判断指针是否有效
【发布时间】:2011-06-03 11:59:10
【问题描述】:

据我观察,如果在ptr 不是指向系统分配内存的有效指针的情况下调用free( ptr ),则会发生访问冲突。假设我这样称呼free:

LPVOID ptr = (LPVOID)0x12345678;
free( ptr );

这肯定会导致访问冲突。有没有办法测试ptr指向的内存位置是有效的系统分配内存?

在我看来,Windows 操作系统内核的内存管理部分必须知道哪些内存已分配,哪些内存尚待分配。否则,它怎么知道是否有足够的内存来满足给定的请求? (修辞) 话虽如此,似乎有理由得出结论,必须有一个函数(或一组函数)允许用户确定指针是否是有效的系统分配内存。也许微软还没有公开这些功能。如果微软没有提供这样的 API,我只能假设这是出于故意和特定的原因。在系统中提供这样的钩子会对系统安全构成重大威胁吗?

情况报告

虽然知道内存指针是否有效在许多情况下可能很有用,但这是我的特殊情况:

我正在为一个新硬件编写驱动程序,以替换通过 USB 连接到 PC 的现有硬件。我的任务是编写新的驱动程序,以便对当前驱动程序的现有 API 的调用将继续在使用它的 PC 应用程序中工作。因此,对现有应用程序唯一需要的更改是在启动时加载适当的驱动程序 DLL。这里的问题是现有驱动程序使用回调将接收到的串行消息发送到应用程序;指向包含消息的已分配内存的指针通过回调从驱动程序传递给应用程序。然后应用程序负责调用另一个驱动程序 API,通过将相同的指针从应用程序传递回驱动程序来释放内存。在这种情况下,第二个 API 无法确定应用程序是否实际上已经传回了指向有效内存的指针。

【问题讨论】:

  • 你不能只写一个理智的代码吗?释放你分配的一切,别无其他。
  • 在某一时刻,您一定已经分配了内存。所以你应该已经知道它的价值了。测试内存的有效性以释放的需求讲述了一个关于代码质量的长篇故事。我的建议是在尝试解决此特定问题之前清理您的内存处理。
  • 您可以通过安全的免费解决此问题的根源之一:en.wikipedia.org/wiki/Dangling_pointer
  • 您可能想深入了解微软的堆实现 RtlHeap 的内部结构。请注意,使用 HeapAlloc 的单个分配很可能对应于 C 运行时(提供 malloc)完成的多个分配。它不会保留所有可用内存的列表或任何类似的分析——它有可用内存块的列表并根据要求将它们分发出去,但它绝不会维护内存布局的完整图景。另外,通常每个 DLL 至少有一个堆,并且这些堆彼此不知道(即堆 A 中的有效指针在堆 B 中无效)
  • @Jim Fell:我阅读了您的编辑,但我看不到它如何改变这种情况。我意识到您希望它尽可能健壮,但显然应用程序有责任不搞砸内存管理(换句话说,它是接口合同的一部分)。这与您必须传递对 free() 和 delete 有效的东西的要求没有太大区别,否则它们的行为将是未定义的。

标签: c++ memory pointers free


【解决方案1】:

实际上有一些名为IsBadReadPtr()、IsBadWritePtr()、IsBadStringPtr() 和IsBadCodePtr() 的函数可能 可以完成这项工作,但do not use it ever。我提到这一点只是为了让您知道这些选项不值得追求。

您最好确保将所有指针设置为 NULL 或 0,当它指向任何内容并检查时。

例如:

// Set ptr to zero right after deleting the pointee.
delete ptr; // It's okay to call delete on zero pointers, but it
            // certainly doesn't hurt to check.

注意:这可能是某些编译器 (see the section "Code Size" on this page) 的性能问题,因此实际上可能值得先对零进行自检。

ptr = 0;

// Set ptr to zero right after freeing the pointee.
if(ptr != 0)
{
    free(ptr); // According to Matteo Italia (see comments)
               // it's also okay to pass a zero pointer, but
               // again it doesn't hurt.
    ptr = 0;
}

// Initialize to zero right away if this won't take on a value for now.
void* ptr = 0;

更好的是使用RAII 的一些变体,而不必直接处理指针:

class Resource
{
public:
    // You can also use a factory pattern and make this constructor
    // private.
    Resource() : ptr(0)
    {
        ptr = malloc(42); // Or new[] or AcquiteArray() or something
        // Fill ptr buffer with some valid values
    }

    // Allow users to work directly with the resource, if applicable
    void* GetPtr() const { return ptr; }

    ~Resource()
    {
        if(ptr != 0)
        {
            free(ptr); // Or delete[] or ReleaseArray() or something

            // Assignment not actually necessary in this case since
            // the destructor is always the last thing that is called
            // on an object before it dies.
            ptr = 0;            
        }
    }

private:
    void* ptr;
};

如果适用,或者使用标准容器(这实际上是 RAII 的应用):

std::vector<char> arrayOfChars;

【讨论】:

  • IsBadReadPtr 与指针是否指向有效堆分配块的开头无关。
  • @In silico:+1 表示“永远不要使用它”。 @zeuxcg:为什么堆分配块的开头很重要?当然,块后面的指针仍然完全有效。 (可能不是专门针对free,但问题是询问一般情况)
  • @zeuxcg:我知道,但我再次提到它们只是因为有人会偶然发现它们并认为它们可以提供帮助。他们没有。
  • @In silico: +1,顺便说一句,也可以在 NULL 指针上调用 free。
  • 将零分配给指针很可能一无所获,因为没有人会将非常量左值引用传递给指针,而是您将指针按值传递并且您正在将副本归零,您很快就会丢弃它。
【解决方案2】:

简短回答:不。

windows 中有一个函数应该告诉你指针是否指向真实内存(IsBadreadPtr() 和它的同类)但是 it doesn't work 你不应该使用它!

解决问题的真正方法是始终将指针初始化为 NULL,并在 deleted 后将它们重置为 NULL。

根据您的编辑进行编辑:

您实际上是在暗示一个更大的问题:面对出错的客户端代码,您如何确保您的代码继续正常运行?

这确实应该是一个问题。没有简单的答案。但这取决于您所说的“继续正常运行”是什么意思。

有两种理论。有人说,即使客户端代码向您发送完全废话,您也应该能够跋涉,丢弃垃圾并处理好数据。实现这一点的关键是异常处理。如果您在处理客户端数据时发现异常,请回滚您的状态并尝试返回,就好像他们根本没有给您打电话一样。

另一种理论是甚至不尝试继续,而只是失败。失败可以是优雅的,并且应该包括一些全面的日志记录,以便可以识别问题并希望在实验室中解决。启动错误消息。告诉用户下次要尝试的一些事情。生成小型转储,并自动将它们发送回商店。但是,然后,关闭。

我倾向于赞同第二种理论。当客户端代码开始发送废话时,系统的稳定性往往会受到威胁。他们可能已经损坏了堆。所需资源可能不可用。谁知道可能是什么问题。你可能会得到一些好的数据和不好的数据,但你甚至不知道好的数据是否真的是好的。所以尽快关闭,以降低风险。

【讨论】:

  • 这些都是很好的建议;我一定会记住它们。
【解决方案3】:

为了解决您的具体问题,我认为您不必担心检查指针。如果应用程序向您的 DLL 传递了一个无效地址,则表示应用程序中存在内存管理问题。无论您如何编写驱动程序,都无法修复真正的错误。

为了帮助应用程序开发人员调试他们的问题,您可以将magic number 添加到您返回给应用程序的对象中。当你的库被调用来释放一个对象时,检查这个数字,如果它不存在,打印一个调试警告并且不要释放它!即:

#define DATA_MAGIC 0x12345678
struct data {
    int foo;    /* The actual object data. */
    int magic;  /* Magic number for memory debugging. */
};

struct data *api_recv_data() {
    struct data *d = malloc(sizeof(*d));
    d->foo = whatever;
    d->magic = DATA_MAGIC;
    return d;
}

void api_free_data(struct data *d) {
    if (d->magic == DATA_MAGIC) {
        d->magic = 0;
        free(d);
    } else {
        fprintf(stderr, "api_free_data() asked to free invalid data %p\n", d);
    }
}

这只是一种调试技术。如果应用程序没有内存错误,这将正常工作。如果应用程序确实存在问题,这将可能提醒开发人员注意错误。它之所以有效,是因为您的实际问题比您最初的问题所表明的要严格得多。

【讨论】:

  • 如果我理解正确,这将起作用,因为指向结构的指针和指向该结构中第一个元素的指针是相同的。该应用程序将忽略该结构的其他元素。非常聪明!为什么这不适用于发布版本(当然,没有调试提示)?
  • @Jim:您可以通过两种方式做到这一点:(1)将原始数据结构作为第一个元素嵌入到带有幻数(您在想什么)的新数据结构中,或者( 2)通过增加一个元素来改变原来的数据结构定义。根据数据结构的使用方式,两者都可以工作。我的代码显示(2)正在使用。要使 (1) 无错误地编译,还需要做更多的工作。
  • @Jim:这将在发布版本中正常工作。将此技术归入与assert() 相同的类别。它唯一的好处是发现错误。它对正确的程序没有任何作用,只是让它们稍微慢一些。当然,有没有正确的程序这样的东西? ;)
  • 请注意,如果d 是一个非常无效的指针(如问题示例中的指针),则访问d-&gt;magic 仍会出现段错误。
【解决方案4】:

不,你应该知道你的指针是否指向正确分配的内存。

【讨论】:

  • 这没有帮助,也没有建设性。
  • 但这是真的。 ;) 该语言的设计假设您拥有此信息。
【解决方案5】:

没有。您只应该有一个指向您知道有效的内存的指针,通常是因为您在同一个程序中分配了它。正确跟踪您的内存分配,然后您甚至不需要这个!

此外,您通过尝试 free 一个无效指针来调用未定义行为,因此它可能会崩溃或执行任何操作。

另外,free 是从 C 继承的 C++ 标准库的函数,而不是 WinAPI 函数。

【讨论】:

  • 最后一段 +1 -- 通常由 CRT 执行的多次分配显示为对 Windows 本身的一次分配。
【解决方案6】:

首先,在标准中没有什么可以保证这样的事情(freeing 非malloced 指针是未定义的行为)。

无论如何,经过free 只是试图访问该内存的曲折路线;如果您想检查指针指向的内存在 Windows 上是否可读/可写,您真的应该尝试并准备好处理 SEH 异常;这实际上是 IsBadxxxPtr 函数所做的,通过在其返回代码中翻译此类异常。

但是,这是一种隐藏细微错误的方法,如this Raymond Chen's post 中所述;所以,长话短说,没有安全的方法来确定指针是否指向有效的东西,我认为,如果你需要在某个地方进行这样的测试,那么该代码中存在一些设计缺陷。

【讨论】:

    【解决方案7】:

    我不会重复每个人已经说过的话,只是为了补充这些答案,这就是存在智能指针的原因 - 使用它们!

    每当您发现自己因内存错误而不得不解决崩溃时 - 退后一步,深呼吸,并解决根本问题 - 尝试解决这些问题是很危险的!

    根据您的更新进行编辑:

    我可以想到两种明智的方法来做到这一点。

    1. 客户端应用程序为您放置消息提供了一个缓冲区,这意味着您的 API 无需担心管理该内存 - 这需要更改您的接口和客户端代码。
    2. 您更改了接口的语义,并强制接口的客户端不必担心内存管理(即,您使用指向仅在回调上下文中有效的指针调用 - 如果客户端需要,他们会他们自己的数据副本)。这不会改变你的界面——你仍然可以用指针回调,但是你的客户需要检查他们是否没有使用该上下文之外的缓冲区——如果他们这样做了,它可能不是你想要的,所以它可以他们修复它是一件好事(?)

    我个人会选择后者,只要您可以确定缓冲区没有在回调之外使用。如果是,那么您将不得不使用hackery(例如已建议使用幻数 - 尽管这并不总是保证有效,例如假设前一个块存在某种形式的缓冲区溢出,并且您不知何故用废话覆盖了幻数 - 那里发生了什么?)

    【讨论】:

      【解决方案8】:

      应用程序内存管理由应用程序开发人员来维护,而不是操作系统(即使在托管语言中,操作系统也不做这项工作,垃圾收集器做)。如果你在堆上分配一个对象,你有责任正确地释放它。如果您不这样做,您的应用程序将泄漏内存。操作系统(至少在 Windows 的情况下)确实知道它让您的应用程序拥有多少内存,并且会在您的应用程序关闭(或崩溃)时回收它,但是没有记录的方式(有效)来查询内存地址,看看它是否是一个分配的块。

      我能给你的最好建议:学会正确管理你的记忆。

      【讨论】:

        【解决方案9】:

        不能访问 malloc 实现的内部。

        您也许可以识别出一些无效指针(例如,那些不指向进程虚拟内存空间中任何位置的指针),但如果您获取一个有效指针并将其加 1,则调用 free() 将无效但仍将指向系统分配的内存。 (更不用说在同一个指针上多次调用free 的常见问题)。

        【讨论】:

        • 即使可以访问内部 malloc 实现,仍然没有通用的方法来做到这一点(除非 malloc 实现维护程序历史中所有已分配指针的列表)
        【解决方案10】:

        除了其他人明确指出这是非常糟糕的做法之外,我还看到了另一个问题。

        仅仅因为特定地址不会导致free() 产生访问冲突,并不意味着释放该内存是安全的。该地址实际上可以是堆内的地址,因此不会发生访问冲突,并且释放它会导致堆损坏。或者它甚至可能是一个有效的释放地址,在这种情况下,你释放了一些可能仍在使用的内存块!

        你真的没有解释为什么应该考虑这种糟糕的方法。

        【讨论】:

          【解决方案11】:

          你显然已经确定你已经完成了一个你当前有一个指向的对象,如果那个对象是malloced,你想free它。这听起来不是一个不合理的想法,但是您拥有指向对象的指针这一事实并不能告诉您有关该对象是如何分配的任何信息(malloc、new、new[]、on堆栈,作为共享内存,作为内存映射文件,作为APR memory pool,使用Boehm-Demers-Weiser garbage collector等),因此无法确定解除分配对象的正确方法(或者是否需要解除分配全部;您可能有一个指向堆栈上的对象的指针)。这就是您实际问题的答案。

          但有时最好回答应该问的问题。而这个问题是“如果我不能总是告诉诸如‘这个对象是如何分配的,应该如何释放它’之类的东西,我该如何管理 C++ 中的内存?”这是一个棘手的问题,虽然这并不容易,但如果您遵循一些策略,就可以管理内存。每当您听到人们抱怨将每个malloc 与free、每个new 与delete 以及每个new[] 与delete[] 正确配对时,您都知道他们正在使他们的生活变得比必要的更艰难没有遵循严格的内存管理制度。

          我将猜测您正在将指针传递给函数,并且在函数完成后您希望它清理指针。这个政策一般是不可能正确的。相反,我建议遵循以下策略:(1)如果一个函数从其他人那里获得一个指针,那么“其他人”应该会清理(毕竟,“其他人”知道内存是如何分配的)和( 2) 如果一个函数分配了一个对象,那么该函数的文档将说明应该使用什么方法来释放该对象。其次,我强烈推荐智能指针和类似的类。

          Stroustrup's advice is:

          如果我创建 10,000 个对象并拥有指向它们的指针,我需要删除这 10,000 个对象,而不是 9,999,也不是 10,001。我不知道该怎么做。如果我必须直接处理这 10,000 个对象,我会搞砸的。 ......所以,很久以前我想,“好吧,但我可以正确处理少量的对象。”如果我有 100 个对象要处理,我可以很确定我正确处理了 100 个而不是 99 个。如果我可以将对象数量减少到 10 个,我就会开始感到高兴。我知道如何确保我正确处理了 10 而不仅仅是 9。”

          例如,你想要这样的代码:

          #include <cstdlib>
          #include <iostream>
          #include "boost/shared_ptr.hpp"
          
          namespace {
              // as a side note, there is no reason for this sample function to take int*s
              // instead of ints; except that I need a simple function that uses pointers
              int foo(int* bar, int* baz)
              {
                  // note that since bar and baz come from outside the function, somebody
                  // else is responsible for cleaning them up
                  return *bar + *baz;
              }
          }
          
          int main()
          {
              boost::shared_ptr<int> quux(new int(2));
          
              // note, I would not recommend using malloc with shared_ptr in general
              // because the syntax sucks and you have to initialize things yourself
              boost::shared_ptr<int> quuz(reinterpret_cast<int*>(std::malloc(sizeof(int))), std::free);
              *quuz = 3;
          
              std::cout << foo(quux.get(), quuz.get()) << '\n';
          }
          

          【讨论】:

          • 为什么投反对票?事实上,资源管理是可管理的。事实上,根本问题是对资源的无节制使用。事实上,指针可以指向通过 malloc 以外的东西分配的内存这一事实是相关的。
          【解决方案12】:

          为什么 0x12345678 一定是无效的?如果您的程序使用大量内存,则可以在那里分配一些东西。确实,只有一个指针值是您绝对应该依赖的无效分配:NULL。

          【讨论】:

          • 而且,具有讽刺意味的是,free 使用空指针是保证无操作。 :)
          • 实际上,0x12345678 在多个平台上都是无效的,因为它无法满足这些系统所需的字节对齐。
          • @Zac:您的观点是正确的,但是在不需要时编写依赖于平台特定检查的 C 代码是否被认为是最佳实践?
          • 如果您正确编写内存管理代码,您将永远不必担心对齐问题导致崩溃。编写可移植代码是最佳实践。
          • @Zac:那我们就同意了!
          【解决方案13】:

          C++ 不使用'malloc' 而是使用'new',通常有不同的实现;因此 'delete' 和 'free' 不能混用 - 'delete' 和 'delete[]' (它的数组版本)也不能混用。

          DLL 有自己的内存区域,不能与非 DLL 内存区域的内存管理系统混用。

          每个 API 和语言都有自己的内存管理,用于自己的内存对象类型。 即:您不会“释放()”或“删除”打开的文件,而是“关闭()”它们。其他 API 也是如此,即使类型是指向内存的指针而不是句柄。

          【讨论】:

            猜你喜欢
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 2013-09-09
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            • 1970-01-01
            相关资源
            最近更新 更多