+5 -5

fs/ocfs2/alloc.c

reviewed

··· 566 566 struct ocfs2_path *path, 567 567 struct ocfs2_extent_rec *insert_rec); 568 568 /* 569 569 - * Reset the actual path elements so that we can re-use the structure 569 569 + * Reset the actual path elements so that we can reuse the structure 570 570 * to build another path. Generally, this involves freeing the buffer 571 571 * heads. 572 572 */ ··· 1182 1182 1183 1183 /* 1184 1184 * If there is a gap before the root end and the real end 1185 1185 - * of the righmost leaf block, we need to remove the gap 1185 1185 + * of the rightmost leaf block, we need to remove the gap 1186 1186 * between new_cpos and root_end first so that the tree 1187 1187 * is consistent after we add a new branch(it will start 1188 1188 * from new_cpos). ··· 1238 1238 1239 1239 /* Note: new_eb_bhs[new_blocks - 1] is the guy which will be 1240 1240 * linked with the rest of the tree. 1241 1241 - * conversly, new_eb_bhs[0] is the new bottommost leaf. 1241 1241 + * conversely, new_eb_bhs[0] is the new bottommost leaf. 1242 1242 * 1243 1243 * when we leave the loop, new_last_eb_blk will point to the 1244 1244 * newest leaf, and next_blkno will point to the topmost extent ··· 3712 3712 * update split_index here. 3713 3713 * 3714 3714 * When the split_index is zero, we need to merge it to the 3715 3715 - * prevoius extent block. It is more efficient and easier 3715 3715 + * previous extent block. It is more efficient and easier 3716 3716 * if we do merge_right first and merge_left later. 3717 3717 */ 3718 3718 ret = ocfs2_merge_rec_right(path, handle, et, split_rec, ··· 4517 4517 } 4518 4518 4519 4519 /* 4520 4520 - * This should only be called against the righmost leaf extent list. 4520 4520 + * This should only be called against the rightmost leaf extent list. 4521 4521 * 4522 4522 * ocfs2_figure_appending_type() will figure out whether we'll have to 4523 4523 * insert at the tail of the rightmost leaf.

+1 -1

fs/ocfs2/aops.c

reviewed

··· 305 305 } 306 306 307 307 /* 308 308 - * i_size might have just been updated as we grabed the meta lock. We 308 308 + * i_size might have just been updated as we grabbed the meta lock. We 309 309 * might now be discovering a truncate that hit on another node. 310 310 * block_read_full_folio->get_block freaks out if it is asked to read 311 311 * beyond the end of a file, so we check here. Callers

+1 -1

fs/ocfs2/cluster/heartbeat.c

reviewed

··· 1020 1020 if (list_empty(&slot->ds_live_item)) 1021 1021 goto out; 1022 1022 1023 1023 - /* live nodes only go dead after enough consequtive missed 1023 1023 + /* live nodes only go dead after enough consecutive missed 1024 1024 * samples.. reset the missed counter whenever we see 1025 1025 * activity */ 1026 1026 if (slot->ds_equal_samples >= o2hb_dead_threshold || gen_changed) {

+1 -1

fs/ocfs2/cluster/masklog.h

reviewed

··· 29 29 * just calling printk() so that this can eventually make its way through 30 30 * relayfs along with the debugging messages. Everything else gets KERN_DEBUG. 31 31 * The inline tests and macro dance give GCC the opportunity to quite cleverly 32 32 - * only emit the appropriage printk() when the caller passes in a constant 32 32 + * only emit the appropriate printk() when the caller passes in a constant 33 33 * mask, as is almost always the case. 34 34 * 35 35 * All this bitmask nonsense is managed from the files under

+3 -3

fs/ocfs2/cluster/quorum.c

reviewed

··· 23 23 * race between when we see a node start heartbeating and when we connect 24 24 * to it. 25 25 * 26 26 - * So nodes that are in this transtion put a hold on the quorum decision 26 26 + * So nodes that are in this transition put a hold on the quorum decision 27 27 * with a counter. As they fall out of this transition they drop the count 28 28 * and if they're the last, they fire off the decision. 29 29 */ ··· 189 189 } 190 190 191 191 /* as a node comes up we delay the quorum decision until we know the fate of 192 192 - * the connection. the hold will be droped in conn_up or hb_down. it might be 192 192 + * the connection. the hold will be dropped in conn_up or hb_down. it might be 193 193 * perpetuated by con_err until hb_down. if we already have a conn, we might 194 194 * be dropping a hold that conn_up got. */ 195 195 void o2quo_hb_up(u8 node) ··· 256 256 } 257 257 258 258 /* This is analogous to hb_up. as a node's connection comes up we delay the 259 259 - * quorum decision until we see it heartbeating. the hold will be droped in 259 259 + * quorum decision until we see it heartbeating. the hold will be dropped in 260 260 * hb_up or hb_down. it might be perpetuated by con_err until hb_down. if 261 261 * it's already heartbeating we might be dropping a hold that conn_up got. 262 262 * */

+4 -4

fs/ocfs2/cluster/tcp.c

reviewed

··· 5 5 * 6 6 * ---- 7 7 * 8 8 - * Callers for this were originally written against a very simple synchronus 8 8 + * Callers for this were originally written against a very simple synchronous 9 9 * API. This implementation reflects those simple callers. Some day I'm sure 10 10 * we'll need to move to a more robust posting/callback mechanism. 11 11 * 12 12 * Transmit calls pass in kernel virtual addresses and block copying this into 13 13 * the socket's tx buffers via a usual blocking sendmsg. They'll block waiting 14 14 - * for a failed socket to timeout. TX callers can also pass in a poniter to an 14 14 + * for a failed socket to timeout. TX callers can also pass in a pointer to an 15 15 * 'int' which gets filled with an errno off the wire in response to the 16 16 * message they send. 17 17 * ··· 101 101 * o2net_wq. teardown detaches the callbacks before destroying the workqueue. 102 102 * quorum work is queued as sock containers are shutdown.. stop_listening 103 103 * tears down all the node's sock containers, preventing future shutdowns 104 104 - * and queued quroum work, before canceling delayed quorum work and 104 104 + * and queued quorum work, before canceling delayed quorum work and 105 105 * destroying the work queue. 106 106 */ 107 107 static struct workqueue_struct *o2net_wq; ··· 1419 1419 return ret; 1420 1420 } 1421 1421 1422 1422 - /* this work func is triggerd by data ready. it reads until it can read no 1422 1422 + /* this work func is triggered by data ready. it reads until it can read no 1423 1423 * more. it interprets 0, eof, as fatal. if data_ready hits while we're doing 1424 1424 * our work the work struct will be marked and we'll be called again. */ 1425 1425 static void o2net_rx_until_empty(struct work_struct *work)

+1 -1

fs/ocfs2/dlm/dlmapi.h

reviewed

··· 118 118 #define LKM_VALBLK 0x00000100 /* lock value block request */ 119 119 #define LKM_NOQUEUE 0x00000200 /* non blocking request */ 120 120 #define LKM_CONVERT 0x00000400 /* conversion request */ 121 121 - #define LKM_NODLCKWT 0x00000800 /* this lock wont deadlock (U) */ 121 121 + #define LKM_NODLCKWT 0x00000800 /* this lock won't deadlock (U) */ 122 122 #define LKM_UNLOCK 0x00001000 /* deallocate this lock */ 123 123 #define LKM_CANCEL 0x00002000 /* cancel conversion request */ 124 124 #define LKM_DEQALL 0x00004000 /* remove all locks held by proc (U) */

+3 -3

fs/ocfs2/dlm/dlmrecovery.c

reviewed

··· 207 207 * 1) all recovery threads cluster wide will work on recovering 208 208 * ONE node at a time 209 209 * 2) negotiate who will take over all the locks for the dead node. 210 210 - * thats right... ALL the locks. 210 210 + * that's right... ALL the locks. 211 211 * 3) once a new master is chosen, everyone scans all locks 212 212 * and moves aside those mastered by the dead guy 213 213 * 4) each of these locks should be locked until recovery is done ··· 1469 1469 * The first one is handled at the end of this function. The 1470 1470 * other two are handled in the worker thread after locks have 1471 1471 * been attached. Yes, we don't wait for purge time to match 1472 1472 - * kref_init. The lockres will still have atleast one ref 1472 1472 + * kref_init. The lockres will still have at least one ref 1473 1473 * added because it is in the hash __dlm_insert_lockres() */ 1474 1474 extra_refs++; 1475 1475 ··· 1735 1735 spin_unlock(&res->spinlock); 1736 1736 } 1737 1737 } else { 1738 1738 - /* put.. incase we are not the master */ 1738 1738 + /* put.. in case we are not the master */ 1739 1739 spin_unlock(&res->spinlock); 1740 1740 dlm_lockres_put(res); 1741 1741 }

