Archive-Team
/
zfs
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 103 Wiki Activity

cstyle: Resolve C style issues 

The vast majority of these changes are in Linux specific code.
They are the result of not having an automated style checker to
validate the code when it was originally written.  Others were
caused when the common code was slightly adjusted for Linux.

This patch contains no functional changes.  It only refreshes
the code to conform to style guide.

Everyone submitting patches for inclusion upstream should now
run 'make checkstyle' and resolve any warning prior to opening
a pull request.  The automated builders have been updated to
fail a build if when 'make checkstyle' detects an issue.

Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Closes #1821
This commit is contained in:
Michael Kjorling 2013-11-01 20:26:11 +01:00 committed by Brian Behlendorf
parent 8ffef572ed
commit d1d7e2689d
165 changed files with 2120 additions and 1936 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/mount_zfs/mount_zfs.c
View File

@ -272,7 +272,7 @@ out:
len = strlen(cwd);
/* Do not add one when cwd already ends in a trailing '/' */
if (!strncmp(cwd, dataset, len))
if (strncmp(cwd, dataset, len) == 0)
return (dataset + len + (cwd[len-1] != '/'));
return (dataset);
@ -501,7 +501,7 @@ main(int argc, char **argv)
* using zfs as your root file system both rc.sysinit/umountroot and
* systemd depend on 'mount -o remount <mountpoint>' to work.
*/
if (zfsutil && !strcmp(legacy, ZFS_MOUNTPOINT_LEGACY)) {
if (zfsutil && (strcmp(legacy, ZFS_MOUNTPOINT_LEGACY) == 0)) {
(void) fprintf(stderr, gettext(
"filesystem '%s' cannot be mounted using 'zfs mount'.\n"
"Use 'zfs set mountpoint=%s' or 'mount -t zfs %s %s'.\n"

6
cmd/zdb/zdb.c
View File

@ -165,7 +165,8 @@ usage(void)
(void) fprintf(stderr, " -t <txg> -- highest txg to use when "
"searching for uberblocks\n");
(void) fprintf(stderr, " -M <number of inflight I/Os> -- "
"specify the maximum number of checksumming I/Os [default is 200]\n");
"specify the maximum number of checksumming I/Os "
"[default is 200]\n");
(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
"to make only that option verbose\n");
(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
@ -1319,7 +1320,8 @@ dump_deadlist(dsl_deadlist_t *dl)
dle = AVL_NEXT(&dl->dl_tree, dle)) {
if (dump_opt['d'] >= 5) {
char buf[128];
(void) snprintf(buf, sizeof (buf), "mintxg %llu -> obj %llu",
(void) snprintf(buf, sizeof (buf),
"mintxg %llu -> obj %llu",
(longlong_t)dle->dle_mintxg,
(longlong_t)dle->dle_bpobj.bpo_object);

9
cmd/zpios/zpios.h
View File

@ -1,4 +1,4 @@
/*****************************************************************************\
/*
* ZPIOS is a heavily modified version of the original PIOS test code.
* It is designed to have the test code running in the Linux kernel
* against ZFS while still being flexibly controled from user space.
@ -29,7 +29,7 @@
*
* You should have received a copy of the GNU General Public License along
* with ZPIOS. If not, see <http://www.gnu.org/licenses/>.
\*****************************************************************************/
*/
#ifndef _ZPIOS_H
#define _ZPIOS_H
@ -60,7 +60,8 @@
#define KMGT_SIZE 16
/* All offsets, sizes and counts can be passed to the application in
/*
* All offsets, sizes and counts can be passed to the application in
* multiple ways.
* 1. a value (stored in val[0], val_count will be 1)
* 2. a comma separated list of values (stored in val[], using val_count)
@ -72,7 +73,7 @@ typedef struct pios_range_repeat {
uint64_t val_low;
uint64_t val_high;
uint64_t val_inc_perc;
uint64_t next_val; /* Used for multiple runs in get_next() */
uint64_t next_val; /* For multiple runs in get_next() */
} range_repeat_t;
typedef struct cmd_args {

78
cmd/zpios/zpios_main.c
View File

@ -1,7 +1,7 @@
/*****************************************************************************\
/*
* ZPIOS is a heavily modified version of the original PIOS test code.
* It is designed to have the test code running in the Linux kernel
* against ZFS while still being flexibly controled from user space.
* against ZFS while still being flexibly controlled from user space.
*
* Copyright (C) 2008-2010 Lawrence Livermore National Security, LLC.
* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
@ -29,7 +29,7 @@
*
* You should have received a copy of the GNU General Public License along
* with ZPIOS. If not, see <http://www.gnu.org/licenses/>.
\*****************************************************************************/
*/
#include <stdlib.h>
#include <stdio.h>
@ -42,7 +42,8 @@
#include <sys/ioctl.h>
#include "zpios.h"
static const char short_opt[] = "t:l:h:e:n:i:j:k:o:m:q:r:c:a:b:g:s:A:B:C:"
static const char short_opt[] =
"t:l:h:e:n:i:j:k:o:m:q:r:c:a:b:g:s:A:B:C:"
"L:p:M:xP:R:G:I:N:T:VzOfHv?";
static const struct option long_opt[] = {
{"threadcount", required_argument, 0, 't' },
@ -133,7 +134,7 @@ usage(void)
" --verbose -v =increase verbosity\n"
" --help -? =this help\n\n");
return 0;
return (0);
}
static void args_fini(cmd_args_t *args)
@ -155,13 +156,13 @@ args_init(int argc, char **argv)
if (argc == 1) {
usage();
return (cmd_args_t *)NULL;
return ((cmd_args_t *)NULL);
}
/* Configure and populate the args structures */
args = malloc(sizeof (*args));
if (args == NULL)
return NULL;
return (NULL);
memset(args, 0, sizeof (*args));
@ -271,13 +272,15 @@ args_init(int argc, char **argv)
strncpy(args->log, optarg, ZPIOS_PATH_SIZE - 1);
break;
case 'I': /* --regionnoise */
rc = set_noise(&args->regionnoise, optarg, "regionnoise");
rc = set_noise(&args->regionnoise, optarg,
"regionnoise");
break;
case 'N': /* --chunknoise */
rc = set_noise(&args->chunknoise, optarg, "chunknoise");
break;
case 'T': /* --threaddelay */
rc = set_noise(&args->thread_delay, optarg, "threaddelay");
rc = set_noise(&args->thread_delay, optarg,
"threaddelay");
break;
case 'V': /* --verify */
args->flags |= DMU_VERIFY;
@ -301,7 +304,8 @@ args_init(int argc, char **argv)
rc = 1;
break;
default:
fprintf(stderr,"Unknown option '%s'\n",argv[optind-1]);
fprintf(stderr, "Unknown option '%s'\n",
argv[optind - 1]);
rc = EINVAL;
break;
}
@ -309,7 +313,7 @@ args_init(int argc, char **argv)
if (rc) {
usage();
args_fini(args);
return NULL;
return (NULL);
}
}
@ -323,7 +327,7 @@ args_init(int argc, char **argv)
fprintf(stderr, "Error: Pool not specificed\n");
usage();
args_fini(args);
return NULL;
return (NULL);
}
if ((args->flags & (DMU_WRITE_ZC | DMU_READ_ZC)) &&
@ -332,10 +336,10 @@ args_init(int argc, char **argv)
"used for performance analysis only\n");
usage();
args_fini(args);
return NULL;
return (NULL);
}
return args;
return (args);
}
static int
@ -356,7 +360,7 @@ dev_clear(void)
lseek(zpiosctl_fd, 0, SEEK_SET);
return rc;
return (rc);
}
/* Passing a size of zero simply results in querying the current size */
@ -375,10 +379,10 @@ dev_size(int size)
if (rc) {
fprintf(stderr, "Ioctl() error %lu / %d: %d\n",
(unsigned long) ZPIOS_CFG, cfg.cfg_cmd, errno);
return rc;
return (rc);
}
return cfg.cfg_rc1;
return (cfg.cfg_rc1);
}
static void
@ -422,7 +426,7 @@ dev_init(void)
}
memset(zpios_buffer, 0, zpios_buffer_size);
return 0;
return (0);
error:
if (zpiosctl_fd != -1) {
if (close(zpiosctl_fd) == -1) {
@ -431,7 +435,7 @@ error:
}
}
return rc;
return (rc);
}
static int
@ -443,35 +447,35 @@ get_next(uint64_t *val, range_repeat_t *range)
(range->val_low * range->next_val / 100);
if (*val > range->val_high)
return 0; /* No more values, limit exceeded */
return (0); /* No more values, limit exceeded */
if (!range->next_val)
range->next_val = range->val_inc_perc;
else
range->next_val = range->next_val + range->val_inc_perc;
return 1; /* more values to come */
return (1); /* more values to come */
/* if only one val is given */
} else if (range->val_count == 1) {
if (range->next_val)
return 0; /* No more values, we only have one */
return (0); /* No more values, we only have one */
*val = range->val[0];
range->next_val = 1;
return 1; /* more values to come */
return (1); /* more values to come */
/* if comma separated values are given */
} else if (range->val_count > 1) {
if (range->next_val > range->val_count - 1)
return 0; /* No more values, limit exceeded */
return (0); /* No more values, limit exceeded */
*val = range->val[range->next_val];
range->next_val++;
return 1; /* more values to come */
return (1); /* more values to come */
}
return 0;
return (0);
}
static int
@ -483,10 +487,12 @@ run_one(cmd_args_t *args, uint32_t id, uint32_t T, uint32_t N,
dev_clear();
cmd_size = sizeof(zpios_cmd_t) + ((T + N + 1) * sizeof(zpios_stats_t));
cmd_size =
sizeof (zpios_cmd_t)
+ ((T + N + 1) * sizeof (zpios_stats_t));
cmd = (zpios_cmd_t *)malloc(cmd_size);
if (cmd == NULL)
return ENOMEM;
return (ENOMEM);
memset(cmd, 0, cmd_size);
cmd->cmd_magic = ZPIOS_CMD_MAGIC;
@ -524,7 +530,7 @@ run_one(cmd_args_t *args, uint32_t id, uint32_t T, uint32_t N,
free(cmd);
return rc;
return (rc);
}
static int
@ -540,7 +546,7 @@ run_offsets(cmd_args_t *args)
}
args->O.next_val = 0;
return rc;
return (rc);
}
static int
@ -552,7 +558,7 @@ run_region_counts(cmd_args_t *args)
rc = run_offsets(args);
args->N.next_val = 0;
return rc;
return (rc);
}
static int
@ -564,14 +570,14 @@ run_region_sizes(cmd_args_t *args)
if (args->current_S < args->current_C) {
fprintf(stderr, "Error: in any run chunksize can "
"not be smaller than regionsize.\n");
return EINVAL;
return (EINVAL);
}
rc = run_region_counts(args);
}
args->S.next_val = 0;
return rc;
return (rc);
}
static int
@ -584,7 +590,7 @@ run_chunk_sizes(cmd_args_t *args)
}
args->C.next_val = 0;
return rc;
return (rc);
}
static int
@ -595,7 +601,7 @@ run_thread_counts(cmd_args_t *args)
while (rc == 0 && get_next((uint64_t *)&args->current_T, &args->T))
rc = run_chunk_sizes(args);
return rc;
return (rc);
}
int
@ -625,5 +631,5 @@ out:
args_fini(args);
dev_fini();
return rc;
return (rc);
}

73
cmd/zpios/zpios_util.c
View File

@ -1,4 +1,4 @@
/*****************************************************************************\
/*
* ZPIOS is a heavily modified version of the original PIOS test code.
* It is designed to have the test code running in the Linux kernel
* against ZFS while still being flexibly controled from user space.
@ -29,7 +29,7 @@
*
* You should have received a copy of the GNU General Public License along
* with ZPIOS. If not, see <http://www.gnu.org/licenses/>.
\*****************************************************************************/
*/
#include <stdlib.h>
#include <stdio.h>
@ -49,7 +49,7 @@ kmgt_to_uint64(const char *str, uint64_t *val)
*val = strtoll(str, &endptr, 0);
if ((str == endptr) && (*val == 0))
return EINVAL;
return (EINVAL);
switch (endptr[0]) {
case 'k': case 'K':
@ -70,7 +70,7 @@ kmgt_to_uint64(const char *str, uint64_t *val)
rc = EINVAL;
}
return rc;
return (rc);
}
static char *
@ -90,7 +90,7 @@ uint64_to_kmgt(char *str, uint64_t val)
(void) snprintf(str, KMGT_SIZE-1, "%lu%c", (unsigned long)val,
(i == -1) ? '\0' : postfix[i]);
return str;
return (str);
}
static char *
@ -111,7 +111,7 @@ kmgt_per_sec(char *str, uint64_t v, double t)
(void) snprintf(str, KMGT_SIZE-1, "%.2f%c", val,
(i == -1) ? '\0' : postfix[i]);
return str;
return (str);
}
static char *
@ -126,7 +126,7 @@ print_flags(char *str, uint32_t flags)
str[6] = (flags & DMU_WRITE_NOWAIT) ? 'O' : '-';
str[7] = '\0';
return str;
return (str);
}
static int
@ -138,13 +138,13 @@ regex_match(const char *string, char *pattern)
rc = regcomp(&re, pattern, REG_EXTENDED | REG_NOSUB | REG_ICASE);
if (rc) {
fprintf(stderr, "Error: Couldn't do regcomp, %d\n", rc);
return rc;
return (rc);
}
rc = regexec(&re, string, (size_t) 0, NULL, 0);
regfree(&re);
return rc;
return (rc);
}
/* fills the pios_range_repeat structure of comma separated values */
@ -156,14 +156,15 @@ split_string(const char *optarg, char *pattern, range_repeat_t *range)
int rc, i = 0;
if ((rc = regex_match(optarg, pattern)))
return rc;
return (rc);
cp = strdup(optarg);
if (cp == NULL)
return ENOMEM;
return (ENOMEM);
do {
/* STRTOK(3) Each subsequent call, with a null pointer as the
/*
* STRTOK(3) Each subsequent call, with a null pointer as the
* value of the * first argument, starts searching from the
* saved pointer and behaves as described above.
*/
@ -177,7 +178,7 @@ split_string(const char *optarg, char *pattern, range_repeat_t *range)
kmgt_to_uint64(token[i], &range->val[i]);
free(cp);
return 0;
return (0);
}
int
@ -195,14 +196,16 @@ set_count(char *pattern1, char *pattern2, range_repeat_t *range,
} else if (split_string(optarg, pattern2, range) < 0) {
fprintf(stderr, "Error: Incorrect pattern for %s, '%s'\n",
arg, optarg);
return EINVAL;
return (EINVAL);
}
return 0;
return (0);
}
/* validates the value with regular expression and sets low, high, incr
* according to value at which flag will be set. Sets the flag after. */
/*
* Validates the value with regular expression and sets low, high, incr
* according to value at which flag will be set. Sets the flag after.
*/
int
set_lhi(char *pattern, range_repeat_t *range, char *optarg,
int flag, uint32_t *flag_thread, char *arg)
@ -212,7 +215,7 @@ set_lhi(char *pattern, range_repeat_t *range, char *optarg,
if ((rc = regex_match(optarg, pattern))) {
fprintf(stderr, "Error: Wrong pattern in %s, '%s'\n",
arg, optarg);
return rc;
return (rc);
}
switch (flag) {
@ -231,7 +234,7 @@ set_lhi(char *pattern, range_repeat_t *range, char *optarg,
*flag_thread |= flag;
return 0;
return (0);
}
int
@ -241,10 +244,10 @@ set_noise(uint64_t *noise, char *optarg, char *arg)
kmgt_to_uint64(optarg, noise);
} else {
fprintf(stderr, "Error: Incorrect pattern for %s\n", arg);
return EINVAL;
return (EINVAL);
}
return 0;
return (0);
}
int
@ -255,7 +258,7 @@ set_load_params(cmd_args_t *args, char *optarg)
search = strdup(optarg);
if (search == NULL)
return ENOMEM;
return (ENOMEM);
while ((param = strtok(search, comma)) != NULL) {
search = NULL;
@ -275,20 +278,22 @@ set_load_params(cmd_args_t *args, char *optarg)
free(search);
return rc;
return (rc);
}
/* checks the low, high, increment values against the single value for
/*
* Checks the low, high, increment values against the single value for
* mutual exclusion, for e.g threadcount is mutually exclusive to
* threadcount_low, ..._high, ..._incr */
* threadcount_low, ..._high, ..._incr
*/
int
check_mutual_exclusive_command_lines(uint32_t flag, char *arg)
{
if ((flag & FLAG_SET) && (flag & (FLAG_LOW | FLAG_HIGH | FLAG_INCR))) {
fprintf(stderr, "Error: --%s can not be given with --%s_low, "
"--%s_high or --%s_incr.\n", arg, arg, arg, arg);
return 0;
return (0);
}
if ((flag & (FLAG_LOW | FLAG_HIGH | FLAG_INCR)) && !(flag & FLAG_SET)) {
@ -296,30 +301,34 @@ check_mutual_exclusive_command_lines(uint32_t flag, char *arg)
fprintf(stderr, "Error: One or more values missing "
"from --%s_low, --%s_high, --%s_incr.\n",
arg, arg, arg);
return 0;
return (0);
}
}
return 1;
return (1);
}
void
print_stats_header(cmd_args_t *args)
{
if (args->verbose) {
printf("status name id\tth-cnt\trg-cnt\trg-sz\t"
printf(
"status name id\tth-cnt\trg-cnt\trg-sz\t"
"ch-sz\toffset\trg-no\tch-no\tth-dly\tflags\ttime\t"
"cr-time\trm-time\twr-time\trd-time\twr-data\twr-ch\t"
"wr-bw\trd-data\trd-ch\trd-bw\n");
printf("------------------------------------------------"
printf(
"------------------------------------------------"
"------------------------------------------------"
"------------------------------------------------"
"----------------------------------------------\n");
} else {
printf("status name id\t"
printf(
"status name id\t"
"wr-data\twr-ch\twr-bw\t"
"rd-data\trd-ch\trd-bw\n");
printf("-----------------------------------------"
printf(
"-----------------------------------------"
"--------------------------------------\n");
}
}

21
cmd/zpool/zpool_main.c
View File

@ -2568,7 +2568,7 @@ get_columns(void)
columns = 999;
}
return columns;
return (columns);
}
int
@ -5037,19 +5037,21 @@ get_history_one(zpool_handle_t *zhp, void *data)
}
(void) printf("%s [internal %s txg:%lld] %s", tbuf,
zfs_history_event_names[ievent],
(long long int)fnvlist_lookup_uint64(rec, ZPOOL_HIST_TXG),
(longlong_t) fnvlist_lookup_uint64(
rec, ZPOOL_HIST_TXG),
fnvlist_lookup_string(rec, ZPOOL_HIST_INT_STR));
} else if (nvlist_exists(rec, ZPOOL_HIST_INT_NAME)) {
if (!cb->internal)
continue;
(void) printf("%s [txg:%lld] %s", tbuf,
(long long int)fnvlist_lookup_uint64(rec, ZPOOL_HIST_TXG),
(longlong_t) fnvlist_lookup_uint64(
rec, ZPOOL_HIST_TXG),
fnvlist_lookup_string(rec, ZPOOL_HIST_INT_NAME));
if (nvlist_exists(rec, ZPOOL_HIST_DSNAME)) {
(void) printf(" %s (%llu)",
fnvlist_lookup_string(rec,
ZPOOL_HIST_DSNAME),
(long long unsigned int)fnvlist_lookup_uint64(rec,
(u_longlong_t)fnvlist_lookup_uint64(rec,
ZPOOL_HIST_DSID));
}
(void) printf(" %s", fnvlist_lookup_string(rec,
@ -5357,7 +5359,8 @@ zpool_do_events_nvprint(nvlist_t *nvl, int depth)
(void) nvpair_value_int64_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
printf(gettext("0x%llx "), (u_longlong_t)val[i]);
printf(gettext("0x%llx "),
(u_longlong_t)val[i]);
break;
}
@ -5368,7 +5371,8 @@ zpool_do_events_nvprint(nvlist_t *nvl, int depth)
(void) nvpair_value_uint64_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
printf(gettext("0x%llx "), (u_longlong_t)val[i]);
printf(gettext("0x%llx "),
(u_longlong_t)val[i]);
break;
}
@ -5476,7 +5480,7 @@ zpool_do_events(int argc, char **argv)
else
ret = zpool_do_events_next(&opts);
return ret;
return (ret);
}
static int
@ -5690,8 +5694,7 @@ main(int argc, char **argv)
/*
* Special case '-?'
*/
if ((strcmp(cmdname, "-?") == 0) ||
strcmp(cmdname, "--help") == 0)
if ((strcmp(cmdname, "-?") == 0) || strcmp(cmdname, "--help") == 0)
usage(B_TRUE);
if ((g_zfs = libzfs_init()) == NULL)

3
cmd/zpool/zpool_util.h
View File

@ -44,7 +44,8 @@ uint_t num_logs(nvlist_t *nv);
*/
nvlist_t *make_root_vdev(zpool_handle_t *zhp, nvlist_t *props, int force,
int check_rep, boolean_t replacing, boolean_t dryrun, int argc, char **argv);
int check_rep, boolean_t replacing, boolean_t dryrun, int argc,
char **argv);
nvlist_t *split_mirror_vdev(zpool_handle_t *zhp, char *newname,
nvlist_t *props, splitflags_t flags, int argc, char **argv);

