* Package: dev-util/wiggle-1.0  * Repository: gentoo  * Maintainer: robbat2@gentoo.org  * USE: abi_ppc_32 elibc_glibc kernel_linux ppc test userland_GNU  * FEATURES: network-sandbox preserve-libs sandbox test userpriv usersandbox >>> Unpacking source... >>> Unpacking wiggle-1.0.tar.gz to /var/tmp/portage/dev-util/wiggle-1.0/work >>> Source unpacked in /var/tmp/portage/dev-util/wiggle-1.0/work >>> Preparing source in /var/tmp/portage/dev-util/wiggle-1.0/work/wiggle-1.0 ... * Applying wiggle-1.0-cflags.patch ...  [ ok ] * Replacing obsolete head/tail with POSIX compliant ones * - fixed p >>> Source prepared. >>> Configuring source in /var/tmp/portage/dev-util/wiggle-1.0/work/wiggle-1.0 ... >>> Source configured. >>> Compiling source in /var/tmp/portage/dev-util/wiggle-1.0/work/wiggle-1.0 ... make -j3 -l2 CC=powerpc-unknown-linux-gnu-gcc wiggle powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o wiggle.o wiggle.c wiggle.c: In function ‘xmalloc’: wiggle.c:120:3: warning: ignoring return value of ‘write’, declared with attribute warn_unused_result [-Wunused-result] write(2, msg, strlen(msg)); ^~~~~~~~~~~~~~~~~~~~~~~~~~ wiggle.c: In function ‘multi_merge’: wiggle.c:650:3: warning: ignoring return value of ‘asprintf’, declared with attribute warn_unused_result [-Wunused-result] asprintf(&name, "_wiggle_:%d:%d:%s", ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  pl[i].start, pl[i].end, filename); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o parse.o parse.c powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o split.o split.c powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o extract.o extract.c extract.c: In function ‘split_patch’: extract.c:124:29: warning: ‘%5d’ directive writing between 5 and 11 bytes into a region of size between 0 and 7 [-Wformat-overflow=] sprintf(buf+1, "%5d %5d %5d", chunks, a, acnt); ^~~ In file included from /usr/include/stdio.h:939:0, from wiggle.h:25, from extract.c:29: /usr/include/bits/stdio2.h:33:10: note: ‘__builtin___sprintf_chk’ output between 18 and 35 bytes into a destination of size 19 return __builtin___sprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  __bos (__s), __fmt, __va_arg_pack ()); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ extract.c:141:29: warning: ‘%5d’ directive writing between 5 and 11 bytes into a region of size between 0 and 7 [-Wformat-overflow=] sprintf(buf+1, "%5d %5d %5d\n", chunks, c, bcnt); ^~~ In file included from /usr/include/stdio.h:939:0, from wiggle.h:25, from extract.c:29: /usr/include/bits/stdio2.h:33:10: note: ‘__builtin___sprintf_chk’ output between 19 and 36 bytes into a destination of size 19 return __builtin___sprintf_chk (__s, __USE_FORTIFY_LEVEL - 1, ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~  __bos (__s), __fmt, __va_arg_pack ()); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o diff.o diff.c powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o bestmatch.o bestmatch.c powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o ReadMe.o ReadMe.c powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o merge2.o merge2.c merge2.c: In function ‘save_tmp_merge’: merge2.c:902:3: warning: ignoring return value of ‘asprintf’, declared with attribute warn_unused_result [-Wunused-result] asprintf(&fname, "%s/wiggle-tmp-XXXXXX", dir); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ merge2.c:911:3: warning: ignoring return value of ‘asprintf’, declared with attribute warn_unused_result [-Wunused-result] asprintf(&fname, "%.*stmp-XXXXXX-%s", (int)(base-dir), dir, base); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o vpatch.o vpatch.c vpatch.c: In function ‘main_window’: vpatch.c:2669:2: warning: ignoring return value of ‘freopen’, declared with attribute warn_unused_result [-Wunused-result] freopen("/dev/null","w",stderr); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ vpatch.c: In function ‘show_merge’: vpatch.c:2366:2: warning: ignoring return value of ‘freopen’, declared with attribute warn_unused_result [-Wunused-result] freopen("/dev/null","w",stderr); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o ccan/hash/hash.o ccan/hash/hash.c ccan/hash/hash.c: In function ‘hash_u32’: ccan/hash/hash.c:212:13: warning: this statement may fall through [-Wimplicit-fallthrough=] case 3 : c+=k[2]; ~^~~~~~ ccan/hash/hash.c:213:3: note: here case 2 : b+=k[1]; ^~~~ ccan/hash/hash.c:213:13: warning: this statement may fall through [-Wimplicit-fallthrough=] case 2 : b+=k[1]; ~^~~~~~ ccan/hash/hash.c:214:3: note: here case 1 : a+=k[0]; ^~~~ ccan/hash/hash.c: In function ‘hash64_stable_32’: ccan/hash/hash.c:614:5: warning: this statement may fall through [-Wimplicit-fallthrough=] b += (uint32_t)k[1]; ~~^~~~~~~~~~~~~~~~~ ccan/hash/hash.c:615:2: note: here case 1: ^~~~ ccan/hash/hash.c: In function ‘hash64_stable_16’: ccan/hash/hash.c:645:5: warning: this statement may fall through [-Wimplicit-fallthrough=] c += (uint32_t)k[4]; ~~^~~~~~~~~~~~~~~~~ ccan/hash/hash.c:646:2: note: here case 4: ^~~~ ccan/hash/hash.c:647:5: warning: this statement may fall through [-Wimplicit-fallthrough=] b += ((uint32_t)k[3] << 16); ~~^~~~~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:648:2: note: here case 3: ^~~~ ccan/hash/hash.c:649:5: warning: this statement may fall through [-Wimplicit-fallthrough=] b += (uint32_t)k[2]; ~~^~~~~~~~~~~~~~~~~ ccan/hash/hash.c:650:2: note: here case 2: ^~~~ ccan/hash/hash.c:651:5: warning: this statement may fall through [-Wimplicit-fallthrough=] a += ((uint32_t)k[1] << 16); ~~^~~~~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:652:2: note: here case 1: ^~~~ ccan/hash/hash.c: In function ‘hashlittle’: ccan/hash/hash.c:400:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 12: c+=((uint32_t)k[11])<<24; ~^~~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:401:5: note: here case 11: c+=((uint32_t)k[10])<<16; ^~~~ ccan/hash/hash.c:401:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 11: c+=((uint32_t)k[10])<<16; ~^~~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:402:5: note: here case 10: c+=((uint32_t)k[9])<<8; ^~~~ ccan/hash/hash.c:402:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 10: c+=((uint32_t)k[9])<<8; ~^~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:403:5: note: here case 9 : c+=k[8]; ^~~~ ccan/hash/hash.c:403:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 9 : c+=k[8]; ~^~~~~~ ccan/hash/hash.c:404:5: note: here case 8 : b+=((uint32_t)k[7])<<24; ^~~~ ccan/hash/hash.c:404:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 8 : b+=((uint32_t)k[7])<<24; ~^~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:405:5: note: here case 7 : b+=((uint32_t)k[6])<<16; ^~~~ ccan/hash/hash.c:405:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 7 : b+=((uint32_t)k[6])<<16; ~^~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:406:5: note: here case 6 : b+=((uint32_t)k[5])<<8; ^~~~ ccan/hash/hash.c:406:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 6 : b+=((uint32_t)k[5])<<8; ~^~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:407:5: note: here case 5 : b+=k[4]; ^~~~ ccan/hash/hash.c:407:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 5 : b+=k[4]; ~^~~~~~ ccan/hash/hash.c:408:5: note: here case 4 : a+=((uint32_t)k[3])<<24; ^~~~ ccan/hash/hash.c:408:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 4 : a+=((uint32_t)k[3])<<24; ~^~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:409:5: note: here case 3 : a+=((uint32_t)k[2])<<16; ^~~~ ccan/hash/hash.c:409:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 3 : a+=((uint32_t)k[2])<<16; ~^~~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:410:5: note: here case 2 : a+=((uint32_t)k[1])<<8; ^~~~ ccan/hash/hash.c:410:15: warning: this statement may fall through [-Wimplicit-fallthrough=] case 2 : a+=((uint32_t)k[1])<<8; ~^~~~~~~~~~~~~~~~~~~~~ ccan/hash/hash.c:411:5: note: here case 1 : a+=k[0]; ^~~~ powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o split.o split.c powerpc-unknown-linux-gnu-gcc -O2 -mcpu=powerpc -pipe -I. -Wall -Wstrict-prototypes -Wextra -Wno-unused-parameter -c -o load.o load.c powerpc-unknown-linux-gnu-gcc -Wl,-O1 -Wl,--as-needed -Wl,--hash-style=gnu wiggle.o load.o parse.o split.o extract.o diff.o bestmatch.o ReadMe.o merge2.o vpatch.o ccan/hash/hash.o -lncurses -o wiggle >>> Source compiled. >>> Test phase: dev-util/wiggle-1.0 make -j3 -l2 TIME_CMD=/usr/bin/time test ./dotest 1 unresolved conflict found --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:54.787663122 +0200 @@ -22,11 +22,21 @@ #include #include #include +<<<<<<< found #include #include +||||||| expected #include +#include + +======= +#include +#include #include +>>>>>>> replacement +#include + #include #include #include ./contrib/nmi.c/merge FAILED 0.00 3 unresolved conflicts found 5 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:54.851653697 +0200 @@ -4288,11 +4288,46 @@ lface = lface_from_face_name (f, face, 1); LFACE_BACKGROUND (lface) = (STRINGP (new_value) ? new_value : Qunspecified); +<<<<<<< found + realize_basic_faces (f); + } + else if (EQ (param, Qborder_color)) + { + lface = lface_from_face_name (f, Qborder, 1); + LFACE_BACKGROUND (lface) = (STRINGP (new_value) + ? new_value : Qunspecified); + } + else if (EQ (param, Qcursor_color)) + { +||||||| expected + realize_basic_faces (f); + } + if (EQ (param, Qborder_color)) + { +======= realize_basic_faces (f); } else if (EQ (param, Qborder_color)) { face = Qborder; +>>>>>>> replacement +<<<<<<< found + lface = lface_from_face_name (f, Qcursor, 1); + LFACE_BACKGROUND (lface) = (STRINGP (new_value) + ? new_value : Qunspecified); + } + else if (EQ (param, Qmouse_color)) + { + lface = lface_from_face_name (f, Qmouse, 1); +||||||| expected + lface = lface_from_face_name (f, Qborder, 1); + LFACE_BACKGROUND (lface) = (STRINGP (new_value) + ? new_value : Qunspecified); + } + else if (EQ (param, Qcursor_color)) + { + lface = lface_from_face_name (f, Qcursor, 1); +======= lface = lface_from_face_name (f, face, 1); LFACE_BACKGROUND (lface) = (STRINGP (new_value) ? new_value : Qunspecified); @@ -4301,7 +4336,33 @@ { face = Qcursor; lface = lface_from_face_name (f, face, 1); +>>>>>>> replacement LFACE_BACKGROUND (lface) = (STRINGP (new_value) +<<<<<<< found + ? new_value : Qunspecified); + } +} + + +/* Get the value of X resource RESOURCE, class CLASS for the display + of frame FRAME. This is here because ordinary `x-get-resource' + doesn't take a frame argument. */ + +DEFUN ("internal-face-x-get-resource", Finternal_face_x_get_resource, + Sinternal_face_x_get_resource, 3, 3, 0, "") +||||||| expected + ? new_value : Qunspecified); + } + else if (EQ (param, Qmouse_color)) + { + lface = lface_from_face_name (f, Qmouse, 1); + LFACE_BACKGROUND (lface) = (STRINGP (new_value) + ? new_value : Qunspecified); + } +} + + +======= ? new_value : Qunspecified); } else if (EQ (param, Qmouse_color)) @@ -4326,12 +4387,7 @@ } -/* Get the value of X resource RESOURCE, class CLASS for the display - of frame FRAME. This is here because ordinary `x-get-resource' - doesn't take a frame argument. */ - -DEFUN ("internal-face-x-get-resource", Finternal_face_x_get_resource, - Sinternal_face_x_get_resource, 3, 3, 0, "") +>>>>>>> replacement (resource, class, frame) Lisp_Object resource, class, frame; { ./contrib/xfaces/merge FAILED 0.10 27 unresolved conflicts found 11 already-applied changes ignored --- bmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.031949256 +0200 @@ -1,10 +1,11 @@ \begin{ abstract } - % Start with a two-sentence (at most) description of the big-picture - % problem and why we care, and a sentence at the end that emphasizes how - % your work is part of the solution. + % Start with a two-sentence (<<<---at |||at ===at most--->>>) description of the big-picture + % <<<---problem and why we |||problem and why we ===problem and why we care--->>>, and a sentence at the end <<<---emphasizes |||emphasizes ===that emphasizes --->>>how + % <<<---work |||work ===your work --->>>is part of the solution. - Heterogeneous systems with <<<---Central Processing Units |||CPUs ===central CPUs --->>>and accelerators such as GPUs, FPGAs or the upcoming Intel MIC are becoming - mainstream. In these systems, peak performance includes the performance +<<<---Central Processing Units |||CPUs === Heterogeneous systems with central CPUs and accelerators such --->>><<<---such |||such ===--->>>as GPUs, <<<---FPGAs or |||FPGAs or +===FPGAs or the upcoming Intel MIC are becoming mainstream--->>><<<---Intel MIC are becoming +|||Intel MIC are becoming ===the upcoming Intel MIC are becoming mainstream--->>>. In these systems, peak performance includes the performance of not just the CPUs but also all available accelerators. In spite of this fact, the majority of programming models for heterogeneous computing focus on only one of these. With the development of Accelerated OpenMP for GPUs, @@ -12,13 +13,20 @@ applications incrementally to use GPUs. The extensions are geared toward switching from CPU parallelism to GPU parallelism. However they do not preserve the former while adding the latter. Thus computational potential is - wasted since either the CPU cores or the GPU cores are left idle. Our goal - is to create a runtime system that can intelligently divide an accelerated - OpenMP region across all available resources automatically. This paper - presents our proof-of-concept runtime system for dynamic task scheduling - across CPUs and GPUs. Further, we motivate the addition of this system into - the proposed \emph{OpenMP for Accelerators} standard. Finally, we show that - this option can produce as much as a two-fold performance improvement over - using either the CPU or GPU alone. + wasted since either the CPU cores or the GPU cores are left idle. <<<---Our goal +|||Our goal === Our goal --->>> is to create a <<<---runtime system |||runtime system ===runtime system that --->>><<<---can intelligently divide |||can + intelligently divide ===can intelligently + divide --->>>an <<<---accelerated + OpenMP |||accelerated OpenMP ===accelerated OpenMP region across --->>><<<---across |||across ===--->>>all available resources + automatically. <<<---This |||This ===This paper presents --->>><<<---our proof|||our proof===our proof--->>>-of-<<<---for dynamic task |||for dynamic + task ===concept runtime + system for dynamic task scheduling across CPUs --->>><<<--- across |||across ===--->>><<<---and GPUs|||and GPUs===and GPUs--->>>. Further, we <<<---the addition |||the addition ===motivate the addition --->>>of <<<---this |||this +===this system into --->>><<<---into +|||into ===--->>> the proposed +\emph{<<<---OpenMP |||OpenMP ===OpenMP for Accelerators--->>>} standard. Finally, we <<<---that +||| that ===show that + this option --->>><<<---option |||option ===--->>>can produce as much as a two-<<<---fold |||fold ===fold performance + improvement over using either --->>><<<--- using either |||using + either ===--->>>the CPU or <<<---GPU alone|||GPU alone===GPU alone--->>>. \end{ abstract } ./contrib/abstract/bmerge FAILED 0.00 1 unresolved conflict found 8 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.085101997 +0200 @@ -1154,9 +1154,22 @@ DEFINEPARSER(pfkey_prop_parse); DEFINEPARSER(pfkey_supported_parse); DEFINEPARSER(pfkey_spirange_parse); +<<<<<<< found DEFINEPARSER(pfkey_x_kmprivate_parse); DEFINEPARSER(pfkey_x_satype_parse); DEFINEPARSER(pfkey_x_ext_debug_parse); + +struct pf_key_ext_parsers_def *ext_default_parsers[]= +||||||| expected +DEFINEPARSER(pfkey_x_ext_debug_parse); +DEFINEPARSER(pfkey_x_ext_protocol_parse); + +struct pf_key_ext_parsers_def *ext_default_parsers[]= +{ + NULL, /* pfkey_msg_parse, */ +======= +DEFINEPARSER(pfkey_x_ext_debug_parse); +DEFINEPARSER(pfkey_x_ext_protocol_parse); #ifdef NAT_TRAVERSAL DEFINEPARSER(pfkey_x_ext_nat_t_type_parse); DEFINEPARSER(pfkey_x_ext_nat_t_port_parse); @@ -1165,6 +1178,9 @@ struct pf_key_ext_parsers_def *ext_default_parsers[]= { NULL, /* pfkey_msg_parse, */ +>>>>>>> replacement +{ + NULL, /* pfkey_msg_parse, */ &pfkey_sa_parse_def, &pfkey_lifetime_parse_def, &pfkey_lifetime_parse_def, ./contrib/pfkey_v2_parse.c/merge FAILED 0.02 1 unresolved conflict found --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.167399499 +0200 @@ -18,16 +18,28 @@ char *http_proxy_server_addr; //for reverse lookups int http_proxy_server_port; //for reverse lookups int auth_d_reload_interval; +<<<<<<< found char *debuglvl_path; /* internal state */ +||||||| expected + char *debuglvl_path; +} tbill_state; + +void generatePage(tbill_state *, ServerRequest *); +======= + char *debuglvl_path; + int production_mode; +} tbill_state; + +void generatePage(tbill_state *, ServerRequest *); +>>>>>>> replacement DB *db; FunctionHash * fh; int available; String *linkPathPrefix; int auth_d_pipe_fd; int auth_d_fd; - int production_mode; } tbill_state; void generatePage(tbill_state *, ServerRequest *); ./contrib/mod_tbill/merge FAILED 0.00 1 unresolved conflict found 3 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.231365143 +0200 @@ -166,8 +166,36 @@ c.homehost = optarg; continue; +<<<<<<< found + /* + * --offroot sets first char of argv[0] to @. This is used + * by systemd to signal that the task was launched from + * initrd/initramfs and should be preserved during shutdown + */ + case OffRootOpt: + argv[0][0] = '@'; + __offroot = 1; + continue; + + case Prefer: + if (c.prefer) +||||||| expected + /* + * --offroot sets first char of argv[0] to @. This is used + * by systemd to signal that the task was launched from + * initrd/initramfs and should be preserved during shutdown + */ + case OffRootOpt: + argv[0][0] = '@'; + __offroot = 1; + continue; + + case Prefer: + if (c.prefer) +======= case Prefer: if (c.prefer) +>>>>>>> replacement free(c.prefer); if (asprintf(&c.prefer, "/%s/", optarg) <= 0) c.prefer = NULL; ./mdadm/offroot/merge FAILED 0.02 1 unresolved conflict found ./simple/all-different/lmerge SUCCEEDED 0.00 1 unresolved conflict found ./simple/all-different/merge SUCCEEDED 0.00 10 unresolved conflicts found ./simple/all-different/wmerge SUCCEEDED 0.00 1 unresolved conflict found 7 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.498286630 +0200 @@ -5,14 +5,34 @@ several lines so that alll the changes +<<<<<<< found don't h... I don't know waht I am saying. -This lion will have some modifications made. +This lion will have some changes made. but this one wont stuf stuf stuff thing thing xxxxx that is all +||||||| expected +don't h... +I don't know what I am saying. +This line will have some changes made. +but this one wont +stuf stuf stuff +thing thing +xxxxx +that is all +======= +don't h... +I don't know what I am saying. +This line will have some modifications made. +but this one wont +stuf stuf stuff +thing thing +xxxxx +that is all +>>>>>>> replacement except for this ./simple/base/merge FAILED 0.00 --- diff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.550647273 +0200 @@ -1,23 +1,23 @@ @@ -1,20 +1,21 @@ - - This is a base file - some changes are going to happen to it - but it has -+had - several lines - so that alll - the changes - don't h... -|I don't know <<<--waht-->>><<<++what++>>> I am saying. -|This <<<--lion-->>><<<++line++>>> will have some changes made. - but this one wont - stuf stuf stuff - thing thing +|<<<--This-->>><<<++This++>>> <<<--is-->>><<<++is++>>> a <<<--base-->>><<<++base++>>> <<<--file-->>><<<++file++>>> +|<<<--some-->>><<<++some++>>> <<<--changes-->>><<<++changes++>>> <<<--are-->>><<<++are++>>> <<<--going-->>><<<++going++>>> to <<<--happen-->>><<<++happen++>>> <<<--to-->>><<<++to++>>> it +|but it <<<--has-->>><<<++has++>>> +|<<<--several-->>><<<++had +|several++>>> <<<--lines-->>><<<++lines++>>> +|so <<<--that-->>><<<++that++>>> <<<--alll-->>><<<++alll++>>> +|<<<--the-->>><<<++the++>>> <<<--changes-->>><<<++changes++>>> +|<<<--don-->>><<<++don++>>>'t h... +|I <<<--don-->>><<<++don++>>>'t <<<--know-->>><<<++know++>>> <<<--waht-->>><<<++what++>>> I am <<<--saying-->>><<<++saying++>>>. +|<<<--This-->>><<<++This++>>> <<<--lion-->>><<<++line++>>> <<<--will-->>><<<++will++>>> <<<--have-->>><<<++have++>>> <<<--some-->>><<<++some++>>> <<<--changes-->>><<<++changes++>>> <<<--made-->>><<<++made++>>>. +|<<<--but-->>><<<++but++>>> <<<--this-->>><<<++this++>>> one <<<--wont-->>><<<++wont++>>> +|<<<++stuf ++>>>stuf <<<--stuf stuff-->>><<<++stuff++>>> +|<<<--thing-->>><<<++thing++>>> <<<--thing-->>><<<++thing++>>> xxxxx - that is all - except - for - this - last +|<<<--that-->>><<<++that++>>> is <<<--all-->>><<<++all++>>> +|<<<--except-->>><<<++except++>>> +|<<<--for-->>><<<++for++>>> +|<<<--this-->>><<<++this++>>> +|<<<--last-->>><<<++last++>>> bit +x ./simple/base/diff FAILED 0.00 --- ldiff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.610383436 +0200 @@ -1,25 +1,41 @@ @@ -1,20 +1,21 @@ - - This is a base file - some changes are going to happen to it - but it has -+had - several lines - so that alll - the changes - don't h... +-This is a base file +-some changes are going to happen to it +-but it has +-several lines +-so that alll +-the changes +-don't h... -I don't know waht I am saying. -This lion will have some changes made. +-but this one wont +-stuf stuf stuff +-thing thing ++This is a base file ++some changes are going to happen to it ++but it has ++had ++several lines ++so that alll ++the changes ++don't h... +I don't know what I am saying. +This line will have some changes made. - but this one wont - stuf stuf stuff - thing thing ++but this one wont ++stuf stuf stuff ++thing thing xxxxx - that is all - except - for - this - last - bit +-that is all +-except +-for +-this +-last +-bit ++that is all ++except ++for ++this ++last ++bit +x ./simple/base/ldiff FAILED 0.00 1 unresolved conflict found ./simple/trivial-conflict/merge SUCCEEDED 0.00 --- Wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.720460636 +0200 @@ -1,14 +1,24 @@ <<<<<<< found This is one line of the file + +I think this is another line + +So is this ||||||| expected This is 1 line of the file + +I think this is another line + ======= This is 1 line of the document + +I think this is another line + &&&&&&& resolution This is one line of the document ->>>>>>> replacement I think this is another line So is this +>>>>>>> replacement ./simple/show-wiggle-1/Wmerge FAILED 0.00 1 already-applied change ignored ./simple/bothadd/lmerge SUCCEEDED 0.00 3 already-applied changes ignored ./simple/bothadd/merge SUCCEEDED 0.00 1 already-applied change ignored ./simple/already-applied/merge SUCCEEDED 0.00 1 unresolved conflict found --- Wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:55.964485428 +0200 @@ -6,10 +6,16 @@ <<<<<<< found Here is a line + +There is nothing else. ||||||| expected Here was a line + +There is nothing else. +At least, not much. ======= Here will be a line ->>>>>>> replacement There is nothing else. +At least, not much. +>>>>>>> replacement ./simple/show-wiggle-3/Wmerge FAILED 0.00 1 unresolved conflict found 3 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.023390401 +0200 @@ -2,9 +2,11 @@ with the word <<<<<<< found two which is +misspelt ||||||| expected to which is +misspelt ======= too which is ->>>>>>> replacement misspelt +>>>>>>> replacement ./simple/conflict/merge FAILED 0.00 --- diff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.075339934 +0200 @@ -1,5 +1,5 @@ @@ -1,4 +1,4 @@ this is a file with the word -|<<<--two-->>><<<++to++>>> which is - misspelt +|<<<--two-->>><<<++to++>>> <<<--which-->>><<<++which++>>> <<<--is-->>><<<++is++>>> +|<<<--misspelt-->>><<<++misspelt++>>> ./simple/conflict/diff FAILED 0.00 --- ldiff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.143821662 +0200 @@ -2,5 +2,6 @@ this is a file with the word -two which is +-misspelt +to which is - misspelt ++misspelt ./simple/conflict/ldiff FAILED 0.00 1 unresolved conflict found 3 already-applied changes ignored ./simple/conflict/wmerge SUCCEEDED 0.00 1 unresolved conflict found --- Wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.261869700 +0200 @@ -2,12 +2,14 @@ <<<<<<< found content line with content + +closing line ||||||| expected content line content + +closing line ======= middle line content -&&&&&&& resolution -middle line with content ->>>>>>> replacement closing line +>>>>>>> replacement ./simple/show-wiggle-2/Wmerge FAILED 0.00 1 unresolved conflict found --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.326327486 +0200 @@ -1,5 +1,15 @@ here is the +<<<<<<< found +original +file +||||||| expected +new version of the +original +file +======= +new version of the inaugural file +>>>>>>> replacement ./simple/changeafteradd/merge FAILED 0.00 1 unresolved conflict found --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.384418521 +0200 @@ -1,5 +1,15 @@ -This is a longish line that might be split up +This is a long<<<<<<< found +long line that might be broken and this is a broken line that might be -catenated +joined +||||||| expected +long line that has been +broken +and this is a broken line that will be joined +======= +longish line that has been +split up +and this is a broken line that will be catenated +>>>>>>> replacement ./simple/brokenlines/merge FAILED 0.00 --- diff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.434953697 +0200 @@ -3,5 +3,5 @@ |++>>>broken |and this is<<<-- |-->>><<<++ ++>>>a broken line<<<-- -|-->>><<<++ ++>>>that <<<--might-->>><<<++will++>>> be<<<-- -|-->>><<<++ ++>>>joined +|-->>><<<++ ++>>>that <<<--might-->>><<<++will++>>> <<<--be +|joined-->>><<<++be joined++>>> ./simple/brokenlines/diff FAILED 0.00 1 unresolved conflict found ./simple/multiple-add/lmerge SUCCEEDED 0.00 1 unresolved conflict found ./simple/multiple-add/merge SUCCEEDED 0.00 1 unresolved conflict found ./simple/multiple-add/wmerge SUCCEEDED 0.00 1 unresolved conflict found ./simple/all-different-2/lmerge SUCCEEDED 0.00 1 unresolved conflict found ./simple/all-different-2/merge SUCCEEDED 0.00 10 unresolved conflicts found ./simple/all-different-2/wmerge SUCCEEDED 0.00 1 unresolved conflict found --- lmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.837937877 +0200 @@ -1,2 +1,14 @@ First line +<<<<<<< found +this one too +and this +||||||| expected +this one too +This stuff is padding too +and this +Guess what you find here? +======= +This stuff is padding too +Guess what you find here? +>>>>>>> replacement last line ./simple/multideletes/lmerge FAILED 0.00 1 unresolved conflict found 1 already-applied change ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.907887484 +0200 @@ -1,2 +1,18 @@ First line +<<<<<<< found +this line will go +this one too +and this +||||||| expected +this line will go +Some more padding +this one too +This stuff is padding too +and this +Guess what you find here? +======= +Some more padding +This stuff is padding too +Guess what you find here? +>>>>>>> replacement last line ./simple/multideletes/merge FAILED 0.00 1 unresolved conflict found --- lmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:56.969321397 +0200 @@ -2,9 +2,11 @@ with the word <<<<<<< found two which is +misspelt ||||||| expected to which is +misspelt ======= too which was ->>>>>>> replacement misspelt +>>>>>>> replacement ./simple/conflictmixed/lmerge FAILED 0.00 1 unresolved conflict found 1 already-applied change ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.024505714 +0200 @@ -2,9 +2,11 @@ with the word <<<<<<< found two which is +misspelt ||||||| expected to which is +misspelt ======= too which was ->>>>>>> replacement misspelt +>>>>>>> replacement ./simple/conflictmixed/merge FAILED 0.00 --- diff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.093534908 +0200 @@ -1,5 +1,5 @@ @@ -1,4 +1,4 @@ this is a file with the word -|<<<--two-->>><<<++to++>>> which is - misspelt +|<<<--two-->>><<<++to++>>> <<<--which-->>><<<++which++>>> <<<--is-->>><<<++is++>>> +|<<<--misspelt-->>><<<++misspelt++>>> ./simple/conflictmixed/diff FAILED 0.00 --- ldiff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.148856871 +0200 @@ -2,5 +2,6 @@ this is a file with the word -two which is +-misspelt +to which is - misspelt ++misspelt ./simple/conflictmixed/ldiff FAILED 0.00 2 unresolved conflicts found 1 already-applied change ignored --- wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.215436628 +0200 @@ -1,4 +1,4 @@ this is a file with the word -<<<---two|||to===too--->>> which was +<<<---two|||to===too--->>> which <<<---is|||is===was--->>> misspelt ./simple/conflictmixed/wmerge FAILED 0.00 1 unresolved conflict found ./linux/raid5line/lmerge SUCCEEDED 0.00 1 unresolved conflict found ./linux/raid5line/merge SUCCEEDED 0.00 2 unresolved conflicts found --- wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.405945332 +0200 @@ -1 +1 @@ -<<<--- clear_bit(BH_Uptodate, &||| clear_buffer_uptodate(=== dev--->>>-><<<---->b_state|||===flags = 0--->>>; +<<<--- clear_bit(BH_Uptodate, &sh->bh_cache||| clear_buffer_uptodate(sh->bh_cache=== dev->flags = 0--->>><<<---->b_state|||===--->>>; ./linux/raid5line/wmerge FAILED 0.00 1 unresolved conflict found --- lmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.468486808 +0200 @@ -955,10 +955,6 @@ <<<<<<< found hlist_del_init(&inode->i_hash); -||||||| expected - list_del_init(&inode->i_hash); -======= ->>>>>>> replacement list_del_init(&inode->i_list); inode->i_state|=I_FREEING; inodes_stat.nr_inodes--; @@ -1356,3 +1352,13 @@ printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o)\n", mode); } +||||||| expected + list_del_init(&inode->i_hash); + list_del_init(&inode->i_list); + inode->i_state|=I_FREEING; + inodes_stat.nr_inodes--; +======= + list_del_init(&inode->i_list); + inode->i_state|=I_FREEING; + inodes_stat.nr_inodes--; +>>>>>>> replacement ./linux/inode-justrej/lmerge FAILED 0.00 1 unresolved conflict found ./linux/inode-justrej/merge SUCCEEDED 0.01 3 unresolved conflicts found --- wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.607618585 +0200 @@ -953,7 +953,7 @@ { struct super_operations *op = inode->i_sb->s_op; -<<<---hlist_del_init|||list_del_init===--->>> list_del_init(&inode->i_list); +<<<---hlist_del_init|||list_del_init===--->>><<<---inode|||inode===--->>><<<---i_hash|||i_hash===--->>> list_del_init(&inode->i_list); inode->i_state|=I_FREEING; inodes_stat.nr_inodes--; spin_unlock(&inode_lock); ./linux/inode-justrej/wmerge FAILED 0.01 7 unresolved conflicts found 8 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.675332757 +0200 @@ -542,12 +542,26 @@ if (conf->pending_bio_list.head) { struct bio *bio; +<<<<<<< found + bio = bio_list_get(&conf->pending_bio_list); + spin_unlock_irq(&conf->device_lock); + /* flush any pending bitmap writes to + * disk before proceeding w/ I/O */ +||||||| expected + bio = bio_list_get(&conf->pending_bio_list); + blk_remove_plug(conf->mddev->queue); + spin_unlock_irq(&conf->device_lock); + /* flush any pending bitmap writes to + * disk before proceeding w/ I/O */ +======= bio = bio_list_get(&conf->pending_bio_list); + blk_remove_plug(conf->mddev->queue); conf->pending_count = 0; spin_unlock_irq(&conf->device_lock); wake_up(&conf->wait_barrier); /* flush any pending bitmap writes to * disk before proceeding w/ I/O */ +>>>>>>> replacement bitmap_unplug(conf->mddev->bitmap); while (bio) { /* submit pending writes */ @@ -707,21 +721,29 @@ conf_t *conf = mddev->private; mirror_info_t *mirror; r1bio_t *r1_bio; +<<<<<<< found struct bio *read_bio; int i, targets = 0, disks; struct bitmap *bitmap; unsigned long flags; -<<<<<<< found + const int rw = bio_data_dir(bio); + const unsigned long do_sync = (bio->bi_rw & REQ_SYNC); ||||||| expected + struct bitmap *bitmap; + unsigned long flags; struct bio_list bl; struct page **behind_pages = NULL; + const int rw = bio_data_dir(bio); + const bool do_sync = bio_rw_flagged(bio, BIO_RW_SYNCIO); ======= + struct bitmap *bitmap; + unsigned long flags; struct bio_list bl; int bl_count; struct page **behind_pages = NULL; ->>>>>>> replacement const int rw = bio_data_dir(bio); - const unsigned long do_sync = (bio->bi_rw & REQ_SYNC); + const bool do_sync = bio_rw_flagged(bio, BIO_RW_SYNCIO); +>>>>>>> replacement const unsigned long do_flush_fua = (bio->bi_rw & (REQ_FLUSH | REQ_FUA)); mdk_rdev_t *blocked_rdev; int plugged; @@ -885,7 +907,6 @@ bitmap_startwrite(bitmap, bio->bi_sector, r1_bio->sectors, test_bit(R1BIO_BehindIO, &r1_bio->state)); - bl_count = 0; for (i = 0; i < disks; i++) { struct bio *mbio; if (!r1_bio->bios[i]) @@ -915,42 +936,14 @@ bvec->bv_page = r1_bio->behind_pages[j]; if (test_bit(WriteMostly, &conf->mirrors[i].rdev->flags)) atomic_inc(&r1_bio->behind_remaining); -<<<<<<< found } -||||||| expected - bio_list_add(&bl, mbio); - } - kfree(behind_pages); /* the behind pages are attached to the bios now */ - -======= - bio_list_add(&bl, mbio); - bl_count++; - } - kfree(behind_pages); /* the behind pages are attached to the bios now */ - ->>>>>>> replacement atomic_inc(&r1_bio->remaining); -<<<<<<< found spin_lock_irqsave(&conf->device_lock, flags); bio_list_add(&conf->pending_bio_list, mbio); spin_unlock_irqrestore(&conf->device_lock, flags); } r1_bio_write_done(r1_bio); -||||||| expected - spin_lock_irqsave(&conf->device_lock, flags); - bio_list_merge(&conf->pending_bio_list, &bl); - bio_list_init(&bl); - - blk_plug_device(mddev->queue); -======= - spin_lock_irqsave(&conf->device_lock, flags); - bio_list_merge(&conf->pending_bio_list, &bl); - conf->pending_count += bl_count; - bio_list_init(&bl); - - blk_plug_device(mddev->queue); ->>>>>>> replacement /* In case raid1d snuck in to freeze_array */ wake_up(&conf->wait_barrier); @@ -1441,10 +1434,23 @@ /* * schedule writes */ +<<<<<<< found atomic_set(&r1_bio->remaining, 1); for (i = 0; i < disks ; i++) { wbio = r1_bio->bios[i]; if (wbio->bi_end_io == NULL || +||||||| expected + bio_list_init(&bl); + for (i = 0; i < disks; i++) { + struct bio *mbio; + if (!r1_bio->bios[i]) +======= + bio_list_init(&bl); + bl_count = 0; + for (i = 0; i < disks; i++) { + struct bio *mbio; + if (!r1_bio->bios[i]) +>>>>>>> replacement (wbio->bi_end_io == end_sync_read && (i == r1_bio->read_disk || !test_bit(MD_RECOVERY_SYNC, &mddev->recovery)))) @@ -1461,12 +1467,33 @@ if (atomic_dec_and_test(&r1_bio->remaining)) { /* if we're here, all write(s) have completed, so clean up */ md_done_sync(mddev, r1_bio->sectors, 1); +<<<<<<< found put_buf(r1_bio); +||||||| expected + atomic_inc(&r1_bio->remaining); + + bio_list_add(&bl, mbio); +======= + atomic_inc(&r1_bio->remaining); + + bio_list_add(&bl, mbio); +>>>>>>> replacement + bl_count++; +<<<<<<< found } } /* * This is a kernel thread which: +||||||| expected + } + kfree(behind_pages); /* the behind pages are attached to the bios now */ + +======= + } + kfree(behind_pages); /* the behind pages are attached to the bios now */ + +>>>>>>> replacement * * 1. Retries failed read operations on working mirrors. * 2. Updates the raid superblock when problems encounter. @@ -1576,12 +1603,29 @@ if (atomic_read(&mddev->plug_cnt) == 0) flush_pending_writes(conf); +<<<<<<< found spin_lock_irqsave(&conf->device_lock, flags); if (list_empty(head)) { spin_unlock_irqrestore(&conf->device_lock, flags); break; } +||||||| expected + test_bit(R1BIO_BehindIO, &r1_bio->state)); + spin_lock_irqsave(&conf->device_lock, flags); + bio_list_merge(&conf->pending_bio_list, &bl); + bio_list_init(&bl); + + blk_plug_device(mddev->queue); +======= + test_bit(R1BIO_BehindIO, &r1_bio->state)); + spin_lock_irqsave(&conf->device_lock, flags); + bio_list_merge(&conf->pending_bio_list, &bl); + conf->pending_count += bl_count; + bio_list_init(&bl); + + blk_plug_device(mddev->queue); +>>>>>>> replacement r1_bio = list_entry(head->prev, r1bio_t, retry_list); list_del(head->prev); conf->nr_queued--; @@ -1949,16 +1993,18 @@ spin_lock_init(&conf->resync_lock); init_waitqueue_head(&conf->wait_barrier); - bio_list_init(&conf->pending_bio_list); <<<<<<< found + bio_list_init(&conf->pending_bio_list); conf->last_used = -1; for (i = 0; i < conf->raid_disks; i++) { ||||||| expected + bio_list_init(&conf->pending_bio_list); bio_list_init(&conf->flushing_bio_list); ======= + bio_list_init(&conf->pending_bio_list); conf->pending_count = 0; bio_list_init(&conf->flushing_bio_list); ./linux/raid1-A/merge FAILED 0.08 14 unresolved conflicts found --- lmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:57.841320668 +0200 @@ -1224,17 +1224,51 @@ rdev->sb_loaded = 1; } } +<<<<<<< found +||||||| expected + return 1; +} + +#undef OLD_LEVEL +======= + return 1; +} + +static struct gendisk *md_probe(dev_t dev, int *part, void *data) +>>>>>>> replacement +<<<<<<< found static void md_update_sb(mddev_t * mddev) +||||||| expected + +static int device_size_calculation(mddev_t * mddev) +======= +>>>>>>> replacement +<<<<<<< found { int err, count = 100; - struct list_head *tmp; - mdk_rdev_t *rdev; - +||||||| expected +{ + int data_disks = 0; + unsigned int readahead; +======= +{ + static DECLARE_MUTEX(disks_sem); +>>>>>>> replacement +<<<<<<< found mddev->sb_dirty = 0; repeat: mddev->utime = get_seconds(); mddev->events ++; +||||||| expected + /* + * Do device size calculation. Bail out if too small. + * (we have to do this after having validated chunk_size, + * because device size has to be modulo chunk_size) + */ +======= +>>>>>>> replacement +<<<<<<< found if (!mddev->events) { /* @@ -1244,8 +1278,30 @@ */ MD_BUG(); mddev->events --; +||||||| expected + + ITERATE_RDEV(mddev,rdev,tmp) { + if (rdev->faulty) + continue; + if (rdev->size < mddev->chunk_size / 1024) { + printk(KERN_WARNING + "md: Dev %s smaller than chunk_size:" + " %lluk < %dk\n", + bdev_partition_name(rdev->bdev), + (unsigned long long)rdev->size, + mddev->chunk_size / 1024); + return -EINVAL; + } +======= +>>>>>>> replacement +<<<<<<< found } sync_sbs(mddev); +||||||| expected + } +======= +>>>>>>> replacement +<<<<<<< found /* * do not write anything to disk if using @@ -1253,16 +1309,75 @@ */ if (!mddev->persistent) return; +||||||| expected + + switch (mddev->level) { + case LEVEL_MULTIPATH: + data_disks = 1; + break; + case -3: + data_disks = 1; + break; + case -2: + data_disks = 1; + break; + case LEVEL_LINEAR: + zoned_raid_size(mddev); + data_disks = 1; + break; + case 0: + zoned_raid_size(mddev); + data_disks = mddev->raid_disks; + break; + case 1: + data_disks = 1; + break; + case 4: + case 5: + data_disks = mddev->raid_disks-1; + break; + default: + printk(KERN_ERR "md: md%d: unsupported raid level %d\n", + mdidx(mddev), mddev->level); + goto abort; + } + if (!md_size[mdidx(mddev)]) + md_size[mdidx(mddev)] = mddev->size * data_disks; +======= +>>>>>>> replacement +<<<<<<< found dprintk(KERN_INFO "md: updating md%d RAID superblock on device (in sync %d)\n", mdidx(mddev),mddev->in_sync); +||||||| expected + + readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; + if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { + readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; + if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) + readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; + } else { + // (no multipath branch - it uses the default setting) + if (mddev->level == -3) + readahead = 0; + } +======= +>>>>>>> replacement +<<<<<<< found err = 0; ITERATE_RDEV(mddev,rdev,tmp) { dprintk(KERN_INFO "md: "); if (rdev->faulty) dprintk("(skipping faulty "); +||||||| expected + + printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", + mdidx(mddev), readahead*(PAGE_SIZE/1024)); +======= +>>>>>>> replacement +<<<<<<< found dprintk("%s ", bdev_partition_name(rdev->bdev)); if (!rdev->faulty) { @@ -1282,6 +1397,17 @@ printk(KERN_ERR \ "md: excessive errors occurred during superblock update, exiting\n"); } +||||||| expected + + printk(KERN_INFO + "md%d: %d data-disks, max readahead per data-disk: %ldk\n", + mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); + return 0; +abort: + return 1; +======= +>>>>>>> replacement +<<<<<<< found } /* @@ -1411,7 +1537,34 @@ rdev->in_sync = 1; } } +||||||| expected +} +static struct gendisk *md_probe(dev_t dev, int *part, void *data) +{ + static DECLARE_MUTEX(disks_sem); +======= +>>>>>>> replacement +<<<<<<< found +||||||| expected + } + } +======= + } + } +>>>>>>> replacement +<<<<<<< found + +||||||| expected + + if (device_size_calculation(mddev)) + return -EINVAL; +======= + + /* + * Drop all container device buffers, from now on +>>>>>>> replacement +<<<<<<< found /* * Check if we can support this RAID array @@ -1436,6 +1589,88 @@ return 1; } +static int device_size_calculation(mddev_t * mddev) +{ + int data_disks = 0; + unsigned int readahead; + struct list_head *tmp; + mdk_rdev_t *rdev; + + /* + * Do device size calculation. Bail out if too small. + * (we have to do this after having validated chunk_size, + * because device size has to be modulo chunk_size) + */ + + ITERATE_RDEV(mddev,rdev,tmp) { + if (rdev->faulty) + continue; + if (rdev->size < mddev->chunk_size / 1024) { + printk(KERN_WARNING + "md: Dev %s smaller than chunk_size:" + " %lluk < %dk\n", + bdev_partition_name(rdev->bdev), + (unsigned long long)rdev->size, + mddev->chunk_size / 1024); + return -EINVAL; + } + } + + switch (mddev->level) { + case LEVEL_MULTIPATH: + data_disks = 1; + break; + case -3: + data_disks = 1; + break; + case -2: + data_disks = 1; + break; + case LEVEL_LINEAR: + zoned_raid_size(mddev); + data_disks = 1; + break; + case 0: + zoned_raid_size(mddev); + data_disks = mddev->raid_disks; + break; + case 1: + data_disks = 1; + break; + case 4: + case 5: + data_disks = mddev->raid_disks-1; + break; + default: + printk(KERN_ERR "md: md%d: unsupported raid level %d\n", + mdidx(mddev), mddev->level); + goto abort; + } + if (!md_size[mdidx(mddev)]) + md_size[mdidx(mddev)] = mddev->size * data_disks; + + readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; + if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { + readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; + if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) + readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; + } else { + // (no multipath branch - it uses the default setting) + if (mddev->level == -3) + readahead = 0; + } + + printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", + mdidx(mddev), readahead*(PAGE_SIZE/1024)); + + printk(KERN_INFO + "md%d: %d data-disks, max readahead per data-disk: %ldk\n", + mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); + return 0; +abort: + return 1; +} + static struct gendisk *md_probe(dev_t dev, int *part, void *data) { static DECLARE_MUTEX(disks_sem); @@ -1567,6 +1802,9 @@ } #endif + if (device_size_calculation(mddev)) + return -EINVAL; + /* * Drop all container device buffers, from now on * the only valid external interface is through the md @@ -3587,3 +3825,11 @@ EXPORT_SYMBOL(md_interrupt_thread); EXPORT_SYMBOL(md_check_recovery); MODULE_LICENSE("GPL"); +||||||| expected + + /* + * Drop all container device buffers, from now on + * the only valid external interface is through the md +======= + * the only valid external interface is through the md +>>>>>>> replacement ./linux/md/lmerge FAILED 0.01 3 unresolved conflicts found 11 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ orig.tmp 2018-07-31 13:36:58.084499090 +0200 @@ -1436,7 +1436,179 @@ return 1; } +<<<<<<< found +static int device_size_calculation(mddev_t * mddev) +{ + int data_disks = 0; + unsigned int readahead; + struct list_head *tmp; + mdk_rdev_t *rdev; + + /* + * Do device size calculation. Bail out if too small. + * (we have to do this after having validated chunk_size, + * because device size has to be modulo chunk_size) + */ + + ITERATE_RDEV(mddev,rdev,tmp) { + if (rdev->faulty) + continue; + if (rdev->size < mddev->chunk_size / 1024) { + printk(KERN_WARNING + "md: Dev %s smaller than chunk_size:" + " %lluk < %dk\n", + bdev_partition_name(rdev->bdev), + (unsigned long long)rdev->size, + mddev->chunk_size / 1024); + return -EINVAL; + } + } + + switch (mddev->level) { + case LEVEL_MULTIPATH: + data_disks = 1; + break; + case -3: + data_disks = 1; + break; + case -2: + data_disks = 1; + break; + case LEVEL_LINEAR: + zoned_raid_size(mddev); + data_disks = 1; + break; + case 0: + zoned_raid_size(mddev); + data_disks = mddev->raid_disks; + break; + case 1: + data_disks = 1; + break; + case 4: + case 5: + data_disks = mddev->raid_disks-1; + break; + default: + printk(KERN_ERR "md: md%d: unsupported raid level %d\n", + mdidx(mddev), mddev->level); + goto abort; + } + if (!md_size[mdidx(mddev)]) + md_size[mdidx(mddev)] = mddev->size * data_disks; + + readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; + if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { + readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; + if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) + readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; + } else { + // (no multipath branch - it uses the default setting) + if (mddev->level == -3) + readahead = 0; + } + + printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", + mdidx(mddev), readahead*(PAGE_SIZE/1024)); + + printk(KERN_INFO + "md%d: %d data-disks, max readahead per data-disk: %ldk\n", + mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); + return 0; +abort: + return 1; +} + static struct gendisk *md_probe(dev_t dev, int *part, void *data) +||||||| expected +#undef OLD_LEVEL + +static int device_size_calculation(mddev_t * mddev) +{ + int data_disks = 0; + unsigned int readahead; + struct list_head *tmp; + mdk_rdev_t *rdev; + + /* + * Do device size calculation. Bail out if too small. + * (we have to do this after having validated chunk_size, + * because device size has to be modulo chunk_size) + */ + + ITERATE_RDEV(mddev,rdev,tmp) { + if (rdev->faulty) + continue; + if (rdev->size < mddev->chunk_size / 1024) { + printk(KERN_WARNING + "md: Dev %s smaller than chunk_size:" + " %lluk < %dk\n", + bdev_partition_name(rdev->bdev), + (unsigned long long)rdev->size, + mddev->chunk_size / 1024); + return -EINVAL; + } + } + + switch (mddev->level) { + case LEVEL_MULTIPATH: + data_disks = 1; + break; + case -3: + data_disks = 1; + break; + case -2: + data_disks = 1; + break; + case LEVEL_LINEAR: + zoned_raid_size(mddev); + data_disks = 1; + break; + case 0: + zoned_raid_size(mddev); + data_disks = mddev->raid_disks; + break; + case 1: + data_disks = 1; + break; + case 4: + case 5: + data_disks = mddev->raid_disks-1; + break; + default: + printk(KERN_ERR "md: md%d: unsupported raid level %d\n", + mdidx(mddev), mddev->level); + goto abort; + } + if (!md_size[mdidx(mddev)]) + md_size[mdidx(mddev)] = mddev->size * data_disks; + + readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; + if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { + readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; + if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) + readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; + } else { + // (no multipath branch - it uses the default setting) + if (mddev->level == -3) + readahead = 0; + } + + printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", + mdidx(mddev), readahead*(PAGE_SIZE/1024)); + + printk(KERN_INFO + "md%d: %d data-disks, max readahead per data-disk: %ldk\n", + mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); + return 0; +abort: + return 1; +} + +static struct gendisk *md_probe(dev_t dev, int *part, void *data) +======= +static struct gendisk *md_probe(dev_t dev, int *part, void *data) +>>>>>>> replacement { static DECLARE_MUTEX(disks_sem); int unit = MINOR(dev); @@ -1567,6 +1739,9 @@ } #endif + if (device_size_calculation(mddev)) + return -EINVAL; + /* * Drop all container device buffers, from now on * the only valid external interface is through the md @@ -3012,13 +3187,30 @@ int unregister_md_personality(int pnum) { +<<<<<<< found if (pnum >= MAX_PERSONALITY) { MD_BUG(); return -EINVAL; +||||||| expected + if (device_size_calculation(mddev)) + return -EINVAL; + +======= +>>>>>>> replacement +<<<<<<< found } printk(KERN_INFO "md: %s personality unregistered\n", pers[pnum]->name); spin_lock(&pers_lock); +||||||| expected + /* + * Drop all container device buffers, from now on + * the only valid external interface is through the md +======= + /* + * Drop all container device buffers, from now on + * the only valid external interface is through the md +>>>>>>> replacement pers[pnum] = NULL; spin_unlock(&pers_lock); return 0; ./linux/md/replace FAILED 0.15 3 unresolved conflicts found 11 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:58.157967053 +0200 @@ -1436,7 +1436,179 @@ return 1; } +<<<<<<< found +static int device_size_calculation(mddev_t * mddev) +{ + int data_disks = 0; + unsigned int readahead; + struct list_head *tmp; + mdk_rdev_t *rdev; + + /* + * Do device size calculation. Bail out if too small. + * (we have to do this after having validated chunk_size, + * because device size has to be modulo chunk_size) + */ + + ITERATE_RDEV(mddev,rdev,tmp) { + if (rdev->faulty) + continue; + if (rdev->size < mddev->chunk_size / 1024) { + printk(KERN_WARNING + "md: Dev %s smaller than chunk_size:" + " %lluk < %dk\n", + bdev_partition_name(rdev->bdev), + (unsigned long long)rdev->size, + mddev->chunk_size / 1024); + return -EINVAL; + } + } + + switch (mddev->level) { + case LEVEL_MULTIPATH: + data_disks = 1; + break; + case -3: + data_disks = 1; + break; + case -2: + data_disks = 1; + break; + case LEVEL_LINEAR: + zoned_raid_size(mddev); + data_disks = 1; + break; + case 0: + zoned_raid_size(mddev); + data_disks = mddev->raid_disks; + break; + case 1: + data_disks = 1; + break; + case 4: + case 5: + data_disks = mddev->raid_disks-1; + break; + default: + printk(KERN_ERR "md: md%d: unsupported raid level %d\n", + mdidx(mddev), mddev->level); + goto abort; + } + if (!md_size[mdidx(mddev)]) + md_size[mdidx(mddev)] = mddev->size * data_disks; + + readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; + if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { + readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; + if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) + readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; + } else { + // (no multipath branch - it uses the default setting) + if (mddev->level == -3) + readahead = 0; + } + + printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", + mdidx(mddev), readahead*(PAGE_SIZE/1024)); + + printk(KERN_INFO + "md%d: %d data-disks, max readahead per data-disk: %ldk\n", + mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); + return 0; +abort: + return 1; +} + static struct gendisk *md_probe(dev_t dev, int *part, void *data) +||||||| expected +#undef OLD_LEVEL + +static int device_size_calculation(mddev_t * mddev) +{ + int data_disks = 0; + unsigned int readahead; + struct list_head *tmp; + mdk_rdev_t *rdev; + + /* + * Do device size calculation. Bail out if too small. + * (we have to do this after having validated chunk_size, + * because device size has to be modulo chunk_size) + */ + + ITERATE_RDEV(mddev,rdev,tmp) { + if (rdev->faulty) + continue; + if (rdev->size < mddev->chunk_size / 1024) { + printk(KERN_WARNING + "md: Dev %s smaller than chunk_size:" + " %lluk < %dk\n", + bdev_partition_name(rdev->bdev), + (unsigned long long)rdev->size, + mddev->chunk_size / 1024); + return -EINVAL; + } + } + + switch (mddev->level) { + case LEVEL_MULTIPATH: + data_disks = 1; + break; + case -3: + data_disks = 1; + break; + case -2: + data_disks = 1; + break; + case LEVEL_LINEAR: + zoned_raid_size(mddev); + data_disks = 1; + break; + case 0: + zoned_raid_size(mddev); + data_disks = mddev->raid_disks; + break; + case 1: + data_disks = 1; + break; + case 4: + case 5: + data_disks = mddev->raid_disks-1; + break; + default: + printk(KERN_ERR "md: md%d: unsupported raid level %d\n", + mdidx(mddev), mddev->level); + goto abort; + } + if (!md_size[mdidx(mddev)]) + md_size[mdidx(mddev)] = mddev->size * data_disks; + + readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; + if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { + readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; + if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) + readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; + } else { + // (no multipath branch - it uses the default setting) + if (mddev->level == -3) + readahead = 0; + } + + printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", + mdidx(mddev), readahead*(PAGE_SIZE/1024)); + + printk(KERN_INFO + "md%d: %d data-disks, max readahead per data-disk: %ldk\n", + mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); + return 0; +abort: + return 1; +} + +static struct gendisk *md_probe(dev_t dev, int *part, void *data) +======= +static struct gendisk *md_probe(dev_t dev, int *part, void *data) +>>>>>>> replacement { static DECLARE_MUTEX(disks_sem); int unit = MINOR(dev); @@ -1567,6 +1739,9 @@ } #endif + if (device_size_calculation(mddev)) + return -EINVAL; + /* * Drop all container device buffers, from now on * the only valid external interface is through the md @@ -3012,13 +3187,30 @@ int unregister_md_personality(int pnum) { +<<<<<<< found if (pnum >= MAX_PERSONALITY) { MD_BUG(); return -EINVAL; +||||||| expected + if (device_size_calculation(mddev)) + return -EINVAL; + +======= +>>>>>>> replacement +<<<<<<< found } printk(KERN_INFO "md: %s personality unregistered\n", pers[pnum]->name); spin_lock(&pers_lock); +||||||| expected + /* + * Drop all container device buffers, from now on + * the only valid external interface is through the md +======= + /* + * Drop all container device buffers, from now on + * the only valid external interface is through the md +>>>>>>> replacement pers[pnum] = NULL; spin_unlock(&pers_lock); return 0; ./linux/md/merge FAILED 0.15 --- diff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:58.394347903 +0200 @@ -1434,97 +1434,97 @@ - - return 0; -abort: -+*** 1453,90 **** 1 - return 1; +|<<<-- return-->>><<<++*** 1453,90 **** 1 +| return++>>> 1; } -+#undef OLD_LEVEL -+ - static int device_size_calculation(mddev_t * mddev) +|<<<--static-->>><<<++#undef OLD_LEVEL +| +|static++>>> int <<<--device_size_calculation-->>><<<++device_size_calculation++>>>(<<<--mddev_t-->>><<<++mddev_t++>>> * <<<--mddev-->>><<<++mddev++>>>) { - int data_disks = 0; - unsigned int readahead; - struct list_head *tmp; - mdk_rdev_t *rdev; +| int <<<--data_disks-->>><<<++data_disks++>>> = 0; +| <<<--unsigned-->>><<<++unsigned++>>> <<<--int-->>><<<++int++>>> <<<--readahead-->>><<<++readahead++>>>; +| <<<--struct-->>><<<++struct++>>> <<<--list_head-->>><<<++list_head++>>> *tmp; +| <<<--mdk_rdev_t-->>><<<++mdk_rdev_t++>>> *<<<--rdev-->>><<<++rdev++>>>; /* - * Do device size calculation. Bail out if too small. - * (we have to do this after having validated chunk_size, - * because device size has to be modulo chunk_size) +| * Do <<<--device-->>><<<++device++>>> <<<--size-->>><<<++size++>>> <<<--calculation-->>><<<++calculation++>>>. <<<--Bail-->>><<<++Bail++>>> <<<--out-->>><<<++out++>>> <<<--if-->>><<<++if++>>> too <<<--small-->>><<<++small++>>>. +| * (we <<<--have-->>><<<++have++>>> to do <<<--this-->>><<<++this++>>> <<<--after-->>><<<++after++>>> <<<--having-->>><<<++having++>>> <<<--validated-->>><<<++validated++>>> <<<--chunk_size-->>><<<++chunk_size++>>>, +|<<<-- -->>><<<++ ++>>>* <<<--because-->>><<<++because++>>> <<<--device-->>><<<++device++>>> <<<--size-->>><<<++size++>>> <<<--has-->>><<<++has++>>> <<<--to-->>><<<++to++>>> <<<--be-->>><<<++be++>>> <<<--modulo-->>><<<++modulo++>>> <<<--chunk_size-->>><<<++chunk_size++>>>) */ - ITERATE_RDEV(mddev,rdev,tmp) { - if (rdev->faulty) - continue; - if (rdev->size < mddev->chunk_size / 1024) { - printk(KERN_WARNING - "md: Dev %s smaller than chunk_size:" - " %lluk < %dk\n", - bdev_partition_name(rdev->bdev), - (unsigned long long)rdev->size, - mddev->chunk_size / 1024); - return -EINVAL; +| <<<--ITERATE_RDEV-->>><<<++ITERATE_RDEV++>>>(<<<--mddev-->>><<<++mddev++>>>,<<<--rdev-->>><<<++rdev++>>>,<<<--tmp-->>><<<++tmp++>>>) { +| if (<<<--rdev-->>><<<++rdev++>>>-><<<--faulty-->>><<<++faulty++>>>) +| <<<--continue-->>><<<++continue++>>>; +| if (<<<--rdev-->>><<<++rdev++>>>-><<<--size-->>><<<++size++>>> < <<<--mddev-->>><<<++mddev++>>>-><<<--chunk_size-->>><<<++chunk_size++>>> / <<<--1024-->>><<<++1024++>>>) { +| <<<--printk-->>><<<++printk++>>>(<<<--KERN_WARNING-->>><<<++KERN_WARNING++>>> +| "<<<--md-->>><<<++md++>>>: <<<--Dev-->>><<<++Dev++>>> %s <<<--smaller-->>><<<++smaller++>>> <<<--than-->>><<<++than++>>> <<<--chunk_size-->>><<<++chunk_size++>>>:" +| " %<<<--lluk-->>><<<++lluk++>>> < %<<<--dk-->>><<<++dk++>>>\n", +| <<<--bdev_partition_name-->>><<<++bdev_partition_name++>>>(<<<--rdev-->>><<<++rdev++>>>-><<<--bdev-->>><<<++bdev++>>>), +| (<<<--unsigned-->>><<<++unsigned long++>>> long<<<-- long-->>>)<<<--rdev-->>><<<++rdev++>>>-><<<--size-->>><<<++size++>>>, +| <<<--mddev-->>><<<++mddev++>>>-><<<--chunk_size-->>><<<++chunk_size++>>> / <<<--1024-->>><<<++1024++>>>); +| <<<--return-->>><<<++return++>>> -<<<--EINVAL-->>><<<++EINVAL++>>>; } } - switch (mddev->level) { - case LEVEL_MULTIPATH: - data_disks = 1; - break; - case -3: - data_disks = 1; - break; - case -2: - data_disks = 1; - break; - case LEVEL_LINEAR: - zoned_raid_size(mddev); - data_disks = 1; - break; - case 0: - zoned_raid_size(mddev); - data_disks = mddev->raid_disks; - break; - case 1: - data_disks = 1; - break; - case 4: - case 5: - data_disks = mddev->raid_disks-1; - break; - default: - printk(KERN_ERR "md: md%d: unsupported raid level %d\n", - mdidx(mddev), mddev->level); - goto abort; +| <<<--switch-->>><<<++switch++>>> (<<<--mddev-->>><<<++mddev++>>>-><<<--level-->>><<<++level++>>>) { +| <<<--case-->>><<<++case++>>> <<<--LEVEL_MULTIPATH-->>><<<++LEVEL_MULTIPATH++>>>: +| <<<--data_disks-->>><<<++data_disks++>>> = 1; +| <<<--break-->>><<<++break++>>>; +| <<<--case-->>><<<++case++>>> -3: +| <<<--data_disks-->>><<<++data_disks++>>> = 1; +| <<<--break-->>><<<++break++>>>; +| <<<--case-->>><<<++case++>>> -2: +| <<<--data_disks-->>><<<++data_disks++>>> = 1; +| <<<--break-->>><<<++break++>>>; +| <<<--case-->>><<<++case++>>> <<<--LEVEL_LINEAR-->>><<<++LEVEL_LINEAR++>>>: +| <<<--zoned_raid_size-->>><<<++zoned_raid_size++>>>(<<<--mddev-->>><<<++mddev++>>>); +| <<<--data_disks-->>><<<++data_disks++>>> = 1; +| <<<--break-->>><<<++break++>>>; +| <<<--case-->>><<<++case++>>> 0: +| <<<--zoned_raid_size-->>><<<++zoned_raid_size++>>>(<<<--mddev-->>><<<++mddev++>>>); +| <<<--data_disks-->>><<<++data_disks++>>> = <<<--mddev-->>><<<++mddev++>>>-><<<--raid_disks-->>><<<++raid_disks++>>>; +| <<<--break-->>><<<++break++>>>; +| <<<--case-->>><<<++case++>>> 1: +| <<<--data_disks-->>><<<++data_disks++>>> = 1; +| <<<--break-->>><<<++break++>>>; +| <<<--case-->>><<<++case++>>> 4: +| <<<--case-->>><<<++case++>>> 5: +| <<<--data_disks-->>><<<++data_disks++>>> = <<<--mddev-->>><<<++mddev++>>>-><<<--raid_disks-->>><<<++raid_disks++>>>-1; +| <<<--break-->>><<<++break++>>>; +| <<<--default-->>><<<++default++>>>: +| <<<--printk-->>><<<++printk++>>>(<<<--KERN_ERR-->>><<<++KERN_ERR++>>> "<<<--md-->>><<<++md++>>>: <<<--md-->>><<<++md++>>>%d: <<<--unsupported-->>><<<++unsupported++>>> <<<--raid-->>><<<++raid++>>> <<<--level-->>><<<++level++>>> %d\n", +| <<<--mdidx-->>><<<++mdidx++>>>(<<<--mddev-->>><<<++mddev++>>>), <<<--mddev-->>><<<++mddev++>>>-><<<--level-->>><<<++level++>>>); +| <<<--goto-->>><<<++goto++>>> <<<--abort-->>><<<++abort++>>>; } - if (!md_size[mdidx(mddev)]) - md_size[mdidx(mddev)] = mddev->size * data_disks; +| <<<--if-->>><<<++if++>>> (!<<<--md_size-->>><<<++md_size++>>>[<<<--mdidx-->>><<<++mdidx++>>>(<<<--mddev-->>><<<++mddev++>>>)]) +| <<<--md_size-->>><<<++md_size++>>>[<<<--mdidx-->>><<<++mdidx++>>>(<<<--mddev-->>><<<++mddev++>>>)] = <<<--mddev-->>><<<++mddev++>>>-><<<--size-->>><<<++size++>>> * <<<--data_disks-->>><<<++data_disks++>>>; - readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; - if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { - readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; - if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) - readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; - } else { - // (no multipath branch - it uses the default setting) - if (mddev->level == -3) - readahead = 0; +| <<<--readahead-->>><<<++readahead++>>> = (<<<--VM_MAX_READAHEAD-->>><<<++VM_MAX_READAHEAD++>>> * <<<--1024-->>><<<++1024++>>>) / <<<--PAGE_SIZE-->>><<<++PAGE_SIZE++>>>; +| if (!<<<--mddev-->>><<<++mddev++>>>-><<<--level-->>><<<++level++>>> || (<<<--mddev-->>><<<++mddev++>>>-><<<--level-->>><<<++level++>>> == 4) || (<<<--mddev-->>><<<++mddev++>>>-><<<--level-->>><<<++level++>>> == 5)) { +| <<<--readahead-->>><<<++readahead++>>> = (<<<--mddev-->>><<<++mddev++>>>-><<<--chunk_size-->>><<<++chunk_size++>>>>><<<--PAGE_SHIFT-->>><<<++PAGE_SHIFT++>>>) * 4 * <<<--data_disks-->>><<<++data_disks++>>>; +| if (<<<--readahead-->>><<<++readahead++>>> < <<<--data_disks-->>><<<++data_disks++>>> * (<<<--MAX_SECTORS-->>><<<++MAX_SECTORS++>>>>>(<<<--PAGE_SHIFT-->>><<<++PAGE_SHIFT++>>>-9))*2) +| <<<--readahead-->>><<<++readahead++>>> = <<<--data_disks-->>><<<++data_disks++>>> * (<<<--MAX_SECTORS-->>><<<++MAX_SECTORS++>>>>>(<<<--PAGE_SHIFT-->>><<<++PAGE_SHIFT++>>>-9))*2; +| } <<<--else-->>><<<++else++>>> { +| // (no <<<--multipath-->>><<<++multipath++>>> <<<--branch-->>><<<++branch++>>> - <<<--it-->>><<<++it++>>> <<<--uses-->>><<<++uses++>>> <<<--the-->>><<<++the++>>> <<<--default-->>><<<++default++>>> <<<--setting-->>><<<++setting++>>>) +| if (<<<--mddev-->>><<<++mddev++>>>-><<<--level-->>><<<++level++>>> == -3) +| <<<--readahead-->>><<<++readahead++>>> = 0; } - printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", - mdidx(mddev), readahead*(PAGE_SIZE/1024)); +| <<<--printk-->>><<<++printk++>>>(<<<--KERN_INFO-->>><<<++KERN_INFO++>>> "<<<--md-->>><<<++md++>>>%d: max <<<--total-->>><<<++total++>>> <<<--readahead-->>><<<++readahead++>>> <<<--window-->>><<<++window++>>> <<<--set-->>><<<++set++>>> <<<--to-->>><<<++to++>>> %<<<--ldk-->>><<<++ldk++>>>\n", +| <<<--mdidx-->>><<<++mdidx++>>>(<<<--mddev-->>><<<++mddev++>>>), <<<--readahead-->>><<<++readahead++>>>*(<<<--PAGE_SIZE-->>><<<++PAGE_SIZE++>>>/<<<--1024-->>><<<++1024++>>>)); - printk(KERN_INFO - "md%d: %d data-disks, max readahead per data-disk: %ldk\n", - mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); - return 0; - abort: - return 1; +| <<<--printk-->>><<<++printk++>>>(<<<--KERN_INFO-->>><<<++KERN_INFO++>>> +| "<<<--md-->>><<<++md++>>>%d: %d <<<--data-->>><<<++data++>>>-<<<--disks-->>><<<++disks++>>>, <<<--max-->>><<<++max++>>> <<<--readahead-->>><<<++readahead++>>> per <<<--data-->>><<<++data++>>>-<<<--disk-->>><<<++disk++>>>: %ldk\n", +| <<<--mdidx-->>><<<++mdidx++>>>(<<<--mddev-->>><<<++mddev++>>>), <<<--data_disks-->>><<<++data_disks++>>>, <<<--readahead-->>><<<++readahead++>>>/<<<--data_disks-->>><<<++data_disks++>>>*(<<<--PAGE_SIZE-->>><<<++PAGE_SIZE++>>>/<<<--1024-->>><<<++1024++>>>)); +| <<<--return-->>><<<++return++>>> 0; +|<<<--abort-->>><<<++abort++>>>: +| <<<--return-->>><<<++return++>>> 1; } - static struct gendisk *md_probe(dev_t dev, int *part, void *data) +|<<<--static-->>><<<++static++>>> <<<--struct-->>><<<++struct++>>> <<<--gendisk-->>><<<++gendisk++>>> *<<<--md_probe-->>><<<++md_probe++>>>(<<<--dev_t-->>><<<++dev_t++>>> <<<--dev-->>><<<++dev++>>>, int *<<<--part-->>><<<++part++>>>, <<<--void-->>><<<++void++>>> *<<<--data-->>><<<++data++>>>) { - static DECLARE_MUTEX(disks_sem); +| <<<--static-->>><<<++static++>>> <<<--DECLARE_MUTEX-->>><<<++DECLARE_MUTEX++>>>(<<<--disks_sem-->>><<<++disks_sem++>>>); - int unit = MINOR(dev); - mddev_t *mddev = mddev_find(unit); - struct gendisk *disk; @@ -1650,17 +1650,15 @@ - char module_name[80]; - sprintf (module_name, "md-personality-%d", pnum); - request_module (module_name); -+*** 1664,9 **** 2 -+ } - } +- } -#endif - - if (device_size_calculation(mddev)) - return -EINVAL; - - /* - * Drop all container device buffers, from now on - * the only valid external interface is through the md +- +- if (device_size_calculation(mddev)) +- return -EINVAL; +- +- /* +- * Drop all container device buffers, from now on +- * the only valid external interface is through the md - * device. - * Also find largest hardsector size - */ @@ -3100,16 +3098,18 @@ - spin_unlock(&pers_lock); - return 0; -} ++*** 1664,9 **** 2 +|<<<++ }++>>> +|<<<--int unregister_md_personality(int pnum)-->>><<<++ }++>>> +|<<<--{-->>> +| if (<<<--pnum >= MAX_PERSONALITY) { +| MD_BUG-->>><<<++device_size_calculation++>>>(<<<++mddev++>>>)<<<--;-->>><<<++)++>>> + return -EINVAL; ++ +| <<<--}-->>><<<++/*++>>> - --int unregister_md_personality(int pnum) --{ -- if (pnum >= MAX_PERSONALITY) { -- MD_BUG(); -- return -EINVAL; -- } -- -- printk(KERN_INFO "md: %s personality unregistered\n", pers[pnum]->name); -- spin_lock(&pers_lock); +|<<<-- printk(KERN_INFO-->>><<<++ * Drop++>>> <<<--"md:-->>><<<++all++>>> <<<--%s-->>><<<++container++>>> <<<--personality-->>><<<++device++>>> <<<--unregistered\n"-->>><<<++buffers++>>>, <<<--pers[pnum]->name);-->>><<<++from now on++>>> +|<<<-- spin_lock(&pers_lock);-->>><<<++ * the only valid external interface is through the md++>>> - pers[pnum] = NULL; - spin_unlock(&pers_lock); - return 0; ./linux/md/diff FAILED 0.15 201 unresolved conflicts found 11 already-applied changes ignored --- wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:58.610914192 +0200 @@ -1436,7 +1436,9 @@ return 1; } -static struct gendisk *md_probe(dev_t dev, int *part, void *data) +<<<---static|||#undef OLD_LEVEL + +static===static --->>><<<---device_size_calculation|||device_size_calculation===--->>><<<---mddev_t|||mddev_t===--->>><<<---mddev|||mddev===--->>><<<---data_disks|||data_disks===--->>><<<---unsigned|||unsigned===--->>><<<---int|||int===--->>><<<---readahead|||readahead===--->>>struct <<<---list_head|||list_head===gendisk--->>><<<---mdk_rdev_t|||mdk_rdev_t===--->>><<<---rdev|||rdev===--->>><<<---device|||device===--->>><<<---size|||size===--->>><<<---calculation|||calculation===--->>><<<---Bail|||Bail===--->>><<<---out|||out===--->>><<<---if|||if===--->>><<<---small|||small===--->>><<<---have|||have===--->>><<<---this|||this===--->>><<<---after|||after===--->>><<<---having|||having===--->>><<<---validated|||validated===--->>><<<---chunk_size|||chunk_size===--->>><<<--- ||| ===--->>><<<---because|||because===--->>><<<---device|||device===--->>><<<---size|||size===--->>><<<---has|||has===--->>><<<---to|||to===--->>><<<---be|||be===--->>><<<---modulo|||modulo===--->>><<<---chunk_size|||chunk_size===--->>><<<---ITERATE_RDEV|||ITERATE_RDEV===--->>><<<---mddev|||mddev===--->>><<<---rdev|||rdev===--->>><<<---tmp|||tmp===--->>><<<---rdev|||rdev===--->>><<<---faulty|||faulty===--->>><<<---continue|||continue===--->>><<<---rdev|||rdev===--->>><<<---size|||size===--->>><<<---mddev|||mddev===--->>><<<---chunk_size|||chunk_size===--->>><<<---1024|||1024===--->>><<<---printk|||printk===--->>><<<---KERN_WARNING|||KERN_WARNING===--->>><<<---md|||md===--->>><<<---Dev|||Dev===--->>><<<---smaller|||smaller===--->>><<<---than|||than===--->>><<<---chunk_size|||chunk_size===--->>><<<---lluk|||lluk===--->>><<<---dk|||dk===--->>><<<---bdev_partition_name|||bdev_partition_name===--->>><<<---rdev|||rdev===--->>><<<---bdev|||bdev===--->>><<<---unsigned|||unsigned long===--->>><<<--- long|||===--->>><<<---rdev|||rdev===--->>><<<---size|||size===--->>><<<---mddev|||mddev===--->>><<<---chunk_size|||chunk_size===--->>><<<---1024|||1024===--->>><<<---return|||return===--->>><<<---EINVAL|||EINVAL===--->>><<<---switch|||switch===--->>><<<---mddev|||mddev===--->>><<<---level|||level===--->>><<<---case|||case===--->>><<<---LEVEL_MULTIPATH|||LEVEL_MULTIPATH===--->>><<<---data_disks|||data_disks===--->>><<<---break|||break===--->>><<<---case|||case===--->>><<<---data_disks|||data_disks===--->>><<<---break|||break===--->>><<<---case|||case===--->>><<<---data_disks|||data_disks===--->>><<<---break|||break===--->>><<<---case|||case===--->>><<<---LEVEL_LINEAR|||LEVEL_LINEAR===--->>><<<---zoned_raid_size|||zoned_raid_size===--->>><<<---mddev|||mddev===--->>><<<---data_disks|||data_disks===--->>><<<---break|||break===--->>><<<---case|||case===--->>><<<---zoned_raid_size|||zoned_raid_size===--->>><<<---mddev|||mddev===--->>><<<---data_disks|||data_disks===--->>><<<---mddev|||mddev===--->>><<<---raid_disks|||raid_disks===--->>><<<---break|||break===--->>><<<---case|||case===--->>><<<---data_disks|||data_disks===--->>><<<---break|||break===--->>><<<---case|||case===--->>><<<---case|||case===--->>><<<---data_disks|||data_disks===--->>><<<---mddev|||mddev===--->>><<<---raid_disks|||raid_disks===--->>><<<---break|||break===--->>><<<---default|||default===--->>><<<---printk|||printk===--->>><<<---KERN_ERR|||KERN_ERR===--->>><<<---md|||md===--->>><<<---md|||md===--->>><<<---unsupported|||unsupported===--->>><<<---raid|||raid===--->>><<<---level|||level===--->>><<<---mdidx|||mdidx===--->>><<<---mddev|||mddev===--->>><<<---mddev|||mddev===--->>><<<---level|||level===--->>><<<---goto|||goto===--->>><<<---abort|||abort===--->>><<<---if|||if===--->>><<<---md_size|||md_size===--->>><<<---mdidx|||mdidx===--->>><<<---mddev|||mddev===--->>><<<---md_size|||md_size===--->>><<<---mdidx|||mdidx===--->>><<<---mddev|||mddev===--->>><<<---mddev|||mddev===--->>><<<---size|||size===--->>><<<---data_disks|||data_disks===--->>><<<---readahead|||readahead===--->>><<<---VM_MAX_READAHEAD|||VM_MAX_READAHEAD===--->>><<<---1024|||1024===--->>><<<---PAGE_SIZE|||PAGE_SIZE===--->>><<<---mddev|||mddev===--->>><<<---level|||level===--->>><<<---mddev|||mddev===--->>><<<---level|||level===--->>><<<---mddev|||mddev===--->>><<<---level|||level===--->>><<<---readahead|||readahead===--->>><<<---mddev|||mddev===--->>><<<---chunk_size|||chunk_size===--->>><<<---PAGE_SHIFT|||PAGE_SHIFT===--->>><<<---data_disks|||data_disks===--->>><<<---readahead|||readahead===--->>><<<---data_disks|||data_disks===--->>><<<---MAX_SECTORS|||MAX_SECTORS===--->>><<<---PAGE_SHIFT|||PAGE_SHIFT===--->>><<<---readahead|||readahead===--->>><<<---data_disks|||data_disks===--->>><<<---MAX_SECTORS|||MAX_SECTORS===--->>><<<---PAGE_SHIFT|||PAGE_SHIFT===--->>><<<---else|||else===--->>><<<---multipath|||multipath===--->>><<<---branch|||branch===--->>><<<---it|||it===--->>><<<---uses|||uses===--->>><<<---the|||the===--->>><<<---default|||default===--->>><<<---setting|||setting===--->>><<<---mddev|||mddev===--->>><<<---level|||level===--->>><<<---readahead|||readahead===--->>><<<---printk|||printk===--->>><<<---KERN_INFO|||KERN_INFO===--->>><<<---md|||md===--->>><<<---total|||total===--->>><<<---readahead|||readahead===--->>><<<---window|||window===--->>><<<---set|||set===--->>><<<---to|||to===--->>><<<---ldk|||ldk===--->>><<<---mdidx|||mdidx===--->>><<<---mddev|||mddev===--->>><<<---readahead|||readahead===--->>><<<---PAGE_SIZE|||PAGE_SIZE===--->>><<<---1024|||1024===--->>><<<---printk|||printk===--->>><<<---KERN_INFO|||KERN_INFO===--->>><<<---md|||md===--->>><<<---data|||data===--->>><<<---disks|||disks===--->>><<<---max|||max===--->>><<<---readahead|||readahead===--->>><<<---data|||data===--->>><<<---disk|||disk===--->>><<<---mdidx|||mdidx===--->>><<<---mddev|||mddev===--->>><<<---data_disks|||data_disks===--->>><<<---readahead|||readahead===--->>><<<---data_disks|||data_disks===--->>><<<---PAGE_SIZE|||PAGE_SIZE===--->>><<<---1024|||1024===--->>><<<---return|||return===--->>><<<---abort|||abort===--->>><<<---return|||return===--->>><<<---static|||static===--->>><<<---struct|||struct===--->>><<<---gendisk|||gendisk===--->>> *md_probe(dev_t dev, int *part, void *data) { static DECLARE_MUTEX(disks_sem); int unit = MINOR(dev); @@ -1567,6 +1569,9 @@ } #endif + if (device_size_calculation(mddev)) + return -EINVAL; + /* * Drop all container device buffers, from now on * the only valid external interface is through the md @@ -3012,13 +3017,11 @@ int unregister_md_personality(int pnum) { - if (pnum >= MAX_PERSONALITY) { - MD_BUG(); - return -EINVAL; - } - - printk(KERN_INFO "md: %s personality unregistered\n", pers[pnum]->name); - spin_lock(&pers_lock); +<<<---pnum >= MAX_PERSONALITY) { + MD_BUG|||device_size_calculation===--->>><<<---;|||)===--->>> } +<<<--- + printk(KERN_INFO||| * Drop=== * Drop--->>> "md: %s personality <<<---unregistered\n"|||buffers===buffers--->>>, <<<---pers[pnum]->name);|||from now on===from now on--->>> +<<<--- spin_lock(&pers_lock);||| * the only valid external interface is through the md=== * the only valid external interface is through the md--->>> pers[pnum] = NULL; spin_unlock(&pers_lock); return 0; ./linux/md/wmerge FAILED 0.15 --- rediff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:58.836977342 +0200 @@ -2,93 +2,93 @@ return 1; } --#undef OLD_LEVEL -- --static int device_size_calculation(mddev_t * mddev) --{ -- int data_disks = 0; -- unsigned int readahead; -- struct list_head *tmp; -- mdk_rdev_t *rdev; -- -- /* -- * Do device size calculation. Bail out if too small. -- * (we have to do this after having validated chunk_size, -- * because device size has to be modulo chunk_size) -- */ -- -- ITERATE_RDEV(mddev,rdev,tmp) { -- if (rdev->faulty) -- continue; -- if (rdev->size < mddev->chunk_size / 1024) { -- printk(KERN_WARNING -- "md: Dev %s smaller than chunk_size:" -- " %lluk < %dk\n", -- bdev_partition_name(rdev->bdev), -- (unsigned long long)rdev->size, -- mddev->chunk_size / 1024); -- return -EINVAL; -- } -- } -- -- switch (mddev->level) { -- case LEVEL_MULTIPATH: -- data_disks = 1; -- break; -- case -3: -- data_disks = 1; -- break; -- case -2: -- data_disks = 1; -- break; -- case LEVEL_LINEAR: -- zoned_raid_size(mddev); -- data_disks = 1; -- break; -- case 0: -- zoned_raid_size(mddev); -- data_disks = mddev->raid_disks; -- break; -- case 1: -- data_disks = 1; -- break; -- case 4: -- case 5: -- data_disks = mddev->raid_disks-1; -- break; -- default: -- printk(KERN_ERR "md: md%d: unsupported raid level %d\n", -- mdidx(mddev), mddev->level); -- goto abort; -- } -- if (!md_size[mdidx(mddev)]) -- md_size[mdidx(mddev)] = mddev->size * data_disks; -- -- readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; -- if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { -- readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; -- if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) -- readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; -- } else { -- // (no multipath branch - it uses the default setting) -- if (mddev->level == -3) -- readahead = 0; -- } -- -- printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", -- mdidx(mddev), readahead*(PAGE_SIZE/1024)); -- -- printk(KERN_INFO -- "md%d: %d data-disks, max readahead per data-disk: %ldk\n", -- mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); -- return 0; --abort: -- return 1; --} -- - static struct gendisk *md_probe(dev_t dev, int *part, void *data) +|<<<--#undef-->>><<<++static++>>> <<<--OLD_LEVEL +| +|static int device_size_calculation(mddev_t * mddev) +|{ +| int data_disks = 0; +| unsigned int readahead; +| -->>>struct <<<--list_head *tmp; +| mdk_rdev_t *rdev; +| +| /* +| * Do device size calculation. Bail out if too small. +| * (we have to do this after having validated chunk_size, +| * because device size has to be modulo chunk_size) +| */ +| +| ITERATE_RDEV(mddev,rdev,tmp) { +| if (rdev->faulty) +| continue; +| if (rdev->size < mddev->chunk_size / 1024) { +| printk(KERN_WARNING +| "md: Dev %s smaller than chunk_size:" +| " %lluk < %dk\n", +| bdev_partition_name(rdev->bdev), +| (unsigned long long)rdev->size, +| mddev->chunk_size / 1024); +| return -EINVAL; +| } +| } +| +| switch (mddev->level) { +| case LEVEL_MULTIPATH: +| data_disks = 1; +| break; +| case -3: +| data_disks = 1; +| break; +| case -2: +| data_disks = 1; +| break; +| case LEVEL_LINEAR: +| zoned_raid_size(mddev); +| data_disks = 1; +| break; +| case 0: +| zoned_raid_size(mddev); +| data_disks = mddev->raid_disks; +| break; +| case 1: +| data_disks = 1; +| break; +| case 4: +| case 5: +| data_disks = mddev->raid_disks-1; +| break; +| default: +| printk(KERN_ERR "md: md%d: unsupported raid level %d\n", +| mdidx(mddev), mddev->level); +| goto abort; +| } +| if (!md_size[mdidx(mddev)]) +| md_size[mdidx(mddev)] = mddev->size * data_disks; +| +| readahead = (VM_MAX_READAHEAD * 1024) / PAGE_SIZE; +| if (!mddev->level || (mddev->level == 4) || (mddev->level == 5)) { +| readahead = (mddev->chunk_size>>PAGE_SHIFT) * 4 * data_disks; +| if (readahead < data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2) +| readahead = data_disks * (MAX_SECTORS>>(PAGE_SHIFT-9))*2; +| } else { +| // (no multipath branch - it uses the default setting) +| if (mddev->level == -3) +| readahead = 0; +| } +| +| printk(KERN_INFO "md%d: max total readahead window set to %ldk\n", +| mdidx(mddev), readahead*(PAGE_SIZE/1024)); +| +| printk(KERN_INFO +| "md%d: %d data-disks, max readahead per data-disk: %ldk\n", +| mdidx(mddev), data_disks, readahead/data_disks*(PAGE_SIZE/1024)); +| return 0; +|abort: +| return 1; +|} +| +|static struct gendisk-->>><<<++gendisk++>>> *md_probe(<<<--dev_t-->>><<<++dev_t++>>> <<<--dev-->>><<<++dev++>>>, int *<<<--part-->>><<<++part++>>>, <<<--void-->>><<<++void++>>> *<<<--data-->>><<<++data++>>>) { - static DECLARE_MUTEX(disks_sem); +| static <<<--DECLARE_MUTEX-->>><<<++DECLARE_MUTEX++>>>(<<<--disks_sem-->>><<<++disks_sem++>>>); @@ -1664,9 +1571,6 @@ } } @@ -97,5 +97,5 @@ - return -EINVAL; - /* - * Drop all container device buffers, from now on - * the only valid external interface is through the md +|<<<-- -->>><<<++ ++>>>* <<<--Drop-->>><<<++Drop++>>> all container device <<<--buffers-->>><<<++buffers++>>>, from <<<--now-->>><<<++now++>>> <<<--on-->>><<<++on++>>> +| * the only <<<--valid-->>><<<++valid++>>> <<<--external-->>><<<++external++>>> interface is <<<--through-->>><<<++through++>>> <<<--the-->>><<<++the++>>> <<<--md-->>><<<++md++>>> ./linux/md/rediff FAILED 0.00 10 unresolved conflicts found 39 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:58.890859267 +0200 @@ -1345,11 +1345,23 @@ } if (rdev) { r10_bio->devs[i].bio = bio; +<<<<<<< found + atomic_inc(&rdev->nr_pending); + if (rrdev) { + r10_bio->devs[i].repl_bio = bio; + atomic_inc(&rrdev->nr_pending); +||||||| expected + atomic_inc(&rdev->nr_pending); + if (rrdev) { + r10_bio->devs[i].repl_bio = bio; + atomic_inc(&rrdev->nr_pending); +======= atomic_inc(&rdev->nr_pending); } if (rrdev) { r10_bio->devs[i].repl_bio = bio; atomic_inc(&rrdev->nr_pending); +>>>>>>> replacement } } rcu_read_unlock(); @@ -1400,21 +1412,67 @@ bitmap_startwrite(mddev->bitmap, r10_bio->sector, r10_bio->sectors, 0); for (i = 0; i < conf->copies; i++) { +<<<<<<< found + struct bio *mbio; + int d = r10_bio->devs[i].devnum; + if (!r10_bio->devs[i].bio) + continue; + + mbio = bio_clone_mddev(bio, GFP_NOIO, mddev); +||||||| expected + struct bio *mbio; + int d = r10_bio->devs[i].devnum; + if (!r10_bio->devs[i].bio) + continue; + + mbio = bio_clone_mddev(bio, GFP_NOIO, mddev); +======= struct bio *mbio; int d = r10_bio->devs[i].devnum; if (r10_bio->devs[i].bio) { struct md_rdev *rdev = conf->mirrors[d].rdev; mbio = bio_clone_mddev(bio, GFP_NOIO, mddev); +>>>>>>> replacement +<<<<<<< found + md_trim_bio(mbio, r10_bio->sector - bio->bi_sector, + max_sectors); + r10_bio->devs[i].bio = mbio; +||||||| expected + md_trim_bio(mbio, r10_bio->sector - bio->bi_sector, + max_sectors); + r10_bio->devs[i].bio = mbio; +======= md_trim_bio(mbio, r10_bio->sector - bio->bi_sector, max_sectors); r10_bio->devs[i].bio = mbio; +>>>>>>> replacement +<<<<<<< found + mbio->bi_sector = (r10_bio->devs[i].addr+ + choose_data_offset(r10_bio, + conf->mirrors[d].rdev)); +||||||| expected + mbio->bi_sector = (r10_bio->devs[i].addr+ + choose_data_offset(r10_bio, + conf->mirrors[d].rdev)); +======= mbio->bi_sector = (r10_bio->devs[i].addr+ choose_data_offset(r10_bio, rdev)); +>>>>>>> replacement +<<<<<<< found + mbio->bi_bdev = conf->mirrors[d].rdev->bdev; + mbio->bi_end_io = raid10_end_write_request; + mbio->bi_rw = WRITE | do_sync | do_fua; +||||||| expected + mbio->bi_bdev = conf->mirrors[d].rdev->bdev; + mbio->bi_end_io = raid10_end_write_request; + mbio->bi_rw = WRITE | do_sync | do_fua | do_discard; +======= mbio->bi_bdev = rdev->bdev; mbio->bi_end_io = raid10_end_write_request; - mbio->bi_rw = WRITE | do_sync | do_fua; + mbio->bi_rw = WRITE | do_sync | do_fua | do_discard; +>>>>>>> replacement mbio->bi_private = r10_bio; <<<<<<< found @@ -1444,7 +1502,6 @@ <<<<<<< found bio_list_add(&conf->pending_bio_list, mbio); conf->pending_count++; - spin_unlock_irqrestore(&conf->device_lock, flags); ||||||| expected if (plug) { bio_list_add(&plug->pending, mbio); @@ -1452,8 +1509,6 @@ } else { bio_list_add(&conf->pending_bio_list, mbio); conf->pending_count++; - } - spin_unlock_irqrestore(&conf->device_lock, flags); ======= if (plug) { bio_list_add(&plug->pending, mbio); @@ -1461,11 +1516,22 @@ } else { bio_list_add(&conf->pending_bio_list, mbio); conf->pending_count++; +>>>>>>> replacement +<<<<<<< found + spin_unlock_irqrestore(&conf->device_lock, flags); + if (!mddev_check_plugged(mddev)) + md_wakeup_thread(mddev->thread); +||||||| expected + } + spin_unlock_irqrestore(&conf->device_lock, flags); + if (!plug) + md_wakeup_thread(mddev->thread); +======= } spin_unlock_irqrestore(&conf->device_lock, flags); ->>>>>>> replacement - if (!mddev_check_plugged(mddev)) + if (!plug) md_wakeup_thread(mddev->thread); +>>>>>>> replacement } if (r10_bio->devs[i].repl_bio) { @@ -1485,13 +1551,31 @@ r10_bio, rdev)); mbio->bi_bdev = rdev->bdev; mbio->bi_end_io = raid10_end_write_request; - mbio->bi_rw = WRITE | do_sync | do_fua; +<<<<<<< found + mbio->bi_rw = WRITE | do_sync | do_fua; + mbio->bi_private = r10_bio; +||||||| expected + mbio->bi_rw = WRITE | do_sync | do_fua | do_discard; + mbio->bi_private = r10_bio; +======= + mbio->bi_rw = WRITE | do_sync | do_fua | do_discard; mbio->bi_private = r10_bio; +>>>>>>> replacement atomic_inc(&r10_bio->remaining); +<<<<<<< found + spin_lock_irqsave(&conf->device_lock, flags); + bio_list_add(&conf->pending_bio_list, mbio); + conf->pending_count++; +||||||| expected + spin_lock_irqsave(&conf->device_lock, flags); + bio_list_add(&conf->pending_bio_list, mbio); + conf->pending_count++; +======= spin_lock_irqsave(&conf->device_lock, flags); bio_list_add(&conf->pending_bio_list, mbio); conf->pending_count++; +>>>>>>> replacement spin_unlock_irqrestore(&conf->device_lock, flags); if (!mddev_check_plugged(mddev)) md_wakeup_thread(mddev->thread); ./linux/raid10-race/merge FAILED 0.19 5 unresolved conflicts found 4136 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:36:59.153140195 +0200 @@ -642,12 +642,14 @@ <<<<<<< found del_mddev_mapping(mddev, MKDEV(MD_MAJOR, mdidx(mddev))); + md_list_del(&mddev->all_mddevs); ||||||| expected del_mddev_mapping(mddev, mk_kdev(MD_MAJOR, mdidx(mddev))); + md_list_del(&mddev->all_mddevs); ======= mddev_map[mdidx(mddev)] = NULL; ->>>>>>> replacement md_list_del(&mddev->all_mddevs); +>>>>>>> replacement kfree(mddev); MOD_DEC_USE_COUNT; } @@ -1990,17 +1992,49 @@ #undef BAD_VERSION #undef OUT_OF_MEM +<<<<<<< found +#undef NO_DEVICE +#undef AUTOADD_FAILED_USED +||||||| expected +#undef NO_DEVICE +#undef AUTOADD_FAILED_USED +#undef AUTOADD_FAILED +======= #undef NO_DEVICE #undef AUTOADD_FAILED_USED #undef AUTOADD_FAILED #undef AUTORUN_FAILED +>>>>>>> replacement +<<<<<<< found +#undef AUTOADD_FAILED +#undef AUTORUN_FAILED #undef AUTOADDING +||||||| expected +#undef AUTORUN_FAILED +#undef AUTOADDING +#undef AUTORUNNING +======= +#undef AUTOADDING +#undef AUTORUNNING + +>>>>>>> replacement #undef AUTORUNNING +<<<<<<< found static int get_version(void * arg) { mdu_version_t ver; +||||||| expected + +static int get_version(void * arg) +{ + mdu_version_t ver; +======= +static int get_version(void * arg) +{ + mdu_version_t ver; +>>>>>>> replacement ver.major = MD_MAJOR_VERSION; ver.minor = MD_MINOR_VERSION; @@ -3949,12 +3983,18 @@ MD_EXPORT_SYMBOL(md_update_sb); MD_EXPORT_SYMBOL(md_wakeup_thread); MD_EXPORT_SYMBOL(md_print_devices); +<<<<<<< found MD_EXPORT_SYMBOL(find_rdev_nr); MD_EXPORT_SYMBOL(md_interrupt_thread); -<<<<<<< found MD_EXPORT_SYMBOL(mddev_map); +MODULE_LICENSE("GPL"); ||||||| expected +MD_EXPORT_SYMBOL(find_rdev_nr); +MD_EXPORT_SYMBOL(md_interrupt_thread); EXPORT_SYMBOL(mddev_map); +MODULE_LICENSE("GPL"); ======= ->>>>>>> replacement +MD_EXPORT_SYMBOL(find_rdev_nr); +MD_EXPORT_SYMBOL(md_interrupt_thread); MODULE_LICENSE("GPL"); +>>>>>>> replacement ./linux/md-loop/merge FAILED 6.36 47 unresolved conflicts found 242 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:05.680594488 +0200 @@ -140,28 +140,66 @@ return sh; } +<<<<<<< found +static void shrink_buffers(struct stripe_head *sh, int num) +{ + struct buffer_head *bh; +||||||| expected +static void shrink_buffers(struct stripe_head *sh, int num) +{ + struct buffer_head *bh; +======= static void shrink_buffers(struct stripe_head *sh, int num) { struct page *p; +>>>>>>> replacement int i; +<<<<<<< found + for (i=0; ibh_cache[i]; + if (!bh) + return; + sh->bh_cache[i] = NULL; + free_page((unsigned long) bh->b_data); + kfree(bh); +||||||| expected + for (i=0; ibh_cache[i]; + if (!bh) + return; + sh->bh_cache[i] = NULL; + free_page((unsigned long) bh->b_data); + kfree(bh); +======= for (i=0; idev[i].page; if (!p) continue; sh->dev[i].page = NULL; page_cache_release(p); +>>>>>>> replacement } } +<<<<<<< found +static int grow_buffers(struct stripe_head *sh, int num, int b_size, int priority) +{ + struct buffer_head *bh; +||||||| expected +static int grow_buffers(struct stripe_head *sh, int num, int b_size, int priority) +{ + struct buffer_head *bh; +======= static int grow_buffers(struct stripe_head *sh, int num) { +>>>>>>> replacement int i; for (i=0; ib_data = page_address(page); else { + kfree(bh); + return 1; + } + atomic_set(&bh->b_count, 0); + bh->b_page = page; + sh->bh_cache[i] = bh; ||||||| expected + bh = kmalloc(sizeof(struct buffer_head), priority); if (!bh) return 1; memset(bh, 0, sizeof (struct buffer_head)); if ((page = alloc_page(priority))) bh->b_data = page_address(page); else { + kfree(bh); + return 1; + } + atomic_set(&bh->b_count, 0); + bh->b_page = page; + sh->bh_cache[i] = bh; ======= + if (!(page = alloc_page(GFP_KERNEL))) { ->>>>>>> replacement return 1; } sh->dev[i].page = page; +>>>>>>> replacement } return 0; } +<<<<<<< found +static struct buffer_head *raid5_build_block (struct stripe_head *sh, int i); + +static inline void init_stripe(struct stripe_head *sh, unsigned long sector) +||||||| expected +static struct buffer_head *raid5_build_block (struct stripe_head *sh, int i); + +static inline void init_stripe(struct stripe_head *sh, unsigned long sector) +======= static void raid5_build_block (struct stripe_head *sh, int i); static inline void init_stripe(struct stripe_head *sh, unsigned long sector, int pd_idx) +>>>>>>> replacement { raid5_conf_t *conf = sh->raid_conf; int disks = conf->raid_disks, i; @@ -199,14 +261,49 @@ BUG(); CHECK_DEVLOCK(); +<<<<<<< found PRINTK("init_stripe called, stripe %lu\n", sh->sector); +||||||| expected remove_hash(sh); +======= + remove_hash(sh); +>>>>>>> replacement +<<<<<<< found + remove_hash(sh); + + sh->sector = sector; + sh->size = conf->buffer_size; + sh->state = 0; +||||||| expected + + sh->sector = sector; + sh->size = conf->buffer_size; + sh->state = 0; +======= sh->sector = sector; sh->pd_idx = pd_idx; sh->state = 0; +>>>>>>> replacement +<<<<<<< found + for (i=disks; i--; ) { + if (sh->bh_read[i] || sh->bh_write[i] || sh->bh_written[i] || + buffer_locked(sh->bh_cache[i])) { + printk("sector=%lx i=%d %p %p %p %d\n", + sh->sector, i, sh->bh_read[i], + sh->bh_write[i], sh->bh_written[i], + buffer_locked(sh->bh_cache[i])); +||||||| expected + for (i=disks; i--; ) { + if (sh->bh_read[i] || sh->bh_write[i] || sh->bh_written[i] || + buffer_locked(sh->bh_cache[i])) { + printk("sector=%lx i=%d %p %p %p %d\n", + sh->sector, i, sh->bh_read[i], + sh->bh_write[i], sh->bh_written[i], + buffer_locked(sh->bh_cache[i])); +======= for (i=disks; i--; ) { struct r5dev *dev = &sh->dev[i]; @@ -216,13 +313,18 @@ sh->sector, i, dev->toread, dev->towrite, dev->written, test_bit(R5_LOCKED, &dev->flags)); +>>>>>>> replacement +<<<<<<< found BUG(); } -<<<<<<< found clear_bit(BH_Uptodate, &sh->bh_cache[i]->b_state); ||||||| expected + BUG(); + } clear_buffer_uptodate(sh->bh_cache[i]); ======= + BUG(); + } dev->flags = 0; >>>>>>> replacement raid5_build_block(sh, i); @@ -412,31 +514,63 @@ if (sh->bh_page[i] != bh->b_page) { bh->b_page = sh->bh_page[i]; bh->b_data = page_address(bh->b_page); +<<<<<<< found + sh->bh_page[i] = NULL; +||||||| expected + sh->bh_page[i] = NULL; +======= +>>>>>>> replacement clear_bit(BH_Uptodate, &bh->b_state); } #endif <<<<<<< found clear_bit(BH_Lock, &bh->b_state); + set_bit(STRIPE_HANDLE, &sh->state); + release_stripe(sh); ||||||| expected clear_buffer_locked(bh); + set_bit(STRIPE_HANDLE, &sh->state); + release_stripe(sh); ======= clear_bit(R5_LOCKED, &sh->dev[i].flags); ->>>>>>> replacement set_bit(STRIPE_HANDLE, &sh->state); release_stripe(sh); +>>>>>>> replacement } +<<<<<<< found +static void raid5_end_write_request (struct buffer_head *bh, int uptodate) +{ + struct stripe_head *sh = bh->b_private; +||||||| expected +static void raid5_end_write_request (struct buffer_head *bh, int uptodate) +{ + struct stripe_head *sh = bh->b_private; +======= static void raid5_end_write_request (struct bio *bi) { struct stripe_head *sh = bi->bi_private; +>>>>>>> replacement raid5_conf_t *conf = sh->raid_conf; int disks = conf->raid_disks, i; unsigned long flags; int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags); +<<<<<<< found + + for (i=0 ; ibh_cache[i]) + break; +||||||| expected + + for (i=0 ; ibh_cache[i]) + break; +======= for (i=0 ; idev[i].req) break; +>>>>>>> replacement PRINTK("end_write_request %lu/%d, count %d, uptodate: %d.\n", sh->sector, i, atomic_read(&sh->count), uptodate); if (i == disks) { @@ -444,15 +578,19 @@ return; } +<<<<<<< found spin_lock_irqsave(&conf->device_lock, flags); if (!uptodate) -<<<<<<< found md_error(conf->mddev, bh->b_dev); clear_bit(BH_Lock, &bh->b_state); ||||||| expected + spin_lock_irqsave(&conf->device_lock, flags); + if (!uptodate) md_error(conf->mddev, bh->b_bdev); clear_buffer_locked(bh); ======= + spin_lock_irqsave(&conf->device_lock, flags); + if (!uptodate) md_error(conf->mddev, bi->bi_bdev); clear_bit(R5_LOCKED, &sh->dev[i].flags); @@ -734,34 +872,74 @@ static void compute_block(struct stripe_head *sh, int dd_idx) { +<<<<<<< found + raid5_conf_t *conf = sh->raid_conf; + int i, count, disks = conf->raid_disks; + struct buffer_head *bh_ptr[MAX_XOR_BLOCKS], *bh; + + PRINTK("compute_block, stripe %lu, idx %d\n", sh->sector, dd_idx); +||||||| expected + raid5_conf_t *conf = sh->raid_conf; + int i, count, disks = conf->raid_disks; + struct buffer_head *bh_ptr[MAX_XOR_BLOCKS], *bh; + + PRINTK("compute_block, stripe %lu, idx %d\n", sh->sector, dd_idx); +======= raid5_conf_t *conf = sh->raid_conf; int i, count, disks = conf->raid_disks; void *ptr[MAX_XOR_BLOCKS], *p; PRINTK("compute_block, stripe %lu, idx %d\n", sh->sector, dd_idx); +>>>>>>> replacement +<<<<<<< found + memset(sh->bh_cache[dd_idx]->b_data, 0, sh->size); + bh_ptr[0] = sh->bh_cache[dd_idx]; + count = 1; +||||||| expected + memset(sh->bh_cache[dd_idx]->b_data, 0, sh->size); + bh_ptr[0] = sh->bh_cache[dd_idx]; + count = 1; +======= ptr[0] = page_address(sh->dev[dd_idx].page); memset(ptr[0], 0, STRIPE_SIZE); count = 1; +>>>>>>> replacement for (i = disks ; i--; ) { +<<<<<<< found + if (i == dd_idx) + continue; + bh = sh->bh_cache[i]; + if (buffer_uptodate(bh)) + bh_ptr[count++] = bh; +||||||| expected + if (i == dd_idx) + continue; + bh = sh->bh_cache[i]; + if (buffer_uptodate(bh)) + bh_ptr[count++] = bh; +======= if (i == dd_idx) continue; p = page_address(sh->dev[i].page); if (test_bit(R5_UPTODATE, &sh->dev[i].flags)) ptr[count++] = p; +>>>>>>> replacement else printk("compute_block() %d, stripe %lu, %d not present\n", dd_idx, sh->sector, i); check_xor(); } - if (count != 1) <<<<<<< found + if (count != 1) xor_block(count, bh_ptr); set_bit(BH_Uptodate, &sh->bh_cache[dd_idx]->b_state); ||||||| expected + if (count != 1) xor_block(count, bh_ptr); set_buffer_uptodate(sh->bh_cache[dd_idx]); ======= + if (count != 1) xor_block(count, STRIPE_SIZE, ptr); set_bit(R5_UPTODATE, &sh->dev[i].flags); >>>>>>> replacement @@ -841,9 +1019,19 @@ switch(method) { case RECONSTRUCT_WRITE: case CHECK_PARITY: +<<<<<<< found + for (i=disks; i--;) + if (i != pd_idx) { + bh_ptr[count++] = sh->bh_cache[i]; +||||||| expected + for (i=disks; i--;) + if (i != pd_idx) { + bh_ptr[count++] = sh->bh_cache[i]; +======= for (i=disks; i--;) if (i != pd_idx) { ptr[count++] = page_address(sh->dev[i].page); +>>>>>>> replacement check_xor(); } break; @@ -857,18 +1045,20 @@ if (count != 1) xor_block(count, STRIPE_SIZE, ptr); - if (method != CHECK_PARITY) { <<<<<<< found + if (method != CHECK_PARITY) { mark_buffer_uptodate(sh->bh_cache[pd_idx], 1); set_bit(BH_Lock, &sh->bh_cache[pd_idx]->b_state); } else mark_buffer_uptodate(sh->bh_cache[pd_idx], 0); ||||||| expected + if (method != CHECK_PARITY) { set_buffer_uptodate(sh->bh_cache[pd_idx]); set_buffer_locked(sh->bh_cache[pd_idx]); } else clear_buffer_uptodate(sh->bh_cache[pd_idx]); ======= + if (method != CHECK_PARITY) { set_bit(R5_UPTODATE, &sh->dev[pd_idx].flags); set_bit(R5_LOCKED, &sh->dev[pd_idx].flags); } else @@ -876,6 +1066,15 @@ >>>>>>> replacement } +<<<<<<< found +static void add_stripe_bh (struct stripe_head *sh, struct buffer_head *bh, int dd_idx, int rw) +{ + struct buffer_head **bhp; +||||||| expected +static void add_stripe_bh (struct stripe_head *sh, struct buffer_head *bh, int dd_idx, int rw) +{ + struct buffer_head **bhp; +======= /* * Each stripe/dev can have one or more bion attached. * toread/towrite point to the first in a chain. @@ -884,11 +1083,45 @@ static void add_stripe_bio (struct stripe_head *sh, struct bio *bi, int dd_idx, int forwrite) { struct bio **bip; +>>>>>>> replacement +<<<<<<< found + raid5_conf_t *conf = sh->raid_conf; + + PRINTK("adding bh b#%lu to stripe s#%lu\n", bh->b_blocknr, sh->sector); +||||||| expected + raid5_conf_t *conf = sh->raid_conf; + + PRINTK("adding bh b#%lu to stripe s#%lu\n", bh->b_blocknr, sh->sector); +======= raid5_conf_t *conf = sh->raid_conf; PRINTK("adding bh b#%lu to stripe s#%lu\n", bi->bi_sector, sh->sector); +>>>>>>> replacement +<<<<<<< found + spin_lock(&sh->lock); + spin_lock_irq(&conf->device_lock); + bh->b_reqnext = NULL; + if (rw == READ) + bhp = &sh->bh_read[dd_idx]; + else + bhp = &sh->bh_write[dd_idx]; + while (*bhp) { + printk(KERN_NOTICE "raid5: multiple %d requests for sector %ld\n", rw, sh->sector); + bhp = & (*bhp)->b_reqnext; +||||||| expected + spin_lock(&sh->lock); + spin_lock_irq(&conf->device_lock); + bh->b_reqnext = NULL; + if (rw == READ) + bhp = &sh->bh_read[dd_idx]; + else + bhp = &sh->bh_write[dd_idx]; + while (*bhp) { + printk(KERN_NOTICE "raid5: multiple %d requests for sector %ld\n", rw, sh->sector); + bhp = & (*bhp)->b_reqnext; +======= spin_lock(&sh->lock); spin_lock_irq(&conf->device_lock); if (forwrite) @@ -902,10 +1135,21 @@ BUG(); if (*bip) bi->bi_next = *bip; +>>>>>>> replacement +<<<<<<< found + *bhp = bh; + spin_unlock_irq(&conf->device_lock); + spin_unlock(&sh->lock); +||||||| expected + *bhp = bh; + spin_unlock_irq(&conf->device_lock); + spin_unlock(&sh->lock); +======= *bip = bi; bi->bi_phys_segments ++; spin_unlock_irq(&conf->device_lock); spin_unlock(&sh->lock); +>>>>>>> replacement if (forwrite) { /* check if page is coverred */ @@ -921,7 +1165,13 @@ set_bit(R5_OVERWRITE, &sh->dev[dd_idx].flags); } +<<<<<<< found + PRINTK("added bh b#%lu to stripe s#%lu, disk %d.\n", bh->b_blocknr, sh->sector, dd_idx); +||||||| expected + PRINTK("added bh b#%lu to stripe s#%lu, disk %d.\n", bh->b_blocknr, sh->sector, dd_idx); +======= PRINTK("added bi b#%lu to stripe s#%lu, disk %d.\n", bi->bi_sector, sh->sector, dd_idx); +>>>>>>> replacement } @@ -1096,31 +1346,65 @@ if (uptodate == disks-1) { PRINTK("Computing block %d\n", i); compute_block(sh, i); +<<<<<<< found uptodate++; } else if (conf->disks[i].operational) { -<<<<<<< found set_bit(BH_Lock, &bh->b_state); action[i] = READ+1; ||||||| expected + uptodate++; + } else if (conf->disks[i].operational) { set_buffer_locked(bh); action[i] = READ+1; ======= + uptodate++; + } else if (conf->disks[i].operational) { set_bit(R5_LOCKED, &dev->flags); action[i] = READ+1; #if 0 >>>>>>> replacement +<<<<<<< found + /* if I am just reading this block and we don't have + a failed drive, or any pending writes then sidestep the cache */ + if (sh->bh_page[i]) BUG(); + if (sh->bh_read[i] && !sh->bh_read[i]->b_reqnext && + ! syncing && !failed && !to_write) { + sh->bh_page[i] = sh->bh_cache[i]->b_page; + sh->bh_cache[i]->b_page = sh->bh_read[i]->b_page; + sh->bh_cache[i]->b_data = sh->bh_read[i]->b_data; +||||||| expected + /* if I am just reading this block and we don't have + a failed drive, or any pending writes then sidestep the cache */ + if (sh->bh_page[i]) BUG(); + if (sh->bh_read[i] && !sh->bh_read[i]->b_reqnext && + ! syncing && !failed && !to_write) { + sh->bh_page[i] = sh->bh_cache[i]->b_page; + sh->bh_cache[i]->b_page = sh->bh_read[i]->b_page; + sh->bh_cache[i]->b_data = sh->bh_read[i]->b_data; +======= /* if I am just reading this block and we don't have a failed drive, or any pending writes then sidestep the cache */ if (sh->bh_read[i] && !sh->bh_read[i]->b_reqnext && ! syncing && !failed && !to_write) { sh->bh_cache[i]->b_page = sh->bh_read[i]->b_page; sh->bh_cache[i]->b_data = sh->bh_read[i]->b_data; +>>>>>>> replacement } #endif locked++; +<<<<<<< found + PRINTK("Reading block %d (sync=%d)\n", i, syncing); + if (syncing) + md_sync_acct(conf->disks[i].dev, bh->b_size>>9); +||||||| expected + PRINTK("Reading block %d (sync=%d)\n", i, syncing); + if (syncing) + md_sync_acct(conf->disks[i].dev, bh->b_size>>9); +======= PRINTK("Reading block %d (sync=%d)\n", i, syncing); if (syncing) md_sync_acct(conf->disks[i].dev, STRIPE_SECTORS); +>>>>>>> replacement } } } @@ -1163,20 +1447,14 @@ if (rmw < rcw && rmw > 0) /* prefer read-modify-write, but need to get some data */ for (i=disks; i--;) { - dev = &sh->dev[i]; - if ((dev->towrite || i == sh->pd_idx) && - !test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) && + bh = sh->bh_cache[i]; + if ((sh->bh_write[i] || i == sh->pd_idx) && + !buffer_locked(bh) && !buffer_uptodate(bh) && conf->disks[i].operational) { if (test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) { PRINTK("Read_old block %d for r-m-w\n", i); -<<<<<<< found set_bit(BH_Lock, &bh->b_state); -||||||| expected - set_buffer_locked(bh); -======= - set_bit(R5_LOCKED, &dev->flags); ->>>>>>> replacement action[i] = READ+1; locked++; } else { @@ -1185,25 +1463,49 @@ } } } +<<<<<<< found if (rcw <= rmw && rcw > 0) /* want reconstruct write, but need to get some data */ for (i=disks; i--;) { + bh = sh->bh_cache[i]; + if (!sh->bh_write[i] && i != sh->pd_idx && + !buffer_locked(bh) && !buffer_uptodate(bh) && + conf->disks[i].operational) { +||||||| expected + if (rmw < rcw && rmw > 0) + /* prefer read-modify-write, but need to get some data */ + for (i=disks; i--;) { + bh = sh->bh_cache[i]; + if ((sh->bh_write[i] || i == sh->pd_idx) && + !buffer_locked(bh) && !buffer_uptodate(bh) && + conf->disks[i].operational) { +======= + if (rmw < rcw && rmw > 0) + /* prefer read-modify-write, but need to get some data */ + for (i=disks; i--;) { dev = &sh->dev[i]; - if (!test_bit(R5_OVERWRITE, &dev->flags) && i != sh->pd_idx && + if ((dev->towrite || i == sh->pd_idx) && !test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) && conf->disks[i].operational) { +>>>>>>> replacement if (test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) { - PRINTK("Read_old block %d for Reconstruct\n", i); <<<<<<< found + PRINTK("Read_old block %d for Reconstruct\n", i); set_bit(BH_Lock, &bh->b_state); + action[i] = READ+1; + locked++; ||||||| expected + PRINTK("Read_old block %d for r-m-w\n", i); set_buffer_locked(bh); + action[i] = READ+1; + locked++; ======= + PRINTK("Read_old block %d for r-m-w\n", i); set_bit(R5_LOCKED, &dev->flags); ->>>>>>> replacement action[i] = READ+1; locked++; +>>>>>>> replacement } else { set_bit(STRIPE_DELAYED, &sh->state); set_bit(STRIPE_HANDLE, &sh->state); @@ -1211,6 +1513,7 @@ } } /* now if nothing is locked, and if we have enough data, we can start a write request */ +<<<<<<< found if (locked == 0 && (rcw == 0 ||rmw == 0)) { PRINTK("Computing parity...\n"); compute_parity(sh, rcw==0 ? RECONSTRUCT_WRITE : READ_MODIFY_WRITE); @@ -1222,6 +1525,37 @@ action[i] = WRITE+1; if (!conf->disks[i].operational || (i==sh->pd_idx && failed == 0)) +||||||| expected + if (rcw <= rmw && rcw > 0) + /* want reconstruct write, but need to get some data */ + for (i=disks; i--;) { + bh = sh->bh_cache[i]; + if (!sh->bh_write[i] && i != sh->pd_idx && + !buffer_locked(bh) && !buffer_uptodate(bh) && + conf->disks[i].operational) { + if (test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) + { + PRINTK("Read_old block %d for Reconstruct\n", i); + set_buffer_locked(bh); + action[i] = READ+1; + locked++; + } else { +======= + if (rcw <= rmw && rcw > 0) + /* want reconstruct write, but need to get some data */ + for (i=disks; i--;) { + dev = &sh->dev[i]; + if (!test_bit(R5_OVERWRITE, &dev->flags) && i != sh->pd_idx && + !test_bit(R5_LOCKED, &dev->flags) && !test_bit(R5_UPTODATE, &dev->flags) && + conf->disks[i].operational) { + if (test_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) + { + PRINTK("Read_old block %d for Reconstruct\n", i); + set_bit(R5_LOCKED, &dev->flags); + action[i] = READ+1; + locked++; + } else { +>>>>>>> replacement set_bit(STRIPE_INSYNC, &sh->state); } if (test_and_clear_bit(STRIPE_PREREAD_ACTIVE, &sh->state)) { @@ -1263,35 +1597,122 @@ compute_block(sh, failed_num); uptodate++; } +<<<<<<< found if (uptodate != disks) BUG(); -<<<<<<< found bh = sh->bh_cache[failed_num]; set_bit(BH_Lock, &bh->b_state); + action[failed_num] = WRITE+1; ||||||| expected + if (uptodate != disks) + BUG(); bh = sh->bh_cache[failed_num]; set_buffer_locked(bh); + action[failed_num] = WRITE+1; ======= + if (uptodate != disks) + BUG(); dev = &sh->dev[failed_num]; set_bit(R5_LOCKED, &dev->flags); ->>>>>>> replacement action[failed_num] = WRITE+1; +>>>>>>> replacement locked++; +<<<<<<< found + set_bit(STRIPE_INSYNC, &sh->state); + if (conf->disks[failed_num].operational) + md_sync_acct(conf->disks[failed_num].dev, bh->b_size>>9); + else if ((spare=conf->spare)) + md_sync_acct(spare->dev, bh->b_size>>9); +||||||| expected + set_bit(STRIPE_INSYNC, &sh->state); + if (conf->disks[failed_num].operational) + md_sync_acct(conf->disks[failed_num].dev, bh->b_size>>9); + else if ((spare=conf->spare)) + md_sync_acct(spare->dev, bh->b_size>>9); +======= set_bit(STRIPE_INSYNC, &sh->state); if (conf->disks[failed_num].operational) md_sync_acct(conf->disks[failed_num].dev, STRIPE_SECTORS); else if ((spare=conf->spare)) md_sync_acct(spare->dev, STRIPE_SECTORS); +>>>>>>> replacement } } +<<<<<<< found + if (syncing && locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) { + md_done_sync(conf->mddev, (sh->size>>9) - sh->sync_redone,1); + clear_bit(STRIPE_SYNCING, &sh->state); +||||||| expected + if (syncing && locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) { + md_done_sync(conf->mddev, (sh->size>>9) - sh->sync_redone,1); + clear_bit(STRIPE_SYNCING, &sh->state); +======= if (syncing && locked == 0 && test_bit(STRIPE_INSYNC, &sh->state)) { md_done_sync(conf->mddev, STRIPE_SECTORS,1); clear_bit(STRIPE_SYNCING, &sh->state); +>>>>>>> replacement } +<<<<<<< found + spin_unlock(&sh->lock); + while ((bh=return_ok)) { + return_ok = bh->b_reqnext; + bh->b_reqnext = NULL; + bh->b_end_io(bh, 1); +||||||| expected + + spin_unlock(&sh->lock); + + while ((bh=return_ok)) { + return_ok = bh->b_reqnext; + bh->b_reqnext = NULL; + bh->b_end_io(bh, 1); +======= + spin_unlock(&sh->lock); + +>>>>>>> replacement +<<<<<<< found + while ((bh=return_fail)) { + return_fail = bh->b_reqnext; + bh->b_reqnext = NULL; + bh->b_end_io(bh, 0); + } + for (i=disks; i-- ;) + if (action[i]) { + struct buffer_head *bh = sh->bh_cache[i]; + struct disk_info *spare = conf->spare; + int skip = 0; + if (action[i] == READ+1) + bh->b_end_io = raid5_end_read_request; + else + bh->b_end_io = raid5_end_write_request; + if (conf->disks[i].operational) + bh->b_dev = conf->disks[i].dev; + else if (spare && action[i] == WRITE+1) + bh->b_dev = spare->dev; +||||||| expected + while ((bh=return_fail)) { + return_fail = bh->b_reqnext; + bh->b_reqnext = NULL; + bh->b_end_io(bh, 0); + } + for (i=disks; i-- ;) + if (action[i]) { + struct buffer_head *bh = sh->bh_cache[i]; + struct disk_info *spare = conf->spare; + int skip = 0; + if (action[i] == READ+1) + bh->b_end_io = raid5_end_read_request; + else + bh->b_end_io = raid5_end_write_request; + if (conf->disks[i].operational) + bh->b_dev = conf->disks[i].dev; + else if (spare && action[i] == WRITE+1) + bh->b_dev = spare->dev; +======= while ((bi=return_bi)) { return_bi = bi->bi_next; bi->bi_next = NULL; @@ -1310,8 +1731,22 @@ bi->bi_bdev = conf->disks[i].bdev; else if (spare && action[i] == WRITE+1) bi->bi_bdev = spare->bdev; +>>>>>>> replacement else skip=1; if (!skip) { +<<<<<<< found + PRINTK("for %ld schedule op %d on disc %d\n", sh->sector, action[i]-1, i); + atomic_inc(&sh->count); + bh->b_rdev = bh->b_dev; + bh->b_rsector = bh->b_blocknr * (bh->b_size>>9); + generic_make_request(action[i]-1, bh); +||||||| expected + PRINTK("for %ld schedule op %d on disc %d\n", sh->sector, action[i]-1, i); + atomic_inc(&sh->count); + bh->b_rdev = bh->b_dev; + bh->b_rsector = bh->b_blocknr * (bh->b_size>>9); + generic_make_request(action[i]-1, bh); +======= PRINTK("for %ld schedule op %d on disc %d\n", sh->sector, action[i]-1, i); atomic_inc(&sh->count); bi->bi_sector = sh->sector; @@ -1326,16 +1761,23 @@ bi->bi_size = STRIPE_SIZE; bi->bi_next = NULL; generic_make_request(bi); +>>>>>>> replacement +<<<<<<< found } else { PRINTK("skip op %d on disc %d for sector %ld\n", action[i]-1, i, sh->sector); -<<<<<<< found clear_bit(BH_Lock, &bh->b_state); + set_bit(STRIPE_HANDLE, &sh->state); ||||||| expected + } else { + PRINTK("skip op %d on disc %d for sector %ld\n", action[i]-1, i, sh->sector); clear_buffer_locked(bh); + set_bit(STRIPE_HANDLE, &sh->state); ======= + } else { + PRINTK("skip op %d on disc %d for sector %ld\n", action[i]-1, i, sh->sector); clear_bit(R5_LOCKED, &dev->flags); ->>>>>>> replacement set_bit(STRIPE_HANDLE, &sh->state); +>>>>>>> replacement } } } @@ -1442,6 +1884,18 @@ * Determine correct block size for this device. */ unsigned int device_bsize (kdev_t dev) +||||||| expected +static int sync_request (mddev_t *mddev, unsigned long sector_nr) +{ + raid5_conf_t *conf = (raid5_conf_t *) mddev->private; + struct stripe_head *sh; +======= +/* FIXME go_faster isn't used */ +static int sync_request (mddev_t *mddev, sector_t sector_nr, int go_faster) +{ + raid5_conf_t *conf = (raid5_conf_t *) mddev->private; + struct stripe_head *sh; +>>>>>>> replacement { unsigned int i, correct_size; @@ -1455,11 +1909,7 @@ return correct_size; } -||||||| expected -======= -/* FIXME go_faster isn't used */ ->>>>>>> replacement -static int sync_request (mddev_t *mddev, sector_t sector_nr, int go_faster) +static int sync_request (mddev_t *mddev, unsigned long sector_nr) { raid5_conf_t *conf = (raid5_conf_t *) mddev->private; struct stripe_head *sh; @@ -1625,10 +2075,21 @@ MD_BUG(); goto abort; } +<<<<<<< found disk->number = desc->number; disk->raid_disk = raid_disk; disk->dev = rdev->dev; disk->bdev = rdev->bdev; +||||||| expected + disk->number = desc->number; + disk->raid_disk = raid_disk; + disk->dev = NODEV; +======= + disk->number = desc->number; + disk->raid_disk = raid_disk; + disk->dev = NODEV; +>>>>>>> replacement + disk->bdev = NULL; disk->operational = 0; disk->write_only = 0; @@ -1688,7 +2149,6 @@ disk->number = desc->number; disk->raid_disk = raid_disk; disk->dev = MKDEV(0,0); - disk->bdev = NULL; disk->operational = 0; disk->write_only = 0; @@ -2172,11 +2632,23 @@ if (rdisk->spare && (removed_disk < conf->raid_disks)) { MD_BUG(); err = 1; +<<<<<<< found goto abort; } rdisk->dev = MKDEV(0,0); + rdisk->used_slot = 0; +||||||| expected + goto abort; + } + rdisk->dev = NODEV; + rdisk->used_slot = 0; +======= + goto abort; + } + rdisk->dev = NODEV; rdisk->bdev = NULL; rdisk->used_slot = 0; +>>>>>>> replacement break; @@ -2190,13 +2662,27 @@ goto abort; } +<<<<<<< found adisk->number = added_desc->number; adisk->raid_disk = added_desc->raid_disk; adisk->dev = MKDEV(added_desc->major,added_desc->minor); + + adisk->operational = 0; +||||||| expected + adisk->number = added_desc->number; + adisk->raid_disk = added_desc->raid_disk; + adisk->dev = mk_kdev(added_desc->major,added_desc->minor); + + adisk->operational = 0; +======= + adisk->number = added_desc->number; + adisk->raid_disk = added_desc->raid_disk; + adisk->dev = mk_kdev(added_desc->major,added_desc->minor); /* it will be held open by rdev */ adisk->bdev = bdget(kdev_t_to_nr(adisk->dev)); adisk->operational = 0; +>>>>>>> replacement adisk->write_only = 0; adisk->spare = 1; adisk->used_slot = 1; ./linux/raid5/merge FAILED 0.65 1 unresolved conflict found 12 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:06.422339312 +0200 @@ -37,11 +37,25 @@ #define MAY_SATTR 8 #define MAY_TRUNC 16 #define MAY_LOCK 32 +<<<<<<< found +#define MAY_OWNER_OVERRIDE 64 +#define MAY_LOCAL_ACCESS 128 /* IRIX doing local access check on device special file*/ +#if (MAY_SATTR | MAY_TRUNC | MAY_LOCK | MAY_OWNER_OVERRIDE | MAY_LOCAL_ACCESS) & (MAY_READ | MAY_WRITE | MAY_EXEC) +# error "please use a different value for MAY_SATTR or MAY_TRUNC or MAY_LOCK or MAY_OWNER_OVERRIDE." +#endif +||||||| expected +#define MAY_OWNER_OVERRIDE 64 +#define MAY_LOCAL_ACCESS 128 /* IRIX doing local access check on device special file*/ +#if (MAY_SATTR | MAY_TRUNC | MAY_LOCK | MAX_OWNER_OVERRIDE | MAY_LOCAL_ACCESS) & (MAY_READ | MAY_WRITE | MAY_EXEC | MAY_OWNER_OVERRIDE) +# error "please use a different value for MAY_SATTR or MAY_TRUNC or MAY_LOCK or MAY_OWNER_OVERRIDE." +#endif +======= #define MAY_OWNER_OVERRIDE 64 #define MAY_LOCAL_ACCESS 128 /* IRIX doing local access check on device special file*/ #if (MAY_SATTR | MAY_TRUNC | MAY_LOCK | MAY_OWNER_OVERRIDE | MAY_LOCAL_ACCESS) & (MAY_READ | MAY_WRITE | MAY_EXEC) # error "please use a different value for MAY_SATTR or MAY_TRUNC or MAY_LOCK or MAY_LOCAL_ACCESS or MAY_OWNER_OVERRIDE." #endif +>>>>>>> replacement #define MAY_CREATE (MAY_EXEC|MAY_WRITE) #define MAY_REMOVE (MAY_EXEC|MAY_WRITE|MAY_TRUNC) ./linux/nfsd-defines/merge FAILED 0.00 2 unresolved conflicts found 6 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:06.498814768 +0200 @@ -122,11 +122,26 @@ */ static void svc_sock_enqueue(struct svc_sock *svsk) +<<<<<<< found { struct svc_serv *serv = svsk->sk_server; struct svc_rqst *rqstp; if (!(svsk->sk_flags & +||||||| expected + { + struct sock *sk = svsk->sk_sk; + + svsk->sk_recvfrom = svc_tcp_recvfrom; + svsk->sk_sendto = svc_tcp_sendto; +======= + { + struct sock *sk = svsk->sk_sk; + struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp); + + svsk->sk_recvfrom = svc_tcp_recvfrom; + svsk->sk_sendto = svc_tcp_sendto; +>>>>>>> replacement ( (1<sk_sk->data_ready = svc_udp_data_ready; svsk->sk_sk->write_space = svc_write_space; +<<<<<<< found svsk->sk_recvfrom = svc_udp_recvfrom; svsk->sk_sendto = svc_udp_sendto; /* initialise setting must have enough space to * receive and respond to one request. * svc_udp_recvfrom will re-adjust if necessary +||||||| expected + svsk->sk_reclen = 0; + svsk->sk_tcplen = 0; + + /* initialise setting must have enough space to + * receive and respond to one request. + * svc_tcp_recvfrom will re-adjust if necessary +======= + svsk->sk_reclen = 0; + svsk->sk_tcplen = 0; + + tp->nonagle = 1; /* disable Nagle's algorithm */ + + /* initialise setting must have enough space to + * receive and respond to one request. + * svc_tcp_recvfrom will re-adjust if necessary +>>>>>>> replacement */ svc_sock_setbufsize(svsk->sk_sock, 3 * svsk->sk_server->sv_bufsz, @@ -1015,7 +1048,6 @@ svc_tcp_init(struct svc_sock *svsk) { struct sock *sk = svsk->sk_sk; - struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp); svsk->sk_recvfrom = svc_tcp_recvfrom; svsk->sk_sendto = svc_tcp_sendto; @@ -1031,27 +1063,11 @@ sk->write_space = svc_write_space; svsk->sk_reclen = 0; -<<<<<<< found svsk->sk_tcplen = 0; /* initialise setting must have enough space to * receive and respond to one request. * svc_tcp_recvfrom will re-adjust if necessary -||||||| expected - svsk->sk_tcplen = 0; - - /* initialise setting must have enough space to - * receive and respond to one request. - * svc_tcp_recvfrom will re-adjust if necessary -======= - svsk->sk_tcplen = 0; - - tp->nonagle = 1; /* disable Nagle's algorithm */ - - /* initialise setting must have enough space to - * receive and respond to one request. - * svc_tcp_recvfrom will re-adjust if necessary ->>>>>>> replacement */ svc_sock_setbufsize(svsk->sk_sock, 3 * svsk->sk_server->sv_bufsz, ./linux/rpc_tcp_nonagle/merge FAILED 0.01 ./linux/md-messy/diff SUCCEEDED 0.00 5 unresolved conflicts found 6 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:06.651423665 +0200 @@ -1,15 +1,39 @@ +<<<<<<< found +static struct buffer_head *raid5_build_block (struct stripe_head *sh, int i) +{ + raid5_conf_t *conf = sh->raid_conf; + struct buffer_head *bh = sh->bh_cache[i]; +||||||| expected +static struct buffer_head *raid5_build_block (struct stripe_head *sh, int i) +{ + raid5_conf_t *conf = sh->raid_conf; + struct buffer_head *bh = sh->bh_cache[i]; +======= static void raid5_build_block (struct stripe_head *sh, int i) { raid5_conf_t *conf = sh->raid_conf; struct r5dev *dev = &sh->dev[i]; +>>>>>>> replacement +<<<<<<< found + unsigned long block = sh->sector / (sh->size >> 9); +||||||| expected + unsigned long block = sh->sector / (sh->size >> 9); +======= bio_init(&dev->req); dev->req.bi_io_vec = &dev->vec; dev->req.bi_vcnt++; dev->vec.bv_page = dev->page; dev->vec.bv_len = STRIPE_SIZE; +>>>>>>> replacement +<<<<<<< found + init_buffer(bh, raid5_end_read_request, sh); +||||||| expected + init_buffer(bh, raid5_end_read_request, sh); +======= dev->vec.bv_offset = 0; +>>>>>>> replacement <<<<<<< found bh->b_dev = conf->disks[i].dev; ||||||| expected @@ -19,18 +43,24 @@ dev->req.bi_bdev = conf->disks[i].bdev; dev->req.bi_sector = sh->sector; >>>>>>> replacement - dev->req.bi_private = sh; - - dev->flags = 0; - if (i != sh->pd_idx) <<<<<<< found + bh->b_blocknr = block; + + bh->b_state = (1 << BH_Req) | (1 << BH_Mapped); bh->b_size = sh->size; bh->b_list = BUF_LOCKED; return bh; ||||||| expected + bh->b_blocknr = block; + + bh->b_state = (1 << BH_Req) | (1 << BH_Mapped); bh->b_size = sh->size; return bh; ======= + dev->req.bi_private = sh; + + dev->flags = 0; + if (i != sh->pd_idx) dev->sector = compute_blocknr(sh, i); >>>>>>> replacement } ./linux/raid5build/merge FAILED 0.00 2 unresolved conflicts found 5 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:06.718917746 +0200 @@ -232,13 +232,20 @@ return NULL; return (void __iomem *) (unsigned long) (port + PIO_OFFSET); } - <<<<<<< found + void ioport_unmap(void __iomem *addr) { /* Nothing to do */ } -||||||| expected +EXPORT_SYMBOL(ioport_map); +EXPORT_SYMBOL(ioport_unmap); +#endif /* CONFIG_HAS_IOPORT */ + +#ifdef CONFIG_PCI +/* Hide the details if this is a MMIO or PIO address space and just do what + * you expect in the correct way. */||||||| expected + #ifdef CONFIG_PCI /** * pci_iomap - create a virtual mapping cookie for a PCI BAR @@ -247,26 +254,8 @@ * @maxlen: length of the memory to map * * Using this function you will get a __iomem address to your device BAR. -======= -#ifdef CONFIG_PCI -/** - * pci_iomap_range - create a virtual mapping cookie for a PCI BAR - * @dev: PCI device that owns the BAR - * @bar: BAR number - * @offset: map memory at the given offset in BAR - * @minlen: min length of the memory to map - * @maxlen: max length of the memory to map - * - * Using this function you will get a __iomem address to your device BAR. ->>>>>>> replacement -EXPORT_SYMBOL(ioport_map); -EXPORT_SYMBOL(ioport_unmap); -#endif /* CONFIG_HAS_IOPORT */ - -#ifdef CONFIG_PCI -/* Hide the details if this is a MMIO or PIO address space and just do what -<<<<<<< found - * you expect in the correct way. */||||||| expected + * You can access it using ioread*() and iowrite*(). These functions hide + * the details if this is a MMIO or PIO address space and will just do what * you expect from them in the correct way. * * @maxlen specifies the maximum length to map. If you want to get access to @@ -290,6 +279,19 @@ return ioremap_nocache(start, len); } ======= + +#ifdef CONFIG_PCI +/** + * pci_iomap_range - create a virtual mapping cookie for a PCI BAR + * @dev: PCI device that owns the BAR + * @bar: BAR number + * @offset: map memory at the given offset in BAR + * @minlen: min length of the memory to map + * @maxlen: max length of the memory to map + * + * Using this function you will get a __iomem address to your device BAR. + * You can access it using ioread*() and iowrite*(). These functions hide + * the details if this is a MMIO or PIO address space and will just do what * you expect from them in the correct way. * * @minlen specifies the minimum length to map. We check that BAR is @@ -325,6 +327,15 @@ return ioremap_nocache(start, len); } >>>>>>> replacement +<<<<<<< found + +||||||| expected + return NULL; +} + +======= + return NULL; +} /** * pci_iomap - create a virtual mapping cookie for a PCI BAR @@ -345,6 +356,7 @@ return pci_iomap_range(dev, bar, 0, 0, maxlen, false); } +>>>>>>> replacement void pci_iounmap(struct pci_dev *dev, void __iomem * addr) { IO_COND(addr, /* nothing */, iounmap(addr)); ./linux/iomap/merge FAILED 0.01 9 unresolved conflicts found 7 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:06.800957296 +0200 @@ -1,12 +1,29 @@ /* * linux/fs/inode.c * +<<<<<<< found * (C) 1997 Linus Torvalds */ #include #include #include +||||||| expected + return inodes_stat.nr_inodes; +} + +/* + * Called with the inode lock held. + * NOTE: we are not increasing the inode-refcount, you must call __iget() +======= + return inodes_stat.nr_inodes; +} + +void __wait_on_freeing_inode(struct inode *inode); +/* + * Called with the inode lock held. + * NOTE: we are not increasing the inode-refcount, you must call __iget() +>>>>>>> replacement #include #include #include @@ -144,9 +161,26 @@ mapping->dirtied_when = 0; mapping->assoc_mapping = NULL; mapping->backing_dev_info = &default_backing_dev_info; +<<<<<<< found +||||||| expected + continue; +======= + continue; +>>>>>>> replacement +<<<<<<< found if (sb->s_bdev) +||||||| expected + if (!test(inode, data)) +======= + if (!test(inode, data)) + continue; + if (inode->i_state & (I_FREEING|I_CLEAR)) { + __wait_on_freeing_inode(inode); + tmp = head; +>>>>>>> replacement mapping->backing_dev_info = sb->s_bdev->bd_inode->i_mapping->backing_dev_info; memset(&inode->u, 0, sizeof(inode->u)); + } inode->i_mapping = mapping; } return inode; @@ -471,7 +505,6 @@ return inodes_stat.nr_unused; } -void __wait_on_freeing_inode(struct inode *inode); /* * Called with the inode lock held. * NOTE: we are not increasing the inode-refcount, you must call __iget() @@ -487,9 +520,28 @@ prefetch(node->next); inode = hlist_entry(node, struct inode, i_hash); if (inode->i_sb != sb) +<<<<<<< found continue; if (!test(inode, data)) continue; +||||||| expected + continue; + if (inode->i_sb != sb) + continue; +======= + continue; + if (inode->i_sb != sb) + continue; +>>>>>>> replacement +<<<<<<< found + break; + } + return node ? inode : NULL; +||||||| expected + break; + } + return inode; +======= if (inode->i_state & (I_FREEING|I_CLEAR)) { __wait_on_freeing_inode(inode); tmp = head; @@ -497,7 +549,8 @@ } break; } - return node ? inode : NULL; + return inode; +>>>>>>> replacement } /* @@ -516,11 +569,6 @@ continue; if (inode->i_sb != sb) continue; - if (inode->i_state & (I_FREEING|I_CLEAR)) { - __wait_on_freeing_inode(inode); - tmp = head; - continue; - } break; } return node ? inode : NULL; @@ -951,16 +999,24 @@ void generic_delete_inode(struct inode *inode) { +<<<<<<< found struct super_operations *op = inode->i_sb->s_op; -<<<<<<< found hlist_del_init(&inode->i_hash); + list_del_init(&inode->i_list); + inode->i_state|=I_FREEING; ||||||| expected + struct super_operations *op = inode->i_sb->s_op; + list_del_init(&inode->i_hash); + list_del_init(&inode->i_list); + inode->i_state|=I_FREEING; ======= ->>>>>>> replacement + struct super_operations *op = inode->i_sb->s_op; + list_del_init(&inode->i_list); inode->i_state|=I_FREEING; +>>>>>>> replacement inodes_stat.nr_inodes--; spin_unlock(&inode_lock); @@ -977,10 +1033,6 @@ delete(inode); } else clear_inode(inode); - spin_lock(&inode_lock); - list_del_init(&inode->i_hash); - spin_unlock(&inode_lock); - wake_up_inode(inode); if (inode->i_state != I_CLEAR) BUG(); destroy_inode(inode); @@ -1059,12 +1111,32 @@ void iput(struct inode *inode) { +<<<<<<< found if (inode) { struct super_operations *op = inode->i_sb->s_op; if (inode->i_state == I_CLEAR) BUG(); +||||||| expected + delete(inode); + } else + clear_inode(inode); + if (inode->i_state != I_CLEAR) + BUG(); + destroy_inode(inode); +======= + delete(inode); + } else + clear_inode(inode); + spin_lock(&inode_lock); + list_del_init(&inode->i_hash); + spin_unlock(&inode_lock); + wake_up_inode(inode); + if (inode->i_state != I_CLEAR) + BUG(); + destroy_inode(inode); +>>>>>>> replacement if (op && op->put_inode) op->put_inode(inode); @@ -1251,26 +1323,19 @@ goto repeat; } remove_wait_queue(wq, &wait); +<<<<<<< found __set_current_state(TASK_RUNNING); +||||||| expected + current->state = TASK_RUNNING; +======= + current->state = TASK_RUNNING; +>>>>>>> replacement } void __wait_on_freeing_inode(struct inode *inode) { DECLARE_WAITQUEUE(wait, current); - wait_queue_head_t *wq = i_waitq_head(inode); - - add_wait_queue(wq, &wait); - set_current_state(TASK_UNINTERRUPTIBLE); - spin_unlock(&inode_lock); - schedule(); - remove_wait_queue(wq, &wait); - current->state = TASK_RUNNING; - spin_lock(&inode_lock); -} - - -void wake_up_inode(struct inode *inode) -{ +<<<<<<< found wait_queue_head_t *wq = i_waitq_head(inode); /* @@ -1356,3 +1421,22 @@ printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o)\n", mode); } +||||||| expected + wait_queue_head_t *wq = i_waitq_head(inode); +======= + wait_queue_head_t *wq = i_waitq_head(inode); + + add_wait_queue(wq, &wait); + set_current_state(TASK_UNINTERRUPTIBLE); + spin_unlock(&inode_lock); + schedule(); + remove_wait_queue(wq, &wait); + current->state = TASK_RUNNING; + spin_lock(&inode_lock); +} + + +void wake_up_inode(struct inode *inode) +{ + wait_queue_head_t *wq = i_waitq_head(inode); +>>>>>>> replacement ./linux/inode-fullpatch/merge FAILED 0.03 --- diff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:06.904957588 +0200 @@ -2,12 +2,13 @@ -/* - * linux/fs/inode.c - * -- * (C) 1997 Linus Torvalds -- */ -- --#include --#include --#include +|<<<-- * (C) 1997 Linus Torvalds-->>><<<++*** 470,6 **** 1 static int shrink_icache_memory(int nr, +| return inodes_stat.nr_inodes;++>>> +|<<<-- */-->>><<<++}++>>> + +|<<<--#include -->>><<<++/*++>>> +|<<<--#include-->>> <<<-->><<<++* Called with the inode lock held++>>>.<<<--h>-->>> +|<<<--#include-->>> <<<---->>><<<++* NOTE: we are not increasing the inode-refcount, you must call __iget()++>>> -#include -#include -#include @@ -145,12 +146,14 @@ - mapping->dirtied_when = 0; - mapping->assoc_mapping = NULL; - mapping->backing_dev_info = &default_backing_dev_info; -- if (sb->s_bdev) -- mapping->backing_dev_info = sb->s_bdev->bd_inode->i_mapping->backing_dev_info; -- memset(&inode->u, 0, sizeof(inode->u)); -- inode->i_mapping = mapping; -- } -- return inode; ++*** 492,6 **** 2 static struct inode * find_inode(struct ++ continue; +| if (<<<--sb->s_bdev-->>><<<++!test(inode, data)++>>>) +| <<<--mapping->backing_dev_info = sb->s_bdev->bd_inode->i_mapping->backing_dev_info; +| memset(&inode->u, 0, sizeof(inode->u))-->>><<<++continue++>>>; +| <<<--inode->i_mapping = mapping-->>><<<++break++>>>; + } + return inode; -} - -void destroy_inode(struct inode *inode) @@ -469,13 +472,12 @@ - if (gfp_mask & __GFP_FS) - prune_icache(nr); - } -+*** 470,6 **** 1 static int shrink_icache_memory(int nr, -| return inodes_stat.<<<--nr_unused-->>><<<++nr_inodes++>>>; - } - - /* - * Called with the inode lock held. - * NOTE: we are not increasing the inode-refcount, you must call __iget() +- return inodes_stat.nr_unused; +-} +- +-/* +- * Called with the inode lock held. +- * NOTE: we are not increasing the inode-refcount, you must call __iget() - * by hand after calling find_inode now! This simplifies iunique and won't - * add any additional branch in the common code. - */ @@ -488,13 +490,13 @@ - prefetch(node->next); - inode = hlist_entry(node, struct inode, i_hash); - if (inode->i_sb != sb) -+*** 492,6 **** 2 static struct inode * find_inode(struct - continue; - if (!test(inode, data)) +|<<<-- continue-->>><<<++*** 517,6 **** 3 static struct inode * find_inode_fast(st +| continue++>>>; +| if (<<<++inode->i_sb ++>>>!<<<--test(inode,-->>><<<++=++>>> <<<--data)-->>><<<++sb++>>>) continue; break; } -| return<<<-- node ?-->>> inode<<<-- : NULL-->>>; +| return <<<--node ? inode : NULL-->>><<<++inode++>>>; -} - -/* @@ -510,13 +512,12 @@ - prefetch(node->next); - inode = list_entry(node, struct inode, i_hash); - if (inode->i_ino != ino) -+*** 517,6 **** 3 static struct inode * find_inode_fast(st - continue; - if (inode->i_sb != sb) - continue; - break; - } -| return<<<-- node ?-->>> inode<<<-- : NULL-->>>; +- continue; +- if (inode->i_sb != sb) +- continue; +- break; +- } +- return node ? inode : NULL; -} - -/** @@ -945,7 +946,7 @@ -void generic_delete_inode(struct inode *inode) +*** 949,7 **** 4 void generic_delete_inode(struct inode * { - struct super_operations *op = inode->i_sb->s_op; +| <<<--struct-->>><<<++struct++>>> <<<--super_operations-->>><<<++super_operations++>>> *op = <<<--inode-->>><<<++inode++>>>-><<<--i_sb-->>><<<++i_sb++>>>-><<<--s_op-->>><<<++s_op++>>>; | <<<--hlist_del_init-->>><<<++list_del_init++>>>(&inode->i_hash); list_del_init(&inode->i_list); @@ -963,13 +964,12 @@ - if (!is_bad_inode(inode)) - DQUOT_INIT(inode); - /* s_op->delete_inode internally recalls clear_inode() */ -+*** 968,6 **** 5 void generic_delete_inode(struct inode * - delete(inode); - } else - clear_inode(inode); - if (inode->i_state != I_CLEAR) - BUG(); - destroy_inode(inode); +- delete(inode); +- } else +- clear_inode(inode); +- if (inode->i_state != I_CLEAR) +- BUG(); +- destroy_inode(inode); -} -EXPORT_SYMBOL(generic_delete_inode); - @@ -1045,12 +1045,14 @@ - -void iput(struct inode *inode) -{ -- if (inode) { -- struct super_operations *op = inode->i_sb->s_op; -- -- if (inode->i_state == I_CLEAR) -- BUG(); -- +|<<<-- if -->>><<<++*** 968,6 **** 5 void generic_delete_inode(struct inode * +| delete++>>>(inode)<<<++; +| }++>>> <<<--{-->>><<<++else++>>> +| <<<--struct super_operations *op = inode->i_sb->s_op-->>><<<++clear_inode(inode)++>>>; +- +|<<<-- -->>><<<++ ++>>>if (inode->i_state <<<--=-->>><<<++!++>>>= I_CLEAR) +|<<<-- BUG-->>><<<++ BUG++>>>(); +|<<<++ destroy_inode(inode);++>>> - if (op && op->put_inode) - op->put_inode(inode); - @@ -1237,13 +1239,13 @@ - goto repeat; - } - remove_wait_queue(wq, &wait); -|<<<-- __set_current_state(-->>><<<++*** 1219,6 **** 6 repeat: -| current->state = ++>>>TASK_RUNNING<<<--)-->>>; +|<<<-- __set_current_state(TASK_RUNNING)-->>><<<++*** 1219,6 **** 6 repeat: +| current->state = TASK_RUNNING++>>>; } - void wake_up_inode(struct inode *inode) +|<<<--void-->>><<<++void++>>> wake_up_inode(struct <<<--inode-->>><<<++inode++>>> *inode) { - wait_queue_head_t *wq = i_waitq_head(inode); +| wait_queue_head_t *<<<--wq-->>><<<++wq++>>> = i_waitq_head(<<<--inode-->>><<<++inode++>>>); - - /* - * Prevent speculative execution through spin_unlock(&inode_lock); ./linux/inode-fullpatch/diff FAILED 0.03 14 unresolved conflicts found 7 already-applied changes ignored --- wmerge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:07.005035853 +0200 @@ -1,12 +1,13 @@ /* * linux/fs/inode.c * - * (C) 1997 Linus Torvalds +<<<--- * (C) 1997 Linus Torvalds||| return inodes_stat.nr_inodes;=== return inodes_stat.nr_inodes;--->>> */ -#include -#include -#include +<<<---#include |||/*===void __wait_on_freeing_inode(struct inode *inode); +/*--->>> +#include <<<--->>.h> +#include <<<---|||* NOTE: we are not increasing the inode-refcount, you must call __iget()===* NOTE: we are not increasing the inode-refcount, you must call __iget()--->>> #include #include #include @@ -144,9 +145,16 @@ mapping->dirtied_when = 0; mapping->assoc_mapping = NULL; mapping->backing_dev_info = &default_backing_dev_info; - if (sb->s_bdev) +<<<---||| continue; +=== continue; +--->>> if (<<<---sb->s_bdev|||!test(inode, data)===!test(inode, data)--->>>) + continue; + if (inode->i_state & (I_FREEING|I_CLEAR)) { + __wait_on_freeing_inode(inode); + tmp = head; mapping->backing_dev_info = sb->s_bdev->bd_inode->i_mapping->backing_dev_info; memset(&inode->u, 0, sizeof(inode->u)); + } inode->i_mapping = mapping; } return inode; @@ -471,7 +479,6 @@ return inodes_stat.nr_unused; } -void __wait_on_freeing_inode(struct inode *inode); /* * Called with the inode lock held. * NOTE: we are not increasing the inode-refcount, you must call __iget() @@ -487,8 +494,8 @@ prefetch(node->next); inode = hlist_entry(node, struct inode, i_hash); if (inode->i_sb != sb) - continue; - if (!test(inode, data)) +<<<--- continue||| continue=== continue--->>>; + if (<<<---|||inode->i_sb ===inode->i_sb --->>>!test(inode, data)) continue; if (inode->i_state & (I_FREEING|I_CLEAR)) { __wait_on_freeing_inode(inode); @@ -497,7 +504,7 @@ } break; } - return node ? inode : NULL; + return <<<---node ? inode : NULL|||inode===inode--->>>; } /* @@ -516,11 +523,6 @@ continue; if (inode->i_sb != sb) continue; - if (inode->i_state & (I_FREEING|I_CLEAR)) { - __wait_on_freeing_inode(inode); - tmp = head; - continue; - } break; } return node ? inode : NULL; @@ -953,7 +955,7 @@ { struct super_operations *op = inode->i_sb->s_op; -<<<---hlist_del_init|||list_del_init===--->>> list_del_init(&inode->i_list); + <<<---hlist_del_init|||list_del_init===list_del_init--->>>(&inode->i_list); inode->i_state|=I_FREEING; inodes_stat.nr_inodes--; spin_unlock(&inode_lock); @@ -971,10 +973,6 @@ delete(inode); } else clear_inode(inode); - spin_lock(&inode_lock); - list_del_init(&inode->i_hash); - spin_unlock(&inode_lock); - wake_up_inode(inode); if (inode->i_state != I_CLEAR) BUG(); destroy_inode(inode); @@ -1055,10 +1053,14 @@ { if (inode) { struct super_operations *op = inode->i_sb->s_op; - - if (inode->i_state == I_CLEAR) +<<<--- + ||| === spin_lock(&inode_lock); + list_del_init(&inode->i_hash); + spin_unlock(&inode_lock); + wake_up_inode(inode); + --->>>if (inode->i_state == I_CLEAR) BUG(); - +<<<---||| destroy_inode(inode);=== destroy_inode(inode);--->>> if (op && op->put_inode) op->put_inode(inode); @@ -1245,28 +1247,14 @@ goto repeat; } remove_wait_queue(wq, &wait); - __set_current_state(TASK_RUNNING); +<<<--- __set_current_state(TASK_RUNNING)||| current->state = TASK_RUNNING=== current->state = TASK_RUNNING--->>>; } void __wait_on_freeing_inode(struct inode *inode) { DECLARE_WAITQUEUE(wait, current); wait_queue_head_t *wq = i_waitq_head(inode); - - add_wait_queue(wq, &wait); - set_current_state(TASK_UNINTERRUPTIBLE); - spin_unlock(&inode_lock); - schedule(); - remove_wait_queue(wq, &wait); - current->state = TASK_RUNNING; - spin_lock(&inode_lock); -} - - -void wake_up_inode(struct inode *inode) -{ - wait_queue_head_t *wq = i_waitq_head(inode); - +<<<--- /* * Prevent speculative execution through spin_unlock(&inode_lock); */ @@ -1350,3 +1338,18 @@ printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o)\n", mode); } +|||=== + add_wait_queue(wq, &wait); + set_current_state(TASK_UNINTERRUPTIBLE); + spin_unlock(&inode_lock); + schedule(); + remove_wait_queue(wq, &wait); + current->state = TASK_RUNNING; + spin_lock(&inode_lock); +} + + +void wake_up_inode(struct inode *inode) +{ + wait_queue_head_t *wq = i_waitq_head(inode); +--->>> \ No newline at end of file ./linux/inode-fullpatch/wmerge FAILED 0.03 --- rediff 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:07.119452999 +0200 @@ -1,43 +1,43 @@ @@ -470,6 +470,7 @@ static int shrink_icache_memory(int nr, - return inodes_stat.nr_inodes; +| <<<--return-->>><<<++return++>>> <<<--inodes_stat-->>><<<++inodes_stat++>>>.<<<--nr_inodes-->>><<<++nr_inodes++>>>; } +void __wait_on_freeing_inode(struct inode *inode); /* - * Called with the inode lock held. - * NOTE: we are not increasing the inode-refcount, you must call __iget() +| * Called <<<--with-->>><<<++with++>>> the inode lock <<<--held-->>><<<++held++>>>. +| * NOTE: we <<<--are-->>><<<++are++>>> <<<--not-->>><<<++not++>>> <<<--increasing-->>><<<++increasing++>>> the inode-refcount, you must <<<--call-->>><<<++call++>>> __iget() @@ -492,6 +493,11 @@ static struct inode * find_inode(struct - continue; - if (!test(inode, data)) - continue; +| <<<--continue-->>><<<++continue++>>>; +| if (!<<<--test-->>><<<++test++>>>(<<<--inode-->>><<<++inode++>>>, <<<--data-->>><<<++data++>>>)) ++ continue; + if (inode->i_state & (I_FREEING|I_CLEAR)) { + __wait_on_freeing_inode(inode); + tmp = head; -+ continue; + continue; + } break; } - return inode; +| <<<--return-->>><<<++return++>>> inode; @@ -517,6 +523,11 @@ static struct inode * find_inode_fast(st - continue; - if (inode->i_sb != sb) - continue; -+ if (inode->i_state & (I_FREEING|I_CLEAR)) { -+ __wait_on_freeing_inode(inode); -+ tmp = head; -+ continue; -+ } - break; +| <<<--continue-->>><<<++continue++>>>; +| if (<<<--inode-->>><<<++inode++>>>-><<<--i_sb-->>><<<++i_sb++>>> != sb) +| <<<--continue-->>><<<++continue++>>>; +| <<<--break-->>><<<++if (inode->i_state & (I_FREEING|I_CLEAR)) { +| __wait_on_freeing_inode(inode); +| tmp = head; +| continue; +| } +| break++>>>; } - return inode; +| return <<<--inode-->>><<<++inode++>>>; @@ -949,7 +960,6 @@ void generic_delete_inode(struct inode * { - struct super_operations *op = inode->i_sb->s_op; +| <<<--struct-->>><<<++struct++>>> <<<--super_operations-->>><<<++super_operations++>>> *op = <<<--inode-->>><<<++inode++>>>-><<<--i_sb-->>><<<++i_sb++>>>-><<<--s_op-->>><<<++s_op++>>>; -- list_del_init(&inode->i_hash); - list_del_init(&inode->i_list); - inode->i_state|=I_FREEING; - inodes_stat.nr_inodes--; +| <<<--list_del_init-->>><<<++list_del_init++>>>(&<<<--inode-->>><<<++inode++>>>-><<<--i_hash-->>><<<++i_list++>>>); +| <<<--list_del_init(&-->>>inode-><<<--i_list); +| inode->i_state-->>><<<++i_state++>>>|=<<<--I_FREEING-->>><<<++I_FREEING++>>>; +| <<<--inodes_stat-->>><<<++inodes_stat++>>>.<<<--nr_inodes-->>><<<++nr_inodes++>>>--; @@ -968,6 +978,10 @@ void generic_delete_inode(struct inode * delete(inode); } else @@ -46,17 +46,17 @@ + list_del_init(&inode->i_hash); + spin_unlock(&inode_lock); + wake_up_inode(inode); - if (inode->i_state != I_CLEAR) +| if (<<<--inode-->>><<<++inode++>>>-><<<--i_state-->>><<<++i_state++>>> != <<<--I_CLEAR-->>><<<++I_CLEAR++>>>) BUG(); - destroy_inode(inode); +| <<<--destroy_inode-->>><<<++destroy_inode++>>>(<<<--inode-->>><<<++inode++>>>); @@ -1219,6 +1233,21 @@ repeat: - current->state = TASK_RUNNING; +| <<<--current-->>><<<++current++>>>-><<<--state-->>><<<++state++>>> = <<<--TASK_RUNNING-->>><<<++TASK_RUNNING++>>>; } -+void __wait_on_freeing_inode(struct inode *inode) -+{ +|<<<--void-->>><<<++void++>>> <<<--wake_up_inode-->>><<<++__wait_on_freeing_inode++>>>(<<<--struct-->>><<<++struct++>>> <<<--inode-->>><<<++inode++>>> *<<<--inode-->>><<<++inode++>>>) + { + DECLARE_WAITQUEUE(wait, current); -+ wait_queue_head_t *wq = i_waitq_head(inode); + wait_queue_head_t *wq = i_waitq_head(inode); + + add_wait_queue(wq, &wait); + set_current_state(TASK_UNINTERRUPTIBLE); @@ -68,6 +68,6 @@ +} + + - void wake_up_inode(struct inode *inode) - { - wait_queue_head_t *wq = i_waitq_head(inode); ++void wake_up_inode(struct inode *inode) ++{ ++ wait_queue_head_t *wq = i_waitq_head(inode); ./linux/inode-fullpatch/rediff FAILED 0.00 19 unresolved conflicts found 21 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:07.189700160 +0200 @@ -64,12 +64,28 @@ struct buffer_head *bh=NULL; while(cnt) { +<<<<<<< found struct buffer_head *t; md_spin_lock_irq(&conf->device_lock); if (!conf->freebh_blocked && conf->freebh_cnt >= cnt) while (cnt) { t = conf->freebh; conf->freebh = t->b_next; +||||||| expected + * We take the first readable disk when above the resync window. + */ + if (conf->resync_mirrors && (this_sector + sectors >= conf->next_resync)) { + /* make sure that disk is operational */ + new_disk = 0; + while (!conf->mirrors[new_disk].operational || conf->mirrors[new_disk].write_only) { +======= + * We take the first readable disk when above the resync window. + */ + if (!conf->mddev->in_sync && (this_sector + sectors >= conf->next_resync)) { + /* make sure that disk is operational */ + new_disk = 0; + while (!conf->mirrors[new_disk].operational || conf->mirrors[new_disk].write_only) { +>>>>>>> replacement t->b_next = bh; bh = t; t->b_state = 0; @@ -316,9 +332,22 @@ while (head) { struct raid1_bh *r1_bh = head; head = r1_bh->next_r1; +<<<<<<< found __free_page(r1_bh->bh_req.b_page); kfree(r1_bh); } +||||||| expected + if (conf->barrier) BUG(); + if (waitqueue_active(&conf->wait_idle)) BUG(); + if (waitqueue_active(&conf->wait_resume)) BUG(); +======= + if (conf->barrier) BUG(); + if (waitqueue_active(&conf->wait_idle)) BUG(); + if (waitqueue_active(&conf->wait_resume)) BUG(); +>>>>>>> replacement + + mempool_destroy(conf->r1buf_pool); + conf->r1buf_pool = NULL; } static int raid1_map (mddev_t *mddev, kdev_t *rdev) @@ -483,7 +512,7 @@ * Check if it is sane at all to balance */ - if (!conf->mddev->in_sync) + if (conf->resync_mirrors) goto rb_out; @@ -851,9 +880,6 @@ conf->cnt_done = 0; spin_unlock_irq(&conf->segment_lock); wake_up(&conf->wait_done); - - mempool_destroy(conf->r1buf_pool); - conf->r1buf_pool = NULL; } static int raid1_diskop(mddev_t *mddev, mdp_disk_t **d, int state) @@ -982,11 +1008,17 @@ MD_BUG(); err = -EBUSY; break; - } ||||||| expected close_sync(conf); + sdisk = conf->mirrors + spare_disk; + fdisk = conf->mirrors + failed_disk; + ======= + sdisk = conf->mirrors + spare_disk; + fdisk = conf->mirrors + failed_disk; + >>>>>>> replacement + } sdisk = conf->mirrors + spare_disk; sdisk->operational = 0; sdisk->write_only = 0; @@ -999,16 +1031,11 @@ * property) */ case DISKOP_SPARE_ACTIVE: -<<<<<<< found if (conf->start_future > 0) { MD_BUG(); err = -EBUSY; break; } -||||||| expected - close_sync(conf); -======= ->>>>>>> replacement sdisk = conf->mirrors + spare_disk; fdisk = conf->mirrors + failed_disk; @@ -1212,12 +1239,34 @@ if (!conf->mirrors[i].operational) continue; if (i==conf->last_used) +<<<<<<< found /* we read from here, no need to write */ continue; +||||||| expected + * we read from here, no need to write + */ + continue; +======= + * we read from here, no need to write + */ + continue; +>>>>>>> replacement +<<<<<<< found if (i < conf->raid_disks - && mddev->in_sync) + && !conf->resync_mirrors) /* don't need to write this, * we are just rebuilding */ +||||||| expected + if (i < conf->raid_disks && !conf->resync_mirrors) + /* + * don't need to write this we are just rebuilding + */ +======= + if (i < conf->raid_disks && mddev->in_sync) + /* + * don't need to write this we are just rebuilding + */ +>>>>>>> replacement continue; mbh = bhl; if (!mbh) { @@ -1297,22 +1346,78 @@ } md_spin_unlock_irqrestore(&retry_list_lock, flags); } +<<<<<<< found #undef IO_ERROR #undef REDIRECT_SECTOR +||||||| expected + spin_unlock_irqrestore(&retry_list_lock, flags); +} +======= + spin_unlock_irqrestore(&retry_list_lock, flags); +} +>>>>>>> replacement + <<<<<<< found + * Private kernel thread to reconstruct mirrors after an unclean + * shutdown. + */ static void raid1syncd (void *data) { raid1_conf_t *conf = data; + mddev_t *mddev = conf->mddev; + + if (!conf->resync_mirrors) ||||||| expected + * Private kernel thread to reconstruct mirrors after an unclean + * shutdown. + */ static void raid1syncd(void *data) { conf_t *conf = data; + mddev_t *mddev = conf->mddev; + + if (!conf->resync_mirrors) ======= +static int init_resync(conf_t *conf) >>>>>>> replacement +<<<<<<< found + return; + if (mddev->recovery_running != 2) + return; + if (!md_do_sync(mddev, NULL)) { + /* + * Only if everything went Ok. + */ + conf->resync_mirrors = 0; + } + + close_sync(conf); + +} /* * perform a "sync" on one "block" +||||||| expected + return; + if (mddev->recovery_running != 2) + return; + if (!md_do_sync(mddev, NULL)) { + /* + * Only if everything went Ok. + */ + conf->resync_mirrors = 0; + } + + close_sync(conf); + +} + +static int init_resync(conf_t *conf) +{ +======= +{ +>>>>>>> replacement * * We need to make sure that no normal I/O request - particularly write * requests - conflict with active sync requests. @@ -1466,8 +1571,16 @@ generic_make_request(READ, bh); md_sync_acct(bh->b_dev, bh->b_size/512); +<<<<<<< found return (bsize >> 9); +||||||| expected + sector_t max_sector, nr_sectors; + int disk, partial; +======= + sector_t max_sector, nr_sectors; + int disk, partial; +>>>>>>> replacement nomem: <<<<<<< found @@ -1526,6 +1639,11 @@ raid1_free_buf(r1_bh); sync_request_done(sect, mddev_to_conf(mddev)); md_done_sync(mddev,size>>9, uptodate); + } +} + +#define INVALID_LEVEL KERN_WARNING \ +"raid1: md%d: raid level not set to mirroring (%d)\n" ||||||| expected r1_bio->sector = sector_nr; r1_bio->cmd = SPECIAL; @@ -1534,16 +1652,17 @@ if (sector_nr >= max_sector) BUG(); + bio = r1_bio->master_bio; + nr_sectors = RESYNC_BLOCK_SIZE >> 9; + if (max_sector - sector_nr < nr_sectors) ======= r1_bio->sector = sector_nr; r1_bio->cmd = SPECIAL; + bio = r1_bio->master_bio; + nr_sectors = RESYNC_BLOCK_SIZE >> 9; + if (max_sector - sector_nr < nr_sectors) >>>>>>> replacement - } -} - -#define INVALID_LEVEL KERN_WARNING \ -"raid1: md%d: raid level not set to mirroring (%d)\n" #define NO_SB KERN_ERR \ "raid1: disabled mirror %s (couldn't access raid superblock)\n" @@ -1587,9 +1706,19 @@ int i, j, disk_idx; struct mirror_info *disk; mdp_super_t *sb = mddev->sb; +<<<<<<< found mdp_disk_t *descriptor; mdk_rdev_t *rdev; struct md_list_head *tmp; +||||||| expected + mdp_disk_t *descriptor; + mdk_rdev_t *rdev; + struct list_head *tmp; +======= + mdp_disk_t *descriptor; + mdk_rdev_t *rdev; + struct list_head *tmp; +>>>>>>> replacement MOD_INC_USE_COUNT; @@ -1766,12 +1895,30 @@ const char * name = "raid1syncd"; conf->resync_thread = md_register_thread(raid1syncd, conf,name); + if (!conf->resync_thread) { + printk(THREAD_ERROR, mdidx(mddev)); + goto out_free_conf; + } + + printk(START_RESYNC, mdidx(mddev)); + conf->resync_mirrors = 1; + mddev->recovery_running = 2; + md_wakeup_thread(conf->resync_thread); ||||||| expected if (!start_recovery && !(sb->state & (1 << MD_SB_CLEAN)) && (conf->working_disks > 1)) { const char * name = "raid1syncd"; conf->resync_thread = md_register_thread(raid1syncd, conf, name); + if (!conf->resync_thread) { + printk(THREAD_ERROR, mdidx(mddev)); + goto out_free_conf; + } + + printk(START_RESYNC, mdidx(mddev)); + conf->resync_mirrors = 1; + mddev->recovery_running = 2; + md_wakeup_thread(conf->resync_thread); ======= >>>>>>> replacement @@ -1822,6 +1969,30 @@ static int raid1_stop_resync (mddev_t *mddev) { raid1_conf_t *conf = mddev_to_conf(mddev); +||||||| expected + return -EIO; +} + +static int stop_resync(mddev_t *mddev) +{ + conf_t *conf = mddev_to_conf(mddev); +======= + return -EIO; +} + +static int stop(mddev_t *mddev) +>>>>>>> replacement +<<<<<<< found + + if (conf->resync_thread) { + if (conf->resync_mirrors) { + md_interrupt_thread(conf->resync_thread); + + printk(KERN_INFO "raid1: mirror resync was not fully finished, restarting next time.\n"); + return 1; + } + return 0; +||||||| expected if (conf->resync_thread) { if (conf->resync_mirrors) { @@ -1831,6 +2002,10 @@ return 1; } return 0; +======= +{ +>>>>>>> replacement +<<<<<<< found } return 0; } @@ -1838,37 +2013,75 @@ static int raid1_restart_resync (mddev_t *mddev) { raid1_conf_t *conf = mddev_to_conf(mddev); + + if (conf->resync_mirrors) { + if (!conf->resync_thread) { + MD_BUG(); + return 0; + } + mddev->recovery_running = 2; + md_wakeup_thread(conf->resync_thread); + return 1; + } + return 0; +} + +static int raid1_stop (mddev_t *mddev) +{ + raid1_conf_t *conf = mddev_to_conf(mddev); ||||||| expected -static int stop_resync(mddev_t *mddev) + } + return 0; +} + +static int restart_resync(mddev_t *mddev) { conf_t *conf = mddev_to_conf(mddev); - if (conf->resync_thread) { - if (conf->resync_mirrors) { - md_interrupt_thread(conf->resync_thread); - - printk(KERN_INFO "raid1: mirror resync was not fully finished, restarting next time.\n"); - return 1; + if (conf->resync_mirrors) { + if (!conf->resync_thread) { + MD_BUG(); + return 0; } - return 0; + mddev->recovery_running = 2; + md_wakeup_thread(conf->resync_thread); + return 1; } return 0; } -static int restart_resync(mddev_t *mddev) +static int stop(mddev_t *mddev) { conf_t *conf = mddev_to_conf(mddev); + int i; ======= + conf_t *conf = mddev_to_conf(mddev); + int i; >>>>>>> replacement -static int raid1_stop (mddev_t *mddev) -{ - raid1_conf_t *conf = mddev_to_conf(mddev); +<<<<<<< found md_unregister_thread(conf->thread); + if (conf->resync_thread) + md_unregister_thread(conf->resync_thread); raid1_shrink_r1bh(conf); raid1_shrink_bh(conf); raid1_shrink_buffers(conf); kfree(conf); +||||||| expected + + md_unregister_thread(conf->thread); + if (conf->resync_thread) + md_unregister_thread(conf->resync_thread); + if (conf->r1bio_pool) + mempool_destroy(conf->r1bio_pool); + for (i = 0; i < MD_SB_DISKS; i++) +======= + + md_unregister_thread(conf->thread); + if (conf->r1bio_pool) + mempool_destroy(conf->r1bio_pool); + for (i = 0; i < MD_SB_DISKS; i++) +>>>>>>> replacement mddev->private = NULL; MOD_DEC_USE_COUNT; return 0; @@ -1883,20 +2096,28 @@ status: raid1_status, error_handler: raid1_error, diskop: raid1_diskop, -<<<<<<< found stop_resync: raid1_stop_resync, restart_resync: raid1_restart_resync, -||||||| expected - stop_resync: stop_resync, - restart_resync: restart_resync, -======= ->>>>>>> replacement +<<<<<<< found sync_request: raid1_sync_request }; static int md__init raid1_init (void) { return register_md_personality (RAID1, &raid1_personality); +||||||| expected + status: status, + error_handler: error, + diskop: diskop, + stop_resync: stop_resync, + restart_resync: restart_resync, + sync_request: sync_request +======= + status: status, + error_handler: error, + diskop: diskop, + sync_request: sync_request +>>>>>>> replacement } static void raid1_exit (void) ./linux/md-resync/merge FAILED 0.25 1 unresolved conflict found 4 already-applied changes ignored --- merge 2013-08-23 08:02:27.000000000 +0200 +++ - 2018-07-31 13:37:07.524053295 +0200 @@ -2602,15 +2602,29 @@ goto done_unlock; <<<<<<< found + case START_ARRAY: + /* + * possibly make it lock the array ... + */ err = autostart_array((kdev_t)arg); if (err) { printk(KERN_WARNING "md: autostart %s failed!\n", partition_name((kdev_t)arg)); + goto abort_unlock; + } + goto done_unlock; ||||||| expected + case START_ARRAY: + /* + * possibly make it lock the array ... + */ err = autostart_array(val_to_kdev(arg)); if (err) { printk(KERN_WARNING "md: autostart %s failed!\n", partition_name(val_to_kdev(arg))); + goto abort_unlock; + } + goto done_unlock; ======= >>>>>>> replacement default:; ./linux/md-autostart/merge FAILED 0.04 1 unresolved conflict found ./linux/idmap.h/merge SUCCEEDED 0.00 19 succeeded and 48 failed make: *** [Makefile:32: test] Error 1 * ERROR: dev-util/wiggle-1.0::gentoo failed (test phase): * emake failed * * If you need support, post the output of `emerge --info '=dev-util/wiggle-1.0::gentoo'`, * the complete build log and the output of `emerge -pqv '=dev-util/wiggle-1.0::gentoo'`. * The complete build log is located at '/var/log/portage/build/dev-util/wiggle-1.0:20180731-113635.log'. * For convenience, a symlink to the build log is located at '/var/tmp/portage/dev-util/wiggle-1.0/temp/build.log'. * The ebuild environment file is located at '/var/tmp/portage/dev-util/wiggle-1.0/temp/environment'. * Working directory: '/var/tmp/portage/dev-util/wiggle-1.0/work/wiggle-1.0' * S: '/var/tmp/portage/dev-util/wiggle-1.0/work/wiggle-1.0'