aboutsummaryrefslogblamecommitdiffstats
path: root/net/socket.c
blob: b343db1489bdb287d4e7c0d26aa72ef18de07f7f (plain) (tree)
1
2
3
4
5
6
7
8
                                            





                                                                        
                         




































                                                                                      
                                                                            

                                                            
                                                                            
                 



                                                               
                     



                            
                              
                           


                            
                        
                            

                          
                               




                          
                        
                            



                           
                        
                           
                          
                        
                       
                        
                         
                                        
 
                          


                       
                     
                           



                            


                             
                          
                          
                          
                           
 
                              

                                                
      
 

                                                                          
                                                                    

                                                              

                                                              
                                                                               

                                                
                                                                   
      
                                                          

                                                                              
                                                                
                                                                         
                                                    
 




                                                                                                            
                                                       

                                    

                                        

                                     


                                          
                                  

                                    

                                                
                                         





                                                               
                                        
                                                                               
 
  


                                                              

   










                                                                               
                                                                                     
 
                                                               
                               
                      
                         
                                               
                               
                                           

















                                                                             
 
                                                                      
                                                                  



                
                                                       

                                  
                           

                           
                    
                               
                  

                                                
                                                    


                                       

                                                                      



                                      
                                                            



                                                             
 
                                                             

                            


                                                 
 




                                          



                              
                                                
 


                                                                 
                                               

 
                                
 
                                                             
 
                                        
 
 
                                 

                                                                 



                                                                          
                                                                               
                                                         
                                          

 
                                                   
                                           
                                          
                                        

  





                                                                          
                                                        

 
                                                                  
                                 

  




















                                                                                 













                                                                                

                                                              
                                       


            
                                                        
 






                                                                      





                                               
                                                  


                                        


                                                                           

                                                                        











                                                                           











                                                                 
                                                                               
 
                          
 

                                                                        
 


                                                                   
                           
                                   
                            


                          
                                  
                                            
                    
 
                               
 
                                                      

                             
                                            

                                   
                          
         
 
                                                     
                               
                                        

                          
 

                                

 







                                                               
                                                          
 


                                                                        

                         
 
                              
 
   
                                                                



                                                                      
                                                                         








                                                                            

                            

                        


                              
 

                                         
                           

                    
                             
 

                                                                             
                                

                            
                      



                                                   
                                    

                         
         
                    

 





                                                                    
                                                                         




















                                                              
                                                                     


                                                
                                                   

                                                                



                                                         




                   
                                                         
                                      
                                  

  
   
                                      
  

                                                                             
                                                                    

   
                               
 

                            
 
                                                   




                               
                                      
                                             

                                       
                                        
 

                    
                          
 
   
                                     



                                                                          
                            
   
 
                                                                    



                                                        

                                          
                                         
                                

                                            



                                  
                                 
                                                                 
 



                                       
                          
 




                                      
                            
 
                                                       
 

                             
                                                   

                                         
                                                   

                                         
                                                

                                            
                          
 
                                   
 

                                                                            

                                                                             
                                                                             
 


                                                                       

                                    

 







                                                           
                                                         
 
                                                    
                                                              
 
                                                    
 
                            
 











                                                                     


                                                             
                                                             
                                       
 
                              
 












                                                                           





                                                                    
                                                             
 
                                                             




                                                                      









                                                                          




                                                                             
                                                                                






                                                                           




















                                                                   





                                                                     
                                                                 
                                                        

                                             
                                        




                                                              
                                                       
                                     

                                 


                                                       












                                                                           
                        






                                                                             
                                                                




                                                                             


                 
                                     
                                                           
                                                              
                          
                          
                                                               
                                                     
                                                                          
                          



                                                                      
                     



                                                               
 
                                                        
                                                


                                                                             
 

                                         















                                                                      

                                                                       
 
                                                                               
                                                      
                                                                     

 
                                                                  




                                          
                                            
 
                                                                            


                                                                             
                                                                             
                                               
 


                                                                              

 








                                                                               
                                                                    
 
                                                                                
 
                                                           
 
                            
 
   






                                                                       
  


                                                                                   
  
                                                                              
   
 

                                                                        



                                      
                                                            
                          
                                                


                      
                              
 

                                                                             
 


                            

                                  


                                                                        
 
                                                                
 
 
                                                                
                                                                         



                                                   
                                              
                                                                              
 


                                                                    
                                                                      
 

                                                 

                                               
                    
 



                                             
                               
 
                                                                  

                         
                                                      

                           

 
                                                                         
 

                                                 

                                               
                    
 
                              
                               
 


                                             


                                         
                                       

                             

 




                                              
                                    
                                                                               
 
                                                                         
 
                                    
                             
                                      


                           
                                      
                                                               
 
                                                              
 
                                      
                               
                                        


                              
                                      
                                                            
 
                                                              
 
                                      
                               
                                        


                              
                                                               
                                                              









                                                       

                                
 








                                                                            


                                  
                                                                     


                                                               
                                                                           
                                               
         


                   




                                                                             






                                                                    
                                                  


                                                              
                              
 


                                                                          
                        

                                               
                        
 
                                  
                      
                           








                                                                              
              
                       
                                                      
                                                        
              
      
                              




                                                              
                                                           


                               
                                                            
                                                           








                                                         
                                                    
                                          
                                                                    
                                                      






                                                        
                                                      
                                            
                                                                 
                                                        
                              





                                                       

                                                      
                                                                 
                                                        
                              






                                                                     

                                      




                                                              

                                                                              
                              








                                                                         
                              
                        
                                                                 
                              
                 


                   












                                                                           



                                                                             
 









                                                                
                          



                                                                           


                    



                           
 
                                

                                   
                                                              
 
                                                 
                                                                
 

                             
 









                                                                      

 
                                                                   
 
                                                 



                                                
                                                             
 
                                               










                                                                         
                               



                                                         

                                                 
                                         
 
                       
                               

                      
                                                      
 
                             

                                                 
                                               
 
                         


                 
                                                     
 
                                                            
 
                                    
                          
 
                      
                             
                                                                

                               
                             
                                                                          

                                  
                          
          
                                                           
                      
                           
                                                            
         
 

                 
                               
 














                                                                          
                                                                      
                                                       


                            
                                          

          
                                          











                                                                   

                                                                        





                                                                   
 






                                                                                    
                                                                  





                                                                   
                     


                                                                            


                                                                               
                                                             
                                                    

      




                                                   




                                                                             
                                       

                                 


                                               
                                                    
                    
                                    
 



                                                                         


                                              



                                                                         
                              

                                                                              
                                      
                    
 



                            
               


                              
                           




                              
 
                             
 










                                                                        

                                                                        
                                                                                       
 
                           
 











                                                                        
                                                                                              
 
                                                                  
 
                                
 
                                                    


                            

                  





                                                                    
                                       
                                                    

                               
 


                                                                   

                                                            
                              
 
                                                                   

 




                                                              



                                           
                                                                              


                                     
                                         


                                       
                                                    

                               
 


                                                                   
          





















                                                          




                                                                       
                              


                                                          


                                    
         
 






                                                       




                                                   

         
                                                       
                               
                                        

                                    

         
                                                       

                                        

                               

         
                                
 

                                  
                 
 
    
                           
                           


                   





                                                                  







                                                                   
                                                                    

                            
                                        
                             
 
                                                           
                   
                                                                      
                           
                                                        
                                                                               
                                                            

                                                           
                                                                         
                                                                         
                 
                                                    
         


                   




                                                                               





                                                                         
                                     

                            
                             
                      


                                                           
                                                                      
                                                      
                                            

                                                            

                                                               
 
                                                    



                   




                                              


                                                              

                                      
                             
                            
                                        
 
                                                    




                                                                   
                                          



                         

                               
                         



                                   





                                                                            
                                           

                                  
                                      
                         
         
                                                                                   
                              

                                       
                         
         
 

                                                    
                            
 

                                                                                
                    
                            

                             


                                                                        
                                            
                                    
                 
                                                 
                                                                            
                            
                                    



                                                                            

                                   

                   
       
                      
                             






























                                                                          

 





                                                                           

                                                                          
 
                                                                   

 











                                                                            
                                                                           
                                                   

                            
                
 
                                          

                         
 
             
                                                                               
                
                         
 
                                                                           
                                                                   



                   






                                                                         




                                                                               






                                     





                                                                      




                                                                            

                                                                

                            
                                        
                             
 
                                                           






                                                

                                                                       
                             

                                                                         

        
                                            



                   





                                                                          




                                                                             

                                                                

                            
                                        
                             
 

                                                           

                                                        
                                                            


                                   



                                                                               
                                                               
                                                    



                   





                                                                          




                                                                            

                                                                           

                            
                                        


                          
                        
 


                                                                         

                                                           
                         
 
                            


                               
                   
                                                                    

                                     
                                                           
                                           



                                             
                                       
 
        
                                            
    


                   






                                                                    
  
                                      

   
                                                                
                                    
 
                                                           


  
                                                                                


                                                                         

                                                                              



                            
                                        
                      

                        


                                                                         
                                                           
                  
                         
 

                               



                                                                          
                            
                          

                                             
                                              
 
                                       
                                                  
                                                                          

                                   
         

                                            
    


                   






                                                                     
  
                                         

   

                                                                 
 
                                                                 






                                                                             

                                                            
 

                                      
                             



                               



                                                                       

                                     
 















                                                                               
                                        


                                                                         
                    


                                                                               




                                             

                                                    



                   





                                                                    




                                                                             

                                                                    
 
                             
                            
                       
 

                                                           


                                                                       
 

                                                                      
                                        


                                                                         
                    


                                                                               



                                                                              

                                                    



                   





                                                                    



                          
                                   
 
                             

                            

                                                           
                                                          


                                                             



                   




                                            
                                                                      





                                                                                                  




                                     



                                                                    
 
                               

                    
                                                      
                               
 
                                                            




                                                  

                                      


                                  
                                                                
                                                                    

                      
                                          
 
                                                
                                 

                                                                    








                                                                  
                                        

                                 

                              
                                                    
                                                        
                                                               
                                 

 


                                                                                 
 
                                                      
                                                                   
                                        
                                     
                    
                    
 

                       
                                              
                         
                                                             
                                          
                                                   
                     
                                                                            
                                                                  
                        
                                 

                                                  
                             

                                                                 
                                            
                                                                              
                                            
                                         


                              
                                                                                      


                                                                                      
                                           
                                                                               
                                            
                                         
                                               
         
                                   

                                             
                                                   





                                                                              


                                                             
                                              
                                                        

                                 
                                          





                                                                               


                                                                      
         

            
                           
                                                         



                   


                                                                        

































                                                                              
                   





                             
                                                                

                                           
                                                             

                                                    
 
                                                          
 
 

                                                                              


                              

                            


                                                            
                                                           


                         
                                                                  
 
                                            
    


                   
                                                                                        
 
                                                   

 




                                                                          
                                                               





                                                   
                                         
                                    
 


                                                            

                                  






                                                           
                                         

                                                            
                
                           

                                  


                                          
                                              
                                                                                             
                                                                                      




                                                                      
                                                  
                                                                                
                                                                                      








                                                             

                                            
                               

         

                                            

                                                                          

                                 





                                                                 
                                                           

 



                                                                        
 
                    
 

                                                        
 




                                                                     
                    
                           
 
















                                                                            

                                                                        
 


                                                                          

                                             
                                                                                
                    
                         


                            
                                              
                                                                    
                                                   
                            
                                 
         
                                                                 
                                            
                
                         
                                    
                                                                                

                                                              
                                                                                

                                                       
                         
                  














                                                                               
 
                                                                       
                   






                             


                                                                          
 
                                                             

                                                    
 
                                                                 

 

                                                                              


                              

                            


                                                            
                                                           


                         
                                                            
 
                                            



                   
                                                                   

                                    
                                                   

 



                               


                                                                



                                        
                                                   
                              

                                    











                                                               





                                              
         

                     
                                                            




                                                                       
                                              
                                                                                             

                                                                               




                                                                      
                                                  
                                                                                

                                                                               





                                                             

                              

                            



                                                                           
                              
                                                   
                                                                       












                                                                          
                               

         
                     





                                
 




                                                                  
                  



                                                                
                   
                                        
         

                                            
 
                         

 



                                                            

                      
                                      
 

                                                             
 
                                                                     

                               



                                                                     
 






                                                                     




                                    

                                                                 
                                                           
 














                                                                        
 
      
 
                                 

                                            
                                        


                                                 
                           

  


         
                            


                                                             
                             

   
                                                                    
 
                                      
                             
                
                         
 
                                            
                               
                                                          
 



                               
                                                
                                         
                               
 


                                                                       
 




                        
                                                 

                      
                                                                         

                         
                                                                            

                        
                                           

                        

                                                                     


                             

                                                                       


                             

                                                                       

                            
                                                                         

                      

                                                                     

                        

                                                                         

                      

                                                                       

                          


                                                                       

                          
                                             

                            

                                                                         


                            

                                                                       

                         

                                                                        
                      
                          

                                                                           
                      
                         

                                                                        
                      
                          
                                             







                                                                                     
                      
                         

                                                                     
                      


                              



                   
                                                                
 



                                                     

                                                                   
                                                                  
                                           
   
                                                     



                                    
                                                                            

                                

                                    

                                                                         

                              
                                                                   

                        

                                      
                                                                     

                   
                             
 



                                                   

                                                                   





                                                                            
   
                                
 
                                               
 
                                    
                                                     



                                      
                                                                  
 
                               
 

                                   
                                                                           

 
                                 
 
                





                                                             
 
          
                                            

                   

          
                                                


                          



                                                 
                                             



                                        

                                                                            


                       


                               
      
 
                              
 






                                             

 

                                                    


                                          

                                                 
 
                                                    
 
                    
                                                                                  
 
                                   
                          

                
                                                                         

                               

                                               
 


                                                                 


                           
                                    
                                                                       




                               
                                                                            
 

                                                         


                                                  

                                          
                 
                
 

                                                       
 


                                                 

                               
















                                                                
                                 


                                   

                                                         
                                                          


                      
                                                                      

                               
                                                                        
 
                         
                                                                   

                                                                         



                                                                              






                                                                                

                                                                        

                                                               
                                                                           







                                                                        


                                       
                                                      




                                                     

                                                                              

                                                               

                                                                                 
























                                                                           

 

                                                                                 
                             


                           
 
                                                                      




                                                             

                                                                
 




                                                                            
         
                   

 

                                                                                 
                                                                       
 
                           

                   
                                                                          
                               
                                                   
                               
                                            
 
                                                 

 






































                                                                              
                                 







                                                                        




                                                               



                                                                 





                                                                     


                               
                                              


                                                                       





                                                                             





                                      
                  
                                


                                                                          






                                                                          
                                                                          

                                                                          















                                                                          

                                                              








                                       

                                                                             
                                                                      
                                                     






                                                                         


                                 
                                                    
                                                                
                                                                     





                                                                 
                            
                                                                              

                                                                   










                                         
                          
                                                               
                       

    




                                                                      
                        
   
                                                        
 
                           
 
                                





                                         





                                                                          
 
                                                                  
                                                             




                                              
                         
                                                    

                                                

                                                    


                                                         


                                                           

                              

                                            
                                                                              

                                                                    

                                    
                           
                           
                                                             










                         
                       

                              














                                                  


                                
                         











                            
                         



                         



                                  

                                                                


                      
                      
                         
                        
                                                          

         

                            
 
                                                                  
                                                


                                                 




                           



                                                              



                                                              


                                                                    



                   








                                                                



                                                                        
                           
 







                                                                     



                                                   
                             
 










                                                          









                                                                           
                                                             

                                       
                                



                                    
                                             



                   
                             
 












                                                                             
                                                                           
                             


                                                              
                              
 








                                                                                     
                                                                  
 
                                                 
 
                                  
 








                                                                                      
                                                                  
 
                                                 
 
                                  
 











                                                              



                                                                  

                             

                


                                                 

                                
                                                                              
            

                                                                          


                      
                                 
 










                                                              
                                                                  
                                                          

                                      
                             

                

                                                 

                                
                                                                             
            
                                                                          



                                                    
                                 
 










                                                                      







                                                                            
                               
 











                                                                                    












                                                                          







                                                                                   



                                                                         
                                    
 







                                                                             
   
 




                                            







                                            




                                                               
                                                                        








                                                                  
                                                                                  








                                                                           
// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * NET		An implementation of the SOCKET network access protocol.
 *
 * Version:	@(#)socket.c	1.1.93	18/02/95
 *
 * Authors:	Orest Zborowski, <obz@Kodak.COM>
 *		Ross Biro
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *
 * Fixes:
 *		Anonymous	:	NOTSOCK/BADF cleanup. Error fix in
 *					shutdown()
 *		Alan Cox	:	verify_area() fixes
 *		Alan Cox	:	Removed DDI
 *		Jonathan Kamens	:	SOCK_DGRAM reconnect bug
 *		Alan Cox	:	Moved a load of checks to the very
 *					top level.
 *		Alan Cox	:	Move address structures to/from user
 *					mode above the protocol layers.
 *		Rob Janssen	:	Allow 0 length sends.
 *		Alan Cox	:	Asynchronous I/O support (cribbed from the
 *					tty drivers).
 *		Niibe Yutaka	:	Asynchronous I/O for writes (4.4BSD style)
 *		Jeff Uphoff	:	Made max number of sockets command-line
 *					configurable.
 *		Matti Aarnio	:	Made the number of sockets dynamic,
 *					to be allocated when needed, and mr.
 *					Uphoff's max is used as max to be
 *					allowed to allocate.
 *		Linus		:	Argh. removed all the socket allocation
 *					altogether: it's in the inode now.
 *		Alan Cox	:	Made sock_alloc()/sock_release() public
 *					for NetROM and future kernel nfsd type
 *					stuff.
 *		Alan Cox	:	sendmsg/recvmsg basics.
 *		Tom Dyas	:	Export net symbols.
 *		Marcin Dalecki	:	Fixed problems with CONFIG_NET="n".
 *		Alan Cox	:	Added thread locking to sys_* calls
 *					for sockets. May have errors at the
 *					moment.
 *		Kevin Buhr	:	Fixed the dumb errors in the above.
 *		Andi Kleen	:	Some small cleanups, optimizations,
 *					and fixed a copy_from_user() bug.
 *		Tigran Aivazian	:	sys_send(args) calls sys_sendto(args, NULL, 0)
 *		Tigran Aivazian	:	Made listen(2) backlog sanity checks
 *					protocol-independent
 *
 *	This module is effectively the top level interface to the BSD socket
 *	paradigm.
 *
 *	Based upon Swansea University Computer Society NET3.039
 */

#include <linux/mm.h>
#include <linux/socket.h>
#include <linux/file.h>
#include <linux/net.h>
#include <linux/interrupt.h>
#include <linux/thread_info.h>
#include <linux/rcupdate.h>
#include <linux/netdevice.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/mutex.h>
#include <linux/if_bridge.h>
#include <linux/if_frad.h>
#include <linux/if_vlan.h>
#include <linux/ptp_classify.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/cache.h>
#include <linux/module.h>
#include <linux/highmem.h>
#include <linux/mount.h>
#include <linux/pseudo_fs.h>
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/compat.h>
#include <linux/kmod.h>
#include <linux/audit.h>
#include <linux/wireless.h>
#include <linux/nsproxy.h>
#include <linux/magic.h>
#include <linux/slab.h>
#include <linux/xattr.h>
#include <linux/nospec.h>
#include <linux/indirect_call_wrapper.h>

#include <linux/uaccess.h>
#include <asm/unistd.h>

#include <net/compat.h>
#include <net/wext.h>
#include <net/cls_cgroup.h>

#include <net/sock.h>
#include <linux/netfilter.h>

#include <linux/if_tun.h>
#include <linux/ipv6_route.h>
#include <linux/route.h>
#include <linux/termios.h>
#include <linux/sockios.h>
#include <net/busy_poll.h>
#include <linux/errqueue.h>

#ifdef CONFIG_NET_RX_BUSY_POLL
unsigned int sysctl_net_busy_read __read_mostly;
unsigned int sysctl_net_busy_poll __read_mostly;
#endif

static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to);
static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from);
static int sock_mmap(struct file *file, struct vm_area_struct *vma);