27
cmd/zpool/zpool_vdev.c
View File

@ -412,7 +412,7 @@ check_disk(const char *path, blkid_cache cache, int force,
/* This is not a wholedisk we only check the given partition */
if (!iswholedisk)
return check_slice(path, cache, force, isspare);
return (check_slice(path, cache, force, isspare));
/*
* When the device is a whole disk try to read the efi partition
@ -424,19 +424,19 @@ check_disk(const char *path, blkid_cache cache, int force,
*/
if ((fd = open(path, O_RDONLY|O_DIRECT)) < 0) {
check_error(errno);
return -1;
return (-1);
}
if ((err = efi_alloc_and_read(fd, &vtoc)) != 0) {
(void) close(fd);
if (force) {
return 0;
return (0);
} else {
vdev_error(gettext("%s does not contain an EFI "
"label but it may contain partition\n"
"information in the MBR.\n"), path);
return -1;
return (-1);
}
}
@ -451,11 +451,11 @@ check_disk(const char *path, blkid_cache cache, int force,
if (force) {
/* Partitions will no be created using the backup */
return 0;
return (0);
} else {
vdev_error(gettext("%s contains a corrupt primary "
"EFI label.\n"), path);
return -1;
return (-1);
}
}
@ -500,18 +500,18 @@ check_device(const char *path, boolean_t force,
if ((err = blkid_get_cache(&cache, NULL)) != 0) {
check_error(err);
return -1;
return (-1);
}
if ((err = blkid_probe_all(cache)) != 0) {
blkid_put_cache(cache);
check_error(err);
return -1;
return (-1);
}
}
#endif /* HAVE_LIBBLKID */
return check_disk(path, cache, force, isspare, iswholedisk);
return (check_disk(path, cache, force, isspare, iswholedisk));
}
/*
@ -1136,7 +1136,7 @@ zero_label(char *path)
return (-1);
}
return 0;
return (0);
}
/*
@ -1502,8 +1502,8 @@ construct_spec(nvlist_t *props, int argc, char **argv)
children * sizeof (nvlist_t *));
if (child == NULL)
zpool_no_memory();
if ((nv = make_leaf_vdev(props, argv[c], B_FALSE))
== NULL)
if ((nv = make_leaf_vdev(props, argv[c],
B_FALSE)) == NULL)
return (NULL);
child[children - 1] = nv;
}
@ -1558,7 +1558,8 @@ construct_spec(nvlist_t *props, int argc, char **argv)
* We have a device. Pass off to make_leaf_vdev() to
* construct the appropriate nvlist describing the vdev.
*/
if ((nv = make_leaf_vdev(props, argv[0], is_log)) == NULL)
if ((nv = make_leaf_vdev(props, argv[0],
is_log)) == NULL)
return (NULL);
if (is_log)
nlogs++;

10
cmd/ztest/ztest.c
View File

@ -4166,7 +4166,8 @@ ztest_dmu_prealloc(ztest_ds_t *zd, uint64_t id)
ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0);
if (ztest_object_init(zd, od, sizeof (ztest_od_t), !ztest_random(2)) != 0) {
if (ztest_object_init(zd, od, sizeof (ztest_od_t),
!ztest_random(2)) != 0) {
umem_free(od, sizeof (ztest_od_t));
return;
}
@ -4790,11 +4791,12 @@ ztest_dmu_snapshot_hold(ztest_ds_t *zd, uint64_t id)
dmu_objset_name(os, osname);
(void) snprintf(snapname, sizeof (snapname), "sh1_%llu", (long long unsigned int)id);
(void) snprintf(snapname, sizeof (snapname), "sh1_%llu",
(u_longlong_t)id);
(void) snprintf(fullname, sizeof (fullname), "%s@%s", osname, snapname);
(void) snprintf(clonename, sizeof (clonename),
"%s/ch1_%llu", osname, (long long unsigned int)id);
(void) snprintf(tag, sizeof (tag), "tag_%llu", (long long unsigned int)id);
"%s/ch1_%llu", osname, (u_longlong_t)id);
(void) snprintf(tag, sizeof (tag), "tag_%llu", (u_longlong_t)id);
/*
* Clean up from any previous run.

6
cmd/zvol_id/zvol_id_main.c
View File

@ -33,7 +33,8 @@
#include <sys/zfs_znode.h>
#include <sys/fs/zfs.h>
int ioctl_get_msg(char *var, int fd)
static int
ioctl_get_msg(char *var, int fd)
{
int error = 0;
char msg[ZFS_MAXNAMELEN];
@ -47,7 +48,8 @@ int ioctl_get_msg(char *var, int fd)
return (error);
}
int main(int argc, char **argv)
int
main(int argc, char **argv)
{
int fd, error = 0;
char zvol_name[ZFS_MAXNAMELEN], zvol_name_part[ZFS_MAXNAMELEN];

34
include/linux/blkdev_compat.h
View File

@ -46,7 +46,7 @@ blk_fetch_request(struct request_queue *q)
if (req)
blkdev_dequeue_request(req);
return req;
return (req);
}
#endif /* HAVE_BLK_FETCH_REQUEST */
@ -79,7 +79,7 @@ __blk_end_request(struct request *req, int error, unsigned int nr_bytes)
req->hard_cur_sectors = nr_bytes >> 9;
end_request(req, ((error == 0) ? 1 : error));
return 0;
return (0);
}
static inline bool
@ -92,7 +92,7 @@ blk_end_request(struct request *req, int error, unsigned int nr_bytes)
rc = __blk_end_request(req, error, nr_bytes);
spin_unlock_irq(q->queue_lock);
return rc;
return (rc);
}
#else
#ifdef HAVE_BLK_END_REQUEST_GPL_ONLY
@ -115,7 +115,7 @@ __blk_end_request_x(struct request *req, int error, unsigned int nr_bytes)
req->hard_cur_sectors = nr_bytes >> 9;
end_request(req, ((error == 0) ? 1 : error));
return 0;
return (0);
}
static inline bool
blk_end_request_x(struct request *req, int error, unsigned int nr_bytes)
@ -127,7 +127,7 @@ blk_end_request_x(struct request *req, int error, unsigned int nr_bytes)
rc = __blk_end_request_x(req, error, nr_bytes);
spin_unlock_irq(q->queue_lock);
return rc;
return (rc);
}
#endif /* HAVE_BLK_END_REQUEST_GPL_ONLY */
#endif /* HAVE_BLK_END_REQUEST */
@ -153,7 +153,7 @@ __blk_queue_flush(struct request_queue *q, unsigned int flags)
static inline sector_t
blk_rq_pos(struct request *req)
{
return req->sector;
return (req->sector);
}
#endif /* HAVE_BLK_RQ_POS */
@ -161,7 +161,7 @@ blk_rq_pos(struct request *req)
static inline unsigned int
blk_rq_sectors(struct request *req)
{
return req->nr_sectors;
return (req->nr_sectors);
}
#endif /* HAVE_BLK_RQ_SECTORS */
@ -175,7 +175,7 @@ blk_rq_sectors(struct request *req)
static inline unsigned int
__blk_rq_bytes(struct request *req)
{
return blk_rq_sectors(req) << 9;
return (blk_rq_sectors(req) << 9);
}
#endif /* !HAVE_BLK_RQ_BYTES || HAVE_BLK_RQ_BYTES_GPL_ONLY */
@ -256,7 +256,7 @@ get_disk_ro(struct gendisk *disk)
if (disk->part[0])
policy = disk->part[0]->policy;
return policy;
return (policy);
}
#endif /* HAVE_GET_DISK_RO */
@ -315,8 +315,8 @@ bio_set_flags_failfast(struct block_device *bdev, int *flags)
#ifdef HAVE_BIO_RW_FAILFAST_DTD
/* BIO_RW_FAILFAST_* preferred interface from 2.6.28 - 2.6.35 */
*flags |=
((1 << BIO_RW_FAILFAST_DEV) |
*flags |= (
(1 << BIO_RW_FAILFAST_DEV) |
(1 << BIO_RW_FAILFAST_TRANSPORT) |
(1 << BIO_RW_FAILFAST_DRIVER));
#else
@ -325,8 +325,10 @@ bio_set_flags_failfast(struct block_device *bdev, int *flags)
*flags |= (1 << BIO_RW_FAILFAST);
#else
#ifdef HAVE_REQ_FAILFAST_MASK
/* REQ_FAILFAST_* preferred interface from 2.6.36 - 2.6.xx,
* the BIO_* and REQ_* flags were unified under REQ_* flags. */
/*
* REQ_FAILFAST_* preferred interface from 2.6.36 - 2.6.xx,
* the BIO_* and REQ_* flags were unified under REQ_* flags.
*/
*flags |= REQ_FAILFAST_MASK;
#endif /* HAVE_REQ_FAILFAST_MASK */
#endif /* HAVE_BIO_RW_FAILFAST */
@ -349,8 +351,10 @@ bio_set_flags_failfast(struct block_device *bdev, int *flags)
#define BIO_END_IO_PROTO(fn, x, y, z) static void fn(struct bio *x, int z)
#define BIO_END_IO_RETURN(rc) return
#else
# define BIO_END_IO_PROTO(fn, x, y, z) static int fn(struct bio *x, \
unsigned int y, int z)
#define BIO_END_IO_PROTO(fn, x, y, z) static int fn( \
struct bio *x, \
unsigned int y, \
int z)
#define BIO_END_IO_RETURN(rc) return rc
#endif /* HAVE_2ARGS_BIO_END_IO_T */

4
include/linux/dcache_compat.h
View File

@ -74,8 +74,8 @@ d_clear_d_op(struct dentry *dentry)
{
#ifdef HAVE_D_SET_D_OP
dentry->d_op = NULL;
dentry->d_flags &=
~(DCACHE_OP_HASH | DCACHE_OP_COMPARE |
dentry->d_flags &= ~(
DCACHE_OP_HASH | DCACHE_OP_COMPARE |
DCACHE_OP_REVALIDATE | DCACHE_OP_DELETE);
#endif /* HAVE_D_SET_D_OP */
}

12
include/linux/vfs_compat.h
View File

@ -71,7 +71,10 @@ truncate_setsize(struct inode *ip, loff_t new)
extern atomic_long_t zfs_bdi_seq;
static inline int
bdi_setup_and_register(struct backing_dev_info *bdi,char *name,unsigned int cap)
bdi_setup_and_register(
struct backing_dev_info *bdi,
char *name,
unsigned int cap)
{
char tmp[32];
int error;
@ -154,8 +157,11 @@ typedef int zpl_umode_t;
#if defined(SEEK_HOLE) && defined(SEEK_DATA) && !defined(HAVE_LSEEK_EXECUTE)
static inline loff_t
lseek_execute(struct file *filp, struct inode *inode,
loff_t offset, loff_t maxsize)
lseek_execute(
struct file *filp,
struct inode *inode,
loff_t offset,
loff_t maxsize)
{
if (offset < 0 && !(filp->f_mode & FMODE_UNSIGNED_OFFSET))
return (-EINVAL);

16
include/linux/xattr_compat.h
View File

@ -52,14 +52,14 @@ static int \
fn(struct dentry *dentry, const char *name, void *buffer, size_t size, \
int unused_handler_flags) \
{ \
return __ ## fn(dentry->d_inode, name, buffer, size); \
return (__ ## fn(dentry->d_inode, name, buffer, size)); \
}
#else
#define ZPL_XATTR_GET_WRAPPER(fn) \
static int \
fn(struct inode *ip, const char *name, void *buffer, size_t size) \
{ \
return __ ## fn(ip, name, buffer, size); \
return (__ ## fn(ip, name, buffer, size)); \
}
#endif /* HAVE_DENTRY_XATTR_GET */
@ -74,7 +74,7 @@ static int \
fn(struct dentry *dentry, const char *name, const void *buffer, \
size_t size, int flags, int unused_handler_flags) \
{ \
return __ ## fn(dentry->d_inode, name, buffer, size, flags); \
return (__ ## fn(dentry->d_inode, name, buffer, size, flags)); \
}
#else
#define ZPL_XATTR_SET_WRAPPER(fn) \
@ -82,7 +82,7 @@ static int \
fn(struct inode *ip, const char *name, const void *buffer, \
size_t size, int flags) \
{ \
return __ ## fn(ip, name, buffer, size, flags); \
return (__ ## fn(ip, name, buffer, size, flags)); \
}
#endif /* HAVE_DENTRY_XATTR_SET */
@ -103,13 +103,13 @@ fn(struct inode *ip, const char *name, const void *buffer, \
static inline struct posix_acl *
zpl_acl_from_xattr(const void *value, int size)
{
return posix_acl_from_xattr(CRED()->user_ns, value, size);
return (posix_acl_from_xattr(CRED()->user_ns, value, size));
}
static inline int
zpl_acl_to_xattr(struct posix_acl *acl, void *value, int size)
{
return posix_acl_to_xattr(CRED()->user_ns,acl, value, size);
return (posix_acl_to_xattr(CRED()->user_ns, acl, value, size));
}
#else
@ -117,13 +117,13 @@ zpl_acl_to_xattr(struct posix_acl *acl, void *value, int size)
static inline struct posix_acl *
zpl_acl_from_xattr(const void *value, int size)
{
return posix_acl_from_xattr(value, size);
return (posix_acl_from_xattr(value, size));
}
static inline int
zpl_acl_to_xattr(struct posix_acl *acl, void *value, int size)
{
return posix_acl_to_xattr(acl, value, size);
return (posix_acl_to_xattr(acl, value, size));
}
#endif /* HAVE_POSIX_ACL_FROM_XATTR_USERNS */

17
include/sys/zpl.h
View File

@ -145,21 +145,22 @@ static inline bool
dir_emit(struct dir_context *ctx, const char *name, int namelen,
uint64_t ino, unsigned type)
{
return ctx->actor(ctx->dirent, name, namelen, ctx->pos, ino, type) == 0;
return (ctx->actor(ctx->dirent, name, namelen, ctx->pos, ino, type)
== 0);
}
static inline bool
dir_emit_dot(struct file *file, struct dir_context *ctx)
{
return ctx->actor(ctx->dirent, ".", 1, ctx->pos,
file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
return (ctx->actor(ctx->dirent, ".", 1, ctx->pos,
file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0);
}
static inline bool
dir_emit_dotdot(struct file *file, struct dir_context *ctx)
{
return ctx->actor(ctx->dirent, "..", 2, ctx->pos,
parent_ino(file->f_path.dentry), DT_DIR) == 0;
return (ctx->actor(ctx->dirent, "..", 2, ctx->pos,
parent_ino(file->f_path.dentry), DT_DIR) == 0);
}
static inline bool
@ -167,15 +168,15 @@ dir_emit_dots(struct file *file, struct dir_context *ctx)
{
if (ctx->pos == 0) {
if (!dir_emit_dot(file, ctx))
return false;
return (false);
ctx->pos = 1;
}
if (ctx->pos == 1) {
if (!dir_emit_dotdot(file, ctx))
return false;
return (false);
ctx->pos = 2;
}
return true;
return (true);
}
#endif /* HAVE_VFS_ITERATE */

31
include/zpios-ctl.h
View File

@ -1,4 +1,4 @@
/*****************************************************************************\
/*
* ZPIOS is a heavily modified version of the original PIOS test code.
* It is designed to have the test code running in the Linux kernel
* against ZFS while still being flexibly controled from user space.
@ -29,12 +29,13 @@
*
* You should have received a copy of the GNU General Public License along
* with ZPIOS. If not, see <http://www.gnu.org/licenses/>.
\*****************************************************************************/
*/
#ifndef _ZPIOS_CTL_H
#define _ZPIOS_CTL_H
/* Contains shared definitions which both the userspace
/*
* Contains shared definitions which both the userspace
* and kernelspace portions of zpios must agree on.
*/
#ifndef _KERNEL
@ -137,7 +138,8 @@ typedef struct zpios_cmd {
#endif
static inline
void zpios_timespec_normalize(zpios_timespec_t *ts, uint32_t sec, uint32_t nsec)
void
zpios_timespec_normalize(zpios_timespec_t *ts, uint32_t sec, uint32_t nsec)
{
while (nsec >= NSEC_PER_SEC) {
nsec -= NSEC_PER_SEC;
@ -152,27 +154,30 @@ void zpios_timespec_normalize(zpios_timespec_t *ts, uint32_t sec, uint32_t nsec)
}
static inline
zpios_timespec_t zpios_timespec_add(zpios_timespec_t lhs, zpios_timespec_t rhs)
zpios_timespec_t
zpios_timespec_add(zpios_timespec_t lhs, zpios_timespec_t rhs)
{
zpios_timespec_t ts_delta;
zpios_timespec_normalize(&ts_delta, lhs.ts_sec + rhs.ts_sec,
lhs.ts_nsec + rhs.ts_nsec);
return ts_delta;
return (ts_delta);
}
static inline
zpios_timespec_t zpios_timespec_sub(zpios_timespec_t lhs, zpios_timespec_t rhs)
zpios_timespec_t
zpios_timespec_sub(zpios_timespec_t lhs, zpios_timespec_t rhs)
{
zpios_timespec_t ts_delta;
zpios_timespec_normalize(&ts_delta, lhs.ts_sec - rhs.ts_sec,
lhs.ts_nsec - rhs.ts_nsec);
return ts_delta;
return (ts_delta);
}
#ifdef _KERNEL
static inline
zpios_timespec_t zpios_timespec_now(void)
zpios_timespec_t
zpios_timespec_now(void)
{
zpios_timespec_t zts_now;
struct timespec ts_now;
@ -181,15 +186,17 @@ zpios_timespec_t zpios_timespec_now(void)
zts_now.ts_sec = ts_now.tv_sec;
zts_now.ts_nsec = ts_now.tv_nsec;
return zts_now;
return (zts_now);
}
#else
static inline
double zpios_timespec_to_double(zpios_timespec_t ts)
double
zpios_timespec_to_double(zpios_timespec_t ts)
{
return ((double)(ts.ts_sec) +
return
((double)(ts.ts_sec) +
((double)(ts.ts_nsec) / (double)(NSEC_PER_SEC)));
}

30
include/zpios-internal.h
View File

@ -1,4 +1,4 @@
/*****************************************************************************\
/*
* ZPIOS is a heavily modified version of the original PIOS test code.
* It is designed to have the test code running in the Linux kernel
* against ZFS while still being flexibly controled from user space.
@ -29,7 +29,7 @@
*
* You should have received a copy of the GNU General Public License along
* with ZPIOS. If not, see <http://www.gnu.org/licenses/>.
\*****************************************************************************/
*/
#ifndef _ZPIOS_INTERNAL_H
#define _ZPIOS_INTERNAL_H
@ -109,30 +109,4 @@ typedef struct zpios_info {
char *info_head; /* Internal kernel use only */
} zpios_info_t;
#define zpios_print(file, format, args...) \
({ zpios_info_t *_info_ = (zpios_info_t *)file->private_data; \
int _rc_; \
\
ASSERT(_info_); \
ASSERT(_info_->info_buffer); \
\
spin_lock(&_info_->info_lock); \
\
/* Don't allow the kernel to start a write in the red zone */ \
if ((int)(_info_->info_head - _info_->info_buffer) > \
(_info_->info_size - ZPIOS_INFO_BUFFER_REDZONE)) { \
_rc_ = -EOVERFLOW; \
} else { \
_rc_ = sprintf(_info_->info_head, format, args); \
if (_rc_ >= 0) \
_info_->info_head += _rc_; \
} \
\
spin_unlock(&_info_->info_lock); \
_rc_; \
})
#define zpios_vprint(file, test, format, args...) \
zpios_print(file, "%*s: " format, ZPIOS_NAME_SIZE, test, args)
#endif /* _ZPIOS_INTERNAL_H */

29
lib/libefi/rdwr_efi.c
View File

@ -398,7 +398,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
fprintf(stderr, "unable to read disk info: %d", errno);
errno = EIO;
return -1;
return (-1);
}
switch (cmd) {
@ -416,7 +416,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
if (efi_debug)
(void) fprintf(stderr, "DKIOCGETEFI lseek "
"error: %d\n", errno);
return error;
return (error);
}
error = read(fd, data, dk_ioc->dki_length);
@ -424,7 +424,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
if (efi_debug)
(void) fprintf(stderr, "DKIOCGETEFI read "
"error: %d\n", errno);
return error;
return (error);
}
if (error != dk_ioc->dki_length) {
@ -432,7 +432,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
(void) fprintf(stderr, "DKIOCGETEFI short "
"read of %d bytes\n", error);
errno = EIO;
return -1;
return (-1);
}
error = 0;
break;
@ -443,7 +443,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
(void) fprintf(stderr, "DKIOCSETEFI unknown "
"LBA size\n");
errno = EIO;
return -1;
return (-1);
}
error = lseek(fd, dk_ioc->dki_lba * lbsize, SEEK_SET);
@ -451,7 +451,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
if (efi_debug)
(void) fprintf(stderr, "DKIOCSETEFI lseek "
"error: %d\n", errno);
return error;
return (error);
}
error = write(fd, data, dk_ioc->dki_length);
@ -459,7 +459,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
if (efi_debug)
(void) fprintf(stderr, "DKIOCSETEFI write "
"error: %d\n", errno);
return error;
return (error);
}
if (error != dk_ioc->dki_length) {
@ -467,17 +467,17 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
(void) fprintf(stderr, "DKIOCSETEFI short "
"write of %d bytes\n", error);
errno = EIO;
return -1;
return (-1);
}
/* Sync the new EFI table to disk */
error = fsync(fd);
if (error == -1)
return error;
return (error);
/* Ensure any local disk cache is also flushed */
if (ioctl(fd, BLKFLSBUF, 0) == -1)
return error;
return (error);
error = 0;
break;
@ -487,7 +487,7 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
(void) fprintf(stderr, "unsupported ioctl()\n");
errno = EIO;
return -1;
return (-1);
}
#else
dk_ioc->dki_data_64 = (uint64_t)(uintptr_t)data;
@ -497,7 +497,8 @@ efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
return (error);
}
int efi_rescan(int fd)
int
efi_rescan(int fd)
{
#if defined(__linux__)
int retry = 5;
@ -590,7 +591,7 @@ efi_read(int fd, struct dk_gpt *vtoc)
* get the partition number for this file descriptor.
*/
if ((rval = efi_get_info(fd, &dki_info)) != 0)
return rval;
return (rval);
if ((strncmp(dki_info.dki_cname, "pseudo", 7) == 0) &&
(strncmp(dki_info.dki_dname, "md", 3) == 0)) {
@ -1117,7 +1118,7 @@ efi_write(int fd, struct dk_gpt *vtoc)
diskaddr_t lba_backup_gpt_hdr;
if ((rval = efi_get_info(fd, &dki_info)) != 0)
return rval;
return (rval);
/* check if we are dealing wih a metadevice */
if ((strncmp(dki_info.dki_cname, "pseudo", 7) == 0) &&

58
lib/libshare/libshare.c
View File

@ -64,7 +64,7 @@ register_fstype(const char *name, const sa_share_ops_t *ops)
fstype = calloc(sizeof (sa_fstype_t), 1);
if (fstype == NULL)
return NULL;
return (NULL);
fstype->name = name;
fstype->ops = ops;
@ -75,7 +75,7 @@ register_fstype(const char *name, const sa_share_ops_t *ops)
fstype->next = fstypes;
fstypes = fstype;
return fstype;
return (fstype);
}
sa_handle_t
@ -86,7 +86,7 @@ sa_init(int init_service)
impl_handle = calloc(sizeof (struct sa_handle_impl), 1);
if (impl_handle == NULL)
return NULL;
return (NULL);
impl_handle->zfs_libhandle = libzfs_init();
@ -243,30 +243,30 @@ update_zfs_shares_cb(zfs_handle_t *zhp, void *pcookie)
if (type == ZFS_TYPE_FILESYSTEM &&
zfs_iter_filesystems(zhp, update_zfs_shares_cb, pcookie) != 0) {
zfs_close(zhp);
return 1;
return (1);
}
if (type != ZFS_TYPE_FILESYSTEM) {
zfs_close(zhp);
return 0;
return (0);
}
if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
zfs_close(zhp);
return 0;
return (0);
}
dataset = (char *)zfs_get_name(zhp);
if (dataset == NULL) {
zfs_close(zhp);
return 0;
return (0);
}
if (!zfs_is_mounted(zhp, NULL)) {
zfs_close(zhp);
return 0;
return (0);
}
if ((udata->proto == NULL || strcmp(udata->proto, "nfs") == 0) &&
@ -287,7 +287,7 @@ update_zfs_shares_cb(zfs_handle_t *zhp, void *pcookie)
zfs_close(zhp);
return 0;
return (0);
}
static int
@ -298,7 +298,7 @@ update_zfs_share(sa_share_impl_t impl_share, const char *proto)
update_cookie_t udata;
if (impl_handle->zfs_libhandle == NULL)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
assert(impl_share->dataset != NULL);
@ -306,13 +306,13 @@ update_zfs_share(sa_share_impl_t impl_share, const char *proto)
ZFS_TYPE_FILESYSTEM);
if (zhp == NULL)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
udata.handle = impl_handle;
udata.proto = proto;
(void) update_zfs_shares_cb(zhp, &udata);
return SA_OK;
return (SA_OK);
}
static int
@ -321,14 +321,14 @@ update_zfs_shares(sa_handle_impl_t impl_handle, const char *proto)
update_cookie_t udata;
if (impl_handle->zfs_libhandle == NULL)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
udata.handle = impl_handle;
udata.proto = proto;
(void) zfs_iter_root(impl_handle->zfs_libhandle, update_zfs_shares_cb,
&udata);
return SA_OK;
return (SA_OK);
}
static int
@ -351,7 +351,7 @@ process_share(sa_handle_impl_t impl_handle, sa_share_impl_t impl_share,
if (impl_share == NULL) {
if (lstat(pathname, &statbuf) != 0 ||
!S_ISDIR(statbuf.st_mode))
return SA_BAD_PATH;
return (SA_BAD_PATH);
impl_share = alloc_share(pathname);
@ -421,7 +421,7 @@ err:
free_share(impl_share);
}
return rc;
return (rc);
}
void
@ -487,13 +487,13 @@ find_share(sa_handle_impl_t impl_handle, const char *sharepath)
impl_share = impl_share->next;
}
return impl_share;
return (impl_share);
}
sa_share_t
sa_find_share(sa_handle_t handle, char *sharepath)
{
return (sa_share_t)find_share((sa_handle_impl_t)handle, sharepath);
return ((sa_share_t)find_share((sa_handle_impl_t)handle, sharepath));
}
int
@ -715,16 +715,16 @@ sa_parse_legacy_options(sa_group_t group, char *options, char *proto)
continue;
}
return fstype->ops->validate_shareopts(options);
return (fstype->ops->validate_shareopts(options));
}
return SA_INVALID_PROTOCOL;
return (SA_INVALID_PROTOCOL);
}
boolean_t
sa_needs_refresh(sa_handle_t handle)
{
return B_TRUE;
return (B_TRUE);
}
libzfs_handle_t *
@ -733,9 +733,9 @@ sa_get_zfs_handle(sa_handle_t handle)
sa_handle_impl_t impl_handle = (sa_handle_impl_t)handle;
if (impl_handle == NULL)
return NULL;
return (NULL);
return impl_handle->zfs_libhandle;
return (impl_handle->zfs_libhandle);
}
static sa_share_impl_t
@ -746,13 +746,13 @@ alloc_share(const char *sharepath)
impl_share = calloc(sizeof (struct sa_share_impl), 1);
if (impl_share == NULL)
return NULL;
return (NULL);
impl_share->sharepath = strdup(sharepath);
if (impl_share->sharepath == NULL) {
free(impl_share);
return NULL;
return (NULL);
}
impl_share->fsinfo = calloc(sizeof (sa_share_fsinfo_t), fstypes_count);
@ -760,10 +760,10 @@ alloc_share(const char *sharepath)
if (impl_share->fsinfo == NULL) {
free(impl_share->sharepath);
free(impl_share);
return NULL;
return (NULL);
}
return impl_share;
return (impl_share);
}
static void
@ -799,8 +799,8 @@ sa_zfs_process_share(sa_handle_t handle, sa_group_t group, sa_share_t share,
shareopts, sourcestr, dataset);
#endif
return process_share(impl_handle, impl_share, mountpoint, NULL,
proto, shareopts, NULL, dataset, B_FALSE);
return (process_share(impl_handle, impl_share, mountpoint, NULL,
proto, shareopts, NULL, dataset, B_FALSE));
}
void