+6 -6

fs/ocfs2/dlmglue.c

reviewed

··· 794 794 795 795 /* 796 796 * Keep a list of processes who have interest in a lockres. 797 797 - * Note: this is now only uesed for check recursive cluster locking. 797 797 + * Note: this is now only used for check recursive cluster locking. 798 798 */ 799 799 static inline void ocfs2_add_holder(struct ocfs2_lock_res *lockres, 800 800 struct ocfs2_lock_holder *oh) ··· 2532 2532 * locks while holding a page lock and the downconvert thread which 2533 2533 * blocks dlm lock acquiry while acquiring page locks. 2534 2534 * 2535 2535 - * ** These _with_page variantes are only intended to be called from aop 2535 2535 + * ** These _with_page variants are only intended to be called from aop 2536 2536 * methods that hold page locks and return a very specific *positive* error 2537 2537 * code that aop methods pass up to the VFS -- test for errors with != 0. ** 2538 2538 * ··· 2630 2630 } 2631 2631 2632 2632 /* 2633 2633 - * This _tracker variantes are introduced to deal with the recursive cluster 2633 2633 + * This _tracker variants are introduced to deal with the recursive cluster 2634 2634 * locking issue. The idea is to keep track of a lock holder on the stack of 2635 2635 * the current process. If there's a lock holder on the stack, we know the 2636 2636 * task context is already protected by cluster locking. Currently, they're ··· 2735 2735 struct ocfs2_lock_res *lockres; 2736 2736 2737 2737 lockres = &OCFS2_I(inode)->ip_inode_lockres; 2738 2738 - /* had_lock means that the currect process already takes the cluster 2738 2738 + /* had_lock means that the current process already takes the cluster 2739 2739 * lock previously. 2740 2740 * If had_lock is 1, we have nothing to do here. 2741 2741 * If had_lock is 0, we will release the lock. ··· 3802 3802 * set when the ast is received for an upconvert just before the 3803 3803 * OCFS2_LOCK_BUSY flag is cleared. Now if the fs received a bast 3804 3804 * on the heels of the ast, we want to delay the downconvert just 3805 3805 - * enough to allow the up requestor to do its task. Because this 3805 3805 + * enough to allow the up requester to do its task. Because this 3806 3806 * lock is in the blocked queue, the lock will be downconverted 3807 3807 - * as soon as the requestor is done with the lock. 3807 3807 + * as soon as the requester is done with the lock. 3808 3808 */ 3809 3809 if (lockres->l_flags & OCFS2_LOCK_UPCONVERT_FINISHING) 3810 3810 goto leave_requeue;