static int sock_close(struct inode *inode, struct file *file);
static __poll_t sock_poll(struct file *file,
			      struct poll_table_struct *wait);
static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
#ifdef CONFIG_COMPAT
static long compat_sock_ioctl(struct file *file,
			      unsigned int cmd, unsigned long arg);
#endif
static int sock_fasync(int fd, struct file *filp, int on);
static ssize_t sock_sendpage(struct file *file, struct page *page,
			     int offset, size_t size, loff_t *ppos, int more);
static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
				struct pipe_inode_info *pipe, size_t len,
				unsigned int flags);

/*
 *	Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
 *	in the operation structures but are done directly via the socketcall() multiplexor.
 */

static const struct file_operations socket_file_ops = {
	.owner =	THIS_MODULE,
	.llseek =	no_llseek,
	.read_iter =	sock_read_iter,
	.write_iter =	sock_write_iter,
	.poll =		sock_poll,
	.unlocked_ioctl = sock_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl = compat_sock_ioctl,
#endif
	.mmap =		sock_mmap,
	.release =	sock_close,
	.fasync =	sock_fasync,
	.sendpage =	sock_sendpage,
	.splice_write = generic_splice_sendpage,
	.splice_read =	sock_splice_read,
};

/*
 *	The protocol list. Each protocol is registered in here.
 */