116
lib/libshare/nfs.c
View File

@ -50,7 +50,7 @@ typedef int (*nfs_shareopt_callback_t)(const char *opt, const char *value,
typedef int (*nfs_host_callback_t)(const char *sharepath, const char *host,
const char *security, const char *access, void *cookie);
/**
/*
* Invokes the specified callback function for each Solaris share option
* listed in the specified string.
*/
@ -62,12 +62,12 @@ foreach_nfs_shareopt(const char *shareopts,
int was_nul, rc;
if (shareopts == NULL)
return SA_OK;
return (SA_OK);
shareopts_dup = strdup(shareopts);
if (shareopts_dup == NULL)
return SA_NO_MEMORY;
return (SA_NO_MEMORY);
opt = shareopts_dup;
was_nul = 0;
@ -95,7 +95,7 @@ foreach_nfs_shareopt(const char *shareopts,
if (rc != SA_OK) {
free(shareopts_dup);
return rc;
return (rc);
}
}
@ -107,7 +107,7 @@ foreach_nfs_shareopt(const char *shareopts,
free(shareopts_dup);
return 0;
return (0);
}
typedef struct nfs_host_cookie_s {
@ -117,7 +117,7 @@ typedef struct nfs_host_cookie_s {
const char *security;
} nfs_host_cookie_t;
/**
/*
* Helper function for foreach_nfs_host. This function checks whether the
* current share option is a host specification and invokes a callback
* function with information about the host.
@ -146,7 +146,7 @@ foreach_nfs_host_cb(const char *opt, const char *value, void *pcookie)
host_dup = strdup(value);
if (host_dup == NULL)
return SA_NO_MEMORY;
return (SA_NO_MEMORY);
host = host_dup;
@ -163,7 +163,7 @@ foreach_nfs_host_cb(const char *opt, const char *value, void *pcookie)
if (rc != SA_OK) {
free(host_dup);
return rc;
return (rc);
}
host = next;
@ -172,10 +172,10 @@ foreach_nfs_host_cb(const char *opt, const char *value, void *pcookie)
free(host_dup);
}
return SA_OK;
return (SA_OK);
}
/**
/*
* Invokes a callback function for all NFS hosts that are set for a share.
*/
static int
@ -196,7 +196,7 @@ foreach_nfs_host(sa_share_impl_t impl_share, nfs_host_callback_t callback,
&udata);
}
/**
/*
* Converts a Solaris NFS host specification to its Linux equivalent.
*/
static int
@ -217,13 +217,13 @@ get_linux_hostspec(const char *solaris_hostspec, char **plinux_hostspec)
}
if (*plinux_hostspec == NULL) {
return SA_NO_MEMORY;
return (SA_NO_MEMORY);
}
return SA_OK;
return (SA_OK);
}
/**
/*
* Used internally by nfs_enable_share to enable sharing for a single host.
*/
static int
@ -281,12 +281,12 @@ nfs_enable_share_one(const char *sharepath, const char *host,
free(opts);
if (rc < 0)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
else
return SA_OK;
return (SA_OK);
}
/**
/*
* Adds a Linux share option to an array of NFS options.
*/
static int
@ -302,7 +302,7 @@ add_linux_shareopt(char **plinux_opts, const char *key, const char *value)
(value ? 1 + strlen(value) : 0) + 1);
if (new_linux_opts == NULL)
return SA_NO_MEMORY;
return (SA_NO_MEMORY);
new_linux_opts[len] = '\0';
@ -318,10 +318,10 @@ add_linux_shareopt(char **plinux_opts, const char *key, const char *value)
*plinux_opts = new_linux_opts;
return SA_OK;
return (SA_OK);
}
/**
/*
* Validates and converts a single Solaris share option to its Linux
* equivalent.
*/
@ -333,7 +333,7 @@ get_linux_shareopts_cb(const char *key, const char *value, void *cookie)
/* host-specific options, these are taken care of elsewhere */
if (strcmp(key, "ro") == 0 || strcmp(key, "rw") == 0 ||
strcmp(key, "sec") == 0)
return SA_OK;
return (SA_OK);
if (strcmp(key, "anon") == 0)
key = "anonuid";
@ -364,15 +364,15 @@ get_linux_shareopts_cb(const char *key, const char *value, void *cookie)
strcmp(key, "all_squash") != 0 &&
strcmp(key, "no_all_squash") != 0 && strcmp(key, "fsid") != 0 &&
strcmp(key, "anonuid") != 0 && strcmp(key, "anongid") != 0) {
return SA_SYNTAX_ERR;
return (SA_SYNTAX_ERR);
}
(void) add_linux_shareopt(plinux_opts, key, value);
return SA_OK;
return (SA_OK);
}
/**
/*
* Takes a string containing Solaris share options (e.g. "sync,no_acl") and
* converts them to a NULL-terminated array of Linux NFS options.
*/
@ -390,17 +390,18 @@ get_linux_shareopts(const char *shareopts, char **plinux_opts)
(void) add_linux_shareopt(plinux_opts, "no_root_squash", NULL);
(void) add_linux_shareopt(plinux_opts, "mountpoint", NULL);
rc = foreach_nfs_shareopt(shareopts, get_linux_shareopts_cb, plinux_opts);
rc = foreach_nfs_shareopt(shareopts, get_linux_shareopts_cb,
plinux_opts);
if (rc != SA_OK) {
free(*plinux_opts);
*plinux_opts = NULL;
}
return rc;
return (rc);
}
/**
/*
* Enables NFS sharing for the specified share.
*/
static int
@ -410,27 +411,27 @@ nfs_enable_share(sa_share_impl_t impl_share)
int rc;
if (!nfs_available()) {
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
}
shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
if (shareopts == NULL)
return SA_OK;
return (SA_OK);
rc = get_linux_shareopts(shareopts, &linux_opts);
if (rc != SA_OK)
return rc;
return (rc);
rc = foreach_nfs_host(impl_share, nfs_enable_share_one, linux_opts);
free(linux_opts);
return rc;
return (rc);
}
/**
/*
* Used internally by nfs_disable_share to disable sharing for a single host.
*/
static int
@ -471,12 +472,12 @@ nfs_disable_share_one(const char *sharepath, const char *host,
free(hostpath);
if (rc < 0)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
else
return SA_OK;
return (SA_OK);
}
/**
/*
* Disables NFS sharing for the specified share.
*/
static int
@ -487,13 +488,13 @@ nfs_disable_share(sa_share_impl_t impl_share)
* The share can't possibly be active, so nothing
* needs to be done to disable it.
*/
return SA_OK;
return (SA_OK);
}
return foreach_nfs_host(impl_share, nfs_disable_share_one, NULL);
return (foreach_nfs_host(impl_share, nfs_disable_share_one, NULL));
}
/**
/*
* Checks whether the specified NFS share options are syntactically correct.
*/
static int
@ -505,14 +506,14 @@ nfs_validate_shareopts(const char *shareopts)
rc = get_linux_shareopts(shareopts, &linux_opts);
if (rc != SA_OK)
return rc;
return (rc);
free(linux_opts);
return SA_OK;
return (SA_OK);
}
/**
/*
* Checks whether a share is currently active.
*/
static boolean_t
@ -523,14 +524,14 @@ nfs_is_share_active(sa_share_impl_t impl_share)
FILE *nfs_exportfs_temp_fp;
if (!nfs_available())
return B_FALSE;
return (B_FALSE);
nfs_exportfs_temp_fp = fdopen(dup(nfs_exportfs_temp_fd), "r");
if (nfs_exportfs_temp_fp == NULL ||
fseek(nfs_exportfs_temp_fp, 0, SEEK_SET) < 0) {
fclose(nfs_exportfs_temp_fp);
return B_FALSE;
return (B_FALSE);
}
while (fgets(line, sizeof (line), nfs_exportfs_temp_fp) != NULL) {
@ -564,16 +565,16 @@ nfs_is_share_active(sa_share_impl_t impl_share)
if (strcmp(line, impl_share->sharepath) == 0) {
fclose(nfs_exportfs_temp_fp);
return B_TRUE;
return (B_TRUE);
}
}
fclose(nfs_exportfs_temp_fp);
return B_FALSE;
return (B_FALSE);
}
/**
/*
* Called to update a share's options. A share's options might be out of
* date if the share was loaded from disk (i.e. /etc/dfs/sharetab) and the
* "sharenfs" dataset property has changed in the meantime. This function
@ -604,7 +605,7 @@ nfs_update_shareopts(sa_share_impl_t impl_share, const char *resource,
shareopts_dup = strdup(shareopts);
if (shareopts_dup == NULL)
return SA_NO_MEMORY;
return (SA_NO_MEMORY);
if (old_shareopts != NULL)
free(old_shareopts);
@ -614,10 +615,10 @@ nfs_update_shareopts(sa_share_impl_t impl_share, const char *resource,
if (needs_reshare)
nfs_enable_share(impl_share);
return SA_OK;
return (SA_OK);
}
/**
/*
* Clears a share's NFS options. Used by libshare to
* clean up shares that are about to be free()'d.
*/
@ -666,7 +667,7 @@ nfs_check_exportfs(void)
nfs_exportfs_temp_fd = mkstemp(nfs_exportfs_tempfile);
if (nfs_exportfs_temp_fd < 0)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
unlink(nfs_exportfs_tempfile);
@ -677,26 +678,25 @@ nfs_check_exportfs(void)
if (pid < 0) {
(void) close(nfs_exportfs_temp_fd);
nfs_exportfs_temp_fd = -1;
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
}
if (pid > 0) {
while ((rc = waitpid(pid, &status, 0)) <= 0 && errno == EINTR)
; /* empty loop body */
while ((rc = waitpid(pid, &status, 0)) <= 0 && errno == EINTR);
if (rc <= 0) {
(void) close(nfs_exportfs_temp_fd);
nfs_exportfs_temp_fd = -1;
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
(void) close(nfs_exportfs_temp_fd);
nfs_exportfs_temp_fd = -1;
return SA_CONFIG_ERR;
return (SA_CONFIG_ERR);
}
return SA_OK;
return (SA_OK);
}
/* child */
@ -724,10 +724,10 @@ nfs_available(void)
if (nfs_exportfs_temp_fd == -1)
(void) nfs_check_exportfs();
return (nfs_exportfs_temp_fd != -1) ? B_TRUE : B_FALSE;
return ((nfs_exportfs_temp_fd != -1) ? B_TRUE : B_FALSE);
}
/**
/*
* Initializes the NFS functionality of libshare.
*/
void

80
lib/libshare/smb.c
View File

@ -26,7 +26,7 @@
*
* This is an addition to the zfs device driver to add, modify and remove SMB
* shares using the 'net share' command that comes with Samba.
*
* TESTING
* Make sure that samba listens to 'localhost' (127.0.0.1) and that the options
* 'usershare max shares' and 'usershare owner only' have been rewied/set
@ -64,7 +64,7 @@ static boolean_t smb_available(void);
static sa_fstype_t *smb_fstype;
/**
/*
* Retrieve the list of SMB shares.
*/
static int
@ -83,7 +83,7 @@ smb_retrieve_shares(void)
/* opendir(), stat() */
shares_dir = opendir(SHARE_DIR);
if (shares_dir == NULL)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
/* Go through the directory, looking for shares */
while ((directory = readdir(shares_dir))) {
@ -163,7 +163,8 @@ smb_retrieve_shares(void)
strncpy(shares->comment, comment,
sizeof (shares->comment));
shares->comment[sizeof(shares->comment)-1]='\0';
shares->comment[sizeof (shares->comment)-1] =
'\0';
shares->guest_ok = atoi(guest_ok);
@ -190,10 +191,10 @@ out:
smb_shares = new_shares;
return rc;
return (rc);
}
/**
/*
* Used internally by smb_enable_share to enable sharing for a single host.
*/
static int
@ -220,8 +221,10 @@ smb_enable_share_one(const char *sharename, const char *sharepath)
++pos;
}
/* CMD: net -S NET_CMD_ARG_HOST usershare add Test1 /share/Test1 \
* "Comment" "Everyone:F" */
/*
* CMD: net -S NET_CMD_ARG_HOST usershare add Test1 /share/Test1 \
* "Comment" "Everyone:F"
*/
snprintf(comment, sizeof (comment), "Comment: %s", sharepath);
argv[0] = NET_CMD_PATH;
@ -237,15 +240,15 @@ smb_enable_share_one(const char *sharename, const char *sharepath)
rc = libzfs_run_process(argv[0], argv, 0);
if (rc < 0)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
/* Reload the share file */
(void) smb_retrieve_shares();
return SA_OK;
return (SA_OK);
}
/**
/*
* Enables SMB sharing for the specified share.
*/
static int
@ -254,20 +257,21 @@ smb_enable_share(sa_share_impl_t impl_share)
char *shareopts;
if (!smb_available())
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
shareopts = FSINFO(impl_share, smb_fstype)->shareopts;
if (shareopts == NULL) /* on/off */
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
if (strcmp(shareopts, "off") == 0)
return SA_OK;
return (SA_OK);
/* Magic: Enable (i.e., 'create new') share */
return smb_enable_share_one(impl_share->dataset, impl_share->sharepath);
return (smb_enable_share_one(impl_share->dataset,
impl_share->sharepath));
}
/**
/*
* Used internally by smb_disable_share to disable sharing for a single host.
*/
static int
@ -287,12 +291,12 @@ smb_disable_share_one(const char *sharename)
rc = libzfs_run_process(argv[0], argv, 0);
if (rc < 0)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
else
return SA_OK;
return (SA_OK);
}
/**
/*
* Disables SMB sharing for the specified share.
*/
static int
@ -305,20 +309,20 @@ smb_disable_share(sa_share_impl_t impl_share)
* The share can't possibly be active, so nothing
* needs to be done to disable it.
*/
return SA_OK;
return (SA_OK);
}
while (shares != NULL) {
if (strcmp(impl_share->sharepath, shares->path) == 0)
return smb_disable_share_one(shares->name);
return (smb_disable_share_one(shares->name));
shares = shares->next;
}
return SA_OK;
return (SA_OK);
}
/**
/*
* Checks whether the specified SMB share options are syntactically correct.
*/
static int
@ -326,34 +330,34 @@ smb_validate_shareopts(const char *shareopts)
{
/* TODO: Accept 'name' and sec/acl (?) */
if ((strcmp(shareopts, "off") == 0) || (strcmp(shareopts, "on") == 0))
return SA_OK;
return (SA_OK);
return SA_SYNTAX_ERR;
return (SA_SYNTAX_ERR);
}
/**
/*
* Checks whether a share is currently active.
*/
static boolean_t
smb_is_share_active(sa_share_impl_t impl_share)
{
if (!smb_available())
return B_FALSE;
return (B_FALSE);
/* Retrieve the list of (possible) active shares */
smb_retrieve_shares();
while (smb_shares != NULL) {
if (strcmp(impl_share->sharepath, smb_shares->path) == 0)
return B_TRUE;
return (B_TRUE);
smb_shares = smb_shares->next;
}
return B_FALSE;
return (B_FALSE);
}
/**
/*
* Called to update a share's options. A share's options might be out of
* date if the share was loaded from disk and the "sharesmb" dataset
* property has changed in the meantime. This function also takes care
@ -368,7 +372,7 @@ smb_update_shareopts(sa_share_impl_t impl_share, const char *resource,
char *old_shareopts;
if (!impl_share)
return SA_SYSTEM_ERR;
return (SA_SYSTEM_ERR);
FSINFO(impl_share, smb_fstype)->active =
smb_is_share_active(impl_share);
@ -384,7 +388,7 @@ smb_update_shareopts(sa_share_impl_t impl_share, const char *resource,
shareopts_dup = strdup(shareopts);
if (shareopts_dup == NULL)
return SA_NO_MEMORY;
return (SA_NO_MEMORY);
if (old_shareopts != NULL)
free(old_shareopts);
@ -394,10 +398,10 @@ smb_update_shareopts(sa_share_impl_t impl_share, const char *resource,
if (needs_reshare)
smb_enable_share(impl_share);
return SA_OK;
return (SA_OK);
}
/**
/*
* Clears a share's SMB options. Used by libshare to
* clean up shares that are about to be free()'d.
*/
@ -427,15 +431,15 @@ smb_available(void)
if (lstat(SHARE_DIR, &statbuf) != 0 ||
!S_ISDIR(statbuf.st_mode))
return B_FALSE;
return (B_FALSE);
if (access(NET_CMD_PATH, F_OK) != 0)
return B_FALSE;
return (B_FALSE);
return B_TRUE;
return (B_TRUE);
}
/**
/*
* Initializes the SMB functionality of libshare.
*/
void

