fs_context.c 38 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * linux/fs/nfs/fs_context.c
  4. *
  5. * Copyright (C) 1992 Rick Sladkey
  6. * Conversion to new mount api Copyright (C) David Howells
  7. *
  8. * NFS mount handling.
  9. *
  10. * Split from fs/nfs/super.c by David Howells <dhowells@redhat.com>
  11. */
  12. #include <linux/module.h>
  13. #include <linux/fs.h>
  14. #include <linux/fs_context.h>
  15. #include <linux/fs_parser.h>
  16. #include <linux/nfs_fs.h>
  17. #include <linux/nfs_mount.h>
  18. #include <linux/nfs4_mount.h>
  19. #include "nfs.h"
  20. #include "internal.h"
  21. #define NFSDBG_FACILITY NFSDBG_MOUNT
  22. #if IS_ENABLED(CONFIG_NFS_V3)
  23. #define NFS_DEFAULT_VERSION 3
  24. #else
  25. #define NFS_DEFAULT_VERSION 2
  26. #endif
  27. #define NFS_MAX_CONNECTIONS 16
  28. enum nfs_param {
  29. Opt_ac,
  30. Opt_acdirmax,
  31. Opt_acdirmin,
  32. Opt_acl,
  33. Opt_acregmax,
  34. Opt_acregmin,
  35. Opt_actimeo,
  36. Opt_addr,
  37. Opt_bg,
  38. Opt_bsize,
  39. Opt_clientaddr,
  40. Opt_cto,
  41. Opt_fg,
  42. Opt_fscache,
  43. Opt_fscache_flag,
  44. Opt_hard,
  45. Opt_intr,
  46. Opt_local_lock,
  47. Opt_lock,
  48. Opt_lookupcache,
  49. Opt_migration,
  50. Opt_minorversion,
  51. Opt_mountaddr,
  52. Opt_mounthost,
  53. Opt_mountport,
  54. Opt_mountproto,
  55. Opt_mountvers,
  56. Opt_namelen,
  57. Opt_nconnect,
  58. Opt_port,
  59. Opt_posix,
  60. Opt_proto,
  61. Opt_rdirplus,
  62. Opt_rdma,
  63. Opt_resvport,
  64. Opt_retrans,
  65. Opt_retry,
  66. Opt_rsize,
  67. Opt_sec,
  68. Opt_sharecache,
  69. Opt_sloppy,
  70. Opt_soft,
  71. Opt_softerr,
  72. Opt_softreval,
  73. Opt_source,
  74. Opt_tcp,
  75. Opt_timeo,
  76. Opt_udp,
  77. Opt_v,
  78. Opt_vers,
  79. Opt_wsize,
  80. };
  81. enum {
  82. Opt_local_lock_all,
  83. Opt_local_lock_flock,
  84. Opt_local_lock_none,
  85. Opt_local_lock_posix,
  86. };
  87. static const struct constant_table nfs_param_enums_local_lock[] = {
  88. { "all", Opt_local_lock_all },
  89. { "flock", Opt_local_lock_flock },
  90. { "posix", Opt_local_lock_posix },
  91. { "none", Opt_local_lock_none },
  92. {}
  93. };
  94. enum {
  95. Opt_lookupcache_all,
  96. Opt_lookupcache_none,
  97. Opt_lookupcache_positive,
  98. };
  99. static const struct constant_table nfs_param_enums_lookupcache[] = {
  100. { "all", Opt_lookupcache_all },
  101. { "none", Opt_lookupcache_none },
  102. { "pos", Opt_lookupcache_positive },
  103. { "positive", Opt_lookupcache_positive },
  104. {}
  105. };
  106. static const struct fs_parameter_spec nfs_fs_parameters[] = {
  107. fsparam_flag_no("ac", Opt_ac),
  108. fsparam_u32 ("acdirmax", Opt_acdirmax),
  109. fsparam_u32 ("acdirmin", Opt_acdirmin),
  110. fsparam_flag_no("acl", Opt_acl),
  111. fsparam_u32 ("acregmax", Opt_acregmax),
  112. fsparam_u32 ("acregmin", Opt_acregmin),
  113. fsparam_u32 ("actimeo", Opt_actimeo),
  114. fsparam_string("addr", Opt_addr),
  115. fsparam_flag ("bg", Opt_bg),
  116. fsparam_u32 ("bsize", Opt_bsize),
  117. fsparam_string("clientaddr", Opt_clientaddr),
  118. fsparam_flag_no("cto", Opt_cto),
  119. fsparam_flag ("fg", Opt_fg),
  120. fsparam_flag_no("fsc", Opt_fscache_flag),
  121. fsparam_string("fsc", Opt_fscache),
  122. fsparam_flag ("hard", Opt_hard),
  123. __fsparam(NULL, "intr", Opt_intr,
  124. fs_param_neg_with_no|fs_param_deprecated, NULL),
  125. fsparam_enum ("local_lock", Opt_local_lock, nfs_param_enums_local_lock),
  126. fsparam_flag_no("lock", Opt_lock),
  127. fsparam_enum ("lookupcache", Opt_lookupcache, nfs_param_enums_lookupcache),
  128. fsparam_flag_no("migration", Opt_migration),
  129. fsparam_u32 ("minorversion", Opt_minorversion),
  130. fsparam_string("mountaddr", Opt_mountaddr),
  131. fsparam_string("mounthost", Opt_mounthost),
  132. fsparam_u32 ("mountport", Opt_mountport),
  133. fsparam_string("mountproto", Opt_mountproto),
  134. fsparam_u32 ("mountvers", Opt_mountvers),
  135. fsparam_u32 ("namlen", Opt_namelen),
  136. fsparam_u32 ("nconnect", Opt_nconnect),
  137. fsparam_string("nfsvers", Opt_vers),
  138. fsparam_u32 ("port", Opt_port),
  139. fsparam_flag_no("posix", Opt_posix),
  140. fsparam_string("proto", Opt_proto),
  141. fsparam_flag_no("rdirplus", Opt_rdirplus),
  142. fsparam_flag ("rdma", Opt_rdma),
  143. fsparam_flag_no("resvport", Opt_resvport),
  144. fsparam_u32 ("retrans", Opt_retrans),
  145. fsparam_string("retry", Opt_retry),
  146. fsparam_u32 ("rsize", Opt_rsize),
  147. fsparam_string("sec", Opt_sec),
  148. fsparam_flag_no("sharecache", Opt_sharecache),
  149. fsparam_flag ("sloppy", Opt_sloppy),
  150. fsparam_flag ("soft", Opt_soft),
  151. fsparam_flag ("softerr", Opt_softerr),
  152. fsparam_flag ("softreval", Opt_softreval),
  153. fsparam_string("source", Opt_source),
  154. fsparam_flag ("tcp", Opt_tcp),
  155. fsparam_u32 ("timeo", Opt_timeo),
  156. fsparam_flag ("udp", Opt_udp),
  157. fsparam_flag ("v2", Opt_v),
  158. fsparam_flag ("v3", Opt_v),
  159. fsparam_flag ("v4", Opt_v),
  160. fsparam_flag ("v4.0", Opt_v),
  161. fsparam_flag ("v4.1", Opt_v),
  162. fsparam_flag ("v4.2", Opt_v),
  163. fsparam_string("vers", Opt_vers),
  164. fsparam_u32 ("wsize", Opt_wsize),
  165. {}
  166. };
  167. enum {
  168. Opt_vers_2,
  169. Opt_vers_3,
  170. Opt_vers_4,
  171. Opt_vers_4_0,
  172. Opt_vers_4_1,
  173. Opt_vers_4_2,
  174. };
  175. static const struct constant_table nfs_vers_tokens[] = {
  176. { "2", Opt_vers_2 },
  177. { "3", Opt_vers_3 },
  178. { "4", Opt_vers_4 },
  179. { "4.0", Opt_vers_4_0 },
  180. { "4.1", Opt_vers_4_1 },
  181. { "4.2", Opt_vers_4_2 },
  182. {}
  183. };
  184. enum {
  185. Opt_xprt_rdma,
  186. Opt_xprt_rdma6,
  187. Opt_xprt_tcp,
  188. Opt_xprt_tcp6,
  189. Opt_xprt_udp,
  190. Opt_xprt_udp6,
  191. nr__Opt_xprt
  192. };
  193. static const struct constant_table nfs_xprt_protocol_tokens[] = {
  194. { "rdma", Opt_xprt_rdma },
  195. { "rdma6", Opt_xprt_rdma6 },
  196. { "tcp", Opt_xprt_tcp },
  197. { "tcp6", Opt_xprt_tcp6 },
  198. { "udp", Opt_xprt_udp },
  199. { "udp6", Opt_xprt_udp6 },
  200. {}
  201. };
  202. enum {
  203. Opt_sec_krb5,
  204. Opt_sec_krb5i,
  205. Opt_sec_krb5p,
  206. Opt_sec_lkey,
  207. Opt_sec_lkeyi,
  208. Opt_sec_lkeyp,
  209. Opt_sec_none,
  210. Opt_sec_spkm,
  211. Opt_sec_spkmi,
  212. Opt_sec_spkmp,
  213. Opt_sec_sys,
  214. nr__Opt_sec
  215. };
  216. static const struct constant_table nfs_secflavor_tokens[] = {
  217. { "krb5", Opt_sec_krb5 },
  218. { "krb5i", Opt_sec_krb5i },
  219. { "krb5p", Opt_sec_krb5p },
  220. { "lkey", Opt_sec_lkey },
  221. { "lkeyi", Opt_sec_lkeyi },
  222. { "lkeyp", Opt_sec_lkeyp },
  223. { "none", Opt_sec_none },
  224. { "null", Opt_sec_none },
  225. { "spkm3", Opt_sec_spkm },
  226. { "spkm3i", Opt_sec_spkmi },
  227. { "spkm3p", Opt_sec_spkmp },
  228. { "sys", Opt_sec_sys },
  229. {}
  230. };
  231. /*
  232. * Sanity-check a server address provided by the mount command.
  233. *
  234. * Address family must be initialized, and address must not be
  235. * the ANY address for that family.
  236. */
  237. static int nfs_verify_server_address(struct sockaddr *addr)
  238. {
  239. switch (addr->sa_family) {
  240. case AF_INET: {
  241. struct sockaddr_in *sa = (struct sockaddr_in *)addr;
  242. return sa->sin_addr.s_addr != htonl(INADDR_ANY);
  243. }
  244. case AF_INET6: {
  245. struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
  246. return !ipv6_addr_any(sa);
  247. }
  248. }
  249. dfprintk(MOUNT, "NFS: Invalid IP address specified\n");
  250. return 0;
  251. }
  252. /*
  253. * Sanity check the NFS transport protocol.
  254. *
  255. */
  256. static void nfs_validate_transport_protocol(struct nfs_fs_context *ctx)
  257. {
  258. switch (ctx->nfs_server.protocol) {
  259. case XPRT_TRANSPORT_UDP:
  260. case XPRT_TRANSPORT_TCP:
  261. case XPRT_TRANSPORT_RDMA:
  262. break;
  263. default:
  264. ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
  265. }
  266. }
  267. /*
  268. * For text based NFSv2/v3 mounts, the mount protocol transport default
  269. * settings should depend upon the specified NFS transport.
  270. */
  271. static void nfs_set_mount_transport_protocol(struct nfs_fs_context *ctx)
  272. {
  273. nfs_validate_transport_protocol(ctx);
  274. if (ctx->mount_server.protocol == XPRT_TRANSPORT_UDP ||
  275. ctx->mount_server.protocol == XPRT_TRANSPORT_TCP)
  276. return;
  277. switch (ctx->nfs_server.protocol) {
  278. case XPRT_TRANSPORT_UDP:
  279. ctx->mount_server.protocol = XPRT_TRANSPORT_UDP;
  280. break;
  281. case XPRT_TRANSPORT_TCP:
  282. case XPRT_TRANSPORT_RDMA:
  283. ctx->mount_server.protocol = XPRT_TRANSPORT_TCP;
  284. }
  285. }
  286. /*
  287. * Add 'flavor' to 'auth_info' if not already present.
  288. * Returns true if 'flavor' ends up in the list, false otherwise
  289. */
  290. static int nfs_auth_info_add(struct fs_context *fc,
  291. struct nfs_auth_info *auth_info,
  292. rpc_authflavor_t flavor)
  293. {
  294. unsigned int i;
  295. unsigned int max_flavor_len = ARRAY_SIZE(auth_info->flavors);
  296. /* make sure this flavor isn't already in the list */
  297. for (i = 0; i < auth_info->flavor_len; i++) {
  298. if (flavor == auth_info->flavors[i])
  299. return 0;
  300. }
  301. if (auth_info->flavor_len + 1 >= max_flavor_len)
  302. return nfs_invalf(fc, "NFS: too many sec= flavors");
  303. auth_info->flavors[auth_info->flavor_len++] = flavor;
  304. return 0;
  305. }
  306. /*
  307. * Parse the value of the 'sec=' option.
  308. */
  309. static int nfs_parse_security_flavors(struct fs_context *fc,
  310. struct fs_parameter *param)
  311. {
  312. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  313. rpc_authflavor_t pseudoflavor;
  314. char *string = param->string, *p;
  315. int ret;
  316. dfprintk(MOUNT, "NFS: parsing %s=%s option\n", param->key, param->string);
  317. while ((p = strsep(&string, ":")) != NULL) {
  318. if (!*p)
  319. continue;
  320. switch (lookup_constant(nfs_secflavor_tokens, p, -1)) {
  321. case Opt_sec_none:
  322. pseudoflavor = RPC_AUTH_NULL;
  323. break;
  324. case Opt_sec_sys:
  325. pseudoflavor = RPC_AUTH_UNIX;
  326. break;
  327. case Opt_sec_krb5:
  328. pseudoflavor = RPC_AUTH_GSS_KRB5;
  329. break;
  330. case Opt_sec_krb5i:
  331. pseudoflavor = RPC_AUTH_GSS_KRB5I;
  332. break;
  333. case Opt_sec_krb5p:
  334. pseudoflavor = RPC_AUTH_GSS_KRB5P;
  335. break;
  336. case Opt_sec_lkey:
  337. pseudoflavor = RPC_AUTH_GSS_LKEY;
  338. break;
  339. case Opt_sec_lkeyi:
  340. pseudoflavor = RPC_AUTH_GSS_LKEYI;
  341. break;
  342. case Opt_sec_lkeyp:
  343. pseudoflavor = RPC_AUTH_GSS_LKEYP;
  344. break;
  345. case Opt_sec_spkm:
  346. pseudoflavor = RPC_AUTH_GSS_SPKM;
  347. break;
  348. case Opt_sec_spkmi:
  349. pseudoflavor = RPC_AUTH_GSS_SPKMI;
  350. break;
  351. case Opt_sec_spkmp:
  352. pseudoflavor = RPC_AUTH_GSS_SPKMP;
  353. break;
  354. default:
  355. return nfs_invalf(fc, "NFS: sec=%s option not recognized", p);
  356. }
  357. ret = nfs_auth_info_add(fc, &ctx->auth_info, pseudoflavor);
  358. if (ret < 0)
  359. return ret;
  360. }
  361. return 0;
  362. }
  363. static int nfs_parse_version_string(struct fs_context *fc,
  364. const char *string)
  365. {
  366. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  367. ctx->flags &= ~NFS_MOUNT_VER3;
  368. switch (lookup_constant(nfs_vers_tokens, string, -1)) {
  369. case Opt_vers_2:
  370. ctx->version = 2;
  371. break;
  372. case Opt_vers_3:
  373. ctx->flags |= NFS_MOUNT_VER3;
  374. ctx->version = 3;
  375. break;
  376. case Opt_vers_4:
  377. /* Backward compatibility option. In future,
  378. * the mount program should always supply
  379. * a NFSv4 minor version number.
  380. */
  381. ctx->version = 4;
  382. break;
  383. case Opt_vers_4_0:
  384. ctx->version = 4;
  385. ctx->minorversion = 0;
  386. break;
  387. case Opt_vers_4_1:
  388. ctx->version = 4;
  389. ctx->minorversion = 1;
  390. break;
  391. case Opt_vers_4_2:
  392. ctx->version = 4;
  393. ctx->minorversion = 2;
  394. break;
  395. default:
  396. return nfs_invalf(fc, "NFS: Unsupported NFS version");
  397. }
  398. return 0;
  399. }
  400. /*
  401. * Parse a single mount parameter.
  402. */
  403. static int nfs_fs_context_parse_param(struct fs_context *fc,
  404. struct fs_parameter *param)
  405. {
  406. struct fs_parse_result result;
  407. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  408. unsigned short protofamily, mountfamily;
  409. unsigned int len;
  410. int ret, opt;
  411. dfprintk(MOUNT, "NFS: parsing nfs mount option '%s'\n", param->key);
  412. opt = fs_parse(fc, nfs_fs_parameters, param, &result);
  413. if (opt < 0)
  414. return ctx->sloppy ? 1 : opt;
  415. switch (opt) {
  416. case Opt_source:
  417. if (fc->source)
  418. return nfs_invalf(fc, "NFS: Multiple sources not supported");
  419. fc->source = param->string;
  420. param->string = NULL;
  421. break;
  422. /*
  423. * boolean options: foo/nofoo
  424. */
  425. case Opt_soft:
  426. ctx->flags |= NFS_MOUNT_SOFT;
  427. ctx->flags &= ~NFS_MOUNT_SOFTERR;
  428. break;
  429. case Opt_softerr:
  430. ctx->flags |= NFS_MOUNT_SOFTERR | NFS_MOUNT_SOFTREVAL;
  431. ctx->flags &= ~NFS_MOUNT_SOFT;
  432. break;
  433. case Opt_hard:
  434. ctx->flags &= ~(NFS_MOUNT_SOFT |
  435. NFS_MOUNT_SOFTERR |
  436. NFS_MOUNT_SOFTREVAL);
  437. break;
  438. case Opt_softreval:
  439. if (result.negated)
  440. ctx->flags &= ~NFS_MOUNT_SOFTREVAL;
  441. else
  442. ctx->flags &= NFS_MOUNT_SOFTREVAL;
  443. break;
  444. case Opt_posix:
  445. if (result.negated)
  446. ctx->flags &= ~NFS_MOUNT_POSIX;
  447. else
  448. ctx->flags |= NFS_MOUNT_POSIX;
  449. break;
  450. case Opt_cto:
  451. if (result.negated)
  452. ctx->flags |= NFS_MOUNT_NOCTO;
  453. else
  454. ctx->flags &= ~NFS_MOUNT_NOCTO;
  455. break;
  456. case Opt_ac:
  457. if (result.negated)
  458. ctx->flags |= NFS_MOUNT_NOAC;
  459. else
  460. ctx->flags &= ~NFS_MOUNT_NOAC;
  461. break;
  462. case Opt_lock:
  463. if (result.negated) {
  464. ctx->flags |= NFS_MOUNT_NONLM;
  465. ctx->flags |= (NFS_MOUNT_LOCAL_FLOCK | NFS_MOUNT_LOCAL_FCNTL);
  466. } else {
  467. ctx->flags &= ~NFS_MOUNT_NONLM;
  468. ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK | NFS_MOUNT_LOCAL_FCNTL);
  469. }
  470. break;
  471. case Opt_udp:
  472. ctx->flags &= ~NFS_MOUNT_TCP;
  473. ctx->nfs_server.protocol = XPRT_TRANSPORT_UDP;
  474. break;
  475. case Opt_tcp:
  476. ctx->flags |= NFS_MOUNT_TCP;
  477. ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
  478. break;
  479. case Opt_rdma:
  480. ctx->flags |= NFS_MOUNT_TCP; /* for side protocols */
  481. ctx->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
  482. xprt_load_transport(param->key);
  483. break;
  484. case Opt_acl:
  485. if (result.negated)
  486. ctx->flags |= NFS_MOUNT_NOACL;
  487. else
  488. ctx->flags &= ~NFS_MOUNT_NOACL;
  489. break;
  490. case Opt_rdirplus:
  491. if (result.negated)
  492. ctx->flags |= NFS_MOUNT_NORDIRPLUS;
  493. else
  494. ctx->flags &= ~NFS_MOUNT_NORDIRPLUS;
  495. break;
  496. case Opt_sharecache:
  497. if (result.negated)
  498. ctx->flags |= NFS_MOUNT_UNSHARED;
  499. else
  500. ctx->flags &= ~NFS_MOUNT_UNSHARED;
  501. break;
  502. case Opt_resvport:
  503. if (result.negated)
  504. ctx->flags |= NFS_MOUNT_NORESVPORT;
  505. else
  506. ctx->flags &= ~NFS_MOUNT_NORESVPORT;
  507. break;
  508. case Opt_fscache_flag:
  509. if (result.negated)
  510. ctx->options &= ~NFS_OPTION_FSCACHE;
  511. else
  512. ctx->options |= NFS_OPTION_FSCACHE;
  513. kfree(ctx->fscache_uniq);
  514. ctx->fscache_uniq = NULL;
  515. break;
  516. case Opt_fscache:
  517. ctx->options |= NFS_OPTION_FSCACHE;
  518. kfree(ctx->fscache_uniq);
  519. ctx->fscache_uniq = param->string;
  520. param->string = NULL;
  521. break;
  522. case Opt_migration:
  523. if (result.negated)
  524. ctx->options &= ~NFS_OPTION_MIGRATION;
  525. else
  526. ctx->options |= NFS_OPTION_MIGRATION;
  527. break;
  528. /*
  529. * options that take numeric values
  530. */
  531. case Opt_port:
  532. if (result.uint_32 > USHRT_MAX)
  533. goto out_of_bounds;
  534. ctx->nfs_server.port = result.uint_32;
  535. break;
  536. case Opt_rsize:
  537. ctx->rsize = result.uint_32;
  538. break;
  539. case Opt_wsize:
  540. ctx->wsize = result.uint_32;
  541. break;
  542. case Opt_bsize:
  543. ctx->bsize = result.uint_32;
  544. break;
  545. case Opt_timeo:
  546. if (result.uint_32 < 1 || result.uint_32 > INT_MAX)
  547. goto out_of_bounds;
  548. ctx->timeo = result.uint_32;
  549. break;
  550. case Opt_retrans:
  551. if (result.uint_32 > INT_MAX)
  552. goto out_of_bounds;
  553. ctx->retrans = result.uint_32;
  554. break;
  555. case Opt_acregmin:
  556. ctx->acregmin = result.uint_32;
  557. break;
  558. case Opt_acregmax:
  559. ctx->acregmax = result.uint_32;
  560. break;
  561. case Opt_acdirmin:
  562. ctx->acdirmin = result.uint_32;
  563. break;
  564. case Opt_acdirmax:
  565. ctx->acdirmax = result.uint_32;
  566. break;
  567. case Opt_actimeo:
  568. ctx->acregmin = result.uint_32;
  569. ctx->acregmax = result.uint_32;
  570. ctx->acdirmin = result.uint_32;
  571. ctx->acdirmax = result.uint_32;
  572. break;
  573. case Opt_namelen:
  574. ctx->namlen = result.uint_32;
  575. break;
  576. case Opt_mountport:
  577. if (result.uint_32 > USHRT_MAX)
  578. goto out_of_bounds;
  579. ctx->mount_server.port = result.uint_32;
  580. break;
  581. case Opt_mountvers:
  582. if (result.uint_32 < NFS_MNT_VERSION ||
  583. result.uint_32 > NFS_MNT3_VERSION)
  584. goto out_of_bounds;
  585. ctx->mount_server.version = result.uint_32;
  586. break;
  587. case Opt_minorversion:
  588. if (result.uint_32 > NFS4_MAX_MINOR_VERSION)
  589. goto out_of_bounds;
  590. ctx->minorversion = result.uint_32;
  591. break;
  592. /*
  593. * options that take text values
  594. */
  595. case Opt_v:
  596. ret = nfs_parse_version_string(fc, param->key + 1);
  597. if (ret < 0)
  598. return ret;
  599. break;
  600. case Opt_vers:
  601. ret = nfs_parse_version_string(fc, param->string);
  602. if (ret < 0)
  603. return ret;
  604. break;
  605. case Opt_sec:
  606. ret = nfs_parse_security_flavors(fc, param);
  607. if (ret < 0)
  608. return ret;
  609. break;
  610. case Opt_proto:
  611. protofamily = AF_INET;
  612. switch (lookup_constant(nfs_xprt_protocol_tokens, param->string, -1)) {
  613. case Opt_xprt_udp6:
  614. protofamily = AF_INET6;
  615. fallthrough;
  616. case Opt_xprt_udp:
  617. ctx->flags &= ~NFS_MOUNT_TCP;
  618. ctx->nfs_server.protocol = XPRT_TRANSPORT_UDP;
  619. break;
  620. case Opt_xprt_tcp6:
  621. protofamily = AF_INET6;
  622. fallthrough;
  623. case Opt_xprt_tcp:
  624. ctx->flags |= NFS_MOUNT_TCP;
  625. ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
  626. break;
  627. case Opt_xprt_rdma6:
  628. protofamily = AF_INET6;
  629. fallthrough;
  630. case Opt_xprt_rdma:
  631. /* vector side protocols to TCP */
  632. ctx->flags |= NFS_MOUNT_TCP;
  633. ctx->nfs_server.protocol = XPRT_TRANSPORT_RDMA;
  634. xprt_load_transport(param->string);
  635. break;
  636. default:
  637. return nfs_invalf(fc, "NFS: Unrecognized transport protocol");
  638. }
  639. ctx->protofamily = protofamily;
  640. break;
  641. case Opt_mountproto:
  642. mountfamily = AF_INET;
  643. switch (lookup_constant(nfs_xprt_protocol_tokens, param->string, -1)) {
  644. case Opt_xprt_udp6:
  645. mountfamily = AF_INET6;
  646. fallthrough;
  647. case Opt_xprt_udp:
  648. ctx->mount_server.protocol = XPRT_TRANSPORT_UDP;
  649. break;
  650. case Opt_xprt_tcp6:
  651. mountfamily = AF_INET6;
  652. fallthrough;
  653. case Opt_xprt_tcp:
  654. ctx->mount_server.protocol = XPRT_TRANSPORT_TCP;
  655. break;
  656. case Opt_xprt_rdma: /* not used for side protocols */
  657. default:
  658. return nfs_invalf(fc, "NFS: Unrecognized transport protocol");
  659. }
  660. ctx->mountfamily = mountfamily;
  661. break;
  662. case Opt_addr:
  663. len = rpc_pton(fc->net_ns, param->string, param->size,
  664. &ctx->nfs_server.address,
  665. sizeof(ctx->nfs_server._address));
  666. if (len == 0)
  667. goto out_invalid_address;
  668. ctx->nfs_server.addrlen = len;
  669. break;
  670. case Opt_clientaddr:
  671. kfree(ctx->client_address);
  672. ctx->client_address = param->string;
  673. param->string = NULL;
  674. break;
  675. case Opt_mounthost:
  676. kfree(ctx->mount_server.hostname);
  677. ctx->mount_server.hostname = param->string;
  678. param->string = NULL;
  679. break;
  680. case Opt_mountaddr:
  681. len = rpc_pton(fc->net_ns, param->string, param->size,
  682. &ctx->mount_server.address,
  683. sizeof(ctx->mount_server._address));
  684. if (len == 0)
  685. goto out_invalid_address;
  686. ctx->mount_server.addrlen = len;
  687. break;
  688. case Opt_nconnect:
  689. if (result.uint_32 < 1 || result.uint_32 > NFS_MAX_CONNECTIONS)
  690. goto out_of_bounds;
  691. ctx->nfs_server.nconnect = result.uint_32;
  692. break;
  693. case Opt_lookupcache:
  694. switch (result.uint_32) {
  695. case Opt_lookupcache_all:
  696. ctx->flags &= ~(NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE);
  697. break;
  698. case Opt_lookupcache_positive:
  699. ctx->flags &= ~NFS_MOUNT_LOOKUP_CACHE_NONE;
  700. ctx->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG;
  701. break;
  702. case Opt_lookupcache_none:
  703. ctx->flags |= NFS_MOUNT_LOOKUP_CACHE_NONEG|NFS_MOUNT_LOOKUP_CACHE_NONE;
  704. break;
  705. default:
  706. goto out_invalid_value;
  707. }
  708. break;
  709. case Opt_local_lock:
  710. switch (result.uint_32) {
  711. case Opt_local_lock_all:
  712. ctx->flags |= (NFS_MOUNT_LOCAL_FLOCK |
  713. NFS_MOUNT_LOCAL_FCNTL);
  714. break;
  715. case Opt_local_lock_flock:
  716. ctx->flags |= NFS_MOUNT_LOCAL_FLOCK;
  717. break;
  718. case Opt_local_lock_posix:
  719. ctx->flags |= NFS_MOUNT_LOCAL_FCNTL;
  720. break;
  721. case Opt_local_lock_none:
  722. ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK |
  723. NFS_MOUNT_LOCAL_FCNTL);
  724. break;
  725. default:
  726. goto out_invalid_value;
  727. }
  728. break;
  729. /*
  730. * Special options
  731. */
  732. case Opt_sloppy:
  733. ctx->sloppy = true;
  734. dfprintk(MOUNT, "NFS: relaxing parsing rules\n");
  735. break;
  736. }
  737. return 0;
  738. out_invalid_value:
  739. return nfs_invalf(fc, "NFS: Bad mount option value specified");
  740. out_invalid_address:
  741. return nfs_invalf(fc, "NFS: Bad IP address specified");
  742. out_of_bounds:
  743. return nfs_invalf(fc, "NFS: Value for '%s' out of range", param->key);
  744. }
  745. /*
  746. * Split fc->source into "hostname:export_path".
  747. *
  748. * The leftmost colon demarks the split between the server's hostname
  749. * and the export path. If the hostname starts with a left square
  750. * bracket, then it may contain colons.
  751. *
  752. * Note: caller frees hostname and export path, even on error.
  753. */
  754. static int nfs_parse_source(struct fs_context *fc,
  755. size_t maxnamlen, size_t maxpathlen)
  756. {
  757. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  758. const char *dev_name = fc->source;
  759. size_t len;
  760. const char *end;
  761. if (unlikely(!dev_name || !*dev_name)) {
  762. dfprintk(MOUNT, "NFS: device name not specified\n");
  763. return -EINVAL;
  764. }
  765. /* Is the host name protected with square brakcets? */
  766. if (*dev_name == '[') {
  767. end = strchr(++dev_name, ']');
  768. if (end == NULL || end[1] != ':')
  769. goto out_bad_devname;
  770. len = end - dev_name;
  771. end++;
  772. } else {
  773. const char *comma;
  774. end = strchr(dev_name, ':');
  775. if (end == NULL)
  776. goto out_bad_devname;
  777. len = end - dev_name;
  778. /* kill possible hostname list: not supported */
  779. comma = memchr(dev_name, ',', len);
  780. if (comma)
  781. len = comma - dev_name;
  782. }
  783. if (len > maxnamlen)
  784. goto out_hostname;
  785. kfree(ctx->nfs_server.hostname);
  786. /* N.B. caller will free nfs_server.hostname in all cases */
  787. ctx->nfs_server.hostname = kmemdup_nul(dev_name, len, GFP_KERNEL);
  788. if (!ctx->nfs_server.hostname)
  789. goto out_nomem;
  790. len = strlen(++end);
  791. if (len > maxpathlen)
  792. goto out_path;
  793. ctx->nfs_server.export_path = kmemdup_nul(end, len, GFP_KERNEL);
  794. if (!ctx->nfs_server.export_path)
  795. goto out_nomem;
  796. dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", ctx->nfs_server.export_path);
  797. return 0;
  798. out_bad_devname:
  799. return nfs_invalf(fc, "NFS: device name not in host:path format");
  800. out_nomem:
  801. nfs_errorf(fc, "NFS: not enough memory to parse device name");
  802. return -ENOMEM;
  803. out_hostname:
  804. nfs_errorf(fc, "NFS: server hostname too long");
  805. return -ENAMETOOLONG;
  806. out_path:
  807. nfs_errorf(fc, "NFS: export pathname too long");
  808. return -ENAMETOOLONG;
  809. }
  810. static inline bool is_remount_fc(struct fs_context *fc)
  811. {
  812. return fc->root != NULL;
  813. }
  814. /*
  815. * Parse monolithic NFS2/NFS3 mount data
  816. * - fills in the mount root filehandle
  817. *
  818. * For option strings, user space handles the following behaviors:
  819. *
  820. * + DNS: mapping server host name to IP address ("addr=" option)
  821. *
  822. * + failure mode: how to behave if a mount request can't be handled
  823. * immediately ("fg/bg" option)
  824. *
  825. * + retry: how often to retry a mount request ("retry=" option)
  826. *
  827. * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
  828. * mountproto=tcp after mountproto=udp, and so on
  829. */
  830. static int nfs23_parse_monolithic(struct fs_context *fc,
  831. struct nfs_mount_data *data)
  832. {
  833. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  834. struct nfs_fh *mntfh = ctx->mntfh;
  835. struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
  836. int extra_flags = NFS_MOUNT_LEGACY_INTERFACE;
  837. if (data == NULL)
  838. goto out_no_data;
  839. ctx->version = NFS_DEFAULT_VERSION;
  840. switch (data->version) {
  841. case 1:
  842. data->namlen = 0;
  843. fallthrough;
  844. case 2:
  845. data->bsize = 0;
  846. fallthrough;
  847. case 3:
  848. if (data->flags & NFS_MOUNT_VER3)
  849. goto out_no_v3;
  850. data->root.size = NFS2_FHSIZE;
  851. memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
  852. /* Turn off security negotiation */
  853. extra_flags |= NFS_MOUNT_SECFLAVOUR;
  854. fallthrough;
  855. case 4:
  856. if (data->flags & NFS_MOUNT_SECFLAVOUR)
  857. goto out_no_sec;
  858. fallthrough;
  859. case 5:
  860. memset(data->context, 0, sizeof(data->context));
  861. fallthrough;
  862. case 6:
  863. if (data->flags & NFS_MOUNT_VER3) {
  864. if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
  865. goto out_invalid_fh;
  866. mntfh->size = data->root.size;
  867. ctx->version = 3;
  868. } else {
  869. mntfh->size = NFS2_FHSIZE;
  870. ctx->version = 2;
  871. }
  872. memcpy(mntfh->data, data->root.data, mntfh->size);
  873. if (mntfh->size < sizeof(mntfh->data))
  874. memset(mntfh->data + mntfh->size, 0,
  875. sizeof(mntfh->data) - mntfh->size);
  876. /*
  877. * for proto == XPRT_TRANSPORT_UDP, which is what uses
  878. * to_exponential, implying shift: limit the shift value
  879. * to BITS_PER_LONG (majortimeo is unsigned long)
  880. */
  881. if (!(data->flags & NFS_MOUNT_TCP)) /* this will be UDP */
  882. if (data->retrans >= 64) /* shift value is too large */
  883. goto out_invalid_data;
  884. /*
  885. * Translate to nfs_fs_context, which nfs_fill_super
  886. * can deal with.
  887. */
  888. ctx->flags = data->flags & NFS_MOUNT_FLAGMASK;
  889. ctx->flags |= extra_flags;
  890. ctx->rsize = data->rsize;
  891. ctx->wsize = data->wsize;
  892. ctx->timeo = data->timeo;
  893. ctx->retrans = data->retrans;
  894. ctx->acregmin = data->acregmin;
  895. ctx->acregmax = data->acregmax;
  896. ctx->acdirmin = data->acdirmin;
  897. ctx->acdirmax = data->acdirmax;
  898. ctx->need_mount = false;
  899. memcpy(sap, &data->addr, sizeof(data->addr));
  900. ctx->nfs_server.addrlen = sizeof(data->addr);
  901. ctx->nfs_server.port = ntohs(data->addr.sin_port);
  902. if (sap->sa_family != AF_INET ||
  903. !nfs_verify_server_address(sap))
  904. goto out_no_address;
  905. if (!(data->flags & NFS_MOUNT_TCP))
  906. ctx->nfs_server.protocol = XPRT_TRANSPORT_UDP;
  907. /* N.B. caller will free nfs_server.hostname in all cases */
  908. ctx->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
  909. if (!ctx->nfs_server.hostname)
  910. goto out_nomem;
  911. ctx->namlen = data->namlen;
  912. ctx->bsize = data->bsize;
  913. if (data->flags & NFS_MOUNT_SECFLAVOUR)
  914. ctx->selected_flavor = data->pseudoflavor;
  915. else
  916. ctx->selected_flavor = RPC_AUTH_UNIX;
  917. if (!(data->flags & NFS_MOUNT_NONLM))
  918. ctx->flags &= ~(NFS_MOUNT_LOCAL_FLOCK|
  919. NFS_MOUNT_LOCAL_FCNTL);
  920. else
  921. ctx->flags |= (NFS_MOUNT_LOCAL_FLOCK|
  922. NFS_MOUNT_LOCAL_FCNTL);
  923. /*
  924. * The legacy version 6 binary mount data from userspace has a
  925. * field used only to transport selinux information into the
  926. * kernel. To continue to support that functionality we
  927. * have a touch of selinux knowledge here in the NFS code. The
  928. * userspace code converted context=blah to just blah so we are
  929. * converting back to the full string selinux understands.
  930. */
  931. if (data->context[0]){
  932. #ifdef CONFIG_SECURITY_SELINUX
  933. int ret;
  934. data->context[NFS_MAX_CONTEXT_LEN] = '\0';
  935. ret = vfs_parse_fs_string(fc, "context",
  936. data->context, strlen(data->context));
  937. if (ret < 0)
  938. return ret;
  939. #else
  940. return -EINVAL;
  941. #endif
  942. }
  943. break;
  944. default:
  945. goto generic;
  946. }
  947. ctx->skip_reconfig_option_check = true;
  948. return 0;
  949. generic:
  950. return generic_parse_monolithic(fc, data);
  951. out_no_data:
  952. if (is_remount_fc(fc)) {
  953. ctx->skip_reconfig_option_check = true;
  954. return 0;
  955. }
  956. return nfs_invalf(fc, "NFS: mount program didn't pass any mount data");
  957. out_no_v3:
  958. return nfs_invalf(fc, "NFS: nfs_mount_data version does not support v3");
  959. out_no_sec:
  960. return nfs_invalf(fc, "NFS: nfs_mount_data version supports only AUTH_SYS");
  961. out_nomem:
  962. dfprintk(MOUNT, "NFS: not enough memory to handle mount options");
  963. return -ENOMEM;
  964. out_no_address:
  965. return nfs_invalf(fc, "NFS: mount program didn't pass remote address");
  966. out_invalid_fh:
  967. return nfs_invalf(fc, "NFS: invalid root filehandle");
  968. out_invalid_data:
  969. return nfs_invalf(fc, "NFS: invalid binary mount data");
  970. }
  971. #if IS_ENABLED(CONFIG_NFS_V4)
  972. struct compat_nfs_string {
  973. compat_uint_t len;
  974. compat_uptr_t data;
  975. };
  976. static inline void compat_nfs_string(struct nfs_string *dst,
  977. struct compat_nfs_string *src)
  978. {
  979. dst->data = compat_ptr(src->data);
  980. dst->len = src->len;
  981. }
  982. struct compat_nfs4_mount_data_v1 {
  983. compat_int_t version;
  984. compat_int_t flags;
  985. compat_int_t rsize;
  986. compat_int_t wsize;
  987. compat_int_t timeo;
  988. compat_int_t retrans;
  989. compat_int_t acregmin;
  990. compat_int_t acregmax;
  991. compat_int_t acdirmin;
  992. compat_int_t acdirmax;
  993. struct compat_nfs_string client_addr;
  994. struct compat_nfs_string mnt_path;
  995. struct compat_nfs_string hostname;
  996. compat_uint_t host_addrlen;
  997. compat_uptr_t host_addr;
  998. compat_int_t proto;
  999. compat_int_t auth_flavourlen;
  1000. compat_uptr_t auth_flavours;
  1001. };
  1002. static void nfs4_compat_mount_data_conv(struct nfs4_mount_data *data)
  1003. {
  1004. struct compat_nfs4_mount_data_v1 *compat =
  1005. (struct compat_nfs4_mount_data_v1 *)data;
  1006. /* copy the fields backwards */
  1007. data->auth_flavours = compat_ptr(compat->auth_flavours);
  1008. data->auth_flavourlen = compat->auth_flavourlen;
  1009. data->proto = compat->proto;
  1010. data->host_addr = compat_ptr(compat->host_addr);
  1011. data->host_addrlen = compat->host_addrlen;
  1012. compat_nfs_string(&data->hostname, &compat->hostname);
  1013. compat_nfs_string(&data->mnt_path, &compat->mnt_path);
  1014. compat_nfs_string(&data->client_addr, &compat->client_addr);
  1015. data->acdirmax = compat->acdirmax;
  1016. data->acdirmin = compat->acdirmin;
  1017. data->acregmax = compat->acregmax;
  1018. data->acregmin = compat->acregmin;
  1019. data->retrans = compat->retrans;
  1020. data->timeo = compat->timeo;
  1021. data->wsize = compat->wsize;
  1022. data->rsize = compat->rsize;
  1023. data->flags = compat->flags;
  1024. data->version = compat->version;
  1025. }
  1026. /*
  1027. * Validate NFSv4 mount options
  1028. */
  1029. static int nfs4_parse_monolithic(struct fs_context *fc,
  1030. struct nfs4_mount_data *data)
  1031. {
  1032. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  1033. struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
  1034. char *c;
  1035. if (!data) {
  1036. if (is_remount_fc(fc))
  1037. goto done;
  1038. return nfs_invalf(fc,
  1039. "NFS4: mount program didn't pass any mount data");
  1040. }
  1041. ctx->version = 4;
  1042. if (data->version != 1)
  1043. return generic_parse_monolithic(fc, data);
  1044. if (in_compat_syscall())
  1045. nfs4_compat_mount_data_conv(data);
  1046. if (data->host_addrlen > sizeof(ctx->nfs_server.address))
  1047. goto out_no_address;
  1048. if (data->host_addrlen == 0)
  1049. goto out_no_address;
  1050. ctx->nfs_server.addrlen = data->host_addrlen;
  1051. if (copy_from_user(sap, data->host_addr, data->host_addrlen))
  1052. return -EFAULT;
  1053. if (!nfs_verify_server_address(sap))
  1054. goto out_no_address;
  1055. ctx->nfs_server.port = ntohs(((struct sockaddr_in *)sap)->sin_port);
  1056. if (data->auth_flavourlen) {
  1057. rpc_authflavor_t pseudoflavor;
  1058. if (data->auth_flavourlen > 1)
  1059. goto out_inval_auth;
  1060. if (copy_from_user(&pseudoflavor, data->auth_flavours,
  1061. sizeof(pseudoflavor)))
  1062. return -EFAULT;
  1063. ctx->selected_flavor = pseudoflavor;
  1064. } else {
  1065. ctx->selected_flavor = RPC_AUTH_UNIX;
  1066. }
  1067. c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
  1068. if (IS_ERR(c))
  1069. return PTR_ERR(c);
  1070. ctx->nfs_server.hostname = c;
  1071. c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
  1072. if (IS_ERR(c))
  1073. return PTR_ERR(c);
  1074. ctx->nfs_server.export_path = c;
  1075. dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", c);
  1076. c = strndup_user(data->client_addr.data, 16);
  1077. if (IS_ERR(c))
  1078. return PTR_ERR(c);
  1079. ctx->client_address = c;
  1080. /*
  1081. * Translate to nfs_fs_context, which nfs_fill_super
  1082. * can deal with.
  1083. */
  1084. ctx->flags = data->flags & NFS4_MOUNT_FLAGMASK;
  1085. ctx->rsize = data->rsize;
  1086. ctx->wsize = data->wsize;
  1087. ctx->timeo = data->timeo;
  1088. ctx->retrans = data->retrans;
  1089. ctx->acregmin = data->acregmin;
  1090. ctx->acregmax = data->acregmax;
  1091. ctx->acdirmin = data->acdirmin;
  1092. ctx->acdirmax = data->acdirmax;
  1093. ctx->nfs_server.protocol = data->proto;
  1094. nfs_validate_transport_protocol(ctx);
  1095. if (ctx->nfs_server.protocol == XPRT_TRANSPORT_UDP)
  1096. goto out_invalid_transport_udp;
  1097. done:
  1098. ctx->skip_reconfig_option_check = true;
  1099. return 0;
  1100. out_inval_auth:
  1101. return nfs_invalf(fc, "NFS4: Invalid number of RPC auth flavours %d",
  1102. data->auth_flavourlen);
  1103. out_no_address:
  1104. return nfs_invalf(fc, "NFS4: mount program didn't pass remote address");
  1105. out_invalid_transport_udp:
  1106. return nfs_invalf(fc, "NFS: Unsupported transport protocol udp");
  1107. }
  1108. #endif
  1109. /*
  1110. * Parse a monolithic block of data from sys_mount().
  1111. */
  1112. static int nfs_fs_context_parse_monolithic(struct fs_context *fc,
  1113. void *data)
  1114. {
  1115. if (fc->fs_type == &nfs_fs_type)
  1116. return nfs23_parse_monolithic(fc, data);
  1117. #if IS_ENABLED(CONFIG_NFS_V4)
  1118. if (fc->fs_type == &nfs4_fs_type)
  1119. return nfs4_parse_monolithic(fc, data);
  1120. #endif
  1121. return nfs_invalf(fc, "NFS: Unsupported monolithic data version");
  1122. }
  1123. /*
  1124. * Validate the preparsed information in the config.
  1125. */
  1126. static int nfs_fs_context_validate(struct fs_context *fc)
  1127. {
  1128. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  1129. struct nfs_subversion *nfs_mod;
  1130. struct sockaddr *sap = (struct sockaddr *)&ctx->nfs_server.address;
  1131. int max_namelen = PAGE_SIZE;
  1132. int max_pathlen = NFS_MAXPATHLEN;
  1133. int port = 0;
  1134. int ret;
  1135. if (!fc->source)
  1136. goto out_no_device_name;
  1137. /* Check for sanity first. */
  1138. if (ctx->minorversion && ctx->version != 4)
  1139. goto out_minorversion_mismatch;
  1140. if (ctx->options & NFS_OPTION_MIGRATION &&
  1141. (ctx->version != 4 || ctx->minorversion != 0))
  1142. goto out_migration_misuse;
  1143. /* Verify that any proto=/mountproto= options match the address
  1144. * families in the addr=/mountaddr= options.
  1145. */
  1146. if (ctx->protofamily != AF_UNSPEC &&
  1147. ctx->protofamily != ctx->nfs_server.address.sa_family)
  1148. goto out_proto_mismatch;
  1149. if (ctx->mountfamily != AF_UNSPEC) {
  1150. if (ctx->mount_server.addrlen) {
  1151. if (ctx->mountfamily != ctx->mount_server.address.sa_family)
  1152. goto out_mountproto_mismatch;
  1153. } else {
  1154. if (ctx->mountfamily != ctx->nfs_server.address.sa_family)
  1155. goto out_mountproto_mismatch;
  1156. }
  1157. }
  1158. if (!nfs_verify_server_address(sap))
  1159. goto out_no_address;
  1160. if (ctx->version == 4) {
  1161. if (IS_ENABLED(CONFIG_NFS_V4)) {
  1162. if (ctx->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
  1163. port = NFS_RDMA_PORT;
  1164. else
  1165. port = NFS_PORT;
  1166. max_namelen = NFS4_MAXNAMLEN;
  1167. max_pathlen = NFS4_MAXPATHLEN;
  1168. nfs_validate_transport_protocol(ctx);
  1169. if (ctx->nfs_server.protocol == XPRT_TRANSPORT_UDP)
  1170. goto out_invalid_transport_udp;
  1171. ctx->flags &= ~(NFS_MOUNT_NONLM | NFS_MOUNT_NOACL |
  1172. NFS_MOUNT_VER3 | NFS_MOUNT_LOCAL_FLOCK |
  1173. NFS_MOUNT_LOCAL_FCNTL);
  1174. } else {
  1175. goto out_v4_not_compiled;
  1176. }
  1177. } else {
  1178. nfs_set_mount_transport_protocol(ctx);
  1179. #ifdef CONFIG_NFS_DISABLE_UDP_SUPPORT
  1180. if (ctx->nfs_server.protocol == XPRT_TRANSPORT_UDP)
  1181. goto out_invalid_transport_udp;
  1182. #endif
  1183. if (ctx->nfs_server.protocol == XPRT_TRANSPORT_RDMA)
  1184. port = NFS_RDMA_PORT;
  1185. }
  1186. nfs_set_port(sap, &ctx->nfs_server.port, port);
  1187. ret = nfs_parse_source(fc, max_namelen, max_pathlen);
  1188. if (ret < 0)
  1189. return ret;
  1190. /* Load the NFS protocol module if we haven't done so yet */
  1191. if (!ctx->nfs_mod) {
  1192. nfs_mod = get_nfs_version(ctx->version);
  1193. if (IS_ERR(nfs_mod)) {
  1194. ret = PTR_ERR(nfs_mod);
  1195. goto out_version_unavailable;
  1196. }
  1197. ctx->nfs_mod = nfs_mod;
  1198. }
  1199. /* Ensure the filesystem context has the correct fs_type */
  1200. if (fc->fs_type != ctx->nfs_mod->nfs_fs) {
  1201. module_put(fc->fs_type->owner);
  1202. __module_get(ctx->nfs_mod->nfs_fs->owner);
  1203. fc->fs_type = ctx->nfs_mod->nfs_fs;
  1204. }
  1205. return 0;
  1206. out_no_device_name:
  1207. return nfs_invalf(fc, "NFS: Device name not specified");
  1208. out_v4_not_compiled:
  1209. nfs_errorf(fc, "NFS: NFSv4 is not compiled into kernel");
  1210. return -EPROTONOSUPPORT;
  1211. out_invalid_transport_udp:
  1212. return nfs_invalf(fc, "NFS: Unsupported transport protocol udp");
  1213. out_no_address:
  1214. return nfs_invalf(fc, "NFS: mount program didn't pass remote address");
  1215. out_mountproto_mismatch:
  1216. return nfs_invalf(fc, "NFS: Mount server address does not match mountproto= option");
  1217. out_proto_mismatch:
  1218. return nfs_invalf(fc, "NFS: Server address does not match proto= option");
  1219. out_minorversion_mismatch:
  1220. return nfs_invalf(fc, "NFS: Mount option vers=%u does not support minorversion=%u",
  1221. ctx->version, ctx->minorversion);
  1222. out_migration_misuse:
  1223. return nfs_invalf(fc, "NFS: 'Migration' not supported for this NFS version");
  1224. out_version_unavailable:
  1225. nfs_errorf(fc, "NFS: Version unavailable");
  1226. return ret;
  1227. }
  1228. /*
  1229. * Create an NFS superblock by the appropriate method.
  1230. */
  1231. static int nfs_get_tree(struct fs_context *fc)
  1232. {
  1233. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  1234. int err = nfs_fs_context_validate(fc);
  1235. if (err)
  1236. return err;
  1237. if (!ctx->internal)
  1238. return ctx->nfs_mod->rpc_ops->try_get_tree(fc);
  1239. else
  1240. return nfs_get_tree_common(fc);
  1241. }
  1242. /*
  1243. * Handle duplication of a configuration. The caller copied *src into *sc, but
  1244. * it can't deal with resource pointers in the filesystem context, so we have
  1245. * to do that. We need to clear pointers, copy data or get extra refs as
  1246. * appropriate.
  1247. */
  1248. static int nfs_fs_context_dup(struct fs_context *fc, struct fs_context *src_fc)
  1249. {
  1250. struct nfs_fs_context *src = nfs_fc2context(src_fc), *ctx;
  1251. ctx = kmemdup(src, sizeof(struct nfs_fs_context), GFP_KERNEL);
  1252. if (!ctx)
  1253. return -ENOMEM;
  1254. ctx->mntfh = nfs_alloc_fhandle();
  1255. if (!ctx->mntfh) {
  1256. kfree(ctx);
  1257. return -ENOMEM;
  1258. }
  1259. nfs_copy_fh(ctx->mntfh, src->mntfh);
  1260. __module_get(ctx->nfs_mod->owner);
  1261. ctx->client_address = NULL;
  1262. ctx->mount_server.hostname = NULL;
  1263. ctx->nfs_server.export_path = NULL;
  1264. ctx->nfs_server.hostname = NULL;
  1265. ctx->fscache_uniq = NULL;
  1266. ctx->clone_data.fattr = NULL;
  1267. fc->fs_private = ctx;
  1268. return 0;
  1269. }
  1270. static void nfs_fs_context_free(struct fs_context *fc)
  1271. {
  1272. struct nfs_fs_context *ctx = nfs_fc2context(fc);
  1273. if (ctx) {
  1274. if (ctx->server)
  1275. nfs_free_server(ctx->server);
  1276. if (ctx->nfs_mod)
  1277. put_nfs_version(ctx->nfs_mod);
  1278. kfree(ctx->client_address);
  1279. kfree(ctx->mount_server.hostname);
  1280. kfree(ctx->nfs_server.export_path);
  1281. kfree(ctx->nfs_server.hostname);
  1282. kfree(ctx->fscache_uniq);
  1283. nfs_free_fhandle(ctx->mntfh);
  1284. nfs_free_fattr(ctx->clone_data.fattr);
  1285. kfree(ctx);
  1286. }
  1287. }
  1288. static const struct fs_context_operations nfs_fs_context_ops = {
  1289. .free = nfs_fs_context_free,
  1290. .dup = nfs_fs_context_dup,
  1291. .parse_param = nfs_fs_context_parse_param,
  1292. .parse_monolithic = nfs_fs_context_parse_monolithic,
  1293. .get_tree = nfs_get_tree,
  1294. .reconfigure = nfs_reconfigure,
  1295. };
  1296. /*
  1297. * Prepare superblock configuration. We use the namespaces attached to the
  1298. * context. This may be the current process's namespaces, or it may be a
  1299. * container's namespaces.
  1300. */
  1301. static int nfs_init_fs_context(struct fs_context *fc)
  1302. {
  1303. struct nfs_fs_context *ctx;
  1304. ctx = kzalloc(sizeof(struct nfs_fs_context), GFP_KERNEL);
  1305. if (unlikely(!ctx))
  1306. return -ENOMEM;
  1307. ctx->mntfh = nfs_alloc_fhandle();
  1308. if (unlikely(!ctx->mntfh)) {
  1309. kfree(ctx);
  1310. return -ENOMEM;
  1311. }
  1312. ctx->protofamily = AF_UNSPEC;
  1313. ctx->mountfamily = AF_UNSPEC;
  1314. ctx->mount_server.port = NFS_UNSPEC_PORT;
  1315. if (fc->root) {
  1316. /* reconfigure, start with the current config */
  1317. struct nfs_server *nfss = fc->root->d_sb->s_fs_info;
  1318. struct net *net = nfss->nfs_client->cl_net;
  1319. ctx->flags = nfss->flags;
  1320. ctx->rsize = nfss->rsize;
  1321. ctx->wsize = nfss->wsize;
  1322. ctx->retrans = nfss->client->cl_timeout->to_retries;
  1323. ctx->selected_flavor = nfss->client->cl_auth->au_flavor;
  1324. ctx->acregmin = nfss->acregmin / HZ;
  1325. ctx->acregmax = nfss->acregmax / HZ;
  1326. ctx->acdirmin = nfss->acdirmin / HZ;
  1327. ctx->acdirmax = nfss->acdirmax / HZ;
  1328. ctx->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
  1329. ctx->nfs_server.port = nfss->port;
  1330. ctx->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
  1331. ctx->version = nfss->nfs_client->rpc_ops->version;
  1332. ctx->minorversion = nfss->nfs_client->cl_minorversion;
  1333. memcpy(&ctx->nfs_server.address, &nfss->nfs_client->cl_addr,
  1334. ctx->nfs_server.addrlen);
  1335. if (fc->net_ns != net) {
  1336. put_net(fc->net_ns);
  1337. fc->net_ns = get_net(net);
  1338. }
  1339. ctx->nfs_mod = nfss->nfs_client->cl_nfs_mod;
  1340. __module_get(ctx->nfs_mod->owner);
  1341. } else {
  1342. /* defaults */
  1343. ctx->timeo = NFS_UNSPEC_TIMEO;
  1344. ctx->retrans = NFS_UNSPEC_RETRANS;
  1345. ctx->acregmin = NFS_DEF_ACREGMIN;
  1346. ctx->acregmax = NFS_DEF_ACREGMAX;
  1347. ctx->acdirmin = NFS_DEF_ACDIRMIN;
  1348. ctx->acdirmax = NFS_DEF_ACDIRMAX;
  1349. ctx->nfs_server.port = NFS_UNSPEC_PORT;
  1350. ctx->nfs_server.protocol = XPRT_TRANSPORT_TCP;
  1351. ctx->selected_flavor = RPC_AUTH_MAXFLAVOR;
  1352. ctx->minorversion = 0;
  1353. ctx->need_mount = true;
  1354. }
  1355. fc->fs_private = ctx;
  1356. fc->ops = &nfs_fs_context_ops;
  1357. return 0;
  1358. }
  1359. struct file_system_type nfs_fs_type = {
  1360. .owner = THIS_MODULE,
  1361. .name = "nfs",
  1362. .init_fs_context = nfs_init_fs_context,
  1363. .parameters = nfs_fs_parameters,
  1364. .kill_sb = nfs_kill_super,
  1365. .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
  1366. };
  1367. MODULE_ALIAS_FS("nfs");
  1368. EXPORT_SYMBOL_GPL(nfs_fs_type);
  1369. #if IS_ENABLED(CONFIG_NFS_V4)
  1370. struct file_system_type nfs4_fs_type = {
  1371. .owner = THIS_MODULE,
  1372. .name = "nfs4",
  1373. .init_fs_context = nfs_init_fs_context,
  1374. .parameters = nfs_fs_parameters,
  1375. .kill_sb = nfs_kill_super,
  1376. .fs_flags = FS_RENAME_DOES_D_MOVE|FS_BINARY_MOUNTDATA,
  1377. };
  1378. MODULE_ALIAS_FS("nfs4");
  1379. MODULE_ALIAS("nfs4");
  1380. EXPORT_SYMBOL_GPL(nfs4_fs_type);
  1381. #endif /* CONFIG_NFS_V4 */