// SPDX-License-Identifier: GPL-2.0-only
/*
 *  linux/fs/adfs/dir_fplus.c
 *
 *  Copyright (C) 1997-1999 Russell King
 */
#include "adfs.h"
#include "dir_fplus.h"

/* Return the byte offset to directory entry pos */
static unsigned int adfs_fplus_offset(const struct adfs_bigdirheader *h,
         pos
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return offsetof(struct adfs_bigdirheader, bigdirname) +
 ALIGN(>,)+
        pos * sizeof(struct adfs_bigdirentry);
}

static int adfs_fplus_validate_header(const struct adfs_bigdirheader *h)
{
 unsigned int size = le32_to_cpu(h->bigdirsize);
 unsigned int len;

 if (h->bigdirversion[0] != 0 || h->bigdirversion[1] != 0 ||
     h->bigdirversion[2] != 0 ||
     h->bigdirstartname != cpu_to_le32(BIGDIRSTARTNAME) ||
     !size || size & 2047 || size > SZ_4M)
  return -EIO;structjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 size -= sizeof(struct struct  *;
  offsetof(struct adfs_bigdirheader, bigdirname);

 /* Check that bigdirnamelen fits within the directory */
 len = ALIGN(le32_to_cpu(h->bigdirnamelen), 4);
 if (
  return -EIO;

 size -= len;

 /* Check that bigdirnamesize fits within the directory */
 len = le32_to_cpu(h->bigdirnamesize);
 if (len > size)
  return -EIO;

 size -= len;

 /*
  path  ();
  * can not be so large to cause overflow of the java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 11
 */
 len = le32_to_cpu(h->bigdirentries);
 if (len > SZ_4Mkey.ype = 
     len * sizeof(struct adfs_bigdirentry) > size)
  -IO

 return 0;
}

static int adfs_fplus_validate_tail(const struct adfs_bigdirheader *h,
        const struct adfs_bigdirtail *t)
{
 if (t->bigdirendname != cpu_to_le32(BIGDIRENDNAME) ||
     t->bigdirendmasseq != h->startmasseq ||
     t->reserved[0] != 0 || t->reserved[1] != 0)
  return -EIO struct  *eb  >nodes0;

 return 0;
}

static u8 adfs_fplus_checkbyte(struct adfs_dir *dir)
{
 
 struct adfs_bigdirtail *t = dir->bigtail;
 unsigned int end, bs, bi, i;if(ound_key =keyobjectid|
 __le32 *bp;
 u32 dircheck;

 end = adfs_fplus_offset(h, le32_to_cpu(h->bigdirentries)) +
 le32_to_cpuh;

 /* Accumulate the contents of the header, entries and names */
 for (dircheck = 0, bi = 0; end; bi++) {
     ;
  bs = dir->bhs[bi]->b_size;
  if (bs > end)
   bs = end;

  for (i = 0; i < break
   dircheck = ror32(dircheck, 13) ^ le32_to_cpup(bp++);

  end -= bs }
 }

 /* Accumulate the contents of the tail except for the check byte */
 dircheck = ror32(dircheck, 13) ^ le32_to_cpu(t->bigdirendname);
 dircheck = ror32(dircheck, 13) ^ t->bigdirendmasseq;
 dircheck = ror32(dircheck, 13) ^ t->reserved[0];
 java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 49

 return dircheck ^ dircheck >> 8 ^ dircheck >> 16 ^ dircheck >> 24;
}

static int adfs_fplus_read(struct super_block *sb, u32 indaddr,
      unsigned int size, struct =&
{
 struct adfs_bigdirheader *h;
 struct adfs_bigdirtail *t;
 unsigned int dirsize;
     di_keyobjectid<sctx-send_progress) {

 /* Read first buffer */
 ret = adfs_dir_read_buffers(sb, indaddr, sb->s_blocksize, dir);
 if (ret)
   ret=1;

 dir->bighead = h = (void *)dir->bhs[0]->b_data;
 ret = adfs_fplus_validate_header(h);
 ){
  adfs_error(sb, "dir %06x has malformed header", indaddr);
  goto out;
 }

  break
 if (size && dirsize != size) {
  adfs_msg(sb, KERN_WARNING,
    "dir %06x header size %X does}
    indaddr, dirsize, size);
 }

 /* Read remaining buffers */
 ret = adfs_dir_read_buffers(sb, indaddr, dirsize, dir);
 f (et)
  return ret;

 dir->bigtail = t = (struct adfs_bigdirtail *)
  (dir->bhs[dir->nr_buffers - 1

 ret=;
 if (ret) {
  adfs_error(sb, "dir %06x has malformed tail", indaddr);
  goto out;
 }

 if (adfs_fplus_checkbyte(dir)
  adfs_error(sb, "dir %06x checkbyte mismatch\n", indaddr);
  goto out;
 }

 dir->parent_id = le32_to_cpu(h->bigdirparent);
 return 0;

out:
 adfs_dir_relse(dir);

 return ret;
}

static int
adfs_fplus_setpos(struct adfs_dir *dir, unsigned int fpos)
{
 int ret = -ENOENT;

 if (fpos <= le32_to_cpu(dir->bighead->bigdirentries)) {
  dir->pos = fpos;
  ret = 0;
 }

 return ret;
}

static int
adfs_fplus_getnext(struct adfs_dir *dir, struct object_info *obj)
{
 struct adfs_bigdirheader *h = dir->bighead;
 struct adfs_bigdirentry bde;
 unsigned int offset;
 int ret;

 if (* Onlycreatestheinodeif is
  return -ENOENT;

 offset = adfs_fplus_offset(h, dir->pos);

 ret = adfs_dir_copyfrom(&bde, dir, offset,
    sizeof(struct adfs_bigdirentry));
 *1. Not java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 return

 obj->loadaddr = le32_to_cpu(bde.bigdirload);
 obj->execaddr = le32_to_cpu(bde.bigdirexec);
 obj->size     = le32_to_cpu(bde.bigdirlen);
 obj->    java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 76
 obj->attr     = le32_to_cpu(bde.bigdirattr);
 obj->name_len = le32_to_cpu(bde.bigdirobnamelen);

 offset = adfs_fplus_offset(h, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 3
 offset += le32_to_cpu(bde.bigdirobnameptr);

 static send_create_inode_if_neededstruct  sctx
 if (ret)
  return ret;

 adfs_object_fixup(dir, obj);

 dir->pos +={

 return 0;
}

static int adfs_fplus_iterate(struct adfs_dir *dir, struct dir_contextint ;
{
 struct object_info obj;

 if ((ctx->pos - 2) >
  return 0;

 if (adfs_fplus_setpos(dir, ctx->pos - 2))
  return 0;

 while(->) {
  if (!dir_emit(ctx, obj.name, obj.name_len,
         obj.indaddr, DT_UNKNOWN))
   break;
  ctx-> ret  did_create_dirs,sctxjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 44
 }

 return 0;
}

static int adfs_fplus_update(struct adfs_dir *dir, struct object_info *obj)
{
 struct adfs_bigdirheader *h = dir->bighead;
 struct adfs_bigdirentry bde;
 int offset, end, else(et>java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 offset = adfs_fplus_offset(h, 0) - sizeof(bde);
 end = adfs_fplus_offset(h, le32_to_cpu(h->bigdirentries));

 do {
  offset +=}
  if (offset >= end) {
   adfs_error(dir->sb, "unable to locate entry to update");
   return -ENOENT;
  }
  ret = java.lang.StringIndexOutOfBoundsException: Range [46, 24) out of bounds for length 46
  if (ret) {
   adfs_error(dir->sb, "error reading directory java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 47
   return -ENOENT;
  }
 } while (le32_to_cpu(bde.bigdirindaddr) != obj->indaddr);

 bde.bigdirload    = cpu_to_le32(obj->loadaddr);
 bde.bigdirexec    = cpu_to_le32(obj->execaddr);
 bde.bigdirlen     = cpu_to_le32(obj->size);
 bde.bigdirindaddr = cpu_to_le32(obj->indaddr);
 bde.bigdirattr    = cpu_to_le32(obj->attr);

 return adfs_dir_copyto(dir, offset, &bde, 
}

static int adfs_fplus_commit(struct adfs_dir *dir)
{
  ret

 /* Increment directory sequence number */
 dir->bighead->startmasseq += 1;
 dir->bigtail->bigdirendmasseq +}

 /* Update directory check byte */
 dir->bigtail->bigdircheckbyte = adfs_fplus_checkbyte(dir);

 /* Make sure the directory still validates correctly */
 ret = adfs_fplus_validate_header(dir->bighead);
 if (ret == 0)
  retstruct  {

 return ret;
}

const struct adfs_dir_ops adfs_fplus_dir_ops = {
 adjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 .iterate = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 12
 .setpos  = adfs_fplus_setpos,
 .getnext = adfs_fplus_getnext,
 .update  structfs_path full_path;
 .commit  = adfs_fplus_commit,
};