103
lib/libspl/asm-generic/atomic.c
View File

@ -95,7 +95,8 @@ ATOMIC_ADD(int, uint_t, int)
ATOMIC_ADD(long, ulong_t, long)
ATOMIC_ADD(64, uint64_t, int64_t)
void atomic_add_ptr(volatile void *target, ssize_t bits)
void
atomic_add_ptr(volatile void *target, ssize_t bits)
{
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
*(caddr_t *)target += bits;
@ -120,7 +121,8 @@ ATOMIC_SUB(int, uint_t, int)
ATOMIC_SUB(long, ulong_t, long)
ATOMIC_SUB(64, uint64_t, int64_t)
void atomic_sub_ptr(volatile void *target, ssize_t bits)
void
atomic_sub_ptr(volatile void *target, ssize_t bits)
{
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0);
*(caddr_t *)target -= bits;
@ -175,7 +177,7 @@ ATOMIC_AND(64, uint64_t)
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0); \
rc = (++(*target)); \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return rc; \
return (rc); \
}
ATOMIC_INC_NV(long, unsigned long)
@ -196,7 +198,7 @@ ATOMIC_INC_NV(64, uint64_t)
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0); \
rc = (--(*target)); \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return rc; \
return (rc); \
}
ATOMIC_DEC_NV(long, unsigned long)
@ -217,7 +219,7 @@ ATOMIC_DEC_NV(64, uint64_t)
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0); \
rc = (*target += bits); \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return rc; \
return (rc); \
}
ATOMIC_ADD_NV(8, uint8_t, int8_t)
@ -229,7 +231,8 @@ ATOMIC_ADD_NV(int, uint_t, int)
ATOMIC_ADD_NV(long, ulong_t, long)
ATOMIC_ADD_NV(64, uint64_t, int64_t)
void *atomic_add_ptr_nv(volatile void *target, ssize_t bits)
void *
atomic_add_ptr_nv(volatile void *target, ssize_t bits)
{
void *ptr;
@ -237,7 +240,7 @@ void *atomic_add_ptr_nv(volatile void *target, ssize_t bits)
ptr = (*(caddr_t *)target += bits);
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return ptr;
return (ptr);
}
@ -248,7 +251,7 @@ void *atomic_add_ptr_nv(volatile void *target, ssize_t bits)
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0); \
rc = (*target -= bits); \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return rc; \
return (rc); \
}
ATOMIC_SUB_NV(8, uint8_t, int8_t)
@ -260,7 +263,8 @@ ATOMIC_SUB_NV(int, uint_t, int)
ATOMIC_SUB_NV(long, ulong_t, long)
ATOMIC_SUB_NV(64, uint64_t, int64_t)
void *atomic_sub_ptr_nv(volatile void *target, ssize_t bits)
void *
atomic_sub_ptr_nv(volatile void *target, ssize_t bits)
{
void *ptr;
@ -268,7 +272,7 @@ void *atomic_sub_ptr_nv(volatile void *target, ssize_t bits)
ptr = (*(caddr_t *)target -= bits);
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return ptr;
return (ptr);
}
@ -279,7 +283,7 @@ void *atomic_sub_ptr_nv(volatile void *target, ssize_t bits)
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0); \
rc = (*target |= bits); \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return rc; \
return (rc); \
}
ATOMIC_OR_NV(long, unsigned long)
@ -300,7 +304,7 @@ ATOMIC_OR_NV(64, uint64_t)
VERIFY3S(pthread_mutex_lock(&atomic_lock), ==, 0); \
rc = (*target &= bits); \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return rc; \
return (rc); \
}
ATOMIC_AND_NV(long, unsigned long)
@ -327,7 +331,7 @@ ATOMIC_AND_NV(64, uint64_t)
if (old == arg1) \
*target = arg2; \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return old; \
return (old); \
}
ATOMIC_CAS(8, uint8_t)
@ -339,7 +343,8 @@ ATOMIC_CAS(uint, uint_t)
ATOMIC_CAS(ulong, ulong_t)
ATOMIC_CAS(64, uint64_t)
void *atomic_cas_ptr(volatile void *target, void *arg1, void *arg2)
void *
atomic_cas_ptr(volatile void *target, void *arg1, void *arg2)
{
void *old;
@ -349,7 +354,7 @@ void *atomic_cas_ptr(volatile void *target, void *arg1, void *arg2)
*(void **)target = arg2;
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return old;
return (old);
}
@ -365,7 +370,7 @@ void *atomic_cas_ptr(volatile void *target, void *arg1, void *arg2)
old = *target; \
*target = bits; \
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0); \
return old; \
return (old); \
}
ATOMIC_SWAP(8, uint8_t)
@ -377,7 +382,8 @@ ATOMIC_SWAP(uint, uint_t)
ATOMIC_SWAP(ulong, ulong_t)
ATOMIC_SWAP(64, uint64_t)
void *atomic_swap_ptr(volatile void *target, void *bits)
void *
atomic_swap_ptr(volatile void *target, void *bits)
{
void *old;
@ -386,11 +392,12 @@ void *atomic_swap_ptr(volatile void *target, void *bits)
*(void **)target = bits;
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return old;
return (old);
}
int atomic_set_long_excl(volatile ulong_t *target, uint_t value)
int
atomic_set_long_excl(volatile ulong_t *target, uint_t value)
{
ulong_t bit;
@ -398,15 +405,16 @@ int atomic_set_long_excl(volatile ulong_t *target, uint_t value)
bit = (1UL << value);
if ((*target & bit) != 0) {
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return -1;
return (-1);
}
*target |= bit;
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return 0;
return (0);
}
int atomic_clear_long_excl(volatile ulong_t *target, uint_t value)
int
atomic_clear_long_excl(volatile ulong_t *target, uint_t value)
{
ulong_t bit;
@ -414,67 +422,78 @@ int atomic_clear_long_excl(volatile ulong_t *target, uint_t value)
bit = (1UL << value);
if ((*target & bit) != 0) {
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return -1;
return (-1);
}
*target &= ~bit;
VERIFY3S(pthread_mutex_unlock(&atomic_lock), ==, 0);
return 0;
return (0);
}
void membar_enter(void)
void
membar_enter(void)
{
/* XXX - Implement me */
}
void membar_exit(void)
void
membar_exit(void)
{
/* XXX - Implement me */
}
void membar_producer(void)
void
membar_producer(void)
{
/* XXX - Implement me */
}
void membar_consumer(void)
void
membar_consumer(void)
{
/* XXX - Implement me */
}
/* Legacy kernel interfaces; they will go away (eventually). */
uint8_t cas8(uint8_t *target, uint8_t arg1, uint8_t arg2)
uint8_t
cas8(uint8_t *target, uint8_t arg1, uint8_t arg2)
{
return atomic_cas_8(target, arg1, arg2);
return (atomic_cas_8(target, arg1, arg2));
}
uint32_t cas32(uint32_t *target, uint32_t arg1, uint32_t arg2)
uint32_t
cas32(uint32_t *target, uint32_t arg1, uint32_t arg2)
{
return atomic_cas_32(target, arg1, arg2);
return (atomic_cas_32(target, arg1, arg2));
}
uint64_t cas64(uint64_t *target, uint64_t arg1, uint64_t arg2)
uint64_t
cas64(uint64_t *target, uint64_t arg1, uint64_t arg2)
{
return atomic_cas_64(target, arg1, arg2);
return (atomic_cas_64(target, arg1, arg2));
}
ulong_t caslong(ulong_t *target, ulong_t arg1, ulong_t arg2)
ulong_t
caslong(ulong_t *target, ulong_t arg1, ulong_t arg2)
{
return atomic_cas_ulong(target, arg1, arg2);
return (atomic_cas_ulong(target, arg1, arg2));
}
void *casptr(void *target, void *arg1, void *arg2)
void *
casptr(void *target, void *arg1, void *arg2)
{
return atomic_cas_ptr(target, arg1, arg2);
return (atomic_cas_ptr(target, arg1, arg2));
}
void atomic_and_long(ulong_t *target, ulong_t bits)
void
atomic_and_long(ulong_t *target, ulong_t bits)
{
return atomic_and_ulong(target, bits);
return (atomic_and_ulong(target, bits));
}
void atomic_or_long(ulong_t *target, ulong_t bits)
void
atomic_or_long(ulong_t *target, ulong_t bits)
{
return atomic_or_ulong(target, bits);
return (atomic_or_ulong(target, bits));
}

5
lib/libspl/getexecname.c
View File

@ -41,7 +41,8 @@ getexecname(void)
pthread_mutex_lock(&mtx);
if (strlen(execname) == 0) {
rc = readlink("/proc/self/exe", execname, sizeof(execname) - 1);
rc = readlink("/proc/self/exe",
execname, sizeof (execname) - 1);
if (rc == -1) {
execname[0] = '\0';
} else {
@ -53,5 +54,5 @@ getexecname(void)
}
pthread_mutex_unlock(&mtx);
return ptr;
return (ptr);
}

2
lib/libspl/gethrtime.c
View File

@ -41,5 +41,5 @@ gethrtime(void)
abort();
}
return (((u_int64_t)ts.tv_sec) * NANOSEC) + ts.tv_nsec;
return ((((u_int64_t)ts.tv_sec) * NANOSEC) + ts.tv_nsec);
}

20
lib/libspl/getmntany.c
View File

@ -41,7 +41,8 @@
__thread char buf[BUFSIZE];
#define DIFF(xx) ((mrefp->xx != NULL) && \
#define DIFF(xx) ( \
(mrefp->xx != NULL) && \
(mgetp->xx == NULL || strcmp(mrefp->xx, mgetp->xx) != 0))
int
@ -49,11 +50,12 @@ getmntany(FILE *fp, struct mnttab *mgetp, struct mnttab *mrefp)
{
int ret;
while (((ret = _sol_getmntent(fp, mgetp)) == 0) &&
(DIFF(mnt_special) || DIFF(mnt_mountp) ||
while (
((ret = _sol_getmntent(fp, mgetp)) == 0) && (
DIFF(mnt_special) || DIFF(mnt_mountp) ||
DIFF(mnt_fstype) || DIFF(mnt_mntopts)));
return ret;
return (ret);
}
int
@ -69,13 +71,13 @@ _sol_getmntent(FILE *fp, struct mnttab *mgetp)
mgetp->mnt_mountp = mntbuf.mnt_dir;
mgetp->mnt_fstype = mntbuf.mnt_type;
mgetp->mnt_mntopts = mntbuf.mnt_opts;
return 0;
return (0);
}
if (feof(fp))
return -1;
return (-1);
return MNT_TOOLONG;
return (MNT_TOOLONG);
}
int
@ -89,11 +91,11 @@ getextmntent(FILE *fp, struct extmnttab *mp, int len)
if (stat64(mp->mnt_mountp, &st) != 0) {
mp->mnt_major = 0;
mp->mnt_minor = 0;
return ret;
return (ret);
}
mp->mnt_major = major(st.st_dev);
mp->mnt_minor = minor(st.st_dev);
}
return ret;
return (ret);
}

76
lib/libspl/include/devid.h
View File

@ -36,13 +36,73 @@ typedef struct devid_nmlist {
dev_t dev;
} devid_nmlist_t;
static inline int devid_str_decode(char *devidstr, ddi_devid_t *retdevid, char **retminor_name) { abort(); }
static inline int devid_deviceid_to_nmlist(char *search_path, ddi_devid_t devid, char *minor_name, devid_nmlist_t **retlist) { abort(); }
static inline void devid_str_free(char *str) { abort(); }
static inline void devid_free(ddi_devid_t devid) { abort(); }
static inline void devid_free_nmlist(devid_nmlist_t *list) { abort(); }
static inline int devid_get(int fd, ddi_devid_t *retdevid) { return -1; }
static inline int devid_get_minor_name(int fd, char **retminor_name) { abort(); }
static inline char *devid_str_encode(ddi_devid_t devid, char *minor_name) { abort(); }
static inline
int
devid_str_decode(
char *devidstr,
ddi_devid_t *retdevid,
char **retminor_name)
{
abort();
}
static inline
int
devid_deviceid_to_nmlist(
char *search_path,
ddi_devid_t devid,
char *minor_name,
devid_nmlist_t **retlist)
{
abort();
}
static inline
void
devid_str_free(char *str)
{
abort();
}
static inline
void
devid_free(ddi_devid_t devid)
{
abort();
}
static inline
void
devid_free_nmlist(devid_nmlist_t *list)
{
abort();
}
static inline
int
devid_get(
int fd,
ddi_devid_t *retdevid)
{
return (-1);
}
static inline
int
devid_get_minor_name(
int fd,
char **retminor_name)
{
abort();
}
static inline
char *
devid_str_encode(
ddi_devid_t devid,
char *minor_name)
{
abort();
}
#endif

2
lib/libspl/include/sys/mnttab.h
View File

@ -77,7 +77,7 @@ static inline char *_sol_hasmntopt(struct mnttab *mnt, char *opt)
mnt_new.mnt_opts = mnt->mnt_mntopts;
return hasmntopt(&mnt_new, opt);
return (hasmntopt(&mnt_new, opt));
}
#define hasmntopt _sol_hasmntopt

14
lib/libspl/include/sys/stack.h
View File

@ -39,7 +39,7 @@ stack_getbounds(stack_t *sp)
rc = pthread_getattr_np(pthread_self(), &attr);
if (rc)
return rc;
return (rc);
rc = pthread_attr_getstack(&attr, &sp->ss_sp, &sp->ss_size);
if (rc == 0)
@ -47,7 +47,7 @@ stack_getbounds(stack_t *sp)
pthread_attr_destroy(&attr);
return rc;
return (rc);
}
static inline int
@ -57,15 +57,17 @@ thr_stksegment(stack_t *sp)
rc = stack_getbounds(sp);
if (rc)
return rc;
return (rc);
/* thr_stksegment() is expected to set sp.ss_sp to the high stack
/*
* thr_stksegment() is expected to set sp.ss_sp to the high stack
* address, but the stack_getbounds() interface is expected to
* set sp.ss_sp to the low address. Adjust accordingly. */
* set sp.ss_sp to the low address. Adjust accordingly.
*/
sp->ss_sp = (void *)(((uintptr_t)sp->ss_sp) + sp->ss_size);
sp->ss_flags = 0;
return rc;
return (rc);
}
#endif /* __USE_GNU */

6
lib/libspl/include/sys/stat.h
View File

@ -37,14 +37,14 @@ static inline int
fstat64_blk(int fd, struct stat64 *st)
{
if (fstat64(fd, st) == -1)
return -1;
return (-1);
/* In Linux we need to use an ioctl to get the size of a block device */
if (S_ISBLK(st->st_mode)) {
if (ioctl(fd, BLKGETSIZE64, &st->st_size) != 0)
return -1;
return (-1);
}
return 0;
return (0);
}
#endif /* _LIBSPL_SYS_STAT_H */

21
lib/libspl/include/umem.h
View File

@ -27,7 +27,8 @@
#ifndef _LIBSPL_UMEM_H
#define _LIBSPL_UMEM_H
/* XXX: We should use the real portable umem library if it is detected
/*
* XXX: We should use the real portable umem library if it is detected
* at configure time. However, if the library is not available, we can
* use a trivial malloc based implementation. This obviously impacts
* performance, but unless you are using a full userspace build of zpool for
@ -87,7 +88,7 @@ umem_alloc(size_t size, int flags)
ptr = malloc(size);
} while (ptr == NULL && (flags & UMEM_NOFAIL));
return ptr;
return (ptr);
}
static inline void *
@ -105,10 +106,10 @@ umem_alloc_aligned(size_t size, size_t align, int flags)
__func__, align);
if (flags & UMEM_NOFAIL)
abort();
return NULL;
return (NULL);
}
return ptr;
return (ptr);
}
static inline void *
@ -120,7 +121,7 @@ umem_zalloc(size_t size, int flags)
if (ptr)
memset(ptr, 0, size);
return ptr;
return (ptr);
}
static inline void
@ -133,7 +134,8 @@ static inline void
umem_nofail_callback(umem_nofail_callback_t *cb) {}
static inline umem_cache_t *
umem_cache_create(char *name, size_t bufsize, size_t align,
umem_cache_create(
char *name, size_t bufsize, size_t align,
umem_constructor_t *constructor,
umem_destructor_t *destructor,
umem_reclaim_t *reclaim,
@ -154,7 +156,7 @@ umem_cache_create(char *name, size_t bufsize, size_t align,
cp->cache_cflags = cflags;
}
return cp;
return (cp);
}
static inline void
@ -169,14 +171,15 @@ umem_cache_alloc(umem_cache_t *cp, int flags)
void *ptr;
if (cp->cache_align != 0)
ptr = umem_alloc_aligned(cp->cache_bufsize, cp->cache_align, flags);
ptr = umem_alloc_aligned(
cp->cache_bufsize, cp->cache_align, flags);
else
ptr = umem_alloc(cp->cache_bufsize, flags);
if (ptr && cp->cache_constructor)
cp->cache_constructor(ptr, cp->cache_private, UMEM_DEFAULT);
return ptr;
return (ptr);
}
static inline void

6
lib/libspl/include/unistd.h
View File

@ -34,10 +34,10 @@
#include <sys/ioctl.h>
#elif defined(HAVE_IOCTL_IN_STROPTS_H)
#include <stropts.h>
# else
#else /* HAVE_IOCTL_IN_STROPTS_H */
#error "System call ioctl() unavailable"
# endif
#endif
#endif /* HAVE_IOCTL_IN_SYS_IOCTL_H */
#endif /* !HAVE_IOCTL_IN_UNISTD_H */
#if !defined(HAVE_ISSETUGID)
#include <sys/types.h>

23
lib/libspl/zone.c
View File

@ -27,34 +27,37 @@
#include <string.h>
#include <errno.h>
zoneid_t getzoneid()
zoneid_t
getzoneid()
{
return GLOBAL_ZONEID;
return (GLOBAL_ZONEID);
}
zoneid_t getzoneidbyname(const char *name)
zoneid_t
getzoneidbyname(const char *name)
{
if (name == NULL)
return GLOBAL_ZONEID;
return (GLOBAL_ZONEID);
if (strcmp(name, GLOBAL_ZONEID_NAME) == 0)
return GLOBAL_ZONEID;
return (GLOBAL_ZONEID);
return EINVAL;
return (EINVAL);
}
ssize_t getzonenamebyid(zoneid_t id, char *buf, size_t buflen)
ssize_t
getzonenamebyid(zoneid_t id, char *buf, size_t buflen)
{
if (id != GLOBAL_ZONEID)
return EINVAL;
return (EINVAL);
ssize_t ret = strlen(GLOBAL_ZONEID_NAME) + 1;
if (buf == NULL || buflen == 0)
return ret;
return (ret);
strncpy(buf, GLOBAL_ZONEID_NAME, buflen);
buf[buflen - 1] = '\0';
return ret;
return (ret);
}