+2 -2

fs/ocfs2/inode.c

reviewed

··· 1122 1122 1123 1123 dquot_drop(inode); 1124 1124 1125 1125 - /* To preven remote deletes we hold open lock before, now it 1125 1125 + /* To prevent remote deletes we hold open lock before, now it 1126 1126 * is time to unlock PR and EX open locks. */ 1127 1127 ocfs2_open_unlock(inode); 1128 1128 ··· 1437 1437 * Call ocfs2_validate_meta_ecc() first since it has ecc repair 1438 1438 * function, but we should not return error immediately when ecc 1439 1439 * validation fails, because the reason is quite likely the invalid 1440 1440 - * inode number inputed. 1440 1440 + * inode number inputted. 1441 1441 */ 1442 1442 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &di->i_check); 1443 1443 if (rc) {

+1 -1

fs/ocfs2/ioctl.c

reviewed

··· 796 796 /* 797 797 * OCFS2_IOC_INFO handles an array of requests passed from userspace. 798 798 * 799 799 - * ocfs2_info_handle() recevies a large info aggregation, grab and 799 799 + * ocfs2_info_handle() receives a large info aggregation, grab and 800 800 * validate the request count from header, then break it into small 801 801 * pieces, later specific handlers can handle them one by one. 802 802 *

+1 -1

fs/ocfs2/journal.c

reviewed

··· 1956 1956 1957 1957 /* 1958 1958 * Scan timer should get fired every ORPHAN_SCAN_SCHEDULE_TIMEOUT. Add some 1959 1959 - * randomness to the timeout to minimize multple nodes firing the timer at the 1959 1959 + * randomness to the timeout to minimize multiple nodes firing the timer at the 1960 1960 * same time. 1961 1961 */ 1962 1962 static inline unsigned long ocfs2_orphan_scan_timeout(void)

+4 -4

fs/ocfs2/move_extents.c

reviewed

··· 492 492 bg = (struct ocfs2_group_desc *)gd_bh->b_data; 493 493 494 494 /* 495 495 - * moving goal is not allowd to start with a group desc blok(#0 blk) 495 495 + * moving goal is not allowed to start with a group desc blok(#0 blk) 496 496 * let's compromise to the latter cluster. 497 497 */ 498 498 if (range->me_goal == le64_to_cpu(bg->bg_blkno)) ··· 658 658 659 659 /* 660 660 * probe the victim cluster group to find a proper 661 661 - * region to fit wanted movement, it even will perfrom 661 661 + * region to fit wanted movement, it even will perform 662 662 * a best-effort attempt by compromising to a threshold 663 663 * around the goal. 664 664 */ ··· 920 920 } 921 921 922 922 /* 923 923 - * rememer ip_xattr_sem also needs to be held if necessary 923 923 + * remember ip_xattr_sem also needs to be held if necessary 924 924 */ 925 925 down_write(&OCFS2_I(inode)->ip_alloc_sem); 926 926 ··· 1022 1022 context->range = ⦥ 1023 1023 1024 1024 /* 1025 1025 - * ok, the default theshold for the defragmentation 1025 1025 + * ok, the default threshold for the defragmentation 1026 1026 * is 1M, since our maximum clustersize was 1M also. 1027 1027 * any thought? 1028 1028 */

