libmount: fix typos

Signed-off-by: Ondrej Oprala <ooprala@redhat.com>

1 files changed, 15 insertions, 15 deletions

diff --git a/libmount/src/lock.c b/libmount/src/lock.c
index f381e423e..82086da24 100644
--- a/libmount/src/lock.c
+++ b/libmount/src/lock.c
@@ -10,9 +10,9 @@
  * @title: Locking
  * @short_description: locking methods for /etc/mtab or another libmount files
  *
- * The mtab lock is backwardly compatible with the standard linux /etc/mtab
+ * The mtab lock is backwards compatible with the standard linux /etc/mtab
  * locking.  Note, it's necessary to use the same locking schema in all
- * application that access the file.
+ * applications that access the file.
  */
 #include <sys/time.h>
 #include <time.h>
@@ -247,7 +247,7 @@ static void mnt_lockalrm_handler(int sig __attribute__((__unused__)))
 
 /*
  * Waits for F_SETLKW, unfortunately we have to use SIGALRM here to interrupt
- * fcntl() to avoid never ending waiting.
+ * fcntl() to avoid neverending waiting.
  *
  * Returns: 0 on success, 1 on timeout, -errno on error.
  */
@@ -293,7 +293,7 @@ static int mnt_wait_mtab_lock(struct libmnt_lock *ml, struct flock *fl, time_t m
  * soon as the lock file is deleted by the first mount, and immediately
  * afterwards a third mount comes, creates a new /etc/mtab~, applies
  * flock to that, and also proceeds, so that the second and third mount
- * now both are scribbling in /etc/mtab.
+ * are now both scribbling in /etc/mtab.
  *
  * The new code uses a link() instead of a creat(), where we proceed
  * only if it was us that created the lock, and hence we always have
@@ -308,13 +308,13 @@ static int mnt_wait_mtab_lock(struct libmnt_lock *ml, struct flock *fl, time_t m
  * The original mount locking code has used sleep(1) between attempts and
  * maximal number of attempts has been 5.
  *
- * There was very small number of attempts and extremely long waiting (1s)
+ * There was a very small number of attempts and extremely long waiting (1s)
  * that is useless on machines with large number of mount processes.
  *
- * Now we wait few thousand microseconds between attempts and we have a global
- * time limit (30s) rather than limit for number of attempts. The advantage
+ * Now we wait for a few thousand microseconds between attempts and we have a global
+ * time limit (30s) rather than a limit for the number of attempts. The advantage
  * is that this method also counts time which we spend in fcntl(F_SETLKW) and
- * number of attempts is not restricted.
+ * the number of attempts is not restricted.
  * -- kzak@redhat.com [Mar-2007]
  *
  *
@@ -327,7 +327,7 @@ static int mnt_wait_mtab_lock(struct libmnt_lock *ml, struct flock *fl, time_t m
  * -- kzak@redhat.com [May-2009]
  */
 
-/* maximum seconds between first and last attempt */
+/* maximum seconds between the first and the last attempt */
 #define MOUNTLOCK_MAXTIME		30
 
 /* sleep time (in microseconds, max=999999) between attempts */
@@ -340,9 +340,9 @@ static void unlock_mtab(struct libmnt_lock *ml)
 
 	if (!ml->locked && ml->lockfile && ml->linkfile)
 	{
-		/* We have (probably) all files, but we don't own the lock,
+		/* We (probably) have all the files, but we don't own the lock,
 		 * Really? Check it! Maybe ml->locked wasn't set properly
-		 * because code was interrupted by signal. Paranoia? Yes.
+		 * because the code was interrupted by a signal. Paranoia? Yes.
 		 *
 		 * We own the lock when linkfile == lockfile.
 		 */
@@ -492,10 +492,10 @@ failed:
  * mnt_lock_file
  * @ml: pointer to struct libmnt_lock instance
  *
- * Creates lock file (e.g. /etc/mtab~). Note that this function may
+ * Creates a lock file (e.g. /etc/mtab~). Note that this function may
  * use alarm().
  *
- * Your application has to always call mnt_unlock_file() before exit.
+ * Your application always has to call mnt_unlock_file() before exit.
  *
  * Traditional mtab locking scheme:
  *
@@ -522,7 +522,7 @@ int mnt_lock_file(struct libmnt_lock *ml)
  * mnt_unlock_file:
  * @ml: lock struct
  *
- * Unlocks the file. The function could be called independently on the
+ * Unlocks the file. The function could be called independently of the
  * lock status (for example from exit(3)).
  */
 void mnt_unlock_file(struct libmnt_lock *ml)
@@ -670,7 +670,7 @@ int test_lock(struct libmnt_test *ts, int argc, char *argv[])
 		mnt_free_lock(lock);
 		lock = NULL;
 
-		/* The mount command usually finish after mtab update. We
+		/* The mount command usually finishes after a mtab update. We
 		 * simulate this via short sleep -- it's also enough to make
 		 * concurrent processes happy.
 		 */