3
lib/libzfs/libzfs_fru.c
View File

@ -461,9 +461,6 @@ libzfs_fru_clear(libzfs_handle_t *hdl, boolean_t final)
void
libzfs_fru_clear(libzfs_handle_t *hdl, boolean_t final)
{
return;
}
#endif /* HAVE_LIBTOPO */

4
lib/libzfs/libzfs_import.c
View File

@ -168,7 +168,7 @@ fix_paths(nvlist_t *nv, name_entry_t *names)
}
if ((strlen(path) == strlen(ne->ne_name)) &&
!strncmp(path, ne->ne_name, strlen(path))) {
strncmp(path, ne->ne_name, strlen(path)) == 0) {
best = ne;
break;
}
@ -997,7 +997,7 @@ err_blkid3:
err_blkid2:
blkid_put_cache(cache);
err_blkid1:
return err;
return (err);
}
#endif /* HAVE_LIBBLKID */

16
lib/libzfs/libzfs_mount.c
View File

@ -287,22 +287,22 @@ do_mount(const char *src, const char *mntpt, char *opts)
rc = libzfs_run_process(argv[0], argv, STDOUT_VERBOSE|STDERR_VERBOSE);
if (rc) {
if (rc & MOUNT_FILEIO)
return EIO;
return (EIO);
if (rc & MOUNT_USER)
return EINTR;
return (EINTR);
if (rc & MOUNT_SOFTWARE)
return EPIPE;
return (EPIPE);
if (rc & MOUNT_BUSY)
return EBUSY;
return (EBUSY);
if (rc & MOUNT_SYSERR)
return EAGAIN;
return (EAGAIN);
if (rc & MOUNT_USAGE)
return EINVAL;
return (EINVAL);
return ENXIO; /* Generic error */
return (ENXIO); /* Generic error */
}
return 0;
return (0);
}
static int

29
lib/libzfs/libzfs_pool.c
View File

@ -242,7 +242,7 @@ int
zpool_get_prop(zpool_handle_t *zhp, zpool_prop_t prop, char *buf, size_t len,
zprop_source_t *srctype)
{
return zpool_get_prop_literal(zhp, prop, buf, len, srctype, B_FALSE);
return (zpool_get_prop_literal(zhp, prop, buf, len, srctype, B_FALSE));
}
/*
@ -250,8 +250,8 @@ zpool_get_prop(zpool_handle_t *zhp, zpool_prop_t prop, char *buf, size_t len,
* a pre-allocated buffer.
*/
int
zpool_get_prop_literal(zpool_handle_t *zhp, zpool_prop_t prop, char *buf, size_t len,
zprop_source_t *srctype, boolean_t literal)
zpool_get_prop_literal(zpool_handle_t *zhp, zpool_prop_t prop, char *buf,
size_t len, zprop_source_t *srctype, boolean_t literal)
{
uint64_t intval;
const char *strval;
@ -1222,8 +1222,9 @@ zpool_create(libzfs_handle_t *hdl, const char *pool, nvlist_t *nvroot,
* part of an active md or lvm device.
*/
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"one or more vdevs refer to the same device, or one of\n"
"the devices is part of an active md or lvm device"));
"one or more vdevs refer to the same device, or "
"one of\nthe devices is part of an active md or "
"lvm device"));
return (zfs_error(hdl, EZFS_BADDEV, msg));
case EOVERFLOW:
@ -3460,7 +3461,7 @@ zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv,
*/
if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
&value) == 0 && value) {
return strip_partition(hdl, path);
return (strip_partition(hdl, path));
}
} else {
verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &path) == 0);
@ -3880,7 +3881,8 @@ zpool_obj_to_path(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
if (dsobj == 0) {
/* special case for the MOS */
(void) snprintf(pathname, len, "<metadata>:<0x%llx>", (longlong_t)obj);
(void) snprintf(pathname, len, "<metadata>:<0x%llx>",
(longlong_t)obj);
return;
}
@ -3912,7 +3914,8 @@ zpool_obj_to_path(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
dsname, zc.zc_value);
}
} else {
(void) snprintf(pathname, len, "%s:<0x%llx>", dsname, (longlong_t)obj);
(void) snprintf(pathname, len, "%s:<0x%llx>", dsname,
(longlong_t)obj);
}
free(mntpnt);
}
@ -4012,22 +4015,22 @@ zpool_label_disk_check(char *path)
int fd, err;
if ((fd = open(path, O_RDWR|O_DIRECT)) < 0)
return errno;
return (errno);
if ((err = efi_alloc_and_read(fd, &vtoc)) != 0) {
(void) close(fd);
return err;
return (err);
}
if (vtoc->efi_flags & EFI_GPT_PRIMARY_CORRUPT) {
efi_free(vtoc);
(void) close(fd);
return EIDRM;
return (EIDRM);
}
efi_free(vtoc);
(void) close(fd);
return 0;
return (0);
}
/*
@ -4167,5 +4170,5 @@ zpool_label_disk(libzfs_handle_t *hdl, zpool_handle_t *zhp, char *name)
return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
}
return 0;
return (0);
}

14
lib/libzfs/libzfs_util.c
View File

@ -652,12 +652,12 @@ libzfs_run_process(const char *path, char *argv[], int flags)
while ((rc = waitpid(pid, &status, 0)) == -1 &&
errno == EINTR);
if (rc < 0 || !WIFEXITED(status))
return -1;
return (-1);
return WEXITSTATUS(status);
return (WEXITSTATUS(status));
}
return -1;
return (-1);
}
int
@ -666,9 +666,9 @@ libzfs_load_module(const char *module)
char *argv[4] = {"/sbin/modprobe", "-q", (char *)module, (char *)0};
if (libzfs_module_loaded(module))
return 0;
return (0);
return libzfs_run_process("/sbin/modprobe", argv, 0);
return (libzfs_run_process("/sbin/modprobe", argv, 0));
}
libzfs_handle_t *
@ -914,7 +914,7 @@ zfs_strcmp_shortname(char *name, char *cmp_name, int wholedisk)
if (wholedisk)
path_len = zfs_append_partition(path_name, MAXPATHLEN);
if ((path_len == cmp_len) && !strcmp(path_name, cmp_name)) {
if ((path_len == cmp_len) && strcmp(path_name, cmp_name) == 0) {
error = 0;
break;
}
@ -957,7 +957,7 @@ zfs_strcmp_pathname(char *name, char *cmp, int wholedisk)
}
if (name[0] != '/')
return zfs_strcmp_shortname(name, cmp_name, wholedisk);
return (zfs_strcmp_shortname(name, cmp_name, wholedisk));
strncpy(path_name, name, MAXPATHLEN);
path_len = strlen(path_name);

6
lib/libzpool/kernel.c
View File

@ -117,7 +117,7 @@ zk_thread_current(void)
ASSERT3P(kt, !=, NULL);
return kt;
return (kt);
}
void *
@ -137,7 +137,7 @@ zk_thread_helper(void *arg)
/* Unreachable, thread must exit with thread_exit() */
abort();
return NULL;
return (NULL);
}
kthread_t *
@ -188,7 +188,7 @@ zk_thread_create(caddr_t stk, size_t stksize, thread_func_t func, void *arg,
VERIFY3S(pthread_attr_destroy(&attr), ==, 0);
return kt;
return (kt);
}
void

5
lib/libzpool/taskq.c
View File