static DEFINE_SPINLOCK(net_family_lock);
static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;

/*
 * Support routines.
 * Move socket addresses back and forth across the kernel/user
 * divide and look after the messy bits.
 */

/**
 *	move_addr_to_kernel	-	copy a socket address into kernel space
 *	@uaddr: Address in user space
 *	@kaddr: Address in kernel space
 *	@ulen: Length in user space
 *
 *	The address is copied into kernel space. If the provided address is
 *	too long an error code of -EINVAL is returned. If the copy gives
 *	invalid addresses -EFAULT is returned. On a success 0 is returned.
 */

int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)
{
	if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
		return -EINVAL;
	if (ulen == 0)
		return 0;
	if (copy_from_user(kaddr, uaddr, ulen))
		return -EFAULT;
	return audit_sockaddr(ulen, kaddr);
}

/**
 *	move_addr_to_user	-	copy an address to user space
 *	@kaddr: kernel space address
 *	@klen: length of address in kernel
 *	@uaddr: user space address
 *	@ulen: pointer to user length field
 *
 *	The value pointed to by ulen on entry is the buffer length available.
 *	This is overwritten with the buffer space used. -EINVAL is returned
 *	if an overlong buffer is specified or a negative buffer size. -EFAULT
 *	is returned if either the buffer or the length field are not
 *	accessible.
 *	After copying the data up to the limit the user specifies, the true
 *	length of the data is written over the length limit the user
 *	specified. Zero is returned for a success.
 */

