drbd_nl.c 86 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198
  1. /*
  2. drbd_nl.c
  3. This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
  4. Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
  5. Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
  6. Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
  7. drbd is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11. drbd is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. GNU General Public License for more details.
  15. You should have received a copy of the GNU General Public License
  16. along with drbd; see the file COPYING. If not, write to
  17. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19. #include <linux/module.h>
  20. #include <linux/drbd.h>
  21. #include <linux/in.h>
  22. #include <linux/fs.h>
  23. #include <linux/file.h>
  24. #include <linux/slab.h>
  25. #include <linux/blkpg.h>
  26. #include <linux/cpumask.h>
  27. #include "drbd_int.h"
  28. #include "drbd_req.h"
  29. #include "drbd_wrappers.h"
  30. #include <asm/unaligned.h>
  31. #include <linux/drbd_limits.h>
  32. #include <linux/kthread.h>
  33. #include <net/genetlink.h>
  34. /* .doit */
  35. // int drbd_adm_create_resource(struct sk_buff *skb, struct genl_info *info);
  36. // int drbd_adm_delete_resource(struct sk_buff *skb, struct genl_info *info);
  37. int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info);
  38. int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info);
  39. int drbd_adm_create_connection(struct sk_buff *skb, struct genl_info *info);
  40. int drbd_adm_delete_connection(struct sk_buff *skb, struct genl_info *info);
  41. int drbd_adm_down(struct sk_buff *skb, struct genl_info *info);
  42. int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info);
  43. int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info);
  44. int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info);
  45. int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info);
  46. int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info);
  47. int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info);
  48. int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info);
  49. int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info);
  50. int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info);
  51. int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info);
  52. int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info);
  53. int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info);
  54. int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info);
  55. int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info);
  56. int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info);
  57. int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info);
  58. int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info);
  59. int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info);
  60. int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info);
  61. int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info);
  62. /* .dumpit */
  63. int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb);
  64. #include <linux/drbd_genl_api.h>
  65. #include <linux/genl_magic_func.h>
  66. /* used blkdev_get_by_path, to claim our meta data device(s) */
  67. static char *drbd_m_holder = "Hands off! this is DRBD's meta data device.";
  68. /* Configuration is strictly serialized, because generic netlink message
  69. * processing is strictly serialized by the genl_lock().
  70. * Which means we can use one static global drbd_config_context struct.
  71. */
  72. static struct drbd_config_context {
  73. /* assigned from drbd_genlmsghdr */
  74. unsigned int minor;
  75. /* assigned from request attributes, if present */
  76. unsigned int volume;
  77. #define VOLUME_UNSPECIFIED (-1U)
  78. /* pointer into the request skb,
  79. * limited lifetime! */
  80. char *conn_name;
  81. /* reply buffer */
  82. struct sk_buff *reply_skb;
  83. /* pointer into reply buffer */
  84. struct drbd_genlmsghdr *reply_dh;
  85. /* resolved from attributes, if possible */
  86. struct drbd_conf *mdev;
  87. struct drbd_tconn *tconn;
  88. } adm_ctx;
  89. static void drbd_adm_send_reply(struct sk_buff *skb, struct genl_info *info)
  90. {
  91. genlmsg_end(skb, genlmsg_data(nlmsg_data(nlmsg_hdr(skb))));
  92. if (genlmsg_reply(skb, info))
  93. printk(KERN_ERR "drbd: error sending genl reply\n");
  94. }
  95. /* Used on a fresh "drbd_adm_prepare"d reply_skb, this cannot fail: The only
  96. * reason it could fail was no space in skb, and there are 4k available. */
  97. int drbd_msg_put_info(const char *info)
  98. {
  99. struct sk_buff *skb = adm_ctx.reply_skb;
  100. struct nlattr *nla;
  101. int err = -EMSGSIZE;
  102. if (!info || !info[0])
  103. return 0;
  104. nla = nla_nest_start(skb, DRBD_NLA_CFG_REPLY);
  105. if (!nla)
  106. return err;
  107. err = nla_put_string(skb, T_info_text, info);
  108. if (err) {
  109. nla_nest_cancel(skb, nla);
  110. return err;
  111. } else
  112. nla_nest_end(skb, nla);
  113. return 0;
  114. }
  115. /* This would be a good candidate for a "pre_doit" hook,
  116. * and per-family private info->pointers.
  117. * But we need to stay compatible with older kernels.
  118. * If it returns successfully, adm_ctx members are valid.
  119. */
  120. #define DRBD_ADM_NEED_MINOR 1
  121. #define DRBD_ADM_NEED_CONN 2
  122. static int drbd_adm_prepare(struct sk_buff *skb, struct genl_info *info,
  123. unsigned flags)
  124. {
  125. struct drbd_genlmsghdr *d_in = info->userhdr;
  126. const u8 cmd = info->genlhdr->cmd;
  127. int err;
  128. memset(&adm_ctx, 0, sizeof(adm_ctx));
  129. /* genl_rcv_msg only checks for CAP_NET_ADMIN on "GENL_ADMIN_PERM" :( */
  130. if (cmd != DRBD_ADM_GET_STATUS
  131. && security_netlink_recv(skb, CAP_SYS_ADMIN))
  132. return -EPERM;
  133. adm_ctx.reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
  134. if (!adm_ctx.reply_skb)
  135. goto fail;
  136. adm_ctx.reply_dh = genlmsg_put_reply(adm_ctx.reply_skb,
  137. info, &drbd_genl_family, 0, cmd);
  138. /* put of a few bytes into a fresh skb of >= 4k will always succeed.
  139. * but anyways */
  140. if (!adm_ctx.reply_dh)
  141. goto fail;
  142. adm_ctx.reply_dh->minor = d_in->minor;
  143. adm_ctx.reply_dh->ret_code = NO_ERROR;
  144. if (info->attrs[DRBD_NLA_CFG_CONTEXT]) {
  145. struct nlattr *nla;
  146. /* parse and validate only */
  147. err = drbd_cfg_context_from_attrs(NULL, info);
  148. if (err)
  149. goto fail;
  150. /* It was present, and valid,
  151. * copy it over to the reply skb. */
  152. err = nla_put_nohdr(adm_ctx.reply_skb,
  153. info->attrs[DRBD_NLA_CFG_CONTEXT]->nla_len,
  154. info->attrs[DRBD_NLA_CFG_CONTEXT]);
  155. if (err)
  156. goto fail;
  157. /* and assign stuff to the global adm_ctx */
  158. nla = nested_attr_tb[__nla_type(T_ctx_volume)];
  159. adm_ctx.volume = nla ? nla_get_u32(nla) : VOLUME_UNSPECIFIED;
  160. nla = nested_attr_tb[__nla_type(T_ctx_conn_name)];
  161. if (nla)
  162. adm_ctx.conn_name = nla_data(nla);
  163. } else
  164. adm_ctx.volume = VOLUME_UNSPECIFIED;
  165. adm_ctx.minor = d_in->minor;
  166. adm_ctx.mdev = minor_to_mdev(d_in->minor);
  167. adm_ctx.tconn = conn_get_by_name(adm_ctx.conn_name);
  168. if (!adm_ctx.mdev && (flags & DRBD_ADM_NEED_MINOR)) {
  169. drbd_msg_put_info("unknown minor");
  170. return ERR_MINOR_INVALID;
  171. }
  172. if (!adm_ctx.tconn && (flags & DRBD_ADM_NEED_CONN)) {
  173. drbd_msg_put_info("unknown connection");
  174. return ERR_INVALID_REQUEST;
  175. }
  176. /* some more paranoia, if the request was over-determined */
  177. if (adm_ctx.mdev && adm_ctx.tconn &&
  178. adm_ctx.mdev->tconn != adm_ctx.tconn) {
  179. pr_warning("request: minor=%u, conn=%s; but that minor belongs to connection %s\n",
  180. adm_ctx.minor, adm_ctx.conn_name, adm_ctx.mdev->tconn->name);
  181. drbd_msg_put_info("minor exists in different connection");
  182. return ERR_INVALID_REQUEST;
  183. }
  184. if (adm_ctx.mdev &&
  185. adm_ctx.volume != VOLUME_UNSPECIFIED &&
  186. adm_ctx.volume != adm_ctx.mdev->vnr) {
  187. pr_warning("request: minor=%u, volume=%u; but that minor is volume %u in %s\n",
  188. adm_ctx.minor, adm_ctx.volume,
  189. adm_ctx.mdev->vnr, adm_ctx.mdev->tconn->name);
  190. drbd_msg_put_info("minor exists as different volume");
  191. return ERR_INVALID_REQUEST;
  192. }
  193. return NO_ERROR;
  194. fail:
  195. nlmsg_free(adm_ctx.reply_skb);
  196. adm_ctx.reply_skb = NULL;
  197. return -ENOMEM;
  198. }
  199. static int drbd_adm_finish(struct genl_info *info, int retcode)
  200. {
  201. struct nlattr *nla;
  202. const char *conn_name = NULL;
  203. if (adm_ctx.tconn) {
  204. kref_put(&adm_ctx.tconn->kref, &conn_destroy);
  205. adm_ctx.tconn = NULL;
  206. }
  207. if (!adm_ctx.reply_skb)
  208. return -ENOMEM;
  209. adm_ctx.reply_dh->ret_code = retcode;
  210. nla = info->attrs[DRBD_NLA_CFG_CONTEXT];
  211. if (nla) {
  212. nla = nla_find_nested(nla, __nla_type(T_ctx_conn_name));
  213. if (nla)
  214. conn_name = nla_data(nla);
  215. }
  216. drbd_adm_send_reply(adm_ctx.reply_skb, info);
  217. return 0;
  218. }
  219. static void setup_khelper_env(struct drbd_tconn *tconn, char **envp)
  220. {
  221. char *afs;
  222. struct net_conf *nc;
  223. rcu_read_lock();
  224. nc = rcu_dereference(tconn->net_conf);
  225. if (nc) {
  226. switch (((struct sockaddr *)nc->peer_addr)->sa_family) {
  227. case AF_INET6:
  228. afs = "ipv6";
  229. snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI6",
  230. &((struct sockaddr_in6 *)nc->peer_addr)->sin6_addr);
  231. break;
  232. case AF_INET:
  233. afs = "ipv4";
  234. snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
  235. &((struct sockaddr_in *)nc->peer_addr)->sin_addr);
  236. break;
  237. default:
  238. afs = "ssocks";
  239. snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
  240. &((struct sockaddr_in *)nc->peer_addr)->sin_addr);
  241. }
  242. snprintf(envp[3], 20, "DRBD_PEER_AF=%s", afs);
  243. }
  244. rcu_read_unlock();
  245. }
  246. int drbd_khelper(struct drbd_conf *mdev, char *cmd)
  247. {
  248. char *envp[] = { "HOME=/",
  249. "TERM=linux",
  250. "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
  251. (char[20]) { }, /* address family */
  252. (char[60]) { }, /* address */
  253. NULL };
  254. char mb[12];
  255. char *argv[] = {usermode_helper, cmd, mb, NULL };
  256. struct sib_info sib;
  257. int ret;
  258. snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev));
  259. setup_khelper_env(mdev->tconn, envp);
  260. /* The helper may take some time.
  261. * write out any unsynced meta data changes now */
  262. drbd_md_sync(mdev);
  263. dev_info(DEV, "helper command: %s %s %s\n", usermode_helper, cmd, mb);
  264. sib.sib_reason = SIB_HELPER_PRE;
  265. sib.helper_name = cmd;
  266. drbd_bcast_event(mdev, &sib);
  267. ret = call_usermodehelper(usermode_helper, argv, envp, 1);
  268. if (ret)
  269. dev_warn(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
  270. usermode_helper, cmd, mb,
  271. (ret >> 8) & 0xff, ret);
  272. else
  273. dev_info(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
  274. usermode_helper, cmd, mb,
  275. (ret >> 8) & 0xff, ret);
  276. sib.sib_reason = SIB_HELPER_POST;
  277. sib.helper_exit_code = ret;
  278. drbd_bcast_event(mdev, &sib);
  279. if (ret < 0) /* Ignore any ERRNOs we got. */
  280. ret = 0;
  281. return ret;
  282. }
  283. static void conn_md_sync(struct drbd_tconn *tconn)
  284. {
  285. struct drbd_conf *mdev;
  286. int vnr;
  287. down_read(&drbd_cfg_rwsem);
  288. idr_for_each_entry(&tconn->volumes, mdev, vnr)
  289. drbd_md_sync(mdev);
  290. up_read(&drbd_cfg_rwsem);
  291. }
  292. int conn_khelper(struct drbd_tconn *tconn, char *cmd)
  293. {
  294. char *envp[] = { "HOME=/",
  295. "TERM=linux",
  296. "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
  297. (char[20]) { }, /* address family */
  298. (char[60]) { }, /* address */
  299. NULL };
  300. char *argv[] = {usermode_helper, cmd, tconn->name, NULL };
  301. int ret;
  302. setup_khelper_env(tconn, envp);
  303. conn_md_sync(tconn);
  304. conn_info(tconn, "helper command: %s %s %s\n", usermode_helper, cmd, tconn->name);
  305. /* TODO: conn_bcast_event() ?? */
  306. ret = call_usermodehelper(usermode_helper, argv, envp, 1);
  307. if (ret)
  308. conn_warn(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
  309. usermode_helper, cmd, tconn->name,
  310. (ret >> 8) & 0xff, ret);
  311. else
  312. conn_info(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
  313. usermode_helper, cmd, tconn->name,
  314. (ret >> 8) & 0xff, ret);
  315. /* TODO: conn_bcast_event() ?? */
  316. if (ret < 0) /* Ignore any ERRNOs we got. */
  317. ret = 0;
  318. return ret;
  319. }
  320. static enum drbd_fencing_p highest_fencing_policy(struct drbd_tconn *tconn)
  321. {
  322. enum drbd_fencing_p fp = FP_NOT_AVAIL;
  323. struct drbd_conf *mdev;
  324. int vnr;
  325. rcu_read_lock();
  326. idr_for_each_entry(&tconn->volumes, mdev, vnr) {
  327. if (get_ldev_if_state(mdev, D_CONSISTENT)) {
  328. fp = max_t(enum drbd_fencing_p, fp, mdev->ldev->dc.fencing);
  329. put_ldev(mdev);
  330. }
  331. }
  332. rcu_read_unlock();
  333. return fp;
  334. }
  335. bool conn_try_outdate_peer(struct drbd_tconn *tconn)
  336. {
  337. union drbd_state mask = { };
  338. union drbd_state val = { };
  339. enum drbd_fencing_p fp;
  340. char *ex_to_string;
  341. int r;
  342. if (tconn->cstate >= C_WF_REPORT_PARAMS) {
  343. conn_err(tconn, "Expected cstate < C_WF_REPORT_PARAMS\n");
  344. return false;
  345. }
  346. fp = highest_fencing_policy(tconn);
  347. switch (fp) {
  348. case FP_NOT_AVAIL:
  349. conn_warn(tconn, "Not fencing peer, I'm not even Consistent myself.\n");
  350. goto out;
  351. case FP_DONT_CARE:
  352. return true;
  353. default: ;
  354. }
  355. r = conn_khelper(tconn, "fence-peer");
  356. switch ((r>>8) & 0xff) {
  357. case 3: /* peer is inconsistent */
  358. ex_to_string = "peer is inconsistent or worse";
  359. mask.pdsk = D_MASK;
  360. val.pdsk = D_INCONSISTENT;
  361. break;
  362. case 4: /* peer got outdated, or was already outdated */
  363. ex_to_string = "peer was fenced";
  364. mask.pdsk = D_MASK;
  365. val.pdsk = D_OUTDATED;
  366. break;
  367. case 5: /* peer was down */
  368. if (conn_highest_disk(tconn) == D_UP_TO_DATE) {
  369. /* we will(have) create(d) a new UUID anyways... */
  370. ex_to_string = "peer is unreachable, assumed to be dead";
  371. mask.pdsk = D_MASK;
  372. val.pdsk = D_OUTDATED;
  373. } else {
  374. ex_to_string = "peer unreachable, doing nothing since disk != UpToDate";
  375. }
  376. break;
  377. case 6: /* Peer is primary, voluntarily outdate myself.
  378. * This is useful when an unconnected R_SECONDARY is asked to
  379. * become R_PRIMARY, but finds the other peer being active. */
  380. ex_to_string = "peer is active";
  381. conn_warn(tconn, "Peer is primary, outdating myself.\n");
  382. mask.disk = D_MASK;
  383. val.disk = D_OUTDATED;
  384. break;
  385. case 7:
  386. if (fp != FP_STONITH)
  387. conn_err(tconn, "fence-peer() = 7 && fencing != Stonith !!!\n");
  388. ex_to_string = "peer was stonithed";
  389. mask.pdsk = D_MASK;
  390. val.pdsk = D_OUTDATED;
  391. break;
  392. default:
  393. /* The script is broken ... */
  394. conn_err(tconn, "fence-peer helper broken, returned %d\n", (r>>8)&0xff);
  395. return false; /* Eventually leave IO frozen */
  396. }
  397. conn_info(tconn, "fence-peer helper returned %d (%s)\n",
  398. (r>>8) & 0xff, ex_to_string);
  399. out:
  400. /* Not using
  401. conn_request_state(tconn, mask, val, CS_VERBOSE);
  402. here, because we might were able to re-establish the connection in the
  403. meantime. */
  404. spin_lock_irq(&tconn->req_lock);
  405. if (tconn->cstate < C_WF_REPORT_PARAMS)
  406. _conn_request_state(tconn, mask, val, CS_VERBOSE);
  407. spin_unlock_irq(&tconn->req_lock);
  408. return conn_highest_pdsk(tconn) <= D_OUTDATED;
  409. }
  410. static int _try_outdate_peer_async(void *data)
  411. {
  412. struct drbd_tconn *tconn = (struct drbd_tconn *)data;
  413. conn_try_outdate_peer(tconn);
  414. kref_put(&tconn->kref, &conn_destroy);
  415. return 0;
  416. }
  417. void conn_try_outdate_peer_async(struct drbd_tconn *tconn)
  418. {
  419. struct task_struct *opa;
  420. kref_get(&tconn->kref);
  421. opa = kthread_run(_try_outdate_peer_async, tconn, "drbd_async_h");
  422. if (IS_ERR(opa)) {
  423. conn_err(tconn, "out of mem, failed to invoke fence-peer helper\n");
  424. kref_put(&tconn->kref, &conn_destroy);
  425. }
  426. }
  427. enum drbd_state_rv
  428. drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
  429. {
  430. const int max_tries = 4;
  431. enum drbd_state_rv rv = SS_UNKNOWN_ERROR;
  432. struct net_conf *nc;
  433. int try = 0;
  434. int forced = 0;
  435. union drbd_state mask, val;
  436. if (new_role == R_PRIMARY)
  437. request_ping(mdev->tconn); /* Detect a dead peer ASAP */
  438. mutex_lock(mdev->state_mutex);
  439. mask.i = 0; mask.role = R_MASK;
  440. val.i = 0; val.role = new_role;
  441. while (try++ < max_tries) {
  442. rv = _drbd_request_state(mdev, mask, val, CS_WAIT_COMPLETE);
  443. /* in case we first succeeded to outdate,
  444. * but now suddenly could establish a connection */
  445. if (rv == SS_CW_FAILED_BY_PEER && mask.pdsk != 0) {
  446. val.pdsk = 0;
  447. mask.pdsk = 0;
  448. continue;
  449. }
  450. if (rv == SS_NO_UP_TO_DATE_DISK && force &&
  451. (mdev->state.disk < D_UP_TO_DATE &&
  452. mdev->state.disk >= D_INCONSISTENT)) {
  453. mask.disk = D_MASK;
  454. val.disk = D_UP_TO_DATE;
  455. forced = 1;
  456. continue;
  457. }
  458. if (rv == SS_NO_UP_TO_DATE_DISK &&
  459. mdev->state.disk == D_CONSISTENT && mask.pdsk == 0) {
  460. D_ASSERT(mdev->state.pdsk == D_UNKNOWN);
  461. if (conn_try_outdate_peer(mdev->tconn)) {
  462. val.disk = D_UP_TO_DATE;
  463. mask.disk = D_MASK;
  464. }
  465. continue;
  466. }
  467. if (rv == SS_NOTHING_TO_DO)
  468. goto out;
  469. if (rv == SS_PRIMARY_NOP && mask.pdsk == 0) {
  470. if (!conn_try_outdate_peer(mdev->tconn) && force) {
  471. dev_warn(DEV, "Forced into split brain situation!\n");
  472. mask.pdsk = D_MASK;
  473. val.pdsk = D_OUTDATED;
  474. }
  475. continue;
  476. }
  477. if (rv == SS_TWO_PRIMARIES) {
  478. /* Maybe the peer is detected as dead very soon...
  479. retry at most once more in this case. */
  480. int timeo;
  481. rcu_read_lock();
  482. nc = rcu_dereference(mdev->tconn->net_conf);
  483. timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
  484. rcu_read_unlock();
  485. schedule_timeout_interruptible(timeo);
  486. if (try < max_tries)
  487. try = max_tries - 1;
  488. continue;
  489. }
  490. if (rv < SS_SUCCESS) {
  491. rv = _drbd_request_state(mdev, mask, val,
  492. CS_VERBOSE + CS_WAIT_COMPLETE);
  493. if (rv < SS_SUCCESS)
  494. goto out;
  495. }
  496. break;
  497. }
  498. if (rv < SS_SUCCESS)
  499. goto out;
  500. if (forced)
  501. dev_warn(DEV, "Forced to consider local data as UpToDate!\n");
  502. /* Wait until nothing is on the fly :) */
  503. wait_event(mdev->misc_wait, atomic_read(&mdev->ap_pending_cnt) == 0);
  504. if (new_role == R_SECONDARY) {
  505. set_disk_ro(mdev->vdisk, true);
  506. if (get_ldev(mdev)) {
  507. mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
  508. put_ldev(mdev);
  509. }
  510. } else {
  511. mutex_lock(&mdev->tconn->net_conf_update);
  512. nc = mdev->tconn->net_conf;
  513. if (nc)
  514. nc->want_lose = 0; /* without copy; single bit op is atomic */
  515. mutex_unlock(&mdev->tconn->net_conf_update);
  516. set_disk_ro(mdev->vdisk, false);
  517. if (get_ldev(mdev)) {
  518. if (((mdev->state.conn < C_CONNECTED ||
  519. mdev->state.pdsk <= D_FAILED)
  520. && mdev->ldev->md.uuid[UI_BITMAP] == 0) || forced)
  521. drbd_uuid_new_current(mdev);
  522. mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1;
  523. put_ldev(mdev);
  524. }
  525. }
  526. /* writeout of activity log covered areas of the bitmap
  527. * to stable storage done in after state change already */
  528. if (mdev->state.conn >= C_WF_REPORT_PARAMS) {
  529. /* if this was forced, we should consider sync */
  530. if (forced)
  531. drbd_send_uuids(mdev);
  532. drbd_send_state(mdev);
  533. }
  534. drbd_md_sync(mdev);
  535. kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
  536. out:
  537. mutex_unlock(mdev->state_mutex);
  538. return rv;
  539. }
  540. static const char *from_attrs_err_to_txt(int err)
  541. {
  542. return err == -ENOMSG ? "required attribute missing" :
  543. err == -EOPNOTSUPP ? "unknown mandatory attribute" :
  544. err == -EEXIST ? "can not change invariant setting" :
  545. "invalid attribute value";
  546. }
  547. int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info)
  548. {
  549. struct set_role_parms parms;
  550. int err;
  551. enum drbd_ret_code retcode;
  552. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  553. if (!adm_ctx.reply_skb)
  554. return retcode;
  555. if (retcode != NO_ERROR)
  556. goto out;
  557. memset(&parms, 0, sizeof(parms));
  558. if (info->attrs[DRBD_NLA_SET_ROLE_PARMS]) {
  559. err = set_role_parms_from_attrs(&parms, info);
  560. if (err) {
  561. retcode = ERR_MANDATORY_TAG;
  562. drbd_msg_put_info(from_attrs_err_to_txt(err));
  563. goto out;
  564. }
  565. }
  566. if (info->genlhdr->cmd == DRBD_ADM_PRIMARY)
  567. retcode = drbd_set_role(adm_ctx.mdev, R_PRIMARY, parms.assume_uptodate);
  568. else
  569. retcode = drbd_set_role(adm_ctx.mdev, R_SECONDARY, 0);
  570. out:
  571. drbd_adm_finish(info, retcode);
  572. return 0;
  573. }
  574. /* initializes the md.*_offset members, so we are able to find
  575. * the on disk meta data */
  576. static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
  577. struct drbd_backing_dev *bdev)
  578. {
  579. sector_t md_size_sect = 0;
  580. switch (bdev->dc.meta_dev_idx) {
  581. default:
  582. /* v07 style fixed size indexed meta data */
  583. bdev->md.md_size_sect = MD_RESERVED_SECT;
  584. bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
  585. bdev->md.al_offset = MD_AL_OFFSET;
  586. bdev->md.bm_offset = MD_BM_OFFSET;
  587. break;
  588. case DRBD_MD_INDEX_FLEX_EXT:
  589. /* just occupy the full device; unit: sectors */
  590. bdev->md.md_size_sect = drbd_get_capacity(bdev->md_bdev);
  591. bdev->md.md_offset = 0;
  592. bdev->md.al_offset = MD_AL_OFFSET;
  593. bdev->md.bm_offset = MD_BM_OFFSET;
  594. break;
  595. case DRBD_MD_INDEX_INTERNAL:
  596. case DRBD_MD_INDEX_FLEX_INT:
  597. bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
  598. /* al size is still fixed */
  599. bdev->md.al_offset = -MD_AL_SECTORS;
  600. /* we need (slightly less than) ~ this much bitmap sectors: */
  601. md_size_sect = drbd_get_capacity(bdev->backing_bdev);
  602. md_size_sect = ALIGN(md_size_sect, BM_SECT_PER_EXT);
  603. md_size_sect = BM_SECT_TO_EXT(md_size_sect);
  604. md_size_sect = ALIGN(md_size_sect, 8);
  605. /* plus the "drbd meta data super block",
  606. * and the activity log; */
  607. md_size_sect += MD_BM_OFFSET;
  608. bdev->md.md_size_sect = md_size_sect;
  609. /* bitmap offset is adjusted by 'super' block size */
  610. bdev->md.bm_offset = -md_size_sect + MD_AL_OFFSET;
  611. break;
  612. }
  613. }
  614. /* input size is expected to be in KB */
  615. char *ppsize(char *buf, unsigned long long size)
  616. {
  617. /* Needs 9 bytes at max including trailing NUL:
  618. * -1ULL ==> "16384 EB" */
  619. static char units[] = { 'K', 'M', 'G', 'T', 'P', 'E' };
  620. int base = 0;
  621. while (size >= 10000 && base < sizeof(units)-1) {
  622. /* shift + round */
  623. size = (size >> 10) + !!(size & (1<<9));
  624. base++;
  625. }
  626. sprintf(buf, "%u %cB", (unsigned)size, units[base]);
  627. return buf;
  628. }
  629. /* there is still a theoretical deadlock when called from receiver
  630. * on an D_INCONSISTENT R_PRIMARY:
  631. * remote READ does inc_ap_bio, receiver would need to receive answer
  632. * packet from remote to dec_ap_bio again.
  633. * receiver receive_sizes(), comes here,
  634. * waits for ap_bio_cnt == 0. -> deadlock.
  635. * but this cannot happen, actually, because:
  636. * R_PRIMARY D_INCONSISTENT, and peer's disk is unreachable
  637. * (not connected, or bad/no disk on peer):
  638. * see drbd_fail_request_early, ap_bio_cnt is zero.
  639. * R_PRIMARY D_INCONSISTENT, and C_SYNC_TARGET:
  640. * peer may not initiate a resize.
  641. */
  642. /* Note these are not to be confused with
  643. * drbd_adm_suspend_io/drbd_adm_resume_io,
  644. * which are (sub) state changes triggered by admin (drbdsetup),
  645. * and can be long lived.
  646. * This changes an mdev->flag, is triggered by drbd internals,
  647. * and should be short-lived. */
  648. void drbd_suspend_io(struct drbd_conf *mdev)
  649. {
  650. set_bit(SUSPEND_IO, &mdev->flags);
  651. if (drbd_suspended(mdev))
  652. return;
  653. wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
  654. }
  655. void drbd_resume_io(struct drbd_conf *mdev)
  656. {
  657. clear_bit(SUSPEND_IO, &mdev->flags);
  658. wake_up(&mdev->misc_wait);
  659. }
  660. /**
  661. * drbd_determine_dev_size() - Sets the right device size obeying all constraints
  662. * @mdev: DRBD device.
  663. *
  664. * Returns 0 on success, negative return values indicate errors.
  665. * You should call drbd_md_sync() after calling this function.
  666. */
  667. enum determine_dev_size drbd_determine_dev_size(struct drbd_conf *mdev, enum dds_flags flags) __must_hold(local)
  668. {
  669. sector_t prev_first_sect, prev_size; /* previous meta location */
  670. sector_t la_size;
  671. sector_t size;
  672. char ppb[10];
  673. int md_moved, la_size_changed;
  674. enum determine_dev_size rv = unchanged;
  675. /* race:
  676. * application request passes inc_ap_bio,
  677. * but then cannot get an AL-reference.
  678. * this function later may wait on ap_bio_cnt == 0. -> deadlock.
  679. *
  680. * to avoid that:
  681. * Suspend IO right here.
  682. * still lock the act_log to not trigger ASSERTs there.
  683. */
  684. drbd_suspend_io(mdev);
  685. /* no wait necessary anymore, actually we could assert that */
  686. wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
  687. prev_first_sect = drbd_md_first_sector(mdev->ldev);
  688. prev_size = mdev->ldev->md.md_size_sect;
  689. la_size = mdev->ldev->md.la_size_sect;
  690. /* TODO: should only be some assert here, not (re)init... */
  691. drbd_md_set_sector_offsets(mdev, mdev->ldev);
  692. size = drbd_new_dev_size(mdev, mdev->ldev, flags & DDSF_FORCED);
  693. if (drbd_get_capacity(mdev->this_bdev) != size ||
  694. drbd_bm_capacity(mdev) != size) {
  695. int err;
  696. err = drbd_bm_resize(mdev, size, !(flags & DDSF_NO_RESYNC));
  697. if (unlikely(err)) {
  698. /* currently there is only one error: ENOMEM! */
  699. size = drbd_bm_capacity(mdev)>>1;
  700. if (size == 0) {
  701. dev_err(DEV, "OUT OF MEMORY! "
  702. "Could not allocate bitmap!\n");
  703. } else {
  704. dev_err(DEV, "BM resizing failed. "
  705. "Leaving size unchanged at size = %lu KB\n",
  706. (unsigned long)size);
  707. }
  708. rv = dev_size_error;
  709. }
  710. /* racy, see comments above. */
  711. drbd_set_my_capacity(mdev, size);
  712. mdev->ldev->md.la_size_sect = size;
  713. dev_info(DEV, "size = %s (%llu KB)\n", ppsize(ppb, size>>1),
  714. (unsigned long long)size>>1);
  715. }
  716. if (rv == dev_size_error)
  717. goto out;
  718. la_size_changed = (la_size != mdev->ldev->md.la_size_sect);
  719. md_moved = prev_first_sect != drbd_md_first_sector(mdev->ldev)
  720. || prev_size != mdev->ldev->md.md_size_sect;
  721. if (la_size_changed || md_moved) {
  722. int err;
  723. drbd_al_shrink(mdev); /* All extents inactive. */
  724. dev_info(DEV, "Writing the whole bitmap, %s\n",
  725. la_size_changed && md_moved ? "size changed and md moved" :
  726. la_size_changed ? "size changed" : "md moved");
  727. /* next line implicitly does drbd_suspend_io()+drbd_resume_io() */
  728. err = drbd_bitmap_io(mdev, &drbd_bm_write,
  729. "size changed", BM_LOCKED_MASK);
  730. if (err) {
  731. rv = dev_size_error;
  732. goto out;
  733. }
  734. drbd_md_mark_dirty(mdev);
  735. }
  736. if (size > la_size)
  737. rv = grew;
  738. if (size < la_size)
  739. rv = shrunk;
  740. out:
  741. lc_unlock(mdev->act_log);
  742. wake_up(&mdev->al_wait);
  743. drbd_resume_io(mdev);
  744. return rv;
  745. }
  746. sector_t
  747. drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev, int assume_peer_has_space)
  748. {
  749. sector_t p_size = mdev->p_size; /* partner's disk size. */
  750. sector_t la_size = bdev->md.la_size_sect; /* last agreed size. */
  751. sector_t m_size; /* my size */
  752. sector_t u_size = bdev->dc.disk_size; /* size requested by user. */
  753. sector_t size = 0;
  754. m_size = drbd_get_max_capacity(bdev);
  755. if (mdev->state.conn < C_CONNECTED && assume_peer_has_space) {
  756. dev_warn(DEV, "Resize while not connected was forced by the user!\n");
  757. p_size = m_size;
  758. }
  759. if (p_size && m_size) {
  760. size = min_t(sector_t, p_size, m_size);
  761. } else {
  762. if (la_size) {
  763. size = la_size;
  764. if (m_size && m_size < size)
  765. size = m_size;
  766. if (p_size && p_size < size)
  767. size = p_size;
  768. } else {
  769. if (m_size)
  770. size = m_size;
  771. if (p_size)
  772. size = p_size;
  773. }
  774. }
  775. if (size == 0)
  776. dev_err(DEV, "Both nodes diskless!\n");
  777. if (u_size) {
  778. if (u_size > size)
  779. dev_err(DEV, "Requested disk size is too big (%lu > %lu)\n",
  780. (unsigned long)u_size>>1, (unsigned long)size>>1);
  781. else
  782. size = u_size;
  783. }
  784. return size;
  785. }
  786. /**
  787. * drbd_check_al_size() - Ensures that the AL is of the right size
  788. * @mdev: DRBD device.
  789. *
  790. * Returns -EBUSY if current al lru is still used, -ENOMEM when allocation
  791. * failed, and 0 on success. You should call drbd_md_sync() after you called
  792. * this function.
  793. */
  794. static int drbd_check_al_size(struct drbd_conf *mdev, struct disk_conf *dc)
  795. {
  796. struct lru_cache *n, *t;
  797. struct lc_element *e;
  798. unsigned int in_use;
  799. int i;
  800. if (!expect(dc->al_extents >= DRBD_AL_EXTENTS_MIN))
  801. dc->al_extents = DRBD_AL_EXTENTS_MIN;
  802. if (mdev->act_log &&
  803. mdev->act_log->nr_elements == dc->al_extents)
  804. return 0;
  805. in_use = 0;
  806. t = mdev->act_log;
  807. n = lc_create("act_log", drbd_al_ext_cache, AL_UPDATES_PER_TRANSACTION,
  808. dc->al_extents, sizeof(struct lc_element), 0);
  809. if (n == NULL) {
  810. dev_err(DEV, "Cannot allocate act_log lru!\n");
  811. return -ENOMEM;
  812. }
  813. spin_lock_irq(&mdev->al_lock);
  814. if (t) {
  815. for (i = 0; i < t->nr_elements; i++) {
  816. e = lc_element_by_index(t, i);
  817. if (e->refcnt)
  818. dev_err(DEV, "refcnt(%d)==%d\n",
  819. e->lc_number, e->refcnt);
  820. in_use += e->refcnt;
  821. }
  822. }
  823. if (!in_use)
  824. mdev->act_log = n;
  825. spin_unlock_irq(&mdev->al_lock);
  826. if (in_use) {
  827. dev_err(DEV, "Activity log still in use!\n");
  828. lc_destroy(n);
  829. return -EBUSY;
  830. } else {
  831. if (t)
  832. lc_destroy(t);
  833. }
  834. drbd_md_mark_dirty(mdev); /* we changed mdev->act_log->nr_elemens */
  835. return 0;
  836. }
  837. static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_size)
  838. {
  839. struct request_queue * const q = mdev->rq_queue;
  840. int max_hw_sectors = max_bio_size >> 9;
  841. int max_segments = 0;
  842. if (get_ldev_if_state(mdev, D_ATTACHING)) {
  843. struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
  844. max_hw_sectors = min(queue_max_hw_sectors(b), max_bio_size >> 9);
  845. max_segments = mdev->ldev->dc.max_bio_bvecs;
  846. put_ldev(mdev);
  847. }
  848. blk_queue_logical_block_size(q, 512);
  849. blk_queue_max_hw_sectors(q, max_hw_sectors);
  850. /* This is the workaround for "bio would need to, but cannot, be split" */
  851. blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
  852. blk_queue_segment_boundary(q, PAGE_CACHE_SIZE-1);
  853. if (get_ldev_if_state(mdev, D_ATTACHING)) {
  854. struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
  855. blk_queue_stack_limits(q, b);
  856. if (q->backing_dev_info.ra_pages != b->backing_dev_info.ra_pages) {
  857. dev_info(DEV, "Adjusting my ra_pages to backing device's (%lu -> %lu)\n",
  858. q->backing_dev_info.ra_pages,
  859. b->backing_dev_info.ra_pages);
  860. q->backing_dev_info.ra_pages = b->backing_dev_info.ra_pages;
  861. }
  862. put_ldev(mdev);
  863. }
  864. }
  865. void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
  866. {
  867. int now, new, local, peer;
  868. now = queue_max_hw_sectors(mdev->rq_queue) << 9;
  869. local = mdev->local_max_bio_size; /* Eventually last known value, from volatile memory */
  870. peer = mdev->peer_max_bio_size; /* Eventually last known value, from meta data */
  871. if (get_ldev_if_state(mdev, D_ATTACHING)) {
  872. local = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
  873. mdev->local_max_bio_size = local;
  874. put_ldev(mdev);
  875. }
  876. /* We may ignore peer limits if the peer is modern enough.
  877. Because new from 8.3.8 onwards the peer can use multiple
  878. BIOs for a single peer_request */
  879. if (mdev->state.conn >= C_CONNECTED) {
  880. if (mdev->tconn->agreed_pro_version < 94)
  881. peer = mdev->peer_max_bio_size;
  882. else if (mdev->tconn->agreed_pro_version == 94)
  883. peer = DRBD_MAX_SIZE_H80_PACKET;
  884. else /* drbd 8.3.8 onwards */
  885. peer = DRBD_MAX_BIO_SIZE;
  886. }
  887. new = min_t(int, local, peer);
  888. if (mdev->state.role == R_PRIMARY && new < now)
  889. dev_err(DEV, "ASSERT FAILED new < now; (%d < %d)\n", new, now);
  890. if (new != now)
  891. dev_info(DEV, "max BIO size = %u\n", new);
  892. drbd_setup_queue_param(mdev, new);
  893. }
  894. /* Starts the worker thread */
  895. static void conn_reconfig_start(struct drbd_tconn *tconn)
  896. {
  897. drbd_thread_start(&tconn->worker);
  898. conn_flush_workqueue(tconn);
  899. }
  900. /* if still unconfigured, stops worker again. */
  901. static void conn_reconfig_done(struct drbd_tconn *tconn)
  902. {
  903. spin_lock_irq(&tconn->req_lock);
  904. if (conn_all_vols_unconf(tconn))
  905. drbd_thread_stop_nowait(&tconn->worker);
  906. spin_unlock_irq(&tconn->req_lock);
  907. }
  908. /* Make sure IO is suspended before calling this function(). */
  909. static void drbd_suspend_al(struct drbd_conf *mdev)
  910. {
  911. int s = 0;
  912. if (!lc_try_lock(mdev->act_log)) {
  913. dev_warn(DEV, "Failed to lock al in drbd_suspend_al()\n");
  914. return;
  915. }
  916. drbd_al_shrink(mdev);
  917. spin_lock_irq(&mdev->tconn->req_lock);
  918. if (mdev->state.conn < C_CONNECTED)
  919. s = !test_and_set_bit(AL_SUSPENDED, &mdev->flags);
  920. spin_unlock_irq(&mdev->tconn->req_lock);
  921. lc_unlock(mdev->act_log);
  922. if (s)
  923. dev_info(DEV, "Suspended AL updates\n");
  924. }
  925. static bool should_set_defaults(struct genl_info *info)
  926. {
  927. unsigned flags = ((struct drbd_genlmsghdr*)info->userhdr)->flags;
  928. return 0 != (flags & DRBD_GENL_F_SET_DEFAULTS);
  929. }
  930. /* Maybe we should we generate these functions
  931. * from the drbd_genl.h magic as well?
  932. * That way we would not "accidentally forget" to add defaults here. */
  933. #define RESET_ARRAY_FIELD(field) do { \
  934. memset(field, 0, sizeof(field)); \
  935. field ## _len = 0; \
  936. } while (0)
  937. void drbd_set_res_opts_default(struct res_opts *r)
  938. {
  939. RESET_ARRAY_FIELD(r->cpu_mask);
  940. r->on_no_data = DRBD_ON_NO_DATA_DEF;
  941. }
  942. static void drbd_set_net_conf_defaults(struct net_conf *nc)
  943. {
  944. /* Do NOT (re)set those fields marked as GENLA_F_INVARIANT
  945. * in drbd_genl.h, they can only be change with disconnect/reconnect */
  946. RESET_ARRAY_FIELD(nc->shared_secret);
  947. RESET_ARRAY_FIELD(nc->cram_hmac_alg);
  948. RESET_ARRAY_FIELD(nc->integrity_alg);
  949. RESET_ARRAY_FIELD(nc->verify_alg);
  950. RESET_ARRAY_FIELD(nc->csums_alg);
  951. #undef RESET_ARRAY_FIELD
  952. nc->wire_protocol = DRBD_PROTOCOL_DEF;
  953. nc->try_connect_int = DRBD_CONNECT_INT_DEF;
  954. nc->timeout = DRBD_TIMEOUT_DEF;
  955. nc->ping_int = DRBD_PING_INT_DEF;
  956. nc->ping_timeo = DRBD_PING_TIMEO_DEF;
  957. nc->sndbuf_size = DRBD_SNDBUF_SIZE_DEF;
  958. nc->rcvbuf_size = DRBD_RCVBUF_SIZE_DEF;
  959. nc->ko_count = DRBD_KO_COUNT_DEF;
  960. nc->max_buffers = DRBD_MAX_BUFFERS_DEF;
  961. nc->max_epoch_size = DRBD_MAX_EPOCH_SIZE_DEF;
  962. nc->unplug_watermark = DRBD_UNPLUG_WATERMARK_DEF;
  963. nc->after_sb_0p = DRBD_AFTER_SB_0P_DEF;
  964. nc->after_sb_1p = DRBD_AFTER_SB_1P_DEF;
  965. nc->after_sb_2p = DRBD_AFTER_SB_2P_DEF;
  966. nc->rr_conflict = DRBD_RR_CONFLICT_DEF;
  967. nc->on_congestion = DRBD_ON_CONGESTION_DEF;
  968. nc->cong_fill = DRBD_CONG_FILL_DEF;
  969. nc->cong_extents = DRBD_CONG_EXTENTS_DEF;
  970. nc->two_primaries = 0;
  971. nc->no_cork = 0;
  972. nc->always_asbp = 0;
  973. nc->use_rle = 0;
  974. }
  975. static void drbd_set_disk_conf_defaults(struct disk_conf *dc)
  976. {
  977. /* Do NOT (re)set those fields marked as GENLA_F_INVARIANT
  978. * in drbd_genl.h, they can only be change with detach/reattach */
  979. dc->on_io_error = DRBD_ON_IO_ERROR_DEF;
  980. dc->fencing = DRBD_FENCING_DEF;
  981. dc->resync_rate = DRBD_RATE_DEF;
  982. dc->resync_after = DRBD_AFTER_DEF;
  983. dc->al_extents = DRBD_AL_EXTENTS_DEF;
  984. dc->c_plan_ahead = DRBD_C_PLAN_AHEAD_DEF;
  985. dc->c_delay_target = DRBD_C_DELAY_TARGET_DEF;
  986. dc->c_fill_target = DRBD_C_FILL_TARGET_DEF;
  987. dc->c_max_rate = DRBD_C_MAX_RATE_DEF;
  988. dc->c_min_rate = DRBD_C_MIN_RATE_DEF;
  989. dc->no_disk_barrier = 0;
  990. dc->no_disk_flush = 0;
  991. dc->no_disk_drain = 0;
  992. dc->no_md_flush = 0;
  993. }
  994. int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)
  995. {
  996. enum drbd_ret_code retcode;
  997. struct drbd_conf *mdev;
  998. struct disk_conf *new_disk_conf;
  999. int err, fifo_size;
  1000. int *rs_plan_s = NULL;
  1001. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  1002. if (!adm_ctx.reply_skb)
  1003. return retcode;
  1004. if (retcode != NO_ERROR)
  1005. goto out;
  1006. mdev = adm_ctx.mdev;
  1007. /* we also need a disk
  1008. * to change the options on */
  1009. if (!get_ldev(mdev)) {
  1010. retcode = ERR_NO_DISK;
  1011. goto out;
  1012. }
  1013. /* FIXME freeze IO, cluster wide.
  1014. *
  1015. * We should make sure no-one uses
  1016. * some half-updated struct when we
  1017. * assign it later. */
  1018. new_disk_conf = kmalloc(sizeof(*new_disk_conf), GFP_KERNEL);
  1019. if (!new_disk_conf) {
  1020. retcode = ERR_NOMEM;
  1021. goto fail;
  1022. }
  1023. memcpy(new_disk_conf, &mdev->ldev->dc, sizeof(*new_disk_conf));
  1024. if (should_set_defaults(info))
  1025. drbd_set_disk_conf_defaults(new_disk_conf);
  1026. err = disk_conf_from_attrs_for_change(new_disk_conf, info);
  1027. if (err) {
  1028. retcode = ERR_MANDATORY_TAG;
  1029. drbd_msg_put_info(from_attrs_err_to_txt(err));
  1030. }
  1031. if (!expect(new_disk_conf->resync_rate >= 1))
  1032. new_disk_conf->resync_rate = 1;
  1033. /* clip to allowed range */
  1034. if (!expect(new_disk_conf->al_extents >= DRBD_AL_EXTENTS_MIN))
  1035. new_disk_conf->al_extents = DRBD_AL_EXTENTS_MIN;
  1036. if (!expect(new_disk_conf->al_extents <= DRBD_AL_EXTENTS_MAX))
  1037. new_disk_conf->al_extents = DRBD_AL_EXTENTS_MAX;
  1038. /* most sanity checks done, try to assign the new sync-after
  1039. * dependency. need to hold the global lock in there,
  1040. * to avoid a race in the dependency loop check. */
  1041. retcode = drbd_alter_sa(mdev, new_disk_conf->resync_after);
  1042. if (retcode != NO_ERROR)
  1043. goto fail;
  1044. fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ;
  1045. if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
  1046. rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
  1047. if (!rs_plan_s) {
  1048. dev_err(DEV, "kmalloc of fifo_buffer failed");
  1049. retcode = ERR_NOMEM;
  1050. goto fail;
  1051. }
  1052. }
  1053. if (fifo_size != mdev->rs_plan_s.size) {
  1054. kfree(mdev->rs_plan_s.values);
  1055. mdev->rs_plan_s.values = rs_plan_s;
  1056. mdev->rs_plan_s.size = fifo_size;
  1057. mdev->rs_planed = 0;
  1058. rs_plan_s = NULL;
  1059. }
  1060. wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
  1061. drbd_al_shrink(mdev);
  1062. err = drbd_check_al_size(mdev, new_disk_conf);
  1063. lc_unlock(mdev->act_log);
  1064. wake_up(&mdev->al_wait);
  1065. if (err) {
  1066. retcode = ERR_NOMEM;
  1067. goto fail;
  1068. }
  1069. /* FIXME
  1070. * To avoid someone looking at a half-updated struct, we probably
  1071. * should have a rw-semaphor on net_conf and disk_conf.
  1072. */
  1073. mdev->ldev->dc = *new_disk_conf;
  1074. drbd_md_sync(mdev);
  1075. if (mdev->state.conn >= C_CONNECTED)
  1076. drbd_send_sync_param(mdev);
  1077. fail:
  1078. put_ldev(mdev);
  1079. kfree(new_disk_conf);
  1080. kfree(rs_plan_s);
  1081. out:
  1082. drbd_adm_finish(info, retcode);
  1083. return 0;
  1084. }
  1085. int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
  1086. {
  1087. struct drbd_conf *mdev;
  1088. int err;
  1089. enum drbd_ret_code retcode;
  1090. enum determine_dev_size dd;
  1091. sector_t max_possible_sectors;
  1092. sector_t min_md_device_sectors;
  1093. struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
  1094. struct block_device *bdev;
  1095. struct lru_cache *resync_lru = NULL;
  1096. union drbd_state ns, os;
  1097. enum drbd_state_rv rv;
  1098. struct net_conf *nc;
  1099. int cp_discovered = 0;
  1100. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  1101. if (!adm_ctx.reply_skb)
  1102. return retcode;
  1103. if (retcode != NO_ERROR)
  1104. goto finish;
  1105. mdev = adm_ctx.mdev;
  1106. conn_reconfig_start(mdev->tconn);
  1107. /* if you want to reconfigure, please tear down first */
  1108. if (mdev->state.disk > D_DISKLESS) {
  1109. retcode = ERR_DISK_CONFIGURED;
  1110. goto fail;
  1111. }
  1112. /* It may just now have detached because of IO error. Make sure
  1113. * drbd_ldev_destroy is done already, we may end up here very fast,
  1114. * e.g. if someone calls attach from the on-io-error handler,
  1115. * to realize a "hot spare" feature (not that I'd recommend that) */
  1116. wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
  1117. /* allocation not in the IO path, drbdsetup context */
  1118. nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
  1119. if (!nbc) {
  1120. retcode = ERR_NOMEM;
  1121. goto fail;
  1122. }
  1123. drbd_set_disk_conf_defaults(&nbc->dc);
  1124. err = disk_conf_from_attrs(&nbc->dc, info);
  1125. if (err) {
  1126. retcode = ERR_MANDATORY_TAG;
  1127. drbd_msg_put_info(from_attrs_err_to_txt(err));
  1128. goto fail;
  1129. }
  1130. if ((int)nbc->dc.meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
  1131. retcode = ERR_MD_IDX_INVALID;
  1132. goto fail;
  1133. }
  1134. rcu_read_lock();
  1135. nc = rcu_dereference(mdev->tconn->net_conf);
  1136. if (nc) {
  1137. if (nbc->dc.fencing == FP_STONITH && nc->wire_protocol == DRBD_PROT_A) {
  1138. rcu_read_unlock();
  1139. retcode = ERR_STONITH_AND_PROT_A;
  1140. goto fail;
  1141. }
  1142. }
  1143. rcu_read_unlock();
  1144. bdev = blkdev_get_by_path(nbc->dc.backing_dev,
  1145. FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
  1146. if (IS_ERR(bdev)) {
  1147. dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.backing_dev,
  1148. PTR_ERR(bdev));
  1149. retcode = ERR_OPEN_DISK;
  1150. goto fail;
  1151. }
  1152. nbc->backing_bdev = bdev;
  1153. /*
  1154. * meta_dev_idx >= 0: external fixed size, possibly multiple
  1155. * drbd sharing one meta device. TODO in that case, paranoia
  1156. * check that [md_bdev, meta_dev_idx] is not yet used by some
  1157. * other drbd minor! (if you use drbd.conf + drbdadm, that
  1158. * should check it for you already; but if you don't, or
  1159. * someone fooled it, we need to double check here)
  1160. */
  1161. bdev = blkdev_get_by_path(nbc->dc.meta_dev,
  1162. FMODE_READ | FMODE_WRITE | FMODE_EXCL,
  1163. ((int)nbc->dc.meta_dev_idx < 0) ?
  1164. (void *)mdev : (void *)drbd_m_holder);
  1165. if (IS_ERR(bdev)) {
  1166. dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.meta_dev,
  1167. PTR_ERR(bdev));
  1168. retcode = ERR_OPEN_MD_DISK;
  1169. goto fail;
  1170. }
  1171. nbc->md_bdev = bdev;
  1172. if ((nbc->backing_bdev == nbc->md_bdev) !=
  1173. (nbc->dc.meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
  1174. nbc->dc.meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
  1175. retcode = ERR_MD_IDX_INVALID;
  1176. goto fail;
  1177. }
  1178. resync_lru = lc_create("resync", drbd_bm_ext_cache,
  1179. 1, 61, sizeof(struct bm_extent),
  1180. offsetof(struct bm_extent, lce));
  1181. if (!resync_lru) {
  1182. retcode = ERR_NOMEM;
  1183. goto fail;
  1184. }
  1185. /* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */
  1186. drbd_md_set_sector_offsets(mdev, nbc);
  1187. if (drbd_get_max_capacity(nbc) < nbc->dc.disk_size) {
  1188. dev_err(DEV, "max capacity %llu smaller than disk size %llu\n",
  1189. (unsigned long long) drbd_get_max_capacity(nbc),
  1190. (unsigned long long) nbc->dc.disk_size);
  1191. retcode = ERR_DISK_TO_SMALL;
  1192. goto fail;
  1193. }
  1194. if ((int)nbc->dc.meta_dev_idx < 0) {
  1195. max_possible_sectors = DRBD_MAX_SECTORS_FLEX;
  1196. /* at least one MB, otherwise it does not make sense */
  1197. min_md_device_sectors = (2<<10);
  1198. } else {
  1199. max_possible_sectors = DRBD_MAX_SECTORS;
  1200. min_md_device_sectors = MD_RESERVED_SECT * (nbc->dc.meta_dev_idx + 1);
  1201. }
  1202. if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) {
  1203. retcode = ERR_MD_DISK_TO_SMALL;
  1204. dev_warn(DEV, "refusing attach: md-device too small, "
  1205. "at least %llu sectors needed for this meta-disk type\n",
  1206. (unsigned long long) min_md_device_sectors);
  1207. goto fail;
  1208. }
  1209. /* Make sure the new disk is big enough
  1210. * (we may currently be R_PRIMARY with no local disk...) */
  1211. if (drbd_get_max_capacity(nbc) <
  1212. drbd_get_capacity(mdev->this_bdev)) {
  1213. retcode = ERR_DISK_TO_SMALL;
  1214. goto fail;
  1215. }
  1216. nbc->known_size = drbd_get_capacity(nbc->backing_bdev);
  1217. if (nbc->known_size > max_possible_sectors) {
  1218. dev_warn(DEV, "==> truncating very big lower level device "
  1219. "to currently maximum possible %llu sectors <==\n",
  1220. (unsigned long long) max_possible_sectors);
  1221. if ((int)nbc->dc.meta_dev_idx >= 0)
  1222. dev_warn(DEV, "==>> using internal or flexible "
  1223. "meta data may help <<==\n");
  1224. }
  1225. drbd_suspend_io(mdev);
  1226. /* also wait for the last barrier ack. */
  1227. wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || drbd_suspended(mdev));
  1228. /* and for any other previously queued work */
  1229. drbd_flush_workqueue(mdev);
  1230. rv = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE);
  1231. retcode = rv; /* FIXME: Type mismatch. */
  1232. drbd_resume_io(mdev);
  1233. if (rv < SS_SUCCESS)
  1234. goto fail;
  1235. if (!get_ldev_if_state(mdev, D_ATTACHING))
  1236. goto force_diskless;
  1237. drbd_md_set_sector_offsets(mdev, nbc);
  1238. if (!mdev->bitmap) {
  1239. if (drbd_bm_init(mdev)) {
  1240. retcode = ERR_NOMEM;
  1241. goto force_diskless_dec;
  1242. }
  1243. }
  1244. retcode = drbd_md_read(mdev, nbc);
  1245. if (retcode != NO_ERROR)
  1246. goto force_diskless_dec;
  1247. if (mdev->state.conn < C_CONNECTED &&
  1248. mdev->state.role == R_PRIMARY &&
  1249. (mdev->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
  1250. dev_err(DEV, "Can only attach to data with current UUID=%016llX\n",
  1251. (unsigned long long)mdev->ed_uuid);
  1252. retcode = ERR_DATA_NOT_CURRENT;
  1253. goto force_diskless_dec;
  1254. }
  1255. /* Since we are diskless, fix the activity log first... */
  1256. if (drbd_check_al_size(mdev, &nbc->dc)) {
  1257. retcode = ERR_NOMEM;
  1258. goto force_diskless_dec;
  1259. }
  1260. /* Prevent shrinking of consistent devices ! */
  1261. if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
  1262. drbd_new_dev_size(mdev, nbc, 0) < nbc->md.la_size_sect) {
  1263. dev_warn(DEV, "refusing to truncate a consistent device\n");
  1264. retcode = ERR_DISK_TO_SMALL;
  1265. goto force_diskless_dec;
  1266. }
  1267. if (!drbd_al_read_log(mdev, nbc)) {
  1268. retcode = ERR_IO_MD_DISK;
  1269. goto force_diskless_dec;
  1270. }
  1271. /* Reset the "barriers don't work" bits here, then force meta data to
  1272. * be written, to ensure we determine if barriers are supported. */
  1273. if (nbc->dc.no_md_flush)
  1274. set_bit(MD_NO_FUA, &mdev->flags);
  1275. else
  1276. clear_bit(MD_NO_FUA, &mdev->flags);
  1277. /* Point of no return reached.
  1278. * Devices and memory are no longer released by error cleanup below.
  1279. * now mdev takes over responsibility, and the state engine should
  1280. * clean it up somewhere. */
  1281. D_ASSERT(mdev->ldev == NULL);
  1282. mdev->ldev = nbc;
  1283. mdev->resync = resync_lru;
  1284. nbc = NULL;
  1285. resync_lru = NULL;
  1286. mdev->write_ordering = WO_bdev_flush;
  1287. drbd_bump_write_ordering(mdev, WO_bdev_flush);
  1288. if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
  1289. set_bit(CRASHED_PRIMARY, &mdev->flags);
  1290. else
  1291. clear_bit(CRASHED_PRIMARY, &mdev->flags);
  1292. if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
  1293. !(mdev->state.role == R_PRIMARY && mdev->tconn->susp_nod)) {
  1294. set_bit(CRASHED_PRIMARY, &mdev->flags);
  1295. cp_discovered = 1;
  1296. }
  1297. mdev->send_cnt = 0;
  1298. mdev->recv_cnt = 0;
  1299. mdev->read_cnt = 0;
  1300. mdev->writ_cnt = 0;
  1301. drbd_reconsider_max_bio_size(mdev);
  1302. /* If I am currently not R_PRIMARY,
  1303. * but meta data primary indicator is set,
  1304. * I just now recover from a hard crash,
  1305. * and have been R_PRIMARY before that crash.
  1306. *
  1307. * Now, if I had no connection before that crash
  1308. * (have been degraded R_PRIMARY), chances are that
  1309. * I won't find my peer now either.
  1310. *
  1311. * In that case, and _only_ in that case,
  1312. * we use the degr-wfc-timeout instead of the default,
  1313. * so we can automatically recover from a crash of a
  1314. * degraded but active "cluster" after a certain timeout.
  1315. */
  1316. clear_bit(USE_DEGR_WFC_T, &mdev->flags);
  1317. if (mdev->state.role != R_PRIMARY &&
  1318. drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
  1319. !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND))
  1320. set_bit(USE_DEGR_WFC_T, &mdev->flags);
  1321. dd = drbd_determine_dev_size(mdev, 0);
  1322. if (dd == dev_size_error) {
  1323. retcode = ERR_NOMEM_BITMAP;
  1324. goto force_diskless_dec;
  1325. } else if (dd == grew)
  1326. set_bit(RESYNC_AFTER_NEG, &mdev->flags);
  1327. if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
  1328. dev_info(DEV, "Assuming that all blocks are out of sync "
  1329. "(aka FullSync)\n");
  1330. if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
  1331. "set_n_write from attaching", BM_LOCKED_MASK)) {
  1332. retcode = ERR_IO_MD_DISK;
  1333. goto force_diskless_dec;
  1334. }
  1335. } else {
  1336. if (drbd_bitmap_io(mdev, &drbd_bm_read,
  1337. "read from attaching", BM_LOCKED_MASK)) {
  1338. retcode = ERR_IO_MD_DISK;
  1339. goto force_diskless_dec;
  1340. }
  1341. }
  1342. if (cp_discovered) {
  1343. drbd_al_apply_to_bm(mdev);
  1344. if (drbd_bitmap_io(mdev, &drbd_bm_write,
  1345. "crashed primary apply AL", BM_LOCKED_MASK)) {
  1346. retcode = ERR_IO_MD_DISK;
  1347. goto force_diskless_dec;
  1348. }
  1349. }
  1350. if (_drbd_bm_total_weight(mdev) == drbd_bm_bits(mdev))
  1351. drbd_suspend_al(mdev); /* IO is still suspended here... */
  1352. spin_lock_irq(&mdev->tconn->req_lock);
  1353. os = drbd_read_state(mdev);
  1354. ns = os;
  1355. /* If MDF_CONSISTENT is not set go into inconsistent state,
  1356. otherwise investigate MDF_WasUpToDate...
  1357. If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state,
  1358. otherwise into D_CONSISTENT state.
  1359. */
  1360. if (drbd_md_test_flag(mdev->ldev, MDF_CONSISTENT)) {
  1361. if (drbd_md_test_flag(mdev->ldev, MDF_WAS_UP_TO_DATE))
  1362. ns.disk = D_CONSISTENT;
  1363. else
  1364. ns.disk = D_OUTDATED;
  1365. } else {
  1366. ns.disk = D_INCONSISTENT;
  1367. }
  1368. if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED))
  1369. ns.pdsk = D_OUTDATED;
  1370. if ( ns.disk == D_CONSISTENT &&
  1371. (ns.pdsk == D_OUTDATED || mdev->ldev->dc.fencing == FP_DONT_CARE))
  1372. ns.disk = D_UP_TO_DATE;
  1373. /* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND,
  1374. MDF_CONSISTENT and MDF_WAS_UP_TO_DATE must happen before
  1375. this point, because drbd_request_state() modifies these
  1376. flags. */
  1377. /* In case we are C_CONNECTED postpone any decision on the new disk
  1378. state after the negotiation phase. */
  1379. if (mdev->state.conn == C_CONNECTED) {
  1380. mdev->new_state_tmp.i = ns.i;
  1381. ns.i = os.i;
  1382. ns.disk = D_NEGOTIATING;
  1383. /* We expect to receive up-to-date UUIDs soon.
  1384. To avoid a race in receive_state, free p_uuid while
  1385. holding req_lock. I.e. atomic with the state change */
  1386. kfree(mdev->p_uuid);
  1387. mdev->p_uuid = NULL;
  1388. }
  1389. rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
  1390. spin_unlock_irq(&mdev->tconn->req_lock);
  1391. if (rv < SS_SUCCESS)
  1392. goto force_diskless_dec;
  1393. if (mdev->state.role == R_PRIMARY)
  1394. mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1;
  1395. else
  1396. mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
  1397. drbd_md_mark_dirty(mdev);
  1398. drbd_md_sync(mdev);
  1399. kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
  1400. put_ldev(mdev);
  1401. conn_reconfig_done(mdev->tconn);
  1402. drbd_adm_finish(info, retcode);
  1403. return 0;
  1404. force_diskless_dec:
  1405. put_ldev(mdev);
  1406. force_diskless:
  1407. drbd_force_state(mdev, NS(disk, D_FAILED));
  1408. drbd_md_sync(mdev);
  1409. fail:
  1410. conn_reconfig_done(mdev->tconn);
  1411. if (nbc) {
  1412. if (nbc->backing_bdev)
  1413. blkdev_put(nbc->backing_bdev,
  1414. FMODE_READ | FMODE_WRITE | FMODE_EXCL);
  1415. if (nbc->md_bdev)
  1416. blkdev_put(nbc->md_bdev,
  1417. FMODE_READ | FMODE_WRITE | FMODE_EXCL);
  1418. kfree(nbc);
  1419. }
  1420. lc_destroy(resync_lru);
  1421. finish:
  1422. drbd_adm_finish(info, retcode);
  1423. return 0;
  1424. }
  1425. static int adm_detach(struct drbd_conf *mdev)
  1426. {
  1427. enum drbd_state_rv retcode;
  1428. drbd_suspend_io(mdev); /* so no-one is stuck in drbd_al_begin_io */
  1429. retcode = drbd_request_state(mdev, NS(disk, D_DISKLESS));
  1430. wait_event(mdev->misc_wait,
  1431. mdev->state.disk != D_DISKLESS ||
  1432. !atomic_read(&mdev->local_cnt));
  1433. drbd_resume_io(mdev);
  1434. return retcode;
  1435. }
  1436. /* Detaching the disk is a process in multiple stages. First we need to lock
  1437. * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
  1438. * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
  1439. * internal references as well.
  1440. * Only then we have finally detached. */
  1441. int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info)
  1442. {
  1443. enum drbd_ret_code retcode;
  1444. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  1445. if (!adm_ctx.reply_skb)
  1446. return retcode;
  1447. if (retcode != NO_ERROR)
  1448. goto out;
  1449. retcode = adm_detach(adm_ctx.mdev);
  1450. out:
  1451. drbd_adm_finish(info, retcode);
  1452. return 0;
  1453. }
  1454. static bool conn_resync_running(struct drbd_tconn *tconn)
  1455. {
  1456. struct drbd_conf *mdev;
  1457. bool rv = false;
  1458. int vnr;
  1459. rcu_read_lock();
  1460. idr_for_each_entry(&tconn->volumes, mdev, vnr) {
  1461. if (mdev->state.conn == C_SYNC_SOURCE ||
  1462. mdev->state.conn == C_SYNC_TARGET ||
  1463. mdev->state.conn == C_PAUSED_SYNC_S ||
  1464. mdev->state.conn == C_PAUSED_SYNC_T) {
  1465. rv = true;
  1466. break;
  1467. }
  1468. }
  1469. rcu_read_unlock();
  1470. return rv;
  1471. }
  1472. static bool conn_ov_running(struct drbd_tconn *tconn)
  1473. {
  1474. struct drbd_conf *mdev;
  1475. bool rv = false;
  1476. int vnr;
  1477. rcu_read_lock();
  1478. idr_for_each_entry(&tconn->volumes, mdev, vnr) {
  1479. if (mdev->state.conn == C_VERIFY_S ||
  1480. mdev->state.conn == C_VERIFY_T) {
  1481. rv = true;
  1482. break;
  1483. }
  1484. }
  1485. rcu_read_unlock();
  1486. return rv;
  1487. }
  1488. static enum drbd_ret_code
  1489. _check_net_options(struct drbd_tconn *tconn, struct net_conf *old_conf, struct net_conf *new_conf)
  1490. {
  1491. struct drbd_conf *mdev;
  1492. int i;
  1493. if (old_conf && tconn->agreed_pro_version < 100 &&
  1494. tconn->cstate == C_WF_REPORT_PARAMS &&
  1495. new_conf->wire_protocol != old_conf->wire_protocol)
  1496. return ERR_NEED_APV_100;
  1497. if (new_conf->two_primaries &&
  1498. (new_conf->wire_protocol != DRBD_PROT_C))
  1499. return ERR_NOT_PROTO_C;
  1500. idr_for_each_entry(&tconn->volumes, mdev, i) {
  1501. if (get_ldev(mdev)) {
  1502. enum drbd_fencing_p fp = mdev->ldev->dc.fencing;
  1503. put_ldev(mdev);
  1504. if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH)
  1505. return ERR_STONITH_AND_PROT_A;
  1506. }
  1507. if (mdev->state.role == R_PRIMARY && new_conf->want_lose)
  1508. return ERR_DISCARD;
  1509. }
  1510. if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A)
  1511. return ERR_CONG_NOT_PROTO_A;
  1512. return NO_ERROR;
  1513. }
  1514. static enum drbd_ret_code
  1515. check_net_options(struct drbd_tconn *tconn, struct net_conf *new_conf)
  1516. {
  1517. static enum drbd_ret_code rv;
  1518. struct drbd_conf *mdev;
  1519. int i;
  1520. rcu_read_lock();
  1521. rv = _check_net_options(tconn, rcu_dereference(tconn->net_conf), new_conf);
  1522. rcu_read_unlock();
  1523. /* tconn->volumes protected by genl_lock() here */
  1524. idr_for_each_entry(&tconn->volumes, mdev, i) {
  1525. if (!mdev->bitmap) {
  1526. if(drbd_bm_init(mdev))
  1527. return ERR_NOMEM;
  1528. }
  1529. }
  1530. return rv;
  1531. }
  1532. struct crypto {
  1533. struct crypto_hash *verify_tfm;
  1534. struct crypto_hash *csums_tfm;
  1535. struct crypto_hash *cram_hmac_tfm;
  1536. struct crypto_hash *integrity_w_tfm;
  1537. struct crypto_hash *integrity_r_tfm;
  1538. void *int_dig_in;
  1539. void *int_dig_vv;
  1540. };
  1541. static int
  1542. alloc_tfm(struct crypto_hash **tfm, char *tfm_name, int err_alg, int err_nd)
  1543. {
  1544. if (!tfm_name[0])
  1545. return NO_ERROR;
  1546. *tfm = crypto_alloc_hash(tfm_name, 0, CRYPTO_ALG_ASYNC);
  1547. if (IS_ERR(*tfm)) {
  1548. *tfm = NULL;
  1549. return err_alg;
  1550. }
  1551. if (!drbd_crypto_is_hash(crypto_hash_tfm(*tfm)))
  1552. return err_nd;
  1553. return NO_ERROR;
  1554. }
  1555. static enum drbd_ret_code
  1556. alloc_crypto(struct crypto *crypto, struct net_conf *new_conf)
  1557. {
  1558. char hmac_name[CRYPTO_MAX_ALG_NAME];
  1559. enum drbd_ret_code rv;
  1560. int hash_size;
  1561. rv = alloc_tfm(&crypto->csums_tfm, new_conf->csums_alg,
  1562. ERR_CSUMS_ALG, ERR_CSUMS_ALG_ND);
  1563. if (rv != NO_ERROR)
  1564. return rv;
  1565. rv = alloc_tfm(&crypto->verify_tfm, new_conf->verify_alg,
  1566. ERR_VERIFY_ALG, ERR_VERIFY_ALG_ND);
  1567. if (rv != NO_ERROR)
  1568. return rv;
  1569. rv = alloc_tfm(&crypto->integrity_w_tfm, new_conf->integrity_alg,
  1570. ERR_INTEGRITY_ALG, ERR_INTEGRITY_ALG_ND);
  1571. if (rv != NO_ERROR)
  1572. return rv;
  1573. rv = alloc_tfm(&crypto->integrity_r_tfm, new_conf->integrity_alg,
  1574. ERR_INTEGRITY_ALG, ERR_INTEGRITY_ALG_ND);
  1575. if (rv != NO_ERROR)
  1576. return rv;
  1577. if (new_conf->cram_hmac_alg[0] != 0) {
  1578. snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
  1579. new_conf->cram_hmac_alg);
  1580. rv = alloc_tfm(&crypto->cram_hmac_tfm, hmac_name,
  1581. ERR_AUTH_ALG, ERR_AUTH_ALG_ND);
  1582. }
  1583. if (crypto->integrity_w_tfm) {
  1584. hash_size = crypto_hash_digestsize(crypto->integrity_w_tfm);
  1585. crypto->int_dig_in = kmalloc(hash_size, GFP_KERNEL);
  1586. if (!crypto->int_dig_in)
  1587. return ERR_NOMEM;
  1588. crypto->int_dig_vv = kmalloc(hash_size, GFP_KERNEL);
  1589. if (!crypto->int_dig_vv)
  1590. return ERR_NOMEM;
  1591. }
  1592. return rv;
  1593. }
  1594. static void free_crypto(struct crypto *crypto)
  1595. {
  1596. kfree(crypto->int_dig_in);
  1597. kfree(crypto->int_dig_vv);
  1598. crypto_free_hash(crypto->cram_hmac_tfm);
  1599. crypto_free_hash(crypto->integrity_w_tfm);
  1600. crypto_free_hash(crypto->integrity_r_tfm);
  1601. crypto_free_hash(crypto->csums_tfm);
  1602. crypto_free_hash(crypto->verify_tfm);
  1603. }
  1604. int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info)
  1605. {
  1606. enum drbd_ret_code retcode;
  1607. struct drbd_tconn *tconn;
  1608. struct net_conf *old_conf, *new_conf = NULL;
  1609. int err;
  1610. int ovr; /* online verify running */
  1611. int rsr; /* re-sync running */
  1612. struct crypto crypto = { };
  1613. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
  1614. if (!adm_ctx.reply_skb)
  1615. return retcode;
  1616. if (retcode != NO_ERROR)
  1617. goto out;
  1618. tconn = adm_ctx.tconn;
  1619. new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
  1620. if (!new_conf) {
  1621. retcode = ERR_NOMEM;
  1622. goto out;
  1623. }
  1624. conn_reconfig_start(tconn);
  1625. mutex_lock(&tconn->net_conf_update);
  1626. old_conf = tconn->net_conf;
  1627. if (!old_conf) {
  1628. drbd_msg_put_info("net conf missing, try connect");
  1629. retcode = ERR_INVALID_REQUEST;
  1630. goto fail;
  1631. }
  1632. *new_conf = *old_conf;
  1633. if (should_set_defaults(info))
  1634. drbd_set_net_conf_defaults(new_conf);
  1635. err = net_conf_from_attrs_for_change(new_conf, info);
  1636. if (err) {
  1637. retcode = ERR_MANDATORY_TAG;
  1638. drbd_msg_put_info(from_attrs_err_to_txt(err));
  1639. goto fail;
  1640. }
  1641. retcode = check_net_options(tconn, new_conf);
  1642. if (retcode != NO_ERROR)
  1643. goto fail;
  1644. /* re-sync running */
  1645. rsr = conn_resync_running(tconn);
  1646. if (rsr && strcmp(new_conf->csums_alg, old_conf->csums_alg)) {
  1647. retcode = ERR_CSUMS_RESYNC_RUNNING;
  1648. goto fail;
  1649. }
  1650. /* online verify running */
  1651. ovr = conn_ov_running(tconn);
  1652. if (ovr && strcmp(new_conf->verify_alg, old_conf->verify_alg)) {
  1653. retcode = ERR_VERIFY_RUNNING;
  1654. goto fail;
  1655. }
  1656. retcode = alloc_crypto(&crypto, new_conf);
  1657. if (retcode != NO_ERROR)
  1658. goto fail;
  1659. rcu_assign_pointer(tconn->net_conf, new_conf);
  1660. if (!rsr) {
  1661. crypto_free_hash(tconn->csums_tfm);
  1662. tconn->csums_tfm = crypto.csums_tfm;
  1663. crypto.csums_tfm = NULL;
  1664. }
  1665. if (!ovr) {
  1666. crypto_free_hash(tconn->verify_tfm);
  1667. tconn->verify_tfm = crypto.verify_tfm;
  1668. crypto.verify_tfm = NULL;
  1669. }
  1670. /* FIXME can not assign these so bluntly while we have ongoing IO */
  1671. kfree(tconn->int_dig_in);
  1672. tconn->int_dig_in = crypto.int_dig_in;
  1673. kfree(tconn->int_dig_vv);
  1674. tconn->int_dig_vv = crypto.int_dig_vv;
  1675. crypto_free_hash(tconn->integrity_w_tfm);
  1676. tconn->integrity_w_tfm = crypto.integrity_w_tfm;
  1677. crypto_free_hash(tconn->integrity_r_tfm);
  1678. tconn->integrity_r_tfm = crypto.integrity_r_tfm;
  1679. /* FIXME Changing cram_hmac while the connection is established is useless */
  1680. crypto_free_hash(tconn->cram_hmac_tfm);
  1681. tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
  1682. mutex_unlock(&tconn->net_conf_update);
  1683. synchronize_rcu();
  1684. kfree(old_conf);
  1685. if (tconn->cstate >= C_WF_REPORT_PARAMS)
  1686. drbd_send_sync_param(minor_to_mdev(conn_lowest_minor(tconn)));
  1687. goto done;
  1688. fail:
  1689. mutex_unlock(&tconn->net_conf_update);
  1690. free_crypto(&crypto);
  1691. kfree(new_conf);
  1692. done:
  1693. conn_reconfig_done(tconn);
  1694. out:
  1695. drbd_adm_finish(info, retcode);
  1696. return 0;
  1697. }
  1698. int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info)
  1699. {
  1700. struct drbd_conf *mdev;
  1701. struct net_conf *old_conf, *new_conf = NULL;
  1702. struct crypto crypto = { };
  1703. struct drbd_tconn *oconn;
  1704. struct drbd_tconn *tconn;
  1705. struct sockaddr *new_my_addr, *new_peer_addr, *taken_addr;
  1706. enum drbd_ret_code retcode;
  1707. int i;
  1708. int err;
  1709. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
  1710. if (!adm_ctx.reply_skb)
  1711. return retcode;
  1712. if (retcode != NO_ERROR)
  1713. goto out;
  1714. tconn = adm_ctx.tconn;
  1715. conn_reconfig_start(tconn);
  1716. if (tconn->cstate > C_STANDALONE) {
  1717. retcode = ERR_NET_CONFIGURED;
  1718. goto fail;
  1719. }
  1720. /* allocation not in the IO path, cqueue thread context */
  1721. new_conf = kzalloc(sizeof(*new_conf), GFP_KERNEL);
  1722. if (!new_conf) {
  1723. retcode = ERR_NOMEM;
  1724. goto fail;
  1725. }
  1726. drbd_set_net_conf_defaults(new_conf);
  1727. err = net_conf_from_attrs(new_conf, info);
  1728. if (err) {
  1729. retcode = ERR_MANDATORY_TAG;
  1730. drbd_msg_put_info(from_attrs_err_to_txt(err));
  1731. goto fail;
  1732. }
  1733. retcode = check_net_options(tconn, new_conf);
  1734. if (retcode != NO_ERROR)
  1735. goto fail;
  1736. retcode = NO_ERROR;
  1737. new_my_addr = (struct sockaddr *)&new_conf->my_addr;
  1738. new_peer_addr = (struct sockaddr *)&new_conf->peer_addr;
  1739. /* No need to take drbd_cfg_rwsem here. All reconfiguration is
  1740. * strictly serialized on genl_lock(). We are protected against
  1741. * concurrent reconfiguration/addition/deletion */
  1742. list_for_each_entry(oconn, &drbd_tconns, all_tconn) {
  1743. struct net_conf *nc;
  1744. if (oconn == tconn)
  1745. continue;
  1746. rcu_read_lock();
  1747. nc = rcu_dereference(oconn->net_conf);
  1748. if (nc) {
  1749. taken_addr = (struct sockaddr *)&nc->my_addr;
  1750. if (new_conf->my_addr_len == nc->my_addr_len &&
  1751. !memcmp(new_my_addr, taken_addr, new_conf->my_addr_len))
  1752. retcode = ERR_LOCAL_ADDR;
  1753. taken_addr = (struct sockaddr *)&nc->peer_addr;
  1754. if (new_conf->peer_addr_len == nc->peer_addr_len &&
  1755. !memcmp(new_peer_addr, taken_addr, new_conf->peer_addr_len))
  1756. retcode = ERR_PEER_ADDR;
  1757. }
  1758. rcu_read_unlock();
  1759. if (retcode != NO_ERROR)
  1760. goto fail;
  1761. }
  1762. retcode = alloc_crypto(&crypto, new_conf);
  1763. if (retcode != NO_ERROR)
  1764. goto fail;
  1765. ((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;
  1766. conn_flush_workqueue(tconn);
  1767. mutex_lock(&tconn->net_conf_update);
  1768. old_conf = tconn->net_conf;
  1769. if (old_conf) {
  1770. retcode = ERR_NET_CONFIGURED;
  1771. mutex_unlock(&tconn->net_conf_update);
  1772. goto fail;
  1773. }
  1774. rcu_assign_pointer(tconn->net_conf, new_conf);
  1775. conn_free_crypto(tconn);
  1776. tconn->int_dig_in = crypto.int_dig_in;
  1777. tconn->int_dig_vv = crypto.int_dig_vv;
  1778. tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
  1779. tconn->integrity_w_tfm = crypto.integrity_w_tfm;
  1780. tconn->integrity_r_tfm = crypto.integrity_r_tfm;
  1781. tconn->csums_tfm = crypto.csums_tfm;
  1782. tconn->verify_tfm = crypto.verify_tfm;
  1783. mutex_unlock(&tconn->net_conf_update);
  1784. rcu_read_lock();
  1785. idr_for_each_entry(&tconn->volumes, mdev, i) {
  1786. mdev->send_cnt = 0;
  1787. mdev->recv_cnt = 0;
  1788. }
  1789. rcu_read_unlock();
  1790. retcode = conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
  1791. conn_reconfig_done(tconn);
  1792. drbd_adm_finish(info, retcode);
  1793. return 0;
  1794. fail:
  1795. free_crypto(&crypto);
  1796. kfree(new_conf);
  1797. conn_reconfig_done(tconn);
  1798. out:
  1799. drbd_adm_finish(info, retcode);
  1800. return 0;
  1801. }
  1802. static enum drbd_state_rv conn_try_disconnect(struct drbd_tconn *tconn, bool force)
  1803. {
  1804. enum drbd_state_rv rv;
  1805. if (force) {
  1806. spin_lock_irq(&tconn->req_lock);
  1807. rv = _conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  1808. spin_unlock_irq(&tconn->req_lock);
  1809. return rv;
  1810. }
  1811. rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING), 0);
  1812. switch (rv) {
  1813. case SS_NOTHING_TO_DO:
  1814. case SS_ALREADY_STANDALONE:
  1815. return SS_SUCCESS;
  1816. case SS_PRIMARY_NOP:
  1817. /* Our state checking code wants to see the peer outdated. */
  1818. rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
  1819. pdsk, D_OUTDATED), CS_VERBOSE);
  1820. break;
  1821. case SS_CW_FAILED_BY_PEER:
  1822. /* The peer probably wants to see us outdated. */
  1823. rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
  1824. disk, D_OUTDATED), 0);
  1825. if (rv == SS_IS_DISKLESS || rv == SS_LOWER_THAN_OUTDATED) {
  1826. conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  1827. rv = SS_SUCCESS;
  1828. }
  1829. break;
  1830. default:;
  1831. /* no special handling necessary */
  1832. }
  1833. return rv;
  1834. }
  1835. int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info)
  1836. {
  1837. struct disconnect_parms parms;
  1838. struct drbd_tconn *tconn;
  1839. enum drbd_state_rv rv;
  1840. enum drbd_ret_code retcode;
  1841. int err;
  1842. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
  1843. if (!adm_ctx.reply_skb)
  1844. return retcode;
  1845. if (retcode != NO_ERROR)
  1846. goto fail;
  1847. tconn = adm_ctx.tconn;
  1848. memset(&parms, 0, sizeof(parms));
  1849. if (info->attrs[DRBD_NLA_DISCONNECT_PARMS]) {
  1850. err = disconnect_parms_from_attrs(&parms, info);
  1851. if (err) {
  1852. retcode = ERR_MANDATORY_TAG;
  1853. drbd_msg_put_info(from_attrs_err_to_txt(err));
  1854. goto fail;
  1855. }
  1856. }
  1857. rv = conn_try_disconnect(tconn, parms.force_disconnect);
  1858. if (rv < SS_SUCCESS)
  1859. goto fail;
  1860. /* No one else can reconfigure the network while I am here.
  1861. * The state handling only uses drbd_thread_stop_nowait(),
  1862. * we want to really wait here until the receiver is no more. */
  1863. drbd_thread_stop(&tconn->receiver);
  1864. if (wait_event_interruptible(tconn->ping_wait,
  1865. tconn->cstate == C_STANDALONE)) {
  1866. retcode = ERR_INTR;
  1867. goto fail;
  1868. }
  1869. retcode = NO_ERROR;
  1870. fail:
  1871. drbd_adm_finish(info, retcode);
  1872. return 0;
  1873. }
  1874. void resync_after_online_grow(struct drbd_conf *mdev)
  1875. {
  1876. int iass; /* I am sync source */
  1877. dev_info(DEV, "Resync of new storage after online grow\n");
  1878. if (mdev->state.role != mdev->state.peer)
  1879. iass = (mdev->state.role == R_PRIMARY);
  1880. else
  1881. iass = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags);
  1882. if (iass)
  1883. drbd_start_resync(mdev, C_SYNC_SOURCE);
  1884. else
  1885. _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE);
  1886. }
  1887. int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info)
  1888. {
  1889. struct resize_parms rs;
  1890. struct drbd_conf *mdev;
  1891. enum drbd_ret_code retcode;
  1892. enum determine_dev_size dd;
  1893. enum dds_flags ddsf;
  1894. int err;
  1895. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  1896. if (!adm_ctx.reply_skb)
  1897. return retcode;
  1898. if (retcode != NO_ERROR)
  1899. goto fail;
  1900. memset(&rs, 0, sizeof(struct resize_parms));
  1901. if (info->attrs[DRBD_NLA_RESIZE_PARMS]) {
  1902. err = resize_parms_from_attrs(&rs, info);
  1903. if (err) {
  1904. retcode = ERR_MANDATORY_TAG;
  1905. drbd_msg_put_info(from_attrs_err_to_txt(err));
  1906. goto fail;
  1907. }
  1908. }
  1909. mdev = adm_ctx.mdev;
  1910. if (mdev->state.conn > C_CONNECTED) {
  1911. retcode = ERR_RESIZE_RESYNC;
  1912. goto fail;
  1913. }
  1914. if (mdev->state.role == R_SECONDARY &&
  1915. mdev->state.peer == R_SECONDARY) {
  1916. retcode = ERR_NO_PRIMARY;
  1917. goto fail;
  1918. }
  1919. if (!get_ldev(mdev)) {
  1920. retcode = ERR_NO_DISK;
  1921. goto fail;
  1922. }
  1923. if (rs.no_resync && mdev->tconn->agreed_pro_version < 93) {
  1924. retcode = ERR_NEED_APV_93;
  1925. goto fail;
  1926. }
  1927. if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev))
  1928. mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
  1929. mdev->ldev->dc.disk_size = (sector_t)rs.resize_size;
  1930. ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0);
  1931. dd = drbd_determine_dev_size(mdev, ddsf);
  1932. drbd_md_sync(mdev);
  1933. put_ldev(mdev);
  1934. if (dd == dev_size_error) {
  1935. retcode = ERR_NOMEM_BITMAP;
  1936. goto fail;
  1937. }
  1938. if (mdev->state.conn == C_CONNECTED) {
  1939. if (dd == grew)
  1940. set_bit(RESIZE_PENDING, &mdev->flags);
  1941. drbd_send_uuids(mdev);
  1942. drbd_send_sizes(mdev, 1, ddsf);
  1943. }
  1944. fail:
  1945. drbd_adm_finish(info, retcode);
  1946. return 0;
  1947. }
  1948. int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info)
  1949. {
  1950. enum drbd_ret_code retcode;
  1951. cpumask_var_t new_cpu_mask;
  1952. struct drbd_tconn *tconn;
  1953. int *rs_plan_s = NULL;
  1954. struct res_opts res_opts;
  1955. int err;
  1956. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
  1957. if (!adm_ctx.reply_skb)
  1958. return retcode;
  1959. if (retcode != NO_ERROR)
  1960. goto fail;
  1961. tconn = adm_ctx.tconn;
  1962. if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL)) {
  1963. retcode = ERR_NOMEM;
  1964. drbd_msg_put_info("unable to allocate cpumask");
  1965. goto fail;
  1966. }
  1967. res_opts = tconn->res_opts;
  1968. if (should_set_defaults(info))
  1969. drbd_set_res_opts_default(&res_opts);
  1970. err = res_opts_from_attrs(&res_opts, info);
  1971. if (err) {
  1972. retcode = ERR_MANDATORY_TAG;
  1973. drbd_msg_put_info(from_attrs_err_to_txt(err));
  1974. goto fail;
  1975. }
  1976. /* silently ignore cpu mask on UP kernel */
  1977. if (nr_cpu_ids > 1 && res_opts.cpu_mask[0] != 0) {
  1978. err = __bitmap_parse(res_opts.cpu_mask, 32, 0,
  1979. cpumask_bits(new_cpu_mask), nr_cpu_ids);
  1980. if (err) {
  1981. conn_warn(tconn, "__bitmap_parse() failed with %d\n", err);
  1982. retcode = ERR_CPU_MASK_PARSE;
  1983. goto fail;
  1984. }
  1985. }
  1986. tconn->res_opts = res_opts;
  1987. if (!cpumask_equal(tconn->cpu_mask, new_cpu_mask)) {
  1988. cpumask_copy(tconn->cpu_mask, new_cpu_mask);
  1989. drbd_calc_cpu_mask(tconn);
  1990. tconn->receiver.reset_cpu_mask = 1;
  1991. tconn->asender.reset_cpu_mask = 1;
  1992. tconn->worker.reset_cpu_mask = 1;
  1993. }
  1994. fail:
  1995. kfree(rs_plan_s);
  1996. free_cpumask_var(new_cpu_mask);
  1997. drbd_adm_finish(info, retcode);
  1998. return 0;
  1999. }
  2000. int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
  2001. {
  2002. struct drbd_conf *mdev;
  2003. int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
  2004. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2005. if (!adm_ctx.reply_skb)
  2006. return retcode;
  2007. if (retcode != NO_ERROR)
  2008. goto out;
  2009. mdev = adm_ctx.mdev;
  2010. /* If there is still bitmap IO pending, probably because of a previous
  2011. * resync just being finished, wait for it before requesting a new resync. */
  2012. wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
  2013. retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED);
  2014. if (retcode < SS_SUCCESS && retcode != SS_NEED_CONNECTION)
  2015. retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
  2016. while (retcode == SS_NEED_CONNECTION) {
  2017. spin_lock_irq(&mdev->tconn->req_lock);
  2018. if (mdev->state.conn < C_CONNECTED)
  2019. retcode = _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_VERBOSE, NULL);
  2020. spin_unlock_irq(&mdev->tconn->req_lock);
  2021. if (retcode != SS_NEED_CONNECTION)
  2022. break;
  2023. retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
  2024. }
  2025. out:
  2026. drbd_adm_finish(info, retcode);
  2027. return 0;
  2028. }
  2029. static int drbd_bmio_set_susp_al(struct drbd_conf *mdev)
  2030. {
  2031. int rv;
  2032. rv = drbd_bmio_set_n_write(mdev);
  2033. drbd_suspend_al(mdev);
  2034. return rv;
  2035. }
  2036. static int drbd_adm_simple_request_state(struct sk_buff *skb, struct genl_info *info,
  2037. union drbd_state mask, union drbd_state val)
  2038. {
  2039. enum drbd_ret_code retcode;
  2040. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2041. if (!adm_ctx.reply_skb)
  2042. return retcode;
  2043. if (retcode != NO_ERROR)
  2044. goto out;
  2045. retcode = drbd_request_state(adm_ctx.mdev, mask, val);
  2046. out:
  2047. drbd_adm_finish(info, retcode);
  2048. return 0;
  2049. }
  2050. int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info)
  2051. {
  2052. return drbd_adm_simple_request_state(skb, info, NS(conn, C_STARTING_SYNC_S));
  2053. }
  2054. int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info)
  2055. {
  2056. enum drbd_ret_code retcode;
  2057. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2058. if (!adm_ctx.reply_skb)
  2059. return retcode;
  2060. if (retcode != NO_ERROR)
  2061. goto out;
  2062. if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
  2063. retcode = ERR_PAUSE_IS_SET;
  2064. out:
  2065. drbd_adm_finish(info, retcode);
  2066. return 0;
  2067. }
  2068. int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info)
  2069. {
  2070. union drbd_dev_state s;
  2071. enum drbd_ret_code retcode;
  2072. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2073. if (!adm_ctx.reply_skb)
  2074. return retcode;
  2075. if (retcode != NO_ERROR)
  2076. goto out;
  2077. if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
  2078. s = adm_ctx.mdev->state;
  2079. if (s.conn == C_PAUSED_SYNC_S || s.conn == C_PAUSED_SYNC_T) {
  2080. retcode = s.aftr_isp ? ERR_PIC_AFTER_DEP :
  2081. s.peer_isp ? ERR_PIC_PEER_DEP : ERR_PAUSE_IS_CLEAR;
  2082. } else {
  2083. retcode = ERR_PAUSE_IS_CLEAR;
  2084. }
  2085. }
  2086. out:
  2087. drbd_adm_finish(info, retcode);
  2088. return 0;
  2089. }
  2090. int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info)
  2091. {
  2092. return drbd_adm_simple_request_state(skb, info, NS(susp, 1));
  2093. }
  2094. int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info)
  2095. {
  2096. struct drbd_conf *mdev;
  2097. int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
  2098. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2099. if (!adm_ctx.reply_skb)
  2100. return retcode;
  2101. if (retcode != NO_ERROR)
  2102. goto out;
  2103. mdev = adm_ctx.mdev;
  2104. if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
  2105. drbd_uuid_new_current(mdev);
  2106. clear_bit(NEW_CUR_UUID, &mdev->flags);
  2107. }
  2108. drbd_suspend_io(mdev);
  2109. retcode = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
  2110. if (retcode == SS_SUCCESS) {
  2111. if (mdev->state.conn < C_CONNECTED)
  2112. tl_clear(mdev->tconn);
  2113. if (mdev->state.disk == D_DISKLESS || mdev->state.disk == D_FAILED)
  2114. tl_restart(mdev->tconn, FAIL_FROZEN_DISK_IO);
  2115. }
  2116. drbd_resume_io(mdev);
  2117. out:
  2118. drbd_adm_finish(info, retcode);
  2119. return 0;
  2120. }
  2121. int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info)
  2122. {
  2123. return drbd_adm_simple_request_state(skb, info, NS(disk, D_OUTDATED));
  2124. }
  2125. int nla_put_drbd_cfg_context(struct sk_buff *skb, const char *conn_name, unsigned vnr)
  2126. {
  2127. struct nlattr *nla;
  2128. nla = nla_nest_start(skb, DRBD_NLA_CFG_CONTEXT);
  2129. if (!nla)
  2130. goto nla_put_failure;
  2131. if (vnr != VOLUME_UNSPECIFIED)
  2132. NLA_PUT_U32(skb, T_ctx_volume, vnr);
  2133. NLA_PUT_STRING(skb, T_ctx_conn_name, conn_name);
  2134. nla_nest_end(skb, nla);
  2135. return 0;
  2136. nla_put_failure:
  2137. if (nla)
  2138. nla_nest_cancel(skb, nla);
  2139. return -EMSGSIZE;
  2140. }
  2141. int nla_put_status_info(struct sk_buff *skb, struct drbd_conf *mdev,
  2142. const struct sib_info *sib)
  2143. {
  2144. struct state_info *si = NULL; /* for sizeof(si->member); */
  2145. struct net_conf *nc;
  2146. struct nlattr *nla;
  2147. int got_ldev;
  2148. int err = 0;
  2149. int exclude_sensitive;
  2150. /* If sib != NULL, this is drbd_bcast_event, which anyone can listen
  2151. * to. So we better exclude_sensitive information.
  2152. *
  2153. * If sib == NULL, this is drbd_adm_get_status, executed synchronously
  2154. * in the context of the requesting user process. Exclude sensitive
  2155. * information, unless current has superuser.
  2156. *
  2157. * NOTE: for drbd_adm_get_status_all(), this is a netlink dump, and
  2158. * relies on the current implementation of netlink_dump(), which
  2159. * executes the dump callback successively from netlink_recvmsg(),
  2160. * always in the context of the receiving process */
  2161. exclude_sensitive = sib || !capable(CAP_SYS_ADMIN);
  2162. got_ldev = get_ldev(mdev);
  2163. /* We need to add connection name and volume number information still.
  2164. * Minor number is in drbd_genlmsghdr. */
  2165. if (nla_put_drbd_cfg_context(skb, mdev->tconn->name, mdev->vnr))
  2166. goto nla_put_failure;
  2167. if (res_opts_to_skb(skb, &mdev->tconn->res_opts, exclude_sensitive))
  2168. goto nla_put_failure;
  2169. if (got_ldev)
  2170. if (disk_conf_to_skb(skb, &mdev->ldev->dc, exclude_sensitive))
  2171. goto nla_put_failure;
  2172. rcu_read_lock();
  2173. nc = rcu_dereference(mdev->tconn->net_conf);
  2174. if (nc)
  2175. err = net_conf_to_skb(skb, nc, exclude_sensitive);
  2176. rcu_read_unlock();
  2177. if (err)
  2178. goto nla_put_failure;
  2179. nla = nla_nest_start(skb, DRBD_NLA_STATE_INFO);
  2180. if (!nla)
  2181. goto nla_put_failure;
  2182. NLA_PUT_U32(skb, T_sib_reason, sib ? sib->sib_reason : SIB_GET_STATUS_REPLY);
  2183. NLA_PUT_U32(skb, T_current_state, mdev->state.i);
  2184. NLA_PUT_U64(skb, T_ed_uuid, mdev->ed_uuid);
  2185. NLA_PUT_U64(skb, T_capacity, drbd_get_capacity(mdev->this_bdev));
  2186. if (got_ldev) {
  2187. NLA_PUT_U32(skb, T_disk_flags, mdev->ldev->md.flags);
  2188. NLA_PUT(skb, T_uuids, sizeof(si->uuids), mdev->ldev->md.uuid);
  2189. NLA_PUT_U64(skb, T_bits_total, drbd_bm_bits(mdev));
  2190. NLA_PUT_U64(skb, T_bits_oos, drbd_bm_total_weight(mdev));
  2191. if (C_SYNC_SOURCE <= mdev->state.conn &&
  2192. C_PAUSED_SYNC_T >= mdev->state.conn) {
  2193. NLA_PUT_U64(skb, T_bits_rs_total, mdev->rs_total);
  2194. NLA_PUT_U64(skb, T_bits_rs_failed, mdev->rs_failed);
  2195. }
  2196. }
  2197. if (sib) {
  2198. switch(sib->sib_reason) {
  2199. case SIB_SYNC_PROGRESS:
  2200. case SIB_GET_STATUS_REPLY:
  2201. break;
  2202. case SIB_STATE_CHANGE:
  2203. NLA_PUT_U32(skb, T_prev_state, sib->os.i);
  2204. NLA_PUT_U32(skb, T_new_state, sib->ns.i);
  2205. break;
  2206. case SIB_HELPER_POST:
  2207. NLA_PUT_U32(skb,
  2208. T_helper_exit_code, sib->helper_exit_code);
  2209. /* fall through */
  2210. case SIB_HELPER_PRE:
  2211. NLA_PUT_STRING(skb, T_helper, sib->helper_name);
  2212. break;
  2213. }
  2214. }
  2215. nla_nest_end(skb, nla);
  2216. if (0)
  2217. nla_put_failure:
  2218. err = -EMSGSIZE;
  2219. if (got_ldev)
  2220. put_ldev(mdev);
  2221. return err;
  2222. }
  2223. int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info)
  2224. {
  2225. enum drbd_ret_code retcode;
  2226. int err;
  2227. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2228. if (!adm_ctx.reply_skb)
  2229. return retcode;
  2230. if (retcode != NO_ERROR)
  2231. goto out;
  2232. err = nla_put_status_info(adm_ctx.reply_skb, adm_ctx.mdev, NULL);
  2233. if (err) {
  2234. nlmsg_free(adm_ctx.reply_skb);
  2235. return err;
  2236. }
  2237. out:
  2238. drbd_adm_finish(info, retcode);
  2239. return 0;
  2240. }
  2241. int get_one_status(struct sk_buff *skb, struct netlink_callback *cb)
  2242. {
  2243. struct drbd_conf *mdev;
  2244. struct drbd_genlmsghdr *dh;
  2245. struct drbd_tconn *pos = (struct drbd_tconn*)cb->args[0];
  2246. struct drbd_tconn *tconn = NULL;
  2247. struct drbd_tconn *tmp;
  2248. unsigned volume = cb->args[1];
  2249. /* Open coded, deferred, iteration:
  2250. * list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
  2251. * idr_for_each_entry(&tconn->volumes, mdev, i) {
  2252. * ...
  2253. * }
  2254. * }
  2255. * where tconn is cb->args[0];
  2256. * and i is cb->args[1];
  2257. *
  2258. * cb->args[2] indicates if we shall loop over all resources,
  2259. * or just dump all volumes of a single resource.
  2260. *
  2261. * This may miss entries inserted after this dump started,
  2262. * or entries deleted before they are reached.
  2263. *
  2264. * We need to make sure the mdev won't disappear while
  2265. * we are looking at it, and revalidate our iterators
  2266. * on each iteration.
  2267. */
  2268. /* synchronize with conn_create()/conn_destroy() */
  2269. down_read(&drbd_cfg_rwsem);
  2270. /* revalidate iterator position */
  2271. list_for_each_entry(tmp, &drbd_tconns, all_tconn) {
  2272. if (pos == NULL) {
  2273. /* first iteration */
  2274. pos = tmp;
  2275. tconn = pos;
  2276. break;
  2277. }
  2278. if (tmp == pos) {
  2279. tconn = pos;
  2280. break;
  2281. }
  2282. }
  2283. if (tconn) {
  2284. next_tconn:
  2285. mdev = idr_get_next(&tconn->volumes, &volume);
  2286. if (!mdev) {
  2287. /* No more volumes to dump on this tconn.
  2288. * Advance tconn iterator. */
  2289. pos = list_entry(tconn->all_tconn.next,
  2290. struct drbd_tconn, all_tconn);
  2291. /* Did we dump any volume on this tconn yet? */
  2292. if (volume != 0) {
  2293. /* If we reached the end of the list,
  2294. * or only a single resource dump was requested,
  2295. * we are done. */
  2296. if (&pos->all_tconn == &drbd_tconns || cb->args[2])
  2297. goto out;
  2298. volume = 0;
  2299. tconn = pos;
  2300. goto next_tconn;
  2301. }
  2302. }
  2303. dh = genlmsg_put(skb, NETLINK_CB(cb->skb).pid,
  2304. cb->nlh->nlmsg_seq, &drbd_genl_family,
  2305. NLM_F_MULTI, DRBD_ADM_GET_STATUS);
  2306. if (!dh)
  2307. goto out;
  2308. if (!mdev) {
  2309. /* this is a tconn without a single volume */
  2310. dh->minor = -1U;
  2311. dh->ret_code = NO_ERROR;
  2312. if (nla_put_drbd_cfg_context(skb, tconn->name, VOLUME_UNSPECIFIED))
  2313. genlmsg_cancel(skb, dh);
  2314. else
  2315. genlmsg_end(skb, dh);
  2316. goto out;
  2317. }
  2318. D_ASSERT(mdev->vnr == volume);
  2319. D_ASSERT(mdev->tconn == tconn);
  2320. dh->minor = mdev_to_minor(mdev);
  2321. dh->ret_code = NO_ERROR;
  2322. if (nla_put_status_info(skb, mdev, NULL)) {
  2323. genlmsg_cancel(skb, dh);
  2324. goto out;
  2325. }
  2326. genlmsg_end(skb, dh);
  2327. }
  2328. out:
  2329. up_read(&drbd_cfg_rwsem);
  2330. /* where to start the next iteration */
  2331. cb->args[0] = (long)pos;
  2332. cb->args[1] = (pos == tconn) ? volume + 1 : 0;
  2333. /* No more tconns/volumes/minors found results in an empty skb.
  2334. * Which will terminate the dump. */
  2335. return skb->len;
  2336. }
  2337. /*
  2338. * Request status of all resources, or of all volumes within a single resource.
  2339. *
  2340. * This is a dump, as the answer may not fit in a single reply skb otherwise.
  2341. * Which means we cannot use the family->attrbuf or other such members, because
  2342. * dump is NOT protected by the genl_lock(). During dump, we only have access
  2343. * to the incoming skb, and need to opencode "parsing" of the nlattr payload.
  2344. *
  2345. * Once things are setup properly, we call into get_one_status().
  2346. */
  2347. int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb)
  2348. {
  2349. const unsigned hdrlen = GENL_HDRLEN + GENL_MAGIC_FAMILY_HDRSZ;
  2350. struct nlattr *nla;
  2351. const char *conn_name;
  2352. struct drbd_tconn *tconn;
  2353. /* Is this a followup call? */
  2354. if (cb->args[0]) {
  2355. /* ... of a single resource dump,
  2356. * and the resource iterator has been advanced already? */
  2357. if (cb->args[2] && cb->args[2] != cb->args[0])
  2358. return 0; /* DONE. */
  2359. goto dump;
  2360. }
  2361. /* First call (from netlink_dump_start). We need to figure out
  2362. * which resource(s) the user wants us to dump. */
  2363. nla = nla_find(nlmsg_attrdata(cb->nlh, hdrlen),
  2364. nlmsg_attrlen(cb->nlh, hdrlen),
  2365. DRBD_NLA_CFG_CONTEXT);
  2366. /* No explicit context given. Dump all. */
  2367. if (!nla)
  2368. goto dump;
  2369. nla = nla_find_nested(nla, __nla_type(T_ctx_conn_name));
  2370. /* context given, but no name present? */
  2371. if (!nla)
  2372. return -EINVAL;
  2373. conn_name = nla_data(nla);
  2374. tconn = conn_get_by_name(conn_name);
  2375. if (!tconn)
  2376. return -ENODEV;
  2377. kref_put(&tconn->kref, &conn_destroy); /* get_one_status() (re)validates tconn by itself */
  2378. /* prime iterators, and set "filter" mode mark:
  2379. * only dump this tconn. */
  2380. cb->args[0] = (long)tconn;
  2381. /* cb->args[1] = 0; passed in this way. */
  2382. cb->args[2] = (long)tconn;
  2383. dump:
  2384. return get_one_status(skb, cb);
  2385. }
  2386. int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info)
  2387. {
  2388. enum drbd_ret_code retcode;
  2389. struct timeout_parms tp;
  2390. int err;
  2391. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2392. if (!adm_ctx.reply_skb)
  2393. return retcode;
  2394. if (retcode != NO_ERROR)
  2395. goto out;
  2396. tp.timeout_type =
  2397. adm_ctx.mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED :
  2398. test_bit(USE_DEGR_WFC_T, &adm_ctx.mdev->flags) ? UT_DEGRADED :
  2399. UT_DEFAULT;
  2400. err = timeout_parms_to_priv_skb(adm_ctx.reply_skb, &tp);
  2401. if (err) {
  2402. nlmsg_free(adm_ctx.reply_skb);
  2403. return err;
  2404. }
  2405. out:
  2406. drbd_adm_finish(info, retcode);
  2407. return 0;
  2408. }
  2409. int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info)
  2410. {
  2411. struct drbd_conf *mdev;
  2412. enum drbd_ret_code retcode;
  2413. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2414. if (!adm_ctx.reply_skb)
  2415. return retcode;
  2416. if (retcode != NO_ERROR)
  2417. goto out;
  2418. mdev = adm_ctx.mdev;
  2419. if (info->attrs[DRBD_NLA_START_OV_PARMS]) {
  2420. /* resume from last known position, if possible */
  2421. struct start_ov_parms parms =
  2422. { .ov_start_sector = mdev->ov_start_sector };
  2423. int err = start_ov_parms_from_attrs(&parms, info);
  2424. if (err) {
  2425. retcode = ERR_MANDATORY_TAG;
  2426. drbd_msg_put_info(from_attrs_err_to_txt(err));
  2427. goto out;
  2428. }
  2429. /* w_make_ov_request expects position to be aligned */
  2430. mdev->ov_start_sector = parms.ov_start_sector & ~BM_SECT_PER_BIT;
  2431. }
  2432. /* If there is still bitmap IO pending, e.g. previous resync or verify
  2433. * just being finished, wait for it before requesting a new resync. */
  2434. wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
  2435. retcode = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
  2436. out:
  2437. drbd_adm_finish(info, retcode);
  2438. return 0;
  2439. }
  2440. int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
  2441. {
  2442. struct drbd_conf *mdev;
  2443. enum drbd_ret_code retcode;
  2444. int skip_initial_sync = 0;
  2445. int err;
  2446. struct new_c_uuid_parms args;
  2447. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2448. if (!adm_ctx.reply_skb)
  2449. return retcode;
  2450. if (retcode != NO_ERROR)
  2451. goto out_nolock;
  2452. mdev = adm_ctx.mdev;
  2453. memset(&args, 0, sizeof(args));
  2454. if (info->attrs[DRBD_NLA_NEW_C_UUID_PARMS]) {
  2455. err = new_c_uuid_parms_from_attrs(&args, info);
  2456. if (err) {
  2457. retcode = ERR_MANDATORY_TAG;
  2458. drbd_msg_put_info(from_attrs_err_to_txt(err));
  2459. goto out_nolock;
  2460. }
  2461. }
  2462. mutex_lock(mdev->state_mutex); /* Protects us against serialized state changes. */
  2463. if (!get_ldev(mdev)) {
  2464. retcode = ERR_NO_DISK;
  2465. goto out;
  2466. }
  2467. /* this is "skip initial sync", assume to be clean */
  2468. if (mdev->state.conn == C_CONNECTED && mdev->tconn->agreed_pro_version >= 90 &&
  2469. mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) {
  2470. dev_info(DEV, "Preparing to skip initial sync\n");
  2471. skip_initial_sync = 1;
  2472. } else if (mdev->state.conn != C_STANDALONE) {
  2473. retcode = ERR_CONNECTED;
  2474. goto out_dec;
  2475. }
  2476. drbd_uuid_set(mdev, UI_BITMAP, 0); /* Rotate UI_BITMAP to History 1, etc... */
  2477. drbd_uuid_new_current(mdev); /* New current, previous to UI_BITMAP */
  2478. if (args.clear_bm) {
  2479. err = drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
  2480. "clear_n_write from new_c_uuid", BM_LOCKED_MASK);
  2481. if (err) {
  2482. dev_err(DEV, "Writing bitmap failed with %d\n",err);
  2483. retcode = ERR_IO_MD_DISK;
  2484. }
  2485. if (skip_initial_sync) {
  2486. drbd_send_uuids_skip_initial_sync(mdev);
  2487. _drbd_uuid_set(mdev, UI_BITMAP, 0);
  2488. drbd_print_uuids(mdev, "cleared bitmap UUID");
  2489. spin_lock_irq(&mdev->tconn->req_lock);
  2490. _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
  2491. CS_VERBOSE, NULL);
  2492. spin_unlock_irq(&mdev->tconn->req_lock);
  2493. }
  2494. }
  2495. drbd_md_sync(mdev);
  2496. out_dec:
  2497. put_ldev(mdev);
  2498. out:
  2499. mutex_unlock(mdev->state_mutex);
  2500. out_nolock:
  2501. drbd_adm_finish(info, retcode);
  2502. return 0;
  2503. }
  2504. static enum drbd_ret_code
  2505. drbd_check_conn_name(const char *name)
  2506. {
  2507. if (!name || !name[0]) {
  2508. drbd_msg_put_info("connection name missing");
  2509. return ERR_MANDATORY_TAG;
  2510. }
  2511. /* if we want to use these in sysfs/configfs/debugfs some day,
  2512. * we must not allow slashes */
  2513. if (strchr(name, '/')) {
  2514. drbd_msg_put_info("invalid connection name");
  2515. return ERR_INVALID_REQUEST;
  2516. }
  2517. return NO_ERROR;
  2518. }
  2519. int drbd_adm_create_connection(struct sk_buff *skb, struct genl_info *info)
  2520. {
  2521. enum drbd_ret_code retcode;
  2522. retcode = drbd_adm_prepare(skb, info, 0);
  2523. if (!adm_ctx.reply_skb)
  2524. return retcode;
  2525. if (retcode != NO_ERROR)
  2526. goto out;
  2527. retcode = drbd_check_conn_name(adm_ctx.conn_name);
  2528. if (retcode != NO_ERROR)
  2529. goto out;
  2530. if (adm_ctx.tconn) {
  2531. if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) {
  2532. retcode = ERR_INVALID_REQUEST;
  2533. drbd_msg_put_info("connection exists");
  2534. }
  2535. /* else: still NO_ERROR */
  2536. goto out;
  2537. }
  2538. if (!conn_create(adm_ctx.conn_name))
  2539. retcode = ERR_NOMEM;
  2540. out:
  2541. drbd_adm_finish(info, retcode);
  2542. return 0;
  2543. }
  2544. int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info)
  2545. {
  2546. struct drbd_genlmsghdr *dh = info->userhdr;
  2547. enum drbd_ret_code retcode;
  2548. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
  2549. if (!adm_ctx.reply_skb)
  2550. return retcode;
  2551. if (retcode != NO_ERROR)
  2552. goto out;
  2553. /* FIXME drop minor_count parameter, limit to MINORMASK */
  2554. if (dh->minor >= minor_count) {
  2555. drbd_msg_put_info("requested minor out of range");
  2556. retcode = ERR_INVALID_REQUEST;
  2557. goto out;
  2558. }
  2559. if (adm_ctx.volume > DRBD_VOLUME_MAX) {
  2560. drbd_msg_put_info("requested volume id out of range");
  2561. retcode = ERR_INVALID_REQUEST;
  2562. goto out;
  2563. }
  2564. /* drbd_adm_prepare made sure already
  2565. * that mdev->tconn and mdev->vnr match the request. */
  2566. if (adm_ctx.mdev) {
  2567. if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
  2568. retcode = ERR_MINOR_EXISTS;
  2569. /* else: still NO_ERROR */
  2570. goto out;
  2571. }
  2572. down_write(&drbd_cfg_rwsem);
  2573. retcode = conn_new_minor(adm_ctx.tconn, dh->minor, adm_ctx.volume);
  2574. up_write(&drbd_cfg_rwsem);
  2575. out:
  2576. drbd_adm_finish(info, retcode);
  2577. return 0;
  2578. }
  2579. static enum drbd_ret_code adm_delete_minor(struct drbd_conf *mdev)
  2580. {
  2581. if (mdev->state.disk == D_DISKLESS &&
  2582. /* no need to be mdev->state.conn == C_STANDALONE &&
  2583. * we may want to delete a minor from a live replication group.
  2584. */
  2585. mdev->state.role == R_SECONDARY) {
  2586. drbd_delete_device(mdev);
  2587. return NO_ERROR;
  2588. } else
  2589. return ERR_MINOR_CONFIGURED;
  2590. }
  2591. int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info)
  2592. {
  2593. enum drbd_ret_code retcode;
  2594. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
  2595. if (!adm_ctx.reply_skb)
  2596. return retcode;
  2597. if (retcode != NO_ERROR)
  2598. goto out;
  2599. down_write(&drbd_cfg_rwsem);
  2600. retcode = adm_delete_minor(adm_ctx.mdev);
  2601. up_write(&drbd_cfg_rwsem);
  2602. out:
  2603. drbd_adm_finish(info, retcode);
  2604. return 0;
  2605. }
  2606. int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
  2607. {
  2608. enum drbd_ret_code retcode;
  2609. enum drbd_state_rv rv;
  2610. struct drbd_conf *mdev;
  2611. unsigned i;
  2612. retcode = drbd_adm_prepare(skb, info, 0);
  2613. if (!adm_ctx.reply_skb)
  2614. return retcode;
  2615. if (retcode != NO_ERROR)
  2616. goto out;
  2617. if (!adm_ctx.tconn) {
  2618. retcode = ERR_CONN_NOT_KNOWN;
  2619. goto out;
  2620. }
  2621. down_read(&drbd_cfg_rwsem);
  2622. /* demote */
  2623. idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
  2624. retcode = drbd_set_role(mdev, R_SECONDARY, 0);
  2625. if (retcode < SS_SUCCESS) {
  2626. drbd_msg_put_info("failed to demote");
  2627. goto out_unlock;
  2628. }
  2629. }
  2630. /* disconnect */
  2631. rv = conn_try_disconnect(adm_ctx.tconn, 0);
  2632. if (rv < SS_SUCCESS) {
  2633. retcode = rv; /* enum type mismatch! */
  2634. drbd_msg_put_info("failed to disconnect");
  2635. goto out_unlock;
  2636. }
  2637. /* Make sure the network threads have actually stopped,
  2638. * state handling only does drbd_thread_stop_nowait(). */
  2639. drbd_thread_stop(&adm_ctx.tconn->receiver);
  2640. /* detach */
  2641. idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
  2642. rv = adm_detach(mdev);
  2643. if (rv < SS_SUCCESS) {
  2644. retcode = rv; /* enum type mismatch! */
  2645. drbd_msg_put_info("failed to detach");
  2646. goto out_unlock;
  2647. }
  2648. }
  2649. up_read(&drbd_cfg_rwsem);
  2650. /* delete volumes */
  2651. down_write(&drbd_cfg_rwsem);
  2652. idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
  2653. retcode = adm_delete_minor(mdev);
  2654. if (retcode != NO_ERROR) {
  2655. /* "can not happen" */
  2656. drbd_msg_put_info("failed to delete volume");
  2657. up_write(&drbd_cfg_rwsem);
  2658. goto out;
  2659. }
  2660. }
  2661. /* delete connection */
  2662. if (conn_lowest_minor(adm_ctx.tconn) < 0) {
  2663. drbd_thread_stop(&adm_ctx.tconn->worker);
  2664. list_del(&adm_ctx.tconn->all_tconn);
  2665. kref_put(&adm_ctx.tconn->kref, &conn_destroy);
  2666. retcode = NO_ERROR;
  2667. } else {
  2668. /* "can not happen" */
  2669. retcode = ERR_CONN_IN_USE;
  2670. drbd_msg_put_info("failed to delete connection");
  2671. }
  2672. up_write(&drbd_cfg_rwsem);
  2673. goto out;
  2674. out_unlock:
  2675. up_read(&drbd_cfg_rwsem);
  2676. out:
  2677. drbd_adm_finish(info, retcode);
  2678. return 0;
  2679. }
  2680. int drbd_adm_delete_connection(struct sk_buff *skb, struct genl_info *info)
  2681. {
  2682. enum drbd_ret_code retcode;
  2683. retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
  2684. if (!adm_ctx.reply_skb)
  2685. return retcode;
  2686. if (retcode != NO_ERROR)
  2687. goto out;
  2688. down_write(&drbd_cfg_rwsem);
  2689. if (conn_lowest_minor(adm_ctx.tconn) < 0) {
  2690. list_del(&adm_ctx.tconn->all_tconn);
  2691. kref_put(&adm_ctx.tconn->kref, &conn_destroy);
  2692. retcode = NO_ERROR;
  2693. } else {
  2694. retcode = ERR_CONN_IN_USE;
  2695. }
  2696. up_write(&drbd_cfg_rwsem);
  2697. out:
  2698. drbd_adm_finish(info, retcode);
  2699. return 0;
  2700. }
  2701. void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib)
  2702. {
  2703. static atomic_t drbd_genl_seq = ATOMIC_INIT(2); /* two. */
  2704. struct sk_buff *msg;
  2705. struct drbd_genlmsghdr *d_out;
  2706. unsigned seq;
  2707. int err = -ENOMEM;
  2708. seq = atomic_inc_return(&drbd_genl_seq);
  2709. msg = genlmsg_new(NLMSG_GOODSIZE, GFP_NOIO);
  2710. if (!msg)
  2711. goto failed;
  2712. err = -EMSGSIZE;
  2713. d_out = genlmsg_put(msg, 0, seq, &drbd_genl_family, 0, DRBD_EVENT);
  2714. if (!d_out) /* cannot happen, but anyways. */
  2715. goto nla_put_failure;
  2716. d_out->minor = mdev_to_minor(mdev);
  2717. d_out->ret_code = 0;
  2718. if (nla_put_status_info(msg, mdev, sib))
  2719. goto nla_put_failure;
  2720. genlmsg_end(msg, d_out);
  2721. err = drbd_genl_multicast_events(msg, 0);
  2722. /* msg has been consumed or freed in netlink_broadcast() */
  2723. if (err && err != -ESRCH)
  2724. goto failed;
  2725. return;
  2726. nla_put_failure:
  2727. nlmsg_free(msg);
  2728. failed:
  2729. dev_err(DEV, "Error %d while broadcasting event. "
  2730. "Event seq:%u sib_reason:%u\n",
  2731. err, seq, sib->sib_reason);
  2732. }