@ -157,7 +157,7 @@ taskq_dispatch_delay(taskq_t *tq, task_func_t func, void *arg, uint_t tqflags,
int
taskq_empty_ent(taskq_ent_t *t)
{
return t->tqent_next == NULL;
return (t->tqent_next == NULL);
}
void
@ -287,7 +287,8 @@ taskq_create(const char *name, int nthreads, pri_t pri,
tq->tq_maxalloc = maxalloc;
tq->tq_task.tqent_next = &tq->tq_task;
tq->tq_task.tqent_prev = &tq->tq_task;
tq->tq_threadlist = kmem_alloc(nthreads*sizeof(kthread_t *), KM_SLEEP);
tq->tq_threadlist = kmem_alloc(nthreads * sizeof (kthread_t *),
KM_SLEEP);
if (flags & TASKQ_PREPOPULATE) {
mutex_enter(&tq->tq_lock);

34
module/zcommon/zfs_uio.c
View File

@ -70,19 +70,16 @@ uiomove(void *p, size_t n, enum uio_rw rw, struct uio *uio)
switch (uio->uio_segflg) {
case UIO_USERSPACE:
case UIO_USERISPACE:
/* p = kernel data pointer
* iov->iov_base = user data pointer */
/*
* p = kernel data pointer
* iov->iov_base = user data pointer
*/
if (rw == UIO_READ) {
if (copy_to_user(iov->iov_base, p, cnt))
return EFAULT;
/* error = xcopyout_nta(p, iov->iov_base, cnt,
* (uio->uio_extflg & UIO_COPY_CACHED)); */
return (EFAULT);
} else {
/* error = xcopyin_nta(iov->iov_base, p, cnt,
* (uio->uio_extflg & UIO_COPY_CACHED)); */
if (copy_from_user(p, iov->iov_base, cnt))
return EFAULT;
return (EFAULT);
}
break;
case UIO_SYSSPACE:
@ -194,21 +191,18 @@ uiocopy(void *p, size_t n, enum uio_rw rw, struct uio *uio, size_t *cbytes)
case UIO_USERSPACE:
case UIO_USERISPACE:
/* p = kernel data pointer
* iov->iov_base = user data pointer */
/*
* p = kernel data pointer
* iov->iov_base = user data pointer
*/
if (rw == UIO_READ) {
/* * UIO_READ = copy data from kernel to user * */
/* UIO_READ = copy data from kernel to user */
if (copy_to_user(iov->iov_base, p, cnt))
return EFAULT;
/* error = xcopyout_nta(p, iov->iov_base, cnt,
* (uio->uio_extflg & UIO_COPY_CACHED)); */
return (EFAULT);
} else {
/* * UIO_WRITE = copy data from user to kernel * */
/* error = xcopyin_nta(iov->iov_base, p, cnt,
* (uio->uio_extflg & UIO_COPY_CACHED)); */
/* UIO_WRITE = copy data from user to kernel */
if (copy_from_user(p, iov->iov_base, cnt))
return EFAULT;
return (EFAULT);
}
break;

15
module/zfs/arc.c
View File

@ -906,8 +906,10 @@ buf_fini(void)
int i;
#if defined(_KERNEL) && defined(HAVE_SPL)
/* Large allocations which do not require contiguous pages
* should be using vmem_free() in the linux kernel */
/*
* Large allocations which do not require contiguous pages
* should be using vmem_free() in the linux kernel\
*/
vmem_free(buf_hash_table.ht_table,
(buf_hash_table.ht_mask + 1) * sizeof (void *));
#else
@ -998,8 +1000,10 @@ buf_init(void)
retry:
buf_hash_table.ht_mask = hsize - 1;
#if defined(_KERNEL) && defined(HAVE_SPL)
/* Large allocations which do not require contiguous pages
* should be using vmem_alloc() in the linux kernel */
/*
* Large allocations which do not require contiguous pages
* should be using vmem_alloc() in the linux kernel
*/
buf_hash_table.ht_table =
vmem_zalloc(hsize * sizeof (void*), KM_SLEEP);
#else
@ -2412,7 +2416,8 @@ arc_adapt_thread(void)
}
/* reset the growth delay for every reclaim */
arc_grow_time = ddi_get_lbolt()+(zfs_arc_grow_retry * hz);
arc_grow_time = ddi_get_lbolt() +
(zfs_arc_grow_retry * hz);
arc_kmem_reap_now(last_reclaim, 0);
arc_warm = B_TRUE;

24
module/zfs/dbuf.c
View File

@ -305,8 +305,10 @@ dbuf_init(void)
retry:
h->hash_table_mask = hsize - 1;
#if defined(_KERNEL) && defined(HAVE_SPL)
/* Large allocations which do not require contiguous pages
* should be using vmem_alloc() in the linux kernel */
/*
* Large allocations which do not require contiguous pages
* should be using vmem_alloc() in the linux kernel
*/
h->hash_table = vmem_zalloc(hsize * sizeof (void *), KM_PUSHPAGE);
#else
h->hash_table = kmem_zalloc(hsize * sizeof (void *), KM_NOSLEEP);
@ -339,8 +341,10 @@ dbuf_fini(void)
for (i = 0; i < DBUF_MUTEXES; i++)
mutex_destroy(&h->hash_mutexes[i]);
#if defined(_KERNEL) && defined(HAVE_SPL)
/* Large allocations which do not require contiguous pages
* should be using vmem_free() in the linux kernel */
/*
* Large allocations which do not require contiguous pages
* should be using vmem_free() in the linux kernel
*/
vmem_free(h->hash_table, (h->hash_table_mask + 1) * sizeof (void *));
#else
kmem_free(h->hash_table, (h->hash_table_mask + 1) * sizeof (void *));
@ -1700,8 +1704,7 @@ dbuf_findbp(dnode_t *dn, int level, uint64_t blkid, int fail_sparse,
if (dh == NULL) {
err = dbuf_hold_impl(dn, level+1, blkid >> epbs,
fail_sparse, NULL, parentp);
}
else {
} else {
__dbuf_hold_impl_init(dh + 1, dn, dh->dh_level + 1,
blkid >> epbs, fail_sparse, NULL,
parentp, dh->dh_depth + 1);
@ -1956,7 +1959,8 @@ top:
dh->dh_fail_sparse, &dh->dh_parent,
&dh->dh_bp, dh);
if (dh->dh_fail_sparse) {
if (dh->dh_err == 0 && dh->dh_bp && BP_IS_HOLE(dh->dh_bp))
if (dh->dh_err == 0 &&
dh->dh_bp && BP_IS_HOLE(dh->dh_bp))
dh->dh_err = SET_ERROR(ENOENT);
if (dh->dh_err) {
if (dh->dh_parent)
@ -2359,7 +2363,8 @@ dbuf_check_blkptr(dnode_t *dn, dmu_buf_impl_t *db)
}
}
/* dbuf_sync_indirect() is called recursively from dbuf_sync_list() so it
/*
* dbuf_sync_indirect() is called recursively from dbuf_sync_list() so it
* is critical the we not allow the compiler to inline this function in to
* dbuf_sync_list() thereby drastically bloating the stack usage.
*/
@ -2409,7 +2414,8 @@ dbuf_sync_indirect(dbuf_dirty_record_t *dr, dmu_tx_t *tx)
zio_nowait(zio);
}
/* dbuf_sync_leaf() is called recursively from dbuf_sync_list() so it is
/*
* dbuf_sync_leaf() is called recursively from dbuf_sync_list() so it is
* critical the we not allow the compiler to inline this function in to
* dbuf_sync_list() thereby drastically bloating the stack usage.
*/

8
module/zfs/dbuf_stats.c
View File

@ -53,10 +53,10 @@ dbuf_stats_hash_table_headers(char *buf, size_t size)
"%-6s %-6s %-8s %-8s %-6s %-6s %-5s %-8s %-8s\n",
"dbuf", "arcbuf", "dnode", "pool", "objset", "object", "level",
"blkid", "offset", "dbsize", "meta", "state", "dbholds", "list",
"atype", "index", "flags", "count", "asize", "access", "mru", "gmru",
"mfu", "gmfu", "l2", "l2_dattr", "l2_asize", "l2_comp", "aholds",
"dtype", "btype", "data_bs", "meta_bs", "bsize",
"lvls", "dholds", "blocks", "dsize");
"atype", "index", "flags", "count", "asize", "access",
"mru", "gmru", "mfu", "gmfu", "l2", "l2_dattr", "l2_asize",
"l2_comp", "aholds", "dtype", "btype", "data_bs", "meta_bs",
"bsize", "lvls", "dholds", "blocks", "dsize");
buf[size] = '\0';
return (0);

2
module/zfs/ddt_zap.c
View File

@ -141,7 +141,7 @@ ddt_zap_walk(objset_t *os, uint64_t object, ddt_entry_t *dde, uint64_t *walk)
static int
ddt_zap_count(objset_t *os, uint64_t object, uint64_t *count)
{
return zap_count(os, object, count);
return (zap_count(os, object, count));
}
const ddt_ops_t ddt_zap_ops = {

11
module/zfs/dmu.c
View File

@ -400,7 +400,8 @@ dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
}
nblks = 1;
}
dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks, KM_PUSHPAGE | KM_NODEBUG);
dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks,
KM_PUSHPAGE | KM_NODEBUG);
zio = zio_root(dn->dn_objset->os_spa, NULL, NULL, ZIO_FLAG_CANFAIL);
blkid = dbuf_whichblock(dn, offset);
@ -1044,7 +1045,7 @@ dmu_req_copy(void *arg_buf, int size, int *offset, struct request *req)
bv->bv_len -= tocpy;
}
return 0;
return (0);
}
static void
@ -1067,13 +1068,13 @@ dmu_bio_clone(struct bio *bio, struct bio **bio_copy)
struct bio *bio_new;
if (bio == NULL)
return EINVAL;
return (EINVAL);
while (bio) {
bio_new = bio_clone(bio, GFP_NOIO);
if (bio_new == NULL) {
dmu_bio_put(bio_root);
return ENOMEM;
return (ENOMEM);
}
if (bio_last) {
@ -1089,7 +1090,7 @@ dmu_bio_clone(struct bio *bio, struct bio **bio_copy)
*bio_copy = bio_root;
return 0;
return (0);
}
int

2
module/zfs/dmu_objset.c
View File

@ -1485,7 +1485,7 @@ dmu_snapshot_list_next(objset_t *os, int namelen, char *name,
int
dmu_snapshot_lookup(objset_t *os, const char *name, uint64_t *value)
{
return dsl_dataset_snap_lookup(os->os_dsl_dataset, name, value);
return (dsl_dataset_snap_lookup(os->os_dsl_dataset, name, value));
}
int

4
module/zfs/dmu_zfetch.c
View File

@ -703,7 +703,8 @@ dmu_zfetch(zfetch_t *zf, uint64_t offset, uint64_t size, int prefetched)
if (cur_streams >= max_streams) {
return;
}
newstream = kmem_zalloc(sizeof (zstream_t), KM_PUSHPAGE);
newstream =
kmem_zalloc(sizeof (zstream_t), KM_PUSHPAGE);
}
newstream->zst_offset = zst.zst_offset;
@ -743,4 +744,3 @@ MODULE_PARM_DESC(zfetch_block_cap, "Max number of blocks to fetch at a time");
module_param(zfetch_array_rd_sz, ulong, 0644);
MODULE_PARM_DESC(zfetch_array_rd_sz, "Number of bytes in a array_read");
#endif

3
module/zfs/dsl_destroy.c
View File

@ -500,7 +500,8 @@ dsl_destroy_snapshots_nvl(nvlist_t *snaps, boolean_t defer,
return (0);
dsda.dsda_snaps = snaps;
VERIFY0(nvlist_alloc(&dsda.dsda_successful_snaps, NV_UNIQUE_NAME, KM_PUSHPAGE));
VERIFY0(nvlist_alloc(&dsda.dsda_successful_snaps,
NV_UNIQUE_NAME, KM_PUSHPAGE));
dsda.dsda_defer = defer;
dsda.dsda_errlist = errlist;

2
module/zfs/dsl_dir.c
View File

@ -48,8 +48,8 @@ static void
dsl_dir_evict(dmu_buf_t *db, void *arg)
{
dsl_dir_t *dd = arg;
ASSERTV(dsl_pool_t *dp = dd->dd_pool;)
int t;
ASSERTV(dsl_pool_t *dp = dd->dd_pool);
for (t = 0; t < TXG_SIZE; t++) {
ASSERT(!txg_list_member(&dp->dp_dirty_dirs, dd, t));

7
module/zfs/dsl_pool.c
View File

@ -1049,12 +1049,11 @@ dsl_pool_config_held(dsl_pool_t *dp)
EXPORT_SYMBOL(dsl_pool_config_enter);
EXPORT_SYMBOL(dsl_pool_config_exit);
/* zfs_dirty_data_max_percent only applied at module load time in arc_init(). */
/* zfs_dirty_data_max_percent only applied at module load in arc_init(). */
module_param(zfs_dirty_data_max_percent, int, 0444);
MODULE_PARM_DESC(zfs_dirty_data_max_percent, "percent of ram can be dirty");
/* zfs_dirty_data_max_max_percent only applied at module load time in
* arc_init(). */
/* zfs_dirty_data_max_max_percent only applied at module load in arc_init(). */
module_param(zfs_dirty_data_max_max_percent, int, 0444);
MODULE_PARM_DESC(zfs_dirty_data_max_max_percent,
"zfs_dirty_data_max upper bound as % of RAM");
@ -1065,7 +1064,7 @@ MODULE_PARM_DESC(zfs_delay_min_dirty_percent, "transaction delay threshold");
module_param(zfs_dirty_data_max, ulong, 0644);
MODULE_PARM_DESC(zfs_dirty_data_max, "determines the dirty space limit");
/* zfs_dirty_data_max_max only applied at module load time in arc_init(). */
/* zfs_dirty_data_max_max only applied at module load in arc_init(). */
module_param(zfs_dirty_data_max_max, ulong, 0444);
MODULE_PARM_DESC(zfs_dirty_data_max_max,
"zfs_dirty_data_max upper bound in bytes");

6
module/zfs/dsl_scan.c
View File

@ -201,9 +201,11 @@ dsl_scan_setup_sync(void *arg, dmu_tx_t *tx)
if (vdev_resilver_needed(spa->spa_root_vdev,
&scn->scn_phys.scn_min_txg, &scn->scn_phys.scn_max_txg)) {
spa_event_notify(spa, NULL, FM_EREPORT_ZFS_RESILVER_START);
spa_event_notify(spa, NULL,
FM_EREPORT_ZFS_RESILVER_START);
} else {
spa_event_notify(spa, NULL, FM_EREPORT_ZFS_SCRUB_START);
spa_event_notify(spa, NULL,
FM_EREPORT_ZFS_SCRUB_START);
}
spa->spa_scrub_started = B_TRUE;

17
module/zfs/fm.c
View File

@ -420,13 +420,13 @@ zfs_zevent_alloc(void)
ev = kmem_zalloc(sizeof (zevent_t), KM_PUSHPAGE);
if (ev == NULL)
return NULL;
return (NULL);
list_create(&ev->ev_ze_list, sizeof (zfs_zevent_t),
offsetof(zfs_zevent_t, ze_node));
list_link_init(&ev->ev_node);
return ev;
return (ev);
}
static void
@ -592,8 +592,10 @@ zfs_zevent_next(zfs_zevent_t *ze, nvlist_t **event, uint64_t *event_size,
goto out;
}
} else {
/* Existing stream continue with the next element and remove
* ourselves from the wait queue for the previous element */
/*
* Existing stream continue with the next element and remove
* ourselves from the wait queue for the previous element
*/
ev = list_prev(&zevent_list, ze->ze_zevent);
if (ev == NULL) {
error = ENOENT;
@ -619,7 +621,7 @@ zfs_zevent_next(zfs_zevent_t *ze, nvlist_t **event, uint64_t *event_size,
out:
mutex_exit(&zevent_lock);
return error;
return (error);
}
int
@ -643,7 +645,7 @@ zfs_zevent_wait(zfs_zevent_t *ze)
out:
mutex_exit(&zevent_lock);
return error;
return (error);
}
void
@ -1512,7 +1514,8 @@ fm_init(void)
}
mutex_init(&zevent_lock, NULL, MUTEX_DEFAULT, NULL);
list_create(&zevent_list, sizeof(zevent_t), offsetof(zevent_t, ev_node));
list_create(&zevent_list, sizeof (zevent_t),
offsetof(zevent_t, ev_node));
cv_init(&zevent_cv, NULL, CV_DEFAULT, NULL);
}

15
module/zfs/lz4.c
View File

@ -47,7 +47,8 @@ static kmem_cache_t *lz4_cache;
/*ARGSUSED*/
size_t
lz4_compress_zfs(void *s_start, void *d_start, size_t s_len, size_t d_len, int n)
lz4_compress_zfs(void *s_start, void *d_start, size_t s_len,
size_t d_len, int n)
{
uint32_t bufsiz;
char *dest = d_start;
@ -74,7 +75,8 @@ lz4_compress_zfs(void *s_start, void *d_start, size_t s_len, size_t d_len, int n
/*ARGSUSED*/
int
lz4_decompress_zfs(void *s_start, void *d_start, size_t s_len, size_t d_len, int n)
lz4_decompress_zfs(void *s_start, void *d_start, size_t s_len,
size_t d_len, int n)
{
const char *src = s_start;
uint32_t bufsiz = BE_IN32(src);
@ -143,16 +145,16 @@ lz4_decompress_zfs(void *s_start, void *d_start, size_t s_len, size_t d_len, int
* This function explicitly handles the CTX memory structure.
*
* ILLUMOS CHANGES: the CTX memory structure must be explicitly allocated
* by the caller (either on the stack or using kmem_cache_alloc). Passing NULL
* isn't valid.
* by the caller (either on the stack or using kmem_cache_alloc). Passing
* NULL isn't valid.
*
* LZ4_compress64kCtx() :
* Same as LZ4_compressCtx(), but specific to small inputs (<64KB).
* isize *Must* be <64KB, otherwise the output will be corrupted.
*
* ILLUMOS CHANGES: the CTX memory structure must be explicitly allocated
* by the caller (either on the stack or using kmem_cache_alloc). Passing NULL
* isn't valid.
* by the caller (either on the stack or using kmem_cache_alloc). Passing
* NULL isn't valid.
*/
/*
@ -1009,4 +1011,3 @@ lz4_fini(void)
lz4_cache = NULL;
}
}

3
module/zfs/lzjb.c
View File

@ -61,7 +61,8 @@ lzjb_compress(void *s_start, void *d_start, size_t s_len, size_t d_len, int n)
while (src < (uchar_t *)s_start + s_len) {
if ((copymask <<= 1) == (1 << NBBY)) {
if (dst >= (uchar_t *)d_start + d_len - 1 - 2 * NBBY) {
kmem_free(lempel, LEMPEL_SIZE*sizeof(uint16_t));
kmem_free(lempel,
LEMPEL_SIZE*sizeof (uint16_t));
return (s_len);
}
copymask = 1;

6
module/zfs/metaslab.c
View File

@ -2021,7 +2021,8 @@ metaslab_claim(spa_t *spa, const blkptr_t *bp, uint64_t txg)
return (error);
}
void metaslab_fastwrite_mark(spa_t *spa, const blkptr_t *bp)
void
metaslab_fastwrite_mark(spa_t *spa, const blkptr_t *bp)
{
const dva_t *dva = bp->blk_dva;
int ndvas = BP_GET_NDVAS(bp);
@ -2043,7 +2044,8 @@ void metaslab_fastwrite_mark(spa_t *spa, const blkptr_t *bp)
spa_config_exit(spa, SCL_VDEV, FTAG);
}
void metaslab_fastwrite_unmark(spa_t *spa, const blkptr_t *bp)
void
metaslab_fastwrite_unmark(spa_t *spa, const blkptr_t *bp)
{
const dva_t *dva = bp->blk_dva;
int ndvas = BP_GET_NDVAS(bp);

8
module/zfs/sa.c
View File

@ -251,7 +251,7 @@ sa_cache_fini(void)
void *
sa_spill_alloc(int flags)
{
return kmem_cache_alloc(spill_cache, flags);
return (kmem_cache_alloc(spill_cache, flags));
}
void
@ -607,7 +607,8 @@ sa_find_sizes(sa_os_t *sa, sa_bulk_attr_t *attr_desc, int attr_count,
}
if (is_var_sz && var_size > 1) {
/* Don't worry that the spill block might overflow.
/*
* Don't worry that the spill block might overflow.
* It will be resized if needed in sa_build_layouts().
*/
if (buftype == SA_SPILL ||
@ -1142,7 +1143,8 @@ sa_tear_down(objset_t *os)
sa_free_attr_table(sa);
cookie = NULL;
while ((layout = avl_destroy_nodes(&sa->sa_layout_hash_tree, &cookie))){
while ((layout =
avl_destroy_nodes(&sa->sa_layout_hash_tree, &cookie))) {
sa_idx_tab_t *tab;
while ((tab = list_head(&layout->lot_idx_tab))) {
ASSERT(refcount_count(&tab->sa_refcount));

15
module/zfs/spa.c
View File

@ -288,7 +288,7 @@ spa_prop_get(spa_t *spa, nvlist_t **nvp)
err = nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_PUSHPAGE);
if (err)
return err;
return (err);
mutex_enter(&spa->spa_props_lock);
@ -488,7 +488,8 @@ spa_prop_validate(spa_t *spa, nvlist_t *props)
break;
}
if ((error = dmu_objset_hold(strval,FTAG,&os)))
error = dmu_objset_hold(strval, FTAG, &os);
if (error)
break;
/* Must be ZPL and not gzip compressed. */
@ -2434,9 +2435,9 @@ spa_load_impl(spa_t *spa, uint64_t pool_guid, nvlist_t *config,
hostid != myhostid) {
nvlist_free(nvconfig);
cmn_err(CE_WARN, "pool '%s' could not be "
"loaded as it was last accessed by "
"another system (host: %s hostid: 0x%lx). "
"See: http://zfsonlinux.org/msg/ZFS-8000-EY",
"loaded as it was last accessed by another "
"system (host: %s hostid: 0x%lx). See: "
"http://zfsonlinux.org/msg/ZFS-8000-EY",
spa_name(spa), hostname,
(unsigned long)hostid);
return (SET_ERROR(EBADF));
@ -4098,7 +4099,9 @@ spa_tryimport(nvlist_t *tryconfig)
if (dsl_dsobj_to_dsname(spa_name(spa),
spa->spa_bootfs, tmpname) == 0) {
char *cp;
char *dsname = kmem_alloc(MAXPATHLEN, KM_PUSHPAGE);
char *dsname;
dsname = kmem_alloc(MAXPATHLEN, KM_PUSHPAGE);
cp = strchr(tmpname, '/');
if (cp == NULL) {

2
module/zfs/vdev_cache.c
View File

@ -256,8 +256,8 @@ vdev_cache_read(zio_t *zio)
vdev_cache_t *vc = &zio->io_vd->vdev_cache;
vdev_cache_entry_t *ve, *ve_search;
uint64_t cache_offset = P2ALIGN(zio->io_offset, VCBS);
ASSERTV(uint64_t cache_phase = P2PHASE(zio->io_offset, VCBS);)
zio_t *fio;
ASSERTV(uint64_t cache_phase = P2PHASE(zio->io_offset, VCBS));
ASSERT(zio->io_type == ZIO_TYPE_READ);

65
module/zfs/vdev_disk.c
View File

@ -65,7 +65,7 @@ vdev_bdev_mode(int smode)
if (smode & FWRITE)
mode |= FMODE_WRITE;
return mode;
return (mode);
}
#else
static int
@ -78,7 +78,7 @@ vdev_bdev_mode(int smode)
if ((smode & FREAD) && !(smode & FWRITE))
mode = MS_RDONLY;
return mode;
return (mode);
}
#endif /* HAVE_OPEN_BDEV_EXCLUSIVE */
@ -139,13 +139,14 @@ vdev_elevator_switch(vdev_t *v, char *elevator)
return (0);
/* Leave existing scheduler when set to "none" */
if (!strncmp(elevator, "none", 4) && (strlen(elevator) == 4))
if (strncmp(elevator, "none", 4) && (strlen(elevator) == 4) == 0)
return (0);
#ifdef HAVE_ELEVATOR_CHANGE
error = elevator_change(q, elevator);
#else
/* For pre-2.6.36 kernels elevator_change() is not available.
/*
* For pre-2.6.36 kernels elevator_change() is not available.
* Therefore we fall back to using a usermodehelper to echo the
* elevator into sysfs; This requires /bin/echo and sysfs to be
* mounted which may not be true early in the boot process.
@ -207,7 +208,7 @@ vdev_disk_rrpart(const char *path, int mode, vdev_disk_t *vd)
bdev = vdev_bdev_open(path, vdev_bdev_mode(mode), zfs_vdev_holder);
if (IS_ERR(bdev))
return bdev;
return (bdev);
disk = get_gendisk(bdev->bd_dev, &partno);
vdev_bdev_close(bdev, vdev_bdev_mode(mode));
@ -231,9 +232,9 @@ vdev_disk_rrpart(const char *path, int mode, vdev_disk_t *vd)
put_disk(disk);
}
return result;
return (result);
#else
return ERR_PTR(-EOPNOTSUPP);
return (ERR_PTR(-EOPNOTSUPP));
#endif /* defined(HAVE_3ARG_BLKDEV_GET) && defined(HAVE_GET_GENDISK) */
}
@ -248,7 +249,7 @@ vdev_disk_open(vdev_t *v, uint64_t *psize, uint64_t *max_psize,
/* Must have a pathname and it must be absolute. */
if (v->vdev_path == NULL || v->vdev_path[0] != '/') {
v->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
return EINVAL;
return (EINVAL);
}
/*
@ -263,7 +264,7 @@ vdev_disk_open(vdev_t *v, uint64_t *psize, uint64_t *max_psize,
vd = kmem_zalloc(sizeof (vdev_disk_t), KM_PUSHPAGE);
if (vd == NULL)
return ENOMEM;
return (ENOMEM);
/*
* Devices are always opened by the path provided at configuration
@ -287,7 +288,7 @@ vdev_disk_open(vdev_t *v, uint64_t *psize, uint64_t *max_psize,
vdev_bdev_mode(mode), zfs_vdev_holder);
if (IS_ERR(bdev)) {
kmem_free(vd, sizeof (vdev_disk_t));
return -PTR_ERR(bdev);
return (-PTR_ERR(bdev));
}
v->vdev_tsd = vd;
@ -312,7 +313,7 @@ skip_open:
/* Try to set the io scheduler elevator algorithm */
(void) vdev_elevator_switch(v, zfs_vdev_scheduler);
return 0;
return (0);
}
static void
@ -349,7 +350,7 @@ vdev_disk_dio_alloc(int bio_count)
dr->dr_bio[i] = NULL;
}
return dr;
return (dr);
}
static void
@ -417,7 +418,7 @@ vdev_disk_dio_put(dio_request_t *dr)
}
}
return rc;
return (rc);
}
BIO_END_IO_PROTO(vdev_disk_physio_completion, bio, size, error)
@ -436,11 +437,11 @@ BIO_END_IO_PROTO(vdev_disk_physio_completion, bio, size, error)
#ifndef HAVE_2ARGS_BIO_END_IO_T
if (bio->bi_size)
return 1;
return (1);
#endif /* HAVE_2ARGS_BIO_END_IO_T */
if (error == 0 && !test_bit(BIO_UPTODATE, &bio->bi_flags))
error = -EIO;
error = (-EIO);
if (dr->dr_error == 0)
dr->dr_error = -error;
@ -491,7 +492,7 @@ bio_map(struct bio *bio, void *bio_ptr, unsigned int bio_size)
offset = 0;
}
return bio_size;
return (bio_size);
}
static int
@ -509,7 +510,7 @@ __vdev_disk_physio(struct block_device *bdev, zio_t *zio, caddr_t kbuf_ptr,
retry:
dr = vdev_disk_dio_alloc(bio_count);
if (dr == NULL)
return ENOMEM;
return (ENOMEM);
if (zio && !(zio->io_flags & (ZIO_FLAG_IO_RETRY | ZIO_FLAG_TRYHARD)))
bio_set_flags_failfast(bdev, &flags);
@ -548,7 +549,7 @@ retry:
bio_nr_pages(bio_ptr, bio_size));
if (dr->dr_bio[i] == NULL) {
vdev_disk_dio_free(dr);
return ENOMEM;
return (ENOMEM);
}
/* Matching put called by vdev_disk_physio_completion */
@ -594,7 +595,7 @@ retry:
(void) vdev_disk_dio_put(dr);
return error;
return (error);
}
int
@ -602,7 +603,7 @@ vdev_disk_physio(struct block_device *bdev, caddr_t kbuf,
size_t size, uint64_t offset, int flags)
{
bio_set_flags_failfast(bdev, &flags);
return __vdev_disk_physio(bdev, NULL, kbuf, size, offset, flags);
return (__vdev_disk_physio(bdev, NULL, kbuf, size, offset, flags));
}
BIO_END_IO_PROTO(vdev_disk_io_flush_completion, bio, size, rc)
@ -631,11 +632,11 @@ vdev_disk_io_flush(struct block_device *bdev, zio_t *zio)
q = bdev_get_queue(bdev);
if (!q)
return ENXIO;
return (ENXIO);
bio = bio_alloc(GFP_NOIO, 0);
if (!bio)
return ENOMEM;
return (ENOMEM);
bio->bi_end_io = vdev_disk_io_flush_completion;
bio->bi_private = zio;
@ -643,7 +644,7 @@ vdev_disk_io_flush(struct block_device *bdev, zio_t *zio)
zio->io_delay = jiffies_64;
submit_bio(VDEV_WRITE_FLUSH_FUA, bio);
return 0;
return (0);
}
static int
@ -658,7 +659,7 @@ vdev_disk_io_start(zio_t *zio)
if (!vdev_readable(v)) {
zio->io_error = SET_ERROR(ENXIO);
return ZIO_PIPELINE_CONTINUE;
return (ZIO_PIPELINE_CONTINUE);
}
switch (zio->io_cmd) {
@ -674,7 +675,7 @@ vdev_disk_io_start(zio_t *zio)
error = vdev_disk_io_flush(vd->vd_bdev, zio);
if (error == 0)
return ZIO_PIPELINE_STOP;
return (ZIO_PIPELINE_STOP);
zio->io_error = error;
if (error == ENOTSUP)
@ -686,7 +687,7 @@ vdev_disk_io_start(zio_t *zio)
zio->io_error = SET_ERROR(ENOTSUP);
}
return ZIO_PIPELINE_CONTINUE;
return (ZIO_PIPELINE_CONTINUE);
case ZIO_TYPE_WRITE:
flags = WRITE;
@ -698,17 +699,17 @@ vdev_disk_io_start(zio_t *zio)
default:
zio->io_error = SET_ERROR(ENOTSUP);
return ZIO_PIPELINE_CONTINUE;
return (ZIO_PIPELINE_CONTINUE);
}
error = __vdev_disk_physio(vd->vd_bdev, zio, zio->io_data,
zio->io_size, zio->io_offset, flags);
if (error) {
zio->io_error = error;
return ZIO_PIPELINE_CONTINUE;
return (ZIO_PIPELINE_CONTINUE);
}
return ZIO_PIPELINE_STOP;
return (ZIO_PIPELINE_STOP);
}
static void
@ -787,12 +788,12 @@ vdev_disk_read_rootlabel(char *devpath, char *devid, nvlist_t **config)
bdev = vdev_bdev_open(devpath, vdev_bdev_mode(FREAD), zfs_vdev_holder);
if (IS_ERR(bdev))
return -PTR_ERR(bdev);
return (-PTR_ERR(bdev));
s = bdev_capacity(bdev);
if (s == 0) {
vdev_bdev_close(bdev, vdev_bdev_mode(FREAD));
return EIO;
return (EIO);
}
size = P2ALIGN_TYPED(s, sizeof (vdev_label_t), uint64_t);
@ -833,7 +834,7 @@ vdev_disk_read_rootlabel(char *devpath, char *devid, nvlist_t **config)
vmem_free(label, sizeof (vdev_label_t));
vdev_bdev_close(bdev, vdev_bdev_mode(FREAD));
return 0;
return (0);
}
module_param(zfs_vdev_scheduler, charp, 0644);

2
module/zfs/vdev_label.c
View File