static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
			     void __user *uaddr, int __user *ulen)
{
	int err;
	int len;

	BUG_ON(klen > sizeof(struct sockaddr_storage));
	err = get_user(len, ulen);
	if (err)
		return err;
	if (len > klen)
		len = klen;
	if (len < 0)
		return -EINVAL;
	if (len) {
		if (audit_sockaddr(klen, kaddr))
			return -ENOMEM;
		if (copy_to_user(uaddr, kaddr, len))
			return -EFAULT;
	}
	/*
	 *      "fromlen shall refer to the value before truncation.."
	 *                      1003.1g
	 */
	return __put_user(klen, ulen);
}

static struct kmem_cache *sock_inode_cachep __ro_after_init;

static struct inode *sock_alloc_inode(struct super_block *sb)
{
	struct socket_alloc *ei;

	ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
	if (!ei)
		return NULL;
	init_waitqueue_head(&ei->socket.wq.wait);
	ei->socket.wq.fasync_list = NULL;
	ei->socket.wq.flags = 0;

	ei->socket.state = SS_UNCONNECTED;
	ei->socket.flags = 0;
	ei->socket.ops = NULL;
	ei->socket.sk = NULL;
	ei->socket.file = NULL;

	return &ei->vfs_inode;
}

static void sock_free_inode(struct inode *inode)
{
	struct socket_alloc *ei;

	ei = container_of(inode, struct socket_alloc, vfs_inode);
	kmem_cache_free(sock_inode_cachep, ei);
}

