tree:   https://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2.git 
gfs2-iopen
head:   c748e1ec9bd20d71265a148042f6bc97ffc5f343
commit: 5e2ff0b932e982c85ae75fd6872d7252627be65b [7/12] gfs2: Move inode 
generation number check into gfs2_inode_lookup
config: s390-defconfig (attached as .config)
compiler: s390-linux-gcc (GCC) 9.3.0
reproduce:
        wget 
https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O 
~/bin/make.cross
        chmod +x ~/bin/make.cross
        git checkout 5e2ff0b932e982c85ae75fd6872d7252627be65b
        # save the attached .config to linux build tree
        COMPILER_INSTALL_PATH=$HOME/0day GCC_VERSION=9.3.0 make.cross ARCH=s390 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kbuild test robot <[email protected]>

All errors (new ones prefixed by >>):

   fs/gfs2/inode.c: In function 'gfs2_inode_lookup':
>> fs/gfs2/inode.c:167:5: error: label 'fail_put' used but not defined
     167 |     goto fail_put;
         |     ^~~~

vim +/fail_put +167 fs/gfs2/inode.c

   101  
   102  /**
   103   * gfs2_inode_lookup - Lookup an inode
   104   * @sb: The super block
   105   * @type: The type of the inode
   106   * @no_addr: The inode number
   107   * @no_formal_ino: The inode generation number
   108   * @blktype: Requested block type (GFS2_BLKST_DINODE or 
GFS2_BLKST_UNLINKED;
   109   *           GFS2_BLKST_FREE to indicate not to verify)
   110   *
   111   * If @type is DT_UNKNOWN, the inode type is fetched from disk.
   112   *
   113   * If @blktype is anything other than GFS2_BLKST_FREE (which is used as 
a
   114   * placeholder because it doesn't otherwise make sense), the on-disk 
block type
   115   * is verified to be @blktype.
   116   *
   117   * When @no_formal_ino is non-zero, this function will return 
ERR_PTR(-ESTALE)
   118   * if it detects that @no_formal_ino doesn't match the actual inode 
generation
   119   * number.  However, it doesn't always know unless @type is DT_UNKNOWN.
   120   *
   121   * Returns: A VFS inode, or an error
   122   */
   123  
   124  struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned int 
type,
   125                                  u64 no_addr, u64 no_formal_ino,
   126                                  unsigned int blktype)
   127  {
   128          struct inode *inode;
   129          struct gfs2_inode *ip;
   130          struct gfs2_glock *io_gl = NULL;
   131          struct gfs2_holder i_gh;
   132          int error;
   133  
   134          gfs2_holder_mark_uninitialized(&i_gh);
   135          inode = gfs2_iget(sb, no_addr);
   136          if (!inode)
   137                  return ERR_PTR(-ENOMEM);
   138  
   139          ip = GFS2_I(inode);
   140  
   141          if (inode->i_state & I_NEW) {
   142                  struct gfs2_sbd *sdp = GFS2_SB(inode);
   143  
   144                  error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, 
CREATE, &ip->i_gl);
   145                  if (unlikely(error))
   146                          goto fail;
   147                  flush_delayed_work(&ip->i_gl->gl_work);
   148  
   149                  error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, 
CREATE, &io_gl);
   150                  if (unlikely(error))
   151                          goto fail;
   152  
   153                  if (type == DT_UNKNOWN || blktype != GFS2_BLKST_FREE) {
   154                          /*
   155                           * The GL_SKIP flag indicates to skip reading 
the inode
   156                           * block.  We read the inode with 
gfs2_inode_refresh
   157                           * after possibly checking the block type.
   158                           */
   159                          error = gfs2_glock_nq_init(ip->i_gl, 
LM_ST_EXCLUSIVE,
   160                                                     GL_SKIP, &i_gh);
   161                          if (error)
   162                                  goto fail;
   163  
   164                          error = -ESTALE;
   165                          if (no_formal_ino &&
   166                              gfs2_inode_already_deleted(ip->i_gl, 
no_formal_ino))
 > 167                                  goto fail_put;
   168  
   169                          if (blktype != GFS2_BLKST_FREE) {
   170                                  error = gfs2_check_blk_type(sdp, 
no_addr,
   171                                                              blktype);
   172                                  if (error)
   173                                          goto fail;
   174                          }
   175                  }
   176  
   177                  glock_set_object(ip->i_gl, ip);
   178                  set_bit(GIF_INVALID, &ip->i_flags);
   179                  error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, 
GL_EXACT, &ip->i_iopen_gh);
   180                  if (unlikely(error))
   181                          goto fail;
   182                  
cancel_delayed_work_sync(&ip->i_iopen_gh.gh_gl->gl_delete);
   183                  glock_set_object(ip->i_iopen_gh.gh_gl, ip);
   184                  gfs2_glock_put(io_gl);
   185                  io_gl = NULL;
   186  
   187                  /* Lowest possible timestamp; will be overwritten in 
gfs2_dinode_in. */
   188                  inode->i_atime.tv_sec = 1LL << (8 * 
sizeof(inode->i_atime.tv_sec) - 1);
   189                  inode->i_atime.tv_nsec = 0;
   190  
   191                  if (type == DT_UNKNOWN) {
   192                          /* Inode glock must be locked already */
   193                          error = gfs2_inode_refresh(GFS2_I(inode));
   194                          if (error)
   195                                  goto fail;
   196                  } else {
   197                          ip->i_no_formal_ino = no_formal_ino;
   198                          inode->i_mode = DT2IF(type);
   199                  }
   200  
   201                  if (gfs2_holder_initialized(&i_gh))
   202                          gfs2_glock_dq_uninit(&i_gh);
   203  
   204                  gfs2_set_iop(inode);
   205          }
   206  
   207          if (no_formal_ino && ip->i_no_formal_ino &&
   208              no_formal_ino != ip->i_no_formal_ino) {
   209                  if (inode->i_state & I_NEW)
   210                          goto fail;
   211                  iput(inode);
   212                  return ERR_PTR(-ESTALE);
   213          }
   214  
   215          if (inode->i_state & I_NEW)
   216                  unlock_new_inode(inode);
   217  
   218          return inode;
   219  
   220  fail:
   221          if (io_gl)
   222                  gfs2_glock_put(io_gl);
   223          if (gfs2_holder_initialized(&i_gh))
   224                  gfs2_glock_dq_uninit(&i_gh);
   225          iget_failed(inode);
   226          return ERR_PTR(error);
   227  }
   228  

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]

Attachment: .config.gz
Description: application/gzip

Reply via email to