1 /* 2 * This is the linux wireless configuration interface. 3 * 4 * Copyright 2006-2008 Johannes Berg <johannes@sipsolutions.net> 5 */ 6 7 #include <linux/if.h> 8 #include <linux/module.h> 9 #include <linux/err.h> 10 #include <linux/mutex.h> 11 #include <linux/list.h> 12 #include <linux/nl80211.h> 13 #include <linux/debugfs.h> 14 #include <linux/notifier.h> 15 #include <linux/device.h> 16 #include <net/genetlink.h> 17 #include <net/cfg80211.h> 18 #include <net/wireless.h> 19 #include "nl80211.h" 20 #include "core.h" 21 #include "sysfs.h" 22 #include "reg.h" 23 24 /* name for sysfs, %d is appended */ 25 #define PHY_NAME "phy" 26 27 MODULE_AUTHOR("Johannes Berg"); 28 MODULE_LICENSE("GPL"); 29 MODULE_DESCRIPTION("wireless configuration support"); 30 31 /* RCU might be appropriate here since we usually 32 * only read the list, and that can happen quite 33 * often because we need to do it for each command */ 34 LIST_HEAD(cfg80211_drv_list); 35 DEFINE_MUTEX(cfg80211_drv_mutex); 36 37 /* for debugfs */ 38 static struct dentry *ieee80211_debugfs_dir; 39 40 /* requires cfg80211_drv_mutex to be held! */ 41 static struct cfg80211_registered_device *cfg80211_drv_by_wiphy(int wiphy) 42 { 43 struct cfg80211_registered_device *result = NULL, *drv; 44 45 list_for_each_entry(drv, &cfg80211_drv_list, list) { 46 if (drv->idx == wiphy) { 47 result = drv; 48 break; 49 } 50 } 51 52 return result; 53 } 54 55 /* requires cfg80211_drv_mutex to be held! */ 56 static struct cfg80211_registered_device * 57 __cfg80211_drv_from_info(struct genl_info *info) 58 { 59 int ifindex; 60 struct cfg80211_registered_device *bywiphy = NULL, *byifidx = NULL; 61 struct net_device *dev; 62 int err = -EINVAL; 63 64 if (info->attrs[NL80211_ATTR_WIPHY]) { 65 bywiphy = cfg80211_drv_by_wiphy( 66 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY])); 67 err = -ENODEV; 68 } 69 70 if (info->attrs[NL80211_ATTR_IFINDEX]) { 71 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]); 72 dev = dev_get_by_index(&init_net, ifindex); 73 if (dev) { 74 if (dev->ieee80211_ptr) 75 byifidx = 76 wiphy_to_dev(dev->ieee80211_ptr->wiphy); 77 dev_put(dev); 78 } 79 err = -ENODEV; 80 } 81 82 if (bywiphy && byifidx) { 83 if (bywiphy != byifidx) 84 return ERR_PTR(-EINVAL); 85 else 86 return bywiphy; /* == byifidx */ 87 } 88 if (bywiphy) 89 return bywiphy; 90 91 if (byifidx) 92 return byifidx; 93 94 return ERR_PTR(err); 95 } 96 97 struct cfg80211_registered_device * 98 cfg80211_get_dev_from_info(struct genl_info *info) 99 { 100 struct cfg80211_registered_device *drv; 101 102 mutex_lock(&cfg80211_drv_mutex); 103 drv = __cfg80211_drv_from_info(info); 104 105 /* if it is not an error we grab the lock on 106 * it to assure it won't be going away while 107 * we operate on it */ 108 if (!IS_ERR(drv)) 109 mutex_lock(&drv->mtx); 110 111 mutex_unlock(&cfg80211_drv_mutex); 112 113 return drv; 114 } 115 116 struct cfg80211_registered_device * 117 cfg80211_get_dev_from_ifindex(int ifindex) 118 { 119 struct cfg80211_registered_device *drv = ERR_PTR(-ENODEV); 120 struct net_device *dev; 121 122 mutex_lock(&cfg80211_drv_mutex); 123 dev = dev_get_by_index(&init_net, ifindex); 124 if (!dev) 125 goto out; 126 if (dev->ieee80211_ptr) { 127 drv = wiphy_to_dev(dev->ieee80211_ptr->wiphy); 128 mutex_lock(&drv->mtx); 129 } else 130 drv = ERR_PTR(-ENODEV); 131 dev_put(dev); 132 out: 133 mutex_unlock(&cfg80211_drv_mutex); 134 return drv; 135 } 136 137 void cfg80211_put_dev(struct cfg80211_registered_device *drv) 138 { 139 BUG_ON(IS_ERR(drv)); 140 mutex_unlock(&drv->mtx); 141 } 142 143 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev, 144 char *newname) 145 { 146 struct cfg80211_registered_device *drv; 147 int idx, taken = -1, result, digits; 148 149 mutex_lock(&cfg80211_drv_mutex); 150 151 /* prohibit calling the thing phy%d when %d is not its number */ 152 sscanf(newname, PHY_NAME "%d%n", &idx, &taken); 153 if (taken == strlen(newname) && idx != rdev->idx) { 154 /* count number of places needed to print idx */ 155 digits = 1; 156 while (idx /= 10) 157 digits++; 158 /* 159 * deny the name if it is phy<idx> where <idx> is printed 160 * without leading zeroes. taken == strlen(newname) here 161 */ 162 result = -EINVAL; 163 if (taken == strlen(PHY_NAME) + digits) 164 goto out_unlock; 165 } 166 167 168 /* Ignore nop renames */ 169 result = 0; 170 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0) 171 goto out_unlock; 172 173 /* Ensure another device does not already have this name. */ 174 list_for_each_entry(drv, &cfg80211_drv_list, list) { 175 result = -EINVAL; 176 if (strcmp(newname, dev_name(&drv->wiphy.dev)) == 0) 177 goto out_unlock; 178 } 179 180 /* this will only check for collisions in sysfs 181 * which is not even always compiled in. 182 */ 183 result = device_rename(&rdev->wiphy.dev, newname); 184 if (result) 185 goto out_unlock; 186 187 if (!debugfs_rename(rdev->wiphy.debugfsdir->d_parent, 188 rdev->wiphy.debugfsdir, 189 rdev->wiphy.debugfsdir->d_parent, 190 newname)) 191 printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n", 192 newname); 193 194 result = 0; 195 out_unlock: 196 mutex_unlock(&cfg80211_drv_mutex); 197 if (result == 0) 198 nl80211_notify_dev_rename(rdev); 199 200 return result; 201 } 202 203 /* exported functions */ 204 205 struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv) 206 { 207 static int wiphy_counter; 208 209 struct cfg80211_registered_device *drv; 210 int alloc_size; 211 212 WARN_ON(!ops->add_key && ops->del_key); 213 WARN_ON(ops->add_key && !ops->del_key); 214 215 alloc_size = sizeof(*drv) + sizeof_priv; 216 217 drv = kzalloc(alloc_size, GFP_KERNEL); 218 if (!drv) 219 return NULL; 220 221 drv->ops = ops; 222 223 mutex_lock(&cfg80211_drv_mutex); 224 225 drv->idx = wiphy_counter++; 226 227 if (unlikely(drv->idx < 0)) { 228 wiphy_counter--; 229 mutex_unlock(&cfg80211_drv_mutex); 230 /* ugh, wrapped! */ 231 kfree(drv); 232 return NULL; 233 } 234 235 mutex_unlock(&cfg80211_drv_mutex); 236 237 /* give it a proper name */ 238 snprintf(drv->wiphy.dev.bus_id, BUS_ID_SIZE, 239 PHY_NAME "%d", drv->idx); 240 241 mutex_init(&drv->mtx); 242 mutex_init(&drv->devlist_mtx); 243 INIT_LIST_HEAD(&drv->netdev_list); 244 245 device_initialize(&drv->wiphy.dev); 246 drv->wiphy.dev.class = &ieee80211_class; 247 drv->wiphy.dev.platform_data = drv; 248 249 return &drv->wiphy; 250 } 251 EXPORT_SYMBOL(wiphy_new); 252 253 int wiphy_register(struct wiphy *wiphy) 254 { 255 struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy); 256 int res; 257 enum ieee80211_band band; 258 struct ieee80211_supported_band *sband; 259 bool have_band = false; 260 int i; 261 u16 ifmodes = wiphy->interface_modes; 262 263 /* sanity check ifmodes */ 264 WARN_ON(!ifmodes); 265 ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1; 266 if (WARN_ON(ifmodes != wiphy->interface_modes)) 267 wiphy->interface_modes = ifmodes; 268 269 /* sanity check supported bands/channels */ 270 for (band = 0; band < IEEE80211_NUM_BANDS; band++) { 271 sband = wiphy->bands[band]; 272 if (!sband) 273 continue; 274 275 sband->band = band; 276 277 if (!sband->n_channels || !sband->n_bitrates) { 278 WARN_ON(1); 279 return -EINVAL; 280 } 281 282 for (i = 0; i < sband->n_channels; i++) { 283 sband->channels[i].orig_flags = 284 sband->channels[i].flags; 285 sband->channels[i].orig_mag = 286 sband->channels[i].max_antenna_gain; 287 sband->channels[i].orig_mpwr = 288 sband->channels[i].max_power; 289 sband->channels[i].band = band; 290 } 291 292 have_band = true; 293 } 294 295 if (!have_band) { 296 WARN_ON(1); 297 return -EINVAL; 298 } 299 300 /* check and set up bitrates */ 301 ieee80211_set_bitrate_flags(wiphy); 302 303 /* set up regulatory info */ 304 mutex_lock(&cfg80211_reg_mutex); 305 wiphy_update_regulatory(wiphy, REGDOM_SET_BY_CORE); 306 mutex_unlock(&cfg80211_reg_mutex); 307 308 mutex_lock(&cfg80211_drv_mutex); 309 310 res = device_add(&drv->wiphy.dev); 311 if (res) 312 goto out_unlock; 313 314 list_add(&drv->list, &cfg80211_drv_list); 315 316 /* add to debugfs */ 317 drv->wiphy.debugfsdir = 318 debugfs_create_dir(wiphy_name(&drv->wiphy), 319 ieee80211_debugfs_dir); 320 321 res = 0; 322 out_unlock: 323 mutex_unlock(&cfg80211_drv_mutex); 324 return res; 325 } 326 EXPORT_SYMBOL(wiphy_register); 327 328 void wiphy_unregister(struct wiphy *wiphy) 329 { 330 struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy); 331 332 /* protect the device list */ 333 mutex_lock(&cfg80211_drv_mutex); 334 335 BUG_ON(!list_empty(&drv->netdev_list)); 336 337 /* 338 * Try to grab drv->mtx. If a command is still in progress, 339 * hopefully the driver will refuse it since it's tearing 340 * down the device already. We wait for this command to complete 341 * before unlinking the item from the list. 342 * Note: as codified by the BUG_ON above we cannot get here if 343 * a virtual interface is still associated. Hence, we can only 344 * get to lock contention here if userspace issues a command 345 * that identified the hardware by wiphy index. 346 */ 347 mutex_lock(&drv->mtx); 348 /* unlock again before freeing */ 349 mutex_unlock(&drv->mtx); 350 351 list_del(&drv->list); 352 device_del(&drv->wiphy.dev); 353 debugfs_remove(drv->wiphy.debugfsdir); 354 355 mutex_unlock(&cfg80211_drv_mutex); 356 } 357 EXPORT_SYMBOL(wiphy_unregister); 358 359 void cfg80211_dev_free(struct cfg80211_registered_device *drv) 360 { 361 mutex_destroy(&drv->mtx); 362 mutex_destroy(&drv->devlist_mtx); 363 kfree(drv); 364 } 365 366 void wiphy_free(struct wiphy *wiphy) 367 { 368 put_device(&wiphy->dev); 369 } 370 EXPORT_SYMBOL(wiphy_free); 371 372 static int cfg80211_netdev_notifier_call(struct notifier_block * nb, 373 unsigned long state, 374 void *ndev) 375 { 376 struct net_device *dev = ndev; 377 struct cfg80211_registered_device *rdev; 378 379 if (!dev->ieee80211_ptr) 380 return 0; 381 382 rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy); 383 384 WARN_ON(dev->ieee80211_ptr->iftype == NL80211_IFTYPE_UNSPECIFIED); 385 386 switch (state) { 387 case NETDEV_REGISTER: 388 mutex_lock(&rdev->devlist_mtx); 389 list_add(&dev->ieee80211_ptr->list, &rdev->netdev_list); 390 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj, 391 "phy80211")) { 392 printk(KERN_ERR "wireless: failed to add phy80211 " 393 "symlink to netdev!\n"); 394 } 395 dev->ieee80211_ptr->netdev = dev; 396 mutex_unlock(&rdev->devlist_mtx); 397 break; 398 case NETDEV_UNREGISTER: 399 mutex_lock(&rdev->devlist_mtx); 400 if (!list_empty(&dev->ieee80211_ptr->list)) { 401 sysfs_remove_link(&dev->dev.kobj, "phy80211"); 402 list_del_init(&dev->ieee80211_ptr->list); 403 } 404 mutex_unlock(&rdev->devlist_mtx); 405 break; 406 } 407 408 return 0; 409 } 410 411 static struct notifier_block cfg80211_netdev_notifier = { 412 .notifier_call = cfg80211_netdev_notifier_call, 413 }; 414 415 static int cfg80211_init(void) 416 { 417 int err; 418 419 err = wiphy_sysfs_init(); 420 if (err) 421 goto out_fail_sysfs; 422 423 err = register_netdevice_notifier(&cfg80211_netdev_notifier); 424 if (err) 425 goto out_fail_notifier; 426 427 err = nl80211_init(); 428 if (err) 429 goto out_fail_nl80211; 430 431 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL); 432 433 err = regulatory_init(); 434 if (err) 435 goto out_fail_reg; 436 437 return 0; 438 439 out_fail_reg: 440 debugfs_remove(ieee80211_debugfs_dir); 441 out_fail_nl80211: 442 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 443 out_fail_notifier: 444 wiphy_sysfs_exit(); 445 out_fail_sysfs: 446 return err; 447 } 448 449 subsys_initcall(cfg80211_init); 450 451 static void cfg80211_exit(void) 452 { 453 debugfs_remove(ieee80211_debugfs_dir); 454 nl80211_exit(); 455 unregister_netdevice_notifier(&cfg80211_netdev_notifier); 456 wiphy_sysfs_exit(); 457 regulatory_exit(); 458 } 459 module_exit(cfg80211_exit); 460