有没有办法在C中为i_block创建迭代器样式函数？

Question

我正在研究学校项目的一些ext2文件系统（实现ls，mkdir，那种东西）并且发现我为需要遍历inode的i_block的任务生成了大量冗余代码。我有函数来计算dir条目的数量，搜索dir条目以获取strcmp名称匹配，读取数据，写入数据...遍历i_block似乎很常见。我试图写一些类似于i_block的迭代器的东西来删除这种冗余。

我想知道这样做的好方法是什么？有没有这样或类似的例子在linux系统代码中完成的例子？或者这只是一个坏主意。

到目前为止我提出的代码：

    // returns block number located at iter position
    // accepts a minode which is a struct wrapping an inode (in memory inode)
    // accepts an iter which will self mutate and should start at 0
    int iter_i_block(minode *mip, int *iter) {
      static char buf[BLKSIZE]; // static buffer
      // buffer number used to check if a new block needs to be read in
      static int bufno;
      // inode number used to determine if we are working on a new inode
      static int ino; 
      // block number to return
      int bno;
      // flag for if this a different inode than last time
      int new_ino = 0;

      if (ino != mip->ino) {
        ino = mip->ino;
        new_ino = 1;
      }
      // direct blocks
      if (*iter < 12) {
        bno = mip->inode.i_block[*iter];
        (*iter)++;
        bufno = bno;
        return bno;
      }

      // indirect blocks
      if (*iter < 12 + BLKSIZE_1024 / sizeof(int)) {
        if (!mip->inode.i_block[12])
          return 0;
        if (new_ino || bufno != 12)
          get_block(mip->mount_entry, mip->inode.i_block[12], buf);
        bufno = 12;
        bno = *((int *)buf + (*iter - 12));
        (*iter)++;
        return bno;
      }

      // double indirect blocks (not shown)
      // triple indirect blocks (not shown)
      return 0;
    }

任何建议表示赞赏！谢谢

Answer 1

这就是我现在要做的事情

感谢Gil Hamilton建议使用结构

typedef struct blk_iter {
  struct minode *mip;
  // buf contains the nth block
  unsigned int nth;
  // direct block (buf), indirection block(map1),
  // double indirection(map2), triple indirection(map3);
  char buf[BLKSIZE_1024], map1[BLKSIZE_1024], map2[BLKSIZE_1024],
      map3[BLKSIZE_1024];
} blk_iter;

// returns a char* buffer of BLKSIZE on success
// null on failure (nothing more to read)
// must start from nth = -1
char *get_blk(blk_iter *it, int lbk) {
  // calculations for convience, could be macros
  int blks_per = BLKSIZE_1024 / sizeof(int);
  int direct_start = 0, direct_end = 12, indirect_start = direct_end,
      indirect_end = direct_end + blks_per, double_start = indirect_end,
      double_end = indirect_end + blks_per * blks_per,
      triple_start = double_end,
      triple_end = double_end + blks_per * blks_per * blks_per;
  // pointers for shorter names
  unsigned int *i_block = it->mip->inode.i_block;
  mount_entry *me = it->mip->mount_entry;
  // null check
  if (!it || !it->mip)
    return 0;
  // get blocks based on lbk
  if (lbk < direct_end) {
    // get direct block
    get_block(me, i_block[lbk], it->buf);
  } else if (lbk < indirect_end) {
    // get indirect block
    if (!(it->nth >= indirect_start && it->nth < indirect_end))
      // check if map1 cached
      get_block(me, i_block[12], it->map1);
    get_block(me, it->map1[lbk - indirect_start], it->buf);
  } else if (lbk < double_end) {
    // get double indirect block
    if (!(it->nth >= double_start && it->nth < double_end))
      // check if map2 cached
      get_block(me, i_block[13], it->map2);
    if (!((lbk - double_start) / blks_per ==
          (it->nth - double_start) / blks_per))
      // check if map1 cached
      get_block(me, it->map2[(lbk - double_start) / blks_per], it->map1);
    get_block(me, it->map1[(lbk - double_start) % blks_per], it->buf);
  } else if (lbk < triple_end) {
    // triple  indirect blocks
    if (!(it->nth >= triple_start && it->nth < triple_end))
      // check if map3 cached
      get_block(me, i_block[12], it->map3);
    if (!((lbk - triple_start) / (blks_per * blks_per) ==
          (it->nth - triple_start) / (blks_per * blks_per)))
      // check if map2 cached
      get_block(me, it->map3[(lbk - triple_start) / (blks_per * blks_per)],
                it->map2);
    if (!((lbk - triple_start) / blks_per ==
          (it->nth - triple_start) / blks_per))
      // check if map1 cached
      get_block(me, it->map2[(lbk - triple_start) / blks_per], it->map1);
    get_block(me, it->map1[(lbk - triple_start) % blks_per], it->buf);
  }
  it->nth = lbk;
  return it->buf;
}