}
/* converts libfdisk FDISK_ASKTYPE_MENU to cfdisk menu and returns user's
- * responseback to libfdisk
+ * response back to libfdisk
*/
static int ask_menu(struct fdisk_ask *ask, struct cfdisk *cf)
{
/*
* This is fdisk frontend for GPT specific libfdisk functions that
- * are not expported by generic libfdisk API.
+ * are not exported by generic libfdisk API.
*/
static int gpt_menu_cb(struct fdisk_context **cxt0,
const struct menu *menu __attribute__((__unused__)),
/*
* This is fdisk frontend for MBR specific libfdisk functions that
- * are not expported by generic libfdisk API.
+ * are not exported by generic libfdisk API.
*/
static int dos_menu_cb(struct fdisk_context **cxt0,
const struct menu *menu __attribute__((__unused__)),
/*
* This is fdisk frontend for BSD specific libfdisk functions that
- * are not expported by generic libfdisk API.
+ * are not exported by generic libfdisk API.
*/
static int bsd_menu_cb(struct fdisk_context **cxt0,
const struct menu *menu __attribute__((__unused__)),
fputs(_(" -L, --color[=<when>] colorize output (auto, always or never)\n"), out);
fprintf(out,
" %s\n", USAGE_COLORS_DEFAULT);
- fputs(_(" -l, --list display partitions end exit\n"), out);
+ fputs(_(" -l, --list display partitions and exit\n"), out);
fputs(_(" -o, --output <list> output columns\n"), out);
fputs(_(" -t, --type <type> recognize specified partition table type only\n"), out);
fputs(_(" -u, --units[=<unit>] display units: 'cylinders' or 'sectors' (default)\n"), out);
};
/*
- * Internal structure for mount tabel entries.
+ * Internal structure for mount table entries.
*/
struct fsck_fs_data
{
errno = 0;
/*
- * Let's follow libmount defauls if $FSTAB_FILE is not specified
+ * Let's follow libmount defaults if $FSTAB_FILE is not specified
*/
path = getenv("FSTAB_FILE");
/*
* This is for the bone-headed user who enters the root
- * filesystem twice. Skip root will skep all root entries.
+ * filesystem twice. Skip root will skip all root entries.
*/
if (skip_root) {
mnt_reset_iter(itr, MNT_ITER_FORWARD);
*/
/*
- * 09.11.91 - made the first rudimetary functions
+ * 09.11.91 - made the first rudimentary functions
*
* 10.11.91 - updated, does checking, no repairs yet.
* Sent out to the mailing-list for testing.
*
*
* 19.04.92 - Had to start over again from this old version, as a
- * kernel bug ate my enhanced fsck in february.
+ * kernel bug ate my enhanced fsck in February.
*
* 28.02.93 - added support for different directory entry sizes..
*
#define ROOT_INO 1
#define YESNO_LENGTH 64
-/* Global variables used in minix_programs.h inline fuctions */
+/* Global variables used in minix_programs.h inline functions */
int fs_version = 1;
char *super_block_buffer;
/*
* Old version would die on largish filesystems. Change to mmap the
- * files one by one instaed of all simultaneously. - aeb, 2002-11-01
+ * files one by one instead of all simultaneously. - aeb, 2002-11-01
*/
#include <sys/types.h>
#define DEFAULT_FS_VERSION 1
/*
- * Global variables used in minix_programs.h inline fuctions
+ * Global variables used in minix_programs.h inline functions
*/
int fs_version = DEFAULT_FS_VERSION;
char *super_block_buffer;
/*
* Perform a test of a block; return the number of
- * blocks readable/writeable.
+ * blocks readable/writable.
*/
static size_t do_check(const struct fs_control *ctl, char * buffer, int try, unsigned int current_block) {
ssize_t got;
case '1':
fs_version = 1;
break;
- case 'v': /* kept for backwards compatiblitly */
+ case 'v': /* kept for backwards compatibility */
warnx(_("-v is ambiguous, use '-2' instead"));
/* fallthrough */
case '2':
warnx(_("Label was truncated."));
}
- /* report resuls */
+ /* report results */
if (ctl->uuid || ctl->opt_label) {
if (ctl->opt_label)
printf("LABEL=%s, ", ctl->hdr->volume_name);
struct fdisk_partition *orig_pa; /* -N <partno> before the change */
unsigned int verify : 1, /* call fdisk_verify_disklabel() */
- quiet : 1, /* suppres extra messages */
+ quiet : 1, /* suppress extra messages */
interactive : 1, /* running on tty */
noreread : 1, /* don't check device is in use */
force : 1, /* do also stupid things */
if (sf->backup)
backup_partition_table(sf, devname);
- /* delate all */
+ /* delete all */
if (argc == 1) {
size_t nparts = fdisk_get_npartitions(sf->cxt);
for (i = 0; i < nparts; i++) {
if (sf->backup)
backup_partition_table(sf, devname);
- if (fdisk_reorder_partitions(sf->cxt) == 1) /* unchnaged */
+ if (fdisk_reorder_partitions(sf->cxt) == 1) /* unchanged */
rc = fdisk_deassign_device(sf->cxt, 1);
else
rc = write_changes(sf);
fputs(_(" -J, --json <dev> dump partition table in JSON format\n"), out);
fputs(_(" -g, --show-geometry [<dev> ...] list geometry of all or specified devices\n"), out);
fputs(_(" -l, --list [<dev> ...] list partitions of each device\n"), out);
- fputs(_(" -F, --list-free [<dev> ...] list unpartitions free areas of each device\n"), out);
+ fputs(_(" -F, --list-free [<dev> ...] list unpartitioned free areas of each device\n"), out);
fputs(_(" -r, --reorder <dev> fix partitions order (by start offset)\n"), out);
fputs(_(" -s, --show-size [<dev> ...] list sizes of all or specified devices\n"), out);
fputs(_(" -T, --list-types print the recognized types (see -X)\n"), out);
fputs(_(" -o, --output <list> output columns\n"), out);
fputs(_(" -q, --quiet suppress extra info messages\n"), out);
fputs(_(" -w, --wipe <mode> wipe signatures (auto, always or never)\n"), out);
- fputs(_(" -W, --wipe-partitons <mode> wipe signatures from new partitions (auto, always or never)\n"), out);
+ fputs(_(" -W, --wipe-partitions <mode> wipe signatures from new partitions (auto, always or never)\n"), out);
fputs(_(" -X, --label <name> specify label type (dos, gpt, ...)\n"), out);
fputs(_(" -Y, --label-nested <name> specify nested label type (dos, bsd)\n"), out);
fputs(USAGE_SEPARATOR, out);
#define UL_COLOR_WHITE "\033[1;37m"
-/* maximal lenght of human readable name of ESC seq. */
+/* maximal length of human readable name of ESC seq. */
#define UL_COLORNAME_MAXSZ 32
extern const char *color_sequence_from_colorname(const char *str);
#define cpuset_nbits(setsize) (8 * (setsize))
/*
- * The @idx parametr returns an index of the first mask from @ary array where
+ * The @idx parameter returns an index of the first mask from @ary array where
* the @cpu is set.
*
* Returns: 0 if found, otherwise 1.
* subsystem names (e.g. "LIBMOUNT_DEBUG=options,tab"). In this case is
* necessary to define mask names array. This functionality is optional.
*
- * It's stringly recommended to use UL_* macros to define/declare/use
+ * It's strongly recommended to use UL_* macros to define/declare/use
* the debug stuff.
*
* See disk-utils/cfdisk.c: cfdisk_init_debug() for programs debug
/*
- * plymouth-ctrl.h Header file for communcations with plymouthd
+ * plymouth-ctrl.h Header file for communications with plymouthd
*
* Copyright (c) 2016 SUSE Linux GmbH, All rights reserved.
* Copyright (c) 2016 Werner Fink <werner@suse.de>
#endif
/*
- * Unfortunately, Linux kernel hedeader file <linux/magic.h> is incomplete
+ * Unfortunately, Linux kernel header file <linux/magic.h> is incomplete
* mess and kernel returns by statfs f_type many numbers that are nowhere
* specified (in API).
*
*
* Linux kernel linux/drivers/base/core.c: device_get_devnode()
* defines a replacement of '!' in the /sys device name by '/' in the
- * /dev device name. This helper replaces all ocurrences of '!' in
+ * /dev device name. This helper replaces all occurrences of '!' in
* @name by '/' to convert from /sys to /dev.
*/
static inline void sysfs_devname_sys_to_dev(char *name)
if (ioctl(fd, BLKALIGNOFF, &aligned) < 0)
return 0; /* probably kernel < 2.6.32 */
/*
- * Note that kernel returns -1 as alignement offset if no compatible
+ * Note that kernel returns -1 as alignment offset if no compatible
* sizes and alignments exist for stacked devices
*/
return aligned != 0 ? 1 : 0;
}
/*
- * This function does not cannonicalize the path! It just prepends CWD before a
+ * This function does not canonicalize the path! It just prepends CWD before a
* relative path. If the path is no relative than returns NULL. The path does
* not have to exist.
*/
&tk_term, &tk_termsz, &type) != 0)
continue;
- /* count teoretical score before we check names to avoid
+ /* count theoretical score before we check names to avoid
* unnecessary strcmp() */
if (tk_name)
score += 20;
*out++ = '#'; /* Hash mark */
break;
case '?':
- *out++ = '?'; /* Qestion mark */
+ *out++ = '?'; /* Question mark */
break;
default:
*out++ = *in;
* order from highest-order term to lowest-order term. UARTs transmit
* characters in order from LSB to MSB. By storing the CRC this way,
* we hand it to the UART in the order low-byte to high-byte; the UART
- * sends each low-bit to hight-bit; and the result is transmission bit
+ * sends each low-bit to high-bit; and the result is transmission bit
* by bit from highest- to lowest-order term without requiring any bit
* shuffling on our part. Reception works similarly.
*
/*
* This is callback solution for systems without nl_langinfo(), this function
- * returns hardcoded and on locale setting independed value.
+ * returns hardcoded and on locale setting indepndent value.
*
* See langinfo.h man page for more details.
*
*
* Notes:
* - kernels < 3.2 support partitioned loop devices and PT scanning
- * only if max_part= module paremeter is non-zero
+ * only if max_part= module parameter is non-zero
*
* - kernels >= 3.2 always support partitioned loop devices
*
* @lc: context
*
* Returns: 1 if the partscan flags is set *or* (for old kernels) partitions
- * scannig is enabled for all loop devices.
+ * scanning is enabled for all loop devices.
*/
int loopcxt_is_partscan(struct loopdev_cxt *lc)
{
if (expected_size != size) {
DBG(CXT, ul_debugobj(lc, "warning: loopdev and expected "
- "size dismatch (%ju/%ju)",
+ "size mismatch (%ju/%ju)",
size, expected_size));
if (loopcxt_set_capacity(lc)) {
/*
- * plymouth-ctrl.c Simply communcations with plymouthd
+ * plymouth-ctrl.c Simply communications with plymouthd
* to avoid forked sub processes and/or
- * misssed plymouth send commands tool
- * due a plymouthd replacment.
+ * missed plymouth send commands tool
+ * due a plymouthd replacement.
*
* Copyright (c) 2016 SUSE Linux GmbH, All rights reserved.
* Copyright (c) 2016 Werner Fink <werner@suse.de>
* for example:
* 10KB = 10000
*
- * The optinal 'power' variable returns number associated with used suffix
+ * The optional 'power' variable returns number associated with used suffix
* {K,M,G,T,P,E,Z,Y} = {1,2,3,4,5,6,7,8}.
*
* The function also supports decimal point, for example:
}
/*
- * Returns complete path to the device, the patch contains all all sybsystems
+ * Returns complete path to the device, the patch contains all all subsystems
* used for the device.
*/
char *sysfs_get_devchain(struct sysfs_cxt *cxt, char *buf, size_t bufsz)
}
/*
- * Returns by @diskdevno whole disk device devno and (optionaly) by
+ * Returns by @diskdevno whole disk device devno and (optionally) by
* @diskname the whole disk device name.
*/
int sysfs_devno_to_wholedisk(dev_t dev, char *diskname,
/*
* Extra case for partitions mapped by device-mapper.
*
- * All regualar partitions (added by BLKPG ioctl or kernel PT
+ * All regular partitions (added by BLKPG ioctl or kernel PT
* parser) have the /sys/.../partition file. The partitions
* mapped by DM don't have such file, but they have "part"
* prefix in DM UUID.
devname = argv[1];
pr = blkid_new_probe_from_filename(devname);
if (!pr)
- err(EXIT_FAILURE, "%s: faild to create a new libblkid probe",
+ err(EXIT_FAILURE, "%s: failed to create a new libblkid probe",
devname);
/*
devname = argv[1];
pr = blkid_new_probe_from_filename(devname);
if (!pr)
- err(EXIT_FAILURE, "%s: faild to create a new libblkid probe",
+ err(EXIT_FAILURE, "%s: failed to create a new libblkid probe",
devname);
/* Binary interface */
ls = blkid_probe_get_partitions(pr);
devname = argv[1];
pr = blkid_new_probe_from_filename(devname);
if (!pr)
- err(EXIT_FAILURE, "%s: faild to create a new libblkid probe",
+ err(EXIT_FAILURE, "%s: failed to create a new libblkid probe",
devname);
/* enable topology probing */
devname = argv[1];
pr = blkid_new_probe_from_filename(devname);
if (!pr)
- err(EXIT_FAILURE, "%s: faild to create a new libblkid probe",
+ err(EXIT_FAILURE, "%s: failed to create a new libblkid probe",
devname);
/*
* Binary interface
struct list_head bid_devs; /* All devices in the cache */
struct list_head bid_tags; /* All tags for this device */
blkid_cache bid_cache; /* Dev belongs to this cache */
- char *bid_name; /* Device real pathn (as used in cache) */
+ char *bid_name; /* Device real path (as used in cache) */
char *bid_xname; /* Device path as used by application (maybe symlink..) */
char *bid_type; /* Preferred device TYPE */
int bid_pri; /* Device priority */
unsigned int blkssz; /* sector size (BLKSSZGET ioctl) */
mode_t mode; /* struct stat.sb_mode */
- int flags; /* private libray flags */
+ int flags; /* private library flags */
int prob_flags; /* always zeroized by blkid_do_*() */
uint64_t wipe_off; /* begin of the wiped area */
uint64_t *offset, const struct blkid_idmag **res)
__attribute__((nonnull(1)));
-/* returns superblok according to 'struct blkid_idmag' */
+/* returns superblock according to 'struct blkid_idmag' */
#define blkid_probe_get_sb(_pr, _mag, type) \
((type *) blkid_probe_get_buffer((_pr),\
(_mag)->kboff << 10, sizeof(type)))
* @cache: pointer to return cache handler
* @filename: path to the cache file or NULL for the default path
*
- * Allocates and initialize librray cache handler.
+ * Allocates and initialize library cache handler.
*
* Returns: 0 on success or number less than zero in case of error.
*/
*
* These routines do not expose the list.h implementation, which are a
* contamination of the namespace, and which force us to reveal far, far
- * too much of our internal implemenation. I'm not convinced I want
+ * too much of our internal implementation. I'm not convinced I want
* to keep list.h in the long term, anyway. It's fine for kernel
* programming, but performance is not the #1 priority for this
- * library, and I really don't like the tradeoff of type-safety for
+ * library, and I really don't like the trade-off of type-safety for
* performance for this application. [tytso:20030125.2007EST]
*/
/* try canonicalize the name */
if (!dev && (cn = canonicalize_path(devname))) {
if (strcmp(cn, devname) != 0) {
- DBG(DEVNAME, ul_debug("search cannonical %s", cn));
+ DBG(DEVNAME, ul_debug("search canonical %s", cn));
list_for_each(p, &cache->bic_devs) {
tmp = list_entry(p, struct blkid_struct_dev, bid_devs);
if (strcmp(tmp->bid_name, cn))
DBG(EVALUATE, ul_debug("write failed: %s", uevent));
}
DBG(EVALUATE, ul_debug("%s: send uevent %s",
- uevent, rc == 0 ? "SUCCES" : "FAILED"));
+ uevent, rc == 0 ? "SUCCESS" : "FAILED"));
return rc;
}
/**
* SECTION: init
* @title: Library initialization
- * @short_description: initialize debuging
+ * @short_description: initialize debugging
*/
#include <stdarg.h>
{ "config", BLKID_DEBUG_CONFIG, "config file utils" },
{ "dev", BLKID_DEBUG_DEV, "device utils" },
{ "devname", BLKID_DEBUG_DEVNAME, "/proc/partitions evaluation" },
- { "devno", BLKID_DEBUG_DEVNO, "convertions to device name" },
+ { "devno", BLKID_DEBUG_DEVNO, "conversions to device name" },
{ "evaluate", BLKID_DEBUG_EVALUATE, "tags resolving" },
{ "help", BLKID_DEBUG_HELP, "this help" },
{ "lowprobe", BLKID_DEBUG_LOWPROBE, "superblock/raids/partitions probing" },
/**
* blkid_init_debug:
- * @mask: debug mask (0xffff to enable full debuging)
+ * @mask: debug mask (0xffff to enable full debugging)
*
* If the @mask is not specified then this function reads
* LIBBLKID_DEBUG environment variable to get the mask.
snprintf(idstr, sizeof(idstr), "%08x", id);
/*
- * Well, all checks pass, it's MS-DOS partiton table
+ * Well, all checks pass, it's MS-DOS partition table
*/
if (blkid_partitions_need_typeonly(pr)) {
/* Non-binary interface -- caller does not ask for details
- * about partitions, just set generic varibles only. */
+ * about partitions, just set generic variables only. */
if (id)
blkid_partitions_strcpy_ptuuid(pr, idstr);
return 0;
uint64_t my_lba; /* location of this header copy */
uint64_t alternate_lba; /* location of the other header copy */
- uint64_t first_usable_lba; /* lirst usable LBA for partitions */
+ uint64_t first_usable_lba; /* first usable LBA for partitions */
uint64_t last_usable_lba; /* last usable LBA for partitions */
efi_guid_t disk_guid; /* disk UUID */
* (due DOS PT limitations).
*
* Note that the PMBR detection is optional (enabled by default) and could be
- * disabled by BLKID_PARTS_FOPCE_GPT flag (see also blkid_paertitions_set_flags()).
+ * disabled by BLKID_PARTS_FOPCE_GPT flag (see also blkid_partitions_set_flags()).
*/
static int is_pmbr_valid(blkid_probe pr, int *has)
{
if (blkid_partitions_need_typeonly(pr)) {
/* Non-binary interface -- caller does not ask for details
- * about partitions, just set generic varibles only. */
+ * about partitions, just set generic variables only. */
blkid_partitions_set_ptuuid(pr, (unsigned char *) &guid);
return BLKID_PROBE_OK;
}
/*
* It would be possible to check for DOS signature (0xAA55), but
- * unfortunately almost all EFI GPT implemenations allow to optionaly
+ * unfortunately almost all EFI GPT implementations allow to optionally
* skip the legacy MBR. We follows this behavior and MBR is optional.
* See is_valid_pmbr().
*
if (be32_to_cpu(p->map_count) != nblks) {
DBG(LOWPROBE, ul_debug(
- "mac: inconsisten map_count in partition map, "
+ "mac: inconsistent map_count in partition map, "
"entry[0]: %d, entry[%d]: %d",
nblks, i - 1,
be32_to_cpu(p->map_count)));
*
* pr = blkid_new_probe_from_filename(devname);
* if (!pr)
- * err("%s: faild to open device", devname);
+ * err("%s: failed to open device", devname);
*
* blkid_probe_enable_partitions(pr, TRUE);
* blkid_do_fullprobe(pr);
*
* pr = blkid_new_probe_from_filename(devname);
* if (!pr)
- * err("%s: faild to open device", devname);
+ * err("%s: failed to open device", devname);
*
* ls = blkid_probe_get_partitions(pr);
* nparts = blkid_partlist_numof_partitions(ls);
int partno; /* partition number */
char uuid[37]; /* UUID (when supported by PT), e.g GPT */
- unsigned char name[128]; /* Partition in UTF8 name (when supporte by PT), e.g. Mac */
+ unsigned char name[128]; /* Partition in UTF8 name (when supported by PT), e.g. Mac */
blkid_parttable tab; /* partition table */
};
if (ls->nparts + 1 > ls->nparts_max) {
/* Linux kernel has DISK_MAX_PARTS=256, but it's too much for
- * generic Linux machine -- let start with 32 partititions.
+ * generic Linux machine -- let start with 32 partitions.
*/
void *tmp = realloc(ls->parts, (ls->nparts_max + 32) *
sizeof(struct blkid_struct_partition));
/**
* blkid_known_pttype:
- * @pttype: partiton name
+ * @pttype: partition name
*
* Returns: 1 for known or 0 for unknown partition type.
*/
if (!ls)
return NULL;
- DBG(LOWPROBE, ul_debug("triyng to convert devno 0x%llx to partition",
+ DBG(LOWPROBE, ul_debug("trying to convert devno 0x%llx to partition",
(long long) devno));
if (sysfs_init(&sysfs, devno, NULL)) {
/*
* Partition mapped by kpartx does not provide "start" offset
* in /sys, but if we know partno and size of the partition
- * that we can probably make the releation bettween the device
+ * that we can probably make the relation between the device
* and an entry in partition table.
*/
for (i = 0; i < ls->nparts; i++) {
* blkid_parttable_get_parent:
* @tab: partition table
*
- * Returns: parent for nexted partitition tables or NULL.
+ * Returns: parent for nested partition tables or NULL.
*/
blkid_partition blkid_parttable_get_parent(blkid_parttable tab)
{
*
* Note the position is relative to begin of the device as defined by
* blkid_probe_set_device() for primary partition table, and relative
- * to parental partition for nested patition tables.
+ * to parental partition for nested partition tables.
*
* <informalexample>
* <programlisting>
* blkid_partition_get_partno:
* @par: partition
*
- * Returns: proposed partitin number (e.g. 'N' from sda'N') or -1 in case of
- * error. Note that the number is generate by library independenly on your OS.
+ * Returns: proposed partition number (e.g. 'N' from sda'N') or -1 in case of
+ * error. Note that the number is generate by library independently on your OS.
*/
int blkid_partition_get_partno(blkid_partition par)
{
*
* Be careful if you _not_ probe whole disk:
*
- * 1) the offset is usully relative to begin of the disk -- but if you probe a
+ * 1) the offset is usually relative to begin of the disk -- but if you probe a
* fragment of the disk only -- then the offset could be still relative to
* the begin of the disk rather that relative to the fragment.
*
- * 2) the offset for nested partitions could be releative to parent (e.g. Solaris)
+ * 2) the offset for nested partitions could be relative to parent (e.g. Solaris)
* _or_ relative to the begin of the whole disk (e.g. bsd).
*
- * You don't have to care about such details if you proble whole disk. In such
+ * You don't have to care about such details if you probe whole disk. In such
* a case libblkid always returns the offset relative to the begin of the disk.
*
* Returns: start of the partition (in 512-sectors).
* library always returns full size of the partition. If you want add
* the partition to the Linux system (BLKPG_ADD_PARTITION ioctl) you
* need to reduce the size of the partition to 1 or 2 blocks. The
- * rest of the partition has to be unaccessible for mkfs or mkswap
+ * rest of the partition has to be inaccessible for mkfs or mkswap
* programs, we need a small space for boot loaders only.
*
* For some unknown reason this (safe) practice is not to used for
* offset (start) of the slice is always relatively to the primary dos
* partition.
*
- * Note that Solaris-SPARC uses entire disk with a different partitionning
+ * Note that Solaris-SPARC uses entire disk with a different partitioning
* scheme.
*/
const struct blkid_idmag *mag __attribute__((__unused__)))
{
struct solaris_vtoc *l; /* disk label */
- struct solaris_slice *p; /* partitsion */
+ struct solaris_slice *p; /* partition */
blkid_parttable tab = NULL;
blkid_partition parent;
blkid_partlist ls;
/*
* So that old Linux-Sun partitions continue to work,
- * alow the VTOC to be used under the additional condition ...
+ * allow the VTOC to be used under the additional condition ...
*/
use_vtoc = use_vtoc || !(l->vtoc.sanity || l->vtoc.version || l->vtoc.nparts);
* GNU Lesser General Public License.
*
*
- * The intersting information about unixware PT:
+ * The interesting information about unixware PT:
* - Linux kernel / partx
* - vtoc(7) SCO UNIX command man page
* - evms source code (http://evms.sourceforge.net/)
* Clone @parent, the new clone shares all, but except:
*
* - probing result
- * - bufferes if another device (or offset) is set to the prober
+ * - buffers if another device (or offset) is set to the prober
*/
blkid_probe blkid_clone_probe(blkid_probe parent)
{
if (!pr || list_empty(&pr->values))
return;
- DBG(LOWPROBE, ul_debug("reseting %s values", chn->driver->name));
+ DBG(LOWPROBE, ul_debug("Resetting %s values", chn->driver->name));
list_for_each_safe(p, pnext, &pr->values) {
struct blkid_prval *v = list_entry(p,
pr->off + off - pr->parent->off, len);
}
- /* try buffers we already have in memmory */
+ /* try buffers we already have in memory */
list_for_each(p, &pr->buffers) {
struct blkid_bufinfo *x =
list_entry(p, struct blkid_bufinfo, bufs);
if (!pr || list_empty(&pr->buffers))
return;
- DBG(BUFFER, ul_debug("reseting probing buffers pr=%p", pr));
+ DBG(BUFFER, ul_debug("Resetting probing buffers pr=%p", pr));
while (!list_empty(&pr->buffers)) {
struct blkid_bufinfo *bf = list_entry(pr->buffers.next,
*
* This function erases the current signature detected by @pr. The @pr has to
* be open in O_RDWR mode, BLKID_SUBLKS_MAGIC or/and BLKID_PARTS_MAGIC flags
- * has to be enabled (if you want to errase also superblock with broken check
+ * has to be enabled (if you want to erase also superblock with broken check
* sums then use BLKID_SUBLKS_BADCSUM too).
*
* After successful signature removing the @pr prober will be moved one step
* continue;
*
* // convert ostr to the real offset by off = strtoll(ostr, NULL, 10);
- * // use your stuff to errase @len bytes at the @off
+ * // use your stuff to erase @len bytes at the @off
* ....
*
* // retry the last probing to check for backup superblocks ..etc.
*
* This is string-based NAME=value interface only.
*
- * Note about suberblocks chain -- the function does not check for filesystems
+ * Note about superblocks chain -- the function does not check for filesystems
* when a RAID signature is detected. The function also does not check for
* collision between RAIDs. The first detected RAID is returned. The function
* checks for collision between partition table and RAID signature -- it's
* recommended to enable partitions chain together with superblocks chain.
*
- * Returns: 0 on success, 1 if nothing is detected, -2 if ambivalen result is
+ * Returns: 0 on success, 1 if nothing is detected, -2 if ambivalent result is
* detected and -1 on case of error.
*/
int blkid_do_safeprobe(blkid_probe pr)
/*
* Try to use any area -- if the area has been previously wiped then the
- * previous probing result should be ignored (reseted).
+ * previous probing result should be ignored (reset).
*/
void blkid_probe_use_wiper(blkid_probe pr, uint64_t off, uint64_t size)
{
char sb_locktable[GFS_LOCKNAME_LEN];
struct gfs2_inum __pad3; /* Was quota inode in gfs1 */
- struct gfs2_inum __pad4; /* Was licence inode in gfs1 */
+ struct gfs2_inum __pad4; /* Was license inode in gfs1 */
uint8_t sb_uuid[16]; /* The UUID maybe 0 for backwards compat */
} __attribute__((packed));
.probefunc = probe_highpoint37x,
.magics = {
/*
- * Superblok offset: 4608 bytes (9 sectors)
+ * Superblock offset: 4608 bytes (9 sectors)
* Magic string offset within superblock: 32 bytes
*
* kboff = (4608 + 32) / 1024
continue;
}
- /* Not a Boot record, lets see if its supplemntary volume descriptor */
+ /* Not a Boot record, lets see if its supplementary volume descriptor */
iso = (struct iso_volume_descriptor *) boot;
if (iso->vd_type != ISO_VD_SUPPLEMENTARY) {
blkid_probe_set_version(pr, "Joliet Extension");
/* Is the Joliet (UTF16BE) label equal to the label in
- * the PVD? If yes, use PVD label. The Jolied version
- * of the label could be trimed (because UTF16..).
+ * the PVD? If yes, use PVD label. The Joliet version
+ * of the label could be trimmed (because UTF16..).
*/
if (ascii_eq_utf16be(label, iso->volume_id, 32))
break;
uint8_t pad2[64-57]; /* set to 0 when writing */
/* array state information - 64 bytes */
- uint64_t utime; /* 40 bits second, 24 btes microseconds */
+ uint64_t utime; /* 40 bits second, 24 bits microseconds */
uint64_t events; /* incremented when superblock updated */
uint64_t resync_offset; /* data before this offset (from data_offset) known to be in sync */
uint32_t sb_csum; /* checksum up to dev_roles[max_dev] */
blkid_probe_set_version(pr, mag->magic);
/* LVM (pvcreate) wipes begin of the device -- let's remember this
- * to resolve conflicts bettween LVM and partition tables, ...
+ * to resolve conflicts between LVM and partition tables, ...
*/
blkid_probe_set_wiper(pr, 0, 8 * 1024);
*
* @SBMAGIC_OFFSET: offset of SBMAGIC
*
- * @FSSIZE: size of filessystem [not-implemented yet]
+ * @FSSIZE: size of filesystem [not-implemented yet]
*
* @SYSTEM_ID: ISO9660 system identifier
*
* blkid_known_fstype:
* @fstype: filesystem name
*
- * Returns: 1 for known filesytems, or 0 for unknown filesystem.
+ * Returns: 1 for known filesystems, or 0 for unknown filesystem.
*/
int blkid_known_fstype(const char *fstype)
{
}
}
- /* all cheks passed */
+ /* all checks passed */
if (chn->flags & BLKID_SUBLKS_TYPE)
rc = blkid_probe_set_value(pr, "TYPE",
(unsigned char *) id->name,
/*
* This is the same function as blkid_do_probe(), but returns only one result
- * (cannot be used in while()) and checks for ambivalen results (more
+ * (cannot be used in while()) and checks for ambivalent results (more
* filesystems on the device) -- in such case returns -2.
*
* The function does not check for filesystems when a RAID or crypto signature
/*
* The RAID device could be partitioned. The problem are RAID1 devices
- * where the partition table is visible from underlaying devices. We
+ * where the partition table is visible from underlying devices. We
* have to ignore such partition tables.
*/
if (chn->idx >= 0 && idinfos[chn->idx]->usage & BLKID_USAGE_RAID)
return rc;
}
-/* function to set UUIDs that are in suberblocks stored as strings */
+/* function to set UUIDs that are in superblocks stored as strings */
int blkid_probe_strncpy_uuid(blkid_probe pr, unsigned char *str, size_t len)
{
struct blkid_chain *chn = blkid_probe_get_chain(pr);
/*
* Copyright (C) 2008 Karel Zak <kzak@redhat.com>
*
- * This is written from sratch according to Linux kernel fs/sysv/super.c file.
+ * This is written from scratch according to Linux kernel fs/sysv/super.c file.
* It seems that sysv probing code in libvolume_id and also in the original
* blkid is useless.
*
/*
* Set a tag on an existing device.
*
- * If value is NULL, then delete the tagsfrom the device.
+ * If value is NULL, then delete the tags from the device.
*/
int blkid_set_tag(blkid_dev dev, const char *name,
const char *value, const int vlength)
*
* These routines do not expose the list.h implementation, which are a
* contamination of the namespace, and which force us to reveal far, far
- * too much of our internal implemenation. I'm not convinced I want
+ * too much of our internal implementation. I'm not convinced I want
* to keep list.h in the long term, anyway. It's fine for kernel
* programming, but performance is not the #1 priority for this
- * library, and I really don't like the tradeoff of type-safety for
+ * library, and I really don't like the trade-off of type-safety for
* performance for this application. [tytso:20030125.2007EST]
*/
/*
* Evms topology
- * -- this is fallback for old systems where the toplogy information is not
+ * -- this is fallback for old systems where the topology information is not
* exported by sysfs
*
* Copyright (C) 2009 Karel Zak <kzak@redhat.com>
/* /sys/dev/block/<maj>:<min>/<ATTR> */
const char *attr;
- /* functions to set probing resut */
+ /* functions to set probing result */
int (*set_ulong)(blkid_probe, unsigned long);
int (*set_int)(blkid_probe, int);
if (!ok) {
if (!disk) {
/*
- * Read atrributes from "disk" if the current
+ * Read attributes from "disk" if the current
* device is a partition.
*/
disk = blkid_probe_get_wholedisk_devno(pr);
*
* WARNING: the returned object will be overwritten by the next
* blkid_probe_get_topology() call for the same @pr. If you want to
- * use more blkid_topopogy objects in the same time you have to create
+ * use more blkid_topology objects in the same time you have to create
* more blkid_probe handlers (see blkid_new_probe()).
*
- * Returns: blkid_topopogy, or NULL in case of error.
+ * Returns: blkid_topology, or NULL in case of error.
*/
blkid_topology blkid_probe_get_topology(blkid_probe pr)
{
/**
* blkid_get_library_version:
- * @ver_string: returns relese version (!= SONAME version)
+ * @ver_string: returns release version (!= SONAME version)
* @date_string: returns date
*
* Returns: release version code.
*
* The difference between fdisk_override_geometry() and fdisk_save_user_geometry()
* is that saved user geometry is persistent setting and it's applied always
- * when device is assigned to the context or device properties are reseted.
+ * when device is assigned to the context or device properties are reset.
*
* Returns: 0 on success, < 0 on error.
*/
* fdisk_save_user_sector_size:
* @cxt: context
* @phy: physical sector size
- * @log: logicla sector size
+ * @log: logical sector size
*
* Save user defined sector sizes to use it for partitioning.
*
if (!cxt)
return -EINVAL;
- DBG(CXT, ul_debugobj(cxt, "appling user device properties"));
+ DBG(CXT, ul_debugobj(cxt, "applying user device properties"));
if (cxt->user_pyh_sector)
cxt->phy_sector_size = cxt->user_pyh_sector;
if (!cxt)
return -EINVAL;
- DBG(CXT, ul_debugobj(cxt, "*** reseting device properties"));
+ DBG(CXT, ul_debugobj(cxt, "*** resetting device properties"));
fdisk_zeroize_device_properties(cxt);
fdisk_discover_topology(cxt);
* a2) alignment offset
* a1) or physical sector (minimal_io_size, aka "grain")
*
- * b) or default to 1MiB (2048 sectrors, Windows Vista default)
+ * b) or default to 1MiB (2048 sectors, Windows Vista default)
*
* c) or for very small devices use 1 phy.sector
*/
if (!cxt)
return -EINVAL;
- DBG(CXT, ul_debugobj(cxt, "reseting alignment..."));
+ DBG(CXT, ul_debugobj(cxt, "resetting alignment..."));
/* default */
cxt->grain = topology_get_grain(cxt);
if (cxt->label && cxt->label->op->reset_alignment)
rc = cxt->label->op->reset_alignment(cxt);
- DBG(CXT, ul_debugobj(cxt, "alignment reseted to: "
+ DBG(CXT, ul_debugobj(cxt, "alignment reset to: "
"first LBA=%ju, last LBA=%ju, grain=%lu [rc=%d]",
(uintmax_t) cxt->first_lba, (uintmax_t) cxt->last_lba,
cxt->grain, rc));
* fdisk_ref_ask:
* @ask: ask instance
*
- * Incremparts reference counter.
+ * Increments reference counter.
*/
void fdisk_ref_ask(struct fdisk_ask *ask)
{
* fdisk_unref_ask:
* @ask: ask instance
*
- * De-incremparts reference counter, on zero the @ask is automatically
+ * Decrements reference counter, on zero the @ask is automatically
* deallocated.
*/
void fdisk_unref_ask(struct fdisk_ask *ask)
*
* Inform libfdisk that user specified number in relative notation rather than
* by explicit number. This info allows to fdisk do some optimization (e.g.
- * align end of partiton, etc.)
+ * align end of partition, etc.)
*
* Returns: 0 on success, <0 on error
*/
if (!rc && !wantnew && num->low == num->hig) {
if (num->low > 0) {
- /* only one existing partiton, don't ask, return the number */
+ /* only one existing partition, don't ask, return the number */
fdisk_ask_number_set_result(ask, num->low);
fdisk_info(cxt, _("Selected partition %ju"), num->low);
* @query: question string
* @result: returns 0 (no) or 1 (yes)
*
- * Hight-level API to ask Yes/No questions
+ * High-level API to ask Yes/No questions
*
* Returns: 0 on success, <0 on error
*/
* fdisk_info:
* @cxt: context
* @fmt: printf-like formatted string
- * @...: variable parametrs
+ * @...: variable parameters
*
* High-level API to print info messages,
*
* fdisk_info:
* @cxt: context
* @fmt: printf-like formatted string
- * @...: variable parametrs
+ * @...: variable parameters
*
* High-level API to print warning message (errno expected)
*
int rc = 0;
if (cxt->parent)
- rc = bsd_assign_dos_partition(cxt); /* nested BSD partiotn table */
+ rc = bsd_assign_dos_partition(cxt); /* nested BSD partition table */
if (!rc)
rc = bsd_readlabel(cxt);
if (!rc)
break;
default:
if (item->id < __FDISK_NLABELITEMS)
- rc = 1; /* unssupported generic item */
+ rc = 1; /* unsupported generic item */
else
rc = 2; /* out of range */
break;
* If no @name specified then returns the current context label.
*
* The label is allocated and maintained within the context #cxt. There is
- * nothing like reference counting for labels, you cannot delallocate the
+ * nothing like reference counting for labels, you cannot deallocate the
* label.
*
* Returns: label struct or NULL in case of error.
if (fdisk_read_firstsector(cxt) < 0)
goto fail;
- /* detect labels and apply labes specific stuff (e.g geomery)
+ /* detect labels and apply labels specific stuff (e.g geometry)
* to the context */
fdisk_probe_labels(cxt);
/**
* fdisk_enable_details:
* @cxt: context
- * @enable: true/flase
+ * @enable: true/false
*
* Enables or disables "details" display mode. This function has effect to
* fdisk_partition_to_string() function.
/**
* fdisk_enable_listonly:
* @cxt: context
- * @enable: true/flase
+ * @enable: true/false
*
* Just list partition only, don't care about another details, mistakes, ...
*
* This is pure shit, unfortunately for example Sun addresses begin of the
* partition by cylinders...
*
- * Returns: 0 on succes, <0 on error.
+ * Returns: 0 on success, <0 on error.
*/
int fdisk_set_unit(struct fdisk_context *cxt, const char *str)
{
* @lba: first possible logical sector for data
*
* It's strongly recommended to use the default library setting. The first LBA
- * is always reseted by fdisk_assign_device(), fdisk_override_geometry()
+ * is always reset by fdisk_assign_device(), fdisk_override_geometry()
* and fdisk_reset_alignment(). This is very low level function and library
* does not check if your setting makes any sense.
*
* @lba: last possible logical sector
*
* It's strongly recommended to use the default library setting. The last LBA
- * is always reseted by fdisk_assign_device(), fdisk_override_geometry() and
+ * is always reset by fdisk_assign_device(), fdisk_override_geometry() and
* fdisk_reset_alignment().
*
* The default is number of sectors on the device, but maybe modified by the
* fdisk_get_devfd:
* @cxt: context
*
- * Retruns: device file descriptor.
+ * Returns: device file descriptor.
*/
int fdisk_get_devfd(struct fdisk_context *cxt)
{
if (!pe)
return -EINVAL;
- DBG(LABEL, ul_debug("DOS: delete partiton %zu (max=%zu)", partnum,
+ DBG(LABEL, ul_debug("DOS: delete partition %zu (max=%zu)", partnum,
cxt->label->nparts_max));
l = self_label(cxt);
/* overwrite necessary stuff by DOS deprecated stuff */
if (is_dos_compatible(cxt)) {
- DBG(LABEL, ul_debug("DOS: reseting alignemnt for DOS-comaptiblem PT"));
+ DBG(LABEL, ul_debug("DOS: resetting alignment for DOS-compatible PT"));
if (cxt->geom.sectors)
cxt->first_lba = cxt->geom.sectors; /* usually 63 */
{
assert(start);
- /* try to use tepmlate from 'pa' */
+ /* try to use template from 'pa' */
if (pa && pa->start_follow_default)
*start = dflt;
/* pa specifies that extended partition is wanted */
} else if (pa && pa->type && IS_EXTENDED(pa->type->code)) {
- DBG(LABEL, ul_debug("DOS: pa template %p: add extened", pa));
+ DBG(LABEL, ul_debug("DOS: pa template %p: add extended", pa));
if (l->ext_offset) {
fdisk_warnx(cxt, _("Extended partition already exists."));
return -EINVAL;
return rc;
}
- DBG(LABEL, ul_debug("DOS: writting to sector %ju", (uintmax_t) secno));
+ DBG(LABEL, ul_debug("DOS: writing to sector %ju", (uintmax_t) secno));
if (write(cxt->dev_fd, buf, cxt->sector_size) != (ssize_t) cxt->sector_size)
return -errno;
}
}
if (mbr_changed) {
- DBG(LABEL, ul_debug("DOS: MBR changed, writting"));
+ DBG(LABEL, ul_debug("DOS: MBR changed, writing"));
mbr_set_magic(cxt->firstsector);
rc = write_sector(cxt, 0, cxt->firstsector);
if (rc)
}
default:
if (item->id < __FDISK_NLABELITEMS)
- rc = 1; /* unssupported generic item */
+ rc = 1; /* unsupported generic item */
else
rc = 2; /* out of range */
break;
*nxt->pt_entry = tmp;
/* Recount starts according to EBR offsets, the absolute
- * address tas to be still the same! */
+ * address still has to be the same! */
dos_partition_set_start(cur->pt_entry, nxt_start - cur->offset);
dos_partition_set_start(nxt->pt_entry, cur_start - nxt->offset);
#include "c.h"
#include "libfdisk.h"
-#include "nls.h" /* temporary before dialog API will be implamented */
+#include "nls.h" /* temporary before dialog API will be implemented */
#include "list.h"
#include "debug.h"
#include <stdio.h>
int flags; /* FDISK_FIELDFL_* */
};
-/* note that the defauls is to display a column always */
+/* note that the defaults is to display a column always */
enum {
FDISK_FIELDFL_DETAIL = (1 << 1), /* only display if fdisk_is_details() */
FDISK_FIELDFL_EYECANDY = (1 << 2), /* don't display if fdisk_is_details() */
} str;
/* FDISK_ASKTYPE_MENU */
struct ask_menu {
- int dfl; /* default meni item */
+ int dfl; /* default menu item */
int result;
struct ask_menuitem *first;
} menu;
unsigned int readonly : 1, /* don't write to the device */
display_in_cyl_units : 1, /* for obscure labels */
display_details : 1, /* expert display mode */
- protect_bootbits : 1, /* don't zeroize fll irst sector */
+ protect_bootbits : 1, /* don't zeroize first sector */
listonly : 1; /* list partition, nothing else */
char *collision; /* name of already existing FS/PT */
/* alignment */
unsigned long grain; /* alignment unit */
fdisk_sector_t first_lba; /* recommended begin of the first partition */
- fdisk_sector_t last_lba; /* recomennded end of last partition */
+ fdisk_sector_t last_lba; /* recommended end of last partition */
/* geometry */
fdisk_sector_t total_sectors; /* in logical sectors */
* @title: Field
* @short_description: description of the partition fields
*
- * The fdisk fields are static user-freindly descriptions of the partition. The
+ * The fdisk fields are static user-friendly descriptions of the partition. The
* fields are used to avoid label specific stuff in the functions that list disk
* partitions (e.g. fdisk -l). The field Id is the same as Id for fdisk_partition_to_string().
*
* </informalexample>
*
* This example lists all information about the first partition. It will work
- * for MBR as well as for GPT because fields are not hardcoded in the execmple.
+ * for MBR as well as for GPT because fields are not hardcoded in the example.
*
* See also fdisk_label_get_field_by_name(), fdisk_label_get_fields_ids_all()
* and fdisk_label_get_fields_ids().
/* According to EFI standard it's valid to count all the first
* sector into header size, but some tools may have a problem
- * to accept it, so use the header without the zerozied area.
+ * to accept it, so use the header without the zeroed area.
* This does not have any impact to CRC, etc. --kzak Jan-2015
*/
header->size = cpu_to_le32(sizeof(struct gpt_header)
/*
* Checks if there is a valid protective MBR partition table.
* Returns 0 if it is invalid or failure. Otherwise, return
- * GPT_MBR_PROTECTIVE or GPT_MBR_HYBRID, depeding on the detection.
+ * GPT_MBR_PROTECTIVE or GPT_MBR_HYBRID, depending on the detection.
*/
static int valid_pmbr(struct fdisk_context *cxt)
{
/*
* Recompute header and partition array 32bit CRC checksums.
* This function does not fail - if there's corruption, then it
- * will be reported when checksuming it again (ie: probing or verify).
+ * will be reported when checksumming it again (ie: probing or verify).
*/
static void gpt_recompute_crc(struct gpt_header *header, struct gpt_entry *ents)
{
break;
default:
if (item->id < __FDISK_NLABELITEMS)
- rc = 1; /* unssupported generic item */
+ rc = 1; /* unsupported generic item */
else
rc = 2; /* out of range */
break;
* Check if a partition ends before it begins
* Returns the faulting partition number, otherwise 0.
*/
-static uint32_t check_start_after_end_paritions(struct gpt_header *header,
+static uint32_t check_start_after_end_partitions(struct gpt_header *header,
struct gpt_entry *ents)
{
uint32_t i;
/*
* Verify data integrity and report any found problems for:
* - primary and backup header validations
- * - paritition validations
+ * - partition validations
*/
static int gpt_verify_disklabel(struct fdisk_context *cxt)
{
ptnum);
}
- ptnum = check_start_after_end_paritions(gpt->pheader, gpt->ents);
+ ptnum = check_start_after_end_partitions(gpt->pheader, gpt->ents);
if (ptnum) {
nerror++;
fdisk_warnx(cxt, _("Partition %u ends before it starts."),
/**
* fdisk_init_debug:
- * @mask: debug mask (0xffff to enable full debuging)
+ * @mask: debug mask (0xffff to enable full debugging)
*
* If the @mask is not specified then this function reads
* LIBFDISK_DEBUG environment variable to get the mask.
* fdisk_ref_labelitem:
* @li: label item
*
- * Incremparts reference counter.
+ * Increments reference counter.
*
* Since: v2.29
*/
* fdisk_unref_labelitem:
* @li: label item
*
- * De-incremparts reference counter, on zero the @li is automatically
+ * Decrements reference counter, on zero the @li is automatically
* deallocated.
*
* Since: v2.29
printf("%s: %ju\n", name, num);
break;
}
- case 1: /* item unssuported by label -- ignore */
+ case 1: /* item unsuported by label -- ignore */
rc = 0;
break;
case 2: /* end (out of range) */
* fdisk_unref_context() only.
*
* Anyway, all label drives share in-memory first sector. The function
- * fdisk_create_disklabel() overwrites thi in-memory sector. But it's possible that
+ * fdisk_create_disklabel() overwrites this in-memory sector. But it's possible that
* label driver also uses another buffers, for example GPT reads more sectors
* from the device.
*
* The function requires enabled "details" by fdisk_enable_details().
*
* It's recommended to use fdisk_get_disklabel_item() if you need better
- * control on output and formmatting.
+ * control on output and formatting.
*
* Returns: 0 on success, otherwise, a corresponding error.
*/
*
* Creates a new disk label of type @name. If @name is NULL, then it will
* create a default system label type, either SUN or DOS. The function
- * automaticaly switches the current label driver to @name. The function
+ * automatically switches the current label driver to @name. The function
* fdisk_get_label() returns the current label driver.
*
* The function modifies in-memory data only.
* GPT is composed from two items, PMBR and GPT, n=0 return offset to PMBR and n=1
* return offset to GPT. For more details see 'D' expert fdisk command.
*
- * Returns: 0 on succes, <0 on error, 1 no more items.
+ * Returns: 0 on success, <0 on error, 1 no more items.
*/
int fdisk_locate_disklabel(struct fdisk_context *cxt, int n, const char **name,
uint64_t *offset, size_t *size)
* until it returns error or 2, the result in @item should be ignored when
* function returns 1. Don't forget to use fdisk_reset_labelitem() or fdisk_unref_labelitem().
*
- * Returns: 0 on success, < 0 on error, 1 on unssupported item, 2 @id out of range
+ * Returns: 0 on success, < 0 on error, 1 on unsupported item, 2 @id out of range
*/
int fdisk_get_disklabel_item(struct fdisk_context *cxt, int id, struct fdisk_labelitem *item)
{
* @changed: 0/1
*
* Marks in-memory data as changed, to force fdisk_write_disklabel() to write
- * to device. This should be unnecessar by default, the library keeps track
+ * to device. This should be unnecessary by default, the library keeps track
* about changes.
*/
void fdisk_label_set_changed(struct fdisk_label *lb, int changed)
* fdisk_ref_partition:
* @pa: partition pointer
*
- * Incremparts reference counter.
+ * Increments reference counter.
*/
void fdisk_ref_partition(struct fdisk_partition *pa)
{
* fdisk_unref_partition:
* @pa: partition pointer
*
- * De-incremparts reference counter, on zero the @pa is automatically
+ * Decrements reference counter, on zero the @pa is automatically
* deallocated.
*/
void fdisk_unref_partition(struct fdisk_partition *pa)
/**
* fdisk_partition_set_partno:
* @pa: partition
- * @num: partitin number (0 is the first partition, maximal is SIZE_MAX-1)
+ * @num: partition number (0 is the first partition, maximal is SIZE_MAX-1)
*
* Note that zero is valid partno too. Use fdisk_partition_unset_partno() to
* undefine the partno.
* @pa: partition
* @type: partition type
*
- * Sets parititon type.
+ * Sets partition type.
*
* Returns: 0 on success, <0 on error.
*/
* For example
* <informalexample>
* <programlisting>
- * struct fdisk_parition *pa;
+ * struct fdisk_partition *pa;
*
* fdisk_get_partition(cxt, 0, &pa);
* fdisk_partition_to_string(pa, FDISK_FIELD_UUID, &data);
* @pa: template for the partition (or NULL)
* @partno: NULL or returns new partition number
*
- * If @pa is not specified or any @pa item is missiong the libfdisk will ask by
+ * If @pa is not specified or any @pa item is missing the libfdisk will ask by
* fdisk_ask_ API.
*
* Adds a new partition to disklabel.
* fdisk_ref_parttype:
* @t: partition type
*
- * Incremparts reference counter for allocated types
+ * Increments reference counter for allocated types
*/
void fdisk_ref_parttype(struct fdisk_parttype *t)
{
* fdisk_unref_parttype
* @t: partition pointer
*
- * De-incremparts reference counter, on zero the @t is automatically
+ * Decrements reference counter, on zero the @t is automatically
* deallocated.
*/
void fdisk_unref_parttype(struct fdisk_parttype *t)
/**
* fdisk_parttype_set_typestr:
* @t: partition type
- * @str: type identificator (e.g. GUID for GPT)
+ * @str: type identifier (e.g. GUID for GPT)
*
* Sets type string to allocated partition type, for static types
* it returns -EINVAL. Don't use this function for MBR, see
/**
* fdisk_parttype_set_code:
* @t: partition type
- * @code: type identificator (e.g. MBR type codes)
+ * @code: type identifier (e.g. MBR type codes)
*
* Sets type code to allocated partition type, for static types it returns
* -EINVAL. Don't use this function for GPT, see fdisk_parttype_set_typestr().
* @lb: label
* @str: string to parse from
*
- * Parses partition type from @str according to the label. Thefunction returns
+ * Parses partition type from @str according to the label. The function returns
* a pointer to static table of the partition types, or newly allocated
* partition type for unknown types (see fdisk_parttype_is_unknown(). It's
* safe to call fdisk_unref_parttype() for all results.
*
* Checks for example result from fdisk_label_parse_parttype().
*
- * Returns: 1 is type is "unknonw" or 0.
+ * Returns: 1 is type is "unknown" or 0.
*/
int fdisk_parttype_is_unknown(const struct fdisk_parttype *t)
{
* fdisk_ref_script:
* @dp: script pointer
*
- * Incremparts reference counter.
+ * Increments reference counter.
*/
void fdisk_ref_script(struct fdisk_script *dp)
{
* fdisk_unref_script:
* @dp: script pointer
*
- * De-incremparts reference counter, on zero the @dp is automatically
+ * Decrements reference counter, on zero the @dp is automatically
* deallocated.
*/
void fdisk_unref_script(struct fdisk_script *dp)
* @dp: script
* @f: output file
*
- * Writes script @dp to the ile @f.
+ * Writes script @dp to the file @f.
*
* Returns: 0 on success, <0 on error.
*/
|| strcmp(name, "first-lba") == 0
|| strcmp(name, "last-lba") == 0
|| strcmp(name, "table-length") == 0) {
- ; /* whatever is posssible */
+ ; /* whatever is possible */
} else
goto done; /* unknown header */
} else if (!strncasecmp(p, "type=", 5) ||
- !strncasecmp(p, "Id=", 3)) { /* backward compatiility */
+ !strncasecmp(p, "Id=", 3)) { /* backward compatibility */
char *type;
p += (*p == 'I' ? 3 : 5); /* "Id=" or "type=" */
if (*p == ',' || *p == ';' || alone_sign(sign, p)) {
fdisk_partition_end_follow_default(pa, 1);
if (sign == TK_PLUS)
- /* alone '+' means use all possible space, elone '-' means nothing */
+ /* '+' alone means use all possible space, '-' alone means nothing */
pa->resize = FDISK_RESIZE_ENLARGE;
} else {
int pow = 0;
* @fn_fgets: callback function
*
* The library uses fgets() function to read the next line from the script.
- * This default maybe overrided to another function. Note that the function has
+ * This default maybe overridden by another function. Note that the function has
* to return the line terminated by \n (for example readline(3) removes \n).
*
* Return: 0 on success, <0 on error
* @cxt: context
* @dp: script
*
- * Associte context @cxt with script @dp and creates a new empty disklabel.
+ * Associate context @cxt with script @dp and creates a new empty disklabel.
*
* Returns: 0 on success, <0 on error.
*/
break;
default:
if (item->id < __FDISK_NLABELITEMS)
- rc = 1; /* unssupported generic item */
+ rc = 1; /* unsupported generic item */
else
rc = 2; /* out of range */
break;
{ 0, NULL }
};
-/* return poiter buffer with on-disk data */
+/* return pointer buffer with on-disk data */
static inline struct sun_disklabel *self_disklabel(struct fdisk_context *cxt)
{
assert(cxt);
break;
default:
if (item->id < __FDISK_NLABELITEMS)
- rc = 1; /* unssupported generic item */
+ rc = 1; /* unsupported generic item */
else
rc = 2; /* out of range */
break;
* fdisk_reset_table:
* @tb: tab pointer
*
- * Removes all entries (partitions) from the table. The parititons with zero
+ * Removes all entries (partitions) from the table. The partitions with zero
* reference count will be deallocated. This function does not modify partition
* table.
*
* fdisk_ref_table:
* @tb: table pointer
*
- * Incremparts reference counter.
+ * Increments reference counter.
*/
void fdisk_ref_table(struct fdisk_table *tb)
{
* fdisk_unref_table:
* @tb: table pointer
*
- * De-incremparts reference counter, on zero the @tb is automatically
+ * Descrements reference counter, on zero the @tb is automatically
* deallocated.
*/
void fdisk_unref_table(struct fdisk_table *tb)
* Add partitions from table @tb to the in-memory disk label. See
* fdisk_add_partition(), fdisk_delete_all_partitions(). The partitions
* that does not define start (or does not follow the default start)
- * are ingored.
+ * are ignored.
*
* Returns: 0 on success, <0 on error.
*/
#define Context_disable_canonicalize_HELP "disable_canonicalize(disable)\n\n" \
"Enable/disable paths canonicalization and tags evaluation. The libmount context\n" \
- "canonicalies paths when search in fstab and when prepare source and target paths\n" \
+ "canonicalizes paths when searching fstab and when preparing source and target paths\n" \
"for mount(2) syscall.\n" \
"\n" \
- "This fuction has effect to the private (within context) fstab instance only\n" \
+ "This function has effect to the private (within context) fstab instance only\n" \
"(see Cxt.fstab).\n" \
"Returns self or raises an exception in case of an error."
static PyObject *Context_disable_canonicalize(ContextObjext *self, PyObject *args, PyObject *kwds)
}
#define Context_init_helper_HELP "init_helper(action, flags)\n\n" \
- "This function infors libmount that used from [u]mount.type helper.\n" \
+ "This function informs libmount that it is used from [u]mount.type helper.\n" \
"\n" \
- "The function also calls Cxt.disable_helpers() to avoid recursive\n" \
- "mount.type helpers calling. It you really want to call another\n" \
- "mount.type helper from your helper than you have to explicitly enable this\n" \
+ "The function also calls Cxt.disable_helpers() to avoid calling\n" \
+ "mount.type helpers recursively. If you really want to call another\n" \
+ "mount.type helper from your helper then you have to explicitly enable this\n" \
"feature by:\n" \
"\n" \
"Cxt.disable_helpers(False);\n" \
static void Fs_destructor(FsObject *self)
{
- DBG(FS, pymnt_debug_h(self->fs, "destrutor py-obj: %p, py-refcnt=%d",
+ DBG(FS, pymnt_debug_h(self->fs, "destructor py-obj: %p, py-refcnt=%d",
self, (int) ((PyObject *) self)->ob_refcnt));
mnt_unref_fs(self->fs);
PyFree(self);
return (PyObject *) result;
}
- /* Creating an encapsualing object: increment the refcount, so that code
+ /* Creating an encapsulating object: increment the refcount, so that code
* such as tab.next_fs() doesn't call the destructor, which would free
* our fs struct as well
*/
"Please note that none of the classes' attributes may be deleted.\n" \
"This is not a complete mapping to the libmount C API, nor is it\n" \
"attempting to be one.\n" "Iterator functions only allow forward\n" \
- "iteration for now. Contex.get_{user_,}mflags() differs from the C API\n" \
+ "iteration for now. Context.get_{user_,}mflags() differs from the C API\n" \
"and returns the flags directly. Fs.get_tag() differs from the C API\n" \
"and returns a (tag, value) tuple. Every attribute is \"filtered\"" \
"through appropriate getters/setters, no values are set directly."
static void Table_destructor(TableObject *self)
{
- DBG(TAB, pymnt_debug_h(self->tab, "destrutor py-obj: %p, py-refcnt=%d",
+ DBG(TAB, pymnt_debug_h(self->tab, "destructor py-obj: %p, py-refcnt=%d",
self, (int) ((PyObject *) self)->ob_refcnt));
Table_unref(self->tab);
self->tab = NULL;
return (PyObject *) result;
}
- /* Creating an encapsualing object: increment the refcount, so that
+ /* Creating an encapsulating object: increment the refcount, so that
* code such as: cxt.get_fstab() doesn't call the destructor, which
* would free our tab struct as well
*/
/*
* the key defines the order in the tree, and so it also defines (optimal)
- * block layout. objectid corresonds to the inode number. The flags
+ * block layout. objectid corresponds with the inode number. The flags
* tells us things about the object, and is a kind of stream selector.
* so for a given inode, keys with flags of 1 might refer to the inode
* data, flags of 2 may point to file data in the btree and flags == 3
if (!writable)
return 0; /* only paths wanted */
if (mnt_context_is_nomtab(cxt))
- return 0; /* write mode overrided by mount -n */
+ return 0; /* write mode overridden by mount -n */
if (cxt->flags & MNT_FL_TABPATHS_CHECKED)
return 0;
* canonicalizes paths when searching in fstab and when preparing source and target paths
* for mount(2) syscall.
*
- * This fuction has an effect on the private (within context) fstab instance only
+ * This function has an effect on the private (within context) fstab instance only
* (see mnt_context_set_fstab()). If you want to use an external fstab then you
* need to manage your private struct libmnt_cache (see mnt_table_set_cache(fstab,
* NULL).
*
* The mount context uses private @fs by default. This function allows to
* overwrite the private @fs with an external instance. This function
- * increments @fs reference counter (and deincrement reference counter of the
+ * increments @fs reference counter (and decrement reference counter of the
* old fs).
*
* The @fs will be modified by mnt_context_set_{source,target,options,fstype}
* Note that libmount does not interpret "nofail" (MNT_MS_NOFAIL)
* mount option. The real return code is always returned, when
* the device does not exist then it's usually MNT_ERR_NOSOURCE
- * from libmount or ENOENT, ENOTDIR, ENOTBLK, ENXIO from moun(2).
+ * from libmount or ENOENT, ENOTDIR, ENOTBLK, ENXIO from mount(2).
*
* Returns: 0 on success, negative number in case of error.
*/
/**
* mnt_context_set_cache:
* @cxt: mount context
- * @cache: cache instance or nULL
+ * @cache: cache instance or NULL
*
* The mount context maintains a private struct libmnt_cache by default. This
* function allows to overwrite the private cache with an external instance.
* mnt_context_set_passwd_cb:
* @cxt: mount context
* @get: callback to get password
- * @release: callback to release (delallocate) password
+ * @release: callback to release (deallocate) password
*
* Sets callbacks for encryption password (e.g encrypted loopdev). This
* function is deprecated (encrypted loops are no longer supported).
* interrupted by signal or signals have to be ignored when the lock is locked.
*
* The default behavior is to ignore all signals (except SIGALRM and
- * SIGTRAP for mtab udate) when the lock is locked. If this behavior
+ * SIGTRAP for mtab update) when the lock is locked. If this behavior
* is unacceptable, then use:
*
* lc = mnt_context_get_lock(cxt);
* @cxt: mount context
* @flags: returns MS_* mount flags
*
- * Converts mount options string to MS_* flags and bitewise-OR the result with
+ * Converts mount options string to MS_* flags and bitwise-OR the result with
* the already defined flags (see mnt_context_set_mflags()).
*
* Returns: 0 on success, negative number in case of error.
* @cxt: mount context
* @flags: returns mount flags
*
- * Converts mount options string to MNT_MS_* flags and bitewise-OR the result
+ * Converts mount options string to MNT_MS_* flags and bitwise-OR the result
* with the already defined flags (see mnt_context_set_user_mflags()).
*
* Returns: 0 on success, negative number in case of error.
}
if (argc == idx + 1)
- /* mount <mountpont>|<device> */
+ /* mount <mountpoint>|<device> */
mnt_context_set_target(cxt, argv[idx++]);
else if (argc == idx + 2) {
}
if (argc == idx + 1) {
- /* mount <mountpont>|<device> */
+ /* mount <mountpoint>|<device> */
mnt_context_set_target(cxt, argv[idx++]);
} else {
rc = -EINVAL;
}
if (argc == idx + 1)
- /* mount <mountpont>|<device> */
+ /* mount <mountpoint>|<device> */
mnt_context_set_target(cxt, argv[idx++]);
rc = mnt_context_prepare_mount(cxt);
* However, if you call mount.<type> as root, then the helper follows
* the command line. If there is (for example) "user,exec" in fstab,
* then we have to manually append the "exec" back to the options
- * string, bacause there is nothing like MS_EXEC (we only have
+ * string, because there is nothing like MS_EXEC (we only have
* MS_NOEXEC in mount flags and we don't care about the original
* mount string in libmount for VFS options).
*/
* stored in context->utab and deallocated by mnt_free_context().
*
* This function exists to avoid (if possible) /proc/self/mountinfo usage, so
- * don't use thigs like mnt_resolve_target(), mnt_context_get_mtab() etc here.
+ * don't use things like mnt_resolve_target(), mnt_context_get_mtab() etc here.
* See lookup_umount_fs() for more details.
*/
static int has_utab_entry(struct libmnt_context *cxt, const char *target)
* @fs: fstab/mtab/mountinfo entry pointer
*
* Merges all mount options (VFS, FS and userspace) to one options string
- * and returns the result. This function does not modigy @fs.
+ * and returns the result. This function does not modify @fs.
*
* Returns: pointer to string (can be freed by free(3)) or NULL in case of error.
*/
{ "locks", MNT_DEBUG_LOCKS, "mtab and utab locking" },
{ "loop", MNT_DEBUG_LOOP, "loop devices routines" },
{ "options", MNT_DEBUG_OPTIONS, "mount options parsing" },
- { "tab", MNT_DEBUG_TAB, "fstab, mtab, mounninfo routines" },
+ { "tab", MNT_DEBUG_TAB, "fstab, mtab, mountinfo routines" },
{ "update", MNT_DEBUG_UPDATE, "mtab, utab updates" },
{ "utils", MNT_DEBUG_UTILS, "misc library utils" },
{ "monitor", MNT_DEBUG_MONITOR, "mount tables monitor" },
*
* 1. create linkfile (e.g. /etc/mtab~.$PID)
* 2. link linkfile --> lockfile (e.g. /etc/mtab~.$PID --> /etc/mtab~)
- * 3. a) link() success: setups F_SETLK lock (see fcnlt(2))
+ * 3. a) link() success: setups F_SETLK lock (see fcntl(2))
* b) link() failed: wait (max 30s) on F_SETLKW lock, goto 2.
*
* Note that when the lock is used by mnt_update_table() interface then libmount
- * uses flock() for private library file /run/mount/utab. The fcnlt(2) is used only
+ * uses flock() for private library file /run/mount/utab. The fcntl(2) is used only
* for backwardly compatible stuff like /etc/mtab.
*
* Returns: 0 on success or negative number in case of error (-ETIMEOUT is case
*
* @mountflags: (see MS_* macros in linux/fs.h)
*
- * @mountdata: (usully a comma separated string of options)
+ * @mountdata: (usually a comma separated string of options)
*
* The libmount uses options-map(s) to describe mount options.
*
* MNT_LINUX_MAP - Linux kernel fs-independent mount options
* (usually MS_* flags, see linux/fs.h)
*
- * MNT_USERSPACE_MAP - userpace mount(8) specific mount options
+ * MNT_USERSPACE_MAP - userspace mount(8) specific mount options
* (e.g user=, _netdev, ...)
*
* Returns: static built-in libmount map.
* Deallocates the table. This function does not care about reference count. Don't
* use this function directly -- it's better to use use mnt_unref_table().
*
- * The table entries (filesystems) are unrefrenced by mnt_reset_table() and
+ * The table entries (filesystems) are unreferenced by mnt_reset_table() and
* cache by mnt_unref_cache().
*/
void mnt_free_table(struct libmnt_table *tb)
* same cache between more threads -- currently the cache does not provide any
* locking method.
*
- * This function increments cache reference counter. It's recomented to use
+ * This function increments cache reference counter. It's recommended to use
* mnt_unref_cache() after mnt_table_set_cache() if you want to keep the cache
* referenced by @tb only.
*
* backward mode iterator).
*
* @MNT_UNIQ_FORWARD: remove later mounted filesystems
- * @MNT_UNIQ_KEEPTREE: keep parent->id relation ship stil valid
+ * @MNT_UNIQ_KEEPTREE: keep parent->id relationship still valid
*
* Returns: negative number in case of error, or 0 o success.
*/
return fs;
}
- /* non-canonicaled path in struct libmnt_table
+ /* non-canonical path in struct libmnt_table
* -- note that mountpoint in /proc/self/mountinfo is already
* canonicalized by the kernel
*/
rc = __mnt_fs_set_source_ptr(fs, real);
} else if (rc == 1) {
- /* mnt_guess_system_root() returns 1 if not able to conver to
+ /* mnt_guess_system_root() returns 1 if not able to convert to
* the real devname; ignore this problem */
rc = 0;
}
assert(tb);
if (filename)
- DBG(TAB, ul_debugobj(tb, "%s reuested as mtab", filename));
+ DBG(TAB, ul_debugobj(tb, "%s requested as mtab", filename));
#ifdef USE_LIBMOUNT_SUPPORT_MTAB
if (mnt_has_regular_mtab(&filename, NULL)) {
}
/*
- * Search for @name kernel command parametr.
+ * Search for @name kernel command parameter.
*
* Returns newly allocated string with a parameter argument if the @name is
* specified as "name=" or returns pointer to @name or returns NULL if not
return;
fail:
scols_unref_table(tb);
- err(EXIT_FAILURE, "faild to create output columns");
+ err(EXIT_FAILURE, "failed to create output columns");
}
static struct libscols_line *add_line(struct libscols_table *tb, size_t i)
return ln;
fail:
scols_unref_table(tb);
- err(EXIT_FAILURE, "faild to create output line");
+ err(EXIT_FAILURE, "failed to create output line");
}
int main(int argc, char *argv[])
tb = scols_new_table();
if (!tb)
- err(EXIT_FAILURE, "faild to create output table");
+ err(EXIT_FAILURE, "failed to create output table");
setup_columns(tb);
gettimeofday(&last, NULL);
return;
fail:
scols_unref_table(tb);
- err(EXIT_FAILURE, "faild to create output columns");
+ err(EXIT_FAILURE, "failed to create output columns");
}
static void add_line(struct libscols_table *tb, const char *name, const char *data)
return;
fail:
scols_unref_table(tb);
- err(EXIT_FAILURE, "faild to create output line");
+ err(EXIT_FAILURE, "failed to create output line");
}
int main(int argc, char *argv[])
tb = scols_new_table();
if (!tb)
- err(EXIT_FAILURE, "faild to create output table");
+ err(EXIT_FAILURE, "failed to create output table");
scols_table_enable_colors(tb, 1);
setup_columns(tb);
return;
fail:
scols_unref_table(tb);
- err(EXIT_FAILURE, "faild to create output columns");
+ err(EXIT_FAILURE, "failed to create output columns");
}
/* add a new line to @tb, the content is based on @st */
return -1;
}
-/* read all entrines from directory addressed by @fd */
+/* read all entries from directory addressed by @fd */
static int add_children(struct libscols_table *tb,
struct libscols_line *ln,
int fd)
tb = scols_new_table();
if (!tb)
- err(EXIT_FAILURE, "faild to create output table");
+ err(EXIT_FAILURE, "failed to create output table");
while((c = getopt_long(argc, argv, "ciJlnprS:E:", longopts, NULL)) != -1) {
switch(c) {
return;
fail:
scols_unref_table(tb);
- err(EXIT_FAILURE, "faild to create output columns");
+ err(EXIT_FAILURE, "failed to create output columns");
}
static char *gen_text(const char *prefix, const char *sub_prefix, char *buf, size_t sz)
return ln;
fail:
scols_unref_table(tb);
- err(EXIT_FAILURE, "faild to create output line");
+ err(EXIT_FAILURE, "failed to create output line");
}
int main(int argc, char *argv[])
tb = scols_new_table();
if (!tb)
- err(EXIT_FAILURE, "faild to create output table");
+ err(EXIT_FAILURE, "failed to create output table");
scols_table_enable_colors(tb, 1);
setup_columns(tb);
unsigned int ascii :1, /* don't use unicode */
colors_wanted :1, /* enable colors */
is_term :1, /* isatty() */
- maxout :1, /* maximalize output */
+ maxout :1, /* maximize output */
header_printed :1, /* header already printed */
no_headings :1, /* don't print header */
no_linesep :1, /* don't print line separator */
* @sb: a pointer to a struct libscols_symbols instance
* @str: a string which will represent the symbols which wraps title output
*
- * The current implemetation uses only the first byte from the padding string.
+ * The current implementation uses only the first byte from the padding string.
* A multibyte chars are not supported yet.
*
* Returns: 0, a negative value in case of an error.
* scols_copy_symbols:
* @sb: a pointer to a struct libscols_symbols instance
*
- * Returns: a newly allocated copy of the @sb symbol group or NULL in caes of an error.
+ * Returns: a newly allocated copy of the @sb symbol group or NULL in case of an error.
*/
struct libscols_symbols *scols_copy_symbols(const struct libscols_symbols *sb)
{
*
* Copyright (C) 2010-2014 Karel Zak <kzak@redhat.com>
* Copyright (C) 2014 Ondrej Oprala <ooprala@redhat.com>
- * Copytight (C) 2016 Igor Gnatenko <i.gnatenko.brain@gmail.com>
+ * Copyright (C) 2016 Igor Gnatenko <i.gnatenko.brain@gmail.com>
*
* This file may be redistributed under the terms of the
* GNU Lesser General Public License.
* If necessary then libsmartcols use all terminal width, the @reduce setting
* provides extra space (for example for borders in ncurses applications).
*
- * The @reduce must be smaller than terminal width, otherwise it's sillently
+ * The @reduce must be smaller than terminal width, otherwise it's silently
* ignored. The reduction is not applied when STDOUT_FILENO is not terminal.
*
* Returns: 0, a negative value in case of an error.
* @tb: table
* @enable: 1 or 0
*
- * Enable/disable line separator printing. This is usefull if you want to
+ * Enable/disable line separator printing. This is useful if you want to
* re-printing the same line more than once (e.g. progress bar). Don't use it
* if you're not sure.
*
return 0;
}
-/* print padding or asci-art instead of data of @cl */
+/* print padding or ASCII-art instead of data of @cl */
static void print_empty_cell(struct libscols_table *tb,
struct libscols_column *cl,
struct libscols_line *ln, /* optional */
{
size_t len_pad = 0; /* in screen cells as opposed to bytes */
- /* generate tree asci-art rather than padding */
+ /* generate tree ASCII-art rather than padding */
if (ln && scols_column_is_tree(cl)) {
if (!ln->parent) {
/* only print symbols->vert if followed by child */
}
/*
- * This is core of the scols_* voodo...
+ * This is core of the scols_* voodoo...
*/
static int recount_widths(struct libscols_table *tb, struct libscols_buffer *buf)
{
if (!cl->is_extreme)
continue;
- /* this column is tooo large, ignore?
+ /* this column is too large, ignore?
if (cl->width_max - cl->width >
(tb->termwidth - width))
continue;
if (cl->width == cl->width_min)
continue;
- DBG(TAB, ul_debugobj(tb, " tring to reduce: %s (width=%zu)", cl->header.data, cl->width));
+ DBG(TAB, ul_debugobj(tb, " trying to reduce: %s (width=%zu)", cl->header.data, cl->width));
/* truncate column with relative sizes */
if (cl->width_hint < 1 && cl->width > 0 && width > 0 &&
return sz;
}
-static int initialize_printting(struct libscols_table *tb, struct libscols_buffer **buf)
+static int initialize_printing(struct libscols_table *tb, struct libscols_buffer **buf)
{
size_t bufsz, extra_bufsz = 0;
struct libscols_line *ln;
struct libscols_iter itr;
int rc;
- DBG(TAB, ul_debugobj(tb, "initialize printting"));
+ DBG(TAB, ul_debugobj(tb, "initialize printing"));
if (!tb->symbols)
scols_table_set_symbols(tb, NULL); /* use default */
/**
* scola_table_print_range:
* @tb: table
- * @start: first printed line or NULL to print from the beggin of the table
+ * @start: first printed line or NULL to print from the begin of the table
* @end: last printed line or NULL to print all from start.
*
* If the start is the first line in the table than prints table header too.
DBG(TAB, ul_debugobj(tb, "printing range"));
- rc = initialize_printting(tb, &buf);
+ rc = initialize_printing(tb, &buf);
if (rc)
return rc;
DBG(TAB, ul_debugobj(tb, "printing"));
if (list_empty(&tb->tb_lines)) {
- DBG(TAB, ul_debugobj(tb, "ignore -- epmty table"));
+ DBG(TAB, ul_debugobj(tb, "ignore -- empty table"));
return 0;
}
tb->header_printed = 0;
- rc = initialize_printting(tb, &buf);
+ rc = initialize_printing(tb, &buf);
if (rc)
return rc;
static void process_wtmp_file(const struct last_control *ctl,
const char *filename)
{
- FILE *fp; /* Filepointer of wtmp file */
+ FILE *fp; /* File pointer of wtmp file */
struct utmp ut; /* Current utmp entry */
struct utmplist *ulist = NULL; /* All entries */
break;
default:
- warnx("unrecogized ut_type: %d", ut.ut_type);
+ warnx("unrecognized ut_type: %d", ut.ut_type);
}
/*
}
/*
- * Reads the currect terminal path and initializes cxt->tty_* variables.
+ * Reads the current terminal path and initializes cxt->tty_* variables.
*/
static void init_tty(struct login_context *cxt)
{
tcsetattr(0, TCSANOW, &ttt);
/*
- * Let's close file decriptors before vhangup
+ * Let's close file descriptors before vhangup
* https://lkml.org/lkml/2012/6/5/145
*/
close(STDIN_FILENO);
}
if (groups) {
- /* FIXME: this might lead to duplicit entries, although not visible
+ /* FIXME: this might lead to duplicate entries, although not visible
* in output, crunching a user's info multiple times is very redundant */
while ((g = strtok(groups, ","))) {
n = 0;
(setting argv[0] to "-su", passing -c only to certain shells, etc.).
I don't see the point in doing that, and it's ugly.
- Based on an implemenation by David MacKenzie <djm@gnu.ai.mit.edu>. */
+ Based on an implementation by David MacKenzie <djm@gnu.ai.mit.edu>. */
enum
{
#ifdef __linux__
console:
/*
- * Detection of devices used for Linux system consolei using
+ * Detection of devices used for Linux system console using
* the /proc/consoles API with kernel 2.6.38 and higher.
*/
rc = detect_consoles_from_proc(consoles);
warnx(_("%s: no entry for root"), _PATH_SHADOW_PASSWD);
*pwd.pw_passwd = '\0';
}
- /* locked accont passwords are valid too */
+ /* locked account passwords are valid too */
if (!locked_account_password(pwd.pw_passwd) && !valid(pwd.pw_passwd)) {
warnx(_("%s: root password garbled"), _PATH_SHADOW_PASSWD);
*pwd.pw_passwd = '\0';
reconnect = detect_consoles(tty, STDIN_FILENO, &consoles);
/*
- * If previous stdin was not the speified tty and therefore reconnected
+ * If previous stdin was not the specified tty and therefore reconnected
* to the specified tty also reconnect stdout and stderr.
*/
if (reconnect) {
rc = blkid_do_fullprobe(pr);
if (rc < 0)
- return rc; /* -1 = error, 1 = nothing, 0 = succes */
+ return rc; /* -1 = error, 1 = nothing, 0 = success */
if (blkid_probe_lookup_value(pr, "PTTYPE", NULL, NULL) == 0)
return 0; /* partition table detected */
*
* 2000-09-01 Michael Charles Pruznick <dummy@netwiz.net>
* Added "-3" option to print prev/next month with current.
- * Added over-ridable default MONTHS_IN_ROW and "-1" option to
+ * Added overridable default MONTHS_IN_ROW and "-1" option to
* get traditional output when -3 is the default. I hope that
* enough people will like -3 as the default that one day the
* product can be shipped that way.
struct cal_control {
const char *full_month[MONTHS_IN_YEAR]; /* month names */
int colormode; /* day and week number highlight */
- int num_months; /* number of requested mounths */
+ int num_months; /* number of requested monts */
int span_months; /* span the date */
int months_in_row; /* number of months horizontally in print out */
int weekstart; /* day the week starts, often Sun or Mon */
} else if (is_mount_compatible_mode()) {
/*
- * Look up for FS in the same way how mount(8) searchs in fstab
+ * Look up for FS in the same way how mount(8) searches in fstab
*
* findmnt -f <spec>
*/
tb = tb_new;
tb_new = tmp;
- /* remove allredy printed lines to reduce memory usage */
+ /* remove already printed lines to reduce memory usage */
scols_table_remove_lines(table);
mnt_reset_table(tb_new);
/* whole tree */
rc = create_treenode(table, tb, NULL, NULL);
} else {
- /* whole lits of sub-tree */
+ /* whole list of sub-tree */
rc = add_matching_lines(tb, table, direction);
if (rc != 0
* 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
* - added Native Language Support
*
- * 1999-11-13 aeb Accept signal numers 128+s.
+ * 1999-11-13 aeb Accept signal numbers 128+s.
*
* Copyright (C) 2014 Sami Kerola <kerolasa@iki.fi>
* Copyright (C) 2014 Karel Zak <kzak@redhat.com>
if (!strncasecmp(sig, "rt", 2))
return rtsig_to_signum(sig + 2);
#endif
- /* Normal sugnals */
+ /* Normal signals */
for (n = 0; n < ARRAY_SIZE(sys_signame); n++) {
if (!strcasecmp(sys_signame[n].name, sig))
return sys_signame[n].val;
unsigned int
unix_socket_errors:1, /* whether to report or not errors */
noact:1, /* do not write to sockets */
- prio_prefix:1, /* read priority from intput */
+ prio_prefix:1, /* read priority from input */
stderr_printout:1, /* output message to stderr */
rfc5424_time:1, /* include time stamp */
rfc5424_tq:1, /* include time quality markup */
sd = get_reserved_structured_data(ctl);
- /* time quality structured data (maybe overwriten by --sd-id timeQuality) */
+ /* time quality structured data (maybe overwritten by --sd-id timeQuality) */
if (ctl->rfc5424_tq && !has_structured_data_id(sd, "timeQuality")) {
add_structured_data_id(sd, "timeQuality");
char *fstype; /* detected fs, NULL or "?" if cannot detect */
char *uuid; /* filesystem UUID (or stack uuid) */
char *label; /* filesystem label */
- char *parttype; /* partiton type UUID */
+ char *parttype; /* partition type UUID */
char *partuuid; /* partition UUID */
- char *partlabel; /* partiton label */
+ char *partlabel; /* partition label */
char *partflags; /* partition flags */
char *wwn; /* storage WWN */
char *serial; /* disk serial number */
assert(ARRAY_SIZE(excludes) > nexcludes);
if (!nexcludes)
- return 0; /* filter not enabled, device not exluded */
+ return 0; /* filter not enabled, device not excluded */
for (i = 0; i < nexcludes; i++) {
if (excludes[i] == maj) {
mnt_table_parse_mtab(mtab, NULL);
}
- /* Note that maj:min in /proc/self/mouninfo does not have to match with
+ /* Note that maj:min in /proc/self/mountinfo does not have to match with
* devno as returned by stat(), so we have to try devname too
*/
fs = mnt_table_find_devno(mtab, makedev(cxt->maj, cxt->min), MNT_ITER_BACKWARD);
DBG(CXT, ul_debugobj(cxt, "%s: %s: dependence is whole-disk",
cxt->name, d->d_name));
/* For inverse tree we don't want to show partitions
- * if the dependence is pn whle-disk */
+ * if the dependence is on whole-disk */
process_blkdev(&dep, cxt, lsblk->inverse ? 0 : 1, NULL);
}
reset_blkdev_cxt(&dep);
int do_partitions, const char *part_name)
{
if (do_partitions && cxt->npartitions)
- list_partitions(cxt, parent, part_name); /* partitoins + whole-disk */
+ list_partitions(cxt, parent, part_name); /* partitions + whole-disk */
else
fill_table_line(cxt, parent ? parent->scols_line : NULL); /* whole-disk only */
* Copyright (C) 2012 Davidlohr Bueso <dave@gnu.org>
*
* Very generally based on lslk(8) by Victor A. Abell <abe@purdue.edu>
- * Since it stopped being maingained over a decade ago, this
+ * Since it stopped being maintained over a decade ago, this
* program should be considered its replacement.
*
* This program is free software; you can redistribute it and/or modify
}
if (ncreated != nthreads)
- fprintf(stderr, "%d: %zu threads not craeted and ~%zu objects will be ignored\n",
+ fprintf(stderr, "%d: %zu threads not created and ~%zu objects will be ignored\n",
proc->pid, nthreads - ncreated,
(nthreads - ncreated) * nobjects);
warn(_("poll failed"));
all_done(uuidd_cxt, EXIT_FAILURE);
}
- if (ret == 0) { /* truen when poll() times out */
+ if (ret == 0) { /* true when poll() times out */
if (uuidd_cxt->debug)
fprintf(stderr, _("timeout [%d sec]\n"), uuidd_cxt->timeout),
all_done(uuidd_cxt, EXIT_SUCCESS);
/*
* sys/syslog.h uses (f << 3) for all facility codes.
- * We want to use the codes as array idexes, so shift back...
+ * We want to use the codes as array indexes, so shift back...
*
* Note that libc LOG_FAC() macro returns the base codes, not the
* shifted code :-)
break;
}
- /* well, sometimes the messges contains important keywords, but in
+ /* well, sometimes the messages contains important keywords, but in
* non-warning/error messages
*/
if (id < 0 && memmem(mesg, mesgsz, "segfault at", 11))
* <name> ::= case-insensitive text
*
* Note that @len argument is not set when parsing "-n <level>" command line
- * option. The console_level is intepreted as "log level less than the value".
+ * option. The console_level is interpreted as "log level less than the value".
*
* For example "dmesg -n 8" or "dmesg -n debug" enables debug console log
* level by klogctl(SYSLOG_ACTION_CONSOLE_LEVEL, NULL, 8). The @str argument
/*
* /dev/kmsg record format:
*
- * faclev,seqnum,timestamp[optional, ...];messgage\n
+ * faclev,seqnum,timestamp[optional, ...];message\n
* TAGNAME=value
* ...
*
rec->mesg_size = p - rec->mesg;
/*
- * Kernel escapes non-printable characters, unfortuately kernel
+ * Kernel escapes non-printable characters, unfortunately kernel
* definition of "non-printable" is too strict. On UTF8 console we can
* print many chars, so let's decode from kernel.
*/
return 1;
/*
* This is tricky to read the info from sys/, because the queue
- * atrributes are provided for whole devices (disk) only. We're trying
+ * attributes are provided for whole devices (disk) only. We're trying
* to reuse the whole-disk sysfs context to optimize this stuff (as
* system usually have just one disk only).
*/
continue;
/* Is it really accessible mountpoint? Not all mountpoints are
- * accessible (maybe over mounted by another fylesystem) */
+ * accessible (maybe over mounted by another filesystem) */
path = mnt_get_mountpoint(tgt);
if (path && strcmp(path, tgt) == 0)
rc = 0;
* outb (0x0d, 0x70); // 0x0d: random read-only location
*
* Other docs state that "any write to 0x70 should be
- * followed by an action to 0x71 or the RTC wil be left in
+ * followed by an action to 0x71 or the RTC will be left in
* an unknown state". Most docs say that it doesn't matter at
* all what one does.
*/
&p->shm_ctim,
&p->shm_rss,
&p->shm_swp) < 14)
- continue; /* ivalid line, skipped */
+ continue; /* invalid line, skipped */
if (id > -1) {
/* ID specified */
int nsockets; /* number of all online sockets */
cpu_set_t **socketmaps; /* unique core_siblings */
- /* cores -- based on thread_siblings (internel kernel map of cpuX's
+ /* cores -- based on thread_siblings (internal kernel map of cpuX's
* hardware threads within the same core as cpuX) */
int ncores; /* number of all online cores */
cpu_set_t **coremaps; /* unique thread_siblings */
/*
* mountpoint(1) - see if a directory is a mountpoint
*
- * This is libmount based reimplementation of the mountpoit(1)
+ * This is libmount based reimplementation of the mountpoint(1)
* from sysvinit project.
*
*
* them. Do this in two passes, not entering the user
* namespace on the first pass. So if we're deprivileging the
* container we'll enter the user namespace last and if we're
- * privileging it then we enter the usernamespace first
+ * privileging it then we enter the user namespace first
* (because the initial setns will fail).
*/
for (pass = 0; pass < 2; pass ++) {
seconds = strtou32_or_err(optarg, _("invalid seconds argument"));
break;
case 't':
- /* alarm time, time_t (absolute, seconds since epoc) */
+ /* alarm time, time_t (absolute, seconds since epoch) */
alarm = strtou32_or_err(optarg, _("invalid time argument"));
break;
case OPT_DATE:
OPT_LIST
};
- /* Options --3gb and --4gb are for compatibitity with an old
+ /* Options --3gb and --4gb are for compatibility with an old
* Debian setarch implementation. */
static const struct option longopts[] = {
{"help", no_argument, NULL, 'h'},
#define CANONIC 1
/*
- * This function works like mnt_resolve_tag(), but it's able to read UUiD/LABEL
+ * This function works like mnt_resolve_tag(), but it's able to read UUID/LABEL
* from regular swap files too (according to entries in /proc/swaps). Note that
* mnt_resolve_tag() and mnt_resolve_spec() works with system visible block
* devices only.
if (prop.no_fail && access(device, R_OK) != 0) {
if (ctl->verbose)
- warnx(_("%s: unaccessible -- ignored"), device);
+ warnx(_("%s: inaccessible -- ignored"), device);
continue;
}
rc = mnt_context_find_umount_fs(cxt, spec, &fs);
if (rc == 1) {
- rc = MOUNT_EX_SUCCESS; /* alredy unmounted */
+ rc = MOUNT_EX_SUCCESS; /* already unmounted */
mnt_reset_context(cxt);
} else if (rc < 0) {
rc = mk_exit_code(cxt, rc); /* error */
if (!itr)
err(MOUNT_EX_SYSERR, _("libmount iterator allocation failed"));
- /* umount all childern */
+ /* umount all children */
for (;;) {
rc = mnt_table_next_child_fs(tb, itr, fs, &child);
if (rc < 0) {
goto done;
}
- /* Note that @fs is from mount context and the context will be reseted
+ /* Note that @fs is from mount context and the context will be reset
* after each umount() call */
devno = mnt_fs_get_devno(fs);
fs = NULL;
if (sysfs_init(&z->sysfs, devno, NULL))
return NULL;
if (*z->devname != '/') {
- /* cannonicalize the device name according to /sys */
+ /* canonicalize the device name according to /sys */
char name[PATH_MAX];
if (sysfs_get_devname(&z->sysfs, name, sizeof(name)))
snprintf(z->devname, sizeof(z->devname), "/dev/%s", name);
tcsetpgrp(STDIN_FILENO, getpid());
- /* Default is to follow the current line speend and then default to 9600 */
+ /* Default is to follow the current line speed and then default to 9600 */
if ((options.flags & F_VCONSOLE) == 0 && options.numspeed == 0) {
options.speeds[options.numspeed++] = bcode("9600");
options.flags |= F_KEEPSPEED;
log_err(_("failed to allocate memory: %m"));
if (p != str) {
- /* copy chars befor \u */
+ /* copy chars before \u */
memcpy(tp, str, p - str);
tp += p - str;
}
debug("TIOCNOTTY ioctl failed\n");
/*
- * Let's close all file decriptors before vhangup
+ * Let's close all file descriptors before vhangup
* https://lkml.org/lkml/2012/6/5/145
*/
close(fd);
/*
* Note that the speed is stored in the c_cflag termios field, so we have
- * set the speed always when the cflag se reseted.
+ * set the speed always when the cflag is reset.
*/
cfsetispeed(tp, ispeed);
cfsetospeed(tp, ospeed);
int opt_bl_min; /* blank screen */
int opt_blength_l; /* bell duration in milliseconds */
int opt_bfreq_f; /* bell frequency in Hz */
- int opt_sn_num; /* console number to be snapshoted */
+ int opt_sn_num; /* console number to be snapshot */
char *opt_sn_name; /* path to write snap */
char *in_device; /* device to snapshot */
- int opt_msglevel_num; /* printk() loging level */
+ int opt_msglevel_num; /* printk() logging level */
int opt_ps_mode; /* powersave mode */
int opt_pd_min; /* powerdown time */
int opt_rt_len; /* regular tab length */
rc = vsnprintf(bs->data + bs->used, limit, fmt, ap);
va_end(ap);
- if (rc >= 0 && (size_t) rc >= limit) { /* not enoght, enlarge */
+ if (rc >= 0 && (size_t) rc >= limit) { /* not enough, enlarge */
buf_enlarge(bs, (size_t)rc + 1);
limit = bs->sz - bs->used;
va_start(ap, fmt);
* Wed Jun 22 21:41:56 1994, faith@cs.unc.edu:
* Added fix from Mike Grupenhoff (kashmir@umiacs.umd.edu)
* Mon Jul 1 17:01:39 MET DST 1996, janl@math.uio.no:
- * - Added fix from David.Chapell@mail.trincoll.edu enabeling daemons
+ * - Added fix from David.Chapell@mail.trincoll.edu enabling daemons
* to use write.
* - ANSIed it since I was working on it anyway.
* 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
load original values
-maximalize kernel setting
+maximize kernel setting
check for difference between kernel and IPC
/proc/sys/kernel/shmmni OK
/proc/sys/kernel/shmall OK
SHM_ORG[$i]=$(cat ${IPCS_PROCFILES[$i]})
done >> $TS_OUTPUT
-ts_log "maximalize kernel setting"
+ts_log "maximize kernel setting"
for i in $IPCS_IDX; do
echo ${IPCS_LIMITS[$i]} >> ${IPCS_PROCFILES[$i]}
done >> $TS_OUTPUT
}
#ifdef HAVE_WIDECHAR
-/* Convert nonprintable characters to spaces in case MB_CUR_MAX > 1. */
+/* Convert non-printable characters to spaces in case MB_CUR_MAX > 1. */
static void makeprint_for_mb(char *s, size_t l)
{
char *t = s;
}
#endif
-/* Convert nonprintable characters to spaces. */
+/* Convert non-printable characters to spaces. */
static void makeprint(char *s, size_t l)
{
#ifdef HAVE_WIDECHAR
}
find = tmpfile();
if (fbuf == NULL || find == NULL) {
- warn(_("Cannot create tempfile"));
+ warn(_("Cannot create temporary file"));
quit(++exitstatus);
}
if (searchfor) {
/*
* Note that we use REVERSE for the alternate character set,
- * not the as/ae capabilities. This is because we are modelling
+ * not the as/ae capabilities. This is because we are modeling
* the model 37 teletype (since that's what nroff outputs) and
* the typical as/ae is more of a graphics set, not the greek
* letters the 37 has.
projects / thirdparty / util-linux.git / commitdiff
