target_core_configfs.c 97 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*******************************************************************************
  3. * Filename: target_core_configfs.c
  4. *
  5. * This file contains ConfigFS logic for the Generic Target Engine project.
  6. *
  7. * (c) Copyright 2008-2013 Datera, Inc.
  8. *
  9. * Nicholas A. Bellinger <nab@kernel.org>
  10. *
  11. * based on configfs Copyright (C) 2005 Oracle. All rights reserved.
  12. *
  13. ****************************************************************************/
  14. #include <linux/module.h>
  15. #include <linux/moduleparam.h>
  16. #include <generated/utsrelease.h>
  17. #include <linux/utsname.h>
  18. #include <linux/init.h>
  19. #include <linux/fs.h>
  20. #include <linux/namei.h>
  21. #include <linux/slab.h>
  22. #include <linux/types.h>
  23. #include <linux/delay.h>
  24. #include <linux/unistd.h>
  25. #include <linux/string.h>
  26. #include <linux/parser.h>
  27. #include <linux/syscalls.h>
  28. #include <linux/configfs.h>
  29. #include <linux/spinlock.h>
  30. #include <target/target_core_base.h>
  31. #include <target/target_core_backend.h>
  32. #include <target/target_core_fabric.h>
  33. #include "target_core_internal.h"
  34. #include "target_core_alua.h"
  35. #include "target_core_pr.h"
  36. #include "target_core_rd.h"
  37. #include "target_core_xcopy.h"
  38. #define TB_CIT_SETUP(_name, _item_ops, _group_ops, _attrs) \
  39. static void target_core_setup_##_name##_cit(struct target_backend *tb) \
  40. { \
  41. struct config_item_type *cit = &tb->tb_##_name##_cit; \
  42. \
  43. cit->ct_item_ops = _item_ops; \
  44. cit->ct_group_ops = _group_ops; \
  45. cit->ct_attrs = _attrs; \
  46. cit->ct_owner = tb->ops->owner; \
  47. pr_debug("Setup generic %s\n", __stringify(_name)); \
  48. }
  49. #define TB_CIT_SETUP_DRV(_name, _item_ops, _group_ops) \
  50. static void target_core_setup_##_name##_cit(struct target_backend *tb) \
  51. { \
  52. struct config_item_type *cit = &tb->tb_##_name##_cit; \
  53. \
  54. cit->ct_item_ops = _item_ops; \
  55. cit->ct_group_ops = _group_ops; \
  56. cit->ct_attrs = tb->ops->tb_##_name##_attrs; \
  57. cit->ct_owner = tb->ops->owner; \
  58. pr_debug("Setup generic %s\n", __stringify(_name)); \
  59. }
  60. extern struct t10_alua_lu_gp *default_lu_gp;
  61. static LIST_HEAD(g_tf_list);
  62. static DEFINE_MUTEX(g_tf_lock);
  63. static struct config_group target_core_hbagroup;
  64. static struct config_group alua_group;
  65. static struct config_group alua_lu_gps_group;
  66. static inline struct se_hba *
  67. item_to_hba(struct config_item *item)
  68. {
  69. return container_of(to_config_group(item), struct se_hba, hba_group);
  70. }
  71. /*
  72. * Attributes for /sys/kernel/config/target/
  73. */
  74. static ssize_t target_core_item_version_show(struct config_item *item,
  75. char *page)
  76. {
  77. return sprintf(page, "Target Engine Core ConfigFS Infrastructure %s"
  78. " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_VERSION,
  79. utsname()->sysname, utsname()->machine);
  80. }
  81. CONFIGFS_ATTR_RO(target_core_item_, version);
  82. char db_root[DB_ROOT_LEN] = DB_ROOT_DEFAULT;
  83. static char db_root_stage[DB_ROOT_LEN];
  84. static ssize_t target_core_item_dbroot_show(struct config_item *item,
  85. char *page)
  86. {
  87. return sprintf(page, "%s\n", db_root);
  88. }
  89. static ssize_t target_core_item_dbroot_store(struct config_item *item,
  90. const char *page, size_t count)
  91. {
  92. ssize_t read_bytes;
  93. struct file *fp;
  94. mutex_lock(&g_tf_lock);
  95. if (!list_empty(&g_tf_list)) {
  96. mutex_unlock(&g_tf_lock);
  97. pr_err("db_root: cannot be changed: target drivers registered");
  98. return -EINVAL;
  99. }
  100. if (count > (DB_ROOT_LEN - 1)) {
  101. mutex_unlock(&g_tf_lock);
  102. pr_err("db_root: count %d exceeds DB_ROOT_LEN-1: %u\n",
  103. (int)count, DB_ROOT_LEN - 1);
  104. return -EINVAL;
  105. }
  106. read_bytes = snprintf(db_root_stage, DB_ROOT_LEN, "%s", page);
  107. if (!read_bytes) {
  108. mutex_unlock(&g_tf_lock);
  109. return -EINVAL;
  110. }
  111. if (db_root_stage[read_bytes - 1] == '\n')
  112. db_root_stage[read_bytes - 1] = '\0';
  113. /* validate new db root before accepting it */
  114. fp = filp_open(db_root_stage, O_RDONLY, 0);
  115. if (IS_ERR(fp)) {
  116. mutex_unlock(&g_tf_lock);
  117. pr_err("db_root: cannot open: %s\n", db_root_stage);
  118. return -EINVAL;
  119. }
  120. if (!S_ISDIR(file_inode(fp)->i_mode)) {
  121. filp_close(fp, NULL);
  122. mutex_unlock(&g_tf_lock);
  123. pr_err("db_root: not a directory: %s\n", db_root_stage);
  124. return -EINVAL;
  125. }
  126. filp_close(fp, NULL);
  127. strncpy(db_root, db_root_stage, read_bytes);
  128. mutex_unlock(&g_tf_lock);
  129. pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root);
  130. return read_bytes;
  131. }
  132. CONFIGFS_ATTR(target_core_item_, dbroot);
  133. static struct target_fabric_configfs *target_core_get_fabric(
  134. const char *name)
  135. {
  136. struct target_fabric_configfs *tf;
  137. if (!name)
  138. return NULL;
  139. mutex_lock(&g_tf_lock);
  140. list_for_each_entry(tf, &g_tf_list, tf_list) {
  141. const char *cmp_name = tf->tf_ops->fabric_alias;
  142. if (!cmp_name)
  143. cmp_name = tf->tf_ops->fabric_name;
  144. if (!strcmp(cmp_name, name)) {
  145. atomic_inc(&tf->tf_access_cnt);
  146. mutex_unlock(&g_tf_lock);
  147. return tf;
  148. }
  149. }
  150. mutex_unlock(&g_tf_lock);
  151. return NULL;
  152. }
  153. /*
  154. * Called from struct target_core_group_ops->make_group()
  155. */
  156. static struct config_group *target_core_register_fabric(
  157. struct config_group *group,
  158. const char *name)
  159. {
  160. struct target_fabric_configfs *tf;
  161. int ret;
  162. pr_debug("Target_Core_ConfigFS: REGISTER -> group: %p name:"
  163. " %s\n", group, name);
  164. tf = target_core_get_fabric(name);
  165. if (!tf) {
  166. pr_debug("target_core_register_fabric() trying autoload for %s\n",
  167. name);
  168. /*
  169. * Below are some hardcoded request_module() calls to automatically
  170. * local fabric modules when the following is called:
  171. *
  172. * mkdir -p /sys/kernel/config/target/$MODULE_NAME
  173. *
  174. * Note that this does not limit which TCM fabric module can be
  175. * registered, but simply provids auto loading logic for modules with
  176. * mkdir(2) system calls with known TCM fabric modules.
  177. */
  178. if (!strncmp(name, "iscsi", 5)) {
  179. /*
  180. * Automatically load the LIO Target fabric module when the
  181. * following is called:
  182. *
  183. * mkdir -p $CONFIGFS/target/iscsi
  184. */
  185. ret = request_module("iscsi_target_mod");
  186. if (ret < 0) {
  187. pr_debug("request_module() failed for"
  188. " iscsi_target_mod.ko: %d\n", ret);
  189. return ERR_PTR(-EINVAL);
  190. }
  191. } else if (!strncmp(name, "loopback", 8)) {
  192. /*
  193. * Automatically load the tcm_loop fabric module when the
  194. * following is called:
  195. *
  196. * mkdir -p $CONFIGFS/target/loopback
  197. */
  198. ret = request_module("tcm_loop");
  199. if (ret < 0) {
  200. pr_debug("request_module() failed for"
  201. " tcm_loop.ko: %d\n", ret);
  202. return ERR_PTR(-EINVAL);
  203. }
  204. }
  205. tf = target_core_get_fabric(name);
  206. }
  207. if (!tf) {
  208. pr_debug("target_core_get_fabric() failed for %s\n",
  209. name);
  210. return ERR_PTR(-EINVAL);
  211. }
  212. pr_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:"
  213. " %s\n", tf->tf_ops->fabric_name);
  214. /*
  215. * On a successful target_core_get_fabric() look, the returned
  216. * struct target_fabric_configfs *tf will contain a usage reference.
  217. */
  218. pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n",
  219. &tf->tf_wwn_cit);
  220. config_group_init_type_name(&tf->tf_group, name, &tf->tf_wwn_cit);
  221. config_group_init_type_name(&tf->tf_disc_group, "discovery_auth",
  222. &tf->tf_discovery_cit);
  223. configfs_add_default_group(&tf->tf_disc_group, &tf->tf_group);
  224. pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric: %s\n",
  225. config_item_name(&tf->tf_group.cg_item));
  226. return &tf->tf_group;
  227. }
  228. /*
  229. * Called from struct target_core_group_ops->drop_item()
  230. */
  231. static void target_core_deregister_fabric(
  232. struct config_group *group,
  233. struct config_item *item)
  234. {
  235. struct target_fabric_configfs *tf = container_of(
  236. to_config_group(item), struct target_fabric_configfs, tf_group);
  237. pr_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in"
  238. " tf list\n", config_item_name(item));
  239. pr_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:"
  240. " %s\n", tf->tf_ops->fabric_name);
  241. atomic_dec(&tf->tf_access_cnt);
  242. pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci"
  243. " %s\n", config_item_name(item));
  244. configfs_remove_default_groups(&tf->tf_group);
  245. config_item_put(item);
  246. }
  247. static struct configfs_group_operations target_core_fabric_group_ops = {
  248. .make_group = &target_core_register_fabric,
  249. .drop_item = &target_core_deregister_fabric,
  250. };
  251. /*
  252. * All item attributes appearing in /sys/kernel/target/ appear here.
  253. */
  254. static struct configfs_attribute *target_core_fabric_item_attrs[] = {
  255. &target_core_item_attr_version,
  256. &target_core_item_attr_dbroot,
  257. NULL,
  258. };
  259. /*
  260. * Provides Fabrics Groups and Item Attributes for /sys/kernel/config/target/
  261. */
  262. static const struct config_item_type target_core_fabrics_item = {
  263. .ct_group_ops = &target_core_fabric_group_ops,
  264. .ct_attrs = target_core_fabric_item_attrs,
  265. .ct_owner = THIS_MODULE,
  266. };
  267. static struct configfs_subsystem target_core_fabrics = {
  268. .su_group = {
  269. .cg_item = {
  270. .ci_namebuf = "target",
  271. .ci_type = &target_core_fabrics_item,
  272. },
  273. },
  274. };
  275. int target_depend_item(struct config_item *item)
  276. {
  277. return configfs_depend_item(&target_core_fabrics, item);
  278. }
  279. EXPORT_SYMBOL(target_depend_item);
  280. void target_undepend_item(struct config_item *item)
  281. {
  282. return configfs_undepend_item(item);
  283. }
  284. EXPORT_SYMBOL(target_undepend_item);
  285. /*##############################################################################
  286. // Start functions called by external Target Fabrics Modules
  287. //############################################################################*/
  288. static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
  289. {
  290. if (tfo->fabric_alias) {
  291. if (strlen(tfo->fabric_alias) >= TARGET_FABRIC_NAME_SIZE) {
  292. pr_err("Passed alias: %s exceeds "
  293. "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_alias);
  294. return -EINVAL;
  295. }
  296. }
  297. if (!tfo->fabric_name) {
  298. pr_err("Missing tfo->fabric_name\n");
  299. return -EINVAL;
  300. }
  301. if (strlen(tfo->fabric_name) >= TARGET_FABRIC_NAME_SIZE) {
  302. pr_err("Passed name: %s exceeds "
  303. "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_name);
  304. return -EINVAL;
  305. }
  306. if (!tfo->tpg_get_wwn) {
  307. pr_err("Missing tfo->tpg_get_wwn()\n");
  308. return -EINVAL;
  309. }
  310. if (!tfo->tpg_get_tag) {
  311. pr_err("Missing tfo->tpg_get_tag()\n");
  312. return -EINVAL;
  313. }
  314. if (!tfo->tpg_check_demo_mode) {
  315. pr_err("Missing tfo->tpg_check_demo_mode()\n");
  316. return -EINVAL;
  317. }
  318. if (!tfo->tpg_check_demo_mode_cache) {
  319. pr_err("Missing tfo->tpg_check_demo_mode_cache()\n");
  320. return -EINVAL;
  321. }
  322. if (!tfo->tpg_check_demo_mode_write_protect) {
  323. pr_err("Missing tfo->tpg_check_demo_mode_write_protect()\n");
  324. return -EINVAL;
  325. }
  326. if (!tfo->tpg_check_prod_mode_write_protect) {
  327. pr_err("Missing tfo->tpg_check_prod_mode_write_protect()\n");
  328. return -EINVAL;
  329. }
  330. if (!tfo->tpg_get_inst_index) {
  331. pr_err("Missing tfo->tpg_get_inst_index()\n");
  332. return -EINVAL;
  333. }
  334. if (!tfo->release_cmd) {
  335. pr_err("Missing tfo->release_cmd()\n");
  336. return -EINVAL;
  337. }
  338. if (!tfo->sess_get_index) {
  339. pr_err("Missing tfo->sess_get_index()\n");
  340. return -EINVAL;
  341. }
  342. if (!tfo->write_pending) {
  343. pr_err("Missing tfo->write_pending()\n");
  344. return -EINVAL;
  345. }
  346. if (!tfo->set_default_node_attributes) {
  347. pr_err("Missing tfo->set_default_node_attributes()\n");
  348. return -EINVAL;
  349. }
  350. if (!tfo->get_cmd_state) {
  351. pr_err("Missing tfo->get_cmd_state()\n");
  352. return -EINVAL;
  353. }
  354. if (!tfo->queue_data_in) {
  355. pr_err("Missing tfo->queue_data_in()\n");
  356. return -EINVAL;
  357. }
  358. if (!tfo->queue_status) {
  359. pr_err("Missing tfo->queue_status()\n");
  360. return -EINVAL;
  361. }
  362. if (!tfo->queue_tm_rsp) {
  363. pr_err("Missing tfo->queue_tm_rsp()\n");
  364. return -EINVAL;
  365. }
  366. if (!tfo->aborted_task) {
  367. pr_err("Missing tfo->aborted_task()\n");
  368. return -EINVAL;
  369. }
  370. if (!tfo->check_stop_free) {
  371. pr_err("Missing tfo->check_stop_free()\n");
  372. return -EINVAL;
  373. }
  374. /*
  375. * We at least require tfo->fabric_make_wwn(), tfo->fabric_drop_wwn()
  376. * tfo->fabric_make_tpg() and tfo->fabric_drop_tpg() in
  377. * target_core_fabric_configfs.c WWN+TPG group context code.
  378. */
  379. if (!tfo->fabric_make_wwn) {
  380. pr_err("Missing tfo->fabric_make_wwn()\n");
  381. return -EINVAL;
  382. }
  383. if (!tfo->fabric_drop_wwn) {
  384. pr_err("Missing tfo->fabric_drop_wwn()\n");
  385. return -EINVAL;
  386. }
  387. if (!tfo->fabric_make_tpg) {
  388. pr_err("Missing tfo->fabric_make_tpg()\n");
  389. return -EINVAL;
  390. }
  391. if (!tfo->fabric_drop_tpg) {
  392. pr_err("Missing tfo->fabric_drop_tpg()\n");
  393. return -EINVAL;
  394. }
  395. return 0;
  396. }
  397. int target_register_template(const struct target_core_fabric_ops *fo)
  398. {
  399. struct target_fabric_configfs *tf;
  400. int ret;
  401. ret = target_fabric_tf_ops_check(fo);
  402. if (ret)
  403. return ret;
  404. tf = kzalloc(sizeof(struct target_fabric_configfs), GFP_KERNEL);
  405. if (!tf) {
  406. pr_err("%s: could not allocate memory!\n", __func__);
  407. return -ENOMEM;
  408. }
  409. INIT_LIST_HEAD(&tf->tf_list);
  410. atomic_set(&tf->tf_access_cnt, 0);
  411. tf->tf_ops = fo;
  412. target_fabric_setup_cits(tf);
  413. mutex_lock(&g_tf_lock);
  414. list_add_tail(&tf->tf_list, &g_tf_list);
  415. mutex_unlock(&g_tf_lock);
  416. return 0;
  417. }
  418. EXPORT_SYMBOL(target_register_template);
  419. void target_unregister_template(const struct target_core_fabric_ops *fo)
  420. {
  421. struct target_fabric_configfs *t;
  422. mutex_lock(&g_tf_lock);
  423. list_for_each_entry(t, &g_tf_list, tf_list) {
  424. if (!strcmp(t->tf_ops->fabric_name, fo->fabric_name)) {
  425. BUG_ON(atomic_read(&t->tf_access_cnt));
  426. list_del(&t->tf_list);
  427. mutex_unlock(&g_tf_lock);
  428. /*
  429. * Wait for any outstanding fabric se_deve_entry->rcu_head
  430. * callbacks to complete post kfree_rcu(), before allowing
  431. * fabric driver unload of TFO->module to proceed.
  432. */
  433. rcu_barrier();
  434. kfree(t);
  435. return;
  436. }
  437. }
  438. mutex_unlock(&g_tf_lock);
  439. }
  440. EXPORT_SYMBOL(target_unregister_template);
  441. /*##############################################################################
  442. // Stop functions called by external Target Fabrics Modules
  443. //############################################################################*/
  444. static inline struct se_dev_attrib *to_attrib(struct config_item *item)
  445. {
  446. return container_of(to_config_group(item), struct se_dev_attrib,
  447. da_group);
  448. }
  449. /* Start functions for struct config_item_type tb_dev_attrib_cit */
  450. #define DEF_CONFIGFS_ATTRIB_SHOW(_name) \
  451. static ssize_t _name##_show(struct config_item *item, char *page) \
  452. { \
  453. return snprintf(page, PAGE_SIZE, "%u\n", to_attrib(item)->_name); \
  454. }
  455. DEF_CONFIGFS_ATTRIB_SHOW(emulate_model_alias);
  456. DEF_CONFIGFS_ATTRIB_SHOW(emulate_dpo);
  457. DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_write);
  458. DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_read);
  459. DEF_CONFIGFS_ATTRIB_SHOW(emulate_write_cache);
  460. DEF_CONFIGFS_ATTRIB_SHOW(emulate_ua_intlck_ctrl);
  461. DEF_CONFIGFS_ATTRIB_SHOW(emulate_tas);
  462. DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpu);
  463. DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpws);
  464. DEF_CONFIGFS_ATTRIB_SHOW(emulate_caw);
  465. DEF_CONFIGFS_ATTRIB_SHOW(emulate_3pc);
  466. DEF_CONFIGFS_ATTRIB_SHOW(emulate_pr);
  467. DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_type);
  468. DEF_CONFIGFS_ATTRIB_SHOW(hw_pi_prot_type);
  469. DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_verify);
  470. DEF_CONFIGFS_ATTRIB_SHOW(enforce_pr_isids);
  471. DEF_CONFIGFS_ATTRIB_SHOW(is_nonrot);
  472. DEF_CONFIGFS_ATTRIB_SHOW(emulate_rest_reord);
  473. DEF_CONFIGFS_ATTRIB_SHOW(force_pr_aptpl);
  474. DEF_CONFIGFS_ATTRIB_SHOW(hw_block_size);
  475. DEF_CONFIGFS_ATTRIB_SHOW(block_size);
  476. DEF_CONFIGFS_ATTRIB_SHOW(hw_max_sectors);
  477. DEF_CONFIGFS_ATTRIB_SHOW(optimal_sectors);
  478. DEF_CONFIGFS_ATTRIB_SHOW(hw_queue_depth);
  479. DEF_CONFIGFS_ATTRIB_SHOW(queue_depth);
  480. DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_lba_count);
  481. DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_block_desc_count);
  482. DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity);
  483. DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity_alignment);
  484. DEF_CONFIGFS_ATTRIB_SHOW(unmap_zeroes_data);
  485. DEF_CONFIGFS_ATTRIB_SHOW(max_write_same_len);
  486. #define DEF_CONFIGFS_ATTRIB_STORE_U32(_name) \
  487. static ssize_t _name##_store(struct config_item *item, const char *page,\
  488. size_t count) \
  489. { \
  490. struct se_dev_attrib *da = to_attrib(item); \
  491. u32 val; \
  492. int ret; \
  493. \
  494. ret = kstrtou32(page, 0, &val); \
  495. if (ret < 0) \
  496. return ret; \
  497. da->_name = val; \
  498. return count; \
  499. }
  500. DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_lba_count);
  501. DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_block_desc_count);
  502. DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity);
  503. DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity_alignment);
  504. DEF_CONFIGFS_ATTRIB_STORE_U32(max_write_same_len);
  505. #define DEF_CONFIGFS_ATTRIB_STORE_BOOL(_name) \
  506. static ssize_t _name##_store(struct config_item *item, const char *page, \
  507. size_t count) \
  508. { \
  509. struct se_dev_attrib *da = to_attrib(item); \
  510. bool flag; \
  511. int ret; \
  512. \
  513. ret = strtobool(page, &flag); \
  514. if (ret < 0) \
  515. return ret; \
  516. da->_name = flag; \
  517. return count; \
  518. }
  519. DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_fua_write);
  520. DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_caw);
  521. DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_3pc);
  522. DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_pr);
  523. DEF_CONFIGFS_ATTRIB_STORE_BOOL(enforce_pr_isids);
  524. DEF_CONFIGFS_ATTRIB_STORE_BOOL(is_nonrot);
  525. #define DEF_CONFIGFS_ATTRIB_STORE_STUB(_name) \
  526. static ssize_t _name##_store(struct config_item *item, const char *page,\
  527. size_t count) \
  528. { \
  529. printk_once(KERN_WARNING \
  530. "ignoring deprecated %s attribute\n", \
  531. __stringify(_name)); \
  532. return count; \
  533. }
  534. DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_dpo);
  535. DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_fua_read);
  536. static void dev_set_t10_wwn_model_alias(struct se_device *dev)
  537. {
  538. const char *configname;
  539. configname = config_item_name(&dev->dev_group.cg_item);
  540. if (strlen(configname) >= INQUIRY_MODEL_LEN) {
  541. pr_warn("dev[%p]: Backstore name '%s' is too long for "
  542. "INQUIRY_MODEL, truncating to 15 characters\n", dev,
  543. configname);
  544. }
  545. /*
  546. * XXX We can't use sizeof(dev->t10_wwn.model) (INQUIRY_MODEL_LEN + 1)
  547. * here without potentially breaking existing setups, so continue to
  548. * truncate one byte shorter than what can be carried in INQUIRY.
  549. */
  550. strlcpy(dev->t10_wwn.model, configname, INQUIRY_MODEL_LEN);
  551. }
  552. static ssize_t emulate_model_alias_store(struct config_item *item,
  553. const char *page, size_t count)
  554. {
  555. struct se_dev_attrib *da = to_attrib(item);
  556. struct se_device *dev = da->da_dev;
  557. bool flag;
  558. int ret;
  559. if (dev->export_count) {
  560. pr_err("dev[%p]: Unable to change model alias"
  561. " while export_count is %d\n",
  562. dev, dev->export_count);
  563. return -EINVAL;
  564. }
  565. ret = strtobool(page, &flag);
  566. if (ret < 0)
  567. return ret;
  568. BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1);
  569. if (flag) {
  570. dev_set_t10_wwn_model_alias(dev);
  571. } else {
  572. strlcpy(dev->t10_wwn.model, dev->transport->inquiry_prod,
  573. sizeof(dev->t10_wwn.model));
  574. }
  575. da->emulate_model_alias = flag;
  576. return count;
  577. }
  578. static ssize_t emulate_write_cache_store(struct config_item *item,
  579. const char *page, size_t count)
  580. {
  581. struct se_dev_attrib *da = to_attrib(item);
  582. bool flag;
  583. int ret;
  584. ret = strtobool(page, &flag);
  585. if (ret < 0)
  586. return ret;
  587. if (flag && da->da_dev->transport->get_write_cache) {
  588. pr_err("emulate_write_cache not supported for this device\n");
  589. return -EINVAL;
  590. }
  591. da->emulate_write_cache = flag;
  592. pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
  593. da->da_dev, flag);
  594. return count;
  595. }
  596. static ssize_t emulate_ua_intlck_ctrl_store(struct config_item *item,
  597. const char *page, size_t count)
  598. {
  599. struct se_dev_attrib *da = to_attrib(item);
  600. u32 val;
  601. int ret;
  602. ret = kstrtou32(page, 0, &val);
  603. if (ret < 0)
  604. return ret;
  605. if (val != TARGET_UA_INTLCK_CTRL_CLEAR
  606. && val != TARGET_UA_INTLCK_CTRL_NO_CLEAR
  607. && val != TARGET_UA_INTLCK_CTRL_ESTABLISH_UA) {
  608. pr_err("Illegal value %d\n", val);
  609. return -EINVAL;
  610. }
  611. if (da->da_dev->export_count) {
  612. pr_err("dev[%p]: Unable to change SE Device"
  613. " UA_INTRLCK_CTRL while export_count is %d\n",
  614. da->da_dev, da->da_dev->export_count);
  615. return -EINVAL;
  616. }
  617. da->emulate_ua_intlck_ctrl = val;
  618. pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
  619. da->da_dev, val);
  620. return count;
  621. }
  622. static ssize_t emulate_tas_store(struct config_item *item,
  623. const char *page, size_t count)
  624. {
  625. struct se_dev_attrib *da = to_attrib(item);
  626. bool flag;
  627. int ret;
  628. ret = strtobool(page, &flag);
  629. if (ret < 0)
  630. return ret;
  631. if (da->da_dev->export_count) {
  632. pr_err("dev[%p]: Unable to change SE Device TAS while"
  633. " export_count is %d\n",
  634. da->da_dev, da->da_dev->export_count);
  635. return -EINVAL;
  636. }
  637. da->emulate_tas = flag;
  638. pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
  639. da->da_dev, flag ? "Enabled" : "Disabled");
  640. return count;
  641. }
  642. static ssize_t emulate_tpu_store(struct config_item *item,
  643. const char *page, size_t count)
  644. {
  645. struct se_dev_attrib *da = to_attrib(item);
  646. bool flag;
  647. int ret;
  648. ret = strtobool(page, &flag);
  649. if (ret < 0)
  650. return ret;
  651. /*
  652. * We expect this value to be non-zero when generic Block Layer
  653. * Discard supported is detected iblock_create_virtdevice().
  654. */
  655. if (flag && !da->max_unmap_block_desc_count) {
  656. pr_err("Generic Block Discard not supported\n");
  657. return -ENOSYS;
  658. }
  659. da->emulate_tpu = flag;
  660. pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
  661. da->da_dev, flag);
  662. return count;
  663. }
  664. static ssize_t emulate_tpws_store(struct config_item *item,
  665. const char *page, size_t count)
  666. {
  667. struct se_dev_attrib *da = to_attrib(item);
  668. bool flag;
  669. int ret;
  670. ret = strtobool(page, &flag);
  671. if (ret < 0)
  672. return ret;
  673. /*
  674. * We expect this value to be non-zero when generic Block Layer
  675. * Discard supported is detected iblock_create_virtdevice().
  676. */
  677. if (flag && !da->max_unmap_block_desc_count) {
  678. pr_err("Generic Block Discard not supported\n");
  679. return -ENOSYS;
  680. }
  681. da->emulate_tpws = flag;
  682. pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
  683. da->da_dev, flag);
  684. return count;
  685. }
  686. static ssize_t pi_prot_type_store(struct config_item *item,
  687. const char *page, size_t count)
  688. {
  689. struct se_dev_attrib *da = to_attrib(item);
  690. int old_prot = da->pi_prot_type, ret;
  691. struct se_device *dev = da->da_dev;
  692. u32 flag;
  693. ret = kstrtou32(page, 0, &flag);
  694. if (ret < 0)
  695. return ret;
  696. if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {
  697. pr_err("Illegal value %d for pi_prot_type\n", flag);
  698. return -EINVAL;
  699. }
  700. if (flag == 2) {
  701. pr_err("DIF TYPE2 protection currently not supported\n");
  702. return -ENOSYS;
  703. }
  704. if (da->hw_pi_prot_type) {
  705. pr_warn("DIF protection enabled on underlying hardware,"
  706. " ignoring\n");
  707. return count;
  708. }
  709. if (!dev->transport->init_prot || !dev->transport->free_prot) {
  710. /* 0 is only allowed value for non-supporting backends */
  711. if (flag == 0)
  712. return count;
  713. pr_err("DIF protection not supported by backend: %s\n",
  714. dev->transport->name);
  715. return -ENOSYS;
  716. }
  717. if (!target_dev_configured(dev)) {
  718. pr_err("DIF protection requires device to be configured\n");
  719. return -ENODEV;
  720. }
  721. if (dev->export_count) {
  722. pr_err("dev[%p]: Unable to change SE Device PROT type while"
  723. " export_count is %d\n", dev, dev->export_count);
  724. return -EINVAL;
  725. }
  726. da->pi_prot_type = flag;
  727. if (flag && !old_prot) {
  728. ret = dev->transport->init_prot(dev);
  729. if (ret) {
  730. da->pi_prot_type = old_prot;
  731. da->pi_prot_verify = (bool) da->pi_prot_type;
  732. return ret;
  733. }
  734. } else if (!flag && old_prot) {
  735. dev->transport->free_prot(dev);
  736. }
  737. da->pi_prot_verify = (bool) da->pi_prot_type;
  738. pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);
  739. return count;
  740. }
  741. /* always zero, but attr needs to remain RW to avoid userspace breakage */
  742. static ssize_t pi_prot_format_show(struct config_item *item, char *page)
  743. {
  744. return snprintf(page, PAGE_SIZE, "0\n");
  745. }
  746. static ssize_t pi_prot_format_store(struct config_item *item,
  747. const char *page, size_t count)
  748. {
  749. struct se_dev_attrib *da = to_attrib(item);
  750. struct se_device *dev = da->da_dev;
  751. bool flag;
  752. int ret;
  753. ret = strtobool(page, &flag);
  754. if (ret < 0)
  755. return ret;
  756. if (!flag)
  757. return count;
  758. if (!dev->transport->format_prot) {
  759. pr_err("DIF protection format not supported by backend %s\n",
  760. dev->transport->name);
  761. return -ENOSYS;
  762. }
  763. if (!target_dev_configured(dev)) {
  764. pr_err("DIF protection format requires device to be configured\n");
  765. return -ENODEV;
  766. }
  767. if (dev->export_count) {
  768. pr_err("dev[%p]: Unable to format SE Device PROT type while"
  769. " export_count is %d\n", dev, dev->export_count);
  770. return -EINVAL;
  771. }
  772. ret = dev->transport->format_prot(dev);
  773. if (ret)
  774. return ret;
  775. pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);
  776. return count;
  777. }
  778. static ssize_t pi_prot_verify_store(struct config_item *item,
  779. const char *page, size_t count)
  780. {
  781. struct se_dev_attrib *da = to_attrib(item);
  782. bool flag;
  783. int ret;
  784. ret = strtobool(page, &flag);
  785. if (ret < 0)
  786. return ret;
  787. if (!flag) {
  788. da->pi_prot_verify = flag;
  789. return count;
  790. }
  791. if (da->hw_pi_prot_type) {
  792. pr_warn("DIF protection enabled on underlying hardware,"
  793. " ignoring\n");
  794. return count;
  795. }
  796. if (!da->pi_prot_type) {
  797. pr_warn("DIF protection not supported by backend, ignoring\n");
  798. return count;
  799. }
  800. da->pi_prot_verify = flag;
  801. return count;
  802. }
  803. static ssize_t force_pr_aptpl_store(struct config_item *item,
  804. const char *page, size_t count)
  805. {
  806. struct se_dev_attrib *da = to_attrib(item);
  807. bool flag;
  808. int ret;
  809. ret = strtobool(page, &flag);
  810. if (ret < 0)
  811. return ret;
  812. if (da->da_dev->export_count) {
  813. pr_err("dev[%p]: Unable to set force_pr_aptpl while"
  814. " export_count is %d\n",
  815. da->da_dev, da->da_dev->export_count);
  816. return -EINVAL;
  817. }
  818. da->force_pr_aptpl = flag;
  819. pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", da->da_dev, flag);
  820. return count;
  821. }
  822. static ssize_t emulate_rest_reord_store(struct config_item *item,
  823. const char *page, size_t count)
  824. {
  825. struct se_dev_attrib *da = to_attrib(item);
  826. bool flag;
  827. int ret;
  828. ret = strtobool(page, &flag);
  829. if (ret < 0)
  830. return ret;
  831. if (flag != 0) {
  832. printk(KERN_ERR "dev[%p]: SE Device emulation of restricted"
  833. " reordering not implemented\n", da->da_dev);
  834. return -ENOSYS;
  835. }
  836. da->emulate_rest_reord = flag;
  837. pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n",
  838. da->da_dev, flag);
  839. return count;
  840. }
  841. static ssize_t unmap_zeroes_data_store(struct config_item *item,
  842. const char *page, size_t count)
  843. {
  844. struct se_dev_attrib *da = to_attrib(item);
  845. bool flag;
  846. int ret;
  847. ret = strtobool(page, &flag);
  848. if (ret < 0)
  849. return ret;
  850. if (da->da_dev->export_count) {
  851. pr_err("dev[%p]: Unable to change SE Device"
  852. " unmap_zeroes_data while export_count is %d\n",
  853. da->da_dev, da->da_dev->export_count);
  854. return -EINVAL;
  855. }
  856. /*
  857. * We expect this value to be non-zero when generic Block Layer
  858. * Discard supported is detected iblock_configure_device().
  859. */
  860. if (flag && !da->max_unmap_block_desc_count) {
  861. pr_err("dev[%p]: Thin Provisioning LBPRZ will not be set"
  862. " because max_unmap_block_desc_count is zero\n",
  863. da->da_dev);
  864. return -ENOSYS;
  865. }
  866. da->unmap_zeroes_data = flag;
  867. pr_debug("dev[%p]: SE Device Thin Provisioning LBPRZ bit: %d\n",
  868. da->da_dev, flag);
  869. return count;
  870. }
  871. /*
  872. * Note, this can only be called on unexported SE Device Object.
  873. */
  874. static ssize_t queue_depth_store(struct config_item *item,
  875. const char *page, size_t count)
  876. {
  877. struct se_dev_attrib *da = to_attrib(item);
  878. struct se_device *dev = da->da_dev;
  879. u32 val;
  880. int ret;
  881. ret = kstrtou32(page, 0, &val);
  882. if (ret < 0)
  883. return ret;
  884. if (dev->export_count) {
  885. pr_err("dev[%p]: Unable to change SE Device TCQ while"
  886. " export_count is %d\n",
  887. dev, dev->export_count);
  888. return -EINVAL;
  889. }
  890. if (!val) {
  891. pr_err("dev[%p]: Illegal ZERO value for queue_depth\n", dev);
  892. return -EINVAL;
  893. }
  894. if (val > dev->dev_attrib.queue_depth) {
  895. if (val > dev->dev_attrib.hw_queue_depth) {
  896. pr_err("dev[%p]: Passed queue_depth:"
  897. " %u exceeds TCM/SE_Device MAX"
  898. " TCQ: %u\n", dev, val,
  899. dev->dev_attrib.hw_queue_depth);
  900. return -EINVAL;
  901. }
  902. }
  903. da->queue_depth = dev->queue_depth = val;
  904. pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n", dev, val);
  905. return count;
  906. }
  907. static ssize_t optimal_sectors_store(struct config_item *item,
  908. const char *page, size_t count)
  909. {
  910. struct se_dev_attrib *da = to_attrib(item);
  911. u32 val;
  912. int ret;
  913. ret = kstrtou32(page, 0, &val);
  914. if (ret < 0)
  915. return ret;
  916. if (da->da_dev->export_count) {
  917. pr_err("dev[%p]: Unable to change SE Device"
  918. " optimal_sectors while export_count is %d\n",
  919. da->da_dev, da->da_dev->export_count);
  920. return -EINVAL;
  921. }
  922. if (val > da->hw_max_sectors) {
  923. pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
  924. " greater than hw_max_sectors: %u\n",
  925. da->da_dev, val, da->hw_max_sectors);
  926. return -EINVAL;
  927. }
  928. da->optimal_sectors = val;
  929. pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
  930. da->da_dev, val);
  931. return count;
  932. }
  933. static ssize_t block_size_store(struct config_item *item,
  934. const char *page, size_t count)
  935. {
  936. struct se_dev_attrib *da = to_attrib(item);
  937. u32 val;
  938. int ret;
  939. ret = kstrtou32(page, 0, &val);
  940. if (ret < 0)
  941. return ret;
  942. if (da->da_dev->export_count) {
  943. pr_err("dev[%p]: Unable to change SE Device block_size"
  944. " while export_count is %d\n",
  945. da->da_dev, da->da_dev->export_count);
  946. return -EINVAL;
  947. }
  948. if (val != 512 && val != 1024 && val != 2048 && val != 4096) {
  949. pr_err("dev[%p]: Illegal value for block_device: %u"
  950. " for SE device, must be 512, 1024, 2048 or 4096\n",
  951. da->da_dev, val);
  952. return -EINVAL;
  953. }
  954. da->block_size = val;
  955. if (da->max_bytes_per_io)
  956. da->hw_max_sectors = da->max_bytes_per_io / val;
  957. pr_debug("dev[%p]: SE Device block_size changed to %u\n",
  958. da->da_dev, val);
  959. return count;
  960. }
  961. static ssize_t alua_support_show(struct config_item *item, char *page)
  962. {
  963. struct se_dev_attrib *da = to_attrib(item);
  964. u8 flags = da->da_dev->transport_flags;
  965. return snprintf(page, PAGE_SIZE, "%d\n",
  966. flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA ? 0 : 1);
  967. }
  968. static ssize_t alua_support_store(struct config_item *item,
  969. const char *page, size_t count)
  970. {
  971. struct se_dev_attrib *da = to_attrib(item);
  972. struct se_device *dev = da->da_dev;
  973. bool flag, oldflag;
  974. int ret;
  975. ret = strtobool(page, &flag);
  976. if (ret < 0)
  977. return ret;
  978. oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA);
  979. if (flag == oldflag)
  980. return count;
  981. if (!(dev->transport->transport_flags_changeable &
  982. TRANSPORT_FLAG_PASSTHROUGH_ALUA)) {
  983. pr_err("dev[%p]: Unable to change SE Device alua_support:"
  984. " alua_support has fixed value\n", dev);
  985. return -ENOSYS;
  986. }
  987. if (flag)
  988. dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_ALUA;
  989. else
  990. dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_ALUA;
  991. return count;
  992. }
  993. static ssize_t pgr_support_show(struct config_item *item, char *page)
  994. {
  995. struct se_dev_attrib *da = to_attrib(item);
  996. u8 flags = da->da_dev->transport_flags;
  997. return snprintf(page, PAGE_SIZE, "%d\n",
  998. flags & TRANSPORT_FLAG_PASSTHROUGH_PGR ? 0 : 1);
  999. }
  1000. static ssize_t pgr_support_store(struct config_item *item,
  1001. const char *page, size_t count)
  1002. {
  1003. struct se_dev_attrib *da = to_attrib(item);
  1004. struct se_device *dev = da->da_dev;
  1005. bool flag, oldflag;
  1006. int ret;
  1007. ret = strtobool(page, &flag);
  1008. if (ret < 0)
  1009. return ret;
  1010. oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR);
  1011. if (flag == oldflag)
  1012. return count;
  1013. if (!(dev->transport->transport_flags_changeable &
  1014. TRANSPORT_FLAG_PASSTHROUGH_PGR)) {
  1015. pr_err("dev[%p]: Unable to change SE Device pgr_support:"
  1016. " pgr_support has fixed value\n", dev);
  1017. return -ENOSYS;
  1018. }
  1019. if (flag)
  1020. dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_PGR;
  1021. else
  1022. dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_PGR;
  1023. return count;
  1024. }
  1025. CONFIGFS_ATTR(, emulate_model_alias);
  1026. CONFIGFS_ATTR(, emulate_dpo);
  1027. CONFIGFS_ATTR(, emulate_fua_write);
  1028. CONFIGFS_ATTR(, emulate_fua_read);
  1029. CONFIGFS_ATTR(, emulate_write_cache);
  1030. CONFIGFS_ATTR(, emulate_ua_intlck_ctrl);
  1031. CONFIGFS_ATTR(, emulate_tas);
  1032. CONFIGFS_ATTR(, emulate_tpu);
  1033. CONFIGFS_ATTR(, emulate_tpws);
  1034. CONFIGFS_ATTR(, emulate_caw);
  1035. CONFIGFS_ATTR(, emulate_3pc);
  1036. CONFIGFS_ATTR(, emulate_pr);
  1037. CONFIGFS_ATTR(, pi_prot_type);
  1038. CONFIGFS_ATTR_RO(, hw_pi_prot_type);
  1039. CONFIGFS_ATTR(, pi_prot_format);
  1040. CONFIGFS_ATTR(, pi_prot_verify);
  1041. CONFIGFS_ATTR(, enforce_pr_isids);
  1042. CONFIGFS_ATTR(, is_nonrot);
  1043. CONFIGFS_ATTR(, emulate_rest_reord);
  1044. CONFIGFS_ATTR(, force_pr_aptpl);
  1045. CONFIGFS_ATTR_RO(, hw_block_size);
  1046. CONFIGFS_ATTR(, block_size);
  1047. CONFIGFS_ATTR_RO(, hw_max_sectors);
  1048. CONFIGFS_ATTR(, optimal_sectors);
  1049. CONFIGFS_ATTR_RO(, hw_queue_depth);
  1050. CONFIGFS_ATTR(, queue_depth);
  1051. CONFIGFS_ATTR(, max_unmap_lba_count);
  1052. CONFIGFS_ATTR(, max_unmap_block_desc_count);
  1053. CONFIGFS_ATTR(, unmap_granularity);
  1054. CONFIGFS_ATTR(, unmap_granularity_alignment);
  1055. CONFIGFS_ATTR(, unmap_zeroes_data);
  1056. CONFIGFS_ATTR(, max_write_same_len);
  1057. CONFIGFS_ATTR(, alua_support);
  1058. CONFIGFS_ATTR(, pgr_support);
  1059. /*
  1060. * dev_attrib attributes for devices using the target core SBC/SPC
  1061. * interpreter. Any backend using spc_parse_cdb should be using
  1062. * these.
  1063. */
  1064. struct configfs_attribute *sbc_attrib_attrs[] = {
  1065. &attr_emulate_model_alias,
  1066. &attr_emulate_dpo,
  1067. &attr_emulate_fua_write,
  1068. &attr_emulate_fua_read,
  1069. &attr_emulate_write_cache,
  1070. &attr_emulate_ua_intlck_ctrl,
  1071. &attr_emulate_tas,
  1072. &attr_emulate_tpu,
  1073. &attr_emulate_tpws,
  1074. &attr_emulate_caw,
  1075. &attr_emulate_3pc,
  1076. &attr_emulate_pr,
  1077. &attr_pi_prot_type,
  1078. &attr_hw_pi_prot_type,
  1079. &attr_pi_prot_format,
  1080. &attr_pi_prot_verify,
  1081. &attr_enforce_pr_isids,
  1082. &attr_is_nonrot,
  1083. &attr_emulate_rest_reord,
  1084. &attr_force_pr_aptpl,
  1085. &attr_hw_block_size,
  1086. &attr_block_size,
  1087. &attr_hw_max_sectors,
  1088. &attr_optimal_sectors,
  1089. &attr_hw_queue_depth,
  1090. &attr_queue_depth,
  1091. &attr_max_unmap_lba_count,
  1092. &attr_max_unmap_block_desc_count,
  1093. &attr_unmap_granularity,
  1094. &attr_unmap_granularity_alignment,
  1095. &attr_unmap_zeroes_data,
  1096. &attr_max_write_same_len,
  1097. &attr_alua_support,
  1098. &attr_pgr_support,
  1099. NULL,
  1100. };
  1101. EXPORT_SYMBOL(sbc_attrib_attrs);
  1102. /*
  1103. * Minimal dev_attrib attributes for devices passing through CDBs.
  1104. * In this case we only provide a few read-only attributes for
  1105. * backwards compatibility.
  1106. */
  1107. struct configfs_attribute *passthrough_attrib_attrs[] = {
  1108. &attr_hw_pi_prot_type,
  1109. &attr_hw_block_size,
  1110. &attr_hw_max_sectors,
  1111. &attr_hw_queue_depth,
  1112. &attr_emulate_pr,
  1113. &attr_alua_support,
  1114. &attr_pgr_support,
  1115. NULL,
  1116. };
  1117. EXPORT_SYMBOL(passthrough_attrib_attrs);
  1118. /*
  1119. * pr related dev_attrib attributes for devices passing through CDBs,
  1120. * but allowing in core pr emulation.
  1121. */
  1122. struct configfs_attribute *passthrough_pr_attrib_attrs[] = {
  1123. &attr_enforce_pr_isids,
  1124. &attr_force_pr_aptpl,
  1125. NULL,
  1126. };
  1127. EXPORT_SYMBOL(passthrough_pr_attrib_attrs);
  1128. TB_CIT_SETUP_DRV(dev_attrib, NULL, NULL);
  1129. TB_CIT_SETUP_DRV(dev_action, NULL, NULL);
  1130. /* End functions for struct config_item_type tb_dev_attrib_cit */
  1131. /* Start functions for struct config_item_type tb_dev_wwn_cit */
  1132. static struct t10_wwn *to_t10_wwn(struct config_item *item)
  1133. {
  1134. return container_of(to_config_group(item), struct t10_wwn, t10_wwn_group);
  1135. }
  1136. static ssize_t target_check_inquiry_data(char *buf)
  1137. {
  1138. size_t len;
  1139. int i;
  1140. len = strlen(buf);
  1141. /*
  1142. * SPC 4.3.1:
  1143. * ASCII data fields shall contain only ASCII printable characters
  1144. * (i.e., code values 20h to 7Eh) and may be terminated with one or
  1145. * more ASCII null (00h) characters.
  1146. */
  1147. for (i = 0; i < len; i++) {
  1148. if (buf[i] < 0x20 || buf[i] > 0x7E) {
  1149. pr_err("Emulated T10 Inquiry Data contains non-ASCII-printable characters\n");
  1150. return -EINVAL;
  1151. }
  1152. }
  1153. return len;
  1154. }
  1155. /*
  1156. * STANDARD and VPD page 0x83 T10 Vendor Identification
  1157. */
  1158. static ssize_t target_wwn_vendor_id_show(struct config_item *item,
  1159. char *page)
  1160. {
  1161. return sprintf(page, "%s\n", &to_t10_wwn(item)->vendor[0]);
  1162. }
  1163. static ssize_t target_wwn_vendor_id_store(struct config_item *item,
  1164. const char *page, size_t count)
  1165. {
  1166. struct t10_wwn *t10_wwn = to_t10_wwn(item);
  1167. struct se_device *dev = t10_wwn->t10_dev;
  1168. /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
  1169. unsigned char buf[INQUIRY_VENDOR_LEN + 2];
  1170. char *stripped = NULL;
  1171. size_t len;
  1172. ssize_t ret;
  1173. len = strlcpy(buf, page, sizeof(buf));
  1174. if (len < sizeof(buf)) {
  1175. /* Strip any newline added from userspace. */
  1176. stripped = strstrip(buf);
  1177. len = strlen(stripped);
  1178. }
  1179. if (len > INQUIRY_VENDOR_LEN) {
  1180. pr_err("Emulated T10 Vendor Identification exceeds"
  1181. " INQUIRY_VENDOR_LEN: " __stringify(INQUIRY_VENDOR_LEN)
  1182. "\n");
  1183. return -EOVERFLOW;
  1184. }
  1185. ret = target_check_inquiry_data(stripped);
  1186. if (ret < 0)
  1187. return ret;
  1188. /*
  1189. * Check to see if any active exports exist. If they do exist, fail
  1190. * here as changing this information on the fly (underneath the
  1191. * initiator side OS dependent multipath code) could cause negative
  1192. * effects.
  1193. */
  1194. if (dev->export_count) {
  1195. pr_err("Unable to set T10 Vendor Identification while"
  1196. " active %d exports exist\n", dev->export_count);
  1197. return -EINVAL;
  1198. }
  1199. BUILD_BUG_ON(sizeof(dev->t10_wwn.vendor) != INQUIRY_VENDOR_LEN + 1);
  1200. strlcpy(dev->t10_wwn.vendor, stripped, sizeof(dev->t10_wwn.vendor));
  1201. pr_debug("Target_Core_ConfigFS: Set emulated T10 Vendor Identification:"
  1202. " %s\n", dev->t10_wwn.vendor);
  1203. return count;
  1204. }
  1205. static ssize_t target_wwn_product_id_show(struct config_item *item,
  1206. char *page)
  1207. {
  1208. return sprintf(page, "%s\n", &to_t10_wwn(item)->model[0]);
  1209. }
  1210. static ssize_t target_wwn_product_id_store(struct config_item *item,
  1211. const char *page, size_t count)
  1212. {
  1213. struct t10_wwn *t10_wwn = to_t10_wwn(item);
  1214. struct se_device *dev = t10_wwn->t10_dev;
  1215. /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
  1216. unsigned char buf[INQUIRY_MODEL_LEN + 2];
  1217. char *stripped = NULL;
  1218. size_t len;
  1219. ssize_t ret;
  1220. len = strlcpy(buf, page, sizeof(buf));
  1221. if (len < sizeof(buf)) {
  1222. /* Strip any newline added from userspace. */
  1223. stripped = strstrip(buf);
  1224. len = strlen(stripped);
  1225. }
  1226. if (len > INQUIRY_MODEL_LEN) {
  1227. pr_err("Emulated T10 Vendor exceeds INQUIRY_MODEL_LEN: "
  1228. __stringify(INQUIRY_MODEL_LEN)
  1229. "\n");
  1230. return -EOVERFLOW;
  1231. }
  1232. ret = target_check_inquiry_data(stripped);
  1233. if (ret < 0)
  1234. return ret;
  1235. /*
  1236. * Check to see if any active exports exist. If they do exist, fail
  1237. * here as changing this information on the fly (underneath the
  1238. * initiator side OS dependent multipath code) could cause negative
  1239. * effects.
  1240. */
  1241. if (dev->export_count) {
  1242. pr_err("Unable to set T10 Model while active %d exports exist\n",
  1243. dev->export_count);
  1244. return -EINVAL;
  1245. }
  1246. BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1);
  1247. strlcpy(dev->t10_wwn.model, stripped, sizeof(dev->t10_wwn.model));
  1248. pr_debug("Target_Core_ConfigFS: Set emulated T10 Model Identification: %s\n",
  1249. dev->t10_wwn.model);
  1250. return count;
  1251. }
  1252. static ssize_t target_wwn_revision_show(struct config_item *item,
  1253. char *page)
  1254. {
  1255. return sprintf(page, "%s\n", &to_t10_wwn(item)->revision[0]);
  1256. }
  1257. static ssize_t target_wwn_revision_store(struct config_item *item,
  1258. const char *page, size_t count)
  1259. {
  1260. struct t10_wwn *t10_wwn = to_t10_wwn(item);
  1261. struct se_device *dev = t10_wwn->t10_dev;
  1262. /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
  1263. unsigned char buf[INQUIRY_REVISION_LEN + 2];
  1264. char *stripped = NULL;
  1265. size_t len;
  1266. ssize_t ret;
  1267. len = strlcpy(buf, page, sizeof(buf));
  1268. if (len < sizeof(buf)) {
  1269. /* Strip any newline added from userspace. */
  1270. stripped = strstrip(buf);
  1271. len = strlen(stripped);
  1272. }
  1273. if (len > INQUIRY_REVISION_LEN) {
  1274. pr_err("Emulated T10 Revision exceeds INQUIRY_REVISION_LEN: "
  1275. __stringify(INQUIRY_REVISION_LEN)
  1276. "\n");
  1277. return -EOVERFLOW;
  1278. }
  1279. ret = target_check_inquiry_data(stripped);
  1280. if (ret < 0)
  1281. return ret;
  1282. /*
  1283. * Check to see if any active exports exist. If they do exist, fail
  1284. * here as changing this information on the fly (underneath the
  1285. * initiator side OS dependent multipath code) could cause negative
  1286. * effects.
  1287. */
  1288. if (dev->export_count) {
  1289. pr_err("Unable to set T10 Revision while active %d exports exist\n",
  1290. dev->export_count);
  1291. return -EINVAL;
  1292. }
  1293. BUILD_BUG_ON(sizeof(dev->t10_wwn.revision) != INQUIRY_REVISION_LEN + 1);
  1294. strlcpy(dev->t10_wwn.revision, stripped, sizeof(dev->t10_wwn.revision));
  1295. pr_debug("Target_Core_ConfigFS: Set emulated T10 Revision: %s\n",
  1296. dev->t10_wwn.revision);
  1297. return count;
  1298. }
  1299. /*
  1300. * VPD page 0x80 Unit serial
  1301. */
  1302. static ssize_t target_wwn_vpd_unit_serial_show(struct config_item *item,
  1303. char *page)
  1304. {
  1305. return sprintf(page, "T10 VPD Unit Serial Number: %s\n",
  1306. &to_t10_wwn(item)->unit_serial[0]);
  1307. }
  1308. static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item,
  1309. const char *page, size_t count)
  1310. {
  1311. struct t10_wwn *t10_wwn = to_t10_wwn(item);
  1312. struct se_device *dev = t10_wwn->t10_dev;
  1313. unsigned char buf[INQUIRY_VPD_SERIAL_LEN];
  1314. /*
  1315. * If Linux/SCSI subsystem_api_t plugin got a VPD Unit Serial
  1316. * from the struct scsi_device level firmware, do not allow
  1317. * VPD Unit Serial to be emulated.
  1318. *
  1319. * Note this struct scsi_device could also be emulating VPD
  1320. * information from its drivers/scsi LLD. But for now we assume
  1321. * it is doing 'the right thing' wrt a world wide unique
  1322. * VPD Unit Serial Number that OS dependent multipath can depend on.
  1323. */
  1324. if (dev->dev_flags & DF_FIRMWARE_VPD_UNIT_SERIAL) {
  1325. pr_err("Underlying SCSI device firmware provided VPD"
  1326. " Unit Serial, ignoring request\n");
  1327. return -EOPNOTSUPP;
  1328. }
  1329. if (strlen(page) >= INQUIRY_VPD_SERIAL_LEN) {
  1330. pr_err("Emulated VPD Unit Serial exceeds"
  1331. " INQUIRY_VPD_SERIAL_LEN: %d\n", INQUIRY_VPD_SERIAL_LEN);
  1332. return -EOVERFLOW;
  1333. }
  1334. /*
  1335. * Check to see if any active $FABRIC_MOD exports exist. If they
  1336. * do exist, fail here as changing this information on the fly
  1337. * (underneath the initiator side OS dependent multipath code)
  1338. * could cause negative effects.
  1339. */
  1340. if (dev->export_count) {
  1341. pr_err("Unable to set VPD Unit Serial while"
  1342. " active %d $FABRIC_MOD exports exist\n",
  1343. dev->export_count);
  1344. return -EINVAL;
  1345. }
  1346. /*
  1347. * This currently assumes ASCII encoding for emulated VPD Unit Serial.
  1348. *
  1349. * Also, strip any newline added from the userspace
  1350. * echo $UUID > $TARGET/$HBA/$STORAGE_OBJECT/wwn/vpd_unit_serial
  1351. */
  1352. memset(buf, 0, INQUIRY_VPD_SERIAL_LEN);
  1353. snprintf(buf, INQUIRY_VPD_SERIAL_LEN, "%s", page);
  1354. snprintf(dev->t10_wwn.unit_serial, INQUIRY_VPD_SERIAL_LEN,
  1355. "%s", strstrip(buf));
  1356. dev->dev_flags |= DF_EMULATED_VPD_UNIT_SERIAL;
  1357. pr_debug("Target_Core_ConfigFS: Set emulated VPD Unit Serial:"
  1358. " %s\n", dev->t10_wwn.unit_serial);
  1359. return count;
  1360. }
  1361. /*
  1362. * VPD page 0x83 Protocol Identifier
  1363. */
  1364. static ssize_t target_wwn_vpd_protocol_identifier_show(struct config_item *item,
  1365. char *page)
  1366. {
  1367. struct t10_wwn *t10_wwn = to_t10_wwn(item);
  1368. struct t10_vpd *vpd;
  1369. unsigned char buf[VPD_TMP_BUF_SIZE];
  1370. ssize_t len = 0;
  1371. memset(buf, 0, VPD_TMP_BUF_SIZE);
  1372. spin_lock(&t10_wwn->t10_vpd_lock);
  1373. list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) {
  1374. if (!vpd->protocol_identifier_set)
  1375. continue;
  1376. transport_dump_vpd_proto_id(vpd, buf, VPD_TMP_BUF_SIZE);
  1377. if (len + strlen(buf) >= PAGE_SIZE)
  1378. break;
  1379. len += sprintf(page+len, "%s", buf);
  1380. }
  1381. spin_unlock(&t10_wwn->t10_vpd_lock);
  1382. return len;
  1383. }
  1384. /*
  1385. * Generic wrapper for dumping VPD identifiers by association.
  1386. */
  1387. #define DEF_DEV_WWN_ASSOC_SHOW(_name, _assoc) \
  1388. static ssize_t target_wwn_##_name##_show(struct config_item *item, \
  1389. char *page) \
  1390. { \
  1391. struct t10_wwn *t10_wwn = to_t10_wwn(item); \
  1392. struct t10_vpd *vpd; \
  1393. unsigned char buf[VPD_TMP_BUF_SIZE]; \
  1394. ssize_t len = 0; \
  1395. \
  1396. spin_lock(&t10_wwn->t10_vpd_lock); \
  1397. list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) { \
  1398. if (vpd->association != _assoc) \
  1399. continue; \
  1400. \
  1401. memset(buf, 0, VPD_TMP_BUF_SIZE); \
  1402. transport_dump_vpd_assoc(vpd, buf, VPD_TMP_BUF_SIZE); \
  1403. if (len + strlen(buf) >= PAGE_SIZE) \
  1404. break; \
  1405. len += sprintf(page+len, "%s", buf); \
  1406. \
  1407. memset(buf, 0, VPD_TMP_BUF_SIZE); \
  1408. transport_dump_vpd_ident_type(vpd, buf, VPD_TMP_BUF_SIZE); \
  1409. if (len + strlen(buf) >= PAGE_SIZE) \
  1410. break; \
  1411. len += sprintf(page+len, "%s", buf); \
  1412. \
  1413. memset(buf, 0, VPD_TMP_BUF_SIZE); \
  1414. transport_dump_vpd_ident(vpd, buf, VPD_TMP_BUF_SIZE); \
  1415. if (len + strlen(buf) >= PAGE_SIZE) \
  1416. break; \
  1417. len += sprintf(page+len, "%s", buf); \
  1418. } \
  1419. spin_unlock(&t10_wwn->t10_vpd_lock); \
  1420. \
  1421. return len; \
  1422. }
  1423. /* VPD page 0x83 Association: Logical Unit */
  1424. DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_logical_unit, 0x00);
  1425. /* VPD page 0x83 Association: Target Port */
  1426. DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_target_port, 0x10);
  1427. /* VPD page 0x83 Association: SCSI Target Device */
  1428. DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_scsi_target_device, 0x20);
  1429. CONFIGFS_ATTR(target_wwn_, vendor_id);
  1430. CONFIGFS_ATTR(target_wwn_, product_id);
  1431. CONFIGFS_ATTR(target_wwn_, revision);
  1432. CONFIGFS_ATTR(target_wwn_, vpd_unit_serial);
  1433. CONFIGFS_ATTR_RO(target_wwn_, vpd_protocol_identifier);
  1434. CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_logical_unit);
  1435. CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_target_port);
  1436. CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_scsi_target_device);
  1437. static struct configfs_attribute *target_core_dev_wwn_attrs[] = {
  1438. &target_wwn_attr_vendor_id,
  1439. &target_wwn_attr_product_id,
  1440. &target_wwn_attr_revision,
  1441. &target_wwn_attr_vpd_unit_serial,
  1442. &target_wwn_attr_vpd_protocol_identifier,
  1443. &target_wwn_attr_vpd_assoc_logical_unit,
  1444. &target_wwn_attr_vpd_assoc_target_port,
  1445. &target_wwn_attr_vpd_assoc_scsi_target_device,
  1446. NULL,
  1447. };
  1448. TB_CIT_SETUP(dev_wwn, NULL, NULL, target_core_dev_wwn_attrs);
  1449. /* End functions for struct config_item_type tb_dev_wwn_cit */
  1450. /* Start functions for struct config_item_type tb_dev_pr_cit */
  1451. static struct se_device *pr_to_dev(struct config_item *item)
  1452. {
  1453. return container_of(to_config_group(item), struct se_device,
  1454. dev_pr_group);
  1455. }
  1456. static ssize_t target_core_dev_pr_show_spc3_res(struct se_device *dev,
  1457. char *page)
  1458. {
  1459. struct se_node_acl *se_nacl;
  1460. struct t10_pr_registration *pr_reg;
  1461. char i_buf[PR_REG_ISID_ID_LEN];
  1462. memset(i_buf, 0, PR_REG_ISID_ID_LEN);
  1463. pr_reg = dev->dev_pr_res_holder;
  1464. if (!pr_reg)
  1465. return sprintf(page, "No SPC-3 Reservation holder\n");
  1466. se_nacl = pr_reg->pr_reg_nacl;
  1467. core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
  1468. return sprintf(page, "SPC-3 Reservation: %s Initiator: %s%s\n",
  1469. se_nacl->se_tpg->se_tpg_tfo->fabric_name,
  1470. se_nacl->initiatorname, i_buf);
  1471. }
  1472. static ssize_t target_core_dev_pr_show_spc2_res(struct se_device *dev,
  1473. char *page)
  1474. {
  1475. struct se_session *sess = dev->reservation_holder;
  1476. struct se_node_acl *se_nacl;
  1477. ssize_t len;
  1478. if (sess) {
  1479. se_nacl = sess->se_node_acl;
  1480. len = sprintf(page,
  1481. "SPC-2 Reservation: %s Initiator: %s\n",
  1482. se_nacl->se_tpg->se_tpg_tfo->fabric_name,
  1483. se_nacl->initiatorname);
  1484. } else {
  1485. len = sprintf(page, "No SPC-2 Reservation holder\n");
  1486. }
  1487. return len;
  1488. }
  1489. static ssize_t target_pr_res_holder_show(struct config_item *item, char *page)
  1490. {
  1491. struct se_device *dev = pr_to_dev(item);
  1492. int ret;
  1493. if (!dev->dev_attrib.emulate_pr)
  1494. return sprintf(page, "SPC_RESERVATIONS_DISABLED\n");
  1495. if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)
  1496. return sprintf(page, "Passthrough\n");
  1497. spin_lock(&dev->dev_reservation_lock);
  1498. if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
  1499. ret = target_core_dev_pr_show_spc2_res(dev, page);
  1500. else
  1501. ret = target_core_dev_pr_show_spc3_res(dev, page);
  1502. spin_unlock(&dev->dev_reservation_lock);
  1503. return ret;
  1504. }
  1505. static ssize_t target_pr_res_pr_all_tgt_pts_show(struct config_item *item,
  1506. char *page)
  1507. {
  1508. struct se_device *dev = pr_to_dev(item);
  1509. ssize_t len = 0;
  1510. spin_lock(&dev->dev_reservation_lock);
  1511. if (!dev->dev_pr_res_holder) {
  1512. len = sprintf(page, "No SPC-3 Reservation holder\n");
  1513. } else if (dev->dev_pr_res_holder->pr_reg_all_tg_pt) {
  1514. len = sprintf(page, "SPC-3 Reservation: All Target"
  1515. " Ports registration\n");
  1516. } else {
  1517. len = sprintf(page, "SPC-3 Reservation: Single"
  1518. " Target Port registration\n");
  1519. }
  1520. spin_unlock(&dev->dev_reservation_lock);
  1521. return len;
  1522. }
  1523. static ssize_t target_pr_res_pr_generation_show(struct config_item *item,
  1524. char *page)
  1525. {
  1526. return sprintf(page, "0x%08x\n", pr_to_dev(item)->t10_pr.pr_generation);
  1527. }
  1528. static ssize_t target_pr_res_pr_holder_tg_port_show(struct config_item *item,
  1529. char *page)
  1530. {
  1531. struct se_device *dev = pr_to_dev(item);
  1532. struct se_node_acl *se_nacl;
  1533. struct se_portal_group *se_tpg;
  1534. struct t10_pr_registration *pr_reg;
  1535. const struct target_core_fabric_ops *tfo;
  1536. ssize_t len = 0;
  1537. spin_lock(&dev->dev_reservation_lock);
  1538. pr_reg = dev->dev_pr_res_holder;
  1539. if (!pr_reg) {
  1540. len = sprintf(page, "No SPC-3 Reservation holder\n");
  1541. goto out_unlock;
  1542. }
  1543. se_nacl = pr_reg->pr_reg_nacl;
  1544. se_tpg = se_nacl->se_tpg;
  1545. tfo = se_tpg->se_tpg_tfo;
  1546. len += sprintf(page+len, "SPC-3 Reservation: %s"
  1547. " Target Node Endpoint: %s\n", tfo->fabric_name,
  1548. tfo->tpg_get_wwn(se_tpg));
  1549. len += sprintf(page+len, "SPC-3 Reservation: Relative Port"
  1550. " Identifier Tag: %hu %s Portal Group Tag: %hu"
  1551. " %s Logical Unit: %llu\n", pr_reg->tg_pt_sep_rtpi,
  1552. tfo->fabric_name, tfo->tpg_get_tag(se_tpg),
  1553. tfo->fabric_name, pr_reg->pr_aptpl_target_lun);
  1554. out_unlock:
  1555. spin_unlock(&dev->dev_reservation_lock);
  1556. return len;
  1557. }
  1558. static ssize_t target_pr_res_pr_registered_i_pts_show(struct config_item *item,
  1559. char *page)
  1560. {
  1561. struct se_device *dev = pr_to_dev(item);
  1562. const struct target_core_fabric_ops *tfo;
  1563. struct t10_pr_registration *pr_reg;
  1564. unsigned char buf[384];
  1565. char i_buf[PR_REG_ISID_ID_LEN];
  1566. ssize_t len = 0;
  1567. int reg_count = 0;
  1568. len += sprintf(page+len, "SPC-3 PR Registrations:\n");
  1569. spin_lock(&dev->t10_pr.registration_lock);
  1570. list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
  1571. pr_reg_list) {
  1572. memset(buf, 0, 384);
  1573. memset(i_buf, 0, PR_REG_ISID_ID_LEN);
  1574. tfo = pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
  1575. core_pr_dump_initiator_port(pr_reg, i_buf,
  1576. PR_REG_ISID_ID_LEN);
  1577. sprintf(buf, "%s Node: %s%s Key: 0x%016Lx PRgen: 0x%08x\n",
  1578. tfo->fabric_name,
  1579. pr_reg->pr_reg_nacl->initiatorname, i_buf, pr_reg->pr_res_key,
  1580. pr_reg->pr_res_generation);
  1581. if (len + strlen(buf) >= PAGE_SIZE)
  1582. break;
  1583. len += sprintf(page+len, "%s", buf);
  1584. reg_count++;
  1585. }
  1586. spin_unlock(&dev->t10_pr.registration_lock);
  1587. if (!reg_count)
  1588. len += sprintf(page+len, "None\n");
  1589. return len;
  1590. }
  1591. static ssize_t target_pr_res_pr_type_show(struct config_item *item, char *page)
  1592. {
  1593. struct se_device *dev = pr_to_dev(item);
  1594. struct t10_pr_registration *pr_reg;
  1595. ssize_t len = 0;
  1596. spin_lock(&dev->dev_reservation_lock);
  1597. pr_reg = dev->dev_pr_res_holder;
  1598. if (pr_reg) {
  1599. len = sprintf(page, "SPC-3 Reservation Type: %s\n",
  1600. core_scsi3_pr_dump_type(pr_reg->pr_res_type));
  1601. } else {
  1602. len = sprintf(page, "No SPC-3 Reservation holder\n");
  1603. }
  1604. spin_unlock(&dev->dev_reservation_lock);
  1605. return len;
  1606. }
  1607. static ssize_t target_pr_res_type_show(struct config_item *item, char *page)
  1608. {
  1609. struct se_device *dev = pr_to_dev(item);
  1610. if (!dev->dev_attrib.emulate_pr)
  1611. return sprintf(page, "SPC_RESERVATIONS_DISABLED\n");
  1612. if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)
  1613. return sprintf(page, "SPC_PASSTHROUGH\n");
  1614. if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
  1615. return sprintf(page, "SPC2_RESERVATIONS\n");
  1616. return sprintf(page, "SPC3_PERSISTENT_RESERVATIONS\n");
  1617. }
  1618. static ssize_t target_pr_res_aptpl_active_show(struct config_item *item,
  1619. char *page)
  1620. {
  1621. struct se_device *dev = pr_to_dev(item);
  1622. if (!dev->dev_attrib.emulate_pr ||
  1623. (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
  1624. return 0;
  1625. return sprintf(page, "APTPL Bit Status: %s\n",
  1626. (dev->t10_pr.pr_aptpl_active) ? "Activated" : "Disabled");
  1627. }
  1628. static ssize_t target_pr_res_aptpl_metadata_show(struct config_item *item,
  1629. char *page)
  1630. {
  1631. struct se_device *dev = pr_to_dev(item);
  1632. if (!dev->dev_attrib.emulate_pr ||
  1633. (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
  1634. return 0;
  1635. return sprintf(page, "Ready to process PR APTPL metadata..\n");
  1636. }
  1637. enum {
  1638. Opt_initiator_fabric, Opt_initiator_node, Opt_initiator_sid,
  1639. Opt_sa_res_key, Opt_res_holder, Opt_res_type, Opt_res_scope,
  1640. Opt_res_all_tg_pt, Opt_mapped_lun, Opt_target_fabric,
  1641. Opt_target_node, Opt_tpgt, Opt_port_rtpi, Opt_target_lun, Opt_err
  1642. };
  1643. static match_table_t tokens = {
  1644. {Opt_initiator_fabric, "initiator_fabric=%s"},
  1645. {Opt_initiator_node, "initiator_node=%s"},
  1646. {Opt_initiator_sid, "initiator_sid=%s"},
  1647. {Opt_sa_res_key, "sa_res_key=%s"},
  1648. {Opt_res_holder, "res_holder=%d"},
  1649. {Opt_res_type, "res_type=%d"},
  1650. {Opt_res_scope, "res_scope=%d"},
  1651. {Opt_res_all_tg_pt, "res_all_tg_pt=%d"},
  1652. {Opt_mapped_lun, "mapped_lun=%u"},
  1653. {Opt_target_fabric, "target_fabric=%s"},
  1654. {Opt_target_node, "target_node=%s"},
  1655. {Opt_tpgt, "tpgt=%d"},
  1656. {Opt_port_rtpi, "port_rtpi=%d"},
  1657. {Opt_target_lun, "target_lun=%u"},
  1658. {Opt_err, NULL}
  1659. };
  1660. static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
  1661. const char *page, size_t count)
  1662. {
  1663. struct se_device *dev = pr_to_dev(item);
  1664. unsigned char *i_fabric = NULL, *i_port = NULL, *isid = NULL;
  1665. unsigned char *t_fabric = NULL, *t_port = NULL;
  1666. char *orig, *ptr, *opts;
  1667. substring_t args[MAX_OPT_ARGS];
  1668. unsigned long long tmp_ll;
  1669. u64 sa_res_key = 0;
  1670. u64 mapped_lun = 0, target_lun = 0;
  1671. int ret = -1, res_holder = 0, all_tg_pt = 0, arg, token;
  1672. u16 tpgt = 0;
  1673. u8 type = 0;
  1674. if (!dev->dev_attrib.emulate_pr ||
  1675. (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
  1676. return count;
  1677. if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
  1678. return count;
  1679. if (dev->export_count) {
  1680. pr_debug("Unable to process APTPL metadata while"
  1681. " active fabric exports exist\n");
  1682. return -EINVAL;
  1683. }
  1684. opts = kstrdup(page, GFP_KERNEL);
  1685. if (!opts)
  1686. return -ENOMEM;
  1687. orig = opts;
  1688. while ((ptr = strsep(&opts, ",\n")) != NULL) {
  1689. if (!*ptr)
  1690. continue;
  1691. token = match_token(ptr, tokens, args);
  1692. switch (token) {
  1693. case Opt_initiator_fabric:
  1694. i_fabric = match_strdup(args);
  1695. if (!i_fabric) {
  1696. ret = -ENOMEM;
  1697. goto out;
  1698. }
  1699. break;
  1700. case Opt_initiator_node:
  1701. i_port = match_strdup(args);
  1702. if (!i_port) {
  1703. ret = -ENOMEM;
  1704. goto out;
  1705. }
  1706. if (strlen(i_port) >= PR_APTPL_MAX_IPORT_LEN) {
  1707. pr_err("APTPL metadata initiator_node="
  1708. " exceeds PR_APTPL_MAX_IPORT_LEN: %d\n",
  1709. PR_APTPL_MAX_IPORT_LEN);
  1710. ret = -EINVAL;
  1711. break;
  1712. }
  1713. break;
  1714. case Opt_initiator_sid:
  1715. isid = match_strdup(args);
  1716. if (!isid) {
  1717. ret = -ENOMEM;
  1718. goto out;
  1719. }
  1720. if (strlen(isid) >= PR_REG_ISID_LEN) {
  1721. pr_err("APTPL metadata initiator_isid"
  1722. "= exceeds PR_REG_ISID_LEN: %d\n",
  1723. PR_REG_ISID_LEN);
  1724. ret = -EINVAL;
  1725. break;
  1726. }
  1727. break;
  1728. case Opt_sa_res_key:
  1729. ret = match_u64(args, &tmp_ll);
  1730. if (ret < 0) {
  1731. pr_err("kstrtoull() failed for sa_res_key=\n");
  1732. goto out;
  1733. }
  1734. sa_res_key = (u64)tmp_ll;
  1735. break;
  1736. /*
  1737. * PR APTPL Metadata for Reservation
  1738. */
  1739. case Opt_res_holder:
  1740. ret = match_int(args, &arg);
  1741. if (ret)
  1742. goto out;
  1743. res_holder = arg;
  1744. break;
  1745. case Opt_res_type:
  1746. ret = match_int(args, &arg);
  1747. if (ret)
  1748. goto out;
  1749. type = (u8)arg;
  1750. break;
  1751. case Opt_res_scope:
  1752. ret = match_int(args, &arg);
  1753. if (ret)
  1754. goto out;
  1755. break;
  1756. case Opt_res_all_tg_pt:
  1757. ret = match_int(args, &arg);
  1758. if (ret)
  1759. goto out;
  1760. all_tg_pt = (int)arg;
  1761. break;
  1762. case Opt_mapped_lun:
  1763. ret = match_u64(args, &tmp_ll);
  1764. if (ret)
  1765. goto out;
  1766. mapped_lun = (u64)tmp_ll;
  1767. break;
  1768. /*
  1769. * PR APTPL Metadata for Target Port
  1770. */
  1771. case Opt_target_fabric:
  1772. t_fabric = match_strdup(args);
  1773. if (!t_fabric) {
  1774. ret = -ENOMEM;
  1775. goto out;
  1776. }
  1777. break;
  1778. case Opt_target_node:
  1779. t_port = match_strdup(args);
  1780. if (!t_port) {
  1781. ret = -ENOMEM;
  1782. goto out;
  1783. }
  1784. if (strlen(t_port) >= PR_APTPL_MAX_TPORT_LEN) {
  1785. pr_err("APTPL metadata target_node="
  1786. " exceeds PR_APTPL_MAX_TPORT_LEN: %d\n",
  1787. PR_APTPL_MAX_TPORT_LEN);
  1788. ret = -EINVAL;
  1789. break;
  1790. }
  1791. break;
  1792. case Opt_tpgt:
  1793. ret = match_int(args, &arg);
  1794. if (ret)
  1795. goto out;
  1796. tpgt = (u16)arg;
  1797. break;
  1798. case Opt_port_rtpi:
  1799. ret = match_int(args, &arg);
  1800. if (ret)
  1801. goto out;
  1802. break;
  1803. case Opt_target_lun:
  1804. ret = match_u64(args, &tmp_ll);
  1805. if (ret)
  1806. goto out;
  1807. target_lun = (u64)tmp_ll;
  1808. break;
  1809. default:
  1810. break;
  1811. }
  1812. }
  1813. if (!i_port || !t_port || !sa_res_key) {
  1814. pr_err("Illegal parameters for APTPL registration\n");
  1815. ret = -EINVAL;
  1816. goto out;
  1817. }
  1818. if (res_holder && !(type)) {
  1819. pr_err("Illegal PR type: 0x%02x for reservation"
  1820. " holder\n", type);
  1821. ret = -EINVAL;
  1822. goto out;
  1823. }
  1824. ret = core_scsi3_alloc_aptpl_registration(&dev->t10_pr, sa_res_key,
  1825. i_port, isid, mapped_lun, t_port, tpgt, target_lun,
  1826. res_holder, all_tg_pt, type);
  1827. out:
  1828. kfree(i_fabric);
  1829. kfree(i_port);
  1830. kfree(isid);
  1831. kfree(t_fabric);
  1832. kfree(t_port);
  1833. kfree(orig);
  1834. return (ret == 0) ? count : ret;
  1835. }
  1836. CONFIGFS_ATTR_RO(target_pr_, res_holder);
  1837. CONFIGFS_ATTR_RO(target_pr_, res_pr_all_tgt_pts);
  1838. CONFIGFS_ATTR_RO(target_pr_, res_pr_generation);
  1839. CONFIGFS_ATTR_RO(target_pr_, res_pr_holder_tg_port);
  1840. CONFIGFS_ATTR_RO(target_pr_, res_pr_registered_i_pts);
  1841. CONFIGFS_ATTR_RO(target_pr_, res_pr_type);
  1842. CONFIGFS_ATTR_RO(target_pr_, res_type);
  1843. CONFIGFS_ATTR_RO(target_pr_, res_aptpl_active);
  1844. CONFIGFS_ATTR(target_pr_, res_aptpl_metadata);
  1845. static struct configfs_attribute *target_core_dev_pr_attrs[] = {
  1846. &target_pr_attr_res_holder,
  1847. &target_pr_attr_res_pr_all_tgt_pts,
  1848. &target_pr_attr_res_pr_generation,
  1849. &target_pr_attr_res_pr_holder_tg_port,
  1850. &target_pr_attr_res_pr_registered_i_pts,
  1851. &target_pr_attr_res_pr_type,
  1852. &target_pr_attr_res_type,
  1853. &target_pr_attr_res_aptpl_active,
  1854. &target_pr_attr_res_aptpl_metadata,
  1855. NULL,
  1856. };
  1857. TB_CIT_SETUP(dev_pr, NULL, NULL, target_core_dev_pr_attrs);
  1858. /* End functions for struct config_item_type tb_dev_pr_cit */
  1859. /* Start functions for struct config_item_type tb_dev_cit */
  1860. static inline struct se_device *to_device(struct config_item *item)
  1861. {
  1862. return container_of(to_config_group(item), struct se_device, dev_group);
  1863. }
  1864. static ssize_t target_dev_info_show(struct config_item *item, char *page)
  1865. {
  1866. struct se_device *dev = to_device(item);
  1867. int bl = 0;
  1868. ssize_t read_bytes = 0;
  1869. transport_dump_dev_state(dev, page, &bl);
  1870. read_bytes += bl;
  1871. read_bytes += dev->transport->show_configfs_dev_params(dev,
  1872. page+read_bytes);
  1873. return read_bytes;
  1874. }
  1875. static ssize_t target_dev_control_store(struct config_item *item,
  1876. const char *page, size_t count)
  1877. {
  1878. struct se_device *dev = to_device(item);
  1879. return dev->transport->set_configfs_dev_params(dev, page, count);
  1880. }
  1881. static ssize_t target_dev_alias_show(struct config_item *item, char *page)
  1882. {
  1883. struct se_device *dev = to_device(item);
  1884. if (!(dev->dev_flags & DF_USING_ALIAS))
  1885. return 0;
  1886. return snprintf(page, PAGE_SIZE, "%s\n", dev->dev_alias);
  1887. }
  1888. static ssize_t target_dev_alias_store(struct config_item *item,
  1889. const char *page, size_t count)
  1890. {
  1891. struct se_device *dev = to_device(item);
  1892. struct se_hba *hba = dev->se_hba;
  1893. ssize_t read_bytes;
  1894. if (count > (SE_DEV_ALIAS_LEN-1)) {
  1895. pr_err("alias count: %d exceeds"
  1896. " SE_DEV_ALIAS_LEN-1: %u\n", (int)count,
  1897. SE_DEV_ALIAS_LEN-1);
  1898. return -EINVAL;
  1899. }
  1900. read_bytes = snprintf(&dev->dev_alias[0], SE_DEV_ALIAS_LEN, "%s", page);
  1901. if (!read_bytes)
  1902. return -EINVAL;
  1903. if (dev->dev_alias[read_bytes - 1] == '\n')
  1904. dev->dev_alias[read_bytes - 1] = '\0';
  1905. dev->dev_flags |= DF_USING_ALIAS;
  1906. pr_debug("Target_Core_ConfigFS: %s/%s set alias: %s\n",
  1907. config_item_name(&hba->hba_group.cg_item),
  1908. config_item_name(&dev->dev_group.cg_item),
  1909. dev->dev_alias);
  1910. return read_bytes;
  1911. }
  1912. static ssize_t target_dev_udev_path_show(struct config_item *item, char *page)
  1913. {
  1914. struct se_device *dev = to_device(item);
  1915. if (!(dev->dev_flags & DF_USING_UDEV_PATH))
  1916. return 0;
  1917. return snprintf(page, PAGE_SIZE, "%s\n", dev->udev_path);
  1918. }
  1919. static ssize_t target_dev_udev_path_store(struct config_item *item,
  1920. const char *page, size_t count)
  1921. {
  1922. struct se_device *dev = to_device(item);
  1923. struct se_hba *hba = dev->se_hba;
  1924. ssize_t read_bytes;
  1925. if (count > (SE_UDEV_PATH_LEN-1)) {
  1926. pr_err("udev_path count: %d exceeds"
  1927. " SE_UDEV_PATH_LEN-1: %u\n", (int)count,
  1928. SE_UDEV_PATH_LEN-1);
  1929. return -EINVAL;
  1930. }
  1931. read_bytes = snprintf(&dev->udev_path[0], SE_UDEV_PATH_LEN,
  1932. "%s", page);
  1933. if (!read_bytes)
  1934. return -EINVAL;
  1935. if (dev->udev_path[read_bytes - 1] == '\n')
  1936. dev->udev_path[read_bytes - 1] = '\0';
  1937. dev->dev_flags |= DF_USING_UDEV_PATH;
  1938. pr_debug("Target_Core_ConfigFS: %s/%s set udev_path: %s\n",
  1939. config_item_name(&hba->hba_group.cg_item),
  1940. config_item_name(&dev->dev_group.cg_item),
  1941. dev->udev_path);
  1942. return read_bytes;
  1943. }
  1944. static ssize_t target_dev_enable_show(struct config_item *item, char *page)
  1945. {
  1946. struct se_device *dev = to_device(item);
  1947. return snprintf(page, PAGE_SIZE, "%d\n", target_dev_configured(dev));
  1948. }
  1949. static ssize_t target_dev_enable_store(struct config_item *item,
  1950. const char *page, size_t count)
  1951. {
  1952. struct se_device *dev = to_device(item);
  1953. char *ptr;
  1954. int ret;
  1955. ptr = strstr(page, "1");
  1956. if (!ptr) {
  1957. pr_err("For dev_enable ops, only valid value"
  1958. " is \"1\"\n");
  1959. return -EINVAL;
  1960. }
  1961. ret = target_configure_device(dev);
  1962. if (ret)
  1963. return ret;
  1964. return count;
  1965. }
  1966. static ssize_t target_dev_alua_lu_gp_show(struct config_item *item, char *page)
  1967. {
  1968. struct se_device *dev = to_device(item);
  1969. struct config_item *lu_ci;
  1970. struct t10_alua_lu_gp *lu_gp;
  1971. struct t10_alua_lu_gp_member *lu_gp_mem;
  1972. ssize_t len = 0;
  1973. lu_gp_mem = dev->dev_alua_lu_gp_mem;
  1974. if (!lu_gp_mem)
  1975. return 0;
  1976. spin_lock(&lu_gp_mem->lu_gp_mem_lock);
  1977. lu_gp = lu_gp_mem->lu_gp;
  1978. if (lu_gp) {
  1979. lu_ci = &lu_gp->lu_gp_group.cg_item;
  1980. len += sprintf(page, "LU Group Alias: %s\nLU Group ID: %hu\n",
  1981. config_item_name(lu_ci), lu_gp->lu_gp_id);
  1982. }
  1983. spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
  1984. return len;
  1985. }
  1986. static ssize_t target_dev_alua_lu_gp_store(struct config_item *item,
  1987. const char *page, size_t count)
  1988. {
  1989. struct se_device *dev = to_device(item);
  1990. struct se_hba *hba = dev->se_hba;
  1991. struct t10_alua_lu_gp *lu_gp = NULL, *lu_gp_new = NULL;
  1992. struct t10_alua_lu_gp_member *lu_gp_mem;
  1993. unsigned char buf[LU_GROUP_NAME_BUF];
  1994. int move = 0;
  1995. lu_gp_mem = dev->dev_alua_lu_gp_mem;
  1996. if (!lu_gp_mem)
  1997. return count;
  1998. if (count > LU_GROUP_NAME_BUF) {
  1999. pr_err("ALUA LU Group Alias too large!\n");
  2000. return -EINVAL;
  2001. }
  2002. memset(buf, 0, LU_GROUP_NAME_BUF);
  2003. memcpy(buf, page, count);
  2004. /*
  2005. * Any ALUA logical unit alias besides "NULL" means we will be
  2006. * making a new group association.
  2007. */
  2008. if (strcmp(strstrip(buf), "NULL")) {
  2009. /*
  2010. * core_alua_get_lu_gp_by_name() will increment reference to
  2011. * struct t10_alua_lu_gp. This reference is released with
  2012. * core_alua_get_lu_gp_by_name below().
  2013. */
  2014. lu_gp_new = core_alua_get_lu_gp_by_name(strstrip(buf));
  2015. if (!lu_gp_new)
  2016. return -ENODEV;
  2017. }
  2018. spin_lock(&lu_gp_mem->lu_gp_mem_lock);
  2019. lu_gp = lu_gp_mem->lu_gp;
  2020. if (lu_gp) {
  2021. /*
  2022. * Clearing an existing lu_gp association, and replacing
  2023. * with NULL
  2024. */
  2025. if (!lu_gp_new) {
  2026. pr_debug("Target_Core_ConfigFS: Releasing %s/%s"
  2027. " from ALUA LU Group: core/alua/lu_gps/%s, ID:"
  2028. " %hu\n",
  2029. config_item_name(&hba->hba_group.cg_item),
  2030. config_item_name(&dev->dev_group.cg_item),
  2031. config_item_name(&lu_gp->lu_gp_group.cg_item),
  2032. lu_gp->lu_gp_id);
  2033. __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
  2034. spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
  2035. return count;
  2036. }
  2037. /*
  2038. * Removing existing association of lu_gp_mem with lu_gp
  2039. */
  2040. __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
  2041. move = 1;
  2042. }
  2043. /*
  2044. * Associate lu_gp_mem with lu_gp_new.
  2045. */
  2046. __core_alua_attach_lu_gp_mem(lu_gp_mem, lu_gp_new);
  2047. spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
  2048. pr_debug("Target_Core_ConfigFS: %s %s/%s to ALUA LU Group:"
  2049. " core/alua/lu_gps/%s, ID: %hu\n",
  2050. (move) ? "Moving" : "Adding",
  2051. config_item_name(&hba->hba_group.cg_item),
  2052. config_item_name(&dev->dev_group.cg_item),
  2053. config_item_name(&lu_gp_new->lu_gp_group.cg_item),
  2054. lu_gp_new->lu_gp_id);
  2055. core_alua_put_lu_gp_from_name(lu_gp_new);
  2056. return count;
  2057. }
  2058. static ssize_t target_dev_lba_map_show(struct config_item *item, char *page)
  2059. {
  2060. struct se_device *dev = to_device(item);
  2061. struct t10_alua_lba_map *map;
  2062. struct t10_alua_lba_map_member *mem;
  2063. char *b = page;
  2064. int bl = 0;
  2065. char state;
  2066. spin_lock(&dev->t10_alua.lba_map_lock);
  2067. if (!list_empty(&dev->t10_alua.lba_map_list))
  2068. bl += sprintf(b + bl, "%u %u\n",
  2069. dev->t10_alua.lba_map_segment_size,
  2070. dev->t10_alua.lba_map_segment_multiplier);
  2071. list_for_each_entry(map, &dev->t10_alua.lba_map_list, lba_map_list) {
  2072. bl += sprintf(b + bl, "%llu %llu",
  2073. map->lba_map_first_lba, map->lba_map_last_lba);
  2074. list_for_each_entry(mem, &map->lba_map_mem_list,
  2075. lba_map_mem_list) {
  2076. switch (mem->lba_map_mem_alua_state) {
  2077. case ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED:
  2078. state = 'O';
  2079. break;
  2080. case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED:
  2081. state = 'A';
  2082. break;
  2083. case ALUA_ACCESS_STATE_STANDBY:
  2084. state = 'S';
  2085. break;
  2086. case ALUA_ACCESS_STATE_UNAVAILABLE:
  2087. state = 'U';
  2088. break;
  2089. default:
  2090. state = '.';
  2091. break;
  2092. }
  2093. bl += sprintf(b + bl, " %d:%c",
  2094. mem->lba_map_mem_alua_pg_id, state);
  2095. }
  2096. bl += sprintf(b + bl, "\n");
  2097. }
  2098. spin_unlock(&dev->t10_alua.lba_map_lock);
  2099. return bl;
  2100. }
  2101. static ssize_t target_dev_lba_map_store(struct config_item *item,
  2102. const char *page, size_t count)
  2103. {
  2104. struct se_device *dev = to_device(item);
  2105. struct t10_alua_lba_map *lba_map = NULL;
  2106. struct list_head lba_list;
  2107. char *map_entries, *orig, *ptr;
  2108. char state;
  2109. int pg_num = -1, pg;
  2110. int ret = 0, num = 0, pg_id, alua_state;
  2111. unsigned long start_lba = -1, end_lba = -1;
  2112. unsigned long segment_size = -1, segment_mult = -1;
  2113. orig = map_entries = kstrdup(page, GFP_KERNEL);
  2114. if (!map_entries)
  2115. return -ENOMEM;
  2116. INIT_LIST_HEAD(&lba_list);
  2117. while ((ptr = strsep(&map_entries, "\n")) != NULL) {
  2118. if (!*ptr)
  2119. continue;
  2120. if (num == 0) {
  2121. if (sscanf(ptr, "%lu %lu\n",
  2122. &segment_size, &segment_mult) != 2) {
  2123. pr_err("Invalid line %d\n", num);
  2124. ret = -EINVAL;
  2125. break;
  2126. }
  2127. num++;
  2128. continue;
  2129. }
  2130. if (sscanf(ptr, "%lu %lu", &start_lba, &end_lba) != 2) {
  2131. pr_err("Invalid line %d\n", num);
  2132. ret = -EINVAL;
  2133. break;
  2134. }
  2135. ptr = strchr(ptr, ' ');
  2136. if (!ptr) {
  2137. pr_err("Invalid line %d, missing end lba\n", num);
  2138. ret = -EINVAL;
  2139. break;
  2140. }
  2141. ptr++;
  2142. ptr = strchr(ptr, ' ');
  2143. if (!ptr) {
  2144. pr_err("Invalid line %d, missing state definitions\n",
  2145. num);
  2146. ret = -EINVAL;
  2147. break;
  2148. }
  2149. ptr++;
  2150. lba_map = core_alua_allocate_lba_map(&lba_list,
  2151. start_lba, end_lba);
  2152. if (IS_ERR(lba_map)) {
  2153. ret = PTR_ERR(lba_map);
  2154. break;
  2155. }
  2156. pg = 0;
  2157. while (sscanf(ptr, "%d:%c", &pg_id, &state) == 2) {
  2158. switch (state) {
  2159. case 'O':
  2160. alua_state = ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED;
  2161. break;
  2162. case 'A':
  2163. alua_state = ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED;
  2164. break;
  2165. case 'S':
  2166. alua_state = ALUA_ACCESS_STATE_STANDBY;
  2167. break;
  2168. case 'U':
  2169. alua_state = ALUA_ACCESS_STATE_UNAVAILABLE;
  2170. break;
  2171. default:
  2172. pr_err("Invalid ALUA state '%c'\n", state);
  2173. ret = -EINVAL;
  2174. goto out;
  2175. }
  2176. ret = core_alua_allocate_lba_map_mem(lba_map,
  2177. pg_id, alua_state);
  2178. if (ret) {
  2179. pr_err("Invalid target descriptor %d:%c "
  2180. "at line %d\n",
  2181. pg_id, state, num);
  2182. break;
  2183. }
  2184. pg++;
  2185. ptr = strchr(ptr, ' ');
  2186. if (ptr)
  2187. ptr++;
  2188. else
  2189. break;
  2190. }
  2191. if (pg_num == -1)
  2192. pg_num = pg;
  2193. else if (pg != pg_num) {
  2194. pr_err("Only %d from %d port groups definitions "
  2195. "at line %d\n", pg, pg_num, num);
  2196. ret = -EINVAL;
  2197. break;
  2198. }
  2199. num++;
  2200. }
  2201. out:
  2202. if (ret) {
  2203. core_alua_free_lba_map(&lba_list);
  2204. count = ret;
  2205. } else
  2206. core_alua_set_lba_map(dev, &lba_list,
  2207. segment_size, segment_mult);
  2208. kfree(orig);
  2209. return count;
  2210. }
  2211. CONFIGFS_ATTR_RO(target_dev_, info);
  2212. CONFIGFS_ATTR_WO(target_dev_, control);
  2213. CONFIGFS_ATTR(target_dev_, alias);
  2214. CONFIGFS_ATTR(target_dev_, udev_path);
  2215. CONFIGFS_ATTR(target_dev_, enable);
  2216. CONFIGFS_ATTR(target_dev_, alua_lu_gp);
  2217. CONFIGFS_ATTR(target_dev_, lba_map);
  2218. static struct configfs_attribute *target_core_dev_attrs[] = {
  2219. &target_dev_attr_info,
  2220. &target_dev_attr_control,
  2221. &target_dev_attr_alias,
  2222. &target_dev_attr_udev_path,
  2223. &target_dev_attr_enable,
  2224. &target_dev_attr_alua_lu_gp,
  2225. &target_dev_attr_lba_map,
  2226. NULL,
  2227. };
  2228. static void target_core_dev_release(struct config_item *item)
  2229. {
  2230. struct config_group *dev_cg = to_config_group(item);
  2231. struct se_device *dev =
  2232. container_of(dev_cg, struct se_device, dev_group);
  2233. target_free_device(dev);
  2234. }
  2235. /*
  2236. * Used in target_core_fabric_configfs.c to verify valid se_device symlink
  2237. * within target_fabric_port_link()
  2238. */
  2239. struct configfs_item_operations target_core_dev_item_ops = {
  2240. .release = target_core_dev_release,
  2241. };
  2242. TB_CIT_SETUP(dev, &target_core_dev_item_ops, NULL, target_core_dev_attrs);
  2243. /* End functions for struct config_item_type tb_dev_cit */
  2244. /* Start functions for struct config_item_type target_core_alua_lu_gp_cit */
  2245. static inline struct t10_alua_lu_gp *to_lu_gp(struct config_item *item)
  2246. {
  2247. return container_of(to_config_group(item), struct t10_alua_lu_gp,
  2248. lu_gp_group);
  2249. }
  2250. static ssize_t target_lu_gp_lu_gp_id_show(struct config_item *item, char *page)
  2251. {
  2252. struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
  2253. if (!lu_gp->lu_gp_valid_id)
  2254. return 0;
  2255. return sprintf(page, "%hu\n", lu_gp->lu_gp_id);
  2256. }
  2257. static ssize_t target_lu_gp_lu_gp_id_store(struct config_item *item,
  2258. const char *page, size_t count)
  2259. {
  2260. struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
  2261. struct config_group *alua_lu_gp_cg = &lu_gp->lu_gp_group;
  2262. unsigned long lu_gp_id;
  2263. int ret;
  2264. ret = kstrtoul(page, 0, &lu_gp_id);
  2265. if (ret < 0) {
  2266. pr_err("kstrtoul() returned %d for"
  2267. " lu_gp_id\n", ret);
  2268. return ret;
  2269. }
  2270. if (lu_gp_id > 0x0000ffff) {
  2271. pr_err("ALUA lu_gp_id: %lu exceeds maximum:"
  2272. " 0x0000ffff\n", lu_gp_id);
  2273. return -EINVAL;
  2274. }
  2275. ret = core_alua_set_lu_gp_id(lu_gp, (u16)lu_gp_id);
  2276. if (ret < 0)
  2277. return -EINVAL;
  2278. pr_debug("Target_Core_ConfigFS: Set ALUA Logical Unit"
  2279. " Group: core/alua/lu_gps/%s to ID: %hu\n",
  2280. config_item_name(&alua_lu_gp_cg->cg_item),
  2281. lu_gp->lu_gp_id);
  2282. return count;
  2283. }
  2284. static ssize_t target_lu_gp_members_show(struct config_item *item, char *page)
  2285. {
  2286. struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
  2287. struct se_device *dev;
  2288. struct se_hba *hba;
  2289. struct t10_alua_lu_gp_member *lu_gp_mem;
  2290. ssize_t len = 0, cur_len;
  2291. unsigned char buf[LU_GROUP_NAME_BUF];
  2292. memset(buf, 0, LU_GROUP_NAME_BUF);
  2293. spin_lock(&lu_gp->lu_gp_lock);
  2294. list_for_each_entry(lu_gp_mem, &lu_gp->lu_gp_mem_list, lu_gp_mem_list) {
  2295. dev = lu_gp_mem->lu_gp_mem_dev;
  2296. hba = dev->se_hba;
  2297. cur_len = snprintf(buf, LU_GROUP_NAME_BUF, "%s/%s\n",
  2298. config_item_name(&hba->hba_group.cg_item),
  2299. config_item_name(&dev->dev_group.cg_item));
  2300. cur_len++; /* Extra byte for NULL terminator */
  2301. if ((cur_len + len) > PAGE_SIZE) {
  2302. pr_warn("Ran out of lu_gp_show_attr"
  2303. "_members buffer\n");
  2304. break;
  2305. }
  2306. memcpy(page+len, buf, cur_len);
  2307. len += cur_len;
  2308. }
  2309. spin_unlock(&lu_gp->lu_gp_lock);
  2310. return len;
  2311. }
  2312. CONFIGFS_ATTR(target_lu_gp_, lu_gp_id);
  2313. CONFIGFS_ATTR_RO(target_lu_gp_, members);
  2314. static struct configfs_attribute *target_core_alua_lu_gp_attrs[] = {
  2315. &target_lu_gp_attr_lu_gp_id,
  2316. &target_lu_gp_attr_members,
  2317. NULL,
  2318. };
  2319. static void target_core_alua_lu_gp_release(struct config_item *item)
  2320. {
  2321. struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
  2322. struct t10_alua_lu_gp, lu_gp_group);
  2323. core_alua_free_lu_gp(lu_gp);
  2324. }
  2325. static struct configfs_item_operations target_core_alua_lu_gp_ops = {
  2326. .release = target_core_alua_lu_gp_release,
  2327. };
  2328. static const struct config_item_type target_core_alua_lu_gp_cit = {
  2329. .ct_item_ops = &target_core_alua_lu_gp_ops,
  2330. .ct_attrs = target_core_alua_lu_gp_attrs,
  2331. .ct_owner = THIS_MODULE,
  2332. };
  2333. /* End functions for struct config_item_type target_core_alua_lu_gp_cit */
  2334. /* Start functions for struct config_item_type target_core_alua_lu_gps_cit */
  2335. static struct config_group *target_core_alua_create_lu_gp(
  2336. struct config_group *group,
  2337. const char *name)
  2338. {
  2339. struct t10_alua_lu_gp *lu_gp;
  2340. struct config_group *alua_lu_gp_cg = NULL;
  2341. struct config_item *alua_lu_gp_ci = NULL;
  2342. lu_gp = core_alua_allocate_lu_gp(name, 0);
  2343. if (IS_ERR(lu_gp))
  2344. return NULL;
  2345. alua_lu_gp_cg = &lu_gp->lu_gp_group;
  2346. alua_lu_gp_ci = &alua_lu_gp_cg->cg_item;
  2347. config_group_init_type_name(alua_lu_gp_cg, name,
  2348. &target_core_alua_lu_gp_cit);
  2349. pr_debug("Target_Core_ConfigFS: Allocated ALUA Logical Unit"
  2350. " Group: core/alua/lu_gps/%s\n",
  2351. config_item_name(alua_lu_gp_ci));
  2352. return alua_lu_gp_cg;
  2353. }
  2354. static void target_core_alua_drop_lu_gp(
  2355. struct config_group *group,
  2356. struct config_item *item)
  2357. {
  2358. struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
  2359. struct t10_alua_lu_gp, lu_gp_group);
  2360. pr_debug("Target_Core_ConfigFS: Releasing ALUA Logical Unit"
  2361. " Group: core/alua/lu_gps/%s, ID: %hu\n",
  2362. config_item_name(item), lu_gp->lu_gp_id);
  2363. /*
  2364. * core_alua_free_lu_gp() is called from target_core_alua_lu_gp_ops->release()
  2365. * -> target_core_alua_lu_gp_release()
  2366. */
  2367. config_item_put(item);
  2368. }
  2369. static struct configfs_group_operations target_core_alua_lu_gps_group_ops = {
  2370. .make_group = &target_core_alua_create_lu_gp,
  2371. .drop_item = &target_core_alua_drop_lu_gp,
  2372. };
  2373. static const struct config_item_type target_core_alua_lu_gps_cit = {
  2374. .ct_item_ops = NULL,
  2375. .ct_group_ops = &target_core_alua_lu_gps_group_ops,
  2376. .ct_owner = THIS_MODULE,
  2377. };
  2378. /* End functions for struct config_item_type target_core_alua_lu_gps_cit */
  2379. /* Start functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
  2380. static inline struct t10_alua_tg_pt_gp *to_tg_pt_gp(struct config_item *item)
  2381. {
  2382. return container_of(to_config_group(item), struct t10_alua_tg_pt_gp,
  2383. tg_pt_gp_group);
  2384. }
  2385. static ssize_t target_tg_pt_gp_alua_access_state_show(struct config_item *item,
  2386. char *page)
  2387. {
  2388. return sprintf(page, "%d\n",
  2389. to_tg_pt_gp(item)->tg_pt_gp_alua_access_state);
  2390. }
  2391. static ssize_t target_tg_pt_gp_alua_access_state_store(struct config_item *item,
  2392. const char *page, size_t count)
  2393. {
  2394. struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
  2395. struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
  2396. unsigned long tmp;
  2397. int new_state, ret;
  2398. if (!tg_pt_gp->tg_pt_gp_valid_id) {
  2399. pr_err("Unable to do implicit ALUA on non valid"
  2400. " tg_pt_gp ID: %hu\n", tg_pt_gp->tg_pt_gp_valid_id);
  2401. return -EINVAL;
  2402. }
  2403. if (!target_dev_configured(dev)) {
  2404. pr_err("Unable to set alua_access_state while device is"
  2405. " not configured\n");
  2406. return -ENODEV;
  2407. }
  2408. ret = kstrtoul(page, 0, &tmp);
  2409. if (ret < 0) {
  2410. pr_err("Unable to extract new ALUA access state from"
  2411. " %s\n", page);
  2412. return ret;
  2413. }
  2414. new_state = (int)tmp;
  2415. if (!(tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICIT_ALUA)) {
  2416. pr_err("Unable to process implicit configfs ALUA"
  2417. " transition while TPGS_IMPLICIT_ALUA is disabled\n");
  2418. return -EINVAL;
  2419. }
  2420. if (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA &&
  2421. new_state == ALUA_ACCESS_STATE_LBA_DEPENDENT) {
  2422. /* LBA DEPENDENT is only allowed with implicit ALUA */
  2423. pr_err("Unable to process implicit configfs ALUA transition"
  2424. " while explicit ALUA management is enabled\n");
  2425. return -EINVAL;
  2426. }
  2427. ret = core_alua_do_port_transition(tg_pt_gp, dev,
  2428. NULL, NULL, new_state, 0);
  2429. return (!ret) ? count : -EINVAL;
  2430. }
  2431. static ssize_t target_tg_pt_gp_alua_access_status_show(struct config_item *item,
  2432. char *page)
  2433. {
  2434. struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
  2435. return sprintf(page, "%s\n",
  2436. core_alua_dump_status(tg_pt_gp->tg_pt_gp_alua_access_status));
  2437. }
  2438. static ssize_t target_tg_pt_gp_alua_access_status_store(
  2439. struct config_item *item, const char *page, size_t count)
  2440. {
  2441. struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
  2442. unsigned long tmp;
  2443. int new_status, ret;
  2444. if (!tg_pt_gp->tg_pt_gp_valid_id) {
  2445. pr_err("Unable to do set ALUA access status on non"
  2446. " valid tg_pt_gp ID: %hu\n",
  2447. tg_pt_gp->tg_pt_gp_valid_id);
  2448. return -EINVAL;
  2449. }
  2450. ret = kstrtoul(page, 0, &tmp);
  2451. if (ret < 0) {
  2452. pr_err("Unable to extract new ALUA access status"
  2453. " from %s\n", page);
  2454. return ret;
  2455. }
  2456. new_status = (int)tmp;
  2457. if ((new_status != ALUA_STATUS_NONE) &&
  2458. (new_status != ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) &&
  2459. (new_status != ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA)) {
  2460. pr_err("Illegal ALUA access status: 0x%02x\n",
  2461. new_status);
  2462. return -EINVAL;
  2463. }
  2464. tg_pt_gp->tg_pt_gp_alua_access_status = new_status;
  2465. return count;
  2466. }
  2467. static ssize_t target_tg_pt_gp_alua_access_type_show(struct config_item *item,
  2468. char *page)
  2469. {
  2470. return core_alua_show_access_type(to_tg_pt_gp(item), page);
  2471. }
  2472. static ssize_t target_tg_pt_gp_alua_access_type_store(struct config_item *item,
  2473. const char *page, size_t count)
  2474. {
  2475. return core_alua_store_access_type(to_tg_pt_gp(item), page, count);
  2476. }
  2477. #define ALUA_SUPPORTED_STATE_ATTR(_name, _bit) \
  2478. static ssize_t target_tg_pt_gp_alua_support_##_name##_show( \
  2479. struct config_item *item, char *p) \
  2480. { \
  2481. struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \
  2482. return sprintf(p, "%d\n", \
  2483. !!(t->tg_pt_gp_alua_supported_states & _bit)); \
  2484. } \
  2485. \
  2486. static ssize_t target_tg_pt_gp_alua_support_##_name##_store( \
  2487. struct config_item *item, const char *p, size_t c) \
  2488. { \
  2489. struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \
  2490. unsigned long tmp; \
  2491. int ret; \
  2492. \
  2493. if (!t->tg_pt_gp_valid_id) { \
  2494. pr_err("Unable to do set " #_name " ALUA state on non" \
  2495. " valid tg_pt_gp ID: %hu\n", \
  2496. t->tg_pt_gp_valid_id); \
  2497. return -EINVAL; \
  2498. } \
  2499. \
  2500. ret = kstrtoul(p, 0, &tmp); \
  2501. if (ret < 0) { \
  2502. pr_err("Invalid value '%s', must be '0' or '1'\n", p); \
  2503. return -EINVAL; \
  2504. } \
  2505. if (tmp > 1) { \
  2506. pr_err("Invalid value '%ld', must be '0' or '1'\n", tmp); \
  2507. return -EINVAL; \
  2508. } \
  2509. if (tmp) \
  2510. t->tg_pt_gp_alua_supported_states |= _bit; \
  2511. else \
  2512. t->tg_pt_gp_alua_supported_states &= ~_bit; \
  2513. \
  2514. return c; \
  2515. }
  2516. ALUA_SUPPORTED_STATE_ATTR(transitioning, ALUA_T_SUP);
  2517. ALUA_SUPPORTED_STATE_ATTR(offline, ALUA_O_SUP);
  2518. ALUA_SUPPORTED_STATE_ATTR(lba_dependent, ALUA_LBD_SUP);
  2519. ALUA_SUPPORTED_STATE_ATTR(unavailable, ALUA_U_SUP);
  2520. ALUA_SUPPORTED_STATE_ATTR(standby, ALUA_S_SUP);
  2521. ALUA_SUPPORTED_STATE_ATTR(active_optimized, ALUA_AO_SUP);
  2522. ALUA_SUPPORTED_STATE_ATTR(active_nonoptimized, ALUA_AN_SUP);
  2523. static ssize_t target_tg_pt_gp_alua_write_metadata_show(
  2524. struct config_item *item, char *page)
  2525. {
  2526. return sprintf(page, "%d\n",
  2527. to_tg_pt_gp(item)->tg_pt_gp_write_metadata);
  2528. }
  2529. static ssize_t target_tg_pt_gp_alua_write_metadata_store(
  2530. struct config_item *item, const char *page, size_t count)
  2531. {
  2532. struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
  2533. unsigned long tmp;
  2534. int ret;
  2535. ret = kstrtoul(page, 0, &tmp);
  2536. if (ret < 0) {
  2537. pr_err("Unable to extract alua_write_metadata\n");
  2538. return ret;
  2539. }
  2540. if ((tmp != 0) && (tmp != 1)) {
  2541. pr_err("Illegal value for alua_write_metadata:"
  2542. " %lu\n", tmp);
  2543. return -EINVAL;
  2544. }
  2545. tg_pt_gp->tg_pt_gp_write_metadata = (int)tmp;
  2546. return count;
  2547. }
  2548. static ssize_t target_tg_pt_gp_nonop_delay_msecs_show(struct config_item *item,
  2549. char *page)
  2550. {
  2551. return core_alua_show_nonop_delay_msecs(to_tg_pt_gp(item), page);
  2552. }
  2553. static ssize_t target_tg_pt_gp_nonop_delay_msecs_store(struct config_item *item,
  2554. const char *page, size_t count)
  2555. {
  2556. return core_alua_store_nonop_delay_msecs(to_tg_pt_gp(item), page,
  2557. count);
  2558. }
  2559. static ssize_t target_tg_pt_gp_trans_delay_msecs_show(struct config_item *item,
  2560. char *page)
  2561. {
  2562. return core_alua_show_trans_delay_msecs(to_tg_pt_gp(item), page);
  2563. }
  2564. static ssize_t target_tg_pt_gp_trans_delay_msecs_store(struct config_item *item,
  2565. const char *page, size_t count)
  2566. {
  2567. return core_alua_store_trans_delay_msecs(to_tg_pt_gp(item), page,
  2568. count);
  2569. }
  2570. static ssize_t target_tg_pt_gp_implicit_trans_secs_show(
  2571. struct config_item *item, char *page)
  2572. {
  2573. return core_alua_show_implicit_trans_secs(to_tg_pt_gp(item), page);
  2574. }
  2575. static ssize_t target_tg_pt_gp_implicit_trans_secs_store(
  2576. struct config_item *item, const char *page, size_t count)
  2577. {
  2578. return core_alua_store_implicit_trans_secs(to_tg_pt_gp(item), page,
  2579. count);
  2580. }
  2581. static ssize_t target_tg_pt_gp_preferred_show(struct config_item *item,
  2582. char *page)
  2583. {
  2584. return core_alua_show_preferred_bit(to_tg_pt_gp(item), page);
  2585. }
  2586. static ssize_t target_tg_pt_gp_preferred_store(struct config_item *item,
  2587. const char *page, size_t count)
  2588. {
  2589. return core_alua_store_preferred_bit(to_tg_pt_gp(item), page, count);
  2590. }
  2591. static ssize_t target_tg_pt_gp_tg_pt_gp_id_show(struct config_item *item,
  2592. char *page)
  2593. {
  2594. struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
  2595. if (!tg_pt_gp->tg_pt_gp_valid_id)
  2596. return 0;
  2597. return sprintf(page, "%hu\n", tg_pt_gp->tg_pt_gp_id);
  2598. }
  2599. static ssize_t target_tg_pt_gp_tg_pt_gp_id_store(struct config_item *item,
  2600. const char *page, size_t count)
  2601. {
  2602. struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
  2603. struct config_group *alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
  2604. unsigned long tg_pt_gp_id;
  2605. int ret;
  2606. ret = kstrtoul(page, 0, &tg_pt_gp_id);
  2607. if (ret < 0) {
  2608. pr_err("ALUA tg_pt_gp_id: invalid value '%s' for tg_pt_gp_id\n",
  2609. page);
  2610. return ret;
  2611. }
  2612. if (tg_pt_gp_id > 0x0000ffff) {
  2613. pr_err("ALUA tg_pt_gp_id: %lu exceeds maximum: 0x0000ffff\n",
  2614. tg_pt_gp_id);
  2615. return -EINVAL;
  2616. }
  2617. ret = core_alua_set_tg_pt_gp_id(tg_pt_gp, (u16)tg_pt_gp_id);
  2618. if (ret < 0)
  2619. return -EINVAL;
  2620. pr_debug("Target_Core_ConfigFS: Set ALUA Target Port Group: "
  2621. "core/alua/tg_pt_gps/%s to ID: %hu\n",
  2622. config_item_name(&alua_tg_pt_gp_cg->cg_item),
  2623. tg_pt_gp->tg_pt_gp_id);
  2624. return count;
  2625. }
  2626. static ssize_t target_tg_pt_gp_members_show(struct config_item *item,
  2627. char *page)
  2628. {
  2629. struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
  2630. struct se_lun *lun;
  2631. ssize_t len = 0, cur_len;
  2632. unsigned char buf[TG_PT_GROUP_NAME_BUF];
  2633. memset(buf, 0, TG_PT_GROUP_NAME_BUF);
  2634. spin_lock(&tg_pt_gp->tg_pt_gp_lock);
  2635. list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list,
  2636. lun_tg_pt_gp_link) {
  2637. struct se_portal_group *tpg = lun->lun_tpg;
  2638. cur_len = snprintf(buf, TG_PT_GROUP_NAME_BUF, "%s/%s/tpgt_%hu"
  2639. "/%s\n", tpg->se_tpg_tfo->fabric_name,
  2640. tpg->se_tpg_tfo->tpg_get_wwn(tpg),
  2641. tpg->se_tpg_tfo->tpg_get_tag(tpg),
  2642. config_item_name(&lun->lun_group.cg_item));
  2643. cur_len++; /* Extra byte for NULL terminator */
  2644. if ((cur_len + len) > PAGE_SIZE) {
  2645. pr_warn("Ran out of lu_gp_show_attr"
  2646. "_members buffer\n");
  2647. break;
  2648. }
  2649. memcpy(page+len, buf, cur_len);
  2650. len += cur_len;
  2651. }
  2652. spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
  2653. return len;
  2654. }
  2655. CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_state);
  2656. CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_status);
  2657. CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_type);
  2658. CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_transitioning);
  2659. CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_offline);
  2660. CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_lba_dependent);
  2661. CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_unavailable);
  2662. CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_standby);
  2663. CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_optimized);
  2664. CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_nonoptimized);
  2665. CONFIGFS_ATTR(target_tg_pt_gp_, alua_write_metadata);
  2666. CONFIGFS_ATTR(target_tg_pt_gp_, nonop_delay_msecs);
  2667. CONFIGFS_ATTR(target_tg_pt_gp_, trans_delay_msecs);
  2668. CONFIGFS_ATTR(target_tg_pt_gp_, implicit_trans_secs);
  2669. CONFIGFS_ATTR(target_tg_pt_gp_, preferred);
  2670. CONFIGFS_ATTR(target_tg_pt_gp_, tg_pt_gp_id);
  2671. CONFIGFS_ATTR_RO(target_tg_pt_gp_, members);
  2672. static struct configfs_attribute *target_core_alua_tg_pt_gp_attrs[] = {
  2673. &target_tg_pt_gp_attr_alua_access_state,
  2674. &target_tg_pt_gp_attr_alua_access_status,
  2675. &target_tg_pt_gp_attr_alua_access_type,
  2676. &target_tg_pt_gp_attr_alua_support_transitioning,
  2677. &target_tg_pt_gp_attr_alua_support_offline,
  2678. &target_tg_pt_gp_attr_alua_support_lba_dependent,
  2679. &target_tg_pt_gp_attr_alua_support_unavailable,
  2680. &target_tg_pt_gp_attr_alua_support_standby,
  2681. &target_tg_pt_gp_attr_alua_support_active_nonoptimized,
  2682. &target_tg_pt_gp_attr_alua_support_active_optimized,
  2683. &target_tg_pt_gp_attr_alua_write_metadata,
  2684. &target_tg_pt_gp_attr_nonop_delay_msecs,
  2685. &target_tg_pt_gp_attr_trans_delay_msecs,
  2686. &target_tg_pt_gp_attr_implicit_trans_secs,
  2687. &target_tg_pt_gp_attr_preferred,
  2688. &target_tg_pt_gp_attr_tg_pt_gp_id,
  2689. &target_tg_pt_gp_attr_members,
  2690. NULL,
  2691. };
  2692. static void target_core_alua_tg_pt_gp_release(struct config_item *item)
  2693. {
  2694. struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
  2695. struct t10_alua_tg_pt_gp, tg_pt_gp_group);
  2696. core_alua_free_tg_pt_gp(tg_pt_gp);
  2697. }
  2698. static struct configfs_item_operations target_core_alua_tg_pt_gp_ops = {
  2699. .release = target_core_alua_tg_pt_gp_release,
  2700. };
  2701. static const struct config_item_type target_core_alua_tg_pt_gp_cit = {
  2702. .ct_item_ops = &target_core_alua_tg_pt_gp_ops,
  2703. .ct_attrs = target_core_alua_tg_pt_gp_attrs,
  2704. .ct_owner = THIS_MODULE,
  2705. };
  2706. /* End functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
  2707. /* Start functions for struct config_item_type tb_alua_tg_pt_gps_cit */
  2708. static struct config_group *target_core_alua_create_tg_pt_gp(
  2709. struct config_group *group,
  2710. const char *name)
  2711. {
  2712. struct t10_alua *alua = container_of(group, struct t10_alua,
  2713. alua_tg_pt_gps_group);
  2714. struct t10_alua_tg_pt_gp *tg_pt_gp;
  2715. struct config_group *alua_tg_pt_gp_cg = NULL;
  2716. struct config_item *alua_tg_pt_gp_ci = NULL;
  2717. tg_pt_gp = core_alua_allocate_tg_pt_gp(alua->t10_dev, name, 0);
  2718. if (!tg_pt_gp)
  2719. return NULL;
  2720. alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
  2721. alua_tg_pt_gp_ci = &alua_tg_pt_gp_cg->cg_item;
  2722. config_group_init_type_name(alua_tg_pt_gp_cg, name,
  2723. &target_core_alua_tg_pt_gp_cit);
  2724. pr_debug("Target_Core_ConfigFS: Allocated ALUA Target Port"
  2725. " Group: alua/tg_pt_gps/%s\n",
  2726. config_item_name(alua_tg_pt_gp_ci));
  2727. return alua_tg_pt_gp_cg;
  2728. }
  2729. static void target_core_alua_drop_tg_pt_gp(
  2730. struct config_group *group,
  2731. struct config_item *item)
  2732. {
  2733. struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
  2734. struct t10_alua_tg_pt_gp, tg_pt_gp_group);
  2735. pr_debug("Target_Core_ConfigFS: Releasing ALUA Target Port"
  2736. " Group: alua/tg_pt_gps/%s, ID: %hu\n",
  2737. config_item_name(item), tg_pt_gp->tg_pt_gp_id);
  2738. /*
  2739. * core_alua_free_tg_pt_gp() is called from target_core_alua_tg_pt_gp_ops->release()
  2740. * -> target_core_alua_tg_pt_gp_release().
  2741. */
  2742. config_item_put(item);
  2743. }
  2744. static struct configfs_group_operations target_core_alua_tg_pt_gps_group_ops = {
  2745. .make_group = &target_core_alua_create_tg_pt_gp,
  2746. .drop_item = &target_core_alua_drop_tg_pt_gp,
  2747. };
  2748. TB_CIT_SETUP(dev_alua_tg_pt_gps, NULL, &target_core_alua_tg_pt_gps_group_ops, NULL);
  2749. /* End functions for struct config_item_type tb_alua_tg_pt_gps_cit */
  2750. /* Start functions for struct config_item_type target_core_alua_cit */
  2751. /*
  2752. * target_core_alua_cit is a ConfigFS group that lives under
  2753. * /sys/kernel/config/target/core/alua. There are default groups
  2754. * core/alua/lu_gps and core/alua/tg_pt_gps that are attached to
  2755. * target_core_alua_cit in target_core_init_configfs() below.
  2756. */
  2757. static const struct config_item_type target_core_alua_cit = {
  2758. .ct_item_ops = NULL,
  2759. .ct_attrs = NULL,
  2760. .ct_owner = THIS_MODULE,
  2761. };
  2762. /* End functions for struct config_item_type target_core_alua_cit */
  2763. /* Start functions for struct config_item_type tb_dev_stat_cit */
  2764. static struct config_group *target_core_stat_mkdir(
  2765. struct config_group *group,
  2766. const char *name)
  2767. {
  2768. return ERR_PTR(-ENOSYS);
  2769. }
  2770. static void target_core_stat_rmdir(
  2771. struct config_group *group,
  2772. struct config_item *item)
  2773. {
  2774. return;
  2775. }
  2776. static struct configfs_group_operations target_core_stat_group_ops = {
  2777. .make_group = &target_core_stat_mkdir,
  2778. .drop_item = &target_core_stat_rmdir,
  2779. };
  2780. TB_CIT_SETUP(dev_stat, NULL, &target_core_stat_group_ops, NULL);
  2781. /* End functions for struct config_item_type tb_dev_stat_cit */
  2782. /* Start functions for struct config_item_type target_core_hba_cit */
  2783. static struct config_group *target_core_make_subdev(
  2784. struct config_group *group,
  2785. const char *name)
  2786. {
  2787. struct t10_alua_tg_pt_gp *tg_pt_gp;
  2788. struct config_item *hba_ci = &group->cg_item;
  2789. struct se_hba *hba = item_to_hba(hba_ci);
  2790. struct target_backend *tb = hba->backend;
  2791. struct se_device *dev;
  2792. int errno = -ENOMEM, ret;
  2793. ret = mutex_lock_interruptible(&hba->hba_access_mutex);
  2794. if (ret)
  2795. return ERR_PTR(ret);
  2796. dev = target_alloc_device(hba, name);
  2797. if (!dev)
  2798. goto out_unlock;
  2799. config_group_init_type_name(&dev->dev_group, name, &tb->tb_dev_cit);
  2800. config_group_init_type_name(&dev->dev_action_group, "action",
  2801. &tb->tb_dev_action_cit);
  2802. configfs_add_default_group(&dev->dev_action_group, &dev->dev_group);
  2803. config_group_init_type_name(&dev->dev_attrib.da_group, "attrib",
  2804. &tb->tb_dev_attrib_cit);
  2805. configfs_add_default_group(&dev->dev_attrib.da_group, &dev->dev_group);
  2806. config_group_init_type_name(&dev->dev_pr_group, "pr",
  2807. &tb->tb_dev_pr_cit);
  2808. configfs_add_default_group(&dev->dev_pr_group, &dev->dev_group);
  2809. config_group_init_type_name(&dev->t10_wwn.t10_wwn_group, "wwn",
  2810. &tb->tb_dev_wwn_cit);
  2811. configfs_add_default_group(&dev->t10_wwn.t10_wwn_group,
  2812. &dev->dev_group);
  2813. config_group_init_type_name(&dev->t10_alua.alua_tg_pt_gps_group,
  2814. "alua", &tb->tb_dev_alua_tg_pt_gps_cit);
  2815. configfs_add_default_group(&dev->t10_alua.alua_tg_pt_gps_group,
  2816. &dev->dev_group);
  2817. config_group_init_type_name(&dev->dev_stat_grps.stat_group,
  2818. "statistics", &tb->tb_dev_stat_cit);
  2819. configfs_add_default_group(&dev->dev_stat_grps.stat_group,
  2820. &dev->dev_group);
  2821. /*
  2822. * Add core/$HBA/$DEV/alua/default_tg_pt_gp
  2823. */
  2824. tg_pt_gp = core_alua_allocate_tg_pt_gp(dev, "default_tg_pt_gp", 1);
  2825. if (!tg_pt_gp)
  2826. goto out_free_device;
  2827. dev->t10_alua.default_tg_pt_gp = tg_pt_gp;
  2828. config_group_init_type_name(&tg_pt_gp->tg_pt_gp_group,
  2829. "default_tg_pt_gp", &target_core_alua_tg_pt_gp_cit);
  2830. configfs_add_default_group(&tg_pt_gp->tg_pt_gp_group,
  2831. &dev->t10_alua.alua_tg_pt_gps_group);
  2832. /*
  2833. * Add core/$HBA/$DEV/statistics/ default groups
  2834. */
  2835. target_stat_setup_dev_default_groups(dev);
  2836. mutex_unlock(&hba->hba_access_mutex);
  2837. return &dev->dev_group;
  2838. out_free_device:
  2839. target_free_device(dev);
  2840. out_unlock:
  2841. mutex_unlock(&hba->hba_access_mutex);
  2842. return ERR_PTR(errno);
  2843. }
  2844. static void target_core_drop_subdev(
  2845. struct config_group *group,
  2846. struct config_item *item)
  2847. {
  2848. struct config_group *dev_cg = to_config_group(item);
  2849. struct se_device *dev =
  2850. container_of(dev_cg, struct se_device, dev_group);
  2851. struct se_hba *hba;
  2852. hba = item_to_hba(&dev->se_hba->hba_group.cg_item);
  2853. mutex_lock(&hba->hba_access_mutex);
  2854. configfs_remove_default_groups(&dev->dev_stat_grps.stat_group);
  2855. configfs_remove_default_groups(&dev->t10_alua.alua_tg_pt_gps_group);
  2856. /*
  2857. * core_alua_free_tg_pt_gp() is called from ->default_tg_pt_gp
  2858. * directly from target_core_alua_tg_pt_gp_release().
  2859. */
  2860. dev->t10_alua.default_tg_pt_gp = NULL;
  2861. configfs_remove_default_groups(dev_cg);
  2862. /*
  2863. * se_dev is released from target_core_dev_item_ops->release()
  2864. */
  2865. config_item_put(item);
  2866. mutex_unlock(&hba->hba_access_mutex);
  2867. }
  2868. static struct configfs_group_operations target_core_hba_group_ops = {
  2869. .make_group = target_core_make_subdev,
  2870. .drop_item = target_core_drop_subdev,
  2871. };
  2872. static inline struct se_hba *to_hba(struct config_item *item)
  2873. {
  2874. return container_of(to_config_group(item), struct se_hba, hba_group);
  2875. }
  2876. static ssize_t target_hba_info_show(struct config_item *item, char *page)
  2877. {
  2878. struct se_hba *hba = to_hba(item);
  2879. return sprintf(page, "HBA Index: %d plugin: %s version: %s\n",
  2880. hba->hba_id, hba->backend->ops->name,
  2881. TARGET_CORE_VERSION);
  2882. }
  2883. static ssize_t target_hba_mode_show(struct config_item *item, char *page)
  2884. {
  2885. struct se_hba *hba = to_hba(item);
  2886. int hba_mode = 0;
  2887. if (hba->hba_flags & HBA_FLAGS_PSCSI_MODE)
  2888. hba_mode = 1;
  2889. return sprintf(page, "%d\n", hba_mode);
  2890. }
  2891. static ssize_t target_hba_mode_store(struct config_item *item,
  2892. const char *page, size_t count)
  2893. {
  2894. struct se_hba *hba = to_hba(item);
  2895. unsigned long mode_flag;
  2896. int ret;
  2897. if (hba->backend->ops->pmode_enable_hba == NULL)
  2898. return -EINVAL;
  2899. ret = kstrtoul(page, 0, &mode_flag);
  2900. if (ret < 0) {
  2901. pr_err("Unable to extract hba mode flag: %d\n", ret);
  2902. return ret;
  2903. }
  2904. if (hba->dev_count) {
  2905. pr_err("Unable to set hba_mode with active devices\n");
  2906. return -EINVAL;
  2907. }
  2908. ret = hba->backend->ops->pmode_enable_hba(hba, mode_flag);
  2909. if (ret < 0)
  2910. return -EINVAL;
  2911. if (ret > 0)
  2912. hba->hba_flags |= HBA_FLAGS_PSCSI_MODE;
  2913. else if (ret == 0)
  2914. hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
  2915. return count;
  2916. }
  2917. CONFIGFS_ATTR_RO(target_, hba_info);
  2918. CONFIGFS_ATTR(target_, hba_mode);
  2919. static void target_core_hba_release(struct config_item *item)
  2920. {
  2921. struct se_hba *hba = container_of(to_config_group(item),
  2922. struct se_hba, hba_group);
  2923. core_delete_hba(hba);
  2924. }
  2925. static struct configfs_attribute *target_core_hba_attrs[] = {
  2926. &target_attr_hba_info,
  2927. &target_attr_hba_mode,
  2928. NULL,
  2929. };
  2930. static struct configfs_item_operations target_core_hba_item_ops = {
  2931. .release = target_core_hba_release,
  2932. };
  2933. static const struct config_item_type target_core_hba_cit = {
  2934. .ct_item_ops = &target_core_hba_item_ops,
  2935. .ct_group_ops = &target_core_hba_group_ops,
  2936. .ct_attrs = target_core_hba_attrs,
  2937. .ct_owner = THIS_MODULE,
  2938. };
  2939. static struct config_group *target_core_call_addhbatotarget(
  2940. struct config_group *group,
  2941. const char *name)
  2942. {
  2943. char *se_plugin_str, *str, *str2;
  2944. struct se_hba *hba;
  2945. char buf[TARGET_CORE_NAME_MAX_LEN];
  2946. unsigned long plugin_dep_id = 0;
  2947. int ret;
  2948. memset(buf, 0, TARGET_CORE_NAME_MAX_LEN);
  2949. if (strlen(name) >= TARGET_CORE_NAME_MAX_LEN) {
  2950. pr_err("Passed *name strlen(): %d exceeds"
  2951. " TARGET_CORE_NAME_MAX_LEN: %d\n", (int)strlen(name),
  2952. TARGET_CORE_NAME_MAX_LEN);
  2953. return ERR_PTR(-ENAMETOOLONG);
  2954. }
  2955. snprintf(buf, TARGET_CORE_NAME_MAX_LEN, "%s", name);
  2956. str = strstr(buf, "_");
  2957. if (!str) {
  2958. pr_err("Unable to locate \"_\" for $SUBSYSTEM_PLUGIN_$HOST_ID\n");
  2959. return ERR_PTR(-EINVAL);
  2960. }
  2961. se_plugin_str = buf;
  2962. /*
  2963. * Special case for subsystem plugins that have "_" in their names.
  2964. * Namely rd_direct and rd_mcp..
  2965. */
  2966. str2 = strstr(str+1, "_");
  2967. if (str2) {
  2968. *str2 = '\0'; /* Terminate for *se_plugin_str */
  2969. str2++; /* Skip to start of plugin dependent ID */
  2970. str = str2;
  2971. } else {
  2972. *str = '\0'; /* Terminate for *se_plugin_str */
  2973. str++; /* Skip to start of plugin dependent ID */
  2974. }
  2975. ret = kstrtoul(str, 0, &plugin_dep_id);
  2976. if (ret < 0) {
  2977. pr_err("kstrtoul() returned %d for"
  2978. " plugin_dep_id\n", ret);
  2979. return ERR_PTR(ret);
  2980. }
  2981. /*
  2982. * Load up TCM subsystem plugins if they have not already been loaded.
  2983. */
  2984. transport_subsystem_check_init();
  2985. hba = core_alloc_hba(se_plugin_str, plugin_dep_id, 0);
  2986. if (IS_ERR(hba))
  2987. return ERR_CAST(hba);
  2988. config_group_init_type_name(&hba->hba_group, name,
  2989. &target_core_hba_cit);
  2990. return &hba->hba_group;
  2991. }
  2992. static void target_core_call_delhbafromtarget(
  2993. struct config_group *group,
  2994. struct config_item *item)
  2995. {
  2996. /*
  2997. * core_delete_hba() is called from target_core_hba_item_ops->release()
  2998. * -> target_core_hba_release()
  2999. */
  3000. config_item_put(item);
  3001. }
  3002. static struct configfs_group_operations target_core_group_ops = {
  3003. .make_group = target_core_call_addhbatotarget,
  3004. .drop_item = target_core_call_delhbafromtarget,
  3005. };
  3006. static const struct config_item_type target_core_cit = {
  3007. .ct_item_ops = NULL,
  3008. .ct_group_ops = &target_core_group_ops,
  3009. .ct_attrs = NULL,
  3010. .ct_owner = THIS_MODULE,
  3011. };
  3012. /* Stop functions for struct config_item_type target_core_hba_cit */
  3013. void target_setup_backend_cits(struct target_backend *tb)
  3014. {
  3015. target_core_setup_dev_cit(tb);
  3016. target_core_setup_dev_action_cit(tb);
  3017. target_core_setup_dev_attrib_cit(tb);
  3018. target_core_setup_dev_pr_cit(tb);
  3019. target_core_setup_dev_wwn_cit(tb);
  3020. target_core_setup_dev_alua_tg_pt_gps_cit(tb);
  3021. target_core_setup_dev_stat_cit(tb);
  3022. }
  3023. static void target_init_dbroot(void)
  3024. {
  3025. struct file *fp;
  3026. snprintf(db_root_stage, DB_ROOT_LEN, DB_ROOT_PREFERRED);
  3027. fp = filp_open(db_root_stage, O_RDONLY, 0);
  3028. if (IS_ERR(fp)) {
  3029. pr_err("db_root: cannot open: %s\n", db_root_stage);
  3030. return;
  3031. }
  3032. if (!S_ISDIR(file_inode(fp)->i_mode)) {
  3033. filp_close(fp, NULL);
  3034. pr_err("db_root: not a valid directory: %s\n", db_root_stage);
  3035. return;
  3036. }
  3037. filp_close(fp, NULL);
  3038. strncpy(db_root, db_root_stage, DB_ROOT_LEN);
  3039. pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root);
  3040. }
  3041. static int __init target_core_init_configfs(void)
  3042. {
  3043. struct configfs_subsystem *subsys = &target_core_fabrics;
  3044. struct t10_alua_lu_gp *lu_gp;
  3045. int ret;
  3046. pr_debug("TARGET_CORE[0]: Loading Generic Kernel Storage"
  3047. " Engine: %s on %s/%s on "UTS_RELEASE"\n",
  3048. TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
  3049. config_group_init(&subsys->su_group);
  3050. mutex_init(&subsys->su_mutex);
  3051. ret = init_se_kmem_caches();
  3052. if (ret < 0)
  3053. return ret;
  3054. /*
  3055. * Create $CONFIGFS/target/core default group for HBA <-> Storage Object
  3056. * and ALUA Logical Unit Group and Target Port Group infrastructure.
  3057. */
  3058. config_group_init_type_name(&target_core_hbagroup, "core",
  3059. &target_core_cit);
  3060. configfs_add_default_group(&target_core_hbagroup, &subsys->su_group);
  3061. /*
  3062. * Create ALUA infrastructure under /sys/kernel/config/target/core/alua/
  3063. */
  3064. config_group_init_type_name(&alua_group, "alua", &target_core_alua_cit);
  3065. configfs_add_default_group(&alua_group, &target_core_hbagroup);
  3066. /*
  3067. * Add ALUA Logical Unit Group and Target Port Group ConfigFS
  3068. * groups under /sys/kernel/config/target/core/alua/
  3069. */
  3070. config_group_init_type_name(&alua_lu_gps_group, "lu_gps",
  3071. &target_core_alua_lu_gps_cit);
  3072. configfs_add_default_group(&alua_lu_gps_group, &alua_group);
  3073. /*
  3074. * Add core/alua/lu_gps/default_lu_gp
  3075. */
  3076. lu_gp = core_alua_allocate_lu_gp("default_lu_gp", 1);
  3077. if (IS_ERR(lu_gp)) {
  3078. ret = -ENOMEM;
  3079. goto out_global;
  3080. }
  3081. config_group_init_type_name(&lu_gp->lu_gp_group, "default_lu_gp",
  3082. &target_core_alua_lu_gp_cit);
  3083. configfs_add_default_group(&lu_gp->lu_gp_group, &alua_lu_gps_group);
  3084. default_lu_gp = lu_gp;
  3085. /*
  3086. * Register the target_core_mod subsystem with configfs.
  3087. */
  3088. ret = configfs_register_subsystem(subsys);
  3089. if (ret < 0) {
  3090. pr_err("Error %d while registering subsystem %s\n",
  3091. ret, subsys->su_group.cg_item.ci_namebuf);
  3092. goto out_global;
  3093. }
  3094. pr_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric"
  3095. " Infrastructure: "TARGET_CORE_VERSION" on %s/%s"
  3096. " on "UTS_RELEASE"\n", utsname()->sysname, utsname()->machine);
  3097. /*
  3098. * Register built-in RAMDISK subsystem logic for virtual LUN 0
  3099. */
  3100. ret = rd_module_init();
  3101. if (ret < 0)
  3102. goto out;
  3103. ret = core_dev_setup_virtual_lun0();
  3104. if (ret < 0)
  3105. goto out;
  3106. ret = target_xcopy_setup_pt();
  3107. if (ret < 0)
  3108. goto out;
  3109. target_init_dbroot();
  3110. return 0;
  3111. out:
  3112. configfs_unregister_subsystem(subsys);
  3113. core_dev_release_virtual_lun0();
  3114. rd_module_exit();
  3115. out_global:
  3116. if (default_lu_gp) {
  3117. core_alua_free_lu_gp(default_lu_gp);
  3118. default_lu_gp = NULL;
  3119. }
  3120. release_se_kmem_caches();
  3121. return ret;
  3122. }
  3123. static void __exit target_core_exit_configfs(void)
  3124. {
  3125. configfs_remove_default_groups(&alua_lu_gps_group);
  3126. configfs_remove_default_groups(&alua_group);
  3127. configfs_remove_default_groups(&target_core_hbagroup);
  3128. /*
  3129. * We expect subsys->su_group.default_groups to be released
  3130. * by configfs subsystem provider logic..
  3131. */
  3132. configfs_unregister_subsystem(&target_core_fabrics);
  3133. core_alua_free_lu_gp(default_lu_gp);
  3134. default_lu_gp = NULL;
  3135. pr_debug("TARGET_CORE[0]: Released ConfigFS Fabric"
  3136. " Infrastructure\n");
  3137. core_dev_release_virtual_lun0();
  3138. rd_module_exit();
  3139. target_xcopy_release_pt();
  3140. release_se_kmem_caches();
  3141. }
  3142. MODULE_DESCRIPTION("Target_Core_Mod/ConfigFS");
  3143. MODULE_AUTHOR("nab@Linux-iSCSI.org");
  3144. MODULE_LICENSE("GPL");
  3145. MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
  3146. module_init(target_core_init_configfs);
  3147. module_exit(target_core_exit_configfs);