Kukuru3

tweet face mail

 

 

 

 struct group_info init_groups = { .usage = ATOMIC_INIT(2) };

 

 struct group_info *groups_alloc(int gidsetsize){

 

  struct group_info *group_info;

 

  int nblocks;

 

  int i;

 

 

 

  nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;

 

  /* Make sure we always allocate at least one indirect block pointer */

 

  nblocks = nblocks ? : 1;

 

  group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);

 

  if (!group_info)

 

  return NULL;

 

  group_info->ngroups = gidsetsize;

 

  group_info->nblocks = nblocks;

 

  atomic_set(&group_info->usage, 1);

 

 

 

  if (gidsetsize <= NGROUPS_SMALL)

 

  group_info->blocks[0] = group_info->small_block;

 

  else {

 

  for (i = 0; i < nblocks; i++) {

 

  gid_t *b;

 

  b = (void *)__get_free_page(GFP_USER);

 

  if (!b)

 

  goto out_undo_partial_alloc;

 

  group_info->blocks[i] = b;

 

  }

 

  }

 

  return group_info;

 

 

 

 out_undo_partial_alloc:

 

  while (--i >= 0) {

 

  free_page((unsigned long)group_info->blocks[i]);

 

  }

 

  kfree(group_info);

 

  return NULL;

 

 }

 

 

 

 EXPORT_SYMBOL(groups_alloc);

 

 

 

 void groups_free(struct group_info *group_info)

 

 {

 

  if (group_info->blocks[0] != group_info->small_block) {

 

  int i;

 

  for (i = 0; i < group_info->nblocks; i++)

 

  free_page((unsigned long)group_info->blocks[i]);

 

  }

 

  kfree(group_info);

 

 }

 

 

 

 EXPORT_SYMBOL(groups_free);

 

 

 

 /* export the group_info to a user-space array */

 

 static int groups_to_user(gid_t __user *grouplist,

 

  const struct group_info *group_info)

 

 {

 

  int i;

 

  unsigned int count = group_info->ngroups;

 

 

 

  for (i = 0; i < group_info->nblocks; i++) {

 

  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);

 

  unsigned int len = cp_count * sizeof(*grouplist);

 

 

 

  if (copy_to_user(grouplist, group_info->blocks[i], len))

 

  return -EFAULT;

 

 

 

  grouplist += NGROUPS_PER_BLOCK;

 

  count -= cp_count;

 

  }

 

  return 0;

 

 }

 

 

 

 /* fill a group_info from a user-space array - it must be allocated already */

 

 static int groups_from_user(struct group_info *group_info,

 

  gid_t __user *grouplist)

 

 {

 

  int i;

 

  unsigned int count = group_info->ngroups;

 

 

 

  for (i = 0; i < group_info->nblocks; i++) {

 

  unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);

 

  unsigned int len = cp_count * sizeof(*grouplist);

 

 

 

  if (copy_from_user(group_info->blocks[i], grouplist, len))

 

  return -EFAULT;

 

 

 

  grouplist += NGROUPS_PER_BLOCK;

 

  count -= cp_count;

 

  }

 

  return 0;

 

 }

 

 

 

 /* a simple Shell sort */

 

 static void groups_sort(struct group_info *group_info)

 

 {

 

  int base, max, stride;

 

  int gidsetsize = group_info->ngroups;

 

 

 

  for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)

 

  ; /* nothing */

 

  stride /= 3;

 

 

 

  while (stride) {

 

  max = gidsetsize - stride;

 

  for (base = 0; base < max; base++) {

 

  int left = base;

 

  int right = left + stride;

 

  gid_t tmp = GROUP_AT(group_info, right);

 

 

 

  while (left >= 0 && GROUP_AT(group_info, left) > tmp) {

 

  GROUP_AT(group_info, right) =

 

  GROUP_AT(group_info, left);

 

  right = left;

 

  left -= stride;

 

  }

 

  GROUP_AT(group_info, right) = tmp;

 

  }

 

  stride /= 3;

 

  }

 

 }

 

 

 

 /* a simple bsearch */

 

 int groups_search(const struct group_info *group_info, gid_t grp)

 

 {

 

  unsigned int left, right;

 

 

 

  if (!group_info)

 

  return 0;

 

 

 

  left = 0;

 

  right = group_info->ngroups;

 

  while (left < right) {

 

  unsigned int mid = (left+right)/2;

 

  if (grp > GROUP_AT(group_info, mid))

 

  left = mid + 1;

 

  else if (grp < GROUP_AT(group_info, mid))

 

  right = mid;

 

  else

 

  return 1;

 

  }

 

  return 0;

 

 }

 

 

 

 /**

 

  * set_groups - Change a group subscription in a set of credentials

 

  * @new: The newly prepared set of credentials to alter

 

  * @group_info: The group list to install

 

  *

 

  * Validate a group subscription and, if valid, insert it into a set

 

  * of credentials.

 

  */

 

 int set_groups(struct cred *new, struct group_info *group_info)

 

 {

 

  put_group_info(new->group_info);

 

  groups_sort(group_info);

 

  get_group_info(group_info);

 

  new->group_info = group_info;

 

  return 0;

 

 }

 

 

 

 EXPORT_SYMBOL(set_groups);

 

 

 

 /**

 

  * set_current_groups - Change current's group subscription

 

  * @group_info: The group list to impose

 

  *

 

  * Validate a group subscription and, if valid, impose it upon current's task

 

  * security record.

 

  */

 

 int set_current_groups(struct group_info *group_info)

 

 {

 

  struct cred *new;

 

  int ret;

 

 

 

  new = prepare_creds();

 

  if (!new)

 

  return -ENOMEM;

 

 

 

  ret = set_groups(new, group_info);

 

  if (ret < 0) {

 

  abort_creds(new);

 

  return ret;

 

  }

 

 

 

  return commit_creds(new);

 

 }

 

 

 

 EXPORT_SYMBOL(set_current_groups);

 

 

 

 SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)

 

 {

 

  const struct cred *cred = current_cred();

 

  int i;

 

 

 

  if (gidsetsize < 0)

 

  return -EINVAL;

 

 

 

  /* no need to grab task_lock here; it cannot change */

 

  i = cred->group_info->ngroups;

 

  if (gidsetsize) {

 

  if (i > gidsetsize) {

 

  i = -EINVAL;

 

  goto out;

 

  }

 

  if (groups_to_user(grouplist, cred->group_info)) {

 

  i = -EFAULT;

 

  goto out;

 

  }

 

  }

 

 out:

 

  return i;

 

 }

 

 

 

 /*

 

  * SMP: Our groups are copy-on-write. We can set them safely

 

  * without another task interfering.

 

  */

 

 

 

 SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)

 

 {

 

  struct group_info *group_info;

 

  int retval;

 

 

 

  if (!nsown_capable(CAP_SETGID))

 

  return -EPERM;

 

  if ((unsigned)gidsetsize > NGROUPS_MAX)

 

  return -EINVAL;

 

 

 

  group_info = groups_alloc(gidsetsize);

 

  if (!group_info)

 

  return -ENOMEM;

 

  retval = groups_from_user(group_info, grouplist);

 

  if (retval) {

 

  put_group_info(group_info);

 

  return retval;

 

  }

 

 

 

  retval = set_current_groups(group_info);

 

  put_group_info(group_info);

 

 

 

  return retval;

 

 }

 

 

 

 /*

 

  * Check whether we're fsgid/egid or in the supplemental group..

 

  */

 

 int in_group_p(gid_t grp)

 

 {

 

  const struct cred *cred = current_cred();

 

  int retval = 1;

 

 

 

  if (grp != cred->fsgid)

 

  retval = groups_search(cred->group_info, grp);

 

  return retval;

 

 }

 

 

 

 EXPORT_SYMBOL(in_group_p);

 

 

 

 int in_egroup_p(gid_t grp)

 

 {

 

  const struct cred *cred = current_cred();

 

  int retval = 1;

 

 

 

  if (grp != cred->egid)

 

  retval = groups_search(cred->group_info, grp);

 

  return retval;

 

 }

 