static void init_once(void *foo)
{
	struct socket_alloc *ei = (struct socket_alloc *)foo;

	inode_init_once(&ei->vfs_inode);
}

static void init_inodecache(void)
{
	sock_inode_cachep = kmem_cache_create("sock_inode_cache",
					      sizeof(struct socket_alloc),
					      0,
					      (SLAB_HWCACHE_ALIGN |
					       SLAB_RECLAIM_ACCOUNT |
					       SLAB_MEM_SPREAD | SLAB_ACCOUNT),
					      init_once);
	BUG_ON(sock_inode_cachep == NULL);
}

static const struct super_operations sockfs_ops = {
	.alloc_inode	= sock_alloc_inode,
	.free_inode	= sock_free_inode,
	.statfs		= simple_statfs,
};

/*
 * sockfs_dname() is called from d_path().
 */
static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
{
	return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
				d_inode(dentry)->i_ino);
}

static const struct dentry_operations sockfs_dentry_operations = {
	.d_dname  = sockfs_dname,
};

static int sockfs_xattr_get(const struct xattr_handler *handler,
			    struct dentry *dentry, struct inode *inode,
			    const char *suffix, void *value, size_t size)
{
	if (value) {
		if (dentry->d_name.len + 1 > size)
			return -ERANGE;
		memcpy(value, dentry->d_name.name, dentry->d_name.len + 1);
	}
	return dentry->d_name.len + 1;
}

#define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
#define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
#define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)

static const struct xattr_handler sockfs_xattr_handler = {
	.name = XATTR_NAME_SOCKPROTONAME,
	.get = sockfs_xattr_get,
};