+4 -4

fs/ocfs2/ocfs2_fs.h

reviewed

··· 132 132 * well as the name of the cluster being joined. 133 133 * mount.ocfs2 must pass in a matching stack name. 134 134 * 135 135 - * If not set, the classic stack will be used. This is compatbile with 135 135 + * If not set, the classic stack will be used. This is compatible with 136 136 * all older versions. 137 137 */ 138 138 #define OCFS2_FEATURE_INCOMPAT_USERSPACE_STACK 0x0080 ··· 143 143 /* Support for extended attributes */ 144 144 #define OCFS2_FEATURE_INCOMPAT_XATTR 0x0200 145 145 146 146 - /* Support for indexed directores */ 146 146 + /* Support for indexed directories */ 147 147 #define OCFS2_FEATURE_INCOMPAT_INDEXED_DIRS 0x0400 148 148 149 149 /* Metadata checksum and error correction */ ··· 156 156 #define OCFS2_FEATURE_INCOMPAT_DISCONTIG_BG 0x2000 157 157 158 158 /* 159 159 - * Incompat bit to indicate useable clusterinfo with stackflags for all 159 159 + * Incompat bit to indicate usable clusterinfo with stackflags for all 160 160 * cluster stacks (userspace adnd o2cb). If this bit is set, 161 161 * INCOMPAT_USERSPACE_STACK becomes superfluous and thus should not be set. 162 162 */ ··· 1083 1083 struct ocfs2_xattr_header xb_header; /* xattr header if this 1084 1084 block contains xattr */ 1085 1085 struct ocfs2_xattr_tree_root xb_root;/* xattr tree root if this 1086 1086 - block cotains xattr 1086 1086 + block contains xattr 1087 1087 tree. */ 1088 1088 } xb_attrs; 1089 1089 };