@ -1116,7 +1116,7 @@ vdev_label_sync(zio_t *zio, vdev_t *vd, int l, uint64_t txg, int flags)
buf = vp->vp_nvlist;
buflen = sizeof (vp->vp_nvlist);
if (nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_PUSHPAGE) == 0) {
if (!nvlist_pack(label, &buf, &buflen, NV_ENCODE_XDR, KM_PUSHPAGE)) {
for (; l < VDEV_LABELS; l += 2) {
vdev_label_write(zio, vd, l, vp,
offsetof(vdev_label_t, vl_vdev_phys),

6
module/zfs/vdev_queue.c
View File

@ -500,8 +500,10 @@ vdev_queue_aggregate(vdev_queue_t *vq, zio_t *zio)
if (zio->io_flags & ZIO_FLAG_DONT_AGGREGATE)
return (NULL);
/* Prevent users from setting the zfs_vdev_aggregation_limit
* tuning larger than SPA_MAXBLOCKSIZE. */
/*
* Prevent users from setting the zfs_vdev_aggregation_limit
* tuning larger than SPA_MAXBLOCKSIZE.
*/
zfs_vdev_aggregation_limit =
MIN(zfs_vdev_aggregation_limit, SPA_MAXBLOCKSIZE);

3
module/zfs/zap_micro.c
View File

@ -938,7 +938,8 @@ mzap_addent(zap_name_t *zn, uint64_t value)
#ifdef ZFS_DEBUG
for (i = 0; i < zap->zap_m.zap_num_chunks; i++) {
ASSERTV(mzap_ent_phys_t *mze=&zap->zap_m.zap_phys->mz_chunk[i]);
ASSERTV(mzap_ent_phys_t *mze);
ASSERT(mze = &zap->zap_m.zap_phys->mz_chunk[i]);
ASSERT(strcmp(zn->zn_key_orig, mze->mze_name) != 0);
}
#endif

3
module/zfs/zfs_acl.c
View File

@ -1157,7 +1157,7 @@ zfs_acl_chown_setattr(znode_t *zp)
zfs_acl_t *aclp;
if (ZTOZSB(zp)->z_acl_type == ZFS_ACLTYPE_POSIXACL)
return 0;
return (0);
ASSERT(MUTEX_HELD(&zp->z_lock));
ASSERT(MUTEX_HELD(&zp->z_acl_lock));
@ -1165,6 +1165,7 @@ zfs_acl_chown_setattr(znode_t *zp)
if ((error = zfs_acl_node_read(zp, B_TRUE, &aclp, B_FALSE)) == 0)
zp->z_mode = zfs_mode_compute(zp->z_mode, aclp,
&zp->z_pflags, zp->z_uid, zp->z_gid);
return (error);
}

3
module/zfs/zfs_ctldir.c
View File

@ -100,7 +100,7 @@ static taskq_t *zfs_expire_taskq;
static zfs_snapentry_t *
zfsctl_sep_alloc(void)
{
return kmem_zalloc(sizeof (zfs_snapentry_t), KM_SLEEP);
return (kmem_zalloc(sizeof (zfs_snapentry_t), KM_SLEEP));
}
void
@ -255,7 +255,6 @@ zfsctl_inode_lookup(zfs_sb_t *zsb, uint64_t id,
void
zfsctl_inode_destroy(struct inode *ip)
{
return;
}
/*

1
module/zfs/zfs_debug.c
View File

@ -97,7 +97,6 @@ zfs_dbgmsg_fini(void)
mutex_destroy(&zfs_dbgmsgs_lock);
ASSERT0(zfs_dbgmsg_size);
#endif
return;
}
#if !defined(_KERNEL) || !defined(__linux__)

21
module/zfs/zfs_ioctl.c
View File

@ -567,7 +567,7 @@ out_check:
return (PRIV_POLICY(cr, needed_priv, B_FALSE, EPERM, NULL));
return (0);
#else
return ENOTSUP;
return (ENOTSUP);
#endif /* HAVE_MLSLABEL */
}
@ -4914,7 +4914,7 @@ zfs_ioc_events_clear(zfs_cmd_t *zc)
zfs_zevent_drain_all(&count);
zc->zc_cookie = count;
return 0;
return (0);
}
/*
@ -5427,14 +5427,17 @@ zfsdev_get_state_impl(minor_t minor, enum zfsdev_state_type which)
zs = list_next(&zfsdev_state_list, zs)) {
if (zs->zs_minor == minor) {
switch (which) {
case ZST_ONEXIT: return (zs->zs_onexit);
case ZST_ZEVENT: return (zs->zs_zevent);
case ZST_ALL: return (zs);
case ZST_ONEXIT:
return (zs->zs_onexit);
case ZST_ZEVENT:
return (zs->zs_zevent);
case ZST_ALL:
return (zs);
}
}
}
return NULL;
return (NULL);
}
void *
@ -5446,7 +5449,7 @@ zfsdev_get_state(minor_t minor, enum zfsdev_state_type which)
ptr = zfsdev_get_state_impl(minor, which);
mutex_exit(&zfsdev_state_lock);
return ptr;
return (ptr);
}
minor_t
@ -5523,7 +5526,7 @@ zfsdev_state_destroy(struct file *filp)
list_remove(&zfsdev_state_list, zs);
kmem_free(zs, sizeof (zfsdev_state_t));
return 0;
return (0);
}
static int
@ -5702,7 +5705,7 @@ out:
static long
zfsdev_compat_ioctl(struct file *filp, unsigned cmd, unsigned long arg)
{
return zfsdev_ioctl(filp, cmd, arg);
return (zfsdev_ioctl(filp, cmd, arg));
}
#else
#define zfsdev_compat_ioctl NULL

6
module/zfs/zfs_vfsops.c
View File

@ -1249,10 +1249,12 @@ zfs_domount(struct super_block *sb, void *data, int silent)
atime_changed_cb(zsb, B_FALSE);
readonly_changed_cb(zsb, B_TRUE);
if ((error = dsl_prop_get_integer(osname,"xattr",&pval,NULL)))
if ((error = dsl_prop_get_integer(osname,
"xattr", &pval, NULL)))
goto out;
xattr_changed_cb(zsb, pval);
if ((error = dsl_prop_get_integer(osname,"acltype",&pval,NULL)))
if ((error = dsl_prop_get_integer(osname,
"acltype", &pval, NULL)))
goto out;
acltype_changed_cb(zsb, pval);
zsb->z_issnap = B_TRUE;

6
module/zfs/zfs_vnops.c
View File

@ -2528,8 +2528,10 @@ zfs_setattr(struct inode *ip, vattr_t *vap, int flags, cred_t *cr)
* once large timestamps are fully supported.
*/
if (mask & (ATTR_ATIME | ATTR_MTIME)) {
if (((mask & ATTR_ATIME) && TIMESPEC_OVERFLOW(&vap->va_atime)) ||
((mask & ATTR_MTIME) && TIMESPEC_OVERFLOW(&vap->va_mtime))) {
if (((mask & ATTR_ATIME) &&
TIMESPEC_OVERFLOW(&vap->va_atime)) ||
((mask & ATTR_MTIME) &&
TIMESPEC_OVERFLOW(&vap->va_mtime))) {
err = EOVERFLOW;
goto out3;
}

2
module/zfs/zfs_znode.c
View File

@ -440,7 +440,7 @@ zfs_znode_alloc(zfs_sb_t *zsb, dmu_buf_t *db, int blksz,
error:
unlock_new_inode(ip);
iput(ip);
return NULL;
return (NULL);
}
/*

19
module/zfs/zil.c
View File

@ -1017,13 +1017,10 @@ zil_lwb_write_start(zilog_t *zilog, lwb_t *lwb)
use_slog = USE_SLOG(zilog);
error = zio_alloc_zil(spa, txg, bp, zil_blksz,
USE_SLOG(zilog));
if (use_slog)
{
if (use_slog) {
ZIL_STAT_BUMP(zil_itx_metaslab_slog_count);
ZIL_STAT_INCR(zil_itx_metaslab_slog_bytes, lwb->lwb_nused);
}
else
{
} else {
ZIL_STAT_BUMP(zil_itx_metaslab_normal_count);
ZIL_STAT_INCR(zil_itx_metaslab_normal_bytes, lwb->lwb_nused);
}
@ -1134,12 +1131,14 @@ zil_lwb_commit(zilog_t *zilog, itx_t *itx, lwb_t *lwb)
dbuf = lr_buf + reclen;
lrw->lr_common.lrc_reclen += dlen;
ZIL_STAT_BUMP(zil_itx_needcopy_count);
ZIL_STAT_INCR(zil_itx_needcopy_bytes, lrw->lr_length);
ZIL_STAT_INCR(zil_itx_needcopy_bytes,
lrw->lr_length);
} else {
ASSERT(itx->itx_wr_state == WR_INDIRECT);
dbuf = NULL;
ZIL_STAT_BUMP(zil_itx_indirect_count);
ZIL_STAT_INCR(zil_itx_indirect_bytes, lrw->lr_length);
ZIL_STAT_INCR(zil_itx_indirect_bytes,
lrw->lr_length);
}
error = zilog->zl_get_data(
itx->itx_private, lrw, dbuf, lwb->lwb_zio);
@ -1344,7 +1343,8 @@ zil_itx_assign(zilog_t *zilog, itx_t *itx, dmu_tx_t *tx)
}
ASSERT(itxg->itxg_sod == 0);
itxg->itxg_txg = txg;
itxs = itxg->itxg_itxs = kmem_zalloc(sizeof (itxs_t), KM_PUSHPAGE);
itxs = itxg->itxg_itxs = kmem_zalloc(sizeof (itxs_t),
KM_PUSHPAGE);
list_create(&itxs->i_sync_list, sizeof (itx_t),
offsetof(itx_t, itx_node));
@ -1364,7 +1364,8 @@ zil_itx_assign(zilog_t *zilog, itx_t *itx, dmu_tx_t *tx)
ian = avl_find(t, &foid, &where);
if (ian == NULL) {
ian = kmem_alloc(sizeof (itx_async_node_t), KM_PUSHPAGE);
ian = kmem_alloc(sizeof (itx_async_node_t),
KM_PUSHPAGE);
list_create(&ian->ia_list, sizeof (itx_t),
offsetof(itx_t, itx_node));
ian->ia_foid = foid;

21
module/zfs/zio.c
View File

@ -1852,11 +1852,11 @@ static void
zio_write_gang_member_ready(zio_t *zio)
{
zio_t *pio = zio_unique_parent(zio);
ASSERTV(zio_t *gio = zio->io_gang_leader;)
dva_t *cdva = zio->io_bp->blk_dva;
dva_t *pdva = pio->io_bp->blk_dva;
uint64_t asize;
int d;
ASSERTV(zio_t *gio = zio->io_gang_leader);
if (BP_IS_HOLE(zio->io_bp))
return;
@ -2995,15 +2995,18 @@ zio_done(zio_t *zio)
if (zio->io_bp != NULL) {
ASSERT(zio->io_bp->blk_pad[0] == 0);
ASSERT(zio->io_bp->blk_pad[1] == 0);
ASSERT(bcmp(zio->io_bp, &zio->io_bp_copy, sizeof (blkptr_t)) == 0 ||
ASSERT(bcmp(zio->io_bp, &zio->io_bp_copy,
sizeof (blkptr_t)) == 0 ||
(zio->io_bp == zio_unique_parent(zio)->io_bp));
if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(zio->io_bp) &&
zio->io_bp_override == NULL &&
!(zio->io_flags & ZIO_FLAG_IO_REPAIR)) {
ASSERT(!BP_SHOULD_BYTESWAP(zio->io_bp));
ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(zio->io_bp));
ASSERT3U(zio->io_prop.zp_copies, <=,
BP_GET_NDVAS(zio->io_bp));
ASSERT(BP_COUNT_GANG(zio->io_bp) == 0 ||
(BP_COUNT_GANG(zio->io_bp) == BP_GET_NDVAS(zio->io_bp)));
(BP_COUNT_GANG(zio->io_bp) ==
BP_GET_NDVAS(zio->io_bp)));
}
if (zio->io_flags & ZIO_FLAG_NOPWRITE)
VERIFY(BP_EQUAL(zio->io_bp, &zio->io_bp_orig));
@ -3078,8 +3081,8 @@ zio_done(zio_t *zio)
* error and generate a logical data ereport.
*/
spa_log_error(zio->io_spa, zio);
zfs_ereport_post(FM_EREPORT_ZFS_DATA, zio->io_spa, NULL, zio,
0, 0);
zfs_ereport_post(FM_EREPORT_ZFS_DATA, zio->io_spa,
NULL, zio, 0, 0);
}
}
@ -3355,13 +3358,13 @@ MODULE_PARM_DESC(zio_requeue_io_start_cut_in_line, "Prioritize requeued I/O");
module_param(zfs_sync_pass_deferred_free, int, 0644);
MODULE_PARM_DESC(zfs_sync_pass_deferred_free,
"defer frees starting in this pass");
"Defer frees starting in this pass");
module_param(zfs_sync_pass_dont_compress, int, 0644);
MODULE_PARM_DESC(zfs_sync_pass_dont_compress,
"don't compress starting in this pass");
"Don't compress starting in this pass");
module_param(zfs_sync_pass_rewrite, int, 0644);
MODULE_PARM_DESC(zfs_sync_pass_rewrite,
"rewrite new bps starting in this pass");
"Rewrite new bps starting in this pass");
#endif

22
module/zfs/zpl_ctldir.c
View File

@ -43,7 +43,7 @@ zpl_common_open(struct inode *ip, struct file *filp)
if (filp->f_mode & FMODE_WRITE)
return (-EACCES);
return generic_file_open(ip, filp);
return (generic_file_open(ip, filp));
}
/*
@ -129,12 +129,12 @@ zpl_root_lookup(struct inode *dip, struct dentry *dentry, unsigned int flags)
if (error) {
if (error == -ENOENT)
return d_splice_alias(NULL, dentry);
return (d_splice_alias(NULL, dentry));
else
return ERR_PTR(error);
return (ERR_PTR(error));
}
return d_splice_alias(ip, dentry);
return (d_splice_alias(ip, dentry));
}
/*
@ -174,7 +174,7 @@ zpl_snapdir_automount(struct path *path)
error = -zfsctl_mount_snapshot(path, 0);
dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
if (error)
return ERR_PTR(error);
return (ERR_PTR(error));
/*
* Rather than returning the new vfsmount for the snapshot we must
@ -198,7 +198,7 @@ zpl_snapdir_revalidate(struct dentry *dentry, struct nameidata *i)
zpl_snapdir_revalidate(struct dentry *dentry, unsigned int flags)
#endif
{
return 0;
return (0);
}
dentry_operations_t zpl_dops_snapdirs = {
@ -237,13 +237,13 @@ zpl_snapdir_lookup(struct inode *dip, struct dentry *dentry,
crfree(cr);
if (error && error != -ENOENT)
return ERR_PTR(error);
return (ERR_PTR(error));
ASSERT(error == 0 || ip == NULL);
d_clear_d_op(dentry);
d_set_d_op(dentry, &zpl_dops_snapdirs);
return d_splice_alias(ip, dentry);
return (d_splice_alias(ip, dentry));
}
static int
@ -423,12 +423,12 @@ zpl_shares_lookup(struct inode *dip, struct dentry *dentry,
if (error) {
if (error == -ENOENT)
return d_splice_alias(NULL, dentry);
return (d_splice_alias(NULL, dentry));
else
return ERR_PTR(error);
return (ERR_PTR(error));
}
return d_splice_alias(ip, dentry);
return (d_splice_alias(ip, dentry));
}
static int

16
module/zfs/zpl_export.c
View File

@ -45,7 +45,7 @@ zpl_encode_fh(struct dentry *dentry, __u32 *fh, int *max_len, int connectable)
len_bytes = *max_len * sizeof (__u32);
if (len_bytes < offsetof(fid_t, fid_data))
return 255;
return (255);
fid->fid_len = len_bytes - offsetof(fid_t, fid_data);
@ -76,7 +76,7 @@ zpl_dentry_obtain_alias(struct inode *ip)
}
#endif /* HAVE_D_OBTAIN_ALIAS */
return result;
return (result);
}
static struct dentry *
@ -92,16 +92,16 @@ zpl_fh_to_dentry(struct super_block *sb, struct fid *fh,
if (fh_type != FILEID_INO32_GEN ||
len_bytes < offsetof(fid_t, fid_data) ||
len_bytes < offsetof(fid_t, fid_data) + fid->fid_len)
return ERR_PTR(-EINVAL);
return (ERR_PTR(-EINVAL));
rc = zfs_vget(sb, &ip, fid);
if (rc != 0)
return ERR_PTR(-rc);
return (ERR_PTR(-rc));
ASSERT((ip != NULL) && !IS_ERR(ip));
return zpl_dentry_obtain_alias(ip);
return (zpl_dentry_obtain_alias(ip));
}
static struct dentry *
@ -117,9 +117,9 @@ zpl_get_parent(struct dentry *child)
ASSERT3S(error, <=, 0);
if (error)
return ERR_PTR(error);
return (ERR_PTR(error));
return zpl_dentry_obtain_alias(ip);
return (zpl_dentry_obtain_alias(ip));
}
#ifdef HAVE_COMMIT_METADATA
@ -134,7 +134,7 @@ zpl_commit_metadata(struct inode *inode)
crfree(cr);
ASSERT3S(error, <=, 0);
return error;
return (error);
}
#endif /* HAVE_COMMIT_METADATA */

6
module/zfs/zpl_file.c
View File

@ -280,7 +280,7 @@ zpl_llseek(struct file *filp, loff_t offset, int whence)
}
#endif /* SEEK_HOLE && SEEK_DATA */
return generic_file_llseek(filp, offset, whence);
return (generic_file_llseek(filp, offset, whence));
}
/*
@ -381,7 +381,7 @@ zpl_readpage(struct file *filp, struct page *pp)
}
unlock_page(pp);
return error;
return (error);
}
/*
@ -536,7 +536,7 @@ zpl_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
static long
zpl_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
return zpl_ioctl(filp, cmd, arg);
return (zpl_ioctl(filp, cmd, arg));
}
#endif /* CONFIG_COMPAT */

12
module/zfs/zpl_inode.c
View File

@ -42,7 +42,7 @@ zpl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
int error;
if (dlen(dentry) > ZFS_MAXNAMELEN)
return ERR_PTR(-ENAMETOOLONG);
return (ERR_PTR(-ENAMETOOLONG));
crhold(cr);
error = -zfs_lookup(dir, dname(dentry), &ip, 0, cr, NULL, NULL);
@ -58,12 +58,12 @@ zpl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
if (error) {
if (error == -ENOENT)
return d_splice_alias(NULL, dentry);
return (d_splice_alias(NULL, dentry));
else
return ERR_PTR(error);
return (ERR_PTR(error));
}
return d_splice_alias(ip, dentry);
return (d_splice_alias(ip, dentry));
}
void
@ -349,7 +349,7 @@ zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
int error;
if (ip->i_nlink >= ZFS_LINK_MAX)
return -EMLINK;
return (-EMLINK);
crhold(cr);
ip->i_ctime = CURRENT_TIME_SEC;
@ -402,7 +402,7 @@ zpl_truncate_range(struct inode* ip, loff_t start, loff_t end)
static long
zpl_fallocate(struct inode *ip, int mode, loff_t offset, loff_t len)
{
return zpl_fallocate_common(ip, mode, offset, len);
return (zpl_fallocate_common(ip, mode, offset, len));
}
#endif /* HAVE_INODE_FALLOCATE */

10
module/zfs/zpl_super.c
View File

@ -216,13 +216,13 @@ __zpl_show_options(struct seq_file *seq, zfs_sb_t *zsb)
static int
zpl_show_options(struct seq_file *seq, struct dentry *root)
{
return __zpl_show_options(seq, root->d_sb->s_fs_info);
return (__zpl_show_options(seq, root->d_sb->s_fs_info));
}
#else
static int
zpl_show_options(struct seq_file *seq, struct vfsmount *vfsp)
{
return __zpl_show_options(seq, vfsp->mnt_sb->s_fs_info);
return (__zpl_show_options(seq, vfsp->mnt_sb->s_fs_info));
}
#endif /* HAVE_SHOW_OPTIONS_WITH_DENTRY */
@ -244,7 +244,7 @@ zpl_mount(struct file_system_type *fs_type, int flags,
{
zpl_mount_data_t zmd = { osname, data };
return mount_nodev(fs_type, flags, &zmd, zpl_fill_super);
return (mount_nodev(fs_type, flags, &zmd, zpl_fill_super));
}
#else
static int
@ -253,7 +253,7 @@ zpl_get_sb(struct file_system_type *fs_type, int flags,
{
zpl_mount_data_t zmd = { osname, data };
return get_sb_nodev(fs_type, flags, &zmd, zpl_fill_super, mnt);
return (get_sb_nodev(fs_type, flags, &zmd, zpl_fill_super, mnt));
}
#endif /* HAVE_MOUNT_NODEV */
@ -287,8 +287,6 @@ zpl_prune_sb(struct super_block *sb, void *arg)
error = -zfs_sb_prune(sb, *(unsigned long *)arg, &objects);
ASSERT3S(error, <=, 0);
return;
}
void

49
module/zfs/zpl_xattr.c
View File

@ -94,11 +94,11 @@ typedef struct xattr_filldir {
static int
zpl_xattr_filldir(xattr_filldir_t *xf, const char *name, int name_len)
{
if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
if (strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) == 0)
if (!(ITOZSB(xf->inode)->z_flags & ZSB_XATTR))
return (0);
if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
if (strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) == 0)
if (!capable(CAP_SYS_ADMIN))
return (0);
@ -534,10 +534,10 @@ __zpl_xattr_user_get(struct inode *ip, const char *name,
int error;
if (strcmp(name, "") == 0)
return -EINVAL;
return (-EINVAL);
if (!(ITOZSB(ip)->z_flags & ZSB_XATTR))
return -EOPNOTSUPP;
return (-EOPNOTSUPP);
xattr_name = kmem_asprintf("%s%s", XATTR_USER_PREFIX, name);
error = zpl_xattr_get(ip, xattr_name, value, size);
@ -555,10 +555,10 @@ __zpl_xattr_user_set(struct inode *ip, const char *name,
int error;
if (strcmp(name, "") == 0)
return -EINVAL;
return (-EINVAL);
if (!(ITOZSB(ip)->z_flags & ZSB_XATTR))
return -EOPNOTSUPP;
return (-EOPNOTSUPP);
xattr_name = kmem_asprintf("%s%s", XATTR_USER_PREFIX, name);
error = zpl_xattr_set(ip, xattr_name, value, size, flags);
@ -582,10 +582,10 @@ __zpl_xattr_trusted_get(struct inode *ip, const char *name,
int error;
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
return (-EACCES);
if (strcmp(name, "") == 0)
return -EINVAL;
return (-EINVAL);
xattr_name = kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX, name);
error = zpl_xattr_get(ip, xattr_name, value, size);
@ -603,10 +603,10 @@ __zpl_xattr_trusted_set(struct inode *ip, const char *name,
int error;
if (!capable(CAP_SYS_ADMIN))
return -EACCES;
return (-EACCES);
if (strcmp(name, "") == 0)
return -EINVAL;
return (-EINVAL);
xattr_name = kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX, name);
error = zpl_xattr_set(ip, xattr_name, value, size, flags);
@ -630,7 +630,7 @@ __zpl_xattr_security_get(struct inode *ip, const char *name,
int error;
if (strcmp(name, "") == 0)
return -EINVAL;
return (-EINVAL);
xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name);
error = zpl_xattr_get(ip, xattr_name, value, size);
@ -648,7 +648,7 @@ __zpl_xattr_security_set(struct inode *ip, const char *name,
int error;
if (strcmp(name, "") == 0)
return -EINVAL;
return (-EINVAL);
xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name);
error = zpl_xattr_set(ip, xattr_name, value, size, flags);
@ -699,7 +699,8 @@ zpl_xattr_security_init(struct inode *ip, struct inode *dip,
&name, &value, &len);
if (error) {
if (error == -EOPNOTSUPP)
return 0;
return (0);
return (error);
}
@ -816,7 +817,7 @@ zpl_get_acl(struct inode *ip, int type)
name = POSIX_ACL_XATTR_DEFAULT;
break;
default:
return ERR_PTR(-EINVAL);
return (ERR_PTR(-EINVAL));
}
size = zpl_xattr_get(ip, name, NULL, 0);
@ -866,25 +867,25 @@ __zpl_check_acl(struct inode *ip, int mask)
int
zpl_check_acl(struct inode *ip, int mask, unsigned int flags)
{
return __zpl_check_acl(ip, mask);
return (__zpl_check_acl(ip, mask));
}
#elif defined(HAVE_CHECK_ACL)
int
zpl_check_acl(struct inode *ip, int mask)
{
return __zpl_check_acl(ip , mask);
return (__zpl_check_acl(ip, mask));
}
#elif defined(HAVE_PERMISSION_WITH_NAMEIDATA)
int
zpl_permission(struct inode *ip, int mask, struct nameidata *nd)
{
return generic_permission(ip, mask, __zpl_check_acl);
return (generic_permission(ip, mask, __zpl_check_acl));
}
#elif defined(HAVE_PERMISSION)
int
zpl_permission(struct inode *ip, int mask)
{
return generic_permission(ip, mask, __zpl_check_acl);
return (generic_permission(ip, mask, __zpl_check_acl));
}
#endif /* HAVE_CHECK_ACL | HAVE_PERMISSION */
#endif /* !HAVE_GET_ACL */
@ -1060,7 +1061,7 @@ zpl_xattr_acl_get_access(struct dentry *dentry, const char *name,
void *buffer, size_t size, int type)
{
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
return zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type);
return (zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type));
}
static int
@ -1068,7 +1069,7 @@ zpl_xattr_acl_get_default(struct dentry *dentry, const char *name,
void *buffer, size_t size, int type)
{
ASSERT3S(type, ==, ACL_TYPE_DEFAULT);
return zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type);
return (zpl_xattr_acl_get(dentry->d_inode, name, buffer, size, type));
}
#else
@ -1077,14 +1078,14 @@ static int
zpl_xattr_acl_get_access(struct inode *ip, const char *name,
void *buffer, size_t size)
{
return zpl_xattr_acl_get(ip, name, buffer, size, ACL_TYPE_ACCESS);
return (zpl_xattr_acl_get(ip, name, buffer, size, ACL_TYPE_ACCESS));
}
static int
zpl_xattr_acl_get_default(struct inode *ip, const char *name,
void *buffer, size_t size)
{
return zpl_xattr_acl_get(ip, name, buffer, size, ACL_TYPE_DEFAULT);
return (zpl_xattr_acl_get(ip, name, buffer, size, ACL_TYPE_DEFAULT));
}
#endif /* HAVE_DENTRY_XATTR_GET */
@ -1131,8 +1132,8 @@ zpl_xattr_acl_set_access(struct dentry *dentry, const char *name,
const void *value, size_t size, int flags, int type)
{
ASSERT3S(type, ==, ACL_TYPE_ACCESS);
return zpl_xattr_acl_set(dentry->d_inode,
name, value, size, flags, type);
return (zpl_xattr_acl_set(dentry->d_inode,
name, value, size, flags, type));
}
static int