static int sockfs_security_xattr_set(const struct xattr_handler *handler,
				     struct dentry *dentry, struct inode *inode,
				     const char *suffix, const void *value,
				     size_t size, int flags)
{
	/* Handled by LSM. */
	return -EAGAIN;
}

static const struct xattr_handler sockfs_security_xattr_handler = {
	.prefix = XATTR_SECURITY_PREFIX,
	.set = sockfs_security_xattr_set,
};

static const struct xattr_handler *sockfs_xattr_handlers[] = {
	&sockfs_xattr_handler,
	&sockfs_security_xattr_handler,
	NULL
};

static int sockfs_init_fs_context(struct fs_context *fc)
{
	struct pseudo_fs_context *ctx = init_pseudo(fc, SOCKFS_MAGIC);
	if (!ctx)
		return -ENOMEM;
	ctx->ops = &sockfs_ops;
	ctx->dops = &sockfs_dentry_operations;
	ctx->xattr = sockfs_xattr_handlers;
	return 0;
}

static struct vfsmount *sock_mnt __read_mostly;

static struct file_system_type sock_fs_type = {
	.name =		"sockfs",
	.init_fs_context = sockfs_init_fs_context,
	.kill_sb =	kill_anon_super,
};

/*
 *	Obtains the first available file descriptor and sets it up for use.
 *
 *	These functions create file structures and maps them to fd space
 *	of the current process. On success it returns file descriptor
 *	and file struct implicitly stored in sock->file.
 *	Note that another thread may close file descriptor before we return
 *	from this function. We use the fact that now we do not refer
 *	to socket after mapping. If one day we will need it, this
 *	function will increment ref. count on file by 1.
 *
 *	In any case returned fd MAY BE not valid!
 *	This race condition is unavoidable
 *	with shared fd spaces, we cannot solve it inside kernel,
 *	but we take care of internal coherence yet.
 */

/**
 *	sock_alloc_file - Bind a &socket to a &file
 *	@sock: socket
 *	@flags: file status flags
 *	@dname: protocol name
 *
 *	Returns the &file bound with @sock, implicitly storing it
 *	in sock->file. If dname is %NULL, sets to "".
 *	On failure the return is a ERR pointer (see linux/err.h).
 *	This function uses GFP_KERNEL internally.
 */

struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
{
	struct file *file;

	if (!dname)
		dname = sock->sk ? sock->sk->sk_prot_creator->name : "";

	file = alloc_file_pseudo(SOCK_INODE(sock), sock_mnt, dname,
				O_RDWR | (flags & O_NONBLOCK),
				&socket_file_ops);
	if (IS_ERR(file)) {
		sock_release(sock);
		return file;
	}

	sock->file = file;
	file->private_data = sock;
	stream_open(SOCK_INODE(sock), file);
	return file;
}
EXPORT_SYMBOL(sock_alloc_file);

static int sock_map_fd(struct socket *sock, int flags)
{
	struct file *newfile;
	int fd = get_unused_fd_flags(flags);
	if (unlikely(fd < 0)) {
		sock_release(sock);
		return fd;
	}

	newfile = sock_alloc_file(sock, flags, NULL);
	if (!IS_ERR(newfile)) {
		fd_install(fd, newfile);
		return fd;
	}

	put_unused_fd(fd);
	return PTR_ERR(newfile);
}

/**
 *	sock_from_file - Return the &socket bounded to @file.
 *	@file: file
 *	@err: pointer to an error code return
 *
 *	On failure returns %NULL and assigns -ENOTSOCK to @err.
 */

struct socket *sock_from_file(struct file *file, int *err)
{
	if (file->f_op == &socket_file_ops)
		return file->private_data;	/* set in sock_map_fd */

	*err = -ENOTSOCK;
	return NULL;
}
EXPORT_SYMBOL(sock_from_file);

/**
 *	sockfd_lookup - Go from a file number to its socket slot
 *	@fd: file handle
 *	@err: pointer to an error code return
 *
 *	The file handle passed in is locked and the socket it is bound
 *	to is returned. If an error occurs the err pointer is overwritten
 *	with a negative errno code and NULL is returned. The function checks
 *	for both invalid handles and passing a handle which is not a socket.
 *
 *	On a success the socket object pointer is returned.
 */

struct socket *sockfd_lookup(int fd, int *err)
{
	struct file *file;
	struct socket *sock;

	file = fget(fd);
	if (!file) {
		*err = -EBADF;
		return NULL;
	}

	sock = sock_from_file(file, err);
	if (!sock)
		fput(file);
	return sock;
}
EXPORT_SYMBOL(sockfd_lookup);

static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
{
	struct fd f = fdget(fd);
	struct socket *sock;

	*err = -EBADF;
	if (f.file) {
		sock = sock_from_file(f.file, err);
		if (likely(sock)) {
			*fput_needed = f.flags;
			return sock;
		}
		fdput(f);
	}
	return NULL;
}

static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
				size_t size)
{
	ssize_t len;
	ssize_t used = 0;

	len = security_inode_listsecurity(d_inode(dentry), buffer, size);
	if (len < 0)
		return len;
	used += len;
	if (buffer) {
		if (size < used)
			return -ERANGE;
		buffer += len;
	}

	len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
	used += len;
	if (buffer) {
		if (size < used)
			return -ERANGE;
		memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
		buffer += len;
	}

	return used;
}