+1 -1

fs/ocfs2/ocfs2_ioctl.h

reviewed

··· 215 215 movement less likely 216 216 to fail, may make fs 217 217 even more fragmented */ 218 218 - #define OCFS2_MOVE_EXT_FL_COMPLETE (0x00000004) /* Move or defragmenation 218 218 + #define OCFS2_MOVE_EXT_FL_COMPLETE (0x00000004) /* Move or defragmentation 219 219 completely gets done. 220 220 */ 221 221

+1 -1

fs/ocfs2/ocfs2_lockid.h

reviewed

··· 93 93 [OCFS2_LOCK_TYPE_DATA] = "Data", 94 94 [OCFS2_LOCK_TYPE_SUPER] = "Super", 95 95 [OCFS2_LOCK_TYPE_RENAME] = "Rename", 96 96 - /* Need to differntiate from [R]ename.. serializing writes is the 96 96 + /* Need to differentiate from [R]ename.. serializing writes is the 97 97 * important job it does, anyway. */ 98 98 [OCFS2_LOCK_TYPE_RW] = "Write/Read", 99 99 [OCFS2_LOCK_TYPE_DENTRY] = "Dentry",

+3 -3

fs/ocfs2/refcounttree.c

reviewed

··· 2420 2420 * 2421 2421 * If we will insert a new one, this is easy and only happens 2422 2422 * during adding refcounted flag to the extent, so we don't 2423 2423 - * have a chance of spliting. We just need one record. 2423 2423 + * have a chance of splitting. We just need one record. 2424 2424 * 2425 2425 * If the refcount rec already exists, that would be a little 2426 2426 * complicated. we may have to: ··· 2610 2610 /* 2611 2611 * Calculate out the start and number of virtual clusters we need to CoW. 2612 2612 * 2613 2613 - * cpos is vitual start cluster position we want to do CoW in a 2613 2613 + * cpos is virtual start cluster position we want to do CoW in a 2614 2614 * file and write_len is the cluster length. 2615 2615 * max_cpos is the place where we want to stop CoW intentionally. 2616 2616 * 2617 2617 - * Normal we will start CoW from the beginning of extent record cotaining cpos. 2617 2617 + * Normal we will start CoW from the beginning of extent record containing cpos. 2618 2618 * We try to break up extents on boundaries of MAX_CONTIG_BYTES so that we 2619 2619 * get good I/O from the resulting extent tree. 2620 2620 */

+2 -2

fs/ocfs2/reservations.h

reviewed

··· 31 31 32 32 #define OCFS2_RESV_FLAG_INUSE 0x01 /* Set when r_node is part of a btree */ 33 33 #define OCFS2_RESV_FLAG_TMP 0x02 /* Temporary reservation, will be 34 34 - * destroyed immedately after use */ 34 34 + * destroyed immediately after use */ 35 35 #define OCFS2_RESV_FLAG_DIR 0x04 /* Reservation is for an unindexed 36 36 * directory btree */ 37 37 ··· 125 125 /** 126 126 * ocfs2_resmap_claimed_bits() - Tell the reservation code that bits were used. 127 127 * @resmap: reservations bitmap 128 128 - * @resv: optional reservation to recalulate based on new bitmap 128 128 + * @resv: optional reservation to recalculate based on new bitmap 129 129 * @cstart: start of allocation in clusters 130 130 * @clen: end of allocation in clusters. 131 131 *

