af_vsock.c 54 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * VMware vSockets Driver
  4. *
  5. * Copyright (C) 2007-2013 VMware, Inc. All rights reserved.
  6. */
  7. /* Implementation notes:
  8. *
  9. * - There are two kinds of sockets: those created by user action (such as
  10. * calling socket(2)) and those created by incoming connection request packets.
  11. *
  12. * - There are two "global" tables, one for bound sockets (sockets that have
  13. * specified an address that they are responsible for) and one for connected
  14. * sockets (sockets that have established a connection with another socket).
  15. * These tables are "global" in that all sockets on the system are placed
  16. * within them. - Note, though, that the bound table contains an extra entry
  17. * for a list of unbound sockets and SOCK_DGRAM sockets will always remain in
  18. * that list. The bound table is used solely for lookup of sockets when packets
  19. * are received and that's not necessary for SOCK_DGRAM sockets since we create
  20. * a datagram handle for each and need not perform a lookup. Keeping SOCK_DGRAM
  21. * sockets out of the bound hash buckets will reduce the chance of collisions
  22. * when looking for SOCK_STREAM sockets and prevents us from having to check the
  23. * socket type in the hash table lookups.
  24. *
  25. * - Sockets created by user action will either be "client" sockets that
  26. * initiate a connection or "server" sockets that listen for connections; we do
  27. * not support simultaneous connects (two "client" sockets connecting).
  28. *
  29. * - "Server" sockets are referred to as listener sockets throughout this
  30. * implementation because they are in the TCP_LISTEN state. When a
  31. * connection request is received (the second kind of socket mentioned above),
  32. * we create a new socket and refer to it as a pending socket. These pending
  33. * sockets are placed on the pending connection list of the listener socket.
  34. * When future packets are received for the address the listener socket is
  35. * bound to, we check if the source of the packet is from one that has an
  36. * existing pending connection. If it does, we process the packet for the
  37. * pending socket. When that socket reaches the connected state, it is removed
  38. * from the listener socket's pending list and enqueued in the listener
  39. * socket's accept queue. Callers of accept(2) will accept connected sockets
  40. * from the listener socket's accept queue. If the socket cannot be accepted
  41. * for some reason then it is marked rejected. Once the connection is
  42. * accepted, it is owned by the user process and the responsibility for cleanup
  43. * falls with that user process.
  44. *
  45. * - It is possible that these pending sockets will never reach the connected
  46. * state; in fact, we may never receive another packet after the connection
  47. * request. Because of this, we must schedule a cleanup function to run in the
  48. * future, after some amount of time passes where a connection should have been
  49. * established. This function ensures that the socket is off all lists so it
  50. * cannot be retrieved, then drops all references to the socket so it is cleaned
  51. * up (sock_put() -> sk_free() -> our sk_destruct implementation). Note this
  52. * function will also cleanup rejected sockets, those that reach the connected
  53. * state but leave it before they have been accepted.
  54. *
  55. * - Lock ordering for pending or accept queue sockets is:
  56. *
  57. * lock_sock(listener);
  58. * lock_sock_nested(pending, SINGLE_DEPTH_NESTING);
  59. *
  60. * Using explicit nested locking keeps lockdep happy since normally only one
  61. * lock of a given class may be taken at a time.
  62. *
  63. * - Sockets created by user action will be cleaned up when the user process
  64. * calls close(2), causing our release implementation to be called. Our release
  65. * implementation will perform some cleanup then drop the last reference so our
  66. * sk_destruct implementation is invoked. Our sk_destruct implementation will
  67. * perform additional cleanup that's common for both types of sockets.
  68. *
  69. * - A socket's reference count is what ensures that the structure won't be
  70. * freed. Each entry in a list (such as the "global" bound and connected tables
  71. * and the listener socket's pending list and connected queue) ensures a
  72. * reference. When we defer work until process context and pass a socket as our
  73. * argument, we must ensure the reference count is increased to ensure the
  74. * socket isn't freed before the function is run; the deferred function will
  75. * then drop the reference.
  76. *
  77. * - sk->sk_state uses the TCP state constants because they are widely used by
  78. * other address families and exposed to userspace tools like ss(8):
  79. *
  80. * TCP_CLOSE - unconnected
  81. * TCP_SYN_SENT - connecting
  82. * TCP_ESTABLISHED - connected
  83. * TCP_CLOSING - disconnecting
  84. * TCP_LISTEN - listening
  85. */
  86. #include <linux/types.h>
  87. #include <linux/bitops.h>
  88. #include <linux/cred.h>
  89. #include <linux/init.h>
  90. #include <linux/io.h>
  91. #include <linux/kernel.h>
  92. #include <linux/sched/signal.h>
  93. #include <linux/kmod.h>
  94. #include <linux/list.h>
  95. #include <linux/miscdevice.h>
  96. #include <linux/module.h>
  97. #include <linux/mutex.h>
  98. #include <linux/net.h>
  99. #include <linux/poll.h>
  100. #include <linux/random.h>
  101. #include <linux/skbuff.h>
  102. #include <linux/smp.h>
  103. #include <linux/socket.h>
  104. #include <linux/stddef.h>
  105. #include <linux/unistd.h>
  106. #include <linux/wait.h>
  107. #include <linux/workqueue.h>
  108. #include <net/sock.h>
  109. #include <net/af_vsock.h>
  110. static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr);
  111. static void vsock_sk_destruct(struct sock *sk);
  112. static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
  113. /* Protocol family. */
  114. static struct proto vsock_proto = {
  115. .name = "AF_VSOCK",
  116. .owner = THIS_MODULE,
  117. .obj_size = sizeof(struct vsock_sock),
  118. };
  119. /* The default peer timeout indicates how long we will wait for a peer response
  120. * to a control message.
  121. */
  122. #define VSOCK_DEFAULT_CONNECT_TIMEOUT (2 * HZ)
  123. #define VSOCK_DEFAULT_BUFFER_SIZE (1024 * 256)
  124. #define VSOCK_DEFAULT_BUFFER_MAX_SIZE (1024 * 256)
  125. #define VSOCK_DEFAULT_BUFFER_MIN_SIZE 128
  126. /* Transport used for host->guest communication */
  127. static const struct vsock_transport *transport_h2g;
  128. /* Transport used for guest->host communication */
  129. static const struct vsock_transport *transport_g2h;
  130. /* Transport used for DGRAM communication */
  131. static const struct vsock_transport *transport_dgram;
  132. /* Transport used for local communication */
  133. static const struct vsock_transport *transport_local;
  134. static DEFINE_MUTEX(vsock_register_mutex);
  135. /**** UTILS ****/
  136. /* Each bound VSocket is stored in the bind hash table and each connected
  137. * VSocket is stored in the connected hash table.
  138. *
  139. * Unbound sockets are all put on the same list attached to the end of the hash
  140. * table (vsock_unbound_sockets). Bound sockets are added to the hash table in
  141. * the bucket that their local address hashes to (vsock_bound_sockets(addr)
  142. * represents the list that addr hashes to).
  143. *
  144. * Specifically, we initialize the vsock_bind_table array to a size of
  145. * VSOCK_HASH_SIZE + 1 so that vsock_bind_table[0] through
  146. * vsock_bind_table[VSOCK_HASH_SIZE - 1] are for bound sockets and
  147. * vsock_bind_table[VSOCK_HASH_SIZE] is for unbound sockets. The hash function
  148. * mods with VSOCK_HASH_SIZE to ensure this.
  149. */
  150. #define MAX_PORT_RETRIES 24
  151. #define VSOCK_HASH(addr) ((addr)->svm_port % VSOCK_HASH_SIZE)
  152. #define vsock_bound_sockets(addr) (&vsock_bind_table[VSOCK_HASH(addr)])
  153. #define vsock_unbound_sockets (&vsock_bind_table[VSOCK_HASH_SIZE])
  154. /* XXX This can probably be implemented in a better way. */
  155. #define VSOCK_CONN_HASH(src, dst) \
  156. (((src)->svm_cid ^ (dst)->svm_port) % VSOCK_HASH_SIZE)
  157. #define vsock_connected_sockets(src, dst) \
  158. (&vsock_connected_table[VSOCK_CONN_HASH(src, dst)])
  159. #define vsock_connected_sockets_vsk(vsk) \
  160. vsock_connected_sockets(&(vsk)->remote_addr, &(vsk)->local_addr)
  161. struct list_head vsock_bind_table[VSOCK_HASH_SIZE + 1];
  162. EXPORT_SYMBOL_GPL(vsock_bind_table);
  163. struct list_head vsock_connected_table[VSOCK_HASH_SIZE];
  164. EXPORT_SYMBOL_GPL(vsock_connected_table);
  165. DEFINE_SPINLOCK(vsock_table_lock);
  166. EXPORT_SYMBOL_GPL(vsock_table_lock);
  167. /* Autobind this socket to the local address if necessary. */
  168. static int vsock_auto_bind(struct vsock_sock *vsk)
  169. {
  170. struct sock *sk = sk_vsock(vsk);
  171. struct sockaddr_vm local_addr;
  172. if (vsock_addr_bound(&vsk->local_addr))
  173. return 0;
  174. vsock_addr_init(&local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
  175. return __vsock_bind(sk, &local_addr);
  176. }
  177. static void vsock_init_tables(void)
  178. {
  179. int i;
  180. for (i = 0; i < ARRAY_SIZE(vsock_bind_table); i++)
  181. INIT_LIST_HEAD(&vsock_bind_table[i]);
  182. for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++)
  183. INIT_LIST_HEAD(&vsock_connected_table[i]);
  184. }
  185. static void __vsock_insert_bound(struct list_head *list,
  186. struct vsock_sock *vsk)
  187. {
  188. sock_hold(&vsk->sk);
  189. list_add(&vsk->bound_table, list);
  190. }
  191. static void __vsock_insert_connected(struct list_head *list,
  192. struct vsock_sock *vsk)
  193. {
  194. sock_hold(&vsk->sk);
  195. list_add(&vsk->connected_table, list);
  196. }
  197. static void __vsock_remove_bound(struct vsock_sock *vsk)
  198. {
  199. list_del_init(&vsk->bound_table);
  200. sock_put(&vsk->sk);
  201. }
  202. static void __vsock_remove_connected(struct vsock_sock *vsk)
  203. {
  204. list_del_init(&vsk->connected_table);
  205. sock_put(&vsk->sk);
  206. }
  207. static struct sock *__vsock_find_bound_socket(struct sockaddr_vm *addr)
  208. {
  209. struct vsock_sock *vsk;
  210. list_for_each_entry(vsk, vsock_bound_sockets(addr), bound_table) {
  211. if (vsock_addr_equals_addr(addr, &vsk->local_addr))
  212. return sk_vsock(vsk);
  213. if (addr->svm_port == vsk->local_addr.svm_port &&
  214. (vsk->local_addr.svm_cid == VMADDR_CID_ANY ||
  215. addr->svm_cid == VMADDR_CID_ANY))
  216. return sk_vsock(vsk);
  217. }
  218. return NULL;
  219. }
  220. static struct sock *__vsock_find_connected_socket(struct sockaddr_vm *src,
  221. struct sockaddr_vm *dst)
  222. {
  223. struct vsock_sock *vsk;
  224. list_for_each_entry(vsk, vsock_connected_sockets(src, dst),
  225. connected_table) {
  226. if (vsock_addr_equals_addr(src, &vsk->remote_addr) &&
  227. dst->svm_port == vsk->local_addr.svm_port) {
  228. return sk_vsock(vsk);
  229. }
  230. }
  231. return NULL;
  232. }
  233. static void vsock_insert_unbound(struct vsock_sock *vsk)
  234. {
  235. spin_lock_bh(&vsock_table_lock);
  236. __vsock_insert_bound(vsock_unbound_sockets, vsk);
  237. spin_unlock_bh(&vsock_table_lock);
  238. }
  239. void vsock_insert_connected(struct vsock_sock *vsk)
  240. {
  241. struct list_head *list = vsock_connected_sockets(
  242. &vsk->remote_addr, &vsk->local_addr);
  243. spin_lock_bh(&vsock_table_lock);
  244. __vsock_insert_connected(list, vsk);
  245. spin_unlock_bh(&vsock_table_lock);
  246. }
  247. EXPORT_SYMBOL_GPL(vsock_insert_connected);
  248. void vsock_remove_bound(struct vsock_sock *vsk)
  249. {
  250. spin_lock_bh(&vsock_table_lock);
  251. if (__vsock_in_bound_table(vsk))
  252. __vsock_remove_bound(vsk);
  253. spin_unlock_bh(&vsock_table_lock);
  254. }
  255. EXPORT_SYMBOL_GPL(vsock_remove_bound);
  256. void vsock_remove_connected(struct vsock_sock *vsk)
  257. {
  258. spin_lock_bh(&vsock_table_lock);
  259. if (__vsock_in_connected_table(vsk))
  260. __vsock_remove_connected(vsk);
  261. spin_unlock_bh(&vsock_table_lock);
  262. }
  263. EXPORT_SYMBOL_GPL(vsock_remove_connected);
  264. struct sock *vsock_find_bound_socket(struct sockaddr_vm *addr)
  265. {
  266. struct sock *sk;
  267. spin_lock_bh(&vsock_table_lock);
  268. sk = __vsock_find_bound_socket(addr);
  269. if (sk)
  270. sock_hold(sk);
  271. spin_unlock_bh(&vsock_table_lock);
  272. return sk;
  273. }
  274. EXPORT_SYMBOL_GPL(vsock_find_bound_socket);
  275. struct sock *vsock_find_connected_socket(struct sockaddr_vm *src,
  276. struct sockaddr_vm *dst)
  277. {
  278. struct sock *sk;
  279. spin_lock_bh(&vsock_table_lock);
  280. sk = __vsock_find_connected_socket(src, dst);
  281. if (sk)
  282. sock_hold(sk);
  283. spin_unlock_bh(&vsock_table_lock);
  284. return sk;
  285. }
  286. EXPORT_SYMBOL_GPL(vsock_find_connected_socket);
  287. void vsock_remove_sock(struct vsock_sock *vsk)
  288. {
  289. vsock_remove_bound(vsk);
  290. vsock_remove_connected(vsk);
  291. }
  292. EXPORT_SYMBOL_GPL(vsock_remove_sock);
  293. void vsock_for_each_connected_socket(void (*fn)(struct sock *sk))
  294. {
  295. int i;
  296. spin_lock_bh(&vsock_table_lock);
  297. for (i = 0; i < ARRAY_SIZE(vsock_connected_table); i++) {
  298. struct vsock_sock *vsk;
  299. list_for_each_entry(vsk, &vsock_connected_table[i],
  300. connected_table)
  301. fn(sk_vsock(vsk));
  302. }
  303. spin_unlock_bh(&vsock_table_lock);
  304. }
  305. EXPORT_SYMBOL_GPL(vsock_for_each_connected_socket);
  306. void vsock_add_pending(struct sock *listener, struct sock *pending)
  307. {
  308. struct vsock_sock *vlistener;
  309. struct vsock_sock *vpending;
  310. vlistener = vsock_sk(listener);
  311. vpending = vsock_sk(pending);
  312. sock_hold(pending);
  313. sock_hold(listener);
  314. list_add_tail(&vpending->pending_links, &vlistener->pending_links);
  315. }
  316. EXPORT_SYMBOL_GPL(vsock_add_pending);
  317. void vsock_remove_pending(struct sock *listener, struct sock *pending)
  318. {
  319. struct vsock_sock *vpending = vsock_sk(pending);
  320. list_del_init(&vpending->pending_links);
  321. sock_put(listener);
  322. sock_put(pending);
  323. }
  324. EXPORT_SYMBOL_GPL(vsock_remove_pending);
  325. void vsock_enqueue_accept(struct sock *listener, struct sock *connected)
  326. {
  327. struct vsock_sock *vlistener;
  328. struct vsock_sock *vconnected;
  329. vlistener = vsock_sk(listener);
  330. vconnected = vsock_sk(connected);
  331. sock_hold(connected);
  332. sock_hold(listener);
  333. list_add_tail(&vconnected->accept_queue, &vlistener->accept_queue);
  334. }
  335. EXPORT_SYMBOL_GPL(vsock_enqueue_accept);
  336. static bool vsock_use_local_transport(unsigned int remote_cid)
  337. {
  338. if (!transport_local)
  339. return false;
  340. if (remote_cid == VMADDR_CID_LOCAL)
  341. return true;
  342. if (transport_g2h) {
  343. return remote_cid == transport_g2h->get_local_cid();
  344. } else {
  345. return remote_cid == VMADDR_CID_HOST;
  346. }
  347. }
  348. static void vsock_deassign_transport(struct vsock_sock *vsk)
  349. {
  350. if (!vsk->transport)
  351. return;
  352. vsk->transport->destruct(vsk);
  353. module_put(vsk->transport->module);
  354. vsk->transport = NULL;
  355. }
  356. /* Assign a transport to a socket and call the .init transport callback.
  357. *
  358. * Note: for stream socket this must be called when vsk->remote_addr is set
  359. * (e.g. during the connect() or when a connection request on a listener
  360. * socket is received).
  361. * The vsk->remote_addr is used to decide which transport to use:
  362. * - remote CID == VMADDR_CID_LOCAL or g2h->local_cid or VMADDR_CID_HOST if
  363. * g2h is not loaded, will use local transport;
  364. * - remote CID <= VMADDR_CID_HOST will use guest->host transport;
  365. * - remote CID > VMADDR_CID_HOST will use host->guest transport;
  366. */
  367. int vsock_assign_transport(struct vsock_sock *vsk, struct vsock_sock *psk)
  368. {
  369. const struct vsock_transport *new_transport;
  370. struct sock *sk = sk_vsock(vsk);
  371. unsigned int remote_cid = vsk->remote_addr.svm_cid;
  372. int ret;
  373. switch (sk->sk_type) {
  374. case SOCK_DGRAM:
  375. new_transport = transport_dgram;
  376. break;
  377. case SOCK_STREAM:
  378. if (vsock_use_local_transport(remote_cid))
  379. new_transport = transport_local;
  380. else if (remote_cid <= VMADDR_CID_HOST || !transport_h2g)
  381. new_transport = transport_g2h;
  382. else
  383. new_transport = transport_h2g;
  384. break;
  385. default:
  386. return -ESOCKTNOSUPPORT;
  387. }
  388. if (vsk->transport) {
  389. if (vsk->transport == new_transport)
  390. return 0;
  391. /* transport->release() must be called with sock lock acquired.
  392. * This path can only be taken during vsock_stream_connect(),
  393. * where we have already held the sock lock.
  394. * In the other cases, this function is called on a new socket
  395. * which is not assigned to any transport.
  396. */
  397. vsk->transport->release(vsk);
  398. vsock_deassign_transport(vsk);
  399. }
  400. /* We increase the module refcnt to prevent the transport unloading
  401. * while there are open sockets assigned to it.
  402. */
  403. if (!new_transport || !try_module_get(new_transport->module))
  404. return -ENODEV;
  405. ret = new_transport->init(vsk, psk);
  406. if (ret) {
  407. module_put(new_transport->module);
  408. return ret;
  409. }
  410. vsk->transport = new_transport;
  411. return 0;
  412. }
  413. EXPORT_SYMBOL_GPL(vsock_assign_transport);
  414. bool vsock_find_cid(unsigned int cid)
  415. {
  416. if (transport_g2h && cid == transport_g2h->get_local_cid())
  417. return true;
  418. if (transport_h2g && cid == VMADDR_CID_HOST)
  419. return true;
  420. if (transport_local && cid == VMADDR_CID_LOCAL)
  421. return true;
  422. return false;
  423. }
  424. EXPORT_SYMBOL_GPL(vsock_find_cid);
  425. static struct sock *vsock_dequeue_accept(struct sock *listener)
  426. {
  427. struct vsock_sock *vlistener;
  428. struct vsock_sock *vconnected;
  429. vlistener = vsock_sk(listener);
  430. if (list_empty(&vlistener->accept_queue))
  431. return NULL;
  432. vconnected = list_entry(vlistener->accept_queue.next,
  433. struct vsock_sock, accept_queue);
  434. list_del_init(&vconnected->accept_queue);
  435. sock_put(listener);
  436. /* The caller will need a reference on the connected socket so we let
  437. * it call sock_put().
  438. */
  439. return sk_vsock(vconnected);
  440. }
  441. static bool vsock_is_accept_queue_empty(struct sock *sk)
  442. {
  443. struct vsock_sock *vsk = vsock_sk(sk);
  444. return list_empty(&vsk->accept_queue);
  445. }
  446. static bool vsock_is_pending(struct sock *sk)
  447. {
  448. struct vsock_sock *vsk = vsock_sk(sk);
  449. return !list_empty(&vsk->pending_links);
  450. }
  451. static int vsock_send_shutdown(struct sock *sk, int mode)
  452. {
  453. struct vsock_sock *vsk = vsock_sk(sk);
  454. if (!vsk->transport)
  455. return -ENODEV;
  456. return vsk->transport->shutdown(vsk, mode);
  457. }
  458. static void vsock_pending_work(struct work_struct *work)
  459. {
  460. struct sock *sk;
  461. struct sock *listener;
  462. struct vsock_sock *vsk;
  463. bool cleanup;
  464. vsk = container_of(work, struct vsock_sock, pending_work.work);
  465. sk = sk_vsock(vsk);
  466. listener = vsk->listener;
  467. cleanup = true;
  468. lock_sock(listener);
  469. lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
  470. if (vsock_is_pending(sk)) {
  471. vsock_remove_pending(listener, sk);
  472. sk_acceptq_removed(listener);
  473. } else if (!vsk->rejected) {
  474. /* We are not on the pending list and accept() did not reject
  475. * us, so we must have been accepted by our user process. We
  476. * just need to drop our references to the sockets and be on
  477. * our way.
  478. */
  479. cleanup = false;
  480. goto out;
  481. }
  482. /* We need to remove ourself from the global connected sockets list so
  483. * incoming packets can't find this socket, and to reduce the reference
  484. * count.
  485. */
  486. vsock_remove_connected(vsk);
  487. sk->sk_state = TCP_CLOSE;
  488. out:
  489. release_sock(sk);
  490. release_sock(listener);
  491. if (cleanup)
  492. sock_put(sk);
  493. sock_put(sk);
  494. sock_put(listener);
  495. }
  496. /**** SOCKET OPERATIONS ****/
  497. static int __vsock_bind_stream(struct vsock_sock *vsk,
  498. struct sockaddr_vm *addr)
  499. {
  500. static u32 port;
  501. struct sockaddr_vm new_addr;
  502. if (!port)
  503. port = LAST_RESERVED_PORT + 1 +
  504. prandom_u32_max(U32_MAX - LAST_RESERVED_PORT);
  505. vsock_addr_init(&new_addr, addr->svm_cid, addr->svm_port);
  506. if (addr->svm_port == VMADDR_PORT_ANY) {
  507. bool found = false;
  508. unsigned int i;
  509. for (i = 0; i < MAX_PORT_RETRIES; i++) {
  510. if (port <= LAST_RESERVED_PORT)
  511. port = LAST_RESERVED_PORT + 1;
  512. new_addr.svm_port = port++;
  513. if (!__vsock_find_bound_socket(&new_addr)) {
  514. found = true;
  515. break;
  516. }
  517. }
  518. if (!found)
  519. return -EADDRNOTAVAIL;
  520. } else {
  521. /* If port is in reserved range, ensure caller
  522. * has necessary privileges.
  523. */
  524. if (addr->svm_port <= LAST_RESERVED_PORT &&
  525. !capable(CAP_NET_BIND_SERVICE)) {
  526. return -EACCES;
  527. }
  528. if (__vsock_find_bound_socket(&new_addr))
  529. return -EADDRINUSE;
  530. }
  531. vsock_addr_init(&vsk->local_addr, new_addr.svm_cid, new_addr.svm_port);
  532. /* Remove stream sockets from the unbound list and add them to the hash
  533. * table for easy lookup by its address. The unbound list is simply an
  534. * extra entry at the end of the hash table, a trick used by AF_UNIX.
  535. */
  536. __vsock_remove_bound(vsk);
  537. __vsock_insert_bound(vsock_bound_sockets(&vsk->local_addr), vsk);
  538. return 0;
  539. }
  540. static int __vsock_bind_dgram(struct vsock_sock *vsk,
  541. struct sockaddr_vm *addr)
  542. {
  543. return vsk->transport->dgram_bind(vsk, addr);
  544. }
  545. static int __vsock_bind(struct sock *sk, struct sockaddr_vm *addr)
  546. {
  547. struct vsock_sock *vsk = vsock_sk(sk);
  548. int retval;
  549. /* First ensure this socket isn't already bound. */
  550. if (vsock_addr_bound(&vsk->local_addr))
  551. return -EINVAL;
  552. /* Now bind to the provided address or select appropriate values if
  553. * none are provided (VMADDR_CID_ANY and VMADDR_PORT_ANY). Note that
  554. * like AF_INET prevents binding to a non-local IP address (in most
  555. * cases), we only allow binding to a local CID.
  556. */
  557. if (addr->svm_cid != VMADDR_CID_ANY && !vsock_find_cid(addr->svm_cid))
  558. return -EADDRNOTAVAIL;
  559. switch (sk->sk_socket->type) {
  560. case SOCK_STREAM:
  561. spin_lock_bh(&vsock_table_lock);
  562. retval = __vsock_bind_stream(vsk, addr);
  563. spin_unlock_bh(&vsock_table_lock);
  564. break;
  565. case SOCK_DGRAM:
  566. retval = __vsock_bind_dgram(vsk, addr);
  567. break;
  568. default:
  569. retval = -EINVAL;
  570. break;
  571. }
  572. return retval;
  573. }
  574. static void vsock_connect_timeout(struct work_struct *work);
  575. static struct sock *__vsock_create(struct net *net,
  576. struct socket *sock,
  577. struct sock *parent,
  578. gfp_t priority,
  579. unsigned short type,
  580. int kern)
  581. {
  582. struct sock *sk;
  583. struct vsock_sock *psk;
  584. struct vsock_sock *vsk;
  585. sk = sk_alloc(net, AF_VSOCK, priority, &vsock_proto, kern);
  586. if (!sk)
  587. return NULL;
  588. sock_init_data(sock, sk);
  589. /* sk->sk_type is normally set in sock_init_data, but only if sock is
  590. * non-NULL. We make sure that our sockets always have a type by
  591. * setting it here if needed.
  592. */
  593. if (!sock)
  594. sk->sk_type = type;
  595. vsk = vsock_sk(sk);
  596. vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
  597. vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
  598. sk->sk_destruct = vsock_sk_destruct;
  599. sk->sk_backlog_rcv = vsock_queue_rcv_skb;
  600. sock_reset_flag(sk, SOCK_DONE);
  601. INIT_LIST_HEAD(&vsk->bound_table);
  602. INIT_LIST_HEAD(&vsk->connected_table);
  603. vsk->listener = NULL;
  604. INIT_LIST_HEAD(&vsk->pending_links);
  605. INIT_LIST_HEAD(&vsk->accept_queue);
  606. vsk->rejected = false;
  607. vsk->sent_request = false;
  608. vsk->ignore_connecting_rst = false;
  609. vsk->peer_shutdown = 0;
  610. INIT_DELAYED_WORK(&vsk->connect_work, vsock_connect_timeout);
  611. INIT_DELAYED_WORK(&vsk->pending_work, vsock_pending_work);
  612. psk = parent ? vsock_sk(parent) : NULL;
  613. if (parent) {
  614. vsk->trusted = psk->trusted;
  615. vsk->owner = get_cred(psk->owner);
  616. vsk->connect_timeout = psk->connect_timeout;
  617. vsk->buffer_size = psk->buffer_size;
  618. vsk->buffer_min_size = psk->buffer_min_size;
  619. vsk->buffer_max_size = psk->buffer_max_size;
  620. security_sk_clone(parent, sk);
  621. } else {
  622. vsk->trusted = ns_capable_noaudit(&init_user_ns, CAP_NET_ADMIN);
  623. vsk->owner = get_current_cred();
  624. vsk->connect_timeout = VSOCK_DEFAULT_CONNECT_TIMEOUT;
  625. vsk->buffer_size = VSOCK_DEFAULT_BUFFER_SIZE;
  626. vsk->buffer_min_size = VSOCK_DEFAULT_BUFFER_MIN_SIZE;
  627. vsk->buffer_max_size = VSOCK_DEFAULT_BUFFER_MAX_SIZE;
  628. }
  629. return sk;
  630. }
  631. static void __vsock_release(struct sock *sk, int level)
  632. {
  633. if (sk) {
  634. struct sock *pending;
  635. struct vsock_sock *vsk;
  636. vsk = vsock_sk(sk);
  637. pending = NULL; /* Compiler warning. */
  638. /* When "level" is SINGLE_DEPTH_NESTING, use the nested
  639. * version to avoid the warning "possible recursive locking
  640. * detected". When "level" is 0, lock_sock_nested(sk, level)
  641. * is the same as lock_sock(sk).
  642. */
  643. lock_sock_nested(sk, level);
  644. if (vsk->transport)
  645. vsk->transport->release(vsk);
  646. else if (sk->sk_type == SOCK_STREAM)
  647. vsock_remove_sock(vsk);
  648. sock_orphan(sk);
  649. sk->sk_shutdown = SHUTDOWN_MASK;
  650. skb_queue_purge(&sk->sk_receive_queue);
  651. /* Clean up any sockets that never were accepted. */
  652. while ((pending = vsock_dequeue_accept(sk)) != NULL) {
  653. __vsock_release(pending, SINGLE_DEPTH_NESTING);
  654. sock_put(pending);
  655. }
  656. release_sock(sk);
  657. sock_put(sk);
  658. }
  659. }
  660. static void vsock_sk_destruct(struct sock *sk)
  661. {
  662. struct vsock_sock *vsk = vsock_sk(sk);
  663. vsock_deassign_transport(vsk);
  664. /* When clearing these addresses, there's no need to set the family and
  665. * possibly register the address family with the kernel.
  666. */
  667. vsock_addr_init(&vsk->local_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
  668. vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY, VMADDR_PORT_ANY);
  669. put_cred(vsk->owner);
  670. }
  671. static int vsock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
  672. {
  673. int err;
  674. err = sock_queue_rcv_skb(sk, skb);
  675. if (err)
  676. kfree_skb(skb);
  677. return err;
  678. }
  679. struct sock *vsock_create_connected(struct sock *parent)
  680. {
  681. return __vsock_create(sock_net(parent), NULL, parent, GFP_KERNEL,
  682. parent->sk_type, 0);
  683. }
  684. EXPORT_SYMBOL_GPL(vsock_create_connected);
  685. s64 vsock_stream_has_data(struct vsock_sock *vsk)
  686. {
  687. return vsk->transport->stream_has_data(vsk);
  688. }
  689. EXPORT_SYMBOL_GPL(vsock_stream_has_data);
  690. s64 vsock_stream_has_space(struct vsock_sock *vsk)
  691. {
  692. return vsk->transport->stream_has_space(vsk);
  693. }
  694. EXPORT_SYMBOL_GPL(vsock_stream_has_space);
  695. static int vsock_release(struct socket *sock)
  696. {
  697. __vsock_release(sock->sk, 0);
  698. sock->sk = NULL;
  699. sock->state = SS_FREE;
  700. return 0;
  701. }
  702. static int
  703. vsock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
  704. {
  705. int err;
  706. struct sock *sk;
  707. struct sockaddr_vm *vm_addr;
  708. sk = sock->sk;
  709. if (vsock_addr_cast(addr, addr_len, &vm_addr) != 0)
  710. return -EINVAL;
  711. lock_sock(sk);
  712. err = __vsock_bind(sk, vm_addr);
  713. release_sock(sk);
  714. return err;
  715. }
  716. static int vsock_getname(struct socket *sock,
  717. struct sockaddr *addr, int peer)
  718. {
  719. int err;
  720. struct sock *sk;
  721. struct vsock_sock *vsk;
  722. struct sockaddr_vm *vm_addr;
  723. sk = sock->sk;
  724. vsk = vsock_sk(sk);
  725. err = 0;
  726. lock_sock(sk);
  727. if (peer) {
  728. if (sock->state != SS_CONNECTED) {
  729. err = -ENOTCONN;
  730. goto out;
  731. }
  732. vm_addr = &vsk->remote_addr;
  733. } else {
  734. vm_addr = &vsk->local_addr;
  735. }
  736. if (!vm_addr) {
  737. err = -EINVAL;
  738. goto out;
  739. }
  740. /* sys_getsockname() and sys_getpeername() pass us a
  741. * MAX_SOCK_ADDR-sized buffer and don't set addr_len. Unfortunately
  742. * that macro is defined in socket.c instead of .h, so we hardcode its
  743. * value here.
  744. */
  745. BUILD_BUG_ON(sizeof(*vm_addr) > 128);
  746. memcpy(addr, vm_addr, sizeof(*vm_addr));
  747. err = sizeof(*vm_addr);
  748. out:
  749. release_sock(sk);
  750. return err;
  751. }
  752. static int vsock_shutdown(struct socket *sock, int mode)
  753. {
  754. int err;
  755. struct sock *sk;
  756. /* User level uses SHUT_RD (0) and SHUT_WR (1), but the kernel uses
  757. * RCV_SHUTDOWN (1) and SEND_SHUTDOWN (2), so we must increment mode
  758. * here like the other address families do. Note also that the
  759. * increment makes SHUT_RDWR (2) into RCV_SHUTDOWN | SEND_SHUTDOWN (3),
  760. * which is what we want.
  761. */
  762. mode++;
  763. if ((mode & ~SHUTDOWN_MASK) || !mode)
  764. return -EINVAL;
  765. /* If this is a STREAM socket and it is not connected then bail out
  766. * immediately. If it is a DGRAM socket then we must first kick the
  767. * socket so that it wakes up from any sleeping calls, for example
  768. * recv(), and then afterwards return the error.
  769. */
  770. sk = sock->sk;
  771. lock_sock(sk);
  772. if (sock->state == SS_UNCONNECTED) {
  773. err = -ENOTCONN;
  774. if (sk->sk_type == SOCK_STREAM)
  775. goto out;
  776. } else {
  777. sock->state = SS_DISCONNECTING;
  778. err = 0;
  779. }
  780. /* Receive and send shutdowns are treated alike. */
  781. mode = mode & (RCV_SHUTDOWN | SEND_SHUTDOWN);
  782. if (mode) {
  783. sk->sk_shutdown |= mode;
  784. sk->sk_state_change(sk);
  785. if (sk->sk_type == SOCK_STREAM) {
  786. sock_reset_flag(sk, SOCK_DONE);
  787. vsock_send_shutdown(sk, mode);
  788. }
  789. }
  790. out:
  791. release_sock(sk);
  792. return err;
  793. }
  794. static __poll_t vsock_poll(struct file *file, struct socket *sock,
  795. poll_table *wait)
  796. {
  797. struct sock *sk;
  798. __poll_t mask;
  799. struct vsock_sock *vsk;
  800. sk = sock->sk;
  801. vsk = vsock_sk(sk);
  802. poll_wait(file, sk_sleep(sk), wait);
  803. mask = 0;
  804. if (sk->sk_err)
  805. /* Signify that there has been an error on this socket. */
  806. mask |= EPOLLERR;
  807. /* INET sockets treat local write shutdown and peer write shutdown as a
  808. * case of EPOLLHUP set.
  809. */
  810. if ((sk->sk_shutdown == SHUTDOWN_MASK) ||
  811. ((sk->sk_shutdown & SEND_SHUTDOWN) &&
  812. (vsk->peer_shutdown & SEND_SHUTDOWN))) {
  813. mask |= EPOLLHUP;
  814. }
  815. if (sk->sk_shutdown & RCV_SHUTDOWN ||
  816. vsk->peer_shutdown & SEND_SHUTDOWN) {
  817. mask |= EPOLLRDHUP;
  818. }
  819. if (sock->type == SOCK_DGRAM) {
  820. /* For datagram sockets we can read if there is something in
  821. * the queue and write as long as the socket isn't shutdown for
  822. * sending.
  823. */
  824. if (!skb_queue_empty_lockless(&sk->sk_receive_queue) ||
  825. (sk->sk_shutdown & RCV_SHUTDOWN)) {
  826. mask |= EPOLLIN | EPOLLRDNORM;
  827. }
  828. if (!(sk->sk_shutdown & SEND_SHUTDOWN))
  829. mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
  830. } else if (sock->type == SOCK_STREAM) {
  831. const struct vsock_transport *transport;
  832. lock_sock(sk);
  833. transport = vsk->transport;
  834. /* Listening sockets that have connections in their accept
  835. * queue can be read.
  836. */
  837. if (sk->sk_state == TCP_LISTEN
  838. && !vsock_is_accept_queue_empty(sk))
  839. mask |= EPOLLIN | EPOLLRDNORM;
  840. /* If there is something in the queue then we can read. */
  841. if (transport && transport->stream_is_active(vsk) &&
  842. !(sk->sk_shutdown & RCV_SHUTDOWN)) {
  843. bool data_ready_now = false;
  844. int ret = transport->notify_poll_in(
  845. vsk, 1, &data_ready_now);
  846. if (ret < 0) {
  847. mask |= EPOLLERR;
  848. } else {
  849. if (data_ready_now)
  850. mask |= EPOLLIN | EPOLLRDNORM;
  851. }
  852. }
  853. /* Sockets whose connections have been closed, reset, or
  854. * terminated should also be considered read, and we check the
  855. * shutdown flag for that.
  856. */
  857. if (sk->sk_shutdown & RCV_SHUTDOWN ||
  858. vsk->peer_shutdown & SEND_SHUTDOWN) {
  859. mask |= EPOLLIN | EPOLLRDNORM;
  860. }
  861. /* Connected sockets that can produce data can be written. */
  862. if (transport && sk->sk_state == TCP_ESTABLISHED) {
  863. if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
  864. bool space_avail_now = false;
  865. int ret = transport->notify_poll_out(
  866. vsk, 1, &space_avail_now);
  867. if (ret < 0) {
  868. mask |= EPOLLERR;
  869. } else {
  870. if (space_avail_now)
  871. /* Remove EPOLLWRBAND since INET
  872. * sockets are not setting it.
  873. */
  874. mask |= EPOLLOUT | EPOLLWRNORM;
  875. }
  876. }
  877. }
  878. /* Simulate INET socket poll behaviors, which sets
  879. * EPOLLOUT|EPOLLWRNORM when peer is closed and nothing to read,
  880. * but local send is not shutdown.
  881. */
  882. if (sk->sk_state == TCP_CLOSE || sk->sk_state == TCP_CLOSING) {
  883. if (!(sk->sk_shutdown & SEND_SHUTDOWN))
  884. mask |= EPOLLOUT | EPOLLWRNORM;
  885. }
  886. release_sock(sk);
  887. }
  888. return mask;
  889. }
  890. static int vsock_dgram_sendmsg(struct socket *sock, struct msghdr *msg,
  891. size_t len)
  892. {
  893. int err;
  894. struct sock *sk;
  895. struct vsock_sock *vsk;
  896. struct sockaddr_vm *remote_addr;
  897. const struct vsock_transport *transport;
  898. if (msg->msg_flags & MSG_OOB)
  899. return -EOPNOTSUPP;
  900. /* For now, MSG_DONTWAIT is always assumed... */
  901. err = 0;
  902. sk = sock->sk;
  903. vsk = vsock_sk(sk);
  904. lock_sock(sk);
  905. transport = vsk->transport;
  906. err = vsock_auto_bind(vsk);
  907. if (err)
  908. goto out;
  909. /* If the provided message contains an address, use that. Otherwise
  910. * fall back on the socket's remote handle (if it has been connected).
  911. */
  912. if (msg->msg_name &&
  913. vsock_addr_cast(msg->msg_name, msg->msg_namelen,
  914. &remote_addr) == 0) {
  915. /* Ensure this address is of the right type and is a valid
  916. * destination.
  917. */
  918. if (remote_addr->svm_cid == VMADDR_CID_ANY)
  919. remote_addr->svm_cid = transport->get_local_cid();
  920. if (!vsock_addr_bound(remote_addr)) {
  921. err = -EINVAL;
  922. goto out;
  923. }
  924. } else if (sock->state == SS_CONNECTED) {
  925. remote_addr = &vsk->remote_addr;
  926. if (remote_addr->svm_cid == VMADDR_CID_ANY)
  927. remote_addr->svm_cid = transport->get_local_cid();
  928. /* XXX Should connect() or this function ensure remote_addr is
  929. * bound?
  930. */
  931. if (!vsock_addr_bound(&vsk->remote_addr)) {
  932. err = -EINVAL;
  933. goto out;
  934. }
  935. } else {
  936. err = -EINVAL;
  937. goto out;
  938. }
  939. if (!transport->dgram_allow(remote_addr->svm_cid,
  940. remote_addr->svm_port)) {
  941. err = -EINVAL;
  942. goto out;
  943. }
  944. err = transport->dgram_enqueue(vsk, remote_addr, msg, len);
  945. out:
  946. release_sock(sk);
  947. return err;
  948. }
  949. static int vsock_dgram_connect(struct socket *sock,
  950. struct sockaddr *addr, int addr_len, int flags)
  951. {
  952. int err;
  953. struct sock *sk;
  954. struct vsock_sock *vsk;
  955. struct sockaddr_vm *remote_addr;
  956. sk = sock->sk;
  957. vsk = vsock_sk(sk);
  958. err = vsock_addr_cast(addr, addr_len, &remote_addr);
  959. if (err == -EAFNOSUPPORT && remote_addr->svm_family == AF_UNSPEC) {
  960. lock_sock(sk);
  961. vsock_addr_init(&vsk->remote_addr, VMADDR_CID_ANY,
  962. VMADDR_PORT_ANY);
  963. sock->state = SS_UNCONNECTED;
  964. release_sock(sk);
  965. return 0;
  966. } else if (err != 0)
  967. return -EINVAL;
  968. lock_sock(sk);
  969. err = vsock_auto_bind(vsk);
  970. if (err)
  971. goto out;
  972. if (!vsk->transport->dgram_allow(remote_addr->svm_cid,
  973. remote_addr->svm_port)) {
  974. err = -EINVAL;
  975. goto out;
  976. }
  977. memcpy(&vsk->remote_addr, remote_addr, sizeof(vsk->remote_addr));
  978. sock->state = SS_CONNECTED;
  979. out:
  980. release_sock(sk);
  981. return err;
  982. }
  983. static int vsock_dgram_recvmsg(struct socket *sock, struct msghdr *msg,
  984. size_t len, int flags)
  985. {
  986. struct vsock_sock *vsk = vsock_sk(sock->sk);
  987. return vsk->transport->dgram_dequeue(vsk, msg, len, flags);
  988. }
  989. static const struct proto_ops vsock_dgram_ops = {
  990. .family = PF_VSOCK,
  991. .owner = THIS_MODULE,
  992. .release = vsock_release,
  993. .bind = vsock_bind,
  994. .connect = vsock_dgram_connect,
  995. .socketpair = sock_no_socketpair,
  996. .accept = sock_no_accept,
  997. .getname = vsock_getname,
  998. .poll = vsock_poll,
  999. .ioctl = sock_no_ioctl,
  1000. .listen = sock_no_listen,
  1001. .shutdown = vsock_shutdown,
  1002. .sendmsg = vsock_dgram_sendmsg,
  1003. .recvmsg = vsock_dgram_recvmsg,
  1004. .mmap = sock_no_mmap,
  1005. .sendpage = sock_no_sendpage,
  1006. };
  1007. static int vsock_transport_cancel_pkt(struct vsock_sock *vsk)
  1008. {
  1009. const struct vsock_transport *transport = vsk->transport;
  1010. if (!transport || !transport->cancel_pkt)
  1011. return -EOPNOTSUPP;
  1012. return transport->cancel_pkt(vsk);
  1013. }
  1014. static void vsock_connect_timeout(struct work_struct *work)
  1015. {
  1016. struct sock *sk;
  1017. struct vsock_sock *vsk;
  1018. vsk = container_of(work, struct vsock_sock, connect_work.work);
  1019. sk = sk_vsock(vsk);
  1020. lock_sock(sk);
  1021. if (sk->sk_state == TCP_SYN_SENT &&
  1022. (sk->sk_shutdown != SHUTDOWN_MASK)) {
  1023. sk->sk_state = TCP_CLOSE;
  1024. sk->sk_err = ETIMEDOUT;
  1025. sk->sk_error_report(sk);
  1026. vsock_transport_cancel_pkt(vsk);
  1027. }
  1028. release_sock(sk);
  1029. sock_put(sk);
  1030. }
  1031. static int vsock_stream_connect(struct socket *sock, struct sockaddr *addr,
  1032. int addr_len, int flags)
  1033. {
  1034. int err;
  1035. struct sock *sk;
  1036. struct vsock_sock *vsk;
  1037. const struct vsock_transport *transport;
  1038. struct sockaddr_vm *remote_addr;
  1039. long timeout;
  1040. DEFINE_WAIT(wait);
  1041. err = 0;
  1042. sk = sock->sk;
  1043. vsk = vsock_sk(sk);
  1044. lock_sock(sk);
  1045. /* XXX AF_UNSPEC should make us disconnect like AF_INET. */
  1046. switch (sock->state) {
  1047. case SS_CONNECTED:
  1048. err = -EISCONN;
  1049. goto out;
  1050. case SS_DISCONNECTING:
  1051. err = -EINVAL;
  1052. goto out;
  1053. case SS_CONNECTING:
  1054. /* This continues on so we can move sock into the SS_CONNECTED
  1055. * state once the connection has completed (at which point err
  1056. * will be set to zero also). Otherwise, we will either wait
  1057. * for the connection or return -EALREADY should this be a
  1058. * non-blocking call.
  1059. */
  1060. err = -EALREADY;
  1061. if (flags & O_NONBLOCK)
  1062. goto out;
  1063. break;
  1064. default:
  1065. if ((sk->sk_state == TCP_LISTEN) ||
  1066. vsock_addr_cast(addr, addr_len, &remote_addr) != 0) {
  1067. err = -EINVAL;
  1068. goto out;
  1069. }
  1070. /* Set the remote address that we are connecting to. */
  1071. memcpy(&vsk->remote_addr, remote_addr,
  1072. sizeof(vsk->remote_addr));
  1073. err = vsock_assign_transport(vsk, NULL);
  1074. if (err)
  1075. goto out;
  1076. transport = vsk->transport;
  1077. /* The hypervisor and well-known contexts do not have socket
  1078. * endpoints.
  1079. */
  1080. if (!transport ||
  1081. !transport->stream_allow(remote_addr->svm_cid,
  1082. remote_addr->svm_port)) {
  1083. err = -ENETUNREACH;
  1084. goto out;
  1085. }
  1086. err = vsock_auto_bind(vsk);
  1087. if (err)
  1088. goto out;
  1089. sk->sk_state = TCP_SYN_SENT;
  1090. err = transport->connect(vsk);
  1091. if (err < 0)
  1092. goto out;
  1093. /* Mark sock as connecting and set the error code to in
  1094. * progress in case this is a non-blocking connect.
  1095. */
  1096. sock->state = SS_CONNECTING;
  1097. err = -EINPROGRESS;
  1098. }
  1099. /* The receive path will handle all communication until we are able to
  1100. * enter the connected state. Here we wait for the connection to be
  1101. * completed or a notification of an error.
  1102. */
  1103. timeout = vsk->connect_timeout;
  1104. prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  1105. while (sk->sk_state != TCP_ESTABLISHED && sk->sk_err == 0) {
  1106. if (flags & O_NONBLOCK) {
  1107. /* If we're not going to block, we schedule a timeout
  1108. * function to generate a timeout on the connection
  1109. * attempt, in case the peer doesn't respond in a
  1110. * timely manner. We hold on to the socket until the
  1111. * timeout fires.
  1112. */
  1113. sock_hold(sk);
  1114. schedule_delayed_work(&vsk->connect_work, timeout);
  1115. /* Skip ahead to preserve error code set above. */
  1116. goto out_wait;
  1117. }
  1118. release_sock(sk);
  1119. timeout = schedule_timeout(timeout);
  1120. lock_sock(sk);
  1121. if (signal_pending(current)) {
  1122. err = sock_intr_errno(timeout);
  1123. sk->sk_state = sk->sk_state == TCP_ESTABLISHED ? TCP_CLOSING : TCP_CLOSE;
  1124. sock->state = SS_UNCONNECTED;
  1125. vsock_transport_cancel_pkt(vsk);
  1126. vsock_remove_connected(vsk);
  1127. goto out_wait;
  1128. } else if (timeout == 0) {
  1129. err = -ETIMEDOUT;
  1130. sk->sk_state = TCP_CLOSE;
  1131. sock->state = SS_UNCONNECTED;
  1132. vsock_transport_cancel_pkt(vsk);
  1133. goto out_wait;
  1134. }
  1135. prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  1136. }
  1137. if (sk->sk_err) {
  1138. err = -sk->sk_err;
  1139. sk->sk_state = TCP_CLOSE;
  1140. sock->state = SS_UNCONNECTED;
  1141. } else {
  1142. err = 0;
  1143. }
  1144. out_wait:
  1145. finish_wait(sk_sleep(sk), &wait);
  1146. out:
  1147. release_sock(sk);
  1148. return err;
  1149. }
  1150. static int vsock_accept(struct socket *sock, struct socket *newsock, int flags,
  1151. bool kern)
  1152. {
  1153. struct sock *listener;
  1154. int err;
  1155. struct sock *connected;
  1156. struct vsock_sock *vconnected;
  1157. long timeout;
  1158. DEFINE_WAIT(wait);
  1159. err = 0;
  1160. listener = sock->sk;
  1161. lock_sock(listener);
  1162. if (sock->type != SOCK_STREAM) {
  1163. err = -EOPNOTSUPP;
  1164. goto out;
  1165. }
  1166. if (listener->sk_state != TCP_LISTEN) {
  1167. err = -EINVAL;
  1168. goto out;
  1169. }
  1170. /* Wait for children sockets to appear; these are the new sockets
  1171. * created upon connection establishment.
  1172. */
  1173. timeout = sock_rcvtimeo(listener, flags & O_NONBLOCK);
  1174. prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);
  1175. while ((connected = vsock_dequeue_accept(listener)) == NULL &&
  1176. listener->sk_err == 0) {
  1177. release_sock(listener);
  1178. timeout = schedule_timeout(timeout);
  1179. finish_wait(sk_sleep(listener), &wait);
  1180. lock_sock(listener);
  1181. if (signal_pending(current)) {
  1182. err = sock_intr_errno(timeout);
  1183. goto out;
  1184. } else if (timeout == 0) {
  1185. err = -EAGAIN;
  1186. goto out;
  1187. }
  1188. prepare_to_wait(sk_sleep(listener), &wait, TASK_INTERRUPTIBLE);
  1189. }
  1190. finish_wait(sk_sleep(listener), &wait);
  1191. if (listener->sk_err)
  1192. err = -listener->sk_err;
  1193. if (connected) {
  1194. sk_acceptq_removed(listener);
  1195. lock_sock_nested(connected, SINGLE_DEPTH_NESTING);
  1196. vconnected = vsock_sk(connected);
  1197. /* If the listener socket has received an error, then we should
  1198. * reject this socket and return. Note that we simply mark the
  1199. * socket rejected, drop our reference, and let the cleanup
  1200. * function handle the cleanup; the fact that we found it in
  1201. * the listener's accept queue guarantees that the cleanup
  1202. * function hasn't run yet.
  1203. */
  1204. if (err) {
  1205. vconnected->rejected = true;
  1206. } else {
  1207. newsock->state = SS_CONNECTED;
  1208. sock_graft(connected, newsock);
  1209. }
  1210. release_sock(connected);
  1211. sock_put(connected);
  1212. }
  1213. out:
  1214. release_sock(listener);
  1215. return err;
  1216. }
  1217. static int vsock_listen(struct socket *sock, int backlog)
  1218. {
  1219. int err;
  1220. struct sock *sk;
  1221. struct vsock_sock *vsk;
  1222. sk = sock->sk;
  1223. lock_sock(sk);
  1224. if (sock->type != SOCK_STREAM) {
  1225. err = -EOPNOTSUPP;
  1226. goto out;
  1227. }
  1228. if (sock->state != SS_UNCONNECTED) {
  1229. err = -EINVAL;
  1230. goto out;
  1231. }
  1232. vsk = vsock_sk(sk);
  1233. if (!vsock_addr_bound(&vsk->local_addr)) {
  1234. err = -EINVAL;
  1235. goto out;
  1236. }
  1237. sk->sk_max_ack_backlog = backlog;
  1238. sk->sk_state = TCP_LISTEN;
  1239. err = 0;
  1240. out:
  1241. release_sock(sk);
  1242. return err;
  1243. }
  1244. static void vsock_update_buffer_size(struct vsock_sock *vsk,
  1245. const struct vsock_transport *transport,
  1246. u64 val)
  1247. {
  1248. if (val > vsk->buffer_max_size)
  1249. val = vsk->buffer_max_size;
  1250. if (val < vsk->buffer_min_size)
  1251. val = vsk->buffer_min_size;
  1252. if (val != vsk->buffer_size &&
  1253. transport && transport->notify_buffer_size)
  1254. transport->notify_buffer_size(vsk, &val);
  1255. vsk->buffer_size = val;
  1256. }
  1257. static int vsock_stream_setsockopt(struct socket *sock,
  1258. int level,
  1259. int optname,
  1260. sockptr_t optval,
  1261. unsigned int optlen)
  1262. {
  1263. int err;
  1264. struct sock *sk;
  1265. struct vsock_sock *vsk;
  1266. const struct vsock_transport *transport;
  1267. u64 val;
  1268. if (level != AF_VSOCK)
  1269. return -ENOPROTOOPT;
  1270. #define COPY_IN(_v) \
  1271. do { \
  1272. if (optlen < sizeof(_v)) { \
  1273. err = -EINVAL; \
  1274. goto exit; \
  1275. } \
  1276. if (copy_from_sockptr(&_v, optval, sizeof(_v)) != 0) { \
  1277. err = -EFAULT; \
  1278. goto exit; \
  1279. } \
  1280. } while (0)
  1281. err = 0;
  1282. sk = sock->sk;
  1283. vsk = vsock_sk(sk);
  1284. lock_sock(sk);
  1285. transport = vsk->transport;
  1286. switch (optname) {
  1287. case SO_VM_SOCKETS_BUFFER_SIZE:
  1288. COPY_IN(val);
  1289. vsock_update_buffer_size(vsk, transport, val);
  1290. break;
  1291. case SO_VM_SOCKETS_BUFFER_MAX_SIZE:
  1292. COPY_IN(val);
  1293. vsk->buffer_max_size = val;
  1294. vsock_update_buffer_size(vsk, transport, vsk->buffer_size);
  1295. break;
  1296. case SO_VM_SOCKETS_BUFFER_MIN_SIZE:
  1297. COPY_IN(val);
  1298. vsk->buffer_min_size = val;
  1299. vsock_update_buffer_size(vsk, transport, vsk->buffer_size);
  1300. break;
  1301. case SO_VM_SOCKETS_CONNECT_TIMEOUT: {
  1302. struct __kernel_old_timeval tv;
  1303. COPY_IN(tv);
  1304. if (tv.tv_sec >= 0 && tv.tv_usec < USEC_PER_SEC &&
  1305. tv.tv_sec < (MAX_SCHEDULE_TIMEOUT / HZ - 1)) {
  1306. vsk->connect_timeout = tv.tv_sec * HZ +
  1307. DIV_ROUND_UP(tv.tv_usec, (1000000 / HZ));
  1308. if (vsk->connect_timeout == 0)
  1309. vsk->connect_timeout =
  1310. VSOCK_DEFAULT_CONNECT_TIMEOUT;
  1311. } else {
  1312. err = -ERANGE;
  1313. }
  1314. break;
  1315. }
  1316. default:
  1317. err = -ENOPROTOOPT;
  1318. break;
  1319. }
  1320. #undef COPY_IN
  1321. exit:
  1322. release_sock(sk);
  1323. return err;
  1324. }
  1325. static int vsock_stream_getsockopt(struct socket *sock,
  1326. int level, int optname,
  1327. char __user *optval,
  1328. int __user *optlen)
  1329. {
  1330. int err;
  1331. int len;
  1332. struct sock *sk;
  1333. struct vsock_sock *vsk;
  1334. u64 val;
  1335. if (level != AF_VSOCK)
  1336. return -ENOPROTOOPT;
  1337. err = get_user(len, optlen);
  1338. if (err != 0)
  1339. return err;
  1340. #define COPY_OUT(_v) \
  1341. do { \
  1342. if (len < sizeof(_v)) \
  1343. return -EINVAL; \
  1344. \
  1345. len = sizeof(_v); \
  1346. if (copy_to_user(optval, &_v, len) != 0) \
  1347. return -EFAULT; \
  1348. \
  1349. } while (0)
  1350. err = 0;
  1351. sk = sock->sk;
  1352. vsk = vsock_sk(sk);
  1353. switch (optname) {
  1354. case SO_VM_SOCKETS_BUFFER_SIZE:
  1355. val = vsk->buffer_size;
  1356. COPY_OUT(val);
  1357. break;
  1358. case SO_VM_SOCKETS_BUFFER_MAX_SIZE:
  1359. val = vsk->buffer_max_size;
  1360. COPY_OUT(val);
  1361. break;
  1362. case SO_VM_SOCKETS_BUFFER_MIN_SIZE:
  1363. val = vsk->buffer_min_size;
  1364. COPY_OUT(val);
  1365. break;
  1366. case SO_VM_SOCKETS_CONNECT_TIMEOUT: {
  1367. struct __kernel_old_timeval tv;
  1368. tv.tv_sec = vsk->connect_timeout / HZ;
  1369. tv.tv_usec =
  1370. (vsk->connect_timeout -
  1371. tv.tv_sec * HZ) * (1000000 / HZ);
  1372. COPY_OUT(tv);
  1373. break;
  1374. }
  1375. default:
  1376. return -ENOPROTOOPT;
  1377. }
  1378. err = put_user(len, optlen);
  1379. if (err != 0)
  1380. return -EFAULT;
  1381. #undef COPY_OUT
  1382. return 0;
  1383. }
  1384. static int vsock_stream_sendmsg(struct socket *sock, struct msghdr *msg,
  1385. size_t len)
  1386. {
  1387. struct sock *sk;
  1388. struct vsock_sock *vsk;
  1389. const struct vsock_transport *transport;
  1390. ssize_t total_written;
  1391. long timeout;
  1392. int err;
  1393. struct vsock_transport_send_notify_data send_data;
  1394. DEFINE_WAIT_FUNC(wait, woken_wake_function);
  1395. sk = sock->sk;
  1396. vsk = vsock_sk(sk);
  1397. total_written = 0;
  1398. err = 0;
  1399. if (msg->msg_flags & MSG_OOB)
  1400. return -EOPNOTSUPP;
  1401. lock_sock(sk);
  1402. transport = vsk->transport;
  1403. /* Callers should not provide a destination with stream sockets. */
  1404. if (msg->msg_namelen) {
  1405. err = sk->sk_state == TCP_ESTABLISHED ? -EISCONN : -EOPNOTSUPP;
  1406. goto out;
  1407. }
  1408. /* Send data only if both sides are not shutdown in the direction. */
  1409. if (sk->sk_shutdown & SEND_SHUTDOWN ||
  1410. vsk->peer_shutdown & RCV_SHUTDOWN) {
  1411. err = -EPIPE;
  1412. goto out;
  1413. }
  1414. if (!transport || sk->sk_state != TCP_ESTABLISHED ||
  1415. !vsock_addr_bound(&vsk->local_addr)) {
  1416. err = -ENOTCONN;
  1417. goto out;
  1418. }
  1419. if (!vsock_addr_bound(&vsk->remote_addr)) {
  1420. err = -EDESTADDRREQ;
  1421. goto out;
  1422. }
  1423. /* Wait for room in the produce queue to enqueue our user's data. */
  1424. timeout = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
  1425. err = transport->notify_send_init(vsk, &send_data);
  1426. if (err < 0)
  1427. goto out;
  1428. while (total_written < len) {
  1429. ssize_t written;
  1430. add_wait_queue(sk_sleep(sk), &wait);
  1431. while (vsock_stream_has_space(vsk) == 0 &&
  1432. sk->sk_err == 0 &&
  1433. !(sk->sk_shutdown & SEND_SHUTDOWN) &&
  1434. !(vsk->peer_shutdown & RCV_SHUTDOWN)) {
  1435. /* Don't wait for non-blocking sockets. */
  1436. if (timeout == 0) {
  1437. err = -EAGAIN;
  1438. remove_wait_queue(sk_sleep(sk), &wait);
  1439. goto out_err;
  1440. }
  1441. err = transport->notify_send_pre_block(vsk, &send_data);
  1442. if (err < 0) {
  1443. remove_wait_queue(sk_sleep(sk), &wait);
  1444. goto out_err;
  1445. }
  1446. release_sock(sk);
  1447. timeout = wait_woken(&wait, TASK_INTERRUPTIBLE, timeout);
  1448. lock_sock(sk);
  1449. if (signal_pending(current)) {
  1450. err = sock_intr_errno(timeout);
  1451. remove_wait_queue(sk_sleep(sk), &wait);
  1452. goto out_err;
  1453. } else if (timeout == 0) {
  1454. err = -EAGAIN;
  1455. remove_wait_queue(sk_sleep(sk), &wait);
  1456. goto out_err;
  1457. }
  1458. }
  1459. remove_wait_queue(sk_sleep(sk), &wait);
  1460. /* These checks occur both as part of and after the loop
  1461. * conditional since we need to check before and after
  1462. * sleeping.
  1463. */
  1464. if (sk->sk_err) {
  1465. err = -sk->sk_err;
  1466. goto out_err;
  1467. } else if ((sk->sk_shutdown & SEND_SHUTDOWN) ||
  1468. (vsk->peer_shutdown & RCV_SHUTDOWN)) {
  1469. err = -EPIPE;
  1470. goto out_err;
  1471. }
  1472. err = transport->notify_send_pre_enqueue(vsk, &send_data);
  1473. if (err < 0)
  1474. goto out_err;
  1475. /* Note that enqueue will only write as many bytes as are free
  1476. * in the produce queue, so we don't need to ensure len is
  1477. * smaller than the queue size. It is the caller's
  1478. * responsibility to check how many bytes we were able to send.
  1479. */
  1480. written = transport->stream_enqueue(
  1481. vsk, msg,
  1482. len - total_written);
  1483. if (written < 0) {
  1484. err = -ENOMEM;
  1485. goto out_err;
  1486. }
  1487. total_written += written;
  1488. err = transport->notify_send_post_enqueue(
  1489. vsk, written, &send_data);
  1490. if (err < 0)
  1491. goto out_err;
  1492. }
  1493. out_err:
  1494. if (total_written > 0)
  1495. err = total_written;
  1496. out:
  1497. release_sock(sk);
  1498. return err;
  1499. }
  1500. static int
  1501. vsock_stream_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
  1502. int flags)
  1503. {
  1504. struct sock *sk;
  1505. struct vsock_sock *vsk;
  1506. const struct vsock_transport *transport;
  1507. int err;
  1508. size_t target;
  1509. ssize_t copied;
  1510. long timeout;
  1511. struct vsock_transport_recv_notify_data recv_data;
  1512. DEFINE_WAIT(wait);
  1513. sk = sock->sk;
  1514. vsk = vsock_sk(sk);
  1515. err = 0;
  1516. lock_sock(sk);
  1517. transport = vsk->transport;
  1518. if (!transport || sk->sk_state != TCP_ESTABLISHED) {
  1519. /* Recvmsg is supposed to return 0 if a peer performs an
  1520. * orderly shutdown. Differentiate between that case and when a
  1521. * peer has not connected or a local shutdown occured with the
  1522. * SOCK_DONE flag.
  1523. */
  1524. if (sock_flag(sk, SOCK_DONE))
  1525. err = 0;
  1526. else
  1527. err = -ENOTCONN;
  1528. goto out;
  1529. }
  1530. if (flags & MSG_OOB) {
  1531. err = -EOPNOTSUPP;
  1532. goto out;
  1533. }
  1534. /* We don't check peer_shutdown flag here since peer may actually shut
  1535. * down, but there can be data in the queue that a local socket can
  1536. * receive.
  1537. */
  1538. if (sk->sk_shutdown & RCV_SHUTDOWN) {
  1539. err = 0;
  1540. goto out;
  1541. }
  1542. /* It is valid on Linux to pass in a zero-length receive buffer. This
  1543. * is not an error. We may as well bail out now.
  1544. */
  1545. if (!len) {
  1546. err = 0;
  1547. goto out;
  1548. }
  1549. /* We must not copy less than target bytes into the user's buffer
  1550. * before returning successfully, so we wait for the consume queue to
  1551. * have that much data to consume before dequeueing. Note that this
  1552. * makes it impossible to handle cases where target is greater than the
  1553. * queue size.
  1554. */
  1555. target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
  1556. if (target >= transport->stream_rcvhiwat(vsk)) {
  1557. err = -ENOMEM;
  1558. goto out;
  1559. }
  1560. timeout = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
  1561. copied = 0;
  1562. err = transport->notify_recv_init(vsk, target, &recv_data);
  1563. if (err < 0)
  1564. goto out;
  1565. while (1) {
  1566. s64 ready;
  1567. prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
  1568. ready = vsock_stream_has_data(vsk);
  1569. if (ready == 0) {
  1570. if (sk->sk_err != 0 ||
  1571. (sk->sk_shutdown & RCV_SHUTDOWN) ||
  1572. (vsk->peer_shutdown & SEND_SHUTDOWN)) {
  1573. finish_wait(sk_sleep(sk), &wait);
  1574. break;
  1575. }
  1576. /* Don't wait for non-blocking sockets. */
  1577. if (timeout == 0) {
  1578. err = -EAGAIN;
  1579. finish_wait(sk_sleep(sk), &wait);
  1580. break;
  1581. }
  1582. err = transport->notify_recv_pre_block(
  1583. vsk, target, &recv_data);
  1584. if (err < 0) {
  1585. finish_wait(sk_sleep(sk), &wait);
  1586. break;
  1587. }
  1588. release_sock(sk);
  1589. timeout = schedule_timeout(timeout);
  1590. lock_sock(sk);
  1591. if (signal_pending(current)) {
  1592. err = sock_intr_errno(timeout);
  1593. finish_wait(sk_sleep(sk), &wait);
  1594. break;
  1595. } else if (timeout == 0) {
  1596. err = -EAGAIN;
  1597. finish_wait(sk_sleep(sk), &wait);
  1598. break;
  1599. }
  1600. } else {
  1601. ssize_t read;
  1602. finish_wait(sk_sleep(sk), &wait);
  1603. if (ready < 0) {
  1604. /* Invalid queue pair content. XXX This should
  1605. * be changed to a connection reset in a later
  1606. * change.
  1607. */
  1608. err = -ENOMEM;
  1609. goto out;
  1610. }
  1611. err = transport->notify_recv_pre_dequeue(
  1612. vsk, target, &recv_data);
  1613. if (err < 0)
  1614. break;
  1615. read = transport->stream_dequeue(
  1616. vsk, msg,
  1617. len - copied, flags);
  1618. if (read < 0) {
  1619. err = -ENOMEM;
  1620. break;
  1621. }
  1622. copied += read;
  1623. err = transport->notify_recv_post_dequeue(
  1624. vsk, target, read,
  1625. !(flags & MSG_PEEK), &recv_data);
  1626. if (err < 0)
  1627. goto out;
  1628. if (read >= target || flags & MSG_PEEK)
  1629. break;
  1630. target -= read;
  1631. }
  1632. }
  1633. if (sk->sk_err)
  1634. err = -sk->sk_err;
  1635. else if (sk->sk_shutdown & RCV_SHUTDOWN)
  1636. err = 0;
  1637. if (copied > 0)
  1638. err = copied;
  1639. out:
  1640. release_sock(sk);
  1641. return err;
  1642. }
  1643. static const struct proto_ops vsock_stream_ops = {
  1644. .family = PF_VSOCK,
  1645. .owner = THIS_MODULE,
  1646. .release = vsock_release,
  1647. .bind = vsock_bind,
  1648. .connect = vsock_stream_connect,
  1649. .socketpair = sock_no_socketpair,
  1650. .accept = vsock_accept,
  1651. .getname = vsock_getname,
  1652. .poll = vsock_poll,
  1653. .ioctl = sock_no_ioctl,
  1654. .listen = vsock_listen,
  1655. .shutdown = vsock_shutdown,
  1656. .setsockopt = vsock_stream_setsockopt,
  1657. .getsockopt = vsock_stream_getsockopt,
  1658. .sendmsg = vsock_stream_sendmsg,
  1659. .recvmsg = vsock_stream_recvmsg,
  1660. .mmap = sock_no_mmap,
  1661. .sendpage = sock_no_sendpage,
  1662. };
  1663. static int vsock_create(struct net *net, struct socket *sock,
  1664. int protocol, int kern)
  1665. {
  1666. struct vsock_sock *vsk;
  1667. struct sock *sk;
  1668. int ret;
  1669. if (!sock)
  1670. return -EINVAL;
  1671. if (protocol && protocol != PF_VSOCK)
  1672. return -EPROTONOSUPPORT;
  1673. switch (sock->type) {
  1674. case SOCK_DGRAM:
  1675. sock->ops = &vsock_dgram_ops;
  1676. break;
  1677. case SOCK_STREAM:
  1678. sock->ops = &vsock_stream_ops;
  1679. break;
  1680. default:
  1681. return -ESOCKTNOSUPPORT;
  1682. }
  1683. sock->state = SS_UNCONNECTED;
  1684. sk = __vsock_create(net, sock, NULL, GFP_KERNEL, 0, kern);
  1685. if (!sk)
  1686. return -ENOMEM;
  1687. vsk = vsock_sk(sk);
  1688. if (sock->type == SOCK_DGRAM) {
  1689. ret = vsock_assign_transport(vsk, NULL);
  1690. if (ret < 0) {
  1691. sock_put(sk);
  1692. return ret;
  1693. }
  1694. }
  1695. vsock_insert_unbound(vsk);
  1696. return 0;
  1697. }
  1698. static const struct net_proto_family vsock_family_ops = {
  1699. .family = AF_VSOCK,
  1700. .create = vsock_create,
  1701. .owner = THIS_MODULE,
  1702. };
  1703. static long vsock_dev_do_ioctl(struct file *filp,
  1704. unsigned int cmd, void __user *ptr)
  1705. {
  1706. u32 __user *p = ptr;
  1707. u32 cid = VMADDR_CID_ANY;
  1708. int retval = 0;
  1709. switch (cmd) {
  1710. case IOCTL_VM_SOCKETS_GET_LOCAL_CID:
  1711. /* To be compatible with the VMCI behavior, we prioritize the
  1712. * guest CID instead of well-know host CID (VMADDR_CID_HOST).
  1713. */
  1714. if (transport_g2h)
  1715. cid = transport_g2h->get_local_cid();
  1716. else if (transport_h2g)
  1717. cid = transport_h2g->get_local_cid();
  1718. if (put_user(cid, p) != 0)
  1719. retval = -EFAULT;
  1720. break;
  1721. default:
  1722. pr_err("Unknown ioctl %d\n", cmd);
  1723. retval = -EINVAL;
  1724. }
  1725. return retval;
  1726. }
  1727. static long vsock_dev_ioctl(struct file *filp,
  1728. unsigned int cmd, unsigned long arg)
  1729. {
  1730. return vsock_dev_do_ioctl(filp, cmd, (void __user *)arg);
  1731. }
  1732. #ifdef CONFIG_COMPAT
  1733. static long vsock_dev_compat_ioctl(struct file *filp,
  1734. unsigned int cmd, unsigned long arg)
  1735. {
  1736. return vsock_dev_do_ioctl(filp, cmd, compat_ptr(arg));
  1737. }
  1738. #endif
  1739. static const struct file_operations vsock_device_ops = {
  1740. .owner = THIS_MODULE,
  1741. .unlocked_ioctl = vsock_dev_ioctl,
  1742. #ifdef CONFIG_COMPAT
  1743. .compat_ioctl = vsock_dev_compat_ioctl,
  1744. #endif
  1745. .open = nonseekable_open,
  1746. };
  1747. static struct miscdevice vsock_device = {
  1748. .name = "vsock",
  1749. .fops = &vsock_device_ops,
  1750. };
  1751. static int __init vsock_init(void)
  1752. {
  1753. int err = 0;
  1754. vsock_init_tables();
  1755. vsock_proto.owner = THIS_MODULE;
  1756. vsock_device.minor = MISC_DYNAMIC_MINOR;
  1757. err = misc_register(&vsock_device);
  1758. if (err) {
  1759. pr_err("Failed to register misc device\n");
  1760. goto err_reset_transport;
  1761. }
  1762. err = proto_register(&vsock_proto, 1); /* we want our slab */
  1763. if (err) {
  1764. pr_err("Cannot register vsock protocol\n");
  1765. goto err_deregister_misc;
  1766. }
  1767. err = sock_register(&vsock_family_ops);
  1768. if (err) {
  1769. pr_err("could not register af_vsock (%d) address family: %d\n",
  1770. AF_VSOCK, err);
  1771. goto err_unregister_proto;
  1772. }
  1773. return 0;
  1774. err_unregister_proto:
  1775. proto_unregister(&vsock_proto);
  1776. err_deregister_misc:
  1777. misc_deregister(&vsock_device);
  1778. err_reset_transport:
  1779. return err;
  1780. }
  1781. static void __exit vsock_exit(void)
  1782. {
  1783. misc_deregister(&vsock_device);
  1784. sock_unregister(AF_VSOCK);
  1785. proto_unregister(&vsock_proto);
  1786. }
  1787. const struct vsock_transport *vsock_core_get_transport(struct vsock_sock *vsk)
  1788. {
  1789. return vsk->transport;
  1790. }
  1791. EXPORT_SYMBOL_GPL(vsock_core_get_transport);
  1792. int vsock_core_register(const struct vsock_transport *t, int features)
  1793. {
  1794. const struct vsock_transport *t_h2g, *t_g2h, *t_dgram, *t_local;
  1795. int err = mutex_lock_interruptible(&vsock_register_mutex);
  1796. if (err)
  1797. return err;
  1798. t_h2g = transport_h2g;
  1799. t_g2h = transport_g2h;
  1800. t_dgram = transport_dgram;
  1801. t_local = transport_local;
  1802. if (features & VSOCK_TRANSPORT_F_H2G) {
  1803. if (t_h2g) {
  1804. err = -EBUSY;
  1805. goto err_busy;
  1806. }
  1807. t_h2g = t;
  1808. }
  1809. if (features & VSOCK_TRANSPORT_F_G2H) {
  1810. if (t_g2h) {
  1811. err = -EBUSY;
  1812. goto err_busy;
  1813. }
  1814. t_g2h = t;
  1815. }
  1816. if (features & VSOCK_TRANSPORT_F_DGRAM) {
  1817. if (t_dgram) {
  1818. err = -EBUSY;
  1819. goto err_busy;
  1820. }
  1821. t_dgram = t;
  1822. }
  1823. if (features & VSOCK_TRANSPORT_F_LOCAL) {
  1824. if (t_local) {
  1825. err = -EBUSY;
  1826. goto err_busy;
  1827. }
  1828. t_local = t;
  1829. }
  1830. transport_h2g = t_h2g;
  1831. transport_g2h = t_g2h;
  1832. transport_dgram = t_dgram;
  1833. transport_local = t_local;
  1834. err_busy:
  1835. mutex_unlock(&vsock_register_mutex);
  1836. return err;
  1837. }
  1838. EXPORT_SYMBOL_GPL(vsock_core_register);
  1839. void vsock_core_unregister(const struct vsock_transport *t)
  1840. {
  1841. mutex_lock(&vsock_register_mutex);
  1842. if (transport_h2g == t)
  1843. transport_h2g = NULL;
  1844. if (transport_g2h == t)
  1845. transport_g2h = NULL;
  1846. if (transport_dgram == t)
  1847. transport_dgram = NULL;
  1848. if (transport_local == t)
  1849. transport_local = NULL;
  1850. mutex_unlock(&vsock_register_mutex);
  1851. }
  1852. EXPORT_SYMBOL_GPL(vsock_core_unregister);
  1853. module_init(vsock_init);
  1854. module_exit(vsock_exit);
  1855. MODULE_AUTHOR("VMware, Inc.");
  1856. MODULE_DESCRIPTION("VMware Virtual Socket Family");
  1857. MODULE_VERSION("1.0.2.0-k");
  1858. MODULE_LICENSE("GPL v2");