static int sockfs_setattr(struct dentry *dentry, struct iattr *iattr)
{
	int err = simple_setattr(dentry, iattr);

	if (!err && (iattr->ia_valid & ATTR_UID)) {
		struct socket *sock = SOCKET_I(d_inode(dentry));

		if (sock->sk)
			sock->sk->sk_uid = iattr->ia_uid;
		else
			err = -ENOENT;
	}

	return err;
}

static const struct inode_operations sockfs_inode_ops = {
	.listxattr = sockfs_listxattr,
	.setattr = sockfs_setattr,
};

/**
 *	sock_alloc - allocate a socket
 *
 *	Allocate a new inode and socket object. The two are bound together
 *	and initialised. The socket is then returned. If we are out of inodes
 *	NULL is returned. This functions uses GFP_KERNEL internally.
 */

struct socket *sock_alloc(void)
{
	struct inode *inode;
	struct socket *sock;

	inode = new_inode_pseudo(sock_mnt->mnt_sb);
	if (!inode)
		return NULL;

	sock = SOCKET_I(inode);

	inode->i_ino = get_next_ino();
	inode->i_mode = S_IFSOCK | S_IRWXUGO;
	inode->i_uid = current_fsuid();
	inode->i_gid = current_fsgid();
	inode->i_op = &sockfs_inode_ops;

	return sock;
}
EXPORT_SYMBOL(sock_alloc);

/**
 *	sock_release - close a socket
 *	@sock: socket to close
 *
 *	The socket is released from the protocol stack if it has a release
 *	callback, and the inode is then released if the socket is bound to
 *	an inode not a file.
 */

static void __sock_release(struct socket *sock, struct inode *inode)
{
	if (sock->ops) {
		struct module *owner = sock->ops->owner;

		if (inode)
			inode_lock(inode);
		sock->ops->release(sock);
		sock->sk = NULL;
		if (inode)
			inode_unlock(inode);
		sock->ops = NULL;
		module_put(owner);
	}

	if (sock->wq.fasync_list)
		pr_err("%s: fasync list not empty!\n", __func__);

	if (!sock->file) {
		iput(SOCK_INODE(sock));
		return;
	}
	sock->file = NULL;
}

void sock_release(struct socket *sock)
{
	__sock_release(sock, NULL);
}
EXPORT_SYMBOL(sock_release);

void __sock_tx_timestamp(__u16 tsflags, __u8 *tx_flags)
{
	u8 flags = *tx_flags;

	if (tsflags & SOF_TIMESTAMPING_TX_HARDWARE)
		flags |= SKBTX_HW_TSTAMP;

	if (tsflags & SOF_TIMESTAMPING_TX_SOFTWARE)
		flags |= SKBTX_SW_TSTAMP;

	if (tsflags & SOF_TIMESTAMPING_TX_SCHED)
		flags |= SKBTX_SCHED_TSTAMP;

	*tx_flags = flags;
}
EXPORT_SYMBOL(__sock_tx_timestamp);

INDIRECT_CALLABLE_DECLARE(int inet_sendmsg(struct socket *, struct msghdr *,
					   size_t));
INDIRECT_CALLABLE_DECLARE(int inet6_sendmsg(struct socket *, struct msghdr *,
					    size_t));
static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
{
	int ret = INDIRECT_CALL_INET(sock->ops->sendmsg, inet6_sendmsg,
				     inet_sendmsg, sock, msg,
				     msg_data_left(msg));
	BUG_ON(ret == -EIOCBQUEUED);
	return ret;
}

/**
 *	sock_sendmsg - send a message through @sock
 *	@sock: socket
 *	@msg: message to send
 *
 *	Sends @msg through @sock, passing through LSM.
 *	Returns the number of bytes sent, or an error code.
 */
int sock_sendmsg(struct socket *sock, struct msghdr *msg)
{
	int err = security_socket_sendmsg(sock, msg,
					  msg_data_left(msg));

	return err ?: sock_sendmsg_nosec(sock, msg);
}
EXPORT_SYMBOL(sock_sendmsg);

/**
 *	kernel_sendmsg - send a message through @sock (kernel-space)
 *	@sock: socket
 *	@msg: message header
 *	@vec: kernel vec
 *	@num: vec array length
 *	@size: total message data size
 *
 *	Builds the message data with @vec and sends it through @sock.
 *	Returns the number of bytes sent, or an error code.
 */

int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
		   struct kvec *vec, size_t num, size_t size)
{
	iov_iter_kvec(&msg->msg_iter, WRITE, vec, num, size);
	return sock_sendmsg(sock, msg);
}
EXPORT_SYMBOL(kernel_sendmsg);

/**
 *	kernel_sendmsg_locked - send a message through @sock (kernel-space)
 *	@sk: sock
 *	@msg: message header
 *	@vec: output s/g array
 *	@num: output s/g array length
 *	@size: total message data size
 *
 *	Builds the message data with @vec and sends it through @sock.
 *	Returns the number of bytes sent, or an error code.
 *	Caller must hold @sk.
 */

int kernel_sendmsg_locked(struct sock *sk, struct msghdr *msg,
			  struct kvec *vec, size_t num, size_t size)
{
	struct socket *sock = sk->sk_socket;