+1 -1

fs/ocfs2/stack_o2cb.c

reviewed

··· 227 227 } 228 228 229 229 /* 230 230 - * o2dlm aways has a "valid" LVB. If the dlm loses track of the LVB 230 230 + * o2dlm always has a "valid" LVB. If the dlm loses track of the LVB 231 231 * contents, it will zero out the LVB. Thus the caller can always trust 232 232 * the contents. 233 233 */

+1 -1

fs/ocfs2/stackglue.h

reviewed

··· 210 210 struct file_lock *fl); 211 211 212 212 /* 213 213 - * This is an optoinal debugging hook. If provided, the 213 213 + * This is an optional debugging hook. If provided, the 214 214 * stack can dump debugging information about this lock. 215 215 */ 216 216 void (*dump_lksb)(struct ocfs2_dlm_lksb *lksb);

+1 -1

fs/ocfs2/super.c

reviewed

··· 1803 1803 osb = OCFS2_SB(sb); 1804 1804 BUG_ON(!osb); 1805 1805 1806 1806 - /* Remove file check sysfs related directores/files, 1806 1806 + /* Remove file check sysfs related directories/files, 1807 1807 * and wait for the pending file check operations */ 1808 1808 ocfs2_filecheck_remove_sysfs(osb); 1809 1809

+5 -5

fs/ocfs2/xattr.c

reviewed

··· 648 648 * 256(name) + 80(value) + 16(entry) = 352 bytes, 649 649 * The max space of acl xattr taken inline is 650 650 * 80(value) + 16(entry) * 2(if directory) = 192 bytes, 651 651 - * when blocksize = 512, may reserve one more cluser for 651 651 + * when blocksize = 512, may reserve one more cluster for 652 652 * xattr bucket, otherwise reserve one metadata block 653 653 * for them is ok. 654 654 * If this is a new directory with inline data, ··· 4371 4371 4372 4372 /* 4373 4373 * defrag a xattr bucket if we find that the bucket has some 4374 4374 - * holes beteen name/value pairs. 4374 4374 + * holes between name/value pairs. 4375 4375 * We will move all the name/value pairs to the end of the bucket 4376 4376 * so that we can spare some space for insertion. 4377 4377 */ ··· 5011 5011 * 2. If cluster_size == bucket_size: 5012 5012 * a) If the previous extent rec has more than one cluster and the insert 5013 5013 * place isn't in the last cluster, copy the entire last cluster to the 5014 5014 - * new one. This time, we don't need to upate the first_bh and header_bh 5014 5014 + * new one. This time, we don't need to update the first_bh and header_bh 5015 5015 * since they will not be moved into the new cluster. 5016 5016 * b) Otherwise, move the bottom half of the xattrs in the last cluster into 5017 5017 * the new one. And we set the extend flag to zero if the insert place is ··· 6189 6189 /* 6190 6190 * Given a xattr header and xe offset, 6191 6191 * return the proper xv and the corresponding bh. 6192 6192 - * xattr in inode, block and xattr tree have different implementaions. 6192 6192 + * xattr in inode, block and xattr tree have different implementations. 6193 6193 */ 6194 6194 typedef int (get_xattr_value_root)(struct super_block *sb, 6195 6195 struct buffer_head *bh, ··· 6269 6269 } 6270 6270 6271 6271 /* 6272 6272 - * Lock the meta_ac and caculate how much credits we need for reflink xattrs. 6272 6272 + * Lock the meta_ac and calculate how much credits we need for reflink xattrs. 6273 6273 * It is only used for inline xattr and xattr block. 6274 6274 */ 6275 6275 static int ocfs2_reflink_lock_xattr_allocators(struct ocfs2_super *osb,