Page History

typedef struct object {  /* Generic struct: contents don't matter */
  int propertyA, propertyB, propertyC;
} object_t;

errno_t objects.  Failing and returning somewhere in the middle of this function without freeing all of the allocated memory could produce a memory leak.  It is a common error to forget to free one (or all) of the objects in this manner, so a goto-chain is the simplest and cleanest way to organize exits when order is preserved.

h2. Noncompliant Code Exampleint do_something(void){
  // ... definitions ,,,

  obj1 = malloc(...FILE *fin1, *fin2;
  object_t *obj;
  errno_t ret_val;
  
  fin1 = fopen("some_file", "r");
  if (!obj1)fin1 == NULL) {
    return return -1errno;
  }

  obj2fin2 = malloc(...fopen("some_other_file", "r");
  if (!obj2)fin2 == NULL) {
    freefclose(obj1fin1);
    return -1errno;
  }

  obj3obj = malloc(...sizeof(object_t));
  if (!obj3)obj == NULL) {
    free(obj2 ret_val = errno;
    fclose(fin1);
    return -1ret_val;  //* Forgot to freeclose obj1 -- Memory leakfin2!! */
  }

  //* ... moreMore code ...
}


h2. Compliant Solutionint */

  fclose(fin1);
  fclose(fin2);
  free(obj);
  return NOERR;
}

/* ... Assume the same struct used previously ... */

errno_t do_something(void) {
  FILE *fin1, *fin2;
  object_t *obj;
  errno_t ret_val = NOERR; /* Initially assume a successful return value */

  if ((fin1 = fopen("some_file", "r")) != NULL) {
    if ((fin2 = fopen("some_other_file", "r")) != NULL) {
      if ((obj = malloc(sizeof(object_t))) != NULL) {

        /* ... definitions ,,,

  obj1 = malloc(... More code ... */

        /* Clean-up & handle errors */
        free(obj);
      } else {
        ret_val = errno;
      }
      fclose(fin2);
    } else {
      ret_val = errno;
    }
    fclose(fin1);
  } else {
    ret_val = errno;
  }

  return ret_val;
}

/* ... Assume the same struct used previously ... */

errno_t do_something(void) {
  FILE *fin1, *fin2;
  object_t *obj;
  errno_t ret_val = NOERR; /* Initially assume a successful return value */

  fin1 = fopen("some_file", "r");
  if (!obj1)fin1 == NULL) {
    ret_val = errno;
    goto FAIL_OBJ1FIN1;
  }

  obj2fin2 = malloc(...fopen("some_other_file", "r");
  if (!obj2)fin2 == NULL) {
    ret_val = errno;
    goto FAIL_OBJ2FIN2;
  }

  obj3obj = malloc(...(sizeof(object_t));
  if (!obj3)obj == NULL) {
    ret_val = errno;
    goto FAIL_OBJ3OBJ;
  }


  //* ... moreMore code ... */

SUCCESS:     /* Clean up everything */
  free(obj);

FAIL_OBJ3:OBJ:   /* Otherwise, close only the resources we opened */
  freefclose(obj2fin2);

FAIL_OBJ2FIN2:
  freefclose(obj1fin1);

FAIL_OBJ1FIN1:
  return -1;
}

This code is guaranteed to clean up properly whenever an allocation fails.  It is cleaner and prevents rewriting of similar code upon every function error.ret_val;
}

static struct task_struct *copy_process(unsigned long clone_flags,
					unsigned long stack_start,
					struct pt_regs *regs,
					unsigned long stack_size,
					int __user *child_tidptr,
					struct pid *pid,
					int trace)
{
  int retval;
  struct task_struct *p;
  int cgroup_callbacks_done = 0;

  if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
    return ERR_PTR(-EINVAL);

  /* ... */

  retval = security_task_create(clone_flags);
  if (retval)
    goto fork_out;

  retval = -ENOMEM;
  p = dup_task_struct(current);
  if (!p)
    goto fork_out;

  /* ... */

  /* Copy all the process information */
  if ((retval = copy_semundo(clone_flags, p)))
    goto bad_fork_cleanup_audit;
  if ((retval = copy_files(clone_flags, p)))
    goto bad_fork_cleanup_semundo;
  if ((retval = copy_fs(clone_flags, p)))
    goto bad_fork_cleanup_files;
  if ((retval = copy_sighand(clone_flags, p)))
    goto bad_fork_cleanup_fs;
  if ((retval = copy_signal(clone_flags, p)))
    goto bad_fork_cleanup_sighand;
  if ((retval = copy_mm(clone_flags, p)))
    goto bad_fork_cleanup_signal;
  if ((retval = copy_namespaces(clone_flags, p)))
    goto bad_fork_cleanup_mm;
  if ((retval = copy_io(clone_flags, p)))
    goto bad_fork_cleanup_namespaces;
  retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs);
  if (retval)
    goto bad_fork_cleanup_io;

  /* ... */

  return p;

  /* ... Cleanup code starts here ... */

bad_fork_cleanup_io:
  put_io_context(p->io_context);
bad_fork_cleanup_namespaces:
  exit_task_namespaces(p);
bad_fork_cleanup_mm:
  if (p->mm)
    mmput(p->mm);
bad_fork_cleanup_signal:
  cleanup_signal(p);
bad_fork_cleanup_sighand:
  __cleanup_sighand(p->sighand);
bad_fork_cleanup_fs:
  exit_fs(p); /* Blocking */
bad_fork_cleanup_files:
  exit_files(p); /* Blocking */
bad_fork_cleanup_semundo:
  exit_sem(p);
bad_fork_cleanup_audit:
  audit_free(p);

  /* ... More cleanup code ... */

fork_out:
  return ERR_PTR(retval);
}