	if (!sock->ops->sendmsg_locked)
		return sock_no_sendmsg_locked(sk, msg, size);

	iov_iter_kvec(&msg->msg_iter, WRITE, vec, num, size);

	return sock->ops->sendmsg_locked(sk, msg, msg_data_left(msg));
}
EXPORT_SYMBOL(kernel_sendmsg_locked);

static bool skb_is_err_queue(const struct sk_buff *skb)
{
	/* pkt_type of skbs enqueued on the error queue are set to
	 * PACKET_OUTGOING in skb_set_err_queue(). This is only safe to do
	 * in recvmsg, since skbs received on a local socket will never
	 * have a pkt_type of PACKET_OUTGOING.
	 */
	return skb->pkt_type == PACKET_OUTGOING;
}

/* On transmit, software and hardware timestamps are returned independently.
 * As the two skb clones share the hardware timestamp, which may be updated
 * before the software timestamp is received, a hardware TX timestamp may be
 * returned only if there is no software TX timestamp. Ignore false software
 * timestamps, which may be made in the __sock_recv_timestamp() call when the
 * option SO_TIMESTAMP_OLD(NS) is enabled on the socket, even when the skb has a
 * hardware timestamp.
 */
static bool skb_is_swtx_tstamp(const struct sk_buff *skb, int false_tstamp)
{
	return skb->tstamp && !false_tstamp && skb_is_err_queue(skb);
}

static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb)
{
	struct scm_ts_pktinfo ts_pktinfo;
	struct net_device *orig_dev;

	if (!skb_mac_header_was_set(skb))
		return;

	memset(&ts_pktinfo, 0, sizeof(ts_pktinfo));

	rcu_read_lock();
	orig_dev = dev_get_by_napi_id(skb_napi_id(skb));
	if (orig_dev)
		ts_pktinfo.if_index = orig_dev->ifindex;
	rcu_read_unlock();

	ts_pktinfo.pkt_length = skb->len - skb_mac_offset(skb);
	put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_PKTINFO,
		 sizeof(ts_pktinfo), &ts_pktinfo);
}

/*
 * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
 */
void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
	struct sk_buff *skb)
{
	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
	int new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
	struct scm_timestamping_internal tss;

	int empty = 1, false_tstamp = 0;
	struct skb_shared_hwtstamps *shhwtstamps =
		skb_hwtstamps(skb);

	/* Race occurred between timestamp enabling and packet
	   receiving.  Fill in the current time for now. */
	if (need_software_tstamp && skb->tstamp == 0) {
		__net_timestamp(skb);
		false_tstamp = 1;
	}

	if (need_software_tstamp) {
		if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
			if (new_tstamp) {
				struct __kernel_sock_timeval tv;

				skb_get_new_timestamp(skb, &tv);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
					 sizeof(tv), &tv);
			} else {
				struct __kernel_old_timeval tv;

				skb_get_timestamp(skb, &tv);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
					 sizeof(tv), &tv);
			}
		} else {
			if (new_tstamp) {
				struct __kernel_timespec ts;

				skb_get_new_timestampns(skb, &ts);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
					 sizeof(ts), &ts);
			} else {
				struct __kernel_old_timespec ts;

				skb_get_timestampns(skb, &ts);
				put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
					 sizeof(ts), &ts);
			}
		}
	}

	memset(&tss, 0, sizeof(tss));
	if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
	    ktime_to_timespec64_cond(skb->tstamp, tss.ts + 0))
		empty = 0;
	if (shhwtstamps &&
	    (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
	    !skb_is_swtx_tstamp(skb, false_tstamp) &&
	    ktime_to_timespec64_cond(shhwtstamps->hwtstamp, tss.ts + 2)) {
		empty = 0;
		if ((sk->sk_tsflags & SOF_TIMESTAMPING_OPT_PKTINFO) &&
		    !skb_is_err_queue(skb))
			put_ts_pktinfo(msg, skb);
	}
	if (!empty) {
		if (sock_flag(sk, SOCK_TSTAMP_NEW))
			put_cmsg_scm_timestamping64(msg, &tss);
		else
			put_cmsg_scm_timestamping(msg, &tss);

		if (skb_is_err_queue(skb) && skb->len &&
		    SKB_EXT_ERR(skb)->opt_stats)
			put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_OPT_STATS,
				 skb->len, skb->data);
	}
}
EXPORT_SYMBOL_GPL(__sock_recv_timestamp);

void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
	struct sk_buff *skb)
{
	int ack;

	if (!sock_flag(sk, SOCK_WIFI_STATUS))
		return;
	if (!skb->wifi_acked_valid)
		return;

	ack = skb->wifi_acked;

	put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
}
EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);

static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
				   struct sk_buff *skb)
{
	if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)
		put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
			sizeof(__u32), &SOCK_SKB_CB(skb)->dropcount);
}

void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
	struct sk_buff *skb)
{
	sock_recv_timestamp(msg, sk, skb);
	sock_recv_drops(msg, sk, skb);
}
EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);

INDIRECT_CALLABLE_DECLARE(int inet_recvmsg(struct socket *, struct msghdr *,
					   size_t, int));
INDIRECT_CALLABLE_DECLARE(int inet6_recvmsg(struct socket *, struct msghdr *,
					    size_t, int));
static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,