190
module/zpios/pios.c
View File

@ -1,4 +1,4 @@
/*****************************************************************************\
/*
* ZPIOS is a heavily modified version of the original PIOS test code.
* It is designed to have the test code running in the Linux kernel
* against ZFS while still being flexibly controled from user space.
@ -29,7 +29,7 @@
*
* You should have received a copy of the GNU General Public License along
* with ZPIOS. If not, see <http://www.gnu.org/licenses/>.
\*****************************************************************************/
*/
#include <sys/zfs_context.h>
#include <sys/dmu.h>
@ -43,10 +43,11 @@ static spl_class *zpios_class;
static spl_device *zpios_device;
static char *zpios_tag = "zpios_tag";
static
int zpios_upcall(char *path, char *phase, run_args_t *run_args, int rc)
static int
zpios_upcall(char *path, char *phase, run_args_t *run_args, int rc)
{
/* This is stack heavy but it should be OK since we are only
/*
* This is stack heavy but it should be OK since we are only
* making the upcall between tests when the stack is shallow.
*/
char id[16], chunk_size[16], region_size[16], thread_count[16];
@ -55,7 +56,7 @@ int zpios_upcall(char *path, char *phase, run_args_t *run_args, int rc)
char *argv[16], *envp[4];
if ((path == NULL) || (strlen(path) == 0))
return -ENOENT;
return (-ENOENT);
snprintf(id, 15, "%d", run_args->id);
snprintf(chunk_size, 15, "%lu", (long unsigned)run_args->chunk_size);
@ -93,7 +94,36 @@ int zpios_upcall(char *path, char *phase, run_args_t *run_args, int rc)
envp[2] = "PATH=/sbin:/usr/sbin:/bin:/usr/bin";
envp[3] = NULL;
return call_usermodehelper(path, argv, envp, UMH_WAIT_PROC);
return (call_usermodehelper(path, argv, envp, UMH_WAIT_PROC));
}
static int
zpios_print(struct file *file, const char *format, ...)
{
zpios_info_t *info = (zpios_info_t *)file->private_data;
va_list adx;
int rc;
ASSERT(info);
ASSERT(info->info_buffer);
va_start(adx, format);
spin_lock(&info->info_lock);
/* Don't allow the kernel to start a write in the red zone */
if ((int)(info->info_head - info->info_buffer) >
(info->info_size - ZPIOS_INFO_BUFFER_REDZONE)) {
rc = -EOVERFLOW;
} else {
rc = vsprintf(info->info_head, format, adx);
if (rc >= 0)
info->info_head += rc;
}
spin_unlock(&info->info_lock);
va_end(adx);
return (rc);
}
static uint64_t
@ -110,22 +140,21 @@ zpios_dmu_object_create(run_args_t *run_args, objset_t *os)
zpios_print(run_args->file,
"dmu_tx_assign() failed: %d\n", rc);
dmu_tx_abort(tx);
return obj;
return (obj);
}
obj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0,
DMU_OT_NONE, 0, tx);
obj = dmu_object_alloc(os, DMU_OT_UINT64_OTHER, 0, DMU_OT_NONE, 0, tx);
rc = dmu_object_set_blocksize(os, obj, 128ULL << 10, 0, tx);
if (rc) {
zpios_print(run_args->file,
"dmu_object_set_blocksize() failed: %d\n", rc);
dmu_tx_abort(tx);
return obj;
return (obj);
}
dmu_tx_commit(tx);
return obj;
return (obj);
}
static int
@ -141,7 +170,7 @@ zpios_dmu_object_free(run_args_t *run_args, objset_t *os, uint64_t obj)
zpios_print(run_args->file,
"dmu_tx_assign() failed: %d\n", rc);
dmu_tx_abort(tx);
return rc;
return (rc);
}
rc = dmu_object_free(os, obj, tx);
@ -149,12 +178,12 @@ zpios_dmu_object_free(run_args_t *run_args, objset_t *os, uint64_t obj)
zpios_print(run_args->file,
"dmu_object_free() failed: %d\n", rc);
dmu_tx_abort(tx);
return rc;
return (rc);
}
dmu_tx_commit(tx);
return 0;
return (0);
}
static int
@ -235,7 +264,7 @@ out:
t->delta = zpios_timespec_sub(t->stop, t->start);
(void) zpios_upcall(run_args->post, PHASE_POST_CREATE, run_args, rc);
return rc;
return (rc);
}
static int
@ -250,7 +279,7 @@ zpios_setup_run(run_args_t **run_args, zpios_cmd_t *kcmd, struct file *file)
if (ra == NULL) {
zpios_print(file, "Unable to vmem_zalloc() %d bytes "
"for regions\n", size);
return -ENOMEM;
return (-ENOMEM);
}
*run_args = ra;
@ -287,7 +316,7 @@ zpios_setup_run(run_args_t **run_args, zpios_cmd_t *kcmd, struct file *file)
*run_args = NULL;
}
return rc;
return (rc);
}
static int
@ -302,7 +331,8 @@ zpios_get_work_item(run_args_t *run_args, dmu_obj_t *obj, __u64 *offset,
mutex_enter(&run_args->lock_work);
i = run_args->region_next;
/* XXX: I don't much care for this chunk selection mechansim
/*
* XXX: I don't much care for this chunk selection mechansim
* there's the potential to burn a lot of time here doing nothing
* useful while holding the global lock. This could give some
* misleading performance results. I'll fix it latter.
@ -341,19 +371,20 @@ zpios_get_work_item(run_args_t *run_args, dmu_obj_t *obj, __u64 *offset,
/* update ctl structure */
if (run_args->region_noise) {
get_random_bytes(&random_int, sizeof (unsigned int));
run_args->region_next += random_int % run_args->region_noise;
run_args->region_next +=
random_int % run_args->region_noise;
} else {
run_args->region_next++;
}
mutex_exit(&run_args->lock_work);
return 1;
return (1);
}
/* nothing left to do */
mutex_exit(&run_args->lock_work);
return 0;
return (0);
}
static void
@ -374,21 +405,19 @@ zpios_remove_objset(run_args_t *run_args)
for (i = 0; i < run_args->region_count; i++) {
region = &run_args->regions[i];
rc = zpios_dmu_object_free(run_args,
region->obj.os,
region->obj.obj);
region->obj.os, region->obj.obj);
if (rc)
zpios_print(run_args->file, "Error "
"removing object %d, %d\n",
zpios_print(run_args->file,
"Error removing object %d, %d\n",
(int)region->obj.obj, rc);
}
} else {
region = &run_args->regions[0];
rc = zpios_dmu_object_free(run_args,
region->obj.os,
region->obj.obj);
region->obj.os, region->obj.obj);
if (rc)
zpios_print(run_args->file, "Error "
"removing object %d, %d\n",
zpios_print(run_args->file,
"Error removing object %d, %d\n",
(int)region->obj.obj, rc);
}
}
@ -463,7 +492,7 @@ zpios_dmu_write(run_args_t *run_args, objset_t *os, uint64_t object,
zpios_print(run_args->file,
"Error in dmu_tx_assign(), %d", rc);
dmu_tx_abort(tx);
return rc;
return (rc);
}
break;
}
@ -474,7 +503,7 @@ zpios_dmu_write(run_args_t *run_args, objset_t *os, uint64_t object,
dmu_write(os, object, offset, size, buf, tx);
dmu_tx_commit(tx);
return 0;
return (0);
}
static int
@ -489,7 +518,7 @@ zpios_dmu_read(run_args_t *run_args, objset_t *os, uint64_t object,
if (run_args->flags & DMU_READ_NOPF)
flags |= DMU_READ_NO_PREFETCH;
return dmu_read(os, object, offset, size, buf, flags);
return (dmu_read(os, object, offset, size, buf, flags));
}
static int
@ -515,7 +544,8 @@ zpios_thread_main(void *data)
chunk_noise_tmp = (random_int % (chunk_noise * 2))-chunk_noise;
}
/* It's OK to vmem_alloc() this memory because it will be copied
/*
* It's OK to vmem_alloc() this memory because it will be copied
* in to the slab and pointers to the slab copy will be setup in
* the bio when the IO is submitted. This of course is not ideal
* since we want a zero-copy IO path if possible. It would be nice
@ -671,7 +701,7 @@ out:
vmem_free(buf, chunk_size);
do_exit(0);
return rc; /* Unreachable, due to do_exit() */
return (rc); /* Unreachable, due to do_exit() */
}
static int
@ -806,7 +836,7 @@ cleanup:
kmem_free(tsks, sizeof (struct task_struct *) * tc);
cleanup2:
/* Returns first encountered thread error (if any) */
return rc;
return (rc);
taskerr:
/* Destroy all threads that were created successfully */
@ -829,14 +859,14 @@ zpios_do_one_run(struct file *file, zpios_cmd_t *kcmd,
(!kcmd->cmd_thread_count) || (!kcmd->cmd_region_count)) {
zpios_print(file, "Invalid chunk_size, region_size, "
"thread_count, or region_count, %d\n", -EINVAL);
return -EINVAL;
return (-EINVAL);
}
if (!(kcmd->cmd_flags & DMU_WRITE) ||
!(kcmd->cmd_flags & DMU_READ)) {
zpios_print(file, "Invalid flags, minimally DMU_WRITE "
"and DMU_READ must be set, %d\n", -EINVAL);
return -EINVAL;
return (-EINVAL);
}
if ((kcmd->cmd_flags & (DMU_WRITE_ZC | DMU_READ_ZC)) &&
@ -844,10 +874,11 @@ zpios_do_one_run(struct file *file, zpios_cmd_t *kcmd,
zpios_print(file, "Invalid flags, DMU_*_ZC incompatible "
"with DMU_VERIFY, used for performance analysis "
"only, %d\n", -EINVAL);
return -EINVAL;
return (-EINVAL);
}
/* Opaque data on return contains structs of the following form:
/*
* Opaque data on return contains structs of the following form:
*
* zpios_stat_t stats[];
* stats[0] = run_args->stats;
@ -862,12 +893,12 @@ zpios_do_one_run(struct file *file, zpios_cmd_t *kcmd,
if (data_size < size) {
zpios_print(file, "Invalid size, command data buffer "
"size too small, (%d < %d)\n", data_size, size);
return -ENOSPC;
return (-ENOSPC);
}
rc = zpios_setup_run(&run_args, kcmd, file);
if (rc)
return rc;
return (rc);
rc = zpios_threads_run(run_args);
zpios_remove_objset(run_args);
@ -891,7 +922,7 @@ cleanup:
(void) zpios_upcall(kcmd->cmd_post, PHASE_POST_RUN, run_args, 0);
return rc;
return (rc);
}
static int
@ -901,24 +932,25 @@ zpios_open(struct inode *inode, struct file *file)
zpios_info_t *info;
if (minor >= ZPIOS_MINORS)
return -ENXIO;
return (-ENXIO);
info = (zpios_info_t *)kmem_alloc(sizeof (*info), KM_SLEEP);
if (info == NULL)
return -ENOMEM;
return (-ENOMEM);
spin_lock_init(&info->info_lock);
info->info_size = ZPIOS_INFO_BUFFER_SIZE;
info->info_buffer = (char *)vmem_alloc(ZPIOS_INFO_BUFFER_SIZE,KM_SLEEP);
info->info_buffer =
(char *) vmem_alloc(ZPIOS_INFO_BUFFER_SIZE, KM_SLEEP);
if (info->info_buffer == NULL) {
kmem_free(info, sizeof (*info));
return -ENOMEM;
return (-ENOMEM);
}
info->info_head = info->info_buffer;
file->private_data = (void *)info;
return 0;
return (0);
}
static int
@ -928,7 +960,7 @@ zpios_release(struct inode *inode, struct file *file)
zpios_info_t *info = (zpios_info_t *)file->private_data;
if (minor >= ZPIOS_MINORS)
return -ENXIO;
return (-ENXIO);
ASSERT(info);
ASSERT(info->info_buffer);
@ -936,7 +968,7 @@ zpios_release(struct inode *inode, struct file *file)
vmem_free(info->info_buffer, ZPIOS_INFO_BUFFER_SIZE);
kmem_free(info, sizeof (*info));
return 0;
return (0);
}
static int
@ -952,7 +984,7 @@ zpios_buffer_clear(struct file *file, zpios_cfg_t *kcfg, unsigned long arg)
info->info_head = info->info_buffer;
spin_unlock(&info->info_lock);
return 0;
return (0);
}
static int
@ -987,12 +1019,13 @@ zpios_buffer_size(struct file *file, zpios_cfg_t *kcfg, unsigned long arg)
kcfg->cfg_rc1 = info->info_size;
if (copy_to_user((struct zpios_cfg_t __user *)arg, kcfg, sizeof(*kcfg)))
if (copy_to_user((struct zpios_cfg_t __user *)arg,
kcfg, sizeof (*kcfg)))
rc = -EFAULT;
out:
spin_unlock(&info->info_lock);
return rc;
return (rc);
}
static int
@ -1002,23 +1035,25 @@ zpios_ioctl_cfg(struct file *file, unsigned long arg)
int rc = 0;
if (copy_from_user(&kcfg, (zpios_cfg_t *)arg, sizeof (kcfg)))
return -EFAULT;
return (-EFAULT);
if (kcfg.cfg_magic != ZPIOS_CFG_MAGIC) {
zpios_print(file, "Bad config magic 0x%x != 0x%x\n",
kcfg.cfg_magic, ZPIOS_CFG_MAGIC);
return -EINVAL;
return (-EINVAL);
}
switch (kcfg.cfg_cmd) {
case ZPIOS_CFG_BUFFER_CLEAR:
/* cfg_arg1 - Unused
/*
* cfg_arg1 - Unused
* cfg_rc1 - Unused
*/
rc = zpios_buffer_clear(file, &kcfg, arg);
break;
case ZPIOS_CFG_BUFFER_SIZE:
/* cfg_arg1 - 0 - query size; >0 resize
/*
* cfg_arg1 - 0 - query size; >0 resize
* cfg_rc1 - Set to current buffer size
*/
rc = zpios_buffer_size(file, &kcfg, arg);
@ -1030,7 +1065,7 @@ zpios_ioctl_cfg(struct file *file, unsigned long arg)
break;
}
return rc;
return (rc);
}
static int
@ -1044,7 +1079,7 @@ zpios_ioctl_cmd(struct file *file, unsigned long arg)
if (kcmd == NULL) {
zpios_print(file, "Unable to kmem_alloc() %ld byte for "
"zpios_cmd_t\n", (long int)sizeof (zpios_cmd_t));
return -ENOMEM;
return (-ENOMEM);
}
rc = copy_from_user(kcmd, (zpios_cfg_t *)arg, sizeof (zpios_cmd_t));
@ -1057,7 +1092,7 @@ zpios_ioctl_cmd(struct file *file, unsigned long arg)
if (kcmd->cmd_magic != ZPIOS_CMD_MAGIC) {
zpios_print(file, "Bad command magic 0x%x != 0x%x\n",
kcmd->cmd_magic, ZPIOS_CFG_MAGIC);
rc = -EINVAL;
rc = (-EINVAL);
goto out_cmd;
}
@ -1102,7 +1137,7 @@ out_data:
out_cmd:
kmem_free(kcmd, sizeof (zpios_cmd_t));
return rc;
return (rc);
}
static long
@ -1113,10 +1148,10 @@ zpios_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
/* Ignore tty ioctls */
if ((cmd & 0xffffff00) == ((int)'T') << 8)
return -ENOTTY;
return (-ENOTTY);
if (minor >= ZPIOS_MINORS)
return -ENXIO;
return (-ENXIO);
switch (cmd) {
case ZPIOS_CFG:
@ -1131,7 +1166,7 @@ zpios_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
break;
}
return rc;
return (rc);
}
#ifdef CONFIG_COMPAT
@ -1139,11 +1174,12 @@ zpios_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
static long
zpios_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
return zpios_unlocked_ioctl(file, cmd, arg);
return (zpios_unlocked_ioctl(file, cmd, arg));
}
#endif /* CONFIG_COMPAT */
/* I'm not sure why you would want to write in to this buffer from
/*
* I'm not sure why you would want to write in to this buffer from
* user space since its principle use is to pass test status info
* back to the user space, but I don't see any reason to prevent it.
*/
@ -1156,7 +1192,7 @@ zpios_write(struct file *file, const char __user *buf,
int rc = 0;
if (minor >= ZPIOS_MINORS)
return -ENXIO;
return (-ENXIO);
ASSERT(info);
ASSERT(info->info_buffer);
@ -1182,19 +1218,18 @@ zpios_write(struct file *file, const char __user *buf,
rc = count;
out:
spin_unlock(&info->info_lock);
return rc;
return (rc);
}
static ssize_t
zpios_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
zpios_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
unsigned int minor = iminor(file->f_dentry->d_inode);
zpios_info_t *info = (zpios_info_t *)file->private_data;
int rc = 0;
if (minor >= ZPIOS_MINORS)
return -ENXIO;
return (-ENXIO);
ASSERT(info);
ASSERT(info->info_buffer);
@ -1218,7 +1253,7 @@ zpios_read(struct file *file, char __user *buf,
rc = count;
out:
spin_unlock(&info->info_lock);
return rc;
return (rc);
}
static loff_t zpios_seek(struct file *file, loff_t offset, int origin)
@ -1228,7 +1263,7 @@ static loff_t zpios_seek(struct file *file, loff_t offset, int origin)
int rc = -EINVAL;
if (minor >= ZPIOS_MINORS)
return -ENXIO;
return (-ENXIO);
ASSERT(info);
ASSERT(info->info_buffer);
@ -1254,7 +1289,7 @@ static loff_t zpios_seek(struct file *file, loff_t offset, int origin)
spin_unlock(&info->info_lock);
return rc;
return (rc);
}
static struct cdev zpios_cdev;
@ -1304,10 +1339,11 @@ zpios_init(void)
zpios_device = spl_device_create(zpios_class, NULL,
dev, NULL, ZPIOS_NAME);
return 0;
return (0);
error:
printk(KERN_ERR "ZPIOS: Error registering zpios device, %d\n", rc);
return rc;
return (rc);
}
static int
@ -1320,7 +1356,7 @@ zpios_fini(void)
cdev_del(&zpios_cdev);
unregister_chrdev_region(dev, ZPIOS_MINORS);
return 0;
return (0);
}
spl_module_init(zpios_init);