Panzerwehr 1949

The war should have ended. It didn't.

General

Genre:

WW2 mech simulator

Release status:

Early Access : Q4 2017

Platforms:


Description

It is April 1949, and the Third Battle of Stalingrad is about to begin. Infantry has long been made obsolete in the irradiated battlefield pockmarked with atomic bomb craters. In their place, a new breed of quadrupedal war machine roams the ruined streets of Stalingrad: German Jaegers and Soviet Samokhods. Under the aurora of a nuclear winter, elite pilots of both empires try to score a decisive blow. Panzerwehr 1949 is a hardcore World War 2 era mech simulator exclusively for VR headsets, inspired by classics such as Steel Battalion and Mech Warrior. Walkers in this game handle more like tanks than agile robots, and the equipment available matches the era and the weight of the beasts involved. Leaning more towards the simulation than the arcade, the game features a highly accurate ballistic model. The game requires the player to first master the highly detailed controls of their cockpit before they can bring the full potential of their walkers to bear. Planned features for full release are a procedural single-player campaign, a 1v1 multiplayer mode and a 3-player coop mode where three players in VR control separate crew stations of a single walker tank.

Features

  • Pilot a gigantic spider tank as either a Hero of the Soviet Union or a Jaeger Ace of the Reich
  • Use equipment evolved from World War 2 and onwards
  • Detailed mech cockpits with many control surfaces
  • Detailed equipment loadout and customization. Use prestige to obtain experimental parts and technologies, or scavenge from your fallen comprades and enemies on the field.
  • Irradiated battlefield of the Stalingrad Ground Zero Crater allows crafty players to use the radiation fields to conceal themselves from sensors.
  • A detailed ballistics and damage model allowing for angle deflections and strategic targeting of individual enemy systems with specialist ammunition.
  • A dynamic campaign with procedural levels.
  • Drop-in multiplayer that allows players to request reinforcements from other players during campaign
  • Co-op multiplayer where three players join forces to pilot a single experimental heavy mech.

Awards

  • Nominated for Special Selection Award - Reboot Develop 2017, Dubrovnik

Coverage

Media

History

The game began as a small hobby tech demo in June 2016. Soon after that the decision was made to make a fully fledged VR game.

Panzerwehr 1949 early alpha was first displayed at Games.con in Belgrade at the end of November 2016.

The game was next showcased at Reboot Develop where it was nominated for a Special Selection Award.

The development continues at full pace and will probably result in Early Access in Q4 2017.